diff --git a/discussion/probabilistic_bundle_adjustment/ProbBundle.ipynb b/discussion/probabilistic_bundle_adjustment/ProbBundle.ipynb new file mode 100644 index 0000000000..fdbe3b8a7c --- /dev/null +++ b/discussion/probabilistic_bundle_adjustment/ProbBundle.ipynb @@ -0,0 +1,3960 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "07c1d969-5e2f-47d6-b49d-e639f8f0ec4c", + "metadata": {}, + "source": [ + "#### Copyright 2024 The TensorFlow Probability Authors.\n", + "\n", + "```none\n", + "Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "you may not use this file except in compliance with the License.\n", + "You may obtain a copy of the License at\n", + "\n", + "https://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "Unless required by applicable law or agreed to in writing, software\n", + "distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "See the License for the specific language governing permissions and\n", + "limitations under the License.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "b3110834-ae1d-46ca-bfef-4fcfd2d27638", + "metadata": {}, + "source": [ + "# Probabilistic Bundle Adjustment" + ] + }, + { + "cell_type": "markdown", + "id": "2f0fda86-5b77-4182-ae35-af8969b72565", + "metadata": {}, + "source": [ + "This notebook shows how to use probabilistic modeling and inference to solve the bundle adjustment problem. Given a video of keypoints, we construct a probabilistic generative model that can reconstruct that video given camera poses and keypoint world positions. We then use Markov Chain Monte Carlo (MCMC) to perform probabilistic inference on this model to infer the unknown camera poses and keypoint world positions.\n", + "\n", + "In an uncommon choice, this notebook illustrates how to construct an interactive inference controller that enables monitoring and adjusting the model and inference hyperparameters to gain a better understanding of the model and inference procedure. As a result, **this notebook must be run in Jupyter Lab**, with a GPU. Running on Google Colab will cause the UI elements to not function correctly (the batch inference should be fine however).\n" + ] + }, + { + "cell_type": "markdown", + "id": "a2e8bc90-66ec-41a4-9b07-93e60fac16b8", + "metadata": {}, + "source": [ + "# Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e58b2aff-cc94-443b-a124-e8698fc99160", + "metadata": {}, + "outputs": [], + "source": [ + "import jax\n", + "import numpy as np\n", + "if False:\n", + " jax.config.update(\"jax_enable_x64\", True)\n", + " DTYPE = np.float64\n", + "else:\n", + " DTYPE = np.float32" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5f74aac1-e643-453a-ac52-f241d6528158", + "metadata": {}, + "outputs": [], + "source": [ + "import abc\n", + "import asyncio\n", + "import collections\n", + "from collections.abc import Callable\n", + "import copy\n", + "import contextlib\n", + "import dataclasses\n", + "import functools\n", + "import io\n", + "import time\n", + "from typing import Any, NamedTuple, Optional, TypeVar\n", + "import traceback\n", + "\n", + "import fun_mc.using_jax as fun_mc\n", + "import ipywidgets\n", + "import jax.numpy as jnp\n", + "from jax.scipy.spatial.transform import Rotation\n", + "import matplotlib.pyplot as plt\n", + "import mediapy\n", + "import plotly.graph_objects as pgo\n", + "import pythreejs as p3\n", + "import tqdm.notebook\n", + "import tensorflow_probability.substrates.jax as tfp\n", + "import warnings\n", + "\n", + "tfd = tfp.distributions\n", + "tfb = tfp.bijectors" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c8f52054-3aec-4a83-b3c5-6f19e655063b", + "metadata": {}, + "outputs": [], + "source": [ + "INTERACTIVE_INFERENCE = None" + ] + }, + { + "cell_type": "markdown", + "id": "e1877db8-8b06-40ef-b548-fe42e1bacfdd", + "metadata": {}, + "source": [ + "# Utils" + ] + }, + { + "cell_type": "markdown", + "id": "0aedd388-5339-4f5a-b29c-c7a02e3bf2bb", + "metadata": {}, + "source": [ + "## Misc" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ef2db63c-c851-4122-9268-00e0478e0fca", + "metadata": {}, + "outputs": [], + "source": [ + "def shape(*args):\n", + " if len(args) == 1:\n", + " args = args[0]\n", + " return jax.tree.map(jnp.shape, args)\n", + "\n", + "\n", + "def dtype(*args):\n", + " if len(args) == 1:\n", + " args = args[0]\n", + " return jax.tree.map(jnp.dtype, args)\n", + "\n", + "\n", + "def cast_floats(x, dtype=DTYPE):\n", + " def one_part(x):\n", + " if jnp.issubdtype(x.dtype, jnp.floating):\n", + " return x.astype(dtype)\n", + " else:\n", + " return x\n", + "\n", + " return jax.tree.map(one_part, x)\n", + "\n", + "\n", + "def to_html(color):\n", + " return (\n", + " f\"#{int(255 * color[0]):02X}{int(255 * color[1]):02X}{int(255 * color[2]):02X}\"\n", + " )\n", + "\n", + "\n", + "COLORS = [ # From https://mikemol.github.io/technique/colorblind/2018/02/11/color-safe-palette.html\n", + " \"#E69F00\",\n", + " \"#56B4E9\",\n", + " \"#009E73\",\n", + " \"#0072B2\",\n", + " \"#D55E00\",\n", + " \"#F0E442\",\n", + " \"#CC79A7\",\n", + "]\n", + "\n", + "new_order = [2, 3, 4, 0, 1, 5] # from luminance, reversed\n", + "COLORS = list(np.array(COLORS)[new_order])\n", + "\n", + "COLORS_NP = (\n", + " np.stack(\n", + " [\n", + " np.stack(\n", + " [\n", + " int(c[1:3], base=16),\n", + " int(c[3:5], base=16),\n", + " int(c[5:7], base=16),\n", + " ]\n", + " )\n", + " for c in COLORS\n", + " ]\n", + " )\n", + " / 255.0\n", + ")\n", + "\n", + "import cycler\n", + "\n", + "plt.rcParams[\"axes.prop_cycle\"] = cycler.cycler(color=COLORS)" + ] + }, + { + "cell_type": "markdown", + "id": "d457f010-8658-4ef9-8fc4-1bee1412b958", + "metadata": {}, + "source": [ + "## Pose" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7a1034bd-49d2-4e70-a628-4d958fbbadf8", + "metadata": {}, + "outputs": [], + "source": [ + "class Pose(NamedTuple):\n", + " position: jax.Array\n", + " quaternion: jax.Array\n", + "\n", + " def rotation(self) -> Rotation:\n", + " return Rotation.from_quat(self.quaternion)\n", + "\n", + " def normalize(self) -> \"Pose\":\n", + " return Pose(self.position, self.rotation().as_quat())\n", + "\n", + " def apply(self, vec: jax.Array) -> jax.Array:\n", + " return self.rotation().apply(vec) + self.position\n", + "\n", + " def compose(self, other: \"Pose\") -> \"Pose\":\n", + " new_position = self.apply(other.position)\n", + " new_quaternion = (self.rotation() * other.rotation()).as_quat()\n", + " return Pose(new_position, new_quaternion)\n", + "\n", + " def inv(self) -> \"Pose\":\n", + " inv_rot = self.rotation().inv()\n", + " return Pose(-inv_rot.apply(self.position), inv_rot.as_quat())\n", + "\n", + " @classmethod\n", + " def identity(cls) -> \"Pose\":\n", + " return cls(position=jnp.zeros(3), quaternion=jnp.array([0.0, 0.0, 0.0, 1.0]))\n", + "\n", + " def __getitem__(self, idx):\n", + " return jax.tree.map(lambda x: x[idx], self)" + ] + }, + { + "cell_type": "markdown", + "id": "4a11e5be-521a-4c6f-b30b-372697a99527", + "metadata": {}, + "source": [ + "## Camera" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "df60ca03-b1b0-432b-a6cd-e241b407cd8a", + "metadata": {}, + "outputs": [], + "source": [ + "@functools.partial(jax.vmap, in_axes=(0, None))\n", + "def screen_from_camera(xyz, camera_pose):\n", + " with jax.default_matmul_precision(\"float32\"):\n", + " cam_xyz = camera_pose.inv().apply(xyz)\n", + " x, y, z = cam_xyz\n", + " # HACK: Why does this work?\n", + " z = jnp.where(z < 1e-3, 1e-3, z)\n", + " u = x / z\n", + " v = y / z\n", + " return jnp.stack([u, v], axis=-1)\n", + "\n", + "\n", + "def homogeneous_coordinates(uv, z=np.array(1.0, DTYPE)):\n", + " return (\n", + " jnp.concatenate([uv, jnp.ones_like(uv[..., :1])], axis=-1) * z[..., jnp.newaxis]\n", + " )\n", + "\n", + "\n", + "def look_at_quat(position, target, up=np.array([0.0, 0.0, 1.0], DTYPE)):\n", + " z = target - position\n", + " z = z / jnp.linalg.norm(z)\n", + "\n", + " x = jnp.cross(z, up)\n", + " x = x / jnp.linalg.norm(x)\n", + "\n", + " y = jnp.cross(z, x)\n", + " y = y / jnp.linalg.norm(y)\n", + "\n", + " rotation_matrix = jnp.hstack([x.reshape(-1, 1), y.reshape(-1, 1), z.reshape(-1, 1)])\n", + " return Rotation.from_matrix(rotation_matrix).as_quat()" + ] + }, + { + "cell_type": "markdown", + "id": "8eb317d4-d0d2-4341-8cc7-e18c394c146c", + "metadata": {}, + "source": [ + "## Scene" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2e1a7cc3-a78c-4b5f-b9f9-375cf31e87a7", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclasses.dataclass\n", + "class Scene:\n", + " keypoint_world_positions: jax.Array\n", + " keypoint_colors: jax.Array\n", + " keypoint_screen_positions: jax.Array\n", + " camera_poses: jax.Array\n", + " keypoint_visibility: jax.Array\n", + "\n", + " @property\n", + " def num_frames(self) -> int:\n", + " return self.keypoint_screen_positions.shape[0]\n", + "\n", + " @property\n", + " def num_keypoints(self) -> int:\n", + " return self.keypoint_screen_positions.shape[1]\n", + "\n", + "\n", + "def make_scene(obj, camera_poses, max_num_points):\n", + " points, rgbs = scene_obj.spawn_points(max_num_points, jax.random.key(0))\n", + " visibility = ~jax.lax.map(\n", + " lambda camera_pos: cast_ray_one_frame(camera_pos, points, scene_obj),\n", + " camera_positions,\n", + " )\n", + " uvs = jax.lax.map(\n", + " lambda camera_pose: screen_from_camera(points, camera_pose), camera_poses\n", + " )\n", + " visibility &= jnp.linalg.norm(uvs, axis=-1, ord=jnp.inf) < 1\n", + " valid_keypoints = visibility.any(0)\n", + "\n", + " return Scene(\n", + " keypoint_world_positions=points[valid_keypoints],\n", + " keypoint_colors=rgbs[valid_keypoints],\n", + " keypoint_screen_positions=uvs[:, valid_keypoints],\n", + " keypoint_visibility=visibility[:, valid_keypoints],\n", + " camera_poses=camera_poses,\n", + " )\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class SceneInfo:\n", + " object_mask: jax.Array\n", + " object_positions: jax.Array" + ] + }, + { + "cell_type": "markdown", + "id": "a5ef967e-7b37-4597-ac05-47f5d35ea91e", + "metadata": {}, + "source": [ + "## Scene Rendering" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8cf10595-e57e-4689-9f43-0a8ff0881d54", + "metadata": {}, + "outputs": [], + "source": [ + "POINT_VERTEX = \"\"\"\n", + "attribute float size;\n", + "attribute vec3 color;\n", + "\n", + "varying vec3 var_color;\n", + "varying float var_size;\n", + "\n", + "void main() {\n", + " var_color = color;\n", + " gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n", + " gl_PointSize = size;\n", + " var_size = size;\n", + "}\n", + "\"\"\"\n", + "\n", + "POINT_FRAGMENT = \"\"\"\n", + "varying vec3 var_color;\n", + "varying float var_size;\n", + "\n", + "void main() {\n", + " gl_FragColor = vec4(var_color, 1.0);\n", + " if (var_size < 0.0001)\n", + " discard;\n", + "}\n", + "\"\"\"\n", + "\n", + "\n", + "def octahedron():\n", + " vertices = np.array(\n", + " [\n", + " [0, 1, 0],\n", + " [1, 0, 0],\n", + " [0, 0, 1],\n", + " [-1, 0, 0],\n", + " [0, 0, -1],\n", + " [0, -1, 0],\n", + " ]\n", + " ).astype(np.float32)\n", + "\n", + " indices = (\n", + " np.array(\n", + " [\n", + " [1, 0, 2],\n", + " [2, 0, 3],\n", + " [3, 0, 4],\n", + " [4, 0, 1],\n", + " [2, 5, 1],\n", + " [3, 5, 2],\n", + " [4, 5, 3],\n", + " [1, 5, 4],\n", + " ]\n", + " )\n", + " .astype(np.uint32)\n", + " .ravel()\n", + " )\n", + " return vertices, indices\n", + "\n", + "\n", + "def camera_frustum():\n", + " vertices = np.array(\n", + " [\n", + " [0, 0, 0],\n", + " [1, 1, 1],\n", + " [-1, 1, 1],\n", + " [-1, -1, 1],\n", + " [1, -1, 1],\n", + " [-1, -1.1, 1],\n", + " [0, -1.5, 1],\n", + " [1, -1.1, 1],\n", + " ]\n", + " ).astype(np.float32)\n", + "\n", + " indices = (\n", + " np.array(\n", + " [\n", + " [0, 1, 2],\n", + " [0, 2, 3],\n", + " [0, 3, 4],\n", + " [0, 4, 1],\n", + " [5, 6, 7],\n", + " ]\n", + " )\n", + " .astype(np.uint32)\n", + " .ravel()\n", + " )\n", + " return vertices, indices\n", + "\n", + "\n", + "@jax.jit\n", + "@functools.partial(jax.vmap, in_axes=(None, 0, 0))\n", + "def transform(xs, cov, loc):\n", + " v, s, _ = jnp.linalg.svd(cov)\n", + " return (v @ (jnp.sqrt(s) * xs).T).T + loc\n", + "\n", + "\n", + "@jax.jit\n", + "@functools.partial(jax.vmap, in_axes=(None, 0, 0))\n", + "def transform_pose(xs, quat, loc):\n", + " return Rotation(quat).apply(xs) + loc\n", + "\n", + "\n", + "@jax.jit\n", + "@functools.partial(jax.vmap, in_axes=(1,))\n", + "def get_loc_cov(xs):\n", + " return (\n", + " xs.mean(0),\n", + " jnp.cov(xs, rowvar=False),\n", + " )\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class PointsDisplay:\n", + " def __init__(self, positions, colors, point_size=4.0):\n", + " self.point_size = point_size\n", + "\n", + " point_material = p3.ShaderMaterial(\n", + " vertexShader=POINT_VERTEX,\n", + " fragmentShader=POINT_FRAGMENT,\n", + " )\n", + "\n", + " self.points_geometry = p3.BufferGeometry(\n", + " attributes={\n", + " \"position\": p3.BufferAttribute(array=positions),\n", + " \"color\": p3.BufferAttribute(array=colors),\n", + " \"size\": p3.BufferAttribute(\n", + " array=self.point_size * np.ones(colors.shape[0], dtype=np.float32)\n", + " ),\n", + " }\n", + " )\n", + " self.points = p3.Points(\n", + " self.points_geometry,\n", + " point_material,\n", + " )\n", + "\n", + " def set_state(\n", + " self,\n", + " positions,\n", + " size=None,\n", + " ):\n", + " self.points_geometry.attributes[\"position\"].array = positions\n", + "\n", + " def set_mask(self, mask):\n", + " self.points_geometry.attributes[\"size\"].array = self.point_size * mask.astype(\n", + " np.float32\n", + " )\n", + "\n", + " @property\n", + " def objects(self):\n", + " return [self.points]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class CameraDisplay:\n", + " def __init__(\n", + " self,\n", + " positions,\n", + " quaternions,\n", + " color,\n", + " size=0.05,\n", + " ):\n", + " self.vertices, self.indices = camera_frustum()\n", + " self.vertices = size * self.vertices\n", + " point_material = p3.ShaderMaterial(\n", + " vertexShader=POINT_VERTEX,\n", + " fragmentShader=POINT_FRAGMENT,\n", + " wireframe=True,\n", + " )\n", + "\n", + " self.cameras_geometry = p3.BufferGeometry(\n", + " attributes={\n", + " \"position\": p3.BufferAttribute(\n", + " array=transform_pose(\n", + " self.vertices,\n", + " quaternions,\n", + " positions,\n", + " )\n", + " ),\n", + " \"color\": p3.BufferAttribute(\n", + " array=np.repeat(\n", + " np.asarray(color)[np.newaxis],\n", + " positions.shape[0] * len(self.vertices),\n", + " axis=0,\n", + " ).astype(np.float32)\n", + " ),\n", + " \"size\": p3.BufferAttribute(\n", + " array=np.ones(\n", + " positions.shape[0] * len(self.vertices),\n", + " dtype=np.float32,\n", + " )\n", + " ),\n", + " \"index\": p3.BufferAttribute(\n", + " array=(\n", + " self.indices[np.newaxis]\n", + " + len(self.vertices)\n", + " * np.arange(positions.shape[0])[:, jnp.newaxis]\n", + " )\n", + " .astype(np.uint32)\n", + " .ravel(),\n", + " ),\n", + " }\n", + " )\n", + " self.cameras = p3.Mesh(\n", + " self.cameras_geometry,\n", + " point_material,\n", + " )\n", + "\n", + " def set_state(\n", + " self,\n", + " positions,\n", + " quaternions,\n", + " ):\n", + " self.cameras_geometry.attributes[\"position\"].array = transform_pose(\n", + " self.vertices,\n", + " quaternions,\n", + " positions,\n", + " )\n", + "\n", + " def set_mask(self, mask):\n", + " self.cameras_geometry.attributes[\"size\"].array = np.repeat(\n", + " mask.astype(np.float32),\n", + " np.full(mask.shape[0], len(self.vertices)),\n", + " axis=0,\n", + " )\n", + "\n", + " @property\n", + " def objects(self):\n", + " return [self.cameras]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class BlobDisplay:\n", + " def __init__(\n", + " self,\n", + " positions,\n", + " covariances,\n", + " colors,\n", + " ):\n", + " self.vertices, self.indices = octahedron()\n", + " point_material = p3.ShaderMaterial(\n", + " vertexShader=POINT_VERTEX,\n", + " fragmentShader=POINT_FRAGMENT,\n", + " )\n", + "\n", + " self.blobs_geometry = p3.BufferGeometry(\n", + " attributes={\n", + " \"position\": p3.BufferAttribute(\n", + " array=transform(\n", + " self.vertices,\n", + " covariances,\n", + " positions,\n", + " )\n", + " ),\n", + " \"color\": p3.BufferAttribute(\n", + " array=np.repeat(\n", + " colors,\n", + " np.full(colors.shape[0], len(self.vertices)),\n", + " axis=0,\n", + " )\n", + " ),\n", + " \"size\": p3.BufferAttribute(\n", + " array=np.ones(\n", + " colors.shape[0] * len(self.vertices),\n", + " dtype=np.float32,\n", + " )\n", + " ),\n", + " \"index\": p3.BufferAttribute(\n", + " array=(\n", + " self.indices[np.newaxis]\n", + " + len(self.vertices)\n", + " * np.arange(colors.shape[0])[:, jnp.newaxis]\n", + " )\n", + " .astype(np.uint32)\n", + " .ravel(),\n", + " ),\n", + " }\n", + " )\n", + " self.blobs = p3.Mesh(\n", + " self.blobs_geometry,\n", + " point_material,\n", + " )\n", + "\n", + " def set_state(\n", + " self,\n", + " positions,\n", + " covariances,\n", + " ):\n", + " self.blobs_geometry.attributes[\"position\"].array = transform(\n", + " self.vertices,\n", + " covariances,\n", + " positions,\n", + " )\n", + "\n", + " def set_mask(self, mask):\n", + " self.blobs_geometry.attributes[\"size\"].array = np.repeat(\n", + " mask.astype(np.float32),\n", + " np.full(mask.shape[0], len(self.vertices)),\n", + " axis=0,\n", + " )\n", + "\n", + " @property\n", + " def objects(self):\n", + " return [self.blobs]\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class SceneRenderer:\n", + " def __init__(self, objects, up=[0, 0, 1]):\n", + " width = 800\n", + " height = 600\n", + "\n", + " camera = p3.PerspectiveCamera(\n", + " position=[5, 5, 5],\n", + " up=up,\n", + " aspect=width / height,\n", + " )\n", + " # grid = p3.GridHelper(10, 10)\n", + " # grid.rotateX(np.pi / 2)\n", + " self.scene = p3.Scene(\n", + " children=[camera, p3.AxesHelper(1)] + objects, background=\"black\"\n", + " )\n", + " self.renderer = p3.Renderer(\n", + " camera=camera,\n", + " scene=self.scene,\n", + " controls=[p3.OrbitControls(controlling=camera)],\n", + " width=width,\n", + " height=height,\n", + " )\n", + "\n", + " def _ipython_display_(self):\n", + " display(self.renderer)" + ] + }, + { + "cell_type": "markdown", + "id": "b1aa9d0d-ab50-49ba-9fdf-0fb9d814e149", + "metadata": {}, + "source": [ + "## DirectionRadius" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "95220046-9a0d-49fc-b569-9da736c79566", + "metadata": {}, + "outputs": [], + "source": [ + "class DirectionRadius(tfd.Distribution):\n", + " def __init__(\n", + " self,\n", + " ndims,\n", + " sphere_dist,\n", + " radius_dist,\n", + " allow_nan_stats=True,\n", + " validate_args=False,\n", + " name=\"DirectionRadius\",\n", + " ):\n", + " parameters = dict(locals())\n", + " self.ndims = ndims\n", + " self.sphere_dist = sphere_dist\n", + " self.radius_dist = radius_dist\n", + " super().__init__(\n", + " dtype=radius_dist.dtype,\n", + " reparameterization_type=tfd.FULLY_REPARAMETERIZED,\n", + " allow_nan_stats=allow_nan_stats,\n", + " validate_args=validate_args,\n", + " parameters=parameters,\n", + " name=name,\n", + " )\n", + "\n", + " def _parameter_properties(self, dtype=None, num_classes=None):\n", + " return dict(\n", + " sphere_dist=tfp.util.BatchedComponentProperties(),\n", + " radius_dist=tfp.util.BatchedComponentProperties(),\n", + " )\n", + "\n", + " def _sample_n(self, n, seed):\n", + " pos_seed, rad_seed = jax.random.split(seed)\n", + " if self.sphere_dist is None:\n", + " pos = jax.random.normal(\n", + " pos_seed,\n", + " (\n", + " n,\n", + " self.ndims,\n", + " ),\n", + " self.dtype,\n", + " )\n", + " # TODO: Properly handle sampling the origin.\n", + " pos /= jnp.maximum(\n", + " jnp.finfo(self.dtype).eps, jnp.linalg.norm(pos, axis=-1, keepdims=True)\n", + " )\n", + " else:\n", + " pos = self.sphere_dist.sample(n, seed=pos_seed)\n", + " rad = self.radius_dist.sample(n, seed=rad_seed)\n", + " return rad[:, jnp.newaxis] * pos\n", + "\n", + " def _log_prob(self, x):\n", + " rad = jnp.linalg.norm(x, axis=-1)\n", + " n = self.ndims\n", + " if self.sphere_dist is None:\n", + " log_z = (\n", + " jnp.log(2).astype(self.dtype)\n", + " + n / 2.0 * jnp.log(jnp.pi).astype(self.dtype)\n", + " - jax.scipy.special.gammaln(n / 2)\n", + " )\n", + " sphere_lp = -log_z\n", + " else:\n", + " sphere_lp = self.sphere_dist.log_prob(x / rad[..., jnp.newaxis])\n", + " # TODO: Properly handle evaluating at the origin.\n", + " res = (\n", + " self.radius_dist.log_prob(rad)\n", + " - (n - 1) * jnp.log(rad).astype(self.dtype)\n", + " + sphere_lp\n", + " )\n", + " return res\n", + "\n", + " @property\n", + " def event_shape(self):\n", + " return tfp.tf2jax.TensorShape([self.ndims])\n", + "\n", + " def event_shape_tensor(self):\n", + " return jnp.asarray(self.event_shape)" + ] + }, + { + "cell_type": "markdown", + "id": "d5ff0ac0-f6d5-4eb0-b2b4-5e5056191065", + "metadata": {}, + "source": [ + "## DonutDist" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "be549d2e-2a79-4b33-988d-19c5770e87a6", + "metadata": {}, + "outputs": [], + "source": [ + "def make_donut_dist(n, loc, dir, conc, r, k):\n", + " dd = tfd.PowerSpherical(dir, conc)\n", + " # rd = tfd.Chi2(k)\n", + " rd = tfd.Gamma(k, 1.0)\n", + " return tfb.Chain([tfb.Shift(loc), tfb.Scale(r / rd.mode())])(\n", + " DirectionRadius(n, dd, rd)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "d579234f-1501-49e5-bbe1-19e6a43146a5", + "metadata": {}, + "source": [ + "## InverseGamma" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7e82592a-211d-436c-b1e4-64997cbb0719", + "metadata": {}, + "outputs": [], + "source": [ + "d = tfd.InverseGamma(jnp.array(2.0, DTYPE), 1.0)\n", + "inverse_gamma_bij = d.experimental_default_event_space_bijector()\n", + "\n", + "\n", + "def make_unc_inverse_gamma(*args):\n", + " return tfb.Invert(inverse_gamma_bij)(tfd.InverseGamma(*args))\n", + "\n", + "\n", + "observation_noise_scale_bij = inverse_gamma_bij" + ] + }, + { + "cell_type": "markdown", + "id": "b73fa2bc-ae62-4326-ac9d-9bee6de6ffc9", + "metadata": {}, + "source": [ + "## Objects" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f0d0805b-1f60-4140-8c11-0dadd8f93b7d", + "metadata": {}, + "outputs": [], + "source": [ + "COLLISION_EPS = 1e-3\n", + "\n", + "\n", + "class Cuboid(NamedTuple):\n", + " position: jax.Array\n", + " size: jax.Array\n", + " color: jax.Array\n", + "\n", + " def min(self):\n", + " return self.position - self.size / 2\n", + "\n", + " def max(self):\n", + " return self.position + self.size / 2\n", + "\n", + " def contains(self, point: jax.Array) -> jax.Array:\n", + " return (\n", + " (point > (self.min() + COLLISION_EPS))\n", + " & (point < (self.max() - COLLISION_EPS))\n", + " ).all()\n", + "\n", + " def spawn_points(self, num_points, seed):\n", + " points = jax.random.normal(seed, [num_points, 3])\n", + " # This isn't a great way to do this, density is not uniform on each face.\n", + " points /= jnp.linalg.norm(points, axis=-1, ord=jnp.inf, keepdims=True)\n", + " return self.position + self.size / 2 * points, jnp.broadcast_to(\n", + " self.color, [num_points, 3]\n", + " )\n", + "\n", + "\n", + "class Sphere(NamedTuple):\n", + " position: jax.Array\n", + " size: jax.Array\n", + " color: jax.Array\n", + "\n", + " def contains(self, point: jax.Array) -> jax.Array:\n", + " return (\n", + " jnp.linalg.norm(point - self.position, axis=-1)\n", + " < self.size / 2 - COLLISION_EPS\n", + " )\n", + "\n", + " def spawn_points(self, num_points, seed):\n", + " points = jax.random.normal(seed, [num_points, 3])\n", + " points /= jnp.linalg.norm(points, axis=-1, keepdims=True)\n", + " return self.position + self.size / 2 * points, jnp.broadcast_to(\n", + " self.color, [num_points, 3]\n", + " )\n", + "\n", + "\n", + "class MultiObject(NamedTuple):\n", + " objects: Any\n", + "\n", + " def contains(self, point: jax.Array) -> jax.Array:\n", + " contains = jnp.array(False)\n", + " for obj in self.objects:\n", + " contains |= obj.contains(point)\n", + " return contains\n", + "\n", + " def spawn_points(self, num_points, seed):\n", + " all_points = []\n", + " all_rgbs = []\n", + " for i, obj in enumerate(self.objects):\n", + " n = (i + 1) * num_points // (len(self.objects)) - i * num_points // (\n", + " len(self.objects)\n", + " )\n", + " points, rgbs = obj.spawn_points(n, jax.random.fold_in(seed, i))\n", + " all_points.append(points)\n", + " all_rgbs.append(rgbs)\n", + " return jnp.concatenate(all_points, 0), jnp.concatenate(all_rgbs, 0)\n", + "\n", + "\n", + "def cast_ray(source, target, obj, num_points=50):\n", + " t = jnp.linspace(0.0, 1.0, num_points)\n", + " points = source + (target - source) * t[:, jnp.newaxis]\n", + " hit = jax.vmap(obj.contains)(points)\n", + " return hit.any()\n", + "\n", + "\n", + "cast_ray_one_frame = jax.vmap(cast_ray, in_axes=(None, 0, None))" + ] + }, + { + "cell_type": "markdown", + "id": "8a5ed230-5a5e-4052-bf97-930925f64e55", + "metadata": {}, + "source": [ + "## Effect Handling" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b6dfce97-903e-4365-8e0a-acd4b4b72bcc", + "metadata": {}, + "outputs": [], + "source": [ + "T = TypeVar(\"T\")\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class Effect:\n", + " name: str\n", + "\n", + " def set_value(self, value: Any) -> Any:\n", + " raise NotImplementedError(f\"{type(self)}\")\n", + "\n", + " def value(self) -> Any:\n", + " raise NotImplementedError(f\"{type(self)}\")\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class SampleEffect(Effect):\n", + " dist: tfd.Distribution\n", + "\n", + " def set_value(self, value: Any) -> \"SampleValueEffect\":\n", + " return SampleValueEffect(name=self.name, dist=self.dist, value_=value)\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class SampleValueEffect(Effect):\n", + " dist: tfd.Distribution\n", + " value_: Optional[Any] = None\n", + "\n", + " def set_value(self, value: Any) -> \"SampleValueEffect\":\n", + " return dataclasses.replace(self, value_=value)\n", + "\n", + " def value(self):\n", + " return self.value_\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class Handler(metaclass=abc.ABCMeta):\n", + " @abc.abstractmethod\n", + " def __call__(self, effect: Effect) -> tuple[Any, Effect]:\n", + " pass\n", + "\n", + " def result(self) -> dict[str, Any]:\n", + " return {}\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class LogProb(Handler):\n", + " log_prob: jnp.ndarray = dataclasses.field(\n", + " default_factory=lambda: jnp.zeros([], DTYPE)\n", + " )\n", + "\n", + " def __call__(self, effect: Effect) -> tuple[Any, Effect]:\n", + " res = self\n", + " if isinstance(effect, SampleValueEffect):\n", + " res = dataclasses.replace(\n", + " res, log_prob=res.log_prob + effect.dist.log_prob(effect.value())\n", + " )\n", + " return res, effect\n", + "\n", + " def result(self):\n", + " return {\"log_prob\": self.log_prob}\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class Sample(Handler):\n", + " seed: jax.Array\n", + "\n", + " def __call__(self, effect: Effect) -> tuple[Any, Effect]:\n", + " res = self\n", + " if isinstance(effect, SampleEffect):\n", + " new_seed, seed = jax.random.split(self.seed)\n", + " res = dataclasses.replace(res, seed=new_seed)\n", + " effect = SampleValueEffect(\n", + " name=effect.name,\n", + " dist=effect.dist,\n", + " value_=effect.dist.sample(seed=seed),\n", + " )\n", + " return res, effect\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class SetValues(Handler):\n", + " values: dict[str, jnp.ndarray]\n", + "\n", + " def __call__(self, effect: Effect) -> tuple[Any, Effect]:\n", + " value = self.values.get(effect.name)\n", + " if value is not None:\n", + " effect = effect.set_value(value)\n", + " return self, effect\n", + "\n", + "\n", + "@dataclasses.dataclass\n", + "class Collect(Handler):\n", + " get_fn: Callable[[Effect], Any] = lambda x: x\n", + " filter_fn: Callable[[Effect], bool] = lambda x: True\n", + " results: dict[str, Any] = dataclasses.field(default_factory=dict)\n", + "\n", + " def __call__(self, effect: Effect) -> tuple[Any, Effect]:\n", + " res = self\n", + " if self.filter_fn(effect):\n", + " res = dataclasses.replace(\n", + " res, results={effect.name: self.get_fn(effect), **res.results}\n", + " )\n", + " return res, effect\n", + "\n", + " def result(self):\n", + " return {\"results\": self.results}\n", + "\n", + "\n", + "_handler_stack = []\n", + "\n", + "\n", + "@contextlib.contextmanager\n", + "def apply_handlers(*handlers: Handler):\n", + " global _handler_stack\n", + " old_len = len(_handler_stack)\n", + " _handler_stack.extend(handlers)\n", + " res = {}\n", + " try:\n", + " yield res\n", + " finally:\n", + " for handler in _handler_stack[old_len:]:\n", + " res.update(handler.result())\n", + " _handler_stack = _handler_stack[:old_len]\n", + "\n", + "\n", + "def effect(effect: Effect) -> Any:\n", + " for i in range(len(_handler_stack)):\n", + " _handler_stack[i], effect = _handler_stack[i](effect)\n", + " return effect.value()\n", + "\n", + "\n", + "def sample(name: str, dist: tfd.Distribution) -> jnp.ndarray:\n", + " return effect(SampleEffect(name=name, dist=dist))\n", + "\n", + "\n", + "def model_sample(\n", + " model_fn: Callable[[], T], seed: jax.Array\n", + ") -> tuple[dict[str, Any], T]:\n", + " with apply_handlers(Sample(seed), Collect(lambda e: e.value())) as trace:\n", + " res = model_fn()\n", + "\n", + " return trace[\"results\"], res\n", + "\n", + "\n", + "def model_cond_sample(\n", + " model_fn: Callable[[], T], value: dict[str, Any], seed: jax.Array\n", + ") -> tuple[dict[str, Any], T]:\n", + " with apply_handlers(\n", + " SetValues(value), Sample(seed), Collect(lambda e: e.value())\n", + " ) as trace:\n", + " res = model_fn()\n", + "\n", + " return trace[\"results\"], res\n", + "\n", + "\n", + "def model_log_prob(\n", + " model_fn: Callable[[], T], value: dict[str, Any]\n", + ") -> tuple[jnp.ndarray, T]:\n", + " with apply_handlers(SetValues(value), LogProb()) as trace:\n", + " res = model_fn()\n", + "\n", + " return trace[\"log_prob\"], res\n", + "\n", + "\n", + "def model_log_prob_ratio(\n", + " model_fn: Callable[[], T],\n", + " value1: dict[str, Any],\n", + " value2: dict[str, Any],\n", + ") -> tuple[jnp.ndarray, T]:\n", + " with apply_handlers(\n", + " SetValues(value1), Collect(lambda e: (e.dist, e.value()))\n", + " ) as trace1:\n", + " res1 = model_fn()\n", + "\n", + " with apply_handlers(\n", + " SetValues(value2), Collect(lambda e: (e.dist, e.value()))\n", + " ) as trace2:\n", + " res2 = model_fn()\n", + "\n", + " log_prob_ratio = 0\n", + " for k in trace1[\"results\"].keys():\n", + " d1, x1 = trace1[\"results\"][k]\n", + " d2, x2 = trace2[\"results\"][k]\n", + " log_prob_ratio += tfp.experimental.distributions.log_prob_ratio(d1, x1, d2, x2)\n", + "\n", + " return log_prob_ratio, [res1, res2]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ac77ac27-ac35-4803-8e44-64be52c387c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-2.7931314 -3.092115 0.29898357\n", + "0.2989837\n" + ] + } + ], + "source": [ + "def model():\n", + " x = sample(\"x\", tfd.Normal(0.0, 1.0))\n", + " y = sample(\"y\", tfd.Normal(x, 1.0))\n", + " return [x, y]\n", + "\n", + "\n", + "s1, _ = model_sample(model, jax.random.key(0))\n", + "s2, _ = model_sample(model, jax.random.key(1))\n", + "lp1 = model_log_prob(model, s1)[0]\n", + "lp2 = model_log_prob(model, s2)[0]\n", + "print(lp1, lp2, lp1 - lp2)\n", + "print(model_log_prob_ratio(model, s1, s2)[0])" + ] + }, + { + "cell_type": "markdown", + "id": "8d3e3546-21d7-49c3-9dcc-17860d1ca5df", + "metadata": {}, + "source": [ + "## UI Hyperparameter" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "edac84b0-a3c6-42b3-9ef1-d22bc34ff8a3", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclasses.dataclass\n", + "class Hyperparameter:\n", + " value: Any\n", + " min: Any = None\n", + " max: Any = None\n", + " log_scale: bool = False\n", + "\n", + "\n", + "def make_hyperparameter_widget(\n", + " hparam,\n", + " name,\n", + " output=contextlib.nullcontext(),\n", + " callback_fn=lambda _: None,\n", + " toggle_style=\"\",\n", + " toggle_icons=(\"check-circle-o\", \"circle-o\"),\n", + "):\n", + " integer = np.issubdtype(np.array(hparam.value).dtype, np.integer)\n", + " boolean = np.issubdtype(np.array(hparam.value).dtype, np.bool_)\n", + "\n", + " def toggle_icon(val):\n", + " if val:\n", + " return toggle_icons[0]\n", + " else:\n", + " return toggle_icons[1]\n", + "\n", + " def on_value_change(change):\n", + " try:\n", + " hparam.value = change[\"new\"]\n", + " if boolean:\n", + " widget.icon = toggle_icon(hparam.value)\n", + " callback_fn(hparam.value)\n", + " except Exception:\n", + " with output:\n", + " print(traceback.format_exc())\n", + "\n", + " if boolean:\n", + " widget = ipywidgets.ToggleButton(\n", + " value=hparam.value,\n", + " description=name,\n", + " icon=toggle_icon(hparam.value),\n", + " button_style=toggle_style,\n", + " )\n", + "\n", + " elif integer:\n", + " widget = ipywidgets.IntSlider(\n", + " value=hparam.value,\n", + " min=hparam.min,\n", + " max=hparam.max,\n", + " description=name,\n", + " layout=ipywidgets.Layout(width=\"500px\"),\n", + " style={\"description_width\": \"200px\"},\n", + " )\n", + " elif hparam.log_scale:\n", + " widget = ipywidgets.FloatLogSlider(\n", + " value=hparam.value,\n", + " base=10,\n", + " min=np.log10(hparam.min),\n", + " max=np.log10(hparam.max),\n", + " step=0.05,\n", + " description=name,\n", + " layout=ipywidgets.Layout(width=\"500px\"),\n", + " style={\"description_width\": \"200px\"},\n", + " )\n", + " else:\n", + " widget = ipywidgets.FloatSlider(\n", + " value=hparam.value,\n", + " min=hparam.min,\n", + " max=hparam.max,\n", + " description=name,\n", + " layout=ipywidgets.Layout(width=\"500px\"),\n", + " style={\"description_width\": \"200px\"},\n", + " )\n", + " widget.observe(on_value_change, names=\"value\")\n", + " return widget" + ] + }, + { + "cell_type": "markdown", + "id": "84f2c557-aa3a-4358-b966-0e67f7bbae2c", + "metadata": {}, + "source": [ + "# Synthetic Data" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b72b1f21-1893-41d4-9acd-078603fd0e3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SCENE.num_frames=100, SCENE.num_keypoints=558\n", + "num object points 4\n" + ] + } + ], + "source": [ + "scene_obj = MultiObject(\n", + " [\n", + " Cuboid(\n", + " position=jnp.array([0.0, 0.0, 1.0]),\n", + " size=jnp.array([1.0, 2.0, 3.0]),\n", + " color=COLORS_NP[0],\n", + " ),\n", + " Cuboid(\n", + " position=jnp.array([0.0, 0.0, 1.0]),\n", + " size=jnp.array([3.0, 1.0, 1.0]),\n", + " color=COLORS_NP[1],\n", + " ),\n", + " Sphere(\n", + " position=jnp.array([0.0, 1.0, 0.0]),\n", + " size=2.0,\n", + " color=COLORS_NP[2],\n", + " ),\n", + " ]\n", + ")\n", + "\n", + "num_frames = 100\n", + "raw_t = jnp.linspace(-1.0, 1.0, num_frames)\n", + "t = (1 + jnp.sign(raw_t) * jnp.abs(raw_t) ** 0.7) / 2\n", + "theta = jnp.pi / 4 + t * 3 * jnp.pi / 4\n", + "r = jnp.linspace(3.0, 4.0, num_frames)\n", + "x = r * jnp.cos(theta)\n", + "y = r * jnp.sin(theta)\n", + "z = -0.5 + t + jnp.cos(theta * 3)\n", + "camera_positions = jnp.stack([x, y, z], -1)\n", + "camera_quaternions = jax.vmap(look_at_quat, in_axes=(0, None))(\n", + " camera_positions, jnp.zeros(3)\n", + ")\n", + "camera_poses = Pose(camera_positions, camera_quaternions)\n", + "\n", + "SCENE = make_scene(scene_obj, camera_poses, 1000)\n", + "print(f\"{SCENE.num_frames=}, {SCENE.num_keypoints=}\")\n", + "\n", + "object_mask = SCENE.keypoint_visibility[0]\n", + "uv = SCENE.keypoint_screen_positions[0]\n", + "r = 0.07\n", + "object_mask = (\n", + " object_mask & (uv[:, 0] > -r) & (uv[:, 0] < +r) & (uv[:, 1] > -r) & (uv[:, 1] < +r)\n", + ")\n", + "object_positions = jnp.where(\n", + " object_mask[:, jnp.newaxis], SCENE.keypoint_world_positions, jnp.nan\n", + ")\n", + "print(\"num object points\", object_mask.sum())\n", + "\n", + "SCENE_INFO = SceneInfo(object_mask=object_mask, object_positions=object_positions)" + ] + }, + { + "cell_type": "markdown", + "id": "68385fef-8ab1-4b19-a78d-7e6768c2e468", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "907ec92f-3a10-4961-a53a-1a581d164880", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "79316223f395456a9b519b9307d0179b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "frames = []\n", + "\n", + "for f in tqdm.notebook.tqdm(range(SCENE.num_frames)):\n", + " fig, ax = plt.subplots()\n", + " ax.set_xlim(-1, 1)\n", + " ax.set_ylim(-1, 1)\n", + " xy = SCENE.keypoint_screen_positions[f, SCENE.keypoint_visibility[f]]\n", + " c = np.where(SCENE.keypoint_visibility[f])[0]\n", + " ax.scatter(\n", + " xy[:, 0],\n", + " xy[:, 1],\n", + " c=SCENE.keypoint_colors[SCENE.keypoint_visibility[f]],\n", + " s=2,\n", + " )\n", + " ax.set_title(f\"Frame {f}\")\n", + " ax.set_aspect(\"equal\")\n", + " fig.canvas.draw()\n", + " frames.append(np.array(fig.canvas.buffer_rgba())[..., :3])\n", + " plt.close(fig)\n", + "mediapy.show_video(frames, fps=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "35808b77-4515-45bc-b69b-e262c54063a3", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fc8a042cc55e44ec88efb0010589f417", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e769f91833204616b6a1eab3b13e5a16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(Label(value='Frame'), IntSlider(value=100, min=1)))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d22dfd988cfb49308f44742c25215d29", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Renderer(camera=PerspectiveCamera(aspect=1.3333333333333333, position=(5.0, 5.0, 5.0), projectionMatrix=(1.0, …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "scene_points = PointsDisplay(\n", + " positions=SCENE.keypoint_world_positions,\n", + " colors=SCENE.keypoint_colors,\n", + " point_size=4,\n", + ")\n", + "\n", + "scene_blobs = BlobDisplay(\n", + " positions=SCENE.keypoint_world_positions,\n", + " covariances=np.repeat(0.01 * np.eye(3)[np.newaxis], SCENE.num_keypoints, axis=0),\n", + " colors=SCENE.keypoint_colors,\n", + ")\n", + "scene_blobs.set_mask(SCENE_INFO.object_mask)\n", + "\n", + "scene_camera = CameraDisplay(\n", + " positions=SCENE.camera_poses.position,\n", + " quaternions=SCENE.camera_poses.quaternion,\n", + " color=np.array([1.0, 0.0, 0.0]),\n", + ")\n", + "\n", + "scene_renderer = SceneRenderer(\n", + " scene_points.objects + scene_camera.objects + scene_blobs.objects\n", + ")\n", + "output = ipywidgets.Output()\n", + "slider = ipywidgets.IntSlider(\n", + " value=SCENE.num_frames,\n", + " min=1,\n", + " max=SCENE.num_frames,\n", + ")\n", + "\n", + "\n", + "def on_value_change(change):\n", + " try:\n", + " scene_points.set_mask(SCENE.keypoint_visibility[: change[\"new\"]].any(0))\n", + " scene_camera.set_mask(np.arange(SCENE.num_frames) < change[\"new\"])\n", + " except Exception as e:\n", + " with output:\n", + " print(e)\n", + "\n", + "\n", + "on_value_change({\"new\": SCENE.num_frames})\n", + "\n", + "slider.observe(on_value_change, names=\"value\")\n", + "\n", + "display(\n", + " output,\n", + " ipywidgets.HBox([ipywidgets.Label(\"Frame\"), slider]),\n", + " scene_renderer.renderer,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "65ae8b68-8099-44d2-b6c3-2c837d278d7d", + "metadata": {}, + "source": [ + "# Model" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "b31f3bc8-048c-470a-9ba6-fa699aed8c61", + "metadata": {}, + "outputs": [], + "source": [ + "class ModelArgs(NamedTuple):\n", + " camera_visibility: jax.Array\n", + " keypoint_visibility: jax.Array\n", + " observation_noise_degrees: jax.Array\n", + " center: jax.Array\n", + " radius: jax.Array\n", + " first_camera_pose: Pose\n", + " object_mask: jax.Array\n", + " object_positions: jax.Array\n", + " object_prior_scale: jax.Array\n", + "\n", + "\n", + "@dataclasses.dataclass(frozen=True)\n", + "class Model:\n", + " world_prior: str\n", + " camera_prior: str\n", + " num_frames: int\n", + " num_keypoints: int\n", + "\n", + " def model(self, args):\n", + " match self.world_prior:\n", + " case \"scale_free\":\n", + " n = self.num_keypoints * 3\n", + " raw_xyz = sample(\n", + " \"raw_keypoint_world_positions\",\n", + " make_donut_dist(\n", + " n,\n", + " jnp.zeros(n, DTYPE), # loc\n", + " jnp.zeros(n, DTYPE), # dir\n", + " jnp.array(0.0, DTYPE), # conc\n", + " jnp.array(args.radius, DTYPE), # rad\n", + " jnp.array(50.0, DTYPE), # k\n", + " ),\n", + " )\n", + " xyz = args.radius * raw_xyz / jnp.linalg.norm(raw_xyz, axis=-1)\n", + " xyz = xyz.reshape([self.num_keypoints, 3])\n", + " case \"pseudo_object\":\n", + " loc = jnp.zeros((self.num_keypoints, 3), DTYPE)\n", + " scale = jnp.full((self.num_keypoints, 3), args.radius)\n", + " loc = jnp.where(\n", + " args.object_mask[:, jnp.newaxis], args.object_positions, loc\n", + " )\n", + " # TODO: Constrain based on disparity?\n", + " scale = jnp.where(\n", + " args.object_mask[:, jnp.newaxis], args.object_prior_scale, scale\n", + " )\n", + "\n", + " xyz = sample(\n", + " \"keypoint_world_positions\",\n", + " tfd.Independent(tfd.Normal(loc, scale), 2),\n", + " )\n", + " match self.camera_prior:\n", + " case \"relative_noncentered\":\n", + " raise NotImplementedError()\n", + " case \"relative_centered\":\n", + " raise NotImplementedError()\n", + " case \"independent\":\n", + " camera_position = sample(\n", + " \"camera_positions\",\n", + " tfd.Independent(\n", + " tfd.Normal(\n", + " jnp.zeros((self.num_frames - 1, 3), DTYPE),\n", + " 20.0 * jnp.ones((self.num_frames - 1, 3), DTYPE),\n", + " ),\n", + " 2,\n", + " experimental_use_kahan_sum=True,\n", + " ),\n", + " )\n", + "\n", + " camera_raw_quaternion = sample(\n", + " \"camera_raw_quaternions\",\n", + " tfd.Sample(\n", + " make_donut_dist(\n", + " 4,\n", + " jnp.zeros(4, DTYPE), # loc\n", + " jnp.array([0.0, 0.0, 0.0, 1.0], DTYPE), # dir\n", + " jnp.array(0.0, DTYPE), # conc\n", + " jnp.array(1.0, DTYPE), # rad\n", + " jnp.array(20.0, DTYPE), # k\n", + " ),\n", + " self.num_frames - 1,\n", + " experimental_use_kahan_sum=True,\n", + " ),\n", + " )\n", + " camera_poses = Pose(camera_position, camera_raw_quaternion).normalize()\n", + "\n", + " camera_poses = jax.tree.map(\n", + " lambda x, y: jnp.concatenate([x[jnp.newaxis].astype(DTYPE), y], 0),\n", + " args.first_camera_pose,\n", + " camera_poses,\n", + " )\n", + "\n", + " if self.camera_prior == \"relative_noncentered\":\n", + "\n", + " def body(cur_pose, pose):\n", + " cur_pose = cur_pose.compose(pose)\n", + " return cur_pose, cur_pose\n", + "\n", + " _, camera_poses = jax.lax.scan(body, Pose.identity(), camera_poses)\n", + "\n", + " uv_loc = jax.vmap(lambda cp: screen_from_camera(xyz, cp))(camera_poses)\n", + "\n", + " raw_observation_noise_scale = sample(\n", + " \"raw_observation_noise_scale\",\n", + " make_unc_inverse_gamma(jnp.array(2.0, DTYPE), 0.01),\n", + " )\n", + " observation_noise_scale = observation_noise_scale_bij(\n", + " raw_observation_noise_scale\n", + " )\n", + "\n", + " uv = sample(\n", + " \"keypoint_screen_positions\",\n", + " tfd.Independent(\n", + " tfd.Masked(\n", + " tfd.StudentT(\n", + " args.observation_noise_degrees,\n", + " uv_loc,\n", + " observation_noise_scale,\n", + " ),\n", + " (args.keypoint_visibility)[..., jnp.newaxis],\n", + " ),\n", + " 3,\n", + " experimental_use_kahan_sum=True,\n", + " ),\n", + " )\n", + "\n", + " return {\n", + " \"keypoint_world_positions\": xyz,\n", + " \"camera_poses\": camera_poses,\n", + " \"keypoint_screen_positions\": uv,\n", + " \"observation_noise_scale\": observation_noise_scale,\n", + " \"l1_errors\": jnp.linalg.norm(uv - uv_loc, axis=-1, ord=1),\n", + " }\n", + "\n", + " @functools.partial(jax.jit, static_argnums=(0,))\n", + " def eval_model(self, latents, model_args):\n", + " with apply_handlers(SetValues(latents), Sample(jax.random.key(0))) as trace:\n", + " return self.model(model_args)\n", + "\n", + " @functools.partial(jax.jit, static_argnums=(0,))\n", + " def target_log_prob_fn(self, latents, cond_latents, cond_mask, model_args):\n", + " new_cond_latents = latents.copy()\n", + " # Condition the latents\n", + " for k, v in list(cond_latents.items()):\n", + " mask = cond_mask.get(k)\n", + " if mask is None:\n", + " new_cond_latents[k] = v\n", + " else:\n", + " new_cond_latents[k] = jnp.where(mask, v, latents[k])\n", + "\n", + " # Add the observations\n", + " new_cond_latents[\"keypoint_screen_positions\"] = jnp.where(\n", + " jnp.isfinite(\n", + " new_cond_latents[\"keypoint_screen_positions\"]\n", + " ), # & model_args.keypoint_visibility[..., jnp.newaxis],\n", + " new_cond_latents[\"keypoint_screen_positions\"],\n", + " 0.0,\n", + " )\n", + " log_prob, retval = model_log_prob(\n", + " functools.partial(self.model, model_args),\n", + " new_cond_latents,\n", + " )\n", + " extra = dict(retval)\n", + "\n", + " extra[\"latents\"] = latents\n", + " return log_prob.astype(DTYPE), extra" + ] + }, + { + "cell_type": "markdown", + "id": "7219607a-fb71-4daf-89f9-8404fdb6c3e9", + "metadata": {}, + "source": [ + "## Construct" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "be781a4c-b628-4a94-ba5a-f7a9a03dd37b", + "metadata": {}, + "outputs": [], + "source": [ + "DEFAULT_MODEL_ARGS = ModelArgs(\n", + " radius=jnp.array(20.0, DTYPE),\n", + " keypoint_visibility=SCENE.keypoint_visibility,\n", + " camera_visibility=jnp.ones(SCENE.num_frames, dtype=bool),\n", + " observation_noise_degrees=jnp.array(30.0, DTYPE),\n", + " object_mask=SCENE_INFO.object_mask,\n", + " object_positions=SCENE_INFO.object_positions.astype(DTYPE),\n", + " object_prior_scale=jnp.array(0.001, DTYPE),\n", + " first_camera_pose=SCENE.camera_poses[0],\n", + " center=SCENE.camera_poses[0].position,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "2a9ecd9f-40d6-4eff-b63e-862b5f21a115", + "metadata": {}, + "outputs": [], + "source": [ + "MODEL = Model(\n", + " world_prior=\"pseudo_object\",\n", + " camera_prior=\"independent\",\n", + " num_frames=SCENE.num_frames,\n", + " num_keypoints=SCENE.num_keypoints,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f88e87a9-76e4-4703-b1b0-8545040edb15", + "metadata": {}, + "source": [ + "## Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "e8d96611-f00d-42d0-8788-d60d55610c9c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "with warnings.catch_warnings(action=\"ignore\"):\n", + " prior_sample, retval = model_sample(\n", + " functools.partial(MODEL.model, DEFAULT_MODEL_ARGS), jax.random.key(0)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "f1f4cd2c-0b8f-4230-8d6f-e30ed4ad68c3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'keypoint_screen_positions': Array([[[ 9.8028034e-01, 1.2025309e+00],\n", + " [ 3.9625895e+04, -1.9633994e+04],\n", + " [-6.3550001e-01, 1.4189218e+00],\n", + " ...,\n", + " [-1.4539595e+04, -1.3471026e+04],\n", + " [ 3.8712141e+03, 2.0664500e+04],\n", + " [-8.3644120e-03, -2.7873570e-01]],\n", + " \n", + " [[ 5.5588574e+03, -5.1534917e+03],\n", + " [-4.9692202e+00, 6.0318656e+00],\n", + " [ 1.9295523e+00, -3.1589095e-02],\n", + " ...,\n", + " [ 3.9367503e-01, 9.8350120e-01],\n", + " [ 1.3383020e+01, 1.4039549e+01],\n", + " [-7.9537235e-02, 1.3372885e-02]],\n", + " \n", + " [[ 7.0432847e+03, -4.4489027e+04],\n", + " [-2.5543211e+04, 3.3735547e+02],\n", + " [ 3.6154266e+04, -2.9825172e+04],\n", + " ...,\n", + " [ 2.4886656e+04, 1.4443941e+04],\n", + " [ 1.4470686e+04, -2.0205463e+04],\n", + " [ 6.3659363e+00, -3.0551364e+00]],\n", + " \n", + " ...,\n", + " \n", + " [[-3.4972364e-01, 4.1383820e+00],\n", + " [-3.0609584e-01, 4.6538246e-01],\n", + " [ 6.6649146e+03, 5.6897340e+04],\n", + " ...,\n", + " [ 9.0580049e+03, 1.1718721e+04],\n", + " [ 2.0873942e+00, 4.5663228e+00],\n", + " [-2.2924969e+04, 3.6215348e+04]],\n", + " \n", + " [[-8.2352705e+03, -4.2877172e+04],\n", + " [ 2.1795264e+04, 3.9726606e+03],\n", + " [-2.4623354e+01, -2.4011900e+01],\n", + " ...,\n", + " [-1.6865485e+00, 7.2222811e-01],\n", + " [-6.2754864e-01, -1.9276551e+00],\n", + " [-2.8546660e+04, -6.2597007e+03]],\n", + " \n", + " [[-4.7001494e+03, -2.3233176e+03],\n", + " [-1.3646544e+04, -2.6081701e+04],\n", + " [ 2.7502744e+04, 6.7807358e+03],\n", + " ...,\n", + " [ 3.7030660e+04, -5.4291821e+03],\n", + " [ 1.1672313e+04, 1.5654638e+04],\n", + " [ 2.5000754e+04, -2.8065387e+04]]], dtype=float32),\n", + " 'raw_observation_noise_scale': Array(131.7358, dtype=float32),\n", + " 'camera_raw_quaternions': Array([[-1.51927993e-01, -3.74685913e-01, 3.71003836e-01,\n", + " -9.43984687e-01],\n", + " [ 2.65967995e-01, -1.29529819e-01, -4.60676938e-01,\n", + " 7.04387844e-01],\n", + " [ 1.09782897e-01, 5.06159663e-01, 5.18138967e-02,\n", + " -6.41531467e-01],\n", + " [ 2.84732223e-01, -1.77640960e-01, 7.49149203e-01,\n", + " 7.00852931e-01],\n", + " [ 5.98554432e-01, 1.87838171e-02, 3.75454485e-01,\n", + " 4.62541729e-01],\n", + " [ 9.26769257e-01, -2.21802413e-01, -3.50857615e-01,\n", + " -1.87504500e-01],\n", + " [-9.44253802e-01, 2.42163181e-01, -3.21839541e-01,\n", + " -5.00077248e-01],\n", + " [ 6.60627902e-01, 6.96577847e-01, 2.22797647e-01,\n", + " -3.83844674e-01],\n", + " [ 4.45689499e-01, 2.73988694e-01, 5.38428605e-01,\n", + " 1.28328875e-02],\n", + " [ 6.27044380e-01, 1.46558329e-01, -1.09853148e+00,\n", + " -3.61354947e-01],\n", + " [ 6.32355452e-01, 6.96397662e-01, -2.53592789e-01,\n", + " -3.60669672e-01],\n", + " [-3.34680408e-01, 6.64863527e-01, -8.98923650e-02,\n", + " 8.33435655e-01],\n", + " [-6.23005033e-01, 6.29542232e-01, -1.31270781e-01,\n", + " 4.20008272e-01],\n", + " [-6.99095964e-01, -4.58210886e-01, -5.41906178e-01,\n", + " 3.13478820e-02],\n", + " [ 1.52476653e-01, -4.54365194e-01, -5.18706024e-01,\n", + " -7.80884385e-01],\n", + " [-7.93749571e-01, 9.14382815e-01, -1.45689696e-01,\n", + " 1.92474772e-03],\n", + " [-7.39528656e-01, -1.93379194e-01, 7.26059258e-01,\n", + " 5.50567508e-01],\n", + " [ 5.60432136e-01, -6.71000302e-01, -3.90102953e-01,\n", + " -7.69878253e-02],\n", + " [ 3.09779733e-01, 3.63405138e-01, 7.75692046e-01,\n", + " -3.85419935e-01],\n", + " [-8.22284818e-02, 3.58133316e-01, 5.26112080e-01,\n", + " 3.90142232e-01],\n", + " [ 5.26768155e-02, 3.64896238e-01, -1.12756062e+00,\n", + " 4.11089361e-01],\n", + " [ 2.51371592e-01, -5.90860903e-01, -3.09902430e-01,\n", + " -3.17731649e-01],\n", + " [ 3.05886179e-01, -4.80466485e-01, -8.82623255e-01,\n", + " 4.69050199e-01],\n", + " [-1.11482859e-01, -5.36642015e-01, 4.67536718e-01,\n", + " 2.37206489e-01],\n", + " [-2.06154689e-01, -2.28394255e-01, 6.38471544e-01,\n", + " -3.54722291e-01],\n", + " [ 7.64642358e-01, 6.33536100e-01, 1.93505526e-01,\n", + " -2.99535953e-02],\n", + " [-8.27196479e-01, 1.16980076e-01, 4.29756522e-01,\n", + " 1.39285713e-01],\n", + " [ 2.25784853e-01, 6.08236074e-01, -3.49070996e-01,\n", + " -1.06403983e+00],\n", + " [-4.53328848e-01, 4.69567388e-01, 4.57290590e-01,\n", + " -2.50392497e-01],\n", + " [-4.18305039e-01, -3.36433589e-01, -5.62098801e-01,\n", + " -7.08624050e-02],\n", + " [ 5.42308748e-01, 9.70694125e-01, -3.19721669e-01,\n", + " -7.72981048e-01],\n", + " [-9.53135371e-01, -2.83963114e-01, -5.31364083e-01,\n", + " 1.07515812e+00],\n", + " [-5.16796052e-01, -8.94382298e-01, 4.99305934e-01,\n", + " 3.55352849e-01],\n", + " [ 3.43881994e-01, 7.83711255e-01, 6.37095034e-01,\n", + " 4.55072701e-01],\n", + " [ 6.92560077e-01, 4.43663061e-01, 7.05655754e-01,\n", + " 1.59616515e-01],\n", + " [ 2.20697910e-01, 5.57565629e-01, 5.37921727e-01,\n", + " 1.01681697e+00],\n", + " [-3.62388432e-01, 4.92087066e-01, 8.82719271e-03,\n", + " 8.77826571e-01],\n", + " [ 1.18506873e+00, -6.90732181e-01, 2.73033887e-01,\n", + " 8.20948303e-01],\n", + " [-7.83699825e-02, 5.33433259e-01, -7.81056643e-01,\n", + " 8.31216872e-01],\n", + " [ 1.86200991e-01, -6.24620840e-02, -7.69225776e-01,\n", + " -2.43534133e-01],\n", + " [-6.57404184e-01, -6.12133622e-01, -3.63545686e-01,\n", + " 7.71833882e-02],\n", + " [-6.75333679e-01, 4.03312027e-01, -1.53848976e-01,\n", + " 2.13673621e-01],\n", + " [ 3.91451657e-01, 9.91384506e-01, 3.89287800e-01,\n", + " -3.86244096e-02],\n", + " [-6.30521715e-01, -1.71269160e-02, -6.67595625e-01,\n", + " -2.95937479e-01],\n", + " [ 3.66410673e-01, 5.22439301e-01, 8.28420877e-01,\n", + " -2.15471476e-01],\n", + " [ 4.98802483e-01, 7.69210905e-02, 3.56308609e-01,\n", + " 4.06433165e-01],\n", + " [-4.56649840e-01, 2.08892629e-01, -4.06378418e-01,\n", + " 9.12917376e-01],\n", + " [-2.10445970e-01, -1.16775863e-01, -9.56291020e-01,\n", + " -5.21333754e-01],\n", + " [ 3.17570865e-01, 8.98765385e-01, 4.37842965e-01,\n", + " -3.07674527e-01],\n", + " [-3.77784744e-02, -9.44907889e-02, -3.38173717e-01,\n", + " -2.17673585e-01],\n", + " [-6.65738285e-01, -6.94405556e-01, -9.99994874e-02,\n", + " -2.30312720e-02],\n", + " [ 3.49179834e-01, -1.23764396e+00, -5.05725324e-01,\n", + " 2.40004674e-01],\n", + " [-2.65043855e-01, -2.10349128e-01, -8.79187956e-02,\n", + " 1.01988864e+00],\n", + " [-1.75777644e-01, 3.83677214e-01, -2.58249193e-02,\n", + " -4.77984935e-01],\n", + " [ 4.32381814e-04, -7.81954288e-01, 3.01555812e-01,\n", + " 4.89282519e-01],\n", + " [-3.22460294e-01, 1.58771258e-02, -8.34118664e-01,\n", + " 7.89358094e-02],\n", + " [-6.19108617e-01, -7.22704887e-01, 9.37339306e-01,\n", + " 7.13554084e-01],\n", + " [-6.00126743e-01, -6.51083767e-01, 7.02134371e-02,\n", + " -5.91366112e-01],\n", + " [ 4.64709044e-01, -3.83766919e-01, -7.34819174e-02,\n", + " 7.23340034e-01],\n", + " [ 1.11391373e-01, 2.46987566e-01, 2.59524018e-01,\n", + " -3.93819749e-01],\n", + " [ 1.00630522e+00, 1.44116566e-01, -4.92491275e-01,\n", + " -5.36585927e-01],\n", + " [ 2.48890325e-01, 5.19609511e-01, 1.87581316e-01,\n", + " 4.41554785e-01],\n", + " [ 6.63042963e-01, -2.08111316e-01, 1.56301618e-01,\n", + " 5.52442551e-01],\n", + " [-5.87123692e-01, -1.62575647e-01, 2.17956066e-01,\n", + " 9.69822764e-01],\n", + " [ 1.66674271e-01, 4.53080326e-01, -3.69119346e-01,\n", + " -2.39664912e-01],\n", + " [-3.86505932e-01, 6.10942423e-01, -5.00057817e-01,\n", + " 2.66106606e-01],\n", + " [-2.54347622e-01, 3.72354746e-01, 3.99116166e-02,\n", + " 6.20316327e-01],\n", + " [-4.96921465e-02, -9.18441892e-01, 3.44903976e-01,\n", + " 8.15902203e-02],\n", + " [-6.36725843e-01, 2.10371893e-03, -6.16860807e-01,\n", + " -7.29355335e-01],\n", + " [-4.36565757e-01, 5.90445995e-01, 2.89873779e-01,\n", + " -5.34469076e-02],\n", + " [-9.48990956e-02, -9.55137372e-01, 5.00165559e-02,\n", + " 1.42975301e-01],\n", + " [-3.14838707e-01, -3.89811456e-01, -6.74244702e-01,\n", + " 2.09302574e-01],\n", + " [ 4.07660156e-01, 7.14925647e-01, 5.40605724e-01,\n", + " -7.90047586e-01],\n", + " [ 1.31185979e-01, 8.02125454e-01, 1.10603094e-01,\n", + " 4.17865366e-01],\n", + " [ 2.20517084e-01, -4.18477237e-01, 2.90681362e-01,\n", + " -5.62349558e-01],\n", + " [ 4.90748197e-01, 1.25575587e-01, -3.97499144e-01,\n", + " -4.35987890e-01],\n", + " [-2.57198870e-01, -7.12255090e-02, 9.69296038e-01,\n", + " 8.77256930e-01],\n", + " [ 1.43123433e-01, -9.27430391e-03, -3.35099757e-01,\n", + " -1.34040296e+00],\n", + " [ 8.57407525e-02, -5.38109709e-03, 4.75591958e-01,\n", + " 8.74427974e-01],\n", + " [-5.44446826e-01, -3.00944634e-02, -2.06931546e-01,\n", + " 6.35489166e-01],\n", + " [ 9.17064846e-01, 6.46720648e-01, -4.41391259e-01,\n", + " 6.15672886e-01],\n", + " [-5.43026686e-01, 4.09820467e-01, 6.57507122e-01,\n", + " 1.57830968e-01],\n", + " [ 4.02954638e-01, -1.72210738e-01, 8.48076701e-01,\n", + " -7.82141149e-01],\n", + " [ 4.16139841e-01, -2.31744245e-01, -1.30540445e-01,\n", + " 5.55725634e-01],\n", + " [ 4.07916337e-01, -1.21158198e-01, 8.86895537e-01,\n", + " -3.80534410e-01],\n", + " [ 2.32394025e-01, 4.22892034e-01, 7.64891505e-02,\n", + " 9.25945401e-01],\n", + " [ 5.80566287e-01, -4.01611254e-03, 1.02383219e-01,\n", + " -1.30755424e-01],\n", + " [-1.15372789e+00, 3.62169057e-01, 3.64901572e-02,\n", + " -5.46632946e-01],\n", + " [ 2.71410376e-01, 1.65175200e-02, 7.98183307e-02,\n", + " -7.19187140e-01],\n", + " [-3.43314469e-01, 2.46294647e-01, -7.23167002e-01,\n", + " 6.08630121e-01],\n", + " [ 5.01465082e-01, -2.85367280e-01, 5.64095378e-01,\n", + " -2.47808158e-01],\n", + " [ 3.48528251e-02, -4.05251622e-01, -1.06104448e-01,\n", + " -3.78682733e-01],\n", + " [ 1.07953250e+00, 2.82175124e-01, -6.28056526e-02,\n", + " 5.19453824e-01],\n", + " [-2.11607907e-02, -7.86108553e-01, -3.92165542e-01,\n", + " -3.36899132e-01],\n", + " [ 8.74649942e-01, 1.78430989e-01, 3.35087627e-01,\n", + " -1.37732938e-01],\n", + " [-6.32407963e-01, 4.82729465e-01, 5.39978147e-01,\n", + " 6.33991420e-01],\n", + " [-1.03223252e+00, 2.31130883e-01, 5.93555510e-01,\n", + " 7.64781415e-01],\n", + " [-5.07121146e-01, -7.17001796e-01, -3.26852322e-01,\n", + " -3.22901100e-01],\n", + " [-7.04385102e-01, 1.66175783e-01, -4.56938595e-01,\n", + " 8.65859568e-01]], dtype=float32),\n", + " 'camera_positions': Array([[-3.12537613e+01, -1.42111874e+00, -8.51368523e+00],\n", + " [-1.52117157e+01, 9.60305786e+00, 2.31950455e+01],\n", + " [ 2.37923126e+01, 2.75534916e+00, -2.34064503e+01],\n", + " [ 4.84719515e+00, 3.43343582e+01, 1.08125620e-02],\n", + " [-1.41254654e+01, 2.44178791e+01, -4.90082932e+01],\n", + " [-4.42659950e+01, -2.08577461e+01, -4.66706848e+00],\n", + " [ 1.77259827e+01, 1.22100401e+01, 2.16972637e+00],\n", + " [ 2.37937050e+01, 2.21075649e+01, -3.71934950e-01],\n", + " [-1.01032877e+01, -2.67316008e+00, -3.28137207e+00],\n", + " [ 3.63336682e+00, 2.88324451e+01, 9.78923035e+00],\n", + " [-1.44270954e+01, 3.82882538e+01, 1.99081516e+01],\n", + " [-2.30130882e+01, -2.12023035e-02, 1.32187974e+00],\n", + " [ 2.16270866e+01, 5.76420879e+00, -3.84611969e+01],\n", + " [-1.15930262e+01, -2.61350746e+01, -1.12158413e+01],\n", + " [-7.81856728e+00, 8.34723854e+00, 3.40747528e+01],\n", + " [ 3.60359997e-01, 1.79351711e+01, -2.49783249e+01],\n", + " [-1.59563904e+01, -4.04742813e+01, 1.73114395e+01],\n", + " [ 1.17220011e+01, 2.58905449e+01, 2.72572899e+00],\n", + " [ 3.71205759e+00, 1.36219072e+00, -4.30522919e+01],\n", + " [-1.82478695e+01, 9.79732990e+00, -2.38393002e+01],\n", + " [-2.89208913e+00, 9.36000252e+00, -2.38623714e+01],\n", + " [-3.29532890e+01, 1.41449404e+01, 2.82875538e+01],\n", + " [-2.02991676e+01, 2.71329761e+00, -1.33434525e+01],\n", + " [ 1.15878057e+01, -1.53237267e+01, 1.55136833e+01],\n", + " [-1.83090553e+01, -2.31087875e+01, -1.33950367e+01],\n", + " [ 1.39383993e+01, -1.90647526e+01, 8.77674007e+00],\n", + " [ 1.81409912e+01, 1.59712200e+01, -2.82454610e+00],\n", + " [ 2.92930679e+01, -3.38720083e-02, -1.74807930e+01],\n", + " [ 1.28059540e+01, -3.12338495e+00, -7.35168648e+00],\n", + " [-2.80920486e+01, 1.34889326e+01, -1.57047853e+01],\n", + " [-8.40764332e+00, -1.99676018e+01, -2.74612255e+01],\n", + " [ 4.27074957e+00, -9.94537640e+00, 1.33726711e+01],\n", + " [-2.67352657e+01, -8.40588760e+00, -3.48194122e+01],\n", + " [ 6.41699362e+00, -1.26025333e+01, -4.02622747e+00],\n", + " [ 7.23208466e+01, 1.44248285e+01, 9.32802963e+00],\n", + " [ 5.56452560e+00, -5.45671749e+00, 1.74738765e+00],\n", + " [ 1.77072525e+01, 6.95184422e+00, 4.94926834e+00],\n", + " [ 2.53545475e+00, 1.23525391e+01, -2.23159294e+01],\n", + " [ 1.48137646e+01, 6.59744873e+01, 6.55005264e+00],\n", + " [ 2.81577873e+01, -1.11248131e+01, -2.86736698e+01],\n", + " [-3.59824982e+01, 1.19687214e+01, 1.07426825e+01],\n", + " [-3.57302971e+01, -9.74959469e+00, -3.67939091e+00],\n", + " [-3.91301632e+00, -2.44476166e+01, -2.21279831e+01],\n", + " [ 5.38754702e+00, 1.70687561e+01, 4.80260391e+01],\n", + " [-1.10787783e+01, 1.46290121e+01, -4.36676216e+00],\n", + " [-1.53195739e+00, 5.83427467e+01, -1.83959160e+01],\n", + " [-1.54909906e+01, 1.93601093e+01, 9.57220912e-01],\n", + " [-1.50919733e+01, -1.87660542e+01, -6.03623772e+00],\n", + " [ 1.26809072e+01, 1.25081139e+01, 5.11858988e+00],\n", + " [-3.99364758e+00, -2.01897507e+01, 3.75410614e+01],\n", + " [-1.26424074e+00, -4.05465078e+00, -1.72862682e+01],\n", + " [ 8.64319706e+00, 9.63397217e+00, -9.28374004e+00],\n", + " [ 3.51466179e+01, 1.93393707e+01, 1.58748779e+01],\n", + " [ 1.14144602e+01, 1.58284721e+01, 2.38412514e+01],\n", + " [-9.50970459e+00, -1.40029926e+01, 2.06051216e+01],\n", + " [-1.06816187e+01, 2.27507305e+00, -1.67601738e+01],\n", + " [-2.75502815e+01, 2.73173523e+01, 2.37726288e+01],\n", + " [ 5.46742725e+00, 2.08078575e+01, 2.19708538e+01],\n", + " [ 3.27124443e+01, -1.45728092e+01, -6.05527973e+00],\n", + " [-1.15781822e+01, 2.69317799e+01, 2.15549068e+01],\n", + " [-1.36414967e+01, -4.64170933e+00, -1.47975063e+00],\n", + " [ 1.79367256e+01, -2.14179592e+01, -2.16881008e+01],\n", + " [-6.22318935e+00, 7.08142233e+00, -1.74035110e+01],\n", + " [ 3.46656227e+01, 1.46850004e+01, 3.05535736e+01],\n", + " [-1.97505207e+01, -2.17132645e+01, -1.89957523e+01],\n", + " [-1.27118130e+01, -3.43927422e+01, -2.62008858e+00],\n", + " [ 1.18294573e+01, 2.76990147e+01, -1.10004129e+01],\n", + " [ 5.55038109e+01, -1.68828869e+00, -1.97196922e+01],\n", + " [-7.60153484e+00, -2.71198654e+01, -3.27173309e+01],\n", + " [-3.71011200e+01, 3.15668144e+01, -1.11750908e+01],\n", + " [-1.46946859e+01, -1.70589027e+01, -1.31439161e+01],\n", + " [ 9.10875511e+00, 3.43826447e+01, 1.61946182e+01],\n", + " [ 3.03332253e+01, -3.63300781e+01, 1.99262447e+01],\n", + " [-1.10537138e+01, -1.72484531e+01, 2.39434166e+01],\n", + " [-2.88254433e+01, 2.47118607e+01, -2.14406986e+01],\n", + " [ 1.37377825e+01, -1.02883186e+01, 1.70011730e+01],\n", + " [-5.88547993e+00, -1.46347561e+01, -6.08912945e+00],\n", + " [-1.28371315e+01, 1.20679073e+01, 1.32494440e+01],\n", + " [ 1.72086163e+01, 1.49413118e+01, -1.43691242e+00],\n", + " [ 1.80731316e+01, 2.17895436e+00, -1.42909985e+01],\n", + " [ 9.61150169e+00, -3.99987068e+01, 2.76481342e+01],\n", + " [-1.36546078e+01, -6.99765682e+00, -5.25201845e+00],\n", + " [-7.35935402e+00, 2.42879143e+01, -2.84734650e+01],\n", + " [ 1.98023548e+01, 9.74178505e+00, -1.20538530e+01],\n", + " [-7.01734304e+00, -2.29743198e-01, -1.69950790e+01],\n", + " [-2.18883095e+01, 2.74564152e+01, -2.12885456e+01],\n", + " [-4.38243198e+00, 4.87638426e+00, -4.52398634e+00],\n", + " [-1.03975430e+01, 5.06710529e+00, -7.36464918e-01],\n", + " [-8.42724609e+00, 2.09739151e+01, -4.62922134e+01],\n", + " [ 5.74010420e+00, 1.73246849e+00, 2.75797825e+01],\n", + " [-3.09604979e+00, 4.47556019e+00, 1.54312122e+00],\n", + " [ 3.67038689e+01, -3.76719742e+01, -4.87405396e+00],\n", + " [ 1.99358177e+01, 1.53715754e+01, -2.16905365e+01],\n", + " [-7.74785805e+00, 8.65913773e+00, 1.11403084e+01],\n", + " [-2.13938828e+01, -1.72895851e+01, -1.32886963e+01],\n", + " [ 2.24843478e+00, -8.28067541e-01, -3.69713287e+01],\n", + " [ 2.07762299e+01, 7.97154379e+00, 2.24146385e+01],\n", + " [-8.34892333e-01, 1.72959137e+01, 5.43206787e+00],\n", + " [ 6.86541080e+00, 3.67161751e+01, -1.07211030e+00]], dtype=float32),\n", + " 'keypoint_world_positions': Array([[-35.675045 , -4.2464643, -18.003294 ],\n", + " [-19.5758 , 36.46369 , 16.358862 ],\n", + " [ -8.156345 , -23.596035 , -17.684082 ],\n", + " ...,\n", + " [ 20.804333 , 0.2422315, 8.532504 ],\n", + " [ -1.3674471, 4.1072836, -23.054115 ],\n", + " [-15.435583 , -14.9414425, 17.47194 ]], dtype=float32)}" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior_sample" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "68b44fdb-f20e-4f28-ad1a-2742b6126c9a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-1.0, 1.0)" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "latents = dict(\n", + " camera_positions=SCENE.camera_poses[1:].position.astype(DTYPE),\n", + " camera_raw_quaternions=SCENE.camera_poses[1:].quaternion.astype(DTYPE),\n", + " raw_observation_noise_scale=observation_noise_scale_bij.inverse(0.01).astype(DTYPE),\n", + ")\n", + "if MODEL.world_prior == \"scale_free\":\n", + " latents.update(\n", + " raw_keypoint_world_positions=SCENE.keypoint_world_positions.astype(\n", + " DTYPE\n", + " ).ravel(),\n", + " )\n", + "else:\n", + " latents.update(\n", + " keypoint_world_positions=SCENE.keypoint_world_positions.astype(DTYPE),\n", + " )\n", + "\n", + "frame = 10\n", + "visible = SCENE.keypoint_visibility[frame]\n", + "with warnings.catch_warnings(action=\"ignore\"):\n", + " _, revals = jax.vmap(\n", + " lambda i: model_cond_sample(\n", + " functools.partial(MODEL.model, DEFAULT_MODEL_ARGS),\n", + " latents,\n", + " jax.random.key(i),\n", + " )\n", + " )(jnp.arange(10))\n", + "\n", + "fig, ax = plt.subplots()\n", + "for i in range(10):\n", + " retval = jax.tree.map(lambda x: x[i], revals)\n", + " ax.scatter(\n", + " *retval[\"keypoint_screen_positions\"][frame, visible].T,\n", + " marker=\"+\",\n", + " color=\"red\",\n", + " )\n", + "ax.scatter(*SCENE.keypoint_screen_positions[frame, visible].T, color=\"k\")\n", + "ax.set_aspect(\"equal\")\n", + "ax.set_xlim(-1, 1)\n", + "ax.set_ylim(-1, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "6c5eec59-ec80-4fbc-846b-4352d7860fa7", + "metadata": {}, + "outputs": [], + "source": [ + "if MODEL.camera_prior == \"relative_noncentered\":\n", + " print(\"This is broken for relative_noncentered.\")\n", + "\n", + "latents = dict(\n", + " camera_positions=SCENE.camera_poses[1:].position.astype(DTYPE),\n", + " camera_raw_quaternions=SCENE.camera_poses[1:].quaternion.astype(DTYPE),\n", + " raw_observation_noise_scale=observation_noise_scale_bij.inverse(0.01).astype(DTYPE),\n", + " keypoint_screen_positions=SCENE.keypoint_screen_positions.astype(DTYPE),\n", + ")\n", + "if MODEL.world_prior == \"scale_free\":\n", + " latents.update(\n", + " raw_keypoint_world_positions=SCENE.keypoint_world_positions.astype(\n", + " DTYPE\n", + " ).ravel(),\n", + " )\n", + "else:\n", + " latents.update(\n", + " keypoint_world_positions=SCENE.keypoint_world_positions.astype(DTYPE),\n", + " )\n", + "\n", + "with warnings.catch_warnings(action=\"ignore\"):\n", + " lp, retval = model_log_prob(\n", + " functools.partial(MODEL.model, DEFAULT_MODEL_ARGS), latents\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "4838ec8d-ba5c-4264-aee8-524e8f0b8d1a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(154142.5, dtype=float32)" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lp" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "24f959a2-1162-4cba-bf47-5d504c1cf611", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[ 2.7765479e-04, -3.3200166e-01],\n", + " [ 2.6322114e-01, -3.6610842e-01],\n", + " [ 2.5917935e-01, -4.0534180e-01],\n", + " [ 1.8391137e-01, -4.5538378e-01],\n", + " [ 1.5793559e-01, -6.2384421e-01]], dtype=float32)" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "retval[\"keypoint_screen_positions\"][6, :5]" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "7a28bf28-e169-4834-abd0-22dbdc66833c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[ 2.7765479e-04, -3.3200166e-01],\n", + " [ 2.6322114e-01, -3.6610842e-01],\n", + " [ 2.5917935e-01, -4.0534180e-01],\n", + " [ 1.8391137e-01, -4.5538378e-01],\n", + " [ 1.5793559e-01, -6.2384421e-01]], dtype=float32)" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SCENE.keypoint_screen_positions[6, :5]" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "0566dc91-a994-4f88-87b5-3725035d7060", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Pose(position=Array([ 1.9328486, 2.3730583, -1.3438673], dtype=float32), quaternion=Array([-0.18325463, -0.5151692 , 0.78884625, 0.28060633], dtype=float32))" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "retval[\"camera_poses\"][6]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "e15feaa0-ab13-4032-b108-007268003466", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Pose(position=Array([ 1.9328486, 2.3730583, -1.3438673], dtype=float32), quaternion=Array([-0.18325464, -0.51516926, 0.7888464 , 0.28060636], dtype=float32))" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SCENE.camera_poses[6]" + ] + }, + { + "cell_type": "markdown", + "id": "c8d13cc6-bf81-4353-9256-dae318c9b16f", + "metadata": {}, + "source": [ + "# Inference" + ] + }, + { + "cell_type": "markdown", + "id": "c61891ff-93ac-4a57-ac98-0f6c88abc076", + "metadata": {}, + "source": [ + "## Initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "b4bb44b5-306c-404c-aea1-790c71110619", + "metadata": {}, + "outputs": [], + "source": [ + "def init_frame_gt(latents, frame, scene, model, model_args):\n", + " del model_args\n", + " # Inits a frame from the ground truth.\n", + " latents = latents.copy()\n", + " if frame > 0:\n", + " match model.camera_prior:\n", + " case \"relative_noncentered\":\n", + " raise NotImplementedError()\n", + " case \"independent\" | \"relative_centered\":\n", + " latents[\"camera_positions\"] = (\n", + " latents[\"camera_positions\"]\n", + " .at[frame - 1]\n", + " .set(scene.camera_poses[frame].position)\n", + " )\n", + " latents[\"camera_raw_quaternions\"] = (\n", + " latents[\"camera_raw_quaternions\"]\n", + " .at[frame - 1]\n", + " .set(scene.camera_poses[frame].quaternion)\n", + " )\n", + "\n", + " visibility = scene.keypoint_visibility[frame]\n", + " if frame == 0:\n", + " prev_visibility = np.zeros_like(visibility)\n", + " else:\n", + " prev_visibility = scene.keypoint_visibility[:frame].any(0)\n", + " visibility = visibility & ~prev_visibility\n", + "\n", + " match model.world_prior:\n", + " case \"scale_free\":\n", + " latents[\"raw_keypoint_world_positions\"] = jnp.where(\n", + " jnp.repeat(visibility[:, jnp.newaxis], 3, axis=-1).ravel(),\n", + " scene.keypoint_world_positions.ravel(),\n", + " latents[\"raw_keypoint_world_positions\"],\n", + " )\n", + " case _:\n", + " latents[\"keypoint_world_positions\"] = jnp.where(\n", + " visibility[:, jnp.newaxis],\n", + " scene.keypoint_world_positions,\n", + " latents[\"keypoint_world_positions\"],\n", + " )\n", + "\n", + " return latents" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "8b6ae962-7842-4520-b55e-76438b246afe", + "metadata": {}, + "outputs": [], + "source": [ + "def init_frame_unproject(latents, frame, scene, model, model_args):\n", + " # Inits a frame from the previous frame.\n", + " latents = latents.copy()\n", + " if frame > 0:\n", + " match model.camera_prior:\n", + " case \"relative_noncentered\":\n", + " latents[\"camera_positions\"] = (\n", + " latents[\"camera_positions\"].at[frame - 1].set(jnp.zeros(3))\n", + " )\n", + " latents[\"camera_raw_quaternions\"] = (\n", + " latents[\"camera_raw_quaternions\"]\n", + " .at[frame - 1]\n", + " .set(jnp.array([0, 0, 0, 1.0]))\n", + " )\n", + " case \"independent\" | \"relative_centered\":\n", + " if frame == 1:\n", + " # This isn't ideal... should we eval the model again to get the first pose rather than grabbing it from the scene\n", + " latents[\"camera_positions\"] = (\n", + " latents[\"camera_positions\"]\n", + " .at[frame - 1]\n", + " .set(scene.camera_poses[0].position)\n", + " )\n", + " latents[\"camera_raw_quaternions\"] = (\n", + " latents[\"camera_raw_quaternions\"]\n", + " .at[frame - 1]\n", + " .set(scene.camera_poses[0].quaternion)\n", + " )\n", + " else:\n", + " latents[\"camera_positions\"] = (\n", + " latents[\"camera_positions\"]\n", + " .at[frame - 1]\n", + " .set(latents[\"camera_positions\"][frame - 2])\n", + " )\n", + " latents[\"camera_raw_quaternions\"] = (\n", + " latents[\"camera_raw_quaternions\"]\n", + " .at[frame - 1]\n", + " .set(latents[\"camera_raw_quaternions\"][frame - 2])\n", + " )\n", + "\n", + " with warnings.catch_warnings(action=\"ignore\"):\n", + " ret = model.eval_model(latents, model_args)\n", + " camera_poses = ret[\"camera_poses\"]\n", + "\n", + " visibility = scene.keypoint_visibility[frame]\n", + " if frame == 0:\n", + " prev_visibility = np.zeros_like(visibility)\n", + " else:\n", + " prev_visibility = scene.keypoint_visibility[:frame].any(0)\n", + " visibility = visibility & ~prev_visibility\n", + "\n", + " indices = jnp.where(visibility)[0]\n", + " uvs = scene.keypoint_screen_positions[frame, indices]\n", + " camera_pose = jax.tree.map(lambda x: x[frame], camera_poses)\n", + "\n", + " homogeneous_pixel_coords = homogeneous_coordinates(uvs, jnp.array(3.0, DTYPE))\n", + "\n", + " transformed = camera_pose.apply(homogeneous_pixel_coords)\n", + "\n", + " match model.world_prior:\n", + " case \"scale_free\":\n", + " latents[\"raw_keypoint_world_positions\"] = (\n", + " latents[\"raw_keypoint_world_positions\"]\n", + " .reshape([scene.num_keypoints, 3])\n", + " .at[indices]\n", + " .set(transformed)\n", + " .ravel()\n", + " )\n", + " case _:\n", + " latents[\"keypoint_world_positions\"] = (\n", + " latents[\"keypoint_world_positions\"].at[indices].set(transformed)\n", + " )\n", + "\n", + " return latents" + ] + }, + { + "cell_type": "markdown", + "id": "7b1c499a-7001-40c9-938d-b74311bbecc6", + "metadata": {}, + "source": [ + "### Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "c020ca60-5d89-47a8-85f9-c8613c145789", + "metadata": {}, + "outputs": [], + "source": [ + "# Enable to run this test.\n", + "if False:\n", + " latents = dict(\n", + " camera_positions=SCENE.camera_poses[1:].position.astype(DTYPE),\n", + " camera_raw_quaternions=SCENE.camera_poses[1:].quaternion.astype(DTYPE),\n", + " raw_observation_noise_scale=observation_noise_scale_bij.inverse(0.01).astype(\n", + " DTYPE\n", + " ),\n", + " keypoint_screen_positions=SCENE.keypoint_screen_positions.astype(DTYPE),\n", + " )\n", + " latents = {**prior_sample, **latents}\n", + "\n", + " with warnings.catch_warnings(action=\"ignore\"):\n", + " for i in range(1):\n", + " latents = init_frame_unproject(latents, i, SCENE, MODEL, DEFAULT_MODEL_ARGS)\n", + "\n", + " retval = MODEL.eval_model(latents, DEFAULT_MODEL_ARGS)\n", + "\n", + " scene_points = PointsDisplay(\n", + " positions=retval[\"keypoint_world_positions\"],\n", + " colors=SCENE.keypoint_colors,\n", + " point_size=4,\n", + " )\n", + "\n", + " scene_camera = CameraDisplay(\n", + " positions=retval[\"camera_poses\"].position,\n", + " quaternions=retval[\"camera_poses\"].quaternion,\n", + " color=np.array([1.0, 0.0, 0.0]),\n", + " )\n", + "\n", + " scene_renderer = SceneRenderer(scene_points.objects + scene_camera.objects)\n", + "\n", + " display(scene_renderer.renderer)" + ] + }, + { + "cell_type": "markdown", + "id": "6ea17139-7fcf-4b34-a0fd-fcbfdbae9399", + "metadata": {}, + "source": [ + "## HMC" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e30db023-51f2-4427-84fe-f12a25c0adc0", + "metadata": {}, + "outputs": [], + "source": [ + "def add_camera_quaternion(latents):\n", + " latents = latents.copy()\n", + " latents[\"camera_quaternions\"] = latents[\"camera_raw_quaternions\"] / jnp.linalg.norm(\n", + " latents[\"camera_raw_quaternions\"], axis=-1, keepdims=True\n", + " )\n", + " return latents\n", + "\n", + "\n", + "class HMCInferenceState(NamedTuple):\n", + " latents: Any\n", + " ssa_state: fun_mc.prefab.StepSizeAdaptationState\n", + " rvar_state: fun_mc.RunningVarianceState\n", + " rvar_state_slow: fun_mc.RunningVarianceState\n", + " mean_sq_grad: Any\n", + "\n", + "\n", + "class HMCInferenceExtra(NamedTuple):\n", + " target_log_prob: Any\n", + " tlp_extra: Any\n", + " traced: Any\n", + " logged: Any\n", + " extra: Any\n", + "\n", + "\n", + "@dataclasses.dataclass(frozen=True)\n", + "class HMCInference:\n", + " model: Model\n", + " init_frame_latents_fn: Any\n", + " num_chains: int = 8\n", + " test_camera_idx: int = 10\n", + "\n", + " @functools.partial(jax.jit, static_argnums=(0,))\n", + " def init_fn(self, latents, init_step_size):\n", + " latents = jax.tree.map(\n", + " lambda x: jnp.repeat(x[jnp.newaxis], self.num_chains, axis=0), latents\n", + " )\n", + " rvar_latents = add_camera_quaternion(latents)\n", + " return HMCInferenceState(\n", + " latents=latents,\n", + " ssa_state=jax.vmap(fun_mc.prefab.step_size_adaptation_init)(\n", + " jnp.repeat(\n", + " jnp.array(init_step_size, DTYPE)[jnp.newaxis], self.num_chains\n", + " )\n", + " ),\n", + " rvar_state=jax.vmap(\n", + " lambda l: fun_mc.running_variance_init(\n", + " jax.tree.map(lambda x: x.shape, l),\n", + " jax.tree.map(lambda x: x.dtype, l),\n", + " )\n", + " )(rvar_latents),\n", + " rvar_state_slow=jax.vmap(\n", + " lambda l: fun_mc.running_variance_init(\n", + " jax.tree.map(lambda x: x.shape, l),\n", + " jax.tree.map(lambda x: x.dtype, l),\n", + " )\n", + " )(rvar_latents),\n", + " mean_sq_grad=jax.tree.map(jnp.ones_like, latents),\n", + " )\n", + "\n", + " @functools.partial(jax.jit, static_argnums=(0,))\n", + " def step_fn(\n", + " self,\n", + " state,\n", + " step,\n", + " cond_latents,\n", + " cond_mask,\n", + " model_args,\n", + " mean_num_leapfrog_steps,\n", + " adapt=True,\n", + " ):\n", + " print(\"tracing\")\n", + " hmc_seed, jitter_seed = jax.random.split(jax.random.key(step))\n", + " tlp_fn = jax.vmap(\n", + " functools.partial(\n", + " self.model.target_log_prob_fn,\n", + " cond_latents=cond_latents,\n", + " cond_mask=cond_mask,\n", + " model_args=model_args,\n", + " )\n", + " )\n", + "\n", + " latents = state.latents.copy()\n", + " for k, v in list(cond_latents.items()):\n", + " mask = cond_mask.get(k)\n", + " if mask is not None:\n", + " latents[k] = jnp.where(mask, v, latents[k])\n", + "\n", + " hmc_state = fun_mc.hamiltonian_monte_carlo_init([latents], tlp_fn)\n", + "\n", + " num_integrator_steps = jax.random.randint(\n", + " jitter_seed, [], 1, 1 + 2 * mean_num_leapfrog_steps\n", + " )\n", + " step_size = jnp.where(\n", + " adapt, state.ssa_state.step_size(), state.ssa_state.rms_step_size\n", + " )\n", + "\n", + " def step_size_part(v):\n", + " return step_size.reshape(\n", + " [self.num_chains] + [1] * (len(v.shape) - 1)\n", + " ) # / (1e-5 + jnp.sqrt(v))\n", + "\n", + " vec_step_size = [jax.tree.map(step_size_part, state.mean_sq_grad)]\n", + "\n", + " hmc_state, hmc_extra = fun_mc.hamiltonian_monte_carlo_step(\n", + " hmc_state,\n", + " target_log_prob_fn=tlp_fn,\n", + " step_size=vec_step_size,\n", + " num_integrator_steps=num_integrator_steps,\n", + " seed=jax.random.fold_in(hmc_seed, 0),\n", + " # energy_change_fn=energy_change_fn,\n", + " )\n", + " hmc_state, hmc_extra = fun_mc.hamiltonian_monte_carlo_step(\n", + " hmc_state,\n", + " target_log_prob_fn=tlp_fn,\n", + " step_size=vec_step_size,\n", + " num_integrator_steps=2 * mean_num_leapfrog_steps - num_integrator_steps,\n", + " seed=jax.random.fold_in(hmc_seed, 1),\n", + " # energy_change_fn=energy_change_fn,\n", + " )\n", + "\n", + " latents = hmc_state.state_extra[\"latents\"]\n", + "\n", + " ssa_state, _ = jax.vmap(\n", + " lambda ssa_state, log_accept_ratio: fun_mc.prefab.step_size_adaptation_step(\n", + " ssa_state,\n", + " log_accept_ratio=log_accept_ratio,\n", + " num_adaptation_steps=None,\n", + " target_accept_prob=0.95,\n", + " adaptation_rate=0.2,\n", + " # reduce_fn=tfp.math.reduce_log_harmonic_mean_exp,\n", + " )\n", + " )(state.ssa_state, hmc_extra.log_accept_ratio)\n", + "\n", + " rvar_latents = add_camera_quaternion(latents)\n", + " rvar_state, _ = jax.vmap(\n", + " lambda s, l: fun_mc.running_variance_step(s, l, window_size=200)\n", + " )(state.rvar_state, rvar_latents)\n", + " rvar_state_slow, _ = jax.vmap(\n", + " lambda s, l: fun_mc.running_variance_step(s, l, window_size=400)\n", + " )(state.rvar_state_slow, rvar_latents)\n", + "\n", + " all_means, all_vars = jax.tree.map(\n", + " lambda x, y: jnp.concatenate([x, y], 0),\n", + " (rvar_state.mean, rvar_state.variance),\n", + " (rvar_state_slow.mean, rvar_state_slow.variance),\n", + " )\n", + " rhats = jax.tree.map(\n", + " lambda mean, var: 1.0 + mean.var(0) / var.mean(0),\n", + " all_means,\n", + " all_vars,\n", + " )\n", + " worst_rhats = jax.tree.map(lambda rhat: jnp.nanmax(rhat), rhats)\n", + " worst_rhats = {f\"{k} rhat\": v for k, v in worst_rhats.items()}\n", + "\n", + " lr = 0.05\n", + "\n", + " def sq_grad_part(mean_sq_grad, g):\n", + " g = jnp.where(jnp.isfinite(g), g, 0.0)\n", + " new = jnp.square(g)\n", + " new = jnp.clip(\n", + " new, (1 - lr**0.1) * mean_sq_grad, (1 + lr**0.1) * mean_sq_grad\n", + " )\n", + " return mean_sq_grad * (1 - lr) + new * lr\n", + "\n", + " mean_sq_grad = jax.tree.map(\n", + " sq_grad_part, state.mean_sq_grad, hmc_state.state_grads[0]\n", + " )\n", + "\n", + " tlp_extra = hmc_state.state_extra\n", + "\n", + " camera_poses = tlp_extra[\"camera_poses\"]\n", + "\n", + " extra = HMCInferenceExtra(\n", + " target_log_prob=hmc_state.target_log_prob,\n", + " traced=collections.OrderedDict(\n", + " {\n", + " \"target_log_prob\": hmc_state.target_log_prob,\n", + " \"step_size\": step_size,\n", + " \"observation_noise_scale\": hmc_state.state_extra[\n", + " \"observation_noise_scale\"\n", + " ],\n", + " f\"camera_positions[{self.test_camera_idx}].x\": camera_poses.position[\n", + " :, self.test_camera_idx, 0\n", + " ],\n", + " f\"camera_positions[{self.test_camera_idx}].y\": camera_poses.position[\n", + " :, self.test_camera_idx, 1\n", + " ],\n", + " f\"camera_quaternions[{self.test_camera_idx}].x\": camera_poses.quaternion[\n", + " :, self.test_camera_idx, 0\n", + " ],\n", + " f\"camera_quaternions[{self.test_camera_idx}].y\": camera_poses.quaternion[\n", + " :, self.test_camera_idx, 1\n", + " ],\n", + " }\n", + " ),\n", + " logged=collections.OrderedDict(\n", + " {\n", + " \"log_accept_ratio\": hmc_extra.log_accept_ratio.min(),\n", + " \"log_accept_ratio_old\": (\n", + " -hmc_extra.integrator_extra.energy_change\n", + " ).min(),\n", + " **worst_rhats,\n", + " }\n", + " ),\n", + " tlp_extra=hmc_state.state_extra,\n", + " extra={\n", + " \"rhats\": rhats,\n", + " },\n", + " )\n", + "\n", + " # TODO: disable pre-conditioning as well\n", + " ssa_state = jax.tree.map(\n", + " lambda n, o: jnp.where(adapt, n, o), ssa_state, state.ssa_state\n", + " )\n", + "\n", + " return state._replace(\n", + " latents=latents,\n", + " ssa_state=ssa_state,\n", + " rvar_state=rvar_state,\n", + " rvar_state_slow=rvar_state_slow,\n", + " mean_sq_grad=mean_sq_grad,\n", + " ), extra\n", + "\n", + " @functools.partial(jax.jit, static_argnums=(0,))\n", + " def resample_fn(self, state, indices):\n", + " resample = lambda s: s[indices]\n", + " return jax.tree.map(resample, state)\n", + "\n", + " def init_frame_fn(self, state, frame, scene, model_args):\n", + " return state._replace(\n", + " latents=jax.vmap(\n", + " lambda l: self.init_frame_latents_fn(\n", + " latents=l,\n", + " frame=frame,\n", + " scene=scene,\n", + " model=self.model,\n", + " model_args=model_args,\n", + " )\n", + " )(state.latents)\n", + " )\n", + "\n", + " def get_ground_truth(self, scene):\n", + " return {\n", + " f\"camera_positions[{self.test_camera_idx}].x\": scene.camera_poses.position[\n", + " self.test_camera_idx, 0\n", + " ],\n", + " f\"camera_positions[{self.test_camera_idx}].y\": scene.camera_poses.position[\n", + " self.test_camera_idx, 1\n", + " ],\n", + " f\"camera_quaternions[{self.test_camera_idx}].x\": scene.camera_poses.quaternion[\n", + " self.test_camera_idx, 0\n", + " ],\n", + " f\"camera_quaternions[{self.test_camera_idx}].y\": scene.camera_poses.quaternion[\n", + " self.test_camera_idx, 1\n", + " ],\n", + " }\n", + "\n", + " def get_hparams(self):\n", + " return {\n", + " \"mean_num_leapfrog_steps\": Hyperparameter(50, 1, 400),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "60b39faa-f16c-44e5-899e-dc9561174dd0", + "metadata": {}, + "source": [ + "## Construct" + ] + }, + { + "cell_type": "markdown", + "id": "25ba2776-2f11-41c8-b098-2c3558b34b85", + "metadata": {}, + "source": [ + "When constructing the inference method, we specify how to initialize new frames. By default, this grabs the data from the ground truth, but a ground-truth-free method of unprjecting newly added points is also available." + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "1aae365c-b278-46ad-b8e5-049f05cdade0", + "metadata": {}, + "outputs": [], + "source": [ + "INFERENCE = HMCInference(\n", + " model=MODEL,\n", + " init_frame_latents_fn=init_frame_gt,\n", + " #init_frame_latents_fn=init_frame_unproject,\n", + " num_chains=4,\n", + ")\n", + "\n", + "with warnings.catch_warnings(action=\"ignore\"):\n", + " prior_sample, retval = model_sample(\n", + " functools.partial(MODEL.model, DEFAULT_MODEL_ARGS), jax.random.key(0)\n", + " )\n", + " del prior_sample[\"keypoint_screen_positions\"]\n", + " # Note that the real initialization happens in INFERENCE.init_frame_fn\n", + " INIT_LATENTS = prior_sample" + ] + }, + { + "cell_type": "markdown", + "id": "897e820f-db8d-4705-8378-73c349054d70", + "metadata": {}, + "source": [ + "## Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "2ebdb796-312f-40c0-b856-af5438d89684", + "metadata": {}, + "outputs": [], + "source": [ + "# Enable to run this test.\n", + "if False:\n", + " with warnings.catch_warnings(action=\"ignore\"):\n", + " init_state = INFERENCE.init_fn(INIT_LATENTS, 1e-3)\n", + " for i in range(SCENE.num_frames):\n", + " init_state = INFERENCE.init_frame_fn(\n", + " init_state, i, SCENE, DEFAULT_MODEL_ARGS\n", + " )\n", + "\n", + " cond_latents = {\n", + " \"keypoint_screen_positions\": SCENE.keypoint_screen_positions.astype(DTYPE),\n", + " \"raw_observation_noise_scale\": observation_noise_scale_bij.inverse(\n", + " 0.01,\n", + " ).astype(DTYPE),\n", + " }\n", + " cond_mask = {\n", + " \"raw_observation_noise_scale\": True,\n", + " }\n", + " state = init_state\n", + " for i in range(100):\n", + " state, extra = INFERENCE.step_fn(\n", + " state,\n", + " i,\n", + " cond_latents,\n", + " cond_mask,\n", + " DEFAULT_MODEL_ARGS,\n", + " # DEFAULT_MODEL_ARGS._replace(\n", + " # keypoint_visibility=scene.keypoint_visibility.at[1:].set(False)\n", + " # ),\n", + " 40,\n", + " )\n", + " print()\n", + " print(\"lp_a \", extra.logged[\"log_accept_ratio\"])\n", + " print(\"lp_a_o\", extra.logged[\"log_accept_ratio_old\"])\n", + " print(\"tlp\", extra.traced[\"target_log_prob\"])\n", + " print(\"ss\", extra.traced[\"step_size\"])\n", + " print(extra.logged)\n", + " print(extra.traced)" + ] + }, + { + "cell_type": "markdown", + "id": "843f0c11-6bce-4832-9c5a-7b1baa68fc36", + "metadata": {}, + "source": [ + "# Interactive Inference" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "1ac48ff0-6461-41b9-9d0a-ac312c330a6b", + "metadata": {}, + "outputs": [], + "source": [ + "class InteractiveInference:\n", + " def __init__(self, scene, model, inference, model_args, init_latents):\n", + " self.scene = scene\n", + " self.model = model\n", + " self.inference = inference\n", + " self.cur_num_frames = 1\n", + " self.target_num_frames = 1\n", + " self.auto_advance_frames = Hyperparameter(False)\n", + " self.auto_advance_interval = Hyperparameter(20, 1, 200)\n", + " self.step = 0\n", + " self.observation_noise_scale = Hyperparameter(1e-2, 1e-4, 1e2, log_scale=True)\n", + " self.observation_noise_scale_override = Hyperparameter(True)\n", + " self.observation_noise_degrees = Hyperparameter(\n", + " model_args.observation_noise_degrees,\n", + " 1,\n", + " 1000,\n", + " log_scale=True,\n", + " )\n", + " self.object_prior_scale = Hyperparameter(\n", + " model_args.object_prior_scale, 1e-3, 1e4, log_scale=True\n", + " )\n", + " self.model_args = model_args\n", + " init_state = inference.init_fn(init_latents, 1e-6)\n", + " self.state = inference.init_frame_fn(\n", + " state=init_state, frame=0, scene=self.scene, model_args=self.model_args\n", + " )\n", + " self.auto_resample = Hyperparameter(False)\n", + " self.resample = False\n", + " self.super_resample = False\n", + " self.num_resample = 0\n", + " self.show_covariance = Hyperparameter(True)\n", + " self.show_errors = Hyperparameter(True)\n", + " self.show_chain = Hyperparameter(-1, -1, self.inference.num_chains - 1)\n", + " self.show_frame = Hyperparameter(-1, -1, self.scene.num_frames - 1)\n", + " self.pause = Hyperparameter(True)\n", + " self.hparams = {k: copy.copy(v) for k, v in inference.get_hparams().items()}\n", + "\n", + " # Precompile (why do I need to do this twice?)\n", + " s, extra = self.run_step(self.state)\n", + " s, extra = self.run_step(s)\n", + " tlp_extra = extra.tlp_extra\n", + "\n", + " self.trace = {k: [v] for k, v in extra.traced.items()}\n", + "\n", + " loc, cov = get_loc_cov(tlp_extra[\"keypoint_world_positions\"])\n", + "\n", + " self.gt_camera_display = CameraDisplay(\n", + " positions=self.scene.camera_poses.position,\n", + " quaternions=self.scene.camera_poses.quaternion,\n", + " color=np.array([1.0, 0.0, 0.0]),\n", + " )\n", + " self.gt_points_display = PointsDisplay(\n", + " positions=self.scene.keypoint_world_positions,\n", + " colors=np.zeros_like(self.scene.keypoint_colors)\n", + " + np.array([1.0, 0.0, 0.0], dtype=np.float32),\n", + " point_size=2,\n", + " )\n", + " chain_cmap = plt.colormaps[\"viridis\"]\n", + " self.camera_displays = [\n", + " CameraDisplay(\n", + " positions=tlp_extra[\"camera_poses\"].position[i],\n", + " quaternions=tlp_extra[\"camera_poses\"].quaternion[i],\n", + " color=chain_cmap(i / (self.inference.num_chains - 1)),\n", + " )\n", + " for i in range(self.inference.num_chains)\n", + " ]\n", + " self.points_display = PointsDisplay(\n", + " positions=self.scene.keypoint_world_positions,\n", + " colors=self.scene.keypoint_colors,\n", + " )\n", + " self.blobs_display = BlobDisplay(\n", + " positions=loc,\n", + " colors=self.scene.keypoint_colors,\n", + " covariances=cov + 0.01 * np.eye(3),\n", + " )\n", + " self.error_display = PointsDisplay(\n", + " positions=self.scene.keypoint_world_positions,\n", + " colors=np.repeat(\n", + " np.array([1.0, 1.0, 0.0], np.float32)[np.newaxis],\n", + " self.scene.num_keypoints,\n", + " axis=0,\n", + " ),\n", + " )\n", + " self.scene_renderer = SceneRenderer(\n", + " self.gt_camera_display.objects\n", + " + self.gt_points_display.objects\n", + " + self.blobs_display.objects\n", + " + self.points_display.objects\n", + " + self.error_display.objects\n", + " + [o for c in self.camera_displays for o in c.objects]\n", + " )\n", + " self.status = None\n", + " self.output = ipywidgets.Output()\n", + "\n", + " widgets = []\n", + " widgets.append(\n", + " make_hyperparameter_widget(\n", + " self.pause,\n", + " \"\",\n", + " self.output,\n", + " toggle_style=\"info\",\n", + " toggle_icons=(\"pause\", \"play\"),\n", + " )\n", + " )\n", + "\n", + " def on_stop_button(_):\n", + " try:\n", + " self.quit = True\n", + " except Exception:\n", + " with self.output:\n", + " print(traceback.format_exc())\n", + "\n", + " def on_resample_button(_):\n", + " try:\n", + " self.resample = True\n", + " except Exception:\n", + " with self.output:\n", + " print(traceback.format_exc())\n", + "\n", + " def on_super_resample_button(_):\n", + " try:\n", + " self.resample = True\n", + " self.super_resample = True\n", + " except Exception:\n", + " with self.output:\n", + " print(traceback.format_exc())\n", + "\n", + " stop_button = ipywidgets.Button(description=\"⏼\", button_style=\"danger\")\n", + " stop_button.on_click(on_stop_button)\n", + " resample_button = ipywidgets.Button(\n", + " description=\"Resample\", button_style=\"warning\"\n", + " )\n", + " resample_button.on_click(on_resample_button)\n", + " super_resample_button = ipywidgets.Button(\n", + " description=\"!!Resample!!\", button_style=\"danger\"\n", + " )\n", + " super_resample_button.on_click(on_super_resample_button)\n", + "\n", + " widgets.append(\n", + " ipywidgets.Accordion(\n", + " children=[\n", + " ipywidgets.HBox(\n", + " [\n", + " stop_button,\n", + " resample_button,\n", + " super_resample_button,\n", + " make_hyperparameter_widget(\n", + " self.auto_resample, \"Auto Resample\", self.output\n", + " ),\n", + " ]\n", + " )\n", + " ],\n", + " titles=[\"Angry Buttons\"],\n", + " )\n", + " )\n", + "\n", + " def change_target_num_frames(new_target_num_frames):\n", + " try:\n", + " self.target_num_frames = np.clip(\n", + " new_target_num_frames, 1, self.scene.num_frames\n", + " )\n", + " frame_mask = np.arange(self.scene.num_frames) < self.target_num_frames\n", + " keypoint_mask = self.scene.keypoint_visibility[\n", + " : self.target_num_frames\n", + " ].any(0)\n", + "\n", + " self.gt_camera_display.set_mask(frame_mask)\n", + " for i, camera_display in enumerate(self.camera_displays):\n", + " if self.show_chain.value == -1:\n", + " camera_mask = np.array(True)\n", + " else:\n", + " camera_mask = np.array(i == self.show_chain.value)\n", + " camera_display.set_mask(camera_mask & frame_mask)\n", + "\n", + " self.gt_points_display.set_mask(keypoint_mask)\n", + " self.points_display.set_mask(keypoint_mask)\n", + " self.blobs_display.set_mask(\n", + " int(self.show_covariance.value) * keypoint_mask\n", + " )\n", + "\n", + " frame_text.value = (\n", + " f\"Num frames: {self.target_num_frames}/{self.scene.num_frames}\"\n", + " )\n", + " except Exception as e:\n", + " with self.output:\n", + " print(traceback.format_exc())\n", + "\n", + " # Oof\n", + " self.change_target_num_frames = change_target_num_frames\n", + "\n", + " def on_add_frame(_):\n", + " change_target_num_frames(self.target_num_frames + 1)\n", + "\n", + " def on_add_all_frames(_):\n", + " change_target_num_frames(self.scene.num_frames)\n", + "\n", + " def on_remove_frame(_):\n", + " change_target_num_frames(self.target_num_frames - 1)\n", + "\n", + " add_frame_button = ipywidgets.Button(description=\"Add Frame\")\n", + " add_all_frames_button = ipywidgets.Button(\n", + " description=\"Add ALL Frames\", button_style=\"warning\"\n", + " )\n", + " remove_frame_button = ipywidgets.Button(description=\"Remove Frame\")\n", + " frame_text = ipywidgets.Label()\n", + " add_frame_button.on_click(on_add_frame)\n", + " add_all_frames_button.on_click(on_add_all_frames)\n", + " remove_frame_button.on_click(on_remove_frame)\n", + "\n", + " # This sets up the initial masks.\n", + " change_target_num_frames(self.target_num_frames)\n", + "\n", + " widgets.append(\n", + " ipywidgets.HBox(\n", + " [\n", + " add_frame_button,\n", + " add_all_frames_button,\n", + " remove_frame_button,\n", + " make_hyperparameter_widget(\n", + " self.auto_advance_frames, \"Auto Advance\", self.output\n", + " ),\n", + " frame_text,\n", + " ]\n", + " )\n", + " )\n", + "\n", + " widgets.append(\n", + " make_hyperparameter_widget(\n", + " self.auto_advance_interval, \"Auto advance interval\", self.output\n", + " )\n", + " )\n", + "\n", + " widgets.append(\n", + " ipywidgets.HBox(\n", + " [\n", + " make_hyperparameter_widget(\n", + " self.show_covariance,\n", + " \"Show blobs\",\n", + " self.output,\n", + " callback_fn=lambda _: change_target_num_frames(\n", + " self.target_num_frames\n", + " ),\n", + " ),\n", + " make_hyperparameter_widget(\n", + " self.show_errors,\n", + " \"Show errors\",\n", + " self.output,\n", + " callback_fn=lambda _: change_target_num_frames(\n", + " self.target_num_frames\n", + " ),\n", + " ),\n", + " ]\n", + " )\n", + " )\n", + " widgets.append(\n", + " make_hyperparameter_widget(\n", + " self.show_chain,\n", + " \"Show chain\",\n", + " self.output,\n", + " lambda _: change_target_num_frames(self.target_num_frames),\n", + " )\n", + " )\n", + " widgets.append(\n", + " make_hyperparameter_widget(self.show_frame, \"Show frame\", self.output)\n", + " )\n", + "\n", + " widgets.append(\n", + " ipywidgets.Accordion(\n", + " children=[\n", + " ipywidgets.VBox(\n", + " [\n", + " ipywidgets.HBox(\n", + " [\n", + " make_hyperparameter_widget(\n", + " self.observation_noise_scale,\n", + " \"observation_noise_scale\",\n", + " self.output,\n", + " ),\n", + " make_hyperparameter_widget(\n", + " self.observation_noise_scale_override,\n", + " \"Override\",\n", + " self.output,\n", + " ),\n", + " ]\n", + " ),\n", + " make_hyperparameter_widget(\n", + " self.observation_noise_degrees,\n", + " \"observation_noise_degrees\",\n", + " self.output,\n", + " ),\n", + " make_hyperparameter_widget(\n", + " self.object_prior_scale,\n", + " \"object_prior_scale\",\n", + " self.output,\n", + " ),\n", + " ]\n", + " )\n", + " ],\n", + " titles=[\"Model hyperparameters\"],\n", + " )\n", + " )\n", + "\n", + " widgets.append(\n", + " ipywidgets.Accordion(\n", + " children=[\n", + " make_hyperparameter_widget(v, k, self.output)\n", + " for k, v in self.hparams.items()\n", + " ],\n", + " titles=[\"Inference hyperparameters\"],\n", + " )\n", + " )\n", + "\n", + " figures = {}\n", + " ground_truth = self.inference.get_ground_truth(self.scene)\n", + " for k, v in self.trace.items():\n", + " traces = []\n", + " for i in range(np.size(v)):\n", + " traces.append(\n", + " pgo.Scatter(\n", + " x=[],\n", + " y=[],\n", + " line_color=to_html(\n", + " chain_cmap(i / (self.inference.num_chains - 1))\n", + " ),\n", + " )\n", + " )\n", + " fig = pgo.FigureWidget(\n", + " data=traces,\n", + " layout=pgo.Layout(\n", + " title=dict(text=k),\n", + " margin=dict(l=1, r=1, t=30, b=1),\n", + " height=100,\n", + " ),\n", + " )\n", + " if k in ground_truth:\n", + " fig.add_hline(y=float(ground_truth[k]), line_color=\"red\")\n", + " # if k in ['step_size']:\n", + " # fig.update_yaxes(type=\"log\")\n", + " fig.update_layout(showlegend=False)\n", + " figures[k] = fig\n", + "\n", + " h = ipywidgets.HTML(\"Output\", layout=ipywidgets.Layout(width=\"1000px\"))\n", + "\n", + " widgets.append(self.output)\n", + "\n", + " output2 = ipywidgets.Output()\n", + " with output2:\n", + " display(self.scene_renderer)\n", + "\n", + " widgets.append(\n", + " ipywidgets.HBox([output2, ipywidgets.VBox(list(figures.values()))])\n", + " )\n", + "\n", + " widgets.append(h)\n", + "\n", + " self.figures = figures\n", + " self.widgets = widgets\n", + " self.h = h\n", + " self.quit = False\n", + "\n", + " def run_step(self, state):\n", + " cond_latents = {\n", + " \"keypoint_screen_positions\": self.scene.keypoint_screen_positions.astype(\n", + " DTYPE\n", + " ),\n", + " \"raw_observation_noise_scale\": observation_noise_scale_bij.inverse(\n", + " self.observation_noise_scale.value\n", + " ),\n", + " \"camera_positions\": jnp.ones_like(self.scene.camera_poses.position)[\n", + " 1:\n", + " ].astype(DTYPE),\n", + " \"camera_raw_quaternions\": jnp.ones_like(self.scene.camera_poses.quaternion)[\n", + " 1:\n", + " ].astype(DTYPE),\n", + " }\n", + " cond_mask = {\n", + " \"raw_observation_noise_scale\": np.array(\n", + " self.observation_noise_scale_override.value\n", + " ),\n", + " \"camera_positions\": ~self.model_args.camera_visibility[1:, jnp.newaxis],\n", + " \"camera_raw_quaternions\": ~self.model_args.camera_visibility[\n", + " 1:, jnp.newaxis\n", + " ],\n", + " }\n", + " hparams_kwargs = {k: v.value for k, v in self.hparams.items()}\n", + " return self.inference.step_fn(\n", + " state,\n", + " self.step,\n", + " cond_latents,\n", + " cond_mask,\n", + " self.model_args,\n", + " **hparams_kwargs,\n", + " )\n", + "\n", + " def _ipython_display_(self):\n", + " if not self.quit:\n", + " display(*self.widgets)\n", + " self.task = asyncio.create_task(self.animate())\n", + "\n", + " def __del__(self):\n", + " self.quit = True\n", + "\n", + " def set_output(self, s):\n", + " content = \"
\".join(s.split(\"\\n\"))\n", + " self.h.value = content\n", + "\n", + " def stop(self):\n", + " self.quit = True\n", + "\n", + " async def animate(self):\n", + " try:\n", + " while not self.quit:\n", + " if (\n", + " self.auto_advance_frames.value\n", + " and (self.step + 1) % self.auto_advance_interval.value == 0\n", + " ):\n", + " self.change_target_num_frames(self.target_num_frames + 1)\n", + "\n", + " self.model_args = self.model_args._replace(\n", + " camera_visibility=(\n", + " jnp.arange(self.scene.num_frames) < self.target_num_frames\n", + " ),\n", + " keypoint_visibility=self.scene.keypoint_visibility.at[\n", + " self.target_num_frames :\n", + " ].set(False),\n", + " observation_noise_degrees=jnp.array(\n", + " self.observation_noise_degrees.value, DTYPE\n", + " ),\n", + " object_prior_scale=jnp.array(self.object_prior_scale.value),\n", + " )\n", + " for frame in range(self.cur_num_frames, self.target_num_frames):\n", + " self.state = self.inference.init_frame_fn(\n", + " state=self.state,\n", + " frame=frame,\n", + " scene=self.scene,\n", + " model_args=self.model_args,\n", + " )\n", + " self.cur_num_frames = self.target_num_frames\n", + "\n", + " start = time.time()\n", + " new_state, extra = self.run_step(self.state)\n", + " end = time.time()\n", + " tlp_extra = extra.tlp_extra\n", + "\n", + " if not self.pause.value:\n", + " self.state = new_state\n", + " if self.super_resample:\n", + " self.super_resample = False\n", + " resample_strength = 1.0\n", + " else:\n", + " resample_strength = 1e-3\n", + "\n", + " if (self.auto_resample.value or self.resample) or not jnp.all(\n", + " jnp.isfinite(extra.target_log_prob)\n", + " ):\n", + " (_, _), ancestor_idx = fun_mc.systematic_resample(\n", + " (),\n", + " resample_strength * extra.target_log_prob,\n", + " jax.random.key(self.step),\n", + " )\n", + " self.state = self.inference.resample_fn(self.state, ancestor_idx)\n", + " self.num_resample += 1\n", + " self.resample = False\n", + "\n", + " if not self.pause.value:\n", + " for k in self.trace.keys():\n", + " self.trace[k].append(extra.traced[k])\n", + "\n", + " loc, cov = get_loc_cov(tlp_extra[\"keypoint_world_positions\"])\n", + "\n", + " for i, camera_display in enumerate(self.camera_displays):\n", + " camera_display.set_state(\n", + " positions=tlp_extra[\"camera_poses\"].position[i],\n", + " quaternions=tlp_extra[\"camera_poses\"].quaternion[i],\n", + " )\n", + " show_chain = max(0, self.show_chain.value)\n", + " self.points_display.set_state(\n", + " positions=tlp_extra[\"keypoint_world_positions\"][show_chain],\n", + " )\n", + " self.blobs_display.set_state(\n", + " positions=loc,\n", + " covariances=9 * cov,\n", + " )\n", + " show_frame = self.show_frame.value\n", + " if show_frame < 0:\n", + " show_frame = self.cur_num_frames - 1\n", + " error_sizes = (\n", + " 1.0 + 25. * tlp_extra[\"l1_errors\"][show_chain, show_frame]\n", + " )\n", + " error_sizes = np.where(np.isfinite(error_sizes), error_sizes, 0.0)\n", + " self.error_display.set_mask(\n", + " int(self.show_errors.value)\n", + " * self.scene.keypoint_visibility[show_frame].astype(DTYPE)\n", + " * error_sizes,\n", + " )\n", + "\n", + " for k, trace in self.trace.items():\n", + " if len(trace) <= 1:\n", + " continue\n", + " trace = np.array(trace)\n", + " trace = trace.reshape([len(trace), -1])[1:]\n", + " fig = self.figures[k]\n", + " w = 200\n", + " last_half = trace[-w:]\n", + " span = np.nanmax(last_half) - np.nanmin(last_half)\n", + " with fig.batch_update():\n", + " for j in range(trace.shape[-1]):\n", + " x = np.arange(len(trace))[-w:]\n", + " y = trace[:, j][-w:]\n", + " x = x[np.isfinite(y)]\n", + " y = y[np.isfinite(y)]\n", + " fig.data[j].x = x\n", + " fig.data[j].y = y\n", + " if False:\n", + " fig.update_yaxes(\n", + " range=[\n", + " np.nanmin(last_half) - span * 0.1,\n", + " np.nanmax(last_half) + span * 0.1,\n", + " ]\n", + " )\n", + "\n", + " if self.status is None:\n", + " self.set_output(\n", + " \"\\n\".join(\n", + " [\n", + " f\"step: {self.step}\",\n", + " f\"step time: {end - start:.2f}\",\n", + " f\"num resample: {self.num_resample}\",\n", + " ]\n", + " + [f\"{k}: {float(v):.2f}\" for k, v in extra.logged.items()]\n", + " )\n", + " )\n", + " else:\n", + " self.set_output(self.status)\n", + " self.quit = True\n", + " if not self.pause.value:\n", + " self.step += 1\n", + " await asyncio.sleep(1 / 10)\n", + " except Exception as e:\n", + " with self.output:\n", + " print(traceback.format_exc())\n", + " self.quit = True" + ] + }, + { + "cell_type": "markdown", + "id": "ec7c29c5-dfda-4f8f-b826-86aa1f0299bd", + "metadata": {}, + "source": [ + "## Run" + ] + }, + { + "cell_type": "markdown", + "id": "20492d25-6e1f-43f4-9e54-f15325b426be", + "metadata": {}, + "source": [ + "By default, this will not infer the observation noise scale, since for this synthetic example, there is no noise. When initializing frames via unprojection, it's important to add them one-by-one, and let the inference stabilize." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "18880aa7-ebf7-4b67-b50c-91ccd50b6345", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3211f417ba9d4c159ed878ce98a7f63f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "ToggleButton(value=True, button_style='info', icon='pause')" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ae34ef2e917a44c0b6dc9324846128c1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Accordion(children=(HBox(children=(Button(button_style='danger', description='⏼', style=ButtonStyle()), Button…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "db8a357f379a44d3b4d6bed7395f2b7d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(Button(description='Add Frame', style=ButtonStyle()), Button(button_style='warning', descriptio…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f4a764ab1f834ce79fad0bb399731463", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "IntSlider(value=20, description='Auto advance interval', layout=Layout(width='500px'), max=200, min=1, style=S…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "930a24f376cb478d98f403ba881a34e8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(ToggleButton(value=True, description='Show blobs', icon='check-circle-o'), ToggleButton(value=T…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b336c46f61714642aaf46d85b9016f16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "IntSlider(value=-1, description='Show chain', layout=Layout(width='500px'), max=3, min=-1, style=SliderStyle(d…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "471e1967fbda43feabb4fdddb4111b1d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "IntSlider(value=-1, description='Show frame', layout=Layout(width='500px'), max=99, min=-1, style=SliderStyle(…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "55a38c12281648a98170fa6487bc9f9b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Accordion(children=(VBox(children=(HBox(children=(FloatLogSlider(value=0.01, description='observation_noise_sc…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b265699673b41e58fae25660f5d2000", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Accordion(children=(IntSlider(value=50, description='mean_num_leapfrog_steps', layout=Layout(width='500px'), m…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e49f31c6b0834075a6f17809feee588b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Output()" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fe00704e21874134be1168f031f14a97", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(Output(), VBox(children=(FigureWidget({\n", + " 'data': [{'line': {'color': '#440154'},\n", + " …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c39a35b9f4ca446d8a7bd5417b871a83", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value='Output', layout=Layout(width='1000px'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if INTERACTIVE_INFERENCE is not None:\n", + " INTERACTIVE_INFERENCE.stop()\n", + "\n", + "with warnings.catch_warnings(action=\"ignore\"):\n", + " INTERACTIVE_INFERENCE = InteractiveInference(\n", + " scene=SCENE,\n", + " model=MODEL,\n", + " inference=INFERENCE,\n", + " model_args=DEFAULT_MODEL_ARGS,\n", + " init_latents=INIT_LATENTS,\n", + " )\n", + " display(INTERACTIVE_INFERENCE)" + ] + }, + { + "cell_type": "markdown", + "id": "3b86ef5c-d617-433b-9de0-5fd7f41b61ab", + "metadata": {}, + "source": [ + "# Batch Inference (Non-incremental)" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "f2d381da-4e49-4e5e-a70a-2b8431fa9f9f", + "metadata": {}, + "outputs": [], + "source": [ + "class BatchInference:\n", + " def __init__(\n", + " self,\n", + " model,\n", + " inference,\n", + " scene,\n", + " model_args,\n", + " init_latents,\n", + " num_steps,\n", + " num_warmup_steps,\n", + " num_leapfrog_steps,\n", + " ):\n", + " self.model = model\n", + " self.inference = inference\n", + " self.scene = scene\n", + " self.model_args = model_args\n", + " \n", + " init_state = self.inference.init_fn(init_latents, 1e-6)\n", + " for i in range(self.scene.num_frames):\n", + " init_state = self.inference.init_frame_fn(init_state, i, self.scene, self.model_args)\n", + "\n", + " cond_latents = {\n", + " \"keypoint_screen_positions\": self.scene.keypoint_screen_positions.astype(\n", + " DTYPE\n", + " ),\n", + " \"raw_observation_noise_scale\": observation_noise_scale_bij.inverse(\n", + " 1e-2\n", + " ).astype(DTYPE),\n", + " }\n", + " cond_mask = {\n", + " \"raw_observation_noise_scale\": True,\n", + " }\n", + "\n", + " @jax.jit\n", + " def kernel(state, step):\n", + " state, extra = self.inference.step_fn(\n", + " state,\n", + " step,\n", + " cond_latents,\n", + " cond_mask,\n", + " self.model_args,\n", + " num_leapfrog_steps,\n", + " adapt=step < int(num_warmup_steps * 0.8),\n", + " )\n", + " traced = extra.traced\n", + " final = {\"rhats\": extra.extra[\"rhats\"]}\n", + " return (state, step + 1), (traced, final)\n", + "\n", + " it_state = fun_mc.interruptible_trace_init(\n", + " state=(init_state, 0),\n", + " fn=kernel,\n", + " num_steps=num_warmup_steps + num_steps,\n", + " trace_mask=(True, False),\n", + " )\n", + "\n", + " self.it_state = it_state\n", + " self.kernel = kernel\n", + "\n", + " self.num_steps = num_steps\n", + " self.num_warmup_steps = num_warmup_steps\n", + " self.output = ipywidgets.Output()\n", + " self.image = ipywidgets.Image(format=\"png\")\n", + " self.widgets = [ipywidgets.VBox([self.output, self.image])]\n", + "\n", + " def run(self):\n", + " display(*self.widgets)\n", + "\n", + " with self.output:\n", + " for i in tqdm.notebook.tqdm(range(self.num_steps + self.num_warmup_steps)):\n", + " start = time.time()\n", + " self.it_state, _ = fun_mc.interruptible_trace_step(\n", + " self.it_state, self.kernel\n", + " )\n", + " if i == 10:\n", + " print(f'Iter time (sec): {time.time() - start:.2f}')\n", + "\n", + " if (i + 1) % 100 == 0:\n", + " traced, final = self.it_state.trace()\n", + " fig = self.trace_plot(traced, final)\n", + " bytes_io = io.BytesIO()\n", + " fig.savefig(bytes_io, format=\"png\")\n", + " plt.close(fig)\n", + "\n", + " self.image.value = bytes_io.getvalue()\n", + "\n", + " def trace_plot(self, traced, final):\n", + " fig, axs = plt.subplots(len(traced), 2, squeeze=False, figsize=(12, 10))\n", + " t = np.arange(len(jax.tree.leaves(traced)[0]))\n", + " ground_truth = self.inference.get_ground_truth(self.scene)\n", + " for i, (k, v) in enumerate(traced.items()):\n", + " for j, s in enumerate([np.s_[:], np.s_[-100:]]):\n", + " ax = axs[i, j]\n", + " ax.plot(t[s], v[s])\n", + "\n", + " if k in ground_truth:\n", + " ax.axhline(ground_truth[k], color=\"red\", lw=2)\n", + " ax.set_title(k)\n", + "\n", + " ax.minorticks_on()\n", + " ax.grid(which=\"both\")\n", + " ax.grid(which=\"minor\", ls=\"--\", alpha=0.5)\n", + "\n", + " fig.tight_layout()\n", + " return fig\n", + "\n", + " def rhat_plot(self, traced, final):\n", + " rhats = final[\"rhats\"]\n", + " fig, axs = plt.subplots(len(rhats), figsize=(3, 2 * len(rhats)))\n", + "\n", + " for i, (k, v) in enumerate(rhats.items()):\n", + " ax = axs[i]\n", + " ax.hist(v.ravel(), bins=40, log=True, range=(1, v.max()))\n", + "\n", + " ax.set_title(f\"{k} rhat\")\n", + " ax.minorticks_on()\n", + " ax.grid(which=\"both\")\n", + " ax.grid(which=\"minor\", ls=\"--\", alpha=0.5)\n", + " fig.tight_layout()\n", + " return fig\n", + "\n", + " def rhat_keypoint_world_positions_plot(self, traced, final):\n", + " fig, ax = plt.subplots()\n", + " rhats = final[\"rhats\"]\n", + " keypoint_rhats = rhats[\"keypoint_world_positions\"].ravel()\n", + " ax.scatter(\n", + " jnp.repeat(self.scene.keypoint_visibility.sum(0)[:, jnp.newaxis], 3, axis=-1).ravel(),\n", + " keypoint_rhats - 1,\n", + " )\n", + " ax.set_yscale(\"log\")\n", + " ax.set_title(\"keypoint_world_positions rhats\")\n", + " ax.set_xlabel(\"num frames visible\")\n", + " ax.set_ylabel(\"rhat - 1\")\n", + "\n", + " ax.minorticks_on()\n", + " ax.grid(which=\"both\")\n", + " ax.grid(which=\"minor\", ls=\"--\", alpha=0.5)\n", + " return fig" + ] + }, + { + "cell_type": "markdown", + "id": "f62d6999-ee22-4ad5-b9d0-651d2761b265", + "metadata": {}, + "source": [ + "## Run" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "8fdfb734-7f31-46a2-8d21-b0b136006ea2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ff79451731dc43a1a97b7b075499f293", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(Output(), Image(value=b'')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with warnings.catch_warnings(action=\"ignore\"):\n", + " batch_inference = BatchInference(\n", + " model=MODEL,\n", + " scene=SCENE,\n", + " inference=INFERENCE,\n", + " init_latents=INIT_LATENTS,\n", + " model_args=DEFAULT_MODEL_ARGS,\n", + " num_leapfrog_steps=400,\n", + " num_warmup_steps=500,\n", + " num_steps=1000,\n", + " )\n", + " batch_inference.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "e892e6a2-8a34-48ec-98d4-f4840258097b", + "metadata": {}, + "outputs": [], + "source": [ + "traced, final = batch_inference.it_state.trace()" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "01c2dc8a-716f-4a59-887d-d61f8432a3fa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_inference.rhat_plot(traced, final);" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "2f91df75-32aa-496c-8baa-506535b1db86", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9d3gc1dX+O7NNqy5ZvVd3m+KKcQWMMWDLjV4c+ALkxwcxmBRC8iWQhC8JLSaJ8xFSTQcbg8EGF8ANd2NwkYukVbF6sbpW0u7OzO+P1R3N7M7szu7Oylp73ufRY+/du2fOObfMveeeew7FcRwHDRo0aNCgQYOGyxD0xWZAgwYNGjRo0KDhYkFbCGnQoEGDBg0aLltoCyENGjRo0KBBw2ULbSGkQYMGDRo0aLhsoS2ENGjQoEGDBg2XLbSFkAYNGjRo0KDhsoW2ENKgQYMGDRo0XLbQFkIaNGjQoEGDhssW2kJIgwYNGjRo0HDZQlsIadAA4NlnnwVFUWhpabnYrAQEIsflhJycHHzve9/zWu8///kPKIpCZWVl0HkKFBRF4dlnn1VUV6n8wwmVlZWgKAovvfTSxWZFgwZtIaRBgwYn9u/fj2effRbt7e0XmxUNLtDaxjs0HWnwF9pCSIOGSwi/+MUv0Nvb69dv9+/fj+eee057kQwD9Pb24he/+AX/2VPbnDt3Dn//+9+HkLvhCa3/avAX+ovNgAYNGtSDXq+HXn/pD2uO49DX1wez2XyxWQkKwsLCFNc1mUxB5ER9WK3Wi82CBg0iaBYhDRpkUFVVhYKCAowfPx6NjY0AgPb2djzxxBPIzMyEyWRCQUEB/vCHP4BlWQDOF3ROTg6Kiorc6PX19SEmJgaPPPIIAGDXrl2gKArvv/8+nnnmGaSkpCAiIgKLFy9GdXW12+/Xr1+PSZMmwWw2IyEhAffeey9qa2tFdaR8hCiKwmOPPYaPP/4Y48ePh8lkwrhx47B161bR73784x8DAHJzc0FRlGJ/mk8++QQUReHEiRN82YcffgiKorBs2TJR3TFjxuCOO+7gPzscDvzmN79Bfn4+TCYTcnJy8Mwzz6C/v1/0u5ycHNx6663Ytm0bJk+eDLPZjL/97W+yPBUXF+O6666D2WxGRkYGfvvb3/Jt5AuIPs+ePYvbb78d0dHRGDFiBFatWoW+vj5RXaWyHD16FAsWLEBCQgLMZjNyc3Px4IMPiuoIfYS8tY2Uj1B5eTluu+02xMfHIzw8HNOnT8eWLVtEdUj/++CDD/D8888jIyMDYWFhuP7661FWViaqW1paiuXLlyMlJQVhYWHIyMjAnXfeiY6ODo/6mzt3LsaPH49vvvkGs2fPRnh4OJ555hlRnddff53X2ZQpU3DkyBHR9ydOnMD3vvc95OXlISwsDCkpKXjwwQdx4cIFvo43He3YsQMzZ85EbGwsIiMjMWrUKDc+NFy+uPS3jho0+AGLxYLrrrsO8fHx2LFjBxISEmC1WjFnzhzU1tbikUceQVZWFvbv34+f/exnqK+vx5o1a0BRFO6991688MILaG1tRXx8PE/z008/RWdnJ+69917Rs55//nlQFIWf/vSnaGpqwpo1a3DDDTfgu+++4y0e//nPf/DAAw9gypQp+N3vfofGxka8+uqr2LdvH7799lvExsZ6lOfrr7/Gxo0b8eijjyIqKgp/+tOfsHz5cpw/fx4jRozAsmXLUFJSgnfffRd//OMfkZCQAABITEz0qquZM2eCoijs2bMHEydOBADs3bsXNE3j66+/5us1Nzfj7NmzeOyxx/iy73//+1i3bh1WrFiBp556CocOHcLvfvc7nDlzBh999JHoOefOncNdd92FRx55BA899BBGjRolyU9DQwPmzZsHh8OBp59+GhEREXj99dcDsh7dfvvtyMnJwe9+9zscPHgQf/rTn9DW1oY33njDJ1mamppw4403IjExEU8//TRiY2NRWVmJjRs3yj7b17ZpbGzEjBkzYLVa8cMf/hAjRozAunXrsHjxYmzYsAFLly4V1f/9738Pmqbxox/9CB0dHXjhhRdwzz334NChQwAAm82GBQsWoL+/H48//jhSUlJQW1uLzZs3o729HTExMR51d+HCBSxcuBB33nkn7r33XiQnJ/PfvfPOO+jq6sIjjzwCiqLwwgsvYNmyZSgvL4fBYADgXMSUl5fjgQceQEpKCoqLi/H666+juLgYBw8e5BfccjoqLi7GrbfeiokTJ+LXv/41TCYTysrKsG/fPo98a7iMwGnQoIH71a9+xQHgmpubuTNnznBpaWnclClTuNbWVr7Ob37zGy4iIoIrKSkR/fbpp5/mdDodd/78eY7jOO7cuXMcAO7//u//RPUWL17M5eTkcCzLchzHcTt37uQAcOnp6VxnZydf74MPPuAAcK+++irHcRxns9m4pKQkbvz48Vxvby9fb/PmzRwA7pe//KWbHEIA4IxGI1dWVsaXHT9+nAPA/fnPf+bLXnzxRQ4AV1FR4ZPuOI7jxo0bx91+++3856uvvpq77bbbOADcmTNnOI7juI0bN3IAuOPHj3Mcx3HfffcdB4D7/ve/L6L1ox/9iAPAffXVV3xZdnY2B4DbunWr27Ozs7O5lStX8p+feOIJDgB36NAhvqypqYmLiYnxWT6iz8WLF4vKH330Ub9k+eijjzgA3JEjRzw+FwD3q1/9iv/sqW3k5N+7dy9f1tXVxeXm5nI5OTkcwzAcxw32vzFjxnD9/f183VdffZUDwJ08eZLjOI779ttvOQDc+vXrPfIshTlz5nAAuNdee01UXlFRwQHgRowYIRpjmzZt4gBwn376KV9mtVrd6L777rscAG7Pnj18mZyO/vjHP/JjW4MGKWhHYxo0CHDq1CnMmTMHOTk5+OKLLxAXF8d/t379esyaNQtxcXFoaWnh/2644QYwDIM9e/YAAEaOHIlp06bh7bff5n/b2tqKzz//HPfcc4/b0dX999+PqKgo/vOKFSuQmpqKzz77DIDzKKWpqQmPPvqoyHfklltuwejRo92OPKRwww03ID8/n/88ceJEREdHo7y83EcNSWPWrFnYu3cvAKCrqwvHjx/Hww8/jISEBL587969iI2Nxfjx4wGAl2/16tUiWk899RQAuMmVm5uLBQsWeOXls88+w/Tp0zF16lS+LDExEffcc4+f0gH//d//Lfr8+OOP888S/utNFmK527x5M+x2u9/8eMJnn32GqVOnYubMmXxZZGQkHn74YVRWVuL06dOi+g888ACMRiP/edasWQDA9w1i8dm2bZtf/j0mkwkPPPCA5Hd33HGHaIy5PhuAyJLX19eHlpYWTJ8+HQBw7Ngxr88nOt+0aZNfx6MaLn1oCyENGgRYtGgRoqKisG3bNkRHR4u+Ky0txdatW5GYmCj6u+GGGwA4jz0I7r//fuzbtw9VVVUAnIsou92O++67z+2ZhYWFos8URaGgoID3byA0pI6CRo8ezX/vCVlZWW5lcXFxaGtr8/pbJZg1axbq6+tRVlaG/fv3g6IoXHPNNaIF0t69e3HttdeCpp3TTlVVFWiaRkFBgYhWSkoKYmNj3eTKzc1VxEtVVZWbTgFp/SmFK738/HzQNC1qIyWyzJkzB8uXL8dzzz2HhIQEFBUV4d///rebH1EgqKqqkpR1zJgx/PdCuPYNsjAhfSM3NxerV6/GP/7xDyQkJGDBggVYu3atV/8ggvT0dNFCy5dnA85NxKpVq5CcnAyz2YzExES+Lyjh4Y477sC1116L73//+0hOTsadd96JDz74QFsUaeChLYQ0aBBg+fLlsFgsImsOAcuymD9/Pnbs2CH5t3z5cr7unXfeCYPBwNN56623MHny5IBexoFAp9NJlnMcpwp9Yn3Ys2cP9u7di6uvvhoRERH8Qqi7uxvffvstv+MXQmkAyOF0Q0yOZ2+yUBSFDRs24MCBA3jsscdQW1uLBx98EJMmTUJ3d3cwWPUKJX3j5ZdfxokTJ/DMM8+gt7cXP/zhDzFu3DjU1NR4pe+p3ZQ8+/bbb8ff//53/OAHP8DGjRuxfft23tFfyWLGbDZjz549+OKLL3DffffhxIkTuOOOOzB//nwwDOP19xoufWgLIQ0aBHjxxRfxX//1X3j00UfxzjvviL7Lz89Hd3c3brjhBsk/4e42Pj4et9xyC95++21UVVVh3759ktYgwGlpEoLjOJSVlSEnJwcAkJ2dDcDpLOyKc+fO8d8HikAiUmdlZSErKwt79+7F3r17+QXP7NmzUVlZifXr14NhGMyePZv/TXZ2NliWdZO/sbER7e3tfsuVnZ3tRhOQ1p9SuNIrKysDy7KiNvJFlunTp+P555/H0aNH8fbbb6O4uBjvvfee7PN9aZvs7GxJWc+ePct/7w8mTJiAX/ziF/xit7a2Fq+99ppftJSira0NX375JZ5++mk899xzWLp0KebPn4+8vDy3up50RNM0rr/+erzyyis4ffo0nn/+eXz11VfYuXNnMNnXECLQFkIaNAhAURRef/11rFixAitXrsQnn3zCf3f77bfjwIED2LZtm9vv2tvb4XA4RGX33XcfTp8+jR//+MfQ6XS48847JZ/5xhtvoKuri/+8YcMG1NfXY+HChQCAyZMnIykpCa+99proCOXzzz/HmTNncMsttwQkM0FERAQviz+YNWsWvvrqKxw+fJhfCF155ZWIiorC73//e5jNZkyaNImvf/PNNwMA1qxZI6LzyiuvAIDfct188804ePAgDh8+zJc1NzdLWvmUYu3ataLPf/7znwGAbyOlsrS1tblZ4a688koA8Hg85kvb3HzzzTh8+DAOHDjAl/X09OD1119HTk4Oxo4d65WGEJ2dnW59e8KECaBpWtUjPSkQi5Grzlz1DMjrqLW11a2uEp1ruHygXZ/XoMEFNE3jrbfewpIlS3D77bfjs88+w3XXXYcf//jH+OSTT3Drrbfie9/7HiZNmoSenh6cPHkSGzZsQGVlJX9tF3C+/EaMGIH169dj4cKFSEpKknxefHw8Zs6ciQceeACNjY1Ys2YNCgoK8NBDDwEADAYD/vCHP+CBBx7AnDlzcNddd/HX53NycvDkk0+qIjdZpPz85z/nj/YWLVrEv2C8YdasWXj77bdBURR/VKbT6TBjxgxs27YNc+fOFfmKXHHFFVi5ciVef/11tLe3Y86cOTh8+DDWrVuHJUuWYN68eX7J8ZOf/ARvvvkmbrrpJqxatYq/Pp+dnS2KdeQLKioqsHjxYtx00004cOAA3nrrLdx999244oorfJJl3bp1+Otf/4qlS5ciPz8fXV1d+Pvf/47o6Gh+MSUFX9rm6aefxrvvvouFCxfihz/8IeLj47Fu3TpUVFTgww8/5H20lOKrr77CY489httuuw0jR46Ew+HAm2++CZ1OJzoODgaio6Mxe/ZsvPDCC7Db7UhPT8f27dtRUVHhVldOR7/+9a+xZ88e3HLLLcjOzkZTUxP++te/IiMjQ+RQruEyxsW8sqZBw3CB8Po8gdVq5ebMmcNFRkZyBw8e5DjOeQ35Zz/7GVdQUMAZjUYuISGBmzFjBvfSSy9xNpvNjS65Zv3OO++4fUeuL7/77rvcz372My4pKYkzm83cLbfcwlVVVbnVf//997mrrrqKM5lMXHx8PHfPPfdwNTU1knIIAYD77//+bzd6rteuOc4ZIiA9PZ2jadrnq+bFxcX8dWwhfvvb33IAuP/5n/9x+43dbueee+45Ljc3lzMYDFxmZib3s5/9jOvr63Pj9ZZbbpF8rpQcJ06c4ObMmcOFhYVx6enp3G9+8xvun//8p9/X50+fPs2tWLGCi4qK4uLi4rjHHntMFMpAqSzHjh3j7rrrLi4rK4szmUxcUlISd+utt3JHjx4V0YLL9XmOk28bKfktFgu3YsUKLjY2lgsLC+OmTp3Kbd68WVSH9D/Xa/Hkavu///1vjuM4rry8nHvwwQe5/Px8LiwsjIuPj+fmzZvHffHFF171N2fOHG7cuHFu5eQZL774ott3rrLX1NRwS5cu5WJjY7mYmBjutttu4+rq6hTr6Msvv+SKioq4tLQ0zmg0cmlpadxdd93lFgZDw+ULiuNU8pbUoEGDG5588kn885//RENDA8LDw0Xf7dq1C/PmzcP69euxYsWKi8ShBk949tln8dxzz6G5uVlk7dOgQcOlA81HSIOGIKGvrw9vvfUWli9f7rYI0qBBgwYNwwOaj5AGDSqjqakJX3zxBTZs2IALFy5g1apVF5slv9HR0eE1m31KSsoQcaMeuru7vV5XV5JeRIMGDaEPbSGkQYPKOH36NO655x4kJSXhT3/6E39DJRSxatUqrFu3zmOdUDxdf+mll/Dcc895rCPlkKtBg4ZLD5qPkAYNGmRx+vRp1NXVeaxDImuHEsrLy72mF5k5c6YopYkGDRouTWgLIQ0aNGjQoEHDZQvNWVqDBg0aNGjQcNlC8xHyApZlUVdXh6ioqIBSEGjQoEGDBg0ahg4cx6GrqwtpaWkeA4lqCyEvqKurQ2Zm5sVmQ4MGDRo0aNDgB6qrq5GRkSH7vbYQ8oKoqCgAQGVlJaKjowE481HRNA2WZUU3ZuTKaZqGw+HA9u3bcf3118NgMPDlFEW5ZUAmK1fXzMpy5RRFoba2FikpKXwdwgvHcaL6vvLOcRwaGhqQkpIisogR3qVkVSoTy7JoaGhAWloaXKHT6WR5VyKT3W7Hl19+iRtvvJGn5U1WpTKxLIv6+nqkp6fzdLzJqlQmQjstLQ16vV5xOymRiWEY1NfXIzU1FXq9XpW+R2Tq7+/Hl19+ieuvvx5Go1GVvkfKHQ4H6urqkJqaCpqmVel7pJxlWdTW1vK0lbaTEt4ByI5Lf/seAcMw2LFjh2g+8SSrLzLJjflA+h4pJ2M+PT3d7bahv32PlJOxk5GRwT/XX95dy8l8Mn/+fBiNRlX6HiknfKempsJgMKjS90i5cMzrdDpV+h7h3eFw8LTJuFTSTkpk6u/vxxdffMH3b3/7Hkl4TN7jctAWQjJYu3Yt1q5dy3eC5uZmPp5KTEwMUlNTUV9fj46ODv43CQkJSEhIQHV1NXp6evjylJQUREdHIzw8HM3NzXwiwYyMDERGRqKkpETUGXJzc6HX690yWRcWFsLhcIiu9dI0jfz8fDAMg8bGRr4zGo1G5OXlob29HY2NjXz9iIgIZGZmoqWlBS0tLXy5nExxcXGgaRpdXV2ieDIpKSmIiYlBeXk5bDYbX+6LTCzLgqIomEwmnD9/XiTTyJEj0d3djfr6er7cF5kYhkF4eDiio6PR0tKiuJ2UyMSyLNrb25GXlweTyaS4nZTIRGhHRUUhOztbcTspkamvrw/t7e2gaRpZWVmq9D0iU3NzM9+/zWazKn2PyFRVVcXzTdO0Kn2PyNTf3y+irUbfIzIlJSWht7dXNC4D7XvCctf5REk7KZHJbDaDpmnY7Xa0tbUpbiclMpGXc1RUFCwWiyp9j8jEsiy6uroQFRWFrq4uVfoekYnMJ4Az/5kafY/IRMa8wWDAqFGjVOl7RKa2tja+fyclJanS94hM586dE40dNfoekYlE4if929++R3jx5tai3Rrzgs7OTsTExKC1tTVgi9Bnn32GBQsWqG4RAoCSkhLk5+fzk6JaFiGWZWGxWJCfny86Y1VjV84wDCwWCwoLC906qhoWoW3btuHmm29W3SLEMAzKysowcuRI6HQ6VS1ChHZhYSEMBoOqFiGHw4GysjIUFBTwuyw1LULbtm3DggULVLcI2e12lJaWoqCggN/VqmURYhgGJSUlPG2l7aSEd47jZMelGhahzz//XDSfKGknJTLJjXk1LEJkzI8cORKuCNQiJKTtaqlVwyK0bds2LFy4UHWLEBnzBQUFMBqNqlqEhGNer9erahGy2+08bTIulbSTEpn6+/uxdetWvn8HYhGKi4tDR0cH//6WgmYRUgidTifaeQEQTRJKyuXouH72tZxhGFAUJUmblCvl0VO5L3SU8k5RlCyPvpYLeREOLn9k9cY7GWhyvLjW98a7sFxoZlaLd9J+5F+y8Ay077nyLpwQ1ex7hG/XNlCDdynagfQ9Ak/jMpC+Bwz2bynaUvU98e5JJrXaz/V5cjz6Wu7KO6GtZt8DBvVN6KvR94TlQl2r0feENIX/eqvvK+9SY0fNuVzpmPfnXSyqp6iWhmENclygtNEvB9rBRKjqRNP3pUM7mAhVnWj6vnRoDzU0i5BCMAzDmwj9MdMJ6QhX5modT8TExKhmTnUtj42N5X1jhLyocTwRExPD68VVpkBMxEJ6gZjy5WQizneuvHiSValMUVFR4DhOkpdAjyeioqLAsqyqfY/jONGxIdkpqnU0JuRbSiZXWX2VSUhbKJMa4yk6OlpRfV9lEvZz4fyi1vGE1JhX42gMcI55NfuesDw6Opo/llTzaIzwKnT6VutoDBjsg2r2Pdcxr1bfE/LuOi6lZPVXJmCwfwfS95RAWwjJwNVZ2mKxIDIyEsCgM1pjY6Ok41Ztba2b41ZERARPx9VZOlCnwYKCApw7dw7AoOmWOKN1dHSgoaGBr0+c0VpbWyUd7Fxlio+PR3d3N3Q6nZuzdGxsLCorKyUd7JTIxHEcDAYD0tPTUVVVJZJp5MiR6OnpQU1NDV/ui0zCwetLOymRieM4tLe348orr4TRaPTJudObTIR2WloasrOzFbeTEpmIY3BsbCwyMzNV6XtEJtJ+FouFd5YOtO8JHSHr6uoQGxsLiqJU6XtEJpvNhu+++46nrUbfIzIlJyfjxIkTMJlM/LgMtO8Jy4m+lTpLK5XJbDaDYRhERkaitbVVcTspkYm8rEaNGqVa3yMycRyH7u5uTJo0CZ2dnar0PSITmU86OzuRkJCgSt8jMpExHx8fj1GjRqnS94hM7e3t/JhPTExUpe8RmUpKSnjaFEWp0veITMRJn/Rvf/ue8L3iCZqztBdoztKas7SrTJqztLtMmrO05iytRCbNWdq9XHOW1pylQwaas7TmLK05S2vO0r7IpDlLS5cHq+8JaavZ9wDNWVquXGrsaM7SGjRo0KBBgwYNIQTNIqQQw9lZmqZpPlKrK4+BHk8Ag/4IQj7VOJ7gOA7p6emS9YezszTHcUhLS5N0ypSTValMhLavvCuVKS0tDRzH8c7YoeAsDYDnW+g8qcbxBEVRItpCmdQ4nnClrdbRWDCdpQHpMa/G0RgZ8+RYUohAj8ZI/1az75HyYDpLC8cleYZaR2NC2izLqno0JqQt7IdqHI0JjzsJH/72PSXQFkIyGGpnabvDgSMt59Fm64MuIQYPjZmBKoHTGeDZaZCiKJSVlfHlajlLe4rcqZbDqt1uV8XBbqicpZXIpJbToJrO0sGUKZjO0nV1dUGVqa6uTlImNdqpp6dHRD8UnKW9RSxWo+9RFBW08RQdHY329vaQcZZWItNwnCOE7xu1ZdKcpYcZhsJZ+qeHP8Wrp/eCIbs8cKApCk+NnY3/nXSziA4g7SxdVlaG3NzcoDhLV1RUIDc3123nqYazdEVFBfLz80POWbq8vJx3ElTTIkRo5+fnB8VZury8HHl5eSHnLG2xWJCXlxcUZ+mysjKettJ2UsI7x3Gy4zLQXXmwnaWlxrxaztIVFRUoKCiAKwK1CAlpC60K/vA+1M7SZFwGw1ma0A6GszShrTlLXyYIlrP0T45sxovFu93qMRyHF4p3g6MovDDlVjcaoroMA47jguYsTUyqwXCWJkc0oeYsTfgIhrO0kAe1eBe2Xyg6SxPawXCWlqKtlrO03LgMtO+R/h0sZ2l/xrzScvLCCoazNKEdas7Swv+r7SxNaPs7p3jjXXOW1hAQbA4HXpFYBAnxSvFu2ByOIeJIgwYNGjRouLygWYQUIhjO0n898zUYjoMe4mMhBhw4wFnOOes9PnaWx6MxoUOfkBc1jsaknqnW0Rhx3A0lZ2mGYfg6ajtLE9osy/LHbmodjRHaQgfEUHCWJvogz1DzaEyod1eZAj2eAOTHZaDHE8F0lpYb82odjUmNUU+8+3I05s3h2N/xFExnaeG4VNNR35W2Wn2P8C6k7UlWzVk6hDEUztJ1HU6HsKKwdBiowcns87569HAOrDBnAgC4xnaUGkplndEKCwuRnJwMi8XCT8BqOdiNGDECubm5qK+vh9VqFcmkRmTpnJwcOBwOVFZWimQazs7SZPA6HA5QFKV6ZGmWZVFfX4+srCzVI0uzrDNYXihFlq6vr+f5pih1I0s7HA4RbTX6HpEpJSWF54eMy1Bwlg4PD0dubi7a29tx4cIFxe2kNLJ0cnIyaJpGaWmpKn1PGFmaLMLVdiwOdmRplmVRWVmpurN0e3s737/VjixNykn/1pylL2EE01n6z6f34smjmz1bhAC8OPkWjxYhmh68ikomXLUsQnJQY1dOfkf4FGI4O0uT5+v1esldRyA7I/IvORtX0yJE/ojvQKg4SxNrrHBnqKZFyOFw8L9V2k5KeKcoil8su47LQHflwXSWloMaFiGhf5DSPqZUJmKh1ev1bvUDtQgF01mayEDTNPR6vaoWIeGYJ39qW4SE41JJOymRSXOWHqZQ01kaFIW9jeUYYY4ADQoOSC88HOCgoyg8OmamR2c0YVoGtZ2lGYZBaWmpJG1PdJQ4B3qjHYjToHBw+dpO3mQitzwKCwv5RYWn+kp4J+VC2mryTiYdQjuUnKUB8Hyr7SzNsqwkbbWcpUkKmVBylvZ3zCsp90Zbjne5ciHvrvNgqDhLu455NZ2lhWOe1Au07wn5kRo7oegsrS2Ehhifnj+NHx7ZhNreTkX1V4+bA6NeayYNGjRo0KAhGNDesEOMe/e8g14wXuvpKAqrx81xuzqvQYMGDRo0aFAP2kJoiMAoOIMP1xnwvYLJKIxOwKOjr9UsQRo0aNCgQUOQob1phwhfN5V7rWNl7FiWMwHXp430iTa5Oab0PPRyoB1MhKpONH1fOrSDiVDViabvS4f2UENbCClEoHGE9jZW4mo4b4KR22Cut8MAYHe9BdelOp3mfLlVYbfb+VtMQl7UuDXmcDj4mxjCZ6pxa8zhcPC3MIQYznGEyC0Sk8nkJpOcrEplIrSNRmNQbo3Z7XYYDAbVb40FO46QzWYT3R5R89aYkLbSdlLCO0VRbrTVujUWzDhCgPSYV+vWmMPhgMlkCkrSVbvdjrCwsJCKI0T4NhgMQbk1RmjTtPq3xghttW+NkTItjtBFhtpxhDDQSEXmDDjgbJxd/U1oYPtEcYRSOxyw2Ww+xdPIz89HSUkJn0sGUC+OUFxcHNra2mA2m9Hb2yuSKdBYLuT7nJwcnD9/XiTTcI4jxLIsWltbcfXVV8NkMqkaR4jQzszMRHZ2tqpxhPr6+tDa2or4+HhkZWWFTByhmpoaVFdXIz4+HjRNqxpHqL+/H8eOHeNpq9H3iExJSUkoLi5GeHg4Py5DIY4QGetk7CttJyUysawz/ta4ceNUT1DKsiw6OjowdepUdHV1hUwcITLmExMTMWrUKFXjCLW1tfFjPikpSdU4QiUlJTxtYh3S4ghdolArjtCXNefQc+wc7ms9wDtLS1mEPp//fVyf7jwaU7ozAoCSkhLk5+eL8tWosStnWWfArPz8fLedZ6C7cuH1YrJjJhjOcYTINd2RI0f6FA9FaWRpcgU4GElXy8rKUFBQEHJJV0tLS/kkt2pahBiGQUlJCU9baTsp4Z3jONlxGeiuPNhJV6XGvBoWITLmR450P/4P1CIkpC20KvjD+1DGESJjvqCgIChJVwntYCRdJbSFYTPUsAhpcYSGKQKNIzQzKRfbcA4OcG5xg8jnEaZwzEvzPcYLCZ8uxaNasVxoOjhJV8kRQijFESJ1PPHuWt8b78JyYplQk3fSfuTfUIojRPShNKaIr7xL0VYrjpDcuAyk7wHBT7pKeFE7jhB5nhyPvpa78i48ggyVOEKEnnCxrFYcIeGY93dO8cS71NgJxThCoe/lFCLQKWiQBwunKqonBaUNfjnRDiZCVSeavi8d2sFEqOpE0/elQ3socWlIEQJQcn3+vYrvFNVzhU6n449p1Eao0g4mQlUnmr4vHdrBRKjqRNP3pUN7qKEthIYIB5orvdap7mnH3kbv1+xdwXEcuru73W57qYFQpR1MhKpONH1fOrSDiVDViabvS4f2UENbCA0RGnq7FdWr7+3ymTbLsqipqVF8VfByoB1MhKpONH1fOrSDiVDViabvS4f2UENbCA0RUsyRiuqlmqOCzIkGDRo0aNCggUC7NaYQgQZUvCYxB9twFgZQsEsEVKQAZETEYkZCtiholxCers8Lg34JeVHj+rwcL2pcn+c4zo13YHgHVGQYhq8jFYwu0OvzLOuMVaR2QEVCWxikLFQCKhK+XWUK9AqzUO+uMgV6hRmQH5eBXmEW9nOhw6pa1+elaKh1fV5qjHri3Zfr84S2mn1P2IbCuVnN6/PkX7X6HikX0lar7xHehbQ9yaoFVAxhqB1QMSIiAoAzoKJdJqDi7VlXoNxi8TmwWEFBAc8jmYDVCqgYHx8Po9GIuro61QMqchwHg8EAu90uCnxF08M7oCLHcejo6IDdbgdFUaoGVCS06+rqVA+o2N/fj46ODlgsFmRmZoZMQMW6ujqeb4qiVA2oaLfbRbTV6HtEpuTkZPT394vGZagEVDQajXwwPqXtpEQm8rKiKAplZWWq9D0iE/FZoShKtb43FAEVyZivqKhQPaBie3s7378TExNVDahosVhEY0cLqHgJQ62Aig6HA5999hmYsdl46thm1Fg7eItQbkQcXpq8CEXZ4/j6gLqpG7zxqMZuT1iu9m7PV5mCGVDxYsnkT/lQyRTMgIpaOw1tQEWtnYY2oOLFksmV9+EkkxZQcZhCjaBoALAoZxyK8idib2M56nu7kGqOwqzkPDAsiz+f+RqW7lbkR8Z7zD7vygfZUcTExPA7T4JAA4txHIf29nbExMRI/kaOjpLAYkK+Qymgoqu+1QyoKKStJu9k0nHtJ6EQUJGiKH5DIuzfgfQ9Ao7j0NXV5UZbjaB2HMdJ8u2Jd6Uykf4djICK/o55JeXexrwc73LlQt6VjEt/eSf6Ju2oRt8j5a5jXo2+R8qlxnygfU9YX+q9E4oBFbWF0EWAjqYxN7WA//yTI5vxSvFuMIIV7Y+ObsbqcXPwwpRbvdJjWRYNDQ2IiopSPaZDqNIOJkJVJ5q+Lx3awUSo6kTT96VDe6ihLYQuMn5yZDNePLXLrZzhOLx4ahd21JYgyRyJwqgReHHyIpiNRlWey7Csm1XK36jWGjRo0KBBQ6hCWwhdRNgcDrxSvNtjne/a6oA2YDuAtecOoChzHD6+4YGAnrux8iRWHfoYNdZBp7OM8Bi8Om0JluVMCIi2Bg0aNGjQEErQTAAXEX89u090HKYEm6qLseSLf4vKKIpCRESEmx+CFDZWnsSKnetEiyAAqLV2YMXOddhYedJv2r4imLSDiVDViabvS4d2MBGqOtH0fenQHmpoC6GLiNLOFu+VJLCpuhgP7/0AvQNXHWmaRmZmplfHMIZlserQx5BaepGyJw5vEuU7U0rbHwSTdjARqjrR9H3p0A4mQlUnmr4vHdpDjdCXIIQRyDr672WHEf72M1jyxb/BsixaWlq8Bo/a21juZgkSgoN7vjOltP1BMGkHE6GqE03flw7tYCJUdaLp+9KhPdTQFkIXEdOSsgKmsam6GCu+XIeWlhZRHAUpKM1jJqzHcZwi2v4gmLSDiVDViabvS4d2MBGqOtH0fenQHmpoztIXEZkRcarQ+bTmNEb3GdB1oRgvTJG/WaY0j5mW70yDBg0aNFwu0CxCFxGzkvOQER6jCq2Knla8VnKQPy7z9Dy5IzkKQGZELGYl56nCkwYNGjRo0DDcoVmEFCLQpKtCOuQzTdN4ddoS3LnzDZEDszAZqxAOcKAA6FzKOQAWRzdfvqX6NJbt+Dc2zn/ALYT5q1OKsGL3G9ABA6lexc9dM2Ux4JJkMCYmRpR4kPAeaFh2lmX5sOehlHSVZVlERUXx+lEz1DyhTZ6vZvh8QptlWdXD5wcz6SrHcTzfrjKpkRJASFsoU6BpDiiKcqOtVpoDYT8Xzi9qpDmQG/NqpG4gYz4YqRtI/6YoSvV0FMFMuiocl2qn2BDSDkaKDddxKSWrlnQ1hBGspKvCJIkZGRlYljMB749dhK01Z9Fp7wMAfN5Xjx7OgRXmTBFPG3qrEUHpsTAslS+zcyw+7KtBNWPFUnMGX97R3Ipemw39Vqsoqd2UiDhsmLcSfzmyA8nMYPN36Dl8f/J1uMaUIEoQmJCQgNTUVFRXV6uSqE/NBKUEQ510VUgnWDKxLBtQkkhPMnV1daneTsFMulpfX4+enh50dXX51U7eZOrq6uJpq9H3hDLRNA2LxeJXO3mSKZhJV4lMLS0tqvc9wjtN0ygpKQnKHEHTNNrb20Mm6SpBT0+Pqn1PKFNXV5dqfU+YdJXQ9qedtKSrIQS1k64KkyQKV9wMy2JfUwWe/XY79jZX+mwRutoQhxP2djAC29Ijo6bjz9csk1xx2x0OfN1YjobebqSYIzEzOQ8Gvd6Nd47j0NzcjMTERLc8T2pYhJqbm5GcnOym9+GcdJVlWTQ1NSElJUW0e/Ekq1KZCO3k5GToJdojkJ0RwzBoampCUlIS9Hq9qrvyYCZddTgcaGxsRFJSEmiaVtUixLLONAGEttJ2UsI7ANTX14toq7UrD2bSVbkxr5ZFqLm5GSkpKW5OtmpYhJqampCamupmDQjUIhTMpKuE76SkJBgMBlUtQsIxTyy1almEHA4HT5uMSyXtpEQmLenqMIVaSVel6JCyeekj4eA43Ljj7wCcCx9XcBLlelDI10fiW3ub6LvSrguySe0Mej3mpY/0yjvDMOjo6OAHklJZlSYf7OzsRHJyckglXQWcu6CUlBRZXlzre+NdWE5oq8k7mXSEfMvx6Gu5kPdgJV0lfCtJwOirTFK0A+l7BAzDSNL2xLtSmUj/DkbSVX/HvNJyT2Nejne5clfeib5pmg6ZpKtCvskz1Ey6KtSJt/q+8E7TtGT/DsWkq5qz9DDDdWmFiNSbVKFVGDVCFToaNGjQoEHDpQptITTMoKNprJt1pyq0Xpy8SBU6GjRo0KBBw6UKbSE0DLEsZwI+nLcS6Qqv1rPgcMreAVZwLFaUOU6VTPUURSEhISFouWqCRTuYCFWdaPq+dGgHE6GqE03flw7toYbmIzRMsSxnAoqyxmHVwY+w9twBj3VZAKccg570SjLUMyyLvY3lqO/tQqo5CrOS86CTOE+laRoJCQl+yeANwaQdTISqTjR9Xzq0g4lQ1Ymm70uH9lBDswgNY+hoGtck53itpweFe2ML8djIa2C953+9LoI2Vp5EzvrnMW/ra7h799uYt/U15Kx/3i3zPOB0EqyurlYcj8EXBJN2MBGqOtH0fenQDiZCVSeavi8d2kMNbSE0zKH0eOyejAlYM32J1+OwjZUnsWLnOrfkq7XWDqzYuc5tMcRxHHp6eoKWqyZYtIOJUNWJpu9Lh3YwEao60fR96dAeamgLoWEOJWk4MiNikRXpPW8Zw7JYdehjiUv54MueOLwJzCWwwtegQYMGDRqUQFsIDXPoaGcaDk/5wV6avAi0Aoe1vY3lbpYgITgA1T3t2NtY7hevGjRo0KBBQ6hBWwiFAJblTMCGeSvdLEOZEbHYMG8lluZOEAXMkkN9b5ei5wnr0TStiLY/CCbtYCJUdaLp+9KhHUyEqk40fV86tIca2q2xEAG5RSZ30ys2NtYrjVRzlKJnCetRFKWItj8IJu1gIlR1oun70qEdTISqTjR9Xzq0hxqhv5S7jKCjacxNLcBdeVdhbmoBvwhiWRbl5eVevfeV+hvNSs7jPwtp2xwOrDm1G48f/AhrTu2GzeEISB6lfA83BJPvUKUdTISqTjR9Xzq0g4lQ1Umo6lsKmkXoEgDHcbDZbF6993U0jbvyrsKLp3bJ1rkz90pRPCFC+2dHt+Dl03vACJ7xo6ObsXrcHLww5dag8j3cEEy+Q5V2MBGqOtH0fenQDiZCVSehqm8paBahywgMy+Ld8m891nmv4ju3W2M7akvwSrF4EQQADMfhxVO78JMjm1XnVYMGDRo0aBgKXBYLoc2bN2PUqFEoLCzEP/7xj4vNzkWDt1tjgPutMZvDgQPNVR5/87IKx2QaNGjQoEHDxcAlvxByOBxYvXo1vvrqK3z77bd48cUXceHChYvNliIwLItd9WV4t/xb7Kovk43vQ9M0MjIygnJr7K8lB7CzvxGMZPQhJ1hw+PPZfYpoC6GU7+GGYPIdqrSDiVDViabvS4d2MBGqOglVfUvhkvcROnz4MMaNG4f09HQAwMKFC7F9+3bcddddF5kzz9hYeRKrDn0ssuBkhMfg1WlLsCxngqguRVGIjIz0StOfW2NfN1agge3z+puvG8rx1Pg5iugTKOV7uCGYfIcq7WAiVHWi6fvSoR1MhKpOQlXfUhj2S7k9e/Zg0aJFSEtLA0VR+Pjjj93qrF27Fjk5OQgLC8O0adNw+PBh/ru6ujp+EQQA6enpqK2tHQrW/YavaTAYhkFJSQkYhvFIl9wa8xSc0fXWWLTBhOVhGdDL/sqJSKPJ4/dSUMr3cEMw+Q5V2sFEqOpE0/elQzuYCFWdhKq+pTDsF0I9PT244oorsHbtWsnv33//faxevRq/+tWvcOzYMVxxxRVYsGABmpqahphTdeBvGgwlVxhJlGoAbssa8nnN1CL+1livzYaO/l4YKO/d5L78q73WkUKoXr0MJt+hSjuYCFWdaPq+dGgHE6Gqk1DVtyuG/dHYwoULsXDhQtnvX3nlFTz00EN44AFnxvXXXnsNW7Zswb/+9S88/fTTSEtLE1mAamtrMXXqVFl6/f396O/v5z93dnYCAOx2O+x2u99ykN96o/F1YzkuWLthhk62TktPF/bUlWLmgOWGYRgwDAO73e61Yy5KH40Ns+/DT49uRq21ky/PiIjB7yfdgkXpo2G323H3rrewpeYs9KBQZE6HGTo4ZPyEIvVGzE7I9Vk/vvDtK5Tq2x8Ek+9Qpa3pe2hpa/oeWtqavoeWtlr6Vvp7iguhIAAUReGjjz7CkiVLAAA2mw3h4eHYsGEDXwYAK1euRHt7OzZt2gSHw4ExY8Zg165diImJwaRJk7B//36MGDFC8hnPPvssnnvuObfyd955B+Hh4cEQS4MGDRo0aNCgMqxWK+6++250dHQgOjpatt6wtwh5QktLCxiGQXJysqg8OTkZZ8+eBQDo9Xq8/PLLmDdvHliWxU9+8hPZRRAA/OxnP8Pq1av5z52dncjMzMSNN97oUZHeYLfbsWPHDsyfPx8Gg0H03afnT7tZaLzhkxu+hzkpBeiz2fCLY1tR192GtMg4/PbqmxBmNPrNZ5/NhuQPfs1/pgBEUQZ0cXY3e1CaOQovTFmERVlj/XoWx3Gw2+0wGAygFCSN9QWe9B0ogsl3qNLW9D20tDV9Dy1tTd9DS1stfZMTHW8I6YWQUixevBiLFy9WVNdkMsFkcnf8NRgMqgwAVzobK09ixZ43PVxOlwal0+O23W9hU3UxAEAPCg5w+FPZARRljsPHNzzgF39PHvkEvRA7v9k41u1YbEnmWGy47nuiKNS+guM46HQ60DSt+kAiUKvdhAgm36FKm0DT99DQJtD0PTS0CTR9Dw1tgkD1rfS3w95Z2hMSEhKg0+nQ2NgoKm9sbERKSoqqzyLnoQzD8OehLMsqKheePgrLHQyDVYc+hg4U9II/0qX0LuWA00KjB4VnjmzGlurT/HcrzJkIAw09KGypPo1lO/4NwNlZfeHd0nlB9EyjC23y1+twQEfTsrIKy0i5Ky92u52/deD654l3pTIR+NpO3mSy2+04d+4c/50SWZXKRGg7BgJUKuVdiUyEtt1u96mdlMpE6PnaTt7KHQ4Hz7cv7aREJoZhRLTV6nssy4JlWZSUlIhoB9r3/JXVF5kcDgdKS0vhcDhU63vCsVNSUuJWN9C+50pbrb4nLCfPU6vvuY554s+iRt+TGvNq9j1iDXIdl4H2PSGPwmcH0veUIKQtQkajEZMmTcKXX37J+wixLIsvv/wSjz32WEC0165di7Vr1/INabFY+JgJMTExSE1NRWNjIzo6Bq+4JyQkICEhAbW1tejp6eHLU1JSEBERwdPR6ZyO0LUmBjXWDiwPyxDdzPq8rx49nAMrzJkinjb0ViOC0mNhWCrQC+SZM2HnWGzqq0UkpccycybYActNR3Mrem029FutqKuvx/nuNnQ7+hEdGYXrx12NttZWtLS08LSJTNNNCYg1D8YNOmN3mhZnGBOQpAvjy3PMzuPFyspK2Gw2vjwjIwORkZGwWCyiTpibmwu9Xo/S0lK+jHxvs9lw/vx5vpymaYwcORI9PT2oqanhy41GI/Ly8tDR0YGGhga+PCIiApmZmWgVyETaDYBP7RQbG+tVJpZl0draCpvNBpPJJJIJAAoLC+FwOFBRUeGzTIR2XV0dsrOzRTIJ28kfmfr6+tDa2oqysjJkZWUpbiclMlVVOaOPWywWmM1mxe2kRKa6ujqeb5qmFbeTEplsNpuIthp9j8iUlJSEnp4enrbSdlIiU0ZGBq9vMp8oaSclMpnNZgBAa2sr2traFLeTEplYluUX+Wr1PSITy7I8X2r1PSITmU86OzuRkJCgSt8jMpExX1FRgVGjRqnS94hMbW1tfP9OSkpSpe8RmcrKykRjR42+R2Qi/Y70b3/7HpmXvGHYO0t3d3ejrKwMAHDVVVfhlVdewbx58xAfH4+srCy8//77WLlyJf72t79h6tSpWLNmDT744AOcPXvWzXfIH3R2diImJgatra28jxBFUaAHrCFC9cmV0zQNh8OBzz77DAsWLODNdR9UHsfde95xi9HDgAMHuJU7wIECEE7r0c+Kj69WmDPxcW+N6AjrkVHTcV1qIZ46/IkoJlFKeDRenVqEoqxxbrz39PUh9t3/GeQdwDIJ2h13/xbhJpOkrBRFiRYipBwQr9AZhoHFYkFhYaGbaVWn04HjOFF9wqNcuZAXu92Obdu24eabb+Zpeaov5N2bTAzDoKysDCNHjoROp3PbdUjJqlQmQruwsBAGg0FxH1Mik8PhQFlZGQoKCvhzfSXtpESm/v5+bNu2DQsWLIDRaFTcTkrK7XY7SktLUVBQIDLFB9L3SDnDOGOhENpK20kJ7xzHoaSkBPn5+TztQPseAcMw+Pzzz0XziZJ2UiITy7KwWCzIz88XRQ0OpO8JrQsWiwUjR46EK/zte0LrAaFN+PGXd9dyMp8sXLgQRqNRlb5HysmYLygogNFoVKXvkXLhmNfr9ar0PcK73W7naZNxqaSdlMjU39+PrVu38v3b377X3t6OuLi40HeWPnr0KObNm8d/Jo7MK1euxH/+8x/ccccdaG5uxi9/+Us0NDTgyiuvxNatW1VZBAUbKQojPbuC4ZSZ+/Y2VeK1cwcEh21O1Fo7cPuuN/DBnPtRlD1O9J3ZaMSijLH4tOa0LN1FGWNhDsAhW4MGDRo0aBguGPYLoblz54pWelJ47LHHAj4Kc8VQHI1NSk9HRngMprFRvh+NDcDOsfiwrwZf9zdjiTmDL+9g7djd2YJsXQSmGgdvyTUwfdhla8IYfQy2HNsPpqEFUYYwTEjPQXpaGhobG/G/mddgot2Mc51NOGXvwIbeasw0JiJFF4ZR0Um4M/NKdHR0BHw8wXEc8vPz4XA4UFlZyZcP96Mx0h8dDgcoilL1aIzQrq+vR1ZWlqpHYyQ+lsViQWZmZsgcjdXX1/O0KYpS9WhMeExDdpdqHY2lpKQgOjqap620nS720Vh4eDgKCwvR2toqysuoxtEYx3FIT08HTdMoLS1V9WiM4zjeGhlKR2NkzFdWVqrW94hM7e3tAJz9JDExUdWjMYvFwtOmKEo7GruUEcyjMZqm8VHVKdy58w0Ag5GjvR2N6SSO0mIoA3o48d0uBzjQAGgJOq7laeHR+OO0JViSNY7nvc9mw9PffIbq7lZkRsbj95Nu5q/mq3E8wXEcHA4Hbw4WYjgfjRFTuclk4ut7k1WpTIS20Wjkj93UOhojzpMGgwE6nS5kjsYYhoHNZhOZyNU6GiO8C68Aq3U0RlEU+vr6RLRD4WgMcC7y9XrxPlmNozEy5k0Dx+pCBHo0RsZOWFiYW/3hfDRG6BsMBuj1elWPxoRjnvjAqXU0Rhy9heNSSTspkWmoj8ZC+tbYUEKn0/F/pMFpmlZULvR/cS1fljMB7827H8nh0XCAg2NgEQSA/0z+AOdiyQEO0xKz+HIdKNwUlsp/5wCHifFpAABWho5refVAHrOPzxfz/EWYzVhzzRL8PmcW1lyzBBFms5tMcrIKy0g5RVFuZZWVleA4zq0+ALf6RL9y5a68EPjaTt5koigKVVVV4DjOjRc5WZXKRGj7yrsSmQhtwp/SdlIqE6Hnazt5KwfA861W3yPlHMeJaKvV98jk7Eo70L7nr6y+yASA39Wr1fdcxzzLsqr2PeHYYVlWtb4nLCfPU6vvuY554WI50L4nNebV7Hvkz3VcBtr3hDwKnx1I31MCbSE0DLAsZwIqb/s5dt70A7w16y4kmCJk65LEqLtv/m8UZY6TrDM+Jhnhet9iL3ADf1J5zDRo0KBBg4ZLFcPeR2i4QBgTwR8znZCO64qd0J2VlAsAMOsMWLHrDehBiY66mIGjsTWTFwMchw/n3e88vjr2GWJa+3B1mB3ftjXgbMdgwlmlR2PcAP26ng7sqS/D7JR8AINmTinTbqDHE66xJ4TQ6QI7nhDSC8SULyUTiV9BeFfzaIzQJjtmNY/GCG3SB9U8GhPqhuzU1DoaI/ogz1D7aExIWyhToMcTANz6tlpHY8J+Lpxf1DiekBvzahyNucanESLQozEhbTX7nrANSR01j8aE41KtvkfKhbTV6nvCozHXcSklq78ykWcQPvzte0qgLYRkMBTO0nLOaLfkjsKGOfdj27cH0WkfjOlziO7CS1fdgrE2I+98R9M01kxfgtd2bkZBixF5Aw7WHawdn/fXI0fGWXqsPgbjDTF8ucXRjSP2VlxtiENLVQ1Ku5z8xMXFgaZp1NXVobe3VyRToA6rLMuCpumQjCPU1tYWtDhCbW1tQYsj1NbWFpJxhAjfNK1+HCEhbTX6HpEpKSkJVqs1JOMI0TQdUBwhluNQb3CgiXYgvtOGTFM0aGrQV43wrkbfE8YRIikVpNopLT0dO0tPor21FZF6E7Ii4xAXG3vRnaXJmA9WHCHSv4MRR0g4djRn6UsYwXaW9rTitjsc2NdUgYbebqSYIzErJZ+P5iwEw3EIf/Npt2vyvjhLE4uQDhRemnwLHh87y6tMau3KpcoD3RkF01n6YsnkT/lQyRRMZ2mtnYbWWVrIo4NhBHNQFGan5oNlWXzdWM7PSzOT82DQ63neN1UVY/XhTaju7QAL56WPdHM0XpyyCAlh4Wjo60ZqeDRmJGSLUvSo2U4OhsHeBgvPY0ufFauPfoo6awc/72WEx+DlqYuxLHei13byx1maYVnsa65EQ28XUsIicW1SLi9vKPe9oRhPWhyhYQqh4xeB0CStpFyOjutnAqPBgHnp7oHHXOu/emInEukwNLJ9bjnLWICPNq2knAGHxPAo/hkcx6G7uxsRERGScsnJKieTsJzjOPT09CAiIkKyPnGkU1ou5EU4uHxtJ28yCfmW40VYXwnvpFxIW03eyaQj5FuOR1/LhTJJOUIGyjtFUbBarSK+PdVXyjvDstjTYEFjRxuSY+Iwe2Cj4Yl3X2TiOE6Sb0+8K5WJ9G+dTgeG4/DXs/tg6W5FfmQ8Hh19LXQ0jb2N5ajv7UKqOQqzkvOgo2kRHYZlsau+zK0OGfPbm8ux6vAmUTDWEaZwcBzQarPyZenhMfjj1MVIDIvApvPFWHN6r4hXBzhU9Xbg9j1vgQKQPDBXpYfH4NVpS7AsZ4JHWT2VC9uD9O/tzeV4/NDHqOvtlKRD5r1KazuW73oDz7UvQGFMAlLNUZiRmIP9zZUinYCicKDFaVnY11SB2WmFsjkWCS8bK09i1aGPRbrLCI/BQyOnoTAmcVDfEmNejb5HyoW0WY6TbG9vdOTag6Zpt/lErr6/Mrm+L9WaD12hLYQuAexrqsJcUxI29Fa7JUf1B+nhg0dmLMuipqYGhYWFsgPCXwSTdjARqjq5nPTNsKzkQoBgY+VJ/PDgR2js7cIKcyY29FYj2RyFP01f6vZi9kZb6uXJsCz+euZrcI3toJJj8eiYmTDqvU+3Smn/35l9yAGwaPs/sb2pTDTqVx/5FBF6I7odgmMOl0WH3Iv61WlLUJQ5FjtOfYM7zmx2m08u9FvhCmeA1je9ygY4Q3+QuarW2oHlO9fhibGzUJQ1zq2NfAXLsrJ8e8Kvvts2yB9FgRFYFkYYwwEKsPb34934Gbhlx78wIjxScgFHsLHyJFbsXOfGQY21A7/6bjv/OSM8Bs9OnI9ffbcNc6kR2MVdwNFbViElOlb0O6m+DMBj/xbqpKamBqeNNqw6skmyvV3l8DZ2XGmH2nwiBW0hpBBD4SztWl+p6TFKb0Q/pOMOCY/Apo/IwMELNV6Pxq6OSeN5knOcVMOcqjlLD39naYZlnUcjfc6jkWsTc0STopSzNCgK+5orUW/tFB0JeOPd7nDIHrm4OmUK20nIY2p4NFqs3fjx0c38pM+Ac1ofphShKHscNlUV447db8IBDgZQoOEcO429Xbhj5xt4f979WJo9XrKdNlaccEtZw1FOawQZT5F6E3oc/eAA3GbOxEfV+/HTo1uwPHsiFmWPQ2p4NK5NzIGDYfC3kgMo725DXmQcUiNi8JPDm0WWDBYcf7zkpG2E1WGHHhTeiZ+B/U2VorhiZAHQN1CHoNbagdt2rsP6OfcDAO7YPbhwIXNBg7UTd+x8A/8z8TpYzpfzeuHlxOAcIZxpXHn0VC78P+H7L6e/xl9Of43U8GiscUn9Q9obkOiT/T3O/pWYAwDYXV+GjZUnRDIJ4W3eowYK9KB43jtsTr9IMwaugQ/o8s6db+C9OffxkflJn7TZ7Xjq0CZeNk8x4WqtHfjBwQ+dl2LMcbjQ14PUD3+LCJ0BHff8FgCcx4xHPkGVtZ3nfYQpHOCACzYrL1NWeCxenrIYRdnj3Jylz7Q14N6zn6EfrKgNGq2dTjnm3scfD35ceQpPHXH2b8J7joC2sD00Z+nLABfTWdpXp8G7867C+sad4qSrEs7SI3WJ0Bv7vTpL/2PfNtycOQaA01kaQNCcpQEt6epwTbp6pr0RW2vPodPex0c1vyMqFzelj8KY2GSRTMQp8fNjB7Gh7jTe6SpH3kDfe88QhpvSR2Fyep6onViOw/nuNnQaOJzlenCw7AximMEXxm90Djw2ZT4mUdGySVePN1XzPO7qb0ID24flYRmYTkUDZqdPwOd99Wi0dmL94V04X16Ob1vreCtQFGXAWH0MYHa+/Owci4f3r8cNI3JQV1sraqfv6B78ZO+HmG4cwdMmlw/Gu44nqhvf2tuQSpv5cck1teF/a7fglKMDC8xpiIeetxpssX2HcqYHC02pmGEepENkKgpLH4w+bwB29jlvhhaZM+DAYPt5ij6fTIdh27cHYWcZrDBnyl6o2H32JJJ0YRijj8EYw6BfhXCOyNdH8uWn7B045ejgo88THLZdQDnTg/mmFMTQA36RoBBOOec/kUwAtvbW485db+L9MbdiTOxgiqS8/Hx8XW9Ba209LvRZcay1FhdsVnzYV4MUOgwLw9MBAP2MA3k65zzrzyURTzLpByLNZOsicIbpxHxTCrZ9exCj+w2gKYqfI746cRTTOXHf85YlgAaFsfpo2MM4rO+rRhSnwwMbXsPS7PFYX3kcY1kzqtDuLpMxYlAmLhrrD+8C1dSG6dkj+TmitbUVloZaLDVn4oS9XbKd/vfQZ+hl7Giva8TXdWWYDif/pO9NYiN52mNikwNKukrGfBccSMxIw0RTPJqaBm85a87SwxQX01laqaWB5TjcvmEttvbWikzCwh1QlMGEqSMy8WVDmded0fzUQmye/1/Oco7D+fPnkZWV5eafEahFiGVZnD9/Hjk5OXDFcHaWZllnoLzc3FzR7sWTrEplIrRzcnKgFzig8jrjOJ+sLa4WoaqqKmRnZ0Ov13tsp48qTuLO3W+KgntSGNxNkt2wq7P0fa0H0AtGso+9P+c+LMtz33nKWRq4gV35hln3YSIikJ2dDZqmeZk2lp8Q8Si3+/a0KzeAwo2mFHzZ38iPHQc454WB0TMBOP1C6qydePLIp7jQ36PY0kABWOBC2xfriSfejaDxTvwMXt9CXqSiz3sqd+VdDwrzTMn4sr8Bwh6slkVonikZO/ob4ApmQEc5EXE4u/Qn0NE0NlUVY9WRTai1dniVSQ8K15uSsa2/ASw4/yxCMrybocOb8dfg7tb9sILhy7ff+BBmp+TzffLdsmO4f++7Ipnk+h7hnfD9ZX8j+sDy5anmKNT3dsnyLlUebwrH27Pvwby0AlAAdtWW4JW9W/BlfyNsYP3uexSAjIhYnF36ExgGjngdDgc/n5BxCcjPex9VnMTqw5tQO2DxdIBDhjkar05dwlubNGfpYY6L4SyttFwH4L7p1+Hjnevc6hKn6H/MvANf1ZVgW0OpqNwVDDjkR48QPSMvL09WnkAcVnU6HfLz82VpD1dnaZ1Oh4KCArdyufpCeJPJlbaQF09+HeSc35NMNE2LaLvyyLAsdjdYUGvtwJOHPoHdpX9wAOwDE/gTRz9BUc54nncMLJJdo5cL+9jDBzegKGc8Np0vxvLdb7jxyEj0RwrAD45sxB+nLkZNSxVmJOZgrwceCQ9SkCq3g8OW/nq38h8d3YL/PfEVwAGt9l7Rd75cPpCi7SuPUuUGQbnrd5wMHblyV94d4PC5DN+AdDsp5d0bbQCo6GnD/pYqtPb3YsXuN0SLcVcIZXK4tKWvl0Q88S6M7C/83NDfIxpDSeGRknx64t2Vb1Je7eLsreTiS1N/D+bveJ2fF/pZh1sf9LfvkXaZm+qcQwwGg9t8AkjPex9VnZIc8zW9nVi++w2RnxigOUtr8AMcx+G62Ex8OPd+/PCwc/dEIHxR3phSiLXnDnil9/urbxHR7ujoQExMjNvNFzX4DhbtYOJi6MSTA+aKnevw7JU3im+jyNxikuNbapElyyOA6p527G0s5yfFr5sqPP8ITkfb//nmc6w9t99rXeGzLvT14Jf7PkEl0+O0YqloxKbhPEapZHrAunzXauuV+okqtIczgsm3Utq11g48ffQzmVdzYLTVRKo5yqXE9/kgGHzXDswLv7ziBuSpSJtYqADl8yDDsnh433qPdNec3os1p/fy76tF6aNV4FY5tIWQQgxnZ2nAma381vzRuHXZGD7uR2pENGYm5YIaeO7BlkroQXk1ER9sqcS81EL+WQ0NDW7X59Vylq6vr0dkZKTbQBruztJ1dXWIjIzkHZq9yapUJkI7IiICtE6HPQ0W1HV34EdHN0M3EGlcypT/3HfbRTFbXpnqdAwWyuRwOFBXV4fw8HDe3MwwDDZVFfNHTBTg1ZRPUN/j3LFyHIev6y24auB3cn0MAH53aqfPTrhG0JhuHIG63l44OCddX46RPB1P6EAN0hbs/pUeI8mVE11Oc6Gt1tEY+UT0LeRFjaOxqcYRqOm1BuVobKpxBM73Wt3yOwllbbZ2ocHayfclJTLpB9ryfK8VUPlojPwr1LuOojAtPlPk0Ntk7RLJq/RojPRB4dGYN969yaQHhX+dO4RZA7QDORojSDFFiNwPyHwiDJvhOu/tarSg1Wb1epkHcDpwr9i5Dhtm3QsdNGfpi45QcpbOz8+H3W7nndZSAWQbY5GXmof29nbesbi0vgwzjYlenQZLS8uQ0e0sH+7O0izHocbRgwsROiTaaaSxRtAuCzE1naUdDIOqrlb0dnSiPhyYlV6IcotFUTv54iy9+cRhPFbyBeIdNMYbYjCXjgfM8cqcOxHGOzfOG32FR2fpsrIybDt1EMsHnDmVOHcS9NU3g8lj0Wu1IrnLqe8icwYusP1+RzWXkmmGMUHk0CzlhAvIOBZ7kUnKWZo4Fs81JfF1/YnU7uos7dZOXhyLPcnkr7O0EpmaGGc0+6F2lv68rx5WzoEHoguR3sXy7aVUJhrUkDpLx9AG7D7xDXKi4vk5Iq6jX9TP/HGWVqPvHbG34ipDHAqpKIzVRwNmStZZWmnfizaEIbmTgS3B5pOz9K7ucp9k2m1rwuvf7sL/M+ZqztLDBaHgLA0AJSUlyM/P5xdZUtaT577dht+d3Ol1Z/TMhHn41VUL+GdZLBbk5+cHxSJksVhQWFjol0VoU1Ux73Dreo305rSRqjtLbyw/gaeOfIIGayeWmTOwvrcayeHR/LVsb+2k1CK05Zv9uPvsZ+gD6/cOFnAGv6u545fQD1itHA4HysrKUFBQwFuEdtaW4Mbtfx9sEwU7WCFSwqPx6tQiVLY3I/98t0dnaULHV5nCQGOZOQMbe52hH3y1nnhzlr7NnMnT9iSrPxah28yZ+EhA+2I7S48wmtFu6xOVS1mElpgzsLG32s0iFKbTo59xKOJdziL0TPIk/LrxKFzBDsi6Yc79iDOF8f3SF4vQMnMGPuitHjJn6Tdm3YXbc68QXZ8ftfEPqBVcAlBiESL9W02LkA4UDALa/lqEDAPl5IIEmd/I5rugoMCjReiX327D705+5ZNMEdDh7fgZmrP0cMNwdpZmWRaRkZHQ6/VuzxY6585JK8RvTn7l/A3knQbnpBWKFlQk8rOUXIE4S1MUhcjISNGNAzneXcs3VZ8WOVISmaqs7Vix+w1smH0fyC/VcLDbWHmSf54eFOoYZxTvWmuH83nzViqKkOvNWZrlOPyt6piswzGBEofVxv4e7G604Pq0kaBpGnq9HlFRUfyNMcDp7Omrc6cQtdYOrNj1Bm7PHI98xHl0libwR6Y6ps/NMThQh2MikxRtpY7Fnsr1oFAvQVsN3v1xlgaAP09firv2vOOV9wamD6yADgVg640P4frUQtgcDvz46Kco6WzBnsYKOFiHIt7JzaP7x03HuNFj3AL8ZUbEYs3UIizLmQCGZZESHs37O8rJ5FpeN2DNUrPvCf91dZZOjYgWjWejwYCXpxVhxcDFFWF9cuw8ZUQGjlyoEfFO+qBQpiiDCV32fq+8e5KJAtBJc2AGFjtC3uVkdUVKRAzfLkII5xPhnOk6v8WHRfg1nggtzVlagyLQNI3MzEyv9eam5COM1qOPdcjWCaP1mJsyeJNLKW1/4C9thmWx6tDHksOW7MSf/mYLXjSNk6jhO1yf5wCHXbbB2BcUgCcOb0JR1riAIuMCwM7GMmzrrQuIhhC7GspxfdrIwWix9i6kNvbzEYtPXAjsWUTfXzVYcFfUZFV4doWrvjXavoMsMuJNZq91pfi+JWMMjLQOG6tOYrVLQEklIHv+l6cuRnZ2NrIBFOWMl41grKNpvDptCVbsXMcvIOQwwhQOwOmMP1T6Jos6cstJiGU5E7Bh3kr3G54DbRBjDMMN2/7Gl8v1k9XjZuPX3+0AIJaf6PKXV87Hn0/vE6U7ceUxNSIG90+Ziy273vSqR/IbDsBzVw6mHZG7fKF0/k4Ji/Ra52JDWwhdAiB+JfHx8R5XwAzLwsYyst8DgI1lwLAs3/GV0nZ9jtIQ7b7SBpyh5T1NxByAmp4OwKSYpE/PowGM1cfgtMOZVJKD+y0qf/FmyTcYL6AdMDiOvxFWZ+3g+Vbz9hUHoNtu81rPX7jqW6PtGeRFKXWT8G3LN15/L8X35poz2Fxzxm+eyCJgSdY4tLS0ID4+Hjqa9jheZBcU4TF4aOR00YsaAPY0WNDU0oJzji68XnKQj1cDOBeCr0xZhISwCH5eau7rwZOHNonqEUd8TyD6XTO1SHbjsyxnAoqyxknOgwzLYoQpnE9XIqXvEaZw/M8V8zExLk12QbUsZwImxqW5WZ9EPE5ZjNlRadgw937JvHGAOG2KkLY3KJ2/0yNiZL+TgnOR6dtvAoW2ELoEwHEcWlpaeMdmOfz17D5JM6QQLJwJHJ8YP8cn2gQkh5Nwckk3R0vmcPKVNoHwCudQwPV5NCiMN8TgrKNTpM8v60oDzpdU3dMmSdtfUBSF5QMTpV7AtyOEXAPl9H050/aENJnxBgDNvd1ef682389MvA6/vuom5yKAYXwa854WFK6YnZyH0k4GK8ZNxc+vvEHRb5ZlT/CY262lrwdPHv4EF6yDelO6WJBb6OloGq/PuI0fl1L6fn3GbdDRtFf5vVmfijLHorS0FEWF41CU7W6BA5TlLJOC0vl7VnIeMsJjFFkRyQLu95NuAU5VKuJDDWgLocsIlu5WVeu5YmPlSX5wC1Hb24nlO9fhQwk/Gn/gHrtDHchZspQ+77cnvsR/yo4GlMgwKzIO9u4LqsgDAGuK96hGS0NooKGvCwebqyTHWuJFOKZINEUEtDnwZjkK5DdS9Vw/L82egD11pej85iy2zH/QY/Z5pViWMwEfDixgGqyDm0apRKhKLGey1ifBpRU5OoFasb1BeMwJeD6eIwu4Remj8Zm2EBp+GO5xhFwTl0rdGsuPiFMURyg/Is7npKsMy+K/9r7HnzFL3UBYufdd3Jo+mp9E/E26OjMpFznhsfzNDEB8A4ECkB0Ry/9Oqp04AHvqy/gEnxf6rFh99FNUWzt43jPCY/DylMVYnD0OGeExaLR28rLREMcUIeDjYMy9n08eSW63VVrb+RshhPaSnPGidro79wq82fCVonbydmsMAHoGMpCTeDMkho8/N6w83dwxCm7ueIoj5K9MwthDat4aowC3uEZq3RoDnH1ESFvJDas5Sbn4prUW3Q6bX3GEWI7DH0/tBsVx+N9JNwMYHE9p5ii3+lK3xiChF1/7Hilv6e2GzW7nX8xSsb4A3+c91zlCSFtJrDGl5eA4XJOQjW04y6e0CeS2LClfmj0et6aPxtcNFrRW1+GhzBsxJ32kW/gPRQlKOQ6zknLdyoWJUQONn+Yqky9JV5dmj8eGOffzt3wBZ9/LDI/BQ4VTURCdKEq03N/fzz9DiyN0ERFKcYQKCgoQFhYGi8XC3waSirlzPZ2oKI7Q9XQi/+z4+HjExMR4jSNk6WzBTYZk7GI9xHJx2LHj20PIj04A4JysoqOjYbfbRfEevMXc6e7qwivZs/BB5XEA0vE0bs+YCDQ728a1nU47OrGqeBsKHCZRPA2DzelEzsfT4ID1h3cBdgdenbYE7xz4EgbKudRKocMQSRnQxdndYoR82FuNXxzZgtF9BpzraML6yuOYxEWiEu2D8TQGaFOtnVg6eSbfThkMhVTajBnGBHwVQNwTAmGMkFjaiBQ6DEvNmdjZ3+hzzB1PsVxuMKUACF4coRTajKXmTHBQN45QJGUQ0VYzjtAxexsojuJpC2W6PiwFcdQg74dtF1DFWvGHnFkYG5GAdV0OwBBYHKHq8kqcjTwHg17Pj6fkTgYPRhei097nMY6QxdGN0foYjFUhjtCx0rN4/HwtFqSNhFlnQBfFoKFBj7Ru8ctL6bzHchzOW9vRFheGJMqI1D4aNEXxOe8oipJMzJyWno6dpSfR3tqKSL0JWZFxiImJQSllRVNjI6LtFLIi40BTlNtcTt4DnZ2dSEhICCh+mqtMqRyHKEMUoq0UdDSN7u5uv5NNA+L3U3t7O3p6emCxWJCYmBhQsmlXmSwWC0+boiiv8dPG2ozYMnG5dNJVB4AuFg1svZZ0dTgiFOIIKY3CvKfBghu3/93rrnzHQCJBbzIJdxEP7n0f71R863VXfn/u1fjXrDtUkUkqjlB2RBxemrxINo7Qpqpi3L77DTASPErtbMnNi/IVz2CTIFGoUCY5S8P2+d/HQ/s2iHZArpaGjIhYlK34GegBXZI2IvX9tQhRAMw6A7oZm6rWEzmLUCT0eDP+mqDEEQo05o6/MqkVy8VVprGxyfjlxPn48ZFPeV86FhxSzdH409Ql6GVs+N7X73vkXWkcoRcn34LHx84SjScSSRxw5lq7WO2UMxDzi8TgUjLvuY55CkC2gA6ZIxwMg70NFt7i2zJg8a2zdvAyjTCGg6M4NPVbeZlcLbVkfiNJnBcuXAij0aiKRQgArH19ePrYZyjruoCCqBF4YcoihBkMfkfU96dcjZhwnsr9yRKgJV0dphiucYQYlsXO2lI0NzchMTEJs1PzRefXwrg1wpgxnmJPCBMJsiyL+vp6JCcne0x02snYFMV46WRsItoNDQ2ytL3F3FmWN1H2Cq7dbnfjkWFZrDqyiX9tKI2ncX7gRhhoCnbOqbWrDXE4Zm8DA/c4LoDzpbG7qRKV1na3cmH9yp42/raZTqdDQ183rhqgDQQWR+jW9JH46PwpvlwHiufbNR6KNx1I8S5VHow4Qq769sSjr+U0KF7fQtr+xD1xLRfqW0j7qvh03LHnLTcqdb2dWLH7DXwvf7LXuENK4whZetpEMcHIuHmPvp93sHXlXQcKUwzxOGZvk9RBIElXdaAweYA2H/PLxXdQbt6Tih3GQRA7bO79uCYsEQf6mt1uSAlBZG20DVoQiEw8LdrJk+vLnVjcA4mfRrDki39jU3Ux30921JfiLyUHUJQ5Dh/f8IBbfSXJpl3LWZZFY2MjkpOTRS4ZcvV9kYmiKDfacvX9TaA9VHGEAvP40nBRsbHyJLLe/w1u3P46Pjr7DW7c/jqy3v8NNlaelKyv1OlXWI8k1vNmOJyZnKOItrCeUtqeQBwA78q7yrmY8NDxvV2794RN54uxYuc61PZ2ggKQr4902ee6g1UoV23PgIWJZdFo7VREWwmiDeL4AUr5Hm4IJt8Xg/ZXDWWSSwZStqnmtGo85EfGS5Yvy5mAytt+jp03/QBvzboLCaYI/ruh0gmR94nDm8B48eXwFjsMAH505FMcqDyHO3e96fc494WnQEAWQYC7vjdVF2PJF/9W5TlqzLEXg/ZQQ1sIhSjIDa26PvHV7rq+LizfuQ5PHtqEXfVlosE8IzEHOi/Z0nUUhRmJOT7z8/jomV4nTmqgnppgWBa76svwbvm3bvK6IpBr929Zjsnsd6VBg0KsUVkgowNNlVhfcRw565/Hj49u8Y9BCbxX/p1qtDSoh1rBLSFXcABa+6UD5PkKHUXh0dHXyn8/sIm4p2AS/jZjhSrP9BUcBmNweYKS2GHVPe3YUnPWp3EaCE/+otdm4xdBcthUXYxem7qxuXyZKy83aEdjIQiGZbFy77se66w5vRdrTu8VXcfc31zpNYgew3HY31zp13XVCL0J3Y5+2TqRBlPA106FIIECXYOtvTptCRalj+bLyNX1020NUmQ8ggKQEBaB5r4er3WFYMGhpa/Xe0UAa88dwNpzBwC4+1MEgn7Oc/BMDZc2Vo+bA6M+NKZ4b5sUpZsYK6Pe4kGNuGBSePLwJsX1Xpt5myrP3FRV7JbSROqq/uUKzSIUgviyvgTdjsEBz4LDKXuHpO9CrbUDK3auw8bKk4onE2E9auAGhWtSVFfsbSz3uAgCgC57v2iXpZS2FDZWnsSKnevcdolE3k/PO48XPj1/Glnv/wbztr6G35740qdnEK7uybtaVO5J30J801Lt0/N8oe0Pgkk7mAhVnVwsfesoCj8ePxcvTLlVUX1y7ERwMXTi7dheybG+2nz/9sSXyFn/vKyrgb/Y2WgRfZbj27WeP6AoCqcdnbh99xuyc6W/8gUyfw83aAuhEMSblmOizyyAUzJh/IVn3klhERI13CGcdGiaRkJCglenM38WWUppu0KJv8DT3ziPmO7d847b8aFSZETEYsO8lXw8IAJP+hbCU043OSil7Q+CSTuYCFWd+EObApCocJy6IkJvxEtTFsF67+8UL4IA92Mnf3USqTd6reNKm4Iz/YVUzi4hSHRiuVcuBSDKEKZ6W9ZaO7B85zr84cROAMDXjeWKj5TkjqJsDvG8IKdv13r+gAOwqngbpGzDgfpD+Tt/D0eEht10GGA4BVTs6etzO0KZaUzEQVuL280tcgW2vqcDjIOBiaLRz7GyV2ONFI1p8Zk8TxzHob6+HqmpqWA5DvuaKpxXUsOjMDsl3+n0yHFIMUUoCtSXYooQBWusr69Heno6GJYdpG2OxOzUAv5Kuat+9zRY0GDt9BgYrqGnk8815ut13/+ZcB3mpRbwwdM4wC2g4rXGROyxNcEOTvZadk54HA6hyq3c07VsQnufrRl9kG8nf64wC2n3D+w/A7lqToOCDSwoQf1gBFQMA83z7QCn6vV5AyjMNibxtOVklePdk0wUgNnGROwXjEtv7aQDhVvTRuOj86d8CqhIAXjj2juxNNd5zOFLgNJ6l7GkB4XpxgTstzWLXs7e2ukn4+bi18d3uJVL0f7a1syXrpm8GBgIrApIz3s0ReHVKUX8tX9yM07Y9x7Im4wTFSXYY2sGC06Vvkf6wAsnvsKb8dfg1h3/Qnx4JF6dUsRf+yc8Cudycs2/ytrOtx+5ml8QGS8Kruo65kl5QWS8KBCiP9fnd9eWYJQjDC3ogg2sZN+rHfCHmp2c59P1eYfDgbq6OqSlpTnbSMXr88IgmVpAxYuI4RxQ8VoqDqaB4HB2jsWmvloU6CORpjPz5lWpYGmWsjJcY0jwGNTuCn0sdp/4BjlRztsmcXFx6OnpwafHD2FrZTE67X0AnMHSbCY9/pQ/D2MiE5DMcXgwuhCfdp9HvUQAuK199YgLj0RyJ4PSLqdcROZNlhPYdvIIT9vOsbif7sKrV96CsVw4T8NoNCI7JwcHz5eKguNJBbXTC4ydvgaAG89GILWLRXmXhW8nYUBFGhTG6qPxrb0NnRIBFTf0ViPDFIV5dDwYQTspCdRHaHPgVA+oGEcbMVYfjWRdGL4KMKBiuN6IDnvfkAVUnGdKQrIuDCzUDagYRRlEtNUMqPitvQ1XGuKQIhiXStqpt74ZNxmSFQdUZMDhmsRsjLU549t4CmonDNRnMBhQHc6hsrlBpJsmpg9JujCM0cdgjIKAio06Bx6bMh+TqGjURFeK5gjXdqJBIZzS4WtbM+6LLsCt6aMxxmZEaWmp13lvrM2I98fciq2153DBZuXbaXFkFm5KH4UwWo9IYyv22JpV63uknch8kq2LwFlrB/55cAeopjaMiU0GIJ7Li1vrsb7yOKYjGm1Uz2Df45xBVK8Oj8UuUPx4ImM+njZifV813/cm6BJQWloaUEDF1up6vn+fsLfL9r363i6/gkS2traip6cHNE17DajoS5BILaDiMMNwDKj4VslRPLj/A9F3K8yZ+Li3RtYiBAA/GjcLLxXv9boz+ueM5bi3YArPw+Zv9uOeM1tgF9BmBTvV9+bch6LscdhUVczH+ZDalQvTTgDO1f6Wb/bjzrNb3MzCzMBub/2c+/mdF3H4EwZFk5PVDB3ejL8Gd7Xu560WQt497cr/OPlWPD52lkjvFEVhY/kJPHXkEzRYO7HMnIH1vdWyFqEP596PYxdq8IeTO0XlSixCy8wZ2NhbExSLEKEdqEUoKyIW53vahySgYhhonu9gWIRuM2fytKVk9cS7J5koALeZM/GRgLZaQSKlAiq+P+c+3iLkbVe+qaoYqwcsFlIpNpaYM7Cxt9qjRej/jZ6BpVnj+LQILMvi48pTvNWGEchErsv/auINGN1vwIjsDN7iSqA0UB9vPe7vQUpYJK5NzIGOpmGz2/Hkljfwz85S1SxCRO9kPrm7dT+sYGAAhYyIWJxd+hPoBqwhFEXBZrdj1MY/yAZddR7hmdBq7xNZhIRjnpT/dPxcPHf1TQFZhHbVluCf+7ZjY2+NrEWIBYcvb/qBzxYhu92OsrIyFBQ4Y6BpARUvAwyngIqZ0XGiBQ/p2FLB1VgAHDhkRMTiTEezYEKWD2r3cfVprBw13fmZZbG19hzsErTJM584+gmKcsYDNMXXkKq7t6kC8WHhgwkBWRZb60rAytQHwNPedL5YFEzNU1A7CgAt2D37GgAu0RwlqXsSwHFPfRkunK/FaNNo/K3kIB8dGBDfxPjmQo3bM4TB7qR4J/9X0k6+yORwoe2pneTKhbyX97RJlgcjoKJj4KXk2r/VCKjIAZK0lbSTt3I9KJ6OtwCJvpZLBVR8+OAGFOWMdy4uKEoy0KhOp3NeNBCNJXmZPAVUXJYzQXS7lKZpt2CNhMdMl2zohSn5fgeS1el0mJc+0u17I4AF6aPwr85SVfue8F9Syw4OFT1t2N9SJdLB/pYqtyCqwt8DQOuAxUzYx4S6JuXz0gtFuvAnoOLMlHy8bwgD08vxi1ohLxScvpCzkvP8ChJJD/QpYZ1QDKioLYRCEMRxkEw05LhAaoDz5/BTi7C2eK8i+p39zoHKsCz+enYfvuiplb2JwcEZc2NXQ5no5okUXK/0xxnDFNH+5bdb8fq5QzK1xCDypoX7n6E+xcNvdTSNuWmF6IhIwvKYGDxz5Q2yWeVHmMJl6chBqi2jDSZ02j3fyPOXNgVg2/yH0GHvw5OHP/E7EF0w4al/X660pXCh34o1p/ciKyIWq13akoy5oqxxshcNCLzxLXx5SsFTNnSO45CSkhIUB1uapjFv9BV4LznOY2RpNeF6SUTppZFInRHdA1f9pfQ9whSOuSmBZ4U36PVYMOZq/PNQCW+VIxC+G/wJEUDTdNDacqihLYRCEDqaxqvTlmDFznUAnLuJckY6zk3GwE5sWc4E/OrYVkX0m/p7JGP0eMJfzuxXXLdm4NrmqrGzZPkW4n9PfKWILgDEm8IBDqjsaeedpX2Hc4og8YdcJ3OKohAbGwvAeVXZNeYS+Z2l+4LPTxa2JZmonhw3G899t0P2N/7QJvjR+LmYnzEKALA0ewL2NpZjTfEebKpWL7pxoPDUvy9X2nL40ZFPJcvJVelnr7zR6zhlAVydkYfyqpN+vzxJsEZXCMeO2iC0l8XGoijbmXrnw6qT+MuZfV5/e1P6KGytPefzM12v9SuN3v/jCfPwq++2AZDuJ6/PuE2V+EUURWHZ2Mn4INzkHnNN8G7wl3aw2nKooS2EQhTLciZgw7yVWHXoYzRYOzHflIId/Q1ICY/GQyOnozAmwc1CkWyOwqmORq+0KYrCip3r+LNtQlvObA8AHw/ktFIKDsB75d9ioSnVK22lWJY1ARvPO2NimCFtzlWCpr5uj8Eal2SNQ2VlJXJyctx2Q74uIAkoOK8/9znsorZ8ddoS9PtxDV8KwrbkKGfAPalr1i196kQ2VgtK++DlRNtXEJ+lP5352mtdPSjcHpWLu+Zc5R6EL8CXJ8uysmMnEDAsiz31ZWipa0BCWgpmpxbwCzElC6GfTpiHh0ZOVzx25axixFpfa+2QbHHyu59fcT3Gx6Xghwc/QmNvl9uYVyvIIdH3kpxxsla6QGmr3ZYXA9pCKIRBTNDEZ+XHWemY7SHf1uiYRHzZUOaVrqXrgmgQC2/mqImWvh6kRqaACvzUBwDwRX2p90oKUNrRgme/2+Y2kZFd9YY592OszeiWY4cEefTnlccB6HbYoAfF65vQTwqL9PBL35BujMSLE27Bo2NmiqIO+7uAUwM04DX2S7D6YCjT9hUcnMdnShAFPeZnj5NNauw3DxwHm82man4q0ncbrJ1YYc7EhlPV/IKiKGucooUJkUu4WCjtaMaz322X/A0gbRUTWuu9WdN8nb/9gVDfOp3O54wBSmmHOkJ7GacBOprG7JR8jI9LxeyUfI+D6MXJixTRtDJ275VUwoQ457Vryks9JSDXdgNBgikCa4r3SE6apOxHRz91S6jqKcijv6jr7cSKneuwt0G9nEfTEzPx+NhZbosgqSjdQ4HEsAgsFKRDUYpUFReHlxvijWbZ8UbBGeAwKzIOgG9JjS8GvEWY33S+GK9OW+KRhnBBI5T3l1fdiA3zViI9PEZUnwRalbPaEGt9mll8Syk9PMbtd77M3xqCB03rlxHMRiOKMsd5rDNpRPoQceNErDEM7825D2kuk83FQkt/D9rs8jnCiAP37voy7Gmw8BFZA8ls7+lZAPCXs95N+0qR4jI5B2MB5wua+3qwpfasz79r6OsOAjcXB89MvB7PXXnjkD1v1djZANw3H+TzS5MXgQ6BtAlKIsw/cXgTirLG4Ufj57olnNZRFH40fq7HY6hlORNQedvPsWX+gwCALfMfRMWKZxQdXbmmnuAAnGqr15KeDkNoR2OXAGiaRkZGhqJz2o9veABLvvi3ZPbjosxxeHzstbhh2+t8GQMOu/qbZK+XBgIGHIwj4nCwpQr1w/C2khwYcPh19SE0Vu1GengMHho5Dc396jjFuurbl+MMJbS7ooyifhKMBZzakOqDavXGYPdvb7SjDSaMjU1CengMPph7H548/Alqg9Qerv4pcs6zS7PH80Hy1IYvc5U3uPZdqbFT3dOO549/iZdO7XJrBZbj8NKpXZiemO1xYaOjacxMzsNnOIuZCo4G5Y7Ia60d+JXgqI34HC7NHq+aTlyhpr6HkvZQQ1sIXQKgKIqPeq0EH9/wAHptNvz46Kco7bqAwqgReHHyIpiNRnxZJ/az4QA0sIEfOUmBA/BJUwnerzweFPrBglAnNS6Tm5q0hYg3mtFm6w3odc0BSImNdwZJG7jZ9mGVugklg4Fg98GLSbvT3o9797wLwPlifGXKIuxpsGDtuQOq8iLnnyLn/+PLfOITHz7OVZ7gelVdTt+vnpY/6qYwaDVS41jKFwsr73Po4ZgtUKip76GkPdQI/aWcBjAMg5KSErcIoJ5gNhrxlxnLsW3Bw/jLjOUw6vXYVV/mdvtLDwrLwzLcopF6Aw24na27Iic8Fo6GCz7TvtjwVyeB0JY7zvAFuRFxSO1ksLH8BHLWP495W19TdKPmYuNi6Pti0K6xduCO3W+pvggCpP1a5Px//JlPlEJN2q5X1eX03WrzftS9t1EdPzxfLKy8z+HhT3Du3DmfdCKX0NWtXoi05cWGZhFSiOGUdFUqkZyQPyEvSsKyb6oqxpNHNuG8tYMP+c4/E4CBon1OCUCDwiOFU/Gb418AGIxmTMLtA8D1yQXoaWgCJUEn0DQHQnr+pKOQkkmYWNREDXLgC+9KUmyYBvTtAAcdgKyIODw9fi7GxySL2slXmW7PnoDTrfW49+xn6Bu4pxVI0lVheTCTrgp14klWf1JsUICItjdZfZEJAIwutFlwiNCb0OuwiWj4KpOw77nynhURi5cn3YoRYeFuSYyVzBEsy/J/omcGkPiSlAvnqUDnvVnJecgMj0GDIBmyaSCiPGmPSL0R3QO69tT36q2dkrohvAuTUBNepGSt7xEnsFUynup7OlDe0YJcJldROgqS0LXG2sHLlBUei5enLEZR9jgR7wzDwOFwiJK3KmknYblcOwlpe2onLelqCGM4J111TWqXn5/P530hnVFpor4z7Y1YX3kcyQ4dzsM9QekZuzN9xAxjApJkkkTKJb4c0z+YJPH9rgo++WC0IQw3pY/CyQv1OAcgijLgxrAUnoYaiS8DSbrqLZknSZIYRTXIJl0VJij1RSZCu8HYh522JozRx+DXWTNRbrFgLIzYP+u/UEpZ0dTYiKPnLageCOevRKamqhqc1UVhqTkz4KSrrjIFO+nqWH0MYKaCknRVSFvtpKuptBnLzJluSVfnGpP86nsEwqSrjoFFrY6icdXY8Xg4bwpqq6sBO4tUhIPucVp/uru7FSW+NJvNAIDW1lY++SXg37wXGxsrSuZJksICCHjeGzlyJNZceQvWf+uMjUSDQp7OOc+K2sngve8l9EP0XFeZyHugs7MTCQkJsglK4zr6Rf1MyXiiQaG3oxMVFRUYNWqUxwSlO88e5xO6NhiNgzJx0Vh/eBeopjZMzx7Jt1NbWxtaW1tRVlaGpKQkxe0klEmuncrKynjaWtLVSxzDMemq1Cq3pKQE+fmD+XuUrLgdDMMnCJTbldMAlkkkdFWyg91+40OYnZLvTJLYXImG3i5nksSBZIvf3/s++hpa8GFvtduZeqC7cmGSRJtLlBo1LELekq5SAP7fyOl4veSQTzIJEzDaKQ6rx87G7ybdzNcl7ddnsyH2nV+AITtUBTKpmXTVtVxLunrxk64SXjLDY7BmShGfrBjwbVfOsiwsFgvy8/NF1my1LEIWiwUjR7rnCvN13iMyfVRxUpQM+YPeasVJVwEgNSIGlmVPi27Kucpkt9uxbds2LFy4EEajUVZWknS1VjCnehtPelDYOK4I1185BUajUbadHAyDwg2/Ex29CWUizvDnlv2UT4LrcDj4xKh6vV5Vi5CWdPUyxHBKuupaznEc8vLy+A4jhKekdvsby90SBLrecKHg3NX083taMaQi5lJwTi4kOJhOp8O8tEK3encWXIU7Kt8QJQEVySVDX0lCRfK7N2ffjVVHxXmXRgyk4bhgk76N5S3xJQMOW/rq3RIyuvKeEz3C56SrhHY/WHAc8FLxbkxPynFzpnyt5AD6OfcFsSfeRbQVyqqEd2F5MJKu9oN149tX3uXKHRI6AdRJukoB+Exm7AQj6SpBjbUDK3a/4eYTpDTxJU3T/K7fdT4h30tB5ALAstjdYHFzxKZpGnl5efyLSgq+zIcURfHJkHfWl+H7u9/lFx/e2knoQG7QS78KXV/uhGc5HRgNBrw8rYhPf+RpnJGFUlpEDOZMuJrfIMu109dNFZIJXYUyVfS0YV9zJeamFoCmaRgMBuTn54veDb6+t+TaQ4q2XH0t6aqGIYFeZiB7gpIEgRyAHk55ggDX2ymecH3qSFA6GpwfGSR0FMVbQ6SQEeE0fy/KGoui3Alut2MAp2NjrbUDTx76xOP198SwCDT3DX7vTSdkZ3a8tc5XsSRpS91qOd3uPVWKEtqhgGDyPdS0R5jCEUbrUdfbGbR2INaoQG5D+TOfEHhKT7M0e3xAtOWgo2noKAq1/d2K9RpouhA5CNMfeXKcJnPlH6cshslo9EpXaUJX13rB0PdQ0B5KaLfGQhwMy2JXXSk+OrwHu+pKfQrSpSRBoB4UVpgzFd988RZ1VQgKwL8Kb/Trxk64zvPEsTzb8/PJjZl78ifhtRkrPHJwV+5VSDRF8J896US4EOxx+B6h25U2B/GtFnJbZPP5MwHTHiqQpz135QK8M+ce7LzpB/hg7n3IUBhEM5h8+0ObAhBjCPNaT4r26zNuw5+mL+XpqPk8IVz7jS9gWRalpaWKHU2F8Bbp+aOKk37T9oYGa5eitnxszLXYedMPFAdG9AckEOPOm36Ad+bcg+euXIB0l2CmZK4syhqnSCdKE7o2Wjv590AgbekNwaQ91Lg0lnOXKdxy7Jz9THHSPoZlwXAs4o3haJU5IlKKxLAI/HHKYqRHxPici2hMbDLen3MfHj/0Eer6lO14AKDH4TlB2YdVJzHdNA6fnj/tdjRGdqdER3I7OGJ1UpKokqct2GWWd7b4nIxWDvW9XRc1H1ggSHfRN8Gy7AlY8dU6fCwR3HM4gwOwOHMs3iw/pvg3rn1OicUAGFwsrSyY7FM/JFBqRQgUDMtiV0MZHtq3XvaYm4IzPc3mCcuCwkOKWVlMm+XZE1TNuSUHstki+PkV10vGbVJ6/dxbQleCJ498ipeL9zhzrWWODVCKywPaQihEIYxeKtwBKQnStbHyJH548CPU9naqwktzXw/SI2L8nlyKBMkdf3ZkCw5eqPb6G297kJqeDsAE3LvnHZEzKeD0oVi+cx2eu/JGFMYkItUchaKscbg1Ywz+enYfttWVYGvtOY9HbwQZA5GlCR3hQvCK+DSvv1cKkgAy1I61PEFH05iTkhdyCyEAihdBs5Ny8fCom9ySaUoFNGzu68Hqw59IRnuON5n9WggptSIEAqULdGKlOt/dhlFB4OPapFy8ZwgDJRM2iBxZu2aMHyq4LoyUggQ/re/twkMjp+NX320DBc/R1UUJouH92O1yh7YQCkF4y7HjyT9gY+VJLB9w5FMTge48ySQxMiZJ0UJIDQgjQntzoBYiMSwCy7LG4+Fs9xecEC0BWtoIMsJj8PeSQyG7CPK0OH909LX40dHNihadoYhEc6RsMk2pF+OybHd/Nh1Ng2FZZITH+GQNHGEKD/pLXy6dhCd0e7Hm+gsdTeOm9FH4V2ep5PcclPkuDidILTKVzFVDYYG7lBA6PUIDD9fopQ5w2NBbzd9MkPMPYFgWD+9b75G21JVhIW05+LrzZFgWexrL8a3eij2N5fyZ9icqHSX5igv9VkWLIACo7+tGQnYG5qYVepxU/dmNS+n72qQcVY7DlLal2iBPe+LwJjcfNqNej5yIeI+/DybfwaZ9wtgn6t/eIBftWUfTeHXakiHx7iIxYbzduPEnYa8DHEZkpQct9xWXFDfk/TtQyOlbzt+qtd+KVpsVD+RP9kiXg/MWWWO0Lmj6VtJPQgGaRSgE4Wp9oQBEUHp0cnbRFOBab1dDmdeXvdT1eSnawu+9mZttDgf+enYfLN2tyI+MR2p4NJ46/CnqejsRTRnQydmRZo7Gn6Yv5aPADmdQABp6vB8rKj3Td6Xtqu8d9dI7XF/hrS39wQhTOADA2u95ly9cnBMrCMOy2F53DpbuCx5/Gwy+h4r2n07uwW9PfCnrJ+ULluVMwI/Gz8UrxbsVZZ290G8V6dsXOBwOGGVuMpGjmi/ry3xaoFMAMiNiMS0+02tdf8CwLH5+ZLPssVGgN+mCAYZlsafBgobuDqRExvDWQyVW/09qTnulr3Su8hee+kkoQVsIhSCSwiJEn3WgsDAs1W1n61pvV4PvN0jkaAPKrsr/5MhmvFK8W/LoQy+gXdvbieU714WEiVIHCnEdNrAsKxtjAxjcxa/Yuc7rmb6Qtqu+W1XKPu+pLf3B9SkF+Gz+96Gjafz62Dag1vsilizOfXH8duWbApDgEtLAX6itEznaaiTY3Fh5UjKLuif4c2TNsiwqKipQWFjo1r/9ddjnr4pPXozzVVWStAPF3gYLruQiUYY22bg9rovxiwm3yy691fxll3iT2aOOOTgXut6gdK7yB576SaghFN47Gtzgy8XbQbAK/TAKo0Z4rwTvV+V/cmQzXjy1yyf/j+F+EZPsarMi4xTVJzfSvCWg9YZ4Y/gQX3r3ji8bypD/4e+w6Xwx5qYo80VJNUfJmvyVgOhg7fRlyAiPkdUJBacv1y3po31+RjDg6XhQCfw5hgKAE631HpNy+oJA2o2/Ki6Idq02Gnq7FdUbqpt0nuAtzMCm88ouEMQbzR7HgC9z1eUMbSEUgmiwKjN1utaLN5kV/a7Ry4QSbwrHFwsekY3DwbAstteexUundit6XqiATDgvTV4kCsfvDSSmyB+nLPL72avGzvT7t8EEmbgv9Dl3p560khgWgerudjyyf4PfthfyQr0t9wq8Om2J5DPJ59euWYHNN34fPx4/FzrXiOt+Pt8TvNEMJLaPL1nNhfj9ya8wb+tryFn/PDZWnvT59wT+LsS8zRVqQun1+aG4SecJ3o69AOBthbcSV42dDUB+DPg6V12u0BZCIYjmPveFil0i3QKpR4LwlXe1KqLf6XKrw5V2a78VOoqSPA7bWHkSOeufx4Lt/4B04gzvfA9XCHe1vjoI6mgaj4+d5dGKQSDUCdnV/fyKG/AjiRe6r1Bb36SFnzn2ueizFJr7enD/1++hxUMUbzkUZY/D9hsfEr1Q5axtGRGx+GDufYg3mfFu+be4OWM0uu5+Hn+csgiPjbkWf5yyCO/NuZf/nVo6uSVjjFuZFG1/LBK1ATrLkwWr0sWQa//2dSFGDfz9fcZtuN7lUkGwnGuvTcpFuN7o1UJysa7PE0jpUthPODjHSrTB5JHOCFM4fn7F9bJjwN+5yhdcCo7SgOYjFJJIdNn5OMDhw74ayXobK0/i8QMbfQpWqIS21GTu61VaOdrDBcSv54mxs1CUNU4UI0gqaaQ3KPEZctUJB2cAuOePf4kXT+3yQwp52mqBw2DcpmDglsyxuPOa6yW/k4vH86RrPJ4BZ+Unxs9x66dKdPLYmGuxPHsCNlefwZrTe0THvTqKwupxc3BzxmhsrhmM+C2nb38sEs0Kj33k4EvaDZ1O59a/fV28yaWvkKKtFowGA26ZfC3+vbPMbXz5kvon2HDVpVw/UerKIDUGAp2rlCCYbTnU0BZCIQjX1T8FIJkOQyPbJxr8ls4Lolg5SuCaV0uONpnMyQ0SkrPLF9O5HG0lMNI62FhlEVm95SWTg9xkznEcenp6EBERIZs4Ug5yUaxJbJBWm5XXCQUKLDisOb3XZ96lEIi+LxaKMsfho+u/h+7ubll9C+PxbKw8iTt2vekmH7GIvD/3Pqw+PNhPleqERCOem1qA/716oegW5CMjr8GhC+dR29OBBFMEb/FypR1IQL/EMGXHPp6g1FlYqn8rXbz9YuL1uD6tUDbCfCBjxxs4jsONCbnYMPd+rDq8STIwZbCP55TAVZdyfdDbDVrhrUC5YI3B1newaA81LouF0NKlS7Fr1y5cf/312LBhw8VmJ2CQa9lkoOtAYa4pSXTzJSM8xmcLAgXgr9OX4cnDn/BXvl1pCyfzQFM+SPGtFDkRcSjtagEgvfN7ZuJ1QE0fnpl4Pf6v5IBiixgN4D8z70RmZKzsZM6yLGpqavy+LSG3gwOAPfVlOHHmDH5U/XVQbjH5q++hxoyELGyb/zAiw8LAMIwifSu5cvzfBzeKFvredCK1eDHq9Xhi/BwAzoXXyI/+IDkGhLRJWAp/LRLpEYE52wvhzboj1b+9hYIgenr2qgUe5fNn7AgjK7taO6RoFxWOQ1H2eEW/uRhw1aXUHBtnCld0W9SftlQLwaQ91BgePSPIWLVqFd54442LzYZq8BZcjQLwQMFUn2LyZITHYMO8lVihwAl1zdQibDpf7PcNEjUQZwjzeDb+04nXAQB+d+JLn44FWQAX+ntEwew8gfhfvVv+rU+3c6QC5+loGtcm5eJYa61ifocDKABxRt+SgnrD/pbzGLPpRayvOI49DRacaqvHngaLR/1682MhvhdK4e04xZdbVL4kI5YCeXmqAX+O5sicA3ieF4ie/B0XriA+h/O2voa7d7+t2PFbLjDlcIASXa4aM0sRrYvt+H2p4LKwCM2dOxe7du262GyoCuERi/B2WOaACXhD5XHVaRPzclHWOOSsf/6i2hQu2Kwez8b7BgL8+cOjpVuZU/mmqmKsOrLJY0JXOcjtcnfVl8HGOvzg+uKBA3BzxligXV26NdYO3L7rTT6Lu7ekwmpfi/Z0nOLtFhW5vq8kFYsSCP3LAoGOojAjMcev38od67rqScpSTMaFL0lA5XwO1YjJdLGhZI79e8lBrxa4i+34fangoi+E9uzZgxdffBHffPMN6uvr8dFHH2HJkiWiOmvXrsWLL76IhoYGXHHFFfjzn/+MqVOnXhyGhxHIQmBPfRla6hrwcNrghPurb7f5RMt1cvFEe5ePEWU9oYO1+/U7x8AOU+5s/EBzpd885Ud6TvlAURTOdLfgzpOb4BqPWGnSW7kXxabKk37rRAmCRTtCH9zosoRvT/r1d3cspZOXptyKJwauJu+qL3NbsCq1PkWHR2BOaoEqt2uEL88L1kHnaV984BiOw/7mSo8+QhRFwWg0Svp9eHPM9bp4mXM/rjRGevUp8Sefoie+hyM8zbEAZC9W+OL4HUydhJq+PeGiL4R6enpwxRVX4MEHH8SyZe7J4d5//32sXr0ar732GqZNm4Y1a9ZgwYIFOHfuHJKSkgAAV155JRwO91309u3bkZamXgbw4QgdTWNe+kggXey9H+Pl6qUrpCYXOdpq7bwd4PB5f71fv831EvSxztoJf9xLdRSFR0dfK/s9w7LY1VCG75/b7rYIApQlvfX0opickIkjfurEGwLRtze8WXYU82KDszlx5dtVv8S6Vt3dDhq+BeWU00laeAw2nS+WXbD2K7DaOcChNdqo6hVj/uVZV4rOb85iy/wHcW1KPvY3V+LDqpP4y5l9Xml4G780TSMvz3dLg6LFy9FPULHiGa86UbLQdHX89pfviwm5ORZQboHzhGDqRA3aSv2/go2LvhBauHAhFi5cKPv9K6+8goceeggPPPAAAOC1117Dli1b8K9//QtPP/00AOC7775TjZ/+/n70C/ImdXY6zZZ2ux12u/+7afLbQGjIgeM4dHZ2Ijo6ml+dL80ch2PNvl+Vbunpwp66UswcMLlK0U4xhsOMwJ3jaABZunCcZ6w+R5S22W3YWXMO1yTmSA6cC9ZuRAI+87lqzExQHCfZTp+eP42fHt2MemsnsnTh6IdOlm9XPQLOQf/TQ58gTIYnCkBVWwvG6KL80ok3BKJvr2Cdrz81+oUrpPgm+m3r78NPj25G7cDxgsnH58vppORCA14YSGchlKnV2o37dr6Fn0283qusNIBEOw2bzab6rnlafCZ24CymxWeC4jhcm5ANjmHwzzMHvf42xRjucR6SGvMEZAzUCo5z0sOj8YfJtyLOFIYL1m6Pemnt6cLO0pOYnTvGo07quzsU9aX67g5eFk98B4qhnr8JFqWPxs1LfoIDzZVo6O1GijmSn/OU8BJMnQRK21Nfuim1EEDg+lb6e4rj/LhXHCRQFCU6GrPZbAgPD8eGDRtEx2UrV65Ee3s7Nm3apJj2rl278Je//MXrrbFnn30Wzz33nFv5O++8g/DwcMXP06BBgwYNGjRcPFitVtx9993o6OhAdHS0bL2LbhHyhJaWFjAMg+TkZFF5cnIyzp49q5jODTfcgOPHj6OnpwcZGRlYv349rrnmGsm6P/vZz7B69Wr+c2dnJzIzM3HjjTd6VKQ32O127NixA/Pnz4fBYPCbjhQYhoHFYkF+fr7oGuMvj23Fq6e/9pnelvkP8pYMOdqfnj+N+/a8A0D6/PrN2XdjUZbTMZJhWbcdDcOy+EfJQXBNHaCSYvBgwVQcbavB7V+9iR7G/10A2VHE6g3o+q4UD7YeQi/k4w3dmjkG1ybl4PuF02DUSw8HhmUx4eOX+J2LHhSKzOnY1Fvr8Rq6UI8AsKHyBP7r6w888q+Utj8Q0mYBsCrSN0OHf8VP86pvfyCnkxGmcEWJJ/2hrQTPTLwOvzvxFQCZMTDzLoyyGdzGjhqQm098GZdykBrzrmPAFRSAEWHhaOnz3B56UHh/7K2Yd8Vkr6EQJnz8EuqsnbLOwukRMThR9NTgTTWZuUoNXIz5+1KlraQv5UXE4bemMQHrm5zoeMOwXgiphS+++EJxXZPJBJPJ3b+Gpmn+XJuiKNA0DZZlITSoyZULz8OFdGiaBkVRYBjxi4N8z7pcOfVULvwjvPxu2iIwFLCmeI9oMnGAAw2AFlze5AAw4JBoCgcz8JlMMDqdDjqdTiTH0ryJeFNHY/WhTaLw/2kRMfjj1CLR7RCapjF34Ayc8G4A8P/GXAuL0YIzRhsmbv6j6BycxNPQuVwwleJdWF5lbcede97C29feBSOAXjCwgRXVZsGBhTMW0Vtz7uHlJO3h2n5fN1eizNoG/QAVbiDQYR8Y2MHx5UJe9BSF6Yk5Ip2lRsagD4xHmQhtO1j0gZVtJx0oSZlceRGWJ4RFYnHmWHB9sXj3/HHJ+sxAYhQpmeTagxLUt4OFHazXdvJFpjDQvE4c4Pjyhn5xtGU53j3JZBDomyyElPa9/JhEvDnnHqw6sgl11g6+PDMiFi9NWYSirHEoKSlRNHfI9T25OUI/sGgX0gYGxiVN4SmXyNqpETFYM2UxirIGk54SXjiOc5tTXMf8100VqLC2e2wnW183EgcCSnJw75POxUscsqLiYTAYwLAs9jVV8BukWSn50A3ohqZp/GHKIty5+02+XXQCOgDw+6mLYDIaed45jgNN0zAYDLyOXWVVOme7lhM96PV6GAwGxe2kZC7nOI5/nsFgcGsPuXZSyjv5TNoz0L5HeBfSFvZDqb4k5P3rpgpUWts9zhEVPW2AabB/+/POpShK8QJtWC+EEhISoNPp0NjYKCpvbGxESkpKUJ+9du1arF27lu8EFosFkZFO99uYmBikpqaisbERHR2Dk01CQgISEhJQW1uLnp7BeCUpKSmIiIjg6ZDGycjIQGRkJCwWi6jz5ObmQq/Xo7S0VMRTYWEhHA4HKioq+DKaplFQUAC9Xg+LxcKf1RqNRuTl5eGZkbOwMjIfR1rOo83WhzbOjt/UHMJYfQzGGwbjklgc3Thib0UOG4Z/fr0N6w1huCl9FK7NG4OIiAjU1dWht7dXJNOynAm4gglHaWsjuh39iNSbMGP0BERHRaGkpMSrTBzH4ay1FQ8d2oIbw1IAs9PiZudYfNhXg2Q6DHNNSXz9DtaOz/vrkaOLwFTjoLN0A9OHXbYmkUy7Tn6DG/VJoABMMsQhTz/oOn3K3oFiRwdeKZiHcotFJFNsbCwqKythsw3GYGrknLuKorB0GCgaNChk6cIRRRnQydmxwpwpaqcNvdWIgB67T3yDnKh4vp1mFRTgiohEjGYHk9+6yhSjD0M8p8MMYwK+cpFJ2E5XG+KQ7yLTKUcHZhoTkaIbjOlz2HYB5UwP5ptSEEcZ0djWBq67HUl0GBrYPl4mgs/76tHDOaRlovRYGJbKlwnb6QaTczwWmTNwge1X3E5KZJphTECWLgLLzJlgwYlkiqEHd4u7+pt8limKMoho2zkWGxX2vZi2XkxIyULlbT/HztKTaG9tRaTehKzIOMSFxYKiKDgcDtG49DRHSPU9uTkiIyPDqTvBfAI454hb0kZh9MTlON/d5hyXxjDMv2oaeq1W0fgjc0RHRwcaGhr4crPZjIiICLS1taG11RlK4kJbPa42xHnte0uSRuFgSxUASLbT7ZlXwGgwYFNVMbYc2w+rINbZo1Q3np9yK8banDcQx8KI98fcitVVe9HW28P3vWhDGG7KGI2lORPQ3d2NmhqnLyTHcejt7QVFUW4yRUREIDMzE62trWhpaeHLlc7l5D3Q2dmJhIQExe2kZC7nOA5dXV2oqKjAqFGj0NPTw8vkqZ2UyNTe3o6uri5YLBYkJiaq0veITBaLhadNUZTs+2nkyJEimS601WO+KcXjHDFK73wXkP7tzzs3NjYWVVVVUIJh7SMEANOmTcPUqVPx5z//GYBztZmVlYXHHnuMd5YOJjo7OxETE4PW1lb+aMyf1anD4cBnn32GBQsW8KY+tSxCrituIS9S5R+fL8aThz5GncA06borJ2v09+beh2W5E8GyLBwMM7iDC4/C7JR859VOP3dGDMsibf1vnElcfbBAKLE0mKHDm/HXgBmfgyePfiKSNT0iBq9MLcKSrHGKdkZ7Gstx3ba/+Ww9eXvW3bg99wq+XKfT4SeHP8Ufi/fI8n5b9kSsrzohK2sgFiEAoECBA+eX9cSTRSgSerwZfw3uaz2AXjCqWoS8yeSNd19lWpYzEesrj3vte5/P/z6uSysMyNJA4OuunGEYfP7556L5hNQHAp8jXHnc02DB/O1/99pO2298CG39fXjqyCc4b23nyzMjYvHS5EUoyh7nDMa66w03/bID7bRhzv0oyh60XHFw3iJrsHYhxRyJa5NynbdaA5TJl3K73Y5t27Zh4cKFMA5YodSyCKnZTv6Uu/Y93lLX143U8GjMSMiWTJrrr0x7Giy4cfvfPc4REdDh7fgZfP/2V6b29nbExcUNfx+h7u5ulJWV8Z8rKirw3XffIT4+HllZWVi9ejVWrlyJyZMnY+rUqVizZg16enr4W2RDBWIqFkLuCqinq6FSdOTMd0rLWZZFa2sr4uPj3Z4tZR4kV3B3NZTh9p1vodU2eK5PUgEAzsXQ6iOf4NqIFOzraXDP3yMTPJBhWextqhBdiSQ7YiEvOxssSGUMaAMk/TM4mXI5/xZhOfndoqyxKMqd4NMVTVcdzk7JF4XEpwGM1cfgtKNDlkcOQGpEtEhehmXxr9IjHmXaUnsGo/XROO3o8CgrI1EmlFuq3Ml3NM+3t/pSMnkrd4Dj/6+knYSQk4kFx+tbOMX6wrtcOQXw+qYGkqdeNSIdH1Qe99r3mm1W0TG3W10P49LXuUNqzJNyqXlCqkzuqMC1nGVZtLS0ID4+ni+fnVqA1PBo1Fo7JNuJgvP4jcTBKcqRTnFhdzjwl6NfgIJ8ezxx9BMU5YwXjdF5aYWSehHy7qpvKVl91bvry53MY0rbSUm5kG9XmYSQK/fEu1Qf9FTfU4wz13meoijJ/u2N99mpBUgZ6EtScwEFp4sFoSWk52/7ecNFXwgdPXoU8+bN4z8TR+WVK1fiP//5D+644w40Nzfjl7/8JRoaGnDllVdi69atbg7UwQbDMPxqPxAfIYZhVPcRAoDm5mZERw++eJXsIk5eqEOnrRd6ULK78vqeDnxcfARPVu4W+cOw4FBr7cCdO9/Ae3Pu43dwm84XY9XhTeJoqeExeHnqYizNmSDiZXdtCcYbYnDO0emW6yVQi5Bw908BmJWUK/pM9Kh0V/7qtCW4c+cbwABPEwf4ZmV8hLIiYjEjIVvUtrsaLWi1WSXrE95tDgcmmmNQ5uhS3UdIP8B3maML/QPTj9o+QuQ5cu30gzEzsCxrPFp6e/CTo5tRM7C49CSTETTPt9BHKBCLkI6i8N+jr0VmeDS4xg5QyTF4ZNQMGPV67G2qUNT3UkwRvD+L1FzAcZzsuAzUIkTqCOcTUh8IzNJAFkIxMTEiXl6dWoQVu95w0y830B5rJi8GOM45Vwrk4FjWyT/HYW99GZIZPWhQbmOetFN9Twf21Jdhdkq+TzIxDIPm5mbExcWpbj0h+id11LQIMQyDpqYmREdHw2g0qmoRcjgcPG29Xu9Wn2FZ7GuuRENfN8ram/Cb41/wY4W0R6O1UzTPE96FtIX+ZEr63qtTirBi9xvQAaJRTxbIv7/6ZqC4iu/fgVi5lOCiL4Tmzp0rEkAKjz32GB577LEh4siJUPIRys/Ph91uR1lZGd8ZPZ0rH2Ha8ZcjO5DM6Hm/CTk/jTP2ThxqOY9rjAlIkvE92fbtQYzuN+BcRxMeO7cD9WwflodlDPppcMB/7X4X4MCf/wNARGsvaABRlMHpIzQANXyE9IJp1tdzZamz8mU5E/D+2EX4vPoMehw2jNVHI4pqkPURujfrCpH/EU3T+KKz1KtMNCiM1Uejwdinvo8QbcRYfTRgpvBVf2PAPkLJ4dF49cIpn3yElmSNwwRjHFo6GWyZuByfV5/B+01nvfoIjdXHAGZKFR+hKSMysSB9FAoLC7G3thQdjX0w9xlRUV4OvU6nyJcr2hCG5E4GtWytpJ9GVHQ0SrhutDZWo7KrFdlR8aApakh8hJT4aQCefYQAoLW1FW1tbXz5NTGJ2DBvJf5x5CvEMIMvr0Ydg8em3IApuliUlpbiTHsjttaewxc9tShnerDQlIr3TFG4KX0UGJZFJOV87Xhqpwvna1HaxfokE8uy/DgPJR8hYrUJho8Q8fMqKytDUlKSSCapdlouGPdkPC0eaCcyz+fn5UGv16OsrIynTdO0T33vSmMkNsxbiRcPb0MOO/hOsOlp3DN5DmaEJeIQqi5PH6HhiFDwEQKAkpIS0TVGuV3EpqpirNj9BigoszTQAJaZM/Fxb43IlO26K/98/n/hoX0bUGVtl92Vx5vC8d7suzE72Xk75Nljn6PMUo4Pe6vdjORq+QjdfPPN/I6EwN9d+cbyE3jqyCdosHZimTkD63urZW+NZUXEonTpT0Xm/YU7/oEv6ks9yqQHhWXmDGzsrQmKRYjQVsMitDJvEv5ZftQnH6GtCx7GvJR8Xr82hwMx7/wCdg8yhYHm+VbDIvTGrLtgovX44eGP0dTbhdvMmdjYW4NkcxRemVqEZXkTsbHiBO7c9Savc6ID3YBMZHcs1Zc2VRXjySObUGftxG3mTHzUW4OU8Gi8PGUxluSMH/Y+QizL8teihdYmUt/ucODrxnL+ttfM5DwY9HqwLIuPK0/hzt1vgoO475EW+eXE61FcWoINvdVwhbCdtt/4kF8WIYvFgpEjR/I6duV9OPoIMQyDsrIyFBQUBMUiRGgLLUJy7STXHgTbb3wIc9MGgx0S2r5ahAiPDobB3gaLW1/q7+/H1q1bLx8foVDBcPcRio2N5Tu6EMKzWYZlserIJnAAPwBc4Xr+rwMFi6MbdnCSvgFkcbS7qRKV1na3ciEu9Fsxf8c/+DPnOakjse3cCbASzwXU8REC1DlX3lh5Eit2vwEOTp2UOrp5fxUpHs/3tGN/S5Uop5NZZ/AqEwegdEDfrjIJ4Y+PEAeg20DD3ssF7CNEA9jaUOpW7s1HqKmvW6Rfs06HJ8bPwYundsnKZAfH60RYx18fodKuC/jVd85cfKQt7eBQ1duB5bvfwIf0SizLnYj3qPvd/CXSZNIbEJlc+0kZoW1tx4rdb2AD7cyRNpx9hCiKQkxMjFvIDAKDXu9MC+ECDsCqI+7594Tt8feyIxhLR7mV88+G2NfIF5koikJsrPO2nj/+NJ7Kg+kjRFEU4uLi+JAIavoI6fV6njapp6Sd5Mob+nt4HUjRlpNVjne9TifZlwi9y8ZHKFQwnH2EdDodUlJS+N2FkBdXb33iu+OLpeGIvZW3KAjLRbeRWFZ0ruxpd0HOnN+ZfQ/K6T5ZPxt/LUIUgOyI2EFeA7w9UdfbiScPfyri5Vt7G/+Sl+O9vqdT1Lap4dGKZPrW3sbXUPuG1ZzCcRjdl41XTu+Bg3PXu1KL0LQRmTh0wbmr98VHKNUc5ab330+6GSUdzdhcfdpNplvSxyBab8L7Vcf55/hrETKAQnp4DNYW7+V5ZMHx+ia/e3j/eizOHIuizLG4NX00f1MyNSIaM5NyQQGSc4GDYfDUoU3QYdDn7tgAbdJeqwdypFGQvm05HHyEKIpCamqqaD5xlVVqPO2pL0ODtVPkR+jaTnXWTvzXFdOw7XgNDAN6IiAbAaGvka8yJScne7Q0DEcfIQBISkoa9KlS+dYYoU382ZS0EyA9nlJMESI+CW1hP1TrJhyAy8dHaLgilHyECgoKUFVVhb6+Prc4QsJz5Qtt9ZhpTPQplstpeyciaD3MoCV9hG40pSDDFIXpXAxWmDN9iuXyxXeH8dqYm/Dw8c1YoLKP0O0ZE4FmZ9v44yN0vKkaW2vPodPeh139TWgW+D1RoJBKh+Hf1gp0ycURovSIaetFqaOUb6c4o9mrTIT2d/a2oPgIXdsXgeioFDy9dDbWVX8HprEVIwxmRBnCsL2uBO93VfDtZKR1sLPO15Obj5AVSAlL9ymOkE1PY1ZynptPw+n+dnxSXYzJhng3mTbXnsHjSVfghxEjUc/2gYO8j5A9JhwTU7Jw4uxpt75n5RxYbs7EmOhknOloBPSDcYQeCM/laZO+t7PqDDJterAch/7uNujhACKi0dnRgaamJp620E/jaEUJpnPRgDkaFkc3jtnbcEdYFjgKIDa4U/0d2NtYjnyHaVj7CBmNRuh0Oj6OEDA479U3NOBkbSUfO+yq7AIkJyWhqb5BNBak2okChVF2EzbMvR9bvhHHETpO9+C3k2/BWJtRNPcplYnjOPT396M8hnb6nnCDgXH/rKNw75S5mB2ZOux8hDiOQ3d3N6Kjo4MSR6i7uxuRkZF8HKHmhiav7QS4+9wRvzhbgg16vR4lJSU8bV/iCCmRifimaT5CwwSXko+Qp/gN/vgIkd3Ce3Puw62ZYzBq4x9EsUOEkNpd6EFh47gi9I6IxFNHP1UlsrSBorFq7Cw8N3E+tm3b5peP0MbyE/z5uRTvxNfGk48QBWD7/IcwT3A09uzxHXj++BcXzUfoqbGzcH9UAQoKCvhzd2Hfszkc+FvJAVi625AfGYdHRjrT0Pyt5AC21ZViW905v+IIkV+8N+c+LMubKLK47Wksx92730azzSopEwcgVmfCQmOyVx+hh0ddg7UzlvG+XKQ/MeBAUxQol5mORJYmPkLC471fTLweV8Wli+g4wCEzPAZrphTxtySFfen98u9w/953+XaiAN5HaPC4kMNbc+7BHTlXhKSPkFQMsrTwaPxx2hKc77qAHx/dImo/13bSg8L/5c3DfTNv9BhZWghffIS2fLMft5/dAhac5Bzx4dz7JaNrX04+QjtrS3Dj9r97bCdAbEkF4HZrTA0fIblyzUdomGI4+wgxDMOfwbp+50v8BsDd94QMDqHvB0Gmi7/Ey9OKsGLnOpArkFJwLe9hbFiaM56P9fO9Pe+iauDF44+PUD/H4oXi3Zg2IovPXa20nRiWxa76Ujx0YIPb+bkr7yzETrSu4AA09nWL2mNuSh5+e9y7TKyApho+QhSAJ8fPwfNXL0RpaSnvlwAM9iWp+CEvn96LV6ctwePjZuPl03tl28Obj5BrP6Fp6XglcjJ1MTZeJ8Lnu/LSae/DrvoyFOWM5+PYbDpfjDWn94KR2e9xgCTtsx3NeP7El24c1Vg7nL4+81aK/IRomkZqRLSIBglL4Uo71Rw1rH2EhLwIyzdWnsSKnevcdFJt7cCKnevw+JiZkv3DtSzC4LTUGA0GSf8QX+ZDVx/IT2vOAJAfNw8f2ICi7PFu/kcX00eI0BNuYtXyESILFOFCRfgeEGpIbs5OiYiR9IsT0hbypVbfI7Q0HyENqkJHO+PhkMWKv6bAeFM4Pph7H+YO7OAIluVMwIZ5K91ecJ4QqTfxvM1NLUC4zujlF8rww0MfYW3EVYrrS72YA0Vjb5fo89yUAowwhuOCLbBEob4iLTwG0xOzZb+Xe8HVDrzgnr3yRp/0QvrWE2NnoShrnFsAS7nneafqGW+VH8Nb5cd4Z/yirHG4b8+7Pj2FYFd9mSR/xNLzxICvj1CuWcl5osCbUhJkRMRiliARb6iAYVmsOvSxR528W/GtIlpRhjDvlfzAnkYLer0kbL7Qb8WuhjJcn+a+ALtc4Ok9QD4/d+UCFMYkKApAeylAWwgpxHB2lqYoCiNGjFBkelySNQ4b5q30mmIDgm9O2TtAY9A61NnvjP+jk5B1afZ4LEwbhaeOfIp/lx6Cgzh1ShyNJZrCcWVWPq8XAOhz2HlH1kCuz3f29wFOtyyv7bSpqhh37n6Tt0h4O9aj4YyvxMnUJ7y39g/6FjAsi/0tVbgvfxL+cuZrWd4JbdJj1DgaqyOBL2ffi5nxqbzTJEVRsNntvIOvlKwUgL+e2cf/X0lAxazwWDw4cioKoxNEwfQoymkhefLQxyI63mSiASTFjwBde16RszRxxv+fK25Ag7WTn9yl2okDx+ubfB9uMOKCl8CXJOjfnNSCQedOjsOrU4pE15JPD4wdcrywZspiftwEkrJG6CzNASI6s5LzwLocO81OLQDt4jwqN0dwHIeEhASRk/CeBgvqB+YLuXZq67Mi1RSJ5v4eUblQj1kRsbgyK1+1SyLio/9ynLF3DhyLyc8Ru+stmJucL9KBx+MlhsHX9c7sB3sbLJiTPlJxOymRiWVZxMfHg2VZ1VNsCGkLy4syx2LDnPs9pkIRyiSUS8g7oe1LOymVCdCcpS86QsVZmqIo1Efr0NDeithKB7Ii40BTlEdntGU5E3BteDI+O3sM2+tKnHx5ccKda0wSOeE2XGgB0grdnAbfaSvF82d3Y2lYBpaEZfDlUs7SZp0B8fHxIplmU/HoDoscsoCKXd3d2Hb6IJabM30O1FfJ9HgMPpjeyfIB5jbXnMG/usqQQoeJ6rvKdGVcOr5rq0UcbfQrQaknZ+lt3x3C6LGz0Nrayve9r04c5R185doJADbAqijp6kvZs7DrQiV+9d125A3I9N5AAt/J6Xmw6PsRbQNmCOh7kqnY0YFbo7LxSOZVKNBF4kBzFQ7ZWjy2EwkAV2EpxwpzptcgkWMM0RhjiOZlyszLxXtnj3jtexfO16KWNSMtPV2UdPW90bfgHzXH8Xl3NUyUDsvMmc5EoemjMCsqDQCw6buD2FpxCp32Pr6dbCY9/pQ/D2MiE/jnenOW/vzYQWytL+HpbOitRoYpCvMMibx1xM6xuJ/uwqtX3oKxXDhPw5vDaktLC++Eq1rS1awrEBkRAZqmFSVmBpQ7S6d2MkjTmXHc0c73PQLhHJHa4eCf4W0uJ+1ktduwwpyJx3Z+gC4TpbidfJGpvb3dL8diJUEiW1tb3d5PY2HElonLUW9woIl2IL7ThkxTNGgbhdLSUkVJVwltX9pJiUyas/Qww3B2lt5UVcw7c840JuKgrcUtcJunFfcvj32OP5zcBcCzs/SMAdrCM+QXJ9+CJybMFQVX+/R8Md6rOi65+5Zzlv540m24YdzVfFnUm8/AzrFDFlBxd30Z7zio9BqpHhSuNSZij63Jq7N0p62ftxB4k0kHCpnmGOQxJnxtaw5KQMWPJ92G68ZcCb1eD4qi8G7ZMd7BV0pWgmhjGNptvbJ6HxkxAr83jcX9rQdg9eAs3Q8G9+5+W5FMJHXDhln3YZIhFmlpaXCwLP5WcgC7myqx+Xyxx3byVk6cpWcbk7DP1syPnXhzOK7b+prXvkcSjK46sgl11g6+PCM8Bi9OuRUjTOForm9EQnIiZg4cIxOH4zt3viE6knC9fECcsb05SxN9C3mU6mPMQPl6QUJTTxah+vp6pKam8j4xaiVdXZQ5BvX19cjIyHDLKBCoReir2lL8fu8n2GNrlnWWpgFsE1xi8DSXC9uJzCd3t+5HLxjF7aTUIlRXV4e0tDQYDAZVLUIMw/C0iU+PJ+uJL1Yuh8PB06ZpWnOWvhww3JylhYHb9KCQoguDA+6B2yiKAihKMgFilbXDzUFOylma0BbWTQyP8uhXo9RZuqunWySrjqbRS2J2yNDx5Czta0DFhv4et2co4T1RZ+I/SdWPN4Vjdko+8j/8ncjx2ptM53s7MNWcqaqztLC8q6ebnyQAuDn4ytFZNXY2nv1uG7+oICDHTr+++iag+DzskA6oSMGZTPPfM29XLBNxsi7KHIvS0lLQNA2zwYAnJsxFcvm3+Pj8Ka86iNQb0T1wRVtKziiDCY/kTsLPszP4IH4MyyJdxtfH6STPISMiFhdsvbhdcLuQyFRlbcftu9/Chjn3Y2JkIgrTCsVBTQ99LOmMT3iUSjrqOhfYHQ7nv3C/xCDXxwDphKauDqsMw6Cnp8ftooUvSVdvzRqLv57dB0t3K/Ij4/Ho6Gth1OvBMAysVis4jgv4kogr73NS8/GuMQqwNcv2sThTOOalFXp1lnZtJ6JPDoP6VdJOSst7e3t5HtR0luY4jqctdMmQq+8L7zRN87RD3VlaNQ+o6upqPPjgg2qR0+AB3hwXAaczJ8Oy2Fh5Ejnrn8e8ra/h7t1vY97W15Cz/nlsrDyJrPBYv3mwdLZixc51ATsXE2dpgszwGJma/uGvZ/bBNvDSkEKqOUrV5xG8/v/Z++7wOKqr/XdmV6uysppl9V7cG7iBu2m2AWNjTEIJOOUHyZfwUUwKpAFfChCCKflISEjyURKqMdhU44ArxRWDu9Ulq9pWX0mr3Zn7+2N1RzO7M7uzu7PSrnzf5/EDuhqdPefcc+/eOfeUudfjszPVhgZfGwF3fdMAX61QZA6uA8kvpl2KDUvWItttfnKsSdiwZC1SY+LUCQyAAKiztQPgvH6ei0cL/jjrapSvvs8jU4VC77zxnPcg6yjehEnJmVgoC/ynwaSAZ4g2/fnxWStwz97NXtfgj/e/A9HN67GrudKrTVA97Wqu9Mr352eqvf4+GNpq0KOTJ2evhGkgI7D4zYdxz7538L/HP8U9+95B8ZsPY2P1Yb8/118eV+RO9PrM3+Zeryvw16h5YlDClZlbjlcqv8T2xnIIOmN4Qg3DDkKtra144YUXjCLH4AV6F+nvvvpY9bBCs4GiePWTvi/kxCXibyc/13jn1Af6BZsXn6wYLxo1Wv0PAsT9Bz5A7Ev346f73lX9/dwxBTD5+LL0BzlxiXhzILW60S1rzEjMSyvw63ktffvzBbe6YAqqr/8Fti37AV5edDO2LfsBqtb8HKsLpqCpt1sXHy193ZqfR9Ht7MeP973r9ctTzwFuTIwVnQ67V37O2XtQ293mMU4zILNile707LhEbFiyFmNirLrWoDttvTbh6zm9+g6EthaoTrQOw6sLpkgZgVp7zqYa5XWm0ZiQlI7XFt2CHHceZetSD4yaJ4ZBeHspH27ovhrbvHmz199XVo7sk3E4ZY012joV8Q4iCPb1n1NkvgDAU8d2asakmAC8ULYP6dFWnLP3aMZpAK5KvpQ2B+D20tl48KutAPTHY8jH6W/+OONqZKZkKHTQ5zAma0z++RyAJ47sAEcIfj/jSsU8fdpcCY7417qBB3CgvxXuWWP3T70Ev5x6GaLMZhBCkBFtVdDSIxOlrZU1BgDJMXFYOKYAe1oGAwG9xQhR3v8442pkJKeDEAIykMUlCIIig0TeNFfKIMmdOGjPhGBBWqFE3zTgfk+PjkMX9LXYWJheJH3e6YHrJzXbaxz48tyw8BYsTstVlPI38byUoQUMxhkRDGZofavwQvzp+G6vMUIEBO2xvCJDSoopEwmiOF5RS4sDAJEo1qBWgVJRhXZGjCvI2FcrlIxoqyJjxn2PSI+xKvQtl8lbdp8JnERbK04DcAWbAlB8LsdxWF0wBStyJqg2XXU4nYoMRI82PAB+sv8d7L30B+B53vCsMdryYVxyMq7JnxRUiw33eZLLIP/Z1zzpkUneqoLKYVSMkFqLDaNihPxpsUGbGMvXoRMEjTSjVaWJMRCGWWOrVq1ypb96ia3mDHyzHm6Ec9ZYcluflAFDM3dsRMBqlWwkreyJCeZETCYJWJxZjO3NFbqyxsbGJGFZ9jgIdhEFJqtfGVbyzB2aQTPBEY2EhAQ4HA4p02CsPQpJstYNRmSNUZnqKqtxIv4k0tPSpHk6W3da0qW/WWMtfXZFNtJcMRGVFRXSPKV3Crglvgi9gsPvtiHZQpx21lhfK/5z6mtFFpS3rDFHTBSeKlqMCY5otLS0oKWlxcP2aAZJk5VDc38Pktv6XBmIAxkkvjJC0joFdAFYFZuDszpabEzsd31edXcrHq/4Ap/0Nmpmjf37y10YP+lSqbUFzQiZjni8NuFqRSuUJrEPtySU4Ors8Yg2mdGoI2ssoddV2Vcu01unvsQbX+7GRXBl1NF5stideGPvdixOL8aa2FxV25PmydGK0bxFog0AE1NSkBOXiBJntGp2H21Zk94poKxLO3NnRlYWtuMkVsXmwIHBcY9WKBjcIzL4GKyIz5No+5M1Bgzue2fPnEFml4hMxAFdIjqi25Gamoptxw8pMhBV15MIHOpswqWjRwfdWkgrGyklJQXdXV0KHpvERt0ZVmrzRPeTfJMVx4VO3fPkj0xnz54NWdZYS0uLrtZC/rQNoXZN16XWPBWXlOA3+z7AdSrfT/kDe8SWL7/AeHsURsXHh3fWWHZ2Nv785z9j5cqVqr8/dOgQZsyY4XF6jHSEY9aYw+nEuI2PKoI5L4/OwDZ7s/Tmlxwdhxa7zaf35MUFNyKaN+OefZtQ29MhvZXnxCXiDzOvxujoWJxrbMbojHTMz3AFWe9sqsBlH/0toMaXZnDIjk3A+tkrsSJ3Ampra1FQUCA9l/rvX6FbcBiWNXZj62fohyg9/cjMK3HPpEXSPD19dKfUFsCfrLFLo9Pxkb0JDrgyj3KsSThx7U9hkgUlOpxO5L3+W6mAoh6ZKO2P7c1BZ43994T5WJE3UapPIwgCampqkJ+fL2WNGfVWbrfbsWXLFtw60GLDAd8tNgB92Ugx4PHW9NW4dPIMKehT/gYrtWro60ZmXALmpubDxPPY1liO5Vv/7jNr7O1p1+HyKTMGPbcch8I3fifVzXGfJxM46XqovqdDIascOdYkbL3wm8jPz1cEwtJsJDqfVNZAs8Z6ZeHLRmWN1dbWIi8vT/Fy62vfc89A1Gqx8eKkq3DdzAWGZ42JooiamhoUFRV5eAP83bPd5ykmxFljdF2GImuM0g5F1hil7S1rbFdLle4sTFqXK2yzxmbMmIEDBw5oHoR8eYsiHeGUNWaJipLaWQCuTS+Rj4ITRNoSfzRhHh449JHPDKtMawIWZ5ZILQncM8sEQUBZN0FpVokigyRrIKtGb3aYfLymtwPX7XgRby66FRMdFoWsdkIUGRpGZI3Js1x2t9Tg3imDV5Nj4kYFlDU2io8CgctV7gDByvzJ+OxsjauYHSHY1VyJjxvK0NxvU9DQI9OogbmUj8eaohRVc71ljdHKyu7xEIQQOJ1ORdaY0Zk7P5w4D48d3wmQQd5NHId1kxZhddFUAMr10WS3SbJ4k6m7zzM7RZ5Zotaq4Ux/j9eWHIBrPnrsStrbG8tRpxH/Q2Wq7mnHQ9OvwIOHPgIH5fxJAdUzV8DZ7/Tge3XBFLy65FaPjEv3ViRyKLK6Bg5+APCTqZfg2bIvUN87eGhLiY4DCBQVzL3RVssa6+/v9ztLSW8G4iguKiRZY4Dry5kQ4qFzX7yrjcvn6VyPKyaLwHXA1TNP/ozTdakmE0WgWWOUdiiyxihtb1lj9bYOXfteQ2+XB49h12LjJz/5icL15I6SkhJs27ZNLzmGICFvZ9Eke3Oli3Rl3iQ8d2qP7nL/tMWFHhjVquOHX7yJTy64QTGWF5eIk91nNf4ieMSblS083AM//QXPcRAIwZPHduHJY7swWuVLyAj4ah0AAL+cdhkuzSwZ1pL4Tx/b7XGgEQjBH49sx0Vj8j2+PPRmf9FsN0EUVQ/sagiU9ps1+oI3SxPHqLaUyXFL+1fD6oIpWJk3SbcsFLRkxbmebrySMhe///pjjI6Lx0PTr0Bp4hiJDgC/aQcLPS1G1AL2wxl0nnY2lKHzwAm8d/l3sVAl/Z5BG2f69AX2630uFNB9EFqwYIHX31utVixatChohhj0Q1qkjeU4V1uP2/OWSXU8AHjtJwMMZgMF+tlqXwK51iQ8PmsF6rrbcO9+9UwtinP2HlR3t2KcbKxgVHJID0K3lMxQ/Ew370DT3N2beZ6zD20fMTkmJqXrPswaDZoG6+1QHGh/LvrluanmKO7at0l56NDwflHavnq7jY6O06TtC5mxo1zeVI0Dja8wAX9ePgBlj7ZYDL4l1/d04MFDH2HDkrUKekNtC756WAHAH2euAN/v+smfQ+1wwsTzmJ9ehPdxAvPDlMdwxpjYeN8P+fFcKMAKKkY4TDyPxVmlsCVmwWq1Ku70tQ4r3ly77uB5Hjk5OZquY7UvAQD49q5XfdIWQHBQ7MRyGe0THS0+/y5QxJstuDSzVDEm37z1erYEEGy3t2he5fiLON6MHtGpSTshKtpnGjjg2wPibS6Dha+6NvK6K/IvaF1fnrNW4ER/L67f8TKU0QeDadnu3eA9iGhAAMFRzoYbdrzqQVsLer2pRupbT9NTtYNmIAiGb197zrX5k2Gz2bCp9iju2qv/UOsv35FyyAJCuy7DgXZGrHZsTiDPhQLsIKQT4ZQ+rxY0aLVaVQPprs2fjKuzx3s0YKTBs7545zgO8fHxUlCfnBeOcwW3ytOpN9UcwV17N6GpR5nirxWwajcRSS8A0BOC9HkahPvCvBsAlTRSmj7+319sRIO9W1cA+Flx8GCi1WLDWwqzHN8ovAAvVuyTeD8r2mGSpaD//eLr8dP976K+pwMiPIOlOQBZ1kSp2aa3QMjY2FhJfiODpZtsXYiD7/T5xt4uDx61GgFnWxNdQfU5EzD2zUek8gJqadk/3rsZ1+ROhNlkcq1VUcSfT3yKDnuvdMBSm6dz9h7cefBdiba3eaJlJ3hweHLmNaq2REHXU1xcnK4AV18BqzsbyxVrSp7GTccabR3Y2VSBxZklQbc5UFvzeve9lbkTXXvOmWo09XUjI9qKeWmFUrPZj85UYs32F2FyS/1voIdaWUA31QGgr3VDXFwc3qo5grv3vK0Ids+OS8T6OSuxKm+S7mBpOh7qpqsApHVpdNNV+ZoP1Pa8yURpe5MVOvdyIgqK9QSEYfr8+YZwTp/3SE8sLsbx48cVAXHuKZeZADIRB6sYCxPPa6bGustEI+6jo6PR29urkMk95fJ4ezPuOLkVjWIfrovJ0Uyfl3gHh4tJEnp7e1FbWwsAWBObixaTzdD0+cut2bg97wJM6LegrKxMdZ6+rjyGGKdrIflKn+fBYZx5FJ7qPoVO4tBMy9ZqUOou02VZJSgwxeFkXTU4AOPMo7DD3oIdjjN4sGQhpjhisD5/AV6v/gqVzm7sVSlzcP3Ei2DiedTV1Wmmxvb19aGtrQ3JycnIy8szxPZoum9SRx/6AayMzcE5jfT5JqEPmbGjVNN9VxdMwayoFHxccRht/X1ItsRg6bgLkJmeji1f78N3TDk4GZsIEUQzLXtH7QlcWjgJm/d/ig9Pn0Cno89n09UELgr/ZSnASb4LIojPMgezrBn4Se5MxJ3rxlvNO5EQPwqXTroQbSoypaWl4dChQ4iNjZXWZaApzGfrGhT8b+tzeU5XxubAKfNlNfV0ob+/P6jGl7GxsbDb7UhMTJTSmKlM/ux7F2RkICmrFJWVlagcaNApCAK2H98DEzjVEhs9xCmlUtOq4HrT50VRxMmm07ihZityTXEKfTU5+1yHrFnfwETzoOchHJquiqKItrY2pKamYty4cYamz7e1tUlrPk1WNsSI9PmTJ09KtHme15ynFrNN117eXteIesKaroYlwjF9Xu2Ue+rUKRQXF0uHrGDfIihEUURFRQWKi4tBgEHPUtwoKS2bpjCP2/iooiCfHGpelfRoK7ZM/wbGjR0rXeld/v5fsOtsjWHp8wkzxmN+RrGi1YK7rNd/8iLeOX3Mr/T51bE5eKO3zmvTVb0eoV9Mvwy/PbQV3MAb8urYHGzsPQ37QPr86wNvyJtqjnqUOaBFD2mTXW9vRk6nE+Xl5SgpKZFSUo3yCPX29WHrRx+pNl0FXB6MbGsSytfc7/E2TVOV3T1CWXEJeGLOKtj7+/HuwU+xsfc0nCCa8/TiwhsRbYryaGjqK33++thcibav+RsdFQszzytiwTLiEvDUQIKCXCZCiOa69PetfFv9Kak5MABYwOPllLm4ZSB9nuKjpbcH7RGSr3m5NzuYt3I6vqOhDM99+hE29NbBHfJ5+uiK27Awo1iiQ/nyJlO/w4F73nsR/+gsU226KoAgz5qEU9f+TLomC4emq4IgSOvSYrEY6hGSr3mz2WyoR8jhcEi0aWq+mqwjKn3+fEc4pc+7j9MqsWq0A0m5VMM7dce9BqruaqlCdU+79Ds9KehPX7Qapn5eweMZZ6+h6fPz04vA87xqHBPP8+jt78dbp5Vl//XwLmIwnkUrLVvv+JNHd2GwzayLtnPgS0HEYKPM1UVTNcscUHibV7pZmUwmw9Pno8yurURewoHOh5ROPvsaBa80jmNT7VE8eWyXB926gauSh6ZdLunEWzp8Wmw8vr3rNa8NTd1BdexOW2v+zjl6PcbqezqwZvuLHnFK3talv+tvYWYJEqNjpQMY9VfK+R490OjX3/Rrb3uEEXuHfLxZdoD0ts6a7DZd+6Sc9y+aKtDh6AOgvUfU2Nrx2dkaj5gud96HuumqXNdGps/L17w8JEPreX95p7S9pc8vSC/S1cR44cAhSM5L2KXPqyEhIQGHDh1CUVFRMGQYwhzH25txw/F3Pb5g6ns6cN22F/DQ9KU4Yzcm9THREhs0DQ6QmoA++vUn+Gv5Xs0D3E/2vxP05wULunmrwT3I2N9Mo6HGSwtvwl37N/sMzqdp4L76dXEA/lm2D5ebx2jGPdPgZYAblia3Rgcre/2gCIYgimiW1TvyhkCaIevtv6anP5g/TVfDeT2GA/QkRASTwWwEgjoIsVu18ADP8ygsLPQrM0BvVgUB8POaTzXfpgHggUNb/OaZA3DP/s04vuJeBd9X5YzDpy3VftNz5+tsXw8QB/z+608UVweAMtOorOuc3/QFEHzQ12hY1pge2h83lAWd+RKInfiLFXkTsbJwilfbkqeB+wIBUNPTjoIpsyEcLvO6kbYEUIfEqLlU+2I0Ut+7mit91qY6Z+8x5Is5FHZCD771PR1I4KI09e2ekecPMuJG6ZpLPYesoWy6Gsp1GS60jchgDiXY1dgIgdmsfyrV3sa1Uld3NVeivKfN8K98AqDW1o49rXVYnDWY0k5EH/nOBn024HqDvypnQkB/byNajv1BXJJRgk+ayn08pY/2b7/+GM+X7w8qvRjwz04ChTevlbc0cC0QAIVJqXhj8a2eKdeyjXR7o3+6prT1zKVeuH8xUn33O53484lPUdHdiuL4FPxw/DxY/JgLvV+4HzeWG5IqbqSduB98tfQdrHdgQXoRkmOt6JRd0bvT13vI0uuRCsRzpYZQrstwoR1oEdGhQFAcfOtb3/IagMQwNBBFEWVlZbpSBemm5O72PT1wzbX8o+fw5JEd6He66to09XRhTWyuR6CpETCDw8df7sNTss/7V8X+IOj5Z851tnZck+ffQeia3Im4pfBCXTqxBrABmcFp0qaerI3V+iofu8MfO9GCIIrY3liOVyq/xPbGcqmQol74unJQgxkcktv6sDJvEqqv/wW2LfsBXl50M7Yt+wGq1vxcOhjS4ozertDGxFg9aBtp32ky+lTf9+17F3H/uh/37HsH/3v8U9yz7x3E/et+/HSf94Kjcuj9wv3tV/9BwRu/C9hGAGPshML94OtN3znWJO16UDrAAVifvwBmcB7U/T1k6bGl3AA9V+4wUt/hTpu+JN1YdIF01R8OCIqLv/zlL0hNTfX9IENYQM/b+If1J3HPvncQ+9J9+PHed3Tf6QeKiu5z+Mn+96QvhtogYjycukviDaK1rxcrcyd5fWaU2YJVuRPRdeNvsemy7+peNI09wbvN5ZB7suQHkGAPJ3qxsfowCt74HZZ8+Cxu2vFvLPnwWb+/dP29SpBXlga8b6Q0FoH+nTsdAPjzRat9fsHlxCUiOzYhwKOR8q+21p/C+qM7PSqQC4TgsSPbdR+GfH0xyxHsgdlI6D34PjFrheJQGygmJKXj1UW3eLTOybEm4fXFtyAlOlbXOtFjS8Md18JgHNjV2HkEf97GRQCPH90hvcEFgmjOBDvx3maAgn4xWPihNckzfd24tWQmNtUd1Xymy9mPt+uOYfzbf8DTF12LnPhEVMB3G5BMawLQWm8kux6xKBurD+POL95SNN3Mjk3A0xdda8i9u6/MLineauEtUM8tUcKfqwT6hSNvy+ALemIReI6XAjfVPo9+AQbSS08ep9TvdOLzM97rmKw/ugO/vWCZz2sy94BTbxiy4G0d0HvwTY9LMIzPlfmTPLIrz/TZcM/ezX5VspbbEm26CoRPXAuDcWAHIZ0I58rSwEAtH5VK0fLaE422Ts2qvwSeFYuBQZehuytbT80dgYjS79Vqucir5NL/F0UhZJWl1XgfbYnFvXs2wQzOp0zNvV345rYX8aspl4CHsrqvOy8cgMVpRfig7oTHuDeZkqNiwA/Q9DZPjT2d2Fj5Nb654yUAGKi47Po7yudri27BtYVTpBohgiBI/9Vje5tqjuLefa4vD1+8/+LA+3gkeiIEQZDSatXqnixIL0JeXCIaezqlA4aW7UmVpbPHo6ysTOLVV90TqbKxrObVgvQicHCtP1pJ/K59m9Dc0ynpm9ZkWl0wBYQQbFh0qyS/+zxpzV9GtFVKm//rqc8BKOtMedgYAf58fDfumrzIZy0Xyve9+zajZcDbKK8sTXmh89Ro68DOxnIszCj2u46Q/L/uz/uz72XGjlJd8+7/nxFtlf7W3xpW8irElAbPcVLF+001R3Hzjn/B4TZ/zT2drnWy5FbNitOr8ibh6uzx2N1Yjq4vT+Hdy74jVZaWr51g6wjR/xpdWVpO2+jK0nLa/syTXpnoZ1A+Aq1hpQfsIKSBSKosXVpaiuzsbFRUVEj1YdSqkSZ39WG+ZYxHFWYAqHB2Y59KxeIjjg5s6K3DfMsYZJhipHHV6r7wrMJMoVXd9+3e04jzowqzt8rSs2PSUMC5eJTHC6nJdMTZgfmWMRCaWnERSQBiE3TLVF1VjVhTFOI4s2bF4pzoUVhqTsfJhFJ0Ovp8ylRosmKWZTQWpxdjZ3MlLrKkep2nlD7gtWOfSp8tl4nO07sHPsXipBykpKSguroadrurLUhFRQVyc3O92t7mfbvxRvVXuAgu3Xirlp3Gx2CmOEqiHRsb67US7hOTluKNI194yETnqWRUKopHpUiVpWnVcWrfeivh0mrqhaPzwAGK9TQRFpxa9VM8d/xTCGc6cbllLGaNyUOU07Ul2mw2TOy34L2p16G2uw2dxIE7yj9BghOYpVHVfG5cOtI7BZR1lSExMREV3W2octqwKjZH1fboPJHmdnTkduiSaSJcPL3ZUQk0Oz0qS7vP07naelTY4Fdl6bi4OJSWlqK1tRXnzg1mVQay7y1IL8I3RhVCHIgBBIDd9jNwgkjV5xOiYpDeKaA/tT+gquZUJkIILBYLeJ6XZBIJwZZjX2Cexr5X6ezG3Xs3YY5lNLo6B72q7jKlCyK6AEyNTYWJ51FZWelXFWZvMtEv8Orqar/mSU9l6fb2dgCutTNmzBhDK0tXDFQLp+tS7zzpkYlVlg4zREJlaVqJ02w2SwchtRN3v9OJ5Fd+BTsRdXuECAjiuSj0uGV66K3C7G2cAxDHmdFFHKpv2f56hC5JK8bOlkoAg5Vgb2z9DP0QVT1CBdZk/Hb6Unz709f8kokD8MCkS/Hro/9Rfd4JgjcX34qVeZPw8wPvY/3RnT5lyrMm4YmZ1+CqnPGY8dbjKOtpRb+GrJnWRDx38XW4+j//9JDJnZcPrvh/uCx7HETR1TfK4XAgKipKKqqoZnuCKKJ0w8OKawRf1bLjYcZLKRdj6dKl0peRt7e9t6uPSN4WansWjocoWze0svTK3Ino7+9XVJgNtDcSxaaao7hz3yY09nQgmbOgkziQFZeI9bOuweqiqaq8v117FN/Y9gJ4cIq1IAzM0+uyHlkcx+HpozvxmwMfoYsMVuBSm6fHZl6lyyMkx46GMnQdPOlRWdp9nmiFZn/eygHA6XR6ZAQF+la+sfJr3DDguQQAK2dGB3FIOqAVmv3d99xlIoTA4XAgJiZGen5nU4VUkdubh/WTK76PhRmDgc/uMjkcDmzZsgXLly+HxWIJyvbcxyn9qKgomM1mQz1C8jXP87zhHiFKm36mnnnSI9NQV5b2+1LWZDKhpcWzQ/i5c+c0K1COBNAKl+4VOvWM08OJOx15dV/3cXlFWl/joiiiurpa8TvKi3xsT2sd7GTA7Y3BqrTyasCCbMy1qXJYHpMpVVOl/6jpOt2eJ36MEwDLYzLBD1wDyf8B8PhMOu7OOx3/sq3eY0xNJhGuw8zjs69B9qgkv2UiAFJsTryx6FZkxyYons2IS8CbS9ZideFUgOPwctUhrzJFm6Pwx1krULb6PqwumgqzyYTf5M8FjfOQyyoM/Hty9krsPlOjaz52NFdJNslxHGpqaiQ70rK93QNVwvXOh7wKs5btua+P1UVTUX79z7F12ffx3xPnAwD6iaigTStLb6o5KvEtXzda68zXutlUdwzX7XgR9T0d4MHh8pgM0HpF1+14ERurD6vyvrpgCl5fshbpcco5z7Em4fUla7G6aKri+e+PvRhL3daO+zwRDvjhhPl+yzR34NrH3bbpfAggyLQmYmFmiUfFYm97BH2WvtUbse+tLpqKV5fcivS4BBAAy2IyYQKHDGsiXl1yq6Q3f/c9d96pfYuiKI032W1e9w667zXZu33KRD8vGNtTG5evS3/mSc98yGn7mid/ZZLT9mee9Mok/+xAbU9v/SS/r8a0HEh2ux0Wi8VfcgxDCCOKf2nh4jH5PgNDQ402LxWa5ciVBTsKoogcjfLvXkGIalCmvC6GnuB0m7MfP973Dp48uhNPDXg/aOaLR0sTGd9fnjvtheogarpaIYiiX4GogWR25VgTfT7nDhPPY0F6EW7Z+Yrq7+lh8Mf738G7U1b7TV8Ngihi7a5XvT7z7d2vagYZ+1MLxWI24+Ix+Xhj4GpPDesmLfKrnhCF/PPcA7rDMauJ6m1nYznO1dbj9rxlrkNaiPlLcyuXEOxzDCMTulfg008/DcB1gvv73/8uxcsALhfZzp07MX78eOM5ZDAMRhX/UoPVHBmH4F9OvRQPXrAUALC9sRyNvV24bewcPHjoI78yhPJHpQDwXjyw3o9SAFL21aJbMREWzUMW5VtvgvxLlQexralCOmTpQSCZXY/MuAo4Uq377yj0tjKo7W7DOL+pe+KThjJ0O+1en+ly2LH+6A6sm7RI9YvanzYnl2ePxbpRHB4/pkyhN3Ec1k1ahD/Muto/Adygt6VJOMDE81iYUYyyLhGlGcVDdEjTWwQhsGIJDCMDug9CTzzxBACXR+jZZ5+VXF6AK/CpoKAAzz77rPEcMuiCHhcgrUXir/fDQXx/7QZ6ENJD20hcmlWKTbVHPdKrR1viAA6KruJa4MGhcNRon8+d0dn7CFB6Pz6YtgaA5xeunv5capAfsibzMT6f98dO6JfuiuzxeD+Ag5Be71OX4Ari1NsaRgsvVRzwGFOzwZ/ufw9PHd0VdBkCnufx+xlX4jcXLg+qsrQW9LQ0CZTvUGEoaettuxJIexYjMVL07QvBrt9QQfdKpHfGS5YswcaNG5GcnBwyphj8g8lkwtixYzV/Lzc+f70fThC82ef7GmZBRqHXWjzB0NaLhKgYdDn6VOVyXd8k4UyfDd/c/pLHM639PSAAvl08C89X7PP6Of0Q0ZxoxgST95i4MTHxXn/vDgKgytaGxgQTxrnR9qc/lxpdDq4u9lVrfu5z4/HVJJEAuHviAqzMmyRtZA6HIwDO9HmfnCD42tKH419/jOdO7fGrFow7upz9ip+92WB9byeu2/aCK+YrgMOQfF2aANw9eZHfNHR9jh8eKl30fOwnkUR7qFtlBIKRpG9v8Ke101DD76PYtm3b2CEozEAIQXd3t2r8lns14AcOfYQUSxxSouMUz+XEJeKh6Vfg51MvUYxzADL4GJ+l5v97/HyMdqPpC75o+4tvl8yU6Lp/DgCsn7UC6/ZuVj1M0MPC5tO+D3McgKb2Vp9Nh7MDiJtRox1Ify53EACnbe3YXnNcV7NkWkxOrULvm0vW4ok5K6XKzoIoYnezK1tvd3OlX5Wt9VRM5gD8/fBuPHjoIw9vmL9VlBekFXjQ9mWDt3/2RkDVur2ty3BGKPkeatpD2SojUISbvvVWqveHtlZrp3Cpgh6Qb/b06dPYvHkzamtrFXUHAGD9+vWGMMagH6Io4vTp0ygtLVVcWWp5Eaj346HpS1GamKpwUQqiiL+e/EK6IjKBw+LoNGzorfPoQC8PyrSYzfjb3Otx3bYXdPPtjXYguCZvIhZlFGtWgk2JjvUZj9Kq42rMBA5J3U6IoqjQtzvoJuzPVZYa7UD6c2nRbmtqgZg33ivfFHoCg+lb3rmebrySMhdXbf0nRsfF637L8+Z9kvOtZSeSt0tnFeX/GjcX9+4fbGuhxwbP2Xuwvakcl2b592attS7DHaHke6hog+N8esGHOqhc61oonPTtj9dGL21vL3L+rt9Qwe+D0Mcff4xrrrkGRUVFOHHiBCZPnozq6moQQnDhhReGgkeGAKDH+P5etsfjqsTE8/hu6Ww8dmS7z89wD8pcXTAFb6q0Nxg6cIPZKQ1l6DxwAu9d/l0szCqFiefxSuWXuqikWOLQNnBY9PwEZe8rb5B/yQO+ryK1aBuZ7RdvjvbreW/XLvKDdqyswYYUk6TzSkmrLYZe0IBq2nbEG/ac087g8obtTZV+H4QYhgebao56ZFyqxQAOZVC5twOG3iSGUEPrxdnf9ewOvQkRetZvqOD38ev+++/Hj3/8Yxw+fBgxMTF48803UVdXh0WLFuH6668PBY8MAcAf45NDEEWfB4aU6Dj8Z+n3VZskri6Ygurrf4H/LL0dKRb/rsqCBQ14NPE85g+4uufLPBh64wDuGqhro3XF9seZK8Bz3i5TBqF1xeQOb7T18p0abfV5BaDnAKcHvg7agGdzWG+gdrNt2Q/wy6mXBsSTngNjwIfKCLveOl9xvL0ZN+x4yWPva+3vwTl7Dx6avhQvL7oZ25b9wJAmr3rg61poU41/sZWhgNHrWQ69ay6U5V18we+D0PHjx3HrrbcCAMxmM3p7exEfH4//+Z//waOPPmo4gwzeIQxUTz3c1YKdTRWSoQZqfGoHqA5RGQjbau+BieM03ZgmnoeJ49Ha7/uayZ12MGju6fS6UPXGC/xi2mWa8TEblqzFqoLJsFgsikKZcrjfsa/MmyR9yb+86GY8NH0psmMTdNPWy/efL14t/ez+e8B1yIqJjtbk2x8EetD2Bup9mpic4fE7PXai58CoVi9GD+1A3lQ5jvNqJ+GKUPIdStoiIdhw+qhPL/g3CqZJ8W2hhp4Dxr3735GqJxsNvfoOZD3rpR0JAet+X41ZrVYpLigzMxMVFRWYNMlVVl7e72SkIRybrtKmmNU97a6y+kc45MQl4vFZ1yAj2rXh+9Mkkud5NPZ0ejSJ/MDe6NHcsbGnU+JFrbR5fVe74nmt1hsf2BvBqYwH0mLj3n3v4Kmju/D4rGtwpewaQ87jU7NW4hs7XoToRpsbkPXJ2SvBAcrGnX3dyIxLwNzUfJgGysLn5+eD4ziPEvHULV/f0yHRp3Mib91w3+TFUlPQTGsC5qcVumIYBmjLeQcheGrWStyw4yWpSjFthSLFOcy6BqsLp8JEOEWjUBEE2dYkPDnzGqn9AyEEhJCgbE/ewFc+f9RO6Dw12jr9XjcZ0VZFE1wA2GpvkuirtanItSZhPq227EUmIg42QaWVheW06bjc9kZHx2HhAG1/2xwUFBQoGiIb1fiSPiPfT9TmicJk8q/NQVFRkaKhph5Z9cpUWFhoSGshd5l2N1fi9a4qr3tEva1dakTrj0yUV3ljWD3ztHPggOFtfztta0dtjICCAXpGttig+wn9W615auzt0tUWqdHWKf2tnLbcDt3naUF6EXLjEtEka7RMdcAP6CDHmoS5qfkKHoEwbrp60UUXYffu3ZgwYQKuvPJK3HvvvTh8+DA2btyIiy66yF9yYYtwb7p6vL0Zb1R/hRkkHrVox8yoFBSb40EI8Mbe7bgwLQ+p0VYkOKHaoFStSWRmZiZS7VA0ET3q6ICNOJFvsiJd1nQ1jbj6pWk16utvPqego9Z0lQOwv78VZ0U7lhrQdHWiORGTSQLe2LsdXF6r5O6Uz9NEWPD6rG/grqNbUOKMlhpfJkTFYOmEC7G6YIqioWImgFk5YxEfH49Tp05JC85ut2P8+PGIioqS5onOSVNvJxK4qMEGpQR4ec8nAM/hitRCqflgJoB8SxKKMovQ3t6OpqYmiXZKSgry8vKkhooTYcFrE67Gc3WH8EF3ndSgNCEqBsuyx2HBqCwAwKyoZKlRaLfTjuQxqVhcNAk11dU4deoU7HY7oqOjfTZd9dX4MrnL1YSWztNl0S4vzsrYHJwT7dI8Jbf1oczpoqWnSWRHRwfSCcF3E0rxWU8zjjg7sMAyBuPNCWgn/SBQb/g7d3QB+ga8095kam9rlGxwQ28dRnFm3BCbL9FWs71vFExDXW2t340vMzIyUFlZCYfDIb01+2oSqbfxZU6Oq5GrfD9RmyfA/8aXcXFxSEhIgMPhCLrpqrtMhBAkJSUhIyMj6GbT7jKda23EjbF5+Hdvjdc94lxtPcq6RL9kot8DnZ2dSE1N1T1PTXw3zOBUGzPT5rgcgHMVtX43x9XbdJWueW9NVzNjR+lqoJ3c1of+fldzXPl+wnHem64+Of0qvPHlbmncfS//Rt40VFZURE7T1crKSnR3d2Pq1Kmw2Wy499578dlnn6G0tBTr169XvM2OBIRj01WH04lxGx9VuDLXxObi7d7TiswXrTcjrSaRPM/D4XRi7JuPSMX0eACrZbRpPZ5T190Hs8mkeRL/d9l+fHv3a4rPdH+7MIPDqtgcvNlb5+E6DsQjJB8vsabgkeiJuPLKK6U3RwqOczXN3NlYjqbebmTExmNeWiGiBprW+nrbEwQB5eXlGDt2LEwDOhBEUZoTNd45ABnWRFRed7+Cc/e3PUq7tLQUUVFRHryIhODTM9Vo7OlERoyLb5OXNyb5m5HT6UR5eTlKSkokV3ygb+VU3pqedgCDTVdpE1ABBLnWJJRd+zPpCsKfdbOp5qjkuYsGj9WxOdg4YINaHiFqk95kcm/CGQUO18fmSrTpOAcgPy4Jj89yedICeSsnhODUqVMoLi5W9FwywiMkCAI++OADxX7ibf788QiJooiKigoUFxcrvE1GeIQEQUBFRYVq/ZlgPUI7Gsrwj08/wuu9dRBBNPeI/1xxu98eoUCbru5srsQlW/7q1SNkBoeNk1bi0umzYLFYDPUIyde82WzWnCeREBS/8Xs0yIqoyvdsuu+fuPaniBooBOpwOCTa8r5favO0seprfHP7S4px+Z792kDjXcr7UDdd9dsjVFQ0WG/BarWeN9Wk5Q3kKLSqanqrtqlGRyv1UGv8s7M1qB74AgKULn33FGARrusROXK9ZEtEmc14fM5KKdMJMtq0QeEfZ18D8wBvWrJmxyeppiOrjRE/x9Vkch+vsbUDAwlSWjwuyVbPAtJ6Xj4fdKHRpoG7BhqVeuO9ztaO3S1VqvEmlA6l7d58UOIB3uNVvNkk3azcGyr6klVt3GQyKexEfoigdvLE7JWwyL6k9fBIsbpoKl7nXZlkTT2dimaZFPL/r7K1Sbr1xvvCzBJkxCVI7U8I4EF7dHQcXlv8LSzO8Iwjkc+TL5nolbMRe4f739MvGzXaas97492bTHpl9WfcX9vzVo1Yzvv8jGL8y+SyN609Ijk6TrXHmS/eqb59NfN0531hRrFmlXYCSC8M+aNSPBqUusMf26Pj8jWvtacArpYv62XrWc6rfN+Xr2c5bTlfavN3195Nmns5AcHd+zdjZcFkDx7daQdre1oIOFqsv78fp0+fRm1treIfQ+gRSFPMMTFW/GvhjbqyJbwV09ObQkkDfM8XREJmhNEwwk580a++/he4f8oSXc/r0S0taQCoB5VzAP4293pcmjU2LEr/n+9wLwi75MNnUfDG74a9AJ9e+LI3wL8s1FAiVOs5FIkVRsNvj9CpU6fwve99D5999pliXCv4ksF4qEXXNwnandcJgDN9NmTHJerOfpF3iz7T1ILbM/zrFi2voePt7tWd71iTGb2CU9dn6IXR/W04joPValVkSxiVGaFG2yiEgra3uk1GwMTzWJJZgl0nj/h8Vu8cyOsWNfV0SjZodF2ZUM5lKBEuNuhvXZtPW6pQ1e/9MHzO3jPk9Wq06mRRe1uVNwn19fVes1AD3b/8nUs9RVT9pR0JL4l+H4S+853vwGw2491330VmZmbELfKRAPemmE4QbO9v8fl3ckPTs7hMPO+6PtK4QvIFX4Xy1PieMToHu1uqA/o8NbxTe8yzO3eQ/W14nkdurjL40VejUnrH7quUvxptIyDNt6MLmc12Q5sd0rpN7+OEom5TwDy62eTCzBKUm+0Q+rWP1GNirKi3dWB7Y7ku2dw3/AdC0AAyVHMZaoSSb720A6lG3GS3+b0PDhV8HTC0dLKx+jDu/OIt1Pd2SmPZsQm6mwEHMpd6e9fppT0i0+cPHTqEAwcOYPz48aHgh0EH3NsScAAmmhNxzNkB0cvfUUNTq3KaHZuA28dd7NFyQxRFtLa2IiUlRfd9qxxqG8DZPhvu3rMJjb2dEt9ZA4eTxw9v9/szvOGWnS+jB0ovpdYbpd43LzWd+GpUCugr5R+svtVA57uhp8ND36EoKBfIG6y3yrur8ibhqUlL8Y19rw/EFHjiTJ8N39r1iuLvfMlm4nksTC/yqu9g3sZDMZdDgVDyrZd2INWIM2LiMdmPfXCooXXA0NLJxurDqi2L/GkGHA5zadRLYijh90Fo4sSJI7peUKTA3b0/OSoRJ5ydqgGCckPTdDf3duKBQ1ukn+Xl38+ePRtUo121DeDa/CnY2ViOc7X1GJ2XLV27/fbQRwF/jhr0vlH602OHEKKqE18ucD2HDi3agUI+32Zwkp0EWzZfC1oeuCdmX4PUGKvqgcLnFciiWzHRnIDXF93q0TpBDf7I5k3fwXbLNnouhwqh5Fsv7UCuU+aNKcDcuHSc7PS9D4YT1HQiiCJu//QNr393+2dv+OzPFQ5zadRLYiih6yDU2Tnolnv00Ufx05/+FL///e8xZcoUReomAK8pagzGQh7H8/Xx49hQV6f57JOzVwKA7i7mii8hWAzieBAmnsfCjGKUdYkozSiWFkEMH1AfYL8hf6NstffqjkWglbzPtTWisYn3iJvy547dKGh5LYaj2aGaB+50Tweud0udlQ7aeZN88njHno14Kn8hUvNzUHHd/fjsTDXqezpwz57NOGO3qf4dgpQt2L5LvuyEwTsCuU4x8TyWZY/D/3WWhe0Xrju07GR7UznO+ajMH2gz4OGAES+JoYSub52kpCRFLBAhBJdequwHxIKlhwf0QJHZJaIhgcfjx3ZCkNVTMHEc1k1ahNUFU7C9sVx3U0v6JfTj/e/g3SmrQ8O8CuKijD90eUN9Twfu2/++rsPCptqjkgduTWwuNpx4HxlxCR4eAr137EbAm9ciJTp2yJod0tYmeouS0QPFg9OX+uTxTJ8NG2uPYMPJDyR9Z8clqh6C5AhUtmAPkHROfNkJgzYCvU6ZkJSOVxfd4uE5DJcvXDm82cmXrfW6aERSM+DheEnUC10HoW3btoWaD4YgwHEcjtnbsf7oTqnmA4VICP54ZDsuGpMPu+hfNhYBUGtrRz3pxfgQZZAkJiYqDtljYuMN/xxvONPbreuw8LuvPsaDh7aAwFUErcLZDYLgOzO7Q00nWvDltbhr4gIPWSjfchgRPPr5mWq/nqcHiqeO79L1rLu+/3vCfF2fU2/zfvBX03cw3bLlcxJKOwkl5DoJRcalHvsO5DqF0l6Vno6VBZPD8guXwpedXJc/VR8hH/WQ/dlP/EUgtIfyJdEf6DoILVq0CICrkuSyZcvw7LPPorS0NKSMMegHAXDXia2aRQnpG+z/zf+G37QFEJyN4UIS7MnzPDIzMxVjJm5oNiv6RjkmRt/B66ljOxUVV/c5WhW0fF3D6P1CUdOJFj1fXot/Vx5U/o0b3xRGBI829XYjzs+/IXA18PUFNX2/UL5f12ec6ev2+ns1fQea7us+J4HYSTiA6iTYGClvtPXA3+sUd9rh+IUL6LOT7U0Vumj5ktEfffuLUNIeavgVkBEVFYWvv/46VLwwBIidjRXIdJjQCM7DIwQMvsECnFd3sxpM4JDaN9iwz0iIoojm5makp6dLtHOtoQ8slb9RpkTH6vqb1v5e6f9N4HBhVDIOOtqkMvTermH8+UJR04ka9HgtzvTZMCbairN2m/TmKefbyODRjNh4dPp+TBUplji09fdo2qSavjsc2nWz5Bgd7f14pqbvQNN93efEXzsZamgdzkVRxNuH9+KbB9/0eLkK1rOl174p/LlO8Zf2cEGPnZy125AQFY1Oh12TzujoOCweaBWihVDqJFL0rQd+c/+tb30L//jHP0LBC0OAaOrtQrE53qNyqTta+ro1q5yqgQOQZ01CNher6ONiFAgh6OjoUNBOjfHXr+A/5JVSaSyClj44eH6ZcoCqvj9uLJdiZSioC9z90HJ64AvFvUKumk7UoNdrcXPxhRLPcr6NDh6dPTov4L+9a6LrmsvbHOixbzWc8+FxUtO3HpvIVTlAus+JFt/0OUEUsb2xHK9UfontKrYTSmysPoz813+rqNic//pvsbH6MJyCgC3l6i+88kD0QPjVa99y0OuUG4sukA6QanoLhHYooTW/eu3ku6WzvdL/29zrfa7dUOok3PQdDPxO0XE6nfjnP/+J//znP5gxY4bUVZ1i/fr1hjHHoA8ZOuNqMmNHYXFmidcihxSK8u/9Q1c0MyPENT5+PuUS/M+Fy6QNRE8swp0T5uMBHWn9v/3qP3i+bJ/k6fF2fYWBzwr0qkSv12Jl3iQsSC+SgjIpjA4e3XvO//Y61CP1i2mXYXJypk+bDASBxJwFmu7rjycpFNdOeuGrPs3/TLscnV48bsPp2fKmt5W5E6Uxo2ObjOQzkLXry06GW95Ih98HoSNHjuDCC11vmadOnVL8jlWZHh7MSyvEq1Ex4HrVf+9+BeLubi7rOIPnTu1RvYdfmTsRZWVlQyCFC+59bozG5dmePaR8xSKszJuE507t0XWlKL868JW1BQT+heJPVo2J56UyC+dq63F7nn/tUvTA3xgh9wOF3CbrbR34r883osupfS3g69qAIlB7CiTdV++cnOmz4ZvbXwo4NT8Y6KlPs/7oTiyLSvdJa6grNOuqNwULNtUc9cwa81HLaij5fH3xLX6vXW+HHL2HQwZt+H0QirQMsrq6Otxyyy1oaWmB2WzGr371K1x//fXDzZahMJtMWDpuOv6x75TuN1j36P1fTLtMM14gNTU1ZH1w3GnPHVPgIYNRULvOoPAViyD3EIggOOLoUC3aJg9O/92FS3XxVS/bwNR0ogZ/vRYmnseizBK0RqeEpMqsvzFCagcKapO0WzUGkhzV9B3Fm5Adm6BoPeAOb/NN4U3f/qb70jmh3hZ3vgmA9bNW4J69m4e0tpMceurTdDrtOAJ1+5ZD7tnQuw/otW936EkOWLd/Mx6fcBm++fkGuBdx8VbLyshDpy4+972D9bOvwTe3v+Sxn2itXa0XJZ+Hw8W3YmFqVsiyxgKZy3DE0FSvG0aYzWY8+eSTmD59OpqamjBjxgxceeWVHld6kQye57F68my8Hh8bcMEqrcXG8zxSU1NV/yZY974a7e3NFSE5BHHwHQ/jbcNx9xAccfpOr97Tou+66EzvYGaTN3374onCW1aNXtr+4uIxBdiCE17jalJjrHhi9jXIjkv0eqDY1VypiO0RAQ99n7P34KHpS6WSBmqfpyf+yZdOgkn3VeP7WHvzkNV2UsP2Jt8dvkUANejVXIfuHmZ/9oFAbVBPckCNrR3/dfgDj0OQFkLhgdNbemFMjFV1P8n148paV72rfZtRtebnIcv6DdV+MtQY8QehzMxMKcUvIyMDqampaG1tHVEHIVEUUV9fj1V5kwwvWEVpZ2dne/TBCabyrhbtl8oPBMyrFvzZXLyBeggeOvghdp08gt39Z1RLFlDoPdDJU/i19O2LJ71ZNf7Q9gf087zFQz178Rpdc+B+5WIGh/mWMR76Lk1MVT0I+jPfRuqEfjFp8c0BePr4bl20QnbtpCOw1QwOP0ibgicbDsI5kMVE4e6x8HcfCFTfevRhBodJxIrd6PG6LilC4YHzp/TCjUUXSFfWZ5paMCYjza8raz2HrkZbBz4+ehCXTbowJFlj/s5luMYyDftBaOfOnXjsscdw4MABNDY24q233sKqVasUzzzzzDN47LHH0NTUhGnTpuFPf/oTZs/2HlGvhgMHDkAQhIjsCO0NhBDYbDYQQmAymQx7kxRE0RVXcroeo/leaZEa1bpBzjdFt7PfEN4p3rv8u1iYVWpop/UlmSUoKy/3+Wxpgr63pWzrYByLXCd6Nw29Xgs1fYcj1IJJM0wxqs8tziwJ6vBvpE7UvpjkfBP4zmKjCFVj0MWZJfjt1x/7fi4lDxeVTvJaoTmQfSBQfevVh5qdeIPRHjh/Sy9otRrSA72Hrs7urpBljfkzl8OZIOALw34QstlsmDZtGr773e9i9WrPVg6vvfYa1q1bh2effRZz5szBk08+iaVLl+LkyZNIS0sDAEyfPh1Op2fV5I8++ghZWVkAgNbWVtx666147rnnQivQCIG38u+hbN0wP70Ab9ceCZJ7OT3j3zj0Bqf/cPw8PH50p1ddacWxaAV8hsOmoQZfqdT+vHnPHVMAE8cpWsW4w8RxmDumwPX/YVKtVu8XU4olFm396ldPRtZ2UsPijGKMjo7zeiAbHR2HgvgUjMsf67VCczAVuP2Fr0D0YGGUB24oO63rPXTFm6OD/qxgYcQNQigx7Aeh5cuXY/ny5Zq/X79+PW677TZ85zvfAQA8++yzeO+99/DPf/4T9913HwDg0KFDXj/Dbrdj1apVuO+++zB37lyfz9rtg9kotOGsw+GAw+HQI5Iq6N8GQ0MLgiBAEAQ4HA6IBtQieaf2GG7Z+TIIgFiYYAaHWJjQ2tONW7b9C/81fi5iYfJJp7G7w6u8anz/oHgOHtj3oc9ATV9INbveDEOhb1EQsCxzLF7trESU1tXBjBXgCMFTM6/BLTtfBqAR0DxjBURBgDjQo08QBBxvbcJ3Tn4IB4hCz1T/WHgTVuT5nw1itJ3I8dlAJVxvdnHW1oWdDWWY7+NL4NPmSljI4GHJDE6yQenKgwCfNlX4pOULRuokwxKnkF+VbwD3jF+Ahwe8MnpsQg3B7Cd/m3MdvjVgk2r486xrQfpFOBwOmEwmzEvNl34n56uxu8PvfSAYfWutJQotfetBhiXOqy790Xcgaz4QnVyUkouSuGQ09HRqHrryrEnIjk0IyZrXy7cgivjZns2I0bAVDsB9e9/BlZmDGb1GfV/q/XuOhJGfnOM4xdVYf38/4uLisGHDBsV12dq1a9He3o5Nmzb5pEkIwU033YRx48bhwQcf9Pn8gw8+iIceeshj/OWXX0ZcXOiL/TEwMDAwMDAEj56eHtx0003o6OhAQkKC5nPD7hHyhrNnz0IQBKSnK2tapKen48SJE7pofPrpp3jttdcwdepUvP322wCAl156CVOmqLvh7r//fqxbt076ubOzE7m5ubjiiiu8KtIXHA4Htm7dissvvxxRUVEB0zEKgiji8zPVaOrtRkZsPC4eUwATz2N3cyWu2vrPoGhzcMW9fL3y3oCvpX598EP86dinAXuGYmHCP1PmhFzfWnoM9Dm9+n/v8u8G7Q0xErsaytB1qAzfbd2DXi95O3r4jlQdAIPeVEDdG/CSzJun1ybUYMR+Eszn07+f8vYfvXokgt0HvPG9qfYY/nbyi4DpqM2JFgLRd7D61Yt3ao/hZ/vfRb2iYGoiHplxVUCeY6OxofprfG/36z6f+8f8b2BNgavZrFHfl/RGxxfC+iBkBObPn++XSzA6OhrR0Z53qjzPS5HxHOdqQiqKoiJQTGtcHlEvp8PzvKvDs5sLnP7enW+tcY7jUFVVhby8PA8eCSGK5zmOw9u1R3HPnrfRIFs4WXEJeGLOKtgFBxwYfJ4HcGl0BrbZmxXuZhEEIlzuaDnEgauiR2ZejSjzoHmp8S6KImpra1FQUAB3PDxnBR68cBn+cuJTbG+owHsNroOvEwQ8AN7tc93HKV9RUVEwmUy654njOM1xOk+iKKKmpgaFhYUwm81Y6Bb/oCYrz/NYkjNOdT7k89TU041LotPwsb0ZfRA9ZCVwNWlsstsUdqVHJkEQUFNTg/z8fJjNZkNsj+r2orRCbEUZnBDhgOgxH64vxSQszCp11T3yMh/z0ouQHjcKdT3tEADEgMel0en4eMAGCQiyrEmYn1EMXlbDJJD1JIoiqqqqkJ+fLz1HZfI2T1q8ryyYjJe4m3HPvk1o6OnE0ugMfGxvRoY1EX+cuQKrCiZLz/M8L9mOXtujMA+sLfl+omee5OMmk0nVJgkhqK2tRV5enqJGjLusPM/j0Vkr8I0dL0KEq2eW9Cxce8Ejs1fAEhUlyUTXfGFhoUeQrV7bo3rjTCY8ffJT6XPN4HBpdDq22Jsggki299jMq5Adl4R1+99BQ0+HNJ5rTcIfZ63A6sKpPvdyyoPZbEZUVJSueeJ5Houzx/qUie4n+fn5iBrQlT+2t6pwCq7Om4hPW6oGDl2jsDCzGBygWPMmkymofc+dd6fTKdGW26G7rJnxieiDoLAPwHPPzogbpeCRfhblw9/vXI7jYDL5vroFwvwglJqaCpPJhObmZsV4c3MzMjIyQvrZzzzzDJ555hnJCCoqKhAf70pzTkxMRGZmJpqbm9HRMRgsmJqaitTUVNTX18Nms0njGRkZUrp+RUWFNDk5OTmIj49HRUWFwnjoF6x7RefS0lI4nU5UVVVJYzzPo7i4GDabDWVlZZIxWiwWFBUVoaOjA01NTdLzx3tasearjZhkTsTc2MHsuUpHN9ZsewHrx16KNbLx445OJPJRmGtJRZosI2Nv/zlUCjZcHp2BRH7wxH6S78MvZy/H5P5oBf9qMlGZ7XY7amsHa+7wPI+xY8fCYbdjWVQGxqZEIbbNhg7RgQ/sjSgwWTHbMlp6vknow/b+Fkw0J2JylCsDyyxro+fPPCUlJaG6uhr9/YPZa+7zJIoiWltbkZWVhejoaN3zNHbsWNhsNpw+fVoad5+npM4+XGxJRS8R8ImbTABQ4ezGPkcrUu1QfK4emfr6+tDa2or+/n7k5eUZYntUppqaGgDAytgcnBPteF9lnr5RMhMmnsfZs2dx9uxZaVxtPa3PX4Bfl+3EUWcH5lpScbElFYm8BSII9vWfwx9mr0Rdba3XedIjk91uR1NTE/r7+6VNVz5PIiGo7W5DF5wYk5OFqdEpaGlpkWhYrVbk5uaitbVVkmkiLPhswfdwinSjtawaP4q7CPmjUsD3c2htbQ3K9uTjgHI/0TNP3myPIjY2Fv39/Th37hza2tq8ztNEWPD6rG/grqNbUOKMlrK2EqJisHTChVhdMAWVlZWSTKIowul0ghAStO0tKCnBNOsYjBddjZN5cCgyWbHF3iTZXkJUDK4wp2OUJR7V1/8C28oOo721FfHmaOTFJyM5JgmA7z2Cfg90dnYiNTVV9zzpkYnuJ4IgYNy4cbrnyd32MgFkIg6JfDxMPI/Gxka0tbVJaz4tLc3D9kRC0BjlRAvvREpnP3KjE6SXCz0yUdo8z+ueJwAee3lCVAzSOwXUi/XIzc2V7I7adyDfuUlJSdK+5AthHSMEAHPmzMHs2bPxpz/9CYBrIeXl5eGOO+6QgqVDic7OTiQmJqK1tVW6GgvkdOp0OvH+++9j6dKlkqvPKI8Q4Gp3UlxcLG2Kam8Rgihi7MZHUdPTruppEEGQG5cIjgANvS53Nw9gdWwu3u497dUjdP+UJViSWYIFGcUwm0y6ZBIEARUVFSgtLfWoTip/g3296ivcuusVAPo9QrEw4aWUi3HllVca7hESBAHl5eUYO3YsTCaT394Tb297/Q4H1r33Il7oLEevikcIADKtiahYfZ/CG6JHJqfTifLycpSUlCAqKspQj5DdbseWLVsgTMzHuoPvKmws15rk4Q3RMx+bao/irr2bcLanC6tjc7Cx9zQyrYmab/HyeRJEcfANOc6V7eRe7JHneQiCgFOnTqGkpERaO1Smt6oO4959m6XMKOfA+nhy1kqszJ/klXeO40AI0VyXwb6VC4KADz74QLGf6JknPZ4GURRRUVGB4uJiXV5HjuNAAOxsLJeugealFSJqwOsof56u+bFjx8IdgdjexqqvccNAxWgTOKyOzcHrvXUgAx6hVxfdgpX5k/zes93HHQ4HtmzZguXLl8NisfjtPfEmE91PSkpKYLFYdM2TZN92GzJi4jFPdu0m512+5s1ms0KmTTVHce++zajtaZf28py4RDw+6xqszJ/kUyaHwyHRpp4cPfNEteYEgQlQnSe73Y4PP/xQsu9APULt7e1ITk4O/xih7u5ulMtqslRVVeHQoUNISUlBXl4e1q1bh7Vr12LmzJmYPXs2nnzySdhsNimLbKhgMpk83GxaRaS8FZdSo6PlvtM7LgiC5AZ0/53cPbirpQo1Pe0AXNVj1eJvans6pIq9AxQAuIxWLRODjk1IycSS7MHNTS/vHMdpujDpeKY1we0Qps67fFz+vL/zpDUu55EuNG/uV28yaY1bAFyRPQ7/6CwbuF4YlIm20vh/pXOwofawas0cbzLRzcpkMkkHz2Btz12mFQWTsLJ4qte6Pnr1vrpwKlbmT5Z6pP0/tx5pWnQ21R3TXa+EbqTua+etmiNYs+NFDys73dOBNTte9Ej3VePF27oMxvaAwS8bNdpqzwO+bU+NF61xNcjXv7fnjbS91YVT8Sp3q1Tqg34FZ3mprq6HR/dxqm/Ku9550jsu17WvedJbj8d9zfOydbOx+rCHfTtBUNPT7mHf3nhXWzu+5knOt695cqdt1F7ujmE/CO3fvx9LliyRfqaBymvXrsXzzz+Pb37zmzhz5gx+/etfo6mpCdOnT8eHH37oEUAdatBUQSC4GCFBEBQGacRbOc/zyM7OdhXhc+NR/hbRaOuEGZyqV4XGnpjAoXTUaGxYdCvu3bcZdT3t2G5vAQdlPJC7Rygj2irJplcmQgiys7NVn5e/wc5NzUdBXBLqezrg8DNGiH6mkR4hQgiysrKkt/5APEJyj0WmNQHz0wql2JlLJ16AV8ck4a79mxUxDaOj40BA8MChLTCBc9UkiUvEYzOvxuhYK5r6upERbcW8tELFYUEuU1ZWFgghIIQY6hGSe8toUU9JNwO/D+StnBacs43KcGVtynhXm6e3ao7ghm2uDZ7agACC+p4O3LDtRenNU64bqhNJFxyHu/e8rRrTwMHlefjx3s24Ons8zBpxF1Qmd9pGeYTkHhb5/mKERwgYvHqTf26gb+XycbrmqTdOjkBtb2XuRFydPR67myvR0tmO25OWSx5AX3oXCcGnZ6rR2NPp8qwMrB335+Vrn/JilEdIvi7pZ2jN01tVh3HDjpck+6b7XnNPp2Tf7p5XSpvGpTmcTty7Z5Nk3+57OQfgx3s345rciV69+3Lacjv0NU9q+57aPAFQfKcEant6MOwHocWLF/usTHnHHXfgjjvuGCKOXIikGKGxY8eC4ziFZ03tXjm5qw/zLWM84mmAwdiTC6OSkdzWh4JRKXhv6nWo4/pw04G3MA9jFFVbaYzQFdEZyIkehfROAWVdZQHJ5HA4fMY0rM9fgL9X7g+LGKFg5slms2HrkQP4sP4kOh190l35RdYM/DRvFiYkuQ74s6wpipiGc3092N5cgQpnN1rQgwujklFsjgcI8Oa+nTjicPUrWmxJw9iYJCzLHocJSelBy0RjZNqSY5BuiUOGjUhXcnKZ6F18RUUFYmNjdcU0UPhaTw0NDbrmKSs7G3fteRvXxGQjihuc/w/6GmEjTlwXm4stX36B8fYo8BwnzVNDQ4NinhpG8XD02RWxch7xaSLwyaF9mJSR61Umm82moG+U7YUyRojOk55YrkBl4jjOsPVEZcoCUBAzBkVZRWhvb/dpe8fbm/Fc3SF80F2HWVEpKDbH49WoGCzLHocFJZOGLEZI7zy1tbVhy5df4LoBu1Tb97Z8+QXmxKQiOytLc562HT+Ei0gCEOu6KlKN9xSBHbUncGnhJE2Zyt2q6+uVKRNAviUJRZna83RexwiFIyIlRqi8vByFhYW6YoRqe9rBQT1GKM+ahFPX/kzyKIiiiHcPfo6bj72r6DtEs8PMsvtdf2USBAFVVVUoLi72GiNEQasty70kFEMdI1RZWSndjfsb0/BNty7Yct5fW/AtTHRGo7i4WMpOcQoCxm18FKcHqtVSz51cA2pvda8uugXXFk5RxAhVVlaiqKhIV4wQjSE43dMheUPy45KkGAL5PNEYoaVLl8Jisah6GgKN03A4HKioqEBRUZHkjlebp53Nlbhky189MhkFma0CwEdX3IaFGcWSV6K8vFyiDQCv13yNm3f822eWy4sLbsQ3i6Zr8k4I0VyX4R4jVFVVhcLCQoW3yQiPEF3zJSXqDZ7VeNcrk5y23KugxuOmmqO4YcdLEKFcT3TGX118iyIOLdQxQnRdeosR2tZQhiu2/E1BR827/9EVt2NJdqnHmqcxQq+UH5RiLgHtDOAXF96IG4sv9BojRGn7ihHyNxPuvIsRihSEe4wQIcRnjJDJZML6OSulUufyOBq6BNbPXgmLW92GCYlp+Neib3m0fPDW3FIv7/SaQ+15kRDsaqmSYk1WFkzGyoLJuOuLt/DMyc89n8fQxQgB3uOb1J4XRBG3f75BNdaK8v7DvRvxyQU3KK5PP2uuRPVAbJdES6O+kpz23fs3Y2XBZJhkcTCUL19xGpvqjnnEEBBANYbA3cYo795iT9Tga9xXvEBTX7eHDuSg4012m+Jg4k47M3aUx/qgkNtYpjVBMU/u8LYug7W9UMcI0WsUI+ePgn5hGR2fJqftzfYEUcRd+zbBIZtfwW0vvHvfZqzMnyz1Vvz8rMuz8GlLldfehcHI5CtGqKmv26dNAkCTvVuSVW1dusdcUriPZcYl6OJdT4xQIPFparSN2svdwQ5COhHOMUIAlDEO0D5xr8qbhA1L1nrUEcq2JmL97JVYlTdJQYf+7YrcCbg6d4IiE2dhRrHiftdfmegXhTvvgOuL+O49b6NRzmNcItbPWYnHZ12Dv5/ao+hF5f5mFC27GjE6RkgQBOkZf2KEtjdXotXe4/HmJee9w96Lqq5zKBVFydtEY7sAZSyXN48Q4Oo8vbOpAkuySqU3T/pfb/MkiKIihoDySONjaAzB1dnjpRox7jFCRnqERFGU+PY2TxkxrqtrXx4heTybFLMl08OC9CLkxiWiya1QIJ0nEzjkWJMwNzVfOjCo8Q5or8twjhGi/+9OwyiPkPz/5TDCI+QrzkYUXY2km3pca0prPdUP9Ehr7e3Bvfs241xPN15KuRhXb/0nUuLi8ZQsc1Aua6AeIfpfb/OUERPvde+gyIiOV6VN6cwbUyDFXNKbAHdvco41CfPTCiW9qvEup+3PPMll8jZP9DOobgO1PT1gByENRFKMUHFxsZTKSI3R2/3/6oIpmBeXji9rytHttCPeHI0p2QXIzspCY2OjQqbk5GQAQENDA3p7e6VaFRlxY2DieUWNEH9lor/v7+9X1BE63tGCNcc2I52PUcRpdAoOV4O+OTfgsdz5+OxMNQD1u/L5qfnAwBQYGSPkFATUdLWit6MTjXHAguxSVFZU6Jqn7V0VSOdjsDg6TRp3jz3hwaHt3Dk0NDQgPz8fra2tSG7rk/Qgj+UqNsdLdGiM0HyLMparqfUskFWqqCNUXl7utY7QZ2drFDEEALChtw5WzozlMZkDkwd88vV+LJtx8ZDECFG+eZ7XnKcZ2dnIiUvEHHGUaozQmthcqV5JWVcZSktL0d/fr6BNYxqenH4V3vhyt8c8FZqsmGUZjW/kTUNlRYVXmdLS0mCz2RTrMhJihGJjXfVeWltbfdYR8lcmel1DeTcynkYURYkvb7Z3rrZe13raVHsUh8pP4iJTAsyxSQCAfJMVJ3o68I8vtoJraZNi+tTmSSQETVYOzf09SG7rQ158shRfp1ZHqKqqymsdoWkxo/HdhFJ0OvoAqO97CVExGMu5vmuam5ulOkLl5eVSHaGmxkasz1+A16u/AqAeI/SNvGno6+31upeXl5cr1o6R8WksRijMEAkxQvROlVYLlvMS7Fs54KogajYrz8z+vsGq8U4IgdPplO7FAdf10biNj6J6II7JPU5DAEGuNQll1/4Mv/ryQzx1bBcEQqQ3oyiOx10TF+ChqZdjy5YthsYIbaz8Gvfu24z6ng4kcFFoI/3IiktUfTtUm6cHv9qK3331H6+xJxyAX05agl/MWCp5hGiMUH1Ph0dMA4XWPf8jM6/EvVOWSF4Vh8MhVdvWmqdXK7/ErTtfUYzLPUIULy64ETeWXBjyGCFBENDf36+IFfCVNQYM1iuh1x5q8WyUd0ob8F5HKM+ahCdmXqOrjhDHcejr61PQjoQYIUB9zfszf4Io4tMz1R6ZjHTNR0dH+7W/6ZGJxvLExMR4PC/ncUdjOa746DnX30B7PaVEW9Fu7wEwGHN4U+tn6IGAqAGv4IlrfwoTz3vME42vq+lpl7yR7jV6KI+U76ioKJjNZl1ZY5R3uZcSgEfWmHzN04O+PE7KvY4Qrfmlp44QbbgqX5d65sldJhYjFEEI5xghQohk6O5Bx8HGaRBCpCA7d9re6OjhncYHyRfRrpYqKR5GK06j1taO33z9HyzPnYAHpy/FX099joruVhTHp+CH4+fBYjYrug4bca/sXnejg7gakdRr1JVR08HijCL89ivfsSdzs4oU16cWnsfjA7FdFHpihACgtb9PoiPXtbcYocw49RgC9/nItA6+GIQ6RogeruQ2qPb86oIpeHWJZ70Sb/FsarQ5jsPqoqlYWTDZa00kb7wQQlRp+5JVDUMZIxTomqfj3urcXJs/2Wd8WqAxQnQ/8SYrz7vac2TEJUhXQ4BnjFBqjBVn+gY9DNTu6VMOEFTZ2vDZ2RoslrXYMZlMftfooXz7WjfUJl/llfYtwhXa4G7fWmuefo5e+/Y2H+60tZ4P9xghfU8xhDVEUURZWZnu+9Bwpt3Y26Xrb3/79cdY8uGzGPvWo8iLT8GfLroWd09eBIvZ+LO9IIq4a8/b0sZmBoc1sblSjAEA3L13EwQfOlqcUYLRljivz6RHW5HV5fmGvrpgCjYsWYvsuES/eJdXn9Y7lwvSi5ATl+hRiZmCg+tgsWCIGp76a4OrC6a4Sg8s+wFeXnQzti37AarW/Fz1EOSLtonnsTizBDcWXYDFsmKOoeA7XBAM3xurD2PNthcUhyBg4IVh2wt4q+rwsO9VJp7HU3NWAYCHjdOfby66UNdnuu9X7nuFHFp7BbPv4QfzCOnESAmW9pd3rcBJI67G1IKlM6KtUqEwtasx9+BAqZDYkluxKm+SaiBmMMGdgCst+3RPh3TtZAYHHoObpgmcKzC5sVxKy1bTmclkwt/mrvGaPv/n2auBftec0asxysvK3IlYkTMBn56pxn/qT+LRw9sHZdS4GluUXijxojdYmuc4PDVrJb65Y5BP9/l4cuY1gCwwNRyCpd1lWjAQ7Cl35bvLqhYsHWhw5/keLK2nUN/P9r+LtyevkniXI9irMb3B0oS4ivttWHQr7tm3CbU9HdLVGL0aSo6JxZPHdinWPJVB/rN7IVl5IDbgGagPDCYxLM4s8ViX/szTwvQihUxq309qwdLB2p58PbmvSz3z5E0mFiwdZhjJwdL+BKy6B0vLZQq2+CD9vTxYOp0Q3GgtxEu2Sp+BxRRNQh/u3rsJ8+LS0dbaCkC5yQYbLN1MXJlrKwcK9fHgMNGcgFFcEzqJQwq8PFdbj7Iu0WvQ4BVjivD6hKvxwekT6HLaJZlmDxRUHNcfhdbWVkWwtPs8Lc4sQbEYi8ryCuktUy1YmgMwLSYVAPwKljabzeBa2hSB6u7B0lxLGyqcFUNWUFFPsHQg60krWDrQxpdymc6nYOnklBS8sG+bz0J9vMihtuMcxmP4gqXdm+OWcT1oaW5GgoNzBTT3c0iOT0ROXKLUSJYWaM03WXFc6NQsJHu2rkGxbuSB+nI09XShv7/fr2DpQNaTWrC0UYVkjQiWbmtrw96KE1LSzoS0bOTn57Ng6XBDJARLA/qargbCuyiqN2D09hYhEqLagNGdd0HwbLoqiCLy3vgtmu02XR4h+fgnS7+PhQPXNbQAmhHB0u6F+sxwNXd8o7cODhDVQn1q8yR/M9JqsUEL/JWWlkoFFdV431Zfhis+GiyupuUR+mjp7VL6vN6mq4IoonTDw4rrDff0eRooStPnQ11QsaysTNHcMVhvpCSroN10NViPECHnR9NV2hy3SVbqAlC3STM4vDRuGa6dswjuMMIjRBu6yr0K3nj3Nv527VEp8D5GFizdC0GzkOy2+lNSIDag7hECXOtS7hHyt+mqXpm8NV2V6zeQ9eRP01U13t+uPapZIuWqzLEsWDocEe7B0nTxGx0sTU/6arTVnvfVENA98M2d710tVWi2u072WsHS8sBiOZr6uiX68kXn7zy5jy/MKEZOXKIUXOkEweu9dRJvAghyrEmKhqCA96BBk8mk2qSS53mMGzdOcX2qhia7enE19zFaZJDneURFRUm0vQWs7pYFrMshnw95oGiog6XNZrMH396e92c9mUwmVdqBBnfK4W1d+quDoQyW9mfNb6w+jDXbPZvTyiG3SScIRufnaNLW4l1rXM67+34SrO3JA+/P9bjWEYHrJUAr8F4tEBsY1AF9iViYUSzx6L7mjbA9Oq625oO1PQo12lrPu/NOY8nc7aa2p91VImXhLTCBBUsz+Alam2M4afsKlNxYfdgnbb3B0mrIjB0V8N96g3twJQfAypkVJfmfnL3Sr0BDb9Cjb72yuj+nh7beOQhmrvxFONh3uNEOJfTw7S0wWA0cgDxrEuak5Pp8NlAYrW8amPze5d8FALx3+Xc1A5MBfYHYantFpNpgILT1BJTfd+C9oPjyF+wgNAIgiqJ01zxctAPNlnCnHchhZiiymORZWyZwWB6TKVUYVkudDxR69e1vZpcgitjeUIZ3Dn6G7Q1lXjPcAj1khQrhYN/hRjuU0Mv3roEkAj2gdvrEzGtQW1MTUfo28TzmD6yj+RrlE+TQyvDU2isi1QYDpe3LbgiA0zZ9dmUU2NWYTrCsMe9ZYzubKtDU0wkOUL0TF0BQZ2uXMquoLtyzxuak5CKa42Enoq4YIflbFo2xAYzNGqPjK3Mn4urs8djdVIHWugbclrcUCzNLVNuMqOlMT5wGzcQQRc+sMfnzHICnZq2UiqsJsngMSSczrwHPcdhYfRjr9mxCc08nVsfmYOOJDzAmbhSenLMKK3MnKnjkeR7z0woVJfip3t1jhOam5gMI36wx+bggitjVVOERt8ayxgLPGqOtX7Ti0+TjNBvr6pzxqBioxD6cWWP+jlNe6TO+5onuFZ+eqUZTbxcyYuKlopLyOZOveX+zxvTwHo5ZY9RuvMV7UotmWWPDDJY15oLerLFzbY1YE5uL7fYWNIl9UoYVBc2eoJlVgHrWWHVXK66OzsKbfad1ZY0lRMVgWeFkXFswBWfPnpVkMjJrzH2eMkQRFtGCC1NywQEBZ7mozZMoij6zxug8Tey34LUJV+PD+pP4rKdZyhobG5OEZdnjMKHfgreOH8CaPa9iWXQm5sUmYqI5AYjlsK2vGWu2vYA3J16DCYmDOqa2Jy/BD3hmjX0jbxqqq6oiImvsmKkP9x5815XRNIBXo2Kw9IKLsCyjhGWNBZg1ltjVizWxuZrtXWjW2F/GXoa5KXng+zmUl5cPe4sNf2yPzhPdTzo7O5Gamqp7nubKZKrsGmzFE0iLjZGSNZbc1YfLozM0M4C397dgnNm1VlnWWJggUrLGysvLUVhYGJKssaqqKhQWFnq8ebp7hK746DnNLAk6/skVtys8QlVVVSguLpbeoF+v+gq37npFdx2hrJhReGLOKqwumqrg3cisMfd5EgQBlZWVUrZEoG+wavNEaRcXF3vNGpOPa7UzEEQRJRsfQd1ADSQzOKyIycI7fQ2ww8VDgTVZahPgzjstwX+6p0OajwJrslSCXy5TqLPGKioqUFRU5HfW2Kaao7h+x4seHgsOLlvasPAWTHRES7T1zpMe3gkhmusy2LfyUGeNqa15d963NZZj+da/+/QIbb38dizJVK75kpISuMMIjxClTfnU4t3fcbqfLF++HBaLxW/viTeZ6JovKioKSdYYpR2KrDFK25+sMUEUMXbjo6gdaKPk7hESQDDWmoJHoyexrLFwQzhnjQHAuHHjVJ8NNnvCZDJh7FjP7Cb35+XZEoBn9hKNWZFnVtGMHTkyrQmKcva+ssZq+zpx3Y4X8SavvHuXL0Y1WQVR9Cgt7yurQv5FOX78eI9xrefl8JUR4k5bzzyZTCYsySr1eGZXSxXqZPPhBMEbfacVz6i1CaA09ZbgNyprjAzwLP8swJWdIteJLzr0MwVRxF37NoFagppN3n3gHVSt+blXmfSMa/GitS793TuGMmtM75o/E4CUZgAAS+FJREFU09/jkRGmhjP9NoV9aOnEG+9a4+62J6dtRMai+5e73j3Cn3H3NW9k1pjFYvFYO8HaHoUaba3n3edp/UDLIPc9nh6Jfj/jKuBI9ZBljbGD0AgAIQQ2mw1Wq1UzJTXUtGm2xJptL0hxQhRa2RJqtGkQsHv6qS/c/tkbWJk3SVfmlq8Uf18IB33rgXtWFwcgnY9Bs9in0K237C9agj/U8NWfKhCd6AvKbMf2muO4pGBiWM/lUEIv34EE1UfK2hlKRKpOgqFNA8o91vxAaYIV2ePx/pFqQ/n1BpY1NgIgiiJOnz6tOzAsVLQDyZZwp+0t/dQbztl7sL2p3OdzgaT4uyNc9O0LaTHxip9N4LA4Os3jutH9uaGGnv5UgehET3q/CRzamlrCfi6HEnr5DqQnXaSsnaFEpOokWNr+9EwLNZhHiMFQrC6YgpV5k3R17PZGQ+1twRe2N1Xi0ixtl76vFH8OrhR/vZ6l8Iden9rwhQnqmZMf738H705Z7TdtvR6LeHO037QZAvMCMzDIMVQeZ19gByGdYOnz3tPn5eMmnpcaXg4wp0g7levCPX2eYnXBFFyTOxG7mirwv8c/w+a6owC8t9iALJVTLX2epvjzgGZwp3uKv1xWOW1K012/9Hk1nRmZPq9nvKWnWyErbRZrBqcIam/p6faZAutLpkDT53c2VUgl9mlqvnw+RLiaVNZ0taLEz/T5uan5KIhLQm1Pu+p8CyDIsyYhJy6Rpc+7BUur0VDjfWXuRGxYfKtHi41caxL+OGsFVhdMUQb2y1LcR3L6vD8ynW/p83plop9B+QgkWFqvt4odhDQQSenzNAOjoqJC2oCNSp9PSUmBxWIJSdNVQgiioqLgcDgUaY4870q57OvtRWaXiO8llsJyttNr09Xt/S2YH58l0VdLn6cp/r7Sfc82NEkp/moyEULQ0dEBh8MBjuN0zRPHcWhMMKGpvRVJ3U5Xc0eO85gnSltP+rwv20vu6kOBySo1vkzmLSgyxWN1bC4+sTdLZQ6S2/pQ5izTnCctmeg8BZM+f66tERdGJWOfoxUXRiWj2Dx4TUfnaa4lFb1d3ZJ9+2N76/MX4LsnPoSNOHGdW+PLN3vr8Nj0K9F1rlOiLZcp2BTm9PR02O12xbqMlPR5i8UipV7LZVKzvYWpWai+/hf4+OhBdHZ3Id4cjbz4ZGQlu0otyGWiX1Yc50qlD2bfc5eJEILu7m5wHBc26fN6ZKJrPhTp8+3t7ejo6EBFRQXGjBljaPp8RUWFRJvjOENsj8rEmq6GGSIhfd7otwgjU82NkEkQRaS/+hC6nXZNj1BslAXnbngI/MAXjlr6PE3x95XuK0/xN0ImmoZePZAuagKHnLhEPD7rGqwqmByyeaLp86d7OjzigoSBiwxv6fN6ZA02fX5nUwUuHyi7oOURMoOTGtrK50Ov7ak1BaUei2sHPBZqMoXzegpl+nwk7hGhlimU6fPDJZM77+Ekk91uZ01XwxHhnD5P3ygSExM9oveDTZ8nhKC9vR2JiYmqf6NFRw/vcr69plxyHEw8L6VZytPnKSy8SbqWA9TT5wNJ8Vfj3V3f3mTdWH0Ya3YMNqWk6aI1Pe1Ys+NFbBhI+6d05LTlvLtDz7jJZMKTAzEcAq0DZLKiWhh8c/rj7GtgkX2RusuqZzyY9PmFmSXIHJgTQSVSiAOQZU3EtNhUaXNTo+ONx9WFU7EyX70MACEEXV1dHmvHiBRmQoj0IuW+Lv2d16FMnw90zesZ97XmtXjXGpfzrmddBso71Xco0ufd17yR6fNq3w3B2p78ebXvnWBsz52XoUqfZ1FsIwCiKEpViUci7V3NlTjX3+P1mXP2HuxqrvT6TKANEd0h57vf6cSTR3bgv794C08e2YF+WRPCQPuvGalveSYfDw6zLaPB+9EjTRBFbG8sxyuVX2J7Y7nXHmWBQM+cPDHzGrS0BJfZRYMybyy6AItlB91wsO9wQ6TqhOl75NAeajCPEEPYw8hu6L7qV/iTuvnzA+/j8WM7Ichcsj/e/y7WTVqEP8y6WlcdmzpbO3Y1V4Y0c4Jm8u1sLMe52nrcnrdM0+slR7D1lvzhz9ucrMyd6BFjwcDAwGAU2EGIIexhdDf01QVTcHXOBPz5xKeo6G5FcXwKfjh+Hixm/ctha/0prK/d5XGdIxCCx45sBwBcMDpbFy29B71gYOJ5LMwoRlmXiNKMYl2HIFr5VQ5a20ePN8kfeCu74B6jwMDAwGAk2EFoBIDjuJBVUw0H2gvSizDaEuf1emx0dJyicJs3qHk6Hj+6U7enwyEIeLv5hNdn1h/dgfcv/54ufuQHuHDQt94rPaPrLWnVFAkHnYQb7VBBEEXsbKrAGdtZNDbxujyH/oDp2xORqpNI1bca2EFoBIDneeTm5vp+MJJpG7TWjPB0PHvqc3xib/H6jEAIDrc1e20XwsF1/SM/wIWDvn1d6QFDc6VHEQ46CTfaoYDHC8LXxl+FMn17IlJ1Eqn6VgMLlh4BEEURZ8+eDVlA3HDT3tVciXP24IOlAwleVkNlVysmmxN9Lp7q7la/g7PDQd/1Nn3VvPU+FyzCQSfhRttoyNuc8IBk3/60ntEDpm9PRKpOIlXfamAeIZ0I98rSZ86cQUJCgpRqaFTtCWrsiYmJhteeEAQBZ86cQVJSkoIGoKw90WjrlGr+eKss3djTOSSVpYusSTgXlYiTzk6IIB50nAOp6sXWZFfl3UW3etQRyrUm4Y8zV2BV3iQAg5VwBUFAS0uLlLpsZI0Qp9OJlpYWJCQkSLU51ObpTG+XpkzyekRnBmKbgqksrWec6oTat5F1T0RRVNAGjKvlQgjRXJfB1nIxsrK0UxBw755N0tyawWFyVCJOOTshYqDNyd7NWJEzAVFmc1D1aeiaT05ODkllaUo70ipLUxu0WCyG1hGSr3mz2WxoHSE5bXnZDKNqIwGssvSwI5IqSxcXF8PhcKC8vFwyRqMqSycnJwNASCpL09/39/ejtrZWIZO8GmlyVx/WxOb6rCw9xmkaksrSl/JjYDMnYRTXhE7iwBq3isUbeuswio/C5aY0lJWVYSIs+HD69Z6Vpfs5VFdXK+ZJFEW0trYaUlnafZ76+vrQ2tqK8vJy5OXlac7TmJh4VZmsnBnLYzKlsSyba+MJprK0HpkaGhokvnmeN8T2ANd66u/vV9B2tz2KQNZTWloabDabYl2GY2XpHVXHcBFJAGJdBedahD4AwARzIiZEDRShE4Htp77G5RMvDMj2qEz0y5nyHsy+5y6TKIoSX5FUWZqu+VBUlqbVwcvLy5GWlmZoZeny8nLF2mGVpUcwIqGyNACcOnUKxcXFIfEIVVRUoLi42OPN0wiPUEVFBUpLSz0C7twrS4/b+CjqezrgUPEIcQAyrImoWH3fkFSWFgQBf935Ae6t2w2HhkfoJ5MW4eEZV2rK5K53uUeovLwcpaWliIqKMtwjVF5ejpKSEq8eoe2N5bhiy988ZHL3CD028yr896SF4Dku4MrSesYdDgfKyspQUlJiuEdIEAScOnVKoq13nvTwTgjRXJfBvpUbWVn6lYqDuHXnK9K4GRxWxeZgY28d5FReXHgjbiy+MGiPUEVFBcaO9WyObIRHiNKWexW88ah3PJSVpemaLykpCYlHiNI22iNEX77l61LPPOmRiVWWDlOEc2VpURSRlJQkGbocwVZY5ThOqgKr9jdadPTwznEckpKSpDdxd1DeTSYTHp+zUupyLa8sLY+1iZKlv8sXF6VtVGVpjuOwZtJsnE7g8fixnXDKFqCJ4/CTSYvxh1lXq8rvq8Iqx3FITk6WnvHXxryNm81mJCcnw2w2SwdPNV4WZhQjIy7BI2CaVsWmuGf/u3j82C48NWcVVmSPl+hRHoyq7msymSS+1a6B1J7XO87zvCptI6r7eluXgejAnTYdD7aydGZcgmJeCYAKZzcEQFEeIjMuISDe3fWalJQkfYGpIdDK0nLaRtme+5c7XTdG8E7H6Zo3D+xfRtgeHZevefpcsLZHoUZb6/lAZWKVpRl0g+d5ZGZm6p70SKQtr5Ash94KyYBxlaUp34/OXoGebz2MJ2atwB0T5uGJWa6ftQ5BehAO+qZ60pOoR4Np36k9ZgyTKggHnYQbbSOxIL0IOXGJ0nwLINjnaJUOQfQFQW95Cm9g+vZEpOokUvWthsiXgMEVUNzYqDswLFJpry6Ygurrf4Fty36AlxfdjG3LfoCqNT/3K7XXiAOVnG+L2Yy7Jy/Cny66FndPXuRXUUZftI2GP7SpnnLc9OQO6i+478B7BnCojnDRSTjRNhLuLwgmcJgVlaJogqvnBUEPmL49Eak6iVR9q4EdhEYAaGO9UIR7hRttrZ5R/iDYA1W46SRUtKmenpi1wjtdAKdDmEofTjoJF9pGQ/6CwAEoNsdLda6MrCLO9O2JSNVJpOpbDSxGiOG8hFYVYwYlTDyP9DjtIEOGkYNAe9IxMEQ62EGIgYHBK/T2cGOIfPjbk46BYSSAHYRGADiOQ2pqasj6yYQTbUEUVRtzDiXkfBvNT7jpGxgMpvXeKsR7LFEwCEedDDftUCJSdcL0PXJoDzXYQWgEgOd5pKamjnjaas1Sje6FpAeU71DwE076pqDBtLR8gfwwRLfAR2ZcBRypNoBLT4SjToabdigRqTph+h45tIcazO85AiCKIurq6kKWGRAOtOW9kOQwuheSHoiiiLcOfoYbtr1oOD/hom93+Mq2W5E30Sg2PRCuOhlO2qFEpOqE6Xvk0B5qMI/QCAAhBDabLWSZAcNN21ezVA6uZqkr8yYNyTWZUxDwYdWRkPATDvrWAg2mVbsKdDgcBnM7iHDWyXDRDiUiVSdM3yOH9lCDHYR0ItybrsobA8p5MaLFhhYvRrTYIIR48A4oy7LTZqlmcJpNV+ts7djZVIGFA0Xf1Jqu+pJVr0y7myrQ7eiTOFBrsXFapXmr3hYboihCFEWYTCZDW2xQ2vJGhv7aHgjBgrTCQZkGeA9l01WqD/oZRtgeHZfrXZLJoBYbLnWpr8tg2xzIW1aoVdsOps2B1poPxvbk/Mr/Xw5/9z21FhuUtpG2J59D+owRtkfH5evSKNuj43LaRtke5V1O25usrOlqBIM1XXUhHJqu0mapvpqutpw9i7JOz+7zwTSJVJOptbURE82JXpuuWjkzztXWS81b3WWicJ8nF/3hbboaSONL1nQ1cpuuussUGxsLAGhtbZWaX+qZJ9Z0lTVdZU1XRygioekqz/Nob2/HqFGjpDdRozxCANDV1YVRo5Qp1Ea8lRNC0NXVhcTERI/PlL9FbGssx/KtfwcATY+QEwRbr7gdSwY8MGpNV33JqlemHY3l+MEnr6BScPVjUvMIcQA+dmvequfNiBAi2ZzRHiFRFNHZ2YmEhASpx5FRb+WhbLoqCILUNJGOGekRam9vl2jrnSc9vHMch7a2NgVto97KjWy66j4OqK95IzxCdM0nJSX5tb/pkYmuHfryZqRHKJRNVynfCQkJMJvNhnqE5GueHvSN9AhR2vQz9cyTHplY09UwRTg3XQUGPTfu8NXUTs94UlKS6rPe6OjlXYtvQNaIlOcUTSHlTVeVzw/Sly8uf+fJl0yLskrRG22C2OMaV2vemqPRvFVrPuTjKSkphvNON0E5bblM7tAaB8epxgjJO7dTHoywPUrTnW9fz+sd5zhOlbaeedLDixptb8/rlYnatxFNV9XGA1nzesfpmjdi33PnXa7vSGm6Cij5Nsr2tNZ8sLZHYTabVe2bNV1lGBaIoojKykrd96GRRrulz+b19/4+Fyw4AE8XL4FZ1otJ/jsg8N5M4aBvLWysPoyCN36HJR8+i5t2/BtLPnwWBW/8LuQZe+Gsk+GiHUpEqk6YvkcO7aEGOwiNABBC0N/fH7LMgOGmrbey8VBVQCaEYEJ8Kl5ddEtQzVu1aA+3vtXgq3xBKLvPh6tOhpN2KBGpOmH6Hjm0hxrsaowh7KGvsnESFgxkjOmBERWhV+ZPwsqCycNe6TrU0FO+4L4D7+Gx6ElDzBkDAwND8GAHIYawh57Kxv5cRRlZEfp8aN66q7nSwxMkh9R9PnroeGJgYGAwCiPr1fU8Bc/zyMnJ0R0YFom0fVU21nuACbZCtSCK2NlciUOkEzubKyEYfD8eLvqWo7G3y3Be/EE46mS4aYcSkaoTpu+RQ3uowTxCIwAcx0k1jkYybW+VjfUg2ArVQ9HrLJz0TTHc3efDUSfDTTuUiFSdMH2PHNpDjcg/yjFAEAScOnXKo97DSKRNr6JuLLoAi1XS071BzxVPna0du5orPX4n9ySZweG6mByYwRne6yzc9A0Mxmhp9ZgOdff5cNTJcNMOJSJVJ0zfI4f2UIMdhEYIQpnCGKm03aH3isf9OTVPUhTnWjp07O69mwy7Jgs3fdMYLQCa5QIemXFVUHz5QrjpJBxohxKRqhOm75FDeyjBDkIM5w0CTcMPxpM0UjCc3ecZGBgYQgkWI8Rw3iDQNPxAPUkjDcPVfZ6BgYEhlGAHoREAnudRWFgYssyASKSthkDT8N09RAIIPuhrhOB2nDIiqDjc9T0c5QLCXSfDQTuUiFSdMH2PHNpDjciXgAGAq+8Lo+0bgaThuwcLEwA2MthhjAOQ62dBR28YSfo2CpGqE6bvkUM7lIhUnUSqvt3BDkIjAKIooqysLGT9ZCKRtjesLpiC6ut/gW3LfoCXF92Mbct+gKo1P9dMgXcPFjaDw5rYXEWvsUB7i7lDrhNBFLG9sRyvVH6J7Y3lQQdjD5e+g0Wk2iDT98ihHUpEqk4iVd9qGBnHOS9ob2/HZZddBqfTCafTibvuugu33XbbcLPFMMzw94qHepLu2vM2mno6pfEcaxKenL3SsDpCFJtqjuKufZtCWrOIgYGBgeE8OAiNGjUKO3fuRFxcHGw2GyZPnozVq1dj9OjRw80aQ4SBBgvvbCzHudp63J63DAv9rGWkB8fbm3HD8XfhcItBojWLgmnqysDAwMCgxIi/GjOZTIiLiwMA2O12EEJGRLdchuGBieexMKMYk5MzsTCj2PBDkCCK+LD+pGb1a8DYmkUMDAwM5zuG/SC0c+dOrFixAllZWeA4Dm+//bbHM8888wwKCgoQExODOXPmYO/evX59Rnt7O6ZNm4acnBz85Cc/QWpqqkHchwd4nkdpaWnIMgMikXYoEUq+Pz1TjX92lsGpehQKrmYR0/fIoR1KRKpOmL5HDu2hxrBLYLPZMG3aNDzzzDOqv3/ttdewbt06PPDAAzh48CCmTZuGpUuXoqWlRXpm+vTpmDx5sse/hoYGAEBSUhK++uorVFVV4eWXX0Zzc/OQyDaUcDqdjPYQIlR8N/V2wcqZNdtZUARas4jpe+TQDiUiVSdM3yOH9lBi2GOEli9fjuXLl2v+fv369bjtttvwne98BwDw7LPP4r333sM///lP3HfffQCAQ4cO6fqs9PR0TJs2Dbt27cKaNWtUn7Hb7bDb7dLPnZ2uwFiHwxFU0Tj6t6EoPCcIAioqKlBcXAyTycRoI3L1nR4VixUxWdjUW6/pFQKADEuc37IxfY8c2kzfQ0ub6XtoaRulb71/z5EwCpjhOA5vvfUWVq1aBQDo7+9HXFwcNmzYII0BwNq1a9He3o5Nmzb5pNnc3Iy4uDiMGjUKHR0dmDdvHl555RVMmaIebPrggw/ioYce8hh/+eWXpVgjBgYGBgYGhvBGT08PbrrpJnR0dCAhIUHzuWH3CHnD2bNnIQgC0tPTFePp6ek4ceKELho1NTW4/fbbpSDp//7v/9Y8BAHA/fffj3Xr1kk/d3Z2Ijc3F1dccYVXRfqCw+HA1q1bcfnllyMqKipgOmqI1FN/qN8ohkLf4Dh8fqYaTb3dyIiNx8VjCoIKoBYEAR8c/ALfPvkhnCCq1a9fWnhTQL29RoK+I8kGmb5HDm2m76GlbZS+6Y2OL4T1QcgIzJ49W/fVGQBER0cjOjraY5zneSkojOM48DwPURQVGWha4/JgMjkdnufBcRwEQfD4LMCzs6+3cbPZrMojIUTxvL+8A0BUVBRMJpOHHBzHqcqqVyZCCMxmM8xmMzhOGRVjMpk0edcjE/08yrveedIjEyEEJpMJ79efxF37NyvrCsUl4vHZ1+Dagike86RHJkIIJqRk4P8W3Ii7DmxGQ08H+IEjUK41CX+ctQKrC6f6ZXtymeg8Up0Ha3tUJkqH53npM4K1PTpOP4fatxG2J39eTlvvPOnlXWtdBmp7FLSir5y2N1n9kQlQX/OB7HvuMtE1r/blFqjt0XE5bcpPoLy7j1MeKH0jbI+Oy9dlVFSUYbbnTpv+N1jbo7zLacvtMBjbk/NOP4vyEYjt6T2ghfVBKDU1FSaTySO4ubm5GRkZGSH97GeeeQbPPPOMZAQVFRWIj48HACQmJiIzMxPNzc3o6BgseJeamorU1FTU19fDZrNJ4xkZGbBarRIdOjk5OTmIj49HRUWFwhgKCwthNptRVlam4Km0tBROpxNVVVXSGM/zGDt2LLKzs1FZOZhJZLFYUFRUhI6ODjQ1NUnjVqsVubm5aG1txdmzZ6VxbzKNHTsWdXV1HjIlJSWhuroa/f390riRMtlsNpw+fTogmeSL15950ivT8fZmfO/Eh+gmTqyJzR0UiAA3bH8Jr86/GROFmIBlmhWd4qp+XXYY7a2tiDdHIy8+GckxSUHLVFlZafg81dTUAHDZd2xsrGG2l5qaKtGg9m2k7VE7obSNsD25TAkJCYp1aYTt0XGqb/lmb9R6Gjt2LM6ePevXPPkjk8lkwqlTp0KyR5hMJrS3txtie1QmaiednZ1ITU0Nyb5XXV1tqO3JZaqsrDTM9qhM1K7pf43cy9va2gAM2negtkf3JV8I6xghAJgzZw5mz56NP/3pTwBcp828vDzccccdUrB0KNHZ2YnExES0trZKV2OBnE6dTifef/99LF26VHobMtIj1N3djdjYWMmzYqRHqLe3F7GxsR6faYRHqLe3F1ar1eMzg30rdzgc2LJlC6688krDPUJOQcC8t5/El7YWiHC13JDDCYI8axLKrv2Z4ppMr0eop6cHVqsVJpMp4DdYNZlEUURPTw/i4uJgMpkM9QjZ7XZs2bIFS5cuhcViMdQjJAgCbDYb4uLipDGjPEKEEHR3d0u09c6THt45jkNXV5eCtlEeIUEQ8MEHHyj2Ez3zpNcjpLbmjfII9fb2Ij4+3q/9TY9MdO2MGjXK4/lgPUJ0P1m+fDksFovhHiG6Ls1ms6EeIfmap94VozxCgiBItOXeWyM8Qna7HR9++KFk34HaXnt7O5KTk8M/Rqi7uxvl5eXSz1VVVTh06BBSUlKQl5eHdevWYe3atZg5cyZmz56NJ598EjabTcoiGyqYTCYPN5vcbaxnXIuOlvtO77ggCKivr0dpaanH77Tcg3p5FwQBp0+fVqXtjY4e3r3x7Y13PTLJF5e/8+RLpp1NFSgVY/AVOIggqtldtbZ2fHa2xqONhy+ZBEFAQ0MDSktLDeWdbjqUtvxL35usesblMsmvU4K1PTko33J6wdgehSiKqrSDsT0K+VwGu3e4/z21b7X9RO15b7y7jwe65vWM+1rzWrxrjct5d9e3kbxTfdN1Y4Tt0XH3NW+E7dFx+ZqnzwVre3J+1OzbyL3cfR6N2g/dMewHof3792PJkiXSzzRQee3atXj++efxzW9+E2fOnMGvf/1rNDU1Yfr06fjwww89AqhDDUEQpJNxMDFCgiAoDNKIt3IAijgNOS/BvpXTv9WKrwjmzUgQBCmI3f35YN/K5fSCeYNVk6mhuwM8BoOX1TxCHID67nYFH3pkEgRBepMz2iNEaVMbDEWMkCAIhscIUX3I45CM9AjJactlCvatHNBel8G+lcvtXL6/GPFWrrXmjfAI0TVP/1+OYD1CctpG2p58DukzRnqE5OvSyPg0d9pG2Z7cI+S+LtVkDSZGSL5XBWp7ejDsB6HFixd7XIu444477sAdd9wxRBy5EEkxQsXFxXA4HCgvL5eM0agYoeTkZACuN/Le3l6FTMHGadDf9/f3o7a2ViFTOMcIOZrPYaI5EaO4JnQShzJGCMCG3jpYOTMcjWdRJpT5JZMoimhtbUVDQwPy8/MDjmlQk6mvrw+tra0oLy9HXl5exMQINTQ0SHzzPG9ojFB/f7+CthG2R2VKS0uDzWZTrMtIiBGiV2Ktra1SrIaeedIjkyiKUhE+o+MIRVGU+DLK9oYiRoiu+aqqKowbN87QGKG2tjbJvtPS0gyNESovL1esHRYjNIIRCTFCHMehqqoKeXl5imsJI97KCSGora1FXl6e9JYr5z2YNyNRFFFbW4uCggK4I5xjhF4tO4hXDu7ER/YmOEA0PUIvzbsBNxRf4JdMoiiipqYGBQUFMJvNhnuEampqkJ+fb3jWWChjhJxOJ6qrq5Gfny8dVozyCImiiKqqKom23nnSwzsAzXUZ7Ft5KGOEtNa8ER4huuYLCws9XoCD9QjRtVNUVOThDQjnGCHKd35+vuFZY/I1b3TWmNPplGjTdalnnvTIdN7FCEUKwjlGCICrpo0KjIjTKCoqUn3WGx09vJtMJk2+gfCNEcpOTMZ79kZpXC1GiADIHpWkO2aLjptMJpSUDMYVGcU73ajktOUyuSOcYoTMZrMH396e94d3d31TGBWnoWXfgdoeBbXvUMQIAYGteT3jvtY8fUbvuLvtyecyUmKE3Pk2MkZIbc0Ha3sUUVFRqmuHxQiNYIRzjBDP82hvb8eoUaOkhWqURwgAurq6pEwM+WcG+1ZOCEFXVxcSExM9PjOcY4QuHp2HedZMfGFrhADtrLG5qfl+x54QQiQvJDgOO5sq0NTThYzYeMxLK4RZ461Oj0yiKKKzsxMJCQkwmYzNGgtljJAgCNIbHR0zMkaovb1doq13nvTwznEc2traFLQjIUYIUF/zRniE6JpPSkrya3/TIxNdO/Q630iPUChjhCjfCQkJIckao7Tpwcgoj5AgCBJt+plqsrIYoQhGpMUI1dXVScXbAGNjhNra2tDR0RGyGKHo6OiIihESRRE/TpmE/9dzDp3EgevcYoTe7K3DExdcjcqKCr9lEkVXvMCZWA53ln+CpH5gclQiAODVqBgsLZmK1dMuCipGiGZkRkqM0OnTp1FXV4eUlBTwvLExQna7HceOHZNoG2F7VKa0tDRUVlZKqct65ykcYoR6e3tht9tDFiOUkJAQshih2bNno6urK+JihMaMGROyGKGUlBTDY4ROnTol0eZ5FiM0ohEJMUIAcOrUKUWpc6M8QqIoSmXU3d88g30rpyXa5encFOEcIyQIAsrLy3Ei2uFRWZpWfw60srQgCHjvwGe4+cT76IUIHpAqS3NwXbm9tuRWrMqb5LdMTqcT5eXlKCkpke7dIyFGyOFwoKysDCUlJZK3ySiPkCAIOHXqlERb7zzp4Z0Qorkug30rD2WMkNaaN8IjRNf82LFj4Y5gPUJy2nKvQiC8D2WMEN1PSkpKYLFYDPUIydc8fVE2yiNEE3Tk61LPPOmRicUIhSnCOUaIpkaq0TYqToPneb/o6OWdXiEYea8MhDZGiD6zsmAyVhZOwa7mSjT2diEzdhQWpBdJRRQDkUkQRXzYcAqOgbgjEYAoi0HiANy9dxNW5k3ye17pZkWvxbR49Hc81DFC1FOjN17AX97VaBsRp+FtXQZje0DoY4QoL0bG2cg/T4tHf8fdeZdfQUZKjBClJz8sGxUjJF/z9LlgbU8+rrZ2WIwQw7CA4zhYrVYPr8r5TDuUkPPN87xH0UQ1CKKoeWCS49OWKpzqa9ekQwDU2dqxq7lS1+dq8R1JiFQbZPoeObRDiUjVSaTqWw3sIKQT4RwsbTKZkJOTI7lZ5bwYcT2Rm5uroC3nPVgXMY11iKSCigCQlZUlXX/4mqdNNUdx777NqO5pBwfABM7VnHXWNVhVMFkhU1NvN3b3nxmkhcGrMcB1EBJA0NjTGVChvqysLBDiKmJp5NVYKIOlqb7p5xh5NcZxnIK2XCYjrieys7MVtI26GgtlsLTWmjfiagxwrXkjbU8+np2dbajt0fFQBksDg/ZNP8OoqzH5mhdF0dCrMTltuR0acTUmv+6kfARqe3rADkIaiKRg6ZKSEtTX16O7u1s6nRsVLE0D4Ww2m+HB0oQQjB49GqNGjVIEtfF8eAdLE+LqlzRhwgRYLBav83S8vRlvVH+FGSQe1WhHOh+DxdFpAAHe2LsdXGsnrp05X5IpqasXP7SW4rCjHdv6WzDRnCgFSwNAhbMb+xytSLVD8bl6ZLLb7VIPqdzc3IgJlq6rq8O5c+ekXnpGF1Q8fvy4RNsI26Mypaeno6ysDKIoSusyUoKlrVYrRNEVxKt3nvTIRAhBfHw8srOzDQ+WJoTA6XRi0qRJ6OzsjJhgabqfWK1Ww4Ol29vbpTU/ZswYw4OlKW2O41iw9EgGC5ZmwdLuMtHgxrFjx8JkMmnOk8PpxLiNj+J0j2vh0kKLJlnwc7Y1CeVr7gc/8Ln9DgfWvfciXugs9wiWpsi0JqJi9X3gZTrTIxMLlmbB0npk0lrzRniEWLC05zgLlmbB0hEDFizNgqXdg/a88Q4An52tQXVPu2KMQFmAsdrWJsX7mEwmWABckT0O/+gsAwdlsDQ99jw5eyWizOpL19f80f/SgycLlmbB0t5kYsHSLFj6fAiW1vcUAwOD32js7QrouQlJ6Xh10S3IjktUjOdYk7BhyVqsLphiGI8MDAwM5zuYR2gEgOM4JCYmelwvnc+0Qwm9fGfGjvL6e7XnKO1V6elYWTBZV6aZ0XyHGyLVBpm+Rw7tUCJSdRKp+lYDOwjpRLhnjWVkZCiyPIyKEeI4DpmZmR4ZJEbFaWRkZEh6cZcpnLPG0tLSpDgQrXmam5qPgrgk1Pd0SFdiajFCC9KLFHTS0tJcOuB5LBz4HQDAS+aHXpnS0tIiMmuM8h2KrDE5bblMRsRppKenR2TWmNqaNyJGCHCteSNtTz6enp5uqO3R8VBnjVEbpJ9hVIyQfM1r7R2Bric5bZY1NkIRaVljNTU16Ovrk07nRmaNCYKA/v7+kGSNJSQkICUlJeKyxrq7uzF58mSfWWPr8xfg9eqv4CAi3uw7PZg1NoBvFF0IE+/qFdfU1CTRTktLQ35+fsBZLmoy2e12dHd3Iz4+PuKyxlpaWhAfHw+OMz5r7MiRIxJtI2yPypSeno4TJ05IsWR65ykcssYsFgtMJlNIssZiYmKQn58fkqwxu92OqVOnRlzWWHd3NxISEkKSNUbXfCiyxihtjmNZYyMaLGuMZY25y6Q3a4yOq9URyrUm4Y8zV3jUEaK0S0tLERUVFfAbrJpMLGuMZY3pkUlrzRvhEWJZY57jLGuMZY1FDFjWGMsa8zdrjI6vLprqM95HTofneYkHo3in80f/Sw+eLGuMZY15k4lljbGssfMha4wdhBgYhgAmXl8rDgYGBgaGoQVLnx8B4DgOqampHtdL5zPtUCJSdcL0PXJohxKRqhOm75FDe6jBPEIjADzPIzU1ldEeIkSqTpi+Rw7tUCJSdcL0PXJoDzXYQUgnwjl9nuM4nD59GpmZmYr4DCMCVgkhaGxsRGZmpuLkb0TAqiiKaGxsRHZ2NtwRzunzoiiioaEBOTk5HkGZWrLqlYnSzs7OBsfz2NlUgaaeLmTExmNeWiHMA/fygcgkCAIaGhqQlZUFs9lsaLB0KNPnnU4n6uvrkZWVJcULGRUsLYoiTp8+LdHWO096eAeguS6DDVgNZfq81po3IliarvmcnBzFs9541ysTXTu5ubnS5wbKu/t4KNPnKd9ZWVmIiooyNFhavuZNGntHoOvJ6XRKtOVxjUYES8sD4CkfgdqeHrCDkAYiKX2+uLhYSpOkxmhU+nxycjJsNhvq6+sNT5+nv7fb7aitrVXIFM7p86LoakY5ZswYREdHB5zuqyYTpX3w7GncWf4JkvohNV19NSoGS0umYvW0iwKSqa+vD62trbDZbMjLy4uY9Pn6+nrU1dXBZrOB53lD0+ftdruCthG2R2VKS0tDS0uLYl1GSvp8b28vzp07J6Ux650nXzLRTKZQNF0VRREdHR3IycmJqPR5uub7+voMT59va2uT1nxaWpqh6fNlZWUSbZ7nWfr8SAZLn2fp8+4y+Zs+749MgiDgvQOf4eYT73s0XeXg6lX22pJbsSpvEkufN+CtnKXPs/R5PeMsfd6Td5Y+fx6Cpc+z9PlA0+f18E7HBVHEhw2n4BhotCpisOkq4DoM3b13E1bmTQoqlZYePFn6PEuf9yYTS59n6fPnQ/o8yxobAaDXBXon/XygHUrI+RZEEdsby/FK5ZfY3lgOQeedtBY+PVON/9jqFYcfOQiAOls7djVXBsV3JCFSbZDpe+TQDiUiVSeRqm81MI/QCADHcUhKSmK0hwiU743Vh3HXnrdxumfwzjonLhFPzVkVcIf4pr5uVAo2n8/p7WwvR6Trm9EeGkSqTpi+Rw7toUbkH+UYIIoiKisrdUfInw+0QwlRFPHW/t24YduLikMQANT3dGDNthewsfpwQLQzoq1YHp0JM4zpbC9HJOs7Em2Q6Xvk0A4lIlUnkapvNbCD0AgAIQT9/f0e6ajnM+1QwikI+LDmmOrlFR27e++mgK7J5qUVIjd6lOYxiAOQO9Cx3l9Eqr4j1QaZvkcO7VAiUnUSqfpWAzsIMTD4iU9bqtDp6NP8fTBxPCaex7LscQDgcRiiPz85e6WiTxkDAwMDQ+BgMUI6Ec4FFQEoin7JeTEifV6LFyPS5wkhHrwD4V1QscnWBR6DBxP3aywnCDgAjbZOBR960+fHJYzBqwu+hbsObEZDT4eUPp9rTcIfZ63A6oIpAckkCIL0X6NsbygKKoqiKPHtzzzpkUmud3eZgk1hBrTXZbApzKEsqKi15o1Kn1dbo9541yuTnLaRtiefQ/qM0enz9L9G2R4dl9M2yvYo73La3mRlBRUjGJFUULG0tBSjR49GRUWFtAEbVVBx9OjRyMnJQWNjI3p6ehQyBVvUjhCC7OxsOJ1OVFdXK2QK54KKSV19iOPMsHJmdBMn1sTmKuZpQ28drJwZyW19KHOW+SUTIQROpxMz45NRff0vsK3sMNpbWxFvjkZefDKSY5IClslut8PpdKKiogK5ubkRU1CxsbFR4pvjOEMLKjqdTgVtI2yPypSRkYGYmBjFuoyEgopxcXHIyclBe3s7zp07p3ue9MhECMHo0aPB8zzKysoMsT0qE/0i5Hne0GKeoS6oSNd8dXW1YbZHZWpvb5fse8yYMYYWVKyoqFCsHVZQcQQjEgoqGv0WYaT3ZLhkCmlBRVHEuI2PoranHSI8PUICCHKtSSi79meKK6yRPE+hLKgYabY3FDKFsqAim6ehLag4XDK58x5OMrGCimGKcC+oSCvBGl1QkVbeVaPtjY4e3gVBQFlZmSbtYAqLyReXv/OkR6b1BQvxzWPvgIDA6VbwEACemL0SFtkXlC/e6bh8Lo3kned5BW3qoYiEgoqEEFX7Dsb2KLTWTjC254u2N971ykTtOxQFFQNd83rGfa15Ld61xuW80wrNlHakFFR0X/NG2B4dl9OmzwVre3Ko2TcrqMgwbNB7F3o+0Q4lJiSm4dVFtyA7LlExnmNNwoYlawOuIwQwfashUnXC9D1yaIcSkaqTSNW3O5hHiIEhQKzMn4SVBZOxq7kSjb1dyIwdhQXpRSyji4GBgSGCwA5CDAxBwMTzWJxZMtxsMDAwMDAECPbqOgLA8zwKCwt134eeD7RDiUjVCdP3yKEdSkSqTpi+Rw7toUbkS8AAADCbQ+fci1TaoUSk6oTpe+TQDiUiVSdM3yOH9lCCHYRGAERR9KjJcb7TDiUiVSdM3yOHdigRqTph+h45tIca7CDEwMDAwMDAcN6CHYQYGBgYGBgYzluwgxADAwMDAwPDeYuREek0BAjnpqs8z6OkpETRHNCosuyAqy8O5V3+mcGWZSeEoKSkRPX5cG66SghBUVEROI7z4EVLVr0yUdr+8q5XpqKiIhDianQbKU1XAUh8y5swGtESgOM4BW25TEa0OSguLlZdl8G2OQhl01VAfc0b0bqBrnla9ViOYFs3EEKkCsqR1HRVvi7pZxjZYoPSFkXRENujvMtpy+3QqLYhAGu6OuyItKarnZ2daG5uDknT1YSEBDQ3N4ek6WpBQQE4jouopqt04ZeUlCAqKirgJpFqMlHaCQkJyMvLC7hJpJpMdrtdOqhEUtPV+vp6dHZ2wmQyGd501eFwoLy8XKJthO1RmTIyMtDU1ITu7u6Ia7qanp6Ozs7OkDRdTU9PR3JysmG2J2+6ajKZUFpaGnFNVwVBgMViCUnTVbrmjW66WlZWJtFmTVdHOCKh6SoAj95ARnmERFH06FUj5z2YNyPaB6e0tFT6oqAI66arAz2Nxo4dC5PJZKhHiNIuLS1FVFSUoR4hp9OJ8vJy6QAXKU1XHQ4HysrKUFJSInmbjPII0b5alLbeedLDOyFEc10G+1YeyqarWmveCI8QXfNjx46FO4L1CMlpy70KgfA+lE1X6ZovKSmBxWIx1CMkX/Nms9lQjxB9iZCvSz3zpEcm1nQ1TBHuTVdp8zqjm67Kx41uukr587chXzg0XaULTYsX9+d98S4f53le4sEo3un80f9GUtNVqg+9DRj95V2NtlFNV7XWZTC2B4S26aqcF6ObrtLP0+LR33F33iltI20PCG3TVUpPflg2qumqfM0Huqd4411t7bCmqwwMDAwMDAwMEQR2EBoh0HvyPZ9ohxKRqhOm75FDO5SIVJ0wfY8c2kMJdjU2AmAymVTv3M9n2qFEpOqE6Xvk0A4lIlUnTN8jh/ZQY2Qc585zEELQ3d3tkfZ+PtMOJQLhWxBFbG8sxyuVX2J7YzkEjbROpm9PRKpOmL5HDu1QIlJ1Eqn6VgM7CI0AiKKI06dP666ZcD7QDiX85Xtj9WEUvPE7LPnwWdy0499Y8uGzKHjjd9hYfTho2v7gfNH3+UA7lIhUnTB9jxzaQw12EGJgCCE2Vh/Gmm0v4HRPh2K8vqcDa7a9oHoYYmBgYGAYOrCDEANDiCCIIu7a8zbUHMd07O69mzSvyRgYGBgYQg92EBoB4DgOFovFoyjh+Uw7lNDL967mSg9PkBwEQJ2tHbuaK/2mHQhGur7PJ9qhRKTqhOl75NAearCssREAnucV/akY7dBCL9+NvV266MmfY/r2RKTqhOl75NAOJSJVJ5GqbzUwj9AIACEE7e3tIcsMiETaoYRevjNjR+miJ3+O6dsTkaoTpu+RQzuUiFSdRKq+1cAOQiMAoiiiqakpZJkBkUg7lNDL94L0IuTEJULLccwByLUmYUG6sts807cSkaoTpu+RQzuUiFSdRKq+1cAOQgwMIYKJ5/HUnFUA4HEYoj8/OXslTCOkOisDAwNDJILtwAwMIcTqginYsGQtsuMSFeM51iRsWLIWqwumDBNnDAwMDAwAC5YeEeA4DlarNWSZAZFIO5Twl+/VBVOwMm8SdjVXorG3C5mxo7AgvUjVE8T07YlI1QnT98ihHUpEqk4iVd9qOG8OQj09PZgwYQKuv/56/PGPfxxudgwFz/PIzc1ltIcIgfBt4nksziwJCW29OJ/0PdJphxKRqhOm75FDe6hx3lyN/e53v8NFF1003GyEBKIo4uzZsyELiItE2qFEpOqE6Xvk0A4lIlUnTN8jh/ZQ47w4CJWVleHEiRNYvnz5cLMSEhBCcPbs2ZClSEYi7VAiUnXC9D1yaIcSkaoTpu+RQ3uoMewHoZ07d2LFihXIysoCx3F4++23PZ555plnUFBQgJiYGMyZMwd79+716zN+/OMf4+GHHzaIYwYGBgYGBoaRgmE/CNlsNkybNg3PPPOM6u9fe+01rFu3Dg888AAOHjyIadOmYenSpWhpaZGemT59OiZPnuzxr6GhAZs2bcLYsWMxduzYoRKJgYGBgYGBIUIw7MHSy5cv93pltX79etx22234zne+AwB49tln8d577+Gf//wn7rvvPgDAoUOHNP/+iy++wKuvvoo33ngD3d3dcDgcSEhIwK9//WvV5+12O+x2u/RzZ2cnAMDhcMDhcPgrngT6t8HQ0IIoioiPj4fT6TT8vjZSaTN9Dy1tpu+hpc30PbS0mb6HlrZR+tb79xwJows+juPw1ltvYdWqVQCA/v5+xMXFYcOGDdIYAKxduxbt7e3YtGmTX/Sff/55HDlyxGvW2IMPPoiHHnrIY/zll19GXFycX5/HwMDAwMDAMDzo6enBTTfdhI6ODiQkJGg+N+weIW84e/YsBEFAenq6Yjw9PR0nTpwIyWfef//9WLdunfRzZ2cncnNzccUVV3hVpC84HA5s3boVl19+OaKiooxgVYIoijhz5gzGjBkD3uAqxZFKm+l7aGkzfQ8tbabvoaXN9D20tI3SN73R8YWwPggZjW9/+9s+n4mOjkZ0dLTHOM/z0mRzHAee5yGKoiJiXmtcbiRyOjzPg+M4CILg8VkAPNyN3sa7urqQlpbmwSMhRPG8v7wDQHd3N9LT0z3k4DhOVVa9MhFC0NXVhYyMDI+iXCaTSZN3PTLRz4uKipJo+ZJVr0yEEHR2diIjIwMmk0n3POmRidJOT09HVFSU7nnSK1NnZyfS0tJgNpsNsT0qE6XD8zxMJpMhtkfHHQ6HxDddP8HaHh0XBEFBW+886eVda10GansUZrNZ+r37ulST1R+ZAPU1H6ztAYNrPjMzE+4I1PbouJw25SdQ3t3HKQ9ms1l1XQazl8vXZVRUlGG2506brstgbY/yrrYu9cyTXpnoZ1E+ArE9k8kEPQjrg1BqaipMJhOam5sV483NzcjIyAjpZz/zzDN45plnJCOoqKhAfHw8ACAxMRGZmZlobm5GR0eHgt/U1FTU19fDZrNJ4xkZGbBarRIdOjk5OTmIj49HRUWFwhgKCwthNptRVlam4Km0tBROpxNVVVXSGM/zKC4uhsPhQHl5uWSMFosFRUVF6OjoQFNTk/S81WpFbm4uWltbcfbsWWlcS6bk5GQAQENDA3p7exUyJSUlobq6Gv39/dK4PzLR3/f396O2tlYh09ixY2Gz2XD69Glp3B+Z5IvXn3nSI5MoimhtbUV/fz+io6N1z5MemSjthoYG5Ofn654nPTL19fWhtbUV5eXlyMvLM8T2qEw1NTUAXPYdGxtriO1RmRoaGiS+eZ43xPaoTP39/QraRtgelSktLQ02m02xLoO1Pfk41bd8sw/G9ihiY2MBAK2trWhra9M9T3pkEkURTqdT4t0I26MyiaIo8WWU7VGZ6H7S2dmJ1NRUQ2yPykTXfFVVFcaNG2eI7VGZ2traJPtOS0szxPaoTOXl5Yq1Y4TtUZmo3VH7DtT26L7kC2EdIwQAc+bMwezZs/GnP/0JgMvY8/LycMcdd0jB0qFER0eHZCT0aiyQ06nT6cRHH32ESy+9VHL1GeURAoDy8nIUFhZKm6JRHiFRFFFVVYXCwkLDPUKCIKCqqgrFxcWGe4QcDgc+/vhjXHHFFYZ7hARBQGVlJUpKSgz3CFHaxcXFhnuEnE4nKisrUVRUhKioKEM9Qna7HR9//DEuvfRSWCwWwz1CFRUVKCoqkt5qjfQIlZeXS7T1zpMe3gkhmusy2LdyQRCwdetWxX6iZ570yKS15o3wCNE1X1LiWWU9WI+QnLbRHiG6n1x++eWwWCyGeoTomi8qKoLFYjHUIyRf82az2XCPEKVN16WeedIjk91ux3/+8x/JvgO1vfb2duTn56O9vR2Jicp+j3IMu0eou7sb5eXl0s9VVVU4dOgQUlJSkJeXh3Xr1mHt2rWYOXMmZs+ejSeffBI2m03KIgs1urq6AAAFBQVD8nkMDAwMDAwMxqGrq8vrQWjYPULbt2/HkiVLPMbXrl2L559/HgDwv//7v3jsscfQ1NSE6dOn4+mnn8acOXOGhD9RFNHQ0IBRo0YF1VyOBl3X1dUFFXSthVmzZmHfvn2G041U2kzfQ0ub6XtoaTN9Dy1tpu+hpW2UvmncWFZWlsK76Y5h9wgtXrzYZ4nuO+64A3fccccQcaQEz/PSfbwRSEhICMlCMplMIaEbybQBpu+hpA0wfQ8lbYDpeyhpA0zfQ0kbMEbf3jxBFMNeWZrBGPzoRz9itIcQkaoTpu+RQzuUiFSdMH2PHNpDiWG/Gjtf0NnZicTERJ+FnRiMAdP30ILpe2jB9D20YPoeWgy1vplHaIgQHR2NBx54QLVGEYPxYPoeWjB9Dy2YvocWTN9Di6HWN/MIMTAwMDAwMJy3YB4hBgYGBgYGhvMW7CDEwMDAwMDAcN6CHYQYGBgYGBgYzluwgxADAwMDAwPDeQt2EBoCPPPMMygoKEBMTAzmzJmDvXv3DjdLIwIPP/wwZs2ahVGjRiEtLQ2rVq3CyZMnFc/09fXhRz/6EUaPHo34+Hhcd911Hk18GQLDI488Ao7jcPfdd0tjTN/Gor6+Ht/61rcwevRoxMbGYsqUKdi/f7/0e0IIfv3rXyMzMxOxsbG47LLLPBp8MuiDIAj41a9+hcLCQsTGxqK4uBi/+c1vFAV/mb4Dx86dO7FixQpkZWWB4zi8/fbbit/r0W1raytuvvlmJCQkICkpCd/73vfQ3d0dNG/sIBRivPbaa1i3bh0eeOABHDx4ENOmTcPSpUvR0tIy3KxFPHbs2IEf/ehH+OKLL7B161Y4HA5cccUVii7E99xzD9555x288cYb2LFjBxoaGrB69eph5HpkYN++ffjrX/+KqVOnKsaZvo1DW1sb5s2bh6ioKHzwwQc4duwYHn/8cSQnJ0vP/OEPf8DTTz+NZ599Fnv27IHVasXSpUvR19c3jJxHJh599FH85S9/wf/+7//i+PHjePTRR/GHP/xBavgNMH0HA5vNhmnTpuGZZ55R/b0e3d588804evQotm7dinfffRc7d+7E7bffHjxzhCGkmD17NvnRj34k/SwIAsnKyiIPP/zwMHI1MtHS0kIAkB07dhBCCGlvbydRUVHkjTfekJ45fvw4AUA+//zz4WIz4tHV1UVKS0vJ1q1byaJFi8hdd91FCGH6Nho/+9nPyPz58zV/L4oiycjIII899pg01t7eTqKjo8krr7wyFCyOKFx11VXku9/9rmJs9erV5OabbyaEMH0bCQDkrbfekn7Wo9tjx44RAGTfvn3SMx988AHhOI7U19cHxQ/zCIUQ/f39OHDgAC677DJpjOd5XHbZZfj888+HkbORiY6ODgBASkoKAODAgQNwOBwK/Y8fPx55eXlM/0HgRz/6Ea666iqFXgGmb6OxefNmzJw5E9dffz3S0tJwwQUX4LnnnpN+X1VVhaamJoW+ExMTMWfOHKbvADB37lx8/PHHOHXqFADgq6++wu7du7F8+XIATN+hhB7dfv7550hKSsLMmTOlZy677DLwPI89e/YE9fnD3nR1JOPs2bMQBAHp6emK8fT0dJw4cWKYuBqZEEURd999N+bNm4fJkycDAJqammCxWJCUlKR4Nj09HU1NTcPAZeTj1VdfxcGDB1U7TjN9G4vKykr85S9/wbp16/Dzn/8c+/btw5133gmLxYK1a9dKOlXbX5i+/cd9992Hzs5OjB8/HiaTCYIg4He/+x1uvvlmAGD6DiH06LapqQlpaWmK35vNZqSkpAStf3YQYhgR+NGPfoQjR45g9+7dw83KiEVdXR3uuusubN26FTExMcPNzoiHKIqYOXMmfv/73wMALrjgAhw5cgTPPvss1q5dO8zcjTy8/vrr+Pe//42XX34ZkyZNwqFDh3D33XcjKyuL6XuEg12NhRCpqakwmUweWTPNzc3IyMgYJq5GHu644w68++672LZtG3JycqTxjIwM9Pf3o729XfE8039gOHDgAFpaWnDhhRfCbDbDbDZjx44dePrpp2E2m5Gens70bSAyMzMxceJExdiECRNQW1sLAJJO2f5iDH7yk5/gvvvuww033IApU6bglltuwT333IOHH34YANN3KKFHtxkZGR5JRk6nE62trUHrnx2EQgiLxYIZM2bg448/lsZEUcTHH3+Miy++eBg5GxkghOCOO+7AW2+9hU8++QSFhYWK38+YMQNRUVEK/Z88eRK1tbVM/wHg0ksvxeHDh3Ho0CHp38yZM3HzzTdL/8/0bRzmzZvnUQ7i1KlTyM/PBwAUFhYiIyNDoe/Ozk7s2bOH6TsA9PT0gOeVX4kmkwmiKAJg+g4l9Oj24osvRnt7Ow4cOCA988knn0AURcyZMyc4BoIKtWbwiVdffZVER0eT559/nhw7dozcfvvtJCkpiTQ1NQ03axGP//qv/yKJiYlk+/btpLGxUfrX09MjPfODH/yA5OXlkU8++YTs37+fXHzxxeTiiy8eRq5HFuRZY4QwfRuJvXv3ErPZTH73u9+RsrIy8u9//5vExcWRf/3rX9IzjzzyCElKSiKbNm0iX3/9NVm5ciUpLCwkvb29w8h5ZGLt2rUkOzubvPvuu6Sqqops3LiRpKamkp/+9KfSM0zfgaOrq4t8+eWX5MsvvyQAyPr168mXX35JampqCCH6dLts2TJywQUXkD179pDdu3eT0tJScuONNwbNGzsIDQH+9Kc/kby8PGKxWMjs2bPJF198MdwsjQgAUP33f//3f9Izvb295Ic//CFJTk4mcXFx5NprryWNjY3Dx/QIg/tBiOnbWLzzzjtk8uTJJDo6mowfP5787W9/U/xeFEXyq1/9iqSnp5Po6Ghy6aWXkpMnTw4Tt5GNzs5Octddd5G8vDwSExNDioqKyC9+8Qtit9ulZ5i+A8e2bdtU9+u1a9cSQvTp9ty5c+TGG28k8fHxJCEhgXznO98hXV1dQfPGESIrm8nAwMDAwMDAcB6BxQgxMDAwMDAwnLdgByEGBgYGBgaG8xbsIMTAwMDAwMBw3oIdhBgYGBgYGBjOW7CDEAMDAwMDA8N5C3YQYmBgYGBgYDhvwQ5CDAwMDAwMDOct2EGIgYEhLPD222+jpKQEJpMJd99993CzE3Js374dHMd59GbT8+zzzz+PpKQkr3/z4IMPYvr06UHzycAw0sG6zzMwMIQFvv/97+M73/kO7rzzTowaNWq42Qk55s6di8bGRiQmJhr6LAMDg39gByEGBoZhR3d3N1paWrB06VJkZWWpPiMIAjiO82iMGamwWCy6u2b78ywDA4N/GBk7CgMDg99YvHgx7rzzTvz0pz9FSkoKMjIy8OCDD0q/r66uBsdxOHTokDTW3t4OjuOwfft2AINXNlu2bMEFF1yA2NhYXHLJJWhpacEHH3yACRMmICEhATfddBN6enpU+di+fbvkAbrkkksk+vT6Z/PmzZg4cSKio6NRW1uLffv24fLLL0dqaioSExOxaNEiHDx4UEGT4zj89a9/xdVXX424uDhMmDABn3/+OcrLy7F48WJYrVbMnTsXFRUVir/btGkTLrzwQsTExKCoqAgPPfQQnE4nAIAQggcffBB5eXmIjo5GVlYW7rzzTlWZTp06BY7jcOLECcX4E088geLiYoXu6HVXTU0NVqxYgeTkZFitVkyaNAnvv/++6rMUb7/9NkpLSxETE4OlS5eirq5OlR+Kv//975gwYQJiYmIwfvx4/PnPf/b6PAPDeYGgu5UxMDBEJBYtWkQSEhLIgw8+SE6dOkVeeOEFwnEc+eijjwghhFRVVREA5Msvv5T+pq2tjQAg27ZtI4QMNlK86KKLyO7du8nBgwdJSUkJWbRoEbniiivIwYMHyc6dO8no0aPJI488osqH3W4nJ0+eJADIm2++SRobG4ndbif/93//R6KiosjcuXPJp59+Sk6cOEFsNhv5+OOPyUsvvUSOHz9Ojh07Rr73ve+R9PR00tnZKdEEQLKzs8lrr71GTp48SVatWkUKCgrIJZdcQj788ENy7NgxctFFF5Fly5ZJf7Nz506SkJBAnn/+eVJRUUE++ugjUlBQQB588EFCCCFvvPEGSUhIIO+//z6pqakhe/bs8WiCKsfMmTPJL3/5S8XYjBkzpDGqu7a2NkIIIVdddRW5/PLLyddff00qKirIO++8Q3bs2KH6LNXNzJkzyWeffUb2799PZs+eTebOnSt91gMPPECmTZsm/fyvf/2LZGZmkjfffJNUVlaSN998k6SkpJDnn39eUwYGhvMB7CDEwHCeYtGiRWT+/PmKsVmzZpGf/exnhBD/DkL/+c9/pGcefvhhAoBUVFRIY9///vfJ0qVLNXlxp0uI68seADl06JBXOQRBIKNGjSLvvPOONAZAcQj5/PPPCQDyj3/8Qxp75ZVXSExMjPTzpZdeSn7/+98raL/00kskMzOTEELI448/TsaOHUv6+/u98kPxxBNPkOLiYulnetg7fvw4IcTzcDNlyhTp0OUOtYMQAPLFF19Izxw/fpwAIHv27CGEeB6EiouLycsvv6yg+5vf/IZcfPHFuuRhYBipYFdjDAznMaZOnar4OTMzEy0tLUHRSU9PR1xcHIqKihRjgdC1WCwePDY3N+O2225DaWkpEhMTkZCQgO7ubtTW1nrlCQCmTJmiGOvr60NnZycA4KuvvsL//M//ID4+Xvp32223obGxET09Pbj++uvR29uLoqIi3HbbbXjrrbekazM13HDDDaiursYXX3wBAPj3v/+NCy+8EOPHj1d9/s4778Rvf/tbzJs3Dw888AC+/vprr7oxm82YNWuW9PP48eORlJSE48ePezxrs9lQUVGB733vewr5fvvb33pcDzIwnG9gByEGhvMYUVFRip85joMoigAgBSUTQqTfOxwOn3Q4jvNK1x/ExsaC4zjF2Nq1a3Ho0CE89dRT+Oyzz3Do0CGMHj0a/f39XnnSGqN8dXd346GHHsKhQ4ekf4cPH0ZZWRliYmKQm5uLkydP4s9//jNiY2Pxwx/+EAsXLtTUSUZGBi655BK8/PLLAICXX34ZN998s6as/+///T9UVlbilltuweHDhzFz5kz86U9/0qsqr+ju7gYAPPfccwr5jhw5Ih3UGBjOV7CDEAMDgyrGjBkDAGhsbJTG5IHTw4VPP/0Ud955J6688kpMmjQJ0dHROHv2bNB0L7zwQpw8eRIlJSUe/+ihMDY2FitWrMDTTz+N7du34/PPP8fhw4c1ad5888147bXX8Pnnn6OyshI33HCDVx5yc3Pxgx/8ABs3bsS9996L5557TvNZp9OJ/fv3Sz+fPHkS7e3tmDBhgsez6enpyMrKQmVlpYdshYWFvlTDwDCiwdLnGRgYVBEbG4uLLroIjzzyCAoLC9HS0oJf/vKXw80WSv9/O/fPmkgQx2H8e0ELxaAQsNQqgoUpNOrCFsEqCtqIVSCdzRJdFkHshIB9wNb4B7RJHSsR8gZsBN/HQjpBuSuOO66I4SDFwc3zqYcfy1YPM7tzean5fK7r62u9v7+r2+0qFAp9eW6/31e1WlUikVCj0dDZ2Zm22612u50Gg4Fms5mOx6OKxaLC4bAWi4VCoZCSyeTJmfV6XY7jyHEclUqlk1cDSJLneapUKkqlUvJ9X29vbx9GzS/BYFDtdlvD4VCBQECtVkuWZalQKHy4/vHxUa7rKhqNqlwua7/fa7PZyPd9dTqdv39RwH+GHSEAJ00mEx0OB+VyOXmep8Fg8K8fSePxWL7vK5vN6v7+Xq7rKh6Pf3nu7e2tlsulVquV8vm8LMvS09PT79CJxWIajUaybVtXV1dar9d6fX3VxcXFyZnn5+eq1WrabrefHotJP+9Jenh4UDqdVrlcViqV+vT39nA4rF6vp7u7O9m2rUgkopeXl5Prm82mnp+fNZ1OlclkdHNzo9lsxo4QjPft+58fAAAAABiEHSEAAGAsQggAABiLEAIAAMYihAAAgLEIIQAAYCxCCAAAGIsQAgAAxiKEAACAsQghAABgLEIIAAAYixACAADGIoQAAICxfgA7komjXrnZ+AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batch_inference.rhat_keypoint_world_positions_plot(traced, final);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ffbdf7d-02b1-4f84-8b01-eba707387b56", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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/discussion/probabilistic_bundle_adjustment/requirements.txt b/discussion/probabilistic_bundle_adjustment/requirements.txt new file mode 100644 index 0000000000..87d7552a48 --- /dev/null +++ b/discussion/probabilistic_bundle_adjustment/requirements.txt @@ -0,0 +1,23 @@ +# Copyright 2024 The TensorFlow Probability Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +jax >= 0.4.31 +jaxlib >=0.4.31 +matplotlib == 3.9 +ipywidgets == 8.1 +mediapy == 1.2 +fun_mc @ git+https://github.com/tensorflow/probability.git#egg=fun_mc&subdirectory=spinoffs/fun_mc +plotly == 5.23 +pythreejs == 2.4 +tqdm == 4.66 +tfp-nightly==0.25.0.dev20240829