diff --git a/docs/conf.py b/docs/conf.py index 56743144b..fa322570a 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -66,6 +66,8 @@ "scikit-sparse": ("https://scikit-sparse.readthedocs.io/en/latest/", None), "scipy": ("https://docs.scipy.org/doc/scipy/reference/", None), "pot": ("https://pythonot.github.io/", None), + "jaxopt": ("https://jaxopt.github.io/stable", None), + "matplotlib": ("https://matplotlib.org/stable/", None), } master_doc = 'index' diff --git a/docs/index.rst b/docs/index.rst index 6b6ab3780..c43dc43ea 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -20,8 +20,9 @@ To achieve this, ``OTT`` rests on two families of tools: :cite:`scetbon:21` algorithms, and moving up towards Gromov-Wasserstein :cite:`memoli:11,peyre:16`; - the second family consists in *continuous* solvers, using suitable neural - architectures :cite:`amos:17` coupled with SGD type estimators - :cite:`makkuva:20,korotin:21`. + architectures such as an MLP or input-convex neural network + :cite:`amos:17` coupled with SGD-type estimators + :cite:`makkuva:20,korotin:21,amos:23`. Installation ------------ diff --git a/docs/problems/index.rst b/docs/problems/index.rst index e37397ac9..228cf67dd 100644 --- a/docs/problems/index.rst +++ b/docs/problems/index.rst @@ -11,3 +11,4 @@ ott.problems linear quadratic + nn diff --git a/docs/problems/nn.rst b/docs/problems/nn.rst new file mode 100644 index 000000000..c004e19d1 --- /dev/null +++ b/docs/problems/nn.rst @@ -0,0 +1,15 @@ +ott.problems.nn +=============== +.. currentmodule:: ott.problems.nn +.. automodule:: ott.problems.nn + +.. TODO(marcocuturi): maybe add some text here + +Dataset +------- +.. autosummary:: + :toctree: _autosummary + + dataset.create_gaussian_mixture_samplers + dataset.Dataset + dataset.GaussianMixture diff --git a/docs/references.bib b/docs/references.bib index 00f86a5bc..14ab4ee66 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -704,6 +704,14 @@ @ARTICLE{chen:20 doi={10.1109/TPAMI.2019.2908635} } +@inproceedings{amos:23, + title={On amortizing convex conjugates for optimal transport}, + author={Amos, Brandon}, + booktitle={International Conference on Learning Representations}, + year={2023}, + url={https://arxiv.org/abs/2210.12153} +} + @ARTICLE{schreck:15, author={Schreck, Amandine and Fort, Gersende and Le Corff, Sylvain and Moulines, Eric}, journal={IEEE Journal of Selected Topics in Signal Processing}, @@ -740,3 +748,29 @@ @article{zou:05 eprint = {https://rss.onlinelibrary.wiley.com/doi/pdf/10.1111/j.1467-9868.2005.00503.x}, year = {2005} } + +@article{jacobs:20, + title={A fast approach to optimal transport: The back-and-forth method}, + author={Jacobs, Matt and L{\'e}ger, Flavien}, + journal={Numerische Mathematik}, + volume={146}, + number={3}, + pages={513--544}, + year={2020}, + publisher={Springer} +} + + +@phdthesis{bertsekas:71, + title={Control of uncertain systems with a set-membership description of the uncertainty.}, + author={Bertsekas, Dimitri P}, + year={1971}, + school={Massachusetts Institute of Technology} +} + +@book{danskin:67, + title={The Theory of Max-Min and its Application to Weapons Allocation Problems}, + author={Danskin, John M}, + publisher={Springer}, + year={1967} +} diff --git a/docs/solvers/nn.rst b/docs/solvers/nn.rst index d4f09c35a..a71744293 100644 --- a/docs/solvers/nn.rst +++ b/docs/solvers/nn.rst @@ -10,12 +10,22 @@ Neural Dual .. autosummary:: :toctree: _autosummary - neuraldual.NeuralDualSolver + neuraldual.W2NeuralDual -ICNN ----- +Models +------ .. autosummary:: :toctree: _autosummary - icnn.ICNN - layers.PositiveDense + models.ModelBase + models.ICNN + models.MLP + +Conjugate Solvers +----------------- +.. autosummary:: + :toctree: _autosummary + + conjugate_solvers.ConjugateResults + conjugate_solvers.FenchelConjugateSolver + conjugate_solvers.FenchelConjugateLBFGS diff --git a/docs/tutorials/notebooks/icnn_inits.ipynb b/docs/tutorials/notebooks/icnn_inits.ipynb index 2e12799a7..0a82ad943 100644 --- a/docs/tutorials/notebooks/icnn_inits.ipynb +++ b/docs/tutorials/notebooks/icnn_inits.ipynb @@ -13,12 +13,12 @@ "source": [ "As input convex neural networks (ICNN) are notoriously difficult to train {cite}`richter-powell:21`, {cite}`bunne:22` propose to use closed-form solutions between Gaussian approximations to derive relevant parameter initializations for ICNNs: given two measures $\\mu$ and $\\nu$, one can initialize ICNN parameters so that they are (initially) meaningful in the context of OT, namely that its gradient is able to approximately map source measure $\\mu$ into a target measure $\\nu$. These initializations rely on closed-form solutions available for Gaussian measures {cite}`gelbrich:90`.\n", "\n", - "In this notebook, we introduce the *identity* and *Gaussian approximation*-based initialization schemes, and illustrate how they can be used within the `OTT` library and its {class}`~ott.solvers.nn.icnn.ICNN`-based {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver`." + "In this notebook, we introduce the *identity* and *Gaussian approximation*-based initialization schemes, and illustrate how they can be used within the `OTT` library when using {class}`~ott.solvers.nn.models.ICNN`-based potentials with the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` solver." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -38,120 +38,13 @@ "import jax.numpy as jnp\n", "import numpy as np\n", "import optax\n", - "from torch.utils.data import DataLoader, IterableDataset\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "from ott.geometry import pointcloud\n", - "from ott.solvers.nn import icnn, neuraldual" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "tags": [] - }, - "source": [ - "## Helper Functions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us define some helper functions which we use for the subsequent analysis." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_ot_map(neural_dual, source, target, inverse=False):\n", - " \"\"\"Plot data and learned optimal transport map.\"\"\"\n", - "\n", - " def draw_arrows(a, b):\n", - " plt.arrow(\n", - " a[0], a[1], b[0] - a[0], b[1] - a[1], color=[0.5, 0.5, 1], alpha=0.3\n", - " )\n", - "\n", - " if not inverse:\n", - " grad_state_s = neural_dual.transport(source)\n", - " else:\n", - " grad_state_s = neural_dual.inverse_transport(source)\n", - "\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(111)\n", - "\n", - " if not inverse:\n", - " ax.scatter(\n", - " target[:, 0],\n", - " target[:, 1],\n", - " color=\"#A7BED3\",\n", - " alpha=0.5,\n", - " label=r\"$target$\",\n", - " )\n", - " ax.scatter(\n", - " source[:, 0],\n", - " source[:, 1],\n", - " color=\"#1A254B\",\n", - " alpha=0.5,\n", - " label=r\"$source$\",\n", - " )\n", - " ax.scatter(\n", - " grad_state_s[:, 0],\n", - " grad_state_s[:, 1],\n", - " color=\"#F2545B\",\n", - " alpha=0.5,\n", - " label=r\"$\\nabla g(source)$\",\n", - " )\n", - " else:\n", - " ax.scatter(\n", - " target[:, 0],\n", - " target[:, 1],\n", - " color=\"#A7BED3\",\n", - " alpha=0.5,\n", - " label=r\"$source$\",\n", - " )\n", - " ax.scatter(\n", - " source[:, 0],\n", - " source[:, 1],\n", - " color=\"#1A254B\",\n", - " alpha=0.5,\n", - " label=r\"$target$\",\n", - " )\n", - " ax.scatter(\n", - " grad_state_s[:, 0],\n", - " grad_state_s[:, 1],\n", - " color=\"#F2545B\",\n", - " alpha=0.5,\n", - " label=r\"$\\nabla f(target)$\",\n", - " )\n", - "\n", - " plt.legend()\n", - "\n", - " for i in range(source.shape[0]):\n", - " draw_arrows(source[i, :], grad_state_s[i, :])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def get_optimizer(optimizer, lr, b1, b2, eps):\n", - " \"\"\"Returns a flax optimizer object based on `config`.\"\"\"\n", - "\n", - " if optimizer == \"Adam\":\n", - " optimizer = optax.adam(learning_rate=lr, b1=b1, b2=b2, eps=eps)\n", - " elif optimizer == \"SGD\":\n", - " optimizer = optax.sgd(learning_rate=lr, momentum=None, nesterov=False)\n", - " else:\n", - " raise NotImplementedError(f\"Optimizer {optimizer} not supported yet!\")\n", - "\n", - " return optimizer" + "from ott.problems.nn import dataset\n", + "from ott.solvers.nn import models, neuraldual\n", + "from ott.tools import plot" ] }, { @@ -165,75 +58,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To test the ICNN initialization methods, we choose the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` of the `OTT` library as an example. Here, we aim at computing the map between two toy datasets representing both, source and target distribution. For more details on the execution of the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver`, we refer the reader to {doc}`neural_dual` notebook.\n", - "\n", - "In this tutorial, the user can choose between the datasets `simple` (data clustered in one center), `circle` (two-dimensional Gaussians arranged on a circle), `square_five` (two-dimensional Gaussians on a square with one Gaussian in the center), and `square_four` (two-dimensional Gaussians in the corners of a rectangle)." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "class ToyDataset(IterableDataset):\n", - " def __init__(self, name):\n", - " self.name = name\n", - "\n", - " def __iter__(self):\n", - " return self.create_sample_generators()\n", - "\n", - " def create_sample_generators(self, scale=5.0, variance=0.5):\n", - " # given name of dataset, select centers\n", - " if self.name == \"simple\":\n", - " centers = np.array([0, 0])\n", - "\n", - " elif self.name == \"circle\":\n", - " centers = np.array(\n", - " [\n", - " (1, 0),\n", - " (-1, 0),\n", - " (0, 1),\n", - " (0, -1),\n", - " (1.0 / np.sqrt(2), 1.0 / np.sqrt(2)),\n", - " (1.0 / np.sqrt(2), -1.0 / np.sqrt(2)),\n", - " (-1.0 / np.sqrt(2), 1.0 / np.sqrt(2)),\n", - " (-1.0 / np.sqrt(2), -1.0 / np.sqrt(2)),\n", - " ]\n", - " )\n", - "\n", - " elif self.name == \"square_five\":\n", - " centers = np.array([[0, 0], [1, 1], [-1, 1], [-1, -1], [1, -1]])\n", - "\n", - " elif self.name == \"square_four\":\n", - " centers = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\n", - "\n", - " else:\n", - " raise NotImplementedError()\n", - "\n", - " # create generator which randomly picks center and adds noise\n", - " centers = scale * centers\n", - " while True:\n", - " center = centers[np.random.choice(len(centers))]\n", - " point = center + variance**2 * np.random.randn(2)\n", - "\n", - " yield point\n", - "\n", - "\n", - "def load_toy_data(\n", - " name_source: str,\n", - " name_target: str,\n", - " batch_size: int = 1024,\n", - " valid_batch_size: int = 1024,\n", - "):\n", - " dataloaders = (\n", - " iter(DataLoader(ToyDataset(name_source), batch_size=batch_size)),\n", - " iter(DataLoader(ToyDataset(name_target), batch_size=batch_size)),\n", - " iter(DataLoader(ToyDataset(name_source), batch_size=valid_batch_size)),\n", - " iter(DataLoader(ToyDataset(name_target), batch_size=valid_batch_size)),\n", - " )\n", - " input_dim = 2\n", - " return dataloaders, input_dim" + "To test the ICNN initialization methods, we choose the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` of the `OTT` library as an example. Here, we aim at computing the map between two toy datasets representing both, source and target distribution using the\n", + "datasets `simple` (data clustered in one center) and `circle` (two-dimensional Gaussians arranged on a circle) from {class}`~ott.problems.nn.dataset.GaussianMixture`.\n", + "For more details on the execution of the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual`, we refer the reader to {doc}`neural_dual` notebook." ] }, { @@ -247,17 +74,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In order to solve the neural dual, we need to define our dataloaders. The only requirement is that the corresponding source and target train and validation datasets are *iterators*." + "In order to solve the neural dual, we need to define our dataloaders. The only requirement is that the corresponding source and target train and validation datasets are *iterators*.\n", + "The following command loads them with OTT's pre-packaged loader for synthetic data." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "(dataloader_source, dataloader_target, _, _), input_dim = load_toy_data(\n", - " \"simple\", \"circle\"\n", + "num_samples_visualize = 400\n", + "(\n", + " train_dataloaders,\n", + " valid_dataloaders,\n", + " input_dim,\n", + ") = dataset.create_gaussian_mixture_samplers(\n", + " name_source=\"simple\",\n", + " name_target=\"circle\",\n", + " train_batch_size=num_samples_visualize,\n", + " valid_batch_size=num_samples_visualize,\n", ")" ] }, @@ -270,23 +106,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "data_source = next(dataloader_source).numpy()\n", - "data_target = next(dataloader_target).numpy()" + "data_source = next(train_dataloaders.source_iter)\n", + "data_target = next(train_dataloaders.target_iter)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# initialize optimizers\n", - "optimizer_f = get_optimizer(\"Adam\", lr=0.0001, b1=0.5, b2=0.9, eps=1e-8)\n", - "optimizer_g = get_optimizer(\"Adam\", lr=0.0001, b1=0.5, b2=0.9, eps=1e-8)" + "optimizer_f = optax.adam(learning_rate=1e-4, b1=0.5, b2=0.9, eps=1e-8)\n", + "optimizer_g = optax.adam(learning_rate=1e-4, b1=0.5, b2=0.9, eps=1e-8)" ] }, { @@ -300,7 +136,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next, we define the architectures parameterizing the dual potentials $f$ and $g$. These need to be parameterized by ICNNs. You can adapt the size of the ICNNs by passing a sequence containing hidden layer sizes. While ICNNs are by default containing partially positive weights, we can solve the problem using approximations to this positivity constraint (via weight clipping and a weight penalization). For this, set `positive_weights` to `True` in both the {class}`~ott.solvers.nn.icnn.ICNN` architecture and {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` configuration. For more details on how to customize the ICNN architectures, we refer you to the documentation." + "Next, we define the architectures parameterizing the dual potentials $f$ and $g$. These need to be parameterized by ICNNs. You can adapt the size of the ICNNs by passing a sequence containing hidden layer sizes. While ICNNs are by default containing partially positive weights, we can solve the problem using approximations to this positivity constraint (via weight clipping and a weight penalization).\n", + "For this, set `pos_weights` to `True` in {class}`~ott.solvers.nn.models.ICNN` and {class}`~ott.solvers.nn.neuraldual.W2NeuralDual`.\n", + "For more details on how to customize {class}`~ott.solvers.nn.models.ICNN`,\n", + "we refer you to the documentation." ] }, { @@ -312,93 +151,72 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# initialize models using identity initialization (default)\n", - "neural_f = icnn.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)\n", - "neural_g = icnn.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)" + "neural_f = models.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)\n", + "neural_g = models.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6149d916e1ca484a94c4f5b218825e1d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "neural_dual_solver = NeuralDualSolver(\n", + "neural_dual_solver = neuraldual.W2NeuralDual(\n", " input_dim, neural_f, neural_g, optimizer_f, optimizer_g, num_train_iters=0\n", ")\n", - "neural_dual = neural_dual_solver(\n", - " dataloader_source, dataloader_target, dataloader_source, dataloader_target\n", - ")" + "learned_potentials = neural_dual_solver(*train_dataloaders, *valid_dataloaders)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now, we can plot the corresponding transport from source to target using the gradient of the learning potential $g$, i.e., $\\nabla g(\\text{source})$, or from target to source via the gradient of the learning potential $f$, i.e., $\\nabla f(\\text{target})$." + "Now, we can plot the corresponding transport from source to target using the gradient of the learning potential $f$, i.e., $\\nabla f(\\text{source})$, or from target to source via the gradient of the learning potential $g$, i.e., $\\nabla g(\\text{target})$." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAG9CAYAAAAobB0hAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACiiUlEQVR4nOz9WZClWVbYe/733t90Zh/CY/KIzIwcK7OyhqQmoBAXrhAI1APqbqRuQ2aAqTGZVCBQ9YPgRRImmUpm8IAZVyaQrA1ZWwtJfW9fUF81JaluqaEYRQ3UnHNGRka4x+DjGb9x790P3zke7jFlRGR4eHjE+pl5ZYX7cT/Hh7PP+tZeey3lvfcIIYQQQhwAfdAPQAghhBCPLglEhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFg9j0QWVlZ4W/8jb/B4uIijUaDD3zgA3zpS1/a77sVQgghxCEQ7OcX39ra4pOf/CTf//3fz2c/+1mWlpZ4/fXXmZ+fv63Pd86xurpKp9NBKbWfD1UIIYQQ94j3nuFwyMmTJ9H61jkPtZ9D737hF36BP/qjP+IP/uAP7urzL1y4wOnTp+/xoxJCCCHE/XD+/HlOnTp1y9vsayDywgsv8EM/9ENcuHCB3//932d5eZm/83f+Dj/90z99w9vneU6e5zv/7vf7PPbYY5w/f55ut7tfD1MIIYQQ99BgMOD06dNsb2/T6/Vuedt9DUSSJAHg05/+ND/2Yz/GF7/4RX7u536OX//1X+cnfuInrrv9P/pH/4hf+qVfuu79/X5fAhEhhBDikBgMBvR6vdt6/d7XQCSKIj760Y/yx3/8xzvv+7t/9+/yxS9+kT/5kz+57vbXZkRmEZUEIkIIIcThcSeByL6emjlx4gQvvPDCnvc9//zzvPPOOze8fRzHdLvdPW9CCCGEeHjtayDyyU9+kldffXXP+1577TUef/zx/bxbIYQQQhwS+xqI/L2/9/f40z/9U/7pP/2nvPHGG/zWb/0W//Jf/ks+9alP7efdCiGEEOKQ2NdA5GMf+xi//du/zb/9t/+WF198kX/8j/8xv/qrv8qP//iP7+fdCiGEEOKQ2Ndi1ffqTopdhBBCCPFgeGCKVYUQQgghbkUCESGEEEIcGAlEhBBCCHFg9nXonRDi0eC9Z5yVVNYRGE0rCfcMqny3jwshHl0SiAgh3pP+OGNlbUh/kuGcR2tFr5mwvNSh10re9eNCiEebBCJCiLvWH2e8dmGDvLA0kwBjNNY6Nocp47zg5GKH1Y3hTT/+7KlFus1YsiVCPMIkEBFC3BXvPStrdZDRbUU7wYMODN2Wpj/Kee38BmGg6bbi6z4+GBe8ubpJHAQM0vy2syWyzSPEw0UCESHEXRlnJf1JRjMJrgsElFJEoWZrlHF0vnXDjxujWN0Y0k5iuq3ohtmSa4MR2eYR4uEjp2aEEHelsg7nPMbsXUa89xSlpagc1rkbLzIeJllJZT3NJCAMDFopwsDQbUXkhWVlbcjufouzbaDNYUocGtrNiDg0bA5TXruwQX+c7e83LITYFxKICCHuSmA0WiusdTvvy4uK9f6EK9tjtgYplXVsjjLyotrzuUVlyYqK0GiM3rsMKaVoJgH9ScY4K4Hrt4FuJ3ARQhwOEogIIe5KKwnpNRMmWYX3nryo2BikpEWF1gqlIAoNeVGy3p/sCUasc1TWEoYa6xxFafcEEcZonPNU0yDn3baBrg1chBCHh9SICCHuilKK5aUO47ygP8rJylkBqaKqHFEY0GlEDNOCrKjqepG5FtY5BuMc6zxZblmrJmiliENDtxkTRwHWOrRWBNNtn5ttA80Yo3F5tRO4CCEODwlEhBB3rddKePbUImdXt9kcpijAo4iDgLl2TBKHRKFha5SS5hXbowylwHlPGBgAokDjPaRFRVk5FroJeeFY6DRoJSGwdxtITz9vt2sDFyHE4SHPWiHEe9JrJSz2GhitUQqs9eRlHXRkeUkcBSzNtei1Ys4cn6PbSGhEIcfnW0SBoSjrLEZkNHlZcWljjFawfKSzsw1z7TbQbt57JllFr5nsBC5CiMNDMiJCiPekP844vzagtBaoA4PKQlZWjPOSo70WWtcBRZpX9CcZcRSQRCGLXcVgUjDJC/LS4qwDpcjKipX1IR5PYAyVdcx3E8ZZwWBc7GmONskq4siwvNSRfiJCHEISiAgh7trV0ywlSinKyhIGut6i8YqycqxuDKnjA8Vaf4z39XZMpxnXNSGhoT929ekbD+BJ84oL633Or/dpRAFG11szcRDQTFQdtOR1UexCpyF9RIQ4xCQQEULctllX07KylJWjtJb1wZjKOZQCraCqHNoo8GDd7m2Uq/8/LSyVzXa+lrUOpRQej/cwzgqgLkLVSnF0LsE6xyQriULNE8fnaEShdFYV4iEggYgQ4rbMupquD8aM0vqEjFJQlBXOeZS+GnxU7sb9POpi1lppHZVzeE+9deP99P/XN7IelPNkRUmalxijSWJDmlVsDTKOP96WAESIh4AEIkKIdzXrajpKC7K8wjlHFNTFpaWdhhbW7/QPuVlfsWvfPbud9x6mAUmgFZXzaDzW1ds06/0JSiu0UgRGsT4YM856tBuRzJ4R4pCTQEQIcUtX60DqzIfzniQOsLZu5b6bcx5FvUVzk6TInqzI1fuoj+gG06JW791OkOJ83bMkDgzOe4rSkRU526MM65zMnhHikJNARAhxS7OupkFgGKYFYaCxts5C3CjY8Nw8IzL7+LXBiAKMrvuLVM5f/3XVdFCeUnjjyUrHhfU+WimK0u05RXOroXlCiAeP9BERQtzSrKtpXcbh0UqRFiWVtddlNm7XjT4vLx1FVd/Xbop6hk1lHR5fD8qLA7aHGZOsktkzQhxyEogIIW5p1tV0tkWSl3Y6G+be3cetvpTWCu89WVGRF3ZaBxKRV5Y40jJ7RohDTgIRIcQtzbqaVpUlCjRZUeFmp1vugUDXNSU3o5UCFKV1RKFhsdtAKYUCghu0e4frh+YJIR5cEogIIW5pNtwujgK8r+s4ANx7eI2fBR5aQWfamr0ON+o3mNWNKBpxQKsRkoSGuVZST/Qtbb0dc5OvL7NnhDg85FkqhHhXs+F2851GvVWj1B3Vh+wOMIxWO9s6gdHTlvBXo5pZYzQ1LVC1zu/0Gqkn9xa0kpBjc23S3MrsGSEOOTk1I4S4LbNgZJKXWOcYTQrSosS66RXNriO7RtUNyWZ2hwpagTaK0tYByDgrUErt1ILM+pA4X2/bRKEmyy1RYPCw09Id4LULGzJ7RohDTgIRIcRtazciFjtNNocpxxZarG1PGE4KHKB2RRuzgGT3MV1FneGYZTlmt3PWExkIjaaoLLvLOsrSkVHRayc8vbzAXLuxp2HZs6cWr/YRkdkzQhxKEogIIW7brF5knBfkhWWhk1BZR1lVVLt6m92oVwjU2yZl5QkDjdGKoqqjjtJ5Atx1J3E8UFjHKCuZZBVzba7rpPq+xxaZ5JV0VhXikJJARAhxR2ZbNCtrQ7bHKVopnK9br4eBJi8t3nmurWWdxRhGQxLVS09ZFbOBu1TW7wlcgul+j9YwyUq+cfYy71zZxmiNMWpnIu+sk+pcWzIgQhxGEogIIe5Yr5XQbcaM0oJvvn2FK9tjjFIYo+pputN0yO4C1dl2jFJ1EKEUGKN22sLbXds5obl6ZBcUgQbrPYNJjlaKOAw40mtgjJZOqkIccnJqRghxV2b1HgDH5lo0kwjn2DnlEhhFFOidfiOz3RLvZydj6oAkMJpGHKBVnS0JQ43z9ZaMpz4ubH09x8Y6RxIHOO8ZpiWhkU6qQhx2khERQty1Wfv3djOilUSMs4KsqPB4wmkPD+3r/zo3OxHjp+3aIQ7rhmRl5eqgxnus9Ttt3jV10OK839nCUSjCQJGXFUVliUKzp5NquxHd/x+EEOKuSSAihLhrs/bvtnJU1NmQINDT7IWf9gKhnpw7ndzLNLBoRAHNOMQ6z9Ywq4MQD2p6hFdR9w7ZPUVv9r9a6zoImr7fGI2bFqwKIQ4XCUSEEHetlYTEoeHS5hiog4+ychhdByDWeYxWKK3otSOywmGdoxmHOO/ZHGYUVd2ULAg0tqwzJRpw1NkT79VObxGgDmScr3uPTPd7pJOqEIeXBCJCiLs2mOSkeYV1DqUgCuqmYmVl0VqRhAHznQZJFBAYxeYgo7KOSV5hrUNpAI/RGhQYXW/LzApXZzNtVL0/g1J1catznkYc1k3Opp1UFzoN6aQqxCEkgYgQ4q5476cFonB8ocVwUpCXtu5w6jzee4zRtBohznmGk5JWI8RoxTAtaUYB/XFOoSxxZHYCmCissxpldbWvSGgMOlQUpSUrLEkY0GmElNZKJ1UhDjkJRIQQd2WclfQnGc0kIAwMcRhQVnXdRlVZhmlBVlj6o5woNCx0Gsx3E96+tE23GeE9VM4RBhqFwpj6BE1lHe1GSCNSdTFqEGCdpbKeJApoRAFBoCkqh3ZeOqkKcchJICKEuCuzEzNmWpehlCKanoIhCmgmEdujjCdPzDM/3Tbpj/OdzynKujZET8/3KuqtnLEtKSpHHBqMVvRaMXllCY3myZPzHJtrSSdVIR4iEogIIe7KzokZ69CBue7j1jmi0DDfaewcqd3zOdM+JG5a0Ar1KZk4MsSBoagclfNUznG019qT9ZAjukI8PCQQEULclVYS0msmbA5Tui29JytxswLSPZ/TjIjDgDQv0VF9TLe09YmahU7C9qig04x47tQirUYkWQ8hHlISiAgh7sruAXiDcUEzCepCVetuWkC653MmBY04oCgr0qxCaQiMoRGHjNKKViPk6eUF2s34AL9L8TC7doCibPMdDAlEhBB3bfcAvP4kw+UVWqtbFpBe+zn1ALwKDyTTGhMpQBX7rT/Orv7dOr9ngKL83d1fEogIId6T2QC8O7myvO5ztMIz7cwqV6Zin/XHGa9d2CAv7J5MngxQPBgSiAgh3jOl1B0XkN7N5wjxXs363+SFpdu6WnukA0O3pRmMC1bWhnSbsQTD94kEImKH7JcKIR5U92p92t3/5trPV0rJAMUDIIGIAGS/VAjx4LqX69O1/W+uJQMU7z8JRITslwohHlj3en161/43MkDxvpOf9CPu2v3SMDBopQgDQ7cVkRd2Ok/Ev/sXE0KIe2g/1qdZL5tJVl33ebP+N71mIgMU76P7Foj8s3/2z1BK8fM///P36y7FbbiT/VIhhLif9mN9mvWyiSPDYFxQVhbnPWVlGYwLGaB4AO7L1swXv/hFfuM3foMPfvCD9+PuxB24nf1Sm1cMJrkUsQoh7qv9que4m/43Yv/seyAyGo348R//cf7Vv/pX/JN/8k/2++7EHXq3/dJJVjKa5Ly5uolWSopYhRD3zX7Wc9xN/xuxP/Z9a+ZTn/oUf+Wv/BV+4Ad+YL/vStyFW+2XZnnJ+vaEynqMhigyRIFmc5jy2oUN+uPstu7De88oLdgeZYzSQupNhBDXuXadcM6B90RBvYXinLvu9u+1nmPWy2aundCWeUYHZl8zIv/u3/07vvKVr/DFL37xtm6f5zl5nu/8ezAY7NdDE1M3mxdSVZaLmyOK0hGFmq1hjtYFcWjoNK8Wib1b0x85FiyEeDfXrhPWOaz1GKOwzjPOCiZ5yXwnoZmEt5xnJA6ffcuInD9/np/7uZ/j3/ybf0OS3N4Lzmc+8xl6vd7O2+nTp/fr4YldZvulC50GeWnZGqSsro9I8wrnHZWt3/CQFhWbgwxj1LsWic2O3W0OU+LQ0G5GxKG544yKEOLhde06EQWacVoymOSMs5JWI+RItwnAxiBla5CSl5aFTkNaCzwklN+nPPnv/M7v8Ff/6l/FmKv7etZalFJorcnzfM/H4MYZkdOnT9Pv9+l2u/vxMMUu3nsubY14c2WTjUFKXlZEgQal6myGUiRRgPWeJAyIQ8OLZ44x175+IfDe8/K59emI+Oi6EfGDccFCp8Hzjx+RqxkhHlHXrRMo1voT0rwkCjVF5WhEAUd6TfCwOcroNCKeWV5AK0Uls4keWIPBgF6vd1uv3/u2NfMX/+Jf5Bvf+Mae9/3UT/0U73vf+/j7f//vXxeEAMRxTBzLyO/btR8t2bcGWV0TYhSBq4MQrRTK1AVjReVIIkNWVEShuWmRmLRRFkK8m2vXiaK05GVFGGi00oQG8tJSVo4w0DQiw/Yo5ZVz62RVtTMkcaHd4NTRrmRHDql9C0Q6nQ4vvvjinve1Wi0WFxeve7+4c/tRezFbFOJIM84URtf7s0orPB6lFJW1OKcpraMZhzTjgFFaXBcMXXvszntPWTmcrzMrxtRZFmmjLMSj69p1wnmP9x6t639rpai8Iysq+uOKSVYyyUs2hxlGKwJjMFoxnBRsjzNePHN0Z/3z3jNOCwZpAUCnEUlB6gNKWrwfQvvVkn22KESRQWtFpALSoiQvKzyABw84VxCFhrl2wivvbNwwGNp97K50nsEkJy/tTiASGEUcBtJGWYhH2LXHc7VSqOlWsNEK5z3Oe/rjDO+hqCzOQ6DAe3DOERqD857NYcqbK1t8+OljXNoa8/qFdbZHOdY5lFLEoeH4fIenluclc/KAua+ByO/93u/dz7t7KO3nCOvZoqCBODQMJ3Wmw11TRVRXFSneudxHaUW3EaGNIi8qLm+N2B6nvPDYEr1mwuWtEUVlqZwjNJpQaez02J339QIkhHg0zdoH1DUimigwxGFAmpeoEMrK4R047Ql0nYnVCsKgvoCxDorKEYeaqvJcWO8zTDPWtidUuxYurcA6x/m1PmlR7smciIMnGZFDZj9rL3YvCnFg2JhefczuxVP/f48nK0qKqqIRBRSlBTzWedw0+/HnxSWeXp7n/LolKyqSaZbFOU9VOeLQEAaalfUh3Va8871JYyEhDod7VaM2303YGqVsDjO6jYhOIyQvKiZZVWdMFQRak5cWPASBvno/qq5bs67O5lbOM8mr6+7DefDWg7dsDlMuXBnQfaK+WNuPWjtxZyQQOWTeteWx1hRlwdYwBbijJ9Wsp8gozbm0NcZOryh2J0RmWzRKMUuNMJzUJ52acUgc1nu2gzTn7KU+gdY0k5DKOmxZn5pqxCHdZoTW9RHgS1sjtgaZ9BoR4pC4FzVqu79GWVnSoiLLS5IooNUISWx9Qm+cFjjtiUJDUVn0dD1zzmNtvXVjqLdxbsUDlfOosmJjOGGclVjnpM/RA0ACkUPmVi2P86Jia5SR5hVvXdwiWh/c8En1blcA3kNeXn9VsfPx6W3wdUU71AVmpXX1SZpAY11dYFZZy5Fec6codZZ6RdWFafk4563VLbznnta7CCH2x72oUbv2azTigCQvGU1KUPD08gLH59us91NefmdtpxvzJCupnCNQerpt7K/Wrt1mI4rSeiZ5yfYo4+Lm8J7X2ok7J4HIIXPtnuosgMiLivX+hLy0NJOQXismK+20ZiPj/Y8v0Wsnt7ySAXjtwgbjrOB2ciiOeg9XqTqbUlqLdXVwpLUmDDTDSc7lzTHa1MeA49DQbUIcBVTTqyCUYqGT3NN6FyHEvXcvatSu/RpFadkeZXUxu/OM85JX39mgFUcUVcVgnNfrhPdMr3+w1u7J1JbVndWa5bnl/JVt8sqx0E5QWtaegySByCFzw5bsWrM1fSInUUArDtkcZuRlhXOOQZrzldcrnjm1wMXN0Z4rgKqyXNkeszlMCY2uMyGKPYVet+IB5evshnOeoqpQ1EFIlpf4adV7Ehj8tDNrWTkWugnjtEIB3RscqZNeI0I8eO5Fjdrur1GUlo1BerWY3eidrd0vvrbKOC0oqjo7OwtCYO928d1Iy4pLW2OiwOCcp9uMiKPgjr4Pce9IIHIIXTvCuigL0ryimYS04pDhtK9HGGjCIEBXjv444xtnr5BEAYvdBkrVp1wGk5ysqMhLu7NVUxef3r7d1yKTrJoOoFJU1pNMn9xZbuvHYzRFZVnbTnee/Ca4tyO+hRD7411r1G7jOVtZh7WOyii2hxlFZYl3TsF4lAaFZ3uUYq1Hq71ByL3ivCcwijQvKSvLYrexE4zI2nN/SSBySO0eYb01THnr4ha9VszmMKOyjjgyqOkGS2g0ldZkRV2FrqiDkN1XItY58tLjnH1PT3jvobIe5ys8HrwC5SmtJ68sZtrMLAhgeanLpc3Rvoz4FkLce7eqUYPbe86mRVlfLI0ceVlnRYuyXqtmSRbr/E6xvN2nYd1l5RhlJe1pMf1gUrA0rV+Ttef+kp/yITYbYT3faRCFhmxXe2S1q8rD+foqw2hFWdW3GUxyKueIg/pY7e4TMu9lR9RTb7+Ms5KirIOaOAzoNiNaSUhgNEZrkihgrpXQaybTniJ7V5t7MeJbCHFvzWrU7vY52x9nXLgymDYj8+DrgKOcDtZ0rj6O62638vQ9KivHOC3QWpGXFUVlZe05ABKIPARmi0OalThXR/Izs9MscVDPhanrOCx5aQmN3uliWA+1qz/nXpVmWeeJwzrwUEoRBYZGEuCcJysqQqNZXuoQR4bBuKCs6s6rZWUZjAsZ8S3EA2ZWo3Y3z9mdItXSstRrEBhF5a6edqmP196H7wEwqv6voq6Hy8sK6xyFrD0HQgKRh8DVxSGgcvVMF+99vd1SWQKjmWsnhEHd1dRPi0t3zuNPr0oCo9Fqb83He+GBSV7tPJbZ3jC79nxn9S4LnQZ5aRlNChnxLcQD7G6fs7uLVJM4PJAiUAX1hZpSKMV0Xo2mqur1qbJO1p4DIDUiD4leK+H9jy/xldfrbZfZ0dxGFNBtxnV/j9TQiOrtGTxY71HTYXRa1VsoUFG8x8uSuvsq071fy8BnQN3B0AOBMTQivbMdtLveRbobCvHgu5vn7O5C19n2x2ytuNa+bcxMH5739QWc1opGHJAVlqNzLT545hgtGYx330kg8hDptRNeeuY43z63tnNEN47qrZDBuKDdjDix0GZta8IoLZlkJVGgiQODc450etz2bs0WldlXUKpOu1a2HmCllCLQ9ZVIVlrSomSOZHpbJcfkhDhE7vQ5u7vQ1XlPWpR46jkw96kkZCcbrFQ92ddoNT1haDhzYp52M74/D0TsIVszD5m5doP3P3GUY/NtnIdxWu6kTU8udhiMC7KqIokDzLRItZi2Xlf3cEHQaqcDPI04oD0dwd1MQrSqm5ttDtL3FPgIIQ6P3YWueWGx07q0a9ec/c5FzBowohRaa4w2nFzocHy+vc/3LG5GMiIPoRulTa11vLZytaVyMwmZpCGXtkbk1pJEhjAIcL6iHmB35/e7+8SNmU7KVNRXQsbURbFFWV99dFsxg0kuDYOEeEQopTh5pM1av26gaG9y1bPflyZKQbsR0UoCnKublz21PC/bMQdIApGH1O60qfeel8+tX9eWOQoNUVB3MozDgFYSsjXMMFozzgqs83e8KMyCkVnqMwo13rOTdZkNvAtDw2hSSMMgIR4R/XHGWxe36I8zyjtsmvhehUF9IaQAbTTeeQJjmOs2ZMDdA0ACkUfAzdoy13ulijiaDZBiGkX46dG6u782CYwmMLDUaxGFZueUThQYUFBWVhoGCfGI6I8zXju/wVp/glKKuXbMMCvveEbM3VCARuEV9JoJnWZEUVmePrnI0lxTMiEPAAlEHgE3a8usVV1Aam3d16PuMVI3FTLm9p+calqlOis8C4ym04jpNmPSYtpgbc9037pifqHTkIZBQjzkZv1DxnkJeOLQYLSmnShGWXFdMKJ2HaXxgKHOYpR3mT0NdN3TKAgM852EMDTYiScKjQQhDwi5HH0E7K5W3y0K6gVhkpXTQEXRnBaxVtXNsyFKXa0FUQAejIYo0Bybb7N8pG54dPKmjY9yjFZ0W3UdixSsCvHwmmVk43A2mbtePQKjaUbXXwsHWtXNFVV9Wx1o4sigbxAzvFsYUc+pUQSB5uhckzgKpH37A0gyIo+AWbX65jCl27o2O+Hqq47pSRZjNAkhozTfUzWmpv/jZ+dzVR3FBqauAQmMptOMWOg0cHhGk4JGFO4ZzufyunuhtR5nPOcub3N+TdFrJrJPK8RDapaRjacZCOfq4/wAWmsCPV1SVN3pMDCawjuU94RG4T2ExhAFjuya2pIoNHjv61qzXdXy3oPWkIQBSRQy10lIokCysQ8oCUQeAbPOq+O8YDAuaCYBxmjSrCQrLc04JAxMHSRMi0qTsG7y4/GEQR1szNohW1fvwyg1awwEUahpxCFZWe254mg3op0TPNujlHeu9FF4Wo0QMz3NszlMGeeFdDMU4iE0y8hqVRfFp3mJjhSKumWA1vX6Ega6bsDYitkapQwnxU7jMaXqNgBFZXeO+yrYyaaGgUYrTRIZ4jAgiYK6U6rzdBsRJtCUlWWSVdK+/QEkgcgjYtaW+drsRGg0c61kGoj4nd4im8MJrYYmzaudJ6z3HjNtAb/TuExBIwoxWrE9ynBu9uSPqWx99aKUopWEvHO5j3PQa8c7X1MHhm5LMxgXrKwN6TZjWSCEeIjszsh2GmE9eLOw0+Gc07XEe6LAMN9pEEcBWiuywlGUliisgxhH3f25qOoeJEqxM5rCaFVnTcKAViPi2VOLAFfXu6JCa8VCR07JPIgkEHmEXNtfZGuU8sq5NbZG2U6TnzgMdvZyjVHEkSEODHllp3UeijCo06VRaAjN1eO5dTGsIgrqvdfXVzZ3shw3O7kD9f02k4D+JJO+IkI8ZHZnZOsWAjGTrCQrqrqrqdGEkSYO6wDEeY/RmlYc1lvHHrJpINFMQpq+nqmllaKs6i6todG0GiFHuq09gYaMjjgcJBB5xMz6i/THGWvbYzwKjyMKDN5DmtcLhHUO5xXNOGSx26Cy9eA65/zOkLwnT8zz2vkNBpN8p/CrEV+dbbM7y3GzkzszxmhcXklfESEeQtdmZOMoIAoNzTjk5JEOjShgdX20k63VWrF8pEu3FbG+ndKfZEC9BTPXanDySJvAGMrKUlaOMNCEgbku0JDREYeDBCKPoNlxuqJ0LM012BxkFFV9ZRKFmiy3VM4TaEWnGaG1JtIAdWHYYFyw2GnSa8bEkeF40kJrjVZqz1Hd3VmO3Sd3dGCue0xSyS7Ew+3dBuXNMqfXfmz5SFeyGg85CUQeQbu3ScLAsNhVDCY5eWnxvp7aG2lDuxGSFw6j7U5h6e5ir8p5vIckrufHXGt3lqPXim9xckcq2YV4FNwqQ3Gzj0lW4+Engcgj6NptkjgKOBKanf1WFOR5xRPH5xiMiz3p0t3FXqO0uO0sx81O7lwb3MiVjhBCPFokEHkE3WibRClFNC1SLas6AzLXbtwyLXrr/iTXZzludHJHKtmFEOLRJoHII+hOAoh3S6XeaZbj3faJhRBCPFokEHkE3cttkrvJcsierxBCiBkJRB5R93KbRLIcQggh7pYEIo+wexlASJZDCCHE3ZBA5BEnAYQQQoiDJN2jhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFgJBARQgghxIGRQEQIIYQQB0YCESGEEEIcGAlEhBBCCHFgJBARQgghxIHZ10DkM5/5DB/72MfodDocPXqUH/3RH+XVV1/dz7sUQgghxCGyr4HI7//+7/OpT32KP/3TP+Vzn/scZVnygz/4g4zH4/28WyGEEEIcEsp77+/Xna2trXH06FF+//d/n+/93u9919sPBgN6vR79fp9ut3sfHqEQQggh3qs7ef0O7tNjAqDf7wOwsLBww4/neU6e5zv/HgwG9+VxCSGEEOJg3LdiVeccP//zP88nP/lJXnzxxRve5jOf+Qy9Xm/n7fTp0/fr4QkhhBDiANy3rZm//bf/Np/97Gf5wz/8Q06dOnXD29woI3L69GnZmhFCCCEOkQdua+ZnfuZn+I//8T/yhS984aZBCEAcx8RxfD8ekhBCCCEeAPsaiHjv+dmf/Vl++7d/m9/7vd/jzJkz+3l3QgghhDhk9jUQ+dSnPsVv/dZv8R/+w3+g0+lw6dIlAHq9Ho1GYz/vWgghhBCHwL7WiCilbvj+3/zN3+Qnf/In3/Xz5fiuEEIIcfg8MDUi97FFiRBCCCEOIZk1I4QQQogDI4GIEEIIIQ6MBCJCCCGEODASiAghhBDiwEggIoQQQogDI4GIEEIIIQ6MBCJCCCGEODASiAghhBDiwEggIoQQQogDI4GIEEIIIQ6MBCJCCCGEODASiAghhBDiwEggIoQQQogDI4GIEEIIIQ6MBCJCCCGEODASiAghhBDiwEggIoQQQogDI4GIEEIIIQ6MBCJCCCGEODASiAghhBDiwEggIoQQQogDExz0AxBCPPy8c/j1DXyaoRoJ6sgiStfXQa6qcK+/ie8PUL0u+pmn0IEsTUI8KuTZLoTYV/bCCtWffQm3soovSlQUopdPEnz8o7jLlyl+97/gLl2GqoIgQB8/RvQjP0j4ke846IcuhLgPJBARQuwbe2GF8nf/M244Qi8uoJIYn2bYl1+l+spXcRsbUFlot6DZhKrEnb9A8f/8dwASjAjxCJBARAhxz3nncFfWKP/z53Fr66inzqC0xg2GuJVVXL8PFy+DtRBHUJSgAKUhjnCDEcXvfg7zoQ/u2aa51RaPEOJwkkBECPGe7A4OiCPs5cvYL38Vt7qKu3AR4ghdVZTdefyly5h8gkLhnQPvKXN4tfdRnpr8OQ2XQp5DGOAuXMC9/ib6+eeAW2/xmFPLB/xTEELcLQlEhBB3zb5znvL3/wC3chE/meD6AxgMwBiIYyhyaDZwW9tcXIuZhKd4tnsRPxiCcwCsJafYio5xzj3P+4Z/Bqi6XqSqcFvb9f3cYIuHLMeePYdf34Af+SHMqWXJmAhxCEkgIoS4K+WXv0LxP/0Ofnsbj4JJCkVRf7DZgMDU9R/9PmquR5pFYDwAhQ+ZhEt0yzX64RFKFdItt0Cb+vOthaLEbmzgnaszIcMR+tRJlFI796EbJ3EXVqn+7MvgHNWXviIZEyEOGblUEELcseqd8xT/4+/gNrfwvTmwlrL0O5kMxhPyfsEbvY9QluC3+3iAssCPJ2xnCVeS05QqYjtaYq3xGBPTqgOQaaYEwL78GtVXv4598y3UwjxKKaxXbORtAJRS6MV57OuvU/z2/4I9ew7V6aCXT6A6HezZc5S/+5+xF1YO5OckhHh3khG5R7z3jLOSyjoCo2kl4dUrNyEeArNtDzeeUP6Xz+G2+6iFeShKNvMWG62nOTP4Kk4ZVlrP0i63oCjJaWCGa/h2icZhty6y3fgAHpgEPfrhUYyrmARzvNX+ME+MvrZzheRfe41iOMCtbaC2tvFLR3gzej8+jpmLxhjl8VGEu7yGnptDP/c0Sim8B3VNxkSfPCHbNEI8gCQQuQf644yVtSH9SYZzHq0VvWbC8lKHXis56IcnxHu2u1DUDUa4d96BosDbDpezHpfjJZqMGYfz4KHyIVnQwVlLWZaMVYwF2uU2vqzwjfqQzFp8imG4SGxTtCuxSrMnfK8sPk6gyPHnV7i8pqi652h0A/RyBd0ubPfxeV7XgyjFm8Oj2Kzg6egcKghQC3O4lRX8+gbq6NLB/ACFEDclgch71B9nvHZ+g3FeEoeGODRopdgcpozzgmdPLdJrJZIxEYfWdYWiYQjn3qmP3K6uUoVPEqsRVivWomWOpOeBug7EOYfHMwwXqIwmSbfBe5QHq0I2khMUOmY+v0TochQe6k2c2niMffW1uk5ERWyHS1CVnNz6NnYSo59+CrexiYpj3Nwcb1zuYTcvEYwH2PRbeKVQ7TY0G/WpHiHEA0cCkffAe8+bq5us9SeAZ5LVe9ZxGNBphOSFZWVtiPee1fWRZEzEoXDtcdzyv31xp1CU4RD35lswHNSFqMCcvUjaaDIwi4yTOeJqjANKFeOcRXm4kjzOenCcZ4ovwzQAHwdd3uy8RB40yfOYV3of58zw61cfB7AdLlG5gPniIm933o/Pch4bvYxdaFJtbKG2/5zwicewS8c5t9rGbV6iOV7nRPYmvqzAWfzWNgQh9o03MY+fvv8/UCHELUkg8h5c2hqxujHEe+pMiFY450nzkrKydFsx64Mx2+MU56CZBBijsdZdlzER4kFwba8OnMNduYJ57DEYDtn89iVc39Pblc1rVnUh6jjo4p0n1S1wjjJokvgxGtgOTxIAoXKkpguAxzAO5gh8wUayTOQK9DQbMitX3UjqwMHqGI/BA9FkmzLdBhReKc77JtmRDxLmF1koL7MwOgfWQRiAicCmUJYUn/s8+pmnCB6TYESIB4lUbt2lOssxpLKeJDIYrVEojNbEkaGyjklWMEoL8sLSbUWEQb1tEwaGbivakzER4qDNtmB2nzwhjvH9Afats5TffoXLWZe18CRWhXs+90ryBBPTq7dWlAKl8KoOHKz3LBRXaLgJCuhHi+S6wTCax/gS7yEzbZwyLKevgYfLyRm+Nfc9eCC2IwbhAmuNxwm8A2WIqWtMtqNFznKawcYWR9e+wcLaqzBJ8UXJKDXQ79eneLTGX7xE+R8/WzdSE+IB4b1nlBZsjzJGafFIvh5IRuQujbOSSV4SGo33sLvCTqEIA80kq3De0W3G5KWdBiEapRRKKZpJQH+SMc5K2o3owL4XIa7t1QGKwgWECrAWv7YOVcVJPWK1+QyvNz+MSipOj1+mUY1Q3uGUARQVBkO9baN8/dRouiFJMcKjON96P4VOyFWM8ZZKh3gMzapPr1jD4VlpPsc4aHMifYuLjafpR0ucGr9Cp9zE+Pprj+LjjKITHPMVR/ov03Kj6fsXuBSdYTM+wRPjr3PUXoQggKKg+vo3Kb/+TYKTJ6TpmThwNzro0G3GLHQbNKLwkaknlEDkLlXWoYAkCsjKCj0NLrz3OO+xzpFXFfj6j42JQitFHBq6zZg4qrdpXF5RWblCEwfLr2/gVlbrYlSlSG3IO+stopWAZU/d28M5GrYPzjIMFxjES4x1hw9vfZ5ecYWJ6WBRlCZGuZLIpkRuQjgNHBR1rUijGpBHTSZhD+UtlhinAzrlJu+0nmdsegzCefCKd1rvp1IRgS+IbMax/G1QUBDz8twnaZcbvLD9hwS+BDRvdD5Uf358hI7tM2kswugilAVEERQFxf/rf6Y6fgxKaXomDk5/nPHahQ3ywu5s26dZybnLfc5e2qadhMRR8K71hA/DQQgJRO5SYDTGaJpGU1lHXlk0UFpHNX1zHmYXWnFgcN6TFhVl5VjsNtBaobUiMHI1JvbXtQWoAOTFTkbAp1ndjTSJAYhVgd/MSFPPG+ELPDn8s+mJFnhi9HVc60NcSc5wofUCS9l5nhh9nbV4mWG0SKfaInY53XKDSTDH2e6HyEyHTrHO+dZzlLqBQzEMFwhsjgt7GFfQLDd5q/MhJmaeSgfgHZVJmM8v0ivXSIMubzU/iFKOXDdpln1Ojl8nciXb0TEuJ6c523mJSsc8Mfo6XbtFGTYZB3O0ii0I64Zrfn0NdWoZdfTIDdvEC7HfvPesrA13tu2VUuRFRX+c45wDBdZ5okDfsp7whhmVRsxC73BlVCQQuQN7Is/pL3xrlLHQTdga1vt7zvudXZpgGmhkhcUYTWjqGpG8sgzGOWFgWOw2aSXhLe9XiPdiTw+Q/gDf7wOgej10r4tePol++klUFEJWz4ZRacqTl7/M+fwYGQlvdD5Mt9xkMV8l8CVz5TrH0rO81XmJLy79FT6w9Xt4FJHNmAQ9FvNVjqdneavzYfrRcSyarNEm1w1ats8k6FCqBi6sj/GG5FS6wXZwFKc0VsdUukHkRqRBh1axyTvN9xG7EZNggV5xhRe2/4BmNeCb83+BUTDPlfg0bTsgcWMCl1ESgrUoV2dkqCwEITQaEAT1dsy06Zk9vwL/9Qv47/1udLMp2zXinrn2dcMDw7RgYzihFU+DBA+DSUFlHUkc4JynqCyg6LYiBuOClbUh3Wa8E1TMMipZXhEGCo8nzSrWtyecvbRFqxGR3EZG5UEggchtulHkGYcG8IwmJdY5jNHEWlFZD1iaSYRiWk+SlbQSMEajlWKYFizNNVle6jzw0ao4vHb3AFFRBIMhZHmd21AD/FwPe/Ycbm0d1W7XPTmSE3WwsrXN6WqdtegEG/Eyr3Q/zpH8Ik8Ov8pS/g6DcJHIZ6S6xdfm/yKBrzC+IrFjYjvZyaBob6lUgMdR6RBdVmwkpyh0TKmjuomZK7jYfIqt+DixzWiUfRwOUFhvONt7iaiaUOqIueIKS/k7XG6c4WLjKVZazzJXXKFCE9shx7J3UEC73OJY/nbd90TXBbR0OqjAMFIddBXTDnIYDmF7m/Ls27gLF1CdtmzXiHti9+tGVlTkRYWnzqhP8pKitPRadXCRl1VdQ4hCKU9lHWlRAQGN2OypJ5xlVEaTgqKyTAb1Sc1ZvaKZHoroNeNDcUJTApHbcKO9PGsd/VFOVtQ1HmlZogBnDEkYoHVdmIqHKDDkVTXNjDi0UkSB4bGjvQf2D0McfrsLUNXyCdyrr+PLAubnAIUfDPEbm6hnn2by+lmKMCQcjTBvvAXjMaaqAFgsLhLblG/P/wU2k1NYDAvFJY5P3mAQzPPK3HcyDBdol5tkOqKhYxyKLy/+EN1ig8AVVAqKoAsoSh3jvcbpOpDHe7wybMXHMM5S6hAf9ohc3Z9nGB0hdBleaebzS5yYvElpEl7ufTf9aAnlKjLd4nj6FnPFBpFLWR6/gsfjlcI7h2u1GDWOsxEuozptlDpBMy9oTdawr7+Jz/J6H3Whnuwr2zXivdr9uhGYeuultA6lmGbOFZO8zpTMggut9TQAKbHWszVMGRpNFBiMVjv1hOOsZH0wZpwXZIXFWne1DaCHynsGk5xuK75pRuVB8kgGIndS3HOjvTyAcpo6KypLFGoaKsRohXUej0cpphGwpZr+kXhXEVIXqzbikLl24z5+1+JRs7sAlTTlyqjJqHmaE+oKY5pst59E9fvkf/RV4q11ekVG7hwxEO/alVBA0w5YzC6wFZ3g1e7HOZq9TaP5NI+PvsFmfJLV5rMMo0Vy08KqkBPRG6Smx6i5QLdcx+km1XSy7jiYpzIxcTUh0w0CCqxqUJiIjl2nU26R6SYKSE0b4ytiO2GhuMhcscY47PJ26wOMTZdSRyyUm8wVlzmevsWTo69hqAOo3Csuhye4kpxgpCPmc0sYQrKwwEI8Zj4cYF+9iC+KejuqKNFxJDNqxHu253WjGbE+SLHO04gD8JCVFYo6UVdWlklWopSirBxZXlI5T2AUgVaAZ5IXKKVJi5I5EsrKMprUrSGs2xWEUD9fPXWNyfYwpZ1ED/wJzUcuEOmPMy6sDdgcpjuByEKnwaml7g2zE+OspD/JaCbBThDivac/zikqSxgoqsrvFJ1GoSIvLGVlKco6elWq/uMwpv5D2xxmLMeh1IaIO7a76PRmR0+dc6ysrpG9eZaF/pDmkUUYjSh8SGUiLnCagohtlxCPtrDuOJPmcdrlN/A+JQNib3DKo3FkqskoWuB7rvyP/PnCDzIyPVZazxHbjEInnEhfZzs6RmoaFLrBMFpiGC7WWzEqIfAFXgVMzBwORbfawgPG5zjdJXAVFkfgC6wKmARzWGXAl4Q2xSuNwdEqNznXfj9b0TGMrwgoWcgvsjx5ne/Y+E8kLsUqw1ryGINgEe8VFWDwzPuKufQCjdEWjZNj5uOT+PGEajCEJMGnGfn8cYK4S4NqZ6qvzKgRd2P360Zp3Z5tF1SdJS8qi1Yay9WPj9IS5/w0awJpUdXbLd4ThrDZTzk+36asHIV1WOfAg9F1Dz8AVH1s3gOTvKKoLEHwYJ/QfKQCkf4445tnr9Af59OmMfWG2nBSN5N58czR64KRyjqc85hdJ1vGacFgUn+NErDOEU5PxTSigNBoxpljd3uR2fFererjvbPGNQ9imkw8mK7tenqjo6evv3Gez37uT3jjrfM0xyN+eLJOtDHkzGMnWPYXqKoN1sLTKO8Ity/hnKHffAydbRK2nqc0MadH36KvW2wnJ9DeElQZ5zov0qxe4PT4ZXLTZL3xOP3oCKNwHnCcHn+TUbDISitkHM7zZvc7OD15BeMrJrpNqSNG4TyVCmlX2xhf1gGHDsnQhD4nsAXGV4zCOQJX0CyHFLpBaRocm5zl7c6HGIXzaK9oVENadsDy6FVeGPwR2+ESTgX0oyXGwTwAWnuWsnP4fJOi2aZsJKiBZ/SNc4yrRSbJUSwlvtSoZoheOEGr0JwKNusfeBzjN7dkRo24Y7tfN4rS7my7zGhVt3PotmKyomKcFYDCuelpy2kwYZ3HTnvx+NLy9uUtFnoNkjDYCVb0tS8h/uq0JuvqIEep4IE+ofnIBCKzuTCbwxQFRLtashelZXOY8ubqJi89fWJPcBAYjdYKax06MORFxdYwm2ZT6mpnPR07XlSWWWNJN41S8QqvZuM16roRozVpXrHeTzk63zqgn4g4TK4bPJfE1x09fStz/N//H/8fNrcGnDxxhOaJI4zfLjFr63x5kvOJuYQkHXEiuECZl0T9LQaNJ9HZ2/jKs904TalCtuNlWnZS13coWG8+yTBcYBzMsdJ8lkqHnBy9zHjuExQ64dXuJ/iO9f+CCRynJ6/weucl+uERTtsKoz0X2i8Q2Iz6PJliFPSocy31oui1wTvNQr7KRnKKyOUk1YBS1SnkZrXN5eYZhuEC2llOp6/y2PhbtKothuER/ujo/wlQnB5/iyP5Cr1ig6YbADAwHd7pvITRGu8Vw47COEv09iaqlUFpUd0GYTumnV5iXmW4pFu/aOQ5KgxRDanjEndmz+vG9CLUOY+ZRg1uehGaRAFJZIhCQ7cZMZrkWO+xDuys2FuBmZ62GWcVr7yzznOnF2lEAWleZ0y8v7ols3ubxnnYHmU04pBjc+0HNgv/yAQi47TgytYYgCQO6hQZ9S84iRVpVnFla8w4LWg1ohse0+00FYPpH8rsD6Oyrg5cXN3ELHN+TxYkDA2h0WitUQq0rpueTbKKvKwO5ochDpVru57uBMq7ahnK//YlPns5Y3NrwLNPn965zcWTp1nwlt7WNu9EimeTELa28HlJs+hzvPgK4OmHxyjLSyjnONv5EKNgkUI3aZWbXGmeoVVskZkWw3AOgLPdl7AqAO8pdIPXeh/jePo2TTvkaHaB1cYZzrffz3L6KuBpV9tYFTAOe+RBE6+mU2W8I3IpTTumNAmtcpNSN/AYrI54fPhVLrRfYBL0ML5gsVhlKTvHleQJAr9MqWMGwTxaeebyS5wev4rmavp5Iz6F1w2cViRuQmgnYAccUSWtoA2DLegX0xW8bvxTdVrop55COYc58wTqyOJ9/G2Lh0ErCek1EzaHE5IowGhFXloa0bTG0DoaUUBgFMNJRSuO6I/q15ZQKyrvmXV6dx6cvRpebA1TXn1ng3YSsj3KcLfoCK+AvKyPr/faD2ahKjxCgcggLcgrSxKanSBkRqEwRpEVFeeu9Osz3Wm+U4kcGIV1js1BRprXe3mltZSlmx6VqlNgbraYzXhPFBjCwOy5v3IavMThI/PjF+/BtV1PB2WDy9kcaloUTXOe/NVt1jctJ499EFdFoEq02WK72eZby09wgvPYYZ+8d5QYj05zutOchAfmiss7Kd6jGxd4u/UiV5IzjMN5nNdcSR4jDdp08zUCSrbDo3gMedDEecNWfJRBvMTp0bd5fvuPGAZzZEGb1cazHM3OcSQ7j1Wa3DSxKkT7Cq8UGmhUIzrlJqGdsN58og7wVcyp0bd5p/1BnFK0qi1CW6B9ybn2BxgE85SmSafaoFX2Ud6ykZziUnGGNOhQqJjMtOrsipsQViWPj79FrhOcr2hYD2sZjCd119gggEZSn5zZHuC+8lXM+54l+PhHpFBV3DGlFL12zIX1ARvDFGBaN1jXa8RhQCMOGU5KolCD8mRFBSjKW0UWgNGa7XFWZ1feZSxNYDS96UmZ/ijn5OKDWQ7wSL0S1rsje38JlXXkpaWsKqzzvLayQRwEtJKAvLT18VznMQrCwJCXFcYqvKv/2BQe6/wNo9LSwTgraDfinb055x1Faek2Yxa7CaO0ONStecX+u7br6aSKpvvA9ZagNxF56VEVRFED5zX4EK3HoAq2m23WzzzD1pvnOPmX/hKPdRL8P/8NSiAHQqZPi11FTU+Mvsljo2+ynjzGpeQM59ofoNIxm0k9h6Zhhyykb7HaehZcRRF0qNC803ofrXKLD61/jj868ddQuiTXMeNwjsC7OhOiFMo7AlfiKYlchkNxufkUGotThk6xwXpymtClpEGXqNxmHM5zpXkGj8K4vH6gaoFSRYQ2R3nPnx35K5S6gdUBoIjchCeG36BV9Xmr8xIeWMrO0ao2YZLW37Qx9Q8gyyEK61bwVYVPU9TxY/f3ly0eCv1xxurGkNBoVBxQVvVIkKJyWOsI4vqJttBpMN9NeP3Cxs7R3ncLLvKywvnrXsquo1U98X2x18A6L6dmHgSdRj39tqwsJqz37CrrSPNy5/iTUgrl68j18lZRb6UohVJQWr/Tth3qkwmBVlSOPUGIAkKjp/NmPJWtj161kpCq8uSVJTSa5SMdXj2/uadB2mHogCfuP9VI9nQ9Pd7oc7zR3/m4n0wYJ+v8LilFNabTbtZ7xrsWqjTNmTRbJGcex332/wtZjm61sGlOrtqc7b5E4OrGYwpPUo2odEDTjjiWvc3p8bfZiE/wRudjbCXHcRgG0RLG5hgszfwypTaMg3ne6n6UdnKZo+PX2ExOMw7mWB6/TpE0CFxG4QNyD143SFyOqYZsNh5Du4JKR7TzNUI3plRdCl8Xv47CRcChcdNaE027WCP0ltw0KXST3DRAaTSeXnGZdrlBZDO0t2xHSxzNzhK5Ao/mcvw4o2COcbJIqWOqqMXR9C3OuDdRiwv4ssJtbeNefxP9/HP3/XcuDq/dR3cXe3WLhrJyO123h2lBtxnz7KlF2o1oZ+puaS1aMR0XeXNuWg8SaEVpbxy1aFVnQ6z1pHk9C22SlaxuDGg3YrqNiFYjemAufO9LIPLP//k/55d/+Ze5dOkSH/rQh/i1X/s1Pv7xj9+Pu97RbkQcm2uzsjEgLy1hoMmKqj7+NG2xqzVEgWacVzhfZ0HqIjeP9R5cfRtbn5iiuOaPYHZE1xgFrj6ilZX1bJn+uADqP44wMLx9uU8YaHqteKdB2mHogCfuP3VkEb18Env2HLpxcs/i4b3HbWzRevpJjnQyvvnyW3tqRGa3Wb20wQfe/xQnIk2+egmUwiQx/eQMW2Wb860XUMDEdHHK4IDctCh1hMajXUWz6tOuBvSKDRwwiI6icVgVEpHTrFICV1HqmEkwT6fYYD5bJY96vNX5MHNbX2TbHGM1HVEELbTPMfk2jeZRmPSJw4Tm5ALDZJFRuIjVmlI38b4OQEJXYOwYrQzKl2g8la6L77zSlEET5R3aOzLdIItP47XBYeoOx6aH0ppKBVgVgoKWHdQBmw6JTQVlfeVKHOGHQ3x/cP9+0eKhcKOWD1F4dXteT+tFZlPYL24Op+NBbv8+lGJ68vPGnAdrPRNbcWlrRFlarIfNwQRjNI0o4NhCm6dOLjwQrzX7Hoj8+3//7/n0pz/Nr//6r/OJT3yCX/3VX+WHfuiHePXVVzl69Oh+3/0OpRRPLc+TFiX9cb7T60NNMx5RYPDeU9g6ctXTUy4AdlcpslZ1C/dZFvvaPwWt1E52JY7qzpGV9SRxSKcZ0U5C1gcTJlmJcwbXiAgDhQ4M3ZZ+4DvgiftPaU3w8Y/WtSIXVtGL8xDHkOe4jS10p034iY/yw5lj9dI6r71xnpPHF2k0E9JJxuqlDRYWuvzlH/guVF4fE8RovLXkSY/EFjw5/HOcCilVTBq0KVTCIDrCxPTIwjZWB2SmQ2Xq7SGcxytNq+pPi1gXCG3OQn4B4y2jcJ5JNMeT21/kin+CjXCJS0d+kLQYcaVMaYUh+fASzeYCl668wiTdpKcdT518Ce092pc4F5AUFwmydRpxhyLsUOqIipDKtMh8hfEW40qcCnBK43S9pE2COZwCvK0H8OXrZEGHgILQFrTtNokb8czgyyQqJ2hFKKPBO7xz07k0AarXPbDfuzicbtTyYbfdU9dX1ge8sbJ5R0EI1KWI1bt8jp0GKllhd70PXOVwruT8lQFpXt2wbcX9pvytwqp74BOf+AQf+9jH+B/+h/8BqLc0Tp8+zc/+7M/yC7/wC7f83MFgQK/Xo9/v0+3emwWhP864cGXA5e0R/VFOGGgacUAzjtgcpmRFSWX9zumWwGhsXYXKLHky4/3eQGS2laOnff7jUDPOSgCOzbdIohCPZ217gtaKqnI04pClXnNnb76sLHlp+cCZYw/kXp44OHv6iJQlKgzRy8sEH//IDfuI5EVJEgZ8ePkI3/ex9/P4s0/gnSP79/9v3CuvwnCEVQqfZWjYU8Jd6IRzzRdwKsQqQ2o6TMIehU6oVEipQzbi5Z26klLVAUrkJuSmg1MB2pe0iw2euvQ7fHXxh0nDOS4N13nlwpc4svA0Ck9Zpaxe+hrrW2f5ro/8X5nrnqIZtfCuwOiQxBi8CjAmwCtF3Z6sro/RrkJTEdocrSx+mvnAO0JfP+9iO6Fph/WE4OFXabkhsZ0QuwnG70qCh+F0KrGCo0dgu48+dYrGL/7f0MEjs4Mt7oFRWvCNs5eJw+sPKsDVNf7FJ5b40qsX2R6nFKV7t9KQPW6jlOSGn6N3eo/UF+BxFPDkiXleeHzpnl/43snr974+w4qi4Mtf/jK/+Iu/uPM+rTU/8AM/wJ/8yZ/s513fVK+V0H0iZmm7xcvvrJFEhkYcoqgH0U3ycnrLq9XFs1itTofV2y9JGDDJy2sPyWC9RxtFFGiy0lJOjwBvjTKMLnbmBTRMgAo0eVlN28TXf7C7o2UhdjOnltEnT9yys+ozT5/mqSeX686qZ8/Re+N12sMB/Lc/If/zL6FPnsB0O/hWC7vdR1XVtLvHVQ5F6QNG4TylSqh0SKUjKhXh0SgciR0zn1/GUNIut8l1Qmo6jMIFwE9PvoRsR4ucXfjvyEarXA4t6+NNwPHy679Lu7VEYCJQig89/1eZ654mMAGFLXFAU9fBh9IK40uMtRhf4tGUOiKYBiGxHdGq+nTyK8yXV4h8jvb1FovyDoUjchnHsren3Uuu7bYAlGX9FoawehHV6xL9yF+SIETcsatHd1O6LX3dNukkq1joNJhkFcO0INCanPuw3k+f6HXfKz9tKW/ZGEwOvIh1X59l6+vrWGs5dmxv5fmxY8d45ZVXrrt9nufkeb7z78Fgf/ZnlVIszTVZ77fYHKY0YkBBpxEynOS4afbDTINZ768O76zTYZ6stNwsl+R9PTWxsvVi2IhDomnn1bycHuHSmjDU0wLYq1/IWvdAd8ATB0tp/a7txrXWnKSifPmbOw3QmDVAe/sdyDLIUgrvmeYA8NRZjfXkNGc7H8R5Qxp08CgyHde9PzBYFeFRWGXwKErTwDUDnKpXOYsmdDmRG2O9pxhdZqBjLgVLXB5cpKxyuu3jXLzyLYbjy8x3T3HsyAv0ustk+YCymBDHHcIwodKGBIicJ8JhpgEOHhI7IvAVyjs61QbH0jcZmzkm4QIprq4VwaGdpWm3sSrk9d7H6lowHMp7jKp4avRVlNv1IqCAKEafOIE+JidmxJ1TSrG81GGcFwzGRT0oVWvSvCTNK5IoYPlIZ6c7952eDp9dEN+paZnjNBCvA5JZQ8+DvvB9oML9z3zmM/zSL/3SfbmvG/2xNJKQZhIySot6eN1068UYjXNup5d/ZYFdEeys/8Jsn69y4HFEgdkJKpRSGKVIQiitJSsrtA6mbd+vZl5m0fKD2gFPPPhu1gDNNxrkxx9j+OdvMPSnGTZPE9cjGuujhSoiNW2GwQKp6dQ1FxhGwRyBL0mDDqCo0BSmgVIa5S1QX2E5FVD/5WtcBcrnuGSBzFX4Kmfl0jcIw4RO6xinT36EpcVnqKqcTusYQZBQVRkoCMKERtxDaYPXCq/rY8Z1wKTAWwKfoKbL6iiap9QxqenilZ7eyuMwVDqkUY6I/ASFZz6/hMajcJxI36TyAUZbtNHgPfq559DPPIlfvSQD78Rd67USnj21yMrasJ6Sm5aU1hEajTGKlfUhjbhe/+1NTr5cyyhQ094hzvu7yqF4z7TTd/1s8vBAXPjuayBy5MgRjDFcvnx5z/svX77M8ePHr7v9L/7iL/LpT39659+DwYDTp0/v2+Pb/ccyO0bbSuopus7XgYG1jtI67HQ7eTZhd7dpQ0YCPWuVVqe9js41SIv6iLCOFAqF1ppGGDApKiZ5RbsRERg9ncBYEUeG5aWOFKqKu3ZtAzTn4c3hifpjeUZl53BViqJkFMwxCubwyoCzbMUn6hM1rsSbmFG4UGdAgIoAcPURWe+wKFABoGdNegCLUh5vAnQxxqDIiiGXt1a5tPZNjh99gTBq0omOY5Sm1T6J0hpjQry3bA9WUFoRVBPmo4iOqlh0I9CqLkgFMt2mMg0iO6HQCZq6u2u3XEdhUd6jvGMc1CeAzHQrKbFjutUmftpa3hJwrv1i/eSdPt2eCSzaGLwMvBPvUa+V4L1ne5ySRAELSUAcBTjn2RymRJmhEQUMJ7c3yygM68ntW6Ps+gLFO+B8HdTUw/U08+2Dv/Dd10AkiiI+8pGP8PnPf54f/dEfBepi1c9//vP8zM/8zHW3j+OYOI738yFdp9dK6Dbjqy3dp0dpV9br4CQvKsZZidGKODSMs/L6QIT6SK/CXw1icAwmJZ1mVBcnFfWRYa0VWqudzqpxaBilBVorFjoN6SMi3rNrG6BZr1HKY5SjwTbx8DXi8Tp5VbLSeYlm1edi4ymysDftITIk1y2U9cR6RGZaBC5DmwZZ0Jr28agbhl2tLnHgKwKfY7wj9AUosKNVvn72C3zp3JdYPvESRodYmwEdFheeoSgmXFr7FieOfYBWYwFvLe1Gly45Le0haDFyIU5pKtNAO1tvCekYS50xCVxBqWMcELn6isH4giPFRQKbE/qCJ4dfIfIlxpf18eTpEV6rAmzYwE5PALEO7ugiqtWUgXfiPfHes7o+wjlY7DYoraOs6tkz3WbEYFLQbkakeUFhb949RFFvxzSj6XPOe7RSdcdvf/Ui+U5YV3+NTiPkzIm5A7/w3fetmU9/+tP8xE/8BB/96Ef5+Mc/zq/+6q8yHo/5qZ/6qf2+69umlLquUKfbqoOTwSTnzdVNWnGIdW7nFMyNeNhpWqNg2rIXOs2IrLDkZV034n39R/XBp47RacQM07rHyKzJjBDvxbUN0ELteLpzCQCXblAVmxBorNMEdkxlWswVV4hcQeBzctPknebzNOyIo+lZNuKTXGo+TW5a+FkA4h3alRifo1RA4NI6IAhaVEqDivDaszraRHnLS2e+B9U+TZYPKMoMY8bgHZ32UcIgwtqcMttksXuUWAc0ygwfdim9IovnqVSAxmFcRWQn2GkBrUdRqojMKIbhAsrXDc+SakTiUzrlFqHLeHXuuwFPbFMWi4tELqtPz9gx3fx8vU/f7YBr1tmkx07JwDvxnsz6iQRGsT5Iyctqp0g0CupBd0XpeGp5gdcubO7MhNlNq/rCtZWE02xK3R8EtXf+zI3MTsjciALCQPPiE0sExrA9yg60u/e+ByJ//a//ddbW1vgH/+AfcOnSJT784Q/zn/7Tf7qugPVBMwtOqun0RGM06/0JdlqAerM/gVnr3UArvKvnByhgvpuQVNNeJZXj6FyLVhxx/spAuquKe+pWDdCcMdMpWo7IO1ARCs9CcZm54hLNqs+V+HHGZg7tSzbik6RhD7zHuJyAnMCXJHbMYr5K4HK2ohOMgy7WxBQqweOw2hDZgscXHuf5YEgeLjBqPsa33vhfiVrLtJtdXDnCR22iIKEZJbTKLby2WG3IW4/RLDZxJsajCVxeF+kpQ2ViAlfSLtaJXI5Tut5CUhrtPaU2OB1QuphJ0EH5FvPFJQJfELkcjyLXDXLdgHARnTm6aoian0cZjesPUKuXMM+/TwbeibtWWUdWVORFPT6kzohrytLSH2fTLf36GO2xuRYXN0d4f7VH1azHVX0MWDNMSxpR3WwQfzVTYqatJnYHHbP3zcbRzIpbw0ATGkMU1I011wcpF9aHB/76s+99RN6L/egjcjPe+z3bM7PIcHYmvLSO9a0xpX33895mWividk1QDAJdFwT5evrvk8fn2R5n5IWtq6qnW0KzOhHprireC3thhfJ3//P01MzVBmj2rbdxZ9+ub1RZfFXtLHyZbvLy3HczNr26VsR7Kh0R+IJmsU1ASWwzUtOi0hHr0UnScI7AFWRBg8x0Ua6k0iGxTWnmawx0A5tuEIzP02ofo2mHFPmQcesMOh8w6T6NClt1tsNXdMbnKJonyIIOylu8imhWm4AicCXalgwbx3AojK9oldsELsf4koV8lSeHX2cczTEIl8imA/YqHfHk8Ks7vUXAszx+FYOlME1icsLQo07UdWt+a5vguWeJ/tr/Yac/ixB3ajTJ+cNvvlNP2p1OfK9sfaLSObfz4n/ySJesqBiMcwJTz49y3qGVxrv69jdKfhhdd+rWqq5bLKq6fLXOdijKyu8ciZs17Tw63yIOAypnubI1oZ1E9Nrxvrz+PDB9RA6L/jjbU7C6OzLsNmMiY7i0Oaq3VW7j681O0Siu1hRZ6/De005iQqN569IWUWBY7DZ2rlilu6q4V8ypZfiRH7raAG1zC4Kw7pMxNwfWUuWWzbLLMJgVpBoKndCqtupaETtmMTs/bdk+R26ajHSXzfgkadBF+xLF1WA7tGMK08TgaJbbZEEXb0uUTgiUJvKWhoZQOzaiRSLvSIwnNzHaZWhXMWmeomX79PLLrLWeRLucQrfoFOt0qk0qHWPyyzSKTbaTU0yCOcBS6ITLzad4s/tRjk/e4pnhF3lm8CVCX5GbBmnQYxz0yE2z/l51RMMNiOIC4gQmKX40QgUBqtsl/IHvlyBEvCezbjWzQXaeun2Dm9ZneF1nPUKjabYTJlmJ956j801AMRhlrA2Km399z86hCpgWoPq6SVk9Eb5CKbUTrLQbMZ1GfU5uc2uC855OM9ppunaQrz+PfCDSH2e8dmHjuszE5jBlnBXMdxKu9MeUlb2t41KzbZtAa5x1oDyBUjSTEOs8UajpNmNW1od1dzv2/qKVUjST4IGelCgOh2sboPnJhOJzn8fMz+HPX2AtXGScB/V5dGdp2QGntl+jUfVR08XtQuNZLjafRnnHVnySwBW07YCAkrDK2WhEWFNPA3baoL2nW65hfEkVLqEDR6ws87ZDFvWo0j5dnxIEMcYcI/BQYjHeonSE9pZhfJw8mPDi5hd4q/sSqWnXGRIslWng0SQ6mPYPeYN+eIRBfBxwlLrBZrLMf0uW+fOFH2SpWOH9W19gOX2D+eLS9T+kLId2G+ZjzJOP40cp5n3PYl584f7+ssRDxzpPIwrISkte1QPtKmtRu7qbBtMBqUor5jtJ3VwsrWgnQX06Zpdraz6cr1/AG3Fdt1WWlqKyNOOATiNiMMnJS7vT6bvbjEBBUdYnNJtJSBzuDQEO6vXnkQ5Edk9J7LaiPZmJOHRc2hrxzpU+1vnbGs88o7WaFjfXV4tBaIjDAOtc3dCsshhdd7Xb3VV1RrqrintldwM0e+48lBV6+QQ+SZh/4yJzW6s00q09n+OBjegEL899N5Ogx3Z0jNiOWchXWcxXCW3G5eQU59sfJLIZpaqYhItYFdGwI5JqwGbjNIHLKTFUQYcgbKBMSBDW82pU0MC6gBOT17loGuRBh2a5ifaewkOpY97qvMSLm19gIz7Guc6HSIMuoS9ZTM+xlZzCK89Sdo7ctHl647N0iw1GQY/CNDjffj+jYJ6N6ARfOPbXMb7i5ORNPrT1ebrV5tVvtqpgfR2WT+FLi1laJPzER6V3iHjPAqOJo/rIbpqXTPJyJ+M+G34K7PSRaiYheRHRaUZsDVOqXVGHmabZZxcIs49U1mGtxxhFIwlp6YjFdpO0LInDgNLW2ZduKyYM6+nzw3F9SnOuFcMNEh4H8frzSAciN5qSCJAXFRuDlGKaRlO3GYHUrZRA+av1IQqIg3pR09P27rP/75zf01V1Rrqriv2w5zQN0HBjfOyhNLP9Q8amw1cWf5BcNRgHc5Q6Jq5GtG2fF7b/iPXkNKvNp7nUfIpW1WcxO8e3576HImgTuQmRTemHS1gC2naAMg2cDilNg1LHjKMjNNOzGFdSmZiJaaOos43aV7TLIVZHZCYGA6/1Ps7z239IYiestp4FFJNwjlPjujPzWnyaZjUisRMUjm61BdUWi/kl5spV1uMneL37ESbBHOdbz3G+9RyfXPufWZ68RuDrU21YC2lKcOYJgk98VLZkxD2xu9X7YrdBM68Hnga6rhfMS7vTdRvqdT+OAp47tchbF7dYH6T1fBi9a8bZNV1VjdHMdRokoSErKhY6Td732CKTaSCRFiWbg5TBJGc0qQOQ+XZjOiX+xq8vB/H680gHIjeckuhhMCkoKzf95dcd7NS0aZm7QZCoqKPZytYZj1kGRalplfI041E3kKmPboWBZpJX1wWk0l1V7Jed0zRvvY0bjaAooN2C8RhvLRea7+NK8higGIdzdIsrtKoBkZ3w2PhlLjeeZD05ReArnu5/mRPpm/zxsR8lDzok1ZBOuUVmmqThHK1qm+OTN3mr+xHctCW8UyGl8RRBi9gOKYMGWdChWfaZBD3GwQIL+SUiO6JUhlKHDMIFLieneWzyKt1qi8vJ41Q6om37HJ+8zjn/Abai47zc+y4+uPlfeXz8bVZaz+Hx9KMTRD7jBy/+Jg7D1+e/n63oKBPTZjs6ypF8tX7yNhroo0cIPvmdmOMP9mk+cXjs7t49nJQ0YkMjCkmL+lDE7u2SPet+I6LXSuoTL9dcp2ql6ovc6b8DrQiNIisscRSwvNRBa72zpTJHwvH59p6DGM044JV3Nt51Fs79fP15pAORwNQNxqx16GlUWlR1vw9jFEXld47jwtX2TX7Xf42G0NRTP+uiIHaOZRnvMbo+KeOVp5xO240CQ6ANjUiRFVV922uqlqW7qrjXlNYEH/8o7vwKXL6Mj2IYDOibBdYap8B72naLXn6ZufwSoZ0wX1ykME0uNJ6mn5xkvrjE46NvEbqcPzvyw6SmOz32OyQ1HSoVY3zJ8clbjMJ5rAoIfEGpmzhlUM6T63b93HE5Vkd1NsPVreI7xQaJm3C+9TzGF/SyDbaTU8yXV1jML9KsBlxJTtOo+hSmyUfWP8vLc9/DSvMZXut9F6/1PsHH1n+X+eIiF9ovAIqV5nOA50Pb/z+abkRuGvV8GQUoDa1WXcSb37wwUIi7cW337nqLpe4Nsnu75Np1/9RSh6+9WXfg9tMBS7PjvLtnzQTGYJ2/ZTPMG/XJum4WzgG//jzSgciNpiTWWyr1IKKdniBG78yeUdrj3d5ykW4rJisszntaSVTPkVGadiNkkldkZYV3dXakEQc7HfVOLnboj/L6tE5eSXdVse/MqWWC7/oE1dvnYDiEoqSIGqA1c/kltpNjeG1ouDGnR99EuYKX576HfnSMY5O3OZ2+QsOOeaf1Ao6AdtXnSPYOhW6y0TmO05pOucnz/T/mvy3979G+QnsLeEKXk9ghXmmUDtDeUagEE7TplVfITJsrzTN8x8Zncd5zpfkkSns6+Trb0TF6xQYtO+Rk+hbtcoNReISV1vtYnrzGB7Z+jz88/tcYBnN8cel/w3P9P+XJ0ddQeFaaz1HqmEvJGZ4cfY3YT3ZVlRuY76HaLWleJvbFtd27b7Rdcu26b4zh+ceX+Npbl6jstEmmvzr/TCmYaye8//GjzLWTO25Edt14kwN+/XmkA5EbDb6DOtosK0dgFJWddrczisp53LSASE3HKZvpXtrjx9osdBs7qbfNfsogzUmcJ/UepSGJ6q+/+5d9cvHG/UuE2C/micfQJ47hyhJ6XY5g6QzPcyE5DZWlU65zLHsHD/TjI3WGI3ub0+OXif2Ey8kTpLqFwfL08Mtsh8dYbT1NUk3o+j6PD7+G9r5uREaF9o7Al5QoQl9hMSgPKI1TBusCFouLXEk6jMJFct3ipc3P86emTRa0UUpRqQYXm0/x5OjrPDn6aj3ArrzC+dbzDKMFRtE8f+HSv6EfzPHK3PehcJxrf4DYpZwefxuAQjfqH8DuOR29LrrRxJw6Jc3LxL7ZnZW40XbJjdb9Z07Vf4/ffnuNrKx2Tm0arTg23+ZDTx17TwHDjcabPLSdVR9010aG1tXzYpSv9+82BtP3GUWgofJ18NGIA9qNEO8V7zu9xNJcc+cXeO0f2qzBWeX8db/sG6XNhNhP6sgi+sgR3JtnUfNzaK2JwpJgCCf63yZ0GR4YBfN8u/dJNI7v2PgcATmjaJFhuMha8zGOpWfph0tsR0u0yi0Cb5krLnOkWGU7XsIpTeAKnFc4FJHPUN4RUhDZcT0fRmvQCuU9savn2qw2nyZxExaLi5yNPsBGdILn+3/CxebTpLq1szca2YynBn/OSvMpJkEPj6dTbfGR9d/BN+dYNWfIdYO3Oi/RKzdYys7t/UGEIZw4jjm6RPDxj8hJGXHf3O66/8ypRZ48MTftwJ0TGsOppTadZnJPAoYH5fXnkQ9E4Maps/NX+uSFpREHpHmFtfUJF60UnWbEfCchLxwL3caeIGTmQfkFC3EtpTXBR1/C/vnX8Nt9VKdNEBqeiFdxqqQEUIrLyWOUOmZ58irGF1SAcpZBuMCxyTniasxK77vpR8c4M/waH978X7nUeAqFp9BNjK8IXUap6gm5Gk+z6uOUYWwcocsxNsObgMx0ODl5nYuNJ0nDOZbHrwGKteQxhuEiF9rP8fzWH+BUfPUU23SvvDt6k46BCo0PA5Jmo87WjL7GMFjgcuMx+u3HMLrDwtabUJbT2pAm4RNPEP733ysnZcQDyxjDEyfmD/ph7CsJRKauTZ0145CVtSGeusjUek8zDOk1o+m5cCtFpeLQCl58P/Y7Pkz1jW/hshychbKCOGY7qxg2TzNMWnTdCqfH32TaGpJW1ed9/T9hIz7FMF4kM22OZW/z7PCLNOwYhSO2KWeGX6MfHWEYHKHQ6XQrxmF8SegKYjcho03schrlen0SpuoT+7SeA2OaBJQ8MfoGr3c/inKeSbhIp9zkUvNJjqdvAeAU5Eajo4i2rhft6cRJADoM6LjX2dKn6agR6siRuhZkfh6V5wTf+90ShAhxwCQQuYmrWZIe26OMtf6YrKhw057+UlQqDjOlNeFf+u/xRYG7sFJ3Xp0OeNThImM1xzhOaOh3GDZatCdDvIdQQWLHLGXvMIwWWcrP8/jo2xzLzrEWnwalWChWadghj4++xfn2C6S6g/E5memQm+kAOjePU4aGHdIrN9iKjtGPluiWW4yCOdbiUzw2fgXfUjw++hbb0RKhnQCerfAYnWKdph1QKkNsNOd1RHeph+lvwWRCvXcToo4dQz/7NEcDg68qVBBAswlpih+O0M3mQf8qhHjkSSByC7MsSbsRsXyk80AU9Qhxr5hTywQffYni7XMwHkEQMuwts1kewRQFZy79Keu9LheDmCfckJi6PCM3Db45971kpsPy+A0eH30T72EQHQGgaYdUKsBg6RYbpEmH+fwikyAldDmPD7+JVTFp2CV2Gb3yCpUK0ThODb/BG92PcKn5LO8bfRHlPXPFJSKXErmCdrXFJOhxqfk0Twy/ShkaKh1gvafsdomPL6GaLfSzT8PFS7i1dXS3zlrOnq3ee9zGFubME1KgKsQDQAKR2yQ1H+Jh453DnTuPWlxEP/M0kzxgw50gspZTK3+MyxzBYIuzPuBrBXwogRB4tfed5EGX45PXWcpW0L6cVm2onfqNStXPleXJyzg0rWpApRsEvmApv8A5/wFCV58EGAdzNOyQdrlJSM7x9E0abgLA0ewclxtPMJ++ziToMgoXOJKdZy05zVudD7GcfpOR0Xyps8QTP/LDNJ5YRh1ZRGl9dQLxhdU9E4jdxha605YCVSEeEBKICPGI8usbuJVV9JFFaDS46E6ggMdba0THXsA9dozkygbj5dNc+sKfsm0cI9djGB4hdhOeHn21bsehwAGPjb+Bpe7GGLqcpBriVMBLm/8FpwK+vPjDNO2Q0Oe8f+sLOGVYj+tGaoErQSnmi8ucHr+CmbZf71SbXOEJJkGPE5PXWG0+y0ZyCoWnVIb1xhJpts2HuhHHv+NFdHB1SbvRBGIVhpgzTxB8/CNSGyLEA0ICESEeUT7N8EWJSmKUgiPJgIbJiU0FKPTCPHGa8Ww+Jm6GvDGxZEc+SWjhmcGXKLQhdBYLlGFEq9WgKkryCURYjmXvcK79frbj4yzkFwGwqg5UutUm88UlNqOTODReK46kFziSr+x5jApYzFdYj5cZhQv1VF8Vspi+w0r7Sb6un2LJvMaHY43/xrdwyyd3MiJw/QRi1Uj2fFwIcfAkEBHiEbVnCF6zwXw03vNxv76BX1nBpRnHtWKt8RRDq+hWa8QM6YcxSZ6S4InbLfR8D28d6flVAlftbNlU0zbvKIjdeGdmwpFshYuNpzA45orLnB6/vPfxTf87X1xmI16m3zzBqf5XeKP5IbZMQFSsMbf4NCeiZ0mufJv8P34WPddDL58k+PjV4XW7JxALIR48EogI8YjaGYJ39hy6cXJP8bXrD7CvvDad3Bhi547RyBdZHq5wbPsrDJQjBlSSENoKHUXoU8skYchgfYt8PCKe9oK0OkThOZa+id41HGEhv0DsMnKTkNgxmhtMlDQG5uc4FvQJ4pDmwmmed1s4GxOMBoTGUZYBZdSicfIEyhjs2XP49Q34kR+S7RchDgEJRIR4RM2G4Pn1jT0FnT7LsC+/CoB+9mncufOs+GXCRsgH4/OgW1StFurUMk1v8f0B+vHHYDCAyYTWY6dYObeKS1McYFVABeSAnuY5FBBgaVQDtKszJxaNmQYjSqk6CDl5kuB9z9BbvYjf2kY1O8RK4QoPVcXp7HXeiZ/h/MKHea5dz4vSjZO4C6tUf/Zl9MkTsg0jxANOAhEhHmE3KujEWjAG/fxz6KUjbG153Kii08iItMP3OoR5gWk38Ft9ghffT/i/+xHY3MKnGUkjYfjKW2z8T/+BcqRBBVgU2hhMs4maaLAOBcyVVxiFCyggDbp0qu06C3P6FObJJyDNUN1OPf58MsEPhtBIYDAE54jISUJHubDIqMrohFkdjCzO41ZW8Osbsi0jxANOAhEhHnHXFnT6zU2K//p76COLKKVonpgnOTvh2OA1aDbqQKEocCsXMceOEnz8I/VplekLvr2wwslXvsWxIx1e0W280YS6y5nyLL6vAQVBAFpxcvIGyjtWWs8xiRbo2H4dBM31CL/zY9gvf3UnW6OeehJ/7jxsbtTHdIxGLSzw+CnDeRMSm+HVbyqO8dPASAjxYJNARAixp6DTNRJUFO0UsTbnYp54qsCtzOEHQ3xRgHMEjz9+3ZwW71ydXRmO0KdOoscKHRrC1nGCssRvbQMxaANZRtOPodWERoOxC0FfhnYbtMGdu0D4l/8S1Ze+gltZhbJEHzuKft+zqOPHsF/9el3n0mryBGt7v6E8R4Vh3c5dCPFAk0BECLHHjYpYdbeD6jyLH0/wF1bRZx4n+r/82J6+HbCrN8niAjQSVNPDaIRvUAc383P4tY06q+JcnRmBeoBdHKN0s77/k8dwKyuo7/kuoh/93153/BagGA7rwtRmY0+hrXROFeJwkUBECLHHzYpYyXP81jb6+FHC7//e64IQuLY3iSJa6OCzIQyH+EYDtIYwqCfgBgYWFiCJOe77NMoBqt3GLJ+AJMFtbePTDH2T47c3e4zSOVWIw0UCESHEde62K+m1vUmePDrCJwq3Wm/rUBSgNeaF9+HOna8zI2VJR/dR8x3M8glUt4ufTN51a0U6pwrxcJBARAhxQ3fTlfRG2zqq10V1O/jxGLdysa4t+T//Hyn/l9/FvvI6emkBFYbQbKKUuqOtFemcKsThJ4GIEOKm7rQr6a23dfqYY0frAtcogk98DDY2ccMRanEenMPfxdaKdE4V4nBT3nv/7jc7GIPBgF6vR7/fp9vtHvTDEULcJnth5eqWSVmiwhC9vHzdlsnt3k4Icbjcyeu3ZESEEPfc7W6ZyNaKEEICESHEvrjdLRPZWhHi0SaXHUIIIYQ4MBKICCGEEOLASCAihBBCiAMjgYgQQgghDowEIkIIIYQ4MBKICCGEEOLASCAihBBCiAMjgYgQQgghDowEIkIIIYQ4MBKICCGEEOLASCAihBBCiAMjgYgQQgghDowEIkIIIYQ4MBKICCGEEOLASCAihBBCiAMjgYgQQgghDowEIkIIIYQ4MBKICCGEEOLASCAihBBCiAMjgYgQQgghDsy+BSJvv/02f/Nv/k3OnDlDo9Hgqaee4h/+w39IURT7dZdCCCGEOGSC/frCr7zyCs45fuM3foOnn36ab37zm/z0T/804/GYX/mVX9mvuxVCCCHEIaK89/5+3dkv//Iv8y/+xb/grbfeuq3bDwYDer0e/X6fbre7z49OCCGEEPfCnbx+71tG5Eb6/T4LCws3/Xie5+R5vvPvwWBwPx6WEEIIIQ7IfStWfeONN/i1X/s1/tbf+ls3vc1nPvMZer3eztvp06fv18MTQgghxAG440DkF37hF1BK3fLtlVde2fM5Kysr/OW//Jf5sR/7MX76p3/6pl/7F3/xF+n3+ztv58+fv/PvSAghhBCHxh3XiKytrbGxsXHL2zz55JNEUQTA6uoq3/d938d3fud38q//9b9G69uPfaRGRAghhDh89rVGZGlpiaWlpdu67crKCt///d/PRz7yEX7zN3/zjoIQIYQQQjz89q1YdWVlhe/7vu/j8ccf51d+5VdYW1vb+djx48f3626FEEIIcYjsWyDyuc99jjfeeIM33niDU6dO7fnYfTwxLIQQQogH2L7tlfzkT/4k3vsbvgkhhBBCgMyaEUIIIcQBkkBECCGEEAdGAhEhhBBCHBgJRIQQQghxYCQQEUIIIcSBkUBECCGEEAdGAhEhhBBCHBgJRIQQQghxYCQQEUIIIcSBkUBECCGEEAdGAhEhhBBCHBgJRIQQQghxYCQQEUIIIcSBkUBECCGEEAdGAhEhhBBCHBgJRIQQQghxYCQQEUIIIcSBCQ76AYj9571nnJVU1hEYTSsJUUod9MMSQgghJBB52PXHGStrQ/qTDOc8Wit6zYTlpQ69VnLQD08IIcQjTgKRh1h/nPHahQ3ywtJMAozRWOvYHKaM84JnTy1KMCKEEOJASY3IQ8p7z8rakLywdFsRYWDQShEGhm4rIi8sK2tDvPcH/VCFEOKuee8ZpQXbo4xRWsiadghJRuQhNc5K+pOMZhJcVw+ilKKZBPQnGeOspN2IDuhRCiEedbdbw3aj2w0muWw9PwQkEHlIVdbhnMeYGye9jNG4vKKy7j4/MiGEqN1uDduNbheHhjSv8B7Zej7kJBB5SAVGo7XCWocOzHUft9ahtSK4SaCy2+4rEaMVCqiclxM4Qoi7tqeGLQ5w3lNax5X+mHFW8OzpOpC4Ya1b5bi0OcY6x/GFFuF0jdOBodvSDMYFK2tDus1Y1qdDQAKRh1QrCek1EzaHKd2W3vNk9N4zySoWOg1aSXjLr7P7SiQvKtKiQgFxFJBEgaRBhRB3bFbDluUVRsP6IKWsLOBRSjHJSoxRfPip43tq3WbrWFV/FZSC4aQgDq9uQcvW8+EjgchDSinF8lKHcV4wGBd7UpeTrCKODMtLnVteLey+EjFGkZUW6xzegy9KAqO5vDVie5zxxPE5mnEoWRIhxLsaZyXrgzGTrGSclTjvMdMMbWgUlXWsbgyZ7zRuWOvmpgWpYaDJS0tZOaLwauZXtp4PFwlEHmK9VsKzpxav7q3mFVorFjqNd81i7D5102mGbAxSrHMkYYB1jnFWkRUTjFZsDidc3hox14pJ4lCyJEKIW9oeZfTHOWXlAE8Y1FvElfU474hDTV46Lm4M61q3azK3Wqk6MPF1PVxa1DmSKDCg7mzrWRw8CUQecr1WQrcZ33Fn1d2nbirryUtLaDTWeSbTKxjvPM4pnKsXj0lRkcShFIsJIW7Ke89afzzNrjqM0ejZeqQ81lpS69BKMU4Lkii8rtYtCgxGK4aTAo9ne5gy0IrQGBpxQOU8S73mu249iweDBCKPAKXUHe+T7j51U5QW5z3BdO+2nKY7nQdHXcGuFVjnSPOSxW6D4aSUYjEhxHXGWUlWVCRhwKgqmK0OztXFqtZ5oN56yYeWVuLIy4qjcy2Urm+dlxVlZXe2dJSCoqwYpwXb4/pETbcRM5jkcjF0CEjeStzQnlM3SqGVoigtxTV7rkrVVzjW1+nSvLRU1u8pFhNCiJnZRU6nGYFSlNZRWkdR2WkQcpUHRlnB1ijjnbU+o7TAOc/WKKOynlYSkkT1Md6iciit0EAYGCZ5wWsXNuiPswP5PsXtk0BE3NDs1M0kqwiMIgo0WWHxzrM7v6GUwntQvt6Xdc7VVynTwtjBJJeOh0KIHYHRWOeY5GWdSbWesnK4WywP1nmyomJte8Jaf0yaVzSTkF4rprIeD9PMrMIE9ddPokA6SB8SsjXzkHqvE3evPXWjtcZ5h4dp9gMUdfW6Ugqj60KzwNSLwSQrGaYFb65u1hkV6XgoxCPPe89gkjFOS7KyIokCoM5m3IhW1Kf0qNcXrSxlpWlGhk4rYrOfUVR2Z93x1Fs8ubPkpZVjvIeEBCIPoXs1cbfXSji52OG18xvTr3X9bbwHpTylBVR9rt86y3p/gtGaVhzWVyjS8VCIR1p/nHHhyoB31vpkZYl1kOYVxtz8AunaLElgDHlZUaAonadyDgVopVHTiyOvPM55JnlJqxHWtSeVZZQWd31hJvaXBCIPmduduHs7GZP+KOPc5T4emGslDFWOV5AXFufqoAO/a7HwkBUlFzfqiGWxG9cdD5V0PBTiUTZbl8ZpOT2yO60tc9OLmNvmMUpPWwiUtOKASms8HkWdEfG+DliqypEXFdY53r68TVZUMo/mASWByEPk2om7sxf6a4MA7z2r66NbZky2Ryl//vol+pNsZ2ulXjhAUe/J4me17VcVlQcqolDTH+dkhaXbjIijQDoeCvEI2r0uee/IihI33d6908qNorIoFFFgKKo6qKlP7Hk8fmerOJzWofRHOc4zLaAPaTdCrJPs7INGApGHyO1M3F0fjNkepzh380FRAF978zIbwxSFxymFLR3XNimcLSLqmn9DfVWC96R5SVlZFrsN4iiQjodCPGJm65LRcGWc7QQhWitw/pZFqrup6Zsx9R6MUgpjFB5FWVVYXxfSGw3ZNBOSVxVaacqqYpLVreDnOgndViTZ2QeIBCIPkXeduKs147QkiQIWe40bZkwuXBmQlxXbowzvPcYo3DQTciuzjAkwvQKpj+Q14oCidAwmBUthsKfj4XstqBVCPPgq6+rREnmJrerBmfg6U3InKRFPvbY0ps3M8rK+4JlvJ2z6umgV73e2fJieyFHGUdr6dF9WVIzzgqNzLcnOPkAkEHmIvNvE3TSvm5Et3CJjsjGcMEwLoL7y8M5T2luvFp46NWqmzYbqxQDKypFEs3kQFXlZkRWWhU4Dax0vn1t/zwW1QogHW2A0njoI0FqjdR0gOK9wdxCJzFasvLTTC5eIqrJsjXIUkISGvLDY6QXRLM4pK08UKsy0lqSqHFe2JywvtnHOS3b2ASB9RB4iu3t/XHtu3ntPmleERhNHwZ73F6WtU5nekxcVZWmJw7rtcvEuQchu1tVXI0bXi4b1jsq6+iSNdfWUzMjQa8e8trLB5jAlDg3tZkQcGjaHqTQgEuIh00pCmnGInRa4K1VnRG+W/NQ3S4pOi+OraeOzI90GjTjE+brz6jAtKWzdj2TPNjGz031108XAaCpr2RimMo/mASEZkYfEbJuj24rZHmcMxjnNJNwzcTeJgnqrxdXBQl5UDCY5+bSFO74OJhz1s/ZGx3Xf/XFAaAxW1R1ZrfWUtgIPc+2EMyfmWF0fvWtBrezbCvFwUEpx8kiH1Y0hZWWxts6eagU3PDBzk2sf78FSr12zAtVZZ2c3a7Q4DVauL6J3O0X3anrHWV5xbD6QeTQPAAlEHgLX9g2xzmGtZ5QWGK2vTtw90mFlfVhnIiLH5iCjco7QaAKlyApbX434ehvnblOW1jnU9ElvncV6SMKA0GjSonrXglrZtxXi4XJ8vs3yYpeVjQFFZXf1/6izFNWuitUbxSGK2TgJdmo9Nkd1AazzVwteFXCzVSsvLVGgd6petVYs9VpywfMAkEDkkLtZ35BxWmKM4rGjPebajZ2of1KUbA4nXN6cAJ4oNHUnwtJitGK+k7A5zMjy8rar2XebFZTh61M2s4BEa8XaYML2JKesLM2bXIXIqRohHj5KKZ5anqdylsG4oLQW61y9JTztyBxpQz7Nnl67IzzbXmHXf0fjHGMA9E7wcqtO7h4obX2RFIWGuXbCXFvq0R4EEogcYrfqG9Jr19scg3HB8pEug0m+kzXJirpwFDxZWTf5me2hFpUlDoJp+vLOIxE1fVxQF6kFRhFoXU/KdJ4oqPd3beXQ4fUFtbtP1QghHh69VsJzp4+wsjZke5wyyeu1p6SuI9NGESqDtf//9u48ToryTvz456mq7upjpoeZYUAGkEM0hg3KFYjHJiT6EzUvEzUxh0ZFDVmvoOuFRKMxa2AN+opIjJqYuHHdVTQuxmA8WM/1iInKoNxyCQz3NUdPX1X1/P6onoZmZmAGZujp4ft+veYF3VNd9Uz1dM23nuf7fB+/R/dAPAAXdJt9IPlMA8j2zkbDAXrHojIs001IIFLE2lM3pK4pyeZdjWzYVp/rNTEMm3gyQyrjkJ3llpNxPDJO+qDao4CIbZFx/QWnFP4dSNr1ckmxGdfAMg3qE2kqrFBeu7XWNCUdKkrDcoEQogcqi4aIRWw272pk9cZdWKZBKGAST2ZIpv0k+wPN0gMIWP6MvjaWqGmVQqFMhW1blEZs+leVyrBMNyGBSBFrq26I1v5qlo7nkcq41GaDkOZeE39MVe/p6gRMQ6GUv2DUwQzJgD/eawctVMbFUIpkxs1OzfXHgZUiO+TiD/bWx9N5w0lNSQc7aMoFQogebld9Eq2hotS/GYmGgqQdl8ZEik074wd8vdpT37ldLNMgYBkoFH1iUYZU95IyAd2IBCJFrLW6IXvPhHFdD9fTNCXTlJfuKWDWXExo34+x1i0XmeqIYMDMBRz+kI/fHZobMlIK1/WLDoVsi9KQTX0ihZdy9iTUSh0RIXq0vXtyAdLZWXuGUnk5HuZ+Rof9IogmynMPGI6EgxZVvSKk0i69SkOcMLQPhiFDv92JBCJFrLluyM6GBLGoQTrjsqM+geP5lUpdF+yAv1plXTyVqyGioUWPg9YH3xMCfrn4iB0kYCocT5FIe1iGkT/0kh0HCtkWWsOgvmWglFRWFeII0tyT63geuxuTufIBhvJLC4A/zGsYCs9tvd+juRe3PYPIYdsk7XiURIIM7VcuQUg3JIFIEVNK0b+qlHgqTV1jimSmuVy6wnE8ApZJLGqzqyGB47rUN6Xone21aK6Cmp2t2+HFp/ZmGYqSUBDTUISDAVIZf2Eq1/NAGbluVMf1sCyTytIwacfD8TS9SuzOOBVCiG5q36UcLMO/NtTXpfC0JmAaBJSBp/dUOdXgV0htvkDtwzQUrt5ThURlnzPN7H6cPTVb44kMrgexsFxruisJRIpcWTTEcQMqWbNxN7sak/jrSCnCdsBf9TZgkUg5xBNpkmmHjOMRsAxCQYtE2kFrvwvUMA0cZ89FoL1MQxGwDOqbUtiW/+vUXGio+Q5HZ9d/sCyDPr0imKaB4WmZGSNED7dvjSPDUJSGgqQyDulMNnle+dcBUylCAUikHD+PzfPzzpTKHzL264+o3PWq+cnmIml+l6//r2nAURUlBAMmTakMKzbskBV3u6HD8pcglUoxcuRIlFLU1NQcjkMeUcqiIQYdVUYsatOnPEqfXlGqyiJ+KXcFsUiQgGWQdjzSjoMGSsM2pmFkCwX5fRaQH4Q0Fxxqi1+MyL9I2AGLyl5hSiM2tmX6i+DhL8dtB0zKoiH6945REg7SlHQoi4RkZowQPVhzjaN9l3LYXp8gkXL8oZWMh+t52R5Tl2TaxQ6YNNcd87IFzJpX3jUMPzfOv9lRfv2RgIll+LVEHFeTyfaqBExFKBjAskyCAYtYNEgq7VK7raHFEhiisA5Lj8gtt9xCdXU1CxcuPByHOyIFLNP/AJsGgX0WvLODFmUlIWhM4riaxqY0hqHo37uUHXVNJDN+bQ/In8prmgpTKTLZ9Rv2ZSqFYRiURWxiUTu3hk3vXhHAL6scDJhEbIuwHfC7Y+NpmRkjRA+3vxpHkZDF7rifv+YviOmSyri5YRnLULnF8Qx/cRpMQxGxLSKhIJbhvybtOCilCAUsmlJpkml/H82rhoeC/o2OkT22VG7uvro8EHnxxRd55ZVXePbZZ3nxxRe7+nBHrH0TV/etz+G6moF9yji6TxludlgkGgpQF0+yZuNuttXHiSczZBw3+8HNrt+QnfViKk04GCBsW7iuRyQUION6ROwAYTs/yVQpRVmJTV08lasr4iTSmDIzRogjwv5qHJmGQcA0cFyP3mUR0hmXXY0JwO891VrnXuNqTWWpv7hd0DKzM//9StB9y0tAw67GJL3LIjiuJpF22NWQIBTwE1Rzr2s+tlRu7pa6NBDZsmULkydP5rnnniMSiRxw+1QqRSqVyj2ur6/vyub1KHsnrrZVn2NAVYzSSH7CVq+SMEOrFYmMQ8A0MS2DTMalKZkhkc7geppIKEB5aYhQwCKRcrGjJv0qSvlsy25Ctn/Xkc7LfPeob0oTT/o57QHLJBy0qO5dylHlJdITIkQP11aNIyCXo9aYSOO4Lol0Bo0/zRYFqbRHJBSkNBxg86449U1pInYAD78i897XM/CXrWhoyhAJWdhBM1fDKGiZxCLBvG5eqdzcPXVZIKK1ZtKkSVx55ZWMHTuWtWvXHvA1M2bM4K677uqqJvV4zYmrueSwdtTn0FpTu70Bz9NUlvm1RpoLoiVSGXY3pjAUaM8famnel2kYrN+m/IAllclNwdPZzHd/Zo5BLGJjGIqmpMOGbfVE7ID0hgjRw7VW46iZP0QSIJF2aEhkSKUdLMuf7ZLJ+DNrYpEgdtCid1mE3Y1J4qkMRlq1ej3b+5rXHGgoragoDeWGi0EqN3dnHQ5Ebr31Vu655579brN06VJeeeUVGhoamDZtWrv3PW3aNG644Ybc4/r6egYOHNjRJh7Rmkso7z1dbn/1OVrrQm1eFMrP7wgQT2UYWl1BLGLn9qW1xrYsanfUYyh/5oylVHZ4x19YKhYJYAeyCbNRf+2b2m0NxCK29IoI0YO1Z6i4uqIUjWbD9npwNIZh7Jntlw0gIqEArusxtLqCiB1o9Xq27zUvkc6wYWu9v5Cn6e7VM5zxb46i/rZSt6j76HAgcuONNzJp0qT9bjN06FBee+013nvvPWw7fyhg7NixXHTRRfzxj39s8TrbtltsLzpOKdXuRKz9daECmJaBkVZE7ECLfWo8vxfE035dkmyJ+OYMd9BotL/GgySKCXHEaM9Q8TH9yzGVoimVwTINgpaZywNp5roepun3rO7vmrH3Na8XISJ2IK9n2PX8hfQ8U/PZlt2s36Yoi4QkX62b6HAgUlVVRVVV1QG3e+CBB7j77rtzjzdu3MjEiROZM2cO48eP7+hhRRfZXxcqtD2munlXI9t2N2XXj9Gkk5nsdDvtZ8ObJq7nD/EEs6vsSqKYEEeO9gwVa62pLI2wsyFBIGTkBSGHMpSydy/J7sYE67bWodBEw4FcQLSzIUE8lZa6It1Al+WIHH300XmPS0pKADjmmGMYMGBAVx1WdNCBulBbuxDUxZOs2riLZMYlHDSJBA1/ld2MS8b1CJhmtm6JnzfSTBLFhDiyHGiouD09Jwc71d9fTC/Aui11eB6UlewZEjYsU4aLuxGprHqE6+iFoLk+gON4BC0/cFFKEbRMAqZBfVOaRNrBMPycE2Ov10mimBBHngMNFR9Mkn177W8asQwXdx+HLRAZPHiwVLPrpjpyIWj+YJdGAnja84OObDCilCJsW8STaZpSDiXhIKapyDjuId/dCCF6ro4m2bfXAXPgZLi4W5AeEQG0/0LQ/MG2LJNYxCbjeKQcl4BpYCiFYfgFi0JBCztgEk9kOu3uRgjRc3Ukyb69DjYHThxeEoiInPZcCPb+YNtBi8pYmPqmlF+iWXtoDaGgxchjjqI0Ynfq3Y0QQnTEweTAicNPAhHRIft+sO2gRe+AScbxF69qSjpUlUU4qkIqqAohCqsrk2FF55FARHRIWx9spSCd8YiGAwzoE5MPtsjRWnf62L8Q7dWVybCic0ggIjpMPtiiveriyT2/J57GMKSQlDj8uioZVnQOCUTEQZEPtjiQuniSFRt2kEq7eV3i+yskJb0noqt0RTKs6BwSiIiDJh9s0ZbmejOptEssGmxXIam2ek+qe5dgmaYEJ0L0UBKICCEOyv56LzpaSKqt3pMtuxpZv72OcNDCNAwZ2hGiB5JARAixX60FHPVNqf3mfhywkJRhkM6k2dWQQGvNhm31LXpPMp4m7bgks0Xz+vQK4XqyRogQPY0EIkKINrU2XGJbFol0Bq1pM/dj73ozyjTIOP5KzYZSeJ7H7niKRMph9aZdGIYinkjTqySUt5RAfVMKx/MIBU3SGZd4MoMdMIlFgtQ3yRohQvQUEogIIfI094A0r1rquntWLXUcl827GnE9j6PKowSy1Sr3zf04/uhKyiIhNu9swPE80o6Lv8KDxnH9pR5KwkHKSmwSqQzJjMvuxiSW6demyTgeqYyLgSKVcf0FFOu1//2ARdiWNUKE6CkkEBFC5OzdA7KrIUnGcSkJBwl7FgFL4a/T7gcSDYkMoWAgt3T73rkfTSkHy1TsbkziuB7KUJhK4WqN52kClkkkaOG6Gq3BMhUZ16O+KU1VwMLTGsf1cLIrOCsUCvA8TTyZJp1xCAUtWSNEiB5AAhEhBJA/3dayDEBjB0ySGQen3qMyFkbjhyFByyCVcUg7LsHAnjU8mhcRq91ez7J128l4fqCgPY2HRgOmoVAKdjYkMZtSeFrnhm5IpiiL2oAm47g4rr9sgMYPTFBgKEihcD2NZciwjBDFTlb6EUK0mG5rZv/AW5aBbZk4nkd9UwoFGEqBUmit/eBhL67r4bguK2t3kso4WIbCDpgEA2Zun+AvnpjMZDCUIhSwCFoG2oNkymVXY5KdDQnSjoenm/tffH6OCbieJpnOUJ9IHYazI4ToShKICCFaTLc1lEIphedplFIETINUxgUFdsAk47hANijJ0loTT2RIpDM0pTJ42g8Y0o7rJ61mN3U9f3hGAZ7WNKUc0o6H1h6u1uysT9AQT7doo4Zse0Apfz8btzeg9wmGhBDFRQIRIUSL6bZBy8QO+EmjGn+2i9Z+PkdJOIDralzPHz7xsv/Wx9N4aJIpF611c+oIWoPjaTLunoBBAyhFMu3guK7f02IoDOUHJx6tBxcaPyXFNP1gqSGRJp7MdOGZEUJ0NckREULkTbc1LBMUxCJBMo5LKu1iZIdVkmmHhqZ0rndj6+4mAqZBNBygMhahPp7Cy+7Pcf2hlba4rkaZfl6J62lQfpChIG88JhfQ7PWv9jSGYUA2qVUIUbykR0QIQTQUoCwSoinp5IY67KBFZSxMKGj502c9ze7GJAB9ekUZ2CdG3/IIoaCFZRqUl4ZwPI9gNqg5kOahFjebCKI1uNmckL1HW5r/27xHT/u9J5ZpYlkmVhtF04QQxUF6RIQQKKXoX1VKPJWmPp7OFSozssmmYTuKAlKOS0VJCJUNNCKhIGE7QH08zaYdjaA1YTtAY6JljkdrtN4zIVi1Eny09lgpMA0/AKkoCRMNBQ7hJxdCFJrcSgghAH9F5eMGVFJRGiaVcWmIp4gnM4TtAP0qS9BoQkGLlOOSzrh50UHAUtTFkzieJmJbBCyD/eWQNneYeEDa8XBcj8z+xnEgO2Nnz2vLojYD+sSksqoQRU56RIQQOWXRELGIzeZdjWzc3kBTKkMilWH1xiT1TSk/l0QBKAKWSShgknHdbPVTD8tQxBMKy1JtpJuSTUjNf25/IYiBH7A0bxMwTQb0jjFsQIWsNSNEDyCBiBAiT31TKrcIXTQUwHU9djcm/aJjnodhGmjPLwOvtV92PRQ0cz0VTak0XrLt/R+g46Pl9vjBi1KKWNTm2OoKBh/Vy09WFUIUPQlEhBA5+xY2Uyh2N6b8WiKWIu14GJ5HwFIopbO1QjyaUn6WqTI6Hmi0r11+2zxPs2V3nGTaza30K4QobnJLIYTI2bewWdpx/QqppsrlYrjaD0C03jPM4no6uyZM5/NrjGTrhyiFbZnsbEiwYsMO6uL76XoRQhQFCUSEEDn7FjbztPan8yo/8Ahkc0S8bHGzvSnIrazb2RQKO2jheH6ps1g0SCrtUrtNKqsKUewkEBFC5Oxd2AzIlXr3V8n1y6tbpkE4GMCyDEzD2FPfg/0nnR4sjV/0zA76i+t5Wuet9CuVVYUobhKICCFy9i1s1lzq3c32dHien5xqB0wCptFi0buO6MgwTjhogc4WQMtWPTNNA8+TyqpCFDtJVhVC5LRW2Kw0HCCZypDK+EM0AcvI5oP46720tS7M/hgKTEPlrT/TZpuAplQG19OYhmJXY4KmVIawbWUrrMr9lBDFTD7BQog8+xY2SzseJZEgZdEQQcsknfHIOB6RUIDeZREsq+OXkXZUgM/R+EXPXE/nVvttSqbZXteEHTClsqoQRU56RIQQLTQXNosnMziuh2UaRGyLLbvjuUJnSilMQ9G/spSNOxtxHNefZtuO/WtUbrinvQwFjuuiUxrLNLO14aWqqhDFTgIRIUSrlFKUhIN5z/WrKOWo8pIWAcqCTzezblsdjuPh7pU3ovb+z15BiudpTAOcDqR3aJ1NiHU9LNOkdyxCynGIJzMt2imEKB4SiAghOqS1AGXYgAoS6Qzb6xLguBhqT70RBZiGQdS2SGZcMo6LaSg8rVst994W0/Bn8BiGX1fEsgzSGVeSVYUocpIjIoQ4ZGXRECOG9mVgVQzLMnC1n88RtAxiEZv+laVU9YpiGH6Z9j7lUUojQeyAidnO0RXDUJimv4aN1n7NE0lWFaL4SY+IEEcwrXXeMEs0FDjo1WzLoiFGH9ePfr1L+HTDTtKOSywcxLYtPE9T15jCyPamxBMZXA/CdgDLNGhItKwFYuCngDSP9BiG8kd4PNCmJpVx6VMWlWRVIYqcBCJCHKHq4klqtzVQ15TE8zSGoSiLhA5pDRelFNWVMaKhYG7f8UQGw1D0Kg1hGJBIZXA8D9sy/aGWgL+GTTrjosmWdFfZfJLmICQbG3m6uZS8gW2ZxKJ+Qu2hBFBCiMKSQESII1BdPMmKDTtIpV0iIQvTNHBdj50NCeKpNMcNqDykBeXamnXz8aqtfLZ1NyHbygUOSinCtl80zfX8fA+NnzuiFFiGgWX61V5dD0wDggGDjOvy2ZbdrN926AGUEKJwJBAR4gjTYoXdbEBgWCaxqEF9PE3ttgZiEfuQehlaS2rt3SvM+u11ZDIuKuAPtzRXS42ELExDEU9lUNn5NkY2ORWtwAQ7YBKyLWzLJBoOdHoAJYQ4/CQQEeIIs+8Ku3vbdw2X1qbFHkpeSa+SMGVRm1R2tovjetkekQCxSBClIJJy6FdRSkMiRTKVIe14KAWlYRtPaxIpp0sDKCHE4SWBiBBHmH1X2N2XaRp4KafVabGHmlcSDQXoHYuys6GJUNBCQ3Z2jYlGUx9PU1ka4ZjqcoC8gEdrzaK1Ww86gBJCdE8SiAhxhNl7hV3DMlt8321jWmxn5JXsvZZNcq/9ZFyXpqSDHTTpX1WaCzT2Dih2NyYPOoASQnRfMgFfiCPMvivs7k1rTVPSoSwSypsWu29eScAyMZQiYJnEokFSaZfabQ0t9teafdeyaWxKk8q4VJSG9xvM7B1AtaatAEoI0b1Jj4gQR5jWVtht7t1orVcCDj2vZF+tzao5UK5JcwC1syFBLGrkbdscQFWUhqWuiBBFRgIRIY5Azb0SuXyPlINhKCpKw63mexxKXklbWptVc6DtOxpACSG6PwlEhDhCdaRX4mDzSrqizR0JoIQQ3Z8EIkIcwdrbK9GdhkUOZlhHCNF9SSAihDig7jYs0tFhHSFE9yWBiBCiXWRYRAjRFSQQEUK0mwyLCCE6mwQiQogOkWERIURnkso/QgghhCiYLg1EXnjhBcaPH084HKa8vJxzzz23Kw8nhBBCiCLTZUMzzz77LJMnT2b69Ol87Wtfw3EcFi1a1FWHE0IIIUQR6pJAxHEcrrvuOmbOnMkVV1yRe3748OFdcTghhBBCFKkuGZr56KOPqK2txTAMRo0aRb9+/TjrrLMO2COSSqWor6/P+xJCCCFEz9Ulgcjq1asB+NnPfsbtt9/OvHnzKC8vZ8KECezcubPN182YMYOysrLc18CBA7uieUIIIYToJjoUiNx6660opfb7tWzZMjzPX/jqtttu41vf+hZjxozhscceQynFM8880+b+p02bRl1dXe5r/fr1h/bTCSGEEKJb61COyI033sikSZP2u83QoUPZtGkTkJ8TYts2Q4cOZd26dW2+1rZtbNvuSJOEEEIIUcQ6FIhUVVVRVVV1wO3GjBmDbdssX76cU089FYBMJsPatWsZNGhQu4+ntQaQXBEhhBCiiDT/3W7+O74/XTJrJhaLceWVV3LnnXcycOBABg0axMyZMwG44IIL2r2fhoYGAMkVEUIIIYpQQ0MDZWVl+92my+qIzJw5E8uyuPjii0kkEowfP57XXnuN8vLydu+jurqaJUuWMHz4cNavX08sFuuq5vZ49fX1DBw4UM7jIZBz2DnkPHYOOY+dQ87joWvtHGqtaWhooLq6+oCvV7o9/SYFVF9fT1lZGXV1dfJLcgjkPB46OYedQ85j55Dz2DnkPB66Qz2HstaMEEIIIQpGAhEhhBBCFEy3D0Rs2+bOO++Uab2HSM7joZNz2DnkPHYOOY+dQ87joTvUc9jtc0SEEEII0XN1+x4RIYQQQvRcEogIIYQQomAkEBFCCCFEwUggIoQQQoiCKbpA5IUXXmD8+PGEw2HKy8s599xzC92kopVKpRg5ciRKKWpqagrdnKKydu1arrjiCoYMGUI4HOaYY47hzjvvJJ1OF7pp3d6DDz7I4MGDCYVCjB8/nr///e+FblJRmTFjBl/84hcpLS2lT58+nHvuuSxfvrzQzSpq//7v/45Siuuvv77QTSk6tbW1/OAHP6CyspJwOMyIESP44IMPOrSPogpEnn32WS6++GIuu+wyFi5cyDvvvMOFF15Y6GYVrVtuuaVd5XdFS8uWLcPzPB555BEWL17Mr371Kx5++GF+8pOfFLpp3dqcOXO44YYbuPPOO/noo4848cQTmThxIlu3bi1004rGm2++yTXXXMPf/vY35s+fTyaT4YwzziAejxe6aUXpH//4B4888ggnnHBCoZtSdHbt2sUpp5xCIBDgxRdfZMmSJdx3330dWsoFAF0kMpmM7t+/v3700UcL3ZQe4a9//as+/vjj9eLFizWgFyxYUOgmFb1f/vKXesiQIYVuRrc2btw4fc011+Qeu66rq6ur9YwZMwrYquK2detWDeg333yz0E0pOg0NDfrYY4/V8+fP11/5ylf0ddddV+gmFZWpU6fqU0899ZD3UzQ9Ih999BG1tbUYhsGoUaPo168fZ511FosWLSp004rOli1bmDx5Mv/5n/9JJBIpdHN6jLq6OioqKgrdjG4rnU7z4Ycfcvrpp+eeMwyD008/nffee6+ALStudXV1APK7dxCuueYavv71r+f9Tor2e/755xk7diwXXHABffr0YdSoUfzud7/r8H6KJhBZvXo1AD/72c+4/fbbmTdvHuXl5UyYMIGdO3cWuHXFQ2vNpEmTuPLKKxk7dmyhm9NjrFy5ktmzZ/Mv//IvhW5Kt7V9+3Zc16Vv3755z/ft25fNmzcXqFXFzfM8rr/+ek455RS+8IUvFLo5ReWpp57io48+YsaMGYVuStFavXo1Dz30EMceeywvv/wyV111FVOmTOGPf/xjh/ZT8EDk1ltvRSm136/m8XiA2267jW9961uMGTOGxx57DKUUzzzzTIF/isJr73mcPXs2DQ0NTJs2rdBN7pbaex73Vltby5lnnskFF1zA5MmTC9RycSS65pprWLRoEU899VShm1JU1q9fz3XXXcd//dd/EQqFCt2couV5HqNHj2b69OmMGjWKH/3oR0yePJmHH364Q/uxuqh97XbjjTcyadKk/W4zdOhQNm3aBMDw4cNzz9u2zdChQ1m3bl1XNrEotPc8vvbaa7z33nst1gQYO3YsF110UYcj2Z6mveex2caNG/nqV7/KySefzG9/+9subl1x6927N6ZpsmXLlrznt2zZwlFHHVWgVhWva6+9lnnz5vHWW28xYMCAQjenqHz44Yds3bqV0aNH555zXZe33nqLX//616RSKUzTLGALi0O/fv3y/iYDfP7zn+fZZ5/t0H4KHohUVVVRVVV1wO3GjBmDbdssX76cU089FYBMJsPatWsZNGhQVzez22vveXzggQe4++67c483btzIxIkTmTNnDuPHj+/KJhaF9p5H8HtCvvrVr+Z65wyj4B2M3VowGGTMmDG8+uqruWn3nufx6quvcu211xa2cUVEa82Pf/xj5s6dyxtvvMGQIUMK3aSic9ppp/HJJ5/kPXfZZZdx/PHHM3XqVAlC2umUU05pMXV8xYoVHf6bXPBApL1isRhXXnkld955JwMHDmTQoEHMnDkTgAsuuKDArSseRx99dN7jkpISAI455hi5q+qA2tpaJkyYwKBBg7j33nvZtm1b7ntyd9+2G264gUsvvZSxY8cybtw47r//fuLxOJdddlmhm1Y0rrnmGv77v/+bP//5z5SWlubya8rKygiHwwVuXXEoLS1tkVMTjUaprKyUXJsO+Nd//VdOPvlkpk+fzne+8x3+/ve/89vf/rbDvcNFE4gAzJw5E8uyuPjii0kkEowfP57XXnut43OWhThE8+fPZ+XKlaxcubJFAKdlQes2ffe732Xbtm3ccccdbN68mZEjR/LSSy+1SGAVbXvooYcAmDBhQt7zjz322AGHFYXoTF/84heZO3cu06ZN4+c//zlDhgzh/vvv56KLLurQfpSWq6YQQgghCkQGtYUQQghRMBKICCGEEKJgJBARQgghRMEUVbKqaL+GhgY2bdqUKwQnhBCi4wzDoF+/fpSWlha6KT2WBCI9jOd5zJgxg7lz5xa6KUII0WOcd955TJs2TeoFdQEJRHqYGTNm8NxzzzFlyhRGjRpFIBAodJOEEKJoZTIZFixYwOzZswF/mRHRuWT6bg9SX1/P1772NaZMmcIll1xS6OYIIUSP8fjjj/PAAw/w+uuvyzBNJ5M+ph6kucLiqFGjCtwSIYToWZqvq83rnonOI4FID9KcmCrDMUII0bmar6syAaDzSSAihBBCiIKRQEQIIYQQBSOBiBBCCCEKRgIRIUSnmDBhAtdff32hm5HT3drT3SSTyQN+7Z0PMXv2bAYNGoRlWdx0003s2LGDPn36sHbt2sL9EJ3ke9/7Hvfdd1+hm3HEkjoiolWe51G7cRuN8QQl0TD9q6t6TCEf13VRSvWYn6c1WmviyQyO62GZBtFQAKVUoZt1QOl0mmAwWOhmFIT2PPT2HehEEhUOoXpXorrwd3T06NEsXbq0ze8rpVi9ejWDBw9m4cKF3HDDDfz5z39m1KhRlJWVcfvtt/PNb36TwYMHd1kbD5fbb7+dL3/5y/zwhz+krKys0M054vTcK7E4aJ+uXM+vH/kTM2c9wf0PPsnMWU/w60f+xKcr13fZMf/0pz8xYsQIwuEwlZWVnH766cTjcTzP4+c//zkDBgzAtm1GjhzJSy+9lHvdG2+8gVKK3bt3556rqalBKZW7U/uP//gPevXqxfPPP8/w4cOxbZt169aRSqWYOnUqAwcOxLZthg0bxu9///vcfhYtWsRZZ51FSUkJffv25eKLL2b79u1ddg46S108ydLPtvPJmi0sXruVT9ZsYeln26mLJ7vsmJMmTeLNN99k1qxZKKVQSrFq1SquuOIKhgwZQjgc5nOf+xyzZs1q8bpzzz2XX/ziF1RXV/O5z30OgHfffZeRI0cSCoUYO3Yszz33HEopampqcq/d3/vTWnu68527u6GW9HN/ITXnT6T+NJfUnD+Rfu4vuBtqu+yYP/zhD4nFYqxYsYI1a9bkfZ122mmcfvrpuSBj3rx5jBs3jrPPPpt+/foB8Pvf/54rrriiy9rXXo7jHPI+vvCFL3DMMcfwxBNPdEKLREdJICLyfLpyPb9//HkWLVlFRXmMY4b0p6I8xqIlq/j94893STCyadMmvv/973P55ZezdOlS3njjDc4//3y01syaNYv77ruPe++9l48//piJEyfyjW98g08//bRDx2hqauKee+7h0UcfZfHixfTp04dLLrmEJ598kgceeIClS5fyyCOPUFJSAsDu3bv52te+xqhRo/jggw946aWX2LJlC9/5znc6/efvTHXxJCs27GBnQwI7YFISCWIHTHY2JFixYUeXBSOzZs3ipJNOYvLkyWzatIlNmzYxYMAABgwYwDPPPMOSJUu44447+MlPfsLTTz+d99pXX32V5cuXM3/+fObNm0d9fT3nnHMOI0aM4KOPPuLf/u3fmDp1at5rDvT+tNaegQMHdsnPfqjcDbVk/voy7prPUKWlGP37oUpLcdd85j/fRcHIJZdcQjKZ5JNPPmHw4MG5r5KSEt566y1++MMfAjBs2DBuv/123n33XZRSXHLJJfz1r3/Ftm2+9KUv5fbneR7Tp0/n2GOPJRQK0bdvXyZNmpT7/qJFizj77LOJxWIcddRR3HjjjaTT6dz3X3rpJaLRaN5w0KJFi1BK5QLMtWvXopTi6aef5p//+Z+xbZvnn3+edevWcemll9K3b1/C4TAnnngib7/9dm4/69at48ILL6S8vJyKigouuugidu3alXc+zjnnHJ566qlOPceifWRoRuR4nseL899j5656jhs2MNeVX1oS4bhhA1mxcj0v/e97HDO0f6cOa2zatAnHcTj//PMZNGgQACNGjADg3nvvZerUqXzve98D4J577uH111/n/vvv58EHH2z3MTKZDL/5zW848cQTAVixYgVPP/008+fP5/TTTwdg6NChue1//etfM2rUKKZPn5577g9/+AMDBw5kxYoVHHfccYf2Q3cBrTW12xpIpV1i0WDu/TMsk1jUoD6epnZbA7GI3enDNGVlZQSDQSKRCEcddVTu+bvuuiv3/yFDhvDee+/x9NNP5wV00WiURx99NDck8/DDD6OU4ne/+x2hUIjhw4dTW1vL5MmTc69pz/vTWnu6G+15OH//AK+hEWNA9Z73JRLGCFfjbdiI8/cPMar7dfowTe/evTn33HP5wx/+wPnnn597/oknnqCsrIxzzz0X8HunTjrpJK666ip+8IMfUFJSwm233caYMWPy9jdjxgzmzJnDb3/7W4YOHUptbS3Lli0DYMGCBXzlK19hypQpPPDAA2zYsIELL7yQXr168dOf/jS3zRe+8IW8a0tNTQ3V1dX07t0bgIULFwIwc+ZMpk+fzpAhQwgEAowbN44vf/nLPP/881RUVPDGG28Qi8UAWLlyZa79f/vb32hsbOTqq6/m5ptv5tFHH80da9y4cfziF78glUph23annmuxfxKIiJzajdtYuXo91f16t/hDpZSi+qhKPl21ntqN2xg4oG+nHffEE0/ktNNOY8SIEUycOJEzzjiDb3/725imycaNGznllFPytj/llFNyF6T2CgaDnHDCCbnHNTU1mKbJV77ylVa3X7hwIa+//nquh2Rvq1at6paBSDyZoa4pSSRktfr+RUIWdU1J4skMJeHDk4fx4IMP8oc//IF169aRSCRIp9OMHDkyb5sRI0bk5YUsX76cE044gVAolHtu3Lhxea8pxvenNXr7DrzajRiVFa2+Z0ZlOV5tLXr7DlSfqk4//uTJkznzzDPZuHEj1dXVADz22GNccsklufekpKSEtWvXcuqpp+aCus8++yy3fbOXX36Zc845h69+9asADBo0iJNPPjl3nIsvvpi7774b8HtZLrvsMubNm5cLRGpqanI3Cs0WLlyY91xNTQ3RaJRnnnkmN2x09tln86UvfSmvp+3YY4/N/f/qq6/m6quvzguKb7nlFm6++ea8Y1VXV5NOp9m8eXPuhkgcHhKIiJzGeIJUKk0k3PrdQDgSIrV1J43xRKce1zRN5s+fz7vvvssrr7zC7Nmzue2225g/f/4BX9t897T3kkmZTKbFduFwOO9CHw6H97vfxsZGzjnnHO65554W32seI+9uHNfD8zSm2fqds2kaeCkHxz08lSGfeuopbrrpJu677z5OOukkSktLmTlzJu+//37edtFotMP7Lsb3pzU6kUSnM6hQG3fgto3euQud6JohtdNOO41Bgwbxxz/+kWnTpvHhhx/y8ccf5w1RfPzxx8CeXkqARCKRFygCfOMb32Dq1Kl88MEHXHDBBXzrW9+ivLycZcuW8eGHH7bIvwgGg6RSqdzjBQsWMGXKlLxtampqGDt2bO7xwoUL+cY3vpELQj777DNefPFFFixY0OrP99lnnzF//nzefvvtvFkxruu2GKprviY0NTW1frJEl5EcEZFTEg1j20GaEqlWv59oSmIHA5RE9/9H/GAopTjllFO46667WLBgAcFgkFdffZXq6mreeeedvG3feecdhg8fDkBVlX+XuPf6D3snNLZlxIgReJ7Hm2++2er3R48ezeLFixk8eDDDhg3L+zqYP5yHg2UaGIbCbSPQcF0Pw1BYbQQqhyoYDOK6bu7xO++8w8knn8zVV1/NqFGjGDZsGKtWrTrgfj73uc/xySef5P2R+sc//pG3TXven33b0x2pcAgVDECy9c8cqRQqEECFQ61//1CPrxSXX345jz32GOAPb5188sl8/vOfz21TU1PT4ve+d+/eLXIsbrrpJpYuXcppp53Gr371K4YNG8aaNWtYvHgxgUCgRS/VkiVLcsFNPB5n1apVeb0fnuexYMGCFj0iEyZMyHscDAZb9LI1W7hwIRUVFXz88cfU1NTkvj755BNef/31vG137twJ7LmmiMNHAhGR07+6imFDB7Jx03b2XZRZa83GzTs49piB9K/u3A/q+++/z/Tp0/nggw9Yt24d//M//8O2bdv4/Oc/z80338w999zDnDlzWL58Obfeeis1NTVcd911gN/FO3DgQH72s5/x6aef8sILL7SrHsDgwYO59NJLufzyy3nuuedYs2YNb7zxRq5795prrmHnzp18//vf5x//+AerVq3i5Zdf5rLLLuu2f9yioQBlkRBNSafV968p6VAWCRENdc1aRIMHD+b9999n7dq1bN++nWOPPZYPPviAl19+mRUrVvDTn/60RUDRmgsvvBDP8/jRj37E0qVLefnll7n33nsBcr1a7Xl/9m1Pd1wjRPWuxOhfjbdjZ6vvmbdjF0b//qjelV3Whssuu4zVq1fzv//7vzz55JN5uTjQ+pDJqFGjWLJkSYt9HXfccdxyyy18+OGHNDQ0sGTJEkpLS3FdN6+ncs2aNcydO5eLLroo99jzPI4//vjcNi+//DI7duzIHbu+vp61a9fmLeoZCARwHKfNXoxAIEBDQwPV1dUtAtb+/fvnbbto0SIGDBiQy0cRh48EIiLHMAzO+n8nUVEeY8XK9TQ0xHFcl4aGOCtWrqeiIsaZp5/U6fU3YrEYb731FmeffTbHHXcct99+O/fddx9nnXUWU6ZM4YYbbuDGG29kxIgRvPTSSzz//PO5MeBAIMCTTz7JsmXLOOGEE7jnnnty49AH8tBDD/Htb3+bq6++muOPP57JkycTj8cBcj0xrutyxhlnMGLECK6//np69erVbeuPKKXoX1WKHTSpj6fJOC6e1mQcl/p4Gjto0r+qtMvqidx0002Ypsnw4cOpqqpi4sSJnH/++Xz3u99l/Pjx7Nixg6uvvvqA+4nFYvzlL3+hpqaGkSNHctttt3HHHXcA5IYD2vP+7NuedevWdcnPfSiUYWCNG4tRWoK3YSO6qQntuuimJrwNGzFKS7DGjenSeiLV1dWcffbZXH755biu22JmWPP7sLeJEyeyePHiXK/IL3/5Sx5//HGWLl3K8uXL+clPfkJlZSUnn3wy48ePp1evXtx6662sXr2a1157ja9//et873vf48wzzwSgsrISpVQuUP3b3/7GtddeSygUyvWkLFy4ENM084aIxo8fT1lZGVdddRVLly5lyZIlPPzww7lZdePHjycWi3HJJZewcOFCVq5cyUsvvdRqobv/+7//44wzzuiUcyo6SIseY+nSpXrMmDF66dKlh7SfFZ+u07N+M0f/+KZ79Y+mzNA/vule/cBDc/SKT9d1UktFV9rdmNCL12zV7y5ep9/+5DP97uJ1evGarXp3Y6LQTTtoTzzxhA4EArqpqanQTekSzvoNOvnsc7rpgd/o+H2zdNMDv9HJZ/+snfUbDsvx//KXv2jTNPVVV12V97zrujoSieh58+a1eM24ceP0ww8/rLXW+q677tLHHXecDoVCunfv3vqb3/ymXrJkSW7bt956S48ePVqHQiE9dOhQPWPGDO04Tt7+7r77bl1eXq6PPvpofemll+qpU6fqsWPH5r4/e/Zs/U//9E8t2vH222/rk046SUejUV1eXq7POussvXv37tz333//fT1hwgQdi8V0aWmpHj16tJ41a1bePhKJhC4rK9Pvvfdem+eos66voiWl9T79gaJoLVu2jB/84Ac88cQTeV2cB6MnV1Y9Eugiraza7PHHH2fo0KH079+fhQsXcu211zJhwoQeXXDqcFdWPVQvvPACN998M4sWLSr6a8NDDz3E3LlzeeWVV9rcpjOvryKfzJoRrTIMo1On6IrDSyl12KbodoXNmzdzxx13sHnzZvr168cFF1zAL37xi0I3q0spw+iSKbpd5etf/zqffvoptbW13bZYXHsFAgFmz55d6GYcsSQQEUJ0O7fccgu33HJLoZshDqCnLCrYXEVWFEZx96cJIYQQoqhJICKEEEKIgpFApAdpThhrrbKoEEKIg9d8XS32xNzuSM5oD9K8DkRb5Y6FEEIcnObrajEtIVAsJFm1B4nFYpx33nm57O9Ro0YRCHRNFU0hhDgSZDIZFixYwOzZsznvvPMoLS0tdJN6HKkj0sN4nseMGTOYO3duoZsihBA9xnnnnce0adNkaKYLSCDSQzU0NLBp06Zuub6GEEIUC8Mw6Nevn/SEdCEJRIQQQghRMNLHJIQQQoiCkUBECCGEEAUjgYgQQgghCkYCESGEEEIUjAQiQgghhCgYCUSEEEIIUTASiAghhBCiYP4/RU3+j7G7AwAAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_source, data_target, inverse=False)" + "learned_potentials.plot_ot_map(data_source, data_target, forward=True);" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_target, data_source, inverse=True)" + "learned_potentials.plot_ot_map(data_source, data_target, forward=False);" ] }, { @@ -424,129 +242,106 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "samples_source = jnp.concatenate(\n", - " [next(dataloader_source).numpy() for _ in range(10)]\n", - ")\n", - "samples_target = jnp.concatenate(\n", - " [next(dataloader_target).numpy() for _ in range(10)]\n", - ")" + "samples_source = next(train_dataloaders.source_iter)\n", + "samples_target = next(train_dataloaders.target_iter)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "To use the Gaussian initialization, the samples of source and target (`samples_source` and `samples_target`) need to be passed to the {class}`~ott.solvers.nn.icnn.ICNN` definition via the `gaussian_map` argument. Note that ICNN $f$ maps target to source (`gaussian_map=(samples_target, samples_source)`), and $g$ maps source to target cells (`gaussian_map=(samples_source, samples_target)`)." + "To use the Gaussian initialization, the samples of source and target (`samples_source` and `samples_target`) need to be passed to the {class}`~ott.solvers.nn.models.ICNN` definition via the `gaussian_map` argument. Note that ICNN $f$ maps source to target (`gaussian_map=(samples_source, samples_target)`), and $g$ maps target to source cells (`gaussian_map=(samples_target, samples_source)`)." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# initialize models using Gaussian initialization\n", - "neural_f = icnn.ICNN(\n", + "neural_f = models.ICNN(\n", " dim_hidden=[64, 64, 64, 64],\n", " dim_data=2,\n", - " gaussian_map=(samples_target, samples_source),\n", + " gaussian_map=(samples_source, samples_target),\n", ")\n", - "neural_g = icnn.ICNN(\n", + "neural_g = models.ICNN(\n", " dim_hidden=[64, 64, 64, 64],\n", " dim_data=2,\n", - " gaussian_map=(samples_source, samples_target),\n", + " gaussian_map=(samples_target, samples_source),\n", ")" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "260b8efc648f42e98392e7884d5f3da2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "neural_dual_solver = NeuralDualSolver(\n", + "neural_dual_solver = neuraldual.W2NeuralDual(\n", " input_dim, neural_f, neural_g, optimizer_f, optimizer_g, num_train_iters=0\n", ")\n", - "neural_dual = neural_dual_solver(\n", - " dataloader_source, dataloader_target, dataloader_source, dataloader_target\n", - ")" + "learned_potentials = neural_dual_solver(*train_dataloaders, *valid_dataloaders)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Again, we can plot the corresponding transport from source to target using the gradient of the learning potential $g$, i.e., $\\nabla g(\\text{source})$, or from target to source via the gradient of the learning potential $f$, i.e., $\\nabla f(\\text{target})$." + "Again, we can plot the corresponding transport from source to target using the gradient of the learning potential $f$, i.e., $\\nabla f(\\text{source})$, or from target to source via the gradient of the learning potential $g$, i.e., $\\nabla g(\\text{target})$." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAG6CAYAAAAF5Ty4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9aYwsaXrfh/7eN7aM3LOy9uWcqrP2NtM9Pb1MjyhSJIccksO5GlrilXgFkFpsf5ENG7RsmIItWbbh8QIDtiEBtgFbcwHBkKwLkvLCO7riWBJNcmZ6ujlL93T3WevUvua+Rsby3g9vRWVVnaqz9Fmq+nT8gEJtmZGRkZH5/uN5/s/zCKWUIiEhISEhISHhGUKe9g4kJCQkJCQkJDxuEoGTkJCQkJCQ8MyRCJyEhISEhISEZ45E4CQkJCQkJCQ8cyQCJyEhISEhIeGZIxE4CQkJCQkJCc8cicBJSEhISEhIeOZIBE5CQkJCQkLCM4d52jtwGkRRxPr6OrlcDiHEae9OQkJCQkJCwgOglKLVajE9PY2U947RfCoFzvr6OnNzc6e9GwkJCQkJCQkfg5WVFWZnZ+95m0+lwMnlcoA+QPl8/pT3JiEhISEhIeFBaDabzM3N7a/j9+JTKXDitFQ+n08ETkJCQkJCwieMB7GXJCbjhISEhISEhGeOJypw/uAP/oCvfvWrTE9PI4Tgd3/3dw/9XynF3/pbf4upqSlc1+VLX/oSN27cuO92/97f+3vMz8+TSqV48803efvtt5/QM0hISEhISEj4JPJEBU6n0+Hll1/m7/29v3fs///L//K/5L/77/47/vv//r/nu9/9LplMhi9/+cv0+/0Tt/mP/tE/4jd/8zf523/7b/Mnf/InvPzyy3z5y19me3v7ST2NhISEhISEhE8YQimlnsoDCcHv/M7v8LWvfQ3Q0Zvp6Wn+nX/n3+Fv/I2/AUCj0WBiYoJvfOMb/MW/+BeP3c6bb77J66+/zt/9u38X0CXfc3Nz/Jv/5r/Jv//v//sPtC/NZpNCoUCj0Ug8OAkJCQkJCZ8QHmb9PjUPzuLiIpubm3zpS1/a/1uhUODNN9/k29/+9rH3GQwGvPvuu4fuI6XkS1/60on3AfA8j2azeegrISEhISEh4dnl1ATO5uYmABMTE4f+PjExsf+/o+zu7hKG4UPdB+DrX/86hUJh/yvpgZOQkJCQkPBs86moovqt3/otGo3G/tfKyspp71JCQkJCQkLCE+TUBM7k5CQAW1tbh/6+tbW1/7+jjI6OYhjGQ90HwHGc/Z43Se+bhISEhISEZ59TEzgLCwtMTk7yrW99a/9vzWaT7373u7z11lvH3se2bT7/+c8fuk8URXzrW9868T4JCQkJCQkJnz6eaCfjdrvNzZs3939fXFzkBz/4ASMjI5w7d45/+9/+t/lP/9P/lMuXL7OwsMB/+B/+h0xPT+9XWgH87M/+LL/yK7/Cv/Fv/BsA/OZv/ia/8Ru/wWuvvcYbb7zBf/Pf/Dd0Oh3+yl/5K0/yqSQkJCScOVQUoXYrqF4f4aYQo2XEfQYQJiR8WniiAuedd97hp3/6p/d//83f/E0AfuM3foNvfOMb/Hv/3r9Hp9PhX//X/3Xq9To/8RM/wTe/+U1SqdT+fW7dusXu7u7+73/hL/wFdnZ2+Ft/62+xubnJK6+8wje/+c27jMcJCQkJzzLh6hrB2+8Qra2jBj7CtpAz05hvvIYxO3Pau5eQcOo8tT44Z4mkD05CQsInmXB1Df/3/ilRq40sj0DKgb5HVKkic1msX/pyInISnkk+EX1wEhISEhIeHhVFOnLTaiNnpxFpFyElIu0iZ6eJWm2Ct99FRdFp72pCwqmSCJyEhISETxBqt0K0to4sjyCEYKNXpDFIoTodVLOJcFOEq6uo3cpp72pCwqnyRD04CQkJCQmPF9Xra89NygGg1VS0qm3SzQ8hCkHo69bwzjJyfOw0dzUh4VRJBE5CQkLCA3BWKpaEm0LYFvQ9Aj8g2ujhDurg2GCa0OtDu0Xw7e8ipycTL07Cp5ZE4CQkJCTch7NUsSRGy8iZaYLbd+i0FcovkkpLhLBAKZTvw8QEyvcJ3n4XOT2VlI4nfCpJzvqEhISEexBXLIWLS4hcDjkzhcjlCBeX9N9X157q/ggpMd94DWmZdHe7YBi4qovnS7zmAOHYGLMzyNERorW1xIuT8KklETgJCQkJJ3BWK5aM2RnMt97Ec0uoKMJp77IczrBS+gzy8iVkPgeOg/J9VK//VPctIeGskKSoEhISEk7gaMVSqAQNP0PRaiOFQJZL+1ES8ZQNvcb8eQYT2xjSwMpGGP45hGMj85v6Bp6HsCyEm7r3hhISnlGSCE5CQkLCCcQVS+xVLHUDh0o/RytI6xucYpREjJYRoyMwGEA+h3AcLCPU+60UUaWGnJlBjJaf+r4lJJwFEoGTkJCQcAIHK5YAbBkA0AstfYNTjJIIKZGXLyPcFL3VCsrzSIseqtslWl1H5rKYb3w+MRgnfGpJUlQJCQkJJxBXLIWLS0h3el/g9EN7P0piLMyfWpRElsuI11/FWxKotR5Obx3l+BgL85hvfD4pEU/4VJMInISEhIQTiCuW1G5FR0XKJVQU4g9CourpRkniKYLOZBl/5mewNlsUx5uYmWSqeEICJAInISEh4Z4YszPwS18e9sHp1sE0Tj1K4vv6u+tCsykRhQL2QuFU9iUh4SySCJyEhISE+2DMziCnp1C7FazrgGVjv5471ShJr6e/a4FzaruRkHBmSQROQkJCwgMgpESMjyFrOj0kTjkD1O3q7667tz/idPcnIeGskSRpExISEh4C19Xfn3Jvv7uIIzi2rb8nAich4TCJwElISEh4CFJ7FeH9U24QHHtwQt36hnT69PYlIeEskqSoEhISEh6COILT6z26qHiUCeVxFVWcqspkHm1fEhKeNRKBk5CQkPAQHBQ4j8LjmVAe0VppEFUDUlmBKox8asrDH0UcJnw6SAROQkJCwkNg7n1qPkqKKp5QHrXaes5VyoG+R7i4pKd//9KX7ytyokqF6MYNGtUdggHwg1UGDy2QPpk8HnGY8KyTCJyEhIRnnidxtR97Xz7OvhyaUB67g9Mu0p0mWl0nePtd5PTUifvoL68RvvMBjldnkB1F5CyE1XgogfRJ5XGIw4RPB4nASUhIeKZ5Ulf7sQfmoe93ZEJ503dp+ymm0zXEA0woV1FE+zs/QvUC0tN5vIENnodigCgVCKt1xH0E0ieVo+IwUAaGiJAPIQ4TPj0kAichIeGZ5Uld7QvxCAJnb0K52JtQvt0voNSBGm/HQVVrJ04oV7sVOut1RG4St7fJ2qbHoBcReh+BNBBuivDGjRMF0ieZg+IQBHfaE4w4bcpO64HEYcKni0TiJiQkPJPclQpKu7pZX9pFzk4TtdoEb7+L+hgNbR4lOHB0QrniSAOb+0woV70+vYGBCgLM2x9R66XxrCzkcuDYqFabaGWV8M7yx9/JM0osDkk5rPb0gFNDHHj9HAfl+yeKw6eFiiKi7R3CpRWi7Z2PdY4lPDpJBCchIeGZ5OjV/nq3xIjTJmX4j3y177rQbkMQDE3HD8rRCeWH9vkBJpQLN0XfyKB2dxn4ApW1cUQHgQDLQqVdqNcJr13HfO1zz1SqJhaHfjegH+kOh0W7M7zBfcTh0yAxQJ8dnp0zPyEh4RPFk77KPXi1rxB0ghSb/eLwBo9wtf8opeLxhHKZyxKtrmv/TBSiul09sfw+E8rFaBmRyRK12nRT2sdj46FA5816fRgpE9XqOg33DBGLw8WdLArFXGZn/3+xOJQzMyeKwydNnBINF5cQuRxyZgqRyxEuLum/r66dyn59WkkiOAkJCU+dp3GVezAVJNNakfjhgY+8R7jaPyhwcrmH37eDE8rVYg8VhKh0+4EmlAspETPTiGs36HoGGBEtUeBWtMDF9g8Rjo04Pwft9qmnah43Qkq6L76BWHkfWdnBMVsoxwHP0+LmPuLwSfI4quMSHi+JwElISHiqPK0y36OpICEUSok9c/D9U0H34nGMa4gnlFvvtIi8Ac5VHrh8XY6PI8dGafcCVBhihU0gQJSKyJlphGmgTjlV86TYUlMYr9ksbP4Rar2NqtYQlvVA4vBJcjAl6kU2670S85ltpCAxQJ8SicBJSEh4ajzNq9w4FaR2K0Sr64zkDXbVKI2WINdYe6Sr/fguj9rNWEiJKBSQCuT4Q9wvn8OeGae93kNYZVzDxHayGGU9ryFaXf/Y4u0ss76uv49eLpN665fPVCfjOCUa2GlWOqMAREoiYxP0farjEh4/icBJSEh4ahztAVMbZBAoinb3Y13l3q+B38FUUH51g52eya5pUzzlq/1HYTAAhCT78iU2du8Q9gNSxZBMOoRe78RUzSd9tEEYQrOpfx4fB5BnKhIi3BSR5XCnVkI4MJWuYsoDvrIzYID+tJEInISEhKfG0R4wu/08AEV7b2LkQ1zlPqiPZz8VtFvBvAbCtrFfzz16hOgReuE8CnHUKDs/TngxRbi8A70t3N4aygmOTdU8C5U9N2/q73Nzp7sfJ1Iucyf3Mmprh7F8n6zp7f/rQarjEh4/py7f5+fnEULc9fXX//pfP/b23/jGN+66bSqVKOKEhE8CR3vAlJw2ALvenlP3Aa9yH7ZaRUiJHB/DmR5DFApE6tQ/+vZ5WJEUCxzTBJHLIy8sYP3pP0Xxz/0Czl/489hf++W7xM0nvbKn29XHSYizOzX9xk2JvHKZYi4gv30D1e2iwgevjkt4/Jx6BOd73/se4YGhLu+//z4/93M/x6/+6q+eeJ98Ps+1a9f2f9/P4yckJJw5DqZGcGzk9BThnWWkO82o06LmZal5Wcp284Guco/6eECgEA/Urn90FDY2oFbTPz8KlqXTRfHC+yg8zP1jgRME+rvc8/FYC4W7bnv3aAMTU4S62eEnqLJnea9n4cWLp7sfJ3H9uj4PsnNlZs6/QfC21NGyM2KA/rRy6gJnbOxwDvU//8//cy5evMhP/dRPnXgfIQSTk5NPetcSEhIekeNSIyKbRUihr2rLJbJGm1bXolprM1K4/1XuUR9PxctRH6S5mNu6r48nn9cCp1J5dIHjulrg+D7Y9qNt62EYDPT37l5W716PffRY3WmNk7X6TLkPNvfqLLCz1+oml3v4popPg+VliCJtPD93DkCnRD/JfqdnhTN1xAeDAf/gH/wD/upf/av3jMq0223Onz/P3Nwcf/bP/ll+/OMf33O7nufRbDYPfSUkJDxZTkqNRNUaKJAjJVSrzVj1I1SvR3X0eawHKBE/2MAPoOm7REoSRHsfZ/do4Bd/rDwO78yjNPt7HDQa+ns6fXIE6FCzw73n3Amc4Q3OyGiDk4giLUYBpqfvfdvTYHNTC00h4MqV4d/jlKhxfg45PpaIm1PiTB313/3d36Ver/OX//JfPvE2V69e5X/+n/9n/sk/+Sf8g3/wD4iiiC9+8Yusrq6eeJ+vf/3rFAqF/a+5M+tSS0h4NrjfHCilFOTz2L/6r5D6879C4effwvzC63QL9w/hH/XxTLo1ALbiLsX38fHElr04xfNxOS2BE6fEej39cyoFjnP8bQ8eq3agn3jJbg9vcMYre+7c0d+nph49Dfi4qVahXtc/HxQ3CWeHMyVw/qf/6X/iF3/xF5m+h1R/6623+PVf/3VeeeUVfuqnforf/u3fZmxsjP/hf/gfTrzPb/3Wb9FoNPa/VlZWnsTuJyQk7HE0NeKFJnfaY3uLs06NqPV1hJQY5+eYe6kEQrL2AH7XuIFfVKmilMI1fAC6gfNA7frjrHjlEacYxKmh04rg9PtapDnOycbbg8eqOtA3Klg6t3UWRhvcC8/T6TghoHC3vehUabVge1v/fPny2RNfCZozk9FcWlri93//9/nt3/7th7qfZVl87nOf42ZcQ3gMjuPgnHSJk5CQ8Ng5Wg7uRRZ+ZLLZLzHl1u4qB5dSL9Sep0P+6fTJ2z7awE+WSziiT78v6NV3cfP39vHEYqBeh4mJj/8c40Ut9sQ8DeJxXamUPla+D4ZxD4Fz4Fj1t1uIbBYj46O6pz/a4H4sLurvCwunux9H6ffZF+IXL+rjn3A2OTNn9d//+3+f8fFxvvKVrzzU/cIw5L333mNqauoJ7VlCQsLDcjSNlLd0mKPtp4iUODY1og2a8CABVmN2Rvt1Fs5rH09d+3i2xz/7QD6e0+ph86jEoyEcR4udWPDE6bLjiI+VHB+Dfo9oYxPV0nOvHuRYnQZx6ieVeroG7vvh+8O02fy8rqRLOLuciQhOFEX8/b//9/mN3/gNzCM2+V//9V9nZmaGr3/96wD8x//xf8wXvvAFLl26RL1e57/6r/4rlpaW+Ff/1X/1NHY9ISHhGO6eAyWYdGts9kosd8rM1VbvKgc3DB3JiSIdnbhf0DVu4Kd2K9i9PtZmHpXPYcze/7otk4F2W0dfHmUBfdpCKU6HxQGXOHpwvxSJPzqD+YUpclEDJ/uZM13Zo5Q27wKcP3+6+3KQMIRbt/TPMzNDL1fC2eVMCJzf//3fZ3l5mb/6V//qXf9bXl5GHngT1mo1/rV/7V9jc3OTUqnE5z//ef74j/+YF1544WnuckJCwj04Lo2UdUIYpPGabcJSAeeY1MjCgl5E7tyBq1cf7HHi8ua8qb0Rnc79m8GNjmqBs7t7NqtzTiIWOHHrsActm65WASEZvVTCcEpPZN8eF3G9yNjY2fG2KAU3buifx8c/3gT5hKePUOqTGKh9NJrNJoVCgUajQT6fP+3dSUh4ZjnUB8f38YwMa/mXMK5e4vkvHm9svXZNLygXLz5cCiAM9SIk5YNVtXz0kV5AH0RIncTSkhYdV69+/MX4o490JOby5fvf9sYN/TxtW3tUbFsvuPd7DvExfe65j7ePTwvfH0ZJztK+xsevWISkBdvp8jDr95mI4CQkJDybHEwjqV6flJtiq1oGJP3+8WH++Xm9eN+582CL/v5j7aVroujet4t5HOkl19UCp9+/tw/mQfblQYifW7Opf3bdB3vcx9Ft+Wlw+7b+fpZSUzdu6OPnuom4+aRx9hKwCQkJzxRHm55duqQ/dpaWjr+94+jFOAyHqZgHZWREf4+b4N2L+OLvUcq8H1cvnAe1wsSCrN/X0Y57lYjHxP1+zrpnpN3Wz88wHk0sPk6Wl/U5KOXZEl0JD0YicBISEp4qpqkXZqW0Z+Y44l6c8QyiByUevxCbVO9FeS9Dtrv7cI9xkFg0PC2BA1r8xSXilnV/gRNXJMXi76wSe28uXDjd/YjZ2jq+S3HCJ4dE4CQkJDx14qvhkxr7xX1wPO/BU06ghUKcerpf+imunopnOn0cYo/QxxU48T4+TPrINHVUJo5u3S8yU63q79nsw+/f0yIWpMXi2egrU6vpL0jEzSeZROAkJCQ8daQcVqKc1FF4ajJCNRqsvLtFtL2DekCl8zCdih9XmffDptJi4sd+kAiOrxs271dOPagQiA/bWfXghOEwynQWPC7tto7eQNKl+JNOYjJOSEg4FaandXXKzo5OnxxcSMLVNVJvv4N/26IRhIylVzFmpzHfeO2+jelKJd1G/0EmhpdKOsLRbj9ahOPjiqSHEThHo0Smef/FN97+WZzCHRNXTc3Onu5+gPY2xamypEvxJ58kgpOQkHAqCDEUIBsbw78fnEI+XhggyiW2nfOEi0v676v3HlglxDAyc7+gT+xLeRQfzqNc4Z8UXVFRRLS9Q7i0sh+9OtoD517jLGKaTf39rPpvej19DIQ4/RTawS7F588nXYqfBc6wrk9ISHjWGR3V4qLZ1OkJweEp5CURstuUtI0ik7PTRKvrBG+/i5yeumcX3ulp7e/Z3r532iOObMQjED4OUn78FFUscA4+lUO9gwY+wraQM9O0574IuTE6Hf14udz9Dcax/+asDauMiSvpLl483f2IosNdis9KFVfCo5FEcBISEk6VuJPw0tLdU8iVAtPQdc6VQR5ZLhGtraF2722wif09sbfjXsTRk4+bZooXw48jco6mqA5Gr0Quh5yZQuRyhItL9L79A6JK5YGmiMd4ehTYmUy1xFGzbPZ0U2hKwfXr+uekS/GzRSJwEhISTpV8/kDpc0tPIWdvCnkzSBOEJr3QouZl9RRy39+fQn4v4kUz7gNzEnGaLE7nPCyP0gvnYIpKRYejVyLt6iiVm0KUikS1BuF779Pthvi+rgI7SeDEKa5oZweajQc2aD8tlBoKnJlTnvUZi5ti8eym8hI+HkmKKiEh4dQ5d05HcBYrec7HU8jTLjmzyzYF+qGNa/jU2xaFI1PIT2JmRm9zY2PYV+c4SiVtdN7dPTmVo6Jovxvz0UGVB3vhPKyP5GCK6mj0qhvYeI0eudUPUK02oXwOUavj9ct4IxcQIn3soNA4xdVZqRD0xig4PQarzgMZtB8H9zpWMbHXZXLydKuUbt5MuhQ/yyQCJyEh4YEWpSeJ6+5FMXI5BpPnsJZvId1ppBA4hk/R6tALTbZrJqUrM4emkN9rm6CHb96L+GnGZdhHOckTEwuGR4ngHExRqbaOXom96NXKmiBcqZGpr4I0IDMgUhBVKkjPJqqUUVHp0Oum+n38b/4zolabevYyuFmK/i7h+7eJVtawf+WrGOfuofYekfsdK9AT3D1Pv97F4hPblfuysqKje0IkXYqfVRKBk5DwKedBFqWnwYULcOuWZH3mCyzUtvankM8429zqjtJuRKQyKXovvoTzgOIrnhXledqzchJx87woutvw6//eP9Vpo/KIFh99j3BxSfuAfunL+8foUVNUwk0h9qJXke8TrXjg+ZBKoQwThESEAZEfYPTbRD9YY7DZIFrf0Gk9y0Q1mghAXrlEZ9tCVTcwmtcJgwCxsU7//93E+Y2/hPkERM6DHqt43tT8/GPfhQdme1sL30cdtnocp32xkDAkETgJCZ9iHmYBf9JYlvaVDEbK9P/ML+K+/zbR2jr4NSwcRicnCBZeYFONUHzAbU5N6QGO6+uwsHDy7UZHdTfdWm04wuGoJwZ0LkWkXaR7uKLr49oZD6aoxGgZOTNNePsOUbWKGowhHAt8gz4pfEzMlAlKYXktolu3COtV5Mw0IuWgqjXC9Q1E2iVa36Kym6Yw6CEcG5FJo3p9ovUN/N/53xB/7muP9XU9eqwGkYUjAzhyrJruBKrRwVIeVkOgTmHxr9WG1WWPu0vxWblYSNAkAich4VPKXaZWIQiVwDhmAX9ai9D8vDZ9bkZTXP3aV/evhC/aKW7Vy9R2JC56vMKD9IGJPSpxNdFJFApa4OzuHhA4Rzwxd9pj5Kw+ZaeFEOJIRdfYx6rCOpiiElJivvEa0coaamcXjDEQEhVGbJuT7DqzFJ0ekbTJtDdxvV0YHUekdY5MWSbCcVBByM5ih17apuQ6BCKFSQgpB+H7RM3WY39dDx6rXuiw1i0zk66QNgf7xyq4fpPVrT9CdTqc4ybe957+4v8kuxSfpYuFBE0SN0tI+JRydAEPleB2a5LaIHPMAv50ODjCoVobTiG3psawbEm5rD0cKysPvs14e/fy4hxXKq56hyu6/MikOjjgIj5Q0fVxF8qjjf6M2RnMt96ElAsC1MDnlv0CG+lLCDdFZDn42Dhem4zpIW2LipclUiBMU9eDS8F6NAXSYFKsc4cLNMnrOnbDQJZHHvvrevBYrfW0QnSMoakpGvisbwii7R3KhQBjdlj+/iDNGx8HB7sUX7jweEvnT6qAE2kXOTtN1GoTvP3umatme9ZJBE5CwqeUowu4RK/uu/08ncB5qJLsx0ncF2dn57DgOH9eL0qViv77/aIyMXF1zEmDPWNij05cVn7QE7PPwSiN5yH2Kro+bh+X4xr9GfPnEBcXEKUiImVDPk87PYEwDHxs/MjAibqkc5KuXaDq5Wj6GUinEfkcwhvQksW9jJpWTp6yoddD5HNQLDz21zU+Vq22BAW24WMIfbCUUgyW1mmLLKJcYrTgP/XFPwgOdyk+rvrsUTh4sRAhWe+ViNRQ9Qo3RXj9BuG1G4nIeYokAich4VPK0QVcCDif3QZgvTuC1wv3F/Cnul8HRjjEU6ZBG4ENQw/TPNhW/37EV+r3W1fiIZ2xPyP2xESVKkophBiqG6UUUaWGnNEVXXEl1WDwYPs03I7+flDgiNEyzJ5HpFL6y/eRKkAphReaBIFAGhJ7apR2qPN0KUOngoyZKZRloVAQhlSjEVQYUmwtIWwHY2YKMRg89tc1PlYbuzYKxVx6GB1SnS5LnXFkLsvcSJtdL0e0P0X9yUcKo0iXg4MWz0+iS3F8seBZGW63Jun4KQaRSdRsEX50neDmbcLFOwz+yf/O4Hf/96cSsUpIBE5CwqeWows4gC1DZtIVFIql7SxqavaBSrIfN7HAaTQOC5P5eS104ujOSaXdR4kbuDUaJ98m7mFTq+nvsSdG5rJEq+vkwhoqCum1Al3hlctivvF5hJQfu1T8uFlUQkqilz+PLBTATSNSDjIYgNdHeX0Mx8K4MI/yBjRagqjbwenX9WuYy9EeOQ8pl4K3g9ePwPexijmMyxcglzskzB4XQkpaz7+JcFO41TVEr4MKQ1S3S3uljhIGcmyUpp+l5mVpBwdUxhOMFB7sUjw2pptKPgmEm6JjFliuFwEYdxvYnSrRjZuoWh1hGIhsBpHPP9W03KedROAkJHxKObqAq24XFYa4gzqjtesIN8WdqS+COJ2PiThVtbw8/JtlaTEwNnY47XA/4ujMwYjQccRDOmOM2RmsX/oyxsJ5sr1tVK1OswnGwrz++55p9FEFzlGvb1CewnjtVcTsLKKQx0xZRJkCcnoW+/kLmC9chd0KwY1bREsrBO99QPjejwlv3GKr+DzmZ15kdiZCZHMYkxPIyxfBNO8SZo+TXTGJ8dqrzF50UK020cYmqtVmc+Jl5OgI57K7tHx9oPLWgQN1INX3uInFTaEwNI8/CSqU2cpfRbXazKR3yJsdXUnlDSCXRQUBKl9AlEcST85TJKmiSkj4BPCkemsYszPwS18elrZWawjLYuTiDOrSZ2naZa5ff/y9Qh6EfF53IY5nL8U+l4WFYen39PS+d/aeHJwwrtTJ1TPptDYjDwZDn4YxO4OcnsLcqbB5HXopG/vzuUPHP/bvPKzAOS5FBfrxZbmMeL2E0WlhroOSJkbWxal2ELduIDJphJUDb4Dq+VDpIopFahefxxifJvvaz9D8zhLFxiJqcwcsC2NhHvONzz/2ap547MLIxTLOW8Pqt+1uBlMVSH///2ZptYUoK+bS1QPPX6f6jIX5xx4pjLsUp1K6XcCTYnkZul2JvHKZ+cE15EYD5aaIGk2EZeG1fVbdzzAx4VDaO/EOpuXE+NiT27lPOYnASUg44zzp3hrxAn5UQE1LyeCOFhi3b+vKk8fN/YRbPMLh1q2hyLJtLVDKZS18lpfv3eMmZnxclwhXKsMU2FFGR7XAqVQOL4pCSoyJMWRN+4yPBrViwfSwHpzjUlQHt2NZEs8tIAv6Nv4gIlVZJtWroi5fxmhP4votTOMlMA1UtYZfbWGMRzRSU5hfmGCieBE5eHJN5w7OlZqYACEkYnyMKILGdb3f+deu0tx9H1nZJWU2UcIBz9PpsicQUVpdHXYpflINBeP0VyyYn3urjDr/JYK33yG8fhM6HRq5WXaLC8iREcycB+yl4Rzdt+hpG/g/bSQCJyHhDPO0emsIKY+9kpyfh2vX9IK7sfF4r4QfRLjtj3BQh7sRx1GctTU9c+poB+LjKBbvL3DiVFOzefxzPZrCehCUUnT6PkEYYUiBAIJIYRqSMLQAcZfAOVgh1mrp71EEg2affGub3IhDO3AZ9CJGZAuRMiHt4mMRbbXIhF08LwtCYk092QhB3FdmdPSwUIs7Fk9Pw/r6FMZrNgubf4hab+9HCp9ERGl7W/e7EeLxN/KLCUO4cUP/bFlw8eLeP/YuFsJrN1j8nXfppUaQ+RznMhVSB8rmn2RaLmFIInASEs4oxzXiA+7qDvukG/FduaJFTqOhw/2l0qNv82GEmx7hoP02R6M4pZJebNbW7j1QEw6nqe4liO4lYuIU1sGU2b3u1+j0Wdtp0ej28QYBvUGAABzbJGWb9BtZUpZDvS0xDUkmZSGEOGSs7vX0vhoGDLwIO+yRCpus32qz7aWQgzYFdR2Rz7FeegWiiKlChwHZ+4q+e/EgaVGloF7XPx8UjXFaUYihaXviuTKpA+mrJxFRqtcPdyl+EoM8B4OheCsU7hbCCslNcZlgqgbbO1zMbmIceIpPMi2XcJhE4CQknFGONuJTCpqBS97s3VVe+yTz+ELorq83buirdduGTObjb+9hhZtl6atk39dX5nG10/w8LC5qL45h3NtbEzM9rcXQ9vbJ06NzOR3B6feHk8Jj8nktcFqt+wu9RqfP9dUK3iDEMAR9PySMIi2CBgGGFGxWuwRBF88c4NgmhXSK6dEs/YFJECoMKeh2TbJZ/cRCTKxoANev0ZNXESkDI+0iAhtVq7PRV5COyBZNqurjG2sfNC0a9xY6eixj8/fMjE4XxSlFOD5S+DjodIYm8sfdpTim3R42C5yYuPsc8Dx9ToIk/dJFpr//AdFaG1Uu6fDjE0zLJdxNcnQTEs4oRxvxKQTbvSI3W1MEkXyqjfgMY+jBWVl5eK/JQY4Kt0jBVr+wJ1CO74sS+yjixQX0eiGEFh1RdP8KKRh2NY6jDscRi4LYV3Lc/Y8rN4/TZ9rIrFjbaeENQnJpi27fxw9CTCmxLYNBEFJt9YhCBSjCSGGbkq1am+9+tMbNtSrLWw2WturUmn0839dRHdvSFTntDr6bBSlJi65WgLks/YEBUUhTFIGPF22Lo2vh4hIil0POHN91OIr0gg+Hp4LHEZR0eiiAHsQj9Sh43rC79ePuUhxTqQzPv3Pn7j629XosbrTf68LrY/sVeAeryo5W4CU8OZIITkLCGeVQI760ixSKgt2hMciw2J5gWqziPsU8vm3rNNDKig7RX748XEgOpjNw4gFQg2PTELFwE3vCrR/aNAdpeqHNfGbnWAOmYejITbutF9C4r01sQt7Y0GmcB/EIxZPDj0szwVCoHDfaIX4ax3VRdl0d9en3IcSn0e2TTpl0+z7NrodSCj8IEQhCFRFFCiHA6XaRa1tEpRwDO03fj/DDiKxjI42IQRSw2/AZLYAZBgjLQGaz9PsS35GEQBT6qJ6HcC0sI8KvtRGFwkOnqB4mura8rDc+c2CdVkpHx0ALnHhm2OPuHHyQIBgKi3Pnnsxjra4OxdzFi1pPHmRlZXi+zM8PI38nGfiTyM3TIRE4CQlnlP3p0otLSFcvNuOpJq4xYKNXZHXHZez8FSafYh4/k9Gh+a0tnbK6ehWitWE6I2o0UXvhDVEoIAv5u1IbR4Vb2hyAAD806QY27qB+rAFzZkZ7gba3hwInNiGn0zqisLMz7HlzEjMzQ1F0km/nXj6ck/7nutpv0u+DsLSACaKISrOLH4RIAVJKFIowVGSqu8ibqzjtNjP+RyjLxBoZpfn8C3SiPP4A0hmJYwt8X9FsD0jLCMtQ+JdfoL9VJvAEXd9ARAN2ixchPUI5XEMNBpgfI4pxNLrmRxIvssia3qHoWrBVod8fQ4hhVAv0cQX9Guzs6J/v5416FI52KX6QAawPw9FKqcuXD3u3oki/D+L/X7p0d/RISAmjZYgvAHYrkIicp0IicBISzihxIz61W9EN2vby+Fm/ylx9iRX3MrVzr+AtyydWCnscpZKOYNTr8NG3Kyy8r83CODaq2UT1vb0xSC0oFO4yDh8n3BYyWyy2J1jtjnChvoh54W4DZuzjqFR0Oir2fczN6QVma0svPvcTOHGl1L2GbxaLWqx0Onf7jUxT+4GOen4ONvvLpyRCwHatQ8cLtLFZsV8Xnq3uMv/eO+wMZvEcl1a6hBn4pDc3sJsN1i8UiUp6g6YBYSDpeSHFNGTtAW2jQDQyjuUpDHsaMyfY9F5CdA3ysodn2ydWit2Lo9G15e4YUSS5lNvQz3UvurZ4GygfFi+DgRZ3MExTTU8/GS8MPPkuxVE03L5haHFzkKHfRkdsTnoPPuk2Dwknk0jIhIQzzMFOugfz+O6FWZ77lRcwRsv0+zqy8TSbok5Ogm1FhNducKdWRMxMoSpVGPjIUhFKRZQ/IKpWETNThzq3HtdB2VA+hWgXtVtlI3XhRANmLF7q9eHzTaf1ImpZ+m9x1c69iMXISQM77+XDKRT096MCKU5b9HqQdkz6XkC7598d7VGKicXrWL0evUyO0LRASgLboVUqQ9cjs7pCqzvAG0QIqXvL+IEgNeKQnSnQrIYowHYkMpNBZDK0/BSq18cbnUXkc/v7+TAcjK4FkSSKJIgDIsXzCEyX0LT3I2cqioi2d7j19g6q0WB8LCIMh/6ox0X8OOHSCtH2Dteu6RMgn3/8XYoHg6G4yWYjLhaGj6ui6C6/zb3EzYP4mRKeDEkEJyHhjHOvPP5VdFqg19MfyBcuPFm/w0HmcxV+XK3iZ0vsNDpYLYGbzmHtrYZdt0y6WUf0eogjFV/HdVAetSwak68yuHwJf7TMSRmWqSmdXlpZ0ZOhAWZnhykqKe9vrp2aGnZDPs4AG3tzjutMnM9r4dNsDiu6DtLsDPiTG9vsNLrHPrbbapCtVehncyAE6qAwFYJ2ZgS300S1W+ySRUYmYaSIQkE6I8m99VlWNz4gbHRwMhYp0SPqdImabaRjoS5dRAj5sUrED0bXVks6PDPrarN3XN68XH4TM59jfn4YnWisNPB7JSwb1j8YQ165zJU3H5/qOBoFWRILhKUx3BcvMv3c463K6nSGhuVytEn+7e/iHYi+bBRfpH/hRWS5zPnzJw/vPCttHj7NnPpR/Y/+o/8IIcShr+eee+6e9/nH//gf89xzz5FKpfjMZz7D7/3e7z2lvU1IOB2ElMjxMYzzc8jxsUMfiOfPDyMbt2/rhfdpoHp9LqibYFvU+ykW5SWWzMuESLpkWDfPU6OECoJjK76M2Rnsr30V5y/8eZw/9ys4f+HPc/kvvo4sl+85YyqOTPR62mAKOo0khBY3Sg2b451ELAJPiuDAMGpxNAIT3/e4x+h6A+5sNljebnJSP0DTHyDDgMC0dB8ZNU47Ku7/f2CmEVGIDAd0O9DpevQGPkEAhhFhzs0w+Mzn8fNlUn6DXPUOrUaELBYovXIeWS4fa55+EOLomshm8babKM8jJXqobpdodR0/U0JevqRvt6OjE8HtJbbMOUS5RCpjEG3tkPnB/43YfDzRiaNRkM2RFwmcLNH2DjM/eLyTuavVobiZNjbI/eHv7T8u01PcMp6jvdYgevdPuJBeu+dk8qN+pk7gUPW0In4aU9QTzoDAAXjxxRfZ2NjY//rDP/zDE2/7x3/8x/zar/0af+2v/TW+//3v87WvfY2vfe1rvP/++09xjxMSzhblsq4gAR2VeJCS6UdFuCmkY3HBXEKYBkiBF5kscpEUXYhCKuYEfZE+sXPrUeHmpOS+gFlfP/mx4+caN1wDbR4eGdEenbUHWPNic+xJXpw47XGSWDoqfJRSVJrdvZLwk/OFgWUTGSZm4KP2PoIDhmU5USBQ0iAyJYFvEAGGoR9svdqm3u7Td0aI5ubJ/8QrjPy5n2frja9hXL3MyIJ2X38c/02MMTvDzhu/jJwYYyJYOVTevP7ZX0KWyyzMD6MT26Mvgu1QcHp0jCJidISx/vJjGSZ5NApSMcbphi7Ccbh83nusQyvj/kgAC/MRzntv7z/uwMlxuzMDtkNqPM8F/0PUO/d+3NjPpByHO50x1rsjVLwDjuyn2Obh08qZEDimaTI5Obn/NXqPd+d/+9/+t/zCL/wC/+6/++/y/PPP85/8J/8Jr776Kn/37/7dp7jHCQlnj3RaV3GA9qjE1R1PijidIaoVzpVqZNyInm8RKINFdZFznQ8RaZcVNYu/20DOzDxQ59a41LvZPLnfTuy7iaJhFCaX0xGcMNTPu3t8hmif2KR8khiK01xxNdBBjjPOdvo+7V4f0WqSrWzjNuvHvgC9XIF2qUyq3dr/t4jjPUph9AJ6mTx+OkUUmCiljcYpWxKEEbdX2vT7CtOUWCMFrIU5KoMCCLkf0fo4/puDdN1xzC+8weiv/eJ+dC34+V9GjJQxDDAbOjoRjYzSCVy2+gU2e/qAzaWrjy06cTAK0gzSbPWKREpwMbeBlI8vCnLjxlDIXrkCVnP4uHU/w4/q54mAcqrF+ezuAz2ucFN4Zoab1VH80AQBF3IHrjyScQ1PnDMhcG7cuMH09DQXLlzgL/2lv8Ty8vKJt/32t7/Nl770pUN/+/KXv8y3v/3tJ72bCQlnHtPUpdvxQn/tmv7+JDhoFrY2VpkudinIJrv9DGGny64zx1SxD5Uad6yrGK8/eOfW2BdzMEJz0m0OprOmp3X0olIZphpOIi7nPekiPP6/79/9vzj6czDFFaysMvrjd5n48D0uvPNtrrz9f3PxT75NtnrEqSwEWwtX8F0Xp9tBRgEyCjAHHtlahZ6Toz45jZAClECgmyFKIyKbEexUAwZ+uD+uAoav8b5g+hiVS7GJd+uHG6hGg3KZQ9G11TX92i0sDKMTd8JzNH2XlDFgEJpIGeGag8cWnYgfp2vmWG6PsevlKDstZPz8HvFxomj4HpFy+N4ZPr9ZflSbpxs4TKQajNjtB37cTb/MWv5FVKtNwW5zObeBIfQLFPuZHlT0J3w8Tt1k/Oabb/KNb3yDq1evsrGxwd/5O3+HP/2n/zTvv/8+uYMNFvbY3NxkYmLi0N8mJibYvEdM3vM8vAOfRM2nZVJISDgF4iGDGxu64+6NG9zTDPkoHDQLZ9fWGUsL6MCmuYB0KqSVT2EuT2f+JRb7ZS7ff5OAbraXyej00fa2rlQ5im0Pm/bFIxzy+b2ZTYO7B3Qex8iI9l00GsdHPQxDL35HZ1cVCjrC1Gxq/1O4uobx+/8X+WrIhjVJLT1FJmyS39nCbTe585nXaI8MI9PtkVHufOY1/GshRi8g069hyx6NsUk2y1fpZfJ7pfYKFUpCITBthZtW7O4YGJEi7ejy5PijLX6eH8dkftDEu9WZBdMgv+YT7pUyt1r6eDqOPuaRm6Jn5oj6Pi2VQgBTqRoLmb3Jm48pOiHcFAMrzWJthCpZxlIN8vaB0NwjPI7v6xlnoM+d2dnh/5ST4kfRZ2g0RhAWvFRcpviAjxsEertKSeSVy5zzrmPu1JNxDafAqQucX/zFX9z/+bOf/Sxvvvkm58+f53/9X/9X/tpf+2uP5TG+/vWv83f+zt95LNtKSPikMDWlRcL6uq60Gh8fNsh7nBys8prs9VHNNFZbsrEpcaZh9vkc/Q1JGB7uX3M/5ubgo4+GnYuPM84uLGgBt7oKcW3C5KReZKpVLfbiAZ3HMTamb7e5ebzAGR3V/XUajcOVWXFDuWYTRsvaJ2L0Otjj40QtC1+4BLZHu2STrVUYX7xBu1Q+FFppj4xSny+gGgozb2BmQ3q5Av1qHhVIhBEhZISKTFQUkXJDTDsgCi3wBW5R73PsVYr3/2H9NwcHn7YLs4hUiWzUOtS/aK01hWq2mB1vEm2nYKTERv55tjbAzAfkLY/RlI6sPM5hkmGxzJ3MZ9nZhNHRJhey29hSh6se5XG6XYgTBWNjh8vMPQ++e61MPz2F2ajy2uQ2KXMYBr3X41arQx9PJgNzz5UJz//soWrBJzVF/X48yPDUZ41TFzhHKRaLXLlyhZtxe8ojTE5OsrW1dehvW1tbTN7jU/O3fuu3+M3f/M3935vNJnNPsr1mQsIZIZ/XF42Li/qDt90eGnQfJ0IOhyjOAoPbMJmDnSqIdd0n5M4d7Q3KZA53v70X587phejWreOFimEMIz21mhYhxaIWLL2ejjr4/t2t9ff3+8CE8eOGdRaLWuDs7BwWOPHtguCgT6RMGcHNtkNPpclSByHoZ3Pkaru4rQa9fPHoHhA4Dt2REayUzoUpBVEokAYIqfA9AUgMO8APfQyyBIFBOq2PY1xfEafUHvTYwt0m3u3WJELAVLELRV3KvPvN7+Ib07i1dXy1SmBbVMpX8UcWMCo7+I0ebqlDyWyguo8vOhFFcP2GZGfkOUrNH3KueQ3HcVCPGAWp1fRrCjpqc7DUv1aDP/kTAEnxygQv3f42bLTuG3052NEY9Hkbi+CzMK7h09ps8MzJt3a7za1bt5g6YajMW2+9xbe+9a1Df/tn/+yf8dZbb524TcdxyOfzh74SEj4tOI5OWYG+cr127cmaj0H347EsHVWo17W4iT0za2sPPqwzndb7r5T21RxHnFo4eN0zMaEjVrUa9yw5h2H667jtx0LmOJ/OvjA6MBQ171oMZJl6NEyjh6aFDANM/+4nvf86iMMviIokUSgQQiGlQkWCjtfTaSIjhZQCx9GiJk5Rxevlw/hvDpp4+6FDEEmkiPaEnwDbZuPDGtHqOjOlLnJmCpXNU13usH29Tjg1x+SkYja4deIwyaMN+h6k4kkpHb3b3ITibJ6Lv3CZwsWxRx5aub4+PE8uXDgsbm7disWNFihv/FwJ5ys/f99hme32cJyDYWghfnRkxL3aPDxpPs3NBk89gvM3/sbf4Ktf/Srnz59nfX2dv/23/zaGYfBrv/ZrAPz6r/86MzMzfP3rXwfg3/q3/i1+6qd+iv/6v/6v+cpXvsI//If/kHfeeYf/8X/8H0/zaSQknGmk1CmcxUW9IF67dvzQwMfJlSv6cfxBRHuzze1dj9lZwVpvhNu3JVevPthiPD+vt7OzoyMqd836EUMvTZwCK5X0Qtbtag9NGJ48YTqO0lQqx6d3bFsLsqPbSKV0lCiyh91/RdrFdSzCaChYjMAnMkwC6zhzjNh/DgdRkSQYmHvCJ0JIA8OQiMjCMkxCW7+msVaI18t7+Y2O4+BohtVOmW2vwKSrW0ErpdjZVSg/pDgikRlt4lpW52gVMpjVDmarQu71i2Ski0AhpiYPLeAfN3Jw7Zr2kLmu9o+Njk+irn71kaIgN28O+yYdGhSrtLCJJ8y/8sowZXWv6ItSWjzHAnNy8vBU9bPA0QgdCH2ufUqaDZ66wFldXeXXfu3XqFQqjI2N8RM/8RN85zvfYWyvc9ny8jLywIH/4he/yP/yv/wv/Af/wX/A3/ybf5PLly/zu7/7u7z00kun9RQSEj4xLCzoLry7u/qK9WiI/nEiBFxw17j+7RWq2wEqanPHjihPO9TPvcL16+V7+mMObmd2Vvtsbt48PlU1Pq4FTr2uozdCaG9FPDNrefn4jsXx9uNozFEzMWjRs76ut39wzlU+rwVOJ1XGPTBbyzQkrmNihIIwjEi1WzTGJunl7jb5DKuejkRwlCDyTYQA04qwpEMp59BqBuAF2MEAo9Zh6yMTVJF0Wu7v68MQj2YYdAP8UG8j9tGo3SrVpgmmYDzVoOJN4UiPQWjQDlyUjBi58ydMNKsMpECoCFEuY772OcyXXiRa39j39sjyiJ5v1ffumk12lNu3dZTPNLW4iSNsB9OgD8PRgZhXrgwF5WAA3/mOTmOaJnzhC3eLxOMet98fRgZPGrJ5FogjdGqkzFJ3HD80WchuYcrormaDH+fYnnVOXeD8w3/4D+/5/3/xL/7FXX/71V/9VX71V3/1Ce1RQsKzzeiovjJeWdGiYWTk7iqlx2FIDFfXiP7pP2W26aGyz7EZzTIqKnRXtjB2v0v46puspMsPNG06mx1WNNXrx18pxyMclpf1wlgu66jP7q4WOseJl5jp6WGjt6N2vtjTcpzA2dqCZkuSOzAUFXkFQ0gyKkDVa3iuy/bC5ePDVWrvb3H58H5EJsIPbaQR6u7FpiLlQmelSbDWJOXt4l6/ziLzhOkJnBfHoFB+aLEa9zJauiHYSecZcxrMhbcJP1pmq2ZDx6JkNGiv5KiUZ6gZ5xhEFsrzKDbvMNG4oV+Mbo+o3kTdvE34/R8Sfu5lEOKhxxSsrQ3Nv3Nzunnjo3CwUiqTOTwctFqF739f/1wowKuvnnx+HCSuToTj3ztniaDT5053giA1jhB6rpg8KKb3hqc+q80GT13gJCQkPH0yGX3VefOm/qBvtXTKCh6PIfFgaDw1N81M2EF0HdZ74xgli5H6Teo3btIZKVGryfvOjgK9f9ev6zRUPn/3YlQo6MWn1xumk8pl/XuzqRfPk8RULGLq9bsFzkkjG+Ir9l4PjKvDcnn7ZofINzCCHvXxKdbPXzpUIn74QMWPoX+Iwr2NCkUUGPrvhsCyItzWJsG1DXrRFOkiFEaztDdLRPUmxg9XiKxXEeLhqomElIjXXiNc/oio2cZI1TC2PiTsejTNq2AOKNttbnXm6A5auOMWfWMMOi3cQZ2c2UXtBIQRGGkXkcui6g2CH/xINy28chkhBKES+JFJyvBPjBzs7uoUahhqYXPhwkM9lbvo9XT1IGhRfzC6devWMAIzPz889+/FsPxb//405749LGGohWJ/O49vpBADn+lSh4x5ZDbJM95sMBE4CQmfUuKmgNev6yvdjz6CC+k1om8+fFrhKEfn8CglKNptlIKNfgnSc0zWP6LSfI4tUcB1taflXkg5jNLcvDk0Th/kYNXVlSs64lKpaBGXzx9fKXXweASB/jpakp5Oaz/PcRVZ8YIX+zWKf9RmfSNkpZSim0sx8EOMUE//jo6IJEUcwdHfor00kZAhZuAjfR/TtnCLAfnrP6QeThNlc6RSTSwTvTOWhepsYd3+EPXWF0+MtJ0UlVuPZqheyDG2fZ3pa99DNZtsFp5HZAqMeWvU+6Mo16XvWTQbEjI+Y907nPOuAxHLYh5yLnNiBYlC5LJErTb0ekSVCmJ8lNstXTRyOb+hd2YvchB1urC9Q33H58ZGDo8MM7Py2DRkFIZ01rYIO12MTJrMzATyhLxQvT4cV3IwDasUvPvuMALzuc89WOuEg+Xf6fSTqUR8HETRnrDZC8iIfI7ZOUlq9T2koT04MY+znP+skgichIRPMXGfmLU1aDUjrn9rhZnmAHfu0aYfHzSvAmzstfFPmx7jToPN/jh4bc7l22xS4M6dw8bPk9BRmoiw1qL+YZt82T6UPjs6wsFxtOG43dZRqs3N4SiIo8zM6Cv+jY27Iz2jo3rhqFQOR3j2GwGGEVS0eCjksqy1snScMUZLIfVWn1ZXESmFIRThwSKiuyI4klS7SXZjm0p/EqUMbDMiX98m3VuHwgs4MqARZLnZ0rkRW4SIXJZS9SZq9+p+ROSgoFGNBuGNm0TrG4eicsbrr9HtzqAyedIvXSRdy6Fmx/HMK/SMAiiD6kqXqpfDkiGDvkfKqFHorGNagpYaYZDKEQmL21xihlVcI0IAyrFR9QaLlQLYkLMOjGb3PPB9gj/8IzpVj+vdczQoMDURcenqDEIcFtGNG7dp/sF3UBsbCN9HWRb1qSnyP/kFCpcPh3o2N4eG4YWFoadmMIBvf3soYN966/4RmKPl33NzOvp51jgqbCAWdpIw9xn831snWl1HfsqaDSYCJyEhgZkZqPZrrFaqrLpXGff7mDKkNsgy61YeypColKIrDCJpINtdrFyWCbfOVq9IL3SwDZ8RUWOXMaxmlskr2sty48awWd9JhKtrnPvxu9xcNFkOQi6lVzFmD6fPFha0UfXOHS3e4nLxtTV95X6SwIk7PR83fDMu+200DgucQgF2b1Ro/ui7OFtLqIFP2igijNeJJm3MKZfJkSw5d0Cr5+MNAnoDX49eEGAaBqESWKYgihROrUVxaQljMKDmTOHJDCZ9Ct1tVCNA5BW2DAgiyXJnHENEpK0BCJO019z3UhxMM0aNJmp7G0wLeWEeOTO1H5Xb2ICd81mKUwWmM12QBmu551CRjRFG3Agvk5/cxan1qfdzyIFHMVVl0m2iRibYrpZAyv1ZWpK9kjXbRtg2lYaJ7yukA5Nuff/8CFfXodOhL11upV6m5hYYFTuc33kP//+bRRyIFDZu3KbxO/8not2GUgm1F1VkaYnG71TgV76yL3Ju3RqO1ogFs4oiKrdqfP89E2GaFKZcXntN3reCr93WHjXQ0cPLJ9ioTpOThc3w94Pdxk+72eDTJhE4CQkJABTMLoJlVu2X2Ok7+EpiiYibrSku5DaRD2BIbHT6rO20aLR9yqkc6ZV1mJ4mnwkoOwYVL0eoJFanSnpkjobKIbb0B3K7rReok/wQcT8PWm3GCufYZZTlwOXc4geH0mcHRzh0OvqKu1DQ4qTd1sbj2Cx8NG2TSpXp9+WxIx7iSquDZNrrbL3zY2penanxHCLlkOt6yI0msu0TllOY87Nk0w5Z18HzAyrNLs3uACnAMgwMAbZpEPgh6fUNxEAR5QtkDRNCE9uwyZbKtFsVvFaf1KiDa3pUe1kKZpeM0UcMgn0vxcHOxGKkpMNOClQYolZWUakUMp9DutM0bku8pU0mLubIjdh0LQevp9glT9luoUzBbjSFKEeIjk/Z32Dhl17BWrS59kEEso0IA4RpkaGDozxUt4coFfGKE9QGAtFsczG/hQp15CDcrUK7Q5jOcS3zCuudLBlRIe8sU8lkyW7ukvqj75D/1V9BKUXzD76DaLdR01PaKAuQTqPcFGJ9g+YffJfswnlu3jLuqpQKV9e48a073Fl3IIo4725yIVBEUyf7yZTSkbxYNJzF8u8o0kUCvQNBsXtVRJ6FZoOnQSJwEhISAF0ynHIUF8wlFsMFLBFR9zMUzA63W5PMyWXsexgSG50+11creIOQdMoieOVl1B9qd2+tWKJUDhlEPo2qQrop8i/OUQsl3a6+QhZCX30fN3vqaD+PERFSaUkCK01/cp7U5p1D6bN4hMPKio4KTU5qgbO2ptf7eH7UUTN1eWqOlam3WLPLd5lcs1md5orFj4oizB98D9WTdEbPI9La9GFkXUQ+R9RoMnLzQzZGR0m7NoYhkVJgmyYpOyKKFH4QYUiJbRmkGnWsTo9epkw+l6bZtwlCi7QMkG6Kfn6cgQeZoE/aHWCLgEgJQGG3d5GXZmCkRPC//Z/7x0l1ugxaA6xcFmGarHZGGF/bwc1lqQ1y1N0y6c42E/YoYrTMSuGzBOtV8iMdtvpFSnabnNWl6mUxgw652RL5Vy5RS+dh9Uf4rT5Wvwdpg6lwSYsbx0ZNTbNaLWNcyHJ+rA1bbaLaXuRgfJwgiLjmvsxKK40rWkyltknbEEWStpvFv7kEy+tIKVEbG1AqIYSkG+q5V67RRwiJKpUI1rf40XfquKPl/b45AMHKGm//f+7Q7FpI1+YzoyuUoibhYvVEP5nnaaMznM3y7+OEzczMg3Wv/rhl9p9kEoGTkJAADEuG1eISl2Yd7nQmKFodOqGDIz2WtjNMLYyQOsaQqJRibaeFNwjJZ2xdOTM5SecnfhL7vR8iNjZpt5uMFXP4M59hcOH5vdEGuseMaWqzZ7sVUVls4VTb5EaG/pqjpuWm71K02tQHWdZ7o1wcaRxKnx03wiGX02moTgd2P9gk+4d3m6mNpduEaw79116FC4ef5+ioFji7u3pRifdJ5J4DdKVQO3ApWF0EAiOTZqzTJAg8qr5B5AVIKZgoZbmSddiqtdlelARRxMAPKUQBtiEgl2egbAaRiUGIISIypketNIW/kyJstYnsCFt4hAGo3SqjxQHmG1+Eau3Qcap6LttygQVznYYYoe8W6LVauN0eu8E0feEyGW2QN7sEYRl16Qo7O8uUqluUswMq3giRHyJ7DSayLS7/zHMoJNtMYnzewjF+RLR4m3M73yNyDESxgBgd5VatjHBTTP/M8+Sujh+KHISdLh/9o/dY9co4okvKimhHRYr0MKRAZl3UZpPtjQqjxbT23KQcan6BZpjDIGTW0GZlz86xFYzi9j3K5WFkzutH/OH/0cTvWljFNG+Ub+7NsDrZT3bQu1Mq6X5KZ4VHETafZhKBk5CQAOgrPPNAP5f5co8dOYbyHLxmH1I5dmY/Q7gt7yql7vR9Gt0+6ZS5b07uDwI2rQzeS69jz9Ux/AETk6PMPT/P1kaaKFIMwoDCiGJ9QyJqdYqrP6S24bEUhMynN3BmJzDfeA3C6JBpeatXBCBj9en4KdbUDNP++4fSZ7OzuiPu1pZesKandbn4+lqE86M7XDjQoyWIJGZaIt1pMksVutdv0v5siWxuGMKPU1bttv6+b6Qu6LKq1W6ZQWhRsLogQEkDMwy5WHaZGZ8gCCNMQ5JJWQghmC7n2L4dEqqQz11NkWvnWPywSTeS9JWDQiCkwhQhruHRE6OYKQNRLFHtdBBBm4wVICfGKfzcqxizM4RLK4eOUyUqg+xiBANq1ghIRT6s0uzP0ySNQ5/RVAvhprh9G8J8mYnXBVvvu6TaOzjeJk0K5IsmUz/9Ata5Ka5d088/KpSxf/anKFZnSH9kEVWrICVr/gRyfJzMZy5Qfl4rjoORgw+/U2ctHEeEHUwrxFQeOaOO0s8YOfARtk0jEhRNG2VZ7HTy9Cy9mk85etZCO8xQ6aTB6DM9K/fFTbUKf/KHPYJ6h0Iu4nOj11BAy0+Rs/p3+cnCkbFD5d8HjcmnTRRpH1D3wCDzsy5sztJQz0TgJJxpHueb5Sy98c4qRw2JZb9GysizNfk8XLpE2yoj6zoKctArE4Q65WIY+ni2Oh5b9Q5BqOcaeZkcCEEoHXrrNabLAR9+qOj0BwgZYTRb3HqnxhxtJsagJsosDbJcuP0eareC+YU39schkHY5n91mqT1Ox0+BgF5P4BkZUgfSZwdHOGxt6SvyXA7soEt7p0tnZIa8gCCSLLYnmHRr5Kw+E2MhtyoVVj9ocGUhOHy+CDnsPrzXBTgdtugahf2/h3HzvjBEWBbSdcm6w3IdFUVEO7tE3T7WYIRs0WW67KBKGWR5hWDDp5uyCSNthM2YHipSRJ0+TnEU86Xz1LcH5JwBY1NglHIYs/LQPtH3CFIZcBxkOoVXVyhT4YQ9kAZb0QTtyGaie4vRq1kGuTKqqv1JhcII4y+EVH/Uo+8NsNSA0qBO8cYKFfNNlJik39dl/UJIJv/UFdRbl1C7FWo7PkE7g1nIsfDc3e+t9z4Y8ONVE2kYZFq7qAwYNFC06IYSxzRI1et4MzN4+Tzm+CibpZcZbNVgJGLOWcfs96gMCrRwod1iak4wcVmrm7i/jQoCzsllLoyH9COH1Y5ugpOzDpepV7d9dqv6T2ep/Ps4YTM9rVsdnGXO2lDPROAknFke55vlrL3xzjKxITHa3kFtbGIhyI1OcKddIi+GHplr13RliZRg7vlLwjCi7QVsVFoEkdpr+6+3KwQEYUi93afW6pHKWwyCLBJJbnORwGuxmLmAiFqU3T4tkWbR+TwXGu8S3riFmJ4iWlxCjJQwg5C8MmgYI1giZNBqszbxEsUj6bN4hEOtpn+emYHG7R4rfpZNZZNnC0Pouu3NfomctYGRslDdLoPvfR/v7WuHzpfsxbdoOeN0u+DupfQyt9bplPL7JTadIEXG6NPq+ahzM4d6jBw8DwMvJAi+gFlMES6U9HG/chlRWSboDBgYKRCSdNSku9kisM/hzIySyRrUGy5RxsUoHTaWxmnGcHGJzfI0AsHsZMhK/zL0+kz0PqJfHqMVppCtBiPFEPON17m5LOn19DHaud3Ev76K8gZEmRyjmRbn7SaD27usr6QRr1o4e8/p0qW9x5USvzimp8cX9HlxlOu3PH7wvscgCLFGSxT7S5RaO6QyfUJlIXoBdqeFl8/Reu55pGGwvGxjvvASg+b3mN/4Q+zAZz2axQ9b2FGNGWuVzAv/D4Q0+N73dIQO4NXPBqTXtthpztGQutHNWKq5vy9Rf8AtdQmzk0EUzk759ydV2ACHzO2P0kPrcZIInIQzyeN8s5zFN95ZJ1rfIPju9whv30H1+4hUivmFeRanfoJ8scDquo6OXL9ucuGCIJOyKKRTbNXa1Nq9fXEjhSBSak/kKAZ+iOeHKKUo5VLk53w2P/Cg3sHIpsiJOkutEXwxIGf2iJTBRuYSU7evI8+fQ21uEd68BaZFybaopV9mYFk4I2nCK5dY35B3tfefnNT+ipUVfYWeKZhYpqLXl3QzNmlzgJSKKBL4kYHc3aFQbdIQktbUBPmxcP98ye/Uabz0y+ymy5w7p1N6uZ3/H1u7VYJ8GmUK2m3INNdo2zN0X3iD9IHBk4fOw7KL2LShWsX/vbfhl76MLM9gXrFQN5oMOpIUfVJeg3ZuCt+cwDIN3FREKiX3y6HLBzTdwTRjZ7ODyAlSJRPKRcT2DrYIuG3O0+xYTE1FTP/c63gjM6i2FoGOE5Hduk570KOZmcI1fEqpPo5rcqP3PNFujcGPbpD96SLTM8ahgZW3b+ufz5+/25i7s6P4wY8CwjDSE9LHHDrZC5TXKljVLnY7IDJMdkfG2blwmYA05kYaWQwIsznmXy9i/96A5cEckTTBkMzb6zjZDPzoGv9893lUNr/f38aQJT7MfY5ocwcxqpjP7ux5cKDt26xt2ciJMrKQ48oDDn19kiilhc3BFgWfFGEDdxcBPEoPrcdJInASzhyPcwLuWX3jnWXC1TUG//i3CVfWUGG4/3d/bZ3S6E3e/+wv00qVqSwbFLIGXc/l6iWbmdEcy9sN/FA3ekNBcKCuWino+3p7AtiudjFNgS22CbwBnpUCGRBGPkutMudyVTKDGq3dFqntCvmbt/QlrmmCAOH7nKu8w/LIqwQXPoccKdNq6YZuBxu4FYta4MSTxedeLNB8F9Y3TNbcES7nN5l1d1nujLHSKTG3+B3KUtCcHGdbSApyY/98YXWd6PpNuiMlQGLMzuB85eeR/2yFqFpFBV3apkFxJsdO5iItN88ox5+HKjLAspCpHFGrzeC778ILU9gjeZjKwm6IKTo4lkOrGdHzatiVNZpbAnN8AbOgV7+4f0+MMTtD72d/AfkHy9i1dTYXu4DJ5NUC4pW/zKA6jdVPMfKyizknuXVNm6fHxqC50aWyCzgFHBkwlqoz7i1TWWoSdrt0wxRu/X0wu2S+chXyWk1ev64fO55zdpBmE957P6TnBUhDYrtdbEfhTKa5NfEFnGYD0x8QWDa9XAGFoL3hAm12Wg2ypS72j27QS7+CNZ0nawScz+xi5l+mNsjwo5UyMtqg+HqW11+X9Ptw+7ZEXr6M0apzrv4uhllCOQ4rjQK9+gDhppj8wnlGj0mjPU0+6cIm5mARAAgqXhZfGUw4jVMd6pkInIQzx9GKmX5osdIZBQFTbpXMQ7xZ7h4ZAM0gTc7s6QjDMz5N92FRUYT/z/4vwpu3UaaJzKTBNAm9AX6jhbG0xJXMv2D1z/wKOxVBrRXQ7ASgcoyOSkxTYkqBHyrUvR4HaPV1L5iSZTJjrrMapgmAVFSjGRZYq6WZbdzC9tpsy2kcIyCVs4h6PSJp48xNYhTyjOwGNLZ3ERcWAMnt23c3DJyb0xGc27fh8mVJ9jMXMKqrdHdq9KWP44Yw8PArVVQQYF6+hJSSSMF6t8ik2xieL7u7OsXkKmQ6hZyewnxrCtVooQYDhG0z9mKOW9+V+yMBjjsPw0iLbbG33f7qDmq2hWkWCEOJikKMXh0p6/Sdc0iZwhR9dnYg3bzFyGvnTpw9tammkZctpm/d4fZqASJFrrPB0vsT1PIWk5cyzMxqYaOUFn/tNqTCAVbk0RQlRs02fifgzpZCBWkCx8a1Q+gKzm2+jf97d+CXvsy2MYNSempEuaxo9/x9Q7WILD74QNDrKxCK0ohPsxeSLfZ1JE8Ievni/n5HkaBT1Tk3y/FJ5frISot6NUdg27hhh8geoZsKqXRGWO2OIlyfc96HXJkfYWdnjOqep2by+TKF858heNujt7rDcq8IRoicHOfyT8/inJ+867g9LY4TNlNTul/TJxHV69PsO+y489AaisbJ1N4b4JSGeiYCJ+HMcbTNvyFCfcmvYKM7gooKGL1dzjc8MveZ5Ht0WwDbvQLbFLRgsndw/Wd3mu7DEm3vEHzwIUpKZCFPV6SxlI9PQJDJYrdbuLdvEb28gnRLhB0Hz4f3byhmOzbNroNM9eGe8ubA4ymopzJMlHJMb19nKfs8Qg3Ih0tUuuOshxNciCpEQrBaeImL5h061ghbvQLzzR1S01OMyR71SgXVbGGUCkTR0FQck8nsNX4LdYTn/KtjtHuSzfdclmshF+s3GZE+ldI0VZ5jYqzAWNBktTvCZq+EIRUTqQbKG1DY/IjGdwdUv18llxpoL9fsFwkKY/uTfjJ7vpjYE3L0PFzpjtLytSFaCsBx8HyfqD9ApAAiRK+NEXg4szmCdgor0qZlT2Ww+zuYd26SuawjSUcZbFUI3/0Bfb+FKE7gphXQo73eRO3cIj07i5RjrK1pj1KxqBvbNVsOnkzj0sGUAU5jgx01xqjbwBM5MmGTGdaQc/NEtTr1P3qfxmenQEjKE30+XGrR6PaJIkUUSeobBQyVwjQFmbxHuxfi5Ju0ehAeGcwVhYJOTR84O+3hpAf4nklQT1OIQmyjSzsoINp9/rg/A8ImZUd8bnSJ3M4y167/KcTeQM39QZgjM2zLKeorLczBgNKoweTV4qlFa5XSvZjiSjz4ZAubXk8/H7+SxxeTCE+f42NOk4J1QL2d0lDPJCafcOY4WAkCYMmIy7kNLuQ2ydld8AMC6bBczfHRR/rKPAgebFtCwJRb2xdM6808N6NLrDezHMjGfGpRG5uodgeR1Ypggyl+rF6kEpW0idh1odtFbG3jOIryZB8pYSA6XLvpUa0HVLYyd3X8vRehguXZi0RWxGTjGlYUYgddznd+RFtkuW09hyl9fMNlkUtYIgDH4U53AtXpguMwz23UYEAU6SxWrTZs2R+zsKC/Ly5qj0h2tozx3BXCN34C+Wf/FSb/Xz+P8dorNNxp6HsUrA6ODGgFLk0/jWo2ia7foNhZATdNbeQiIpcjXFwi/c6/JKpU9s+h+PnH5+XR89CLLPYSeXrMgefhmy6B4TAYQNj3kb6HnZIgJH4okSIibXpYMsRL5YkqFcpU7zqetWpEdP0GBW+LzeIL4DhMp+tsiBlq2TkK/g5Ty9+hVo1QSh+v3d29zr2ui8rkKfS3SPlN2l2DslmjJsq0VA76fdJ5E5FJE42UWVsJUc0WY1N9bqxVqLZ6OJZB2rGprKepVCNq7S7pnEcQhtiFOmGk7hI3oS/3xU0q28dJD/A6Dv2WS2hYOKLHIEgTKIOdcAo/NFCRzyXzT5C9FrfUJbDs/QGytq2P/bVr0GhKRKHAxTfGmHp+5FTETRyxuXZtKG6mpnSk8ZMmbgYD3en5o4/09yDQQz1L0ykWeu9zKbtO0e7s+5rioZ5yZuapD/VMBE7CmSOuBIkqVdSBldIQigmnzsX+e1yYV7gTuhlEp6OnS3/0kb5yj6J7bytr9bmc22Ahu0G6s40sl+mYBW7c0B9ArdZTfbpnCsVht6XNgIYocM16mUXzefwQUApTQn8Q0h0MsPN1EAor3aXXdohCaFdyRNGDOzfbI6MsfuY1/NE0o/4GbqeJHXhMGmvUs5Pccl+iEhXZZZQdJsmLFkSKxc44eB6mbTA5tWfm3RMZsel1/7nYe7OJlD5nzp+H8XFJZZBnJZpFjo+RniggyyN0djuAIjYThZFisLpJ1O5gTIwh8ll8ZSPSLnJ2mkx3i+j6TcK9SZpxFcx+Bdkx56FSQ4ETVWoEozP4TpbBAFQYIVREyg7xQ7knslyUUjjGAFsNUJ0u1s4a6uAJD2zdbBFVqpRHBSDY9fI0By7NgQsIskUDsb7K5o0W29vaM5PLaUHY7Urcc2MEqRxUqxihhy8c+pGNGgyYM9aQM9oXt+ifgzBkKt9iqzZs8mhKg/WlFL22TcqRpDIea5UmTqFBEEZ3xfaCgUG3oUuY3HwPK+XTracZ9LSRKsikqGWnCDxJIxzFivpk/Cqv29+j4bnc3nSQ5RHGL+a4dElfxNRq+jNBKf38nnvudHrbPCvCJgx1Q86PPtLvq7jhYDarK+mee14y/ZNXMfMZotV1VLerR4N0u3rI5ykN9UxSVAlnjqMN546bgOt84RXm93p/xGHSINAfbLWa/pAbG4NS6eRtiUqNmWIW6+dm6RUla2vDEDLotMb09Nlq1f6kkVMTOnrT7qBKFrNilUAZLKpZtsQUngiYS1+nli3iByGRUggBuZE2vXaKFOD3LQwzpFPNki50MKwIlMJtHTaTHi1daY+M0hkpk++1Edsh+dsbmNkcI3So+6N0o5CibFMVJWajGkKmCIRFZSdi9OIMpQsldm5oL0g8MXp3VxtfYy5cODzCITbE9nr6Q3x2TnL9ymU23m1xYfVDJgvQswwaddipGExkMxizMwig6btEEUgpcEbzRLsVVLMNo3na7cOzq46e07hlImGifB/aNWQ5S3DlefxAl2tHSiIlZFSbTujSDlwsGdDsmJjdbTLtTZRfY/D7/xfG4p39dgdRBJE3gDBkS0ziK0nO7HGnO05zkCZvdTmXq1PZyBD0fCx72L03ivTxKI7kSY9dZu2dDOX6d9nyRsEMueiukp6ZReZz3G5PgO+Tt/sYGUmjrZs8gmD1jk2zbiIk5AoBXgDSrRJEd/uy/L5Fv63TFulCB2lGtCu5QxHASBlsFK5Q6KyRa1Y41/+QycFt1tMvoWSToFBg6gtTlEd1j6Lr14fH/V7zmZ4kSmlBcPBi6SzOtLoXSumxJpXK4Rlstq3bLRwVjGdxqGcicBLOJA/zZnHdYT+OZhM2NvQbcntbfwkxw+Sf+UVS77994ray6NB2FOmKm2ZTX+XfuLGX1pr65FU2fBzk+BjmC88TvPMn0GxB2mVeLpL2N1gMzlM3x9kpXsRjgowxIPSj/XRfKtvHtHROJvQNAs+k28gwEmxwbu1HZGsVZKjLgdulMlsLV2iPDNWHFACCZjrHyIsOZqeL2K3i5xw8RzDwLNq+DUYWc1BmwVljo1Wimp6m9MqLCCm5fFkvcKY5TL2USkORahi6oVu3qxf2+Xn9Ou/s6KnMCwtgjJbh868iNntk1tdwug6VQZmWO8HUpVFkPofT8Wn3Uqz3R5hNV/WnfRhiRjoF1W7r/kAH054Hz2m12CMahCgkxlgZ6xeeJ+yMMdjUYssXFoZtk+5V6NqTKAVG2KfZVWQGIRNRi3zRQIyOHmp3sGPOIGybyVSNrW6WXZVnKlWnH+qP+qzlYfldqoyy03Jxy1rIt9v6a3JSH7suZaZ/tsjqt0DUm+SLBucmswghqHg5gkig2m2mLjv0ikWi5i6GIVlftmnUdGfnbC7ANEFmGzS66i5blte1GXT1KpkptRFCR/4AhFAopc3YvUYaR3UQwAudP8aJuiylXkRGYMmQOW5iGJ+j09HCVd9/2KPpafIsCJtGQ38GHhQ1QmhRcz+xeNaGeiYCJ+HM8nHeLPm8/jp69bGhpuD5r2LNN5nKtXEKzrHbklJHbaan9SK4sjL80Fpf14vj9LReBJ5FhJRYP/czqFqdcHVtP9cyGjVxg11+PPImt0efx99JM+j1cUcaSGP4YWg6ARmzTaeWJQoFajcgt7VO0BcMMi6BaWEGPvmdLdx2kzufeW1f5EQKxF6kJ++blC657LY8ss11ImeMnjVKp5uh1x9QFaPYqQznL9hszr7K8qDMVaVfv5mZPeOjr3XHzZtavMbMzemUweamjuKk0/rv7bYWRTMzsKrK7J77ZWacCqmbCmtVopaaKEt7XqbcKovtCZa7Y1rgeB7CzCKdvbRKoNM+9frhsvX4nLbeaWHUAkwvhTnn6k7E1/T9tC9G4hSypDyDWs0DEWJ4XVQQ4hlppOEwOh0hM2lU2t1vd1B/fgqRzyEnJwhvt3EKJTqhQ9NPkzY95txtNlcNgvIEmTGXTkc/Z9/XKRPfH/pX+p6BPHce5d/iJf+PoZena+aoNC1Uq8rl0g7mG1/GtEykFGyumdR2LcII8oUAy1aUxnts1Q6n0AD67RR+XwuhzEgbFQk6NZ2mkjIiiiRhKOg30kgjJFff5kX/D9k4d5Wen0aoiLxskC8GGBXFxh+vIt6cByGZmNCi9mnySRc23a5+zxwU5ELoxo8PeyzP0lDPZ/RjOuFZ4eO+WYTQqYnRUf2m3d6GRkPip4ssh0WoQnYwvGI9jnR6GNXZ3taLVberF0whdJXOJ+UD7GEwZmew/5//Cv53v0d0exHV9zBTDunZOZyRaZyBT1iL6LZSeAODwlgTYQ5d3tJQZMstOpUs4/Wb1INRBlmHmoRxsUxgO7RLNtlahfHFG7RLZRCCbHWXicXr5GoVMqbATDmkXJfbzFEM6qSlInAmGGRnMcsulbEsqUsu4+OS3V0dubl6VQsLS6+ddLv6dYwHboJ+7Uol/bftbR3Fabf1z8WiFkAAnY5Ezo0xl4OuG9GozrK1U2M6rbD2dLEfGvsmysLkHN18bj89Vijoc6ZWO1zRJaQ2vQoBosmhZnmgxUUYgplLIV/8HIPvVxE1j1R3l8hywEnRLcxjFTb3no/YKzPfIppuYFuC7fQFGmKTQn2ZXqZM6BvkWcOo3KCZe5nKyGWsvtTRmr3+QNmsPnabm/p9sbwMVj7PS78whXN9Fn91k5VeEYweCxcl9lu6QWZGKcJulo1ViWFALhvipBTjUwP8KCIID1cAdBtpQl8/6Wy5RTgw6bXcvXMnIgolwcDA6zhIMyKtmrzS/RYrmRcYRCmassyEXCZl9uiGaXZyr5DdbWO3Wlx6tfBULz6OEzanIbA+DoOB3vf+kQLSkRGd3j/t5oePg0TgJDzzGIZOMU1N6Tf1xoZOA7TbWqyA/kAaGzs+pC2l/sCfnNT3W17WH2ybm/orldJX/fGi+ixwXPTMHS1zsdamdm2DbL5BeydHu2WxuzJCptQmXRz2lxcCxuxVip0dOlaOqprBCAa0ZZ4F8wOkiOhnc+Rqu7itBkYQMP/eO1i9Hl4uh1PMoXwfUa0xnx5QefmXyBcL2F6K5WoGD4ltwfoGSEMLiiAYlodfuKCjNOm0Xry3trTgiF/fiQktPKpV/bqn0/rnRkP7NgoF/XOjoX9OuZKdiXN0vA2i1Q+R5RKm8PEH4C1v4RSylN68SnfPQ5PLabG0tKRFznGTqQ+OsDhIGB7oZzhSpjtRQtBGsI2bSeGkoKVGqA06lJ29ldVx2GhIwu99n2K4zHq/TN8fI+UFtBotrKDCZO87bOTm6OczZN2QvtKLW7+vo55C6HTdxMSeuLH0Yjfx0iTqha+y+E4L0xswNS3JLpT2o5/VqqC5m0XQQxo+thtRnghQIqTrBSghAR0a6FSzRJFu3JkZaTHoOQy6e+GtSBAh6bdTRKFAGorMSJuxwTqbaoG2KOCpDEW5TUp2aUYjROEIpbRNrrPGuYkmhvl0nLtK6c+RuA0AfDKETRjqz6yjhRTZ7L0v9j6pPGNPJyHh3ti2rp6Bw2HZg+bk8XG9OB13BeO6OkoQe3xqNb1A3Lr18UO6Z5XjomdTIzlmRzts1to4M03CNZdOM0W7msX3LHKjTaShV27THzARLLKZXiBS22yE85iRz3X/81w0f4AwI2So+5OML93E7vdol8qEwsYJwbQdnJkZivUK44MPWRr9CgUkcxmdOmw0tJDY3taCptXSr0cuNxycuLysRa3raj/VwVTVxIQWPqur2nvTaunfy2X9YR97EQoFfX+zmCca+Txqp4/aWOVc70NuhhdZn/4cV372PM7MFFwbVvHFBuaDi+BBoghQEarZJlxqoBp5UDmCQA/ZtG29792uxHQdvFYekxApAhzDI2v29reldiv06zaSGrWxabqpEuV2g3ZDEQJjpYjM88+x6c1RrVvI9+8gLhqoVB7X1WImm9XHoNnUvxsGvPKK3v7KqoR8gVwGSnPD59Bswo9+BKa0mBwF6XSxc128IERGgpxrU2v1dOVaVZuHhdCRmziSoxTanyMUnUoWaYZICcWpCioyqDbG6BsGVuRRNHcoyS3qagIpJOPZFBfsNeyw8VR6rHwShY1S2otWrR721TiOTreflcnpT4JE4CR8akmnh0MBDxrrtrb0172MdXGKamJCC5zlZfYbzG1t6Q+N2dlnK6oDOh1ycaZEEIU0OwNGp7tkiz6762m8jkMwKJEbbWG7PoFlExkmxXAX2xoAsBvN0FcuN4NXuBj9ENcwMQd9srUKvUwOpKARTeCLLC8UdklZEhyBWl/lwlsVbjfHKBSGZavNJkgRsXatw/nRNtVemuWlHJevSNLpociIIzHN5tAsXirp16rT0Yt5LqdvV6noaJ+UQ3/K1JT+X602Qu0LX2HarnC+0+fOeyNsZF2enx2G/mK/TRz6P9jU7SBRrU54exPVX8TjBr66RN84z4BzCFI4jsFgIIkicNIWys3Q6zSxHZOS3cQxdOoniiJad3bBOEd2tkA3TNPoZSh3VgikgxSSqXCZNeOztI0C6SJ49T69lQreZJbJKUmxqBfuiQkt+CwLXntNn+dxalaIYfoO9N9++MO9PigCzs1ZzMzkEaZLEEYYUrC0VQc1NA8bZoRb6OxXSqlIgFBEStCtZjHtACkVpbldevUMYWDgBTbF9DqF5g5GLqAWTWBIyWTR5GpxC7W2jVyYf6I9VuKIbdyZGs6+sKnX9fl9UNTEHrWzMFj0aZAInIQE9OJXKNxtTl5d1f8/qTQSdIrqyhV9+50dfaXkecOozuioDvU/qZy2iqLHUrXwoNspZFJcnRvl5lqVjjfATfuMztaobefwOg71jRJuoYsqKdqlMvmdLYKSzZihS1ya0QhNNcKyf5lmfpTAdjDCABwb2zRwgy6en2KxPcnV0g5yr8274fdZWNCN+mJD7NadLrX1GmqwiWCXCbdKs7DA9dplnv9imXPndKoqn9cL8fq6FjLxaxGPcFhc1F6ceFGYmNCRvsVF/f+4M24QQLstkc+NIQFx++5qk/gciYXNcU0Po0oF/4MbRH2JOWKjZJZwtcmgXyG002BncJd36UazKJXHMCVydAQ16BM1q5hGT88J8zyitU02mEZOjJMyA3Y8m0zUptrPETk2Y2oT1WrTbEnauk0ygWMQtTsUnB5KZej3dfRxcXEY/cpm9Xm8qa0+hyaEDwZa3PT7+vmdO6dFYC4nAK3w2r0BlWafdiWHECGGFZDK9vbFThRKpBEReAb9TgrTDrBcn/xog24ti9+3CH2TVL6H7+YIbjSJ2gIzFXBxpMesOyBaqz3RHivHCZvxcf1+Pot0OjoqfagX2DPsF7wficBJSDjAUXPy1pa+6h8M9Ic/nJyvjlNU47r33H6H5Z0d/WVZekE9OAjyUQlX14al9AMfYVt6dMBeX5QntZ1CJsXV2TJdz8eUkobVRxhN2jWXdjVLr5EmHJisn3set90kW6vQz+aYNBYxlE+2v8uGfZFq5hxup88Vy8JVEQOg7LToKIOuZ3KrNcmCsYix1+bdcYapp3xUpbOzRr2foumMIFMulpEitb2G32yxnHqZc6+OMz8Pd+7o18Q0daOyixf184hHOMRRiGJxaDge28vODQZ6ocvn9WLX7w/77GQyelHp97XQ3Wv0TBQNIzg6UjEUjzg24bVFIs9H5MvIsMrgzip+dBnfyRBhY4QDnOoGjU5AlL6KyDukSimkKCB2OuRbHxH2akjbRkxOQJhGFnKs9lIstseZl3cwIo9IOEywxXvmazR7k4xkPYLIoC8zqKiHhU+5rIVdp6PFTSqlxYxSw3P+/PmhfykMtbjpdPRxmJ/Xx+po47p+P2J73UGIgFw+JBQe7aoWNyoUSCOi30oRhRLDjMiWW5hWSKeewWu7GHZAKtfDyfSodybpn08zVd3iaueHlNsGKnCeWI+VT5Kw8Twt3D1v+Dch9L6Ojj4bZuGPSyJwEhJOwDCGJePHmZPjapzR0bvNyY6je/PEEaHdXR1xiLvrjo5qr8ejfPiEq2v4v/dP9YTq8oiec9T3DvVFeZAP/o+7nYxrU86l99vzNyJFutDFdgc0dvIMejbL8jLeJYeFzR+QrVVIhS3SRpPVwnM45YidfhFvMOCH6Z/kc41/jhwbw7FMUqJN3VcEwSS3d/MsXCqS2ktBpNMwNRmx8u3rFMMefu4c7cChEUqkFEyNmKhKleYPF2leHCVfkOT0ukq1qj/4O51hmH5+Xi/ki4t6Ia9UtMCZntYL986Ofv0mJvT33V29+M3O6sjOe+/p+z7/vF7ku119nuzPv2o0GfzuP98Xj0QhYaVMVLpCqAQ7VcgObIJcjkCkiJSJpbrInEuraUPUJnID2NzA7NZIR21KZh2jWMJ8/VVqziTif3+bXFhnbXBR95MROXwjYDTawlMWgbT0SI3QIlQSPxDkTY9cQbK5qc/FzU0twl9/XR+XeEL42Ngw1aeUFjfNpl5QFxb0fctHskOeB6srBoaUpHM+hgW7eyM8osBAmiGtShbDDJGGojBZYdBz6fZ0bxwn08e0QxAKr+MiBUw+P0IqncML5nDLLtJ1H3uPlU+KsDnJLJzL6YuvT1Nz0nuRCJyEhAfgJHNytaq/TjIYH4wIDQY6quP7w4XSNHVU52GNfiqKdMSl1UbOTiNipZR2ke70fl8UOT11zwXg6HZCpT8ZzbS873aEEMyM5ej0BzQ6/X2xZtoBpekqrZ08/XaKTW+e+uwE45dWsIJhJ2PpmeRbDdq7ebYz5/n+4Gd4rf5HmCN5ItsiP9jB6jaou+dZmXqVi77cP065QYVS4zYqP0VABz8yafop2Bt/MJvvEGxusvJHS1x+Jcv0VJlrLe01iV+Hq1eHKaXYbxNFejFbW9OC9oUXtMCpVPRCb9t6EYzTT+N7w143NrTAif1ascCx+nX8m4sEYgljVItHtb2L6vaIZJNBmCboh7TT4/jCxscgxMBQPmEEXTOP7HeI1ir0CLAzDrmsj2WPEFWqBN95m90Xvoosj1Df2qZlp8jbXaQ0EI7FaGOJa/YrNN0xSk5AgIEXGriDBqKUJXKzlB0t0PJ5/RxsW0cEhhPC984VpcVcrabfAwsLOuIVH4OYuOFeyjY5NydZ2hA0qxamAUGgkEZEayeP6fhIQ1GaqdJr6NEMUWDsRW28/SaAlgEXLwmECHFsi8mLk5iZx2sojr13cVdn0K/3UeF2mhxMgR8kldJi/HFGhp8VEoGTkPCQPIg5eXb2biOfbevUiFL6Q2p3V4f4FxcBFVEUdUZTHWT6/j4atVshWlvXERchaPkpBpHFiN3a74sSra2hdiv37CN0dDvdwGGrV8SQEecz2/fdTiGTYnY8z26zi2lIwkjpaFakyI83sdMerd08/Y7Lun+B/HhDX5krRXGwQ1kqmsVxdrtjNOzLfL+d5bPtP8YNdsAwKF6ZIvfyS2yq8r5PJpXS07lL4S5BcRQRtKkOsiglaQYuMuhjdA1mq7fpD3w++iDN1Qs+5z/3OkveNJ6nF+7lZTg3p1NH82afWzt5lpdznD+v++psbenXMZXS6aZeT4uf2Jjs+3o7B0cyHLpyVhHu+i06g5D++Xmy9t70z1wG4SqCICTq9pBRSGRZ+Fh4uPhYmET4pAgxsfwGwlJEmSzC6mCbSs/AcqfxVzYJb9xGXLrITsVi0PEp5nr4kU0xHTCoWoShwLYkoZIMBoJ+P2QkJZh6YZR6X1KrDxtkTk8PK6lgmMoD+PGP9QLbbOroZHz7gzSbWhwBnDsnWFrLIUNFGPgoESEig27TwXZ9rJSPW+jQrad1SsoKcPM9DNvH7zpIAW4mYmoKTNOkkE4xM5aj8BjFzSdB2MT9mo6ahWdnh00qE44nETgJCY/AQXPywVLMuGX8caWYQgzD+oMBLP9gh/6Pb7FdqbIdhEhLMncOsm+9cmKKSfX62iuT0hvuRxZ1L0vVy+IYPtPONsKvac/HPTi6nbThAYqgN+BmO0fGtJnwqvfcjmtb5FybfMam0fIII0UQRYRhRDrnYaUqNLfz+H2b2lqZMWuVyzvvkq9XkUFAZNvczr5CbexFdp2LvG1MMp7fZPaczezLl5CGgbUXFbhzR3twUnvTuSfYxjdtLmU36QY2Xc+k4RnIgY3jnmN0NIuPze0bfRZ2v0nhC1+B3AQ7O1CWFZpvfxd7cwk18DHEOQalSXrMUy5Psr6uTeZXruiU5PKy/nlrSy84m5s6+hY39Gu1hgbmVApUs4XV2Ea4MzSCLLbZJFICJ51GpCPoGESBHqoZhhCYJr6yUIBpQWTZRO0QghDDtTBkSCtIkTW6e+eRYCe7QLS5SXqmTG/sPOl6g6jno0KfMbfCrfM/TcvPkY9qBE1FYKQpFg2yl+bZjYoUcsPBia++qgV3PIstHn8C2jAfC4GLF4dG5INUKloAgRaiS0sglMNYtohtNllfV3h9geVEZMsdDGXid7NEXYuiWcOO2vi9FL7IkE5ZXFwQnJvO4toWpiHJpKxhpPIROevCptPR595RA/vk5CdrSOdpkwichITHQDzcc2zssDnZ8+5tTja215j9gfa/NAvn2BWjKM9n6VYbsf4Boz9tMvmZibu8OmJvgafvQdplzGlhiZCdfgEvtLhdGwWV4bKZ4l7p+KPbMdp1FtY+pN1SbIhpWkDLKDG12mPi/PHbMA2JYUgcy8ApmTS7Hl3PJ4oUEkjZCmu6TqeeI9gEuTKgGU5QKkT0APoeV+vfYztss3bu86y3ygzs84wYDnIvJJLJDM3Fy8swM13GnpkmXFxidjbF7WiKF/IrfLBZpK0cGsYYlmOSMiW2ERE4E1RrTco3v0vjhV+mqGp03v4RS+0elwogigVmRYubWwZr/7TF/FcU2+YUOzt6sY6jNEoNUwFxmuriRXj3Xe2vevll/fqmUqCqA/AHkDZp+mm6YQoUXM5vIEdGiAYmaqAQpiDwIhAhoYBISFIpgRcYhJEiMhxkSiJliEDsT3yPmi2aGwGq0WDj2y4tY4HRUgDnzlMasVBjV4i286Q8CP0Jem2F7UhEycEuS1xDi5BCQYsbKXXFGWjhFp+na2taWDabOi3lunuRyAPG6e1uhgZFEJILF4Zes1oNyiWLyvURpkZCwijk0tUBrUaWZs0g9DtM+h+Srq3QHjgow8AczXLhz8yTuzT/2ARNzMH+VTFxCvm0SczCj59E4DxGHle5bsInm6Pm5Lgd+sHOySMjMFo+7H8piZASW/iRZD1dor/VovLuHRrWGEJKzp0bmj3FaBm5t8BLV3twinaXot2l41usVgRyfJw7zTKifXzK7Oh2hJ8junkLNRiQcV0uGStUmxZVZ5qtd+5Qocy5l8t39QXKpCwK6RTVVo98xma0kMYPIvqDgE5/QNfzcaQkPdFj9M4PqUTj1LPnaA9GOa8+JGUMGIyNMVX5CFmROFd+itpuls11k+/24Y039Id7Os1+RdTaumTyxTdI7U3nvlDucWMwzcXWEtetl+hZWXbMcwQdjwvZLQwpqKTPk1m9ycIbO1z/1gd0N1sYqs1aPWCKjxD5HPmxHM1mn8bbHzH68gSbm5KlJX38Yl/O+PjQ4DkYDMtvKxX9PZ/X6aseDoapR5s3fZcRpzM8aOk0ZF1UWyFtB9n3Cb0BgWtjGBLX9Om0JAoTbIsoDBHSIGP2KdodomaL3o0VlD+DNE2amWnMSBLUOxjdPmOXZ1msj9Bs6f3z/TRE4OyZUGs1HSUoFIbesRs39K4Vi8NzZXcXPvpIP9fpaf33q1cPV92t9cp0ZRZZHmH+J89x+7bOW8VNF997D0olgWWZvPiiydaWQ6cBubBGdu0dVK/HIDeOXbKYkpuk64vIf75I5D6YSf5B2do6e8ImCPS5dLRXUj6vTe2JWfjROHWB8/Wvf53f/u3f5qOPPsJ1Xb74xS/yX/wX/wVXD7YcPcI3vvEN/spf+SuH/uY4Dv2jQzWeIo+rXDfh2cK29aIMd5uTK4stgkWL8cIcRRFRG2Ro+BnGnTrnMxXUZJd6vU699RwqX2BpSW+nWISJCYn5xmvaQ7O6jiyXdB7M80hValwpZVF/5vOs+LpRXJwyO9qcTEi9nWhnl/DDazriUCgQRQLZalNO2ZQvRmzWq/Su32R1RLfon58fpt32zcbegGZnQDplYpoSV5gopci5DnPjBcxaFdVfZ8LcYKk6x5aa5oa6wmV1nXl3A1UqUgxWuXLFZ3XW5IMPtFD4l/8S/vSf1h/2qRT7vXA21RTjP/lLZD74LtHaOgu1d7gRlFjIrHDLfIFm6OJ1bQSK89kdLMtkqT3JlQ9+TPH6dwnMCXbT5wlFAydQjNRWGeu+Q3PsT1Fd73H+rSpbYpSdHV0tBcOFfmRkmKY6d+6wDyef12KnZ2bJl0dQ63361hFVqJQebDg6ivPyJezOFsG1iKhjIwkxBn26qXOYqQIpb0DQGxAZFo4McaRPuLbORjCOMCSd7Cgt8uRSfUQqS6q9Rfu9RfoTZWxb0u/rqEA2q8/HalUfx8FAH9OXXtKppTAcpkFAR2x++EO9+I6N6fPuypXDVXfL6RfwSymk7zO++x6L/0cLPufgpcuYphZH5bK+bzy6otGAsdEI5wcf4PX6ew36BBezGxhSoLL3Nrc/7IXkWRM2UaSP98F9An3xMjWVmIUfJ6cucP7lv/yX/PW//td5/fXXCYKAv/k3/yY///M/zwcffEDmHu0W8/k81+J4Kjz2UObD8LjKdROebY6ak9d3Byg/ZFuNsdOUtPwUthHgh9oIkJI9xsOPGJtoomYKrK1pv0S9rr+EmGH6Z34R+0dva2FdrSEs60BvkGmuoBeu1VV939gIrUWSXtCM2RnMt94gvHkLFRqITodF+0UouUxNQqFoMGN3CZo/YKN7lTBTZHFRL44XLujvhUyKK7Nl1nZaNLp9Ii9ASsFILr1vDA27DfrhgGyjQXmwxvdyP8uWMcuPeYNm/xovbryPmXdJiT5XrgxTJru78C/+Bbz1lj6GjqNTJLduwTaTjP/UVymG2ix96X/7PW75OWa9j1gyL9KURdZDFyvKMufuIgzJjR/3me+vU51YoCgarDJHxRrjrXwbo1lnpHWLqnue+m7I+Lg+XnFzwUZDixzLilCdHs3FLlEKRstldnblfhk6QL8vKV65jNhdRjXbWGaHgZFCdbtElSrCLkC5jFHMIKfzDPoR0S2FY4Vw4XnCqostJTI3QrDuQ7dPzqkTNdtEO7sMjFFESnDHfpEQkyhSWIZitBCwsiVpGQOKE6n9ZnxK6QiMlFpoFwrw5pv6vKjsRqhmi0sTTaLtFP1MmXfekXS7WrCVy1rcoHTUMWy2WSx+HqUEIZLxXIct+wV6O22M63doLpTodCWlkhaknjfs9j09DbLdxNtpIHJZ0uaAXuDgRTZpOTjWJB+LmvDOMuG1a0S1Bvj3vpDc3j5ccVQuD3sbPQnuJbyU0u/Zo2Zhw9ANRBOz8JPh1AXON7/5zUO/f+Mb32B8fJx3332Xn/zJnzzxfkIIJuNLjVPkcZXrJny6KBQgdwX6f7JKVUFdlslZfSIlqA6yBEpSVD5dtYC1mafsDiMFByu31oIpeP6r5K42GE+3MTJ3X9Eahi5xP2isjL9cV6dfZKGInJxAFIsQRpTUCA1jhG0E202YcHbJBDUujLYIp7TACUOd1sikI6adCtl+n6uuQ3dsjFBxtzHUsVGNBngeRqnI58X3uUWHOyywnHqOWr/My80fMOPYmOawjHtlRUdE/uiP9GyksTFdvXTpkk75be9IotExSuU+st/jfPVtGH2NnswTYNEOs6w2czidCsXREezGNtXMeeaDa7xvvYZHCps+PxSv8vn0tynUl6im5uhGKWZn9THb3dULdaMBa+9XGF/5Hmt3ilRDj9YPrzM7OcuW9ae4fTu/L3AMA2S5jHHZIlpbx+yv4g36BG4XOXEF4Z4HkUEIvfD3ehIkmCkDlbL3h27KQhp7dgK7tsVE6ybhtfd0/5NsSC0q0BtAWvSRlsCUIT0jQy+0saRPr5diMNDRm5ERHUWMx1bE3ZmvfadCdP0Gc633GPg9fMvl+9YX6Yycxy5mmZrS4kYIiHYqhKvrLKY/Q6QkO14exxhgejlagUsqG7C44+KW+qSLaa5cGS7smYxOWSkFYd9H+SGiYNEL9LkqxOFBSaqqTfJxdDy8cZNoeRWiEMpl5Lk5hG3fdSH5tIUNnBzB77/0BptqKjELnxKnLnCO0tjrsDRyn85K7Xab8+fPE0URr776Kv/Zf/af8eKLLz6NXTzE0TLbO+0x/MgEAaYISeccMiu7FHcqGBNP+F2W8IlCjJb//+z9WYxl2XWei35zztXuvokuIzKyz6y+WMUqslgkZVmybB5Lso98dHEE494r24D9JAkW+GQZtgHZD4QhGxJgG5b9cIz7cAX72j6WYZ1r6YqUKJIixaaKZDWsJvuIjD72jt2vfs77MGPHjszKLFaxqyIVf2IjImN3a6+19hr/HOMf/0CdXqZ18yZzpxM0kt24gRQGgyHZi9itXyDMqpj9md/OqVOHOojDeUzjsWSomgyTJiKF0+UH6G3EbCr6wYEN3FFkSYoY1lhyS/hKIaoVFkmZN9tsRm2i3GN7UMXoS5wzITXPvv94DLe/0aH/pascdLq0zD7tYIz3bUqzAjtb8Tbnccl5hi/zMh9g6DT4svgLXLnm8+Rhdumhh+xnWVuzWagXX7RZsAsXrAj28mW7/ft7mvjrV2mVSrhFwZnx64gKxLKERjHSJdbMCqU5hRx06dVWKQ++xYKzzVDUuMMqinV25SJz8WuszKXs1ap0Olajsrtryyt0O+RffREnu06z/AR7ep5dL2Zl/Q20XqInLsKztaNOKoAirOE8VKG0skCyXyDPCZxxC3NVQmQzKnk+G3sQBPb/05KR1qDCEqVKi+ZaBPU6u+4yBCF7zhmKzBBmOygnpFWK2B6WmVCiHihGh+7NSllyAxzN6Dp/Hl77Yofiay8yn67jz4cUfpOXds8y6KTI4S1WT5/i0qX2kZFlPo65NjlN0fTpJ2U0djDoTlKj4Yx4MzlHTe8SqJTVMyW2tmzGa+ohNIUKXXJXQZpB4HOhso06TnCSBOG66H6P4s++SjEYwnBkmW1YhdEYc/0G5vIl5Gm7kNz63JuMnj4Fwm7sD4LYwFsz+KlbZmtQJX0zQqy/gnrWQ821jzonT8TCPzi8rwiO1ppf/dVf5WMf+xiPP/74Ax/30EMP8X/8H/8HTz75JP1+n3/xL/4FH/3oR3n11Vc5ffr0Wx6fJAnJMWn64EHjfb8D3NtmW/cm7Cc1MJAbRZ8GvRh23gR5MDu5q1W7qiqXT4Rkf14x1b8c19Es+TmYhHh/xG7lLKUPzCPbkvHYrrwrFRsENzfvno81HM7M2aZ6m7dzNW027W3ajqrLFda8K5jbe6ws55RrCikEp0sdCm2404V0fpXNqMXWG/Z9w94GF179Azp9Rbd0hgPvAgdpxuL169T2/+Cu0qzRGr21Yze60DAYUin3GKoGPV3j0ejLbPnnWfeu8NpVlyHwzDOzDFOlMpsI/tprlqA984z9bFeuwBtfHdLdjCkWn2Dh1B7Oxjbt4R0ui4zEfwYtWwxUk+sHHpdViFNRbKSXOD98hRuVCyyITfqmwhvZJVr+LerPPcK+lEeDNnd3YXdX8+jml7kTFWwvPE4JgRgLJqqOPL0M1zP0xha6qFCpyKORDkoBQqLaLaSAvKZha4gZSchdMB5pJsnzmblekliCUy7PRj0EnXVkkcFjjyDeNExGMHEqKGnQuYDxkHG5xHCscCseuRNg8tkg0aKwmbBazQq3b93UFG9cJUwOaJytAYKXuucZUMFUBKvR65zZuo2SfxWw23d9t0aiAqLIIVUuVXfCKC9RdiZcHa7QEAdUvQnNJcHamj3XlpZms5GmpTLKNWS7RWv/dVpzlbskBsYYdOcAde4sxdXrlji0GhRb21AKMa5Hz12kNljH2djk4PwzHARPYDYj3ItD2ufrbzEf/H5hmsFPBxF7c48zykqITCNdEHMhle4ai9tfJHz+Z04y+O8B3lcE55d+6Zd45ZVX+MIXvvC2j3v++ed5/vnnj/7/0Y9+lEceeYR/9+/+Hf/sn/2ztzz+U5/6FL/+67/+Pd9eeGubbdMb0/Rst4QxEI1yRr4hLbvkx4SIg8HMTOvotYS9iE/Jz4/aJOoTvBXq9Ar89Cdm6e1DHU14YYWLH/4A6nT7aIBeuWwDxdRJdurKCzbdPZ0ftLVlhaHDob293VT0chkulTcYf+kb3Oqm6F6P9QMNlSqLy5JmKYXOAWcaFdRfOs2GtoH7zrom//I6S4OC9pkabbpsxw1GImTHf4TtTpdzX/om1Z8/hd7csiWG6zcx3QObshCwOLxGzSmz4V5gVFuhXvFoc41r5XNsbtrSxgc/aDUbjYZ12XVd+Na3LImbTOBjH7Mvd2lhwGt5wUA00W5IeGGRg0FAkz5P6n2+MWnSjzUHI48b8gpn0zepLZ3i1oHPRwaf5ovuTzBQFXLp8eqln+f5xx/lXGa1N52OFaXu3Y7YWc8R1SqZdjkVdrg+WqCXlkm1y6n6iM2BZPuNHvUzLQYDexwcx5KLJLFDNidf/zrZZkoWrVKIgCwZkKxcpCgaGGMfH0WglMYnJR0YApXRGN1GzrXo5HVM0+FO1iDVDjXRJ5AxzeEmHc6ReG1K821GY0mlYq8nUWQzgO02PPGEPS+i3SGm2+X0Qooh5Ev7DxHlDql2uFjZ5mxtjNo6wOx3SOvz3LwJE1UlqS0w2U9otEek2gcMm5M2TX/I4vg2eu4UW6Mq5YrNRklpSVZR2J9CgBCSK39pFf3733qLSF537ABNdfki2Z983mZF0oJb8hKR0yYgAQFpWTGchKihB65DY9JlZWmAWvjB1H60hu3Xe+xc9+m7z5MObYvj6fI+Z0odXFlgnByzeefbGm7CSRfu9wPvG4Lzy7/8y/ze7/0en/vc5+6bhXk7uK7L008/zbVpD+49+LVf+zU++clPHv1/MBiwurr6XW3vFPdr153B4Pd2KJ0/h/dUbZo5BWxgGo3sLYpmK5vJxN52do69h7AL3ynxmaa+T/CjAXV6Bbl86oEXt3L5UOCJDfpK2exLntvMQp7b4Nnvz0ZGnD5tz62NjbunolcqNiMxzepM0+vOcMSV5RZ522H9DsTDITtXJXtzczTPn+bUj13BWV3hHDZQ3frmgHS/y1Z4CTHyKTu2g/F8ZZv1yTxZpcKt2xHep9dYvflZxGhgP9NojOl2D6OepLI6x0N1wRrzJLsjisVFnvpIwLXrttPkC1+wWpsPfMCe9488YgnAa69ZIvdHf2Q7rNxywKXSHW5kFcYiIJYuwleMWKDqxjwprvNicp6RaLDPIr4Yo0dbNObm6M5/hEfjfb41LLHhPIS/WuagJ2m1ZiMcFhZg93rOTtLg0tyYXuazFbUQGMa5x07c4Gx9n81ehZs3BR99xB6L8dhu93gMw7V9iq99nTjZRVSWEbKMyATZbpe4BzlPAi6OA5NeghlMyDs90AafPgv9b2BqpziQFfZljW4wjywSZFogi4yRKTMIThEsz1H4ZZxi1t0VxzO34nrdEjeTppw31zH+En+0/QS9rIRLwUP1Tc5U9vGR6F7GpJdyp2vPL60l0cJ5auOXKboxe95ZHKmpMmBhvMbQmyNuX2Fh3nbvBYF9/zSdlahmnXwrFPch91ORPIUmTwrulM6wHwWM3CGBzsiUh0MOykAaUafHgjfCBCNE+P29OBozK+8eHMB4W1GkLVTg0fYHNL0Jp8IuchoGjmmJ3g4nXbjfH7znBMcYw6/8yq/w3/7bf+Ozn/0s58+ff9evURQFL7/8Mj/90z993/t938d/t8N+3iHuV2a4dyXifPiZtzBxz7Oiv3ulRkUxIz6j0Yz4JIm97e8fe29hA9V0lVYqndR3f1ghpPy2KzyYtdtO59K4rl35TfZG3OkYXF+RpSV2diRSWmGy71tR8jSjcPXqoR5nURPcI5B3S3C+YdCjMdsbmnGryeipj3NtrCitWeKkFJxrD5lwg43gCXIDa6M2ifY48Cs0vDGn6l1uj1yyN25wfdymvHSGlfAAtbqCjiN0nECWoXt9ZKPOavdl4voc21c+yngiOXVqFoivXbNZlI98xJ7nDz9sP/fVqzYr8bnPwTMfbFM+vcz5Gy9z03uGQiuMMAgjGGc+wXiLJ5YrvGROMxxJNv3z+I6DM14HA8tBTHmpxqlmhV5e5etfh5/8Sav1uXbNBvd2W7ArSsTRBBzIjSRUGXtxnVEWsComICVR4R19D7W238vxSDP81hphFFMsnYLcxyQCpINptcg6BblOkJ5CT2LyzpBcS4znonxDoKEy2SF9I0afPcNOcpZUBDTCgmrFp54ruukpsrllhOcTTywxrtUsAc4ymx3+4Afh6pu2Y+qMv400OV/Yvky/KJFph0cbdzhd7hCqDDNJGKs6+wcV9g9byqMIyos1nMoj3Hh5QiXZwzUp826Pvepl5Mop5s/VUMqed3Fsf3qePecuXbq7ZPogco+Q3H7pgA39BKN+A+E6BP4AbzykHBQIIagXHeb0HVT4CLrTQ50/d9hy/r3HcGgXC/3+3Z41rbagFO5wqjwhrNwnnB5qid6OeJ104X7/8J4TnF/6pV/id37nd/jv//2/U61W2d7eBqBerxMeupr94i/+IisrK3zqU58C4J/+03/KRz7yES5dukSv1+M3fuM3uH37Nn/37/7d9+QzPKjMMGvXfecnp1Iz+//jmGZ3hkP7BSvsOB/yfNYRcxxCWOIzvZ3ofH60MM3UtNMNkj97ge31DCfxMEoxuLPMeP4C5cUaeW6zEOWyDS5JMrOA33xjSHbDpVR5iFNmwiT3kRgqboyqVlg+M8EMv8XIeYKObjGZ2AnTjgOrYYDjK86pdXRYwpHzDLOA/aTKflLlAIemWac62WK7eoUo9/la9yJz/oCzl4GNTXT3ALO7h6iUURcvUv/wMzRX7MypNNGE2ZDHT8Vc36xy0A34zGckTz5pScfFi/a8vnrVao++8lXJw2eeZ2m/w4X+C9wInwDHIc80cjggD+vUHjvLE1Ly4oswmXisO+cJH16kVInZK7t85Kkqn/+CpL9jCcFLL80yR3EMrTMV9l+psNEds7SUgvYoOTFSVOmmZaLBGFWvIkohWs8WG64LZhIx6maUqhVyo9iKG8TaRWHQRlEEPmYECm2HaGoP6TigMhxRUKsbWFxkez9kcJAy8jwcUeCrDOkphkmJYXmZsOaSpJZUlEr2+nBwYEtTH/oQvPnlDsUbV2n2byCLPV7onmdXSqKS5Om5NVbKXSpOgjGG7l5Bd+4RdkdVHNeSG1teglsHLVqPNyhRp6QSuuOQylxoHa0P15KTyaz9+V7/pbvO5WPkflpi3dyEfq9OUV7E7e/jhyVqLdBJTG28x7zXw0wiqFQw3QNkrXrfheS7xfEyUSJDNuIW/b68a7r4NBO2sgLlUoW0oylu7mDKy/fXEr0N8bq3CzfVLp7Ij2aNnXThfnd4zwnOv/23/xaAv/gX/+Jdf/8P/+E/8Lf/9t8GYG1tDXns4B4cHPD3/t7fY3t7m2azyTPPPMMXv/hFHn300R/UZr8F367M8N1CCBuk7u2OmWZ3ppqLNJ1lfaYajHtfJwxnxOfEVOqHF9OVH8MRy+0WBJpkUrC1F1ON9mDug3S7bZLEZj7Gh0a67bbNHG5/M6KTF0Sqxs1RlU5aJpQZJScldFKWPIPIDmj5Y+bPto5KXnkONwdt8urTnNr/JuXVgPOVXXItWZvM008D9jo+++FjtJMNFsoZvpOwGTVZy+dZY56Hz60xv7KN3trG+6mfRH3giaPvyllvg/5XX+bOuoa8YNlx6VVOsxNe4GtfK7GzY4P14qL9PoSh9cR5OVugf+V/5eHuF7i48TpXR6eRUpHPnyJ4+Dw021QKW+Z69VWYTCQ3dyq49QrzVbhxE55+2nZq3b5ticlwaLNgb74JcSJpXFnk4BsRcu9NTGWBXPiUzIhRL2e3fobzz7S4PZKsr1uSMS0n50mBKAR4LpmWGCNIcpeSSsmNIjIhBQKHnCJK0bJMKHPiwsOXE5aCHur0ClEk2BrXSIXAd3LKZkww2GHozhOX5/BzWxpyXUtEBwO7WFpehv71XfKvfhMnHtJe1LyRPsN6tMR4Ini881lOlQ21mouZJOzuCnreCrvNRxBYsTVwZBrZakGtJsmyKgdxlebhGq5ctkTI82YZ5XuzNg/C3h6sr2m6GxEmz/ECRXhhgcob65hel1o5pd3sYDZ3MHtDcFzkqQrqwvl3vZB80Pcp+rMX2VzLORj59EQTqlXk2VUqS3WaTY4yizN8Zxn8KbLtDtu3E4bhEzC0zPBiddsO5HgXQ3NPcH+85wTHHDcIeAA++9nP3vX/3/zN3+Q3f/M3v09b9J3jnZYZvqfvediOGgRvdefMshnxuZ/OZ3f37tfxvBnxCYKTctf7Gfeu/DLj4MmCoCI5V9boO68RbxV4T/4VDJIksStjre2x73SAPORU2MWRERucpuWN6achB4MKrkkZkKJMibO6RB17Xjz0kCXUt25J5OXLbPaHmJsxS3MptXLGeXmTdDRgvXqZ4ZlH2X8to9v1mK9EPFJbZytu0UvLvD44w+v5KZ6uvUi4snwUAKakLRiOuNxucVOfoYgLWr2bVKN91haeZX29Qrdrjf9aLXjySRtTvvUtuJa2GS7+NZ7/WIfH4pgb+1WKUo0klfjYQDs3Z1ukr1+3mc8bN2xGdDpJu9Gw35e9PfjKV2ypamry1zjbpD9S7OxJ6sMNKtmIVLQYlM4yfvwMH3i2xe3P2nESTzxhsydRxOHxkUdt0cDRTKncKJJcYZAoaUgLB6Osp80wDxDCMB8MSEyL4lSFzv4qxhhKeQ9HTIjqpxmVVwhL1tQvCCyhTRKbvfN9WFnWrP2fNzBRzPnzmvXxCt8anGWsAh5pX2V5a5vaRoeiWGBHrjCcO8NO42FkpYaUmmIYMegZhKdoNH2aTXmUNa4cExP3erPRFW+XtTmOXs/ur72bA8zmJmI4wNUJDXeImmtRO1Oh9coLmFc3MFFkT2LXQ8zVkMunUM8+/V2RG61h6+Vdtv7oKt1Bk6IoMFmOn+/T6HyLhd3PsPi//Rjewx+87/PfTQbfGEs69/bsQkHvQZ6EiIprh/B6Q+QD/IBO8O7xnhOcE3z/4LqzduDjKAq7mp+SH7hb5zOdqQOW5Eg5EziXSnCSKX3vcdx/CQS3R4d9sQIWgx7VdpNw5yaXWx3kwjy93kzwOc3ECKqMy4/j7m3iL2Qs5utU9mL6E5dEO+zQhkqd5BpUD7NAp07ZgPnQQ5BfbHPLfYr41etsd7psdwqanmb+/CoPP/cYxfwprvbucLA1ZNddZC+pMe/3eaS+ztXhMukk5uuN5/Ffa/PRJjjqbtJmEFwUewyDgC2/hbvfZTV6g077afoDyWc+Y/U4jz8Ojz1mMxavvgqbm5I/juf58R+Hy2dt8ETYc9v3D0tsq7PRGZ3ObLDk8rLtRuv3beBNUztu4JFHpiJbqC3XGFWfoNw+SzzKcCch/qTEgZZHXW15bssYvm91Qrkb4FcrmOEWwrdp0+naTmuYJA4g8XzIIxetBYl2cUVB2UnwZMH10Rz7RYXCDVHVCtWlgKBxirEuM94BbxSjtMb1QIqAyUQyNwfPPgvrrw7RnS4XF4fsJ22+tHuZOHO4XFljtTVhsTWH2ZdsPvmzTEpz7IyqSCVR4z7FxgZ7By4lM0Y5UBsYupOLlBZqgCV/k4m93jQa7zxrMxpZcrm3B3owQF+/jptOmKulCN+lbjStO3+CeKmDKZXtzlQKfA+hDSLLKdbW4ff/EPEudSrG2OOytQWdjiZ5pYseuMg0Yi7dYc7rMxd2EU6K6RyQ/Vf7PXLO3L855e0y+FPt5FRTeRxBxaUe7lN2+4hS+NYXfgcanhM8GCcE588hlJrVkY9jmt2ZCpynvhxF8WCdz9SdtFy+e0r2Cb6/OO6/JAS0/SGdtAoGdqIG27qKiXos72a0598qTu52bUfMQXqR/QOJs95nNBHIQlJTQ5bzDqGXUzBm8JJDb+TitWocHNhAtrpqye6lD8+jn2mz+VqfwUHOyPMY16qUjWTFhYd/apXJ//VpbvZGDIJFdqMqe6MSc8kazVrKjdMPk+eSz30Oms6Ih9Y3UYemmZuTJpM8YLW8x6XqNjfSJl5vh9XHh5TKdba2bDdVp2OzOQ8/bLfplVfs5/ujP4KPftTOApt6A00zHI5jHx/Hdn/sHFr0TIeZPvWUJR63b8/miU0N/8plGI0k+1mD2jyUI4gOA9jW1lGFAmPsYiBJ7L4Wy8uItXX0fhe8qn2jIofhkFgugXDAFRjXx6SatJCEKmc+sKuQQgs2Rk0KJ6DS8CkvhExS6O9O8DoHRIkgNBGuM6SzOU/rbJXLl2tWc5WmLLPBKK7w+7sPMS4czidvsjz8FvODLubUEtfMRXJZZ3dYt7qh4YD82nX2ogqNMEF6Pp6O6e1llEffIqxfIVhqsbc3M9R7J1mbKLLZs2mnaJFr1NYd5rMN1EKTmlsw73eRwlBs5ujxBBLbhiXnrFNebgRq2EcUOcVgiHiHOpXh0J4L3e6xqd2TiPp4g1K+SZFY/YsrDBIOu0Ga6F6f/LNfQP0/fuGB7zHN4E+tHPavvpXQCDErEUsJRtdIb7bu24X7TjQ8J3h7nISkExzhuM5ncfHu+5JkJnCeXryn2YB7J+FOy2bT7q4Tnc/3Hvf6L7X8ES1/hDbQSav0hi5GKvbGZfbfmF1Y220bqBcWDicZ1xoMqqeJPnOLTtGgcHx6xDQaS7itBvP1lNb2VYY9yM5+iJ0de3EfDOyxnQ7+PP24jWr7+/Y2Hk8FySuc/sRP8dCLXyO+801uR0sciBb7tYt0V06xdLFGuWxX8p2O4fOjZzhbjrjAPr7KmeSwPp7HVTkXGtv0JyO6Wcr8vCUSW1uWdPzP/2nnKp05Y8+7l1+2AfTzn7e6mtVVm60BG2CnJZUPfMBqbjode/+U5Ozt2X0URbYD7c/+DH7iJ+x7OY59/nBoFwlhaJ93cGBv58/brM+tW7PjFYYg/RrmqQ8ib1zF7KToNMOoHNNokMcVRKqQErKwgkpHFIVAyIJVf4feQDDci+3U7nJAtSpt+3VvxHhriCg0visIXMlY13AnPUprd5gsX4TWHM05hcwS/sfGjzEWPg3R45K/xul8C30QcWOywrjq0zso4TchyzT5+g6DSZl6KcE1CUXmknk+suZTHd0gu+6RNBrMz8t3lLVJUysKP+wjIcssWV6uDtGTW1RailRqhlmJihtTTrqY4QjKJej26FbOsiMu4BETiJjTYYoZjFDz82+rU4mi2biPqZsz2GNXqUCxO0EnffLE9rX3RYMUny4tLnAdHAfhOOjNB7/HZGLPmSh66+culy0BvJ+9x3fahXuCd4YTgnOCdwTft7cH6XxGI/slnxKfKJrpGKYQwl7QpjqfMDzR+XyneJD/khQw5w1oRZvI8+cYXajS6dpjMiUfQlhiMj9v2761B/0X9inXT5FKw4Qm1/NlXK3pjwdUyyGqu8/Z2gGVapsssyvgwcAGq/19G+DPnJlNap46K+c53MpX4NFTrH6oy2M6InMCbg3a7Hfk0Sp+cREI4c4bkrVBk7Vonke8a5xhi7V8ldT3uXYwz5yTcuUyXO/bAFUqcWQK+PnP20zLs89ap95XXrFt5l/5ii2pPfzwLLhOJjOd2VNP2cf0+3YkhJQ2WE/J/sGBJWzXr9v9deeO/bxxbPfBNBPqunZfPPyw/f/6uiVWYM91rSEK2tQ/0sS5FiHWFKrWRix6FC/NhjJq6eE2yiSjlFB3qXeucYNLbAaX0KaG67vU6zAea/qbQ2QeY/wSysnxVcqYErVGzJnJNUZvgPN8i/b5Gv85/SmGVKiKCU+Lb3KWW2jX43rtEXpDl37RIqz65DmMOgl5N6NcDMi6OX0qNPQ+5bCg2ZTsBGdY6G/gZUOWlupHupv7Ic9nxEZru988z+5Lx4FgEDPIC8ayidB2P3gyx+Q5uYbb3mNs1lvgVhA4nGKTKkPLpnQBUmLi+C6dSpbZ82Jn5+5Gi3J5VmY/yji7Hh3aCCOpy5QGtmUqJLZjRYoCXBejzdF7TF2hDw7emqWR0pLjev2dXd++l124J7gbJwTnBN8VHqTz0frQ3Gx4t59PmtrgeHwY3rT19Pj4ih+lBcv3w6H0naz83OeeYW5eMjdv932/by/4U7OygwP7WpVJQT1LOHc6QsiEYZYy6LZsOSupsZ63KCVdoptQWbXHqdWypGI8npUapqMk5udtpuihh2wwu30bjJGsjy07Xl6Gh1dsJvDmTZsV2dmxmqClhYLRnS1GpsSraRmhSzyVfQldrbMnl+isXqbfa3PhgiUp29uWWHmeJRe3btnA8xf+gvV88X2bTXn5ZY6EydMsw3g8Ix5PP21Jzng8K2c99NBs5tfamiVEq6uzc3Vq2+C69vNG0axMBXY/12p226Sc6d7qdQmlMsIHfPv+eW6fo7UNzsLz8RouC6eX8J78G4itGjtfr0IhqVY0+TAi78TEY41wbElFmZxeVmXOH3ClusVQLmM6HS41Ovzuf61wQJOAMU9Hn2PF3WKsfDbNMnt5g1FYx5GGYhwzyMp40YhiMmSsfHAqCAxt3UOPcwZJwOLiNmQ5lxYGuI37OwdrbY/vnTuzWVvT8qbnzUp5kQnAUTAasxzuU/I1o7zBy9Gj9MOzGG1AJtR0n0vcoopNGZuiAKlAa4TrYvyAzc3DFvNjbd2+b4+zUrMsSpbZ8851oV6vMjcPRWcX5QUsOh3KTN3o7WpNlMuMS/Ns7VfJ78nSCGGP89zcd+4+//3uwv1e4YfNbfmE4Jzg+4KpMLlavfvv0+zOVOA81flMA/DxCxPMymbTrM8Pm87n++lQ+m5WftOszXSlPRzOuqqGWUiXC4hOSKVimPf7/IWFb9HLytwez9Mfu+RCs7ZXoujZlenigsZPhyyoiGo9IA1qdDqSwcCSlXbbrpRXVw8FybklCWnKURBqt2224/x5W6La3ZXs+mcw0YDW5BoHlTNoz+Xr8qOo4Zhn9Z/Ree5JCiQ3btjz4uIFzfVvDFlQKdV5n/VuheFQ8j//pyU4Tzxhg87LL9tA++lP21LT9Jo8Gs2C31NPwde+NiNOnme37dQpjsZlfPnLNjt086a9fxq4p9nIorBEqlqdkZ8wtIF8OkBziunKP8/tcXCcwwyOto8LQ8mZh8t0wjI7h81DOktp9m4zXCsY5R7EBdJXaAL6qkLTHdEKRozzENyCs/Et/sdnfozdfYmD5kNzN1nuD7g5OUuvaJCpkDisI4KQPMsYHRgq1RHxTocchVEunii4zJvsqkXmgh1U1GVur09jwUOVP/KW83LqnH3rlj3ecWz37+nTM5H31H0bwGQpq5PXcLZusxNe4AX/EYqgBOUA4WUsdb7FueIqDhLpVkGII+JBo87+yGe79QSDV2c6FaXs+afUzFojju05HwT2HJ7OqwoCyfxfugi3P4PeP0C0mhjHISsk3bTGODyH8UJUfRWnZNN1nmeJ/L3Xt+8G70UX7rvBD6Pb8g9ZuDjBDzuEsBeeUom3DMSb+vmMRrPJym+n8/H9Wdbn+2RU/V3hXodSfA8OeuSvvoZev4P7N/76A7sy3im+05XfcfI5GlZZf71BttVh5LcYZ1aAFTgpD1fXUcN1OmeeYOuCz3gMSXfI66/2EJMxDXrM+X28dp2zT14kqcwzGMwsCKbDHRcXrUGf1hxNmO507G3afn7urObqjXW2w4BOcAmZJDSibQ7cRYpqna+Iv0pzbcITH9esrUuGax36n77KwuBNstSQi3kutlrcKj1ORIWvfc2Sko9+1GYYv/IVm7X69KdthmeqMxsOLQnJc0uIvvENS1IcxwbHhQX7GXo9+/y9PXv+TYeVTg3tajVbNtpfj3l0dcBgXGVrMyQILPGbtm3D7NzWeuZdNcWUKCllCeLamiVUOssoRfvEUUzhVEh0BdQYlSZQZEhf0ixPKEvbyrUod/li9hzb3QADPBu+zHJ5xJ3Sc+wPQ7JCoqWDUT5FZkXNpd4G4w1NMY4wRlIfbaDLVQ5UgyW2EALOOreRu/uw9IRd0Wt9dL5tb1uyGkX2OyyEzdhNxdswy1Z5HqyoDdJXP82bXGSv+ZTN1giFN+5zcfRV5rwBwplAvYqJInR/gPA8hlnIhv80XU5jRAXZvohEHmZ/NRU9hDhlon02ehXKZUmtZskq2HNucfF4xuU06c//HHv/9bPsRxWMUqAcROiB66IadeaePcf8Ffnn0jS1WFsn/W//A9M/HLmy3EYk6fvebVmYd2JE8yOGwWBAvV6n3+9Tu7eV6ATvO+T5jOSMx2+teR+HEDYwTQXO75XOx2hN+rv/w2pkTluDlWJjCzMYQlFgkgS5fIrgb/3fUd8lyXk32/QgIjQlY5NBxl7lPKkMIcsxQzvfJ3z+KVaemEfubLD2P77BxrBG7NdJZEiUOTjJmLnShLnnLuIvto9KLXt7NohLaTM2tdpMezHVBE3hjHss/un/h6Lc4JZe5VavRV4I6l5EGGgGkYtMY9SjD3M63KP6zc/TiSuIVhPpu6zKO9zeKyOCgMGVZ9kY2rqp71tCo5TN0OzvW0Ly3HM2yE4JVxjac2xvD954w27/0pIlPb5vs07r61bn82M/ZknH/r4lLq4LbdnhzRcGxKOcx9VrbJhlZL3C6Q/MsxW36XTse1y+PCMt1SoYo7l5w+C5Bt8zZFohpeT0afi5n7OOyn/6p5p8OOG8vk5cajHKArIc3GyEzjWF9DntbnB+OUcKQcmJubMheUU+SVFp8NHnYfnqH7F+q2C/fIZcK4SAtHCJCw8x6SPylNypIBXkk5gmHUZZSDU7YMXfZcnrUptsYw4OIM0QZ8+glhaQK8sMHnqO68MlxmOIJhoTx5xqRJSqDkWpiuvNCHe5bF2AB33NK//5VUZ7EaJWgSSlOt7gyuBrBMX48DuyjPe//BR6/Q6jNzdY61bY1y1yN0SUSshWE2++jlfxqTcVIk/pvbbJ6CAjLEZU3Qhnrol66DLNC23m5+8WQk+76KYmmHp/j+Llb2G6HXwTM1eJqJyZ/3OthcnX1kn+X/9vzOYmxvMRjoOoVZEry4hqBX1nE3X+HN7P/ewPpFz1buL3CcE5ITg/tJjqfKbkR+sHk5+pzuf4+Irv53dR7+6R/Kf/gqhWIc8YXN1mUJQJvYKKM0FFExgNUQ8/jPfz/+v3/eL5TtLLdz0my8ickL3mI6QXHkG222A0+Z99BbG7w9JpiSs165M5dqIGiRZMBpqs1KB0cZnFRagyRGQJ2vUZUmU8ng0PbTTsyr5Ws0LdzU3Qe3vkf/pnyLkmq+Uud8ZWbNxPyiipaTgDOOiSlZuI7j4mSbkirxJV5jHNOWSpRMWd4OxscFA7h778CFe3axTKQ0jJww/bktiLL1qC4Ti2i2phwWZ6BgNbvhgMbIllbc3uu8VFW+5KU0tKBgP7OsvLNkDevAkqHjB3+2tsjJqM3AYrlR5xotBRzOlqn63V5zjIara1/pJ9zu3bUHEmxJ0xW3ENjwyXHC0d/IrHkx/0OHvWlsW2NzLkqM+psEeUO3TSCjJPcUxGoSX1bJ9LxbeonF9EKkXan/CV/ENk5SYf/pjL+fNw+6UDdl9cJ00MTuiSSZ9J6uKkE+JM4DkFRamO0glhf4tEWWHxYv9NLsTfQvrOrA2pVML54FMMTZWru3WGoka2uEohXBazNUr9LZLCIXByZLuFvHKZ1sU2CwuWJF6/Dno0Jn/1NWTgca5xwILfRxsopT1MnkOWk2Sw//H/ne2oRtyNMFkGeY70FG4eUx+uYboHDNKQSHuU4g41N0bOtRG+S9N0qfdv49TKuD/9CcTyCt2uzRzer4V7fh4adQ2d70xn8sOmUfl2yNY26P3X/x+DG3tMygsYL7CfMUm4JK+jLl9COAozHOH/wv8N+QMosb2b+H1SojrBDy3eTucTxzOBc5bNSgKDgb0dx7RsNiU+70Yo+KAL2tSnBt9D316DLGNUOc9YCPYBQoNhQtALaH7hNdo/fwrHffsL4Xd68Xynw/zuLXcFYUDt8D2yDLZf73PQ6SIqNbYin8IIxkXAQ7U7lJyUG7LB/ihGD3zWbkTkk4SSGbPodQnnK4QXLiKa7aMV8+amFWa2WjarEZcFN76iMEnGOnMg4NHaHfbjGjtJjf1hgIzLNHWXRAtUGHJVPAFRTjmeUMzX0Q7ogcf82h/T2etwJQzYDC7QLZ3h9ddLbG/bbE4Y2izNCy9Ync2jj9rA2+vNSmpJYksue3u2I+sDH7Dn2rQEd+GCPc9KJU1yY5PtcY2FuZx4LNlPa8zLDmPPJe8NMGoT3a4cjZzR2nrTFN19omzqoyDI8BC6wBt1OVeRjCcL7BzOxlphn3FWYhxLMgRKuHgiQ4qcuWibcNJB7wi8RsAX+HHSco2nP+Syumr1MPtpk3TFRe7vEI1SksLgqwljr45v+iRuA5+Csani+n3Ojl7nbLhDrbqPUQHCcTCAcF2i5jI3ssfojRyiNCWLMha6X6Sie8RuEzEXELZLkGY09t+kmrzJ1fhnefXV2XTh0Ek5I18hb5xmXJS4M5mj7o4JSjk7UYM7aYPxKEfdFshDYbbr2EwgBx26X11nOxZUKk3q1ZT6nVuYwYC5cEDTG6Fq9sIwKp1j/U5G8Yd3cD5yCoQ8+t5PRfF3W1lIeJeB2mhN8cq3yL/6IrrbBSkQnve+16hMkaazheLU9d4uaNYpBlVMAHgBQgiEUjTCBAapNRu9fBGTZe9Lt+UTgnOCHzlM522F4Vt1PtMv8nB4t85nPL67I2j6Or5/9/iK43i7rMiRT81BDzMYUgo8LogbbLHMkBqOTkA6pNUWO3dSui8OEfX60ciMRsMG2mk6/TsV+N070uHISOwBw/ymQscpmdLrG4gwwJlrs1wb0RbXMK1l9rMG/bTEKAt4tX8GAEXBpfRrlDZf4pY+yzCcJ5ElbqV19J2M+t4mKx+GVquNUnZ/7+0dziBah0ajxcppiVr/FpvhkxRaMcxK+CrnUmWDgzt77DrL7PuryKxHUw4YixqBN+FOPofsSXSe4Wcu+GdQtQq1MIHuVZrpLtd4lh4lfu/34GMfs8f0hRdmWZmPHOplDw6svmaqj+l0bBkrDG32ZSqifekl66Cse0PeHOT4QYAvR6SpYZw6LEzWMaJOTzuIeB3jLiEPVd5FrjGDATqOSEQJRAHkaKVQSJTJCK++xputnyLP7XFBCkwcMzHzKKFxRE6Ox6q4zXx4AIVHteHxmfBnyHyXRx6WnD076yyLY/AqFcaihGykqKIgKhw8kRNvpEgF4zyg4sZcKPW5MnkVMTh0RiwKTJaROiWulZ5hO3wY3TWko5j5bIuKHDJJPaTQlGUf0x2xVBlS1Gq8zlMknRhZ7KEebrCwYKfF79+QHKgFxESBB6lxWJvM8drgNGA1R7mUKOUwN2cXNAcHsLurCa+v00h3kIstlDQs6C2CyUtQdkkjzdXNs0zy81RdG3RNJcF0OqjxgMUrDarV713purizQfaHf0T+9W9gkhSCANFoIOfb7yuNynRMy5TITAc2PxDDIW53m6ChMKMJRWGoOBFNDkAApdCW3Hv9963b8gnBOcGfK3iezRi0Wnf/vShmX/zjbe1xbG/HtSJCgDjYJ3jhK5SifcrtKjK8Oyvi/i9/GbmyTP7qa/bFHQeFpsDBNSkmiRGVMrpcJjmIyIY5Xslmj5LEEq0p2TLdDvKFl6jEPRpzdVTo3jcDcz8cH+kghCDTikEWUnFifJXfd5jfg8iUunTR/p7ELJX6LAV9zpX3uDo6RSeukmUFb8ZnEcZHtRusBvuUnYj1eJFh6jEZwOsvRqhVzdycpN22n1cpK+qdTCQb/kdpqID2/h3m5zQ7LDKJFFG3j1+MOb80YOJIro/LbLBKiQmBAFcVOOM+294SYZAxKIYsSpehrFBbGsNOnyd4mWvqQySp5POftwLen/gJ+MIXLAH43OesIBns9jSbcPbszOTy1q2ZmLhW06zfyKnkY+r0CIshxqmzMShTGu8wYp6ut4grNLF2KI1tL3zRUERRlbx7gE5iCi3IHA+QCDSmkAhyKn7EzkbO9f0c8GjNCSbbNYZagzRoIcnwmWOPpunhZinlquIz0cdIlOTsRcmFC7YMNp17JIT9XEEgiXSAH4BJbXYoEy6B1iyXD3i2dY2GF6FLF9CHU9+zxHC19BSbzccZqDbpRLIyeI3lyW0mQRtXT6gnB8hGjTn/gDeTi7y+c5Z600EKgVPSrMavopqL5G7Dfp+qVeLGEvHukLjaAAQGSLSLQjOXrKPm2wxrIfv7Nns2Pw8MhojRbZYWEsLqNpPMY63TpON+nMStIhyDSQpU5FD1oO6OaYZ9ZLKJP/8Eqtb4Hl1N7Hcl/b9+n+KNq2BALMwjigLT72PiCHHpInow/IFOBL9vNuYBmJbuXdf+nGrnjAGdpOSZgmoDU8kwowmecmBKDJXCFDlmv4t6/NH3pdvyCcE5wQmwQbZev3dS8ANWPVqTvXaNeOjQn3vUTokeYb/49fOE3XVqX3qN2nMfRK7fId/cQkQuBD6ni+uMYpeRP0fSakGeEzo5btVBHJbGpsQqz0Epjfv6Vcw4J527xF6mULlGSHCbq1Q6t2j82dcp/W/3v3geH+kAYIBuUqWbHNb1TIEfb7F4kFJbePtylt7bR1Qq6E73yFzQVzmP19cxNUP85ho39QK71ScxRvBK/wyFUSDhTHmXc61dtodDErfJwUGZvT17YZ0/HCWR55D5NQ7MB+lubrK+t0+dA077e0wW2nRNHVNtEAorPA6iEQNvni2xQtkM8IoIV4TkBez7p0lzSSnKWQpBVByC3gaPPPYwnazO9es2a7S7Cx//OHz967Y89Sd/MsvkdDqWCF+8aMtZUWRHQzxz+QB3q08x8Fjf69N0XmVhFHNdfhA3m7Cc3GAnXGFPrLDADq5I8N0CRyekW/uMFkvkuz2M9jGORyFcNAqNwhiFYyJOpTcY4jIuBAXgeZK4VCadGITJcdAIDIGJqcXbSAc+W/prRLnLYiPl4Ydd1tZm3WxTgz3fnw3EHI9tVkQLl2rFcDH5Fk8sDFGHp5GsVSnKV7h2VbG2dJleGpLIkGq6y3KygZNHeJ5A6T4d5pjLbnJNPcSrogq+gaygrEcs1cbEuUNy4OKMMzJlM2ZpKtHtSxQH14n7GTL0mQuG1E1Gb+jQ9+epnznH0pI8KictLAAbA26lCV8cP8mgVwYDpsipy5sIo/FEztnkZU6VG6iq1WiYSYR2HMxkQnF7/XuijznKju53SYXPoHaakWyhpWK5tk4w2IXNLeSZ09/zieAPGqvzdpiSmenzj9+OxlYcg/Q9PE9Tpkd5Kce7cR2GCWbqqxAniCRB1GvvW7flE4JzghO8DaSclaim0Lsd4uHXSefbjL0x23GDtHDwZYYrCiblRcbrEfvnaphn/ney3p/AQRdfZ1TEmEodmiseotqzJn3nz1E8VmU4shd+rWdttaY/JDs0Vom0z9akgUHgiwwlDY5bI7zRo/rlIW6rfmhcZm+O89aRDp4sOF3e5yCtMM4DTJITiQobvQqbr9mauzpo0F5ZpObG9oJ4rJwl2p7NPN3HXNAvOVwRGzyy7KNRvDFY5o3RCmhYGy5w28wh8oRlJ2X1Qpnd3Zk3iTH2pRYWIJyvoRYrTDqr7GY5+65Dq57RnvwBPrvsscTp1oTR1hAn02ROwIAqI+8MZR3hOQXGCdiLSxggKlwazohGOsJLE+bmbRbm5Zftvv7jP7YeOPv7tvT0uc9Z47922/6t3bZ6mzffhPGw4Otf0zwr38D459kv5rjhPcyyfoFSdx2jFJ1gBUdkZChi4+JkI7JyHb+siEYZo80eeZKBLGEoOJx6ZPUtGHxi2v3rvNj8yxhXHJkK9pMSOGMoJAWGVrHL5fybmEqZF9znmRQ+NTni0SsOa2uzdvbpinxaFqxUrN+UUva2tCR57mOK8ufvoDdGmHYT4/ncPGhydb9FTzZJSwuUvR7ze6/hm4iW6hGbnG3/DLlQbMlV1v2LeEWOdAynzS0qSQcll0l0mTzN6DCPOShx2MVu9cpOjbknzlO7fYvhwYhhYqg6KSunFM7DZ2icb7KwYIP4q6/Cl74EOpqnyJ9GRA5Cge/knKtvcS7+Gm5v/7CWnCE9ayxpjKG4swnGkP7hH0H23Xm4TCaHnl3rQ9IbLviPkckOkWqhUdToo0SBmJZwCvMda1Tu5xT/dkjTWfOEUneX4aZk5jimJfGpa3epdIwE6SrpHShu3rSdoJcv3KcTdAXvb/y197z89iCcEJwTnOBdwkQxZBlBWRDKoW3ZFbOvUub4RLkm39Wo1jzeR38C5+tfIY3GdKsVupUyIskx+yNk6RGC1aeoR/JwrtPsApPncPDahE4Rk/s1SqSslrr0shK5VmhgZMp0Uh/nhiLo2YvV1OSsVALHaUPtA1R2r9E4LXCVIVQZYXhgh/n1NtHnLjI6U6W3bidOm0qT3djn5shmfSpuTMsfUWu1MMMhzo9/HH3txlvMBeWl8+R/8gWIE1Qp5NHGBo82NjAG3hgs89rBEtoItroh24fNOHNzNkPS7VqyM3URDkNJu10+Cs7dVLPnfQB/b5fWgmapmbJDlXJ3h/FE4ORNEjzGwRJjv0LZz8kKgzSa3ajOjqmwiGQlD6hgydQzz8ymWX/jG5bIXLxoO3xeeMH+Pjdn75+bgzjW3Hw9ZWhCXpIf5NHyHSaTMlvZIpVTD7F482Wuuk+gXIdTZp03eYSDok7VGXBQPofnGEYRRKPCmtUpRZI7aClBCLSRCAxeNiYZa/arTbIox6/mJHlAriXgIVRGTSZcqndRLPBy+hCDvExoJjx2ao+dyQq7u/Y8iCJLdKfjEaa+Uq5rA9qVK5bMSblEUf0E2Ze/xvrtnNeGZzjIyiQiJHQyTk2uUlYJ9fgmA7fFTecie+U2saoQFiNCMyZgwmr/NYJWCFKgpaRbtJhMysjhANGok4qQYmgzY1P35wkNak8/yaoeIvKU9ryifrbB7TXJCy/cPT8KQJU8FuYyrgz/lPZq5UhXZsQ8xWSA7h4g5uYwvgeTiSU3nQ6i1ULWqvAAkf1bvueH+6rfv9ueIknsNo23IU/mEIGPrzShtmXfS1y1VZzDURJmMnlbjcq7zcakqc0kC2HfwnFm1wzP1ZjBEJPa4aTUqggp8f0ZiXmn1hn3c0uXly9Cr4/udFG1Ku7f+Os/MJuL7wQnBOcEJ3iXuDcrcqa8R1T4jHOfcR5AmqOcBHdBIupAu40ufZj8zWtE+2PijiGTZYLmHOHlFWSldWR6d/QehxevkvKZCwaU1QRZDq0guvAZZiVGeUARpUSeJm2fIXNnF8vpjBzPk7jVxxF7IeHNAaWqxA9A5QnV0Sb1Wp3SR56ickoynw5IDkXEg6LKXr9Kph36WYmNSQvMacLxHo2DJeaff4ym7uDks44uAH3txlvmYwkBD9U2uDz4KvKRc6w9fpGXX7EX6eNeONWqNWKLYxtQ7tyxf69UoFSScHqZeBKxsZOxFZ6mGU5YWJqgdhMqbkTsSHaiIXHoMcl9MLaENswdVJazGyyzf6PC6dS2eAsxm5/16qs2m9PrwSOP2FLU9es2EK8sa/ZuT1gwA8YmZptTdLIaN0YLNoYZ2NTLXFjsUdnrY1IHKTV4ELk1Im8OoQVeGlFQIpMBQirQikxKQNgyCwJHp1SzLhuVy+SOj0fCZD9jpByEcsBz8dKYlt6h3rvNy/oxOjLA0QOu8DId/1n2tiSOYwNzqTTrDBuN7Dnl+7Ys+PGP3z1iZc9Z4ZuVU+wGQ6LhCN+dMF+OaQQpTQbsdQSveU/RDZbRSKRJqWRd5tll2dlFqRwjEnpxk747hxtIpHZIxgmZ06S1skCjIUkPdT+lkn1/KWF+XlIUdV59FV7+JvDNu79zYWiPy/nzoJSkuFMn+//quzOJjgPVKlJIRK2K2d7BHNpDi1YLeeXSA0X2ZvEUo7Gk3581H0zL05OJ3d7puVwqHVodLEN2fR8RhIThHpX+BqXKMfJQFBghYThEPvIwRaPNoPfO/LymDtDT64DvzxoO7je8WAhwBnsEV18m2LtNkA2R/nfvNPwWt/QsQ7guzmOP/lB4A5344Jz44JzgXeJeEz9xbDlkjLnL+KrQcubVM7SrK52kCM9D1KpHLatJMnN/ldJm2X3frsiKL38FvbOHmGshECCg7MSUVUS4fRPvwhnMX/1ZhiPrmJtlhyvjiX09gLgzJNrsko8TPJPgqRyvVqJ0fpHyqYYdVzDuEX7+f1KvgVfx0EYwyEp00zLDLGQ4UWRxgfPYI4hD//upm/S03dvrHNfw3Gc+1j2r5bU160uTpnfvY8+zr5vnVuCrtf17mQFidxczGqKKDKSk1AxYeHIRx4HoS98gnmh2vVUGpkycOWSpwXMKxpVTuKF3NGhxddUSqiiyAfSVV2a/T6eP56MJ4WCb1fhNulFIPhxzo/wkPTmPARbdA7R0EMaw4HdZ3f4KrwdPI8KQSeYy0gFBMWE5vYFTJGxVH6Z8Zp6i22d/FBDj21lM2iAoKOkhTw6/yOv1jzBWNapORJYbYsoY18PzJDU14rn9/84b+QW2vHMI4FFeIXJq7DmnkfMtEhMi5Ux3M5nMShBXrtjs1bSU0e3aY7CzA1GkcXs7lKMO7Zam5kTcGbfYz2uMEg+SGEcWlEPBilljrvcmwhgmfoNtlnHSMY4oiEVIEjap+il+LYBTy8hajXrdbodz2O59547Not17/B3HmgE+9tjd5eHjuNe3SbgucmUF9ezTyCCw+rPJhN4ffJFRuMjIaYCBlj9ECBhkIVlUoCcR+rmPE7u1u8pAd2dCZyaiVmRuv5vT64CoVdHXrqPTjChsMZHW9yl3Q8TKMs6zH7ReUseQJLMRHo5z+H33HpxdmXZ13i8T8xbX9MMsle507/u9e7d4P/n7nBj9fRucEJwTfLe4+4Ly7QP5/TAdTTEeP7jbIctgvHXA+KXr5KnGLykCT+PrCWo0QIQB6vDiKYQlRtPxFY5jycFgYANcEmvGu2PGI42RDpkbkiTW48Z1wfc06tabuP0O5ZZHqDJcpam7E6rOGLW5TrJ6heFH/gq93mz8AABGYyYRymRUGFPr3aDZu0E57yM9G3i+3Ypve3s2C+o4jDk2VmJk34s0IXQyhOvgVoIjD6GG6FJaf51sr0eaS7bNIj1vgazconBChLBBfxqwymWrrymXbUap34dr1w5tAYoR4s4a49TBDSRnvS16WxNS43Ddf5yhaiAQnA72mOgAx2Sc1rfJpI/JMooo5Yb3MI4peCh7iVx4bAfnKHsFollnbw+GOiDHh6JAAE29yyk2uOo+gUTgy4yJ9inQuK5HtSb4kPci6zsed1hFAA+V1ohkif2kjklSCr9EVm7guvKoxFcqWULxF//iLGszHNr9vbk5K2WVVUR78xu4vuRacoaDtIJG4MkCT2ZUJjucG32D2sVTpE6FjWEFPYnw4z5R7pL4dcK5KqW5MrLkI12H+lJIuWLLJELYyeK93luPf61mCc3p0++8hfvewBuV2gyG9tw0BtKtfQZfepmoOo/BlnVLKqEwikw7mEO30ODxK5SXG0dzyaaZmlrNnnv3xvKpu/rgxi6DL3wTPYnBUZjhEDOZYJIMXIf83BXyy4+RlZpHJCYIeOC4h7cjMW+3D97pguv9KAR+tzghON8GJwTnBN8LPGgF+d2mbqdlpmnmJ8ug2O+g37yK7nShKCiUS1JfIl0+Tx7Wjy6MQWBvx69j0zbQ6fiK44aHaTpLwxfFYabnxhZZBtJ38JyCgAQvHlAKDJVnHyZcbt/VcdZ5fYftr60x3E+YZHZ0tqhVEM0mMgwoVyWNlTJLS5J6/Z05SHc6NvgeH746bWGtVA6bOOLZ53Mc+7qlUEM0wY8H1MIUZ66OqdTZ2JTs79vPO53enWUzXcr8vC1/RJENbC+9pDG7u3jRgEoNJnmIAZbHrxFPYILPdf9JYlVCAgt+jyQx1CqaR57wePNLuxBF7LqraGE4p+6Q+E3GVHHTEW7ZZ1836E0UpnCAHIlmId8g82v0aBLI1H5mHAyCUih4+GKGeeM1rhcX0EhOBQc4StNNquRIRF4QaY+wVWKceoflPZu1+dCH7D6aTKzGaG3Nfl4pbSBdXoZs/4A3XkmJZOVQ9WyoOAnzQZ9LlR2K8YTNTZiUF6mUIZEBSaaQ8ZhAZYQXVpCLczQa8ijzsb9vs2HTLNwUrmv3+SOPfGez5KLIEqUjMpPOZoOBPb7pYEJx7QaeD65nWYWvMkoqJZAppAkyHtP+6Y/SON+6y+tq2s041cbcOzPs6DHbXSZX14l7MSYvCEyMX3UIL5/BOXfmKEs7xXdCYt4OeneP+D/+F/JKk8SvkWmHujvGkXaHm8nkB+o0/P3GCcH5NjghOCf4XuEHmbo1WpPvdBgdZIx1yNitA/Kui67Wd5e7wJKBKfHxXA1DK0KUvoesV6nW5NGwydEIRnc6jF5bY9JNSHNJJj2SsEnRnEeEJTzPEoMggDDr4b/2Il4ypNGUVMo58USw1xUM3XkmFx5HVO/+jk3LWqdO2bLWt5sQ3+/bgHzci2iqjygdegcVBejxhKLbQ8UjAjPBNzGqFFI5P094fgnHkWxsWNHwNPM0zZwFgQ2IZ87Y0shkb8TuC7fpmDZlP8dgGGcBfj6k3buGyhKGTpOblSdJ8fBURlkkeK0q1aoh3LhKiktf1xkWJRzHMOePSLVC56CyMQe06FMFJBQ5DhnzxS4dtYBWCpeCFB+NISCm2ZBcXuzx0hsBWrpUHCvSKIwg1j6KnFQ7KJ2QBQ3qLZdmE37yJ+1+TlNLGm/dmpGAKbHpdq3AO0tyiCcoASU346HqBm1/zG5So5PUCMyIYpKQBE1MlhOYMaFMUfUqrYcXKC83GY9tZ1wUvfVYzs3Z2V7z7zLORtFh51LfHq/jJdgpuUmSmV5lek6Focb/1os4e1uo+RaBk1FzIypOhMRqeDh7nvQv/QyjMYw2DwW67qyErLUm2R8RjwsS41L4JbuYyEb4IsEJPahWYDjCpIfl53qVIJDfExIz/XzT73QUzUp6xsxGnIh2E3FIphbDHjXXHgBTFOitbfyf/xuos+9fQfA7xQnB+TY4ITgn+FFEksyyPvcreUVbXcZX14kOEoocjBS41QD/wikaq21c9/gVWBMmfWRuZ0mNnTpxLG2pK5mKIDXJzU3MeIIqe/gyx1c5ZZUQqhj/YJvmmRqlT/w4o7HNoAyHs2nSUyhlCc/iog2A9zpGH8d4pHnh82O2dyVGKITvkReSUTfBH2zj5gkoSZHm5Bk4RUydHv5iC/fSWfx2nVrNlmV2dmYkcDSaaZ+0hovzPZw3X0VUy1yfrOCIgihViGyCl0eU8iGNeJu9cJU7/iUKXIJAo4KQqh+z2vsGXW+ZAsX2pEGGw9nSPoKCQeKiJgP6TouxOnScLDQhI2r02WMRpazoOEfgFAUlRjylXuElnsQUBb7SCM8j0xJtFMWhSLnQAp+Y+qkqDz3h89xz9vO88IIVTU8m9v9BYFvyp4aSQmiE0ShhaBa7PJp/k0lzhd2kgUQjMcTaJY8yylVJ7dFVZBJTD2Kk57IbVRgM3krsfd9Oir98+cFlmXsRxzYz0+9b4jolM9PuoTi2v7uu/RzTcuNUL+PZJOJMK3OoC4uGGZP6EmNZI0tAD0ZHJV5jIHr9FnF3QpwptOOhaiXC+Sp+bwfnYBdRFOAoxNTDIY7wioiyl1JZrlN5/gM4q+8uc3vcTHRKYKaC5ncSmYUA0+/DF/6EoOwQlgWByghUNnuPkwzOny+cEJwT/HmCMTC6vkXvD77EaARxqcYogzxJcKMxqVdleOlxZH0eVzq4jkIIcZT1Od7BMe3qAEj3+0y+8FUmbp2JrNCJq6TGQRuJI3JckxLkY0qPnqcyXzoKQNWqDbLdriU89zMZm84IWliwK2Ah3uqwnKmAl0ofYcu/iO4coMcTMuUzjh28YkKo7AsnuYORkkpZUL+yiFOvYYzVpEzHMEynSY9GNmB6MsMb7HGhtE3qhOyndSaTnDwzFNInIMYrIhbLI7bNKTbyeTSSckXhCE043qXljYllid2kTlIoGuKAOOqTFh6hKejJGsafBZww30OrgFT4SDK0CjEFBGbE48F1rporoAtkGqFMTupXQShyoxAYcqOoc0CjavjL/89TtNqSl1+2HWKTiSWWvm9N/jY3Z0Z/psjx8oiz4iZts892sUCWaRwH8qBOIjxKZkI16+IEDo0PnGMom3S79jgez0wIYTNCTzxhycW3Q5JYMtPrWfIyLTHl+UyEm2Wz8qvj3C3+dV17X73O0fiF4wN4p94vutMhf/OqzcTkDqkMKSoN5MopfNfgvvESXjLErYXguZBmtoV8NMSreVSXqpRKGr+zjX7jDQDkIw8h59oPFPNOzRWPk5cpuX+n5AVmnz0MD7Ow9wiRTzQ4D8ZJm/gJTvCjDqPxXvoK7fgO4UKb3X4XZQqEJ9AOiO4W4k7MRulZSr5H1Q1o10MC1yOKbMv5cRIyLXl54ww3i2jWAxoiQwC5sRmFXAuSwmGcBAx2BHnHBqPpqjsIZhqEZtNetKNoln2aBqibN+17ekmf6tXXWUy7NObsaAw/Tnim81lE9HmyOOVb9Q9z66CBLhRGOSQiZEIZpVIqpk+a+ty+luHNa1pte6FPU6sDSVPb0aP14ZT6iSKhxisjn0YQs+h2GMUjuu4pJDk96pRcn5wGi84+aaHYNW1GI0MYShwVMowTvJJG6ZisCNjNPIgEgWNIhYcRx1MahkgrkJ4ti+BiCoNjElrOgKs8hDEGIxTK84lSD3JNoVxAoISmRYfL5U0+9vMrXN+X/OGnbbCfao1KJVvm2921xEYIqPgxF6NXGJiQiVMjVnWKHCJjCNMBDX0HRwmUC53yKkW9Te+gdLTVQljd06On+6w2Rqjyg8u0UzLT79+tl8myGZnR2gb06W2qIQrDuzuYpLRdiaPNAdFeRrTjsVOrYpAkiSUT0w4le862CR5u4mcjWiRI/7AEBeRf/gpuvkNlpUrZHRLIDDDke29gBtvIyhKq9hAAxUEXXJfcCNJOTFarkog54sZZ8v0e8p6Bng/ClINMvwvHycu7xf38au5teni/Og1/v3FCcE5wgh9xTOdRZbUau/0Jo9RnwCJSaGQR4YcD5nq3SNQStObwvYgiGLGw0EYRHA0ina46p2n1aBAwEksw9MF1EUBZpbgis3OvEs3Yk+StU2jPBq+imM122ty0gWq6Cp8OSJ0OGRViuvLVRDe3GI+q7NSeQ4wEaqypuhGn5jrUbr+E6nV4cuEqj99+g6vhE2yIs6xxHoccJQomJiSmiZNoKqT0egFbWzPn1mlGZ2nJZnRAkiuPyViSx5JeHNDmDvN6k11O4YqMka6SxhGZrjJX3CZWhr67QBQptFMlJ0Hs7TJK+5hwBVSIqyS5gVx5lswcoTgkN8p2pAkH0OTpkO0iQBQ5SrmEUjMhxLgaXWhAUmVMQ434S+evM7n0JP/nlxaORLFK2f1+3GNJKVsOrNU04+v7bMVNCAJS4+KT05D71M2QONXssIArBY7yEc0WTqmEUnZG1+OPg7t/mFX7wiZZmpEfOgQXT32IUWX5iBxPycxUKzPVkEyJzNQTZ5qZmYpwpyaF02xMv29JUrTVZXL1DnEvIs8FSImsVQjOnaK0WKdSsZmqY98CkAWu7+F6ijCQ6CKH/SGD7hZReY5RXCKZOMz5A4ZjRRQ7pO1nSGMXuTGHJzIakzFF5QI5LlkkKfVLeKENo3aMScf63jTqdxGXILDn+fcLb/GrOWbA+cPgV/P9wgnBOcEJfsQxnUfVkwF5rjHKQ2hBmgu0CZkon4kO2N8pkcYeJd/FUZL+bsKlVZ9SSVCvz1bRU4IzXC7R206It7YRtRYgSLVDrF2i3CUbT3AaFfy2FdVMnzstP0xT9tO/dbsz/YHj2IBQKkGgY4JhF1MKyIFx7iOFJjOSXlpG+3MY1aGy47DIkHNyjRW2CUjJcDgwdTpyAUcaHJ0xHAmiYhZw1tct8ZpOcK9UrCi30/EYSUE8Noy1IFWn8URGk30cnTOWBRNRIpc+uXBppTukbpmICkkOo8TH1TW8Yu+wdUyQipB+GtFwFMhjl1+DJTfi0PgPAUUECDQeGB+yiLEbIlAYHKTKaNY0V867XDzf4POv/STDl+RdAuoss4TGmj5aAjf1x+ntZiRjiecFNN0xkfYYxR57UYCba6Rr9TzSLVPL9nh8/CKnf+rDR8FyapUQDxKGtdP0gwZRrBi9XhBf3yNfrZE4laPuqXuzMqXS3SXQqUB+en5NTfeOZ2IAxHiAe+0N/GRAreoh/MOS0miL8OZ1amefxT+9eFQi2uumbO7EHAxSRhNDlkgwConETyXB6BEoSmgDBZItVcFkhlyW0Y4HeY5MKpRVRCxWENLFI8XRI1wdcaE6RqIxjNDdbTz3NM6lx3/gGRN1egW5fOp941fzfsAJwTnBCX7EIcKAQiqS8RiUS0UOKdHH5BNMIchyl0z6CN/mzbNCow30xzG9QYk4vv/SUwiJuPIw1cGf4h9cpdQOcENFFAmGg5So1kY8fRHRkuT5TIdQFLNVrTGHHVCHLeB5PntMnh9qMyYSnZxFGhdXFaTawZMZjtAUKAw1PFeSRhFD52Gu5w7CUbgio2KGNOJNlis7JOUF+pHHnpnHdTWOKejvGzItUK5iPJYcHNhg225PV98uk7Fi1C+YjAQpkOgQn4iaOMAIycSE9EWTrORTMT0mWpLjI50y/TRBuEuIcRevNI9266RxzKgoqHj3XH6lLTeBJNcpbpFjVAAqAJ1SCB8KUEoQiIR51eXDz9d4ea3J9a/MxLdT7xshZsLpZvOw9HaoNXIcKLkpsTb0iyrjSQnHJKhJDz8Z4Iqc85OXuRS9hPfEQ6gV6/o7+TOP6MdO0T2A/ud3Ge09RFyZIxl5pPrw8/gGJxoS7m3TfPQC5bI88peZ6rektNsTRZqDO2PicYGW7mG7kQ3I0069Vut49kMjvvwyZJuopTaFkYxzj0SVmJTnmPQy8s9EmNOavBDESU5/klLkkkL7GCMQxk4tl9JQmAJhDE4yBmFwSKGIqZqIaraDX+QoNE7ttH37/dv4RUFAjK8HVKrnkMPMzmg6OMAkKdmn/wh98+Z35SD8nUJI+T0b6PmjgBOCc4IT/IhjGJbplGvIm7cpGm1ENKLS6+BFEUIXqDxj1GjT8S8ybkkqoQ20UgjOnKsRui6TiSUoUWQD09Ek4sYc0dMfZ/zmVfYPPXpQCjm/inroErLdPkrVT9u5p6MYYNYlMxVjghWMFoUN1mkKhWOIDxIKAYn2rWg6Cw/naQtEnqJki5FOgCa6sC3WJRFT0gNcv4QoNyiijGo9ZOHMiHR9h0G/YCefQ+EgXce+prBOx9vbdlts+UQilcTzCqJuRGR8UuESEyCNQVEAhmFRZVRInLxP5rZAuJTDNuOowzgZ0QSkchASW6bi2AVYSEBiMGg0aZ7gSA8cH3SGHTUvQecEqstFsUkSzvP5l+pHx8VOnz98uUMTw0plZhsw9QoaDOz9ExngiCEhE+vlM7nGY1u/j4Oh586R4nKHM+Q3XKK0zci/RHRVkiUJaSZJtlsUzilULHBlzrzfp+SkCGFQXoJKdiiF8+RB/S5yO4UZDmBzA2+4fzQkVc010Rcuow6NK6cjCw4ODs0q+wnxnTm0s0yx76GN3WfGSAokWmrEIEfuJUTSkGQZSI10NK6j8XxNGIBSGi0KHAmN6DblXoesGuCKFEckuCJlIbtFbdDDWTmFN2d1R8X+DuaghzEG2Woiiozi2nVMkmIKjVhYQMy1v+2cqxP8YHBCcE5wgh8haK3Z70ckWY7vOriO4NrmAcXFh6hv71Hf3sCbjJCFpnAcJJB5toR07pUXuPXEs4xacwSegxCCvNCEtdl08/shy9pMHmsy2eox6edk0oea9XeZepbczxMFbECu1+0qfZrNKQr7+zQwR5FPPkgpDvYpqnWSwmNS+BRGkOeGPE3IpcfEr2CKApFnxMYwNiWku4BxPOS4IFA5VS9Av76OSBNUUGcxHOPplGySsKeXSEtNjBEkY9AIokgyGslDgbRHEI4RwyEZDokoAwJjUkxRgEgwIiR3HbJkiOs3EFJSChoIYBJ1CIMmnldFIEFIirfsEUGuUwyGTPq4Rh9mdoA8hvEdpIm4XpmjUG2yid3HUs4MFGu1WfZmmtU5Pg5gOvogDBQX/B0anWvEiWQ0yXm98hyRKhM5dTLhHpZeJPkgwJSrOEWGF2mU1ITESNfgqgIpoOSkpNqlMBKjPUwi6W+DrM8mVruH89KinQPSG9fIooworNMXC2S5JF0vyLcGFPMlchlak8vimElgphB5EykUUhs8WdDyR/jSmvf5IkYe7LHbvEzXLxHqAtctQBZIp0CqAuUYpBQYbSgM6EsB7Ze3cPsRcaVK4bioPEMLSeK6JFkBgxFepYRsNSl29+wwzWYTfWfDtmFLhSyFyNUVZLmEKYVHc67k8qk/12Wi9xInBOcEJ/gRwcb+gDfXOwyjFGMMQggEEHgOC2dXWR9/iIt//Ae4aULhWAvfYXmOuFEj9z2qvQ4LN69yo9kmSnNKnoPrfPsLs+tCvSGpN1r3vX+qhZgSnXuzQHn+Vm+c6diJaQaleGSB7Jv7iMltRKVE6ofEqSQ76FLkmmx+hUkREyWQIikQFDhk2sUYB6FCstBnuBdR5GcQSuEmOSUnpeoK3KpDfbBPNuzjKBgWFWJ8cumTFQFxbMgyTZFLwsIAMVIJciNBhuAIm2lBg/BwfZc0n+B7FaR08b0Kk0EP36sSeBXibMzdvm92P2s0Rms89zBjIByU0ZD2cIsY7XgM3UUKpwaxscEbheNoQrdAoEkjSZIrlJJHZZ5pZmdhwY5CyHPo9yXbe5e5utMgSTPSkkehJQjwdIwyBUYIpMjxsglOFKNCHyeUuK5BORMcmSAdS8Ai7eEIjSNydJYzET4mc9GDWckxyyBLNemeJkvOgeNhJjDdGUJpZJai9id4iz7lsjwSofs+qDRDvn4LP1RUSgV1d0TNjQlUiivs5O5ef59hc4F6WVNojcCWXcEORtUGdDHr0x615rj1xLMs3nyTykEHWQzRymF/5Syj1hzLkz5iv4czGCA8F/nMs2RGknX6JPs5ubeEbrRwFuZYqBWH569AtpvojQ3MfuekbPQe4YTgnOAEPwLY2B/wzevbZLnGdxVKCuKsYJJkJHlBoTW5kKRhif1KFS2V9WhxzgICNOyXVnB6Kcm6Ii2ViR3B7ZuKXX827uH4bSoEdt1Z19P9IOVMVPogTJ1ap7fjwxd9H1huof1HjsZV+MUBpQIiUrKFU+QqptzboEOLsnIohKLIDVmuyNw6utYmLyDLNRoHtCRHMMk9OnEVjUEVCa6OKAlD6Gt8E5GmMVEa0SskuVEoJyQVPgIweQymAGJbQpIONmtlg6nnhhR5gqN8HCck9OsURY6jPKQRGKOPnGctDBIQyj3S0OR5SpzHFFmMHzRx3NC+vjEIIdE6phJ6pFHBONYocnwyGh4QVHBLPqdOzeaSHRzY7rWp3kmICvgSk46gyBGHGRsB+CImJMIrEtxsQqFdTPMMVH2rqfLbpKMMHZTQRlCgKLSkMAKdaYzjIXZnro1CHN6KApFl+I7AcWIcUdDwJ3gyJ1AZZd2nknRpf+xj1M62j2ZYARgdkuot6/lSe6vnS77XYdBoE1WqOFKSF/qIPBUaTCHRWmC0xGiBPvw5kWfZPncWbyFCFZkdhRLYFrvtOYdakbJSDwnK4VF7ub55myx6AdFqWkEvgjmzjRTm6MQ13QNMFL/td/cE3z+cEJwTnOCHHFpr3lzbQ3W61ERB7noMwippUdgMSaHpjROqSYLUBZPq4UAoI6iYATkuBQ7aUcikwNEZmQCtDXGaE3jeUcnofqZ8D8JxwjOd4H0vSZrepuMfpvOt3voZIY7bTK40mWz1mQxy9HCE+ubLUC8wW9fQ2ZhSmBKJEgk+qeOQ5dYNuEgl1OrkgwOMH5Abh0Q7TIqA3NiwnhKQSJ+RUYhEAhpXaHQ2RuUJBB6QgpKQa5DBoXbG2AGgJgfhoIVECoFCgCPtfUC91CJORmg0rmtnW013kcFY0mRs67cxGdpAlkV4XokgqGOMtlkvAUWe4Do+FIIsigjJkEJilKIkUoJ0TNRPmWRtXu97RyUeIe6eCSUlKOVZAz2dIh2DKTSJCjFGMqSFVhIcgZYKUdQRt+XhNp/CmCEmMpbcCYEwGqFzlDR4DR+vIo+O8XRkgR8Ncb/xdfy5KlJaDc1p7hDoCcJ1ML6H2d7BD55GBW20npXZ8lySPPQR4i1DejtF1xrkToBOC/RwROE+ws3GWfpbJcBQGDvk6p3a2SZh+S3ncFoUxGEIcy2CqndE7qWsY96McEoGt+ThyGJGbgCSBOG6iPBtrLlP8H3FCcE5wQl+yNF5/QbNP/kTqr0OssjJhKTaaLN17jKj1tzR43LXQysHJ8/IPR8pDBXRO7rfyRM8ETFsnUbVFFKADgWnVheol+1F+q5Sw31ux4Pn8aAy1dZ8NwTJBkpJsNSkugqyJzFv7uFkuzC4TuaXicWQAXXWOYMyKSEFMhCQDxF1h3T/gNwpoaVHZhRREZFkiig2FMKhMDYHUhy2YudGY0QF3Gn7NkCBERJ0AVhCgnAwGHJdIITGkS6291uBMPaxAgJpSDgUyBwyHGM0BkNRpCjlo7X1EZLSwQkbh69jMAAmR+uCoihQMsIBS2wclxxJUUgiU8fQhMLA0CB8mym6dwDrdOhojsRQRSgfiUZIjdAFGf4h7bKpF+lIHMdFqUNCWndxmwHhYJsw6uDrCSUnI5iv4ly5BE3/SD9TFMd0QkNF7kl0VoBOoNthbRJbHigNuBoZnsHdriHup91Si+infuzY8Nm+FbYvLDBZOc1oYjBFgZISCRRGgzj8XNIgD38KqZGHP9/Ol08JCHyXS5caVI9lIc1Cg/TVms0mVe7jINw5QJ0/h5hrv6Pz/QTfe7wvCM6/+Tf/ht/4jd9ge3ubD3zgA/yrf/Wv+PCHP/zAx//n//yf+cf/+B9z69YtLl++zD//5/+cn/7pn/4BbvEJTvD+QHFnA/GHn6ayu0/RaDCWDiJNqO5t4w/7R6JhgKhaZ9RsU9vbYdS81+/dEIyG9OeXiKp1G9YETJKcN+90uHK6Tb0cHLX6fifTn8EGuntJ0XHC9O0IUnw822+a5LXH0Gt3KMRlpFMCBCkuuVGQpRD6mCBEjIc4noNshOQHfXS1joek7ERoMrLhgEwGpH4FHVYZZCUyrUi1INFToa/DtI27UGDQxzbSaleEVDhoW7o6HjWlshod5eEZzTAZ43vVYyUqc5QNUurunVvoHKO11VQJkMLBUXYHGeUQSYdY29ZnmO00dUiMRG4O26Jn4uPpz+m2y9BBjkY4RYKrclyZExQjgmyILzO8UOIuziMfecRqWLQ9D1y3hJLncJI5nCLFLbnIevXos99XW9uqItt19NoddBxBXiB8FyEVFAVmMACjEXl6NDhzmjU5+v18G/XhJvJg5vlCu8Vrax3mdnvEaYExGsdR5EVBln/nE4kKA6M44+vXtvjAxVNHZP/95CD8gxz6+8OE95zg/Kf/9J/45Cc/yW//9m/z3HPP8Vu/9Vt84hOf4I033mBhYeEtj//iF7/I3/ybf5NPfepT/OzP/iy/8zu/w8/93M/x4osv8vjjj78Hn+AEJ3hvYLQm/8rXUJMJk/b8UWeI8QNGyqV8YEXDo2b7SACxc/4K4WhA5aBzV8dIMBqShiG75y8fER8pJHO1gFGUs7E3pFby71qlfieYEqS3G6j5dshSTbbTJR0l5E5A9vQ5Jt07JN0xeepgPA9PR5xKroPrIVuLIHcp3BjmFFl1ieSlHtlonzysYpSDIcUphpRkjC67FI6k6iREhcskFRzEKRiPSJUABUgUktyIQ73KIbk5zHRMBcPTzIslRYcEpiiQxQSKnKIIkFIxzfRIoe7R5GhAoKSDEeZw3x8em2ln1bF3mmp45GEDvf2pEY5EOuqQkLx1PIDVuLiI3Qzx6is4owFKahxpcD2Bch1Eo456YgnZvl/QlAgxmwk0LUfel5g4oJTEhCtE/+4PyLt9q2EREie3QiwRehBWcXa+hPf8281PknBMvDuKUgZRQrMacjCMiBJDnhcU+nszbnG7O0HrLZ6+PCM57wcH4XtntIlDN+n3wofn/Yb3fNjmc889x4c+9CH+9b/+14DVE6yurvIrv/Ir/IN/8A/e8vhf+IVfYDwe83u/93tHf/vIRz7CU089xW//9m+/o/c8GbZ5gh8F6N09kv/0X6BSYW2QMkk1Q11Do9DaoLIUN024/djTJJXq0fNK/R7tjduEwx6yKDBKMa426K6cYVJvAgYpwHcdFpplq0PINZdX2pSDt/eb/3b857u5X29vk7/0Cnp7x5qiSIlcnEeeP0f++S+id3cRh6OkRbWCWpyHcgW9vYNaPY3zUz9pZxVt7JC89DrpXo88M+TKJx+n5MJBLizYKd5GkmtFpiW7t3fYKxRpo0UtiVG5RuMxLDxGOmAkQ4z0UcrBdXzcu8jHlJQcS01lfRKjiNMI5XjooqBUaiKEQGvbwjwjSffC2H9aAxpPgqsESmo8UeDLlEBl+CrF0zFuEeNduYSq2hELx7nCvVd+IUAOe3DrJmJwgDI5yndw2nW8y+dx5lr3z8h8BzD9Ptmn/wgTx5g0Ba25qK8iaxXUilVFv9sJ2L1RzKu3dqmUPLKsoDOMGEcpaa6//ZPfAQTgOpIrp9s8dm7h7pLUe5RBmbpJ6+EI2W5B4D9w+OePCn5ohm2macoLL7zAr/3arx39TUrJT/3UT/GlL33pvs/50pe+xCc/+cm7/vaJT3yC3/3d333g+yRJQnKs+D8YDL67DT/BCd4HmI5gkGFAWyhG+xmjwn7hjTEIWcLXQ4pIkjmzoNv35+mfn8OLJkcdI2l4OJTpsATkSEgLxWiocB1JlOR0u4bE15jBEJOmCO9wYOG3GSz4vYDudCi+9jKm10fnEpN4UBSInW3E9SHysecw4SZmEiGqFaiUEVmO2RghwhXU6tPI/cPt9Bfh2XnMYIhMU3zPw8tSihe+gT7YxtSqKOmhCoMcJbSaPpvDnGp3B8cpkbhlEuOSagiUQYmCgU4p0EjAdfRRR9Usg8MhozBgHPI8pXNwC9ev0KytoHWOkIfzp/ICEEip0DpHGwOmIM0mJNmQJBlT6BSB5mNn5ymbAln2bW5JaKQwNnMzHCLLIdKkyNhAKUTr4wxHQxRh8hzhONa7pdyAxz4Ak4j08O+UQsgkbH17gnoc066p479Pb6avKeQccqmCzFM8k7DmnQHft8/JNSbq4l4zqOHdr3P85/Hfo1TR7/pEA4kxiklsiGJlCc70ecdKeHf36Zv7fzZxeN/hfzMpWNtIafgZ5dA79v4S4c/DYXVRjO6/vffb7m/380H3Ga3JvvwCxWCMOr18dKcohchw+cSHh/eY4Ozv71MUBYuLi3f9fXFxkddff/2+z9ne3r7v47en1qP3wac+9Sl+/dd//bvf4BOc4D3Ag1aHIgwQngtxQrUUcqYFqrtJWthuGydN8ERMv3EGWZvqR46/MIBrgzKTo0u/IwBpnYzn5iRSCkp5wRl3G++Vl9Gb25gsQ7gucvkU6oNPoZaX77/tb5Mffie5Y2MOL+Tf/CpF/030ZIxOC/KwTBaUyDJBOuhSvPIq5sMfJd3rk3ZHZB1BKipk5TOY+QX0XhWzOzON01qidf1unU/pY+TxkKKT2QwODoUTkDsheZiy72kKI2fzonxbEAIoIfi2eQJhQKcYUTCM9imV5ykHDaRySbIJvlvGmAKDQR7OqZJSHR41Rej4tpuqrNEmBzQdVWKUR6hhZv1iVEZAjBuPkVmOa8bwxus4jsZtVvDOr+LMNRH9LubGNWS3g8hzcBSy3UJeuYxst4Hygz/H2x6wd0aAjSvJ3CGCHFH2AQeDY/mfAZNkGOkhlW/thd4RHFwCDvoRSZqTFcYeZ/O9C+4CGBSKnV0ov8fNUaY/JLvpIMLHESPLrJQsuFDZPfHhOcR7rsH5QeDXfu3X7sr6DAYDVldX38MtOsEJ3hnerr4ul0/Zyc03byPDZWoVH8+V7ByMmcQp4fiA/vwSaaN62L76zqrR00cZAcNkgqsUK+mYype/gjlKhddsKnztGvJg+65U+NSROM80xV6XbJyiPR9da5LnUHT7ZJMU7fgUlRrmMAAddzK+69afEN+qk+ePoynIqyUGomE30gMaGpNlyDcV8syTGC9D5xotFLl0KcaSYjAzFLQE5603Y0pAANLMJqdrgUkMBs/Kb4Cj8tExG+IpdVS8HQQIyWBywCTqsTj/ML5XQesCJRV5keI6x3U5x7U8x46PNIALAqLUIREuUCAzjcg0Eo0s2kjXIJEoAzLTsJWjdnL82gBnNMTXNfygjh8a3CLG2RrhdK/iPSFx55pH/kbT2/30NMd/1xsbZF/+KvrGTUycIAIfeeE87nMfekuZxOgq6UZGcfMacu4+HUj9TdSFc3gfqr7jBKExgqUVny9+axcTpfi27Yxci7v34F3/EZZUveV+cfd/jz3A81wa7ZSFhjc7T47df+/fHvTzu31sMYpJ9QhR8kEkgKDujmdPOPHheW8JztzcHEopdnZ27vr7zs4OS0tL933O0tLSu3o8gO/7+N9p28cJTvAe4d76ujisr0/n3Lg//Ym3dHH4vk/LBW/3gNE9ouHjsJkRYW9GHv4Ux/4mwAjivoMjJJXNA+L+PLL9EBQCDlPwRe0C+X4f8/vbiKdPobW05KbbI1vbJO+PKHIQSiK8DQB0YjUXSImsVRDLy8i3qaWbcUEeGzuSybOubwYYUwYkRhiMgiJyYacAJzjqxrprbpa5u0vr+H0w1afIo/vAVnEkBYbi0P4O9GHZSVNYFiimtGZajnq7Oo5AqIBW/SxCKowxKGXLh0pZd2nriTON6vrI9M8Y0EbbLM9hh5BtvbbGjnD4AXNbdtRIhIG0OHS1Fla7M+ppJE2kbCFig0zstgvAjHLEVxWqoZFSHrXn+/7Mq8jz7N+m5SbHATnqwTffRPZylF7EIUcONHKvj7z+Is7HA2S7fUSKHEciL30EtlPkWh+vVcEJHJx0gul+Zx1IQoCjrIGikgKEoSiwLeEPfNYDSL8xhMM+TpaSux5RtX70PXIDQXfcZ67lHImN3wtoV5KEHYRIEaX7zFI58eF5bwmO53k888wzfOYzn+Hnfu7nACsy/sxnPsMv//Iv3/c5zz//PJ/5zGf41V/91aO//eEf/iHPP//8D2CLT3CCHwymHVJ6OEKeXkYjGWYhhaqTzy2S7XTgj28iPvpRsif+Otkb1zCdLnmaEeUeydx5+ksr7OkA9r+zbRBAEDgESUSx34VmDRBoA9tRc/ZAv4LZT3G3IlS1jBj1Ma+/gZPE+OUA6UnEcAB3NpGmwFlZQtYqFKkmHfbQtzrIxx6FWvOIdOT5bDJ2mrik1MgooUVAgSLFIyagQGIQGAkGB5EIpJ5xuiOiYmZuzMdjZp7fTXKmJGg6mBLAFAYT5RhAIzEoSweUtD3ER9mWQ5Jxj4XfbG8CQhL4VdI8pSgSPCc8etS0Cys7NPGbOh3PshsFxhTW00bY0pWU4ogw2G0FnWuUMDjKppg8meFIjUOBzGPMaEhRapCrkAyFIwoKoyiMREiJKXJrnOdIlJodj8nkbqPA2b7V0M1hcgHhXsCR1k3ZMQlOHuHtRXhf3MB7qnlXucpxFpHn/gpy/Ray00XpDKUqeO0rdlDrqA2HSoV7OfqDskj7g5Q0g9BTpMXhyVTob18+PIZKd//Y2IYcrRxGzTY7568QtedoVkKSrPiedRZ+x2g1EY06+uYa4vQyolw62pYTHx6L97xE9clPfpK/9bf+Fs8++ywf/vCH+a3f+i3G4zF/5+/8HQB+8Rd/kZWVFT71qU8B8Pf//t/nx3/8x/mX//Jf8jM/8zP8x//4H/na177Gv//3//69/BgnOMH3FGa/g97YtJkbIRhlAXvxzObXlB3MzgB3f4hozuE810L3B+zvHDAswGvWELlG9Cd3va4Q5sjwzP5u7v5daJQ0GGnwHMm5pTr+To/Gy69Rr53D8+0YgYqTUBhp3Vt1ht7v4Jw6jZkLSf7kJbJ8D72wABRk2pBEY2KnSiwCsnGDTM1bUz1HUIxSzEsxel4fZYCOZ1yMDtDOMsgRtkXb5k98ErSRaG1FvUIUuJUSbomjwGzMbCr5vRkbsEHxeIZk6g/jHmqy7cBPSYZ3mLkBDqeYg7Q1qcKSH2M48rI5MgA8Ij+25Rsk0gkxeYrjhIdt4Xd3WbmOT16kaJPjKB8pnMNjp3CUOszgFCjlIKU80hUJAcpoPBLbim0EBZKscCi0xnFyfJkiixGFU0J5NvA3xABlMhACrTzMeIw6+xBU60e+RdOp3ml6dyZMSpA6g6iLNAXicGaHMjkSTaZCMuMy7hnkRoI8nNo6I0l1VOMJVCXBMTmOL3EqIWoikQ+orBxvQ7dt57Of/Yli2CkzUYIs10c0c9pJdS8Xudf8rzLssPjGawTRkKhcQTsSt8io7e1QHg/ZfvY5wuUWQkB/EjOOMyqHYuMfJI5K15tb6J0d2NqEVht5dhXpuT9wH573K95zgvMLv/AL7O3t8U/+yT9he3ubp556it///d8/EhKvra0hjx2gj370o/zO7/wO/+gf/SP+4T/8h1y+fJnf/d3fPfHAOcGPFKYdUiKwpdWKipCMEXmG4wpk3UHGWwRLT6DO1gHJKCrRvzmk7ipclbPVHVBx3oV18BRaYHKFNi79noMTtxipC+z1Wrilkh0hoB0yrciNIksKsqKF2qzCZkS2ESL8S4jIxQDdSYDJQggkAkGWQhKVrPmdERgVQJTjxBkq8I+s/afZgqKQ1o7/TheRxihXIoXBNRkyjymUR6rKJEGLXDqkY40sCqQokEqA4+I48shRVwhbcnFdjSpSTKFBKITvkmaSwQAGgxlpEEIiHIXI80MaIg7LSFOHYUOh7ZiGuzM295Kc6b0Cx/Vx1bHAaAQI0NpmaJRykVqS5QnoCCEUrhcgkIgjv5xD+fFhhUxrKIxE4+PkGnXoHOyKHE9lZMYhyhvkXhmRB4gcKrpLlAzwdYSUAk8VlHxDeRGCBfvaeW7nWGWZJXz3DkYttg/Ik1sUfolCeOjCMD+6iZtHGCHRSDIURV5FzP3/2fuzGFuz9CwXfcb4+3/2XfRrxepXZlZmVmZWZla53FSVy2BvN2zYHG+QN0fHNxY33CAuQAIugAuE5AskLmiEhA4CjrZA3sBm27grXLbLuJrsm5Wrb6KP2bd//49zMWLGXGvlysqmsqoyy/FKUxEx54w5/3aMd3zf+73fOb276r5tziR57mm9VQ5J+FAH8YfwcMrMNPVPgCSySEKHID1KTyEQQpDlOUopeIDU51qsPyf4KOw7A0ZxjcPyaeb6HCHBrEmcyYjsnZCO76KkIIxSnASK3rsjSvO/DZljDLvIKET6H0/5+AOp6+VlRK1Gfm+LvNsjHwzg9CmMixd+YD48n2T80AkOwN/4G3/jPVNSf/AHf/Cu5375l3+ZX/7lX/4+b9UJTvDDw/0VUipNUDt7uKOxtvyXhn69VHwgv55mufa/MSRxmh25uYLKJXl23yOVulxYHWlKcuCo8WCeC0QuMcIYM4ekIFB2Hdu9TGEQYFDWqZT5dgqFMevjN8rYSx70+8QMUaJIGscgJWWZkGcDHJnjEGAkM4bmJXLHJVcGcSpJggRhVTBcC+IYM9areavsYlqSNPWZUGW63WWa2iAFAoVlFTGNDGW6GOUSKktgPCGPdZRDyoRSAayVOnjF4+hQNp1h9A6JJgmDvMoMT5MX0zw2xRNi0UQ0SYyjGIwC0qOan5QEm9QwmfebSlWGeRzFmZMccfx3DgghMISpm2UqhZzrY5S2yYjTENPQTtO26RKnIYqc4XAby7Dw/CbGkddOHOvt8zw9yUspyMc5cSaJc92JPBNSpwZlgsoFlpXh5G1IclJlcGhukGJqzU6aUoqm1LcEfjg/x/rzfR+qVSgW9cO29fePXxnR+fYdQrtFnNrks5Bi0tcpPCE0W4ljjN1XMR+rIBuN42M7NxuUUhOn6VSnwqZT3XR1TqYerribC9Kn04UYXZMlk2xaYBalRyk+gTRAypRcZhhGjpAZ0jxq0yAW1fvmLEROE0ZOk1RprVdNdhGmRaYg8zwKswlBMCXy/CNXaXHcK+v+BrGgrQ2O20mk2SMq1d5dCv5+Qm4pHkxdCyEQvoeolJHTKfnOHnJ1Fesv/DzS/ERM7z9UnByBE5zgEwjRbCDX10jffgfGuuwWzyMzbeJEEvcC0tyGeznZRK+uw9igs+8xNCVJCr1BiShWZLk87p48JzWPMnkDcKIJlf4BXjjGI8Y2JUnBw1xvUjyckfe74DlguyAFxmSEVbAwn3wMWZFk/TH2cIesm5MIl8AoglUhUg5TPEBgWBG2tDEBW8a4MkGZMdhVgv1DZpOcWW6CAMOxEI0qVsGHShPb8OFwQBKnKASZsMGzcOpFfC/F3L6DkQTEfhklTUSekE1T2JphnV1HmSUOdyJGvZyMJiCP3X8lITJVeJ6NclxmM3ncGkIIsB0Dy8zxHcFoYhIlNrnS5CXLYqQ0USonMyRGli1CK6B9hZUOCSmVHZ+DxfwmgRQwkcJgFvTw3To5GbbpkCUzGoU6RjrBnN3BK/pMWSYB7fkym0emJJWSgz/qQZ6RGy5BbjNIiygUJhluwcAaBjjRENMp4KojlpSm5IZBarq074Xk4yJpJhFCN8qsVjUhmcM0NelxrBbSdalP71FMB/izDqYtyHODSHiEsUFglUjIyK/fQNZrKORxZGg8fvBalBLKZf1wHP2d88c8dRjHMJnox5wU6S70gkLJ4rAfMwkTbZwoYB6NyVKDLDU0oUcc3xMqF1ixgxJnUdLCJMUkBnq4TChaESUvwR906Vc26ZYb1Esej2+aD+i95pV60dYewWvfIJlEZJU6qVUkjXLSwzaMx4jnn0PUG++qknq/hrZqOCa5ZSG8pxBjHd1d83sUzAhRLCJOraOGA+j1H3B5/rOKE4JzghP8kKDUIuw/XwEu9CKSbOmLJN+ZkAdTRKlAbljEuUmSQVp1yJwi+TcHGI+10BOkSTDyGSQphhTEkU6dCJkjjQxhL7Q3iyi51uQYAuzRiKWDGxhxQl4oYjgOKknwR13caIRpW+SzLqoXopAkXpnpylnC05cJu2Wyu1PUVoiU5zGMCMMxkSpHxCF+OoFsBFKS+GUywyHOpTYknGQop0q2NUalGdK2sKUgSSVxmKH2hrAMZtHFcQXFzSIWCYZtaL2B6+lI1Y0bZEmIKpdxhEISM0ssulaDSWiRvSNRboaIMgQ5tpTYMsJWEV42JEgsphTpD2yUkSINiW2bWBbUapoDdDqS7tA51vNoDU+CaVqkaYxhumRZTC5NRJ4iMI44pRYMK5USJzNM492VLQqFUDmmYWMbDt3BbWrl0yAzHMuFdEpm+ijbpenEVLMdhJQcGOsEidZGhWFOGJqYoknZmFDMRxQZYhgZM7tG7JQJE4NDcw28VSxi/GxEmQEbziHFik0ibbqzIROvjLIXTVZ7vUWZPegoTqkEjl0hW3qGbHcXoRLsSoJHgJNNWQ7uUksOaCxJ5EYA45exa2e0mDkISS2X0G8QxZIgWPQam0/8Yagf/f677595FVexCK3WIhpkGBbDqcuN7Rk7vTFZliNyA0vYBIGkP8zJEpM8Ncgz47gM3BAxRTHEMlwc3yXLLfrxKXopGEogwwyRJ4yurWJKwciT7L0xwyh5+L7E8zQR9L0c+7VXKc32sTZXEGIGzKAIqq7It29j7AfYX3h0G4o5UZr3aZs/kgTiYUSeJSin/GjzwpPS8AdwQnBO8InEp7F53FEk/l2EJTkyKvuwTVGEZSMKBaQhIY4ZZFUQAqsg8SoFLAOM2S2c4gqiUkEIQb1lsd/XDSSLecwsjMjUkeFZKvXqFXHftghErgf56v4BRpKRlGtIQ1cq5U6VmWGRdkYow0A0z2CoDJlEiCSG2MQACn5OtrVFno4Q9QJmf0Iap2SmS+YUUdmMNJMkskBu1iGVut1AGJIJjzS1EVmKVzBxjRhJirKFLjeejJCjNkQW1qRPnioy08Es+xgb62SmJJ9MSYYjUrvIOC4yy2zGsYcSc0FwjlApnhlTCvexXAPfTonCjP2gSo9VMmkhVIqRx9jZGN+IWF5xGVlLdLt6op0TG8PQk9lsxpE7cIJpOqRZhBQWaRphCAPD1Loj3SHcPKpICnVDTcFRRE2nsSwECO1i7DkFPOp0eldo1i9qZ2TDReYzHMulk/pUbYtCMuBccQd14TQ7WynTsSI96pPVy0r0KeCZilpdUGmY+AWJHfY5eLPNxCqT5CZTo8FUNOkYZ/GihLo1opB1ObM0pbzpUqtpTdLdu5po3F+ZNhhAmkpS7zKiVKIw2qGYDomkA7LKyK9Sq84w19YpixxvcJXC//PbiNn02NfJXV+j+OLzGJvv1ovMoxpBsHjcX/mmlI7gTKcP/6dLgVWW7CqDSUAmYmw7p1RWtJZzeuMxcZIdUwNDCupFh89e2cE/2CNbOkWUO/RCk87MZBKbZJOEwK1Q7rVx4hCRKxIpycpFkrU1xkdWB2oakN5sIZx1xKEOORXMkIoV6HPuNZB3JhTfHOIs196lJ5Jy8ffDyG1B9K1dhDn+oZWGf5rG5hOCc4JPHD4JzeO+e3Rl8Z4P6tw6xzycff8gdv8ANxfXAmR3R0TuPcS5FUQoCaIBofRxCgaOEZBlOcHekNwJiL0KYQi+Y7NcLdMdBoSRJAkNkkynRI4LmRVIAb5rcapVxrYkajjCuBEjllsYrsVhUCbFRAqBHHexRITCwJQpWBZOQRv5eoMtnNEMufE4wewWablEaFlMWKY7tSBJIVVg6/JuUShjkGDP+rjRAE8FuFaC3e9gFj2k3WJotMgRODIhRzCLQO7fwSnY5JU6gV9EJSlRd0I23iJcMZnMBLNkg1w5KIROHQmBJVIazpiaNSKY5vi1OslsRFut0p64BLlJhsJUGV7WwyKlEe9QsGIOsyXu3POJ3YRUWcfnzfP0z3m0QUqBYUjSLNPtFZIZngRM70ibo7SRn8qJkylCGJrcSUAo8jzR/auEhDQEw9ZnyvJZKTUpzK4z9E6BWQCnhG/OyIBJ6jHDZnmyj9055Ox0hxhJx1hnlBWIdWE4s1QQtiWHfUnZjyiFAaXpPivqHVyZcOCfYWisEEuXILXZjhuQ17Cvlal0dfTK96HRgM1N/bNQgK0tuH1bk5zcc8iNKlkyopcVybDIpIW0DEZ+xLI5I+u06Q0KCIrI+ilExcJKAwo39ygf/j6FX/zqu+5vIRbNQWs1Hol5l/n7SZAmP4Jqwada8AjjlCxXGELg2iYtK6czDJjFCaaUrLVcGjUbs1gg/4PfwdjbptioUSw4nDIi0naXvKg1NwYgVxsP9H1ShyWSz/wsYXmN8a0pQ9EhcJeJj8rvTTkfNECZJmkCk2HK7H0KsO4fLxwHLLOBaF7A2L6Du1HAkvnxe34QpeGfhLH5w+CE4JzgE4X3M7fjIzaPy7JHk5WPGl2BIxHh9euobg8zDbFthbtcw3vuCbzNFWz7ARnGMR5YARkuovrgCmi+ap0lPiO5SjSoktgFsNBa1eDofVGEwsOKPESw+HzfsfGXLNLcJ04D+tsHTEcTQmES2BVMw6BadFltlPAdPcLm0ykpIDwbISRVLyXLM8pZj+LkNXwjwg2HZP5TbJvnCHOTMLM5cDZRewnCjMnjJsIpQiJIbYlvGpiZrnZyjRgnHFD8wgoimpG9ugUywW6WKOZTvP510rHDOB2SrJgIz0MhGCcO6XRKntnE/jKG4RBkFsOsSmjYZEFCvhOTu0UUFhYpNWdG0xkjpSLIHEwyklgxyUsc9msEWZEs09obN5vgplPKSZu17C5jWaVtrHNoNYlwSLAQSYrhGDiOTkNEkY7cgF5xCyHJMguIyJMAV+YoswwchXuOaq9MBAm5jqipBLARCEw1LxfS5nQij1DSBukgnTLFrItId5iKFpnZYpQWWHF7BJlHnMBu3KK83acZT7EsgzPOVSKvwUBV6ccFZrlBqlzSJGMwhCE1XPczFPIhZTGhEnTYlNeRy8v0ZJPDvsPUq5OZBr2eJjBKaWJXreq0lO/rn2fPQrOp9TJJXOHW/2/M7XsGQ7uEEhIMgwCbW5MiWd8h884i3TK1dMaK2QNT0q+dp9fpIX93G/MLum9SoaA/v1h89D10P+bRtMJ7dpcQxLH1AAGKY4PlevGB+16nwVbJn/xFLQ7u9HS/M7OIXLqAFw5wxof4qzVcI9Hanvv6PnlvfofKX/xFlqQgeuk2wu88MsqiZjOUP8G6CGn1wXEpih4ck45di7P5NSfJTz9Hdgjqbqj7rlkmJKl2Gfcfx1h5DuOGfOQCyrYf6fv5gfD9Gpu/nzghOCf4xOBhc7tjA62HmseJ1VXSTL5/dOVD4kNFV7Z3SP7wEV1893aQf3jnPbv4Jvd2mP7pa8x2+wSxQWwWyOotjEsXEfWHVl2qRlo9RX7QRjT9IyM4/ZIpUpzpPv7pFu7lErnSA/dsxlGlkED2R9jXrtPq9qjHCZmQ5LUq1uWLeKvaX8d19WTlugLp72BYw+NBOVOCST9mpCx2jRWUnRLG5xkl1aPjpTDMlDxItCDYAE9NtAZZpg8OpHFEgRGNM2C99CpReptx/TQjJempGpn/BIFZZJJ65AMDKUuYIsdIQ1Q4I3QqpKpMHlkMkgJJrlNtpqmopj2aZyxqnbtk7S5DZ4McgzgVDBKfceIRxYpUuKjcxjBT/HRE0Y7Z6L5CNdgnNR3uOZc4lKtMzTIxPpIcQyVYZPgFE9OTTCb6OM+vkbkhoeMYGKZBmmQo6R2lnjI0yQGOqq88UoRhHTXRzDGEASIHdVRmLiRGHpApgRIQS5++s87y9C0cy0DaNt24RDus0TT7FJI+47zMVJYIvcdoqQMIB6xFr+M3LtFwi0xCi05YIMAnwiLHJDCKRDgMaFG06+xn61Q6I0rujM/X7qBe/AIDQ7K3p7U3SaKjJIeH+jEXHtfrcOfOnIxI7Cce43PB71GYfhujWSOxPLZGFe62iwyVi+F5SJExTRxuJqtU7YmOFNpVvPaQVn+MWa8cC4jvx/3iY8/7cBP1/B6uVB79utYvHRGgUoPZUo2sPyaPdGRWqZzJH/9Ppv5p+jMt7vXMiA2/9+6+T0cFAvMWKu9qQ3EUZTGWGphSR6c+CI49ndYbBNWnCV69QngwJJ4KMEzkyhLy4gVEvcFR9vc4yvheuP8Y3k+C7h/3pPzgY/MnrbHnCcE5wScGD5vbZUpwa7JybC2i3AbqVoD1nTHivUaq+zC/By3r0SuZ91sZvud2vsfNnroFwpUKs90Byf+4RfriKgq58Pzodsm+8zYqyBClNShYECeo/TZqOMZ84Tlko4Hj6EHP8yTWl06T/c5VZv02YWWJQBZJY0U8mpB4TYJTzyL3HyFU7HbJX3oZMxjj12w8X+IlY2TvNvL6dayLCwKWJDCWdfq1zzDdHSAa9eNScJWFZEZEGiZE5SVio6QrcWSCZ8SYyQxlB5jnHiOPcvKDQ1zbopSPKTkxhu+gpjNGnQnj5ctsvTMh+c4YshoMx2Qy5NA7jbBP4cUDfDNkFgqCqEUmPbLIIsIgsctkqoSVZ5TMgLI9o+FMKcoxaW9MnybD5gWyvqQ/EIyNOjmSIDFJj8wBCzWLYs2g6SpWdq4gRkOibMy+sc7UrNAVS4zMOkgDW4RIBa6aYCKxbY/eyCKK9HXkOPNIgP5dSnR1VWCRChdIj0iLAWQgDMxkjGkYSKVQKkcJRZYfeeSkEVg6qmTmEVIIYnR38cRwaRce46K4SmiXsWXGflihmxQpqJhNeY99tUxAmX25RtVyWQp3WJlcI1s9TUeWKYZtIhx65jJT5RNkNqmhe1iNsipTWWKoqhSloOM/Rb3nU6/DT/6kJs29HnQ6mtxMJouS7uAocmgYmjyUSk2MtZ+neHgDp72Po0Kazi5n1yX53i7GhXMkymQraLA7a5AriU2KMiAKTPb2QR6lmKRclKRLqRcvg4F+3H+P27YmPaXSo3UrHwTzUvhFlZgEFmNMdneLKbeJK6eIVEKY2VTtR/d9klK+q4UKjgNR9D0Z8M39mxwHSp9ZRj3e+q5amLkD9cMRovdaCH63Cq4HqrcmDpbMOO0fIgWf6MaeJwTnBJ8YPGxuJ+AB3zRhm4hpgitCvGrlkb1xfiDbeR8RA8H10eqDr/tF1MEYa3A/EctR16/jRAP8tTKuMcM1YiyZkzZgunVAfMckWfkSUaTLk/VAvkb+1C8u/DSyMRgGcnkJ4/IF7OUGvs/xw7I0AYv/8x+TJXeRZ9YQQo9akVFg2Koz3puS/t425udX79MLSfJzT0DvFWbtKZFfJzcsnBwsZWDmIXbNRjoj/XahezQVBjtUzzYov1ghtWzi//gdgnsRI3uJA6OKymaQ5QjTQeQ91M0dmM3wyyYVc0yYGvSCGqEsEMkGeSYIhE8SeSTSwYxzXJlTcSZUShPKdkDNmjBOPXaDOuPYQCmfILDpBR5G5TKTTkiYaPbqElL1YOmMy9pF52gCKxM2n6X36i0GgzFdc4mh1QTAUTNybFwVIvOUqtTk6XBgk+ULHcjkqDTf8/Tk7roQTxWp6ev9zQIwTJSKmTsZe3lIIor6WlA5KF29hgIjn5DhoKSBkCaGyrCyKYn0SYWNaWZs5+d5Itumby0h4oCDuMbUqHDLqPDs7OvsyjP0xRJjUeFN9/Oshvc4HYectYaMjJh2Vscv2iT5mGHiEeY208QlPPLAibDIsJgMLcYJHBzA9rYmDmtr8MUvarFxpwPDIbTbi+jOvMqq3wfDKGP5z1CphTgy4dAzKBVSjP6f4A5MmuWY88U254vt43smmkTsZx7d0uMEx5qSB8vI5xN8sbiIeszTue22fswhhL4fyuUPluZ6Xzg2poqxejsUSwXw/QciMw+Le42Ndfj5n13oVXp9hGVhnD3zsRnwCSm/K5mY++rMS+s/COYRyXcVSySxPsm2BQqS7KED+gmt3johOCf4xOB+czt8DykUF8t7x6+r2QzlTXDOSOTSD2877ydiQkDVnjJOPa0zkQmOE2KHW/jHLsOQH3aJxq8glkoId0KcG9yZLC8+06+jdgOs9oIUzdsGlM408B6r4QU9rDR4X0fUhyNh3ahILyotXi86qE6XuDshcsrk+ZE7bLWB+fyzFK5dx+seQqi9XOTmOt6sTTG6S6nkIF37eDWqKiVmn3mWG9/uEf5pF+U9TW4lqFmgl/h5hmkZVNc9KoOrBIOjaEt2invWBQLLJTB9olSQmL52k43HVNMOBSehum5RSrqUx9u0rcvsB3UOA318ZqlFZ1rC9SRx4DAeQ5Z5uFWHmpFQL8Zsbjh4S6XjY5Wmmpx0Dy0OpysMC5uoNMVSIbkwsbMYKxtjypwqA7ascwSiipSSU+sL75U01SkapTQBSBKYBCaQYRsxqIxYmZhZSGqWsbIQOxuTWgVMkZMhyI78cAQKR0CkMjJhY5g2HhPyXDJVksxySSgQpBk7WKMD7wAA109JREFUQZ1N6x5SVbCzIbvOeRJh8B3/S/zC8N/SLV7gmrjMiDK3jYtMxjM21W2qLZcLkz3GZk6HBraRIVAEuU2YmvTCArPMJskdsqO5LAj0vvb7OnJz+7YmDefOwQsv6NN7cKB/9nrQ7cJolJOGKSrM2B+bWJ6LGUicaU7RPY/oDtnPbcpmiGnkuEZM3Rrh9nfYPHuGi18tHHPuOIbdXdjbWwiHH067POzRsxAYP7q66qOkubLtHdJvfpv8sI0ajbXfTLmEsb6KKJffU9xrbKwj11Y/NRVHsDAW9P0Hn89LEL2yjbgvhf0APqGNPU8Izgk+MfiguesfdvO4h4lYyx3RYnT8uprNULbxwM3+cHQqOTKyA7SA1wpwwi0qyyPMM49Kv0mg+YG27+HvUkCYWyi0+69tautXU0XYC96jw/1rDUqXahTjLla6GJTz3T2Sb36HyXafQccmkA1E/RLy0gWkqJG+/S0dnl9fpWzOKF1/CSc8YFZt0U8q9IcWnfg0WcthPJHs55vEqoYSElPEFI0xTtqh4sSUNn2WvnieYsXk9o7DvVurZIMaHOQkrqKX17AJSALFVBQY5CWcmRamFotw/rykVHIQwjneN8PQEbFuF9rtnOFWRpY6GLaJYaQQ5rhpj1TarAR36Llr3PEvEFKkUJScuyTZ3tYTvlJ6gswyHdEJwyPSkwssFCWmBHYRO09JTZ88ExREeNRHSqFUjBCW7pdlCGQmdYuKNCUTWkkuEDgqxJYpbXwgJzcd+sVNyutrrBUnHLxxwKZxwG6yRJRa/E7xr/KVyf/FT3l3+bb8In1qtOMiM/NxVutl1u0rNNtXKLRyZplDOyrji5iSOcMPe2SVKr1ikcl0IXadpziiSJMF29aRkqtXdTTlM5+BCxf063tvthm+dpvRKKIblxhRJbaLUC2Qph5jcxNTHGB2Q/qui2NlyDzjIFQU/SewV56luCNpNhfOzGfO6MccjyI9D+t15t44S0uLUv4wXPTQeq80V6mkz+v9aa4HhLWbp8nvbekoRadDNp0iT22g4uQ9007vF2X5tODTMjY/jBOCc4JPDMT3KXf9sW/nR7jZHyZFBTPiYumh6JSdI/2PvgJSCqaTnMFORj/cQO36iHIJgcCVyeJ9UQqmQaVuUj2lV2sPrmQl0CJJ9ETQvwF5vg5PrKI2dEm8YZkIwBEJleltnNGrmCtFhB/THRhsp6tQOwWGydS0GcYFUmGiDB+jEFAIhlTCMQU7oiinFLMR9d41rPNnuf3YX+HN2yb5zi75aEKawTCvYKmAfJozAzo0ME2JW7apVUw2NuD8+cVEBovV/f6+Tqt0uzrdkUYZeZLimxm5FNiWQJkWhSijOXuH64XPMJYNchxaLcmlJ23efFNPlPOKnSjSAtt5SF9rFyS1uiLtG6hcUTam9LMyEoWvJijHx7cElpCEuCRK+9VgKHKrjCcGxJlLhIOtIgzbwrOhlAZMcpsMk0Q67A49nHqRVnOf7sGAUwVJOyoxjAr8fuUv8+z0D/lzo3/H67WvcLfyOcbmMlt9i4nzJOtGQvGwz+nmPo67Shgq2gMH1/XwL1XxDe0wPBjoNFQY6n2cC6vnzTYnE31rDgaaTBSyAY/d/h2WZl1Uq0FXtBhO+0xHKYNhk8nyRcZOkayxBOM+3SDDCFMcmTArnmGy0cAMysgbOlrk+/r7CgVdpTVPSb0X6dnZ0aRnfv4fdkgWQhOY1VUd7ZnNdLpt3rpjTuI6nfvvgxz72zfxh1A6tY4pQbiuvi6HI9RwhFLbmF94Eevzn8wy6Y8Ln5ax+WGcEJwTfKLwg8hdf6/4KDf7x70CShKOm0Ied3i+r/dNPhyj2h2MahWvVaBUkZSsAElOPtzFOHsG+/HKcTpAKf1Zg8GDJOHh/a6frVCa7iJf+ZNjLwySmPywQ/7YJQzfoxMUUXkfJXXUqC9bSGYYpDj5iLI5xhJ9WsaYctAmUA43jMe4Xf9fkOtPIAYm6fVbjGMHwykjbEkY+RwmLRQCv2RQL9rUlyye+IyO3IxGDwpey2Xt03L3rp605poZpcC3UzJmCMOlbAZ4Rky9OOYwKnPV/AJjVcQg4fSpnM3HfF55RX/23I8lCLQXjGHo3+f9kAoFKNVcDgIDN5kRZSYJBl4+wjcipk4JzwBDah8UledHzTElyjCpLZUY7ygybCwpsGwTmSdUVJ+AZbBtskw7/u7uSvz1c9QnrzOYdll2E3wjZG9W5xX3p5gW1vjpL2VsrDZ5+VWT4RC6QYGo8hy1YIesf5OiOuSs3cda/yz5hdP08hpmoqNStg3Ly5rkdLsLAhAeNcKUcpEK6vVy3MGU9uwJHF/SGvW4VNxhqemiGjDY2qabx/D8C4zGHoO+Q/8w1k7bjmBq24ymEjvRt1Ga6rTYPLLS7ern55GZZlP/PYdt63L1s2cXz0WRJj37+4tIz/x+Ob6exUJf1Grp/xmNFlE6NRwzOZgw9c/SmczbIjj4jxUxZgH5eAJRhPXjX8BYWaSbf1TxaRibH8YJwTnBJw6fhtz1h73ZP+oKKM/1gDseLwbeR0H1uvDydygHbSpNC6uckV+9hdqbIscF5KWLCMc+/q70mefpHejO2Y8kM/dpGwqFh8rjf/e3ye7zwlC9PuruFvnVa8wuPYNlQSQlMk/BMGjl+9hMKVoRjeldLNdgLB1ur3yVSeaTZxnMAkSjTlBoou7eQUY5oVNmGBdJcgNXRhSdFD8ZcLYY8Pj/60n6A0kcLyateRXN3btaL9LtLiqd8lynPUwTVCSxZYItU86Wu2z6B3zt4CkOgwpT5VKWU86bt3CWL/PSS3riKxb16ZpM9GToOHoSHg7159u2TokMh6CkRe10ie6BD4Gk4Au8TBEYEuPI8E0KhSVSIiRgoYTAr/m4vZRJoIhzExnFJMKmVYnIHcnBwDyufplMoFOtsvH0U9Ru3abfmUA8wol2uWte4hoXGX+jwy9e/i1azz7Pq7ur3LsHw7FPUjxPUNtgvR6QNgw2HtM6ptu39XFqt/Vxmuvjm039fQcHel9nM01C5jodQ2U4kzGdrIzoZ/TzMnsHgtPOIa1lSbVpUh2/jLN8jvB8i4MDSXTeZTrVx3BOPOaNNafThUC2Ulm0LgB9Dvv9uf+QJrKNxiKtNPeYMoOQM0WXs19YjBtz0rO3mxP2A7IkZTgxGQ093nlHHl/3c9LTtEdE3GZWOsskF4SZTaqkXpwUfKTrkO/tQ/RQl80fYXwaxub7cUJwTvCJxKchd21srCNWlsmv30QNR7qj78Xz79nF9/1IUdJcp3v4YOj8UZivZMvlI/LBUdVUfBe5OY8OVRCPP6YFkgdtRtd7jFcvk891M3ED7huX5/2WKpX3rjh5VHl8mku6hbMMlqtkvQFiT2KsuwjPQw4HNOw+pdkBstlgtHSB17e+yDQydAdkSogjEz7lVrBX1oiGMb1BgUTWKaqIohFgWDnL7oDHq9v48ZC9YYH965vHYuyVFR2dmbcSmBObeXWPZemUR57ryIPpWDTSiKcm32BfPsFv7nyOblwiU5Jld8AT+et0Cue4eqNIchTRME19XlZX9bHf3tYT5nziXV7W0Z3Dw3lTSEmiJNIEr1Ei6w4gTjCtnMSwESpDZikSm9w0dGmxCV7RJIhzYqtGqRxj2hLqNsVUMgwX+ySlJhyFQo3VL1SQt3bpvrmLRHLZ3+F6uMlutsr/+ZbHX2x/jR//hS/TaKzz1lswGkl6iQeux1BCtqWP0YUL+vPnJdmdjiYO1arez8ce00S73dZEZ3qk1ZFJRjcua5dnGSClQYc1skAyuDekulSGuMpmL6aytIi0JIn+rNFI/z4cwmiYM2jHJHGO4Uj6uY1SEnnkF+M4i9QZaDLS7x9FlHpdCrdfp9q9gZkE73LZdRzYtHdYP1w48Uamz2H1cdqtzxA51QciPWpaJ00+j+zalPyUFbdP0bhP4fwRhbWfplYHj8KnYWye44TgnOAEHxGPtC2/8s53tS03NtbJl1aZ3Osz6qVEuHqUnkh4yNjsfo+Pcvm9yz3zwwerpuLcoB1VmIlV1MZFVHkMQYD52ecw19cQUlIu64n7g5qMwburs8LMZGuqBzrREBhBQKl7i7q/j5zsQfuQnmzyneqPESZNxKAEToSUCdKxSCczpJSkhQY9d5lg38OVASU1wvVNVrwRZ4t7lMyQYVpgEBUZ5h4qHUASs7mpJ6Ib13N6uwH9viJMLFJhkWZ6UqxU9HFLEn0sCwX4zGckK1T5H//xBe7sLDGijCMz1tw2L+b/k5d4gb14k0xKWi09eQ4GsL6uT9X2tj4ec31Ksaj1OFtb+vlWa9GYslqF8pLHzNzA6A4x4oA0yZHKQpgSIWyk1NuapvpzBgNJnEmcikmW6Ql8c1O/vrNzdB0Z+u+7d/XfK71tlmWHw/o5slzylLPF26NTDFSN/3j40/zSH7/Fk391ldVVyauv5OzeTejsQViA6dRiZUX7NVWrcPnyIoqilCY6rquvwTiGS5c00en3YTrNmW1PmAkbJQyUMAjwMcnw7SKdxOSg51FwM9KDEj6apKyv6/OxtqYfeQ6dtw84vHGb9U6fceIyoczUqxOUVhAF7zgCM48mVqv6934fgvYIbtyhmKQMShcQZQuRJBRv7NJo/x7+L/wMwLuceL0w4lTnJTajq8fmnGGohcy7ux6zcpF8MGJkFhnHa1xnbX43UJzss3bKYKPW4IPSk09bq4NPO04IzglO8BHwQWzL5fr6sZjxwVSQBBpQXnze9+LS+nDVVCcsM0uPvISEwKk4lPNdmhcU5pmPvlJ8lE9RyQooWzP8ckxupySv7tG9WuG2+wxhzT2qdTcQswA7GsHaBtmZJ4kyi34PRqGF5RqUy5KKCRUr53L0Mku1lMwtsBM06EWLqjJfTVh2dxjWTN56C3pbIwa3B4TTjEwJImUjXYdSy8Or+USRnjxtW5c3P/WUnrD/89fXaBtNApFSUSM25V2es67x39M/R180wLRYXV5U3Zw+vUiPWNZC+2RZWtw89wuZp8HmeqCCtkxhNvMxV1ysyCU5nCKSHCNNgAgpM6RpMplYx4QsDPV3lMv6ECbJgmSMRjpyUijo79zfSlBtk9VygdNel61pk0wZfLZ6m7fGp5kmBX7jxjP8L68OObM04/PDV7jSc7genmEyKDJr25iRw2hUZGND7+/mpo7YjEYLojPXwhSL+nvPnoXJ4Yz+9i4D6ZDkkkCWiISDZEZbrCCsHD8e4FUctvpFzIneh7lgu1zW0S/2dij/yW9THE+QzToTs8LhOCcd7hKre4yXniE0K0dWAIuquNFIR0SMvR6NaIrRrNBLXeLQwpYpUdVn1DtE/q5mn+WBTf3UBoZxdDM+wonXdSXnzsG5c5LsTInkN/+E6TDmsHieg3yJOBLkQcjYrnG9cJ6bf7hIb5XLmrAtL787EvppbHXwaccJwTnBCT4kHpWqiXODsVFmXDtF1B4d99V5uPHm3DF17rz6PRuQ8e4KrbozoeWOsKT2WVGzGcqJPnSF1sOhdBz7ge9xjJQVb4BSsBdUuTVcJ7SXdM8sIbSOJx0gcsXYW2bqVZnky4zbJfJcR5Fa1XlpN1y8CAKPwX+qcO12+oCjctMdUTEn7N7LeKv2Bca7FQb7U+LtLlmSE8gC0pQUCCgmbaL9ApFYQxZ8Wi347Gf1iv+b39Qlzr0eKGWzesbk8dMpZ5ob/N/feIbhzEJIydraIm2ysaEJUhzrqMlotEiRrK1ponHvnv57dVWT1SxbeIoYxhFJCCNk7xCV2Ejbw5ICEQrIE9Q0JHB8ymVHmwbGOcEkY6kQESuTgwObS5d0lGU2W9j2S3mUKkoEPWo08hkXSrtsT5tU7SlPiXtcG68yiBx+82sWL4g3eZpbPL1Up5YZvDNYpTt1ObzlUlqXpKlPtar3xTQ1KXzssYXo936i4/sQqZhlcUCjWmTYixmmVQxDEQmXKUXdMkAW2KaF05fU63r7u139/7UaDAc52be2qA0N6qfWEFJQIqbUiFF1RbB1hd7AIHn+i+RKHguBj8u/w5hknHBgryOnklSZnPEPKZj62HXdNeLdBI+QuHKKYS9DZRlNd0K9kn1XJ955Wrn4re/g79xgM7mCsCzkmXWSzz7PAWX29jThVEpfL8MhXLlydG8KHUVcXcmp/ulL8ClrdfBpxwnBOcEJPiQeTtUchmWG8aLTnygWUb0u5mxE5XSVcvnBqo+PGw9XaLnGfSXhH9Gj4lGhdLG2iigWtaOyu8Z+2ODOtEWaG+RKodrbiCynlrWpGkMmZo0DZ4OpKDASdUIqlGYRlVaMV3VZWtIRlblhXrcLnY4kX38RsfcyqtvjVHOG7Ul2RyVu96sMzQaBf4GkD+lhn2lsIV0LX2aUrCkCCNIq+XRGoXuXy0+scOn5CtOZ5L/9N11KPBrpybXVgi98QWKaZf7zb5YZTTX5XFnRE+ec3BiGfvR6C21PnuvPWF3Vz8//zjKd3shzTagqlbnIOUcMBxhJiHLLgMSUgAQDicoz4lGE61hU3ZBxzyBJY4JbW0ghUF6NwAUjK9Ao2vSmFmkqqVYhGEt281WqyRaBqfOYn63dYWvWomZPuezd5W5aZ3+2zDfVE0zrFb7o3eC06NPwZlwdrnCzXWF0aDHJXAxD99xaX4dr17R4ul7XZKTdfpDouL6JbSdMTUGzadAYbjGIfEJcqhwyMetEVpHAdEgSrVECTWp9X3/e/p0Qa88kLJ6nP5EIoThTOMSUOUIIvGaBtcEbOI3LqEaLTmfRADQIoH8nIhAjIrNKogwkikHikyLJc4m0FI10CzMJiBKfXuSQKpM0n1AqbGOtr0Ch8J5OvO8lrHWkpIgm53MEwaJ6a056BgPo7wSk19cQzhlE26JmTzhXOKBgRp/oVgefdpwQnBOc4EPi4VSNLVNKVkDRDCmYIRQy8r19nOZTGK3q9317Pm6PivcKpSe3t9nNV9nOLpLclDqqYwhEltCa3KLaf4WxqKF8n66xxoGxzoG1ia2meOmEUjCgYiqeetJl/blVHQk76HL7rZxQuYiydh30i5KVz9fJr15jq+PROywypErgN8nqTXKryLQfoaYZtm1QcSYsOUP2ghpxpDDiIRvTa1w++A5+vsKbb/0Yb/AU/ZlOWdVq2kflC1/Qepo//EMdESiXNemZzTS5WV/XEZJaDW7cWPT2CQId3bh0SaeTDg70a2truuLo3j1NcOZC8F4PRBJjRDMc30ClEqF0s1LJEWGQBnmaYQzaLB/eYjf7DBmSSe6yFO+QT6bsdA0uettgbTISp4jMIuOxRatlMJw6vDNc57PuDqmSbM1anC3uc2uyTHm2z+mKQXE85VZ6hjeHm0xyl59ZfgvfCPmsc4WCV+dGdIoJRQ4PXYpFTQbnxLzd1impVkvv4/7+0XbnRQ6Lp/H6u3itAoG3TC1KMLOYrqrBLKFaiUlOGUSRnuyF0Bqe6VR/ftXMIMvZzZYxpzkFK2LZ7VOSR42R7msDYBg6/bO8vIiYeAnENw/I7AljWdV9tpRkGPtYMkclCTklnNmMwDBwnYiCHCByg5uTVcQtA7vp0TCqOO8hSntYWKvyXDsbPyQU9jwt1r5wYfG/QQBbL0/ZVhGp5YOCflTkLgpbHqnUVYYfbtPsx5RaP7i2Mz/qOCE4JzjBh8TDKaGqPQNmx6+rH4Jt+cflUfFw+i1TBvdmTXZmDTIH1GiC8FykY7MS3qYR79OTy6iCy8hdQeWKiSjTM1YJjAKVrEMxH7AR3uBc/yWs4hm8jYtMbu5y54/ukXd6kGZgGjTKCQ1rRDqecTtoMRArjOwWYWuJvFAks1xmM4kKwBAZnphwujolFwbDuECepNQm97gUvs6S1SOyTb6Rf5F7W8uMSDEKCcsrFo89Bs88Ay+9BK++qifapSUdcZmX5K+uahKzsqJTWvMqqtFIk571dU1orl7Vx811Nam5e1dPvK676MSc5yDyDDMPkaZEJQLXiPHNeRmbQghdDZfe2cLtH2J6FwmFTyh9RBZh5zkTq04YgrAU1fiAQZyQyBrjsYVdK5C2Y662W1yq7CPdjFvdGmdnL3Hbf5zGmTLGm1sUq4I3RpvcGS/zP+KIr8z+b9RozLkspZpWuFf4GbaqTzOd+ozHej+3t3Up9q1bOupy6pQ+PisrsL0tUU+tkn5nj247p1QM8VyII4PKpM1yEQZnzhE7evIvlRbRsXljx/bURqk1SnFEyc0IU4srw1NU7SlL7ohK2n7k/STEUZTs+RLxdsLk1lU69cskuYUCpqnDKPHIZhEhHjN7GaFyEmkjhQQDYs+hELRR+z0OHr9Mr9eA/iLCt2i+ucCHFQp7Hly4KDj18uuIUgnhewSpxSj1mKQ+eS5QccpEVIgGRcTVxf6VSos2FCek58PjhOCc4AQfEp9U2/KPw6NCdbpE24e0i5cIxmV2g9rxa1Io1msjWvHbDD7/v5JmqwzjGNO2CfYHzLaHFLIhpaSPTUSeWZwL36Sgpjr0oRIG1XPcvQbZS2/p1g7lImvlEe5gh/i1G9ywLzBZvczQWyaMJfk4Jg0HRBTJbV1t5Dhwaj3DGO0TRSVmho8QOefCt7kw+zZGyecgW+fbhc/TT9aYygJ+PqEhRzz34hrnL0j+8A/hnXc0udnY0BPJ3P12eXmRqrp1S5OU2UynmkC/trGhIzPzlMv6uiZJf/qnOk2lO2vryVxKMCwD20hRqUQhsGSKZ8Sa2AjtmCfJiMcByihRFFMiXLIMZrKMxwwrm3EYlzkXvsKee5apYZEENrFTplh3GSZ14mBIe+pRmQ2pmAF3Wp/n8a9ucGOvSOnqNSwx4YX6DV7qnGVnXOI305/h55zfRCiL2mxIZfonlMSEm80fY2YU2N/X+wF6P1ZXNalbW9PRqVOnIF9vcMt6BvnWTfJuj+6kRMmcUVypkp+/QLlYwfN09GbugFws6mOv3bItsFyGQc5YFfGNiDC3CDKbvaBKdSIprV3gTLHBI/jGcQSz0PltvP5ryEaNxPLpTFz8WQ6OJIlzhvUW8ShARgEju6T1cSpHUaCYDQlrpzAm8ri9w7xCba6jaTRA7G2R/F//lXw01tHNtQYiit9XKPzwmOGZCZ6ZsMxIjxnDXdLN8wSbJYYjTYrfy5ywXNbb83C/qA98j3/Ky9Q/DE4IzglO8CHxSbYt/6geFVGk0w7Te5DOVhBeEYCSFVJ3Rqy4fTpRlVnssDduYAYpqt4ijvWuuypHOjGE0Ij3qQSHCNMAKclyOFDrzKoVrIufh+s3scIRG5sCy+gRZ4Ib3Rpj/0VGRp04KKAsi8wwiCybKFKY3S7OpsPaukGjAUFQoOutkw9GlOszLlm3cEcvk3kub/AM19Q5Rk6DVHjUrCmrVptn5Ws0ij/Lf//vLe7c0eTj3Dk9UQyHmtw0m1oTtLz8oNdNli3IyoUL+n2vv64jO1IuyrYzres+7u4eHzWuVLaNW3FhMARTYaCreITIEYDIdNfxJDNw7IyWOGSiNLOYGWWawTaZWWdqlInMIgUjopgOUDNFYLuMTJeNMw67u032VYXmmQmxa1NcLnAvkVz6XM7bb9VxD9oYtSafV1/n2+oFuuYK/4W/wi+M/h12vYZ54RQXd96mhMPemR9ne0frceYpu05H79e8H9T58/oYXHixRfJMg1uvjVkKY7BsBlmJckXim/oYFIs63TedarJTq+nnPU+SFW06txOSMGNs2oSxROYW5axD6i0zLJ+l+7KkVtN6oOVlfdzneDiCaSR9ViyLtYvriPUVDv/wLZxajdzLyHpjapMrDKmSSIex36IrWxh5EWuq046mqc+daepI3GAAvRttkt//JqpvUZeS6uAuRrmDsb6K3PjuQuEPMmYUfuwZyiuS5ZUH78vhUH//nPTMhczHn/0hSM+ftTL1E4JzghN8BHwabcsfRhhyXAEyh7BtbDtnxdjBLli0ozLj2Gdrqtu3qzgiMVykaWMaixB+Yb1C/ZJEvXQFZQC2SZSabBsXUFKBITDOnqN5pkT5xn9HLpdAuuSTgLfa6/RnObHjI0VOIezQM4pMMokZh9gqpjZps1G+hXnqM3Q6TZJEYmyscjZ4i9X2daRr08983pA/QT8t0zdbGNKg6Yy5UNznifJdsv0p/+X3PA7HOnJw6ZKeEDodTW4aDR2tWFrSuprhUE+iSaKjNfPU1LlzWmfT6Whis76uJ5grVxYO0POS7v19jrq1S8yNVQjGyCBEyBhl5Ig8hzzDNhSJ6RIGBYrErLLLPsvEyiDCJTB8ymkXQ0V0nGVOG7uE0iWJLdJwTOzadLuSRkPS7zu8vevw+c/rLCoCDtuSx37mFFd+Y4x5uIccj/ii/Ud82/wik9zjv5T/P/zCysuUpUQ1aqz232TpJx+nUm3yzjv6Wjk81McnTfWxWVnR2qRqVf9u2ZLLL1SIY+0kXT+qxB4ONbmxLD1BFwqLfl6djp6YE7+MYwuS29uMBglTVUChSI0SMi9QnkpUYUHEd3f1Z64s55TiRTTC+gu/AEd6nXl0QnW6NL71LZrmHcSyR9CwccImy2mKsDKmWY/2aEa+BoE1r7DT214sHpGdwx7Jt1/D6PeRrkfPLtPLc5zxkNPXb2JcPP++QuGPMmY4jr4el5YWz821TMPh+5OeeXoL/myWqZ8QnBOc4CPi02ZbDjr0vrenJ+374ft6VWyZJfZvFbl3TyLyRZl2pgSZEpiTCc7yEma1hJQ6VaNXjZLsz3+ZeNCjtzPjULSORl+9el1fyaj/1achC4iShDyOGd4dsD8rMckmpKlNKW1juNDJG6jpBEckFI0pG2zjBl3Gh6cZ/skW8oLNUj3hXPI/MbK7ZIMB72QX2BWP003rTL0mvpFT8UMeK+1wubzLYAi/E/wsw55DLuDxx/XAv7+vIwq1mp68Gw2dRpm7487LwuepseVlvbKfu/yC/lmrLfpdlUo6yjBPadm2noScRhllXsB4O8RIBqg4RKgcTAun6ZNMTXLTQiUJlkyxyEgwMfMZM7PC2uwmhtOiZ7QQQCM7ZCYsUjVlmlUJAonvayJhGPDaa/DsszpKMhiAs7zO4/8bXPmvV8m7XQwyXsz+B6/6P0loVPn9yY/z4+4VWk6G6vXxCPjMZ/T27+xogjOP5qysaFI4v9TnXkG+r99/+bImRXfvLlo+TKcLLYlS+r3r63r72m3wnBybMaYRUTEjEunSky2SKKN3Z8wskBgFn2ZTn5/evRE7X9umOtnCyyesij3cRhnzhecwnnxicR++Kz2UQlGHOpRSeNu7nD17BvvFEvmRseFgsOj3treXk71ziDEzKVo+jm2QCRthKCzfQo1jsp095MXzqCR5ZCXWHB/HmDG/Dpfva3811zXNq8veRXpUTvrNLQoDj+pGA988Ejf/iJepnxCcE5zge8CnwbZ8MtGkZp4+maNYPCI1lh4I79wBpST56WcQhy+TdfqYZQ9l2sgkRYwnSN9l+cVNmo/JB0SPeQ77Yp3h53+F7Np1jP0DzGTGutvGOb953G05P2wzSjz2bxokeZ2uu4adh9SjfdryFOYsJjZsXGLOOtt4IiTJJFveZSg2KEQ9LrS/RvWwi5pMiVvrvF78Mr2RTWdskyuFZyqWS0Oeqt5jyR2xNyvytb3HGJs1pGHwxGM6grC9rStc5uH9+UTc7x81L801IYwiTRguXICnn4aXX9Yl0ratCV6xqCM6QujVvufp908mDwpDpQRRr2Ku5dhuCUOkGNs+uTDwKpJJnJP5VUR/myjMca0ZaZZi5hkhPgOzRSM5oJgpMmHgxGOKfkokYgwvYRRbjEZ6m7a39XbcuQObp3PywZi9dox12uGxv/Q4V/6/Y7AsbN/iBXuPW+MlRmmBb3Qe52nvHc5aXT35Ch3parW0U/M77+j9mLdrKBQ0CSyX4d7dHDkZc7Y5wii4OM0Gly9LplP9v4UjJ4Uw1JP0/em8leWc+M2X6XUnSOFSCLvMzBIrzgTlFhjEBeK+iRIuh4eSPAwodbYoRj0OZQkVu7QjKG53qL/5Wyw/9Qr2n/9p3U7lQ6SUDR4kD+Mx7F8dMZvdIiz4DMNlcmVSFUM8QqaixM3CZ6lM2jT7Y4wPUFzw/Rgz5o1g34v05MMxeafHpLDCdKZL4y6U9o40YD+6ZeonBOcEJ/gRxHCooxMP97Mql3W42zT15H3nzruJj7fWIPjcM/DG2+S9LioHvwBrF2zcLzyBsbEQCUSRXqXPm0DKRoP6z9VoyS6ED65Qh0PY7dSZRi3aqYtTkNRFnwOxwsyVJLlNokxOT9+iULfxRcxIlWmnFYRncao64ozYRl25gqpW2Vv/HDfHa3TDAmPhIQsJ3qTNmdFbPLGcULAENzt1vtG+zIwiTsnh8pNaRHrnzsINeN5Q1HU1EZxO9b7MIx+mqcW16+t6op63LlDqqMy5qvU489Jw19WfN/fHmbeJEGLeD0siiwWkCcYh5In+DpCoWh1BlbzdpzW7SuKcJzIKSDICs4gf3iQYmQzcVeq2zWa5TxKXGFgGNou0z7z6KZ0GVLeu4gz3McIZtyRsrsVcWIq50a6R2RVsI+V8qc1+GLEzq/Nqd5PxSpMX7xPJzyNcjrPo+TVvANtogDnpEd3epjza5kqa0XDHNE8XtPh3Y/3YFXl3d9EeJE31fkcRZHfv4d54napRRHgeU6tEKZ9hTQ7pJys0ihlkQ+JCgWHsEh8MSQKLSV7BiAMa8QEzy2VSukQ7TWi/08Edv8Xpn5dULq5+5JRyqQR+a0wkb5CurNOeDplMBFUvIBcWY8rk0mBAlWGniHH6FN64wbKvr4UfJu4nPdndEZG4QVw9zSgropQgRxxrwe4vxf9RwgnBOcEJPsH4oBUPc0Oxw8MHSc28AqTV0lGFONYTX/jQOFYo6GhGnkOw29UNRKdT1tjFtyJkaxXrxReOJ4KHCZQQurJGV9xIYLEKHA4XEaT9WyGGUaVl7tCNl8BMyKQkchqsDK9Rjg+pRYf01eMEmYOIpiyZCWdXcwolh3yUEU4irraepzdcoxcVCXNbt40wQy4U7nCh8y2M7hKvtJ/ijeQJAqNIoWHz2FPaJfjWrUVbhVptQXC2tvTEPXct7nT0BGxZ+vidOgXf+tZRuseZ729O1BmTzFySVGJWDJaW5PEkPhcZ2/ZRIZnSEZD5KZRyEeUxDBCOC+sb5O1bNONdtgqfIZEOfjpkalUZRlWcJKFs92D5FEkQ4lQ8nJKFrXLaexnhMCOxc2pOzmhrwFtphWfTq5jRkCQzudVOOS/vcL5e5WbnceJSEccJWRYRdtLhlnGB29YGs69LvvzlxfaZpk49lUpao3T9ut7+w3szgs4ubjrDLFSxy4JeUqR7fcLm4e9T/MWvYmysH7ci6ff1/8970qo8J7txizj3EOUCRTHBAGpGD9sL2Q1CUqPIwF7HdhJKYsRs9DZ92SLCJjddTJHhZlPMMMKxE7piGQYew691qMfLFEuStbV17L/44dNDc1sIOwlYW5fk12+gRjHC91gyDFQYMZ5JBsvPoy5dIEnkcb+y+f3XbC7294eB+T64yQTPz979hh+CtcUPAicE5wQn+ITi/SoelNJRgk7n3aSmWslp0EVEIZly2dttMJk+OJDPHYRns0XUIu92qbz2B1RnOxjNOrjLEEbkhx3i3/pdup//RSbuQvFomlp7Mdej3I85sclzTYZsG5ZKM/ali1xdpT4c0o2aNJIdikyolseM0jL9voDpjKIdslKcINfXkEcmgP2RyRuFn2bGGlHqY8oMM41oJjtcnL7KWnSTPE55mRd4x/0sgeNRaxpcviyxbT0pJ4kmN9WqJji+rzUmc+JiGDoFkxxFVi5e1FqWmzf1sS4U9GtWNMJ7623e3q2h0gYOYHdD3E2fKKpj2/rYOo7+nHnncZ0W0L8bxoLk6AhPTjIYI2SJci3CsAUGYGYZieHSd9d4LH6FviwyGeWUyy5P/kSFN69PaN+Z4E5SphTo9KYs59tEaZkcwVv5Z3jafh1fBsyyArfGm5zv3+biE31uDAzCSYZnJdTX1vFP+1zZ9Wm34bd+C/78n39wcl5bWzRqvX0rJ7nbYxzZRIVllAyp5RNis0yhYXO3A/7/uM25X1lFGvr6q9UWrsjdLjAeo0ZjDFuS5xkTo0SZAVUGIOCCdYdoELO3aiBWH6f3rTtEacyqu0ccpEyNOgrJxK5TirtMU21AWXAUyWDM7s0AUSjQ6+mKrWazRf30B/eVeaDEe2MNefGCvidHY1SWIqKI8to6rf/9OczTDdJU79dcDzMY6Adosry0tCi9/0Hhk2pt8f3GCcE5wQk+gXhPN+Fb92jvZYyf/RKivhiMhNCrxHod8p0d4m98h917IYPYB8NANurISxfx1xv4/rwT9OL7fF/3y8nf/mOyYAd5ajEIxm6RreomaXuAfOU25heaVKqSlZVHTxL3E5vDw4VhXr8PynJoWgPaao3mqs96MsNRDp5lMDDOI8IQmd/jjLOLfe4UoqC3Qym4Mlpnb5wzcIuY6GaKZjJlfXKT88FbVLyY2CjzTfdF7oRniaOU5dMxFz9TwLK0fiRN9b6WSzlVY4I7jegcegSJjxDyAe8R29bbXa0uIjrjsZ7Y18pjCnfeQEU9ulwkN0xKcoI5G6Feu8no4jMY1QqOs0jfzcWfoImNTlc9GM1RcYqaTFCmjXAciiLAIMeyBUHmE2ces8CHOKFQtTGee5rhBIw717FnLo5nk2UeUWIznDlUk232nDM4Rsoea6yxj28GzEpFbk3PcckyefxXPsf1m5LUsimvlLBCyWdb8MYbOgX1W78FP/MzmhTOI4p2EHKp7mKMTTpvXueecwaATlQizSWnC13S3CArVpkdjLj6nTHrj1co39dgdu6KvPNKQFcIVLGEms5wvZiCuM84U0qscML5pSnGZsy9r9+iKCPCtEBfFWhlu6TSIsg8fGYQp8RuhdAsIOIImaZUjiJH3a4mVrWaJhunTj3azO9+PErDIy+eh8EQ1ekhKmXsv/RLGKdPAfp6v1/HM53q+yCKNDGed4SfVzo1m3pbvhu+V++aT7K1xfcTJwTnBCf4hOFhN+EcSScqM8p8VFWhOj3k1RuYP1ZjeVn3IzruD3Rln/3fe5t8JhGlJUTRQqYx1c4VhpMhM54nbGhiJITWasy1Avlhl/S+Hlu5gpuTVeZpelku0hpepdU4h3yEEHFObJTSk4iUepAfjzWxqNeh2yni1lqsdO4iS3VWqzP2gjq64EixEtym/LiDGlVR27vQrDMttXi7t85gbDK2KrheShIl+E5OK7jGudnL2GWXGUW+EX+BPf8sqVlgNdvhbBrj2M9w5R1JlmlyU1AjKrevYQ0PGSY2oSgwsU9hL9eIc73St20wzZy6G/B0o8crb1bpdgv4viSOcsz2DuXwkEHlNAxAKYFhSpqVDHM8Jryzj/FYCZAYR+X0WbaorJoTnLnfilJ6kosjhVIKZUisLGTd3GZAmalRQkqTmbnEMF9luZYQvvAMsVPBfPVbPJm9ySuVL9KLXUoyopt6BMKnGse0srv0nTXiLCXME5RnYZqKxDDZ2pZcMCSP/XiLa9dgFizEwM88A2+9pVOXv/3b8BOX9ii9860HIoqnCgVK8YTCssWt6RqmyHSLicyhaEQYNoQTAzOK3+WdM78GV9cENeMmO/YKs5kgCBR7zhJrYgcvm8J4jHAczOefRSQxK2ablcKYXl/ipFUwJJbISIQFubYySIuK3PIYpi7CNI+1VL6vf+7v6+8fj/X+lkqazL5X89t3aXiSRGt4nnzifW0hCgXd5gL0NdDtLoTs91c6maYmffMO8nN8XN41PwrWFh8WJwTnBCf4hOHhZp53Jy2yXI+8QgiWmzGlycs49XPIWovJRK8KVZ6TfvMO+SxENuu03BFhljMWHr3aJU2Mrt2g+fM1WkvyXdGXh3ts5UqCAikVG14HuxCR7w3eJUScExvQUQ5Y9HSKYz1gj4+8Z5otiTLOsPTaVfa7GbvFClgZBTVheXwdaQoQDioKyQcDtro+d/0yE89DlEpU1urkCsq3r7DcucFm/yVEscgwLfANfpy2vUYmPU4XumwYfYzBlCuvxWSmq8338hG1Oy9hhRPSUoXc82lPGvjTNuZ2h0P/ceLEwVAJZ7jFhZuvcfttk446y1hsUmh4rDVynBtdVLnKzekamTLxjQhbpDTsCbJUQI3H5JOAxCzguprgpOmC4FjWIgU2Fx+bJoRC6sammUkexBSMMTNRIAAcobs3Dq0WF08HxJUKRn9M3u3RLp6naoREuY0kZ5bnzKRPx9mgGe/QyPfJpEUSC+zxhNx3EYZBmNkc7qWsLOlqqWvXdMShWNQRhyef1Gm9oD/j9/7rjOdlyHqrqP17pjOyO1sU+z2KVROjLBlEHtuzJobImAiXhujgmBnKtnVaz9LeOZWKFm5n2zuk3/w2qt1mdXSL3PHYNjaJc8WOXEJIwSnrJv5TlzCefALV6SIdG5wm9WCbameLPMuRroPKFR2WGJp13JoPQR+7tYa56TEa6/2ZzRbkql5fmA6apiYdlqVJ+byj+v34OEq8DeNBX5vZTEd3wlBfH3t7+jFv01CPd+F3Pj7vmk+jtcX3gh8awblz5w7/6B/9I772ta+xv7/P2toaf+2v/TX+7t/9u9iPSugf4ctf/jJf//rXH3jur//1v86/+Bf/4vu9ySc4wQ8EDxONhjPBEBlFUzvyqSxjNhRs31Rkvfv+cTymOrxNYzlDFmIOwxLjRMffXSNlZWmMOdnGEecQ4t0RmId7bJkyPy4lBVCzB4WI86oYWFQMNRp6IglDvXINQz2BzCeMpSVQrQYH6mdR165Dr8fp8Da2LRHNGqo3IO/1yVprvF3+CXojm0Ho4BspcrWOZUK5d5N13qbafxP6Aw6SGt9qfIXIKSIMl7PFDht+Hwm8M9gkSzKKFfC9nMqda5jRFNGsEyQeW0GLkhvgFQy2e0WmSYpTgFZ0Dy8+pLGc8VJwmcG4hhcPiA4jTFdxSt1hYm2CAlsmFKwIQ+YYMicxHXw1IUhT4qMu446jI1rzirV5SsIwFtE3x4GxNFB+EeIJgVXHDsZkLiyLbfbUKkFskjglDi9+DseW5FlMkApsy+Lxwj1G8WWCzKKuDmjnFQLDY2KUKaoZQuR4RkScOtjTgEoVJl6Lfujjj6BUzLlQ7XLtOoyHNoXVErYtuXwp59rv7TGJM75tv8Do3stcGr0EeYYSEoIAce0q53+8RtuqUbJCbkxWiMhJZx7Lqz52pYQh9P4bhibF/VtdVl7/Ou6sg9w8TX5vCxmEbKY3SU2Xrfrz5Dlsl38C6/LnuJBJzPu1JBfOowwDubcP0xnCNGmJXZYqIZPcoeNv4j52BulIGkdVbLOZJjLza9a2NZlzHC18Br1tpdLCBmDecBQ+/hJv39eNX0HfP72ejvAoBaNhTu9P75H3WhitS7SsERUZfM/eNZ8Ga4uPCz80gvPOO++Q5zn/8l/+Sy5cuMCbb77Jr/3arzGdTvn1X//17/q/v/Zrv8Y//If/8Phv/6M25TjBCT6BeJhoVCytR0hyyUFYYzZVKFXEkg4CvRpeWgK2R0RZG+GtAlAwY4pm97ipo8pM8sF7G5E9Soh4TG7uEyKO7QZ77+jnBwO98mw0Fp22fV//3ulofYHrLkz05s0oZaPB6l+oUDq8iRq2oFQkvfIOqtun17zEtfEppplFbFoUqwnJOMPdvUNTtDmTXcdfLZK3nuLmWzNetz9PJH0M2+Fcsc2KOECGCVcmm6RCUCoKfB+q5gR7eAClAr2kTD8q4BkRUigOwzpj4eFmU+TMoEKf5851uD09wyT1CJRPwQuoR7tYfYOJUWV3UkagcIwEpaBuTzBEziB0cMwZsW0gcz2xSvmgEHtOcCxLv56meqLNc0lSX8ZLRsyo4RoJhXhAMe1hyRIzd4Xw1AaB1+DCKbjZsZGmhDhhSy5xqbRLd2wyCKeMzQLDvMwsC2ilhwRWhUNjnZXoBjmSsayztm7SLZfYfqPL+u6fYu/f43SUcEtcYFSvU3r6PGXP4Ex0lX27SXvq8U52gYnn8px8BZGmqMBEjUbkb7/D0rkzVLwiMg7pDCwO5Cqy1qLQ020W5ikgQ+ak166zPSxhtE5zrniI4brkO7vkwxHGdMzZwUvkL/4YO+ufQ9Qb3LypHaFPPf88stMlH40xLp4nX14i39qB0RAsG9msU7uwROvFJ8iWGty7txB4+76+FpNEX59xrB/zknUd1cnZuR4gspTJHjiNEtWaZGnpwfYQHzek1PdLs6n/nm712O3vEZaqKCU5DKr4Rowlsx9p75qPEz80gvNzP/dz/NzP/dzx3+fOnePq1av883/+z9+X4Pi+z8rKynd9zwlO8GnF/UQDd512XGEcHzmvolDjHoX1GqeeKWHft7rMHyJGBTN68IPfpxT0/YSIE3+JzvKPI/cl46OQf6OxMMQrFPQE1unoiaLZ1IP2uXO6NP3OHf09vg9rYofs698hOdIVkOekhx1uLH+JzmiDceJiGRmeGZMhKPoZS4evc6F4gHnxLCB4Z7jBO9UiQezg5VPq032Wo0PEbMIV80mSfELRy3HNZSoVqOcB4ySn59YRKGwjJVOCJDcZxQ4pFgYZZ9NrnFmakCuTYezTj4r4ZkSsbGzf4mL6Ov3CKbbbdZRtUTJnKCVp2mPSXPduKrWWwPexj8rEHxYUz8nOPF2SZQsH4tgoYl48R7ztUY0OyaaKWKyQuadwG8s4jQKDgY6giUoJq1EhO2gjHZumO2I0KpJh0pJtsiQnMotM0wJuMkEJg5GzTDHtIwoF2qc/x7qxz73vvMXdIOfccgWzZXEh6HH9MGP0x2OKj52inrdR4Rgndth2LrItzlJhygXrOjQaqOQAspx8NMFK+5w397FPfZb6ZpUbnTLpUEfzNjc1mUj7Y9LuAFkqoZTk5niFM0WB+VgRYxaQjycQRXg/+QKPrzSOXZGTBG4l69jP/hKr9/4EdncRWYZx+hSy9hTG5UsYZ04fp10MtEGjUjr1MxrpYz3Xh0mpn5tXObVvD7F37+CPBzjphM61BlmxSu/8Cr3TVQxDp9buF0t/v+DmAetqC9lIUUIyST2kyBdv+BH1rvk48YnS4AyHQ+r1+vu+79//+3/Pv/t3/46VlRV+6Zd+ib//9//+d43iRFFEdF/DndH97VlPcIJPGoRkeOkLHG775HdCRMkAK8PMIpanN/DrNtZXnsNwHmro9zGUgj5KiDgxqhzWP4+8dIHAbRAcEZhikeNmm4WCDu0XCprYCKEnszDUmgvQz509C8bhuyvERvtTrqRrBH0Tox5QsnPi3ELKnJoVsJzv0Bq+hFx7DCEEr/VPcXO8wkxKiuqASnTIyuwG0rG5WvgciTIoyjEOBv7tt1g5e55x5DKVRdx0ykjWWHb6BJnNjfEK08zDJaDBIRYpZ2oDbkzWMUVKJiSuiKnZEwwpGAZFstV13F7CLAIlcwypsNIZ2WiKdDYIl88A8jhSkyTg2Dn5NIAArFkMVDCOSqezbNG4M0nAblRQhRL+ZovJfs5o7LFS9ul0JGGoCZI29JNsXbqIOe4Td3rcTcos2z2ybEYnbFK0i4ztMoHTojS9w1T45MLCdzLsZ5+Ceo2tb3yLpegeh83HuJM1uCD2kAWPi5sR1+/C5PYBTmbTGt5AFc5gi5u0WWKPVQRwLr+iT3yljP3nfhrh+wjP5VKzwXgicXZ1KrN3lE4tFqEUxcg0QdhFPDMiyiykUPqaLfhI1yHf24dIRx9dV3vwzF2R41KLu0/8EoVLQ1ZL2mH7u2lJ5j5Na2sPiuGzbHHNju52Obx2h0mUIb0aFAqYiaA6ukV25ZDd8BlEqUwQLEz01tffvwLqo+L+SK70PcpW8OAbfkS9az5OfGIIzo0bN/hn/+yfvW/05ld+5VfY3NxkbW2N119/nb/9t/82V69e5Td+4zfe83/+8T/+x/yDf/APPu5NPsEJPlY8YJ5nLiM/9xxcv87y8CqFaIiwLOS59fesePi4SkHnQsThnT67OznCtonMEkEgqXsLe37T1B8fBDryMG91sLqqRbW3by/KopeXdWmuynPi+yrEQHB32uJuXiV121SiA9xJn1HjPEhJyxlyutjB72yRAqLgsx9U2BmUCMOYatSllPRZGV9DZBFXi58jERZlOcVyXbyCYCN6h8ErBvmzz+PUixweKFZbfTIluTdrMc0cfCOENKNagWfVNYYTvdDqxwVckRApm7qc8rhzg27kcDtYI18SVCeH5LOEihhQMDqMljcprZ0lcsqkqSYslgVxu4+8d5X8wISsgOi+TeZ8BrmyBpSPtSlznY4QgJDMnAayBRzpm+aeRdOpvl4uXtTpvvxzLyKvXyfr9HA5QBhlbJWyVo+5E2YM8yYls0cjPqQrm3SKG/heATcYEnd7dEpnqTtT+lGRnaDBht9FSsHFpQHXuwahXUMlHmtijz1M1tghxkEpxY1kk7PVPQzDAM9FeK6OKnS6lJoNLl7UgvZGQ4uYswwmkc+mHRPECYFwQOhKNMTRBfMek3ehwH2uyJKpVeNGWKPmwfIHTB/N23Lc78IdzHLEzeuczu4SLa8zTk3GSQEkqPIGzvCQYvs25UtPMRxKul197U+n+rw1Ggti/3Hhz6p3zccJodTDZu7fG/7O3/k7/JN/8k++63uuXLnCY489dvz3zs4OX/rSl/jyl7/Mv/7X//pDfd/XvvY1vvrVr3Ljxg3Onz//yPc8KoJz6tQphsMh5R9ErPEEJ3gPzGa6Aur+dglCaE1NtQqoD+9/8UBZ6VE5q1x/b2L0MO4XD4fhotO2lJqwzMfZJNFEZ+4jUq1qIrO1pfcL9CRw5szif/LDNtH/+Z8QpRKxU+LWeJnDqAIoWr23UMMxh+4ZZLPBSmnCOeM2RhqRbe+jZlO2zn2Fe9MWvZHET4eUzICVbIe8N+Cq9yyxU2JV7BEIHycLOZdfY+gsg+cjvvRlDtuCxt2XyMKYO/ICg6xAmNrIPOGsu8fG5ze43PsGV69JptU17k6XMMgomCGmzLkcvMSodJpXjReIcpN6yyCZJlzemFCpm/TSMq6nU3i9niZ1xrhP8tYV/LDPgXOKKUVeLL7FW+1lhG2zXXyczHC4eHHROuOJJzRxXFlZtNVwXW02OJstRLCXL2sC1e9DsZgz3hlj5hErVpfb39hib1AginJ61DAlrCRbOCIm8UqoQoWVy2WSt65iNKrU3BkShW9GeIbuxqqyjGx3n9sbXyL91kt4+ZSWN2bLPKeZwVE4SdQbnE5v4K41UMPhI8uZDw+1gPbePQjDHG/7GuXRFpUlh0zptXbVmdC0R+Tbuxhnz2D9hZ9/V3fw+6//Xk9XIc3Raulr9cMgz2HnrT793/6fCM9DOA6WTHCNlF5coBeVSGNd49/8wiXyQhnf1//X6eifczdsIbQweV5q/73iQT+sdy9YrB/BDuDvh9FoRKVS+UDz98cewflbf+tv8au/+qvf9T3nzp07/n13d5evfOUrfPGLX+Rf/at/9aG/7/Of/zzAdyU4juPg3C+FP8EJfoiIY00gHm6XcL9u5Rjiw1c8fNRS0PuJTRzrv+t1PWkcb85RSXNw5JdiWXqiPXNGm8Jdvbp475kzi75Dc8wrxDqixXCq7Vx9M2TZHTLMW7TjJsXZIc2wzenhddRwSDoLwDB5u/JF2vsuQ2lRTtqU7ZA1sUeUKE1u7CLnRi9hSYVVWWPN2WOUt1BhSDRTTO5MqD++jr/8FNuvthl3TCbKxWdGvZxgnz3HU18qs/v6jyG2XmPciVFWSihtytmIc8OXGYQWkzBCso0hXeKZRDbreOtNIgWTA3DcBRG0zBxj6zppGJA3GhDaGJnCKUhkVITRCDEekpebWJY8dj+ea3NmM53qU2pxzJNE/y6EPkePP64JzmQiEZUKGeBfXMIKm1R//0/JZiMmfpmpKDL1GxQrMYFRxx8fML2b4B6JlAeiyLrfPSY3AEQR0rZ47KdWeKdzluDuPQ4Tk9PBG9y1LyFKRax6mbQ34W5cZ3V/Snmp9Mhy5qWNdSoVvd3TqeTm4DT5LGSwH/NEc5+hqNEfWfQmDmcqVazNDZL/+v98V/+Xel0/5q7I7bZ+rK4uIorvBylhrTyhIW4wLF2gGzskuUXLHbPiDZilNtuTKsNuSq+nkNnCDbtc1udkOtULFdNclP8XCno7vpcWDX8WvWs+TnzsBKfVatFqfbABeWdnh6985St87nOf49/8m3+D/AgS9VdffRWA1dXVD/2/JzjBDwpZptNP4/GDz5dKOurxcfep+TCloPcTmyTRqY852ZqXMM8RRQvNjRBw5owiiBNefQOkELi2SbMpjitB7ofKc9LJjBvhBnQVoqw4WzxgJ2jQDitMpMtSdZvl2S0q2wfk87yNafEt/6eZxTbDxKGa3KbiRGyoDnY643X1IrFpcy54A0clgGRJHTARFTAgcjyiIMfoHuJYK4RTm0P7NGFRUrBAmD71iybPPqedjMfOEtPHX6D35gQrGFFSXVAJtWCXmXuJu+5lEmyaskc4VRSzLpV4hYG1fFxJFkVHx24yweh3MItVcmWSKIkUCltkgEB4DmIWoJIMw9A9rKZTfR4MQ39WraYjFZOJjuwlif7bMLQ4dn5Ookifs05HR9HOnYOrfyrZ9x5jSaa0M0FgLBPbA5asIQdJg2g6wykX8Eb7hM4GO7MGZ4sHmDJ/IA1iLLd47C9c4spvJMSjMe3CChdKE27FTdLRBCMak7olDupnyMwJdTl5ZDmz40guX9apIe8Fn5tvnIeDQ97uSZbEASUrIlpaZ2vpCQp/+iZL4d0P5P8yd0WeC4nnfjLzbu/ve78c6V1qeY96OSDODYwjQa9vxly075AWZvQuPMPoqJt6cCSJmXsZzaegfl8vXkolfc6k1NtXq320FNafNe+ajxM/NA3Ozs4OX/7yl9nc3OTXf/3Xabfbx6/NK6R2dnb46le/yr/9t/+WF198kZs3b/If/sN/4Od//udpNBq8/vrr/M2/+Tf5qZ/6KZ5++ukf1q6c4ASPxDyEPRdXzuG6Wuz4XeyefiAYjxe28WmqJ8v7iU1+X8FGHOtozTwQurEBmQj59hsB3X5KrvRAf+4MWF4JeDB0k23v0PvjN9nbzsiHY6zDHdZqAXfrz3Eo6+RKsOL2OB1ex6oLEKvg++Q7O3zD+hliy2MsatQnd6jG+6zP7uF7Ke8UXkB4DufDGxTCHolTwMhilJIoIFI2Mg4JimusjG+T/fGIK/01gtRC4ZPbBmcvWVRrZer1hW4odqvI9TJ53MDxIk51v8NO/0md/xgapJlJIn0yz6CZXEG+dQCf/RmKRclstqiKimYZTpphlyHIJbbMSHIwpT64wjSRKoc8P3Y8znNNcqpVjqvVQBOaeZm1lPq9QaAr1M6c0WLuble/HoYgVYiVRbRqEYmyiYKYFIMgsxECal7INEo5LF5kJY6p9G4zLKxzK29ywbqD6j2o2zJPrfP4/wbv/P4WYafHbj/lvHuNW7XHyfIMs15GIeiGJcrmDFPmjyxn1sRY75uUJUbDAvdurGG4Fxl6Bk+/4LL3377DaCwZNz/HaaeDK9P39X+ZC4lXVxdp0u1t/fzp09+9JcPDehdbLnLGc6JnnT3DqScrCLlYFAyHC3PLUkl/R7GoL5M4Xpj2RZFOpRmGbg/xcGTz/fBnybvm48QPjeD87u/+Ljdu3ODGjRtsbGw88NpcFpQkCVevXmV2lNC3bZvf+73f45/+03/KdDrl1KlT/OW//Jf5e3/v7/3At/8Ef7bwvXb1NgxdcfFJsGy6n9hkGfR6OXVrTF3FMLIx6iWyXAtD55GEORlrNPRqdPcw5KU3pqRpjmNLWisphpnRn6bMtmMubTSoFPQonm7tcP0/v0EyTRClImtnbeKbATd6DbqxoNgYUPUizg7fQNomKrcQS0sk947IjV0kEh4NutTsCevDG7hmxrXyTzCtn+F0MaQyNJkMXUSacTZ8m+3q88SZxIxGHDqnWfFHyIM2d7JTJLbD2KhQFDMqySHidsJTzy+RJOtEkT5/+/vgehK35iHCnI3wBrdLl+nGJYRSlK0psTJBKNyyTX93SLgxoVgro9TCdyXBBtPASCIy6ePKhJY9Oo4OiCzTzTYNfbw9T0+Ik4nW34zHehKd9y0CTZzmTsh5rifPeRRBKR0RPDiAvXGR094ht5IaQ0o0vSlhanEQVRCAy4RcWtRPF5kuPY/YvYrf32I6cblt1jh/tvKuNIh5ap0n/t+rXHtpTBrFtMsmj5VGXPmPI3LTQQFNZ3y8f8AD5cxKKaZhQprlmKbk4kWL69cF5z5jcvuWiZ0LvvlHMzY6B/hlSYBga9qiZAWseIMP5P8yJzRZpiNFcax/zonVo9QKH1agP++MnqaaRI1GOqozHi9Ex0Locyilfr7dXnhEzc/n/PWH8b32njqBxg+N4Pzqr/7q+2p1zpw5w/0a6FOnTr3LxfgEJ/h+44P0gjlul/BQV++VlQ+uBfh+435ik+c6lF5VXWo3rpN1e9jZjNjwyRt1XZ5TbRyXwHqenjTyHN55R7F1GJGmOa2moFI/ms0xKBcko2nMTntM2XeYTXOu/fZdsmGAqtW5WD5kL9lguLFBfwDNwU2a8YDl0zbGuTPIjXWSP/oGSSq4NVslt2wskeIwoskhG+YWpoh4x3+RUV5kyR6x5IUM0wbCH3Ku9y0wDJZmtwmdSxwUz9GqJhTa++xTYWgvMc5L+EaMNAzKZcnF4ArqpS1uBasoJY8jV3muJ6vlSkA7qoBvMZ552EZK3Rkzij1MqfC8nNnEYDLIaDb1JDaZaFKYGx6yUSc/aJOVGmRITJkhhQIUKgiQ7hLCNI7bNSilIzDza2k81tGceTqq2dTkZjDQ0YJ+X/++saEjF/M06MyqsLS+SvHmPqpmM0l9otyibM5Ic0E8DWitlGgnRcp1CWsvkgSPY8UxWDbDMyWWHlGaJA3J5RcqXLsGoYKdMVz0t7md+uSWRy8uUbcni384qoiaKMHO3Q7DWUiUZEgBtmVgGwbdUJB7gvZIEh9mhOMGRm7zeOkuU2OFsXA5dj77gP4vhqHTdGkKt27p83n7tr4vz517d3n3R9G7mObCiXgueJ4vcEDf+5636HeVZQuDwTA88jJ6aJyYjzfZ9g5qPEUYArm2hvnln8Q8auh5gg+GT0yZ+AlO8EnEe3X1zm7fJTgc037258gqC8HJvBx2voL7JOBhYjMc6sG0Rpf85Zfxwi6zwjKJXYYoIT9oI0ZjjOefQzQbx80R9/f14B3GKbM45tSZBMd+sDuhEALfNRnOQt64OmP3Wgdnaw/XmuEHh3xzvMlMOJiWz+bakPWmwJtk2H/uqxiXL6I6Xcb/8zW2h3WGxFTliCJT6nQoMIM84Ur1C4xN3YtoObEYhKdQJJxTNxCej/HYRXa4yCCvU3NzivmU0URwr/wkmbQwyJEiZ83tUzBjVpcyplsd1PqYflZhZ0eTlHnU6vIlxZVvV8jCDEemzDKHYVwgVZI1t0tTHXLPqBApmzxftCPQDTYl8tJF1GhMOpyQez7CylCzGWo0BsfGalYQkTxe2c9Lxee6rLmh4mCgiVOjsUhV2bZ+/eBAV1SBTs3oKI6kc/7HWOn8N8bdHtKXNO2AQeAymhpMnAbu5iZLS/Kou7xkZaVCvaZJU68PxdKjo45CLHpXhXaFneqTnDl8hZ3ak4SB4NqkwoXSPsJ3UN0+ycY61wLFOBwTpxlJmpFliiTLkUJQK7n4lZwwdnHrM6bdEm6S8trwAqf9HTbrASCPD8iH8X8xTb2tcbxIQWpXZE1O7m+w+b3oXeaC5yhapMjabX2/2bZ+zTAWKeAw1Pel4+jzvbcH5qjD0su/j9HZgzBEBQEqTsjubpG9/Q7ql/8i1uee+0D7fYITgnOCE7wnHu7qLYTQ7RJoMauc1c0r376J+YU6laq2cn+vbsQ/DNxPbJTSfxeLWuwIOYU7r9GfhcyapxAITJmRug7KtVGdHqs736b6Y3+eIJTHZn0ASysZUxlgWe8lIpLs3JOgxuSDMU8nNwn9InFqMM58UAFu3sWzDrDKNsSWNoeTkpHdYLf8BJ2tEJ8Jbj7lrHEXg5xYWbyTnmdcWqPhR6y3D+hGlyEZcM7bxXz6CVRvwJ1ghcArIE2DQj4ibE+45TyFcgokyqJsBnhmjBSKz9bugHLYDqsYUYw4WtULoc9lrQZRsYFs1DnYU2RFWHH6HIQ1cgVOMiQ66CBaaxRaLrOZnuCkXKQjpNOA559DvHFAPpih4gHKn2DUKsiNNcy0gEwW3kKGsUhxgZ4o59GGuXbDNBfPzbuU5/lCZDy3HZi4S6z8/M+y/I23Odju052WkUZIs1WkV7nIxCxSR0/AjqMnZNBalt1dXdJ98eKjr+sFyZHE555ge/+QtTd/hwOWGckqV1Gcza/gbKxwcOYyg1nMJIjJshxQ5Eo3qs9yRXcU4FomS2sho65LbecO8dhk5i9zb7bOIEv48dUdTJl9ZP+XeVn9/a7I169rInrq1CJV9L3qXRxn4Z58eKgjO/3+ooN5va7PY6GwOJ+DgW4RUbp1j+mhD+Ea5ahN08kRhQIiSch7feL/9J+RrRbGSSTnA+GE4JzgBO+Bh7t6jxOX/aAGgAC8qsXS+DWKjXPIT5AA8H5iA3rV7/sLDUejAd3bY/p7IaJUpGyFBJlFmuvhoOWOqa4MyPanXHtpjCrp2Pm8A/QkkMiOIMtypPngzDcdG3Q7gigOMayMxtIUrmXEkaRtnMJjgm2E1OUBk0AggymtLMHu9TgMC/TyKoeNJ6gMvoM5CTg3fB1RKRPnJlfTTYb2ErWKYjO5y+HjP4X5+GXOtabYpS8gmg3ab7eJvnmX/l7OanYDx07ZrlwiwWdMiZoZ4JgJBSNis9DGlhmDkWYVk9Rha1+TwHn05Kmn4NYtHYXJOltMRjnFYoSXDlDTGWxdpycEqTHEe/s7TNcuE1rV47YMjqM/K200cJ+uoboBZnUT5zIYbzUAiRzq70oSTRrmpcZS6klwNtOTshCLaMrcqG461RP0PD2yvKwJTqejtVLtNnTtdZb+91V63x5TnyUYjsVBUMLN5LGXUbWqr5lWS3/X7q4+13t7mgTcZ1v2AOYk550uhLnNtnGWjeQmFik9o8Ud8xKn0in9yYyJY5BmOYYUpKniPpUOWa4IooQ4TVFuSLhZoHDlAH/SZ9d5HKUUf7RzjifyN1iufjDDyvfCw67IQaAjUaWSJnYfV+RVCH0+lpf1OZx/11wI7nn6uDuO/lkRY2aDQw7TOiKPSAouJaHwCI5CQDXUYEDy9T9G/h9/5UST8wFwQnBOcIL3wMNdvaVQeGZE0xnjGgkqy8j3wk9ML5jxWE9Mc+3G3BxuXibbaumJr9uFPIpx8oBT9SmGIelEJdLcYNkdIAS00xa9oIoZxhhljtNUAAXXouK79MYB5YJECIFSsL+jUzRBFFOohlh2yjgpslO+CIMUCoqK0cUTUwDM6QRvf5vIttn/728TmDsc+OdYe6qF8fnPcvbqDukrEHVGXCt9joG/Tr0Ycy65zr59FuPSRc49U8N1a8f72x6YHIRlVuVV6lmHg/wUe+kSka0oxz0sz6BgxNgy5UyxjVKKg44NSw1yVx+oeRSlWFyYG4ZeA+OChXGvR3cUk03GrCT3aJVmtFtPMRNlSoeHWKOQ6eazUC4ft7GwLE0ibFsS+AVkq4BcAnll0aMKdNQly/T/3N+4dO5aXCppzUYc6/NqGJrkFIuLKriVlUV11Tw60O/D8rLk9JMVtrZ0OqteX6RFej1NZlZX9Wvz7tr7+5oUj0Zaw3KffdmDUDln9/6Ya0jiS59hL91kw9zFpcQ+y9w97CBfu0b63DMIKYjT/JEfkwN5pi/eaKmCaSTIGyGnZm/TS5aJMp+r9Rc4PLvEc6u1j3qbHONBV2R9/1y9qqN2y8vf88c/AN/XpCrP9TEfDvV52dvTrzebYMUxftjHiHTJYiQKbKlTnEmuYuXad0AZltYHnTTY/EA4ITgnOMF74OGu3gUzerCB5SekF8zDAud5r6L5ar/V0oPpPP0gJZy7ANmrh4ioBL5H09HK1DCz2Jo2UVEERs76hqRy9sHvE0Kw3ioxCSN6oxChTEZ9D0lOnOYsb0QEMQShondQZNq6zPLsOmdGr5MWPXLTwpmMqO1tI4C3ln+M3KgxSpucGlzFeu02F/7S08gv/B/kn32O23/UYzi2qBsjztvb7Jc/i3HpAqc/2ziexLMM7rzSZedP79FMdqk3JX2e5MZgHTWdoXAoGAH2LEH5Nk+1bqFmM/YODYRXId68yNa2pFRapGOefnoxAQ2HoAplNr9Y4NbXFWnuUKxHVFsW3UmBaVim3Eyx2z3U7h6Ui0SRxHEWEYH38jq6P9Vk25qYTCZ6wp33FB4OteHfnODY9iJNZZqa4IRBTrjTZTULuTkss0WJel3S6y06u89dstNUE5tGQ3/mcLioDBJCk5vVVf09QujvnH/Gw1CdLmp3l4tLJW7mDSKrzNjLqVgBZjrgVqHIqJciOlPSxge3+J02mlBXzDoR6czBLFQI7HUMafAHfwDPPquJ2veK+X7Po2D9vn58FFfk94OUuppyfX3h1zOb6WOrpj6uaFJI7+E6CiNJSWcRyXSEmR0px4XQ+q1PyKLqk44TgnOCE7wHPum9YB4mNnGsJ7v5pN9s6pX8nNjcXyar8gbqvn1TCO5Ol0hzA4XCmx6ycd7D2XzvlbJpSNoHBrMABAGlSsrahkm9UuDO7pjegak9ZcoloifrzO40KPa7yHSEPxyQmf9/9t48vLKsrvf+rD2ceUjOyTxUpebqaqpnuujmqmC3NDQ2IshVQRpQ8V4GeaWBC1wBhSu0iFwFLsq9r4jyoAj6XhAQwbYFEbrpia4eq2tIpSrzdE5Ozjztvd4/VnZOkkqqUlVJpSpZn+fJc5Jz9j577SF7/fZv+P58PNv5U9T9IYqyjYQ9hWsZdBSfo/5wDe78eY6bVzN7tUubnWdvR5ahzCGsWJSOTmORgNvxYy4zT48Qq00TaIszi8FwIYlpCbL+BLHaNFbQxgr4aS2dJjg1iGP5KLReD7t3U7USMNdfSErlBQkG1TGWUj155/MQM4qEqjO44SBmKEBVqjykqFlCInCjMax8Gr9TpFqNzB93aBgLHl5Zt2W5UKvjZsvYAUEgEMYwDAqFRqJzvd4ob/bea2tTHpxSCazyLJPPjRGsPEevHKTObkQiQfzFvaTpnjdOduxQ3phiURkwXgm61/4hHFaTbltboxqrr0+1kJieVp8v1ZPxPJ1G0M9uMcZEuYmwqR4EwlaFpD9Ltm5QzgaQYRs7UGPVCIHTGgBXMJsVtERnKZaiBHw2jz+uDJxrr12+1Pp88ZKEvbyZC1FFPh8WlpqPjEAhH2RioIWxWQezZpHIn8J2q0jTBNOnHrSExJ3J4M5mMFF5OLqkfGW0gaPRrMBaNa88H1Zzs5o3bFwXmc1RLdawAja+pigIg0RCTZyeABmoJMqF/XEW7ltqsEA6tA1sEPUK24rP4m8KYh/6T8vu22yhzJFTacaGbcK2n6AFoeY8xWqFqWyVVNplasqg7kh8oQr+UJUCLfQnkgRzs4QzKXqeeZJT4WtwLJuSG6YlME3CXyDopskHwzA8walHc0xX4iSSBvv3xzh9OoaIq4m6qakxnv5+KE3nqc/miMUsYnaRkWKCbDVI2bGJWiVClotVLWLt3c81NyehfIDT6ShWIEa1ZjD0nJpsvATfgwfV5A8Nob1IBKZTEscVtIaKNPvyBMwarYFZXAkVx0fN8OF3swSMChVDGTi1ufl8aS8vIUDmshgjI7ipOJXpFAxN4A93IsUuisXAvNfHU80VomHgGIYa78xYkeapk7iVGtWmOEayk95CnsEJh1PfTBP9KZtcoI2ZGRV+sSw1YXutQtrblcdmYkIZM52d6vpqa5vzjJ1ShtHAgErOXZp0vNDTKUJBOoKZ+c/K1TrF9DStosqQeQ3VfADXNfCHFnhCV4EwJOHmLOWawBeQBENRZtM+0mn493+HG29s5JhdLG1tyntzoarI54tlKe8cGLTSzujfPEMhU2fa14702+TrCcK1NPHgDC1GGsO2cY6fxHre1bijY+eUsNjKaANHozkLl7IXzLn0dhZ6bNxUiuqxfphOYTh1HMsk0hkifP1+ptPziiHzXbyXo97azcDzfgHn6HFkKk1baZy4v4Kxs3fFfZNS8tyJImPjNsGARSjkEoqVSWVrICGbDuLWBTXHIdRUwLQW5FsIQSnWhCg7jFh7cEyLkJEjKcaxHItoKYdwHArSZqS+jdlJaNmh8iQGB9VXxGKLwyRTU2qiTk1L2tw0XTGXkUor05Uobs1BSEnELGBZEiou1+7IYrZ3UatBtTTX2XpOsiUUUsaIbStvhtdXK51WRk9PDxxLqdyIiDsyr/ViCIkhQAiXUsUmYBgEIxbGnMeltoLDQmZncY6fxFfOAU04th/bdLEzE0i3maq/CSFCBIPKw1KrKSM1n29UXBmGizkzhb88i9OUpGgZFN0C4WgFIRNUptNsO/Fjclf/PBMTBs3Nylg5flyNoblZ5Z8Eg8oDmMmo49Daqv52HHXMBwdXTjpeydMpJUxn8ljZWWZbO/B1u1RnoFr0IR1BIHp+YZa6lPgCWUyrRqlmsWOHzalTAr8fHnlEje+qq9YmSfhiVJEvhtaru4jd1k3+b77OqLOdqhlkxtdBLrAT4Y6SC/ZhJpvpGR7HfPoZnB8/sqyExXLtLLYi2sDRaM7BpegFcza9nfxEgclr70AkVCjMmU5Rf/RxjHIJEY0QDrnEnDSjQw7Z6acwb7JJ7k6umCgppXoSL5dBJJJEXtxMbzAF5bPvm+vCU8/UGZ90MExBLFHC74fZQoVqTVLMxMBxKNccwoncshNNvWYyU24lZEzS7E7gtyv4SkUimRT+cglXWgz5DzAT9JN0Z9i3L87wsBqz1+LCo1BQCdPj49DVCcnTM4xmexkrhQgVBpmpdhKQFWw3g7QtmgJlmttUQtHJk41jMTysPBpe9dKBA8qA8EJTUqptFYsQTvixpk3I5xGtLiDIVJVrzCfq1IpgJVsx4lH88szJ1vN8SNdFDg0hC0UMmQenjFPMI9xxrGATUtSopbIUiwGCQZVHMzurckK8sBlAZyhLqZSiEmzCQDBbDTNViRO2JmkN5JiMhpnsHyGQ6KcUbiMzE6WpWeUaQUNXB5TxksmoydvnU581NSkDz0tKjkTU+wMDylCClT2dtXwJRseoBoNM7tiDMCGSzJFPRalVbFzHINRUXOE/Ynkcx6UiyoTjM9ScEDt32osSdlMp5c1ZK8XwC1FFvlis3bsJ7OxkR3EWNzfKDDkwLOyYn3RiO9LvZzDtwg+maC7ZtPR2IYy5C+0c7Sy2GtrA0WhWwXr2gllObweg4GtiNL4DdzqNcfQE1guU9oo8fhxRLhFqj9DizzJcaqVIN6JFEkiP0Dv+I/y3/DzzwmgL8NoQgLpJ79ihqnvg7PuWzytDIF+qUqxUibUUyBRBFtTkX82HAQeMCpFkadnvqJVtyvkABCWBeInk9AhVJ0jT1BhGrUbZH2Yw8DxmZZJYdZqWEwMMPP5yzGQXhtFQjAVlgAwNqXyJjg6IxaKkm3czeyqHrzJCyk1g+iQRSkjXhGKJq+oP4ZYPUC4y307BC0NFIo0O3S0tKiwDjfBUW5sK+RmGQWJ3knA/85N5pW4gqxXI5TH8PdQ7e0EYc16dhpHkaevAXGLu9DSy4hCqpSAIpm0iXAu7kEH469SL4GZyBGMqAWR2tuG9Mk1Aupiz0xjVEmmji4SvRNCskvSpnYqXxxmfDJKeLbHnh/8fJ0PXMPxsgujP9dLV3c3Ro8qYMYxG3s30tApV7d6ttjMyoozKalUd65071fmuVJQx4RlHy3k6a65gtqWd0e17yCda5q+5SDJHIR3FqZvkUxEiyQWqx+fANA3qjkOuVOGaq+tQt+fP38iIGueDD6prZdeuVX/tKra7sirywgrDtUAEAxjxOHR3YyFpq9cRlgWhEEkxSzVfYQQf1ZxLJtbDbN6PbTr0hqYwhVxVO4utgjZwNJoNZqnejiMFJ/MdSgUNMGJhnFQaM5tDANbMJL3tOaxwleNZ1cLYNFy2hycxrApyNHXGjW2hiiucPXS1aGwLvD3FSpWyyBBqzmEaJpZlkJo0yeUEkjrBWAnLV1/2eyoFP9WSSh4JNxfJmNtoyk/QPDaM6dQpBuMM23uZlS1ExSw9nSXyeZPCT47Tcns7e/eai8Z04oQyuqJRNbmEIwbp7XvJH3+aWkVQCUWIkcUnS9Trgn32CaxwAOfRxxm8qlsZIIaaFJuaGhOUpwbs5aek0+rYdXWp3x0Hevc10bX/RozHXdyRUdxiBkwL0d6Gr2UnRGPzasbhsErW9do+mOac0VMsQi6HJEgoKImJHAaOSigN2pj1KrWaoFqoEmhSY/HE/4QAZlLUjx2nOj4BeT9GZZpweZJAU5iqa+Nmp3GPnyBUaaVoxyl17CTkmhQnppj55gDNd/00ra3dTE0pg6WjQ70ahhprOq3G3tmpjrPnqTh5sqFg7PVW8sI1Sz2ds2WH05MFao6cv5a98StPTgQpBflUdEWP31JcKREoDaZa3aWtWV0D/f3K05JKqf04dUoZZDfcsLZeluVUkU+cWF4V+UJZGPITPV0YS4obzJlp+tqacdIjZKN7SFX91ByTsuNrVHmusp3FZkcbOBrNBrNUb0dKAVLlV9RdA2HZCKeAWa+yvbOMI09hBJVh0x7MEDSr2HPdj+WSG5sXgiko6Rn8fnUjXs1kUqmom/jcKPFFZvEV6kRMH8VKjdR4iEqtjgTCiTyGIZf9nuJsCKem7vyRRB5hSPKJFsZ27qdpYoya9DFubGfG6CRk5elMFCiHmyngh5k0XaEJoBGbOnECalWX6kyBpkCZba1wejzJZDaI3w8ZoxNfvUyiNkbWThANVunqDoMVZ2Ywi+zOYSXi80nY8XgjD8czZLxjBWoy8wT1yuW5Tt47upDb76I0ksY6JTH9NkU7RsRRvayqVbV8KKQMnHpdTX6exg6lMjg1hC+CISQmDgKJi4EjbPyiSs31kc86tO5vnA8Af36K3KOHcUoVjFiMjsokTsmmVHApV6v4DJN4ehS3XKFDjDEQ6WTC6GZXfIITVjuj0xB9+DESr+xkasogHFZGjesqQ2dyUnlyfD61r57nyWvxceoU9G13GXgyx8CjVfbsBqtdhTUXejojxQr+zGncSg3pSJZeHZFknmImNOfJiRJJntvIqTsS0xBYpoltKQ+lZSnDdHRULROLqX0oFuGHP1QGSe8aC/+uVhX5QlhVccNN1yP//T9odtMkYiV1nxALjvBlImGx0WgDR6PZYJbq7ag2jOC6hgoy1etsD44R2QMQwF2wbMxeEg5acGPzBMw8+voaJeTnYmJC5TWA8vSEYzWeGigTDtq4OYP0uE3NqWOYLtFEYcXvyaei8+GZpU/p1XCYbLyFweBVGEgCokTYn6cWCJOtx8B26S08iVs8uGhc1YkUY09M0VE6SQeDHH9oG6lIH5FkiAkRx43G6LCrBESSuoxwsG0EYcWQjsNkOYiVSlOrVhkZiNLc4ZsL0alwnRCNRomeBk5vr3rPNFUuiuftEYbBrNWC0QqGCeVpFSrxdGNggXfDbLxaFmAEEKYFroOQdQKihAAEkpq0CDg5SmaAfKZOoDSNbScolQzqNZd4/6NkS3X8rXEcadHU6mN8zGDa7SJeS+GMT1LPZzBdFyMUwJ+MUUcgkPhMh2o0Qn7oFM3TKXp6WhkeVhN0PK68MuGwqh5KpZRxAOo66upShp6bSjH78GM0j08wWW7iuYdN9u6onVG5Ewn66GiOMjiZoe71jlhCqKlIORegVrGVkTNnAJ8N0xBEQz7sJSraXV3qWj19WunMTEyo/Tp2TIVlr7vuzAabF8t6qSKfq7jB6OrEOdE/n9htGY1k/stBwuJyQRs4Gs0G47mkKyeHGW7ejitNBICAbaEJrNmhRTerc2nzyO07OZZu3NhaWs4UaFupHN1xlIfEC2Xt2KEeHjN5F9eVZDIGE+OAcAmEy1graJpICYX0nHFjSCKJM/MsqqafUXsPCIOAL0fEyFGRQcYrcUJ+Sbc8ibAtzLDKGM3nIXVCifm114ZpaXFJm3upFPyI1DSpVJiCE6bJyNHXNEO+HqLJyhOw1OQ6Ni5wMxmsJx9mxO1CynailQLThV0YsRh9fQ3DxDTVZFWpKC+M1++pq2uxym02q15dt6EcHQyeWTllmsx3CzdNMIIhjGgIigZmMY8VrBEXWYRbR5Rz+FwL0xcnf6pMZeYJ/OGDFNp3MXu6RmjiFCK6H0eq27cZC2OUmzHygqZ6mlquTKreTHubi9nTRW+khCMrCAG9oWn6a62MFFpoKpWJtKlJ2FNPjseV9yGXU/s+OamMtq6uue7ltRTVnxxmolRhR5tFOB6iWDQ4daLEtqnvYN9yCBGPz19TO7uamMmXqMyunEwciJYRpqRa9JFPRwg35zHMlY2coN+mJRYmHDjTWgkGlcHR36/Ok5crlM3CD34AV1/dEE9cS/2Y9VBFPldxw6WWsLgS0QaORrPBuNJgqOeFlIYeR05lMGIRemMZ/PU87uiZN6uz3dgm/H2UOm/BwMCyVGLk0nvcSuXohQOHmETd/QMBpc3h2U+mYZAaD1Cs1HGkpKWtTMVxAOMM6X3XFRTSc20PfCo3ZynSFUzXurHCOTpnT2AGDGoESDttmEjarFGsVAq29xHubqdeh+Ehl9TTI7TWRvG1x/EHskwXA8zQjNVUJ5e2CFBiZ+0YuXoPAugOqnhTLZNjdrAOtk052sZ4aTvNRpbg9DDZDHS+oBfDaGFoSI3P05oxTfV07vcrg8c0ma9AgkbysGcQlkpqkvU8BZ7BZBjK6PE8OKIlidnWCmN5TF8Qqg7Uy0injFE38RlVhM+iGg5RDrbgmx5hdhYyvhDBag1iagO94Sn8Rp1krIm6FcONbyObLuEzI3RuqyDCISxcrLnOT6aQmE6VumFSMYKEUJ49LxTp8ynPR3u7MmgmJhpeqIDfpf5MP7VSnUBLgtNukj2xMY67nVScONPHT9J84suI9jYMv49qaxuTO/YhrXO7Df2hCobhUs4HKMxEzpQYmEMAIb9Nd2t0kXG/aBmhkqS9hPrOTuWZqtXgmWeUAXJ1cgQeW3v9mLVWRT5bccOllLC4UtEGjkazQbhuw61NrAXr+TfQOfwQ/onnkJM15Ao3q+VubEUzxnjiEMbe3RjJJNu3L6/VsVw5uixVOHFc4g6pEvPea5KLJvFaDUYGbWzTplqr0tZdxhBQLQuWZla4dYNCZq5sOljFHz5T0E26gnw6AgIq25sJHCtjzNSYCHYjTEm7cxr/WAoZixL/6UMIw+TEUShO5QlkJ7FiIfpCU/TnOxkvNdNkF5iqRMHnI1GbpGZFkNNpulrL4ErccpnB4zXAIL69iVO0YBqS5nCZSXsXMptn58SDuM7LqdWUNeglkHZ3qwnRNFUy8sI51Yu6+HzKU+D1hoJGGMv726umsu25RGPDwOjbhpE9heEGMUJxMGxEqoKoO/iCBgTDuBgU7Rh2q8CdqFE6NQ62RcApUrEiWMJVlTzhMVLlKGPlNuKhNEbcopZ6Gl8oeIaXr6fwHIPJmxgsJNiPMt4Mo9Hyoa2tkWQNygOyezdMHM8xPl2nJeqj5tr4jDoT5Tg73OOcGDeYdpMEZY5wcxM1V5I/chz71Ajxm28hY4UQqByalXwzdqCGMCSlbJBiJkwwVsTyNUJbAvDZJpGgTSx07szhpiblfervV/tULCqjJ3U6y/fvn+Tq8gSJOIgm5bZaS/2Y81VFvlBv0qWQsLiS0QaORnOJkVJV7+QXRG16eiCyP4l0X7qqm5V3Y6tPpDjRD9g+rFiU5oSxsv7NMuXoZcdmyOlGJiUylWbH+AMEbnk5Xon57KyXiyLo7rSoBwqqcaRtYhqCas3FEOBKqFdNSlkVTgpEystK8ksXZdwA/nCFejDMSfv5iBMlgoUcbaUBgr4Kcvt2ml50C/E9Ozl6VBkTlYJD2Cmxo7mqvFLCJWHnmK7GyNVCNAVy7DZOMbvvVkR6mlD2MO5sjVpdUDWbMDtaKPjjjGfiNIsMscokmXo3zdEaYmyYqeMZIEEyqc5PpQKW6eIWStQqDq29kkRzdP7YZDJqnzzvTjjc8NiAMmoqC+w7r9eUZ/yYzc0Yu018xRQMSuqVCrJcxorGCMRCuHWDWk3iugKf6WAEozi5aYz2JuITg0w0X0WmFqbFnyNo1ZFI3HKVRKeJu/tqpp/O0jE8cIaXzxeLYO7bDRhUKuqjXbtUkqxX5eU4Kqw5MaHCLePjEDHLJGWKGXpJGEVMwyFqFWBghJ5iiaHoAYbLO9hTd8kKi1KylcjMNM3Hn2PoqhtwpcQwBI67cvjJ8tUJxQsUZ8OUsqFF11HAZ9LWFKZadymUa0SCvhW/Z/775hKQPWmEgN9l4snjlNMZnmQXyewUV7lPYcbCiK5O3GxuTfVjVqOKfC6Bz3OxnhIWVzrawNFoLhFSqhutp70CKrdhocT8+dysJiYNMrOtiJaGW/5sZapLy9GnK1FmKuoum/QXSLRnkKP5+RLzwUH11AuqBNcVfjJVP5WaQ91xEUIgDIEpoVqwKOVVKCIUL2LaZyaVKuNGuYb8oQq+YBUpYYI+2CVpFlP4Qp2ItmZ2Xr8P07IYH1fHbXISOhIGLcEUVtWiakRAGqTrEWZLNkGRY698lrRowW5rY+/LdiHSu5GlMqeerSMOP0VTUjCacYgXhmgtnuS06EQaKfbaj+DakJpyMFobLS6iZJj94QByyqHq+mB4mMh4DeeQmni8JGyv83cwuPj4e54d79y7cxEXbxkhQERj+H/qZ7EeKGHkpzGOTGMgkalxgkYMIQxq1VGa20xMu5ly1cLYt5do6UnGp9PMxCIkLQcqFcL5CRx/AnbsIGsmsK+/FXPCXTZ8sastycmTqiJq3z41plBInW/DUJPvzIzyghQKalLe0+oDyyQqZ6m56lwHylmcbI5AyEerM86UkeR4pYuoOYRtmzhNzQSmp4gWc2QCEdwV/TcNTNsl3JynMBOhnA8gXYEvVEUIg2KljmkI6s7yHclXoqND7Uv/9wdpHnqCvAiTD7YzY3fxhBthd+YJYsV+RE/PmuvHnE0Vudsaxbp/eYFPrUZ88WgDR6O5BHiuao/V6tAsR7HYaF0AZ/aZWoml5eilOZG07ZFJfIaDdFSJeb1QZuBoI7/EM5ykVMmd6VyRgM9CAnXHZWpCkCu7gFwxQXShceMLVfCFqvOJyOq9GiIWphxKsG1/N6ZlkcstzqOIRqPEeptxBk5zKr6DYt6hNpvBqYVpqp2mWJ5EJtpojRQwrTi0tVIsgkjMYvgsZqYlM5k6nZXTRH1lJk0fUTeDnZ6gZAShUCTQq0IazmyW1qFHGMk3YQT9xGyBMILIUyeopdTEU6+riadUUuckFFK5S95xC4UaXh5Y3sABMC0DIxLGKWeRhQISsINB/IakIk2q+Trh4rMEkklKIkypbQeRl3di3DeEm0rjlscRts3evjpPBHYwVooRs8FIJuHGu/Bnz/QImjRyh7z2FL29KjHWG2c0qowd77qdqsbYliwzNlgk19RDLCwZKLSxzXkKaZrE82NUm6I4oRqyLDEMA+nzYTl1gtIhIwSGlKgr5ewYpiScyFNIR6iW/NiGTSDqUCzXEAaUqjWaOL8SaL/PZcfIDzhZLRJpDhEWU8wSQ5iCyegupot5+qbHMWOxddGPOUMVueJy6geDuDOtbO9NzCfDazXitUMbOBrNBbKauHkq1ejmDctXNK0W152bfOfug/G4mvhXy9Jy9K7QDOYS7YySGWVyUjW1DIcX64cIIehujVKoVClXHUIBi2w6hCUh6KsSTcwQ8FlU6s6ixGMpFxo3VQKhKkJAdq6E3PLXCUQqhPw+Aj4T0zRU3s+ICo+0zVX6dHcbODffxNCoSX1knGwpxKzRQRNp9lYeZyLQhyEg8qPv4MTVk+/gaRcpXeKhKsP9FQJmjXDQ5ZTYh0Cw3ziGNEyGfXswT54i0m3g5pupj05AqaxEFqVJq3+WiF9itKiJp/bQY3BATTxSqtBUrdbQjnHdMw0c77zNl5kvyOcxDZfa1IwqHZcSaRhYok5d2FSDceRsicD0MIXtN5K1mon3GIR+upPKdA6r7SBWOECgJYnxPYNaVhnP9TqMjRv09S3vifCSiwcGVDm4ECpvJJ1uJFmnUsr7kRmcIfXQBFZGEE0P4M6kmYruIBmrMyvixDNpRChEZ7dJNZBjqiJwXYlVrYJt44tGMFwBAkwhcF0XIQwc10WgSr/rrsQQYi5fSWIYkqaWvGoBUrfJpSWBWAEhBOnZEh3NkRUTjZdDTqcgnaLPHCNXrzBp95Bghj76OSV24wZCnCh00ROuEVhH/RhPFbk6muJYOoWIRBgq+jENlx3hCeXZ02rEa4I2cDSaC+BccfOFLRFATRxtbRe+vakpNdnAhcvDL22KaC6YG6SUjE8a5FsPYMWiKyZDxsMB9vYkGZ7McaIfXNfFMGDPXsiXQkQCPiRQqtTIlSpUKg6pCZWX4wtWCYQqmIYgnw6ric1yCUZL2KZBMh6iVlcKtcNzfX88g8HTYyk3d1O9zsfE/ceYkQHCbo6r6oeZbL4KI5FgZ0sWdzRP/eHHmMlIaj/sx58eI513yFRjdNYHCTgl6qHdBN0cgfwkcq4tt3P8OEdSNRwRoakwQimRQCAwhMRn1GnxZ+cnntxwGtmTI7EjTjqtxlgqqfF6c24otLjKaiUPjpRglIs42QK0tSPS01AqYQaqWMKk4tqUCGE6FURzgmJRGdEtrQajtTi5WHy+QsfnU4aplMq4Ots14vc3kp+95p1tbQ31ZilV5U95PI149lnskmQ63EfTXhDjZZpypykX/EyZnUREEd/unYhYDJ8Ev21RKlfxZ2ao9fRitiTxZwrUHZd63cU0TGzbQLomwgAkmK5LOODHlS6zBVXWblsGbV1lZqfDlMpQq0fY3ueQLVVWnYczf42XykhhIJpiRGcnCFslyiKMiWQXx0kTY7rqZzy0l3whSd8yvcTWErNWZif91Jt7GCx14LgGLgLT829pNeKLRhs4Gs15crbGmNmJElPX/JwKD6CMhI6OC79RlsuNvkigqnoWVjidDysppMpyheOTTYhAHHPvbnbtNs4qiBYNBjArfra31RGGZNcuCPktnhtMkc6ViIV9+OwAsWCAgQEDy6xg+Er4QxUkUJgN4rrqST3cXEBKVYbuuC6GIRg8ZWKbat9jsYYAn1d1lqsEcHxBDDtCMlglFu0hTxdNviK2KZHJZupPPsXwQzNQqWAzS8HcRtjNE65nSRVixOQouzkGwSCTtQTU67S6Y4z7bwTHIVhIMWEkEM0VupqKNPvz+ObUovH7makIZLU6f5zC4Ua+jeepWZoPpQwcSalawym7VKomYOG6AsOp4joSIxkBv0Vn+knKxQmmRCt1w6DU1IVhxSDgny9J966DhT2h9uxRpdDj442Gk174bDm2bVPhktOnG72burpU5ZhtQ73mUjl+mnB1hmLTDhzXJGV3sWP/GEMzbdRSRUTE5rTVw+7sc0jbAr+fmHAQqSnKwRD5/Vdh2iZ+26Redwn6LZoiQQI+C9s0qDoOuUKV5kiQgztbmcgUeebUJC4Sp+4ikcRbC+RTUYI+m9kpg0giR71Wx83Nrrp6SAQDGH4f+FtwS2WMXJZQsKbaYzgOzblTRIXN6J6XUqkYHD3KitWIa4HnUfVVi+yJjuFIcYZHVasRXxzawNFozoNVNcY8doLobc309BoXbNh4zfw8wbhIRBk3F/tEubTEvJLKMyi3Y7Ql8V21iz2HkmfdRr2uhABB0Jq06V6Q/+iFr7KFKkGfxdR4EKhjB6v4QzX8tk1mxqJWVUKGsdY8grmwhSGoVF2sehx/xJrXYmlra7RMOH5cbb9WqjFbj5CM17mhfQwDg/Z6lritMqLdSpXxURfpK9IUq5O1esnWW+koPENEzlLwJWnx54js2o4cGiZXj4HPR1VEEZaJZQsI+DFqZdxCjq7ODFF7QXlUpULFTGL5fBSLytvheWtgsS4OKO+O40CxXGNossiMm8V1HCZPGzhlH9lWMP1BhGlg1iu4wRDBfduJpOPMFJswDINyQBKpzDJlW/Odzr3z5C7It21vVwZOoaCul3pdGSte88ylBIPqe2o15vtnxWJqnXod7NIswdkxiuEWknaekmsylQ9ilyMkA3lSLVEyBR8tV/eSStm0pJ9DpmewbZvIgT1M9O0jH43jlmr4bQspBbZlEPRbc40zXcoVh0jIx46uJkzTJBbyEwn68FkGIFT1lRB0t8D0hKBcdskerSKe+Q6VqYlVVx4t8mDu3oU7OobM5sB1lBS17SNw8Hlc9XO9TE0rT9bp0+p/r6dn5f+JC+VcHlWtRnzxaANHozkPllYiVRyLwWLrfNZksMlHV+5xgoGdCHFhcXNPJAzU5LNz59pKzHsl5umTM0yMudg+Hy07orS2nT2RcaE3ablcovnw1cRc+ErWCYRq+Ow6QtgU8haG41flxckcpmmAlNRdCQiE6ydkh0mlBO3tyrBJJBrHxKummp4JEbMKPC84OP/E6xk3Ukrq/QNkaYVwCOwqFQJErRIRX5WJSjdISUflFKLcRz4vwe8jVJ7hZOw6sC2afFmq4WbqBYtwaYZINQN2eP773dQMIrEXEY+SzysPSVNT40nfMz48w8Pvh+mZKlOZEqFolY6ZaWJHnqE6miBTj5M7fYxK4mocy4c7M0Mt4SNXMbD9YDgBHBecXIlYX4RwS5BSSYXDQiF1XdRqalsL+0Z5SeeZzLlzvnp6lGdsaKjRsb2vT53rSqEOdQd/TCLKBZyZGsFSDcdJ48ppZLiXmGFStvdj3PAztEQP4ndKiKDKCYoJQVe5Rt1xsUwDx3EZmc4xWyzjVuoYhiARDdLdGiUeVp6KcMAmHgrMewMX5tm0tFeZeCpN+MQAp7HY1R7HDNqrqjxa5MHM5jC29YCjJKjdXAGjJYH9cy9GGAZtbeqcnjyp5Byee079H/pWHxE7J6vqOaXViC8KbeBoNOfB0kqk2VoIJNimQ29oCsOt445VLyhuXqmoScV7+l8pD2YtOHXaoFJPYrSurkdVPq9KW+HM0vaFxEIBzKqf7e11whGXjg4YnLQYGi1TLVi4UtLeWabmGtQdB8cFyxS0xqLY9STC9c1Xl+3YoV5rtYYqbL0OdsRHokXQnD2NjC1pV1EoMlRsBcuizZdmmi5sWaGlPkLYKpB3gvjKOUS9iFsqMSY7kZUqHdYkmSaDqlnFb7qkI72IaoZobhyZq6sDNDfx1MNNGHt3E4kY5PPK2GhqauTfSCkpV+tMpurMFgSGTzKRLuO6EC3nSTz9AEa+AIEOHDtEwbWpjI1RNlrIumVqxTFEtAz+GuVyE7ImELEA8VsOEJ41SKeVpkoopEJTnvSAd9z6+lQy+tTUnPdLumROzhA1i8uGcjxjqFxuGEqBwFwZu89H1Fcil5sll6oQqWWI+/JkfS2k3U56Uo8z5N+DUS4gaeF0voV9+xZ7GpfmycTCfgoLjJ5wwF50Dhcms2cLVUIB5e1xHJdiqcrOiccQUlJo3cWA00Ifk9ghY1WVR2eIZNZqCNvGumrfGYKaPp9qvzA6qo73yZMX13phObQa8fqiDRyN5jxYWonU5CuQ9OfmPQnyAuLmUipXuKceGwyq3Ij1SHBshJjU9+/Zc+7Oxws9SmfLSZBSlRmDoKPNnu/5kwjHOFkyscwaiZYCjpSYCCQGIb/F7p4kTq6ZuhS4Qo1nz57G9/b3KyPHMJRHIpk0eP6NrTjfiZzx5FsdmqRqxhF+g6gzxZTTSnv2ONHSFP2Bq8GVdBWPQsDGyRVx3TBGJECl52pCpoXhqpigHTBxIjE6ajPIig85Nj4/8WR2H8LwJWluVoaflF6SrqRYKzI6WaYmy5ycrpCb9RGerZCf9eG6foyTJ3Eys2SaWyhUoOq6VEybSjCIW3apBvyU7BjhQo7m0gymaCET7KF8dTf2tg7s59S2ZmdVblc8rgycVKph4PTOlbrPzMCelhSlB/sZmplmFydWDOV4eTcjI43KuV274MTxKIXmbbhHjhJyXdxQhKwI0so4k0Y7w8F9tLhTzEyOkW/tJRozOHWqYZwuhxDinMnBnjdwZGqxt6e1XqG1kMXXGWfWyjFVjjFUTLIzMrnqyqPzVf/t6lKexFOn1DHNZC4syX8ltBrx+qENHI3mPFgaN59PPOXC4uYLq62EUBPDWrrBF5LLqQkMlAemq+vc64yNNYQJd+1aOVTWMG4aidWgvFKzqQDdLQZmKEuhalOrq+zbeChAX2eciZEgUipPSDSqJlgvQdfzGmWzauxNTXD99WAnujGWefIdan8+hpWit3QMkZllR+XHGI5D1Q4hLRvDqWO5dUSkmalbXoF1apqO3DEmzAMA+IwaFdei6loE5QzJQ/uxXvgCqFTnJ57ccVUHLqfTuFOSoBsgM+sjW82Tq+YoFUx8oQpIoVSeXamE6fI53FSaGX+Ies1RJdL1GlatjCnKVK0YZrnEdO/VZOwOkqEM1cpOypkA0+kSldFJoAUwFuX7gDJ6PLxjF3SyuI/9hEwpSEssiEh0IirLh3K8vJtCoRFisywIBA2KnZ3En/wBs0YLFdckYDgUnCCiWgLbh6+9A9JpIjJHqRSfv9YuNBneIx4OEAst9vYEJsepug4E/DQZBfxmFVcuMARWWXl0vuq/gYDy5njilydOXHh/qbUYj2Z1aANHozkP1ipuXqspl7c3UbW1NfJN1gPPzQ6LZeLPxsBAozJo796Gp2ep/g/JJMeOqw8XavPUao0mjvv3+AgGkxTKsUWhiZERgZTKA9HSogwYL2RSLCoPyfS0mjD9fjWheMdp6ZNvSQQx883w8CP4ho4hqzWMShkCAYYC+0BKerNPQziMkUxQHMtjPu8AkWf6GZtO40ZjmLZBthjALeRpjtSwDt2E2bE4JuFMp3CPHWcqM0SlHMQ0bDJ2E4X2GLIloPJgrBpM1zEqJYJUybgJLLeKcB3qlo2vVKQ7+xxZt5VobQJh1igEI5huDeHUKEZjRJ0ZjJPPEaomYHSG1PAwJPci489DykaMcK4IaFHicWeny/Bzo6SLfvzNIYRdZtaJ0nyWUE5HhzK2x8Yaxu/27XBkKES2eSeWWyVQyuNziiTlGB2xAKcSz2fC76cve5ih6vPxR1WYa2Rk8TVzoSz19rjB4CIPatBc0g5knSuPtm1rCG1OTalr81wK4pqNQxs4Gs15cjFxcymVV6JQUH/7fI0y6PXAdVX1kWdI7d59bte6lHDsWGPC9ETg4Ez9H2ybk9HrMfbuoWlHct64cRwVJgE1WYZCIF1JaEFZb6aUJJ8X5HJeIqxLm5HCOa2MksF0kkrVwOdTBk4yqbw3C1n45Dv8HAgD9ry4F/frUeoS8AeQjqPypqSLHTAwD+wnH+nETaVovnkvs7e+HOPRAZzULDJfxQSMpjY6X7wNs6dj0fZqgyM4jz6LWc5TiLZQCYRxCzNYmWkS+XFy1i5kRbBn4EFmMzGoS6IijYzsIBNpRxomwXyW6Mw0siYoR6LU7CCuMLBrVaxqBatcgdk8facfZaLaQ94fJ+9vouAvEpo4iT1tUI7vpborgc+njsvkpDJgvZytnbEUg9k8M75OdltT1KTBdCVGs6+wYiinqUkZONmsMlKV4Bw0JU2mQyEiET85J0zdcQhFQxAK0VarMzlrMiS20xHKMp6Csusn1Bbh+HGDffvO94o9O0s9qEsbiV6KyqNQSLW3OHlSGfHHjzdaQWguL7SBo9FcAGeLm6+kcJzNKk+Kx2qSey+GUknl9oDyfpwtL8LDdZVxA8r42rmz8dlS/R/8fk6kW5ATU4QLk7RvvxHoRkp10wflmYrFzjSMqnaIkejzqO/YS7gtgZtKsXP8h1RG1ecn2YVsTlLu2cfpTDPNzXDjjSt7BDzF4FAI/Nu6qd1yCOf0EBKJqNVpN9MEwyZW340Y8RiTs23gZGgL5emv9GK9oBVjdpbyZJZq3k8oESK5b7GbS7ou6QeeQZYqJLoDTFf8FEp+TMPEjJmYmQLR/gHC1RrR8hhT4TbqPhPLrRLKZTDLNeq2j/jIBMJ1KYWiuIaJdA2koeTd6oZNeDaNmAW7VKISiyJdg5orKNlx2npcgqdnKRwbIXOgibZ2g6YmZeCkUg0Dx3bKCNfFP9cTzJEmPf5UY2dWCOW0tirPxMREI8zYub+J9EMJshNTxDsccvUwk2YX7WKWuJ1nIp2n5oL7Hz/ArSSwTJtCczvB/X1MJZK0rmHk5XKpPPLENr2w7/i4OmaryWnTXDq0gaPRXCDLxc2XUzh2O3sY7LoVkVBPlRfTrmG1TE83mkautu9VrdbwuizN0Vmq/wOC/nwnwg/hsEt76hnqD4Po7OT4CXWHb25W4aSlhpH0+xlKt+CMT+PMlpB7ttE79CPcQgYjmWDWSCBzQcbHoTQ9SnCbTWtr5KxPyF4ek5cga/Ztx+jbjrAssCwStgWhIEII6q6BrNYRlonrD0AF6tMzcOI4hak69ZqPyGiaWrGyKBlXTqdIj5YR0Shx3wzTlThV1yIgpWo1EAwSnJyk6g+Qa07iShtcSdUOUjaD+AoFpGViuCqeZDp1sCXCdfDVCsigSTHWRDiruniWI9F515mUUHMgYDkEYj5mZirMDmVpa2+an1AXdTIPBmj25ZlxAuSdAFGrTMy3wJhZIZSTTCoDJ5NpGDjCMOh8QR+j/5KjMplBhi1mXT9JpwQjI2xPZzjddCNjdh+72qbpn4lhTY5Sy80wxfXE48k1zSu7nCqPolHl4fS8pMeOXZwYp2Zt2VBbs6+vT3UkXvDzh3/4h2ddp1wu87a3vY1kMkkkEuHVr341ExMTl2jEGs3KeBO5M3AaEY1idHcy7ttO/wmoP/ITjMw0e/eunXEjXRd3cgrn9BDu5JTyHM15TzzjZseO1Rk3pVLDuGltPTMBean+z4l8J1JKgvUMnbXTiGAAZ3iYY4/lkFLl+LS3LyOMGApystiN8PspN3dil3I0P/YvmPkZjJ4unECY6WoTZStKuNkiX7Hxp0a45uDK3aPHxtRrItEIpYmWJGZPF7JUQsSjiHBoPpwxUmpG5vJs2yYYryZxUyncnzyOOzGF6bcQ0QjJWA1n4LQ6n8MqM1uWytSqAnw2AknIKhOzC4ASdPRTxahWqds2UqheTEKAgwUI6n4/dqVMORSmFI5i1qs0l8ZoqozhBmzK4QjVYAizXseoq1wdS1SJihmiZgavgbawLaTjUis18k8Wtn3w9n/3tjKyVGayrNw6NdecW0aFcozu7mVDOV6O08IeasmrOjBvuoFqay+ttSHkTIaBdBNIiZ2I07wjhvD7Gau20tVcwGhNUC/XcI+d4GT/+XX+Xg1mTze+V96F/5d/Cf+rfxH/L/8Svlf+/IaUVRuGCll5BuHIyOL8Os3GseEenI985CO8+c1vnv87eg7T953vfCf/9E//xN///d8Tj8d5+9vfzqte9Sp+9KMfrfdQNZoVWTqRF50Ao/kEmCBaJF2ZZ4iMlhD8PGvxXLGcp8jp7GWw8xaMZPKM3JmzsbC6aqWnz6X6P5HKFHJqitZsP47rgDA4be6GHVMEkvF55VfPMBKJZigWSZeDSLdMzmwiZpXxBSE6fAzj6qsQQjCQb8eVAC6DhU4S4RmurT0OqQQsU2Xiuo0qr4W9vs4WyihP+BDBAJFbDjCWA/fYcSiVqCVayVfiBMwaLfEqIr4kGTcYAMtE1Gqq+WdohkI9wHQ1gFMvEqulKQPSUuc3aY4BkhlXJSZJ00IAjs9PIdYEgOE45M02ClYCx7Gh7uJaqlO7Va/hs8rUDR+u4cOYO5miXgcjCJUKzukhRDBAojlJKq10eaJRtf/xF16LGJzEymeQdoVxI0qPMXrOUI7XjyqVYlF4qe/6JIOJZjK5q7CrVWS5QuXpCUJNftoCOWarEUp1H93BCj7TgWgAJzWDmc0xOBhn27ZzX4vnw+VWedTUpI79iRPKm3b0qEpKXqlNhmb92XADJxqN0tHRce4FgdnZWT7/+c/zt3/7t/zsz/4sAF/4whe46qqr+PGPf8wLXvCC9RyqRrMiSz0co0X1GBz3FWgLZJFWcM06Ay/XCyubNxk/IREjP6H5xdfQec3q1MgWdjs/W07QQv0fWa/RerofWa0qURzLYrTSSq3iYh49St/1QWAurFMq485mIZVC5goEXZD2HsLhCCQS9ASmcOr1+TKUqFVkuJRkuhIjbJdpC+SJFmZXLPv1coyWK3lfLpQxayQw2ttouamPcnM7cmQWIz2FjEaouiqOEreLGAJgcTJuKZTESCaITJ1EJn1UXRsBhP2CQl1i5meo20l8QpWe2ULFjCTKMDGcOq5lko8mCeZmyTcn5y1Qw3URSKxKhWI8jisNujMnsJviQAyfKfD7TGqOwDc9jE/2UH18ksLhAWy/Qbizm6nOF5IKJOcNVLOnm+jBMPn+cYqFGWS+hAzlVxXKaWpSYap0uuHRCYWUUSFjcXq6YejwFMPlNvYG1LnZEZkgVw8iBGwPTXG81obI56mXq/MVcaup3ruSMU3lzfFCxIOD6rittXGnWR0bbuD84R/+If/jf/wPtm3bxmtf+1re+c53Yq1Q5vHYY49Rq9W4/fbb59/bv38/27Zt48EHH1zRwKlUKlS8elcg69XLajRrxFIPR0dwhpBVaTTPW6POwMv1whouJinhQ7RIOjPPED1RQj7v58+ZaDkyorw3cO7qKq96pX7yFOTzyriJRhFCMCVbKLoBRFOInfIE9Yed+fJjOTuLnJxUrSyiEaQVwHX9kC+wrfg0tCTUhuc6VPqMOkJKSnWbFn+eq3z9UF2+7LdWU2XsQqysrLw0GTwzHsOKRWnfb6hKsWpViQjGbEKyQkn46AhmGl+w4LzNVA2MvXtIVI7hDk+TjfYhcTAdiS+XpRRpIi9aaCudQvrtJe4ziV0pUYlHGN7dTt9TjxGZSVGORHEsG1+tiF0tUfUFyHd1UHNsqpVnaM6Mkg8lCYeDUKlSGB0jkpklGE9Q9icoNkGTm0aePoUzEqTIDdDXCDvtv7mJx60YmXwv0WQRYyf4Os8tItfergycycnF8gU7d6pQ5ugohGIWWctkJmeTiDtYhkuzT5UHCgE95ihDZhQxl4AzPAx7druI9OYXtGtpUQnfJ0+qsvLnnlPhYq+vmubSsKEGzjve8Q5uuOEGEokEDzzwAO9///sZGxvjf/7P/7ns8uPj4/h8PpqWZBu2t7cz7mUZLsO9997Lhz/84bUcukaziKUKx1F7iSGzRvocSz1F46UmSnUfCNgVmcBYpafIUwderZqxF/Jxh4apT0wiIhGElJTrFplaAGGb7OkuYtiJ+e3TksQ5fgIsG+k4CMtiUOxEmNAZHMPIlnFHxxDtbbjFEo4jmCrHGSy00uzPc33TCeTEymW/J0+q1+3bzz120dZKtQqi1DDkpATD70NYJrWKxBeQbAtP02QXGisvOG+FGTCSScI/fxv1hx8le0ogaxkMYVCONzPRtYtiyaLj9ADBBcaLUa9hl0vUfT5mu7og4ePUwZtoHzhGZCaF4eRwTINKKEKhrRXRbFMr25w8cDNdg0fwZauIzCwybFMgREtzkXBHM+lqhKxTpTlcwgh2IU+VcY+dQN7SPG80JBKo2vlAEOGrMz5aptdW5+asnbeFCrfkcioEOF+dZavqumoVmrfHyScTTE1M0RRVSsMeUkr8mQlC7d3Um6KYJtQmUxz58XF25R5fdYPMKxnbVt6c8XFlLA4MLNaJ0qw/a27gvO997+PjH//4WZc5cuQI+/fv55577pl/75prrsHn8/Ff/st/4d5778W/hqbu+9///kXbymaz9HrlFhrNGnCp9DmWeoqidglDuLQFlFdSnsNTdDaNm3Nh9nRjeeXXjgP5PLZhEYl10NHlYsajSnPG2/50Cnd0DGNnH3JomJPFTgg4xMUsYSeHW3cQAuwXvgDZP8CxQZuTZoKIVaDdmCA4cWrFXJFisbEPqy21HxpSr729KvQCEGyLUk8mqE3ksAMh2oOZBQm7i8+bTM81s5zzChmP5rAqVWpSMFOsU67WqNouwwevW2S8WFYb+WiSbEcHTjxIgDL5RAv5ZhWqsmpVijJCJtuNFagRNguATTbWSumGJhj3ETYlwViQ0rNP4kvaGHWouhZVV0lLCyFoboaZVIr8YJpoXyOT3S7P4pwao1g4Tc2t0hYeXpVh0dWl8kjGxhb3ROvrU9fQ2LhB+6E+xu/LMTRYZltb6YyS7R0v3sHxvEFtMkXt0cOIUpGZZBeJ1uqqGmRuBjo6VKL/wIAyFmdnz64Krlk71tzAede73sUb3/jGsy6zc6G4xgIOHTpEvV7n1KlT7FtGIaqjo4NqtUomk1nkxZmYmDhrHo/f719Tg0mjWcql0udY6ikKWxXCViP8ejZPkeM09GkCgUbn6PNhafm1ZVv0zJVfL92+Z4wZ3Z3IQAAx4scqFGipDSANE5FsVo0Od+9msvUA2QfHqU5LItUZ9kaOnDVXZHBQve7atbpxS6k8VkgXezbF5DHA9lGSUYy9ewjO/gQ5nca2cshlzpvjqvPm9eEShgGxOAZgVmv46xlqdRekS7W9jZPNSQJzxst0oYOKP4wwwWcsrOUWlOaSjes1E5EHKQWGqaqOpKPag1eCIVzTxLXBqQMBP+TBNBzCZsOQbQ5XmJnxMz3pEO1T7znDI2wbeITnZrtIhzroiOSom3nMVRgWQqj8kWJxcesFw1AhwWwWaGnD3LeXyvF+KpPPYJsS4Vtcsr296NL/4HEoFhGtCdIIYkysukHmZsDvV60ehodVLlJ/vyrJ95K4V9LO0lwca27gtLa20nqByk6HDx/GMAzaFpZDLODGG2/Etm3uv/9+Xv3qVwNw9OhRBgcHueWWWy54zBrNWnAp9Dku1FNUrTZCOk1NjZLWC9m+2TO3/Z5zbH86NW+MGbEofWGBWapD/SpV6oyEfIGaFSBttjLa3EpzR4mb90UJJHaveJOfUTIxhEKrb3g4PQ1uKkVi8HEKU/3Uil1gmUqXZ9cerOffgN1/BDk7vOx58xKxvXwU123sswQiYUmhCIZp4LgS0zLmjZeqDCMdA4GLEMvXDhtCgiGRUiAM9eWuo/bdxaXuClzTp7JYyxWEkLT6s3QGZ+a/w6qVwAxRQRm3Xr5Wa3mQo7G91KSJEAWmzA66euxVGRY9PcpbMzKiJmiPzk7IDKSYePA4XbPPMFRq5TTb2NMyi3XT9VjPu3r+O/35FKHMMIVYEtt0qDsWmWqE1kB21Q0yNws9PQ0BzlRKeRL7AiPw2OKKyM0curuUbFgOzoMPPshDDz3Ei1/8YqLRKA8++CDvfOc7+bVf+zWa54Q7RkZGuO222/jiF7/IzTffTDwe5zd+4ze45557SCQSxGIxfvu3f5tbbrlFV1BpLgvWuzPwhXiKFioar1b0b022v8QYs00gompmpZTI4VHMHX0MZJP090M8brCtL0xsX/isY/Bkr84nyjx1LIXz6E+I1Y8wFtmLCEaIuFlyE1PUsyXMm66h9zW34svtW/a8eSEtr09WoQDFUoXZ8UlK+RKheJmak8AUAtMQOO4SQ0bOlXgbyxs4wpDK+HEbBqPreLo1LsIwMeIxjGQCN3WCaEs72VqYimsTMGsNbZuWvfOuFi9fy2xJYBUkwnVxpKBQ84FbAtvG6T+JOzl1Rr8tD8OYP70UCo39d0dGaH7iAaayAWaau7EiYdxKnVxqitiPH8FIJBoCiaUyHe4o/b4O6o5Bwp+l2VdsbGSNEvCvFIJBlZtz6hSURlMce/RZktUZEq1RFXreIqG7S8GGGTh+v5+/+7u/4/d///epVCrs2LGDd77znYtyZWq1GkePHqVYbPwz/Mmf/AmGYfDqV7+aSqXCHXfcwZ/92Z9txC5oNMuy3voc5+MpWtgeYrVNNtdq+6sxhib6XkB6xsB11Y1/796zb9sT9UsmV587VCq6uMeOY5dzGH1dlHIxBFCwmhAtEnMqjXvsBP5bno8ILn/elnbvHn16hOzDx/BlUviBXmsYGb6GTGcbpmFhmVCru1TrnjqfnDsmK6i/CWXguK4Bc92xPQ+OYTu4dRvXdDD27sF9+jlCUwPMBveQtXz4mZ0/ns3X7yAnDIpF8C/I1+qR05zOt1ErVrEzE5Syx7DqZahWqX77u/hectuKE+m2bSq0OTysJmbPMxQvjTHdciMlBNsjE5ymnQn/VURmH1vkGfLCqtvNIQbd7aQrMZL+5RO5twpCQN92l5mHH2G4VCPVsoe0I9glxjFCwS0TultvNszAueGGG/jxj3981mX6+vqQS+QgA4EAn/3sZ/nsZz+7nsPTaC5rVuMpmppSbnBY+xLV1XqqzmYM1a69iWypjeETymC56aazGy0LRf3OJwp++ukcbipNd2sFKW1kpUxY5iiIKI4viBmLYM1MrBgi8W5BXsdoZ2iY9A+ewCoUIRbFNS0qFAjMzrC7OsZsfBeFZAvRkEk2VyUvJb5SAVtWCBpFas2RM3ZUCGX8yDpId/FnpuXgOpCaLWDGm6i96A4iTz+MHCiRLdRoCTa0bVrb2sidVB6nrgX5Wj3BNMVcHcbHkfUa04FtdLpDIATu2AS1b393RW+BaapQYL2uvIH+XKOSr9s3w2gxQa4WIuYrkq2GmI7upHVkaP54emFVa+A0sZYWsrUwQ8UkvaHUJWuQeTkip1MEJwfY0x5lQCZwXejPdbAnNrblQnfrxYbr4Gg0mgvjbJ4iL5kRVtdBfK23v5DljCGSSQaOG/T3q5yg7dvPrfh6NlG/lZAS3EoVHAerXsI9OkBPtkyGOI7VigyFkE0x2uToiiESTysokVDei+IDD+MWXdymZgxTGXQlK44TjxKceRp5rELqxluIRwI0ZwsEB4cgk8V0q7SJIcrNcSZ27CWfWNyzQwgJ0sBdYuDYPoeA6aNWd0nNluho7aDpF+/CfiQHtSr+vcwbl3M2GIUCiK4FIcJuP8ZMClmvIoJBCgSgWEY0N2Hs6sMdGTurt6CvTyn0Dg7C7kDDMxQ2KrQFZ4lZRYSAbDXELHES1YH547nQk9cyfYRs8CAl16LgOAQy45esQeblxnwSftDPLmOcbC1I2VlQWrXFQnfrwda6ojSaLcDx48q48crA18O4OV+EYWC0tWJu78Voa+X0oMH0tMrxCIWUEXY2ViPqtxwTEyB8PtrkGO7R48hMBtsHWX8HEhDZDO7oGIF6YcUQiZd/09Q0l9cyOkY9GMQw5/JqkJTdAAhwQhah6SnC+SzBqQnCP/gRsZkpAn6LWjiGDPqJT03Q99SjNOfSmAvuwF74Srqqt5WUYAiIR2wCfhufZVOsVEnN1NXxbIojWlox2loXGQfeup5hYUQjyP4B/NkpsH2qxL9UxvGFMbs7MQxjkbdgOSxLnSspoWoGG5V8KOVnzyHVGZyBWp3T7Fh0PM2ebuw778DcsZ3t9ePImQzDMxGMvj71/hbMM1lUEQnE7NK83AOwJUN3a81lcOvTaDRrwVKNm2WUFi4L8nn1MzraCE2di9WK+i0lkwGiEaK1NG4+D/E47mwe18jiSoGBi13PIu08JJbPvvZE0E0TnFIZpyqRlk1AFPGbDpaok64lcF2XumXhcxyiUxO0Pf04pQyYARN/uYLP7yMSFzjdnYTGJ+gcOE71+S+k6jg4jpyvsJKuwBBK2yYS9NHaFCI1DlIauNKlVlfL+f1QLqvQ3ULnRzSqcq/KZQjMhQhr372f1pGnGTLCWMKBSAirqw8Rm0vKWoW3oK9PnYfT+QQ7VqjkC1slZN5FtrVRiSQJLljf8+TZ0yk6xuukSiFGklF29WzN5+xLpZ21ldmaV5ZGs8lwHCXKJqXyiFyuxo3rqvBZf7+q5tq589xCfRci6gcqTAMQqmdVuwCfHyYmma2GwTCwDBdcSVv5NG4qjfPskWW/x9s2qKfuoj+BD4kt88StWSJmcX45o6p6dXU8+yT+1BSVYExpABkGZqlEeGSIZuFitiSJzc7QKav0tsbpTETw2WojlmHhty3CQR9tTWH8Pmvu2LkYBvNNNz1PlheK9EgmAekyfWJGNeP0+bBe9nMEd3RitLXidnSzs7OIaYlGjuMqvAU+n3ccDOQNz8eIRnCHR5HFohJ4LBZxh0fZ0ZTG2Lub04NnTi+eJ6/tmk6Mpji1unHG+LcKCz1syx3HrRq6W0u0B0ejucJZqHHT3KxKwS9XTpxQYSPbViXHO3ace53zFfXzGB5Wr53RPHXLRIRDyGKBEAXK1RkKVhz8NsFoFGZnqT/6+CL9FlBeEGiI3ImWJIXEdgJD00QCFSpVF9sylKYPEnt2FtNx8AmJtG3qvjAIQZsYo2T7Mco1/FOT+HbuoFTIYVQrVOoulmXSlYwwUTcI+RzCQQvpWvjshjBgpeoSDfkIzBk80ajqFZXNLg7bWVMj1H88xEw6TYITSlelqxMRCGAMjVMXNrWhE5gGiFhU5Udlc6vyFvT1KUXewWoXu1ZIHvfffCMRN0mxuLhZ51J2715cnbXaqrjNxKXQztrKaANHo7mCKRYbBkBHh8oTuVzJZJTBMDGhvAw33njudS5E1A+Up8jzvFjhAHVXIkslRFsbQSTtbolTVi+mKRB1E4IBZCp1RsWKt31vkhaGgbt7P/bMT2gpnCQfDFOumzjFMnapgOn3Iwxw4zEoFKi7JhgQooDfyUEohCgUsIoFrKYIe3Z14yQSWKbBsGFTL9VxrTqOrIJrUKtLhHApVWtYlklPRwAcgeM0pP4LCyqu5zvNz7QiIhGMZKfSVXn2OdyJSVodP6OhPaSCvbS5Y8jpaZzJKcxdO1flLfD71TF1XZAd3fheuXwlXa9UHsXJSWV0L2e8mKYyxicmlKFzLomAzcp6a2dtZfQR1GiuUDKZhnHT23t5GzeOo5oO9vcrY2H37tWVrV+IqB80tH+6u+dyHRIJZV1ZJvh81AJRsCzaGIVSCRGPIw3jjByU7FzO58LQmEgksZ5/A4E9O2kWDolSkagJLbvaSNz2U5g+H8VAiHooRKw8AdLBcVwMQ+D32+A4uKk0Znc3kZ4OmiIBIkEfQgj8tk13S5Rk3E+t7pLN1qnUHJJNc+83qYO20KjxokwLO82H28MIv58aNgQDuI6DrNUIN/kQ0Qg5JwyVCtL2gd+PSDRhdK2uC+S2ber19Okzk8e9SVkI8ATpvR5gy+EZPwslALYiKx1HzcWhPTgazRXI5GSjumfnTpUfcTlz4oQS6fP7ldjgapKFL0TUz8PL61DChgbW82+g/sQTkJlFRiMETJde5wS+0izC58eYC80szUFZmH/j/Q3ga0/ie8FdyOkUlekawVyYlt1Rok4K8dhPQEAp2UqkNEh0dgojFMRn+zBqNWSlghmLrugxCfl97Opsxi/qNCVcWpKCcsFmelrMJxMXCios5VVMweJO80l/nuF6gEI9QFNtCnJ5RCwG1SpWTwKJiWm78y0zZC6/ar2VYFBtt1ZThqunD7SUREJdp8WiWnal5pJ79sw17xxTYTc9t2vWCn0paTRXGIODDeNmz57L17iRros7OcXEE2OUJrOkUi5+P9xww7nXqQ0MkRmcBemuWtTPW3fm2VHk7CzRqDv/mfm8A1jXX6dm2UoV8nl8lTyiqQlj9865pqDdi3JQHEe9LvQ0eaLqsVjjqbvc3IWIxwlHDERLEv/2HpprRZJdrQSu2kuwNUkAiSgWIJ/D6OrC/sVXnDW/wu8XBHw2ActPJOgjHBaLxuR5cMJhFzk7S+nE8FwvoyoE/ATNGq2BWZrsArJWVyv6feA6dFnjdDUXMJpiiHAIEQgga7Xz0lvp6VGvngdxJbyGrl6O2HIYRkPbyGsGq9GsBdqDo9FcQRw7ptz5nsbN5ZqY6QyPUH/4USrDE4wXOjnu7ibWJNizsxmfb/ksaG8dd2SUU8V2amaArl4TJ/q8cyZbLlx3qNgDpkliRw3nkGpYKAwD++d+Flmt4k6nMaJhldhjGsh0ZtmKlUxGvS7s3eWFrBYm9XpGj6oyaojaMTGBnWxG7t+jPEfTaUQ8hu8X78LcdmbMzdu0lA2jtTqXY+yFyEqluf111D4Hf/QU6SGXlJwmQQp3cgr8fsy2Vpq8fk+2pdwslSoYJiGfi1hlB/qV8HpSVSpnlqkvJBCYK693lFdtpVYhsZgKRzrO2ROTNZrzQXtwNJorADmXtOm6asK4nKtOvERXZ+A0g9YexsM7Cfldwtkx2h79J5zhkbOuUw83UU+0YYSChIaPqveXWWe5dZ1IHJFoxggFkadOL1rX7OnG9/KXYl2lLEOZzUK+gLljebE5L8F4oTHjGTgLvTr1unr1zsdCUTuZyyPH1cxtPu8Avlf/wrLGDSwO9Xjf5Rk43t/lsvrdmU5R+/Z3CQwdQwSD5BPbES0t4Li4R47izC4QjAsFIRpBZrNK92aBZPR8k84l3qvV0D13uLxqtZXYuXN1y3lij5OTjWOq0VwM2oOj0Vzm1OsqhwXUk/P5JtxeShYmuk62HKBUipCrh4j5y1zbncEdzZ/REmDhOkZPFyfzXQgBvc1ZjOTZmw4uXXe01IIQBj3NuWXXPZ+KlaWGCzTyXRaNYZn3LqQyZrkqMS8ktXh7qnmom8tj9nYhcn7qgBEOwVX7cA4/iXvkKOLgAUQgAJUKhmkiQ0EwLSiVkOfoQL8avNL5hTpFy2GaKgE+k1GJ5h0dyy8nhAp9eTpJl6uWk+bKQRs4Gs1lTKWidEdAJdueT5PJjcBLdK01t5OrhjhdbCVml9gXG8FnushlGgguTI4FARIswyFg1oGzNx1cuK4Qal2AoFlbcd3V9NBa2j18Iat+7zy7ynsGjusu/7mXUByqzpJJpZHJFrXPArwdN+Ix2L8XZ3AIOZ1GmobSVbn6AMb2HtzTQ2uqt9LRoYyW0dGGR2el5TIZ9dPWtnJIKxKZbzjP1NTlf71rLm+0gaPRXKYUCo0S285OiMc3djyrwWsgOBjoZrISJ+HLEbRqdATnaoCXaQngrSMCfvUUH57GZyyIUZyljcDCdQG6Qmkcaaxq3bPhJfEuzAXxPDoLm4LOV1WtQaK3aaqJf6HXZjnvUFCUyNQdilaUGFW2haawjcZKoiWJqFaxf/bFGInmRd4jef11a6q30tSkDJxc7uxeHFAG0MiISjg+W++xvj4Vjk2l1PevVH2l0ZwLnYOj0VyGzMw0jJtt264M4wZUmfWw2EapLPCbVVoCOa5rPtVYYJmE1qVNB4NmDVPIs66z0rqmkPgWTPYX2rBwYYNND6+r+MKcHK9P1bk6oa8Gay4X2PPgLDUWvETjUNwHlkmhqJJ2/GYdY8nxMnw+zO7OM/Vp1kFvxdO78TSLViIaVftUrzcUopdDiIaMQH//RQ9Ps4XRBo5Gc5kxPt6YLHbuXJvJ81JRDCapNHWQztrE7SK7o+Pzk+9KCa1e00E3lW70RprjXEmwF7Pu2fCqlRZ6D7wE44WVQF4F1VqcI9NsVBwtl3sT9DpXJhIYyQSFTG1N9/lC8bxcXtXZ2fASjk+dOvtywWCjUmt8/EJHptnqaANHo7mMOHWqMVFczho3yyElDI8YTCYP0BHJ0TJzDKNUOGcDwYtpOrheDQuXC7d4XoeF1U5raeBYViNEVa+fGZrxtlGuGBh79yCDocumSWNyzpaamjr7crbdMNS8KrWV8JLpM5lGNZlGcz5oA0ejuQzwysC9MuB9+1ZWiL1c6e9XE36sK4b/+deR2JVA5vK4Y+PIXH7Fcmw4s7R6NeusxbrL4U2mngfBY7l8GC9XZy3OlWkqI8d1lYHjGbeeN8czDEolMFuSGDfesGb7fLF4ycCp1LmX9Vo9TEwsf0wX4jVjPZtQoEazEjrJWKPZYFxXKbhKqZ5wz7dr9uVANqsMg5kZlUy6d28SwV3nldB6MU0H17Jh4dIGm9CYiNfT6PQ8OLXaYgOnWlXGjbdtVZbtIiwL84brMK/aD4EARji0oU0avVLwVKrh0VkOr0/V5KTKM/MMnuXw+1XOUzarysc9BWWNZjVoA0ej2UAWatxEo2cvtb1ccV1VJjw2piT3u7q8MuDzK5OG8y+tXqt1F+KFCBeGnbzw1MIEYzh35dD54OXguK4ycny2i5zNUTxZwN9qz+XUGDjTKfz9z5CfyFPiJJbfxOjuQtx8E8YGNnJqb1fHbmrq7AYOrL5PFajrKZtVSsjl8uLGpxrN2dAGjkazQZTLjWTLlhb1cyVy/LiafBIJ5YVYagRcaSwXNlmuRcNaYxiNJOPqyATW0ceoDULBTRMK5jC6u3D8z8M9cZJYdZRCaBvl2HaizizOwGnVHmIDwlMeQigjPZdThs65uttv3646kp88eW5Rv5071XKnTl3eKt6aywudg6PRbAD5fMO46eq6co2bdFpNyLmcCqOcTd/kSsAr0V7qUfAMnIXeAy83Zi2r3EwTnEyW8n88jDl4EhEMUmvtRESj1E+ewvnRj5GZWSLdcYTfT1EGEaEgRk8Xbk6pRMuVlAIvAV7TzNVUPnlhNykb3d9XwudrhAzP1eBTo/HQBo5Gc4lJpxt9ebZvv3I9HvW6CjOMjSkhwp6eK//JenZOj3Bps0fPmFm4f14p+VoaOIZwqQ+PUi1UsXs7EH4/dXzKiEk0YRQyuPXavBCiOydqKMRi1eaNQojG8fB0g87GavtUgcrbEUIddy+5W6M5G9rA0WguIWNjyigAlUw8r21yBdLfryaxlhbl8VipU/SVhJdg7AkrStfFnZzCnZqC7Owi78haloh7yGxOVUXFmlQbBsAWcxLKjkNQVJCVKtVCje2RSToDC2qt/X5krXbeqs1rjZcIPLJyf9R5vD5VcG6hQGgk4A8NnbsCS6PROTgazSViYEAp3wqhNG42MB/0opmYaCjSRqONJ/ErHa9E3DBUl/L6w49SGx6nXuwi4HOoDgusm2/C7Ome9yKsZdKrrFaRjotrq9YTu6LjiLk+U8KyCJoVso5DqWLSHF2iBniBqs1rjWGoY1IuK0/L0nL7pXh9qmZmVLn52f4vLEstMzWlcnKuxIpDzaXjCr7FajRXBp7GjWfc7N17ZRs3Xjn4+LiabHp7r/zQ1EKEUMZN7dvfxRk4TTHUikg2E4uCM3BavT88Mm8MreW+C58PYRpQrQFgCNn4/lCIYFAinDolY7HbaCMUjM+GJ9K3mtATNKoHV6N3k0yqY16rrS4Mptm6XMG3WY3m8sd1lXEjpdL02AwVICdPqlyVtjb1pH6uJ/QrBS/kFIu61B9+FDeXx+jpIm81I4RBNCrXPZlXxKKIaAQ3lz+jDQOAL2AiwmFKs9XLQsF4JUxThS2lbOQqnY3V9qny8JLZR0ZW7r6u0Wz8f4JGs0mp1eDYMfV7PN5QZb2SGR5Wk5DjqAnMa4q4GfAabDbLFO7IKEYygRCC+lwir2W4i5N5s7k1N1aFYSC6uhCBwLJtGMy2VqxbX4Db3nVZKBifDe/aWG3V08I+VV7uk3N6CHdy6gxj0jRVaAuUTIFGsxw6B0ejWQdKJaXxASqMcy7hsyuBUkmV805MqJDC9u1XvjdqIV5OjV0vU6nWEAGVB9MTSpGvL8hr8fuR6RlktYq1DndQIxbDvOkGzIki7sgoMj2DsG3MHX1YN9+Ime+GnTvwJ3ddtGrzeuIpM7uuCs/6/Wdf3utTVRhOMfnVnxCbOoGs1hA+G6O7az73yaOpqdHuYTW6O5qthzZwNJo1JptVyr6gDIFodGPHsxZIqQy2mRn15BwOX9kVYMvhqRKLYADhs6FcgVAQU0ji9oI4S6VCzQoifL516/RuJJP4blm+1YU4ChIDYw1Um9ebHTtUtd3AgMvexLnbaHQbIxx59FkmSmVi7VGMoB/KlRWFDPfsUV7S8XH1f3al9W/TrC/awNFo1pDpafUD0Ne3eWTlBwZUyM2y1CTiJZFuFupzldjBIIiWpFINHjiNEeyaL9eGRjJvufsqRCy6bgYOrNx6wus4fiVg2yDTKZyjx8nlnsKulVb0yEjXxXnkURLVDOmW3YyKKD1GCkJBjGAX7vAo9Ycfw+jqnDeODEOJC46OqpYn51JE1mwtNsyn+f3vfx8hxLI/jzzyyIrrvehFLzpj+f/6X//rJRy5ZquzUn7AyEjDuNm9e/MYN/m8qpyanFRPyZshl2gpCxtsCsPAuvkmjGhk2TwYIxqhuu9aEMaaGziWde6wn+c584yyyxlneISuJ/8Jd2KKIWs3RrdSZV5YjeYhp1XuU7LVRCAo1X24Uh2MswkZxmLquEm5um7mmq3Dhnlwbr31VsbGxha998EPfpD777+fm2666azrvvnNb+YjH/nI/N+h9XyM0mgW4GmjuCOji/IDTne9ELepZVNo3CzEdVVicSql1Iqj0XPnUlyJeAnGXkWY2dMNd97RONdL8mDKpTZwzt4k8kLwGm6ejWBQGZ2l0uUd/pSuqkazCxmMll2AwMHCChnLemRkqaz+pwJ+tskpJsvxeQ0goJH7tIyQ4a5dqlpxakol9K9HbpTmymPDLgOfz0eHlwYP1Go1/vEf/5Hf/u3fXuQSXo5QKLRoXY3mUuBpo7i5vKqwCfiRpQpHjxuIocexnn8D+25JbqrE2+PHlfcmEFBG25XY7Xw1eBXZC8+d2dON0dW5bB6Me3R9xuEl5kq5cqdy73nusjdwphvVaL3+FEOFFtLVCG2B7BkeGdHWuij3yR8y6A0vccecRchQCBU2HRpSOT86VKWBy6hM/Bvf+AapVIo3velN51z2b/7mb2hpaeF5z3se73//+yl6AhYrUKlUyGazi340mvPBexr1tFFEKIgrTPqdnYhkAl8ly87xH4HcPKIcmYyaZKemlGdjs6gVL8UzbpbznAhDJfOa23sx2lrncz/Wq02A58FxnJVDUF7oczX6MhuJ55Eh4Cdg1mgNZGnxL7j3Lmkt4eU+uan0GRpAqxEyDIfVsZGy0Q5Fs7W5bBx5n//857njjjvo8RqZrMBrX/tatm/fTldXF08++STvfe97OXr0KP/3//7fFde59957+fCHP7zWQ9ZsIRY+jQohcKXgZE55EeO+Em1tRdyR/PzT6JWO46jKlOlplcTZ1KQ6Om9GPDXcpQ02z8V6eOpMw8UoFqiXq1RjEqsncUa1kbfd1QjibSRLq9GafEs6ZC7xyHi5T3I6pXKdks0qHlqpKONmFUKG27erUFU6Dc3Nax9C1FxZrLmB8773vY+Pf/zjZ13myJEj7N+/f/7v4eFhvvvd7/LVr371nN//W7/1W/O/Hzx4kM7OTm677Tb6+/vZtUJjkve///3cc889839ns1l6N1sZiGZdWZgfMPcOAK2BLE2+AtJZOT/gSuTECaVdEomoCXUzR4S9/JvV6qh4mnNrnUTuDI/g/sezyCGLilOj8NQYVm/TGdVGVwqrqUYzd/Qt8sicK/fpXMdBCGXknD6tQlULphnNFmTNDZx3vetdvPGNbzzrMjuX+Lq/8IUvkEwmecUrXnHe2zt06BAAJ06cWNHA8fv9+DdjZqTmkrH0adQQsDs61niKv0waHV4I0nUX5ZlMyySua5DJQHv75m9oWKmo19VqqHiek7WsbfDyu8SsxAzsx7UjOFZxRf0XIS7/btoX6pE5W+7TaggGlWGez8PYmEqO12xN1tzAaW1tpbV19S56KSVf+MIXuPvuu7EvwJ94+PBhADr1VaxZR5Z7GvWMm5WeRq8EllaF1e0gk9GDpFqvon13nGRy87v5V0rmXQkv5W+tDJyF+V12Vx9WwaLsWjiBEEZsef2XK4UL9cispAG0Wnp64LnnVM+0RGJzVv5pzs2G5+D827/9GwMDA/zmb/7mGZ+NjIxw22238cUvfpGbb76Z/v5+/vZv/5Y777yTZDLJk08+yTvf+U5++qd/mmuuuWYDRq/ZKqxFfsDlxnJVYadTLZTHZ4nM/gSZuIbW/VeWwXa+eN6Y86lG8lo6rJWS88L8Lp/pYAqJJRzqrrlstRGo8FippMJll/sld7EemQtlxw4lUDkwoENVW5UN/9f4/Oc/z6233rooJ8ejVqtx9OjR+Sopn8/Hv/7rv/KSl7yE/fv38653vYtXv/rVfPOb37zUw9ZsQcyebtXQcMf2y77R4blYripsopIAn59irAO7nGfb6IPr0jH7cmKhwN9q8YyitZqfF1Yb2YbL3ugIIbNKXc7FzJZUG0HDuLrcE409VqpGW0/8fqWJA6p8XLP12HAPzt/+7d+u+FlfX9+icsHe3l7+/d///VIMS6NZlo16Gl1rllaF1VyTXC3IZCVOe2CWhM/BGBvbNFVhK+EpRmyk6vQZ+V1zl5LjGTjL5HeFQio5ulRa21ygzUZnpwpTFQrqWG22/mmas3Nl3ZU1msuAjXgaXWsWeg08Kq5Fwp8DAYlI9QyvwWbkfPNvLnSds7GS/kvdNVbUf/Em6stdC+dywEuSP3368k/M1qwtV96dWaPRXDSLvAaAJRx8Rh1buOyMjF/RVWGrxWtYeSEJqGtp0y7b+8p1kJXqfO+rpfldXsWXNnDOjW03QpCnT2/sWDSXFm3gaDRbkKVeg5OFDgTQGpjFwD2nauxmIJNRr83Nq1/HUxde67DQ0vwuOZNBlkrnzO/a5ClSa0Zbm/K6lcuNJHHN5mfDc3A0Gs2lZ2FV2OxgFieURPgs4vVp3IkrsyrsfPESjGOx1a+z1iXiC1mY32UdBcPvw3dT9KznQIdcVs+uXUrAcmhI9araTD3jNMuzee9eGo3mrJg93ZgvvYOplgPIUom+7OErtirsQvC8Mecz0XlP/+uV2Duf39XWCrH4WY0bPUGfH5alPDmgVI41mx/twdFotjAnS91YL+ik3T9D0Dx4xVaFnS/LdQ9fDZ4H53IQjrNt1el9rZOeNzOJhGoeW6+rCrrz8d5prjw2911Mo9GsiNct3DANmncmr+iqsPPF88Scb4PNlTp8bwReJVW1urHjuNLYvVu9jo7qHKbNzua/k2k0mjPwuoVD44a/lTjfBpselyLnRboucnYWd2oKd3JqRbFFXSp+YZhmoz/V8eMbOxbN+qJDVBrNFuTECfXa3X35S/2vB55RcCF9ttYzHOT1BnMGTJyapHJ4GKO7a9mO4l4eUKl0/obaViceVwa+lMqTqY/f5mQL3to0mq1NKqVu7LZ9fj2YNhPnm7ciXRdnYgp3agqrkFmXFhZebzBn4DR22IdINiOiUZyB0+r94ZFFy/t86lV7cC6MPXvU6/h4QxNJs7nQHhyNZgtRr6skS4CdOzd2LBuFl7MSDq9uec+rUhyapl5qI+wvUj0VWNarcqEs7Q1mly2qNQM3GMLoCZy1o3ittiZD2HIYhvJgjowoj+a+fRs9Is1aoz04Gs0WwiuP7e3dupU359Ngc6FXpRRqQSSbCUetFb0qF8rS3mAhUylMSynO6Ch+xrpaC+eCiUaVJ1NK5dnUbC60gaPRbBGmptSN3O9fvfdiM+IpGJ9Ly2apV6VsxxDCIBQVGD1duLk89YcfW5Nw1dLeYE2+IruiY1jG3Hcv01Ectq6RupZ4nkyvfFyzedAGjkazBajVGk+ofX0bOpQNZ7Uej6VelYqrMpJNIc/pVTlflvYGAzAWGi8r9Abbignia40QyqMJWgBws6H/PTSaLYB3496+fWs/9XvOltVUTy31qrQHMqrbuscKXpULYaWO4sCKHcWhUSquPQ8XRzisjqWUMDmpvHfu5BTO6aGzluprLm90krFGs8nx9G5CocaEuFWZnVWvq8m/WeRVCQUJWxXCVsPDspYd1xf2BnOHRzGSzSqWWKko42aF3mDBIOTzqpJqq1bErRXbtsHRozB9PEXwBw9ijQ0hqzWEz16xVF9zeaM9OBrNJqZabeScbNu2oUO5LPASjOPxcy97oV6VC2VpR3F3bPycvcEWauFoLg4hoNcexXn0JwyckIhoFKO786yl+prLG+3B0Wg2MSdPqtetnnfj4ZWIryZ35UK9KhfDwo7islQ+Z2+wwJzzSBs4F490XawnHiFYKVNq6WFChOgwMhAKYgS7zlqqr7k80WdJo9mkjI6q12i0MRFqzi8H6UK8Khc9Pq+j+Cp6g3n7Ur74NKAtj5dU3tNWQyDI1YLUXBNgzZPKNZcG7cHRaDYhlYrqlgxKzEzT6AS+mvDUQs7Xq6K5MvGSykXAz3YmGSy0AgtCk34/Mj2zJknlmkuDNnA0mk3IwIB63apqxcvhNdg83w7ioLwqoq11bQe0Rgihxf7WgoVJ5b6Qwa7I+GJv3xomlWsuDfoRRKPZZAwNqdd4vNGvSAOFgnrVx0SzHEuTyhcaN+uRVK5Zf7SBo9FsIkqlxkTe2bmxY7ncON8Gm1cKXn6V9uJcHF5SuRGN4A6PIotFpOMgi0WVZL4OSeWa9UWHqDSaKxjpuvO5IQQCnE4nQRjs2rXRI7u88ITwNqMOUDCoDNtS6dztJzRnx+zphjvvUC06RkaR6RmEbWPu6MO6+Uatg3OFoQ0cjeYKxety7Y6MIqs1hsU26s0dtNy0A9tu3+jhXVacT4PNK41QSOUXaQNnbdBJ5ZsHbeBoNFcgXpdrN5fHSCYoWVEqszHk5BRNDz6L07w+JcxXKl6C8WZsMqq1cNaeyzmpXLN6tEmq0VxhLO1yTTDIaLkV4fezc1ttTbtcbxa8/JTNmINjzT2magNHo1mMNnA0miuMpV2uh4otACT8OWxTakGyJXjGjWlu7DjWG23PajSL0QaORnOFsbTLtc+oYRouSX9eLbCGXa43A7m5BuCbMf9mIbqKSqNZjM7B0WiuMJZ2uW4LzCKYbSygBckW4eXfNDVt6DDWFS32p9GcifbgaDRXGEsFyQzRyC3RgmRnUqmo180corJt9aqNHI2mwboZOB/96Ee59dZbCYVCNK3w6DQ4OMjLX/5yQqEQbW1tvOc976HuCVasQDqd5nWvex2xWIympiZ+4zd+g3w+vw57oNFcnmhBsvNjswr8LSTgd5Gzs5T7h3Enp3SCuUbDOoaoqtUqr3nNa7jlllv4/Oc/f8bnjuPw8pe/nI6ODh544AHGxsa4++67sW2bj33sYyt+7+te9zrGxsa47777qNVqvOlNb+K3fuu3+Nu//dv12hWN5rJDC5KtDq/LdjS6seNYT5zhEawfPkNtuE5GTtAUKGN0d2HdfJO+DjRbGiHl+jo1/+qv/orf+Z3fIZPJLHr/n//5n/n5n/95RkdHaW9XomSf+9zneO9738vU1BS+ZRrGHDlyhAMHDvDII49w0003AfCd73yHO++8k+HhYbq6ulY1pmw2SzweZ3Z2llgsdnE7qNFsIAuVjLUg2ZmMjcHsLPT1NfRiNhOeHlI5W2EouJ9ouE4HE7ipNEY0gn2n1kPSbC7OZ/7esDvhgw8+yMGDB+eNG4A77riDbDbLM888s+I6TU1N88YNwO23345hGDz00EPrPmaN5nJDGAZGWyvm9l6MtlZt3Cwhm1Wvm9G4WaiHFOhVOkgVGUCEghg9XVoPSbPl2bAqqvHx8UXGDTD/9/j4+IrrtLW1LXrPsiwSicSK6wBUKhUqXqYhygLUaDSbn82cdLtUDwnAb9QAEEIs0kPSqryarch5Pe69733vQwhx1p/nnntuvcZ6wdx7773E4/H5n97e3o0ekkajWWccR71uRu8NnKmHtDs6RkdgprGA1kPSbHHOy4Pzrne9ize+8Y1nXWbnzp2r+q6Ojg4efvjhRe9NTEzMf7bSOpOTk4veq9frpNPpFdcBeP/7388999wz/3c2m9VGjkazyfHS/pqbN3QY68ZSPaQzKsW0HpJmi3NeBk5rayutrWvj6rzlllv46Ec/yuTk5HzY6b777iMWi3HgwIEV18lkMjz22GPceOONAPzbv/0bruty6NChFbfl9/vx+/1rMm6NRnN54yVep46DtHxE90TZjJJfnh6SM3AaI9g1H6aChh6SuaNP6yFptizrloMzODhIOp1mcHAQx3E4fPgwALt37yYSifCSl7yEAwcO8PrXv54/+qM/Ynx8nA984AO87W1vmzdGHn74Ye6++27uv/9+uru7ueqqq3jpS1/Km9/8Zj73uc9Rq9V4+9vfzq/8yq+suoJKo9FsXpzhkfnS+XKhByyT2khtU5ZMe3pIcjql9I+SzeD3Q6WixB61HpJmi7NuBs6HPvQh/vqv/3r+7+uvvx6A733ve7zoRS/CNE2+9a1v8Za3vIVbbrmFcDjMG97wBj7ykY/Mr1MsFjl69Ci1Wm3+vb/5m7/h7W9/O7fddhuGYfDqV7+aT3/60+u1GxqN5grBK5l2c3lEIoEINCNqNZyBE6rx6CYsmdZ6SBrNyqy7Ds7liNbB0Wg2F9J1qX79mypc09NFwQkwVkzQ7M+T9GVxh0cxd/The+XPb0qPhtZD0mwVzmf+1s02NRrNFc/Skum6qxpPxe3CliiZFoaxKfdLo7kYtIGj0WiueLySaTFXMt3kKxIwa9jGnMid349Mz+iSaY1mC6F9mBqN5opnUcn0HAGzkbunS6Y1mq2HNnA0Gs0Vj1cy7abSLE0r9Eqmje5uXTKt0WwhtIGj0WiueLySaSMawR0eRRaLSMdBFouqhFqXTGs0Ww6dg6PRaDYFumRao9EsRBs4Go1m02D2dGN0deqSaY1Gow0cjUazudAl0xqNBnQOjkaj0Wg0mk2INnA0Go1Go9FsOrSBo9FoNBqNZtOhDRyNRqPRaDSbDm3gaDQajUaj2XRoA0ej0Wg0Gs2mQxs4Go1Go9FoNh3awNFoNBqNRrPp2JJCf14zvmw2u8Ej0Wg0Go1Gs1q8eXtpU93l2JIGTi6XA6C3t3eDR6LRaDQajeZ8yeVyxOPxsy4j5GrMoE2G67qMjo4SjUYRQmz0cLYc2WyW3t5ehoaGiMViGz2cLYk+BxuLPv4bjz4HG8+FnAMpJblcjq6uLoxz9Jjbkh4cwzDo6enZ6GFseWKxmL6xbDD6HGws+vhvPPocbDznew7O5bnx0EnGGo1Go9FoNh3awNFoNBqNRrPp0AaO5pLj9/v5vd/7Pfx+/0YPZcuiz8HGoo//xqPPwcaz3udgSyYZazQajUaj2dxoD45Go9FoNJpNhzZwNBqNRqPRbDq0gaPRaDQajWbToQ0cjUaj0Wg0mw5t4GguKR/96Ee59dZbCYVCNDU1LbvM4OAgL3/5ywmFQrS1tfGe97yHer1+aQe6hejr60MIsejnD//wDzd6WJuaz372s/T19REIBDh06BAPP/zwRg9py/D7v//7Z1zv+/fv3+hhbVp+8IMfcNddd9HV1YUQgq9//euLPpdS8qEPfYjOzk6CwSC33347x48fX5NtawNHc0mpVqu85jWv4S1vecuynzuOw8tf/nKq1SoPPPAAf/3Xf81f/dVf8aEPfegSj3Rr8ZGPfISxsbH5n9/+7d/e6CFtWr7yla9wzz338Hu/93v85Cc/4dprr+WOO+5gcnJyo4e2Zbj66qsXXe8//OEPN3pIm5ZCocC1117LZz/72WU//6M/+iM+/elP87nPfY6HHnqIcDjMHXfcQblcvviNS41mA/jCF74g4/H4Ge9/+9vfloZhyPHx8fn3/vzP/1zGYjFZqVQu4Qi3Dtu3b5d/8id/stHD2DLcfPPN8m1ve9v8347jyK6uLnnvvfdu4Ki2Dr/3e78nr7322o0expYEkF/72tfm/3ZdV3Z0dMhPfOIT8+9lMhnp9/vll7/85YvenvbgaC4rHnzwQQ4ePEh7e/v8e3fccQfZbJZnnnlmA0e2ufnDP/xDkskk119/PZ/4xCd0SHCdqFarPPbYY9x+++3z7xmGwe23386DDz64gSPbWhw/fpyuri527tzJ6173OgYHBzd6SFuSgYEBxsfHF/0/xONxDh06tCb/D1uy2abm8mV8fHyRcQPM/z0+Pr4RQ9r0vOMd7+CGG24gkUjwwAMP8P73v5+xsTH+5//8nxs9tE3H9PQ0juMse40/99xzGzSqrcWhQ4f4q7/6K/bt28fY2Bgf/vCH+amf+imefvppotHoRg9vS+Hd05f7f1iL+7324Ggumve9731nJO0t/dE370vL+ZyTe+65hxe96EVcc801/Nf/+l/55Cc/yWc+8xkqlcoG74VGs/a87GUv4zWveQ3XXHMNd9xxB9/+9rfJZDJ89atf3eihadYY7cHRXDTvete7eOMb33jWZXbu3Lmq7+ro6DijomRiYmL+M83quJhzcujQIer1OqdOnWLfvn3rMLqtS0tLC6Zpzl/THhMTE/r63iCamprYu3cvJ06c2OihbDm8a35iYoLOzs759ycmJrjuuusu+vu1gaO5aFpbW2ltbV2T77rlllv46Ec/yuTkJG1tbQDcd999xGIxDhw4sCbb2ApczDk5fPgwhmHMH3/N2uHz+bjxxhu5//77eeUrXwmA67rcf//9vP3tb9/YwW1R8vk8/f39vP71r9/ooWw5duzYQUdHB/fff/+8QZPNZnnooYdWrLQ9H7SBo7mkDA4Okk6nGRwcxHEcDh8+DMDu3buJRCK85CUv4cCBA7z+9a/nj/7ojxgfH+cDH/gAb3vb23TX33XgwQcf5KGHHuLFL34x0WiUBx98kHe+85382q/9Gs3NzRs9vE3JPffcwxve8AZuuukmbr75Zv70T/+UQqHAm970po0e2pbg3e9+N3fddRfbt29ndHSU3/u938M0TX71V391o4e2Kcnn84u8YwMDAxw+fJhEIsG2bdv4nd/5Hf7gD/6APXv2sGPHDj74wQ/S1dU1/wBwUVx0HZZGcx684Q1vkMAZP9/73vfmlzl16pR82cteJoPBoGxpaZHvete7ZK1W27hBb2Iee+wxeejQIRmPx2UgEJBXXXWV/NjHPibL5fJGD21T85nPfEZu27ZN+nw+efPNN8sf//jHGz2kLcMv//Ivy87OTunz+WR3d7f85V/+ZXnixImNHtam5Xvf+96y9/w3vOENUkpVKv7BD35Qtre3S7/fL2+77TZ59OjRNdm2kFLKizeTNBqNRqPRaC4fdBWVRqPRaDSaTYc2cDQajUaj0Ww6tIGj0Wg0Go1m06GrqDTnRS6XY2xsDNd1N3ooGo1Gc8ViGAadnZ1aPXkd0QaOZlW4rsu9997L1772tY0eikaj0WwafvEXf5H3v//9GIYOqKw12sDRrIp7772Xr3/967zjHe/g+uuvx7btjR6SRqPRXLHUajUef/xxPvOZzwDwu7/7uxs8os2HLhPXnJNsNsvP/uzP8o53vIO77757o4ej0Wg0m4YvfvGLfPrTn+Z73/ueDletMdonpjknXlfX66+/foNHotFoNJsL7746Nja2wSPZfGgDR3NOvIRiHZbSaDSatcW7r+rCjbVHGzgajUaj0Wg2HdrA0Wg0Go1Gs+nQBo5Go9FoNJpNhzZwNBrNZc2LXvQifud3fmejhzHP5Taey41yuXzOn4X5Jp/5zGfYvn07lmXx7ne/m1QqRVtbG6dOndq4nVgjfuVXfoVPfvKTGz2MLYvWwdFcUlzXZWR0inyhRCQcpLurddMIXDmOgxBi0+zPckgpKZRr1B0XyzQIB2yEEBs9rHNSrVbx+XwbPYwNQboucjqFLJURwQCiJYlYx2v0hhtu4MiRIyt+LoTg5MmT9PX18cQTT3DPPffwj//4j1x//fXE43E+8IEP8Au/8Av09fWt2xgvFR/4wAf46Z/+aX7zN3+TeDy+0cPZcmzeO7HmsuP4iSH+1//+Bz7xqS/xp5/9Mp/41Jf4X//7Hzh+YmjdtvkP//APHDx4kGAwSDKZ5Pbbb6dQKOC6Lh/5yEfo6enB7/dz3XXX8Z3vfGd+ve9///sIIchkMvPvHT58GCHE/JPlX/3VX9HU1MQ3vvENDhw4gN/vZ3BwkEqlwnvf+156e3vx+/3s3r2bz3/+8/Pf8/TTT/Oyl72MSCRCe3s7r3/965menl63Y7BWzBbKHDk9zVMDEzxzapKnBiY4cnqa2UJ53bb5xje+kX//93/nU5/6FEIIhBD09/fzG7/xG+zYsYNgMMi+ffv41Kc+dcZ6r3zlK/noRz9KV1cX+/btA+CBBx7guuuuIxAIcNNNN/H1r38dIQSHDx+eX/ds52e58VzOngZneITq179J5Sv/QOUfvkblK/9A9evfxBkeWbdt/uZv/iaxWIxjx44xMDCw6Oe2227j9ttvnzdevvWtb3HzzTdz55130tnZCcDnP/95fuM3fmPdxrda6vX6RX/H8573PHbt2sWXvvSlNRiR5nzRBo7mknD8xBCf/+I3ePrZfhLNMXbt6CbRHOPpZ/v5/Be/sS5GztjYGL/6q7/Kr//6r3PkyBG+//3v86pXvQopJZ/61Kf45Cc/yR//8R/z5JNPcscdd/CKV7yC48ePn9c2isUiH//4x/mLv/gLnnnmGdra2rj77rv58pe/zKc//WmOHDnC//7f/5tIJAJAJpPhZ3/2Z7n++ut59NFH+c53vsPExAT/+T//5zXf/7VktlDm2HCKdK6E3zaJhHz4bZN0rsSx4dS6GTmf+tSnuOWWW3jzm9/M2NgYY2Nj9PT00NPTw9///d/z7LPP8qEPfYj//t//O1/96lcXrXv//fdz9OhR7rvvPr71rW+RzWa56667OHjwID/5yU/4H//jf/De97530TrnOj/Ljae3t3dd9v1icYZHqH37uzgDpxHRKEZ3JyIaxRk4rd5fJyPn7rvvplwu89RTT9HX1zf/E4lE+MEPfsBv/uZvArB7924+8IEP8MADDyCE4O677+bb3/42fr+fF7zgBfPf57ouH/vYx9izZw+BQID29nbe+MY3zn/+9NNPc+eddxKLxejo6OBd73oX1Wp1/vPvfOc7hMPhRWGxp59+GiHEvOF66tQphBB89atf5ad+6qfw+/184xvfYHBwkDe84Q20t7cTDAa59tpr+eEPfzj/PYODg7z2ta+lubmZRCLB6173OmZmZhYdj7vuuou/+7u/W9NjrFkdOkSlWXdc1+Wf73uQ9EyWvbt750Ma0UiIvbt7OXZiiO/864Ps2tm9puGdsbEx6vU6r3rVq9i+fTsABw8eBOCP//iPee9738uv/MqvAPDxj3+c733ve/zpn/4pn/3sZ1e9jVqtxp/92Z9x7bXXAnDs2DG++tWvct9993H77bcDsHPnzvnl/9f/+l9cf/31fOxjH5t/7y//8i/p7e3l2LFj7N279+J2eh2QUjIylaNSdYiFffPnz7BMYmGDbKHKyFSOWMi/5uGqeDyOz+cjFArR0dEx//6HP/zh+d937NjBgw8+yFe/+tVFhmI4HOYv/uIv5kNTn/vc5xBC8P/+v/8vgUCAAwcOMDIywpvf/Ob5dVZzfpYbz+WGdF3qDz+Km8tj9HQ1zksoiBHswh0epf7wYxhdnWsermppaeGVr3wlf/mXf8mrXvWq+fe/9KUvEY/HeeUrXwkob9ott9zCW97yFn7t136NSCTC7/7u73LjjTcu+r57772Xr3zlK/yf//N/2LlzJyMjIzz33HMAPP744/zMz/wM73jHO/j0pz/N8PAwr33ta2lqauKDH/zg/DLPe97zFt1bDh8+TFdXFy0tLQA88cQTAHziE5/gYx/7GDt27MC2bW6++WZ++qd/mm984xskEgm+//3vE4vFADhx4sT8+H/84x+Tz+d561vfynve8x7+4i/+Yn5bN998Mx/96EepVCr4/f41Pdaas6MNHM26MzI6xYmTQ3R1tpwxAQoh6OpIcrx/iJHRKXp72tdsu9deey233XYbBw8e5I477uAlL3kJv/RLv4RpmoyOjvLCF75w0fIvfOEL5290q8Xn83HNNdfM/3348GFM0+RnfuZnll3+iSee4Hvf+968R2ch/f39l6WBUyjXmC2WCQWsZc9fKGAxWyxTKNeIBC9NnstnP/tZ/vIv/5LBwUFKpRLVapXrrrtu0TIHDx5clHdz9OhRrrnmGgKBwPx7N99886J1rsTzsxxyOoU7MoqRTCx7zoxkM+7ICHI6hWhrXfPtv/nNb+alL30po6OjdHV1AfCFL3yBu+++e/6cRCIRTp06xX/6T/9p3lg8ffr0/PIe3/3ud7nrrrt48YtfDMD27du59dZb57fz+te/nj/4gz8AlFfoTW96E9/61rfmDZzDhw/PP4B4PPHEE4veO3z4MOFwmL//+7+fD5/deeedvOAFL1jkGdyzZ8/8729961t561vfusjY/m//7b/xnve8Z9G2urq6qFarjI+Pzz9oaS4N2sDRrDv5QolKpUoouPzTSzAUoDKZJl8orel2TdPkvvvu44EHHuBf/uVf+MxnPsPv/u7vct99951zXe9pb2GrtlqtdsZywWBw0QQSDAbP+r35fJ677rqLj3/842d85uUgXG7UHRfXlZjm8k/6pmngVurUnUujxPp3f/d3vPvd7+aTn/wkt9xyC9FolE984hM89NBDi5YLh8Pn/d1X4vlZDlkqI6s1RGAFj4Hfj0zPIEvrE1q87bbb2L59O3/913/N+9//fh577DGefPLJRaGaJ598Emh4VQFKpdIiAxTgFa94Be9973t59NFHec1rXsOrX/1qmpubee6553jsscfOyG/x+XxUKpX5vx9//HHe8Y53LFrm8OHD3HTTTfN/P/HEE7ziFa+YN25Onz7NP//zP/P4448vu3+nT5/mvvvu44c//OGiKinHcc4IWXr3hGKxuPzB0qwbOgdHs+5EwkH8fh/FUmXZz0vFMn6fTSR8duPgQhBC8MIXvpAPf/jDPP744/h8Pu6//366urr40Y9+tGjZH/3oRxw4cACA1lb1VLuwP8zCRNSVOHjwIK7r8u///u/Lfn7DDTfwzDPP0NfXx+7duxf9XMiEfCmwTAPDEDgrGDCO42IYAmsFA+hi8fl8OI4z//ePfvQjbr31Vt761rdy/fXXs3v3bvr7+8/5Pfv27eOpp55aNPk98sgji5ZZzflZOp7LEREMIHw2lJf/n6NSQdg2IhhY/vOL3b4Q/Pqv/zpf+MIXABXmu/XWW7nqqqvmlzl8+PAZ131LS8sZOSzvfve7OXLkCLfddht/8id/wu7duxkYGOCZZ57Btu0zvGrPPvvsvNFUKBTo7+9f5K1xXZfHH3/8DA/Oi170okV/+3y+M7yCHk888QSJRIInn3ySw4cPz/889dRTfO9731u0bDqdBhr3FM2lQxs4mnWnu6uV3Tt7GR2bZmnzeiklo+Mp9uzqpbtrbW8ADz30EB/72Md49NFHGRwc5P/+3//L1NQUV111Fe95z3v4+Mc/zle+8hWOHj3K+973Pg4fPsz/8//8P4Bydff29vL7v//7HD9+nH/6p39alZ5FX18fb3jDG/j1X/91vv71rzMwMMD3v//9eTf32972NtLpNL/6q7/KI488Qn9/P9/97nd505vedNlOmuGATTwUoFiuL3v+iuU68VCAcGB9epX19fXx0EMPcerUKaanp9mzZw+PPvoo3/3udzl27Bgf/OAHzzBUluO1r30truvyW7/1Wxw5coTvfve7/PEf/zHAvBduNedn6Xguxx5CoiWJ0d2Fm0ove87c1AxGdzeiJbluY3jTm97EyZMn+dd//Ve+/OUvL8p1guVDR9dffz3PPvvsGd+1d+9e/tt/+2889thj5HI5nn32WaLRKI7jLPKsDgwM8LWvfY3Xve5183+7rsv+/fvnl/nud79LKpWa33Y2m+XUqVOLmgnbtk29Xl/R62LbNrlcjq6urjMM4e7u7kXLPv300/T09Mzn+2guHdrA0aw7hmHwsp+7hURzjGMnhsjlCtQdh1yuwLETQyQSMV56+y1rrh8Ti8X4wQ9+wJ133snevXv5wAc+wCc/+Ule9rKX8Y53vIN77rmHd73rXRw8eJDvfOc7fOMb35iPsdu2zZe//GWee+45rrnmGj7+8Y/Px/nPxZ//+Z/zS7/0S7z1rW9l//79vPnNb6ZQKADMe44cx+ElL3kJBw8e5Hd+53doamq6bPVzhBB0t0bx+0yyhSq1uoMrJbW6Q7ZQxe8z6W6Nrpsezrvf/W5M0+TAgQO0trZyxx138KpXvYpf/uVf5tChQ6RSKd761ree83tisRjf/OY3OXz4MNdddx2/+7u/y4c+9CGA+bDIas7P0vEMDg6uy35fDMIwsG6+CSMawR0eRRaLSMdBFou4w6MY0QjWzTeuqx5OV1cXd955J7/+67+O4zhnVAp652Ehd9xxB88888y8F+eP/uiP+OIXv8iRI0c4evQo//2//3eSySS33norhw4doqmpife9732cPHmSf/u3f+PlL385v/Irv8JLX/pSAJLJJEKIeQP4xz/+MW9/+9sJBALznp8nnngC0zQXhcoOHTpEPB7nLW95C0eOHOHZZ5/lc5/73HyV5aFDh4jFYtx999088cQTnDhxgu985zvLCkD+x3/8By95yUvW5JhqzhOp0ZyDI0eOyBtvvFEeOXLkor7n2PFB+ak/+4r87Xf/sfytd9wrf/vdfyw//edfkceOD67RSDXrSSZfks8MTMoHnhmUP3zqtHzgmUH5zMCkzORLGz20C+ZLX/qStG1bFovFjR7KulAfGpbl/+/rsvjpP5OFT35KFj/9Z7L8//2jrA8NX5Ltf/Ob35Smacq3vOUti953HEeGQiH5rW9964x1br75Zvm5z31OSinlhz/8Ybl3714ZCARkS0uL/IVf+AX57LPPzi/7gx/8QN5www0yEAjInTt3ynvvvVfW6/VF3/cHf/AHsrm5WW7btk2+4Q1vkO9973vlTTfdNP/5Zz7zGXn11VefMY4f/vCH8pZbbpHhcFg2NzfLl73sZTKTycx//tBDD8kXvehFMhaLyWg0Km+44Qb5qU99atF3lEolGY/H5YMPPrjiMVqr+6vmTISUS/yXGs0SnnvuOX7t136NL33pS4tcvRfCZlYy3grIK1TJ2OOLX/wiO3fupLu7myeeeIK3v/3tvOhFL9rUQmyXWsn4Yvmnf/on3vOe9/D0009f8feGP//zP+drX/sa//Iv/7LiMmt5f9UsRldRaS4phmGsaSm45tIihLhkpeDrwfj4OB/60IcYHx+ns/P/b++ObRQGgiiAzllyCLnLoA6iDWjFEgVYLsCFUAoFECMKIESyLvJFnAxIlu3lvQpGDlZf69mZKg6HQzRNM3dZk/opikmegk9lv9/H5XKJ6/W62CGKryrLMrqum7uMryXgAF+jruuo63ruMhiRyzLTYWoz81j3/R8AwBMCDgCQHQGHUUOj37NJvgB8bjhX195QvUS+KKOGPTH/jS0H4DPDubqmVSBrocmYUdvtNlJKf68BdrtdlOU0U2sBvsHj8Yjz+Rxd10VKKTabzdwlZcccHF7S9320bRun02nuUgCykVKK4/HoF9UEBBzecr/f43a7LXL/DsBaFEURVVW5uZmQgAMAZMedGACQHQEHAMiOgAMAZEfAAQCyI+AAANkRcACA7Ag4AEB2fgGwCqQXooAmKAAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_source, data_target, inverse=False)" + "learned_potentials.plot_ot_map(data_source, data_target, forward=True);" ] }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "execution_count": 14, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_target, data_source, inverse=True)" + "learned_potentials.plot_ot_map(data_source, data_target, forward=False);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Using this initialization scheme maps the source (using $g$) or target measure (using $f$) to the Gaussian approximation of the respective counterpart. In the case of target $\\nu$ this represents almost the correct solution." + "Using this initialization scheme maps the source (using $f$) or target measure (using $g$) to the Gaussian approximation of the respective counterpart. In the case of target $\\nu$ this represents almost the correct solution." ] } ], @@ -566,7 +361,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.9.15" }, "vscode": { "interpreter": { @@ -575,5 +370,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/docs/tutorials/notebooks/neural_dual.ipynb b/docs/tutorials/notebooks/neural_dual.ipynb index ae4a2a57a..20b6651ae 100644 --- a/docs/tutorials/notebooks/neural_dual.ipynb +++ b/docs/tutorials/notebooks/neural_dual.ipynb @@ -4,21 +4,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ICNN Dual Solver " + "# Neural Dual Solver " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In this tutorial, we explore how to learn the solution of the Kantorovich dual based on parameterizing the two dual potentials $f$ and $g$ with two input convex neural networks ({class}`~ott.solvers.nn.icnn.ICNN`) {cite}`amos:17`, a method developed by {cite}`makkuva:20`. For more insights on the approach itself, we refer the user to the original publication.\n", + "This tutorial shows how to use `OTT` to compute the Wasserstein-4 optimal transport map between continuous measures in Euclidean space that are accessible via sampling.\n", + "{class}`~ott.solvers.nn.neuraldual.W2NeuralDual` solves this\n", + "problem by optimizing parameterized Kantorovich dual potential functions\n", + "and returning a {class}`~ott.problems.linear.potentials.DualPotentials`\n", + "object that can be used to transport unseen source data samples to its target distribution (or vice-versa) or compute the corresponding distance between new source and target distribution.\n", "\n", - "Given dataloaders containing samples of the *source* and the *target* distribution, `OTT`'s {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` finds the pair of optimal potentials $f$ and $g$ to solve the corresponding dual of the optimal transport problem. Once a solution has been found, these neural {class}`~ott.problems.linear.potentials.DualPotentials` can be used to transport unseen source data samples to its target distribution (or vice-versa) or compute the corresponding distance between new source and target distribution." + "The dual potentials can be specified as non-convex neural networks\n", + "({class}`~ott.solvers.nn.models.MLP`) or an\n", + "input-convex neural network ({class}`~ott.solvers.nn.models.ICNN`) {cite}`amos:17`.\n", + "{class}`~ott.solvers.nn.neuraldual.W2NeuralDual` implements the\n", + "method developed by {cite}`makkuva:20`\n", + "along with the improvements and fine-tuning of the\n", + "conjugate computation from {cite}`amos:23`.\n", + "For more insights on the approach itself, we refer the user\n", + "to the original sources." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -30,10 +42,17 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, + "execution_count": 2, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ + "from dataclasses import dataclass\n", + "from functools import partial\n", + "\n", + "from IPython.display import clear_output, display\n", + "\n", "import jax\n", "import jax.numpy as jnp\n", "import numpy as np\n", @@ -43,145 +62,124 @@ "import matplotlib.pyplot as plt\n", "\n", "from ott.geometry import pointcloud\n", - "from ott.solvers.nn import icnn, neuraldual\n", - "from ott.tools import sinkhorn_divergence" + "from ott.problems.linear import potentials\n", + "from ott.problems.nn import dataset\n", + "from ott.solvers.nn import models, neuraldual\n", + "from ott.tools import plot, sinkhorn_divergence" ] }, { "cell_type": "markdown", - "metadata": { - "tags": [] - }, + "metadata": {}, "source": [ - "## Helper Functions" + "## Setup Training and Validation Datasets" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let us define some helper functions which we use for the subsequent analysis." + "We apply the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` to compute the transport between toy datasets.\n", + "Here, we aim at computing the map between two toy datasets representing both, source and target distribution using the\n", + "datasets `simple` (data clustered in one center) and `circle` (two-dimensional Gaussians arranged on a circle) from {class}`~ott.problems.nn.dataset.GaussianMixture`." ] }, { - "cell_type": "code", - "execution_count": 2, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def plot_ot_map(neural_dual, source, target, inverse=False):\n", - " \"\"\"Plot data and learned optimal transport map.\"\"\"\n", - "\n", - " def draw_arrows(a, b):\n", - " plt.arrow(\n", - " a[0], a[1], b[0] - a[0], b[1] - a[1], color=[0.5, 0.5, 1], alpha=0.3\n", - " )\n", - "\n", - " grad_state_s = neural_dual.transport(source, forward=not inverse)\n", - "\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(111)\n", - "\n", - " if not inverse:\n", - " ax.scatter(\n", - " target[:, 0],\n", - " target[:, 1],\n", - " color=\"#A7BED3\",\n", - " alpha=0.5,\n", - " label=r\"$target$\",\n", - " )\n", - " ax.scatter(\n", - " source[:, 0],\n", - " source[:, 1],\n", - " color=\"#1A254B\",\n", - " alpha=0.5,\n", - " label=r\"$source$\",\n", - " )\n", - " ax.scatter(\n", - " grad_state_s[:, 0],\n", - " grad_state_s[:, 1],\n", - " color=\"#F2545B\",\n", - " alpha=0.5,\n", - " label=r\"$\\nabla g(source)$\",\n", - " )\n", - " else:\n", - " ax.scatter(\n", - " target[:, 0],\n", - " target[:, 1],\n", - " color=\"#A7BED3\",\n", - " alpha=0.5,\n", - " label=r\"$source$\",\n", - " )\n", - " ax.scatter(\n", - " source[:, 0],\n", - " source[:, 1],\n", - " color=\"#1A254B\",\n", - " alpha=0.5,\n", - " label=r\"$target$\",\n", - " )\n", - " ax.scatter(\n", - " grad_state_s[:, 0],\n", - " grad_state_s[:, 1],\n", - " color=\"#F2545B\",\n", - " alpha=0.5,\n", - " label=r\"$\\nabla f(target)$\",\n", - " )\n", - "\n", - " plt.legend()\n", - "\n", - " for i in range(source.shape[0]):\n", - " draw_arrows(source[i, :], grad_state_s[i, :])" + "## Solve Neural Dual" ] }, { - "cell_type": "code", - "execution_count": 3, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def get_optimizer(optimizer, lr, b1, b2, eps):\n", - " \"\"\"Returns a flax optimizer object based on `config`.\"\"\"\n", - "\n", - " if optimizer == \"Adam\":\n", - " optimizer = optax.adam(learning_rate=lr, b1=b1, b2=b2, eps=eps)\n", - " elif optimizer == \"SGD\":\n", - " optimizer = optax.sgd(learning_rate=lr, momentum=None, nesterov=False)\n", - " else:\n", - " raise NotImplementedError(f\"Optimizer {optimizer} not supported yet!\")\n", - "\n", - " return optimizer" + "In order to solve the neural dual, we need to define our dataloaders. The only requirement is that the corresponding source and target train and validation datasets are *iterators* that provide samples of batches from the source and target measures.\n", + "The following command loads them with OTT's pre-packaged loader for synthetic data." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "@jax.jit\n", - "def sinkhorn_loss(x, y, epsilon=0.1):\n", - " \"\"\"Computes transport between (x, a) and (y, b) via Sinkhorn algorithm.\"\"\"\n", - " a = jnp.ones(len(x)) / len(x)\n", - " b = jnp.ones(len(y)) / len(y)\n", - "\n", - " sdiv = sinkhorn_divergence.sinkhorn_divergence(\n", - " pointcloud.PointCloud, x, y, epsilon=epsilon, a=a, b=b\n", - " )\n", - " return sdiv.divergence" + "num_samples_visualize = 400\n", + "(\n", + " train_dataloaders,\n", + " valid_dataloaders,\n", + " input_dim,\n", + ") = dataset.create_gaussian_mixture_samplers(\n", + " name_source=\"simple\",\n", + " name_target=\"circle\",\n", + " valid_batch_size=num_samples_visualize,\n", + ")" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Setup Training and Validation Datasets" + "def plot_samples(eval_data_source, eval_data_target):\n", + " fig, axs = plt.subplots(\n", + " 1, 2, figsize=(8, 4), gridspec_kw={\"wspace\": 0, \"hspace\": 0}\n", + " )\n", + " axs[0].scatter(\n", + " eval_data_source[:, 0],\n", + " eval_data_source[:, 1],\n", + " color=\"#A7BED3\",\n", + " s=10,\n", + " alpha=0.5,\n", + " )\n", + " axs[0].set_title(\"Source measure samples\")\n", + " axs[1].scatter(\n", + " eval_data_target[:, 0],\n", + " eval_data_target[:, 1],\n", + " color=\"#1A254B\",\n", + " s=10,\n", + " alpha=0.5,\n", + " )\n", + " axs[1].set_title(\"Target measure samples\")\n", + "\n", + " for ax in axs:\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.set_xlim(-6, 6)\n", + " ax.set_ylim(-6, 6)\n", + " return fig, ax\n", + "\n", + "\n", + "# Sample a batch for evaluation and plot it\n", + "eval_data_source = next(valid_dataloaders.source_iter)\n", + "eval_data_target = next(valid_dataloaders.target_iter)\n", + "\n", + "plot_samples(eval_data_source, eval_data_target);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We apply the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` to compute the transport between toy datasets. In this tutorial, the user can choose between the datasets `simple` (data clustered in one center), `circle` (two-dimensional Gaussians arranged on a circle), `square_five` (two-dimensional Gaussians on a square with one Gaussian in the center), and `square_four` (two-dimensional Gaussians in the corners of a rectangle)." + "Next, we define the architectures parameterizing the dual potentials $f$ and $g$. We first parameterize $f$ with an {class}`~ott.solvers.nn.models.ICNN` and $\\nabla g$ as a non-convex {class}`~ott.solvers.nn.models.MLP`. You can adapt the size of the ICNNs by passing a sequence containing hidden layer sizes. While ICNNs are by default containing partially positive weights, we can run the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` using approximations to this positivity constraint (via weight clipping and a weight penalization).\n", + "For this, set `pos_weights` to `True` in {class}`~ott.solvers.nn.models.ICNN` and {class}`~ott.solvers.nn.neuraldual.W2NeuralDual`.\n", + "For more details on how to customize {class}`~ott.solvers.nn.models.ICNN`,\n", + "we refer you to the documentation." ] }, { @@ -190,141 +188,120 @@ "metadata": {}, "outputs": [], "source": [ - "class ToyDataset(IterableDataset):\n", - " def __init__(self, name):\n", - " self.name = name\n", - "\n", - " def __iter__(self):\n", - " return self.create_sample_generators()\n", - "\n", - " def create_sample_generators(self, scale=5.0, variance=0.5):\n", - " # given name of dataset, select centers\n", - " if self.name == \"simple\":\n", - " centers = np.array([0, 0])\n", - "\n", - " elif self.name == \"circle\":\n", - " centers = np.array(\n", - " [\n", - " (1, 0),\n", - " (-1, 0),\n", - " (0, 1),\n", - " (0, -1),\n", - " (1.0 / np.sqrt(2), 1.0 / np.sqrt(2)),\n", - " (1.0 / np.sqrt(2), -1.0 / np.sqrt(2)),\n", - " (-1.0 / np.sqrt(2), 1.0 / np.sqrt(2)),\n", - " (-1.0 / np.sqrt(2), -1.0 / np.sqrt(2)),\n", - " ]\n", - " )\n", - "\n", - " elif self.name == \"square_five\":\n", - " centers = np.array([[0, 0], [1, 1], [-1, 1], [-1, -1], [1, -1]])\n", - "\n", - " elif self.name == \"square_four\":\n", - " centers = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\n", - "\n", - " else:\n", - " raise NotImplementedError()\n", - "\n", - " # create generator which randomly picks center and adds noise\n", - " centers = scale * centers\n", - " while True:\n", - " center = centers[np.random.choice(len(centers))]\n", - " point = center + variance**2 * np.random.randn(2)\n", - "\n", - " yield point\n", + "# initialize models and optimizers\n", + "num_train_iters = 5001\n", "\n", + "neural_f = models.ICNN(dim_data=2, dim_hidden=[64, 64, 64, 64])\n", + "neural_g = models.MLP(\n", + " dim_hidden=[64, 64, 64, 64],\n", + " is_potential=False, # returns the gradient of the potential.\n", + ")\n", "\n", - "def load_toy_data(\n", - " name_source: str,\n", - " name_target: str,\n", - " batch_size: int = 1024,\n", - " valid_batch_size: int = 1024,\n", - "):\n", - " dataloaders = (\n", - " iter(DataLoader(ToyDataset(name_source), batch_size=batch_size)),\n", - " iter(DataLoader(ToyDataset(name_target), batch_size=batch_size)),\n", - " iter(DataLoader(ToyDataset(name_source), batch_size=valid_batch_size)),\n", - " iter(DataLoader(ToyDataset(name_target), batch_size=valid_batch_size)),\n", - " )\n", - " input_dim = 2\n", - " return dataloaders, input_dim" + "lr_schedule = optax.cosine_decay_schedule(\n", + " init_value=1e-4, decay_steps=num_train_iters, alpha=1e-2\n", + ")\n", + "optimizer_f = optax.adam(learning_rate=lr_schedule, b1=0.5, b2=0.5)\n", + "optimizer_g = optax.adam(learning_rate=lr_schedule, b1=0.9, b2=0.999)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Solve Neural Dual" + "We then initialize the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` by passing the two {class}`~ott.solvers.nn.models.ICNN` models parameterizing $f$ and $g$, as well as by specifying the input dimensions of the data and the number of training iterations to execute. Once the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual` is initialized, we can obtain the neural {class}`~ott.problems.linear.potentials.DualPotentials` by passing the corresponding dataloaders to it.\n", + "For more details on how to configure the {class}`~ott.solvers.nn.neuraldual.W2NeuralDual`, we refer you to the documentation." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In order to solve the neural dual, we need to define our dataloaders. The only requirement is that the corresponding source and target train and validation datasets are *iterators*." + "Execution of the following cell will probably take a few minutes, depending on your system and the number of training iterations." ] }, { "cell_type": "code", "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "(dataloader_source, dataloader_target, _, _), input_dim = load_toy_data(\n", - " \"square_five\", \"square_four\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we define the architectures parameterizing the dual potentials $f$ and $g$. These need to be parameterized by {class}`~ott.solvers.nn.icnn.ICNN`s. You can adapt the size of the ICNNs by passing a sequence containing hidden layer sizes. While ICNNs are by default containing partially positive weights, we can run the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` using approximations to this positivity constraint (via weight clipping and a weight penalization). For this, set `positive_weights` to `True` in both the ICNN architecture and {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` configuration. For more details on how to customize the {class}`~ott.solvers.nn.icnn.ICNN` architectures, we refer you to the documentation." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "# initialize models\n", - "neural_f = icnn.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)\n", - "neural_g = icnn.ICNN(dim_hidden=[64, 64, 64, 64], dim_data=2)\n", + "def training_callback(step, learned_potentials):\n", + " # Callback function as the training progresses to visualize the couplings.\n", + " if step % 1000 == 0:\n", + " clear_output()\n", + " print(f\"Training iteration: {step}/{num_train_iters}\")\n", "\n", - "# initialize optimizers\n", - "optimizer_f = get_optimizer(\"Adam\", lr=0.001, b1=0.5, b2=0.9, eps=1e-8)\n", - "optimizer_g = get_optimizer(\"Adam\", lr=0.001, b1=0.5, b2=0.9, eps=1e-8)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We then initialize the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` by passing the two {class}`~ott.solvers.nn.icnn.ICNN` models parameterizing $f$ and $g$, as well as by specifying the input dimensions of the data and the number of training iterations to execute. Once the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver` is initialized, we can obtain the neural {class}`~ott.problems.linear.potentials.DualPotentials` by passing the corresponding dataloaders to it. As here our training and validation datasets do not differ, we pass (`dataloader_source`, `dataloader_target`) for both training and validation steps. For more details on how to configure the {class}`~ott.solvers.nn.neuraldual.NeuralDualSolver`, we refer you to the documentation." + " fig, ax = learned_potentials.plot_ot_map(\n", + " eval_data_source,\n", + " eval_data_target,\n", + " forward=True,\n", + " )\n", + " display(fig)\n", + " plt.close(fig)\n", + "\n", + " fig, ax = learned_potentials.plot_ot_map(\n", + " eval_data_source,\n", + " eval_data_target,\n", + " forward=False,\n", + " )\n", + " display(fig)\n", + " plt.close(fig)\n", + "\n", + " fig, ax = learned_potentials.plot_potential()\n", + " display(fig)\n", + " plt.close(fig)\n", + "\n", + "\n", + "neural_dual_solver = neuraldual.W2NeuralDual(\n", + " input_dim,\n", + " neural_f,\n", + " neural_g,\n", + " optimizer_f,\n", + " optimizer_g,\n", + " num_train_iters=num_train_iters,\n", + ")\n", + "learned_potentials = neural_dual_solver(\n", + " *train_dataloaders,\n", + " *valid_dataloaders,\n", + " callback=training_callback,\n", + ")\n", + "clear_output()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Execution of the following cell might take up to 15 minutes per 5000 iterations (depending on your system and the number of training iterations." + "The output of the solver, `learned_potentials`, is an instance of\n", + "{class}`~ott.problems.linear.potentials.DualPotentials`.\n", + "This gives us access to the learned potentials and provides functions to compute and plot the forward and\n", + "inverse OT maps between the measures." ] }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 7, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "31b3dff5bd2840b0b358f91fdb2b117b", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ - " 0%| | 0/15000 [00:00" ] }, "metadata": {}, @@ -332,17 +309,8 @@ } ], "source": [ - "neural_dual_solver = neuraldual.NeuralDualSolver(\n", - " input_dim,\n", - " neural_f,\n", - " neural_g,\n", - " optimizer_f,\n", - " optimizer_g,\n", - " num_train_iters=15000,\n", - ")\n", - "neural_dual = neural_dual_solver(\n", - " dataloader_source, dataloader_target, dataloader_source, dataloader_target\n", - ")" + "learned_potentials.plot_potential(forward=True)\n", + "learned_potentials.plot_potential(forward=False);" ] }, { @@ -359,16 +327,6 @@ "After training has completed successfully, we can evaluate the neural {class}`~ott.problems.linear.potentials.DualPotentials` on unseen incoming data. We first sample a new batch from the source and target distribution." ] }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "data_source = next(dataloader_source).numpy()\n", - "data_target = next(dataloader_target).numpy()" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -378,46 +336,50 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": 8, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_source, data_target, inverse=False)" + "learned_potentials.plot_ot_map(\n", + " eval_data_source,\n", + " eval_data_target,\n", + " forward=True,\n", + ");" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plot_ot_map(neural_dual, data_target, data_source, inverse=True)" + "learned_potentials.plot_ot_map(\n", + " eval_data_source, eval_data_target, forward=False\n", + ");" ] }, { @@ -436,21 +398,39 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "@jax.jit\n", + "def sinkhorn_loss(x, y, epsilon=0.1):\n", + " \"\"\"Computes transport between (x, a) and (y, b) via Sinkhorn algorithm.\"\"\"\n", + " a = jnp.ones(len(x)) / len(x)\n", + " b = jnp.ones(len(y)) / len(y)\n", + "\n", + " sdiv = sinkhorn_divergence.sinkhorn_divergence(\n", + " pointcloud.PointCloud, x, y, epsilon=epsilon, a=a, b=b\n", + " )\n", + " return sdiv.divergence" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sinkhorn distance between predictions and data samples: 1.4665195941925049\n" + "Sinkhorn distance between source predictions and data samples: 0.85\n" ] } ], "source": [ - "pred_target = neural_dual.transport(data_source)\n", + "pred_target = learned_potentials.transport(eval_data_source)\n", "print(\n", - " f\"Sinkhorn distance between predictions and data samples: {sinkhorn_loss(pred_target, data_target)}\"\n", + " f\"Sinkhorn distance between source predictions and data samples: {sinkhorn_loss(pred_target, eval_data_target):.2f}\"\n", ")" ] }, @@ -463,21 +443,21 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sinkhorn distance between predictions and data samples: 6.814591884613037\n" + "Sinkhorn distance between source predictions and data samples: 0.00\n" ] } ], "source": [ - "pred_source = neural_dual.transport(data_target, forward=False)\n", + "pred_source = learned_potentials.transport(eval_data_target, forward=False)\n", "print(\n", - " f\"Sinkhorn distance between predictions and data samples: {sinkhorn_loss(pred_source, data_source)}\"\n", + " f\"Sinkhorn distance between source predictions and data samples: {sinkhorn_loss(pred_source, eval_data_source):.2f}\"\n", ")" ] }, @@ -490,21 +470,23 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Neural dual distance between source and target data: 21.16440200805664\n" + "Neural dual distance between source and target data: 21.95\n" ] } ], "source": [ - "neural_dual_dist = neural_dual.distance(data_source, data_target)\n", + "neural_dual_dist = learned_potentials.distance(\n", + " eval_data_source, eval_data_target\n", + ")\n", "print(\n", - " f\"Neural dual distance between source and target data: {neural_dual_dist}\"\n", + " f\"Neural dual distance between source and target data: {neural_dual_dist:.2f}\"\n", ")" ] }, @@ -515,22 +497,176 @@ "Which compares to the primal {class}`~ott.solvers.linear.sinkhorn.Sinkhorn` distance in the following." ] }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sinkhorn distance between source and target data: 22.00\n" + ] + } + ], + "source": [ + "sinkhorn_dist = sinkhorn_loss(eval_data_source, eval_data_target)\n", + "print(f\"Sinkhorn distance between source and target data: {sinkhorn_dist:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solving a harder problem\n", + "\n", + "We next set up a harder OT problem to transport from a mixture\n", + "of five Gaussians to a mixture of four Gaussians and solve\n", + "it by using the non-convex {class}`~ott.solvers.nn.models.MLP`\n", + "potentials to model $f$ and $g$." + ] + }, { "cell_type": "code", "execution_count": 15, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoQAAAFjCAYAAACkHhroAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABngklEQVR4nO3deXxkVZ3//9ddas2+dDq9b+mmoUFhEFHARkVABgQXZMBxFBCGGR2/Ol+X0e/v4cJXHYZxcPnqjMI4IqO4gQsqg4gKtrKoKEvTAr2v6XS2SqpS613O749KlUkn3Z2G7iRNvZ+PB7a5uXVzq5J77uee8zmfYxljDCIiIiJSs+yZPgERERERmVkKCEVERERqnAJCERERkRqngFBERESkxikgFBEREalxCghFREREapwCQhEREZEap4BQREREpMYpIBQRERGpcQoIRWrIlVdeydKlS2f6NEREnpft27djWRZf+9rXZvpUXjAUEI6xfv16Lr30UpYsWUI8HmfBggWce+65fOELX5jpUxMRec4sy5rSfw888MBMn+o4Dz30EB//+McZGhqa6VMRecFzZ/oEZouHHnqIV73qVSxevJhrr72Wzs5Odu3axSOPPMLnP/953v3ud8/0KYqIPCdf//rXx3393//939x3330Tth9//PHTeVqH9NBDD3H99ddz5ZVX0tzcPNOnI/KCpoBw1Kc+9Smampr4/e9/P6Hh6e3tnfbzyWaz1NXVTfvPrQX6bKXWvPWtbx339SOPPMJ99903YftzYYyhUCiQSCSe97Hk8OizlyNJQ8ajtmzZwpo1ayZ9Cu3o6Bj3te/7fOITn2DFihXEYjGWLl3K//k//4disThuP8uy+PjHPz7heEuXLuXKK6+sfv21r30Ny7L41a9+xTvf+U46OjpYuHBh9fv33HMPZ599Ng0NDTQ2NnLaaafxzW9+c9wxf/vb3/La176WpqYmkskkZ599Ng8++OAh3/cDDzyAZVl897vf5frrr2fBggU0NDRw6aWXMjw8TLFY5L3vfS8dHR3U19dz1VVXTXifAN/4xjc49dRTSSQStLa2cvnll7Nr165x+/z617/mzW9+M4sXLyYWi7Fo0SL+8R//kXw+P26/np4errrqKhYuXEgsFmPevHlccsklbN++/ah8tq94xSuoq6ujoaGBCy+8kA0bNhzyc/M8j+uvv56VK1cSj8dpa2vjrLPO4r777qvu8+STT3LllVeyfPly4vE4nZ2dXH311QwMDIw71sc//nEsy2Ljxo289a1vpampiTlz5vCRj3wEYwy7du3ikksuobGxkc7OTm666aZxr6/8Dr/zne/wf/7P/6Gzs5O6ujouvvjiCb+DyYRhyOc+9znWrFlDPB5n7ty5XHfddaRSqXH7Pfroo5x//vm0t7eTSCRYtmwZV1999SGPL8eGW2+9lVe/+tV0dHQQi8U44YQT+NKXvjRhv6VLl3LRRRdx77338pKXvIREIsHNN98MwI4dO7j44oupq6ujo6ODf/zHf+Tee++ddDj6UG3Wxz/+cT7wgQ8AsGzZsuqw9th2YH+vfOUrOfHEE3nyySc5++yzSSaTdHV1ceeddwLwq1/9itNPP51EIsFxxx3Hz3/+8wnH2LNnD1dffTVz584lFouxZs0avvrVr47bp1Qq8dGPfpRTTz2VpqYm6urqeMUrXsH9998/4Xjf/va3OfXUU6vt90knncTnP//5ce/TsqwJr6u0XWPf78E++6GhId773veyaNEiYrEYXV1d3HjjjYRheMDPq2Iq1/a//du/ccYZZ9DW1kYikeDUU0+tfq5jWZbFP/zDP3DHHXdwwgknkEgkePnLX8769esBuPnmm+nq6iIej/PKV75ywu+z8jv8wx/+wBlnnFE9ny9/+cuHfB8AzzzzDJdeeimtra3E43Fe8pKX8KMf/WjcPlNpv2uReghHLVmyhIcffpinnnqKE0888aD7XnPNNdx2221ceumlvO997+O3v/0tN9xwA08//TQ/+MEPnvM5vPOd72TOnDl89KMfJZvNAuVG4eqrr2bNmjV8+MMfprm5mccee4yf/vSnvOUtbwHgl7/8JRdccAGnnnoqH/vYx7Btu9q4//rXv+alL33pIX/2DTfcQCKR4EMf+hCbN2/mC1/4ApFIBNu2SaVSfPzjH+eRRx7ha1/7GsuWLeOjH/1o9bWf+tSn+MhHPsJll13GNddcQ19fH1/4whdYu3Ytjz32WDXIvuOOO8jlcvz93/89bW1t/O53v+MLX/gCu3fv5o477qge701vehMbNmzg3e9+N0uXLqW3t5f77ruPnTt3PucJEZN9tl//+td5+9vfzvnnn8+NN95ILpfjS1/6EmeddRaPPfbYQX/Wxz/+cW644QauueYaXvrSl5JOp3n00Uf54x//yLnnngvAfffdx9atW7nqqqvo7Oxkw4YN3HLLLWzYsIFHHnlkwk3gr/7qrzj++OP5l3/5F+6++24++clP0trays0338yrX/1qbrzxRm6//Xbe//73c9ppp7F27dpxr//Upz6FZVn80z/9E729vXzuc5/jNa95DY8//vhBexCuu+46vva1r3HVVVfxv/7X/2Lbtm188Ytf5LHHHuPBBx8kEonQ29vLeeedx5w5c/jQhz5Ec3Mz27dv5/vf//5z+n3I7POlL32JNWvWcPHFF+O6Lj/+8Y955zvfSRiGvOtd7xq377PPPssVV1zBddddx7XXXstxxx1HNpvl1a9+NXv37uU973kPnZ2dfPOb35w0SJpKm/XGN76RjRs38q1vfYvPfvaztLe3AzBnzpyDvo9UKsVFF13E5Zdfzpvf/Ga+9KUvcfnll3P77bfz3ve+l7/7u7/jLW95C5/+9Ke59NJL2bVrFw0NDQDs27ePl73sZdWgZs6cOdxzzz284x3vIJ1O8973vheAdDrNV77yFa644gquvfZaMpkM//Vf/8X555/P7373O04++WSg3AZcccUVnHPOOdx4440APP300zz44IO85z3veU6/p8k++1wux9lnn82ePXu47rrrWLx4MQ899BAf/vCH2bt3L5/73OcOeLypXtuf//znufjii/nrv/5rSqUS3/72t3nzm9/MT37yEy688MJx+/7617/mRz/6UfXv5oYbbuCiiy7igx/8IP/xH//BO9/5TlKpFP/6r//K1VdfzS9/+csJv8O//Mu/5LLLLuOKK67gu9/9Ln//939PNBo96EPohg0bOPPMM1mwYAEf+tCHqKur47vf/S6vf/3r+d73vscb3vAGYGrtd00yYowx5mc/+5lxHMc4jmNe/vKXmw9+8IPm3nvvNaVSadx+jz/+uAHMNddcM277+9//fgOYX/7yl9VtgPnYxz424WctWbLEvP3tb69+feuttxrAnHXWWcb3/er2oaEh09DQYE4//XSTz+fHHSMMw+q/K1euNOeff351mzHG5HI5s2zZMnPuuece9H3ff//9BjAnnnjiuPd6xRVXGMuyzAUXXDBu/5e//OVmyZIl1a+3b99uHMcxn/rUp8btt379euO67rjtuVxuws+/4YYbjGVZZseOHcYYY1KplAHMpz/96YOe9/P9bDOZjGlubjbXXnvtuNf39PSYpqamCdv39+IXv9hceOGFB91nsvf7rW99ywBm3bp11W0f+9jHDGD+9m//trrN932zcOFCY1mW+Zd/+Zfq9lQqZRKJxLj3WPkdLliwwKTT6er27373uwYwn//856vb3v72t4/7/f361782gLn99tvHnedPf/rTcdt/8IMfGMD8/ve/P+h7lmPDu971LrN/8z/Z3+v5559vli9fPm7bkiVLDGB++tOfjtt+0003GcD88Ic/rG7L5/Nm9erVBjD333+/Mebw2qxPf/rTBjDbtm2b0vs6++yzDWC++c1vVrc988wzBjC2bZtHHnmkuv3ee+81gLn11lur297xjneYefPmmf7+/nHHvfzyy01TU1P1M/J93xSLxXH7pFIpM3fuXHP11VdXt73nPe8xjY2N49qe/VWu//1V2q6x7/1An/0nPvEJU1dXZzZu3Dhu+4c+9CHjOI7ZuXPnAX/+VK/t/f8+SqWSOfHEE82rX/3qcdsBE4vFxp33zTffbADT2dk5ro368Ic/POE9Vn6HN910U3VbsVg0J598suno6Kjep7Zt2zbh93fOOeeYk046yRQKheq2MAzNGWecYVauXFndNpX2uxZpyHjUueeey8MPP8zFF1/ME088wb/+679y/vnns2DBgnHdzf/zP/8DwP/+3/973Ovf9773AXD33Xc/53O49tprcRyn+vV9991HJpPhQx/6EPF4fNy+ld6lxx9/nE2bNvGWt7yFgYEB+vv76e/vJ5vNcs4557Bu3bopDRm87W1vIxKJVL8+/fTTMcZMeBo7/fTT2bVrF77vA/D973+fMAy57LLLqj+7v7+fzs5OVq5cOa53YGwvVTabpb+/nzPOOANjDI899lh1n2g0ygMPPDBhyPL5mOyzHRoa4oorrhh33o7jcPrpp0/aqzFWc3MzGzZsYNOmTQfcZ+z7LRQK9Pf387KXvQyAP/7xjxP2v+aaa6r/33EcXvKSl2CM4R3veMe4n3vcccexdevWCa9/29veVu3pALj00kuZN29e9W92MnfccQdNTU2ce+654z6HU089lfr6+urnUOnl/clPfoLneQc8nhy7xv69Dg8P09/fz9lnn83WrVsZHh4et++yZcs4//zzx2376U9/yoIFC7j44our2+LxONdee+24/Y5Um3Ug9fX1XH755dWvjzvuOJqbmzn++OM5/fTTq9sr/79yLRlj+N73vsfrXvc6jDHjrofzzz+f4eHh6nXrOA7RaBQop1wMDg7i+z4veclLxl3bzc3NZLPZIzoUOdlnf8cdd/CKV7yClpaWcef9mte8hiAIWLdu3QGPN9Vre+zfRyqVYnh4mFe84hWTtmXnnHPOuBGWymf9pje9aVwbtf/voMJ1Xa677rrq19FolOuuu47e3l7+8Ic/THp+g4OD/PKXv+Syyy4jk8lUP4OBgQHOP/98Nm3axJ49e6rv+VDtdy3SkPEYp512Gt///vcplUo88cQT/OAHP+Czn/0sl156KY8//jgnnHACO3bswLZturq6xr22s7OT5uZmduzY8Zx//rJly8Z9vWXLFoCDDmFX/qDf/va3H3Cf4eFhWlpaDvqzFy9ePO7rpqYmABYtWjRhexiGDA8P09bWxqZNmzDGsHLlykmPOzbI3LlzJx/96Ef50Y9+NCHYq9xwYrEYN954I+973/uYO3cuL3vZy7jooot429veRmdn50Hfw8Hs/9lWPrdXv/rVk+7f2Nh40OP93//7f7nkkktYtWoVJ554Iq997Wv5m7/5G170ohdV9xkcHOT666/n29/+9oSJSfvfYGHy30E8Hq8OlY3dvn8eIjDhd2BZFl1dXQfNudq0aRPDw8MT8mQrKud99tln86Y3vYnrr7+ez372s7zyla/k9a9/PW95y1uIxWIHPL4cOx588EE+9rGP8fDDD5PL5cZ9b3h4uNomwMTrCcr5gytWrJiQCrF/W3mk2qwDWbhw4YRzaGpqmrQtA6ptUV9fH0NDQ9xyyy3ccsstkx577HV82223cdNNN/HMM8+MC6TGfjbvfOc7+e53v8sFF1zAggULOO+887jssst47Wtf+5ze2/7Hr9i0aRNPPvnkAYfTDzYxcqrX9k9+8hM++clP8vjjj4/LI58s//Fw7ifAhPvB/PnzJ0z8W7VqFVCuP1h5sB5r8+bNGGP4yEc+wkc+8pFJ32tvby8LFiyYUvtdixQQTiIajXLaaadx2mmnsWrVKq666iruuOMOPvaxj1X3mewimKogCCbd/lxmilWepD/96U9X81b2V19ff8jjjO09m8p2Y0z151uWxT333DPpvpWfHQQB5557LoODg/zTP/0Tq1evpq6ujj179nDllVeO6xF473vfy+te9zp++MMfcu+99/KRj3yEG264gV/+8peccsopB30fU/1sKz/v61//+qSBpuse/NJYu3YtW7Zs4a677uJnP/sZX/nKV/jsZz/Ll7/85WpP32WXXcZDDz3EBz7wAU4++WTq6+sJw5DXvva1k/aATPb5Herzf77CMKSjo4Pbb7990u9XbjCWZXHnnXfyyCOP8OMf/5h7772Xq6++mptuuolHHnlkSn9jMntt2bKFc845h9WrV/OZz3yGRYsWEY1G+Z//+R8++9nPTvh7fT6zWo9Um3Ugz6ctg/KM7AMFq5WA4Rvf+AZXXnklr3/96/nABz5AR0cHjuNwww03VB/koTwh8fHHH+fee+/lnnvu4Z577uHWW2/lbW97G7fddhtw4HvJ4dwnwjDk3HPP5YMf/OCkr6kEU5OZyrX961//mosvvpi1a9fyH//xH8ybN49IJMKtt946YYIjPPffwfNR+f29//3vn9CDWlF5OJlK+12LFBAewkte8hIA9u7dC5Qnn4RhyKZNm8bV7Nq3bx9DQ0MsWbKkuq2lpWVCQdVSqVQ91qGsWLECgKeeemrCU/b++zQ2NvKa17xmam/qCFqxYgXGGJYtW3bQRmf9+vVs3LiR2267jbe97W3V7QcaSlmxYgXve9/7eN/73semTZs4+eSTuemmm/jGN74BHLnPtqOj4zl/bq2trVx11VVcddVVjIyMsHbtWj7+8Y9zzTXXkEql+MUvfsH1118/bgLO0Ryi2P/Yxhg2b9580KfeFStW8POf/5wzzzxzSjf5l73sZbzsZS/jU5/6FN/85jf567/+a7797W/XdCP6QvDjH/+YYrHIj370o3G9O4dKnRhryZIl/OlPf8IYMy7I2bx587j9DqfNej4P3odrzpw5NDQ0EATBIc/rzjvvZPny5Xz/+98fd45jOw0qotEor3vd63jd615HGIa8853v5Oabb+YjH/kIXV1d1Z7QoaGhcVUuDme0acWKFYyMjDyve8DBru3vfe97xONx7r333nG9hrfeeutz/nkH093dPaE82MaNGwEOONlv+fLlQHlUaiqfw8Ha71qlHMJR999//6RPKZX8q+OOOw6Av/zLvwSYMGvrM5/5DMC42VYrVqyYkLtxyy23HPDJb3/nnXceDQ0N3HDDDRQKhXHfq5zrqaeeyooVK/i3f/s3RkZGJhyjr69vSj/ruXrjG9+I4zhcf/31Ez4/Y0x1aLPyZDh2H2PMuPILALlcbsJ7XbFiBQ0NDeOGKZ7vZ3v++efT2NjIP//zP0+aN3Ooz23/Idv6+nq6urqq5zjZ+4WJfzdH0n//93+TyWSqX995553s3buXCy644ICvueyyywiCgE984hMTvuf7fjXoTqVSE95LpXdnsjJEcmyZ7O91eHj4sG74559/Pnv27BmXc10oFPjP//zPcfsdTptVCQimY6USx3F405vexPe+9z2eeuqpg57XZJ/Xb3/7Wx5++OFxr9m/nbBtu/qAVrluKgHy2PYsm81WexCn4rLLLuPhhx/m3nvvnfC9oaGhas73ZKZybTuOg2VZ49rX7du388Mf/nDK53g4fN+vltOB8sP+zTffzJw5czj11FMnfU1HRwevfOUrufnmmyftGBj7+ztU+12r1EM46t3vfje5XI43vOENrF69mlKpxEMPPcR3vvMdli5dylVXXQXAi1/8Yt7+9rdzyy23MDQ0xNlnn83vfvc7brvtNl7/+tfzqle9qnrMa665hr/7u7/jTW96E+eeey5PPPEE995774ScsANpbGzks5/9LNdccw2nnXYab3nLW2hpaeGJJ54gl8tx2223Yds2X/nKV7jgggtYs2YNV111FQsWLGDPnj3cf//9NDY28uMf//iofGZQbsw++clP8uEPf5jt27fz+te/noaGBrZt28YPfvAD/vZv/5b3v//9rF69mhUrVvD+97+fPXv20NjYyPe+970JuSMbN27knHPO4bLLLuOEE07AdV1+8IMfsG/fvnGJ4kfis/3Sl77E3/zN3/AXf/EXXH755cyZM4edO3dy9913c+aZZ/LFL37xgK8/4YQTeOUrX8mpp55Ka2srjz76KHfeeSf/8A//UD3+2rVr+dd//Vc8z2PBggX87Gc/Y9u2bc/hU56a1tZWzjrrLK666ir27dvH5z73Obq6uiYk9Y919tlnc91113HDDTfw+OOPc9555xGJRNi0aRN33HEHn//857n00ku57bbb+I//+A/e8IY3sGLFCjKZDP/5n/9JY2Nj9SFJjl3nnXdetSfruuuuY2RkhP/8z/+ko6Njyr3u1113HV/84he54ooreM973sO8efO4/fbbqxPiKj1ph9NmVW7+/9//9/9x+eWXE4lEeN3rXnfUCsv/y7/8C/fffz+nn3461157LSeccAKDg4P88Y9/5Oc//zmDg4MAXHTRRXz/+9/nDW94AxdeeCHbtm3jy1/+MieccMK4IPeaa65hcHCQV7/61SxcuJAdO3bwhS98gZNPPrk6wnTeeeexePFi3vGOd/CBD3wAx3H46le/Wm2PpuIDH/gAP/rRj7jooou48sorOfXUU8lms6xfv54777yT7du3H7BtnMq1feGFF/KZz3yG1772tbzlLW+ht7eXf//3f6erq4snn3zy+Xzkk5o/fz433ngj27dvZ9WqVXznO9/h8ccf55ZbbhmXl76/f//3f+ess87ipJNO4tprr2X58uXs27ePhx9+mN27d/PEE08Ah26/a9a0zWee5e655x5z9dVXm9WrV5v6+noTjUZNV1eXefe732327ds3bl/P88z1119vli1bZiKRiFm0aJH58Ic/PG6quzHGBEFg/umf/sm0t7ebZDJpzj//fLN58+YDlkY50LT/H/3oR+aMM84wiUTCNDY2mpe+9KXmW9/61rh9HnvsMfPGN77RtLW1mVgsZpYsWWIuu+wy84tf/OKg77tSsuSOO+4Yt/1A51QpkdDX1zdu+/e+9z1z1llnmbq6OlNXV2dWr15t3vWud5lnn322us+f/vQn85rXvMbU19eb9vZ2c+2115onnnhiXOmA/v5+8653vcusXr3a1NXVmaamJnP66aeb7373u0fls73//vvN+eefb5qamkw8HjcrVqwwV155pXn00UcP+rl98pOfNC996UtNc3OzSSQSZvXq1eZTn/rUuNI9u3fvNm94wxtMc3OzaWpqMm9+85tNd3f3hJI5B/pM3/72t5u6uroJP/vss882a9asGfceAPOtb33LfPjDHzYdHR0mkUiYCy+8sFrOZ+wxx5adqbjlllvMqaeeahKJhGloaDAnnXSS+eAHP2i6u7uNMcb88Y9/NFdccYVZvHixicVipqOjw1x00UWH/Jxkdpqs7MyPfvQj86IXvcjE43GzdOlSc+ONN5qvfvWrk5Y+OVDJjq1bt5oLL7zQJBIJM2fOHPO+973PfO973zPAuJIvxky9zfrEJz5hFixYYGzbPmQJmv2vjUOdM2De9a53jdu2b98+8653vcssWrTIRCIR09nZac455xxzyy23VPcJw9D88z//s1myZImJxWLmlFNOMT/5yU8mXF933nmnOe+880xHR4eJRqNm8eLF5rrrrjN79+4d9zP/8Ic/mNNPP726z2c+85kDlp050GefyWTMhz/8YdPV1WWi0ahpb283Z5xxhvm3f/u3CeXTxprqtf1f//VfZuXKlSYWi5nVq1ebW2+9ddKSOZN9ppUSMfuXE5vs/lP5HT766KPm5S9/uYnH42bJkiXmi1/84qTHHFt2xhhjtmzZYt72treZzs5OE4lEzIIFC8xFF11k7rzzzuo+U2m/a5FlzBHKTheRGfHAAw/wqle9ijvuuINLL710pk9HZJzPfe5z/OM//iO7d+9mwYIFM306Msu98pWvpL+/f9Jhezm6lEMoIiJHxP7LUBYKBW6++WZWrlypYFBkllMOoYiIHBFvfOMbWbx4MSeffDLDw8N84xvf4JlnnjlgWSMRmT0UEIqIyBFx/vnn85WvfIXbb7+dIAg44YQT+Pa3v81f/dVfzfSpicghKIdQREREpMYph1BERESkxikgFBEREalxzzmHMAxDuru7aWhomNblhUREjpYgCNi8eTNdXV0HXHdVRORYYowhk8kwf/58bPvA/YDPOSDs7u5m0aJFz/XlIiIiIjJNdu3axcKFCw/4/eccEDY0NFR/QGNj43M9jIjIrLF7927WrFmjdk1EXjDS6TSLFi2qxm0H8pwDwsowcWNjoxpOEXlBqLRlatdE5IXmUOl9mlQiIiIiUuMUEIqIiIjUOAWEIiIiIjXumFy6LlfwKPo+MdclGY/M9OmIiIiIHNOOuYBw70CGnb3DeEFIxLFZ3NHEvLaDz5wRERE5Wrp7+kml0rS0NDK/s32mT0fkOTmmAsJcwWNn7zAAjcko+aLPzt5hmuri6ikUEZFpt+7Bx7jr7nVkRnI01Ce55MK1rD3zlJk+LZHDdkzlEBZ9Hy8IScRcLMsiEXPxgpCi78/0qYmISI3p7unnrrvXYYyha9lCjDHcdfc6unv6Z/rURA7brAgIcwWP1EieXME76H4x1yXi2OSLPsYY8kWfiGMTc4+pjk4ReZ6m2maIHE2pVJrMSI7OjjYcx6azo43MSI5UKj3TpyZy2GY8kto7kGHr3hQlPyDqOiyf13LAnMBkPMLijiZ29g6TzpWqOYQaLhY5dh3uJLHtPSl29aUJQ0M86iqPWGZMS0sjDfVJenoH6Oxoo6d3gIb6JC0t5aLmyi2UY8mMBoS5gsezu/oZyZfAgqyBZ/2Apro4+aLHSLFEfSxKW1Oy+pp5bQ001cU1y1jkGLR/8He4k8Se3dnPM7v6MRhirkMYGuURy4yZ39nOJReu5a6717F52+5qDuH8zvYp5RYqYJTZZEYDwuFsgXSuSMSxiUQcPC8gnSvy5JYe+tM5/NDg2hbL5rWwrLOleiMRkWPP/sHf3JY69qWywNQmiW3vSfHMrn6Kno/r2PhBSKHkYdsWRd8niQJCmX5rzzyFrhWLxgV2++cW9vQOcNfd62hoqCMacWlpaWTzll2ajCKzysxGV9aYf0353zA09KRGcB2burhLsRSwac8A/cM5DFDyfBzbJhZ1VXZG5BgxWYWAXX1pgtDQ2hCvThJL50qTBne5gseuvjQGg+vYGANeEBIYQ71t6UFRZtT8zvZxPXwbN+9kT3cfq7oWVXMLH/79er745e/iuA6ObZPOZJnb0TouYOxasUg9hTJjZnRSSVMyTkMiRhAYil6A54e4jkVoDLGog23ZRFybkhcwkiuSzhYYGikwmM7heeWZxTt7h5VYLjLLVSoEuI5N0QtwHZswNNiWdcBJYmMnjhR9nzAsDxNHHAfLAj8IsbBYNKecr5UayTMwnNNkE5lR6x58jO/ceR/bdnTzy1/9gW07utm6fQ99/UNEIi5dyxYyNJzh6We3A2gyiswaM/pYnYxHWL24na17U6RzRYIQXMehUArI5j3qEhHyJR9jIFv0CM2fXzuQyePYNrZja7hIZJaLuS6+H7A3k6+OCNQnoizpaGLPQIb+dJ7Y6KSySm7hpj0DFEo+8ahLS0MCPwxxHBsICYxFzHZZvaidWMRl/bZ9ZHJFCiWfWNSlMRnT6IFMu8pQcSIRY83q5az/0xYe/v1THLdyMR3tLSxfuoCNW3ayfcdehoYz/Pqhxzn9JWvKweBQhp/+4hH6BoZY1bVYPYUy7WZ8nGVeWwNR1+FPO/uwLYuGZJTu/gyZfImhkSJhaDCAMeNf5weG1EiBloY4hZJPruApqVxkFqtcwxYWgQnx/ICRfAnPDwjDEHCAcs/gk1v3kc4VMcYQGtg7MIJtl18bizg0JGMsbGtkUUcT67ftww/Kx4Nyz6EfhJpsItOqu6efR//4NL39KRrr69jd3Us04pIvFFmzehmDqQzrHnqcZzduxw9CbNvC83x+8cCjFEslPM/n8Sc3UleX4C9efBzXXf2Gak6hJp/IdJjxgHBgOMe+4RE8P6C9KYkflEtJZHJFAnPw1xY9n2LJZ0t36qD5hFr7WGRmFX2fSMRhXl09IzmPkXyR4WyRoZEijmOTiDo4ls3O3mGa64qkc8VqijGUU4wrecaFkk885jKULWD3W3hBSNS1CYFY1KHkh+VUEz/U6IEcVZVAbePmnfzm4Sfo60+xafMuvJJHa0sTyWQMy7LYtGU38ViUp/60pZruFHFdvJJHLl/Atixc18WEIblcgY2bdvCtO39G14pFmnwi02ZGA8IN23vZ0j1IyQ8IAkMqU8B1LIpeMG54+EBCU+4pPNgMRa19LDLzKkXlC6WAXLFEMNpdaDBgQgwOhZKHwWAsQxgaXMciCMccxLIIQoNlgWNb+EFI71AWC/D8EBsolgIcx8bzQxWtl6OqUlamrz/F1u3dLF44l5NPWsXQUIY/PbMdy7ZoqK9jXmcbT/1pC/l8kWB0VS3LAs/3GUqXv7ZtC8dxiEYjlEoeQWhIpTJs3LyTH//PryfMVtbkEzkaZmxSycBwjk27+ymUfPygPCzsBSH5UjkYtA55hLJsocTwSHHCMna5glcteg3lmY2gSSgiM6FSVD40hqIflntEHLs8uYTyDTJfCsjkSmSyxdFJI+V2ocqUvw4NZPIe6WyBfNGjoyWJ69hE3PKQc+W4KlovR8vYsjJzO1rxSj59/UPk8gXa21oAQ7HoUfI9tm7bg2VZRKOR6t/z/ilQYWjwPJ9CsURoDI5t0dLSAMZoJRSZNjP2+DwwkqPkhwfsCZxCByEAfmhIjeQJTXmoOea61V7BXNEjkyvS3pTAsiIHLWshIkdXJV94w44+jDHkih7Fkocx5Z69MAxpTMbpaKkjCA3pbBFMdaR4XAqJbUHJD/GCkNb6JAvamsozkQOD7VhKD5GjqrJkXdeyhfT2p4hGXVKpNL19KTZu3kljYz1NjXUMpUcYGclz2l+cwLObtk8IBPcXjOYWOo7DCauX4fkBvh+wdfseli9dMGElFJEjaUYCwoHhHOmR4pSGhaeiXLaiQNeCVgC27k0RhIZk1CWbLzGYLhCLuPiB0TCSyAxqa0qyckErO3uHy6kijkMi5lQDvJbRmoTzR4PHuniETK5EOlckNOWhZMuCXMEv3zhti8GRHCub2g/rIU95xfJ8VJase3z9Rvr6h0hnchQKRZ7ZuB3P9znj9JNob2umry/Fb/+wgUKxiOcFUzp2GBp27enl//3Hd0gk4jQ31RMaw76+QZYvXVBdCUXkSJv2yGjD9l62ja5dPFWOxUEnmCRiLk11cYZGCvxpRy/9wzkcx8K1bRIxl2zBYzhXoi4W0TCSyAwbu/xkGBgGM3m6BzLkSwX2DozQ2hjHsR3q4lHmttSRLw6BZRF1bILRGcS2DRHXxsKiu3+EBW1/vq4PFewpr1ier/md7Zz18hdz0xe+ief5dMxpIRqN4NoWHXNaiUYjBEFIrlCkqbGeHTv3ks5kD+tn5PJFCsUSpZJH14pFtDY38tbLL+CUF606Su9Kat20BoQDwzm2jeb0JWIunl864NCwY1vYGLzw4MEgQNR1iLgWfUM5wjAcTTx3MFa52G1zfZyVC9toSk4sQaGeApHpl4xHSBIhV/AY7B4kHnWJOEkGM3n6h/M01cVprIuxpXsQY8rJzuXJZqY87FZOOibiOgxnC+wZGGblgvZDBnuTrZii8jTyXKzqWsyypfPpnNNKaijDjl099KTSLJw/hz89s43UUIYgKA/5trY0Uix6DA1lppwOBWBbFp7vMzAwRGtLA8PpETY8vVXlZ+SomNaAcKRYwg8NdXEXYywijkXpANFeEBqm2odY8DxKw+W9HcfGcQyeH2JZFsYY2hoTxKMT36p6CkRmVmUFk8ZktFwxIAgZzhXIFkr0D+fwRqcZW6PFrMe2FoEB/JCIa9GbytFanztksDf25x1quTyRg2lpaaSjvYXMSI4du3rI5ws0NCRxXIfePb0smN+B53ls2ryLbDZPGIaHFQxCuaamMT59/SnisSjfufM+gjBU+Rk5KqZ1lnF9LIprWxRLAZZlMFOeS3xwhVJIvujTmIyWewsdh2jEIRmLkIxFGBopsmF7H+u37WPvQAaY2FMAmoEsMt3CwGCMoXcoy+6+YXpSI2QLPplcqRoMQnlW5mQ308AYLMvGC0JGiqXR5fGs0eXxrHGVB+DP5W8OtFyeyFTN72znkgvXUvJ8BlNpgjCkVPTYsnU3ff1DbNy0naef3U6pVJ485Y+roTR1QVguut7bnyKXK9C1bCHGGL51x8944Dd/pLun/wi/M6lV09oKtjUlWTavhW17U4zkPYwxxCIWnm+e9wQTAwym89QlogRh+SbjOnb130TMHddjoJ4CkZlV6aHPFsrVACoTRmDqVQZswJjymsj1sSieFzCUyVdHB+ri0XHBXqX8zc7eYdK5UnVkQMPF8lysPfMUGhrq+PTnv8HWrXuIxV0Gh7zyxKd8CQuDZVtgwA+mnjdfYdsAFr4fkM0V2Lp9D42NdYSh4Y9PPEtqKMOC+XPUWyhHxLTXIVyztIOXn7CI4xa30VQfIx6JEButH/Z8eaFhKFsE4Pgl7axa2IbrOiRibjXoq/QYqKdAZOaM7aFvbYhjjakxeDhCAAvmNteRiEXGBJTlA1mTDELMa2vgpGVzWbN0Dictm6s0EXleTnnRKl77mpdhMBQKJcLQ0FBfR6VgUhiGRCIOtj21ETHH+fN+ETeCbdtYFkRcB8/zWb9hC3947BkirsuqrkUYY7jr7nXqKZTnbUYKU7c1JVna0ULEcSh4AbGYi3sERo9du1yfzA/Ltcma6uIHDPoqPQUA6VwJQD0FItOk0kOfiLnlSSKTRW5TYAGxiMNQtsCe/jSu6zCvrYG5LfXMa2vAdZ1xQ8YVyXiElvqErnc5Il7zqpfyFy8+jqamBmzbolgslnupqeS1O0QjB/9bsyyLiGuTiMer24olD98PMAbmdrTQ0FDHYCpN0Stx8otW0tRYr2LVcsTMWHfYcLZAEBr8ICSdLV88lV6Cydg2hIdIwbBtG3t0FuJIsURbU/Kgw0Njy19olrHI9BnbQ29Z5Zvh1AeKyyrBYFtjEmOoLmPnjwaa6vWX6TK/s53zzjmdm77wTaLRCHb5j5pisUR9fT1tLY3YlsWW7d04dqUnvHyvamttIhjNL4y4DoXixDx2x7Fx3QjzO9uZ095MNBqplrZRsWo5UmakpawMF9UnokQcm4F0Hi8IsOHAM4sPEAyOvY2URtcvjTo29bHyRJFDBX2V8hciMr1aGxL0DmXLs/zd8mBFuazMoXOKbQtc2yYWdatL1fUP54hFHEbyRQoln3jUVa+/TJtVXYtZvnQ+czta2dszwJatu+npHSTiOixcMJet2/YQrVS78AOwLOqSCU44bhnxRJTHn9xEOj1CJOLiODZhEOI4NoZynmz/wBDLly3gHW+/GIC77l7H5m27qzOOVYZGnq8ZCQiHcwWyRY+mZJRkY4Jo1GV373B1wfvJhIBrlxe3ryxlFXVt/DCkEhYaU75wFs5ppK0pWX2tgj6R2aMymaRQKqdyzGmuY+ncJrb3DDGYyROEHHC0wLHLw2phaHBsm3ikHBB292dI54rV/ZKxCEtURkqmUUtLI3PaW8hkcuzrHSyvPTy3DRMantm4Hdu2qK9LMDA4XF3CLp3Jsn3XXmLRKK5r09hQR0dHKxue3goWuK5DGBr8IGDhgrm8++8uqxam7lqxiFQqrZqEcsRMe0C4dyDD1r0pRnJFcvkSrY1xjLGwR4O9ydhWuYvdsqClIY4fBoQBo9P4Lea2JIlFIpT8gJIfsKSzeVrfk4hMTWV0IFfwyI2WiUnnirxo2VxOWjaXwZE8YWDww5CNu/oJKS/lVWkbmupi1MXLlQTmNtcxlC3QP5wjky/nAbt2OW+rUPLZ0TtMR0u9eghlWlTK0Nx2+90MptK0tjSyetUSIq7LY09upFgo0duXwrYdTBhWl2Lc15simYiRzxdpbWlgMJXGjKY+eV6AZVu4rsuF57983Col8zvbFQjKETWtAWHlZuA6Nu2Nf16VoCERIxGLEIRFjJk407DyNGVZFh3NdRS9gPxo70IQhMQiERKx8luJuo5yhkRmqaLvUyj5ZPJFPD/EjPbsb9jRR3N9HANEHJu5zXU0JGMMjRRgTMXSfNGnLh5l5YLW8momuRi9Q1mGRgqEBhzXwYQGLwgpeL7KSMm0qpSh+cKXv0s04hKGhl/95o+kR0ZX0ZqkFmGpVKJUKj/QpEeydHa0kYjHKZZKuK5LQ32SruULeNPrz5nutyM1Zlojp/1r/8WiLulckWVzm9nVnyZf9MGEBKbcK1CJCytDxADZgseCtgaaGuLEXJfhbIGdvcMMZgrYlsXiOY3qERCZpWKuizGGoufjWBaWbROGIdlCiWQ8QmMySrbgs2cgw7y2Boaz5YdExy4n3MciDgvaGhgpFNm6N4UBgiDEolx3MPCDansRj7h6OJRpd8qLVnHlX1/It+74GQ/99kkyIzkaG5IEfkihUJqwf3kSio1t2/iej+cFzJnTjFfyKZY81hy/jL97xxvVGyhH3bS2lmNnFiZiLn4QkoxF6GipBwuGRwoEoUXUsYhHXEJTnoVcKPnVXkXHsdk3lK0OBSXjEYqez66+NJ4fsKs/DRYs7WyZzrcmIlOQjEeY01xH33COEHBMeZi3FEIYhvQN5crLVoYhdXGXiGtjTDlfuOSH5Es+W3tSjORL2JZFa0OCSNQtzyou+Xh+gGVZNCSirFrYpodDmRFrzzyFJ57axG8efgLfDxgaHinPPJ6EbVlEoy4vPnElz27ZybzONo4/bhl9/Sk8z+cfxuQNihxN0xoQHmyVgKWdLWBgZ1+a0BgSozMEAZ7Z1U9jMkY04mCMGbeiSK7gsS+VxfdDiiWfTL7E8EgBDCydp6BQZLZZ1tnC3oEM2YKHbVujqwmFZAseEdfGtsBYFqmRIvGoS6Hkky16mNFRg0LJx7HL+6VzReY011GfjLF6UXt1xnJHs3IHZeZ09/Tzp6e3EY9FyYxkCQKDsaxqTcL58+Ywkhkhmyuvf3zySatobm4AC5qa6tnXN1idPaxgUKbLtI+nHKwMzNJ5LXS01I/7Xq7gkYxF8Ecb+v1ri1VykgolD8uySFaWqOtLK6FcZBZKxiOsWdrB1r0pin5AbHQouHsgQxAaXNumtSFOKQiJug6Fkk8sUhlqDghCg2NbMFqEPlvwiEUcXe8ya6RG1zY+buVihoYzeH7577ahPonruixa0EFLywrmtDbTNzBEEIZYlsXfveONmj0sM2ZGEmwOVgZm/+8dau3RmOti2xalICQZcwkCQ8R1CI1RQrnILLX/gyFQDfbq4uUHwIRjU5+Iks4VsS1rdE3Ycp3CZCzKSL5EaMrBoeoNymzS0tJIQ30S27JYML+DdGaEWDTKqpWLSSbj/NUbX8OqlUuY39lOd08/qVSakucTjZSvhTXHL5/hdyC16JjIuD5Yr2IyHmHRnEaGRwrl3kPXIR5xSUSVUC4ym+3/8Ld8Xgs7e4fJl/zqg19TXZyhkcJooOiSzpbIFkpgWbQ0JOhormNBuyaSyexSKUFz193raGlpwA8COtpbaG9r5pIL17L2zFMAqsHgxs07+c3DT5AZyVWHiiv7iEyXYyZiOliv4oHyD3WTEDl2HOjB78+BYkAyHmHZvGaa6uNablJmtbVnnlId/q30/o0dBl734GPcdfc6+vpTbN3ezeKFczn5pFX09A5w193r6FqxSEPGMq2OmYDwUCbLPxSRY8tkD35ac1yOVQcqHt3d089dd6/DGMPcjlae3biTvv4hcvkCnR1tbN62m1QqrYBQptULJiAELVEn8kKla1teSFKpNJmRHF3LFpLLF2hsrCOdyZLN5klnsjTUJ2lpaZzp05QaY8/0CYiIiLwQdff0s+HprXT39I/bXpl00tM7QDIRZ057M5GIS0/fIJZlccmFa9U7KNPuBdVDKCIiMhtUcgQnmygydtLJ5m27mdfZzpvfcA6ruhar3IzMGAWEIiIiR9DYHMGuZQsnnSgydtKJgkCZDTRkLCIicgRVcgQ7O9pwHJvOjjYyIzlSqfS4/eZ3trPm+OUKBmVWUEAoIiJyBI3NEQyCkJ7eAU0UkVlPAaGIiMgRVMkRtCyLzdt2a6KIHBOUQygiInKEKUdQjjUKCEVERI6CAxWmFpmNNGQsIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLj3Jk+ARGRF4Lunn5SqTQtLY3M72yf6dMRETksCghFRJ6ndQ8+xl13ryMzkqOhPsklF65l7ZmnzPRpiYhMmYaMRUSeh+6efu66ex3GGLqWLcQYw113r6O7p3+mT01EZMoUEIqIPA+pVJrMSI7OjjYcx6azo43MSI5UKj3TpyYiMmUKCEVEnoeWlkYa6pP09A4QBCE9vQM01CdpaWmc6VMTkVmmu6efDU9vnZUjCMohFBF5HuZ3tnPJhWu56+51bN62u5pDqIklIjLWbM81VkAoIvI8rT3zFLpWLNIsYxGZ1P65xj29A9x19zoaGuqIRtxZ0W4oIJQXlFzBo+j7xFyXZDwy06cjNWR+Z/uMN+giMjtVco27li2s5ho//Pv1fPHL38VxnVnRY6gcQpn1cgWP1EieXME76H57BzKs37aPDdv7WL9tH3sHMtN0hiIiIge2f67x1u176OsfIhJxZ011AgWEMqtNNcjLFTx29g4D0JiMArCzd/iQQaSIiMjRVsk1tiyLzdt2U/J8OtpbWL50waypTqAhY5m1xgZ5iahDtuCzdW+Kprr4hOHgou/jBSGNySiWZZGIuaRzJYq+TxINHYuIyMwam2tc8ny+8e176OkdoLOjbVZUJ1BAKLNWJcizLUMqUyIIDUEYsmdgmJULxudqxVyXiGOTL/okYi75ok/EsYm5+hOX6TXVJey6e/rZuGkHWBaruhZPuq+WwxN5YRmba5zJZKdcnWA62gLdLWXGTTYRJFfwKJR8giBkKFfEcSxsC4xl0ZvKsaDNG9dLmIxHWNzRxM7eYdK5EhHHZnFHkyaWyLSaalmJdQ8+xpf/6/ts2bYHPwjoaG/mL887kze9/tXM72ynu6efn9//Ox7+3XqCIJwVCeci8vxVAruS59PW2sRbL7/gkLOMp6tcjQJCmVF7BzLs7B3GC8JqEAdUtxU9n5If4BibiGPT2pAghOpQ8Nhgcl5bA011cc0ylhlRKSuRzeZpaqgjM5LjW3f8jNCYcT2A3T39fOuOn7F1Wze+5zOcztLXl2LT5l088Os/8qq1p7Lh6a388YlnibguJ79oZTXhvGvFIvUUihyDunv6+cX9v+Oh365n5+4eevuH6GhvYfWqJZz18hfT0tzAxs07J4wWHKhczdFoCxQQyozZfyJIvljOEQRwHZvGZJRC0SMIDWBwbUOu5BGLuISBmTSYnNfWoJxBmVaVJ/6+/hRbt+9hZCSP5/kUSx7ZXJ7UUIaW5gbOOP0kTlzTxa7d+3jqT1voH0jh+QFBEGJZYFkW23bsYc93+pg/rx3LAte12bh5Fy87bQ09vYOkUmkFhCLHmB/8+AHu+OEveHbTTnwvIJ8vYIwhm81TKBR4YN0fwLZwHYeu5Qu57uo3VHsAJytXs3nb7qPSFigglBmz/0QQ17EYzpawbIu5zXX4QVjOIbQtohGbkheSLxaoT8Z4ansvJd8nGYtWg8mdvcOTTjgROVrGDuWUSh47dvaQTMRobKxn72j5CNuG9Ru28NBv15NIxLAw7O7uIwxN9TgWFpGIi2M7DA9nsICh4RFsy6YuGWfXnl5aWxq1HJ7IMeYHP36AGz/7dTKZLIVCEWMgCENaWxrJ5Qrs2t1LEBrmz20jnoiyY2cP37rzZ9WC1SXPr5arOdqTTxQQyrQaO8Q7diJIEAb0D+cJQoNtWQxYeeoSETw/IBl1aaqLM5jJYYU28YjD0EihPJzsBdiWRV0iolnFMq32H8p5euP2cs+gbdO9tw9jDPX1SXbv6cN1HQrFci7s8PAIxux3MAvi8RgGgx+EGGOY19FOd08fQ+kRjDHjEs412URk9uvu6edr3/gJ+3oHCcMQ3w8AsG2LkWwe24JiySMaidDYWE8sFqFU8tm6dc+4gtXLlsxn247uo740pgJCmTaTDfEu7mhi694UvakcfljebjAMZwuElIPDeDSC69r4oQELhrNFbKt8UfmBYWgkT2iMZhXLtNp/KMeyIJvNk83mwLIIghBGcvhBQMRxCEOD4zh4no/r2oRBiGXb+H6AbduEJmThvE4SiThg8HyPeZ3txGIRrvzrC6tDSLN9PVQRKdu4eSc7d+8jDEMc2wbX4PshYWgoFIrYloUx4LgOpZJHyStRLHoUSx7LIi7Lly6gp3eAbTu6pzT55PnS3VOmxWT5gjt7hzlp2VwWtDXQN5QlGXOJRV2KJZ+SH9JanyDaUs9AOkffcJZiqfx0ZQDbAscCLMiXAhKxgOXzWjRcLNNm7MoD9XUJ/vT0diy7/EdZKnmEocH3A7K5QvU1pZJHaAzGDwgNEJb/pl3XYfGCuSxbMo/BVJp8vkgyEaOttZGlS+azauUSYHoTzEXk+RkYGML3g9EHRgsT/Pl7JjRYEYdkPIbj2PQNprAsi7kdrSTjcTrmtDCQGqa+LkFP7yDRiMua45cf1fPVSiVy1Ixdcq6SL5iIudXC0V4QMpwtUAoDLKt8I80XPHJFj5IXsL0nxY59Qwykc4zkPMpTS8pCA34IxZKPMQbbtmbwnUotGrvywPoNW8iM5IjFyg8kY/MDx/L9AAuL/b9dKJR46k9b+Z+fPUws6tLa0kg+X2TXnl7WHL+8GuxVeiU7O9pmzeoGIjLRugcf4+cP/B5jyg+Gvh9gxuaKWGBZUF+fwLIsOjvamN/ZTl0iTjqT5Ze/+gOP/O4pfvmrP5DN5il5Phue3npUl7ZTD6EcFfsPD89trptQONr3A7buTVHwfIqeT8FjXG5VyQ8p+qUD/gwDWEDEtXFsW5NKZNqtPfMUNm/dzR8ee4ZcrtxoH5LFn59sxiiWPCzPY2g4y+pViykUimRGcjz48BN0LV/I2jNPoeSNXjfb91SHk2Z6dQMRGZ/XC3DX3etIxGMcf9wyfv+HDXh+MP4FBjwvYHAwTWhCUkNpwtCQzxfJ5fI0NtZTl0xQ8jx69g1wy60/qNYkPevlL2ZV1+IjPnysgFCOuMmGh/cNZZnbUse+VJZ0rkQQhBRKPoVSuefQwIRE+8n7WMZzRst1RFx7NIDUpBKZPj/48QPccusP2dc7WE0YP5QD9R5CebZxaijN1m3dOI7NnPYWIhGXb93xM554ahN/emYbQ0MZevtT7OsbZPnSBUctwVxEpmb/vN4Xn7RytCe/lZ59/TiuMyEgNADGUCiWOz127+kb9/1stkAyEce2LHbu3kddXZyzXnYyj6/fyE1f+CbLl85nTnvLEc0h1pCxHHEHGh5uqo9z0rK5zG1JUih5DGeLDGeL5IseY0d8D2f01wvLAWg6VyTi2ISBqQ5TixxN3T39/Pie35RrioUhjju+ObWeQxZDNBYBA6mhDK7rcvxxS3Ech9/98U/c+vWfsP6pLcyf186Jxy+ntbmRt15+gSaUiMyg/fN6jTE8/Lv1OLbN4+s30rNvgFKpfD86nNSmXL5AaihDNFpuE9KZHL39Kfr6h/BKPnM7WqsF64/UMLICQjnixpaTMcZMWFe4N5Wj6AXVkbPQQBD++fUH6UCZlAEyuRKxiMPm7kE2bO9j/bZ97B3IHKm3JDJBKpXG832SifjoRCe7WmDasiAaiRx2bmux6GHZFo5jk83mGRnJ8cT6TdiWTSIeI5GIsnHzLjrmtOC4DtGIBnlEZtJkeb1BEHLC8cvo7RvCGLBH24SDjQ5MZiSbw/MDWlrqSQ+P0LOvn3QmS2NjHXXJxBHPIVZAKEdcZV1hgHSu3B1eWVe46JeXogvDEOsQf32HcysteQH7UlmgPEwN5eXv1FMoR0tLSyMd7S3l0jDRCH4QABbGGIwp5wROKe9hDGMMQRBg2xZDwyP89tEN5ItFXrRmBXV1CTAWxWKJXXt6lTsoMguMrTYQBGE1r/ekE1awsmsRL3/piTQ11T+nY9uWRUtzPb4fksnm2fD0Vnw/YE57M8lE/IjnEOvxUo6KA60rHHNdbKtcP9C2LAyGSudgJQCs3ENjEYeSFxDuf/D9VHoac0WP9qYkfmCwLMgX/UnXPNakE3ku9i8GXZllfNfd6yiWSuze00e+UMD3gtEew3LwdrgCP6RU8nFcmyAMWbpoHk1N9cTjMZ5YvwnP94nHo8odFJkFKu3At+78GX984llaWhq44tLzaGioI+K6BH5AW2sTxsDIaF3SqfYU2o7N3n0D1CeTnHzSKgyGdDpLU1P9USlSrYBQjppkPDJhgkcyHqG9MUnfcBY/MOM6UCr1BaEc5IVheMAZmWNVvh0EIX3DWUxoKAUhjmUxnClQGK15uP+axyJTdaBi0GvPPIWuFYtIpdI8s3E7n//Sd+ju7qdYKgeCh9lBCEBoDJ7n4zgOWPAXJx/H4Ojw9ElrVnDG6SdxzqteqmBQZDYxf/73yac2s+GZrezp7qW/f4hCySMZj1EoFKdWiWDUwgVzWTBvDitXLKK5qZ4gCNm8bTd/9cbXMKe9RbOM5di2dyBDT2qk/IRkgWXKyffGUK0z6FoWxgIvKF9htjW1vEI/NAxni0Qdh3jMJR5x2TOaR+g6ttY8lufkUMWgK/+VPJ9SyQcMJjQHDQYP9ZwThiFBGNLYkGT1cUtpa2kEy2JV12IFgiKzSKV9SCRiLFsyn63b93Dr139MJBrBsS1Kno/n+fgRZ7Rw/USVe+D+ohEX27bo609Vh6Ub6pOsWrlES9fJsS1X8Ni6N0W+6BGPuBT9gMAYHAuS8Si5YokghFjcxbVtcoUSQfWpa2p9LcaA41i0NiRIxFwG0nkM0JCMVmc8a81jORz7L1HX2dHG5m27SaXS4xrlaMRlfmc7mUyWfOHgQ8UH+mt2HBuwiERcjDG0tTbz81/+jiAMj+oapiLy3OzfPti2zVB6hIb6BJlMnmKxhAEKhWJ5OctJRCORcs7xfnr2DeC6Djt37xtXZgpgw9Nb1UMox67KhBIsSCYiRDybkYKHbVs01MWwLIt8ycO2bRKxCEFoyOZLhz3sVvKDag5h1HUAxhXE1prHcjjGJo13drQdMJG7paWRuR2t7Nq9r1xA2vOnPDxkAbZt49gOrmuTTMaJRiO0tTaRSMSqP1fL1InMLvu3D6mhNGEQ0tc/PG6/AwWDUF7BqK4uTjb752UuHcemVPJZc/xycrkCnufz1ssvIJPJctP/u/2orGWuWcYybWKuWw7QRiu0Y5UT74MgZN/gCJl8kSA0lDyf4ZE8uXyJkD/3pkQcm4hj05CIEHWsA85C9gPDQDoPwPJ5LSyf1wJMnPEsMhVjl6jbvG03lmVN2lM3v7OdM04/CYPBdcoTQqZai7C6JGMYYtkWa05Yztuu+Eva2pq0TJ3ILLZ/+xCLRnFHOyKmKpGIs3L5IuLxWLVUVRCEeL7H1u3dzGkvl5kaTo9MqHl4JOsQqptEpk0yHmH5vBae9QPSuSKhAceGuniMfMkn9AKwDDYWuZKPTfmJpfJcFYs4WBbUxaM4jk2u4OEH4bj8Qscq97TEIg5d81tpa0oCTDrjWWSqxk4eOdgwjTe6Zmmh6BGNRDCUy8h43sFXMXEcm7pkgqaGOvLFIi97yYmcdcbJbN+595A9kyIys8a2D30DQ2zcspMdO3um/Pq5c1tYtXIxz27aCVg4TrmjxPMCNvxpK3v29DJ/XjsDA0NTSl95rhQQyrSqlKMZzhbIFIps7x4iVyhR9MthnxWCH47ePEeL/LoY/LD8dWWZuzlNSQqJgELJo1AKKHr+aMBY7jl0bBvb+XP3zGQznkUOR2XyyIH84McP8NWv/5hSySMMQxzbxsLCcZxDBoQR18FxbDzfJ5cvcv+v/8COXT0sWzKfbTu6j0qJCRE5cirtQ3dPP6u6FtPd3Tdx/eJJWBa0tTbT2ztILBahWCoRBH/u5SgWi6SGDSXP48f3/IZSyTtqD4kKCGXaJeMRkvEI0WGHZ7x+vCCszro0gOeXL4ZwvwWOs3kPy4J0tkix5NNYFyUWjdDZ0sC2nhR+aIg6FvFohHjUVZ6gTJvKMnae57N08Xy27dhDqeRjMBSL5WTxWDRCySuv3mNb5dVIgiDEGINlWZQ8j2LRo7EhyYnHryCby7NtRzdvvfwCohH3iCeQi8iRVxlC/v0f/kQmky2PhDk2kUhkdLTAGzdHMh6LsmzJPLbt6KahPslINo9tGfwgxC4vfURbSxPxeHR0FSSLfL6oOoTywmI7FhHXKU8CCct1ZypB4WRGrw08P8CxLfqG8jTXx1k2r4W6RIRdfWnC0BCPusoTlGlVWcausaEO3/dpa21m5+6ecuBnW0SiEcIwxHVsPD/AdZ1y3U3bpn1OMxHXJRpxyeULnP6SE2luqqehPsnmbbuJRlzWHL98pt+iiEzRqq7F/MUpq3FtBz8ImNPWzPadexkYHGL3nl4KRQ/bsli8aC6dc9t46Lfr8X2fYqk8ydL3y/nHkdGlKSNRl1gsysL5HezrG+SvLj2XOW3NmmUsLxwx16UxGcPzy0t1GWMo+SGeHxKL2JS8sBocOnZ5veNExKboGXKjvS5Fz2c4W2BpZwsdzfXKE5QZUVnGLvAD+vqHyObzRCIRulYsZOfOvVijs0uMgUgQ0LV8IfV1Cc542Ys479WnlydSpUf4zp33EYtFxi2BpZxBkWNLpT0wxlSHdpctnc9HPvQOfv3gY/zk3gc5cfVyGhvrePCRJzGhYfWqJWzesod8rkBjSz1z2psZHh5hKD2C7/msPHER2Vy+XIfwKNUjVUAoM6YyyaTkBWTyRQDq41GyhRKOZZcTCkcjwsqiJUFoYVkhEdch4jrUxaPjCk0rT1Bmwthl7BzXYU57M6WSx+JFnTTW1/HkU5vKPQXtLVz8l6/gkgvXTvp0b1sWd929TjmDIsewse3B2Gv5lBetYm5HKzt29WCMIZvNk85kaWyso2v5IpYtWcDvHt1AW1sT9fVJHNumva2Z/oGhaVmyUgGhzKjqJJNcAQxEXYf12/aRzhXHreZg2wBWeWk72yYWcWmqi1GfiKrQtMwK+89E3rxl1+gKBlFOXLOC449bypsueTWnvGjVuNeNXSN5qrOZRWT2mcq1PDZY7OkbJBJxmdPeTDIRp6d3gBPXrJiQN7z/OupHiwJCmXGVSSZQXs1kwZwG7AGLXMGj6AXEIg7JeIR5bfUko1G27E3h2Bb1iagKTcusMnYm8vzOdgYGh/nxPb8hmYyTzxfJZLLj9j/QGsmTNfrTdVMQkcN3ONfy2GBx4+ad/ObhJ9i8bTeOY/Pyl57E3I7Wca87VIWDI0V3UZk19g5k2Nk7jBeUS3asmN9Ka0MC27HG5QXatsXO3mHSuRIRx9YEEpmVunv6+c3DT9DcVD/pSiOHWiN5rAPdbERk5h3OtVxRCfLWHL+c0087kV/c/zse+u16fvPwEzyxftOMXONaqURmhVzBY2dveamfxmQU17EZzORJxCK01CfGBXzz2ho4adlc1iydw0nL5jKvrWGmTlvkgCprnB5opZFDfb9i/5vNkV6dQESen6leywfz+PpNJBKxGb3GFRDKrFD0fbwgJBFzsSyLRMzFC0KK/uRrwSbjEwNFkdlk7Bqnk80aLnk+gR+wdfueg84qPhI3GxE5eg51rR/KbLnGFRDKrBBzXSKOTb5YLtyr3EA51h1sDeR1Dz7GN759D4NDaZ56eiuP/P6pA66R/HxvNiJydE11vfMDmS3XuO62Misk4xEWdzQpN1BeUCabaTh2CPjlp53E1u17KHk+b738ggkzkOHAJSw0sURk9ng+FQJmyzWugFBmjUoJGhWXlheS/WcIVoaHKgvUL1+6oLoiyYGoHI3I7Pd8ZgPPhmtcAaHMKiouLS90Y4eHDmeB+ukqPSEiM2Omr3HlEIqITKPnm28kInI0qIdQRGSazYbhIRGRsRQQiojMgJkeHhIRGUtDxiIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS49yZPoHnIlfwKPo+MdclGY/M9OmIiIiIHNOOuYBw70CGnb3DeEFIxLFZ3NHEvLYGBYkiIjKrdPf0k0qlaWlpZH5n+4SvRWaTYyogzBU8dvYOA9CYjJIv+uzsHaZY8tk3lJ0QJIqIiBxtkwV66x58jLvuXkdmJEdDfZJlS+azbUd39etLLlzL2jNPUZAos8aMBoSH26tX9H28IKQxGcWyLFzHJpXJkyt6JGORcUFiU11cPYUiLwD7txMaDZDZZP/A75IL19K1YhF33b0OYwxdyxaydfsevv29+1ixbAEdc1rIZHLcdfc6BgaH+c3DT5AZyeHYNmecfhLnvOqlCgxlRkx7QFhpzHsHs/QOZwlDQzzqTqlXL+a6RBybfNEnCEIGM3n8MMQYsICIa5OIuaRzJYq+TxLdLESOZfuniNQnoozkSxoNkFnhsSc38rXb7yYacelatpCe3gHuunsdr7vgLDIjObqWLcRxbBrqkwwNZdi6bQ9btu7GsiwSiRipoQzNTfVEXJc/PPY0v310A7/41aNc/TevY+2Zp8z025MaM60BYaVxHxopkMkVsW2bWMSm5AVs3Zs6ZK9eMh5hcUcTW/emGEjnsC2LZCzCcLZI33CObKHcU5iMR4i5x9RouIjsZ2yKSCLqkM6W2Jcaoa0xqdEAmXHrHnyM226/myfWb6K1pZFIxGXRgrls3rYbLAvHsXl643YWLeigty+F5/mkMzmMMeTyBSygVPJYs3o5v3/saUZG8ni+z4ant3LzV39A14pF6imUaTVtUVOlcfeDEM/3MUAYBuRLIbmiR67osac/zcqFbZO+fmA4x0ixRH0syoK2BrKFEnWxCJl8iZjrUPIDSn6AMYZlnc26QYgc4yopIrZlSGVKlPyAQsnH830sKzZuNIACGkaWadPd089dd68jEnFpbWkkny/wzMYdeJ5PQ32SVCrN8PAIW7bt4U/PbKOzo5XWlkb6B4YxxhCLuRSKHrv29NI/MExmJEc04pJMJqhLxtm8dTcbN+9UQCjTatoCwkrjHnVtDBaObVHyDa5twLIA6B3KsqC9cUKDvmF7L9v2pvBDAxgijk0QGvJFv3xxRR1c16a5Po7nhzQ1xKfrbYnIETQ2PzDmuljAYLqA41hYlFNDUiMFohEXzw+xLIvewSxD2YKGkWXapFLp6pBwNBrh6We3M5hKs2jhXM5/+Yv5zcNP0NhQx0tOXs3gUJrMSJ70SI5CsQgG8oUiABHXwWAIw3JHSVNjHRE3wkiQZ8fOvXT39CsolGkzbQFhJf/P80Nc26I0mvdnsLCxaGmIY4DhbIHhXAEMNNXFyRc9tu1NAaPDRrkinhfS3BAjX/Qp+SG2b9HelMCxbZyoreFikWPQ3oEMW/emKPkBUddh+bwWOprrGEjn8EsBQQhYUPRCdvemAYhGHIZG8jQkYrQ1JaY0jJwreOPaGPUoyuFqaWmkoT5JT+8AC+d3UCp5LF44l3/4u8uIRlz++1v/QyqVoVgs4TgOA6lhgiAgDM244wRhiI1FY2MdhXyJUskjm81jgJ8/8HuefGpzdTayyNE2bZFTJf9vZ+8wEdchEoSAwXUcWurjxCIu+aLHk1v3kS95WFjUJ6LUJyJ4QUh9IkKxclPAkC/4NDfEyBZ8ElGX0Fg4wOKOJjXwIrPc/jOFB4ZzPLVtH/mSDxaYEAolj5NXzKOpLs7QSIFoxKLkGUIM4ehxCl5QPWYyHiEIQ7KjAd9k7cDegQzP7Ownky/30DQmYxy3qF09inJY5ne2c8mFa7nr7nVs3ra7Orv4lBet4rEnN7JzZw8j2Tyu65DNFfA8vzIQNk4YGoYzWRLxKAZT3s+2Oa5rEScdv6I6SUX5hDIdprUrbV5bA011cYq+TxgYBkdy9KZyGKBQ8snkihRKPpZtEQaGQslnaMTCDwzDQYgx5acrC7BsGBop0pCMsXJBG8lERPlDIseAyWYO9w1lSY2UE+0r/zMw7LOtJ0V7Y7JcUcAP8AMz6THzRZ/u/mH8EIwxPLllH8WSz9LOluo+uYLH1r0psoUSEdcGAyP50pQmtInsb+2Zp9C1YtGEGoLD6RH8IMRxbIIgIAjKDy1m8j9dgiCkVPIJw5D+wWFi0Qilks+uPftobmpgX98gqVRaAaEcddM+tpqMR8oJ4PgsaGuitT7J7v5h9qWy5Es+oQErMFSuHW/0BuCP6WqPujZBEOIFhmjJZ3d/msUdTbTUJ6b77YjIYdi/uHwmV2Lb3hTxWLkpCsppwpX/YXvPELGoQ8kLOMD9lMreJd9gj67Ons4VeHLrPjCwdF45KCz6PkU/wLIsIo4DFgQln5IfqEyVPCfzO9snBmrGEI9HiUZdMpnslI5T8nwsy8KYEN8PePh364nHotTXJ1lz/DJaWhqPwtmLjDftAeHY3gHfDyh6AfmSRxhCJeabrOG3RrdbQH0iSrbgEXEtWurLE0h29g4TdR1sx1JPocgstX9x+Yhr44emfH1PcuH7ocEv+Ic8rm1B1HXKOVm2RWgMYWjY2Zemo6W+Wooq5jrkTAkvCMoNiim/TnnHcqSsWrmEhQs6eGrDluqo1lTsv2+hWKLkeezrGwQmXw1F5EiatlZwYDjH4Eie7v4MrmNjA4OZAr4flHOGDnHdmDH/DmTKQ0uxiMNAJk8yFiFf8nl8Sw+OY5OYYqFrEZleY4vLJ2LlmcK2BcPZ4nM+pmtb1CUilLyQ8ryT8qNjJOIQGsNwrlDNV1w+r4VnvGBcDuHyeS16gJQjppJfuGXbbkxoysPGYTk/8HC4jo0B9vUO8qX/vJP+gWGCMBy37J3IkTQtAWGlbExptFfQtW0c16bkl3MrLPPngK/SE3gohvIMrZF8QCZXwgCuBbFYhJLns3VvqLwgkVlm7OSydK5ExLHpaK5jZ+/wlK77ycSiLq7t4NsG/PKwczxqk4xGMKFha3cKA9WSNKcfv1CzjOWoaqhPEo/FGMnmAIsw8A77GK7rUvI8RkZyfP9HD9BQn+TUU47HGKOJJnJU2Ef7BwwM56plY+IRh9BAKQgxYVjdxx5zFlO5KTijs7W8wBCOCSZ9U85RGhop0DecY8/A8JF5EyJyxMxra+CkZXNZs3QOJy2bS0MidsDrfpKJmRNkCx7pfBFjDPNa62lvStKQjBONOFhWuaelMRkFqOYvzmttYF5bg4JBOeK6e/r5zcNPsHzpfOqSCQrF0mh1jKmzbQvP9wlDg4VFsVgincnx2JPPUpdMkBnJkUqlj84bkJp11APCkWIJPywXj3ZsG3u0hR97gViWVd0+FQeYaAiUg8Ny/WpDbypHrnD4T2YicnQl45HqJLChbAF7spocAFZ5Elld/OCDGWEQlvMGDbxo2VxevGIuy+e14LoOiZhbXjs25uIFYXllE5GjpFK0uqW5EWPMpOVmDiYadYjHYsRi5Ykpzc0NxGJRwjBgcDDN5q27aKhPaqKJHHFHPSCsj0VxbYtiKQAMllVepaS1IUbMdbAtsC0L17Gx4LACw4PcQ2hIRDGgxl9kFiuOLmPZkIhO+n1joOSHZA8xsSQwjFYeCBgploi5Lk118Wq+ojHllY0ijgrXy9HV0tKIY9v84bGnqyVnDocJy/mv0YiLbdvkC0WKxRL5Qqk80aTkcfJJK4/CmUutO+oBYVtTkmWjZR/ypYCIa9OQiBKJREjEXCKugzUa2Y2pNnFItlXOGXTGRJAW5eHkeNQhHouo8ReZ5SqTTBKxyGE9DE7GCwwjuRLb9w6xfts+hrMFFnc0AZDOlQAVrpejb35nO+1tzQyk0gwMpg85YXJ/bsRlVdcSEokYhUKJXDaP5wcYY7Bti1LJ5777f8dN/+921j342NF5E1KTpiVaWrO0g86WekaKJepjURKxCMO5Alu7UzQkY0Rcm3S2yGAmX37BFC4gx7YIDbiORTLqEok4eEGA54ckYhHc0QRyNf4is1dlksnWvSlcx6bkj0+2muoks4poxKalIV5dwu6kZXM5aVl83KooIkdTd08//QNDNDfWk85kCcOQ4DCSCMMwIF8o0FBfR481QCTiEolGKJU8vJLPjt09FIolfD/Q5BI5oqat+6ytKUkbyerXw9kCJT+gMRkjGnFwbIt0rohFeYjokDcBY0hEIxy3uJ0FbY30pkbY2ZfGCwIijsPc5jqVnRE5RvhBuX5gLOLg2hbZYnmI+HBnHscjf84XTOdKFH2flvqEik7LtEml0gRhyHErF/PI7zdMaWLUWMWix46d5RJqtm0zp72FZDLOrj29eJZPW0sjlgV9/UO4rqNVTOSIOepDxvvLFTw27R5g4+4BMrkiewcyZLJF/MDQUp8gEYv8uQTNQa4kL6S8ssnoDJN9Q1liEYc5TUliEYd9Q1lNKBGZxXIFj70DGbbuTVVXD4lHnAm9hFPlWOUZxyUvUL6gzJhKDmEuX8B2rPI6q4epUChS8nzmd7bjui65XIEwNCTiMQCSiQTpdJaI62pyiRwx09paVhr/gXQO27Koi7vkiwH96RxtjUmWzWsuL1VV8olFHAol/6A3B5tyINhYFxu3+kEi5pLKFOhLZ5lDnYaJRGaZyopFuaJHJlekuT6GY1t4QYgXhFMeKq7kHVpWeaJatuCTzhVJxiJKGZEZsXnLLtKZLNt27qVU9AiDENsqr54zlmNbBOHEv3Lbsjh+9VLq6+t43QVn8fBv19OzbwAsi+ameoIgZO++fiJRl4suOEu9g3LETFtAWFlYvuCVe+0cx8LzDe3NSXJFn+XzW4hHy8M98YhzyERcx4Z4PFK+yCzGrX4wMJwnWyixbe8QPQMjWrVEZBYZv55xjGy+RDpborEuysBwASjnBruOQ740cXaxPVpb0LIs/CAArPJEsmiUeDTK8nktKjgtM6K7p5+77l5HQ32SU05axaOPPUMmk8V2bAqF0rh9DZBMxMnlC6PrGJdL1ESjLol4jIb6JCet6eI1r3opqVSajZt38puHn6C3P8WihXN53QVn8YbXvXJG3qe8ME1bQLitJ0XfcBYL8INyNWnHsSl5IXWxCE3J8prE8ahLGBqyhWI5r2i08R/bU2gBUdclGY2QiLo0JePMbfHZ1ZcmWyiRK3jUxaO0jkku1w1CZHbYfz3j1oYE/ekcfghN9TGGRgq4jk3EtSmUxvcUWhbUxSIsaG8knS+SK3iU/IB49M8TyfTwJzMllUqzdfseRkbyeJ5PPBYhnTaUSuPTl2zbwrYsYrEI0VikPERc8ghDU15pa3s3y5dafOPb91SXqVtz/HJOP+1ErWcsR820BITb96bY0j1IyQuqRaiLfoBrDEEQMndOYzVYqyxrZSgXmU3GI9QnYgyN5Cl65ZpOQWAwlJ+mFnc0MZwtsC+VrXa/u65DW1NiQnK5EstFZt7+6xk7jk1bY5Ll81toSsbZ1pNi294UhVJQnWbsWMBoDVMvDBnMFoi5Divmt9LakKAUBNWl6ERmSsnz6esfAmNob2shncli2RbG//NjjWPbOK5DQ12CZcsW0NbayIMPP4mJlPeJx6LE4zFOPGE5I9n8uJnElf9EjoajHhDmCh47+9IEQTmAC0NDQDl/Ih51MBh29pWX4Fk6r4V5bQ001ZXLRAyPFNi2d4i9/Rm8IMAAMdemvSkB2Di2RdR12Nw9CEBrQ5xMrkSukCeTK9GQjCq5XGSWmWw94+XzWpjXWu7Zq5SpGhzJs2XPACP50d4VC3w/JB5zaUpG8QPDYCZPxLXZl8pWcw87mutY0N6oEQGZdtGIS0d7C5mRHP0DKQqFIhHXBVMOFgFCE+LgcO6rXgq2xaYtOzHG4Ng2lm0Rj0eJRSMUSx6dHW1s3rZbM4llWhz1KKk8PBQQGoNt2biuoeSbcpFNy6boBYzkS6SzBbBgaWcLyXiEJBFirsvO3mFs2yJuuxSDgCA0jOQ85rbWkS+VVyUYO/xUDgI9gtBUbzZKLheZXcY++E1WH7CtKYntWOxLZUnGomRyRbwwpBQGNCajRCMuEdcwmCmwqy9N1HWwLcNgusBAOkfvULYcZGr4WKZRS0sjy5bOJ5vN4/sBjz72NEEQEpqQaMQlDEMs26a5qZ63vuUv2b6jmwcfeRJjIBKJUJeMkc7kiEbLQWFP74CWqZNpc9TLzpSHh8qLzFtWeYkp27awLPCCAAtIxFwCY9jVlx5XKqbo+wShwXEs4jEXx7IwBvywvJRVxLGpj0UnLE/VkIyxZskc1iydw0nL5uqmIDILVdYzPtDDWhiUHxwdx6azrYGmZJx41CXiutVr3bYswtDgOhbpbAnHsbBHZ2/u7B1W6SmZVvM727nkwrXU1SUoeR7RaATHsYlFyx0Wlm0RjUbomNNKNOKyqmsxK7sWcfppa5jb0UoymSAWjzJ3Tgs9vYNYlsUlF65V76BMi6PeQ5iMR1g8p5F0toAfhkRtm4jrUij5BIEhFrEIAkPUsQlDMy7XL+a6RF2H7Og6pa5jUwrLvY2ObbG4o4m2piQlPxg3/FTZLiLHpkpZmkLJp1jyiUddGpIxOlrqyiMKlWt9TiP7hrJkC+WHR9sC17api0fIl3zlDsu0W3vmKXStWEQqlea3j27gllt/SP/AENGoS11dgojrsnzp/GqvX0d7C8YYli2Zz+7uXuKxKH979RuIRlxNHpFpNS2JdUvntYAFu/rShKEhHnWJRRx296XJFX2ijk08GilvH5Prl4xHWD6vhWf9gHSuCEBzfZwlnU0saPvzMPChhp9E5NgxtizN3JY6MrkSQWjomt9KW1OSXMEbd63Hoi5b96YIwhBjWbQ2xPGDULnDMmMqkz/WHL+cluYGbvnqD+ju6QfLYvmyBVzx5vOqgd4lF67lrrvXsa9vkNaWRi65cC2nvGjVDL8DqUXT1lou7Wyho7l+XEPeXB8fFyROlutXCfaGR3MMm5KTl4+p5B2KyLFt/7I0Dcko6VypvOoDE6/1ShuxZ2CY3lSOEHBAucMyK7S1NrF06XziiRiJeIw3v+Ec1p55SvX7Y3sUx/YIdvf0q8SMTKtpfXzevyGfLEg84OvUsIvUhP3L0kylUkAyHmHlgnYWtHkaKZBZo1KoOhGP8fLTTqKnd4DfPPwEp5924rggb/9yMusefIy77l5HZiRHQ32yWotQ5Gia9rWM95eMl2cTF31fCeAiUi1LA5DKFCj5AXNbprYE5aEmqohMp1QqTWYkR2dHW3lyVEcbmZEcqVT6gK+pBJHGGLqWLcQYw113rysPOYscRTMeEO4dyLB+2z42bO9j/bZ97B3IzPQpicgMm9fWwNzmOiyrPGN4XyqrtkGOOS0tjTTUJ+npHSAIwimVkXkuQaTIkTCjAeH4NU2jACoVISLkCh77hrLEIg6tDeXVR9Q2yLGmUobGsiw2b9s9pTIyzyWIFDkSZnQK3v7J41pmTkRAbYO8cBxo0siBVILIu+5ex+Ztu6s5hJpYIkfbjAaEzyV5XERe+NQ2yAvJ4a5BfLhBpMiRMKNDxmOTx9O5EqBSESKitkGkUsdQwaBMlxl/3FZRaRGZjNoGEZHpM+MBIaiotIhMTm2DiMj0mPGyMyIiIiIys55zD6ExBoB0WrWRROSFodKeqV0TkReKSntWidsO5DkHhJlMuUjsokWLnushRERmJbVrIvJCk8lkaGpqOuD3LXOokPEAwjCku7ubhoYGLMt6zicoIjJbBEHA5s2b6erqwnGcmT4dEZHnzRhDJpNh/vz52PaBMwWfc0AoIiIiIi8MmlQiIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiN+/8B+Y21dlgDsDEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " train_dataloaders,\n", + " valid_dataloaders,\n", + " input_dim,\n", + ") = dataset.create_gaussian_mixture_samplers(\n", + " name_source=\"square_five\",\n", + " name_target=\"square_four\",\n", + " valid_batch_size=num_samples_visualize,\n", + ")\n", + "\n", + "eval_data_source = next(valid_dataloaders.source_iter)\n", + "eval_data_target = next(valid_dataloaders.target_iter)\n", + "plot_samples(eval_data_source, eval_data_target);" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "num_train_iters = 20001\n", + "\n", + "neural_f = models.MLP(dim_hidden=[64, 64, 64, 64])\n", + "neural_g = models.MLP(dim_hidden=[64, 64, 64, 64])\n", + "\n", + "lr_schedule = optax.cosine_decay_schedule(\n", + " init_value=5e-4, decay_steps=num_train_iters, alpha=1e-2\n", + ")\n", + "optimizer_f = optax.adamw(learning_rate=lr_schedule)\n", + "optimizer_g = optimizer_f\n", + "\n", + "neural_dual_solver = neuraldual.W2NeuralDual(\n", + " input_dim,\n", + " neural_f,\n", + " neural_g,\n", + " optimizer_f,\n", + " optimizer_g,\n", + " num_train_iters=num_train_iters,\n", + ")\n", + "learned_potentials = neural_dual_solver(\n", + " *train_dataloaders,\n", + " *valid_dataloaders,\n", + " callback=training_callback,\n", + ")\n", + "clear_output()" + ] + }, + { + "cell_type": "markdown", "metadata": {}, + "source": [ + "We can run the same visualizations and Wasserstein-2 distance estimations as before:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Sinkhorn distance between source and target data: 21.226734161376953\n" + "Sinkhorn distance between target predictions and data samples: 1.85\n", + "Sinkhorn distance between source predictions and data samples: 1.40\n", + "Neural dual distance between source and target data: 21.11\n", + "Sinkhorn distance between source and target data: 21.20\n" ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "sinkhorn_dist = sinkhorn_loss(data_source, data_target)\n", - "print(f\"Sinkhorn distance between source and target data: {sinkhorn_dist}\")" + "learned_potentials.plot_ot_map(eval_data_source, eval_data_target, forward=True)\n", + "learned_potentials.plot_ot_map(\n", + " eval_data_source, eval_data_target, forward=False\n", + ")\n", + "\n", + "pred_target = learned_potentials.transport(eval_data_source)\n", + "print(\n", + " f\"Sinkhorn distance between target predictions and data samples: {sinkhorn_loss(pred_target, eval_data_target):.2f}\"\n", + ")\n", + "\n", + "\n", + "pred_source = learned_potentials.transport(eval_data_target, forward=False)\n", + "print(\n", + " f\"Sinkhorn distance between source predictions and data samples: {sinkhorn_loss(pred_source, eval_data_source):.2f}\"\n", + ")\n", + "\n", + "neural_dual_dist = learned_potentials.distance(\n", + " eval_data_source, eval_data_target\n", + ")\n", + "print(\n", + " f\"Neural dual distance between source and target data: {neural_dual_dist:.2f}\"\n", + ")\n", + "\n", + "sinkhorn_dist = sinkhorn_loss(eval_data_source, eval_data_target)\n", + "print(f\"Sinkhorn distance between source and target data: {sinkhorn_dist:.2f}\")" ] } ], @@ -550,7 +686,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.8" + "version": "3.9.15" }, "vscode": { "interpreter": { diff --git a/pyproject.toml b/pyproject.toml index 2b98fec77..350a4a68d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -15,6 +15,7 @@ authors = [ dependencies = [ "jax>=0.1.67", "jaxlib>=0.1.47", + "jaxopt>=0.5.5", # https://github.com/google/jax/discussions/9951#discussioncomment-3017784 "numpy>=1.18.4, !=1.23.0", "matplotlib>=3.0.0", diff --git a/src/ott/problems/__init__.py b/src/ott/problems/__init__.py index 87714fd6b..15cfac006 100644 --- a/src/ott/problems/__init__.py +++ b/src/ott/problems/__init__.py @@ -1 +1 @@ -from . import linear, quadratic +from . import linear, nn, quadratic diff --git a/src/ott/problems/linear/potentials.py b/src/ott/problems/linear/potentials.py index 21588b4d4..b12a41a90 100644 --- a/src/ott/problems/linear/potentials.py +++ b/src/ott/problems/linear/potentials.py @@ -13,6 +13,10 @@ import jax.numpy as jnp import jax.scipy as jsp import jax.tree_util as jtu +import numpy as np + +import matplotlib +import matplotlib.pyplot as plt from ott.problems.linear import linear_problem @@ -79,7 +83,7 @@ def transport(self, vec: jnp.ndarray, forward: bool = True) -> jnp.ndarray: vec = jnp.atleast_2d(vec) if self._corr and isinstance(self.cost_fn, costs.SqEuclidean): - return self._grad_g(vec) if forward else self._grad_f(vec) + return self._grad_f(vec) if forward else self._grad_g(vec) if forward: return vec - self._grad_h_inv(self._grad_f(vec)) else: @@ -157,6 +161,147 @@ def tree_unflatten( ) -> "DualPotentials": return cls(*children, **aux_data) + def plot_ot_map( + self, + source: jnp.ndarray, + target: jnp.ndarray, + forward: bool = True, + ax: Optional[matplotlib.axes.Axes] = None, + legend_kwargs: Optional[Dict[str, Any]] = None, + scatter_kwargs: Optional[Dict[str, Any]] = None, + ) -> Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]: + """Plot data and learned optimal transport map. + + Args: + source: samples from the source measure + target: samples from the target measure + forward: use the forward map from the potentials + if ``True``, otherwise use the inverse map + ax: axis to add the plot to + scatter_kwargs: additional kwargs passed into :meth:`~matplotlib.axes.Axes.scatter` + legend_kwargs: additional kwargs passed into :meth:`~matplotlib.axes.Axes.legend` + + Returns: + matplotlib figure and axis with the plots + """ + if scatter_kwargs is None: + scatter_kwargs = {'alpha': 0.5} + if legend_kwargs is None: + legend_kwargs = { + 'ncol': 3, + 'loc': 'upper center', + 'bbox_to_anchor': (0.5, -0.05), + 'edgecolor': 'k' + } + + if ax is None: + fig = plt.figure(facecolor="white") + ax = fig.add_subplot(111) + else: + fig = ax.get_figure() + + # plot the source and target samples + if forward: + label_transport = r"$\nabla f(source)$" + source_color, target_color = "#1A254B", "#A7BED3" + else: + label_transport = r"$\nabla g(target)$" + source_color, target_color = "#A7BED3", "#1A254B" + + ax.scatter( + source[:, 0], + source[:, 1], + color=source_color, + label='source', + **scatter_kwargs, + ) + ax.scatter( + target[:, 0], + target[:, 1], + color=target_color, + label='target', + **scatter_kwargs, + ) + + # plot the transported samples + base_samples = source if forward else target + transported_samples = self.transport(base_samples, forward=forward) + ax.scatter( + transported_samples[:, 0], + transported_samples[:, 1], + color="#F2545B", + label=label_transport, + **scatter_kwargs, + ) + + for i in range(base_samples.shape[0]): + ax.arrow( + base_samples[i, 0], + base_samples[i, 1], + transported_samples[i, 0] - base_samples[i, 0], + transported_samples[i, 1] - base_samples[i, 1], + color=[0.5, 0.5, 1], + alpha=0.3 + ) + + ax.legend(**legend_kwargs) + return fig, ax + + def plot_potential( + self, + forward: bool = True, + quantile: float = 0.05, + ax: Optional[matplotlib.axes.Axes] = None, + x_bounds: Tuple[float, float] = (-6, 6), + y_bounds: Tuple[float, float] = (-6, 6), + num_grid: int = 50, + contourf_kwargs: Optional[Dict[str, Any]] = None, + ) -> Tuple[matplotlib.figure.Figure, matplotlib.axes.Axes]: + """Plot the potential. + + Args: + forward: use the forward map from the potentials + if ``True``, otherwise use the inverse map + quantile: quantile to filter the potentials with + ax: axis to add the plot to + x_bounds: x-axis bounds of the plot (xmin, xmax) + y_bounds: y-axis bounds of the plot (ymin, ymax) + num_grid: number of points to discretize the domain into a grid + along each dimension + contourf_kwargs: additional kwargs passed into + :meth:`~matplotlib.axes.Axes.contourf` + + Returns: + matplotlib figure and axis with the plots. + """ + if contourf_kwargs is None: + contourf_kwargs = {} + + ax_specified = ax is not None + if not ax_specified: + fig, ax = plt.subplots(figsize=(6, 6), facecolor="white") + else: + fig = ax.get_figure() + + x1 = jnp.linspace(*x_bounds, num=num_grid) + x2 = jnp.linspace(*y_bounds, num=num_grid) + X1, X2 = jnp.meshgrid(x1, x2) + X12flat = jnp.hstack((X1.reshape(-1, 1), X2.reshape(-1, 1))) + Zflat = jax.vmap(self.f if forward else self.g)(X12flat) + Zflat = np.asarray(Zflat) + vmin, vmax = np.quantile(Zflat, [quantile, 1. - quantile]) + Zflat = Zflat.clip(vmin, vmax) + Z = Zflat.reshape(X1.shape) + + CS = ax.contourf(X1, X2, Z, cmap="Blues", **contourf_kwargs) + ax.set_xlim(*x_bounds) + ax.set_ylim(*y_bounds) + fig.colorbar(CS, ax=ax) + if not ax_specified: + fig.tight_layout() + ax.set_title(r"$f$" if forward else r"$g$") + return fig, ax + @jtu.register_pytree_node_class class EntropicPotentials(DualPotentials): diff --git a/src/ott/problems/nn/__init__.py b/src/ott/problems/nn/__init__.py new file mode 100644 index 000000000..61f97ede2 --- /dev/null +++ b/src/ott/problems/nn/__init__.py @@ -0,0 +1 @@ +from . import dataset diff --git a/src/ott/problems/nn/dataset.py b/src/ott/problems/nn/dataset.py new file mode 100644 index 000000000..8810ae701 --- /dev/null +++ b/src/ott/problems/nn/dataset.py @@ -0,0 +1,146 @@ +# 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. +"""Toy datasets for neural OT.""" + +import dataclasses +from typing import Iterable, Iterator, Literal, NamedTuple, Tuple + +import jax +import jax.numpy as jnp +import numpy as np + +__all__ = ['create_gaussian_mixture_samplers', 'Dataset', 'GaussianMixture'] + +Name_t = Literal['simple', 'circle', 'square_five', 'square_four'] + + +class Dataset(NamedTuple): + r"""Samplers from source and target measures. + + Args: + source_iter: loader for the source measure + target_iter: loader for the target measure + """ + source_iter: Iterable[jnp.ndarray] + target_iter: Iterable[jnp.ndarray] + + +@dataclasses.dataclass +class GaussianMixture: + """A mixture of Gaussians. + + Args: + name: the name specifying the centers of the mixture components: + + - ``simple`` (data clustered in one center), + - ``circle`` (two-dimensional Gaussians arranged on a circle), + - ``square_five`` (two-dimensional Gaussians on a square with + one Gaussian in the center), and + - ``square_four`` (two-dimensional Gaussians in the corners of a rectangle) + + batch_size: batch size of the samples + init_key: initial PRNG key + scale: scale of the individual Gaussian samples + variance: the variance of the individual Gaussian samples + """ + name: Name_t + batch_size: int + init_key: jax.random.PRNGKey + scale: float = 5.0 + variance: float = 0.5 + + def __post_init__(self): + gaussian_centers = { + 'simple': + np.array([[0, 0]]), + 'circle': + np.array([ + (1, 0), + (-1, 0), + (0, 1), + (0, -1), + (1.0 / np.sqrt(2), 1.0 / np.sqrt(2)), + (1.0 / np.sqrt(2), -1.0 / np.sqrt(2)), + (-1.0 / np.sqrt(2), 1.0 / np.sqrt(2)), + (-1.0 / np.sqrt(2), -1.0 / np.sqrt(2)), + ]), + 'square_five': + np.array([[0, 0], [1, 1], [-1, 1], [-1, -1], [1, -1]]), + 'square_four': + np.array([[1, 0], [0, 1], [-1, 0], [0, -1]]), + } + if self.name not in gaussian_centers: + raise ValueError( + f'{self.name} is not a valid dataset for GaussianMixture' + ) + self.centers = gaussian_centers[self.name] + + def __iter__(self) -> Iterator[jnp.array]: + return self.create_sample_generators() + + def create_sample_generators(self) -> Iterator[jnp.array]: + # create generator which randomly picks center and adds noise + key = self.init_key + while True: + k1, k2, key = jax.random.split(key, 3) + means = jax.random.choice(k1, self.centers, [self.batch_size]) + normal_samples = jax.random.normal(k2, [self.batch_size, 2]) + samples = self.scale * means + self.variance ** 2 * normal_samples + yield samples + + +def create_gaussian_mixture_samplers( + name_source: Name_t, + name_target: Name_t, + train_batch_size: int = 2048, + valid_batch_size: int = 2048, + key: jax.random.PRNGKey = jax.random.PRNGKey(0), +) -> Tuple[Dataset, Dataset, int]: + """Creates Gaussian samplers for :class:`~ott.solvers.nn.neuraldual.W2NeuralDual`. + + Args: + name_source: name of the source sampler + name_target: name of the target sampler + train_batch_size: the training batch size + valid_batch_size: the validation batch size + key: initial PRNG key + + Returns: + The dataset and dimension of the data. + """ + k1, k2, k3, k4 = jax.random.split(key, 4) + train_dataset = Dataset( + source_iter=iter( + GaussianMixture( + name_source, batch_size=train_batch_size, init_key=k1 + ) + ), + target_iter=iter( + GaussianMixture( + name_target, batch_size=train_batch_size, init_key=k2 + ) + ) + ) + valid_dataset = Dataset( + source_iter=iter( + GaussianMixture( + name_source, batch_size=valid_batch_size, init_key=k3 + ) + ), + target_iter=iter( + GaussianMixture( + name_target, batch_size=valid_batch_size, init_key=k4 + ) + ) + ) + dim_data = 2 + return train_dataset, valid_dataset, dim_data diff --git a/src/ott/solvers/linear/sinkhorn.py b/src/ott/solvers/linear/sinkhorn.py index 844ae4c9f..f91e3cc4b 100644 --- a/src/ott/solvers/linear/sinkhorn.py +++ b/src/ott/solvers/linear/sinkhorn.py @@ -944,6 +944,7 @@ def output_from_state( When differentiating the regularized OT cost, and assuming Sinkhorn has run to convergence, Danskin's (or the envelope) `theorem `_ + :cite:`danskin:67,bertsekas:71` states that the resulting OT cost as a function of the inputs (``geometry``, ``a``, ``b``) behaves locally as if the dual optimal potentials were frozen and did not vary with those inputs. diff --git a/src/ott/solvers/nn/__init__.py b/src/ott/solvers/nn/__init__.py index a695e215c..4e7fa248b 100644 --- a/src/ott/solvers/nn/__init__.py +++ b/src/ott/solvers/nn/__init__.py @@ -1 +1 @@ -from . import icnn, layers, neuraldual +from . import conjugate_solvers, layers, models, neuraldual diff --git a/src/ott/solvers/nn/conjugate_solvers.py b/src/ott/solvers/nn/conjugate_solvers.py new file mode 100644 index 000000000..6eb4d5f57 --- /dev/null +++ b/src/ott/solvers/nn/conjugate_solvers.py @@ -0,0 +1,121 @@ +# 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. +"""Implementation of :cite:`amos:17` input convex neural networks (ICNN).""" + +import abc +from typing import Callable, Literal, NamedTuple, Optional + +from jaxopt import LBFGS + +import jax.numpy as jnp + +from ott import utils + +__all__ = [ + "ConjugateResults", + "FenchelConjugateSolver", + "FenchelConjugateLBFGS", + "DEFAULT_CONJUGATE_SOLVER", +] + + +class ConjugateResults(NamedTuple): + r"""Holds the results of numerically conjugating a function. + + Args: + val: the conjugate value, i.e., :math:`f^\star(y)` + grad: the gradient, i.e., :math:`\nabla f^\star(y)` + num_iter: the number of iterations taken by the solver + """ + + val: float + grad: jnp.ndarray + num_iter: int + + +class FenchelConjugateSolver(abc.ABC): + r"""Abstract conjugate solver class. + + Given a function :math:`f`, numerically estimate the Fenchel conjugate + :math:`f^\star(y) := -\inf_{x\in\mathbb{R}^n} f(x)-\langle x, y\rangle`. + """ + + @abc.abstractmethod + def solve( + self, + f: Callable[[jnp.ndarray], jnp.ndarray], + y: jnp.ndarray, + x_init: Optional[jnp.ndarray] = None + ) -> ConjugateResults: + """Solve for the conjugate. + + Args: + f: function to conjugate + y: point to conjugate + x_init: initial point to search over + + Returns: + The solution to the conjugation. + """ + + +@utils.register_pytree_node +class FenchelConjugateLBFGS(FenchelConjugateSolver): + """Solve for the conjugate using :class:`jaxopt.LBFGS`. + + Args: + gtol: gradient tolerance + max_iter: maximum number of iterations + max_linesearch_iter: maximum number of linesearch iterations + linesearch_type: type of linesearch + decrease_factor: decrease factor for a backtracking line search + ls_method: the line search method + """ + + gtol: float = 1e-3 + max_iter: int = 10 + max_linesearch_iter: int = 10 + linesearch_type: Literal['zoom', 'backtracking'] = 'backtracking' + decrease_factor: float = 0.66 + ls_method: Literal['wolf', 'strong-wolfe'] = 'strong-wolfe' + + def solve( + self, + f: Callable[[jnp.ndarray], jnp.ndarray], + y: jnp.ndarray, + x_init: Optional[jnp.array] = None + ) -> ConjugateResults: + assert y.ndim == 1 + + solver = LBFGS( + fun=lambda x: f(x) - x.dot(y), + tol=self.gtol, + maxiter=self.max_iter, + decrease_factor=self.decrease_factor, + linesearch=self.linesearch_type, + condition=self.ls_method, + implicit_diff=False, + unroll=False + ) + + out = solver.run(y if x_init is None else x_init) + return ConjugateResults( + val=-out.state.value, grad=out.params, num_iter=out.state.iter_num + ) + + +DEFAULT_CONJUGATE_SOLVER = FenchelConjugateLBFGS( + gtol=1e-5, + max_iter=20, + max_linesearch_iter=20, + linesearch_type='backtracking', +) diff --git a/src/ott/solvers/nn/icnn.py b/src/ott/solvers/nn/icnn.py deleted file mode 100644 index 5d24eb2d7..000000000 --- a/src/ott/solvers/nn/icnn.py +++ /dev/null @@ -1,206 +0,0 @@ -# Copyright 2022 Google LLC. -# -# 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. -"""Implementation of :cite:`amos:17` input convex neural networks (ICNN).""" - -from typing import Any, Callable, Sequence, Tuple, Union - -import flax.linen as nn -import jax -import jax.numpy as jnp -import optax -from flax.training import train_state -from jax.nn import initializers - -from ott.math import matrix_square_root -from ott.solvers.nn.layers import PosDefPotentials, PositiveDense - -__all__ = ["ICNN"] - -PRNGKey = Any -Shape = Tuple[int] -Dtype = Any -Array = Any - - -class ICNN(nn.Module): - """Input convex neural network (ICNN) architecture with initialization. - - Implementation of input convex neural networks as introduced in - :cite:`amos:17` with initialization schemes proposed by :cite:`bunne:22`. - - Args: - dim_data: data dimensionality. - dim_hidden: sequence specifying size of hidden dimensions. The - output dimension of the last layer is 1 by default. - init_std: value of standard deviation of weight initialization method. - init_fn: choice of initialization method for weight matrices (default: - `jax.nn.initializers.normal`). - act_fn: choice of activation function used in network architecture - (needs to be convex, default: `nn.relu`). - pos_weights: choice to enforce positivity of weight or use regularizer. - gaussian_map: data inputs of source and target measures for - initialization scheme based on Gaussian approximation of input and - target measure (if None, identity initialization is used). - """ - - dim_data: int - dim_hidden: Sequence[int] - init_std: float = 1e-1 - init_fn: Callable = jax.nn.initializers.normal - act_fn: Callable = nn.relu - pos_weights: bool = True - gaussian_map: Tuple[jnp.ndarray, jnp.ndarray] = None - - def setup(self) -> None: - self.num_hidden = len(self.dim_hidden) - - if self.pos_weights: - hid_dense = PositiveDense - # this function needs to be the inverse map of function - # used in PositiveDense layers - rescale = hid_dense.inv_rectifier_fn - else: - hid_dense = nn.Dense - rescale = lambda x: x - self.use_init = False - # check if Gaussian map was provided - if self.gaussian_map is not None: - factor, mean = self._compute_gaussian_map(self.gaussian_map) - else: - factor, mean = self._compute_identity_map(self.dim_data) - - w_zs = [] - # keep track of previous size to normalize accordingly - normalization = 1 - # subsequent layers propagate value of potential provided by - # first layer in x normalization factor is rescaled accordingly - for i in range(self.num_hidden): - w_zs.append( - hid_dense( - self.dim_hidden[i], - kernel_init=initializers.constant(rescale(1.0 / normalization)), - use_bias=False, - ) - ) - normalization = self.dim_hidden[i] - # final layer computes average, still with normalized rescaling - w_zs.append( - hid_dense( - 1, - kernel_init=initializers.constant(rescale(1.0 / normalization)), - use_bias=False, - ) - ) - self.w_zs = w_zs - - w_xs = [] - # first square layer, initialized to identity - w_xs.append( - PosDefPotentials( - self.dim_data, - num_potentials=1, - kernel_init=lambda *args, **kwargs: factor, - bias_init=lambda *args, **kwargs: mean, - use_bias=True, - ) - ) - - # subsequent layers reinjected into convex functions - for i in range(self.num_hidden): - w_xs.append( - nn.Dense( - self.dim_hidden[i], - kernel_init=self.init_fn(self.init_std), - bias_init=self.init_fn(self.init_std), - use_bias=True, - ) - ) - # final layer, to output number - w_xs.append( - nn.Dense( - 1, - kernel_init=self.init_fn(self.init_std), - bias_init=self.init_fn(self.init_std), - use_bias=True, - ) - ) - self.w_xs = w_xs - - @staticmethod - def _compute_gaussian_map( - inputs: Tuple[jnp.ndarray, jnp.ndarray] - ) -> Tuple[jnp.ndarray, jnp.ndarray]: - - def compute_moments(x, reg=1e-4, sqrt_inv=False): - shape = x.shape - z = x.reshape(shape[0], -1) - mu = jnp.expand_dims(jnp.mean(z, axis=0), 0) - z = z - mu - matmul = lambda a, b: jnp.matmul(a, b) - sigma = jax.vmap(matmul)(jnp.expand_dims(z, 2), jnp.expand_dims(z, 1)) - # unbiased estimate - sigma = jnp.sum(sigma, axis=0) / (shape[0] - 1) - # regularize - sigma = sigma + reg * jnp.eye(shape[1]) - - if sqrt_inv: - sigma_sqrt, sigma_inv_sqrt, _ = matrix_square_root.sqrtm(sigma) - return sigma, sigma_sqrt, sigma_inv_sqrt, mu - else: - return sigma, mu - - source, target = inputs - _, covs_sqrt, covs_inv_sqrt, mus = compute_moments(source, sqrt_inv=True) - covt, mut = compute_moments(target, sqrt_inv=False) - - mo = matrix_square_root.sqrtm_only( - jnp.dot(jnp.dot(covs_sqrt, covt), covs_sqrt) - ) - A = jnp.dot(jnp.dot(covs_inv_sqrt, mo), covs_inv_sqrt) - b = jnp.squeeze(mus) - jnp.linalg.solve(A, jnp.squeeze(mut)) - A = matrix_square_root.sqrtm_only(A) - - return jnp.expand_dims(A, 0), jnp.expand_dims(b, 0) - - @staticmethod - def _compute_identity_map(input_dim: int) -> Tuple[jnp.ndarray, jnp.ndarray]: - A = jnp.eye(input_dim).reshape((1, input_dim, input_dim)) - b = jnp.zeros((1, input_dim)) - - return A, b - - @nn.compact - def __call__(self, x: jnp.ndarray) -> float: - for i in range(self.num_hidden + 2): - if i == 0: - z = self.w_xs[i](x) - # apply both transform on hidden state and x - # x is one step ahead as there is one more hidden layer for x - else: - z = jnp.add(self.w_zs[i - 1](z), self.w_xs[i](x)) - if i != 0 or i != self.num_hidden + 1: - z = self.act_fn(z) - return jnp.squeeze(z) - - def create_train_state( - self, - rng: jnp.ndarray, - optimizer: optax.OptState, - input: Union[int, Tuple[int, ...]], - ) -> train_state.TrainState: - """Create initial `TrainState`.""" - params = self.init(rng, jnp.ones(input))["params"] - return train_state.TrainState.create( - apply_fn=self.apply, params=params, tx=optimizer - ) diff --git a/src/ott/solvers/nn/models.py b/src/ott/solvers/nn/models.py new file mode 100644 index 000000000..e96c70163 --- /dev/null +++ b/src/ott/solvers/nn/models.py @@ -0,0 +1,363 @@ +# 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. +"""Neural potential models.""" + +import abc +from typing import Callable, Optional, Sequence, Tuple, Union + +import flax.linen as nn +import jax +import jax.numpy as jnp +import optax +from flax import struct +from flax.core import frozen_dict +from flax.training import train_state +from jax.nn import initializers + +from ott.math import matrix_square_root +from ott.solvers.nn import layers + +__all__ = ["NeuralTrainState", "ModelBase", "ICNN", "MLP"] + +PotentialValueFn_t = Callable[[jnp.ndarray], jnp.ndarray] +PotentialGradientFn_t = Callable[[jnp.ndarray], jnp.ndarray] + + +class NeuralTrainState(train_state.TrainState): + """Adds information about the model's value and gradient to the state. + + This extends :class:`flax.training.train_state.TrainState` to include + the potential methods from :class:`~ott.solvers.nn.models.ModelBase` + used during training. + + Args: + potential_value_fn: the potential's value function + potential_gradient_fn: the potential's gradient function + """ + potential_value_fn: Callable[ + [frozen_dict.FrozenDict[str, jnp.ndarray], Optional[PotentialValueFn_t]], + PotentialValueFn_t] = struct.field(pytree_node=False) + potential_gradient_fn: Callable[[frozen_dict.FrozenDict[str, jnp.ndarray]], + PotentialGradientFn_t] = struct.field( + pytree_node=False + ) + + +class ModelBase(abc.ABC, nn.Module): + """Base class for the neural solver models.""" + + @property + @abc.abstractmethod + def is_potential(self) -> bool: + """Indicates if the module defines the potential's value or the gradient. + + Returns: + ``True`` if the module defines the potential's value, ``False`` + if it defines the gradient. + """ + + def potential_value_fn( + self, + params: frozen_dict.FrozenDict[str, jnp.ndarray], + other_potential_value_fn: Optional[PotentialValueFn_t] = None, + ) -> PotentialValueFn_t: + r"""Return a function giving the value of the potential. + + Applies the module if :attr:`is_potential` is ``True``, otherwise + constructs the value of the potential from the gradient with + + .. math:: + g(y) = -f(\nabla_y g(y)) + y^T \nabla_y g(y) + + where :math:`\nabla_y g(y)` is detached for the envelope theorem + :cite:`danskin:67,bertsekas:71` + to give the appropriate first derivatives of this construction. + + Args: + params: parameters of the module + x: point to evaluate the value at + other_potential_value: function giving the value of the other potential. + Only needed when :attr:`is_potential` is ``False``. + + Returns: + A function that can be evaluated to obtain the potential's value + """ + if self.is_potential: + return lambda x: self.apply({"params": params}, x) + else: + assert other_potential_value_fn is not None, \ + "The value of the gradient-based potential depends on the value of the other potential" + + def value_fn(x: jnp.ndarray) -> jnp.ndarray: + squeeze = x.ndim == 1 + if squeeze: + x = jnp.expand_dims(x, 0) + grad_g_x = jax.lax.stop_gradient(self.apply({"params": params}, x)) + value = -other_potential_value_fn(grad_g_x) + \ + jax.vmap(jnp.dot)(grad_g_x, x) + return value.squeeze(0) if squeeze else value + + return value_fn + + def potential_gradient_fn( + self, + params: frozen_dict.FrozenDict[str, jnp.ndarray], + ) -> PotentialGradientFn_t: + """Return a function giving the gradient of the potential. + + Args: + params: parameters of the module + + Returns: + A function that can be evaluated to obtain the potential's gradient + """ + if self.is_potential: + return jax.vmap(jax.grad(self.potential_value_fn(params))) + else: + return lambda x: self.apply({'params': params}, x) + + +class ICNN(ModelBase): + """Input convex neural network (ICNN) architecture with initialization. + + Implementation of input convex neural networks as introduced in + :cite:`amos:17` with initialization schemes proposed by :cite:`bunne:22`. + + Args: + dim_data: data dimensionality. + dim_hidden: sequence specifying size of hidden dimensions. The + output dimension of the last layer is 1 by default. + init_std: value of standard deviation of weight initialization method. + init_fn: choice of initialization method for weight matrices (default: + :func:`jax.nn.initializers.normal`). + act_fn: choice of activation function used in network architecture + (needs to be convex, default: :obj:`jax.nn.relu`). + pos_weights: Enforce positive weights with a projection. + If ``False``, the positive weights should be enforced with clipping + or regularization in the loss. + gaussian_map: data inputs of source and target measures for + initialization scheme based on Gaussian approximation of input and + target measure (if ``None``, identity initialization is used). + """ + + dim_data: int + dim_hidden: Sequence[int] + init_std: float = 1e-2 + init_fn: Callable = jax.nn.initializers.normal + act_fn: Callable = nn.relu + pos_weights: bool = True + gaussian_map: Tuple[jnp.ndarray, jnp.ndarray] = None + + @property + def is_potential(self) -> bool: + return True + + def setup(self) -> None: + self.num_hidden = len(self.dim_hidden) + + if self.pos_weights: + hid_dense = layers.PositiveDense + # this function needs to be the inverse map of function + # used in PositiveDense layers + rescale = hid_dense.inv_rectifier_fn + else: + hid_dense = nn.Dense + rescale = lambda x: x + self.use_init = False + # check if Gaussian map was provided + if self.gaussian_map is not None: + factor, mean = self._compute_gaussian_map(self.gaussian_map) + else: + factor, mean = self._compute_identity_map(self.dim_data) + + w_zs = [] + # keep track of previous size to normalize accordingly + normalization = 1 + + for i in range(1, self.num_hidden): + w_zs.append( + hid_dense( + self.dim_hidden[i], + kernel_init=initializers.constant(rescale(1.0 / normalization)), + use_bias=False, + ) + ) + normalization = self.dim_hidden[i] + # final layer computes average, still with normalized rescaling + w_zs.append( + hid_dense( + 1, + kernel_init=initializers.constant(rescale(1.0 / normalization)), + use_bias=False, + ) + ) + self.w_zs = w_zs + + # positive definite potential (the identity mapping or linear OT) + self.pos_def_potential = layers.PosDefPotentials( + self.dim_data, + num_potentials=1, + kernel_init=lambda *_: factor, + bias_init=lambda *_: mean, + use_bias=True, + ) + + # subsequent layers reinjected into convex functions + w_xs = [] + for i in range(self.num_hidden): + w_xs.append( + nn.Dense( + self.dim_hidden[i], + kernel_init=self.init_fn(self.init_std), + bias_init=initializers.constant(0.), + use_bias=True, + ) + ) + # final layer, to output number + w_xs.append( + nn.Dense( + 1, + kernel_init=self.init_fn(self.init_std), + bias_init=initializers.constant(0.), + use_bias=True, + ) + ) + self.w_xs = w_xs + + @staticmethod + def _compute_gaussian_map( + inputs: Tuple[jnp.ndarray, jnp.ndarray] + ) -> Tuple[jnp.ndarray, jnp.ndarray]: + + def compute_moments(x, reg=1e-4, sqrt_inv=False): + shape = x.shape + z = x.reshape(shape[0], -1) + mu = jnp.expand_dims(jnp.mean(z, axis=0), 0) + z = z - mu + matmul = lambda a, b: jnp.matmul(a, b) + sigma = jax.vmap(matmul)(jnp.expand_dims(z, 2), jnp.expand_dims(z, 1)) + # unbiased estimate + sigma = jnp.sum(sigma, axis=0) / (shape[0] - 1) + # regularize + sigma = sigma + reg * jnp.eye(shape[1]) + + if sqrt_inv: + sigma_sqrt, sigma_inv_sqrt, _ = matrix_square_root.sqrtm(sigma) + return sigma, sigma_sqrt, sigma_inv_sqrt, mu + else: + return sigma, mu + + source, target = inputs + _, covs_sqrt, covs_inv_sqrt, mus = compute_moments(source, sqrt_inv=True) + covt, mut = compute_moments(target, sqrt_inv=False) + + mo = matrix_square_root.sqrtm_only( + jnp.dot(jnp.dot(covs_sqrt, covt), covs_sqrt) + ) + A = jnp.dot(jnp.dot(covs_inv_sqrt, mo), covs_inv_sqrt) + b = jnp.squeeze(mus) - jnp.linalg.solve(A, jnp.squeeze(mut)) + A = matrix_square_root.sqrtm_only(A) + + return jnp.expand_dims(A, 0), jnp.expand_dims(b, 0) + + @staticmethod + def _compute_identity_map(input_dim: int) -> Tuple[jnp.ndarray, jnp.ndarray]: + A = jnp.eye(input_dim).reshape((1, input_dim, input_dim)) + b = jnp.zeros((1, input_dim)) + + return A, b + + @nn.compact + def __call__(self, x: jnp.ndarray) -> float: + z = self.act_fn(self.w_xs[0](x)) + for i in range(self.num_hidden): + z = jnp.add(self.w_zs[i](z), self.w_xs[i + 1](x)) + z = self.act_fn(z) + z += self.pos_def_potential(x) + return z.squeeze() + + def create_train_state( + self, + rng: jnp.ndarray, + optimizer: optax.OptState, + input: Union[int, Tuple[int, ...]], + params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]] = None, + ) -> NeuralTrainState: + """Create initial `TrainState`.""" + params = self.init(rng, jnp.ones(input))["params"] + return NeuralTrainState.create( + apply_fn=self.apply, + params=params, + tx=optimizer, + potential_value_fn=self.potential_value_fn, + potential_gradient_fn=self.potential_gradient_fn, + ) + + +class MLP(ModelBase): + """A non-convex MLP. + + Args: + dim_hidden: sequence specifying size of hidden dimensions. The output + dimension of the last layer is automatically set to 1 if + :attr:`is_potential` is ``True``, or the dimension of the input otherwise + is_potential: Model the potential if ``True``, otherwise + model the gradient of the potential + act_fn: Activation function + """ + + dim_hidden: Sequence[int] + is_potential: bool = True + act_fn: Callable[[jnp.ndarray], jnp.ndarray] = nn.leaky_relu + + @nn.compact + def __call__(self, x: jnp.ndarray) -> jnp.ndarray: + squeeze = x.ndim == 1 + if squeeze: + x = jnp.expand_dims(x, 0) + assert x.ndim == 2, x.ndim + n_input = x.shape[-1] + + z = x + for n_hidden in self.dim_hidden: + Wx = nn.Dense(n_hidden, use_bias=True) + z = self.act_fn(Wx(z)) + + if self.is_potential: + Wx = nn.Dense(1, use_bias=True) + z = Wx(z).squeeze(-1) + + quad_term = 0.5 * jax.vmap(jnp.dot)(x, x) + z += quad_term + else: + Wx = nn.Dense(n_input, use_bias=True) + z = x + Wx(z) + + return z.squeeze(0) if squeeze else z + + def create_train_state( + self, + rng: jnp.ndarray, + optimizer: optax.OptState, + input: Union[int, Tuple[int, ...]], + params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]] = None, + ) -> NeuralTrainState: + """Create initial `TrainState`.""" + if params is None: + params = self.init(rng, jnp.ones(input))["params"] + return NeuralTrainState.create( + apply_fn=self.apply, + params=params, + tx=optimizer, + potential_value_fn=self.potential_value_fn, + potential_gradient_fn=self.potential_gradient_fn, + ) diff --git a/src/ott/solvers/nn/neuraldual.py b/src/ott/solvers/nn/neuraldual.py index 919ada881..1b8bc0058 100644 --- a/src/ott/solvers/nn/neuraldual.py +++ b/src/ott/solvers/nn/neuraldual.py @@ -9,76 +9,129 @@ # 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. -"""A Jax implementation of the ICNN based Kantorovich dual.""" +"""A Jax implementation of the neural-based Kantorovich dual.""" import warnings -from typing import Dict, Iterable, List, Literal, Optional, Tuple, Union +from typing import Callable, Dict, Iterable, List, Literal, Optional, Tuple, Union -import flax.linen as nn import jax import jax.numpy as jnp import optax from flax import core +from flax.core import frozen_dict from ott.geometry import costs from ott.problems.linear import potentials -from ott.solvers.nn import icnn +from ott.solvers.nn import conjugate_solvers, models -__all__ = ["NeuralDualSolver"] +__all__ = ["W2NeuralDual"] Train_t = Dict[Literal["train_logs", "valid_logs"], Dict[str, List[float]]] - - -class NeuralDualSolver: - r"""Solver of the ICNN-based Kantorovich dual. - - Learn the optimal transport between two distributions, denoted source - and target, respectively. This is achieved by parameterizing the two - Kantorovich potentials, `g` and `f`, by two input convex neural networks. - :math:`\nabla g` hereby transports source to target cells, and - :math:`\nabla f` target to source cells. - - Original algorithm is described in :cite:`makkuva:20`. +Callback_t = Callable[[int, potentials.DualPotentials], None] +Conj_t = Optional[conjugate_solvers.FenchelConjugateSolver] + + +class W2NeuralDual: + r"""Solver for the Wasserstein-2 Kantorovich dual between Euclidean spaces. + + Learn the Wasserstein-2 optimal transport between two measures + :math:`\alpha` and :math:`\beta` in + :math:`n`-dimensional Euclidean space, + denoted source and target, respectively. + This is achieved by parameterizing a Kantorovich potential + :math:`f_\theta: \mathbb{R}^n\rightarrow\mathbb{R}` + associated with the :math:`\alpha` measure with + an :class:`~ott.solvers.nn.models.ICNN`, + :class:`~ott.solvers.nn.models.MLP`, or other + :class:`~ott.solvers.nn.models.ModelBase`, where + :math:`\nabla f` transports source to target cells. + This potential is learned by optimizing the dual + form associated with the negative inner product cost + + .. math:: + + \text{argsup}_{\theta}\; -\mathbb{E}_{x\sim\alpha}[f_\theta(x)] - + \mathbb{E}_{y\sim\beta}[f^\star_\theta(y)], + + where + :math:`f^\star(y) := -\inf_{x\in\mathbb{R}^n} f(x)-\langle x, y\rangle` + is the convex conjugate. + :math:`\nabla f^\star` transports from the target + to source cells and provides the inverse optimal + transport map from :math:`\beta` to :math:`\alpha`. + This solver estimates the conjugate :math:`f^\star` + with a neural approximation :math:`g` that is fine-tuned + with :class:`~ott.solvers.nn.conjugate_solvers.FenchelConjugateSolver`, + which is a combination further described in :cite:`amos:23`. + + The :class:`~ott.solvers.nn.models.ModelBase` potentials for + ``neural_f`` and ``neural_g`` can + + 1. both provide the values of the potentials :math:`f` and :math:`g`, or + 2. one of them can provide the gradient mapping e.g., :math:`\nabla f` + or :math:`\nabla g` where the potential's value can be obtained + via the Fenchel conjugate as discussed in :cite:`amos:23`. + + The potential's value or gradient mapping is specified via + :attr:`~ott.solvers.nn.models.ModelBase.is_potential`. Args: - input_dim: input dimensionality of data required for network init - neural_f: network architecture for potential f - neural_g: network architecture for potential g - optimizer_f: optimizer function for potential f - optimizer_g: optimizer function for potential g + dim_data: input dimensionality of data required for network init + neural_f: network architecture for potential :math:`f`. + neural_g: network architecture for the conjugate potential :math:`g\approx f^\star` + optimizer_f: optimizer function for potential :math:`f` + optimizer_g: optimizer function for the conjugate potential :math:`g` num_train_iters: number of total training iterations - num_inner_iters: number of training iterations of g per iteration of f + num_inner_iters: number of training iterations of :math:`g` per iteration of :math:`f` + back_and_forth: alternate between updating the forward and backward directions. + Inspired from :cite:`jacobs:20` valid_freq: frequency with which model is validated log_freq: frequency with training and validation are logged logging: option to return logs seed: random seed for network initializations pos_weights: option to train networks with positive weights or regularizer beta: regularization parameter when not training with positive weights + conjugate_solver: numerical solver for the Fenchel conjugate. + amortization_loss: amortization loss for the conjugate :math:`g\approx f^\star`. + Options are 'objective' :cite:`makkuva:20` or 'regression' :cite:`amos:23`. + parallel_updates: Update :math:`f` and :math:`g` at the same time + init_f_params: initial parameters for :math:`f` + init_g_params: initial parameters for :math:`g` """ def __init__( self, - input_dim: int, - neural_f: Optional[nn.Module] = None, - neural_g: Optional[nn.Module] = None, + dim_data: int, + neural_f: Optional[models.ModelBase] = None, + neural_g: Optional[models.ModelBase] = None, optimizer_f: Optional[optax.OptState] = None, optimizer_g: Optional[optax.OptState] = None, - num_train_iters: int = 100, - num_inner_iters: int = 10, - valid_freq: int = 100, - log_freq: int = 100, + num_train_iters: int = 20000, + num_inner_iters: int = 1, + back_and_forth: Optional[bool] = None, + valid_freq: int = 1000, + log_freq: int = 1000, logging: bool = False, seed: int = 0, pos_weights: bool = True, beta: float = 1.0, + conjugate_solver: Conj_t = conjugate_solvers.DEFAULT_CONJUGATE_SOLVER, + amortization_loss: Literal['objective', 'regression'] = 'regression', + parallel_updates: bool = True, + init_f_params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]] = None, + init_g_params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]] = None, ): self.num_train_iters = num_train_iters self.num_inner_iters = num_inner_iters + self.back_and_forth = back_and_forth self.valid_freq = valid_freq self.log_freq = log_freq self.logging = logging self.pos_weights = pos_weights self.beta = beta + self.parallel_updates = parallel_updates + self.conjugate_solver = conjugate_solver + self.amortization_loss = amortization_loss # set random key rng = jax.random.PRNGKey(seed) @@ -91,44 +144,79 @@ def __init__( # set default neural architectures if neural_f is None: - neural_f = icnn.ICNN(dim_data=input_dim, dim_hidden=[64, 64, 64, 64]) + neural_f = models.ICNN(dim_data=dim_data, dim_hidden=[64, 64, 64, 64]) if neural_g is None: - neural_g = icnn.ICNN(dim_data=input_dim, dim_hidden=[64, 64, 64, 64]) + neural_g = models.ICNN(dim_data=dim_data, dim_hidden=[64, 64, 64, 64]) + self.neural_f = neural_f + self.neural_g = neural_g # set optimizer and networks - self.setup(rng, neural_f, neural_g, input_dim, optimizer_f, optimizer_g) + self.setup( + rng, neural_f, neural_g, dim_data, optimizer_f, optimizer_g, + init_f_params, init_g_params + ) def setup( - self, rng: jnp.ndarray, neural_f: icnn.ICNN, neural_g: icnn.ICNN, - input_dim: int, optimizer_f: optax.OptState, optimizer_g: optax.OptState + self, rng: jnp.ndarray, neural_f: models.ModelBase, + neural_g: models.ModelBase, dim_data: int, optimizer_f: optax.OptState, + optimizer_g: optax.OptState, + init_f_params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]], + init_g_params: Optional[frozen_dict.FrozenDict[str, jnp.ndarray]] ) -> None: """Setup all components required to train the network.""" # split random key rng, rng_f, rng_g = jax.random.split(rng, 3) # check setting of network architectures - if ( - neural_f.pos_weights != self.pos_weights or - (neural_g.pos_weights != self.pos_weights) - ): - warnings.warn( - f"Setting of ICNN and the positive weights setting of the " - f"`NeuralDualSolver` are not consistent. Proceeding with " - f"the `NeuralDualSolver` setting, with positive weights " - f"being {self.pos_weights}." - ) + warn_str = f"Setting of ICNN and the positive weights setting of the " \ + f"`W2NeuralDual` are not consistent. Proceeding with " \ + f"the `W2NeuralDual` setting, with positive weights " \ + f"being {self.pos_weights}." + if isinstance( + neural_f, models.ICNN + ) and neural_f.pos_weights is not self.pos_weights: + warnings.warn(warn_str) neural_f.pos_weights = self.pos_weights + + if isinstance( + neural_g, models.ICNN + ) and neural_g.pos_weights is not self.pos_weights: + warnings.warn(warn_str) neural_g.pos_weights = self.pos_weights - self.state_f = neural_f.create_train_state(rng_f, optimizer_f, input_dim) - self.state_g = neural_g.create_train_state(rng_g, optimizer_g, input_dim) + self.state_f = neural_f.create_train_state( + rng_f, optimizer_f, dim_data, init_f_params + ) + self.state_g = neural_g.create_train_state( + rng_g, optimizer_g, dim_data, init_g_params + ) - # define train and valid step functions - self.train_step_f = self.get_step_fn(train=True, to_optimize="f") - self.valid_step_f = self.get_step_fn(train=False, to_optimize="f") + # default to using back_and_forth with the non-convex models + if self.back_and_forth is None: + self.back_and_forth = isinstance(neural_f, models.MLP) - self.train_step_g = self.get_step_fn(train=True, to_optimize="g") - self.valid_step_g = self.get_step_fn(train=False, to_optimize="g") + if self.num_inner_iters == 1 and self.parallel_updates: + self.train_step_parallel = self.get_step_fn( + train=True, to_optimize="both" + ) + self.valid_step_parallel = self.get_step_fn( + train=False, to_optimize="both" + ) + self.train_fn = self.train_neuraldual_parallel + else: + if self.parallel_updates: + warnings.warn( + 'parallel_updates set to True but disabling it because num_inner_iters>1' + ) + if self.back_and_forth: + raise NotImplementedError( + "back_and_forth not implemented without parallel updates" + ) + self.train_step_f = self.get_step_fn(train=True, to_optimize="f") + self.valid_step_f = self.get_step_fn(train=False, to_optimize="f") + self.train_step_g = self.get_step_fn(train=True, to_optimize="g") + self.valid_step_g = self.get_step_fn(train=False, to_optimize="g") + self.train_fn = self.train_neuraldual_alternating def __call__( self, @@ -136,26 +224,103 @@ def __call__( trainloader_target: Iterable[jnp.ndarray], validloader_source: Iterable[jnp.ndarray], validloader_target: Iterable[jnp.ndarray], + callback: Optional[Callback_t] = None, ) -> Union[potentials.DualPotentials, Tuple[potentials.DualPotentials, Train_t]]: - logs = self.train_neuraldual( + logs = self.train_fn( trainloader_source, trainloader_target, validloader_source, validloader_target, + callback=callback, ) res = self.to_dual_potentials() return (res, logs) if self.logging else res - def train_neuraldual( + def train_neuraldual_parallel( self, trainloader_source: Iterable[jnp.ndarray], trainloader_target: Iterable[jnp.ndarray], validloader_source: Iterable[jnp.ndarray], validloader_target: Iterable[jnp.ndarray], + callback: Optional[Callback_t] = None, ) -> Train_t: - """Implementation of the training and validation script.""" # noqa: D401 + """Implementation of the training and validation with parallel updates.""" # noqa: D401 + try: + from tqdm.auto import tqdm + except ImportError: + tqdm = lambda _: _ + # define dict to contain source and target batch + train_batch = {} + valid_batch = {} + + # set logging dictionaries + train_logs = {"loss_f": [], "loss_g": [], "w_dist": [], "directions": []} + valid_logs = {"loss_f": [], "loss_g": [], "w_dist": []} + + for step in tqdm(range(self.num_train_iters)): + update_forward = not self.back_and_forth or step % 2 == 0 + if update_forward: + train_batch["source"] = jnp.asarray(next(trainloader_source)) + train_batch["target"] = jnp.asarray(next(trainloader_target)) + self.state_f, self.state_g, loss, loss_f, loss_g, w_dist = self.train_step_parallel( + self.state_f, + self.state_g, + train_batch, + ) + else: + train_batch["target"] = jnp.asarray(next(trainloader_source)) + train_batch["source"] = jnp.asarray(next(trainloader_target)) + self.state_g, self.state_f, loss, loss_f, loss_g, w_dist = self.train_step_parallel( + self.state_g, + self.state_f, + train_batch, + ) + + if self.logging and step % self.log_freq == 0: + self._update_logs(train_logs, loss_f, loss_g, w_dist) + train_logs["directions"].append( + 'forward' if update_forward else 'backward' + ) + + if callback is not None: + _ = callback(step, self.to_dual_potentials()) + + if not self.pos_weights: + # Only clip the weights of the f network + self.state_f = self.state_f.replace( + params=self._clip_weights_icnn(self.state_f.params) + ) + + # report the loss on an validation dataset periodically + if step != 0 and step % self.valid_freq == 0: + # get batch + valid_batch["source"] = jnp.asarray(next(validloader_source)) + valid_batch["target"] = jnp.asarray(next(validloader_target)) + + valid_loss_f, valid_loss_g, valid_w_dist = self.valid_step_parallel( + self.state_f, + self.state_g, + valid_batch, + ) + + if self.logging: + self._update_logs( + valid_logs, valid_loss_f, valid_loss_g, valid_w_dist + ) + + return {"train_logs": train_logs, "valid_logs": valid_logs} + + def train_neuraldual_alternating( + self, + trainloader_source: Iterable[jnp.ndarray], + trainloader_target: Iterable[jnp.ndarray], + validloader_source: Iterable[jnp.ndarray], + validloader_target: Iterable[jnp.ndarray], + callback: Optional[Callback_t] = None, + ) -> Train_t: + """Implementation of the training and validation with alternating updates.""" # noqa: D401 try: from tqdm.auto import tqdm except ImportError: @@ -166,43 +331,44 @@ def train_neuraldual( valid_batch = {} # set logging dictionaries - train_logs = {"train_loss_f": [], "train_loss_g": [], "train_w_dist": []} - valid_logs = {"valid_loss_f": [], "valid_loss_g": [], "valid_w_dist": []} + train_logs = {"loss_f": [], "loss_g": [], "w_dist": []} + valid_logs = {"loss_f": [], "loss_g": [], "w_dist": []} for step in tqdm(range(self.num_train_iters)): # execute training steps for _ in range(self.num_inner_iters): # get train batch for potential g - batch_g["source"] = jnp.array(next(trainloader_source)) - batch_g["target"] = jnp.array(next(trainloader_target)) + batch_g["source"] = jnp.asarray(next(trainloader_source)) + batch_g["target"] = jnp.asarray(next(trainloader_target)) self.state_g, loss_g, _ = self.train_step_g( self.state_f, self.state_g, batch_g ) # get train batch for potential f - batch_f["source"] = jnp.array(next(trainloader_source)) - batch_f["target"] = jnp.array(next(trainloader_target)) + batch_f["source"] = jnp.asarray(next(trainloader_source)) + batch_f["target"] = jnp.asarray(next(trainloader_target)) self.state_f, loss_f, w_dist = self.train_step_f( self.state_f, self.state_g, batch_f ) if not self.pos_weights: + # Only clip the weights of the f network self.state_f = self.state_f.replace( params=self._clip_weights_icnn(self.state_f.params) ) - # log to wandb + if callback is not None: + callback(step, self.to_dual_potentials()) + if self.logging and step % self.log_freq == 0: - train_logs["train_loss_f"].append(float(loss_f)) - train_logs["train_loss_g"].append(float(loss_g)) - train_logs["train_w_dist"].append(float(w_dist)) + self._update_logs(train_logs, loss_f, loss_g, w_dist) # report the loss on an validuation dataset periodically if step != 0 and step % self.valid_freq == 0: # get batch - valid_batch["source"] = jnp.array(next(validloader_source)) - valid_batch["target"] = jnp.array(next(validloader_target)) + valid_batch["source"] = jnp.asarray(next(validloader_source)) + valid_batch["target"] = jnp.asarray(next(validloader_target)) valid_loss_f, _ = self.valid_step_f( self.state_f, self.state_g, valid_batch @@ -212,103 +378,169 @@ def train_neuraldual( ) if self.logging: - # log training progress - valid_logs["valid_loss_f"].append(float(valid_loss_f)) - valid_logs["valid_loss_g"].append(float(valid_loss_g)) - valid_logs["valid_w_dist"].append(float(valid_w_dist)) + self._update_logs( + valid_logs, valid_loss_f, valid_loss_g, valid_w_dist + ) return {"train_logs": train_logs, "valid_logs": valid_logs} - def get_step_fn(self, train: bool, to_optimize: Literal["f", "g"] = "g"): - """Create a one-step training and evaluation function.""" + def get_step_fn( + self, train: bool, to_optimize: Literal["f", "g", "parallel"] + ): + """Create a parallel training and evaluation function.""" - def loss_fn(params_f, params_g, f, g, batch): - """Loss function for potential f.""" + def loss_fn(params_f, params_g, f_value, g_value, g_gradient, batch): + """Loss function for both potentials.""" # get two distributions source, target = batch["source"], batch["target"] - # get loss terms of kantorovich dual - f_t = f({"params": params_f}, batch["target"]) + init_source_hat = g_gradient(params_g)(target) - grad_g_s = jax.vmap( - lambda x: jax.grad(g, argnums=1)({ - "params": params_g - }, x) - )( - batch["source"] - ) + def g_value_partial(y: jnp.ndarray) -> jnp.ndarray: + """Lazy way of evaluating g if f's computation needs it.""" + return g_value(params_g)(y) - f_grad_g_s = f({"params": params_f}, grad_g_s) - - s_dot_grad_g_s = jnp.sum(source * grad_g_s, axis=1) + f_value_partial = f_value(params_f, g_value_partial) + if self.conjugate_solver is not None: + finetune_source_hat = lambda y, x_init: self.conjugate_solver.solve( + f_value_partial, y, x_init=x_init + ).grad + finetune_source_hat = jax.vmap(finetune_source_hat) + source_hat_detach = jax.lax.stop_gradient( + finetune_source_hat(target, init_source_hat) + ) + else: + source_hat_detach = init_source_hat + + batch_dot = jax.vmap(jnp.dot) + + f_source = f_value_partial(source) + f_star_target = batch_dot(source_hat_detach, + target) - f_value_partial(source_hat_detach) + dual_source = f_source.mean() + dual_target = f_star_target.mean() + dual_loss = dual_source + dual_target + + if self.amortization_loss == 'regression': + amor_loss = ((init_source_hat - source_hat_detach) ** 2).mean() + elif self.amortization_loss == 'objective': + f_value_parameters_detached = lambda x: f_value( + jax.lax.stop_gradient(params_f), x + ) + amor_loss = ( + f_value_parameters_detached(init_source_hat) - + batch_dot(init_source_hat, target) + ).mean() + else: + raise ValueError("Amortization loss has been misspecified.") - s_sq = jnp.sum(source * source, axis=1) - t_sq = jnp.sum(target * target, axis=1) + if to_optimize == "both": + loss = dual_loss + amor_loss + elif to_optimize == "f": + loss = dual_loss + elif to_optimize == "g": + loss = amor_loss + else: + raise ValueError( + f"Optimization target {to_optimize} has been misspecified." + ) - # compute final wasserstein distance - dist = 2 * jnp.mean( - f_grad_g_s - f_t - s_dot_grad_g_s + 0.5 * t_sq + 0.5 * s_sq - ) + if self.pos_weights: + # Penalize the weights of both networks, even though one + # of them will be exactly clipped. + # Having both here is necessary in case this is being called with + # the potentials reversed with the back_and_forth. + loss += self.beta * self._penalize_weights_icnn(params_f) + \ + self.beta * self._penalize_weights_icnn(params_g) - loss_f = jnp.mean(f_t - f_grad_g_s) - loss_g = jnp.mean(f_grad_g_s - s_dot_grad_g_s) + # compute Wasserstein-2 distance + C = jnp.mean(jnp.sum(source ** 2, axis=-1)) + \ + jnp.mean(jnp.sum(target ** 2, axis=-1)) + W2_dist = C - 2. * (f_source.mean() + f_star_target.mean()) - if to_optimize == "f": - return loss_f, dist - elif to_optimize == "g": - if not self.pos_weights: - penalty = self._penalize_weights_icnn(params_g) - loss_g += self.beta * penalty - return loss_g, dist - else: - raise ValueError("Optimization target has been misspecified.") + return loss, (dual_loss, amor_loss, W2_dist) @jax.jit def step_fn(state_f, state_g, batch): """Step function of either training or validation.""" - if to_optimize == "f": - grad_fn = jax.value_and_grad(loss_fn, argnums=0, has_aux=True) - state = state_f - elif to_optimize == "g": - grad_fn = jax.value_and_grad(loss_fn, argnums=1, has_aux=True) - state = state_g - else: - raise ValueError("Potential to be optimize might be misspecified.") - + grad_fn = jax.value_and_grad(loss_fn, argnums=[0, 1], has_aux=True) if train: # compute loss and gradients - (loss, dist), grads = grad_fn( + (loss, (loss_f, loss_g, W2_dist)), (grads_f, grads_g) = grad_fn( state_f.params, state_g.params, - state_f.apply_fn, - state_g.apply_fn, + state_f.potential_value_fn, + state_g.potential_value_fn, + state_g.potential_gradient_fn, batch, ) # update state - return state.apply_gradients(grads=grads), loss, dist + if to_optimize == "both": + return state_f.apply_gradients(grads=grads_f), \ + state_g.apply_gradients(grads=grads_g), \ + loss, loss_f, loss_g, W2_dist + elif to_optimize == "f": + return state_f.apply_gradients(grads=grads_f), \ + loss_f, W2_dist + elif to_optimize == "g": + return state_g.apply_gradients(grads=grads_g), \ + loss_g, W2_dist + else: + raise ValueError("Optimization target has been misspecified.") else: # compute loss and gradients - (loss, dist), _ = grad_fn( + (loss, (loss_f, loss_g, W2_dist)), (grads_f, grads_g) = grad_fn( state_f.params, state_g.params, - state_f.apply_fn, - state_g.apply_fn, + state_f.potential_value_fn, + state_g.potential_value_fn, + state_g.potential_gradient_fn, batch, ) # do not update state - return loss, dist + if to_optimize == "both": + return loss_f, loss_g, W2_dist + elif to_optimize == "f": + return loss_f, W2_dist + elif to_optimize == "g": + return loss_g, W2_dist + else: + raise ValueError("Optimization target has been misspecified.") return step_fn - def to_dual_potentials(self) -> potentials.DualPotentials: - """Return the Kantorovich dual potentials from the trained potentials.""" - f = lambda x: self.state_f.apply_fn({"params": self.state_f.params}, x) - g = lambda x: self.state_g.apply_fn({"params": self.state_g.params}, x) + def to_dual_potentials( + self, finetune_g: bool = True + ) -> potentials.DualPotentials: + r"""Return the Kantorovich dual potentials from the trained potentials. + + Args: + finetune_g: Run the conjugate solver to finetune the prediction. + + Returns: + A dual potential object + """ + f_value = self.state_f.potential_value_fn(self.state_f.params) + g_value_prediction = self.state_g.potential_value_fn( + self.state_g.params, f_value + ) + + def g_value_finetuned(y: jnp.ndarray) -> jnp.ndarray: + x_hat = jax.grad(g_value_prediction)(y) + grad_g_y = jax.lax.stop_gradient( + self.conjugate_solver.solve(f_value, y, x_init=x_hat).grad + ) + g_y = -f_value(grad_g_y) + jnp.dot(grad_g_y, y) + return g_y + return potentials.DualPotentials( - f, g, cost_fn=costs.SqEuclidean(), corr=True + f=f_value, + g=g_value_prediction if not finetune_g else g_value_finetuned, + cost_fn=costs.SqEuclidean(), + corr=True ) @staticmethod @@ -327,3 +559,14 @@ def _penalize_weights_icnn(params: Dict[str, jnp.ndarray]) -> float: if k.startswith("w_z"): penalty += jnp.linalg.norm(jax.nn.relu(-param["kernel"])) return penalty + + @staticmethod + def _update_logs( + logs: Dict[str, Union[float, str]], + loss_f: jnp.ndarray, + loss_g: jnp.ndarray, + w_dist: jnp.ndarray, + ) -> None: + logs["loss_f"].append(float(loss_f)) + logs["loss_g"].append(float(loss_g)) + logs["w_dist"].append(float(w_dist)) diff --git a/tests/solvers/nn/icnn_test.py b/tests/solvers/nn/icnn_test.py index a039808a9..9f6babf96 100644 --- a/tests/solvers/nn/icnn_test.py +++ b/tests/solvers/nn/icnn_test.py @@ -19,7 +19,7 @@ import jax.numpy as jnp import numpy as np -from ott.solvers.nn import icnn +from ott.solvers.nn import models @pytest.mark.fast @@ -31,7 +31,7 @@ def test_icnn_convexity(self, rng: jnp.ndarray): dim_hidden = (64, 64) # define icnn model - model = icnn.ICNN(n_features, dim_hidden=dim_hidden) + model = models.ICNN(n_features, dim_hidden=dim_hidden) # initialize model key1, key2, key3 = jax.random.split(rng, 3) @@ -57,7 +57,7 @@ def test_icnn_hessian(self, rng: jnp.ndarray): # define icnn model n_features = 2 dim_hidden = (64, 64) - model = icnn.ICNN(n_features, dim_hidden=dim_hidden) + model = models.ICNN(n_features, dim_hidden=dim_hidden) # initialize model key1, key2 = jax.random.split(rng) diff --git a/tests/solvers/nn/neuraldual_test.py b/tests/solvers/nn/neuraldual_test.py index 84e1c7dc8..fe7f9ee34 100644 --- a/tests/solvers/nn/neuraldual_test.py +++ b/tests/solvers/nn/neuraldual_test.py @@ -11,74 +11,52 @@ # See the License for the specific language governing permissions and # limitations under the License. """Tests for implementation of ICNN-based Kantorovich dual by Makkuva+(2020).""" -from typing import Iterator, Literal, Sequence, Tuple +from typing import Sequence, Tuple import pytest import jax -import jax.numpy as jnp import numpy as np -from ott.solvers.nn import neuraldual +from ott.problems.nn import dataset +from ott.solvers.nn import models, neuraldual - -class ToyDataset: - - def __init__( - self, name: Literal['simple', 'circle', 'square_four', 'square_five'] - ): - self.name = name - - def __iter__(self) -> Iterator[jnp.ndarray]: - yield from self.create_sample_generators() - - def create_sample_generators(self, scale: float = 5.0, variance: float = 0.5): - # given name of dataset, select centers - if self.name == "simple": - centers = np.array([0, 0]) - elif self.name == "circle": - centers = np.array([ - (1, 0), - (-1, 0), - (0, 1), - (0, -1), - (1.0 / np.sqrt(2), 1.0 / np.sqrt(2)), - (1.0 / np.sqrt(2), -1.0 / np.sqrt(2)), - (-1.0 / np.sqrt(2), 1.0 / np.sqrt(2)), - (-1.0 / np.sqrt(2), -1.0 / np.sqrt(2)), - ]) - elif self.name == "square_five": - centers = np.array([[0, 0], [1, 1], [-1, 1], [-1, -1], [1, -1]]) - elif self.name == "square_four": - centers = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]]) - else: - raise NotImplementedError(self.name) - - # create generator which randomly picks center and adds noise - centers = scale * centers - while True: - center = centers[np.random.choice(len(centers))] - point = center + variance ** 2 * np.random.randn(2) - - yield np.expand_dims(point, 0) - - @property - def ndim(self) -> int: - return 2 +ModelPair_t = Tuple[models.ModelBase, models.ModelBase] +DatasetPair_t = Tuple[dataset.Dataset, dataset.Dataset] @pytest.fixture(params=[("simple", "circle")]) -def toy_dataset(request) -> Tuple[Iterator[jnp.ndarray], Iterator[jnp.ndarray]]: - src = iter(ToyDataset(request.param[0])) - tgt = iter(ToyDataset(request.param[1])) - return src, tgt +def datasets(request: Tuple[str, str]) -> DatasetPair_t: + train_dataset, valid_dataset, _ = dataset.create_gaussian_mixture_samplers( + request.param[0], request.param[1] + ) + return (train_dataset, valid_dataset) + + +@pytest.fixture(params=["icnns", "mlps", "mlps-grad"]) +def neural_models(request: str) -> ModelPair_t: + if request.param == 'icnns': + return ( + models.ICNN(dim_data=2, dim_hidden=[128]), + models.ICNN(dim_data=2, dim_hidden=[128]) + ) + elif request.param == 'mlps': + return (models.MLP(dim_hidden=[128]), models.MLP(dim_hidden=[128])) + elif request.param == 'mlps-grad': + return ( + models.MLP(dim_hidden=[128]), + models.MLP(is_potential=False, dim_hidden=[128]) + ) + else: + raise ValueError(f'Invalid request: {request.param}') class TestNeuralDual: - @pytest.mark.fast + @pytest.mark.fast.with_args("back_and_forth", [True, False]) def test_neural_dual_convergence( - self, toy_dataset: Tuple[ToyDataset, ToyDataset] + self, datasets: DatasetPair_t, neural_models: ModelPair_t, + back_and_forth: bool ): """Tests convergence of learning the Kantorovich dual using ICNNs.""" @@ -89,37 +67,35 @@ def decreasing(losses: Sequence[float]) -> bool: return all(x >= y for x, y in zip(losses, losses[1:])) num_train_iters, log_freq = 100, 100 - dataloader_source, dataloader_target = toy_dataset + neural_f, neural_g = neural_models # initialize neural dual - neural_dual_solver = neuraldual.NeuralDualSolver( - input_dim=2, + neural_dual_solver = neuraldual.W2NeuralDual( + dim_data=2, + neural_f=neural_f, + neural_g=neural_g, num_train_iters=num_train_iters, logging=True, - log_freq=log_freq - ) - neural_dual, logs = neural_dual_solver( - dataloader_source, dataloader_target, dataloader_source, - dataloader_target + log_freq=log_freq, + back_and_forth=back_and_forth, ) + train_dataset, valid_dataset = datasets + neural_dual, logs = neural_dual_solver(*train_dataset, *valid_dataset) # check if training loss of f is increasing and g is decreasing - assert increasing(logs['train_logs']['train_loss_f']) - assert decreasing(logs['train_logs']['train_loss_g']) + assert increasing(logs['train_logs']['loss_f']) + assert decreasing(logs['train_logs']['loss_g']) - def test_neural_dual_jit(self, toy_dataset: Tuple[ToyDataset, ToyDataset]): + def test_neural_dual_jit(self, datasets: DatasetPair_t): num_train_iters = 10 - dataloader_source, dataloader_target = toy_dataset # initialize neural dual - neural_dual_solver = neuraldual.NeuralDualSolver( - input_dim=2, num_train_iters=num_train_iters - ) - neural_dual = neural_dual_solver( - dataloader_source, dataloader_target, dataloader_source, - dataloader_target + neural_dual_solver = neuraldual.W2NeuralDual( + dim_data=2, num_train_iters=num_train_iters ) + train_dataset, valid_dataset = datasets + neural_dual = neural_dual_solver(*train_dataset, *valid_dataset) - data_source = next(dataloader_source) + data_source = next(train_dataset.source_iter) pred_target = neural_dual.transport(data_source) compute_transport = jax.jit(