diff --git a/.comfyignore b/.comfyignore new file mode 100644 index 0000000..d7af0d4 --- /dev/null +++ b/.comfyignore @@ -0,0 +1,10 @@ +# Excluded from the ComfyUI Registry archive (not from git). +demo_images/ +notebooks/ +docs/ +screenshot1.ply +__pycache__/ +models/ +.github/ +Makefile +install.sh diff --git a/.github/workflows/publish_action.yml b/.github/workflows/publish_action.yml new file mode 100644 index 0000000..d420820 --- /dev/null +++ b/.github/workflows/publish_action.yml @@ -0,0 +1,28 @@ +name: Publish to Comfy registry +on: + workflow_dispatch: + push: + branches: + - main + paths: + - "pyproject.toml" + +permissions: + contents: read + +jobs: + publish-node: + name: Publish Custom Node to registry + runs-on: ubuntu-latest + if: ${{ github.repository_owner == 'Alexankharin' }} + steps: + - name: Check out code + uses: actions/checkout@v4 + with: + # The SHARP submodule must be materialized so [tool.comfy].includes + # can pack it into the published archive. + submodules: recursive + - name: Publish Custom Node + uses: Comfy-Org/publish-node-action@main + with: + personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }} diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..b3dcbf7 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "submodules/ml-sharpt"] + path = submodules/ml-sharpt + url = https://github.com/apple/ml-sharp diff --git a/GS4D_nodes.py b/GS4D_nodes.py new file mode 100644 index 0000000..26603f3 --- /dev/null +++ b/GS4D_nodes.py @@ -0,0 +1,1227 @@ +"""4D (dynamic) Gaussian splat nodes for camera-comfyUI. + +Implements the ``GaussianSplats4D`` container (ComfyUI type string "GSPLAT4D") +plus nodes to build, render, save and load dynamic splat scenes: + +- MotionMaskFromDepth: geometric motion segmentation from a depth sequence. +- EstimateTracks: CoTracker3 point tracking (lazy torch.hub load). +- TracksToTrajectories: lift 2D tracks + depth to 3D world trajectories. +- SplitSplatsByMask: split a splat cloud into inside/outside a 2D mask. +- BuildSplats4D: bind canonical splats to track control points (kNN blend). +- RenderSplats4DFrame / RenderSplats4DVideo: render at a time / over a path. +- SaveSplats4D / LoadSplats4D: .npz persistence. + +Conventions match the rest of the repo: camera frame is +X right, +Y down, ++Z forward; pose matrices are 4x4 WORLD-TO-CAMERA acting on row vectors as +``cam = world @ R.T + t``; depth maps store RADIAL distance (Euclidean norm of +the camera-frame point), matching pointcloud_nodes' depth_to_XYZ helpers. +""" + +import math +import os +import hashlib +from dataclasses import dataclass +from typing import Any, Dict, List, Optional, Tuple + +import numpy as np +import torch +import torch.nn.functional as F +from tqdm import tqdm + +try: + import folder_paths +except ImportError: # Allow notebook usage outside ComfyUI + class _FolderPathsStub: + def __getattr__(self, name): + raise ModuleNotFoundError( + "folder_paths is unavailable; SaveSplats4D/LoadSplats4D require the ComfyUI runtime." + ) + + folder_paths = _FolderPathsStub() + +try: + from . import GS_nodes as _gs_nodes +except Exception: + import GS_nodes as _gs_nodes + +GaussianSplats = _gs_nodes.GaussianSplats +_concat_splats = _gs_nodes._concat_splats +_match_sh_orders = _gs_nodes._match_sh_orders +splat_cloud_rotation = _gs_nodes.splat_cloud_rotation +_stitch_splats = _gs_nodes._stitch_splats +_write_ply_splats = _gs_nodes._write_ply_splats +_resolve_device_choice = _gs_nodes._resolve_device_choice +_xyz_to_pinhole = _gs_nodes._xyz_to_pinhole +_xyz_to_fisheye = _gs_nodes._xyz_to_fisheye +_xyz_to_equirect = _gs_nodes._xyz_to_equirect +DEVICE_CHOICES = _gs_nodes.DEVICE_CHOICES + + +class Projection: + PROJECTIONS = ["PINHOLE", "FISHEYE", "EQUIRECTANGULAR"] + + +RENDER_MODES_4D = ["auto", "gsplat", "fast", "over"] + + +# --------------------------------------------------------------------------- # +# Lazy accessors for helpers written by concurrent work packages (contracts). # +# --------------------------------------------------------------------------- # + +def _render_gaussians(*args, **kwargs) -> tuple: + """Resolve GS_nodes.render_gaussians (contract C2) at call time. + + Returns (image [1,H,W,3] float 0..1, alpha/mask [H,W], disparity [1,H,W,1]). + """ + fn = getattr(_gs_nodes, "render_gaussians", None) + if fn is None: + raise RuntimeError( + "GS_nodes.render_gaussians is unavailable. The 4D splat nodes require the shared " + "render_gaussians helper in GS_nodes.py — please update camera-comfyUI to a version " + "that includes it." + ) + return fn(*args, **kwargs) + + +_POINTCLOUD_MODULE = None + + +def _interpolate_se3(trajectory: torch.Tensor, num_steps: int) -> torch.Tensor: + """Resolve pointcloud_nodes.interpolate_se3 (contract C1) at call time.""" + global _POINTCLOUD_MODULE + if _POINTCLOUD_MODULE is None: + try: + from . import pointcloud_nodes as _pc + except Exception: + try: + import pointcloud_nodes as _pc + except Exception as exc: + raise RuntimeError( + f"pointcloud_nodes could not be imported (needed for interpolate_se3): {exc}" + ) from exc + _POINTCLOUD_MODULE = _pc + fn = getattr(_POINTCLOUD_MODULE, "interpolate_se3", None) + if fn is None: + raise RuntimeError( + "pointcloud_nodes.interpolate_se3 is unavailable — please update camera-comfyUI to a " + "version that includes it." + ) + return fn(trajectory, num_steps) + + +_COTRACKER_CACHE: Dict[str, Any] = {} + + +def _load_cotracker(device: torch.device): + """Load (and cache) the CoTracker3 offline model via torch.hub.""" + key = str(device) + model = _COTRACKER_CACHE.get(key) + if model is not None: + return model + try: + model = torch.hub.load("facebookresearch/co-tracker", "cotracker3_offline") + except Exception as exc: + raise RuntimeError( + "Failed to load CoTracker3 via torch.hub. The first run needs internet access to " + "download the facebookresearch/co-tracker repo and its checkpoint into the torch hub " + "cache. If this machine is offline, pre-populate the cache on a connected machine " + "with: python -c \"import torch; torch.hub.load('facebookresearch/co-tracker', " + f"'cotracker3_offline')\". Original error: {exc}" + ) from exc + model = model.to(device) + model.eval() + _COTRACKER_CACHE[key] = model + return model + + +# --------------------------------------------------------------------------- # +# Small math / coercion helpers. # +# --------------------------------------------------------------------------- # + +def _coerce_matrix4x4(matrix, device: torch.device) -> torch.Tensor: + if isinstance(matrix, torch.Tensor): + return matrix.to(device=device, dtype=torch.float32).view(4, 4) + return torch.tensor(matrix, device=device, dtype=torch.float32).view(4, 4) + + +def _coerce_trajectory(trajectory, device: torch.device) -> torch.Tensor: + """Coerce a tensor / nested list to [K,4,4] float32 on device.""" + if isinstance(trajectory, torch.Tensor): + traj = trajectory + else: + traj = torch.tensor(trajectory, dtype=torch.float32) + traj = traj.to(device=device, dtype=torch.float32) + if traj.dim() == 2: + traj = traj.unsqueeze(0) + if traj.dim() != 3 or traj.shape[-2:] != (4, 4): + raise ValueError(f"Expected trajectory of shape [K,4,4], got {tuple(traj.shape)}") + return traj + + +def _coerce_depth_seq(depth) -> torch.Tensor: + """Coerce depth input to [T,H,W] float32 (accepts [H,W], [T,H,W,1], [T,1,H,W]).""" + d = depth if isinstance(depth, torch.Tensor) else torch.tensor(depth, dtype=torch.float32) + d = d.float() + if d.dim() == 2: + d = d.unsqueeze(0) + if d.dim() == 4 and d.shape[-1] == 1: + d = d.squeeze(-1) + elif d.dim() == 4 and d.shape[1] == 1: + d = d.squeeze(1) + if d.dim() != 3: + raise ValueError(f"Expected depth sequence of shape [T,H,W], got {tuple(d.shape)}") + return d + + +def _uv_grid(height: int, width: int, device: torch.device) -> Tuple[torch.Tensor, torch.Tensor]: + """Normalized [-1,1] pixel-center grid matching pointcloud_nodes' linspace convention.""" + u = torch.linspace(-1.0, 1.0, width, device=device).unsqueeze(0).expand(height, width) + v = torch.linspace(-1.0, 1.0, height, device=device).unsqueeze(1).expand(height, width) + return u, v + + +def _uv_to_dirs(u: torch.Tensor, v: torch.Tensor, projection: str, horizontal_fov: float) -> torch.Tensor: + """Unit ray directions [...,3] in camera frame for normalized uv in [-1,1]. + + Inverse of GS_nodes' _xyz_to_pinhole/_xyz_to_fisheye/_xyz_to_equirect (which are what + render_gaussians uses), so unprojection and splat rendering stay self-consistent. + Multiply by RADIAL depth to obtain camera-frame points. + """ + fov_rad = math.radians(horizontal_fov) + if projection == "PINHOLE": + f = 1.0 / math.tan(fov_rad / 2.0) + dirs = torch.stack([u, v, torch.full_like(u, f)], dim=-1) + return dirs / dirs.norm(dim=-1, keepdim=True).clamp(min=1e-8) + if projection == "FISHEYE": + r = torch.sqrt(u * u + v * v).clamp(max=1.0) + theta = r * (fov_rad / 2.0) + phi = torch.atan2(v, u) + sin_t = torch.sin(theta) + return torch.stack([sin_t * torch.cos(phi), sin_t * torch.sin(phi), torch.cos(theta)], dim=-1) + if projection == "EQUIRECTANGULAR": + lon = u * (fov_rad / 2.0) + lat = v * (math.pi / 2.0) + cos_lat = torch.cos(lat) + return torch.stack([cos_lat * torch.sin(lon), torch.sin(lat), cos_lat * torch.cos(lon)], dim=-1) + raise ValueError(f"Unsupported projection: {projection}") + + +def _project_xyz( + X: torch.Tensor, Y: torch.Tensor, Z: torch.Tensor, projection: str, horizontal_fov: float +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Camera-frame XYZ -> normalized uv in [-1,1] + radial depth (GS_nodes convention).""" + if projection == "PINHOLE": + return _xyz_to_pinhole(X, Y, Z, horizontal_fov) + if projection == "FISHEYE": + return _xyz_to_fisheye(X, Y, Z, horizontal_fov) + if projection == "EQUIRECTANGULAR": + return _xyz_to_equirect(X, Y, Z, horizontal_fov) + raise ValueError(f"Unsupported projection: {projection}") + + +def _projection_valid( + u: torch.Tensor, v: torch.Tensor, Z: torch.Tensor, projection: str +) -> torch.Tensor: + """In-image validity for projected points; pinhole additionally requires Z>0.""" + valid = ( + torch.isfinite(u) + & torch.isfinite(v) + & (u >= -1.0) + & (u <= 1.0) + & (v >= -1.0) + & (v <= 1.0) + ) + if projection == "PINHOLE": + valid = valid & (Z > 1e-6) + return valid + + +def _quat_slerp(q0: torch.Tensor, q1: torch.Tensor, w: float) -> torch.Tensor: + """Batched quaternion SLERP between [N,4] wxyz quats with scalar blend w in [0,1].""" + q0 = q0 / q0.norm(dim=-1, keepdim=True).clamp(min=1e-8) + q1 = q1 / q1.norm(dim=-1, keepdim=True).clamp(min=1e-8) + dot = (q0 * q1).sum(dim=-1, keepdim=True) + q1 = torch.where(dot < 0.0, -q1, q1) + dot = dot.abs().clamp(max=1.0 - 1e-7) + theta = torch.acos(dot) + sin_theta = torch.sin(theta) + near = sin_theta < 1e-5 + safe_sin = sin_theta.clamp(min=1e-12) + w0 = torch.where(near, torch.full_like(theta, 1.0 - w), torch.sin((1.0 - w) * theta) / safe_sin) + w1 = torch.where(near, torch.full_like(theta, w), torch.sin(w * theta) / safe_sin) + out = w0 * q0 + w1 * q1 + return out / out.norm(dim=-1, keepdim=True).clamp(min=1e-8) + + +def _median_filter_time(traj: torch.Tensor, kernel: int = 3) -> torch.Tensor: + """Median-filter [T,...] over the time axis with replicate padding (kills depth spikes).""" + T = traj.shape[0] + if T < 3 or kernel < 3: + return traj + pad = kernel // 2 + first = traj[:1].expand(pad, *traj.shape[1:]) + last = traj[-1:].expand(pad, *traj.shape[1:]) + padded = torch.cat([first, traj, last], dim=0) + windows = padded.unfold(0, kernel, 1) # [T, ..., kernel] + return windows.median(dim=-1).values + + +def _fill_invalid_linear(traj: torch.Tensor, valid: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + """Fill invalid timesteps of [T,M,3] trajectories by linear interp over time (hold ends). + + Fully vectorized (sort + searchsorted + gather): a per-track Python loop with + np.interp would serialize M GPU syncs / host round-trips and stall for + seconds-to-minutes at realistic track counts (grid_size 100-200). + + Returns (filled [T,M,3], track_ok [M] float — 0.0 for tracks with no valid sample). + """ + T, M = valid.shape + device = traj.device + dtype = traj.dtype + n_valid = valid.sum(dim=0) # [M] + track_ok = (n_valid > 0).to(dtype) + if M == 0 or bool((n_valid == T).all()): + return traj.clone(), track_ok + + # Sort each track's valid timesteps to the front (invalid -> sentinel T). + tt = torch.arange(T, device=device).unsqueeze(1).expand(T, M) + key = torch.where(valid, tt, torch.full_like(tt, T)) # [T,M] + key_sorted, perm = key.sort(dim=0) # valid times ascending, sentinels last + vals_sorted = torch.gather(traj, 0, perm.unsqueeze(-1).expand(T, M, 3)) # [T,M,3] + + ks = key_sorted.transpose(0, 1).contiguous() # [M,T] + q = tt.transpose(0, 1).contiguous() # [M,T] query times 0..T-1 per track + # First valid-time index >= t per (track, time); clamp into the valid range + # so out-of-range queries hold the first/last valid sample (np.interp-style). + pos = torch.searchsorted(ks, q) # [M,T] + n_ix = (n_valid - 1).clamp(min=0).unsqueeze(1) # [M,1] + i1 = torch.minimum(pos.clamp(max=T - 1), n_ix) + i0 = torch.minimum((pos - 1).clamp(min=0), n_ix) + + vals_mt = vals_sorted.permute(1, 0, 2) # [M,T,3] + t0 = torch.gather(ks, 1, i0).to(dtype) + t1 = torch.gather(ks, 1, i1).to(dtype) + v0 = torch.gather(vals_mt, 1, i0.unsqueeze(-1).expand(M, T, 3)) + v1 = torch.gather(vals_mt, 1, i1.unsqueeze(-1).expand(M, T, 3)) + denom = t1 - t0 + w = torch.where(denom > 0, (q.to(dtype) - t0) / denom.clamp(min=1e-12), torch.zeros_like(denom)) + w = w.clamp(0.0, 1.0) + filled = (v0 + w.unsqueeze(-1) * (v1 - v0)).transpose(0, 1) # [T,M,3] + + # Keep original samples at valid timesteps; zero tracks with no valid sample. + out = torch.where(valid.unsqueeze(-1), traj, filled) + out = torch.where((n_valid > 0).view(1, M, 1), out, torch.zeros_like(out)) + return out, track_ok + + +# --------------------------------------------------------------------------- # +# Contract C3: the 4D splat container. # +# --------------------------------------------------------------------------- # + +@dataclass +class GaussianSplats4D: + """Dynamic Gaussian splat scene (ComfyUI type "GSPLAT4D"). + + static: time-invariant splats in world frame (may be None). + canonical: N dynamic splats at the reference time (world frame). + trajectories: [T, N, 3] absolute world xyz per timestep. + times: [T] float, monotonically increasing, normalized 0..1. + rotations: optional [T, N, 4] wxyz quats (None -> use canonical rotations). + """ + + static: Optional[GaussianSplats] + canonical: GaussianSplats + trajectories: torch.Tensor + times: torch.Tensor + rotations: Optional[torch.Tensor] = None + + def to(self, device: torch.device) -> "GaussianSplats4D": + return GaussianSplats4D( + static=self.static.to(device) if self.static is not None else None, + canonical=self.canonical.to(device), + trajectories=self.trajectories.to(device), + times=self.times.to(device), + rotations=self.rotations.to(device) if self.rotations is not None else None, + ) + + def at_time(self, t: float) -> GaussianSplats: + """Evaluate the scene at time t (clamped to [times[0], times[-1]]). + + Linear interpolation of xyz (SLERP for rotations if present) between the + bracketing timesteps, substituted into a clone of the canonical splats and + concatenated with the static splats. + """ + times = self.times.reshape(-1).float() + T = int(times.shape[0]) + if self.trajectories.shape[0] != T: + raise ValueError( + f"trajectories has {self.trajectories.shape[0]} timesteps but times has {T}" + ) + dyn = self.canonical.clone() + if T == 1: + xyz = self.trajectories[0] + rot = self.rotations[0] if self.rotations is not None else None + else: + t_clamped = min(max(float(t), float(times[0])), float(times[-1])) + probe = torch.tensor(t_clamped, dtype=times.dtype, device=times.device) + hi = int(torch.searchsorted(times, probe, right=True).item()) + hi = min(max(hi, 1), T - 1) + lo = hi - 1 + t0 = float(times[lo]) + t1 = float(times[hi]) + w = 0.0 if t1 <= t0 else (t_clamped - t0) / (t1 - t0) + xyz = (1.0 - w) * self.trajectories[lo] + w * self.trajectories[hi] + if self.rotations is not None: + rot = _quat_slerp(self.rotations[lo], self.rotations[hi], w) + else: + rot = None + dyn.xyz = xyz.to(device=dyn.xyz.device, dtype=dyn.xyz.dtype) + if rot is not None: + dyn.rotation = rot.to(device=dyn.rotation.device, dtype=dyn.rotation.dtype) + if self.static is not None and len(self.static) > 0: + static = self.static + if static.xyz.device != dyn.xyz.device: + static = static.to(dyn.xyz.device) + return _concat_splats([static, dyn]) + return dyn + + +# --------------------------------------------------------------------------- # +# npz (de)serialization helpers. # +# --------------------------------------------------------------------------- # + +def _pack_splats_npz(arrays: Dict[str, np.ndarray], prefix: str, splats: GaussianSplats) -> None: + arrays[f"{prefix}_xyz"] = splats.xyz.detach().cpu().float().numpy() + arrays[f"{prefix}_scale"] = splats.scale.detach().cpu().float().numpy() + arrays[f"{prefix}_rotation"] = splats.rotation.detach().cpu().float().numpy() + arrays[f"{prefix}_opacity"] = splats.opacity.detach().cpu().float().numpy() + arrays[f"{prefix}_f_dc"] = splats.f_dc.detach().cpu().float().numpy() + arrays[f"{prefix}_f_rest"] = splats.f_rest.detach().cpu().float().numpy() + arrays[f"{prefix}_sh_order"] = np.asarray(int(splats.sh_order)) + + +def _unpack_splats_npz(data, prefix: str) -> Optional[GaussianSplats]: + if f"{prefix}_xyz" not in data: + return None + return GaussianSplats( + xyz=torch.from_numpy(np.asarray(data[f"{prefix}_xyz"], dtype=np.float32)), + scale=torch.from_numpy(np.asarray(data[f"{prefix}_scale"], dtype=np.float32)), + rotation=torch.from_numpy(np.asarray(data[f"{prefix}_rotation"], dtype=np.float32)), + opacity=torch.from_numpy(np.asarray(data[f"{prefix}_opacity"], dtype=np.float32)), + f_dc=torch.from_numpy(np.asarray(data[f"{prefix}_f_dc"], dtype=np.float32)), + f_rest=torch.from_numpy(np.asarray(data[f"{prefix}_f_rest"], dtype=np.float32)), + sh_order=int(np.asarray(data[f"{prefix}_sh_order"])), + ) + + +# --------------------------------------------------------------------------- # +# Nodes. # +# --------------------------------------------------------------------------- # + +class MotionMaskFromDepth: + """Flags dynamic pixels by warping depth between frames and thresholding the residual.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "depth_seq": ("TENSOR", {"tooltip": "Depth sequence [T,H,W] (radial distance)."}), + "trajectory": ( + "TENSOR", + {"tooltip": "World-to-camera poses [T,4,4] (or [K,4,4]; interpolated to T)."}, + ), + "input_projection": (Projection.PROJECTIONS, {}), + "input_horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "threshold": ( + "FLOAT", + { + "default": 0.10, + "min": 0.0, + "max": 10.0, + "step": 0.01, + "tooltip": "Relative depth residual |d_proj - d_sampled|/d_sampled above which a pixel is dynamic.", + }, + ), + "frame_gap": ( + "INT", + {"default": 4, "min": 1, "max": 256, "tooltip": "Temporal gap for forward/backward reprojection checks."}, + ), + "dilate": ("INT", {"default": 2, "min": 0, "max": 64, "tooltip": "Dilation radius (pixels) of the dynamic mask."}), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("MASK",) + RETURN_NAMES = ("motion_mask",) + FUNCTION = "motion_mask" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Detects dynamic pixels from a depth+pose sequence (1.0 = moving)." + + @torch.no_grad() + def motion_mask( + self, + depth_seq: torch.Tensor, + trajectory: torch.Tensor, + input_projection: str, + input_horizontal_fov: float, + threshold: float = 0.10, + frame_gap: int = 4, + dilate: int = 2, + device: str = "auto", + ) -> Tuple[torch.Tensor]: + target_device = _resolve_device_choice(device) + depth = _coerce_depth_seq(depth_seq).to(target_device) + T, H, W = depth.shape + poses = _coerce_trajectory(trajectory, target_device) + if poses.shape[0] != T: + poses = _coerce_trajectory(_interpolate_se3(poses, T), target_device) + + u, v = _uv_grid(H, W, target_device) + dirs = _uv_to_dirs(u, v, input_projection, input_horizontal_fov) # [H,W,3] + gap = max(1, int(frame_gap)) + dynamic = torch.zeros((T, H, W), device=target_device) + + for t in tqdm(range(T), desc="MotionMaskFromDepth"): + depth_t = depth[t] + cam_pts = depth_t.unsqueeze(-1) * dirs # [H,W,3] + R_t = poses[t, :3, :3] + tr_t = poses[t, :3, 3] + # world = (cam - t) @ R (inverse of cam = world @ R.T + t) + world = (cam_pts - tr_t) @ R_t + has_depth = depth_t > 1e-6 + + flagged = torch.zeros((H, W), dtype=torch.bool, device=target_device) + for t2 in (t + gap, t - gap): + if t2 < 0 or t2 >= T: + continue + R2 = poses[t2, :3, :3] + tr2 = poses[t2, :3, 3] + cam2 = world @ R2.T + tr2 + X2, Y2, Z2 = cam2.unbind(-1) + u2, v2, d2 = _project_xyz(X2, Y2, Z2, input_projection, input_horizontal_fov) + valid = _projection_valid(u2, v2, Z2, input_projection) & has_depth + grid = torch.stack( + [u2.nan_to_num(0.0), v2.nan_to_num(0.0)], dim=-1 + ).view(1, H, W, 2) + sampled = F.grid_sample( + depth[t2].view(1, 1, H, W), + grid, + mode="nearest", + padding_mode="border", + align_corners=True, + ).view(H, W) + residual = (d2 - sampled).abs() / sampled.clamp(min=1e-6) + flagged |= valid & (sampled > 1e-6) & (residual > threshold) + dynamic[t] = flagged.float() + + if dilate > 0: + kernel = 2 * int(dilate) + 1 + dynamic = F.max_pool2d( + dynamic.unsqueeze(1), kernel_size=kernel, stride=1, padding=int(dilate) + ).squeeze(1) + return (dynamic,) + + +class EstimateTracks: + """Dense grid point tracking with CoTracker3 (offline model, loaded via torch.hub).""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "frames": ("IMAGE", {"tooltip": "Video frames [T,H,W,3] float 0..1."}), + "grid_size": ( + "INT", + {"default": 20, "min": 1, "max": 200, "tooltip": "Tracks a grid_size x grid_size point grid."}, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("TENSOR", "TENSOR") + RETURN_NAMES = ("tracks", "visibility") + FUNCTION = "estimate_tracks" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Runs CoTracker3 on a video; returns tracks [T,N,2] (pixels) and visibility [T,N]." + + @torch.no_grad() + def estimate_tracks( + self, + frames: torch.Tensor, + grid_size: int = 20, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor]: + target_device = _resolve_device_choice(device) + if frames.dim() != 4: + raise ValueError(f"Expected frames [T,H,W,3], got {tuple(frames.shape)}") + model = _load_cotracker(target_device) + + H, W = int(frames.shape[1]), int(frames.shape[2]) + video = frames[..., :3].permute(0, 3, 1, 2).float() # [T,3,H,W], source device (usually CPU) + # CoTracker3 internally resizes the clip to its interp_shape (~384x512) + # anyway, so pre-resize BEFORE the device upload instead of shipping the + # full-resolution video to the GPU as one [1,T,3,H,W] tensor (~5GB for + # 200 frames at 1080p -> OOM before tracking starts). Track coordinates + # are scaled back to the input resolution afterwards. + interp = getattr(model, "interp_shape", (384, 512)) + interp_h, interp_w = int(interp[0]), int(interp[1]) + scale_x = scale_y = 1.0 + if H * W > interp_h * interp_w: + video = F.interpolate(video, size=(interp_h, interp_w), mode="bilinear", align_corners=False) + scale_x = float(W - 1) / float(max(interp_w - 1, 1)) + scale_y = float(H - 1) / float(max(interp_h - 1, 1)) + video = video.unsqueeze(0).to(target_device) + if video.max().item() <= 1.0: + video = video * 255.0 + + pred_tracks, pred_visibility = model(video, grid_size=int(grid_size)) + tracks = pred_tracks[0].float() # [T,N,2] pixel (x,y) + if scale_x != 1.0 or scale_y != 1.0: + tracks = tracks * torch.tensor([scale_x, scale_y], device=tracks.device, dtype=tracks.dtype) + visibility = pred_visibility[0].float() # [T,N] + if visibility.dim() == 3: + visibility = visibility.squeeze(-1) + return (tracks, visibility) + + +class TracksToTrajectories: + """Lifts 2D tracks + depth to 3D world-space trajectories.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "tracks": ("TENSOR", {"tooltip": "Pixel tracks [T,N,2] (x,y) from EstimateTracks."}), + "visibility": ("TENSOR", {"tooltip": "Track visibility [T,N] (0/1)."}), + "depth_seq": ("TENSOR", {"tooltip": "Depth sequence [T,H,W] (radial distance)."}), + "input_projection": (Projection.PROJECTIONS, {}), + "input_horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "min_visible_frac": ( + "FLOAT", + { + "default": 0.5, + "min": 0.0, + "max": 1.0, + "step": 0.05, + "tooltip": "Drop tracks visible in fewer than this fraction of frames.", + }, + ), + }, + "optional": { + "trajectory": ( + "TENSOR", + {"tooltip": "World-to-camera poses [T,4,4]. Default: identity (static camera)."}, + ), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("TENSOR", "TENSOR") + RETURN_NAMES = ("trajectories3d", "track_valid") + FUNCTION = "tracks_to_trajectories" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Unprojects 2D tracks with depth and camera poses into world-space 3D trajectories [T,M,3]." + + @torch.no_grad() + def tracks_to_trajectories( + self, + tracks: torch.Tensor, + visibility: torch.Tensor, + depth_seq: torch.Tensor, + input_projection: str, + input_horizontal_fov: float, + min_visible_frac: float = 0.5, + trajectory: Optional[torch.Tensor] = None, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor]: + target_device = _resolve_device_choice(device) + tracks = tracks.to(target_device).float() + if tracks.dim() != 3 or tracks.shape[-1] != 2: + raise ValueError(f"Expected tracks [T,N,2], got {tuple(tracks.shape)}") + visibility = visibility.to(target_device).float() + if visibility.dim() == 3: + visibility = visibility.squeeze(-1) + depth = _coerce_depth_seq(depth_seq).to(target_device) + T, N = tracks.shape[:2] + if depth.shape[0] != T or visibility.shape != (T, N): + raise ValueError( + f"Shape mismatch: tracks [T={T},N={N}], visibility {tuple(visibility.shape)}, " + f"depth {tuple(depth.shape)}" + ) + H, W = depth.shape[1:] + + vis = visibility > 0.5 + frac = vis.float().mean(dim=0) + keep = frac >= float(min_visible_frac) + if not bool(keep.any()): + raise ValueError( + "No tracks meet min_visible_frac; lower the threshold or check the visibility input." + ) + tracks = tracks[:, keep] + vis = vis[:, keep] + M = tracks.shape[1] + + # Pixel -> normalized [-1,1] (align_corners=True convention). + u = 2.0 * tracks[..., 0] / max(W - 1, 1) - 1.0 + v = 2.0 * tracks[..., 1] / max(H - 1, 1) - 1.0 + + # Sample depth at track locations (nearest to avoid mixing fg/bg at edges). + grid = torch.stack([u, v], dim=-1).view(T, 1, M, 2) + d = F.grid_sample( + depth.view(T, 1, H, W), + grid, + mode="nearest", + padding_mode="border", + align_corners=True, + ).view(T, M) + + dirs = _uv_to_dirs(u, v, input_projection, input_horizontal_fov) # [T,M,3] + cam = d.unsqueeze(-1) * dirs + + if trajectory is None: + poses = torch.eye(4, device=target_device).unsqueeze(0).expand(T, 4, 4).contiguous() + else: + poses = _coerce_trajectory(trajectory, target_device) + if poses.shape[0] != T: + poses = _coerce_trajectory(_interpolate_se3(poses, T), target_device) + R = poses[:, :3, :3] + tr = poses[:, :3, 3] + # world = (cam - t) @ R per frame. + world = torch.bmm(cam - tr.unsqueeze(1), R) + + in_bounds = (u >= -1.0) & (u <= 1.0) & (v >= -1.0) & (v <= 1.0) + valid = vis & in_bounds & (d > 1e-6) & torch.isfinite(world).all(dim=-1) + world = torch.where(valid.unsqueeze(-1), world, torch.zeros_like(world)) + + filled, track_ok = _fill_invalid_linear(world, valid) + filled = _median_filter_time(filled, kernel=3) + return (filled, track_ok) + + +class SplitSplatsByMask: + """Splits splats into (inside, outside) by projecting centers into a 2D mask.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats": ("GSPLAT",), + "mask": ("MASK", {"tooltip": "Mask [H,W] (or [1,H,W]) in the camera view."}), + "projection": (Projection.PROJECTIONS, {}), + "horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.05}), + }, + "optional": { + "camera_matrix": ( + "MAT_4X4", + {"tooltip": "World-to-camera matrix of the mask's view. Default: identity (splats already in camera frame)."}, + ), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT", "GSPLAT") + RETURN_NAMES = ("inside_splats", "outside_splats") + FUNCTION = "split_splats" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Projects splat centers into a mask; returns splats inside vs outside. Splats behind the camera go to outside." + + @torch.no_grad() + def split_splats( + self, + splats: GaussianSplats, + mask: torch.Tensor, + projection: str, + horizontal_fov: float, + threshold: float = 0.5, + camera_matrix=None, + device: str = "auto", + ) -> Tuple[GaussianSplats, GaussianSplats]: + target_device = _resolve_device_choice(device) + if splats.xyz.device != target_device: + splats = splats.to(target_device) + + m = mask + if not isinstance(m, torch.Tensor): + m = torch.tensor(m, dtype=torch.float32) + m = m.to(target_device).float() + if m.dim() == 4: # [B,H,W,C] + m = m[0, ..., 0] + elif m.dim() == 3: # [B,H,W] + m = m[0] + if m.dim() != 2: + raise ValueError(f"Expected mask [H,W] or [1,H,W], got {tuple(mask.shape)}") + H, W = m.shape + + if camera_matrix is None: + M = torch.eye(4, device=target_device) + else: + M = _coerce_matrix4x4(camera_matrix, target_device) + R = M[:3, :3] + t = M[:3, 3] + cam = splats.xyz @ R.T + t + X, Y, Z = cam.unbind(-1) + u, v, _ = _project_xyz(X, Y, Z, projection, horizontal_fov) + valid = _projection_valid(u, v, Z, projection) + + inside = torch.zeros((cam.shape[0],), dtype=torch.bool, device=target_device) + if bool(valid.any()): + uv_u = u[valid] + uv_v = v[valid] + px = ((uv_u * 0.5 + 0.5) * (W - 1)).round().long().clamp(0, W - 1) + py = ((uv_v * 0.5 + 0.5) * (H - 1)).round().long().clamp(0, H - 1) + inside[valid] = m[py, px] > float(threshold) + return (splats[inside], splats[~inside]) + + +class BuildSplats4D: + """Binds canonical splats to 3D track control points via kNN linear blending.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "canonical": ("GSPLAT", {"tooltip": "Dynamic splats (world frame) at the reference timestep."}), + "trajectories3d": ("TENSOR", {"tooltip": "Control-point trajectories [T,M,3] in world space."}), + "reference_index": ( + "INT", + {"default": 0, "min": 0, "max": 100000, "tooltip": "Timestep the canonical splats correspond to."}, + ), + "knn": ("INT", {"default": 4, "min": 1, "max": 64, "tooltip": "Number of nearest control points per splat."}), + "rbf_gamma": ( + "FLOAT", + { + "default": 0.0, + "min": 0.0, + "max": 1000.0, + "step": 0.1, + "tooltip": "0 = inverse-distance weights; >0 = RBF weights exp(-gamma*d^2).", + }, + ), + }, + "optional": { + "static": ("GSPLAT", {"tooltip": "Time-invariant splats (world frame)."}), + "times": ("TENSOR", {"tooltip": "Timestamps [T], normalized 0..1. Default: linspace."}), + "track_valid": ("TENSOR", {"tooltip": "Per-track validity [M] from TracksToTrajectories."}), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT4D",) + RETURN_NAMES = ("splats4d",) + FUNCTION = "build_splats4d" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Builds a 4D splat scene: each canonical splat follows a kNN blend of track control-point motions." + + @torch.no_grad() + def build_splats4d( + self, + canonical: GaussianSplats, + trajectories3d: torch.Tensor, + reference_index: int = 0, + knn: int = 4, + rbf_gamma: float = 0.0, + static: Optional[GaussianSplats] = None, + times: Optional[torch.Tensor] = None, + track_valid: Optional[torch.Tensor] = None, + device: str = "auto", + ) -> Tuple[GaussianSplats4D]: + target_device = _resolve_device_choice(device) + if canonical.xyz.device != target_device: + canonical = canonical.to(target_device) + + traj = trajectories3d + if not isinstance(traj, torch.Tensor): + traj = torch.tensor(traj, dtype=torch.float32) + traj = traj.to(device=target_device, dtype=torch.float32) + if traj.dim() != 3 or traj.shape[-1] != 3: + raise ValueError(f"Expected trajectories3d [T,M,3], got {tuple(traj.shape)}") + + if track_valid is not None: + tv = track_valid + if not isinstance(tv, torch.Tensor): + tv = torch.tensor(tv) + tv = tv.to(target_device).reshape(-1) + if tv.shape[0] != traj.shape[1]: + raise ValueError( + f"track_valid has {tv.shape[0]} entries but trajectories3d has {traj.shape[1]} tracks" + ) + traj = traj[:, tv > 0.5] + + T, M = traj.shape[0], traj.shape[1] + if M == 0: + raise ValueError("No valid tracks remain after filtering; cannot build a 4D scene.") + + ref = int(min(max(int(reference_index), 0), T - 1)) + k = max(1, min(int(knn), M)) + ctrl_ref = traj[ref] # [M,3] + deltas = traj - ctrl_ref.unsqueeze(0) # [T,M,3] motion relative to reference + + N = len(canonical) + if N == 0: + raise ValueError("Canonical splats are empty.") + canon_xyz = canonical.xyz.to(torch.float32) + # The eager [T,N,3] trajectory tensor can be huge (2.4GB for 2M splats at + # T=100); keep it on the CPU so it does not pin VRAM for the lifetime of + # the GSPLAT4D object. at_time() only moves the interpolated [N,3] slice + # to the render device per frame. + trajectories = torch.empty((T, N, 3), device="cpu", dtype=torch.float32) + chunk = 16384 + for start in tqdm(range(0, N, chunk), desc="BuildSplats4D kNN binding"): + end = min(N, start + chunk) + xyz_c = canon_xyz[start:end] # [n,3] + dists = torch.cdist(xyz_c, ctrl_ref) # [n,M] + d_k, idx_k = torch.topk(dists, k, dim=1, largest=False) # [n,k] + if rbf_gamma > 0.0: + # Subtract the per-row min in the exponent (softmax-style) so weights + # never underflow to zero before normalization; the normalized result + # is mathematically identical. + sq = d_k * d_k + w = torch.exp(-float(rbf_gamma) * (sq - sq.min(dim=1, keepdim=True).values)) + else: + w = 1.0 / (d_k + 1e-8) + w = w / w.sum(dim=1, keepdim=True).clamp(min=1e-12) + delta_k = deltas[:, idx_k, :] # [T,n,k,3] + disp = torch.einsum("nk,tnkc->tnc", w, delta_k) # [T,n,3] + trajectories[:, start:end] = (xyz_c.unsqueeze(0) + disp).cpu() + + if times is None: + times_t = torch.linspace(0.0, 1.0, T, device=target_device) + else: + times_t = times if isinstance(times, torch.Tensor) else torch.tensor(times) + times_t = times_t.to(device=target_device, dtype=torch.float32).reshape(-1) + if times_t.shape[0] != T: + raise ValueError(f"times has {times_t.shape[0]} entries but trajectories3d has {T} timesteps") + + static_splats = None + if static is not None: + static_splats = static.to(target_device) if static.xyz.device != target_device else static + if static_splats.sh_order != canonical.sh_order: + # Harmonize SH orders now (zero-pad the lower-order cloud) so + # at_time's _concat_splats does not fail with "All splats must + # have the same SH order" at render/save time — e.g. an + # sh_order-3 static from LoadPlySplat with an sh_order-0 + # SHARP-derived canonical. + static_splats, canonical = _match_sh_orders(static_splats, canonical) + + splats4d = GaussianSplats4D( + static=static_splats, + canonical=canonical, + trajectories=trajectories, + times=times_t, + rotations=None, + ) + return (splats4d,) + + +class RenderSplats4DFrame: + """Renders a 4D splat scene at a single time value.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats4d": ("GSPLAT4D",), + "camera_matrix": ("MAT_4X4",), + "camera_projection": (Projection.PROJECTIONS, {}), + "camera_horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "time": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "output_width": ("INT", {"default": 512, "min": 8, "max": 16384}), + "output_height": ("INT", {"default": 512, "min": 8, "max": 16384}), + "render_mode": (RENDER_MODES_4D, {"default": "auto"}), + "max_splats": ("INT", {"default": 0, "min": 0, "max": 10000000, "tooltip": "0 = unlimited."}), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("IMAGE", "MASK", "TENSOR") + RETURN_NAMES = ("image", "mask", "disparity") + FUNCTION = "render_frame" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Evaluates the 4D scene at a time value and renders it from the given camera." + + @torch.no_grad() + def render_frame( + self, + splats4d: GaussianSplats4D, + camera_matrix, + camera_projection: str, + camera_horizontal_fov: float, + time: float = 0.0, + output_width: int = 512, + output_height: int = 512, + render_mode: str = "auto", + max_splats: int = 0, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + splats = splats4d.at_time(float(time)) + image, alpha, disparity = _render_gaussians( + splats, + camera_matrix, + camera_projection, + camera_horizontal_fov, + output_width, + output_height, + max_splats=max_splats, + render_mode=render_mode, + device=device, + ) + return (image, alpha, disparity) + + +class RenderSplats4DVideo: + """Renders a 4D splat scene along a camera path over a time range.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats4d": ("GSPLAT4D",), + "trajectory": ("TENSOR", {"tooltip": "Camera path [K,4,4] world-to-camera; interpolated to num_frames."}), + "num_frames": ("INT", {"default": 49, "min": 1, "max": 4096}), + "time_start": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "time_end": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}), + "camera_projection": (Projection.PROJECTIONS, {}), + "camera_horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "output_width": ("INT", {"default": 512, "min": 8, "max": 16384}), + "output_height": ("INT", {"default": 512, "min": 8, "max": 16384}), + "render_mode": (RENDER_MODES_4D, {"default": "auto"}), + }, + "optional": { + "max_splats": ("INT", {"default": 0, "min": 0, "max": 10000000, "tooltip": "0 = unlimited."}), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("IMAGE", "MASK", "TENSOR") + RETURN_NAMES = ("images", "masks", "disparity") + FUNCTION = "render_video" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Interpolates the camera path, sweeps time from time_start to time_end and renders each frame." + + @torch.no_grad() + def render_video( + self, + splats4d: GaussianSplats4D, + trajectory: torch.Tensor, + num_frames: int = 49, + time_start: float = 0.0, + time_end: float = 1.0, + camera_projection: str = "PINHOLE", + camera_horizontal_fov: float = 90.0, + output_width: int = 512, + output_height: int = 512, + render_mode: str = "auto", + max_splats: int = 0, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + num_frames = max(1, int(num_frames)) + poses = _coerce_trajectory(trajectory, torch.device("cpu")) + if poses.shape[0] != num_frames: + poses = _coerce_trajectory(_interpolate_se3(poses, num_frames), torch.device("cpu")) + if num_frames == 1: + time_values = [float(time_start)] + else: + time_values = torch.linspace(float(time_start), float(time_end), num_frames).tolist() + + images: List[torch.Tensor] = [] + masks: List[torch.Tensor] = [] + disparities: List[torch.Tensor] = [] + for i in tqdm(range(num_frames), desc="RenderSplats4DVideo"): + splats = splats4d.at_time(time_values[i]) + image, alpha, disparity = _render_gaussians( + splats, + poses[i], + camera_projection, + camera_horizontal_fov, + output_width, + output_height, + max_splats=max_splats, + render_mode=render_mode, + device=device, + ) + images.append(image.detach().cpu()) # [1,H,W,3] + masks.append(alpha.detach().cpu()) # [H,W] + disparities.append(disparity.detach().cpu()) # [1,H,W,1] + + images_out = torch.cat(images, dim=0) # [F,H,W,3] + masks_out = torch.stack(masks, dim=0) # [F,H,W] + disparity_out = torch.cat(disparities, dim=0) # [F,H,W,1] + return (images_out, masks_out, disparity_out) + + +class SaveSplats4D: + """Saves a 4D splat scene to the ComfyUI output directory as .npz.""" + + def __init__(self): + self.output_dir = folder_paths.get_output_directory() + self.type = "splat4d" + self.prefix_append = "" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats4d": ("GSPLAT4D",), + "filename_prefix": ( + "STRING", + { + "default": "ComfyUISplat4D", + "tooltip": "Prefix for the .npz file. You can include format-tokens like %date:yyyy-MM-dd%.", + }, + ), + "export_ply_frames": ( + "BOOLEAN", + {"default": False, "tooltip": "Also write one 3DGS .ply per timestep (evaluated via at_time)."}, + ), + }, + "hidden": {}, + } + + RETURN_TYPES = () + FUNCTION = "save_splats4d" + OUTPUT_NODE = True + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Saves the GSPLAT4D scene as an .npz archive (plus optional per-frame PLYs)." + + def save_splats4d( + self, + splats4d: GaussianSplats4D, + filename_prefix: str, + export_ply_frames: bool = False, + ): + filename_prefix += self.prefix_append + full_output_folder, filename, counter, subfolder, filename_prefix = \ + folder_paths.get_save_image_path( + filename_prefix, + self.output_dir, + 0, 0 + ) + os.makedirs(full_output_folder, exist_ok=True) + base_name = filename.replace("%batch_num%", "0") + npz_name = f"{base_name}_{counter:05}.npz" + npz_path = os.path.join(full_output_folder, npz_name) + + arrays: Dict[str, np.ndarray] = {} + _pack_splats_npz(arrays, "canonical", splats4d.canonical) + arrays["trajectories"] = splats4d.trajectories.detach().cpu().float().numpy() + arrays["times"] = splats4d.times.detach().cpu().float().reshape(-1).numpy() + if splats4d.rotations is not None: + arrays["rotations"] = splats4d.rotations.detach().cpu().float().numpy() + if splats4d.static is not None: + _pack_splats_npz(arrays, "static", splats4d.static) + np.savez_compressed(npz_path, **arrays) + + results = [{ + "filename": npz_name, + "subfolder": subfolder, + "type": self.type, + }] + if export_ply_frames: + times = splats4d.times.detach().cpu().float().reshape(-1) + for i in tqdm(range(times.shape[0]), desc="SaveSplats4D PLY frames"): + ply_name = f"{base_name}_{counter:05}_t{i:04}.ply" + _write_ply_splats( + os.path.join(full_output_folder, ply_name), + splats4d.at_time(float(times[i])), + ) + results.append({ + "filename": ply_name, + "subfolder": subfolder, + "type": self.type, + }) + counter += 1 + return {"ui": {"splats4d": results}} + + +class LoadSplats4D: + """Loads a 4D splat scene saved by SaveSplats4D from the ComfyUI input directory.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + input_dir = folder_paths.get_input_directory() + files = [ + f + for f in os.listdir(input_dir) + if os.path.isfile(os.path.join(input_dir, f)) and f.lower().endswith(".npz") + ] + return { + "required": { + "splat4d_file": ( + sorted(files), + { + "file_chooser": True, + "tooltip": "Select a Splats4D .npz archive from your input folder.", + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT4D",) + RETURN_NAMES = ("splats4d",) + FUNCTION = "load_splats4d" + CATEGORY = "Camera/GSplat4D" + DESCRIPTION = "Loads a GSPLAT4D scene from an .npz archive." + + def load_splats4d(self, splat4d_file: str, device: str = "auto"): + path = folder_paths.get_annotated_filepath(splat4d_file) + data = np.load(path) + canonical = _unpack_splats_npz(data, "canonical") + if canonical is None or "trajectories" not in data or "times" not in data: + raise ValueError( + f"{splat4d_file} is not a Splats4D archive (missing canonical_*/trajectories/times keys)." + ) + trajectories = torch.from_numpy(np.asarray(data["trajectories"], dtype=np.float32)) + times = torch.from_numpy(np.asarray(data["times"], dtype=np.float32)).reshape(-1) + rotations = None + if "rotations" in data: + rotations = torch.from_numpy(np.asarray(data["rotations"], dtype=np.float32)) + static = _unpack_splats_npz(data, "static") + + splats4d = GaussianSplats4D( + static=static, + canonical=canonical, + trajectories=trajectories, + times=times, + rotations=rotations, + ) + target_device = _resolve_device_choice(device) + if target_device != torch.device("cpu"): + splats4d = splats4d.to(target_device) + return (splats4d,) + + @classmethod + def IS_CHANGED(cls, splat4d_file: str, device: str = "auto"): + path = folder_paths.get_annotated_filepath(splat4d_file) + m = hashlib.sha256() + with open(path, "rb") as f: + m.update(f.read()) + return m.digest().hex() + + @classmethod + def VALIDATE_INPUTS(cls, splat4d_file: str, device: str = "auto"): + if not folder_paths.exists_annotated_filepath(splat4d_file): + return f"Invalid splat4d file: {splat4d_file}" + return True + + +NODE_CLASS_MAPPINGS = { + "MotionMaskFromDepth": MotionMaskFromDepth, + "EstimateTracks": EstimateTracks, + "TracksToTrajectories": TracksToTrajectories, + "SplitSplatsByMask": SplitSplatsByMask, + "BuildSplats4D": BuildSplats4D, + "RenderSplats4DFrame": RenderSplats4DFrame, + "RenderSplats4DVideo": RenderSplats4DVideo, + "SaveSplats4D": SaveSplats4D, + "LoadSplats4D": LoadSplats4D, +} diff --git a/GS_nodes.py b/GS_nodes.py new file mode 100644 index 0000000..98fd1f8 --- /dev/null +++ b/GS_nodes.py @@ -0,0 +1,2499 @@ +import math +import os +import sys +import ssl +import shutil +import logging +import hashlib +import urllib.request +from dataclasses import dataclass +from typing import Dict, Any, Tuple, List, Optional + +import numpy as np +import torch +import torch.nn.functional as F + +try: + import folder_paths +except ImportError: # Allow notebook usage outside ComfyUI + class _FolderPathsStub: + def __getattr__(self, name): + raise ModuleNotFoundError( + "folder_paths is unavailable; LoadPlySplat requires ComfyUI runtime." + ) + + folder_paths = _FolderPathsStub() + +try: + from .reprojection_nodes import ReprojectImage +except Exception: + try: + from reprojection_nodes import ReprojectImage + except Exception: + ReprojectImage = None + +_SHARP_AVAILABLE = False +_SHARP_IMPORT_ERROR: Optional[Exception] = None +_SHARP_DEFAULT_MODEL_URL = None +_SHARP_DEFAULT_CHECKPOINT_LABEL = "" +_SHARP_PREDICTOR_CACHE: Dict[Tuple[str, str], Any] = {} +try: + _sharp_root = os.path.join(os.path.dirname(__file__), "submodules", "ml-sharpt", "src") + if os.path.isdir(_sharp_root) and _sharp_root not in sys.path: + sys.path.append(_sharp_root) + + from sharp.models import PredictorParams, create_predictor + from sharp.cli.predict import predict_image as _sharp_predict_image + from sharp.cli.predict import DEFAULT_MODEL_URL as _SHARP_DEFAULT_MODEL_URL + from sharp.utils import color_space as _sharp_color_space + from sharp.utils.gaussians import convert_rgb_to_spherical_harmonics as _sharp_rgb_to_sh + + _SHARP_AVAILABLE = True +except Exception as exc: + _SHARP_IMPORT_ERROR = exc + + +class Projection: + PROJECTIONS = ["PINHOLE", "FISHEYE", "EQUIRECTANGULAR"] + +DEVICE_CHOICES = ["auto", "cpu", "cuda"] +RENDER_MODES = ["fast", "over"] +RENDER_MODES_ALL = ["auto", "gsplat", "fast", "over"] +FUSE_MODES = ["smart", "average", "discard", "keep"] + + +def _infer_sh_order(f_rest_channels: int) -> int: + if f_rest_channels == 0: + return 0 + if f_rest_channels % 3 != 0: + raise ValueError(f"f_rest channel count must be divisible by 3, got {f_rest_channels}") + per_channel = f_rest_channels // 3 + total = per_channel + 1 + order = int(round(math.sqrt(total) - 1)) + if (order + 1) ** 2 != total: + raise ValueError(f"Invalid f_rest channel count for SH: {f_rest_channels}") + if order > 3: + raise ValueError(f"SH order {order} is not supported (max 3)") + return order + + +def _resolve_device_choice(device_choice: str, fallback: Optional[torch.device] = None) -> torch.device: + if device_choice == "auto": + if fallback is not None: + return fallback + if torch.cuda.is_available(): + return torch.device("cuda") + return torch.device("cpu") + if device_choice == "cuda": + if not torch.cuda.is_available(): + raise ValueError("CUDA requested but not available.") + return torch.device("cuda") + return torch.device("cpu") + + +@dataclass +class GaussianSplats: + xyz: torch.Tensor + scale: torch.Tensor + rotation: torch.Tensor + opacity: torch.Tensor + f_dc: torch.Tensor + f_rest: torch.Tensor + sh_order: Optional[int] = None + + def __post_init__(self) -> None: + inferred = _infer_sh_order(self.f_rest.shape[1]) + if self.sh_order is None: + self.sh_order = inferred + elif self.sh_order != inferred: + raise ValueError(f"sh_order={self.sh_order} does not match f_rest size ({self.f_rest.shape[1]})") + + def to(self, device: torch.device) -> "GaussianSplats": + return GaussianSplats( + xyz=self.xyz.to(device), + scale=self.scale.to(device), + rotation=self.rotation.to(device), + opacity=self.opacity.to(device), + f_dc=self.f_dc.to(device), + f_rest=self.f_rest.to(device), + sh_order=self.sh_order, + ) + + def clone(self) -> "GaussianSplats": + return GaussianSplats( + xyz=self.xyz.clone(), + scale=self.scale.clone(), + rotation=self.rotation.clone(), + opacity=self.opacity.clone(), + f_dc=self.f_dc.clone(), + f_rest=self.f_rest.clone(), + sh_order=self.sh_order, + ) + + def __len__(self) -> int: + return int(self.xyz.shape[0]) + + def __getitem__(self, index) -> "GaussianSplats": + return self._select(index) + + def get_splat(self, index: int) -> "GaussianSplats": + return self._select(index) + + def sh_coeffs(self) -> torch.Tensor: + total = (self.sh_order + 1) ** 2 + expected_rest = (total - 1) * 3 + if self.f_rest.shape[1] != expected_rest: + raise ValueError(f"Expected f_rest with {expected_rest} channels, got {self.f_rest.shape[1]}") + coeffs = torch.cat([self.f_dc, self.f_rest], dim=1).view(-1, 3, total) + return coeffs + + def _select(self, index) -> "GaussianSplats": + def _slice(t: torch.Tensor) -> torch.Tensor: + out = t[index] + if isinstance(index, int): + return out.unsqueeze(0) + return out + + return GaussianSplats( + xyz=_slice(self.xyz), + scale=_slice(self.scale), + rotation=_slice(self.rotation), + opacity=_slice(self.opacity), + f_dc=_slice(self.f_dc), + f_rest=_slice(self.f_rest), + sh_order=self.sh_order, + ) + + +# Real SH constants used in 3DGS/instant-ngp style evaluation. +C0 = 0.28209479177387814 +C1 = 0.4886025119029199 +C2 = (1.0925484305920792, 0.31539156525252005, 0.5462742152960396) +C3 = (0.5900435899266435, 2.890611442640554, 0.4570457994644658, 0.3731763325901154, 1.445305721320277) + + +def _normalize_dirs(dirs: torch.Tensor) -> torch.Tensor: + return dirs / dirs.norm(dim=-1, keepdim=True).clamp(min=1e-8) + + +def _sh_basis_l1(dirs: torch.Tensor) -> torch.Tensor: + x, y, z = dirs.unbind(-1) + return torch.stack( + [ + -C1 * y, + C1 * z, + -C1 * x, + ], + dim=-1, + ) + + +def _sh_basis_l2(dirs: torch.Tensor) -> torch.Tensor: + x, y, z = dirs.unbind(-1) + x2 = x * x + y2 = y * y + z2 = z * z + xy = x * y + yz = y * z + xz = x * z + return torch.stack( + [ + C2[0] * xy, + -C2[0] * yz, + C2[1] * (3.0 * z2 - 1.0), + -C2[0] * xz, + C2[2] * (x2 - y2), + ], + dim=-1, + ) + + +def _sh_basis_l3(dirs: torch.Tensor) -> torch.Tensor: + x, y, z = dirs.unbind(-1) + x2 = x * x + y2 = y * y + z2 = z * z + return torch.stack( + [ + -C3[0] * y * (3.0 * x2 - y2), + C3[1] * x * y * z, + -C3[2] * y * (5.0 * z2 - 1.0), + C3[3] * z * (5.0 * z2 - 3.0), + -C3[2] * x * (5.0 * z2 - 1.0), + C3[4] * z * (x2 - y2), + -C3[0] * x * (x2 - 3.0 * y2), + ], + dim=-1, + ) + + +def _sh_basis(deg: int, dirs: torch.Tensor) -> torch.Tensor: + dirs = _normalize_dirs(dirs) + x, y, z = dirs.unbind(-1) + basis = [torch.full_like(x, C0)] + if deg >= 1: + basis.append(-C1 * y) + basis.append(C1 * z) + basis.append(-C1 * x) + if deg >= 2: + x2 = x * x + y2 = y * y + z2 = z * z + basis.append(C2[0] * x * y) + basis.append(-C2[0] * y * z) + basis.append(C2[1] * (3.0 * z2 - 1.0)) + basis.append(-C2[0] * x * z) + basis.append(C2[2] * (x2 - y2)) + if deg >= 3: + x2 = x * x + y2 = y * y + z2 = z * z + basis.append(-C3[0] * y * (3.0 * x2 - y2)) + basis.append(C3[1] * x * y * z) + basis.append(-C3[2] * y * (5.0 * z2 - 1.0)) + basis.append(C3[3] * z * (5.0 * z2 - 3.0)) + basis.append(-C3[2] * x * (5.0 * z2 - 1.0)) + basis.append(C3[4] * z * (x2 - y2)) + basis.append(-C3[0] * x * (x2 - 3.0 * y2)) + return torch.stack(basis, dim=-1) + + +def eval_sh(deg: int, sh: torch.Tensor, dirs: torch.Tensor) -> torch.Tensor: + if deg > 3: + raise ValueError(f"SH degree {deg} is not supported (max 3)") + basis = _sh_basis(deg, dirs) + return (sh * basis.unsqueeze(-2)).sum(dim=-1) + + +def _make_rotation_support(l: int) -> Tuple[torch.Tensor, torch.Tensor]: + n = 2 * l + 1 + gen = torch.Generator(device="cpu") + gen.manual_seed(1337 + l) + for _ in range(1000): + dirs = torch.randn((n, 3), generator=gen) + dirs = _normalize_dirs(dirs) + if l == 1: + A = _sh_basis_l1(dirs) + elif l == 2: + A = _sh_basis_l2(dirs) + else: + A = _sh_basis_l3(dirs) + A64 = A.double() + if torch.linalg.matrix_rank(A64) == n: + return dirs, torch.inverse(A64) + raise RuntimeError(f"Failed to build SH rotation support for l={l}") + + +_SH_ROT_DIRS = {} +_SH_ROT_AINV = {} +for _l in (1, 2, 3): + _dirs, _ainv = _make_rotation_support(_l) + _SH_ROT_DIRS[_l] = _dirs + _SH_ROT_AINV[_l] = _ainv + + +def _sh_rotation_matrix(l: int, rotation: torch.Tensor) -> torch.Tensor: + device = rotation.device + dtype = rotation.dtype + dirs = _SH_ROT_DIRS[l].to(device=device, dtype=dtype) + a_inv = _SH_ROT_AINV[l].to(device=device, dtype=dtype) + rot = rotation + dirs_rot = dirs @ rot + if l == 1: + B = _sh_basis_l1(dirs_rot) + elif l == 2: + B = _sh_basis_l2(dirs_rot) + else: + B = _sh_basis_l3(dirs_rot) + return a_inv @ B + + +def rotate_sh_coeffs(sh_coeffs: torch.Tensor, rotation: torch.Tensor) -> torch.Tensor: + total = sh_coeffs.shape[-1] + order = int(round(math.sqrt(total) - 1)) + if (order + 1) ** 2 != total: + raise ValueError(f"Invalid SH coefficient count: {total}") + return rotate_sh_coeffs_ordered(sh_coeffs, rotation, order) + + +def rotate_sh_coeffs_ordered(sh_coeffs: torch.Tensor, rotation: torch.Tensor, order: int) -> torch.Tensor: + expected = (order + 1) ** 2 + if sh_coeffs.shape[-1] != expected: + raise ValueError(f"Expected {expected} SH coefficients per channel, got {sh_coeffs.shape[-1]}") + if order == 0: + return sh_coeffs + parts = [sh_coeffs[..., 0:1]] + T1 = _sh_rotation_matrix(1, rotation) + parts.append(sh_coeffs[..., 1:4] @ T1.T) + if order >= 2: + T2 = _sh_rotation_matrix(2, rotation) + parts.append(sh_coeffs[..., 4:9] @ T2.T) + if order >= 3: + T3 = _sh_rotation_matrix(3, rotation) + parts.append(sh_coeffs[..., 9:16] @ T3.T) + return torch.cat(parts, dim=-1) + + +def _rotation_matrix_to_quaternion(rotation: torch.Tensor) -> torch.Tensor: + R = rotation + m00 = R[0, 0] + m11 = R[1, 1] + m22 = R[2, 2] + trace = m00 + m11 + m22 + if trace > 0.0: + s = torch.sqrt(trace + 1.0) * 2.0 + w = 0.25 * s + x = (R[2, 1] - R[1, 2]) / s + y = (R[0, 2] - R[2, 0]) / s + z = (R[1, 0] - R[0, 1]) / s + elif (m00 > m11) and (m00 > m22): + s = torch.sqrt(1.0 + m00 - m11 - m22) * 2.0 + w = (R[2, 1] - R[1, 2]) / s + x = 0.25 * s + y = (R[0, 1] + R[1, 0]) / s + z = (R[0, 2] + R[2, 0]) / s + elif m11 > m22: + s = torch.sqrt(1.0 + m11 - m00 - m22) * 2.0 + w = (R[0, 2] - R[2, 0]) / s + x = (R[0, 1] + R[1, 0]) / s + y = 0.25 * s + z = (R[1, 2] + R[2, 1]) / s + else: + s = torch.sqrt(1.0 + m22 - m00 - m11) * 2.0 + w = (R[1, 0] - R[0, 1]) / s + x = (R[0, 2] + R[2, 0]) / s + y = (R[1, 2] + R[2, 1]) / s + z = 0.25 * s + quat = torch.stack([w, x, y, z], dim=-1) + return quat / quat.norm() + + +def _quat_mul(q1: torch.Tensor, q2: torch.Tensor) -> torch.Tensor: + w1, x1, y1, z1 = q1.unbind(-1) + w2, x2, y2, z2 = q2.unbind(-1) + return torch.stack( + [ + w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2, + w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2, + w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2, + w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2, + ], + dim=-1, + ) + + +def splat_cloud_rotation(splats: GaussianSplats, transform_matrix: torch.Tensor) -> GaussianSplats: + device = splats.xyz.device + if isinstance(transform_matrix, torch.Tensor): + matrix = transform_matrix.to(device).view(4, 4).float() + else: + matrix = torch.tensor(transform_matrix, device=device, dtype=torch.float32).view(4, 4) + rotation = matrix[:3, :3] + translation = matrix[:3, 3] + coords = splats.xyz + coords = coords @ rotation.T + translation + quat_r = _rotation_matrix_to_quaternion(rotation) + rot = splats.rotation + rot = rot / rot.norm(dim=-1, keepdim=True).clamp(min=1e-8) + rot = _quat_mul(quat_r, rot) + coeffs = splats.sh_coeffs() + coeffs = rotate_sh_coeffs_ordered(coeffs, rotation, splats.sh_order) + f_dc = coeffs[:, :, 0] + rest = (splats.sh_order + 1) ** 2 - 1 + if rest == 0: + f_rest = torch.zeros((coeffs.shape[0], 0), device=coeffs.device, dtype=coeffs.dtype) + else: + f_rest = coeffs[:, :, 1:].reshape(coeffs.shape[0], rest * 3) + return GaussianSplats( + xyz=coords, + scale=splats.scale.clone(), + rotation=rot, + opacity=splats.opacity.clone(), + f_dc=f_dc, + f_rest=f_rest, + sh_order=splats.sh_order, + ) + + +def _xyz_to_pinhole(X: torch.Tensor, Y: torch.Tensor, Z: torch.Tensor, fov: float) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + fov_rad = math.radians(fov) + f = 1.0 / math.tan(fov_rad / 2.0) + depth = torch.sqrt(X * X + Y * Y + Z * Z) + u = (X / Z) * f + v = (Y / Z) * f + return u, v, depth + + +def _xyz_to_fisheye(X: torch.Tensor, Y: torch.Tensor, Z: torch.Tensor, fov: float) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + fov_rad = math.radians(fov) + depth = torch.sqrt(X * X + Y * Y + Z * Z) + theta = torch.acos(Z / depth.clamp(min=1e-8)) + phi = torch.atan2(Y, X) + r = theta / (fov_rad / 2.0) + u = r * torch.cos(phi) + v = r * torch.sin(phi) + return u, v, depth + + +def _xyz_to_equirect(X: torch.Tensor, Y: torch.Tensor, Z: torch.Tensor, fov: float) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + fov_rad = math.radians(fov) / 2.0 + depth = torch.sqrt(X * X + Y * Y + Z * Z) + lon = torch.atan2(X, Z) + lat = torch.asin(Y / depth.clamp(min=1e-8)) + u = lon / fov_rad + v = lat / (math.pi / 2.0) + return u, v, depth + + +PLY_TYPES = { + "char": np.int8, + "uchar": np.uint8, + "short": np.int16, + "ushort": np.uint16, + "int": np.int32, + "uint": np.uint32, + "float": np.float32, + "double": np.float64, +} + + +def _parse_ply_header(f) -> Tuple[str, int, List[Tuple[str, str]]]: + fmt = None + vertex_count = 0 + props: List[Tuple[str, str]] = [] + in_vertex = False + while True: + line = f.readline() + if not line: + raise ValueError("Unexpected EOF while reading PLY header") + text = line.decode("ascii", errors="ignore").strip() + if text.startswith("format "): + fmt = text.split()[1] + elif text.startswith("element "): + parts = text.split() + element = parts[1] + count = int(parts[2]) + in_vertex = element == "vertex" + if in_vertex: + vertex_count = count + elif text.startswith("property ") and in_vertex: + parts = text.split() + if parts[1] == "list": + continue + props.append((parts[2], parts[1])) + elif text == "end_header": + break + if fmt is None: + raise ValueError("PLY header missing format") + return fmt, vertex_count, props + + +def _read_ply_vertices(path: str) -> Dict[str, np.ndarray]: + with open(path, "rb") as f: + fmt, vertex_count, props = _parse_ply_header(f) + if fmt == "ascii": + rows = [] + for _ in range(vertex_count): + line = f.readline() + if not line: + break + rows.append([float(x) for x in line.decode("ascii", errors="ignore").strip().split()]) + data = np.asarray(rows, dtype=np.float32) + if data.shape[1] < len(props): + raise ValueError("PLY vertex data does not match header properties") + out = {} + for idx, (name, _) in enumerate(props): + out[name] = data[:, idx] + return out + if fmt != "binary_little_endian": + raise ValueError(f"Unsupported PLY format: {fmt}") + dtype = [(name, np.dtype(PLY_TYPES[ptype]).newbyteorder("<")) for name, ptype in props] + data = np.fromfile(f, dtype=np.dtype(dtype), count=vertex_count) + return {name: data[name] for name, _ in props} + + +def _extract_f_rest(data: Dict[str, np.ndarray]) -> Tuple[np.ndarray, int]: + keys = [k for k in data.keys() if k.startswith("f_rest_")] + if not keys: + return np.zeros((data["x"].shape[0], 0), dtype=np.float32), 0 + indices = sorted(int(k.split("_")[-1]) for k in keys) + if indices != list(range(len(indices))): + raise ValueError("f_rest indices must be contiguous starting at 0") + f_rest = np.stack([data[f"f_rest_{i}"] for i in indices], axis=1).astype(np.float32) + sh_order = _infer_sh_order(f_rest.shape[1]) + return f_rest, sh_order + + +def _ensure_sharp_available() -> None: + if not _SHARP_AVAILABLE: + raise ModuleNotFoundError( + f"ml-sharpt is unavailable. Ensure submodules/ml-sharpt is present and its dependencies are installed. " + f"Import error: {_SHARP_IMPORT_ERROR}" + ) + + +def _horizontal_fov_to_f_px(width: int, horizontal_fov: float) -> float: + if horizontal_fov <= 0.0 or horizontal_fov >= 179.0: + raise ValueError("horizontal_fov must be between 0 and 179 degrees.") + fov_rad = math.radians(horizontal_fov) + return (width / 2.0) / math.tan(fov_rad / 2.0) + + +def _tensor_image_to_numpy(image: torch.Tensor) -> np.ndarray: + img = image + if img.dim() == 4: + img = img[0] + if img.dim() == 3 and img.shape[-1] not in (3, 4) and img.shape[0] in (1, 3, 4): + img = img.permute(1, 2, 0) + if img.shape[-1] > 3: + img = img[..., :3] + img = img.detach().cpu().float() + if img.numel() == 0: + raise ValueError("Input image is empty.") + if img.max().item() <= 1.0: + img = img * 255.0 + img = img.clamp(0.0, 255.0).to(torch.uint8) + return img.numpy() + + +def _list_sharp_checkpoint_choices() -> List[str]: + input_dir = folder_paths.get_input_directory() + checkpoint_files = [ + f + for f in os.listdir(input_dir) + if os.path.isfile(os.path.join(input_dir, f)) and f.lower().endswith(".pt") + ] + return [_SHARP_DEFAULT_CHECKPOINT_LABEL] + sorted(checkpoint_files) + + +def _build_rotation_matrix(theta_deg: float, phi_deg: float) -> np.ndarray: + theta_rad = math.radians(theta_deg) + phi_rad = math.radians(phi_deg) + r_theta = np.array( + [ + [math.cos(phi_rad), 0.0, math.sin(phi_rad), 0.0], + [0.0, 1.0, 0.0, 0.0], + [-math.sin(phi_rad), 0.0, math.cos(phi_rad), 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + dtype=np.float32, + ) + r_phi = np.array( + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, math.cos(theta_rad), -math.sin(theta_rad), 0.0], + [0.0, math.sin(theta_rad), math.cos(theta_rad), 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + dtype=np.float32, + ) + return r_theta @ r_phi + + +def _concat_splats(splats_list: List[GaussianSplats]) -> GaussianSplats: + if not splats_list: + raise ValueError("No splats provided to merge.") + base = splats_list[0] + for splats in splats_list[1:]: + if splats.sh_order != base.sh_order or splats.f_rest.shape[1] != base.f_rest.shape[1]: + raise ValueError("All splats must have the same SH order to merge.") + return GaussianSplats( + xyz=torch.cat([s.xyz for s in splats_list], dim=0), + scale=torch.cat([s.scale for s in splats_list], dim=0), + rotation=torch.cat([s.rotation for s in splats_list], dim=0), + opacity=torch.cat([s.opacity for s in splats_list], dim=0), + f_dc=torch.cat([s.f_dc for s in splats_list], dim=0), + f_rest=torch.cat([s.f_rest for s in splats_list], dim=0), + sh_order=base.sh_order, + ) + + +def _pad_sh_order(splats: GaussianSplats, sh_order: int) -> GaussianSplats: + """Zero-pad a splat cloud's SH coefficients up to ``sh_order``. + + The SH decode used throughout this file (``sh_coeffs`` / ``eval_sh``) is + ``cat([f_dc, f_rest], dim=1).view(-1, 3, total)`` — channel-major over the + concatenated flat vector — so padding must reflow the existing + ``(3, total_old)`` coefficient rows into a zeroed ``(3, total_new)`` block + and re-flatten. Simply appending zeros to f_rest would shift the green/blue + DC terms into the red channel's l>=1 slots and corrupt colors. + """ + if splats.sh_order == sh_order: + return splats + if splats.sh_order > sh_order: + raise ValueError("Cannot reduce SH order by zero-padding.") + total_old = (splats.sh_order + 1) ** 2 + total_new = (sh_order + 1) ** 2 + n = splats.xyz.shape[0] + old = torch.cat([splats.f_dc, splats.f_rest], dim=1).view(n, 3, total_old) + coeffs = torch.zeros((n, 3, total_new), device=splats.f_dc.device, dtype=splats.f_dc.dtype) + coeffs[:, :, :total_old] = old + flat = coeffs.reshape(n, 3 * total_new) + return GaussianSplats( + xyz=splats.xyz, + scale=splats.scale, + rotation=splats.rotation, + opacity=splats.opacity, + f_dc=flat[:, :3], + f_rest=flat[:, 3:], + sh_order=sh_order, + ) + + +def _match_sh_orders(a: GaussianSplats, b: GaussianSplats) -> Tuple[GaussianSplats, GaussianSplats]: + """Bring two splat clouds to a common (max) SH order via zero padding.""" + order = max(a.sh_order, b.sh_order) + return _pad_sh_order(a, order), _pad_sh_order(b, order) + + +def _direction_bins(xyz: torch.Tensor, angle_deg: float) -> Tuple[torch.Tensor, int]: + if angle_deg <= 0.0: + raise ValueError("direction angle must be greater than 0 degrees.") + step = math.radians(angle_deg) + theta_bins = max(1, int(math.ceil(math.pi / step))) + phi_bins = max(1, int(math.ceil(2.0 * math.pi / step))) + dirs = xyz / xyz.norm(dim=1, keepdim=True).clamp(min=1e-8) + theta = torch.acos(dirs[:, 2].clamp(-1.0, 1.0)) + phi = torch.atan2(dirs[:, 1], dirs[:, 0]) + theta_bin = torch.floor(theta / step).to(torch.int64).clamp(min=0, max=theta_bins - 1) + phi_bin = torch.floor((phi + math.pi) / step).to(torch.int64).clamp(min=0, max=phi_bins - 1) + return theta_bin * phi_bins + phi_bin, phi_bins + + +def _filter_overlapping_by_fov( + other: GaussianSplats, + horizontal_fov: float, + padding_deg: float, +) -> GaussianSplats: + if len(other) == 0: + return other + if horizontal_fov <= 0.0 or horizontal_fov >= 179.0: + raise ValueError("horizontal_fov must be between 0 and 179 degrees.") + half_fov = math.radians(horizontal_fov) * 0.5 + if padding_deg != 0.0: + half_fov += math.radians(padding_deg) + max_half = math.radians(89.9) + half_fov = max(1e-6, min(half_fov, max_half)) + X, Y, Z = other.xyz.unbind(-1) + in_front = Z > 1e-6 + x_angle = torch.atan2(X, Z) + y_angle = torch.atan2(Y, Z) + in_square = (x_angle.abs() <= half_fov) & (y_angle.abs() <= half_fov) + keep = ~(in_front & in_square) + return other[keep] + + +def _stitch_splats( + splats_list: List[GaussianSplats], + mode: str, + voxel_size: float, + direction_deg: float, + pinhole_fov: Optional[float] = None, + weights_list: Optional[List[float]] = None, +) -> GaussianSplats: + """Merge multiple splat clouds, optionally reducing duplicates per voxel. + + weights_list: optional per-list weight multipliers (one float per entry of + splats_list) applied to the per-splat weights before the voxel reduction. + Only affects the "smart" and "average" modes; "keep", "discard" and + "main_direction" ignore it. + """ + if weights_list is not None and len(weights_list) != len(splats_list): + raise ValueError( + f"weights_list length ({len(weights_list)}) must match splats_list length ({len(splats_list)})." + ) + if mode == "main_direction": + if not splats_list: + raise ValueError("No splats provided to merge.") + if pinhole_fov is None: + raise ValueError("pinhole_fov is required for main_direction stitching.") + main = splats_list[0] + filtered = [main] + for splats in splats_list[1:]: + filtered.append(_filter_overlapping_by_fov(splats, pinhole_fov, direction_deg)) + return _concat_splats(filtered) + + merged = _concat_splats(splats_list) + if mode == "keep" or voxel_size <= 0.0 or len(merged) == 0: + return merged + + device = merged.xyz.device + dtype = merged.xyz.dtype + voxel = torch.floor(merged.xyz / float(voxel_size)).to(torch.int64) + unique, inv = torch.unique(voxel, dim=0, return_inverse=True) + num_voxels = unique.shape[0] + + if mode == "discard": + idx = torch.arange(len(merged), device=device, dtype=torch.long) + min_idx = torch.full((num_voxels,), len(merged), device=device, dtype=torch.long) + min_idx.scatter_reduce_(0, inv, idx, reduce="amin", include_self=True) + keep = idx == min_idx[inv] + return merged[keep] + + weights = torch.ones((len(merged),), device=device, dtype=dtype) + if mode == "smart": + opacity = torch.sigmoid(merged.opacity.squeeze(-1)) + sigma = torch.exp(merged.scale).mean(dim=1) + weights = opacity / sigma.clamp(min=1e-6) + if weights_list is not None: + multipliers = torch.cat( + [ + torch.full((len(s),), float(w), device=device, dtype=dtype) + for s, w in zip(splats_list, weights_list) + ] + ) + weights = weights * multipliers.clamp(min=0.0) + + sum_w = torch.zeros((num_voxels,), device=device, dtype=dtype) + sum_w.scatter_add_(0, inv, weights) + # Voxels whose total weight is ~0 (e.g. FuseSplats with weight 0.0 for one + # cloud, in voxels populated only by that cloud) would otherwise reduce to + # degenerate splats at the origin (all-zero weighted sums divided by the + # clamp); drop those voxels instead. + nonzero_voxel = sum_w > 1e-8 + sum_w = sum_w.clamp(min=1e-8) + + def _weighted_sum(values: torch.Tensor) -> torch.Tensor: + if values.numel() == 0: + return values.new_zeros((num_voxels, values.shape[1])) + out = torch.zeros((num_voxels, values.shape[1]), device=device, dtype=values.dtype) + out.scatter_add_(0, inv[:, None].expand(-1, values.shape[1]), values * weights[:, None]) + return out + + xyz = _weighted_sum(merged.xyz) / sum_w[:, None] + sigma = _weighted_sum(torch.exp(merged.scale)) / sum_w[:, None] + scale = torch.log(sigma.clamp(min=1e-9)) + + idx = torch.arange(len(merged), device=device, dtype=torch.long) + min_idx = torch.full((num_voxels,), len(merged), device=device, dtype=torch.long) + min_idx.scatter_reduce_(0, inv, idx, reduce="amin", include_self=True) + ref = merged.rotation[min_idx] + ref_per = ref[inv] + dot = (merged.rotation * ref_per).sum(dim=1, keepdim=True) + aligned = torch.where(dot < 0, -merged.rotation, merged.rotation) + rot_sum = _weighted_sum(aligned) + rotation = rot_sum / sum_w[:, None] + rotation = rotation / rotation.norm(dim=1, keepdim=True).clamp(min=1e-8) + + f_dc = _weighted_sum(merged.f_dc) / sum_w[:, None] + if merged.f_rest.shape[1] > 0: + f_rest = _weighted_sum(merged.f_rest) / sum_w[:, None] + else: + f_rest = merged.f_rest.new_zeros((num_voxels, 0)) + + opacity = torch.sigmoid(merged.opacity.squeeze(-1)) + opacity_sum = torch.zeros((num_voxels,), device=device, dtype=dtype) + opacity_sum.scatter_add_(0, inv, opacity * weights) + opacity_avg = (opacity_sum / sum_w).clamp(1e-6, 1.0 - 1e-6) + opacity_logits = torch.log(opacity_avg / (1.0 - opacity_avg)).view(-1, 1) + + out = GaussianSplats( + xyz=xyz, + scale=scale, + rotation=rotation, + opacity=opacity_logits, + f_dc=f_dc, + f_rest=f_rest, + sh_order=merged.sh_order, + ) + if not bool(nonzero_voxel.all()): + out = out[nonzero_voxel] + return out + + +def _get_sharp_default_checkpoint_path() -> Optional[str]: + if _SHARP_DEFAULT_MODEL_URL is None: + return None + filename = os.path.basename(_SHARP_DEFAULT_MODEL_URL) + cache_dir = os.path.join(torch.hub.get_dir(), "checkpoints") + return os.path.join(cache_dir, filename) + +def _download_sharp_checkpoint(url: str, destination: str) -> None: + os.makedirs(os.path.dirname(destination), exist_ok=True) + try: + torch.hub.download_url_to_file(url, destination, progress=True) + return + except Exception: + pass + + ctx = ssl._create_unverified_context() + try: + with urllib.request.urlopen(url, context=ctx) as response, open(destination, "wb") as f: + shutil.copyfileobj(response, f) + except Exception as exc: + if os.path.isfile(destination): + try: + os.remove(destination) + except OSError: + pass + raise RuntimeError( + "Failed to download the SHARP checkpoint. If your environment blocks SSL downloads, " + "manually download the .pt file and select it from the input folder." + ) from exc + + +def _load_sharp_predictor( + checkpoint_path: Optional[str], + device: torch.device, +): + key = (checkpoint_path or "default", str(device)) + cached = _SHARP_PREDICTOR_CACHE.get(key) + if cached is not None: + return cached + + if checkpoint_path: + try: + state_dict = torch.load(checkpoint_path, weights_only=True) + except TypeError: + state_dict = torch.load(checkpoint_path) + else: + if _SHARP_DEFAULT_MODEL_URL is None: + raise RuntimeError("Default SHARP checkpoint URL is unavailable.") + cached_path = _get_sharp_default_checkpoint_path() + if cached_path is None: + raise RuntimeError("Default SHARP checkpoint cache location is unavailable.") + if not os.path.isfile(cached_path): + _download_sharp_checkpoint(_SHARP_DEFAULT_MODEL_URL, cached_path) + try: + state_dict = torch.load(cached_path, weights_only=True) + except TypeError: + state_dict = torch.load(cached_path) + + predictor = create_predictor(PredictorParams()) + predictor.load_state_dict(state_dict) + predictor.eval() + predictor.to(device) + _SHARP_PREDICTOR_CACHE[key] = predictor + return predictor + + +def _write_ply_splats(path: str, splats: GaussianSplats) -> None: + xyz = splats.xyz.detach().cpu().float().numpy() + scale = splats.scale.detach().cpu().float().numpy() + rotation = splats.rotation.detach().cpu().float().numpy() + opacity = splats.opacity.detach().cpu().float().reshape(-1).numpy() + f_dc = splats.f_dc.detach().cpu().float().numpy() + f_rest = splats.f_rest.detach().cpu().float().numpy() + + props: List[Tuple[str, np.ndarray]] = [ + ("x", xyz[:, 0]), + ("y", xyz[:, 1]), + ("z", xyz[:, 2]), + ("f_dc_0", f_dc[:, 0]), + ("f_dc_1", f_dc[:, 1]), + ("f_dc_2", f_dc[:, 2]), + ("opacity", opacity), + ("scale_0", scale[:, 0]), + ("scale_1", scale[:, 1]), + ("scale_2", scale[:, 2]), + ("rot_0", rotation[:, 0]), + ("rot_1", rotation[:, 1]), + ("rot_2", rotation[:, 2]), + ("rot_3", rotation[:, 3]), + ] + if f_rest.size > 0: + for i in range(f_rest.shape[1]): + props.append((f"f_rest_{i}", f_rest[:, i])) + + dtype = [(name, " GaussianSplats: + return GaussianSplats( + xyz=splats.xyz.to(device=device, dtype=dtype), + scale=splats.scale.to(device=device, dtype=dtype), + rotation=splats.rotation.to(device=device, dtype=dtype), + opacity=splats.opacity.to(device=device, dtype=dtype), + f_dc=splats.f_dc.to(device=device, dtype=dtype), + f_rest=splats.f_rest.to(device=device, dtype=dtype), + sh_order=splats.sh_order, + ) + + +def _progress(iterable, desc: str = ""): + """Wrap an iterable with tqdm if it is available, otherwise pass through.""" + try: + from tqdm import tqdm + + return tqdm(iterable, desc=desc) + except Exception: + return iterable + + +_GSPLAT_AVAILABLE_CACHE: Optional[bool] = None + + +def _gsplat_available() -> bool: + """Return True if the gsplat package is importable (checked once, cached).""" + global _GSPLAT_AVAILABLE_CACHE + if _GSPLAT_AVAILABLE_CACHE is None: + try: + import importlib.util + + _GSPLAT_AVAILABLE_CACHE = importlib.util.find_spec("gsplat") is not None + except Exception: + _GSPLAT_AVAILABLE_CACHE = False + return _GSPLAT_AVAILABLE_CACHE + + +def _import_gsplat(): + """Lazy-import gsplat with an actionable error message.""" + try: + import gsplat + except ImportError as exc: + raise RuntimeError( + "gsplat is required for render_mode='gsplat' and SplatPolish. " + "Install it with: pip install gsplat (requires a CUDA-enabled PyTorch build). " + f"Import error: {exc}" + ) from exc + return gsplat + + +def _quats_to_rotation_matrices(quats: torch.Tensor) -> torch.Tensor: + """Convert [N,4] wxyz quaternions to [N,3,3] rotation matrices.""" + q = quats / quats.norm(dim=-1, keepdim=True).clamp(min=1e-8) + w, x, y, z = q.unbind(-1) + return torch.stack( + [ + 1.0 - 2.0 * (y * y + z * z), 2.0 * (x * y - w * z), 2.0 * (x * z + w * y), + 2.0 * (x * y + w * z), 1.0 - 2.0 * (x * x + z * z), 2.0 * (y * z - w * x), + 2.0 * (x * z - w * y), 2.0 * (y * z + w * x), 1.0 - 2.0 * (x * x + y * y), + ], + dim=-1, + ).view(-1, 3, 3) + + +def _empty_render(output_width: int, output_height: int, device: torch.device) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Black image, zero alpha and zero disparity for views with no visible splats.""" + img = torch.zeros((1, output_height, output_width, 3), device=device) + mask = torch.zeros((output_height, output_width), device=device) + disparity = torch.zeros((1, output_height, output_width, 1), device=device) + return img, mask, disparity + + +def _ssim(img1: torch.Tensor, img2: torch.Tensor, window_size: int = 11, sigma: float = 1.5) -> torch.Tensor: + """Mean SSIM of two [B,C,H,W] images with values in [0,1].""" + channels = img1.shape[1] + coords = torch.arange(window_size, dtype=img1.dtype, device=img1.device) - (window_size - 1) / 2.0 + g = torch.exp(-(coords * coords) / (2.0 * sigma * sigma)) + g = g / g.sum() + window = (g[:, None] @ g[None, :]).expand(channels, 1, window_size, window_size).contiguous() + pad = window_size // 2 + mu1 = F.conv2d(img1, window, padding=pad, groups=channels) + mu2 = F.conv2d(img2, window, padding=pad, groups=channels) + mu1_sq = mu1 * mu1 + mu2_sq = mu2 * mu2 + mu12 = mu1 * mu2 + sigma1_sq = F.conv2d(img1 * img1, window, padding=pad, groups=channels) - mu1_sq + sigma2_sq = F.conv2d(img2 * img2, window, padding=pad, groups=channels) - mu2_sq + sigma12 = F.conv2d(img1 * img2, window, padding=pad, groups=channels) - mu12 + c1 = 0.01 ** 2 + c2 = 0.03 ** 2 + ssim_map = ((2.0 * mu12 + c1) * (2.0 * sigma12 + c2)) / ( + (mu1_sq + mu2_sq + c1) * (sigma1_sq + sigma2_sq + c2) + ) + return ssim_map.mean() + + +def _coerce_trajectory(trajectory, num_frames: int, device: torch.device) -> torch.Tensor: + """Coerce a trajectory input to a [num_frames,4,4] float tensor on device. + + Accepts [4,4] (broadcast to all frames), [1,4,4] or [num_frames,4,4]. + """ + if isinstance(trajectory, torch.Tensor): + traj = trajectory.detach().float() + else: + traj = torch.tensor(trajectory, dtype=torch.float32) + if traj.dim() == 2: + traj = traj.unsqueeze(0) + if traj.dim() != 3 or traj.shape[-2:] != (4, 4): + raise ValueError(f"trajectory must be [T,4,4], got shape {tuple(traj.shape)}") + if traj.shape[0] == 1 and num_frames > 1: + traj = traj.expand(num_frames, 4, 4) + if traj.shape[0] != num_frames: + raise ValueError( + f"trajectory has {traj.shape[0]} poses but {num_frames} frames were provided." + ) + return traj.to(device) + + +def _normalize_map_sequence(seq, num_frames: int, name: str) -> torch.Tensor: + """Coerce a per-frame map (depth/mask) input to [T,H,W] float ([1,H,W] broadcasts).""" + if not isinstance(seq, torch.Tensor): + seq = torch.tensor(seq, dtype=torch.float32) + seq = seq.float() + if seq.dim() == 4 and seq.shape[-1] == 1: + seq = seq[..., 0] + if seq.dim() == 2: + seq = seq.unsqueeze(0) + if seq.dim() != 3: + raise ValueError(f"{name} must be [T,H,W] (or [H,W]), got shape {tuple(seq.shape)}") + if seq.shape[0] not in (1, num_frames): + raise ValueError( + f"{name} has {seq.shape[0]} frames but the video has {num_frames}." + ) + return seq + + +def _project_splats_to_pixels( + xyz_cam: torch.Tensor, + horizontal_fov: float, + width: int, + height: int, +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Project camera-frame splat centers to pixel coordinates of the source pinhole image. + + Uses the same focal convention as SHARP/ImageToSplat (single f_px from the + horizontal FOV over the width). Returns (px, py, z, in_bounds). + """ + f_px = _horizontal_fov_to_f_px(width, horizontal_fov) + X, Y, Z = xyz_cam.unbind(-1) + zc = Z.clamp(min=1e-6) + px = X / zc * f_px + (width - 1) / 2.0 + py = Y / zc * f_px + (height - 1) / 2.0 + in_bounds = (Z > 1e-6) & (px >= 0.0) & (px <= width - 1) & (py >= 0.0) & (py <= height - 1) + return px, py, Z, in_bounds + + +def _sample_map_at_pixels( + map_hw: torch.Tensor, + px: torch.Tensor, + py: torch.Tensor, + width: int, + height: int, +) -> torch.Tensor: + """Nearest-neighbour sample a [Hm,Wm] map at pixel coords defined on a width x height image.""" + map_h, map_w = int(map_hw.shape[0]), int(map_hw.shape[1]) + if map_w == width and map_h == height: + xi = px.round().long().clamp(0, map_w - 1) + yi = py.round().long().clamp(0, map_h - 1) + else: + xi = (px / max(width - 1, 1) * (map_w - 1)).round().long().clamp(0, map_w - 1) + yi = (py / max(height - 1, 1) * (map_h - 1)).round().long().clamp(0, map_h - 1) + return map_hw[yi, xi] + + +def _render_gaussians_gsplat( + splats: GaussianSplats, + view_matrix: torch.Tensor, + camera_horizontal_fov: float, + output_width: int, + output_height: int, + max_splats: int, + opacity_is_logit: bool, + add_sh_bias: bool, +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """CUDA gsplat rasterization backend (PINHOLE only). Returns (image, alpha, disparity).""" + gsplat = _import_gsplat() + dev = splats.xyz.device + if dev.type != "cuda": + raise RuntimeError( + "render_mode='gsplat' requires CUDA tensors. Set device='cuda' " + "(or 'auto' on a CUDA machine), or use render_mode='fast'." + ) + if len(splats) == 0: + return _empty_render(output_width, output_height, dev) + + means = splats.xyz.float() + quats = splats.rotation.float() + quats = quats / quats.norm(dim=-1, keepdim=True).clamp(min=1e-8) + scales = torch.exp(splats.scale.float()) + opacity = splats.opacity.float().view(-1) + if opacity_is_logit: + opacity = torch.sigmoid(opacity) + else: + opacity = opacity.clamp(0.0, 1.0) + f_dc = splats.f_dc.float() + f_rest = splats.f_rest.float() + + if max_splats > 0 and means.shape[0] > max_splats: + keep = torch.topk(opacity, k=max_splats).indices + means = means[keep] + quats = quats[keep] + scales = scales[keep] + opacity = opacity[keep] + f_dc = f_dc[keep] + f_rest = f_rest[keep] + + total = (splats.sh_order + 1) ** 2 + if add_sh_bias: + # gsplat evaluates SH internally and adds the +0.5 bias itself. + colors = torch.cat([f_dc, f_rest], dim=1).view(-1, 3, total).transpose(1, 2).contiguous() + sh_degree: Optional[int] = int(splats.sh_order) + else: + # gsplat always adds the SH bias, so evaluate SH manually and pass raw colors. + R = view_matrix[:3, :3] + t = view_matrix[:3, 3] + campos = -(R.transpose(0, 1) @ t) + dirs = means - campos + coeffs = torch.cat([f_dc, f_rest], dim=1).view(-1, 3, total) + colors = eval_sh(splats.sh_order, coeffs, dirs).clamp(0.0, 1.0) + sh_degree = None + + fov_rad = math.radians(camera_horizontal_fov) + f_px = 0.5 * output_width / math.tan(fov_rad / 2.0) + K = torch.tensor( + [ + [f_px, 0.0, output_width / 2.0], + [0.0, f_px, output_height / 2.0], + [0.0, 0.0, 1.0], + ], + device=dev, + dtype=torch.float32, + ) + renders, alphas, _meta = gsplat.rasterization( + means=means, + quats=quats, + scales=scales, + opacities=opacity, + colors=colors, + viewmats=view_matrix.unsqueeze(0), + Ks=K.unsqueeze(0), + width=int(output_width), + height=int(output_height), + sh_degree=sh_degree, + render_mode="RGB+ED", + ) + rgb = renders[0, ..., :3].clamp(0.0, 1.0) + depth = renders[0, ..., 3] + alpha = alphas[0, ..., 0].clamp(0.0, 1.0) + # gsplat's "ED" channel is expected z-depth; convert it to RADIAL ray depth + # (multiply by the per-pixel ray norm) so the disparity semantics match the + # "fast"/"over" backends, which use ||XYZ|| — otherwise render_mode="auto" + # silently switches disparity meaning between CPU and CUDA machines. + xs = (torch.arange(output_width, device=dev, dtype=torch.float32) + 0.5 - output_width / 2.0) / f_px + ys = (torch.arange(output_height, device=dev, dtype=torch.float32) + 0.5 - output_height / 2.0) / f_px + ray_norm = torch.sqrt(1.0 + xs.view(1, -1) ** 2 + ys.view(-1, 1) ** 2) + depth = depth * ray_norm + disparity = torch.where(depth > 1e-6, alpha / depth.clamp(min=1e-6), torch.zeros_like(depth)) + return rgb.unsqueeze(0), alpha, disparity.unsqueeze(0).unsqueeze(-1) + + +def render_gaussians( + splats: "GaussianSplats", + camera_matrix, + camera_projection: str, + camera_horizontal_fov: float, + output_width: int, + output_height: int, + max_splats: int = 0, + opacity_is_logit: bool = True, + add_sh_bias: bool = True, + render_mode: str = "auto", + chunk_size: int = 256, + max_radius: int = 32, + device: str = "auto", +) -> tuple: + """Render Gaussian splats from a world-to-camera 4x4 matrix. + + Returns (image [1,H,W,3] float 0..1, alpha/mask [H,W], disparity [1,H,W,1]). + All three outputs are always present, even when no splat is visible. + + render_mode: + - "auto": gsplat if importable, running on CUDA and projection is PINHOLE, else "fast". + - "gsplat": CUDA gsplat rasterization (PINHOLE only, raises otherwise). + - "fast": chunked torch splatting; anisotropic projected 2D covariance for PINHOLE, + isotropic approximation for FISHEYE/EQUIRECTANGULAR. + - "over": slow per-splat depth-sorted over-compositing (isotropic). + """ + target_device = _resolve_device_choice(device) + if splats.xyz.device != target_device: + splats = splats.to(target_device) + dev = splats.xyz.device + + mode = render_mode + if mode == "auto": + if ( + camera_projection == "PINHOLE" + and torch.cuda.is_available() + and dev.type == "cuda" + and _gsplat_available() + ): + mode = "gsplat" + else: + mode = "fast" + if mode not in ("gsplat", "fast", "over"): + raise ValueError(f"Unknown render_mode: {render_mode}") + + if isinstance(camera_matrix, torch.Tensor): + M = camera_matrix.to(dev).view(4, 4).float() + else: + M = torch.tensor(camera_matrix, device=dev, dtype=torch.float32).view(4, 4) + + if mode == "gsplat": + if camera_projection != "PINHOLE": + raise ValueError( + f"render_mode='gsplat' supports only the PINHOLE projection (got {camera_projection}). " + "Use render_mode='fast' or 'over' for FISHEYE/EQUIRECTANGULAR." + ) + return _render_gaussians_gsplat( + splats, + M, + camera_horizontal_fov, + output_width, + output_height, + max_splats, + opacity_is_logit, + add_sh_bias, + ) + + R = M[:3, :3] + t = M[:3, 3] + + coords = splats.xyz @ R.T + t + z = coords[:, 2] + in_front = z > 1e-6 + if not in_front.any(): + return _empty_render(output_width, output_height, dev) + + coords = coords[in_front] + f_dc = splats.f_dc[in_front] + f_rest = splats.f_rest[in_front] + opacity = splats.opacity[in_front].squeeze(-1) + scale = splats.scale[in_front] + rotation = splats.rotation[in_front] + + if opacity_is_logit: + opacity = torch.sigmoid(opacity) + + if max_splats > 0 and coords.shape[0] > max_splats: + keep = torch.topk(opacity, k=max_splats).indices + coords = coords[keep] + f_dc = f_dc[keep] + f_rest = f_rest[keep] + opacity = opacity[keep] + scale = scale[keep] + rotation = rotation[keep] + + dirs = _normalize_dirs(coords) + total = (splats.sh_order + 1) ** 2 + expected_rest = (total - 1) * 3 + if f_rest.shape[1] != expected_rest: + raise ValueError(f"Expected f_rest with {expected_rest} channels, got {f_rest.shape[1]}") + coeffs = torch.cat([f_dc, f_rest], dim=1).view(-1, 3, total) + colors = eval_sh(splats.sh_order, coeffs, dirs) + if add_sh_bias: + colors = colors + 0.5 + colors = colors.clamp(0.0, 1.0) + + X, Y, Z = coords.unbind(-1) + if camera_projection == "PINHOLE": + u, v, depth = _xyz_to_pinhole(X, Y, Z, camera_horizontal_fov) + elif camera_projection == "FISHEYE": + u, v, depth = _xyz_to_fisheye(X, Y, Z, camera_horizontal_fov) + else: + u, v, depth = _xyz_to_equirect(X, Y, Z, camera_horizontal_fov) + + valid = (u >= -1.0) & (u <= 1.0) & (v >= -1.0) & (v <= 1.0) + if not valid.any(): + return _empty_render(output_width, output_height, dev) + + coords = coords[valid] + u = u[valid] + v = v[valid] + depth = depth[valid] + colors = colors[valid] + opacity = opacity[valid] + scale = scale[valid] + rotation = rotation[valid] + + px = (u * 0.5 + 0.5) * (output_width - 1) + py = (v * 0.5 + 0.5) * (output_height - 1) + + fov_rad = math.radians(camera_horizontal_fov) + f = 1.0 / math.tan(fov_rad / 2.0) + fx = f * (output_width - 1) / 2.0 + fy = f * (output_height - 1) / 2.0 + # Legacy isotropic footprint, used by "over" mode and by "fast" for + # non-pinhole projections (kept for regression compatibility). + scale_mean = scale.mean(dim=1) + sigma_x = (scale_mean * fx / depth.clamp(min=1e-6)).clamp(min=0.5, max=512.0) + sigma_y = (scale_mean * fy / depth.clamp(min=1e-6)).clamp(min=0.5, max=512.0) + + if mode == "fast": + if camera_projection == "PINHOLE": + # Anisotropic footprint: project the 3D covariance to the image plane. + # Sigma3D = Rq S^2 Rq^T (world frame), rotated into the camera frame by + # the view rotation W, then Sigma2D = J W Sigma3D W^T J^T with J the + # perspective Jacobian, plus a 0.3px anti-alias blur. + Rq = _quats_to_rotation_matrices(rotation) + W3 = R.unsqueeze(0) @ Rq + s2 = torch.exp(2.0 * scale) + cov_cam = (W3 * s2.unsqueeze(1)) @ W3.transpose(1, 2) + Xc, Yc, Zc = coords.unbind(-1) + zc = Zc.clamp(min=1e-6) + j00 = fx / zc + j02 = -fx * Xc / (zc * zc) + j11 = fy / zc + j12 = -fy * Yc / (zc * zc) + c00 = cov_cam[:, 0, 0] + c01 = cov_cam[:, 0, 1] + c02 = cov_cam[:, 0, 2] + c11 = cov_cam[:, 1, 1] + c12 = cov_cam[:, 1, 2] + c22 = cov_cam[:, 2, 2] + cov_a = j00 * j00 * c00 + 2.0 * j00 * j02 * c02 + j02 * j02 * c22 + cov_b = j00 * j11 * c01 + j00 * j12 * c02 + j02 * j11 * c12 + j02 * j12 * c22 + cov_c = j11 * j11 * c11 + 2.0 * j11 * j12 * c12 + j12 * j12 * c22 + # 0.3px low-pass blur and stability clamps (match the legacy sigma clamps). + cov_a = (cov_a + 0.3).clamp(min=0.25, max=512.0 ** 2) + cov_c = (cov_c + 0.3).clamp(min=0.25, max=512.0 ** 2) + b_max = 0.99 * torch.sqrt(cov_a * cov_c) + cov_b = torch.maximum(torch.minimum(cov_b, b_max), -b_max) + det = (cov_a * cov_c - cov_b * cov_b).clamp(min=1e-8) + conic_a = cov_c / det + conic_b = -cov_b / det + conic_c = cov_a / det + rad_x_f = 3.0 * torch.sqrt(cov_a) + rad_y_f = 3.0 * torch.sqrt(cov_c) + else: + # FISHEYE / EQUIRECTANGULAR: the pixel-space Jacobian of these + # projections is strongly nonlinear and direction dependent (it + # degenerates near the poles / image border), so we keep the legacy + # isotropic approximation (mean scale / depth) instead of a + # projected 2D covariance. + conic_a = 1.0 / (sigma_x * sigma_x) + conic_b = torch.zeros_like(sigma_x) + conic_c = 1.0 / (sigma_y * sigma_y) + rad_x_f = 3.0 * sigma_x + rad_y_f = 3.0 * sigma_y + + max_radius = max(1, int(max_radius)) + chunk_size = max(1, int(chunk_size)) + total_px = output_height * output_width + alpha_sum = torch.zeros((total_px,), device=dev) + color_sum = torch.zeros((total_px, 3), device=dev) + depth_sum = torch.zeros((total_px,), device=dev) + n_splats = px.shape[0] + rad_x_all = torch.ceil(rad_x_f).detach().to(torch.int64).clamp(min=1, max=max_radius) + rad_y_all = torch.ceil(rad_y_f).detach().to(torch.int64).clamp(min=1, max=max_radius) + + def _splat_chunk(px_c, py_c, conic_a_c, conic_b_c, conic_c_c, opacity_c, colors_c, depth_c, rad_x, rad_y): + """One chunk's scatter contributions: (idx, alpha, color, depth) flats.""" + conic_a_c = conic_a_c.view(-1, 1, 1) + conic_b_c = conic_b_c.view(-1, 1, 1) + conic_c_c = conic_c_c.view(-1, 1, 1) + opacity_c = opacity_c.clamp(0.0, 1.0) + max_rx = int(rad_x.max().detach().cpu().item()) + max_ry = int(rad_y.max().detach().cpu().item()) + empty = ( + torch.zeros((0,), device=dev, dtype=torch.int64), + torch.zeros((0,), device=dev), + torch.zeros((0, 3), device=dev), + torch.zeros((0,), device=dev), + ) + if max_rx <= 0 or max_ry <= 0: + return empty + + # Window [floor(px - rad), floor(px - rad) + 2*max_r] covers the full + # [px - rad, px + rad] footprint of every splat in the chunk. (The + # previous arange(-max_r, max_r+1) offset from the left edge cut off + # the right/bottom half of each footprint.) + grid_x = torch.arange(0, 2 * max_rx + 1, device=dev) + grid_y = torch.arange(0, 2 * max_ry + 1, device=dev) + x0 = torch.floor(px_c.detach() - rad_x.float()).view(-1, 1, 1) + y0 = torch.floor(py_c.detach() - rad_y.float()).view(-1, 1, 1) + + xs = x0 + grid_x.view(1, 1, -1) + ys = y0 + grid_y.view(1, -1, 1) + + dx = xs - px_c.view(-1, 1, 1) + dy = ys - py_c.view(-1, 1, 1) + quad = conic_a_c * dx * dx + 2.0 * conic_b_c * dx * dy + conic_c_c * dy * dy + weight = torch.exp(-0.5 * quad) + + xs_int = xs.to(torch.int64) + ys_int = ys.to(torch.int64) + valid_px = ( + (xs_int >= 0) + & (xs_int < output_width) + & (ys_int >= 0) + & (ys_int < output_height) + & (quad.detach() <= 9.0) + ) + + alpha = opacity_c.view(-1, 1, 1) * weight + alpha = alpha * valid_px + valid_flat = valid_px.expand(alpha.shape).reshape(-1) + if not valid_flat.any(): + return empty + + idx = (ys_int * output_width + xs_int).expand(alpha.shape).reshape(-1)[valid_flat] + alpha_flat = alpha.reshape(-1)[valid_flat] + color_flat = (alpha.unsqueeze(-1) * colors_c.view(-1, 1, 1, 3)).reshape(-1, 3)[valid_flat] + depth_flat = (alpha * depth_c.view(-1, 1, 1)).reshape(-1)[valid_flat] + return idx, alpha_flat, color_flat, depth_flat + + # When gradients are required (e.g. SplatPolish's torch fallback), + # gradient-checkpoint each chunk: otherwise autograd retains every + # chunk's [chunk, 2r+1, 2r+1] intermediates (exp weights, alpha, color + # products, ...) until backward, and memory scales with + # n_splats x footprint — OOM at realistic splat counts. Checkpointing + # recomputes the chunk during backward instead. + needs_grad = torch.is_grad_enabled() and any( + t.requires_grad for t in (px, py, conic_a, conic_b, conic_c, opacity, colors, depth) + ) + if needs_grad: + from torch.utils.checkpoint import checkpoint as _torch_checkpoint + + for start in range(0, n_splats, chunk_size): + end = min(n_splats, start + chunk_size) + chunk_args = ( + px[start:end], + py[start:end], + conic_a[start:end], + conic_b[start:end], + conic_c[start:end], + opacity[start:end], + colors[start:end], + depth[start:end], + rad_x_all[start:end], + rad_y_all[start:end], + ) + if needs_grad: + idx, alpha_flat, color_flat, depth_flat = _torch_checkpoint( + _splat_chunk, *chunk_args, use_reentrant=False + ) + else: + idx, alpha_flat, color_flat, depth_flat = _splat_chunk(*chunk_args) + if idx.numel() == 0: + continue + + alpha_sum.scatter_add_(0, idx, alpha_flat) + color_sum.scatter_add_(0, idx.unsqueeze(-1).expand(-1, 3), color_flat) + depth_sum.scatter_add_(0, idx, depth_flat) + + alpha_img = alpha_sum.view(output_height, output_width).clamp(max=1.0) + color_img = color_sum.view(output_height, output_width, 3) / alpha_sum.view(output_height, output_width, 1).clamp(min=1e-6) + depth_img = depth_sum.view(output_height, output_width) / alpha_sum.view(output_height, output_width).clamp(min=1e-6) + disparity = (1.0 / depth_img.clamp(min=1e-6)) * alpha_img + disparity = disparity.unsqueeze(0).unsqueeze(-1) + return color_img.unsqueeze(0), alpha_img, disparity + + order = torch.argsort(depth) + order_cpu = order.detach().cpu().tolist() + px_cpu = px.detach().cpu().numpy() + py_cpu = py.detach().cpu().numpy() + sx_cpu = sigma_x.detach().cpu().numpy() + sy_cpu = sigma_y.detach().cpu().numpy() + + img = torch.zeros((output_height, output_width, 3), device=dev) + alpha_img = torch.zeros((output_height, output_width), device=dev) + depth_acc = torch.zeros((output_height, output_width), device=dev) + + for idx in order_cpu: + cx = float(px_cpu[idx]) + cy = float(py_cpu[idx]) + sx = float(sx_cpu[idx]) + sy = float(sy_cpu[idx]) + if sx <= 0.0 or sy <= 0.0: + continue + radius_x = int(math.ceil(3.0 * sx)) + radius_y = int(math.ceil(3.0 * sy)) + x0 = max(0, int(math.floor(cx - radius_x))) + x1 = min(output_width - 1, int(math.ceil(cx + radius_x))) + y0 = max(0, int(math.floor(cy - radius_y))) + y1 = min(output_height - 1, int(math.ceil(cy + radius_y))) + if x1 < x0 or y1 < y0: + continue + + xs = torch.arange(x0, x1 + 1, device=dev) + ys = torch.arange(y0, y1 + 1, device=dev) + yy, xx = torch.meshgrid(ys, xs, indexing="ij") + dx = (xx - cx) / sx + dy = (yy - cy) / sy + weight = torch.exp(-0.5 * (dx * dx + dy * dy)) + alpha = opacity[idx].clamp(0.0, 1.0) * weight + if alpha.max() <= 0.0: + continue + sub_alpha = alpha_img[y0 : y1 + 1, x0 : x1 + 1] + trans = 1.0 - sub_alpha + alpha = alpha.clamp(0.0, 1.0) + sub_color = img[y0 : y1 + 1, x0 : x1 + 1] + sub_color = sub_color + trans.unsqueeze(-1) * alpha.unsqueeze(-1) * colors[idx] + sub_alpha = sub_alpha + trans * alpha + sub_depth = depth_acc[y0 : y1 + 1, x0 : x1 + 1] + sub_depth = sub_depth + trans * alpha * depth[idx] + img[y0 : y1 + 1, x0 : x1 + 1] = sub_color + alpha_img[y0 : y1 + 1, x0 : x1 + 1] = sub_alpha + depth_acc[y0 : y1 + 1, x0 : x1 + 1] = sub_depth + + depth_img = depth_acc / alpha_img.clamp(min=1e-6) + disparity = (1.0 / depth_img.clamp(min=1e-6)) * alpha_img + disparity = disparity.unsqueeze(0).unsqueeze(-1) + return img.unsqueeze(0), alpha_img, disparity + + +class LoadPlySplat: + @classmethod + def INPUT_TYPES(cls): + input_dir = folder_paths.get_input_directory() + files = [ + f + for f in os.listdir(input_dir) + if os.path.isfile(os.path.join(input_dir, f)) and f.lower().endswith(".ply") + ] + return { + "required": { + "splat_file": ( + sorted(files), + { + "file_chooser": True, + "tooltip": "Select a 3DGS .ply file to load from your input folder." + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("splats",) + FUNCTION = "load_splats" + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Loads a 3D Gaussian Splatting PLY file into a GSPLAT object." + + def load_splats(self, splat_file: str, device: str = "auto"): + path = folder_paths.get_annotated_filepath(splat_file) + data = _read_ply_vertices(path) + + required = [ + "x", "y", "z", + "f_dc_0", "f_dc_1", "f_dc_2", + "opacity", + "scale_0", "scale_1", "scale_2", + "rot_0", "rot_1", "rot_2", "rot_3", + ] + missing = [name for name in required if name not in data] + if missing: + raise ValueError(f"PLY is missing required properties: {missing}") + + xyz = np.stack([data["x"], data["y"], data["z"]], axis=1).astype(np.float32) + scale = np.stack([data["scale_0"], data["scale_1"], data["scale_2"]], axis=1).astype(np.float32) + rotation = np.stack( + [data["rot_0"], data["rot_1"], data["rot_2"], data["rot_3"]], + axis=1, + ).astype(np.float32) + opacity = data["opacity"].astype(np.float32).reshape(-1, 1) + f_dc = np.stack([data["f_dc_0"], data["f_dc_1"], data["f_dc_2"]], axis=1).astype(np.float32) + f_rest, sh_order = _extract_f_rest(data) + + splats = GaussianSplats( + xyz=torch.from_numpy(xyz), + scale=torch.from_numpy(scale), + rotation=torch.from_numpy(rotation), + opacity=torch.from_numpy(opacity), + f_dc=torch.from_numpy(f_dc), + f_rest=torch.from_numpy(f_rest), + sh_order=sh_order, + ) + target_device = _resolve_device_choice(device) + if splats.xyz.device != target_device: + splats = splats.to(target_device) + return (splats,) + + @classmethod + def IS_CHANGED(cls, splat_file: str): + path = folder_paths.get_annotated_filepath(splat_file) + m = hashlib.sha256() + with open(path, "rb") as f: + m.update(f.read()) + return m.digest().hex() + + @classmethod + def VALIDATE_INPUTS(cls, splat_file: str): + if not folder_paths.exists_annotated_filepath(splat_file): + return f"Invalid splat file: {splat_file}" + return True + + +class ImageToSplat: + @classmethod + def INPUT_TYPES(cls): + choices = _list_sharp_checkpoint_choices() + return { + "required": { + "image": ("IMAGE",), + "horizontal_fov": ( + "FLOAT", + { + "default": 60.0, + "min": 1.0, + "max": 179.0, + "tooltip": "Horizontal field of view in degrees used to compute focal length.", + }, + ), + "checkpoint": ( + choices, + { + "default": _SHARP_DEFAULT_CHECKPOINT_LABEL, + "file_chooser": True, + "tooltip": "Select a .pt checkpoint from the input folder or download the default model.", + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("splats",) + FUNCTION = "image_to_splat" + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Predicts Gaussian splats from an image using SHARP." + + @torch.no_grad() + def image_to_splat( + self, + image: torch.Tensor, + horizontal_fov: float, + checkpoint: str, + device: str = "auto", + ): + _ensure_sharp_available() + target_device = _resolve_device_choice(device) + + image_np = _tensor_image_to_numpy(image) + height, width = image_np.shape[:2] + if height < 2 or width < 2: + raise ValueError("Input image is too small for SHARP.") + + f_px = _horizontal_fov_to_f_px(width, horizontal_fov) + checkpoint_path = None + if checkpoint and checkpoint != _SHARP_DEFAULT_CHECKPOINT_LABEL: + checkpoint_path = folder_paths.get_annotated_filepath(checkpoint) + + predictor = _load_sharp_predictor(checkpoint_path, target_device) + gaussians = _sharp_predict_image(predictor, image_np, float(f_px), target_device) + + mean_vectors = gaussians.mean_vectors[0] if gaussians.mean_vectors.dim() == 3 else gaussians.mean_vectors + singular_values = gaussians.singular_values[0] if gaussians.singular_values.dim() == 3 else gaussians.singular_values + quaternions = gaussians.quaternions[0] if gaussians.quaternions.dim() == 3 else gaussians.quaternions + colors = gaussians.colors[0] if gaussians.colors.dim() == 3 else gaussians.colors + opacities = gaussians.opacities[0] if gaussians.opacities.dim() == 2 else gaussians.opacities + + mean_vectors = mean_vectors.to(device=target_device, dtype=torch.float32) + singular_values = singular_values.to(device=target_device, dtype=torch.float32) + quaternions = quaternions.to(device=target_device, dtype=torch.float32) + colors = colors.to(device=target_device, dtype=torch.float32) + opacities = opacities.to(device=target_device, dtype=torch.float32) + + scale_logits = torch.log(singular_values.clamp(min=1e-9)) + opacity = opacities.clamp(1e-6, 1.0 - 1e-6).view(-1, 1) + opacity_logits = torch.log(opacity / (1.0 - opacity)) + + colors_srgb = _sharp_color_space.linearRGB2sRGB(colors.clamp(0.0, 1.0)).clamp(0.0, 1.0) + f_dc = _sharp_rgb_to_sh(colors_srgb).to(dtype=mean_vectors.dtype) + f_rest = torch.zeros((mean_vectors.shape[0], 0), device=target_device, dtype=mean_vectors.dtype) + + splats = GaussianSplats( + xyz=mean_vectors, + scale=scale_logits, + rotation=quaternions, + opacity=opacity_logits, + f_dc=f_dc, + f_rest=f_rest, + sh_order=0, + ) + return (splats,) + + +class FisheyeToGaussian: + @classmethod + def INPUT_TYPES(cls): + choices = _list_sharp_checkpoint_choices() + return { + "required": { + "image": ("IMAGE",), + "fisheye_horizontal_fov": ( + "FLOAT", + { + "default": 180.0, + "min": 1.0, + "max": 360.0, + "tooltip": "Horizontal field of view for the fisheye input.", + }, + ), + "output_width": ("INT", {"default": 0, "min": 0, "max": 16384}), + "output_height": ("INT", {"default": 0, "min": 0, "max": 16384}), + "checkpoint": ( + choices, + { + "default": _SHARP_DEFAULT_CHECKPOINT_LABEL, + "file_chooser": True, + "tooltip": "Select a .pt checkpoint from the input folder or download the default model.", + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + "pinhole_horizontal_fov": ( + "FLOAT", + {"default": 90.0, "min": 1.0, "max": 179.0}, + ), + "feathering": ("INT", {"default": 0, "min": 0, "max": 512}), + "stitch_mode": ( + ["keep", "discard", "average", "smart", "main_direction"], + {"default": "smart"}, + ), + "stitch_voxel_size": ( + "FLOAT", + {"default": 0.01, "min": 0.0, "max": 10.0}, + ), + "stitch_direction_deg": ( + "FLOAT", + {"default": 5.0, "min": 0.1, "max": 45.0}, + ), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("splats",) + FUNCTION = "fisheye_to_gaussian" + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Reprojects fisheye views to multiple pinhole angles, predicts splats, rotates and merges them." + + @torch.no_grad() + def fisheye_to_gaussian( + self, + image: torch.Tensor, + fisheye_horizontal_fov: float, + output_width: int, + output_height: int, + checkpoint: str, + device: str = "auto", + pinhole_horizontal_fov: float = 90.0, + feathering: int = 0, + stitch_mode: str = "smart", + stitch_voxel_size: float = 0.01, + stitch_direction_deg: float = 5.0, + ): + _ensure_sharp_available() + if ReprojectImage is None: + raise ModuleNotFoundError("ReprojectImage is unavailable; reprojection_nodes could not be imported.") + + image_tensor = image + if image_tensor.dim() == 3: + image_tensor = image_tensor.unsqueeze(0) + if image_tensor.dim() != 4: + raise ValueError("Expected IMAGE tensor with shape [B,H,W,C].") + + _, height, width, _ = image_tensor.shape + if output_width <= 0: + output_width = int(width) + if output_height <= 0: + output_height = int(height) + + image_to_splat = ImageToSplat() + reproject = ReprojectImage() + + view_angles = [ + (0.0, 0.0), + (0.0, 45.0), + (0.0, -45.0), + (45.0, 0.0), + (-45.0, 0.0), + ] + + splats_list: List[GaussianSplats] = [] + for theta, phi in view_angles: + transform = _build_rotation_matrix(theta, phi) + reproj_image, _ = reproject.reproject_image( + image_tensor, + fisheye_horizontal_fov, + pinhole_horizontal_fov, + "FISHEYE", + "PINHOLE", + output_width, + output_height, + feathering, + False, + transform, + None, + ) + + splats, = image_to_splat.image_to_splat( + reproj_image, + pinhole_horizontal_fov, + checkpoint, + device, + ) + if theta != 0.0 or phi != 0.0: + splats = splat_cloud_rotation(splats, transform) + splats_list.append(splats) + + merged = _stitch_splats( + splats_list, + stitch_mode, + stitch_voxel_size, + stitch_direction_deg, + pinhole_horizontal_fov, + ) + return (merged,) + + +class RotateSplats: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats": ("GSPLAT",), + "transform_matrix": ("MAT_4X4",), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("rotated_splats",) + FUNCTION = "rotate_splats" + CATEGORY = "Camera/GSplat" + + def rotate_splats(self, splats: GaussianSplats, transform_matrix: torch.Tensor, device: str = "auto"): + target_device = _resolve_device_choice(device) + if splats.xyz.device != target_device: + splats = splats.to(target_device) + return (splat_cloud_rotation(splats, transform_matrix),) + + +class MergeSplats: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats_a": ("GSPLAT",), + "splats_b": ("GSPLAT",), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("merged_splats",) + FUNCTION = "merge_splats" + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Merges two GSPLAT objects into one." + + def merge_splats(self, splats_a: GaussianSplats, splats_b: GaussianSplats, device: str = "auto"): + if splats_a.f_rest.shape[1] != splats_b.f_rest.shape[1] or splats_a.sh_order != splats_b.sh_order: + raise ValueError( + f"Splats must share the same SH order and f_rest size (got {splats_a.sh_order}/{splats_a.f_rest.shape[1]} vs " + f"{splats_b.sh_order}/{splats_b.f_rest.shape[1]})." + ) + + if device == "auto": + if splats_a.xyz.device == splats_b.xyz.device: + target_device = splats_a.xyz.device + else: + target_device = _resolve_device_choice("auto") + else: + target_device = _resolve_device_choice(device) + + dtype = torch.promote_types(splats_a.xyz.dtype, splats_b.xyz.dtype) + splats_a = _coerce_splats(splats_a, target_device, dtype) + splats_b = _coerce_splats(splats_b, target_device, dtype) + + merged = GaussianSplats( + xyz=torch.cat([splats_a.xyz, splats_b.xyz], dim=0), + scale=torch.cat([splats_a.scale, splats_b.scale], dim=0), + rotation=torch.cat([splats_a.rotation, splats_b.rotation], dim=0), + opacity=torch.cat([splats_a.opacity, splats_b.opacity], dim=0), + f_dc=torch.cat([splats_a.f_dc, splats_b.f_dc], dim=0), + f_rest=torch.cat([splats_a.f_rest, splats_b.f_rest], dim=0), + sh_order=splats_a.sh_order, + ) + return (merged,) + + +class RenderSplat: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats": ("GSPLAT",), + "camera_matrix": ("MAT_4X4",), + "camera_projection": (Projection.PROJECTIONS, {}), + "camera_horizontal_fov": ("FLOAT", {"default": 90.0}), + "output_width": ("INT", {"default": 512, "min": 8, "max": 16384}), + "output_height": ("INT", {"default": 512, "min": 8, "max": 16384}), + "max_splats": ("INT", {"default": 0, "min": 0, "max": 1000000, "tooltip": "Keep only the N most opaque splats. 0 = unlimited."}), + "opacity_is_logit": ("BOOLEAN", {"default": True}), + "add_sh_bias": ("BOOLEAN", {"default": True}), + "render_mode": (RENDER_MODES_ALL, {"default": "auto", "tooltip": "auto = gsplat when available (CUDA + PINHOLE), otherwise the torch 'fast' splatter."}), + "chunk_size": ("INT", {"default": 256, "min": 1, "max": 4096}), + "max_radius": ("INT", {"default": 32, "min": 1, "max": 512}), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("IMAGE", "MASK", "TENSOR") + RETURN_NAMES = ("image", "mask", "disparity") + FUNCTION = "render_splats" + CATEGORY = "Camera/GSplat" + + def render_splats( + self, + splats: GaussianSplats, + camera_matrix: torch.Tensor, + camera_projection: str, + camera_horizontal_fov: float, + output_width: int, + output_height: int, + max_splats: int, + opacity_is_logit: bool, + add_sh_bias: bool = True, + render_mode: str = "auto", + chunk_size: int = 256, + max_radius: int = 32, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + return render_gaussians( + splats, + camera_matrix, + camera_projection, + camera_horizontal_fov, + output_width, + output_height, + max_splats=max_splats, + opacity_is_logit=opacity_is_logit, + add_sh_bias=add_sh_bias, + render_mode=render_mode, + chunk_size=chunk_size, + max_radius=max_radius, + device=device, + ) + + +class SavePlySplat: + """ + Save a Gaussian Splat PLY to the ComfyUI output directory. + """ + def __init__(self): + self.output_dir = folder_paths.get_output_directory() + self.type = "splat" + self.prefix_append = "" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats": ("GSPLAT",), + "filename_prefix": ( + "STRING", + { + "default": "ComfyUIGSplat", + "tooltip": "Prefix for the .ply file. You can include format-tokens like %date:yyyy-MM-dd%." + } + ), + }, + "hidden": {}, + } + + RETURN_TYPES = () + FUNCTION = "save_splats" + OUTPUT_NODE = True + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Saves the input GSPLAT to your ComfyUI output directory as a .ply file." + + def save_splats(self, splats: GaussianSplats, filename_prefix: str): + filename_prefix += self.prefix_append + full_output_folder, filename, counter, subfolder, filename_prefix = \ + folder_paths.get_save_image_path( + filename_prefix, + self.output_dir, + 0, 0 + ) + os.makedirs(full_output_folder, exist_ok=True) + base_name = filename.replace("%batch_num%", "0") + ply_name = f"{base_name}_{counter:05}.ply" + ply_path = os.path.join(full_output_folder, ply_name) + _write_ply_splats(ply_path, splats) + counter += 1 + return { + "ui": { + "splats": [{ + "filename": ply_name, + "subfolder": subfolder, + "type": self.type + }] + } + } + + +class FuseSplats: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats_a": ("GSPLAT",), + "splats_b": ("GSPLAT",), + "voxel_size": ( + "FLOAT", + { + "default": 0.01, + "min": 0.0, + "max": 10.0, + "step": 0.001, + "tooltip": "Voxel edge length used to merge overlapping splats. 0 disables voxel merging.", + }, + ), + "mode": (FUSE_MODES, {"default": "smart"}), + "weight_a": ( + "FLOAT", + { + "default": 1.0, + "min": 0.0, + "max": 1000.0, + "tooltip": "Confidence/recency weight for splats_a (used by smart/average modes).", + }, + ), + "weight_b": ( + "FLOAT", + { + "default": 1.0, + "min": 0.0, + "max": 1000.0, + "tooltip": "Confidence/recency weight for splats_b (used by smart/average modes).", + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("fused_splats",) + FUNCTION = "fuse_splats" + CATEGORY = "Camera/GSplat" + DESCRIPTION = "Fuses two splat clouds with weighted voxel merging (weights bias the per-voxel reduction)." + + def fuse_splats( + self, + splats_a: GaussianSplats, + splats_b: GaussianSplats, + voxel_size: float, + mode: str, + weight_a: float, + weight_b: float, + device: str = "auto", + ): + if splats_a.f_rest.shape[1] != splats_b.f_rest.shape[1] or splats_a.sh_order != splats_b.sh_order: + raise ValueError( + f"Splats must share the same SH order and f_rest size (got {splats_a.sh_order}/{splats_a.f_rest.shape[1]} vs " + f"{splats_b.sh_order}/{splats_b.f_rest.shape[1]})." + ) + if device == "auto": + if splats_a.xyz.device == splats_b.xyz.device: + target_device = splats_a.xyz.device + else: + target_device = _resolve_device_choice("auto") + else: + target_device = _resolve_device_choice(device) + dtype = torch.promote_types(splats_a.xyz.dtype, splats_b.xyz.dtype) + a = _coerce_splats(splats_a, target_device, dtype) + b = _coerce_splats(splats_b, target_device, dtype) + fused = _stitch_splats( + [a, b], + mode, + voxel_size, + 5.0, + weights_list=[float(weight_a), float(weight_b)], + ) + return (fused,) + + +class VideoToFusedSplats: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + choices = _list_sharp_checkpoint_choices() + return { + "required": { + "frames": ("IMAGE", {"tooltip": "Video frames [T,H,W,3]."}), + "trajectory": ( + "TENSOR", + {"tooltip": "[T,4,4] world-to-camera matrix per frame (a single [4,4] is broadcast)."}, + ), + "horizontal_fov": ("FLOAT", {"default": 60.0, "min": 1.0, "max": 179.0}), + "checkpoint": ( + choices, + { + "default": _SHARP_DEFAULT_CHECKPOINT_LABEL, + "file_chooser": True, + "tooltip": "SHARP .pt checkpoint from the input folder, or download the default model.", + }, + ), + "keyframe_stride": ( + "INT", + {"default": 8, "min": 1, "max": 1000, "tooltip": "Run SHARP on every Nth frame."}, + ), + "stitch_voxel_size": ("FLOAT", {"default": 0.01, "min": 0.0, "max": 10.0, "step": 0.001}), + "stitch_mode": (FUSE_MODES, {"default": "smart"}), + }, + "optional": { + "static_mask": ( + "MASK", + {"tooltip": "[T,H,W], 1 = static/keep pixel. Splats whose source pixel has mask < 0.5 are dropped."}, + ), + "depths": ( + "TENSOR", + {"tooltip": "[T,H,W] metric depths. SHARP splats are scale-aligned per keyframe via a robust median disparity ratio."}, + ), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("splats",) + FUNCTION = "video_to_fused_splats" + CATEGORY = "Camera/GSplat" + DESCRIPTION = ( + "Runs SHARP on video keyframes, optionally scale-aligns to metric depth and filters dynamic pixels, " + "transforms each keyframe splat cloud to the world frame via the inverse camera pose, and fuses everything " + "incrementally into a single world-frame splat cloud." + ) + + @torch.no_grad() + def video_to_fused_splats( + self, + frames: torch.Tensor, + trajectory, + horizontal_fov: float, + checkpoint: str, + keyframe_stride: int = 8, + stitch_voxel_size: float = 0.01, + stitch_mode: str = "smart", + static_mask: Optional[torch.Tensor] = None, + depths: Optional[torch.Tensor] = None, + device: str = "auto", + ): + _ensure_sharp_available() + target_device = _resolve_device_choice(device) + if frames.dim() == 3: + frames = frames.unsqueeze(0) + if frames.dim() != 4: + raise ValueError("frames must be an IMAGE tensor [T,H,W,C].") + num_frames = int(frames.shape[0]) + height = int(frames.shape[1]) + width = int(frames.shape[2]) + traj = _coerce_trajectory(trajectory, num_frames, target_device) + depth_seq = _normalize_map_sequence(depths, num_frames, "depths") if depths is not None else None + mask_seq = _normalize_map_sequence(static_mask, num_frames, "static_mask") if static_mask is not None else None + + keyframes = list(range(0, num_frames, max(1, int(keyframe_stride)))) + image_to_splat = ImageToSplat() + keyframe_clouds: List[GaussianSplats] = [] + for i in _progress(keyframes, desc="VideoToFusedSplats"): + splats, = image_to_splat.image_to_splat(frames[i : i + 1], horizontal_fov, checkpoint, device) + if splats.xyz.device != target_device: + splats = splats.to(target_device) + if len(splats) == 0: + continue + + if depth_seq is not None: + depth_i = depth_seq[i if depth_seq.shape[0] > 1 else 0].to(target_device) + px, py, z, ok = _project_splats_to_pixels(splats.xyz, horizontal_fov, width, height) + d_ref = _sample_map_at_pixels(depth_i, px, py, width, height) + ok = ok & (d_ref > 1e-6) & (z > 1e-6) + if ok.any(): + # Robust scale in the disparity domain: + # median((1/z_sharp) / (1/d_ref)) == median(d_ref / z_sharp). + s = torch.median(d_ref[ok] / z[ok]) + if torch.isfinite(s) and float(s) > 1e-6: + splats = GaussianSplats( + xyz=splats.xyz * s, + scale=splats.scale + torch.log(s), + rotation=splats.rotation, + opacity=splats.opacity, + f_dc=splats.f_dc, + f_rest=splats.f_rest, + sh_order=splats.sh_order, + ) + + if mask_seq is not None: + mask_i = mask_seq[i if mask_seq.shape[0] > 1 else 0].to(target_device) + px, py, _z, ok = _project_splats_to_pixels(splats.xyz, horizontal_fov, width, height) + mask_values = _sample_map_at_pixels(mask_i, px, py, width, height) + drop = ok & (mask_values < 0.5) + splats = splats[~drop] + if len(splats) == 0: + continue + + # trajectory is world-to-camera; the splats live in the camera frame, + # so camera-to-world = inverse(pose) brings them into the world frame. + cam_to_world = torch.linalg.inv(traj[i]) + splats_world = splat_cloud_rotation(splats, cam_to_world) + keyframe_clouds.append(splats_world) + if not keyframe_clouds: + raise ValueError("No splats were produced from the provided frames.") + # Fuse with a SINGLE voxel reduce over all keyframe clouds. Re-stitching + # the whole accumulated cloud on every keyframe (the previous approach) + # is O(keyframes x N) work and peak memory: each iteration re-copied and + # re-unique-sorted the entire accumulated cloud, ballooning runtime and + # OOMing on long clips. + if len(keyframe_clouds) == 1: + accumulated = keyframe_clouds[0] + else: + accumulated = _stitch_splats( + keyframe_clouds, + stitch_mode, + stitch_voxel_size, + 5.0, + ) + return (accumulated,) + + +class SplatPolish: + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "splats": ("GSPLAT",), + "frames": ("IMAGE", {"tooltip": "Ground-truth frames [T,H,W,3]."}), + "trajectory": ("TENSOR", {"tooltip": "[T,4,4] world-to-camera matrix per frame."}), + "horizontal_fov": ("FLOAT", {"default": 60.0, "min": 1.0, "max": 179.0}), + "iterations": ("INT", {"default": 300, "min": 1, "max": 100000}), + "lr_xyz": ("FLOAT", {"default": 1.6e-4, "min": 0.0, "max": 1.0, "step": 0.00001}), + "lr_rest": ( + "FLOAT", + { + "default": 2.5e-3, + "min": 0.0, + "max": 1.0, + "step": 0.0001, + "tooltip": "Base learning rate for non-position parameters (3DGS-style ratios applied per group).", + }, + ), + "lambda_l1": ("FLOAT", {"default": 0.8, "min": 0.0, "max": 10.0}), + "lambda_dssim": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 10.0}), + "opacity_reg": ("FLOAT", {"default": 0.01, "min": 0.0, "max": 1.0}), + "allow_torch_fallback": ( + "BOOLEAN", + { + "default": False, + "tooltip": "Without gsplat+CUDA, optimize through the differentiable torch renderer at reduced resolution. EXTREMELY slow; expect minutes per 100 iterations.", + }, + ), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("polished_splats",) + FUNCTION = "polish_splats" + CATEGORY = "Camera/GSplat" + DESCRIPTION = ( + "Optimizes an existing world-frame splat cloud against posed video frames " + "(L1 + D-SSIM photometric loss) using gsplat's differentiable rasterizer." + ) + + def polish_splats( + self, + splats: GaussianSplats, + frames: torch.Tensor, + trajectory, + horizontal_fov: float, + iterations: int, + lr_xyz: float, + lr_rest: float, + lambda_l1: float, + lambda_dssim: float, + opacity_reg: float, + allow_torch_fallback: bool = False, + device: str = "auto", + ): + target_device = _resolve_device_choice(device) + use_gsplat = ( + target_device.type == "cuda" + and torch.cuda.is_available() + and _gsplat_available() + ) + if not use_gsplat and not allow_torch_fallback: + raise RuntimeError( + "SplatPolish requires gsplat with CUDA (install with: pip install gsplat). " + "Alternatively enable allow_torch_fallback to optimize through the pure-torch " + "renderer at reduced resolution (extremely slow)." + ) + + if frames.dim() == 3: + frames = frames.unsqueeze(0) + if frames.dim() != 4: + raise ValueError("frames must be an IMAGE tensor [T,H,W,C].") + frames = frames[..., :3].float() + num_frames = int(frames.shape[0]) + frame_h = int(frames.shape[1]) + frame_w = int(frames.shape[2]) + traj = _coerce_trajectory(trajectory, num_frames, target_device) + + render_w, render_h = frame_w, frame_h + if not use_gsplat: + # The torch fallback renderer is O(pixels x splats); shrink the target. + max_dim = 256 + scale_factor = min(1.0, max_dim / max(frame_w, frame_h)) + render_w = max(8, int(round(frame_w * scale_factor))) + render_h = max(8, int(round(frame_h * scale_factor))) + if (render_w, render_h) != (frame_w, frame_h): + frames_chw = frames.permute(0, 3, 1, 2) + frames_chw = F.interpolate(frames_chw, size=(render_h, render_w), mode="bilinear", align_corners=False) + frames = frames_chw.permute(0, 2, 3, 1).contiguous() + # Keep the ground-truth frames where they arrived (normally CPU): each + # iteration samples a single random frame, so only that frame is moved + # to the target device. Uploading the whole clip up front would pin + # ~T*H*W*3*4 bytes of VRAM (about 5GB for 200 frames at 1080p) on top + # of the rasterization buffers and optimizer state. + frames = frames.contiguous() + + base = splats.to(target_device) + xyz = base.xyz.detach().clone().float().requires_grad_(True) + scale = base.scale.detach().clone().float().requires_grad_(True) + rotation = base.rotation.detach().clone().float().requires_grad_(True) + opacity = base.opacity.detach().clone().float().requires_grad_(True) + f_dc = base.f_dc.detach().clone().float().requires_grad_(True) + has_rest = base.f_rest.shape[1] > 0 + f_rest = base.f_rest.detach().clone().float() + if has_rest: + f_rest.requires_grad_(True) + + # Learning-rate ratios follow the standard 3DGS recipe, scaled by lr_rest. + param_groups = [ + {"params": [xyz], "lr": lr_xyz}, + {"params": [f_dc], "lr": lr_rest}, + {"params": [opacity], "lr": lr_rest * 20.0}, + {"params": [scale], "lr": lr_rest * 2.0}, + {"params": [rotation], "lr": lr_rest * 0.4}, + ] + if has_rest: + param_groups.append({"params": [f_rest], "lr": lr_rest / 20.0}) + optimizer = torch.optim.Adam(param_groups, eps=1e-15) + + total_sh = (base.sh_order + 1) ** 2 + fov_rad = math.radians(horizontal_fov) + f_px = 0.5 * render_w / math.tan(fov_rad / 2.0) + K = torch.tensor( + [ + [f_px, 0.0, render_w / 2.0], + [0.0, f_px, render_h / 2.0], + [0.0, 0.0, 1.0], + ], + device=target_device, + dtype=torch.float32, + ) + gsplat_mod = _import_gsplat() if use_gsplat else None + + for _ in _progress(range(int(iterations)), desc="SplatPolish"): + frame_idx = int(torch.randint(0, num_frames, (1,)).item()) + target = frames[frame_idx].to(target_device) + pose = traj[frame_idx] + + if use_gsplat: + quats = rotation / rotation.norm(dim=-1, keepdim=True).clamp(min=1e-8) + sh = torch.cat([f_dc, f_rest], dim=1).view(-1, 3, total_sh).transpose(1, 2) + renders, _alphas, _meta = gsplat_mod.rasterization( + means=xyz, + quats=quats, + scales=torch.exp(scale), + opacities=torch.sigmoid(opacity).view(-1), + colors=sh, + viewmats=pose.unsqueeze(0), + Ks=K.unsqueeze(0), + width=render_w, + height=render_h, + sh_degree=int(base.sh_order), + render_mode="RGB", + ) + pred = renders[0, ..., :3].clamp(0.0, 1.0) + else: + current = GaussianSplats( + xyz=xyz, + scale=scale, + rotation=rotation, + opacity=opacity, + f_dc=f_dc, + f_rest=f_rest, + sh_order=base.sh_order, + ) + img, _mask, _disp = render_gaussians( + current, + pose, + "PINHOLE", + horizontal_fov, + render_w, + render_h, + max_splats=0, + opacity_is_logit=True, + add_sh_bias=True, + render_mode="fast", + device=target_device.type, + ) + pred = img[0] + if not pred.requires_grad: + continue # nothing visible from this pose + + l1 = (pred - target).abs().mean() + loss = lambda_l1 * l1 + if lambda_dssim > 0.0: + ssim_val = _ssim( + pred.permute(2, 0, 1).unsqueeze(0), + target.permute(2, 0, 1).unsqueeze(0), + ) + loss = loss + lambda_dssim * (1.0 - ssim_val) + if opacity_reg > 0.0: + loss = loss + opacity_reg * torch.sigmoid(opacity).mean() + + optimizer.zero_grad() + loss.backward() + optimizer.step() + with torch.no_grad(): + rotation.data = rotation.data / rotation.data.norm(dim=-1, keepdim=True).clamp(min=1e-8) + opacity.data.clamp_(-15.0, 15.0) + scale.data.clamp_(-12.0, 6.0) + + polished = GaussianSplats( + xyz=xyz.detach().clone(), + scale=scale.detach().clone(), + rotation=(rotation / rotation.norm(dim=-1, keepdim=True).clamp(min=1e-8)).detach().clone(), + opacity=opacity.detach().clone(), + f_dc=f_dc.detach().clone(), + f_rest=f_rest.detach().clone(), + sh_order=base.sh_order, + ) + return (polished,) + + +NODE_CLASS_MAPPINGS = { + "LoadPlySplat": LoadPlySplat, + "ImageToSplat": ImageToSplat, + "FisheyeToGaussian": FisheyeToGaussian, + "RotateSplats": RotateSplats, + "MergeSplats": MergeSplats, + "RenderSplat": RenderSplat, + "SavePlySplat": SavePlySplat, + "FuseSplats": FuseSplats, + "VideoToFusedSplats": VideoToFusedSplats, + "SplatPolish": SplatPolish, +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..bccd337 --- /dev/null +++ b/LICENSE @@ -0,0 +1,29 @@ +MIT License + +Copyright (c) 2026 Alexander Kharin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +--- + +Note: the bundled directory `submodules/ml-sharpt` contains Apple's ml-sharp +project and is licensed separately under the terms in +`submodules/ml-sharpt/LICENSE` (source) and `submodules/ml-sharpt/LICENSE_MODEL` +(model weights, research-only). The MIT license above does not apply to that +directory. diff --git a/README.md b/README.md index e43fc06..3732490 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,7 @@ * [Installation](#installation) * [Node Categories](#node-categories) * [Node Reference](#node-reference) +* [Video → 4D World](#video--4d-world) * [Workflows](#workflows) * [Example Workflows](#example-workflows) * [Contributing](#contributing) @@ -35,6 +36,14 @@ A collection of ComfyUI custom nodes to handle diverse camera projections (pinho ## Installation +### Option A — ComfyUI Manager (recommended) + +The node pack is published to the [ComfyUI Registry](https://registry.comfy.org) as **`camera-comfyui`** (publisher `alexk`). In ComfyUI, open **Manager → Custom Nodes Manager**, search for **camera-comfyUI**, and click **Install**, then restart ComfyUI. The registry package bundles the SHARP submodule and installs the base Python requirements automatically; optional CUDA-specific extras (`gsplat`, `vggt`) still follow the manual steps below. + +> **Maintainers:** releases are automated — bumping `version` in `pyproject.toml` on `main` triggers `.github/workflows/publish_action.yml`, which publishes the new version to the registry (requires the `REGISTRY_ACCESS_TOKEN` repo secret). + +### Option B — Manual install (git) + 1. **Clone** into your ComfyUI custom nodes folder: ```bash @@ -55,6 +64,13 @@ A collection of ComfyUI custom nodes to handle diverse camera projections (pinho * *Optional:* `open3d` for GUI point cloud tools. + **Optional dependencies** (only needed for specific nodes): + + * **gsplat** — CUDA-accelerated Gaussian splat rasterizer. Required by `SplatPolish` and used as the fast render backend for `RenderSplat` / `RenderSplats4D*`. Needs a CUDA GPU and a matching PyTorch build: `pip install gsplat`. + * **vggt** — camera pose + depth estimation (`VideoPoseEstimator`). Install with `pip install vggt` (or `pip install git+https://github.com/facebookresearch/vggt.git`), or clone [facebookresearch/vggt](https://github.com/facebookresearch/vggt) as a sibling folder in your ComfyUI root. The `facebook/VGGT-1B` weights (~5 GB) download via `huggingface_hub` on first use. + * **CoTracker3** — point tracking for `EstimateTracks`. No manual install: it is fetched automatically via `torch.hub` on first use. + * **SHARP** — image→splat prediction (`ImageToSplat`, `FisheyeToGaussian`, `VideoToFusedSplats`, `SplatTrajectoryEnricher`). Ships as the existing git submodule at `submodules/ml-sharpt` ([apple/ml-sharp](https://github.com/apple/ml-sharp)) — run `git submodule update --init` after cloning. + 4. **Additional Nodes** (for certain workflows): * Clone the following repositories directly into your `custom_nodes` folder: @@ -94,13 +110,33 @@ A collection of ComfyUI custom nodes to handle diverse camera projections (pinho * ### Point Cloud Nodes * `DepthToPointCloud`, `TransformPointCloud`, `ProjectPointCloud`, `PointCloudUnion` - * `PointCloudCleaner`, `LoadPointCloud`, `SavePointCloud`, `ProjectAndClean` + * `PointCloudCleaner`, `LoadPointCloud`, `SavePointCloud`, `ProjectAndClean`, `DepthEdgeFilter` * ### Trajectory Nodes * `CameraMotionNode`, `CameraInterpolationNode`, `CameraTrajectoryNode` * `SaveTrajectory`, `LoadTrajectory`, `PointcloudTrajectoryEnricher` +* ### Gaussian Splat Nodes + + * `LoadPlySplat`, `SavePlySplat`, `ImageToSplat`, `FisheyeToGaussian` + * `RotateSplats`, `MergeSplats`, `FuseSplats`, `RenderSplat` + * `VideoToFusedSplats`, `SplatPolish` + +* ### 4D Gaussian Splat Nodes + + * `MotionMaskFromDepth`, `EstimateTracks`, `TracksToTrajectories`, `SplitSplatsByMask` + * `BuildSplats4D`, `RenderSplats4DFrame`, `RenderSplats4DVideo` + * `SaveSplats4D`, `LoadSplats4D` + +* ### Pose Nodes + + * `VideoPoseEstimator`, `TrajectoryInvert`, `TrajectoryCompose` + +* ### World Nodes + + * `DepthScaleAnchor`, `SplatTrajectoryEnricher`, `SphereSplatSeed` + --- ## Node Reference @@ -130,6 +166,51 @@ A collection of ComfyUI custom nodes to handle diverse camera projections (pinho | `VideoCameraMotionSequence` | Processes video frames and depth maps along a camera trajectory, generating reprojected outputs. | | `DepthFramesToVideo` | Converts a sequence of depth maps into video frame tensors for saving. | | `VideoMetricDepthEstimate` | Estimates metric depth for a sequence of frames using VideoDepthAnything. | +| `DepthEdgeFilter` | Detects "flying pixel" depth discontinuities and outputs a validity mask (1.0 = valid). | +| `LoadPlySplat` | Loads a 3D Gaussian Splatting `.ply` file into a `GSPLAT` object. | +| `SavePlySplat` | Saves a `GSPLAT` to the ComfyUI output directory as a `.ply` file. | +| `ImageToSplat` | Predicts Gaussian splats from a single image using SHARP. | +| `FisheyeToGaussian` | Reprojects a fisheye view to multiple pinhole angles, predicts splats, rotates and merges them. | +| `RotateSplats` | Applies a 4×4 transform matrix to a splat cloud. | +| `MergeSplats` | Concatenates two `GSPLAT` objects into one. | +| `FuseSplats` | Fuses two splat clouds with weighted voxel merging (keep/discard/average/smart modes). | +| `RenderSplat` | Renders a splat cloud from a camera pose into an image + mask. | +| `VideoToFusedSplats` | Runs SHARP on video keyframes, scale-aligns to metric depth, filters dynamic pixels, and fuses all keyframes into one world-frame splat cloud. | +| `SplatPolish` | Optimizes a world-frame splat cloud against posed video frames (L1 + D-SSIM) using gsplat's differentiable rasterizer. | +| `MotionMaskFromDepth` | Detects dynamic pixels from a depth+pose sequence (1.0 = moving). | +| `EstimateTracks` | Runs CoTracker3 on a video; returns tracks `[T,N,2]` (pixels) and visibility `[T,N]`. | +| `TracksToTrajectories` | Unprojects 2D tracks with depth and camera poses into world-space 3D trajectories `[T,M,3]`. | +| `SplitSplatsByMask` | Projects splat centers into a 2D mask and splits the cloud into inside/outside parts. | +| `BuildSplats4D` | Builds a 4D splat scene: each canonical splat follows a kNN blend of track control-point motions. | +| `RenderSplats4DFrame` | Evaluates the 4D scene at a single time value and renders it from a given camera. | +| `RenderSplats4DVideo` | Interpolates the camera path, sweeps time from start to end, and renders each frame. | +| `SaveSplats4D` | Saves a `GSPLAT4D` scene as an `.npz` archive (plus optional per-frame PLYs). | +| `LoadSplats4D` | Loads a `GSPLAT4D` scene from an `.npz` archive. | +| `VideoPoseEstimator` | VGGT-based per-frame camera poses `[T,4,4]`, depth maps, FOV and depth confidence from a video clip. | +| `TrajectoryInvert` | Inverts each 4×4 pose (world-to-camera ↔ camera-to-world). | +| `TrajectoryCompose` | Per-frame matrix product `A @ B`; a single 4×4 input broadcasts over the other. | +| `DepthScaleAnchor` | Robustly aligns a depth map to a reference depth via disparity-domain scale(+shift). | +| `SplatTrajectoryEnricher` | Expands a splat world along a trajectory: render, outpaint holes with Flux, lift with SHARP, scale-align, smart-stitch. | +| `SphereSplatSeed` | Converts an equirectangular panorama into a Gaussian sphere seeding a 360° world. | + +--- + +## Video → 4D World + +Turn a monocular video into a navigable 4D (3D + time) Gaussian splat scene and re-render it from any novel camera trajectory. The reference workflow is **`workflows/video_to_4d_world.json`**; the stages are: + +1. **Pose & depth (VGGT)** — `VideoPoseEstimator` estimates per-frame world-to-camera poses `[T,4,4]`, depth maps, FOV and depth confidence from the input frames. Since the depth maps are Z-depths, run `ZDepthToRayDepthNode` before any node that expects ray depth (see caveats below). `DepthEdgeFilter` can additionally mask out flying pixels at depth discontinuities. +2. **Motion masking** — `MotionMaskFromDepth` warps depth between frames using the estimated poses and flags pixels whose residual is too large as dynamic (moving objects vs. static background). +3. **Static splat fusion + polish** — `VideoToFusedSplats` runs SHARP on keyframes, keeps only static pixels (via the motion mask), scale-aligns each keyframe to metric depth, transforms splats into the world frame and fuses them incrementally. `SplatPolish` then fine-tunes the fused cloud photometrically against the posed video frames. +4. **Tracked dynamic 4D Gaussians** — `EstimateTracks` (CoTracker3) tracks a dense point grid across the video; `TracksToTrajectories` lifts the tracks to world-space 3D using depth + poses; `SplitSplatsByMask` separates dynamic splats from the static background; `BuildSplats4D` binds the dynamic canonical splats to track control points via kNN blending, producing a `GSPLAT4D` scene. +5. **Render a novel trajectory** — build any new camera path (e.g. `CameraInterpolationNode`, `TrajectoryCompose` to retarget relative to a source pose) and render with `RenderSplats4DVideo` (or single frames with `RenderSplats4DFrame`). Save/reload scenes with `SaveSplats4D` / `LoadSplats4D`. + +### Caveats + +* **Z-depth vs ray depth**: depth estimators (including `VideoPoseEstimator`) output Z-depth; point-cloud and splat lifting nodes expect ray depth. Insert `ZDepthToRayDepthNode` where needed, or geometry will bow at wide FOVs. +* **`SplatPolish` requires gsplat + CUDA**: without them it can fall back to the differentiable torch renderer at reduced resolution, which is extremely slow (minutes per 100 iterations). +* **`EstimateTracks` downloads CoTracker3 via `torch.hub` on first use** — expect a one-time download and allow network access. +* **`VideoPoseEstimator` downloads `facebook/VGGT-1B` (~5 GB)** on first use via `huggingface_hub`. --- @@ -150,6 +231,8 @@ A set of JSON workflows illustrating typical use cases. Each workflow lives in ` | **Pointcloud\_walker.json** | GUI‐based camera control via Open3D | | **sbs180\_workflow.json** | Generate stereo (side-by-side) wide-angle/fisheye/equirectangular stereo pairs from a high-res input | | **video_camera.json** | Camera trajectory movement workflow using `wan-vace` for video inpainting. | +| **video_to_4d_world\.json** | Video → 4D world: VGGT poses/depth → motion masking → fused static splats + polish → tracked dynamic 4D Gaussians → novel-trajectory render. | +| **video_to_4d_walkable_world\.json** | Video → 4D WALKABLE world (test-friendly defaults): polished static splats enriched along a walk trajectory (`SplatTrajectoryEnricher`, Flux outpaint + SHARP) → 4D scene → walk-through render + `.ply`/`.npz` exports for free walking in external 3DGS viewers. | --- @@ -268,9 +351,12 @@ Contributions welcome! Please open issues or PRs to add features, improve docs, * [x] Add processing to pointcloud or depthmap to remove outlier and lonely points at depth borders. * [x] Use built-in comfyUI mask type an image. * [x] Unite nodes into groups to simplify workflows. -* [ ] Create a single workflow for view synthesis. +* [x] Create a single workflow for view synthesis (`video_to_4d_world.json`). * [x] Implement easier and more flexible camera control - more complex camera movements with more than 2 points. * [x] Add more examples and documentation for each node. * [x] Add pointcloud union * [x] Fix imports for renamed folders (e.g., inpainting_flux) * [x] Integrate camera movement pipeline with video models (e.g., wan2.1) for smooth, high-quality inpainting along camera trajectories. +* [ ] Compressed export format for 4D scenes (current `.npz` stores raw tensors). +* [ ] SAM2-based refinement of motion masks (current masks come from depth-warp residuals only). +* [ ] Fisheye/equirectangular rendering through gsplat (e.g., via cubemap render + reprojection); the fast CUDA path is currently pinhole-only. diff --git a/__init__.py b/__init__.py index 8d12912..789efac 100644 --- a/__init__.py +++ b/__init__.py @@ -4,6 +4,27 @@ from .metric_depth_nodes import NODE_CLASS_MAPPINGS as NCM3 from .flux_fisheye_filling_nodes import NODE_CLASS_MAPPINGS as NCM4 from .complex_nodes import NODE_CLASS_MAPPINGS as NCM5 from .video_nodes import NODE_CLASS_MAPPINGS as NCM6 -NODE_CLASS_MAPPINGS = {**NCM1, **NCM2, **NCM3, **NCM4, **NCM5, **NCM6} +from .GS_nodes import NODE_CLASS_MAPPINGS as NCM7 -__all__ = ["NODE_CLASS_MAPPINGS"] \ No newline at end of file +# Optional node packs: a missing/broken optional dependency must never kill the +# whole extension (mirrors how video_nodes degrades when video_depth_anything +# is unavailable). +try: + from .GS4D_nodes import NODE_CLASS_MAPPINGS as NCM8 +except Exception as _exc: + print(f"[camera-comfyUI] Warning: GS4D_nodes could not be loaded, 4D splat nodes disabled: {_exc}") + NCM8 = {} +try: + from .pose_nodes import NODE_CLASS_MAPPINGS as NCM9 +except Exception as _exc: + print(f"[camera-comfyUI] Warning: pose_nodes could not be loaded, pose estimation nodes disabled: {_exc}") + NCM9 = {} +try: + from .world_nodes import NODE_CLASS_MAPPINGS as NCM10 +except Exception as _exc: + print(f"[camera-comfyUI] Warning: world_nodes could not be loaded, world-building nodes disabled: {_exc}") + NCM10 = {} + +NODE_CLASS_MAPPINGS = {**NCM1, **NCM2, **NCM3, **NCM4, **NCM5, **NCM6, **NCM7, **NCM8, **NCM9, **NCM10} + +__all__ = ["NODE_CLASS_MAPPINGS"] diff --git a/docs/lingbot_world_4d_report.md b/docs/lingbot_world_4d_report.md new file mode 100644 index 0000000..2af0c1d --- /dev/null +++ b/docs/lingbot_world_4d_report.md @@ -0,0 +1,127 @@ +# LingBot-World 2.0 → 4D video: analysis & integration report + +*Research date: 2026-07-13. LingBot-World 2.0 was released 2026-07-09, four days before this report.* + +## TL;DR + +**LingBot-World 2.0 is not a 3D/4D model — it is a camera-pose- and action-conditioned autoregressive video generator.** It outputs only pixels and maintains no explicit geometry. But it has exactly the property that makes a video-generation model useful for 4D reconstruction: **you command the camera trajectory (poses + intrinsics) of every generated frame**, so every output video is a *posed* video. That turns it into a controllable multi-view video factory whose output can be lifted into 4D Gaussian splats by the existing `video_to_4d_world.json` pipeline in this repo — with the pose-estimation step optionally replaced by the commanded poses. + +Feasibility verdicts: + +| Question | Verdict | +| --- | --- | +| 4D video from a 3D scene (splat/mesh) | **Yes, indirectly** — render the 3D scene to a seed image, then LingBot animates + explores it. 3D enters only as a rendered start frame; there is no native 3D conditioning. | +| 4D Gaussian-splat video from its output | **Feasible and first-party-endorsed** — the LingBot-World paper itself demonstrates reconstructing its generated videos into point clouds with VGGT-class models, the same VGGT this repo already uses. | +| Drop-in ComfyUI use today | **Not yet** — 14B Wan2.2-based weights, no quantized release for v2, no wrapper support yet ([kijai/WanVideoWrapper#1920](https://github.com/kijai/ComfyUI-WanVideoWrapper/issues/1920), [Comfy-Org/ComfyUI#12154](https://github.com/Comfy-Org/ComfyUI/issues/12154)); reference inference is 8×GPU `torchrun`. | +| Commercial use | **v2: no** (CC BY-NC-SA 4.0). **v1: yes** (Apache 2.0). This alone may decide which version to build on. | + +--- + +## 1. What LingBot-World 2.0 actually is + +**Repos & papers** +- v2 (current): [Robbyant/lingbot-world-v2](https://github.com/Robbyant/lingbot-world-v2) — "Infinite Worlds with Versatile Interactions", tech report [arXiv:2607.07534](https://arxiv.org/abs/2607.07534), weights [robbyant/lingbot-world-v2-14b-causal-fast](https://huggingface.co/robbyant/lingbot-world-v2-14b-causal-fast). Released 2026-07-09 by Robbyant (embodied-AI subsidiary of Ant Group). +- v1 (deprecated but still useful): [Robbyant/lingbot-world](https://github.com/robbyant/lingbot-world) — "Advancing Open-source World Models", [arXiv:2601.20540](https://arxiv.org/abs/2601.20540), weights `robbyant/lingbot-world-base-cam` / `-base-act` / `-fast`. Released 2026-01-29. + +**Architecture (verified against code + paper)** +- Built on **Wan2.2 i2v-A14B**: a two-expert MoE video diffusion model, ~28B total parameters with **14B active** per denoising step (high-noise expert for global structure, low-noise for detail). Ships the Wan2.1 VAE and umT5-XXL text encoder. +- v2 converts it to **causal, chunk-by-chunk autoregressive generation**: latents are generated `chunk_size` latent frames at a time against a **KV cache** with **sink tokens** and a **local attention window** (`run_fast.sh` uses `--local_attn_size 18 --sink_size 6`). A **MoBA mask** ("Mixture of Bidirectional and Autoregressive Attention Mask") mixes bidirectional attention into teacher forcing to stop the long-horizon quality collapse that plagues autoregressive video. Result: the paper demonstrates an **uninterrupted hour-long session with no perceptible quality decay**. +- Two inference modes: `causal_fast` (distilled few-step; drives **720p @ 60 fps** in their real-time deployment) and `causal_pretrain` (40-step CFG; checkpoint still marked TODO). A single-GPU **1.3B variant is described in the paper but not released**. + +**Conditioning inputs — the part that matters for 4D** (from `wan/image2video.py` + `wan/utils/cam_utils.py`) +- **Seed image** (`--image`) + **text prompt**: the world is initialized from one image and a background description. This is the *only* way content enters — no 3D input of any kind. +- **Camera trajectory**: `poses.npy` `[T,4,4]` **camera-to-world, OpenCV convention** + `intrinsics.npy` `[T,4]` = `[fx,fy,cx,cy]`. Converted to per-pixel **Plücker ray embeddings** (`get_plucker_embeddings`), folded into the latent grid and injected per-chunk into the DiT (AdaLN per the tech report). Relative poses are translation-normalized (`compute_relative_poses`), and `interpolate_camera_poses` (SLERP) is provided. +- **Keyboard actions**: `wasd_action.npy` (movement) / `ijkl_action.npy` (view) as multi-hot vectors concatenated onto the Plücker conditioning. v2 adds character actions (attack, archery, spell-cast, shoot, jump, glide) and **chunk-wise text events** (weather, entity spawning, time-of-day), plus a VLM-driven "pilot/director" agentic harness. +- v1 README explicitly recommends **[NVIDIA ViPE](https://github.com/nv-tlabs/vipe)** to extract `poses.npy`/`intrinsics.npy` from an *existing real video* — i.e., the official video→control-signal bridge. + +**Inference & hardware** +```bash +torchrun --nproc_per_node=8 generate.py --task i2v-A14B --size 480*832 \ + --frame_num 361 --ckpt_dir lingbot-world-v2-14b-causal-fast \ + --image examples/03/image.jpg --action_path examples/03 \ + --infer_mode causal_fast --dit_fsdp --t5_fsdp --ulysses_size 8 \ + --local_attn_size 18 --sink_size 6 +``` +- Reference: 8×GPU (FSDP + Ulysses sequence parallel), 480×832, 361 frames (`frame_num` must be 4n+1). Single-GPU runs auto-enable `--offload_model` (T5/DiT swapped to CPU between stages) — expect 80GB-class VRAM for comfortable 14B bf16 inference; there is **no quantized v2 release yet**. v1 has a community **4-bit quant** and `--t5_cpu`, and supports up to 961 frames (~1 min @ 16 fps). +- Requirements: `torch >= 2.4.0`, `flash_attn`. + +**License** — v2 code *and* weights are **CC BY-NC-SA 4.0 (non-commercial, share-alike)**; v1 is **Apache 2.0**. Anything commercial built on v2 outputs is off the table; v1 remains the commercially safe option at lower quality/horizon. + +--- + +## 2. Can it turn 3D into 4D video? + +**Yes, with the 3D scene entering as a rendered image, not as geometry.** The paper is explicit that the world "is initialized from an initial image and its background description" — there is no splat/mesh/point-cloud conditioning path, and the model "operates without an explicit notion of geometry." + +The working recipe, using nodes already in this repo: + +1. **Render a seed view** of your static 3D asset: `LoadPlySplat` → `RenderSplat` (or a mesh render) at 832×480+, from a pose with good scene coverage. +2. **Author the camera trajectory you want** in the splat's own coordinate frame (`CameraInterpolationNode` / `CameraTrajectoryNode`), convert to camera-to-world OpenCV `poses.npy` + `intrinsics.npy`. +3. **Feed image + poses + actions/text-events to LingBot-World.** The model animates the scene (wind, characters, weather, spawned entities via text events) while following your camera — i.e., it *invents plausible dynamics* for your static 3D scene. This is "3D → 4D video" in the sense of *generating* the time dimension, not simulating it: physics is learned and imperfect, and the output will drift from your 3D asset's exact geometry the further the camera goes from the seed view. +4. **Optionally lift the result back to 4D splats** (section 3) so the animated version of your scene becomes re-renderable from any camera. + +Caveat on fidelity: only the seed frame is constrained by your 3D input. Occluded/unseen regions are hallucinated. For higher fidelity to the source scene you can seed successive generations from renders at multiple poses and stitch — the same strategy `SplatTrajectoryEnricher` already uses with Flux outpainting, but with LingBot providing temporally coherent *video* instead of stills. + +--- + +## 3. Feasibility: 4D Gaussian-splat video from LingBot output + +**This is the strongest part of the story.** Three findings, all verified against primary sources: + +1. **Posed video for free.** Because generation is conditioned on `poses.npy`/`intrinsics.npy`, every generated frame comes with a commanded camera. A monocular real video gives you poses only after VGGT/COLMAP estimation; LingBot gives you the trajectory you asked for. (Treat commanded poses as *approximate* — the model follows them but is not geometrically exact; see limitations.) +2. **First-party evidence that reconstruction works.** The LingBot-World paper itself demonstrates: *"by leveraging large-scale 3D reconstruction foundation models [lin2025depth, wang2025vggt], we can further convert the generated video sequences into high-quality scene point clouds"*, with point clouds showing *"strong spatial coherence across frames"* (Fig. 16, [arXiv:2601.20540](https://arxiv.org/html/2601.20540v1)). That is literally VGGT — the model behind this repo's `VideoPoseEstimator` — applied to LingBot output by its own authors. +3. **Long-horizon consistency is the v2 headline.** Landmarks stay structurally intact after being out of view for up to ~60 s (v1) and v2 extends coherent generation to hour scale with no perceptible decay. Long consistent orbits are exactly what splat optimization needs. + +**How it maps onto known video-to-4D paradigms:** +- **CAT4D-style** ([arXiv:2411.18613](https://arxiv.org/abs/2411.18613)): camera/time-disentangled video diffusion → deformable 3DGS optimization. LingBot is not time-disentangled (you cannot freeze time and move the camera — camera and time advance together in one causal stream), so you *cannot* get true simultaneous multi-view of a dynamic instant from a single run. +- **Monocular 4D lifting** (this repo's pipeline): works on any single posed video — LingBot output qualifies directly and improves on real footage by letting you *choose* a camera path that orbits/parallaxes around the action, which is the single biggest quality lever for monocular 4D reconstruction. +- **Multi-run multi-view**: re-running with the same seed image but different trajectories gives multiple views of the *same static scene* but **different sampled dynamics** (different seeds/action outcomes per run) — usable for static splat fusion, **not** for dynamic 4D supervision. Keep dynamics within one continuous run. + +**Bottom line:** treat LingBot-World as a *trajectory-controllable monocular video source* feeding the existing 4D pipeline; don't expect synchronized multi-view rigs out of it. + +--- + +## 4. Concrete pipeline: video → 4D video / 4D splats + +### Path A — real video in, 4D world out, LingBot as the world extender + +Your existing `video_to_4d_world.json` already handles real-video → 4D. LingBot adds value where that pipeline is weakest: viewpoints the source video never saw. + +1. **Base 4D scene from the real video** (existing flow): `VideoPoseEstimator` (VGGT poses/depth) → `ZDepthToRayDepthNode` → `MotionMaskFromDepth` → `VideoToFusedSplats` + `SplatPolish` (static) → `EstimateTracks`/`TracksToTrajectories`/`SplitSplatsByMask`/`BuildSplats4D` (dynamic) → `GSPLAT4D`. +2. **Extract control signals from the same video** with ViPE (officially recommended) or reuse the VGGT poses: `VideoPoseEstimator` outputs world-to-camera `[T,4,4]` → `TrajectoryInvert` → camera-to-world OpenCV → export `poses.npy` + `intrinsics.npy` (VGGT's FOV output gives `fx,fy`; `cx,cy` = image center). *(Small new node needed: `TrajectoryToNpyExport` — trivial, ~20 lines.)* +3. **Continue the world where the video ends**: last real frame = LingBot seed image; author an exploration trajectory (orbit, dolly, walk) continuing from the last real pose; generate 361+ frames. +4. **Lift the generated segment** through the same stage-1 flow and **fuse into the base scene**: `FuseSplats`/`MergeSplats` for statics (scale-anchor with `DepthScaleAnchor` against the base scene's depth), separate `BuildSplats4D` time range for new dynamics. Result: a 4D world larger than the source footage. + +### Path B — single image or 3D scene in, 4D splat video out + +1. **Seed**: any image, or a render of an existing splat (`RenderSplat`) / mesh. +2. **Trajectory design**: slow orbit or arc around the subject + gentle forward motion — maximize parallax, avoid pure rotation (no baseline → no geometry). Keep FOV fixed; write `poses.npy`/`intrinsics.npy` (c2w, OpenCV; translations get normalized internally, so keep the trajectory scale moderate and re-anchor metric scale later with `DepthScaleAnchor`). +3. **Generate** with `causal_fast`, 480×832, 361 frames; drive dynamics with keyboard/character actions and chunk-wise text events ("a horse gallops through", "rain starts"). +4. **Reconstruct** — two pose options: + - *Trust-but-verify (recommended)*: run `VideoPoseEstimator` on the generated frames anyway; compare with commanded poses (`TrajectoryCompose` of one with `TrajectoryInvert` of the other should be ≈ identity); use VGGT's poses for reconstruction, commanded poses as sanity check. This absorbs the model's camera-following error. + - *Fast path*: use commanded poses directly, skip VGGT pose estimation, still run its depth head (or `VideoMetricDepthEstimate`) for the depth maps the lifting nodes need. +5. **Lift to 4D**: identical to the existing workflow — motion mask → static fusion (`VideoToFusedSplats` + `SplatPolish`) → tracks (`EstimateTracks` is CoTracker3, works fine on generated footage) → `BuildSplats4D` → `RenderSplats4DVideo` along any novel camera path → `SaveSplats4D`. + +### Integration notes for camera-comfyUI + +- **Coordinate conventions align well**: LingBot uses OpenCV c2w + `[fx,fy,cx,cy]`, this repo's `TRAJECTORY` is 4×4 matrices with `TrajectoryInvert`/`TrajectoryCompose` already available. Needed glue: (a) `TrajectoryToNpyExport` / `NpyToTrajectory` nodes, (b) optionally a `LingBotGenerate` node wrapping `generate.py` via subprocess for remote/8-GPU boxes — running 14B in-process inside ComfyUI is not realistic today. +- **ComfyUI-native inference isn't there yet**: WanVideoWrapper/ComfyUI support for LingBot checkpoints is an open request blocked on VRAM/quantization ([#1920](https://github.com/kijai/ComfyUI-WanVideoWrapper/issues/1920), [#12154](https://github.com/Comfy-Org/ComfyUI/issues/12154)). Because it's Wan2.2-architecture, wrapper support and GGUF/FP8 quants are likely to appear quickly; the causal KV-cache/sink/MoBA inference loop is custom, so a naive Wan2.2 loader won't reproduce long-horizon behavior. +- **Pragmatic hardware ladder**: (1) today, single-image experiments on v1 `base-cam` 4-bit quant (Apache 2.0, 480p, camera-pose conditioned — same poses.npy interface) on a 24 GB GPU; (2) v2 14B on a rented 8×A100/H100 node or single 80 GB GPU with offload; (3) wait for the announced 1.3B v2 release for true single-GPU local use. + +### Known limitations + +- **No geometry inside the model** — all 3D/4D structure comes from post-hoc reconstruction; physics is "imperfect" by the authors' own admission. +- **Camera-following error**: commanded poses ≠ achieved poses exactly (Plücker conditioning is a soft constraint; translations are normalized, so absolute scale is undefined) — always re-anchor scale and consider re-estimating poses. +- **Dynamics are not repeatable across runs** — multi-view supervision of a dynamic instant is impossible; design single continuous runs whose camera moves *around* the action. +- **480×832 native offline resolution** (720p is the real-time streaming mode) — plan on splat-space upscaling or `SplatPolish` against upscaled frames. +- **Generated-content artifacts** (texture shimmer, occasional object morphing) become floaters/ghosts in splat space — the existing `MotionMaskFromDepth` + `DepthEdgeFilter` + `PointCloudCleaner` stack mitigates this, and track-validity filtering in `TracksToTrajectories` matters more than with real footage. +- **License**: v2 is CC BY-NC-SA 4.0 — non-commercial only, share-alike. Use v1 (Apache 2.0) for anything with commercial intent. + +--- + +## Sources + +Primary: [lingbot-world-v2 repo](https://github.com/Robbyant/lingbot-world-v2) · [v2 tech report arXiv:2607.07534](https://arxiv.org/abs/2607.07534) · [v2 weights (HF)](https://huggingface.co/robbyant/lingbot-world-v2-14b-causal-fast) · [lingbot-world v1 repo](https://github.com/robbyant/lingbot-world) · [v1 paper arXiv:2601.20540](https://arxiv.org/abs/2601.20540) · [v1 cam weights (HF)](https://huggingface.co/robbyant/lingbot-world-base-cam) · code files `generate.py`, `wan/image2video.py`, `wan/utils/cam_utils.py`, `run_fast.sh` (read directly). +Secondary: [Robbyant press release (2026-07-09)](https://www.businesswire.com/news/home/20260708757367/en/Robbyant-Unveils-LingBot-World-2.0-Pioneering-Hour-Long-Real-Time-Generation-in-World-Models) · [v1 release (2026-01-28)](https://www.businesswire.com/news/home/20260128459962/en/Robbyant-Open-Sources-LingBot-World-a-World-Model-for-Millisecond-Level-Real-Time-Interaction) · [CAT4D arXiv:2411.18613](https://arxiv.org/abs/2411.18613) · [ViPE](https://github.com/nv-tlabs/vipe) · ComfyUI support threads [WanVideoWrapper#1920](https://github.com/kijai/ComfyUI-WanVideoWrapper/issues/1920), [ComfyUI#12154](https://github.com/Comfy-Org/ComfyUI/issues/12154). + +*Method note: claims were gathered by a fan-out research pass (18 sources, 90 raw claims, 25 adversarially verified: 14 confirmed 3-0, 3 refuted, 8 verification-errored) plus direct reading of both repos' inference code and both arXiv papers. The two load-bearing claims whose automated verification errored (v1's video→point-cloud demonstration; the unreleased 1.3B variant) were re-verified manually against the arXiv HTML.* diff --git a/notebooks/smoke_test_4d.py b/notebooks/smoke_test_4d.py new file mode 100644 index 0000000..fcbaa9e --- /dev/null +++ b/notebooks/smoke_test_4d.py @@ -0,0 +1,484 @@ +"""Standalone CPU smoke test for the 4D-world node stack (no ComfyUI, no CUDA, +no model downloads). + +Run with: + python notebooks/smoke_test_4d.py + +Stubs `folder_paths` via sys.modules injection so the repo modules import +outside the ComfyUI runtime, then functionally exercises the NEW code paths +with small synthetic data: + + 1. interpolate_se3 (pointcloud_nodes, contract C1) + 2. render_gaussians (GS_nodes, contract C2) shapes + empty case + 3. render_gaussians fast anisotropic footprint + 4. GaussianSplats4D.at_time (GS4D_nodes, contract C3) + 5. BuildSplats4D kNN track binding + 6. SplitSplatsByMask + 7. MotionMaskFromDepth + 8. align_depth_scale (world_nodes, contract C4) + DepthEdgeFilter + 9. FuseSplats weighted voxel fusion +10. SphereSplatSeed pano -> splat sphere -> render round-trip +""" + +import math +import os +import sys +import tempfile +import traceback +import types + +# --------------------------------------------------------------------------- # +# Environment setup: repo on sys.path + folder_paths stub (before repo imports) +# --------------------------------------------------------------------------- # +REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if REPO_ROOT not in sys.path: + sys.path.insert(0, REPO_ROOT) + +_TMP_DIR = tempfile.mkdtemp(prefix="smoke_test_4d_") + + +def _stub_get_save_image_path(filename_prefix, output_dir, *args, **kwargs): + os.makedirs(output_dir, exist_ok=True) + return output_dir, filename_prefix, 0, "", filename_prefix + + +_fp_stub = types.ModuleType("folder_paths") +_fp_stub.get_input_directory = lambda: _TMP_DIR +_fp_stub.get_output_directory = lambda: _TMP_DIR +_fp_stub.get_temp_directory = lambda: _TMP_DIR +_fp_stub.get_save_image_path = _stub_get_save_image_path +_fp_stub.get_annotated_filepath = lambda name: os.path.join(_TMP_DIR, name) +_fp_stub.exists_annotated_filepath = lambda name: os.path.exists(os.path.join(_TMP_DIR, name)) +_fp_stub.get_filename_list = lambda folder: [] +_fp_stub.models_dir = _TMP_DIR +sys.modules["folder_paths"] = _fp_stub + +import numpy as np # noqa: E402 +import torch # noqa: E402 + +import GS_nodes # noqa: E402 +import GS4D_nodes # noqa: E402 +import pointcloud_nodes # noqa: E402 +import world_nodes # noqa: E402 + +GaussianSplats = GS_nodes.GaussianSplats + +torch.manual_seed(0) +np.random.seed(0) + + +# --------------------------------------------------------------------------- # +# Helpers +# --------------------------------------------------------------------------- # +def make_splats( + xyz: torch.Tensor, + sigma: float = 0.05, + color: tuple = None, + opacity_logit: float = 4.0, +) -> GaussianSplats: + """Isotropic sh_order-0 splats at the given positions.""" + n = xyz.shape[0] + if color is None: + rgb = torch.rand(n, 3) + else: + rgb = torch.tensor(color, dtype=torch.float32).view(1, 3).expand(n, 3) + C0 = 0.28209479177387814 + return GaussianSplats( + xyz=xyz.float(), + scale=torch.full((n, 3), math.log(sigma)), + rotation=torch.tensor([1.0, 0.0, 0.0, 0.0]).view(1, 4).expand(n, 4).contiguous(), + opacity=torch.full((n, 1), float(opacity_logit)), + f_dc=((rgb - 0.5) / C0).contiguous(), + f_rest=torch.zeros(n, 0), + sh_order=0, + ) + + +def rot_x(deg: float) -> torch.Tensor: + a = math.radians(deg) + return torch.tensor( + [[1, 0, 0], [0, math.cos(a), -math.sin(a)], [0, math.sin(a), math.cos(a)]], + dtype=torch.float32, + ) + + +def rot_y(deg: float) -> torch.Tensor: + a = math.radians(deg) + return torch.tensor( + [[math.cos(a), 0, math.sin(a)], [0, 1, 0], [-math.sin(a), 0, math.cos(a)]], + dtype=torch.float32, + ) + + +def make_pose(R: torch.Tensor, t) -> torch.Tensor: + M = torch.eye(4) + M[:3, :3] = R + M[:3, 3] = torch.tensor(t, dtype=torch.float32) + return M + + +IDENTITY_4X4 = torch.eye(4) + + +# --------------------------------------------------------------------------- # +# Tests +# --------------------------------------------------------------------------- # +def test_01_interpolate_se3(): + poses = torch.stack( + [ + make_pose(torch.eye(3), [0.0, 0.0, 0.0]), + make_pose(rot_y(90.0), [1.0, 2.0, 3.0]), + make_pose(rot_y(90.0) @ rot_x(45.0), [-1.0, 0.0, 2.0]), + ] + ) + out = pointcloud_nodes.interpolate_se3(poses, 10) + assert out.shape == (10, 4, 4), f"shape {tuple(out.shape)}" + + eye = torch.eye(3) + for i in range(10): + R = out[i, :3, :3] + ortho_err = (R @ R.T - eye).abs().max().item() + det = torch.det(R).item() + assert ortho_err < 1e-4, f"step {i}: R@R.T deviates from I by {ortho_err}" + assert abs(det - 1.0) < 1e-4, f"step {i}: det(R)={det}" + assert torch.allclose(out[i, 3], torch.tensor([0.0, 0.0, 0.0, 1.0]), atol=1e-6) + + assert (out[0] - poses[0]).abs().max().item() < 1e-4, "start pose mismatch" + assert (out[-1] - poses[-1]).abs().max().item() < 1e-4, "end pose mismatch" + + # K == 1 repeats. + rep = pointcloud_nodes.interpolate_se3(poses[:1], 5) + assert rep.shape == (5, 4, 4) + assert (rep - poses[0]).abs().max().item() < 1e-6 + + +def test_02_render_gaussians_shapes_and_empty(): + n, H, W = 200, 48, 64 + xyz = torch.stack( + [ + torch.rand(n) * 2.0 - 1.0, + torch.rand(n) * 2.0 - 1.0, + torch.rand(n) * 3.0 + 2.0, + ], + dim=-1, + ) + splats = make_splats(xyz, sigma=0.05) + + for projection, fov in (("PINHOLE", 90.0), ("EQUIRECTANGULAR", 360.0)): + image, mask, disparity = GS_nodes.render_gaussians( + splats, IDENTITY_4X4, projection, fov, W, H, + render_mode="fast", device="cpu", + ) + assert image.shape == (1, H, W, 3), f"{projection} image {tuple(image.shape)}" + assert mask.shape == (H, W), f"{projection} mask {tuple(mask.shape)}" + assert disparity.shape == (1, H, W, 1), f"{projection} disparity {tuple(disparity.shape)}" + assert torch.isfinite(image).all() and torch.isfinite(disparity).all() + assert float(mask.min()) >= 0.0 and float(mask.max()) <= 1.0 + 1e-6 + assert float(mask.sum()) > 0.0, f"{projection}: nothing rendered" + + # Empty case: every splat strictly behind a pinhole camera (known past bug: + # early return used to yield only 2 outputs). + behind = make_splats(xyz * torch.tensor([1.0, 1.0, -1.0]), sigma=0.05) + result = GS_nodes.render_gaussians( + behind, IDENTITY_4X4, "PINHOLE", 90.0, W, H, + render_mode="fast", device="cpu", + ) + assert isinstance(result, tuple) and len(result) == 3, f"empty render returned {len(result)} outputs" + image, mask, disparity = result + assert image.shape == (1, H, W, 3) + assert mask.shape == (H, W) + assert disparity.shape == (1, H, W, 1) + assert float(mask.sum()) == 0.0 + + +def test_03_fast_mode_anisotropy(): + H = W = 128 + ang = math.radians(45.0) / 2.0 + splats = GaussianSplats( + xyz=torch.tensor([[0.0, 0.0, 3.0]]), + scale=torch.log(torch.tensor([[0.5, 0.01, 0.01]])), + rotation=torch.tensor([[math.cos(ang), 0.0, 0.0, math.sin(ang)]]), # 45 deg about +z + opacity=torch.tensor([[6.0]]), + f_dc=torch.zeros(1, 3), + f_rest=torch.zeros(1, 0), + sh_order=0, + ) + image, mask, disparity = GS_nodes.render_gaussians( + splats, IDENTITY_4X4, "PINHOLE", 60.0, W, H, + render_mode="fast", max_radius=64, device="cpu", + ) + assert float(mask.sum()) > 0.0, "elongated splat rendered nothing" + + # Alpha-weighted pixel covariance of the footprint. + ys, xs = torch.meshgrid( + torch.arange(H, dtype=torch.float32), torch.arange(W, dtype=torch.float32), + indexing="ij", + ) + w = mask.flatten() + wsum = w.sum() + mx = (w * xs.flatten()).sum() / wsum + my = (w * ys.flatten()).sum() / wsum + dx = xs.flatten() - mx + dy = ys.flatten() - my + cxx = (w * dx * dx).sum() / wsum + cyy = (w * dy * dy).sum() / wsum + cxy = (w * dx * dy).sum() / wsum + cov = torch.tensor([[cxx, cxy], [cxy, cyy]]) + evals, evecs = torch.linalg.eigh(cov) + ratio = float(evals[1] / evals[0].clamp(min=1e-8)) + assert ratio > 2.0, f"footprint not elongated: eigenvalue ratio {ratio:.2f}" + + # Principal axis should be near 45 degrees (rotation honored). + major = evecs[:, 1] + angle = math.degrees(math.atan2(float(major[1]), float(major[0]))) % 180.0 + assert abs(angle - 45.0) < 15.0, f"major axis at {angle:.1f} deg, expected ~45" + + +def test_04_at_time(): + T = 5 + canonical = make_splats(torch.tensor([[0.0, 0.0, 2.0], [0.0, 1.0, 3.0]])) + static = make_splats(torch.tensor([[5.0, 5.0, 5.0]])) + start = torch.tensor([[0.0, 0.0, 2.0], [0.0, 1.0, 3.0]]) + end = torch.tensor([[1.0, 0.0, 2.0], [0.0, -1.0, 3.0]]) + ts = torch.linspace(0.0, 1.0, T) + trajectories = torch.stack([start + (end - start) * t for t in ts]) # [5,2,3] + + s4d = GS4D_nodes.GaussianSplats4D( + static=static, canonical=canonical, trajectories=trajectories, times=ts, + ) + + mid = s4d.at_time(0.5) + assert len(mid) == 3, f"count {len(mid)} != dynamic+static (3)" + # Concat order is [static, dynamic]. + assert torch.allclose(mid.xyz[0], static.xyz[0], atol=1e-6) + expected_mid = 0.5 * (start + end) + assert torch.allclose(mid.xyz[1:], expected_mid, atol=1e-5), ( + f"midpoint mismatch: {mid.xyz[1:]} vs {expected_mid}" + ) + + lo = s4d.at_time(-1.0) + hi = s4d.at_time(2.0) + assert torch.allclose(lo.xyz[1:], start, atol=1e-5), "trange should clamp to last step" + + +def test_05_build_splats4d(): + T = 5 + ts = torch.linspace(0.0, 1.0, T) + # Two control tracks moving apart along x. + track_a = torch.stack([torch.tensor([-1.0 - 2.0 * t, 0.0, 2.0]) for t in ts]) + track_b = torch.stack([torch.tensor([1.0 + 2.0 * t, 0.0, 2.0]) for t in ts]) + trajectories3d = torch.stack([track_a, track_b], dim=1) # [T,2,3] + + canonical = make_splats(torch.tensor([[-1.05, 0.0, 2.0], [1.05, 0.0, 2.0]])) + node = GS4D_nodes.BuildSplats4D() + (s4d,) = node.build_splats4d( + canonical=canonical, + trajectories3d=trajectories3d, + reference_index=0, + knn=1, + rbf_gamma=0.0, + device="cpu", + ) + traj = s4d.trajectories + assert traj.shape == (T, 2, 3), f"trajectories shape {tuple(traj.shape)}" + # Reference timestep: splats stay at their canonical positions. + assert torch.allclose(traj[0], canonical.xyz, atol=1e-5) + # Each splat follows its nearest track's displacement direction. + disp0 = traj[-1, 0] - traj[0, 0] + disp1 = traj[-1, 1] - traj[0, 1] + assert disp0[0] < -1.0, f"splat 0 should move -x with track A, moved {disp0.tolist()}" + assert disp1[0] > 1.0, f"splat 1 should move +x with track B, moved {disp1.tolist()}" + assert torch.allclose(traj[-1, 0], torch.tensor([-3.05, 0.0, 2.0]), atol=1e-4) + assert torch.allclose(traj[-1, 1], torch.tensor([3.05, 0.0, 2.0]), atol=1e-4) + + +def test_06_split_splats_by_mask(): + H = W = 32 + mask = torch.zeros(H, W) + mask[:, : W // 2] = 1.0 # left half white + + # 10 splats projecting into the left half (x<0), 10 into the right half, + # 5 behind the camera. + jitter = torch.linspace(-0.1, 0.1, 10) + left = torch.stack([torch.full((10,), -0.5) + jitter * 0.1, jitter, torch.full((10,), 2.0)], dim=-1) + right = torch.stack([torch.full((10,), 0.5) + jitter * 0.1, jitter, torch.full((10,), 2.0)], dim=-1) + behind = torch.stack([jitter[:5], jitter[:5], torch.full((5,), -2.0)], dim=-1) + splats = make_splats(torch.cat([left, right, behind], dim=0)) + + node = GS4D_nodes.SplitSplatsByMask() + inside, outside = node.split_splats( + splats=splats, + mask=mask, + projection="PINHOLE", + horizontal_fov=90.0, + threshold=0.5, + camera_matrix=None, + device="cpu", + ) + assert len(inside) == 10, f"inside count {len(inside)} != 10" + assert len(outside) == 15, f"outside count {len(outside)} != 15 (10 right + 5 behind)" + assert (inside.xyz[:, 0] < 0).all(), "inside splats should be the x<0 group" + + +def test_07_motion_mask_from_depth(): + T, H, W = 6, 32, 32 + depth = torch.full((T, H, W), 5.0) + r0, r1 = 8, 16 + for t in range(T): + depth[t, r0:r1, r0:r1] = 3.0 + 0.4 * t # depth-changing square patch + + poses = torch.eye(4).unsqueeze(0).expand(T, 4, 4).contiguous() + node = GS4D_nodes.MotionMaskFromDepth() + (mask,) = node.motion_mask( + depth_seq=depth, + trajectory=poses, + input_projection="PINHOLE", + input_horizontal_fov=90.0, + threshold=0.10, + frame_gap=2, + dilate=0, + device="cpu", + ) + assert mask.shape == (T, H, W), f"mask shape {tuple(mask.shape)}" + + patch = mask[:, r0:r1, r0:r1] + background = mask.clone() + background[:, r0:r1, r0:r1] = 0.0 + patch_mean = float(patch.mean()) + bg_sum = float(background.sum()) + assert patch_mean > 0.9, f"moving square under-detected: mean {patch_mean:.3f}" + assert bg_sum == 0.0, f"static plane falsely flagged: {bg_sum} pixels" + + +def test_08_align_depth_scale_and_depth_edge_filter(): + H = W = 32 + new_depth = torch.rand(H, W) * 9.0 + 1.0 + # ref disparity = 0.5 * new disparity + 0.1 (i.e. ref = 2*new before shift). + true_scale, true_shift = 0.5, 0.1 + ref_depth = 1.0 / (true_scale / new_depth + true_shift) + valid = torch.ones(H, W) + + aligned, scale, shift = world_nodes.align_depth_scale( + new_depth, ref_depth, valid, mode="scale_shift" + ) + assert abs(scale - true_scale) / true_scale < 0.05, f"scale {scale} vs {true_scale}" + assert abs(shift - true_shift) / true_shift < 0.05, f"shift {shift} vs {true_shift}" + rel_err = float(((aligned - ref_depth).abs() / ref_depth).max()) + assert rel_err < 0.01, f"aligned depth off by {rel_err:.4f} (rel)" + + # DepthEdgeFilter: a vertical step edge must be masked out, flat kept. + depth = torch.full((H, W), 1.0) + depth[:, W // 2 :] = 5.0 + node = pointcloud_nodes.DepthEdgeFilter() + (valid_mask,) = node.filter_edges(depth, relative_threshold=0.05, dilate=1) + assert valid_mask.shape == (H, W) + edge_cols = valid_mask[:, W // 2 - 1 : W // 2 + 1] + assert float(edge_cols.max()) == 0.0, "step-edge pixels not masked out" + assert float(valid_mask[:, : W // 2 - 3].min()) == 1.0, "flat left region wrongly masked" + assert float(valid_mask[:, W // 2 + 3 :].min()) == 1.0, "flat right region wrongly masked" + + +def test_09_fuse_splats(): + n = 20 + voxel = 0.5 + base = torch.stack( + [ + torch.arange(n, dtype=torch.float32) * voxel + 0.15, + torch.full((n,), 0.15), + torch.full((n,), 0.15), + ], + dim=-1, + ) + cloud_a = make_splats(base) + cloud_b = make_splats(base + 0.2) # same voxels as A (0.15+0.2 < 0.5) + + node = GS_nodes.FuseSplats() + (fused,) = node.fuse_splats(cloud_a, cloud_b, voxel, "smart", 1.0, 1.0, device="cpu") + assert len(fused) < len(cloud_a) + len(cloud_b), ( + f"voxel fuse did not reduce: {len(fused)} vs {len(cloud_a) + len(cloud_b)}" + ) + assert len(fused) == n, f"expected one splat per voxel ({n}), got {len(fused)}" + + # Strong weight_a pulls fused positions onto cloud A. + (fused_w,) = node.fuse_splats(cloud_a, cloud_b, voxel, "average", 1000.0, 1.0, device="cpu") + assert len(fused_w) == n + d_a = torch.cdist(fused_w.xyz, cloud_a.xyz).min(dim=1).values + d_b = torch.cdist(fused_w.xyz, cloud_b.xyz).min(dim=1).values + assert float(d_a.max()) < 0.01, f"fused positions not near cloud A (max dist {float(d_a.max()):.4f})" + assert (d_a < d_b).all(), "weight_a=1000 should pull fused splats toward cloud A" + + +def test_10_sphere_splat_seed(): + H, W = 64, 128 + stride = 2 + color = (0.2, 0.6, 0.9) + pano = torch.tensor(color).view(1, 1, 1, 3).expand(1, H, W, 3).contiguous() + + node = world_nodes.SphereSplatSeed() + (splats,) = node.seed_sphere( + image=pano, + horizontal_fov=360.0, + radius=5.0, + splat_scale_frac=1.5, + stride=stride, + device="cpu", + ) + expected = (H // stride) * (W // stride) + assert abs(len(splats) - expected) <= max(4, expected // 20), ( + f"splat count {len(splats)} far from expected ~{expected}" + ) + + image, mask, disparity = GS_nodes.render_gaussians( + splats, IDENTITY_4X4, "PINHOLE", 60.0, 64, 64, + render_mode="fast", device="cpu", + ) + assert float(mask.sum()) > 0.0, "pinhole render of the sphere seed is empty" + solid = mask > 0.9 + assert bool(solid.any()), "no confidently covered pixels in the render" + rendered = image[0][solid] # [K,3] + target = torch.tensor(color) + err = (rendered.mean(dim=0) - target).abs().max().item() + assert err < 0.05, f"color round-trip failed: rendered mean {rendered.mean(dim=0).tolist()} vs {color}" + + +# --------------------------------------------------------------------------- # +# Runner +# --------------------------------------------------------------------------- # +TESTS = [ + test_01_interpolate_se3, + test_02_render_gaussians_shapes_and_empty, + test_03_fast_mode_anisotropy, + test_04_at_time, + test_05_build_splats4d, + test_06_split_splats_by_mask, + test_07_motion_mask_from_depth, + test_08_align_depth_scale_and_depth_edge_filter, + test_09_fuse_splats, + test_10_sphere_splat_seed, +] + + +def main() -> int: + passed = 0 + failed = [] + for test in TESTS: + name = test.__name__ + try: + test() + except Exception: + failed.append(name) + print(f"[FAIL] {name}") + traceback.print_exc() + else: + passed += 1 + print(f"[ ok ] {name}") + print(f"\n{passed}/{len(TESTS)} tests passed") + if failed: + print("Failed:", ", ".join(failed)) + return 1 + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/notebooks/test_gs_functionality.ipynb b/notebooks/test_gs_functionality.ipynb new file mode 100644 index 0000000..963714f --- /dev/null +++ b/notebooks/test_gs_functionality.ipynb @@ -0,0 +1,461 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "1613c89a", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import sys\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "root = Path.cwd()\n", + "if root.name == 'notebooks':\n", + " root = root.parent\n", + "sys.path.append(str(root))\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from GS_nodes import GaussianSplats, RenderSplat, splat_cloud_rotation, _read_ply_vertices\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "80ef195f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "splats: 1179648 sh_order: 0\n" + ] + } + ], + "source": [ + "def load_splats_from_ply(path: str) -> GaussianSplats:\n", + " data = _read_ply_vertices(path)\n", + " required = [\n", + " 'x', 'y', 'z',\n", + " 'f_dc_0', 'f_dc_1', 'f_dc_2',\n", + " 'opacity',\n", + " 'scale_0', 'scale_1', 'scale_2',\n", + " 'rot_0', 'rot_1', 'rot_2', 'rot_3',\n", + " ]\n", + " missing = [name for name in required if name not in data]\n", + " if missing:\n", + " raise ValueError(f'Missing properties in PLY: {missing}')\n", + " xyz = np.stack([data['x'], data['y'], data['z']], axis=1).astype(np.float32)\n", + " scale = np.stack([data['scale_0'], data['scale_1'], data['scale_2']], axis=1).astype(np.float32)\n", + " rotation = np.stack([data['rot_0'], data['rot_1'], data['rot_2'], data['rot_3']], axis=1).astype(np.float32)\n", + " opacity = data['opacity'].astype(np.float32).reshape(-1, 1)\n", + " f_dc = np.stack([data['f_dc_0'], data['f_dc_1'], data['f_dc_2']], axis=1).astype(np.float32)\n", + " f_rest_keys = sorted([k for k in data.keys() if k.startswith('f_rest_')], key=lambda k: int(k.split('_')[-1]))\n", + " if f_rest_keys:\n", + " indices = [int(k.split('_')[-1]) for k in f_rest_keys]\n", + " if indices != list(range(len(indices))):\n", + " raise ValueError('f_rest indices must be contiguous starting at 0')\n", + " f_rest = np.stack([data[k] for k in f_rest_keys], axis=1).astype(np.float32)\n", + " else:\n", + " f_rest = np.zeros((xyz.shape[0], 0), dtype=np.float32)\n", + " return GaussianSplats(\n", + " xyz=torch.from_numpy(xyz),\n", + " scale=torch.from_numpy(scale),\n", + " rotation=torch.from_numpy(rotation),\n", + " opacity=torch.from_numpy(opacity),\n", + " f_dc=torch.from_numpy(f_dc),\n", + " f_rest=torch.from_numpy(f_rest),\n", + " )\n", + "\n", + "ply_path = r'C:\\Projects\\camera-comfyUI\\screenshot1.ply'\n", + "splats = load_splats_from_ply(ply_path)\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "splats = splats.to(device)\n", + "print('splats:', len(splats), 'sh_order:', splats.sh_order)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c9fd95c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first xyz shape: torch.Size([1, 3])\n", + "batch xyz shape: torch.Size([10, 3])\n", + "sh coeffs shape: torch.Size([1179648, 3, 1])\n" + ] + } + ], + "source": [ + "first = splats.get_splat(0)\n", + "batch = splats[:10]\n", + "print('first xyz shape:', first.xyz.shape)\n", + "print('batch xyz shape:', batch.xyz.shape)\n", + "coeffs = splats.sh_coeffs()\n", + "print('sh coeffs shape:', coeffs.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdb51258", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rotation check: True\n" + ] + } + ], + "source": [ + "angle = torch.tensor(45.0 * torch.pi / 180.0, device=device)\n", + "rot = torch.tensor(\n", + " [\n", + " [torch.cos(angle), 0.0, torch.sin(angle)],\n", + " [0.0, 1.0, 0.0],\n", + " [-torch.sin(angle), 0.0, torch.cos(angle)],\n", + " ],\n", + " device=device,\n", + " dtype=torch.float32,\n", + ")\n", + "M = torch.eye(4, device=device)\n", + "M[:3, :3] = rot\n", + "rotated = splat_cloud_rotation(splats, M)\n", + "expected = splats.xyz[0] @ rot.T\n", + "print('rotation check:', torch.allclose(rotated.xyz[0], expected, atol=1e-4))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2efc4b71", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([2.00000e+00, 5.00000e+00, 9.00000e+00, 1.70000e+01, 3.70000e+01,\n", + " 1.14000e+02, 3.10000e+02, 6.65000e+02, 1.29400e+03, 2.69800e+03,\n", + " 6.05500e+03, 1.18850e+04, 2.25600e+04, 4.00610e+04, 6.72920e+04,\n", + " 1.02351e+05, 1.39929e+05, 1.71870e+05, 1.98916e+05, 2.24122e+05,\n", + " 2.51042e+05, 2.65383e+05, 2.60755e+05, 2.33589e+05, 1.92389e+05,\n", + " 1.53507e+05, 1.31031e+05, 1.19792e+05, 1.09082e+05, 9.60300e+04,\n", + " 8.77160e+04, 8.33950e+04, 7.75550e+04, 6.74730e+04, 6.37030e+04,\n", + " 7.14220e+04, 5.70690e+04, 4.32740e+04, 3.77760e+04, 4.02890e+04,\n", + " 3.39090e+04, 1.82060e+04, 1.59050e+04, 1.43550e+04, 9.91500e+03,\n", + " 4.23000e+03, 2.07900e+03, 3.27100e+03, 3.91700e+03, 6.93000e+02]),\n", + " array([-9.8898716 , -9.75400066, -9.61812973, -9.4822588 , -9.34638786,\n", + " -9.21051598, -9.07464504, -8.93877411, -8.80290318, -8.66703224,\n", + " -8.53116131, -8.39529037, -8.25941944, -8.12354851, -7.9876771 ,\n", + " -7.85180616, -7.71593523, -7.58006382, -7.44419289, -7.30832195,\n", + " -7.17245102, -7.03658009, -6.90070868, -6.76483774, -6.62896681,\n", + " -6.49309587, -6.35722494, -6.22135353, -6.0854826 , -5.94961166,\n", + " -5.81374073, -5.67786932, -5.54199839, -5.40612745, -5.27025652,\n", + " -5.13438559, -4.99851418, -4.86264324, -4.72677231, -4.59090137,\n", + " -4.45503044, -4.31915903, -4.1832881 , -4.04741716, -3.91154623,\n", + " -3.77567506, -3.63980412, -3.50393295, -3.36806202, -3.23219085,\n", + " -3.09631991]),\n", + " )" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "#splats.scale.flatten().cpu().numpy()\n", + "plt.hist(splats.scale.flatten().cpu().numpy(), bins=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "33b77bb7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAClmUlEQVR4nO29f3Qb53Xn/R0AQ2CMSAQpy5aByrTCWIwlipKWiSzHqaJ1ZNEOqx+n3ZNEjZo2zUl2tY3VbaKeSpUVlpH1Wm25Z7tysmo3m6TZo0Zu2t3oRxlbcqPqqPZaUcJIoikpVMIj0y4R2rIpQDI0BAfAvH8M7sNnBgMQpAgSIO/nHB6SwGAwGDwzz33u/d57FdM0TTAMwzAMw1QInuk+AIZhGIZhmPHAxgvDMAzDMBUFGy8MwzAMw1QUbLwwDMMwDFNRsPHCMAzDMExFwcYLwzAMwzAVBRsvDMMwDMNUFGy8MAzDMAxTUfim+wAmm0wmg2g0ijlz5kBRlOk+HIZhGIZhisA0Tdy6dQvhcBgeT2HfyowzXqLRKBYuXDjdh8EwDMMwzAR488038Wu/9msFt5lxxsucOXMAWB9+7ty503w0DMMwDMMUw82bN7Fw4UIxjxdixhkvFCqaO3cuGy8MwzAMU2EUI/lgwS7DMAzDMBUFGy8MwzAMw1QUbLwwDMMwDFNRsPHCMAzDMExFwcYLwzAMwzAVBRsvDMMwDMNUFGy8MAzDMAxTUbDxwjAMwzBMRcHGC8MwDMMwFQUbLwzDMAzDVBRsvDAMwzAMU1Gw8cIwDMMwTEXBxgvDMJPOobP9eHT/KRw62z/dh8IwzAyEjRdmUuFJiwGAg6f7MBDTcfB033QfCsMwMxA2XphJhSctBgC2ra1HJKRh29r66T4UhmFmIL7pPgBmZrFtbT0Onu7jSWuWs3V1Hbaurpvuw2AYZobCnhemIOMNA21dXYdXdj5mm7g4lMQwDMNMJmy8MAVxCwONxxg5dLYfbUd7OJRU4Ti/87H+ZxiGKSVsvDAFcdMujEfXcvB0H9Im4FVQdCiJJ8Lyw/mdj/W/EzZ2GIaZTNh4YQriFgYajxiTtm3f1Iitq+uKmrRY9Ft+OL/z5roaKACGEkkcOttve/7Q2X6saD+JFe0nxfcsf6eyN27PkR7bdsXCxg/DzG7YeGGKhiYMADkGjXMbmlScxg9NYm1He3DobL/rJMSZKuVPV/8NmAB0I4O2oz0ARsfEvs7LiOkGYrqBp4/0YPvh89i2th4hTUUimULHiV6kTWs/JoCYbozLUOVQJMMwimma5nQfxGRy8+ZNVFdXIx6PY+7cudN9ODOKR/efwkBMRySk4ZWdjwGwJpKOE70AgB0tDcI4kbeROXS2H3uO9MAEENJUBP2+gttPJofO9tsyoehvzoopDBkLaRPie6LvPa4bMGGFBds3NQIAnj7Sk7OPpkg13k2MYCCmi++9ua4GZ65eB2CNHaDwd0LfXyKZQkw3xHvy98cwM4PxzN+cKs3YkCd456TglgZ98HQfYroh/nZu49zf1tV16DjRK15TTGp1oWMaD85wlFOzwYaMhdMgJU+JglHdEn2XsmHTdrQHcwKq6z67B+Li72QqjR0tDTnnmozjg6f7bM9tP3wend1RVPk80I0MQpoqPHP8fTHlwmTdp5jiYM/LLKTQRebmXRlrX/JEV8z+xusBGe8xFTpWt/cdy1s026DzDVgeFTIaAMtbRt8znc/muhocvxiFCUBTPRhJZURYSFNHXyujqR74fV4Ao16XfZ2XMWxkEA4FEI0NI6B68OA9c2yGj1cBWpvCOLBlZQnPADObyXdPG8s4maz71GxmPPM3Gy+zkEIX2WSvHmjVTBOOc/8r2k8iphtQAOzd3Ihz14Zyti9kHE3Gcbu9dqz9FXtclcj2w+eFMQJYHhcAkG8UG5eH0dV/Q4yjX8V1ZLIbREIBDMSGbfv0KBDPu5HPyCm0/e7WJTPqvDPlgWy8y/dIelxTvRhJpXOMaPa83DkcNmIKUihUcyeVUeUJfc3i+ejqv4FEMoW0CZy5eh2P7j+FoUQSupFBx4le2/uYsDwhg3EdaRM4fjEqXh/TDURCWsHjkkNCxRy/0wsz3v05w2Uz6WZFYlwyKKy/vRg20sKAOXYxio3Lw0gkUxhKJG2GidNwAQDTLGygjMdwoe1n2nlnJp9iFiFOb2xzXQ0SyRQAe3kHum9GYzpMjN6jaN/nrg1hMK7j3LUhHpdTAGcbzULkDKBCKaduKa/0uNtraEKP6QY6u6MYiOmI6wZCmqWDGIjpGM5OUjHdwIr2k1izeD5CmoqQpmLb2nq0NoXhVYCA6hGrH8pSkWuEOI9rrAwl5zHv67yCgZiOfZ1XXDOgEskUQpqK5roa189K2TN03DMJOpejPhdAN9LYsDxs266r/0b2OXfDQ1M9iIQCACzjlMJEk8W8YNUdpUvnG9/y85yOXX6M53sZq+yCfO3v67yMgZiOM1ev40LbepGA4Myc3LCc7lFe2747u6NIm9bvYo5/++HzPL7uADZeZjmFLm7ZGJGfz1d1N5FMQVO9CGmqMEJMAEG/DztaGhAJaeLCBywD5tjFKNYsno8LbesBWB6aOQEVjy9ZgEhIw46WBgT9PsR0Ax0nevHo/lNC8Cs/BuRP35aP+ekjPXhozwvQjTQAa1LetrYeXgVIm5ZR8/SRHuFVeenyW+J1i3Z2Yvvh8wCsG9mFtvW40LZ+Rqyy5In83LWhrIcsbdvmpcuD0FTLANFUD7atrUcylXbbnUD2wtA5nSy6B+JFp0tvP3we9btGvz8g//iWn5f37zZpcvG9qYe+F7r2C53recEq228n8rVPRngylSn4PqsW1WaF6aZtgbM0XC00WfmgbMuBmI7jF6Oc7n8HsOZlllPIrUphoGQqDb/PK4SV1mMZ+H0eofcYK42awkjkpZAzjhQA1Zpqm9xIGEpu3K7+GyLkRGLPZCqN4WxYw00QTK9rrqvBS5ffypmMidf3twptTlq6GkKOY5Ifz520Fdv5uBOcx1+KGLr8vZ+7NoRjFwuvFmU01VrzjDfUUyoUABuWu4t4D53tx77Oy+JYFQBhyUNXSLck67VWLaoVKf70fs6w5ra19Tkp5cydUUiPNno/8KI2WJUT+unqvyFCPIBd7C1fY5Sun0ylbcL0+2vvwqVoHCZG9VpNkWpcisbFfUK+dxXznZPGD4DtuGfCAmgyYMEuGy8TIp8hQ4ZJSFNxa9iwTfCANZnVBqswEBsWgYZl2boedHMnQpqKC23rcehsP756tCeviFOBXSDaFKnGawNx22OqR4GRMcUNhCYg+Qbhti+ZSCiAV3Z+POc19J5ypksx0A3SzegoRtAnpx7TcZOYudANbjxiwUNn+11rsZQzNJkU831oqhe7Wx+yGdVu+yPWLJ6PF3p+BSNtIhIKIJEcNUypnoxHscYaQat16/0s8TCt1OWaNwdP92FesAqXonHOkpoAhZILZLE/1Y1yuz/J1z99N3SN0fcYCWlorqsZlxEvI485Z5IC/b80bL+fPDPGNT0bYeNlFhsvE1W8uxUio8fJ+zKRlTYp8+mGonoUPLnsvgnfJJzIEwsZRg/teTGvl8WNjcvDOHP1+qSFNeSbKYXDgNEbsVtxtY3PvYzugXjerBznZJvPiyUbh2Olw1cSsrFAFMpgovOVTKWRSps2w4Oep3Pmtm/AGqsZ03R9Tp4QFQDXJO8dTVpOg9irAH3PtnJWigv5zgldF5Z2SsnxwHSc6EViJIVU2kRA9bpe92SYHL8YRSDrtSWjdGm4WhiWxdwD5DHnNIr6nm0FANTv6hSGUfumRteFQjHX6WyEjZdZbLwUU2tAdqXTqnFf5xVx4T+zeXTVOJQYybkh5LvZuyF7ZYhCnpCxUmrHIqSpourreNi4PHzHBhVVjpXThuVzKddDIW8KPTeWMUFeJuf7ua00n9ncKL5f1aPA51Vs9VOA/Oe/0lBgibsLGdZkyLhNTB4F8Cq553a8OCe1vZsbc0KjFNoio8Zp3BKF6iCNFeYt1URYqn2PVTV50c5O21i1vm+vCNHK1w5df/OCVXhtIA5F+k6coc7R0HMGupGG6lVgFHtTy2KVCxgS9zbVo6Bt41JbGFbOsLOuRQ/8Pg/WLJ6fYyyFNFU8DoxdgmEmGj5svMxi42WsmiUAhIeFiIQ0ERumVaRbGIUoZHyUM6pHQdo0XY2jyfpMzptgJKSJG7OmeoRGRz6miU6c+Y65Ur+fiULagTtx+082zu+aive1NoVt+iu30AFde3LBP6cBJhs+TgPA6Tnd13kFw9lssXy6IKdGzDmBlqoAm9tnlQ2YB//0hzAyJjyKNa4L2RdNeULVd0KhxZRb/SNN8uy4Qecvn/dTXhgqsMLvrw3EEZDqGhX6visdNl5mmfGSzwIfFbZZ3hO5l5DMxmwK7PGLUfi8CoJVPrEiGQtN9eLxJffihdd+dcer15mI6lGQypjCMCzFGXIrCkfcqSerUiCB93jFxzITOVfkCSh0rTi9Mj6HwaplKwm/NhDPeQ6wJrQ5gVzxOF17TqE5hVjmBatcqxPL17nTe0Hb0f7kXlYTFZG73Z8oxCaHfHe0NNj6nl1oW28zboDyEYkTzsVHsdd4vrG2cXnYViBShs6JrEEM+n3seSkl3/jGN/CXf/mXGBwcxPLly/Hcc89h1apVY77u+eefx5YtW7Bp0yYcOXKkqPeajcaLvCpqrqsRcXeqgCoLPylLQr6x0UUgr1jG4xG4E+/BbGK6DInxVq9lxkchbcxkvkeprjHVqyCVNm36DVmgvHH5aIbOeLKpRntSWcYd6d8WVNuNbbounNfHeMLTE2WiBmuhBADnQmI8390z2SrjpM9JpjLi+Mh4cWqrZhLjmb9LXufl7//+7/HlL38ZbW1t+NnPfobly5ejpaUFb7/9dsHXvf7669ixYwd+/dd/vdSHWPHIBdrkQknNdTXwKkBYKhT20uVBvH1zOKdR3kBMt63sxnOjZMOlOKbrNLHhUlqMTGkNF3qPku1bMlwAy2CQ3+/YxSjqd3ViX+dlEdaRG69SDRRnjZvjF6PZ+ilpREIahg1LuO+c3OmtnB+x1OfU7T2LodBL3AyX1DjeZF/nFXR2W56XkVRGFHZUYIXwth8+j2PZ80pFImVmU52hknteHn74YXz4wx/G17/+dQBAJpPBwoUL8dRTT2Hnzp2ur0mn01izZg1+//d/H//6r/+KWCzGnpciob40gTFirwzDMOOFql2nMiaWSTVPnN4I2dtAQtb2Y5d4oTMB5DRsymQCcpMBnHWHKlEHUzael5GREXR1dWHdunWjb+jxYN26dXj11Vfzvu5rX/sa7rnnHnz+858v5eGVJfks57HK+FO56a7+G6jWVOhGBnGH4aJALvhuh2LKDMMw+YjrBoyshqt7YLRYm9MkkY2UtGni6SM9bLhMEN1IY8+RHmx87mV4FOsOrnqs36RXonYsAAq2SZlJlLQx4zvvvIN0Oo17773X9vi9996Ln//8566vefnll/Gtb30LFy5cKOo9kskkksmk+P/mzZsTPt5yIF9DQLfHnapzamoY0lTXeHGhWweHFhiGGYuJmB9ss9w5ZCwSRsYUIuiOE71IJFPImCbWLJ4/azpdl9Vy+9atW/id3/kdfPOb38Tdd99d1GueffZZVFdXi5+FCxeW+ChLS74Gg/Lj2w+fx6KdnXg62yODQkNzAj54FauIWfumxhxvSiHPC8MwDFNekIcFsMTASvYxTfWIztdBv094w2QdDAmsZ2r/pJJ6Xu6++254vV689dZbtsffeustLFiwIGf7vr4+vP7669iwYYN4LJOxPAI+nw+9vb2or7dP6rt27cKXv/xl8f/Nmzcr1oAZK+V5XrAqp0aLTEy3BjN1NXV6U3gBxDAMUznIoTYSAwf9PlHyguaLfZ2XMWxk0FxXY/PIOwXWM4mSel6qqqrQ3NyMH/3oR+KxTCaDH/3oR3jkkUdytv/gBz+I1157DRcuXBA/GzduxL//9/8eFy5ccDVK/H4/5s6da/upVPJ1se040YuBmG6LMRORbCaR/HcxbdkZhmGYyiOZSiORTCGkqWKhWxv0C88LzRfJlJXlJVcsnknZSCUPG335y1/GN7/5TXz3u9/FlStXsG3bNiQSCXzuc58DAHz2s5/Frl27AACBQACNjY22n1AohDlz5qCxsRFVVe5tzWcKzpARGTPxbCnxpojVcl12JQ7GLWtcUz22NL0F1QEwDMMwlYt0q4emeqCpXgwbGcR0A7eGRxMy3OQGfp8Xr+x8LK92stIpadgIAD71qU/h+vXr+OpXv4rBwUGsWLECL774ohDxvvHGG/B4ykp6U3LyVaukH6K5rgYD2bL9Qb8Pn/zwQhw8PYJfxUerYaZNy5hxhojIqGEYhmEqE69HwX1zAmKuGEqMiPB/2gTaj1+yzRsk3lVgaR9lDp3tt3lsKh1uDzANyN2FC1WrlPtfjLfzsbNyJFfBZRiGqTzGajb7zOZGW9Yp4WxyWQltBcqmzgvjDrn4WpvCNlefMx7ZXFcjXnPm6vWcui2E1RkXIqwE5KYnsuHCMAxTecQKGC5NkWoRCkqm0lAwGmpKm7DpJ4cSI1AwWlG90kNHJQ8bMblZRM7wEOGs5UJpb2SQuA1guWlb90DcFiNlGIZhZh7UzPNSNI6l4WoAQCKZgm5kQLEUOcvo4Ok+0TzU7/OiNuiv+NARe16mgHxZRE7F97a19QhpKoYSSaxoP4nmuhqENBVVPqtBV0hTc/ZtZR+NmjXsYGEYhpnZ+H1ekX16KRrHKzsfw46WBlsdrzkBa74grYumekX37m1r63HwdF9FZx2x5mUKcAp03fpPOKvlApYWxvm/s809wzAMMztQvQoyGdPW9TsSCmAoMeJaJZ30LQMxHQqA6qzxQgvqcuuBxJqXMmPr6jq8svMxdPXfsPWfmBesQv2uTmw/fF4MJsAacCFNRXNdjdC5KLA0MG8M3eYquQzDMLMQI23mdP2OxobztndJptLYtrZeNM6M6YaQMFR6DyTWvJSIQ2f70XGiF4DVynzr6jrhqqMB8/SRHgBW6/jqrMFC2wKWOtyEFbtsbQrj+MVoXuGWs6srwzAMM/MJqF6hZ1E9CoJ+H5KpNHQjA7/Pi62r69Bxold48KmtQDl5XCYCe15KxMHTfYjphrB0gVEPzNbVdTald0D1ioElxyFJAzMnoOLM1etsnDAMw8wCik28oP51CqzwETVn3N26BJGQhh0tDWI+IY++PCdVMmy8lAgyPCj84xToktvumc2N2N36kMjll4W9W1fXIej3CcOm0Hhmw4ZhGGZm4M02X8yH6lEQ0lT4fZbXxYTV+yhtAscuWq1hyLPSdrQHMd1A0O/D/bV3AQDmBSu/Wj0LdqeAFe0nEcuW+L/Qtr7gNgqAvZsbAVjVEpOpNFIZE0baFEXtnHDIiGEYZnZBISK3wqUkQaBGvlSwzvm/WyPg6YQFu2VOoeZY1Zoqwkox3YBuZGBkLZZ83aTZcGEYhpnZOD3vRsbMW3E9kUzlGCpbV9ehtSksNJTUwHHPkR4cOttfcU0bWbA7BVBqmrPhIoWHDp7uw5rF89HVf0OEmJrraoSw6uawwfVbGIZhZjghzYeYnnJ9bjxTgJyNNCeg4vs/eRNtR3vQ2hRG37OtACxvP+2X5qKBmI62o1YiSbl4Y/LBnpcpgIS6gDVghhJJ0RyLDJmu/hu2dOqu/hu40LYeF9rWY24gtzgdwzAMM3NQANwadjdcxiKkqaISuxOqvp42rcxWYkdLg9Blbltbj21r64U0oRIEvex5mUIoFAQAtUG/sGxlr0xzXQ0G4zoAE/W7OtHaFMaOlgZ0nOgt2JwLsBTqCvKHlxiGYZjyxEThezfZJgHViwfveZ+tWOmOlgacuzaEzu4oFlQHMBAbdt2Hz6MIj8uOloYcDSbtQ+6rV66wYHeKOHS2H/s6r0A30tBUL3a3PuTqlpM7SQPWgL22v1Xsg2rDMAzDMDMTj2Jv9SLrVqga+9s3h0V4SFM9olCdXFXXes6Lx5fci67+G7bXAJbo1+dV4Pd5y6LyLgt2pxk34ZPcGKs2m6ZG2xw6248V7Sdt/YwIM7u/Q2f7RSySYRiGmbk4NY5pE9jXeQUbn3sZTx/pwUBMR9DvE94YZ4VdqqoLAH6fBwe2rMS2tfU2wwWwtDG6kUFMN7DnSI+Yf6i/XjmLd9nzUgLIe+LsXSRX3JUtXGf/IgA27wtgWc9k/DAMwzCzG6oD4zRcNNUDv8+LRDIFI2NCUz24svdJm1c/EnIPLTnnn6n2wIxn/mbNSwkg3YocN9y6ui4nTETNGklEpcCymM9dG8oxXobZcGEYhpkV5KvdJT+uGxloqkdUzaXndSMD3chIqdWWziUxkoICYMPyMA5sWSmMGfL0J1MZDCWSSEmhqHLufcRhoxLQ1X8DadP67YRCSgBEdhH1L9q72Yppur0uoHqgqd5SHzrDMAwzzciGi9wqwGnQkFaFsobCoYB4jS+bfqQbacR0A0bahAngzNXrOHS2H4lkSnhvdrQ0oDZYZasr5vd5be1qyg02XkqA3LHTqX+Ra7zQAAppqhBj0evlrDcSY/l9HpsehmEYhpnZKICtVYA8NySSKew5Mlr+fzBuhYIyJoQR4iSuG9jXeRkx3cBwVu9CGa/OfVPdl3I0YFjzUmJk11zQ70NzXQ26+m/YarxQxUN6fOvqOmw/fB6d3VG0NoUBjPar0FQvkqk0F61jGIaZJWiqB8NGBiasOWA4289IZuNy+1zhfL1TG0OP1wb9Yt7Jl9E6VdoXzjaaZmRvC3lhAEsEdeyilUO/dXWdsHSpmdZATBeiXjn0dObqdbFv3WDDhWEYZjZBhouFiYBL00YyWp7Z3IhISMPG5WFbNlJIU23SA68C7G5dIhbSh872Y+vqOjRFqgGMhqtIi1lusPFSAuTQEFXX3dHSIJ7v7LYG2dbVdah2hIGSqQwe3X8K84JV8CqoiGJBDMMwTOmQ16u6kUEyletFAay5hRbGZ65et70u6Pdhd+tDQh9DUoV9nVcwENOxr/MKDp3tx6WoVfyOFskB1VOWrQLYeLlD3Gq6yJoXYuvqOmxcPtoUi9jR0iDKOnsVKyd/IKaLcs7kdclT+ZlhGIaZZeTzvtPcIldzB6xidNGYjnPXhrCjpQFB/2iiMZXg0I00Dp7uy6nyO2xkylLzwsbLHeJsspiPQ2f7cebqdVT5PELtDVhGTfsmy83XvqnR5qEhYmO0BWAYhmFmNyFNRVf/DRw625/jsU9lrEyjzu5oTtIIoXqUbAaSPatVbtxYTrDxcoe4eVncDBqyhHVJ3e1Mm3arBbOjpYG9LgzDMIzAbU5IpjIYiOl4+kiPrQEjYIV+FABVPo+ooptIpoTG0qtYYaWYbmAkNVpTzKMgZ34rF7hI3R3iZnCQAIq+cGdOvd/nxba19eg40YuYbogBRL9VjyIqIzIMwzDM2Jguf1k8vmQBuvpvYCCmo6v/BpKpNHQjA9Wj2IyTjhO9SKYyIpRkmpiWHkfFwKnSkwA1yqJ0Mydu7QIA4KE9L9iaaVGM0lnLRY5dMgzDMIwTSqf2eRQRJiJCmor7a+9C90AcTZFqvDYQF88/s3m0xhjNVZrqwUgqgwXVAQzGh9HaZFXlLTWcKj3FOGOIj+4/he2Hz9vSpclNJ8cY/T57bJFU4DtaGpBMWVURY7qRU6SIYRiGYWQonTpjmtiwPIxISLPNG68NWFlE3QNx+KSyvR0nerH98Hks2tmJt28OQ1O98Pu8aN/UiMH4MNLmaIZsOcGel0lA9rzIhefS5mhxH2exOtlNBwBrFs8XmUVrFs93LTTEMAzDMGOhAKjWVKxZPF8UP93Xedm1UF1IUxGXkkLkuau5rgad3VEsDVfjjaHbACwdZqlSp8czf7PxMslsfO5ldA/EEQkFACi2yoUHT/eJDtLOirtyZ2kaPPlQvUre0s8MwzDM7MTZ0FGWKhw625/VtKSFl8arAO2bGtF+7BKMbP61mg07UQNHAFjRflLMT6Wststho2mECvxEpXbjsmdmzeL5UGDpWAZiOo5nK+vGdUN0CF0ari74Hmy4MAzDME6cOhdnrbELbetxZe+T2Lu5EZrqQcYEzl0bEnVfFACGlFbtrO9STtV22XiZZFqbrEJ0AdUjdDCyJoa6SBOUwmZitEMoxSYZhmEYZrw0RaoR9Ptw7tpQThFVQs96X45djGLN4vmIhDRsWB5GSFNF2xoq97GjpQGRkIa9krh3uuGw0QQZK8NIfh6wBkFzXQ1eeO1XMDImPAowN2DFJI9fjMLEaJySs4sYhmGYYvEqwILqAAZiw1A9iqjZIoeRQpoPVCGGUqUhnhvVYsoyh21r63Hu2pBoEkxhpLHmv4nCYaMpYKzKutRfgp5/Zedj6Oq/IeKKZDIeyxouQG5uPmDFHxmGYRgmH2S4AFbYh3SVAalabkxPiQzW4azhonoUeBXg5rAlY2g/dimncOrxi1GkTdgK3xVbWb6UsPEyQeTKunJ69Ir2k1jRfhLbD5/HniM9ouHVo/tPobmuBlo2TBRQPTkeFq+CnPYABreQZhiGmdWo3sKL2AFJY0lQI0a5OzTh8yhQAPi8HqTN0V5JRsa0GSWHzvaLRbVPOga3yvJTDYeNJgFKg5azhNwyhtzSpJPZUsx+n1ektb19c5iNFoZhGGZcqB4FPq8Hw0bali0EWIaInFUEIKcY3dJwNd5NjIg5qu1oj5jHVI+CjGmWtGAdh42mGLJCW5vCotBca1PYZumGNBXJVBoDMR0dJ3ptyu/drUsQ9Pvwwmu/wkBMR3pm2ZMMwzDMFBD0++D3eWACeOnyoE2su3V1nc1wCWkq/D5v1jhR0PdsKz754YXieeowrWS3TWXMsipYx72NJohTsJRPtCQXmyOBVCKZwor2kwCsMBHFDwnZ6aKpXtFngmEYhpm5UF+7iRL0e5FIWvOFbow2auw40Ys1i+eLiAAtrOUidoBdy0KazXnBKlyKxhEOjbYKKAc4bDRB5H5FzXU1OH4xioDqxe7Wh4QhQ4V9nFlEsgKc9C9WqwATMT1VsmNmGIZhZjbPbG7E00d6itqWdCvOzFg564j25VWAvmdbS3bcAIeNpgRZsNTZbWUM6UbaJnSKZ42VQLa/BBWhk3PprddZHplbw2y4MAzDMKOMlXCqSRlFlJ06Vi88mou2ra1Hx4lem5yBHntozws2I6jK53WtFzNdsPEyQbaurhOpZLIbrbmuBoBlvVL5Zb/Pi5huoDbox4W29TiwZSV2tDSgWuoenUylUeWzMpGaIoUr7DIMwzCzg7GiSLqRFs17jYyJg6f7sLt1CbxSlpHTAHp8yQIhWUimrMVzMpXBo/tPoeNEL2K6YasDo8C+OC8HOGw0ScgZR+2bGm2FfQBkw0oePL5kAbr6b2AokRSDQ1O9GDbSIpTkUcYesAzDMEx54+w1VEpC2cVwMpWB3+cReha5b558XOGQZmsWTNu56SybIuXXmJE9L+OEaro43WfkcaGSyl39N5A2gTNXr0thpQw6u61eRsOSVTuSStsGOBsuDMMwlc9U3MqV7M/9tXdlPSZpxHQDL10exGBcx/21d7keV3NdDSIhDTtaGvDKzsdECwC/L9cseGPotqjaWy7eFzZexkm+yoJd/TfE30OJpBgYyVRG5MlT00UFVpEgTfWKtOoxahAxDMMws5RC04OZ/XH2xNMNa+65FI0Lr4xMV/8N0R1arqq7o6XBdftyKEwnw8bLONm2th4hTUUimcKhs/3CE9NcVyMMEN3ISANj1Pbe0dKAdxMjMGFVMvT7PLjQth6rFtViTiB3sDAMwzBMMR6cgEOkq6keeBWrWfCOlgabAaSpXtf0aCLo92Hj8tG6ZRQqIp1nOcDGyzjZurrO5j6jL76r/wbaNzUipKnQVA+GEiOilgshp6MBENV1SSDFMAzDMMXSFKkWBsbu1iU2j0ltsAoLqjUA1twjGze1wSqRCp1IpkTm0aGz/Wg7arW1oW7TaxbPR9vRHmw/fH7KP18h2HiZALL7TP6bqubWBv0i7uj3ecXgcrrbdCNj086QpcwwDMMwY/GLt29hR0sDgn4fzl0bsj03EBvGQEy36SxJqiB7XWK6gVvDhvhfbmtz7GIUnd3RsqqsS3C20QRxVtiV/weAfZ1XXPtLUOE6glxyB0/3obmuBmeuXkcimcqpsjiVqnWGYRimMghJBVABK1tVAUSfonnBKnRn9TBUVJUyYVctqhX9i8hrE9cN21yzcXlYbF+qnkYEZxtNAc44ofz/1tV1qA1WwYRdyAtA5NQTMd1Ax4lezAtW4djFKGK64Voemg0XhmGYysfpXB+rCJ0bqvQip+TANGHrU0Qpzl7Fihocv2h5Uo5fjGLr6jq0b2pEJKSJfVVrqth/U6QaB7asRN+zrSU3XMYLGy8TxKm8dgp5ScBLKdSEWxpaTDeEZQwAkVCgtAfPMAzDTAvyQnQiNb08Cgr2P9qw3KotRgvqZCothLtbV9cJ7Qv9JiEu9T5as3g+2jYuRSSk4ZMfXpi3PMh0w2GjSUTudwTAVgDIGV6ifkh08qkhl6Z64fd5WMDLMAwzwyB/Sakm3Y3LrVAQzTFykTqai+hx52/azqsAcwJWKEqeyyIhTaRWl4rxzN/cVXoScTa42td5GTHdQEw30Ha0B+euDdk6eJ65eh3JVBrDRgZGxoRXsUow+30e0f2TYRiGmRmU6pZOzX/PXL2OM1evi8XvKzsfEwvmRDKFgZguHqfF9mBcF5oXBda8Q8aOs1ljOcGelwngFOvm28bZ2ZMMEtmylYW4kWzL8aXhavzi7fdySjQzDMMwTCE01YPaoD+vh8UZBZgXrMJrA3EEVC8AU7StoVY3U1nXhQW7JSZflV3nNkRTpBqRkCYq6ZJHJRLS4JOEV9HYMNIm0D0QZ8OFYRhmFjFZZTL8Pi9e2fkYuvpviHotAzEdL11+y7XI3BtDt7Pta9KitAd5YNqO9pSd1oVg42UCFFMmmbZ5ZnOjUH2vWlQrDJg1i+fjlZ2PIegfjdzJLjDqV0GM1eKcYRiGqVzGIxPQVI8t4wgAVK8iehUB1hwkG0TDjgUxLcIB2CrpXmhbj72bG4UBs+dIeRowPCNOAGeZZDc1Nm0DQFQsPHi6D2euXhcNGwGIPhI0xhRYA2nv5kahGgdga0/OMAzDzDw01eOaOr1xeRiRkAZN9WYfUXIyjnyOF1IatKZ6oABYFqm2zVO0wCaD5ULbegCjfY6qs3VfTKBglGG6YONlEug40YuBmI6OE705z+3rvCIs6nyemlvDVlEgrwLs3dwoBlG5VTRkGIZhSsewkXFNnX79nQQAIJW2FrFOWUFIU+H3ecUimRbUAHBl75O4tr8V7yZGbHKHravrRJIJ9emTF9q0sHarDl8OcLbRJJJMpfHo/lM2Ia/sqqPyzeSeA0bLMZM4CrCq8DqrHDIMwzDli6Z68fiSe3HsYu6iU/UoSGXMMe/p+Z7vdnSMlmmKVOPYUx/FobP96DjRi6HECPYc6YEJa2FNySXObFgyVtLmqGeF5iKaw8qlCaMb7HmZBHa0NCAS0myWLyGHfo5nK+gS1I06EtKEqpt6TYw1yLkFEsMwTHngUawCpGeuXkdTpNr2HNXwcjIaAsqPrGtx3vMVAK/vb8Wxpz4KYLRpsG6khScfgK3yuyx3kBfOcp8+WkSXY2E6GU6VHieF0qS3Hz5v6xkhW7kHT/dhKJGEbmSgqR6MpDIitz6ZSgtNS1OkGr94+9aYGpeJVGZkGIZhSksxfejyGTROQpqK+2vvQvdAPOc1G7N98+Q56dy1IRy/GEVA9WB36xIAlvclmbIyiXa0NNi0mm5z2fbD54X3aCoK08mUXar0N77xDTzwwAMIBAJ4+OGHce7cubzbfvOb38Sv//qvo6amBjU1NVi3bl3B7aeafGnSh872i54RZ65ez+l19MrOx/DgPXMAAKm0KXQwsuECAJeicfh9Y1vkbLgwDMOUH8XcmmUjxJlZKpNIpkTIyMiYYrtQtiDdivaT2Nd5GQMxHXuO9ODM1eswAdQG/SLsY3ljMojphm3ecnpiCFlrWY5aF6Lkxsvf//3f48tf/jLa2trws5/9DMuXL0dLSwvefvtt1+1Pnz6NLVu24F/+5V/w6quvYuHChVi/fj0GBgZKfahFkS9N+uDpPjFo47ohwkHydpei1iBMZavpAsgxVFqbwmAYhmFmB2b2RwFy0p9TLqtU6v5M1duHs4tfE1bjX2dPPeq7JwtvSdC7/fD5nPAQlfPYuDxc1pqXkoeNHn74YXz4wx/G17/+dQBAJpPBwoUL8dRTT2Hnzp1jvj6dTqOmpgZf//rX8dnPfnbM7acrbLT98HlbryIaYACEq27jcy+jeyCOpkg1PvnhhaL/BLUJ8Pu8WLN4Pl66/BYXqWMYhplFbFwets0hgJU6TfMCPUc1v0iC8PiSBaL0BnnyQ5oqslbdoNYAVDR1qsND+SibsNHIyAi6urqwbt260Tf0eLBu3Tq8+uqrRe3j9u3bMAwDtbW1rs8nk0ncvHnT9lNK8oWNuvpvwIRltERCGpKptLCMadt3EyMALOX4niM9wnCJ6YZw6x27GGXDhWEYZpZx/GI0p1YLSQoObFkp6q4MGxnxeG3QjwNbVoo6LcVIDoDRCEJrk1U/prmupuwFuk5Kary88847SKfTuPfee22P33vvvRgcHCxqH3/yJ3+CcDhsM4Bknn32WVRXV4ufhQsX3vFxFyJf2IgeX7N4fvaR0UGYSKZw6Gy/reKhCa7jwjAMM5uRbRXyuHgVeyZSTDdw6Gy/yGpdFqmGAmub5roaPLTnRSza2Ynth89jzeL5ooK7G3L9l1d2PoYDW1baWgmUczsAJ2WdKr1//348//zz+MEPfoBAIOC6za5duxCPx8XPm2++WdJjyidyosdpEPh9HkRCGkKa1YCR8u1bm8JiYHoUBclUGiFNxcblYU5/ZhiGmUU4RRtGxkrmcJby39d5Wcwx7yZGYAIYSaVx5up1kRp97GJUVHDv6r/h+n75Ige0sJZrvpQ7JTVe7r77bni9Xrz11lu2x9966y0sWLCg4Gs7Ojqwf/9+nDx5Ek1NTXm38/v9mDt3ru2nlLi1ApCRPTCJZEoYJwBEk6zHl9yLSEiDkTFFuAiwquuSwcMwDMPMbPIJTknAS+hGBivaT2JF+0k019XYGvw668WENFV4+52QeNf5PLUSGKtnXzlRUuOlqqoKzc3N+NGPfiQey2Qy+NGPfoRHHnkk7+v+4i/+Anv37sWLL76ID33oQ6U8xHFDlmvHiV5XI0b2wJCWJej3iYq6gBUuokEkP0av3dHSwF4YhmGYWcyySLXoS6SpHqGhpFpi1Jfoyt4n8Ex24bujpQFBvy8nLVrm1vCoFlNejOeLKpQrJQ8bffnLX8Y3v/lNfPe738WVK1ewbds2JBIJfO5znwMAfPazn8WuXbvE9n/+53+OPXv24Nvf/jYeeOABDA4OYnBwEO+9916pD7UoyLMCwNX9BljemUQyBU212ovPC1ah7WgPIqEAvIqVirZ1dR0utK3HxuVh8RixdXUdAkVUX2QYhmEqE8oayscbQ7fx+BIrQpFKm8KQobAQZQfJGpatq+uEZ0ZOlyacVXXzhZEqgZIbL5/61KfQ0dGBr371q1ixYgUuXLiAF198UYh433jjDfzqV78S2x88eBAjIyP4D//hP+C+++4TPx0dHaU+1KKQvSP5XGxU4n8klcaOlgZcisaRNoHB+DD6nm3FgS0rxbYHtqxE37OtWLWo1pZ373QoehRwOIlhGGaGUBusKvg8ZZ+asLQww0YGAdUDTfWKsI+b8dHVfwNp0/LmOyMD5PGfE1DF/5UUKpLh9gCThFz/BYBoeEVpaJ3dUSwNV+PdxIhrawFn3r2mesZsEcAwDMPMHBQAAdWL4awI1w25NovcbJHmlLHK+9NcUy61XWTGM3+z8TJJyMYHNbZyDirahgao3+cRWph9nVcwbKSxLGIZONQHiWEYhpkdqF4FRtq09bxTvQpgWt4X6lzd1X/DNrfQ4pkWyhQaooa/zm2cry8X2HiZJs+L7G1xs2jlbQhZPwNAVEZc0X7S1oGaYRiGmfmENNVWUVfGbW5xm1echguQ3+NSqNnwVDOe+ds3Rcc045HbjBeKH84JqMIoUTDa+OrpIz0ArIJ2j+4/lTN4qV4MwzAMM7Ohiu1OqBIuzRsHT/chkUzZDBcF+T0uQG6zRWcT4UqBjZc7xGm1FvryScgb0lQE/T7xmu2Hz4ttjIyJgZiORDKFvZsb0XGiF4DVH4kMHIZhGKa8UT2KrXt0scR1A8lUbouYjcvDoggqCXQHYrpoSUNSg2pNtc1DZJwAcI0IyLqZSqKsK+xWAoVSzbYfPo/6XZ3COMltIWDh1iYgmUqj40SvyO3f13nF9ryWVZ0zDMMw5Uc+w2WsGl4mkKN3fGZzIw5sWWnLDpJrhW1bW4/drUtErReZsTKKKq2+C8GalzukULywflenEE71PdsqHic9iwKrqu65a0M4fjGKQLZDaFf/DQwlRgo2aJQFXQzDMExlEAkFMBAbzvu8ldBh+RX8Pi92tDS4GhZjZRVVImXTVXqm4dYaIJ/VeuhsP6p8XiiwF6CTMWF5bg5sWYm9mxtRG/Rj1aJavLLzMfh9hb8aqt7LMAzDVA7RPIYLNWk0YRktcodot7lH9thPJOQzVqubcoeNl3EwnmqEB0/3QTfSCIc0W1E6wOr4SSWfSYC1r/OyaDsgbyPDoSKGYZjyZqKtXeQoUzwrF6Ay/m5zT2uTVZ194/LwhEI+lVxdF2DjZVyMpxqh27Zk6b50+S1hXZMAa9jhRXFTmz++ZMGYHhmGYRhm+hhLhzHW85rqFY0ZQ5qKbWvrXUv+U3V25+IYKM6rUsnVdQHWvEwpcpE6E9bA3NHS4Fo4SC79TNDrGIZhmMqj0D2cNJAA0HGiF8lUWmheaC4otkaLs6ZLOdVyKQRrXqaZfFYvWboblodtfYpe2fkYDmxZadPOkJZGbt7FhgvDMExl0BSpxjNZY6QYNmTDP1tX1yHo90E3MojpBjpO9CKRTAkvjAwZNW1He2zzjdOrUukhIjfY81ICyOp11nMZ7zbAqGU9L1iF7oH4VH0EhmEY5g4JaT7E9JTrcx7FrnORvSqHzvYL/SNgJWiMVV23UMYRe16YoiCrF0Bea7eYbWTeGLoNAEKgxTAMw5Q3+QwXwG64yNXWAcvzfqFtPS60rceOloa82pStq+vQvqkRIU0VnabdqNRaLoVg46UE0EAZa9CNtQ0w6u5LptLwKpbC/MCWlVCzeXWeiUrbGYZhmLLA57Vu5A/teREP7OzEQ3tewPbD5/Ho/lMAYDM8nLIECjNRZhJR6anQY8FhozKF3IYk2kqmMtCNdE7jRrkENQt6GYZhKhOvgpzmilTktLXJag0gd412hpmcYaF8jRjLGQ4blTljWcQUx6RCdLeGDZBZEtMNLNrZiftr70IkpNlKULPhwjAMU5nIhovqUUQdl7RpFaQbiOnCcPEquWEm6lFE80qlp0KPBXtepgGyiN3alsvPU0SI0qpvDRu2Aa6pHq6yyzAMM8NQvQpSaRM+j4Kg34c1i+ejq/8G5gWrcCkaF/IBmUr0tDhhz0sZ4eZl2ba2XljUzhQ3ej4S0rB3cyP2bm4UzRznBFTbdmy4MAzDzBxIy2ikTZiwmjsmU2lRSuPdxAjSplXE1MlM97Q48U33Acx0qDN0x4leWw0XACLF7eDpPlthum1r622W89bVdXh0/ynEdGNaPgPDMAxTWmT9oqx/oerrh8725633AkDUiJktsPEyTdAgI2OF/pbTpuXnEsmUEOQqAKo1FffX3sW1XxiGYSoc2XABgCqfBw/eMwfdA3GYADY+9zIuReNCqDubjJR8cNioxFAq9I6WhpznnLn3stuv40QvBmI69hzpEd6bak0VFXqDfh8euDuIkKYKVyPDMAxTeciGC3EpOrow7R6IC6EuNfN1yg3cJAozOV2ajZcSU0xxIBpgAHK2pSFNBtArOx8TzRyPXYwiphtIuQx8hmEYpnJxZh9FQhpam8Ii88hZ2NStVcBMbAtAsPFSBpCXZV/nZWEl72hpQEhTRfNG0sCsaD+JoUTS9noTYO8LwzDMDGHYyEBTPdBUL0Kaiofum4todsHqlioN2BNByFiZySJe1rxMM4fO9iOeFeIOGxlhJbt5aw6e7ssr2nVzOzIMwzCVh4nRbFLdSCMmaRupaB0ZKM5EEFkrOZNFvFznZZqRa77IVRS7+m/YhLzNdTU4c/U6kqk0p0gzDMPMQjTVi92tD4lwUCXXdHFjPPM3e16mGGcZZ6qK6FbW+eDpPiSSKcR0A9GYDhOW9mUokYRuZKB6FGRM0xYbZRiGYWYWqkdB28alAEYXs0Bu6KhSukdPBmy8TDGUObTnSA8Au6uP/pcNmn2dVwBYjbvumRNAc10Njl+MArBCRW5Vdp2t1hmGYZjKxciY6DjRCwBCOuD0uFBbGbl22EyGBbvThAnY6rnIinA5Q8nvs76iVNrEtrX16Oq/YethRIaLV9LrsuHCMAwzs4jpBmK6AU31Yl6wCvW7OrH98Hnx/MHTfUibVh2wRDKFQ2f7OVWamTzkLCJy+cmKcOdg29HSAK8yauxsW1uPkKZCUz22DCMOHTEMw8x8RlJpUbCuszsqHqe5AbAMnYOn+2Z0qjSHjaYYN/W3HDoijYvslSEhL8UxKevIy9nRDMMwMx7VoyDo9yKmp5A2gZDmQ1xPocrnxaGz/WJekecGOeFjJqZKs+elxBTrtiMLGYDwwtBjZLhQu/Pmuhp4FWBpuJoNGIZhmBmOkTER01Pi/5ieQjikQTfSNq8KefHbNzWy5oW5M9zcdvk6TctVdEm469Yu4MzV60ibwLuJEbQ2hafjYzEMwzDThCfbJoDmh+2Hz6N+VyfOXRsSQt5H958S84ZcdXemwHVeSoxb6hqlQo8nR39F+0mhMtdUL2qDVZgXrOLGjAzDMLMQqr5+8HSfKKXhVYD2TY0i6yikqbg1bIiGjuVeE2Y88zcbL9OAbNAAyJuXv/3weXR2R9HaFMaqRbXYc6QHJqwBeaFtPep3dbJQl2EYZhYS0lQE/T4MxHRoqhcjqbTQR1Lh0/ZNjQDyzzHlxnjmbw4blZB8ehe5lgu59TpO9OZs29kdtSnKA6oHCoA1i+fj0Nl+VPms/yOhwBR+KoZhGGY60VQv1iyej0QyhZCm4vEl92JBtQYA4rGZrnthz0sJkUv/OwcSPUfWM2UZya69jc+9jO6BOCKhAKKxYVHfRYFlyOjZ5l3OInUKgBn1pTIMwzACBUC1pubtdSfPIxORKUwX7HkpE9y6fMrPyQLdHS0NOd0/302MAAAG48M2Y8TetCu3z5G8rabyV8wwDDOTMAEkU/l73DXX1QhPPmWnUkuBmQLXeSkhbl0+5eecLr1EMiVKQMuhpea6GrzQ8ysYExC4cBNHhmGYmYgJTfVCN9K2Rz0KhO6FdJIAcPxiFK+/k8ClaBytTWEc2LJy6g95EuGw0SQw3mZYh872CyNlR0sDtq6uE649wK4iJ6Pn6WwvJACuoSKGYRhm5iP3rpPnApILqF5lzIWuVwH6nm0t7YFOAA4bTTHjLcFMVRDlSrrb1tZDcWxD+3Tud5gNF4ZhmFmHRwFkd4O8iA2HAvAqsBkuCkb73qkeRSR3LA1XV3zfIzZeJgG5mFyx2zv7G21dXYe9mxuFDkbeJ/1NzChXGcMwDFMUGTP//X8gNmwrnaGpHuzd3Cj+NzImBmLDACw9ZaX3PeKw0RRQKKyU7znn44fO9uOrR3u4YzTDMAxTkEhIE0VMVY8CwzFxPJM1ajpO9CKZSsPv8woJw3TCYaMyQ7Zwna66fNavXP+FtmPDhWEYZvZSbCu7gZguqq87DZemSLVIGAn6fdCNjE3CUCmw8TIFyCEgp7EyVsgpkUyhflcn5gWrih64DMMwzMxjoutXr2IJeQHgtYE4Dp3tx6Gz/UgkU9BUr03CUClw2GiKKTYzibaTe1a0NoVx7GJ06g6WYRiGKRvyFSBtilTj3cSIa7871aPgF//fJ2z98UhDWW7F6zhsVAYUag1AXaOLYVmkGgqAKp8XL10eLMGRMgzDMJWAXGVd5o2h23hl52OisKmMkTHx6P5TWLN4PkKaCtWrIBrTMS9YNa5Ek3KDjZcScadKbnr9G0O34VEA3Ui7pkiHNJXDSQzDMLMIp/clrhvYfvg8hlyMF8DysHT138CFtvXIZEyYAC5F4+NaSJcbbLyUiPGmTxPbD58XGhdy7aVNK2y0YXlY5OyHNBWRkIY1i+fD52HzhWEYZrZiwmrg66y2q6lebFweFnOR3NC3tSkMIH+UoNxh46VEjDc8RFAn6UvRuDB8qEPoqkW1mBNQRb+ibWvr0dV/I0dNzjAMw8wMFFi6lXzP0e/WprAVFpK29fs8OLBlpUgW6TjRKwrbnbl6XWgrK7HeCxsvZYRlFXvFQKRKvEG/D1tX14n/h7Opbe3HL4mWAux8YRiGmXmYyE13Buzi3YDqwZmr1wEAbRuXQlO9AEabN1LpjWQqA69ivY7SoycaJZhu2HgpIw6e7oNupBEOaVi1qBaJZMqWwkaVeWnAymWg2fnCMAwze5Bv+VSrJaYb6DjRC7/PmtqHjbQtHOT3edC+qdFW4V1uAlxJoSM2XsoIZz0Y8rqcuzaE+l2d+P5P3sStYWO6D5NhGIaZZCbLe55MWboX8swcPN2HHS0NovXM1tV12NHSgKDfB8Dy+Lcd7am40BHXeSlT5M7Tcd2wWdkKAJ9LyWe3MtAMwzDMzMTZYdrv84paLqpHwT1zA8Jzv6/zMoaNDDYsD6Or/wYGYjq8CjAnoCKmG/AqQPumxmnNPuI6LzOEW8OWGzCgeuFVrEJEkZCGvZsbcc/cgG3bkOZDZmbZoQzDMEwWN8fM3ICKZ7INfXe3LhHeFMCuk7EkCRmYAI5fjGLb2np4FYhGjpGQNu2Gy3jxjb0JU2pkL8uaxfNx5up14W3xKsDu1odcB1XHiV5hZcf0VFFuR3nAMgzDMFOPpnpE1k8xNEWqcyrnyryy8zFR7l9G7o9HBFQPtq6uw7lrQ+jsjmLN4vk4sGXl+D5AGcDGSxlA+hZgNFUagM2NRyltzXU1QlW+o6UB+zovi4ugmIgRGy4MwzClp1AYfzyGC4Acw0UBUK1Z4Z6nj/Tg3LUhdPXfQEw3bFlIVBcsphvQVA9GUhk8vmQBACtVOm1CzCeVBoeNygDKIgppqsjVp9ouZLiQoKqzOypU5eQKHA+cUs0wDFN6Sqk/rNZUrFk8X/x/7GIU84JV8CpAOBSAAqtAXWtTGMlUJhtyUpA2ga7+G7Z9UXXeSitUx4LdCuDR/adEPZemSDV+8fZ7GDbSWeHVEAZiw3f8HuN1YzIMwzClQfUqtlIYTjYuD+P4xWjBLtNy80XAKnYa9PuEgLfjRK9NnpA2Me1NGlmwWwFQSeaxLF6KY5LD5N3ECGqDVaIcdHNdrXANEqrzgTxEQgGENFUUNGIYhmGmn/QYXptjYxguAJBIpjAvWCX+X7N4vjBM2o72ZJNBPPAqwNJwdcUVqpsS4+Ub3/gGHnjgAQQCATz88MM4d+5cwe3/4R/+AR/84AcRCASwbNky/PCHP5yKw5xSqCRzZ3e0YH496WGqs6GkocQI3r5peVrSpjWInQZ6IYtdNmsGYsNIpjLw+9jrwjAMUy5MNOJErWM8iqVzkbUyFC46eLrPNmekTWtRXGlNGktuvPz93/89vvzlL6OtrQ0/+9nPsHz5crS0tODtt9923f7//b//hy1btuDzn/88zp8/j82bN2Pz5s3o6ekp9aFOKVSQrrUp7Grxkmemua4GIU0Vj+tG+o5iqc5X6kZalJBmGIZhKhdahDrFICFNRXNdjZhTyDnv93krzuNClFzz8vDDD+PDH/4wvv71rwMAMpkMFi5ciKeeego7d+7M2f5Tn/oUEokE/umf/kk8tnr1aqxYsQJ//dd/Peb7zRTNi6xz0VQvdCMNBUBA9QIw2VPCMAzDjIkC4Nr+VjGnyFXcyWhx+3s6vDBlo3kZGRlBV1cX1q1bN/qGHg/WrVuHV1991fU1r776qm17AGhpacm7fTKZxM2bN20/MwHZEqY252Rl1gb9aIpUQ4F74SKGYRiGAax5g7ST5IHZ13kZAzEdTx/pwdNHrEzWfZ1XKqpNQEmNl3feeQfpdBr33nuv7fF7770Xg4ODrq8ZHBwc1/bPPvssqqurxc/ChQsn5+BLCIWECqWlbV1dh43LwznGybCRxkBMxxtDt1EthZMYhmEYxo3245dELbGu/huunvthIy20MM11NVN5eBOi4rONdu3ahXg8Ln7efPPN6T6kMSGxrtO6dRo1B7asRDib7kYEVC801YN4ttbLjMpzZxiGYSYFuaYXJXHEdAPzglVC2EuoHgUbloeFFsZZC6YcKWmF3bvvvhterxdvvfWW7fG33noLCxYscH3NggULxrW93++H3++fnAOeIijeKAuouvpvIJFMieJzAMQ2cslnaqDFRgvDMAyTj3xq1u6BOJ7Z3CgW0QCQypg4c/U6Wpuspo2VIOAtqeelqqoKzc3N+NGPfiQey2Qy+NGPfoRHHnnE9TWPPPKIbXsAeOmll/JuX4lsXV2HV3Y+Jjp7Uro0AJuYip7b0dKAC23rRVvz1qZwTm0XgivoMgzDMOSlD2lqzrzw9JEeJJKGkCWYsBbGZ65eFynTxcgbppOSh42+/OUv45vf/Ca++93v4sqVK9i2bRsSiQQ+97nPAQA++9nPYteuXWL7P/zDP8SLL76I//pf/yt+/vOf48/+7M/w05/+FF/60pdKfahTjjNdekdLgygiRIXp0qZVUIgGUCKZEhZyyEXzUsKK1AzDMEyFoBtp+H1e7GhpEF4YOVwU01MwYU/6iOsGDp3tt7WkKVfxbskbM37qU5/C9evX8dWvfhWDg4NYsWIFXnzxRSHKfeONN+DxjJ7Qj3zkI/je976Hp59+Gn/6p3+KBx98EEeOHEFjY2OpD3XKoVQ0Z2oaFaajFOm0aZVyvjVsCEHVsYtRNEWqgaHbQojFMAzDMAQ1biSGjYxoBUONGhdUBxCNDcOE5YFpO9qDOQEVadNqG1CuISTubTTFyN2hZZ2L3FOCtqHnvArg8RTudSHDfYoYhmFmJ8Xe/6n7NPU1CmmqWCCTYdPaFMaBLStLfsxE2dR5YXJxtgUAkFPhkDQxpHFp39SIVNZwUWApwwvx4D1zuP4LwzDMLGQ4j+HinBMCqlVdd2m4Gl7F6n0k6yndOlCXEyUPGzF25EwjUnXnq2Qoh5HCoQAGYsNYFqnGL96+VbBFgNzPgmEYhpk90MzgVYA5ARUx3RBeFlknuaOlAVtX1+HR/adshkratAygkKaWbcgIYONlytm6uk4YJRQeosfdIE8NWcNvDN3Osaw9Cgt1GYZhZiP5wkRVPg+Cfm+2sa8PcT2FZCqD3a0P2eYbuVXAuWtDGIjpMAEE/b6ybtTIYaNpJF+xOhlnRlIylc6p8cKGC8MwzOwkmcogEgrYHlNgNWkciA0DGM0s0o20mG8oFRqASI8m74sCK7O1XNOkATZephUyTGTXXL7c+tffSSAa04WFrakeEcMcSwPDMAzDzEwyJoSRQtB61mnUAMC8YBUA98UzzUnVmmormFqOcLZRmeHs/Nl2tAduSUYhzQdAQTKVBqCI5o0MwzAMQ6geBUG/D3GpnUxIU3F/7V24FI1jabga7yZGbPpLkjRMdXfp8czfbLyUGfKgIctYAeDzKAVFugzDMAzjhgJgWaTalsxBKdLy7/ZNjdOqc2HjpYKNFxlnvZdISMO8YBVnEzEMwzA2KKNIzbPQpefp7w3LrT5GzXU16OyOilovQb9v2rwwXOdlhiDXe9FUL6IxHQ/cHcQzm2detWGGYRhm4lRn06Blw0VTvSI9WjZnNiy3is+9svMxHNiyEu2bGhHSVMR1I0cHU0xiyXTAxkuFoBtWltHxi1FsXV1n61GhgDQwDMMwzGzErU2MpYnMbdj7wmu/siWGbF1dh6DfJ3odyZlGbokl5QCHjcoYZ9gIsLKMrux9EofO9qPjRC8A4P7auziUxDAMw4wLOUwEIEemQC1rpgoOG80QyF2XTKWhwDJcdrcuAQCcuzaEW8MG1iyej9fYcGEYhmHy4JYyTYVPKSTkbEtTbp4WJ2y8lCmHzvYjkUwhpKnw+7wwAdQG/QCAFe0nceyiJbA6fjEKH9d5YRiGYfIwlBhBJKThmc2N2Ljc6l/U2hTGmsXz4VWA5roasS0ZMQBca46VC2y8lCkHT/chphsI+n22AUaPE4oCTqFmGIZh8jJsZDAQ09F2tAcvXR5E2gTOXL2Orv4b4m+noVKuQl2CjZcyRRZJ0QCjRo4ybLcwDMMwhDN5g2q8KLDquVCV9mQqI7z7APJW2y3X8BEbL2WK7LqjAUZ59nKmEcMwDMNoqgfPbG5EMjW6olU9CkxYDX0D2XlD9SiIhDT4fR7h3XfTudAcVK7NGTm/tow5dLZftAcgcdWhs/05XaUjoQDevpnk8BHDMMwsJKSpWLN4PvYc6bEVogv6fUJm4Pd5oRsZBP0+vLLzsZzic+VqpOSDU6XLGOpzRERCGoYSIzl9jCIhzZZOzTAMw8xM5Eq5hFtV3Y3Lw1i1qBYHT/ehua4GZ65eBwDsaGnIMVSmq5eRE06VrgDcukc7H9u2th4hTYWmeqCpHiSSKdcGjM11NUgkU1N27AzDMMz04OZtcBouCoBVi2pF6Ker/4YIEQG5WUTlLs51g42XacJtsHSc6MVATBfF56jqoW5kMJLK5PWsvHT5LQ4ZMQzDMAAsA4fmFrnsxra19TnzDFD+4lw32HiZJtwGSzI1qgInL0xzXQ0iIQ2tTWFEQho2Lg8LdTjh5o1hGIZhZi4KLC2kmq3zRX2MLE+9V5T4l8tu5AsJlbs41w02XqYJt8Hi93nEb7KOj1+MYtvaeqxaVAvAcgWS649hGIaZnZiwUp/J6/7gPe+TPPVpxHRD6FjkhTJlFu1oaXCVL1QKbLyUEfKgIkxY4aQ9R3owENPx1aM9NhEvwUV2GYZhZi+vDcSFoUKeehLgyhVzAYiFcyVqXQhewk8j2w+fR2d3FK1NVntywKrp0nGiF2sWzxfqcGBUpJVP2sKSF4ZhmJmLM8tIgVVhne79AdVjS3mmkBEAm6HSdrRHPLZtbb3wzlQanCo9jdTv6hQ1XNo3Ndpy9OmxravrbB2kbw0bSEvfmKZ6RMVEhmEYZmbSFKnGL95+z1XjqADYu7kRAIQxQsYKdYeW64ZNR8foYuBU6QqhtWm0QdbB0302qzptAu3HLwk3346WBgT9PrQ2hcERIoZhmNnFawNx6EY65/4fCWnYu7kxJwzk1LpsXV2H9k2NFZdVlA/2vJSYYov/HDrbb/O8yHgVoMrHHhaGYZjZikdxlwe8vr9V/J1vvpG9925F6soF9ryUEfkEUbLKmwZWIJvipnoUKLDchM5mWgzDMMzsQzZcqPliU6Tato1TnEtZRJQuTRlIMwE2XkpMvuI/ZNRQJlFMN6AbGQwbaRgZE+GQhmNPfRQB1QsAwlXIISOGYZjZh5xRemvYqqjePRDH9sPnc7aVxbmHzvaLau1UqG4mwGGjaYLce86eRKpHQcY0sTRcjTeGbudU1XUqzpsi1naJZIqr7DIMw8xwVI8CKICRzdxQAFyTQkcAKkKc6waHjcqIfEWAKE0NsCojaqoHIU1F0O9D2rTEWW7tABSH66V7II64brDhwjAMMwvImKYwXAArRdoJiXNDmioq7c40uM5LiXHm1gMQwqlkKg3dyCCkqbjQth7bD5/H8YtRqF7FNjhl3GwUeiik+RDTuUEjwzDMTIXu96pHQdDvsxU1dQp2Zc1luYp0JwobLyVm29p64b4joRR5VGQnysbnXkb3QBwA8hougFXXBVBcc/0pDsowDMPMTGgBmzHNnMwh52K5kovQjQWHjUqMM7deFk5tWB4W7QDIcAFGG205GzACVtZRvkaMHDliGIaZOVDWqVcZzTDKSl5sC2Ji29p6eBXrOTJgKq3hYrGwYLdMePBPfwgjY8KjAHMDltGyo6UBB0//EgOx4RyhLsEVdhmGYWYPVE03X/2wShXrAuObvzlsVGLkGCQA17+3rq7Dk8vuQ2d3FFU+L2K6gUhIw9bVdTh3bQiD8WjeInVsuDAMw8x8VI8CI2Pm9DByQo/P1HARwZ6XEvPo/lOivwQADMT0bMVcL3QjjZCmYkdLg6iuq6ke+H1eJFNp+LOGjEw+DwzDMAwzc3mmgLdlpsCp0mWEXKROjkeSbiWZStv6Gvl9XgT9PuhGxjVV2kThQnUUF2UYhmFmBpFQoOg2M26lOWYibLyUGCrXTG4+Eu9q2cq5fp/XJuLd0dKA5roaKLC8MBuXh3P26ZbXT3CqNMMwzMzAq1iC3YHYsK3NTD4jJV87mpkIh42miUING+VQ0ys7H7OlUTMMwzCzEwXAhuVhdPXfwEBMF4VNaR4pthFwucJhozLCaSHT/wBcG2gBQHNdDbwKMC9YhUf3n8InP7wwpwEXwzAMM7swAXR2R4UcIZnKiB55gN3TP9Nhz0uJcXpRVrSfREw3RFVdel4BEFC98Psse1LWu5BOhmEYhpl9KADCoQAG48NobQrjwJaVAJAzn1Q67HkpI/J1lZaf9yqWRa0baWG0eCVVLhsuDMMwsxcTwGB8GO2bGoXhQt560krONtjzMsW4xSQPne1Hx4leJFMZ+H0eMRA7TvS6ZhwxDMMwsw9Z40Li3EorRFeI8czfbLxMMpMpmCKXYD6oaBHDMAwzcyFHfEC16oORN7+SxblucNhoGsmXquaW2nbobD9WtJ/EivaTOYJeeTtN9djCSITP7UGGYRhmRkB3eDP7M2yk4VWspA6nOHc21XgB2HiZdPJpXNyMmoOn+xDTDcR0Q6jF5e12tDQgEtKwu3UJ2jc1ZjtKj8KtARiGYWYmCgDFsT41YWkgu/pv2B6nfkaUeTQbjBgOG00R+bQucluA2qAfzXU16Oq/Ydtu++Hz6OyOwuNRYLB6l2EYZlbTFKnGG0O3AVAD3z6p9YzVB68SM5A4bFQGOF14bvn3W1fXYe/mRoQ0FcOGla/f1X8jp/7L8YtRpE2w4cIwDMOgeyAuvPa0KA5pKuYE1Ok+tCmDjZcSUWyZ5q2r6xD0+0Rvo+a6GtvrO070ujZiVGAJdhmGYZjZC+lfgn4fYroBv8+LSEizpU/TYnr74fM5OstKhY2XEjFWfRfntqS9pVgmvd4NTfXABDjTiGEYZhYi6x+PXYxi++HzGEqMQAGwZvH8HC8/LYY7u6M2j00lw5qXacKpgcmXYr398Hkcuxi1vVZTPRhJZbh4HcMwDAMFEB560k869ZUHT/ehua4GZ65eB2BpZcotxZrrvEyD8VJsfRfabiiRFKIqElwVatIoo6ke+H1eJFNpzjhiGIaZ5XgUgBzxZMg4mza6UW6NHNl4mQbjxdnDCHAfGM7CcwqAak1FTDfEa6niLgAE/V4MxIZd3zMS0jAY1109MLIlzjAMw8xcnJ4XeXFbKJPVbd6aTjjbaBpw07gUEu1S4TkacPRaytenuGQ+w0XJvme+0BFreRmGYWY+CoBlkWqENBUKrPpfQb8PVOJOz2aydnZHbfPRobP9SCRTCGlqUdrMcsM33QcwU9i6ui7H7SaXbybkEBGAHM/Mo/tPIW2OemTur70Lrw3Ec7woJoBz14byHg/rYRiGYWY+JoBL0TjmBFRb1uqZq9ehG2moHgUZ08TScDXeTYzY5h7y+JdDyGi8sPEyiTjDRDQgDp7uw7lrQ8JlJ7vnxjJ4Dp7uQ0D1uGpbOrujOY8xDMMwswtarHoV628S5YY0q+5LTDfwbmLENvc455py07+MBYeNJpF8LQDcXHaAey8KuZhdx4leDMR0YbgosCorEnMCbHsyDMMwQCKZQmtTWJTYiOkGgn6faDMjGymP7j8FALaU6mJrk5ULbLxMIm66F3qMBpWbJqbtaE9Ow8ZH959CMpUWj3kVYMPyMC5F4+KxmJ4q8SdiGIZhyglN9bo+bmRMHLsYRTSmI+j35m3gKBdAlRfP46lNVg6UzHgZGhrCZz7zGcydOxehUAif//zn8d577xXc/qmnnkJDQwM0TcP999+P7du3Ix6P531NueHW5ZPccAe2rMwpHETF6dImXL015HHRVA/aNzWiq/+GTcuiehWussswDDNLUD2KbVELAJFQwPa/CWAgNuzawBGwDBqvYnlqyIgB3FvYlDMlM14+85nP4NKlS3jppZfwT//0Tzhz5gy++MUv5t0+Go0iGo2io6MDPT09+Nu//Vu8+OKL+PznP1+qQyw5Y7nhtq6uQ/smq7dRIpmyWcAyfp8XB0/3YV6wymoLkC3Ha6RNrrLLMAwzSzAyJpy3/KHEiNC2yFBGqpMzV69bvfKyO0okU6jf1YmNz71cUd2oS2K8XLlyBS+++CL+1//6X3j44Yfx0Y9+FM899xyef/55RKPuItPGxkb8n//zf7BhwwbU19fjsccew759+3D8+HGkUpUXHik2DU3uSUFGztbVdXD6UwZiOi5FrawjbtDIMAzDAFYq9I6WBlvLgGLQVA8iIQ2pjIm0aTV7nPWal1dffRWhUAgf+tCHxGPr1q2Dx+PBj3/846L3Q4VqfL78wtRkMombN2/afqYT0qt0nOgVgqmx3HBuscYNy8PwKqMC3ZCmYmm4Oue1TpehGxxZYhiGmblsXV2H2qDf9pgJ5OgpAatcR0hT4fd5sW1tvW2umfWal8HBQdxzzz22x3w+H2prazE4OFjUPt555x3s3bu3YKgJAJ599llUV1eLn4ULF074uCcDChUBKHoguMUaD2xZib5nW/FuYkRU5JXFusRg3L2IHRHSVDS6GD0MwzDMzKB+V6eQFcikTWBf52XxP+kwk6kMYrqBp4/04KXLb2FOQMUnP7xw5mpedu7cCUVRCv78/Oc/v+ODunnzJlpbW7FkyRL82Z/9WcFtd+3ahXg8Ln7efPPNO37/O4G8KDtaGnLEu3I8sdj/m+tqEAlpSKbSQqyrqV5oqievN0YmphvoHqgc0TPDMAzjjupRhOYRgDBWKOwTcAkdyTXCRstvpKXn04jpBvYc6ck7H5Uj4zJevvKVr+DKlSsFf97//vdjwYIFePvtt22vTaVSGBoawoIFCwq+x61bt/DEE09gzpw5+MEPfgBVzRUiyfj9fsydO9f2Mx0cOtuPFe0n0XGi17XIj1O8W+z/Xf03bIWFVI+C2mAVdrcuwYW29Xhj6DYAaxDLISR5gDMMwzCVj5ExEazyIaSp2Lg8jGqHUJcMlZCm2jJRnUaIpnpzvDQmkHc+KkfGZbzMnz8fH/zgBwv+VFVV4ZFHHkEsFkNXV5d47alTp5DJZPDwww/n3f/Nmzexfv16VFVV4dixYwgExtZzlAtUalkW3so4dS35/m+uq7F5XKjfEQ1KI2O6DipKjyNY1MswDDPzoHnm2MWorclvDpJ1QunQVLBud+tD2LvZynTVVA9UrwIFVho1UBk1X0rWVfrJJ5/EW2+9hb/+67+GYRj43Oc+hw996EP43ve+BwAYGBjAxz/+cfzv//2/sWrVKmG43L59Gz/4wQ8QDAbFvubPnw+v170wj5Pp6iotd4Le0dIw4bihs8vn9sPnceyiPUMrpKniPQ6d7ceeIz3cQZphGIZxRfUo2WaN1vwEWAtu6jSdSKZEn6Pp7C49nvm7ZPXl/+7v/g5f+tKX8PGPfxwejwe/9Vu/hQMHDojnDcNAb28vbt+2wh4/+9nPRCbSBz7wAdu+rl27hgceeKBUhzopuDVmHC+UXq2pHlH3xa1/0a1hQ2x/8HQfNiwP48zV60im0khJtV/kNukMwzDM7CSVMYWXZs+RHlRrKmK6gWhMhwkrjESelu2Hz6OzO4rWpjAObFk5vQdegJJ5XqaLqfS8jNXIip4n63ashlfkdaGqu5GQhnnBKnQPxBEJBZBIphHXDZiA6F8xENMR0lTcGjbEa17Z+RhWtJ9ETDdE7r9bY0eGYRhmZqEA8HkUsYhVvQp8HsU2B8gNG+n/C23rAViZS2nT2k84a9BMVQbSeOZv7m10B4wlairUlNENtz5I7yZGAFgp0TtaGrB3c6PQxgwlklAAWyYSYKJ+VycSSauwn25kxKBlES/DMMzMxgRsldeNtAndyCCkqeJnzeL5woPvVUZDSQDQ2mTVfQmonrIW7bLxcgeMJWoq1JTRDar3smpRrW0fCixPTMeJXrFNV/8N6EYGJqz2AWSXUE8LI2PmVFxkES/DMMzswKOMZqEqABIj1oJ2R0uD6JPnVYD2TY1CP/no/lNYtagW7Zsa4fd5x6wQP51w2GiakENOAGzhJ6do96E9LwjvyTObRwcaCYTXLJ6PM1evi5ASwzAMM3PRVC9qg6otw9QNWV4gP7ZtbT06TvQimUrD7/NiR0uDiBR4FWBOQJ0WAS+HjaaZYgr8yCEnZ/hJ9ugcOtuPYSlWSeWet66uw4W29djR0oDObitlzpnzzzAMw8w8dCM9puECWKnP29bWI6Spwjv/9k3rdUG/D7qREeU9tq2tF3rLmG7YUqfLETZeSkAxBX5kA8UZfpLbBRw83QcTlvuPwkcHT/eJonh7jvQIvcvN4dGcf5UbGjEMw8wa3G75Z65eF3/TPGFkTBw83Yd5wSoA1lxBXv/2TY3CyDGzry/XSrscNioBziykO6kBI6etrVpUKwZdoZL/CoBqTbVSpzMma10YhmFmIQos4a0z2/SZzY1oO9ojdC99z7aK5+T5CsCUho84bDTNOBstjlV914kcdiJhVVf/DbFfuUGjglwviwlKgVNwz5xAUZ2nGYZhmPLGo4ymOReDifxlMqgvHv2meef7P3kTt4YNrFk8H2sWz4dXKc/wERsvk0g+rQvFHItVblPzrI4TvWiuq8kZPJTK5lFGi9BFQhqeyZZ7Jqy4qF5UbJRhGIYpbzImXFsChDT3erNexRL3Avaw0sHTfaIMB/2mead7II60CXR2R22L53KjZBV2ZyOkdek40WsLG020+m5cN3Dm6nUxeCiEtDRcjQXVmlCQpzKmcOnJ7c8ZhmGYmU1TpFo06HWyNFyNT354ITpO9CKRTCFjWiU0tq2tx7lrQxiM63m9KkvD1fjF2++VrXCXPS+TCAlvAbgKdottM75m8XwAdq/KtrX1OH4xKlqfD8R0eBTLsl4WqZb2W1ioyyEkhmGY0qN6lDHuxpPDawPxvA0auwfiaD92CTHdEIXrKIxEC+PjF6PYfvg8AMtLo6kehDQVv3j7PehGGibK0/PCxsskQEYJALyy8zHRudMZIiqUhSQbNrJCHIDw4AQcRecyphVCejcxIu03V5xLnUM11Yu3bybv8NMyDMMwY2FkzDuuu1VMUfSx3kOutkvIc5AJiHIbtcEq1Ab9iOkGho00AGs5XI6F6th4uUMOne1H29Eem1HiFOwS5JlprquxeWDc9gFYg0YW+e5uXZIzmI9djCKRTCGkqWiuq7HVhCFuDhvZNgFp14HMMAzDlB+lShQdSiSxZvF8ocVsbQojpKlIJFOYF6wSHv1ISMPezY0AUHYp02y83CEHT/eJdLNiy/939d+wGSq0DwVAIpnCmsXzEQlp2LB8dEBRYbr2TY05rkhyGR67GBVWuLwN2ysMwzCzB2drGGC0VhhghY66+m/gQtt6XGhbjwNbViLo9yGmG3gtK9h9bSCO5roaHDzdJ8S85dTniI2XO4S8KdQfgiikb3EWpaNsJMAyRKgDNcUZyftC9WOc4SO31Dm2VxiGYWYnzvRoTfVgw/IwqjUVmurNzhkmHtjZiQd2duKhPS+gua4GkZAm5hcT1oJ4IKYjrhtl1+eIi9RNAGcROjdWtJ9ELPuFU9+IQttTPyMA2Lg8jDNXryOmG9BUD2qDfmxbWy80MwrsxgkZQu3HLnFYiGEYhskhEtJE76L2TY14+kiP7XlaBCeSKdd5JKSpuNC2vqTHyEXqSkwx5f+L2X774fOo39WJ7YfPi74SgF3Z7fd5hX6G0tVMWKpwBYDqVTCUSKLjRC+Cfs58ZxiGYXIhLUvatGq6yMVNKcwkZyWFNBWRkAY1OzElU+7F7qYLNl4mgDPs4wZlHO1oaci7fWd3VBQDIj0LbSe/niCjRgEwnE1hM9KmaK4V1w3XnkacHs0wDDP7kLUv3QNxZMzRx4yMiUhIw+v7W3Fl75OiRAeRSKaQSKbgy84pfl95mQscNppG3PoWuYWWKEzVXFeDM1evI64brGlhGIZhCtIUqcYv3r6Vo4HZuDyMrv4bmBeswqVoHEvD1bgUjbtmN1GvvPH25ZsI45m/2XiZJGQDgwS34/miSfOiqR6MpDJobQrjwJaVtufkAngyqlfJWscK9GxuPsMwDMO4EdJUBP0+RGO6bSHs1FPK25da7wKw5mVaIF1LZ3e0qEJ0zr+pVsuwkRGhJELub0QhqI3Lw0IjQ6EjNlwYhmGYfHizVdlvDhtW8odif27v5kY8k63rIpNIprjOy0yFjIrWpnBePYws3HX+HdMNBP0+bMgaJUvD1baKu2nTKudMwl3qccQwDMMwY6GpHswJqEibo7W/TBOioe+cgIrv/+RN7DnSI+rBkIQylTExENPRdrSnbAwYDhuVCDmdGkBOSEl+jNoByDFFOVQ0lEhCNzLQVA+u7H0S9bs6RWG8Kp8nJ56Zz/XHMAzDzE401YvdrQ+JJo2pjIllkWq8mxhBIply7Y+kehRkTNOmiYmENNEIeLLhsNEUkq8YnZuXpav/hvjSybDp6r8hvC6yRkZuJUAl//0+q7V5a5PlnWltCmN365KcY2LDhWEYZnaSrx2SbqTRcaIX8Ww6dDikib54yVQaXiW3Mq+RMZE2gXcTI7Zs2HKAjZc7JF8NFzk92pkqLb/GLY16++HzaDvaIzw1Jiwvy5rF8/Ho/lNYtagW7ZsaReq0s8KuS7Y0wzAMU6HIpf3HwkT+OSCWzVSlVjRU+wVQkDbdK/NSixoArj37pgsOG90hxVTbHc9rDp3tF5UPFQAB1YNhI4MN2dQ2Z9aRln1e/hKpEBHDMAwzu/Eo9v521rzihW6khcRAUz3w+7xIjKRgpE14FEsPsywyNeEiglOly0DzMlHkNgGqR7FVO0ym0sKQWbWoFh0nel3jlAzDMAyTD6rdkkyloRsZ8X9MN2yaSfp7qmq9sOZlGijUiHE828htAoJ+H0KaCk31IKYb0LMeFgoX3Rpmw4VhGIaxo6ke187SBBknjy9ZIP6POwwXwPL8R0KaMGzKKduIjZdJoph+R2Nts/3weew50gOPooiGjhfa1guhLmBZwM11NWg72oO0af3v1hKAYP0LwzDM7MKq+2XXr7jNBXIfPROWdyWkqVC9ChRYxs0rOx/DjpYGKBjti1QOsPEySRTT76jQNofO9uPYxajVryhjiiaLj+4/hWTKKj6nwCoi1NV/Qxgu1ZpasJM0N5lmGIaZeYx3XUpzgQJLhrBm8XxRHHXj8rDopXehbT2CVT6YAI5fjOLQ2X5sXV2HakdiyHTDmpdpwK2VgKxf0VQPdrcuEZ4aMlLur70Lrw3EoWTFVACnRTMMwzCjeBXAoyg5i1oS6gKm8ObHdEMIcbcfPo/jF6PweeyvpecnkpwyXliwWwbGS6EvmkS5lBUUCWmiSJDcQ+LQ2X4RHoqENAzGdc4iYhiGYe4Y6m9Ei2hnnyOiKVvIrpRGC8GC3TKgkL5l29p6hDQVVT4rh37b2nrsaGkQbjsS9gKwFQZqbQrb9lNI68IwDMMwTihstKOlAdvW1uP4Rasfn0+aT1SPIsJSrw3EMRDTy0brQrDxUiLyFZ+r39WJc9eGEPT7oBsZoW2RvTSy4bN1dZ0oDPT6Ownbe8iuPTZjGIZhZj7jWbNGQgEosKQIG5eHEdJUkfIMAG1He4S3xciYYh4xsq0DIiENgWzWUjKVLqvmjBw2mkIW7ewUOfN7NzcKS5Zy7SlkdOhsv3iOBhkZNISmepBKm8KAsdLiFKTSGaQyJmthGIZhZjmU+kwhIuqTR//Lc4rba6/tbxUSCJI2cG+jWYgllrJ+b11dh6Dfh5huiN5FhPyc3BtJZiSVwUP3jX65VmpcGgYbLgzDMAxG67QkU2kMxHRb+vS2tfUFPfa+bMEx8v6TtKG5rqYsPDBsvJQYuTDd7taHEAlp2N36EIDR0NIGKU2NaK6rAWC1AJgXrBKDTFO9It/+tYH4mO/P4SSGYZjZg6Z60BSphlcBHrxnjvC2yNxfexe2rq4TISFCni+CVT7bc2TEUJuaQjXNpgLf2Jswd4KzCaMbqxbV4sCWleL/Q2f70dkdFf9fisZFhUM5OZo8ObqRzvv+7IVhGIaZmTj7FgGWF747u7DtzrPAvRSlxxWxHwXA0nA13hi6DcBqBLyi/aT4m8p6bFtbX3A+mypY81JiZP0KYOXVexUri4gMG2cMUe5vBFipar94+z2bkUK1X2ifzrLODMMwzMwipPkQ01Pi/0hIK6hbyffaSCiAbWs/gD1HemzzhjwXyfOQXNajlM0ZWfNSRsj6FWB0EJDl6lZxV+5vFAlpeDcxkuNdMWEZLWS4+Fwk6BwyYhiGqWzkW7tsuACj8oJ8qB5FzCXyjDAYH8bB0302w8WrQMxFh872I5FMQVOtch5Lw1YYaqz3m0o4bDQFNNfVYDCuY83i+Vi1qNaWFu1W9Icek11zHSd6RVdpp4eFWgo4YU8MwzBMZZMvNqJ6FBy7GHV/Mvt80O8TIZ9EctTwofAQtQno6r+B5roadJzoFXONnAH76P5TSJv2XkjTDRsvUwD1Iurqv4EDW1bmrVJIIaZkKg2/zyvaj5Oq2+/z4sF75uC1gXhOCWeGYRhm5pHvLj/W/d/ImIjpBs5cvY77a+/CQEyH6lXQtmEpDp7uExIG0lyuaD8pIgTko6HaLuRxmW6diwyHjUrAobP9WNF+EivaT+LQ2f6imjYCEANKNzIiTRqA6HsU0w1cisZhArhnbiBvWEj1csCIYRhmNuJ2+yfhrpE2sXV1nZAmkIQBgGgADEBkwPp9XgzEdHT13xDFUssFNl5KABkhZIDIVXLdoHTq5roahDRVxBkpnz6ZGk1zq/J5oHoURGM6wiF3A8bgBkgMwzBlzUSWmMWsS+cEVNs8sqOlQbSSkVvKzAmo0FQvEskUDp3tF80aFVjemFd2PoY1i+eXndaFYOOlBFDvIk31iIFRCMo6OnP1OoJ+H3a3LsGFtvU4c/V6Vu1tIhLSENJU6EZGFKIbiA1j7+ZGPLPZ6n/EMAzDVAbjWWJq2bIYbutS1aMglM08lW0b8uA/faQHgFVlt23jUgCjC+yRVFosstcsni+Oq+NELx7dfwpnrl4Xkge5Zlk5wMbLJCI3VLzQth61Qb8t/JMPCisBEDVhth8+L+KPfp8X84JViOkGVK+CSCggXvvVoz1oO9qDecEq132rHkUUtmMYhmEqj0K1vIyMiTWL5yMS0kQ9MDkERNvEdAPnrg0BkJsDe0VzYFmMG9MNkSZNkodCzYanAzZeJhHnl1us1sVZfnnb2npbkTrAHrOU7euMaVnj+YoRGRmz4MBnGIZhKgdNzZ22j1+M4u2bw2LB66yoSxy7GMUDOzvx9JGerL4yjaDfJ3QwTg8+eWOA4uezqYKL1E0i2w+fR2d3FK1NYVvF3HxQwytKm3bbV5XPA93IiEqKVFyIXIHjQfUqMNImVM5UYhiGqTg01QO/zyuMlGKhCrrOsBMVTJXnn4f2vADdyED1KMiY5pQUpyO4SN00IadEF4PTUyPHFA9sWYm+Z1uxu3UJIiENcwNWTHMwPgwAIsY5HnweDyKhABsuzKxCU70IaVwVgql8/D6vzRtSCFmc+xtNYbQ2hXOeb9/UCABi3tl++DyGs4ZLKmMKY6ccBbvseblDZO8JgLyelEKvba6rQVf/DdFAS4GVqkaFg+j38YtRIfJqilhFhhLJVEmMEbeeGQxTaWiqF7tbH0Lb0R5XsSPDVBLFes1Dmg9xPSXmi5Cm4tawYbsGyJtCbQBCon9eLuXoeWHj5Q6hL/5Ovlzah9yfiHLw5Z4Szu6gmurJG9tkGAZiBTmjbnIMU4CQpiLo9+X0PKJrYVmkGu8mRsQim4qjxnVDMnZ8uDWcwtKwfdtSw2GjKWQyREy0jw3LwwhpVo5+a5NVJIh+N9fVYNhhqLDhwjCFMYowXDgTj5lJyJlCMuSxeWPotpivVrSfzFZ1t7ediekppE3g3cSIrVFjuaRJA9we4I7J15+okBg3H1Sm2RmKOnP1ui1kNFEioQAGYsN3uBeGmVmwV4aZLVBD33wJH7JcQAFscgjSZ5ZLlV32vJSI8eTEy9seOtuPtqM94n8qJkQJ0huXh11T5YqhGMOFV6HMTIG8mG4UO85dmrUzTFkyGWNVFpFUa6owVMotTRpg46VkjOfLlrc9eLpPaF22ra3HtrX14kZrAnj9nQRqg37X/XiV4spHF8IEbEXwGKZSSSRT2NHSgI3LwznPFettcdNGTnSSYDuIKRWa6hEZqW7PFXpdSFOxMdvLSJYurFk8X4SKxmpxMx2wYLdMcGYeOcVUsgr8mc2N2HOkx3YDbopUA8hfrG68yOJhGQ49MZWEW5YFw8w0QpqKZCo9Lh2kpnpwZe+Trhmz84JVYi4JaSoutK0vyXE7Gc/8zZqXSWQiOheCQkcAbFlLFDaSU+TOXRsSZaCJyTJaiHz3ejZcmHJE9k4S1FtMNlzyGeUMU8mMt2gdAKTSJh7dfwqJZEq0saG/3QS/5QaHjSaRO+n90FxX49q9k0JKbRuXipDQ8YvRnN4VdwrH9plKxkSuUbK7dQlSjrjP3s2NeH1/K57Z3Dhlx8Yw0wVpvtzkBEbGxEBMRzKVyZE4yAXuii2KN9Ww8TKJ3ImoqZjqvK1NYXgVwOdRxnQPquO0RrggHTPT6DjRiw0OvcvTR3rwwM5OtB+7NObrJyqMZ5hSMZ4x6VFGDQ/Z+0g6F9qX3+cR3v5kyiqS+uSy+0Sfo2Irxk81fHVOInciaspn+MjeHGoZ4HMxozXVYxMEcgsAZraQL6MophtYtag276pzrH1wHSWm3NCNDDTVU5QRkzGtRowyHmV0XD++ZAG8koFz8HQfdCMNE0BndxTNdTVll2EkUzLjZWhoCJ/5zGcwd+5chEIhfP7zn8d7771X1GtN08STTz4JRVFw5MiRUh1iWUGGD2AVDlrRfhKHzva7GjV+nxfAaJxfgTUgx2OuqB6lYPaD6rjj8yqUKRecTsX7a++Cpnpdtz14uk94LAtl0U1EM8Awd8p4PeSAdf+/svfJvEZ7vn06W744vf3NdTViTkibVn2xcsswkinZjPSZz3wGly5dwksvvYR/+qd/wpkzZ/DFL36xqNf+1V/9FRRldoowSKBLAipqVX7wdB+2Hz6PR/efwprF8xEJaVgWqRZhJCeqR0FIU0UWkhOqPOo0Spoi1YiENBiO9AzqbM0w08kzmxtzQpyvDcShG2loqheRkIaNy8PC+J4XrMKqRbVYUK1h29oP4JnNjcLQKcfxPJXHVIYff9ZRjIdcNkYUWMb6op2duDlsuG6Xb5/0sFcBdrQ0iIVxc10NHt1/CmeuXrctgCdbVznZlCRV+sqVK1iyZAl+8pOf4EMf+hAA4MUXX8QnPvEJ/Nu//RvC4dy6C8SFCxfwG7/xG/jpT3+K++67Dz/4wQ+wefPmot+7UlOlCUqNBix33pmr10XPCepzBFjF6rr6b7iqwvNlVDRFqnEpGsfS8GhTx1TGRNiR/lyo+Vex2RrysTLMZKB6FGRMMyd+DxQO8RRqOFfpFNuob7rhRq/58SrAgur8JSjkHnZuWXWEs4+X816tqR74fV7saGmweVPkxoxBv0/00JvKFGli2nsbvfrqqwiFQsJwAYB169bB4/Hgxz/+cd7X3b59G7/927+Nb3zjG1iwYEFR75VMJnHz5k3bTyWzdXUdLrStx4W29ejqvyGq63oVYGl41Ity/GIUQ4mk+N+rWAZNSFPzGhc90TgWVGt44O4gkqm08L44Lxq6GdI+Zao11dVF71wxsuEyfsrRE1AuaKoHQb8PadO6KYc0Fc9sbsTjSxZgOKsDmI1UguECsOFSiDkBFc11ta6esJCmCpkA4J5VR9BY0FQvNNWDak0V3hiq6XKhbX1OGIg8MDtaGvDKzsewu3WJ+L+cKckVPzg4iHvuucf2mM/nQ21tLQYHB/O+7o/+6I/wkY98BJs2bSr6vZ599llUV1eLn4ULF074uEvNobP9BZtbOZ/ftrbe1qjxUnS0losJ2KzxOQEVqxbVIugfLd1D7QSIjAkMxHQcuxjNWamSBkb1KFlBmBceRcHxi1FEQgEosCbXuG7gwXvelxNvlW9OPAdPjGJu8IUqKM+08y5rVGqDfqxZPB9eBVgWqRbjnHp+DRuZnBApGTlUZVeBdROX9VxjnTOn9gu4MyNT9SpspM4SivmeNdWDmG7gWJ7edWsWz8eOloaC1718nZgARlJp+H1exHRDlAoYNjJ55x1ZmlCu1XTdGJfxsnPnTiiKUvDn5z//+YQO5NixYzh16hT+6q/+alyv27VrF+LxuPh58803J/T+U8FYdWDo+aeP9GD74fM5XhhqG0CGA92cqWBdx4leDCWSwmjZu7kRXf03xOCOhAI5FwFdYD6vgnC2nszu1iUYkTwz0dgwwiENpmldHN0D8YJueDcNzkQZq92BfOFOxttOdBea6sUzmxvziuWK2W8xx+8suCbjvPnl64PlNiGXG5GQhkTSirkrsEr9n7l6HWnT0rgMxHTs67wiPnNA9eKNodsArAmBSp2TkbNqUS3CIQ27W5cgWOXLea+mrH6sKVJt8ywaaTPne7kTL4KRNmGao9qyiQg2C5FPxFluyJ9a9SgVMSbzke/I5XHipj10e51zPBy7GMW5a0Pw5Bkn1nmzngtpqi1cT9eAV7HuDfK841wo30mNsuliXMbLV77yFVy5cqXgz/vf/34sWLAAb7/9tu21qVQKQ0NDecNBp06dQl9fH0KhEHw+H3w+6wbzW7/1W1i7dm3eY/L7/Zg7d67tp1wZqw6M/Hhnt5XiRoOMpqal4WrsaGlAJKRh7+ZGXGhbL/4HRrOOOruj2Nd5GQMxHYlkGq/vb8W2tR9Alc8rVqCAleNP9w25GaQ8SQZUDwZiumgOSTde+w1/dChNxJUt99eQL9P2TY0IafkLQW9b+wFx/JPhmp7ILkKaiit7nwAABP0+V4OhmP3mO363CSmkqdi7ubGgUfTS5UEMOzxsmurJEWNPlDuZbvK91hqbXqHlojBoTDeQTKURCWnCONYNy7jxKsDjS+5FPGtQDxsZNNfVoLM7ahvT9PeOlgZRWoDGdvdAHK1NYRx76qOoDVbZjiljTiwrJF8oixYAiWQq7zmYKOPR9jyzudE2qd6p+TCe1ztHYNuGpXf47tNHMVfTJz+8UHj/6DxZ49h+1pxFFQHLu5jvmjXSpihwumbxfLRvarSFgA5sWSkek+cXp7FSjo0Xx6Kkgt2f/vSnaG5uBgCcPHkSTzzxRF7B7uDgIN555x3bY8uWLcN//+//HRs2bMCiRYuKeu9KF+xuP3wend1RtDaFcWDLSiGmIrwK0Pdsq2srAhL7xqUu1JRRVBv0i9LPMqpXgZE2ocDSs1Ccs+1oD9ImhBpdrhewcbl1bHQMJPCSoYmh2FoZkZAmUsU3PvcyugfiaIpU49hTH8UDOzsLvs55fDKa6hWTnJOJih0VABuWh3Hm6nUAEAK4Fe0nJ10YGtJ82NHyQVsvK031ojZYlXX1/lJolihE6HYu6JgPbFmJh/a8mPecjAcFgJIVYsriwGJF3U6e2dwo+nnR2JbbZpCA8KE9L4hxRWEheTtgVDDuVazijvJ3de7akLjGVi2qxdNHesRxX9vfiu2Hz9vO4UQFv5pj/BcjWh3vdXMnaKoXyVR6XEZ/qQTCUy3wn+gYnSiWN8/M+V6tnkSZnOtRPr5C51z1KkilLQ/5eAS2d9LKppRMu2D3oYcewhNPPIEvfOELOHfuHF555RV86Utfwqc//WlhuAwMDOCDH/wgzp07BwBYsGABGhsbbT8AcP/99xdtuMwEqBAdGQeJZEqkPJNo99H9p9BxohcDMR1tR3uE64/CTHs3NwqXoTV5ZzAQ0xHXjRyxLRkuJiBc7AdP92FpuBoKgKHEiLjxE53dURw624+2oz0YiOmuhgvpEIoRUoY01Wbxv5sYsf12c7mGNFWsFA5sWZl334Um6aDfN+7VpqZ6sXdzo9AXOZX7YzF+97iCg6f7hDGqqR4MG2mxahqMW4aLV7FCI+SxG331qPeCvrfdrQ+N+3OTJkp2QJgATNN6TL61FjspkNeOhOF0HuWYu6z7chMQBv0+sR2lSUdCGlqbrN/tmxqF8D3o9+HctSEcuxhFWirgRWPUhHVTlyuKKoDw1DgZ7zksZpmoKKNatskOKTnRjfEZLsDkCYSdhdbyGS75zkBIG/+1KzPWpxjPvvNtK99rdSO3aSKN6REpJZlKXFTL3lbpDWhMREIBREIaglW+CRlhlaJrKUTJJPp/93d/hw9+8IP4+Mc/jk984hP46Ec/iv/5P/+neN4wDPT29uL27dulOoSyYSyhbr7t5G7Sn/zwQiyo1vCLt29hIKYjphtQYF30HSd6ba+jgXlgy0rbhWECqA1W5WQQAaMGBK1gL0XjWVFwWrjraaJpbQqL0JJXsbvHaYUvGzAyqlex3ZQ3Lg/nKOCdLswH7g7mHO+axfPFxTfWec3HmsXzsbfIHjeqR8Hr+1txZe8T2Lq6zjVGnG+Sk3G6f2U9Et3srGwB6++YbuDtm8MiTFQb9Ivss+a6GhEGlL8TwDrP9BoS/NFYOXi6D4E8Rd3yHndW/+Scu9weK5Y5ARUP3B3EgmoNqxbVum4j674AZEOo1vhRMBpqlce8/Hvr6jpb3zCncXfwdB92ty4RoUfq7E4jlLQCD94zBwBsIUz5YzsNDbmSqby9kmd7Qj6XYxkKlqi+4CZlhfjswoAvXCgTyG9kxPRUyTwnpBEpFrdtQ5oPw3kWTprqxcasHuvctSF4pJpmRsZEXDcQ9Nt1V1TOfzSspIixr6nevMb9TKZkxkttbS2+973v4datW4jH4/j2t7+N973vfeL5Bx54AKZpFtSzmKY5rhov5UqxYqhC29FzsjFQnfU+AJZehYwYKmZ36Gw/WpvshkoimcKqRbWiOR1dqLSCpRv9gupRIeywkcG2tfXCgKL9UBaUnMoXUL04sGWlWDkEHG0LglU+3DM3IHQcZ65ezzHsnKuC4y5hEPIi0LmRIf3MWOLFrv4bOHdtqKhVlpExRdVjINfA2n74PNqO9uDxJQuyhdDcLy3nhEMhn0QyLbxEI6k0drc+ZHvvW9mCVOSJmBNQ8dLlt6AbaVRrVqZZIpkSn8VImzZPGnkirPfU4fd5hKfC6Y3zKPmFn3TslJUW0tSiJlCPkqsBoSwLEt/K42D74fOo39WJjc+9LB4nDZdupIVhJhu9ZPzL4x+wVxKVx7V13i3diawL6Oq/Idzw9Bhl+sV0d52K09Bw2h1kpCrZc9u2cal4rJCmqxDj9ZyoXkVcF5OZWl6sAVWtqXh9fyuCVT7oRkaMXRqXOcdbQsus0L4nEr4iDyddN07jyqOMlp64svcJUaPr2MVoztgxkVu+YkdLg23hAph4+kgPYrqB2mCVawr0TGd2FkeYYooVQzm3IyHumsXzhbGwIXvzIUv7lZ2PiRU/tTKXhYoHtqy0ZSfFdEOEms5dG0LGtCaVbWvrcehsP45nXepR6eIxAbQfuyTCRMcvRoWAsrM7atMD6EYah8724/7auwBYjb6oF5PqURDPHmNMCmGNZdi5eQnSJrDnSI9ooeDkwJaVeT0hdANPJFN5UxQJ+R5HVY+BXAOrs9s6b8cvRnHwdJ/NoLNj5kw4CiDEpgDg8SjoONFru8GmTYiKy0G/DzHdECu7ZCqNtqM94nsgo0L2pHX13xBjRRb0nbl6PSe0ljEtY9atnH4m620zMib8Pi+Cfh9+oyk8pgGYMa10ZzKYncihMPl8dmcziw6e7rMZ7mRsy9BnpfFP45wMvkQyZRvXdD3IlawpY4+ur+a6GrQd7ckxetygCcztXNBkROd26+o6cSxxPYWN2ayQfBWxJwMjbaKr/wZ2tDTA7/MWZRxoqmfMDDpvkUZGTDew8bmXbfeLRDKVU2iTjEaneHWiRp4b4wl/Ob/Tpki1zbhXvQoC2fvM/bV3uY7vjAlhQJMcIN9ZU7LvIT9P+hQKhcrGTSWJbCcTNl6mgGLji87t6H+K2QMQNx/Z0t66ug4jqdEbe2uTlSI7ENPxwM5O3F97l9DAUKhpz5EeUSNjJJXB1tV16DjRK6WeemwXqJExRZiILtRhI+O6Sjl4ug+vDVgr1Yw5GirJmKbNUBhJpcVkWugClL0Q5CIF7Ol/8g02phs4dLYf7ccuuQofD2xZKQyAsZDvcU5tDnkHth8+b+v4TcaZDB2d83iomBStqEKaCiNtIqYb4gZLnhB6b/KOLctmffl9XvE9mIAwKgDYJu6xajjIehxrQlHEpCrPT04vTmd3VIwJ+kxuNNfVYOvqumwGmWrLMNuQ/U2fkc4nZbZtW1svxi8Z2277J12YHCYjEXtMN4QnUFM9Oe9JrTl0I4OYbghhb9oEBuPDYtzlM1ACqlW9dO/mxoJev4GYjo3PvSyuBROWXql9UyPeTYzYvgdN9dreS1M9wviWazO54fweNNWLoURSrNiLm8AV1wwYOm4gNxRaiO7sfYGQxzj9pgWOPKYioUBerxfRFKkuifF3c9iw3bdeG4jbSucbaVOMmdcG4nk9NyFNFcYwFR+lEBKhqR5c29+KY099VIwj530HGP3OVY8y6zwuREmyjaaTSso2ypcxlO+xQmWbnVlK9bs6bRcRrSRlHY2mejCSyojXULaMAmDv5kZbBofqUYRAlW7qS8NWuwGqekqZJ5GQe6lrt2wLylwa6xz9Kq6L1250ZPrQcZLOBiicvUDqfU314vEl96Kr/4ZrxpQMnXP5+6GMLMoAA+CayeNRIGrkuKGpXvh9HhGzlr8jQs7Gogw0eoyOqbmuBl39N0RWGT3v3N55fjtO9CKZysDv84hMNfrMgD39lip10mvpHIQ0FbeGDXE+aEz4pEyJUmdDyGXOZej4aVzL+5Ovm1WLam3nnvRdNNbfGLqNZLYA2P21d+FSNA6PYn0+GnuhbIl18uKMJ0uJspNCmmr7HmTI2CLhMWA/9/K+RlKji4umSDXeTYy4thNxP5bRLD2ypcayURRYC5vhbLkG+Xos9D61wSpEs6UYZJzl7mWaItU5hhCQNcDN6as87DzvMrLBLxPSVNEKhq5DZyKAfK3RGCjHbKE7ZdqzjZjicNO4uD1Gq2VnKEKO8Xf130D7pkZhCDi1LhQuWrN4vrDmd7cuEZlNAEQF0w3ZlcBQYkTU3SDdhbwafTcxIrQCcs0RMlzotfS42/3ETc/ido6c3VBJxClnmlBIjbxL+VakdGMjMfNgXBeCTBlN9QiRstw2nr4f8g7I59rvs3sgNNUjDBc6H7RqJmiS2Lq6TghU5RWk09Mghxedhsu2tfXie2yuq3HdnvQg9ForjOARq0Fazcu1VUZ1MYoYcx0nelHl84jnKEPNoyjQVC+qNRU+7+j5SKbSeHT/KWx87mXhscqH8zooRvROXibyspCxTWe6WlNzbvTOcB9V46XvlbL/3hi6nQ3VWStsGvs+r+XJWZYNJZDXgK61fN2uI6FAjvaEjOdkKm0r9Kh6lKww3ivOifO6cV7v5I0jncW7iRGbEHks5HGcMS3jXPYQeJXR64v0HGb2MwSkIoFk+Li9r1exvKqv7HxMbCuHKo2MKc4DnS/ijaHbrtoyI20WIXQuPO0pGC1cOBYehba3qpBT2jJBNbAUWNcjjVGnp7ir/waCfh90Iy0KjsqeXVmMTx7MSs8WulPYeJlG3LQwhfQxsl4BGL3Bk+hRvtF39d/AM5sbbV1006Z1s6aJuONEr5gMZL3LmavXcfB0H3Qjnb0QTbGapjRTr2J17N1zpAdD2ZTm1qz2gTJdqjVViPLyudEDY9xI6HxQDFj1KCIEQpABQyE1ShVv27hU3OCc7nUFo6tq0lY448wjqQzeGLptaxsvfz9yWjtB5xawbuQjqYytCqxupHFr2MCTy+6znZO4btiEppQmHglpuLL3SdtNSr5xOXUeB0/35bS6d9veWbhNJhzSbG0mAKsIXEhThTaFtE7WZ0wLl7kJa9Khm7DshRrOpux3Z13rhQxXuePtivaT2HOkZ0xtFOmBKATXXFeDg6f7RHjILRuDDFAqVkc6Mef3StDETO5/ukbeTYyI9wYgriMykJ2CTkARIkznJKkbGdsE7PMqmBNQ8fiSe8XYk6+bmG7gzNXrtrAW3SsoVZx0T3vzaI4IOXOFiqoFVI9YIJFxsTRcLQxTv8+L9k2ji5dU2sRgXBfnV/bAaKpHXJMZEzh3bQgAROdvqqo8+tmt9xiMD2NHS4PNG3ju2pAtXF4szkWgV6HvxxrzJqyxc+ypj+YVExMZ0/LmJZJpMfbpq1NgZYmSJ+rM1eviOrY8v56sAetFIpnKMS7p3nTsYlSERAHYUvlnM2y8TCNu1rP8mGx5u21PK2vAugDJ4KGsjH2dl7F1dZ2tYigZMLHs6pQylGS9C2DtS76Q5gTsxkf7pkZbOjXd9MMhTWg2SGS8ZvF8BP0+EauXtQ67W5cUdY6OPfVRXNvfinvmBmyiY4Lq3nSc6LWdJ+vz+0VGVSSk4ZnNjbi235qc5BXrawPxbPZDQJwrADZjcqwVj7MmDukvLEyx35cuDyLo94mJy4Q1mdP3RueO3jef50HWeZC2pbmuJq8BLBtf8t80MVBcHhhtCkcTn2wYtDaNfpekgSlkiIYkXQ8ZkW7bj1aUhk3vRa/NpzmSP18om4115up1m1jZLTNp1aJa9D3bKprR5ds/ebMeX7JAHJfcJFI+nzS26bv2Ksiphi2Lqd9NjNgMWRoupIEiPYX8OXa3LslZEMiTO50/ALaxJGuOCGqnsHF52OZxoaxB3ciIBRKJjN8Yui1ta9qMxFRWH3f8YhSd3XZBPHmXyKin1HW6fmO6YTPyqAI4CdZlA/TYxagtzZi8IPIihRYuo/97c4zYdNYzKmtq6Lic1xAZX7IXKp9B7fMqaDvaY/v8h872C3E+dXgezhr6xy9GbYa2fG8iz7qsX5vtsPFSxpDl7axNQZAF7lUsY4JuzpSVQb+3ra0XE6hz4gFgK2BHxoZ8M6ImX5rqtRUUky+uoUQS2w+ft5U8p1ATTSJnrl5H0O/DmsXzRYijGLenPHHTZ3Grb+Pcfvvh81jRftKWPSLrRg6d7ceBLSttKeNWxtaoXode43acToNCvjERl6Jxcb5lTQ0VDqQUXFkITZMVIRcldPYnkUN4JEJ2m6wJMr7OXRtC29Ee4YKW66mcuXpdvL882dLk3NoUtgnHqabK40sWCNe/NfFaK9mmSLXNE2ClCdsNVzqXzs8pF6mTxzjgfn3I2VgA8t7sZWOXXic3p3Pun4wVStGnc0FGCR0X9WCaF6xCXDegehSb4e8swCcbj2RYb5DCVrJRKRuy8jigsCY9JmfFkQiZ/ibR9oW29Xgm66Hc3brEZijSogaATZhqjdFRrwUdMxm4nd1RIaym8UwGnky+kCtB4T55EidP2tbVdTbDwciYtvYgJuwl9muDfhEGByxjiPZBgnA3AfaC6gAe3X8K3/+JvVeebmTEQo08U0OJpMiuBCwDh8T7tABSMPodkSFOej06WhOwXbt0b6IxIo/tSupBVCrYeCljnBe4W9dpmhDkmzrdPDYsD4sbHXkAKI5PExVpAkxYFzY1gRyI6Xjp8iAG47rIVnp8yb2izgutWuWeSuTRcVbOTKbS8CrWb0q1pgaUcu2UfNBEs6/zimvNElqR0c2OtqeUbt3IiPTUjc+9jKezIQgyfgDL+CN9jjzpUhE8p5HiVuXYWQmXtDf53LxyZkxrUzhnNZ1Ipmyiabf+JLSyJ+Oi2JXZWIYxYH1fsihQzn6Tz5+znspgfBhpE7g1bBmybwzddt0PMGpEOj9nc12N+G5kfZNMvgmQrosdLQ3jutnTMdD3Ke9fNpoptdppIJKhENMNdEshNLf3J6E0GfvyOaHvpqv/hs2oPHdtCPW7OoVnlc6VHBqKZz0XdP7IC5dMWcYylRdww+ltBUZDLAqsa+TxJfcKY4mOWS6CSBN7+6ZGUBG6DcvDeCabOUMZT2euXkf7JqtS9aP7T2HN4vkiy2pesMp2fuUwKIXE5Xo1VT6v0JeFpHISajbzj4TNCqzSDQ/teQFnrl5Ha1NYNPOkhRpdf4PxYRHiJOj+QJ7JM1evC52PvAghvZHf5xWGERkmznu20MBkP/tQIlmw5lUl9iAqFWy8TCNuoQD5MWfs3W216LyBOrOO5Iq58kQqu+dpNZXMxo8pFKFnU6Ep7Zk8KORCbj92CYlkStw0yKggF/woiu1ilt2odGMvRpBJegu5ZglN1gByzkUg60miVeuhs/05GQpk/FB4zYR90nXTW8gTrXzTphsLudqpAJeb65k8Ce8mRmwTlaw1SWVMcXMDkOOpct4Ix7MyK7Tyda6ond4eCkPI5w+wh7DIQyOLWJ3fs6y5kQ2ObWvrbRqefLhpU+QsJQBifMoGHf0mbxwdE2kOyKsn75/CLfL3eehsP1a0nxQGuOwlklNZaYzKmibZ0JGNwI4TvcJb4Rw3ZNQMGxlbrR6aBOWCk7LOxRL7j7ZA2Nd5xTau92QXEQCEXmzN4vnCqCAPk9OQkJkTsF9nsh6Itg36ffD7PMKzKOuuuvpvIJP1mJAhIH8vzlAbifZrg37oRhq1QT+u7H0SF9rWi9Ydsm7Iq0Bo8Oj95fD5mavXbXWQaOwSlBFI2hXA7pWiex9dTzS23DRY9L3Kxvk9c6xQNXl23CjXfkTTBRsv00ix2UbjwbmiplUCZd/QTVx+H7qxDWcLzNENisJEAanLr2yU0KqyNui3hQ/kmylgeXTyCXbphlfoc9MNxVmXQ56sZQ0Mbb+79SFbafm2oz1in02R6rxZObJnx01vIU+08oQmr0TlyUX+rM9sbhQ3WapoTK5nmgBJYE1GJX3GjhO9tsnSzXh1rszyGYXOiV/ezvk5aBUvT7oU/pPPH42bdxMjQkANwHb+6Hsmr4OsxZBFxTSBj+VFcn4+eRxRqvKwNFnSNvQZZBFzV/8Ne08ZB87zLRsgZADTeKPQWNvGpeL7I4OMPjvVaSGPZNvRHjEhumVGkcG5YXnY1hrD6T2MxnTMC1blFLwkrwppLORwhbNYHx2rMwQpe/fIGKPzLJ9Ppx5INvjlBYU8XmWDWu6dRscAjOp3nJ4lOZOOFnky7ZsaxWJHXmw5PU30Ha9aVCuqWlNWlHPcyUUTz1y9jm1r620h13PXhsRxUKg1n1heNnzl643eK1/oWH5+tulguM7LNFJsnZdC2zufmxesEjoLt67UQG6dAAAFawg435e8O0vD1WKiou3IK+Ts3ksXNYWUho2M6HI81mcrdA7kDsCF6h/QeZD1QXL9E7fPbNU/sep6TESnQ/ujG1UoWwNETmt2hkvcarnQdnJXcKfOKR+FPmO+7Zy1YORzRzdh+djd6s2QEU2f2TmWnLVo3M4dbeP2Wd32s21tvW380aRKXdVprMvbOMc3ANvf8rbycxSC7B6IQ/UqaNuwNOd5Qr5e3hi67dL13YvhrJeCVvj5jk/+v7muRhSaDGVr6FB9J7n2kPOczQtW4bWBOALZOkfkSaBaI3KNGaoPI38m5z1F7nLudu24nbuxcF6vgP0eRd+7gtHaPXKdH+d1lu8989133O4Xbte0jHxcIUftHef4LHQ/cX4OeZ/yteTc3u1aqjTGM39PXr1lZtyQq3+sxwo957yJA9ZNS3a5DiWSGDYyCIcCGIwPY16wKueCJUNDFnDSPratrReTE/3vTCOViygBowp8p4vZ7/O6Fior9Lll5BULubGBUbcsHYO8ym6uq8mGD7y2bAp5Mnful1bVzkJv9Px4jlM2PgZiOgbjui3URDd6uQqu09CQJ4W4bti0F/I4cAst0TlwOze0vdOYlb9XKmVO36V8g5RfQ8f56P5TYgJ1FtuibWhClzPmnNvIY8r5WeXieHLqMk1uBLnv5YmXvtexvken2BWwhxkpvEHhjj1HrMwSyngjyCP1xtBt3Boe9eRVZUMofp9H1Nnx+zwI+n05Y9Ht/8G4npPJUuWzisS5hQPpvK5oPyk0btS9vuNErzCEZCjc7Lye5KJyqXQGg3Ed564NiffoONELq3+RFQaRvTey8SUXm6T9k0dmX+cVDBtpfP8nb4o0fAqnkRFgYtSjKj9OY9IZ3nKG1WUv2rlrQzZDjvZD28jb0ril4pZymI8+g1xIkO6rspdPvqeSoUX3KjksS2M8nxGW79qd6bDnpQJwXnAyTiudBribNU6P0YqPVmvyc/lWOtvW1hf0zsirMU31YnfrQzbPC4CcSqaA+4o2H07PjnMVSqt9uTKqXPGVfrutYOT90E1EXhmNN97stlqmSrapdAapjGnzPOX7Hov1zo21+nJ+v06vSb7jzndcY3125/eU73jGev9Cn9XNizbez+c89+R1IKPHbZzS2JC9nBQSgPRapzdnKDEC3UgLb4F8faxaVCv2/dLltzBspLEsYq/qS6t1eYxaVVnTQljrtkJ3fuZClbQVULhy1DdE3hPaTja8KOxCW4clD4P8HvK5c16XdM7IU0HfmbNKOG1Hla7JkDeRe49y7k8+Jvqc1/a35own+XiK8XLkuy/k8x4Cdm+e04Mj36OSqfSEPdSVClfYnWHIVUCdsU1ZfzGWKp0ec2t0SBoVEivKpe/JUHH+L2ecyEWUqK6MnDVBq88zV6+L3h5O0d5YOh+nVkHmzNXr4vgo+0I2ZJxaFuf7UaybJiFnvRY3fYkbsgbBTR8xkkrDyJY8p+wJOXZP3pl9nVfE6+QMmHzHIn/fbjFwel7OcnDTxshxdVmcWyhl3ImsRcr3nbqNT/nzyplg+T6rHEpy+3xumVeFzh1gL2dPGhaaZOhYaIy8MXQbC6o1rFpUK7RLVEfEfUxbeyc9i3xN0ITU1X9DCF0vReO2bDnn2Fy1qFaIVuXUcKdAeo+UXQdAZAeRl4hEzdRni0S1I6m0SO8nw4PuEX6fVwh5l2VrFSnKaHd70peQhogypKjIpYLRiswUSpbvL5YXySuaFJIehITEgCV0JYGx7HkDLB2RXJFW9qLRN3HobL9tjMslJEiH9PSRHizaOVpLiMbVUCIpRM50PyQNEHWYdxP1O68N5/iX71F6trid7D0q9l45G2DjpQIYrQKam/0x1qR67tqQTYi5bW09/FJJd3lCJPEpAJshsHV1nbhxtTaFbZMfAOEGlcWrZOwAlmt1XrBKpEvnK+41ltvTbcKlmwSlYzuPj1omvLLzMfHbTYjqfA/6XE6RbD7GEtXRfuUbpGwEkhuZalRQx2jZqHQW5ssn1HO7wTnHifN/eQVIk75TiDkexvpO841b5/l3fmZ6LZ27fAYd/ZZrlrghr2TlmipyITNnlp/bGKFibLXZNF/584+eW6vM//21d9kMVtoPHQcdg9Vg1ZrA5wWr8mZ5bVtribzj2XYOFJai9yaDLJlKY0X7SXSc6M0RpdcG/TYjyM3Yl69xygo7eLpPpBvLPnznJC2LWwHLgHs3MZI9Z34h/qbr9+DpPlGd+Y2h26KmkCx6lb93MgQJudYLiWkpVZu8RXuO9GDPkdFu7HLtIrkKr4nR+j50TbhlTFEJiONSFXJnnRp5/AjtVLa0xcbllgcOgK2Ni3MBWmw5hJkOh40qiPGIeZ2iOqdblSZEN7HlS5cHMWxksEwS68lueDlkdO7aEI5fjMLnUeDzKjaBnrwSIhRYN658YsSxPqeMHAYDINzHxYrWxhLsOrVEhfbtFl4BRlescmzfzb1M7+sWIpQ1HvlEvQDE3+Sadwsz5qOQwHg6XNT5PjNRjEiRwiNyeNTJWE0rrXCPe0NU+q4ohJJPRO0MccihAQA2YWs+8aZ8vc4LVol2Fsee+igAiBCLHLqRw5WE7KFxNhp1C2M5dRxu14YskJXDWLIoVW7mSvcUeb/OMJ9TQyc/7iZ6pX3JGhS69Ti/N+e+3e4fh872Y1/nZeF52rjcHhoknpFCYvTemuoRxo/shXP7DM7vvJhxPZMEuk44bDRDKeRlca62acUO5IZ+gNFaHHThy4XdyF352kBcrCzdVpIHT1t9dExQP5uMWOmSJ4eKNBEmYFvJu3kJinWN0jFVa6pttVks+T6TfK7dKpwW2pccXqF9yvUk9nVeFq+RDUbyIrjVLpHPpbziko9f/lsOR7ilXOb7v9BnmWq2rq7LWbG6HWOh70Qul59vlUr7cfPC0fdHIRJnWfnR1b5i8xrI0HcMjKaMO70eFBaiInQUonCGNOjzklCYfgPW9QxYDSKdHihnQUoZ+Z4i13DJdw3K3k5g1ADbttYS8VvNBXPbGVDhOmfmkvN7oO/z3LUhZMzROjn0uOzRkXu60eegGlMbpFYk9L0508rpefn+IRdHrA36AVgGzYEtK4XXgwhlw3/03lRh+sF75uDWsGELDcljjLw3bjWu3Ma18zot1lM902HPywwhn0AUsItbZc+LvEqkVaq8akimMtCNdI54cbR9u+XW1R0uYbeVzsHTuWncgLsY+U7FsZO1jztFNk7kKp8kkpTTPU3puXyemXwi1Hzv60xHdq7Y8nluymU1V+wKM1+qcz7herHvNdaYKCbtm/arqR6MpDI541y+Rp3XZj7Pk9s1U6wAmtK7Za+NM/uHrmunUFceJ05hdD5Bqvx9OMdvoe9mrJRv57mS38c5Bgg3T5zzO8jnYS7kLXV+13KCgHxssqeKkN9zNqRCjwV7XmYhbhoGp16BVvCygIwYLey2RFSGpC62dIHRamG0fXtGuNMjodGGdHLVUtLavLLzMdGhWRbDulXsLFYcW4jxCtvc3jOfZ2IsnKJd6oNCBcZkfYkloB6tfuosuS9/jmJXXLLXSN7e+fp8nptyYaxjctMZuXkgJ6KnAnLHhHM85DvPbvulkvFyheuDp/tE01LAXvXYKZCXPzNpT2TvnFMLkU+D5ea1kT2EAMR1TcclFxN0CqPlIpiUsiyLnEmo6/TekleJOio7rzG3CtBOzwnpcg6e7is4BggyypKptO38yPdJ0va5efvk783NoKXXLqgO2I5d9lTR/VEunplPyyR/t+V2bZYD7HmZoRTyRoylwZDTDWX9hrNoW74aDXI6ppw26tQOOFc9zn0Uy0RWzRPdbyHGWok707EL6RIKpWIW8jRM1mevBArpjCb62Qudb7fvtZi0cCDXW+KmZXGOFUqt9/s8Yt+Fxrp8fMBojRDCWTjSTVOVzyswVgo+4fSqkFfR6Y0d6/O7fReFyj/Ini3AyswMqB7sbl3i6l0eSWVcyya4eSNlnZ7T01TI8+LmqcqnaSrk6ZlNsOeFcfUk0IVHnhO3VFa5twqlC5KGhVT41AtEbphXyNMxWq5bsWkHnN6h8XpLnGnGhVbNE2G8Kx6nR4Ve51wFO0uuO3UJ8mvpcwC5TQzzrTLHex4rFTdtzni/d6c3xXnunBoP53iQPZKFzrfTw0jHLmtZZEjboWdL+RfyJLmNO/ncyNd6IU2V0yvgzJoq9B1sdLTuoMc3SN5Yt9fl+/xu34XTuyTvR/ZskQ7P2SdI7tk1mlKdEe9N9xJ6D/KkmIBoQSKnizv1Ks7eXtvW1udkaeY7f2SwTJfGrBJhz8ssYqwVO2CPCwPIiRHnixvv67xsK6gkvxe5ZvNpYZxZDMWuPMotFjxWLFxewQH2gmeFdBVuxbjY8zI5jFV0zK0gnkyxnpeJfCeTte9KHQ9ux12MtgfIbQHh3K8zkwlAjseFrrVC15+bHihfRmA53KPKnfHM32y8MDbGMnAKiQWB3NRreT9ugl3ne47n5lopN2W3tN984r58bmWg+H5GTPHM1Il/pjJZ30ehkLX891gLAg7hTi5svLDxUjLyxdydKx237fJlEMyG1Uk+L5NcLj1f3L+Y1TfDMEylw8YLGy8lo9iVhNt2+Xo0zfbVyWz//AzDMAAbL2y8MAzDMEyFwdlGDMMwDMPMWNh4YRiGYRimomDjhWEYhmGYioKNF4ZhGIZhKgo2XhiGYRiGqSjYeGEYhmEYpqJg44VhGIZhmIqCjReGYRiGYSoKNl4YhmEYhqko2HhhGIZhGKaiYOOFYRiGYZiKgo0XhmEYhmEqCjZeGIZhGIapKHzTfQCTDTXJvnnz5jQfCcMwDMMwxULzNs3jhZhxxsutW7cAAAsXLpzmI2EYhmEYZrzcunUL1dXVBbdRzGJMnAoik8kgGo1izpw5UBRlug/njrl58yYWLlyIN998E3Pnzp3uw5k2+DzwOSD4PPA5IPg8zKxzYJombt26hXA4DI+nsKplxnlePB4Pfu3Xfm26D2PSmTt3bsUPzMmAzwOfA4LPA58Dgs/DzDkHY3lcCBbsMgzDMAxTUbDxwjAMwzBMRcHGS5nj9/vR1tYGv98/3YcyrfB54HNA8Hngc0DweZi952DGCXYZhmEYhpnZsOeFYRiGYZiKgo0XhmEYhmEqCjZeGIZhGIapKNh4YRiGYRimomDjZZoZGhrCZz7zGcydOxehUAif//zn8d577+Xd/vXXX4eiKK4///AP/yC2c3v++eefn4qPNCHGex4AYO3atTmf8T/9p/9k2+aNN95Aa2sr7rrrLtxzzz344z/+Y6RSqVJ+lDtivOdhaGgITz31FBoaGqBpGu6//35s374d8Xjctl05j4dvfOMbeOCBBxAIBPDwww/j3LlzBbf/h3/4B3zwgx9EIBDAsmXL8MMf/tD2vGma+OpXv4r77rsPmqZh3bp1+MUvflHKjzApjOc8fPOb38Sv//qvo6amBjU1NVi3bl3O9r/3e7+X850/8cQTpf4Yd8R4zsHf/u3f5ny+QCBg22Y2jAW3+6CiKGhtbRXbVOJYGBOTmVaeeOIJc/ny5ebZs2fNf/3XfzU/8IEPmFu2bMm7fSqVMn/1q1/Zftrb2833ve995q1bt8R2AMzvfOc7tu10XZ+KjzQhxnseTNM0P/axj5lf+MIXbJ8xHo+L51OplNnY2GiuW7fOPH/+vPnDH/7QvPvuu81du3aV+uNMmPGeh9dee838zd/8TfPYsWPmL3/5S/NHP/qR+eCDD5q/9Vu/ZduuXMfD888/b1ZVVZnf/va3zUuXLplf+MIXzFAoZL711luu27/yyium1+s1/+Iv/sK8fPmy+fTTT5uqqpqvvfaa2Gb//v1mdXW1eeTIEfPixYvmxo0bzUWLFpXF583HeM/Db//2b5vf+MY3zPPnz5tXrlwxf+/3fs+srq42/+3f/k1s87u/+7vmE088YfvOh4aGpuojjZvxnoPvfOc75ty5c22fb3Bw0LbNbBgL7777ru0c9PT0mF6v1/zOd74jtqm0sVAMbLxMI5cvXzYBmD/5yU/EYy+88IKpKIo5MDBQ9H5WrFhh/v7v/77tMQDmD37wg8k61JIy0fPwsY99zPzDP/zDvM//8Ic/ND0ej+2GdvDgQXPu3LlmMpmclGOfTCZrPHz/+983q6qqTMMwxGPlOh5WrVpl/sEf/IH4P51Om+Fw2Hz22Wddt//kJz9ptra22h57+OGHzf/4H/+jaZqmmclkzAULFph/+Zd/KZ6PxWKm3+83Dx8+XIJPMDmM9zw4SaVS5pw5c8zvfve74rHf/d3fNTdt2jTZh1oyxnsOvvOd75jV1dV59zdbx8J/+2//zZwzZ4753nvviccqbSwUA4eNppFXX30VoVAIH/rQh8Rj69atg8fjwY9//OOi9tHV1YULFy7g85//fM5zf/AHf4C7774bq1atwre//e2i2oxPB3dyHv7u7/4Od999NxobG7Fr1y7cvn3btt9ly5bh3nvvFY+1tLTg5s2buHTp0uR/kDtkMsYDAMTjccydOxc+n711WbmNh5GREXR1dWHdunXiMY/Hg3Xr1uHVV191fc2rr75q2x6wvlPa/tq1axgcHLRtU11djYcffjjvPqebiZwHJ7dv34ZhGKitrbU9fvr0adxzzz1oaGjAtm3b8O67707qsU8WEz0H7733Hurq6rBw4UJs2rTJdl3P1rHwrW99C5/+9KcRDAZtj1fKWCiWGdeYsZIYHBzEPffcY3vM5/OhtrYWg4ODRe3jW9/6Fh566CF85CMfsT3+ta99DY899hjuuusunDx5Ev/5P/9nvPfee9i+ffukHf9kMdHz8Nu//duoq6tDOBxGd3c3/uRP/gS9vb34v//3/4r9yoYLAPF/sed3KpmM8fDOO+9g7969+OIXv2h7vBzHwzvvvIN0Ou36Hf385z93fU2+75TOD/0utE25MZHz4ORP/uRPEA6HbZPeE088gd/8zd/EokWL0NfXhz/90z/Fk08+iVdffRVer3dSP8OdMpFz0NDQgG9/+9toampCPB5HR0cHPvKRj+DSpUv4tV/7tVk5Fs6dO4eenh5861vfsj1eSWOhWNh4KQE7d+7En//5nxfc5sqVK3f8Prqu43vf+x727NmT85z82MqVK5FIJPCXf/mXUzpZlfo8yBP0smXLcN999+HjH/84+vr6UF9fP+H9TjZTNR5u3ryJ1tZWLFmyBH/2Z39me64cxgNTGvbv34/nn38ep0+ftglWP/3pT4u/ly1bhqamJtTX1+P06dP4+Mc/Ph2HOqk88sgjeOSRR8T/H/nIR/DQQw/hb/7mb7B3795pPLLp41vf+haWLVuGVatW2R6fiWOBjZcS8JWvfAW/93u/V3Cb97///ViwYAHefvtt2+OpVApDQ0NYsGDBmO/zj//4j7h9+zY++9nPjrntww8/jL179yKZTE5ZD4ypOg/Eww8/DAD45S9/ifr6eixYsCBHpf/WW28BwLj2e6dMxXm4desWnnjiCcyZMwc/+MEPoKpqwe2nYzw4ufvuu+H1esV3Qrz11lt5P++CBQsKbk+/33rrLdx33322bVasWDGJRz95TOQ8EB0dHdi/fz/++Z//GU1NTQW3ff/734+7774bv/zlL8tuwrqTc0CoqoqVK1fil7/8JYDZNxYSiQSef/55fO1rXxvzfcp5LBTNdItuZjMk0PzpT38qHjtx4kTRAs2PfexjOVkl+XjmmWfMmpqaCR9rKbnT80C8/PLLJgDz4sWLpmmOCnZllf7f/M3fmHPnzjWHh4cn7wNMEhM9D/F43Fy9erX5sY99zEwkEkW9V7mMh1WrVplf+tKXxP/pdNqMRCIFBbu/8Ru/YXvskUceyRHsdnR0iOfj8XhFiDTHcx5M0zT//M//3Jw7d6756quvFvUeb775pqkoinn06NE7Pt5SMJFzIJNKpcyGhgbzj/7oj0zTnF1jwTQtAbPf7zffeeedMd+j3MdCMbDxMs088cQT5sqVK80f//jH5ssvv2w++OCDttTYf/u3fzMbGhrMH//4x7bX/eIXvzAVRTFfeOGFnH0eO3bM/OY3v2m+9tpr5i9+8Qvzf/yP/2Hedddd5le/+tWSf56JMt7z8Mtf/tL82te+Zv70pz81r127Zh49etR8//vfb65Zs0a8hlKl169fb164cMF88cUXzfnz55d9qvR4zkM8Hjcffvhhc9myZeYvf/lLWypkKpUyTbO8x8Pzzz9v+v1+82//9m/Ny5cvm1/84hfNUCgkMsR+53d+x9y5c6fY/pVXXjF9Pp/Z0dFhXrlyxWxra3NNlQ6FQubRo0fN7u5uc9OmTRWRHjue87B//36zqqrK/Md//Efbd07lEm7dumXu2LHDfPXVV81r166Z//zP/2z+u3/378wHH3ywLA130xz/OWhvbzdPnDhh9vX1mV1dXeanP/1pMxAImJcuXRLbzIaxQHz0ox81P/WpT+U8XoljoRjYeJlm3n33XXPLli3m+973PnPu3Lnm5z73OVu9lmvXrpkAzH/5l3+xvW7Xrl3mwoULzXQ6nbPPF154wVyxYoX5vve9zwwGg+by5cvNv/7rv3bdtlwY73l44403zDVr1pi1tbWm3+83P/CBD5h//Md/bKvzYpqm+frrr5tPPvmkqWmaeffdd5tf+cpXbCnE5cZ4z8O//Mu/mABcf65du2aaZvmPh+eee868//77zaqqKnPVqlXm2bNnxXMf+9jHzN/93d+1bf/973/fXLx4sVlVVWUuXbrU7OzstD2fyWTMPXv2mPfee6/p9/vNj3/842Zvb+9UfJQ7Yjznoa6uzvU7b2trM03TNG/fvm2uX7/enD9/vqmqqllXV2d+4QtfyKmDUm6M5xz8l//yX8S29957r/mJT3zC/NnPfmbb32wYC6Zpmj//+c9NAObJkydz9lWpY2EsFNMs0/xZhmEYhmEYF7jOC8MwDMMwFQUbLwzDMAzDVBRsvDAMwzAMU1Gw8cIwDMMwTEXBxgvDMAzDMBUFGy8MwzAMw1QUbLwwDMMwDFNRsPHCMAzDMExFwcYLwzAMwzAVBRsvDMMwDMNUFGy8MAzDMAxTUbDxwjAMwzBMRfH/A/NOyCznaC0BAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot xyz o\n", + "x,y,z=splats.xyz[:,0],splats.xyz[:,1],splats.xyz[:,2]\n", + "# pinhole camera\n", + "focal_length = 1.0\n", + "px = x / z * focal_length\n", + "py = y / z * focal_length\n", + "plt.scatter(px.cpu().numpy(), py.cpu().numpy(), s=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80a52870", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'theta')" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# plot image of splats.rotation[:,0] depending on x and y\n", + "# show theta and phi scatter plot colored by splats.rotation[:,0]\n", + "plt.scatter(px.cpu().numpy(), py.cpu().numpy(), c=splats.rotation[:,2].cpu().numpy(), s=1)\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e369207", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "86472f94", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1179648, 3])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "splats.xyz.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1ae2e071", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([6.0000e+00, 2.3000e+01, 5.4000e+01, 9.8000e+01, 1.8700e+02,\n", + " 3.1400e+02, 5.9600e+02, 1.0140e+03, 1.8900e+03, 2.8500e+03,\n", + " 4.1970e+03, 6.2830e+03, 8.9580e+03, 1.2365e+04, 1.4772e+04,\n", + " 1.7271e+04, 2.0356e+04, 2.1797e+04, 2.3964e+04, 3.1041e+04,\n", + " 4.7172e+04, 6.7602e+04, 7.6863e+04, 7.3804e+04, 7.0490e+04,\n", + " 7.0885e+04, 7.3202e+04, 7.6177e+04, 7.8799e+04, 7.7383e+04,\n", + " 7.1340e+04, 6.0224e+04, 4.7399e+04, 3.4557e+04, 2.3587e+04,\n", + " 1.5506e+04, 1.1299e+04, 9.4020e+03, 8.4900e+03, 7.3060e+03,\n", + " 5.3550e+03, 2.7900e+03, 1.1320e+03, 4.6300e+02, 2.1600e+02,\n", + " 9.9000e+01, 3.2000e+01, 1.5000e+01, 2.0000e+01, 3.0000e+00]),\n", + " array([-9.84057236, -9.34688568, -8.85319901, -8.35951138, -7.8658247 ,\n", + " -7.37213802, -6.87845087, -6.38476419, -5.89107704, -5.39739037,\n", + " -4.90370321, -4.41001654, -3.91632938, -3.42264271, -2.92895579,\n", + " -2.43526888, -1.94158185, -1.44789493, -0.95420808, -0.46052116,\n", + " 0.03316574, 0.52685267, 1.02053952, 1.51422644, 2.00791335,\n", + " 2.50160027, 2.99528718, 3.48897409, 3.98266101, 4.47634792,\n", + " 4.9700346 , 5.46372175, 5.95740843, 6.45109558, 6.94478226,\n", + " 7.43846941, 7.93215609, 8.42584324, 8.91952991, 9.41321659,\n", + " 9.90690422, 10.4005909 , 10.89427757, 11.38796425, 11.88165188,\n", + " 12.37533855, 12.86902523, 13.36271191, 13.85639954, 14.35008621,\n", + " 14.84377289]),\n", + " )" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "splats.rotation\n", + "plt.hist(splats.opacity.flatten().cpu().numpy(), bins=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "65dc38ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0.8371, 0.8370, 0.9024],\n", + " [ 0.5582, 0.5965, 0.5719],\n", + " [ 0.5752, 0.6227, 0.5913],\n", + " ...,\n", + " [-1.1020, -1.0950, -1.1001],\n", + " [-1.0436, -1.0330, -1.0441],\n", + " [-1.2455, -1.2441, -1.2464]], device='cuda:0')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "splats.f_dc" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c79d7ebc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 1023.5, 1023.5, -0.5)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAHiCAYAAADf3nSgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz915NlSZLeCf7M7LBLnbsHjwySpCqzSFY170YTsAWwwGJmd2f2Zd5W9r/ax5UR2RVZzAgAARakAVSjSVV1dZHkPDMyuHO/ftlhZvtgdsglziIjM7qAqy3VGe5+7zl27JiZqn76qaowxhgWspCFLGQhC1nINy7yRQ9gIQtZyEIWspD/XmWhhBeykIUsZCELeUGyUMILWchCFrKQhbwgWSjhhSxkIQtZyEJekCyU8EIWspCFLGQhL0gWSnghC1nIQhaykBckCyW8kIUsZCELWcgLkoUSXshCFrKQhSzkBclCCS9kIQtZyEIW8oLEO+8HhTj3RxeykIUsZCEL+e9ejMnO/MzCE17IQhaykIUs5AXJQgkvZCELWchCFvKCZKGEF7KQhSxkIQt5QbJQwgtZyEIWspCFvCBZKOGFLGQhC1nIQl6QLJTwQhaykIUsZCEvSBZKeCELWchCFrKQFyQLJbyQhSxkIQtZyAuShRJeyEIWspCFLOQFyUIJL2QhC1nIQhbygmShhBeykIUsZCELeUGyUMILWchCFrKQhbwgWSjhhSxkIQtZyEJekCyU8EIWspCFLGQhL0gWSnghC1nIQhaykBckCyW8kIUsZCELWcgLkoUSXshCFrKQhSzkBclCCS9kIQtZyEIW8oJkoYQXspCFLGQhC3lBslDCC1nIQhaykIW8IFko4YUsZCELWchCXpAslPBCFrKQhSxkIS9IFkp4IQtZyEIWspAXJAslvJCFLGQhC1nIC5KFEl7IQhaykIUs5AXJQgkvZCELWchCFvKCZKGEF7KQhSxkIQt5QbJQwgtZyEIWspCFvCBZKOGFLGQhC1nIQl6QLJTwQhaykIUsZCEvSBZKeCELWchCFrKQFyQLJbyQhSxkIQtZyAuShRJeyEIWspCFLOQFyUIJL2QhC1nIQhbygmShhBeykIUsZCELeUHyjSphgfdN3m4hC1nIQhaykL/V8o0qYUP2Td5uIaWoqZ/FBb57kc8uZCELWchCLiILOPq/C8kBECLAKmRzwe8LZhX5QhaykIX8bZFf3/Ppa1bCwh38J8mv78T9OooxCYVCvsC3uLjSni+VEbCQX3+5GEKiVJdv7t1/HejNAhH6b0PmrcFnebeC5+WcnFsJCxE9w+UNxpx26OtnuOZ/T/K3SWFNv8fZsUnZ5LQFbdfC4p3/tyGzhpnlfMxfs3ne4yIGYHGt0434849t/vUvJs8yFiGCC33v2XkzL8pIKJTRV/n++T53+tycd21Nnz/nuf9J57C5wH1Plgt4wvoMRXzSQE8b5PPxsOrybJv2b6vU5+7r22TPtvFn36vWI05/p/kZf1/IV5PzGG1f3zqynI/zHkqnj7W4ljHpVx1WTapnvzg/xZw4Fmt8nvAtkzgECnxvnen5twhB/S7PwptReGrpGb53xlVVd+o8nV07SnUQIix/lrJ5qp6YPWvOex6YE+ZGzR1X/Y5n3++0MQhCf+OC37mYCGPMua4mxFkHtWBxwP56iJRNtB5y9jsTWDvtq1t7C3kRMv1+FQLxa0SQ/KbPlNn7CRE45fs8xjHveezv7H1y5u01ISKMGZ9wRe/E93na3y423vO/BynbaN3/Cvf8+iQKrhAn2xNzcp45OvuZTp4fY86e/+cYE14o4BcnFhKSsj3n9/X/WrEKGJ6FoPU808xO9iAW8bdKvspcTL/f/IQD56vO99f1vs5/PD1buGze/SafxXqxz+uYPNkLeza+BnCKc3QxBTzvHV5MAQPIqfEIvBPezfnXjJTNU9GG2evOv/Y4eTQzJ+eZI6PnG0DV/WZFqe65z8rn6AkrTl9Ep73Ms757Xnle1zldrCcZfyP3mi/1uVwgEAv5qvJ1raFn8bwVQqgSwj2vWE/Sfuf83ti88+LZ5qJ+/xM+8UzXvZh8lecplMl8T336d0KEJ3rnL1bqSvHFn4vfsCd8lkI6bUK+KlmniAt8M0rRepLnvdfXQVowc/89HV96/nJyHG/W2l14s89HzjePz+oJ2pjf13VYneR5n/GdCypgYOI7ledyVox83h4+bS7U3H8LPHxv+dQ7Sdng2Vm455WLPs/05+qG/WnfL+Lj6hstwHTWvYQIUKrD+TI6Zuf1ogS60L808Zvze+uT8rckT/irHgLThJ/nqQAuyv6bhoCf9dlEjfBwvvtbBupZctLBdNo9iu+cbHgYE0//5hxj+TpEnPDvXx/x1HK5oeukl9Nkdv7PJzYO+c3Nk+etnvGJ+sF+sXdZkIIqxX+WoXzR7IPqeoG/Vv7bkJGk26d+82zSYiWTYSWDRQdmjayTw09fVc4zThu/PsnI8rzVM5XarFKdT7Kyz1kgKvOfsUAiTj8Dq/dtlfXkaM7He7LXsO98t+b4GOecXTyj5QJKuJigsyyIkxfCV7OantcCu+gknW5VzT5TMaVfVQmZGtzzPG2lOcQPPE4er0DK8yiCb17pzvf+5qMEv06S5Ydl3P78kN+zPus3mzKWZfun/l0gELI4Ty72LrUeTs3XSXv9NOTsfOfMfKV72ner8bcbd9ynq7OjzkSehdLzuetg9nOT58TJ5+1Fz9K68jpfvneWHaFqnuE8hTytwIXwmXfW2ecs5u8kAtTZ6Im9vpU8P2aGqX6GJytEOHEWGrI5Sv/iaOwFTvfC2zxrMxTB/JOo49+E1f3NHb6zluDXAYmffc1KIRUFUs4/z+aMNLKKyPV1y0ljnv/76YPpm61NfpF1/GJTh06Xr1aMpZhzKdvPhRxlyGbW20ne81n3k7JxwmdOS5Wzv59cS/OLMswqlnnXVDPf7Y8+dReojt88752pSE7Lw7Z/m0ppLK9/cppO8QynQ6l5OR/nz/fOyWuEpvmIy+TPQpyljuZ9//xOVXVezEMpDWm2OzWeybVjzPiUs/DZ9+9zcbFmF4/BWthm6rfZzO8ucJcLf2M+HPJ15t6+OPizWmDGvY/TU48m5+brMFqeJYn/q43j5Pjj1/FeLjLW83ibXyVscbIyOhn+fT5zYty4te4jhJy75+YbR6cdnpN/03pMBcnWcn3PQAm0HrmD/eIQ4eRaml+U4SSlOTkH9bSjeczri45pchzW+AnK91DtO1O7/ilry9i1ebpyEbXrz4pV4LNzPPl+zq4RoPUQpVqcCDk7x26yKNCzIDkG31ub+I2nlmdztmvjP9vAn36286+558SOVsxTut+0zOZ8PRvT8m+znD/371nZmBf53tfB+PyqsfSvU74Z9v20nOedn5ZLCvaQyfLDi9/7jOtOyvxzYLn9Bkf9D6ae4bS18zzX1Um5uUz8/qvm1E5+v7jn814vZ89LYXRl2QECNXMennc8F5uP55l/fp4xFutsfg0Du2ZT/jbopPOwo59jitKvs5z14l/M4fv1ycmb+fRD9+s/VAqL8zwb+mIHxXmU+0We7/yKwvfWSbO9c3++usP5ny8KrjBOHrmfzp+qUpB7/rYWWHh+clpa3/M3JoWIkDKYEzP8Zs4SgYfyumfG4P/2y3kKCjHxmaoY0WnfeV5FiE4f39eWonS2a34aVv911UN+FvizkLNexrO9LE8tP9P3vj4R7v+f/A5O93qe9+Exu/wM2bkVz8Us78nYp5RNAn9z6jMXeb7iWmevZxtrOv8h3wxvujuc//kqBQwnp6rMxie1HpUK+OIlX7+e8EsFb361lJ5JmL4+//V19yxdxc4WY8YnMHUvtoesZ6vO4HnM/t6QPYMCvth8z+6fr0Psu5llgtf/Pvn+zuawzA8vPJvMFnh5lit8rTIbr7row1cpP6cr/69GMKlkNvdt/n3P6hDFGfDfxYyRM3PkzkVKsq/7pMP9JHKNlM3nQHqa97xfn0dwFmlH6+GZaSXnE/sMti7w9BierY75ML73lUZ0sswri/h838FJ8cGLyFcjAp59BtRZstNyscpMX6dD4cRoqtzprxtavdj1q/0jznQ4TjpDZ+d71lC08k2w+Oe/00lG+Dxn76u9lwsqYeFueToBxhYTt5v7q1dVqajpp7N4z5KaMi8JHvMsGI2QUwSQuc97Voeo4m4nKS898SmwiuOkdK/zP3vxXOdfyHVIcn4qxPA5xHuebRMJvAsaAO65zwEDFdcv/nU+du90HriVLJ+Fc6e5CEp1Zyz655dG8lXE5T6ewZ2YPWjnwNsi4Pko9rNz/20uanTiZ046eyYbMUyOtTIAzvLEC/JpIScr5Cr96CJK2+7j88XxZ2Pe85SiwDtRWZ61x05TskKE6DPWzolnqJ7+njU6puXZDbOLzLmkeKf1+dB6jBDKzcGks+epzile+jkL7VwkJlwVGS8C3ifh4c8rxnJ2KbX5JermxQnqnzt7fAIPhHeKETF5jbPL1p1yr3ORX84XS1KqS54PKN7RReKKhQFQPcfzfI9/G4lW/22JfdfPE2qblmeLZ9bXt5RtjMkwJkbK1rlj0Z63Ogde/XVZV3XC2vOMR54kJ93jq9z7WcoSC0cOO0/3tLMLAp19v6lPTJzJz0oE/Gqk4+ceE66KjJ+eOP38NsZJEHP1u/mbeF6coD/197PunJ2qGKcrGdm5eTbv5XxowfkqG1kFXL2jiY4hczw9a/FZqL/eds2NbOKTZ8tpqQXfjDxr6bjnJ8+2Bp5HjrOZ8c5Ous90+cXzvJ/iMLqoiIlqXhXaYi5EBpsf33yeCvj5IQ/Fnqqk2o/TBR8m5QJpLaekfYkTFaY84d6nr4HZHOQ5n5k4D4trSc6bliplWAsTnP0uzjpTpGyi1HTlsWJs9esrgrmtCotxzFfAJ4WaGuG1U/8+d6zn/uSvlXx9UF5xiJ1PcT4v5XMyoWr6ZYtTnn3emItNcra3fJ4D74RqNuW1v35lPAlbnWAUnAgNzv98HYqrz3cUXJnz6dktdTJcVcl5UpDOVtRnexzTuabC/d/Z8qy9oC/C1fgq+/b8351f9GK22tRkPmr9HufphWzm1nI/veDD+T3U+eslP+VvALp272kjYZ7XfFb4sVLe9UIYQjhjQMw5r8p5nRrZRLWzcxj/cwt7qPLaWg9PMNym17F+Bm6IQMr5oatR/MCORNlSm+e62vNNUTotDeBvo1w0J/aiUM7znoPzXO+rpkB8FfjlrNSP55//OR9uv8g8XWzNChEghFceZjbMMTjxezY8cJ6a3hN3OXMczy4vYk3W5Rkh7dp7FiJAyeZUvPQia216jc//7MV7CQukbGH0+AQI9nxzdXJoS5UGk5BRDUl4/mlPJ4exzvu+BVI25hgc563dMD8UeXrYbz4kbscRc54waj23el6oc34++MnyjXRRmrTO6zFS/28BNFiXeVZJkbbhPlHzcma9jpNibWeRN766VGOZf73JeT6rIth5Oss867inv3fWz19FCrj9pHScs6zQ4nv1MZ0jTGESt6GLnzOkbJ3opV5cAVti4/PpjztPTp6b80Pi9cyAi77TaUj7fKmFxXsuwiazhCVTG7/C81ZOuVoNCTgFNjzZ8SiIlMHEnCnVQYizINjpZ52TXjRXyVhotEjhs8pBuKYVhedZjed8GR5W5mU/zCpgew9Lup0v01X45s+fPid3xiCEz0w/YnPRkEhRdleXkLktZzqd8mUVqiFHiAApm3hqlul/EkG2Pn/2nXxtcHQ9B8+ReKaLcBfFFkzyFRhtk5j9xWCqk5RMzUCYWHBVrHWiHdozNMSehYbPe6id/ozzS8ZVn5+d54IdPXvg2pZq5x3L84f1n39957o3c57fnyWnf15MsX8tvDi44Ho5XbL88Ln2arVwet3YDJneJ763fsI6myeG4JRuSKcfQPMMs/Mr8tmi/9VhWo0/L6FIm3Fgsx0qY7XeoQxO6lRlmbtyQglYpWA/b0wyMZ48751odFkFqeakR83P3y7v5aDz+R3VDFrH5blVH8/0PAX++px7KDxvdU72Q2FkVZ/3nVGT5UcTV7BrS+B5qzPKdXIuTiLZ1j7hlF8xNmNyDGaCU6C8ee1aizNr+tpFjNwZJs4osND3ZMpX1VXJlvs0OiHLh1PvqzoX7Tir7xuy8j5ajy5E0j03HC1FBEKWFz8Zrihe3DdRMuxZGW9fz70vVuLv7OtVMgmfncyCnQ/HnD0PhRHhT7AJZ8vefXU5u5rNs8rzeN8nbeSTob6vWu7wxYmYet9f/XpWzDn2gSDwNyZicUJEeKpdqyz26xDOelaZXVOzmQnzxe6fmFnEq250Fqk2cyD2qfVq31VM5Y/l5e8xJxXOOemcAYHCxmulu279zDprnwh8b22ikYKFhEe1cRUZOlUo6aSwQfV75ox38r6WqV/dp3rG6lkrhv70+5tftlOI4Fxn3TOwo+c9Qp0NWAzu6+R8FRDWyRMrZeuU707LsxCG5nQoOWdu6nyZv6itTELEJ7NgT2eSV1JPPC8+Y049AC7uwc6HGc9DnDr1qiKYIjqdbWEXnyuK3Z8ss2v2ZNKS9RaUan8N3j2cviafF1Jx0h59lutWHu3ZhqhxCri6jzFj0uyA6j2e3nhhEnpenbiWEMGpea3zCFPzrz37e1vNbN781ElbYuI7s/vNnpHTMHC97sB0zYDCGzdz4NjQ35q4rygV8axMK4rJJgX19xHPfLYgqk2zie18ujOEzGVZTK4Bz1um8vin56q673QnIwu7V4qxytCxT1NwNKalUNaetzIX6Zj09A1Gj/EmegzLCdQDqKEr0+uy6qtcvG9bvOd8OvDcmtJi4ar2czb17/ohOI9td3E5+cA8DcKyL9SSZU767rnufs7P1a98WhGT58kMnlfI4LSDYfrf9XjoyfD95Ds+i7A0HcM8D8x4cU/Hhjkulm5m15HdaKcXWJnTKecEtEegMCa10LGLI51UFeg0ma8s1MSBOK00RO3weHYxc5RlPYxxUgU1dQ6ux8nPLGW79n17n9C/5H6uKxhXNOGE2LgpvRTtDseakWpS9CkG8TxFVolFf6Rsz7wbQ+6qmRXzU++XWxzW7uB3jsmkwTz5vkzN0zQmce+8YBunE2u1eFf2v5PrNMn2qXu+k9kIp4W66s5MPrXWZ50CJZsIFGk2CTPPIx/Z91ZdwyrXeo0Jav+u3+vkczIKLs/sswI6rvaEqjVwyMmzHsaMa0rXzkWnccula1Vzk+WHNZ2TW49+zrNNFnuZnOPifWfZ+UNKvwYNHGZhgfN/5xyfLOGYr3KgFferwxTfVGep0zuYnF1EZD60dFGo8nyFIs4/JxZ2G53rsyd9H5hiRdblLFZ0BcdL2cTohEnGa8HyvAh71n3zmRjTJ439ectZYZGzQyCnwdEWxbCpMsXanF2jxZqeXU/zrj0P6jx/8ZziEC4yH+atC+X2w3jq99PXmTaM5RQTuJ5rPZtpEfibKBmUaS4nX1+gVAedz6tkZ59nPjPZfcLNTbEOzz9X1fu33z0uRlMbhx3n/LDT6aEd31u3yqsOl0+9W9sN7BilWrU9dB40rD4vI3e/NbK8X4s5m/K57Pu2e/ssKL3wxu0ZMY00vMAuSl9PrOx5Hz7PEhd7UW0bnXdUi8vPKv+zFMu0XGQ+v/7uLxdfM7OxmZNjZee9ThVnqtJg5h2wdTkplPBN8BWKsV+04tD5rh34a2XstqrGVs8zPuuAqrySOX+lMrALOQtxmVXYk4VsTnpP9j62WEbgFIiNX/tedwoenz+GwtCcVKz1FJhZA2VaGUrZdBXDKuOtuq4/GUd1kGphAEzGaQWhv0Wc7rgrT+//+hzI0qiZNCZqn6rFT2e4IRM/zztr6s87rwra6dyd4vrFWrL/LWqyr7kwxXSsdnavCxG6Z7N/K428Yn5LZ+U0x26aCzP9mcnqZxYB0TVjctIo/wZSlKYPowpOEfK0rh/Peo+Ldqyw4zkN1i4mb/Zesz9btuK8g2M6zlH//ledg+LaFi6qH0Bi5uCtL5bzKODZ139SvGxebPQiaRCnx2ILKOds4sakTFcRexYFzFSMx34n8FZPUMAKO28WRqtX+SnmzvIRTrv38zTgcrsuhZpbHMGKmvrvSTIb60rSbWfpF235JuOW895Z8a4tGjFdC3i2QUoFSVbzUo+lCjw3t4LQn26UUb+2nHPt4l25vwuvVMAAxsQk6d7UOOxdZx/M7v8CJvbUMp5aQooAW/Jkus65KRVw0ee3YObaw9ueD4YMpVq1A9w+t5JNhPBRrpa973VdXXt77SQ7tGk8wp4RYoJlXaQthUzELOc6U8UzVdyQ+n6ddVLqipAyZOB7axg9rs1BoQ/mvRf3CeFPZdoUitKOJddDJt9xHcpm4veVcVH0LUjt/YU3MQfVNerneC0UUysEIhy8XTxntccK46HOTs9rYYnzZ/Vc0BOethTPOugu6pmdayScDU9f9L7n9fLqVmCdTWito/l1Uuv3v6gXPa/26jyv7Lxw/Wkw2lls6PNCPhf1ZC4i0896njHNXuN5sYLtppQlDFVApRYyO6pZ5tPPcPExV/Ise6juLVcexWmQ5eTd5/d4Pl/f1unxzgufTHoXxd5qhJdnoNmLoyWnnQXFveZB7MwZ+7zPzPvcLEIVBZddu8n5npxS3Rq8PDlOKZso2XTM8ep+s4UjKlZ0EWabvwbrY6x/tx5Kq8POdfSjgu+lbEwooLNDUdMIynS44fTzcbpgi71v4ekWZ2TdMSnOtGK+BL6/SpLuABLPW7Ix4zk50QVioFQXYzRa909AYSbHO7knxFT8eL5c0BOuW4rTjL/ip/nFO05f0OchLU1ujNPakc1as+cpUHHaPaevUSyewhqzC6Cw4OrMzcnnnlcI47SxVdes/27Sc6+sOhtvm2d9neaRV98vCCnzxmS9u7OWS3GInny/+cSoc1qMwmdyTov1WP/+7L0n8i3PXAtT351DTKp7CUV8CXBQonCkoHnEp/KTc+9VyGyZy69qvNbX6enXtF7v5DPP7/EszlDAk2u/TniZVBzFuOrv1B7oo/ih+1SNiEN+wjpXk+VF3Xcmi3ZMP/NszLn6/bSyFrVuSFBHQ+oymT9aEbIm+z0LSiXh5jrPjzEO1Sifx1stuQ1VT+oa1DlDpKrVjHewdrUG6/NToDnFWOoKeHJedT5k0ussxlCHYJPSGz95L08WSJmf4VF1MJrUI/aaQgYUeeG2LGS9NatFSS3ZqkIGqzKtNuc4SXfwvBU81Zkgxk3eKy/jxHl+XO7xWYU6e55PduE6n3wFOLqCL+pyupV69gs6+TtTG+hclVOK71y01GT9+3XLKp+CVadhyuK3BV39JIVU//m8FWCqa1XW2PQC6M/8rlLUdYV1EpRejGe2otBkqsD0M9RlGlp0G6g82GffhVWuZyti+9zFfNWNQOn+Nb+ymCFDyMBCfuS1zTTvvciJn+1n570vQdGIoA5zCeGfwsyfvFcBXU0X/K++X2+vOL3X5h96xQE229B+dn7nKVHLyo2nfitqDOb6NU+TyXU9H3mYnOv6Hqofwja0Vd1X6/5MCqKnOmT5cTWXDlLMsiPOXlu1MNqUAVKffz3BrtdzQyxaj2rvs35+VOO3BnOTKpe2+n1hdHveElrbOtNVhbZpA7EobiHKn+tpN1aUM6x8MkeksudYNa7AXys/G/gbtVQdYQ2DuQ6PBKMJ/WV7N5M6aHmScVxcd2IGJtKMZufG3noWvraFSSxkn2VHNdZzYdSYMwzD3H133zKhJ2DyInRpz6LJDIQiR3n62erhTlX7X3Wv88gzErNOgm/PJsZU+W42Qfw0Zu/kNaaZx2cp1ovA3xeBiefDSeVfJ5Luz1Pw4jzQ+bx5LWTe50+G0ybJAxWEdV5ocv69zlNT+6S1cV44fRLWlzKcO96imME8KPOkMVUwV3GY+XNZuyXEN/FOZ8dSXK9I7q/mfB4D92yZB+FXBJ9Z5fZVmeWz12sz22HrLJld+ycXpLCfFfK04gbT+8QZb0ZTD9dMQpNnjO+EsIQdp3Rnnj5hLqszw1adGiNlZN93OYb6+TaPRDh95py+b+2YZMn4t9Xv5FSRidnnPO2MKBTsZBc4e77NMtTte1Kq7SpnTe7bZ22lWTHelTuHpuo1nxLCKtjSk/u4LifN8/z1UYaSUNaQM5rZIlXznlHheUtk2QH18/BrJGadNMlne3U2kF1YdvnE4Wdl+t/zvFlNkQ9WfvLEWruVJ3YycUjXPnuS12rzI6uyj0Ue46Q1bEzhadmxT0JvdWt/3oYrChTUYfRiEYna9+rQ3aQHMen5zj7HZLm2AhI6y4I8Waq2adNjmJZpEpWZ+u9ZS7H+93yqGXh1Xfv73ClgcQpEb6/jeas15GISQp2GzqV0+cYTGz2f7UzjDFa7IUXZUs2rlcarpE70OIm8Njs3Rp+mFC+yrU/3WqxM1/s9DdmpxjB7IEqMyWdq6xa8h/lrcPZsEO6wFiJgupvOXKJYSfKaHKenurWCGY7c5A58W4505MY078Cuzrri4C3et6lDtuW5VRDoAjemwnidPHNscYkIz1ulKrlJOaaie49wkPI0QjVZHEQR+ltTMHQ1UxauPql96XTYoDrPLGFRTn1eTCEWwp2X83LKizPLjifwlss5qSMJ9Wc/SexYcoSI5nYumpznyrudvyaEu15VdETIYOIcMGUYsliLBXSuncF9UpvKk+UCu/UkvN8+3Oxkn8TInIYr69dh6vdmalHVr5E766mAaOs5fLNjnKwAcxo8NS9u5OIEul4PW55goZ1koJgSQrPPVIeGKwb0bDL7dEL79H+Lz500/nm/P8uTPklm561er3f+Nesx1LonU2yyYjPOjxVPJM+XPxdktYJpW8W3pgusaz1wB5ZgXpwpy/bdgReUdWntO50dk2XVzl87kwUExu53bt0aS9qr6u7OU3QnVSyb3zbztOIpVVjiZAN0XgOGk4zUSYMHQJY1g6evUcmsp1A8h9ZD6uEkM+c8kLI9sU/qsXxDVhoh0zWA542nSM0p9p9lKhvSbM9CnGXc0Ey0qJvOCPAm6mVP7kmtR9j0p0bte1UIyBoMXvnc9XvWr5O7vNUs23fEoElFZj1t4YyWgo8wOTfV/XPi9Cm5LtJ2Zp2k2fBasS+raxRjrBydgohqjYp6zeS6sW2RmjqRSrg+vx37feeFJ9nh1Jxgq3IV38Ur10OhDwoYvqiLbkzsPOLpd19xd+oVsYQM8LwlxIxhUnd27DNMFvWYjsubib04r5jKWXIBJVzcfL5CnLQY6xBAfsLmrsdL6/HK4vv2M5P9T2cPwGnv5aQxTlook7DWLMliXspRZfmUSvlEC22ekVHFVQ118paFg8WMVXbydeZ/pq5oJq27wN+s3W8aipn20E+SkyCcYtPNJ+rNzlPNazVFbmU9zDAb97LfqivbvPy3JZM1qIhA0+kQpvSWLIO5iCGZcq7sgZfU+o8WPVHt3Ex60/PWSKH866Q5Rbf1MlK2yo4/FYpSRw6sVX0ySnPShj5pzqYPFcBkrmxg7S8zse7iwJplCs96l3npMRSfmYjhzk35yyf+W2e5zms0r3V/8r5i2tjKnEI7u4KXlCFFow1QtfdcwIqVg1EUgBCuVn55eyoFeuJeMdlUM4TCwJSlJ2sc+mIV+ux1pvNMs+xoJiZcwe15LQ2s+HthoBbP3ijnYJ4hPnuGmZkxWEJa5JAgKBVzUSN6xrGa9bKFe3+yTHUzNSeqjvTZ50vT/XIercExwJBjiXm24IaUDUzJYZlMF6zWZDW2evMJrWPyvIK9C9TB99aokwqLRkTVGQOgnCFROU5Fd6nZ7kxnyzPA0RWDzQ1/zk31xKWnYQ37wCGTOXzFgxcPBpMKVUz9d/ra1WFU5fJW15hHNqkOzXnx1uKQdi8Y5WyeeW3KTobnZg/XaS80Z5IEUP/MPKiyPt/1f9cPt0mjJJuorFPFb6rnrPUpPVEZGE6CSy0hwy8/N99YKlqs2UPJLuri/aryPRTty4prFfGhMs3ApcqJUlE6MoxQFHnc9VxKgTfBapzwnIQsN5c9ZJpzPlfBbtXGq7wKKduOgWtqz2HlaPBBbfyFoWrHOVmntr6OmQqt2PsV8OSsVKkkJ61lQzZTk3e+QXXe301eHyYh+mni4GS2ALXfCXfIjagU1rx9XiiG+rlQzJmmzlCfLk8IdQb7vFjevPCNQMlowstDSHdoi4lrVB16/Ck4Fqy3V++cZJ8/yw4cdG1/V4y5Uhr1OasbRrMomH22OjRcT0Fruo4+aU2RF3NTM6Cm1v50eC7Pey6MmE18p9pXZ6UmibKYiSVE1dnPstwzVVZAPZRR73hl92OxN7UeufQp4TgSMaUOEGHp7Ng6ztOSW5hZFOtwjJJRrbxmMXa7H+XE3sptVa3aetZlqlbqnuX8bXwvoIRVCeNA/dCYXcCTi6HOGCsspHHNba9DsfUhFYsyn/iumNms9p7FQp8XJ5pkqtW97+LAqF+vFlQv49XW8i4S8me9x8nnn7DIJvKrbXxCqYLZaZ/FpoBMbjQLIRbKtziECkPFKjqrFM6Gk4veo/UxTtf+rludJ8tsDMsu4HzKyJmef1G7vj04jSni+lWT70JhWiZzl0mvvjqMpGzZMU+lDBTPYQ+L4r0VKEg9JaMIYaTuELOHTlB6izUPSPhI9w61tnBqp3m7vKMQkjzruU2Xl3M9r3CGhdVChIxq/XCnPWtV8xCKv2t3aJ/EuTDuoKyTa+rXnhxFJc+aHDFv3df3+eT9hIzcQV+10RQyIAouYw/QRi21xJS/m5RZxQc4+LcyVqWss8nd/WfGJUo4XcrWlPdi753rofO+nDFu9IyBWzTwAJynPWR6/iebGdRDS1XIyZi8bBVYjMHUYN2T4qqW9VxPySnG5WOVlEUn7VrMy9mYzkYoxu6pZQrEyb6vIi3RfrZ6PukKiBjKSl5AYVAIETg2vVNiU1B4sU+FK3JS/M0iFYUuqBl4ZkyVAVEVSyn2BhiMTmrjlShV9VlOXax+3n6oh3oMutago5ozC3Ufurmtt860Z5rnraB17M4se0arr0cJa0f3P03m5WFWKS/FCyo+a6vgFF7zpIcxfeBMFgyox03t/QoIxaZYTCdUT0J09U1rpa6kde07c+A6IcuJLryoyU0yFdszRQ5bNR82Kd8uoAr2LMZawEQpk+k00wtIllZgNT/TKR+To5/997zqRdPfndysldTntDo8i2esGymTB11xsATYA6hKFypgLZuWMaZgmNbnRbvD0TYXcIYXVSqRZfKOqYy2YpMXBp+sfa8g+Pj4XpeisH+Rj2yVZmBTX4TveuhKxslBOWatLXlD1VNFsL1QhQipe/WAPSxKw6yG3ghVG29xYEyGS06C9WfzipnzuXnvetJrrnsMVUy22j9F1ap54qkO9VSWyVzqPqFv+81aUlaE1sNa7qycImXZNVA3wuphiaJhhr32JMozt57wjFFuag0einzXChK38eZi7VkIdF5taox2HlB9D8/Gtqu/y/K7FrkojOqcNNsrjf4qxGbcM056scX7nkwnq4yIVnQdqHr9TvdJnzReq/HmeZ8iJGFZ2HXSV4GE2fFWRqSg3uSguJctp5lTELyssTS1/oxmkttQnc31Slp1x8ZQN1hqzhRZjVWduxBT6u5dQfGTHbfqyt4a2cP4QfmMdhyWlT75fHUjSpThDeOY1FI25yBPJ8tXrB1ds7Bm0g+KFIBpJVIE9RVFHdaq0kulTOv3mKT51yvrFMW16wqU8trTxdIne1HWFXte+17dI68MgSIdoowvTpF3qmvD5H3rHVTU1Dh07TOmPGAqqeLFxsHWk4fBtHU36c2XB9bM92Zl3jxOvrPzkg3qYyiUWlG1Z9oL07Qbtxkne2iTOUvYMGlwQb0yFS5tpH6wBP6mKz1YkLeKpuuWkFI1WpD43orbIIWV7g55GSBF4DqpWMs+8JZdh5r6ulZuU0uMyey4TDb1GTtmW+fXhRycAVrVDbZxJHvwTWcInF3Np3o+mP9+5q0NO+eet1KLi9Y/YVM8JhtM1MIzp1Y7s3uz6ss6mRZSpKHUUzxObp5ix257yU5WKrLvZpqtPf1dqCNaZU3iqesUeaZCeDUv76zj0O3hibS2Ym9rzqqSVlXGmkS+GuE14nTfxR/bNWi0mo9JJ8XU3lM9/KUm9k3xjNM9eGdmTURuHqbTner3nj1Dq3WVT83l9Ax4LrXpcN6kOqPEI8+HCOFZIyAfUqQJ1dPO7LoYOP0yyT43ruFKZbjUEdm83Jc2Hc5C+dNNNormEFU7RLsXER6eapPlvYn7Fk8oRIiSEQZdNrc4T8Wsr6CEpxeGmfo9VBTzMfMU6KT1WP97cajUySvTn68X7J62zueXoqt3xiiVeLkxT9uA0xDfZNx4utj3vN9ZKZoweEzAM7UXVYyxypus4l3zn606XCfnbnr80/HmeUbRecoBzpunmgc4YSwV97FjlDJEigCDRoqANDtgtjsNtWtNcgNK1qfwau/d0AxvkuuYOH1KfS0VCsFuMmv0FBvXxo4DV3KybrBV77d4nlkFMl0a0KdeeCHwN0jTfZTXdTCyO3y1LTZiTOqgM10e/kUh+MrQk6WCn1yz0zM/+94EHkJGE/mWvrfuOsacr73aeWTegTw7nvp6nC5ZWT8HznMMqakDc1ZOes6T9+S8n4vni2pnFzVjDib3T17+1/NWyfMh9SIck/NUIUi2OcYOYAj9S8TpE4q9Mq/ZwLxc/tm8aOdJu/PapjWdXl7UU8soGbn9Uzx7iDHxxD2nOSFSRqc09KifS1bRTSvTSYVXGGT2nLAGtyzPZtvIYY9572miMxeeK025XY6oGd7AkJPmQ/Ks5ypveRUJj6rBA4BUTfK8VxqBvrfuIG1rZFklHpVOQ7Evq+YVVb7zc84TPgn+mi2kDdUCLhZjEQctoFuroAtot7AiHQwoHFmHIj5QTLysDbk49OrwTXH/WTZ10f918nOzm6oiWtQXnIUDJ4t5u7iKqMeI7dhsqoua/Jx7ltLbLFIVSthLWviyMHaEpN731EKnrXKOZi3+4rnmeazWMLAQY50AR/nd+Qp4HvRon3EaggdTI0RNp164Q0UnaJM4K996rlVMSTlF5HgDJWGtei6DIQovUaRHFGEMT0WkeX8KDg3dBiiUXj3GaOdI6xEIryx6UKxF31sr4842DcNC4oUC9tQSFbQm7RoymXt/oe23KiRZdlSuGXtYWSUrZQNP2YpJZe65yRDCHgaBt4pSFammPvaChVmuGTmbfmTDGJOKKs0OmNcbtRJxQm/j6u8TP5XGa5FSsonnrcwaBBPVluqwrnLPNb3GKlZ6IdVay0vuwEljS7O9KcPcwf6iCGvA7EEuUarr4Pjp8EtxBtnQkO1pWz2T59n3URDtsuygZpjVeSfWC7XVqbQb62H5mSQtvF4zNU/FfmvVvLvquaoc9yrsUazTekpYmU7k0o/qZLAsP3QGQHEGKhfzrYcJlON+FIxnWSMrifL6k4ZDDdI3rr56zQgRiDKkFvo2/auI4xZ5uoXzlGZ7tSpp9RAc+KrtxmLXfpJu43vrbkwhw/gBcbpv3w2WwW7Lcdq1VqQxGTKU13V/E6UDlGYH9gm9FavTypAo5fgoc7YLR+oCbWC/tlaGE9DV1AZ2B5qnOiVNvDp0cVZG3QMsYNs6nDLpFU/KPIi2UrKTxb5Puza1zxWLbRoanobLqV1renxFTMguaJs6oR1sWbQsqwgUFfRaQN7V5q8OCFnCo/azWRl7m2SFzpdpS3oSKr+Il1JdESSBv0Y7usLB8TvOo49Zar3C8eieG2NOVR3HtszL9Ritk9IiLkoR1uH9eb+rexhRsIUQ0kF71Rqq+ogW8FPdIKu/9wppsEQLCUKiRECc7uB7K2R53ylmuy8EcgJWruDwAmqdJKZUa0dYrzk7LOFyT3WQMiDNDt1BqZEywpMR4+SpJTEJr2SZVutmur3led7T9OemUa1pD7KAAichyyI+Orf/L96EV1bBydNV2ya/1wivMY6fzDEO6wgYte/DpPF93upk0/ef5LREwVYtdj1/rMW5UFT8mtxTFToGVJ9x8xD664yTx0yfWcX1ZquiVdcrkBa7hqxXVzRtKM+UuQhXzTmZQBNn0czp+5bjm7PmKo97dh1VUkdGZr17IQJ8b9l5sgVx07GnhVc2RlEyQptkymMuQlPb5RxOozLFWV2twyosWGRW1MmaVupIRP1MrdC50pMWsty3tmPW11Yxa55Yy6yKDRf5wTXLR4Q1RaLLWqbFRElVNGKvII5JS7qWslP796QUh55gnuU7uTmKGHL9s5Oft5LX/mLZtmbmd3birWVsCWrVGItprr9Y7aBSz7FHwzJWaK2ywpotFollIFsyxri8sxDKekx6PEHgmFws089XzJuYMH6KQ6aK00/P5zypey72gBQIknSPYWwhIctY1RwN3ncbzirpwOs6ooQmy4cl+xisoVIYaPWWjTamNDmP9jPWY0myHmnWnygwoVyx9gpJsEq523wVKZsuN9A+q2XqNt0c2mvkeZ843bHKG410h6PWQ/K8Z8k5TtHYzjL2PQX+BhVztJK6l5OkO9a7Ez4CQZYfk2Y9+571GKMTsuzAHdSWfT2Z3xi68MV00fvyE1P/Ld7ZvANSu+dvl57StMg5xriSTUpCT60qVBRcqXkNk4TLqrGCsYzxKahzFD+kTtpphNfcMyqEsOzdVnSLqmJbkTJWeM0VWlKxfpkzT4XhUJ+fKt5n573+2Tpxs0orKgqI2E/VjfyisYp97wVr1qKEOXHpARekK9u+0JDbFokT81Lz0skttCp8knTbrbkx7cZtAm+ZguTYCK9Sf492LA65cpDzpKFQIFJMzZOcWMvzqmxpHZfIzskNdrRrAbmMlI2S0Dhd36BItyvqxTfDLbL80O2vlCw/dqGknCJfvAj52MwS6yzVUdt6KKRgXFsEo5YRo8cI4dNp3nXPZVGSwN/A6KT2XArfW7Hon3AOkMtdryqtnU+e0ROuvbS5TeaZ+rmK7dZjfaVXWYuDVqzhgnyS16yN6VQjqHuas82n694SzKQ5TI19sm1gETOuNyW3FqAQXrkA6jHGYowVicul3NTIZ/U0kup5rSdXWFKhv06cbFPFPt34nAU42ed2migy8dZqz1IZApOxW5gf0z9f3Gzy70Usa9obmrRIpWwS+RuM072a1Slr/61ibNX8z1rWlphy7H5ylqlDGSbHUf2tzsgs1l0zvMYoeYqSkasuVKWNaJPU2Oz2O1IGCCS5LlLtivrRFoZUqlnGngrDqF5fujgsPNVGCOkQgDFFzKyKf1GOv/IyKi/JU22SdK+Et5N0e2od1LgLM8jUSe9STXl/1GKj9e9O/ncyXl40Y59kiBYe8+S+m5WCWFPMKeQ1ZKdaz5OIxjwvdd5anuZzFGlvdY+sfq16zNeGIiaRGHstKZtlS8viGtV5VHmGdWJa6F8iyfadNzw737NEsnqzB+Xmpc1kreXJMJUQlrlfT7GZJGlViEHob5Ww+HwEwi/DASfPWzG++plsUZ7AX5sowlEnGRZ7rvB8KydCu/U+7aEaF6vdrYwFYet9F7W1i/sD5Zk6TWwt9hJQ8i/sfmqjdYKUAUoGjOMnICSe6jrOQTxFQizmHEoCGDBdB3ueXEAJW9zbFqk+or4wzwNr1eGBkimqx25D5kz2prQvrThIZx+2UuwFhGBMUjtgp1OYppXUpAKrPgeTm2Xy3taTsqlBdj40Vf5g1YNy2mucLQZeEa9s3FdXsS43H4VCtgvTHvyWzFQczpOHyyQ7G7eYPaaJXdPNB05mZp8OR01uvtk59tQyQnhI4bnm47LM4bTdaCwMj5Ao2awlu7vYqKmxWY1GeV3HUCwK60PFSp5NuRAioBleZTD+fGKMBfQd+kv0h5/XDKXC6ItRquOYmQUbsu9itLZ2r3YlE+1hUWyy6p0H/gYCSZLuOpLInoPRjwBqa8rtCtWm3bjG0eCTcnP7qo2SIWk+cMo+mVJgtQIr0rLHbSxr8gCdp0BPZjmfP/QwG+6YJgSexqif/dvk+qtDyZVirViv+dxrnDx+MUGamT/OipcyPxXM4KnlWhqPcWNqW8RiIqQTuT0+XW3M7puKDOiMb9cc/uSxNyiIRAW7N/DXXRzXPoMleVnkyVPLBN6SS7cpmrPYUEy9QULRBMQSrHrVHcv1oQj9DXI9dh2qKuSs+m9leM1C6LaWQcHgrmfLhP4Wcfqkdmao8u9KtdD5EKXa5A45MyZ1aXD2bMj1sDZuu07sHjuskePsO1BeF4x2hkgFSdvn13iq7c7VejZLlZdcyGz2CBPvLPA3SdN9pHLNVXSCPgcR8gJwtN0MVaUXK3Xi0WTN0SJmFlHkWhm3kK1yGEwoHDPRJswRGlxg35YoK+KeBcHCQbS41JaSxKTLMRW5eLMKxo0dB6FTsZWrfDS7eSw0XlUAK9iAFhbOqWoY26orBWQ2QSITHhM1aUVon93FP4tCHAZT8+KMeyarrPJ84Bh6dm7rSfW28bSFbZRq2ecyeorIURGeCuirDjsbirzn+kFQ5YhO/t7UDuCCuFI//AVZfoSSga0LazJX3cbF/3ViN4iMKmjJVFBdK7qKUm1Cf7nctIKqik63eZuyrZmpuslUpDWrmEfJDtZLbVNtHE2a7jMYPwThEQXrtKIbdBo38b0uYMjzAevdNwm8ZbK8hxCSwB0AlniTUOWjW8vd81boNl9BqQ5pdkiS7rpDZGxj/86iL4xNIXwLhQlJlh9z1P+gfFYpA1J3KGauCIeUkYW+6rnMjshl9JhmuIVSbaRqunzeyXVdf4d1JWM/S3XNmhSwfPn3GjxZlamtiHMl2UdEzBYrqROt6iS5iohjDQRn3E4ZspYYVJSwFYT+Ru379vyx0Kv9XUGyqqpQFdeczGEv4GULiRdKQtSua0oyXK6HFdKFPXRtkf9qb9vfWeRs1pt0RKcaqmjnwp4vnlqe6llsjQdjbG2BopiNIaspYIDcsayLudSMy5Q9gzGaKLhslVtZEIPyfMjzAQUcXCFP9jNx+tSSKVWrfEdVSK6qU21JeTmTMWzjKkt5NuRjKmWdZIeWPCUjB2E71rFQeO4csMZngYLlaJM45GjocvahWie6PF+KMJLdI7aYTpYfOWKqoNO8U3rbxqS1Xs02dCWlO0MLneHe13L7W+X4hfBdSKXSe2nWoxFexZNNlwVykhE6vSqeSaoFXRYlmEg1qUSVB4eFQPK8Xx7glbVYZ/QVlaHs8IpYma1I0qpt7qInZx2qdgquPKiqRTspdYi8OgAK5QrUlCnlGISQpeKuCrU7+Fy6A6gsXaersZrMwo2ugLsxsVUeqlmOALe5hbDpBUUKjS2HF1EUnSg+UzyvMbEzDNwslPBs8Z6KOZyuPiWnPMh6WcXiAKqnn0yLqf23iAnbmWuEV9160LUwhjVKpPBsTq5slJ6s760gXX4dwGD8kDzrMYof2HgueVn1xpiEw/775SiqNC4XayxLSxoKdvRkf94Qz1su2Zhxesgo2WGY7JCmtg2dEIqd3s8cNG1bxw3jBxiT4Xtr1RoRHr63gjE5WXbEMNmx3qjRroBHVL6PPB84r9vGjYQrg2hMjlItlLIHhECR57aH7GRRinod3ogqzqrdHGR0my8hRUC38RKN8LKzyGfzFKsyhaq2dlTt+nYtSxGUHId58eGpq7rqUTm2EEs9hmiNPSnbVY5nuR4nvdLqAJd2HTlFKty7L64pZRHjrbzfcbJN4dlaNm2j3JeyVGw2zld5OHb/2gPZFu1QZeERy76366Co1OQMZREh3flSpapUPIJiHgvmv2We22e1a8+eoVIUMfScLD+m23ip5oxIxz+I7fko6uO2UrCALZpl50rnQ7Tul0o9CiwUa71G6UIm9UJJuHdXOE42S8EaOnZuq3UC9hyStQ5khjyf322qUNZFaEIIn8BfdwpXYvQYKQJXdMWiNJkzdnyvSyt6iUZw2d5Vj9BOycfpUzcmm7li60gXWQ8FXBw449UWGSnqT/eGH7rnrXnxwp21Dj20hpXTTSYmDDYZJ/v43grK6+KprntmyuphnmqT5gPidIc879d4D6fLhSpmWTEzX1Nus092vLHEiFyPnYItiEDV9+3EFRCOqtXgtSJwNVxlhBA+eX5Mne5fPEJBgjKOvFRMui1IYD3nenpR8TxVh42q3FrZcUdGpcUHuJhEZWFpPaIobFAc1DaGNSo9+AJWr5RtbbELD2O0s7yaZa6ekk2KVBJLBHAHt7BGgTEFEYHaQVGRRaRsWWUvCk/cjsVanI3SeiukfsgWZRVtyGAesWIeGa7y+isijPVM07yPr9oYjEtR02idoGSTwLPJ+Z5jG2tHzDLG/t0qpVpTAATtxu1yrQgsTNeKrlJ6+SYn10OEO/SWWndZar1WrpMiFSjLe6RuA0lpwyJZto8hJww2nZIMCbwlGxNSLcdKDpyhYO+n9Yg027VeFMJuSiHdOtSl9yuERzO85uoRuzCH66pTGCMGCzV3mneoYFH7npVsusPYGpSt6Cqhv06hqK50f5c4O+Kg/wFpdsDx+AHG6NohVVVZwiE21uCqE6ZqRMOSjV+k69W91eqNVEawS5/DHsyRvwYmqxnl1sC0yEbhTeUOZo3K69XZzEIofGec2DKHVsl5bv+M4oduTFVYpjobFIURZtnKAlsAwi/HM8mJqBE3TZ2hXxi6qXM0iup4Nv1nnDx1I7eetxC2U1bob7g9XSg67aquRUjZJs37zruWZPmRI2haRdwbfUER65WyYUMwNQfBYGiE1yiISLnzrKv0IJzxFrl7epao6MKAnupYlKwIXTiYNyuNd+3mKiB3IbLQX50x5I3JyLJ9bFekbuU8GV0aeQUCJWXTKezcKVDLek/SPRtmyvsIEZWZDYVxvtS4CUCcHZRErizbd8ZFp1b+F0yJiAlXZz10+sJmF9TTMwVFURCLYHneamkYK6eMbVW+BkVdfCEkSdazZ5VOLCrisjgK5yHNdkmzPTrN2/j+6oRBdppcQAlXC9UyKFsUloTto1gF4CtvihLjLyDDOpPRehYr5SYpXmDgrzlvz1glrsfOC1VUsInvqP6qhOXspFkCjIW9gwllMl0Uo/hfVQEpLz1Z29dSuEVR1Ri2Xpzt/GKtenvQeKpjiTal1W9zRq1iHtvDxKRlXLCAMwWyjHHked9Z3QXoY2qKOK28JWeUFDBN/TUaPXYHYAHjVB6M1rHNXXXPXVRsKuDB4n6VTEOCU2kpZTzNenNWqYT0R/esYabHKBnieUsWbnZ1drO8T5L1WG294jzD4pC198z1mOXmbcJgk2a4xXL7dYSMGCd7KNVlufUaG90f4qsueZ7YrjRqmQJet8n2fY4Gn3A8ugfYSllWYdu5D11+Z573aYRXWWl/lyi4XJYztDFsDxuLG9AINiy0ldu1ZeFOqxiMi1lX618S+qtkTimvt18nCizJS8qI0N8iCtYwJkbrEUo2Hc/AYxA/RskmV5Z+F+kU12bnu7zU/RN8bw2Bx2B0DyVtTvk4fsL+6JPS6/dUhyw7IskOJ2DfevxWqa6r7VuHk6ffc06a7ZYdpuqdjmznoxZCeAT+RplWFXgdWuEWo+QpnrdMUbLRU8tEwTppPiT0V938rRF4y/he1xl/tgRs6G+V1ZN6ww8dxFjEaxVZdkhV7hGK2tF2TE2nAEIX7yvYyhlptleuv4r9TW1/SMpc11p8tipnqSnCajasYJWx761hyMiyw/J+cbrjlNQhBdFHqZbblxkCaaFVBEXRluK7hcfpqSbd5ksgvLJcaKF44nTfGX62lkDBtC6cHAth2/2vdYI2WdmuU7u9ZsgdfJ+T6zECwUb3B5bp7rgPeT4k8NcZJ7sYMybw1x06UaRYtm3cMx+W76c6P2OqQjOSLNsvOxQJERH6l0rD1WDoNm+ROgUXeMsUhNc0HxB6K7Qb1xwys4pBo106o0XRmu48zSxxLjsCtGM0j8sQkp3XZTxv2RlWnhurJdlqPSROnyKEQ2FcuAqj3ZzbDJhWdJnAW3bZDz6+arvrWnSt5W/ZeZ8ptDRfLsiOrhh5dvBVY4ASXizrZ0Ylu0zX4r0CgXQkF091LftUJxR5bQW8WS8TWTDeSgYqgqJ8ZJ3EA7qirVPlcdW97XrlpKq3Z0U2qN+/UNpKdZyydcquHGutNGP5feliL+OScFTlzlkr3fdWyLJDmxjuqihV7Ok6qcZ6y/Z+RW6bvb+FtgvLt4JVCmZf7shPBZFsHlmt+ncFW9dDCpPMcCg8jurfLj7iKk/ZA6NJ6C0xjB9SxF2KfGgLz/bLWKn1/CNyk6D1mG7zNuNknyQ7dIeLZZYr2XTPY3MgPdUmyw5Lb9/3ugReh/7oCzc21xrSlb8zRtOKrjKMnyJlgCcjYhezbYVbHI/u0Y6usxG+xsPBX5NkvdII6zTvkOYDAq/D8egevuryrdY/4b3Bv7aEK2+ptuEq9myRAy9kVBIQC3jRFivpuVxHC8tpnbDceoVB/IQr7d9gP/6UQLUYJnsoFdAffo6QEaG/bN+aDJHCoz9+iBQevtdmFD8sSV3aZDSCNYbxUxASXzUZxY9phJcZxQ+omOST1rqnlksCS7FnMJoovMQ42aYg3BTx1+KALtjbBSGu4a8wTPYYpzvl3Bd7vhlukGZDRi79p9O4xfHwU1fW8IhGeNWN0Rl7BTGvTM2qqpNZD1XSCLZQMiBOj5DS7ptx8rTM67YKc9nleHsEXpeVxm0eH/6l8y4vY0k6DcbJHll+WLLvi2pmdh1aolC19/LaODzW26+z3fupNXDdZ4vxDeOHdBq36A0/wvNWkMIjzXrufLOVmXI9JPI3MOS0gk1G6QFxduS8c0da1OOS1Nlt3uJ4dJ/Cg83zAVGwRZzu0oquMxg/pBFskdbg5CzvWYPEkZWkbOOrNrlJiPwVBuP79vx2RmRx/lokIHLneUq3+QqD+LEbW0pBIC1IXkp1Cbwuo9im11lPvGsNXLc306xP6FvY1hhdIhyN8CpJfowUHoHXYeiMU+PInAUUbPfOiCi47PatJc0G3iqhv8Tx6PNyzRbGeHF2FFkuvr9Kmu6XOsX3lt15FbjcfOukaT2yYR7hM0p23L72ysYvxhk9zdDO9zjZPleq0rmVsLX8qlJ6BYOugGoKSr2dzMIjcJaqkC42JitF6qjoRf3dSqFJF5vxKHtGuoRsC5N4Ey99kimrS6VcpHsUDL7KSMhKZWEhiUqZV8ZCnfpflIGTE5sPKMufFTBlng9dClEVly2IF8bFguvKumBF2jxWm39q6wUX5A9ZjdcpLMs0dsS22hxL6Q4rGdk0A+HVLPqqlF3FBNZl7NIUTSbKg2W6CAlMwv+imIDyGlZpKXx/lVZ4icPBB0gZsdX5PruDD8jyPpe6v8Fx8hitM5ajl9gbfogljawQp0dok5G5OfRUhK9ajNMDknTHPaM17P648//gL0f/b5KsRzPcYpweoIQlM2k9Yr3zJhpNf/wIX7XI8hHNcJOj4WcABF63VMJKBNxs/wEH+T0Oh5+jTUK38RJHw89oR1cJvS79+HH53hrBOlk+oj9+SOgvM46f0GneoT++b1ELGRF4Xdaar/Lw8M9KJb3efp3e+D7t8BLj7AhftRz0aGNK19q/zX76Of3xIyJ/haa/znH8kEZQNVXI8hG25KfHODkgzfust19nt/9umV5VjKkoGiCFh0ETeF3G8ROHEhyX62K+J1wYYFVBGN9bYbP9HQ7HXzBKdpAyKD2OwqAV0sZJm+EWK+EtDuLPibxlOuoSselzMP6M0F9iMH7CRut1+tlTRvGuRbmEZJzsunrdhyU6UrBbi1KQQvhEwSZJ1iPPBzbtJTtEyohmuOXOAk3gdRgnB2iTEqe7rLS/TX/8yHp9rsCKQaNEQCNcZxTvkub9CaZzUZs58DfdnD8tmweE/hLjZA/fazOOn9gwBtAOL3E4/IyCEKS8Lr5qcrfxJ3w0+A/kJkEJR1h0hrNSbbLsAN9bo9O4Rse7xNPBWzSCdbRJGSV7+KrFcHy/dCikDPFV13q5KqIVbHI8foRBk6Q7KNXBk00ybfdT6C/hyQZHw8/KkI82Cb7q4qkGy9FLHIw+w5Bzu/lHPM3eZ/f45yjVRQqLcgzH96mz84vUsUJBFRkZlm18SJFy1G3e4Xh0vzRGG8FlRslTQBMFm8TpYXmGK9WkEayxEtyilz1yhuYjAq/DYHRvIp0ocnM+ih/ge+t4KmIcP5kgylnDuF0qfWtIVvrJUx20SYj8DUJ/iUyPEEj644dYJGFYXhuwpS/dGZXrMZ3GTXrDT5AypNO4yTDeIQpW3P7+krQsn3mynLsMlqe6NsbiSpb5qk0UrHA0+GBiswoh8b1lWztXtYmCNcbpAUVMrmQ4GgGC0lOuF7e3cE+A9CIHn1prvOxo4+JHxmDzuUxSek7Fi1eqXSv2IEqDAUAYyjzOgiyUOwVs7yUoGoAr1XLXzkrPDFwrL2eQFJZVQS4qGLATlnMZ58tLy9pupoZVwK54edkazSlubWJ8tUyWHdprGW2j6rJVwW0O7o6zpyWD05NttLGGjF1oU5V3nJFiXG5rYSBYxSoqI6lMwanFzQojYlqJYxmN2qSsd77HXv99krzPavMVDkefIfFZDe/QSx8R50d0o+tsqLs8SH7OcuM2R+MvMEaT67HdUOkBAsl65032+u8ghUcUrvCT+H8nClYRQrIcvsST9IBMDx18dNl6eDqzh7Pw6ERXyE1WKvcsH9OKrjNODwj8Dlf0NTbFFZ52rhOZFlfMFn8V/Svi9AiDZq3xKv3sKVf877CTf0IuYiJ/DW1SEB6581JsPBeGyQ5H8Ze0ohtWCegxmYlLgy/wOvSGX7DkWiJ6IiQzMVk+4m7n7zOiR4MuneYlno7fKT0TTzaJghWEUPheC99r4cmQpeZtfNlACp9B+rRMeQIYxtusNO8QySUe5kNCb4lMNklclxm7Bos0G1um0xK6NHXzPNdjfNHA91qE/hJxejQRSikPZ+HRH99nObhJN7hGrHvsp58TKPs9sF78OD9A6xTfs4ZW6C1ZaFpINrtvUsTUMx1zOPiAIiUM4+LsSKJgCyVD2y/bZIySPTrRNRreMqPskNejf8R93iVovsHD4x9bhrEMWGne5XD4GYG3RBSsoIRP1LzL/vAjpNdFydAqHDc3uR6jHcK13LzFODtE6wzfa9MJryKFT8NfQcmQNfkS4+AIISSxcxCSrMfHwz8lClZIsmOUDMmN7aaVpHs0gjXGSAKvw7p3F4Nms/kGQkjWzDXeS/+NRRbihwij8bxlbnR+nxWzyQPzPpkeMkz2CP0lmv4GT4/2LTojAjqNG2T5CCVDhxIEYDy3DpcRQtIM1hFIEtcl70Hyc0LVLTNZWtEljgafuPi8RjsaQehvcan1fbTJ2Bt/jDYpSVZLdUIQ+usM4qfl+lKyy+vRP+KL8OeM3f7MtUVDPa9LnO7T8r/NElsc84Sud4XMHyGEpN28RZ4nJNkR3dYrXPZe55P+nwKKRrBGb/iJ1S16TLf1MqNkDyk82uElBsk2q42X6akGg/FDjNG0G9cZJwdE3hJpPmAYf8lK+zv0xzZnW4oAzQhjMtKsj+9ZZW5kUDK3h/FTlGoReF2G8Y6dT3+dvcGHNII1ziPnVsKZ6yphPc+M0F8iVF2W269zNPjEVWnRZLW4pu+1aQeXyXVMlh2UCiHXdgHkJinhV+MIXEUMt8gDs1BmZiFsY2MAuR5itFWYxb0KqMMaClkJfRZwQZLtI6WdLGM0mR46j+iwjAO2ohsWZiAh9NbJTVJ2zyiUqD3ImyRZD6NdbWIMgbfs4ItdFzsoPJDV0jO1c1eRrUQB9eRDpL/q0lkCB1FVNbLzIqbsPJok6zmY2hYE8f1lVzvZxq+KlArpPFRPNRknjx1kZiEcpZZdkYgBZdcSPQJTK4PoYvQFRF0vzl4gHAKJRoIZO5jomP74IUpGSBnQ8jYJaZOFQza5RZ9DXlN/hwO5w272CZ8P/5xLze+ybLaQDcld8yaP5X2O9TZr8iafDv4zoVri28v/E/fjn+GpBoPxE/5u43/mx/I/Mch2eLXzjzkyT1DC5zh7ghIhl7zXWFm+yaq5xK54yEHyOSvNO4yyfTYa30aTcyn8uzww7/Ox+BVL4hIBDRQ+H8r3yHVCrse85v9zHvMJgWzR0l32RchKsEHi91kR1zkyNlXkbvSHPNLvWSMrlGiT0Qo2MUazFL1E5mCprneVLX2D9xsZ695dBmbPIR/WoNBodkcf8u3wH5KIMdtCstZ+g1AtsTN4FyXDcr16qkHiDM047+HLBr5q4TUaaJPS8Na40v4O29mHHGb3AOupJQ6aLNrNVd6fNbCKHE3P5T0qr0vkr/Dl0Z/Rii7jew2UDMpGCZ63SqA6romGbUKwM3qP0F8mUsv4XoOuuERf7LHCFXrNHfbGH9MKNl18UZfjClWXfvKYLB8hXeUo31vGc+sNoBms0wzWyE3G0fAzQn+ZwOvgywar3m12s08IVIt75pd4MmSY72KMLskymbFhsjg7QEqP1fAO69xgq3WHz5K/LM+8PB8gZeiYrpa8E2c94tSm3wEM011GyVPi9IDXO/+c+9mvWIteZsVc4aH3NgeDj1lrfat8ljg9oj/6gmZ4jVzbBglpZnPBW8EdDvJ7ZC51yJMhgWraUEv8hCtLv8/T/q9oR1fomDUi0+Ca+BY73n3G2RHj9IDj4acWzk+e4qmIS/63ualu8Nf6PxL4HVYbd+klDzBoRskegerQkCs8HbxFM9xiPXwFTc6WvonfaeKJkKeDtzAmJfQvE2dHRMEmvmrR8Fc5SD5Hm4ytxhvsJZ8QeB2W/OvcNa/z8/w/MBg/wZMRWiYYPUDJiNv+GmvZH/Ne8Ct2Ru+hTcZq61VSPSJO94lkl/vpL/AcwhioFuPsiP7oM4QIeXn5n7KhL6G04mN3Lo/Tg1JXtBs3uRb8AN8PORZ7ZMRoNJ4IaXirjOUBgWfRxyzvu7Xco9O8yx/6/4Rf+W/xdPgWkb/K0fCTMhSWa7svVpp3GSTbaJ2VufxZPibXQ9bb3yHXMXk+ZBifpyHOBT3hIn6rVJNhskPTFSVYat0lSY8Zp3sU+bCBv04r2CTOe7TDyyV8VCgaTzVIk17lRQloBJtkuT3ws7zvICO78YrYaZYdOnJUq4RgC483c156EWuLwkvkOnE5l9IdPPuOUm5hK6CMh6T5wKXQRM6jswW9BbLMeTVopwStAlYO6sj1uIQ87DVt/mWux3hOQec6IcszFxMplLl9nszFOLK8j+91SbMeUgYI4eK6jpxmoZsilm0QUH63EWwxTvcoimQUhItCQdcLCBQxWRvrisgcpT53MaqiCElFVikqhLnGHHqM76+TunhbVR1K4skmnmqwEt2mzRq/17jNj0awppfoi0Puibe5rl/nqrzGx413aNDlWOzTYIXLXgsvvcl9Cct6hTutP8E3IXfkFteDKxybEYftA3LnprW8Df6wdZte8hJJbjhWKanJudNs8fZgn5EY8ZJ+hRvey9yTH7KubnNdX+Wp2OemWucmfweJoBtIfjq6xw8bV3hr6NNsLPFQ/ZJP8r8iUC3ivMfVcIVN/Xs8NQe0TQvfKHbMJzTVGlfNFkdqh6P0AcvBTUb5AUr41ksSS6xzmcfNzwloEIuYH6h/wIZq8GV6xLpssxL4PBwPuRQ0eEO8zFrkMcw0r3n/Ex9mTzDkLLevsKxX2FBtlBAM8ozPxOfcNrd4m5/xR/7v8WVyzJE4IBUx31N3ibUm9oZs6muEns+e2KPn7+DLBll0iYN+hWQV8eBifZRiNIPCsBIeqR6xFb6OQROnR6TpPmOd4KkmRZbBONllFD+m3XjJ7rMIMh0zVNbLF0IS58cs+deQ0XUyHbPhv8LT5F2HprUYxTt2XYc2J3g1vMO3zHd4zDYHPOYg+dyt+3WU8NlUr3Bv/GPr/ahNItnl0fgXXI6+xyiw0HSS7nA8sszxRmhTX4b5LpfU9wHo+P+YR/LzEvLP9NDB0n3bWMPF4peil/BESKx7pfdzJHbwREibNdqmzcHgY4TwOBx9znLjFrv9ty15yFvC95qEYolxWpQ7DYjzHsN4B20SOo0bdq4ZM4ht7Pxx7ycAHA0/I+9+j66IkEaQMmQreoOOWeNXR/8vpPRoBFsEfofItHlfvEXHu0RuUjSpO+d8lhsvWcVnjknzHksNa7Te8TbY1WNeNt9jZGIO/Xs0w03GyQHGZGw1v8tR+oBBYqHWpr+OR8hL/m8RmIjrcpXdfMim/xpHqsM4O7TPKNa40fxtdtIRK15EpLusNV5lZ/Auo2yfyHnmCp+Wt0FLrLGbfUJv+IVzwNZ4qfOHDMweG1xiT+7ym83/mU/4G45G92gEW6xFL3PbfJtYp0gEiRixl36KLxu0WGFT3CRot5EoEjMsjbed7JBOcJnMaLbMTWhCRJuh2ibJDi2LWkZkekzL22TL+xbb+UekekToL9EbfWEr2OkBLW+Dy0u/xd7go/Pp1nN9CmoVRSi9w+P4IUoGlnThcHVt0tI6OBx+RrdpX7SFnBWYDE8uu5hAQfiysFaBtxfKreotab1ZGzPsuypGQ7ROaAQbZDIi00PyfIBSUenZKRmitVXygdfF91ponZHmAyJ/iSQ7Lj3xTnSNJDtGeJ0SIpHSbkTbpWfo0koknixYhjYQj7SKvKi+Ygki+/iqS+ivEGdHJUmqMBC0GVu2rEMXjMkwooD3itKJVmF7sol28fZcjx3J4zFCKFrRVbS2n0uy49II0CYjCtZIssAZED2EsOUUQ3/dQoLpnmU3Frm8Lq5XVXMq4u319BVba9ZgXKqFjeGk2ZBxumPTdvIegd9BY+HOLwcjXpV3uNQKGA2u8LK4TeQp+lnKH/i/SW4MwzznsdknUIJrqsVy+ioouCa77KZjHmU93mit8uXA8Icrd/g3+/d4SfyAl/11LjcEj4c5ozxjM7LpQg+GMd9urpAbG8NreIIr8Q+50VbkGvYPj9lseIwzQ6gESsCfdG8xSDXLtGnoiEdC0fI2kCjGHPKB+YzbvERfHBEz5s3wJlHyx6RGsxL4vJa8zgc+dMwaSvls6Rvsyses68tkZIz0AVvc5Jq3TMdXREqgzRK+FBwlGaHwuNFWpFrxs4MekfC524nw4suMMk1qNEgble9lCQeix6vcYS3yUePf5EkyZElEXPNv8CA5phFKyOA3xRuM8xwlBK+EL/GzYYgvbiGF5P7SGpmJ6chNdtKPnIKy68jWxJYE3hJJZhm7cWqZ131pY9dZPsT3V5HCs3F2F4JRqm1zvZMdtjrfZ7v/Dnk+ZF99DMDVzm8hkOzFH9v4X/rQeZU7+KpNkh2WPIMkjVAy5Lp+habyWMqXWWIZLwxJ0mNGyS7jZJcD9alFzUTA8egeUbBOrhMeDv+G1cZdhvleBSv6a6UHk2THHDWHrMs2l1WbFf1tHvpbDIMeXwz+nDjdRQiPNO9zONinGV7l2/wmmdG8Y35k4/PZgIHaZit6g4Zp8ljeY6X1Ml11habpciz28FSbVniJcbpv9xIWJclNzFX5Hd7q/X9ohltonaF1Sj97wpG+R6dxg5a3wXHyyBniR+xxD4kkosnu4ANWm6/QFsu0Gzfpj+6B0TSD7yKRaHLu6m+zJCN+Zn7CONllpf0abe8SR+kD+vETpIzY7b/N8tJ1+tkKvlBgYE10uBb8gKfZ+7TCTa42f8h1fZNPvIxDfY9bwe9wKJ6yk37Eun+XdbOGENARIW1zm4+lJpUj2uElRukBHx39a3Zbr/EP5T/menaDI7HCUvsSR+YJh/EXSBHQyx8RyDb3hz8my8cO+ZFEwQqRaTHiiCXRZEO08T3JY71OHsYMkm2eDH7JrvwQT0XcDOwaW/PvcJTdZzf/jLHaJNMxR+MvuNn8PZ7mHxDnx0gR0BLrvG1+yW97v4GXKe6LjyzalO6y3vo228e/pNO4TmqGpKLNKN0vQ0uB17Voh8m5Y77LB+bHqFpGwWlyAXZ0SNHZpzjoi+4uad6fLOVIkcKi8VWXJDu01Yf0sCREhN4K43Sv9EqzvIfvFC1Gu+ooVjnZAvFWKXmyiXZxKJtv2iHOjvBVkzSzHrGqBeZtrqZkuXmLvcGH+C7eVSjkJDumGW6Q5ePSMw59GyPwVINRvIunGqUnW9wry8c0grUJ2HHo6q7abh9jl+Ii0dqSJ+L0qGRg5jom1wmt6JIl3BhNkh0TeB1X6cnCxpG/VipXKTwyPaYZbDjDxyrf1darHI8f4ns2fp1mA8c4thVmirm2h9t+SUgqSD4FIapAFsr4ca3+9WRHGhv/lzIk9FfxVatkXxaeeuAtc6n1fQebNXktWufz8TEpKd9rrfOLwTavhOt8d1WxPYL9WJMbuNGWdHz4q+0EX0havqSX5CwFik4geTzI+M0Nj70YjhLDZkOwEhh+9CTlA/MZ/8vGa6QafrY7JjE5fcasyzap0VyKQr63Kvh3j8b8YLVB04N/+3SfJiEbQcRKKPn5sT0gH8vPGeseUkgC0ea2fpUVL6LjKx6ORtxoNhjnhvVIcbUJ7xxoIuUyBQQ8HqZcbvq81+/hIflCfsLL+lUuNyKS3PDasiIzoAT0kmKPwUoARylsjzTrkeQoMXwxGPKtpRafH8e0PI+rTcWPjh5zS21wu+uhBLx3mHC56bM/zgmU4DDJuNEKaHiC+/3Mzp8vUBIGqSFQgn/b+4Dr+jrbYpe26fA3o3/B9dbvsJN+RK5jPNmgP35EM9xwcW+NlB5aZ8TpQUnMm23ULkqSXpLuYFmzUa2ZvW1q8Hr3fyQyTT7VP6Gp1nh49Bd4ql0aokW4ptt4iXX/Lh2zykvSesVvmw95OPwbxulOrXGCwfdWaIYbDOKnXGq/SWqGRHKJUX5Ab3wf32sxjJ/SCDYYJ3sYNJ5skuZ9WtFl/jD4HwmlQglBajRjnbPLIZ9mP0EJj6PRl/iqRRSs8He8f8RQp7wvfkkveYCnGtxQP+BY7LFkNnig3+aW+AGbssuHfMoX/T9juXGLttqkazYYih6haXBbXOXH+kccjx8RBSt4ImRv8D5SBOTapnVtNb+LT8RO+hFap7SDLVI9wpicJB+Q5gNuN/+IAQfsx5+yEt5iU9/kU/0T7sjfpkWDh/JLjvKH7Bz/iqtLv89x+sjyC2SDQLY5Th4Rel021Su8oW7yi/wjBmaPfvqEhrfGlrjDJbNBSs6hOEYZxVD2+bj/H1AuRS1UXW6JH5CKlM+yH5PlI3zVYhDbsE3kr2DQvOn/E0aM+ZK36MdPLCkqH5Fkx3iqQeB1kEhG6QEtR8Aaprsk2TGXWt/nrnkdH8W74hd4IiSgyZP4bQbxY17q/gmr+hKpSNnnATkpx8kjPNUoz9mrjR/S00/ITUxuUnIdMxg/5lLnh3zLfJ/3xM/xRMj9oz9zzpTVCUqGKBnQ8NZIdJ817zZfHP9ZeT43gnW6/hWG+R690X3GyYOzdev52dFtomC9jEcWRAnl6tZainfVeq+M3ToPUMoIgSxJHe3oCoeDjyiK4ReEr9BfLjd80TJOCI/IXysVme+1yHMLHzfDDZLsmFawydHoS1usQXiEjsXoe81SIVq42KZepNkAKT1GyR7NYINxekAz3CRJj1HKsUoLckg+wlMNPNkgTo8InRcthCTylghUm1780MLGeb0kYECeJ/heEyFUqdC1SWkE61bRywZpPrDsx3gb32u5A9lavMU4Ar+IYYxYatzkaHQPYzSd6ApCKAbxtvO0A2ekxGWutlKBfV7hM0738FSTZriJ1mnpDQhhiSFpNnDwtfXKi6YEZcy4luYkpU0XCjwbD7Tz2i/JaJeXfosVcZ3v+y9hDDxJhjyV21zTl3m52yDOYZBqhIBICQ6TnEGesRYEHCYpG1HAcZoTSsmVluJSw/BFHzINS4EgN/DhUcy3lkP+t8N3eNncZdn3ibVmkGckJmNZReTGsB555AYej8Z8Z6XJfz3YoU2DlJzbjQ5fjPqkZNwMlhhkOX+R/Xta3ia99FFpHP1R8E+IlOIwTUhNzrofca3l8f7RmIZSeEIQa8175hMA7prb9E3MkowY6pSm9NnXAxSK73S6JBoeDmM0BolAY1j1A8a5JlKSwzRlbFL2xRFt0+YL8S53zXf4TLxHKNq8xstcawVsRIK/2hlwT97jt4NXeTd+SmhCQnyuBC2Gec6n+iF/f+kWHx6N6ZuY11pdHg5jEpPzSD6hzx6ZifGEzT8daau0jNElQ7vlbbA9eBuBzaHO8jFRsMJg/JB6Cz+BYr37JqN038Y9hU+uY3cAHmLMmEZ4jchf5Xe9f8SRGeLj8bPkX5HlI8bJUxrhZbJ87Pb8IcZkXF/6Q94UP8CTgi+zfR6K9+nFD/FUw34vPaAZbBCnRyw1bhLnPZb863SEVdy+CXmo32b3+FdEwWYJLaf5AIEizg642f0jXtavMiApYX2J4lH6Nk1vlWVxlSPzhH76hJXgFjf0ywC0Rcg7/JJVrrFhVlj2Qv5j/K8JVZfflL/P27xNP3vClmdLH143V3iLnzDM9vnj4J8yyjOeiB06ZokP9J+zP/gAT7WJ/BWWg5vkpKxyDZ+Qp3zKMNtjnO6TZn0a4QaebJBkx/xe+H/mXfHX3DVvMmJMhyYjEj7j56zL2ww4IDMxse6Rm5S22qQt1uibPYb5LqPUlsa92vgh2+kHDMZP3H625WQvhd/hB+o1DtOEp2Kfd47/heOC9PG9ZQSSbuM6w2SXOD1AyYiN1uscp4/I8rFF34zm7tI/Kj1dYzK2Om9iyNnpv2eVdWAzBNpyk45ZY4fP6adPSLLjMk0vTg9ph5dRIqQjN3kw/ClJ1mOj/V0Ohp+UBlfhNDYCqyva0RVWvJv4hISmwQ6fM857NovC3yCUbTxCVvUl3ov/PYHXoemtYcjJtCVYrsvb7OSf4Msmie7TdyGDItYspc842WcUf3mmbj03HO17XXKdEDj2oLVaDsnyviUled2yAEKcHpQebDu6wti57QCh6pbt0Hyv6CbTJNPWkoj8VXqjLxy8axnIFh6OS2bmODnA91ooY3PlIn/V5lPKAE9FJUNPSs95dRolQyK1zCB96vIqW/hOqUrp042uodF0o+v0k8doMjzZINOWIALYg6QsPWctt1F6QG4ypPCcxxyidUqcHtkCDTojTo/YbL6BJwKSfIAiQAkf464vhEuXqMEXcWpzA1sNC19pnRFnR7avbNEQQfgMkz2awRrLjZscjD4DDZ6yhlHDW7XWMho/bNkxOWMmkC366RPa4eWSbDJOKmTC5rIeUlQt0yajbMBBEceK8GQDrTMif5VB/MQx1XMgZbv/DuNGjz9u3ebJKCND839aucPnxzmroeW4j3PFIDNcbQoeDgXgsTPKWQsDVkJJN5CMMkMg4cMjCyv/YNWS4X70xJDoHAF8V75Kx1fcHw357nIb8HnrsM/vb3nkRvB537AcCEZZwFoIl+QSmdH0zIDPRrArt/mDxl0+HwzpMSRQba7oO+BD6g1J9YhBbr3bG+0GOyPLUo+1YSsK+FH8K/6XtTf5dzs7/OOlb5Npw7vHx+Tk7OsBN4MljrMMH48bUZuWLxiONGuhT6Qkd7uCHz0Z8+0VxUGsOE4tSfFyM+KnB5rXO13WBr/JfXa5bO7QNg3WGj7XmoKnY/jWUou93jJKCH6jeZm3B/u81u6QG+thr8Vr9FODLyS5yXk6StmMAjYbktXjmzxNN3jX/AWxOeKyep1lcYke92kE69ZAk21umm+x1rpGKhL29BcA7PXfdwVlXNMCYdGRJO/jqxZr0cu0WGFJr/Kx/isORwl5DlL4JNkxn/ifcclcpSNDuuFVfNHkifklo/ixrZCU92kEW4zih+zHnzIOvktPjxiLIUVbw7a3RSx7SOHRDa7xaPyQ/eHHNIMN+vk2l+UdNJqQkGGya/kODjHyVINWsElTrdPPt3nFvEZTeTTwSPOUJ2KH+0d/jtFjkvAqXiNikO2w5F9nZ/Q+o/CAVI+47L1Ohw0e5m+zLRv8lvk9bnq/wWfJX/BT/8/oje+z2XyDA3OfSCzxHjsM0h0G48f83Ps5d3mdTbNORwXAH/B06SW2k/dp+Ru8ZL7FUAzRGJRR5KR0/Ssk2THLzdsk+YC76ndZVm1iMhpihQ/NTwlFhy/0Af3YpgUuta9yTd/lqt9mJx3xrrDxc2U8clJ64wf4qkUzWOez4/9kU0H12NV1SOiP7rMjQz40yzzmfQbxNlIGdKNrxK46Va5j+vFjPNVgs/NddgcfsD14G2M0K807GGPrWg/MHt3oOp6ISPWQYbaHLxssNW6w5F3nwBEJV8wm29zDFw1a/gYd/4pTetazFkiOxl9wxBeE/jK+atFPHjsjccRrS/+ML8c/JfA6RKrLob6HJ0IUPm2zxDrLHIt9etlD0mxQOlkr4S26tEqnaINbbJlV7qkvOdSPODaWCZ3qIRvqLnlgHRptMl4O/ogv8p+VXJ3np4SV7SDkqxa5jmmGm6VHqpRNks91bAPdXtsd5GEJL+Q6IfKWyExsc9tEw0LPLkewgKAtacB6c77Xtl6si9HG6SGesmkSQkiiYJUsHyGMpBmsEefHjJK90gsuYN8ixyvTQyJvmXF2iC9DjMkdzBwjpLQda2TsCGU219eTDTJGeLKBQUOOU8yeU5wW1tUmK1+gJrUvKB+UCrGXPSqhmSQ7LtMcivSBPE/QJiXP4nK+x3rMIH7iYOgRoaPSS+ET+asOHgmsMs72LUtUtshMjDQ+mStokOsYqTyk9MjzBCl9C++TM4i3CfwOregSSXZMnB7hqWbJwMXFBm0eoA+myCMWFu72ZPms5Xew4YvQs4bKn/e/5I3gGldkm+PUsNlQ/Gx3TNf3kUDbl/xyL+NxOuB3VpdItaEbFMVA4HJT8NFRzitLip/sDFkOmmgDodJsRiHbI02mDZ+MetyOuhzEmi9GfVZVg3/16JhI+PzjKxFPxxBrze4YWp4t1TlKmnRkiNRb/Gz4mKtyjSfGhjVCfL5lvsMX4h4rYoP3xM+5Y/6AOIdRbjhOU7bH0DNjfif4LntjQ5sGf9F7zBYrbPlNHqcDHsovWEqbPGKXsezzwfgRG/EtdsznrMmb9Nnjp8MtMpHR2ruJkoK9ZExL+fybo89oijZ/1T/mNf8yG8kyN1sN/mz0IdH4JbQJ+HC8RyxiXlaX6CU5QkAsYnIDvxg+QWN4xAc8Gl0ips8drDf2eBwTqoif5x+wyRUC2WaLOxyLfSLT4nLzTR4Pf0HgddgbPSCOeryifp+rbLHEKrvyMUljwOHgA/eubEnMON0nyXpE/hpj1UJIySobjLMjlAiIohVawSZK+KzoDToiJDWa2+b7bItHrLe+xaOjw5KbkGRHhMEmrWCTD+V7LJtLKHy2+28DFtVKsh6NYANPWO9W6zGjZI8oWGFZthiR0hPHeCrCkNMMN/FEiCdD6wUx5lvyD/hYfMRr+lVCqfiCX7LGSyU6F2cHPOr/jFa4RUdsoKMcTYoWGXv6HoFoEsg2veQBf67+PYFq4ylb0SvyV1H4IJrEps+SuMS+/pTAWyJjzAfib/h99QcM84wQjzvmDnmQ8nj4C37GPVYbd1kSl0BAizUu65s0Gl2G5pBUj9iTj7itvsM7+RN8QjwRsR9/SivYRGubzTI0BxyLFodpQCA83uQPGDsC01PzkYWAhUdvdB8lAprRRunRGWlTB+P0kI/SP8VTEavhHfIw5SXzOjueva80kq5Z4p54n17ygHZ0BYDj0QNHuGvie7b/dK5jkJbZ/4b393goPyMxfQyade8u1/R1DjmmLdZIiXnVfJtP5MesyWvsNKzD0k+e0ikbd4AWKaFa4jh5xGp4h8v6Ms3w73Ik9uiYVYb+PpFcImGIZplfmD+nLTZ5PfiHfO7/HF826adP6JoNmtLnuniTJ/oDWqbJE7FD03RZYYOHfIwnItbFDSLdRKnvsKfuscZN2qbFsnedvqzaU54m51bCzWCdfvwYJQM7mc6LzPQI37O1kRvBOrmOaYeXS5y9iDlkOiZQbUbZoVWMYp1AdfC9JqNkj6Loho2PZo7gFJax2sDrWIWrZElCSrGVjCJv2aZB5SOUsEo18DtEapkxh8TpIZFcdQeFTavJdezKQCpbWtF1utHa5U4Kz7If8x4NbxVfNonzI2SwTiDbaJOiTVpaZLlOiIIVAtkmUl2G0ieQLVI9Isd6h75quTSjDoFqMUr30SYt070OR5/VcgkDfAf1FrVJQ1fUo4BHA6+DclBxy9uglzzA9zZsHQ5h470CZZ/N5CWCkeUjQtUpPXcbwx6VsF4Rly87OrnC9rNlP2VpeEXeMlpnjHXivpMSZ0e80f4fOBZ73I+XCfFYCZvc71vIfpTleFKwJCU/WPf4l49zBqmFjn812OVOsMpKKPnTnQMiAt702txoNdgMDfuJoBNIuj60PHgyCmiPFb+/CY9GkuO0weWmx27PsOwHHKWC/djQ8hSfHidESnGtpVgJ26QaPhnd5zV5A4ngUrbJJTa50WywPU7RaEZiRCjavNfvcdlv8d1Vj1gr/sPOHj/orHKtJbjXN9xoNHl7fMxaGDDIcjSGV82rrIU+r0bX2B7lZPoury173OvfxIaRb6GEIDeGzYZECfiWbKEN3EheZpBqPh326fiStbBByxf8jn4FbaAbCO7oVUIl6KeazYaF3Zv5FuNcs84yvpA0zQ+45nX46+wdXu20+bw/5qVWhBDwf1t9g4+PMgbZLdbMEr7xWRMdOuo6/0Z9UK7HprfGrnhEnzZds8y3eYVHaoN3gn0LGaPx1TppduA4ICP68RNMoPlE9GzcMOrwpvy7GAz7HLEmOnhCunbyEQeEVkEF68TpvkPULO9k5/htLnd/k9CExCK2oaLsCOMtAZo4PeBx/nPW22+wJm9yaB5xw3ybfY4xwhqdSXZMFFzmoP9eyUGx9cwjtnmHVrjF2/6IN/T3WZHXOTQPy6pOadajGa6x5F8H4FXzPR7Lx/gyYCQGDM0Bq1zDBDkSa+heV9/jfv4rLvuvs643GYohPXFA3+wReUuEaglfNEjNiB+lf8or4rcJUByZIS2WWWu8ypK4RFO3yck5Fvu0jd1L6/oSB9In8YYcZvcZ8m1eFtd5y7xLS6xhwpxlcRXdyAhll6ZY4f3+v+Uzf4ml4IZlCDPkFt+jrTZZUlcRSBqB9f6OheVH5P41Apo8jd+lHWxxOLpHoFokZkhTrpCZnGv6Oh+KX5KZMcdyhV78gMhbZlld5zC/z/XO75KYIa96v8VD+QU+ISOvx0FsU5yWRJMDlvBFRE7KkX7ITW4yFD1SbEhgQEJEmwMeM857tNUmN4PfIhYjPHxW9QZSCDwj+SxssKGvsy12WDIrDEWIb3xeV3/MtnhE03TISfFExF76KUfiPk21TkdsEAZtQhPxNm9zzdylp9Z4zD1i02edG+zJQzCwxR1CEzIUfXpih378lHa4iW8UDbqTGQbPQwlnOnYxmgZ5npRxxNBfIs2G+Krlqh6l5DpxHnBUHvxaWzZxIFskwid1Vq6FuDuMExurlK79VJoPLYQcrJReYhSsOLZywzUJwMYZxOEElOspm3s3lq5qC4pcx4zzfXzVsqlHrppQoUiKWLDWGePskMhbJtXWSx2muy6on5PrBM+3v4u8pVJJBtiCGIFosh9/SpweEStbZlDrjIa/SqZjtE6R0ifOj0vyF0A/eewsUd/FfseOoZqV8TQbO0/phHaz9Mb3iQLLTDVCW5TCpGVKQKBaaHQZM9dal/G5UHRIpCVTKeGTMihzM4uYdxFfB5u4nueZS4oqeiJb48ugyUzs4n8euZDgiGEfj/8zDX8F3wvZ1Jd5PEzRLq78ndWAhoJ7fcPOGDJylgJBx4fd8TJCwKf9sYVwG012xnCcan6yC0uB5CjRDFIbS+5n9rr/+oGHLySH+ZirosN3u13u9RP2YkUv0WjgUsNnkGkiBT8+OOKxvIdEkWnDWKcc0uflYJ29OKPjefiZjSVekq+Rk/Mg7bHUX+HL4ZjLysZ2/8uTIS3l0w0U34m2+MX4ETfFJsfiiFthh/fjba6lazY2ro942Wzw5WjA1ajJODM8zvr0RZ+14TJ74pB/vHqNw8Tw4XGfS0GTQ9Gj6XX5sDeipTzGec6lRoAUgpeXFL0UMmMYZoZICVqeJDdwtRHiS8Fuv88H6WM2zTWOYs1jtmGwyUYY0Evgw+wJO3zOjvicULRBX+Ne3mMYPy2LyewM3qURrBF5y2zxOwx1yjJtLjffZKB32Rt8SJb3kLJB7grDSOmRmZhx/ITlxk168UPe8v8rl+RrLJkV7ovH3BFXbUVmoXiVGzzMDxGokoMQu4ppregyw2yPXf8REsX32/8X3h//R1ai2xwlX9rSnsJjWV7h2OzQT58w8m+Riphr+jJCCD5XLVvEQUZk+ZBGsEGcHRF4HZLMImlZPqbV+g1e5w65uc173U0ejX/hysHG5KQcmkeMZZ+x6bHODTx8BtkOxtO0xSYZMQfpPVL/Ei/L36VPj0/FW/SSB6wEt/BFg7Z3icP0S5b8a3TEBiPV4wGfsKVvskyLhgkIRcQX2d9wNPqyhGoj02RMwhfiXZqskJuYwfgJP/L/dxr+qsu3PWIlus3L3GRf3CcUbY70QyJ/BU816Gc2O6XtbfGQj8nMmEgsMdQHHJFzVbxOhEU0t7MPaXvfIvS6tMQ6K83rHJsdNDn9fJtANVgxN+mnTxBCEcklloObrHODy2aVX8htDrP7rHg32RXb9PJHtJRNb90IX2NkDgik5Hp+lffFW1w2d1gWW/TMkCW9xjItMjQpOTv5Jyypq3S8DVJiunqJAT7Lpstn4j2W2CIXGT4RAT6hWeEL8S5t1mgQ8qX8FI+QVCSM6ZPmQ257v8Nn2Y951P8Zgeqw3LjJp9k9xuk+j/XPS3g6FG2U8WmaLrlIyU2KT4vARGxwnZ58xJF+yG8Er5Im66y3X3++Stigy9JnUniEqotBk+oRaTagGWxOKIwocMQoB7/6XpNAttDGVsnJXH6VNim+S1i31VvWILGb16bWWFg48Dp0/CsEqs0wsQpwkGyjZEiouvY6qkXKwG4q1XFVhDwa3hqjbK8sOdjwVxm7+sQFqagoWWbhY4U2GU21hiZFCR8lQqSQDDPrvbaCTRpyhUT1SR08bb3eypMu7gfQjx/Tja6TOi++4a+SSavkGy4/bpTsljC7Lxv0Rvft/OljQn+JwLGQx9lhaUwUOZFCSAbZNrY7jY8nAnKTEagWeDYnehhvOwWbkjFmnO6z2ngZQ04qR+U8pLmF94o0MVup7IiqrraFcssSgLnEkw0XJw8ZxsfgPOgCktdoeuKY31laItfw6XHCX+4ec6vZ4m7XKoxXolX6GXx4lPL9NZ9BBqPMQ2rBKLdx4ctNRcuDhoKDGHwp+MMtj6PUfn4jsgr+rf2W+5ygl/g8GKRESoKBUAnWI0VDwQ+Xlml6ywjAk/CzXc1tb42tpuIvD/dZ0x18Qm7K75ORsyOfcEu/RKoNicm424rYH2tGpHRFQNcxuF8PLtPyJOvmOi1f8i02EQgGWU5LRwwyuNNqszfO2M2HNPC5G11hPZIcxE0OE0OSGy4FTTTwmn8ZX8KtdsRGJHj3AA7inFeWJMcpbI9yktww1hnfXg7pp4bHw5S73YBealgVLe501ziMNe+Pd7ilLvO91YB+Cg+HOd+PrvDjuM+hfkQgGqyJDg0dMur+EV8c/We3BvqMElgL7vJO/pcsq+ss6TUadBmLo7KZSeB1y+YV4+SARBwjpcfjo59S1EM/iB4hhaRp2iRaE0mFEGAM+PgUXZYsQ3jMUvM2o2QXozRH4r5dT/IxL0d/gkRyKbjNx+5cuq6vsye6XPdeYVW0yI2h5dmj7nf9f8ZOcMiH4z8t+SXNYAMhJJ3wKkfjLxBCsp+NWfZCUq1p0LIhqvSI1eZdhpllVY/EAU21xh4P+K75IStqjUNxQFcvIxFkXsyhecgPo9ukepWfZzF72Yc8Td/CUw2awTptb8sSpFgipMEBjxmKPm3T4CPxFvujTxgltuZ5pFbISdmUXf4s+ZcWfRK5DSO0vsvTwVushncYprtk+Yhe8oCh/30i2S2N7ZXwFmN9RCSXWDFX7N4XCU3TJjM5kWyzrjdpEnCgffqyR2YS7o1/zOXoe3xHvEpuDL8SB2yam9wX73BFX2UzClkXr3Dv+L/S9Fa5bb7PtaBDpASXxq8QeyPG9NnTX7CmblkFaEZkxERiiQd6jzWWWOUa66LDQ3ZdepWmj11XIb5l0Q//BoBWuAkKHo1/wa3w91jnBsooxgwt0ZAcieESt0lNwoARt/TLDInpix5dNhBKoo3m7wb/jIfqkGN5SEbKWPRYa7xakhU9QkKaKKPQQtMxa0gku3IbTc5Vfa3k9+ynCUfiEGHOav95QSWsdVoSpMDi+EVKjzHaxgR1VuYJZ/mINOujfRsnLGFl1SpZwnF+ZJm7zisu2ssJIUvYtChQkesEXzbIjb1HZhIbiJcNMhO7gtmWEGYLahxZxa/ajFz9ziJGbeHnhotPp2T5uIRlhVAuBhujhM2f3M7fB/pI4ZNmA4yy0O5R+gAlPMs6zg5t2cBsh8DruPzkSUn1iHFyUD5zyRh1ELrvSmRqk5VVdIRYcYVAbIUg+y4yUNCOrqCETz/fpqlsibSx6zJTpDuM0n1bZSrZLj3twOuQ5H2rmLM9lPBIUntQKuFhVMN63TrBdxXGdNkwPKNogmHffUQnvEqc95DSJ0l2KBplGJPajkjBTa7rG3hIfrS/w0v+CqnWXA6b3GxLPjzSXGlKAikYZ4ZrLZ+/3o3peB7X2j6+8MkMxDn0U0uwOkisQv7VwYDNRouf7FjiyiudJtujHClgnEu2R5rcGDYij4fDhGutgDg3PBrkpEYzyjNiMja8JsM8IzYZO+kRjXiDJ/JzniJZNVfomjZv6R8BsCa3+MNuky9HAikEnyeHtInQGN4/GtCUPl9kB1zPVlFC0PIlm5Ei1oZPx8c8kfe5NHyD/TRBIrgWtLmXHLEzVmgTcJRkXGn5bDUkT0eaQWZYCSW/OhhwIHp8J9uin6U0lMfDIdw7TvCkzR0OhOKX+0Nudxo8NHusxlv0U83IpOyOfJ4mI5uukh+w0t/gIMkY5ClDYuvZ5YccAjusMJC25KRdc7YOgO81OczuE8i2hQ3lHm2zTFtsstp6jcPhZza7AY3EK41cKXw6jZv0x/cZJTtk+Yh9+QlJfsy1zu/wmn6dlvIQAnJy0qxP5G8wjB8Q+huM031XbxliURTeOSIMv89VtQzA1eCfM3ThpMus8pH8hA+zL7ihfsB1vc5YW3LgkdjhSuNNhuYAP2qQ5AOW/GsM8z1bH0D4vMNfkSYjbqvfZA+bZrLcvMUGt9CeZs3Y/fYRP6crLvEhHxKJNmP6DOQBCp/d4Yfcav4BD8dDGsJnO/vAImnKlk9N9YjcpKx4N0lNwgGPuWzu8Jn5GTfkZQLRdOE+W7FshStEuknkKVaCW/SzJ+QypSM2uK6vcxTc5zD9kshbpuGtckf8Bgeih0Gzm3zEZvAtOmaVXaFZNlusGkuk7dFnXzwhMUNe0q/TFiFd32eVVQ7TDmO/z9P8HVpmmS/MDm3TAgkfJv+FPE/4hf+nqPE/IJTN0hn5TP6SdvrbRLniJbnB47xHKmOSfMCX45+w3LiJQHGUfMmd4O8wEkPuiz6BaXBsYhI5IhEjBhxwRd9hVz7mWG8T0uZq84cc621aco0My+E5Fnt8j+/yGQ8JidgytziSe+RkaHJ24g+4Fv6A3OSMxYDANJBIclKuiw2WAsUSa+zGXX6q/4yX5e/ymf4ZStgSq4HXZEmvkpGxyz1C0SaizYADrum7HIgeK8EtOmKDIz1kR3xO7jg5Z8m5lTBQdpMpYpIFXBoFK1YZyqSEW7XOaEWXy82iZGjTc9C0oktlbBNspxYpPdCUsHKuE9rRFXqjL2qM3ZDheK8syp/rmLHZpxtdR3mWwTxK9giV9bBDV7Wq6a+XcdVOdLVUTHke2zioGNP01hhkNj9XCZ+cFENOT1vquS8bCKFoRMvkJiXOj21s2WROcfvl53KTlnHzwpBoBZsWvvCatPwNclfnOsvHrtIXFB1/OsFlB//b/GHfxcebaq2EsJtqjX72lLbaRJNj0OQmI1RdfGlhYik8JBIhFO3wEkr4jPMeEh8lQ/s7GSJQhH6GEh5Ntc5I29QCBa6nqCzTzyySbDsy2WpaHr5s0lGXGJkDRmIXIyPy3Ja/lCKglz7iHXVEV14moEHbX+NhOibKFY+GkvVI8sFhylEes+5H5EbynZWQpgcfHWl+uCb4mz3Djbbkyci2Z+wlBiUhkh5PhobvrTbJNTwZ2TjscuCxN9b4Ejq+pOUJfnsjJNHw+XHOMLcGTUN5fKfbJNHQSyRbjYiPj0IGqeYfNn6TLwcjnogdPhHv0vYu0cse0SZiN4a2DFgJ4B9srPGz3TFvrvl82fdYjwR38y2+6Kd0A8lhrBllGiks5P498W2EgGMzok3ElZZinHdQwpLRxjrjl8fH/NOtNXqJXbe32oJMN2mOfG51JLc6TfoZHMaG292AQWrYy0ZoY1j2Qv634//MNfEt3hvt8RuddfJhxFZTcZR6rIUBoerQS2z99TvtJu/1M3bHH3It+iFLeg0fn9y0iNNDlIxcbebHjFNbNCby1xh5eyz51+mzTYMVayQ68qZSNnTUCa+WaUu2uE/TGtl6SKaHtlWluYQxhkwbAinZlB1ud/8+nx//F4TwidOnrla6LRNojGYpvGFhYGNzehOt+cI8ZpN1UnL+cvwvGIy/RAifnveA913Xoc3mG9w/+E8or8uKq/W96t+iaboYpWm0V9gevsN18QZfirf4IP5PtrawHjFK9oj9HreC32FH7rChN4jEEikxsemzn31Ow1tmWVwlxaJKB+Y+W2wiheB19ce8HfyHMgWz4a2xN/gAGmA8zf74U6Koy3f132E58HkleY0bzTv8Ivt35Dphx1iDaEd3OUofcM37HhrNo/RtLqkr/L3wf+BLvcv74//I7egPWKKJMQ2e8BmRt8xu+glL3m/TERs0dZuuCunlMW3TQrNFXxzyBe+ihM+V5A4NAh7I+zRNF60zjsUe6/oKIR4K3zbriNYZpfv8Uv4ZK9ykEayhRMjB6DN+4h+y4t/khrbs9IGxaVUCRSDaBDQZqQN2uccf+b/DR/Eux/KAhmlwSV/iM/khy2aLEHseR7LLVX2bS16Hnr7FT5N/Q9u/hC+aHKUP+Eu5Q0tt8BLf4TPxgJyMLX2NAMWqf4k9HqHwuKqv0GfMrnyMQfMZD4jSm9aIlRYFfS/7j2WhplawSWZievIQaSTr3MQziltqg09zG058SW5wWa/y2OxzIHeIWKKlquYrp8m5+wkXhSbSbFh6wLlOXOHvY47Hjxgn+yVD1pCjTeaqUlkWsUSWNPY0HxCnB3iyQSBbrj+qLL3qgoUdeitlelPq4GIpfTxlC9bb/N2QUbrPKN6hEdgUHCksO1gKn2G6W1qdmY4t6Uk2kNInzQc0/BV6yQOXS+vZNAYgzo/LXEmAQLYZ5z0bz80G1oPMjhnE2y7nN7SwNbJkf0ppi7sX5KdcJxwnj901hs5Y6JBmQ/ezTQXKTOxyirOyXnARdzUmJzM2jt3LHnGUfOly2EYcxw+J8yOGsfX+c2P7lw7TXYbZvoOajy1DXTYd1G4NCI0mMUMGDrYuiAW2L+qkVeepZdsAAk1mxqRmxCDdcYiCbVBeVP0ap5aR2DLLrOl13hrucDPs0PQk9wcxqYYrLY8lFfLtFY9vLwt6qeHh0PDGiuQX+4ajJCPR0PQkvQRHhIpZDjxWQsFbByPePRq5WKjh0TCm4wt8KXinbwvTdzyDJywb+1YnJJSKh/kBmxEuDUrwWS8j1jl72YjPBgNiMhs/0ke8bt7Alw3uyXv8zeERQsDb+ynv7Ke83I14/zDnF4NtPjxK+fw4ZZzn7MUZR0mGFHbsPj6/Mu+RaYNAsiMOee9wTNtXfJw/wWDI0EgED4aGrabi03ybf/O4xy8H2ygh+PAo599vH/LOwZhPBn1+erjPX4w+40AccKPRpJcleCLkCZ/xVN7j/eM+LV/y1mGfpvL4VXzfEcKswj+Ic3blNg1/lbZZYl8+ZV01yz2+3LxFlh+7Smu2S1Ti1u9hco9RdkhGQZQ6YBjfYzB+jBQeLblm97yJy3SPzdZ36DRuOIh5j/cG/5ofjf5XDvSIYZ4RSMmr3HHngV2DWvex/bitYfq499c80u+RkJJojRKCNbNKjyFv6f/iyre6mgDpvutIlPHo+Kco1WbN1SrOdMzIHKCFTVsKaHKr+Xe462/yA/mHNP11C30PPrY5sME1MseG/svh/4pAEps+DbFEx7vEdfM6t8x1WmbZxhSPfsqIhK7v8VK4xHf9/wPaFf63+ygikG17DX+VoTmgowJyAy3l8Ug+YC24a4mnesj28S/Ziz+m6a3xVH/EmD5vqr9HTMrD/JAdYZGG+9kveMgTPpYfctnc5XV+h5a3wY64z4G5z0jYlLsBY2IsQ7pvtp0xn/J28v/jp8m/JKaPwqcbXec4f+LOCYOPPZMacoVucI1Uj2ibZVsOU15BoGx4DcmImC5NlsQlrjV/i050hSaWodxUay5nGVo02M/v8VR+SeJSQX0CMjSeu99jeQ9PCALn+CS6T1us0fI2GGeHPO7/nJ/qP2NXf8Zhfp9d+YSEnESM8Qi5La6y7IUoFD4WzXyY/oq/yn/CU7HPE31oU6WCGyw3b3Gz+XsIofBEyDV9mViM2OYTUhI+z3e4r3/FtnzEUR7zqfgC3/jc1DfITMxR/vBcuvXcnnAUrLg+irv4XotAtUnFiDi1MKznNwhVh9xklvZv9p0X1yLDkoxyp5Tb4SW7AfIR2qQYQhvj1bEjQwVI6RF6XcbpgSsYYOGfLB+jXE6tlJ6NJaOIXI5yAedqk2KM5tj1pxTYXMdMD8suK6HqEGNzFpu+3aS+bKCEj+8aokdqmVG2hxQ+vmgwMDu0vS0S2bcsaTRttUnGmFF2iJCSUC2R6iHjvIcxObE+Rmobiy7iuNpkpGJAO7iEJ6IyoTzwOoxyG2sq2OWjeBdtUjwRlAz0plzBa4T0s6e0fNvCremvo72MQbzNUuOmZTp6K3ZOVGqNGJdyJYVHnPfKHFAhpI19uP6sWT621YREhB9eYuwMEyvGtWu0ikQJn2G+S8e/wlDuITPPdpZy7yLJeuyNP0ZEkkSM6OhlemlGajTLfsClBgwyQZJ7vHeQ0fYlK6Hk6Sgn1YrvrQo+6fk86Oek2iBQLAWCq82Qy01BKOH1pQYPBhkrocCXPp/3Y1q+4OEg5+VGl3Fu8KStUJVrUAqut33EYJXdGA7jnJVQucQtm8B1PWrycDzksr7MUB3xKV/gEbGmt/BRtDzFna496P/dzg7XvGXebG0SKPjr3i4NQjom5FjHfMIO/9flOxwkTX5v6Xscp4b91Oey2iRQgh+uCZpHVwmUYDVsszPKGWeGUW74vc5lng5z7gRt+qkmkILvdZbopZrjVJKbAK2N89BTcjRvit9AIrjetgbWo0HG1ajJKNPcVVd4Mkr53mrA9liRabg1vI5QknWzzFXWUEJwVaxxv3GTOOu5PsSP8VQHKVrk2TbDbJ9meNNyQ8zQlvjsfK+s9ZvrMWPTY5DYIjQCyUudP+S2vs1Tb59H+l0222+Q5Dbv86H8gjf4FsM8I8dwrf3bfHn8F66B+9ARLMeE/hK+q9k+kD1gBSUEGZpLcgnJ79Prvk5oGgxFj8/6/wVPhO57LTxhvelQdViSV+mbbY6NRcECGrwsrtNLUzrK5zvm9/kvg/8nvr/KzfYf4BOynX9U7tUVs8ll8RrHOuYj8XOeynu8pL7PctolzYcE3jKP5edcyb/HOM/5mL/mjej/yC8H/18S3Wez+Qax7tMUK4zMAY+P/5qfdlJaZp3ItEjEkLHusdp4mWG2Ryu6bI12PSTOe3TUJRSSoegzFMc87v+cwOuSZgM+Sf+zLfvZGLLGD9CkbJpbNEzEjnyCNKu85K/wMO1bE8poluUlVvQGMlRkjFk2W6QiZos7fJ7+mDRI+VI8JcfWQjiUX2JMzlbwOqG2KOaa3iRpfpfMxCyZDe6Ldy1LmxyFhy+a9M0eoWizn3xK09/g59mHNEQLiW+buSBsURHG3FDrePk1duQOB+Y+H2QPuSEu8ab6ewgEV4IGP0k0B9q2ylyXtxnTp22WuWw2ydEMnTetMbyn7yGF5Ja5zpH3hCVxiXujH/M0+xW2AcQ1273Nv4vC1iT3jMcj8ZQr+hpPpCQloa07rKlbvGRu0lQeH+tDNrlMJD18GviOdPvclHCuE6Ty7aGaHpcVmACr8HJNzDF5npA7VrTWGZqsTA0opFDAhWedZsOyEbdyRS+0zsoOMQWUbHOHm+UYDDnGaHquNNg42XNN2xsTSm0Yb9tYtfDITMLItSnzpY199uMnttaxThGetNZxuo+SgSU/mIxRto8vm7S9Ldt2zsTEaQ/pOvd4MrSt7Whw5Kqk5Dom8ldLT7pgLTaDdTJXfCTVI/s/l/NbpAhJLNSv8zG5SQjVEqPUFqGXwmcn/sA1lggZZXvWKHK9MJUKyE3KKNkl8Qd4InAEuqHLm7aGRqZHznCyselY94jzXtnurwgD2Cppto1jWU/albGUwiPJ+5YH4HLAh/FTbN9TDXqMcF5VYvoEokkqUiKpaEmPXBt+uZfxNB3SFAFd3+fNVcEXA/CE4Kc7CX2d4AvF9WaEErAaCu71NR8Pj7k/DLjbiWh5goYn6aeGJ6OMnhnz/qFgV/e5FSzzxorgy4Hgz/f3ueR12Ig8cmEh0HcOxqwEPo9HCYnO+UR+jBGaG3zPvkc0TZY4Mk84ir+kH16jbTbppRnvH1iF3SLiMIs5zGIi4eHj81q7w/YoQyL4/cZtHg9titSv9ocEUhGT0Q0a7MUZ94eKJ6MEJQQPskOO5B43kxt0vYBeYkiNxpeKWGvaQuJJW5oS4D0+YElscCT2WdFrjMQYdIfLYZPVUPDuQcpQZywJRaJtDerCo/4ofcomK9wXj2jqNk/EHlt6FWEE2xxwW/wGoR/wZfgxj3VmWyA61qyUTTaa30IgOUg+LxGbzc53GaQ7DOMdnh7/wmYNeB2OR19yx/ttNIYD8YhBsk07vMSr8vd4y/t3HOdPGAtbgSqSHq+Y19iPPueo/wHKdUgLvCU81WA9fIWxse0Ut/Uxuzxmkyu2AL/q0Nc2taVpujSCtbJ8LMoa3Z4oFMYWL4vbfCA+ZMVskpqEd/kIX4RonXNv/JcI1wzlafIuV4PvY0xO17tKkttY6pA+T/T79IZf4HttHkcvc9lv8ffb/3dSk9Nxdd/f5pfsHP+KXfEugdfloP8BSXRMN7yKwp5/nrS1oIfhJsv+DW7rVwFQRvKh93ZJqhrrI17x/pCxGbItdvEJiE2fleYdknxApkesBLcZZLapxPu8zQrX2ecRy1xiTW8RSMWn2Q4HcpsVs8mqvI4mZ1c+ps0aMUNSLNr5xHxkMyaClO/L18iNIW/b+PsoP6BtllmXbYSWdv0BTbEMBnKT8iR/n2/JP+BQHnDTfItP+SVH6X3awRbDbJ81eZMDHuOJkCOxw1gMaLJCU7f5TD8FAQMOOE4eIwOftu4wEEO6xoZxfsN7Fa/hM+CAI/OEpljhkX6PJbFMzv+ftT95kivJ0nyxn6re2WY3n+GYEQjEgIwcIjMra+iqYklPfGyhSAsXFP5tXHDHFR8pr/lev272kNWvuiorKzPmCCAQmBzw2d3c5mt3UlUu9NqNLC66soRtGyAyHe7mds3u0XPO9/0+zUgcIZCU1jj7Jh5LW7DUl7T8Ifvxj1jZKYaS2/YxF/KIkozUujhViWLAHguxJLJtJuIMIzUFK56Jp+zru2hR8lo8YWr3WNpR8x77hx6/dxFe85GVDFAybNieoeqRVqM6lsuvsZJJ06W6sWbhoBZ1ZxTINkXlhEClXhIFA2Jvg5l+S67njVVGCOWoLXURlsJzLGNt8L3Ejbrrrth1je7Xyasxvvq+u+snd103rQbkxqUz+TJulNkZ13V6kqQwS0LVIa4tSg7/6Iqdwqcia2LpAtVGIPHqvWqihiyri8bOtCaDAY2afBDdc+MXk5OV478HQVlbumS9a5bCw/PcXjn0uhR6QaWdZxtcUV97hCXrrGLViNVCv0/PP2h22J6KaIXbTs2NO0Bl1ZTE3yRUXWbZW6c4rB9FNafUk9pPXc8v1+xwW+GprgsplyEDeZMVMwrjGLyL1SEu+FuShDvsho+5Z+4xsytu+T12E49ZYZgZQyAlM7FA2g7vxBEvFvDXk0v+ZLBF4vm8XhgyW/GLTcNloXgyMVxmBftBG2stp2nFbuyxl0h8CbNS8sDvOnWxv8Gb5YrfXoX82a5gWQ1oec4G9ZfnS3680eKvrq/J84BE+uzHEcvVbWJ8LJa/2Onw68uCz8uv6fr73Ip+xh/Ed3i5XOILyTBSzEtDpH26vs+yqrgyCxSKZWW42/E5WgqGkaA0sCjhbjtmJxacpgFPlzM2VMwn4zkv5BMe6Q85Fs8Y2gMWZNwKY07SHAu8XeYsbcFVargVdAikZFStqGTOI3+H0ljOzZLEJsxJ6VcRz6agrWUvCpkWms3I49t0xkDEvCiuuJYnrgMyA8ZyhG8DVH2AvSO3CJRkVWle2BW323/MRL/lcv45ge+iPjMzpS23uev/gkteOa+6SJpwlFa0xzI7Jfb6+K3YjUOFGwPm1ZRVcU4aXbEbPnaJQabAQ3Jur7kttvkT/3/gtP8Lvi1+CdB0sm/nf0M/ucu5fcJhNSXNzzmPbmAxbIfvM9VOQS2RTqgkB2zG90hMm4m8pCRjVp3wlf73eDJmnh0xS+7TUbvsm7t0RcTIznkY/wVXvGGTWwztBoe8dAXYprT9XSLartirITNek5cTfmX+7/ws+T9zN+pQaMfp1gYi020CLoyp6MS36QT7dMQWF9UzLIat1gd4ImRRnfFm+l/Y7N5gaHvEyuOWfkQoPF6LF+yIu9zzh3ylF7zK/tp15d5ttrnNhecIUwCXuUul6nr7HBWf0PZ3ebL8X/C9FvvRjxjaHRb2grboc8seMLIzTsVzZjVzO7Mz3rU/ZMQhm8l7rMSS02rBtmrxM/lj/kb/LVvqAXOu8cUWP5F/wSVjhmafuRzzqvp1w18YeRfsmxsUaB7xMW+CFwAYZchYNEUrsV1CIoSV7KkekVKMi5wtOyDzZyyqc77mnA3/Lq+rX+Ov/hn7UYxBs6wunHbDnDFQt/GNYoXL8+6JXUZ2RkDsVOFUhKrDezzg0F5w094mEB5SCGa0mdtLZsUR7wZ/xkqkKOuzJzYIpOSy6mCwPOcTunIXjWaPBwgrCfBZyCG5XfD7PH7vIrwWM6073EC2mWavyVW9H60FVVJ4lJUrUtaaZpdcMK+xkjGFWTTd4bpjzaoJlckwpcNFmgb24WFM2jCO18HgeTn9ntMpPAzOouR40BnaFG7ka03jXV53nC6ZKKytRVWdBel2nsZWaBGQ1bsBTyZUtkCbnJUZO69v3RVqkxOqLpVx+zBPhc7na1Yu4MEfOEtVdU1pVvgyJtWjxrYEzooF1Ai9qObYShJ/i2V53vCrV+V1A9DXNTRjLfpSwsfaBU7DrOpdl+uKMzNtLFRCKLJq4nzeqt9g+9bdtZRe8/v59TRB1SIvUYtzrM3BOnxlWY0QovZRBxGVzep4t2l9bQO3Ey7GqNBjwpJSlLwux7yZSm4HzsoBENuIW3GLVWUZRoIfdzYbnOXrBWx4Ec8Xio3QMis0/cBnXLjx0o04pDRwtNRc5yVLW+DjOs13vA4zVuRFxd9ctvGk41VfZdD3Qr6dFtyP+lzlBXOT8yY744G3jy9dcMQ3Ezi2zpLSZkjBihfLBUMvZq5L5qXkSXHOfbXNXuLCKIo8RgnJRZYzKzwuzJw4HTAMJUfFgovqlJuLm7yWr/hF9D6FsXxtD7lv3mNFiSdC/rB1i6uV5rfpKQ/9HWIlOFwtOZZvUHh0y4hvxbf8NPiQUbnFqMhpez45BRLJXI6Z6zbKSO60It4uc16LYx5Xd5AIXnLUKEKuOeJKaH4mfsZ39ojMligkua5Agy8UGxyAhY7aJei1OZ78JQjJ5fxLluEOKvoRG/aAA/8RZ7xCCp+N1rtczj9HCMnZ7BOScIdFfkZlVhT1zrab3MfYiqP017SCbX6Tf0YUbLDvP2ZkUroi4kAOMcGfIhG0bYvP9X8iDoZYq8mqKcvsGDDMU3dTdwdAwBrayV16akBmZuxwGy0qltZpRNpqm8jrMtFv6cd3mK4OUUnIhQxZ2C4bOHBJJfc5Ny845wWBTRiwR2QP+CL7N/STfUoyhhwwCV437AGJYFka3uprtqoevpC8Lx6QtscNyS7TE961PyS3JaWXU9oVngg5XvwdN9o/ZaaOOOFbjHjIQ7XDgepwUiz4ufchmTZ8qV8xsccuiMIaEtVlT2zQNW2+5TMSMeBG+6dUNiehhw1uE5Cw2XoPT4RcVy9J1Zg/EH+KEm6S1DNDvNLjUHzZ3KOuxZREDLjIvmHCa074lMjrkahNdrnHgimn2ee0wj5D+kzEGUtzyQPzMw7Lv3bPLdzmJP+cMIh5oPZ5at4wNPt4eMAtrjglsl1GHBKJNlNGTM0xc3sbVflYaQhszBZ3mfsjLtKvWUine/lV/v/khvwJAPPsBBO5FWHb9umpkFJremKXJWPnZkEyFZcM7IAfiT+mGyiGWZ8v7X/lHX5KXyTsmG3G4i2ejDmyT+iLfcA5DvzKJyZkJK+4adwYfixHlOR4wqdr9qjImeSvf6/a+nsX4TWacA2GqExKK9gmLUb4XovY26iFQ67rLfWySfXxVB3fZ1yBlbi80Ky4JvIHSOkAEoHqIKWzNeSlGzU5UpbXCLeMLRtYR1aMmzzIRA0Zrb6FWrHrUpd0PSL+/rEOOJDCa5SWSbjViDha3hBZHwzWwqVI9dEyp6N2QcGkeusAFzWXGagFBotmRC+EbMLTRX23k8InlglpXVhDv0fk9VH1CbCsUgK/09C6VE26WlvD4mCzQe25zteQeEN8ETu7gslJ/CG+LJmspnSifTwRsdLXzj5Uj/A9FZPIActaKBOoNpVxUn9fJE70ZRb11CNweyU7BRlQVVmNrVSAbsQypUmJ1YDMTMnKUb0PXgCCsir5dvI/0Y5v4snYdUUi4W1Z8gN+wk4S0vEHXGYVe4nHrLB8MR/TETFKRFzZObcYcLQ0nKTQDRTGwjfiKz6wHyKFYFm567AbB2gb8PXqkl/0dogUvGsHXGQF3UBysqyIPIFCEChBgEIK+HAQMStCXi/d9Xu3p/Cl4quxpmc7JN4GJTm3zB0yCoZRm2/SQ/bkXd7xtrkuc/asx+t8yg86A6x1YJHEk+Sp28V+tkrRaHbNPoFQbJt9pkXFRujxWL/LXsfjbFXxKPwJq8qipEBVimVVURrJjShhSz9iM1IUBkT6LvOyZCkmnCFpVx3ej4eklSEpQxZk3Pb7HKcFS1uwZbdYVZqpmLBltliIJRLJqf6agXeHL+23IKCwAzwsO35C4klavmCvvM11XjE2G07E0z5nvnJrl6KaE9qYWU0n+gEfcRbe5kQ8q7OxJ/VhuqpJcxUCQRzsUVYphZ4jhcf18inGpBTVjP3eY4YyoaoP6/fVNpnRnNkJy/yMqrbYSRmgarZxr3UPJTwMhmn6ktAb0PJ3iEWPsX7NsXrGgH1u2PfwhEdlK7q2RVv2+a74S5Jw2+k/fMll9YxT1eKG+IAVLk2r0AukknRsj56I+PP4/8Jr3mJr2xNAmp/Tjg+YiTmn9i1zLniSn7IdvU9hUmLR48Xsf6Ud3WS+esVZ/zHbZocNs8upeM7SXKFkyNJcuRSr4pxXcsIj/1+hJPgoviuumMhLXs1/Sej12Gx/iEXTswMMli0/5oUOuWFusRu0KLThK/sdpU3Z4iZCSAZmizMPpuUR3/mHDPSQRIdcijFalGzzAGklJ/YpVmgM+numQs1l0JQsxBTfhnwc/CtWNue1fEFpVyRqiDKK28kfMjEn5HrGILzLnGteaMWO3aYlA15y5FTm1t2LWmKTO/YmC5sTqBhpJZFN3HRQVAxtn3PzzK04jVu1pfqCmTkj1zN22z9knL9iQx2grOJYu9WOqYFCPiHX4gSFTyR8EuniTC2WTXWPxIR8Jb5g196lJTappNPfFKzYtzd4IZ84MAcliWmzJXq0lEdZlW4yjE9HBSjr0/0dnOZ/6/F7F+FldlqHdsum0HgyQcoplV6x0GcNJxmoMzGdsnedfASOu2xrH7EUDu1WVktHiTIrFAGVdkXHFUwH91h3quvud43LLKo5kddHClVzWiWh16u9iC6FRZuC2N/AWt1YkXI9pyjnTciCNYX7s8Y7Oq/uikC1m9cgt4tmD12YhRtlrxnQXu6gI3XH6w4jYfNzfM+BNiKv56AkauiIPuU1G+F95nUm8Hp/W4hFQ/ICGsuT8wH3EUI1e3avnkKsn2uhF/he4sbVteS+6x1Q1gHbUvikxgneHIR8RVpcuYLrq8bfFvkbTNPntKIboJ1vGNYGdNPsh4tqRum7Q1hjO5MB1tjaM1xibcY8fYnvDSi8OUmwyUDdJjcVizJgP5G8WpS0PJ9vJjl3Qjfx0BZuqD6lNXSl5FW65OONDs+nJf8i+Qm/Xp4iV0OMtURKoa2k60vuB5s8mS75aNAi9gQt5aGtZb/lURiLLwWDAA4Xhvf6kr+5KLAWClux64e8nGtanuRtMeVm0ON1NSC1Y17Lkj1zm9fLjK7tsygNs6rgbivhxSzjD/obvJgXLHXJx8MWV5mlpTw2IoUnY3yZMMpLjLX8sDOgMJBWhnM9ZzmP2IsjpIDLrEAKwaNok9LAdqya5zspDO/1FU+WGTtei47eILARS5HySTYnsgkhARLBqtKMax/+vajLk+wSXwRcyktC60aW29679MwGCSG+ULQ8j3GVUVnLuKg4WpUoIVF10tOFPGVbPsKYkvnqkMDr8mTxP7Pf/phX4ks2xc+55W2Q6QNG4lvnK7eGorb1CSSe10dK5y4wpkAqtxP1vU1a0S6RbXFh5+ypLnNdcCGumIhz3sz+E0omTW63r1rshx+xqHdwhV1ww77H03BJy99BCZ9b5g544BOyZMJSTMjsFF8kzPnexphVE8oqJQp6VDInqyac+c/A4sRE+pxcz3mqFtyXP2csLxmaHZCwabZRkc+p+cx55HGFy1gnYLpWr1jlVwxbD9ntfuymVYGzcIZ4SBJi+yFjcU032WNunI4lUEMiNWBZaSIlacuA53zD2+lfkYQ7ZOWYvBzTjg/4tPo39KKbiMppf1/LZ6jiESMxYWC3KGRKyoKcBTEHhLTp+7c4q54wki7mb5lfEPsDKuu4DAN1m7E9xSMkVgOU8mmLIb4NaNsOM6b07ICSilKUKHxmxRFaF9yO3kXh81P5R/hKstQlL+VLfOtzKF+ysmOm2Vsm0R0AFL5zDNgpI3nCuDyk5W2xxwPG8pLr6iUD7w6eDdlLfuTuPTZlzgkWzaq4wpMhO+EHPF3+r+y3fsItc585ipP8cxJ/i4SEu+ojPjPf8FocUlonBjZCc8986GIai0NU4J5LoobcNw+5EFdciitiukzFiMR2mMtrRpyAga7YohQ5sU1Y6ZyZOW4Sqf6hx+/Pjg53asRj4WhNONuBG1mGblcjwyaRB6jFThWqjkcD1xW2vC20Khmnzwn8TjPKtqVu/MRpcYkyYdMVr8fQQqjGyhR4bfJyWqt+wybXds23dlGDffdGFx0MmsIsGnVyFAyasbivWqBo9qmVXtEKtvFE5KAiMiQSXTI7c35ab1ij3lStNJ47IIHXY1adNPvgULnONlDtpuMNhBvxru1cUnjE/qCBlhhbEckelcqb18YTAb5IUL7fXJP176lESGVTrNWUNqWybhSvqwKjKpQMWFaXTYH0PUUo2xT1Xj+QbWToNa9RpidNtqcQHqv8sv6Jxu2G69ff4oqsmxh4jtBVX681WMTtqf0a8KEpqzGVdilXKgyZigHeSvJ2ZUikz9NJgbGW+13FILAkynKZ+FxkkFWWlgw4WmjemCtue3vsssEg8NlLJEdLTeJJpoWzN/wfDxJyY3k5h9IaOr7HKLNNhN8wiFhWFZ9cKSSCp7zmJ9E9xnmFEHCSrViIOW8LqKTbKXnW43bY4WU+4UHU5yLL8YTkIitpex6j3DAIPPY8HyVgEAoqoyi0dZasNOO9XkzHd0rtSQEg2dUdVlo3GcKhVMSexBOC2BcoAYWBQAq2Y8lFBgMZo61lYAfklHjW4914wLI0pLrCAg+6AfNJzooCi2UoupRWc9/b4kv9io7pM667uEh4TG3GqJpxzx9SGstu7KOtz+tlyoNuAoS8mkesbMnQ3+Fz/f8mr5x45Tp/wUZ4nyudEuIRkbCRPGAVbH5PxjMrhFBs+Q95aB+wDArO5AkTc0JLDolo41mP2EbkIueX5b/FlzHz1Qmh36MT32W+eoWSUaN5KMnJ9JhEbfKe/bj53O2LRxhM050JIenbHW6IIaktSW3OhmhxZecM2eY79XfsBY9p2x5alWypB3jWoxIVS8ZshPcp7YpR+i1fiH+DFD7nKuJG8EM0moqcdriLsSVv9ed4ImRHPuTafsssfYmvuszyYz4O/hVGWL6Nfs3MXlCySyA85nZGKXICYkLpuPFpMaJQS67899ivyVe5WTSxfJ6MaiFryWbsil5uF3TEFkvGvJVv8Anp2g7nqSN1bYTOH33T3CKRPmP5gG/t35BXs+Z7eIQ8sPcw1vIVn9C3O7zRxxyoH6JtyVRcUonKBTaIiDOua8azpBPscbV8yql8y0P7gNSWbPoRXRGQ6A6v7Scs0ws243cxtuRi8SU3Oj9Dosjtgm3RY8mMDf8umXX3irbtM5S/4Ln+tbtfCqexEULSinb5M//Pec2YK3nCRfGEfnyPA3OPG2GLVnGTC/UtiRxwzSW3ZId71QPOxAVteuRkDOwGqUhZiCmD4C6a0t1LTU4qcgIbOTKbuMETnpOKOR27QS5WlLh99RM+Q7KPL0IG3h2S39Mn/I9SR68TfyrhisWydMIoT8bkZoqud5prHvLaE7x+rIVY16vvas5xwSq/+ns/Z91Bh16vzgD+HsIR+Q6FWeiVS2Sqsx21yd2oiHU4Q9GItLTJyfWcuT5pwhGA5jmuSV9ltXSpTL/DQM71nIKlG73Yily4TljbisIsKPSi9pA54tVCn7piDs2IXZPXO+fC7cPLeRN4YetItWl51NiCHLHHY1y8wtTdsTY5lQxZleNmr77OrDS2Qtd+6FV1jawLuZsIdMiqaTMG9L0WRekEWrPy5HtFdg3kKFiSeEPKatlYvEJvQF6N658XuV2zpU5UMiiZOL53be9aH35AImWI40zXoQ5rcRcuCnJH3Oeu2qLtSyLP/X+vFhmhcGlJSkj+T7d83iws41wzjBT9wMNY+HGyy28nU1KREpRDXl6nnMsjPqgespf4PJ+njIoWgYTj1HW5voQXy6WLizNwUaQUaPpBh1RrpvaM6/wmD7oRiQf/ZbTgBjtcMuU6f8EwOGDL9vm6OGVfbNL1JSeZYSd0KvJRXnCnE/HL60u6JGiT1IxqR82a5IaW8jhNNSSKo0WFwbIbe7yprnkYblIYeLKcsue1ybThNM8IhMfNJGKcW7S1xFrxap7zHa/wTYiRbr1xw+zzdpWSU/FRp0dh4DTVLMm4lEe8yb/hrn3MWI74ujykMAvuqH+GMe4gemXnhARsiR6n5ZLbUZu0cj9zRspRParvBz66sBhr6UT7qDJoDt6Xq2/YiA/osYm0baZim1KusNatf1blmCTYJLEdIqXwTMTIujxYgeT16q+b2FKBi/hcFVfNfWCZnxIHeyTBkG3vXZaMyeyMO+onXIszXoin7p5EQipmbkyuT5wXlwWVyMlZ4YuQpZhwBXTYILSBW6ewYGJP2OcRV7yhIiOgTccOMcLgscUyuKTr7eOLmHF1SEnOpXQeWil8+uomY31IYZaUKudG9w+YlkcsszPKasmz8BMmq0NKvXSTwFbKPftj5nLMVfWc0qzoB7cdA18vmacvWPX/BOgiBHzEH/Afy/8rcbhF7G2wyM+QymsQi/PihMJbONa9rfiF9y94Kp9wkPyM1Dqa11v5ioqcA/OANhFdtU9bvk+Km1Ys7AVju8OO6vCR+QmhVNyR/5zYk/y6fELPuoxmg+GYc0pRkJOyYXZJhUMCX5bP6HgbKBReKflWfsNCn7nY2TqzvRvdZFc8JGXeAJKu7dKpvUXKFncZyRMCYiZixU3rHAvSCnIyxvqQWA24KjNk7dkuqjmxN+RCnkK+x4aKucFjplyirMd1WfCZ/S+8yy/YVAkvzDFTMWlWCgCVzYnFABQc2ieOpw5cccIdc5838jV922FuFcfiLQt22LMPyERKiTtIjfTLf7iw8o9hR1vTFK7E32xUw+v9asMrrmkwa8vPWh297gwFjt60vlmvs37BFUxtCpJg83tgRk3bqqqsiUVce4I9GTad81oVnNUw9qx0AigVbIN2hc8TIUHgvMKy3umuv9eqHDsIhikbCPp6/7osL5vdb6Zn+DJ28Am1RWEXzIvTmmHdqb+XE7EFXssVRzEi9oZ4IqRUbq9S2YJeeItldUnL22KcvURKr5kYrAuwizvMaAVO1byGmax/1nrk3fK2kL5PIBJS7V67lrdN17vBuDwkzS9cdx/tuu5XtZsDSag6zfcQSGJ/QFZNm2viq7YTtlUjQCJkhDELhAhcR6K6VDYnkG2W1SWD5D6L/Iw0e+tIW3XXLGXsoPxWuNhEb8ULfcGH3i6VcZ3hFRMGpktL+Sx1yfNFBFgyo7nZ8rAoRjm8WZTciTocZZK9xKdfdbGrfQaxR2VgGEQ8m2pmZcW9TsjbRcllZgmF5wQ+nsetKORoWZBVlr044P7yBwyjgEVpCJXkTL5lZrtc8oqN8D7bdoAvJR/4e2TaMMoNPRUSKsFJmpMoj+ezkofRBi+zKb5MmJUVvvT5YV9zkin+8nzFrSRmO4IvJhltGTArDR/GW0gB2ljaIuSdnsdKw4H1uVxpur7g9aKi6yumheHCzPiX/UdMckOoBE8Xcy7EFbfELh/32zydFJyZKT4+qVjQtVtYNngjnnK++IJB8gCAY875KLpJYSwnxYJNldD2FQPrEyuJxeFCd2WPic7o1ba17TBkVip+Yv6EX6v/UGNql2y1PmAsTsBCn66Lz8uO2UgecLV8SivcZajuupuutVyZBWf2KfPsuOkiy3rfu54U+cqxm9Pyiq32D+jLfUepIiU3C0LZZsaYA3OPmZjTsgm5yMltRsf2GKq7bJs90tpyk4o5XdunFDm7ZodQeBzKYwZ234Uz6Ddc+yd4OGbwrDrmzfKXPOz9H9CiZMt/yD1zjxFTtuUB23S4MHMMWyzkDM96bItfMPZHLBgRkLDlP2To3+eqeEYsBkRJj5Plb+lEN9Am58R7wSj7rmHCtxiwEmMEilZ8m9hGxJ7ENwIlBA+7/5JL/bxJcdsJP2Db7PNE/xWrYsRW+Ijr8hV7/gcc23NmleMlzLIjNluPuG0fsynbaGH5TjxnYLfZpM9n5gWFWZAVY7JgxivaZHrSuEB2zSNKkVGJmNgmGCx31RajakVOSSoWLLSD/Wz5DzHWcFNuklvN2fIzimqCFAHSBKjQZ1s8wCegZ4dciWP64gYpC7btJnNxTSFWbNhdHvjblMZwVs15Jb7gPfsxb+XYAaDQ/Kb6t0Renx/YP+QsdvGJ3y3/I6PoBgN7m6HdoW07LMScT8x/IVFDBsR8Yj7BFzEbZpeWGHBg9jgR54w5ISShxE3A2sZNIXx8zuQ5Co8CzYU8RFr3GRvaDSyGxCYs+PvRrv+tx+/PjrYlnnT5vGl5VVtqXJyhFYasuG6i8CyGKneK3PUJ1gpnbwr8ei+57uJ0gTYO2+ipqIlN0yYnr6a1CtI4q5II6hGprGP9vrcBpcVVXfDzOmR+2IQdFKXjRbti7n62sK7IrU9lTkEtXWhETb/K9Qzo1rtTRaZdR7jS1xjlBF9FLVZb5VfYQDcTA2MrjKocoN0UFGZBqr8/acX+BrmeUlZLllw6JKjooFRYc5fXVDKnvJ5lR/Xr4g40WhcujKFcOtGVWbAqr9mM3nWIuOyMwl8Set06IzhGyYBFdkLkD+rDS1RfW0fVKk3a7PShBqM01rICKVtNxisIsIayBi10o5vMiiM3iq6DOYR0/khboy7XqTiWisXqNfPwFve5w3GWEgqPzJZUQtP3Qm61Pb6ean47ShmJKUPb45NRSctTREqwEXq8XC6Zk1IZd0rdUR1mpeaPdzz+3UlBYSv6KqIwlm6geLXISG1BrhW3Apde9L/bC5gUgpPU8m6ry2/TU+7ILT5dnaGET0hEKNvcNY+QQvCCN9zI99kKIp6VF7wbbDMvXS7Udqw4W1VsRoov8jl/s8gY2h7LUvE69fh0lPNSPqdbvM+yktyKE8ZFRaEtKCgqy0Wm2QoD/l/j73gobtP1Pb4rrvDkFsPQY5Q78Vq8CrnKNJOi4gVvmIozPrQ/YWozfnk9o03MpTzCoIloc2Gek5ZXzNOXRMEOF/NPUDJh2tnnTTbgjXzBHredTzlbcihf8mP9AdpdPCprKKkYmRRRJWxFPrMs50Qec0M95ip+w0qPKcyCXM/IvCnf5We0w120KVhVE1rhLjv+I87Kb5DC4xtPcm1eUll3cL9ePiUJ99hovesO1HrW2PUshnawxzw/Joq7RLTZNzd4IXP61mUxz8ScsThhLkIqXJMw5ZyQNjMx53X1a/eZLeecSo9WsE2bLiNyloxpiQFz67rcG+YetwN3QD8y9/giKRiYLWZyQtv2WJChrMepfEVqt5jIc2K6rHDBAG0R8rzOGDZCN8+n7e8y0yd01C69+DbT1SHd6Cb75j4q+n6U/CZzz7Ud7rKp7tGxbvVwWWQ8EZ8xWn3LRvwOc3tMP75HQcpr8TXa5HTiA34o30eGHzRBFLlYoakYtO+gKUlZ8A1HhCJhqo8RStIzHf5p9Kd8mZ9yFj1r2MyL4tRZSoUHEezL90mFi4ec2Quu9Bt6YoeB3eDcOoV6Uc0xaLq2Q46m7wd0ohuMFjNCf4CxJdflK65x2NA9c5vMzijEgkC08QnQlMzsBQqP31ZP2DM3OZLPkdbnVJ6S2jEtz1kqN4OHVOQcc8LEugPHMHmXULSZmTNmnNGX+0S2XU82S74UX+KLGJ+QAJ+u2cFgyYTTKM3sBZXNmefHxP6ATe8BH8j7jM2IghULsSCkzcBuccsboKQgKn3cfK1sgE//0ENYW3/K/oFHEt2hG910o4/aVrMehbiw5laT02vs92H1vtfCGKdoXqdiVHpF5PWpbN4gE63VrqD9TgJQXk7pRjdZVSPS/NKphlVML7rp2Mo1ZMLZhFIiNeB69fx3irnjIy8L591NPNfhruESTeftbzrlnIwJRYeKrBFYGWtIy0sC5ShhmZ4RqS7GmuaEGKgWnogozIJYOoVwINso4ZMbB8X3RNAcSKTwnehCtllU53S9fQrrWLq/C92wmCbtyUVB6prZ7UbghV42kYvrmMg1ym2RndSQAiekyopr+vE9jC0pzJK2t+OM/DIklF0W1TkCSafmIxtTNjGTq+KKSqfoBp5icVhKReAPaYW7dP19Sps2rxdQ7+6S30lgcsVboPDq5Kit1gf0xC6bxn2YDuW3pHrEbflDcjLmYsS4eEXsDfkfkj/jTbrCFwptDV0vIPYkH20I/rdzh95LTcVHg5jfXC+IhMcHg4i0siSe4OtxRqf28u7FAYNQcKtl+eWpxpeCXig5XORshgGLUnOu53xr/ppEbfK/b/0cJWBZRwVuhILXc02oBMNIUhq4XGkGoWQnFryaG7qBZFVZBqEbtZ+kzkJ1px3SDQRpfVD2hBsbvynmDGSMRCAEtDzFVZ6zHYW0PEnsCR50LMtK8MlIc1gHRwRCccQ5iW2Ti5yB7dJRAf92/n9jp/UDTha/QetFs5dfXwelOnTjO+z4bnd609wiJefA63FUTbkd9NmOVU3ucqSu9e+/qgyBEggEb7IFx/INR+mv2Ul+wKR8w3z1BiWj5n3swkDazWcAYFVcEnhdd4DL3hIHm2z6D+jZIalYUJJzw9ziTLrowm2zw3PxJTftI2ICRuIahU9sIyo0R+Lp935e+ZLcOqThRfWMTe8BXu2NT2ybK3HM0fxXbLbeZ188IhNLDJq5vXR2nOIJd/yfccAOn/NbDCWBaDMuXnHf/yNiG5EQUqJZiCXKengoLuQJm2aPLjGXYsIeLsf8a/EVt8w7eEguxRUDu0FOwWs+Y1s84BZ7TGxKLnISm/DU/qr+rBl+Iv+Mvh/wtpjytf4l1moir890dUgSbvMT+Rd8K75koS/wZcx7/JybUYusskgBnhRc5TlP5Ves9JhAtnlgH9MSAUtb8JTfEIiEeXXWxNG2w10APlZ/wXfiGRFtDrNfcT/8Y34U3eS32SGHxa9ZFSM2Wu+ghM8uD7ngFT2xy3n1hHH6nN3OT/ip/DmZ0Xxq/4rp6pC8uEDIAE+1ifwBeTmln9xt2PJ9M6BNxJm4ZGg3mIg5JXnzml3KI7p2iw3bY06KFppcrBqhYd92uBRX7NptxmLGDgPecNr891SM6NkhMzFm19zgSL6ka7dIxYwDc5MCzZF8zh3zkJySXOQshEOzPuYDXtpjEttG1qSyXKy41ofsyw/o2g4DGfMtL8lY8Or6f/oHa+vv3QkHXqfBQfrSFdbK5gR+p9n7OnaQ8+2uOzljymbXud5veur75CNbe4LXO05rNRUFRTl3ykI9a8RglVmRV1MWhRMkBapNYVxhWH+43fePGrzj2ke8Driv6kOCIqwL1pxczxpkZaqv8GTS8JPXlqi10Gh9QlfCp9IrAq/jiq2eYjDkds6yuCAVVyT+Zp2cdF0fRpxIKlCt5vut/cfgWNWedKpmY8rGQiWFRxT0yKopQijn7/WDhie9Tp1a1dch9jZQMiArxmiTNTnNSvgsChdIseSSVXHlLF6BE3ZYDJlxandPxXW26vdiMakStJ4D0imjhUQKj6y8diHftSWr0hmVWSFlVO/mZb0TrqtO7aUUSCbZa/w4ZiQlF/oZgXUCtpVIeZP/mlB1XDi43Od1mvKjQZurzDAvNUoKEk/w2bWh5bk84L4K2IosC1ZsegPGudtE+xJutUP+dnGKsgqd9jhcGiqTcK/rcb4y/HTDcLKUPMkuGYoum7LNa9HjF97HHKcFiVLsJB4vZhlPFwWR8Im04nCVN77hR/2Yv73MSJTHdV4xCD1ezrRTZWvLlZ3TyX0KIymNZT+RHC1dwbaF4W4n5HRZMdclurSUaGaF5jBbcBC0GWWCizzjjTgiEDFjcYmmYtvs81Y8oyO2wHY5MiOEkLyd/hJrS0J/h6K8+v4oJHyMTpmmz+n1XGi7xSIRPNPHCKF4VubMyjoJyvO4yDI2w5Dj1Yq7rYRv6t31khUFKZ3wBkfzX6F1CvV0RcmIsrwGIQnoNeuUVrTbePbh+65lZae1l1Nh0OSUzOwZA3GThVgy5ICZnGCMWxPEYoBhyFJMSBgw4ZxcrBiVL2h7OyzsiF3vPd6Td7DWCfSkEIQmZNVynfux/BosDORNAEdKyi95Iz6l8h8T0mZpRiBgL3jMggnKDpmJKRJJJSrmXDJgj4KUK3mKNPvMxTWxiSgokUJxJS9YMiYgYVr/u4geU3vOhU24lG8JSFiIKWW5ouVtsawu+avyf6THLS6WX+KrFv34NpHoQexU2y/Fczc6FyHL4oI30QtW2QEvzN8y8O4Q6JiVnHEy/w1CSNrRPk/k3zaq7y3uovAplOM7LPMztK3o+QeMzIyZOeGsvldMxSWjfJcfhrdo2y7n4Rsi2kzsMVe84V37EaXVHFZTtF6i8LnWK3a8Fg+qn5AnHzJtjTBoptVbFvkZB+2fM64OQYKm5FQeMjT75GLFDHcYA8gp8PGJ6aIpOZcXXJmXbncLeDh7WlHnnH9be52vxRkbdpdLMaZvuwxtj2vmPOAeC9wk5ZwXbNpbvJbPm4OjRDAQLaZWkAqJR8iXfE0suqS4ujO0Q5Y2IpFdEpuQU3BmCiacNLXpH3r83kVY1crndeH43VhDV+AkeTklCgbNHhfcWGJdECud1cEMBb4fs8hOkIHXjFgdAnHlOlO5QokAJTyWdeCArxI84sYzvC4Ojj9tamCGCz2wxlmfIq9P5PWdAMKktfUppOPtkpmpY2FLF2eWVRNC1UUK6ehVdT4p0Nh2tMmbfOG1rzY3s4YXDY4uJoWPFC44QcmQyOuTVzO6wQGGEokLmFhzn7V1z8uJrDyQbgVgTEUcbjTBE2sYANDYroRQKM+lO7nUJEno9//e9XOhD5mDxBdXzWlX24p1qtI6ltFTMW1vBxFJQtVlnD7H2gopE5TquL+LAK0X5OU1nmrTkzeY2LcNX1zWPkx32DAgQrAaIcLasuRG3FEwIKHHUfEJ1hru+D9GInlR/S2R1+eGfMxcjBxRB8nJUvO0PCexCVMxpl10uRv02UsUl5nhbkfyyZXGQ3Fephy0ugQKMg3L0tK1bYZezHN9wl21x5tFRaor2p7H25VLQNqwW3yZnXNLbDboVF9ItmLFqrI86EZcrnxavuQ6r9gOEofNNCGzEiKl6AaStu9hWcNBNPe6Hscjn34gMRZ2YkmuoTCW3UByM+ixHcGTaY7B0vN8IGAQeuypLrm2eFJwIw7Ztfd5vpo1cXQGywYHZCywWBKb1B77OhREOFuQ2+tbrC0I/V3y8pxFdUbXu8G5vOAdcZN90UVbS2oqDpIQJd1rd6sVk1aGnO93XVLAP+nvcLQcMjEFfx1ck+YV1jqvfi++zbUtSIItVsWITnxAV95E1pY7gFvyB5zxEg/3uV53rmvxzy5utxjakFxkLBjRpe/2mqJNZitiG/NWPCUWPe7ZOwzVNsfiJVvmJhfikGfaJf9MxBl9u8sWAwbyJtf2kKyOSLzt/REVB/xd8T83TosL+YyO2nU+YbtwSWR2Rixa+IQkNqG0JaXMiUxCRc6+vc9YjuibLTZlm8oaJlyya3aZiTahdffGDjHfcMkmt9x9o8Y0tog55ynz8sRhbsNtKpux3X6MwicRfYZmm4h3OBWnTO0Zk+y1a2qs4VI85U3+v2FsxUS+JvR65OWYW90/IbNThtzmmiOW1SXb3gMe+7fItKGrO6Reyhv5BbEa0GLAruyj7UdcRW+Ylm8ZF6/4LmhjCsN78gHbfEBqSpbSQUh6KqS0hlawzXJ1yMqMyUVB7HW4LXsYwJcuW/vY3Oe3wb9naUYuBEheEIiETW65NQSVs0LR4rV85oRx1quv/xYjc8hQ3iGyLQa2y1v5xlHH7CYhkWP9mxGR6CKsJJNTlHX3xQ06CGAqJuRiRZ99OqbHFW+4Yz/gW/PXPFUpH9ifOuW/PiSSPW7ah1zIE1q479OTEWec0LY98vqwsC16jMUulzVj/B96/N5FuNlzmorSOiXxOhf4e+5xBkX94axZ0NoUVPUe0feSZmealld1CHzmvhZH1yqbbmrVFBtPrn+G8xwrFRB7G45wI0OE7wReuXZioqwY1elDEYVZNklPca2urvSKVI4a8Ze2Tvzkewm5nrGq3O+51Esif4NQdWtRlGZVOkBIblx+rlAKbUuXIyxbrMrrRnAW+24UtU5tsspZpDwZkhsX7rAez69Rl2vFdSBbLPIzSr1ktnrbvJ5A4+0NVJui7ibWWc2eTHDRcesx4PeximuPsKeiZpwVeB0M7hDj9tsuvCI3MxeiHpgaTRk1I02BQNeWF2yJNikLe9GM2Uu9qOPvTHMN1ylM1ub4nmP5ftD+16RihkBy1/8F+2yirWE7CpHZLziVr7gjtvnUnnC2+AzV9vmr+RcMontIoVjoC96Vf8Sy0vx2sqQjQx7KkOuy4FHSJ/YElYUXk4IrndIiIKfkrKo4EDscmRG35Cb7SUhlLJ+PHGP5g17MrWKTC73kXfELFpUrOoX2mBWa69zZjSa5ZqkrPuzEjHPDrKwYRgGzquBWu8VvJ1Puxx26geTjIbxJnSc0rfOBF6XlOC3xhWSSWwpt+PLaRRGeVgs8KRiXK7rGITm/uHb4yqlNUSiO5HOMreiILaSVvCMP+Mxe0pIBX/MNG+F9ZulzPNUhLy5q3rdLwKr0lLw8Q6kuo/kXRP0BD3nE3BSMxawpFKcrl0o1DH1O0oJIKRIRcJzm7HltXlSXVItNnusTcrmi5e/UYsIVeXnJdfodVTVlYTKE8Bh690jtmJ7Y5cw+IZBt3pgvXJqY10bW+NfQutjTlViRiQU9M+RCnjDRb52fN0iR+IwYMLaHbKkHdNlmYIZESjHTkoQe1/KMlR4zNUdEqk+hF5xkv+F2+4/ZMQf4MuRaHmHRfCe+Zd/cJfG3uCq+oRvcIqsmrMpr+uEdB+ixKyLRpaRgbE9ZmAvekb8gtDGHfIm1moFoUZkKLTSf8wWRaNOzQ0bimsPqt/T8A2blCV4N49Fqj0wuSZmykjMw+2z6D5jqYycCVQMCkRDTZcmYi+oZCzXinv2QkhyFzyC6h6FkyG0u7Ss6wR6T1SG+lzj8ry3J7YK79ge84DPXaIiAM/OUrWKTQHg8F582e/ib5iHf8XcMGBIS1s/VsBM6eMko+44L9bTGPv4cbUtC0eaFOWHEEaPlt1gqRosnbPceou0GZ0XKioKpvOahuM1+FCOzf84z+TUrGXAg3mMmxqTMMMJQkrESK3IcTUyLNhNOSBhwzRFb4i6hjUjFAs/2kThXxgv5xGF7aRPKNgPjDnMTc4KSPgUrts0+S1ImwmkGbpgd3sjXaFOiUCgZss0DlJC8Fc/wbMhCX/BalY6HLUoMutYlKYSVXMhDN5EwnmOP//+Aov7/LsJS+ijC2p/bwZMhVQ3RCP0eWruu5vtgetftOP9wTFHNHRlHegR+p1EBKhk2tpk1YWv9WI9j14XZUa6CphNe76bXCu28Zj0rGSExTecokYR+D08mhKpHKNrOrO+1sKUh9vrNXnm9k63qLr/lbbnCKQJXHL2O27/WO2JTP7/E3ySWg6YgejJE27JOZ3Kd7/rDoK1E25K22iYzU3w/Ji3dgSBUbudrMXVYRdmkTgGN+nwtplr7oBM1pLQrd/rTl82O2EpTs7Ldh7Gqk5lC0SEKNghky+1oRUBO3tgc1nt+p45OqLS7ia6tXwDWrBAorCm4Tp8TeG507MmEyqQo5UK+C5PXXuHSbYSlS4P6QbjPVnTA19MVwyDgZT6hJxImRcWe6rIvPiLxJHezRwTthMR26Ed3kCjOlp+x1/4xL/RvwHzsVgGmJNMhwyDgaTohIuCFfMqOuc1CzshNm7kcE9qYBXN+HN1kL5H87WjBhhcx1Tk344SW76IVj2clmUiJrc+GH7LShmnl0nUANmOFTi2ZtmgLP9gIyDT865sxb1LoiJCLrOBGEvJs7uAgb+Ub2sUDEs+nFwgSpbguCzalohcofCl4tUzpiYh3e4rxZcSsrHg+taxsSU5JRMBITPiIH3Bmp8zFhJ4dcq1XbIhdLuwMT4YktotAIGVA4N0grYNFWtEes+WiOaxF4S5X6ROuknss5JSb5iYGpyTv+h5SuE3+xKaElU8sfPqBz6oyvBduo4TgB94Bb7MlSBjr50jpEYd7tMM95tkxnorZiT4ktwu2uIu2JR1vl2V14UJV8iu22+9yUX3L9fIZy+QeaX7RHOi224/Rxnl3r8VbtrjLifmGULVJ1JBL/ZzK5Lwup1g0cbDJLfFjELApfsyn+f8D4ztwRlFeclE8QQUeA7PFBRk9eYOxPuRrc+jIc7UPdyO8z8qMaYuhI3HZY3wRkzJt4knH3iUn2ae0gz08ETG2Sy7lW3wiEnpc6udcWU2g2vT8AzxC7no/44JXjFbfskqWhDamx5YbC4sMhUcg29y0j2jbCGkFQgi+4oxIdYlFjzPhBEi37COmYsyYExLb5qfyjzgzEx5GPybEc9GYSuCjiJSi0o+5Fues7ISut81X+q/xROhSsbwNVtWEa3lJi01C4zESCzp2g37wJ8Qm4q14xmb0LlvmJlpoxozZ5R4rUnKxIsZNZ0J/l2HrIb4N+ba44Ovs3xIHm0zmz1n2/pgH2ftEwmPb3Mb6hrG4qIFIhn37kKmETCzQVHTYYt/cQHDAFSM6OI/uFcdsmZuMhGvAVswISNi397kSp0yqt3heyNKMSOSArulzIkdEBBhrucYghWQkJhSkdOUuxli2xQOWYgJ2yH3zHhWGM+8YTUnPbjHlkj1zi2PxHW2GdEj4rjyi5x84XYYZYoMf/vctwi4L1xWmVeE64PV/F+Wc0O+5zss6z62UTsGrlFPIlnrZYM+k8JrCKmqJ+ZqcVeolusyavXIn2nfdt16S1fnDWXGN8Rzv2KmoZ38vaWk92rbWsMhOXLdnKqzvfMtjnREFg9piVbIozpudZmlWzeEAINNjVuW4wUaun/OyuMAEprFmrJDk0ll+8nLS2LlUTQdLi1FzczA1w3qiDxsZ+3r3WulVM0ouqjmVcSKxopo3+c1NZnMdqGFs1ezO155gaw3Gd3artTBtlV8Rh5tUesW1foEQksyUTczh+sAyz4+J/A13sKnZ31J4VKYAIaE5KMka3KGpdNpcZ7dDL1AioNQLpAydQKuaIGRUW9QUL7MZ2nY45owftO5S6B6Z0Uicr/Z5NmHPdtnyEp7pK5Zc8QN+zgVj8mRO3+5gpeEtT5vrdDx6h1l10pzQ75tHfCecIOWm/IjUTjivntLxdjlcbfC3+RmVLLkTPGKpPXqB5IvrgtvtgIFos7A+r+UrNnjE0+yKXdlnrktUrfwOlOQqc6/HF9cFvpD8+jqlpEKhuB21+XJ5zTvRgFXlBFpjs6JaGr5bVPzpdptvJgGnacm5ntMlZjeKeJst+Xbq01JeI/AaejHP9DUjsaJjBnwuvqAjhszsBe95d3ihz/FQhATsmhssxJJu6x1my+8osO561RMnIQMEEPqDWjV/zHflX7EXPOatfEtk2+wy5CLPSMnpiYQ2EbHyWOmKizzjbivh8+UVN1SfuXYjME1FL77N1eJLvJrg1ijzzQXL4oKJOOQg/DFb9ibCk6R6RBC3yFiQ6zmRP2TP/wDlOU9oKXJumpu8kM94sfjPhH6PMryJEi5UZWEuGKcvmizxxN8ikQN847NjN7gUE0K/R5qf04lv0Yp2sdY0HeVo8S20HL8+8TdZ6iV70Udcls+YVSf0/VsUrLjMn6J1gRdHTglezZuv24k+xGLYM7cpKLnOX1BUc260fsq2esjEntAX+5xXT3hX/iEFJUr63Ev+lHfFLc7NnIkcU1ExsSfk1ZSed5MT8cJRqKpj9tQH3LAPuZbnLO0VAoUvYi7kCW3bRwmfS3HEgi5vy99wO/hZg3w8l4f4RGzoHV7ZT5DGTbxC2lQyxxcxmZg1gtSMBakZ81R82jQtxhq6cpc75j3ahGSUzFiwEEuMNcQ2oWc7fCs+B2sIgx5dscuYE1I9Iiuu6kS2gmV1wSf2xAlFqzmD+B4JfaxwTcNcjF0jYp16ORUzLoVrVIwwYKHE6XtK4RCaBSvG+SvawQ73xX027AOOVZ8lE0LZpmu3GMtLZuUJ33kuO32fR+zZDU655sA8YClSruQZHTPg3DzjC3nFUNxGIunaQfP7GVuSir7T69gWBst76k/xjYeH5FfZ//j7ltZ/RCcsPIKgwzI7a7y6uZ5jraEX3aEyKYv8jCR2N3mtC5Jg2NCsIn/g7DLVjEpnTUdpjCsYot5ltqJdjCkbhbW2Fe1w14EoavJUZXIC1WoUleBwmM6aNGjAF5VZEQdDAtWulaFgpcEDlHD5kkqG9W7V7ZN9GbMqrymrJUmw+X2IQ+0tXovL4mATiXRjZExjMZLCJw42WRVXdMIbLllJXhLKLpke48mETLss43UnHckumZkxy966iYCMKWqvZKA6DQIz8jdcVnM1cbnAZkXsDWseb0nk9Sn0sqF+xWpAZTM2o3eZVSeNgn3dnX9vmvcJlFNRrxOjAtUi1/M6CMPBT6RKMDqtOygFGKzF+X9tQeC5/baUPqVeUlQTwLi0JZPV7yRDZQvelX9CiBMrve/dZJw7Jed25DPONaO85J9uDQkkfDXW/Mz+IZnRdJTPlreDzAUzMWZavOUj758xVteg3A07k1Pm2QnfxZ83Puw74sec8hwlfDreLp4I+dr+ii57XJbP+MK4vOpbOmQ78nk6Tfmt+U/clz+nZfvEnuTjaJthKHizMNxoSTINXd+N20d5xbVesec7WMsPOgOuM03Xl/xBNKQfwLKCD1fvcMwE3ypuxgnnK0vLE9xIArJpwrvdmK+mC3aDlhNrWTAWhLBcVikPvRvMdUlKgcInFTOG9gBtLXfkNitdcZBEXGQlp7x1K6L64QArLt/ZU212Wz/kdPEJZTVGypBZ+oqWv8U2D7gnd8iM5mGvhaDF0bKk6wdIAW0/4DrXFMbyMNrAE4LbYYtRZrhh3+Ol2WPmvSUKNmipLe6Jj3la/RJtch6Gf04qZvTMBiN5TosBpVyR66mzddSTs4EZsiFr8A2C5/JtE3zgKZeYU5mU29zGF/e4aH/ori/uM3q8+Duq1g8I7EO+K/6SbnDghJSqRSwH9OwWl7xCoghqnOuqGLEbPiYVV4yql0SqTyASFtWZS1TTBb6XcL36zgkaVctZirxdZ68xC1qyz5gTdsIPGKmXvM8jzsyEUg4ZmUP21Ad8Wfx/OAh/TGlTuvY+x0zQomJghmRiRSa6aFlymT+lqObcbP0BidokFTMUPgqP2/YxPZHwlhNCG9fUppusREpoY+4Ff0TXdpAIZmJBiwGhjfHx2VT32DTbGGE55ZDHfIyyghdem8i2Gdo+M7Mkku4Q5dsABESizYbZYiomrGzEruwT2wFt0yKnpKIio2DAPpPgNZHX5zj/lFUxcj7jOtmuSbsrpy5XwFROMKsMHbtBr97bekhWFLSJeCvyRkF+Jt7SYUjPDAlFzIbt4aM4AWbKxcOeygs+8A/YUvt8u4pJxYLYuvSknn9Axw7xRUjfdmj7HnN9TVaTHe/bO1wxJ5I9FvqC1JuxYXbRQnMhLglFmz1zm7YIiYw75JzIIySStu3RtW1uJD/hxfTf//ctwusxqwtpnzedgCNSzerEo+9DC4Cmg6x01ux41yrptTpWkzeFzFqDJwJWZll3X76LRPO+35sWetF8j/W/k8Jz421ZNapqbZyP1rGLdaNGjlSfHLePlUiSYBOBckVefh/KsB6LS3wKM8ZgHDnXGpaF23/6Xsvtemvuqttvu30yOOrKrDohK8aI0O1xcz0nrq1S4JJU1tGIUnoE9ZtoXfAtGm1cB72eRqxJZAJJYRbNRELX1yYIW0grmx35RL9pwhvWD1fo58RqiCdDVtWk2d+uRXfGlI0P28Wv5Y6CVXfEAg9rS4xZIRAOt+n16h17iivSZYOptGh6yT1uej+iZZ1H+YW+YGh7bMUJbV8yKwxLXTISU/7rZYdE+hhrkUJQ2ApfBhy0FKN8gDIeA+/PeNTqcrj06fvuPfnSDJgmIz4U7zBXBYnwERK62ik3L+Qpj+UDlCc4K5Zsqj1O5Ssshk8XkvfjIU/EF/wT/59TWkOiFOO8Yl4KnsxX+CiWVcB27HGc5nR8n1BKNlVCqCQdHfLlfMrjTo9ZaRClYJyDAFq+5I87W1Q1wWtVWUoDk8LgC8lVpomEx0mxQBt3wr6sUh61umxUMX9Z/kd66gYfyIfE+h0WZBgsM50jEMxYkqcVS1b8LHyPX6E5LMfOJmYrLBXWLKkwHM3+GlsfjtxUJWKWH5N5M7r2T/GQvFlIZjrnIGpxnhX0fZ9xXnKtV4R4lGh8FJaIN9mCS3lJIVf04tvMsrec5ldMwyPmq0M2Wo+44BWz/Ihrr888PW5gPdrkZNWUxeo1SrX4Fa95p/sv2DX7dGTIlXnZQHDycsqx/pRVfsm48xMO5JBbbCK05NB+5g7hJnXdaJC6936g8VWLrJqw0Gdc8oR2uEtX7uJ7CXvBY86EYmWndIMDZsURXW+/odn5MkbLgsjrc8f/GW+qTwlUq7EjAuzKR0w5dyple4UnQr7jFUYajtK/Yy/5IWN7grEVx8VnjsffieiILab2DCsMFk2lXZLZfvgRd4LbWGP5SvyWs8VnxMGQ2BtSypxzDDFdJIKu7XEhTwBo2y5jeYlEUpLTtT1ysSIVMxKbkDKlZINcuH3ytLZGze0lM87Q4jYzcYlHyLY5YCFmZHZKLLqcyFdoSmLRJTQhF/KEbbvPQsyIbMJzfstQ3GEjvE9u5w4aIl+x67/PihnL6sLZXIWP7yWsE5b25CNS5kzFJblY4dsQLdx99K11HO1ru4Wq0Za+CCmEYmYvCEWEbwNysaKyBYnaYMwpX5aGH8pbTOU1U3tGJLuEJEzLI1r+gJQZL6tfsS0fsWn2uJBHSBSnXDOX13iEtNU2Ch8tNCU5pcgJSZAITrkgIEKLCk2JR1LLg11Q4u9G2f63Hr93EV4Hwq+9ukqGzoZShzAk/ham9n4C5GbaFMom3kv4+J5yQI+1yAhJK9hhUZw6YpRQDTlqnZS07pbXgQtKBiRqyFQva0tSQK7nDckLDUa4Ypjp6+Y5eCom0xMi1XfCBCIW+qIZQUv8WgjRZbx6WSuK6+AI2SaSXVI9ohVsO0EUkqyaNHvZvJzWXaYbifsicYrtMGRVXRN5fWfYV9tkckokHCh+HY3o18IqrSsC1SLxhoxXL2uxk1N6B7Ld5DcHqkVl3RjQpTG5ayFQf89vHMqQQLaafOR1N1BGqxrxFzXXOZBtd+CRCYVeom3RqKGF8hqLUhxsk+VngMGNpb3m8LF+nyADsIZKT1GqgxDt5o3ZVSEdX5FnFR0VIIXjI99qe6RawRyUkNzthHR9+JurBbfiFr4UXGWWzTDgvWiLV/MSJeFRL+HT6ZT3213uMeS0jOjGijSTzE3OXpjQ8mIqY9mxD1BSMCtLLuQ5HdOnb3dZignX8py/yUcM2KPtK77KL6GCnyR7COCkcvGJHT8mqyxzm+NVkp3YpxtIhABf+pC54e/ttuK7aYUSgntdxfnKMistt9uCiwwiJdAW7nYEmfbYjFyqk84ttzsen44XXMhT0jTlQA6J1YA9c5NP5Wcc8IBdr0OmNR3f53npDjSBVGyImON8yQa7nPkDV4SFBAtSttx1EM63j3WHJd/bZJkdE7QfkYqU22qTSEkSlTAuyiYEQ1vLVo1eva4y9uKIVWXoq4jI7BMKxYgDvvQmLPNzKrOiHd3EYEj1yPn/gwM+iP8lT7L/QFHNeafzT2mZLlmYkoklM3PKvrnBwIvwhOCPxJ8xJee5/MZ17/mMXusBCzFlolu8kk+ZGwdYSYsrktBNZZblOVEwwCNqULKtYJu+usll+Ywr85yD4McA3PR+xE32uLRTNoNbtE2Hd9R7BEKR2Yrj6IiFHXGsv+TA+wiJ5K35HKNLNrx7SOuai1l14rCWKmFhR3TFNoP4HtPqrcO7qhZKeAReD4PmVfpXbofubxDLARfpV2id8n73T9gIAk6KJXftY1bRGE84xOfSXrHLQzRO/JMQktgObevC7t+x9zjlmsgm9EVCva2jRcA75j1O5BkPuEluB6QU7MkuGGcR6the4zmPCRiLnNvmMbENGHi3eKaPWIoJJ/IVATGZWNGzA0I8hvIOe2aPY6npiC3eETd57W1hrWZot5l4Djdq0BhlSGwXD0VkY3btFtc4CMiBHPLaXBDbGLW+ZxAzYcmH/JipSZEIjNRs2wElmtS22Pcf0zF9zuQrXq7+igu7S0tussN9SpujRcUj9ScYY8hFTt93ynSJaA4cBsPMnHKLHyCRSCupqJAiomt6tInIqejZPjMxZ8duOB65KdE1X3+hL/BU8nvV1n+EMMtzKUc1QWk9/l3fdJfm3L0Z/E03mvXd6DrwHAWqLOsdcGMtcrsAX7XI9KRJU3EErbzplpUKGryitkX9dRWh6jYQC+G5UWqu5006kzEFFXyv0JXr4uCTlpck/hbj8lVzCi+rZdNdejKsVcMupKKyBUW5xPq6TjpyBaoyK0LVoaz/rMyKZXHhvkbGrMx1TcaaNSOX9RuqMjkLLlhV1+738XuNityrUZRGVk3M2/rfrNXTQsgm5xgcuat5nWobli9jpPDJ9cxNKaq542xXc1LvykFT/I3Gp1xUc5TvSGaL4tRZraTf+JxdTut6r3jNOtJQIMBWVGbVTBwAjCkI/T7GFvj1KGqZnXGRxLwvb3KZuwOEEoJYwRfTOQuxZE9sECuP0hgEcFXjJi+zgis7Z1N02I4Czlaal+act3Pf7WxIEAIGoeKydD5chWBJxm/LYz6Q9zmr5igU9+MOy0rwI/8eLU/yJs14w4ofevcIlOCL7IztWDLMekTSeX77gWIgWuxEAdtxHRghAh71A05SzV6iOE01hbb0A4/n8xXbZeiehxIUBr5bzimpmJc9+oHk+TKn6/tMC8WidP/2mT5m17oDxoIVj+UDRtWKZ/aQm+YhGyoG/S5bXsJR5UaZXjV0geNKMgw9Pl1ecCEP2bI3eRD9E16riFn6AiFcLrTzcccI4bkc6/KavLwGYL46Im8/ZlLl6MqQU7ItO2RGOzGLXbIvu81rOcpLAuk+14n0mOuCsXSo1rJKWRUjfJXQDQ7I9Jit1geEos2FPeRe9Md0bY+2iWh7PkeV5J64QcY93spjTLXDipy5nNCq6XWB16mdFSuuxHNm6oxx+pKt+H1yO6cb3mBRnDsrpNcikC1G2XdI6SZmgWy7UAN/H4+QvhnQETFf8YmbjtHGEmCwrCjJbcVCLHlf3OeN7ZGrjJ4d4CEZyj9nTkppXaSkwueGesyZfooSITviPilzZ0NS0LE9jqQbm2/USvEoGDDwbuMTcpj+tZtE2YrX4gmvS2jLIRN7TKwGfMRP+dz+HUNuu+AKsaRl+1yKMW+qT9nyH1KQclj+htjrU5gFJ6pHYRcEss0O95mLazbNHofigok4oyLnjQ1Z2TFK+BybBZ5M6IpdrjliUV0wkSeEss1+dZ9MLsntAk+EjM0VKzlj195lKsZMrdNYLO0IgGPTZikn5HZBJV3HuGLGSo/ZULeJbcxUXjMWFyS2S88OmDLmVE9J5awu0AlWGCYsOZOvuMQHAS3bZ2bPOBQ+KzFzz4mQmbhA4dMKtt3qUHZdh20XtBnykk/oyj22zT6+vUmLmJIKg2EuRiT0UPic8Iw9HmCs5FQ8pyd2GYsLBna76XYrUTFiysB0Oan54ftml335AZk3+b1q6+9dhIGmACNc55XWBm5b22zWYigpvIYbDQ7isc79XZVjhJD1LrNqwggif9DYhExZNqNv93OdShqbNrvbdYfqe0kjxCorZylS9fP4XT61p2IC2Wr+XWXSuoiXNdwibBCRhV7UamBFINtoUeKpoKFp6Vp63ux19Yx5dsJm/C5SeCz1JavS7bCVcB7c2BuihM9Kj8mt854Gsk2lcqw0Tae7hoooFSKFpBXuNPQvi6Hlb6FtSVpeIawLz1jvqTvhjabDX1O/3Dg7b4Rxse/CFgLVYq5PmkOBVxdtlzzVc7Qx6ShWuXD7MqxByhBrK0w9Qm8e9cFDCY+KVSPgcjd22XCw+8ld3uGndAPFu32Pz0eKQahYlJYbYYtCJ2RG1zaTnFkR0A0kpdX8yXaLbyY+Z8WSaaEQAt7395hXFZFUjKoV1sKbZV6PjDWekOyKHplNaXmKsPI5iFpc5xW+kBznS2QuiIXPwAwZFTldL+DPe/uMc4MSkpZXj+StGykvSsNpltNRPoWt+M31AokgkDEtT5JWFdPcfaznpaYwhtiTDAJQSFoiIZCCUabpeB47seJwodmMPG60JP70AAMctBSdbMhZ5mAggT5gSsq5nlOKgkXlMxQdLhhTWsMFYzZ1nyEefdosGTAWF8z1WY0p7bpDbzlqMng9mVDqGVGNlyyrCXEw5Kj6nC31FxgsI3lOYkJ2ghglQRZtdmOPTtVnlJco4QRnW5HPrNAcBDGr1ZA2Xb6WpwzC+7TUFgGJ29vblAH7HOtDropvaYXb7MpH3NC7vBVf0zYfM8Md2i/kOcfFZ40wUcmAXnSHtLx0RDfVZrx6WX9eJT4J29zlmT1uaH1CSXbiD+nbHdq2hbYaLBywhyckvpJ0fY972Yd0RMiUjBJYiBkhESvh3uupqTiQQ76zb+kRobFktqRPG2MtY3HCB/YHpLagK37OsXzpQgPwqUTFefUEbSti0eem/YC34msWxTk/9v8lEzujEI4yuJf8iNSMMWgW1Tnn+RfcaP+UA3OPjJKKjKk4Z5NbzLikFBktBuz7j3mT/5rE3yTxhnVi3TYDu0+qZuQsMNawtFf4MuSG2a+pTzPOy6f4MmZXPGTuXXNVPkfLIR2xxUqMm5XZiXzBvDqj4+0ysPu0ecgFJ+zKHrltExKR2wwrBmyYHXxclGRORWx9LsWYhC6huE9lXOHbMFt0RYQSgu/EKwAyJKkdExKT0KZtW/hCEZtHjMWYubh2Vir7AaENyOk6gZYtMRhCG7FSQ3bNDtZYlnVk5a7o8USa2gJnmcoRJ3ZUB5uc0WKAxfDA/ohj+ZrSFiBgm7v4xrEfBrZLSk5Cj4XNuJKnTVHumAEzUu7JHU7qCek/9PhHCbOQ3yf/rIVOQFOA14rnZX6Kr9o18nBUd5gK6fvNTnOiXzakp9DvN0KqqnDdoLVOLR0HmxTG8aKVjKh0WtO16vxRGbPIz9zfvQRPhqTFVWO/MKaq/ck5udWN13lVn5KLcs7SXLhs03KO75na87zCUxEW3eQhT4rDWjkd1EjJmpJVTp3qunBvIE/GTQgEwDI7QweDRpCWVqNaSf79mFmbnHl27CYH9ag/rEVZxlTk5YR2uNfgOiu9qsfOLSar13gyasRskb/R0IjWxdta47jbvrMjeSLC9xIC1f77+2ArEUKxLC5YiesaktKirAVZWEPob5IVpwjU7/ChHVYzLUZI6aFEgLYLlEwcNalaNM/jXB3RTSMEIZU1XGQlpTF49XPw6z/7KiKtDIerJUsyTlcJkRJU9WztVtvnYqV50A15sygJhMfZqmRk58SE7AcRh6sl20GCKn0sLvB8VRki5YAZGyqmGygusoId1cFgiT3JcapZVZphENAPJM/mKTfimLbnUpxuxCGL0mCw3IlbTIqKZWXRxnBeLdlWLbRVTTcv69jCEk1HBlgsc12SSI9FadAWpBD8+mrFd+IZA7vNq7HH/WCDUCi0tSxsjkJxK+hwXRa0PI9DfUVOhraGh8E2bd919VtBxFnpsWn3eey9xxf2awp/Tlm590U3vkWaX9SF6/sOUyBZZMdI4fFl66+a4ukheVZeMLBdXstX6MUDt18XV9xhj0Nzhc02OddzVlVW+yjdZyPNz8kiF4+5Eb+DNjlv7adMF0/pJPeJ5YDXxa+YBneZF6c8DT6lNCmr/JrF6i1RsNkcxJUMuU6fUWnHOe+Kn1OFOb5MGOeviLw+Z/IZt6KfOR40AxLbZswFACUVb8VTbtv3eCVfs232mZoxYR5xLc9o2T4RCSUFWlTkNqNvBozliNfiEGV9fBvyhlMS26ZPi5byyYxm29zmQoyJiLmUZ2zY/aZbXTCisgWBbOERcSmPKKqF2w/LNyg8QutsXCEJKW461fK2MKaka7dYkTGXY9psk1t38IvpovDZN7t8Iz5ByZCPxZ84YluV8Vq84JojBNJZgYQhEG1SppxIyYoZc+14BAP/Nm3T4sNwl09ti8P817SDHZdQJ3wwKR/xBzz13BoxEwsysWBqjvlre8h74g+5lmcUNnUTOyVp2z5XYsbCjrhhHzIRZ5R2xYY44FR/jRQ++/IDSltyLg4pbd042JKevIHBcCVOeFG9pefdZGEviMWAWXUCHlzxBotu/NFb4i5jTrAYIrqcSsPADDmXh7QY8NIuSOhyzRGlzMlZ1NOCVyzNFQN5k4Fxr3VpVyyEy6GemBfsiPucm2dcild05S4ePi3TZdvsuzWjbSERvJEveGu+ZrR88nvV1t+bHT3sftzE/q0VvLmeE6pOHVF27YD/ysWatcLdRv28xlGu4R3rRye8gbZuxFpUc1dU6vSlSme0wu0mUtCYsskV1qagF90kq3GTUnhEqktl1pF+I+fJ/Z3vo23ZMJ/T8pLQ6xLLAdPyLUqGTQHrh3cozKLxy3oybN6EvkxYlGeEqksg22TafVAiNWBWHNEOdghEm5UZsyrdKLor97gonuDLuLE9KeE77Bwwqd42/9uqvG6ETdrkbocsJJP0FaHfq5Oaus53XCMoI69HadwJOlFDltVlQyJaTwF8mbCqwyfW/mVH1lJNapPzFbfRtmyU4MaWzLOTBqqyKk5RMkGbFBdRWLJeNgnh003uNz97snrdAEPAjaa7yR32/cd8IO/yuXnGh+Id9hKPSWFYVYaJzrgVtyiN5SrP+cPthEzDb0ZLLsWYDdvjYbtNoNz++GRZUVnLrbbPq3nBTLuOMdUVK1vSkgGBdLCJwhje6UaECl7NKrZjxZP5go4MMVjmJmdDxewlHoESjHPDIJT40n39TqK4ygyXxYpHnRY7seDl3PByNeedpMOLdMGWl6CtJVCSg5biq8mKsGZ3B1LyB9uKX54VHLQChqHbBbt4QkfVOmgrPr1eMgwiLosVP+i3mRWG/5D9hp+IHzHVOSWaGJ9LMeHDcJfjLCWrFaQt5bOXeHw5n9EWIV3f50VxxQYdvhK/pSd2eTb/d+496w8oKwfAkdJrDspCSNL8GCE8Aq9PO9zlI/ln7IYxiSc5TnME4AnJwhS8027x5WLMhmxxIwnoBYLr3HKSuonTf63+F6bL5+49rhKsrdB6jpQxnfh2E+KSV2NCb4BFN1oQcJGXib/JdfpdE+ayzI7xVJv9zsekelQnngW8I3/BhmihcQeWVKT0rTtYHcs39OyQyLodpm8DfDwGMuatvWJguzyX33BgHnAhT/AJyUm5Ye4wklf4NqRV71ev7ZKKii3R46l4wo5xe8WqJontyj7f8oK27dO2LaZigkAR2tDt4IG5HFOworApXbGNsjXzQJja6xojUUS2xTkv6IldZ41k3HiP11yCNkMnZKLkTfkbfuT9c1bkvLKf0FG7NVbyhA0O6NkBczElsU5M1iVuUoMKs6AwS257P2EhJizMBXviPQ4rh7sceLe5be5RoHktvuaGfUgpyib7ObIxqUi5JTc51mNSueC2vUFmS1YUdIlRQmKwJNLjVM9QKFoEKCGZ2YwSd3jz6v5wIJxCPrWFEyDWIR0BCTfMLU7kET0z5FK+pWOH7NsdRmLKWFwQknDLHuALyWt7wlJM2LC7KOsxlSPu2TuM7ZKVWNGuX49MrNhhwDnjZkSuRcUNs8+CjFQsqERFwTrIhuZ9pdHkIueMZ2hbMklfkRVH/2Bt/b074TS/qG+2Em1kEwywtrmsO9F1p7gmWwkkWXHNOt5Qyu8FPMvyvPbROrZ0K9x13bB2++Y1Tm4dBqFNRqXdTWNenH6fAaxXTGs/q+M9V4jfGWc7UpRHxqxRaZdmVQuVan9jDcFYF1Zw6maj1x7aqgl5cCEIiyZwYl6eUOms9hsvqGzR+ISn+piySvEDF2gukQipWNorCr1sslKVCpwfui6oxlakpRv3r193oAlHWD++5zWvSBmhhOfCIWqPpsE0nsb1XngtfHPCLrenXuRndKIb7k1RW7IC1cb3WqTFJYHqQF1UXShDncvsDaiqMVJGNQ0tw1MRnoxqixKAJAl32PIfsm128D1Bpmd8ybfM53dJyXncHjC0ba7zio3QgxxGORjr+MktmxALZ18KlGA/cXCLr5djvGWXB92AX49XdAPJLHV7zA87HQ7nBUoI3ulGjHPDotTkRrOsJB0Z8tZe8XGyx+Mo5FejOenC40HHCY26gaSrHLhjWhiUgJtxwtmqohv49AKJXAlmheF+0uardMSe6nFZrJiVHm/EEY/EHVq+pO1LRrlgbFYs5wV/Fnc4WlpiT6CtxZOSL8YrLsUYVQ7Z8CIuVppVZZyNxxp8oVjYFUfyJUOzz1VesGBFnxYn4pwtvcnT5Rk3ucFbTvkD/w5ptaCwTgFdUdKNbzGef0UlIyqTom2BLhaAxPe6lLWPU6k2eXlFUU34JKnYLx+zlW/RV5GzinkKz4S8WKT0RcKxHXG6FOylGxjrBGs5Bdv+IzL/mk50g3H6Al+1MaYgCffwZcxk9ZpAdWiFe8xXr3CrC6/u1u/UDgFDP75Th6/MGbQfsek9YGlHbKkHtEQXKwwDWmS2YixmxERkYslTnrk4PfMBI3nCBrvMxJgtu8tCLDnlrcPT2pCu3WIix5RkTgFMl1X994UYMRagzLvucycyTuqvWYgZqZgxsNssxJQ5DgijKRnImA0R88qc4uMjEVzIUzpmgMcWI3lOz2xQioJULEiZMinf8FP1zxmJKQsxYc8+4GX1d0Sqy7w4ZaE63FI/5q35nI7aZYGbrG1yCyEUn1b/zq3A1IC27TMR50Sii7SSVDhKVGQTDIYFGYltc25d+tXH3r/kc/1L2t4ue+I9FwtZNz/T6i3nXtt9Hz3iWD1jVhyxFT5i2xxwIl9R2BRf+5yK52DhGI8efUpRMKpxigaLr33O5SGFXTTxsHviPVIx47F8hxf6nGuOGIkumZ2BgNzOGYo73DQPWYgFkzoveilnbJmbFCJjQcZYXKBxRKuxXSCtZCYv2Tf3ScUCIyzbZs9lLNt7VNYJWhdizsAOOBXXTMQ5mrIJ9hiLWXNQ6psBC+EwqK5TP24sarJuarreDbJgff/7bz/+EeNovxFbxcGm89mavKFW+arlhFZeCyVDympJUc5pRS6NY51WJFDM8+MGMuE6ZQ+hZSMoWhdKVWPd1iPaNQTEmIokGKK1Q2D+Lg/Zk6FDXKqQqsycGtjv4ImASA1Y2HP3PWULT4ZOsWgKhtE7XOcvmt81kT1SfdUUs3VxUsJHIJvghFB1mkIYel1X3OquuTQpXp3kFKsBqXZ+OSkkkRhQ1HvaQLVYlWMnHJExgWq7fbFJv++e65312sNbmhWR6jaJUGvPduQNMZRkeubyi83K4SetIQoGNYIypO/fYlK+oeU5So8OKrR18VsW7XyJ2kFZ2ip2oRGqjbUVvtfGYtB6idYLRP2aeCpuiruzsk0QwsOYDGMqClISEdALJQ+KD3ghntD1Au6GCeNcc7PtsRP7vJprbrdiBLARCloiYG4tPd9nI3JvciUgUNAXCZuR4nyl6YiQq6zCExJlFcZa3u0HXK4MaWVRAm53fJalR2EsG6HHgF22Y7fTPIha3O9KtIXDhWZZSrQRtHzBrNCU1vAdr7htbnGxUpytCnoyckrrwvAw2kAg2I58XiyXfKDustfy+Go65wYJDzqSW0GnVhiDcmJlfCk4mZccc8YdsU8/8BjlJd0g4GU+4768xSDwGeUFbWI8c5u+SGh7HmkZuuxl6z7wJY47vWu3afuCP1f3+M+Ll9w1j/mq+k/c9n7CWDwlK06cxYyqxlhO0CYgCjad6t061TS1riK0MW/kC5Z6n3eCTeZVRdf3WFSCSCl+FOzy+eqcg1bAeVohbUQgE4a6w7H8LaPF1/RbDzG2Yjv5kIW+qK1+HkVVo2iDPbTJGSQPOJ/9pvaazxtP7kHwY3RQktguKTNu2fdpW6dUDa3HhRij8EhsQozPwgYMuY0SPi0b0zcPOZYndO2ADdlibmrgv1ihUAzsBp6V+OxR4vCsvlBcc8aWvek6KOFe54Ed0JEhF2ZGLnJumruscFx534ZkYsHQbHNlF3REzJhT2nTwCeobr0dCyBhJiA8WEtosxZhd/31GdsoVb0joc2g+c1AKs+Je8Ie8qT5lISYUesGcM1pqCyV8rjlpMsENJZ4IWeHsnnNzRqgS8rqDe1L+J0q9ZDv5EG1LtuQDlmpManIiNWDL3CQTKUuRNkl22uRYzyBxk8dAJCT+Vj22nbFv7jrEpChRwmecv0KFfs0UAK/+84xnBNLdQxbFOVvhI/bMbQKrkDhv/I7d4FockdkZvnBTgR47YOGtfMa2ud3Q70LbJpULEuMU3RFtTquv8b17DEWHsXVOljYRiQ25EJdMRYnCJ6cgEylTsWJhL6hkRd8M0GyQ2DYLMePSvqIUK27xCGzCpmyDgZXIeFn8V0Kv65DD1ZzY32CSviIP5k2z+d+tCDsFsWy6KeeLXTVweBl4DXRjmZ8RB0PyyiXyrAqX6LLIzwj9XgONwNAoGGFOVnOZy5q+tLYyrUlb2hZQOSqWtr3a9+o1u9cocEEHZbVsnhu4JKeiBnOs84ZdUV85e5BVTjBVTmtx2RLhO/tGoZ1ScJ2Tuh5PB6pNpTOMquh4u044Ugu2HALOnU59mbAsLmoGc1lHPcZo+f14Pa1fH23yWrimvidY1R39qrhqdr1rhbMJ6hzgakVZpUTBgEyPm3G28nzieqTtWL4uV9iYsrmm49VLd01qtvTaA56LOZ4IsFaTFePmMKBNSpXP8VSnRlHmhP6OE7SVc7rRTZTw3S5edSn1zAm0qjGj7DvOwgPKuRvF9+0Oz/UJfXsTIQR/OT7nnWCTZaVZlJqWp7AolrZgUyUESlAZEMIppn+dHrNhe2xGEVeZZRgGjIuSju9TFJppYThcOHvQTDux1nkm0dYwDJxqWVvLl3lFpCSeFIxyOE8rEqVo+ZJnsxW7UUigJMLAv+494pPrFUoIbrZCMm1ZlobSGmZZRdcLmJWGBStGeoJe7HArbjErNOeZWjtFWFbu5+RGsx0FLLW7cflCsiwNLeU+mtuyw8ik7NbkuRtRQq4jcmPItKEjQ4SAod7nSfEf2Is+4on4jDv2A85TzbQs2bU7vJYv6MkDclbEwQ6r/NilWVnwvTZaL5yjQGdE4S4CRWYLwDCefwUd2PM+YEv0uCwyJiwo8g5n4pIbeofLNGUmx1ytturfRfJKX3JXbTloTbDpbCr+Q67K5wSqxdJUdKMDRotv0LrA2JJB8gCAwOuzHb1Papxid5Nb9T62y5U8YdPssxIr3vANfbGPZz1GHDEQ+9xglzNGDKxjxR/LN+zYDb6V39CzW1RoLozzrl9xiMJnjz1yKq5r/GEhVuSkdKyDuFyJYw7sA+aioMLdwM84AQkdM6DCNH5RLUokikPxhAf2MS/EC9oMaduIBRm+DUkI8YWiYMWKnFvegJNqxgP7PhZLR4ZgYcv0GYgtrvxTDJqUOT3/gMR2HRhIut+xZftcc4QvYqblEb6MaattLIZ55VS7lSod4x2fQXiXaXlEQMKKqRMlcsgL+xskPlM5ahjfN+0HTIMREsmG2eKZ/dtG9Loj7je2qGt5yZV+SVtuI5BshPdR+CzFhKl26m6FT1pes+W55KZW6MiFUzFmLkYEJHxlJy4MBp+WHBLRZmQOCeRtR/LSI65VyKbZZypHXNk39Njl0H5GJHpIPAbebebmgqeyZG7OQMOl3GUmLrnKn9EOdlwusViwY++SiSUeESU5MzHl3DwjVgNC2hzwHi/13/FSZWxxlydccmWec0d9TFHNOQh/zFn1hLJa0gq2a6xzzCT95veqrb93EfZUXKfz9GoBU6tRPwshyYpxM4KN/AHGVoRe73shkzWNMncd07ceu1qrXZdm3Bg3Fi6RySUurcH/pkE2rke0rjgX9fOLyIprutHNJskp8DqNEMWvgRq+alHYOYlyH661mMyXSdOdA24sLPx6Jz3D2JKef7OO+ssIVRffa9FRu8yqY6SsGdV1mtIa7YkHvchFpAkjUcqv06KWhH6P2Ovjy7jx8K6DHCLVd7+jSEjCrSYIoxvewCNiKt5irWYjuNvkiErhEyuXZ7wyOavyGuv1yIoxod9DiqzmaTv2sTEVSgUNstPYqvFAl3pJbiaUOsVXSYMWjYJt8nJSU7QkWEVRXRMF20SBA81frb5tKGelnqFUGyUjYn8DieB+2/nnRlnsxqxSUBrNtuhxs614ObOk2tmfjLUkImAz8mj5blcbKcFBS1CYfV6vFryaG+ZVRaoFu3FA7AkuCqdMjqTiskrJKRl6PXYSxeVK0w0kmXbZuJl2/OfjfMlhbgjxmIo5G2YXay29QHI8XfKjjRb/eTTio/YGs8Jws63QuRNdDXyPG57vdsm+z9AOOVsVzHWBzt3r/WahmZQFCsH5SjCMPF4sMyrrc7cdky+6nOoZj1sbfLq8YN8MaPuKcS6Y5JqVLfk8P+cGOwwCn4vcFUNpJF1azr+PR1dsk7FiWkbcbIV8t6i4Ye4wFRPO7DN8L6EyG3XRnZLVQkYpIowt0Ka2EdbMbyEDxouneJ2Q2/IGEsE9f0jiSbrlDVq+xM8l2uyiPMGDTuz23YuQUbWiU9+U36a/IqumZOWYTnSAkiFpMSIJ9xo3wzR7TSe8wU7rB9wxDziRx7Rtj0vxlofmAySCA/k+E5OTsqAn3KRtLq6RVlGKnMJUXIjnIB6wYXu0bJ9Vzfwd2g3mpLSJWbAiFj22zT4ZBVuqTVqrgPfMXhNkkYmQgd1mW7WYmjFGaLq2zbU4IaJNh8RFLoox22YfjQtxeCk0F+KckoxN44r8GpChMSTC5655h6mYc1otXGcsZmwz4NiOGIkj+vb/y9p/NUmWbFma2Keqhxs3c06CZyTPe+veYj013dPTMqgHCMhfwL+bxxGIACIDoFu6IYWaLnppssjg4eEk3N3c+OGqigc9dvLel64ckbKHlIxMDzd+tu691/pWjxCfp/YJpdUsSZ1dyyZ8qf5HLsUZPg7fORRHrOwNY/8hK+2sRxFdDv3Pua6f4RMSixGaikPzEOsZVsYFe5zJHxhzynX9zDEYzLnrZu0Zr/O3dMMDPBlywJHTeVic7UgU1KJmw4x1fUWidhBIenZIYrtUonLPQ50ikdzWLxj7D4lMQiUqItshFUtiBhQk7R69Vu66/5F9irWWtZzSN0OmvHVpfuoILWoi22XNlI7ps2ygKQkD9xjEBM8qUjFjLE+Zc8Uj8zE6dE3IvHyLL2MumlCGgTggsV3uxJXTRugpKJiJilpn1CLkh+I/MY4/Ypm941vp2OaX1Tetg2WVXzj7rq1QfzBF/W/d5E/6KbZ72R+j9BwP+Ya0+NDaA8BxpbeCoLJetWAPbXIHf2jyfLd2GPf7VFOUg/b+jClbXvQqe4eULv1nC03fAi6UDFrUou85Ik5Vpy1VSsmQvJw5X691yuyiWrgUI8yPXb3NG+GSG6mmxbVjUlvTiotqcgLpVN9S+FT1htwuWn9yXi9YlY6H6n7Ga5V+pV6T13OKetmiJQHS+o7SbFxKSXM/hf6RblVYF+O4VZUvi3Nm5WtqnVPVKSt95RKo9IrSbNjU16TVbXsgAuiEexhb0Qn3KKqF27vbon3tts9RyaD1aGtTOOpYY1cSqD+wHBmkdH5T5fXxvSHd8BCJpCZvSGXN77U1Wq+R0uNAfkJFyX9Jn/FPmys2usZaeL7ecFWvOIgDLlNXlBPlcVWmvFjlnHHJy82GnrMHktaW9xuHezwKOlgs18xITcUoFPR9ZwXaWoP+ZNhnIBIqa/h/r7/jTTXjn9fXTIuKVWU4zzLelytqDHfyhqMo5i97B1gLkfT4h8WUgyhiWVoW8o5cWwpj+HZecJ1VLOqKw0TyflNRGIO2lmlRkyiPpz134HjQC3hd3pFa53W+KUqeb1b4KI4Sxaxw4fAxAf81fUNMxNSkvCjuWIoVXV/yMOnwb3v3XOdca1TznTtWQ5Zs+EL9B2bmjJqKge0xDHxerzNSCjQahd+ygT0Z46mEwN/F2gJPDejFpxidNq6CkijYb6xlGdYWzNKX/I5/puv5hEpykeW81Nf8Oj8jUhLVjBvnpeE6q+kSYbBU5Gzs1IF9rCEOHGq1qGdUekMvPMb3EkJ/yF7yBYHsEoouV/KKkdmlwFlwfpDf8L38mnf1HW/kS3ya6QwuIWjfPiSxzory0H5FbGP3nvKed/K5835KF3qQUzIRPXp2jEJhsHzQK6c4thELsSK2EefiebP7sxRGO24xkIiAj81nKNwBqxAFe+YIDxf0PrUrBg0KtYMLqQe3D92IORsytLU8E7/lvf0Oi+Fa3HLFK6Z2RWhDx9ZGUFFzyR0SwQN/xIE5oCdiPCQGzbE5QlOxsFcM2GfHHOE1k6uUBdf1M/reMRlLTs1DIrp8r/+Gaf6cvnQc7ZAum0aRPbC79OUhvkiIxciJZa1bcf26/n+hRMhAHTswip6ysFdu/aQ3XKz+gcv0N2hRs5bLNuWpYI3B8ED9EoN2/1/MOTO/RTavf8GalbjjN9X/yrw+w6C55JoP4o6RPWIh70ikc5kofGbimjveMxAHnOGEYiMOCWzMmim5WLMWC4byiI7p02uSrJ6YzxjafT7y/3tHdbQVaT3lgT3lvtrhcz5z+3C1S5cJNQWxP+YufU4vPGaXhyTBLsP4EVIErPMLB5AKJo7CFp0wiT9ur+f/0u0nd8JbXKU2pSO+yIC6dIHx2wLsEo6CtuvceoNrkRGHuz8iJmUHXybkpbPGFNW88cYGhDLG9+ImkzhwWZo6a7GVKLcfDWTH7SWt232YJrEIYGOd5Wjb2W4f37bjdCpLjS/itmtXwqcbHriCo/rtnF823bCScavG3t58r+P2KeEn5HZBqdd0vQMkilTOyOrpj9GEqtuOdLtyj5qCQHYpzZrKZCRqQm0Kt2uRXdLqpmVaA+71kUG7o94U13gqIpR992Z7EDZEr8gbEssR8wZcEskBLoJQtmuEwrjAh6J28ZHbvU1h3QQh8sfth+hHWEiGNc5mpOslLsrQEIeTNoijI3aopBO9uVAKB/eI/DHX9gV/Iv57nnQjXq0KKqsZ+j6r0vIoGjArNJ+NfM43TkP6xaDHs0VKKCKOopjvZjUdX7IoazIpea6v6NseX/X73Kt2KIxmVlj2Y4ESkkgqRqHk3bpi3CAtR+UuWtTsMcJYS64Nnw06vF2X3Og1D+0pg8AVVIlgYXL6xMRKcpW5E/Sy1MSe5OnA59m84kES8Z+nUw5Vn0+HPr+9K/iV/Qfu2c+Y2DG1dTvpz+IJb7MNu41/8MAPOc+yZr8tKOocQY//4+gh//Ps7/hT+Ut8KTiv1ljgPCuw1nIUR1TGcCYuCIkRAvp0eCZ+yyP7CxbcEQmP2lhqDD4eBus6N9VnJE7ZeDPezv8j1lZ4aoAQnls7qK5TS9sfz+fd+BG+6rBIX2Ex3NQpP+g7PvFOOfQP+Ca7IVCCrMqBLpFye+IdkfDDZsXH5jOey2f4XofF+nv8JhwEnLVtXV5ireEo/hMUHqXImOsztyKRa3cRt2sMmoE4YCGn9OyEXLj4v4HdRYsR18JFyfnWJ2+8vYl1lLZ1fYX1DEfmMT4eM3HHmhVrMedF+Tf8hf9/4qX8gZ4dc0/tcKc9ZmLGiEPmfMBjn+fCPf8dc8iVuKNLxwU7iNtmf+gsO74NScWaShSMzC5LOeeVfMHI7nHLOyL6DOmytgWh7HJon9ATMbXVjMQRlaiQzet/LW7QonaiOtvlQ1XzRv7A0B4wYUjPTugon4844YMeoFAMZERhn/CRPCA3mlv5kMIW7Noha3J6ZkTk/Sm+8qlsRSI/Z8Mcj5AH6peENmyylytCEob+PXKzJK1u6AVHDvjBHQEJu/KUtViwtlPH3ve63Ev+woUw2Bvm5Vu0KemFx3zIfkcS7tHzDjizXyOsu+a8zf6OSm8YxPfJmFHrnGFwn9v8GXP1jon/mJqC2+wZu/GnaFNwW79oV2zr6ICRd59z+wOecNfY6/Tr1tLZ8XYpZcb5+h+JghEz/5S74iVKBhzEXxGScKm/4W/K/4V74Z+zZson9gteln9DGRxys/7WfV4blPINr8mrGcbWzYGyJvT6zboxY1NckXsLPPmvTMyKgwlS+q1y+cd4Qb8Jnt5tE5S2Xly3x61a0ZZjSzdt+7bT8gcEntsN/yFrUyDbDruqN21B8GTswOmNos5agxWGyrikosB3I2hwBcVXHfc79IZecESm7xoFb0xmZs0IPHIm9vIaX3XoByesinM6wR6qGd1uC1hZOXVxKTyXliQCVvaqiQh0gq3aFtQmpdZ5SwVLzW0bw3hb/+CsITQ86WqBsVUL269N1vqxA9nlrnxO5I8IVLctvu4x1y7XWHik5S0qDNvXJNW3Dr5gMkqzaQMptjGQ1upWJd1vxuVpdUvPP2KRvcVTW1BKQLEVxNna+YEbwY6num5UbQ2lcVOOTC2wVlNp5/Hevq99/whtK96J90Sb+7wV5xzZA+ZVxUnUYTeS/H2+4tV0zc+jI3q+5OUyb8hZTuF82FFsKsOTfsC8NKzyKR2bcJu7newbcU5U3OM81YRC8WTgk2tY1xVJFJLWhrVccmQOmLGhEAWTesBVKljpko1IOVJ9Sg0rXXIQxjyNevzX9A2/iB5SGY/HxT0mkUeuDb+apszZEJVjQnwH0bjrMDMZQ3nEzzpjYk8gheA8LShszQd5zYh7aGs5zzI6yudso7nOCx7JY6Y25W/v5gyEwy7eVQV7qsObzIU6KAEXWc5OGHJSHPJCPuetFizklLyekao1x+aIXuBjrWU3iPlN/ZyuHfDIfMy3/KMb2dp1M81oVjC2pDIFw+6n7uBsijaNy6UPnWJNzu3mO7Jo5mII9SHP9S0rOaUyO/RIOCsX1KUmJuQ47HAjb/hE3iMwMZ+rf8+vwnm7QpIiaAE/w+gBmoqKnNv8GYm/Q1rfYZT5IzHkfY6Z2hUeiqHtcyMle3YHxR7XzBp7i2o71Eq4oAslXWH5IN8REDMyuwxEwj/Uv2UcPmZml3Sa4IBLvWRHdrmhJmPpkoZEzcTsU4mSpZwTW3eBHdgJvg1QKFLW7JlDFmJOJUoGZkImMk7MIUuceOmR/YzX4nuUkAxEhDQPWwTouV5jhKEgI7EJa3JGdsyajWMRN/S3gIQ73mOF5sr+QKhDusScy1f8QrjkqdCElMawMHlz6LihI3fp4LtsbRvTEQEfmCGsZMCE0IZcyrd0aPbLuCCNhbjCol2WsF0wFe85MU+YymtqNBJFV0zY2Bs8FXNd/+CSuhr90G7ncwrt9ChpcU1RLZhEH7Gqr1hmbwi8PsP4oQuVqW5JggkfNr9j0nmKR8R18S1ltaIXHTkxaXTA0Dsl8rq8NX+HL2OW+oJETRw4yhbsJV9Q2ZRldtYIiH08FbMTPGWl3Y48UF12zBEAL4ordjuf86H+jrxe8P/Vv6M2Ob7qMEoeI4Rkuv6OrJ4614jqtAEUnWCPtLx16FFv3K5MtwTDf+n2k4twoDro5gIc+G4n6yAOmx9HykIRhg73uEVbSiR5M67tRAdoE7T2plrn7WjajVxLB0q3lRMQNTm8TnEdUOu8HTOHqt8WF+VvQwYKEu++K9rWIKxsi5WwikIv2j10pPptdymFjxJ+u2OubIqnIje+Nq74b9nPlfToBocEIiFnRqJ2mmJekPi7TRFNHcs62CGv51gMk+gjDBpPhORmiUWzyi/oR6eEqu8+sGLjPMiq0+YLGyqUCNpRvaeipjiGSNzFSaDYZjjHSWjX2QABAABJREFUaoS2FavqAk9FxN6QdfnB7e3reasul8J375/csMjeusNUPXP8ahWTlTck4T5VnVLUM5SMCFSPTKcoGaH1GhoSmZSOub29UBocTrQ0K6ytiaMDAhL27BG+9aiE4X/qP2Ycwq+nJf1AsKktJ0GP/XjIrDA836zY950Y62l9zLysOUoC3q812jpF8cDucuT1GQaS67LkC/9+85pZbs2a2Z3i406fQCo8Iej5im7W514So23MtKhIbYUQgkT6WDNgGCoiT3AQxvR8ySAQjDZjLlNnUdLW8vMxvN0ornLLnuzjSUEkfB5EXVaV5r7fIygUSkCpLRtT8rNhD22htw7ItOZhN2RVeQxDyft1xZKM2oSMZMww8FhVCV+Ofd5vFFlt+Sjq8WaTooSkQnNebNj3E/aqE2pq9u0JlZeTmC5z1jz0Eza14arIWIkbugxQyEZceMoeT8jiOev8gloviYNDirrBl+o1voxZpC/wVZ/A67PJLxHb2Mxq4boZLknFkn8ffYmxsCLlgTch8kTzfYSPxT06nuLz+jFaWEJ/SFVvKOoFvkp+dFKYNRtzgxQek+ijdkWyqT7gyZjEm3AkPuGaGdfiLYVd8YRfEtqYaOvQMD438j2hPWEt5oQ2RuET0aUQa/p2F4kTXEoE2hoOvE/xbdD6SvvGTXXuzIYb+4Ij+bnjByNaG5FAUpBTC42mcuswFCERHpKBHVLZmqWck5guNYYP8h0xfc7Fu0bUNWXXjBjIiNIYVsYpq/smaX6Xx7XIWLPhWEzcVMbmdIhYIOmJXbDQkTssmNI3p1gMr8wH9u2YmbyhshUj+mgMOWsWusAXioyciegjhSA0zic/IOFWzHlgnrjsXPs9Y3lCT8Q8sJ9zKd+68b8YkNgeCsXE7DGTU26084FbDA+Cv+Rc/5778V+Ss3aYSj3jWH3JVLmAhFB0KUkZ+w+bJLgxxlZk1QxjK9cMeR2yet7ss792HAdbOoCTPyK3C1bmitP4zyjJnDDNvmdZvmccPkYg2eUhdMA018Z+dOT24mpEaZxi+lK8pCsmJOEeoegilGzdJr6MmaUvmXQ+ptArlIwIVZ9CL9u656mYUA3oeHvcpN+R2lsif0Reztop5r9aEd5yirf72LZg6RRra7LitrUVbce/QDuW3H55pfQcblHFrtDpDOl5LTggrxet8q6ucwLP7V613KYHOYFSKVctXEAIRVWnTbF0ZJ4tnckV+gohJFk1o9t4kbejZYsr6oviXZvpu7X7OLFZRKA6f0QJy+opUdB3hbS+QjV78rS6cfYcnAAMHN4zq+5clKCM2TRozMQbI+WPoi/THHC2p0eA0mwaaEb9Y5escyy6FQJI36Nu/Lil2bSv+Za0dVe9+NGe1HSlmibxqloRBWOy4pZSL/BVl7S4dohDmThLmPCJg93mABA3ooOaJDp1XFZv7HbQIiCv7poAiR8xlWIbfC7ekKgefxqfMis0d4Xm60XG2HOj6XM+8EAccpO50axEUBnLqnZ4ycoa3qw0H/SK2AwYBI5Q40tBoARX8gpVHfGgk/CyviEkJMYn9gS3Zk3fDPGlQCKZFQ4RqYRg7EUEUrDfC/n1Iqc2luvMcF2mKNEhVIJUpDzPNH+9N+ZZmvP3NwGHiWAqFgxNj2Mv4ECEaGvpeIrjjiSQHUoDQfNVuM01XV9yrmccyCEv13lDBvN5Y274NNynH0jerQuWpWYUemQabnOn3L5I3QU0VoorPWUlpsjqEYUoeKwcXvSdrlnIO3zrFNrLquJRp8Ny8xSvSTy67/0pN/Z1gzTcZWXfAZK0eEcveUKkhqzLS3cY9IaU9ZJJ91PWxSWVTtEmx9iIm/Q7imhNqdcsy8/xpWAjlzzXFcd6h4119i1PCmpjybT77tz3fsk7fk1eTRvhpXNHFPWSsl5R6TU2Nu2hbhJ+RMKAgpQVdxyaUxI5JBFDftB/z7H4kue8JrF9B36wQzpEdMwpS7FmjxFYuLFdQkJWYkHPDngnvqe0Kafmc1fARcjcnlPIlI/tx/yWf2QoT+mbHq/E14Siy7F50HpQA5EwMX2WsmCPAbmteS/OiewTVmJBLWo86/E42OFleUvPjpnYMVNxRypcJ19Q85a3AHTFkKW4oRJ9nnDK2pRMzD4hPt+L5yS2R0RCh4iSjBifPbvDjp1Q4EJQ9vR9QkKuxA19O2IhpkzsgALD0B6wZMOEPh4eP4jv2Tf3qERJRYmyyq0CcHnePxf/jrfiLSEKbUOe2k9Y24KCglSuKWxJn4S39pqeciCRJRcYYXik/oxL+4Id7lGLmo4aYawhEAl9u8utfYsSPgO7y1XDg+gFRy68xrrwl3n62mWj+5r9zlfMy7dYq1EycNbOJqBGKsXG3IKEWeoojLlxzIienJDVcxcY0kz7ls3UcpNfUfsDVuaclT9mnV+0WqDD7i9Y5mdE0ZBx8lET6VoQBSOW+RlS+O5gGEzIqhmz7BVKBU0srEfPPyLXM2bpj8yJ/9btJxfhbQHaJiNVtcMYRv6oVdk6AY9sx7/bEAEhVBN0HzVPwM3tmzUkQBs76IkAg9tbBl6vLeyeigi9PrP0JUoELjhel01sWeGKpd9DCQ8p3Qll6zfG0uYGa1Pgq05zGlq3vlaBIq3cOGXrv018578rzdqdemSCr2oSb0JpnT+34+2Sager19u8U3xKs/lxlC3cRTmQXQTr1ubUDQ7dyyB80toBzwPZxaiaYJulKmQ7zpfSw/cShFDtc9vuIywuBjJWIxI1YSku2m7CHZB+3CnXOier7kiLD3SiQ7dj93stPatqlNuRN8SXCdpWJHKER0jq7Tevh08ou1Q2pRO4IhB4PUdGaw4JdZOJ7KmIkfeAxHS5ykp6vk/Xl3wVdfnH+Zx9r8Mn4pjbKicvJXtRyFKs+TTpoq3H2aZg6PuuC+2N6AeCVWWJ8SmM4YdliU/AlbjmUN9nnxFzUjaU/G7hBEK3RcEkCPlZd8x/SZ/x7/iYSehxnVeY2pLVhp5wI2uASPisK811UfDY26XrS16vDF0Rsqk1uZb0bRcfxVVWEUpJqCSbWpPWkr1Y8vUsx+Lwm6W2SN/5Q3uexziSvFjlbGrNJ/4+y6rmVbHmUPURwgnQvpnlbGxJYX20NXw17PCb+ZojsUNhhkgEh4yZ1hmf9rr4m5hb/Yr/c+f/gBSC+92IRWk5VWOUELzWN+Rizcfm5/wgfodEcdz/S97N/wuiWStt8nOkjNjk5/heHyk8Vvm5K47WkIT7ZOWNg/DoHl+o/8CyLhn6Af8uecKs0PQDxbL0GIWKjid4v6kxWA6jkPPcTdWEcLGddw0isxMdMk6esKmcujezM/rigAwn7klsHx/XtUW2yw2vOZU/w7c+pciIbcRLfsND+zMKKkJ8LnjGHn+JwUEBb+UVBoPCpyd2mdgdNJpM5Nw395iKAYV1CNATPsG3Pj0RMhAHeNajoGyKvU9sY5Zyzq15BRLuc0xEl5VYMLBDrsQ5QzviukypGoQnuB11LWoS61CgmqoVk/XsmExseGMvSehyLd+zY1z31rODdiV3aO7j49H3Ar4xLxmYCbeNrXN7/wUlQ7uLEpLAKpbihjEHDeoy4J55TIiHwl1nFqS8tr/iSH6Oh2LdvGbXxonVLsVb9u09tNBIK9GiZmlTdriPZxVd2+GdMiSmS0xER06Y2Us+Nl8icZORyu7QkyHSSvqmS4hHN/y/MJARlTWcSZeNrKyi291jZPeYmAFrcib+CRJB13ZYiw2JTahUzTXvCUWPXXNCGacc26f0SZjJJalYc+h/Tu1X3NWv6HsHnJjPyUTJsvcETUVq54w5YdV7SM9O8DxFRspu/BnH9iMu1Eun17EFI46QfjN5RLMSd0RqxBP7JUWzLriSZ0gUiTfCJD+tE/7J6uisnLZFb3vb+m5rk5GXs3YXW+vMjZyqeeuNrWoXilBUCyqTNSHat1SNHWYb/LAVL1lMu3cGWrXvdhG+VR67QlT9AeRDuV2kLtvH0j7ZLQLT1tTWBTEU1YJ1cdWgLpu9r16jbc2m+sC6unKiJuEgG9oUVI2NQZuCTX3TRAjqJnxBUhr33IvaeRGrekNa3bKpbyj0kk11Q1bNSKsb1uUl4FKl6sYWVVYrNuW1G+1aQ15N/0AV7jjS2z97InD0r3qDtjV3xUsyM0PiOuqyWjXJT64AZ9Vde0jaqtOdiC10YI5gn350SuLvEqsRq/LCoUVtytJcUZhlQ9nyWVYXlNqFUWxfV3fgWlDr1MUfNlnPmgqFYjcKWFYVt5km15aJTMi1JtWac/mejIq7okJYZyHa1IYPzLgpc4QQpLXl9UrzbJnyVr6jNIY/34l5KA/50+g+pbH0fJ+x7LDvubDxRPp0lE+oBKESHJljKmN5n+YoITiIPX7Q56xswUHi8aDnsbQ5g0DxuBvxe/2aXLtC7QvJuq6ojaUjAu51Yj4bBowjFxix0TV/u7zk/z7/HoCe55GamspYXqwyDlWfRVVhLXw+iJnWGR3fdfo+Hr50BK3dWPInk4jTqMPYD3jaS7jJ3Rj1mhldGXAuL1jYnL0g4W/X5yh8dtUT3qc552nB398t+Xq94Fv7knldENoQTc2FPGeH+wghOTAPG0KVh2l2tdbWzb6/QxzuUpucTnjIYf/P3IHS64OQrPML3ohv+E78DmNhWRrOqzVvNimFMVxlFam2eFLQUz6ZtpywT18e0otOuNv80HyPDev8nOnmB4ytWdRnpPUdazt1WEpyurZP13Y4kz+gqQhFt8nIXTM2u6zFikSOWMg7ClEwFXf4ImFhUyqreWn+Hk3dWIic8Gkqb1kLN3Vakjmcou1yI+ZUouKd+J7cOkThQtyQi5SwUTm7cewOp+ILNBXfiq8bzGRCiEe/8SjHwsdDkYql45/L1+SsKShdaIjdwydk1w4RKCZmn0P2mMoP+IRUomJpr1mIWauwnskpNYZca3wbEhKQiICFnLoDAj47okclKiqriYRPxw5ZiwXfi++4kldMxZSMilfiDYWtuZFXDNRxC9SIbUTXDqmpeW7/kYCYmABllTtIoPFQ3PCaipIaQ8cOWcgpGo2Hz6F9TEHNlbjhmfyWK3nFwuSENmQtNo0iuiSS7j73zR7KKrTQHJsH3JM7KCE58fvkTbpaIgJCG+IhqUTJjjni0D6mQ0QgErSoGfsh9+QOe2afr7xHWAwfyX/DR/YRG3J2ZJeRmbBnDjm1T+naLofmPh6KGs2JOWTAPpnIeGg+YdeccmifUImCru01NC5D3+4yEAfUGE48J4qzGBLbY2AmrUjsX7r970pRcl9QVyxRtCEC2zHqtpBsgwd8z+2Mq3pD4A3aVBNwCUTWGrQuHXVLwB8mJ3kyBt+Nc4t62e6Ot1YmKVxUlcG4PWuDptyKu6T0qHXV+pu38/nYG1OaTSt8SoKJg2nYgMTfbdNCthYqJfyWJLXdVde2IKDb8pVjeUBNTm0KYjXCl4ljagufQHSJkxGFXTWPIXaTAN/tKrY3KXw3arc5UnpE3qDdnYf+kE6w164Etqq/7d+TOCV6x9sl1zNC0SOlaKPblNjubBWVcoU7q2YNvcsn8LtY6yhZ4LrxymZoWzEM7jMv34IHiZqwqtf0vAM8QjbcUNsSY9xnIvKHFHpJbXKUjNyBzTSHNSpu5RU605x4A97XC6argJOow7JyI+f79T1OkoiuL+mmHpWBri8Z5D32wojaWBalYT/xqEzAL9VHHCaKTQUbXZFlNU96Ti1sM8VJx+PETnixzAmkx14sWVfWZdRKQSAVc52TrzUn7FNjeLsuiZTj2aa1YTf2+A/dJ7xeFUzCAGNhY0q6vkBjCSS8XDogyEbXfD6Ieb/xyfUEJQWJJ/kn/QMfm485iiNqa6lKw6qylAaOgg5dX1BZzSedPuvKsNQFf3u3JsQlPgXKjbNPOh6WiLF2oJGfq0csqoqs1i1Pt2+GBFIxCX3OspqBjLhrLqxHXh9RS/oiIpCSR+yzoODTwf+V7xb/C6bJjo78XfJqSlG71ULkj4i8IR/Wv20+c+47JpBMs2c8Sv4H/sH8ir36Ph8FOwxCya9WtzzwRyRK0OsobjKDFCDx6VVjZs3viMNdsnKKtTWD+D6xGtG3u8y4IBAJI3nEkhsykRHaPiN7xDv9K/a8p9zoF/TUARJJZBM+2Jfscw+FYi0XTOwJY9nhzmx4pP6MO5wgZ8/uMGdNaEPeie/5kp+TUbEQd4R2DDjb05gTbsWUQQPsMFhm4pqP7FPO5AWJ6ZLYBGEliehTiMx1vdayz4g38pwxHdYsKOyaVKwZ2gO6jZL6AzXCSoyo6CifWMeOr4xgZHbpEPFenjGyR4REVGjO5FuW5pJaVkjjbEISwcpmbJgiheStWJLaOZ4IiW3MM37LhBN8G3JsT3gn39CzQ2J8BmZChXZBFsKJtDw8ZnLKwIzx8fiF/Hc85wcC4SGtxMenouJaXvDQfMlARCBgwCHf8R0RAZHtEBLgo9izO4zsqAkLtNTUDGyPsR+SaJ839ZQxTmcUErJmzVpsqHTNjuxSGev8xLZyO22RMxYdapMwlbccGCdi/Ep8zrmZYSzOKSFmdKqAfXvCnbyhayJiQn7P7xmIXboNV1wBHm6ypZq+dM/ushArejLEN4oKzYYlG5HStX2Wcs7AdLE2IUCRG81U3qLw6doeB16P12X1k2rqTy7CSgYNl9nlALfCnmZBvd1p5uUMGXrNODr4I3sLFY0laeHGn83ud+s7NqamsG5vvO2q89KJhWzTFWfFbYteXFcLOtEBnuoT+2PWxVXrwXXjUCci2kI/2i6wTvFDJ/xyCUhle5CodQO0kH6j3HRRgEYo8tLRdDwVU5p1693N1Mx5inEqYU84EVVu5my4acfHzofr4ti2I/qtjSuv7uiGh62XujJZm52sTU4m/FZUtQV7GOP40lJ4FNWCJc3rK1ctSjMtnMihlkW7r92mTtHsn4XvPnir2oVTyEbstaVvOQ+g63i1KahsisXQ945aU/sfQk28liPtkm4C1WFZXXCkHvNFZ8ybTcpIdChszbPckXh8PG7lNUW6z58M+3yt3/KJvcemhplYMtQhB7HL6F2WkpOOzz8v5qyrhL3Yjf07yietLb/PP5DYhFMxoOfBvW7IojBECi5Sl3L0oDukNj5pVjEJAhJPclfU7MVb60zATqTINZQaIqXImlH1xItZV5aP+zGzwlAYQ8dT7IUhBripMgLhMVA+/UDyIHuMLyUWeJUvGIqErDZktdt/BxI+6XUQAjaZxkcx8WJu6pTrosAXkmHg8b/Np0gEa7Fiz+6wFyfMK6isITVTApVQiRKJA5BYLNdmxSnHCCGorCEXGe/FC37BzzBYruQHKgr6ySMW6++RKiErP4CtiaND8nLm2Oz1W7AGY0s8b9hCeLQpeVf8A6fhn3IuvmNe73BYOuThuu7xw9LFNb4rV/zbyZB3a91YpUZI4ZEVN0y6nzJdf4cvE2L6zLigsim1LTjC0YzueM9cegzsLiPvPhLFifySruk0flnLvnjMW37PHk+QKO7ERSvWiunzJZ+zouBcXhDZDoUtGLDP3KYoFAt7xSGHVJQUosa3iq51a5oP8j0PzEP2GPFSvKRjh/TpMBNL51MWGROzx1zOOBNOjFmSAiekdu4OFGbMVN5yLZZMzH6r5L7kBaEOORc/8Mh+QWx9QgIKKh7Zh0ytm6gJBD4hvki4b+6TSJ+ldf72c/mKXfsQr7H9+IQo69jGgUgam1VIbgeszDV7HCGEoG8TCmpSkXJW/5on3r8BCztmj7XYMCDBWufhPeeKPXbRGJRVlCIlFSkdG3AhPrBnd/mET5myQlnVhi1sxXG+DYhsghaac/GeK+0zMTvEzQFjKu4cRcsmbESKj8eqbTaE46TbDgt5w6Ed0xMh2oxYk9El5gf7FiElN3WMQnIs9tnYkhifmgqNI8xZDIXI6Noeg2Za4iH5hr/jUHzKA7nHa3NJJUqesyASXUqRUVMxag5kAAUFVhju+wN+qK6JSRjZCalIuaqdjupftQgPogdYNHk9ZxQ/wlgXeC+l3yYl5eWdK5hNkIKnYjdebYpJFIzaXabXBCF4nhszb8fH4MLlt//flx264QGb0gVIKBniiRglA+Jg4iAZYolEth7l7eLcmO3OOHPwAe8+lcna/WegugihELVsx9YO8BFQVHOnXBY9MjFzvmI/bi7Qmtq6xKZOuOfAG41P142QHcN6G4RQ6BWdYI9QuFEGgC9i7kxFx991ArPQoSqNqRAoZzVSBiNrqN3UIVIjly9s1ggpCXwHJ4m9CaHnUqR63gGlTd3O3BT4Xodt5OM2eSn0B+41FnFL+up4e1Q2xRcJHiF31Ws8GZKoAaUMf+x+hGJT3RB7E7Jmjy2Eag8+SbDTdjbutXKHBpf2EtH1BQbLThiwrhRd62hYWW35LOhzndWU2hLa2BUua5nYATd1SlR2WZPT1T5pLdFoBoFH7DkK11VW8Tbb8CTYY1rm+BJ+f1fiNR3pvITrvGAkY1Jt+fviJb5wJ+VlqV0ecRrT9RWBErzbOGuURBApyTiS9H3BbW7pB6543hUWa8E2LOh5YfjFqIe18HrlxtYHYcy60kRKMBQJpdUMlc/9rqK2cJk6wEfPl4xCj/OsQlvLJ90ebzZ5O667lK8Z2N0GOnHFA/uISCrO9ZwD+QmhjdyuDMOizLmWH3hoT5FNAY6UQmjZhLjfss8In5BSZAz8E5byTZtwZKxlnb5GyAhtche8YEtCf0zg9ajzlEqvW+HdrX7FofyEgRlyFHT5yOtxm9esTUlgJBUVSsBxR3Fy9wSNxvYMF4u/ZZa+pBufkOkZtcxZ5metVfC5/UdC28MTIWN7QCZSTs1D1mLDmf2ae3xFj4SK2nVcjKiaNKNaVNzI9674moIFOQbLntlv95RzcUNIRGhDdrhHhaZrO4jGp7sjuzzjFRt7y5pD9mWPjbnlgX3I0AuZaVcgNTVrscKzHlpU9MyEIV0SX+FpZ4/yURyZA7dGkHf0zJCSihHOJnNon5CIgLUtyEWGsh6lrd1IWtwQm0f0zJAeQ3yhOLO3dBqr1NAeMLR9apxu4Z14z8CMHDzEzAhlF9lMRIbyiJ6NueTaIWZxabh7/if4JmgDKUIS3rEhokMgEg7MHon0uTVreiTQRCMCHNl93stLpJWMGFNQIpHE9DkwR7yW39MRI1KxIrE9RmaXtViyFCv61nXBhcg4MmPuxIJSZLwTV+zYYyIbM7EDAqkojbNE3dkNCkVJRSlyCgoGZuzWEVSMRYdzbunSJRI+XTtk5EW8r+cEMuHUnHItbp1SHEd+3AZWvDO3pGLFPfOANRkGw0pM+YJPyamZs+Hn/gOuioyeDHhXrpjJa56Yj7gRcwyGA6/Hd+anldefXISzekpWTt0FXK9bBe62C87yaQPHqCjrhk2sS5QKWmVvXs5+DGkQWdvlbm9b3yrQqnDjwNl1tsV7S9xy3aTEbwRMpd60naijPRUYWzbjULdLyes5tc5JgglS+NQmxZiqsTFVjV+3bilapd5gpSGv52hd0gn3WoGaJ5yYKa/nZNYdPrSd4omQQi8pjWoPJ1tbVIHbP1lrqHDd5LI4x+WkBu3z2sr0q3rdjnW3OcqL/E2rKrUYJ7QyaetxXtVXruAiQYZk+dQdVmyBMZuG6dyhE+y5g42hAY24znkraNsqtIVouuLqxvk6ZYAxJbmckYR7Lce6xO2e5+lrtEmbHWOGp3rUOqMb7JPZinlhGHpOSbzQBV0ZMC8135iXjMpdKlHybg1D20MCSglMZfGQ7ESKr8sVuU7wGlvKhzxHCZc7/N5M+TTa4yzfkIiAd2vNk37Ay1VJZeC3iyXv5Ev6dpdhdchDe8pL8YZpWaCEJKNAW5egdFOnPE66GAvvspRAxdQGXq00q6riV+kM3wZ0iVqLzF1RE0hJpi1P+orYk2xqy7rSjhxlLHObchoMuCoyJlGXVWl4mc/5KB6iBOxEkkHQ4beLJX7hTumrWkANhzwkxG99pdPcsaf7JPxQ/y07/hO6tsMr8YZP5CPmJmZjS6ZMucchV+WmEQlV1GhyW1PJwimlGTFIHjX5v+/wvUmrGSga1bu1NXlzGAYXaOLU/EtuqzlFvGQUPOS89jkonRrVYBnifKzvNy5bWaNJxZoT+wmL6F2jGXHf28DrMY4/IhJ9oibQwBWwkJm4bqhHUwqR4RExFRek9Dkxh0zFggueEYkBMX0S22dsB7wS54QiYmT7RNLjd/yWiT1hKt67YHrbIREB1+KCyCYNN3lOJPrcccXI7tGzI3w8NrriPl9SUPOtuWLX7nIh3zM0u8zlDUOzS2AjQkKmYsGZXrJv7pHgggP6dsCe2SfEo8ZwK9xB9kAOWJmC3FbtaPSVfMZn9gv27ZiNmFNQ4uNzJ2/IbYrCJxM5iU14JPd5aS6cgMtaFB4LMWNkxwzlEb4NW2FbaGMS6fGYI16aC8AVwLjJwwXca8+MsT1iJe4ASCnITMVcztg3e3SI2fcSKuNoY4844dauMVg6RCypGZhJ8+cRAzNuZmyKW3nNyEwoqaiokfjsmUOm4o6BHTIVBR1GRDamQ8CcDV0TU6FJbI+lnLuaYSWJ7XImvmEojxmYMTEBua3xhKKi4iDq867YMK273MoLagr+2fwnjtWXRNbnWtxyYJ0DpGyaJIFkTcbDYMx1mfLOXHONswNaYTgv3E77Vqd0RUjPTngmv6W2BbmesREP/vV3wlWdUtVLVyRMjbFVO1p1fy4RtulGVaeNtAu9fpsmsR1Rb7/cw+RhmwXqAgv8tqvchgl4TYflex181SGvZs5m03S5lUnbyESBUyHbxt6gZEhtMneS97qNz9fdTyASQq9LXj9H4hEHOy1YQzUCru1eOPKG1NKNiEPVc4QrOXDCpfoKT4RNB1wjZbelWul2TK9dKlITKedJl24UecM2fMJajS87jWf4Rx+1xZAEDjcJLoO5Mhm94MiFRFhNqAaIUDUS/rAdUQ/8U3TgxjlbAlnoDxwMpEFRbtcJtcnZ5v9uu9g42CUtLpHNIcbYGmt+ZHhvC3ALYRGB+/umBOnGZ0J4JP4uD+1XDETEbix52JN8P9cMvZDjjs+qNBxkR1TU7DBk4Pm8rG84lgmRkqQUfJaM+JC53e1BHLAbCfqrGCGc2OptljnwiC95ILrMy5p5WTEKJQ97AW9XFR91erB5TCR8diLF23zNsT1hP4o4TCSLMiStLYeJJEo7DANXRD/quvxgwOWeVvDU32NTaxYmRxvDnuezqWmFVb+9K/hsGLKsLLMCnvQbWloaESnBJ70OxloWpeajeMi9ruTlUrvHtTZ0hBuR/yIa8182ryjJ+IX6hFVdUxpDICUbXbUHgLH/kLHZ5zjssKuf8LDv8XJWcSZfMzYHDEMfXVruiz08qziRE+Y658/Ch1znJTd2wWPvL/hV+j8jUGiT/sE0o8KYsmXhBl6PONghK2/phofM0pdYm7vRtX9ER4w4DQa8Lu/4qrNDoS09P2E/lixK68ILrEdGTifY43b9TQvuKOsVc/PGsc6RDLxTKptRi4K+3XXiGOMyXo/sU0pyVuIOwwE34owhxwgkM3vGE/snCDdXIrJuinVp7+iKCXuMiE3k9sdig28V+/aEVKT8TD1hXddsTEmIx5wNMSGJCLjgFokkZc3H4h7nzBmZXW7kez4yH7Mm58Drsa4rFsw4NadNvu0Nj+2Dthv3hOSKmwbqMeacKXfyipg+sU14qHYp6kescZGQPTvmWA1Z6RLfBs6zzIrIdhjJCZGSJLpLRcUGN45eiBsHBKKgZ0fOpiZKDtlDNzHyTmA04Kk6ZlpnLMW6TQ96ZD5mRUrKjAf2c67lBcfmHrFNMFh8FN/WZ9zj0BVW49CUmXDXtJWY0mVIyhrfBmQiIxVLunZIzwwJ8ZnJKcp6FDjdyFx8oGcHjMyEHZW0Dpr3dkloAqbS8ROklRQiY2AnXIqXHNtPmySqkArNrpcQaWe5+l1+RS7WJOKUxPbZiDl73lOUdasKgaSyYxfbKNz18r65j8ZQGcML8Q1YmMoPHJkTNjZjLTZc85YB++REDG2foe3zSnxLqAYUdt1Ob/+l208uwqVeETYYxdpkxOEOm/yqsaA42Ma2iw2aXbG7OK9b5KRj0tZUZk1Ze9Se8/AWQOSP3dhauSxcKf0fyTrSay1Lke9G2luRl/Ia240pnAisGX1WeuOCFvxBK8oqjUtXqvSGUm0IVSMGaBCVgdcjK29RMiTynCWgqJcIoZrQc0nBCms1pXQnUW0KattkAJsKLYtWFb0lp6TlHZ3G7rTNMa70xu3U601LVzG2wgauyHkybKcExm5Tj0pqWzT40IKiWjBMHuKLmNS4qDFp3X5b29IpkmVI3zviNn/W+Lo3zqMtApL4PsvCsXTjYKct9EoFbUykaBTftrkIG1tikQTKdWO1yQmUG+/XximiLRZMiWiK96b6gPIVl9yxuesyE45s9D8NHjLNDbuRi4R8vt4QScWirijImRYVvpDcykukGBMr2NSCd2mGEm6XhYWb3KMjAwpTcZnWzJvJy8iLuM3de3+m7/DLCV8N+vzjYkplIk6CLrl2EI7L1PAuX/MX4z6hgqs8J69DpIC/07/iq/RnHMYBLzcbfOGU0OPQY5UJYuGT1ZbUVARG8lJfo6xiJ9vlMndf6g+pZlNrpmLBjgn51WrGjuxya9Zsspg3mbPx2EXX2a7EC/zyKR9yQ0jMrt1lbkoCqdiPfd5uMio0hand4cUeIZG8KO7IRUqwOSEVSx6ZJzyX3xEWDgTynLccWBd6UFFzk5dcM+NSvOAz+wseD/6al4v/FSE8tuaJ0N9pxY3d8IBF9o44mFDWSzYop51ovPJ32QuI4XXZd+xgM6HQLvGpHwSsKkMkPB4lHf5T9opPzV/w23jTHuaEkE2iUk3kOXRqbhYE0qmhJZK1XHJnzjjmLzC2Q9f2qNAcmIcYDBfiB2pT8D1/x0PxC0Ib8kG+xyekICWzM2ISJyyTb3lqP0FjWIs1GzHnvEqcnUkYBwOxCXOxZCD2OLI7XHBLzw74oFfM5A1dO2Tf3ONGzJmK99T1Q1KxZmBHJNLngoyeGbEg507euEhEJMfsIyzMSfGta06GZuRSfGoHk5AIzsUPGCp87dKNVvaGHXuPnh0ykzf8nt/j1xFGaiK6TMwOyioG7KKsoscED4892eParMipOBMX9M0QJXym8pqodjvoGo0Rrlu+kleMjVMACys5NfcRCC54xlfiL8hthURybRd0iKlE6XzZ9Hgl3pDbJQlOY7JjJyzZ8Kl4wgtxhkRQ2IrEdknFmq7pU6O4bz/mVl4T2JhKV8SESAT3xTFLciZmh7XY0LddEgIuxC1dMXGcb/mGiX3K2mZkOnTXEp03tqaQtS1AgEHz2D5AY/GsYp8RkafYaI8lC0Z2TEf5lMbwvp6zz0MWckrXDlFIhnSprEbxmFt5gbSSgZywMDmP7GfUGGJ8/qt4+a9bhH2VtJ2o14QPbDsrp1oOWlN0Vt01Kmr/jzyn22zb0B+1JCuFE0H9IapR4Cw1SbiLEh6lqZvCEYJHQynpUQkHAqmNC6YXXo8tCnJLfpLCIy1uEEKSBDstPzrxxggUsT9ukZNbD/E2uzNQP3a1UnityhjAF0mrmhbCdaGh7wAenoqJ1cj9OxGEDbSkQQGGqk8cOJ9yN3QA9UpuUCLAmIpecERlUvxm7Lj19nbDA4yt6YXH5HrukqxEz3WfGGJ/jC8SalU4+1ZzEbUYEn+HrL4jVIP2eVQma1+jRE0a6Igiq+7wvYSsdKMyB1WRbryPRDbqdG3KRoS1zVYeUdQuihFrMGaDlAGh6jGQEVNuCe2QgR0ykjHL0vAhz8nqACngUl4SmVPWtuCAPWJPESnJX8nPqI3Fl4I7s+GvxmMqA087Pd6nBT1fkdWCYTBwKuVMuYg974S9SPH/m9/g4bGuax55Hn3caPm0q3i7hn4guc01S7HmzSrhqONxL4mb913wefoVvpTOOhTEDANH0vqnuzV3YsHPoyMEsBu4iMHEJkxkQi+QvM8MB1FEZSD2FH/iH3CdVXzRGVMZy886E349zTmJu3QbgdyiFPyi/oTdWPFildO3XcYqbsbbztrV9Xx6fsTzbE5EwJqMmppTNUbbgYt0ZMIb+dqNAkXETuhzlTlP6p3OWIoFSxbs2h3Wcpdn/B4shP64dR/M0pc/Ton8DiPvASY2jS3PkdG8BpW6/Q4tynck4Yi+HfEiW7LvOZSntxF4QpDZil+nMz6yH7Mk48/VX/OP4j+2aV+h6tH1Dijt2nlvuUIJn7k+I5IDDu1jkPdZm5xr+Z6R3WNIQkLA1K44sZ/QTFWRSPrESHNITU0iukSiy8D06MoAaSQ5FRsySpGR2B4aTUnGrjnhWA35vX3mkpZsTUHNLiMCochsRWw7FCLjgdwlNTWhCTlUfQrTY0HO2pRkcgkSJrZPajusxZy+HbG2BTNxx1LeMLJHnJqHfM8/ccKn+ChySqrG/dGzR+zJPoUtqERBZBJ8fPp2RNeesBYb1mLhtBQoND7zpquNbUwhCm6NoI+bHj2wx/hKMtc+xvY4imL+tnzOPfO4UYHfcWAOmgCJgolMWJuSrgyY2PusrRN61qImE1MOeMwNNxg7pKM8KlPQE7scmX2WZNyKKXt2h0BKRvWEgoKIgA0pG2YkostMuL3qgTkgEC4f2rc+BQXCdghQzMWKQmRsrCJqRFwWTUHJnjmhQrMjeljg783fsSsecsCEU3PPBZmImrE94hy3T98XIye61JpEeoQmailmM7vhUA1Y6gKvyZ7WGN7Jd9wzDzhWQ3ZMj8xWRJ7TOd3Ubjyd2+qPAon+VYpwpdM/Sjrahhu4rqtGSh8hJKv8oi1EWxqVFabd67qoPtOol/M/EmltLU1Aq1Su6pTaZERyRKFd6EBZr1xha2IKFSHr4qq1I5XVqvUwq0YNZ03dFmtjqtYL3EYlNkb4LSVqq3wOvX6rqva8MZvqpv3vSji82fbxuy7czU/SekriTRrmq2wgFo74ZZU7aBT1svU/b3N8fdUhrafUjfc3DnZIy1vKekXaqKO3CE/fS5iVr+n4+2hTkDYEq22nPQwftPzubXzh9kKnRMgyOyMKRkTeGIP7mdo6KpoUXjNF6DVditcWYK1T/AZp+Ycq2bJeOK+pNXjekKqeuTGmDPmGb/mSz+lHiu+KBZ6R5GlNjaE0hpOODxt40A1ZVQHP8xnUoK2zYHzQK5ZiAQL+813Fp9Eu60pTWc28rKmMwdOSfqDoej479YRxqCiM5WEw5mV5y8NeyHfzkgrNrND81805AzskVj0ui5QD4aAWWW05zwr2wpDaGI4TN0rOtaNQTcKQSMFCrPCtz1mWIhH0vcAdCHTE7/kGVp+zJmdeegwDR+i6K2oqa+j6gn+Yz4i9EQubk6c1Szb0SDgME1Ktebt2KTK+COjZkEeJz9na8l1+w0T08aXDJc7EkpW4o2fHGCwL40aeqXQ85Lm4QnPEt9mUXKSU5KzFnANzykakTsxjB9yZtxzKTzCxZpo942b1a4TwiL0heXXH0L9HRe7gMuUtO/HH3KTfueCO6IBl+gopArKy5E69QnpPGr93REbOVa0bS4jiqb/XKMnnvBKXYGAn/pjz1d9hTE6VZHT8XXeBVhNSPWVXPSFnzXu+d64F6XJ9B7bHLSve8ns6csLI7hHasN2XfhB3LMUNPesO3jlr1vQpTM2tvHAHWPoMzJhKlIT4jO0Bd/IDUks24pb3MuVT+yWFrZiJGe/qX/NE/RtSsSKzC35PxrG9x0ze4GuPS3mGEh47Zmvnm3GJR88OiG3EUCSsKAiJeGw+ZSnWvJMvmXCfrunwQros2j1zn11zyka66dqp2OXcSnKRcsklXTFhZPsMbM8BM+RLKgp27Q45az5Sp3xvX3FgjlBI5mzAuh20LyTX8oN7PYp9UjvjSl60GMhX8pkjbZlLvpaaUCbsmX02cu486XaEMUMu5EvO7A1zLpznuR4hpctKrtDU1KRiRWp7XOlrpuItHbFDx8R4KGL6RDbmYz5mxoY92WuU/A7ZuTCCngp4bS45YZ87s2EtlpyTshAfGHMCgI/HmoxbUgqR8ZH5GRKBxrCkYVhQsRA3RHSpbcj34hk9PSEVSwZ6whvzzwj5ZzwNd7gqC+baZy6WVM2Yum8OCIhZiBWR8XjPBypZUld7nMs37HDEQETMbNE2cP9qRXjLL94Kd7ajYneBdqNVKXzKekE/efAHiUU7pIWbjW+7LucjDf+oqDv05IZ+dNoKqJQMqLQb1253zMZsrVB3DVPaUbnyNskppBP9WMy3Y2Sv6Sq1rQlUp4F7lI1oyoHqjamb3F3fFWscqrIT7JFWt0RyQFbftftnbYv21J7q6R+lOuX1nHXlLD95vWhHy4m/Q1ftsdbXTRpU1ykUw5qOt8umvmnTpgKvR887IJMhUnqMgoek+paBd8rGTFscp7GOX9sLjlD4BLLLvBGqFdWizVbejvQthlzPWwa4saZFbnoibA8GoeqxLq6odUrk71LWi5aIFqhuu2cG5+sujBsDIzyqetokMzmB20Q+YBB4HHck53mXvnJjptTU7MU+v1nNOOSQ60wjhQuz96Tgpk7Z9RIeR0NG4Zj/x+q3DOyIQhtUw3w+TFyO77TMGQkPX7rPwk2mGYSS6zJlSJdZYbjXDbjOFMNA8kAfcmFnXOchEy9GCog9wWVacZpEXGcVO5HHKBT8092KgyBhbQt+WGkqkzCyfWZiSU8GnOsZuk5Y1pI5a47sQwaRR9cOOS82UMIvJiH/203G2A/5er4hEznawKHX5bJe80W8i7YwLdx3q+f7HFf7pLZkFPpcZwYhBF8lu1xlJTdlxqU8Y9+cMGw8jx/0irHocGtX9O0I3wakIuEgCpmYgK/LlHvigNLssh9F/K5IGcgIYywDdYxpKGuD6AFZowdYlZfkxRV3zWc49Pocx7/kuvreiSOVS9qJekP68oCS1PnMqTnjG94038Gn4i+4H/Qotct/XpmCW/GOJ+ZztFeR2wUHvV+2h9BlcU6tM3aSTxFIXqz/E8P4YevfNxgW5hxfhuSsGXNK1CibDZZCZKzFnFNzjwMmTO2SG3nGwDoP7o1w+8Wh3edOXGClYWQmJCKgtoY7UTGVH4gYsGtO6Hge07pmYIf8ufprCmpWeEw4YWLGvJLP2DWnvJXP6DdCn1xkHJhj3spnDOyQk6BLqATXeYmPQlnP5RvbDksRsrI3eMJj155yKMYsyJ3/1Hp0fI9lVXEsJpzZG+7ZT7gTN3wnfsMO91vohMEyFXdEdJnrHCkVN/KG0Mb0bZdz+Y4FUxLdxyegEI6n3ZN75Kw5No+o0ezaHW7ELff4itymRDahxuA1EZJz1tzJK07MExSKXO6ibUVPBXzJx2x0xVQsCG3Isbnn4htFTcyIoXGCti0xLMQBcpZyzsAmXDHlwBywl/h0ao+zcsEeO5RoLuRLYvr4NuTUPmUtVsSE+DhbFEDOmqmYokVNYGO6tkuMaxqXYkZFgY+PRDG2AyZ2yDv5hr48JjA+87Lilncg7pGLNR/xkDf2Al8o/jx8yLoyrLT7mUP7BA9J1w6pRMWlvcMIS1Etf1Jt/clF2BVfB5Jwo8dew4XOW3yiw0Um7d4VaPjBss0V3qYQWWsciLsJ+d6m8aTVLWW1+oMYPceOjoJRg2Hc0qt897uRlLjudRuLuO2CtzfbhEPUDcc6DnaIRELJpvUs0yquFWlxTRSMXEeMaYt1aVPKakXgu0Lm9t05nkxYFedNxGPoLkDNIWWbagTgiYDaFszrMyLVJ6/nrOpzF1QhfGYN3arWWct6Lm1KVt21grSyXlGZrM1J3hZSgFV5gZR+620uzZok3CMtrtudW1U7IVvkDVuld2mcB9h18uUf7cYd49sFOlhrUMLDV31W+bnbeaueuy+97ZZLwLDdJwrh4ckQg+bvyu/5rHrCl4MeV2mNJwWvyin3OCbEp6Dmrs45l++pKPj3wZfMaumC4f0u7zcumH0t1nytpySmixaadDXAYFmT8cRLKLUTnWxqx2uuMRxHCeNQuazfMieQMbU1jOnR9TyEELwt5+zoLn3f49lmSYwPeExzw/3YFaACJ9bR1jrIASN6vmKsewghOI5D+mXA+3pOaSzauMdyGAf83U3KG/maof2Evhdw6B3w280tPj6fdQYsSvd4L7ljaHs8CEPelzkf5Hui4jESQUd5TAvNxpYcBB1+V5yRylnL6Y1twjkZHRKklY7QZJb8YxES2pgZl1SUBCJmnSfcl3u8sudEJATE+ISkDT0u8CfUek1ZrRj1vqDWGfeDPyexXbomRvqSmTqjK/cYmwM8PGpT0+MUH0VfBTy3Qz4LDimMYV4XRErwtlxy4g0ojcepfUpBxcQccSA/w1jLShW891/xIfva7aIx3G2e0U8ekKgJlc3whHs+XbnH3F5QmZSx+DmlyNGiom8nFDYGAbdiSiUc2nRsj/jAS7r0UPhU1omFIrpMzRsS0UWQsBbrNm0pFQ608b1Z4ouQnBRjR1zLC9b2mq7Y44Oo2TWnxEScmqecyR+Y2BP2GJFT0be7vJXPuK1HdMo+E9HnTL5DIunaAb5V9O2IPXvEo6jPrKxYmYJUpPTNkFt5yVm54EZe8cQ+4pgdEJDbLp0Ge+khOQp65NpwqeFavCfkkMh2eKd/5VYJzVA1sh32GHHFlC/Fp4RK8n2tWQuH8XSqjJSVmLJndynJKUUOFrp2SNe678PH9mM6nkeqa6Q54lp+IDU1t8xBwMj2+bX5z3S9A3bsMcp6VGTkImVjp3SE892eyXcUrAlIyG3FgZiwImNa1Cx1wZn4gS/4ORc4IEZJxrE94Y18SWZnGOFsRAkDctb07MQJt8yEubzBQzETUzzrsTDnhKLHWvRReLyXZ/TtiJ4dMxXvSQjJbMVHfMGtmLJjDrgUdxxzwNLmvCrekNg+EsFD+yV38sZdP0VJYrpkIuO+2ON9E1n6L9bWn/RT0BbOLSULtcVWOoV07E1Iq5s2wGGbw5vW12zjCKNoSJMw5gqKdpaZJNhtcZih6rdFdJsPnFV3LVBja4vaeoeldElCnWCPrL5rd8HauL2lxbDO3rscY9VpxA7bAuEycH0Zk3hjlzaEJA532t0vNAQpkyKFJAn32k5164eOZJ/M67X86G33vE1ncs/XbwMWAtlx5KDgyMG/ZegKnApaP3XH32VtPyC3r4s3oOPvNuQulwJlfePoVSLktvihLcCueP6Yexx4PaT0idSQXM9bvGZVpyTBhLIR0Vlr6PoHbOobtvnC213/Vilb6yVCBC7UwTi7VS88ZpmfAWBM7rzO4kcw+J56yl/3H/O7+Ror4c2qpLaGRHn8Mj4i8gTHUcJ1XnCSROj0CIMbCe/6ManWLEuNEoKHatfta0zGTE75SJyyF/lcZiWFqclqixCgMQgB79OCx7FLMHq/qdiLPQ6jmINEEqqQZ5slR17EZV7QJeLaLOnYMbteQt0UUGOh0NYVdWL6XsCmtmzIUFaiREDfCyiNoetL5k2Un7WWfiCBhJ4v+HiQkC1OWTYCqwTJsRrS8R3IY1XX3O9F3Ct2+KBXeFIwEBGheUDH8/CEC7VQwnmtYyUYqfvUFMz5wNDus8OQ1DpgR4ZT7D/m50y55pBj5uIDY7NLjM+cNZ4UHNR7RNLj1/YFSjh9RuLvOBGkjPG9hEPvc3blLp90evx/0t+xYz9mYCYkos+eHbEio0bTp8OjToc3mxQp4OfREfuxJNOKTqG4zNy05BvzmqfqPjFdMl1jCNkJfUpjKQvNL+WX/BCNMRimvKUX33OqZD0lkgO3YkES0WWhz0jUDp71yDEYYXgn3pDYHl3Tx8cnJcVg8K3PrnBWL9/28XlIYH16IubWvEBISYluuqQ+e7LHrXG2mtB6XDfdc9WANL5lyYE5JsbHYEmkz5m9JaaPpqKjPM70JT4hfbvLrt1pQxK+lB/xt/XfIKUbzy/LlIGIuG0mIVVD1FrIO0pSDJYjc8Iz+YxDc59beUVJxid8ynPxgsAc8W3lMLgThviEBFIxMn1i+d8RmYBIeCyM6wrHQUDPHKCtpbaWTGw4NQ+RCGIx5h2XRHRZsiEVK8YNYCQXGwyGUmRcUTGpHeKxjxNoLmxKLTS5WLPDkJ/Jf88ll0Q2ZkCPXG44tYdIJDN7yRMe0fd8flM/Z2R2OQo6aGtJq5L3ZgoCntjPWZLTp0fHOlFdhaayLozngXdEafbJqBir+7y2lzw0D1iSsTLXrLgmESOM0EzEAwSSR2KfjR5zI+bsM+J78QyBZOyH/Fa/4NicUImSFQueqmPmdcG1dCP3e3KHSCkqY5C1aFQ5tjlc9qgbTdRPuf3vwlZuMyLBdU3bQuXyZNfNRTprhTpRY+zPqx9jnbakp9gfOQV0tWi4y9uwA9XeVyuSapTEhrrdv27Rk9q41I3KuPvuhofk9bwdMxtbE/qjFokZeq4D9WTikjyiB20BacezpqK0ui14PXVAYRcY6xOqPrVx3en2d5VqjRCKXM/pevtUNiUUPUqbktZTynrVhhxYqx2Uo+Fdb8EZvtdpu/dAdVtCVVrftSP8Uq9bP29lMvLqrkltcvvmqsn99XFThy38Y9sFy2YfXtuMWmQugEONHH2suHI7eZO2+2D3fjny1XYf7F6fso1UhB/Tm+oGIr99D62tkKJPzpp364qX8ns+s18wCnysVYwjyU2mG+6wZkOJsREGy66XkGnNhyplKdacsoPBMtc5kXB83FsqXppz/OKUhcmbzhUn4kJRGsNhHHCdVwRS8qHeYFN3gr/O4EW2dDYIILUla7HhodpFNr+jsJp3acVuELGoKiKlGIgQX0rudRWv7yRTMefAxIxCxfu0dhe05v77geIiLXgtztCrB8Se4xWf2iOUELzKF/RETFrAS/GSY3uPykRkumYgEp4vc6foBIaBwli4zAsiqdBoXmdrCumCFTQVlSgd7UglpKZGWYkvHHijawccxAHPc7cGuBa31KJmo13U3bd8T2VT7rILlArYE0/Y83fphgGF1bziNQ/jLr9fz+iKIcdJyBEhuTZoA4n2WOmSJ72Eu1xzEEXESrKpDV/Pcsahe28mQYgpLffUQ5Rwdq6NtnSUT6Et07JgKhZM5D6fyhPelysGjDjzf2DP3OdSvGCaP6cXHrOQN40mIWRRneEHMYVdM7EnJHaXjVzSswNSkTIV7wnpshGmieKTxEK5/Z3JOOeKHe+Jsy0JSUlOKlZcGZ876Q7nfTsiExsmZh8fj9xW7In7zYHIPf9bsyYm4prXTOynvKtnPJBHPOc1Ja7rVvgsbEy/HnAiPqVvuvxQXVMLzTkFHoo74cRoO+aQioJMz/igXBxiSIJs0JaVKHkrzomaznQj5vTsGF8oJIpnvKQvRizFjJKUoT1gJi84MA9RlWRlG2Y2ITf6B0Ivpmv7YGHCBGPdZ3nBlJm8YWL2WdspY04cAYtOe7gxWCZmh6m8RVrX4f8IBNGsxIK8QVqecUnfDujSY8qK66ombIbK31cf2LUuoKSi5IbX7Im/pC9DvrUv+EJ8xJm+a1YL+4zVCed2SiqX9MyIpZZEJLyXl6yZMsFFnH4kTjnXM67lW47MYyppuBAfqETB0N/nSfERV+KGd9WCVMyRnDIyE16L3/GEIwKh2DNHzOSUX5lfMTKH7FnXKF7LCzQVf6/f8TPxJ1jAon9SXf3JAQ5u1Bq0F2chHOHJgSZCN9ZVHaeW9jqE/rAdU3sybmAWVUteKpqMYd9zCUYuNL7CE4ETMTUFFmhjE42p8b2k6Rx1qx7eJjMJFGl567zF1QptSiJviJIBFt1yq8HZZtLy1o21/AFJMCFofLpBs98OVJfEc+MSTyYkcsS6vKS2JVK63asr9j8eBsClImkqlHBF2/dcglLH2yVUfTreLonaaRWlncBRt7zGl9wCS3TuCqLXb2KyfGqdE/uObzuIHrRJSaHqEXg9F28ofDwRoE3RrgG64SGR6rfvZdKQuiyGWI5Igp0mF1q2/ujYGzYBD0FjHUnbn8nLWev7rupNI4pz4i0lkyYUwHciMgq0tTw2n7ATBmjrmNDHiWAUKjwpUKLp+pTgs26fi3rJzG7Y9RI+Dx0b9jBxoIq9MKSnAu6be0zshGGoWIg5V+KaXFsKY1iS0vM8poUrjPO64CTo8dy8505nREowk1Oe2zPuippdz3kzjzs+qXZRgodRiBISTwqOkpBQSlJT0/Md0iAkcN2YEnR8wST00dYlz6QUbrRqCz6VD/ClYFqWfCLvoRrp7o7ssrYFA89nzxwxkBES6HuBC4qwBWMVMxN3vElTZmXN0A/IjeaXgzFjFTOxJ4Siy0P7JTUVYz/gs5HPNTPHD0e5C7btc51X/Ew+ZSAjDuwufxU/cp8HFJmdkVV3dMI9Hgf/lnscMlAhh4nPXhjyxD7ih2zO42jIf9e9x/u0YFMZbgpHJNPWMvRCNpUl9iSDQNLzBda63XbHk6S1YRBKOspnP/EIlXvfH3cT7ncDbsqcvhdwwJhV5b6rOyrhZ70B983H3PPGHPDI5Q3jqHWaikgO2A8+Z1a/5YH9nLn4wI08Q1mPXGQciwm71nlEK3J6dkAgHHXpOW+pqClEhsLHQ9JRHjt2gsIjJmTfnDjVsXWfZR+XqLQUayZNkV/pkplYYrBEBBzgYib7JLziPROzx2PzlD1zwsBM2LU7DERCaN0uc4chlXDP51CMeWCeAM7HW5GzL5+6A4ZxF/2xcopng8W3Ibt2h6FIUHisxZxLnM1nZHYR1qU1HZqHDJvR9VoumdplGwohEez4T4hsgsHwQV5zI29IRcoaN9YFyETGmJPmcQcO/0jMsRrxg/17AHbNbtP5d5nYMV3bIbJdurbHQkwZ2TEDO6JLRCZyusTsMWIt5gxVxMQOuBI3TBuQyREf80accaPXPDQPuNUpHh6f2y/o2wGhDTlkTM+M2BUD5s1eODFdDsxDbs0rVvaG92ZKKtd8Yb9iJJxPX4ua0MZcFzkbSrq2x6Hq8xk/I6NiIBIC0eW1vmFjS/oiomtc/vsxjrwW4zMyu3xiP2aHewRScsUdWXX3k2rrT88TbsRYdZmjhMNDlk28mdryoW3Z7nKB1kMslENH/qEX0AE9sra7NrXbiyoZUtuyVQBv83W33VmgumSl6y630YhCOT9y6A8aUlbV7q5LvW73s9v72oqwLJpNfdMKnDzhs6k+tHtrF0HYZWVcBqUnfsQ3auNOp7XOyKwmVD1qW7Io37UwkW1CjBQem/qmOShICrN0bOjKPQcj6yZPOWgnBnndTAiQZNVdm7e8vWXV3R+I2mTLmo78MavinMgf48mYvHQZyk6MtWyBG4HqNHnGCyqRtgEYSriRdlpcoyIXb+d8oAGGHG1ypHCHsbS8odZ5O/nQTXBDrZdgDRZL4PUozJoPrPiiMyatDScdxbfznPcpVFZzL4m51SmnYZdcW5RwX/Zjdkh1zWWdu5DzTDCtM069DrEnKYzkhjU3ecQhe5S2xpcQSI+5Dlvk5EkS8iGTLKuKI+sKeqgEfeNSYlYU1MawEHPk5pgte3kUSo7jkMrAqjJktaa0NVdZyTR32MxP/H02tcWXlrQ2eMJFxUWNd/izbp+zTUHX87hlzq2GYzHh6SBgmhvIE15V7mLzgjOu5n06RC0MQSL4KrjH78p3WL3DUkNPhrxdlby111yYbziUnwC4/VdVcZ1JFuKGHhM+F0+5ZMGanDdcEpiYG/2CSA6oN1+4zxolEr89kO3aESsK7nRNlXaZhD5Tu+JADgiVYF0Z9iNnK5uIgPf5hsMwYVNrqOF+z+Pbec5+FHC/p3i3dmr0T4c+r5aayhjONxXLuqSjfEZCOmGdWPA0PuS7VcZcrPht9RpPhLxcTxgwouMpwjpkIPYpZJ+agmn5gpPgF1S48JQFs3YycG1fcI+veMcVK3FHQMyOPeZO3nDBmg5DdsweS7FiYCbcyDPOZMadHjKXV3QYkYgAJQTveeEiEO2YtdgwsQNeiRcuW9hGTs8gXOhEbRwM5I04I7Ix9+0xMzZIBFP5gcT2qZvvucEyZ8OIbhsRmCjFzGg6dkhM2KJKd3lIRk7PDPE9yR4jXonXxLaDQJDbGiMMD80D5yGnYl/1uNMZp+IzgsCJFCubsms/IaPAE5I1SwoKEttzFCw/4a5K+E78Bi0m3Lf3eCa/dYAe4XQZIQGv+IGYgUtKsh/YUY/ITM6NPGNZX3CsvqRvB1zJMzQVGxFR2HVz6Cm4FVeuc21yjhUurnTsh0xrn8dyl4Uu6KmAfzKvGLNLhcZD8kp8z0xMyMSSkC6hCdgVA7Q1HIgx12JGJlImZod7fMVb8xuU8KhEwco6R3Qq1ijrMbBDAqF4Lr4joss+PW6Zs5YLKjPhM77glXhDbCNurNtnH5iHLMlZizW7dsShGnCpnXvjQ72hEkUrcP2Xbj+5E94WzjiYEPg9dON3Bac4ToKddtSsddmkCLndY17dtQENWpctaUmbsu3UnGpXU2oH1HD5wq5gx8GkzRveqoaBdpcq+bF781RMoLpE3qDlWHeCPSJ/jO+5kU3g9YiCEd3wsBGZ9YlUn3V5ia86RMHox/toipIvYwKRNEQp3aYkeSom9hwGM1Q9PBnT8XeJvAGh12cSfoSxTvncUbtI4RPLEV1vn93kUxcf6O0T+yNqnbfqZddZ+4RqwF70GVEwIvHGLnZQ+ETeoFWGeyJyMBAZEntD4mDHKVz9Ezqh200773XYpmBZa9rnuD04harfPLYDdpJPASfIc8rqtSusTT6wU6gGSOnRiQ6Igx2UjFxIRBszqah1Tk/ucSa+59VmQ64N68rypzsRf7XnkI++dDuVrDZUxvJP2ZlTLIYNfg7JF4MufV/RkyHa4DpOu3BiJU9xHIdsyOl40sE/8PCk4OOhT2VcnF6sXJD6YRwxDJyloUfiRFsqphY187pgoysk8CGt2dSW9/mGjic46fgIBKahDYX4jEJJrAS/X8+4qVMs0Fchk9DHk4JVZVq1trIef9U/xGDJNcxLjRAwpoeHxxfqPp/FE0o0NYZQeERK8qZY8FedBxyGCZHw2Y99hICluGGgjols4ryJIm1+t0Xh80juc6PXTESPQhQoPE7tEffkVxzbj3CGIdv+E2CP+6zJ2ebOHsQB13nJgRwQe4q7omF7K0FlQAp42u2yEyl8Ien6klfLioVNuc5LfjV1K4quL5kV7nVb2JyOp9AYhoHHqnL//YHc5f2mIhY+vvWJxYCxPaJr+2gc7KRsLH+fiSd8JT5n4J9yWX/ThCXgutmGYNeXhyzklLVwlhqDcVQ/6/HQfERkkyZ3t0+fDhKFQNK13WZkfNVc3ywDu4tvfRQ+d+ICieDYPKBre1jhQB+ZmaGp2BUDZnbTkKAKZnZDl4gljiS1tbtUVrMne+zJPmkD+09sl7uqYCanbdca2cR5dZuoQB+fZV3iCzciH9kRuvGwFqx5Ld8wFXfsK2f12aIolYASzREf80p8i4dCCkFiXRqUKwiCRV0RCMXn9k8IbUwgXQTDiMPGi1vwTj53uQCkLMSME3PoIhebOMWRdx8jDF0iDoxDmPq4JqYSJbnY4NuQIV0kkufiBw7MMVdmzm2VU4iMZ/YdOSXneuZygkVET4bciQWeCJmYPUK6nJhT1mLDC/GKjIqdMKCiJLYJGTlaaB6LP2VIh4/sIzSaQhREzXPOyN0BxtZ07QAhYCGmlGQM6XDBLSUZChezCDCkw7HfZd+OuREzBx8RBYXIuJVXzLj4I3Hwf+v2kzthIVTbRW59pFaYNiBhy3/d7na3O8Y/3BtvyVNSesT+mLye/xE3WaBaaEdZr9oxdKXT1kecmar9Oy3W8g8yiaNgjERSaOcVzqsZRbVw9ijpNdF/Em3rJgmpRMsCS7d9XlvWNR5UInVpGLZkbs/afF4Z+JjmsRY0EPfmcOEgBm7nu7QX7oNnU3LtQBa1kG0IgkRSmrXr/pWbMOT1vLVzlWaNlZqqTknFHWW9YmHPCP0B6/yCOJi459JMGXL9Y4bxRt60gdS1SdtDizYlRjavo4pZF1fu9TSbNgUqrxd0g0N64TFpdeNUzl7fPd9qThzs0IkO2kOQaeAIxpRYU7pRt9UoFbBjDinEGA/JvC7INpo3G8teGHJnNky0z0QmXOsNj/w+PTugoOJDntOVAVOT8v0i5V4npud5fFO958DusicGWOC2KMioWMk5V9mATNc8k98SlV8RKZ/n2dJ1rfGIH/SUIqvo+mMexT2+zj8QFB5Tu2SfveZCZnhXlnhIftbtMy0ll1mJtoaFWJHagC+iMff9Hn83nzISHTYiZWwH3OQlr8UZqvAY2XF7EejrLpWo+H6Rcr8TM801j/s+88Ly682MieizqCtuK82OSlzEoq3IteJSvkWtFSdBl0BKpIA35pq5PiNREwoxZNGA8we+z/N8hid9PugVczljxpSO6TOyu7yT7ylIXciAnfBUnXCnF2zqGybhRzxWuwwCxT+k5xyzgyehsDWxCjnpKP5ptuHTXo/bzCm5pRB4Ehal422fdPsMQ0mxSDiIA96kKefFhl8O+3R9uM4sEsGbfMVJ4GLqLouUk6hDx5cYC38y8fmnW5+9us/34jnvzTmL7C37vf8bu2KAEkNemnNOOSTVt6TFNVl5y0ny50grOTIP+X39AutpYjmiZyeuy6IiJORIjHjLNZUoyFjyb/yvmJYluV0QiC5vxDccmidooflWfM3H5jMeqkN+sG85MAdodh0u1MAredYUyg4f8WekNuWKO4b0uBA3HNjPeSl/4Bafz3hKbWoWcsp7+YraFoztCRsx5yPxhCU+ynr4QnFqj0iUxxtzg0SwFDdtqMKtvOKCjMfmKRExBRUn3oB5XTCxzjN7yJjU1ERSUaJ5Y27wC5dt3LUdEj4lFSmR7GOMIzxJOyQSPlfcccCYJRl7dofvxXMKuyahRyVKjuw+GzsiQHElr5wNSCiemC9d8IfYcGZ+Sy67nHDIQCQU9hjfBhxwwFys2DF7nARd5lVFTsoXfMoz+QqA0IQ8sMfu35Wi40ve5muWNqdjA27FW07NJwxFwktzxTecsyMekdslcMysrHgsj/hn+2s6YoRBk9gDhBAkyuN7c8bYHKBFzUbMMcKgrWaP+yQ2YVpnJKJHKlbciDkTO8S3PlN566YadoMQgnlVtgerD3qFbQp0z4y4NS/aJvVfrwgj2xHxNn4vq9xeMJIjh5kLxu1YFZwlRzcCpO3+c2vB2Y5TK522u16N2+HWTQCDLxscppCE3qDtnB2SMiUOd1tGdJsa9Afc6FD1yMVdO8bddo5CSCIxcgH1oiBQbi+tZOi8ss19BKrb7lcTtcOqvqIXHbHNMIYtVcl3nZ/qE3lDVsU5/egUJXyyet4mJSnluyJpmvxgW7iibIvmUOMEattEpK0ILqvnKOXIU8Z3YjNPhD923WLARfnPjumrRtQ2xwtCsvrOgTvqTeu3VipoASs978D59AK3Z9K2IlETcj1rSGIppXZjcF910bZ06nLh4Qkn/Frl7wm9QdtVG5MhhI+1Rauwjgn48/4EbS1/v7zmSIyorKHQhv0GHXra9ZkuYS+WRGrAt5sFQgi6voIq4X4vIFZQG8FjfURuNMPAZ1o6+MZARtziuhZPSAZ2l3OmfBIe0k8jKqspjeUTdcqvzDdcbPpoa/FtwGEcEhYjclOjhGQU+GxqTd/3eLUq+GzQ4SqtXZZwHfMw6pF4AiXgYTB0cYTlHnuRzygUbO72MVj2vQ6VjbnTGT0Z0iPk1q55vbF8OujwbF4SSMmpGjMKFZvaMisLXptLfhGfsig1k8jj8eYpFZpUa0Ipuc6cUj2QXbpiwsQ4EcuSlMsKRqJDate8Fr/jwD7lntxhSUGN4U+Dx/xT+ZJfBo94na/4jfmWSHQxxn2uvtZvOdocgHAd67s1HEcuenFTW5fMVHf5012Pd2vrbGOBR6Ed7/r9uqbrS0Lpkqj2A/cdOU81o1BSWcNYxeRGUxg3vu/IgJ4vKI1Tf79Zw7KqiJViWO8SqBgTuR3xF6OIm8zglycURrPjPeGh/DO+zv+fzOo3+F5ILlwz0JeHpHZGKpbcN4+4kg6ze26naCoshogut0XBe3mJsIoH5ikZBSfekHf1Hfv2PnesSO2annFFamLHrGyBQPDIPCJWHnOTMxVTBnZERUUkfO6bj1FC8tR+wtoWXDBzFioq7pnH1Bh0s3L6mt/QE7sMbR9fSHJTc603aFGxEHN27SmRjemK0K1E5BW+UFyIK0Zmwod6Q0HJrh1SY3gjHY72iT2lK0LuxA0Te0RGxRv5Ax+bzxiIMTd1SoeYOWsWcsqpuUdCwqKZLKzJeWwfc86Ve96kVI26uyMDaioemgdEnmJh3FSlomCoTvEJmbKgbgRKlVhzKW7wiVBWcVEKXojfO3SmGfC595gX+gIPSWk1GgMGFrkbHzsk6Yw9HnKo+rwyH4hkn0PzkD16vCVkIeacM+dnfMbEnvBY7fFcX6HRLGyKb7rUFHh4xDZA2RO0qLkRZ0zsSSsInQGn5j6B8Jix5kAOecmSyrrnHgrFtV2xFksimzAUCUsWTTSjT0/+DzwTv/lJtfUnj6MtTl28VRy7TjNo955bIdXW1we04QTb7ne77wz8nmMzW4PvJY0oq0apoKU9OU5yidY/KnE9FbcJR55K0LpsfrZo04/yek5a3RKqnrNA2Rrf6zSgj4q0uqXQKwqz5TtXTQKTbhXM4Dr3rLpz3bKtWdVXrtOsFy41yGxcglJ9R1ZPm/u9IZJuDF7oVTuyN9a0RUubgnVx2UwQCmpTtOP0WufN/VVk5S2Vbu6jdLSxQq/aXfP2tV2XH7gpvicKHGc3racY63KGt4cOgCTcw1Nxa+HyZUyqb1mVF1jrIiorvXH2JKGoTUFeL5pUneuGjZ1T67XbK2NapjW41CshJEp1sE1QhWiQlStS/nZ5yW1u8PAQwlEF31ULfClYlprb3LCnOkxzQ6CgLyIUgl9Xr3hrr5nmmueLindZSmpqClvzj9UzVjbDR/HP9r9yYA4cucemjOyIp/4e68pywS1Dz+2IAyU4NPfpB4raGvrEaAtKCC7EBzrKY15WbHRF4glOOgFv16XLFjaak6BHrCSvVgV/M7tpLEPgC8m7NOfVsnb7a3mJFPDO3HIu39DzPPytswDNsjR8xwsqa5hEHpvaIoFREHJgd+kHkoUuuMpK3sq3RMLHF5KbKuNb+5K5cMEhXTvgWrhuaSJ6LheWS+biA8YaVuKOja4YeQ7HtyhrBmbMXVFRULA211xUv8diuGc/YdSEvIc2bMeYT/queK4rw+fyIf+Uv+XXU813K2dxui1KLqsNZeM7r61DjL5dF+zGilwbVlXFbaab7xYoBJnWvKqmfDwI3U44dyzry7RGW+P84SR8LO4RqRF3OuOHRcmy0lzqJZmt+Jl6wpAucbDjwh4oXNfv30cgiUSfzM54Kb+jZ4YoFKlY4xOS2C6PuceF+MDK3iCQzMWSmJDSGDZyyZn4hkpUSCvZk31ipcgouZJX/Er/R97Kd1zqBRfyfWN+FBzIAYWtuZLn+EISCsUr8RtWcsYx+3xkn1JR0xUhM3nD0Pb42H7J0IxQSKfkF3esxRqB4pF5wsfBHrnIuMY9l8vqG96IM6c5QdAVLqmqQjMTS3wbOmKVNVRWc2yO6HvOCb5jj8moyE3dvschIbHt4AvFnuqQCfcdrqkJhaISBRMvZiovuBMLDJa+7+ETMmdDqt3n3mK4xyGf8BEFKX3b5VTskoolgY3o2QmpnRESUlETi0GTseX2wd1GuX4lrlmR8ly8oqBmLZaY5ncfMCY3mmN2kCgq4cSBvvWZiw9uT68kqVhyUS8Z2wGX8jV78v/P2n80SZZkWZrgx8wPC1YRxcCwmePw8IiEVVld1F1Nve8f0L9vFkM01D0zNURJM1PdWQmiMjIDebi7uRs2U6wqKvhhZp4FPxGP3HRF0aRuzMjdVFXAk3f53nvOdzpEUrFj7iERTMWCgXBUqz3zgKHt8UpfcckdEy44l2dccE2fFitTcmicdbIj4saNETgsKBFvxRmVcBjSU3nBB/kO/Qf3x/+zrz+eHS3jTdQYuJAGbWs8VTuxknQj0LV6+sfRZ7HhQfueCyzQuqQSGVK6LtNlBDvKlDEVkdcjr2d4IkA0qT9r6IezPLnM3UqvSELnnS30YvNYA6/DOpM3CXcoq8WmYARex+1uRUShZ268Ws/IGyVbO9zHmnpDz1orio01hLLNqhllezIEue6Ef0xdysyEyOs7RrRwOagrc0ttHTUobtTWiRoyyV/TDvco9AJpHWxk7WFOwp3NiH0tcOt6B9zpV5sVgKeiDZZTm2IjDlMiZBQ9Y6VvkMKjFey4bhvpxHNWk6ghmZkQS/e6t/xdcj0lVF0KPXcBEjIGf8R49R3alkT+dhMTmbvAjDrFmJKinhH5A4wpkSJAowBNEu4TqQGhDalsRcsTnNgeVeO/LUTBoq4ZhQHf52PaxDwI2ywqd6I+TiLa5QNmddUoqhX3Om1Ol47bM9ZdLuUHFvqSSmc89/6Zi9k/0m895afqf+C8XAEtnnl7HLQ8Wh58N60YyoRRJDlIIn51l6EEdAPFo/LQ+XpLj6T5aLQ8QaIUubbkpuaiuuOwHhJJhTGGeV2SG0XL87jUYyK7wzAIKcoDgkDwkdhlWm3xvlzQExFuIOjGrp+Ix9xrB8xKh8NMrQOBZFRcpjUdFfDKnOEJn9SWbHsBfq1IbBcE+AzZF1toa2l5nvMp2iELXbJtR9QYZIP8m9YFt2LMEbsceT20tfw82SFc/An/WPxfeNj+91zwjpE5YEf1ESJmJ/a4SmvOU0vHVyghGMWSL8oTamP5ab/DuDB83PfJdYQv4bd3OSftiJdzt7Ps+BCpdbCLIEBhLRgUp+WCQzXgdOWK807scZ3BSrswi5OozbgoudYrpHDxd5nucqy2+CQZOF1AXnIYx7wrnJr4qvyGa76jH9yjZfvs2BMAJswZig43dsaW2aagIBcp3/OKj8Vj3lpJLWqHfFQJudH0zBaJcPvStnCBAKf1jDPxgifmMwZqSGQC1xmZQ27lNRPuyEyCRBLbFmlz3/mYn7Ptx2S1ZmxSeiIhkoqR3mMultxTI3RtaMsAXwrC2hl2AAKhGJcuHOGdOOOB+Yit4Kdoa/me1xwEbcZlTiJ9lBDExmdlS47FNqXVvJdv6dkhfbYxWJ76O5yWy8YC5MbH99SIHdviTE8ZelsUVUYhMu7ZQ2pr8Al5X094xFPeyjfclztcFhlLOabPAE9IR2kjoef7jMuCn6hPuCPj2sw54AgfxdTCljhqphABBk1llyzJaeEzkm0Wxu1Wtag5MscMvZhbc+mU0FLx3txSozlgRG5nFPRdHjcJXfMJkfD4Vf09A7NNR8R0lE9ZP6YVOFiPRHIjLxmYbRZkKDw+iYf8PrvBtz4dEnI5RFmnkj+II15kc3a9iPN6zlxM+cy7R6gkL3K3ttozu0zEnD22GAY+L/Mplcz/qNr6RxfhZXHx40gZRV5NaIUujWVtH1r/fT0attYgpb+B/Zt1NBr6x92kcMrkQs8ccUvGLPLzjUq6qKZNofObn+9+bmVSsIa0uKEdHWyERusd5RqaUdUrSr0g8gebvOC8ntLxDwhUm7Qcb6IQy3rBqrh20AxbNSSo5Wa/HMr25u+VcdF5+g/Gxrl2e1Rjq82hYB3RaKWhMhlFdckgfsiyvto8H4F0OMwGH6eET1nNqHUzSbAltjbc8WpDF3MMaQdGUTIkCbZYlO49WpmCQs6pTUYn2GdZXTnYus6a6UOL3MxZlddEXo+qTom9YbPT98hKByRYW57c+05zKKg3lqVKu4AG1dih3C48BTQg8FTMoX3KUdDhvFxym9f82v6KEScciiFP1A6p1vgSjrw+r/QV4yLhJi+prCaQrkPdi0JK7QRSWR3zvp7Qp0WbNgvxI77TJUIZJstv+C/Rgk54SF1+5fCdC0fCkggCKZgUhnlpeC9O6VQPaPsuoGFeGr42L/lUPmJVG96uShLpURlB3wsxdYd3XHNstp0mAkFuagbS56fRAZ1AMi/dyLXUlkVd81Z8oGP7+DJhX7Z4W01YViF3OqNfeiwqV4R8FKMwZFpKlnXNMAz4n+IH/OfJDbtei7y2vJFv0VQM7A4TcU1l9yhtTVqXZBRciFc843NSSiICKjTaWorGhvMDLwlMTGLaLBZthjLhqP1nXFXPuef9HA/FlV5wHPSYFIapzklXHp/1Y3JteTF3POAVOdtmxHVeshtHlAZmpTs8vV/WfLC3+NZncRtRY+jJiJ5UhEpwlpYkSjUJSe7xfbA3eJXi82iXr4vvecJjBqHktoA7eYPEY8WEE3HkCoUYMSlq+r5PyxOURYpPhDYleTWh4x8w4wojnVI6Y86e3WIhJ2BcrN+e3eEbfsk7uhgMt+Y1PXnIaT3jyOsx4w6DxrcBb8U1J9rtW3ftA7aDGIj5rjpFoAhtyMAMuZGX7NhtzuQpAInwWZiCFRkX9UXjrU1IrWSiKwyGyMaEUnInZlyS0Sq7rruSP2y41hJFYGP6ZsBUzDHaci9qo8uaV+WtuxaN5EK85C/Un3Gmb1kZnxYxH/GEhXU2wTkrPtTv2eOQQCre8Z6B2ablKSyWhZ3yTVngE1KKjMLWLkrUP+asWqIxtGyfH3hHiy4tXM7y2KRcyXcUdo+i7JCIgNfmCk+4HfSlPKdjBlhhmIsbtu2IkR/x++qaHfGYc/mKtv6U1/IlkWyzsmOe2S+JhI+SgkR3myZGMqkcBvnSSlpixMC4g+iNuEWLmk/lA4b1LjN5xw5dFrpiIse0qx/dJZ/LJ0gpeFuPiYm4LSoWckJoY7a9IQN7n0xrlhQsK8OVPKWotxmKLj2bkGs31R3LK0IbM7BbKKu4YcbvipcMxRE32Xd/VG39b8JWuqJTkjShAhZX+IytqayL3jKmRijpRFC48e2aBLUuzhgX87f2wK7DIOpmxLoWUQkkoe/wiuukolrnxMGIVXGJUsGmEK2VaELIRkjlyFTGVpv4QyWDTaGubNoIuQaU9YKwUSW7rjxowBe++1m4n6VtRVG5rk8ICcJxdKXwiGSPSfEGbd1eWgqvCbhYoW1By3MsWa0KFI4mlgQjYjlAU6FtRVrdbCYOVb0i8J3aOq/uXNZyw+6NPDdtWD+2vndMbR1hbH3QEUg63h41OVL6GFNtRtEAkeyy5GIT/ZjrqSNrNfv09ZcSDkVa1XNE4xn2ZNyMqH+0SAGN8jrAkAEutEIiWdVu9OZJwUn9EQGK1FbsRL4j9dSWmzrlntxBAGfccl/t0A0E99qKX1xX3OqUgYx5W4+577kdmEYzsDt84n3E35T/W4PW1IAmLS4oqgllsuSR/DMq4yILAyW4LDIOWm0GoWQxPcKXgvMsZ05GYkKeyAdc1gtUrdj1WqS6RmPp+wH3k4Q0LRiEPou8hcXtd89WFdO6YKty9qIX5pQnHGFwXX+bGCUEv9fv2GWHndjjbikYFxXaWgIpOYpChpEgySX/99V/4i+rvwJgINrEnuQsTwlFjBFhY315yHYU4ImQQlt+Wb9nx95jyw/5vv6aT/gJbRGwMAVdEeGZA1rCKZ4vs5IfxEvm5oLx8js+6/zPxDamI2K+2oq5Kyyvlil/td0h0/ByVhF7koM44rAlCWSH0sAoDJhXlo+68HzO5nvbeo+0NpxVS/6s3+fNouJ5NiFpoukGgY+qFDObcs/v81DvstIVaW348+BjKgMdH1rKI9It9uwe7+RrFjbjyOsTKhiEihfpAk92+Er8hDM9ZRHso03Bbfodo+RjuqbPO/E196w7mPTskFQs2bYO/jLknvP04zOSD1kyZlc9JjeafbNPIn0SX/FtPWdhMypR0rYtxqVTkBth3FQPiWcdzEEiODbHTFlihKXG0CKmb9qcyXNqUdM3+/RkRG0NC1vwQ3WNRbNjdt3eOQhIyk9JbUlGTp82h3HMhyxFWQdrWVWGE3PfWXxsr7E6HXBRL/GEQjbjdd8MkAgiJenqFiucUBHgU/mIYezKwD+ll/w0eMg35QWHjNDWEilFYv3N9Gos7jhkl4lZkRByZr9jxA4LMWPLHvBI7RAowYdiyUpOOTb3yCgbD7bHkjlf8BOkFFxUK1py5Py8docf5DcEJBzbA5ZizMKmnIsJpjZs2z0GMuZdsWAgdprIRLjjHIDUVGwz4lycURrDSLapbEmkFAGS7XqbJQUBCi1cJnduajokDD13X4lE2+FAAV+61YJvJEoKAhOjhSaSylmRLLwzX/Mz8ZesbEkkfNqEaGtYiR18G/yL9eb/aW39o/4VLn0nClwxK/XS7VKrxaYTXKfpgNsfCyRlQ7pac4hdPq0LHIibgrGmW1nrovc22bm6xJPrsIiCyN9qRF2TzYi21vlmVKtkSFkviIOhizfUGQSuoBfVDE+uBV3ZZnzrhGKqSXJKyJuAgkIvNqH16+SntLrFC0Na4R510916IqDUjpaVVrebwp3XUycws8VGmZ3qMXk5wfcSSpviCUf0WurrjQDN2BolfOblB7cnNzVGVJs3M6sm5NV483rUOiP2t5jWHzaj63VB7AROObpGUmpT0goccjOvp1TKKcGdnau/2VdbzMaDLaxkWVw2E41gAxGx6E1W8hpr6Yq/aSxKIZ5qb/bR2lrmNueDnjBgi0B4aGv4Np3QEwnWeoxUwpVesCsH7OFEXK/nNd/Xl+wxpKImkJL7ckjbl8Reh7f5gpm442+r/8Iqv8DodRcOUTCiqKbcLX7Lwjtlu/0JfpHgEfLvk8+Zl27Hqa2zRbU9nzfmLbviMY+7AW8Wkp3Y4zeLOx5HffLa0vIEvhQ8CPpsR5L3ObQ9n4tVzVboMQw9ztKCk3bI85WbHvQ8nyf6HoXQlMZ1ZQCr2mx8wDuxz9s05WI140G1xcvqmj+T/5aZLnhvFhyKIddFgcVyob/hSH3JvueiD5eV4aJR5LdEn9CGvK0mnPARSwoq63Elr7lvD7mWV+yZPa5zwW/5Z/J6wqq8Jgl3admEnkjYjwNWNbR957H+dlKz0BWvxRt2igOeJV23A5dwlVlmZU1WSz54HlntDjqvlimJ9Kmt4eNWj0VliZRky7T4Db9kiyNUscfnnS6VgWVlqKzBYHlV35BUjgg1ufUYhSF+7fNBvqNnt9lWbW7qlKu5JcRjLG95X77gyDymTYxFU+mUQHWobMqZeEFb7LBkTkVERYkRhjlLHvs7vKmdfWnXHHErlhyZx1gJZ3bMsRxRW8NNleGLkLG85hPxiDudEQjFwrqOcWiGdGTIW84Z2C3GYkbXtlnICTu2R4hHKBxhK7ItxuKUKV326HHBHSHhBjfakxELU/CuKGiL0E0QiLiwd9zkE7YZ8Nz+gs/Fv+G5fUshUzp2yBV3HDJq0LSac/GGLtuENmTKklykTKuQEBd2MZFw7PUotWFSaK7qFblc8bqYciBG3NmVy0o2PWo0c24YckAqFsyNawJGfkRfH5LZ3O1ibcXSTPnEPiYVTthVormVF2w1lLET9lmZkr0gwdQR18Qs5Zx90eOR/pg7MSOSiqE54kK85L75FHCY0DUYo2UDCpd8TCTaVNQkIiAUiqHZ4ZIZWtSbVc1rc8UjbxdfSr6rTpmJG7AwoMuVvOa1mfCl+oLf2N8x5ZKf6C94yQd8G7JrtzC15Z49RACVMdzIU0qbcs9+ztSmG1TnTN65iZcNNofvf9UiHPo9Zwdi8WN4gjAk4c7mJixY25g0ebXA95JNwVr7XoWQmySkTRjCWtDRxPOtv8p6Qej3yEtXEKumoEjpEavhJiQCHAVq/TuU50aoflPEf0QwrnNvXQxhKNvcFa+IPacEXquiPRU7XzJyM5J1Y2NF7PWZ5c4atQ5SiJRTM8feFrEakOkJgWw7BXXkMk0TNSKKu2T1lFV1RTc4YlW7ztcXCbFsSGQoOuEhpXGThVB1N0zu0O81+9ct4gYO7pCWbkTvqxZKeLS8HSqbOjuW9Ol6B2Rqsgmd0LrEool9F+2mm8NCpVcbFbyvWhTVjLKe4ntdJMGGGx2Eu43Pe+33zgm8LrUGrReAdOB/vaJQBWcs+cg/5ER0XEpRVrIVRJx4MbEn0Ba0gTSNedwVvFtZ3nLOl+oEv/JpeR6HwYDrvOLazPlJOOJX6Xt8ETC31yzyU7RegpBgBSDJi0tsA4+r6lvOp39D6O8R+B1OzRN2opB5XWKwtBt2cy8bcsMSf9FlXpeEheRB0Ecb3MlZO1CFJx3Mo68iQinZTRTvFq6jbXsed7nmvj1kK/RIa8NHnYC7wnKTV9w394iUou1L9ojwhBPGJNLHt4pACnYYcGuW/Ly3xbJK+MmW4H+/EFRac6S+ZGj75EZzms3YVR0eRl0u8ozaakJ8SipifB60EnwJ42VIx/c5qY5IGrzifT7lrfqGQi04Cr+iNutYSE3sCTpK8Jc7CQK4yBTV4oRPe22UgN/elTzqBAwjwaRQbMeK48TS8SXfTzV/Mmxxk1tybXi9WvFxt0VsBd0g5OfxX3GdW2aFYV4ZjIVRrGjVkkXlcaRihpHku2mOBa6LnFt5TmK77DBgoUs0mi3ZIlGKqhrxTJ1QSePsa6WiHR1s/PM73KOyJXt2m0AqZiZnyYrIxrwqbynEklC08ZDc6XeMxB5CwLbp85YLHsh9fEIyXZLYPS6YsyM7TIzDPYY2pK8ilBC0awf179sOc7GkYwZo4W7GsVLo2mVNGw7w8SmsRllFIQom1jAUHRam4Epe0zXu870yJVfymr4d8DjoESnB7zKJLxQfifu8N7dENqZFwCv5lmfmIb6U7Ot79EXCqbjiROzRD0Z8yFesyFjqa7bkHr6EUsMrfU1CwtKOSUSbjtfjpqrJmHNsj4mkx9dcIpE8NA9ZUdIl5q4qKGTKUozZso6ihYVKuOeZiiUtnEUxExlLMadtD+mqkHHpFOkD4yaEC0oC4RHbmDPtAhmU8NlXbZ7rD6zElJaJWJHj41NREeKavkIUpNYjtbAUCz7yDqmMZaYLPCRbOA0ExtCxPY7YZWpTpiyZ2nMi0eVMTzjhCQUlQgHW+fBbNqFvkw0+NhHBJmdaCcFK16S2pEUAZouHYZ+3heJe0GNZT/91i3DgdVjll4339m7T7Wbl7UZ4ZWwFlk0xNNYJnGrjIvTW9CUHevA2KMm1/1ibAltrtCk3NiO3d/Q2xTEvJ5uueyNaEgFZNUGgXK5vlbqOUy//RSfu+MwlhZ27HalKqXXGylxvRtq+ahHIFquGw4xlsyOtVJe0unVKbwyh6jpSVcN5Xo+Hs/qOef1h8/gj3/GZ0+rWwUC8Pqv6hqKaEoQtKptS24K0vIUAinq+IW0ZW7lOulEoC9wu1sUUTvEaYRaw8VbPKrePslaTl5PGKlYTqi5SFCgVsKpunLe4sRHVJnPdrDUEXs+RsKxLRKrqKVJG2GZKkZeT5nvSDfzDpWwlze81KOXworc4gthp5aL2KKFNhCcDpBC8XhSMwoCLPCOl4P3KATyklVznBUPRJdOaLHNFwkNxlbnHMRcTFuU5dT1DILDN6w8gVYLRKbYRiQGU1S2eivn76n8lsn0Ekkfi55xnEk9I+rTpeyGRJ1BaclPm/Mmwxd+P52x7CUoIcms4Tjw+LGs6vqIycJE67EUgJVdVSobDFRprWVaau0ISewJfSC7sjAdqi+uspjaWMzsmsQkftbpcZCXLylkpMpHz97MrnoYjvpsJXphTCpnxwNznXFyxYsqQA870hCvtMZN3zOwlWxzRtT3O5SXLlUvfUcLju+qUyCacmSWHYo8Zk4017la/piO+oqUaCEQumZeCSVkxCHz2E0nYkOJ+N11yK8aUs106nsfrasyqHrCsPMZFxQv7gW7xkMvMhUhseRG/nN+6NQeKv07f0LFbHLFLZisMltokCCGIleCkLflPNzPG8pZn4oRC1xt70a/N3+ILd40t7RF/FZ+Q65hrvaJFwP9R/SOhbNOVe8zMGds8QFmPW3lGJUr2zT6vxO8IRZtt+wyNm77tm3uEeOzKp7znOVY/JRN543WHicm4lRfcNw+YiIx39ppcLmnbnqMuafcZcorbOaENmYsJITGXVFihmemATKZ8pu6xrN2efGZTzsR3fGR/xrk8c8EsxAzNiAv5Acw+bSIGZtjASmpWNdznS96LU1Z24sA9ok3LOF9tZQ3CQkfElFazw4jX4pSsnHPCI7q4lVYqljzP3TXv4CGJO7BQkniSAz0AAy3ls9AlVhpiQlaUFBQMZEyiFLJ64nb+Kmx29R001uUp43EqLwhtjETSNwNSSnItqDEkps1YXnFgjsgp8WzUdLsROSnaOqragC26tseNuGXHbjPyI66qtDEtGQa2S0e5ONHEtjmrluQi4739HbvyKSERK50zFE5UfNH4uBNCVmIPZR3zokPIe/GCwuxRigyPkJFs885eU8mCnCUWQ5dtzvSUfdXj9/wGKT06dkhi27ws7uiS8E11ysye/VG19Y/fCTc5s+uiUOkUT64BGN5GEbwqr50y2UtcJyrLzRjaZfU6O5K29SagQeJtdrubjq7JEl7DQYytN/SmtTirNjlxMEQItYkDXAcpr8fVSTAkCrZc11Y5sVQcjki8LTwiar/EEwGFXmxG2/BjF54Eo0Zc5tFWO/gyYVXfuCQk4eNJs1FHJ57rLGvlbm6+jBtutcEXyaZb9z23M478LaTwyeoxQigHzNDLzWsJbP7c7HKDQWMXqjY74j/s+DveHpl2XW8g244Y5u1wm32/EVOtU6+EUBt/qK5dJKPGdclrYIkQAdaWaL3aFOz1eNuY3K0RVIu8nFDrpfMHC59AdYi9Ph2xjWc9DjynMt+JFV8v5lgslXFWpUi54G0fj3npOgeB4l4r5uVqSUbJQLQ4l5d87t3nXTmlljVzc8l89QIpY6ytm3G5xFNth84UHsLWm8GQxU1UhtETltqJO36d/98IvA6D8AEVKQNzzLPqhES6uMLz1LAXtLgsV2zjkpVOV5pFXZNXFaoZ0W/5IYESPAraPE9rTpKYysBu7PP16o5PkgHDSDFdJsTKdeuJB3neQwnJaVo4ypYQnGWaQmQ8Fo40dJXW7NkdpBUulB1HhjpWW7wy58S2T89s8bF332E9oxaB7HOa5ox4wk7kMy+d5edOXJGbilP9W4pqxih+xr59xNNoi/9c/ponfMyznmJSQqgCRpHAl/C4G5HVFo3hvtjnZ6OAcQGLeY9n/YBIwWVmOLCuk9yPA1q+YF4aPvGHdAP3fP/38QkGw4yckUrQ1nJXFfzldosXM81VZonx6ZsBwnN2ri+6XcaLgGPxGed8z0P7JSOVcJHWFFbTIuDPthOKm5+AhaVYOViCDFnKOY/MR4TC44O44Mh+hLTuPTuXr3hqvqAlA0qj6doeAxyTe659agw1hn2/RVHtojEsxYxDc0TICG0NbduiJyNSU/FBfuAn6rHbn2pHVSqo2VIxC12yL7Z4W02ohONDJzYkEG3mLHlo73PGFQO6BEIRm4ecygt8M2IoE8YmxVjLypb0aXEk+6z0Ede4A3GFZmT2KKhpy4CFyQjx6HoBW+IeQggqY+j4CrJ/g2fcwdOXkqEeuuJnuyghuS0qPtgbhvTJtNOY9O0uLRFwwR1D2yM3NbmpuRTXdG0PT0tC3Bj2likjs7+xPwkkuXDEKR/FmTwnsW2UdeVnRcZQdMltRSZyutbtiAdssSRnKRYUInOTBQx3VUFPOttqy9xnRUkPR996J9+xjofclU/ZtqNmJ60IpKRnIjwr+SDfcWzuMTI7zMSUEzkiNTU9u80hI66Nz1B0afmK7XJAagsyETMTN9xxymfiSxKliGyXgdl2ZK0mDGKPHjtmxCU//HG19Y/6V0BeTxuIv6Mh+cqNmhUBVpiNb7XWeQP1T5G+/wdhBFkjzCo3VicpfdLsitAfbNTTod9D65JAtah1Tl5NUGJN1JKbCMOydgVV65KcqeNDS5p9tQuNAFiV14R+32XvNgVcm4LKZCxrpxpeF0Xfa2123+vdqBDS7VfrOxb6cqO4NrLaBCesqruNd9dajRI+SvkbIZmUHrUtNklO6/2rNqXL2rU1LW/Ioj5z43pZkZZjWuEOpV7S8rdZ5Zfu8FOvULIk9HusiksHT/E7mwJbyCVpdevU01FI7G8xq05RMqDrHTAxb8hLt1dvB7vcpS+bw8QayVlT6RRr64ZMFmGsdPtW4QGGsp7TiY+Zp0tAI4RHFAzIippaO1V6qV2XXZIxtMeMYkWpLZPC7f5Kbcm15trO2NIjtv2Ys2pJbSyVNTxSu+TaEgiPrgw5THxergp+Uf+aE56Qs+Rq/k9YLNaskDJuLmdDVU9cYTY5lvpfXsflFZMGXzoIHrDTekpFwaR+xzI/59r8jtNon8jr05Y7LLNrvuAv+SDfMNVDPBSq9DjxBpzrWypRcGwPuKsKZCWYk/E46vMiXbClYi7yisdRn/dphi8U+1HMq2zBvt/iOi+ZsmIp5pRkfChaRDZhLM8pbYqSJ4zLkplN6eLwgZ5R+IQUZAgBV/YVHb6iTcQrfUVMzId8hcEyE1Mik5CmMRLBipwts8sP4lcufctWPLGfMRFzXuZT/ObG9nKuGUWKy6zkrpAknqTUlsRzYpVLM+Pdcsi01GhrmJeWl1nNFRNGok8gBe/SktWqQmMo0bSygHutmC3RIlEe7+sJp2bMkRyy5Ye8nGt2E8UPs5yMipKKy3rBlmxxmxt6ts9cLGiLHULr0fIUk7LivTgloc3LmdufvrUXpGKBRJKKJSUZl/KKkoyAmJQlM65Ysssj8zE34paVcTSzXKwYmCEv7Ae0rIhsm5f8moP6GZlMWTBlYW+o2OdSXDnPO4qVyVjICZqat9WkscCcsqBNTUXLPETjICHvza/Y8h6Smy67QYxffcrELpvoTUUifa6Ng0DENqEnIwqrSUVKj4ihF3NaT9n1hvQDxfP8nC17gI9CIAiFx8IU+M2B+aU+pxIlPeNiISfmhkIuGdgDYhsjtSuU1/KchbkmEl0i2iy44U74HNun3MhLLIZbk7AntjDC0mmmJoXIHC/QwkqkXIslCp+CnEP2SG1JW4S8tL+iJYdoKlI95kR+QZcEz+wxlROm3KBFxZZ1li2D2fiub3hDjAtnOOOKHTtiYjISEXAqLyjJOLcVj3iKRLJnDqiomcsJwgqWYk4lCgb2AZ6QTJggkLwU3zCvHdGwY3vE+EQkvJJv2bH7vBZvuK0GDOnxTny3sXk+sF+QUrIsC3IxpxBdpha27Yhv7C94J9rcVzuY+l/ee/7/LsJS+sRqC2Nqp9oVwSZWT5uSWfqabnKfOBhucm29xsqzVjuvx8fWGhI1dB2l19v4f6FR9UYHrjCFO1DQBCl0NhCKNRPajaidV3adUyyEQtgfxUVrpa+vWhT1jDgYNn+fb8bF693r2nYUqwGZciPslr/rcoabkIS1ZcoTkZsECJ9+eJ9Uj6lNwch/TGGXzKoPG2yZ29X6TmnsObW3Zj229xgED5DCY24/kAQjinqO7yUU9ZxAtSj10o3GaVTqzTg/8Dr0w/vUtsDIirzZQawPG1k9JlDtTXrUsr6krBd0ogO0rVmWVxhbU+sUY0ucorkGmyJVgqcSyuoGpToIGSBl1GA9U1bFFWAAg9YpWQnapO7TiHYhHyKmZfs8jDv0A8H7pUFJ6IkIY2EQeqhyi7Yv+evyd0ipGNRPWNoCoUMmdc6ClFCHVMuIz+QThICvecHr6f8LGhSqW/es1fHrSEyJVG20SZsxugUUQvgupD55zDP7OVO7dIMpL2GU/Hc8t79ACp+O3KEipycPGdsZHesK8I34QCASCl1QiozItrhlyiN/m/fVzME/DMzFgi1idsKIvLZuxI4DWzyKO0gBqVbkNmVghnRFxDUTHgUjgtLnRl6y0hU3Yso2fQ7iiNMs48Dr8htzzrG5x9QUPOVnvJcv+FJ8AXrgwjDymrFJ2bPbeMLtu2/srLnZvmOavqMd7rnDKpJCZPxFe5/TVYd7vYCsXucoWx51fRo3Blsh+LJNZVrca0uiTAAe88oQe5LdcsBeHFAby1HL57gVIIBpCZPSsqos99shkRJE+RaVgcNEkTaHs3lpmNoUH48t3Pqi43nMqorrZn+4EGN+Wf0/2ZOf07NDnoh7BEqiJOzEPi+ykov8t2hTMIkHeIQYNIVd8ol4ysRmhCIitCHbfkzfHJGammsmbJltQjwS00YLjabiU/snXItbfBvioUDsMRa37JodMkoykRHg85F4yHtzy60854l9ypktGNh7tIncIUQGrIzPffUzeqbDB/kev3rAB3HOnt2l6wXcaEnR8KS7xoE3UluRUrCQdwxNj6x27OxfF+/YsztEst2EV7j7Q6ZrYuFEcRkVe3abqV1RUyNxrOn35gOeCmnZYxJC5qRsmV1+FnzMdZnio4jVQ870hLlw101ATLshBL4XpwQ65lhus2cOSURAPwg4LSWP1C6lMbznklfiFV+oZ7zRN5vP07Y5ZqYShqa36XI969G3ByS41DJrLUtyl7JExc/kXxBIyUrXnIg9FragoGxiFkPatkuXhImYuymF8HgnbvAJWZKxbUdMWXBnV4T4ZHLFJ+IxoZIU0rDQJXthTFYbXtuXjBqFe88M6dJiLGY8sz/BQ1Jbx3SPlWJZV+zaBxzIAbd2iY/iT+W/QwlBputNA/pf+/pvwlbm9bQZ64IMnETcFbuYwOs2O+Ngw3xeBwesR8yVXjnLUDDAUG2EUkXl3uj1rjVrds7rEXWtMzxikmDELHuH8J04K5QOZeksOI1PWZeNdcl14wBGVO53N37milWjDG5tKFtBszsO/R6ZdvtlbQpyPXXULdnCkyG1dFYnh790yMlmJYsSHpP6LVk12YQcRMGASq9YVg4G3/K3N1ODVrBDoRcI9SNTW4lwYylad81CqGbnmrkRe7i9EbutudDraMi0KUDrsItSLzcEslVxga/aGNwBpqhmWFs7URNuj2rtj/tUrVcIETa7VY0xBVKGCOFhTO6KIAprK4wpwZrN1VLpJcv6kshr8102RjDktijYjSJmNse3CRdZSdvzWVWWz8XHnJoxg9DnLl8RSsX9JMTQ5u+X77HW0DExt0x5tfhrlEzoxCfk1d0GW7q2siXeFvPibHPNudctRcmIoroi9Ht05R7+2uphc5Z2TCRatOWOIy3ZFlvWhZhv0eFK3CGsw65qKibinMIsNyI7VXmciR/4U/mnvC8X3IlTrs1LhuU9tKiZ22u+4GdcMyHP2igkBTULeUfH9viV/Xue8jN0YwV5aB/Q8jyo+1RNdjC4wIR9c8yzTpu/Xb7lhH0OzUOkErySP6Cyj5AIToIOd1XJey6oROEUweaSLY5ZBUP3OSvHnAfO53iR1sSeYpxrfl+e8llwxHPxPSfVF7xfFkxtyp/3t1jVhklZ4cmQm7xiL3Yj9Nuy4trO8PIBRy2fxBP87k7TDyT/ZXnJiD6+kMxKZ5UJlOCb6j0vZxGJTTgO25ymOWfyNSfmCafygmN7wJtyygvzD+yrT0nFkmPzgCTo8q74R+b+Njd0eVJ/zAfzgU/EIyLbYhQ94zb/Hoki1WMSNaQrdnhrL2jT4UZ84J59xvf15SYkwcfng/wBaw2haDMy+0zknDEzduyIt/KN+8zaPhNxzpARb/itG33KHSJ9QiEz2rZPbiv2eUSN5lxcERI1sXmV21nKUxLb5YJrcpa8khOW9T1iIpYUhCJBCcmYGT3rdpcAb+UbtswuhSg4YZ+MisR26dsO39gf2DfHGCyn4iV93F7z0By4w6O8IbFdFmJMJHtOE4NmLGYYDAeMeFPecSFesW8fEdMjJMSzHtt2xAIXaXgp5i5kQlySmj6pcGPyRHuEeLzTTigWkZCKBW/0DRUFFTkSRdg8l0txQ2QTFD5d28ZHbZ5fSMAH8QOhaLNjDrg1SybcoEXNQ/OQGsOdvCIgJmOOEZodPmfXDshxtLW+HTggh2iT28oR5NhmhXPv3OglS7OgZ/sUlFwXggpNW/SZyBsucdOCM3HKyOzxRr5o4C/bvBZvOa6PKah5z++o7MdUskCZEbUx7AYxU52TqOG/chEWEiVC4nCEMdVmX7u+ARpTI1VDfZKuG1kDIoCN6MlaQ1WnVMpZhdZM47V/VwnP0bKUywRWKiBSA9ZB8aHvLiBPOoSlE2jpTYJSy9umMimr8vpfBM+7G5gTOmEg9F0KUjvcI6vuHCLTlFR1Sjvew/j1Ji1pbbWJ5YBSLjeRi+DG9J1wj1SPsVa7zhPTAEUyZ0WSNZ5wzwNA2zmR18cXCYWZE8o2udHO7qPnbuwe7G6iB2uduX2yLknC7Q3+01ctLNplCJuM0O83JVBucpDn+nTz3wBqnW7ek3Z0wKq4RBuJtVVjcXL+bCEDsDXWVkgZOiCHXmJMttnBuvfYiZ6MWSvVFVKGJOEuD+Sf0DdtDC7FKKPiQSfhNFectAMWpYcUYCyctAO26z2HitRdp7xcav7J/md8kRDxlGsmXPEKY3KG7c+a99Tncfjf0bddzuUpoY1R+BCCxCf2H/N++feE/oCimhAF+9wL/pSeGTCKAjp6h1ld8dpMCMUTHtgnbr+mEm516kITlMBkAxLpc9zYHi7NDB+f2PfZD2O0tYTFZ1zrFRUVvojxCDm2+6Sm5GPvPp4Q3FSSqVjgW59KVAzNAW0R8hV/SSSVoyU1w0VwGMvvqlMO2SW1JbdVTipS/mmRMxHntG2XE7/H39b/QCIGLG3BvtdmXDpW9IAttHXCsbboMzQ97uQHtC0wJmclpg7+obvcDxPGRc3IDukHkr8UnzEIBHkUcChD2j6US8t+HLCfCLajAF9CZQS+DNix25TG7fq1gUddhbHwV2qfSWFo+4JlZYk999z28h12wggpoOtLtA359+oreoHkF7OS7eb3DrL/wFES8h/TvyeTK+7q1wzCBwztESdihO9Jinof4YGmYly8IPJ6ZGbCofycQztCCkFpNUpIIvMJKQW+9dkLWpTakBqfM+sywE/MfV7J5xyah/h4aAwPzUPGYsYOA0ITkoiAn9g/51Rc8JAjpHTPyWAYi7GjTZl7DGhT2pofxO8Y4DqsgdmmTURKwYQL9u0jjrw+5/UcibO2ndkr9tmh4/nc1CmJ7bAUTvh0Rur2uVbRtx0i4fKoL+UZx+aEvwp+ypt8QWVDtoOIaaWYN+KofXMPjSa0PhU1FRVbtscHccGQIfftx7RFyFwXtJodbyJ9ViZnINr4xmchZjwyT91raWM0mkhJKuvjmR77ccRNXnLJG3y7y6EckpptdgP3OSmqIS1iKmp867Mi41ANONQnDL0YTwj86jMmzCmp6JBwS90U3Yq2CBnylLav+HX1msDG5NYhOG/FmH12SGzIz71n3FUlHRniETIXNwTEdOwWEQGRHZJSUImKRPhcmpSFuOML8SnP7Wt863MsHlAJw9AcsCN6hEqR6m3HmBcxP7N/5ZjUtstETOjYHtPKka7zBo38X/v6b/IJu26o3iijPRWTV2NnN9ILlHCS8XVhxbjxaa7vnPK2aZSMrRzswxq0cQKg9biVP8BjGluBBiudcrqW2WZHLHxJUc/wZNSont04MmW8sTOtAyfc7yxRMmpETTXz/HSD0nQgj7Cx+2Qb5fIafVnbchP8EKouy+LS7cOb76lsukE/1o1tJ/a3nGq6mUhEasCiciSwvJzgR7FLTzIFM3O6KYxCOShJWt/9i1zj9XNyv9e9ztqUlHqFJ8MN7MRBUSLSerzZ4bfDfazVLItLynq+sYKtD1IAUbDfFPxlo2pPkTJput7CEXlkhK8SPBlT1JNGFQ+eSjZqdmMrynrKVvjIWUm8kNNqTmUSvuh2yTXUuNFjpAQ3eU0/ULxZFCRKsR15dAPFt/U1iW3zp/Lf8d5espRzKgpW1Q1RsIPBMPIec22fsxBjrnmJMYaO3CGxHebFGYk/omBOFAxY5RcoGXG/9W/JWdGzA87y1FGCSPlS/DsmYs5B2CetDW+021FVZc2R50ZnCT6xJ7ktClpEvJbfE5DwroRnPKKiJhMZQ9vnkoKYLjOb0ibijb4hFyv22WfCHA9FRYUVhv0opLaW67xgP4m5KsUm/vCH6gqfgG/F7zmxT5iKKRJJIZfcN5+i0byor9G2whchH+QPFPU9Xup/YODfY9/c4zjo8c/1dwgkSzGlrF1XHQcuW7lvd5mz4jJzn8GOCvjNYkKIz8u85EHQ5+v8ij9Xe7TW3uRUMM5r2r6iH7qUKSUEO5HP89WcQXNwXRqnkpYITGaboPSIqImVvChc/GKduySfCs1uneDjO7W1eMkX6hm/Xl1jRMVN9QM9/4j75in34zbzUpPqmrlYQA2vyr+lqGZ020f0xQEVBblxXOPn8vccmcf4uNXAQk5YVD2umKCsh5IuqvBa3DCyh9zISzSVo0fh1LIZKZUo0LZmIq/RVFw0kXhWGG7sOzpyh5KUa3HLnt0mo+TQPgVgLK9p2x7Ghvh4/FR8xbl1MZhzOWXbbKOE4Jb3pGLB/foBYzFmYLfYZ4fcVizkHa+tYSau6Iht7ttD9rwOS72gp0I8IZgJZ/OZVh23t5c3VDblmE/JRUqGYiouCUgoREZFwQ/8iq7YY2ZjbsQbPCJ67JKYNiPRYWELFmLGmFPadLjn99ClIcXwppxuQCyXeUFuKwKRsJRz2iZmIuZMqjkLcYeWFZ45oaZGC81C3NHRLqZzWVesKFmKJZqKPbGPLySP7CN3CJXX7Bh3IL0sSiLRYtv2mbLCYFiKKQvTwcfjrirJbcUwaFFUS/p2l8BGaOFCGPpeyKW5wrMes+aQYcwBC0pCEZOLlF/bl+zbx8zkmC3T4bn9nkR0aduIcztHC00uV8ztNaFo07ZurTqRY/Jmdflf+/qji7BSzjs6z96jRNCAO1yIe+j3CPwOtc6a7FkXwqC8oAmuj9G6BMVGgewgGlNEs9v0muLruuccY+sNP9lXLfKybkLng02YxFo8tKZxraMIgQ2GshMdMklfYRsYxtpn3A2OkMKnNCsir+eKmC02JK/NY26+lsUFmbxrOu5oUxil8JD47vE3XjKX16t/9BcL5bpufw+LJojaJHLAbfED/eAe0/LdJs5xrSRveUO3OzblBsKxzlgOVYe0HG881UU9x1MxkddHNx1t4g3dTdecs8jP8L3Wxqdt0WTlGCk8tMkRIqA2OVovUaqNMTlCRMjmUDXqfu4AJ5tuWTKKn6GpqEyKxbAqrgn9Hov8lFZ0iBQeOSuWdc1x0OMyL5hkSz5LhhSULCqNEoof9Cl/Lu7T9T1KbfntXU5p3YX9UBw6kYkIaJsON/ISTwT44T5ddUBJyoH/OXtmjxtxy0Sck1gXQdYND8n1nEC2ycp3aJOy0/mC0MaciD18JUlNzcQuOVQDQilRdX+DkPy33QO+n6UU1EgB94I+SsC4LCmoaYmAP5FfclO7InIh7tgVA1bWJ6fknnnGl70eeW35p/QCZRVf+A9ZVBV926ElA26NZSbvSGt34x0EIX+zfMsTdcQLc8qe3XGKWnFG1EDu50AhMmKbMJFjds0O+00c3bYZ0PceMDYZX6n/QE+ExKE7NIzYJxWu+B6qz3lb/oLYH/CR/RglBN3AY1m5jrk0hi86A/qBIK1dTOFP/T06vqDlCUIl+e24pOUpOr5gUTqP7rgsuM6dl7LtKwah5N3S8qATktWWu6Lm0I+Zl5pca5frSsmDYItpVbIfhbzLVoRKMtAxgZTs1kd0QsWBGfBR8FeMqTi3t0TC5yLLOWnF7MY+2W2PX1b/DwBa0R7z8pTd4BED22UmFtyKM+6ZZzjoriQRCT1734nJ6DcpVWMeip8zFB06nsf7KmBLtKitYcqKkejwg3jJE/sYg2WfLWbGTSYiG7MUMyLZxSekZ4eENmQnCmnXPq+0U87uGJcn3ZYBSggWumQl57RMjG6ygiZ17rj3tkMifbaNGwdvq4TEOttk23ZJ5ZzEtEk8DyUFvbqPwZLWhpCI2mq6vs+iqvjUfkGsFKGUpNoF0MtmuvhVcJ+bouSMmJ4Z0BYhgXVTxI+jbeaV6zKvTMojeUBH9xjKhFRrPsgPG6/vWEyJbUzXxkzEhM/FM5QQnBoHL2mJgEOG5MahMJ8EI35bv2XfHCMQbIcB81KjrGTJkp4dMGGFsopDv01Z1bRMFx9FIBQzpmRixbEY0TUJZ/KcLbPHw6jHqjI8t295wDHTsmLAAYc4nvrUuqndvC7pM0Ch2AtavCnv6NMmkh4DM6DGcCz2eSs/4OETSMWX8hNW2oFCtkWPru87BjoHKCQTXOTikd1Hev/KO+GsHCNDD18lVPWSqk5diEAzFnajvuEG4mCt2Xh62/4BaX292QFL4YPix1B5aza7PaNdETSmIq9dqIInHQlHSh9tS0JvDbaQm2K43ju7HXLeBBtoSr3EkxFl4z2udbbZH7ugB0moeqzqG6p6tUl2qurVJi3KFVXjkJXB4A8IUyW1yam8lKy8JQq2ANeh0tiH1qlHq9pZYlblNZG/hWoK4qK+3HiO83raFMaSXE8pawdG8b2WQ4bWZcPZXmzSo/4wprE0y83YPq3HKOGRhDvNQUGSN+Icax1kZZVfNvCUnLp2EYStcJeqTtGm4HH7fyBjzhfiU670gkIWLMQdc3NBWwypKCiV+/06qNx7r5fUOmHLHriAa7tAV20qqxmJDsZCSMCydh7AHbZRArLacYQHgc91oXlkHyEknMsz7tt7XIoxN9UP5NWde31jtx5YiQmX0uW5hqLNlXnlvOq2IFYDFuV5g9wMCESbyCQknnLpRwhiQha65EoXxAT0pM9ZtWQ+K5iKBR/5u2hreVdO2VUdcutsSRY2DGtPSOYseM8Fvghdt0nK5SKh3WSRVqLieXWBRRORUBvDWF4R2xYX1YqZmNKxPRZyzLe2YMENhcx4xiM0jjF8x4I9hlzYa4a2xxg3VYg9yVbRYz+KOcvdoaCgpG0DrguHVzzyerzSBWf2G0LR4Tj8OYGNMVgmZgVVm5bnIYHKOIb2N4slPeloTaEN8VceGW4KsO27Tve3ixkWw5Hf5YM84+f+I27zFEqwNuAwCZiXht/k53Rth9O6RCKpqbkQrstYVBWlrbnIHRYxKDzei1M+5QEDGfNNdoMVhneFphIFfTPgrXxHLpaI9FPSOuBGuMnaOmXN91pMxRW+9RFW4ouIVKSENnR7UGFomy6VKLllykv9D/T9EzyjuLEzxpVkIm/A7PJOfI1AsSf+jE94yrmdYIWhtppcLhmZPXKRsbA3RKLLjtnlXJ6S0CWvHfhlIs+5Z54BsBAzznnDn6ovkFqwYoJin8R2uZbntG2fymYENuJr8Q33ceEUy7qiQtMV24zlFbIJmb+rc3yhuJYXXNiaR/UjhJWEeORas7AFt/Kaw/qAlMJ146LHE/OMJTnP81tmckzBEi1qctt2TYzImZQubemtfENEi9fmij5d3toLp7wXU3oM6dNCWsGFfMeIT5hxw6/sDT2zzR7bvJQv2DJ7PPJHvKrf0zF93pRTQhET4+xgvyi/IyDmHodsWXePj0XEKVf8Xo9p0+W+N+S0njEXU3wbMjNnvJA+Qkp6ZouYgPM8IxIeW3abC3FHYhOs0DwX39NjmzP7DV25z1P7mIKCibjmXV0wrd/R8495aD7hXJ4yNLu8FR8QSI7MPitKFsaikJw1q6+iHJKLjJyMmRizZXdpi5CZTflQ//pftwi3wl2nGg0PydSdE1yh8VRErXM68QlFNcP3ko2ndd3JrYVXod/7kWMsYzdCU6YpQr3GwlOB16Q0mbLpksNNhrGvEtcpBjubbjrwOq6rrRe0gp0GFFI1DGff2YT+IHJxHem3HmHXNmfLf8CNee4yheWPBdRXblzdDvfwZMKyvHACLVtsun7ni25hrablb5M1hKzSpuC5fXig2vgiccIhNSTVY3r+MUt9TSfYR+JTyWzDuy70YsN6dvv0GKOqTZF1/mhJ1JCzZplTvOoGt+mpeIOsrE3lAChCbkbyy9wxV03TCQthaEWHPPH/Le/V7+irY6SV3LePuWHJrbwgsi0yO6MlR+5Q0DCvQ9Fmx3vKWLyhrBdUOuWaN9w3nxKgqKzmUatFZSzLyriTtpT4wike277gMnO7RiUE2zbitFzSES2e2Adc2zmpdPuVwOtQ1SkDdQ8Pn4KUmopCZCh87vE5AG/4FRZ3/SmVoLXD+/VpIYTLAm57Hp6WXJoZI9EhUopQST6PerxbumujG0gWleFh2Kc2lkt7jkQxMEN8fE7lBQdmjxYJUzkBC9tmj5VImYpLFsKZoRUeHePEIoVo88je57WdkDLhSOySEvBePKdn3YhY4dMzQ2bk/JvkKWdZQSgVLU+R6APO9BSDg/jPS81r+T0P5FfklNzIS9q2z5kteeRvc1vlvNLXfJv+RwD+p9b/wn7iYyzc5jU92UMIQceXTAvNz7c9zlKYliEtz+MpO7wrZ3RkyJZwWcCJJ/GloFtFPOtFSOBmuocS8LNen2Xl1hzXWU2kJD+NDthPJK/m7gB8r+PxZj4kUIJlpQmaEfFnwRHTsuIJ91jpGiUE970hudEOdqLn1Gj2mli5kpq/rb7mrnzFQfRTzrJ/xlMRx95P2TM7dFTA9/Y9j+wjJILDVsirld90WzlH7PJWnLHjf0TPDPHxuB/2WNWagWmjMTywXzTrN4EnBLGJCK1HQc2udQfvO3HDyJ4wNFtEwiexXXbtFoES7KiIqviIXT9hFCn+brnggXnCqq6Zk/Ez8VOmuJzhgdlmR3bZNn3eyLfsmhMWpGihUUiXtSsy9swhEkGBs4FFeHwuH3NRL5FCsEWHGoMvJAdBm1k15VxeEtuEnCUH9pBYedQ6IMRnjz6XZooDW3rcijE+ATOTU1Dy1D6m5/ukWjPVuUsXimKKonBCTzQJIZqKjufxafUZv+GXfOofoa1lq9rjWG1xWi7YYZe+iljoktD6ZFT4KPpmm0pU7EQBxjqAj8Xt2V2QRYiSgjYRB/IETwj6VZdrrqgoGMk2gZSUxhBIyZle8szbc/QsMyG3c7SoiMUAvxGIDW2Pge06+pn/BTObshe0aFUPKdGEZpfDsMUvq+95aB+gG7zqQ3ufWCl8KVmWGTuyizCSSlTN+H9KYFv/ukXYBdcbCj3fYCcFypGV/iBJaN0x/gjWKDe4SWNrimJG4Hco9ZJa5wghG3KT+3PtFXb85qqx6DRdaT13XRCQNR2RU+carHAF3Gv2kj8iLd2u1WIIVNtBRhroyHr8a63BeoaqXuGHLZdpXKcEfmfDdK5M1oi3XLKSEr7LA9Y52itcPKN1YeKh6jKrPjT+2xArDGl9R9vzXVawnri9r77dPOdIuWK6LsBrlff6AGOtuxDtppiG5OUdLX+bUi8dkUwvSPwRy0axbnEpU8Y48lUc7LruX0iMKRtxlcRXbfrJA3yRUFGyLz9iyRQtfFY2x0Nx3zzgrXyDtYZdc0KIz3s5pyf28KzHVFw19qUlUkYUZk4sfM7lJYlpI0WLV9mCgYw544oH7HNTO7rURepzoWdcpLAnewRSkoqUee0zZYUWNZfF182UxYnTVnZMKNoYNG3bZymm1BS0OOZSXtLnmNQ6lXpRz1Ayom27VGhuysylClGgheuu3ogpo3oHbWOWleCaCX3b4cVyxVhMGdo+EkEm5zw2n9BTLgVJUzUJRQWairYdUVGzEGNOzBMq6k0nNWKPgITItrm1C4yo8Ii4tQt8An4qvyJSEiUEb8oumcg4llu8SVe8kt+xY+7RKmO2vYSJvMFieJ4rDtWAXX2Pv8t/4B4nGLPLWF4xMNv8k/6GEQdc84Yk3KHvHfM9r/HyRzzo+OwlPr+/c532h3JGXyT8Xy/GfJFs80Z8oFdusas6ZCJnGPZZVYbUltTWR1rYiQK+m2X0/YCdIOHr/Ir/Pt7nw1KTGwe896TgNMu4yhWxUuzFHv945w5VWzZGCMhNRUsEvC6mPIkGjAvnjx6La6RRPLDHfDB33MlLEtvlSrzjfPlPSOHRjY7ZCT9BIrkX/zkt0yWwPgU1l+aa+xxyZ1dkIkNl2xvyUiqWVJTENiHGxQ9eynNWxYCYiAv5gS27y0JOqalY6q6bSkhHe4qJNkSoqT2jJUYYDCsxpW93GYsZVeGEiVsq5kV9zfNlxUzc0Ldd7syKc/mKyhwzpIdAcSvP8YxiLK/x8JnJO1qmS0XBGVekYkHL9pmJKTNx4+4doktN4dKxRBdphVP9i5Q35oa+3kXh0zYdpnJCQMJz8c8Eto0vIzp2i4VRXMt3tJpghJ7ZcslGYkhi2nwjfs/n9ee8tee06TKWV5yVEiMMO/YAgWAi5gzsAe/KGQkhHbnNeblCIVnICTPdYiYmrMSUSt8jEzkVBW3rRswLOWFhb3iRJVzId3SEI6vt2G3ei7ecyfe8rXMi2Uabmo7d4k42Pmnrc80cbWtmYsxT/RgPxS/11/TtLkYYejg6lhGG0Mbc2oVDXoo5RaOGDgm5LFe8l684sA8AeF1M8WXI0joM5lws2WeLXGve6VvatJiYjCvxhmP7FF8oVjgu+79qEXYxdVUD6P8xwm/dqWlTbDjQod9z1p+yJmk6NnB5w+vR6rrg+LJF5Ds4Rjvcw2A2iEa/KcDrohOqzmavW+sci95QnDwRYJvxticTwBUvFxyRO2tOM4YWwuX6SiFJ6zsi1XfpR54jeHkiwPcSrNWum/a8zf53HRYhUEjl1NaxHFD7BYFqEYoONfm/UD+7w0R7A+wo7YrE22JV3RB4HSLVxSOiFMvG92pIAqdurmWJMY5SptZxjtZ5BQOvQ67n1DqjExywqm8QqH+RhuTJCOX1iP0Bq/IaJcLG3+xhMET+NqP4mXtPbcUt7+mLA3p2G9+69FuFYknOoTmh5oiJHNM1fbcTpmDbbm9uCJ5qI4XHtnqMbxVf+vfpBg728EW3ixSCfX3iMnwrDyXaLl1JDzitZxy3fW4yzVxMeKC2ia3HqRmT+NsEqsWyuGQ3+JSuHTBjzNAc0CFpNn1NFrNtM7BdCg75Vk5ohbsssneciRd8bL8AYCJScrHCtwFa1KTMSEWbSteMpKP5PG61mRSavE5IpE/X96iKj+h7IVf1qlGPuo5vt1HNrkk+mR0ykDG3ZolHRKpvyVVGzww58Zq1hX7mDj2qhy+cbUcKuClKPm9t8e1qtvn8HZnH/Hl/i//37B27IqFnnML0IGihJLS8LazdwpOCeyrmh5VPIgKkOeI1v6Ir9nkoP+OLdpdVZZmUNa/nFQ86PjuxR9sXzCc+x62QYb3Ng46kNA/RBgahZLXoEUhBt+WRL0J2IoUnIfFgJ47dzywMXdtmJ7KAz9lKMooUkYJZ6dPyFKNYMS8NHRlirCU3mo97ERepQklo6x4f9yW/vFH8aWeLq9SpTXeigLvMI7MTrorfN7azJUI4EE5hl+zbe1RUDESbiV0SETC0bpoAuLjB0MevXLpV2+6Tmxoh3KErk3MUPgE+F/IDHbuFRJLYdsN8dvaxlJQAn4KSoRm599w+RduK+2Kf2DvhukwJhMetmBLakNiT/EWwz5tlwY4ZIRFsewkj8yUIuLVLPvL3mVcjEBCZIyyWqVhghQNXPFWHGCzjOqOvImCf0hqwUNiaa3FDaEO2VMyNXrJtB3zk7ze7zlajDA+aQ+Uuz6IBi8oFi+S25r78yonkjGVGTosB9+0hvcBHlpK9VkBUHHNezzkyx9QYXopfs8chF82krG+7PEraTEtNW/c4jlpc5wU946hcPTtwgJugR8cfcJ4W7vkqxbwe4IuQPa9DVD8hFJ5LM7I+T+xjXou37JsnzMSUnu2z77d4X4UUomAoOkzsCmMlu/aIU3FFYCOe8hGV1eQ24n7Y47rIeSfebbzFlQ1p2zYWQ0JIJD0+2BuOzEM6IsSXkqnOKckYyJiW5xGWHttx44HPQiLhEwqFNB/TkxErU2KFIQlGf1Rt/W9QR9/hey1HiCqv3ZhPusg/bUvycrIpvi5TOKJuukdwBbg2TnDlqxZSej96iYV0Qp7GmlSbHG1K4sbP6CISK5b1petgTb1RU1s0Zb0gK8cEXodU3NHytjfK6FB1yWz1L4AUtc4o5Hwj+kqrm42tSpsCIWXDufapRb4pzqHoYqXZFP5Vee06f8917Xk9RUu3p83rKTnTTUKSFJ7LOMaxrgEir88se0ftZRtfdFHNUNKxnrPSsY7LekEEVKyo6pXzMtcLap3jqcjZoTzniS70HCEkaTneoDydkExthGJ5OUabFKXaJMGQ0qbs8ogb3iDxWdgbMhHiiZDYOorTrTznsXlCQcZDjjgTYyqbMuCAsRi79wbjroFqwcxeMrNDHgQD/mlxS79h1t6xYCbH/Nx7xvPqih0GPO3GGCuhhjeLgrbnMTS7LGzF0hac8h03y9/RSx7SDveY6Hf0xBBfhKzknNTZ/rmr3vBU/RsueMk7u2Sg7lHVWZO2VdMWQ16I7/lSfIYyW/zOvuGx/RxpBXvBQy7LFIFAW8tAtPlmNSEioBAFb+2MXjGgouLX5hUdscWdKIlti0QE1NagUFTWsB0GfFuOmRmXgVrYBVveQ07EiOf2LTd1xEDGnMgRtzrFFxKDG9Xvxu4D/fXqjkqUXGs2+L/TVY3C56Zylg6AVGvySvNavOGxfehIWQ1h65oJO2LAif2CFXMkghfzjIedmNss5d9s9blIDd/nY37SGnEpLzHLXY6jFt9OmhxiY+gh2Y9ilITrTHNt5phZh5N2yD/drfii3+ZXizsGosWdmPHDrO0Soyy8XhTsRD6pqViUBaeloaBEi5qKklrUxMsTVrqmtDUFFel1i9zUfD/T9H2fnSjgNMtoEyHxNxhbgHZ06NZYVMyEo1UtrDuQVWg8JPtem7/Tf8tD+yWv8iljeY1E0TJdrDDcih8Zv46ZtMeOOaCkYinmzMUNXbbxCZvd/Cm+jHlsHDf5zI7Ztn0yKr4Xr2lXPZZyRs8MCQmZygn/XF0zKvZIRcpSTtkzh0zrFXfyivvmAQbraHD2CafyNZ4I2TEH7LPFc/E9x+YBV/WKM/mWjhjia8VEzCnIOWYfD9eV1rbmrblmTwz5QTwnLe/hofggz/hI3Oe5/Q6FzyEj3mZLzuR7njZCsxf6kqHtozFcynMi28YTkl/VL5BS8Z+zMZ/KR04gic+W2cYjIsZnz+xxLs/IxYp5tiSxCYXImZZ1MzA3m3G4wmdSFtyUhrfyFR07ZE8PqUTFfXFArjVtGZCaiu/t99QU/FR+yUBvOzuUTTZEsEIUXPOGEzkiM1mjXNd85B3yfX3J0hZoNBN5w011iZWGnh1iMJzJc6b2jEj0GuuW4b295Jb3hHzEO/E9H5vPUUj6Zptr5vRLhyL9df6BQmQccEgiPS70nFt5QWHcOikg4TL7zR9VW4W19o/KXOq2PiYrx4Se290GfoeqdiPfNaEpUC0KvdikI6050Q4KYVDS5f+u97ur8nrDi14XYiEkq+KKJNjekLc2KEy9apKBvE1hX1tsgKZLDTb+ZGtNk8I02aintS1RIqAbH1OZbNNlSiSGxgqlc2J/sDlAeCJACp9YDZhX58ReH4+IzExYFhd0wkM3qq/ndIMjcj1p7Do1oeyyrK8ANpnG/eAe2lYsqvPNIWRdrNfRiOsuHKDUK2J/LfoqKJsAB2NckIWUPj3/iNzMyKo7pPQbVbrryhJ/m6wes8zPHB+6OQztdb/i0H6M1/S778VzdrjnXltKDIZt6xSFqUjdKAeDh0dPJJS25kbc0m1EFD/Y/0IsB1wsf0UcDPkf4/8ZTwimVYkQgtSWHARt3pVTHkd9vimu+CLaI9fuEpyUjvyjrUVb6xJ8uOOt/ifK2o3awU1QPpF/1XBoT9HUVORUNmOfx7zWv8RaQ9c/4Cb9boP43G9/xZFxN5yeSKisbpjV7gOthCSRHr4UG9buMPT46+yf+cR+RiQVv7XfsmX2OJCDTeLNfXtIaTXX4pbEtt2YU5S0TJeH/pBlXeMJSewpfqiuGDavl8GSU3I/7PG2mPEkduPe0ri9014c8GK1YCzG7NhtnnZaLCuz6V46nrcJFzdYXvGegRmyrdrOM6lTvtb/iZa3zZ+pP+XTgRs9D0LFpNDEnuRDsWSkEg5aHh+WFZU1RFJt1M3gogYfdyXzCi5Sw7SsedoLCCR8O6l41vcRwOuFg3Osk7FMc2u5SjWRJ+gFkpYnuCss89Kp0I9aHqva8u1yznHYpuNLni8d8nMn9si1uxbuioo7u+KDeM4kf01ejfFVm93WF/xUfIm27vlvmW2n1hcpLZtwIy85Nidcyiu2zTYSgVhbprBUaDJytujwRr7lgbmPwRHOZibf2KsUkmEQcVO6oJGRbKOtO/D0RULb81yqTq0prMZau0lt6ogQT0hanuKqzDiJEwptmVYVN3ZGSEhbhOTWjeQ7jaJ5HXCxIuPE29pk4PrCjfUlwiUg2YR7YYdlpZmYjHtRm1JbUq3pBy7JS1vLQpcsyQgJ6IgQKQSVNUzskpiQipqeSAikW4nUxtL2FbdFwaW44ZBdhqHPTVGiENzaBY+CLa7KDItlRY7BZSf3ZLTx0h/6babVj06TKavN9OdtPcYKw6EYcm4cB/tJMOKyTOmriMJoXom3SBQ7ZheFZCZcvGc3UPxd+btNIMjKlqzIGMtznphnXIobRnbIe/mWxHZo2w5LseCRPOCtcZbBHbPL0IvJtOaleE1oY9q2S9LQtoaigwA6vmvSFlWFJySeFJzXc0J8jqMW2sBlmRIJn0gqWr7kr/P/L5fT//xfra1/dCe8Dj/IqzHt6JCyWlDqBb5KNklK645vnR28FjU5EZf7/8LKDa3pDz2wWpcb/2snOnK70GZn7JKRVhtbUuQPm/QeHwSblKa1+GrNt17vc6X0yKsxAIHX3QjH8vKOJNxp8nm3yeqpO2B4zgK0FvasYw3Xo/hVdUOg2pss5LS6/YN0KJ9CL4iFO0DkekKtMxJ/RCDdvjnTE0rjXgMhJHEwcnvoxre7Jj3l5YQ4HG1+7qq62eyxW8EOi+q8eU8mmzhI1aQqbVYAeoWDSRpXgG2JNilxsI9pDjAKRS6cvatr2ixIqWTJigmpmLvtqVkylPfwbUhsI6y1vJLfAaBFzZbZpqW2qW3BfvsrrtPf8wv9CwAe8Dl34oaP1X0uS4fQu84LHnk7XOclLeVxV+fklAS2xa1Z0iVmRclM3lBUM4fhFHfshJ+gqZjbBbt2C4XfRMZp3utf8ZpfkhbXeCrmovgVSgbM0teEfp9H5mP3vuCCIyySD/I9PeNG/33bphsocm2ZNLCLjq/o2CFLWxAQs2eO6YmESElecMmxOeSWBVrUtG2HbdXmQrt0l1QuOa18ajR922JRFqRyTt92NjfXmIhpWbElW7zIpnREzA/iOaVNebb6CRMxIRcr3osVyeoJ3/At++Ye26pNbS1LUzIWUw4YOfFXI5z6IM65sS9Z5KcsOefvWgWr279AW8Ndqtn1Ey4KNz251it+u3yHRPGV9xHLuuYsn3JU9wE4aft8P3Oe8F4g+S6bYac9amtY2ZK/G6csxYqpuOJn5nOGkUII8KVgGMLrRQ14bIWC0kChLa+rMY+CEX8zvaKDyw/OteueQzzemhuK1RYd32deVVwzIZVLKpNyL/5zzr2v8UTAqr5mIUsqNJV0oe0Zmodyl9TUdOwDLJbYJhtl95wVqXTTk1n9wX2Wucdt/ZJQxZywz/e8opDOW1qJkoKUrHSgiw/iOde0iUQbKwy+8SgrTYXmXJ6SM8eTIRFtOvR5xe+4bz7lvKzYET2+zq/YF1tM7IqpdACJnj1kKuasrM9ZVbEQY2pR8MB8xEyOealzEttmJu/YMtu8NpeMzB538hzJIb+ublyOrTBsVe7+9oI3UMLQ7FBScSM/4BM1k8UDYus3RUAxFmPm4oYzJJ/bz/kH/X8wkg/5RN9jLGbMxA2BieiaEbdM2RdbtG3M+9LpPL7lOQqfgdl2NLgm8WwoE5Z1Td2sbV7KbxnaI251SowLSZAIxialFDljTvFKj6WY88GuSOjwlffkXxS49/Ythc3Zy3eoRdF4g92evBIlP5WfUWK4Mq+ISJq1gmAqJ/g2ZKpzxvKUvt3lUp7z3mQc2Ad4wqcQGW3b5Rv+kXt8zjVuLfZN9Z627TpamRihrUWhNuP2G+Fek/dc8Ik8ZlUZCr34o2rrH+8TliESb5NOFAUDbKk38Ash3X44kC0K4UQXa8BFWS/wRLzpYJUMCYMO8/zDRqkc+v1NrGGgWuTVHXEwoq12mJbvXMFtisq6o86ru+bnOUylbPjM6z2qw1e6XTKw8dxqXWKVph8/3Nh6tK026u5AtUi8IXfZC7ez9VzsXWlWG6hGYecuh9gWBLJNrqebztyYGmMrdLO/draiH+kppTENI/vQEbe8PefpxaEtK5M5X690Vi0pfUyTj1yZjDgYOUhHw+QOZW/TUUeqy7w42xxo1klVbkpQUpZ3YE2T8yxdZBiaVMwp7ZJT+QGfkKk9I6un9Pwj+naXHs94ZX9HSwydz9hGKByW1DRjv44dEtmEl/ofkMJnVd9QVgvCpM1H9mNanmJeK4bCoQJjTzIIQ5SEoIyRIqbtS86WBS/FKc/sMy6AXnTcPKfQ0bCAa14ykW60tZRjZtXpxrK2nq6Efo9VfkHkDzlK/oRzznjGQyLlTrIdXzJf7m68oABKuODuFSU9EdENJDKXaNx49jjooY3lUddjeXeMryR9OcCTgrNiRaIUh/TpBUOu85JFEz/uCUkkPHwbOpYwARU+D+MOi0qzHXnsGJ/r3FG0buQHsDCyQzzrfJhI2DUnbMkW/cBjUTnowH/oH3GVad6WNbmp2PUT0mqEVYZOZ4+L9DfuurKa3SCm5UvS2vC03d4o1hd1n4EdMLMVfzqKuUxDvl7d8e+2hiwrSyAFLV9w0rLUZsQwEvx/bu74tDUg15ZxEfKTcI9mqEHLE7xZVBjrsR87m1JpLN8s5hwEbb5ItnmbpnyRbGMseFJwV9QMQ8kgjPmJn1AZWFaWe+0IX+7zZqF5XWzx++KvUTJk5D1macdcCofe/ISnTMjYEi18KdDasOWHCCG4rEoKkaOp2WGAz8C95+oZutn1tqWDMPRDn5/bZyzqGikEqalYkpOLjNCGPLVfcCWuecgRHc/DAKV2DOIjc0yGU/36KIZBhCw/4V7QozKuqx/qHhrLw7DPoGwRScXMFMTE9ESCQpCZHnOxZEvFPAo/4vt0zq7XYku3iDzFA+8JLU9SLe+xI7tcG482MQW1269WFSO7R4uAdkPd+pzPSU3leOHU7IQR86qmMppj9umoY+6qAl9JPuMveMsr7uqcAV1qNF+2drjMSu6pER1fkWc1Q5kwCD2e5E8pbc0r+R1De8TQ9tjzOlgLtYVrccOe3eFP5VeUxjCzOXtRRKktt1XOB/kDj8zH7LHNIAgpdZeZLpqJBZzELS7zgsJoju09+ioiUJKf659xpReMVAIatNWbDOdHfElfJNTWMBYzHnLEwhbOXld9TKexd7Y8RewJXqWucVFIdsUjRnTIbMVdnXMi9ok8NzHrB4oXqSuwxsKKko/8XX6orjmwu1xVKYkI2PIf/FG19Y8uwms18TrHd50V7ApO7QhXpiI3003+rQjUpmiHfrhRQONB2QiLfBk7NXAjfNKm3HSYSvhkZrLp7Kp6hW72xUqGRP7WpqN2ZKx881gBQr9PqDpkaw+y+bEopuWYJGAzzi6b3OI1kzk3041FaFlcEHidfxEGse7Q17YqJxT5EdFZmYxQdTcYykC10c1rCK4zdVGPBakeu0JezzZ2q0C1KHA2L2v1hg+9VqYn/jbz/MMmEEMouVGEa1MglNx09evHaGyFbIRD7egAgeLGvmFbPGBk9rg2P6BlxUg+RDbFbllfIj1FKhYU9YxKpBRqQJ9dHpgnvJEvSO2U9zJjUr2j5x+hq4JudMzt8ve04yNXVJgxy32u5Tl9s01IyCLP2FUdHvd8/mb1ll2zQ7+KWIopI3PAubhFU7Esr9xzkS0uit9yHP6cnDmz6pSWt82seO9WHhiSYNuFjAQd+sE9DsOfcmAOEUZQUHO/F3CZ1mgLv17eUoiChfXwkGSUTAofIdwe1gIXK/d+XcoPTGnTLwfue+76fCe+5kg/ZpcOp5UbTWlrGUUe365muGxUn1t5zch2aHmK7XJEJHyqZnLxu/ySfbb4ernAYBmIFgdygLaaWzEmsgk7sktlDZV1VqlpWfEhS7mQF3wZPOT304xfmb8hkj0GDHlenzFiyJbZ5lS+ZCf5lHl9zgv1eybVCUWd0TcDdusOkZL8Sj9not9yqP4Dl9zx+zuP1DhAw4tZtSnavvS4zgWxB7mGnkiwwKysyW3Nq6xg20uYV5ZOrUg8yaQw/HP1gmNzzGqp8JCcl0vO6rfscMS3qRvtdn2PfqC4SGt6geIu18zqikR6gMfvmx05AnbCT5jU75hbd2j1bUhoQ74W39ARW2jb4ev6B3I74171JTui5wRXVtEh4Z08I8NpJx6axxTUTMQd17xkII+ZFgMqURHakJHocCmuWYgxz8wnfJBn3JkPHNiPKK3m6+qcgd0ixicQClAI65TCU3HFvDxiJsfc1he0bJ++7TIVc3zrQ9ljbBeMTIftIOa6tFwzYSZuyJnji5hdM+B5umAlUhZ65rphc8d+vk9Bza08BwNdHLgnQLGoKr4X3xOKBGl2uKsXLpDCaK7lOZqKA/OAb8oLcrEkFDErG7GsIuctNppIeOyYIzwkr+VrpvoDrVXCXMyI6gSv9pr1XcR5NqFDwpW8ZlFf8pH8jDsWLGuPVCzp2T4Rjof9rXnHkjF7POC7YoWyjmEQ0qagIqNEVIJv+S0IeGg/IdeaD+VyI4wbyysKvcfczFD45HIJGt6Kb0jEgLlpcaa/pusdcE3EUx5zyWuwUAtNVhVcyjds22MiG/N9fUmvHDrGu5hwYI4QKN6ID+zZvUb13WVap9RovjNTfBEwskN+U73lWBxwXq64FK8RPGZb9Mhtxcre/msX4ZrIHzhghilcYfEd7MKFKHhI6W98rkqGlNWiyR+O0KbA0BRrWzuvrWHjhy3rhbuJ+iMKPXeFsEkFWpOrpPQQdi3IMk2X6G2gH3k5IfDd342psFa7nODGH7xWVRs7pxXubxjQSvhktSu6QcO3DpRiWVwAPyqsA9Vusnj7GGsozXJzQEj8EWnzWoV+b+NRFkL96FO2mkD1KfScjrdHaVOKakatAoKgvckg9kVCqse0vG1W9U1zQPFJ/BFZdUegfvSfSeECqQPZ3timpPA34AIlA4RQG0KWtTVhs18+sh9xK8+JTIKHZM/7mKUdI61kxD2U7zOwB2yZHj6KqdxlJsf0zJBCFFgsQ3NAnzaFrdny9qhsyVJdsqquEMLDEwFjec6JeURLBGzxBKUE25HPtNCc13NaaY+26fIgcR3M3vKQh3GH3+WXRLQ3QR6R7OEHCbf6NQ/EV1TeI255T1kv2G9/xfnyn5yfMByx5T+gb3dp29Ym8/fQd1nTV1XKx50Oq7pLICXWupHsSLaprOEkCThdlOx7LTwp+MI7Iq0d9zfw3d6v4yu2zM9ItUYJQU8kaGsYhI6X3CJgFIb8UNzyiBMQcFVmGCyxUsxqt0scNerwkWnT9hWBFLzI5jzwtrEWt8szBR0ZEnuKrDZESrHl+VyUsKhr+n7A0/LPkFaQiIAOMcMwoNSWl/XcTTzKCdPqB0z3L0gYIJD0AsV/KV6xZXbZlUfktiIhoRsoKAET88nAJ9dQGsUodJOCl3NDP5S0lMe81HwyCLhMPTwp2I4E75aaQAoqA6+LCW3RYzuI2E0UL+eCUejzkM+ZlxohIFJORa2tpTSSyBNshR5mCS1fsqoMSzFnz+5wLW5R+GTlLcav2fM/4da+oyf3iGizZ7fp+wFUT6mFJiTgPRfs2G0sDrSwZ3ZJcZYzjWEuFuzYbSISQhPyIOowLWuUFLw3twybCY8Qgvv2mI+9+3R8xYcsRYsabTU7UZtV5bjP0ghyE1GILkden3YdcyvGtG2bnoy4wVmUIummJgaLBHaChHm15Ev5CdO64JobJ1JUfd7nLiAho+JjeZ8SQ0+EVPoAg2E/iumHktOlOzTt5ceMZJuUCo+Eu8Yt8sg+orQ1ZcN8/0g8JDNOPHUpL/lI3KcXKLqB5BezBefCCccqccL9uM2qag6ExnBtZ81+XdJXEULvsi3d67+sfPoi4aNowG1R4RtFR/l8wj1+0B6Hqs9rc0VEzAf5A1/wE1aUPEhaKCEIs6/ITd1oI3yGxsWBVmi6duBWQjbAYqlthxifz/k5kVAgYGC3KExJl4QpKT25hzIeR2pIP/CYFDfcUyOshVAfoTF0hPP6SgQeiq7ZoatCVjrnVox5qg4Z1xnatolsTFsGHJl9lBD0VcR9/SltEbqdsPCITO9ftwivi+06x1d4chMnKITEaieGKnG7Yim8jTDLmh/FU+sutZTLzc81DWCi0LNNp7geHTu1tNsru5QhJ9Ba86mrerUJe1gX302X3nSejuo1g8Yf6/ysOTnTjdUp9Psbq9WP+9R0o4QGNqKptCF5rcVTq/Ka2N+i1hmL+nKjem6He3giIDd3TVJTG2MrWt62Q9SZFN9LKOsFi/Lc7ZvLayKv5xKRrDto5OVkI8LKqwmVXhEHow1sZD1FWCvEja0wTZSWkqHzIpsSQ4lpQB4AMzlGokjlEm01KW5HPbbvWFU37AQfAzAVCzQVN7yhzyG5SFH4zBuf5Xe8JBEDpvoDbbWDJxMW+fmGCx4Q80G+obIZ/2P0p5xlBeBzV68nF/Ag2GJZGWcXkRfITPDe/Ko5QNzSDve4XP2GfvwAXyYYa5iJGyQeB+2fc5t/TyvcpeMfsMMDzs1zvlSfkZrajfdsRW0tpbHsBS0u0opIKuZ1yYN2TFd3OcsytvyQHxYpd/KKYe3whYUxbEc+hXbfL3HQhrPGA9lSvoO44zHONZU1DIOQcenoUM95wefiGR6Sngr5jfmW/771BX+XvcSg2an3eS1+zxflzwikU/Om2o0VjbWcyzN8G9Iu3U7qvtym1JY9s8c38lu2qj325RZ3ZtXsrhWTUlDYmj3xlO9W/xG/yVDe4yED0+VcXnJXJPTMFl92trjLNWdVI9JKnB470pKrzPLL9Iwt2+NZp82kMJTaIAU87HqcrjSLyvJ3xXOe2IeMIjfC/26x4Gmrw1xOqSi4LNtNhrHlIi8Y2zkn3hbPzXv69YB51WJlSgSCrTpCW8uVXjA1ExLT5r484Ll4QWZnDO0R1jor42kjdkzlmJH3mBfye06qR4zlNaGNGdBmWx3xUp8z4YL79uONOhsgI6dvuyTSJzUeCzHjOg+Yk5GKJTNxw1IkJLbL0ha0RcgP+pS9eodIeCjrudjJIuWAEbmtKNGUVJRk7vkxIBMr9uw2hdUsuCEUMbU29ETEnV3RMwljO0fhMa9L3su3GDS/1j9wXJ1QUHEtrxyitU55J7/nSD/mRp5S24L79ZDv8htCQlo6YCVSjLFUouROXBLTZSIyRCNcA8jFkm/slEi0SGybjulzxpS3ecWTeodCFE0cYM6B12VVGdq+5CqvubEzFk0O8H3zgNQ4lOONvCGr3HWakXOWG9q2zZU85cKEdEwfJXyu9YqYmBYBA3tAbmvmYskv8mtWTIho80jcRwrB8+WCS3lOW/S4E5d07BYfuEAKF8MpUU6pbSUXxnlzL+xzOmqPvnnCVE6Q1glvpzrnNjMkoiGZiTkhYaOyviIQMcpKRvS5ENdkTfZAYtvc1Cnn8hSLIbJHFFYzJ2NHdPCFW1k9F98wMoecyNGGkvhf+/qji7DvtRrbT/aj8Me6LjH2B8yy9y7G0O9g0Y0NyXXNnnTjad9r/biva/J7K7NCEdKNjlkWl8T+1sZH/P9j7T+aJEuyLE3wY+aHBasoxobczEE4CFzVBbqre7o2vZo/N39hdk1NNENT1DMFqDIrMyMDeTg0N2ymplhFBT/MzLPgp+KRs5iMIgpduZmaij8RUXmX773nfOfO7xp4HQf0EJLKLsGyEnXdqbBLPXeeWNnDaFeA70bI7mfdvzeUq/+umr1q1GT8esp1jXnTFXsyQkoPX7Ua9XK1Ghl7Ilwpon3lvM+B16HjbTOrz+hGB44EJruISK2e07K8wvgOjnDXqXbCPSLZY15fUJp5owB3I2nPG65sXZ4M0aZcHWTuwid68VGzS2+TljfEwfoqcMMhRad4KmkCM9KVcC5VE3ps0W7i3KRQRPRYCghUm0NzTEFNjI9qfuEHZshMTLkn1/GFo9MUZGybXSY4xFtaXaNNTuB1idSAdbONRLAQS7SFqU0Z1gEf99r8ZnrNsnYqzm6guEzrBv/XpuVtclu8BNyePPR7eDJknUP6tInNMc/4PcvKgUL2gs9dtqqJ2BIPONG3dEhcoZQBoZScLSt2Wz5nS03gCQKj0Bau85J7raT5bQ9Z4wnvqxnUCb6Q5NrdgJaZg1DERjqGrVTkRnMc9hiVJYESoCXPqiseeBuUVYS2Q3wliPGY65KP5BOu82ZlYh1848oMSU1JgCtikfHJa4sSgnW9zWHQ4aJMKSh4Y67Z0H36KmJXO7RjJBW+8Rh6MXstn++nSx60WhyYhCs+4GL2ByJ/A98G7McxUbHPjVkQ4mOtK6jHts/bhWZcOh9xx1fk2tC3XXbChJYnGLtzH+uRZFlbzouUftDmV8FjPCGYlZb9RBCpLmfLmn8Z3+eP6QUGixLgS0nfU6iyx3HbJ5/usRkHFNpiKsta6FMZeFOO+DDaYBCucZHWvKyvQcDH9gsAnlpD5A/4if9/YdngKMdcs2OOHBvadunaNkoIFnVFQptNfrL6PRzaHjNSHjbc6juhzbodumxeHaOsYmjXWJKTigWPky6joua+3SO3bgT/SO1zpZdIBFfChcW3iIlp0zEJAkFO2dwzBaWtOeQJuchWiubYBoztgj5tfKHQ1vAL70MmVUVLeRhpsbXlyLvfgGZKPrQ/oeV5tOvHjMSU0phVMlEgFQ/kFtd1ypHf53Xp0SWhowKiQDIqC26ZMzSbrMs2BZqcioyCLgkBikVd07ZtUpHyVnxNu/4FHRXQDSRXOUgkPTNsgCealvRRRhCaHZSQvBUzpJXOimZDHtgHtJTHwlS8Fe/YsH0CqXhjzzgWu0RKkdUxmUhpMWBo1hlGAVJAS3tc1Yo9MWTd9gmFIjUVLeXjC0mqazqBsz1t2w0mLPmp/DeEKM5wBfiAHTq+x5tqjI9P27ZRQnIrLvhcfkJuEk7snx/IKvbEFoPQ56RY4CHZ8GMmdZe2bRPisREGyEKghOBdPaYSFb/2vmBU5k59Xf/o8/+rFOG7guHUuU5kdCeGKvR8RcS6Y7feKX/v8oC1yaGmUUOXq13mXTJTpZcr7nQ73F7tatNytLJD3e2khZCrDlUKz6USNUXmrni7oAKzSh1SMqCsJ/iqu7omACMciQv4J95nKTyXzqRLapERe33m5W3Tcd4Q+v2GRZ03yuOQSi+Z1xcYU5Fqp5jWqmKZX5CEm66YNB383T75Ljhioa9WB4fSLMmKG4zviGF3e11r9Wpsr+o5Vb0kDtfJ6lu0LomCweq5OTuXtxrlVnrRkLPcbt116SFLJhQi47Z+hbQ+WrniEMg2P/AntrnPc/tbBuKA0MZcNMKt5/YEaSQSSZseL8TX9OQeCq8RkpWsJz+jMDM8IVmS4VufH7IxPs4G9P10SS5SbnXAs+IKUUg2zAYb4h63vKcw85UvWghF19+m0FOEUsxIeWl+49Tg1jCMHhHZFi3rvLkKn4/jDSpjKbWDQuTa4EnBrDS0PEXddLVnaUHP9xkVNYdtn1kliJRgXbfpBR6v8hnjXBDnPp6QvBJvkJViky1i4dH1A26KAoPlTTGlI2IqXOzgTCxYiCkva+hZF+ZuMazrHTbZoiUCWp7ifw2f8M10jrXwNJ1QoxkIx9x+L19wVSc8FPfp2w5LcpSQ7LY8zmeOSvVcX7CUE0a6RT5zWbN/XF5hheE2fUE72nPWOwIWleFeJ0TPLN+KrwgXnzDKA3KjuTELAjmgMoZvixv+/douJznMqhq7dJGDr8ucTPucLWt8HBHLWBjGkkDCydLyZplzxZi4iihETi00xrbZjn3+uLhhW/b432d/ZMceoXOLtZZhEHKVF/T9gEpULGtNaSx/W/89n9ifkdiEt/IdQ7OJNjlKbnIhT5jrCzwZEjPAYHktn1PbgkpsMSNkTw4Zc400m0zkmIk9oxL7RDbhWXVJYhNifHKRcSlG+DYECabxt26aXbq2x01e8wOvWNgRNQXb4gNe22s+FB/ynktueMea2KdrW3wn/sA6h9yTO5zbcwSSkZ3RIaFFQGg9vi8vG/uTR0jAtXAH54m85OfmC8Z2yaxWXMr3HHJMrjUz3GdmU3Q5q2euW7U+P4hXPJL3uDIFqam4MEusMPy2fkMoE87tS3wb86j6gCUlV/ItXbtBx8acckEhM2bmgm3xgcNn2jXmwu1cjTV8L76k0imfT/8HrsWEAV1eyqdsmSMMlpkuyChJxYJCZGhqfBE6xTaGqU3piR6X4pbUTgjkPfqBx2X2jA2xDgTcyAsUPolxxf889zhMYnLtTIhXZs5U3nKtX3AkP2fUZG/nYklQxQzpEwqPQzXgvF4wsgVD0eWVGDEzOTN3a+O9fEHfbpOSkpoxP8h33Bf7bJh1norf86H5Od/w96yL+5yVIWv0OJOnZNUGXToOFsIWXxXvMRh6ekBIwI0446SMWIg5HdtbTRz/akX4TuQjhb+6ud8lJ/15IMLdDvJOqVrrrFEdt1cXFck1PPFj1+lGzc6En4SbK1WxtQalAsea9lpuJKuC1ZjbwS0m/6Trtjj85N2/vStOxtZUerEScXnKMZTvDhLgeNV3Fp9AtSn1Aul5bq/b7MGFkE7NrTru2pu4wFIs8FWLnr9PaRfEYuBi0aqnBH6HuGE8C+EKV8/fR6IYV2+RyCbRyUUgxnLgeNXBFoFok+oRhqb7Va1G2ezRiraRSDwVkNvpj5nNGNZaj5hmb8nKa+Jgg2U+QwgPa0uSYB1PRMR0WTDiIv2KjeRDrDX0rUPc+dZnKkd0Tds9rnCUsLbt07G9RlG94IHcJTeamRiwtCMUzqPsqy5dsUmlehwGbULVoTKW59mEGJ+TLGXNi8jqHhfydMXCNVhCGxLJJmzdaznetrfGE/sFUgpOxRmlyGjJTTI9RghJz24wsF16KiRQkmUdrzy3U5OzpmK6gQtueFbc8GG0QSgE07piMwwJleDtckqU9Wh5gvOsJJCSm8KppO91Qjq+4KvbnGN7xMjOyCjYVi36gSRSEZWBlp9wtqx4IBzb+Oe9HX5726YlAyKlsPUBAy/iYd/nD7dL1kIfKcAXsBclaANt4ehU01Iz1ZoWA7bNlhMlBQmVifClZFoa9pswkzXb40BssJMErEeC89QV29s6b8SGJa1wkyU5OyphJ4Z5GfC8SPionxBIeLsQ3I+H3OROL7xh+3R950HW1rIWSc7Tmg97LdoeFEbzqBtTG8ukrNDWJXduxIrDJOIDbxeA02UHTwg+Hgi+HVsMhthT3Csf8aDVjMkTQcuD0zRhPYT8ZtPt4KXgI/tTPl9L+Gac88ZOOKv+hGgOw5d6ST88Zsc+pG/bBEKRmEcrG1LcvFZDvclYjjgwe9yX+47WRc1L8RRlD5x/uKEtpSJd/fnDaGOVLqWt5dgeEcn77kBtDLGJ8aQkZY6wcrV7vmd/wrpKsNaFi7QbqEtlNROWVKKibVsMZExqK3yhyGxOTIeHapdJXTCVt3zh32fPPCHHeX0/iTcIlTtImqrFOQUPgjVS3aMfeETVwOVd20tim/AJHzI1OUJKfBtyzhVTec2ReUyIh8Wyy5brZL0POKtnJISs+SEbNmFSF/j8BE3NjnRakoKMooFueCgSEbiOvbZkKLbNLjOxoG87DdkLvrHPudHnJHRYY5+W51LTduXHvBTfs2EPqESBRBET0SGk7XtoC0/tKw7MIRZLYnY4lPv4QnJrlrSJWNioofpl9GSf3Di3Rio0pa2xwlBQ0KdNgGLd7rFOn47y6dZtIusjheAobrFR/yuUEJzUe+ybHdbDkI4v+Yl6wjfTBet+xJZt8a4e06FHLjLuRR3y2uLXD2jLgMgErPsRl/KDv24RBqjqdIWQrPRy1cXeATDu1NJ3O9U7uhWwYj6Dg1bopiCX1ZzQ760oOHeddFnPVzm/d7vPu9xiKTw8Ga9gIbXOEaak1hlR4DniVLMnvVMNu+vyKKpblEzcn1Gu65Ue7XCHtLxxP6tLFvp8VfSKagpBI05TPXQToSiEamxENUI4X/KsPsOXMTfVMzfCNs0OXC/I6ymxv4YUHpPqHYF04/msGpME6w2PW7LQVyT+OrUpWOprl6QkYwo9c2N4I5sUpXIF6/gxg9nt17PG7nXnqXZfBtHs6qfFO0Qo8URI6PeYlG+JvSFj4RKSNuwep/YZcwa0vW2XTERFLpZMxTW1dR+Y58bQtT20qFD4zk4m3XqgouDY3OOPxVu6tkdEwELMuRJn3Df3OatnbKkOPXOfCSkevrvZiRqfkFt9s9r91TrjXbSOQWMxzPXFKrZyENxj225gcMrkaalXIPeDto9YghBQasvv6h+4L+4xLitOrfOOt+oNbgrH2n1VWEJ8TuRrPrEfsrCuw/2H+ZhD6WAhPc+H2h0Svq/e89Ds8tS8Y9/sIAoHJQnxaCmfN3MHNCnNgIdhl+/MFare5iZXZFSc5JpT+Y61bAuJdElNRqMQvOOcHgPm9ppttqisRuIzqjP2whYXeU5BzbpKmJMSWI93ac7LpeZEvnPgAbqOqoah1AvGwTWjss3fXgqO2yFBEfNiVnBrllzLC35dPOFFcUtMSEHFs6mje9XWsBYKXs8140JSasnU5lxnHpWxHLdDXi8KxnaJkn1mpaa2hmfihUvGsXt8dSuZVTVTOeJpVdEiIdPusHSeGYy1bEYB8xLmpkAYQccGJNLnb29vG9KVRz84Ii2vqXXaHGodd/iKtxyYD1zxxkeaLm/F92TmngNTUDASU2654J59hC8UD8wTIuHxnksysaQkZd3usRAu6u+rolqNZTUVm3ad92bi7g024Fy+JrUbtOiTMSWnXAXRX+sF216Hbu3gKVOb8k58hy9iHpuPmLDklb112EabkIsUz3qM65yCCoFc5S2PxZjARsyzmBrDuko45YZcLPiuMmzZNarc8EaccmB3kUgKcn5nf4MvY3IzozYpO+pjOnbITMy55T3rHHIsN5jrcpUudSFOGNebtG2LjIKxvGbT7HLKyOUziwUVXRLb5SVf0hGb/Ex+yJW8JGfhiqmVzISgZQO+4k+0GTK2jsWdi5Tvq/ds2nW0cPfHG3FKZTOXliXH3DNP6AmfV9mcVEyYih7CulH/S/EUn4j73Cej4lpe8IX6gN/pN4Q6QKOZiSm5WNK3HbbMPguxYGEdTCQTKblpkdcVp/Idmop75hFv8nNqUfORPGJotjgTl1yXIYtqQs8M8fD4Wp+zbbaZywmBjWlbF6ByakeEhGhjGIsxX5XfrSas/9zXf0cnXDcFOHC+XxU1Y19FXjpP77K4wG+Uu3dCkKy4aWAT4erna52v9rB3WcBuNOutaE+9+JDKZI3FKVvtpO/oWy7POGtGwfFKUBWotvPZNtdxd2BwIP8xnnIKWZdpHKFsQCfYIRI9tO+EXG2vz6K4cD9zF0Yh3V74Lps39pzKWQqPKOiTVbfNv2tTmoW7Ts9ZiZbVJZXJ6IWHlMYJ0rreblOwXFRhINvkcuJgI6bAayICA9XGWk1lspVFyiqzIojFauA6eR+iZs9+l2V8R9XSpkCphLqeopQDhiT+uhM02F1a/oCSDB9nIzu2e5yKm1UQ+Uf2E864YZsh1li+Eb9n137ghF1Wsi7b1GYXD8VcXmCNYdh6jMJjJKZs200i6RFJRZ9dlrrGl5I1WggBB62Q5cKJco6iNmmd8K15iWmmGtrkZGXOq/L/QxxsNOp8RSvcZKDcB0YIQSQUT5cOz7gk44vWJrWB7dgnrS2REhyVRzzoRHhS4C82WOoKba2jROk2W16LYehxoD/huihZUzG3OmOTAUo4fKQnBXtxyKIyqHqL0hg+846ZVBWBlFyYOUPbJ1LNygTJpmoxrzRDs44SjirVExF7SUi4vM+luKVvuwwCj5vCkpqKY7mLFALPfIQvFL6QnJVLDqIWkZJQwFHk9p5rWYdTLvg0OERbsOUBM7Ggpl4J+TreNvftPXqeT2EMubb0zYB+5DHPPX7qPabQprGMeHzc6VAZCKSk1oaL1PLZWkShobLODlM3VKxls7/+aXuN9UhwlUvO04p1vcOW6tAPHf0q0zWJ6GLRfNwa0PIF2oBvBYnnrFCTqmQzSPj7+vc81B9xv9UiKLqoWnEq3+CLCE9GTdhLfxVsf2uXxLhUnp5ImNqU+/YTMnIqUXFgjoiFjzCSvhcyrnMHkbBwKLcBp0a/tlMyMWPTHLEheszIiW3EUhiUkJzzgo7YQAmfDXNAnzYTFhzxIVfyjB1z4HbgKKyFa3lNRcEv/MfExefMbcpOHLFLxFXeYRgGaGu5KVyzEUiFMILQxmSUrMs2kd0klIoLM+VSvgX9kMf+Nm+qMQPRZi0IWNYNsAdBZBNiIjbZYMQExDYt6dT4U5Oz4SV8azISk+BLQQufkYENO+CLaJdpqTnRt2yIHtv0iHzJpArYjEJui4qn8gd6doNd8YTYREyqkjW7wVy48XMlCiKTsLQlbeliT4ccMRBtDpJ1Xi2X7McxRbbGHts8F8/os03buM9g5EuWtaYnHVxEGVeqOjLkvnnMnJS3zUHzyByRoolw6vOpyfl5dMTzbMZ2kFAYw8DE9EOPSVkz5ppI+HSUT99+wKke4wvFwA44DNtIAdROjLUuOrTVJu+NmxCEZotrcUNgYzbsgIyKQehxk4WuGxdLAhvxU/Fv+dL/b3/lItwo6lY7XcyPUYMqJq9uV8pmYytHLZIxlZ7hqfZqNH3X8c7zU6JgbVVkVzaihqhVmaQhJTkOdVnPifwBdaO4veuU7x7XPU7qWNBNwLyzNuUkwTrL4grbELTMn3Xlrns03JTPGi9xRS0KomCANgWh32vIW5XDRwbrK2GUEApPBGTV7YpyVSDxZLiKVvxxrB6uCnCh5/hesiKIhapLbXM3um9G81l9+0/oY6Hn8oaLaopAOpiH8ZnnZwS+E6Atyktqna8IYoHXoSYjCdYZL58jENimi7fCietS3GltZs5dYZNDruyUShaUInPpMcxYMGKJyw71RMi1OCGizVzc8qLZ/+SNEKwdbjuvd3Afg3FWEOvA8xt+zNxm3A97XOQ5Svi8XDjikrIer/OaEI+RfU0g20z0DHARjG6F4BTiSbBBINvMzAUfyofMTcF21GJgffqh5KsplMYyrzSjOuODVodMu8i1WWXoBZJuoHhavOGeOeCSMTtyjUVdsagrbplz3x/yrppyIp7y2H6GMgJfSsZlRawUmXb5x3+sXvGgPgRoSEAxV+KapN6lNBpfBBRGMwwDJrXiRJwh53soIci1xROSR2qbUZ1RGkvX9+hYj1FZcNiKOU1HhLZHpBRLI0hrw21RcSVuyHI3jt7z22TVGjeFQ3/WuM/StuzzsinAuZnyJX/Pg+pzjsMesSd4FPcdQMKLOSmnFKLACMvSKkoTMwgFFsW90KMy8F9HE3oiYjsOmIg5e15CqS3vsiUZJZt6wP9xc0rfdunIEIngvRnhVxvOQx2GvK8KfBsyKmpGBSy18yTfVpqOCrjfiTlPKwZ2F4vl9+k5G7bPhTylpuA6/R5rDb34iHH6kisZ48uQShbMgIqChe2ylBN6dsjQ9ngufqBrO1wybsA7hkB4vBRfs28ecsp71s02UzGmx4CB3eVWXjDijBZ9urbHkdhkEHp8lWvatkdFyVLO8IxHKhdI08UnxKfhOosMo4dYaShJeVVMuJHnBMR8n0k+iNaY2pwsr5iTEuIOzjM7ZU9sOzKczLjiPZt2H996jWI5QqP5rj4hl0vO7UvWq0M0FUsx5tb20ULjW+fLPhKbvLHnZCKntgkzsaCoKyLR4kqesWimOi2bUKH5LhuhRc2VeMtSDNkzu7yyV/giJCjd/aHDkK5tO+KU/gMfyX9NiMeJuGTXPCC2ASfyLZXtI60kZ0bY8MxfZROGbPGHfOTcJijHkxZnWLbYE21eFRMUirYI+UJ+zoScSQOBKprV3EX1HWv+PQwG34b4hLwU77gnDniZzdFol1mMz0TMuMpDxvKapR3xVKT09AaRTWgRk9uKN/IZk2KbUmT4ImAqrmmbJ5SV5kQ8Y88+YipvObYHpLZEYwhQnGc5bdzYPcUdup/Kb+BHU9Bfpwh7MlllB9+xorUpV0zjvEE+KhmgazcKVirAN+4NFqhVUVEyWPGaaXy91mqEVG4XGu2uWMrKuO4vDPsrlvKd7/ZuP1s20X13QrA7P7NArqIAA7+z6pYLnTb2nWAVfSilvxKfASjhU9klkddnWVyt4hQ9EWONWSEkhZQrf/EdXrKlNiB09qtYDZiUb1c+Xpf8JKlsijZFg7Nsk2vHtw69rhN/GZe8JJCUdk5RzwhVx+2f62lj7apIwk1HCbPl6hqElg5YIdss84vmdfEQMsLampa3wYF9gm88KmoqUZJJF0OmbYUWuvFSFrhfbQ8lXNG4tUvaYkjGjIwZ8/qCGZId9TG5WNIJ95hkr+jFR3RN33kVbcXDdsxp6khVCS6FRxCjBHzRCbjKEl4vClJb8kJ+x679iLf175EiACGxtl5ZxrbbX7DOEY+Us2sYrCvulabrK17PHXKy1Ja10COULTLtPLzP8oK8TliPHBv6U+8+ozInJHTj7DAkUoJuGeBJQYjP/9b6l0xKw+vydsWSzbVmKwpo+YJ/4z8k15Y/5id8Eu7T8iSZ7qOEwJcBi2WOryRZbXjSacF8i37g866coypBz/cxwMCLWI8UF2nN+2qGQjErAwyWazHhQlf8snXIsjJ4QkANHpKFWOLJDhU1W17LBVDImC3Z4kvzdFWAl+UVT8J/h7KNIjzT/HTd4+8uS2JP0SbiSdxnVrpd8kHLpTpdZRaBoOvDUDoF+Xok+df+Lt9MFxzECUMbc1ZXBEqwZnscxi1ybfmwvca349ypXH2HBM1ZcMwemdYMQx+Jz1biQB0Pu86XLBEcy01KY5zdQ1cktsutfoVSARvJh8yqM6TwWBTnvPUL9r3Pmg5wnRDPpRfhiFkBMRJBaN37PDcFQy/mc/M5vchD5Qof1cTceYxFgcJfsaQ1TlvQNi26Ypu2aWFISAjoBwGBHHBTlKzbDm3fo6o0yio2VQtPS05kykC0CM0hIzFiXbg9okTQkSHCOM9yJEL6JPhS0tYdtmSHtq8ojeWsXPCRv8Pz0sfH45Hc51LPOZdvqWxBYtsM7WPn6beGvhdSG+t82NWQnJKcGh+fgXDXPzQ9xmKGwXIlz1gzW3wYDxHAN5nkQK7RiiRDc0iuXae9LfuURtNSPrvqEXPuEUjJuM65Z56s9sCH+hhfKOY2YyzOUPhs2D6hDTkK+syrFlObs6laaDvkyszpCYe53FFdXpozttQuLU/R9dsM65jSGCICEkLue79GWqcjiZu9cGgHWAELsWSHNXq+g+9QwIaXcCwGDgIjPHqhcqsrJclqzS/k5wTKMbPfVU6UpjF0VMRH5jMWFOyZXVqeR2QV78wNwko6JOxFCad5SkHOsdwltRs0hpi/XhF2EYJqNVIGqPSCtLxZ+XVrk2Mq1w2Hfg9fNepik6FUgDBypZwOVIu8nq66WCm91bj1jvx0J4S6i0B0GcLFKkXpzsoDrIIX7q7V6LpJIyqZpK9XgiX3/3J/fxeYcFfs7rr8QLWYZSdO+MVsZYeyxrDML/C9losDxHGr/9yTbGTI1Lyn0ksH8NCjRswmSevR6lrvJgvGunjIQs9XgjKAohqvXvs7VfqiuFj9XVk7K1OllwTBJvP0bKXAvjuMTLJXeCqmqlPsKsmpRKKoqbmU7wiIWdgRlUnJZZeJOSMQCVdCI1Hs2Ae8EF/zKT/jxizw8ciYuVN6dUbL2yAWPaSVjOs39LwD6jDlIT9jIeYY20JjOE0rZrrgtbkllXOY3FuNqM9Tp64d2Tl7qs/CHHDBK9reFjP7CiUSKj3G8wbsJ79g2+zxIO4gBcy1ixiUAq7zjEglJErR8jpMqgptPUIlOc8z/nPxJf/C+xWVNTyb5uTWwfC7XkCXgEldkHghL5cLBIJQO0DCybJgYlMkEl9ILsyUQ2/A82zGoIjZjJzq+57a4aYoeFPkFKJAWa+5oUkXYC48vp9nCAS3VUmMz3N7wlG1xwnnpGLGYvqIC3FNITMOzAGvqhHv7dfcEz/Fx+eb5S01NR4emVzSsT0iG7OsNZUoyY2D+EsEnpH0cUHpP+Tf4KsWZ/zApnjIF3GPP01nPJu2edwPOF069nE/kLxLM2Ys+ZsrQdcL8ITgD7cZD9oJuy2fZWU5SzVdX9KWAVd5SWWdN3ZRGRfYXmku6jn9csCtXTKpBBumzVyX3Ochkac4q2dQOGzjb2c3bgy+6POyvMVguJUX/ML/hK/qVxQypbALHshf8dT8F67SbyjrRmyoDd1kl4KMC/OUgTpi1+zTJeGNfO0O4yyo2MRgear/hh3/Y7K6z1B0uClKLuQpA7PBttlixpLEtOmyxaKh8E3kmNgmvC0MSKioORHP8EWMqn26dkBFSSVK1qoNbuU1BSmxjmiLkMIuqKxmLMZENuFc3GK04Z35A+vyIUsxwhcxfbvNTFyjbQUShP6Ap/aaxLZZyCmmdGLMRATcNlz+mC5a1JzyjCP7IZfyysWMahdNulkfkcmUgRlisbwXT/Hsx7SJuBZjfOsiTPp2g7G85vvM8aQlkks9J9Ehr+QLJIqSlJgupcy4px9hCHhjzzDG4DXxqJlucy3fI6RkzWyvEKzXvGaLNd6Kr6mqxwjrRKpXesm6SriU75jSZt1skmtFJpe8ryekekEqZoQkRLZFlzZTsWSTAedcEdiIiIAZSyQxLenT1W3eyFO6ZR+FYi6myFq4pDChMdawmTnhYKgdMe/UTkFDZGOu5HsAfOtzZh0PvC2HrJtN3tUO0iKsJMCnxnCWZ2Q4LsC5veXCPCVrsMp/tSLsIvP0ylYj5Y/FwlNuP6NEsCJWue9NXTfsJSti051X2JMJie9TKTeKvhPZGFtT1cuVuMuxm3sYTNOBu52yEHLlI46Ddcp6TuA5AZPnhyt2c6A6SOkR+2vk9QRPxqvCKYVHqLoNvcvtY9bjx2RNV+p7bg+8LBxAQ8kQT0UuHlCGq2vWpkDbmlB1V7SwQLXwRcKivnT5xCJBej4ShUETiIRJ7Qq9L2ISfx3juW4/rW+x1qzU0Ut9TakXRMHaiq8tpbeCmdyNzbu+2zOvDknN6+h421GzQkiZ1xf0vC12zBFLkbJn9zmR7/BtSCIH9O0WO6yhsUghuBU9ClOzKTuMTErXbtC2bW79AYGNwTaRknrJyL4kVB1CfDq4Q8GFPCPUh+xFCWflKU94xHYr4Dqv2G87Yc/fzk9J5Yyh6eDbgIHY5cI8bZ7HmHZ8n93oCyyGDS/Bk4LYE8jMKWg3YknXd/QpgL+bXrpg+nTJvmqxEUT41c/ch066YiqNS8jxpSRWAghdYooMedQL+GaSMQhCnlWXfJFs8z7N3eMbR3L6l90+56lGCsH9sM+4dIzhddmmF/QZhJLrTLOpWtzr+Lxb1BzFIedpxa3OaIuQ2LrUmoFeY2DXWA9DimJAiy2sgJaNeSJ+TSICjlsRbV9wmWmMhcvqHQuxYI91XptzCpFRmh4xPiMx5VhukGkHaxAotxsWA2ITO/Wzl7CsLQ8D6PmKx7bDydLyLzZanKcJPyxnJF6ENrARROy3nE/YWgiU5DKtOeoEGGt5Psvo4/bTc12yE8Xc93p0A8GjaMDzfMxH/YDfjireyrf8VD7ml70hvoTLTPPTZB0lYFwYYkI6MuRJsE6kJINyyKP4AaOi4g1nzapnRjc+pqimbCYf8xmfcmMW1Kpg2+yRiIC34pSP+IDC6hVoQ1vDofcFh2wzjH3+sXjJwAxJ6NImxkOyRocTeUrLxGQib27GIXtiSIUhMHv4KI7th2Q2Z0P0WNiC42iL35UvaYuQuQ1YsxtseE5hPBC7ZFQM7Rp9FREpiQGuGfCReEhu77EwLnavbx/QkSGpqeh7IT0dUVpNYhM6IuSZeE/bxGwHLZ5Vl3zuH5Nrw1LvcyMmAKR2Qi4W7JgHDEUHbXq0lE9lDev2kC3V4VRPOJabzHSBQjYWKUOLiEj4BFJSNVnDPbtBYhN6IuKSMYfyAYNEcZoVbNtNWtInM/Xq/7HNx8xNQVeFBNqnEO7+uhVFqOLXHLZCLrKKSz2nLUIyXfOx/IgLM8FH4QtFzwy5F6yhjYvtnNQFM1K2/ISNJt95WK+5qEEvZKrnLG1GpWsykbNhNqio2Q86XJceW0FMpz76UZBJgBCCvh8QKcE9FXORVSgh2LQfca5n7Hpd/NoHdvGspCcjnnPFsT2gkYgwDAOy2jDVczKxpG06LvNd/GXl9S+OMvS9dZSM0LYk8p0fNSuuAZp9XbzqaO8KE9DsaC+RDXPaUxECtRoPl9V8ZT+6K+Z33e6PHtcfPa8OOOGKTl6NnSUK1RTCkla4hRA/qp7vcJV3X9aalW3nTuBjbOV2yKZsAg+qpqg7S9YiP3Oca6+1elxg1ZGvxvCN//muCN55pwXSCdEw1KYg9vrUpiCtbvBVC9U8t6y6Xe2Qy3q+6myLakro99yuvCmstc5pRdsU1WSlio48JxC7e42k8Fd+ZG1LsAZjS6QI6CbHPJC/4ly84MA+4Uy+RNuK0iwaqtcmIW0S2+Wa10SiS9v2WYgJhV0wYJdKFI7Bi+Q6+55WsMksPyEJN+l7B/TtFrGNqNHEhPx80OX5tFz98k50TksEvBRv2DP7XIlrl9UqYqbVe2bZG6ytCbw+m8kndISj/QgkfTMgIWQsZkTWjRo/aneZlAZfwut8zqPYrUKeZzMOgw7dQDKvjANQBIr/mP+BdbvHBa8YsMvn4SHzSjs4h3E4yvdmhG8D7gV9cm14Z27wrXt/JQ5XmdqSu8zfWLj828QT/GF+S5eYCUvG8pojc0RBzVRMWLdDrsQ1EsnQrhEJHyUEg8DnZT6hpKJPmwrNRMx47G1TGed3dippwZf8N7bFB/RsnxifBTk9kbAeBsyqmp3E5+8W77iwz1ZUt031AQd2l74fMAwl75YlpdEctmJO0pw1P+Coo/jNaE5LBuwlwWrU/rG/jxAwLivWGzHReZE2tinDUruD+dguCAkoKFcqa4AuMSMxXb1+l/Idn4tPVok6l+KWXdYZWUe/+0V3nWVlucxL0iZW9E/6P5EWV2jr8sal8BgGD+naDebCEeAKu6CHy3Ud2uGKctQ3GyzljIUdcWifuEmE/J7czEjkgIW+YkM9ZGCGvBZfs8NDhrbHehjyqphgMM4PKq8IbMxMXKPwiZrM7aHo8lR8y4Y5YCKvSe2Yj+xPOZVn1FR4+AQ25ooXbOAU/SfylJqKA3NIhea9fMWH9kOmNifGp6OC1ch5yxwylteENuYuZvRSXtE2XTZll6c8X/Gpv+c37IgPScWMDbPNM/sbhuoeu2aPH8SXHNqPOJMvOTKPGYtbhnbIG/kMiaJrN5iIC4ytWecQ0wzkP/T3eV3eNsGnyvG27QvW5X0S02Ykz9g19yicsoVL+ZYWA/pmwKl8xZY5IiQgFSnCSnblgO95QU3BE/sh2homjQ8aYMw5iejzmPt8zbfsmnukIsVg6NoOiQi4YERoQ+Zy4uhzZgcfxQ/iT/SavbpvQ3KxZM8cIhFcixtCIm7EKQk9DJrEdtFUFMLxIyLbpms7PLX/wD3xUy7ka1oMeCKOOdUTWkSUaFKRMhe3rJsdMpFxar5moI64qp5irWay+Pqfra3/HcQsx/C9A244JfOPxeYuklDirQqVMTVG1ngqodbpKurQU25fG6rOShVd2wxPDVYpREoqfC8h9oYsq0u0Llc76busXmNrpPXwvBilgh/Dvm1NK9iktu4gUOklnoxXqUtSBA0UZIeqQWIaWxF5DgpR1EUjwKrxZUwSbhCqrtuxco0Szjt8p0S2mEbtbahtQawGLKqL1XMD8GVCaRZufy1DfBkTeT0C1UbiU1lnt/BlTFaNV7aku8LsVNrRKk9ZoCirOQK1sjbVpiD21yj1YhXYcAcc0XWOpxKUHJBXI/faIemJbULrM7T7TTj2p2QiZWjW0Q1+z5MhIQmBjTiy9zmTpyjr0zZdlPSZ2LOGjObsTrFybOLEJquUlabuEinJbVXQ9QIWYkloPX4dfcCLzLGB23SpKFG+T1pcUekZvfiIHfuAx+GQyzynQvNJr8OX0yn3lEsYWuqa69wJfI7aHme5x/Nsxn7Q4VHcJdOW67zGE4KurxhGkp8Wn9EKJF+obU7TAoHbE5cY+r5PqARZ1uN+J0Yb2G0p1HyD2JN0A8F3swVbUcC4lE2IvaG0mkxb0trwKBq4fNk65KH/mFlVk5qCPRyJ57yqCW0bH8V6GDCMJK/n5aqwb4YRLU/yH9LvKMwmiVJMdYGHZBCErNf3aZuOU5N6gkWeEysHIVFCcJnWBDb6J8r8tum6aD/lYgUTpdhvBQSN4vvnQ5jV0FUhSrhcYAH8PD4gUoL3y4rDllsbpTX0VURlDJGSXNYFh0EHv+4yNu5mdi9uY3GpShdZzZPWDteZZitRzMoBg1DSzTucZzm+9ekHPgOxxkWR8WpeEEnFT4cRX99Kamvo+furz09lMrpqF9mMTjt2yJHYZGpzzuR7JBJlJfvmgIKKNhGhcSAObTXXYkFlMx7wOcZYjsVD9oK79KZ7pGKBbwOWRcmZfOnuTWgem8+IhOceCwj58VD2K/U5YSB5mfsoDjhMYjrFMbHn1L4v7Sk/sb/kLrP40O4ztSkaw0vxFev2kI7vkxiPd/WYM3vBXFwT0WUmJ9y3xxS2JqfJOrcO9KGtZd3ucC/oY4BJ9SEWza7Z5ym/ozYFPTF0yUzsIxHcM08I8dj3D6mMparv0xcJnpB0TYeCklPxjAG77LGNEjAQ7SZUw41xZ/KaLbNJIDw2bY85BR/HG6xHkn8Y+00XmvETfsJm4vMuzTA2ZstrsRl7dKvHnOYpSgrGNuNxNOSqaJNaR48LbciJuOEDnrAWBISqy/NsRluErIcBed5lw0t4V4OPT0eEZLZyNkuzwUwsCG3Irt0ikh4n1mV+Gwzr7HHFWzY5YmC7RNKjNC7xrLSalILPxL9iJ4q5LS+dJc3MyEXKpXjb7IwrfCJiAkbikofilxhj6KkhL/Tf/0W19S8uwrXOHR3K1qRF6rrfZrR7h5W862KFkKsusaimGOtQkZ5MVvm+lV5SwYqsZWxNXro96F0YfVWnKzGWapCS4PaooeqRldcrWEbgd8jLMZVOifwBeT1xKuPihk60S6mXVPWCVrSzQlnO89NVXrCn4hWd6263bDHkpiItrxGRWhV1g0Fat7O+qy53KmVtCnwZr3a2d2Kvu67U7akrqtopxdNyRDc6+KeM6tqFWuT15J9gKrVxh4W6zlZglLvX7O7r7t8aUzcKbxeuYWxJbaQ7DJmcoprwSv4OXVdci5A1eYRHSGVLSjLeyh9oMyRn4fblSKZyBAZu6hdI4dNR24yql3S9XdrhNteL79hp/5S2GDKzV2g0I5NykqdsMgBCfqgvqGTBjnePPePGe6OiYigTTu2IM36gNoWjgNmSONhiR3zIVIw4zxNmpLSJCSSsq4T39ZQ10UIAozrDR3GeSraCho9dVbwuXd7vvhyubDBpLTjXM0LthGdCCEZFyXPhwABC+DzPZlzK99yzH/P18pb2MiKlYMO2+a4Y0aPDfy2+5sDcW52wH8g9tLFc1ylrJiZSko4MGYSSq6KmI9x1nRQLfuLfY1HXLCnxJfx2MmEoE2Y2ZyEW1IVhUMUkok9pDJfaEYNapouoBKXIKHGWu7Q2zMSULduhMIbLekkuMnyCZsXhRnC5lyJo8zybsee3ybVhUbmd/KSseDGPMDirjkQQKphXLmDgXeoK6+8XY+77Q2JPcqNTHsQd3mZLzuVbLmtFzw65521wXaf8bfEdHbvG0PYIhCJSPtdlTq4Dxw9OfVIKEkKXCV3OuZEXGGnomSHaaParBvrBzSrKMqsneDLkPP2SneRzNBWpmPPGajo4xXhFQUpBTMCpfMWheUSAAwmdiueUNiXXE658J0h6K18xKvq0bYct1ljYnBrNTE6I6SKFYsmYKXPOxYKO7ZOLFE3NjTilxQCv9nhgdpk1tKmXqRMOXdlzBmaDAWucyFMOzB5jkzm/rnjPjn1AX+yChZflDXM5RkmfJWNqcmYmZVc8wWDJKSlEQYeYyCZMxQRje2Qi412piPFp026IV5KhPCKhjY/PKc+obIoSH9K2bV6IP+LVIX27zZA+z8UrBmaDS/mWvt3myH7ItbzgKd/ypPyY1Ja8s+/dGkpASJv38mTloy1EwfdZicwk5/I1VXnk7pemzTfpDINhIq8J62PG85yJmBMTUZiKV/yBqviEPTHkiiVd6/zVt2LJqS2Ylz1O5SsS2WNhY74rL8gYI+tfk4uU97zj5+JXLK2LrDyRr2nbPptynTf2nMBEFNKR+26l09d02CAxbrTd8TzOyoILxtSyZmCGaAzv8gWlTCmbLnzMGdIq1thlISZMzSkZO3j43EjHl9BUWP2XyaP/4nF0v/2TphBnqy73bgRtbOX2pCpCShdmf7e3vfP43o1IwY2olQzxZMg8P109DjhBlydC5k1+bOyvrcRfQkjS4srtUT1nRYr8QbPzDFcjWCUDlsU5fmONqnSKrxIEanVNUnqrEITIc1DxeXmOJ2PXgda3dIN9tK2YF6fE/gAlQ+b5Ga1w0838G/mb2+sm1LZA2wIl3E5aCEllMsp6Ti88xBMhqR45JXhzoFDCnaa1LSj1glB1SaubFZLSBVREK350UTkxWyvapqznq4LdCfdIq+t/Mnq/i2W827PXJm2CONwhoxMfMQjv0WJAy3QZii5vxFs6ZsBSzmiZLi3i5oZWMxNTKlHQtj1C6677Sp5xU71w4RP5BXG4Tq0zjqJfOwSll9APFYW2ZLUjWF2YKY+jIYNQUhpLyxP8abykpXy+st8yq09ZFE7VPYjvs80HbLNGICVLXfG4myCF4MUs59pO+XlnE2vh3bJYjUm1hUlVoppT0m4SogRcZfVqHN5p1LrWWqZ1tRrR/mF+i4/HukroBYq0Nuy2PF7PnfDpXjvibFnx8SDg70YztvyEqkHoHXV8xoXhh2zMw6jPWqhIa9cZz6qa0mhGYoqw7n36vLVJoS1v8rnb0eqaV8LdPFzfVVGJgn8TP6blC86WNYknKbQlUM7ipAS8KaaOHkRORMAb+ZI9c8yFPAVgok8ozZK2t8Vn/Ix+4JjR87rmXifk2SzDF5JIKgaNatRYiDzBsjJMdcFuFDMIFS9mOdoanvQSfje95YO4z6IyPNcXxDYmFQs+UHur7m8n8ThPa7S1bEY+b5cZR62YXFvO84zjVsKs1HQDl+t6vqyZ64oH7Yh5ZQmV4CqraPuK02LJmXzPRfE1aXGJ77XZT37JltmnLRwRat0OGYsZO6zhCcmXfMnA7vJIbXNb5/RUSG7cnvidfE7fbrPLOmfc0LddDqM2hTZUxtILFJd5ibaGvh9wWi3QaLaUg/Y/1ScM7RCJoKtCLvWcTGQciI2VAvulviS0IW1iEunzkndsmi3WVMyf7Hc8sY9JlEdpDHNTcC9pcZGVnHLDll2jxjAVc7q2zYYfc1sVaAwbfuyY2jgxUUXFjuqt/Oyv9TUGw+fRLl/lF1QUVKJYjV7vACFDu8bQi3lfu9+hlII12WJuChIRMLM5FRUfxkMmZd3oKAS5Nry1V+yyjgBKq9EY9qKESVnznNd87j1CCbgp3PRLW8s7c0PbtliIJcJKHgXrLGtNbmomLHkYrrGoNIPQ4yovGdslD6M+y8pwo9PVznhuM2o0lajYZIBEOIa6FJxXSzwkD1ptbot6dUAfixkPPJdhXTU1J9M1+0nkpkdZRctTPKuueBxskmvDa31NITL2zQ7DIOSsXGKwJCLgnXjPntldMfYzKk7lG3bMEU/N33I9+8d/trb+xZ1wVo5WAfGB6iCUJK/GaJMTegNqkzlqk99ZKXzviqrroE3T1dWrfW/RFIo79e9dNnENTeF0YAkpPfLGi3tXZGyTx3pnQborOo5TXTQq7FukDEjCrZUfua5TtMmJgvVVF55WN3QDl8xSm6zxJxcspQult+hVl2xsRVHPXCIMLkUqBEq7xNhqRRW7E3Xd7bPTetRAOFxRS/ML4mAd34u5y+4NlVxlE3vK0bZqnRH7A0q9XD0vYDVx8GS8UkJHwRppcdUkR0VNOEWPvJ6uLFzG1mi9WL12qTciVG1SueDEfMuB/Ziqodi84yt6cg+fkCVjx3W1XTKRMhZXq3GMNgXtYIu4NSCtRw4kQoGP4k09YkP3qKwmkT4/8Iohm0zLmlmFs55I1w09t9+TmTGh6rHggqPkX3Jsj5AIWsojUAJfSE4WFb3AYysKOM1zbjLdFK83mOKIlvL4o/kGISRP7GNnqyo95nWNgGZc+ZqPi48w1rpQAT8g15o/zCfsKBco3vIl53nBmh/wf85e8ok6QluLLwWF1RTaIR3PqyVtETKzOc+nYwZ2jS3VYVkZflP+sNoF92TED/I77pvH3IopR2KTv8teMTTrnMsTqB3kocsAYSVzecueOaSyNd8tpwxkzLm9JdUL9swuC3L2vR65Nex6XSa1s5SlFES0+c78DYlYZ8c+4Ma+wBMBiRjwd9V/IKbPQ/sFN/KKfLrLmbxgwYiWGZBnC3bMET4en7a6nORLR8/KM7bLHtd2SoBPaWImckymezzqeUTLHW6LisSGVNagjGBWlyznNWt+wMvyluXSTTOOiBkVJUpITtMCJQRfZ695wCGpqZixZK0IuC5zXskXfMQTXhUTLuU7ItpUekknPqTn7xPZFjfygjMyjs1DRmJCyybcMEdaSWpH7IoH/KnJy26bPpFN6NNi3e5RUboiIjJq2+Z35UsS2ya0IcssYiSmKDxULdnz2/xGf8nCuPxZIzRLm6GF5trcYKQ7OJ1YQEBWF1TSUaak2WBkJxQidYVVFyy44lJsomqPS/kWKRV++hghBKmYYewAF9uRs8RjWeUrkdOsXnAjTtkz96moyEXKtVaM5YiBGXIpXrLGPr/P35KLJYntENqYK15zYJ+48AVRgoUvzVNSMSYRAypyevYTruU1Y3tCW246dXleMRXXrJlthqaLLyRes0p5ny+5FjcUIqNVPiCSirm+5mnV5otol1vmRGZAy1NgnIVoKkYIIXlWGRZiyi57bo9cOGHYN/klBkshM74tCnZwdthT+Z7ItpFC0rcdRqRcMKJrO/g25rKaMxNT9tjmIit5xXsqWTA0TifwphoTEjAVEwIbkcoF11lMKmZsm11OqgW+9fm2PGfLrqFFxdxeU7HJtKqoqFEoclsx5YKpcF21QDJgl8R2eS2+pmpWMv/c11/cCbfjRyvRkO+51KC70IXQ75EV13Tiw5VVyDGaM6Jg7Z/wpUs9d7AJ1VoJnO7CFO4KbCfcY16cIlBEwYBlfrEShGXlNaE3oKwdj/ouCMIVphzTCDicQCrCU0lj01k23//xgBAHGytBVRKsr3a8QiiKakLkr61Y1EoGhF6Xop7RDraoTeGKrskIVdd1nbZA2wqvoYM5b7QkrW+bfGEPXyRUNnUxkCZj4B8BcFM8w1MxSvhuXK2dR7lsCmatc/rRMdpWLKtL5xluxv93BbUXH62gIom/QVpdu5jHJuxBCElZzwCDNSW+v8bD9v+MbwMysSS1Y9piiG9Dx4BuYB0+IQMz/CeiCLj7IF1zUz5jENzjJv+BfnjMffsJa81hY6Idgs/HY8NLyLRmPQw4zVMu5CVP5CHaWr61z5ibK9LqmrXwAQEJm2aXw6DD8/KGSlQcy026vsey1mzHHt1A8MOkohconmczWgQEUhFIuRrHfhJtMa9cN7asXId8lwfc9t1etyUDAil5V99iheGjcMvtVSUoITjPcgZByEW55FGrQ9cXzCvLsnYir3Gd05IBO3HATV5zqzM2vIRU10xsSkLIMIiYVxW5rdkIYgah5O2ioON5DELF3y/f8Wm4z3VR8kf7tyjh8ym/YmpT1kSLp+IHjsx9+iriRqd4SM7kKZFt84tkjz+mF8zEmPv2HlXTkaypmKkuWPcjntan+ARMxYiJPsFaTdvbJjNjKpPR8ba5Sr9ZiSG7wT6+iNkwB+zKAWOT8SBuPP1ApFy39WyxYDNIGIaSb+dzPu50GBeGt+XUkZ6US6AaGXfNEsFelJDWBl9KBqHLcw6V4Lvpko5yQRIC6Pg+z6pLHqhNuoFkXGhSUzO1KX/K/x+NrTFgL/i82fNZNhkwDAK+Kd+zbTeocYCWtgg55ZJNu05GhUTQFiFVc5iPpMetWVJSsSHcofG45a5zUlZktkIg2ApiXpa3tBvfsYu1lEghCKTkpb6kb7tcy2uO7B7D0GdS1lyZGUPR4dpOmcoRH/IQg+XEXtO2bRZiQcsmhPi0ZEDX9xoVuqDUlrNyyUwsOBBOMX5eLcnIGckzunaDPdbRWHJb0RIBGkeBkwiu9JKuiBDA9+J7FD4f2IdMbb7KvW55khfLBSNxyz5bdHyft+WEddleXeN+0GFU5mgMm0HCi8pF9T30N9HGUhrjDl9CcGKveeLvYK0l1ZpbsyQioEKTkXOg1pjqgqmYU5Cza12BPJGnPOKIKzOnEiXKeqtu/S4XvKV8Mu2U2MPI42+yH/hMPSTXhsJqEukRe5JnxQ1D0aXn+VTGkpqahS3ce4YkEj6Frel7IU/NO27MK/7n4N/hScG4rFYH9GvtVnLrKmmeo2YjiHhfLriS55RkLM0NoehQ2Dmh6LBnHzGSl/xw+3//Z2vrX9wJ33Vh2uQ/JvmIANMoggFHyVKu+1M2WNGt7oqskg6LaHHBDHe+4LuRdVFNUTJgXpw2xQLKetokpjQISZlQ1GOE8NCmRJscKQJqvUAIDyWTFb0q9H8MVZbSoxUdr0bWd2Pa1Y7aZBjjUosK7QRPRTXFolfPr6hnSOmT69kqqejue0qGq+ePB9a4ZKXSVOTlLSJYR4iK0v5oG/JkTGrGP2IuMahG4OW68qLZKTtV+Lw8cxjOermKh7x7buBiEu+mCo4z7a8wnwBR4E6StXHjxKq65eXiP7Pd/pxR/pzD6JfUVCzFxOUd24JEDJBWUlCgcRGML8VXrHPIhX2GNU6UNi5fk1djCI95I77nnfVcEIQMuW+P6XgezcSW0zxlLGZ41uOtvsFgMULjiZD18AM6do1Nu85hEruRa5UytEM6vkIK6PqKysB5aog9ST+UnBWvOTYP2QldFu3YjNBUBHKbi3rOZBagMWQUHPsDfCl4PS+IhE9pNB3Pw8NjX/X4h/IpXTvg561tCm0ZiSlF2eJMvud1tuDj9FMMlgtG7LLOTpjwqphwkmYcy022/IRJVbIgZyHm9Ei4Kp3is0TzsryhUyYsycmriFyHpGLOV4UrHNviA254x3PxjIwxY7GNwmdJzpk9RcuaLbO/Gis+X87JZOr+bB2hbCwWvLHPsNLwfZ1SmYxt+YQ9c4ivwpVa9zP5KX8UfyAgYSf5gjW7TWhD3osXlHbBXI6ZmwQPyW1Rc2MWlFR8Em/wLktpyYCs1lwYQ0sEPJ0vSaTPL/trzoutITc196Mu7/Mlb+Ur4uIx77lEaZ+dyv1Ofjxwo3Q0dFRAamrOygVd2lTW8Pvsgr7tsiTjrf2S/eQXvJj+B7deCj5mJsbk1lGqbLHDVF7TsT3aIiQRPifW/XksZg2wQ5LbimfiK/59/C/4KnVj3VLkPBdurZMut+mJhDNuiImpqVm3EalYgIUuCc/lDxg0W+aIylb41uVs5yw45ZJRntAmRoua3FYs5Yyague8JbIt9zuKIhUzcrGgbXu8Z0xctthhk1f1a4ZmizYRXdtmanPe2DEDBljhFhZzMaI0LkFqImaciIZHYCsemQ9ZiAVzphiccHRhrnipPDp2QE9ETMqK2nhMxJzARnhSclY65GmiFGEVul5cJ5zKM3e/K3e5kaf07AZZrUlNxRv5mgN7xHtxwq7d57f1N4Qk3OhXCCFpyXVHxqrfMJHH9HG89227SY0hp6RlurwR5wihaNmELdXhUiuW5LSJeSffcF/fZ8KSS1PwKnVgpZsqx0OSUbHQBWM7wm8saUII3plrBraLh6Si5lS+4b55SE7JZV2DhAPxCZdlhodECek46NopwUfyBq2dPmDMCU/Kn2GwSBR9u0Uk25yWX/LI/1cU5DyM+jxP/8rCrB/tO66T7ET7FNXUATsKl+dam5SyvkWp9koJPUvfNF2hbPbHJQLJMr8LSGhTNgIkiwFDU9hrpAgc6alRYsum8EoRrNKEQm+AUgF56Ubfsb/m2NFeghCNdUmXdMI9AGJ/QGXSVSCCL+PVPrmWLrc28vqk5sYVLn9A1gQ79IMjxuVrrNBI6RPKPlJ4LshehCv8phI+8+KUJNx0NKzGf9dR24zL1ygZOi+t6rGsrzGmasbPDh7inqO38kLfoTtjf420umNxe6t0qFB1WBQXGFvRD46Zle/dakC18PyAcfqCJNyiqCZu3F9P8b0BtV5QVJecTP8rvuqysCM6wqmNW9aN7G6bUYsWmkwsSWyXvtjlTfmPBKqNthUdtc1CX2BtjSdCNsxBQyvy6XshbV/yPsv4bNACPL6b5HwSbjOr3H5pqStOzJ/wZcy4eovxNT3bd9m8wMCuuS4nUrycl4RSEijBpKzZSwIqY/mYjzgXt4yLkLXQY8u4D/ayNqzJFuuhT20tp7lgXteESrKbhOTaMCs178vFau/0r6MnKCFIa0vLF3wSbbEVS94uHvN1/QaB4/M+8XfYihU3uW5oPc7vuBHFTGtBZAN21R5n9Yy+SEiUxzN9yrbd4FLc0rUdYuHzHc/omw1aODh/JUqElVwXT2kHW3TMgGNviJGWYzHgtFoQoLgXbvH78hVjxhzYXd6J95yKjIqCt4u/XVnlPBWzF35BQUZtDS3T5Vqe0DMH1MJwaJ8wZUzX9kgacti8dhaVWhZsi122gxbrkeQnwRr/YXROaexqRzzKnZ0r8SS3BdzrhLyel5RWs5eEXGYuCnE7SKjLY57LV3wiHjHVBQftkM1YUBtICCmo2fFj3hTXDOlxr5W4PWImedLuUOg2Mvsp17ynEx9Q1Q6iMtKv6apd9s0Om1FIVH5KLQx7SehoaeyS1YavzQXXYkaLAYd2nw/sp4yKmgO1xkyx4CIAAQAASURBVFJXnJGS2A6FyChEQSQ77Jp1RsyRSH6oHZ9bCcF5ntGxawzsgL2wxagsVx3xc5thMNwL1si15sY4HvasarNjdwCYseRQ7RFKSdc85Dv7ghrNr4LHPM1vSCl5LB6w3Qo4SwsyWzEVY47FLv3Q4zQXGHbZsH124oisNrT1JpV1QSMX3NL3Qny9zhVj579njSt1zrbZpSUC2p5Hbd1KpZAZv4zuOR54GbPvtXle3nAtT1D4zO2Y+/a4ufacX3tf8Ky6JDc1WTMx68iQn8hHvLbXzfqqzb9Q/xMXZur89UT05QYbtkegJP+t/o+M1JCAhHWzgxWGJ94ev9Vf07X36QWKHn3+U/E7fia+4Jfeh4zKkm3RI5CS78xbPvOOGZWOkicR/KTTZVR0mFcVvnIHCgTMSNlRPZ7aV+yZY1rKZ6FzBiLiw/g+sSd4Oy95ZU85wDHPz/WUbdmjxz63OIjUffs5z8RXgBPCHtiPGYmxayI9jzZdWp5E/9nU9f/f1188jva8NZSMMKZEyagRRl1ibekCA1Sr6bhME/bgiqcxZQOXiNB6gRBBY3EK3G7WH2JxQi5ftYiCAWXtfIJSeCT+BvPi1AVGqDZFPSP2HXO60LMVICOrxmhT0I/vk9WjFXP5TumcBEMMZtUZKhWsRrp5E76gtVMS/3lcYFWntMJN6saCI4VHoed/djgpnDBLxisy151lS8lgdc13Nqa8ntDyt5BCkuvZ6npCv9cU+3CViBR6XZbF1cp+decHzssxSbhBWlyvfM3alLSj3dXK4P/XW+x7LXdQ0nkjZAtWtjFrcmjQlq1oD2sNm9FHeITc1q/oeQdsmwNei6+Q+KR6RKwGaFuRVter0XdejenH93gkfsFCuNcosgmPoyHfFBd84G8xqyq+E9/QsUOOxS6veI+mYmxOKPWSjrfNoX3Crwd9LjNNqS2XVUoi3Lh3WVtKbZjrkg86CX+/OOdArDfj5DFftNc5WRZMbU5XRC7021R0VMBE50TCZ2ELejLi3N6yyYCW8hjVGQbLTDg6z5E5ZDeOmJaacz2jS0zfD3hfOcTfrtdFW8tSV6z5bqJzWaUMvZjX+tqNXcWQCzNlLK/xCVkwIqZLxowPzMdUaHxcmtKX5f9zFUUZel3m+al7b6xhs/0T1thnzBk9sY3FcGtOSOSA2+o1e/5neNajFvXKt70wV0SyR2EW5HrigkZUl0n2lv3kF4Q25tI841B+SkFOKlyH9on9lMxWnMi3jOs3JGqdthhSkLJjjuiKiCvGbDJgPwk5TQv2kpAXywUlmsOgw7yuSZv0sET63JjFilo0tGucyVOO7RGlrYmFj8YSCsULTqgo2DX7K0HQvajDrNR8w/cM7CabDHguXjCu35BVY4pqTOgPaIfb9OQeJSk9u8FUXNOzG6zbITOWXMsTNswBMRFjccu23aTCEawS6xTmi4ZN7OOY13cErIqClu3TtR0M7nZpMbSJuBTONzuwXb4Tf2CNfXp2wDvhQDM79oHTjgjXJc/lmLm9ZqcZR0vEao1wzpVbYSFRVrGUM3pmjZG8pG37dG2bK3nJutkkxGNBzkv7Ox6JX7Dvd/mDfkrHrnEsNzjRt4Q0HaxI3YSg8Uq/tV/SU3tsml06wrHc34rvMVS0xDp9s4EVbno2FSMyO+W+/YSKmp5ImNuMkoqYiHN5QmRbPJB7jv5m91afuQrdeHkbayhOKZ7YhIqKU/GMnthm22whEZzIEySKPbPLW/kWi+HQHHMuz4lsC2VV0/27OMylmFCR07FDFH7zuT0ikT5v7RUSiabi0r6kNimfyn9LieadeIovYh7ZD6isXoneYuHzUrxh3Wyj0ayJFufcMhXX5HZGJLpM6xP+B+9/5Wu+ReHzdvG3HLf/DQULunaDR3IfvwEG/efyP3I5/edDHP7iIixEiEAgpLMPWVsixF13mq+61Va41YyVw1UxuisId3jHu5B6KX3a3paLpivPkNInUn1ksxvWK2tOsRrJViZzFiDjikvsD5wEHkleT+mGe8yKUxJ/HU+GLCs3ZnJipZhAtVaQjLKer8RSd0lMdwQq17XXq9FwK9xcpRndJRtp6xJq7p7PipYl29TGjR8D1SZvOm5PRFQmpdCzVV5xWc9pBZvk9XSV2XwX59iNDpjlJ6uwh5a/RW1SFsUF3ehgpSDuhHssq8sVAczYCk8mKOFT25zKZGTlDcbUVHqGr7oO3gFonUJzYrNYwCBli8gfEgUD1r2HePgc2v0V5NzdgIZc1t+z5X3IkjEXyy+bVJsen/r/njXZouV5LOuaW7PkIOixHrn39Tyt6fqK87zgK37DJHtLJ9qlK3f4XD5hUhes+SGxJ6mM5U0x5YvugEXlkpBmpaEwhp3E42RRrawee6zT8308Kchqw7t6jIfil/01zlPNs+qSrm0z9GLWQo/rvCJSikg5teesUQQr6Shci0ozjDzeLFNaymcj8plX7ubkS1yGqBTsJIrawrQ0XOXlCroRKsGrpVNpDoOQ5+UN27JPZQ0j6274Q9HlnCveVP/o8pyDIzwRclM8WwkH7/QFQki2409ZmhFeo6r3RMi+eUhBQUjIw7jr1ObzKS0CDlsxZ2lBbQ0zMs7lazbMAaXIWYgJEW3apsuxP1gpvO9Yun/iK/bMfQyWSpTsiDVyU7MdOSWpAApt2W0pFpXl+WLJz9bajc/W8m7piGOzqmI/CblqXm9rLZ4UzKqapSnZCROy2rAeucGcFHCRVWzHPlux8zO/mtXM65pASjJdU6H5g/5/U1QTap2z1f6Mz3BEtBs7x2vSblsiIFEefzDfsm52GQjnQT0I22gLZ+WCGB8lJG/FKQMzpCci8mZXOK5zBIIb4bKyu7ZNSwTsJSGzyvC0OmfDDuiogMq6OMZhA0uZ6YKJmPPI2+Rd5ax0AM/FKz6TH7DUNWfcsMs6M5sjEUzFhE+CfUpt+c68ZcNsrNTABssb8Rbfhnyg9p26XZe0lE/LU3xbnnMkNlFC8MZcE9uILdWhMJo34pQju9fkGS/Yln2MtbQ9j1S76M8X+myllH6qT+jaHm0iPCEbStY6SghGdUZB5bC0GCKb4OERE1CiifHZiWI6vmBcuM/qWT1bieo+9+5TGctt7RqkGzHiWLjpwMikPE66XGQl77nk09C9Fi/ra7q2zaW8YtdscyJPCG3Mqf6ae/IX9HF2pgU5x2GPxJPMSk1lXA703LhIUscmcGvRPb9NqjXGWh52I94uSp7ZtzzgkKnJSURAIj1+sO+oKKhx+psNs0+fFr83/4lErZOZMR+Kf8mW1+K6TnnS7jApDf9Yf8XL2//9n62tf/E4uhUdOtsNajXqTYsr2tEu2hQU1ZQkdGPZPxcqAYSq4wIgREhhZqsCVpuMcf5qNXK9E2Ytq2tavosKy/UMJXxKvVx5hgs9Q8mQdrjNorigHW5T6iWtYBNjjQNWmCVS+C7n11R4MsZrqFSxt9Y8RuCIW0JRm4zYcz9nbE3srTWFyZCWN5R60XSpJSWLVfd7B+5YlOd0owPyekLWeIWdL9rRr4yqKZg3YJCaULrYwU64R21d51vrDPVnqLPapA23WqHrFONVq4B2cN19ZTIHAalciEVRTV3HjCFRQ2b5CeDWCZutn7CoL7FWsywu0XqBp7pury7dft+YBdbkZOWlmwp4IVN7wYmQTDhz9jNTIJSk0HNO7Z8c+ayeuVi5YIcTnjFhg345ICLgWl5wLHpktWVU1FTG8FbfcMVbhhxhIsNQHlFR0A8Vj/stnk9rZqWm7Ss6Iub72ZIPOi0WleGydBqDcuGCzt0NtU3Hd3tLbQW3dU6fFt+I37O9+DXjOueMp4R8xrs64612KUOe9vDxHP1KRtTWcKpv0FT07IA8jbgQVwz0GmEpiT3JV/kFn0XbPNfntOs2b0t3Ol8TLXcDtGfsecdcZTUekglLLqprlPDpeB63VUlIyDvxlKnoclO/QJuSfnhMJLrEtsU1rtiX9QRra3Z6v2aSveW6eIo2JY+i/4lrXrOoL0A+XEHkr/MSHfq0CCi4O1zBIAiJtUetD+iQMMOQ2THrdpepHHFa+SzEwqndbc0TcezoaVgGosUFhRPFFSWv8ilR8/gDGfN27kheofB4Ma2IPSfGWpBz6Mf40ucmr7EWTsopIT6X8or77HMprziU97jRFWlaM7IzPow2mOgcm0KoAv40ndGRIRfcMtBdquZGDxAH60zTV0zLdzwPB7Rtn1wunfjThixQDOseA7HJifgW337uuM5Fyb7XX9lM1swGHh65yIitz40YEeotzuQpunkdBZJCZJyS8T7tOBCKLBgx5cTOGJgNClEwzRPnkZeXdO2AH+oLcrmgZ128Ys6Ml/qKtm2xRg8hoKCgFDkd2+Or8h0AQ7tOR4ZMTc7C5qTNzviKt7yrE6wwTOWIyLToFj3e6t9hvS8ITESXNhkFE52TURISr3Kuu7T4lu/os0VYhVSi5NqcMGSfmVhQ1tqNb8WUc/GWNbvNWFwhtCQkJBcZ74xzTvTskBYxIzFiJgwlGX2zQZHXyFwwEiN6dsCVfM/QuJzj5+UNu3Kw8nCnYs6N6bAUKdfiNfPskMgm7IstzvKMkZjQtm22g4RR5XEqz1jYEUYMiNSAZjjBe3nuJkKmyz+kb+jaHvt+l6f6DYVMCUnomD7v5QuGdp/ndcrQ9lxy1NQJ9BLRpsIwE3O0TYhoN0AONxXcUR+TigVPq/9C299mxz7gWr1nS7Z4X08ZiBbrkWBewbJZaf71inCwuQJB1LbElzGh30Mi8b2+sxoJn0C2KcyMXE9oe1sUZuZETxiW+pJe4Mg9QiiU8JCeT20dhtKXMRa94if7jWc3rydEXh9PROT1hNBz9CptK2LfRQ4q4bmoQa+Ptq57LsViNeKLVJdSL1aZv3cF9k4o5gkH1IhUH+lJjHW7XYCFPUcKx6n2VEyk+qsDhhCq4YT6tOQ6UdBjWV+57rzpYJQMaHkb1PZHdbahIlQdlPDxcF1N1nC578bISoar4InA7zihl16s/q7Qc0LlCu5d3vLdeyKEojSLlX/7bufe9Xa5LV6SBBukJY0HucSYHGMyRPMrIWXAbvQF0kqO7cdoqx3NSlRM1TUDuwkhzOozIr9PXo6J/DX27Ics5YxH4oBrFvhCsW8OyLVhUmp2k5B/SN9QiQIsnOqv+YX8X2gJn1udcZoWTAqPSV3wSb/F23nF1KZsyg6bkeD9sqajgtXp1qHnffqBZJRrjts+ubZMa0XfD/ik/BmTumAvSvhp/O9Qwgm6boqSbuCzrGu244DaOD+qsbBpdnmdLTiIWnxfXHFf7LHb9p3HGChEhhTwQG1xXadseB1KY0hNxYYfQwXPF8smFcdnIWb4ja96UlWs+QFUzg3wbvl3xME669FjwP2/F2KxOgRK6bGVfMqsPqOox6zFv6A0C654wU/sLylkzUHUQhu4LkoOkwhfwqRUbAaOhX3FmH1/Gwl0dEIsfJTtUogjbuQZ981DCmqX8esf8nX9xilq5TZYiKTi59EOT5czBjLmDDdO3g1jKgPWWmcds5f42ufzaJP1SKEXbQSwHinWQsXbRcmnnQFZbfGzHZaUdOkzLmoCqbgyM37Z2eTdsmTLT+gGzmM99GIST5LoTX69qfjNtSHXml/w73kpn5F5NxTVlEvxLVdCseF/QGRbtGxCIQoqNHtiyC09KluxZjYI8VgLPV6kZ6vxLrbH/ajLotJkuoeSggf2GAtMbcqu1+VNPSKhTYDPluow0QktGXBjQjZlh1d2hiXCYLhv7xEKRW5qCutIZZUo6YgN2qZFjN+87hASMhHXDO0an4eHpLXbb7Z8SZpVXMlzPpYPkAgyk7JmO1RWr1J8Mkp+qv4XKqupqFmIJW3bwmA59HukWpPaihmZU+ubXacc9n2mdUXPdOipkBN9y/2oy7RMeGuvGJpdtNAUdkGLmKEX83vzggfi5xhjWBcdlpR85B3wjX6LpuJRsM5lmZFT8kQdMNcV/zr8CVd5ydSmzMSChWkRE/BenlA13vZ10eaADXJTY5q5XE+FzLTf3GvhA7XnAD1skJKS0CUXKSNcVneMT6AEu9UWJ/KUsPJZZ5OiCVfIRMamOWJT9OgHPudFyoaXMKozPut3+JvpDF9ItswaZ+KSto5IRJfYRoxVmxFvXW2QIRvcY1N2wezz3kx5GPWZV5qb3HLYVhwWn/51i/DdCDcrnTCoEsumk3Q7zEov3ahXj1bK30nxhshzPuE7YZfF4MuETI8b8ZBaFZyyeQwpfOomrg+cmvlO/h15fQASMWDJjUvtoSBvFv+Vydw4WBaraw9km6yerIruXahCbUvKak4r3CRQbRblZfNmy5U4ClwM4x1LuqqXDvbRfM9i8KSDjdwUzwhUi1I7BXRqbykrtxud6DcrEpiSIbl248hlfbXaI5f1HDxnNwr8jqN8NY+lmpCJO29yZbJVApWSgVNMh+46hPRXYRUuhSp1li7VouvvkldjjCkJffda+qrtPNymACGhwWAu7BW+OOC9eEFCjyVjxsVrEn+DTfZJRI9SLfBF0uyrK6wwKOsxMTklFbl11qTKGqY259vsGx7YJ/ym+D/wVMwv1L+nxtka7sVt3mcZ3SDgTb3gbOngB/tej9s65/XcveaRUlyVKa/Ed/giJi0O8AuPkRixqY+5yGpKWzMuLTtxxO/zt/jFNm0/4tv5jDUVsx4GnOcZM1LmS7cDvJAXHNp9LhhxJDcdpEKM2BdDzpYVtXUkqiHrlMbyTDv/4cj4SCt5pPax1qLwWZCxp/rMdckRe4yso3bNbM6onPNePGVZXaNNyQPvV2ChIGcsRxzYXTbEv+I0PGNk3rBljsjkGE8mLOtruv4ufbvFpBGKfF3M2GMdieBdmtPzfCQudxhgaHsoCV/Wr/hV/ID3WcaVuHHsbzvmStywwyY73h4vyxu69DkMOujSCc60dQK1QTOJOrZH7EQhmbYs65r9VsC38xl9uszEgt+mp/jWJ8BntvQZerFLrrJvIT3iVI8JCZtuXfDGnjO0a8SE3OSaD/sh7xeakzTHF5I39oxHdp+2r3i9ELyorqjRSCHZMUfopOLd5L+sss19QowwFBRkIuVaOGFRQMxYuvXUttnj+XJOhx49GVEazViOeJ8rCipCfJ7yHCU8hmaT9/IFov7A3U/wMViem/ekcsbCXPEhv2JsMkLhWOlzOeESx072RUjLJkzEDNkc+sfilswm7MoBZ8ZR75b2hmdiylnp9CsbZpuoDkgpqCh4X0+YyhELO2LAkDP5mr7dorbGKXgbV0PbOvTrO3lBRJus6tMi4kJe0DJdXsiX9O0WV2hO62KVqfu1/QElPV7lbpesRUUlC6b2AoniQp7RM/fp2+2VV/mp+IFte8CkKpmIM3btB/ym/oZEdNm0G7zW14Q2pFV5jaBR4RNSodkN2tTlHjMx57V8ziPzmJGYsq+GPLWvODAHjLTL9X5eX/Hb6gyfkG228JBg4Z14yiP7CWMx41S+QaJY5g7L2TNrlDjOeiEKhrZP18acyFPe2ZTXVU0kWrRMQEHFKDe0bYvvxFMyMaYtNnkvzrEYXlb/bbWGXPcekskZOQuMXWcg2qz5AfNKsx37KAGT0q54C//c13+XRekuKB5Y5d6m1Q2ejFEyWHVmcBe113CTvRaR6hPK9oq/mqgho/IH2v42cTBgWp3QC/YByPR4FWwQqQG1dfnEwioi1UPbisIumOYnpN4tnnACKE3hiFBNAEMSrON5a9QmXe2V//wx83KK7yVudIxTH4eiQ6pv3EjaX3NsZl/ji6RJISpIfKcgvhuvK+HsSVEwQNuadrBFVk8A3O62PF+lT3kyRIkQbQtaaoMFF26vorqrx2zFG3giZFy+djeWhsDlyZDp0qUkRaq/8v4KoRooihNv1U0wRhh18Pw1xulLhPBY5Gfk1a3jd3sRoe8eI/sz0pbzSft0YhdSbzGs2V03KmaLOOxiMFzxnrbt0xLrjOs3K1b3QkzpmAEdGRJZ30XcGcPYZJzLtwQk/F7/nwyjR2ybexgsx0nCfkvy9W1FSsHr1NCnzaQq2fW6dAPJMGoRe4KrwnCvo9g3HQ7zXwLwIpvxQavDP6Yz3i1Llqakq0K6vkfbF3xUH/Ck7zEpYSbmPAo7ZLVlQY4WNXvBGi1PUi43eNyL2Sx2V/us/2v7E768dXCFT3ptLBEvZjmzUvORd0DiSa7y0p3aA0dB61ddLuQZfe06kbFd8kG0hjaOUHVlKhIxYGEvaEXbCCs5UGu8Mzes2z4d5XNb5yzsCE9EXIv3WG2Iw3WU8PAI2bTrbEcRV3lBYUOWlKtdlARiT1EZV4SFEJynFR/K45Vo5FjscGpHRLTZY51Tbrio4UhuEkjJf6n+hq7c5hfBI5QQBBJ2Ep9/XJ6zJ4bU1rKXKL6ZFGS1ZV25g9a9sM2s0nhCUBhDKB0rvKBmj102Wj6tep2boiBWHkaH7Kouz/UFQ9tnO/FoNXelvTgk15b/rX2P7ycl/VBylWk2GXDYCvmb9JXDA1pDJz4iLS7pxId0TN/dowh46G8yq/Y45ZJjsbNiWm95Lc7rBW0RUhrNkpJds00gFMIKfKFQeHwkHjCl4AvxOcoTLOoAJSSpLWnbTRa2yzEPGIkJlXA2vl27x9AeMLJ9HoZrzKqasc34RbJHoS2nufNMj4QDDeUi5VjsEphPiQh4kLR4sVwQC59EeXi1ZEabmBDMkG12ySgYml2u5QkH4lNanuK69AmEosYwFtccmgf0VYSVEEjJTLc5E8/osMEeW3QbH/aht0amNT4hm2aLoReT6YhYrTGuczetkNerTjyuYxJCDuKEL3OzQrH6IibHjX237eZKxKZQLHWNLySh9dA24q38Ab/8qPFq1/TtAyrce5soxec8otSGyDqkbN922GGNZaNlGQQh94KYw/IXVMaSGJ8R77lnnpCIAAHkVtFTIS1fcluEJJ6HkoJlueEStYxhRsrSljxJ+qxHkkHYRU7vcy1u0I7HhaZmPfiAzI4xjd2zb7dYt0NKNF0v4H5X8Xc3KTq1PO6539tS/JVhHTv9/5HaOFhDWc8RQpL4642nVhI06mhfJvgidh5ctCt2ekLX20UKj2n13tGmbE1tChJvyKK6IFTdRvTUWimfa52vij6wUgHfpTHdpQ15Kl4pf30vIVRdstoVm7vvG1OvlMNCSCKvR6GdACryeo7zbJar8fUdDvIu9xecWnuevacd7bpRuvCRzcha24Ki8TYrGVJUU6T0iLwey9L5h93fTxx3uQGS3CUzKRm4KYFy4g1rnc94+Wde4DtsZaWXtKJt8vLWHSxksFKB33XbWTmiHe265Cad/ROymDYpYaMwr02Oabp+h7M0hP46vtdiJ/yMqTld7eMD2SYQCYVd4IsYiWJSn5CXbqqx0/4pAB07pBIFoY0Z8Z779hNmwollznmxIsvssc1G6E6Q+y2fP87GPEn6VAa+K1x8YK4NF3nOZugC73+YZWhr8IVaofLuRCsALeXRDxSTUnNZL1e7uX8dPWFcaAqjyWxFjeFUvmHT7PNRMuA0K9DWsB1FPMud4jUhZMICD4827nUdiSmhDdn3esy1gz7MbE6Ixzv5hsi22LVbPJc/0LdbGAzzRtSza9zO7YrXTJu9nydjPlP/joVYci1OsNawZe+thCa3zDkTzxhnr4iCARLJmnefI3PEAifmSRo174KcR3Gf0ywjo2LHaxN5Am3gd/UPbJhtFI4tPCNjS3XIdL0ST30rvuLfBD9jPVL8v2ZPqSh4aB7xXP7Avw0/w8KqiHd9wR8nczaDhFxrEuVQf3tiyIm9oaLACMO+2cETkvdcMrRrzMSCpImhq6i4lZf0zQZn4hlr7PMT/5DbqmRhCyoq5nLCptliy094WbuuyscjEj4jO8MKw6244N38v61WS/34GCVD1uV9Mmas2W0WYkpiuxQiw7MebdthIebUouYhjlSmrWVk5wxEm+fiGVHD5b6LxDNYClGQ2IQARVeFTHTORMzwUMzEmLbtrxTPPiG7ZpsLcbXCvfo2YCFcWMmJPOHYHjGyM9bocCGuEY3VrUXEnJQAH4XinXzOmt1laHtMWGCFwbcBl/IdD8wHjMSUHdY45YYNO+AH8TWhaPPAPmBsF/RpOQ9tA9jZMUdo9Ip1XOIAQh2xQUXBPXPMa/mGbeM61VnzM0uRsmXXuGVOSMilfI/C4749ZmZzTuQzts099lSfN8ZNHbq2zRv5jM/Fp0x0zrW8JrYJwkpu5QUPjcvQnoprfCK2zD4n8hkx7sC/a/ZXhK3CLrhvPyLEI5IeC1OyHcZESvAP+WuklWzaDRY4i1kpMn6i7vEP+g/sm4cAvBZfUeoFn8n/kXfyDTNzzqZ4yAO5x0Tn+CguxBVzMWKpr5v7yoZDB4uYtu3zob9PrjWPewGRghcz5+QwWB50ff7T2L2uvx3/3/7Z2voXd8KR7FKL0FltVHelXN7wPyCzUwwVCKdozvQYT4TETccJkOobPOkKpPuq6fq7VDYlVF0KPVsFNsRqgLEVsTekIzdZ2hvS+tZlFstglQE8L8+Jg3VC1SXXEzpNYbkb3/oypucfMMqf04+OKfT/l7X/epI2yc48sZ+7vzp0RqRWnxb1lWrdAHqI3eEMSbMds13jH8kLGm/WeLFDgkPMYIABGo3urupSn1apRWToV7s7LzwyGnO1TbPOsjKrShnyPX7OeZ7f4wzr1hpC5TKK3e90I/VQtbDSoTIbwQahaFHaFIum0DMqvaAZ7dDx95jWpzRUj1l9zjR9TxJuEvtrRLLDuPxAM9xaKakJXOhD29shlW703JIbqMgn0yO60R0Ekmnpkl9KvWAtvI9EIULHn3bCse6SLX21mjI0wy0Xz8gNDX+TXI+xVpOE6zS8dSSKiT1ye+ZlulUnPmBenFMtASfW5Oh/9VzXJqfr32NqzqmWOFIhJD4Jo+oDA/8BqXXPsUQugyucJ/XAPGTbb/CqvmRfDLjDNhPrLDALO2SduysVs5IwLt1OttSwJhssasu4KpmIIW8XLSZixo08p28/53RR01Bul2esJastV6VmYlM+iB/4C/ULdhoeo8LRmAYqQQlBoQuGRc1CV6wHEbt+iBRQzfcwGEaFxlpLgUtZehCuoS1IoE9EL5Tc5JpJXdG2TToyYhAr0nmNJyTbqsmwzrhn7q0K2v/c/hGXmaYbSBb1Dld5iSclf6j/80r4dyA/54zXSCto2yaRfbQi+dySj97oX6OETxT0+Jn8d3hC0g8CpICsdh7sSAk8KXg7U1TG8qjlkoBiz2UP90JJs+ryMO7yXXaFh+Re2OWkWHApLxiXLojggfmEm6LiJE+RUvEL71MGsSKaPcOXgo1YsKghq92Bp+dFfNpTfJhLxoXm369t8zc3Z/wo3qIy0I8kgYTjhSbSO/hS8jR0he3lLKUvE/q2Rcv36Nc/5X4z4nhRcacRoUREaaDQfZfelBYra1g/Uvzz4owbecoT+wxlPNLGJ0zy9wgUgWrSEAN8G/JAPOOFeMuW2aEjIz7YSxo2YU02uBd0eJtPKISm4/mkWtO1Ddb8gB+bZ4zrAiUkcwrGcsQn8pDYk/y++MA+204pLIbcETu0fY//Wn5gz+5zLs+RSPpmwJg5G3adwtYu+1m2KGxBQ/n8WD3kTXnDuuhQ2JqB7RMJjwsxorR6udpRHEZNBtUXTEyBLxR92myEIdpaNusWlTA8CzfJa0ujTuh6Ib/gp7zRl2hr2JBtNiKf79OMXCzo2Q360uVYy9rFcQZSMjUFfRWT6prIU1hjlhnMGk2XTdVC2yZzW7IjezR9xSFP+UP5kbbvs+0FNNJPeSVfEOuQdboMQpfG1a+/QFvLTtBgWA3ZpEeoln/D8/mRv8/vc6e36IgIzCMCFC0ZopSg0BUt1njIAy7FiK7s0w08ZlnBuKzYigP2zDYPWjGlgfcLwYiax+ouQgh2zP3VIcoXCfvyGUMxJrINkNtgcWlgwieRHlfGdzGHsuYq+55M3nA//BUHbHHCkFxr7rcC2j5c5lAbV4C3E4/LzHDfW+dVffkn1dY/uQiXdr5CNd5+SOEzM5fkeowngj9exHXGvDrFRI6wlJc3+J7bld5agJz95482n9ss4spkK9ERwEX1HQCBalDbjMjv4ouEee3iDV1Bba+K0i2v05iKTGfIwFuRs2pbYkxF6LWxaCcqW47Pta3RuqbhrTPNj1zxw9mhFuUljWADVIusuiEzoxWFSiIJl/nK2hSOsVo7e9JtSMNqR6yHq9s3Mu9XqVK39ixtSoyK8VTMvD6ntuVq/1zrjFLPqW25YnDXJl/9PhfvWK06eXlb1KVTiN+mOXnK3R8XGVkiJQgZYW0Ny64/9DpIIVlUVzT9Le7IX/Ga3zLggLnfdqQfUZHbCdrWBLIBssG0PuXcSyiqdeZyzMg0eCP+QE3Ohn3AjZ5QeQUtz4knGp7gNK+YlorNxCOQku1EMRwbfuY/dVGCOua8bJBr1y1/P507TUGtEQLuNBK+WsxRwnds4PlDUuOKtbaWsc7p46D2c3KmZcqB6dEOJAkhH+V7jHbj71sq1IkdIqwLd38hv6dTrdOyHRoEXMoLlNlmUigsUFvDZuhjiBjVOYu6ZmQX/O3kmk/8bb6ZTZmLBZe849A8Xb0/mt4mN+IcYV0Q37m4pBAZO2aPjudzXg+5FBmRajMtTvgy+J+cqMaGDAu4sQsykfHQbjG0ZoXx09ZZwAyWR52Ati/JakvXtii1ZVf1ODZDdkXCL9baPB9HfCt/wMfRhXJbsxc1UPkOs7rmYpKhMZwuRmxlXSKpqKzBF5KFrvl6KCiNcdD7SYWwkmFR886c8UTv0gsVL4trAny2vBYvZ/nKLzozzsKTVs0VbctiqRfuEHWjM9ZUzKIWXNkJQ3nMhu7xcT5iXw7omTZH8pQxp6xzl2v9Pa1oj1LPyZlivENOrCIXc07lMUMbk4sFlSg454jHxWNe2l+zJZ7wRrv9ekuscVG5/NwOXbCgl0fUN/qSXdMnsglXTGjVCb4IuTELZNV0wTM2pWW6TiUtxnRsl/fyDRbj0IY2ZCZvWOgOL+0HlygmOgjjsbAlY5tyKl6wJR6R2IS5WPA6r5nIG2444pH9CefyhLOiQWAjtNCs2y7Gutvn4/NGX5KLBQqPlALfKv637O845DO2zTYjMWVkMipTcyE/MrVdDsw2NYaz2mFys1oRiQaFrVmIlKZ1PHWJ4I18zif2U74tz9iwAzr0qIzh23RMTMimOSCj4L18yXHVw7chFo1AkdopMQ1mtmCsNT3aXNUpx7WLLqyEg7wA3IgJvnEhHG1iCutzutQyLHSbWVbylflbdtVnyHzHBaPMBSecU8gMieS4CgnxKUSx5Gc3adt15nJK1/R4L76jQZ+eXeOlfE1AzNwOl2u4PYb5K5QM+XHwHzgTR0xMl/veBt3Qhb/Ma8G8Mhy2PCoDF6mmHUjutjx+d33zJ9XWP70TFh20qphWpy4LV7q0o3F9hCcCGt4GAklp54SqQ+R1HSzAzmhH+zTVBqkZES6VycUyPN6TCQ1vncJMV0AMpzb2aHpbLMQVoWyT6xGJP8AXydIG1cJavUpA8kS4GuEqEYLC4SD1jEh1Ufg0vHVX8IRHrqeu8FsfISR5deP8unq02sPexg8KIfFExKT4SK0zFsUZcbDORfmHf1UAa0dIMSlJ0F/mATsBWjc4ZFIdOYu5rVYLfiV8Em9tJdK63cve+owD2SBUrVURD1UHaVJqkRF5naXvd+H28MLDYv47EEgz2GRRXTkEXLhFXt0sAy5Kaj3HU02qerQ6LGANjfiQdrhLT+zTDXbJmVNQ8KX9KxSS59ygRY3Cpyt28f2ESXVMVlzTTe5yXnzDvv8/EZpdEhHQEuuM7BELMeaJ/BU9YnwJvdB1SXeShKYv8eXSzG9hPYg4LRf0vZgHbZ98EtHyFVlt+UW/xbS0pEoQKsE38xG/6m4yzNfJakPDl7RRzCpNL/AZCJ9Cu6XCvbDLi/KSyBN0A8lTr8FTnnG8cMkpSjjvats0UUhi5fHMfEqyDI8AUOW+s5QYlzm8FkkKDRf1gntRm8uiIBMZzwLne3QUZ8Pn/IS/zf9vlPWURrjNgENSpizsNZfimgO2aXk+p+WcXBsueU2tXaRjN7yDZ11n3/AU/UjxYDkev841O1FAVvucZSVoF4oxJ6eVdmh4rlO+ERP2ZIOGUBzUA4LlWFkJwUPziHw5og9xhxdfKAahT6Y97rUUk7LFrLJcFgUKQeIrtv2QxBO8n9d40uO4TPkf1zbpBfBpfch1bhnmmvvBYJU57MuIWAknwPNChvqGTT/hpJpTUfGLzjoC+DAvuR+38JZpPa06wdp99pOIfh3Q8CRk0DZdHqsD3psrkmB9lVzW9LfYMHvseG0OGfDcfMQnpGN6eEhq+vRCn/3yC7ZY48pMuOf3Oa6mdISLk4zxudeKuc40X5sL7uDiB7s08YUikgqlJUfyCN94COmC6nNTsxGu4QnB82zEmtmiEhVPxFNipdgyHeaUpExI9ZCpOORCXpLYJg1ifsQvWY8CLvOSnojJbU1hG/xY/CWVXTYPBGzJLjNTEEjFWZGyLdYYk5KT0jBthvKUdTug7fv06n3WaKx2qiEePRmzZp/iCcla6PG+OOEee+jlhjIkYsqCXMzZF+tIBJGS3KseE3uKA7NFaisexm1qa/Frn4YI8K0D0HxiP6WhPBa6prA1m0HMTdXnmjETMeYvGgeMS4O1FiGaXJUZDRMTCMXc5izEmMK26fkNSm1AO0fCuC5W66iWt0Xf9JFCkFhHpfvcO+CkWDAXC3w8agw92+aSAmElu2KLjvKppeW+91dMq5oZ5YqR/8Q7YKFr/mv+/0BKD0/GtETI581nXKSa9/WQn8cbTCvDqIAnXcVhorkqJYNQoS0MCyjs/M9bhOf6ErtkldxafGq7zM7Vi1UBXlRXRF6XWPXI9Mj5bo0rZNP8iE50ZxU4X1u3i7RSo21F/a9SJ8p6RuaNyKobZLAsyPqKcfGedrhLWjkP1qL8Y8uvZLDK8b0FZ0jhkZorcukjkGSlC7S/7chrk7lYRRWvuspKL6h17nJ+hQubSESPVA3xVExoO85bvEw7ksJDSh9fxquDxTh7uxoV34Lxb/+9RVO6wqscVGM58i2qCdKXq137H79PrpKYqnqxRFzO8ElQMvzjAUP6q1CHvBw5RvfSB33L2hZLELo2KVKG2OXfCPwBgdeiKTaYM6Rnd0hoUlEyJaOipGs3ueYjvohZMGJcfiAtrgj9zkq0VuBwlBObki0pRDFtLM52kdcun/bbUe5OuUHA8UIzrDOapduJJyKgNIbf3MwoqNhNekwrw4uxi7QblRX+8tBykWqUhPf1kHbdYM2L+Ma8wit9fh7e51V5TS5S9tnGtwG/Ld/yE+7RCSSni5qxznlvpqzbHpH02AgS3pTXfLBD2vQI65Bzc8Qdc5+Cmr5MnBK5nFGZJqmuSUXK35fviEWbJ/KA2tgVXSsVU/6x+hfKekrgtYn9Nabiiobtsi2eIpG8E0dEVYOJvGJiu87/red4MuYn4meMbMZMl4QyYloaRkXND7zmU/GQUeGykD9yxoHdpusH9ERIZUBbUAKeBdsMi5KdJOQP5UdU5vNzscuZnuJMch4f5Rvum0doC087EZe5Jtea01TwKhuzqVp0/YCjcsLHasIndp+v80vuqw0ST/BRvmJ79iVfVyVNz+e1PiWyCTEhDRHwTl+xxRpZLVkPIl5WjhB1VWWEeMT4/G4ypiMizrjhOkuclciLWPdjzvU5f5P9lvvmCRQ4FrjIUKLDBj2ug0NOZv+EkhFKhpyoV3T0F1wzpm27ZCLjWL5mze6gqXhZFEgheC+OmDNE1xojDHNmKOFT2YoXM82R/EDDdjnmgoCId+IbNrmPr30qURHZJhU1Tdt1o292+F15xo7Zokm0IkGNzILX5gIPn312WTf7pKqHbxTSSmZyxJBTYtrcZF2OxHN2zSNnCxRX9E2HgpoNs+3WFkqRGsnClBgsP4gfiEWbx+KA/1r/f+hzlwU5X9Un7mekpK9iXutviHmKNoZzec6Vfs2D7OeMxBEVDn+6YESTPgsxQqL4A1+jbcVWfQ8ELOqcXKSM5QWjfI+mbbgds53RICIXGX2R/DHjW55RlOsUFKRyTst0mZaG83Kx8hIDXEhH0FvYa7btU2oMWa0prJNIvdZXVLJky2xxIS9J9ZBzdUpm+jSWB9NpVZNROAX9cuoyElNCIk7ED0j7jFnlYC4v9ZDIJmyIDoltciGPOTOamTmnrGc0ox0eqb/imAuSdJfIE3werDMsjJsyYfgvl3O+7DY5STWXZcrjVhNroSn6f94iDMvsW+mA2bciCGPqZfGpCUQT45nlXtKNNhNvDb2EfAReCykkpSmIVY8QqEzqYBx2sSJCGYwTU9maZrCNRbPQbg/qMI1mtf+8VWPn9RhfxgjfdXUCx1cOVcd5j5d5v5W/IPEHGFvhe86H7OATLSLpPL5+EJPXk9VhIS9HLNQ1eXWzylEO/Q7NcAtw+15PhESyQ6qvkUISB4MlKCRDCEk/ekhmRv8dGzpQTSb5keu0VUziO+arJyLqJWPbU7HjUltH8Yr9ZQiDzvGWFxs31nfhE3k9WX7dhWIkvstMrowTf5mlX9iNnyVY5w+VMibwW8SqR2LblMIxeYWV9HGowdDGLuJNNimsAztI4dOMdjC2IlI99u0TPorn7NtHTOUYgQO337G7lGhmpuBR0uTbccphI+bDImNR+YzKglj4TEo3imr7TvCmtEDbACFgO1HkWvFympFIj4Wu2PHadJZJPI1lsk2gBOv1FmuyQdMXfMo62rrgiG3VJtYBr/MxP1kGWhxETdZr15FvxJIPc00uUmLboG2btFVIoh/QUD6Frmn6itpYGgTca3ucpZKm3uC4ipxISrodrUJRU3Jdv2aSvkYuveix7PEZzxhZh8rc9BosdI/SusNLQU62fK09i/4vNH1FY4lW1NbSCSSVUewXB1yyYKEDagwJTaQUzGvnRfeX431j4ev5mAO/w2lasGU3APiYuli8gWiihOAn4jOMtGwnitfTcpWcZIF7keuqh7nm81YPa3ssakNcRUSewJPwzH5KJ1DsNRJeT0t22eReO0Rb+PX8jA16VFa7ziyUbNdrVNawEYVMSnebHzcTjhcVsY74st2h0DAtNZuJxyYP+bvpMRLB3UbCv6RndG2bjVjxm8VXPDafccI/0Y72SNSARHQpTU0mU+Ziwr7Zp2udcv2JuAfAjc5o2yYZa7SJ8YTkI2cEVmEwtGTIwGyTijkbdsBeHLNTuEg+IeA31Qt6xrklOrbLUNQMxZDENDmV5zxgH9+GbgxKTGV79G2HpudT1DEbtoMVcE/s0vQVP5QXS0/zgo7Y4r6/xlok+d/mV1RoLuUZGVOemE8pjWEziIk9N9XoFs840xNOGHNP/JTcpvRFi2tO3T7Uaua12zUvRMoCWDPrKOnRIUHbigkpT+QdJnqb9SDmQ9llIm8IbMwuAxLlcVPnnMsLuqbngCWiYqASCqOpraHGgXB6kUee1VyIG7d7BTw8ts02EzEjVII7cZO1MsaXgosq5aF9gBICLSypLVmQEakm59WEnmiyxybXZoZAkJgm6+oBP/LvkdUuGtJg+YZv+In3BbnWSCm4NnPWbRclJMI+JSZcKaiNXWMixlxa+CLZ5E3a4ER+pLYFjWiLu97P6dMitSGn9ZS5nvGr5gF3W5LSwB9uNAU1Z6nmXXnDo2iNXuC0Ewd270+qq3+yOrrTeLYal96mEHWDQ+b6cuXzBWdliryuGxWrHtPyeCWSsjjs5K1HVwoPT4TkSztPoBpoW69yeQPfjZxX41sZrjpgb9l1hqrtiFOySbpEVHaDQ26KNy7nNtymXnaG7tDgwhIkkqwarSD3g/ARhZ2j8JlUjjJ1q6z2VYNFfu4ygv+VYjorHOtZqcApw29V1V6DohoT+t1lJnBO6HcoKmeJKusZcTBYhVxIJJPs4wp/edtVAkRel9oWK4Rh5HVIy+Gya3ZpUrdq7RXSc9nJN8MtSrOgqMbOaoWmqufUeoYQbgxvTIGUIZG/TjPcIlY9mvSJbcK1cIHwCW6n7tuAwEZciHcM81esx0+pbLZKd0q8Pjv2EVfyiMyM2BefUlFyX+5QGM1a6JPWhravaAWS303GPE7aPOpI/uWqpjRmFdw+FEPW7YD7jSaXmcsPzmrDXtPjcik2ej3L6foBo7JgEIZEyu1nPCkYliUvxXP+KvicUltmdc2VnbAje7ziAw3TZl+t8Tv7Nf8m+BEf8jkFJamYExIxoMslI3ZFn+/4nh1zl8OwxUnxx0Dvt+IdvwgesxEp/n58RYOIY3lEx/RpkTAWM47NN1zNfr9K+Ool9+mqfWLr8qhzseC+vU8oFB/sJQsxZqyPyOsxG+EntKw7TbdtC4lgP2qQ15a9pscwN/xT+ZyeWefAcyk6kZIrfOF7e8YTb5dv9Dt2zQ5POw1eT3O6vs+wdGPMvUZAIAVvZy5Wcbb0/SoBP0wXdFTItU45jJo0fcnfLl64YuaFzLQDqdwNunwoJ5zItzw2n7AdR7zIRigUbRGxGQVcFxUNz+OH6pjENvm0scaLxZSMnF3V4505W8XVzcm5F3YZluUSPqGX6mT3z4G3xnbi8fvpiEIU3FXrfGfeEdiYD/W/oE1Be2l3NFQ8sz/jUlxjMGhRE9kGczHmob3HO3HE3A4d+UgeA7Bj7rKhGhzpG7o0GYoJM3HDwGw73zSaJhEZFRUV5/IdbesK8bl5Tl/dpW82GMnhioM80h8IZZu22CBnvpw9+BSkDJYkqYvlxf8zvuSVeIuHj7Ie+2zzVrznIXeXaUVvWJgh+zyjQcxH+YYDc5938jm1LXhsv2QobhhyzL59QojPK/E1vohRS9JYx64zF2NK0pWbQaJImfDQPF3R1kbihp5d46N8RceuYzAUIqNvNrmUx86OZLa4Wdqt+rbLpbhajtajVdxmbOPVc3VRLwhQ9L2Yi3pBKlIqSg7EFh/tOYltUlNzKl7SFTv0TJ8z+YEts09LxIzsnIkc0jcb+Hi0ZMilcQr1GneAPrcvucePkQjO5Afadp3QhrRJuBTXy+hLQy5SRpzRYZMbjlfOnki0WTdbfNZ0Hbq28NXikl+0NxzudFHRCz3O84LtKCStDVdVtnILSATf2Be8vPm//+/W1j+5E479tWWHltOW22R2QiiaaFW57kn0Vt3Rv/4IvTYN5V6g8/p8GfYQogjxREQomkSyQ03uSCS4XWkp53gyASCtrhyKcpmx21JbbmRRX67G3onskeLCBISQy5AHTVpekwQDsmVIw21RC1RztQutTMawfE1WukD6aNltbiafL7vXBb3kAVntIsIEEk+GGL+zhGg4aIbF0In2EaiVoEpIN1L2ZEgcHy7FbTWRaq9G0Er4tGJ30ZBIDIbQa68OD7dRkOBEXqHfoTYZnkpYSx4g8VnUVwSqyaK4pBluUYgphZ4ihHKxjLWDPehlvCS2BhEghE87uceG/4SR/kBMm7ZxNotAJHj4BDZm066hhOStfE/PbpP6zkt9OzK3GDeiFlMGdpdvs6/wkog79hmBkg4/6QtmleYyL0k8xzlWQvD7oV4RsKhCPu+0+fXEUa5cdq9iWtVoa7lIBR/KCZdFyJ1GQqggqz1OigU/6bZZ1JbaWA6SiG71OUoI9puK61wi8g6dwOPfhw85T2uavuRO+ohBpLgqApqE7Moul3rhuki7RqIUaTXiUobExSGR8Fcjrg2zQ2UgVPBp0qc0lqC4y4k450k4oMgr0uqaRrRPWpwRB33uih9zYl9y195BCMHMZKSUNFSC1hUBMUU9xZiae+YBGsNh3OC6qDhsBhQaLvOMdzPDc/uWdbPFQDbJjebTXsh1btmv1rk0M34c76MtBHXMmDn/OJmzITpclTkPWgnXmebtLKMfhOSm5m4colPLvHL7290oYVFrtv0GN0VFpELu2zvcbTvF6/uZoUcDJWFdNUn0U75cS4gUxN4abV8wKhzoY1QKslrTtC18PGaVoaBkjRafdAOecsjJwrjnzovZiCXtMiKrLaV22c69UPF302O2Ew9t4U7YYVRWKClYq9eZCRcHmpVDWsEOAklTbPBevCO1I2qb88D+hEIUPLD33K5VpGxaRz5KbdcJ1NC8MseEIkJaQUVBy67RJCKSHpdmypofMqsVI6t5YD4hFB4nXPCX6v/I3JTMyRiYDbpeyHf6knvip0grWaNBpNSStOYu2L6SfFwiDnftQy6Z8Kl8iLaWCkMkFX29QeBJlAj4sXjGcLk6yyjZNu51uW73eRpuIBBsmITzsrfKFvZFzD3zmIySuZiyQY8n3iY3VUk/CMi1A9H06ONyuArWaLGp9lnomsfmE3biiL8tfse2uYtC8dA+IrUlQ3FDYCNaJHzaaTIpEy5zNyL/0nvIcTmjoKBrW+w2fP5l9pKfiB85tXvQZFE7FvmZnnBf7aCE4KpO8UVM23SpqNg1d1wqmx/wtr4itg0KUTAUl3S4x9O4z/tszkA2KWyThCYbskVuavbMPXzUMsq0QuEzkE1Ko6lsRIeus8zJgsv6JZ/Kv2bKjIVIyXWX7USyqN2kbVpaeqHEk4K9huRhO+a7keZhx2NQNNlOBO9mAiUEfhb+SbX1Ty7Cxi6Ny6bgSr90UYBMV0Wskul/1+kW2vlsPREyqY6JvS61LVd+YImksDNK6QKTbwUVngjJzXRFhZLCR0qfRXm5gtnP9LmzQpXXKwZ1tdzt5noMOKtUXo5Wau7bzvKWd72orpadaQNPxhT1mMBrrfbKSgakekheu/g/ISSBapKW13gqYppd0ojcODorhyTBulMJA2k9dHYg4VFpt7/VtsLH7Z1dF++sVMbWqwNCXo5WyErXpdbUMltRtxrRlgtisDVV7dSc0+IEJYPlvtftuN0YvaasZkjpLalaEZWeIoSHS7rSWFPgeR2Kaoz2K3bkJ5zp52yJHa6WZKGB2eCjfOVOylZynP+W2F+j4W2Q6RHr6gFz72LlAa+8DCF2CP0O2zzgSp6TVTlfRFsYnBDIVx7j0jCtahqexyCSvJs55KMQgt9NxrRJnOJzVvLcvuWvokecZAXDsmAgm7y3ZzyQBxwvKiYmpyVDfjOe4CEp0UzqkN045GOaMSoc4WgjCrgpao5zN/qOvYChGHKWNihtTUZJW8dUVBzZOYdig+sqdwI62ybFoTabRMTKY6I1R+WEatJyJC2ZcM4QLWqO8gW/z/+ftKIdJtkHknCbtLziW/MfAXge+xyax3wQP7BtH3Bcl7yv/mlFQevEhxTUtETIpNT4QqItzCpDIJXbD4uYPb9NqCSTsuZvbs44VAMq6xJ+JqVmr+nzsN5aBa57QqKxNDyBDhWl8fCkO1ScLWp8KeiFikVleJOPWVdNNmKPybxiWmq6gc8PU6di3goSnlfXXBaCSz6wzyO+uhFsRhGXRbEKV7/I3IrhNlmpxvCyunCdshdwmhoqY1nUGmvh1/UPPM4esx0HXOUlZ9yQiwX/NnjADgOshR9m7j0xFENkJZnLsRNe+XvOUod01xI7JRRNSjMnlo4zfMZrQvuMEN8l6Sx3h7lYsGM2KaiZA6mYE1k3NWvbJi3lpmZzOeW4UgzlJTOuuGOfIa0AAW+Xec+RbTATY8J6hy3xiDfm14Sqw0RsYYwmFDFFXeKhMNoSEtJmnbmYEtmEhXaIyaG8wLchE3HOyGzQMG1SOccXIWu2w4X8yGc849xMCAk5yt0UKbFNbuQFHdvnShwhkLyXrzkw9xmJgtSUvKnfEIgYv9rDF5JreU7H9AlRTOQQaSTjekEuUlI5Y5xtoqRTGmsqcgIUf/RcX5Hy24lm22vyQrygZfvkZZuzZSJSadd4NwsQyJXS+oN0qMt7+gGVqHi/zP29klcEOO1FSMiCjGt5ybu6crVDZCSmSUjMBy4ZZS23kzZzWiJmIm+YcMMabg89EikhkSOJ1b9Hez/iWnxknbsAnNkf8G3CJH3Lh/YWz+znTG1Ori2LGk4WFZHwWdSaSAmem48c1Pf5zXXKnJw9s4YQrmNu+JJRoVfpXH+2IqxtRSCbhN4G4/LDH7GN1hCp7vJ7CmfxKY/xVcN9v2wSq96SGOXRUltM6iPHaZbJKjHpX7OaA9mkqTbQVEsq1ZxauKCFRPWx1jhSjm8IVINANVDCX9FMGtKN8Eo5I1Atly7kdwmX/x3IJlbGCKGIVBeLXqmylfBp+TtMyo8rZbQvGySqT2nmK/9vO94HHMCjGe0sgxkqSu32yLddt7NWlUTLw0fDc1MBiaK0KbVZLHnUbbzQ2YwqWO28BRIVhitcpkC5vbip8b2EWucruldtChrL2yeFtwR6jJZjeJfRjDXL2EIfbM1G81OaYoO27XHOW7pqn8rUJKaJpE1BSUIHaSVN22YtvM+ofAfAL9W/5QVv6Ph7TCqXYWzRXNQ/8MT7HzhQPRa6Rz/0GZU190N3EdtMFNZCqRXjqqQbRDzpRLyelnhS8LNulxeTHG3hvblk3+6z15DMK5+zagEG7qsdAPqhx5ZsYSwkpaITKHwJw8Kxqu80EnJtWFSGbigpjeJO5IhZXy+ueeLtEytBW4W0bMi5mfA07rOoDDd1ToXmjn2GwdIRbjJzzg1bZo0ncY9X2ZTzesZnzR7fz6e0aXEp5gzFcKWqF0IyiB5zaZzdrhFsUNmUt+JbApEgreRKHhN7a8z0Ce1ony3xiEtxxkDc50jfsCE6gMe0qjBYPCTP/D1iTzAuNW/tids7+opMaxqe42F/nJfc6IyWcDnBSgh+uhZzlhragUTlLi1qJ4rdY+QrlIDKwGHQcTmtxmcrCtmIJYvKsp00UQISD2bXfXqBTz/vMCdnJ47ohhIIafluVzksSzbCkDaKUjtvczvo8mFWsZm4adSkXNKVhOCOvs938g8cqp9xpxmypbcIlKDU7utN343lO4HkaB7xDd+twBq315lD+5TSVk6QZ7eZiB1KW3EpT2nQR1jJuh9zXeUM/IjKWLp6nYyKEI8tu8GpOHf4Q+uub6mpmdkMKSRNIrr2Dgu7w1TM6ZKQihkBMR2zRojPgRzQCBXvq3dseI95Iu6ghOA7845Hapc3+pKRuEJT8YX4hPemoG3X2PQaRJ5gg5B27g6mW3aTlgx4Lh3Occ0PuahSGraLEXYVF7qjNujaCG0tG7RBQM+0aSjHZu/IiL68z9A4X3skPQqriaTCWLNCMFblJoUo2GINaDE1HVKRcs84bUQ38LjKSz6KM4xwU8Bds8NGGHFdFETyjwXoE55QGs3dZszHRcGAXSyWNT8iq3a4kMdky6VDy3bYCmPW9CHH9YSEECUkXRlhbY9qeY3fTUJiT/Bm2sATEk8JMq3JbUVL+TzlDi/1MSM5pG8GeNZjIJv0Ap+5GPNA7tCv15iR0qXJOYqrxXd0knvsm0f0I5+28dmMFVeZEyhuhCG1sbQDwf9B3sOX0PR8/pftiDdzuMkNkxIedxSDUHF11f2TauufXIQd89SdaJv+FpVJVyxmKSSz8swRnfRkteu1aCbV8Sr9yBMhmXWc1Ky+WamXb33CsOQ26xLfSwhUk2l9jNbligR1O8K93UMbW1PU0+W+tEupF2hbMC/OUNIVr9sgiFvG9XwJ/bDWUIr5KoZQm9J1wtpJy6Xwafk9JuVHUj0kkM0VDOM2b9PiGM63RdDYavm3yiUac4SnIko9Z1FeUqjpio+dVtcu+aicUKulSluGGFOTVleU9YxWtLvKlvVURDvaJ6vdBb7W+aprj7zuSl1urVl2/q5buFVYs3wOnTraIFVCbQo2xA4eEiPcG+E1v6UhBy7uy9wB0+VanlKIjGnlLF61Kfit/Edm5ZnLZTYFDX+TrtjlkhfEhDzXRzyUe8RK8jofU07cpODD3Kmk10KPi7rkLFVMTE5HRtxt+byauNv7oK2Q022+q455Pg5JPAkVBFKRG83LmTtNb0cx80rjS8G7RUrXcwXnvJ5RmgbaWkdgmkb81v4jd4vPXYcnnUfxfZ3RYPkaRfFVfuoeLsEqZ3fTHPBP+v+9vJ/r9O3PaPiCdh4xtTnv5hkFJblIGZgtzuQHBvFjQpqIWDKwuxxEDxmJG5q2TWwDLuQlY3vKe77Canchu0WbChSamrstnyAdoARESrAdB0xLw7QueVVe80ytc9D0CdMDDDCt9DLuTzMIA/5QnNKljRSCnThkLRQcLwydQPLteEFBzWHk4gfHOufQd37ili/4YbZYMnV9lBD8Nku5kyScpBVt3+O6KImk4roo6QchN+WM66LiQ1ZSY4hzd6jeiSNeZVNGcsiW2eT7+oo7+Q6XZsrR1LAluyyM+5mmCOl6IQ/qT7jJNUoIfl1/y0/Vs1Us3dejjI/imEG+QUdGxLTRVCS2zcfin/FUzPf671j3HzHSH9CqJqHJXExo2C7XfOBSgq42OZPvCOtPiaQiFykTMVyt1CKaTMQYlwdc4NsQJXwUPhWad+I9e3Yf3/ogILINKlEwkTe0TJdLe8FGsck2+3xv/itbcgsfxVwM+cZoNuw2uVjg48hbRhiu5SVevUVdu3F9JSqUVczkiE+4z2fyATkOHLPuJZyYj5zZG0zRo2kbvNGXHMgBR9YVdy1qFnJEz+ywTo8TO3RWH3+dSV1xbibM5ZSL8gcC1eSVqNgt71BTkyz90EN5ysJe0xd3SG3EW/uasEhAOPHREadUFJzKc8ZFk0pUSCuRSCpq3nDBQ3nIPy1O+Em8w1GWU5NwUaXMxISAmJ6MeW+/Y4t1figv6NoWCsWpPMdiyO2cdbOHj09BgZ+5gvxc/OAOPnWfSlTcyFNm9T4zOQIBh+aACk1GTW5q5pVEohjWGd/bf2RbPuE7fsDDgah21Wc0Ccnr26jF2E3qygW7KuSyqjleOLDHv8xuaBDzh3GLD/OcjShgURleTNzr9lt+9yfV1j+5CAeqicQlHmlbUZoFZTWjFe1Qm4JWsL3y+WbViIa/jrFOCFUBDW/ddYs4C8+tHShRfQrhk6g+ArkS+vgydmNqJFHQQwkfazXhkh3tvq7Iamcbstas8IqlWSxHy+HyWioJpBtJ3XbEehmGYJawidIYEn/gFNTaKbWzeriMRHQHBVfg9FKEFSOFzzQ/ohXtUOoFSniraMNaZyT+gCjouQ5WKOJggERS25JENZfK5wC5/B43Og/xVERejYj8HkqE+F4DgST2XDceqObqYCOlh0C6sblxeb6342pt8tVBSes5YnnwsLZAqdZyNA3X0gHat+wjtuwac+4wsjccsE2+TNFcM1t8sF+RlzcMkqekesisPEPrkrXwHte8dr9LvyVSPaQV3BO7bCYe1sKO12ZalwzFhM/DLSpjkQLWVMwn3YC/H2bkpqblB9xrBwxzw0VmKYwT49ya4bMsZ8drMq0qHrUa3ORuPJTVglBJ9jyntDxOnUXhxA7ZoMedqEXDF0TZr4g9N31pB4Kb3KMwMe/0FQdywJWek4op9+xd8uUqY4cBgZIciT5WGQYcMCVlXsXESrEduPzTuZiSmCZvxVf07SF923cABFlR2JwDNeDSnlHbmufiGwKaDDhACMWx+WoFhWmLLRomQSL5j9M3SCv5aXSItksKlRJsiphIJSxqS64tlbFsJopQKj7Oa9YTn+8XI1I5xaLJTELf9Hk1qekEiu8nCz7tNng7LWl4kkJbFJJ3s5IzPSEm5GGjxXrklM9vpppHcYNp6Q5QFotYXhs+7UW8m9bsqh5t32MgnACvFypiTxAraAddGl6X/zS8om07bMQ+R1mBRNLwPN7UH3ki7pAbzcf6hi3ZJdcOAvIpT6mMZSP2eDUvWPMiBvUGGTk94lWQvBGW916Lafqe3fYv6Zg+e2Kf0rjmoUazbntcitc0bZcL+ZFNc4gRlkHkcbZo018K4Y7kOzzrEdmEuZwS2SZP/G1GZcGcnJ4X0TD3QUJmStZCn0Xe50i847F9jBDQMM5aFXuS8+IexlgXt0eIwueN+AN3zDPWVZPQl0zrOZtml8NGzKI2zCvNxOQYLA2zQxRIJlW1QrVqa3kmHmGBSEmoYU3GvLJHPJT7jHXOa75x/ACboHEkp4/VhEAJJlWKhyK2CY/lX7IuHSpVeDCvHdq0FDkPzWM88ZS1wKcyUJcaLWr6tsOZuERTcWDuEAoPjVlFC36QH+nZNg85JDc1XdpktcUIw0A6mt2izjgQXVqex4PyM6Zk/CTZ5v0iZSKuuWN30Vg+imNCAipqAnwmJudu3GSe3XPxjF5A4kmGxZpbLxhJLlI8IamsZkf2EMJhV6O6QUdGdNmnICOtbljk53TiA3p2jZKax92Yi6xBJxCOayAaBAp+Ogj4YazZaPjsskk3gLZv2UsiXk0N3VARKlhUlmA5OfuzFWFXeOdoWxPfJhkFfSf6MbPlftMVkVpn3KSviYK1VU7wtDx2FiPp9qLd4JDr7AUT8xFjajJx43bIMiRQjdVOGZwwKdcj2tE+aX075gtXKmWJJKsdq7k2met+vQbCKqfS9ttO7LVkQ5fLHfRtgXbJTi5xKC9GSOkxL5dM1VuG9HLMVdWp60JtgbQVSgWUerFKWbqNXhTCFcbbInh7O0u9cPsR7WIWl19yrG1dr1jUtyrsrB66na4KXZC7ZPU5AK1Ldxuq2Sqo4lYkFngdyvqPzGinhG5gjNvDt6I9N5FQD0hMkzPxGk2FEIpKFIxNyjvxB3piOXo3jpV9Pvstod+jEWwgfMlF+R2R113t3/vs0ZAu5HxaurHnvK6IpMe/6+5gLJQGIgUf04rnY8F+2OSomPOHm4pc/xGimSiPA7a5zJw3NsCNiC7LlFHh0wkU/zH9NU/t56Ra0vQ8lBBUVjMQLS5wk5frouQkr9kKYy7ynMNGzG+nN7SJCaSibZt8b1+jZUVlM96LD+zaPfq2y5AZsQ7piR2ato1CMRMT/iZ/ji9iHqefcC6umDPkzHxHrHpo4fa5LsZuTpMuQkBlC8byiqfmp3wU75mJGwo7X9HkADqmT0TAWIzQVPTsFi+zMZtli83kFssJ2peU2lIZqKzh7cxB8gMpMdYyFzNyO2VnaZUYLhXKtbUcJDGVsbQDR/6ZVZpIeiRK8aN4wLg0HKU5aR3Q8iVHxZzPgjZZbdhpeHyYl+S25sRc08522EwUxwvDt8U5B3JApBxaUlPxzHd//21d84vOOi8mKca698Ml75jVN5wX33AivqLhr9OVu7y3KZFNsJUhtCFjOcJk+7wQX/MLfk5LhOz5Tb6u39O2Xb5orPFPixMkEm1yRzqKfKTZIxfpaj83JXV0LT4S0qQQBa/EKW8zn1g0KPCdRah6B/5dhhyj8Nmwh7wrb5jLKevGpQM98Td5Xl0wl2PiPOB0qa6e2pwbeQUChnWAXwdIIRmLKTN7RSQcurcl1jHWcqYnNHTEEd9SiUfMFy0ykTtushgswwhqLsqMFNdpb5tthtqlcd23n4MBg+XGXhHZBjcmY6ASQttk19zho3xFgx7jOgYBz/NrWiQMxY0jWckhHZNwZSdM5JBQxFzZd7TFFq/FmIf2ET8UlyjrkYuUlu0wFBOueMeP7C95J48YmA3O5QmJbSORRLZJSoE2hrGYUoqMr7Pv2PafcamdQvpGnnNif6Bdb+ELl351kjY4F5eERJRLdXwu5rwWJzywP2IorwltzH/Kv2eXh1TUjPSUiRmS0OJAbjE2Bp+AN+I9A7uFEA5ic6FzNljnG/EdpU2Z1xfk5Q37rb9AIBkIt4//+qYgUYppCXdaHttxwLtZgbYhgRS8mTqB61YccGTd9eW9PWXLbnC34YRpnvgzC7NC0UJ6PSqbrWTukeq5zkw2iGQHIZ3QqJvcddQatYHx9H8XglDbnFB1SPWQ2O+R1xNa4S7aFijhCs28viD21vBkSA60vZ3lzxaUywJ8C/u47bgDr8Zbdr6d4ABDRa6nBKrLvLxY5QCnS6j4LWhDCElDrTOuPtL2dtBBn3wZ++fJkMQfOOHZssuuhQuVCGQTKSSeTKiNK8y3RCwpfWxtVgX41l7krF3uUKKXzGpjKtrBHrkYoZcCsNXvwXNK6qUtKV/6TEPVdgK1/BSlAif0Us5SIIWPVJ4LhVAB1CCE59CUS8+yEBHNeI9N/wk9s44xhkpUbHCXvu2gMUyXAQaP7I9RVnIij0lkjyBOuFj8ASUDHolfcCOvGHrv8UVCaoY01QZ9u4bB8mkv4niuuUhrDhoxxlrOU5cUWmrLSTVnoBI+XfNJazgpBOFylPq0E3G8qMm1Qyme55bS1mx5La4yTYlmr6GoDPxI/Jg77YC3s4L15Q6n64XsNDy2qk0CJWj7gklpafqCUgdUxvI4dvaDq9yFnVsMTdvlzJyDhFDcoR/6XOaSV/IFz/iE0mrm5NyV27R0h3y5zbojtvmeGX3vHoWdU1NxaabcDdbYLR9xLU/J9SahSLhj9+kGPnm5w1zMaLHGjv+II77jl+pX9AKPf8k/8Kk6ZF7XbMQBF3nJvfYy37qCQLpghtgTbPqC3wwrRmLKoRzQDR1DOrFNzuwEIyx3otaSN21YVJZBy+d0UeNJQayE29EbzbiyzGqxQlMG0pHJftTpuJxinaPSmINGwLDwGNiIhidYVJZPugFnQ59e4LGVSLLRgKavVqEPXemY30pIRmWNsoqm7BPZJj/z/wNDcUPfrlFbw2HU5ChfcBA2l4lWLo7xaf4lew0fi+8OEWWXn3X6ZLVlJoaMs/cI4bkpFE20qJmJG5q2hUUvLUoJG+KQB94GL6sLvpSfMK2dmregZmYL1vy73DH3uRRXSCsJ8CmpuNQvmchz+uxxXqYY4V4zUzGnY/qs0XLBAjbGtz7rosMp1wyME3F64pDKllSi5K+iR3ydXXCoBlzUC+7wJQeqhy8FN1XMW/GOnr/NsCyRCNaDiI9lzSNxSBQomnVAbg9IRMBL8Zz75hGfe/coteFe2+d4odkv7xLicWAeki7H7V2zzobo0PF9KCEWPrmpORc3SCGIbYMtu84G62jjfL8n4pz7cheAl3ZMwwZUtmJHuBzsXbNDhean3mNmdU0gJf3QozKW66LCNz2wPfbVLqf2YgVhEfV9mjJACcG1SfGtIlKKL/0DtHEg3d/U33LXPGTKgjN5xK45YE3FaFMxkle0TI/73jqF6aOkQFvLHa+PtpbC9DgWFxyolhv5Y3gnX1HYOfPq3NEfgzX+OvyCaaV52vW5zj2GuWsEBpHi/axmM/H4NHJZ3VMpOM0MjzsJeW3ZTgTbScjRjc9frDcIJGgbcJNu/nmL8FxfOvTkshN149zKjTrUOgt9RVbdrNKJpPDIxYTaOkuOL2O0dbFjKDfWzarlvtQ49q+2bqdqrSatrgm8liNnydFqfB1Ix2idlB9d5u2ywNYmc/5bv8eivnL86WqM9tzfB7hJX648uFL6q+61toXzLpO7TtUal+kb7SBQgMNEansLQYhZVBerDrleCqG8pXisKMdEwZr7vuJymWSUkwRNlO/G1dZqpxb3HJLzlmvt8n/dbQiDFgZDbd1OXNuatBzSi++5SUBoWJSXhH57CepwSu5aZ0RBD2PrFdc6rwzGZGi9cL5g1WVmr7g2r1EypCf2HaJSZMQ2IRVzajRt22IkXIZpInq0WIOGC+Q4ki+Z1Y4ssx19wUR/RKuKlgyJPcVlZnhZXdK3HYJKMogkZ7OCfugEVhbDmZ4QjntcVRkVNe1AkmpJqi2JJ5nVNR6SiXWgjWHtXgdPGx1eTRxQwmB5PTtCWskhd3hbDRnKU1h8xnN9RNO22VQtcqN5Lz6wY3Y5rktCfIZiSEjEqXhBmy0+1L+l4bkoya/sP/Gz8i/JqGjZNZQUNJTPlRkz1h4FBXuyz1QXzExBJia0xQYNupRk9EWL59UZu2LAxXLP2DN93ssjTK3psY7C59Q+Z1acMIgf88acsJu7C/ZxNaUlYl5lUza9Bte5YVw6oMepLmjKwIEIVBONoSBnoWsa2tnBDvwOWf2MBCeIm5Z6NSL+OK8Y1hkFFXdtl9xo3sn3fCIecKXnZCJnw/YotKUbwPNxjRCCobhhW+1xntWrGEdjXaDE87HmfrDmRtsCZqYgLxR7ScQf0isaxPxQLKgo8U1ALTQbZpvHjTaVsezZBvVSJb2oDA0RUGhDVsMrfc6a7WCwHM0rKuvU3oUo+HYyYyxmzMw5xuSst75YiTwnYsi2OeQ1v6UjdslYMDIf0KbiSmzRZ49RnfNWvuBL8Tnn9oI9s43C51xe0DN9CgrmYsbA9ollz03EKMHCTAwZmB1S4RTLN3ZG1zSJibmUx4y54sDcIaVgJK8YmSM8EdFlhxfplJG85MacU4uClljnK3PBbn3AupewUe9wVqScy3O3k64ekIqUl/aKJ/oOAAqfS0bO2rb09p7oMXrS4TVHrLPOkTwhWKq8G7bLlTxiyCl3ygccyyMkkoHdYiiO2TCHVLLktXjFrrlDRs4H+xWeCEntlHvmAUZqpmTkImUmbsDCe/NbEjVAls+4EROklpwuQjoiYWJTKlFSo9miz47d5EieEOp9TuQxTdvhQAyYiwVDccxd/YT3Zo6yipgILZ03esPscWDu4AvFt/YVbXqoZW61JwVXlWOR35HrzHTFNWNCG9Ki88eJhW0wrU+Y5sfUOqXffErH2+Ob/IKn4QZnqWFYOIreVtCgNHBRpYRFk5dFwXoYoA14QjIuDP9QfsMn2RMkgr7tcrIwnGQFqS15++feCSvhk5sJsdfFWDe+zeoxoWoTkGBkD3xnV4q8rlMgo5HWcZ1LMydRbt9S2RRPJrTCxHmAVY+0HpJ4fdJ6iJIhoWoTyQ4TUzhv7DI9yJcxhZnSDvYo9MTFAy5zjLWs3e5VNZ3H1oeqXtAKd7Fo4qC/KqIAQrnDhFXGFbilWOyW1lWZbOXRrfljkMKivFzGB7r7KoQTIQSquUqXquoFVmmMrWhHy5zkajlyF8r9HZI/sqkBlqPtTnzIOH1HXk+WEYOlC7fQLgUp0yOXgSzDVdRjXo+XUY4NIq+7AqDcxhwGqoUx+TIGsklD9glJWHghPbvDuulxLi7ZZ5vC1tRoJ6wTY3q2hy8CEpNwLS/p2W3W1B6hCfG8kPPqD3RsnyD8ORlTJibnQdLmKjf8ZXsbbSwnaUVWO2FRO5BsJx0qA5eZpuFJ9hot4uWrUQifH2YzdsMGm1FA5AnezmCmS8Ziyif+trtIe4q6CtlvhFxmDXwl0Bb+z4NNfjd0UYOP1B7rkTvZLmzFvt2npQKUllyKa15nf8u95K8JaFLhbGyL+oqUIW1/h+95ySZ7HIgt1iO3Z+3RpqUCHkYtvlpcsq/WONNTPOHISJ9GmwyLipbvcVkpXom33DdP2G2EXC4mHNg9x9S1Ne/FFevcRUX+KqO04/uoehspBb6QPG3FvJ4WjEuLLyS50YTC44t+wA8jt2uPhE9im2xEIfNK0wt9LqqUSrpxYFYbNhOP7nLHdZ1L7sRN3mdzbqqS3Thkkm6x1fTp6S7XRcWNWfAging+rjFL/GVkE/Yait/cpHgiphe48VykBG8WC+62mgwi+GFs+Olaiw+zmkEkWUtbxMrjwG9yWbjH+ZwhGo0nYVY5lKmSbqx6YoYM6JJqTWUNsY1ZkPM07nOV/xHyv06XoZhwR67zIncI21C0iESbNbPuvPsioSEGxNaFHlhl6Ng+oXGTs4ySe+YxZ0yw0nAhbuiYPifiB7r0aNMgEV0mNmeDQ244p2f6TMWcbXNIKlJ6dg0PiY+ioXxemG/o2E0+8fZ5ZS9p2yZ9s0EoYjq2S7VMVQpJMGieiU/4aM/xaBEJn7N6zlzM6do2vg3wCTjhgk+DPc6KlCNu2FdrdE2Lc3lO32wgcV7sLg2+4Tu2zSENEdAyXXx8tr0msSeZVhs8t29ZkBNaB/AoKOjbPQJ8Nuw+vpQsqGiJDiG/4Ew4K5HB0jI9mjgP9QO1w6jO2VNfcig2mNicTetCF7Rw06tN1eK5fcvAbFEuDwr7ZhcjrBv106MdKOIswhMhfS9mRzaojOWiXvAFnzMyGRrNbpRwWRR4+PRth34QuqmPJ9kmISp9LvSMrkjo2w41hmrJb79n7zKzmWPwi3Ma0TZb8gk/Cg6d91fAtLIkSqFtiATWQsFPgzbXueHzXsxVZhjXFfuNkPeLnAf2IT9aD7kpLO9mhqYvucxG/JvODiezjT9vEV4Ul472ZBRSeKuOy5cx58U3K3XwrVd2Wh4TqtYSQRlS6OmK6VzbYlXctCmZV+cYWzOvzld5wZX0qGS2UkCn1ZX73uJ8mcg0X16wFcZUaOkU01l5Teh3lt5YV6SU8AlFD8+PmJbHKy5zrXOiwFG98nJEFPTwpDsxVqbACr0SZPmqQez1Vzvh0HNxjrepTxaXOmRsvcRz+iu167w4JwrWiLzOMjnJFWq7zFv2ZUxWjvC9hvu9piAJN1DCcylFqrF6HG53yRKJUku043JEfQvPuP3Qulwp2p0gq0bJBGNKpvqURPUZ5q/QYcWVeOeEcaIgoslYnKPwCUk4F6cYDFfiiMqmNMUGE3NCWl079rc1vNe/Zc27xyP7hB/1YwahJdWCUls8CaUxKCH4x/Q9vxR36IUurGFUVnwocvoyceISXPB9QwQMyxKF4Ma65+Bx3MNkltNygY9izJyn0TrfzEd0RULTD/g4L5gU/vJi7KAIP6SX9EyfD+IHCjPFNzGL+op+8IB2tL96vBQ+z9T/sPQ8vuOmeENRTRhGOwQ0Wcv2GbDBtRgi9YA36Qkderwxp1SyJNVDbpTih8xzHNvaiYGatosvFB/TnEpUnHHJrt7kufiOm+KNo7LJmAF9rsWQHbXHTbVAWsFANvk4r0hNxZoXURrDzBR0VcR5amn4kkCFnBQLtmSHYVE6y4aAror4aKe8lXM6ep3ZvMejdsyvJ1f8qrtOqi0NEbDfCHk1d/z3ylgybZksGeOni5pB5EIdrvOaXdXl+bjkbtJgI3bP18e5pjLQlAHvZhUGn1AJhrkTZ/kSFpQMvJDLouCcIXfkBnrpG/7DbLScStxQiIy/ih7RNRsc5QtOcJOKWxXYrHJ84q+z/5WtxpcEJKybLf6u+n+RlVck4TY1OZfVKbk3ZY09yuVBtxY1Ck1JylRIrDAYNJqKNbvDBW+wVuMRoUVFIJoc8RJPhHiEtEWPkbhcvcdCG/JOfMM2DxjKa670a6Tw2TFPyMwIT4W8qSM+atcRDbwHtEyPqZihqdiyG7wXzt/8B75mUh87Mar3UxZy7GyYaM7Mc/bkZ6Riyvtiwg/m7+l6+1hjSEhQ1l3GF2S85yW+jGjYLgkhpdXEhIzEiGtzzlbuGAAt06NNgmcVC5GSyjkVBb5dpxv4nBUpQ3FDYpuciFeUJuUBP2bgR+SVG48rFL8339IQXRLbZGYLQjzm5Lwyv6GjdkHAfXOfXbvHUIxZiDETfcIj8QsaNmDdrjNiwSRLOZdHDMwOudUc12N3HRYlGJiIMYltYrHMbMZ9cUDgSf6h/i3P7OfkmWZhSmakWGE4I8fHZ7ZE51YUzEzCQqRMio8oGfIz/z/QVzG7DcnLiXst3m/7FFowCF13/Tcjp/xu2w7DokE/9DHWMi0N62HAUb7gLLVc5RW1NZTGciAHvJ7m1KL4k2rrn1yEB7Gb/QshqWyKQOH5zltbyoVTL2NWjGNfNQhUc+XddXYkiRIJ0vqrpCCxJENJ4TtspSlW+EWAtre7wkkKIVcpToWeEnldQtFC+aHjGas5WT10u9elyvk2WWlhrlzwwdLD66klRlMv8GRMM4qd7Ul4GNztr3WGrxqrbtei8b2Eqk7R1nmYawpi1WW4eEngt/BkTKjazMszGsGGG8uXI3dwwUWk3SZQCSRD/YZCuzE6QCjbzOuLlbgsUl1yPcaYP+Y4K+ETyjap/iPBq9COshT4DdLq2oU3SLdDvkVlKrX07llDovr07A79cI/QhsQEvBbfUVGwY93kILARW7LLGz6yY3YpcD5LTUVTblApB1dxNqmQH6lHVMYyLi1t33VcApiWht3E5Z/+desOUrgL9G5Dcq8VcpF6bDe8lYjrceDx3ajClxIJ9GWPdiDoh4Km3+D1LKelfNaE867uNdaYVpbvp3Oetprk2jKII64zTV2FZKbNWI7YsHd5XvwNSdCn6W9h0Bhb0zZd+gwYiRvWZIM1GrRMB8//MafhMXtmnwU532b/kTR+Sm6mzOWYws6X6mPDpjlgTazTsRGtwOe4nNFC4FsfD48jeUrP9PGEYi7mfOCEXXMPGSpSM6Ih+xSm5kfRvlMCyxaRklxXOXOTceD1CJTgbjvAEwGZdmCAsrQEUrDpJ1TGUlvohR7TytL2PTbzA4bygom44heN7dX7+TzTnBUpAgE4W5C1IcbCIJJY22Be18SeJNOGm6JiLfQJpOAkKyiNotQghNtP10v6bew5L3HTF8tXJgwLy2HYouVLToqKJk0qY3ii9pnpit/bv+cpv6BlO9yXO4xL7djcIqDBNv0w4CzPWA8ijkt3+N5v/JJNs7dMRLq9xkRk5RV5NWK39XOa9GmbFtfykoUZIqViIUYs6kuG9Sv2op+Q2hFpPSRTo2USWsXA26BgTmbcGqzr7aOpGIlLahwI5Fi+dvYzK0lsQts6eqCm5oZTNxFUTTbocePtOqHX8uOaD8Siw9i6LKV75h5D0aTy0hUl75ZI2LdrbIhfccWIvtkgIuCh/Asu+MBcTEhsQmQTuiKh4/vYavlYWBdjmBCypmLGZson4j5GWXy9hRKSlvIZ6gk3HLNm9+jZPhUVJ8WCRARENiEh5N/HP+cyr4ikItWasRyxpw4pqpon9imXjDAY1v2Y2lou9A3b4gkt06EpQtbDgEhJotSjNmt0gyfM6pq5LZiLBeu2Sz8IqUuNj48U7n3TkzGRVHysR7Rsh56MuSkqniQu/MFR6w55Ld/yiXjAp50W15l7H7yvh2zJDtuiw1QXZJT4eGgquuEdTqf/yNv4BX2+5MNME0rJRZnxYSZ40vWYV3DYtMyqTbJa81k/YFE71XM3cOzz305v+LSxRmUs91sB08qnGwgmhWKoa+7aJ3/eIlzalFA2WdSXy9CAAiV9KptS1QsWVrs9qtdaohjD1Q54uuxi0+KSJNxwAA49dcWqOKcRblAZN+b1ltYfgFB1WJhr0up6lZELUCxjCOfFOZWfoYTPok7Rtl6OW8MVp/m2O8yK66VdCMpqtuwMDUngQhNuvcSug9UsyksSf4AUPrVJkbhowqpOl5CMDCOdFUgJnyTcWI2Ib7v0vB7T9LeI4x6VcRnDxtZkdkQo224sLwISNSA3E7fTxdD2drjRbwhkYwUzKevZ6r4I4axezvrkDkUdf5+r+vsVqKOb3CUtr6l1hrIBod9ddf7WGhQ+I3FK265zLT5ysHzBFHbOG/kD2lYksscN5+R2Si0rOqaPpmJcHxHIJpVeUBi3EviR+BWhkhhrOF1UZLWHsdDyXZzbjtfmg3Z5qgkha37I318tUEgqNOOJiz/rFwmvrUFbQ0P55MYZ8A9Fg2+nMzZ9J/uXwoEbjuY1gRKc5zlDccN1HjOpK6rUASgscCHeUZgZhZ4xiB9zz37CmCkzhuzIT4htgMESEiERXJoZQ3nBhtmhabsMxQ2ZWPCz8H/mtf2Grtxhx+wyI+VKHNGgx1xMWbcDamu4LFMOghZCwFrhkodmtcMV+rLJtzplYs85rn/nYia9dRZmSE8+QVvL22LMkXjOz83P3etIpEzrBp80ExaV5SytHdWqtmS1JjUV60FEajWPOs5Pn9WWOy2JL3v8XX5GSMIPsxl34iaPojUGkWI7aXGRadqBYDP2+ZfrHG0VkRLM6ppLRmypTaQQHHPBgX+wuh5EShIoeD2p2Wu6y8jbfELDdmj4grfTEiGgF3jMK8NxPeHAdOh7MaPaKUubvuS0zvh34b/l2/KYc/uSt8bnnv2SBgFCCA6SiDeLBRLBVZm7eDrr8wmPOGfCS+u6zFIvMLbEmBIhai4Wf4DG55zqb5gvTomDPgsuVhz7wGuRMSUSbULfBZLcHvwthnW7Typ7IGFo3vMT8W8wWLp+QFZrTs3IUa7EPXIqTuWJO7zjAh+MV3NgHYnKI6Tt7bBldtw+H8OG2WEhUjI94p16z57ZZ1P8konIORIvwULPbhALnwtGnNuXdOUOOXM2zSFdu0Uu5qQiJbQhtTX8S/2CPesmO0NxQy1qatNmaCbkYs5bA2u2w4yUho2RWhDakI7YpLlMEMrshE/5MS/EC0KRMGPMJGvStk3O7BzfBiDhG/2O1jJv+Vy8JZAJZZ2zZde5Fh/oiC0qW1FZj/M8Z8ycvmhzLq6gWmeOs17FNiKQitNywbU8Zc1sMTJwI68oTJsdehSiYCbGBGaLEs0iLfFRrAfRqia8M2e8m7pp1hZraKG5NDPuBl1mWjgmvO3RsT2m8opu4xG75h4XZsF+2OSsSLmQl4T1Lpe54iKteTk1bMUBew2FFDCvnNah5UvezgpiAk7SgnutkI/zmp2Gx/ej0hHrPJ935v2fVFv//8BWOlYzgEAxL88xvvP8xn6PUHWIvT61SYlUz439RIKS/oqPfFuUA9l06l/hs548JaTJQg6ZGjeOuRVM3Y6pb/GXtx5eKbzV7rbWGcrzl57fainSKoiCnrMr2JqsviEOB3giWBbpaAVFuMVQylUAAiuL0a0VKrdjEtV0YBLp/natM4yplt2uj1Ju7y2tT6Kcovp2R5zrMZHqrgoqsLRMGQLVpLAOqhF67f+ORLYoL0mCwYpD7cvYjctu/c/CeYctmsK6UIhbPGep564Tlp7DXy67+tvDB8COuU8lSrbtfUI8WmKdofnAI/s5V+KajulxLc+xoommIiZiXB85XKhXsMjPWG99RqFnvBTPGeV7PI76KCMYFhVPuyEdH0ZFl/VY8WmwzVfDkv2mz6KyFFXFQDaJlKMonWSSQeSx15B8O6qIlERXloftFte5Zj9qrEbWsecSj3INpbY8bick820GkYIc5rXgvxS/obAz5sU5vegeHX+Xpu1SUeOh2DL7dERCpBT9yOMo9Wl4irgMkEiaImTXayKEcHm4vuSu/AsmpcYoS2R81m2HwtYU1CgkXd8pr1PtEIwFNYXxmNuCQitSXdCmSykzVODeEw/sZy4tRirS2omNDu1TXtiPlDKja9ZpKB9j4d28YDNyatJYQcv3mVWKXBu6gUfDg7PUIIXgpnD2pU2zR7Xc5zU8wZt5AQQMC/e5z3oxLybuZ2pjKQ2cco1vfbSFXBueeLtcpDU3OuPfbTqLzayCaV0CHoPQJS1NS83HuaGwmkS4Avw78x0b7PG2GvLT1gZrpskwr5lWmogAa8En4Kfi33BjFzxtdKiN5dvsivmiYNtr0gsV3y8m3Fcb9ELFN4sbGkTsyGe8Lf+BWrvCHi6573EwoDBzlPDoJfcBOBRfooVbz+yLAW/tCftsrw58sSf5x+oPDMw2mcjYNttIBLvsoJdpT8OiYmhnBPg0CJjanAYBA7PFqXxHTYESHgMOmNuCidUsxJCu2OFKXC09zTELXPH8VPwlXRExoeCYCx55u7zVKT2xT8e0aAU+r+oR+/YZ0kgOOeBKjIltTN92SSnIRL7y5s5ImUnXmU7MCW1+zLrt8kKcsm/3iaTHKSes2w6xUvimBQYeJ23yrE+LNRSCO+Y+Hi5Te2xyPsi37Ju7bAUNJF0WtWaQuIP2PL9H0zRW4RsP7Gc0CLgQI3bCmNM8YyZH7NDjidol8SSnGQghGNk5N2ZBIQpats+G6LAW+sS577z4pmRHDAiE5JqUiRgREjEXE6ZlHx+fL+QjxnVBIBQTm9PyPR4mO3w9mTKuKi7FlSOgyXNKMob5K34V/l/ZikK+y67YiDtAwi+a99EWPOFoftoqeqHgw6zmy76HAF7NF0TCYzMK2E4i5jW8mKQ87iRcZU6/0A99/mv5e8o/d55wWl0T+2su57RyIQLa1hSV4wYX2o0kBXI1Jh0X71d+V2Nc1N6trUnJkEV1gReEjMwHrNU0/E0KPV2JjZyi+lbt22aRXzo4hZAEquFSiJQDelR6QSc4YF5f/BFFKSIaok9NwbB8Tei5wIVbRjU44ZIbb7s9cSQ7+EHCvDqnIQekZrTaAVnMEmMZr4RnsexR2jlpfUOonA1CLoEdbhpQLO9HgSfaFGZKKF3yU2kWf2Rb25pKL2gG2y7tRAZLW5O3sks5VfYV2tYkXp/I666sXYnskYsJQilq66Lwbg8zod8hL0cuJ7mc0mk8omG7vDD/wMB7gC9CYuN814FIuGHCTAw50d+wIR+xbQ45kW+ZipkbYyeHXJcv8VTCcPGCVrTnKEKiotCGUEkWwHlqWPjO4vJ2VvDTQci1mdMuO6yFijKrmJsSJULepylNGfD77JzfZ/A02OS6KPhG/DPM/pK5KTmIE94vUqakhFXAomqgpCuQx/WYLg1ez2oqNB/kW0bFO4pqQiPcYtc+wrOKkRwyEzf4hKRiTmkqUjvncX7AOUP8ep0ZKSNzhC9CuuIACbzRF0gt6doWBst+1OA0d2SvV+Jb7tlP+CA/UFS7q+6kK5JV4EMqUp6GG3xXTFFWuUj36piOv4dvFVYY3mlnn3uv/4Vd9Rkje8Rd+zlzMUMJwagwBFIiBbxczPi03eK30xt6wu2q8trybqaZVk5BfdgKqI3hrfiKe/ZLl9nrOQSOsW5VEEnFfzpLGeMuhHEZI0SXUmR4KIbFkh4lFduJRz4P+PvLjI7nKFp7SbT0LUtO8pSeF9ENFOfpjI5sUxjDJzxhQUkkGiwqS6jEEpwgsVgGseJN6fFcvmDNbrkVRqWZyCF3zR1KYyiN5Je9Lq+nJfNKcDfo8t/q33OR/mHJZi8JvDY7yU8Y1R/oevsofBqii299jviOHdmjsJprxnhS0K47xJ5iXNfMdMlEW56Ip8wp2JQbZLrmSJ6wbbZ5JX9gnB/SJEaLmtAGHDRi3iycj3UuXDLSp+IhQsJ35g13pEPUHhlJ07TZkG1mtuBL+Tm+dNeUb8xrbkyTNk4/k+qaZ/ZnjO2cCs2wzLnLHQyWKSkFNaENUSgi4XGNu9a2RI8TUhrscckHNswhbeGgOVMyOnad78RvaLPFyBzxnZyyUR8ykyO0rPk2NRzx7VLk+tf8oP8La/5dGqaLEj5zc8mJVIyrLg2b0BEJl3mFsZa+7SCE4IxLalEzNB/oih1G5oisvIeVBt+GjGzGOSfEdYNa1oQ2xghDhWQuxqR25LC3RUAhcqbiinW7z7U4IbAJn6gHHNmXq5qkpfPgN+rP3XNgczKRcV15zKcePsr5nsUFR/r37MovyOwEJQPW/IDLvKQv2vzz2K2hFrXiMtNMqwolBOdmjLHrXFc5349jvliTnGU+bd8FiFznlueLKQOVcJHWvK2GtGkAPmt2hzfVP/x5i3DkdahMRqhaVMIVMfmvulwpPPJ6TLAEbFTLZCFz2/0us261rZ3gyDiV3C0OMq2vnHXnNlzAGgK/gSLEyphcT5HSo6gm9JL7S4KWAeH8wwCFmdL0NpnXFyv4xkXpeL23iUmOkOU8vtq6mEEp/eXXKgyaTI8QQjHXl6v7VJmMltrCW8I4Gv46IFnoK2LZo+3tuG50WZQFEm2LlYitqKcEgeuMK5tirRs733KY3W2U1Cblqrqi0otVZ6tNQaja+CJx2c23/mPtOujY63FTvaOoxkjhkyxjEm990JV2kBLX3QeOd23bbHvPKMnYMptEwmPLbNGQB3y055R2TsvbIrQx/tJnOBFj+uxxqr+nHzzgQudI6THLj+n5h8v7ICi04Wk3XHWpenlKP0stf7W2Rlpbstryb9c2uSncF3eUhy8FzWyTeaX5UMzIRUYkOjQ8xV7YYFFbHrQSSh0jheDjIuNJJ2EtVEwvE4c9lAH/rfhfnU/Uc3S0h/IvUCjuRW0+5h6JCMhtxRv5A9tsg4EgkOyagcNp0sKKT9mkRz+UjEvDvnAXVCVd2ougyUhMeehtkFeP2A0b9PVDpqakSY8J6bKzNMSeJCkStHFinqkcs6gv8UTAlrnrwBmp69DGYsod9VNysSCmR2JDmjbips7Z9xP6oUdpXJTipDT8uLVGrt3jud1wvsyG5xTlo0KTas09+yUeku0o5vtxTsvzkAIetCMKbZmWinG5ILQhA9lkr6H4YdTgULlVzTt9xc+jbSIlyG3FWMzYD7YptKU0zvN9PLd0VUTbVwyLmpKKs2qxJKKFnKU+G7HkMjPk2nBVu/XMSNzwbhbw49aAQK7z/WTB68UcgaAtehzJE+5zwHleMC4V65HPi8WUT5ptTFXTjx8zzF7gywaeilmY4er9tG32GaiEEz3mJ+IvEQJGZs5cTmj7m5SmwWt9yhbrCCHIbMElV9xXu1zoGZnISGwTD8kd8wiAS3FFZBM8JN8ubqipWaNFLuZsmB1OGLPndWmZHpcs6IiIDe6ihQOpzMUCo93zpxCExIQ2ZD9sslbHZLpmzQ+pKk1DBFicWrywFQPR4oRr7sgNfCH5zrxDWY916+AoB/ohH+UbtsxdruQxO+YuGk2Ij7QtDuRfMDE5U3FOYeYOiYkLJ2kS05G7pGLEnCkCSduuU4kCTcZj+3M+8opDscHIZsxtwcO4xaK2HJczDoMW76uMgdmiR5+2jXgtDetmHYPFR+ELxWPuc2MXZOQ88TcZVxUnXPCJeMBv7K/p2zWngM4LQiLatsld9SVfm5eUxrBnH+DjrdZSb+orxiy4H6xxUWZ0SKjQLKw7IG+IDjmbhH6TjCkX868J/Q6BEnTxMYAuDXdbId0AtJEEMqAXShrZgHYgqE3M444CLJFUaAuPOpJ/vsrJyElNQLg8SLPMLa9EsZrO/O99/MlF2JMJwipH9lmOQwORUJNS6jnmFj5hKwo9oxU4EUi9TA2Swl8pou1yjOyrBnk5gmDJjLbVsvNrYWxNQw6Y6XNqUxB7XWLVY4bEF8lSVZysDNdqGcBQ24LEW1vd7ltClyecV/LWQmSsI3wp5YQuwdLWZHAJRMZUSOXTDDbdaFk2WZhrl+NbTpzgablDAkhEl1RfM9HHS3SlXAnM0vLaFavyFE+5vF8hJNP6FE/GxF7XITj1yIW++2vLw4hxGDhcOEZlHXEr9tdWCvNG4HbsoWqt9sW3imXfa6zut68aTNP3AGTlNaPkipKMmDZTFozQKBRX9hojDOv2LnPGpGJGJpynN7EtMuHWAdfFy6XoLSZQLS6yb4njNpUxjOqcychDW8On3QZXec3MFPzzYshB5grdIPL4zc2MSPjktkIgyClpEvFOvseXIZ/IQ/zaWZo+LkoXn5fl9L2YxJMIIfjtZIxepuDMxYxX9mzFED/0fkrDJpzJDxR2TpU/YSSv2DIOOtCzO7wQX5OIHh9Kj4l04eMbwmXzllZzmWme6yMmuInPpj5kIofUZo2Kgjf1FUZYoMOwzriSV6ybdToicZxeAUHVp6LmYznjSDxf0tccqrWwBe/SBd/Zf+CecLf3Sp6vWMjg2MvXRcVmLPEl/G6YEyvFtNRuHFhpIiU5W9QoKWj5kqy2/K58z7pZ51Ke4hPi54o5Ob5uAZLaWN7MU1oqICZcZRVnGh75m0yril7gc5d1Yk8QKjiIG6hMMsxrGr7km+KMLfpcM0ZZj7NM8kVzjVY94EM+p+Ep/uFmzLU8598Fj7nIcxaUjOSQTbNBITK+tr+nV/2cr/IbClHQtA4r+IN9wY59TIVhYlMmGlTR5n7c4iQteWw/YySmzLzTPwbEyA064ikjLhnKa6R2GbivxFs867tRsdnipnAJXq3S2Vg8K5mLOXfEDhd6Rri07SQ2WeJYNB2RkLBNw/PIjSayPkM7W8ota2J8buQVC93Ew/nILRHKKipRMdMl29L5zd8YF7jxRbRPoQ0Nz6VkNTzFvNK8Ft9wxz5jIkb4hCBgwpi7cpt/Nv+NffuMfXZ5K99S2zVc2pBHy64xl1P6ZoeZmLDHJl/xG7pih6mdoIRPJDp8Jp5xakZIJPfVBgtd4xPSFH00NQP/AWPO+YLPuTZzPspXbJpDjsT1iql+nL9l0xyQiYzvyjk+IRfymK5Z5xT3/x/lGxdCg09sG8wZI6UisxOqqlh1u8fGjew/iLcU+T6FKKgoUUgu6gWlTJnYlLmYcWaeM66fkYopI/OBhlrHL31y4ZgBXVpkS1/2ntnnQ/XPK1ZEL7lPU20wLmsOmgFnixqD5YfJgpYKeGsu6No2UjT5qn7FT4qHbCaK/+/FjI0gYVwXbIQRf3c5Z05GmwYzm1Fanz3V50Zn7IdNyqK3Wvv92YpwaVyhLaoxzXCbRXlJLserr9+GMQCr/ap3m7W7HONGwZrDK5KtAuyToE9tSwLVXHaYm0Syzbj6SCHnKBFSkS07a02tc4ew9HYpbYoQCk8mFNUMqTyMrcjqKVWdEvodZydSbQLZJBAJlUhXxfG2oxRCoW21wm4m3toKDiJQLiZROKi+Ej5xMFgVWSEkNTkjc+QsUaJJqedEqk2p51QmIwkGWKsRQrnP1SmB33LWKlOuMKC3IJJYdNCqcHtvEbGorwilQ28qGRKKFp4IaUUbjOr3zO3l6nmIlYOVOGW0x6K8JPLXSJfQELt8MQKs2S0iGxOguBCXNG2bQmRcVS/5TP2PKHxuxCkNeozsEXfsXUY4YUbGzfJE2SCvbpaM8MJ5cueuu20on40ITheCNRWz6zWYV5pB7NHyBRtBQiAFu42IcWnJ64RQCdr5Iy7qBadmio/z+G7FLhWoS5OGJ2gHwtHVKp9U13zDV8zqc7Ly2on/ZOiKgxgT02aNLfa8Lo06okTTkzGJDfCtzx3VpxFKflOM6dk2JTXry4zR0hie+QeUeo/caIyw3PXWaPiSe/UuH+wlsY05KuY0RYhnPda9hJmu6Nk2kfCIpKJjExLp8W15AcC+9yPWzYBHzSbDXLOvv2AupkzsObvmERJJRyT0wwBfCvrhbcKYGyPP64r+0qN72Ap4OXU75Yby6IWCf7i5YZ119qMGW+YxWa3ZbPhMq4hcazwp+Ho24TBssZ0oPvN8Ps4NC10xKx0pqx/6dALJqIB3s5LtxOd9NifE417b54dxzg4DvliLeDnxGNcFGkPsCf5z+ootdphXmqYIyW0HbaHrBzxOEv4wkTRkwC+DJ7zPZ4zKikxktG2LgUoIlORH1S/pBj5SQFgqKmtWgelbccBlJvjAiJa/w032msRfp2G7tG2TyMZoNGsqxmjLs/AJlbH8vnpLbH3ageKmqJAIul5IadwETlvLtmrza/NPfGp/4kbC4oaO7dL1fV6V11R1k0T6pLaiEAWpVVRLdppvA864xAjDfblLw1NcFaCpmJOTGsGlPGVgt5nKMV8XDgFZmIQTPWJDdLi0Ew55SipSHso9UlMztFPCZdBDJDvOWkTJQ/sAX0qO9A0tEu6IbdZCj49ZSkSHmS3Y4REWwwY9jjjjoXmMUsuEK3HMet2lQrNpN2irEF9InusjIho0A8WrasjA7hIS0LUNhmLCyBzRkAMqUZKLOefV9zzw/oKKglLkzMQN62aPTZxXNhI+2hqwTt9QWE2iPE7rDgLJptfgvJ4xlBVTMSEkomO7bipgAprmUzbjgJuiSUd08a3intzkrWyT4kbCZ7rCR7IXNTjLJZ7Z4mgZo5j4A+bFOU21wYG5z4Oe0yI0fAlEBEowiBR3xR7Hixol4D90nnCWuoPu/7LXZFQKvh+FHDQVtYnYFDGeFCzqkIOmz4uJE5ttxYpHnS751f/pz1uEja1XkYBKhGhTEPs9Sr2g1jm6mqzydcEJgyKvuwphuCXYSOnRDLYpzZyyntGJ9jF6uSeVLgpvXp+732HmTsS1DIEIVQulXNeq8DG4ztnhI+MlCUvS9LdYCLdfs9ZghXFUKllQ6ClKhiSqz7w+dylGtfucNgUNb4PaFmTVDZ3wgEJPqOoFoWqtxr++jFFLdKZ7bAxZdYOUPom3hicTV9SXTOq0vKYZusdGCp9GuEFDufHm7X2tTEpejx1ow44IVYdpeexCJXRGLkYMvAcsxK04TpLaEU1vC5+IktQJzeqhA3xQLG1K7n4pGa6KsDYlF9VzRqpBR+7iE5IxBQmpHdHx93hvf2DXPiSzI0oxJxId3orXVDZDIFkL7+MTcVW9XDG+czvlP6cv2GGXj+KYNb3Ou5nPt/oD99hjXOTciAnDRZOBcqNVJQTD3PL9YkJFxd1gzWEXbUzLV7zNJ7yvhzTqmEQ4IUxbRMxtQUuEPBcv8EXIbDkRWdiaptogEm3e8o6O6YOAxCa81qdsMOBGnjOzARt2wJU8wqs9kjqk+v+x9idPkiZpnh72qOq32+7mbr6Hh8e+5FaZVV1V3TXTjelZACFAkBzBCHkjb7zwL8KBIjhQhAJSCMFwBuQ0mtM93V37mltEZuy+b+a2f7uq8qAWXoPT1KGkLiVVIZlh5uamn77v7/c8smAkprSXnOExc06YIyt5w4zuy4TDckJUBkyWfc+pdK7lJptkYkGgBKN6zobsIAQc1RNO5KslkMY94GlRk9mSN/OMOTlSCDzr0RR9bqke47pgZjNu+xFv5hlNzwWzPloRTGxOjM96opiWhqYH23HIqNDMKu0k5MLB+a+LgA96Ed9MNJk2xEpQGUE3kJS6yUWRE8iY3Be8yKZ4SAZxRDeAn12WbCYKayXHxQI/c1Ycg2VUGAZRwEmWc7TQPOj4/L9Gr3jIHd7NKj7x7i91h5Lj1FBRktcWTwpmpWEraPCmHJPnERU1V2ZOSEhPxmhr6YeSi7JiUTikqMHiCyeomNYlCy1dap49flr9jl58h5ZY4wfJNqNCM69rjjgn9rpILZYGJpYErJpZpbm2C87lAbe9jxn4HovZChrDtS7ZFPfIcKaiRZ2g0fRCyUbd5dBessuae+CwMQrFLXOfuVig8Pk42uA3+QlHZshq2aUv2lyg2VRtZrpEU+HjEVo3it4LWzQ8yfNsRGUr2rRIRcq+WqM0hufiKxLR4Tv+HY6LBevmFjt+m6sqp7KaE654FGzS8Fx97CArmbLgrThjz95hTXR4KV5T2ZK+7RNJj7HOkUj2zEMWlMT4DMWELhGprpcZj4JFrZnaCzbsBl0VcbHkJnTkNn2zzkv7c7bkE9b8B1xxjMWQMmZanaD9ig2zz0yO2TZbvJVvqMhp2B67bDHTFUfypVsn1h9yIU+YmQvacgOD4ZSXHOs2PiG5mJNnD10KXRr33Wf7dGyfrt3hQFzRpMGVvOCb3LCpOhS6ZmC2mPkXqOX37kfiKRk1o8LdUj/PzxjQYzeM+GaaseIHjl9QaBa1A8ikteUXV4a2L5nXNT8ZpizIaJGw5scc1WOmY+c+nokJvxgLKmpem1/8cQ/hvLzG91y6dq4zknCA4ff6QXBA9lC53XHDXyOrxy5JbDJy7caksb/iyEJej2IZ0nLO4CmJ18cXMUbUzlmsWuilYhCg4a+Sce26ySLFFwklc+SSZe18w6skoovyfGpytK0QKEo7pzYpwbIrW9uCtByyGj8kE6MlBKNkUjnISOKvLkNWvttFL1GcZT27CWAZ69LhALG/QqFnN0X/aXm+rHKZG8xnwxvcPIyUdo5HRKJWMWgKfXnDjQ6WSezI6+KJiHa47V4DGZHqkeqr5cNCTiTaBMQM69d4wskvrDUusOYpptnhzWhbCg9rSoSSNLw12mLAiln6jYVkww7o0mPOjEJkGGvYFI/p2jaH4g0RTabmhJba4Hj+CzrxHtZqpPSXPWiNpuZW3OD7yX2OF4aWL7if7zoKTWX5QWObhicIFIwKixBwnWtCPHdj0prtRBEqH2vhE9/ZT17PCiY2ZTfouM+C8TivFyBgZA6XsJKKneb3iZb0q8S2GIgOki5SCmLjcynGPJa3ybTGl5Jtc4cd32ETK73NSFxTkzAXE5q2QWwitoIm1lqavuRtmtISMR3Px68Vd5sRz2cLkmWu4L69s0z7+m5MaSw90QBzl6/1O1pqg4/k95mbgp2ghRIQVIqZ8RiKnG2zg5GWu82EF3PLbkPQ9BN+OZqy32qjLTRFyG4SUWrL83RMVneojGWmS3biGAE88Tc5KGecimtW0nWUcKzpCosnBOPSEHkCaniXLWiXv4fNTyvLX4/OCG3IRtljURtuRU02EsmH3gqL2nWUKwOlCYmVpB9a/rLxkLR2dqymLznPNE3f7ZH/5WCPSQlv5xXDsiaSintRl0hJTlKFJySPugHv5holYFwaWjJ0tCyl+KDnc5G7ish1Lrksc7ajhLM8Zzf8Lmf1M0bla/6KgnvmPofymAUjlNhlzUs4KzIetRpMqwRtDZFSKK3YMvsc5Qv6dcxYzOjZNtthAykaDIuKxJPclSsMy4IvZlNSkSKRDCKfSZqTEDISUwAG9Ggpn4u8ZCHGrJsd1qKAi7wAAauRR1MrVPEIKQSFLUnFHOgyKR3C00eRUhDZmExrKqux0tAzfayFjIJT8YqwenJT7/ss3uJ5OuayPmPP7tFSAR1C1kyHXuh+j/w6ZGBXyagYmpSBalAupwojcU1KSNM2KIym4/v8JP81gWzSo08omwy5RulVNr0mJ7Whb9fx8UhUnx27zql11aC9Zsiz2YyF2qeyFRKJQfNWvnG/j3afb+VXlHbAt+JzOmwwF0Pe8hXz6pwt/0NqKi71S7bkUw7qXxOpNrHokVGi8Nkzm5yLNnsMeCcuCG1AYhPmYsGqGRDj83PzY7Z5zFCeUFRTynpGN3KWrli5VHfiCb6bbLIaOdJe248JFOQafjWeoLVmy2uzqAyeFNxqCtpBxJuZz1Fp2IkafFmc8ShY56xMiWTAY2+HSAkCKXiXtv+4h/BKcg+AtL5GCo+2t0Vu3IevGayT1tc3MIrYc3jItr/For6gxo1aQ9mkMHNSPUQuU7yJ6lPbgml5RC2LGzylNiXaFASqiaciOv7ujfHIJZkVFk1eT266f6VZLDu0xiE2VY9ASErrxsO+SEj18CbtrFSAplqCQwoCzwFDfJFghcEXMbHqLUe8F+jlNECgCGWTmTlzHWHRI7MTcjumsDM8Ed1Uit4nt2tbLjnahkJPib0uhXWvwxPhjXYxlj0MmkV9eTOmzvV0+foc+rPUCwLlbs6pvWItfOSsJUsISG0LMjNCidDRw94/LCGp9NxBSqwjfx2I5+7/E5Ih75D4SBTGaow0tK2DiEzqQ2bCp9RzpvaYveaPbkJv73f9Svh4KuRFNuY4c69nXrmd9LhyU4NFbRiXcFlmdFRIsARSgBtVNjzBwbzmtJ4ToOgqJyhXQnAsXtOqnvIlv+a2fUoqUg7nP0EKj63GZwiko1MRoGyXmRzzBmd3SUVKIXKats1ZPXMjLxtxKl5SV4/QomYuJzzkDodcAXAij3jIXb6qDihExqfiIW/kC1bsBnnlbv+nqee+hE3biSnQzMqCjoiYmYJEBIzsgkPx/OYB0FpLXyb4EjwhOLXXN8SijeAWiSc5yyruNhpc5NDy4Yf9NkrAm5nlghGtYsArfUEuF6zWTX7H5zwVH1Boy1Xu1gH7UYtO0OEqN1gLnnShuVRr+p4bNb/La9a9Bqf1nIkY0bd9RoVxI13hc5ZVrEU+h2lOy4+YVfBylrIdx1zmJQ867mHg11eGQAk6geQy01zlJROTc1lKuipiWLgbxVk941i+5qn5gEB6XOYVY5vyIOryN9eXS5FIj0R6vLWnVKLkE3mHq9xyMC9cotrCrSRmWhpey5f4hESqTc6IkAQhBBtmg5oB57n7bG1FLr9xgfPMqqrHtt/k6/qQB2qHbqhQC8VEzOjUITNdklExzwtWVcKcnDtRh+d5jhSGN+mCEI9v5Vd8wicAnJkJ20GfqpAM9BZtEdH0JT8uX3DbuJpUbSzaGm43EzZNwFHqeNmFMbwVz3hoP+RR3OPL7JKhrahExa55QC4yUq05l+/o2U0SEdD2fd6VY6alYSydcSuSHpl2KyeD5fPylKf+LdbNgCluOvLD3gqnqcZqw1SkNG2bgWzhKcFJPUXWTVa9e6R2xKZq8kZPWbEbDMWEtHY99L2gizYW6oduXy0uOdS/YzT7E+qlbrBl3QXFmD65SOnYLg3l80h/AMBj+wmvxctlir3HwNunaRrshk2+tA3uqnXa9s+RVnAijkgI2RS3eCVOGItzfOMzlZdMxSU75g4Gw1wsmFDRFduc8waPkJa3wVlxxiq3mNkMZRJqa8k1zCvDu0XJpRjfZBEAzuQxu+YWq7HiYF7Q8X0ucxgVhsNyQkvE/Kp8Q9t2OShnxPicmTGzesSn3KcTSDZ48AedrfI//Ufe/0Gf2hRY61COpZ2TVm7k+x4QUekFpZ5TmjmL6pLcOI2eFJ5zmuoRclnx8YX7pZhWJ3giZCW8ixIekWwTem1XrVEdAtGk4a8RiiZT7YJMgWxgbMU0P0TJAGNrLOamI1tT3Nz+IprkeopZ9mNLPae2BdfZS7QuKY3rcvnSSSCsNczrczI9IjOjmwPLkwk9fw9ja3I9prIpSvgUeoKmQvL79LVF3wgrjK3ohLccJtO6L4TY69IWG8s/79LSbsTt44uYeX1+M+p+/8CgjUtaXxevHFnMVgSqSeR1HV5SdSjsjNxOmOsLQtmm0NOb97/WGWnpbtuejIlkh7bpMmCPe/YpD8xT2mKDjthg1z5gwD4Ds8VUjKioeSR/xLp8wGbwITvqE67r1xhb0wv28VTMZvSx0yPaPrtBh40o4l4rQQjc07ZdkNqSlVAhgbuNBr1Qcaup+LO1Jk0ZMIgVWW0JlECjuRU3uNfxGZmMRCk+ER9hrWWVPUZyyLfFv0cgSUK3d7pt7hLYiHV6PIhWeCr3uW13l4CHgKf+LVIxZ8tr07MrPA4HbNkHtEno2TYPucPE5DwN12nbJt/zH3KvHfKD5DaJdaGz78gPMDj37nbY4HT5Hqc4eLxE8KjRpuP7PGq2mNiUTDigTFZds25u4QnJxOSU2vIim3JgPqei4I65s2QwzznXMxq+IKstWe2ezl9ONYW2hDZECvhRe4v/4/p97rQDOnaN3/ErLsuci7ziqJw796uBhieY6IKDfI6xkJuaUVFTGktThNxpew4bahO2wwaPu4pbcYNASkpjOFhkaGs4WlQczAsqNJ1A8rgbcbKoOctqHnWd39aXsBorJiYnEQEVrjv5b2dfEnuCJ40ea2aXRLmah7WwG3SorWUg23yWbLIRhTzp+XRsl4FZZ6/lEqm3myEPOgGFdaPh0hhWzRYlGQJFIxwwNG9pKZ+MkqYI2UkiCmqui4qjRUXTNngYuHRxJ1AY4ZLaaW0cJpGSa51xIa6I8WmJECFgXbUQCLZkj7ZtUlDhC8VT+xGRkqyEHgPZ5ut0RMtX1GgKW/NsNuN/3f4YgEmpWdROGXmWVfRC18OtrSVSig/5hJZyD61dmvj49GybmZhwLc4Y65x/HHzKwK4ysS5dXomSo3pCbBMyO+ILvqDA1fRSHN72i/otQ3HNTI4pRMFpqgmk4HbYYc122fLaeFJQGsOKaLiHQjti07qL1337MR4ePdumEAULkTqegtHMxQIpXK+4r/Z5w+8I8OmKhIyShgzY8bo88rbp3VAQHRxnzJyOXWPL7LNpNrnigGP5lrfFhMA6cE6yDJZ2TJ+RmGKwbLPOd8QnVKKibdcobcqBfMGx+YJUTKlEydRe0GGdUfWOVF8R+T18AppE7DZCViPFeixJPIknJP+0t8WTZhslHN/+/9B/wloQ0/Jd/qAduGrgdkOyKpvcbkR8FuzzJOnRlwlPOg36os2fBA940lPUxv6hRyvCWvsH/ekHK/+K1I4oly7ajtpmVL8lWdYYZvWZW4B7KzfoNYuhNq68Hiq3gH+/5/VEyLR2qcaWt8GkOqSqU3rxHSyatL4mkMtqkLeBEJJx+c4FsURwM/KW+DcYTYumKQfMzQWVyW7EEN5yB/y+w/xeMegCVx497zaX1bfLrvIaHhHT+oSmt37zz45km8pmjqZVXdIN9ljUFxgcTjISHcb1IbHqLUfV5qYjnNVjYq+LR0RpUyyaULSY1ifuF86/5UAkNqUjt6kpuMi/phEMloev8/gq4ZPpEbFyBC7ncK7pql0W9oq0vqbv3yW3U6blEb5quJ105chZlU7ROiUJN4n9Hm3PpYS7dp25GOPhU1Ew1odI4dGQblReWwePGMsRl/olm/IR36R/RTPcuPEjR16XrtqlYbtLcfoVPduj78UueSkke83ghjoDMCxq9lvuf7vI3JjsTtTmNM/oeg7gMa9cxedZfslCTolsgzf1z/GWafiynnE3/BFN6xysFQUDu8ZL+TU75h6X8oyeWWMkL2naLk3b4LX40vWGcb3hnDkzfca2/JCROGHL3KVNzJgFTWI8JOfimtCGjOQlu+YWkfA44pxa1MwZ0rc7+NZBYy7lIcbW3LcfcCWGTMQlEU0kig2zQUuGDE1KiEMLOrn8rZu6S0P5HOsxHyR9AiXoBYKT1DAtNampaSiPTGv2myF/vfiGfxQ/RAmHB70sc4ZiwhnfssVDVukys5kbHYqAaik+2I5j/q74gg/FYxKlaPiSX6WnKKt4EK6y3VD88npGIDwuGNG1LRSSjSjiWXHBB9E6r7OZwxtKxa1mwDDXvCyub+TrqXBWrjv2Nrmt2Ika3GpKXkwcDrPUlt/Wr/lhdJfP00u6NLmVxHQDSW3dzfl/Sn/MPfshXRXR8BSvizE+Hhk5G7LLgT1jyBFN0WdsTnjAZ5zKQ26Z21gsD5pu+nCR1XQCB0M5qCZLhKG+YVav2j6J9Lk2Cz5p9XgzL1DCJVqAm4fJmS55K9/Qsiv41mcg2zQ8j7YvOc1KjLVoLLmtSESALySpqbjdSBgXmtIYOoHHvNKMtaO8BTYilXMeyVu0fEVWGzYSjxfTHF9ICqsdQKMZMiwMEqewPEpzrpnRpcmYOXL5nx2vQ2kMLzlk3QwYimsUPg/8dcZVibWWrThiUmq+tC/YN7dZDUPeFhPX/2XkrFA2ILFNdrwOp/Wciopz+Y5PxEfcbQU8m+Rc2gltGqz6EUfVlK5IqJep4BrDiudCT4knuS5qfqZ/TlsMeCRuEyjJr+tv2De3yZaWMY2mKxJOuWZXrNIOFOOyZmFKdqIG/1B+gcJnzWzcBLi2RZ9veA2ARDG3Q3btAw7FtwzzF2TlJbc6/5gdc4+r5ffBVDrX+332mJkCH7cS2W2EHC4KFrYkEQH9Jar1NCtZDQMmZU0n8PgmH3Iu3/HQPOGaGZ81Bwxz9/MNpGSmK/6h/B+YLp798Q7heyv/kpCElAnz+uym0hOr3s0hXOuMXrhPpp1I/f3BUdv8xmxykv+GxF+lpTa4LJ4vd8QR2lak1SWR16XQU7QpaQabjolsKxr+GqWeO86yt7KUI7hd7Xvf8PsR9Kx2pK2Gt4a2FZFsk5upGyHXZ8Sqhy9iAhKu6pc01YDSpjfgi4bsk1uHtJubi5uRcY8tDqpfIoV/A+3QpiBSPXI9otQLWsEWlUkJZJOmcGP5jCkeoZO3L2/eUvhM80OioEfP22Omz5aULTfmdLfihNxM3HgcgyfCpUEpQbBEV5qCQDYpjRszuxG4Yl6dIYRakr1qynpC4HWo9IJecpc1dY+ZvWTb3mcgW3zJMzQVm2afoTzHw2dg1qkxpCJlkxUOOEWLmo5Z4VS+4Wj2U7fnD/o3AbD14CkDs0WAoq1CthOfX86uuBusLPeWFR90Y4a5YVK6ao23dNZe5hU7DZ/LTNMJHCpOW7jMK7YTn79ZvCZnzvHiFxhbEwd9BsFjnizHPldmzl7QoTAGTwheV0NWaDGIQhaV4Wfmp2xyj23Rd7AI4X5Zun7AUTkjxKOgZqAaNH3FeZ4jhCC1JXfiFgfZgmDZAAiFYm5KIuGR2Yo1P2ZclbyRb7msvkUJj9vqM1Ix57h0svoH9lNCPO63Y0IpMMBpqvlt/YIP5T18KfCkuHkI8aXgdkvxalpzWWXsRA36keTH48ubXuRITPm2+Pd8HPwX/OXaCv3A8uMLzdtqxJF4TldscV/sLl2qlhUVIxF8uOLzZmZo+G7W0o8Ep6llWmrageIyr7jUcza8FqUxDCKfpi85WlQ8M2+pqbiuX/Mn6p8C8FP974hUmzX2+UetW3y2YvjXh4Z2oOiHEiXhIjMsKsOdtrsFT0pLIOEsqzmvF2z7TU6rBTtBEyGcy3VUGM7znA+6CZ6E19OazYbHy2nOxysR34wrcqP5qf53DLwHfKzukWrNc15wx9zBE5JzRuyrNVJdc8o1PdsmFB6pLVmQ8VGyhhTusH29WPDdlSYnqXargrygpXymdYkSkspqRmLKk3CdzUTy16NTMpFy226TKFddavsevVBynmpXr0szIunx8UrIi0nNvK7ZSkKmpeaomrIXdJjVNV/xNevmFgkhBTWpSHnkr3NUztkJmhhgVBZukmLzGydvtTz0uoH7bLYDyTeTlEAq2r7HRZGjhOSMIR6KyMbcj92+8u+Lr/nMe8xOQ/HFyN2uV8OQYVnyVrwjsW36tsNQTNhXa87YJT26gXvwuFhSogaRz5tFulTZCE7kGRUFH4j7GCxf25esmQ1qNIfiKwLR5FPxMad6yp90+jyfuH93Q/l8bV+R2jGr3GJb9PmV/QmP7XfJcfpRH3VTGxvJId/x73BR5I6wJaeUZEzNKR25ffO7CPCX4X9OO1B8s5jyvW6HysJ5WrMaKXJtOUrd+/RpP+LZuGIz8Sg0rMeCysA/XI/5i9UuxsIXo4LV0OcoyxiEET8aCJ5PJdpathPBVQ7/7eX/ncniq//k2foH74Sdxsoll7WtMdbcQDKAJQ4yprKpo169lwUAi/ICEShq8uX4uHKHjl4gpU/TH3Bdv7lJ8IaqTSUywmWtyCxNQEqGJNJVhdpyg4I5vkic4L4+u+ll3RyOoo0VhoW5cqAR2fxfBKMMtcNpUhHKJpmuaMkBl9W3DpLhOymzRVPZlEveoE1JZVK68Z4LngkPT4TM8hM68Z5Lfeu5M0YJQ03Bor64sSotigu68R6BaLJYjp4KO6fQ0yVly3f7dVPRDNZvutLv98vGVszKE9rBzo0cozBTYtljri8Q5j+yKC1BH75q0AgHTLNDtMmdZGO5N79SpxS2IGfq+rLiC9cHN3OueE2i+jTo8Vv7C2qbU9Qzjq2m5W+51LsMaPhrzMtzEn+NgjkzMaFju/hCcpVrBrKNARbaQdtPFgGeFOw0fY7mFVuRx2laUxpDpAR7LY+/ux5yy+/QDhRHZkg574Fwn8PQ75CVQwfcx7llJ9Z9Afx95VCVj/k+MRGekPxd+RsCEjwRYqzl0F4x4ZI7+h4v5DMelk+4kmeENmbV9nlu31KUKZFssmU23Di9qJmRsi17zHRJS/lII5jZggt5Sl1tMhFjSlI+VP8Z3/Irvin/hnawQ8ff5ZZ9xINGi6O04Do3rESSd/OS1FSMOORrfLSpWDUbtEXEsM7oezFHCwe3eCWfMTCf8fPxNfvBCu1A8tv6lIKUWmf8tvg3NC//Jf/72yH/5Y7gt6M1KrvGrybXtCOPt2bKnhjw0UrA25nhKre0A8Hfz47p2ja36yZneYFCOPa21SSEbMQer+a5c6yWAmshsU1uyVWeDJ7wcqrJteZfNf4rYk+wGsJWrPl2pnhhDoiyhI/E2g0RzZOCr8fue2OvGXCeutvDe4rXTtCk6Uu+WoyojSNuvZMHeJPbfLYaoaTAWMtqGHCWGk71FIND4b6c/jtazR5WGP4keMxxsWAzajLOQmb6/WtK/iPISoWHx6hwD33TytGvjhaaeaXZTHystZzWc0ZyyG27zUhM+Thep+FLTlNDYp0yTwu3RimNQAp4MyvIbU1lA8bM2Ra9mwnQWhTwYjGjIyMnDIkkovBYKTfIREZta67lGYltc1nm3I1bvMim7EetGzfw9xrbHCwyDuoR26rLW3PJ29zwyN/ky+npEhak8es1juUJK2aNdVaYk3Mi30C2z7bf5IfBE241Jc/GFUIIWspnNVJoG3Cnuk3L88i14ZAp53VCU4RsxIHzRVfu/hYphxHd8tzBrq1l12yR2pJB02NWGZKyveSzB0TChSu/sQdIIZmWPaZkVKIk0wl/ljzgRTojI2dkM/b4kCsxpGO7xMLniHOatkVHJEzthGlV01A+U3dMsGv2eC1zxvqQVd+N1BPb4kv9jo+r2zRFyG/HczwkTc/nYFESScWJOKdjexwtAs7qGX7eoTKGg0VFQc2VPOPNrOWc16ZkIHyUcBmFV3OXhfCkoNTwN9kztsKP/6Cz9Q8+hBM61FTLW6AiEAlWajxcAMfYikh1b3aV70EWhZ7gqZhx9pokHJAWl67KZEviYNWFoigwtiJUbTwZIvEp9JTr4hWJv0qhZy6FK3zK2hmHppxRG7erjUXn5jCVwieSbUoxp7BzVtljwZVjQJsJSoQ3N8rUXN8c2oVxu+IS90RmlwGq9/zoRPWZVK4yZKy7gb5/jake0oq2aKkNhtUrB4swc1IxIhCJo4TJ0LG0oxBjDYnoIMNHzPQZuR7R8NfI9ZSu2CbyO1wWz5c/oJBQtl3ymYRQLdGb1qXDK7RLidt0SclqL993lrfUVSq9cOQvv0X5XhFGwQPxfTDQIEDxgJyUhBaBjahkRdM2yW3GSFy411Ne0Yl2yeox8/qczeanlDYlra9ZC50AYqpP2BD7rKiYfqRYCQWvZ+7b53En4vOx5tvqggE9Cu1RWUNWWyLlPsy+hEUNTSJWI0VpYE+tstA1GVMa9PCDiBP9G2rtYCNvxSGVKNg0u3RYJ+Huza22HwY8LVwQJJQKX7lDZl+u4XuSUbVNrDx6eo2eaBAoyYXxSGjzJ/EeubbMK03DUzwQqzQ8yWJRcV4v6MgIYxyoIcTjR81bTKsdhkXFDo85Cdxn5wP7Eb6SNHzBIArItTM+KSSR8PBJuMcuhdVsxCHfZCPWVQttLYU27DR8guxTHnYUctIhVIKGJ/iz+B5/nf2W9cZHNOnzl+sJw9LyagZfzSasew02vBZSQNu2UFLwbFTTjxSBEswry54Y8GQlIK2hMgG3mopIuZ/BtHQHy+1GxNtFTmpL/vl6h8/Y5DSzvJtrnlVHADSqHQ4WFf83+3f05W0S2+S22KIf+XQDyZ81mkxKNzI/zzXbSYgUgjttj6OFYNtvk9YOaXmV10tyl8ezSU5Cm0R5vJxoWr7El4JeKNDWIjOBT0AgElrxLQaiQ2k147JiK2hwkC1YVy18KTivKiZihBY1tbXsRA0+LyY0/R5SuNBURc1GrPi2qhkVms044iKXfNq6iy/gtt6g4QvOUsNFUWCwBFKRKMWodAd9ULubqsWwKiPQ0PIVJ6l7P0dFTUs6hGsmcuR8lUHsowqPhIRVlWCNIRMpYzvnIr9iUwzYaSiGhRM0nKQFgVRccQIaNsUKGsuirvlec4OLrGahawIl+Wfxfb6YzGgon54K6VSP6Uc+aW2YFAVShDzo+Hwzdg/KV7lgWOa0VEDiLUOs2uFXrbX8TfYVj7jPnVaIxWIs3Iu6DIuKqc153OjweuEkCyuh64zf5TaPexHPxjn3zUPOxTWxdayG66JmIq9JmbDCFmdZiIekFPky3KWobUQiAqQQdEyXjow4tddENkFJ93C4Klpsig7XZKzabaYq4bz8is3gQxQ+j70ddpsKM4dABoRKsBoJRoX73O2IfVo+TEpo5TGREtxr+zwbw704Zj2/x05DcV1YrirBsKhJpEcnlAxzw2IpU9mOY/4ifszP0oM/7iE8sWfuZrkcA8/e91uXCMtANW/2sJqKtL6m6a07raCe0Qw3iFQPGbsaU0dscG0OyfUYJXya/ga1zWmIVSb6mFC1b5CYDW8Nhb88aNwhH4gmSvaZ6hMyO3G0K1sRqIELadkKTcVCjsmrMYPgMQqPoX7Dok4JVQdjK/J6Quz38EXIlXGdtRV/n7l0yMqV8O7N7rbnu7GxFD4dtc3MXGBsRUttUNmMymZ0/VsofDIxuukmN7w1x9OW4ItlYhDNwlyRqD7WGjLjRvg1FR4OfFKbgkLNWdSX+DImF1MK7eL2zXDDhcZMhq+SmxBWVo9vesGVXrhOtddFCo9J9g4hJHk94cI8o+F3AbgW2VL8HaKsYixd4O5l8bd0wltM8gM64S1SrrhOX9KKtplk7/BEwLr3GCn2CW3kjCxyjYkYok3Nq0XOYL7Gqh8xrkoq43MriWkUPoly0oF+6HOWlVzbBT3R4CJTjEtN2wtIa8u0ciKEtTBAFY855goPj4fRX/Ll4n/k5fyvudf8SwSSGJ/CNmmT0PUDfqPf0q3uMbauVnSor2nrBnMyyjqirUJG4gJfB0zkNROuWdUDEprM5ZSzrCRSit/xOVHdZMNs4ReKoZjgW5+FkYzFjBWzjsbwxWzKhTzFJ2TCOQIHgfGl5FpnMHNBpLf2lLtqC20tI5OxIe7wK/sLKpvyZ+VfMJAtDswV+2qN19WQ4ypkLubo63ViT3JVVPgy4DKvKG3KbfuUmZjQ8Cz/42HGNTO00Kyx7GJL8FEOf6g15NAN3ch5bkpeTuRNrejNTCMBg0txp7VkXmmedmJyHZHW8HqmedBRS3ewg5lktWFuCx7zfULj0fWdBanhCZ5Ncrr+cpydZQTC7WZ/k7rO+w9aG5Qa1iLJdfF7ytCitggcnakdbHCV1+TaEHs+X05mnMkzAhEvOddOqfkz8T8TqCYD7qGrPh92nPzjZXGNFjWRTaiW+8fzPEeLahmGW/BWvuKheMh1YTi11zxR6wRS0PV9Xk1zbjVDPp85d7UnJKWtKShIjXuYnNmM3aDDZZkRoChw++c10eE4TxkECd3AgVB8KbjnhXy7BDw8W0xoEjMRMyDhgT/g6+qUU/GSz8T36AQep6lhuuyI7zcSDtKcFbtBX7S43Qx5Oy9oed7NQ+12I+blNGdY5g7CId3h+r5ON6wzvtNt84vxmKxuoq3DMg5iRT9q8LPJJccZtElYY42uiqiMoWP7BEry48k5ISGftDscziuei2d8JJ9ynBakS2LVZf6Qv0ge8mqesqiXukvl8URtMqkqzhkxNClPvX0qa9hIfIa55q05Zs9uIwT8hp+yxj6R7HGp54zliDMKQmJmckhLJ/S9mJfmkEQ3WaHFHMvcXtAN9riqX/JQ/imxElzlhs+XOYR/yF6iUo9HapdxXbDihzfQDm0NAvcwOq4LvFxwXqVMRg46supHXFU5EzHjdBbQEw12kpDj1K1c8B0P+496CDdE/yZo1fDahF6Lws4obYonQqzVdL1dYtrMuCSzQ6blEVI6ypMnEwzuAM30CKs0xbJ6U9v8Rk2og4JF6XSJkddBSEVt5iRqlYbskzHEWIMvIipc2jjXI4ytEEJh0OT1FVL4tJRLIDf9DSb6mI7aJi2vnPVJNFHKv+FVz+3wBrIx1oeO1+y1WehLAungID4hLbVBbidU5A4BJ9tIFELIm/qTJ0Oy/4ijDRCptpNfLM0acwmFnuGLhEAkKBFS1FPm6oJSO61aovo3/+z3N3JUm7a/9b8YvXfEBqkYUtULGsEA5XXJ9ZRmsIlegkfycoiSESAxpmY1esiCMR3bJ0ffVAgkgtDscC6PiP0VOmKDCQektWPySuHTUGuMzAu0rW+AAxKBQPKm/jkr/j41mjW7yloQM6sq1LJLvqide/PNrEJb9xTd9Dwi2ybxJMOi5sBckdiEjbjDL/Mj7ohtDvMFt+Mmi6xNRU2N5k7zL3iX/pgr85qe3OWNfMue2cNg+UK/4VPvIc+rU5o0uWCEFILtMOGqcBSrQ33NPe4zZkHKhI/5iEag+Ko6Ysds0vQ9XtQXrNldBqLDdsM5kUkhEAqNZZMVIs+lIfdaAe9mMZ4S/FQfEYk2mooX9pAdNrnXDngxKenYLkosJQZGcSkO6dsdKlmSGqcQ7Nk2bV/x5611JqXlunCfpV4oqY3blz/uBsyGH+MLxYVY8G+OCgpqDvmKR/a7eEIQeYLjRcUz8Uuk8ZmU7un8lvmTJdLynKJeYyYm3DVbPOz6NwexUoLbLcnBHGoLkRJc5ZZ7bUXbt3zQi5DjLfelHSp+dhmyk4T40vV8txuKe03DuHTUq8gTPGwn/O3sLR17iyfhOsd5ymla4wnBTsNjNZL8dmh42PbpBtAOIvRoj8ddwWUeUBsIFDxuNeln+zzXh/g24Lh6SRKssiguWEnusGH7WGu5LjSrkeJZWdG2TddHV+5Wd6sRI9INJqWmKQM+4DErkUcrkHws1nmbpiTSSdwBThaO5jRnxlNvB89ENExAIN0u8MoUDMuc9cCRlI7zlO0ooeELns1KTso5r8qcXeWIaw1PcWVnbIgOAYoVL2JVuCDTu3zOllhlgz4jk0EZc78TEKkOv1ycsW1iNqIQnTVpeR5Xuaa0Gk8GvMjG3I9dhajleVxVNWuRT+IJjiZTGsLHE4LHrRa+dFW2Xqg4XlTUxjKvLLPK3FDbDsQRvg1omHUs0LZNLmvXl76Wl7yYBmRUtMUae62A60Izzz36ZsBlXtH2PVoqIKstE5sjtWCn0SZUAZMsZtNrMqxdzVFmbmq2YdZpeB79SNEq/xGH5YRQShIdYkyXhJBIeHzLgpZ064Ydu0msPL62L+mbdWe1Uz7fVX/JFWMGseSbSclnwR0edCSluUNeWyprOJSHfK/9iEzD0bzmdiOhNpbTVJNIn1wbnrZaN/mF1SihMAFN2+dr8S231CO+WFzTEQl7LY/KgC3+yNjKhR26w3ZZ2enL20SiTWrdDS5UnSWazX1Zv+8Ku13riFC6HXGmRze93PcpZU9EJLKHiFzXNVQdapsj3td+MNTk9OwmQ+FS0BVutxnKthv5UpHqIbHo0PYGjO0xhZ0vXcOXRKpLZif0o/tLqET1+46wLQjFssO53C+VQFZdE3gtt+P1JQVurzvO3jFInrpRuxcSEDMzF6ype9TLp+xaFoTCuZVrW7j+rahoy00qcnwi5pzf/Lsj2aaQTv9YiYyu2l2Oxl0ozBMRbTHgtP6KQCRLxaJjwS5wQvLEX70JcYHjTWtb3UBAhJBYW9IIBzfrBYPlqn7JuveYwpYciq9c0txqlAgZmrc3NqZKL35vxbIlK/4+yigKUaCpmIlrVuQ+p+lviZIfUVvDoq5peh6eFIxLdyv868kRd+Q6ncBjEEvOM0taahoothOfcr7CXitESUHbdnjLKT16TEtNIgIKK3kufoOHywdM80MW8oKV8C4v5DN8IgyaL+q3lCJjm1UqW9Eg4ihfcC0mhDqkS5OMilTMWbXbXNgZSRnSorOkBznusBGGhS0ZFR6XdcqZPKFn1mgTcyDOmJpLNsw+b6cp26wzr2t8GbNp9ujLhC/4iildDucB67EPGbyth0gkb+yvsdowrF4QeC0i1aBvO1yKEUnhk2mPizKl78VIAe/mJcd2yEa9wmXuwA6bsk1PrzFiwVCec898ylv5LX71mLiUfG6+IavHrPuPuON/gEbz1n7FDpv8k+Y9JqVBmxafrkr++5NLruQJe+YONYYfrLUptOQ8M1zmJaFUXOXQCxVv0wV3Gg18AcPC9VJPs5IzM0YLTcvf5CCVKOE+j1eZZlgWPPB2KIyhE3qMiilrcp31WPHVqGY98dhqeLybacpE8f+c/pKKjPnJh1zLS1bMGg2Cm3BSmw5n8pDN4EOG+o3D1NqYb8VzPpJPGRYVeW2ZiEse+eusRJJSQ6bNcpJQc10ZEukzNyUd63SQP5lcYoWhK1eZ1w45eSfs8Am3OMkzxlVFaku6KqI2lqFJuZLHtK27UV4XJSMxxS8USeWMPhpDTHQDTrnMDauixcwUxMLnbT2kS5OBjFj3Gm5Ebi1lXXNmJohph7bvkYo5L7KQhUjp0uagmrAiGqwFEed5zofNHs/nMzIKbnk97jQaHCwy7rRiHsRd5pVxo+jS8o3O2YncA95m4vHT2RnNesCirqlEibYRHbvCVI45tyPu+QOmZU5fJkBMzzYJpaIhfDKd81ezF9xnj56MecE71mlxURQk0kNbe8OzttbZFx2iVNC1EQZLc5kOr9AYLIeLgrFNKalYjRTGhhyaQ6QZEOEhkDzpBXw5KjjkkoZO8GXIhTyiIV11cWTmRMScpJqZLplqy8mp4FGrQVrXLHTFp8F9Dheay6IktxW5CfmGV3wg7pMoxdf1IbPZKj3PVae+mE1piZDc1vgy5Nf6OR3RR+Ley7O0Jl1ON/9oh3Bp5kwq9xTty5gr/frm0MrtiEStMqvPbhR/aXVFqFq05QbX9atlMMlRpnyZ3HRppfCpTMpU5MyLM/woYVFfYow7zDwV0/P23C0c9+UWihYJHS70Ny4AJStHvLI1lcpZ2CuMNUQywSMkUl0CkdAUfY6KXxP7K44Vi+PFJmrV7aV5r21rU5vUISNtQcffXSavEybVEZ6KMLam4+0usY5uHDwVF8Si48Ad9Zjmsr86qY/c31u2KezccbRtg4H/iIk5dnvheky4DDbUpuDKvCRQDZfMliGRaDO2x8Rel5p8Gbyo8ESEwr/ZmSeix9xeuEN6SSzzZEwcrJEWpwRLucWqGaDRNImQ6jOEcfWGphiwYZyOrxIlPgFX5ium2cENG/x4+lOE8GjZPmuiw8guiJe7ZCsMi2iXOUPWGRBIiRKCQaxQQrCoNX+SbDOvDN/kQ0Zlm3vtcPmlUGNRfLIS8dWoZK8VMBczNuwajzoJv5xc86TRo9ABw2LfGanilOv0JVl5yaUpaIXbbEq3nz4xX3NbfMqEnA3ZYWYKGjKgwRqvxRFyGWLbxk1MRswJhUdXhXxhTqjMKp9EW5zlBSkl3+pjOnT5QfgAbS2LyuCbkL7dcbcG22U1Cvifsn+Pb2OaImQl9HicP8aTkpVIESlBVEoeB2tYLHnxiHtqi39X/z9cat/6FNTsijVWQ592INlMWjfVrtuBR2O+znf6ildTi6TDXsvjfKQoqfjPW08YRHCWfQbAl9MZiWjxf9n43zAILd/OXLCpmN1jEIU0PIEvFW0fXs0sMSEt2+dJu8nPphf8t0cz/kVvh3YgCaTrJ19ktQNzqJDYEzR96AaWWRmymUhW0zXWYslqCF3f8OOrBT0v4kfrHi+nMaWBUEHLF3yWbKIEbCfgS4+N2HKZC4ZlwaL2lg9U9VIg0uREviGmzX/du8t6FDKvBX917nEi3e/Yk/CfE1ifyCZsNH1ybZlVmic8ukFXvltkKCHZjAP6eBxnbrebSJ9pVdOufHbVipMBBIqFrgmtT9uXREowLDxankds3QSkF3o0dIuidPtaY+EYt667YMRt1piSkoo5n0V7vM4c3GG/GfMP5Tf8afgBl0WJRPKk4w7fo3nN/Y7HooZ8omlLx3SujeW23SWlZItVRiwwuIfE4+qKp+Ems8phQcdVwE7T42Th4B3PZi4M9toes2XX2WvEpKlHVhuUcD3m9+YsgLveGp1A8XxRs2e32YwDTjOHEb0wMypR0rEtOp5P4knGWcId1Xco2rJgmy1WGx7HqavWBSZgX25SGsOoMNxuKSLlfkZ+oPhV/g5ZSP6r/h6MG2hr2UpCrhYzQkJ+PbumTcx9uc92MyD2BOeTHm9mmkgqrNY8iLscZSHv5DsnpLAd9oMVxlXJeqwwNmZeuQNeCHjQ8ekGPpPSrVmedmKGRUhWG/5l+wlXuWU1Enzi73OVuzXNQLc5T2u2Gh7TMuCz5D6VcXmHpi/ZjC1t3+MfLn9PofujHMK+jGlHHzCpXYfUExGJ6FHYOTU5hZ3R8/YcS7c+YSW86+AYpDT8dULZdDUdMScWHYzQLIy7XSNC5vU5nWiXSXlAJ7iFsxkZ1sQ+KVO6dp2KgoZaIzdTatG+6c++FyUIoZAoGmKVqT2ltCkFcxrSOYVrKmJ/hUi6zvKkOnI1Jipq42pUUngkdJCeIqLJSfXFTWf4PzYXlTZ1jGZbkeGgJJPygMLrujHycu8SENP2tsjMyLlERIxyYi8sCzpymwIXCnP+YRdQy+rhjRZxUV0ifZ+GWGVmLpDL0e77KpIXhEuBhuNJl3rOvHC7a21KGsGAvLpGyog4XGVN3WNkr0nFlJCEqb24mVQApCKlRnPFAV2xRSe5wzR9i7ElFRB4TozxbPFvOY53eSr+DHCAgcxWbIgHvMj+PWHcZKy7PJLrDHNDadyuSkmY1TV3lynfg/mSwY3lsigZRDGpqRgXHvtyk1M9oRMkPEq6vFjM2AgalCKjoqDSGbXJMSZHij6T7B1Ro4MUHgP1AGsNh+JbXtuUbR7zjtfUuAmBL0JG4oQrEj5Vj5hXzuh0oUd0bJ8xOYdZylhe4ouQlAkCxd8UL9g0+4T4XIkDPBGyb+9jsRzlCxpqjYW+xArLIJZI4cJY17mmMIZrnVFUJW0S7nlb/EP9d6yEd+nadZrENGXAzBSc5te0sya34gajwvGV78ddfOlunlLAb81z1OKx672Lir+dvqM5aXEn6nCYL4iEzyYDagNrYY0QHn91UjEVI35b5Ghzi81EMa/gZ/NTvtvYJPbaXBeaR9Eqw6LiF9czTuQxH6t7HFUue3A985iLBcxXORZub5ZIn1YQcq8tOUktaQ3zUFJj0Nby66Gh1Ja1JZQlUoLjtKDt+zwbC+aVYVoqJmVNPwiZ1TX/542n5FpwlFp+Mj/mB95H/K5+y98Or7kTdRiXNS/FF9SmYE3scype0meH70S7fD2fUlDSE020NU4AsdDMyemSLL/XBL6QjEzGTExYNX2+nOZIBG0VcpaVNJQH2tXlDuY1vcAliNPa8moxR5TQCzwkEoULjj0Ru1TGfdHfavpcjH227Dovl3zuWw1H/PIJ8YRgbgs2ZIerXHNR5JzIM8z4Fr6U1NbQlB6FMYxLdyvf8To0fMm74pi+Wb0RpNTG0gkUv0xPCW3IvAo5qCasqxaBdRKMCedEJHwaJQQqYl5ZNhIXHHw5y2l4Ic95wW61R65D1rzEvYZMM11Wo4bynMfcQ0nXZng1rcgouaoED1oNxpVkyIhtE7OdhFzlNS1fcqup+P+O3hHoTSal5Nv5nBpDS4Rs2XUayolElBQ0laQylk3lUsoTm/ODtYR/c3VKUqzxdlFR48KBG3aNJi2uiopAKO7YfSrrsJx/U/4tDdlHj+7xTPyWh/ZjtqKY69zwYupWOCsqZqZLxpVkEIZ8U59RjR3u9bqwNDx3Q18saWQnXJHPVilszVXh3fSJzzPNeQalNiSi98c9hLWtWNghkeoRiMTtfu0lUnj07R5TeUlmR7TFBtLbdUpB0WVuf+/3bNk+UijnwrUTVuSuO1htF+M5xnM72HFVnuqSpr+BWY6yKgq0qMnNlEi2b8artUnJ68nNmLS2BTkT0uqKaBlImhpnY0JCXo+Jgx4RTYYmo7LpzaGcmRFd5f5OCp+cOYFs0FQDGrbLVFzSDW8Ti47jNZt37k0UDo1W2NkNbMMdKprINpFC0VJrWAwTe0Yomhzp3y6T3B0S0WWBA5f7hAztO2KvT8v2yUWE9N0NV1PdYClzO8FaQ8NfuxFkGGswFCRqlcrPqLXbtafVFZVOwRpnsfLdiHrD7DIXM3ps0TMreEgW5ByLb+mxxRP7KWPrUJmFP6Fawtuz8pzA6zqLkmzSlREH5oqmbZCKlAteOsUiPnfVgK2GWgLT3b7HWthOXD2r6QsKrSi05VbTZ1FZmj5sRBENX9DwfVTW5duJZlQWKCQS+FDtc1XlaFVhY80ofUlanNKMdxnmL2iF26yILUIbssYuvg2QCAo7py0GVKIgZXrjpD6u5sT4aAyrdBkypa1CAuOxnO5zX+5xYWc07T1O5Ts2zC4f8gm5qW8QnL+tX3DHPKQW91kNnVN5VGiUEORGE0jp/h6i4Gues1U/IJE9tsw+TREyp+B2lFBkmg+jdeaVIasNd9oBT9QKb2aOdvTlKGcnCflUPUIby724zbOs4rutVf4/i8+5KE94IO7xVhzTNT1+MTQkXoO2b7nUc2LR4JbYoDAGUAgBPdtGCvjuiubHVxJt4NN+hLYRv7ne41HX445ZYVTY5c+rTabhd9cpEmdd6gUwKiFQjvYlgKetNqepGyeepppiWSWpDPRDnzf5jD9dcWNSKRxeE+DCTOn4ffaSitczj6fBJkoIHopb5EIjEDzphsyuP+RCnjPlkkJP2ZbrNH3BWXHMltmhtDVTMedJuI4SsMh8dhsuhPPVZI6/zIVs2DUCqYikQklBP5QYnBM7zzSL2nBd56yKiBfTnENO6bHCfivgZFETE/Kk02BSmhsYSTuQLmEv5vTFgPUgYl5pOoHgN+kFfTvg22zMg7jLQZbyojrlO+EdVsweV1XOihctb22CSCl6gUdtI66LitwIPvRu0/YlsSeYlIZ24DSWG6zw4UrE31xf8iBa4U0+o0FA1w/4F8H3ucgqRoXlMq+JlBvRHy0qIunyBo+4j5SCt/aUfr1ClEnageQDv8PhouAHwSN8CVltGRWWee2SGqFocDAvOOSUXTbZb0mOF27v6i274s5GJ1jUzjMcCZ8LO2FDuqxEqMRyj+5Up0M7ZSGnfCe4w3lmuecPaHiC06qkQcKdqEOkJK8XhrbvMS4rrLVUaApKunKL8+o5n4ZP+XP1Axa1ZjNReAKqSYAvQ263FNPKozYwiAWDeIejhcZay52Wz+upS5tvxgEXecUn4RabiSTXECuHlv3iWqONpR8pViPF8dXaH/cQbshVFuaKaXlEoBoEXuzGolaRLgHmAoVvQ3xCRpyQ2jGFmVLqOa1gwBXvSOshkWoj8bmovyFRq0TLOXqmR9Q6WwoBHMJxbE8ozRyl/CUb1ZGrApFQ6gVKeGxF32Fijm8sR/PyHIG8QUfemJYICVWbaX3CQvhEXpe0uqKUixv4RkCMZz1m4hqBdDdtm1KSOrOITUn1kKYaUJuUprfhbszl72gHO8ztxY120diaqbhkWL6kH9xD4TOvzqi9Lk1vA4misHMMhhXvDhNzTE/u3uAwh+odAU0W9SV40BYDJvoQgJ53m4k+xiOiQY9Szsn1dDlZcGG0YfUNrWjbTQmqCdrmqGU3WVrJXMy44oD79mOmYs6B/jWP5I/wRMiFecmZfY4vY2LRQ8mAJFhlnL6hEW1T1Qu0KQlFk9IY5mLMLblKpnMC2SQzY67FIUdmBWYdKmvohx4NX94kTb+aTdn0GxTGONJMIWgHkqvc3rhyS21Z6Jq0Lh2Iv54xq11YZijGeIQ0vQ1Sb0htMrLiksDroG3BtTxh294hE65D3LQNEtEjZeKmGrYgkm1G9VtGvOWR/BFvxVe0xYANu8ELe0jTtlnIKT3T58rMUSg0mk2zx0xMmDJBCskLc0rHrDvzDM5Q85vqNavFAA9JW4UkSvGlfsdCjtg0+zRkn7G4pGG7zMQEvbQ39ULJQer2dr81z+nYPkfjEIOlIxI2Ivffj9ICbc0N/ONjucqrec73/Q94U455Iw85yH/Oi3pG5PfYnv43/HANWiKmtBV7rYDDecXbecUgduGZt4uclTDmVsN9qfjSAToetmNOUsswr9HWkpqKjaTBj6/HzMWcP2/vcDiveDeHfugelMalYVrCeZmhMRgbECnBYZqzm0Rc5e7hpCdjno0LRiajodtYC7+uX7DKBqG0VEbyKp3ztf0JK2qPJ+KuExtg3ZcjGQUpmR7RU3uc2CtG0xhfhrRkSCAl5+aCL4szEpvwMGkTKsHJomYoxuyJAZtRl78vvuZ73mNmdY3WllkFH61E+FLwKi3RhWU7SjjOU24nCX6+zdCmHMyd6KGoKv5q9oJVM6AnY47tkMdmQF5b1q3zCA9iuQy4GTbFCgtb0lYhoRKEwuNDtU/iSQ4WGa/kc2T9mDNxQVI7ut1mErCoLIMooOELjhYV+y3FRWY4zFwQ7HU+Zd1r8G6uue33mFUab4m/9aSgNpZB7BMqwQ8HHl+NLK9mDtfpIekLj9ccEdqYx/4OAOOyYloJJiZnLhbooodEECtFURj6QUhdGp4LB/15ZD5wK5yJz0asqIzPtHTe5DXbo+0ruqFkVvmc1TOexmv8tPiWjXqLQDUYlxUKye1GhJ4bHvirnBUZo9JBVvxS8bDR5iKrGJc1Dzsh80VGrkNKq3khn3HbPOCV+RlNuYEnQ3Kj2W+H/O31NdfXAavKTUM2Y4+/Hl4SErDmJaS14ihf8KDZ5CyruMgMwzrjtfyGoPiIhSkxuWVYuNVOKBW+FFxXBRKBznzGpeRMvvnjHsIxrsNrvHrp+HUjPWsLMjtyVSK1Rs4Cn5CEHiXpDWRCIOmIDWbmBN9LWLO7HMovXZpZLGiwilCK0NtlWv/+QFX4hNIFwCyGTI+4pT5lwZgVf5+ZPlsGhWqs1RR2xkp4F2NrfBEjhcInJLCx8xGrwuEz7Zy0dj3hnr/HwlxhrXHhMjGksikS/0Y68d7A9H7PWtgZtXVWj55ZY+i1nQeYCi1+n9Q2aLQpya0jXykZ3rCuC5vdhN00lcNSMr1BbQqU6/7KkNLMyVVCbUtC1Vp6kKWTTNiEUz1l1bvngmXEHBQ/J/Ba7kCsromDPrNsSjvYIbYNFC4het9+zFwsOOcVPe82TRvSoEcgE3bNLV7wpUuFB1s3nuKqXiClh5IBW2afCs2G3eacGY+jNW7XfX7m1czqM955XxDWn3IrajIsat6kBYHwaPuCpggRQnC3FXCZG15nM+6LFtrC3JQEOiLyBAstaImQk3rKo7iHLwW5tjT1BudVm0P5BqUCoqDHaPYlRiVsyEe0TYeuSAiNT0MGLGzJQ+7SDTwui5IKzchOWVXbNG0Dg8UTIRtmg2sx4VK/ZKFcwLCSBT4hA7NOR0Rc2AmZcJ91LJwvPmcS9Ljlf5eYkEj4PAzd3/Xn6QHoFe5GTXYWmxg2CIQis+2bB9iBXaWhfHwhOZzX+ELR9CV3qjsMotB9kSeKUsNqJMh1wGokeTZdMC0tj7sCJQUQsdMQDC9ipOlTRB9wNP8ZeTXiMEt5XDXpeD5llXCdm+Xe06MfCr6ZFfxorcWbmaNFxZ5gWBjud9w4fa8pqI2bWhxXQ/67618TyTbb5jYvpzndwCerDYUvCKVwvWYBi6uArYaPJ9y+tLQ1i8qwmShiD765mvJRY5V9z73O4yxDSZ+ZmPBs2uVO0/BRp002+RTPKH4ufs5H4jO0gfN6wUB0wMDQvMIqQ9928ZB8EK+Q1gZt4c/CO3y7mOHj9I9ZbdHW8tDb4G7b1X8atkuuDRtxQK4N67FiWlrezAu2wwZKCJSADzpNPAH9KODlRNx0aSWC7wZ3CZdjdmHdNCHVNd9bTRgWljczF06MlWBhSiLho4QgUIKG8mgHikBCPwjZLu/QDyK6ZpfKGqa6oBcEfDlOedJpECmWN0p4ky5oyIBCG0I8RnXOZpjQDRXPZzkbQYPtRPF2XvGuWPBhq4O27iBpB4K0lqwQ01tStx6KW0SemwRoY12FkAYtEXInamEs3G2713267D9fV4qPxFMedgKuC8uv0lPuey3XApCClVDSCeAodZ+hXFumtTPkzSrNU3mXVqiIPUGpPUKrWNSGgppRWXG/2WBcGo6rczq2y2VecWXm7PhtTlPNk7hPWhv6QURa3iGjYEd9QsMkIO6QKBf0/UFnjUEEr2eG9VjyalrzMOqzqDUfr7j9cMtvoqTge6sBR6llECSY8gH9xOM0nVBazaftLm9mBZ+u+oxLmIwrBmFIL1yCO/gj74Tf30gFkki2l2EglyRe5wFGuKCTbwNm4prcTohEh6YYMOIdqXXgipa/RUDCSFw4elR4G4PmunrjGMR+m0j13G1y2Un2ialshhQhC3vJWJyR0GFi3QGc2hF5PcaTMU05uEk+N+kT2JhK/J7s9b5v3BO7+H7CrD4jokktCmqRo6lp2zXOzHM25J4bTUufSO66p20xZtN76kbL4oy5uUBKRUL/JikOsOLvE9PGtyFz78wFrHBqQ9eNDtG2wFMhmZ3c4Cx7apdCzZ0mUYQ373FHbGDQ7oYvEgrmRLLDTJ+hlE/L2+Cqfkmi+rRYoeGvo23BOH+LsdUSmtJmVjrPZyAS5wumwLcBkWyT2BaH4oQL/S1KhJxKn8v0a1bi+yzqS7QpaIYbTPMjpPBpBuvkZMyZ3+DwjvIFM1LG1Ttif4W22OCt+JZO+RGeFNxtNPlFegyjPqFQxErwalbya/NrPhCfMCxqB+0QioN6hKkNu2qFXqgY2AALHKfF8jOZMhfuYa0f3udo+mOkSqh1ik/IpTxDmC1SkTK2gIAGfcZlTWlrBIKxOGfH3GFBRirn5GbK5+ZvWfce80j8gFf2cyyaFn0KkfFSfMGivnShOeOS6/P63P3sgn0GZo05GSNG5FmPjaDBqu3TlAGBhDELGkTsNhIu5j5aVLTtBmPm7ARrNHzBZaZv+p41BiUEL/QpB9OQW16P2PM4Kmf4skVLBVwUBf08ZrysRFzkDpJ/J475obfC35ktPs//NS/Elzw/qwhFkx3uUBhDJBXDokZb5+x9j66srSGUitxopqVkNXIj4i8zlxq+663hVwE9GmwmAcdZwbtixrrX4HBe4UlBN3DihV7oMS0N1pdktaHnRaxEkuNU82FP0SahMpa8MMRKciLPkFbyMv8P/Hj4X3OVtwiUZcfrkniSp+pP+d3iiq/qNwQyoTKbSCTGVDRs1302WCBSwXYc8iqdI2m4hDmCha451KdENiHQPq+uCzbFCn3bZaErnmdveSD2uMgLpmTU1FSF41pf5TWZVpyVCxSSnJI95faz7806u3YLay0NYv6++gX37FO+GXtEnmBcF0zEjB3d57srLb4c5QzrjFfTc9btCqtxTMMX/HLmes3DMscXir1mSJhLvrh26ZbfTaZkFLRJuC18Hrcc1vKr2RSNZk01l8YmKKh5VV5RmRU8IdzaqbLcbkmejWoGseK9b2AllHw1ychtxdPEVXJe6XMqWbApHPVqWFT4QvLji5yG8ok9yek8paBiP+nx5chVR5V1LIDrmaHlK6YVfDXJ+Zrf8WH1CZXxkAjWVJOV0ONhB97MHMbUWgiU5F0+Zy9q8jy/YtsOeFeOeeBtEyhx0/2+qtx7NLJz+qLFyLqw2o7X5XPzDbmYk9g2r6uK+ajDxObcylp4UnCeOSJdJ1B8XVxRX/Vdq8OWSAS/mlQsRMoT35mrvkmnrIoWb8Uxx4sGZ2bMTy46/Gg9oh84klhWW2Z1zXX1h92E/2B29KDzQzdixdDz9lzQyRYUenIjll/YKyLRucFZvt9f+iImsyMETl8Yyx4rdotD8zsqk9Hxd8iN23H6MqG2OaVe0F6iEcfVAR1/h8qmS/xkmwH7XAsH0ejYNS5540QLok1mR2T1mFC1ackBw/o1kWrTFdukTEj1kI7a5qp6SeL10UtjUWnmtL0tjK1d0EzuEtqYg/o3tLwNZvXZDbGr4+063KSZOkqYbNKXeyxwB3FlM1a5xZAjZtUJTX8Dbxm8ev/+lMb1gSPZISBhak5dRYsmc3tBQ6ziEzK3Q4SQxLTJcDengISJPiavxze8avfPXNwEwSqT4YmArHJjfiVD2tEufblHYpp4eCgUEsFcLLjigB6btGyHc3lEZBsc1r+h7W1xMvs5nkooqmu6jQcU1YRefIcVdrjFJr6UrEU+Xy5cgnFKxgvzE3rebSLb4Im3S6odVxfcE3ykBJk2DIuKO62QxBNcZi7AFUg3mj6cuz7xP9rwOU0FF7mm6UtOFu5ndmXmHMvXSBSn6W+I/BXm+QmfNv4bhzPEZyxH9M0qqyqh6Su+Ls6JrPtC1mg6ImFoZ8yXY+cLeeJoR2aTC3mExVDalKbokzOnsplDeOoZ2hRkxSVxuMb/qvGvuChT2iq8eY1tX7HfcjWsq1xzUE3IRMaK7XAmz7jLLSSCyho2YycUd7cEw2biudto7nymiSdYi+DXVxX9yGNaavZaHrPKhZx2EstR6khYh2nOyM75F2trHMzde/wb+0vaYkDLdPnzlTW+nZTcawdIAePCcpwWbCUhuw3Bb4cVq5FHP3Ld4MRzh/AXkxk9L+Je2+cn1xNifBaUfNDsMKvcQ8BhMcdHcTtJ+HhF8Juh5SjL+KDbYF5ZPAmLylIbV6arjCGUcnnTt7ya51wxxrcBczGlbTskhDfdzW+zMREBLRXwsBPw/x6/om9WOZZvuWPukVKwKps3fHAlBW1fcpw6FeJz+5rINtkTA9qBojJuBXCR1ew0fK4LzbTU7DZ9rnLDuCrR1jAII6x18gRj4Tx3dZbWUkP6gnf8k+Y9F25S3tKN7RLlbxc5iXTrmOM8ZSdqcJDP2Q4bNyGvcaGRAiZ1RSIdh9rg1IctFbCeeJynNb50nerCWL6ZpjxsJ/x0dsZdb41J7fa62lo2Ygd0eS+iGNYZPooxC77fWaMbwM8uU7q+I2M9z0bc8jtun5lWbMQ+xsKbhftu+eFag0LDr68XrPghX9eH9OwKPRlzuxXwYpqzHgVsJpK3MxdC3Ew8Pp+68Xh3ecv9cjJjzXe0wXFV4glJy/c5Kec3Y/Ouimj6Ln1+UM7QaFZlk71mwKhwdCqJ4Ll9y8Se8Zfhn1Fow2m14KN2m/9++j/Tl7fZMBuu/iWO2TIb+ELR9n0edhSZdrmEbyY5vcCNzWsLnQC+nWgqYzipnZWpaRv847U214XlMnNs9o8bq1zlTkYyiBXD3PnThYDDecVre8zno//rf/Js/YNvwi21QWlTcu28le8Prp532335kzpjkvKd9GCZ4C1t6kbOekqsehhbO3qUgkT10dLdWGfmjA3vMQUpl+XJcvx5Qc+7TSAbNzfAzIyBKblaMK1P6HvOI+kwkgmFdTzpqT5ehqWcXcQjosDtcxPVR+EtO7w5fXmblAnaFuRmSltuMNfuhusT3CgSW94GcyHpeLsk1nGpa+G6yu8P1hW7xVw4ClhNTW0KhHAs5rk+I/K6N8anQDYxtkLhM9HHWIwLhNkpkejc1JlSfUXDG2AwDpGpNohsA1/d4dR8xQo7pGrKpD4kVK3f35hlzKK4QKkAYSS1yVhU56jAR8s1NswWb+W3TvfInNrmnNlvEeIxABPO8URwY8hSMsRTTSbpS9rJHZfkFhGRUvRDj0npfjGEEBhraHobLOwV63aH42pOR0Qsas2lnlNSsSG7RFLxYS+iNPDj6zF3IlfTmlYafxnQUUIwLASzyvIunxPmHtWSJ54QonBJ9Fa4zSh9hRQeb/ktA3GPc84JaXImj/H0LjMtmcoRoQ2psIzkJYnZZSbHRLZBT8b0ucfIuP1Yzw4447VbT4gBmRkRyQ6Vcen4eXlCK77leOfGoHDghoUpqTHUJqbQivMyYyuKOai/RiC5FopVe4sDzmjaFgkh41IzrysqNLHwOVgYfOHStm4UKnk1tXxjD9hLXWXk5cQJDAZRwLeTkrvtiL2moNAhYan4t1enXIpDntqP+GfRD29G+UdzTT/0eDOr2G/53GoKjlJ4tZhzlrncwGlWsqg9RmVFP/R51FEMp9eYuscHyudfrHf4YqRR1XsQi8YXkt2wybislulnwX8oPucO97jINLk2jOqcSPgEUvJBL+Aqdzft/3A1Yc1L6Hg+oe6znvhYVvir7FdkZsQo/YD+8kBe8UPeViNa6QpP5B5f8Yam7dL1QuZ1ztCkjOSQPbPNib5iu1rFAgtd8VDeoRd5jMuai7ygoXx+PXOrqX69ykVecCYuqWbrVFZzLE/IxZys2GcvbDGvDKGSBFJyaK4oTY+X/Jrvyx9xmbkwz0F9zbl4Q7f+Hu1AMrcFldZca8OCjKvCqS4HseA3Q2dsOtYjcpFSiYKn4i7vxDG7doszccGhLWjXD1yCV89plmuuky0uuFXv8b3mBqepO4DP9Yw2McZaKmPIrKHtBexEDZ7ll5Qi5/PJlD/tt9lrxPgSvp2lxARM6gqTwbXOULlwbQYhGdop47LBuDCsBRFrscLLb3FR5ARSMi0NvcDnqqhoByGeFJyVOduiRSICuqHi68WI+3HXZRsCxaTUKCG5tgu2/BVWdMypnnAvXGFeaaaVSyI/bnR4tpggcb8HV8V7Za2hR59dtjnNMxrK507cYlpa7vAphXX5jNoad+EQkgtGmKrLv75y3wGrskllNWdFzUUhOJSHPBJ3ONczPmmt0Kh6fF6ccCjf8PeXd26sYhfiDafpK7btfaQWNLweF0WBtu535xtek4v5H3S2/uGwDnO1hE8ofCLHjn4PhVj2awPZdN0sNSA1oxsxwrQ6wZPuy/J9vcknwifkQn+D54U33eNANgm9NpkeoU3BsH7t+sQoWnYN67l/p7Ieseox1oeEss28OKMVbRGKFtYaYn+FHpv4BEy85s3f04WGRjRk78Y41DBtCpnSV/v4NmRkT4hVzyWmRUor2CIS7nCYmMMlmGK4HJEvk8lULBhRioxsCdHQhKzIXRo8ZSZHjMWJ8ymLBHe8u6fBDbPFpWozsof0zRYn4tsbj3BJilnKFtpijYF6wJwhkU0c69nr4+P2yoFqssY+Q44ozYJIdVEqwFcNlAyZ5yfU2pFpemaNbOld3jBbDMWQxO5xLt9xZd+BdUzsSLWpTUEvuYfB4KmIvBzR9rbwRUzfdAilJFDuqXbDa9ENFFWqGZEQiSZX4oz77NP2ncJtVTbZbfoUGtYigcUFsO5EbeaVMytJBG8WKXNyniQ9RoVlWNRMxYzP4i2kEPwqPeWWXGVD7xIRUIg9vkkMs/yYULTo2RWe+LvM6xqNZbcRcZwWfOo9JFKCi7zkluqQhJKVep8v9Bsa3jq+hKIImNiU0Ibc4QMu5CkVBQLFZfqMKOixyM9QIuCp+gsClKM+xTFXRcW1mLDNKquRx9epm45c5JL7fMxr8TVzfcFj+RGR9Nhp+mgLSsC4lDQ8yUVecbcVcJFrZpULMDV9RagE/0V0l9NUux27OeXjcNeZc7IF94gYl9AOBNuNgK1yg69mCUZY0tqw1fDYbgh+N6w4KBf05HujlaCwNV0V3ZitEk9wnJa8E8dQbHNdKM7stzwN/gnnmestH5YTfpP/azbER/xl/AlNX/B6WvLxSkTiwS+vSnbNPrcbzoL0bjYjFxkb/oC1WHEwN0tGtuB+4hjPm4ng1dQQe4Lnk5TbPOC1+BqDJaNCIvip/jVK+vSKJiM7Z5dtpjihAcBQnjMwW2gMd9Q6+y2fysLRvCJSLhzlC8mgEXOQ5k4yYi0vF3N2ogZxtckg8rnIK1q6S4M2H7Y65LVlI1bMKstxXrItNrjViPjU+yecpzW/1s/5562nXOUB7apBIAWLyvKDXpfzzP0cDzPJduLS2X9z6aYJn6wk5KM2ig63G6HzJ3t3Ocs0u95tCm1dWtvGbIuYhi9ZtwF+4UazDU9wrTP++XqHadXnm3GJEoJu4DMsS6QAi+VpvMZFXqIxTCvrOsmLiltJjLaQa8t6rOjWbb5ejFizTRrKo6wTxoXBl3CeF6xEsetUe+6ArYzlbTFhRbqQ7VokGRY+lbHsNyPezQs+66ywqAxzseAidwjM1Jbcj3okniBRiidBn81Ecl1I0tpNYE7TiltBi8IYvp4s0BjuNpr8NH3LLpu0PI+1WHE4r8i15UFHcVU0MCRsJyEv0hm3xSYGi2+c43pXrjK3JYPIpxuEFMbS8gXdyT3udTzGQ5+Xs9Rhdm3CVFyy5sfk2jBnTM9u8aPmbfabgmdjQ6BgO3Zo0EEsaGUP+R/m//6Pewg35cD5dK1mak4JRcslY0lZ1BfUtiRZgiAUPsZWrIl9DIZMjmipDbenFQMUPrFtMBPXDtZhnfQ8N1O6YhcrDZVJl0znmMyMWLEbjMQFWFf9mYkhPjFWamLRYTv57AZj+f7hoBAZQ3vEqt3jmiM6rINw1qEFI6w1VDZz1SU7ZWErunKL2hRub+u5h4ZFfYnyfBLRBdyoeY19zuy35HpMIJ1OUKLcwbq0/fg2JBcLTsVLEnp05RYze8mivmDgPeSsfsbAc18waX1FqDos5NQFOmxFU/TdTlr4aFNwrY6IaDOtTtBehcHVuq7FCZXNMNYwl2OwEKmu8xar1o2dKVyqDGubcyrfEOCUiGfyhGv9bjny7jmMZ+WsVAtTUOucJFh1Fad65kxXoknDdt2tF3g2XZBSEBmPgzRDIuiZNc7lOwISju2QxDh4x7QumZYex3nKcerxuBNxsHA7mNXI7Q/f69l2vA6jQrMaeaxFHqN5h2FRo5bqubbvYW2TlxxSUYCGSs+5Ll4hI4+q2r9xpCb5GheMGJVO7q0xXFYT+nXbMXPNOp/Xr/FtQCVKerbPWI6Y2UtCmlTkTPK39OI7pPU1SoY8iv8Zm6rphA6B4iqvaXgeu/WaqyVpy37Q5bJ0+7M39i2ZHpGoPveaMW/mBadpfeNNVUJwXCzoezGX+RJNKiTn9YIka/JVcc6+WsNa+MI+4569z9t8RqeMUCi+nizYbyR0Q8HLSU3kCVZUTDfwiJTgd+MZm2FCoCR7XotpVfPL/B0fBbd43HbjxnGhSbWm5TvGt6zdTQ4idsUHvCqv6VctPuhFHMvXtKItLovn/ANNHuR77DZ93s2dxq80hoKKs8wdCgPV4Fy7gzdUMCxKthIHa7kqCnpByFmm3Tg1CYmVxwethAfV92kHgsSDg7lh137GWZ6TKI+fVz9h4D3gzfw/sNP8Pk3bZc/sMSdnPYootOFg7hSIE11wqBe0yoQv7Y9pmQ2U8Nkxu7RkSFs6KUHDU5xn7sBu64RLMeLN3I2UT7KcM3HJtlgnVopMO/rU8/qYu9xlWBhWIoUSMWltHHO4jBx+EriQp+jFFv94rX0juj9JNWcMWbM93s4LBlHAwaJgZBesVg5N+YvxhIkYs8mAcak41RNWRYuvZlM+bLl97XFqWVSWuSnJFzX3WjG18ekEis1E8OWoYmQXSASfTyt2wyadwFsKPQxH5YxxFZLakmP5mjU+IteasZgxMAnzyqCE5GRRLz/fmpNU0/Q87sddTrOcQlu0hMxWHC0EDc+jsprxcoxckLukcjPiOvdoB4JCW07KBQaLFC22G5JnI00/8rgycyalxw/7bZTw+furKSdpwYYdEHuKWV2zLjw+7gf8ZlhwMBcIQCEYFZqKmtzURNKjEiWFVeSmdEjONOM0cyPq89SS6pqDuWA/bvJ1NuQoFZS4FaInBa/rY2pRsGG3WVSWi1xwXdQUWjGuKt6KQ76v71JbS0P2/7iHsMKFSBK1SmlTWmKNiT1Domh6G2RmRFMMbpLQgWySiik+IV21exNaWphLQtnmWr9GCt+9OEIC0UTLynWE60vW/AcYtKs71W+YBg52kYguI3NIZVNi2SPXUxreKiUpuZnQkKukxu1NS9zhflT/lqa3QUFGakauV4vPXfFdRuqSGSNCmjTo0jYdeqzxUv58+ToHJN7KDSdbCJewS8WUtthw0oilIjE1I7R0o3qzTEnHtJmWRxTelJ7aoyM2uBIpvg0IZJOpPSMWPTbVUwqRYdCO12zP8K2rG2lb0fV2KW3KdfWGjr9DQoepdQD8lu1zbr51xCVCcqa05IDMTmh7m2TW7cFjv0dRT9CmIJAJbdsDeijrEcqYSpQktkmNphWsoakZ1q9Z5KdUekEzct7mbrzPXXuXfuD2iaW2bIQx35QzUuNgAgC3/R5X+oSm7RLakNpaLuuUgpItEdGUASOTUduIB+2Qt/OK46xgLQzwjSKUkqYvmVeGRW3YiBWx8NlOfJq+4PK6QagE9zsBF6MuIT7X9jWeTKjqhQv2IShtTZsmVzrlQTCgMIZ5XQGOErbiBygJpQkIbEzbtpgwZiomjO0JD+0nnIsLjtNfIYXPrDzlif9PkUrStC7BfT9oAXCv4/PtpKQbeKS1SwB/Oc44kWfsmi2m9oyW2uAH3kfEnuBhJyKQcJX/vsI1muQc1Nc89deW+0rFde1u2rtiFWvhYddnvfwICQQqYRCBLwPOMoG24Al42PUoDUSFJPFcNeX7/ZaDaFQuITyIfDbEbZ4tJkCLBx3Fw47iq5GDN4xLwZ+3bvNimvGvp19zh30GUcg/Xof/7t2E6+oVK+FdNoPHDnW6HJ1HyqEZh3bGQLaZmJypmLFBn5KKtdilgLuBWyVEStD0HJWq1G7cu6gs1sJvx3PWgphMw6OOutnXVibipJzzv23+l/x1/mvicJVNs8ennS6/mlzzQWOFrcStMrLa0g2go0IKXfNBp8Va+pdcVTlzMgZBgsTte/eaDjZyXCxYCZt4MsIvV+kF/s1EIq42SZRiJZLMK8uL+pxa1OzGEZ6Eg7nbr3sSch3xpBfwH4Zz7kZdVquEdqz4dqL5s/WAvzpd4NWCH7W2KbUjiT2f5NxphcyrgKbv9vwPG216YYf/3+iUPbFKjKvj3I5a9ELBPwocyCVRgqPc8oO1hHEJoZI8X0zJdJOdho9cdFhPFLcagt8ONfNaMykd+WsvdO2EFQI+DD9jpyH42WVJV7e41VQMc4EvPZSA07Tmg17kcJCVpq4sH68kDCLLWSYwWDbjgNJYul7IotZM6xIjDaWpeTcv6AXOH14sH9ber2UWtXOPX+WC22GHaVXzeuoeVtf9hNfVkFLkjHTAtujTC1xK+08HIYsaFpVH7DnC2MC26AQeV0XJXc89HB+UMyKpEAZuNUMGkeDlVPPBSoSxcJFbvtdepRsIDuYRu9WKs3dZd9Hci5oMYmd+e9ILqAxcjnL+LLm3VG0qBvnOH/cQTq2zAr0/hHKcoD6SnZud3FX9EiX8JY85xxMhlc0IRZNYdByIQqQo4dP2tpnWx0SqTVtscK3fEcgmAsm2/7Gr6hjHnFYyJLSxs9OIS1blHWKbYKwll1OHidQjp1lEsiJ3OS5/Sy0LWmKNa/0KTyaUYk4gEhAQknAuD9zulJCZPkMoNwKuRLHEDg6oKahMRkttuL2vcn3myGsve8sdV4VCUYtiiZIMWegpkeoQ2SatYIvauu5oyoRY9VDWZ13c5dy+Qgmfqbgk1UP6ap8cRxXDQmqderC0KavsYbyKhb6kku59HdeHN/v1zIwIZMIKO1yYl/TlbSoKYtFhYS8pTUYSrFHqBQs1pGfXeMcXrIl9IpswEZdUonA5bhtzyRs3cpUO02lsTeh32ROfcMoFu94tYk/wZlawEwVkVcqO7JNYny/4inndZaIPUZ7vbqCmT58BHzdWGRY1gZR4xu1QX89K+qHPxys+55lz3X4zrpiWjlKzGgYI4dylg1jwzVizomK+Xoz4juqxIhocc+X29Y1V5vqC2ha8E88IRZPEtklsk8IYDuprVmhxIa644gBTPiCVc2ZcMqvPaHkb1OTkesqG95gTcUzGlFa0RU/uctfe5o045EfxPc6zirM8J6VgL+hQGXdDD6RgYWFUGPpBwFWZoK1hUZ2zHtxlXFXouaXpS86yko0lBCAqFQtyKuECaYF04/qCmqMsw2A5kG8Rk4dM65IVP+Rh1+PNzAWrQul+P7W1dAKPxBO8XizwhWLFDzhauJGoLwW3Wx5fjws24oBNr+luonnMQW15lc0odJN35YSNeAUhBN/1HvL31S/43w3+hI6v+T/dbpLqf8WXY/ifFr9iXp/xabTLlxMXsAmk4knc5zwvuZCnrJoNjsUZCU2+ns75fr/FaqR4PknZiiMGsUepLfc6blXxelZwZsZUouI7jSZHC83PL52D+d3cMtY5GTkvUqiFqx5eyTPezRKG8oLfpAWvFk3uNZp8k07xpYM69KyzC+W2oqBCIplVFWObUpcabfsO6kFGaRosapc/+FX1gj1ziykZbRxh6Xk15YNwgwf+OiflnGHuWMT/f9b+40u2LM/Sw75zztXXtLmba/enReiMSFVZVV3VKAgSDSw2gOaE/xs544SLAwJgN9EgCtWlsjIzMkOrp4VrYW7y6nvP4eBYeGFx1FzMmMSKzHj+LOyZ3Z/a+9tKWNrTojIsdMHTmS1KBkOuG97mV9xzR/zjuWVM91jnOtfErqQ2ECmHN0u7HZqW8NS8YU2PmKcLGipO6jlrssVXfInM3yNQIU+TBQpJS3rci1u8WmiGgeTf53/NSNwjKjwuckNBzci0+XpiWd6xchmFLs+SBUMn5O3KuumVLlvRgLttD0955A38ITvhJ8E2rhSkuubJzN6dB77L83zK+NolEC6H4oR7co/YFfzT7DV9MyASHh/0Yo7nmhqbunVcntM3fe5GLT5uDTlKDN8lM0YqxhWSszxn3Qv4ii95UL3LVWVf/47qU2pNY+zP+mxccNDyOM2speptPcGpFQdel67nrESAhssqIyFnKNrW3mVKvlqkuAuHD7odjhPDRV7ZsAhH8g+LY1qmxULMaGdd5Ao49EXxlneaPVquZFLYiX0/suvqjmsbs+iPbVFSwsVXPwpSXNpmSCWtz7VthrTFkDP5FCkks+ItgdMFCVvmLsc8pSNGFKTEcg2BpGV6FGqJK2ympBQuvmghkUzNiYUqVJfE/pCes8eCsVUQNycYtUkjKkpsIapNwZpzj6UZ0zI9FC5D7x4h9o675X9IbuY2HtAUNrXIOOTMaIwNVbDpSHOLMtSHtOQIF5+uHlJLO60jrOJbClu422bIVFjRkkvEBnft/ZYlKGibAamwsJJQ9smY49NaeZFtADwGLqofaHRB4PSY6pNV85JSyi4uIZ5qUeoliZrimAAp7Xv1I0ELYFmfUTYJi+aEXnhAowuujN02+LJF3z0AYFK9YZ69puPtci3P2dPvshATfAJ6ZpOOaXMkX1pbl7Gr/bpZoqRdXWflFb2wxbq7ZpugGnqefXh+5N6iMVbtulHvE+Gzp/5TDs0pc3PG0IzoiohJ0fC0OeKRsivAsoFR4NqUlRLGheaHRcbjjlXTgkPPlzyblTzhJfL6HhuRomskKrNfptpoHGFRo4kZM09f0+5skjUTDsRjfFza0udtfU0lKjDYtZ44Z2DaxDrEFT5T/YZp+YZt/0M8p4VeCcAAHBHYFbuY8JFzh44nCB2P60JxXSjSpsFXDm1Xsaw0j3oupYZxrrkSx3yT/lvuR3/FL6J9APq+LbBZ7TIMJH+fv+Chvsum7PLGXDAuKnYin5Yr+Kv1HlljM37d5C4D3+F22+Ui0xYq0QdX+pQaIkfw9WxBqBXrjn0oz3SOp3we9jxezDV3O5JxAXfaPusBVFpyXWuOEpt6s+u1WNQ1B16XD3oN99o+/5fDSwLZIVSGWgu+miqWlWVo39IP+Mfsd/yT85RIdPgg2GQUWp/saW54yB1iTzGtAiZYEAJYhnRCia9CXCm4yGr6vhX6bIYe/Wbd3gtXT6qtyGVaKnYixUWu+KqYEJuQtBmz7b6Pa3xqNHe5RW5q1r0QT8GvBj0EdqswLe3Pb4yLxEY45o2hzjWeVPa+Pkv5IFpnK5J8P9X0XJf/PHxEywEpIiaFVaQfJQGj0DbvjY4JHSukWw8VV7lmN1aMwjY9D7aKAT3PPsQ3xMaqWXPw6nXWQsVRUtJyPboezEuJasTqga75ubrLViS5yNpMiobVNYaD+iEbgRXjSWH/v/MqZZZYb3ClDR25xSO5x3bskNbG+pADwaIS/GoUUTTwZtngYz+7H3jrxK6k0Ya8gbQx/DArWA88NhnyQzZhS3VITUnTOKx7AY4QK5GTZjPw6dYHvK4mrJVDboltSmPXz2lj+K9691fkLIC2VZk3hi/GFZXReChCRzJ0HGrt0vMl/4afc5o2OFLwJB/zuOeR1PDpbMxHLTudFg0IDLOyYVN2EQJi15bNTijZMiHHaUNW+xSm4W09IcRnKRa0TPvmex47isiRtFzB/WqTk3rOu+4u/6H6ex6ZT/jI3+eyKPnTDcW0FJxlJWltCWkbkSKpDI4UXIjL/6ja+h9dhG3akU/JEl9aNe2PPlwHxURc0BPbuMbH8QNqbKj1lTyxMXjqn39WSwzxTMCa2KeiZGnGpNUlHX/z5t9JzBVS2mK/EGO0KWjR48o8J9UTtGwozZJQ2FjCi/op2tRIR9Flg4HZpKZBIjmuv2TkPqIkpdBzPBWRijnr5jZvm88pxJJAdDjPv8EPW/TlHtfNG5Ta41ou7eSrOpYXjaIvLKh9Li7xiJBIKgq0aFYTV4dG1BQio8DakLps0NV9DuVTemaDwEScihd4ImLduU0lCjLmKFx6ZoPX+veMxD0ruhIaR/kULJlVh2x471qEqLAAFSVcalMipcuW/4i+GXGqntMVVkV9zQmpnuAIHyUcWsEO4+wJbX+HVE5w+edM1koUaBpqk+KJFlutj7lMv0dKh7S4wHe7TFniVoqjsuDddgfRCKYrZXTa1KwHHq06oOf4PGvOKERGT2xT6opLM2NZB0S0biDqp5mdbq7EmCbZYT1UPK8WlE3MRij5H4sXhMVdup7Ddr7DuU5IFz4LU/Aw7nCW1jch4RNxwR7vMpHPuUi/YRDepzYNx/Il9/VjPFwc43DNgjf6C9pqk3NxzcB06ZkOH7j/BRUVS+YYNG/T3xL7I5uQJSoGxCTG0oZ+jHzLak1tNC6SrDGUjZ1o/nZ8zVRO8E1Ij022wv+GipLPkwtCArarFpdlRkrB+bXPHvvstq3XUCQjRoHLiyShoOZx3OVtktnQBeVwkVXMS8lllXGcCyod8zfJc26ZPc645kq8Zd38lEIbDs0VuUzYbmKOE8NpnpHUHpuhw4tlzpulYhS43I1jZmXDP5Xf8W/679FyFJFjOMoEz+eaXKSkZsLb1P7v/8/5NyTmCldEDMUu3XCf1ExpRM3rrMXLzK5Qr5jiax9dx8xNjkZzkVlvssCqXxeV5s1ygYdiWDqc5gU7obWtPVsmdL0WPU9yllWMApdvZxmxclgzQy7EJUq4hCZiX67xQp9QiZK26RFUDidlwYYT86Kx55s/62wjVwCJy7zEVx7P8oldheqEat7iifyOcbZDVo8Y+g7fJhN81ePX83P25Rov9Tk7rNF2XU7ThtiR/EF/zXZ+mxCX11WKi8tRCUMZ8cXqHjwTUzbNOmu+T60NoSP5Qv/ArcVtluQMdZ9pKTjPSwpTs6gccmNVwhe5w6WZERLQFj5t18VB8jKfc5w7BMIhUg4P4jZXeU1S1+xInw29S7XC/56kBQ2GeeUxLxteLWwDvRYq3hQ2KWw3dvlqNqcrA36/mPFXw3US32NcWAHuTF7jNy4bTkzgCCpt/cWR45HUhq4n+T4b0xctktrQ91xc6RI7Ak/agl9rc2OFCqRahUgItmOPWekQrwAoZ0VF0ThU2jCuM3aDmNvegO+nFvKRCfu+HiUlHdchqRvWA5evs1dEusWO3CSpDU9mJZFSTKuSUeDT9Vy+mVcMVEisPaak/L8WFkx02+zxukhRKHuDFyOelVcIoRAInudTMpHx5fU22hgSU1IWDUMv4CixbgWFsCCfP2YRrkyGoWGobpMxJ1uFKpQiw9Ud2gyZiBMCtumzxWzVBRRmaVGUynp4czNnYS6JRIcxR0ijaIt1tNdwVT+3yup6jF4FGUzFGaVZ4hBwpL/GET7+SgTVGHt3lSj765orAtFhzqUVf618tVI4dPWQRLqkjIlX0/Ilr3Ckz4BdJpzQC26xrW+zFEvaavNGdRyrdSTyJiEpYcLAbGOERtPgm5DD5ksrzlqtA6fNIW21SWWsdStV9k5d6CWV7OOZgExbgc6PrOqOWbdoSzGl5+zhmwDXeCTmilD2qU1B6AxZmgskLpHp4IuIrh6Aa2/HbTNkKWZgwDMhubBWrh8jG8smQUoXrWum2SvW43dZMzv0TYc38g0ZczwiXBEwqV/jqy4AjS6omiX7rV8R6xBPSu56bY4SqzDsuJaOtOUGnKc1sXLp+4o/lTt8sYg4lW84Fmd8xC8pTE1LtIkcyWGe0JUBd+KYQRHgK8l1rvkw3GBeac6zhn2zS6kNbVfyTqfFk3mKKyV+47CoNLO6IhdLWqbFffOAr8XvqXWKrnMyb427wYCiKvCE4oV4Q89s0DNtumqHw+Q3/DT8N5zIY+5zm7fmjOf53+G7Xeom41H4n1msqO6y6UV22m0ca3epNceFDUm43QpZVJq7HcXrhWBe1UzkmH2zy1txRGRanMpXfMgH3O9Zr2PPk0hCKh3wsOfw9XXJ26VdKZ82Mx7663zit/jN9YyzrGQ3Cshqw8/XLdUnduDXF5aDfJrW/Jfd+xgDt5st/h/LF1xVOV0vZpMBfXeD/ZZV9fYcn2BFw5qYJQ/dIbEr+JvZEY/cLf5Pw/fIGvgfzi85k6/om216poMvApRw+fVFjiMk4/olEonr2FPGLfUJa/TYC22831VRMS8bPo42kcKSvj69anin1+PlvOSjAcwrwdvE/tnu6BaDQLEbCZ4nNb/JT/jQucVP+i1GgWHgC14sK5aVYmZSFrUVzTxSexw3X6MxxK7ksd5lXOY0aEaBx7b02QgF1WSNrKm5yhpi19qiOl7ARdYQ4lFQ0yKk67j8UvyEnic5TkvSRrCh2szKhv9uY4uXC0NHbxM7guPUgitutwUP0keU1Px0GOPJmE+vcu53AkptqJea/ZZPrTs8SeYY4zMIFJ4UbGS7POxEXOcBG6Hk2aziw0HAUdKsipHPvNRsx4pZ6dtfj127tqVPy7XpXEltVnnTduJvuS5pY2gJnwddj63QUGqf87RmWtb8dM3nKDGc5QVJrZiJCVuyRd4YdvyYsjHcdga4El7kU275XUahYq+6x/fJjHldsmgEr8UbHnuP+PRizqPYhn/0iImVwzs9xaSEnchQNPDri5zMVPx00CZUMC7sa+96krYL308r8qYhra3XudQNLdemN627IbVeNbmOYhgogmyLlwvbnE7Lmp3IY1FpAhPzp50teh6MhKDr2Y3Pby9tXKEn/ZvV+y1nSFt2eeT0uMprDjoe2vi8WhT4Zo1brYAX6Qv+6+jPABj4Lb68zgkd24j/pNdBCcuPfrsUbIR2Sn87L/6/y+j/f0W4LdaZ6ENro5G3uGyeU8uCiL69p5lLAjpMxAlJfYEULqGyStuqSXBFSFdbX7BAcqJ/YCD3SJiwZExLDEnMJYHo4Lstm/3LLuf6BYYGIdSNF1fhMq+PEUIxr0/YUx+ScIUjLUnKGE1NgU+Ig0MirzDC/sGsqTtc6Od05Q7K2Fv2j0Qthcu1vGRqjsmqKevuAzxCJvVrjGNV3aVegrTK65qK0MREpsUt9VMW4hrPhCzEmL46wMElNROEkBRmeZPJfK0PWYoIzCpfWUWMG0tXUcKnbqwtqVYFvmwhtC3st8y7zMWMCSescXDToAgpGefPiL0RUkir5hV2W9HW1ooFWN62CsnKK+Jgk3n6muvsGU7kc0KKNHbNbdBclN8jhct19gytawv6iG7h4nMs3zIUD1lWmlNzzabYpNKGN5mlCFU0lsRV9PGUYCBjJrRAwGf617TliDv6Did5RkbBLb/FZV5xpMfsmqH1CooB49Km2fyYqCNxWFQwEXN2vQ2SrKLSGmMMfbPOSFl7xG7ziAvxNUjbPPx1+b8CYMQDAM55QSP2metTuuEBp/INI73Lp/wjjSko6hmxN+KO9zMeeiOeFleEwmUtVPQ9xXcTyaJq6LiKSHgILCc5qWv+4TIlIScmoE2PU3FBQYqLx66+xwkTnIVdn42Lmtttj3GueT5vONETPojW6XiSYtYmqQ2xIwixrOy8sajFbyYNeW2nl9ttn+tc40rJ87m9IYaOZJ3b5JRc5B4aC//48rrinV5AYwzT0oZJxARktebNoqFnOjyvLnhxKUnlkj+N7/Dfdtb5m7OMrdBnVobMzYRjrnhT/Z7IGdIT27zv3EIJuCoKhr7HtGgYhYomt2u5z5MLOsT8XXoKEs5mHrWoeZjcJW9soMfXywnPzKf8rP4L7rZ9HrRaHKZvOCqXPOx1+fLa8E/lt6yxhVcp7AwoOJLPSfQcT7YYiyOO8zYZJTN5bQl32a5Vx2eKpbbvjwaui5o/pJe4xmUmx2hpnxkNFWl1l1P5CrcOGOiNFdJG2cnwqmJZ25uvEoInvKCle8TJ5kpBDl9d5wQrROKPeMyFKVhWLid5RkXNm3LGetNi3hT4OLhSUGjN64VtJP6v17/BET538wf0HJ+v9XPeTjYJcenLkInOCIyywsbSZ7+1CqRY2An2TE/p0aLjWKvd769rdoKI5/mUCJ+dIOLprGFclsxMyketAflig2GguMxrYkdR6oatwCIZBZKzwm5QSq3py5D92OPLxYw5Z/zNxTZbbsx5ZuEgQghcKfn1ZYYrJJ9PC7a9GFdK8kbw5XW6ek6UvBP1+WGWcimmKGPft04ds+mH7EQuoSP4LsmInTYtV/KsvGJfDFjzFaFSHF7nkMNz+YzF8jYuihYxb5YlftfjItOc5QVvlupmWrb2LYUxA+Z1yXYYMC5qCtPw1WzOphfzllNuyW2+Wc5YcMHT5QF9J6AxDj3PpWxgUtRc5JqNwOMoMUjgMGls6IdI/rhFeGEuackRV+VTZu4Z6+oeM3NGbHpMxRmOsOvSntmgVgVZM7EKZtGnG9yioaIU+eo39QmlzccVKNa5zavqn4jddfwVZjISfYRR9OQ2F/VTWs4I17G3n8Is6Tg7LBubm7sUU6omo6jnBH6H3MxuiutCjOmKHTLSG9qRWGXxCGGtQDnWVN1QEesOXQYcO89IzYSkvmTX+ZCchMIsb+xPAIkZs+SC/qqZMGgaURHQWtGg7f051zPL3aaizzZSSDwTkKgVgWmlJu4pu+ZGwlX1nC4bNNQEskPXrFOIglwkeERW+Y2LKyyEvOvvY2gYiyN6bJOzRKIICQhkl1zPmJZvaHkbOL5P0cyJ/A2kdPGISJoLdtVHvK5+h0DeCLF+LMCNLmg591jTI9YdSy7ajh3yZEDRGM7znKETkuuGjvSYrzrZedVwr+OzmG7wVBzfwEJOxDl7bGGMBeQPfYejzN782tWAUEncUhErh8syZzcMOclyWo7LlhiwHkqOMlYPVUNNzaIpWZKTi5TIXyfJT1nmx8jQxZUhLdp0TY9v9N9yLi2r+575CYUuqUSJR8RjfsmnYcWufB9hJEndsKcG3O+6xA48n1ve8n7L/vOsVHhKUmnNtU448LpclpLX8hXvi4f8Tj9FGoVnNtlyWnS8DpOioeMplLDCrVIbjDEYobnTlkgB2gR0PZs7dacdMilswtB27HC0rJEC3iwLBDAKPG61JXmjGOeG3VhwetHlcbuFIwVvliW1NighMAaGgRVsnSQ1Ckns2jvmaVIxos+38itCOhjgJIW2crnVljhC0p0/4kW24Cfqr1BG8ka8YSdSKAkXhWFSVpYuhd2WJHXDgDZLcpRxaETNI2eHQaB4Na95f+DQGIGnBiznj/h1/T/xk/Jf82y5xJU+LgoB/Mk6fHnUpkPIwHfxK8VpM6dvtrnkFUUz52fyT3ln4HOa6pVP1DAK7Nr3pExYdyI6nkQKQeQonHTEcbXkljkgVg49T/E2tVnDHf0O22GAFLZZ+mBgeciRI3izEGzHlu2kFvc4aHvsxQbo4EmBFDZbNnIkw0AQKkHL7RI7cNBq8XYZ0Xatin1feSxKjTbcpIh1PMGf6Z9RaM3jgUvPM/RnDwFWIiDFyLi8TlL6MmQtsGplVwo2nBhXCjw9wJc2NvR9f8C80hy0FPc6Qz67KhmFkpOkYSf0ec8PkQLud2yzPq4zfBnT9RwaY0V+HooHbZuQdK8T8IfZNbelz58OemzN/8zegleH+6u8IRYeA1/xXj8kb+A4cRmFkqME+l5EWq9spNq3ynXXYyg2aIxd0YeO1Qd0PYUrYd9r4ymBp2BT9nCE4Ltpw2/qz/mX4cd0PIkzf8hbccq22WAmpriNAux5xxfqhlHfGMObJOO9XmQDRIzVAVwVhkAqIhw6ruQjuY8jBO3G4UD8BZOyInbs97ZsDK403Ol4XOUNkSMIHEHHFXRc+PSq/OOvoyPRR2OD48FGCy7KE3r+NgEtW3CIyERCzJC2s05FQW7mGBoCWmTCFrIhuwgUc6A2OZfiFS130wbVi5rUTO1NWegb8lNAC8c4lHJJW6wTmBYoWzglyuYAu+t4RNb3q+fkIsElwDchjagZ6E0W0k6mE31IpbMbwEjbDEnElNAEzMSUffOIU/kG322xYMzAbBPRplk9vB3j4IsWHiGRbiGF5NK8oie3OSo+I3LXUcJlUZ4QugPrRwauOWLALtfyjHH1Ak/GuDIilH0Sc0VHbNJQI4REC20zc01m0Wm6TcrENihIEj0mkn1m5gyBZF4eMfLfuXnfpVBcyNOVbUyt/sADXBUxy94gpUOsRkybQzSaubi8yUvOq2uqJiX2N1hkh4Teuk1XEqfMmpA1M+SzxYyR7FA0moSSeZ1xIY9Ag5GaT8T7aAR/mM5oaHAISPJj+zp8nzdo9thmUVlYfjdtU2sQCMZFzc7K4nG5aJhXDS3HZVLn9J2Ai0yTUaFrw5k8Z1dvUaPxcTnkiJ53wDx9hRCSpDhDCodvvQRPxtYr3WQIIbnyLpiaYxpTsSfeo0azrz5maLoMXJ9qlc96lWueFQ25tkKtl3ObJNRW3s0NuKwrrquSKUv29S2+lk9IG7v9uFBv8GqXltsjUJKuJ1kP4NXCAhBe5UtGos+zucaV4oaP3RgLsJer1jGtPbLGdvI7kc9JWmCAi8wwrzTHeUrotAmFy3FaESnFvCm4F7e4yCumpeYozflkGJE0NdHqVicEPAr7XOQl/8L7hMM8odaG9UDw5Szly3HIO30XRwo+6HToeYKvr0t+5T/iMtec5zkdxyNvGoSwq+4jPWZLDKjRnMlDRnqXNdHisrK2tPM64bHp8WrRsBcr1syQvvpP+OurMXf8Hh+F9xkXGgO4crWpYsFReUqkW4xEl4VxKOUmjuvzgrf8MC3sDZSKEJ/PizP+k85tvq0mVHXNea1IRcqH4QaL2gapvBZvOKj3edNcERCCgSt5hs72qLAq/B8jJOeloeMpXs5LZjq3ARilbSTeZpabPhQd3ooj3pW3ebNo6Po2XvDJvGDoeZwWKXdVCyXgySxlzbeF6EdtRJS5VMaCLIJFi5fFlIdhn2fZlHfiPi+WKR3HYyxmaN1BFYKzrLEramMTjRpjSJuGddfFU5BkNaVWPJvZ6MLz1Up+WjQcZwW+UBSmoa1cPux2OEoqnpXX3HGH5I3mjXxJL32HxJRcZS4ftPtcZQ3Pyis8XBSK6Sxn3YnYjh2ezXOmZc2zueFhN+AiL7kqhNU5pEu2fxSNuQ6v8wVt4SOFoO+5K8GbfS9+M8756aDNWZkSCJdFpUh0yZofc5oX3DePKbXhKKnIVgS/UeCzLfZ4mk15u2w4KxMi4XGW2cnfF4q+55M3Bk/BpDAcTVNajsu4ztj0Yr5LZizEjJFZYzMIKBvD/U7A389PeKQ3uK5zSu0xKaA2mkrbupjXgmcz63Mf69d/3CK80Bco4bLlvmsLAzl9/zaRblGKHLUqzj9Om2ljD9mRGlKbfBVkb9XFS6b4REjjEkqb7XulX9qJjSVr7HPBK0pSPCIcEawCEy7J6zkoWKCodU4s14hMm0IsrZeX1Eb7iSUKh9RMmZtTumKHmJApVkzlSJ8lFwzlAb4JScWc1EwYS5tKVFCwpQ+YyDFTc3Jz4/4xGWMppiuldci1PMPFJxZDGmp63gGlSXGZb7sjAAEAAElEQVSET887INczImmbmMIsGfOGFiMcYb3CW+Yel/KQFiMi07FCJmcl/tKn9u9coIRDV2xSU7FkbCMPzZIBuzZrWU3om5GFmgAeIQ0VlckIZIeev43CZawtmKNq0ps/o0IvCemgpEdeTzFG4ztdimqGFA6e07YqdHOPjgjYiX3Guc+iKdmNPSKnw7Nszp6+TUGFQuE6gt3IY1S5fJfYSRwky+wNrooZql0bIFDmNNqnq/ybgvz78gV/xj0uspoazWboUGnwpZ1mHAn7TZtxWXCHXWZYH+q6sScQnxZCOBhTonWJVFZYVqkYbSpib8Qse8sxX1DVKaPoXYa6y9Dz2VMRnrSZpm0Xvp1U9DxFoS2WMdc1oVJ4xgYc3OsEjPOGfWfAm+aKDdHna75gWV8QqA53zEcszIxNx3owW67ElZDWsBZITlPN++3uzVr23bhPz3X5oTrnllrnXhSigY4reDIrmZiEX3aH7McG8CkaQ+wK0lqwH8Zc5Q25qbluCrbooJAYWCEibTZtbawy+jStUVJwnFjbC8BI9OnKgLZnlaU1tskIFWxHVqk8LkCsUpHarqDWPkflkjVlp4uysSEP1cojWuuCpZiDhi3V4eOhi6GHNnCcp2yEbdbcgK6n+PfZp3zs/YzLXFM0mn+4yCioeV79Pf9t5//IVrRhV4xZyZk8Ztoc8q+i/4xvskt+0RnRGGuZuq8fs88Ws1IzMmuM/ICzIqNvOjTGZhlvyR5J3aXnSVhCrFxmTWG/h9SsOxGl1iihVhnJtuG43wkZNS7j3LKcl5XhIIyB2CrjzS22Y4ehD1ljaWgPvRADXBXK3i2VoO/57MR2unqbanqOb2MlXcGbhcukrLjjW2X3o6hHyxX0HJ/QkfTrDm3lsRY4GBy0Mav7qmBZKy4ym1ucNwZtrF0qdCTzsmEjcuh7oIRClYJ5ZUlksSv5zeySx+GQqqnQBtYChw+Ld3in7zIpHJ4vMgZByFakWA83OFxWeEqiVorty6xhK/R4naY8aMeEylqu+r7ih2SOg7xpTAIliITH5spPbLCvM1KK2HHYbynWfNjyI4yBtVBRLyz9LZCK2PGIHUuZWw9aJHWENlBjGMiYUaiodMiDrsvvxksMhs3ANteVhou8ouc59D2fo3LBw6hDVhsO/DZJHTFvCualVaNvhvDnbNMYQ2Osn7jvK3q+Tdf6p/GcXww6bEaS57Oakbn3xy3C6+I2hci41od4IkIKh1l1hOPaKdJQkrNE4VJjAxha3gYOVr1rVtadafUWYBXHp/BExJIxjghufLKFyJCr20BFbidpExObDq4T3GT+nvHU/juiZFGd0XG3WTM7pMIKuSTK8q7rKcJR+CK8wWDGcg1ftFmYS+Rq7dsVVp2tMVyI53giYtGc/fOaGBucMKlf46kWLTGiwSoXA9NiwSUDdilYMpB7aBpSpjcr7Jbp4YuIpRnjrLzVAImcE9Cioaahsvd2U+A49xjKW6uboo80ko4eMpYXbOu7pGJpARu6xZU4wVddAhMS0aEiQxqJS4tSZAzMJplIOSo/w1MtXCdGNFaBmOsZgewyMYcETg+A0BmS1WPqJiPwhryj/gUtE6CERGP4KrmiQ0RGRVLZdfSGE1Nrw4Wu8LG3l99NbfHxcTjwfs735b+lrhPm2VueugvS4BO6DHkcxxwtK47KBR23y6beJG8MkzrHx4YUFI3mqJrzyOkxLw2F1owCn5Yr2dIeb1OPnAqzgrz04nsssiManSJFl6qxegFHBdTGqiv73m267jqPnV2Sur5BAH69sCITsJCLrDa8EK9JzZR9HqEaSWM0S3KOlrZAX5gZHVp8L78HA1WTEKgOBs1UnJM11pYyrwzzShE7gou84iVHfKhv2c8I9mb7tLqgY1rErmRcaCqtb76uW6pDUhnmlWCcWzVm5PhcFzV3Oh7P5wUbXkhjAtYChcrEiljl8WKZMiflIvN5myXsBDbBaCtyKJctdiKPgS8oteI8rQGHa3nJL4IeFzm8XpTstVxO05qsqdmJXCtsciRrKmK35d5Md8dFQkJGJSoyPUEou91ZMy2uCjhNG/q+XPG2IW80P6TH1BRo4Odrll38f36TUwiLWJ0UNUrYNemVWTAzx3iyxTfZJTEh38wXbLgR63qPKUvuumsoATthyNssoaBCY3idWUuOI2yDMik1Z+KSdtPlSp7xrrzLpM5JmporpuRZB08oElPi4/D3i7fssMFrcchWsoWDpEYzEwt+1dni1aLgJKktca8yfJlc8U44ZBRKLsWUll63ljyds9F0aIxhYpYsasW3yQXbeoe7cYuup3ibWlLXd+YFfy4e4q5W3pt+aBndjmBeat5mCX0noNQO06JhWheUjWUZH3FOsrAZwBkl6TwiNSUOkt0g5p1ewO8mM4qsRiI5zXJaKwfD2zRjIuZU1wPutH06jsd1rvGVIGsMV01K1dS0sM+H1JS0Kx9f2CSwbxdzXBQan22vxbfVW6bLBcoo7ntrSARXec127FpRpytZ1DWpKanmIU+0JYClFCR1m4UuSLXkTFzwS+cWx2lBYko2vZiOK3mRJGx4NqDlImssx3vsMxMT1s0al3nJ0PfwFJRa2+dMWXAhT3BSSUZBLlJuiS0KKu6FLX6fnjI9a9GVlny2piJcKfh9ekqTVtyV20zFnMZ0yBtrjZo0J/9RtfU/Xh0tCpbmAm0qItmzCucVpjIXS5ZmfBOSHos1Ar/Lut6loGCuT0jVjLYZgnub3MwQ2FCD0qSEomv9viLHNyFTcX6TGqRwSfWYC/mKkbiNwmFhLhlxgCMCOmZ9hWe0IQoFOTWVnfQoGMoDrpyGthzZrOMVLzrVE4byYHW5tbznDNgzjzgUP5A2Y1rOkEjZiEJftEj0FXk9xVMt+mKPqTnBFSEekb0niyFd3Wchx0zNMRLXepKFj6bBMwFLMcUVIZFpsaPet2+ugStsc+IKn0gNbd4wSxz6dpIVLQqRcW5esGGsH3kqzjFGE4kWNQWB6HAtLu2N20BgIhwcTs0VHbFOvrJLzbI3aF3SDvcxpmEkH6GMy4n+lpYa0THrlCLjUhVkjOn5t6hNQ0LJSMZMm5zb3oDLMsNDUTSaluPSGENlNDN5zSkzPCJ+4j5ACEFLejwxJzgyoMagtb2Dl2TsqB7fzpakFNwLrEJxKhYEhUtJQ0dYte2srni/1adozA31KlB2lfc8m7PjtjCVoSVGLMwlWXlF3cwBSbnKpzZoRtF7pM2Yd1r/CmVc7jsjkrqm1A1gOc73ozahI3gyy3nYtark/0PrEY2B/2H2Hedo7pg7uDgUuuGIcyJaPBff4tPiOPmU/dav6JohPRGxLT9mI1KcJPXKKlGxFQV0PB9vuY8GYkewrQIqDVtiQIVGIAiUhZR0XEEduBynBZVWXGS2YTxo+URKcGzGxOmIVFecVtf8orVJ7AoWy4rNwCd2BO/1Yt4uPSpt2A9jdmPJVW44SWu0MZxlFdq4dDxLA5qXmp+4d1hUlt2tMTdCsJbj8mKZoxCMQp9SW//tvXZIWht8HF6KV/TZoqt2WNNbRPjstz16HvQ8xYu5TQgKFdzveqwVe/x1fslniyuMWbNJVIQIIo6cAe8PPF7O7Yr3lttn2dxhYWy84oOoTaUNO7FET4c0xvKWj5KKUejyTqfFpNDUqxPD2zRnFHjstSSvF5oDtc+LJOHn3gOO85Qt3+otBmbEYvX5uBW2uN2WPJ3t8rCreFzalflhlrLuhfS0T6Ag1zWjwGU3Mjybw5/11jlNGyaF4RetLRpt6VzXhSJy4OW84c/76zyZFUR6j/0otJ/zRq+2Lw0/8+/zIlkSChdZC9Z8l/XAI6uNVQYHES3XTpgtV7IVx7ir6TTOd5mWNW3HYVq53OsEbAQhkxI+mywYBm1awueMazYZsBF4+CrEkbCFw6wMEAhmpUZJwfZqen82q3i/3WE3Fhyn9maeNzZWcyuyG5+kikmbmoHvsBEK5Nx+3t+UU4SwmgaArxYT1mSLQEk2Ag9H2nPL0PeoC400wmopqoBFU1oscV7TdV0eRAHTlb7icScmUIJ5Kel4AleuMS8btqRtaidFTdu1wJqO61JpzcNuRCu5zyB0uC5CJnXAhVmwodoMA8GDaoOeJ/GVwEms6GwUKj4Kt/luas9Dj5otSg1rPmS1YFH9kYtwzpJaW0ayRtMVm1w2z+mpHabmGG30zco1MVdUOkMoi4cMZZ+2GbJu1shFQkdssjRjlLBTcmom1CZHoFiI6xt1daz6XOmXtNTITrQiYdy8oqO2wcA6t5mLSxoqHphPeMk3NMJOpgJJbHqUIiOWa0ybwxWRSxGt7D4Zcxoq+mabJRfkzZy36jvbEMgCjWakD5jKSxJjAyxwLLQhYULWTEjMJQP3NgljymZJX6zbVCIzJ1zdmwdik8LkhNi1ekCLjmnxjfk1B+Ij6zM2Ka6MmJsLOmLE3FwgUSRiFYRhQlzTQUkXYZS94VYnbLvv42trpfrxhu7gk5oJ1/KMA32HWK5RklmPs3OLBSerWMIZjgq4VkdEok/RWJXpm9oqX9fVPXJ3yojbFKLgTLxiX33CjmuFFRUNW27MtCrtulB8TUeMeJ3+mrKe0Ylu8cR0ONZfI5CEqm+pZsJDyYisvCTxrviD/Jye2KBtulzkBY6QhMamMwkdMDM5y7Lgo26Xcd5wWqTsBBHf6rdQ7FsFqJgw0jHXLG7obla/YKd9Y2p0k9JtPWJT36aQ22yzxsQkLOuaF+I19+VtAJ4tE2ZiwVrW4w/6P6Bnf8nIt1D9z9MzUiZ8In7Gu0OP34wXdF2XrBzwVHzFojqh7W4TeH0i06ai5IhzhvWANdNi2uTUjWbDiXk+Lxj6Ll/o7/jXrQ/5w3SOQrITRJzpKXe9tZXv0eGb5YxKtzktUjzhUBvDWdaQNBWu9FhUhttqnb4vcWTErFhwmtbc6aw0HNowLW3X33FtqPrzbM5Z7jNwPa6bjNthi6Ix9HyLnHy7rJnWBR8PYqSAvFGYyq6hH3cVlVa8nEuuq5K3SclEZ7wTd5lXmrPcKtvbYp0lU66rV4zFS7acd8kXfdbTFn8ysivI42ZKuBzgSUFtDC4BPWIu85pJneOi+F58zZq6w6dXNtSDEqZyQoLVeAQ65FWScikmLKtNKqNZNCVeIYkdxTiv6fvWjzprCgrtYYzhPC85WekLCkqGos1pnrETRJznOQklMR5P5He8I94jqTS/uyxpMDyf+/yhfMW6Xud+3GZRaUqteTIt2Qps9vCTmUveWD+5pwTfJTN8HN7r2rzftNb8bpzxWr5AJO/hCknsBcSu5Ok8wxeKVFt/bsv1eei2+GoxoWUCZqXkusmsxa/j8ZvpmAPdI6ut0t7kmhF91nyPdOXDvSxzjuUJnewOi1JwkuUIrEjMk5KR7rMf+xynJdc6ueFBr/k+p0Wy0haU/ONkypbqIAQsKsN3U82iaii1FS5WpuG7YsE7/gan9ZKKimmSok2PszKlLX1m8ppl1SZ2FEltYxtfmmPCap+v69dEusVQdBgXJQbwhOJNbkW0FTV7ep9hbEVpV3lDpeGoXLDftHlaXZCKJTvJNltBSG00F/WC27LHUpc8X9T0PZ/n1QWP/RE9D8a55DfpawqRsc0uSzHHb1w+G9uT2GUJbeXhS8mkLDgpK46TiPXAYVpq5lVFUtf8YZZwy+/Scjf5j/nr/yd29G3xMWfiFZGx/t0d+T4VBa6ISPWY0qRsmXss5ISJOETh0tfrvDKHSGV/q4YKhWMzWvWSthzZoAJRMGneWK7zSo0LsCbv3NyLNQ3GNEgUGsNEnNCYikj0GcsrtLH2p9DERHRuMJEeET21R2x6zOUlHiFDs83z+p/wVMxEQkgfRwW4IiQ3c9bFbRpqKmFf7yYPmIrzm8Sorllnzgk77ocWoYlhoa5xtYtrrJf5x/ctFUsSJrRMxwq5TAuFZE3dwdEOLg678n0W4pqR3mYqrPhqpLdZMGMhrplyTod1MuaEbGKEZtf5EL1adQsh8QjxjbVlIe0HoKRZTfvpjTjMUSGNLhBC4qhwNcEP6bpDAhPyVP6Wq+R7LvmWtfgRQ9Mlo6JjHvKsvOJX3Q3mpRUoOdJG7E2ZU5uCH+b/I1ongKFuMkrHit8iYYVntc7w3TWU9DFGM88P8cM2Pwn2bn5m7EpOi5yu16Mxilme8zDu8NVsTlv67IcxHU+iStcCDqTPZj0CYE8N8JrHHDsvmWavwdT2nOFugTvknvMn9EzMJRV9zyUtXHqey2axDdJOowMnIGgc/mQUsDX/L2h7kqtVqMBEXLCnHzEIHF4vGkoaFnXNiTwmpEsuJyjhEji9lfe7xWBFg+p7grtxi+O0QGO40/Y5zxr+3H+fpDbcjax4CuCBv0bkSFaxyTYlSwoetluMArGyjQh24hhtDC+ShLbyqLRiUlZciWNO9XMWk4/tQ0gbtIGd2HqFZ2VDLjIKUxDrARurxspXkryBV4uCxhjayuO313P2AusbtdYOiTbw2TjnuXjJx+5DnlbnbIoBbVfgKcn3xZx9uUZiJsT0b54jPd1nXbVwhb03l42mQ8QwUHRcOxH+N733SFf3wvXKQQi4XO6yyYA7HZ9J4XNVFGQm5KT+mtDpMZQRG6HLjg4JlOA/pM/ZYZdQCb7OzxnRp+e5bISSF3Orbp4WDm+yhI7y6UmPQdCh1nCcFrRdQVK7bLkB3+Tn3NeP6XkuXV9yndt4zfVA8q+iu0wLg5KQ1Q232z5Hy4p5VeOsojjbrmBaGjZCScvtcpRUuBLutMBTLkfTKR+KdzgrE+7H7Zvvwcj3udWW/PayZixm1DomcgQftPvkteHr/JwdOeTDocdFZmM533MHjELFchazH0RsRZKBb/h3Jzm7Qczjnkc0OaDRhknT8NEgImuslSrXDXdbdhOz5rvc8QaktcERktMi5f1uG0dAx3XxmjahI9mJFY5glYSmuMgbe69VHvfdmNARRKsQlpa72pTErRsKmN1c2IbulhmyEw05SqE363Mn6DIKFFuR4TIXHCUNi6Lg/XaHpLaf544rqAxUWqCNYddrc6ejOL9qsyuH3O1ZRXRtNO/FA/vahMPAdxkFiqczw0VeMPAj9luKer6HEIJFVTGQu7zU50zFGe+Y9+i4LkrYs8lWGPBeP+TFwnLYb7ctia3jCpLa4/kiZ4s/8k143pzQqIpZdYRxNH2zRWispL3HBo7yycyERM65qp8TOyN8E7KQUxzjE9BarZYn1MIynV3H/vqcJTUFbbVJ2wzxZcRMnKFpyLF2I48I34QEqm/JVyIkqS+I1Bot02MsjhAoGiy4ITdzesIqt0sycjNj0rym79xCoqhERdfdpTRLalOsGNEpQkmKZsbCCa0fmQvKZslStgjpMmCX0+ZbtLIq2pQ5EkkuEkpSHCQ7bHKpLQikp/u8Ft/iipCZvCY1U0qRcS3OCGgxk9cIJJfNc9pqE43BNyHnzfdIx67Ua1PQEkN84xOKDhUlE05xRWgDL+SEXX3P/j74jHmDNC4dMWIplsT0WdMjnvA7ZtkbfLeL68T4qn2ziZhxjNGaSA0JTJeFdNC6JhR9Jszxjc+W2+G0gpPEcp9D7TKvap6IJ3TNOr5s4bs9siK5KRw1Fb5oUZgljamoKsulVaqF53QpqikycjjNck7EOTtsImqHEX3anqTlQFLHzMuGTS++KQBHy4pIt9hQbfJGcyLPcLVPbCIu5RkeEUp4NMIh8nZYDx+zrvdIxJwN+uyJNcZlyYU8Z0PfZikSbvstxoUVIX2rD7k473AuXnEre8y77Y6NWyxsaPyy0rxqLilEzsxMuNZvCJUN4phzyZ54j59EmzdWoEob3iztw9WTknGdERWSH6pTqGBoeqQU7Ltdam2hC98uFgTCpdIuhSjwlY11O01hN3ZXcXE28m8niHiRT0kSHyUka+zwwB3xsKf4bmLB90WzEqNkNblu6JsOQy8gUIKzvKDnegRK8HSe0RjNvXbErND4jUNSac6bBRfyhAfLe4wLl8LURHQ4KZdIIXginhAv32Vel0zkBSf6CVk9ZS5OrBjOWadlAn4wL1HGpbrYs8IXsaTjxuQNdDxJ14VG29CFZ8uE5/I7PpE/YbflIoCvyre86+0zL3367gGx6fGcQ4LygJZrBUK3zAFLCt5kCalc0uguX00TPKHITMUPs2v2xSZbfkRWa76rD5ktz3mPj+i5LkdJxUIXlNrDNR5LcuLGZZHUBFIxrQouS0NFQ08FvNDH5CKhmt/j0syoRIWDwq1GhErwupiR1TaqMWkqrnKH30xWAB9hm7JLeUk789mJPL6dLdkOQr66LhFCkIolXyQXfBSPOEkL9ls+v2ht8jfJcxaXm6y7IXfMLZJKk9b2Xvx1fs6sXKPQDQk588onyN2b5uCqSVkv3Jus3odxh+eLjBNxzp+1bvFyUdBxHW63ff4wT/hulnArjrgsM97ttni7LPm/T7/ifx9/RKnhq+SKXadHqW1m9LfljD2xTiAVldHUpQHg8+SCoeiwKDM2nTbfT2u2Qo/zrOLlwnDQ8nBxcIS1JL1ewstFjgAKSpKV93pcVHxX2FzgFgEZFafykMnVHSoa2q4ibwxfFSfkcsmrTDPUG6RiydtCs19sscmACQnP55KW4zCrKyJpy+J1k7HBAIMVX/7t/A235RanzYwP/bWbAiwQ5I2ldsWOw1ogOeaMMW/+uEX4x3xbR3g4wl/ZcXbIWd4ohsFal6RwmVcn+G6LgiVpfU3KNZEzoCM3V+k2Cm1qZvqYntqjMhkxPWITkYgpa+yzZIpE3RTXH72ci+aMlDEdZ4fa2LWxh53GUes02Il4ak6sHUi/IZBdpHIZ1y9pO5skYkJtbDjDSD0gx0Iv+mab0Okw1Sdsi0dUdDg13xKKLj29zmvzGZFas82DsL7hXCQrTrR9OydmyYa4a5Xjq1uxQZMyu3ltt/UjxmJMITIMmrbaJKCFi8NEXLLm3KOrh2g0h3xLIiSbbHLJkW16VszowizZ4C6JSCmaGUrdJhR9CrMkMLENZTAZuVzimIDN+KMbfnbPbKDRpGLORX2Or9os6zOyyiZeCSG5bx6gEBhhu/8tN7bg8xXUvtQNAzYpRc60fENenBEHt0jy1zgyJDQxih4Lcc1Z8gUGg0CAkJT1DNCcLH9P0GrxSNxhJ7I32TxpmBQN00IwrjPux23SWpPWhlobzpsFA9qsBQ6BI/huUdE3Q7oioNRDFnJC4PVZix/jCJ91vcdH8YizrMdaYG+eV3mDKvd42HPYrrZs+lBtuMgqKgp2VJ9H7hoC669tDCzJifBZNBWBsclTGs2+/IBLDvEJ+IiPWAsdPAl3WoaB7/B0ZulH46Km1DbdqetJWnmLjgjYijzOModBoBj6wvpGgxbv9iV/c5bZBswR7Lfs/Wzo29dTaEHPszF066pFz7Pgh1GzwVYk+duLBefygncKW6ACBaPQ4bPFlDXRRgIHLUlWu+xE9qGVmpKCkldLycNOCPgUWvOTTp+jpIUBdmPFVtTid9OSj7pdXNHlr2cNT5tj+vRZ6gu2xGNO5LeEqm8bMJNyKI9Z05tIBB+sewg8xkWLvmf4emIf0q+XFq94txPQVh67zT2GsW0EHnQlrVmHT+tvkFKxq+9wIU95yB1utR2kgH8cz9j2WnSNy/2uQ6nbJJVtQGZlQ2AUI7lL2WgaA4GS/NQ74DTf5L1+QMuBZ3Poi5jYEWzqAXmjGQWKyljvdr+2UYe1UcSO4hN5wGmWMwxcNoTlXX+9mHPQUhwlDdtOh5Yrb84487Lhcdzl19lLfhnctirh4hYt13pkH7TjG5KULz1uN/eIVvLjfj+w3/0GHstbbMY2DvAis/fgUajsxOmOGIUKV7i8WPxzRrcnFPstnw3RJXIEv/R6DH0oNfgq5CPnNklt+Omaz3UB2xEkVR+D/W9vSfsZPGh5jOqPeL7I2AoD/nKwzhfXKX3Pp6o0/6Kzy9CH68JO2j1fkNaGj8MN3iwNENioQWMbyd3YRQO1tp/9nm8V+U9nNfc6AT0PBAG/vcrYCX0OWj6/CLf424sFd9oh56nLw+BdDlqCTy9LWq7EU4L3/S1arkQClYbnicftKKblSm61DG+TgKOlFWXueQHjvMZgV94uil+19i3Ag3U2QxeZ9Qgd2yReFiUPOiGh4qYA1xred/f5D9UfuQgfiI8oTU4u5wzMJksRMjcXrHGAoeHMPF2F1Tv01B4X+gdyM2fEAZmcEKo+HpZo9WOObaYn+NKmEdXkpGJuARv6gmyFXoxEn47cXCkmG9pmgKN8hnqDY/OMhoq5uLQxg0g0mg19wGu+IJBd5lzSVTs3yUAdZ3RDulqKKZHq09N9LmRmhWIqs8Qp2bJWKhMSqTUKs6QSPWK5TmWym9SjSA2J6d/QUdrSp9I1mUhIxQKFQ73CUnbNOhNOcfA5kUds6h3OxDEuPgJJznL1vtp4w0t5ZAVfDC1mU1yt1tkRIx5xKE6I6BCZiCt5Rt+5RahDcmF500orfBGRmLHNNxbWb72kIKSDRhOaEENDWS2om4xmlR8cB5scOJ8wMykhlrpUlQ1Lcg7FD3TFJvfVHpXWbIoeX/EljS5BSNLiGKXarLsPKMiY6hdWNd8skdJHCg+tS5QMEKuAiIv6Kb4K6VR7LKtmFchgb4RDxyIhz0qLuMx1zbbT4brOeZPYZCEpFR4KR0j25ICLxuf94B5pU4OBtmfJO7muWVYKRwoOC3tfusx93iwLQqUotabUDffFPRrsyuuqsLfBXGT4+JzJc9b1Oj4Op2LKQG9SiYptfZddp2szSdOMzSBgWSt+f1UQKcVpZiMOz+oFm06bnie4F3aYlw3awNSkuKnkKDHsxx5tV/BqYWgrl3E9t9aj2hKVYkcyLQ1fL2Z81OnSciWXRUnH83izKDk0V8zKNTa9iLjeZbdl4RKfX2c87IQ8DoccZxlrYcCysmeFs6zhg4EidLq0Xes9diVWRNNcMZ93UEIy8n1eLSpeNZc89q3i+/tZvtoIZbwWT/lA/4pDcYheFd+kuuTP3P+aqU6RCO6GNlLxNG2sD3VpLSf3uo5dh4tDevkdHnQ93k5yxnnNduzw2VVNJUqW+gJftHnC79gx74KAWWkoGsOu1+KstLfzUjt8O8lpuy5Z3TDTOffjNkVjkFihzVGWEUiHSDpMC8OLeU3eWN/tIaesmzU84RA7AYtK87KYUomSHTHElZKromBKwq7T4zhPKWm4lpcMWOfLid0qtJXHaV7gCqsGnzY5HR2zqTeoNHQ8e691ZIiScJXZ9e132XiFgHQJlGRW2VAPubKHndRznLyLELaB0sDRsiZtahJTclTqG8/0XCx5L9jky+KQ2aLLvbCDMXCW1cxKh5dJwnYQUjSS47TgJFGcNwsOsi7nZcaSjF2nx5mecTyv2ZdrnDcLNIZW5TIuKo7kKVvqNkGjeLUoOE0ULVfyZX7GMOky9AKeL0pSUxIJe5df830ix3rmv6ifIVFs6S2Wlc9LY3hjLrictcnIeRysMzFLNo3Pq2XOpLDPpnmpmTY5SaK4zB0caRvTWtskJpkLluS8E/ep0VzkFn8aOQ7fTC2ffZ2IaVlzrRPWVYtM55yJQ+7xAWfyhFvmwCZjNSWHS5g1BQ6Si6xho68YhYqsNnyfzFhTEdWKF/5HK8JGaDwT4ImITKSs6U2WYsw1R/TZsilBeoIW1qfZcbbpssEpz3FlRN9sWyTciizliZBI2eKy1Bd05Y4tFMZnj3c55nvWuU1NTcLETrpmytSc0BGbjOU5hV7gCGtZakRlE4NMyJl8RUCXntkgW62JxQok4lpIHLWoyc3cqp5FSk+vk8kZngmJRJ9J/RockEJS6pSe3MaYhtoUN5COQthVtof1GUskZ3qKEXp1+3aRKK6rV/TcfWYip806rrFr07G8oq/XAVhKu5pqGQvvKIyNXVTYEAsAQ8N59QOB08IzipbpUAj7QdBoMjOjEkPre2bKVF6yo/epZUWD5Upfc4QjfPraTueX8oyaAs9tEzvrnC8+R8kAV4ZkIuGRs8PXzStumz0CpTjWJ3hEbOoNpivSlzKSjljnuPwNAELYTrlj+lSUtOUITYMQDk2TgJQ3nyspPBpTY4xmIa7J6h27BnIjTrKcvudbiEIdsqYiFo21VUzrgomYE5mIrggoSHkuvmVD32Zb9jmRr9jifR73Aq5yKxoJlLK+ylARKcGVvOAD5w7zUlOZBtHA7baPMXCcVpRa80X1mhYdYgIa4zGQMa52UEjOpNUIvOUr7plPLGzGGHJTWy+kJ5mUcKWX3HF7xMLhXkdxvzPgi3HFRWbXzvc6kqczTVuEBErR8+wXey1U+EqwFirmC7sJ6HmKpLbFcegL9os289LeT3uuVT33fQddDLnTsbSgeWmzeT9PLpjJMbPZBu9EfXbCkKSygp2/Lz9lxAFPzuDIfI9c0eQW+Qk/Df41u2rItMnxsCKaxhgKkZHVmtPEcMGEM57SYweAzSCgU9/lH+UJd8xHnHpvuNYJLs4N7MMWekHbVYzCFWeggX+YnvMT/w53O4qOa3jP32RW1qwHNiD+yaThE/HnfCe+YYvH9Eybr8W3BMX7dlsTKQodIBH8/trG8w19ydu6ZsO1lqzIEThSUDTQcTySpmaiM06ThvfiAXkj6biSXX2LZaXZbSkaDXkj+NdbQ76ZNBzmCQMVWoqbO8STgo4bW6541SI1NZ+sBbxdam63JUXjcpUbXiTVSsks+JedFv90kVM0Dq6w9/yd2OfbRcKdTpeBv45YNRhrgeA4sWSmsjH8kMw58Hr8+YZkXAgOlw0HbY95qXGly+3AZ1JollXDnY5H7HQ4SjRt0+XAb1M2ht1YcpEJ/pCect8dsRdbQtV1ociahoG0UA1fOCyNVbS7coAxhsiR/D5/ymPzAaPQ4dPlGbtmi61IMilgpnM2w469+4ohD3s+t1uGfzz36BoXbSBwrA1NCQiV4F1912YeC3i1sMCObbHGT9cDXi1aRI5gJDt0PEmgAjwlkMQYA78Ytnm7bGgM/GxNcpRawdlPBjGLypDVAS3XUsVGoeIsqwkVDL2AjVDxzWxJIBw+aPeZFZqpOWdD7zP0BfeT28SuYzG8rm+1E9rhcTfg8+mCw6RF6AgWlebAb/PhQPHi7NEftwif8hyELQQZc3wRWj6xmVOJEonCFfZu+yM5qqIgwE66V+bNarUsCURnBZFIaYk9NthnaeZo4VuPmnhOKOwDXNOwrO2Ut2Fucy5eYdB0jY0YVLg3N+jGFFSyIKZPwoSFuKZtBjZIXQwpRMZl85xQ9emYdW6b91myxDUu1/IMYzQTcYLCpeVs0jObSCQLcbla2y6I6K9WrC65XKJNTSKmVvxkljSyvoGMhCZGrxqSdb23mhRSm1RkQvbMNhOWuKtkHyM0BeVNbGLbDKw3myPaYp2O7uEry+d2jcu5eIUvWrjGJTdzNBVLMWNuznBFREnKiTwiNRN2zANOxQv7oNNzJIKZWDDXZySVXUXPyyManTOIH9JVO7wn7nNcLRmxYSfBWlLIlFRPKKjpy5CFLngmvuFk8TvqZoaUoaV96ZxrcUbbDNjR+7ySP9hc4ibFmBqlIrQpkcKjHR4wS1/itkKemTPeD7ZIKo0QgrVA8qb0yEWGJCaSlibUUS7HOiEXCS2zS4A9fdz31vht/Q2PzGNeNZe4yYjrqsQVkuOk4apJaZKQVFekcsbT6pzHnp3mMlMxK12uV2kxAujoHh1CCmoOvB6TssBF8Ux+T9qMV82RZqom/Ny/zU4seTIVnNcJV7nPRZmyoSykI3bsmnlcGA7aNrpxXmpCJTnKE3rK3mcPk4LvxfdsL27TlyFfms95T3xE27XACCUEh0vNpKxxhV255Y0hqxuS2lqNTrlmq9qi1IaDluTTq5y73hrjssXA9Sm14bqoeLcfMM41f+H/jHnZMNEZ7/Jz7scx47zhMkgZizFbco8HQZt5pZmUBUpIHBzemisykfI8+Wv60T1usQfs8YfyJQUpH/JLpiRWHc0LNt13mJUtZiVshIrNSPLNJKfvB3w6nVJQ8MC31qTfX+XEyj749lou31zXjOuMR94Wn9bf2PhOtWTIT3mXd3hbzeiKiLC0qMpUl5zJM8Jmj28XKRrDla5xK4cQl5bjEjsKV0oCoxg3BR4uF1nFVuTyxWLCgdflrEx5cW0zaOcmJ6tbpE3D43ab71d3+8iRfJ1MGIgYR0hSXbEbhhwuNRd5ybfZDB8fH4ftwDY/F3nBpLBpSPOqIlYO13XOcWIbki+uUxwhyU3N3Tjm5bxmWddcFfY0FAmPizLlfz72WWrbnL5dWu9rIBUvFxUbgc3h/t30mrtBD1fCUiw5Kxz2w4i/ubpm02kTmoBvmjd4yS0GvuKontIhojGCDwc+f3eVcMvt03IlR6mlS7U9ya3sMRUNjYah6eIIyVmq+ZKv2OCAWhveZgljcU0/2+NwqTmtEhwkC1IWesJIb/Gb9JodNmmM5rqQPM2vGYo2615Ax5M8nTVclClPxBc8Mj/h7VIQKcV5meEKRVu5N8lKt9se5zl8P8sYeh5ZrbluLKf+djPAU4K3SclLjphfbHIhrjgqu3goexcuNH9X/cYmc+Hx78YnVBQ80nssK81VlZNXJT/tDrjM7U34LLP534fmkne9Lf7d6Zxj/fUftwhHok9Fvko0svfIRWMZ0jl2IgxFF2nslJMxZ2h2yUVCskItRqZDJQpm5gxNRdksmahDpLBWJkxF23Q55wWVSQnkHbq6R+PUxKYHQE1u70siR5saBNxSnzBnQsqYioKB3iSRE3pmA4nAET5aaHwT0lb2Jq2F5kqc2QxiOVx5cTvc0ne5EJfMxSUSybU4odEVjnBJmWHQOMKlwt6nS5He2KE6rHOmn2JoWOgzXOcxa3rETJwzlZc3a2ebJzznDV9Tm4IN+YBL8+omFvGhechX/MGyoY2dqivs7dvQoHA5Fc9ZVCfseh8TYwufNFaNHokO15ywrveoRIURmitxgkDa30/cRRpBYCIGco/YH3JRfEdWjjGmoqt2iEybwJHsq39Gxk1MQkNFR25yx+vQ8QTfzUsi0VsBSexNTwiHwButKGk25PtPnU/4tBXxbPLfIwDf6ZIWpwzbj7lOniCFQ1ZfM/FPSOsNkqbiILaq4mPxjFvmMbOm4E4c8zJJkLi0dY97/oC2K1mvb5HW+7RcyaPqIY6QvO9v4EpB3jh4StLxJFFpp/SUgl19jwO/TaAErlAobDDDjw89Awwal0XVsOEGzKuaKQkTecll9j1FPWMQ3eee+DlrtIhdQahACthwYn6xLpG0eLawIQVKCpIaZqUmduSKuCPxFTxut26oWIdZzS1zzyI0Yw+ZfIwSlsrT9wRHiZ2srsaGB91//goXjaTjKWptMPmAUtsJ+cms4dLMcOs+GsOttoVd/JBf8S8Dn0VlYR6jwCNuWhaasVyw7Vn+shaayypjUbu4QnIizumYLrfkFpXRnJiG9fhdJIpLM+PdcJ2wukXS1GyFPkVW35D2XOOzqCx57EFbkzWCo6VLz4MYj/daXX4+1HwxlbjS47t0Qr+Jabs+w0AxXyp+3KM4MmLPvMsL+QP7+j7vx5ZbsKw0L80xPwkO+IvufX59kdNTAUPfUtdcCXljeNhVZA0rUIjCTYZsxQ4d16IMW1ir0EO/Rcdt83Je45mIt9WMLdVhKxTMSzuFvddXnJ0G7MWWxnSRG7LGECpBqBS/ijc4SWqGgeI4LRn6Ltuuw2la40rJx8OAbyY2YEIKuBu2McBWZEEmx0nDO32Heenw7czeRC/zigs94Z1WCyU8LrMGjRXttV1BWrtc5Q3XTcZczPBVn7zR3FebhI7EkcI+E7Thl70BlRlYsElkaMwaxtj36bNxTkVNuIoXtN9LSwH7qNtlWuhVNrZV4Q98yTv5e+RU7LUkHwxavE3avFqUtF3FFjZ32ZMtxsWAM73ggdrFEYL7XYdRYHh5ZLnxD3sKbeAy1+wEEe3yF2xELpU2lNrwn262+PLaIkVDrC95FMCTmeZX65aJ3RjFdxPBovYIlaDnWw/8v2rdJVBwmUcoAV/MZ2xEDnlt+Avxy5uVv1so7rVDNkLBrIRR0GJaamIHDJJah6yFimmhuRfssuZDO2nzPBn+cYtwbHpUoqAiw8FlKs5vONINlojjKB/PBAzlgS10K0pW1kzoyHViEzGnoiNGCCQLZdN+EqYMzCbXHJHLhB7bLMwlrvFxcdGrm/MB7+OKiEIv6YpNUjGjY+w6d6aPUcL6ZY/F9/TZo2VijuRLal0gV1zqeWNj/ULRYWnGSJQNOxDOyspTo4UVemk0LgFLfcaFfkLH2cEhYmbOAJssZfNcXPuzuVxZmc5wRMBAr9trt57hKAvsqCloMbSYyXpOoDoEJiJeNQIuDmOzoCJlKaekZsKAXTAwk2NG5t7K0ZgSOD1m5gy5AptMzCHn8i1tM7gp6BJrXZqYQ5Lqkq67R2AipmLONUc/1k0APNWmaZa8mP3P7HZ+xXU1ouvYW7RPwLU8I23G1LLg+/ySpmiQQpCaKY6MbPF1+5T1gu3oE7pmSMvEPJNP+RnvUZHjuUM8p01WXmJMxaI4JvI3Voznc2bS50hZX3KQjRA5jDhAIhiLKU2imYo5k0YypMuT8oLbzTqn9ZKCgp63TqQcFk0FOLxKUlxhQxYusppIOighCLSHvyIvJbXBFZInvOShucOjdsz3iyUaGxU30RnPzJjL5jmlTsjSK6pmSTe6w3viV2SUlLrBGCtCOa0S+jLks7FgO1J8Or+kRcjdOOZFWrAT+ZxlFX3P4cuJ5QBHjkQgOE9tEP0v1iVnmRXivDanDPUAUQb8kE5pi5C2G6CE4Ghpg86zWrNoKpa1zXNOTUno2Ni6QEkeB+s2TlA47ESGs0zg43OcCowxDH2P87xEYBGDn/Q6PJ+XrDsRuh7iCYeNwEMKWKbrbAchvym/t0hYucM9/T77QYv/pfg7yOz5ShmHt8URc3HBvDhi2/+QW2KbtmtXu/9wAaNQ8LS6YHbZx5OKvVjwbKn4dDZmIi/5xL+PEgJPCcZ5w6E8ZlkOqUSGL1u42uWOfsjtKObbZEKLgDvtEL8K+D6/ZDPaoDA1RQNJWrEkp0PI0PN5PtckdcO8LnGFWuU0N7yYV3wvvudd+Q4vkiUFFRE+c1JuewOixqIlv7yu+L3+nJ/Lj/nsqmbg+mxFgi/HNY0xfF8dsV9v0nEtS9kVEiUUC13gVXK18lbMyobPxxWvxTHve7fQBpZVw6wp+DwfMzQDhk7I99OGsrGpYWdZSSAVmwz4h8Ux21ix6NIUnJXCWvlij8bAmorom5AXyZJAuBxyitaa951b+DhoDD/McqQQBFLxdLYSJpmGSNrGa0DMorKEs3FhWeZ9X934ng3hTd7w26xmJhYUIucfLwXGUgxIyGh0w1JMOagOVtxyxabT5m19zYV8w9XVO/QcO6yUWvNqYUVbkzqn1va7OEssRe+J/I728hMuypQazaO4w7io+Q9nOVthwLeTms3IoTFW29FzXc7zkqdZyoHX5ffXC6ZiQd90bBNLwWlS851+w5IxMX0eiVsE0uEoqXibGGLH4ev6Nbt6C1eGvFpmTEno+2t8V5zzQI94tWjoeQ6Fnv9xi3Aq7A+MxZClGeOKkI7cJGNOZTJC2ccjJBcpS8YIJF0z4NRcARCZFnMxIxVz+mbEUszwRYvItMlEwpWwEP3CLG2c4ao425zYHo2sSI212yChICWiSyKm7Oh9OnKLzMys3UgXONLBQbKtbzMTPbbNBtdmwRWSW+ZdWiYgkZMbeMbC2AzigoKFsfhJiWSgN6icHGlpyEyaN/iyY6d+FC62uGbMiekTm4hURCT6kit1RsYc02gKs7xRSc/MGXvmETvyrzgUh1T/m3vtWF7R0332+YBYh5xJSUPNLbNHoWt84ZDqkrnoMF3dJF3j28LcWHFYT2wgkTgotNEsxRiHgNvunzAVZxzzlLyZ4MjI5u6iaZoSRwWAxFUtumwwNnMC3WfdrBEKl0P9DWl1xV3vp4R4nIkztvQWhdggC/cYqQcYNHNzQWYmPOQhG6HHRRHZWEKpeCf+r7jiDXk5xlFtHBVSVDManVuleXnNJL7kHXGPSltaUMe0EAhuyRHGgK8d7rRDYkeQ1BGTQnM7aHOc2zSUrDZExn60A+lwpZfcC4dUWvJ8kXI7jthttXg+L4gdQakNCYZP3PsWu5k1LEj5KB6RN5oX5SVj/Zrr9BmuiqiaOfvdv2RgtunJgC3HsqYPWoK/Pcu5E7ZpjGHgKzZDw8ftNY6SkmWl2VuBEFwhKbXhXtsm6uyEhlklOEwsJvOzsb6hHylcNr2IrUjhp13WQsvT/XKRsqvabEbSBnrUilrbpB2NYVlpfqt/Q2T6/Mvw3RWsXvPNRDCvGj5sd7nKGw5aivPsn+H/HU9ynDasBY6lBKVtYldyXdS0XcW6F/ImX6Kkgy/ahCZmoKzdcJuH7KkBoSP5tjwlYWI3Uaamr9ephCatNaPQYTcSHCaGX3W2yGvDd8mMvztveC6foaTLL71HRKsV/tGy4sOhy+HFiGqFirUDQMO9uEulLSu45zkYY0liUth0oj9bb/F83tDzJN8vLN3NVwIDXNYp216Lk3JJR9qhouU4/JfhRzyZp/zFqM3zecOiaojpclYmZBQ4MmZS53TEOtd1zoYXUmiNEtD1FNdZxsfhHqPQpmLVc0OlDUoKBiqk5yk2QjvlOlKwHrjIyS4At9qStJZ40iVrWnw/y9haqcMPWi5JbRXwngQpHPJxFwTc7wRktY8ruQGzgF1dHzbX9Gjx0SDAm+5w3EwY+jbPOnQsMzpQVj08KSxf+mcDe89+k9lTSdLUKOHS8xSNgZ1YcJpZPOS9jmJ+1TAKXWrtcV14KCE4bebc8XvsxorzrMW0rJk2Lda9gL2W4jTVxK5Dz1vnu9Rh4ATc7zq8K3tcZIZx3uCuMtoDJbkftFkLJB0XtuYf011577ueZZrf7bh8dS05aEmm5Y8hKYZSazqew3oYUDQ+aW3YCSLCwmU79nmbZLwbrnOa5Txy9omcWzQaPhwqzjIIFRwlNoHpHnuMYpe+L9iLI14vQ4aB4P16g9gVdLSkaAzGNH/cIlyS2qg+YyfZgV7nVL65KZqFsdxoLTS5npHXU6Sn0E2NJ1ssxJSUGZXJaJnbKOOQiiWFsAoylwAjNJv6Npfi6CaZ6ceQe5eAhbBozEj06Zg+MzFG0zAREwv5EO4KuZiyFFMCE3ElT1g0Z/TFAA+XQHYZiwuOmDOvThi4t20B00uMaUicIS4hcy4pzJK2XKc0S0LRZ01v0RPrHPM9Pb3OuXhFJHoEpsWSMVOO0bK5ibDyTYgUilzMMDQM9QYTeYkSLhfiiNT0SM2UlClSOGzo20gjGcsLhto+bHxj4R7P5Us69BFGci3P2NIHzIS1VA1N9wZ7WTYJU/fcCqHYpE3EibHvYyKm5KvuTEmfSfqcfnSPq+U3BN6QRfYKR3VYix/jE+DhctnYifBcXFA1GcZonul/Yld9BMCSjERMidTwhnBzKKzSu60crouayLR4Ir5mZA6ITMSQD6HN6gZdIqWDNg6O9CiqK94s/4E0nrBnHtHXMa/lcz4Q77Jo7LqurTyOEkv06YmICzNjJLrMxZJpYYUkV03KRWZYUxESwZtFyaOeXUX/yJqtqCGPCaSdTq6KJV0RccwZd9UO/+/sD0R0OSo+Y5kfo3WGMTWj9sc3AIppk9P1YrLG8HJhb7FZ1mY/jHElHK2K6n5sI89sY6B4W0/oNTF54wIOdQCz0pKtYkeQ1natelmULMQ1TytBvlhbKUEFV5mhoeFFeQXLNTwpGBclO5HP/a7DoOgwKTR/5f8px3l6A0tojJ0+GyN4ukgZegGfj3N6nsudtgVdaMMqUCDjOJN0HXsnrY3FVV6UKT+Y37DGHVwRsms2WDQl503BmujxWl/SlBUn+jtuiY8Zig7/JF8xkZd09D5Z09B2XWoDZ1llGy1PcuC3UUKwZt5jUlZ0PBuMMCks+OKba1t8J/KSUqfMs0OasGKQfkLXtZnLSaWpVmmjE3HB/zo1DE2XOSl3VxMlwNvMbkh8HC7KlIOgxat8wVBaVOWzeclEzHk+t6B+gM3QxS8kHc/6fYdOyJA9cm2BLYku+e/Pr4kJ0RhOc5shvGgqlsayr89noFD0aZPUkNaWmvXZtc311VXMrLQWo0lZM28KzuUF5WzEO50WX0+sGFIAdzsBz+c5m17EWZlSNPbWv6xswX9SXjCizxnX+Fj/+JfXOS3H4ZNwRN4YLsucptT85ajNv724ZCjadFyXjcjhh6l936/FDNEI7sQxn0+WzEm45Qz5v129oq+HvBN3LTxGwN9nT9Bo7pk7FMbQFRFJ3fBspm8Elz0CfqjOyWdWdDavDFlTM5PX3FE9fjte0nN85nXJyLd2rC0/4qzIOK5qKt1h7gpeZgueZxaPulYGPOo5XGTwupjRL/pcZg2+crjIbcYxwJN5xsJkvBv3V4EwikobbrdCpqX94LxprvBrn0t5RnF5n3f7Lt9OKgJlV/djnaKzkMNU8/EgxFfwemFxqK+yJUuRcKDW/vjqaIkiNkPm4tJ6gRE3NoG2GdKIipKMnl7nDh/z0vkMTcMD8QsKCq44XuHoNunKgNh4PBOXtEwPZdSNyEijqU1BIipaDFeLDE3XjKhpGJoeE+akYklJSmVSIjr4JmSJTQ/a410uOaQRNqpMCMlL8Q0tMaRvtnCNR0AL322RmgldsUlbvs9EnNDVAy5kSkCLNgMm5tRO6CxZirkVbYkRl+IQlxDX+HRMm5BHnMgXBKbFRJwwUg+oKKmpWJN3yFmijV79vabPFgtxTWMqNrhLQcalPKRnNolMh7mY0TIdalFzyA9E9PGNT71aab8W34KBhT6jUvfQpsFTscWFIkmaM15Je+eumpQKmNZvqJucwOuT5Gd4bpur5DsAispCUYbxI/bNO3QIqbGexjUZ4mqHwyYj8tZ4KP6EkYy5aBKupI1RPNAPaQufSDm06g6lzPh98y0jvcu+WqPTtFh3QxZ1zSjwCPJPWLjvcSRfcpp+TqNz6nqKocFz23jCJlkdMqdtBigpeNyJOU1rhr5DqQ15ZkUtQ7nOk3zMO8EGs7Kh0A0fdDqswEO0my55bTDAx4OY80wzMC6HeUKpG2uZiVp8l054IV4w16e8zn9DXk6o6gmsqGRShvhOn4Hco6Jg22yy7gX0fMmOA+eZYV+uMQpclISeZ72XNuEI7q/ut8dpw23Pko2usoZ5qbnIFZ9PF/SdgL7vMi01HU+ijUdZHPCzQRuA5/MKVwoOs5Q7fg8lBI0xJHXDwhR4ymcUGL6f1oxCh9gRxG7MpLD/DZXWvFnCvGzYDUN6viRf2FV6reGqsn7mSWljGvu+4jgrGLgejnTwleB/yf/WChWZcUc/5LU8Zt2scynPyEyPlokZyyukcDgW3+OY92m723yo7tEJLTQkXE1dj3se09KgBBxnBQ86IXltGIUBbZfVXVLxsKt4Mmu4FbQJc5fj6nO2oo9I9JgZOUlpgxVem2OcykGg2NIHdERATkUhCt6UMwSSc3nEfXGPdBXi4aLwpGAmJnRMwO2Wz7xSPPK3eDLP2Ap8vtdX7IgtfraueJsIxrlmt+Xwcl6y5v8IwPA4SV2GvsVxutL6qX87zthwYpZ1dSMGu8prkloxryr7fZAKqWP7eiTUxgIpXBQPxT6Phi7L2iY/WSKVZOjD25XTYNOLVp5nW2zGZUGLmI7n0hcbbIZWVf/58grZdMhTzXbs8rgbMy81h4nhZ521G+70ZdZQaI0jFbfkCF9a//JP+i3+/fSSYTDiL8UdNkILqjhNNfc6Hv38AUVjcKTgD+UrfhncRgkbTfqo1eYyr5k2OX/W3SapNK9SGzrxqBuxXd5lVjZ81GtxmjZ4wk7AkSM4TivW3IDLKiOpG3q+y7vtDheZfR4AfDYuuNP2+XlvwFYISSUZBQZ6Pl9ep4wLGLgeD8KQ2IEvr61l7CK3eoieJ2m0x7R22HTarOkWO7HNDd+KHK5zmxFdVRU7UZeOJ+h6VnAphaDlQD4NeRS2iR3BfvPTP24R3ta36YiAb7mkIudCnpIV1zhewFxcMquO2HZtIEEqlghj17cCyURc2FWvWVKKFMcoIhMxM8dIKUFAqVOkcGzer5Un4BiHU/0DobIToBElP4jP2TfvIBHMuUAbjZaa0ERIXHKR4BOgTU0mUkI6pExY44CKgpm4JKZPS3eQ9DBCM9Rrqxi8PTqEpKbHTFxy1zwiosWVPEXToIydJgWSLX2bt+I7AtFizoJUzPFp4aDomHVSMWe5in+0TYylHm3oAxs6b1qcmaco4fK2+ewGPJKL5UpV3uJCHNE2Q/psE+iIuZhxrp+i64pIrVmrlIro6yG+CLkSb+k6Oxyln+I6EUU9x/F95vkhYKff2B8xzw6R0qGqE5TwcJwQbSr223+KRFGYAk+0QMNMLPi6+hsG7m1Cd8CavMPCzHipv2AoDohMh4W4JsQlUg65brjl9qnqitAEKBTP9BEj1rmqciuAEnBhZpyK50T0+Vnw3/Gd9/dUOiMpzimqGXN1TFsNVut+S+DJFy4LU9BxbbjCkpyitHagmIC3+RIXRUrBF/OcXa9tU3q0oOPZB2dWG6ZVxcykBCsm8K6+x0Xa8EPz9yTpGVU9x5gCIdz/zTdAMogf4asuNRVdPSRWLtOqQuXwvKzpe67t6Ev7YKy1wpN2BayBUajoeaw+3fB0nlGZBoNhXDoMnXC1RrZTzEbZZ+h7XIsZpW7T91jZp6xAzVc2Nu5tNSPC537UZlkZpqXkeXOCW+ziSYUx9sHuK0Fk7KqxNnbSmpQ2HOJtuYAS7gQd/i59zsCsUzQOVe5ijOGkTJiLJQtxjSMjDnifGWNi6dHTNp3nZ+5DjIGjcmntiNUVoTMgk5Zb/tfF/8S/NP87Ylfyw7RGCYHG4h7XAoetwMeTcFFpQNIYwd8tX/NA7VJpRVLXtEOPGk3oDFg0Z5Y/oBWhcHGEfWZ0TY8LeUpsInJTMfIi5tWSA69LYwz74jGzqmIsxnRMF4VVmGuhabTm28WC1/IpUdmlbXo8K55Si4KrfMRvl5cMTZeO4zH9UaXs2Jv1385OeOxtsKws0zuQDnNXcjuKeZUmaAxOI3naHLHH/4e1/+qObEnPNMHHbOvt2h3u0EAg5ImjT2omk6JYXeSarumpi1nda/7E/LEe2b2qu6arimxmkUlmMtXRJ3QEENCAa996m9lcmGdU/4DMtc5lAgHA3W3b973v82wzLlMCXC5zq9cTwHGWMM59zvKUw6hB4PhcpBWTwhA4grw2nNYz3NqhnrZ52PF5Mbe72CfVFfecEXfbLmeZYdOLuSwTPmi1eLEoGeuUlVzwOBhQrc1gcSAIHcF1VnOib/lpe5usNlyWKQJBy4sYhh5PkwXVKibXipEZcp3ZrMFlphnXGX0n4iRL13tel3lppxaryh5c5/UClbV4Yl7Rose0aPA2T9jxG4zLgjdLw1tzy8B0eLk0nOhbCpHxqD7gxaLibivg24V9fyeq5mRlONVjftzc4nfLybsH0vOkJlE1uQqYl4o3K5fjVcFOFHJbVLhS8Ov5GAeHgYy51ks8XBqVy6+LY2LdxMVdu7ZtSOuLscaR9qZfatsvf73KcIRkO7J790WpGEUutyplsrIPQgt588c9hG/lJUsTYYymKQZII9kIHrJUl7ScIS13i5IMI7VV8ekCVwSciCeUOqUv9wmF3b3WKBZiyYH5mBQLTAhlmxDLW07qazruPi3TYbmWN/xh9Ns3e9TUXPDCsqedLWLd5Nh8vu4du1SUKGw3Vq51icH6xnqmviB3FlRrAIhPxEok72pKwkhSsUSbGoNhIe2hGxAQmYilGAOKuZzgEXGrX3Gf79M0TSoqKlEREKKo8eTaCWwuiUSHiTlFSEnbDBnLK0I6NBkQOFYknooFA21DaxfymA29g4fHqXxBJQpKMh6IH3LhHNM1m1yb1zjC45X4nEpntJwtbqpn5NUN2nSpVUrL38GRAZ1wn4bYYFq/4b3G36DRXOonrIoLYn+DD8Sf8mGzxfGqZK/p8/lyQl80cIxL3zsipMmIPRztsO022VObXK/xfB+Ihxhpmc+bnsOqMsRVzK7X5KSaMzJDXCSv5CsyM6dV/pgWMUO+jy8kOPB9/oqm73HuLogJeCNfMtI2bNJ1A+53XL6dltwJWgxCu+u5zTrvXp/bDZdv5iti6XEvjpkWitARJJW9UUwrxf22z21eEjkOG26XL4tzVvUlX6qXCCFJixsc6eO7XcrKZhn+ABcJ/QF9965lnpPywH9Eqqw9Za9hg0bzsuagETErFD8eOVRacJHxLjg1LRRZLSmMYj/0KLSLxCN0BYdNh68mJT8Z+fjScJb2yE1N6AQMTJeGC6eJsf5S3960v5xm9D2f9yKL+Pz1fEyAR6UbbJkhpdIsSgst6AY2Zaq0Tc++WRU86vi8WtSWIyxts+C6PGeot9j1muuHJknLd0lql7e85ir/ms3wQwLt09NDSuz++ShuMIok/+vkmEwmuHjsBz+goqCr21yS8mPnv1mLIAz32i7D0HCRCZaVZDcWTAs7PfCkw6/GFgKxxYhVXQEeLdflJLFaPa0reu4dPpXvMdYZ/cDjo57Dg/wQZeCXM3sItJ2A76pT9tjksOXwbG7Da03X5a7aZb/lkVR2BdDTA4QQPIxbeMljvjD/iCff475+wBf8khM9ZyIvKcjR9YhEOXzN53RWm3waHHBHDnlRTDhwe+9eBxdpzaOux0Gzxd9ez9mKfJZpnwU5P+l1ebEoUcbOu/ebkn7Q4sk8ZzuIudeWfD1VfDLweb1U7MQO/cDl/Nph3++wqCqmhcODjsfX05yH3uZaZqD5s1GDt4kBYtLacNjy+WHoc5p0eLJa8tNBG4N1Wnd8QaEcRnmPQQDtJkjR5Dqr0Qb6geCOalFrQ6EVu2FM6Ag+6MJJ4uClkt3Y4etZxd/s+MwrwXkqaZZ3OGja26wnbXLdKe5x0LZp+KbX4jZT3G1FKA0fRTvroCTkix73Gtt0fEHH9+zvodtiVmhqY4gcyYG7zf2W4bulDTbGruRNYh8EstrYB7tIcJu7NDyBMjYLIBFcy3M+ajzmdml39KXW3Gefjdh996B+om9p601OyxUZOTuyx09GPuOrmAuu+VnzwK53AkHbl2xHUKgWLV9ykdR8U43/uIewomYlZuRqTuDYUa1LQMMZMtLbvBJjZuotkezRcw5J5JhD85iVWLKSM1q6i4uDkhXSWITaRF6SmwWx6OER0tEDmkSsnDGZmTKRMRFtClbEYoBnAiac0pFb9M0eF+YbcjNnKSOi9Y6uaTpc8oqGsCCQhCmFWTKXY2LTZt/9jEJkdPSAG/kWjSYwAbfyAo+AUuTvDvBzeUZqZvbrigHX8hSw1Szp7NKgR0cMOeY7OmLLqhP1Jk1CLnjBBgdkIll3nnM6bFKsd6gN07XaQt20yMe1ltCRtjNcGeth1cYiPksyBnqHN+IbWgyZixsiOszVGUJIinqBMYrZ6lsa0SFFNSf0B7giYCf6DI+Aj5wjXpqBlZqjuREBnfAOsezRFxHPF/bp7jqruZanePoOczmmpmBuVhhpx+lufY+G8AkIuOAFSlswyXnmMco7tDyPXGRcVFZD13Z9lqrirr5rLUeqJhL2VrvjNHGEvY1dlgkODl03oF9bjnZT+ozrDDULWemS23zFqmqRK5fP9RMapsuhGPHlfMHAtW+mWWlDTa/ThEh4vBRvuGvu8L8snrAwlwzVEY7y+HLxP+K7bZQuCf0etVqhjY8xGoT77jD2gj474We0TY8NuqxMgSPhqlwylldcTHr8oLFFruzId1GX/M/nFXfCFm3fViJ2GxZI8GqhuOCabr7Hqq6o0Ww5EdeZoTCKX99UzFXBC/ktj/kIg927/35sofNJpbnNa/58y2MrDAgdewv71fyGn651ecpAQolvHGojSVVNlWu2Io9vqwvuqBGBdHizrNlrupysKt6TB+w2PC6Sml7ksKg0KzI87XCiZ7w1X1PpjI3wEX29ZfP5wibSc5HwJBVkdYeZuHpHDpvUORWKG3nDePmEL5oBj6pPeNxuELt2X14ZmBea16uSWLrc5A6/LV9zKHY5agacpRWZqqnXvuEFGaf6KzZc2xIY1xkLsWJRrLi57FojVFWSiYzvRzs8TRe06FCjeTavOKknRIRIZdWP80WTh40W89LQwF+PJysajseO/oAP/G1WleK+/p5dW+iHvJVvCYVLoks+kZ/hCMGzfMJEXlHJnKgO6AYtTus5Dg5vxwUTeYkjPT5yHvOo0ebn2XdcZzaVWxkb+BHAm1XFMPQ5yRIGecuO6RMLm/ntraLtOzyMusSu4EU1ZaQ3ebGoedy1fW8rVIHfje3hLhH21qsMSSU4TW2y+HilWFV2AvFiUeJJSct1+XJS8bDj4TuwGdtbpDJYQQd9BoHHWW4Z+Ukd8NvqOZ+6D3i2KBiLOV9MI87SnO3IZ1yW1AuPYeTw99l3fCIf0nAd/sPiCe+Ju3hC8lrdMFm2mIoFj+tNklqx1/AY+L71/C4147Igo+IstxOmP6TV7zRini3gMGpQKMNBU5KrEF9avsCbZc3Tua0tvVjmDHyfb5MZ1/Kc77uPmeSKAI/X+oJCZGg0e+k+20FMYWpqofguG1OJirE4BQ2/ux0wNymZTDhJLEyklfkcNn3GBfwuf8snZp+2L/FU9Mc9hEPToG06KKciM3MOzB0GpsNT8RWpSCn0goYzZMPscmFeIJCsxPJdVxQsf7qioBBWHLavj7iWV6zMmEA0uZLHSH3EXfMhqUipjHVG1iYHgdUUGvCMT8t0GDtNdnjElGuUqYhEh6m45r7+iEtxTlt36dJjJZb0tD2kz9e1HyUrGvRYmhvGElIzpSWGLMWEVE+5x6eciVdsm3u81L8icJu0zIBcrOg4u4SmwULckKhr2u4ubd2lEAU1NTfCJkJ9HTIwfc6lRVMesM3ZOi0emGB9+13RNh2mXHBg3uM1X9ERW2ijSMWCjhlQmpSmGODi0mePubli0xxxI62e8Sb5hijYYJmf4zhNmv42rhPRdDdp0Fvv5g8JHMl9MSJX9oWeLD6iTUzfCWj7DmFlMX6LSrGl99fp8l1CcYexWbIru1yoBQUVMxYoUeEIj57ucyHfIoSkry2P+FacUZHxPfEjElWjjGbohwwIuClzWo6PayJOyyU9GVEZjYPkTtTkJi8ZiQ77jQDfEbxYaAqtaEqfXT+mUJbytKG30Vi/qcYSfLZ9l7erirfliodRl7TWNOsOx+KM6/oZeTkl9SYk+SVC/FfN4Sp9DUKidWk719Kn1ilhsMVm/DEjvcNAxjzlFXc4RCAI8LhrjpBYsULbd7jMSo7lCd9zH/BxX7CsBP/5ZsKe1+awZd9uB2KLticxxiZIpYBBKLjIJJuxS6OSBMXHvN8NbchGVMSOy9s8oSF8+oHHiyUklcaX1j50P+gzLTTLqmIr8rkr2zzsSJIaJkXFrUrJkwAXh2Hocb8t+P9ejKlXbVwh2Gu43OR6je2UXJYJHh5TsyKVK24WXwGauG0fXn/ifsZ1GbIXNhgXJUsKklrx33d+xN/PLvit/oqG6PJA7hGoLU58qw+922isyVeGrdDwi2vYjB32ZMTPJze0VYwnAjZDn7stqLTHvLRmp08HHnrc4uU6HD2pXjNy9tikh8Lw4w37oXeehnwv3OPloubTdoffL6aMwoDIkTTcIc/zKRuBx/vRDqW2Ybi3q4pRGOAKm5qeFjU/ineRAjwpuM00/3rU57uZ4sP4PZLK4EmftLaozDuyx67u8q15iYNknNfEBBZkIRR9vYWLy4tlRkbFZ95DTvOEoRfZnX6luc0lrhA8zaY8ino4AjZCh+eLnEHgoTT0A4dXy4Ke8fg3/W0EMCnEu+xBrW3Ya6EKjuIGUtgUdegIbnLNp/2Yp/OSWWlBLYvSvNthvyxv+Vl3k8b6VPhuVnHJhG13i2HZ5agVkCvDThgRORLfgT+RD+3FpDJ0TIuNULARhpysFD/aiFhW9vf7oXhAqmoGYcBfuo9wBDxbpmwKi5H8QbzNRmhv5LkybIQOw9DmBjp5xFYUc52Z9U1ZMykq3u9CwzH8biJ40IbPJ4rQkfjS1g4BHnctBvaX5UvK4pAz+YqOGeJJ2AhdNlSTptfiOtM8zxaEwmMjdFAmwqscPulHXKSacdFnEPosqpr7YZe7pstW5DAp7CQrcMAVMDB9PAm7DclO9uiPewhrobkRl8R0qEXFnCUn+kt80eRYf07DGZLrBZns0WWHgd6goORWnq9vu21uxTmFWSHXC/fn4gs8IkYckmKDVrfygoW+IMAGUR7oD5lxTmia7/4tc3FDITIabLBgSs+M0Ay5NM8YcMiNvGFhLmmKDhXlOl3tU6Nsb1bEBNgUZCja1vZjcmt6Eh5dsUltlK0uyRkb8j4t3UMJRUcPKERBw8QsxZimu0XDdDkWX6FMxUjcJxcJuZ7zlm/Y5wMLBBEDnokXdMyAghyXmDP5ir7ZYSyvLU9avOZAv09BwXzds57LMdpYn/BU3nBbv7BOYDElUTd2VO51SPJLPKdhDxAhGXj3GOk9alMTETJqWK/pcTmjJxpcpYqVXDAwLa6qlDdVQSUq2mWTa3lFgzYODptug43IoV14SCDTGYdixKXW5EKxp++jUBzoO1QorsSEWRmQsyCrx7zyT7nRLxg696Hc4pV8QSibbKlN7sQxZ1mGNiHDwOer4oJOGdDxPH5Zf0m+esCdOOaSCT3TpjA1TtVgqUr2hEtHxGyFAR1f8nae8zYXVLpB5DpkVc7Piy/omk3e6i8Yr77Dc5pEwQZaV+y3/oTjxc9xZECt8/VhrBBopNMm9Hrk5ZhedJeWGdi9s+twr7rDE/GUXfkRH7ZbZLVhWijO1Iz74ZBFqfjL+BHXWc2vbwy+Izj0O5YLnAiOS0t1epkkDP2IeVUxCHzOEs21XlAuG7ySr2jQxZuPaPsOf9beYRDA/+NmzImYsZ0fsq873O+4fDnJmZcuT+ozdtnElxIpBFIYfnNrg0dbkU9fe1ZsTp+k0nwxhr6wNZueaxOovyyfsKP3SDOHqZhyywldscPb4jf2veIN2TfvMRZXPKkucIXDt2v+9rbs40rBi0VJjaJrNlmKCS/1OR26hG4XVwT8Pr1kUmzwV9su38wlv8lf8xfeHVqeIBcpf9Uf8vXU5Vk24zwL0RgGfsjnc8vjbXsuno4tFU5agYbBBpquMsNJUrAZ+vx2nPGd+JJHi49YiDnQ4SqrKIwiwmdRKSZFzVtzyxZ9Go5L6EheJZbmFDkuZ2nBzKQMnSYbssmbpeZlecvLEhpEDNyI03rGqXjCD+WPuVErHsgj5uRrSExJIQoe+5vW9FUv+Er8Cx/zYwB84ZIqxaWeMZGXvFpZuEMlC77OS0Z5j7044G4r4PWyIDc1x2Vpx/ROn1LB62VFrhWPOiHHy4qOb2UOIhecZQUf9yKezkqEAE9IbtcaxjMzJ5g7zFTOR50Wv5lP+Kwx4jZXjHObtPekJDYxRy3J61TxZmU77kmluClKVqZgIGPOzJhDZ4MLNeF/myzYFxtc6jlvb3wUinjdFjmWx8j0Hm3P5aBpJ16JqonWCebr3JqLKmq2nTaTQpKvFYsvljXf6zeYl/aBpeN5vFxCUtlx+euVwRWCSVFbbSeGymhOEodvlgs+cB7yTB7TMUMKkdH2JBepeheMe5ulbLtNJnXOL+c3eHhcyVPC+UMSZfkRTeUyURnKhKS6whH2DFlVGmPsBcYXdpz9X24WPK//8Y97CAcmwiN4B82QSDrOLi3TR0vNghti2Xu32E6FxcR1zBAjNCUZATE9RrR1k1P5FoN1AwcmeBfeapk+U/0GnBahaLMwCY7wLGyDilC0aZouTdMiESmJmNE29uspXZHLhIbp0hW7xDqmwmcpJvaPIgpC02TH7Nqqh1ihREVLD+isVYFN00cIwTP5hJbpk4mEhb5kJextPWfBBgeUVOR6QUuOaJsOMR+wlDMUNamZ0pAb6w92TUds4ZnAGpSMJBAhm04Loe5zJU/Z0NtUoiQTKau1xMIYhUHjENAT+0zNBaVOiZ0Nyyte/RNxMCJ2B+TMqNUK323xYfRv6Zk2K5Pj4fKnvQEXqeIisynOPdfC/tu+ZDLfZE7KnaADNPiuvOJe3GSaTdmSXQA2IofTxIoHNkKHZDHClYI92SVRTYahT6nsLbQ2Bke0uMwLLkWTI/cTRrSYy0uGesgMq5gsWNGkzS/yUzKxIGXF6xJqUZGoPnOlKUVKSkGlY5qmQdcNaHsxp5m9Sfx6NueDVpuksujHLk00lsX8apkxlqfMq1Ou6q8B6Dbus8hO3vmqb4tnRP4Qz2mQ5m+RTowxNb7bpVIr8nJMHGwy4JCh2cDDgugDx4f8Eb1AErtQeYJpofg3G0OyGnqBy01ek6iKvXW9wnEEYJGUHRFz1AxQJljXkXw8KdhvCEbRkOtMs8p3cLCAkVlp93Kx6/C+u8+rKubjVo8Pu7CoYBj6tH1JsdpmFHpshIKb3DAra7q+S+QKm8CuSy7FDR/6e3zcd7jOoFlJktqj4UoaHnT0gFB4jM2CMadUOuVp+h/wnJhmuMsweI9t0WabNlpYkL3BcL/RxJFwnlRMdcYjb8sq4XTME/2PnAFpOeZ++COahHw28EhqWFWGkRlijL1F/Dg+oNLwfjfgVxOrVnzUdfm7mxkBLqmuiYzF3i7UOQPniM+iLQL7TE/XF+w3Qi4yQ5UpPuJTOr7Hljzgu+KaR/6I82LKh9HQhpyUYZzF7DVst/YkKdkKImJXsqw0H/Z8lLG3RY29EX/IkLZvvbihKxjoDRrJp1yoOREWkOFKK1i4mDmEJuKyyFiQcM/f4K74M8ZlSaE1LcfjW33ModhlV/T4lhcM9CaRiVjIGZ+bp0TFnzKtcxwkPxs2eT5XVNrQ9gSvlxaV2PU8poWm7Tuc5gk/jFtWqRoFFMoynO9ETRquWD+UucyWDe53PL6baVoeDJ0mubKZA0+AtzYlPQq7XOe2dz0MfUJXkOqaruez74V0fMFOvcXxqrD6UcdiZY/8PlmteNCxwaWvZwkjvUPDd+17dFEzihxyJdkILTXuH2+WeDj8qGezHueJ4nHP5Rc3OTuhpXSNcztCH0WCrIYgWIegSkNWaz7uezRdw0kiaLhwm9uE+Ym+5Yh9SqM4iu1O+27L4SIVHLUkd1tNjleaR90mlW6yqgxCdNbVJp+v5ktuqoxPOx2+nC/4uNPmXtPwm7HmQdvhIrO9/PutkLYn2FZt3i4e/nEP4bE4ZWj2qXXKqfOEPfPe2kxkn3L+AOVYmksO5ac0TYNirR+sTYEWVjifihWOcYlMg4laoWTFVDbJzBRfNIlNjO80WdTnZHIKDoS0iXSIIKZpWlzI4zWpyiE0DbJ1EMsTMV09JJUrZuaMFl3mckxhVlyTsqsfkooVp/ItNYX9QMaz2jvT5FJ8x0PzMWMmDPWe3U+bmFKmDPU+L9WvCJ02Hj5dmrwFFvqChuhSioyO7tvxqHDf4Tsd44IAz3i23Id9QV+p5dr6pKhEyUJMKVgxZB/PBEzNW1r0LXebEwo1J3A6XCaf0wxt2MpWklIqleA4MQ/Cf2W/p5BsiCba2JqEMlYisC37PFeXbKkBW3HEh50mWW04TuwueF9sMC5qPgn236kKk8rwilPivEmUhyzEkjtmRNd3GdcZr/OCpggIHPs6GBcVXc/ng+pjQseh4zvERQ/POIxEB9e8T5OQtutzpa3qq6P73MoL9vUh5+KKhbhhy9wlwGNe1rwR39HT36M2hufyu3du6qdLSSQ88nWI7pn4kmr5IXMxY1K8JC+n+G4LbSqM0UjhIoQkdgZoKnzRZF6d4rhtlErB1BTlNZ7X57D5MzpmYFncrGgbKyK3OkCH0IFlBaEDH/W9dZHfho4u6yWHvn0DX2WVHbULQa7sa+LZMuWnwwbfThWzuqDrBmjjkCnNTuzgyS6VBmUMTc/jOi95O15RUTMQbfLaMC0lT+eKtie5zRQn+pYR26xquM4qLvWcSebzWcc+dE1qTc/0mJUVhXJwpPW6Noh4z2vxtzcTfDw6rseysuKRrJ4ghUvo9dnxPmJTj6ik5lue8JF4TE5JgMdJavdtGkNGzkUFGTnH5nMcGXCz/IpGuM2FfM375kNmJTRc2IwEnycJXyxrjqoWDddCGDIFCRn9sMU/3yQ0RcBWGOAIeJ4uua6+JXL73DV3uMxKKqPpuB7fLjJ2wxhXCBwkE5NQliEpBYXIuS0KHodDrvISRwi6vsuHzQ7jXHG/4zJdZvREm5fJiqEX8evblK7nEziSRVXTcB0cYRV2q0rzXtflNzc1vnARJsJF8sVyTluEXDOlR5vtMOIqzxmJDpXWjBoer4qUluiwqEv2xQ57ccDvk2uM1CzkjJwVHTPkR/KnXNUJUznmfXnIb25zTrjgfXef/3nxNe/xgLnOeV5f41cR+2JIRsmvJ0sySrI6sAYnaadF3pr3aQy0HJuqrozm9VLxuOtznWm+mye0HJ9E2cT1ZhRzsiq5kTfM8gWfskPXs8zqb6pbdtOtd2dEx/WIXMmiNLwuJ8zlmCh5wHWZ4iB5ELW5yAsuy4p7cdOumpYZpQ5Ia72eLMxJ6gZfLee4SJyl5cWPi4qbouROI+Qyq5gWVpaijOFOy6cXSE7yFb8fh+vEukQKh7YvSJOClZhxrR3uegNO0wJHCNqey2WRoUzMtKz4iq/oZzv8rL3DWVpRaZvxUBgScq7kMXr+EA/b455Xkl7gcJ4aXq5SpmJBx7T42bDJ03nFUl3+cQ/hntkhEylCOJaaJRbEa4tPbGK+L/6M35l/outsI7TktXzCjr7HVFzTYkhTt3FxwEAiUgBiZ4NQtOnpAaFo4GiHioqG2MDzYnJtWc2ZmVKIEYEJuJbn1lBkHJSwHOWptLSrQDRJxYqu7lHKjIqKDb2FkjV9vcmW7PCUMcma+FWaObUu2HDuoqjoscNMLJmJK7psshILSjIqk6GE4o7zA655za04YyquabNFYCKi9X9jecWhPkQbTURob0/S5ztuuJZjItrkAjQaSY/YxOyvhfKpmdJe/4x/AI+MxSmFXrHI31LrjH4cE3gdKpVgUKyKSyqVoE3NoPGIXTbIjN0fRq7kH6vfclT9kMgRbDttPAnve9u0fcmLeU3Ds6xku1d0OS6WHPgtuoGlOS2qikBKtvQmG17IMHL4p2VC7Di2fyp87rVDkuq/0nl2Yx9tYFran7JQhqP1qLrpBvSdLpOiYity+fPqezzNx4xki03RYklJaGIq0SYwAV0n5EateMzHNliTz3Gkh2cCYtOkJQN2Gh7fLUsKKgLR5In+JbUuCJwWOVOy8grf7bLMT3FlSOT0KPWKUHaYlq9ZpK9xnBhjKgSCRnTIXvh9mqbD42DE50VO2zR52GwiBGxFgtNUcZZYOtesNMTrW1WubH/zbthhI7S7rbttn5NVxSBw6QaC68zCAXIFH/VdxoVF4p2mBTdmzrjo8LgT8qvZjKPQJsGnpeTCvOUn/mP6gYMU0PUM27FNZf/hfw1PcJUqhIAmEdfiBmXaSAGx9JjrnPtte1Ps+oI77sCG25L7lFQcuH1qY2iJiHptyNpufg+XgBVj9sUOldFI4ZCpmk3HroyuVcIAn1zXjESHN+KMpbmhUhktd4vIt2hZj5AfbIQ0XJvK7fmGD6Ih2tj6VMcXhI4NFQ1Fh9OkxBc2DT4IJJNCcybf0Pb3eGA+AWCv4fNimeI7gj2nQTeQCOBPmg3eriICR1DpiFnZ4nsDj9g1/N2FTcg+6jj8+qbksOUzCg17fotVpfher8V/mh1zz9lhM7YfkS3PqjC7PhyvDLO64G3icFUnvNdo4zvWmfv7bMaVOOWBuY+zTsV/2I2JXEtcmhWaDdlkUZe4QvKwExI5sJP16GpLkmqsvcOXRcb3O13SuoMvIXJd9qs7PFuteF8+pBe4/D7/DQFN9s0usetwywWbeg+97ra/ypYsxJLbecQPOwMcAbNC87Djc7ysuRNZp6/APqw/bMUsK8NM5Xg43OaGQEo2qxFDL+JNtrLADSekVD0LuzD63Uh3x4nYb3rsMeQs6bKoKgoqHBwWleJxJ+I2t53cWanp+QGhY3/eBx0XPW8zyRU/7Hb5epYQOZJcOihjCB3JRVoRuQ7L9Rg5UwYpoL1uE4aOg1mnp1eVsRcRXIZ6i49bPZSG97ouvxsXDEKHWoesKsVh06ddfIZcX5QmKmPoxjRch0VVcyB6yFpyEDZZVDW5MpTacqpzJRhFDdK6wdezjKvMkCmFL//rCvWPcghHJsIzHm1nh5rCMpBNmyt5TMWAnJAt8ZBIR5yIbynqOXO3x0jvsZAzIgK7a9RtdtmgNIpCZoz0tgV/UKFExUrM3h36uWyjqGmIDWqjQBRkZv6ue/sHoYHEQWHBHJGJ7eiZnK5pUaNpmT5vxTdE+nuUMsMVAR0z5Mos3v2iHDxysUIayY6+x7H4ipG5Ty5WFiJirHsXAdrUhML+/yacouUOd9ljyg2X4ppEzIiwycez6gtc4ePKmLaw/WFFRWh2AHgtn7Clj2jLET09IBM5A9MhFB1qU9CX+9R+SlZNCWQT6UsWxRnGaEq1RAiJ58QEosU34mt2zV1e6TmDostQ7K97o9a240jBvKpIlX2KTPOazFRklDh1Cx97Q/rtfEKAx5IUr+5hMFxVKcOoxZEz5KbMuSoNKzKyecVe2OC2KIgcF18KXmf21hYaKwPwpUOmKzZCh8+XU1oiIqkN87LmjtdjI3R4tkzJKdl1esyUrY39vPwv7HgfIfSAt+IZ8/qUttihafb4svhf8YL/jtXSZdOLKbRmbDweiB/iCIeX4kua4Q6z5BmVWtEItkmKC+bFCUU1x5H+uwCWUiuE8HCdJgfhj+yefS0auCd32Y49ni5XbAcxWS3WgAwolOG3q2v+qr9JVms6vsN7XclvbmouUoUjoNVwuKlTZrXDXRoklSZVNcfFkk23wVWd8GeDLv/b5IaYmMix0I6Kitf5kkq3uFJLPnYf0fElLxb2cIyckJtM0w8kSa14z7OCgKsqZSYWHMoRMTvEruDVsuCgEbAnfJ4uMoaBz2li1X2fuu+Rqpo2DcZ1xkwseF39M3k5ZbPxMVv6aH2AeryUL3FweY8HTEjoOQEvqmt25YBFVfON+DU/kj8lNytqcmqdcZV8SSc6tLhTc4/L1IL3bSJekFS2Z/p+u8nvJgmX4prYNHkUDugGtupxViQY0+CmzOmJESf6klB6NByX3y1vyUXKFnvMy5pVJWh6Dm9Xisi1qM33ez5JbXg617Q8wVRn7Pktvp4qbvWKYhGhdMiiqlBGc5pI9thkrgqSuQ1sgU0u9wOPUhlC6fL7xZR9v7P+8BcsSoNnPPbNIQtypmLMX0Z3+eVswr7fYTd2eLYorI6xfsldc8R384z9OKQXuNxmK07Lmk4dcmEmdLCVwZ7v8ibJ2F6PZBdixcws0cWAT/g+S10ANj2+rfeJ8PhafMVlbb3i8+otgdPmZBHTEkOm+i37+Yfcc4f8fnXLo3DAN1PbI1Yo7gZdtoPYfr3YSgs8HE6rBVM5pqsPAbgftW2grF7hFRIX20HPa2MNZsanTcSW2+KqTohdS2y7KUo+Ly7ZMiMGfkihDG3P4XhlFZkHTY+r1Fbfkto+THw68HgyU4x1SrMK+KQXUWpIk5rTVU3Tk7RkQNeXJLXmV+kJvgmphD1XPAJ+vbpkRI9niX1oP9A+L+sbQhPRKFvr0JdiO3aoqJnWOZd1xZbbYqkqInxL/zJvcSuX69s+Iz8mV4pASg5bLp6QXGYVh82Ab5Pgj3sId4TF/80Z09ND2sScy0tyvaAvdnCMS5MGCRlDjijdjL4eciVP2dR7zMSC0DSYyRsSFozMJht6i0t5hou3xlguaJkBU3HOVJwTrHvDS33NkmtC2QYD+/ohK7GiXCMve3rAqXwB2NRxue4Hn8q3BCZizhU9sc8Yi73cNEcYoWlJ28n1jM9C3OATMeaUQg7wiPG0R0wbj4BcJAxNjw0OkUh6us2lvFqbjgKeiOcoKjbMFg4eE05pigGx28cTMU0G9HSfXCT09RYRHk/FV2zre3h4bOgRp/IVPtG66rRDQEBlKhJ3hCtjlrUdb7hOhNIFod8jLa7oxw9pigFbeovPui1mpR1nNkuf2Rp9tyQlKoZMTEJPN9gM17uaYsIDd8Qwcni6qOwLUHcYBJJKN2l5gsvMjuHmpa1SdF2bWr4tJDdixqFo0PXsDil0BRkF206HXCsCHEqtyMhZVE1aIkIZzSiSOMIGMi4zgyMkgfHo+S4N3eDLcsx7zp8R64Cn4gukcdjy3mdhLnmqf4Exmm/U39Nwh8zru5ya77jHp9wJOrwoJmxzn2O5wnPbaFMjpWdVirpGCEno99G6olIpIHFkyL3WX7GhR+z5dsf5LJ/wMOxzvCrY8mMcITjJEg6iBtd5SVg5+Hjc5prN2OX1Kmdy5bC9trw0PEml4X/Ya/OfLyqus4prveQ1X7AnHpOrkD2/xd+Nb/hX3R0+n63Yjl0e+y1K3aLt2c6kl3St4H2xYuBGPOi43OSG0BX0A9hvepQKTtOCLb/BFg0k4DsCV8BRM+DNqqDleTzuRGgDaa2R2qbK7QeBZCoWlCIjcNrUTs6HfMor+YZH3CXXNXf1XULpMtYpMQGRI9hTAyYqY9trMKrvc6JvCUUTKRyk7zHyjzjVX9HwR5SmJlMWK7nXcLjONL3A4aN+i4vMcCbPeSzv8GHP+mQjB6aF4MPYHkaecHilfk3b3WGsF5zoBY/dO4RO/50X+bk+5WNzQOhIGq5kVSm+mOT4UhKuBQ0DGXNervi006Ht9VhVmmVluN8OuUprNkLJ427IP12n3G9FtH1Bz4cXC0l3vYO8SAXXuaLh2jT1vDTca0u+LWo+bLcY54qP/A6hI3gQdRFY2MMPNwIM4MxtrkAZKJWtJz2IuvQCybN5ziY9/nw7ZFnByUqj0JTasNdw2Mi6PGxHOMLq+gpKftjtcJkpHjU6OAKcyQ/RxvBBJ+K3s/fpOxGFVvxz/R8xRnPpviKoAibyiv9cfMOfOj+jaQLmJmUQOoxzeyA+nytuqoyuE6KV4b3wHtNCMQhdHrQF/9PFjDtBh63I4TSRCCFoexJZDnGE4FHX4buZYtdr2trg0tLXqnLIJ70GgwBuc7jOFbnStDyHyIHn5S0BAcrYtcyrpeaDnkOwaHNbVHw9tfjN2hironQF94OA388WeDic6a/Ydj5gaDbwhYsylv6XUjJwI1pek8us5qdtmzD/zdw2GB527Fj+UdRjXFR82GqxKDUHTY/XSxt0/D917iGF3UNX2nBeZnwUtxmFhlnkMy0Uw1Bgkv/DmOqPcQgbY1hQgICIgAyb2O3KHZq6wa285oo5fbPDhfmOUHQIRQOPgLmYMjQbHMtX1hQkAsZiTCoWhDStXH6t8lNUKFOxxV06psVYzEDaepNHwIxzUpGiqPBNtDYvrYhoU5JRiOLdnvpQH3IuL1GmwqAZ85ZSrUjcAbfqFQB955BULBnoHS7ECzY4xDUOLdOz1RDTZCUtb/m5/I6+2aEQGZcio6t7GKnfWY16Zodz+Zqh3qMjNpFG0hAbpGZKKTJWIqEkZS7HoMEVAYqaCrt/6ZpN2qbJK/EtqYwIaTIz5xijCGSTpLrCcxrk5YRa5xijEcJlKI5wjEdBRaoMuTKsKjuWDKSkS4ij7Ig5ExkFBTrv4SAITMCbaspFZQ/Rlws7Kk5rw3Vecr8dclsUCCG417Qc3e/KK7ZVn4yKoekyL+2to9aGvDb8pDPkNLFMYCHgXFyxZUZMCnvTuBTXfDndst9/TXQKpUOpai7ygo7rMTJDhn7EN9UJh+bx+kUIqZjhiIxedJdVdUltClK5oiVGaG14W6y4lecEWGJYrVZI4ZMW19RqRSPYQhUF8+QFgddnr/UTUjWm5WyhqMnI+U19xo/9R6RiRVJZEs+yrgmlw7F8xTjv8t8NDgkd+Hra4TaviVyH1JQcNducrAoGgW8rRI7gP5wVGGwk4Fy+5J7+lD/p9mm48I83KxqEfD5bUaHWaWtNqWzC81jdcs8dYlz4sGNhBaeJZlyU1EZznrhUxoouer712n6dTDjw7E76NjecpQWelCyqimqlyZQiNZbDfVPbAGVbhLysfkHDG7Iszvgw/LdoDA84spjFckUhCjq6xVSOGYkDTrOMgpoAl1Vte0OOcQiIqERBbQqUsOSshj+y2Q0ds6wqQschqRW3hWIQ2m7nHbPPnabH66Wm7QvanuCr4oL/Jtojdhx+r57RdneoTcH1OhdyUk8YqDYrU/C40SFNt7goUhrS50k1xjEO74UbzMqarNac1FM+aWwwTTKeLTLGZsE9f4N5WaOM844k9U/Xme0kJy792uV4ueYsJ5qEnAD7fnmaLthwYm5VyjhvEJqI0IFxWTItBaPQp7muDiW14SLVXBc5Rw2brFXaUpg6vuQqVZxlGQ3H40LN+d2ty1m1YinmeMJnV8ZMCkPDcblK7e3vlhkbosu4sEaoLyYFrpDcX3Olv5lnjMWYTbnPrSrYdj/gfXnIF/oZgfFIzZQhR7xU13RNi3P5kl/PLZ97ps8JTZuG7HFqCj5yH/D3+Vcc6rsUqc0OTOWYPd3mIrUd5mQN7t5vupwnytaKtMGTglJZW9mkKm3Puja8Xta0PYsNPatzXBFxmmiGokPkWEraYdNeGF4stCVwOQ47DZdVZfh9egkK4jLmW/0PNNwRD/UHfCj/nMJUdJ2QpbJrDQdrtM+V4nP9Lfv6iGRR03I8EpHyplJcTHwqatpEvJKvaOePOSsSPs8XNExMIlLK+RBfSlZ1ZT8XoxYa+GKiOc8zYunx5cR6Fv6oh/CEJaXIkUgqaroiZs6UpumQkVNTEWIF8yNxn7E5phAZ+3qXhJKMci0dmJKyIBAxhVnhicCmouUIjaKtOwwY8EY+o1pDKe7oh+/MKZUskEbQNG1e8wWuCHAJ1tpDy1ZO5RgHj5SCgd4gEvG7LvGR/CGRDrnnHJDrmmd8w762KbYNDmmbFj0ZsTIlt4zXI29NQ7epZYVnLBpzpDdZiBUCyQOxz0wNGQv7fd/wOU1hfbqhadCiz5wbPONZipeQpHJFadJ1r/kBGRVjeUtmrLrxD4rFDQ640E9wZUheTinXNC+tc0pdEvlDQhPTpUnXDbhIK0ahx5tizpZrgfgVhqNGzLNkSZMmBQUt17PpdRUzCmzo5XW24rJeElcdzvKUR60mLQ8+6cccL2t8R/CmmHPkDpnVBXt+k6tyLeCQf+i7Sr6apqzI6csGbc9lmG+wFYaktSar7YNNx/MQwuIb5+sPZY2h43oUWnMtbtiRBzx09pjVBXfimEWpoX5IKHwKU3Pu24CWY1yO819y4z6j7x1RmpTr8lsbfNMF0vEJvA5lNSYpLqmqCWGwRVWvkDhsy/e4wzbPOWZLdvkgGDIra34S3+EkydiJQs6znFA6PDAPcbBe4OvMcFkm3IubNDzJKOogsHspKeCoJblI7ZO6MXDY8vmrxg8JJExKWNVwr9HgLC045Wq9x2txXCxpi5Cu57GhusRrj2vThWUJB03JIAyZFtqOdGvNolSWa6sNET6zqmQztqGa2mgCHOYm5VhP+cS7Q6hspDjXig97Id/NCnynyaq8ohXsMhBtAuEw1imhthOpbdFnFHl42Q6eIzgKY87SgsxUhI7PQt/gi4im6TDUW9Sy4Kz+CteJ2BUfMBIt9poOfmbH+R/0PC5Sl8tUsxVL/mIr5M3K8PvimE85YBA4bDFgURpWdU3CmELNScprhtH7+CJiJDr0A48jLySrDYFwqIxirnMeeLbitaw0g8AjdASb8ZCsNtwJWxw0JWeJDQV1fJfv8ht+0Bohgabr8X7TGromhX3I2g4jTvOEgWgxCm324SRfWXNTEbPTcGmULdLa0PX8NTta8nxe86Dj4giQSDbCBlJAz4fjlWZW1owLY/+N2mU39tgytl3hiBapiim1Zr9hX1fTQvB+z349T27hCDhqwT9f21u6FAKlDduRT9OTfCCOOEsV7zfbXGYRkzrnLxqPyZVmpH9qD8A8pesG/IjvgYQD0eFMbxFolwt5QWLG/F7bCd1EzMnFirhqM+OMq2rTAkBK+54Hl+OkoOl6pLVlm+9ELqvKrmwiLclqTbzmXNfG0HQlj1oW3FMoW6ea1bZXPsk1J6Vd38Su5H7b4dlc8bS85o36LZXOqOqUZrDFwOyh0Gx6MR/1Xa5z+7dUBq4zTeAI0tpwN7/PnUZMrW33uFu36TohuVbsx20qbQiLhxw2Hdp+i67fth50p8+zuaLWhrbrc9R2OUsUnhZc5jmBcBmFHq/TBH8tA/mjHcID0WZuXMs8lm8J9T0m4pQNDmjRsQEqVmipScyYrJ4xcA8Jpcvn+heEsoO/7ua2zIC2adFniDSCqZgghKQm5Uy+wicmpMmGGTAwfRJybuU5lcnY1EcoYaH7Q3GER0CgAy7kayuI0EMMCiEkmbD7s8AEbJtDUjGkZWKu5DWFbvNU/QOx6HMlTxFIImMl5rd6xYU8Zqj3iAhIWTGTN2gUb/ickA41Q3KRkDLnQrWZyCscXPp6ky5D3qjf4ckIT+wzMj3m3NAgJBY9BnpEJnJqU7DBoe3Wiks8QlIh6QibOGzrLmfiOYVarHe/DZQu6EQHLPJTqnqGEJJcpJyJBbE+5K25xWT2DZyoGonHib5lkjTY8huMy5xt19Z5ZnXBXCxZ5REbTkzfiZioDHdtHLnOatqex7QwLOsabWw3F+Ba3HDHPWRIhARLiFkj87qez6xKyHXNdaGJhMd1XtDz7YSiu5Z6n2UZ1+KWkdlgNwi4qQ2TqmDohwQ65DLP6XsBnnB4mi54FLe5qC1t7ZNWB7m8y4YTM9cFzeC/ZSyvLLXN6SGFiyMDhHBQakVZhQjhoE2NkCFK29HSSl1Ty4IDtvCMz1HbOnhzrWh7Pv5ao3bYiHAklInmva7Pba7xpGAsxvSLiI1QcpFqhqE9MJ9nM6CLMoZvzQsMml8vbvm/R3/Jk7nh77IvyMyUphgxMjuMsA8qzXWEdWFyuti9Z1prbguFNj7XeUlau9xWOU3p8/0Nn74veb50+O3chrn2wgaF0vaDOPa4SgV32x7FLKYwBalSPDPHbOkt2k7Ai3nFpZ5R6wJHBvxA/gULk3NNyoGzwVJZAULX71jZBFPyqknbb1GvISsn9YSu2ARgIi75zPmQLT7kn505s+WXLNsTCtNjUdpbX6nsIfQ8WbLlN5iVhrQWeFIQmyYNVzKzf6J1ajzg6yzgOjux7wURkbPiiXhKVWR8Un7GpZ6Ri5Q2HTJhU9pXlcUSSiSXeUHL8ZjVBW3X5zoT72QDgSMYiQ5Kw9NkhS9cLlKJMQYh4GV5y0C02fLjdxWlk3LJUsxxMsnQj7hILbf4dV5QURHgo02TShtOE6tVVMZwVlhm8h86u7muaTk+x/mKoRtTarjJKxJVkVLY3jUNJoXhIrVd5xcLm01IKs2iLoncmK3I5cmyoOcGfLVc0JMRJ2nFjBV9WngyoOU5XKiM75KagYz5jhf8VfyYrSAiqRUv9RWRichExgN3i0md87PoPq+THVYm53utPt8tV1yKjBP1O5Sp+Ub+goYztFIcvctvq38mlB0c7THKLAfh+SKgZ/oUlJZSSECYtviV+hce1Z/QqQJmKqdGv4P3nMlTLjOPtu7i4fJa3XCtXvO/30BHbHFS/guh2yUvp9Q6ZS/+IQdig0RV3FY5f3dlWJIikQT43I1aXGb2krIXWayoMgZHCC7lOagdHCQ3ecU35hkjvcPLRduqNBPFibmkZTpsOPG7hsTPJzdsyQ7KwPudBr9YXKCzLodRgyf5/I97CFdGsZAzluYGlwCD4X3zPXzh0PRc5nUDf11DqkWBcCU906dG05bbAMSmtS7XK1YioWfaXMgLenrAtUhoMqCiIDFjNrlHji27t00TqfeoRMlYntM2QxwcbsxrPuBHayC+g0ByI9+yq+9yzHf02KFtOizEnNg0CUzARMwZ6A1i4TPw7mHQ1oPMio7pojGM5TURbSSShVgx1sc85Pu4SL4y5zh477y5vojJRcqBvsO1uCEioKCi5xzSNj0w8ER8Q4Mel/ISuf7X5iIhEE2uzQt2zWM6DGmZDgEurpE8l08ZsEFNzrb/ETN9znb8KceLn5OWY5TOEcKl4dsb9w+CQxqeIMo3OWw6/Grics0UTw9IhQUqNNwmxgTEruQiLyio2RUDzs0UTzRRxjB0YyZFzdCLmFQFyng0PUHb80hrw0bgk9WaodngabrgcaPDstKMc0Xbl2vzDwSVTyw9tmOP366ukUgi5VJjqwiOgL0ool3tEDqSaaHY9ix0IakVCzHls3iLl4lVKXaE7dluu01GkUPkCgpKZkoycCMC5XLgPCTlHsoYnviercY1apQuSIsrWNeUEBqlc3rxfQ7Fp2Cg7bv82D1gEEClHeYrO9rfCDz6gWRcaEIhuNPyMUDXl0Qu/Lm4w7jQa7IS+A4MAhdJm4OmxBVwc3PEfhzyeXLNf7pccikvWahzKp2x73zAo7hN6Ah+sTpjmPdo4LMdhXatUFf8eBjzxdjuBEehT8uXvFwsedjYYlXDi4VhXlbr35GkHwgmhaDhWYRhUjlktaHledwJtlAGnPwOuVF4QvJcXfKi/Dmh28GVMQLYdBtc1nbMHXoOLT2k7Uk6PqjEKuguM5vwHQQ+jcpjoQoySj6WH3CsbinIUabCkSEjvYMUgsgVvF6WFqE5M2z5DXKluM40T/QJm3qEh8cvkzM+8Letd1kZBIbaFDjSJ/T75GaBQXHffEaAy0HTZ7oM+CweUWnDtKx52PGpNLxYFFyUdqUkla28nNcLPhsM+N2tvZ1thIJceSwqzXYQ8015wbj0OHD79HyXUG2QK7u3nCUVLddl221y121TaptUL5VEGZfAiZgUygYipWBlDOOiWussNbHwiVzBdiz5elpyrxmjDcwSSaJqDjwPV3qEjk/La/D3N3Oarg2j3m/7XGYKVwi2Ysk/j1fciZpsR4ZFJfjrZpOkho2izYMWnGc+b1ch27FjR9aV5rPmBoUy7DYk09tdXMk7G9cH/jaHTZuKlgJGosGzZYpCs+O2aXiC7SBmm7sc9R/weqmYlhVznVKjyCj5t/Ff8C/pCYXIuJGXNE2Xc/OEM/0VjrBSHyk8fjN/hRQev/NuCGij1+PbFls06fI2+zVCSDrBAcpU7PAek+wFd+KfkrFgFLxPZTLi5oBUjSlYkamaWFqr1Z2mB7QYF5rrvKTjS95kOXmq+F4/YlIITpKChuMSmzah8BgG9jXzfR6TK8V+0+Xtymoqt8WI7Sh4N/HreND0rCt8EFgf82fxFpErOEsqdv+wRvtjHcJjMbPUJnJC2ixJORPfcWg+Iqk83nP3eVOPuZbHVCalITaIjMdr8ZbCrCzG0YQUImMubuxTkwlImSOkBXFU2FuAQDIR52ybIzKRUpDj4HGmv7J2JSfgrtxkbA55zXN29BE+ERpN19hbpKZ65/UtRIYWmrvsca01GTmVqanIEEISGLvDesq/EMkeDXpII6mpiU1MLHtILRAIK9E2cwpR0GMHjMUQpqYiETO00MS6iUeAY1zaxFSU3PCahtigZfqkIuXA7PFEzBlytH5AaXIhj+mZEcJISpNyKc/I6wWZmeHJCEVFO75DXk4RwkUIF0d4pGLBF7mkl7XJKelVPc6kBVO8MQUePo5xeZLOWIg5uUr4k+B9qlzxlFcoWdP0hvxL8ZqB2qAjQ+Z1hSMkr5cVXd+hVBrtCq4Lm8R81LId45MkYy8OuchKYtdacJQxtESAKwU3eb1OPOfEjkOp16GuvOZOy+e2qJjWOWMx4bG3x2bksKo0g3STr5MJG7JJrmv6gR0pRa7k9coqyypR0RBtdhoup4l5B3Gfl4qhsjWNljfkVr9iFLzPQp1TqhW+0yR2Buzp+xSiIDQRjhC8TlJeJJrDqGFxjcuSCI9M2deRJwWXqYVn+I54h5yUwMlKcVws+TZVeLi0RMDf3izYcluMzYI4d/m2+I8EXocNeZ+74gdUbsVU3PC/Zc9I6hs+c/41GsOvqn/PI/4SieSO1+Pvb2xnMqwljhC4tWFPDpjkihfLtVaUnEPfVlk8aa0utZZkyvC2nHOPLkcth7PE7g5P6xkTeUW3HqJERcMfoU3NUBxxa5Z4tce9sEtWa67L1E4zMliqiqlZcT/ok6iaS8aUeY8VOWfiOX32eKMzImNpVh25i47q9UPznO3SJ1M1L1eWz/zMHPNvWg9Ia8Nesk0oXX409Hk6b5Otk7E3Vca4npCpKaHfp6hmbHnvk5oZ1/KCDb3F3yevMFJznPj0/ICJyvhyqmg51jNsK5VNxmYJBj6MBzydKyYqI809DAE3RUnDcRnXJVti8M5Be52XxI7LTOU0hOVLr+oaV0iu8oSKmqxucannjGSbrcjmAUJpd6Qd3yWrNc+WKQ3HY2UKzjLDWcb6pu0xzmtGfmypdLVNBWe1QBnJB602L5YpV6sEH2uMkkJwntkE8dNsiiN6nGX5uz51qQ2/uoFZVdmFWupTKk2qa8arjCUpaT1AobjJFL4jaLgusSv51XjFhheSKkXLdZmKBZv0mNY530wVUggGgZ2QrSrFIPDYoMtvy9dEJua7ZE6PHtL0+bDT4nfzmcXbuocs1SVZPaEf3ONu4y/o6yG/Tv9Hhs2HrMw1aT2hkhmFCCjqOZE/IFNTsvKWwltQ1FNS5tzmT4m8Pg/Fj3mmf4UyFcv6krdujx8F92i4Yo1hNZyWS67kKdX8iI4M8aXkq2lBqu2kQavYmuB0yDLPCPAQCPpuyG+mCz5st/hKXfI37QdcZ4rrIud5WtMSNmS3HfmcJhWjyLP+dCXp+g6X9f/RwvZHOIQlkqWYcKg/4lqcciPf4pqQlViwApLa+nDbZmhZyGLMipyR3iSRU/pmCx+PigKPkA29hUSwYXYJTUQmFxg0G3qbWloJfYQPusuFfM22PuKu+AFn4hmRaXCrUwJhx0yvxOd4xHakTMOGuESMMhUhbRb6kq7c4VavLICDjAOvQ1EfMOYUxzisuGZbPKaioK27pGJFi5ixmOAT8Vo+scGxuuCutDD3mJipmHBhJtzKs3fBslSuKMlYSo2rHZZiQkiHfX3IpbzEMS6hdGjpwTuudoTPp/J9wEqlt819GibCuBpFRcN0udYvMEaTr+0cjgwJRYcH5i5d3yOrNRsypOsLRssddtw2kSt5ky8JcBn6Ib+pLy06c10w9UxAxwx4ls0YMlyTiSoCYV8apda8Tm1nsGMcJAJfSo5XBW3PW6v3NLmpyJVH4Nh9j8JgDPiOxCjN41aL0BHM5xXKQMd3mRZ2V0cBpe6Q1YpJAb4U9ESD++2QL+cLAlxmZc2yEtxr+cxLO87cFxusdMll6uBJybNsxo7bpuk5fBgMGBc1uW4zYIOWCUA+4kJOeM/b5El1xY7b5iv9gnvukDstSS+wIPhpoXg/GtBajx0brljvXm2S+KDp0vTg5zcLuk7IbuzRCwRPy4yX9a/4d83/C9Oi5ky8YtN8QiUqvjDfMoweY9A8MHfZin1+MICTdIdXi5phyyF2BV9MUnynwVyOGekdIlfiVQ5DP8IYq5i77zUZhh6BAx0/5jQtaJoQDe9uv/tNl9tcc7flUM5s99sRvKMKLa5jVtj3z5V+RsfZpWMGbNAlp8LBBvlu6pSG8KmN5qpOeBC36FQes7IiEA7SSCoUPdGgbT4mw37oN/A54VtieizzM6qo5o474G5LMghjlIZRBFvL+7Q8yGrYDEPutGxiuOEJBqHL03lNSwY8bhzw/1w+Y1Vc0gp22df7PO68x5fzBX0nYmBsp/O8TDDGZ9O1e9dX1ZiHwQZ9cUBeG56rSxom5iwreNSOKFVMpe3fdRQE3BYlb+RrNvUeFRU91UQieKbOuCO30Rgi12EzstzoaZIhESy1bQQsVMF1JnClYFGXvNeJeTJPOWhE7DQazEvNrtsmV4akNhy1HJLa7sdPVnqd8oa2J9c9Y0PHF+xGER2/QVbbVHzkWKjJstScZhlHLUmubFis6UlOkwqJ4EE7ZCuCp3NbFfS1ZFxq3gs3OGo5vEeff7hZ0jMhw9Dlk54BGjxNbOCs0JoDubEOQvmMIsnfTS/omU0ed2BaOFznBd8bxOw27vFfxhMa+Az8gONybm+EXpO0vkdXt2g471EKRaUVYzHhrXzGw8a/QVHTFCPa3hbX9TP6zh6xP2Qv+B7X9VN+Gv4PfKH/HkeG3OZP7WrOVLyR35CVE3y3Rc+11am2LzlLKu40PU6Tmk9aHZZVm6OWbSskNfQDl2dzl+tC0HE97lZ3WZDx0+4AIax+9Da3DmRl4AN5xDi3ju/bQvDnGx2OVwqB4Dqv0MbQDwSzQvAqn/P9Tp9wHd77ox3CsbEHzLH4CmEcNjhYd2sTNvQIheKOfmiNKeKaiTqmdqx31SUgNvbA8ghYmTEnYoUQkoHZ41Ze2nAVAZnIiGhTYW9cK7HAw3ppF3JGQJOCjLGo1wdIz7pqGTMTNtySi4yu2WRg+hTUbIp7pCzpiJilsQnql/UNGs1IHzIQbaT5gIiAwNhfyVxMeCNeENEmNJYpvalHxE6LFQt6xqq5/iCV+MPtuWN6LMWcntlba+9sYK3GGnNC0yAyITOVo6T9GYzQjJmwUD4902YhpwzMJufylNvqBT3vkKUYE4oOWTXBc5o4MrBjVj3lQkxIiiZbfoPvqlN2lH0xXtUJj4I2VoKYMyDkrjnijEt+r55Ry4LczLmmYkPeZayP8UXMpjlCYQUSd4z9WhOWbGh7I0xURd8L8KWg4XjkSpNRMi480tqW940xpLrmSmXM5JTb5QY9GXHGLbKSfBBscpyvSEVqDUQrG37xpeBlumIqpojFJhpbXxoEHm+zlFzZUZMylg3bdQNmVckn/ZjFNLbmGAGnac6NmNE0DYau7fKFjsOg7vC6nLEt+pRac8cckitNUkHgwKTQ3Gm5zEvDWVLxQp2zxyZ/vhXiS/j5peY6V1xm0BC+/Tsmhs+XCc/rf+SO9yM6vuT/vfj/MAze45f6F/xN+Oe0/T12Yyi1vakmNaTK0PMtPGAYGP7pWvE783MqnXGa/po6/phO/pjdMKYXSK4yZatSElqeDZhYIpe9EY0ih2VluFkj9KRgPZaWRA48ndUMQoezxOAJh1g3uZSv0XWFT2RtYmJGTIzE3qAdHBJjecX2YcjeoiXyHZf8Rt7Q05av/a3+Bzbc+7w2FqBzXX6HNjULOeOqdvn1bUQg7coiqR3eJgXLysMY++H55cQugheq4FGrycoUdETIr1aXlCqhVhmlTugGAb+bz2iLEE8KllVJz3FpCBuY6gWOrWzJLt+U1i08ltdoobnlmMfmU/5u8Zr33X3WF16+LmwF8EfeY74pL/CMR2lqShRCWI1gpmwYr1QRc1VwGDYplaEfOjxd2tVJYRQ9L+C1uuG+jvClw0mScdCIuMhyEkoa2LzBspLUGr6bKgahw5f5Nc16i6u1chPgMtOMQo9Xy4IzM2aLvl0PkuLi4ODweqkZlyX7ccii1NTa0PQk81IzKSwrYKozPmp1gBCB4D/djPl+u8/AjYhcyctVCsS0PUFTBOTaritCx34dgeDnkxs+iTfJasM/XGneVFMiAkplVzF/cDY3PMlDp8t2LDlPNbtqwFE74Ok8xRUSbQwD02cpJvRMnx2vybjMWZASOt+jbVp0/UMSprgytjQqdx83jpnnb4i9DWJnwKY+pHDnxM4G7/Me13rxTuk5ndlMUKVDvjUvOb3Z5X6jyW/Si7W69gpfRjT0PhpDXzT4fLbCYFGXCSWbpsN1ZnfEPxPv8/nSTue+mpS8MRfssokymobj8cU0YxQE/HW/z9eTmhP55o97CF/IY7b0PjeCtbavRBiHioKX4kuGHGFQNHUbjWbMawZ606q0jIVyH7DNc17RY4eO6fGar5iJK4Z6j6m8YcWYHXMPRcXCXDIWDQJCKuzILWPBkX7AWMzwjIeLS4BLKFzGnOKux8+WE21HiSEet8Le/lamYEM2SUzKSsxp6R6lyMmNta/cyBs29YhLeWlv8LQZy3NuzS3bPOaNfPGuQtWkzbl8aRO4QuGZgETMiNeiibfyGff0YzKRszJjelgoSdM0qKiRCEZ6k4yCiICuY/uWvnCQSKbyhpHeYehscclbSjMnEj17+JoSTzZoh/v8hffnRK695bR9yWw+smk/EZObGgFsiBYHzcA+VRuPUO/S8hzO8pR6nf/eEDH3pX0x+o5VjFlamGLgRhR1RakMkeOgatvvTGtDpmoetCPuiAFvlhb6ftTyOE8UkSsotc/b3OW9Zst2Z+ttIlfQCySjsMNZ2mRaKO6sKxuuhJYMSHRIy/dQlWFuUsLS4V6jwazUDEOXwBF4ua1FPWivu6+m5FGrzW2uqNHEJuZuZHVw2jjsNyX//vaGET0SUxLiccmYv2jtEThwkdoE6vFKvSPnfBZaJ3RaA67gcde3PUwBxyvBPMt5wnM+dh8R89/y73Zjrgv4m+j/ylJVbIcBf7lpOM/hby9SXss3DPUWr8WX6687QemCYfAeH4sP+KH8V9yIOW+c3+ET0fEsuvOg6bMVOdzm1ljzD5MxPdHgWJxhpObf9ex+7pO+Q1IL/v34nJ80djlsCl4tLT1oVheMRMzbpGAvDlBJizNjKXin5e8o/cfs6gO6jmVeBzJiWddEjkOm7NhxUSoGosVm6DMtbYCta2JKFArNgfM9xpxyZD7iXL7GkxHG67GpRzSkz59tetTGVnZeLTV/sWW/13Vu6UPaeBhgV9r97M8GHd4sFcuygTYVcTDCkxZv+H7c43WaMK6W7DpdKm34oBcyLQwnqf0APmoEbOldLrOSz5qPWFWGfyle4uNwR+yw03C5zRWlMvyrzg5vVhUNV/In/i7/vDrjKLImoqeJDW/FrsCXNsU7kHZyUmjFMHS5SIP1h74mq60Z6DZXVkg/T3CEDfgldUBSK4ahx4tlzr1mSC9wuMwqPg63GEaS2P1DR9a+1qaF4qDh8763w9N5SUO4HPgRUgg2I8GsNNxv2dxEqQU/2PD4za2hH0hOVjXaGP71sEuu4IOO5DwTvMldYlfQ9CT9QLIVN7jJrPd6M/R52JH85rbCdwSLUvGTkQ+zAadpzv1WxLIy/FV7iCPsv/Mi1etuvKEXCE5WmnlpGASSN1lBXvs0HI+5KtjwQm6rnL7ZYiomtCr7u4sIOHB6jOuMPnv8ods3FzdIHO7xKdN4n7m5ZFff5Zn5FaVK+IHzr3nCc77nvWffV0rxuGvZ2R0fHun3SGr4bp7wf9ve4XhlOEnaHLUClDbMSofPqzcg4N9271FpuM4CnPV67U+D95kUNX/Wtyx+VwjuB4fc5Jrt2D5IvVwaQscm//eaLl8s5B/3EN7S+8zk9J1KsBY1TdNEUbFt9ikoiQgYuBHn9YId+T5tE3EpbvBEREHBBQVN08UxDgZNUt8QeE26NEiNlSk4OEw5R5kCn9CCMdZS+G19SMvxudWKVBb09IAVGcaE7+LguUgITIhGkZgSB0nKjB2zSyg8vuMFA7OJZzzemN/hiybbYkRiMjIWlOtwmIOkFPZF4sqAJWM7alZjq2SUJT2zQ9M0idZ1KC00PdHkghQXGwJLxAwXqzVciBWOcUjkAkcPuZWXNilNwaU5R0qHHoc4eIz18TtE41JdUumMUqxwZcCo+SGVzhgnT3jZfEy7sgjH6Xq0Ms4t93lFxkVm2crTwqPtSd5WOUPfHloOkoa0O65B6PJtMuVu2KFUBkVFaVLeyhOuVURMk1ldWGWg9Ehq24k7k6ccr+AnwUNSXXFbriiVrUY1hSR0xLvbSegIXqcJrTpgUUqksIEQxxH0AkGh4Nt5Qihd9p0+pdJUxu5YI9cW8i+yGnDpB7bSlOuaRenyuijoSKv+K5VhwwsptOYiy2k4lml7llh3tFkDKiqjGNKj48Obpf3g/PU4414zfkfqeZOtCIXHonTZCF1O0pyDOKQb2GTqnt/CLw/5tfktfxb8EA2816o5iCW/nYQcNQW/uDH8InvJd8v/iXZ8h1thwTItdwspFtQm43jxc2bxWx7IP8HH46/Dv8aXgpPMIl5fLBzutixx6X474KNGn4us5D77OEKQ1rCsKo5XkuerhA+CbWalZkc7COD1yj7IlhpmJuUqnVoYjM7I6xlKlZyU/0TSuGVXPcbFZWpu8Ajo1D0iPJT22Gl4XKQV13nJG3FG07SJCOjIkFzXpGJBgx4rscInoufe4da8oKDiLzdaPF8Y0tpWq67zim/TFZ+2+oxCwdO53eGFjnwXBmp6TZZ1zaU8tzIUf4+QJgtmXOdNShQenk2qlyVnRcVR1KQyiruNBpWGl8mKvbDBorR/d8/4TEzCh3GfV4uSwijeiGOCuc2V3MksntPFpvJ3vSZNEfB8ZQ1LMxJcHDrCAlzmOucy9QjXN9dKa+Z1RW0sR7xOWgz8kLYvOF0pijWT+GmyYM9vorF6vkRVqMJwkxuarsvT+pK7chMhoNaG2xyankvbc/m2uOIzscWiVEwKs8Y6OgzWIcLrzGYVktpw0HR5tlB8PrbM7M8nFY86MRU1Z4mttj1bFMSOw1llQ5ybpsGvbxS3KqWnI6Y64z9dFggEoXBRBt7kS6ZlSOw4a6a6zYAcND3+YTImExn9skO4JhzOS6sabHoxLU8QODEHIiZTVrzyz6sz7sgRiaptgNN02QoiBqFDpXd5vbJK21OmdMUOC+bEcoAULv+i/hO+bPL/K7+j5x+xq+/y+0lN3wv4ep4TCpdh6NN1A35+mVMbTUbFy4UhdlxyrejpAQd+i1lheLFOyJfK4yUnJNkWBRX+oo0jBaXRFMpwWq6YltaqdCEvUNkBL5KSJSkz8/aPewjXKAZ6g0oWtHSHnIwLefxO8K1ETW08cqUYyytys2BA38Iu1jfXnmjyVpwTEVubkNNiRx9ZCKbICGm+cxN/JH62/r6aS3nGlt5FIHmpzxiZIakpMGiUqHklniJxaJk+A9NnJpbs6F1mYskWfULR5lycsa/3SRgTiIi26bAvP2Eubqi0wsezIzlc9vUhCxIb6DKaLb3LS/ElDTFgKPepUWzS4404wzVtWo6PUtqmrh0XoZ31L9fBJyIyA/q0uGJCkwa+9qioCE2TkspKxnEoSJnqjB4DEjlFUdE0bQ7Fp5y7z+izx1KMadDjafK/YNDvSFEP4ybPViuWKqVBREP4dGmwG/tcpILzcsVeo8N7ssG00PhScNSwo02w1B67T5XkwvCxs0fTO2CSK75Wxxx5fRZVxdQkVFpRFT6X8ooNbYNwoSNwhORe0KVQFlLhSIgdQep7TAvFXtNl5K9rap69xa4qTT90uMk081KxHUZktX4H/1DG51LPWVQWSedLS0GaFJKJTmgSUmr7RtJYgs0fKDozlTN07feblRW7cUAqVtz1u2S1/eBe1TZoVa71Z23XZzMSKOOgjUOhPE5WNb3AwuDvyZBlZVBa8FHf5R+uE36v/hYhJJdFxknSZFy4/O83cypqev6A/5I9ZUNvsdP+MYFosqF3OHB7vKnH7MuH5EHGIpwy12coUdM0Ef8x/4/EzoCcOX/i/AUtT/JmqdiOfK5SxYOOgxQ+11nNR32PtmcA25VtSp9VpdhpeFxlhtu8put5nJRLxrkFEzRNk7mYMk1eonWJMXYMfLX8nFVwRdPf5E/lz/Ad8S4g1fDsxCV2HCoh+Uje4abM8ITDXNt6SUcP0Ggm8pJpfUxeTnk/+mt+0ulzlZn1qFjS9SFyAw6Nv74VKyJHAoZZofCFwyCI2I4ESeWxm++x9G/I9BRPhjh4tD2XeSGIhc9+0yXIJKX2SWuNJxyus4qdhscn3RZXqeJlOWHP7XJP7tD0HLZjwXmq6Xs+11WbA7mBRNDxHealYkN3SSlJlf29z0qHY3VLJlK29CYLk/Nvhl3SOuD53Pqkn2czumvFZlJpOiImdCSetF7fTwYO//kiZzuMMCaiv660zcqKD7sNzpOaR12X/3BzRZMmg9BlUtRsRlZFminYiiWGEUllzUmFMhgsL3mvIdiMHN4mhpu8osg1ewOPo1bArNCWjT2IuUw1n7b6ZLXhQVvwSc/nV7eaRuVztxXhS0GtDXuyw6zQNE0TY+CDnvPuhj6KOiwra8NqenZ0NAhcSmXoiQYPgh6etCn6jgyZVAUtx6eoFIVy2WnYw7wv4KhpSKodCqVpey4b+JzlqQ1+hQ7XWc1RM0RpGNTfX9PQNP9UjxnIO2yxxVhMGLg/ZM9vvKse3WtLFmWTpDYs1wIWKVwqbaiUouV56761y5ZnaWNCwEHUoFSGvaaDs7rLy/KW/357k+cLw2FTcJYaXq9yHjXadHzBbe7x0L3PqtJsCI9B2OLvZh/9cQ/hLg0uxQ09PWQp5vgmtLfE9ZdwTUBFxcQo7nOXc25ZiBWZSJHYEevKFBih12znin3xIZWpKNC0TY+Kkpm4InYGLMyKprEkLonkVl6zq3d4YV6TygW7+o5NOVOyp60SMBVLKlEy0puMxYSe6eFJyV1zRCgdZuS4IsAxHh0Rs2KJWYPOBZKm6ZBTciGPWapLuuyzYbYsOch8QgOfb8TXPNCPKVEYoSmoKLTPTCxZigljE7Hkho7ZJDABmUjJRMqGP6KpNjlWt4QmQmK45ZiB2GNLdNlx7zKrSk7WnWWJw0CPmMkpc3OJKwJyEkqzYlw+x3VihJCk1Q2Zn7MoNW0noGF8YsehNoZVrZmV9vd9K6/5z7Ml3492WNY1QriU2vBdecWPGtskteGqTgirJmd5ii9cKu0zqQq2sP1PZTQvzW/wZZOmGDDQI3KRsScHLEpt92faJ1UKV7qcrAq6vsc35QUf+Lam9rqcoETNkR6+I0JF5SZXec5BI+I6q3hlzkDBjtnkSkyQQjLXOd8sCz5otThJSnvLc9ssant4JKqmMDWhEzEIXC4yi6c7bLnkynCe2MNI4HBbFPjSIa8NvpS8Xiq6vuQkqQilswZs2LFvUitWdUWpXSrtcppltBwfKWzobIG9qW65jzHa7nj/X9fn3IoTPuJTazWqn7Fyxtw1H9IkwJOSUeSwLTd5vSz4sNflLNnk66LLobNBomoC0WakDxkJi//UxuV+x2FW2n3yi4UidAR/tuXS9RTfzB0mheI6L2g4HmdqRqcakNSKmcrpEhLhsVQlM3nJhJpQWG+yEJK0uEKphGa4C8D18kuetA75SB4QrZm/Xya39EQTB/GOodyUPk95hSM8Yt3kufoFP3T+hh0e88ppE4dNlmLGm1XFMHQ5bAo+H9e0PJfYhbPEMC0rSq3YDENcIXitrm02oqr53RiOWj7f5QmVTpkkT9lo3+WB2CdXmqYICKXD87l15g4CF20EbT/ky+SW1TJiP4r5df0doWiQqxYKAxV8N9V8I75mWO7TpUWpNe93Q64yS4BbFpoL+ZZrXN5kAalYMDJ77IoBndDlKs95OlOclEu23SY3ecnQafJaX1BnQw4bEW1j63fXqmRR+viO5JV8Qbf+gF7g8k/LC+7IIVdMKWdtHCH5emJI5QplFGdpyEbg8zJJ2PBCrlJN4Nid+rKu+ba64Z6zSdtz7PfJNZ/0fU6SjBU5DyOrIlTaMrsv1ILrsUMuMh56I4SwQorDpp3sNBzv3U65NoaWZwEhr/IlAMsb2+Htez532w6vFtZiFUqHicrQGJoi4JV4Q6O+TyNyCKRjJxW6ooHHc/GKQbWJXnWIXEnLE7xcCQLHBvRCx+pBAVwpWJaa3YZNuU/WdL62LwDJe9UH5KbiUavJycpjScGqsv3fqc6I3TbLysowdsOY8yzHlw5vzDkDBlyWCRLBE/FbHpc/YC6W3PdGGGM4qeaw6pLVirE85+l8yHVesSgd7rZdSlPzPFkyLOyDflLZUNx1XvIyK3ilfvnHPYQrFEsx4ZYT9sx7eHjrPW1u9Wqm4kIeU5qUwHxEImd4BPgmYsdscSOmGBQJU3wiNkSLmUkZy2u29A4LVpypr9h0H1OS0TNtfGG7vx3dfff9PuBHXHJlf2i5oKHbnIgnYGCDAyQCD4fQxDaQoxUOgiu1fBfsysWKhW6ykjNCmryVJ7h4LMw1HbnFnr7LQg6RRnIrL9nRu2SUaGPoYn+WtmlZTSHQ9T3yos1jf5NxWTI2TcbynJEZvtsVvygmRATUwpaxRrJNYY5omsY780duKvbNLjMSlLSducBERKJj4feMUaKidFaUlSVnNYNt5uKGJxVs02cUWj9tUmvO64y7QUTb81HpPhuBz2VW0vKsQ3ZeKnbFAG1gI5Rsxx2mhWbkxzTWe9uuH/PVakpW+zRdjx31AVNxjsTh41aPf1qdcKNW7Mk2N+IWXQ542GjR8gSrSuEIwcfBDsNQ4kgI8Ilpkmt7u4jViNgVbIbWxtRwHT6VB/yy/I4NP+An7T3+9mZGSwR0PEs9GoUeg9B2cG9zBwP40qfUNrX7pkhpEtL13XeUnKUqGQUhebViYSI2RYue73GaJywUeLLBXmwrB4PQ7nWEgJf5kpKKu86AhifQmfXoNkzIODfkIqXWGTfqBT+K73G8MjzN/5aGP2ImUk5WkjvOD7jkGX0n4qjlsyg1znrpXBnNbW6FBt+Pt20SNna5M/8py0rT9SVfLRdEbshFavg8uSYi5Fpe8Ki6y38+1/yf93xOE8VyXUfxHUlD2fFn7LqQ2+SrX0rOyxUH+gHfmX9iqS/Jq6m1S/lDqjomcNqsiks2mh9yUv2GgJCeadN1A+4Hfbs+EDa9XGt4vSq5J+6gMFyLKX3vCDR8yzOEkNyY19zTnyKlwJXwZmU4arss10S/2BXsNQKOV4pRJBnnmk16jCKbxH2zrPmH+QUX4gWT1VP6jUcszQ17zbusKkPXt1q5yLV94qYnebUsGAQeDUL6bkjkCvazQ95vN5nkmuNyzrXO+avuDmH2GUllwSvLuuYqU0yKimHoU1DzQ/cxhy2Hy9S+jrSBq8x6fDMqml6ELG1VreNZZvjA9LnbijhPKlwprP92ffuSQnC/fMAgdvAdwVE1pO05/NTfJqsNL5MVj5oRzeKIcVHy42FIpmCv0cSTFnP6IGjQ8SXzUnK58mh7Dlux5DqDRQlfTSoOGhGL0rqmL9PaPkyHIX89HPBioRiXAR/0HK5zmwQ2CHKtiByH3Yad5KW1IXbtz/y42+XJTL8j4g0jh1lp+MnI5+ncXmSWmYMnHHJT8Yl7n1VdMwpdTlYK3/H461GX2wJu5lv8ab/Py0XFbkMyzs1aDao5aLrMSvv32A1j2r4FuPx+tuBHfQvOmBY1G6HtWn/Si3iztA+EUgikEbR9h+1YMs7t36PtSxxhR+BtP6JQ0K4PMIZ3+RQx/QErMj4K7YWjNnBXdtkIHfYdh+PpkF4gWZT277YXG9K6xYtFTjewzYaniwwpPO40A85SSZ5N/riH8JKURX1mhejyHIA7+h5TkVKamBP5kog2O+aIc3nKXX2XJ/JrCpEy4ZRNc0SDNg4ec3HDTMe85HMGHOLhoKgYuY9o6y4vzQtmYsiQDkM9ZCFWBMb6Sq/FDYGJ7HiYAUoots09ClGwFBM6ZsC5vCQyMeM6s6ldecXCXLJnHlOJgqbpcCpfvENDHukH3IoxTTHgjtnluXyFRDLS20zEOQthb+UtGXDMU6t1JH/XQ74sMkvMKeyt6Nh8zpD7KDQNE3PDazpiQGbsiBosK3mub2wKvIYAlxt5w132aOuYW85piYjYWHnE3KQ0aVKtQSill5AWV4xX35D6t8Thz7hiilsM3qWH//+s/VeTZMmWpYl9qnq4cTPn3INnJM9Li3ZVo2d6GsAQDAS/Bn8FTwMIRCCYkRaZacw0q66u6uqqy5NFRmYG8wjnzLgdfo4qHtTS6w24DzdeUiTFI8LC7Jhu3Xuv9a0tp03bFbydVzSU/ailEHxdveWP3XvclhnrXsii1MRpTaYrhmLKT5obBErwZlbS8ezrDR1lb9Mi5ZF+n1Uv4N3CWsle8VsW1SMGZkBKzmni0fPcu13WabHgInPoOj59FRLXpc1/jaf4ONxvNFgNJKdxxWk5o6DkE+cJ46Lku4nhrfiGFfYJ9DrDXHCRZrS9iLO0ZlHWhI4iXeYfrwYeq3j8Kn/NaSH5kXfIvNQE0iGuajSaiopRnZLWLgU1PRkigHdxStvxiEvBpLTs666IuGKMp+zOWmLH+FLYQ2Mirtjzf0pbd/njVZiUAnfWIFQ93g97TIsaqQU/l3/CIHA4jyvanoVn/MDZLbXhq+ySP2puchrXvJrVzOqcVTdEA2Mx4v89+xVZNeHA/SktE/GJ8xBXwu+KE67z+3w6gH+4rjkyJ5xXkg/c/aVYxhaCs6Rgqq3V7JV8TlmmLNJTpPToRw9Y5ZAX+q/QpmQn+gln6W9xVMCz5P+Do0K64oD3q09Z8X1Os4RG7nGtZyzkjJgxq3qXNks7j7RwmuPsV0jh8Omgx0VSMco007IEfCpt2eRzk3O/bnGSL6hNk64nOWj6JJXhzczGbR6aVW70Ca7TpNQpT8UfcTTPuWLMnlxhVKe4lSKSLs+mCxwkL9OYG3nJff89vp3P0Zjl5bRmIeZss86bWUnTVWS6JtGGjcDnZTqhiWWkd6TVFfztcMqTqMuk0FwWMQrJMLepbZ/H1wzlOZT3aAobgJCLnN/ME1ZFh7bjcpWWfMlX9M0WvvHJRc7L5Ht+6nxEXFvKlhS+/R6SkddW3BmbgqO5d3fhmZfWDVBqw0ViuM5zujQ5She0vDbXWcmKb90Dz+Mx7zd6jHILGLnfjHi5iPkmn/HQWaM0Nf/uakYgXFwh+etLC2ZxhOAsrjnJFzxptDmaZ4yM7Rb3vQ5H85LDpoWReFLwm9sKYyz+NCFn3+2Qa8XX9REbZoO/u6kIhMOsLPlmbPi8fsEG25wuaoyBZ+OcTFcoYXFL305tROGoLBiaGT9218hLs9S82M9wUpV8Prb86b2mz02Z8rjbYpgLdoMG66HkV8MFt2LIJmv2rKlOCLKI98PVf/zeGc1VUXCaSLqOz6JKeZ4O+Ul7hbiEXBvy2pBW8MTd5NWsINM1mZZ8PfY4jjMOmz4auM1qOo6LEjYj+Vxc4budP2wRbhGxoz7BUDPhCo+Ib/gVDTEAs8JAb+Hg3KmovxVfsasf4S6Li2MczuUpANv6AB+HgdznodjFdyV52WXMiDYhO/JDMhIuqWnSoGfa1NhFOlhI/FM+Y2EySmExaNe8sslHZpMKS1zSGHzjM6lP7shIIQ1SkfBYP2VCzFu+4Fp08QnQRtuUIbOKj0dL+GzqQ3KRs+038KSA3BZSHx/HWI52IBxOiznOkqu9KZ+wxwYZ1fIhD8FATzSZmoRSFIyqjGAZo3grr8lJiEybqcl4J7+3SVHkzMWUhm6jUCzEwnbGRPTdDa68IwqTkJQ3JGJGRmwnAnWXjuOiDXw/LSi1xpWSTd/hZbbggdxFAO93mhwvChqOolrK7EMGtF3BF6OEKzHiE7ZYVy0ksNl0eDkNKamZliXn3OIbn0B2loAShUtEz3PviiNAiMsH3QhHWgVly1WUGn7W7XKd1RTasBIIKuPQq3s4Erqe4OUUfCXZqO6xr1bYabhcJhV7jRBPwmFLcZVK4lJzref0RQNtwGDYMztMTWIJP67kZGF3mqvxxl2SU0O5HIZWGb8WCvLaqiHXQ0WjkDxoC0Y5rKXrPGhLvhnXtJRNSXnYcdBG8l7x4Z3t7SyVfD+teaj+hHPzgq5vM2ura4sRbbsCbSTnSc5PVwOGuaLnB2xFglmxSsMVZLVgXFQcRg2y2qot33f3eKR3cFzBaTljO4hYCxTHi4p9s82/ur5iINr8pv4rPpV/iRKSeVWx7zr0fIe36YKGsJ7FFTdgVu4jXInWJUl+RaVzcpWyFn3AvLokZ0HL36bSCcbRJPkV2t/mRkwIqxUUNiziIq/Y0Ov4YhtPSdK64iWvUMblRr9iK/iUyLRpOIKdhstaAF8MDW3XKo1d6eMpn4YjqEyTQEmOFikDzyfXmvttl1Jbb7MxmqrOeBL8GV0V2Gfa2PB5F8X9ZsRlWuIgudcKOV5I7nmPabuCvaBJ2xMMM81u06Wcr7MWeDzuSH55Y61AgZJsRZKeb62HzyaxtXE5kp82+7RceDayYfRg99qL0mIk76kBGfbPPllIOl6Xr/JzHrbtjl678DP9CUlds9P0+PXiko/E+5TaCg8fNhtsRYKjOQyqFpNCU2rN/WjpHGi5fD+pKbVhu+FyNM/xpKTrenw6ULxdGG7TmgftH6Ay8JQe38Rj7gddVgKHean5tNfkOo2YFhVbQcjj5XpDCng1LSmNZlFVfNwPeK/b4X+7GvFhs8eW8ZmXmv2W4tm4ojbwoG1/76zQxNribVXVIKs1Ww2HbfHw7oL5agkpCR3J/6n1lFlpX++PVlxGOXw1qfjxIOTzYcbAd+n5EvDZwOZQ7zYED9o+L6aag5biQ7fBvIS3cxt4IhBcp4aGo2wmuAP/dL1Jrpu8nlnO8z9pHVBplk4Ju4ff8h0WpU1yi+uKNhGrXoAxloh1NC+pjbSJSEi6nqQ2LmdJzuMOPGj7aCO4zaHS1nY1KWrWAp8H7gH/0/zoD1uEL+UlLd1lJK/wadI0XTwZYrDs2EwktE2Hvt4gFgmR6OIahxLrhb2Sxxzqh9RoTuQR+9r6UiOabJguIS6YPpfihqZpMZcjaioWYsKa3mIuphzKTa7NOR3TwxOKHg2mRtCXDc6NojbWoB6akFhMaJsmZ/KYLrtkJmGbDW6xX15HSDISXCKLtMTjUrxhlRUqNFMxwTUDpnKEZ0Le5BM0mkOecCNvyMnIRIxHSMuEhLjciDFd06YSFa85Zo11hkyJ6JCKhFK3WIgZB2KL2BQsGOKLpoXd010WdweB5CW/ZlO8R2AiErG4S1oCmIkxuVgglyatoppzXv+W9egjNMYSlKqKJ52Am0xzliVM64qN2gJQrvWc21jQJMARkre5VUTGOmFguvxuZHmzD9UGw7zkrTmnWbeZV00GpstYzGiJAa52WcgZPbPFmXi5TIUqSfIH3MhLdopdNryIGzHhF5OM+4EVbb2srmmbJtDgvFgQCY+VIOQX0xvWZJu1pXVjblLuqy4/bmzwNs44jwWhY0PbU9v4UmpDx5fMqgmudrjKx6zTsyrxsuI2rflqPmPLaXOdlgzlNbFpck+t03QVv4qtZ/A2OeeefsCqF/B8klGamrwOuc0LMlNSmwaeEjRdh3Fec55oXqUzBjLCF02EaPLvb0asqiajpe/9xbRgkrukdc1h02dWGt4mCYFwyGv72rPK8N3UHlz/dnzKvljjXFxxmUo2WSOulN2JTgtcIWmJkHlZc5bZpKDHnYDGwn6N/1z+c+vpLEukEBwvalquZDdo8Df5r+mLHU7rN1wXz8nLKa5qcNj+p1xkX+LKiC3zCOW4ZGZKS65xW78icLr8kftf8zfJ/xMiuNKvSfWYZr7GGvtIBF3Xql/P6jGFtqEmA3XIRJ/TY5U3Mytse7ewoJO4shaW0BHsNQz/8TJnI/QsL5mCUTHHw2U28lnzLb1NUyOFY7PJaw8XxT2/y0m+YCom7NS7zOqcCo0nIxwheZVNSKo2cV3xfbbgvtfn5SzjsBlynVYcze0IdmFy1mnwi6F9T1uOgxLSppVruEhqzo3hWN8yTVpsBxGfj+135ki+ZK+8T1+FvJnnZKZEF4bQhDyfxpTUy+/sgkzEzOfrPPDWKGpNoTW3Yki2KHgbhxyLUxIxZb3Yp03EV/qIjhngTda4LhJW3ZB5oZnrnL6wzPb/x+URB8Jmk4vUCqYajgXLVNRc5zlnXBKYCGNWuCpSEnJC3WWYs0ztqlkJ7HM9qXLeLWz3fC/o0HAEL2Y5c52zVrUpdM2bOCYuQ06LBTkFh16f/abi34wvWNU9amP/rEVZsxm5tB2PRVVicrhIKzypCKTiq1HFtCrvVPst1+W77JatoocQ0HIVWQV/f5NRmAqBoNCh9YAvSgIl7UVVOLxYLO66+tPY5UU8pyV99hoev5nf8qye8bFzwOtixELOKMn5C/UeXyU3tIhwUSgh+bJ6yxO9x4v6FIlkM1ljXnrcFCkOkhhrfT1aCF7P/jFOseEojrMFOSW60pBxh+H8gxXhPbPDlITItHCxUImJUayJDkZAIma4+HRNC2UkZyK9U6Z+V09Z13tE0r5Juj6wD7jJuVEnJCzo0mMorynJaRnbxv8Qcn8ujywYRK/RMzajeM95j+flBYMlJF/h0mMTF8dagXA4lq9Z1Ne01AZb5oCCCoQNdIgpqGSFg480kl2/SZ4/oqBmIRa4eEgEm3qToZjQEw1uzJShGPJQ7KKk4Gv9EsfYBf1MLHjsbJBrTV53mcqR7RhMm0uR0tRtFqT0TJ+5yVl1Il5rWNUbFJQM5Tlds05gPLpmg0A2bdqUWUXhUoqce+zwhlNW9Qa5yBFGUouaIlhg0IyLI7ade4SO4nV9RTbp4gqFLxxcrIryQcPe5LPakFaaeV2y63VouZLrtMnc5JRo/rS7zjjXrDiKerHJlIT3uj43qUuS5mxEHjrpUOkWA8/neQln9dc01Cqrqolb77DhWXjGgVzFXe5AHSkITcC6G9H1JNDksGUzRNdkmwdti90Dn9PE0PYExsDUJHREB6sDFQQKXs0s8vKDTovHYo9SalZlhC8lHw8Uo4smnhL4lYX2u0KxbXbwhUPDtRapj4INVgLJolxBL0lNJJDUkmlhPbKPmxaAsN+0N+idhoMBvklzptpOP8ZyiBIOD70uHxdPeW5eE9clz+OEv1jpIgVLZXCTnmczVFuuYC0QnCd2n/WTaJtJXrO67Db/yUbIvIQvRhZHmFaaylgk3gPfo9BW1d7zFbNS86vqd/yo/hSAluMQOoI3cUzfCfhMfsakzhhxSuSuoLVlag+rN7T9bRxhvwc7+h4lFSUFubPAFSFHvKUd7CJxWWGfc5Ewyl+zcK7ZU5/RqNdsARYZVZ3TdrcoycnrGStOi62Gw7TQ3GtJbnPrBY8ru3N8Njb8eMXiTsGlUbWodBMhxNLzDLe3BiVdQn+FEsunvt/oU2nLOv8wbFMbSCl4EvYY+PD9rKZNyKIq8aTCMYqs1jjCUtCarqLhCvaigLT26PuKQWX3tmuh5J4M+bvbGaHjk9WGjchhw2ziKziaVax7IcMi5180PsFTNqav47lcJB5PupJS286t7dk1xsN2m6OFnWz8ejLhcdQmrST/5+4+//F6zuN2SDndpOscMNQpfdenLPdYd+0Z+kGnxcCHm8zw46DNt5OM2hh8rD3mYbNBqc3dawmVoElok7/YAWAzUngqotRW/exKmNSGmzLFVw1mVUEkbRxmVls4B8BG6NEqHTZD6HkR15m1AT712vR9++dEjh3Z7jUVk9ywEtj3e6ch2G+6fD2SbEYKJT0uE8232Q3/+9V14srhKq2ZFfY176o+DVcisJ7s2kBLuayEAQNf0HZhVsJK4CzBPILrouTDTovbrCatNGmt+ecbbY7mhtO45NPmCpOijxDL8BjtcxA2GQSCjbTLiu+yGkri0rBaHhAqyV86h2hjOJrnHLYU10ODIyR/3u/y9Thn4MP2RsDrmaHhCt7NrTXuPM3IqXiv1WIRP/jDFuHMlDwOe3yTVjg4SAQODqkpLWfTbDCU5/jGR6HY0Bu8MGd0TJc1VvGFw1jbLNtV0eGtOEHUEpfABjjIcz4QD9EYjsQFLWOxX00TEJmIkpKCikQsWNGbnBcxiZxxyzt6bCGFw0n1JRfC5xE/QxlFgy0qcciYIRNi3vE1tc55IH6KQhLpJrEcU4qCWVlxK89Z0zs4KBJh6TdTcUPPrDE1No1DIjnWt0Qmoim66OUkQBhp4+OCgIHf4z9mpxgMDenR1T1SkeEbn5KKvrBIvdqU3MhLNvQ2A71FSIArFKEJaZommUjx8XCMIjI9pBTUlLg4LJgTEPGy+s93HN1x/JLfyP+RR43/glykPHU3KbXhbTXEw6VVujZYO7W3eBdlCTW1vfR8zxta9JBIjuYFtTHcpgva2JHt9xMbi7fj2J93hLTje3wkkq7atZnPtQUl/NCRSQQX5Ywd06HtyTtiWadsUVJTTm2xbrsOx4uSRVUSKoeYgpvUI9eae77lGP8QMO4rh6yuUdig8EttKU7boouS8M1YW7SoIyGHGQkZCdtinXfijD3nHkeLlKfdiEVpmBWaX1ff4qY+m3qTvTDiKF1wzin1/AFpXXGRSt7rBDybJKwHAe+Hq7xMJxZ2ote4lGcM85L/atujcfOQ68xS397M7CgxcAQnWcwH7RYNR/DdpKDp2pH9bkPxPP0hmWnEDuv8+qa0IjDl8kV2TiJm5CxYS/b5sVrjzTwlVA7GWAzf++VHKGmVy6+yCX7h4qK4qmL8JdhGUzNJj9CmQgkPYzSh6NlViBzSNB0GpsORuGJbP+RCHLGmd5iJSzQlY3FOWo1oeGuEskfMhH+X/DVSOriqQcNZ5Wz+K3ynw374c4yBN/McV0huc0m2RH/OjLlLsTleWIvYu2zButNASRtxOSng5bSkpMbBp6xibsUrcmfBZtamNjYBaZhr0qqmouJ1Oidw2hhjKLGEsdfFCIm1rG14EaPSZimfZRW+cNhr+LyaWe+oEIKWFzItLDVpmFe8NCf08gGftDt8PykRAprKoet6HC3sv63pKo4WJUoIjhce42W+b6Bcvo2nvI1dWsrjtT5nU6xxnKRcimv0ZI+UgufTmK0g5DxLGTjWx19SkdRWqxFXDq9mhrfiBNd4RKbJumxRmoKciuu04rU+58fhLuO85ljfsin7GAPfc8xDsct304xvxbd0zTp7coVxYdXkq64NVGkol0BJzpKcsYnZE1a9PCkM74opetThuvjHacFXxQ338gH9QLEa2PjEbyd2qvHldMaNvKG42eFxx2c9UlwkNRqYlSUHzoAvRwVX9ZyHQY+TOEcKgTaGnrRK79fZnLEc0terzOYeV4lLrmtOueKR2maz4RAoeCSavFsUGPtoMS9r/v66Yqoz+iokq63wseFIfl2+ZWGuGWb7bGcblKZGCtfiYqViO/J4vUhoKUvD2wkavJiWfNBpMS80eQ3f8xp3+JDHXTsB+nwyI6ckqLt8J58xMDt8O4eI5h+2CPs4fJGd38UXjkzFXI7pmQNyU9GmQWH6+LgoJGMxQ2PDEjqyS6FrmsLnVlyyajr09IBYjenqVcZySNN0OdMTNmSHA7FpOc/SI9ElBk2ITyhs2PtUzImMb1nT7NMwEU3TRquKB+Z9YjIeeiucFzE5OY5xuO/12dF/xnE1Il36fz1cNvUhW06bqyqmJ9boiwZXFKzoNau0Ni4h/h1oYy5G7Oh7rDoRaR0wNcmycAa8k8fobJdzeUnPrN15YosigCXFamoyagy51vyp+3PmZYmrJFd1RU3Nmu9zll8y5pw1DvFxyIGhmCJ1FyVd+4Evx9Tb7sdEukkmFzTDHao65VJ/hxI+v6xKDvR9+rTYb9iH8Si1l4tdv8mrfMSp+I6n3p8AsFZsklOwrbqEjuQiT9DY7uG+312qQy3zdjMSbEYev7wJ6fmSn/mb/G2c0tMDJmLGvlgj0XZfh4AIn62Gw8AHWKc2lhF9luQctiy28CbTdD2LB4xLzRoNdpsO309tMWu6irWwyU1WWdKP4/CmnHLfWaFftNgMA9ZDSdu1KtxA2l3YdhBxlsF9t2/Vq9UKR4sUR0hart3VekrxL/iAs7gEacMa3mu1CBaHuFLSDQNqYw1tPc9267Oy5sC3cJN5XeIsOeD/08mCOQl/2l1HCZtJe5kkbDsRG16DorZ7uAdtD0+xjEoz/HhFklSC82urDk5rQ1/6aAMf+pvAJm1XMis1PU+w37CiOkfarmGvYQVNBsOO08GVgqzWuFrhSUmpNYvqisDtUesC12mghENpUiRd9vUeI+aEyqFXr6LR/ER+wlCn7PI+fdNCIfnCSxBLgeFF9iVpcYPvdsnLKZP6FaDJKzjJf0PH7bOjOjzuOrRceDWz73fThVlpPbmBEkwLu0bZbDgI4CqtbSGUgk0n4lfzZ9Q6J84uaTbWEBL6nsNFlpNUBe+32jSLFRal3RNuhQFpbdhvKY6GkhCPrrKf4V4UcJbkbAXhHas5Ug7H1ZgeTc7ikkJrSmrabsiPOORlNkYKQWU0Ix3jlh0ariSrJQ87HldpTW4q9gIbRaiBTwZ2WvGh7DDNrbr6A71zlw/dyLbpepKB30cDtYYazaIq6Xk+T6IubU9ykTgMfGlZ1WmfnmgwJWEjdCnidTwl+dGKixhucZpk7DdC8qQHQG5qQiLWQhdPwSGf4Erbjf9xv8vrWclhy2VW2MhGJeGw6ZPPK3xl4zmPk5SZmAIdKjRdzyGrDE+CFeJSM841SkgKbT2+TVdQoQmN/XuHmeZ32cld4fzxiuQkFkwLTZZFLMqa1cCGXpRGI4Ug1zV/udJnmPeY5lZItR4pDhoOf3+9TdtT9jtYWO/5447Hu4W1Gq6HgpZrOI6tiO0qqQgdiafgn0bvMSkeA7DXVHw+ikkrw4rvky35BqtewEqomE5zpICj+obZtMN/vROR1fCT9DFSwHZoOJprJmLG+94m2w3F/ugxEkFMSiaS36u2/n5cLSDGRhCmesxEXCGRtHSPS0bkWE5mIuZUaHzhMBL25u7hcmwuiSm4ZoxvwqXSN0AgMULT04Pli5E40uZrXstz5jrHEwofe6O/NXMC4VBSYDB0zAAHS04CWGOfghofjy+qN7yVL5jLMQqX78orZlVBITIaJqIWFbFICPEotCYRCR3TQgrBGj1cFIdhk55oEpPSNS0ahIS0Sck4rSa8FSdE+OSmIhEJNRUn8oRVvYprbGrJu2LCS/k9HRGRLncEU5NQL69tvlS4QuLjEuAxzAsCY4v3rlghp+Kd/B6ACTH7ZhsXh1zkbJl1SnJG8pJUj6l1jjGapLjlNn5ObhZcyiscIflVckZeaza8BgsRc5vndufBA2ZlzaLU9uYtFtzWiUVfqoA/663iCBvKMCtqxnlNUWsuEsNlYhh4Pm3XjsAesMtCLOibDpd6yqW45p04Y65zrsUN7xYFr2aaoyTmIs14Hk+JTUFcGUa55nl+xctkzvN4zE2RWaFIafiOl1zmKdOi4jjOmVUFpbaj7S5NSq1pOx6fZyc8G2e8Wxjexgm5qRn4//iIJ3Vtx+9+k3JJVHs9q7lKDU3HogGz2iLpPGXzlO83A0vmqg3zsmaYaSZlQVJpBr5D25OURuMLRV+vctjy2fAiG4yQ2J+fFZpAuHQ8yU2REleahgPrIUvrCxwnGf/psrRYwVYLA+w0FPOqYlYVfJ1fcJll/FX8PV/nFzgSzpKchivxlVVkvo2zu5Sr0mguiwQh4JoxszrnpXhj34fihqKa46sWbWcbXzRRuJzIM1aFnXKM5Q2X8ohCa1rSZyjPyakAO8EpdcJN+i1rwVNWWx8iUNQ6w1ERUnhgtB17L7GoZ7FmUkDfF1wkNaexfZ7y2ma1Ro7Ax6HWZmk5E9bKJQQXeYIQkvXGR4T+CmJ54CeVpuO41NTEpeE2zznXY26ygu/SMVldMymsS2DghDwzLxHLtKxAKd5lC2pjR5Zg8a7boc9G6LDT8OirkHFh7Ug7TofXs4yW67KpbBd+mVmC3LNJijaw7oXc5iVJZTvzl9Oai0Qvwz8sCvU2z3kbJ1ymBZPa+vuP44KssqjNH1Z4l0XMy2TO6aJiXOT87eItV1lBIhZMjY0NHGbWUhTXJX91NWdS5VyJEV/HI2oM2hgCqeiZNmdJzrezmNO45NkkJhEJ16mmNobvpznfxGPkcvxcaPCFw21e3OVbSyQtV1JT821+bc+joqI2hllZsigNHc/hm+KCq6Rm223SM21eJ3bq9r67Q2k012nN319VDHzbsU5NgiutPmBWFcR1ybN4RGwKno0LrtPKaidqzTDT5FowrUomeU3XgxeLBWb5miel5QcECr4aGSa5vSDUxnrR38xzSm0wxjAsMm5SOy0TAk7yBS33B7ub4KvpjI7y7YTONDmRJ3w5MnwxtLvu77JbjhaC/abij5rbZLW2BZ2MkopCZPgEv1dt/b074UQkXJnX+LLNprZQ/5lYsGasgq0kI1i236/EGzwiNvQ2IS6Xwt6CjuqUrukzEws6RGzqQ9qECCFYsGAsb/Arl5b0aZgugXCZmgyJoCE9AtqcmBtKUdBTAV7t8EJ8x0PzmBN5xq7epqRmIuaU5GzrexSUGLEk/iiXVm0ze4WRXMlTGiZCaMGuXGFu7AE2NQkzMWW93sMVkqkYgoYuTdq6SykKNkSPzCScyXM6uo8wEiUc9vUeA8/nskispxJFoseciSsO5CZKCN7qG2rT4IvqJRrNx+KRpQ3JgNJoalGzwv7yA5Js6fusyRZaGEY6Zstp0zchV/Wcjh7QpsE3DFnzn3KdP2fb/5SZuaQ0ie1ClUO3sjSsSWFtOpthQK/2uSnSpTG/5uNmn7dxRI0NhP8hym2uczzjsOp79kYpBVltOM1itgN7OwTo+Q7rcpuj2No0ItPEMYqW9HkYHqCN4SItaCsfY2DdCxgXJedxyUHLo5e277JV/yr9iofmEdpYoP6wKEh0yaNWtExfYokJDJiVFZ6UdEwXI6DnC65Sl1u9IKt9mq5EZZKWq+gJ2z2FwqXpOCghln5a2G8qHrYVaW1Z0dsNF1fATsNlUWrmpcaV0Hc9lLR+4i9HGT3P7tGaVYvjRcHHfY+VYpXrtGYzkrxbGDItkELwaa/JeVzzbl4TdO2e/vNhztykSCLiCiaFZlKUTArJzNjR/kRcEosJNSURbb4cFhhgktsc56bjMq4yGtJjlJfcmjmX8og/kT9ixwxI64rb6hVZMaId7tkLr7B417ZZpWtaXImUoZmT6YQmXXbNHu1AMS9r1us9+sqCGjpimwfmHi/DV8z0Bb5oIYJdYJekvMFTDbJqymN+yrrToNCavabEAPPSdlvbDclmZLNbtyLFdWbYiQImy8LrK5uHfLzIuZLXFOWcW/09jgpYNbtcmxkfhSsoAYsq4kFbsteMOIsD2p7k76dTDlsecWnYCB2+nE95KO6x11SMR1ZncC9ssdOw4RYXqeEmtarYtgvfT2vO6gkfN1Y4S3Ii5XDQ9BnmGk9JBr4kriwS1JUCAzyLR9zz7f6/4zlc5zkD4XEeVzzpesti4eMIwWoocYTPl6OMj/oBk8JQG83TnsNVqmi6gqu0pulKBiakV+xxWszZEes4UrLTcNlpCH5xXfCoFXGZVvR9hyTOOfS6TMqSzFQY7fCoFfFintwV2YNGxAMZEZdWUDQsCroi4sO+w3li6VcrgfXBA+xFIWXSI3LsebZCl66vGGaGtdCKosCj50se1xs86ChGucGRAftNRV7D8aKi7Vqb4M/XXIY5bEYO950B89IwyiyspdCGP+40eDOveZNN+XGnv7wYGNLKcJHa1ehBEHAaGw6jBp6EngervodAMCms3qI28H5LchJLq1I3sNeUlFryu2GFIy2fIK00H7Xby7CLkkedgCj12G26BAqedNqkdZu2a1ckF4ngbZYxKTTDvKLnOawGDpNFzj8brJNU8Dczm0/w+/wSxvwwSf///eu/6f9fudULTsR3bHCPpmmgMczEnK5pMxRDItPEXY7kJIIdr8mwyHknj9nS22iM5fvqgg0/ZFZWzPUPaUkxORkbZo2xmDEwHXIqJsKGd/dM7478tKbXmYmFPZBMkwifoZhQipzQRKzQ5ZoxczHinr7H5+Y/UZmcPfUZY2EZtA/NB9yKIS4eORkP5Q5v9Q1d02ImFiRiwRNxwJfmOQFNK6ySM9q6ay1LYsCxsakrA9MnpWBTtbmtEzoy4CVH3DMHZKbkrXzFff2IQDq8Ned37+mQdzwyn9n8Xp1xI294gA0MONdjSlGyzQpXjFmhS2IKTuUbPEKapkNJwYoZsO6FXC3Ve5fihp7p8Zvif0EKhxX/EQCPzBMCaT2R14zZFgPWApeXyfwOhFEvKTFrssVYpzYAQzo0HMXL4pYWkRVMSJeN0GOYVVzVc542emS17UwiR/JFfrxUok84Nd/SkmvE5pamWGNf7/NWHrGt92hJ/y5xqaFcPCVxJThC8GV2iTKKA2dwB1LwpKThKApt6HqSkzgnUIrVwI7ATuPawvPrmrfihIzFndDIPmMz2kvRX0VNLSrW6bG7HONeZRltx+OiWnAYtBjlJddmypU44r9r/5y/nZ1yVP4Dh+4f8d+uWIhIT4a4wnYLz81rNvQWXRXQchVJpZlVNoHoIIqYFDWv6ysm4hKFS19v0KVpx+ba2uCMgaNigkRwL+jwIhvxp91VTuOK19UNrvHoiQZKCFwh+aX+BevcJzQBr/kCJVwOzYc08FiQ8Ue9Pv9q+h0XxdcYoxFC0vX2qUzOvDhnxX9E16yzarosyGiJkBNxjkGzrbdoKY/SaGJd0JAeSljwzYpscmFGLMSU2+oVnmpS6Zxx8hohJD+K/i90RETXtYEXa6Gi5cJ6YPiPFzUNV95NKTxlx4rz0nYsm6G1gSV1xTEXXNTf3P35XbVLzoId/YCWsFO1obziqXhApBTHxZw11SB0JC/yWwaiTUu5nFcz+rJB23XIao0vJauh4vk0ZjsMqY1VQq+G9mI0LzUXecJ2YDvT6yxnLfDp+Yqj5Y47UJJRaZOLPGmhF7m23dVNZcNRmsKn73q8K6b8vNvnm2nKx72Q55N/3CXHVc2sKtgOQ9qeZDOEF1NNZQw3uZ0gArRNk0h4zEzGe42OHaVLeJVNUCg81J3vfa4tSz3RNhf8B4V0JhJ8Atbp4UvFWW1dHy0i7jea3GQlaV1xrxVytLAN0HPxDJeAn3vv0XQlv5vf0qVBz/P5RfU563qfn3dWuc0sh9pffp6f5+94pHaYVQVKSHajgPMkpzA1KdZO9kHbTh8DBf95NOLA79gLqEnY96yG5IfvZs/z6fnSwkWMYVFVzE1OiMt6ECxztK3T4OUs48crAScLzXma0XRcbqqEmZizwYDEFJzJt2zoXToiYmoSHoXdu/c8ks6dXuM/5P/AY/MxkbS17cKM6Jn2codufyara17rM546u7wtx1yI18yqc8bzL/7/1tbfn5hlND4ukejBEv4/FkN2WGdEbOOovCbjIv/H36MNTcflsb7HnJxIeCx0QY19wAWCgRMyqwqEkXTo0VIe5yZhYXw7hjYuEp+W9JdflAESwarpklPhojiXl8SMrcjLDLgQ16yYAZv0mZLRUhv42Hzhrllnw6xSUlOJivecHU6KKfO6QApBVwVUtWYmxkzrnE+cp3ytX9IkpKnDu2Kf6JKIJn3RIHAUD/wmcaVZFw0uqgWu8FFC0JUBjvG5FNd0dI97cptMV6z4Ppf5KgbDQluhSE//Iw7PwWFAm8xURERciGt+2tjjNm2ijMNUDNHUy8M8YCgmFCK9G+0HTgchFLG+ZZadkARjPqx/hloWjNpYMVJHBkgEGvjP1S+5xwfkpsZB4knFeuhyFCd82lij7QmeL1WZ9mB1aFQd2q6g0gJfWrN/23RAwFN/nZ1ywEU9RUhJaBocNCIm8eqdnWA7sof0ZVrdPTdtT/IRGzQcwW1W273e3O5OKm3Yaagl49X6ImsNX46tHeS9VgslHMazPh36vN9qcx6XTHVGZFaplxOHB22Pv5leIIUdR/V8yeNOxKKCydDlJIv5ab/N6fiKz+RnDLOaC/Mtvmrzz3s7NBzoiICe5xJXNdsNl3J+CNKKXZQQPGwrDK4FK6QVK4HDnrvDVbLJF9Ub+rRs9q7jEBnFN8UFGwz44+6As8TC7gH+5exz/tz/mB/7G9xkFZuRw7tFwVt9w2fip7Rdh4s84RE/wjfOcsQmWBFNm4tavSLOLkBIlPCIZcgT+ac8kzdUxl4oSzSvzRd8xh/foVxrNC/1KU/ULnNtiJTibTkmEwm1aTATY3p6lZm6ZJK+oxfeoxlsUVRzqmVSGFg/98tpxUbk4EvBYduh48I345rVUHExr+kHkkEgmRZ2FdBwJXFtXReb6n1epX9NL7xHQcKGPsTF4aAR4KmQi7iDkoLdpsJP21atuijw8dkMfJJK8yTqshJI0hq+nVp282ViIRHl8lI3zjVXqbV1bYQKJRoY7KGshOQ8Synq4K6jOy0WbLoNfAWVhp2m4tm45MNegJ6FdD0r7Mq15lHYpeHCZuDzxSjhJyt24jPKDQbJwP+BDgXDHAJHsCgNj9shP/NCyiVfey1UzArr+VYSBII12aLvO+S1DXLwlGBDeZTasLnEUFJusBn6RI7g9SKj47rkWvPj1gov5gkDL0AJ2Gt6zAuHq6Symeeu4o/1p5TaKqIzYViTbT4bWEV7OPsMV4o7Hv1NVrIZuRTasMcme02XtuvyfFzxpAMf9nx+NzSshQ1qDaWBV7OMx52Ap40eAqiNiykjmq5kXlqE5r1WSNsVnCzsyujHKx7aOIyLgNNFRc+XNBx40LaTpw96AS+mNW1XshPZsfBa2GaUNZhXFS3h84l8SuQt9/NVm81IMsoNSeUsRZ02oepP9c8Bu0OeFYaTuGbVC+60GELA8aJky6zjK8kD2edTd4W/TV79XrX19y7CAJfy3MYMCtuZ7YkNK7gi4LV8QVnsAXAtT9nU+5RVjYvCEZJVN8SRgou8JCWnQcCFvCCrBvRlA7SN/1sXn/KYPX4rP6dntkjEjNA0yHTEUEyZyxHbeg9HSCpjvXwfOwccFwN8HPpOgFNJvhW/YZVDFnJCX2+QyAUzcUOTAedckYgZNSV/W56wIR6hjCIyEbmuWYiYjh7gC4dhlTJgHQfJiTzDNR7SSE7kMU3TpTABUgv+Nv2epunQM21ycvbYJNHlsjgm7Jo9zuQpt8CB2Oc6z/CFQ2lqlJBcMsRQc5Y5XMorXOOTsOBQbXKqhwQm4jzJCWigjOKe2OZbXuEal2GVMpbn+DSpqBFI7suf0SS0O+EwYJy+oQ5+gkIyFTcMdIfjak6XBgsyVKHoiS1KKhoqIjAKY2y6ixKSb+Ix3SRi4Lvc5AVJZRgEkteLDEHIy8yqzAdFh4dhl1/nR5TZOjNihvIcTU3GjP81OaYrt0DDtHaYLwK2w9AmuWQWsK+EpWI1HRdfWnHIu2JCKlJc4zItOxw0fX65uLhDdR40Ir6IrxnnDVYCSUdEFsyf2g56IO1lb91rEFc1w1zTM20CpbhNrT9ylAf8oviWH3nvYYzhLK55oLaojeFFfosrIgqzIHKsTeKCEV/krwlEm/H0HjnW7qWEYBAIXs002w3JdWopWddZyWCJOn0iDpiS20O+SDEYDtQahy2PrP6BXa154PeRuWRSVBzrW+ZiRKN4aoubWsWXknFR8pN+izczuz9e8X0u8oTaaMa5QEkfIRyqaoJ0+6TlmK/kv8F32qyxz1znvJUv6Iot2o7Ln7gP+Pv0DTEZT51dplXJlmdBDGfiBY/NxyCgbXqM5Q2H+iO+cUeUOqGo5hijmcoh950V9puK69QWhmlhoTHncU2jq3jSVbxbWKj+y5mllc11zvezEk8oclMRmyHn2W8pqhkSl1SPuZLwWD/lJM5JjUV1xqRMxm0SU+Ck0mJmsaI1beB5MkYmgvcbPSSC27xAAI2luvwyrSi0puFYm1JSw/P86o6Ud2Ju+CjY4mU2pknAZhDa0bIUXCQVp9WENdlmahK+n9qD/ThJedCKuE1r0towzOy+u6TmOjUM84phlfKk2eLFYkEVawseaTSs9kJrOp7kNDZcpgWxKej5LWpjeBPPWVHWVXCt56zJPqdperfOWZRWZHQS59QYXovXkN23ca4q4uvymE/8PeLK5nU3HLuDf1Fe34XTPBZ7jHK7L7/C+u/BTm0s09vnOLVK4rguqZdOkdPY7qOtV73EGNvEHccOn0+nbLoNvhrbZm1oZmzJnk18Kq147aZI8YXDl/EtT8MBl3lKqX2IrLXwy+otV1ddmgSs+QFKCtLK8HKWo4Rgp+Hx96MJiUj4QG5wkdmQkb2Gz1m5wENRoTmr52zXK0xNxlSMGeQHnMQ5e03f0gALi8DM6pqLespwFNmAl2WWvEWFarSBzFQMxYQ4a7KiIs7ymBF/4BSla8YkZnIHl3gr39HS1s5Si4o9fZ9j+ZqH+jE985jn8hl7+iGbfsRvy5c8ru9xXo6pRX2HmrOQDJeRjgFo0COuLWJxt37EutMA1vl1/Vt69BiYDsoo1FJPNiPmwBlwVaQAZBTEtbVibPDIcplNRJsIT7vEckxbdxnLGzIzY5MHBMss4XpZvJqOw32zxk2VEEjFmbbCrtgoXOOxwzpH4oQ1vUVNzY0YM9BdBqxxJt+wRo/QBKSmZCLmGGq0qXCF4sDs292fELQcn6sqpil8XCF56mzyorzGFQrHOIzFOYf6CXFdksgF22YLAzRNw0LrlWSr3GHghBRa0zNbtE0Lf/mRjuQNa7SZmHMKvSDwevy6/Fes+k/Y0of0XR+vUlwwomkapGRss4Ev1d0I1RUKUcEF12ywykbocZtV9F2b0mMwbAYhi7Lm590B305TBr639PlCJF3eb63zzbRBU3pMTUZDeKS6ZCYW7KgOnrKiDE9KPnVW8Ja/+Wa5w32VzpiLKRus8jiwis95WeNIQc+0ea8XLAEF0I2bGGMYL9WUSgIaq3Q1mlXPqmMXumDLcfmg28CVsBkaXswiitoQmAa/q74nNkM2ecCn0QZNV+AuBpzV3/Jn7j/lYbPil0OHmnKZrW0j3p5EXRquTQha8uc5XtQ87bmMc0PTdVmUhuNizp/0uxabWZulUEviSIu/SyrNx32Xr0cVhx0H6FJpw8feBm1vi5czSxb6ZfE9+9U+O2FoDwMMa4FPVhmGYsSe2KDtKVbye3Ra2zi4vIn/hqpO8d0OobTv50ws6JhVXCyUYFY6+ITWkeBIJqXhqkjpKJ8BO7yVr9nQuyzklOvyOzJnRprfYrya0O2xrT5koPvsNBTuMo91M7LTi98MYx60IhqOYZQLFqWm4yl6nr/MYg1YCx2u04qX5g11nZPllxgM57Nf4rtdgqjDM/FbPuYnCAQbXsS89PCloq+spS2vbDpZx7MUso+D/jIRynZVA18wLyFfvv9tpXClg7scK/d8ScdYMMcwL9gVq+w0JLXpktWa6zynpayqv+sput6A4yTl03aPl7P0TqDa9QSutJ2lIwX7TcGk8PEUBErS0QF9X/DPWy3OEuh68NWoYL9pGeM/0JvSymXD8QiUYFHCQdAiriwX/yedAT0PdhsNbpeDyFlp3/ftyOc6K/kT7ymToqKsrb/259HBXRqQxBZgT9m88wrNjtkkpmQ9CPCVYFWv0/Pt/vzlaEHDeHQ9eK9tk592wpC0tiKt2hhKU3MuLvlEHbDXVPxyOOc2c7gXtnivKzmaK54vZvx5dx1H2tjg02KBj8PPBk1O4pqu7uMrwYq77DqVYFRpfBPy5/0Bo9wQOoKzuOQirbgxU7ZEj0rDjzpdKm3Pl5YbobG7+4dhm6TS3G87fDeJ8JQk0g5P/Q55bdPXXCnYb9rvUV7DWuCi8i4boYMjBQaXhgOBsmCUpDI8aTV4u3DYavi8jZM7DsYftAiHJsCVIS3Tp0nAurjPd/ItHd1nLhaMxTVds86CDGEkD817NJTLm3xiR7NS0CIiNhmTOmPTbfC2LGzYgnC5ZowyDpcMOS+/YVU9YMXYAIanfHw3e9d1g5yKFSfgurTM0hU34Df1N+zqQ0KleFePCU1AT4a8MSPWRJuZTtjW91iIOWt6k8fyHokueSff0TY9AhNyKy9xyi3uR02e6xsaetseTOIEyS4CxRf8mkP9IWuqwXPzmqbp8LDZ4MtFzod8SGwKIuFxzZg17K1boBiaGRLrkb0Rl1Q65+feR0yW0P2krolMxAKbo/wDiaxG45kQTygKU5NTkJqMsmwyEwtOtPVxJnJGJhYEprn0I+fEuuBD8WMSUXCm3pKqMVfpM0Qouahh2xzg4tJXIZFq8qK85oGzxqKw3kNpBJHy+Njd5ThbUGjDS96xUWzcBb/PyoqbesFK2bMFsLBeyQOzTY3hdFEyFXMeRhski5Iv+S0lCYHoMNKX3K8eMSsdVnyX1+mcHa+JIwUvxCuK9JAVFZHXOQsyLjOblzyuMoih6/h8OY4ZeFYAUqOXXUBNaWqOMptuc6kndipQ2OL/yFvjNC4otK2U16ENQz9OUn4U7vNtOuSQA7ZCe4g/m6R8J75BoHClZF4JPp9OcYXHtlknMQV7YcR1VrLveFwmcBQnbIchhYZ/PbygaRr8qNvmTZbfjWnnhabtSUsAim3x3Wu6vJiWPJ9YBXBR2xE8wLioSCpJZkpGOfzYfcyL8pp+5XNbZtxrNHgTx9xvNLifbREoyUWaUciUNb1FRY2SPpG3ghI+LbHKmGtaZkAqYoSxYJfcVDZrmIq00gw8n3fFlEA7CBQfivdQjuCkfoGzxGFG/hpJfs1a8z200VRo3s1tLN+kqFkJJN9OCgJpo+6O4x+gGTZIZD2ylKXfmS/ZWTywXACZEOfXCBlg9AIhJHk54Xz+G6p6wa3zLbUpOJR/wUnyC7rhPXb0e3wWbXBeGWIy0qpJVhmKumZRVQx8j2fxmIdlj6ssY0FGgMeGH/I8HfJeOKDUdlWz7oUEyoquIqV4M6+5KVJWXPvs18agtaEtHeJKsxeF3KQ1jzsRF3GFFPYS5krBpCzoa8VpbLiq55TzBrsNn4Yj+e0woem4NBwFSLqehZtcpDZZ7OvRlJbw8ZTHu3mJpySlrrmqbPNyNdWsqxbh0vokl+uVq6Tii/yYjulRZAGBVGz4Id8UF6yZLf6Hm2/vmolZpejpkEC4d7tbKQSzskJVYplWFnJc1iRixlRHfD60jPrMlLRpkNU1O5G1BaW14V2VU9SG3wxjvGUGsQt8NaqJq5pVJ+LtosSVktfFLU+CFb7Jr5gWVnvyg32v6Upus4pneU6oHHbFCheJzZ4eZha84mtJZKxneZprzpKl4t33qLRBSZtd/iad8zBq8cUoozaaRFtgS6ENN5kNtzleFFZM2PB5Nl1wr9Hgo77LaWzpYvPKisyUEFznOYFUpLUiMxXnidVDTcWEWv9+xKzf26Lk4hDQZCKuuBETPCWpKMlFzppevwtmiEVCT4bMSHirr3FxmIsh0zq3qmcCXBTawK08ZyimZEvrjk+Ab3y6apeUGXFdUpraEqnqnEJrHCQNbEi8j893vOS0nOET0ZI+XU/RNA36ssFc5zRNm0AqSlES4LEQk7tDMKWkowes0aMtAj5WD6jQnCYZ63qNSDk8cNdoMrA2FbGgK7a4lZdc1DNc4+Mbn2FWcyyec2aGhMJl1ffwjd1X3pgprnFp02BNttkVq2zobQ70A3wlWAs8Go4diTlIOiKgFCV9dugon4Kahom4YETf9Tn0+qyKjiVhGR+faMl2toETvvGpRcU9fc++ZlOyoiJ8IvbNh4Ruj3l9ybQ6YShvGYgWbdfejvfkCqESOEgSkaCEZL+lGASSVSdiXtZo6rv9fLDkBbtYOtNmGBAqxcC3AoZAKtuJ0eX5YkZDubxvPmWPj/CICGkTSZeG4yCF/fcndU3bE1a4pTx6nsNDb4Umdnd90HL4s9UWDUfxcd/l416DUluvZ1v5HLYd1kOXdc+iRBuu5MetFQLhsB82CIwlHbVdh80woOt6DHzbhW4GIcdpjMZypW/zEiXsJGBanrLKIQNf8u/P7diwbZq8FSe832qxGkoGvkulbRDER90GDUdY3yI9YlJGueZnqwE7XpPagK8EhTb85+HUCq2kxJPwpBNwXSQ40mYyL6oKIQRdz+GqtIKfrcjnqkgpKTgrF0TSJS41NZq1UPCwY3fVa4HP++IRqcjo0rAMZp3jiQiDxsVG9DVNl4/8LWYms2Q7HJoE3JQpo7Jgy7H6BLCq9G/1W3ps4qmm5ZcvbSuxueVTf5+ODNhrWm/wamAP4EApm0TmSVZ82Iwk+00rkFIC1gLFz51POQxaXMl33GbfU+scKRykbOI7PTban+G7HQbNp3TCfSJvlcv8a/t3l1d8ufiX/Ovkl4zlDWN5wzDXJHXFm3LIwLcRlGuyxdvM2ikBtoKQrifZcbp4UuApwfNkzHkRI4Wlj1XGWlu2gwglBI/bIU+6dhWU1ZYQNSs0By2Hi7hiXpd39qpACT4bRNTaFhSJIFBq2XnB405Ew1EYDGdxSVzaTtyTCk/CT7odMlMRl5oP+i4Sq9j/F+tddrwW+16HuC45bNnYwc1I0fPsrvKps8vDsI3Adt4XeULXtFmUmj8LngDwMOjxcavDBz0fXyjOkpzdhs+tXtB2rfI3IWeYlwx8h594D9n3W5RGI4D3Wk0EMK8t4MdXglAJchYEjiAh534z4LKIEcDjjmIjdO3OvEpZDxXvh6v0fcVDZ42VQPCoI5cEMLjXkiS65GnXjt89KbnIUvab9nwxGPqB/fm0MqxHis3Qo6EcthuSlVDRdCX3WpKW8JkU9rLwtBvxfseK8nYakmszZVLaaNSdyJ7rq17IrKj5fGj/v68EDceh50ur+DeG1/qMlUCyFYT0fRchBBtmFVeGv1dt/b074Uh4PGCXcz3mQrziEev09Krt7ijZ0bvEZGQi4SVHuMJnj018pbgwAQtSSl1TY3fIma5pmQE90ybB+u3apklfhczNhHH9jonYIpEL2tqSqSbMyWVKW3fpSZ811WChuwgkyjhcMKJOe/g4XOoJIQG5yPlav2LX7LIRBCTZDjOxINclUzkiJ8HXPh6Ky2rEgA4TYkpRMq8SBqLNhllnxQ0o9SrTOl8SfCRts86MlNJodsyTO8jFr4uX+CJEG41EUoqSW4as6RVq7AG+4YeM8gohIK3tISsQ1BjmYsim3mdeF/g4jMUMsDe542JOjUXyjeUN+3qPtYZLHO8yFjM2hY2b+8p8g0fIU3F/CZmo8XHpO/fIWTDKX/O2/HvOnRab4n0OzC6JKbhIS3xcHjprvCmHvJg6TKqchJw12WJX7/JKntDUbcKyzzt5TNN0eDaVlNRseU3rqTU5LdXkIs3YiQKuM4krJFekHDgDZlWLS3HDb/k1XhXxSf0BLenzVl9DvMa5PEXVe+z7TX47mXIvbDEral7NSrK6JlCK80RwtEgRQnCTOdzUC1bzHidJhkJwLi8J8h0ELl3P5ThNeCO+oCd2SfMVIuExNynlvMXSjcVb+Yp/Fn7CdVZyqxf8blThCo8H6o/4IFglrgxf61c8lIe0HIe8GHCRVDzuukt4gOawGXK0zOpbjxzmJqdPi3FREaUuwyInruxlIasMO16Tw5a9Gl6kVqUbChvdaZNj5PLglczLkEDZ0ApXKEpR8Dhs8zwZ05M9HjVaHM2tuChY5s5+br6gIXoMEaxF73My+ztMqFmIa3rOPjf5d+x7P+W3xRFGag69e5S57XAro2kJxUW1IMRlIi75pix5l/2ClfAxaTlhkZ2jpP35QHSotLXSvZ4LktrlJqt4ufjH0dy/nR7x368c8nxcMNc5MRkD0aLruvyi+px7+jHT+hRjNAZNOzrAGE3L2aCmpO3bzOND8xHX/jmJGZPIIbXO8ZwW4+KIkbGhD2f8llrnaFPxXdmh4+2hhMuq2CUwIR1hi+M38zldFTDO6zv++lAMebbQ5NjXnsgFzbJNm4hJqbhkxEResWc+ZpJrer7i5dR2qosq57acsKMG1Abeza3dKK0M94MucVVTG/jr+BVrep33Wi2+nVv+8ZpvRU9dz15efjuZ0VXWevVsZClqoROS13Z/uu6Fy9AKK44aZppSW8UuwLyC7lKIpZB0lcfz6oSP5B4GzW1e8DbLcVGseyGnRcqLRUlFxX/I/4Gflj/lftBlXJR8Gd+yIlpkpqKlbHb5N/M577Va3IohJjF4wuFbYdX4cbnMM89qtrwG52nGVWZ7v9LUlFScLEp2mi4dD25SwVVqffnv8jnjIiCtPB63I1xpL/auFBw0Is4Tm+T0Jl0QZu7y0uLwbl7S85X1B+eGt3HGXhRwNNf4UvGuvsUv17hK6zth5Dg3rIoO64GF5KglsCepLdXtrTknKvfsxHI5lf31bcKIOT8K9jmPK97oK8tIkJfkIiEv53/YIuxJ2/VM5ZDH+mNKrZnLCZ4JCU3IRMxxjcuB2LyLxDvjlmbdZI0tCkoOghazsuKsHhPqgC2xwoyMvmxQG+tP9ZRks9hEKImjHdq6y5U8ZksfkpHQ1l18XM6LBW/Ft2ybh7RFgG9W6SiLTEwp6NOi63rclmqp/jWMclt4A9OgIyIuOCKgyb7f4vvChgok5Ow5PS6qBc2l+vZSXuFX2/Q8l9K4FNr6MhdL+LgxMBAtvjNveVTt85BD5sY+1C3l3VlXPKGokUTSWUIA7ANaUjNjwaboU5iaHmusqQZxbQUqbdO0UwRXslJHXNRTFmSk2OLsStvVb4o+t3pBhM9DHrPiW97wW3PBx84D5qbiPR7w1lxQe5ZENk7fcC2+J1JNFA61qFgTLRt/5tnO2JchVwVoDJ/2GyxGXVaWCVCRafPAXWNc5ATCYSWQFDWshR20Mew3I0a5ueuOo8qSs+qFYaUeEBDhGpcrrNWpWW2yEijq+X1cZRWrW16T2XJkaQy8WGSsuR6TQrMeBOS1ZpRXPG30mC9jygAGeoXtpsdNZuPWdsOIJP2QddnivYHH3w5t4MJ+y+W3kykpGXvcp+EK3FwykxOOzTk/kz+n59sv/5eLEa7wude22cP9oEegLGV3UWq+ry75bzo7PF8krKjIqma9JtOyZDtyebssRn3fsUCQrOKinsKkz7tiyoHfIa00q4HN010LDMNMMCoLkrGi69mv7NOu5CwJ2Sju0/YkD3TXUp0QnMk3UML/LvgMTwke5E9Z90JeFyMQ0Ar3EEjG82dUUYqjQnKREpk266bPSRaTkltkKpJbveDA79h4O/M+b8QRxmiG2UvS4oZ2eMAiO+eg9edobMh9k4A/XXeJK8FtKtgLIxbLA3nP3efl1Kq/K+NyKS6ZM0FXNR4Rv63+tT2cVEBRzdlw3qOnByyYo9HMxI3VaZCwrfd4IW6pdMpT95/xdfa/ErkrdOQ2U32GL1pcxl8ghUOcXZCXU3y3w63+nk6wS1ds0y9Wecmv+an5c5SwBfjPB33GeY9xXjMqXVyh0KZN37M5tvtNyfPJOl1vk3lpC3Dfh4tUs+Y5zEtLyZvXBRfxlI8aK7gS3i5yfrYa0HAE72KBm3uMxZhZ0eCn/Ta/Gc3p+iFXqS2oYOEt12nNILBj2b0oJK4MxmgbBqI1PU8x8AXeUl397+ev+S879wH4dpqiJKRlzWYQ8nFfcHHeXqYVdbjIE5402kvXg+D/MOjwD9cFaV0wYIeer2wOctvHnXdxpWBaZgTaQSsLNSpqw/vuDp4SNByBH3/Cl+IrhOAOORt5kiediF9Nhxx6XfqBz39YnLOvOoQK4tJ2mqU2Ng84D9lpeKwFgi9HBduRy+Ouw5ejnNoobsuMnw6a9PwOaWVQUjDOazwlOWxJe6Ey8JcbIf/hIuGwaS+wnwYbVNpwWeQMxYjP1C6ncYnAOjNa2Mv0sMi51wp5M0/p0eegpbhKBS+TOT2/zb1WyL4OMUDHUzytN3naU/z1le3+z4pf/2GL8KTOyClpmx4LUoLaYcNsEJPRJEAZxZU8xdc2AjAVCaGJuJKn9PU6e06fWWl9pXM5pqW3OeOKgIhEO9RobuQNK+KAQFjRS4jHwAm51S6ZSHHxGMqrO0BFUwyYihFtHXIrhtxqcIVnKdOmIqh77IUR/5CfkoqEgV4hEVPWzDoLchAgUVznGQjLUq7QnFZTErHAmBYuDqtmlXfyjFdlzpbeYSzGbNZrLMiIRcJ9z94SO7pPIeyIZiFiNkWfaZ0z4ZwNtrg2U/q0OKutkrLleByXU/qiwYa7zuvilrUlseiqnuPjMjExbSKmOuP79DXv8QAfz4qz9FOGYoqeGwYy4jfml3TkBh2zQ2EqxkVJqBQP1BZXpUWoXYpzalGhTUlDrFD4a/iyzZv617ScDQCrbESwXvZQwuW4sDc6ow03qUsqUrpeF23gibuOBjbDgLfpgmnhstNQvJlVRI7k+1nCtbjls2CXUW5tK2/nBZmumBFzLl5Q6oTK5FykuzzUj7nN4VLcMNB96tyOxXxcNmkS15bpe50VOEKCo3hd3dg1htflpkh51GqwKDXH+QXatPGl5LyICeoGucgZ1Q7XqcNYDmnpkEVpeNpsMymahEosM38lvWTAgBXutV02QoMAXi58Omwwymtr2ag1U53h43AlbIj3N+OSRCRMa0WSVFxwzZ7YYC0UZLUFVFxkOVla0lUBPdHEV4J11aLSdsz/XlcyLWCYC7YaDicLw0U95UGwykVScxxb9ekPkXpgV0YrKmJLfMLbasizZMim6tBSHhp7UVzQo+H2OC+/JvA3UNLnqfxzQu1yLW55JV9yoO9zK8/Z1gcA5CLnTT7hWDxnxzxhx+wy8U9wpE9WjhFC4jkt1vUOHRHw6UrAu0XNWWJj5TxlrRyfDhQXqeBoXjMsMv54tcEvb0vel4coKfiieslUn1mLU53RCfdYbVoleJOAS3GCwmVL32chrMbiRt6wZh4gPMWtOOfnwX/PmhdZIpJoc66/YbP5GZPiHduNn3CVPaOsYopqQjew/76X/Jpp+o5/x/+dyF9DIhkO/wlzEvacPhLBim/FiHFVEzoOf3O94Ef9Jv9pNORcvmYnf8CqahIpxUVSWjCJmOKYHjtOl1lhd4mbocf/fHPBx+E6noKP/B1OsphKG74Z2zP2dGFzjudlzbBK0RjWnQbj3LASOGgDaVUjBLhSclXFFOOQY3PJNus0lEOkm/yr2TM+U0/u9BHbbpNKG/6HixNymXKR2ISprgrwFJzHNffaLt9NtOUdiAjfuNxmFUOd0BYBO5HPi3i+nA4EzMqSuBIcm0s+8nf4Ph0T4SMRPBUf8KDtcpVqaiV5mc54LNo8CXu8TGdcFQ4P5T6vixH5rIsjrJL9u/qETtKjI+zu/V/f3ACws9wFx7rgsNViPnP4N6Nz9uQKk9qKPlcDj7YvuEwNua45Tiriyqbm/TA1e1nMaNMgJsPFdr4aq1x/M7fs61IbLsUNW9UuJUvkcmZoe5JP3Q43aU1S10uvtw2DabqSv7tO6TsBZVWz3vjoD1uEfRyGYkgmYh5i0yFSCnqiycDzmJUOI3wcJK6UTPUlq+ZDVuhyKYZIBK/0OQERnaWX9ZHa5kv9gjXuc60tCONtPkVj2DBbdwVxZZmONBYjakq2Vc+OatJ1FiJejo8LenrAumoxqTNC4TLWKfNU8lTd56qeE+LyWD/lRkwAONCPiISHKyVjAyfyhG29g4PHmmgxN3ZUBtixmOktDzsPXyjmBh6qDUuSES6jVNByHG7LjEQugD4GQyR7uFrRp0VORS0qlBDclhlt7B7hPEvxsZ33QkxJhcsn7gGv8owZCfe9PvvyMXGp2fGahI7gdVJwqFZtFqanWMn38HRAw3EolnCLyJEklR1DbQUhebbKumox0ruMGbEhnxCZJqfqO9pmlWvzilqsMxI3pCT8RB6SY8epTzoRr2YZq6bHKC/Zinx8BTdpTcP5x+i3WWGsJSctOWxEjBOPcWGpQb8blXhSkhthfdDskKnYWpjMjKGYshBTFC6PGk1WAsH/OLqmpXsM8whjrAJ4UlQctCyNaGA6HDZD8trwo36TuLQRgffENrNSc1Ok7AVNTrOYn7U2MQaEgPvs2UmENniO9WiOC3tRbJchU2EhCS+nIScLi1TdDiJmZcW9liJQ8HdXGY8aLQuJz1eWO3GHy9in71jk5Uo1YDPyOI2t4Kc2hoNGgBIB12mNUoLKGCZ1xkCEdDzJSWwTdw4ahrdaEDqK/6qzym1mC3/fV0ztmor9puDbie24V0PFZWKFVRJxB174ej6lKXwGeoUvyn/NPH2HEA5K+rxxvmCNB1Siomm6JOTc0w/ouz6VMaRVgYtDJHqsibZN8uIBt/oN682PMdQMnHvsuy2UEIQKnnTUned1I1SshfBiZr2m35UX/Ly5TVqDKyRH9Q3U4BOSlLfk5QQlAwLVwxdNJuaMUuY0TReBYlO1OdYFkbFTlB2nS7dq81a8wMVaSoZiyjYrDMSfcGuG/Dz8jFxrVrwtpnLIZfkcQ83UXGKMnZ5sND5hmL9EIPlV9T8jhORKHOLLJud5gz+KDngXp3yfJPg4vJtXDOUV9/V7bPoRt3lO2w34ZODwZm5Y07v0fIkSNjJwQzqsBuCpDTZCC6hIKsUw99hqOMSlggR2my5JZXjUcblIrCL3NqvxJNxmmlGZc78ZURu4TO3K6merPhuLPZLK+mp3VZ9/0V9nUkBUROS1fc43IsUTs03kSA5aEiVc4srm7EaOS9uFl9OKn3W7HM1LHjXtXlMs4OO+x0ViOAyb+KrFViQY5rZw7bBOqCQrssnAd+98xc/GGVuRZa0/UO07+17L6/LtNCZQkqYOSeua2thVjh8HPI7adD3JvDQ8CvqU2nqxF6VFwM4LjSclu2aFlqvYCFtcJCUNx9L8strQcl1OizllXrMXRhy0JP/q+oqpHNLVTdakfT1tV9L1PN7GGaWuKbXVU2yyhsHiewfL1KauZzPGd5uK28xeGiLnHxPi1nyfL/MT5nL0+5bW378IL7AsTGVczrhiYPpoLDPXGOwYVDTZ8CKOizkb4h4xKZXRdGkzqwrWWOFEnlBT4egtCu3T0QMyKkpRMhU37Ot7NKTHhRnhG9+KfnAtclL7XBifGsM4t/GBCzFhzWyxrbespWa52/sBdxkIFyHsKPU7+YyQNht6i74KeW5e4xqf+2IbX/vMhGYq5pQUYGBPbqC14Vyesq/3iaTLS/GOTb3JWy5silF9yXBhweYTOWZSjyllzqrewFVWGy3uLFU2/H3VdK3QjBpX+BS1tQNJY8U5vXqViorrPGNDdhjqhKzWNKXijb6iXbfYNA1sDqem57nMippt1rlhSlbX9gKjh7zHGpEjmVWCSWGFNZM6YyhvcY3PwHSX/j6Xi/obkmKIEwb0zQ5aaI7TmC3ZozTaHiSht3zAJReJDQJ/I95yb3HAp50O4yWvNV/agm6zioWYUugecWV41IosLMBxeV3dEJkmtaiYGkuReln+HT3vkJaxKtVJAffMAWfiCiWgMnCUzWmLAEfY8dFsGYtnMBwv6mVkm6A00HYlRW0vN5t+xNEiIzEFPRnS81xOs5i4dPCkIlTLDNplWMeB2CLTlsrzoN3i7yd2jKaEzT89jTXHXGCSTRYmpyV8Km0POxcHJQWzomDVCym04cOe4Pup4jTJ0cbhYRt+ubjhJ80NrtOKULgUWvNxX3EcWwIYKMa5tuPLhd2xjauMs1jR8yXDTPNuXrMWOjxfzNhpdvCVJKtS9uQK87rgzTzlVL7isX7KVEzY9X/MmzqmrBNqnTNO37ARPiJmTEP0CI2HJxTPqxPuy21SkRKZLjUl3/GSi+xL4uwM3+3T9DdYcx6TMF2ykQs2S0sv+npcMytLfrYa8N3Eqln3mor7+TodT9By4dhckouUiT7Hl03KKqYZbCOlS1zd0HE3MELT1avEckZDtxEC9tUKi8o6CwptdRYtM7DJXnXKgA4ZFR3lk9Utfld/x5reYlN1yHSCr1oEosMj84Q36ggCWFSXDPyHuAScp58jhcPZ/BcE7oCV8DH/r+lvyMspobdCrXMe8xdEom0/t9qw1wi5Tkv+7kozMXby1M0iMlNRUhPich573FQJL+aSjrLEOI1hURpexwsEglFuO9ebLMIYG9v3Ir/loVnhqkzoq5Cma5/Bqc5oChubeJwt2PYbAOS65psxGGOhOi3PJli1XPhFOeazYIW38+XlI5J8P1mK7hzBWKcMcwdPWYX1qMxRQvLFsGCsUyu6a3h8P625zK3HfS9scJxkjM2CAQMmRcl25HMTJ8xLl1lZ3glww8RFCrvXHWYVG74Vxv3d4hgv2aBjWozzmi/TK5RxeBwMMEZzkVgQyE2ZUmi73tpvebyeZRS1LWXfzWPWvZCOb8+nHa9FrQ2naUplAjKR8Jj7tDw7xl9UJaHjsSg1haloSBsk0XYdZlmOwCfXNeuhS20Er2Y187K+Wws9y6544K7xbXnKR/4OTVcSZBEazVwM/7BFOMJnRTR5ay7YMKt0XY+q1NzqBbpqUFHRMS2SuuZUvmJTH5KKlFU6vBJvWNUb9GWDjh4wEDbC7lJPmcsxtaltMdU7FNRUOuNWnvGh+PAOazmtbR5sz7RJTLkslnY8vOpEJHW1ZLNqek7AuMqWYxZ7Ew0rj/fMh9wysbdlXaOEy5Qr0nqdAI8tvcNCxKyYARfy4q6Ir+oNciq2/ZC9bIc5djR+Jd+xrvdRWBgJJXRkgDaGETG1MUzFHIXLpbhm1aywYMaMlDXZ4lrPSUxBd2nzWJCR1iVbTptJlZNSEmEB9RpDXmt+FG5xnKTMq4qckkprdGnxdKteSEMPqI1hUtc89tbsA+Up1nzLSNVoGsKjXMYrLkjpiSZP+Zgzdcl18AqBXL4vY3wZkuqCvmgQVzaerefZdKJzPebTxhpJvEXLdRjnmkVpdzJdT7HjutaHudjDlXZsWtSGWybcDzYYzdsMvIC2u8K72GJNr91N5owY8o7vkg5dEbET+bxLK87ymIOwiVcqDps+lYFfpe+4r7YxGJJK4wjLjN0IFcNcMMwr9lsurrTh7LtRwPPYjvjanmCbiLYr78LQe6LBJ80+X8+nbIYer+KCB40muTbsuR18Jej5zpIuJLnNtul4DtvKp+PZNKCVQHDYanM016x3ouXFpOJo4SIF7DV88tpwkUr+SWeT40XFXtPlPBasRw5fjAwdz5KmDhqav7my79tKoBBI4tql50siB1Qo+ekK/OrWsOU17zKRO1mL9chhRTu8jmOemg/QwtAyHZ5V/wFHhZR1Quit4MqQqbAjv+v6BUZZZOWVecGGWeNGHHGsx7TkBtfZc7JyjO9aYMHH8i8odc2fDB6iBNxr2QzguoZQCUJlfeN9XzLMNf8wnNEQHpHjcp1Z5Ks2hjU2eWU+517jnzDSJ/iyyQP9lAiXr/maqRxyqA+4EiMuqzn3gg6FVgjjsxl6HMW2iBRL2tuluOaJ2qXrK65jybbeIxAub/U1HdPF4yN+3FjjeJHzmPskYo9E5LR1SE5FGWY06OF7ISf6S4zReKqJK0OazgaL6pJX9T9Q65xXpqLtb7ORPOKhs0apBRMz5p+17nMeV6y5HsdpwlrgsxUpvpyc8oF4SNtbConilHmpOYwaXKY2HGQhFnwQduh4grgyJHLBerTOqHStNSbVjAuLflxbJhA1hGftUEWJLxWF1gTSXkgv4op7bYdn44JMJHhSMGjY1cC7eY2nBJU2zIqaTzt2JXY8nRMIl67j0/YkoSNwEkFW/xBJaMVZD9o2LSp0AuTC+v7/fCPgPIGD5b54v+kzyhw+6jsUS/pX6AhcKazgNC54z93hXTFh37Mq9Q/EOvtNybOxTbX6QVfyAz616zk0HesmEALezStuzZBdtcsos6PinYZiURoe+Da97BP2uMntCKnvOzjCetWVEBxG9gLT9SRfTBZs+hENV1Bnht8NM7IlGKZCQxFxf8m7n5UlTdMiqTRZZRiIFhe8Zl5e/l619fe2KEnsDel9d4ehmPK6umEqJtZ7KARtGnwrfkOpNQ/1ewC8720yNQkGzY7b5lYv2HG65Mbi4tpEbOgtBqZj05XkCGf5kiI6NkVHxDQd+yCs+T45NgN0Rw5wl8GJ87qkMDWXjFhZflAxGdd1TMOxD6VA0FIuGhtx11AOu2aLD/mECmvtCISLb+zfcWB2udZzuq5Hgb3BfZVdUpqaobxmT66wpx+SiAU1mu+qM2ZiTm0MTcfebZquomNaRKZNZJq0lU9gIkpRkJuavmjQEj5xVVmfNIqcnEBJXKFYU9ZmFeJRG8OozCk1tJTHXsOnJUIiYeMeL+QFtbZdQc9XuDjMyopASd6kc17kt+S6RiIpTM2qarJJn/fCAX3Xozaa+3Kbttwk1zMW9TW+bPOy+Bsu5BHfiGc8K04BqA18U1zwXrDKb5ILckq+rF/xOptwVc+pl+Hit1nNi8XiLn1nJZAMi5wdOaDnCzaD8E7BKYSgpCYXKbf5C6bZCdfynGMuKLXBNyF7QRMl7Gd7kVScxxUKS9W6znJqYwPuX88ystpOSwIl+X6a8Z9GQ8JlVqqPRWYezXNCJVHShjhkteGdOGNRana8FnGlCYXLuzhlVhgqY7jNS+LK8G5R83fXMb8xv2RclFymBWlleBPHnMWab8Y2btFaUCQ/WrGgha3IAhvy2tDzIKuN7YYMrASKuLTd7jDTpBXc5HIpYDL0fGtpCqSdPp0sNL8ezfnNEH4AwKfVkoHshXQ9YYt+aElnDeUwkjd31om6mjGaf402dgzdMgMaapWFGfKN+DWT9Iiv+HtKbTvmJgOycowxFY+j/4K16AP2woh/vt6h6cBZrPl+WtNyLUZ0I5KcpxlZbaP91kLJtt/AlfY7/g/TK3JKFJIz+ZZJ+o7L6lvyekZlci7lFbEu0KbiqXjAehAwEzdM5JiGIwmkYm5SbrPqbs2jMYTCpWN6DAJ1p0O4lle8Fq+RSDoywMHhi/mI++2ArufgCqt4dYS1EHXMKjUlj9x1WmqDPbO088g/4rG2e+pKp0TuKpvBx9wsnvO6/M/8y+n/jV/qX3BVfcu/m7/kb8q/4kU64Vi+ZV7WXKWaD8RDruo511lBqS2xKq4qfpuec8WYuK7YYgVtYJwbZoXhodjlPLagnELrJdjE0JI+11lB4AgGvrXbVUYvmxYLnii1VfSPc4MvJT3T42RRchbb0XVS14yLkg/7DmuhxVxepTWhcBn4LpsNh1mhqbS1m/lSsSg1H/d9y2qvDN9PE6a5JlwS6P7huuDdomAtlEzK0sYFBoqvRhV/fTNllJc2ZrBM7PdHTzDG0BeNpftBcJam/PubEYuq5Hte8+v8iHlp1znTouJNOuftvOavpqe8mZW8rq+55Zhv0yFZrZlUOV+OY+al5s2s4iKpGeYlc2ObmF8lx5yWM14nC0ptI1pvs4rX84KhmDArK2oD95sB78QZq25IS/oMZMSkzhjlmr7rc84tLRHSdm2inyclUjg40v+9auvv3QkrIamNFRc0TQOFJBAOUgrmdcGClNqUxBS0pE+qFbd5zqpqIuodKmmPiWGVci2veCT2kThkuma/6SPn69wwWRbEmr5eZTXwmGYel5VVWzYcxbk8An3ItmyypnucyHMm5pzP5E9xtcsor7jVC3KRwxLfdiROaJkupjJ0aXFpJqyaRyyaQAABAABJREFUDtuhz/NkjL8MnXgtXvNUPLLqbjNnx+kigXvuwP678bkUI+6ZAwJHktYZW2adQDp0xRZfm+8pdY/vqivWWCGuLEjkuip54G8yKWyiU4kFhOe6xhEST0rus8br+ppHrs3a7bq2Ow61y9zkvOGUB3KXN9kMB8nreEzHdMkpeBwM2DD3+G35kp5exSs6zMQCVysCrRiLEQMzoMZwLJ7zxHyKEoIbk1BnhgetgGlpd5mbyS5rYgslFNfigkyNSfUYJVwWwiWurQhiV66SVhplFPteF1Uo2iJgM7S3cVcKIkeyZiLSyiphT2Pb0ftScp0abnNL5godj8xYnGlPr7Lh/gveiOc0TBeAo3RBKfIlhEOTiQQhuigp+NDZRBvwpGJUp5gE2xlUhlu9QFUtnnYDnk2s8KI2mg87LUZ5TZJXDPOKAQ6vZxYs/1lwgECwElgc4UbocZkWLMqa6zomxGWn4XOV2tCJv3D+mNs8J6fii3mMz3KfFDnMCkvvejWr7eHnK97NbaSd9f0a/rerKX+x0uUqtfQfpeGgJTmJa0oDF6kVyhXa2k5cKUiBYa55my44CJusBBbt+UO61TC3moNZIdltCL6batZDxWYoeX0RMlCHjMUJuTvFkSEttcFR/gsAPGW7gVKnODKkLTfpmAFfp/8LV/JbWsEOi+ycS/OC9/gZfV8yyiHXdhKx1bC2mqedBj0PPulHDHxDqOyE4qO+4tuJoNTwfriKAJ6lN7yd/TUCSeD1cGXIbfwtquESioiWWKXQVjqzrvfQaIZZTVzbohsoyYHbIs3sCmrge8jCXnRsLnBFQ7cZiDYDz+Mit1Gq5/KSr6bWCjYTC0bykltcDswhczFCIJmUBR/J95mR8xP5l2Sm5J085lP+knPnkrE5seS0cI+4uMZVDQtBKd5wK94wy0742pkgpcu/qz7naf1fsiV7KBRd12VW1rRdl1obPnG3uEgzDlsBo6y+u1gdtCQNx+PfXixIyPmLwYDTuOazQcAvb2MetWzIxNtFTlo5d/5nV1qv8O/mt2yzwzC3aM7/41aLz4eahmvpW5muGXgek4Il0UvQ8+D7qWA1kEwKzSBQ9H3BKLcipv2mYjfSuDJgUsCfrUeUGoa5ZFpoZG01FHkNP14JuMns833QcnDiJlmtabk2O6DhKIqsxZOuw6y0z89VUtF3fX7cbjDwDcfx02USkn1XEl3i43BaLHjf32RYFPzT7hbGbAEQV4Zfxbe8562T1TZIZScMOfR95qX1i8/THqtOhJKCg5Z9jke59VP/pLnDL24sbOQ2q/iT8B4GCLW92ASF/e9G5DCa9kgoyGuPQEn2m4rXowGeiv6wRbg0tmP5jpdssstMzJiIK7pmnY/CDb7KZnTENnueVeDNC8mIOU/cFTJtMYvNKrgTP50xJpEL9tnmaJHd/T0NPE7lBY5xmBURHRExNylDMWWWpQSyicHuHF+KFzRNlx+Ln6GEYEN2yE3NtTxHIOmaHUZlzgYbrLohv6u/Y66vOeRjXCE5TTJWZBMlBC/MO1x8NIbNMEBkgtXA4evFmFzkrNOj47pclhbh+bIa4kqfvm7dJZU8FY/Q0pAw50SkbNXbxHXGfbXNbZ7TdT3e1gmu8Xmrb1BG0TYNIlzmOmdPrSyTQOyofk1aQEJNzYZe54044yN/j7f5lFTEyyCKikobflk9o2m6DOUVbuXQpklDuTzX74hME41hNwoYx0/whUPfd5hVPmOz4Dx2OGz5FiCBw/+XtT95kjTJ0zOxR1W/3XY3d/M13GNfMiKX2qurN6AHGEA4nBFCSApFSP5ZPM2BB4pQhBxSCCEHwACD7kYv1bVX7hmZkbG7h+9mbvu3qyoPauktPLEPlZc6lGSkh7l9n6r+9H2fZ0HNpTymY/o01Q+YihGj+hU97wZv5OtrccRtfQsPj1IbHjU6vFwueJ1WbPgxl1V2bZEpbE0vTBjEkn6VMKscUOLlsialAGIaImDMmF02WdiCzIx5rY8IVJOZ2qJlXf/5QmerVLvgrHTj6cq4rl9bNHlWXlDlzrgV4lMYzUWm3CjJhgRScbKsSXXNyM4ITY/Xy3TVOyzoBJJ+KMg0POr6mNVC2PAlUgt8ofjsqlj1WzMC7XMz7KCEG/e/q6eUtaZRuspHw5c87inOc8hXIIHauMTw11PLQDV4NqkJlBPcP1qz/M2Zq2M9m6bcbsXk2rI0Je+WrqLlQjyWSPjsJKuxdMPJCWIFvTDg60nOaQpN3ydSkllpaXiCTbtG39/mXbnNq0bCKHvGm+l/wdoSITziYJNWuIsUPsbWvJ7/DWvJPdYbj5gWh9wKf8ZFo8E+HzASIz6ZCL7XbXGVuxf/ycr29K/727yYuRfv35/V/GTg8/RKM6vcxmZWue/5r82vGOevaMX7LPMzEtXnKntBEg64aR+xrhJemhO0NXxcvqFNFw/FL/WvWeeAHbFOrg3CgBYaaQXPczdV2vcCdlXAeOGc5B3PpzauxzoIQ/xil3w15erbDic8oykGRNIjt1N84YKAG5HP6XJKjE9BhVw5zJeMiUWPnh1wTz7gMp5wzksi2+R70X/LQszpNHaZ6mPmxTFVveA0esGX6TM8FfNOPmSuz6hMxsB/SCdzgdVuHjCsct5UGeuixaRw3mqL5UK+43+6yujaNpeFT0HNm0XB/U5EaTXSCELhESvFpCqJlcee1yXX+lry8NenhdO1Vg2nAPX8605uL/DRFr4YF04xW3k8s4d86N1kXjmJwVkGp6lhVklezHLe60Zc5PD1dInGcL/Z5CxPuRRj/MLncbxBri0v5jmPOg1GZcnIztgoV3hg1eR2K+bp2G0S2oFCCUFhDGkNWxErhKQlqw2+cCHQfhAwLAqGhSPqnSwDGr7k+XLO/UaLnm2z31QMcxdQPc3d1WZL+ZzWC96Ir1D1h+SURPMuz7MJJRX73hqFVryxJxxlPg2bcLF0XupFXdH0fJa6ZlKVbnpHRYKjyo3liOFoly0GfG5/8YddhAOhkDaiZe8QKcU6CVfa9VeNhW3WiOQGpbF8Ub/BSsOW2eJFPqGmxhYtjuUJCp8KTV+06Zomb+QR+3aP9TCkKlo0lE9sEodyNBW+UBwEHeZ1zdKWzJCUVPhC8iHv4StnjPm8fnWdjn6fBxyaIV0VMdMFM7Ggb2O+rx7yMaCM4tiOyGRKz/RpENCgjRYajXtxjOwMvTD/PwuwWL38M5Fyz96l5XlMTMl+EvM6XbIbh+TaslnskYqUgopcpByaiiYNTGUJRYxvfbaVo9z0AxdiucqXhFJSGXhjTzHCIOlwu9HgF5kTOjz291lUK8b1Sj03kC1iTxDWCeu2D7ZPR7kwwUwXHIhdYk/xrp7wZpnSIOKCMXGxvuogu8/6KjdUxlJQ0yRiR95DC7frPDOvuKl+yJRL5vqMPfk+F7xmYXe4G3XRxjF4d6OEszyn6Uty7TZegRIsK0XsuS6tAUaFowI9ajd4NXfasYby2NObrIU+RV7zkfgzjoIjMmYIJH27xmm9QKPp2C6TuuB+o8XT5ZQfdbvk2vLzxRs3Uvc9pqUb3Z2VKee5E9MfphnvdRpktaVhJPMs4mYrIPECljXcbIb4q25mL3CL76w0vBXHRNU+d+IWtbVUBhKrCFRjdefudsWlsfxxr48U8HpWs5ko7rQcxzeQsN5wIAJXMbHXUJGHnYh2AC9mGm0VD7qSs9Ryqxm7n9WTfD9pcbNhebkQnKbODpNIj8vc+V9z7WhBuSfYSwQt3+d2SzEt7bViclHBThxxoylR8yYXZZ86usnYvMDYmlovyKsRG/EjcjPDWoMxJZPsNcaUREGfVMz4AX+KwaLosKSkE7ie5Lh091vNcpPSuFOVBS4zd8qQAo7tiJ82d3gxM7w0J+7EK0PS4oLQ71CaBRvJI2LahMbp5OblFR+GN4jKGxyJIQbDtr3LGi0umbJjewz1gpF8R9e2WJdNnvGST+eGm2GHuZhSi5qW3kMJcc0+7/o+L8s5d8M1lrWmYdfZMFvk1MSyx7rZ4a08xCxvsC5aLG3JpTyjY/oU1Dy2TzhnzF1/gBLwvDrnT72f8W11zpbX4rXOEUj25PucxwmT/A2pHrEW36Mh+lxU32BMhZQ+E33E2+znSOkxlT/lfe8es3pJaTVWg1/7vNdu0lg8JF0FnO63Y76dwdKW9MOIf72T8PHITURqazmrc5601mj68OthzVooaPsCpgEt7bGVeHQD9918H1c5BFjUoJYhx8WSgR+yk28xKgs+XEsYF5bKGKRwHO4P1yJmqxzEXhzzRX5OL2zxk6jBXw1zftBeYxC5KYi2Dc4zy5NuzFYccbQU/JvdNh+P3Eh7ECvOMsuNhmJRu+uNYa65KuAn65KTTDIuBReZRawEM4FU3G+H5Dp2TYi8IhEBny2H9ERzNSWD2FNcFYIru+T7nT5PVBdj/5hZ5TaOsScI8VmIObl2pqaH6gb9SKEt3G4JfjesiJXHVuxxlsHjns/LmaYXSlq+oOk1+M1lk4NOwEWmofynra3/5EX4HefcUTsc6wlNHV+Tn4y1jIqSd5xTmIx+PcAXIRu2R0F9vXtoewG9uk8m3Km3sk4AsG/38IXkrMgoqJhoiIjxkBTUjJhyXFVsM2AQJHxbndHnCe/qKVN5Ra0rQhuTiilbbFEYzVroMy1HCC1p0+BKnLGpe7R8H4FkKM8YmG0iG1+Hnto0YIXWO03d2DhAXQMwfN1iqSvG8oJdc5OG5/2je7fQnMsLRLrJRhAT4jEUM3q2TWLXOZYnq7vmkkJk9KzzDns4p+ppWqNwmriBbHNH7nCkrzDCclXU9Eyfba95bdupqJzMQkhOzBjyHgbNWMy45w2Y1/V1iKDt+0yqkvfiPp504YvP8vmKBQsTFlQ65ql9R9v2aNJgRkpi/GvF4mO+B0BoQ6b2iJfVPxCoJlq4FOdcTOnbNQLh8HaVibnZCni7KFmLfAaR4ptpTjfwmVWuK3mRV8xKSy/wCaRgVmkGUcCNpuTXpTNU7Zo9LsQlZ+Ybfl1+Tie6waI8pxXssM4+3WKXiorPJwtuJgkd2yM3mi3P511eUFc+NYauiphrxy2OFFxmhtgTXMhT0rrNs1lOS/koKYiU4POJE6D/+WaDWQk902dJRdMq2r7k6/mC3SjhOHeg9r5p8fn8ioSQrHZXG+uRxzA3LCp3B5xryzB3CelPrwxv8wUZOY+iDT6ZzPnzQYvKQNuHi9xSGsuTngutfH7lDDyVcb7lrHZErKFOmSwlB3GDxBOrO0TDshJoYznPDP1IYpBc5Zq0FozLCosLtih8DnifpX9OWc1Jwm2y8pLTxcdEQY9aOzFKHPSZZ0fcCn9Gx/R41I34apoxtTm7fpPnM01l4KCp+GyccasZ8fWkoBt4pLXhQcenNI74ts0a//l8xnPxGSfTfyAOtjG24nbznzHSr5HCR+Ezt5cocUChDQLJ1/klbRr0aDMUI3bkgNw4eFDfttlULV7qhdscCMFtc4sxC5a1dpMga+hFPsOi5Fv7lg+82w4sQcSkrJjbghscMBFzurgxYiUc1vZIHnGPW/RVzBuTksqQtmlwzBCL40kfyUMe2Ud8U51yINwJrxIFt+0tABL7PoTvcyIdIOh9dYucu0xNzliMycSSIpiRFpfUFPxS/wOBbPKseImnYjfeLRO2xH36dOmokKx2KM2toMG3Uzeub/mSN8tVSlm0+Gbq3renXNCa7VIaQ2rcu2Ex82j5Pv1Qsqzd4eM0rUiUQkloiICWL+iGDX4/veLtPKAXOob9Sepc3uuROzkPV4aopm1wmhpGRcW6bHKyrBkXkm7g/huVsSwrt3ha4OkEXuVT1mSDrHY0q3rc50E3wBOCYeFOr3996vI8LV+tpBkeg1gyLiR/NznnB80BV4XjUHd9nzZrXJYZX45zPCFZmJKckp5o8PFVhkRQWU1LBXxhn/F++oCRuKJlO0gp2G8E/HxxyPqiz4wlb5ZumrjmRXw9X3AlpiyHfZ7yGXeLx9xtNPk6r1iYkmXl8bac0JG7f9hFuGd7DHXKO/ENLbHB9717vC2njMjp2w61rPFtyLps0jSR2yGLiEnt7svaBO4XLyZsscbUpkSrvm0gJXNTkKx6sm6ZcVBytDt9Wixvywn1CiFXUzMyb9gS9+nZHksxYU5KTIezPL/uFhfU3DMPmJByVVpqWSCQaDRjOSKxTQIaZLaioKJpA3eXgfvlDWKfZ9k5vvYwWBLbBtx9i8KNTYSAm2aXl/INYXVzpVPcRwhBKBTKerSJqTHEJsQXiq4KWeqaL+Yz94Wgdp3r0HccZ7FGKCXTqiJA0Q0Vvoy5qkqwERtBxLLWSCuJPYWsHRlsUjmIxbm84Ik6YF5VdDx/5fx05f8tsUbDc3+fZ/o1P1E/ZKydH7aiZMtuMDQLdrw2pTHEnmJU5lSiZM27Tcf0SeWCF/o3PBI/45bcZqYLFG43Ga5MSN3AYxAJfj3M6Hg+3UDSDlxAqR+5CcowN/jShUzS2gDyOgXrIalEQVHP6Ef3yM0UY2sEkrm44rUOCHGf5zCvmYspc2C0iBjJE/bNHXaCJi/LIVuyS2VduKQTSkptuWkPeLacse03GFY5+7HrU96IE5q+4HDh+obn8h3fVw/phRILRMJnM1ashS3eLkqeLWeEONjFth1wI4lo+4KzLKcfhlzklrYvWFaWV3M3hr0dt+iHHdYjyIYx88qliWcVLCu3CBdacp7DuKzoBq5jepZZ3usFDCLLetThk6uM+x3Jq7mlF0q2YhiXcJpamr6k7eMS40ZxqyX4+XnFrZakH1g+OfboiSY3g5/y2v4CbQq22t/nf5n8OedZRbOhKLXlt+ZT/iz47zhoBnw+m7GsLXeaEUJEDHPDk55LRH871ewnEduxIK99uqHkgy68XHD9zGS24mt+zdXiOZ5qrxb5dTJmtNQW2+aA2mjaJERKcVhN2eaAK3mJtYZNehQiI5AS8Lhnb19v7u7zAxeulNJNmUSL5/YIJHjW4zR3U5+e7XNUOh7BQLYAKGzJmbzkR/4DstohL1Mx4yYHVLZyNSMreWDfcyPets/vZwVrooGUgp7Z4IIpPj6xr/i6PmbP3MCXkm94zkfqIb4U9OvHLExJEAhOq4yKmn3hIDlLf0Q3OKC2BQPucmXf0Qw2uW0/4qn5O3I94Wnx74iDPsqE3DAfEhAR1IoLU1KiOQhb3G/HTIqQaekc1mdZyR6b3O14vJrVHLTcNKg2bpPfbCragSCtoe17dFfPx1XhQpgvZxn+aqloeIIH7YRF5ZLUvQAOFy6p3fV9LuUlfqZIpM+xHbFpezSFcurQUOIb924Yl5a7LfifTzL+ZG2NaWkZ5Zr3wk1C5e6S1yNFJ4hpB276UxvLUb6kJUNAcZG5KdRtv3/N4Zer2uIggo+HEb1QEXmCrPapTbK6xxW8nGms9THAernNFRl91sgoqazhItMueyAm7LDOGVe0bRMp4JV8xod8QCfwWOQP2Q4T1AozOs9KYk/QJubIjv+wi7BCMhETapsT4qDXCzGnY7tsRRHkWyzImdqcnaBB2wRMasdZPpVvKeotNkSHKT4L6xbCsZgxtBXN2snNj+Uhj8V9ZjrFx+dL+xxfhsQ24VK43p3RFVM5IbARu+IxiXW71toWTOQlDRNzJF/jE/KeuMNQO77nvWAdTwrWigYTm7IUKcp6bIs1Wp7HeTUmss55XBrXm01NxUlqSGgT4tEPIjpVRNP3GJUFFsORvuJ+uM5lndKzG/Qj19k1WG4mMa+WSxdqIkehiPEJhZNlSwRf6o/Z4va1wzMqb7AV+3xaHLJTbxJIt/P8fXrK43CTlvI5qTMavuSqKnmS9CmNpWHaxERsRhGjoiS0sesWr/yop5nr+FkMLRHS9CXfZGP+JPgRDV/SWXYJbMS9YJ12IHm9gMs6pSVDh6SUHnfUBvO6x4ycwPiU6gZf1n9Llg8J/S7fV/+SSPi8Wi7Zjx1sfVJCP3AnL4DTtGIjcpxlT7KSeFsi5SD+l7ml7QWYuueqXGYbFfpM7RnL0o0sQ9FkXL9FexVK+LyxC7J6zE31QwqRcW6/osWAvhdzVi4dHceUdFXEy3lJKN2YfMiEddFlPVKcV4ZvsjE+Ho9bbV7NC/qhz1E5JRINDqspz2buLu5b8THPpm5c2RNNbkZOCLBlN0iUx7IyVEbQDXwOmoIvx6660PDdybYXOrynFHCRu2DMu6Vrkyvh0tSv5oamZ3leus/Gl4KXM8N+U/KXl1ccBB3e6yl245CLHC6yirttF+abFC4hPS0N2rqAGcBv0nMkkotsmzdzyy25jbaWJROk8HgU/QsGdNhKBONCsttQVAbk8iM8KdiKBZ/O3N1cWru7O1/C0dISSsFFmZLVIZl2i7e28MtLycvlgh/3mxhrmYg5o/nXAPSbj9gWjxjyloCEfXOT3SjhVT7jTFzwPf+AY11zLg9p2w16tu2Cn7bH0tashwFv8jmJdkabobzgobjJTsPj6fSIfbb50+Q2XyzGGOz1xrUwNQPV4EIvr6+8dlUXqeV1vUfh8768S2kMiUlWohHFu3KBMpLPZzNSsWDBjKZp0yC6dhgHUnDX3qZC88ae0MHd9VbGXbFVaC7ywm0ycSN6gyESbXxCduyuYwhwC4l0EznvMXe5wdf+C87Lr5hlh3wjzthsfMBni09pRjtoU/CNidkt38dgeOzvo1eu23U/4vXcBWvzudtYX64UsD+/WvBeo8dl7qpAwwJn0hIep6lLE7eEy3mks4CW53FZ5jxoJ/zNWU7X9xlEAadZzs8at6mMo8tF9cY1FOTp2H0Hj1JnL9oIIs59l0j/9GolJYli90xkFQ1PsZ0ovprPeCwdSS7xJJskXFYZ0yxnXSUr97Pm3dLSD53NKtKWYS6Y64rT5YKf9rq8y2uO9QQtap4YF9bKtF6dmmNXAaUmFQtiG/Bb8xWJ6JCYJutRQJE72cxllfFQPGa74YAqPRkzKSuGhUPofmfY6voBtv5HhO4fZBGOhEdsY7bEfVrW3dFe8hrELT4uh8QiYSpGbJo95nXNhZmxJTtgICShQYwvJA3TpilCtDWwMgf5KMZi5v5dSiSSuZgyMDsMVAOEA0wYLFYZbrLN0C5o0SZRHqd6xl37GGFdzaVnB27HbDWpSLnrD0i1ZllWqzG6xy7reMJxcQdel6RMGMkhuc7YFX12WSenpuX7rJUdTuQZfrWLtobzKuVEvmPDbDEQHXwpCFdQkVI7WlQHj9pYmjKgMi06MmJuCiYs6duWc9d6gj/iJ+RGY6zlNnuc6znlssENtgmUq3LkIsNgrsc2G6rJWiiojbuD7oWS3arHp/ZzkuIxqS3x8Yk8yVqk+Hw+Zk02aIuIF+IVmC3SLKQjEv6h/j03yvu0RcSCJfFK7t30fPoyJPYElfGZrkAfldXcilqc5BmZnbLlPaLyChc+IQXrNGQWd+LbjBXdQDLMNc/zKQdBly+XV9yNugDEStINBTozXOQlgQxItePjZrXziI7KIbv2PlvRbaZiREnKH3v/igszw8dnKM9AwUJMSO2YUDbZNHuUGD7stJmVhtO8oOkrlrXmTTXmp8kGKvfwpcQAt+Im53nJyM4duN2W6NzQFQlN68hXP+30+evpW9L6ii3vPvejNfLa8rQ4R+Hho1yxP/H4eD7kTrDGsHBqxbkuaZUB9zo+R6VmEMvru7Tv9x1RaFlDrmE/0Xwxhi8ngn4oeT2vEL5kVml+O3RGo14omZROWdfw3J3XpDRsxpL1SLCVKHLtTtWeENxoejz29ngx1Sxrd488qwS/Nb/Gonns/wueNNZo+oLd2HC8dPKHXLuXn8Wdwp80O7QD93MdLS2xp/hyOudW0qAlQzqBxw/XBb8dmhUEomTNi1DC0Z2+Wv47PJXwXvK/4I3+HWuyQ5sn9ETMZsOn5QuyusmVucRi2VU9PO2xJtx7oLIaKwybUYC2sOk1yI1eTZMKCqPJtUculni40eyW1yLXmquqpKV8WKXMA60oqFnzQiZV6cQytmauCyLR4Kp2esjF0kMIF6bzkCgh2PGbbJoGlTVuAqVz1oQbUb/J57REyCCMaNV7HOkrnuszZ6mqHce+F4RoY4m9xrV0/shW3JG7JIFaTbxgKsakLGiaNs1Q8T1zn0NvE9/zGEpnrurEBwCUZk7T3+Kb5X8iCQcc6y/oejf4s/hDYk/w68Wpy6PIDiflgt6qqtYkYCcRgNs0ficSmZWWRaV5r9Hj6+WUg7BFw3M1PyUkiSeIlaITSiIlWI8cXKS2gsSDceFcu19e1fQjRcMT3GlGTErDVqxIa0sg3UK87occ5UsUkjuNBsO85qoQPGm3SDyHodxKJK/nloySBJffKLXlw7WQrIbK4tQbAs4yzZof8MN2zKiw7hqVGM9KgtVB68O1iLdzTS8IeVfOGagGe8rRCKPsCZtRQGksd9qS81ySKMWtVotRrrnRECxqQcMPuMo1D7seF7nlTttjXjnzWWkWf9hFeGjn+PhUokRbF6s/KN+nEiV35Q6HtYPDx/gMzYJKVOSm5q18S2Lb7EdNhkXpTsM2Zc9vM6mWhMS8lW/ZMruEeLRUQK5LWrZDW0Qc6wkeig3VZKYLFnbE3G6xFCkTMeZ9dZMd0SZS7l75QaPNvPrH+9Me7oU1zCyDMOJZecGDYEAvlPz14gW3xA20dT9317hU7dw6mlVfJnQDyYtqwZbZpOWvEHIF9I0DfJRWMylrNoKIUVkwr2uUFlyZJR3hxl8GV5d5YX/Drnyf1IZ0V7UoKaAXuLuq57ymxwbPxDMABnqPfb9DpGMqKpq4hXw3bPB2oa//jlkd8dIc0xA9hkx4P97kInd3vr+bXzCXY/bUXdqBoljuO4KTNhyaIRv2BgGKt+IY34acZSVNz+O8XrLpNVBG8nVxwaNwgEAwrmc0Kp91P0JWH5Haghf8nqvlM2bqiG58251Oiza3zV2+nGhGdkZftPmotUbDE7wr3d0qwKR0vWZjuZYgdHyfysCkcjq40DrB/Ja/xkFzm6eTgtutkOU0oiEDCtMjlwvu2du845wT/ZRPyv/RsYHnP+bYjmjbJovK49AM6dNBW8tf9Dc4TQ2Hi4L9Zkjb9xmXksNF6U7R9ZzQ+lyKIR3b4++np0zEOYm3RkXBb8vn3LY3CW2IQLLmRe6EnWn6osXrckKc97jV8plVHsZaTlJnZbnIHAXr60nFjzd8vp0azrKSu+2I310psrqkH0oGMRynzrn7w3Wfvz/XbDc8bjUtbxbQ8Nzpea/hAiQd3430K+MCKQ1P8M0859245GHS5XZb8fWkohO4hOeH/IiZzdkPWgTSBdL+8sRdEXySnbAQEw7MAU+6Df6n2TfsmF0C4ZFIj8oanvINuZgxT+/zR51NYgWHS7e5OksdV3tsxwTzPX6t/xIlQ5QKmIhz1r27XNoh7/v7aGv5ZjkjEQESQcO2MRYedAIurwSl1SjhjG2RdQL5li95nrtcxiD2GS53aK6gMT4hI5Oy7TVZ6poThnwQ7qz0kQkbsSJQCbNS0w4UoYr4VfkNG2aLrkhIibC4U/9GEDOvqtXGJyRSCmstUoA10AgkTd/dy3fKbd6VCzzhRrqVNWih2bA9hsUql4DHqHSHik3p3n83zD5bDFw+pkwZBAlVqXnf3+d5OUSLmhfFFVrUpHJBYpvkLFD4dNUN53kPGkyZMPdPSLw+tc1Z6Av+Y/Y3DJdP8WSEkiFvwi2U8Llvvu8Yz+0mL2aaV8WE47TB1Kbci7tMy5ojO+Rq2VypTdtk2jC3BTejFpPCMeaH2T/W7iZVyXYUMi4gWqk6X+tLytTpYFuewz++nJfuUOa5dkUgxXWQ9ruK3dNsxH7VI1AOELKsfbJa81FrjVnp/p2X2ZzmskU3lLyc5ayFPpPCyRyUcGHH+x3FXubY1N+5iQF+M1o4Na5yQKShTrnpt3iTplyIS6Jyj06g+B+GL4lFQlU1aVYNFpXm6QQC6WpwSjgE6afzK9rzmLutmIediM+m7T/sIlyJioZ1R20fj1gJ9v0OxsJcV1SiIiBmO4rxZczzdI7B4hPioXiej52fVIxp0+JVNWIkT2iae9xYuWNzoymMxsfjSL5Gmptcync8tI94bU5ZyAk3zSNmYuGgE2SclUv6Xszvq+cYafCW7j5xLkc0bZctu8HJsnJuViHZFmucFimnBawzYElJntVMxZxULHgkb9INFG/SlGe8YrzYJiLG4k64xrpFFeBUnrJrdmh4TgKhhAMILLVzF8dKOYdnecHArnNb/JCUBTOxIKp8cltxI2rgS9hNQvRynwrNgbnt9JC++yWmIqVrWwyikMtCONpN5HCMBvegN20bYw1dGs59CqRacy9YR8l1JmVN07orgF2ZECtFM2swEwtaMmRp3H8r8hSXVeaqSnVFezVe+U7Dtif7zkplIZIeb3jNrn1Mo73OVfUabQtacsBNc4uvxaf8RfhHdLRDUNYGRrkLvC1ry6tsvvosWwxixefFkB+Fu8Se4PPpjBtRg/VIwazPrXbI23nJScoq8GO5ElMG3jZxGfEhH+ApQbNuMcuOMLZmWhwyDN5jKA4ZSQn6IZuix6m4wpuvNgE25XbU4av5jA0vYV02kbiO85ppYKwlsgkBitC2uBTwAT8BoCE9B06wASkFp/WCRh2wHUec1CkftdYYZs7kUhr30n7YUfzdeUE/DLjfNrxc1Pzi3I0pbzUStmL4dFRTW8NZVtOP3P1zaSzjEvqhzy+n55ynfdIV6OSnGyHbsWVYCK5KyY245unM4zwzHDQl+3FCw28QSsG7pWEQe2S15YIx26yxrhKavjtBJ56rUf1ifkrPtunaljtlGsu/aD7g6WxBPwi41VI8n9bcqG5RUHE36pLVli+nC+43m2hr+eG6oDtv82IW8FfF37IozpDCZyt8n8vqW2543+M97wbnq81kjNP4RUqgly1X+VrCmTzirrmHtoaa2t2/lym+TFAoGp7iMq+cu7yumdmcBm0kDlaysAVSSN7kcwpK+sIxrgWCuSloa4U2UJIykhfsqbuUlXseSmNd2pk1xoVhpguOdcoNtcahGTIWF9wr7rOwBVMx5rbYpSdj5qbAN4oKzVRektiE3Sjm8/yMm3KDlgp4Yy7ZVwmP6rv0Yo95pVffqwBtHIY1VIIbam1V23GEuIHZ5GGzxbeLJpFw13shHrtxTKmbpOIxiW2BgLm8wiOkjlNqWxKpLtP8DcbUfOyf46mYV4sdOnaDJi0CKfG184P3w4BBtU3iCd4tY3zpJjU/6HbQFiaFoeG7U/B7XXiXCnpVxEXmCHAXmUYbS9M22Ex8TrOSZa05aAU8m6aEfsDtluLTq4pNz+NBHPDl2PCk5/N6bmjX7hCzFXu811VsRoZIBfzt1SVbskMgJfeSFrPSXdM86ka8mlX8s22PT0aWbiiZFIZlBW1fcavlJjrfWxN8OYHYCxnljvJ3EHSvyVVrXsRI++w0PEoN/033DrPSXk+GBrHvxu2ewK8tW4ngOLW831hz6NZc86ebipuTx3/YRXibNTwpmZs2Hg7z96V+e13x8fHRVGhr+TodooWmI/p8P7jJt/kVPo5Ks2Y7uPyj4gpHpxmLGWNj0VTsiy0WLDkwt+l5EYl+yBlX3Fe7GHb4lf0VP1U/peEpCj3gM15AvUMkmuyyTifw2VY7ZPWWA91HHidZToBilGfMxIJ7/oBJVXIraXCRVxhrGVKybgZYAZ9kZxTSjYC/G5U36XG4zFgPXRDovbjHadYgUK6eYrAkQjHVBRZLQwYuSFAvqGTpHMKiwyu7oGfbtDyfqta8yqfcjjpMyopLMWGbtesqRFlVhITsq3Uu9YKromJhCywhF5kjx3zNC26ZmzSJWJBzd9UrHdk5sQ1RWpBXmkgqLvKK2EZcFC5EteEl9ImxFqZyxI7ZxROCJTla1PRsG18K7ngbXGQ1/dBDIvjUfslD84j3uhGHkxb/vLPD7ydN1rwtvi3/jqF5wan+jHa4y8/Lz/hIPMFg8STEnoTMjap/3Ovwalax21DMK0vbtpgUmjfLgq3A1X/y2jI1OZ9Ocx633IvxKtdc5BlrdLgsM/643+EsNfwuf8uu2OInyf+OhVhyU25wqmc0hbuTeyO/Zd3uUoiMb3nBTXOLpUg5yj32gibz2tGVTvWMB0HPEZm0+x34KCLpEdLEF5IrsyRfgRGaIqSiZCoWaLPGMnPjMmvhXsfj3dLQ8CRKwr+9OOVRNOAs07yYaRa2oKEaPGg67eGXY03sSYZVTUf6fDYqudsO0ALOUoflHIgOl1XGhh+zHikSz3IjrvgPJyVNGfB14OFLx2oeFrjvf6FYD10S/av5jFSk5GJJJDf4s02Ps9wBNNwdcsU2a2hh+Vp8wYF5QKljthNBz4vYihWnqSHXhhtRg0m5IrMtl4CTY8xKw//rXcpz8RktscEkfUUUrNHx9yhJeaD+lD4t3lUzliIlFTMecIdxWTE1OTE+U10QqZiaglh5DiZjYo7zlET6fFy+AQmdKuLCTmnT4KAZokR4jUjthJJJ5ZNZxV7Q5Ff15/TsQ7S1HOcpPt8xwxfc4SEzlhybBVfyknu4YKPBcMKQRdZiTcVcmSmpqTnlBQ/MR6SUNAh4lNzkqqgZ1a7pIQgZBAkDnrCsa2alI8IFSlIZh5B9mo3Ykh2+zka0SVjznXhjVGdEwqc0lufmHYNsg6YMaNsOHRlds8YPOQUB3wsPHA3KFAzYISLgufgSj5C27ZGoj+jbLon0+U2kmeVHLPJjQr/LeP4lUiUEXpu1+B5LfcnnU7c03FY/AuCW2uA4K+gHAf9+9hRNxYG5vap/dghUQlZbRrkDqAxzR1Jc6oqbcZOLvGJpSgZBwqw0DKKQysDbhUbgTpW+dJviSRkhBaz5IZuJx7K2/HYy42GjTTeEn3U3Vqfckl7ocZwVnKaOyb6bhCxrQagcpnY9klwVhtpavpk4VObTynBZZezHDS6KgrFdsLAz+mbd2e9YI7Qhn86m9GTMeebe70vj3uMLckoq7ofraAvlwukbp6UmVJJUa/7Tib4WwPzBFuGW73NWLq/VXqWxbJoBJZoZGV2aVDam1JaB6LC0JVII3uYLtlWHoU5ZDwM+L4Z4OEfud13XTXpESvGFeU666tQqnKKrKUJCG/KunlKIglA0WdQuQPDGnhDR5EbU4M4KunGY5oS1Sy03fXXtML0wM96L+wyLkEVdsxlFvElTNIYNL6EwGb513GVlFT+ObjGrNEtbM6BH1w+YVxXLWjOyc1pVjwediGfTnHmlud1o8Gq5xBcOpTezzg+8EzQZ1UO0NewmIcNlh0h4jOqM99pNns4sL/IJHeGMMJGn2A1bHGeGP+9t8nxaMtFOF7mbhHQqn+PMReyXlGywRSAViVLMqpRP52PeyRd0xSZ3/DXWIslp6pzHiacoywiJ4FbLvagu8pJbzZC+ecCnywu2ZcKdYI1UO0a0FDCv69Vd6Rq+FPyZ9yFfZyP+7fQZVhh+P+k5G5VV/Mj/bziSh4zlW4w1lKRMTcG9ZoNICZ5OUjb82N0zWnjY9Xm70PhSsK4SIk+wH7h+bDtQdAJJtYjpBR6JEvx+MuNRq8W7KqcQBXe8DT4epayHIVrULEzBrahFsKqObas270drTEvNy/qSsbjgePlbdho/4Hf6P+PLmNveX9AOJPMaCqupRMll7sbya35AWTrMaqQkYe1CHB2RkFsHiH9XztmWayjRX3mROw6EX2hyLfjjATydOq3fnuzjCcFaJGm0Ff9wWbo0fEPw9+cFe42AQAqyOsIAH/UDDheGViCd8GBZspOENP2IhgeRgndLOFwGPGy5mtXxsuKwviIXKf9t4xaBdM/DRuzuaN9rtvmb9JQds8vY5JxkLXZiy+dj96ISAm40Qv4mfcY/D39IJ5CcZ5pbSuEJwe2WZVJKSqPYjBWjouLL5ZV7Pq3bfESe4F7Y4lXqc1p+ge81SIsLuv4+XbvFrWCNs3JJREBiQ3zW2UoCeqFgXARcFTW51pyXGQc8YEaBzZ2woKLmRpjQNjd5Vl4QKcVDb51X+ZS3C4+RnbOtOrR9BzW5Yk5rVTt6ZB1S9zv944Ql1VLzfqfFF9O5e4+hUdbjiCGxjejSRq2uG3YaHqfTkG4Q8KT8ASMxZU/2OdVT3mWnhDZGCkFiE27ECftNydfjmrkpWFMxvg0ZlTlbUcRa3XGNDk/xSPUZFRWhkmzEircLS2mcOvGxv482Dsk6WjpQxUKXjliIZJsBhTbsNwLOMslS14RCsWvuUVs3eo1XbmhtLdviEV4ckfojQtWmGW4zSV8jUMzLEzbDx1xW37LIT/hKDQF4G27TUBvcKx7RY4MnSZ+LvGI/3ERby+myRgpY6opeENIJJBuRoJU5pnovDDhPFYVxaMtO4Fzh1jrCXeJBaWAh5ryZNyms5k4zIq8tx2nBUF4wKhLOM0ttDWuhz1bsM8oNDeUxqwy3miFNX3CWuY1gZQxtX7GbCD4eOkDPehzxOl1yK2nQ9CW+jPggjPkvV4YYnx90dvh8suDDxjrHacGjbkgvgFdzy6tlxXoYcjdwAd7voD/7zYjd2GkmL3KLEj6JJ5jO1/6wi7Av4US+Y6F7PIk2mVcad4UP+36HaV1xLE64ME7154uANRGzEEumZkJAxLiskEgykbKOS+PK1Z/xiXGGo44KEQLe1RM+aKxzkVWMxDm3zE0C0SQ0IVfMeRJuQLHDhZnhCbeLH5bV9WI5NClbonUNe/cLxWf5GQN6+MKNUG43GrxcLliPFf35AI1hEPsUaZuTLKfGMBYz2rbJqHRJt9f2iHUGKCH4ZDIjxMMTHpNCk0ifXuAzzhcM6JGbmm0/YKfcoheEVN+14YFHrSaXmeZKTHnP36YylhY9NhPFsrJsmj0+Hs9RSBIR0A99jtOCbuD6ct+lznfNTUqjaXkeuUjp2zX2zF0mcsxZmaJtzHbi8XyWUVnFIAqZV5qTZc2FXtKXiRsbWUuXJmdFxn6cMK8t53lJL/A54pQmbeZVRWYruiZiW3WIdUhGwViM6cptUl1yKS95T9xlIvZ4Lb9hWV9w5p3zfHnJPwt/zHoY8qqYMNAtumHAq7nm2+qcVMz40/gB9eozUhLmlaYfSiY6x6+cus3gdIAtEdMh4ef1L9kUd2jUG0S2wV7QQuC+Dw+6Prmb8PHNcsme6pPaBd34Nhf5Uyez1zOGIuXVco6momnb1ELzG/Nf+Kn+CySCDT/maX3EtD7nZ/6PiJTgNMt5ym/Z4s85FN9gzX0SQgbSMae/XS553GqR1pYvJoKNCCYl7DV8Sg2BgrPUJTIT6/Pl2LF4R4VlLQRPeE6PKOBxT6xCW4IH3qrGZ51ybmfF9b3VkpymsJvA93qS42yTX1zkXBWW3NT4wgW1mr7i9SLjn7ce8O18yb1mg2Vt+WoCF3lFL3BZhd8vLlDSJ/ZcfQzg6UTzg3WP8xw8ATuJ4qqwVFbz406fX00vqak5Td31z2asmE6PKKopg+QJM3lCQoembTKrHFTh0k7ZEB1ipThOC263IgIpeLZ0HexcZKzTJRSK1FREwr8GZSsh2KTHnbbPZea+E9qa68DcRVFwtxXh5R77cYN24FLxs1LzVXbJnWCds/qcbdFxEH8cs31hc/q2z1bQ4KR03eO+F/KmHnE5jd3Clygq4zOpPTJdExNS2JDEJjRFSE7F82yCsV1SXdOSIVc647ba5Hfm9/TNj/BRfJBsoC1c5OUqk1BxmjsxwpScBj6/rb9ky9ygHXSxGMbGpZorqxFCMbUpaeXxqsopRU7TtjgjZUesE0hJpmteyVcUdo1t1piLEXvmIQ0VMRJX9Ogxa37oJnQq4Lk9IiuGJMEGSoZM01dE/hpv53/NO/UrIr/HW7aZ5m8Y8ASAPXOXHa/NIAq5yAvelhmzxYRNM8BH8Vw+Y8Ps0aXBoq5YN84eJwXY1fOa1ZZ126cdKt7mGePCEbB+vBEhh/vX6eezogQcPCmtDaVxU8HYc7Wl0ljeFnM0Gj1p8aQXsB4rZqXAF9DzIkZFDbj61nEKVhiMtfxmcsVEjtmoblKuKJEvZi6vAXBapOQ64m7bpx8p1oULmP38XHNVu5pjbS1nmWa6Uub+//vnnyxwqAz8JHgAwFleuIUP90Mu6hpfSJT1uGlv8NDbpSAnUJKbcoOBXSckdKYf22ViT661VvfiLrU1bJg9nqgDOoErY1/KdzxfzumFHjfMPpH0mBrn392SXaal5hkvKUTBSZZjV+EnJdwzqnD3sTteewUSCPkg2iK3LjB2mOb8Jj3kUgw5T2u6qxAVQCLdmLFCcyVO6HsxbS8gkT437Y3rOzSFpMYghKAfKfYarty+LlqMrTsVSwFdL+Tj+hmXecmW1yKULkSTa8PjYJvCGE7qGftNj0VlOcncOC4WPm0voO37nOU59zsRp0XKgox7jRY9O2DDS7hizlXl+r2DIOF21GHTDFBIQiU5WlRkq6uCb3PnuWwHir/Y6BIpxzSeaHenrTEU2nJmJtfWkkoUNIkIpaKtQmJPXm+e5tJ90a50xrE8JGdBaQyX8hJtK7JqzFHxOxLRZVSU5NqlSeemoDKWfij5INriXzQf8PlySKhcOvs4T7nbdj2+m3GTyhoKbVhXCXsNRWU1DeXxM/VHDOjRjzz25fqqy+t6ttq6k2Kk4P1WG1/IlXJvdR+8+BptSj6t/iPv9KekYsaheMpNOaCltji0Z1yYOU/rI+7JPR7Y9/ll/Xt+UXxDPwhpyQHLWvOEj3i/2WMjiIg9xVasOJQvma9OWy/mOZ+NKgIJz2fZNbjjIq9oiwhfSPqR5JNRfv2s5dpJMDINr+fwbmlZ1s7V/G6p2YzhZstjN7HsNx3EI1CCyxw+nyhKA+th4ByragUQCV1S+3YrZhAJfrjmiEKPOvC4C/fbIc/yEed5zobo8KF3k3rlcd1rKN7rKl7NLQ9bNQeJkxF40glFztIaD0UuUnqhx2t9ySfjBUqGRMEa4/I1j9Sf49uAcLX3P+OKjxoD4tUJe78R8m7pPpttv8FB2OLDeBNrLZ4UtFRAZTWRcNOgUAk0lt9dzVlUbpO834jxhOCpeeuodxZCfEZFRTdw4b/NxON7jQGXZcZDuU/bd3fkAKkteRj36CqXhbgdt/BxdcIuTW7FTRZixmmqV8+Gwxj2Pbc4b3oNduOQM3nCQsx5lo8orWOeN4RjJWzaW1hruRQTfpm/JKsNx5zzshzSD/3r99Be4KZ7D+0DElwT4k7UpS0i7sZtDqImO6yz53VYVwlbsotZ8RUOxMDBKHxFIBUd2ycXSzSWh/YBfdGiIQOa1tVDm7ZBQU2mazbMBj9M/jf8q/h/Taja7LV/RqAaJOE2vkooqimz/AhrDdpWXBUv+c3y/8bf1f+FF/mESzGhEAV9s34tzHmfx+x5XQKpmLDkUVex0/CY1i7wdpEZvprPSaS7MrkROr70KHcShUBK2oFgECuO5TsEgm7g0JaRVByaIa9mFdPSTQ/2ghYxAbdaAbl2EBs3HXX2pEi5O+IfrjvefSoW3G8lbKoWT9QBLd9tyF5M3TqlsWyFMQ3p/POhcpTAcWG42YTbbc8pGUM3MRvEHpX4pyGz/skn4bflxNlnCHglX3NQHVCsuFyZdf3XShQ0pMdptcQXLoK/1BUv5bfcMveIhCO0/LD+CceMaNoGX2cjbgVrNI1PqjW5dnrEPW5zM27yLBuTiYzQrhPicS6uiE1MQkiHPsfia3K5RZXvUojClbV9n0VZuNSaB9/mVyzrNg3Pc+lK4Tiyst7kjCsHcbCGC3mKt3SLa07Jumyy432PeVXRD4Nrao+y7nRwIS6JbMK+Sjhcuv9eICWnXLEr3Wj7cFlwwZgDe8BL+YZJfcKGuEWV7nBqr9iv1xnEHjZr8XJe0g3cBmAoRjwJ9lhUmkXtNI7fTnMuxZCbYoc3y5QmDSZ1QYuE1Ja8lc94XH1AJBU1hkGQXN//rqmYyhiu5DmeVgxkj8OFcWluIcgombGgTZNOKGmXDS4LV+mocBJxTzrE25tiykHQoWECUqYkosOCJX8cvsezbMwbecRp9RVKeIR+B0+EZMyY2JRN2+J+3OUky/Gl4MvJkpYKaAc+u6rLvDIMYsW7ecmssisLVs0g8l3YrDY8Xz0YUriNzM1GtFIRKjYiQdtXvFtqLjO3oQiU+zO6gcd6vstQHLMf/Zg3pkYKD4thUZxhMHgi5Jf2b9GmIPKaPNe/xJMJyvhUsmDH3OGr6i/5uZ2R6iFfepqb9g7tIOJw6U6SmzF8NH+CEu5ndHQeQ6bhXFzRN9v82SZ8Ow/QBnohjAvoBj5fzKc8sR02Y8Fvhzn/1bYLKs1KNx1wfWtJKC2lcQnQ09RVnUptEcItqqeZYFlrdho+v5tf8JP2ACngX+74/G5kGebw2XzKukr4h3PFjabi9bziUdznTbbgUbNFwxPsNyyT0qU/G57lx31DIA3/9lCy31ScpnpFqZLcCDrkukmuLW3b5BPz1xTVlFa4i5EVCkXHdmnKgMJqbqkNrlZSgdzaa9axRHChl6sOpr2+D1YSioUTG9jVHG5uMyICIk9wVWtmpWZY5VjpFuVxYbiQ5xRmjWcTxbDK8YWi4/ksyJC1oOHFrEWSr6ohP4xv8DJdcChfcrO86/jcUcxlUeILxbisSWyTizJlP27wk3ib2sCyMvRqpyD1ZUzTdmjahtsk1zkn4oSu6aG0Qgv3M+7KPkfWtQM+UHvo1Z8zY8lML9kXa5zXSwoKAnyWtc+xHuPhccsL+Xae0VIBgRJoK9iJPM5mCYXR9MOAeV5wlC/xUdRCs24G7DciPllecNNzOYkJ49UEqEMmUnKbIKxEIjmtF9zhIwoKhvIYESpu8Jgvsv+R2mQYW7OsL8nLMRbDaPmMhXdGVl4ChkHr+yyrc3rBLULR5LG9z9As2Pd6fDt1WtSNMODtvCI3zoF+aM+Yp73rd7QSgi+vKiIleTuvafiSh+I22rqgVMt3XfZbbFAby1roMS01wQo/W2rLZizYb7pT8qKCXihYVi5/0fAEz9M5j71bfDZ3d8BH1QRZSdcG0j6qDLHWclZkbAYxBvjPlyO+33JBrLR2CtNSW17PS/YaPsPckNjmH3YR3lQthjqlEiVbZpetKCLLncmiQlNajU9I5AluqCZnheJdPXULmblFIh384qpcOjKWgIqaJq4uc7VC5N1JmozT1aJuLLfDLr+pTpmZJh0R0bVt18ek5rbfp1X9gAjfEaBq90FcVu7POswXRMLn+6113i1LfOlG55Wx7DQ8zlPBWQVH9pI2LfpmwJ1Gk8QTXGYR87pmXjlN4risuOn1OazHLEzGrlynb/vOGKUte0nIRb463XsDhlXOThRzlucMRI8zccWB2afHBjuqTT/08PN1jvQVfTvgXM+p0UR6jZ0oplvv0PBc7aop3Q56bgqMdDs/pzELmGjnTX5jLunZHRa2QGufO3GLl9mce0mLYV5f22Vu5rdWwYmaI31FgxhdmpUoQ1CimRaG3WgFQTEWDIwLzVqkGOqUC3lCs4yo0PgioqbiafofOLYHhKLFmt3D2ApjKwLlvog3zH36MqEXKk6zkqbnc7hw4ovYk8xLw0TnvNdz+MYHcQ9r3clvrkuiSrGbKE7Sim7gkxpFZSxNX5Frd6IWSI4WhshzO+ZFZWkFLiHZ8BS3W5KLvEfbNBkECWvRBv8w++/pNO5SsaSpBmgqtrlLrTShCRkKn0AkSCQTe8Kr/G8pqgmL/JhB6yMS22YrjBnlbqedeJJnU8NSV+jCctAKeJW/QaLoFXfo2y7LWvO7ke+8sZVmUiqOswJrLXfjNrEn+GZSU1nNu9SRthaV4UbTXVUECkaloOVD1ze815UsazhcWDYiybiEi8zSDRSJEvy4NaAbCAIJSy1YVhqQfL/Tpe8eRWaVE8HPK2jJkP2GG4GXxiViPx25F2FlLNuNACU1t5qWr6YlqS2JVJOvq3dUoqSqC46yX+F7DSq9ZE3eYKhfXeNNxyZjTcVIBLnR7CYBk9JwVi5pCp9uoDBFwlbsc5k7Qcm3yzkPmy2aK1zs91trzCu7miw5Yb27yhLsRDF31F0ARkVNZBs0cfUxv1Ycc0Zf7rOrujR8ybR0PIAfJ/sI4HvdNpPpBkty9qMGs1IzCMNVQr0gJKCtQrLafa9iT7grHVxQbVkZ9uU6uXHXPMfyHamdsMmAl/JrQpoM6HFkL7FoXi+y667qptfgTrDOSbmgNhYPyVzk9GmjhKASFVi4yDS+cL30plBIYTlaVNwJ1lnWNW/yOe+32sxWasyJ9klFyrhosEaLaLW5tRjWzRabXoPX+pJ1ug58Yuc0CNhvxFzmFT3t3N9fVYf8OP7f0pERR/YSiSRtza7XifPqG9LiGCUTltU5RTXltPwYJQPOva9oBTvMzA79fJ01FRNIgQoUgZasy4B3uaIhnZ51WGk+6DYZF2LFEHDP+EwXbERNcg3f5MNrO9bM1JznJQ3lkXiCR60mm7Hgq3HNRqxYj1wORQDPyyH3w3WGeY2H5G7HYzRSbMUBUdGnNIbtxGcQO5LYMJccZo6jkGtLG3cvPAgE45V96mhZkyiPGw23Uf64/gMHs2a6IEDRsB0i6fFFcUouF/zAv0fiSQ6XGX3bXwGzBTOWrK0i71M7Zls2yU3NQsxYYxvPdngt33DD7LOdeHy5fIemIske0JERx3YERRchBAO7g0Zzzph9tVLphU2nlKp9Thhy0w64lJe09B6x8KmtIZIetTUsKsPcFOjCkVz2m+4+4qRcokXFQ2+X2JOc5QVXRc2zZYpG0xIxW1HIYbYkkNKNlIhQSDzp8IVjk/GmGvM++0TK4R2/SzjOSs1W5NBp1bRDQ/mcmysmdUhpDBdmRoCjR90MO7worqiMYTP2r2Eem0HMWZnSVREhHolpUmK4YEyiEzoyIjeam3KDwmhOxRXvN7f53XxIKhacZe4O0ZOKbig5zl31oR955GmHr8TnfMRHVNYwliMaps1ZqTiIG6tOdEmLvjOGGB8fV64fiSkA++Ymp/KUfvIAbStm9QkT89aRuYJtGmKdXbNP34upV87O7/7Zb/oMc8ndtmJUwK51wYvKWOaVJlIeDd8hSyPl5OaZrdjxQiIVMi7cSLAXSho+FAYOmo42lSjBceqoV2/zBU0R8tmVM7BcsGBepkgkzfgGy/wMbXJO5r9ByYgimrLpPaJtW9wTP+LT/N/jxSEeIQJFHGyQledcpd8SNBJ+W2VsFK5fGqwS4Ms6ZDtxJ8Vds8ehfIMv3dXEWT1HZS06gVrd6Vrut2O+mi7ItUNlrkcKY0MGERxq15n+QSTZTeBvz2qyWvGgIzlMFZ9fVTzqOoViS7vqjS8BI5hXLtiyrB1N63bLjeKzFc1nmFkmVcWlnRIT8SfrHQ6Smr+/tOS1ZSsSfHaV0/F9/q76FbftE6pFzM8GAQdJwXYU8jIr2U0UrycJfbvGl/YXeCpmK3yfLJgyta6adG5fMhSHNESfDxqPOE1rclNTaB9fwr1Gi0K7DcdQp2SLgEg6iYOqYyrjvhshjkVtsXyr33Hb7JKbmkh6aGMBways2E589ho+s2mHrhdyq6WoTMBR7Ty6E53TCRp0Ao/fzC+cYlAISqNoW5eE7ofuvRAZlyMBKChp+46SFqgmx7mTtUzkmH7tMhijwlAYTSdQ/Kl8wFlW0vI9gup9R6DyfHyzgbGWtcgnry3hCvCznUguSkkv9NjzWvxu7hoXbV/h1z67qoe2ljOuKESGLPdo+x4jk/LI73BSumuNs6zGl5JDM2QmxzwR95CCa7720CzosEZHRFgLyiqGYsJCTKlEQWhuUujIke9YoEtDgusMN23I42Cbo2LBvlznc/sVLbvGpv8Q2zB0/D33/TLPKKoxRTmhNjmxv8aL5V8hG/+Sz4rfEekuxtY01AYRTVr02AsatK1HVjupzJtswUIswUCiB/S8iHllUELyw9aAvHb4zalxf29lBKMcKmtIa4/CGHYTj68nhkEsyTVsyS67DcWslBwth0xKtzF/vpyzEEsehQOeLmZ8ubD8tNflNHOHnX4kGeWGGkNaW44W9Sqn4uEJyaQu+GbiaHjfIY7/YIuwQtJSAa/MOTt2nQfeFudVyqtiwo+jPv0g5LP6lFYV0vY97gTrWGt5WV/SsT1KY9iNY5Ji9x/tOvkOUzHnOA04MAc0lE/DVySepKe3kAKavuDFHBrKlbyf2pfssudqQRZ8IWmaJpd6wYHY5cxOKEXOLbXNlc5oipC0dvcx/TDgk+ItSXaD3GjGYszArvOmGtOoIko0SosVTq5G4XaLW0HCpKpc71f4FLa+RgHuBy2gRa7dSWgvjllU7j55LYx5my35qpjzKHSotLZtubtiBD3h6i6Xee2K5MRESvLFdM6SnPOpq8Y0ZEA/8rjl+xwuXMigWHRpeB63Wj4fj+d8Zn7LE/sD9tU6Lxc5BsNNsUM38JwasZ4T5R1C4TG1Kca64vxGfYOGrzgrC7bt9nW6+12WoYRkbjN2xTqH4pSlnfCResJj7vMfl/8XQr/DenCfhblgXd6mFBl9eUBimkgksQ3ZD5tucVgh6gTQ9h2JqxtArp1b+KApOE8tnrB0Akdr8qQLa/S9GF+66oxC8unywvWfheuBvpqVLEzJVhjzYl5yI4k4TV0ta6+hiFUbJV2Y6TKveeK7ROdXxTl/HPyvuAjGnPOSUfoMbUrm+QmbzUe8EV+TmTHWGnI75Sp9gRCSwGtR1gnWGs6Xn9NL7lLLAmVu81fLN/w4uE+kxOp0DCMx4bG4zzCveWWPyeUS9A4XmeTAtFjWmkfdgEmRcJgvGMRt2j6IlWg+UoIHHQePWNZu3D6IJQdJxdvU548GHmu+5tXM3ZsdLR2H12DR1iKF4HZLMi3diXe74UQWg8jxqf/+oiQmIsYn0/DrkYcSlsc9wbwWfCk+Z6O6QSASRmLIOvu0PMPbNGBW1fyb3TbGWu6ka/yufkZMj1j1uCi/JlRtsvqK/fDHlGR0bJ9bcmOF1LS0VEDiCUDw6XzMDztrvJnXPEjaLGuLNpajYoGPYppyLY6ZFJq9psdP1U0E0A0DCu1QnY7yZni+WDIWM7SoSOsW6TChG/jsmW122h7Pp3P2rEvt/8v+Jl+MCyIpeZG5k91ew6e2oBAclnMeJG3aXkBXBBTa4CE5ypd0VURlfELjc2iuuKk28eV1foyLrOL9XsizaUW5Sit/d0o+44pdtc3vyxfUssLDZz7bYknOWe4xZMJQHnM/+B5vsyVdmrw2p7Rshx5tQtZo+M7BeyUvebYUpCJFWMmoFtxJmoRlSEKbTqjItMUXCgHseG1mdUlpNUM9p02DG1HCL4oxN80ddiKHJ277HlTuhNwXMV+Z1wSiz522Ih8nTOqCH/nv86YaMxWX3PX+iEuOALDW0Ir3Kes52hSMls9Yb7zHl9P/h/v/4wMqvURFIaVYuHpj0eOPvZ9waIYczzzmckLKlNvmAS/LKwayff0+GWauWfGwG/Bm7iY12lr2mh6fTeYMpM+tVsC/P5sQ4mGJiZWDhBwuNEfllA269ALB20XFG/kt2+YWg0hxVYSEUvHFOGVBjmckxvqMihqL5Swr2Ypdot8TECmfeeVxqyWpLXyZhn/YRTiRbj6/yzoay7x2ib/K1DybZWxFIf1ynZQKv3aX06kxRDZmLEesi4TDbMlW4GDXJ3lGT8YokXCu5/h4SO3GU0dFeT2uMlZxygX7Zovc1BywT9cPOM4yZjjGtEQQEjK2S8qVpelYj+nSRFvDV+YNA7uNLix35C79SFEZSZ664MBNv3cNHRlEAb8ujghsTKTavKudNcpD0vIDXutLEGBXvOtQhXhSkGuX0jvMcqZijhGWbzJnEplZQTeQaCuReYPSuNpUIj2muqDtxywqTUeFrnJBzJ7XJZSSwhjGdc6sVBRast3wGOWa3dj5f1/MStoqJLE9IuECB6/NKREJDc9jUtYEUrKG83j6wr0djIVQSdqV8/EaLBfyjJQpJQvaYoucBRUZDdHnsvqWsp7zV+oFSoY8SP4lmVjy0+Ah9eqLH3uSSVkT+u7nftQNOEsNkZJc5CVd36VtfekgCG/mlmnpMI+zCi6rjF2VcLSoHL2GFu1A8HvzBd8rniCEsz6VImdZa262HFauMrDpN8hWoa/vkow/2Qj5eFhRGM39TsTreckgcqcubQVhHqKEILYR62IflfiUNmVZnTO2R3hETNLXeCoira+Qwict3lFUV9fPhUayKe4wtqducTAn/G3pXuIxbW7aA0Ibcmicgu8G27zgFT4et+ImtbUcNAM+HdUknmQ/avLL6Tn/an1zFd5zjuBn04phLml47rNsBRHnhcevLir+fMvjTaoIlKHhwcejDCEEkVT4QmKt4ReXGf/mRsirhWSYaT7qK/77s6+5a2/zpBsjRcxvrmaMcsvH8yt2vDa18Xi6mFKLgpkYs20OuBd3uchLRqXPZyMHZYik4fXSvQBzO6Mm5yp9wT9L/g/8uv5P7IbfY8ds8VR8TClSmnWDlgkpjSaSHi8XOVuRa2NbXGjwNCt51IlYC+FXlxFKODTkSIwY2A1SXfPZJKOrItqBYlbCl4sp9+I2F1nNST1jW7W5EWzxPJsgkOwm7rrsbVFykbmg5uf5GbGNeF/0OLVXPFIDBsZxpb+eLdkIYnaTkHKpafqSUVHz1Lzgrr3N/WaT9Ujw2VXBo27ERRYADQrj2N1KCDJtCaRkVa5gK0h4WV4RSEk3UORpi9+lp9ziBpFyC8uZmTOWl9zy1jisF1gMF3mBWvH2C5Hx2N/jpFzyVhzTLrvci3o0jLuqa9rGdZjsTepEOcI67KlewYZK42hXJ/KMG3aHdVq84xydGfpsIhF8VZyzK/qkpiKlYCBbSAnbZhupBKPckmtnb7sdNCjqgjW7Q2RjPhAfMjQLwqTJwOww9cYYYbhhdzjlgqCTMK2OWA/uc7z8LRZNINpEXoelGfL/HP+fkCLAUxFSuGDhZnjAQLqApbGOtpcbzWfmJdPxbd6IY3qmT4jHrHQY2dOsROWCYPV5GAvL2hArQSuQLOsGpdH8drREIti1t1mXTZa1pR8GXBQF+42Yz5dLpjbn3dJ3CFoZkpvajerDgHHpVKJZbThJBaNc84ZP/7CL8CD2KbTluR7StE1uR20O8wUtEdNSPhd5SSpS7ngb5NqNEd6ZEXeDAbIUSOXuG9+VC5c4FIoje0nXtEnFgu9FN9DWEkjBl+mC12bC96IbNH3BB+wxrzSD0NWcEk+yHiX8Zr4gxKPrhSxqR8x57O9dE3gS6YTmoj7gVitCAqdpzetFRiQdYeY0yzmtli64ZDWlsXTMGm1iTmrHv06N80i+yuYs5ISm7XK30eTb5Zxvswk3ww4GF5Fvyxi/ULwUL/kgeo+GJ9gyW6S1pV6h7pQQGGsJlGRDxbQDyagsUVZwoNaJlKTlS14vMsfC9iKuqoI1Qr6cLrnTaNL0BT+fnLMlu+w3AibzfabkVJUbO+YiJdeuK3lRONg6wNPZYgXOELQ8wajwqaxhP2ryoviCRX2OFB4X6ecgJI1wk0qleDJkWr6gEe3S9Q4oyNgwW4zLij/ZDPlq7E42l3rBvaDLmqcoNVwVNbGnaHkeBne3rIS4Ft4fmiEPgm3eLlwwY1RUpLYkxplxFpUgoklpXA+yrzdYVIamL7nRsHwycqfNceEgF+91ndnnIi9Z1u6z9qUkkHCrFVAZdzJUwI86fT6dTrkRdKhMi7PahcYOSRkzYyEmNKItGt4GCp/b6j2+jn7t3LvG2byycsir8hf4qsEb7yWBTejZHbboo61hzIJz+Zau3WKXdfphwCjfIBI+rcAhMt/mC87kMUndpm+7rNHieGl4ns14n47jkfuK2rp6lifcgvdiLnh/zWdawWilSZyunMGHWcqtJCKrLfuhx7yynOdupH+7rXg2Nfx3nfd4O6+ZlZa9hqAhApq+YFO5e9ZCO0D9fxX8MU+Lc3a8Nu91JQd1RKQs3VA5QEPpRnSH9RhPhoyL18TBOh+bv6PnHyBRXIghPxQ/4WteuEqb2KbtOU54aksg5EmnRVZbHnQUP78oebesCZTHc17zkbrHo6TF53MnFrBALHxiz72QhYCCgnbgqEiqdu0IR0T23NVRodG5ZaAa+FLQCyVpMeNJuMXRskBZj8q4u/FcZKzLPv1QoqSgH0TuWkuXTsgg4PliyT8sL3mobrCsLV/nl6zRQgnHPN9NAoSAk2XF0cLdbV/WjicsETxN3Z3h9+ItB7PQNS3ls6GajK27prphdinYJKMiI+eW2uAbnXNZ5k41yB6twGNUlNwL1gF3dbGw7vu57Td4Wh/Rt31y7UJtQyYMS0hsQiwSun5AqQ21rdnyG4zKnP0kJso9BpHPaWbZDRN8CcO8JhIevhR8M1+SU/LDxjbHacGa7XAlptyKWiwrRzc7MAcYLPfVHv3Q4zRzTOxte4c1f4+SjMBrsSse8036nxkkj1HCpxntEnt9LuafIoTE2pqvxP9MGv6MxDQx2nAuXnPD3ud7/n0CJfhB6w6fX5UkSq3eM5LdJHBVv0owqQuHKFZiJVNxjYCmD+eZ5TKvaeIsdkLAtKx51ImRwKO4z7zSdAOJEjFbsaK2gftOrDIbkxVff1zAu3rKTT76wy7Ck0LzjT6iadssxILStBza0BY08LhgTNM2aAeKQLv70Pu+q3BoNFc6c+MuKo6ylLGYcUNscGFnrFuXyFySOWeoaPJGjFhWhs7KSZrpml7g8UYcEVc3KY3ECsPCZqyLiIzKnUSqihtxQqktSroTn0Jwntb4UnBohtwNBkRK8GV+jo9btFq+4p2ZkxYFEsEVczw8bjR9Xsw1kVIUuiS2DdrW7YBfLiUKB5If6hSrDe83e8xKxXvcx1j4er7gRB7zfe8eV5U7iVbWEArFu3LuOLlei9SWZOTcV+v8qvqSg+K2i+Gr6LrrnNaGvhfjSXgxc4nJCzOjWjTZChpclk7x1tQtBK4feKqn9ESTX88u2JJdBIJT+RqWkIoFBoOxhr18mwMe8a2cUZuC3fZPOZ7/hln6knZyh7wc86jzb+iaHk0TsR6GtHy3GExXIgEpoOG5qcIw09zreNxuu4dgURnS2u1cv1uQT/KM+8GAd0vNV8U5Ugg6IqJBwDfiGe/Zh5wa54lOqVjWTskohOCgKfnlRcWkLvhJv8lX45K+59B+j7qSyYXk7VzzYd/j2VTzfFrxXs/n60nNbsMnVnC00NcQ+1y7DMAX+TlP4k3WqojSrHOgDihsjUYT4nGTjxirS/608ZAv0xHnjbfcMQ/ZjRJqYzkrnXnqw37A8dKwqEJ+FK9zmWm+v+7xZmG5zxq3Wq632/IV2kZsq/sMq5x8Bae3ODnB1aro7BB6ln4kKLTi7ULT9iUyFFzkltO0JvZcKvP7fUF6HtELnHh9VBiHgrSwmziYwd22uxuLPLHaGML9TsS7peYb+4rdcg8PyZm4JMoTdmWf7697jFZ6u53YpVNHuWaUCw7rMf96Y4OPR22+CuHN9L/gqyZrzQMWdkSPbeamIBYNdtnkjbngQAwY2jn7Xo9Su1DlRVYRewFTm9IVXS4yQ2SbzKuKQRxxM3R0uX4YsKg0p0XqnpM65Eqe8XbhlKtX8pJmFfJBMyatE1Kt2UwUs9JSaEMncBjWHbNLN5QU2uNxa4NPrpZsBBF16TawkRIcpy5FWxrLThTTqZw8oGE9RtpHrghhLRLECoryu6s5NYaMnJiIxAb0g4BRYWnjlHp7XofcOKFGaioKanwjCaTEWM2bwgVba2NQwE6wzm6iSKfbtALnCX/DMVvlJo/aDcaFYT1ygcUzfcU9z4lrRrylkBmPuOsqQyamoKAnY9ZFwrKu0dYhhsdlQSAUv8pf8753k6x2PfCsNkShwpOCtNY0/QAlYs5K92xbcFRAXC7olTnng2iHz4sTSpExq9vUxt25+zZg3+uR6pqXvOEg+DFt26Qd3SAzY0LR4pb/R0gkeTKh1hm+atD2d5gz4nn6Vxjrmg0j+ZwvqoBbwU95nXfwkGTaNUw2g5hZaRACRrWbmmS1RgmFpx1MJ5ACJR2y9TKH0hhut0KuCs1m7E7ghwv3+WhrrzvwX01LBmHIqHC89/XIAXGOspRIKna8tvMp/CEX4XYgaaZtRvKcLbOLBGpcb3NRV6Ry4XR8y5SMigYBA9+n6UvuBWtktXtR+EahreGm3GCuS5rEtJRL+aZywQ2xxnrkkeR3OK+XdGvHgBVC8G02IVkRs7aTmO1qzakTGx6XE8mCjK7qOvh8fsRNsU3TV/RXyrPbQYtbdoNca2LlcdcfEEjBqCgx1u0M7yUt8tULQVs3Ykhtya0wwpdrLKsux3rC0dK9HFsqoOVLPoo6TEtDrh3RZbAycLRkyA1zAwNoa9DWMAhdBzEyTY6rBWeZO/mBC7X9UD3mqT1iyw5Ijbv418ZVcF7mE5aLhF7gsxf0mJWOOrMWSXwZMylrClFwoNapjaVvW7R9H6o266HPolLI+hFKSIw1nMnX9OyO22mLHEVIRYa1hma0g7Wajn/DPRRWcjPsYC1sxYpZ5UJEn13lbMVusbXWLci+FDybum5yohTfVhckNmFNxRTGpYfB0bhSU7El1jjmHCUE99shF5MtkLCruvQjj1Fe0w8l6coaNSrgbtvn+RTWQpeS1pbrXutQp+ypFmntvKSxkgxzy6Ouz2lqVr1Dp4O81wh4t4RJVfIoHFyD92NPcTcJOE1dde5h1+eqiAnUBushHDQ3+Oyqy52uT2cVDNupW2zFlsMldAPJojIU2o1Yp6WrTDzpKa4KN2YeRIq0Ntxpe8RpghIJxsIHa4L/68mQ0Ia83+zxauZG7D9fnLLNgH4Q8Kjr3MFSCPf3NR0edJxdaS1SXOZustQLBXeaBiksuRZsdg3zWjKrBJFyJ96vxobP6jfsmW1ui5uklITC48/bB5TaIUcTZRlZd4K4LCTv0pRBFK56keskHq4epwt81WS98QiDYVafcJp/zE8a/3vA8a+jahMhoGsaRJ5wXfXCbbojBR2RcFlmRCph06653r6x9CP3e5YCOquxdU3NUI9Ytzv0Yo++aPObbMyaH3CRGSZVSUFNbdwzeVot8fIm47LiIG5QastapPhynHO3laANQMjLfEIvdNSj78QmqdYMzYIfNNbYiASDbNeNRbWhwCWXCw1zUn7QHKBtm1mpSbXmuFiyrhJKY/CkYFJV+EKSa829ZoNxoSmMS1w/ru8wMQXtQPG8POUj7zap1vx8ckVfONb6RVlzwC79yAFgvi7P+VBuOT+3rq4rX2228G3IMSOuxBn3xUMOAudRTjzJvDJUxrBR99hLInwpmCx6nJQu0KhxQo/SWBZ1xbE8Icr36QYeAoEnxTXkJVuF3g7EgMN8wSZrbIYuz5DWho3Iw6Z9Yk+irSKzM7RImBHyx+pPnf7WatZUzEtzzF3vj3grPyWWPTI9JlY9pzNVbSbZazBQ1FOO1RdoW/NQ/akLsUpJ03dTkV4oeFPUtH2PdiBo+YKz1DgHdTtcjbbdeP7UXvGe2qYTSLZi4Uxk2nEweqGbhvaIaSi3Qev4/qoq6bIso8In1TVXdsmlPPrDLsLjQpMKN0ppipB57RyVV1VB1wtZqzeuT6O3ohav8ilfLjNiAhpZgLEu2Xolpmyy5qoB2qJxp6OOjOjLfZKVKutL8Tl/FPyA2BNMCueknRYpoQ1priT1Z2ZCJSo+nyh2o4SvijnWwnFasM2A3NQ0UXxSvCUUEV9lOS0SR69ZpekMLpU4Ki2JCK6/mNYa0qpGW0WIG780fcmrfLo6PbJK7SpO0oKJTbkRdGiHgpFwdo8P2m3GZcWEBW/rt7yn7nKpF7wqcm4FXcDZmywusbimnE9zWleo1dTAs5JMZDT8NS5zt1B2cSf9Z/MFDelcvWtIvs2dZaVpGzQ8RagEiSc4WriHfVEZlrpmN46ZV5ozXdCgR8MmzMScE/MVvkzwZcz58nP6jfv0xA1u2B3W/GCFwHS9znWrOFxmbMcRH65FHC1djavleZymNYPY4yIzPLdHeJVHZF2S+50Z8SAY8Kgb8PEoRQnBVhgzLiv6do1B5PPvZ9+wwy5Ds6BNTJ5qCluzFvpcTp2M/L2e4pcXOTcaIWeZYFgUeKXk0BoKas7lOyj38JctXuQTNlWLXuAxq8TqdwyzklX1BO62Fb8eujrHw65Py3fowM3YaQJfz+H3o5QTcc4HwT6fThckIqC0NaNc8bhteblUHC1qtmJFXlu2W4JUO3TqTqKorXuOIuleBOPCkbMmdcHTiWU78ZG4+sl/Oqk4UOuu4pK6CcpPBj7j0y4IaHiSjmfIteKoNPyo22FUGL6eZrS9gExr+qHPdqL4q/EpV8UWlbE86joByKgUfH6VX1OBtqOY972bTKqS9TDgPDf8aD1iKzKc5Y4VP6ncifk7xnVGRdOP+WI+5XbUZhAa9poev525fngiekz0EQP/IUPh8Y35OU1viy8KxQPP/TwZFa/ynD9vrCGQ1MbybqEZ2wVPEneq6gUhR+WU2sTXrllwlKkdr823+h1928fHfedP04oNu86y1hgUMzLWRINACU7KBRr3XX0rjiHfpe37WGvdJnC5xdwUZBRsyQ6hgvVI8rqcU1YJ91sJ87lbcH59mXOr6U7Fi8qBNKZlTaEt98N1PAnzwvWA21axLwM+m0/py+T6WipSEk+Ka5pepBTv8iV/sdnixUyxrAw37Q1ybegGHod5hbZuQ/Kg1eTtoqAysKxqx4Vf2dPuqh1CKXlXLtCyJhMzenaHvtlxMBttuapzHoUN3ixzTuQZpczYNu9RGteU8G1Ai01KNIflnLaIaHo+W/UW7dDDWCioKY3FWsuwyjmUb6h0TmkX3OYjl7TONYHwyG2FziJGJmWYGzKRs2Vv0SBiK0iu15qejEmU4qbdobKGRPyMQ/GcWPV4Yj/gq0BiMRDDnnyfIYdcZk8B+F3+f8diaISb1Iuc3fgHNNMuUgiO8xQpEq5yw2WZ0/YC/u3sE36k3neEt8Q95y9mKwfCrGQ3SmgoDyUF46LmTtxiWmo2Io+1UBB7blNoLRwtKvqhW5uulktK+wdWGeZG88jf42U5XPVDfYZVTtcLea7PuK02WY88RkXtRsEoopX8QJkOgVD0vIj2ii3b8KQDkgfugXqbL9jzmgwiR8/ZyG8AztThtFSCe1GP8zyn7SsOFxVbssvcFCTSZ15ptnG2kSLXhELhKcGi0tyTztObEPJcfs2uuU1JRYP4WmWV6ZqCmkhFREogkAixChIJxXnqoBY1mh3pOqxtFZJrzSAK6GgfTwqOU6ffe9BoUxvYjAK6ep1U99iKfSYLj3BleymNpqF8rrSzFmlrmZSOBHXDbNCP3L3QMI+4zCtCKbknB4ALVWV1ydykdGnydmHpCxcW86XkMF+w4SXURnKlHQy+rTzAQwC7DZ9v5gVLxtSyYsfssSn+lC/5PYvilP3mz1g32xz4XTdqBr6eLV2HWSpezHIuxYRbats9OKHi9+Ur/nl0l5eLnN8vrvDwaNKmTeLcqr5kXTvNYreU/Gg94YurkpYv0dbno1ZEaeBxcYdBw3P4wlmGEoLvdZt40p2AnI7OVc0k0PLhXjtmVrr6lTYhf9J+wqS0FBreS3q0A8luYjlOXdrYE06yfp7nZHXAMZYn3QaBhHstzf/7SBNKSdXwHIXNwkdrCbfKm8wrwx+tdXi31GwnMc+nJX95pugElj/eVFzkgtiD0wxuNQX/5/Pn/MDeY1Fp9ho+X07gZhMaPgxC55z+YC0grZ1KEBQyh/MqZUlGX7Q5tiP6s20SEXDBmH22MQi+nhjutiXvlpZZqfnZRoNRYTlauLvV3w1LNnE+2PcaHUaFuxMrNFzZJQdBF7satUlgNw653ZIoEZFpqKyjdn3UrYmU4etZwKu54Vf1J9zjEdPCsB+0+JOBw2oOc01CBxne5yT7hNDvcF5+hRQ+QvoYW7NF/zqHUVCyLlr4Eq5WeYFR6e4zZ6Uh1TWZrUgI2YzdaHhc5+xGCeHKRduzaygkGRWz0oF3FO7aZ1GWhPi0fJ9lZbiXtPiOHnuZOU60L32WleWW3KYfeujMEuFz0HJTkGVlyEVKbEMCJfig49LrALPKbcjHJmORK27ECcepu5e8zDQPuh4vZy7BOysNm16DeiW9f2NPeCz2XR1RuYVYCXi/0+LZVFMZN4E8SVNi0aIXSrbyNVawOl4vcqy1tH3JULuw51ro6GCXdcrNyNWsRjYmtWMsmgt5wrFNkdpHSZ90dodMZGyZTQB+WT6lZdeYcsayvuS1qQhUg453g6f1W/6I/5pLMeRp8dpBh2SBLQ0TOSYUMVN9zI587EbJIqNtm3RVtAptimuVqMO1JpzLd3SNO+V/d3W2Fnqc5gWRVCTK56weUdoFt+wH5NTcs49cRVLuEduITW4RJW1yO2OYPWM7+Yib5g6/qP8HrupXHJUXNMNtbosfMipcwPhWI+Ewzbll75Fj6HkeR4uKfekyOb4UyFIwiCVtX5J4lqOls5ldFZZ2IKitMyaV+rsNlJuunS5rPmyuMUoH/6S19Z+Mrby0U7Rxku0KTfSdcF5rurbNqZ4xKtwJKFCCpnC2oX257kJQSYi2ljfmgu3EcT+HZnH9F2iJECVd4u0wW3FjtSZUglGZM6tqNiLJiTjn22zCt/odV8bRYIz9xyrGd+Ngg+W8XjI0C96YS/Z8x0W9Zx7RJOJesM6ZPHFc2NDjRJyz4SWkteU/zl6yqJyvUht4Jd5wWE3xpGDf67HXcGP2yphVr9DysrxiWevrhOObZcq8MgwLJ314aY45TstroXckFbHyONcOqNFQPttxwHbirTYpHqdZzt/lTxkbtxDtNTzOq5RJVVIay4V8x0B06AcRz3lNbiu2o/D6hL/UNRbIcC+12lje1VOmpabtwxN1wJ65y9KOeCO/5ZV8hUDyrxr/R/bNTWICYiWIlODj+RWbQcxmrDhMs5V/2AFV/mp0yeGiZNts83pRcCROmMoRmci4G66xFUX0I8WHPcuscp/RMNd8PMrphY6RPKsqzjPDMHfjrKy2RMrd549NxhfjlN9cVlTGdQL/+nLCeVo7IlLmrjoiJYiVJFSC/zA64dW8YFJoIiX4/8w+4y9Pc347may+I7CdSI7kMd3Q6fAkjpH+1VRxrMcYCyepZVa54I87MbtF/Kqw3G07JeNm7LPXUCSeYF4Jfj6cESq3gXy9sPw4uM9x4brmaW2JPcGrueHLq4ppJbjbDgikO51fFTCvXIivIyMGosNTPuPEfsMvsle8FC8ZiXd8srzg66l0J+oSPlle0AkUs8qFD5/xiv/p/Ip3ZkTT89j03Nh3XllOM2eZaRLxorrgXTXjoKlYjxW90D3XkSc4XGjeLtz//rt3gn97pPiHi5xv0gkfiQ/+v6z9V7NkWZbfif32Pvq4vlpG3NARmRkpS1d3daMbsoE2YAY02owZaeQX4dfgIzkvBMdINAwz3Rh0o0XJrKrUIjK0uFq7X9dHn735sM/1zHoAK8cMblaWlZERcd39nLPXWn+1eCmfMchzTrOYh0PJv9+PeJZcIJC4BAghKcqYJfceGsUw3kUIyYfl35JTVN+5ZNF3+aqfm6XuAu60QuZFg/MiMp5+Sq7VQg6nhq97t9OoCpdk0TcbsO41a7wSn5MYLJmNIKDjOuSUZtlJYTQhC76Z6q/UJW8Eiyg0H2RPWQ3tWab8su/SZcDDoZlkWq7FvJ7j9UaDlQCOpwWnsWbZd9lNJgYBEh4TYmq24GrdDBe50gwqCqJmmyCXpcAmUYWBZvUCWWmGjOM446KMsS63CWUFy4HFICvZdFsMipSzuKTtmNWFHddU4nnXm+3fDfFICk3NsumLC87SlI5rkxGzyk1c7fMmb3FTv4MlHBI15En5S070Mx6LjzmUB2SYtanDdG929ntWCwuHurXEE/GUUhTYwthv1tQ6PXnGHXEFgAXrOgA9cUBXHPKIj3ilTnmcnbIt9hmKcw7lEY/1rzmQL1hSa4yI+W35KyIxocuAR3GPB3zMYdmn7kje9NZoi3XqmF0DOSUDccpQnHMuT7iQJzh4KEquhN+no5eoS5e54BYL9k3SfECUdfks+gt+mf8n/j75C/5d/9+R6JyW5VW1xqRtXZQxSakY52a/cFxoPulmfNxVPB8lTHNNT0V82Y/57cWQpitndrPLe8+RRh19Ubz6b1uEtVCcFxHn5QQL4/PVaKY641DuEeLRdo1aMrAkJ1zQsh2zpFoN6CYFi77DfW+VaaF4NY7Z8lokpbGwxDrn83SPflqy7AbVDlNFaAtziHs2D4cxY9EzOyb1Eltei3PRZ8l3cYRkNTAbaC4Yc6GmuFi82ehwy16q8p1t5l2fN9ohm3ULC4e+6BPYglDXjW3IFmzpdZNhnJfsTmNucY2WCHk/e0CuFe9PDnk5nZLpkmlpFHFvhPPEpVHPLfkOh/JodlEmKiMVsUm6okRXdp4n+hV/ODdPPzUHxUGUcjQtWA1tGo5kyfe4rW/SEB6F0gQ21ITLgudRswWvcZe10GMpsFhT62SUnCYZOQUOFku+y2poLrEnLKMkRbHg2/yqO+JRsc+crPGafheNYqq7NMUScVnQFT2uBjXe6AgkZpq82jC53lu1kPfca1yxO9QciYfLS3XIiCmOkIz1OQUpi7rDgm/hSpPWtBdJVgIb35KMiwJfWtRswTgvuVY33MxyIPmTVRNWMi1MZ79k1bjTCrndcgzso7u4WCwFNtPCTAwNx+LRdEjNEVypS75fX+U7Cz5tz+LZOOIn3n3enQv4N2stuknBeWKymK/pTQplOtudSc7TgVELr8g2876FJUXVEJjPsBXm/HhR81YHrtdKQksQ2IYnfTrI+LxXsOaaifqNjuTtjmajJllxa9xs2fxgEcaZ4nZLsll3+PA84zAyn+HlqKTuwFmaslFzaLoW99o+N/XrXOU+m3qN++IOG+omAUZX8FZH03ZhSbTQQM022oFQN0lFyjIdCq25Une411T8ZLFkydfYAn60WCPUIRtOk0kBd5qa1UATl7ARCv7RiuB78zm9LKHlSY6SmGXfZc1u0nZtDicf4QhJy/I4j0vmbJ+3agvcEVfYVJt8x/1zkrzP9vhn3LR/yGLtde6qN9iyvkNfnjPJSywM5CoRbAUmy7rpwBFd5u2Atmu2a41yZVAQaRTeriVYq5mGt9Saz0Z9FrlG07V4a85nmBkeP8DBFw6JKlgOTOHSaL64yGi6Ztfy/3HuNWqOiRYdVSIjhSYiJatEhQ4WdUfwm7OM7fKcX8eviEuzA/mNjs+S7/L91iJRoXkxTvgoOuS0HNONS86LiKYruNeWJvFMWiyHNituyLBMzbPc9ln3alXYCDRsm91Jxl5xUUHoZihQQEzCw37Gim8m82vV9qy27TEuc0ZFxl1rE4lZOv+Pa69jaRuPr32rr+s3maQnNJ01ChXRj18x1ucIJJ8Uf02pUur2MkoX5Cpios8AWFdbhLrOEtdmf5eFw44650A94Lx8QSZi6szjU2deXsXGYrv4kIQJFg4DfYjWpTlzRMSRfMlF9Iz94jP21Jc8V78x11WUDLKSl8mATbWOJSRzjseefMmi2mBVXSXRI9IK9nVFyLxawtEufRWzpV9noI5o126Sl1NsGZDmA7J8TF5M+az4Gz5Wn+AIyW42QApYcWusBDb9ImHBCnk5Sag7lhGsVfnVy3YNT1gs2zVGmWKjZpquO22HXlKyVrOY9y3m7OvfqrZ+azg6J0MRkooUoSUXaY4rTM6rS0CJ2TRR6KobwOE4N96r14NFzpOMi9QcEE+THvviIVfT+wAsY4QX18U6wzJlOayxnHcotOIfRttcYZVCKzqux3p2nbuhiZub5oplPUe/koY/mY7IKViRbU6UsQ4NU8VX5S737S2U1kyLgmejgoZtc0tsMlIpF4miI+qcFxG1vEGJppsa4ZAtJE95yX3rFnfLO2jgu+E6J3FGpHImOsLKBIkuKgEZHE5T5vQiBZr10GV/qrmpr1NzJE5hc5GnrFoB33Vv0UtMUfxi2uWOP8+8b6DfTGm2kzEpKSuyzd22iyONCOdSjdl0bI6ilO8v+lwJajyN+ya8RPuMiIgLH0dKrtgd2p7FfpSwarX4ODrGwiLUdV6KPbr6Fb5ucVe/x5ITcrtl8bi/znGS4o18Ppucs261KbXZbLTo29xsSvanpjCtOjUahYdnWUzLnJZYZk0ZW0VUmIhMq9qNuh9HrPkB857DZs3wpC8mR0zGi1yrBzwZZFykBusbZorrDYuDqbF0dRMDRb8hVyi1Jq1Qj9XQTJbrTp2GYybWZ+Mpoyyg7Up8aePbZvo7SwQt16ANUaFZCVyUhnlPMM2tmQCl7Zr4uZ2JZtEXdBMzqf701CyV0Jpqa0vJes3iO52MX3UTvtNqorWxPCgtiEvJ/tQomWs27EeSe204jAyUlaiCP1xweDrURlCj4UroczQtuCgSzlNTaBZEgzM95FglFLKgJCfXLXamRpX+oyWTn11oeGde0Dua427Lp+bAJ92EvQkkpY0jDR3RrxTTCs1O3sdL5/lPBxkboUdgQzfRvH+Wsc8xUzlAju+wGYQ8SE7NgoES3gz/NULA1YbD02HC/Y7PV/0EKQRbtZBBWuLaDeruKo/i/0LdWyEVBYf6IW/oH7IrzqgRcl4YRXmZmek2KWFTLNIvEpR2WPQd9qOEtuvzcBhzzBlvuBv0EkWpjehtTTfZKXKqUCuarsUnyS5bcg1fWpwWKaMcDiZG01B3DLSoMQEm2+OUXCvawiQ1OdpBYQRXiTLny0WqK4tSgwXaVQMp2R4V7BQ9NrM5IlUw57iE5fJs+9SKW+NgWrI7Nks21kOXz4dD1tw6EpNdvJrXuMhNRrxv2eRK4wjJXX+Baa44LkeM8nKWFX+mxoiswahMOU8cXu/4HExgWpolFp9FJ7wbrpCUmqNpbhZrsGSymeUFDT3HevAeAJHoIbA4nz7ElgGe08KxagzSHZKsh2s3CESHXvKc0su5z3fYEbuM9AkICHTIudgnKQYseLepqSanYpvT6ZcoXbDZ+CHX7O/xMnufhrOG0maX8rQ4w7PrZntecJWOdZWROsGXHr5oEqqQ94tfEhc9fuj8K/p6ylmR0WSRQ/GMN3mPOTaMpoUhi3qDM3mEr2vkIqVbvCBXBomxA4+WtU43f2HuD2eNw9FvGUXbXPgvaXlXGCYrbKp1ZLU/HGDRM5obIYRZ4VuCJyXTMmNSZOhCI0XINFecV3x8VpohK9C1b1Vbv/UkfEWscCz36YpDcnIKbfY47oh9Ah1yq9ZgyXcpUJwKs1t0KAacyCPjGdOK9ZoJSnirtsA/83/CVbfNa2GHeV8QkzDn2dyo1ei4gj2OuWDM646BORSG+5iKyOwI1uZwX/I9HCE5LPtEIqIlQiJl+N5+lpulEEzYz4ZmO40qqNk2gS24KGNcYdPxJA3LYc4KGOUFbccl14p5z8EWEk8HZErR1WO+4jHT3BTAtu1xN+gw77ms+QE5JUfTHE9aLFghazWHuiPIdMmy71aRezahNIq6XppzECWcxjk33LnZGr+dSU5gC677zdn2qd1JycHU/HdXmqXfD7NjMl3y87MJD+Nz5kQNIcARFjWMaM6VsBBY9JKC9cDDtyza2igjPVwG+pBF6yZb+h4KTcMxCVY3WzYrvtncMi8a3Gw5fJ4cMSqyineD/SghLkwEnsZsUpqS8R3/KnXbIcCh5Qo2aqao3mpKXm8Z3v9+x8KRsDcp+aPmVe60QgJbcKftshwIXEtwkiSU2qRmGU6t5IP0JcdJzJW6hW8L2q7DtDAq49CWeNJMg8uusR7VHcGS7xAXxlLTcoy4yLPMlNBLDUyZK9iLzcRypS5xpeD5SHGe5EwKDFyYGtHUMFUs+GafqLFlwU/PXFrS5+P+iGlhxGMP+5nZ2hOYKf040jwe5DzolwwzRcMxu2GjwiiYO56k45r0MIB3OnXemQu4WatzzAUuDit6EaklK2qNfloSl7A3UXzeK9gISgplbHnbYp8Xo4ydseKdeZ9MKcPf1jRLvoHiH0wv+Ml8m++3FtlqSBq2TccTJk9aGD3DOiv8q8Y7/PP1gJotuOct4WgHT3v8i8VlrjVc5j3476+YJnEtNHRIyxVsl+es+m8xTg8pVUpSDBiJCbf4LjklNhYTMSYULk3HJlIFudI0HXh33sMVNv1U81l0YppLRxjEiyUjfkkLjpMYgYkofLu2xHGcsTspOYxjVvQSS76DbwteqzeJC02mFLlWRpiUGBixGxsuejP06aU5y6FNUK2rqTsWtpC80Q4ZZWZdqY1kznFN3jdQdyTv1JZ4qY4IpaHjzL1nmd3A2cC4FpSinxbsTBNa0ucsi/ClCZVYDm1jURJGxV9zJK91bJYD89+68phSa/blHgWKVavJou/QtDyuNcyEG5UlbcflPMmxtM3L6ZRCmbCQju5wo+7j65Db+i5LeoF37TtEuo8UNnPBTVMIg+ssO3cRQlKqFMeuU5Qxw/wAISRpOeT97D8S6QFKKy444HHyd6RqQtPd4DT+Ci0UQkg6ocnvnqouR/oJUjikakRTrrBi36Npr5MRsRv9mk35Fuf5M9JyxPnkEcfR5+yIh0yyYzruNSY6pS/PeTD9S16kP6cXP+Wh+JKBOCEWCR4+C6JBQ8/RY5eSAimMBuE8f2aKIxGuVcORASeTz0FIhLBRquB8+pDd+LeciwF1R3KtHnCnbc6tm03JO3MB0zJn3jcIzLzrMmf7KDQnScJm3cG3jBOn6RqBYSTG/22LcKIKltQa6+o6K7KFLSTOZaC26PNhtMdBHOMJmxXm6YsjBBabapNHatdMlMOIXlpwHGcMM7NHtp+WfHYRU4qSJ3Gfh9M+D/sZuUgZyHMGuZmuXWGxPY14x1/DloLTqOQpr3iSdI0ggQbLdFjyqtxmMaHtOAzKhO/ab+BgOtwRhlN9Eg2oC49DThjn5qZvOmY36HzFi5Vas6+75CLlKS/JRU6om4wrfqlQmu14giNNQb1Va1BoI+cflSkfTU5M9B6KUV7yIr3gSJySaxNKMdEplpCk2ixSH+Q5Z3HJqMiY5oqXyYB9+Ywzcc60MOksY5UihWDVC3G0uUl6YkCNgIbj0HFtfGmRUbIeBHzazfl4fEapdcVdd41AjlrF24dkxKRkbAV1LlJzEB5MSx7HPZMAQ5eng4w1FkgpqDvm+1kPPLpJyfOsy644ZCKmHMgXfBWfc15E3O+E1GwjXsmU5smw5Cwu+WoQkSuzX7ftSrbHKd245NXIWMVOY2OtcYXFcaRYDi2zMqxhs67WqFkOB9OSn09f4FuCs1jxZJjwWXLE356O2B4rLAnTosQSBlWY5ibU4yI1qlrfMrzgauhgSRhmmuu1GvOeKWJSCOJC8eacy9vtEkeYlZBLgcVyaBlLmy2527JoOprTuKweKMGcZ6bpt+ZdQlszykzz9XKSsFV3WAtNbOBSINiX+2yPFb+9GPLz4RGfX5iCelxMeDxIeK1ZVjm0IQJTtH0dUqAolRGlWVUe8H8+1IxyzV8ejVlVq3zO52RK8+8vnvCAB7zMLtiZmO9g0dfc9NtMCtNYnMWmmZoWmn84G/FgPOQ0yXgltnk6jPiH44xBZiDRDbvNgqyz7GvuNRV3GjkPBpJfdUfsTWNa0ueL/hRPe7gEBE6HUiVE2Tl75ad8Vf4DOcZ6Z+GYtZS2pMuAmiPppvBkYJrGlVCwQJtSm7VxeYW0XU7xjrA4jXMajmWCYSyLpcCkIy15Pk+jERdpzkmcV0iB0XGs1myuNuyq0TPWug+jPXKt+Hw45FDucSaPWAnMRHQclQhhptgJCathtYlJp3TTnGdTc+C+VEcozUwzM8wUC7JuoEzHYqIycl3iSklNugyVEZmNM0VKhhDw/nSHuFD0M5OIdxzlXFfXCS2LNbXBom1SBsNqkHg1TqvEv4ysVJyXE96pL7DiBbiW4LSYsmiHJKVmRbYY6giJ2ffsiTo/kH/Ee+K7ODKgJsx2pZazSc1dYjl8Eykd0nzAvGc41jjrEZVdhskO0+Icx66RlAMmxSlpMWRPfcnB6NecjT9H6Yx+9NKIuMop6/I+I3XCSfEYgEW1SScwsG2pUmzpMVe7RejOU+iUUqUcjH/LtnhATorvdkjyPreDP6XUOf1smxOeMRFDtsU+L/P3UVrR0HNckW/yPefPuWX9mMDq4GIU2Lb0yMsJobuIY9WxLBelC4SQvMh+yfvxK3pJydOBEdn++7MDPu1F1CyHqIBP+2OjHQgtNv3a7Do3HLMese5IhICwGnZ+3+tbw9Ev5TMyHZHriOelIi1HrIr7xIxwCYnFlFLPkeqCRTtkvtxgIE5ZYZ6OmkcLYzXoZyl122FUZCyJDuPSrAg7UA8AcGWdkV5jSa+yK5+SaLOpaS003d5+lOAJi0IrMhFzJM4ZqA6pmLDEVfxigSXPp0xNgpMvHLJScS2ocxDHnMhthjRZ0+u4UnJSPOFR6nPCK17X71CzHI6jwnh6Fawyx4E29pmmZRZzNxxT0C0hTBfvSpQ2HeicZ7bjxGR42uM0Klj1QpYCi1W1wHHU5qgYcdNrV4vqjbDnP0W/4pZ+CzJYdH1jMkdyVd2pDh2zOSkURsRTDyymRYfDsm8EUhQcZGNWbcNt5+RkpeZ606EWm5zlpiuJsgmhvcBBERNpyag4Ys25T52AtVCiMRt5doZm5ZgtBRLJUCVMxJQF0Z6FoCwHJq3oe/4Sv5hE7JSfsG7dp02dVT9gkmuSEraTMdd8o0otlUYIQVoVkOejlNXAQD4bdYuaDZkS1GxwLY8PRmfcVQucJSkLfsh352tMC3itpdiY3uIsNgvtG47HxTggJuUwNs3JGX3K/jxt12beN7udt8c5oWXzdGhWju1OUmqWzUbdJikVe1MzeTddySCFVV/xYc9MYb4luN4w3txL2HOYQzcV3O9Y2NLi2dDGkXCWJrSTkGEmKPXXW6kOpgUt13iDQdJQHUZ5yb9ea/K3xy41W7IcCOpJk6M44SKTPJtMWHfqLPhG0EZuhEevdwRfXhhY+agY4WDz4eQp17jLZhAyiq/yIj/Dp04pCiIxYX/SYsG3+fWgj4PNdxeauNLifqvk3+2krIYh9xoNtDYown3xGmexotCaXprT02Pu+PO803JY9jIT/1pKPhkO0Cieiy+4od6kIwNSVbCslujKVzh2nbyYMM3OyMuIvfoj/k39D7Ck4IPhOa4Vcs1apJ8WCGxartmOtT0uyXTBlIQ3/EUOIs1GaAL8G7bNg3yPLdbYqFl82DMbxwapQeM2rDXuhE0+jHcJyzokLXzLFOhxpshtwaLrmyasKOmyx4/qVyiVz9v2G7wYJbiWWTF5KcAcZIoQj/PEfCdrbp1+lpKSs6DnqUuXtmeiQUsNuvKcO1pSaE1X9BiKc35svWPQCTFgLxHkFLSpsae6rLPCuCgIM8lGzVhe/m54iMqWqhx1yYncZ5S1Kaud7n872KVBi9MyQyD5ZfSKq3odhSYmoVdIzqvlKSM5YIkGR9OCq+o6hVC0HIfb2bu0hE+hFdtiH2FLHHxWnNcY2+ckakSke8zX7jDNzkiyM1r+linAyRG29LGEiy9bCGHj2iFzwS2ORx+xX3xG6CywV35Kx75KoSLG5QmllVOUKQc8oO4u05s+oxlssmG9zYv05zT9TdJyTCg6WNhI4XCl8WNc5bMkrjHUe+QqxpMBL9NfEToLJOWAPfEpvtVhnneYShMj281fcNv6Mc/L39AMt5DCpu1eZVQccaXxY7rpM6bpMYFrzuvrDfj8QvGas8peNubtVsgo1xzJQ+47d7EFBJYkp0RpWApMPGk3MXqEc7b/2xbhcXnCD6w/4TM+nsENN/QWexxzop4wSY/Z8DfZcOv8tvjS4PaTj1gLrzEWQ1atuplqUewVF0boJfZJ9JAt/TYAhU5xqZOLlBNxSKomFCha0uZvog/Y1LfpyTPquoWlbQblPg17xXwQ4XGiX3FW7vJa+RYXYkivuGBJL3BWTsnTgJic1/WbPBJfUZOuyZe2NvGUx5viPXbkPr1yB4BbfJcvCqO6e9PbYJSVVapWxEEG77Vb7E1yEp2TlB7HSUpPj7gu55mWBR1RY6INz1Tmmk/y5yyoFW4FTZLSrEdb8G0O45R+Knmb7zLnm+JxaYD/cbNNoYxi/LfJNlP6rOvrHEcmku+lOmQkz0nVhA1xj6445Jr9DsdJRFce4WQOi0HbhAWonE+SM96wr/I4PSMVCX2OUDonYULLusK0AFvAi1HCnO3zQL0ABR4BNeHSp0+uDeRZagMlv0gv6MojbupbXFgHLOkFrtVCcqW51TQ3sYvFOC+Jy4JbzYDrtuElpwUElkXTNclbX/UTbjZ96rb5bwC33AXMNkXNb/sDOjLgrTmPz/uC7UnMqu/xVd+s2bvitDjPY67VfZ6NpzSpsxq6TAvF3jRlodpodb0hOYqMYnWfY27odSa5gaZzpfAtww0D/O2RgSx7KuLdVpv/z9E5bWpshD5xqemnhpu2hOTRIKHtOOxNTCBLYAs+60+43aixURNMcpgWYub7tQV4eFypO+xOoe24fDUZcq/WopuaNY/zbsnNWp2lwEDmpbZouiHLgeCLC7M/N5aGxVpxa2zwHoPcqMhXZJtMlcy7HsN8gbFOqbvm+/6uM08vKfn1mSIrFWexhRCCvNqC9nyUcL3hcaNhFOKHScSUhD9bWuRgaiw273ddXm8p/uZQcSBfkKgRNTFPo6JQzuQxCkV39JC52h2GahelCjy7xUX8nA+4SVPXGcoeX408GtLDlcbPflpMGYoBW2LVWFyUw4thzrkYMIl8UpGyQJsbcp1cKf5fF7/lFm+Qa+OuuGWvoDQMs5Ibcp0n+hULqoFj2TxQLwgTs+HmDW+Fr9ITVpjjz8I/YG+ScqGNlqUlQj67iPGExVil1KRLw7bNtU5P2VWf48o6nqzjUwc1R1t6+BZc5BkSc39tiTVcS/Lb7DE3uMGSWqCXZYTS5ppY5bDsk4mEXR7TEivMO8u8SC9wsxa/Sp/xGrdp6Q5zjsfz4oy8TKnTNvy80GzYTdzcpy97aBQ5KW21yI7cJyflbesun6gH3NX3uN7wsEQT34JRrnHSkN1syPPihBXWjaDJb3CQutREhwu1T1OuEBU9XKvGNDsjcDo4Vo2av8lN3uXz8j+hq8UUWTHgZPo5jhWSFSMOB7/AcxYpVUqqS8bxPkGzQz96gSV9xuIQ352jbi/TT17RDq+xLl7nQhyRFWN8u8UkOcK32pxPvqTur5PqCS/K35jPWkyJ0lMyf4JrN8iVWWM7jPcI6wvsyj0aqoOSJQO9y6ncpSFXqDPPLbHJb0qzmvSsfERZRdGe8IpPxy4vxkHVxOScygNGuYmQvS9vIgVMC820Wg7USzM0DrmCXJkAJVkFMP2+l9Ba69//2+D1uf8zHTXPSAx5Hv09dW+Fur3CtDzHEh5pOWLZuUuCUaotqk2e5P/ADfcPGYseF/k2LWeDOb1mBExasiRafKJ/zYa4x4viN7ScDWp0WFLLHMo91tUVBmKEox2zZFq85JZ+gx35klv6NkMd8VS9zz35B+yKx0yKU5r2Guv6Fg42h3KHkpwtdZspMRfyhLv6Ds/FK5bUGjviIYVOWRTXaOkOx3IXiUVOwh31GikFMSm5yDlQD7Clh8QhFB3m1fIMZgptSVQoDooBCkUpzMLyh+olY31OKDpkRGit2NL3CIXLV3zKG7xLpgvORZdQ1zmVu7zFm7Rcm6/SEySCDTnPqExZcUOeZ11KUfJeuIrSml8kj7CwSZjgVGrZVE+whVm7lxFxS92jxKzeeqx/zbvij6hZDt0y4lDuMFU9ovyctnuV71vf4XrT5n/rb+NrM7l5eLhYCASLbsAnxWPuizts1k3G6vNRzOe8z03e4/Vah8AWLPnw5UXBVsPmVxcXLMg6C77NoGpk5j3JcgB7U81pVLIQWFyrC94/zeh4NtNcMe8bGDBXRpn8+bjP3dCIwzZqksCCX57F3Gz4hLbg44sx83bAoEi50zSxgKsBPB/pSv0sZz5U3zIc7MH06xzrlis5jYyfcy8bz/b6LvpmeXymICvhg8GAH3Ta+JbZ2XuvDQ1bsx8ZQdGrUUHHM1O30sbydDDN+b/cgIvMZpALRrngk27CW3M+aQkLPpwlhlveHpfcblkseJrHQzOVv9kx4RofnEf8yWrIB2c5Cs2Vumv2ykoYZSV/vOrwcVcxyHIWfZdBVrAemoNAAaUy2b+roc2Cb/y/x1HJgm/xyWCIROBg8Vqrxu4kIy4LXGlxs+mxPc5oOBb/49Wcvz31+aPFjP/plRGpdPOEM3FOIqZkRLyu32Tec3iQHjMWPXZGP2W+do+GtcLh9COULgjced6x/xln8pSGarMiW5UoSzFR2SxDYD+Zsu7V2E8nrLl1jrIJsopzbbs2j+Med/x5LAFxqTnIxrzXahMVmp1pxLtzNZ4PzUKQSEScsUtBwiLXsHAoybkmVzktxxzLbf7Uf5ek1Px9+nMDoYqUTWWUxk3b5Um5P8tBfjjt05NnxIyw8biubnKnGXIwzXmonzGnlpnIEdfZYE+fsM4yZWWfnJAwESNO1BPuiB+yZNU4LAcsiAbbYp+GarMkm+zoI0binKvqjokRlScsqWUmYjrL6Xel5F7H5i96L81Aom22xKrRG6icnhiwrOeYkNAWIaFlc1AM+XFnnoNpSVKWfKw+whUhG+o6fXHBol5gR77gtr7LUEcUFGQioccB74jvoLRmRxyanIEqp3qcH6G1oigTNCVKFTSDTQqVonSOFA7D6BVSumw0fsDR5GOKMkLrDJB4jkknS/MLLOkjhI0U9iyistQZgTuPJT0m8QFCmBlS64KynNCq3yXLxxQqxnNalGVGzVtCCpso7yKQZMWYooxohlt07KucpY9QqmAz+C7d4gXDeI/52l2acoVb+jorgcu0MA37tDD3V0v4xndemMZjJXCrHfQlthSshJL3Ly7YFl9y2P+H31tbv/UkfJB+yst8yHztNkvhG0Rll7PoIb7bQeuSprPG9uQXtIKrSOHwUn1Aw10lERMcPJL8gmv29xiLC07Th/h2m3nxE1bEbc7YRamcVE1Y4wYjMeEkfcAJD/iu8684F132i894z/qnHMoDdkY/JW/EeLKOS52ePGNBXyV0OgzVIX15Tl23kFj0i10ObZ+chBvqLo5l0rCO5DZaKyzhYOEwFkMKUiwcHMzC+nN5zlCfEIgWrqyzqe+SipQeBxTM84gneCrESV1CXScSE0binHFxQiLuMdE9FrjChAH9dJsF7zYPip9yxX4HW3j01IgGISfqCVk54cfOn7NPlxdZzFXWOeGCZ3qXE/WYTnGV/67zFn81fMLOtMWJOGNdXyElpy8hJ2VY7JOVU5Qu2PDf47q6Y8Ri8oCOWuSe+BG2kDzSL+mzj6NDfNnE95okasQvi1/ws17K6+LH+MJwdTaSC8Z4eORKkZOwp7qcDj1e8Akducnr6ge0Ld+IuHzBaWLCREbV0nVbCAZZybxnm6D6XHKRSoZZybBMSaYO3djiTI2x8ya2ENjSKHg7nuTxaMpURDTdOT4bjDhJHHxp0WVAK15krWbTExdMi5A3wnnSEvYnGc+GinnP5WUyIE1SQh1iI2laHr3EGOt3oog52zd7nEOLpiNIBjVypclSzYOxWWEXF8aLfq/W4m8Hu3wn2GQ1lBzH8LIw8HRcGB/2QQE3/XZlnTIbxf7+xKLlCh70U76/6DHQEWnpc71hemBHVhkMDcMxh5aJLyw1nCRVzB4xZ3HIvG/zeDrkeDg01rjCLA/56FzxUfEYnxrrcovzcoKe1nnKK0LdRKEIdICbthlkcJxGXIgh80mbOSvAEoKabVEow5Eu+WYN6HFkvN3vZ1/SOXkHV8KziUvNLnmVDohFTCpiltUGF/IcV0o2axajbInflA8py6nxCIeSdnAdKSTX9JvUhIujXU7kNole5oZa41D3CAk51D36SciX5d8zTX/MS/UB3eIeU2kOfU/XsVKHbvmCJH2HSIx5W94F4G/GT8iIuSvucTAt2S8v2LTmuCgFTV5HIJgQM5Q9MmJ+XTyhbi3h4PMX4/9IzV5kmOyQOiOUzlGuYlNd4YF6QZ0WX6qnfK+4x4ncp5e/5Kb9Q4aihy9tfjs+YSh6Mz4wI2asUl7lv+bUWeY+3+epeEBdzONoF0cGnIkjNqw73LDmOM1iGrqNh2u2+rDCudrmhfiMm/odRvrMuBlEi7QwgqS8zKC/zqJa5IV4wOv6HYSEQ9VjkTYlOZ/zPqviHi1CPldPULLk0aBGT4+5kKfkOuKefts0d6zSZUxTL3LICbesDXbUOamI2VKvs+A77MZT5vUC990tjrIJIzFm3tkgrhqxYX6ARhHnF4TOAoU2HHkj2MSRAQejX1PzV8mLgKwcE7jzJFkf3+2QZmcoXTBfu0VSDABouVc4HP6SOAMpbJYabzJKD5nGu4T+JgkKV9ZQVk7DX2OU7DMX3CIth/TjXTynRZL3cawa7eA6mZqwP/kNeTGiHmwS6QGhtYAILSbZMbbnMdQJ7dLBrXzcAPPSKNND1aLjOvTSbBakFJUlfRXTzwK2vBZZeu9b1dZvLcya826YLFit6CXPWbbvUaqUwfQFhc5I1YTF2utckW8yyY4ZRq+oiyXG+pxu8YJOcJ0D9YCGnsO1amRqyi+Tf89InBOrPh3vGp6s81z9hq+m/ytS2BRlzCMMn5DmAz4t/46j9As8u8OoOOIse8w4PWSiewCsqQ2ULsiI6YszzvNn+FYTRUk3ecpj8TFP9CsUJYtqg4ZYxBEBmpKxuCBRQ6aqy4IyXWSo6qxwHb+Smh+K5wCkakJPHvEG9wh1nT7HPMj+mnk9T1MvorXhcwFiMUWjaLtXyXREzV7ksHzAafQlz4pf8Fn598T5BUWZsCP2OdQPKckZ6QRLW+SkTJMTPEL+t+FzYkaMiPDwuRaY76tbvCDWfebs6wTOHK7dwMLhhXjIc/EFdd0mFSkn8pCpzrjDdUqVcjL5jLPoIavqmoGc8nMupk85lHt41c7jtcDHw2PdqbNdnvN/aH2Huq6RkTMvt/B0wKITcH/OoZ/lJCWcRkY1XChoOkbEtBoam9DVuokG9SxBzZHcbtRo2Da5VizJBus1EwCSlnCYTjmPSzaDkDnd4vEwxkKyHnjMeza+DqqsXbgh10iEicFMS82OPuZMD3mVjAjxuO8vs+U3mLcDPGkScdZrks0gJNeK9dBM3g/7GXXHwNGuJfgXy20jeikK1mqmZ90Sq3STgn6quRKaglUojWvBnKjxRm2OOy2LuCh5d05zo2nzT1ZyhplmNTALP/7Z0hyeBcex4CASNGzNr88KxrlJnvrVmcmt/dPlnF6iuduWFBT8dHhkMpRliF2tajvKpozzHNcSvMZtlvQi00LREAF32i5b+ip/2FxjUXdYtZrsZ0M+yp/iChtNyXfm6rzWdhkUqYlTlIKxSlkOLO61Hf7RikEP/qz+NnXb2LOmRSVMCzrcsla4qa9zJ2zytn0dSwgajvHHX0yfIoSF57SwhEOpU6b5OQ/Ln7HHMUNxzrQ4YyjO+Vh9QiwiGsLjhFc0hEfdXual+oB5+zrrao0ldZVJfgKAS4BnNdnJP6Rf7PCyPGMiJpzkj1hUG0Q64ySN2eNLXqojXolHnIsuCRn3gnlaap5Bsc935R8hkJznz2g5G0yLc5bDN3FkgBQONg4v5RMG6ohn2S+Y6i5/E/9nPELesP6ESExoq0VO1ICXxQcMy0N8HTKUPQSShvTYcn9gVl6KEVLYTOlzQ64BcJ4/o+lITrKIT8u/40Hyv/FR8he8YJ9jzuhOH5GrmImYMilOSYoBBQln+gUTMWQsLnigXjAQI7b06+zLQx7qZ/TEAQOmWDi05LoRxfE5Dh4TdcYJF+QiZ6zOqMkFapaDL2wOOGWXB9hYRGLEuMzYV1+wqTYZij7b8YR9uYuN5MvilUFQtEOXPeq6Ta5j1pz73LJ+zIJ/ByEkW9Z3uCN/jGc1Wbbvca/x57ScTbbCH7FQe42mu2HOLenRCG9Q81eZpMdk+RgpbJpiCdeeoyxG5PkFw2SfKD1FSJc4O8WSPqPEZDUbvrpLoRP60QvyYkCc9czQJV1Gyf5sIvbdBabJIePihOPJp6zJ18y/50fcb7S4WrfQaKMv0cZOumo1udqw2UmMGG/Jd9hq2IxVikYxVim9LJt5+X/f61tPwsP8gEXnNoVIcf2Q4+IhDX+NcXJE3V6mJVaY0ifVCUJIAneR8/wZrlVDoYiKC6bJCak3ou1eJVFD5p0b1HWb0+wrPL9JqkZ07C1iq48UDqvhO9h4xEWPwF0wxvFyWh3iDdLSLIoepDvU/Xke68dIYbOoNlAojvJPSLIL5sKbXPV/gEZxnD+kUDHnPOG2+xMOs88o3JS0HLEl3uV5+T5d55ip7uKIkHFxgiUcoqxL3VvhYfRX3Kj/I/bTj9lx5+hzTKrHWNIlFC5HIkZUgRX95BX41wlFhyvaTPiJmBLRw7FqWNJj1X6dgX2EIwKO8gfMOde4obfYlvsmOhNJO7zGQfopDXeNBa5ww53jIs+IS81d+QccyBccTz5lIHfJiiHrzR9QV02O1UOyYkxk9Vh27lLXbR7q91nRd3GtOuuN75GqCYfiOR29ikYhhM2q2iQXimu1kKt1QT8LmRQFW3KRz/oTfOGQ6pwLtc9rfJedvE99Ok+mjEDhNI+YUwG+Jel4kq/iHtmkU/nt4KAYMJiENG2XUVbSUxHzMjTq3FzxSL9kYbrCUPRRuWZYDHDxyUho0OKL+BRL23REnbZr83RQcFyOCKmbwA5czsU2TbmCrRYpsdiNp9ys1Qlti0eTEatOjbNYM85LarZFVFlWWq7N6x3Jfz4e4WGTK48X6QUrskUvUZylKZ6waLomBMSStWqXskk62qp7nMUl01zQUxG/OW/S8YyFybXg8XjMtAhpupIH4yE3gyZfJidsDRZZDU1Aw8FUcFKMuRu2+bsThwfTC07jBg3C2aZ4IcDD4VwP6ckjLByG8YYRRFHwMDtGU+IPV3GE5NU4ZUdu80PnNV6piE11hdutgLl4wyy8yEzm9mpoxHa363XCCh4fZBJLmBCKP1s3fuRRbrzbX8Xn1Ai4EdbZqEk+72UkquB/Pj3iXGxXqlPXhCXgk2jz/G+om7QJ+URtm+B9/TqfqJ+xLK5RCk1dzPOQr+jHr2j5m5xlj7libzGQ5xRlgoWD1JJhsoNtBXhWi7qucSBfUbMX2echdWFiA9/Rf8BL8ZJxfsIV6y4axcP4nKHs4YsmH5R/x5b1HoWTIpDU7EV86nTzpzhWDVcHRGJIW65R2ikSh469xXn5gjP9lBt8nwPxBF80sZTNOD1kKfxjtstPcWWdCz01PnkRk5MxKU5o2uuclmPeFj/gr6P/O39l/5y2XKclN8DZoKUXeTT+T/xJ7f+Kqv9LhpzSZQ/PanDdepecjF39OY72KEVBS80T4NGSPqhFJmLCQO3TFm/wSfkBk/SE94L/3mT4ExPIDkfqCff5PgFv87z8iIeWw/fce5xmLrbw6OgmS3Q4ERdIbAZMSEXMpldjvrjDY3ZQlOzLba6q67TFGgNOcQjIiNFSoXTBgrzONbnIbtklkB08HZCKmDvqPrHOqdHE1jatYMVsf2NEpiM6rHGinhjVtmoSekts1L/PWfoIrRU1fxWtFUnepygnBgpXCUXRR8qAi+lzBBLfXaog7pA57waH4w/RpUIKm7yMkNJHo9C64Mvh/9sMWvmQX012CHWdLadDLCI2gmWeR2NKSqJBgIdZqbkXJXQTG4WeUZQAlWbuv10RXnbucl1v8Zvir0nzIQvBHSblGZ7TwhUhddXksPyCASbubMl/zXSX6RM2vHcZ6EMicUapMsbFCU17jePoc24Hf0peTjkY/IzAW6UWLvKa90/Z5yH9fBfXqiGEhSvr3OU77DjP6GfbdOQmp+UTtFa0vCtMdI9SpZS64Nh+ybK+hm0FCCQ2Pq+in9Pyt1A6J3QWmGZnfD7+/+LaLebZYLv4Lbv259TsRQAG8S5zwU2a9hqn0ZczaMO2AvaSD2l5V3iZ/oq8mCKlUe09dL+c8SMLXOG4+JSmWOKkeMypesht+yeE1FG6wJIeW9Z32Ck+JrTmSdSI6/YP6Oo9dsQhA33IuPLINeUqo3KfYbqH7XscZG1SMl4Wp0SiX91I5lLWgw1TkN1dXKuOEJK8nKIcxXbxIUJIzvQL0nJMkr1gIbzHMN/Hd5sUZYzvdBiKAbH2ueMs83SoeKPjsj0uGeUFJ/IUTwesy3kW+DFDlfDHc4vsjAuu1AI8C9bcGkmpqDmSjZrgi7FH0zW8cs0RvJykfGdukVFm1uytKjNlX3BCEg/JygkHxSc4Vo2xs0Gs+myKN9jJP6TjXkOj6GfbvO38c/42+ZhS5/iyiUZR6hyJxSQ7BReQMNEeUzFgPF3Dw6vS2DS/jF4Z/kytmixzx/zvpydxtV/a2M3eqi0w7wu2xyVdBrzlL7MaSj7NTnhL3qAbK2xpvMVncYklTYpWK/fppRlfpl1Kct7xrpp7wzfJcle9BlfqkuPYWHAuRR011+HtoENUaB5M+rzXnKObKCaZYCs0fuqstLjRaHCWhDxLJAuiwfeXfPanmmZh001dHorPcEufRET8s/Y12vE9vkpPyEXKVhByp6mp2YZ/XvAlUrTYHZfcalkMMfD4W3MmlOXNDsSFy/unJa4luNm0+IMlTXm6OCvc04JKK+DwYjrgYvoCISSW9EnzC07U53TCG+wNfsa0fsaG9TZJOcCRAY/FA9JixI79KTuamc5ESpuzyVeE7iJfqJ+R5mOyYkyveIUjAxreOr5sUZCwK59yPPmUmreC0jlrzh1eFh9gOw4H0YdI4fAV/0BeTClVyvXaH1EXS2zHjziut9C6pB+/Ii8jnMYPcKwahYo5Ug9JCqP+Duw5+skrpnaDYfQKISTUv89F/BwpHKS0saTHz9L/QFlmWJbLoeexN/wZrt1mIbxHqQtO468YuydoVbLYuE8/foUILHzR5Dx9gvQslutvMdIxEomipJ+8Yiv4ESMGZMQ0rTWOi4cM4z12heRm/U/5MPo1t4I/5kg9om1t8pX+hFIX+O4cx3KXLXWTfQz9pVF8pn/KJD0hcBfIrIiP8qd0yxdMkxP61itCdwFLeEzSEz7LH/P9+v+JsyTlF8n/TMvfotQpP7D+hGNxwaZeY1/AfvoxTXcDRywxxwZSS+KyZE99SWB1aOo6AxQrvs8n2REJE66pW+zrM1wR0tBznOguF+KAhrXCH7hv8TIZYAmbll5k0/mXPOYDchUb65HdIM2HlCqlUAkgsWRYFeacUiVonaBUzGn0JUU5QkofgaQT3iCQBlmV0sWSPq7TYM67wQijc9iiw6JaRArjN/9kcsaiZ0RaQghKpRkVGXVhhIWZUqS65JX4duroby3MCrwrtIKreKLB0eRj0ArbCnHsGr7d/h3yO82H+G6HokywLZ9Jcshq47ucTx9yr/ZnfDX+Dyidsdh4y3QrQpovTGV47hKu3UCjaLobnIw/wbWb5MUEx67zXf/fciaPzaQZv8J3O0gkntUiVxGurKPIqYkFzrLHLLi3OYo+oeGtsyHvc8Y2SdnHtzqcTx8SekumSKkCxw5Zcu/R0vO8LD5Ao5gkR2hd4NpNbCtACpu6s8K0OEfrEs8yh/+KvEsuUo7SL3CtGhfTZ7TC6yw6tznPnzHnXMOnTlt1eK4/Yhjv4rsdfLtNb/KYwFtk0btrYt3Kfeata/TVPm/wQ7qix0CccjL5nNX6u6yr6yg0++IJb/Iej8RX9LNtpukpgTuPLQOyYoxt+XhWE1+2GOb7TJNjynJCs3aLwJ6nUBGlLhjHezh2fdZobFhv8yT6a1Zqb7OqrvFa2GEnisgp2XDrXOQZV0KfflpyXEy4EzZxpOCLyQVvN+Z4PDYwTU24lJgNK0filLpu4uGQkpOLjD1lmpZpckI7vIbWikl6gtI5dW+FcXJE4C2Y0ACrhkQyZ1/nOP1idl/WnGUyNaFUKYE9jyUczqcPafobSOFQ6NSEyRdDsmKMQP4OP+Q5LVbt1wl0SFPX2ZEvuKvvGfW2zgiFS8d1GGQmoKZuO4S2CXUf5SZy9SzOOdQ93g1XeDGd8FqzTtMR/Lo3mu3InrN9ElWSa8UJPRzt4OJgYRGJiJvOEi+zLqdim+v6NQZixJxukZJzN2zzZXROJCesqGX25A7r6gon8oi74jrTMmfF98lKzXkem/26tlmU0i0j7jeaHEY5K4HDKDPWva2GTVyafcBX6xZHkeJVPGbTqzPvW1ypaUotiAo4S8wqzWfTMT3R4886JrLQt0zhPZiWSCApFTvqnO3iQybJ0UxU49oNQneBOL+YKVCLMmG98T166XMa7ioCi0InXEyf47sdPKvBNDNRiWvhe5ynTyhVRlHG5OUE35lHU5IVI+Zr92ZFMs2HADT9DQbRK5QusK0QWwYUKsaWAXF6iOss4Lsdlt3XOUo+w5IuUXqOazeYJjt4zjJ5OWGt+X1G2QGTZN/QTMLGseqUOkPrAksayFFV4iDPWaAoIxASKWxz30qbaXKIa7eZqwIsziZfsVB7jVGyj235xFkPpY29yJI+DX+NSXqC1grf7fCG/ac806bwXLXf40XyC+74f8rD6V9RqAjP7jAX3ORw+D6WFRK6i4zjberBVeKsR8PfQAiz7rRUKVHWI3TnadpGbZyriN70MRvNHzEuzM8dRq8IvWWKMqYoIzynQ9vfoibmOc+fEdrzOCLAwmFVXeWZ/gBftojK7ixvelQcccv6Madim4vUCMfedv8lZ/Kogm7PCGWHN8XrnJZjXvEpb/IjzkWfW9YKH6pPmdcbXJEL7Kkuz7Ofs+LdZ1Duc1/8AQdyn5E6YUXc5nnyUwKnQ5T1ZvdZVlwghAsotFZI6Zrv1JknL6cU5QTLClmqv8Ew2SfOTnHtNgB3wn/CBsushx5/E3/EDXWPgRizJRdZDm22Jwm+tBiVKRkldeGR6xJHmHW9X/JrTga//L219VtzwkoXnI0+43T6JXalXMuKAePoBcN4l970KZPIVH7T/XqkxZBSmZtVYWIgX2XvUw82mK+/zijZpygn+E6HZngd224jhERKo+jM1IRGcAVLelxv/mMWg9d4yofsRR/QnT6m6W9SqhRLetjCmz20Z5OvGJaHBPY8u+Nf4jtzuLLOoX5IhzVyFTPM9gi9JQK7zbL/BpblYkmPQbnPl9P/BVsaX/JC7TVWGu+xGf4AgWSaHDNIdrhj/SEtZ5NBvM0o3ufx+C/ZnvwCS3rEeR/PaVOomKnukeZDJBZd9YpUpEzSE6S0EcIy+a3hFtPkkJ3hTxmrM1xZp1du8574Q2wkhSgY5gfcq/2ZuRZocpFR6JTflv+FQb6HJT18p8Mk3jfJNnkf16rjyxb9bJu8iCjKMZZVr3ZxviItx+Tl1KgVw++Rq4iavUQmYpLsmPP4MbGIiQs9U872stQEyHuCqw2beRniW4Jxrrjpt4kLs5LRwSLTJeuBWT1529rg7cYcEsEL/SFPs5/RnTw0/kIrIFcxaTmiE1yfwYuW9GjaawgMp1S3VygxSMam9x1CZ4FhskPb3qRUGf3oBb5okhcjxskRtvTQWjFKDgDIC+MXHEcvKVVC299iGL1iP/2YSEyIMYdgrku6ekxL+hzRpZumzHsutjCPy34yxa5WWw7SskokanIcZ9ys1ekmilfjEoUmEwlDMea4mNBVE/p6whkvOBLPWLYalac749PiKc+KX3A6/ZKP0v+F7fw3TEl4yef8VfT3nIpt+nqfL/UvyUmYEnOaP2FQJjyTD3mVDDnNjdBqX+4xKFKEgJSMXMGOOuOzSReFiU58NSr4dDjgYXbMb3tj4sLkN4OJRP2LowueDBTdRPPB5JizJCcULu/5Vxlmmm6i+I/dXSa5SbKzpeBD9SGH+iH9yZfkRZ+suCAvuiR5j1G8zyTeoSgTAEJvEaULijJmmp9zMv6EcXLEav1dLOkhhYMlPereKg09j9IFUbJPqTOEkPhuB9sK0LpgnB7i2U2DSgmbUiUs22ZphGs3USrDdRqmKNohvrdCqRJaziaH8SdMk8NZEbQtH9dZNA2yY4IrSmXUu0JIWuF1NIrl+lumEdAKz2mBVjh2G60VobdMM7iCUhlRss8k3gUkc+FNTkafcj55RDvY4nT0MbZlinhRDNho/gghzBrIa/K7JlDCWyLOevxm/D8hhc043uPh5C9J8h5P4r9FCIktQ9NYln08Z46yjGi6GwBorVipv0NWjBlFO/Qmj5lmZ9S8JcbJEYeTj8jUhGG8ixQu0+KMurVEqVK0Lqi5SwTuAq7dMo298OiXZhHHItfoZ9tc5NvYSFrWOsv6Gsv2PXzRJFFDsnzM4+zviMouaT6k5i5xIc9ZUxs4eEaPU57wXO+bHPHsDEdYHOvHHBRDNtRNclJ+XfyUnJR57xYOHo4MeCI+MddC3KCpGwROB9/q8FrwT7GtAN/t0AiuGbSiqktC2NU/TTOudYLWBafjzyuqU5LmXQNri4KG4/DFtMtVdYeO7TMWFxyXIx6Px9XCD4sLMWTBCnkmnhBhcgciUury221R+taTsOus0Ag2kEgG0StKFbHZ+mOissvF1MSCSWlEN2UZzUb70FsiSs9w7QZJ1sOx69hWgCU9ovSM1fq7nEw+Nw8XktBbZBzvAuA7i1VRttFVUk6S9UBILOFS6oyynLDUfI9BtI0lPQoV0wquMk4OsS3T9dlWwDQ5xrHqXKv/hBej/2Jk79KlGVwhzrpkxYjrzX/MWfaYUfSSTv01tFbEWRcpHLJyzFx4iznrKjvTX9Hw10mLkfGyuXMzaXwruEp/+hzbCvHdOaL0DFsGNPw1mnKVw+gTLMul417jLPqKUmVcafyY7eHfz77rteb3Scq+KRjJEe3QTB7XeZeCgn0e0ps+qaLhbmALH01JVFwwinaQwsZ352fdfV70uNL+J3Tjp7PvcxJtg5Cstn7A6fjzKr4to127abj3YkqUHrPUfIclcZNFvcAL8RCAhljknzZv8OVggidscm3SuQRwnKR0GaDQ3HOX6aYpQgjGOuZR+QsAU/iFTZSdUxYjfG8FS3r8xPu3PBJfEZU9orzLkv8ao+KQtBzTcFe5iF7gu3NIYZPmQ9JiiFIJobfKNNmvAgLapHkXy6rPxHGe0yLJjIfSseqk+QWO3aTmrTBODlAqo+6vM0kOCb1lVv23OIg+NIePrFPqFK1LFuybJuGJlCW1xqk8mHXyLiYms6TgurrOBWMSEZEK04hdTgWXr6a9hi08xuUJWTnBterE+QUAUXpK3V8nyfszq0WhYkJviSS7YKX2NofjD7nd+GfkpBzGn3A1+AEJE1I9wRN1XAJW1BopOSM54DD/At9qsyJuM6dbPOIjAObkJutqjWfyIU29SEfPMRJjmrqBh40vbZ7yEk8H3JDr1GyLaw2LT3sJebWLeCMI+Kvob8hVjCtrnI+/QAgbrQtCb5U4O0erBCFdLBmy2fghu6OfU1b6jlbtNlF6jhCStfp32B38HULY+M4iWTHEtkK0VuRlFdRfoVKu3aA//op2/TWA2RScl1Ms6ZLmFwTuMnF6iOcuIYVDlB4w17iPJRz60cvqPS4ziXfx3SWsqvlO8yFFOaJTf4046+I5bUqVMk0OkcLFczqVuGdSWWXMpIUuWG3/aPYsNoJNijKhKOMZbfXNaf5yYjNnbIMoPcV35lkM7jHI95gkRwTuPEUZE7gL5OWUOD2fhZ+UKgFdYNlNs4+5HFXf0RxS2tTcJTyrRT9+hdI5WTFAa0U92KzESgWL9TfpTh9R99eQwsYWHpmaEqVn5MWAmr9ZWY9iSp3NGp3QWzZntmMovO7kKxy7brKm7XnG6SENb520HJHkFyhVEHgLZPmYrByjVIJjNQm8BeadG5ylj7BlwLvWP+ZL/Utq1iK5jpnDFOxXxW9p2mvc522+4BPqYp5u8YKavUSdefbTj7Gkx6Jzm5P0ARpF6CwAcDb8CKpirHWOwEJIH60SPHeparSgVMkM3QC4X/83BNonFqZ5HIsLUj0h0xFpOeK+9Y9oCI8n4ikNPc9UDDDxRpKz4hm90cf//8oq8L+jCNv23OwAawRXycspSdZF65zQ2yAvp8zX7tKdPqIsRlh2k7IYodEIYVU3atWB2B2SvDdLLRnFe9jSr0j1IUKYSdi26hSVRN11FkjzU3x3lbq3Qj96MXs/YLqcur9JlJ7SDq8T532KMsaxa1UHuY1l1Wc/R+uC+do94uLChJVPn+HabTynxTQ9RQqbW/V/wqvo50jhkJdTNus/5Cx9RFHG1YN6gRQuvjuPb5vJ7Xz8BXV/E99uM0r2DRKAwrFC0wVOnyCETd1fJ86MQKvhrdOdfIVVCQQCdx4hLOaca6TabB45Gn/I1eYfkejRzHecqgkX0TMWanc5G38JQuLZLZTOK+huMoPQWuH1GURoJuULPGcOrRXt8Bq96VO0LnCsOp7TIkrP0bog8BZpuKtk1QGYlmM67jXKCtm4ol+bBUUEliAuNedZzKE84D3nFsdpxBPxCdP8nDQfGg4/uEqUd4mzc5TKsK06jWADRwZorYjyLpZ0ueX8Ac+yX6BRzHk32O3/Db67SqESFmqvzeB0jSLLx8TZMVL6lOUU22qgdIZSEQuNd+mNv0RTYtsdLOHSCW/SnXxFUQ7w3bWq8RhhW3VCb5FRtI1t1VE6w5I+dX+NooxZ9l5nWW2wIx6yrm8DMC8aZhp2bT5IXzKnFrmQ55wVT/GtDk2xxJQ+w/yAojTCvUul5iQ5xJYhUtqk+QDXblKqjFJFAEjp49mtmSCxKCMCd7Fq/jqUpZkMlc4pyoTF+muUOmecHNH0N7GFxzDbQ2vFqv8WR/FnKJ3jO3Mz/cMK1/kq+k9GmeqtExc9XKtOWoxQuqDprXNbv8tD/T4d6yrzaplIGJHOdb3FF3zEJD+hKBOS3DgVyqoYWFazavASav46cXpuCqzbYRy9QgiHmr9OlJ4CELiLROkh7dpdBtNn1cQyh1IFeTlB6wwhXHxnnrToV5NomyTr4jlzhhPURhDkO/M4dsgo2kbrnHqwxTTZZ7HxDpP0hNCdnz2Pnt2h4Zv7oB+9nD1HaX7BfP11BhXKp1EoldAIDL8vhVM1cgkL9fucjz4hvCxaKmaz/kOmqsfp6GMs6WNb4ez8Cr1l4qxHWU6MOEir6t4okMKdDTW2NDYez25xy/9HPIn+mjQ7I/DWibNj7IoSK8toNvUplVbnrotrNw0ymZvGXulsdi4AzNVu0xt/iWU3cayQe8E/50n8tzO4VgjbcKV2Y/ZrUvrUvGVcq87F9Gn1Xbg0gg2i9AwhJEnWBRReVQilcChVitIFjWCDrBhX5+gQKWzu1/6cB9O/ZLX+LnvDX1RnlU3dXyPNh79zfer+Go40CNqW/T32yk8ZRTtY0p9lVl9Ez/AdQ4u6ToM0HxCnxxjFlIXnLJLmp0gZMFe7yyDeQeuClcZ7nE8f4lg1vuv9a+asgMNyQC5yAu1zJo8QSO5xkw/Ur1gRt8lEzKZaZ0rGvnzGot7kSfoPjKOnv7e2fusiHPpbpuhIn7KM0DpByjpSuhRFn0tk27Zb3+gu97GsEEu4FTZvV8kqEq1THHt+diBd8kd50UVgI60QIWyKYojnLM6wfa0SbLuN0pk5bO0WRdHHdYw1qFTR7GeAQgh31rl16ncZRTuUKqp4AlAqRsoApSY0wzuk+RDXaTBNjgGFVhmus0ChIizpV9xImyQ7Y6HxFlHWpVQpeTlBCnfWITpWjawYM032qsSYZNa1akpAstB4i2G8h2PVqqzUDFfW6E4e0gy3iNMuQkhcu4FtBdySP+RU7nI8+ZR2eI20HFOUMW1vi/PpQ0qdgVYU5RjbblVNkPlZAgHCxqnguVKZzs626tiWXx1yI0DSDLcYTl/g2CZVSCDJywmu3ZzBb3HWQwjJXHibNXGXuq7RFxf4OuRCnjBVPVwRoig5HL6P1imes1xBkBMzoWTHNIJrM+TDc+YMt6YS7jb/nHm1wEfJX1Aq031L4ZAVQyzp0w6vMYi2afhrpOV4hnSY62CQgGm8S+Ctz/5MXo5YarzL6ehD2rW79CcPgRIhfEDRDG8wnD6mHtwwVobpc9zqAMmKC1x7bjYpeU6L0J6nJuaxcXgx+ftZodYoas4yp6MPWWi8xSg21gnXaVCWGXF2jGO3cawaWis0JWk+mE2LIHHtJlkxQqsEaYWo6noBWFYdpTJA4dpt8nKCZ3cA0JRI4ZDkvYr/7hjBShVQkJfTGT+ZFQPq/iaBM8fZ6BOa4Q1zXZG4ToOas8w0PyVOz2eoVl5O8e0WvtUx02S6TcNdY5wdEWXn1VmgEdhVA+5gokIk6IJGeIOsGFOqjLzoAwopAwJ3mSg9xLaa+G6HaXKM1gVa5+Y5rrbaaDRSBmiVsNz6Af3oBfO125yMPkYKl5q/SpL1Kyi6YZKa8gvq/iZJ3ud6/Y85Sr8wQp4KSRPCxbZC8mIAFeKmKxm6QGDbbYpyUj27BVLWZ81A6C0zTfara9aunvOI0FtnmhiRaj3YIsn735hUJVon+O4aWiuyCrlZabzHweDvzZklfZTKsKprL4VrOGd3ibycmOuvCyyrbqbiMsK1jDc5zo5xbRN8YUmPrBhSlpPqLKA671Kk9CrEwZzD02QftKrgelOobcuI6mr+OtPkeHaWWtKfFXPPmZtB7c1wC6VyxvE2ttVECts0LrpgvnYHpQvGyeEM2ZDSZb52h97kMY5dp+6t0h1/gWO3qftrjOI9889oB9duslx7k0G2S5SeY0nXUAT+Ft3po5new7UbjKKd6rO65MWIdu02gd2eDStf16zSnHCyhtYZWpez+82228zVbuGIkElxyorzGiUmoKNf7CCFY+Bz2yyFWJOvMREDJBbb45/hWg2mycvfW1u/dRF2nCV8pzOD/aQwoddKTaoPEaCqyDDPWTbTVnaGtELKcorA7B9u1+8xjvdQynTwjtUkK4x83HT/ckaeKzXFqm6sjeaPKHRKKDrsTn41g7lVFZdmfMUTfGfR+MascNYRa13gOXOk+cVsCs2KMZb0yMspeX4xm5KawRWG0SvKcgxobKuNlG4l2DjEwE4ZtmUeOHN47OG7q9XDkeC7S+RlVDUrObbdwpb+7PswD+OQ0LtClO5h2x3z8AuJUhme0yYvI3ynQ5Se4tpNVmpvA3A8+ZSsGIAuENKlFd7EkQHn48+qBzf5xkFSctmMmJf8BiphpiyAorgALCyrhiojmrVbjKKXWDLEr6CwrBjNHkDPmcOxjXd60buLomRanjOMd2kH18hVbKCscmSma7uNLc2S96wwxvxxvM18/Q16k0dVQxdWh1iGY5m/O0oPEAhjxs97s27ccIEmAs9z2ihV4LsGHsyLCUpnFUR9WMHvZprMivEsXUdIF62LGUJjW6FJ71EJ7fpr5h6tRD2qgqrm6/dIyzFZPqZeKXBvyR8ylBfsxr/FsWuMoh3ebf6PvCw+oOms0Y2fmntZ52zV/oCYEWfRV7T8LS6iZwjkrEG7LIyX10tKH1VG1XutrqEuoLp+QsgZZGsmtGz2vPruAkl2Zp5V6f+OkDLLzQSS5V0cZ468GGFZIWUZzdAYW4aGb7QMzF6U8UwsZ0mvmryj2bRW81aIs+7MIiKEN3sGHbtOnB4iZQDI6pwoEdjms+gCaYU0gy36k4em6c67v/M5L+9frTMCd5Uk76FVUhVlbzb5aZ3PfnbD32Ac71GqCM9ZIPSWGMcH5EUPIZzZ9Kl1Rj24yjh6gcAyTY7OEMKm5q0yjsxBWguuzs6/y3PGtuo4Vs3Ev2anCGFhyRApXbK8h5QeUvoE7jx5MSXJjrGsxmzqVSpBCBelpqYQqATLqs9QrTg7rc7aDK0yENIIQp1FCmVQkUn8CilrKBUjhIWU/gwltK067fAa3fEDQGFZ9arxsGeFHSFBqxlqWfM32fDf42n/P+BV9p7LCd1cj2pCt8JKZ6Fm59dlo3rZ+Kb5OXON+/Qnj5hJkGb3sOJyIPPdVaOnyc7xnDZZMTLNoN2iUDFWdZ8JLOLsuOLO52a2pLIYzZrVVu02UtjEWRelCrK8i++tkJfR7yChl2e8wGah+Q7no4+QMkSpFM9ZrFwsLqG3NENr58KbJOWoGuYSbKvOXO0WWTklzYc4dkiS9cnLCY5VJ8kO/qs19fL1rYuw5xpjuRE31IyQoXoTSmXUgw1G0StzADiLFFVBLsqImr9qeJDCQJqe0yEthtT9tYpnOca2QqzL4quLSuCwiG+3yVXM/23zz3k0gF5S8LP8PzOK92aQUcNbRwhJd/LQcGlZv4L3Lioi3gataIZbhNY8o+xgBn/V/FV8u80g2kZKG9+ZwxI2cd6fQYBGseiRlePfiVGTwp492OazTmbQ6mD6zBToZN9w2Fad0F1kkhyidYFdwb5ApdozSspN6y0KUTClzxV1i6d8SFaawI+ijFnw73BF3eJB+dNKDTqgE1xnlB5iSbdSRZuDM8vHM6jZscKqkTjGtVtYljubLpP8YjZtmgKnZhwWXApTIPSWmMQH+O48Le8KaTnEtzq0xAoZMcPykLi4IMn62JZvHiRhz2588z26+O4ceTFF6RzXblBzFilUaiweQpKVk0rgZh7+y/fm223i4uLr/59f0HQ3WNU32ech4/QQx64hkIyTAzYaPyAqewzjXUqd4TudGTVx2RjYlk9eTvGcNqPoFa3wJtP0pPJxm0Yzyfv4Toe8mJpO26rRsjcZlyez91zqnFVxj93iY/Jyang3b4W6XOI0+WrGTdnSwxV1puW5uWdUyjQ9wbUbZIW5vwJ3gSS/wJLeTAPhWOHvXFdzGErDMaoYpbKqITUH22Ux/bq5S2bPwiX8acsQS3ozXjIvRziWQT80Ct/pzD574MxRkwucp0+wZYAlbOr2ChpFVPZmcG1RDAi89QodGqFVhpDujBtWpYHZhXTRKsOpDlJzoBlbCTBD3C4/p1aZobjKCbbVnBXmyyKw0HiL3uTx7By5RO0cK0RgzZ5lc70j0IpGcIU0H84iFbNybLQmVVNkSR9L+mSFobwsaaJcL5uzpr9hBIBWQFHGWNIIjQJ3oeKL48r5kXz9swtT9MxnU0jp0wy2GEYvaIU3mSRHX2tv4h3awRZZOWWaHldnhTkb27XbjOKdapgxFJMqI5wKTVIqwXcWSYv+THFdqAilMrTO6dRfn93ncXZanUnNCmp2kcKdNXbfdIaY76uYKbkBHLtOqb7+d9sKiNJDrrT/hF7ynCTvE7jzTOLdqgmIZo1XzVv9xme7hOONuO1SxwEYRXrVoMfpIXaFJNmWT5SdY0ufUplYSykdJskRNW+5Om8Vq83vAhAVvZmdybFrlV0tmX0/AomqaLlLRNSx6gA0/DWSYkheTGeN6GUtsKSHbZn30PTWaYt1tqNfEiU7/9Waevn61j7hS37RsZtk+bjqUtqmYKKYxAdcTrFZYQQSntOh7q9VN7BXfZk1pulxxRPl1QcwUJcjA8bJoTkspeEPBBab1luMcsEPF0qW/ZLDpz/kqV+QZBfYVkB6yT9Jn1X3Pjv5ryqI2529fyldxvEBsdXFsWrM1e7MxAeXnEHDXUVibC1XgztMdA9FORNJLdr3yHVErmKSYsC69w5nxTNcu4HSOUv1+0zyk+pQk4Y7Fsaz5lomDUZKl5X69+knxmNYc5aRQuILU5A7qsNj/QF1ucSefI5Pi1zFlKU5KHvpcxJnNBOcbYTf4yD68GtIXxWUZGTFEMeuM83OqmkrM/yTSkjyAp954rKHFDau3UAKxwhotMK2gtmke+nBsy2fKD2bwZua0sDhOsNyHKbFWaVqtWfKV6UMtCyECR1xrBq+22HTeott9Vs8q4XSBcPEKLpb3hVyFXFDfp+uPELbyiQFZUYwlakpSdZnuf4Wq/omu/bnjPMjAtfA43k5ZTl4g172AscK6WfbLLn3KPyUJOuT5P2qiWyb92OH+HabNB8ySY4IvVVajtE3NL312XW2pT8rwA13jYv4udns4izQkEvkJOTETMWAUbzDreY/p1u8MMrs0hzSSTHAt9v041d4Tnt2XzoyoOatVGpURaGTykpl4dst4uy8etYaMxjXsWoVNxeZiRWj+rQquqdUEUrLWdGVwkaRzaa+2a9Lm0LF5uAVlakaZiLJy2Zimh7jWjWO4k/w3TkTnK9iBvkeWpcG/q0QBstuzorZNyHPNB8ikGg0llUzKIR0sWWA63wNH5ppz56hOWYar4NlziBLhhX/mUAVLuPaTeL8AqfyxTtWzeyuzfv4zhxK5yYspCrAvtNhzruBIwJ2459XRSSdqagvEa68nFKoy0bANGSLjft0J8bamBQG0vatzoxvtaRnonCrgcK2/KqomGb9sjlSQiKFgXRH8Q5S+oziHWwZMk1OyCsva1qOidPzGcpR89dnKunLAnyJ4gjpm0ZaBhTCJi+nM8GlI22kdtFCAYph9AKqMCDz+exq+je/tlx/i2G2R5SeorWxfpmGOKloKZesGNEINsmLaGalUrqofq/LwejXaF3QCK5WwjujDXDsptHeJMdE6ekMvbMqqsy2QqbJPvXgKtOqiKaqa+7NCv3QujD6gxxTsKvvX0qHJLvAEi5SOLh2s7K8liTliGH0ygjidIYu1GzoKy/p0tl3UVQZEO6seRnEGXV/jcCZYxjvUlTIUVaODDXn3uEiMRxwX72qOPHf//rWk7BltWfwjxAOjeDqrIOZ/WXIipPNcJ0l8mIwgz8Cd5WsHM8gjZq3auDDCsI1P6OOUykh0+wMjSb0jL9t3r/Flr5HV57xbPSfCbxFJvEuttWc3fCFMofSpYDDwIx1inKE1iWWVZtB0b5jDhPDGQ1xrBpXgx9wmH1Oy9lkWV/jWLygKZY4L18ghU1LrnNTX+c3xV9X8JO58IG3gFI5bfcqJ9PPZzeLY9Wpeyt07C1yEi7Sl7NCcOm5Ppl+PruYNX+lQhNM5xq480zTY5Ybb+OKOqfRl5QqY7X+LseTT/GcFr7dZlhxqpdTwSVcpFVC4K2T5L2qu7VnD0tRxrObxJK+4YGjVyw33uZs8tUMvpwP7zDJT4jScxrBBnHWJcm6uJWd7JKPvOy4PaeDEJIoPa04dMOBXdIAAEneN5NPdaDmxQitU4TwuNb+J+yN3591/K7dpFDJbBIVQtIKrrIgr9PX+0gcpsX5bJo0k4dBXW42/ykT3cMTdUblEWkxIkpPK03A1/qEmbpVZQYKxIhXfGeRJD+foT2Xh/D5+AssGRpPthXQnzxhvv4aobXAefxodugGVodhujfr6KUwEPhldx96y4TOAqPKg5qXE8pyimN3sC2fJOt+431eqjrFrJBdTjVCOFjSr3j+y+JlzyYL82fNr1+Kl77mmOXsWfkaVrRn99E3p1NDT3TMxKdLijKh7q3QnTxE66KCmeXsPQpEJag8Rwingl/jCjr9Gn69XK5uoOoKfRIezfAao+lzhHRnVJesxHuX34vWKa6zSF4MZqpXx5mjKCMDzyJ+Z+o2v8+cBRvNH3E4/nCGEqgyoh5eYxJtz6BZp8pAEEJWoh41g6wvG8yav25W6BUDRtH2jO4BZsruUiXcbf35LIQnTs+rZmJc8eZGgJYVA7TK0JQGVpf+N+5XZWiDYjRD1y6bW/PMHVc0lY+UFdR8ed8Ip9ISGIHcJN7/mte9pDGq5kxXzpHLM7ooo1mR9p151oP3eDH86xmc7lRcuNbFjDt2rHqFIMiZwPESkawHGxWdtFtRAsWMnjSNW1DdFzat2s0Z+halxxXk7uDac5X46xQpPZxKnOY5rZkAVOmMmrdKqTLSvG+aRKtu0KBKuzONd2e0x9d6nW++vnbxOnZnhhRcUpxJejJTXV9qllxngbwcoVSK1im/7/WtJ2EpXZDuTIFnIICw4v0MOV/3VhDCYhBtMxfepjv5CtdqUAtv0J+a3OXL4I1LYY8RoIAtQ9L8fGY9klZI4C5WRvGEo/GHHPLb2QNjprMmpYpmcIItQ2r+CkoXjKIdQm+ZZf8N9ie/mXHDl5OEgfDMIueat0JeTnk1/Tmht8Qg26XuzTNM9xhxwJx3g1j1iXSfcz2k6awxzA+o+Sv0J0+Q0qbpbxKVl0XNdPilSknLMQNhhDnjeJtmeIMbzo95mvw9fmAmQWN/yBhOX9CpmxD6NB+y7L3OdnbOND/Hdes0K9Xl/vAXCGHTcd/mZPp5BTMbcYgQ7kxgYFk1HDukVKnhGq2QZnAFRwZYrkMfyIsJthVWymmXQqW0g60qUatvOsisjyVdkqxvJjR3AYHJA1523uR48ikL9dfxRIOChJPRpzhWnValIA2teQ7HH85Eb0u1+1zELwCMwlfN49ttsnKKS8DVxh/SzZ6x5XyPWEwpSMl0RF8bumNBXue8fMGyvM2QUzSKm/U/5ax4ime1jL88XGGsz6vpS1XpSiu8F/xbPlUPOYo+Ic0vqoO8MIfbbLLwsaRHzTV+Sc9pETqLXETP6EcvZ0rKvJxWE1adN+Uf8Yvx/5Oav4pnNXFlnajsseDf4VR9SVEmOFbNNETCrhASA7lf/qxJekJc0TDjeLc6FNRM8W3EddJwhN/gf8E0Dd88NL4WQF6qYE18ZFa5Db5uQKqCrTJzeFsuSiUVx2qa28tDWlj1mZK1FVwlYUBv+nQmEjIBFyMCd5lpsgPCIc1PuXRFGDhXGgEa1ozD1DqfFVApa8beKIxy/JsvgWXed9UoWNKnLIsKym5SlKNZE2WaDwXCMUVAZJX2wwwRWiuOxh9jS5+kEuksNt9lnBxC5b0tyqFpbHVRNQoWoXeFabIzK4xUVNWlu+Dy915eh9mWIK24UPvERY9JVXzMuVrDd+Zn1EyaX5ifpZkVXCFdXLuN786R5oMZTG8JlyzvzrQ0QhhBqyVM5kFcRjSCq6T5kCzvolQ2Qwdtq06pTGQjwq2U24ER9AmXxfqbDJOdWTFDm7Myzs4ZuPszD3WS92YiT0N1ZF9zupVwLcmNit2SdjVV5nQ802CVuiD01r+GxCthr1vZhooyNsiOalXoTTD7DMbhYRT+eTkx4stiOnseHKtu7GEqnjW+ZTnBceZmuqOg+tlf62Z+dyYVCKxKoHpp/zLDQdvQDLMG0kDmmUpmIuTAW+XbvL71JCxliFPBz2v173A6/XI2pgfuMqVK6YQ3acs1TvMnlbAlo+5vkhVjWsFVM/brnMH0GZYMjTlehoTeEq5VI8oNkR5np8gKWrmEdMwB1p8pc1XFE17i963gKmk5IkrPaQVXSApjDI/zC9J8yA/D/4FfTv4flYLS7CD2rTZRfk6UnXOt8ceM1Rm+bNJLn89sOJeRiMP8gFG8QzPYMnyZ1SaUHQ4nHyGlTakyat4KhYrJiymOXcOzGlxMnxF6y9TdVcbpofksMmAY71HzV5gmJ9iWT1EmtMNr1KxFDscmXtJzWmT5GM9pzQRoobPARfTc8KJOh6iCK6WwaYfXqiSuOZOCZdVNF64zbOnPIGalit+BmU0hCWbF9nrtj3C0S5c92mKNs/IZljCBKBpFL3qKJT2uBj+gIGdNbfBKPDIPhh5XD0FBx7pKt3hB015jWp7TsFbIdIQlHE6nX9Lw12lbJhfYksaA78sWNTpY2mbIKakek5ZjbOGSFEN8u4VntRBIlriGox0OxTM29V2elL80+eakKEp86pwVz7hivcvT+L/wE/9/4In8ilRNaMs1usULRpVP+DI71q92n67W3+UifUmc9czhLkMawRWu2t9hr/yUBfsmr8b/wFr9OxyOfztrLueqhec1dwlHhuQq4op8E0vb7PA5pUpxrfps7+k0PTMiJ5UQuouztLlLSDotKltJZeW6PDh1xft9Mw3IrqYzo/S+zjje+1rQBTO+7Wsbi4n4uwwxuPy9Upoi3wrNoo9R9ALbamDSomozDvnyYMuLAZYMqfmrDKfPAIVjz/+OfiIrLrCtprGNlREI+xuTfYmUwQw6vRQzXloczaviur+BAFhWjZq3SpoPycsJrfA6SX5Bmg+qyVmZoi7smeXrMlDDiLO86rsrEQh8b4WiTH5Htf21y8L+RiNkc6v9r9id/Go2AFxOfVK65nmU7kxt3azdYpqeGjRFxViV8NB35k0RK6dIGRioWhcU5Zh2/R6T5MhYNqtCcCkkdKxwJjiyrPpMOBpn59UwEsxsir7bmT3Xlz5rVUHXwKwBtSvRY5Sdg1a0w+tMs7OZDuFSId8Krhp/NWomhpXSN8OWt0R3/ADLCnGskCQ7M41XlR5WVAPcJSJ06eLw7BZJ3mOh/jpJtWzhkiJx7PrMCnspcrtsQqR0Z1xx3V8jzrozb/glX6uqpk1Kdya8lJXYUlTNktYGAfv6fvt6Gr506lxy15foXc1bYVDd6/C1Y6Hur1OUCWnRR5URSn/taviv1tbf+zuq1yXkoFTG0fhDwHj6AncZgHZ4jUxN6BYvCO15fHcexzKex6wYMYx3SQvDZfrOIkp/3ZXl5ZR+9JKyzChVWqn2osq3aW6WKDufdVyu1ZiR5ZfhE93Jgxk3FWU94uzcxGgKyUr9bT7O/tLEwQUbs2Sdy6JiVe8jLnocjH4NwLg4oSZMt3cafUnL2UBUijtX1uhHL5iUZxQqIsmMqf2bwpppckxv/OWM/7uInpEWQ6bJMZP0hE54oxIBmClDCtuIdMpzIy6opv3AW6DtXqXlXakmbI9rjT9mpfY2thWYAJHaLdqhUSUbLjbHkj5SOLSCqzSDKwaGttszAYHSObblEzhzBO4CDXeVmr+C1oqaajIU5/jCBKuXOuciMoEsUdFjKXyDm/5P8HWNkpzn4gsDDakhLbnOpniDResmh/EnROkZw/yA3uQhp/FXJGWfcXEyE3q4BKT5kLq1RE0ukGvzgB2WDziZfk5WBXu0bIMC+FaH08kXZGqCQrGtP2WBq/TkKaE9z2H8idkbqs02Ha0VJTmOVeNUXDDIdrmIntErt1m27/Fm7V9ztflHxqsr3Ao1uKhiQI8rn7pkrnaHm9YPOSg/Z5Ic0S1eoFRmAlCQeE6bZriFXQk2hJAUOmGSntAXZxyIJyTFgC3rPZQ2GdeB7KApafjrKJXh220a/hpt9ypzwa2KT6wO3ktuSxvPuV1NlVK6eM4cvlsJvyzzOS45VqCCm9XskDfccKUMr5AApRK0Mvm6ZWWN6k8eMkkOq8PPCJbSok8nvIltBcZCI13EpX3GanIJ1+ZFnyzvkhf9yvpGNdFcTg+SZuXnlDIw9AYSY0miUu3apuhVR5VfnTVfNxGZoRe0KW7j5MBA5P46QlhcKrFLFc045jy/oCgGFZIzRz24iucsIqRrlPY6MxA2RmVsV1ZJpcyvSysEFHvTXxufujK57bbVxK6gTqoYXvNmJVF6PhMFXhbb9cYPDN8vbHx3eXaeBd4irjPPJD6gLEY0w5umYFbvX6mErBiRl2ZCVhWUC5fiJePVTvNupdXZryDa7te/z5mrUAiJZYXMhbcoyogoO2ep/gZSukRZb6bxuPwcntPifPyFcUjYLRyrZs74MiKpNrBZVmioo9JM52VFfVye3Z7d+UZDZL6TtBjiWHXORp+gdMFceHum3M7LqEIBlmfXXOucwF1Ga0VWDChVwjg5ICtG+O4CWTEkKwaG5hMuomoApHRnrgjPmcO1jfPlEj0xL4VJTRfGQkb1fOiCwF2cDUPT9OTrP6K/FrDFWa+KRw1nMPXve31rONqqOrzLxBRLeiR5n054Yxa2Pk4OsIRLXxkj+qVq0HxoE2YxinbQqJlSNnAXKFSMQJLkPTynbUQmlWXiUmErKqh1Em3PukLfmSdK9kl1URX8BMeumwIjwyr1ZmKWTFe8TJSezfyO/XxIx7/OSfYZg3KfJOubeLz0FMeqs50cMVe7xevBv2Cn+KTq6EdcRM9Bqyou72s+NM7OCb1lovzcPLxWHaUKE/ZRjGiGxhNrW/P0po9NEVbZTDU+SY5w7QYNb51peoxnd7hp/5CUhOPyoVnTWE4ohFmSbQmH78o/4nM+IhQdhJSEtXlcEVK4KUJINtRNDq1XJLJPaM0zVAcoXZjIx3iXOe+Gia9UMY4MSKXNo/S/0PGvMyqP2I1+zkbzR8SyyzAzvsfjyaecVlPOesPEXZYiN1Nt/gR9mVhT2QfAcJFtf4thukdeTJmv3cYRIaEyMHumI06mnxN6S5RWPksjmqYnJn+4VifOzomzcxPzmZ1x7BmoORMxNg6j7IBSpYS6iRYK2/bxRJ2e3iVKTzl3t4mzXpUrbfNs/DdsNn7InF4hqd3jR9YP+dv0f6VUCaNoG99dINUFUvp0Jw+JfbMb1bUbyOqAVzqveLuUpLggs8aVUtRimhsF/uH0IzynRVEmDN0eaTEyDVbQQWDRsa7S4+GMGy69glKl1F0D5dkymKVANYKrlUDLOBPMhGG+48vJ81KoY7r/y0QnOeMw4esifGl/MoEfRkhlJmI140K/Xs2pkMI0xbblI8T815ZFK2ScHs6mSyncmW/7awgZ+EahjbOeSS3SBYVK8JwORTlGSu8bAqwIUUG8aXb2Db7aqoQ0ClUmCIRBx6RLlJ7O7F0GfnZRemr+Tl3MoPckO0aIdVynQV5OqsZFISp18KV97NLNcDk4KLIK1je8rKE1FLVKb6IqqN+pMogv3QYGIjXKbkcEM09zqbKZp3kS7xK4q8TFCNdZIMn75kxJT2eIhVEuy0qU1pgl0OXlBFuGVVNSTbnSJ8l6FbJoFM+WdLFtE7UpkCaysrIAnU8ezRA6S7uzZ/XSQXKpGDcFcEg7vM44obK1mfs0So+59IVrNG4VCgMYh4n0Z/zspcAuUxmWNBnfo2R/1oRpXdCufMRUiJ9ld4yivUJsav4qZZmRMyUvI1PIa3fpTR6RFQPatduM4z0zEVd2r8s8AtdushS+wUX6kkkZGX+7TgFdBUFZ1b1qRKuXQTlf8/TZjIM3inwXrRRfe9x//+t/V2zlJX966c+9TBNSupiJsi4hsbnaHYbx7iwY4tKvFucXZMWY0FsizQezAnTp3bz0frl2gwXvNqmeMEh2DLFe8cGXYpFvBnJfvprhlvEGlmPDH1SwtuFmClq1m6T5AIAk6zJff202QWb5+HfsCZfS/4369zmJvkRKc9Nfvlbt13kV/XzmUx3H+zMhUd1fw7ManI+/qOwgPlu1P5jFHvbL3VlcITDjLvvRS1yrUSkRU1rBVd7mxxyJU0Jd50RuM8jMhqSkGHDd/RHnbNOPXyErrktTmsjOMuNG8BM8fJ5mPzOyepUbvrn2Jktc5XHydyhtJkVz6GU4dkjHvTZDBebr9+hNHuParRlUmuR95sJb/P/a+88nO6/8TBB8Xu+vybzpkQ5IeAIgCLoiWSxWUVWlqlJJqpHUmhlpZmK6x+zGxsbG/hP7Zb9vbMR2bO9Ma1rd8qZbJZVIqiyLHnQgfCaARCJ9Xv96sx9+55x7EwBJkMVqSK33iWCQzMx773tfc87PPL/nkSUNrWAZlt6g8RvZRTe+Q2SItI1R5ygUScNW932hEFSzF9FnqjqT1mms9d+ka655yPNUjFrx6xol2zD1CdjGONpsDI4/PDvBZURJE445JZiZk86j2A2vomrOYgyL2CyuY6v7LuMftAS5gzMyD3hPoxmvCDMNz5qDH20hTlvgc8Zp2oaiOCySj2AZDfTDDWR5iKp9EG1/Gapii2oRb9EUQ5sZNzTh/XRefm/FN6kMCIhSY1ZQia3NnIgAoOGegibb2O5fABem4fP6AESmy2VdAYgyqVgwhHiNL1pCXG5RZhk2J1JpTAoRgOBUuNYBYp+ymc6C9wNlE2PeKWy232AlYyqVCzZwHoveJ83TauJ7DY8SKYoulLT4XCvPAg2tzhb4AWs6zXyaV032iG0tCFPqoLcNCYY+Di400/WvC7LWYAY7By/Ny7IpiIB8bCXLQ1G25Ypm1BckswaJvZafJ1kiIQkyU2mDs9Qz3rsvBqpeBTIkbH3ixFJ+r/LvyMlSDfck/GRHrFW6WhViL8PXn8/0jzrHsdP7AIbG53fpuapac2izliEA8LGgKGmTxHBCI6i2MUMsc32UaSvookQtSyr60aZ4NhS21iaCyGeK68IDPV2tiVlpCbIYn+OkSDL8oO/OnY4AiPPNpYijpCU4RbSukQFPlLSFpkFexHDMGYwahwUBVlOpT7xfdCSFpY/CjzaRZl22upOqFr8P+UQBF2zial7DZEhxH7E1WILyQOXoB96EHfMQFEWHo03AkUdhwsWy/yNBKtnuvsciL5vNGI4KjdSiiOGYs2w8aYNtzAMyAY80OQVeU1y8YP8enhsnPeI/31rH+e5/gMIeDksbwW7/spg/5cPngkHImKIy27Bpbm0dulpDxZzFXv/yPrWXjPUHqNRHZCY/2hYLlaWTgLyljWBWPoN6UcEjVRfNKMeH0QZy5OhLLeTIsBl+CABMK7spdKIfwaN4dMSEKgN7EZnW/yi4iKf1Y7gd9tGSurie/AwA4EfbpL6UB/D0KVSkSdzyX8ekfRqVYgy3s3ehyAYMyRMLOC38Y3CNSez2LlJ0mMewtBEacWJGF1HSAh9DGjEOIczb6LHSiqLoyPNUqD7xgCNOu6hZi9jzr4rFNEqb8Kw5pFmAIN7GpHcOzWBZKDaR5F9L3D+8VyYxQZKG+wi2e+8zUQFiAXM2Mgm4tMSDTML6Lp62/xtsyGtY7rzEBOXbyIuYmPrhOkaco0jyAKpsiO9saw0aJ2IKQpvdd8UCGSe7ADJUnePoh+swdRLkD5Nd1O0lVNVZbEUfQZEN4jgw4Yw896EofJzCZf2tNrhIBB+zoHnVFjym00tjUQ4sbQR+vMPMyG1RGeIVpiyPkOUh0qwLzz4o2jQF+KjLLVEipfIzmalwqcOBchwtCppaQ8LkXamcCvBxJd6R4gzxYQs4Yhab4prZBs3765rH2PVb4OIYABi7t8MWqh6KIoQkmUJ+Vugbpy3aKFh2RmIaI0xoJWUMakOUJAfStzq4wh0Awaw2tAZIirXFAu4uVMUTQjMAMGofRTu6xQiMBBL9oJIwn5keyIP2ROBCwQqVI7nsIrHlKTPm601epJisPIbt3kdI05ZQt+JqZqloF9HGx8WI+DmQWemUzxPvF2AZBAlg7Y847Yj+uiTJGHVPYrd3EXwMjbcrssyHpU8gTttIBRsbImDhamGmPg5TG4EqG+hHW4jTtkimVMUSzzQfK51xn8Ba702kuS84ESS7OyYIUrQh56jaS+gEN9j3jsWaoMo24xaFQmSES/2iyAWRikrgdYTJtjj2dKg3DAwqQfy5SFIiCSqKLkadXGtWaIzziQddrdBIW9oUlRLTIN5QwIM+xhlIMp9kmVnylGU98UxVrAUhUkTPUQc5K71/Eh64J8znGB15FI/JJ8mE2VwAAPjJDjEoi1yo7fjRmrjAfAO21BoTQIhZL6TBTmCONOuwURXW6IaEOAcaRo7Rogouqu1Hm9jrX4XKRbYLFi0zqT/eFylYph6nLcbOo17Ydvc9wWhTFJsN2FMpZdQ5xtxWNGZzNwJDq8LVaZTEj3fQk1pYsG0cqRQwFAlnrUn8euMAzqnHMZnPinEpk5Wd4qSLx+VzcBQVo0YBCUBWAAuuhMPFQWgycNxz0ZX2kKQ+LHUURZEiiHcwZhwjHeBiGzVrHpViDNeiH1G0nAdiED7PY4w4R2j4nBN+wnUURY5etI6aNsduqB2MWIdZKamLVnwTO70LIOcYjyL/IZF2VSFLxDyP0WGLF5/Po4WWNuBR5ziawTL1QlgLgtjALlxzhvql1pwgcuRFis3OG1Q1yHyY+jjyPBILIlcE4+MZgIwk7eDn/f8Dy91X4Flz8Nj8ecU+KAIm7sqUFQmCaAdh3ETLX0GWR9jufYSd/iXaqNgGZhsHYBkH0OlfxYR3FjVjgdyn1Arq6gJ6+RbyPGXD+aZ42BSlgizroigS1u7ogksRZpkvnHvSLAQXG0nSDjxzGn60iX60hShts1EU4iQQC1pFEK3BMhqY9p6kaxbvIkx2yZEo2YMfbSHL+jDUqqjwcFF+2rj9QT+SIUlbJIfJVI/yzEee91EUGbF5i5QYy+z6cBYqQH1GLpHJq1H9cI3Uh5QKyfspLgpmDlCxF4hFWqQAFBRFhCRtihZSwohmRZERyZFtunwBr9gL0NQ6ijxGmnXZyEiGokhY1p0zwmHM5kUzRPEWAja+Qs+2hgI5CZ2AsvjN7nkErNogSSo8a1HoGQBUTuVBHVds4+pcFFCZ8KN1Gu8qBhaGvFqmqS5MbRS9eBOuOQ1J1ulvMx9R2oSp00YsQabsNw9Jtpdl2YY2wo6VStOGVhdzz5KkwmaCRKriMiJYhzg1Eiv7Fjl2uu+xwAqCb5PnMTS1QnatRQpS9DIZl6AqgkVdHWGjPG20/BXkrJS61XkL5JGs0/gX+3xZVnGr+zMhrGRqI0xUhjYnTiblmxrPwPlMO9jmN+GcZueQj5mG4C5VmuqK2WdJUhFnXXAFOCHqwsae+H6gyiZsY4I4N5KKMNllXCFuANTc92zwdS7Ng6ERwgxhvMXEnjQRtETJHtK0jQIFspxc6YQQDmSxuUOM6t497nR/PHAmXHNPoShyzBqP4yAO4HzxlrDAUmQDmmqjy2bPUv7QCwUVG5rioG4eRDNchqOPoxOusn6vPNSD0tlNSAxGTXXg6OMI0xZ0xUWTycfxDLhmLWCvfwWyrGPCPYO0COEngwFpRTaQpH3Wv1LgqGPY9S9jwjmNbf8iVIVo+d3gNibcM6hI49hILwIA6uo8duIrMNUazkrP4e38h4izHjJGRqnrizicH8fb+ctwFbKs6qR3kOWR8EctkMGRGtiMLqBuLOIr+uO4GG4jlkI0sY4gb2JMWcJufgMRU+Pyoy0URY6KNQtLrmO99w6mvcexG17FIeM5bGMF/WSbZWzUw9YVDzP2OayH76FizGCnfwl8HjiMm4yRSGWiur2EgA22R0kTsqwLZiFnGXaCW7BZ74NLt1l6Q7DaSTrSRD/ahK2PQVUsdPwbMNncbLt/BaPuI9hjmx4kGbriMeeUWAgeABDsVgCsBKWzzZk0eF1zdmhUJRclqhHnMLPCDEUZkM++8vKqrjUQJztwrHn40TqmK1/CWvtn4FlF3T2GVv8aiiLFqHsCaRGj4y8LQwGeZXD9Xl2twTNn0PSvI03boHKpB64KFsa8VKqxbISyQK6HzsttGvs3zVVOod2/RI+u7IBnozy7pe8TifI574nykZzBz0CZJwZEGjoWVTxX1Afer5lOo0o5dHWEyD6SKnSr88yHoY+LTb4oEqF37lkH0OxdYp8hi7Ivl0Dk8or8uvHj52U6gMuqAny2mOZ7e/vK5Hnep7+X9ksrFkUMCcM97f3ldjE3Lcn75mq5UtXwZ5h6Q6jr8fn8brAqKnQpG3/h0qI86+WjVLwdwAMq/sxkeUwVACZDSdeI/tZQ6zQ6U+SDfi7L3oYVsDiL2dJJJpPP4fLWB99cLH0MfrgqKhcqy965X67Cqj+mPoJeeIexl4m46pqzYmS0Zi2iw8Rz8jwVLZkR5xh60QayPIZtjIlZXP7s8YBwxDmKVrDCNn9XVDckSWbKYMvI8wA6s4EEIEhbPLDhft9FkaLhnqSW3lBrw9TqTG8+h2POoh+u7Zsc4NwAsKqorlFFj/rv+6cH+MY7zJ4WuuGMd5DnEVTFEwQ/Va2JPW6/1gAnQcrsdf0H6gs/8CY8Xv0SJuVjGC1GMWs6WAm7SJDgJj5AmLWgsoc7K1KosoEo7cBUazDlKjb776NmL6Iuz2ItOg9LHUE/3gJXfbK1BlrBCpNQI+3QqrmApn+NvWc8mB9mdXgJsuhPpXmISfcsdoPLMLURPK58HR/gdYzIs2gXGwiyJmrqLHoZefU2w2U0rKPIigT9dBuabGFEmUeIHp5SHsVOEmJVvoXN+AJm9EexGr2FPE/FxuYq4wjzNh6Tn8cb2d/jnPwitqUmjMLAlexng5k0YWAeYMI+jYl8HuvSdZhSBRvRB5BlDaqko6LOoJttoBOQX6qljyLLYkzZj2LdfxeKoiNOuhhzTmK7fwGKbEDXPATRjij3a2oNSdqhsh4rgcVZV/TaeKYry6SoQyIZfYyah0Xvd9jAm5tcDC80XLXJ1OtiZAGAWEDm3eewFV8UsqF5ngrji+GeWZJ2IMvkhONH62h4p1BX5nGt/bf7eoiypMKz5sQogCLbbPGhaJ8bT8TpnmDvZ1kfujYKx5jcJ8fJfa2HCU0VaxZN/zoq1hx64R0kyR5kxRbSp3HagsK0vrkxCA8CKBshgQhOJOKiMDR2k0JVauz6U3k0zbqC7csJSUURAkMMYAAw9QlE8RZUtQbOzKRFro3ByAwfr6FzoSgVIQnJZ2EHfIlckHJ4+R8g8Q0ySWnRbCwbIRr04Rjhi5X7eK8zzbrMgYYzRBUh0EHELmpLZVkPVfcY4qQLP7oljp1mMRVhviJEO+jEgIse0DmKUXWOIIz32IZAvd6iyNjr25TdsYydj5ugyGHqo7RZgDIlvinxc8FnxA2twbgUJBzD3Y401aHxJ0bC0tUaKS2xTJiPT9I8qy+y1kHfeL+qFxmQdCFJsrjXANDoExNc4eebB2meNUf2pGxTIfIalbVJ3OcGtdxY75kHBPxzZUmnoMK/Dl1rMDehtijb0mjjQbT8ZWiqC27+kechDK2BKNmBqY8LPgN/ngAI2ce8SAUpa3gkimfJfASTG7f40S3o2pi4Fpxgx9eqLI+EUhkPUg5UnsF2cBF+tAZDa7Br6Q/1oQcE3uGRLQCidUMOXeuDWW4WwPL7m8+7UwCZMNGQoXl89hpZsRnpj7T5dW1UPDN8+oTbtH6hI0pjyhK+O7KIGcNBN8lwyqviqDmK79gv4Gn1W5AlDRPqcZxVXkRWJHhG/3WckL6EbkrsVlOuopFPkoh52mLzqT340TrinCQBLUbjz/IYI/IsyPieJNR4j5eXIUx9FKZSQ5TsQVc8RHkHEhTEaRc/8v8tevG6yGpH1YPw8yZOSF9CWkSYsB7B8eIUZCg4q7yIKOtgufdDNIoZ/CT9KTroi410NXoLp7Vv4pzx61CUgQzmIelxvJW9jIo6jRvyCjrSNlaKdxAlbVTUadS0OYRxE45Gjkq9dAMXk1cQFV20skFfqh9vIUeGosjgmJPQFU+QozoZZda8RNyKbtDCj2zfDCZtAKTHesj5KirWAqK0iSztsBGxNhOyj8RmqMsO0ixAK74pCA7Ui4xhGxPQ1RGoLAMkF5SYOUJVmRBJCM+cRpy2MOoeR5aH2IwuoB9titKbwvp6iqyjYs0iirnhBm0KcdqFotjY7V3Ezd5PWSuBxgoMrQYSgG+zB4k8XGnDZ8YTWciG9G02GjYGWbYQJ9vI8kiUFfMiRc1epN6rpFLrI+tgu/MWiSh0P0CStoTZSMe/joZznKLrzEeSNsFlHfOMxGGIpFdDwzvDPoNlYbLF+kkK0qzNonMD85WvQFEc1NwTbHONRcnWMmYgNldIiNMO01/2qSfKeA88Y+QztdS3VQEoVB5HxqL4XETgwuObBRHxkFNQlpHZBb1GFqMjnHQJABDlaxpf4j3FKNkEuU8prPxLn8sz0iwnZnK7fw0N6ygdO1OGkqCS+lA6CCoKZDB0qigVRczKfH2gyNEL77Ds0mbP/jgUxSEhC0mDpU8xV5zBGA8Fcikb60pFuZ7uG669zck1sZDq9Kx5uNYBpKzsLksqxivnYOoN4mGoVRhqXWR3NFdMRCC+EHMnL9uYQM05QgSlzCeOgjFGWaI2IhjkJKpTASQZk945jNhkkTnlPSGyel3xoCo26uZBprkQI4h2xIYdsCqMbUywZ2ECLpO49ONtuPaiCCpU2RLcDtuYID94SYajj0Nhs7dV5whsYxyeRV7mY+4JuMYUmyzQIEsaDMXDiL0EXfVg66Mgx6U2Zr0vUTk6H1hy6qrHVLjG2ZiWjhHnGDxrDqpi4oD3tOCgkO+yDkOtwzVnYBlj2PKJjKgoLiNicQMgIpQWTIjEMsZAwkK7YlOecOkZHd6AFdmGolZY1TUVJXpx/4HsIIEBj4L/d84IfZJkQJK0ITKvgUn7NGsRhvdR37o/HngTvhW+gXf2AlyOt3Ar38GtXoQgzbERxBjRdMzJpxGgg2X5MurqPDawiyvSO7DUGmr2IrrpBm5IF9CwjyNOu8JH1dDI+D7PUzJvt+aQJHu41nuZKVuF6CUbqDuHieyRUwkpjHfJvkriGrcZDlsvwNLqsPRRTJtnkWYBja0gQV4kWJNvISsi3Or+DK+l38ed7ht4O/1b1HRSdrqevg5LqmMVF7CTXIOuuOgFq7iGt/Fm+KcoihyWUocmWXgv/I9w1Un42S42og+QFhG2Om9QPyFvC/nKSYkeqCjrokBOSlRpC93gJrrBLbjGFG62XkGPjeIkWV+Qmwy5grq9xJyCBtqxYbyDbnAbo84xmPooJr1zMLQaHGseW9kVREkbtjEB05hkuqk5m+k00AvX0PaX0Ys2GNOQBFMa9nEosgFTr0NXHMYijlnmQ+U4RXHQD24iiHfEHLLOZDOJWKGxhb6LOOXqMinCeAc1ZRaGPo5p93HIsklm9TlpxnIt14yNcNCCqCBOdhhZgvrLPhvhCaJ1JOkOsjzEUvVXqYyX9dgYQcxaATmCeBeWTrPeO53ztEGwzyyKlM2C6uDON4No1sauf5lttjqVohjRqECGoohEKa4V3ICmVMQmxd+X95F4r2u5+Z+QZX20eh+xvqsuSpRR0qJZVbYh02hPn/WMCxTIYJuzUBVPyO4VeUh9W0mFJCmoOsfY9zFYuZckETM2ImRoDfHsqGoNjjkrskcJkpgz5uVpYkLPUitBa0BXR2AbcywAkCHLxJmgoEBnykUFsqwPQGILoAQUKVbbP2TvnUCSFNTcE0izDlTFg6pWYekTUJUqjSAV5D/L+82QSJQmZ0p3RZGy/i8thJpaQZjsQlWq0JQKNLVGLl/MojNK2zC1UVYxyhkXxBELtM1UjUyNNtZ+tI6Ov8zaLGSyEqYtODqNNcYp+VZzoX/er+R9YlU2WanZh8L06qkFQYGyoVSYIpdFYjxpByojf0qQ0U3uYLd/CVnmk6etbCHLfdg62Q1u9T9AnHPSU4d6oUUOUx+HodHkAjfM6YVrA7EKiSpTk86jkCQZVfug+D6KTO5rWZHC1sYgix5oG2HSpPGpIkHLX4Ef76JABkUhVS5XGkfVmEM3vANHH0fVmkdaRDDZDK7M+td5kWDGexqpMAvxkRaxCJa3g4vChYjWJV8EOdxwAQBsfQyOPi7aT2GyS3K1rIJGZGBfXF/LoPEoSx+je5wlLbpaFRU+oV4mcacmFWBBZc09gTwPYRqT8KxFkt5lVQqVCaXwUnSctrEVfsTK4abgVXwaHnhOOEyauGh+gHZyG7rs4I6kYbv1Pma8p7HTuYw0D2BoVdT1Rdxsv8QeWmJyzlSeRju5jR3/InsY2eB81oMhD/q/tjqCfrINidX1/WgTeRFjQj8Jv6BsJEWEIg+gaWPC9i0vYuz2PkJgNMFHe2ytgjjtYs55BnvpMgylit10mWaB8xiT2gncTFpIUh8t3BTWiHzUpG4fYj1oGhvKchIBSIsQ68Eynjb/K3yUvyn6rXHhw7UOIkra6EZraNjHoUoGOtjGpHEKO+k1UqaSdCRShlH3BLrhHeywESaux+ua0+iGt2nezUjQ7l+ixVWxkaR9Uhdj84etYBmGVsWOf1HMLfrRunDCAcBuchc19yBZ57GSmWtMIskDum4yvUfNOog09xEkTWhqBWPOSWx034amVFC15ilQYCpcVOIzwF2XJFVGN7glpEZHnKOI0g6SrI+GdwrbyRVkeYwt/0PW8w3Itk1rIMn6cIwJdIObMPQqioypOjEika6NEzmEycdRb9OAY07hVv9VqoaoNcTpHmxjhvrVrG8GUJnJtRcRJ13I2ggjTXXhWgsUxKUtcA/YjM2r2noDu70Om4vUWSlZFRunUB/KQ2RFzjgQhChtiv4iOebETHAhBbeEk2UdWUrlyiIPERfkVetHt8UGLjbcglTk9jMtJQoaWNTe7l9hs7JMv1kyUBSRkHZN83DfqIgsqTC0Ois9gs3Sp6jYh9ANViHLJhxtAkG0LcacCKQwpSiOaAvw0RbyEM4AFODWgjzrlmWDbBezLrUXinwwDsJYsKSXrA3aIaznFiVki6epNoIoZgYQuVClso0Zdt7bTOSGrwup0CMgS82KkKi1tQbN6jPhEC5RqqtjCOJdFlDm6EebGHWOIs764FKIhjYLP9qEpY/BM2ZQIMN29z3murOGUfckXSFJgW2MIc1Cdp5j7PlXoUg6rQUwxdgSbTQhgniXlXSp196LNog9XZAhSsU8AFtpoDAz9ppYlJHHrOO403sLQbyLqjWP3d4FZOw8GUoFUdJGM15hGgM0wlPkOQy1iqp5An66hzBrIcsjzGjPYTV/C5PWaewm10EiSqooOed5ik64ilF7AZpkIc19OCq16TrpHTjqmLAdpRZXIBKTI9Vfg1FYuJWeJ3MQtTJk/Up7gcwUvIJ4B7pKbPwobSLNTfSYRenx6u/gZviaEEmSIMPSG0iCW2LGPMscBBkRs+K0A5URx8JkF0WRYrH2daz13qS/z0mvmipUEhSFPh9FjjDeQiiqNgUsfZz8votcPJeaWoHPzIlcY0r4pH8aHjgTRpEjynvQZQdh2kJWUGlzy/9QWPzFSRdnpLMgbedNnFG+Bl2tYq3zGsJ4j5UOaZwhy/rQ1QqTJEsRRDvY6V/ClH6KKd5QdFnkMZY7L2Gj+7a4salkN5jhBCBcTxaNZ3Da/C62sYKadRDLnZfIiSQja8IobcLQarjW+QHyPCVT+KQNTbZQs6n0UjEPwJLriBlbNy9SGGodljqK3f5lOMY4tqUdBOkuDMljfRIZc+aTGHEOI8tjbHTfxpZPKlHtfA1zymMAgJ3ue3C0MXTC26zn6EJXK3CNSQTxLvrRBmx9DFnWo7Eb7wyq7jFUrAVkeYgx7Qj10Y1x5l+7QmYXrB9WtZdQteYRZ112bjnjMBsQICSdxOaDG1BkAxPGScRpB7v9S+iGdxAxedA77Z9TH7WgxeOQ9TwOOl+BY07CNiaYI1AVZFvHZwN1TDqPImWl7aJIYSujCOO9faWpSedRmMYkltwXMeGeodK1bMI1JjHlPsbMualkVzEPUClK0jHpngVJeo4IpqNnzbOeEFe86rKxJgtBvAudMYkBCgCXKt+AqlaRpH340SY8axGK4iJOu+As4G64xsryxJY39Qk0KmdBcokuy3hlNmKUsU2HGP856wWmWZdprXNpyVBskryyUXdPsV6qDrAMlnSYR5BmbaRZB5rqssBVYQ8jZdq6WqHSNgpiFKMQ2bCiMEUtiXShVdmkcQ1BPLrJBPGJPUsksVl2zWJkWR+9eJ3IRowR61nz0NURVOwl0WYokKLLRtcGCkF0nDJjlM9UvwxJUuFHt6lsXKTimGWW6UFSoamjMLQG6s5hVk6XhTk9ZTkhXHuR+nF5KNSQNNVB1ZzFtPs4Zt0vYcQhxaVp93HU7UPw423Iso4l90XhMRtlHZzyfhuWSmQwR24gz1OM6vT8REkLE+4ZquxkfVhqjfWcaXTPMaegqQ5awTL68RZsYwoV/QBUxUUnWAX5LQc4pr6A4+aviGxJVzxkRcwqARY01YWlj7IgnDtd5ajbh5DlMfIigcc4C5Iko6EuoRmvoKbPD/WdKQDpZ9tI0g61Y4oEnjUvAlGNEbXGjROIEiK6qjIlGzVzAWkewVRq4nMSRDBY0NvxbyBj6wDv+WZ5hEfM7+CG/yo2+u+iah/EZv99zEgnURQZdvoXYapVkenKkiYmI26Hb+NG8ga4qYkiG8gyH5pagWdOY958GgDQ6l/BQOgkZaNcVJ1SZBPX+/9AZWfWB+buYtPu4/QMFinSPGD2riamvCfYCNUoLH0Mimxi3T+PJOuxyRwqcde9R6jMnHURxpvw7EOw9CmWAVPlKIx3kGVURTD1BooiEfKtNMoWi73p0/DAxKyqcxJpFsLU64iSNqK0jXH3EbTYbi9JMvrhLRClW0WeB1AVT8yHGlpV+D7yoel5+xlcbv0FW5hHmHky2XmRqbcslG94s1xV6/tIPtwphDMvPXtJCE2IWTrOlgPpplbdY3DUMbSjW9RvZSxGTgrRFBfcj5gbPGdFDF3xMG6fRFIEUKBhtf1DqEoFJEdHykVfcn4Pr/b/LYa1nSfcM5Ag407n5+AOSQAJgiuyjRHnKHrRhojOGt4p9KJ14f/LFZA01aUMmY2TDDOLp9zHcLP5A8HErFkLkCRFaLFOumcR5z304y340RpUpQI+xjVZeRzNgEQwkrSHir0AXXaRFRGa/atiHhKSjLp9CLu9i/T9GBu6ok7jduenMJgEpqXU0Us2wBXSavZB7HTPQ1XJ2rIb3BJD8pytaulTqFnz2Oq+D5V5H/fCVaiKC9sYRz/cANcaTzI6xlbvIlxrAVVjDuudN2nDZ761QA7bmIKqWGj1LlIJkpH50ixAP7gpPEnzIkGcdqCrFZj6iBCjqduHsNe/LBiUGXuwOdO2Zi1AkQ1stt+AqU8gL1IcdF/ALf91xGmbvG8Zk5LfW5zlSgIgjJTETOX9aFOYovCyfJb5UBSbTQIQG1lTKpBlFYZWQ5oFzG5u0NdKkj3BDFcUF6piU8DHyGOcJcxJZXy8z9IbQvUuTvfEs2cZM2LG1dYpU+RkJy5+wjWaqUzYH1o5ZFSdIyiKHF3/OhkMyCYazjGEWUec64p5QHi1JqwPTgFGLtYMQyOuQZjQwjtTeRq3mi8Jv2ISj6BMZNF7Abf9N1AxZ9EJV5FkPo11ySoFZooHWVbF501XnoIrjeJO9B4rizoI413UncNCf54zczl3Ysw5ib3gKibs0wCAW+0fMx4FzZ9OVZ5AkDXRDzdE0qApFcTJDqruMUiQ0Y824BiTCOIdtlYFsI0DbPpgXVQuDlSewU5wmc0Q+4jTNuYqX8Zq9+eCrdywj2Oj+zay3IelT2HSPo0b7ZfBNZgdfRx7/UuQJBUVawHd8DayrAfHnEWS9uGYk0izgAWjEJoK3AlKkijTzPIIfrQJm/n1SpIs9K9dcwbTxhmsRefRD8l1qihyHKx9Eyvtl4U3Mf8MPhKXZz4UxYWpjwqdfT9aR9VZYr1vlWWeqSD+CQ9gRtZTFRdxsgvHnIMfrUFTaxhzTqIZLAsNdkU2ccB9CpvBh4jSNvkc+yuQmBIYJ9NRK4g4G5xASCVqSUy+CI4GOz8URCVQFE+wprOs9al76wNnwr2QzAe6wW0EzPAgzSO4xiSitEni4Wy2lhbDA0xD1YdtjMNQK7D1MaRsdliRDVxu/RVIGJ8y0G5wC1X7IBxzkn2xDFX7IEa904yVqhBzOPcZI89EUWT0O9kEIOOM9i3UQX2ePE9RsRZEDX/SOwfbnEWWR+in22KgfNF7gY2iuLANcoLhpTYJEuJkB6psEust28VG92342Q4q9iFkuY8o2UAQrUORdTSlPRz1voW8SCkCl1SMYRHfdZ8BF0Qg9RcPRZEhy3rY7r6HIKY5R0ufwE73AwBUYjS0Oqadc6jYC8hz2hg8a15s5CRTaKGV3IJlzIBbmHXDO9jrX4anTyHPQ6x330QrWGEltxFB+KjYB7HLIk5HH8dT7u/DVcYR5z3WM5uAZ82LiD3JAzTck0Kow1Rq2A4+GlQklDpq0jSq2iyOy88xmTwDpj4FRdLR8Zcx5p6GY0xi3H2EKfnYiFlpkveCdMXBOe+/g656mFXPQlVMzFaeQ5SQpCjZGioI4100MAeuj3zQfE7cs0G8jUntBCRJEcIPqqTT+AMKNgteRZqHQnGrKDKYWh2aYqOmzDLyjANDq8PUG7DNWdScY3ja+X0YShV1eRaaWmclsx4uN/8MfG7UseaJsKFWIEkqGu5JEnvIA5bFEcO5Yh+i8nxBdoZj3hnU7SWM2IcxX/sa5r0vY7f3Iar2EvI8QJRs46D9FeR5gsf17xLTXG+Aa+QCwAH3KTQqZzHhnaVKjjaCOe9ZJshQp6xWGxXCJRmb5eRKTro6ggnvUWjaCGrse6DIKVBQSOEKAGxjCro2xhipVTjmFKZrX6YerToKmfEQ4rQLXaNjdM1puNI4Ov4NxGlHEOhoA2jRaAcKIuAVA9tH0l6/AceYQoEcneQOVLUGQEbNWIAfbaLhnoSp1bERfUB93DzAqHUUuuKx8ibNDpt6Hcf1XwEALFS/it3gMnoFeVIfc76JOfNJHKl8i3q/eYpR5xgx6o0Z5DmxgTe6byPNQuyEl7HRf1e0LpYq3yDmf7qLfrgBy2jANqagKeSju1j/FkzGnKe2G40lmtooXGsBdesg/Hgbs5XnULEXULEWsNr+KfxwlTQMVBuyrKOTrokxpThtYaN3HprqQlFcBNEaOumaaP1ZegO7PdJSV2UbllrDhHsGujpCSlGsSjVmHIOqWJhwTsOUq5jwzgrzHW4M0/GvsfJtjKnKEzC1UdZuIDb6te5LIOU7k1ptio2V9ssAcuYjvIY8jzHtPg5DGwHXE1+qfAOKrMOUK6wkTZUtSZJxwH4SXPP8cO3XSVgHOSrWgqj2ZHkonIu4cNN653WEyS40xcWYexqypGKtN2gjZlmM8eoTaLgnMbAMzZluuQogQ5ruASigKBU45oIQ8gAyQJLhmjNwzRl41iLGK0+yWWn5rmD04/HAmzBX8yFLMhO3/TfQClaw519FlnUx6h7HqHMcrjFJqXnWh62PUb8r7aKuzItIWlMdKCwz9aw5hEkTDec4jla+A0XS0BHuLzk8dZJITUUOQx+HpY7A0iegK6T36loLTJEmh6GN4Z3wL7EcvwrXnMGS+yIJbUsyZqvPIy1C8SDyXkwYb2K58xIkScXzzv+Ap/TfYHV+UsqBJMPQx3HYfhFx2sVW5y3keYyWv0y2brIJTW3AtRaQ5iGWw5/io9afIst6yJiO6Uryc/xl70eUUTGykyyrqNhLsIwZqIoLhxFveD9xwj5Nm4esYqX19zRfV6TY61+GJCkwtTqCeBfj7ilSMZIdKIqOBfd5eNYijjnfRN1egp/u0SaquGSgrnoYc05CUx3omodecBvHnG/iaetfYEY5hRXpfWz5H0KTLUEAqenzcI0pKLJB/Z0iYqQJH9u991ExZzHDxCXWO2/iVvQGoqKLXXkLVfsgdvuXkeUxavYiKvZBGLKLTnCDLBqZMEHKhBMUmWbKFdnAnryBIN7G9eDHUBULtzuvQlEGKl62MQPXOoC2tA1NJc3x1fQ8FqsvigVuJ70GRXHhWQcoA2QkGZlZTXaCG2JzqVrzkCUN08YZuMYUNqMLbGyOMhJDq2HGOkeynVKAE8Vj6BQb4E5UrjlLWWMWwNBqeFT/Dsa9RzHtPk73FGMsG9oEJpzT4DKD/WgTSdqDqY1CVyvYbL+GjfbPsdP7AHd6b2Gl/TIkSUUvvAPLmIGujWInX0aS9fFa8EfI85jKY3mIoojxTPX/BAUagmQPDczh/7H0v+Kg/RVkSODo45gyz6BuLEKWVDzh/h48aw6a4kBXPZxz/xtqBWge9vxrcIxJtMNVHKt8FxV7gW00Buv1+ULKUIIMxxgnAZe0BVWx4ZrTcMwZLFS+CgDM9pSEaNyiRkxemYIAP95lJTwdNF5lQVMcTHrnMO2cA7mUTUCSDEE8LJBj3D2FqcoTeEp5EhV7AQt4FH60CUPxkBUpusFtxHkPUdrEmHaEKhqZj25wG215FxPOaZyVHxHrXMWcxXL8Klb8n+Bm8BrivI+KOYsg3RXBA1c1y5nmc5g0ocgGRpzDqFsH0Sk2ULcOwlAo64uSFhrWUeiaBz/axLp/Hq1gGZ46iYq9IIRnSNEqQD/dRs1aQK2YxEnlBXxV/w40xYVtzsJWR3FMfYHOZx7Q6/VpjHlncND7GhxGfjRYAOJas0Q4CzfABYoso4EjxWPY6V/EAfcpUUWxlVGs9d+EqVYR5m3sRddxrDiLhnwQuupBY0SjqnNEeA33020YWhVFHiNMKMAZdY7iEeNXMe6eQlGkqFkLGPNOYa76Amb0R4kMJ8nY8i/A0huQJDIB8QuaR5/I51HT5sS99l+P/EtERQ+OOYWGdwZbySX40TqyPGSzvqRdbhsTGLcfgR+toWCVLNuYgmvO4JT1XRzD48Q3KGKESZOZ4JiIsz7awU1IkooR5wimqk+SQQQKNvEw4JZkeYQw2qDKj0ycDc4hiNMujdqqDksKHqjI/OCbcJp10Q1vY8F9npin0RoSzqCVLXjKJJr+dTT9a5QFAyLqjNOuULDphWsIom10AxoIj9MuHGMS2/0L2EwvouWvwDMPML9KGXe6b6Hnr8DSqdHPF7Iw2YWpjWLCfATj9klY+gQW3edBzjPEjL3U+WskyR4U2cZG713s9a/ikPoUUORo9a9h1DkKWTaQZbQAvp//CD/s/WtY+gTGvdMwtCpk2cSIvYTrwY8BAJYxRf02Sca4/Qg88wCmvcdZKZFYv2PeGZAhOpluF0UOTbLxDfdfou49ws5FEw3jCJ41fxuKrAuijMJmI7f8C9RfUEdQdZaYrB4Razr+MtIshCLraIU3qHyHHJY6gqf0o0QOk/ZwVH4GUdJCP9qkuVO2WSwVp2CqVcEWXc3eQx8BLva/j4ydXyKEUB/LzyhoGdEWBRudNGar8Kw5mHIV/XQLsqSx0nmApn8dVzt/i25wWziuqJKJPE/IeUhiurNZCEOrouocQV7kGPeotHcUT0KBhkOVbyDOujAZGY3P5yqyjueM38Jh5VkhjlBzjkCVdHSzDZjaGI7XvgdHHWfVE5J9rGvzIqK2jAaR1uyDOFj5FYwqi+gGt3C59RfY6ZyHpY3gSfN7sI0ZhMk2xrQjOCUfxnHzV5CjwAd4HX66R3PYqoff9H4HT5rfQ91ewret38Db4Z+hG9GYy2Lt62j51EOvWLPY7L8vRsG4zm3FnMWofRSqUsWp2n+L6cqX8IT9L6DIJqYrNPYRRhtQmea0pjh43PptTFeegqVPYMw7BRQ5rhSvYye9hqoxh0gK8P+88xKu9V6m2coixm66jKLIseA8hzmtimfVb5P2eXgb74d/LXrpcdqCIqkI4k1YBV3XNKeNN8tItjHNyEVMUxzEWQ91i3S0CzZaFMS7WGm/jETIQOaYt5/BrewdmndnGSoAcOGeJyv/Cseq34XFVKRG82nEaRcac1s64D5FLSnIyIoEO/2L+I+df4MoaeO8/6cAAF1xMaeeJfGZcBUHK7+CteBtGn3RRmDqdfSKLfjZDq5nm3B0qv7EWR/9cA1ZHiOINxElLbSCZUzoJ9HsXUI7X8Pj5m+yEUYyQxixD8PWG2j617Hbv4IgbSEtQuz0PxKzqqvtn0KRDXjWHPKcMq7N/vuYUU4hLShANfVRTDinkWYB2sEtXCN4X4gAAFcqSURBVOz/DdbkZbwS/7XQnDYkF1NKFSP2ESpLJ12kRYhReQFh0UE3vIM73TdYj5mUAE1tlJVtZRhqFd3gFl71/x1kWcVuch22MQUJMpohacC3ghvox1uwtBGsybcBDEhveRFjQXsSrj6BWe9LCOM9eOqk8OhNsg6irItt+Tb8lPVrJQ0tfwVB3oRZOJixzuER9zdxwH4Ch+UvUftLraCKCdjaGI6YI9iLrkORdeiygz9p/yG66QZsrYGsSNDxl2FqYzhc+VUhnDLpnQMA3Om+Bc9axEz1yyDjHGKAX4xfwhvhn8O1DjCmeIg7vbcQJk26t1QaddrtfShUB019gnESZBYokEOeqlIAWTBtalUm8lmU7CEvUoRxE5Y+xUb4vsBNWFNpTGA9eo/cNyQNiuJixDkCXa2hm21Q4z2PGc3cxJz3LKZqz9BcJoh1yq39qvZBjDjHYGl1tP1lmFodTf8axtwTUCQVx6yvA4yxpqo1WFodvXANO9334EfrLDPXcbv3OlI2MrKZXIKuODhifJV6DZCJNFOQObqqmHin84dIsxY0xUUnXKXFTR9HnLax2/uQNflVVCQyrMjzEDWJ2JdzzjMYs07QvHLaxJ3uG0iyPm53XhWKMZ3gFra778HQanDNabGR7YZXcUH6EHPKYzC1UXjWAURFDxeldxElO+gGxFo0tCrr45FmsibbCKIdxOkeG/vJWdS5DdeYFMzPne576ISr+OPmv4GqWFhu/g3e8v+ELUhE4Sfhcg2vBX+ETngbx4yvMZUfDe/5f06RZXgHmkqesVHSxgHjMczIp9CLNrATkZ0h10AukGFJ/RIO5EswlCritItJ51FM2Wdx1Pkms7qkDTBMdhlZo4aGdRTj7iNE9kuJMGeqNUxIh1CTZlAgx3vpD3DbfxPtfA2T7lnmuxvDZIHK49Zv45L8IbpyE+u9dxAle2j1r6AV3CC/ZZnO+5b/IbKMSq155mOt9yamnXPgs9I16yBU2cZq/zWs9H6MmcrTMPVxQCJ3mSvSO5ixzmGh+iIUqHg9ewN2YaNWeNjuvY92/xritI0oaeNv/L9BTTFRk6ehKxKOWC9iwXoGjWIGYdHGpHcOmmwhyQOYeh1fNb4Hx5zEN93/EZKkIs57aAbLqNkHsYub2Auu4b34+xhxDsPPdrFkfIV6zEyydMw4hle7/xoyFByxXkQv2sDR+n+FgOlEZ0WCDCn68RZGnSNkUqHU4CrjSBHipv8qLqcbeH7SRE2dRd0+hKq5AFXSYWp1LFW/jQPKo/CsedzI3qaSMpPkBABTG8N05SlU7EPQNQ+mWkNFmoSq2CK7s/UxcLUk15zBdOUp3A7fhqFU0dCWWHlyA3HWRcM5BtecQQU2IviYw2m041u4llHf01TqUGQDUdFDN1jBGeVraIc0O6+p1FpI0g5ccwZjWERb2hYzxiP5hHCi4vKMSR6gG95BR9pGkgdoBStIsj5GnGNQZQuaUmGeuAZu9V+lESTJxLL0oVD2ahhHkBcJOsEqbGMcqmKhF97BjHSSSaOS5V7DPYlZ9Sx64R0YWpXmazUPu7iJINpBP96CIuvYi66zLM9HwzmOp5RHxayrJMnopGtYy5o4gScQZ12qZkUbyJFho/8uOR4xzewCOcJkD6Zex6hzHJriwjNm4BhTSNIWU6WLEDHlvbxI4KhjqFkL0FUPnWAVV9p/gwA0bhgkezC0EbSkTeRFjla6iiTr4VbrFZpAYNe8F97BTnQFiqRi0juHMWUJimxgu/sBPuj9BfyiiQ97f4Hlzku4EP8As+pZHHS+AgAYkWfxl90/gSxr8IwZ6LILSxtB219GO7gJS6nTlEwe4Hr3FXjWPBrOMfjpLpOgJKGMzd57wsWMk90AELFVtliAQuz0KG2TiApk1Jxj6ASrOGy9ANeYRJzu0f1rH0JRxOiGt2Hpo0zRK0OPyeJqioOaQ+OoJC9qCjLep+GBiVma2oBtTKAbrIBL3wE55qovYDug0aMoaQoLKl2tIc19jDrHsdu/KKTwuFuQLOkia5UlDUFMJ8yz5inL0jz0glVB7FIVG2G8CXK3oOY4F9RWWdkiiLeR5wE8+yC6/lU45iI8YwZBuiskNcnlpgfLOMBcLhJwVxQCMe3mvS+jl29hs/0aNHUUadqCqtZwxv0e3un8IbEz1Qoazglsdt6CZ81j0jiFq62/giTpjKGpCU9jAOj6yyzjS+HpU+hEazhgnsNadB55nsIPV0W/IctjJMkezQzLDkxtlMk+hjhW/Q1E8LGXrKAfbZDcWhFTP5P5bvLsImR6v541B1sdQV7kSHMfe/1L8Kx5pFlIgVBwC9zaizKhbVj6GGytgRFlHrfDt1ExZtCLNzGvP4mutEvZuqILBR5LH8Vp7Zu4nL+KZ9Vv4D28j2a8AlnS0NCWkCAUbkU7vQvCNN7RxtAKbtKokkmCLp4xQ5lJ2kWWR7D0BnTZRTu8QWIu9hGSrcwDsSAWoHGLNAsEUY4MHubA/Zm5nWKaBXjc+m282v3/invcMacwZhyjwC7rwTammFhKCNsYQ02fRzu5DVlS8XXj2/hJ+lNsdt+FbZAgy1H5WZwP/hxpHmLUOQpVMlGVJrGeXMAZ5Wv4af9/h6bYiJKWkK5c8J7Hzd5PkaQtzFS/jBwJ2uEqquYsdvqXoKseloyv4HLwAzHuYWojaPWvwLPmUdPnsdqmKs145Sz8ZIdKeNXvYStI8bPsh9AkGzkSmFIVe8kKRrRFWKjgZvgaTurfQE/uoFmsQoKCxeIU7sgraKWr0GUXI/Is1uJ30QvXYOlj0BSHbOEA0d8N4h08Yn8HO9IagryJdnATz1i/i9fCP6Pra07itPwC3km+D0+fRpL7cJVxrPXeRNWax79qfBP/2x4dpwEXKjRc7f49Trm/idX8PbT8FfIrz3pY1L6EHdxEK7qBEeMQNvvvAwAW3efRyCfxfvJ36DPR/QnvUXTjdSHdmjLBE1lSUXcOox3cRMU8AFOp42DxCF7t/1sya2FOXgWoTaGrFRRFjijZYXKhPaFMJ0s60rSFierT2Oq+A00hhu/z2jfxg+CPSKgnvMM+m4uZpKg6R5BmAQ6Y5yBDwXL/R+K5z4sYeR5iovIk0txHL9pA1ZqHBAXdiCRc0yzAvPscOvkGy3IVtPwVsUFQZa2KLI9RMWbgSuPYS0kfoGLOkhlD1kUvWKUStT4KVbbQ6l+Corh41P0tXEt/jihpwWIz5FwTPs0DnLV/Cw5MXMBrMCQPe9F1qIqFSe0EQhALuoE5XE9+hrq+CBtV3I7ewZhxDFvRR8jzFI4+jlawIjbvNAugyAba/jJkWYetj+G49jVciH9AJXIW7HK54TQL4Bkz2OtfRsVeECTVIN5Ewz2Fpn+dBe6j0FUPdW0eKgxsxhdQ1agalTIRGz4vPm6ewK3uz2DpowiibZj6KIJ4m/kSOOiFayjykIiPjGznmDMwFA8pE3yJ0y6SrI806yFjXtqfhAfehCvOcbpIvY+Eawd3HyGWYQ/k50s37Jh7Arv9K8IKLC/I3s0PV+Hai6jqc9jovo2KvYBm7yPYxozYiDWlAsecpN5bvIu8iJkwgIIk62PUOYamf42UU4qEZsOyPqrGHLIigSOP4nrzr9jIQxVR0sa4ewq7/mX2MG1DU+ti04niLTQqZ7HdeQeybMAxZxAwUwAAqNiH0O5fgSyTB2gQUYnpSOVbuNT+ayL15CmitI2KNSce+n54C2CqKY65CEcfh6uM40b7ZXB3JiK82ahZiyKjV2UDzf5VJlMIePYSqvoc7nRe37eAJNxpSHFJLEPShV1g1ZoTWq/cPm/BfgaXO/8JdXsJe/1LwjaSS8AdqX4bjXwSP+/9/yBLOkydFMzqOqlNjRYHsIUV7AaXqfcVraFmLGCr/wGetP9r7MnbWIvfRcdfgaZW8Ijz62hJ1AOjjMJmBK8GTKWCZrCMqrmATrjKWKvbQoauas2jE67C1EagSCp0xYUEBZ40hlZ+B6pkYK39M1j6BDF38xi6WoUf3YJjLqBhHcVedB39cB2Tlcfgp3tI0j401UGeJ5AkGYe0Z/FB7y/AXWs01WWMeCpHkTiFilHzMNZ775D4vl5Hu38JDe8sUhb4ONoYdvqXYGhVAMAJ7VfwVu//EKo+pjYGXfOgSjpcdRLVYgwX+99HnOxipvY8TKmCtf6biJId5uyzi3Pe7+E9/88RJ7vQ1Dqmvcex2v6xYLpyK7cZ72k0MIfV/D0URYYwbeOY8TX4Ug9aoeNWeh5Pqd/EP/T/LTxzGs+q38D54h1kSBBlbdhKA5v995FkPWiKi0X3edz0X8WodRRPyk9iNdvDpeQV5DnNODfMo+ilG4izPg4Yj2E3v4Gtznm41iz6IZELXWsBX9J/E29lf49W/wq1CdgcvKnU0U3uIE67mLBPo5du4Pfqv4a/7L6FuKBKwJh1Ar1si0R/gvdh6w3mZasjTjswtBq4zvmXlG/gh+Efi9aWoVUxZZzBnfA8GThIMlTZxNfs38cr/h/ghP1trObvYadzHqpawzH3W5AhYyV+DQAYz4PmPDvBKpV1kSGI1qAqVVjGGHrBKnvuSJNZVSxB/nGNSVTVWWxHlyDLGrOiJEIm33x7wW1wGzwyik8QROuMqU6gueYaVNmCH92CqlRRsw8KkR0/Wocsm6hYc+iHG+BOXCedX8O7nX8viJukYkW62LYxgSyjMvvjlf8BK/mb6IS3kTLTkVH7KDa754V+vyxpGLOPY733DtKsh0PVX4VXjND5637AxoJofK5mL2K7+wEMrYYk7WHCO4u94CoAIE47+Hbl/4wbxR1c7P0nVKw5BPEOBfvRNvIixlTlKTytPI3v9/4dFu3nsJ1dQ9O/DkmSMe0+jtudVxnBsCYSDB4YhvEuzrq/iz15A7vJdREkVu2D6Pg3MO6dRlYk2OtfhcWkTI8538Q2VtAKbiKIN9lUBe0/o+5JUbFSJAM7vQ9Rdw7Tpp6HmK0+j1vNl4SSFrcuBYAD9hPYiD5gAi0O9rrvfHGbsKY2kBcxGu4pdKM1hPEOG9dQ2YI1JRhnFf0AwqyJrEjR6n1ETEe1ikXvBVxr/Q1qzhG0/Wso8hhV9xh64R3Y+pjwc2x4Z9BQlyBDwXpygfWYYsGirunz2IuuC5FvSx9DyEwJjrvfweX+3yHNejC1MfjRbZj6BDPwNjDmnUE7uAnPnMaCcg4Xw5egqY7whqV5SBpj6fjXSIGI9RDmal/Do3gUP/D/gGbt1AqyPMbjzu/i9e7/xjZb2qQ11UUYb7GbfwpJ2odlNBBEO+CWdACgSjrq6gKCoo07nZ/je/X/G/4h/j4AoO0vI2MygVzlhett86qDolaQZeTjnKYtuPYiCyBCoR1sGxOoGnPw0120+pegqTXEyS5k2UDVXiLyGoAz9vdwNfuZcFOim74qzq2ueNA1D+3+FTErS+XJFJrqiIXBMSbgR9siECtAc487vQtCQ5fKYHuw9AlM2qexE12BzucJiwhJ1oeheKSqJrtiA+JjQo3KWbSDm6hxZn20hijZg6q4OOi+gGa+ysaxNsFL+Iv1b2G5+TckE6i4GLWPIsraogpgGxPoBTeYHy71e75q/jZ+nv49gqQJz5hBP9kUQg1pFmDUPgoA2Oy9R9wCfRyypCFKmuCOYrrmwVJHyG2MzT3yeUVapLpQZAPT5lmRBdrGGA5pz6Ir7eF6+29pvChtwTZnKRtm0qBx2oWmOLA1Wsy57VzVnCUHrvAOfn/0v8ef9/4WllzHbnhV6H/bWgO7vYvg2r2uOc0IR6lgFh9RnsWF+AewtQZpH+c91NRZbPjvg/sq98I7GHWOYq9/VWSvjjKGjf67yPKYGOhZQGp5eQ+WUsdG713qcxY5PGsOUdLGlP0oqsUYrkT/gHHzBE7hJN4qXkdahNjtXRRlVtJgbgOSDFOrC2Z/P97CqEnesWPOScaX6JNEoz6KfrjKxrN60FXy19VUGw39CLaij8SI2Jz7DK63/xbcGjLP48G4GVNOU5hK2lT1aXTjdSZxqYtnEkwm09BGaI6fCZEoioss7TCzCl/otedFijHnJO60fiLmrQ2tIcbzavYitjqklVCxD6EfbaJizZHNqLGATnwbaRaibh3ERvdtMTs77T6Om61XoDDLyzTzScmKBQF5HqLhnYEuu9jsnseIcxTbnbehKC4mvXOYKpZwMX4J/XAVc7WvAQA6yR30ow0kyR5q7gn40ZawM1QVCypTVbOUOrb7F1AxD2C395EQrzngPY0t/wK+bP4Obsq3SLOBzeDO1b5GxE+mHkaZr0XGML1LwqCibi8JzQnefiEC2ioTqKEEyzbGMaWexGZ6EWkRI4ypb8ud9uh8HgQAVLUD2Iuuw9OnsNu/Qsll5sMxJhDGTeiaB0PxcFj+Etakq6QEV5AnObk3jRO5rf0TyIx0+YVmwiPeY2j1rzCHGWYbNjQ3VXEOo+OvUORS+RJkKJgqDuGd/h8jzTrQVbIFHDEOoUCObf8i4qyLSfcsZCjYDj4Sjhtz1edxu/sauEVfmLapDBbeJsY1cmbVF7PRj1OYkI/gcv/vSDQk7WDEOQJbaaAZr1BPMOuC27hBUuFZ88LcW1MqSHMfhlqHptpk7t6/zIQWVGZqT0QpbhrgmdNURk/32EJP0mj9cI1EG1j5mEfKsqyK0hY3VDioPo1b2Tvw410E8brYaPnCsNr7uZijkyCLUj93y+HBTZYNlJQq9iK6jOlXFClcJsAQJU1AkoU7UpTsQFdHqOzvr+wT8FdlexCQmNNiflORDURpE9z709RILzaMm6KsM+49hjT30QlvC8WiNOvA1McF67ntXxP+sZzlaqo16LKLtAix179KZCb3edwO38aj+newJ29jPbkASZLR6l+BbUwJg/eac0RUTXgfRlMcuMakKElJkHHW/V2c7/8xsqyHqerT2GIcAEOrMlWsEH60zpxzOoyMQQsiVQ+uCHIKQJ6mNWsRe/3LQgQ/y31ROSFXIe5zHYtFte3TTDY32QCAEfswuc8UKSbds9gLrrFSOxmI62oVjjGOrEjgR1s0M8mEGlS1hhPud3AleBlhvAXXmkdFP4BesoFD2rNoSZtwiho0GLhTXMKvO1/FO/4GrsQ/Rs4UqSRJRtWaxxPyV7GGTVzq/x2q1jwWpcdwA++iHdxEwz4ujktTHDZjHyLN2nix+n/HdfkSVjs/RZb1UXdPou1fw7Hqb+BS+69Bzk8uHGMS8+rjaEp30IpvIs1CHDa/ii1cQ5C2MK8+jhvpG8jyCKPGYfQzqjp5yiTG8gNYl65jvfcOuHm9rngw9TpUyWCz9tskus/uZ131EKVtzHnPop/vwJA8NOMVBPGumNMGwNx6zoPmmpcoaDCP0uy9WmFthD2xBkTJnpjl5vKHSdpkEw0mm+WnylScdpGkLYx5Z7HnX4WueJiyH8VG8D78cBVggbofrsLQx6GrHmuv7QizDe4PPDxHnOWxcKTj1ay56vMI8w76ySY0xUHHv0EcGLUB15xGm5nijLonRWZXc46grs7jdu91lmWTjgDXZp60TmPdfxdpHogstB+uiSCfG5HIssskV3uQ2OgOEUmvAJChMtGcun0Ip/EMtqUm9nAb28FHSLMQE+4ZNMNl2HoDcdaDH21DkmSM2EfQCpZFAMF9gnn1zFDrxLCP1onrwUichlaFJClI0j6itI0D3tMw4WIj+YgRqUilbMw7hYQ5WvXCO3jU+S1cSX9MlZ0iRsU+iKLIMK4fh114uJWeR5oH6AU3URQZPPsgDulfxrXoR0jSPrg1Lqnc7bcVvR8emJj1mEIzdUG8jYZ7CmOVx6Ey5phpTKIfrkORTbjmLPaCa+ikd3A9f10YIWiqA11xsBNehgINfnSLRniQIMzbiJKWIExt+u8jZ5HMXv8KCSswVZWOfw1BtM38T4mUtNV5C7eStxAn2+ymzdGPt7Da/qGIdgFAlW1UnMNQFBtd/zoUtcLmLjeJah6todO/iq3OeSGIkec9mre15kk9h9kv9qINdMJVYonmMWPtMr9LSUWUNkn5qogF+1mCDJeVPdr9a/jI/xv04y1aiJkUZJx10e5fwUr7ZXzZ/n045gxmvKdJ9UmxB5uMNgJdG2WBAo2N1d1j6PjXIcsmJr1zzGt3U3iJypIKV5+ApjrQ1Bqesn8XplqDbc7C0BpI0xbpDbMNeMw5iaZ/DX60SZEjMlKaUehh01UP/WgTmuqwvr0LWZKFLWOeh6hac2zxIHIc9X3JY7juHIYfbSJK2tjpnEcrvIEg2UPNXkSWh9hKr8DWGvhZ+/8FpVChyRb1mtxTUBVLCKzvdT8QcnEAiaDQd07YTCsJmHwQ/DXrP8noRGtQZROjzjHSm019tsDkGHEOi75+1T6IPPPR8pfRYHKERR4jZzJ+rWAFhlbHbu8jcJ/sXrgGQxuj/v6QuIBt0GxsnofIsi5TkGqjYKNnqmxBlU2sd99EmOxi3n0ONWcJ096TUBUT7eAmWv0rqJizOFn5HmruCRKxQY6b6dtE3Cty9IKb6MZ3YKo11IsKdFhYzy4gR45WsIxL/Q7u4DKOa1+jcSX7EJV6sx6SIoNemJhzn8GYsoSLCemaH7ZfhCuxwFLWMWoeFveJJBn4oPgZNJjMEUhB21/GM97/hCud72Oh+lVoCmUlQbyDWWkMu+FVeNo0auYCrgQvY6v3IQylglvZO+iFd9AP11ErJnFOfgFfN76Bdf88NuQVhHkbU+5jrL01iihtIoybGFHmSfhfNmHo46i7J2AbFHBmaQcb/vvIixTrvXdgqjWosglJ0oQ38U7vAooiY2ViqjYFeZPJGOaIkhYLaqeZqEZEegJZD3G6R/rFkMDV0HilSFUs5hpmipE/SZKx7r8Li4mPkKa2DE0bIc/aLEQvvIPHrd/GUu3XwN2uZIl0r4NoDV3/OpKsjzFlifgjaQtFHmI7uIg095FlNH+syCY8+zAzL5HFRh5nPTjGBDSlgiDewc3OjxAlG0zdiypOSbKHMNnF7d7rTF+AZCh5UJBlfeR5n7UmTVTtg9A1T4w8ZXmMhnEEkmSQOpqkwjbGsde/ip8Ef4gPe3+BDAlMZmG50TuPLCeBoCT1Qa5kOTY7bwhy7WH36zha+3VqETDmeZQ24Udr4E5rfJQ2TruY1E7QVE0eo59t43r3FcRJFxPmI1S5lXXs9i6i1b9GrRN7ER8Efw2ftRw1pULl/iKHDgur2XvIiwR+tElJkzaKfriG9zv/niYEmO1nnHWFROYXtglflT6EzmYxt7vUE8jzEIriIIw22FwsEWnOmt+FqdTQDm6xXt0IJsxH0FCX4EfruNn5EcDE0/f8a5iWT+Kc93tQ1RHhfpIzMs5Xvf8Fkmxiu/OWyErGvdPw7EMwtVEosg1ZNtAP10H+qPQgkQuPjVbvItr9i0iZzVeHRX8FSCiDxO4LpGkTutaAoY+jKCKY2hiTzzSZyEIM1zrAGu8dRAlFqeP2SZyu/i4OuE/BZOxvz5ojL1a1wgTeZXSDVZj6KMaUJZyr/nd4svI/Is18uMYUdMVjpg06MZkhoShi/NT/d8gyyrq4AbmljwGQkCRk8s578wDQ7F2CItuYdM9ivfMm/GgLpj5KQQAjuHXjdRoXki1cxhvoMq/eNA8xVjmHin2ESmS5j73gGsjSrMZ6TgqCeBumVseIvYQCOUbsw8yzmbLnlLGqSd6vhozrJBcxRo3DKAoS7wiiHSGCr8g6FLWCfngL3WAFPZbhyqCSliTruND5U8R5X4wajWiLkCChai+x8nKFPfw6U4YidbCAvZcqm6ha87QwKbYosW/33qesEhkTTUgQZ33UnCXkyKkcptYwX/kKutEaRpyjcCwy/CBpTQ/98Bb1B2WblaC6rAQbsvIZCaPsdd9DmrVougAK5utfR909iRHnKLhpeRjfYYu3jUPFIXSD27jVehljxjFUeSCY9/Fh+z+w6zuOPA/RC24jy7pw7UU8Uv1dNIwjCNMWXFnH9e4ryIoUV4KXSTgHKhypgYvJK9iKL2JMWcIR60VosoU3s7+DAQM7yTXECGBpI3D0cRgwcUw6SGV6fZx5Z1MmXnPos6KiB0lSMF45ByDHheyHqNgL2I4uYcw5iTxPoKseXsteIR3jcBlR1oZnTuO4+x048iha/Wv4nyb+L6g5S9jCNfw8+Y94OX4FU/ZZ3Gq9QtoE0XUsVF+EqZLTVpx1cdN/FbbWICMESRasaN6nj7MuWv4K0rSF7c47yPIYo+4jSJgnM+mR04idLKno+DfQCVfZdaUSqKK4aPVIoF9VPACUbaPIyVwEBdtQKeBWFBvt3iW41izOeP8Cp5UXYWp11MwFxCmxs0lJTUM/XBVmEAGbc30n/EtsJzSRkLOAh0OSdcTJLi53vz9g4kqUGToqTXuE8SZi1gJxjAk0ux+iKGLo2hg6/go6/gpkWUXVXMBS5RtwrUN4t/enyPNAfN+MVWridA9hvIswpsqfodUgSQoAUgHT1RrzKSZP7CTtIE672EtWyD3JnESWh+wZo+ty0PsamsEyDqhnAORMlQoYcY6KCpEkyfCsRSTJHix9DMv+j3Cp+aeQJY2Uydg/htbAmHeWgoeMqnZJ2sOd6D3GSK9hr38ZSdpEEG/iRucfaHKlyJFm5GNu6ROw5LpQUMxyH3HaQpq20AtX8VHrjxElbXT861BkE45JZC5Z0iFLOikBKqRzkOfhwInsU/DA5Wiy/dJZxpbCNuaZw00qNgFZopM9qh1CP9/Fnn9F+HNCkjHnPYu9ZAVx0qURG2bYTgLePZb9jiBOW3Tjat9CV2rjTv4Rdjrn2Q1LLhjc9JyzqZOsgxHnGDNEsFBzltAPNwRLlrMTyf5NQYEUsmwLUZCiiCHLNsiEvYXp6rNY77wOWdLhWXNo+8swtBom7NNQoOFG5x+QZX0cqL2AdnxL+GoCQJxswdSnkbKei8zdOiQVi5Wv4Vrzr6BpI9TPQg5NcdDqU5nIs2bR6ROhoUAKSSLNXj/eRp6HdMNrJDjCZQOr9hI6wQ1kWReybEFl7jjEDBxDmGxjxDmGMG2jFyzDNuYQJtvQ1RojKpHVG3dvco1JbHXOQ2XZ7oT1CDaDD0VJnXt86moVSdZn115FmvtssbDhWXNw1DFs9y8gy0NGwLuEuntMMJ511cOM/ii2s2vohmusikHRKX99O7rFZpI99MMVyLI9JE0JphGbM7UwFWG8u0/YP4jpeOdqL6Cd3EacdJEXCSrmLPWqlXksd15iymM2EuZZa2gjCFmvnLcs4mRHyFCqao0CIMhIsp7o7XGlNW65KVCkQuqOW+5JkkGmDqx/pKkVxMku+70MbiQuSSpzCHIwah7GaHEAV6J/QJKSmH7Hvw6H9YoBCqgMtYow2YXN+1mqJzYk3pOmRV/Bgvokxoo6OvBxJfsZVNnATuc8TGMSrjGFrEjQC+9AllQsOM9hJ72GbngHcboH15qHo01gp/8RTK0OV5+CJ49jufMSVNnGpPso1nvvwNCqmDOexLL/IzYNsU1ZKK+UsbLnZvghzujfwuu9P8CByjNoJ7fBJWor6jQFtMwelcvXxmkXrj5FI3M4h9d7fwCTbcac+FPkZKJhaqMI4nWoSgW2MYZ2nzY5U5+AqY+g4y+DWxzKkip8fz1rDkWRIYh3mWhDCEWxocpUmuZQZFO0jbjcaJi2WetExpHqt7EWnRctIL4eyYrNOA8+00XfGhAuZVP4qZNbV8SCAAK3VeR/qyku0pzsL8kTeA9T1Sex3n5NmNLT6GDMpCwvwzYm2BoTsw1plNpMWQfT1Wex1fuALD1lCzzjLFh2mmc+UywkM4Oa+whavYv7iGYy0yynud0OO0YfWdaBBHVflU9l2gzbvY9Y6b+Fqn0QtjqKO+2fQZFt1J3D2O1dEIRdTbVZOXmNScNSKXvMPY2t7jvghh/8HFftJfjRFjxzGnv9K0x61aA2ZXCTVdlyaOqoqHA1nBPYaP8ckqShKCJIUKCqNZh6HY42gd3+JSiyzsbu1pFmbXBL0U/cWx98EzbADckLZFDVutBtlphsGDc9HvVOQ1dcNINlUiCyzmLNf5vYZ0UKRa3AUKuYsB5BK11l1nddHHa/jo9afyq+oMEsq2xjHGFMWV/I7M44+WHUPY4o66Lj36CTplRgGQ3MqmfxYesPMVY5RxJrRYK97ruQJJJRI2s0F1kRE2moc36gFap4VP6VVfSCG6g6R0S/u2ovQZMttIObiNMWdLXGRno2YWpjGLOPY8v/EHXrIDa771JGzHxS0zyErnjwo9vwGBmgYGpNRR5C00Zw2P06Lrb/HBX7INq9S0LoPi9izFaew054GY4+jt3+ZdKmZvqy9F7DBvFgqkMVwVDPsh50rYEZ9wn4eRObnTegqyOYdB8V7lh7/lWxuHEheVnSsNV9F7KkMr9OA2FMCw93b+IjUpKkwTamxOiXpY+i46+g6iyh3b8GU6dFYViMvWItwI+2hKLSUu3XsNL9IfI8RMU+iDHtCFb7r8E1JlFXF7AZXYAfb2PSPYsd/yIsvYEoaTNNZuafm/WFrmue+dC0EVSteaEFbRtjLAs3KGvKQ/ANkqQ0DdEzIm1wHXGyJdRzyO2FCCCuOSPcriRZR8M9ha3OWwBocddUB11/GapaFSNKA8vAjBHBQmjMJCDNWgAUoVlu6aNM6i8SzyBftBRJZ/14CiR5X79iLSCIdzDnPIO14G0kWR+POL+Oj/y/QZx2MFV5AobkYi9ZgR9tYd59Ds30BoknwMJPwj9GwzpK/VfkyNIOXHsRttZAXZ7FTnoNU8pJVIoqLmQ/FM8nQNaMimzCNsbwP4/9Dv71zp8hiGh0qmEdxQmcwY+DPxJKVFP6KcQI0Eyo7TSqLOJa5wcicG+lq5hVziCVUqynF9APN0jWUCKvXJ5BATJGvFPohXdA/sE+dLWGijmL7c7bkBVb9Cy58xPfZCmbIbISJ1fRPDRVdLgVYp4HVKlCITJBbkhhGVOCtc6NMRxjEt3glgjCHXOKLdDdfRtazV5EJxj4jEcJK4eqdcYLkZmpR4gs91nrR0WU7LC23EC3mDJDEjpp2MfFVAUFB7JYP4sihSqTdWA/vAFZphYP72sXBTl8jXqn0Q5uwdTriJOuODbiPND7SbIOz5pHx78uEhpaF7gUZAhVqQlmf8WmZz5OtiHLjqjo8fba8PrgWXOIk67YPyRZR577MPVpRPEW5uq/glZ8E/1okzymmYZ6lnYEcRUApqpPoh2ukvY4L+/L+uB5LFKMeqfRizaQ5iHStA3u/qVrFPR0mZojkVKpQlgUOarWHMK0LcbDEubbnRfhp++tD7oJy/Kgvj1bfR674VWRZWhqhfU9dFZ+rqFqzTMrQJpZfcL4DVyV3sNa68eQIMEyZojlZh7EWvsnIBF76k35jN3Lb9BZ70vY8N8Xm+KB2gvMvm8/8yzPA6hqVWzwm8GH5JmZbKPhnUU/3mLsVG5eThHydO3LuNP+uVhEeNRWFDl6wQ3Rz+Ab9nbnHUzXnsV6+w1WciX2pCbYkykjZ9BDzKNTSZIxah3FZu89QVaqmLNo+tfZTHAxuLEBcCcZMkBvMUPpUAiTb3bPI83azASAyr6mNgo/Woeu1hi5Y53dcDpzFnKFBGmUtiGBTBn68ZawW7P0CcqwgltC4BySTH3jPETOnHaKIiNanlqhjJBFyvwB4AxQHvUWBTmhAEDFXhAEpUnvHDa75zHpnUNVmsS13svUH0924dkHMWIcwrZ/EWGyTWVn9js+MubpU9jsvgsamSMLtG6wwoICRZD3LKWOzf77OOR8FVph4Fr0I8Hop2pKj4h7oOyXqiJEAuHjC7QojyAryCEqz0NYOvX5JUnFsep30SrWsN5+QyycSeYjTZtitp2s9uh+NfUJUaLXVBttZtJApEeFlUgHRDEudsMDmWnvSepdAtjuvImqcxySpCBOuvDMaWx1zsPUG4ypr1O2n+yh6h6DKukIkiY5EOEo9qQNtNJVhHETh60XIEFBKPVI+lM28Lj0Zfwo+lPBnCZ1oD1x3qruMUxqJ9DMV9HyV6gF4RzFbu8izURXv4pOuiay6Onqs0iLEE3/OhxjElXtADSY8Ism7rR+QtwD1cWIdRgTOISe1MKd8Dz64Sp0dURkyOR2ppH6mKzS5AarJjS8U2iyytKIcxRpQe2SfnhLPGu2MUPTBrkvnjkewPGNoSgivhKyzZckVgeGFVS54GsK3UOmmAbg5VVF0sXCzS36kqwDXgECwBbxDriM4k73HYC5YxUFEdw0hWRqu/5VtgknkCSDqmDMcCVJd8ENQgCAG+twkhTdvzEmKo9jq/uuILpyFExLnZKQ6wBkeNY8euEq8tyHqtTEGOVAopGcwCggpfJ5wdp/kkTuXhlftyUV3ETkVOV3cKn/d2KdoI0uAZBBggpNGyGSJ2NhB9EaLGOGXWsipPbCNbHp89533T2JbnCLtRk0VMxZtENyjztgnmPl6jUWnHXE85qlHRRDspPcc5xXzDhU2aJJDuYmFyV77HnmBjUtfBo+0ybMbxJSTCJHH/LG7ImsUlc8Mbtb0abRSe6gG9xCw30EO/2PoEg6omSbicerQhx8u/MOJElBUWQi+qs5RyjyYCUPvjlxz9gwbiJKtiFJCkx9HEG0Dl0bZbZUCd08/atU1oWKRuUsdnsXMOIcw17/khhbWWnSSBAvqZCRfReq4iHN2jhS/y3cCUnGUJMtbHTeEqSgir2EA8ZjuNj8Y1GC4qM7QbQOQxujoX5ZF+40PBLNMl9ErESuaOJw/Tdwvf234v25Jyv3luVM81HnCNbbb4hyx1jlMTHnXDDD8yKPoWkj7HxEcMwF9MNbZHtXpORExJjGUdKGY1LUXrEW0I+IjMBHlHjGlWV9OOYcYxeyuW51FCn7joZah6FVmWdsKh4+jdmiJWmHZD/ZCEfNOUIG9kUuhuy3Om9AUTwcrvwqrndfwW/V/1f8VecPSL5SIyZklsViU47ZvLRrzSKMm/CsA2j1r+FY9bu42PxjVN1jiJOuYOP72S7Lfmm22NZHYShVIoYxBybuLDRuP4LbnVdRsRcQRDsYc05irfUjgGXHlB31abFjfqRUYqSM1TJmQPaKdN1lxR4aW6AFS5YtmNoYZFll7HpZ9BUr9gL2uu9BUTy45gzjPpAtX6fYQo5EzONnWQd19zTa/jKOVL+NrfQKeuEdoW9sanWYahU5cnSCW8jzkHqrcNEpthBmTajMmnGr8zZsYwZPG9/DG8lf07HoB9CKbkBTHCGsP6WfQoIIq72fI0lb+JXK/xVv5y8L5yAUKTNuIJnX7eAjxKxFddb+LdzEB8iKCDVlFrd6r9I8tWwJwQM+508LG9ne8bEjRTaZhSWVjy19FCPGIdzpvkXtAMag5hsUuQBNQJF1tmBzlntF6G7Tz8gulXzNA0iSJrJdfl357/jGyDMrepYH/VvyTM6hsHE7arsFgjnPZ20BIIzviHuC1lmF3S99sQ7w54m+k8L4D21QcKCJahjPiIsiESOavNJD7biCrbcJy8ipmqWrIyzTzVkASJUVTi4cbusN7Q7geggDlyHy5OW/45mxodUYt4QTKWUWGORQleq+5Iu+F03gWMaMSLqo7eYIRzJ+bLzakBcpHHMKPX9FVG25MYnwGGcBCGXtJiRGj+LXa7r2Zez2r4i9LU52xLWge8Zj1Z5xGEoFfkLl7yT12XfTkee9oaDg4/EZNmEbo+4j2O19iKJIYGgTTLeTBq3XWj8UJ4b37mTZhGceoAXeGEcnWKVyT+6LkoWhjSCI1iFBgqGPwzNn4MdkXWWpI2gFK4iT7X030Gzta4iKLjbbb0BVq3CMCciShmbvghDh4Jlhnoei70Jzfh12gVtQlAoMlRubs9I6M27nJXZJNjFXfR5B3sRe/yo86wBbYPZQFBlq7nFESQt5nqJmL2Kz/RpUpSrUxVDkcO1F0Ufl4hxJ2hFz1horfaVZC559mMRAJHlfBE43qA9VqWDCPYP17puMNEEZU8VeQi8khiDfwOlhLtjDQJd5oHYGYcfXizaEJKbKlJy46xRtTJti7IIi1EgsKpRJahi3T+Jm66V988w0vtIlA/isD3IMIsWwMGlCU2yYTJJuOFofjsa5td/AWkwcPVtcNqEoDjxrDlXtgJgn5n1hValg2nscSeFjo/MOiiJmc9LbUJUqIMmY976MoKBsshOtwVSr2OtfgqmNwdCq6Ia3MeM9iVutH1KWL0gjhiiPcas3zhrlGzll4oNyIbdB459NxJK+uL58w+Dv65gzohQtywZbwBVhp0gViF149hIcbQJR1kEvvANukGJoVRhKBUekp3Ah+yFytniPaUew0nmFRqIqjyHOeghTmsmcV8/hsv/3WHCew6FiAa9nLwk1oGfUX8XbxavIiwQFclHtoswhFdcFAE7Y38b73T9h64eOw+7XcSN4lTZURYcfbWLMPY047yHJ+mJOl7cNiOxHanYN9xSCdE/0eGUm6pIXKcbdR6BLLm53X4OljxKbP+vD0MYAgAXqGqjV0IChVdEL1xjpsMHGe+j550ItdMwWijyGolaQpk2oap2NNdGmRRs0JQ58bZIV8pMlsZ515HkPMmM3a4orNsOqcwSSpNAom/CbTsXaRPeXicO1X8OV5p+At5l4y4O79PC2ICUhawAzHQAgAgoqM3OOgkKbN5tXLpBBAv0/lcgN0Q+VoLBkgRTpDNb+ospnS1QN6PnugG+6wwEGX6P4MdXdE+gGt1nFMBGVKr4P8ACEr1uevcTGocj609SnxNgWTRyQnaIsqUybYYd9bh+SpNGcNtMP4BUCLl1KI2UauJgKnbOcVcCaok3E7gYSm4puApDEPcA1CAx9HJbeQJjskXhL3GStjRY+DZ+JmKUKCzyafe36V0WPDJBR5CFMYxJhtCEittPV38WV4GUAjHxhnMJxLOE/df7frCdnCqEEXfXQ6l8TGYWi2GIj4j7Clj4qxA34jJ2u1hAnO+Lm5B6WvOc2iBD5d9GhKhUk6e7QBVdEFmno4yxipdK6rnmIkjbiZHffhSEbRYPmBVn/IhMbFYuwJJW9T4UJWmzu6//V7IPMYiwBjz7JOJqZ0LMIU1WqtDkyLe0kbYIv9AD1HtPMR5q12SKtipt8ONIn2b2OWMAL5NQrYlkalaiifZkAv0FtYw5+dFtE//y+KIqYkaC27zr3rLTHiAz8XPNFic5hLjZgvtFrak085HyRGe5RcYITn5EedU8gY9q3XeZvTXPEm+BSgXyRqDrHkOXxPg1hTrzQFQ9BvI7F2jcRFm3I0LDW/hn14pgUZZi2kOUx+uEqJEnfF3FTxpQLAhCfp+XnRWakHUW2GeFKR54H4p6ieyVi54uyadOYhGfMiOqAJKlI0z3Yxjxl2MmOmHun+e89Kj/zZ5CVBW1jAn60TkzmuAlF0TFpnEK1GMXF8CVB2grjJmbsc5jID+Cj/MfI8giPqC/itd7/TixuyNjzr4L7uvL2Au9jm/oEPHMGB6XHEUkR3u/8e8hM/J5vmrrqIU67SJltoyob8NM9aLLFqjkWFNkU8pBp5oN7x/KKGJ27Pkx9SnhBp+y5dIwJIjfy/qfi7is188yM9z81tUZGL3yhvsvrmY8bAdgXYAEZJMlkWTJlfrLsiEyXnp/hzU9jz7LLpkB4W4c2S8IgUx2UdXVxTBycXMkTBb4ZQFKZetmaCCj4mgKA6QvwrHWo3MqSD/o7ziuRwSs1A10I/h4pe43Knu1CvBP9PbV1dG1ctNqGM3yeifOge77yFapIsv/nJf7h/jtvf1FPOIKqVukc5iFb+3kQJYt1ecw5ic3ee+x8h+IcFUUIQ5sUIkMASSaHcROeOY3d7vuiHK2qVSjsPhdVArHGRgBkuNYCJElG11+m0VFWDYniO/g0fCZiFq/Pe/YhNoBNL5VlF4vVF7HSfhl53hMXFIymDwAz3pNYbf8YhjaCCfs0tvwLMPU60eaRQlMpQu0HNyHJJsa9R7HZeQtFEUGWLTTcU2gFK/t0kh1zTixwNabFGsS7SNIdAJIoQVHEStmFKO+wi0kZFl3kqnMErd5F8IfUNWfRDW7uKy8CwKh3moQZsh4KFJBlQ6jlSHxEhvVwVdlGVsTCzJ4TgHgvhG9mtkFyhbxUKUkmi8h2h25wIuvEIgolHW2CLErfw2UyCmSoX82JHJwxOeqewA4TKOCLhmNSaXrEPoKt7jtisyTVIeotWvoU00btiL4rRfBdDBYRyopobCwVDHny5lTEA8j7Z7QAZCJj4WQPx5xBL7gJg5U0k8yn8z4UhVesBYTJnth4aKOnEh+RbfxB6VEdEYQLns1orIQexrswtDpsvYF2cBMj9hG0wxuIkhYMrcbkEqmnyIfxeRBC/TR6UKlHPFxu6xGJJNlB1TmCfriBJN2FqlShq2Qb2PGXxaZAPIAKkyWVMeadwXbnbdjmLACIlgK/N0x9GpPOo7jdeRUAMO09CT/bQTe8I3qkimwyA5WqYHHbegPz8qPIUeC97h+J8iUA0d+UJR1fdf8VXun9f8SGS2SWPfFc8GyJgj7aaOh8mIKcVNUOoFqM4ULvr6FIOhrOcax3XmfPX4bJ6rPoRmvoh7fEPcM5GlRqjFkA0gaQQdfGxfXlZu8AqHIQ3GTEqsFkwjCHgRZX2ogkqKg4h9EdIkXxrJQHhRQ89dlrB2butG5oovTMZW4pMwYUxRkEmWyqZFCiBfZvuOwxYO/Hn6XhUu/+TY9nnLJYT/jxkRWkeU/AwD4Bg+oYMLx5Dv5fEs8Q3wzp9bxUPgik88wHeT97bD3MRLWHJzf7X8uDgoSyWsYC52vnYD0Y3tyloddRkDD4DFmU1QfnMoNtzLMKZ8DOhz7E9zDBvZ8nnNO4031LiJ/kjGA8WKdT0dbQ1RER9PLnRJYNWrvjXXb9ZdEK7YfrbC/6ZDx4OVoyRTlQlm2MOMdYaTqGolTgWXNiIZFlA3PVF3Cz9RKAAYGBlzv5eJGmVAY9kqETxRdwOvEKyzh5NEbRJ8/yUOSouSfQ6n0kIqTBDacM9UPY92AOGmeq/y0+7P4Zu9kzETjwESnRAxrqs3ACFJDD1MdFv9Cz5tDqXWDv7wxljzImqk8KDeReeAdp2hJVgkG2WAxlvin73jp7kHiZh6CqdWRpBzO1r+B26xXwB4JHxDrrvXLWpCzrghTEA4RMkB8ycT4501dXKwjjHaiKC1MnSUASbie1mjTzWYmNsgMeZNHmKolskG+qsmxh1D2One57qNiHWI++YCWsQTmdXwN+DXl7QpENyprSFixjRpCXFIVEAWxjilxWgptE0BEZBSlJFSL6lln1AAAyqEoNByrPYNN/nxGn9qCqIzDUKoJ4G7PV53Cr+RK4LCvN/1H5nN9rRZHD0icQJrui3MwXNUWpUM8y2YOhj4ssjc8l8iCRoygoAz5Y+xauN/8KhkYlXcechAwZVXUWNzr/AElScdb5HbzV+TdDC4HDrmcyIMaxCpKpTyHJeqhYC+T/Gq5All245oywcJsyzqBXbEGXXNxq/xA15wj19FkmtFj9OrrZBqrKDLaTK8hzYr67xiT8ZAdBtI0J7yzutH6Cqdoz6ERrWDSeESYfUdok+VVeimeObLyHyrkmqmwNLZzK0H2UsOudw9LHSJiBBa+K4sK1DmBEW8TNzo+QZf19AQr3quWbSdU5gnb/kjBlGc7Q2AohgoBBhgt83KYlSQYMbYTGrqK1oQ11OEAevM4yDuyrUgxnn/z8DK5nNBTQYv/nsr+l/nB41+/pmRo8Y0MbuWRioLiXin/TvbbIpi3uZvTyjXR/SXxQuqf7hMr1bRYM8ICDEQz3/eyuHrKkwdKn4Ee3IUGCY82z4xisUcPJhqpWRTCmKlzDQEaadSFBgmcfoopjEYuqHA/q6brmokqiaSPQFAf98JZ437HKY9jtXcSgitYVPuYU2GT7vlvNPY5W70PxPXny0GUVo0/DA2/CqjoyFCnTl+fORoMHRhVsRN5fOFL9NawGbyKIt7FQ/SpudX7CSqOJiGBUpSpIFlTGkNjNFYkHghO2KLJQWO+C/rZiH0E3WCFNVTafRTcc133uQVEqQ1km3+C67NsNRVtDERafHewy0ZGiCKGpDTjmJPI8QZqFQkQj5exH1h9RFNoMZ7ynsd57ZyhKpu+ia6OYdh/HdnBRZPO8hEOswy6Gg4kB9v+MR860sVKkr2kjYkPi30WWDZHZk9UW9X6ztCNYoGm6B01tiIiO1HAMUUrmPTI+18r7LXdng5KkQlVcxMmuiHqHy1rD5bFBCa8HfmPzzRiAqFQoisOOsQmgEOeIM1UHhD4i6pjaGHOdigfBG1QY+jjCeJMdS/+e6Nk1JrHdPU993DwcIuBY4P3kPI9hGWOIkjbp4nbfhyTrWKx+Hcut74sNYjgb4JmlqrisV9QBX9wq9lHBOKXz7MKz6FpV7SV0g1uYqTyNm82/g6J4NLfevyIWEUsfZbq5RNqy9FH0gtW7qiWyyFJlma6RoVbRD1fE8fFsZLb6PDZ674LY3VWYKlUAuPYun393zVn48TaVf/0VGj9UXKiKDdeYRENdwkrvx0zc/z1WdRglL99gVZC2kqyHY9Xv4nb0DrUQGGO9KHJMe49jrfPagHUsqSJA5uBlezLfiGAZU6w/yoPivtjwMDR+x+9r6gvqon/LAxqebfJMjZ5vVwRRg7WJB193Z318sxmc/2Et6cHaw8FfPwzprr8Z/OzjSsv3ZrXDmx5VoURWB2B/oMEzYP59K0PB8qAU/fEYzrQLkTBRsK/vK4sDYM/jOhxzQcz28meDros8tGbQed7PyibIsgXOx6jYS+QTzEapRHAgKbCNGSRZn5FVB/K/fH0YJr7RcQ5VP1iViu8posWwL1gj8DL8Fz6ixKP1QQ+DTizvg/Ebj19Azz4MgPpMpl5n/VBylhkmsPDFYVCyAXhUwcHFEeJkS3x5itjopuIjQbwkNnB16ePuG1R8HrCvBKrItoiQeI+L+o49EWQoig3PPIA47eKo+SIu9P/jvrk5HuHW3BNo9i6AkxR0tcbKyNTfrjABEN774j31+/WWAODuyFJk7wyuvbhPT9sxZyBLKht5KcQGxEuiHf+GKBMTUzAQ14JHpQAFFQDEdaMNaTASxdmCw72aASFs0Guicz3I3Aa9skH2LB4GZobNCWtU5kpZH2/QmwIosq85R9DsfSDeZ9AD5GQvXZSr+O9sYwb9cGWop5cNve8gsONZWJZ1RClbURwm+kCLhmfNDeYHh3rWg++SMw5CU5Crhr+DpjZEcDlM6BK9fMYDmPYex63mS5BkfZ+YCL9n+QgbD4aG545l2UXFXmBCOSRoUrcPYaf7wT4ddduYgiLr8LRprLV+xEq1NyHLJjHaWckRAFzrIHrBdfE96Pr4UJQKVNkWbROZC/rrY8jyCEk2EHXRFAcj1hKivIMwbSFOuoJfkWY9VO0l5EXC9Jd74vP5NRn0IAeEtcEozqAqAUBkhbxMPFjwgf0b6HCmQ78bZHKDsuq9m6O4K4f+u9j3/3wW997PuDvTHsbwejfImAfPTfYxr2PvzLLfB8HwRnn/7zW8oX/su2Bw/+sQxDWxkeKe45UkE3zElR+rLLv7xpt4eXp4Y+efx/v3vKrg2Uvo+tcAFEJYCsDQPeOI6ggPsAeVF1aZYJ85vCnvv0eUofW52Hc8pj6FMN7EgAvz8Xhg2Uo6MQV7iQR+I6rsBqe/4fJvJgAJfrSJUeMw0qyHIN7FhPcoioL6NKY2CsckXWFeyuMbja6N40T9X6BAxv4pUBQpMYrv2pyBDChY053faEVKmUDOjxnsxClDxxqL3g3ZL2ZIszbStCkiXfo7VoLnM4NpBwFjb6+kb6BADlWtUtTGekPj1SfQDWkTA2P+FawUz8vJzd4lZFkXs+6XWAARDEW1YNrYGvv+gyhrwG6mRYH/0/WvMUp8hiKP0Q/XWJ+LbdqSjIgJneR5QuemSJl3KRO2YGL2tAHTg1MwZaKiSNi5kNnnUDZHC6xGpS3BMhyc8wIZe23M7h02piDp7D4p6HeSKq4r7wXyUTgAzLVmmADCr2OEtr8MSdJwtPabdK9gQPai61ujBw2ZUDXzw1W6lySVWZLxR0GCqtYRp6TnLUEhRSCJz31TQGJoVTRcMm7vsGDqQOUZdvysrw2w756x8mgGmq8kElTdPU2fp5iih+2YC2xRSJCy8YgCBdK0hc3++6zXSfOIE9WnUaBAxT4EQx+HodZpswTJnqZcnAES8ryHVu9DIvMUKdK0jXZwE4Y2gh4jONLx5mjoR7DW+hEKFGj3LyHPA6RpE5rqwjZn4ZgLkKAw32/qzRraJG1sIMs8kkukgCzPyVe1H64xiVsfeR4hTVsIojU0w2VIIH3xOfcZVOwF9v8BWv0r8KNtkOVmLDYcHvzR+pGz61sM3acQz3Ce+UM/y5Fl3aH7Qxkil0oYLKT7Z0QHuHsDlkDryt0bbzH0N3zdxL7AWpRqJU4opWB5cDwDshZtArRp83NQDJ2PezE4Hiprq/uC9vv/vSI2oLt/R8/rgBd0L4bP0aDEP9gsi6FzzgOTwbnj68lwsEBrYjoUgAy+z3ALQZYtVjkZbPA9sfYBQbSGLOvvq3yqik1ER/as0Bo02A49e0mMj/JK3qA3P3RuQQE87QE6ZJksV6N4C58erBAeOBMeLIJg4zBUPpNll7I51uvk/R5ORuGkiUEWnbCyTIOpkjTBrfp4CZZKoqHIzjR1FLYxxkhSuciABUsNYIQrinR5Rqoq1bvKuhRFUrl2V3wW71HzLISTphTZRpLy3iqVYDn7ztQnmHNKR/RF+RD6MHvZMRewZD6P91p/AAkS6t4jzOTb3zdi4FrzjGW7v6zBI1P+b55t7C/7DG4JPo/HRRm49KUgczBK/n7CBf+cTBC6iiIUiwNlvPTdeLluEIGz0TFJGxqT4GV9yhz2ZxF3ldNBPaBesAz+0DjmIpO2HJTFq84xdIPVfRk0/87DzFNFsXHc/Q6u9P+eXZ8dSFCHyojUWsmGhV4kVZQoeR+IZ3SKbIqylq6NiZ64qU+zMYcdaCqZnvOZVoX1i2mOmvqSAzY+l63k5cRUHBMfV6q5J9EPN5CmLXHcnJQDALpaQ5r7TKnrCixjCmkWQpF1IV4xODdDfTk+mpL5sPQJoQLU6l2Aax3EIeM5vN/+D/vEQfI8gKp4om+bMw31jr+MmnMEe90PAGS0PjA+hySZcK1Z9BhTnZcR+b0rQUXde4SNpuWDcj/LeogdbbNnKBPnl5PZhnkcvCxtMVP2gFVw+D1NB5Df81zxCgzP1Pf3H+/6S1bNuH+GOCAr3fvzQYnz/iXlgYTpveXkB1mWP/7vBuvE/uO5f8kbGC7LfvpnPGjZ/EFx/2O6F3c98/dUJ+4dw6T1PLzPdaD1h7ewBuNcVKniPWBa8/l5pO+oKCROxFuQnGdA9xO/h+g7faE9YV2bFG9IjkHUC2y4p5iF2K7oIfLeUJq1yGmpyKGpLnMfiYd6iPuH6MNkV7Dt6CtTr4dbHN49l7d/Ro2fJhV3l43uJS8MLiAnGFGp1cfwBXXMRSpZCsIQlbgkqNC1BuK0JcQ5eFlXgoyUiUfs6yeyUrMk6ULtJ0p2RF8vSfYEsYqYp6H4RgQ6J559GF3/Kj7toboXxKzmWtXcroyCnZ5Y5GksqApTq6Mf3BTVCc9eQi9YpcyRzV/vL6vScapKVcjjDWcb/FoMiGsAL1dNVJ7Enn+FtRqon0L/LcHQJhAlm+zfG0OfRX3uqr2EIN5hQgeDe4BfL1l2mI9qGxX7CNIsBLdAkyALcQBeLiZyxp7obQ8W53sXy+FNxTJmkOYBXHNaCFXwLID6an3sn9ccBD5AJgKDgaZ5+ollQQkKHGse/XANY94Z7PYvIss6rLS9K6oavD0x6p5Ey18RLFBSmTKgqzVEyYbQOqdWDA9ceamXAmhFsQW7XddGh3gHBarOEREkWcYBGFoNrd6FobIx5zq0hngH5FITJRuQJFMEF8O9/0F5dJAVDgfa+5m4++93Wit4AJvc8zfD539wX/Fy52Ck7hfbYB4ED/oM78f9+7P7e7KDv/u4jPnzffZnOcq7Gd73bvYPcn4HG+TwCBT/HX8+ORExy/rEI4Esgu8HObZhcRRuZbrfE/h+/fac3eecF8SFUsIH2oQfuBzNhRccc4rpqCY0QpMHcIxxwXSUJBmyYjOmmsoGycm8nMpArJQwpHec5z764S36PStlmPoEChQIojV2EnOKdjnbjZ8SSR06MQOpNF4CkWVLqDUNXkPm2oAiSqvDGwO/IThpZXCq6OcFUppLZgL+EmQkyR6V2QomKiHJzPqO+W2Cjy2QfGXIxlsgyVBli2zpMJDUvBcKO6a1oeMEOxf3KR9B3fdzWTaQ5j7iZJeciIqMuXwMSESWPgFNreO4+x2ESZMdM30uMf1C5Hkf3Gd58N42O68GUnYNBwunxMp5VJ4bMMfp+IsiJquyfNC/rduH2DsXpMI2pN3KMxhSrLFR10hxzdSnoSo18V146Zzs0yZQd0/BYHJ3veAGuKA7LxcbWlWI4pORB9lc0vfIGOvY2neWdbUGCSpUtSZ66K3+FUTJ9lBpTEGex9C10XuuJYp88HMm6kKl44BlaDbLAvl5ZCNCikeuU8FNFEWEnd4H4AYrnAGuKcSA5g5B2503yUEmui2CHcr6ZTrGIhXBE7UYdBjaBCx9AkLEJQ/hmOReReNThdgESPyiD1m28YT5W+iHG/DsJSjyoNSeZT0q67PWBBH7Ntl1V+GZ0xh1jotrz+8PAt8s2ViQWhn6/MF0wQCZeO2gFcIhDf18eDPgGwHPqoq7fj5cch28z2fD3e/x+d/rXtY0f84w9G+Ic3R/5B/z88+P/ddi/4Z7L9v8k99pgIxtvMVdGzAwnAWH8TrbNDNkWXdoA6byN3+G6Bjlfb8rkIqNtChi1kbp4l4Mn2PeHumyNpPM9rkH68EDnyETphElJpKgeJipPI3V9k9p85Vonkqw2tgXUtURMpLuXcKg33lvY58PzhNykU0P32Sy7MIxp9D1l0UUTD9nEb8gNQ2XKXj5lJewh0gNIB3fQflqPyFDlonlyeeSOXty38kT2WNINoxMwIBn1IY2xkhbTHBDHQGfP+PZp6zYGHGOoh3chGtOY6/7rnj3+5eoPj1qNLRJEjOJbu4/XlFWY2NRQ65Yw99J1xoi61TVEWSZT3OrrLy9/3zdD8MZRSgyIP46Oi8b+15B2e+uMKsYRJ+UjY15Z7DZfg28pF4UISzjAGRJE2M3vO0xmKEkJq3E2MAKE/zgBKmF6otY7f78PrN8Q8Q3RsajDPB+33PAmuQjdlQFIvYm9at01OyDTAOYv45jWG5w/7U6Wvt1XGr+0b7jGp4KGGbfcrLbxzNmCTwLzfOIEZRSoQqlKx6itCmU0KikPrh/+efvJxEOYGiTAMDGDkkFTBhq5CEOV34Vl5p/LFpCw6Q7fq8Y2uRd98ZAhYnaPDtDv1FFdeneqsHnzV7/c5RVP+tn/+Ll6X8e2K8MeK+D0TBr++575tNK7Pf//bBEJ6/a0edrLMD/Ql2UVFG+kSDBNmfhh6vCbWSQSeaiXMDnV4f7WneTjFSlQjrQbHaOL1rZMNHqnpOiDJEl5KFS8n5QH3sgjrH/JN6/l0P0/AFTeJDR3f23XJ+Vq2clTFB8S1xcVakNDXDzPjbEe/FNUZJ0eNasYDL/Yhhs1vfOGOKenw+XqvazKPf3nLmsIn3XB/PJ/NgjvM+iye8NTW2gKNKB8IdkDOnwtsBFArgF2sDNBjC0BsL4zr7giLOEefZnaJOoWLPY6b4njmHQklDhmjMIkyYSZk83UA0b7mWzoOo+o2S6RjraPBCj0aQUpkYG9Nx6ERhkBfv7d4P3H6s8gZ3OeaZklmNYfWmYIKOoFdE+4Az4+21KPJOnnm8PNNPPS+S8fEsZJ2cUD8Qquqi5J5mYzb2leX7vmPr0UGtg/yI1PCZEyHGvct1dR83K1FGyvS+4/i8T/9w30c8LaWitHvzsXs7Lx69bNPmwP9AeJCnZEG/g09c+RamI5/UL7QkPNuH7RQ/3G2TfrypDC+Ld1HL6Wz5/Su/AmXX3i0D4Qz0ocWhqAwXyj8lUho//7s9+sKiVWx/y4fD9UITJw+D78xEosjjjGUYQrYGrwAxm2gZzy/frWd2LBxmPeFAo91nUBueEC3gYWpU5tVCfjIgx7U/5fAmaOvpAajH87+++dxTFGRJu4SMHV+86bkno+UqShrna13Cz+bef+ml81EllRhYSZOQFSZSmTBbRMw/QfZUF+8Zw+LkZBFV0/999X94vU+XSkQNpSm49WYi/GYxZDOCYi8iLZD/piJXBOf8AuLs8uf/8auooFFlHGN9BzX0E7f4VxqTGXT2v4QWLCG+2QQppuuqhF1wf6l8Pvu/HE3t4sEL3jKFNIitipGlb2HkSIfHu536/KhLhfgSoEiU4HnSE6t7X8XEvIoleH/rNIEkZjBJ+PIZnrAF88ZvwsODFJ32wZRxAUeQImf2bBAk6F0pPW3dlw3cvaBzD7MKCbXb7mc53P5BUytq85+f0OcT0HbbH+qT5Ov5defZPyls8wh8svjxzH2xMA0LI/vIhz4LvV/IYMGY/GV8cieJurdj7z2rvx92My48f3P+4LPwXOF42O8yrHvtL69yCkky52/2L4nWcFDXcauAZLBcAGfSjZWGTxrV5B6VfYLgyMABn/e5XarvfdR7MHg8Lz3z8rKjorTGzhuH5dWKxU9+7Yi/u+84cg+ulDH3e4HjIVWvlntep6gg0xWbVqeH2w8ffo5Kks/nym7j/XCq/z4H9M7LDc+Iff7/sbyuV+OeLu5+tB6se3EvCezA82Os+/hi+4E1Yu88HfXqf0jIOIIxpZnCgTDMQ0OD9wuES4v73vj/u3vgBsFLY+ie87n4D8YPPGbynAts4AD+69THvNbgR7s9k/TwR2ScN6/+y8Y+7DDYIoGhOeHhBvruU61oL94lkB6X3Ye1d7kc8EHXBPcGDLNtEwJJkJGnvnqoHf82wheGwAg+XXRQBGgbiK6o6AlOri+MdtELIkCNiJfHBM0H3nalPwzbGh/gD9PO7I3UiVxGLnxvTfzJbFOD3LrcT/TiWPgdnVXPZUtc6OMSqv/t9+VjW/TPm4b+756f34S+U+OeIL3qt+uLZ4cMV4y88E/7kD/2kcup+ujxAi5AEdYgcxR/yj9+8Pq2u/0kXaP/Df/9N8tMl2T7uc+73uRKbAeZ91GEJweJjXzeQTru7x/GfDw9eHn84GJDHNrH/Og44A/cfKXJhGxP7Rq8kScN09VnsBVeH7sP9memw/Olw4GkZM3D0cex03wOfZ7/bmWt/BeXuoJXbzPXF53DltoxxDSr24l3z8Ry0eNwtK8jPz90kJv6aj+urDnpig+9vaJMkuvEJz8R+F6H7VEs+JpPYP0r4yxyRKfFfFj7LJjzcXvs0JbB73/N+z9Zn/dz/bJvwJ75OzGzeb/Tm40q098dgfnT/e3xWwsZA1H1Y+OHu+U8+A/vpi8Qgg7l/qZlmKu8+7hJfPPZvbtxsY9jHdyAM0xq8is0EC7ctZoHJWwmSZDLHqXcw2JhpMH9YJJ8P/g+/7+C+GNbIvjtIIJJf3V5CJ7wtdG0H7Z/73Z/RvvfY314APvvmRsc0UX2asdD/cQZgJUo8GB5edW84MP0lbcKf58v94y533g3qLfPRjM8bqQ/6ovcrnZf4ZWB/5DusR32vgtDHg5PQho0lBLP3npLoJ98fg6x0F/eyiQfVEU0dRZaTklUQbyPP++xnA+W4QQ/VYKV4967sHMIy8fNXUcrMtESJz479PsocX+gmLOQpP7GfBPxiD/GDb9aOuQg/XP3P0CO6HxEAuHtB/XhZuxIPF5/QorgPgUhVakP+swOjEoCXbJt3vR8X1x8WeN//foZWhx+uCmvFYSb/YL55wNzn4ifDZK/Bpj3s1/zp3/GXgUGPviRJlfjHhF/8Ofg0wu5nPY4vVDGrKBLRp9LUxoC5eQ8+ToFF+YTXiE950MNBP7xXZ3kYnE37i+FuswiAjnH/cZI82efdgD+P6k6JB8NAU/puSFCFQPswsqwn5pIBCY/X/uXAhSe9dzKAlJl4aZju/apznORaISHNugjiTRTIkKQ7TBKTM73p3wOBeDrmPI9AXs3OvmeGpPQM0c8m3sEIRrwzn+Wk/MKgAKXcgEv8Y8MvHogW91nff9nH8bl6wp8uSv7gzMfPYrP12fBPqwRe4ovCfmLV/jGcQc9YU+v3jMvdD/v7/YORswGx6N77jJsxACQfaRkNphpHRKQR79Q+ZnPNPY6OvyxKWbo2jiRtifExz15CP1zDwAO3YIIAKfN3/jjORYkSJR4mfmnErM/Onn2Y4zcl/vli/4Z8v57Nvr8WwixULv5kdiSbY78riOQynwM2NVCxj6LrX7/vpj1wWBowmbk9ICfzDUrWw8Fq+UyVKPGPHb+0TXi/AMI/Lzz4GFOJh4f7VWQ+X2Vk//W+/yiaGL+TdDjmLIJ4+zOONnz6senaOBO7+WRluBIlSvzjwRfaEx4Gd6n4Lx1ckL7EPzV8khjEZ32nIaGPIXBnIAkK6/8CKHL0guX7qsr9oiCzA8riLePAXb8teQUlSvxTxefahD8N+02V/2lAgnoPmetupx8AZRb8Txb3k5y8P+5HIOTOW651CADZDbrWIUiyThaA4PdGIV7x2Y7tk5FmLVGOHtaQBoCqcwwfb5FXokSJf8z4JYh1fF4R7RIlHg6GRTE+TfOa+rM0vvTJBMV7H6uPF3X5xTGsRFeiRIl/HHgIilm/iIdnuXGXeNgYNty4PwZqasCD3eslgapEiX+u+KX1hD/hIz/3K++dxy1R4ouFpjY+5S+yTx31od/ff5bw/m2YL2LusESJEv+l4nNvwlzA4ItBUZbRSvzSwcVmPhsevNdaKqaVKFHis+KXbuBQokSJEiVK/HPEQyhHlyhRokSJEiUeFOUmXKJEiRIlSjwklJtwiRIlSpQo8ZBQbsIlSnwOcMWsEiVKlPhFUG7CJUp8DnBzhhIlSpT4RVBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDQrkJlyhRokSJEg8J5SZcokSJEiVKPCSUm3CJEiVKlCjxkFBuwiVKlChRosRDglQURfGwD6JEiRIlSpT454gyEy5RokSJEiUeEspNuESJEiVKlHhIKDfhEiVKlChR4iGh3IRLlChRokSJh4RyEy5RokSJEiUeEspNuESJEiVKlHhIKDfhEiVKlChR4iGh3IRLlChRokSJh4RyEy5RokSJEiUeEv7/bwaZNOe2BdgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "render = RenderSplat()\n", + "camera = torch.eye(4, device=device)\n", + "img, mask, disparity = render.render_splats(\n", + " splats,\n", + " camera,\n", + " 'PINHOLE',\n", + " 60.0,\n", + " 1024,\n", + " 1024,\n", + " max_splats=2000000,\n", + " opacity_is_logit=True,\n", + " add_sh_bias=True,\n", + ")\n", + "img_np = img[0].detach().cpu().numpy()\n", + "mask_np = mask.detach().cpu().numpy()\n", + "disp_np = disparity[0, :, :, 0].detach().cpu().numpy()\n", + "plt.figure(figsize=(6, 6))\n", + "plt.imshow(img_np)\n", + "plt.axis('off')\n", + "plt.figure(figsize=(6, 6))\n", + "plt.imshow(mask_np, cmap='gray')\n", + "plt.axis('off')\n", + "plt.figure(figsize=(6, 6))\n", + "plt.imshow(disp_np, cmap='magma')\n", + "plt.axis('off')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pointcloud_nodes.py b/pointcloud_nodes.py index 5d196d2..417f4fc 100644 --- a/pointcloud_nodes.py +++ b/pointcloud_nodes.py @@ -7,7 +7,10 @@ import os import folder_paths import logging import hashlib -from kornia.filters import median_blur +try: + from kornia.filters import median_blur +except ImportError: # kornia is optional; median_blur is not used in this module + median_blur = None from tqdm import tqdm # Try importing open3d and its visualization modules; log a warning if not found @@ -136,6 +139,116 @@ def project_first_hit(volume_sparse: torch.Tensor) -> Tuple[torch.Tensor, torch. return rgba.permute(2, 0, 1), first_hit.any(dim=2) +# ==== SE(3) trajectory interpolation ==== # +def _rotmat_to_quat_wxyz(R: torch.Tensor) -> torch.Tensor: + """ + Convert a batch of rotation matrices [K,3,3] to unit quaternions [K,4] (wxyz). + Uses Shepperd's method for numerical robustness. K is expected to be small + (trajectory waypoints), so a Python loop is acceptable. + """ + quats = [] + for i in range(R.shape[0]): + m = R[i] + trace = m[0, 0] + m[1, 1] + m[2, 2] + if trace > 0.0: + s = torch.sqrt(trace + 1.0) * 2.0 + w = 0.25 * s + x = (m[2, 1] - m[1, 2]) / s + y = (m[0, 2] - m[2, 0]) / s + z = (m[1, 0] - m[0, 1]) / s + elif m[0, 0] > m[1, 1] and m[0, 0] > m[2, 2]: + s = torch.sqrt(1.0 + m[0, 0] - m[1, 1] - m[2, 2]) * 2.0 + w = (m[2, 1] - m[1, 2]) / s + x = 0.25 * s + y = (m[0, 1] + m[1, 0]) / s + z = (m[0, 2] + m[2, 0]) / s + elif m[1, 1] > m[2, 2]: + s = torch.sqrt(1.0 + m[1, 1] - m[0, 0] - m[2, 2]) * 2.0 + w = (m[0, 2] - m[2, 0]) / s + x = (m[0, 1] + m[1, 0]) / s + y = 0.25 * s + z = (m[1, 2] + m[2, 1]) / s + else: + s = torch.sqrt(1.0 + m[2, 2] - m[0, 0] - m[1, 1]) * 2.0 + w = (m[1, 0] - m[0, 1]) / s + x = (m[0, 2] + m[2, 0]) / s + y = (m[1, 2] + m[2, 1]) / s + z = 0.25 * s + quats.append(torch.stack([w, x, y, z])) + q = torch.stack(quats, dim=0) + return q / q.norm(dim=-1, keepdim=True).clamp(min=1e-12) + + +def _quat_wxyz_to_rotmat(q: torch.Tensor) -> torch.Tensor: + """Convert unit quaternions [N,4] (wxyz) to rotation matrices [N,3,3].""" + q = q / q.norm(dim=-1, keepdim=True).clamp(min=1e-12) + w, x, y, z = q.unbind(-1) + R = torch.stack([ + 1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y), + 2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x), + 2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y), + ], dim=-1).reshape(*q.shape[:-1], 3, 3) + return R + + +def _quat_slerp(q0: torch.Tensor, q1: torch.Tensor, alpha: torch.Tensor) -> torch.Tensor: + """ + Spherical linear interpolation between quaternion batches q0, q1 [N,4] (wxyz) + with per-element interpolation factors alpha [N]. Falls back to normalized + lerp when the quaternions are nearly parallel. + """ + dot = (q0 * q1).sum(dim=-1, keepdim=True) + q1 = torch.where(dot < 0.0, -q1, q1) # shortest arc + dot = dot.abs().clamp(max=1.0) + a = alpha.reshape(-1, 1).to(q0.dtype) + theta = torch.acos(dot) + sin_theta = torch.sin(theta) + near_parallel = sin_theta < 1e-6 + denom = sin_theta.clamp(min=1e-12) + w0 = torch.where(near_parallel, 1.0 - a, torch.sin((1.0 - a) * theta) / denom) + w1 = torch.where(near_parallel, a, torch.sin(a * theta) / denom) + q = w0 * q0 + w1 * q1 + return q / q.norm(dim=-1, keepdim=True).clamp(min=1e-12) + + +def interpolate_se3(trajectory: torch.Tensor, num_steps: int) -> torch.Tensor: + """trajectory [K,4,4] -> [num_steps,4,4]. Piecewise: quaternion SLERP on R, lerp on t. + K==1 -> repeat. Must return valid rotation matrices (orthonormal).""" + if isinstance(trajectory, np.ndarray): + trajectory = torch.from_numpy(trajectory) + trajectory = trajectory.float() + if trajectory.dim() == 2: + trajectory = trajectory.unsqueeze(0) + if trajectory.dim() != 3 or trajectory.shape[-2:] != (4, 4): + raise ValueError(f"interpolate_se3 expects trajectory of shape [K,4,4], got {tuple(trajectory.shape)}") + if num_steps < 1: + raise ValueError(f"interpolate_se3 requires num_steps >= 1, got {num_steps}") + K = trajectory.shape[0] + if K == 1: + return trajectory.expand(num_steps, 4, 4).clone() + + R = trajectory[:, :3, :3] + t = trajectory[:, :3, 3] + q = _rotmat_to_quat_wxyz(R) + # Enforce hemisphere continuity along the waypoint sequence so piecewise + # SLERP always takes the shortest arc between consecutive poses. + for k in range(1, K): + if (q[k] * q[k - 1]).sum() < 0.0: + q[k] = -q[k] + + idxs = torch.linspace(0, K - 1, num_steps, device=trajectory.device) + lower = idxs.floor().long().clamp(max=K - 2) + upper = lower + 1 + alpha = (idxs - lower.float()) + + q_interp = _quat_slerp(q[lower], q[upper], alpha) + t_interp = t[lower] * (1.0 - alpha).unsqueeze(-1) + t[upper] * alpha.unsqueeze(-1) + + out = torch.eye(4, dtype=trajectory.dtype, device=trajectory.device).repeat(num_steps, 1, 1) + out[:, :3, :3] = _quat_wxyz_to_rotmat(q_interp) + out[:, :3, 3] = t_interp + return out + # ==== Node Definitions ==== # class DepthToPointCloud: """ @@ -794,8 +907,9 @@ class CameraMotionNode: class CameraInterpolationNode: """ - Wrap two 4×4 poses into a trajectory tensor. - Outputs only `trajectory` (shape 2×4×4). + Interpolate between two 4×4 poses into a trajectory tensor using proper + SE(3) interpolation (quaternion SLERP on rotation, lerp on translation). + Outputs `trajectory` (shape num_steps×4×4, default 2×4×4). """ @classmethod @@ -804,7 +918,10 @@ class CameraInterpolationNode: "required": { "initial_matrix": ("MAT_4X4",), "final_matrix": ("MAT_4X4",), - } + }, + "optional": { + "num_steps": ("INT", {"default": 2, "min": 2, "max": 4096, "tooltip": "Number of poses in the output trajectory, SE(3)-interpolated between the two matrices."}), + }, } RETURN_TYPES = ("TENSOR",) RETURN_NAMES = ("trajectory",) @@ -815,14 +932,15 @@ class CameraInterpolationNode: self, initial_matrix: torch.Tensor, final_matrix: torch.Tensor, + num_steps: int = 2, ) -> Tuple[torch.Tensor]: - # stack into a (2,4,4) trajectory # convert to tensor if needed if isinstance(initial_matrix, np.ndarray): initial_matrix = torch.from_numpy(initial_matrix).float() if isinstance(final_matrix, np.ndarray): final_matrix = torch.from_numpy(final_matrix).float() - traj = torch.stack([initial_matrix, final_matrix], dim=0) + keyframes = torch.stack([initial_matrix.float(), final_matrix.float()], dim=0) + traj = interpolate_se3(keyframes, num_steps) return (traj,) @@ -1250,6 +1368,95 @@ class LoadTrajectory: return f"Invalid trajectory file: {trajectory_file}" return True +class DepthEdgeFilter: + """ + Detect "flying pixel" depth discontinuities and output a validity mask. + A pixel is flagged as an edge where |depth gradient| / depth exceeds + `relative_threshold`; edges are optionally dilated. Returns a MASK with + 1.0 where the depth is valid (NOT a flying-pixel edge) and 0.0 on edges. + """ + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + # Depth: [H,W] or [T,H,W], trailing channel dim of 1 accepted + "depth": ("TENSOR", {"shape_hint": [None, None, None]}), + "relative_threshold": ("FLOAT", {"default": 0.05, "min": 0.0, "max": 10.0, "step": 0.005, "tooltip": "Mark a pixel as edge where |depth gradient| / depth exceeds this value."}), + "dilate": ("INT", {"default": 1, "min": 0, "max": 64, "tooltip": "Grow detected edges by this many pixels (max-pool dilation)."}), + }, + "optional": { + "mask": ("MASK", {"tooltip": "Optional validity mask ANDed with the edge-filter result."}), + }, + } + + RETURN_TYPES = ("MASK",) + RETURN_NAMES = ("valid_mask",) + FUNCTION = "filter_edges" + CATEGORY = "Camera/PointCloud" + + def filter_edges( + self, + depth: torch.Tensor, + relative_threshold: float, + dilate: int, + mask: torch.Tensor = None, + ) -> Tuple[torch.Tensor]: + d = depth + if isinstance(d, np.ndarray): + d = torch.from_numpy(d) + d = d.float() + # Accept [H,W], [H,W,1], [T,H,W], [T,H,W,1] + if d.dim() == 4 and d.shape[-1] == 1: + d = d[..., 0] + elif d.dim() == 3 and d.shape[-1] == 1: + d = d[..., 0] + squeeze_batch = False + if d.dim() == 2: + d = d.unsqueeze(0) + squeeze_batch = True + if d.dim() != 3: + raise ValueError(f"DepthEdgeFilter expects depth of shape [H,W] or [T,H,W] (trailing 1 ok), got {tuple(depth.shape)}") + + eps = 1e-8 + # Forward differences along x and y; propagate each difference to both + # neighbouring pixels so both sides of a discontinuity are flagged. + dx = (d[:, :, 1:] - d[:, :, :-1]).abs() + dy = (d[:, 1:, :] - d[:, :-1, :]).abs() + gx = torch.zeros_like(d) + gx[:, :, :-1] = dx + gx[:, :, 1:] = torch.maximum(gx[:, :, 1:], dx) + gy = torch.zeros_like(d) + gy[:, :-1, :] = dy + gy[:, 1:, :] = torch.maximum(gy[:, 1:, :], dy) + grad = torch.maximum(gx, gy) + edge = (grad / d.abs().clamp(min=eps)) > relative_threshold + + if dilate > 0: + k = 2 * int(dilate) + 1 + edge = F.max_pool2d(edge.float().unsqueeze(1), kernel_size=k, stride=1, padding=int(dilate)).squeeze(1) > 0.5 + + valid = (~edge).float() + + if mask is not None: + m = mask + if isinstance(m, np.ndarray): + m = torch.from_numpy(m) + m = m.float().to(valid.device) + if m.dim() == 4 and m.shape[-1] == 1: + m = m[..., 0] + if m.dim() == 2: + m = m.unsqueeze(0) + if m.shape[0] == 1 and valid.shape[0] > 1: + m = m.expand(valid.shape[0], -1, -1) + if m.shape[-2:] != valid.shape[-2:]: + m = F.interpolate(m.unsqueeze(1), size=valid.shape[-2:], mode="nearest").squeeze(1) + valid = valid * (m > 0.5).float() + + if squeeze_batch: + valid = valid[0] + return (valid,) + + NODE_CLASS_MAPPINGS = { "DepthToPointCloud": DepthToPointCloud, "TransformPointCloud": TransformPointCloud, @@ -1264,4 +1471,5 @@ NODE_CLASS_MAPPINGS = { "PointCloudCleaner": PointCloudCleaner, "SaveTrajectory": SaveTrajectory, "LoadTrajectory": LoadTrajectory, + "DepthEdgeFilter": DepthEdgeFilter, } \ No newline at end of file diff --git a/pose_nodes.py b/pose_nodes.py new file mode 100644 index 0000000..5c9fef7 --- /dev/null +++ b/pose_nodes.py @@ -0,0 +1,461 @@ +"""Camera pose estimation nodes. + +Provides: +- VideoPoseEstimator: VGGT-based per-frame camera pose + depth + intrinsics + estimation from a video clip. +- TrajectoryInvert / TrajectoryCompose: small utility nodes for wiring + trajectory tensors ([K, 4, 4] world-to-camera matrices) in graphs. + +Coordinate convention (matches the rest of this repo): camera frame is ++X right, +Y down, +Z forward; trajectory matrices are 4x4 world-to-camera +(`cam_pts = world_pts @ R.T + t`). VGGT outputs OpenCV-convention +camera-from-world extrinsics, which match this convention directly. +""" + +import math +import os +import sys +from typing import Any, Dict, Optional, Tuple + +import numpy as np +import torch +import torch.nn.functional as F +from tqdm import tqdm + +try: + import folder_paths +except ImportError: # Allow notebook usage outside ComfyUI + class _FolderPathsStub: + def __getattr__(self, name): + raise ModuleNotFoundError( + "folder_paths is unavailable; this feature requires the ComfyUI runtime." + ) + + folder_paths = _FolderPathsStub() + +_here = os.path.dirname(os.path.abspath(__file__)) +# climb up 2 levels: camera-comfyUI -> custom_nodes -> ComfyUI +COMFYUI_ROOT = os.path.abspath(os.path.join(_here, os.pardir, os.pardir)) + +DEVICE_CHOICES = ["auto", "cpu", "cuda"] + +# Module-level model cache: {device_str: model} +_VGGT_MODEL_CACHE: Dict[str, Any] = {} + + +# --------------------------------------------------------------------------- # +# SE(3) interpolation (contract C1). Prefer the shared implementation from +# pointcloud_nodes; fall back to a local copy so this file works standalone. +# --------------------------------------------------------------------------- # + +def _matrix_to_quaternion(R: torch.Tensor) -> torch.Tensor: + """Convert a single 3x3 rotation matrix to a wxyz quaternion.""" + R = R.to(torch.float64) + m00, m01, m02 = R[0, 0], R[0, 1], R[0, 2] + m10, m11, m12 = R[1, 0], R[1, 1], R[1, 2] + m20, m21, m22 = R[2, 0], R[2, 1], R[2, 2] + trace = m00 + m11 + m22 + if trace > 0.0: + s = torch.sqrt(trace + 1.0) * 2.0 + w = 0.25 * s + x = (m21 - m12) / s + y = (m02 - m20) / s + z = (m10 - m01) / s + elif (m00 > m11) and (m00 > m22): + s = torch.sqrt(1.0 + m00 - m11 - m22) * 2.0 + w = (m21 - m12) / s + x = 0.25 * s + y = (m01 + m10) / s + z = (m02 + m20) / s + elif m11 > m22: + s = torch.sqrt(1.0 + m11 - m00 - m22) * 2.0 + w = (m02 - m20) / s + x = (m01 + m10) / s + y = 0.25 * s + z = (m12 + m21) / s + else: + s = torch.sqrt(1.0 + m22 - m00 - m11) * 2.0 + w = (m10 - m01) / s + x = (m02 + m20) / s + y = (m12 + m21) / s + z = 0.25 * s + q = torch.stack([w, x, y, z]) + return (q / q.norm().clamp(min=1e-12)).to(torch.float32) + + +def _quaternion_to_matrix(q: torch.Tensor) -> torch.Tensor: + """Convert a wxyz quaternion to a 3x3 rotation matrix.""" + q = q / q.norm().clamp(min=1e-12) + w, x, y, z = q[0], q[1], q[2], q[3] + return torch.stack([ + torch.stack([1 - 2 * (y * y + z * z), 2 * (x * y - w * z), 2 * (x * z + w * y)]), + torch.stack([2 * (x * y + w * z), 1 - 2 * (x * x + z * z), 2 * (y * z - w * x)]), + torch.stack([2 * (x * z - w * y), 2 * (y * z + w * x), 1 - 2 * (x * x + y * y)]), + ]) + + +def _quat_slerp(q0: torch.Tensor, q1: torch.Tensor, alpha: float) -> torch.Tensor: + """Spherical linear interpolation between two wxyz quaternions.""" + q0 = q0 / q0.norm().clamp(min=1e-12) + q1 = q1 / q1.norm().clamp(min=1e-12) + dot = torch.dot(q0, q1) + if dot < 0.0: # take the short path on the quaternion hypersphere + q1 = -q1 + dot = -dot + dot = dot.clamp(-1.0, 1.0) + if dot > 0.9995: # nearly parallel: lerp + renormalize is numerically safer + q = (1.0 - alpha) * q0 + alpha * q1 + return q / q.norm().clamp(min=1e-12) + theta = torch.acos(dot) + sin_theta = torch.sin(theta) + w0 = torch.sin((1.0 - alpha) * theta) / sin_theta + w1 = torch.sin(alpha * theta) / sin_theta + q = w0 * q0 + w1 * q1 + return q / q.norm().clamp(min=1e-12) + + +def _interpolate_se3_fallback(trajectory: torch.Tensor, num_steps: int) -> torch.Tensor: + """trajectory [K,4,4] -> [num_steps,4,4]. Piecewise: quaternion SLERP on R, lerp on t. + K==1 -> repeat. Returns valid (orthonormal) rotation matrices. Matches contract C1.""" + traj = torch.as_tensor(trajectory, dtype=torch.float32) + if traj.dim() == 2: + traj = traj.unsqueeze(0) + if traj.dim() != 3 or traj.shape[-2:] != (4, 4): + raise ValueError(f"Expected trajectory of shape [K,4,4], got {tuple(traj.shape)}") + K = traj.shape[0] + if K == 1: + return traj.expand(num_steps, 4, 4).clone() + quats = torch.stack([_matrix_to_quaternion(traj[i, :3, :3]) for i in range(K)]) + trans = traj[:, :3, 3] + positions = torch.linspace(0.0, float(K - 1), num_steps) + out = [] + for pos in positions: + lower = int(torch.floor(pos).clamp(max=K - 2)) + upper = lower + 1 + alpha = float(pos) - lower + q = _quat_slerp(quats[lower], quats[upper], alpha) + t = (1.0 - alpha) * trans[lower] + alpha * trans[upper] + M = torch.eye(4, dtype=torch.float32) + M[:3, :3] = _quaternion_to_matrix(q) + M[:3, 3] = t + out.append(M) + return torch.stack(out, dim=0) + + +try: + from .pointcloud_nodes import interpolate_se3 +except Exception: + try: + from pointcloud_nodes import interpolate_se3 + except Exception: + interpolate_se3 = _interpolate_se3_fallback + + +# --------------------------------------------------------------------------- # +# VGGT lazy import helpers +# --------------------------------------------------------------------------- # + +def _import_vggt() -> Tuple[Any, Any]: + """Lazily import VGGT. Tries the pip package first, then a sibling clone + at COMFYUI_ROOT/vggt (mirroring how video_nodes.py handles Video-Depth-Anything).""" + try: + from vggt.models.vggt import VGGT + from vggt.utils.pose_enc import pose_encoding_to_extri_intri + return VGGT, pose_encoding_to_extri_intri + except ImportError: + pass + + vggt_clone_path = os.path.join(COMFYUI_ROOT, "vggt") + if os.path.isdir(vggt_clone_path) and vggt_clone_path not in sys.path: + sys.path.insert(0, vggt_clone_path) + try: + from vggt.models.vggt import VGGT + from vggt.utils.pose_enc import pose_encoding_to_extri_intri + return VGGT, pose_encoding_to_extri_intri + except ImportError as exc: + raise ModuleNotFoundError( + "VGGT is not installed. Install it with `pip install vggt` (or " + "`pip install git+https://github.com/facebookresearch/vggt.git`), or clone " + f"https://github.com/facebookresearch/vggt into {vggt_clone_path!r}. " + "It also requires `huggingface_hub` to download the facebook/VGGT-1B weights." + ) from exc + + +def _get_vggt_model(device: torch.device) -> Any: + """Load (and cache) the VGGT-1B model on the requested device.""" + key = str(device) + if key not in _VGGT_MODEL_CACHE: + VGGT, _ = _import_vggt() + print(f"[pose_nodes] Loading facebook/VGGT-1B onto {key} (first call downloads ~5GB weights)...") + model = VGGT.from_pretrained("facebook/VGGT-1B") + model = model.to(device).eval() + _VGGT_MODEL_CACHE[key] = model + return _VGGT_MODEL_CACHE[key] + + +def _vggt_preprocess(frames: torch.Tensor, resolution: int, device: torch.device) -> torch.Tensor: + """[T,H,W,3] float 0..1 -> [1,T,3,Hp,Wp] with max dim == resolution (both dims + divisible by 14, the VGGT patch size), aspect ratio preserved.""" + T, H, W, _ = frames.shape + imgs = frames.permute(0, 3, 1, 2).to(device=device, dtype=torch.float32) + if imgs.max() > 1.5: # defensively handle 0..255 inputs + imgs = imgs / 255.0 + scale = float(resolution) / float(max(H, W)) + new_h = max(14, int(round(H * scale / 14.0)) * 14) + new_w = max(14, int(round(W * scale / 14.0)) * 14) + if (new_h, new_w) != (H, W): + imgs = F.interpolate(imgs, size=(new_h, new_w), mode="bilinear", align_corners=False) + return imgs.clamp(0.0, 1.0).unsqueeze(0) # [1,T,3,Hp,Wp] + + +class VideoPoseEstimator: + """ + Estimates per-frame camera poses (world-to-camera [T,4,4]), metric-ish depth + maps, depth confidence and the horizontal FOV from a video clip using + facebook/VGGT-1B. + + VGGT extrinsics use the OpenCV camera convention (+X right, +Y down, + +Z forward, camera-from-world), which matches this repo's trajectory + convention, so the matrices are returned as-is (padded to 4x4). + """ + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + # Video frames: Tensor [T, H, W, 3] float 0..1 + "frames": ("IMAGE", {"shape_hint": [None, None, None, 3]}), + "max_frames": ("INT", { + "default": 64, "min": 1, "max": 1024, + "tooltip": "If the clip has more frames than this, it is stride-subsampled " + "for VGGT and the poses are SE(3)-interpolated back to full length " + "(depth/confidence use nearest-frame fill).", + }), + "resolution": ("INT", { + "default": 518, "min": 98, "max": 1036, + "tooltip": "Max image dimension fed to VGGT (rounded to a multiple of 14).", + }), + "device": (DEVICE_CHOICES, {"default": "auto"}), + } + } + + RETURN_TYPES = ("TENSOR", "TENSOR", "FLOAT", "TENSOR") + RETURN_NAMES = ("trajectory", "depths", "horizontal_fov", "confidence") + FUNCTION = "estimate_poses" + CATEGORY = "Camera/Pose" + DESCRIPTION = ( + "VGGT camera pose + depth estimation. Outputs world-to-camera trajectory [T,4,4], " + "depth maps [T,H,W] at the input resolution, mean horizontal FOV (degrees) and " + "per-pixel depth confidence [T,H,W]." + ) + + def estimate_poses( + self, + frames: torch.Tensor, + max_frames: int = 64, + resolution: int = 518, + device: str = "auto", + ) -> Tuple[torch.Tensor, torch.Tensor, float, torch.Tensor]: + if frames.dim() != 4 or frames.shape[-1] != 3: + raise ValueError(f"Expected frames of shape [T,H,W,3], got {tuple(frames.shape)}") + T_full, H, W, _ = frames.shape + + if device == "auto": + dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") + elif device == "cuda": + if not torch.cuda.is_available(): + raise ValueError("CUDA requested but not available.") + dev = torch.device("cuda") + else: + dev = torch.device("cpu") + + # Stride-subsample overly long clips, keeping the frame mapping so that + # poses can be interpolated back afterwards. + if T_full > max_frames: + sub_indices = torch.linspace(0, T_full - 1, max_frames).round().long().unique() + print( + f"[VideoPoseEstimator] WARNING: clip has {T_full} frames > max_frames={max_frames}; " + f"running VGGT on {sub_indices.numel()} stride-subsampled frames. Poses are " + "SE(3)-interpolated back to full length; depth/confidence use nearest-frame fill. " + "Increase max_frames for exact per-frame estimates." + ) + proc_frames = frames[sub_indices] + else: + sub_indices = None + proc_frames = frames + + images = _vggt_preprocess(proc_frames, resolution, dev) # [1,S,3,Hp,Wp] + S, Hp, Wp = images.shape[1], images.shape[-2], images.shape[-1] + + _, pose_encoding_to_extri_intri = _import_vggt() + model = _get_vggt_model(dev) + + try: + with torch.no_grad(): + if dev.type == "cuda": + capability = torch.cuda.get_device_capability(dev) + amp_dtype = torch.bfloat16 if capability[0] >= 8 else torch.float16 + with torch.autocast(device_type="cuda", dtype=amp_dtype): + aggregated_tokens_list, ps_idx = model.aggregator(images) + else: + aggregated_tokens_list, ps_idx = model.aggregator(images) + # Camera + depth heads run in full precision (per the official VGGT example). + pose_enc = model.camera_head(aggregated_tokens_list)[-1] + extrinsic, intrinsic = pose_encoding_to_extri_intri(pose_enc, images.shape[-2:]) + depth_map, depth_conf = model.depth_head(aggregated_tokens_list, images, ps_idx) + except torch.cuda.OutOfMemoryError as exc: + raise RuntimeError( + f"VGGT ran out of GPU memory on {S} frames at {Wp}x{Hp}. " + "Lower max_frames and/or resolution, or set device='cpu' (slow)." + ) from exc + + # ---- Trajectory: pad OpenCV world-to-camera [S,3,4] to [S,4,4] ---- # + extrinsic = extrinsic.squeeze(0).to(torch.float32).cpu() # [S,3,4] + trajectory = torch.eye(4, dtype=torch.float32).unsqueeze(0).repeat(extrinsic.shape[0], 1, 1) + trajectory[:, :3, :4] = extrinsic + + # ---- Horizontal FOV from intrinsics (resolution-invariant fx/W ratio) ---- # + intrinsic = intrinsic.squeeze(0).to(torch.float32).cpu() # [S,3,3] + fx = intrinsic[:, 0, 0].clamp(min=1e-6) + hfov_per_frame = 2.0 * torch.atan(0.5 * float(Wp) / fx) # radians, at processing width + # Aspect ratio is preserved during preprocessing, so fx/W is the same at + # the original width and the FOV needs no conversion. + horizontal_fov = float(torch.rad2deg(hfov_per_frame).mean()) + + # ---- Depth + confidence, resized back to the input resolution ---- # + depth = depth_map.squeeze(0).to(torch.float32).cpu() # [S,Hp,Wp,1] (or [S,Hp,Wp]) + if depth.dim() == 4 and depth.shape[-1] == 1: + depth = depth.squeeze(-1) + conf = depth_conf.squeeze(0).to(torch.float32).cpu() # [S,Hp,Wp] + if conf.dim() == 4 and conf.shape[-1] == 1: + conf = conf.squeeze(-1) + + # ---- Convert VGGT z-depth to RADIAL ray depth ---- # + # VGGT's depth head predicts z-depth (its unprojection is + # x = (u - cx) * d / fx, z = d), while every consumer in this repo + # (pointcloud *_depth_to_XYZ helpers, MotionMaskFromDepth, + # TracksToTrajectories, the GS4D helpers) multiplies unit ray directions + # by depth, i.e. expects RADIAL distance. Multiply by the per-pixel ray + # norm sqrt(1 + ((u-cx)/fx)^2 + ((v-cy)/fy)^2) using the per-frame + # intrinsics at the VGGT processing resolution. + fx_pf = intrinsic[:, 0, 0].clamp(min=1e-6).view(-1, 1, 1) # [S,1,1] + fy_pf = intrinsic[:, 1, 1].clamp(min=1e-6).view(-1, 1, 1) + cx_pf = intrinsic[:, 0, 2].view(-1, 1, 1) + cy_pf = intrinsic[:, 1, 2].view(-1, 1, 1) + uu = torch.arange(Wp, dtype=torch.float32).view(1, 1, -1) + vv = torch.arange(Hp, dtype=torch.float32).view(1, -1, 1) + xn = (uu - cx_pf) / fx_pf + yn = (vv - cy_pf) / fy_pf + depth = depth * torch.sqrt(1.0 + xn * xn + yn * yn) + + if (Hp, Wp) != (H, W): + depth = F.interpolate(depth.unsqueeze(1), size=(H, W), mode="bilinear", align_corners=False).squeeze(1) + conf = F.interpolate(conf.unsqueeze(1), size=(H, W), mode="bilinear", align_corners=False).squeeze(1) + + # ---- If subsampled, expand back to the full frame count ---- # + if sub_indices is not None: + # Subsample indices are (near-)uniform over [0, T_full-1], so uniform + # SE(3) resampling reconstructs per-frame poses well. + trajectory = interpolate_se3(trajectory, T_full) + all_t = torch.arange(T_full).unsqueeze(1) # [T_full,1] + nearest = (sub_indices.unsqueeze(0) - all_t).abs().argmin(dim=1) # [T_full] + depth = depth[nearest] + conf = conf[nearest] + + return (trajectory, depth, horizontal_fov, conf) + + +class TrajectoryInvert: + """ + Inverts each 4x4 matrix in a trajectory tensor, converting between + world-to-camera and camera-to-world conventions. + """ + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + # Trajectory: Tensor [K, 4, 4] (a single [4, 4] matrix also works) + "trajectory": ("TENSOR", {"shape_hint": [None, 4, 4]}), + } + } + + RETURN_TYPES = ("TENSOR",) + RETURN_NAMES = ("trajectory",) + FUNCTION = "invert" + CATEGORY = "Camera/Pose" + DESCRIPTION = "Inverts each 4x4 pose (world-to-camera <-> camera-to-world)." + + def invert(self, trajectory: torch.Tensor) -> Tuple[torch.Tensor]: + traj = torch.as_tensor(trajectory, dtype=torch.float32) + squeeze = traj.dim() == 2 + if squeeze: + traj = traj.unsqueeze(0) + if traj.dim() != 3 or traj.shape[-2:] != (4, 4): + raise ValueError(f"Expected trajectory of shape [K,4,4], got {tuple(trajectory.shape)}") + # Rigid-body inverse: R -> R.T, t -> -R.T @ t (numerically stabler than + # a generic matrix inverse for SE(3) poses). + R = traj[:, :3, :3] + t = traj[:, :3, 3:4] + Rt = R.transpose(1, 2) + inv = torch.eye(4, dtype=traj.dtype).unsqueeze(0).repeat(traj.shape[0], 1, 1) + inv[:, :3, :3] = Rt + inv[:, :3, 3:4] = -Rt @ t + if squeeze: + inv = inv.squeeze(0) + return (inv,) + + +class TrajectoryCompose: + """ + Composes two trajectories per frame: out_k = A_k @ B_k. Either input may be + a single [4,4] matrix, which is broadcast against the other. Useful for + retargeting novel camera paths relative to a source pose (e.g. compose a + relative path with the inverse of source pose 0). + """ + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + # Left operand: Tensor [K, 4, 4] or [4, 4] + "trajectory_a": ("TENSOR", {"shape_hint": [None, 4, 4]}), + # Right operand: Tensor [K, 4, 4] or [4, 4] + "trajectory_b": ("TENSOR", {"shape_hint": [None, 4, 4]}), + } + } + + RETURN_TYPES = ("TENSOR",) + RETURN_NAMES = ("trajectory",) + FUNCTION = "compose" + CATEGORY = "Camera/Pose" + DESCRIPTION = "Per-frame matrix product A @ B; a single 4x4 input broadcasts over the other." + + def compose(self, trajectory_a: torch.Tensor, trajectory_b: torch.Tensor) -> Tuple[torch.Tensor]: + A = torch.as_tensor(trajectory_a, dtype=torch.float32) + B = torch.as_tensor(trajectory_b, dtype=torch.float32) + both_single = A.dim() == 2 and B.dim() == 2 + if A.dim() == 2: + A = A.unsqueeze(0) + if B.dim() == 2: + B = B.unsqueeze(0) + if A.dim() != 3 or A.shape[-2:] != (4, 4): + raise ValueError(f"Expected trajectory_a of shape [K,4,4] or [4,4], got {tuple(trajectory_a.shape)}") + if B.dim() != 3 or B.shape[-2:] != (4, 4): + raise ValueError(f"Expected trajectory_b of shape [K,4,4] or [4,4], got {tuple(trajectory_b.shape)}") + if A.shape[0] != B.shape[0] and A.shape[0] != 1 and B.shape[0] != 1: + raise ValueError( + f"Trajectory lengths do not broadcast: {A.shape[0]} vs {B.shape[0]} " + "(they must match, or one must be a single 4x4 matrix)." + ) + out = torch.matmul(A, B) # broadcasts [1,4,4] against [K,4,4] + if both_single: + out = out.squeeze(0) + return (out,) + + +NODE_CLASS_MAPPINGS = { + "VideoPoseEstimator": VideoPoseEstimator, + "TrajectoryInvert": TrajectoryInvert, + "TrajectoryCompose": TrajectoryCompose, +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..88daa5a --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,23 @@ +[project] +name = "camera-comfyui" +description = "Custom ComfyUI nodes for camera projections (pinhole/fisheye/equirectangular), depth, point clouds, camera trajectories, and 3D/4D Gaussian splatting — including video-to-4D-world workflows." +version = "1.0.0" +license = { file = "LICENSE" } +dependencies = [ + "transformers==4.50.0", + "diffusers==0.33.1", + "open3d==0.19.0", + "protobuf", +] + +[project.urls] +Repository = "https://github.com/Alexankharin/camera-comfyUI" + +[tool.comfy] +PublisherId = "alexk" +DisplayName = "camera-comfyUI" +# Force-include the SHARP submodule: its files are a gitlink in the parent repo +# (not git-tracked files), so without this the registry archive would ship +# without submodules/ml-sharpt and ImageToSplat/VideoToFusedSplats would be +# unavailable until users clone it manually. +includes = ["submodules/ml-sharpt/"] diff --git a/submodules/ml-sharpt b/submodules/ml-sharpt new file mode 160000 index 0000000..1eaa046 --- /dev/null +++ b/submodules/ml-sharpt @@ -0,0 +1 @@ +Subproject commit 1eaa046834b81852261262b41b0919f5c1efdd2e diff --git a/video_nodes.py b/video_nodes.py index 49e3ace..31afe2c 100644 --- a/video_nodes.py +++ b/video_nodes.py @@ -7,7 +7,7 @@ from typing import Dict, Any, Tuple from tqdm import tqdm # Added tqdm import # Import existing pointcloud nodes and projection definitions -from .pointcloud_nodes import DepthToPointCloud, TransformPointCloud, ProjectPointCloud, Projection, PointCloudCleaner +from .pointcloud_nodes import DepthToPointCloud, TransformPointCloud, ProjectPointCloud, Projection, PointCloudCleaner, interpolate_se3 import folder_paths # Ensure video_depth_anything is on path @@ -95,18 +95,8 @@ class VideoCameraMotionSequence: # depth_seq: [T, H, W] or [T, H, W, 1] T, H, W, _ = frames.shape - # Interpolate trajectory to match T - K = trajectory.shape[0] - if K < 2: - interp_traj = trajectory.expand(T, 4, 4).clone() - else: - idxs = torch.linspace(0, K - 1, T, device=trajectory.device) - lower = idxs.floor().long().clamp(max=K - 2) - upper = lower + 1 - alpha = (idxs - lower.float()).unsqueeze(-1).unsqueeze(-1) - traj_lower = trajectory[lower] - traj_upper = trajectory[upper] - interp_traj = traj_lower * (1 - alpha) + traj_upper * alpha + # Interpolate trajectory to match T (SE(3): quaternion SLERP on R, lerp on t) + interp_traj = interpolate_se3(trajectory, T) out_frames = [] out_masks = [] @@ -122,12 +112,12 @@ class VideoCameraMotionSequence: for i, (frame, depth, pose) in enumerate(tqdm(zip(frames, depth_seq, interp_traj), total=T, desc="Processing video frames")): if depth.dim() == 3 and depth.shape[-1] == 1: depth = depth.squeeze(-1) - # Use mask if provided - mask = None + # Use mask if provided; must be (re)initialized every iteration + mask = None if mask_seq is not None: mask = mask_seq[i] - if mask.dim() == 3 and mask.shape[-1] == 1: - mask = mask.squeeze(-1) + if mask.dim() == 3 and mask.shape[-1] == 1: + mask = mask.squeeze(-1) # to pointcloud pc, = DepthToPointCloud().depth_to_pointcloud( image=frame.permute(2, 0, 1), @@ -237,6 +227,10 @@ class DepthFramesToVideo: raw_color = raw_u8.unsqueeze(1).repeat(1, 3, 1, 1).permute(0, 2, 3, 1) return raw_color, ds_color # [T, 3, H, W] -> [T, H, W, 3] +# Cache for loaded VideoDepthAnything models, keyed by (checkpoint, device) +_VIDEO_DEPTH_MODEL_CACHE: Dict[Tuple[str, str], Any] = {} + + class VideoMetricDepthEstimate: """ Estimates metric depth for a sequence of frames using VideoDepthAnything. @@ -267,16 +261,29 @@ class VideoMetricDepthEstimate: input_size: int, max_fps: int, ) -> Tuple[torch.Tensor, float]: - if VideoDepthAnything is None: - raise ImportError("VideoDepthAnything library not found") + if NO_VIDEO_DEPTH_ANYTHING: + raise ImportError( + f"VideoDepthAnything library not found. Clone " + f"https://github.com/DepthAnything/Video-Depth-Anything into {COMFYUI_ROOT!r} " + f"(expected module path: {video_depth_path!r})." + ) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # if max input<1.5 normalize to 0-255 if frames.max() < 1.5: frames = (frames * 255) - model = VideoDepthAnything(**{"encoder": "vitl", "features": 256, "out_channels": [256,512,1024,1024]}) - state = torch.load("/root/ComfyUI/models/checkpoints/{}".format(model_checkpoint), map_location='cpu') - model.load_state_dict(state, strict=True) - model = model.to(device).eval() + cache_key = (model_checkpoint, str(device)) + model = _VIDEO_DEPTH_MODEL_CACHE.get(cache_key) + if model is None: + # Same checkpoint directory as computed in INPUT_TYPES + model_dir = os.path.join(os.getcwd(), "models", "checkpoints") + checkpoint_path = os.path.join(model_dir, model_checkpoint) + if not os.path.isfile(checkpoint_path): + raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}") + model = VideoDepthAnything(**{"encoder": "vitl", "features": 256, "out_channels": [256,512,1024,1024]}) + state = torch.load(checkpoint_path, map_location='cpu') + model.load_state_dict(state, strict=True) + model = model.to(device).eval() + _VIDEO_DEPTH_MODEL_CACHE[cache_key] = model np_frames = frames.cpu().numpy().astype(np.uint8) metric_depths, fps = model.infer_video_depth(np_frames, max_fps, input_size=input_size, device=device.type, fp32=False) return (torch.from_numpy(metric_depths), float(fps)) diff --git a/workflows/video_to_4d_walkable_world.json b/workflows/video_to_4d_walkable_world.json new file mode 100644 index 0000000..8d8003a --- /dev/null +++ b/workflows/video_to_4d_walkable_world.json @@ -0,0 +1,1611 @@ +{ + "id": "c8b4d2ef-5e31-4a5b-8d2f-walkable4dw01", + "revision": 0, + "last_node_id": 22, + "last_link_id": 41, + "nodes": [ + { + "id": 19, + "type": "Note", + "pos": [ + -1650, + -440 + ], + "size": [ + 620, + 520 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [], + "title": "TEST RUN", + "properties": {}, + "widgets_values": [ + "TEST RUN: video -> 4D Gaussian WALKABLE world (first GPU test)\n\nTest-friendly defaults (raise once the pipeline is proven):\n- Render output 512x288, 49 frames (RenderSplats4DVideo).\n- SplatPolish iterations = 200 (use 1000+ for quality).\n- VideoToFusedSplats keyframe_stride = 12 (use 6-8 for denser fusion).\n- Walk trajectory: 8 waypoints, ~1.5 m forward + 1 m sideways.\n- SplatTrajectoryEnricher: max_views 8 at 512x288, 28 Flux steps.\n\nDownloads on FIRST use (needs internet once):\n- VGGT weights: facebook/VGGT-1B (~5GB) via HuggingFace (VideoPoseEstimator).\n- CoTracker3: via torch.hub (EstimateTracks).\n- SHARP checkpoint: default .pt auto-downloads (ImageToSplat / VideoToFusedSplats / SplatTrajectoryEnricher), or drop a .pt into ComfyUI/input and pick it in the checkpoint choosers.\n- Flux fill weights (multi-GB): SplatTrajectoryEnricher outpaints through OutpaintAnyProjection, which needs the ComfyUI-Flux-Inpainting package installed as custom_nodes/inpainting_flux (see README install step 4) plus its Flux models.\n\nCUDA required:\n- SplatPolish errors without gsplat + CUDA (pip install gsplat) unless allow_torch_fallback is enabled (extremely slow).\n- gsplat is also the fast render path for enrichment and the final video.\n\nExternals: VHS_LoadVideoPath is from ComfyUI-VideoHelperSuite; SaveWEBM / InvertMask / ImageFromBatch are comfy-core." + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 1, + "type": "VHS_LoadVideoPath", + "pos": [ + -1600, + 250 + ], + "size": [ + 240, + 380 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "shape": 7, + "type": "VHS_BatchManager", + "link": null + }, + { + "name": "vae", + "shape": 7, + "type": "VAE", + "link": null + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 1, + 2, + 3, + 4, + 5 + ] + }, + { + "name": "frame_count", + "type": "INT", + "links": null + }, + { + "name": "audio", + "type": "AUDIO", + "links": null + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null + } + ], + "title": "Load Video (<= 64 frames)", + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "aux_id": "Kosinkadink/ComfyUI-VideoHelperSuite", + "Node name for S&R": "VHS_LoadVideoPath" + }, + "widgets_values": { + "video": "input/video.mp4", + "force_rate": 0, + "custom_width": 0, + "custom_height": 0, + "frame_load_cap": 49, + "skip_first_frames": 0, + "select_every_nth": 1, + "format": "AnimateDiff", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "input/video.mp4", + "type": "path", + "format": "video/mp4", + "force_rate": 0, + "custom_width": 0, + "custom_height": 0, + "frame_load_cap": 49, + "skip_first_frames": 0, + "select_every_nth": 1 + } + } + } + }, + { + "id": 2, + "type": "VideoPoseEstimator", + "pos": [ + -1280, + 250 + ], + "size": [ + 300, + 170 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 1 + } + ], + "outputs": [ + { + "name": "trajectory", + "type": "TENSOR", + "links": [ + 6, + 7, + 8, + 9 + ] + }, + { + "name": "depths", + "type": "TENSOR", + "links": [ + 10, + 11, + 12 + ] + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "links": [ + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 39 + ] + }, + { + "name": "confidence", + "type": "TENSOR", + "links": null + } + ], + "title": "VGGT: poses + radial depth + fov", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "VideoPoseEstimator" + }, + "widgets_values": [ + 64, + 518, + "auto" + ] + }, + { + "id": 3, + "type": "MotionMaskFromDepth", + "pos": [ + -880, + 250 + ], + "size": [ + 330, + 230 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "depth_seq", + "type": "TENSOR", + "link": 10 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 6 + }, + { + "name": "input_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "input_horizontal_fov" + }, + "link": 13 + } + ], + "outputs": [ + { + "name": "motion_mask", + "type": "MASK", + "links": [ + 20, + 21 + ] + } + ], + "title": "Dynamic-pixel mask (1 = moving)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "MotionMaskFromDepth" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.1, + 4, + 2, + "auto" + ] + }, + { + "id": 4, + "type": "InvertMask", + "pos": [ + -480, + 290 + ], + "size": [ + 180, + 30 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "mask", + "type": "MASK", + "link": 20 + } + ], + "outputs": [ + { + "name": "MASK", + "type": "MASK", + "links": [ + 22 + ] + } + ], + "title": "Static mask (1 = static)", + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "InvertMask" + }, + "widgets_values": [] + }, + { + "id": 5, + "type": "VideoToFusedSplats", + "pos": [ + -180, + 250 + ], + "size": [ + 340, + 280 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 2 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 7 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 14 + }, + { + "name": "static_mask", + "shape": 7, + "type": "MASK", + "link": 22 + }, + { + "name": "depths", + "shape": 7, + "type": "TENSOR", + "link": 11 + } + ], + "outputs": [ + { + "name": "splats", + "type": "GSPLAT", + "links": [ + 23 + ] + } + ], + "title": "SHARP keyframes -> fused static world (stride 12 = fast test)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "VideoToFusedSplats" + }, + "widgets_values": [ + 60.0, + "", + 12, + 0.01, + "smart", + "auto" + ] + }, + { + "id": 6, + "type": "SplatPolish", + "pos": [ + 240, + 250 + ], + "size": [ + 340, + 340 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 23 + }, + { + "name": "frames", + "type": "IMAGE", + "link": 3 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 8 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 15 + } + ], + "outputs": [ + { + "name": "polished_splats", + "type": "GSPLAT", + "links": [ + 24 + ] + } + ], + "title": "SplatPolish 200 it (needs gsplat + CUDA)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplatPolish" + }, + "widgets_values": [ + 60.0, + 200, + 0.00016, + 0.0025, + 0.8, + 0.2, + 0.01, + false, + "auto" + ] + }, + { + "id": 7, + "type": "EstimateTracks", + "pos": [ + -880, + 800 + ], + "size": [ + 300, + 130 + ], + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 4 + } + ], + "outputs": [ + { + "name": "tracks", + "type": "TENSOR", + "links": [ + 25 + ] + }, + { + "name": "visibility", + "type": "TENSOR", + "links": [ + 26 + ] + } + ], + "title": "CoTracker3 (downloads on first use)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "EstimateTracks" + }, + "widgets_values": [ + 20, + "auto" + ] + }, + { + "id": 8, + "type": "TracksToTrajectories", + "pos": [ + -500, + 800 + ], + "size": [ + 330, + 210 + ], + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "tracks", + "type": "TENSOR", + "link": 25 + }, + { + "name": "visibility", + "type": "TENSOR", + "link": 26 + }, + { + "name": "depth_seq", + "type": "TENSOR", + "link": 12 + }, + { + "name": "input_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "input_horizontal_fov" + }, + "link": 16 + }, + { + "name": "trajectory", + "shape": 7, + "type": "TENSOR", + "link": 9 + } + ], + "outputs": [ + { + "name": "trajectories3d", + "type": "TENSOR", + "links": [ + 27 + ] + }, + { + "name": "track_valid", + "type": "TENSOR", + "links": [ + 28 + ] + } + ], + "title": "Lift tracks to 3D world trajectories", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TracksToTrajectories" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.5, + "auto" + ] + }, + { + "id": 9, + "type": "ImageFromBatch", + "pos": [ + -880, + 1120 + ], + "size": [ + 300, + 100 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 5 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 29 + ] + } + ], + "title": "Frame 0 (canonical view)", + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "ImageFromBatch" + }, + "widgets_values": [ + 0, + 1 + ] + }, + { + "id": 10, + "type": "ImageToSplat", + "pos": [ + -500, + 1120 + ], + "size": [ + 300, + 150 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 29 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 17 + } + ], + "outputs": [ + { + "name": "splats", + "type": "GSPLAT", + "links": [ + 30 + ] + } + ], + "title": "SHARP frame 0 (world = frame-0 cam)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "ImageToSplat" + }, + "widgets_values": [ + 60.0, + "", + "auto" + ] + }, + { + "id": 11, + "type": "SplitSplatsByMask", + "pos": [ + -120, + 1080 + ], + "size": [ + 320, + 210 + ], + "flags": {}, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 30 + }, + { + "name": "mask", + "type": "MASK", + "link": 21 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 18 + }, + { + "name": "camera_matrix", + "shape": 7, + "type": "MAT_4X4", + "link": null + } + ], + "outputs": [ + { + "name": "inside_splats", + "type": "GSPLAT", + "links": [ + 31 + ] + }, + { + "name": "outside_splats", + "type": "GSPLAT", + "links": null + } + ], + "title": "Keep dynamic splats (frame-0 mask)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplitSplatsByMask" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.5, + "auto" + ] + }, + { + "id": 12, + "type": "BuildSplats4D", + "pos": [ + 280, + 850 + ], + "size": [ + 310, + 250 + ], + "flags": {}, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "canonical", + "type": "GSPLAT", + "link": 31 + }, + { + "name": "trajectories3d", + "type": "TENSOR", + "link": 27 + }, + { + "name": "static", + "shape": 7, + "type": "GSPLAT", + "link": 40 + }, + { + "name": "times", + "shape": 7, + "type": "TENSOR", + "link": null + }, + { + "name": "track_valid", + "shape": 7, + "type": "TENSOR", + "link": 28 + } + ], + "outputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "links": [ + 32, + 33 + ] + } + ], + "title": "Bind tracks + ENRICHED static -> GSPLAT4D", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "BuildSplats4D" + }, + "widgets_values": [ + 0, + 4, + 0.0, + "auto" + ] + }, + { + "id": 13, + "type": "TransformToMatrixManual", + "pos": [ + -200, + 1480 + ], + "size": [ + 270, + 420 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "transformation matrix", + "type": "MAT_4X4", + "links": [ + 34 + ] + } + ], + "title": "Walk start: frame-0 camera (identity)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TransformToMatrixManual" + }, + "widgets_values": [ + 1.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "id": 14, + "type": "TransformToMatrixManual", + "pos": [ + 110, + 1480 + ], + "size": [ + 270, + 420 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "transformation matrix", + "type": "MAT_4X4", + "links": [ + 35 + ] + } + ], + "title": "Walk end: 1.5m forward + 1m right (w2c, t = -position)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TransformToMatrixManual" + }, + "widgets_values": [ + 1.0, + 0.0, + 0.0, + -1.0, + 0.0, + 1.0, + 0.0, + 0.0, + 0.0, + 0.0, + 1.0, + -1.5, + 0.0, + 0.0, + 0.0, + 1.0 + ] + }, + { + "id": 15, + "type": "CameraInterpolationNode", + "pos": [ + 440, + 1560 + ], + "size": [ + 250, + 100 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "initial_matrix", + "type": "MAT_4X4", + "link": 34 + }, + { + "name": "final_matrix", + "type": "MAT_4X4", + "link": 35 + } + ], + "outputs": [ + { + "name": "trajectory", + "type": "TENSOR", + "links": [ + 36, + 38 + ] + } + ], + "title": "Walk trajectory (8 waypoints)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "CameraInterpolationNode" + }, + "widgets_values": [ + 8 + ] + }, + { + "id": 20, + "type": "SplatTrajectoryEnricher", + "pos": [ + 740, + 1480 + ], + "size": [ + 360, + 520 + ], + "flags": {}, + "order": 16, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 24 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 38 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 39 + } + ], + "outputs": [ + { + "name": "enriched_splats", + "type": "GSPLAT", + "links": [ + 40, + 41 + ] + }, + { + "name": "last_render", + "type": "IMAGE", + "links": null + }, + { + "name": "last_filled", + "type": "IMAGE", + "links": null + } + ], + "title": "Enrich world along walk (Flux outpaint + SHARP)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplatTrajectoryEnricher" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 512, + 288, + "", + "consistent scene continuation, photorealistic", + 28, + 5.0, + 5, + 0.02, + 0.01, + 8, + "auto", + true, + "PINHOLE", + 90.0, + 1024, + 0.0, + 0.0 + ] + }, + { + "id": 16, + "type": "RenderSplats4DVideo", + "pos": [ + 700, + 850 + ], + "size": [ + 330, + 320 + ], + "flags": {}, + "order": 18, + "mode": 0, + "inputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "link": 32 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 36 + }, + { + "name": "camera_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "camera_horizontal_fov" + }, + "link": 19 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 37 + ] + }, + { + "name": "masks", + "type": "MASK", + "links": null + }, + { + "name": "disparity", + "type": "TENSOR", + "links": null + } + ], + "title": "Render 4D along the SAME walk (time 0..1)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "RenderSplats4DVideo" + }, + "widgets_values": [ + 49, + 0.0, + 1.0, + "PINHOLE", + 60.0, + 512, + 288, + "auto", + 0, + "auto" + ] + }, + { + "id": 17, + "type": "SaveWEBM", + "pos": [ + 1100, + 850 + ], + "size": [ + 280, + 320 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 37 + } + ], + "outputs": [], + "title": "Save walk-through video", + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "SaveWEBM" + }, + "widgets_values": [ + "4d_walkable_world", + "vp9", + 24, + 32 + ] + }, + { + "id": 18, + "type": "SaveSplats4D", + "pos": [ + 1100, + 620 + ], + "size": [ + 280, + 110 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "link": 33 + } + ], + "outputs": [], + "title": "Export full 4D world (.npz)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SaveSplats4D" + }, + "widgets_values": [ + "ComfyUISplat4D_walkable", + false + ] + }, + { + "id": 22, + "type": "SavePlySplat", + "pos": [ + 1180, + 1480 + ], + "size": [ + 300, + 110 + ], + "flags": {}, + "order": 21, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 41 + } + ], + "outputs": [], + "title": "Export ENRICHED static world (.ply)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SavePlySplat" + }, + "widgets_values": [ + "walkable_world_static" + ] + }, + { + "id": 21, + "type": "Note", + "pos": [ + 1180, + 1660 + ], + "size": [ + 380, + 340 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [], + "outputs": [], + "title": "Walkable exports + enricher notes", + "properties": {}, + "widgets_values": [ + "WALKABLE WORLD\n\nSplatTrajectoryEnricher walks the polished static world along the SAME trajectory the final render uses (8 SE(3) waypoints from identity to 1.5 m forward + 1 m right; matrices are world-to-camera, so the end pose stores t = -camera_position). At each waypoint it renders the splats, Flux-outpaints disoccluded holes, lifts the filled view with SHARP, scale-aligns and smart-stitches the new content, so the walk path is watertight.\n\nIt REQUIRES the Flux inpainting models: install ComfyUI-Flux-Inpainting and rename the folder to custom_nodes/inpainting_flux (README install step 4). The node lazily imports OutpaintAnyProjection from flux_fisheye_filling_nodes and fails with an actionable error if that package is missing.\n\nExports for free walking outside ComfyUI:\n- SavePlySplat: the ENRICHED static world as a standard 3DGS .ply -> open in SuperSplat / any 3DGS viewer and walk freely (dynamic content excluded).\n- SaveSplats4D: the full 4D scene (enriched static + tracked dynamic splats) as .npz -> reload later with LoadSplats4D and re-render along any trajectory.\n- SaveWEBM: the scripted walk-through of the MOVING scene (camera walks while time sweeps 0..1)." + ], + "color": "#432", + "bgcolor": "#653" + } + ], + "links": [ + [ + 1, + 1, + 0, + 2, + 0, + "IMAGE" + ], + [ + 2, + 1, + 0, + 5, + 0, + "IMAGE" + ], + [ + 3, + 1, + 0, + 6, + 1, + "IMAGE" + ], + [ + 4, + 1, + 0, + 7, + 0, + "IMAGE" + ], + [ + 5, + 1, + 0, + 9, + 0, + "IMAGE" + ], + [ + 6, + 2, + 0, + 3, + 1, + "TENSOR" + ], + [ + 7, + 2, + 0, + 5, + 1, + "TENSOR" + ], + [ + 8, + 2, + 0, + 6, + 2, + "TENSOR" + ], + [ + 9, + 2, + 0, + 8, + 4, + "TENSOR" + ], + [ + 10, + 2, + 1, + 3, + 0, + "TENSOR" + ], + [ + 11, + 2, + 1, + 5, + 4, + "TENSOR" + ], + [ + 12, + 2, + 1, + 8, + 2, + "TENSOR" + ], + [ + 13, + 2, + 2, + 3, + 2, + "FLOAT" + ], + [ + 14, + 2, + 2, + 5, + 2, + "FLOAT" + ], + [ + 15, + 2, + 2, + 6, + 3, + "FLOAT" + ], + [ + 16, + 2, + 2, + 8, + 3, + "FLOAT" + ], + [ + 17, + 2, + 2, + 10, + 1, + "FLOAT" + ], + [ + 18, + 2, + 2, + 11, + 2, + "FLOAT" + ], + [ + 19, + 2, + 2, + 16, + 2, + "FLOAT" + ], + [ + 20, + 3, + 0, + 4, + 0, + "MASK" + ], + [ + 21, + 3, + 0, + 11, + 1, + "MASK" + ], + [ + 22, + 4, + 0, + 5, + 3, + "MASK" + ], + [ + 23, + 5, + 0, + 6, + 0, + "GSPLAT" + ], + [ + 24, + 6, + 0, + 20, + 0, + "GSPLAT" + ], + [ + 25, + 7, + 0, + 8, + 0, + "TENSOR" + ], + [ + 26, + 7, + 1, + 8, + 1, + "TENSOR" + ], + [ + 27, + 8, + 0, + 12, + 1, + "TENSOR" + ], + [ + 28, + 8, + 1, + 12, + 4, + "TENSOR" + ], + [ + 29, + 9, + 0, + 10, + 0, + "IMAGE" + ], + [ + 30, + 10, + 0, + 11, + 0, + "GSPLAT" + ], + [ + 31, + 11, + 0, + 12, + 0, + "GSPLAT" + ], + [ + 32, + 12, + 0, + 16, + 0, + "GSPLAT4D" + ], + [ + 33, + 12, + 0, + 18, + 0, + "GSPLAT4D" + ], + [ + 34, + 13, + 0, + 15, + 0, + "MAT_4X4" + ], + [ + 35, + 14, + 0, + 15, + 1, + "MAT_4X4" + ], + [ + 36, + 15, + 0, + 16, + 1, + "TENSOR" + ], + [ + 37, + 16, + 0, + 17, + 0, + "IMAGE" + ], + [ + 38, + 15, + 0, + 20, + 1, + "TENSOR" + ], + [ + 39, + 2, + 2, + 20, + 2, + "FLOAT" + ], + [ + 40, + 20, + 0, + 12, + 2, + "GSPLAT" + ], + [ + 41, + 20, + 0, + 22, + 0, + "GSPLAT" + ] + ], + "groups": [ + { + "id": 1, + "title": "1. Load & Pose (VGGT)", + "bounding": [ + -1650, + 150, + 720, + 560 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 2, + "title": "2. Motion Masks", + "bounding": [ + -910, + 150, + 640, + 420 + ], + "color": "#a1309b", + "font_size": 24, + "flags": {} + }, + { + "id": 3, + "title": "3. Static World Splats", + "bounding": [ + -230, + 150, + 850, + 500 + ], + "color": "#8154a6", + "font_size": 24, + "flags": {} + }, + { + "id": 4, + "title": "4. Dynamic 4D Splats", + "bounding": [ + -910, + 720, + 1540, + 640 + ], + "color": "#b06634", + "font_size": 24, + "flags": {} + }, + { + "id": 5, + "title": "5. Walk Trajectory (2 poses -> 8 waypoints)", + "bounding": [ + -230, + 1400, + 950, + 620 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 6, + "title": "6. Walk Enrichment & Exports", + "bounding": [ + 720, + 1400, + 880, + 640 + ], + "color": "#88A", + "font_size": 24, + "flags": {} + }, + { + "id": 7, + "title": "7. Walk Render & Save", + "bounding": [ + 660, + 540, + 760, + 680 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + } + ], + "config": {}, + "extra": { + "ds": { + "scale": 0.4, + "offset": [ + 1700, + 450 + ] + }, + "frontendVersion": "1.23.4" + }, + "version": 0.4 +} diff --git a/workflows/video_to_4d_world.json b/workflows/video_to_4d_world.json new file mode 100644 index 0000000..d3c3b4e --- /dev/null +++ b/workflows/video_to_4d_world.json @@ -0,0 +1,1515 @@ +{ + "id": "b7a3c1de-4d20-4f4a-9c1e-video4dworld1", + "revision": 0, + "last_node_id": 21, + "last_link_id": 39, + "nodes": [ + { + "id": 19, + "type": "Note", + "pos": [ + -1650, + -380 + ], + "size": [ + 620, + 460 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [], + "outputs": [], + "title": "README: video -> 4D Gaussian world", + "properties": {}, + "widgets_values": [ + "VIDEO -> 4D GAUSSIAN WORLD\n\nRequirements:\n- gsplat + CUDA (pip install gsplat) for fast rendering and for SplatPolish (it errors without CUDA unless allow_torch_fallback is enabled).\n- VGGT: pip install vggt (or clone facebookresearch/vggt next to ComfyUI). facebook/VGGT-1B (~5GB) downloads on first run.\n- CoTracker3: downloaded automatically via torch.hub on first use of EstimateTracks (needs internet once).\n- SHARP: lives in this pack's submodules/ml-sharpt; the default checkpoint downloads on first use, or drop a .pt into ComfyUI/input and pick it in the checkpoint choosers.\n- VHS_LoadVideoPath comes from ComfyUI-VideoHelperSuite (install via Manager). SaveWEBM / InvertMask / ImageFromBatch are comfy-core.\n\nHow it fits together:\n- VGGT poses are relative to frame 0, so the WORLD frame == the frame-0 camera frame. That is why the frame-0 SHARP splats (ImageToSplat) need no extra transform and SplitSplatsByMask can use its default identity camera.\n- VideoPoseEstimator already outputs RADIAL (ray) depth, which is what every depth consumer here expects - no Z-depth conversion node is needed.\n- The horizontal_fov FLOAT output feeds every fov input downstream (converted widget inputs).\n- SplitSplatsByMask receives the full [T,H,W] motion mask and uses frame 0 of it (its canonical view).\n- The novel camera path (TransformToMatrix pair) is expressed in the same world frame; identity = the original frame-0 camera." + ], + "color": "#432", + "bgcolor": "#653" + }, + { + "id": 1, + "type": "VHS_LoadVideoPath", + "pos": [ + -1600, + 250 + ], + "size": [ + 240, + 380 + ], + "flags": {}, + "order": 1, + "mode": 0, + "inputs": [ + { + "name": "meta_batch", + "shape": 7, + "type": "VHS_BatchManager", + "link": null + }, + { + "name": "vae", + "shape": 7, + "type": "VAE", + "link": null + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 1, + 2, + 3, + 4, + 5 + ] + }, + { + "name": "frame_count", + "type": "INT", + "links": null + }, + { + "name": "audio", + "type": "AUDIO", + "links": null + }, + { + "name": "video_info", + "type": "VHS_VIDEOINFO", + "links": null + } + ], + "title": "Load Video (<= 64 frames)", + "properties": { + "cnr_id": "comfyui-videohelpersuite", + "aux_id": "Kosinkadink/ComfyUI-VideoHelperSuite", + "Node name for S&R": "VHS_LoadVideoPath" + }, + "widgets_values": { + "video": "input/video.mp4", + "force_rate": 0, + "custom_width": 0, + "custom_height": 0, + "frame_load_cap": 49, + "skip_first_frames": 0, + "select_every_nth": 1, + "format": "AnimateDiff", + "videopreview": { + "hidden": false, + "paused": false, + "params": { + "filename": "input/video.mp4", + "type": "path", + "format": "video/mp4", + "force_rate": 0, + "custom_width": 0, + "custom_height": 0, + "frame_load_cap": 49, + "skip_first_frames": 0, + "select_every_nth": 1 + } + } + } + }, + { + "id": 2, + "type": "VideoPoseEstimator", + "pos": [ + -1280, + 250 + ], + "size": [ + 300, + 170 + ], + "flags": {}, + "order": 5, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 1 + } + ], + "outputs": [ + { + "name": "trajectory", + "type": "TENSOR", + "links": [ + 6, + 7, + 8, + 9 + ] + }, + { + "name": "depths", + "type": "TENSOR", + "links": [ + 10, + 11, + 12 + ] + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "links": [ + 13, + 14, + 15, + 16, + 17, + 18, + 19 + ] + }, + { + "name": "confidence", + "type": "TENSOR", + "links": null + } + ], + "title": "VGGT: poses + radial depth + fov", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "VideoPoseEstimator" + }, + "widgets_values": [ + 64, + 518, + "auto" + ] + }, + { + "id": 3, + "type": "MotionMaskFromDepth", + "pos": [ + -880, + 250 + ], + "size": [ + 330, + 230 + ], + "flags": {}, + "order": 7, + "mode": 0, + "inputs": [ + { + "name": "depth_seq", + "type": "TENSOR", + "link": 10 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 6 + }, + { + "name": "input_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "input_horizontal_fov" + }, + "link": 13 + } + ], + "outputs": [ + { + "name": "motion_mask", + "type": "MASK", + "links": [ + 20, + 21 + ] + } + ], + "title": "Dynamic-pixel mask (1 = moving)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "MotionMaskFromDepth" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.1, + 4, + 2, + "auto" + ] + }, + { + "id": 4, + "type": "InvertMask", + "pos": [ + -480, + 290 + ], + "size": [ + 180, + 30 + ], + "flags": {}, + "order": 10, + "mode": 0, + "inputs": [ + { + "name": "mask", + "type": "MASK", + "link": 20 + } + ], + "outputs": [ + { + "name": "MASK", + "type": "MASK", + "links": [ + 22 + ] + } + ], + "title": "Static mask (1 = static)", + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "InvertMask" + }, + "widgets_values": [] + }, + { + "id": 5, + "type": "VideoToFusedSplats", + "pos": [ + -180, + 250 + ], + "size": [ + 340, + 280 + ], + "flags": {}, + "order": 11, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 2 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 7 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 14 + }, + { + "name": "static_mask", + "shape": 7, + "type": "MASK", + "link": 22 + }, + { + "name": "depths", + "shape": 7, + "type": "TENSOR", + "link": 11 + } + ], + "outputs": [ + { + "name": "splats", + "type": "GSPLAT", + "links": [ + 23 + ] + } + ], + "title": "SHARP keyframes -> fused static world", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "VideoToFusedSplats" + }, + "widgets_values": [ + 60.0, + "", + 8, + 0.01, + "smart", + "auto" + ] + }, + { + "id": 6, + "type": "SplatPolish", + "pos": [ + 240, + 250 + ], + "size": [ + 340, + 340 + ], + "flags": {}, + "order": 14, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 23 + }, + { + "name": "frames", + "type": "IMAGE", + "link": 3 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 8 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 15 + } + ], + "outputs": [ + { + "name": "polished_splats", + "type": "GSPLAT", + "links": [ + 24, + 38 + ] + } + ], + "title": "SplatPolish (needs gsplat + CUDA)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplatPolish" + }, + "widgets_values": [ + 60.0, + 300, + 0.00016, + 0.0025, + 0.8, + 0.2, + 0.01, + false, + "auto" + ] + }, + { + "id": 7, + "type": "EstimateTracks", + "pos": [ + -880, + 800 + ], + "size": [ + 300, + 130 + ], + "flags": {}, + "order": 8, + "mode": 0, + "inputs": [ + { + "name": "frames", + "type": "IMAGE", + "link": 4 + } + ], + "outputs": [ + { + "name": "tracks", + "type": "TENSOR", + "links": [ + 25 + ] + }, + { + "name": "visibility", + "type": "TENSOR", + "links": [ + 26 + ] + } + ], + "title": "CoTracker3 (downloads on first use)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "EstimateTracks" + }, + "widgets_values": [ + 20, + "auto" + ] + }, + { + "id": 8, + "type": "TracksToTrajectories", + "pos": [ + -500, + 800 + ], + "size": [ + 330, + 210 + ], + "flags": {}, + "order": 13, + "mode": 0, + "inputs": [ + { + "name": "tracks", + "type": "TENSOR", + "link": 25 + }, + { + "name": "visibility", + "type": "TENSOR", + "link": 26 + }, + { + "name": "depth_seq", + "type": "TENSOR", + "link": 12 + }, + { + "name": "input_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "input_horizontal_fov" + }, + "link": 16 + }, + { + "name": "trajectory", + "shape": 7, + "type": "TENSOR", + "link": 9 + } + ], + "outputs": [ + { + "name": "trajectories3d", + "type": "TENSOR", + "links": [ + 27 + ] + }, + { + "name": "track_valid", + "type": "TENSOR", + "links": [ + 28 + ] + } + ], + "title": "Lift tracks to 3D world trajectories", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TracksToTrajectories" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.5, + "auto" + ] + }, + { + "id": 9, + "type": "ImageFromBatch", + "pos": [ + -880, + 1120 + ], + "size": [ + 300, + 100 + ], + "flags": {}, + "order": 9, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 5 + } + ], + "outputs": [ + { + "name": "IMAGE", + "type": "IMAGE", + "links": [ + 29 + ] + } + ], + "title": "Frame 0 (canonical view)", + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "ImageFromBatch" + }, + "widgets_values": [ + 0, + 1 + ] + }, + { + "id": 10, + "type": "ImageToSplat", + "pos": [ + -500, + 1120 + ], + "size": [ + 300, + 150 + ], + "flags": {}, + "order": 12, + "mode": 0, + "inputs": [ + { + "name": "image", + "type": "IMAGE", + "link": 29 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 17 + } + ], + "outputs": [ + { + "name": "splats", + "type": "GSPLAT", + "links": [ + 30 + ] + } + ], + "title": "SHARP frame 0 (world = frame-0 cam)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "ImageToSplat" + }, + "widgets_values": [ + 60.0, + "", + "auto" + ] + }, + { + "id": 11, + "type": "SplitSplatsByMask", + "pos": [ + -120, + 1080 + ], + "size": [ + 320, + 210 + ], + "flags": {}, + "order": 15, + "mode": 0, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 30 + }, + { + "name": "mask", + "type": "MASK", + "link": 21 + }, + { + "name": "horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "horizontal_fov" + }, + "link": 18 + }, + { + "name": "camera_matrix", + "shape": 7, + "type": "MAT_4X4", + "link": null + } + ], + "outputs": [ + { + "name": "inside_splats", + "type": "GSPLAT", + "links": [ + 31 + ] + }, + { + "name": "outside_splats", + "type": "GSPLAT", + "links": null + } + ], + "title": "Keep dynamic splats (frame-0 mask)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplitSplatsByMask" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 0.5, + "auto" + ] + }, + { + "id": 12, + "type": "BuildSplats4D", + "pos": [ + 280, + 850 + ], + "size": [ + 310, + 250 + ], + "flags": {}, + "order": 16, + "mode": 0, + "inputs": [ + { + "name": "canonical", + "type": "GSPLAT", + "link": 31 + }, + { + "name": "trajectories3d", + "type": "TENSOR", + "link": 27 + }, + { + "name": "static", + "shape": 7, + "type": "GSPLAT", + "link": 24 + }, + { + "name": "times", + "shape": 7, + "type": "TENSOR", + "link": null + }, + { + "name": "track_valid", + "shape": 7, + "type": "TENSOR", + "link": 28 + } + ], + "outputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "links": [ + 32, + 33 + ] + } + ], + "title": "Bind canonical to tracks -> GSPLAT4D", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "BuildSplats4D" + }, + "widgets_values": [ + 0, + 4, + 0.0, + "auto" + ] + }, + { + "id": 13, + "type": "TransformToMatrix", + "pos": [ + 700, + 1250 + ], + "size": [ + 270, + 154 + ], + "flags": {}, + "order": 2, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "transformation matrix", + "type": "MAT_4X4", + "links": [ + 34 + ] + } + ], + "title": "Novel path: start (frame-0 camera)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TransformToMatrix" + }, + "widgets_values": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + { + "id": 14, + "type": "TransformToMatrix", + "pos": [ + 700, + 1470 + ], + "size": [ + 270, + 154 + ], + "flags": {}, + "order": 3, + "mode": 0, + "inputs": [], + "outputs": [ + { + "name": "transformation matrix", + "type": "MAT_4X4", + "links": [ + 35 + ] + } + ], + "title": "Novel path: end (small orbit)", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "TransformToMatrix" + }, + "widgets_values": [ + 0.3, + 0.0, + 0.1, + 0.0, + -12.0 + ] + }, + { + "id": 15, + "type": "CameraInterpolationNode", + "pos": [ + 1030, + 1350 + ], + "size": [ + 250, + 90 + ], + "flags": {}, + "order": 6, + "mode": 0, + "inputs": [ + { + "name": "initial_matrix", + "type": "MAT_4X4", + "link": 34 + }, + { + "name": "final_matrix", + "type": "MAT_4X4", + "link": 35 + } + ], + "outputs": [ + { + "name": "trajectory", + "type": "TENSOR", + "links": [ + 36, + 39 + ] + } + ], + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "CameraInterpolationNode" + }, + "widgets_values": [ + 2 + ] + }, + { + "id": 16, + "type": "RenderSplats4DVideo", + "pos": [ + 700, + 850 + ], + "size": [ + 330, + 320 + ], + "flags": {}, + "order": 17, + "mode": 0, + "inputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "link": 32 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 36 + }, + { + "name": "camera_horizontal_fov", + "type": "FLOAT", + "widget": { + "name": "camera_horizontal_fov" + }, + "link": 19 + } + ], + "outputs": [ + { + "name": "images", + "type": "IMAGE", + "links": [ + 37 + ] + }, + { + "name": "masks", + "type": "MASK", + "links": null + }, + { + "name": "disparity", + "type": "TENSOR", + "links": null + } + ], + "title": "Render 4D along novel path", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "RenderSplats4DVideo" + }, + "widgets_values": [ + 49, + 0.0, + 1.0, + "PINHOLE", + 60.0, + 768, + 432, + "auto", + 0, + "auto" + ] + }, + { + "id": 17, + "type": "SaveWEBM", + "pos": [ + 1100, + 850 + ], + "size": [ + 280, + 320 + ], + "flags": {}, + "order": 19, + "mode": 0, + "inputs": [ + { + "name": "images", + "type": "IMAGE", + "link": 37 + } + ], + "outputs": [], + "properties": { + "cnr_id": "comfy-core", + "Node name for S&R": "SaveWEBM" + }, + "widgets_values": [ + "4d_world_render", + "vp9", + 24, + 32 + ] + }, + { + "id": 18, + "type": "SaveSplats4D", + "pos": [ + 1100, + 620 + ], + "size": [ + 280, + 110 + ], + "flags": {}, + "order": 20, + "mode": 0, + "inputs": [ + { + "name": "splats4d", + "type": "GSPLAT4D", + "link": 33 + } + ], + "outputs": [], + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SaveSplats4D" + }, + "widgets_values": [ + "ComfyUISplat4D", + false + ] + }, + { + "id": 20, + "type": "SplatTrajectoryEnricher", + "pos": [ + 700, + 1780 + ], + "size": [ + 360, + 520 + ], + "flags": {}, + "order": 18, + "mode": 2, + "inputs": [ + { + "name": "splats", + "type": "GSPLAT", + "link": 38 + }, + { + "name": "trajectory", + "type": "TENSOR", + "link": 39 + } + ], + "outputs": [ + { + "name": "enriched_splats", + "type": "GSPLAT", + "links": null + }, + { + "name": "last_render", + "type": "IMAGE", + "links": null + }, + { + "name": "last_filled", + "type": "IMAGE", + "links": null + } + ], + "title": "OPTIONAL (muted): world expansion - Flux outpaint + SHARP", + "properties": { + "aux_id": "Alexankharin/camera-comfyUI", + "Node name for S&R": "SplatTrajectoryEnricher" + }, + "widgets_values": [ + "PINHOLE", + 60.0, + 768, + 432, + "", + "", + 28, + 5.0, + 5, + 0.02, + 0.01, + 10, + "auto", + true, + "PINHOLE", + 90.0, + 1024, + 0.0, + 0.0 + ] + }, + { + "id": 21, + "type": "Note", + "pos": [ + 1120, + 1780 + ], + "size": [ + 360, + 260 + ], + "flags": {}, + "order": 4, + "mode": 0, + "inputs": [], + "outputs": [], + "title": "About world expansion", + "properties": {}, + "widgets_values": [ + "SplatTrajectoryEnricher is MUTED by default: it needs diffusers + the Flux fill weights (multi-GB) and a strong GPU.\n\nUnmute it to grow the static world beyond what the source video saw: for each pose along the novel path it renders the current splats, outpaints uncovered regions with Flux, lifts the filled view with SHARP, scale-aligns and smart-stitches the new content.\n\nTo use its result in the 4D scene, rewire BuildSplats4D.static from SplatPolish's output to enriched_splats." + ], + "color": "#432", + "bgcolor": "#653" + } + ], + "links": [ + [ + 1, + 1, + 0, + 2, + 0, + "IMAGE" + ], + [ + 2, + 1, + 0, + 5, + 0, + "IMAGE" + ], + [ + 3, + 1, + 0, + 6, + 1, + "IMAGE" + ], + [ + 4, + 1, + 0, + 7, + 0, + "IMAGE" + ], + [ + 5, + 1, + 0, + 9, + 0, + "IMAGE" + ], + [ + 6, + 2, + 0, + 3, + 1, + "TENSOR" + ], + [ + 7, + 2, + 0, + 5, + 1, + "TENSOR" + ], + [ + 8, + 2, + 0, + 6, + 2, + "TENSOR" + ], + [ + 9, + 2, + 0, + 8, + 4, + "TENSOR" + ], + [ + 10, + 2, + 1, + 3, + 0, + "TENSOR" + ], + [ + 11, + 2, + 1, + 5, + 4, + "TENSOR" + ], + [ + 12, + 2, + 1, + 8, + 2, + "TENSOR" + ], + [ + 13, + 2, + 2, + 3, + 2, + "FLOAT" + ], + [ + 14, + 2, + 2, + 5, + 2, + "FLOAT" + ], + [ + 15, + 2, + 2, + 6, + 3, + "FLOAT" + ], + [ + 16, + 2, + 2, + 8, + 3, + "FLOAT" + ], + [ + 17, + 2, + 2, + 10, + 1, + "FLOAT" + ], + [ + 18, + 2, + 2, + 11, + 2, + "FLOAT" + ], + [ + 19, + 2, + 2, + 16, + 2, + "FLOAT" + ], + [ + 20, + 3, + 0, + 4, + 0, + "MASK" + ], + [ + 21, + 3, + 0, + 11, + 1, + "MASK" + ], + [ + 22, + 4, + 0, + 5, + 3, + "MASK" + ], + [ + 23, + 5, + 0, + 6, + 0, + "GSPLAT" + ], + [ + 24, + 6, + 0, + 12, + 2, + "GSPLAT" + ], + [ + 25, + 7, + 0, + 8, + 0, + "TENSOR" + ], + [ + 26, + 7, + 1, + 8, + 1, + "TENSOR" + ], + [ + 27, + 8, + 0, + 12, + 1, + "TENSOR" + ], + [ + 28, + 8, + 1, + 12, + 4, + "TENSOR" + ], + [ + 29, + 9, + 0, + 10, + 0, + "IMAGE" + ], + [ + 30, + 10, + 0, + 11, + 0, + "GSPLAT" + ], + [ + 31, + 11, + 0, + 12, + 0, + "GSPLAT" + ], + [ + 32, + 12, + 0, + 16, + 0, + "GSPLAT4D" + ], + [ + 33, + 12, + 0, + 18, + 0, + "GSPLAT4D" + ], + [ + 34, + 13, + 0, + 15, + 0, + "MAT_4X4" + ], + [ + 35, + 14, + 0, + 15, + 1, + "MAT_4X4" + ], + [ + 36, + 15, + 0, + 16, + 1, + "TENSOR" + ], + [ + 37, + 16, + 0, + 17, + 0, + "IMAGE" + ], + [ + 38, + 6, + 0, + 20, + 0, + "GSPLAT" + ], + [ + 39, + 15, + 0, + 20, + 1, + "TENSOR" + ] + ], + "groups": [ + { + "id": 1, + "title": "1. Load & Pose (VGGT)", + "bounding": [ + -1650, + 150, + 720, + 560 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 2, + "title": "2. Motion Masks", + "bounding": [ + -910, + 150, + 640, + 420 + ], + "color": "#a1309b", + "font_size": 24, + "flags": {} + }, + { + "id": 3, + "title": "3. Static World Splats", + "bounding": [ + -230, + 150, + 850, + 500 + ], + "color": "#8154a6", + "font_size": 24, + "flags": {} + }, + { + "id": 4, + "title": "4. Dynamic 4D Splats", + "bounding": [ + -910, + 720, + 1540, + 640 + ], + "color": "#b06634", + "font_size": 24, + "flags": {} + }, + { + "id": 5, + "title": "5. Novel Camera Path, Render & Save", + "bounding": [ + 660, + 540, + 760, + 1140 + ], + "color": "#3f789e", + "font_size": 24, + "flags": {} + }, + { + "id": 6, + "title": "6. OPTIONAL: World Expansion (muted)", + "bounding": [ + 660, + 1700, + 860, + 640 + ], + "color": "#88A", + "font_size": 24, + "flags": {} + } + ], + "config": {}, + "extra": { + "ds": { + "scale": 0.4, + "offset": [ + 1700, + 450 + ] + }, + "frontendVersion": "1.23.4" + }, + "version": 0.4 +} diff --git a/world_nodes.py b/world_nodes.py new file mode 100644 index 0000000..c7b23d3 --- /dev/null +++ b/world_nodes.py @@ -0,0 +1,632 @@ +"""World-building nodes: depth-scale anchoring, splat world enrichment along a +trajectory (render -> outpaint -> SHARP -> align -> fuse) and panorama sphere seeding. + +Contracts implemented here (see SPEC_4D.md): + C4: align_depth_scale(new_depth, ref_depth, valid_mask, mode) -> (aligned, scale, shift) + +Heavy dependencies (Flux inpainting / diffusers via OutpaintAnyProjection, SHARP) +are only imported/loaded inside methods at call time. +""" + +import math +from typing import Any, Dict, Optional, Tuple + +import torch +from tqdm import tqdm + +try: + import folder_paths +except ImportError: # Allow notebook usage outside ComfyUI + class _FolderPathsStub: + def __getattr__(self, name): + raise ModuleNotFoundError( + "folder_paths is unavailable; this node requires the ComfyUI runtime." + ) + + folder_paths = _FolderPathsStub() + +try: + from . import GS_nodes as _gs +except Exception: + import GS_nodes as _gs + +GaussianSplats = _gs.GaussianSplats +Projection = _gs.Projection +DEVICE_CHOICES = _gs.DEVICE_CHOICES +_resolve_device_choice = _gs._resolve_device_choice +splat_cloud_rotation = _gs.splat_cloud_rotation +_stitch_splats = _gs._stitch_splats + +# Zeroth-order real SH constant; rendering with add_sh_bias=True computes +# rgb = C0 * f_dc + 0.5, so seeding uses f_dc = (rgb - 0.5) / C0. +SH_C0 = 0.28209479177387814 + + +# --------------------------------------------------------------------------- +# Lazy accessors for symbols provided by sibling modules / heavy dependencies +# --------------------------------------------------------------------------- + +def _get_render_gaussians(): + """Fetch GS_nodes.render_gaussians (contract C2) with an actionable error.""" + fn = getattr(_gs, "render_gaussians", None) + if fn is None: + raise RuntimeError( + "GS_nodes.render_gaussians is unavailable. Update GS_nodes.py to a version " + "that provides the module-level render_gaussians function (contract C2)." + ) + return fn + + +def _load_outpaint_node_class(): + """Lazy-import OutpaintAnyProjection (pulls in Flux/diffusers machinery).""" + try: + from .flux_fisheye_filling_nodes import OutpaintAnyProjection + return OutpaintAnyProjection + except Exception: + pass + try: + from flux_fisheye_filling_nodes import OutpaintAnyProjection + return OutpaintAnyProjection + except Exception as exc: + raise RuntimeError( + "OutpaintAnyProjection could not be imported from flux_fisheye_filling_nodes. " + "It requires the inpainting_flux custom node package (Flux NF4 inpainting, " + "diffusers). Install/fix custom_nodes/inpainting_flux and its dependencies. " + f"Import error: {exc}" + ) from exc + + +# --------------------------------------------------------------------------- +# C4: robust depth-scale alignment in the disparity domain +# --------------------------------------------------------------------------- + +def align_depth_scale( + new_depth: torch.Tensor, + ref_depth: torch.Tensor, + valid_mask: torch.Tensor, + mode: str = "scale_shift", +) -> Tuple[torch.Tensor, float, float]: + """Least-squares scale(+shift) in DISPARITY (1/d) domain on valid_mask pixels, + robust (clip residual outliers, 2 IRLS rounds). Returns (aligned_depth, scale, shift). + + Fits 1/ref_depth ~= scale * (1/new_depth) + shift over valid pixels and returns + new_depth remapped through the fitted disparity transform. If the fit is + degenerate (too few valid pixels, non-positive/non-finite scale), returns the + input depth unchanged with (scale=1.0, shift=0.0). + """ + if mode not in ("scale", "scale_shift"): + raise ValueError(f"Unknown align mode: {mode}") + + nd = torch.as_tensor(new_depth).float() + # Harmonize devices: the inputs may arrive on different devices (e.g. a + # CUDA motion mask from MotionMaskFromDepth combined with CPU depth + # estimates); compute everything on new_depth's device. + rd = torch.as_tensor(ref_depth).float().to(nd.device) + vm = torch.as_tensor(valid_mask).float().to(nd.device) + + nd_flat = nd.reshape(-1) + rd_flat = rd.reshape(-1) + if vm.numel() == nd_flat.numel(): + vm_flat = vm.reshape(-1) + else: + try: + vm_flat = vm.expand_as(nd).reshape(-1) + except RuntimeError as exc: + raise ValueError( + f"valid_mask shape {tuple(vm.shape)} is not broadcastable to depth shape {tuple(nd.shape)}" + ) from exc + + eps = 1e-8 + valid = ( + (vm_flat > 0.5) + & (nd_flat > eps) + & (rd_flat > eps) + & torch.isfinite(nd_flat) + & torch.isfinite(rd_flat) + ) + if int(valid.sum().item()) < 10: + return nd.clone(), 1.0, 0.0 + + x = 1.0 / nd_flat[valid] # new disparity + y = 1.0 / rd_flat[valid] # reference disparity + w = torch.ones_like(x) + + scale, shift = 1.0, 0.0 + # Initial weighted LSQ fit + 2 IRLS re-weighting rounds (outlier clipping). + for _ in range(3): + sw = w.sum().clamp(min=eps) + sx = (w * x).sum() + sy = (w * y).sum() + if mode == "scale_shift": + sxx = (w * x * x).sum() + sxy = (w * x * y).sum() + denom = sw * sxx - sx * sx + if float(denom.abs().item()) < eps: + s = (sxy / sxx.clamp(min=eps)).item() + b = 0.0 + else: + s = float(((sw * sxy - sx * sy) / denom).item()) + b = float(((sy - s * sx) / sw).item()) + else: + sxx = (w * x * x).sum() + sxy = (w * x * y).sum() + s = float((sxy / sxx.clamp(min=eps)).item()) + b = 0.0 + scale, shift = s, b + + resid = y - (scale * x + shift) + sigma = 1.4826 * resid.abs().median() + sigma = sigma.clamp(min=eps) + w = (resid.abs() <= 2.5 * sigma).float() + if float(w.sum().item()) < 10: + break + + if not math.isfinite(scale) or scale <= 0.0 or not math.isfinite(shift): + return nd.clone(), 1.0, 0.0 + + disp = scale / nd.clamp(min=eps) + shift + aligned = 1.0 / disp.clamp(min=eps) + return aligned, float(scale), float(shift) + + +# --------------------------------------------------------------------------- +# Internal helpers +# --------------------------------------------------------------------------- + +def _coerce_trajectory(trajectory: Any, device: torch.device) -> torch.Tensor: + """Coerce trajectory input to a [K,4,4] float tensor on device.""" + if isinstance(trajectory, torch.Tensor): + traj = trajectory + else: + traj = torch.as_tensor(trajectory) + traj = traj.to(device=device, dtype=torch.float32) + if traj.dim() == 2: + traj = traj.unsqueeze(0) + if traj.dim() != 3 or traj.shape[-2:] != (4, 4): + raise ValueError(f"trajectory must be [K,4,4], got shape {tuple(traj.shape)}") + return traj + + +def _project_to_pixels( + xyz: torch.Tensor, + projection: str, + horizontal_fov: float, + width: int, + height: int, +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + """Project camera-frame points to integer pixel indices. + + Returns (ix [N], iy [N], ray_depth [N], valid [N]) where valid means the point + is in front of the camera (pinhole) and lands inside the image bounds. Uses the + same projection math as GS_nodes rendering so pixels line up with renders. + """ + X, Y, Z = xyz.unbind(-1) + if projection == "PINHOLE": + u, v, depth = _gs._xyz_to_pinhole(X, Y, Z, horizontal_fov) + front = Z > 1e-6 + elif projection == "FISHEYE": + u, v, depth = _gs._xyz_to_fisheye(X, Y, Z, horizontal_fov) + front = depth > 1e-6 + else: + u, v, depth = _gs._xyz_to_equirect(X, Y, Z, horizontal_fov) + front = depth > 1e-6 + + ix = torch.round((u * 0.5 + 0.5) * (width - 1)).long() + iy = torch.round((v * 0.5 + 0.5) * (height - 1)).long() + inside = (u >= -1.0) & (u <= 1.0) & (v >= -1.0) & (v <= 1.0) + valid = front & inside & torch.isfinite(u) & torch.isfinite(v) + ix = ix.clamp(0, width - 1) + iy = iy.clamp(0, height - 1) + return ix, iy, depth, valid + + +def _pad_f_rest_to_order(splats: GaussianSplats, sh_order: int) -> GaussianSplats: + """Zero-pad SH coefficients so splats match the requested (higher) SH order. + + Delegates to GS_nodes._pad_sh_order, which handles the renderer's + channel-major SH layout (cat([f_dc, f_rest]).view(-1, 3, total)) correctly. + Naively appending zeros to f_rest would shift the green/blue DC terms into + the red channel's l>=1 slots and corrupt colors. + """ + return _gs._pad_sh_order(splats, sh_order) + + +def _match_sh_orders(a: GaussianSplats, b: GaussianSplats) -> Tuple[GaussianSplats, GaussianSplats]: + """Bring two splat sets to a common (max) SH order via zero padding.""" + return _gs._match_sh_orders(a, b) + + +def _scale_splats_metric(splats: GaussianSplats, factor: float) -> GaussianSplats: + """Uniformly rescale splat positions and sizes by a metric factor.""" + out = splats.clone() + out.xyz = out.xyz * factor + out.scale = out.scale + math.log(max(factor, 1e-12)) + return out + + +# --------------------------------------------------------------------------- +# Nodes +# --------------------------------------------------------------------------- + +class DepthScaleAnchor: + """Aligns a depth map's scale (and optionally shift) to a reference depth map + using a robust least-squares fit in the disparity domain (contract C4).""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "new_depth": ("TENSOR", {"tooltip": "Depth map to be aligned (any shape)."}), + "ref_depth": ("TENSOR", {"tooltip": "Reference metric depth map (same shape)."}), + "valid_mask": ("MASK", {"tooltip": "1.0 where both depths are trustworthy."}), + "mode": ( + ["scale", "scale_shift"], + {"default": "scale_shift", "tooltip": "Fit scale only, or scale + shift, in disparity (1/d) domain."}, + ), + }, + } + + RETURN_TYPES = ("TENSOR", "FLOAT", "FLOAT") + RETURN_NAMES = ("aligned_depth", "scale", "shift") + FUNCTION = "anchor" + CATEGORY = "Camera/World" + DESCRIPTION = "Robustly aligns a depth map to a reference depth via disparity-domain scale(+shift)." + + def anchor( + self, + new_depth: torch.Tensor, + ref_depth: torch.Tensor, + valid_mask: torch.Tensor, + mode: str = "scale_shift", + ): + aligned, scale, shift = align_depth_scale(new_depth, ref_depth, valid_mask, mode=mode) + return (aligned, scale, shift) + + +class SplatTrajectoryEnricher: + """World-expansion loop for Gaussian splats. + + For each pose along a trajectory: render the current splats, detect uncovered + (hole) regions, fill them with Flux outpainting, lift the filled view to new + splats with SHARP, align the SHARP metric scale to the rendered reference + depth, keep only the splats that cover holes, transform them to world space + and fuse them into the running splat set. + """ + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + choices = _gs._list_sharp_checkpoint_choices() + return { + "required": { + "splats": ("GSPLAT",), + "trajectory": ("TENSOR", {"tooltip": "[K,4,4] world-to-camera matrices of poses to visit."}), + "camera_projection": (Projection.PROJECTIONS, {}), + "horizontal_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 360.0}), + "width": ("INT", {"default": 512, "min": 8, "max": 8192}), + "height": ("INT", {"default": 512, "min": 8, "max": 8192}), + "checkpoint": ( + choices, + { + "default": _gs._SHARP_DEFAULT_CHECKPOINT_LABEL, + "file_chooser": True, + "tooltip": "SHARP .pt checkpoint from the input folder, or download the default model.", + }, + ), + "prompt": ("STRING", {"default": "", "multiline": True}), + "num_inference_steps": ("INT", {"default": 28, "min": 10, "max": 60}), + "guidance_scale": ("FLOAT", {"default": 5.0, "min": 0.1, "max": 30.0}), + "mask_blur": ("INT", {"default": 5, "min": 0, "max": 512}), + "hole_min_frac": ( + "FLOAT", + {"default": 0.02, "min": 0.0, "max": 1.0, "step": 0.001, + "tooltip": "Skip a view if the uncovered area is below this fraction of pixels."}, + ), + "stitch_voxel_size": ("FLOAT", {"default": 0.01, "min": 0.0, "max": 10.0}), + "max_views": ("INT", {"default": 10, "min": 1, "max": 1000}), + }, + "optional": { + "device": (DEVICE_CHOICES, {"default": "auto"}), + "cache_flux": ( + "BOOLEAN", + {"default": True, + "tooltip": "Keep the Flux inpainting pipeline loaded between views (avoids a multi-GB " + "model reload per view). Disable to free VRAM after each outpaint on " + "low-memory GPUs."}, + ), + "patch_projection": (Projection.PROJECTIONS, {"default": "PINHOLE", "tooltip": "Projection used for the outpaint patch."}), + "patch_horiz_fov": ("FLOAT", {"default": 90.0, "min": 1.0, "max": 180.0}), + "patch_res": ("INT", {"default": 1024, "min": 64, "max": 8192}), + "patch_phi": ("FLOAT", {"default": 0.0, "min": -180.0, "max": 180.0}), + "patch_theta": ("FLOAT", {"default": 0.0, "min": -90.0, "max": 90.0}), + }, + } + + RETURN_TYPES = ("GSPLAT", "IMAGE", "IMAGE") + RETURN_NAMES = ("enriched_splats", "last_render", "last_filled") + FUNCTION = "enrich" + CATEGORY = "Camera/World" + DESCRIPTION = ( + "Expands a splat world along a camera trajectory: render, outpaint holes with Flux, " + "lift with SHARP, scale-align, and smart-stitch the new content." + ) + + @torch.no_grad() + def enrich( + self, + splats: GaussianSplats, + trajectory: torch.Tensor, + camera_projection: str, + horizontal_fov: float, + width: int, + height: int, + checkpoint: str, + prompt: str, + num_inference_steps: int, + guidance_scale: float, + mask_blur: int, + hole_min_frac: float, + stitch_voxel_size: float, + max_views: int, + device: str = "auto", + cache_flux: bool = True, + patch_projection: str = "PINHOLE", + patch_horiz_fov: float = 90.0, + patch_res: int = 1024, + patch_phi: float = 0.0, + patch_theta: float = 0.0, + ) -> Tuple[GaussianSplats, torch.Tensor, torch.Tensor]: + # Fail fast: the SHARP lift (ImageToSplat) is pinhole-only and requires + # horizontal_fov < 179 degrees. Validating here avoids crashing in the + # lift step AFTER minutes of rendering + Flux outpainting work. + if not (0.0 < float(horizontal_fov) < 179.0): + raise ValueError( + "SplatTrajectoryEnricher lifts filled views with SHARP (pinhole), which requires " + f"0 < horizontal_fov < 179 degrees (got {horizontal_fov}). For panoramic worlds " + "(EQUIRECTANGULAR/FISHEYE with fov >= 179), visit several narrower pinhole poses " + "along the trajectory instead (e.g. 90-120 degree views after SphereSplatSeed)." + ) + render_gaussians = _get_render_gaussians() + outpaint_cls = _load_outpaint_node_class() + outpaint_node = outpaint_cls() + image_to_splat = _gs.ImageToSplat() + + target_device = _resolve_device_choice(device) + current = splats.to(target_device) if splats.xyz.device != target_device else splats + traj = _coerce_trajectory(trajectory, target_device) + + if camera_projection != "PINHOLE": + print( + "[SplatTrajectoryEnricher] Warning: SHARP assumes pinhole geometry; " + f"lifting filled {camera_projection} views may distort new splats." + ) + + last_render = torch.zeros((1, height, width, 3), device=target_device) + last_filled = torch.zeros((1, height, width, 3), device=target_device) + added_views = 0 + + for pose in tqdm(traj[: max(1, int(max_views))], desc="Enriching splat world"): + # 1) Render the current world from this pose. + image, alpha, disparity = render_gaussians( + current, + pose, + camera_projection, + horizontal_fov, + width, + height, + max_splats=0, + opacity_is_logit=True, + add_sh_bias=True, + render_mode="auto", + device=str(target_device).split(":")[0], + ) + last_render = image + + alpha_map = alpha.view(height, width).to(target_device) + disp_map = disparity.view(height, width).to(target_device) + hole_mask = (alpha_map < 0.5).float() + + hole_frac = float(hole_mask.mean().item()) + if hole_frac < hole_min_frac: + continue + + # 2) Outpaint the uncovered region. + filled_img, _ = outpaint_node.outpaint_any( + image, + input_projection=camera_projection, + input_horiz_fov=horizontal_fov, + output_projection=camera_projection, + output_horiz_fov=horizontal_fov, + output_width=width, + output_height=height, + patch_projection=patch_projection, + patch_horiz_fov=patch_horiz_fov, + patch_res=patch_res, + patch_phi=patch_phi, + patch_theta=patch_theta, + prompt=prompt, + num_inference_steps=num_inference_steps, + # cached=True keeps the Flux NF4 pipeline resident between views + # (cached=False forced a full multi-GB pipeline reload per view). + cached=bool(cache_flux), + guidance_scale=guidance_scale, + mask_blur=mask_blur, + mask=hole_mask.unsqueeze(0), + debug=False, + ) + last_filled = filled_img + + # 3) Lift the filled view to splats in this camera frame (SHARP, metric). + new_splats, = image_to_splat.image_to_splat( + filled_img, + horizontal_fov, + checkpoint, + device, + ) + new_splats = new_splats.to(target_device) + if len(new_splats) == 0: + continue + + # 4) Robust metric-scale alignment against the rendered reference depth. + # Reference ray depth from the renderer: disparity = alpha / depth. + ix, iy, sharp_depth, proj_valid = _project_to_pixels( + new_splats.xyz, camera_projection, horizontal_fov, width, height + ) + samp_alpha = alpha_map[iy, ix] + samp_disp = disp_map[iy, ix] + overlap = proj_valid & (samp_alpha >= 0.5) & (samp_disp > 1e-6) & (sharp_depth > 1e-6) + if int(overlap.sum().item()) >= 10: + d_ref = (samp_alpha[overlap] / samp_disp[overlap]).clamp(min=1e-6) + ratio = d_ref / sharp_depth[overlap] + scale_factor = float(ratio.median().item()) + if math.isfinite(scale_factor) and scale_factor > 0.0: + new_splats = _scale_splats_metric(new_splats, scale_factor) + + # 5) Keep only NEW content: splats whose projected pixel lies in a hole. + samp_hole = hole_mask[iy, ix] + keep = proj_valid & (samp_hole > 0.5) + if not bool(keep.any().item()): + continue + new_splats = new_splats[keep] + + # 6) Camera frame -> world frame (pose is world-to-camera). + new_world = splat_cloud_rotation(new_splats, torch.inverse(pose)) + + # 7) Fuse into the running world. Concatenation is cheap; the full + # smart voxel reduce is deferred to a single pass after the loop, + # so each view does not re-copy and re-unique-sort the entire + # accumulated cloud (O(views x N) work/memory otherwise). + cur_m, new_m = _match_sh_orders(current, new_world) + current = _gs._concat_splats([cur_m, new_m]) + added_views += 1 + + if added_views > 0 and stitch_voxel_size > 0.0: + current = _stitch_splats([current], "smart", stitch_voxel_size, 5.0) + + return (current, last_render, last_filled) + + +class SphereSplatSeed: + """Seeds a 360-degree splat world from an equirectangular panorama: one Gaussian + per (subsampled) pixel, placed on a depth sphere around the origin.""" + + @classmethod + def INPUT_TYPES(cls) -> Dict[str, Any]: + return { + "required": { + "image": ("IMAGE", {"tooltip": "Equirectangular panorama [1,H,W,3]."}), + "horizontal_fov": ("FLOAT", {"default": 360.0, "min": 1.0, "max": 360.0}), + "radius": ("FLOAT", {"default": 5.0, "min": 0.01, "max": 10000.0, "tooltip": "Sphere radius used when no depth map is provided."}), + "splat_scale_frac": ( + "FLOAT", + {"default": 1.5, "min": 0.1, "max": 10.0, + "tooltip": "Splat sigma as a fraction of the local point spacing (larger = smoother, fewer holes)."}, + ), + "stride": ("INT", {"default": 2, "min": 1, "max": 64, "tooltip": "Pixel subsampling stride (1 Gaussian per stride x stride block)."}), + }, + "optional": { + "depth": ("TENSOR", {"tooltip": "Optional ray-depth map [H,W] (or [1,H,W]/[H,W,1]) matching the panorama."}), + "opacity_logit": ("FLOAT", {"default": 6.0, "min": -10.0, "max": 20.0}), + "device": (DEVICE_CHOICES, {"default": "auto"}), + }, + } + + RETURN_TYPES = ("GSPLAT",) + RETURN_NAMES = ("splats",) + FUNCTION = "seed_sphere" + CATEGORY = "Camera/World" + DESCRIPTION = "Converts an equirectangular panorama into a Gaussian sphere seeding a 360-degree world." + + @torch.no_grad() + def seed_sphere( + self, + image: torch.Tensor, + horizontal_fov: float = 360.0, + radius: float = 5.0, + splat_scale_frac: float = 1.5, + stride: int = 2, + depth: Optional[torch.Tensor] = None, + opacity_logit: float = 6.0, + device: str = "auto", + ) -> Tuple[GaussianSplats]: + target_device = _resolve_device_choice(device) + + img = image + if img.dim() == 4: + img = img[0] + if img.dim() != 3 or img.shape[-1] < 3: + raise ValueError(f"Expected IMAGE [1,H,W,3], got shape {tuple(image.shape)}") + img = img[..., :3].to(device=target_device, dtype=torch.float32) + H, W = int(img.shape[0]), int(img.shape[1]) + + depth_map = None + if depth is not None: + d = torch.as_tensor(depth).to(device=target_device, dtype=torch.float32) + if d.dim() == 3: + # [1,H,W], [T,H,W] (take first) or [H,W,1] + d = d[..., 0] if d.shape[-1] == 1 else d[0] + if d.dim() != 2: + raise ValueError(f"depth must reduce to [H,W], got shape {tuple(depth.shape)}") + if d.shape != (H, W): + d = torch.nn.functional.interpolate( + d.unsqueeze(0).unsqueeze(0), size=(H, W), mode="bilinear", align_corners=True + )[0, 0] + depth_map = d.clamp(min=1e-6) + + stride = max(1, int(stride)) + ys = torch.arange(0, H, stride, device=target_device) + xs = torch.arange(0, W, stride, device=target_device) + yy, xx = torch.meshgrid(ys, xs, indexing="ij") + yy = yy.reshape(-1) + xx = xx.reshape(-1) + + # Match the renderer's equirect mapping (GS_nodes._xyz_to_equirect): + # u = lon / (fov_rad/2), v = lat / (pi/2), px = (u*0.5+0.5)*(W-1) + fov_rad = math.radians(horizontal_fov) + u = xx.float() / max(W - 1, 1) * 2.0 - 1.0 + v = yy.float() / max(H - 1, 1) * 2.0 - 1.0 + lon = u * (fov_rad / 2.0) + lat = v * (math.pi / 2.0) + + if depth_map is not None: + d = depth_map[yy, xx] + else: + d = torch.full_like(lon, float(radius)) + + cos_lat = torch.cos(lat) + X = d * cos_lat * torch.sin(lon) + Y = d * torch.sin(lat) + Z = d * cos_lat * torch.cos(lon) + xyz = torch.stack([X, Y, Z], dim=-1) + + rgb = img[yy, xx, :] + # Rendering with add_sh_bias=True evaluates rgb = C0 * f_dc + 0.5. + f_dc = (rgb - 0.5) / SH_C0 + + # Isotropic sigma from local angular spacing (radians per sample) times depth. + ang_spacing = float(stride) * max(fov_rad / max(W, 1), math.pi / max(H, 1)) + sigma = (splat_scale_frac * ang_spacing * d).clamp(min=1e-6) + scale = torch.log(sigma).unsqueeze(-1).expand(-1, 3).contiguous() + + n = xyz.shape[0] + rotation = torch.zeros((n, 4), device=target_device, dtype=torch.float32) + rotation[:, 0] = 1.0 # identity wxyz quaternion + opacity = torch.full((n, 1), float(opacity_logit), device=target_device, dtype=torch.float32) + f_rest = torch.zeros((n, 0), device=target_device, dtype=torch.float32) + + splats = GaussianSplats( + xyz=xyz, + scale=scale, + rotation=rotation, + opacity=opacity, + f_dc=f_dc, + f_rest=f_rest, + sh_order=0, + ) + return (splats,) + + +NODE_CLASS_MAPPINGS = { + "DepthScaleAnchor": DepthScaleAnchor, + "SplatTrajectoryEnricher": SplatTrajectoryEnricher, + "SphereSplatSeed": SphereSplatSeed, +}