From 132395b7a93f872b248f960266addae138fbf606 Mon Sep 17 00:00:00 2001 From: Fanjin Date: Sun, 26 Jan 2025 15:13:26 +0000 Subject: [PATCH 1/8] adding tutorial on constrained bo from clf --- notebooks_community/clf_constrained_bo.ipynb | 840 +++++++++++++++++++ 1 file changed, 840 insertions(+) create mode 100644 notebooks_community/clf_constrained_bo.ipynb diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb new file mode 100644 index 0000000000..254083854e --- /dev/null +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -0,0 +1,840 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# BO with Binary Black-box Constraint\n", + "* Contributors: Fanjin Wang\n", + "* Last updated: Jan 26, 2025\n", + "* BoTorch version: 0.12.1.dev91+g0df552162.d20250124\n", + "\n", + "In this notebook, we show how to implement BO under unknown constraints learned from a classification model trained together with a GP.\n", + "\n", + "To add some context, the recommendations presented by BO to assist laboratory experiments may lead to undesired experiment results, such as failures or infeasible protocols [1]. And in these cases, the underlying feasible region can only be obtained through experimentation. In such cases, these unknown constraints can be treated as an unknown variable modelled by a surrogate classification model. \n", + "\n", + "The present code is also inspired by the implementation in [2].\n", + "\n", + "[1]: [Wang, F., Parhizkar, M., Harker, A., & Edirisinghe, M. (2024). Constrained composite Bayesian optimization for rational synthesis of polymeric particles. ArXiv, abs/2411.10471](https://arxiv.org/abs/2411.10471).\n", + "\n", + "[2]: [Tian, Y., Zuniga, A., Zhang, X., Dürholt, J.P., Das, P., Chen, J., Matusik, W., & Konakovic-Lukovic, M. (2024). Boundary Exploration for Bayesian Optimization With Unknown Physical Constraints. ArXiv, abs/2402.07692](https://arxiv.org/abs/2402.07692).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set dtype and device" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "\n", + "tkwargs = {\n", + " \"dtype\": torch.double,\n", + " \"device\": torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\"),\n", + "}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Problem setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We begin with setting up a classical synthetic problem `Townsend` presented in [3]. The objective to be maximized is:\n", + "\n", + "$$\n", + "\\begin{align*}\n", + "y_{\\text{obj}} &= \\cos\\left((x_1 - 0.1) x_2\\right)^2 + x_1 \\sin(3 x_1 + x_2)\n", + "\\end{align*}\n", + "$$\n", + "\n", + "Subjected to the constraint:\n", + "$$\n", + "y_{\\text{con}} = \\left(\\left(2 \\cos(t) - 0.5 \\cos(2t) - 0.25 \\cos(3t) - 0.125 \\cos(4t)\\right)^2 + \\left(2 \\sin(t)\\right)^2 - x_1^2 - x_2^2\\right)>0\n", + "$$ \n", + "where $t = \\arctan\\left(\\frac{x_1}{x_2}\\right)$\n", + "\n", + "Here, we follow a natural representation where $y_{\\text{con}}=1$ indicates a feasible condition. We will train a classification model to predict the feasibility of the point. Note that in BoTorch's implementation, **negative values** indicate feasibility, thus we need to do conversion later when feeding feasibility into the pipeline.\n", + "\n", + "\n", + "[3]: Townsend, A. (2014). Constrained optimization in Chebfun. https://www.chebfun.org/examples/opt/ConstrainedOptimization.html" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class Townsend():\n", + " def __init__(self):\n", + " self.dim = 2\n", + " self.lb = torch.tensor([-2.25, 2.25], **tkwargs)\n", + " self.ub = torch.tensor([-2.5, 1.75], **tkwargs)\n", + " self.bounds = torch.stack([self.lb, self.ub]).T\n", + " self._optimal_value = 1.660\n", + " self.name = \"Townsend\"\n", + "\n", + " def __call__(self, x):\n", + " return self.objective(x)\n", + "\n", + " def constraint(self, x):\n", + " x1, x2 = x[..., 0], x[..., 1]\n", + " t = torch.atan2(x1, x2) \n", + " constraint_value = (((2 * torch.cos(t) - 0.5 * torch.cos(2 * t) - 0.25 * torch.cos(3 * t) - 0.125 * torch.cos(4 * t)) ** 2 + (2 * torch.sin(t)) ** 2 - x1 ** 2 - x2 ** 2) > 0).float()\n", + " return constraint_value\n", + " \n", + " def objective(self,x):\n", + " x1, x2 = x[..., 0], x[..., 1]\n", + " return torch.cos((x1 - 0.1) * x2) ** 2 + x1 * torch.sin(3 * x1 + x2)\n", + "\n", + "townsend = Townsend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot the landscape of the Townsend function as a reference. The infeasible region is masked out." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the townsend function and constraint\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def plot_townsend(ax):\n", + " x = np.linspace(-2.5, 2.5, 100)\n", + " y = np.linspace(-2.5, 2.5, 100)\n", + " X, Y = np.meshgrid(x, y)\n", + "\n", + " obj = townsend(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", + " con = townsend.constraint(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", + "\n", + " #mask out the constraint region<0\n", + " obj[con==0] = np.nan\n", + "\n", + " c = ax.contourf(X, Y, obj, levels=20,cmap='Blues')\n", + "\n", + " ax.set_xlabel(\"X1\")\n", + " ax.set_ylabel(\"X2\")\n", + " ax.set_title(\"Townsend Problem\")\n", + "\n", + " plt.colorbar(c, ax=ax, orientation='vertical')\n", + " return ax\n", + "\n", + "# Plot the townsend function and constraint\n", + "fig, ax = plt.subplots(1, 1, figsize=(5, 4))\n", + "plot_townsend(ax)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate Training Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[KeOps] Warning : \n", + " The default C++ compiler could not be found on your system.\n", + " You need to either define the CXX environment variable or a symlink to the g++ command.\n", + " For example if g++-8 is the command you can do\n", + " import os\n", + " os.environ['CXX'] = 'g++-8'\n", + " \n", + "[KeOps] Warning : Cuda libraries were not detected on the system or could not be loaded ; using cpu only mode\n" + ] + } + ], + "source": [ + "from botorch.utils.sampling import draw_sobol_samples\n", + "def generate_initial_data(n):\n", + " # generate training data within the problem bounds\n", + " train_x = draw_sobol_samples(bounds=townsend.bounds, n=n, q=1).squeeze(1)\n", + " train_obj = townsend(train_x).unsqueeze(-1)\n", + " train_con = townsend.constraint(train_x)\n", + " return train_x, train_obj, train_con" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Classification Model\n", + "We use [approximate GP](https://docs.gpytorch.ai/en/stable/examples/04_Variational_and_Approximate_GPs/Non_Gaussian_Likelihoods.html) implemented by GPyTorch as the surrogate for unknown constraint. The latent function is modelled by a GP, and the likelihood is modelled by a Bernoulli distribution. Followed by training, we extract the probability from the Bernoulli distribution as the feasibility prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import gpytorch\n", + "from gpytorch.models import ApproximateGP\n", + "from gpytorch.variational import CholeskyVariationalDistribution, VariationalStrategy\n", + "from gpytorch.kernels.scale_kernel import ScaleKernel\n", + "from botorch.models.gpytorch import GPyTorchModel\n", + "\n", + "class GP_vi(ApproximateGP, GPyTorchModel):\n", + " def __init__(self, train_x, train_y):\n", + " self.train_inputs = (train_x,)\n", + " self.train_targets = train_y\n", + "\n", + " variational_distribution = CholeskyVariationalDistribution(train_x.size(0))\n", + " variational_strategy = VariationalStrategy(\n", + " self, train_x, variational_distribution\n", + " )\n", + " super(GP_vi, self).__init__(variational_strategy)\n", + "\n", + " self.mean_module = gpytorch.means.ConstantMean()\n", + " self.covar_module = ScaleKernel(gpytorch.kernels.RBFKernel())\n", + " self.likelihood = gpytorch.likelihoods.BernoulliLikelihood()\n", + "\n", + " def forward(self, x):\n", + " mean_x = self.mean_module(x)\n", + " covar_x = self.covar_module(x)\n", + " return gpytorch.distributions.MultivariateNormal(mean_x, covar_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Model initialization\n", + "We initialize the model with a `SingleTaskGP` model and the custom `GP_vi` model for the feasibility modeling." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from gpytorch.mlls import ExactMarginalLogLikelihood\n", + "from botorch.models import SingleTaskGP, ModelListGP\n", + "from botorch.fit import fit_gpytorch_mll\n", + "from botorch.models.transforms.outcome import Standardize\n", + "from botorch.utils.transforms import unnormalize, normalize\n", + "\n", + "from functools import partial\n", + "\n", + "def initialize_model(train_x, train_obj, train_con):\n", + " '''Initialize the model for the problem.'''\n", + " train_x = normalize(train_x, bounds=townsend.bounds)\n", + "\n", + " model_obj = SingleTaskGP(\n", + " train_X=train_x,\n", + " train_Y=train_obj,\n", + " outcome_transform=Standardize(m=1),\n", + " )\n", + " \n", + " mll_obj = ExactMarginalLogLikelihood(model_obj.likelihood, model_obj)\n", + " fit_gpytorch_mll(mll_obj)\n", + "\n", + " model_con = GP_vi(train_x, train_con)\n", + " mll_con = gpytorch.mlls.VariationalELBO(\n", + " model_con.likelihood, model_con, num_data=train_con.size(0)\n", + " )\n", + "\n", + " #make sure the GPyTorch model is in double precision\n", + " model_con.double()\n", + " mll_con.double()\n", + " \n", + " fit_gpytorch_mll(mll_con)\n", + " model = ModelListGP(model_obj, model_con)\n", + " \n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We further set up the acquisition function `qLogExpectedImprovement` and the method to optimize and get observation from Townsend function. The constraint is passed to the acquisition function as a `constraint` argument. See [here](https://botorch.org/api/acquisition.html#botorch.acquisition.monte_carlo.SampleReducingMCAcquisitionFunction) for more details. The helper functions `pass_obj` and `pass_con_unsigmoid` are used to pass the objective and constraint values to the acquisition function." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from botorch.acquisition import qLogExpectedImprovement\n", + "from botorch.acquisition.objective import GenericMCObjective\n", + "from botorch.sampling.normal import SobolQMCNormalSampler\n", + "from botorch.optim import optimize_acqf\n", + "\n", + "BATCH_SIZE = 1\n", + "NUM_RESTARTS = 10 \n", + "RAW_SAMPLES = 512\n", + "\n", + "def optimize_acqf_and_get_observation(model, train_obj, train_con, \n", + "):\n", + " \"\"\"\n", + " Optimizes the acquisition function, and returns a new candidate and observation.\n", + " \"\"\"\n", + " # best_f is the best feasible objective value observed so far\n", + " best_f = np.ma.masked_array(train_obj, mask=~train_con.bool()).max().item()\n", + " \n", + " # standardize the training data\n", + " standard_bounds = torch.stack([torch.zeros(townsend.dim), torch.ones(townsend.dim)])\n", + " \n", + " acqf = qLogExpectedImprovement(\n", + " model=model,\n", + " best_f=best_f,\n", + " sampler=SobolQMCNormalSampler(sample_shape=torch.Size([1024])), objective=GenericMCObjective(pass_obj),\n", + " constraints=[partial(pass_con_unsigmoid, model_con=model.models[1])],\n", + " )\n", + "\n", + " # run the optimization function\n", + " candidates, _ = optimize_acqf(\n", + " acq_function=acqf,\n", + " bounds=standard_bounds,\n", + " q=BATCH_SIZE,\n", + " num_restarts=NUM_RESTARTS,\n", + " raw_samples=RAW_SAMPLES,\n", + " )\n", + " \n", + " # observe new values\n", + " new_x = unnormalize(candidates.detach(), townsend.bounds)\n", + " new_obj = townsend(new_x)\n", + " new_con = townsend.constraint(new_x)\n", + "\n", + " return new_x, new_obj, new_con, acqf\n", + "\n", + "def pass_obj(Z,X=None):\n", + " '''\n", + " directly pass the objective to the acquisition function\n", + " '''\n", + " return Z[...,0]\n", + "\n", + "def pass_con_unsigmoid(Z, model_con, X=None):\n", + " '''\n", + " pass the constraint to the acquisition function\n", + "\n", + " Note: Botorch does sigmoid transformation for the constraint by default, \n", + " therefore we need to unsigmoid our probability (0-1) to (-inf,inf)\n", + " also we need to invert the probability, where -inf means the constraint is satisfied. Finally,we add 1e-8 to avoid log(0).\n", + " '''\n", + " y_con = Z[...,1] #get the constraint\n", + "\n", + " prob = model_con.likelihood(y_con).probs #obtain the probability of y_con(when constraint satisfied)\n", + " prob_unsigmoid_neg = torch.log(1-prob+1e-8)-torch.log(prob+1e-8) #unsigmoid the probability and invert it to adapt to BoTorch's constraint API\n", + " \n", + " return prob_unsigmoid_neg\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also define some helper functions to visualize the BO process through plotting out the acquisition function value, and the underlying constraint probability and expected improvement value before subjecting to constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_helper(model, train_x,new_x, acqf,axes):\n", + "\n", + " with torch.no_grad():\n", + " x = np.linspace(-2.5, 2.5, 100)\n", + " y = np.linspace(-2.5, 2.5, 100) \n", + " X, Y = np.meshgrid(x, y)\n", + " Z = torch.tensor(np.stack([X, Y], axis=-1)).to(**tkwargs)\n", + " Z = normalize(Z, bounds=townsend.bounds)\n", + " Z = Z.reshape(-1, 2).unsqueeze(1)\n", + " # get the acquisition function value\n", + " acq_values = acqf(Z).cpu().numpy()\n", + " # get the constraint probability\n", + " model_con = model.models[1]\n", + " prob = model_con.likelihood(model_con(Z)).probs.cpu().numpy()\n", + " # get the expected improvement value\n", + " ei_values = model.models[0](Z).mean.cpu().numpy()\n", + "\n", + " # plot the townsend function\n", + " plot_townsend(axes[0])\n", + "\n", + " c_acqf = axes[1].contourf(X, Y, acq_values.reshape(100,100), levels=20,cmap='Blues')\n", + "\n", + " #plot the constraint probability and set the colorbar to 0-1\n", + " c_prob = axes[2].contourf(X, Y, prob.reshape(100,100), levels=20,cmap='RdYlGn',vmin=0,vmax=1)\n", + "\n", + " c_ei = axes[3].contourf(X, Y, ei_values.reshape(100,100), levels=20,cmap='Oranges')\n", + "\n", + " #plot the current observations\n", + " for ax in axes:\n", + " ax.scatter(train_x[:, 0].cpu(), train_x[:, 1].cpu(), color='grey', label='Observations',alpha=0.5)\n", + " ax.scatter(new_x[:, 0].cpu(), new_x[:, 1].cpu(), marker='*' ,color='red', label='New Point')\n", + " ax.set_xlabel(\"X1\")\n", + " ax.set_ylabel(\"X2\")\n", + "\n", + " axes[1].set_title(\"Acquisition Function\")\n", + " \n", + " axes[2].set_title(\"Constraint Probability\")\n", + "\n", + " axes[3].set_title(\"EI value\")\n", + " \n", + " #add colorbar\n", + " plt.colorbar(c_acqf, ax=axes[1])\n", + " plt.colorbar(c_prob, ax=axes[2])\n", + " plt.colorbar(c_ei, ax=axes[3])\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Perform BO loop\n", + "We initialize the BO loop with 10 random points from SOBEL sequence. We then perform 50 iterations of BO. The acquisition function value, the underlying constraint probability, and the expected improvement value are plotted at every 10 iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "\n", + "\n", + "Iteration 2: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "\n", + "\n", + "Iteration 3: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "\n", + "\n", + "Iteration 4: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "\n", + "\n", + "Iteration 5: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 6: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 7: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 8: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 9: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 10: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 11: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 12: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 13: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", + "\n", + "\n", + "Iteration 14: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 15: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 16: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 17: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 18: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 19: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 20: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABcwAAAEiCAYAAADETJH2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQm4G2XZ/p/sJzknyVnb032hpWXrwlYBRfZNQBARRT4WERVBEFABlV1ABBE+4M8mmwIKKJuCLArIp0ChhbK2pYXu69mTs2Wd/3W/p5NOcibJTDKTTJLnd13TNJPJZDLJeefN/d7v/dgkSZKIYRiGYRiGYRiGYRiGYRiGYWoce7kPgGEYhmEYhmEYhmEYhmEYhmGsAAvmDMMwDMMwDMMwDMMwDMMwDMOCOcMwDMMwDMMwDMMwDMMwDMOMwII5wzAMwzAMwzAMwzAMwzAMw7BgzjAMwzAMwzAMwzAMwzAMwzAjsGDOMAzDMAzDMAzDMAzDMAzDMCyYMwzDMAzDMAzDMAzDMAzDMMwILJgzDMMwDMMwDMMwDMMwDMMwDAvmDMMwDMMwDMMwDMMwDMMwDDMCC+ZMxfHggw+SzWaj1atXkxXAceB4brrpprzbXnnllWJbhmGYUrZPaDf1cMABB4hFC6effjpNnTq1wCOsPXCucM4YhmHKBa4L6JNWE7hm7brrrpbp32e29a+99prYBrcMwzDVBvdvmWqEBfMygk6TloU7VoUhd17lxefz0c4770y//OUvKRQKlfvwGIapIv7f//t/op1ZsGABVSMbN24UbeqSJUvIKshihtryhS98oazH9sYbb4jz1dvbW9bjYBgmO5999hl9//vfp+nTp1NdXR0FAgHab7/96NZbb6WhoaGyHtvzzz9vWUH7uuuuo6effrqgdtrhcNDkyZPp+OOPt9T1pFw8+uijdMstt5T7MBiGqRDDYLblrbfeSm2L++eee25Zj5dhqgVnuQ+glvnjH/+Ydv8Pf/gDvfzyy6PW77TTTiU+surizjvvpIaGBurv76eXXnqJrr32WnrllVfov//9L7u9GYYxhEceeUQ4K95++21auXIlzZgxg6zAlClThPDjcrl0PQ9tZaZgftVVV4n3OG/evLTH7r33Xkomk1QuvvWtb9FRRx2Vtq6trY3KLZjjfMFp09jYmPbY8uXLyW5nvwLDlJPnnnuOTjzxRPJ4PHTqqacKZ3I0GqX//Oc/9NOf/pQ+/vhjuueee8oqmN9xxx2miea4LjidzoIF869//et03HHH6W6nE4kELV26VPTN//GPfwiRJ/OaUonAjHPJJZfk3Gb//fcX593tdqcJ5h999BH9+Mc/LsFRMgxT6Vx99dU0bdq0Ueut8ruDYaoNFszLyCmnnJJ2H51GCOaZ65niQKe+tbVV/P8HP/gBnXDCCfTkk0+K873PPvuoPmdwcFA40hmGYfKxatUqIZCiXYFbEeL5FVdcQVYAg4JwTupF+YM+H3rFeKPZfffdK+q6CYGOYZjyttnf/OY3xYAiDBTjxo1LPXbOOeeIQU8I6pVCPB4Xg5Z62u1CrgtGttNw8h977LFCOL/77rtVnzMwMED19fVUCWDwId8ABAZKS33eGYapLo488kjac889y30YDFMzsMXJ4qCzeNFFF9GkSZPEj+xZs2aJLD1JklLbfO1rXxMdUSXHHHOMEEqeffbZ1LqFCxeKdXB0KKf2wGl94YUXCkceOqaYJtnR0ZG2v0WLFtHhhx8uhGev1ytGNr/zne+kbYPOOqYV7rLLLqJDOHbsWCEe9fT0pG0Hh+LRRx8tXDx777232BbTYeGwzwQOn4MOOki85sSJE+lXv/pV0U5G7E/+waTMPFy8eLFwf0Ao//nPfy4e27p1K5155pniveA4586dSw899FDWff/ud78TP8BwvF/+8peFa0QLDz/8MO2xxx7iec3NzeKH3Lp169K2kY/zgw8+EPvGcWI0+S9/+Yt4/N///reIg8A+8D355z//WfA5YhhGOxDIm5qa6Ctf+YoYoMN9NRDPccEFF4g2EO052jQ4Gzs7O1PbrF+/Xrj20BaPGTNGbP/iiy+OiufKlhOYmT2ulmG+efNmOuOMM8Tr4zggFn31q19Nqwuh3A9ed6+99hL/x/Pk6Z/yPtUyzLVcu5TTRjG9H+0btsU15IUXXiAjyJbFnnnMyqxauEp32GEHcSx43++8886o5y9btoy+8Y1viOum3Ob+4he/EI/BEQqHKsC1Uj5f8vlV++w+//xz4XZF+4+2HZEymYKdnH/7+OOPi5lS+PxwXTr44IOFwMcwjDZ+85vfiFmH9913X5pYLoO+1fnnn58mSF9zzTWpdgF/w+gnRiKRgvq3sVhMzECZOXOm2KalpYW++MUvCtMMQPsAdzlQTrnPbKvQ55aP6ZNPPhEO+csvv1z0J4PBoLiOfOlLX6JXX301b4a5HGOItkSeGYN9oM2HiUT5PLTv6AvLx1VIZm1mX1z+TYK+7A9/+ENx/UMbp4w9w7UB73X8+PFiYCNb5BX68/vuu2/q98pdd92V9rie86S1f6+lRlFmhjmuTWjn16xZkzqX+A7hu4ljUn4HlX0ExNpcf/31OV+LYRgmF+hzH3jggaPWQ2eZMGGC+D0jg+sN2lRcq9AGou2U9YdcZGsXs9Wjg0aFthjtn9/vF7+roAUxTDlhh7mFgbAA9wU6cBBtMWURwgl+iG/YsEF03gAalmeeeUbkciN/Ec+DCA4nw//93/+JfQD8H+vg6lDyox/9SIg9cESi4UIHHALGY489lhKNDzvsMCEMYLohOtHYDm5KJRDH0QCic33eeeeJTvDtt99O7733njgepQsRHXI0xHhfp512Gt1///2iw40GGB1iWdRBQ44fKnhdNJ4QMtBQF5tZCdDoy3R1dYkRWwjVcMBAIMe0SXRmcaw4H+h0P/HEE+I40UnP7MjiB1E4HBad+OHhYZGBiR8EH374odhfNiB8XHbZZUJ8+e53vysGK2677TYh3uPcKafzY/ABP8ZwnBBX4MzB/yHQYTonHPQnn3wy3XjjjeL8QnTHBYdhGPPA3x8GLuHuw7Rz/F1CZJVFZoAfwGirMRUdg40Y5IRQjkFN/ADGYCTaHIifa9euFW0oRAFEdMEBaSSYZYMOKNp+/DhHGw+hBq+rVrwTsWCYAgqB4Xvf+554HwCd52KuXTIQl3A9gUiC9up///d/xTHieJTtdDYg5igHHQBEkEKc75gej3Yc1zN05iGs4bOFoC3vD4OWOAe4j/OBc4bryt/+9jfRnmP7Tz/9lP70pz+J9yrPcMoWE7NlyxZxLvE+8LnjPUOMwjnEDxIMYiv59a9/La7lP/nJT6ivr08c47e//W0xKM4wTH7wtwohO1sblgn6ZvibRL8KA4H4W4Ngifb8qaeeSttWS/8WIgKej/1CWEf/HcaUd999lw499FDR/iAGSy2mUeaBBx4QfU20QRCRMdiG/fz+978X16GzzjpLtGUYFIDhBXFhWqJP0BdFfxfHh+PB/iBe33DDDeJxHI983HhtANHeiL44wHUAbSWuNxDm5fOFAYZDDjmEzj77bBFrJV9nM39foJ+M6Be8D5wHDDDiObg+y0Yfveep0P59PjDIijYcfQD5uogISSxo9/E77OabbxYCuQyuK7jGos1nGKb2QJuR2edFf1VLf1nJSSedJNpW6C3t7e1pfXJcf6AvyKDNQ58U7Q4GHP/85z8LHeLvf/+7ELWNANcWXDPRDuN6gz4x2nkMJkMPUft9wjAlQWIswznnnAPrXer+008/Le7/6le/Stvu61//umSz2aSVK1eK+++8847Y7vnnnxf3P/jgA3H/xBNPlBYsWJB63rHHHivNnz8/df+BBx4Q2x1yyCFSMplMrb/gggskh8Mh9fb2ivtPPfWU2A6vk43/+7//E9s88sgjaetfeOGFUeunTJki1r3++uupdVu3bpU8Ho900UUXpdb9+Mc/FtstXLgwbbtgMCjWr1q1Kuf5vOKKK8R2y5cvlzo6OsT2d999t3idsWPHSgMDA2K7L3/5y2K7u+66K+35t9xyi1j/8MMPp9ZFo1Fpn332kRoaGqRQKCTWYb/Yzuv1SuvXr09ti+PGepzPzGOSWb16tTjX1157bdprf/jhh5LT6UxbLx/no48+mlq3bNkysc5ut0tvvfVWav2LL74o1uMzZhjGPBYtWiT+1l5++WVxH23pxIkTpfPPPz9tu8svv1xs9+STT47ah9z+ym3O448/nnoM7dSMGTPE+ldffTWtHT3ttNNG7QvtBBYZuX2S24Kenh5x/8Ybb8z5vjL3I19n1NoUHAeOR++1C2A7t9udtu79998X62+77bacxyi/N7VFPleZ7yPbMcv7amlpkbq7u1Prn3nmGbH+b3/7W2rd/vvvL/n9fmnNmjVp+1ReR3F+s12nMj87+VqH66hMOByWpk2bJk2dOlVKJBJiHd4Ttttpp52kSCSS2vbWW28V63HdYBgmN319feLv5atf/aqm7ZcsWSK2/+53v5u2/ic/+YlY/8orr+ju386dO1f6yle+ous3QWZbFQgExL6VxOPxtLZBbvPR5/3Od76Tth77QJ80s3+aud3xxx8v2kUl9fX1qtcfNeTjveqqq0RffPPmzdJrr70mfo9g/V//+te03yRf/OIXxfuQwXvENeKwww5LtYXg9ttvF9vff//9o/rJv/3tb1PrcD7mzZsnjRkzRvTh9ZynYvr3am293IYrr+X4HiivRZn9+H/84x9p6+fMmaN6TWMYprqR20i1BdcYJViHa0guoI+o9bV/+MMfCp1jcHAwtU75f4C2dNddd5UOOuignG2eWruofC9yHxl93sbGRumss85K2w7XC+g+mesZppRwJIuFQcEfuArgOFMCdwvaQjlaZf78+cKN8Prrr6ec5PJUf7hDMEKH7TFiKDsDlcAhopwug21QlAdTBIHscMYoIqaRqgHnNRx9cMZg1FNe4KjBsWVOc9x5553TjgVuEkxph4tP+f4xLR0uFuV2el0V2C+eB8cMXDuYaospkMqMcrhz4IxXgtfHiCscKDJwseDzgFsU00aVIEYBU5hkcNyISMF+sgFXJaY+wQmjPG94XUzVzTxvOJfKEV+8N3w+cIDitWTk/yvPJ8Mw5rjL4TCTpzWiLYVrA+4LtKMyf/3rX0WkU6ZbWH4OQFuBeADlNEi0U7KLzwgwQwdOO0wJz4zLKvW1SwauQaVDcc6cOWK2lNb2C+cHTkzlgnNdCPjsMONKRr5OyceCGUC41sKpOHny5LTnFlpEGucL1wu4aJRtPd4XZnMhakEJrlXKrOLMY2QYJjtwFwOts+/kPhyiCzPbM5AZnaSlf4t+G2b5rFixouD3gVk4mbNW0O7KbQP6lt3d3WKWJvJu8XtAC5ipqATvBbMw5fNWKJjFiuNF/xazN+Ewh4sQM3KUwPGtdFQjXhCORsyiVBZLxna4TmSef+SIo68vg/OB+5hJhaiWQs5TIf37YsF1EbPMlBFviIHBDKdKqtnBMIyxIK4rs8+b2a/Wwo477ihm08iJAgC/WzCzEdG+yhn9yv/jtwNc7rg2aL2u5APvAbP3obko9RC01Whrc8VlMYzZcCSLhYFgjc5SZqce4qj8OEBjguKVEMoBbtGI4cc3Gj4Ut4Sggw6hmmCe+aNfFgtkMQVZfeiYYzokpgyio4vOI6I/5OJl6PSj8cS0TTXQUc31mvLrKgUcvD+lCCyDHx56gFCFTjXEbgwkqE0dRUc4s1gSXh+itbKDrnb+ZbCt2sUI00GzgfMGAUntuSAzUgDHnynKYKACOcGZ64BZghjDMCMdSwjjEMvlHFaAduu3v/0t/etf/xJxVgDiANrRXKBNwYBe5t+43jYvF2izIVJA7MF1AYOSiHnCAKtySmYprl16rge5QPsJccEI8l0PZdEL2Y9Gke1apzxfytfLd4wMw2QH/UGAiA0t4O8P/UC0zUrQXkL4LqQ9Q8QV6kagj4i/7SOOOIL+53/+RwwWagUmEDUQHYPrD+osKE0u2bbPJFf7Ip+7QsAAIKbw41zivMl55JlkHqd8fjOvg+izI1Yn8/zj2pNZKBTnGWAAEtc8veepkP59seA8wSCESAIYnzB4DvEcmfc4jwzD1CYYsDOq6CdMIqjHgbhEaCEw00CzwXolME2ijtySJUvSancUahTJRB48lmtbZFLMtYdhioUF8yoB4jiyU5GtB8EcuXjokKIjjvtyxp6aYK50ciiRi7OhMcRoI4R35D4iixbuOnQ0sQ5OODg0IJZnK3an5oLJ9ZpGgixwOUM2G8XmohcKzptciFXtnODcajlvpTyfDMOMgGzxTZs2CdEcSyZoD2XB3GiydVIh4mdrD2Tg1IN7BIU20Z6jhgLyavF+MGOp1JjZfuE8qe1H6f4v1bEYRSUcI8NYFfzwhqiqtSi7XmFAy98n+qUYREX9oZdeeknkacOQguKUyAfXglq/FQXkkZcOUwtqRqBfLheIlDPDjTj+QtA6sFmK/rgR56kUYCAbNYlwrYbzEjU2MMAtm2IYhmGKAcL4pZdeKpIC8NsAg4BoXzCIKyPXw8N1C8WXMRMWhj7U0UCbVOhvlUw9RM4xVzPvYOYQw5QL/vZZGFRjx1REuGCUTj24IeTHZSCEY8oiisFglFAWxtG4yYI53BDFFKeBKwMLhHk0kHA+QCRC5x6ubRwrCooa1dnF+1ObropiP6UAr4+pj2jElS5ztfMP1I4Vhd9yFanAecOPEDhaZAcMwzCVAQRx/NDG9Ei1uCUUg4MAgjYRf+v5BBq0KdgGbYKyk6nW5sH1h+mLmcBtB9ddPnA8cJljQduFaZkYBIWQoIYeF4mea5fZ4DypRZVkuhK1Ip/bfJ+l3vOl9hmX43wxTC0A0RFF5N98800xQzMX+PtDPxDtpDzrQy7Wiza40L9PFOlEvBIWxPyhv44CbLJgXohzD+YWtFG4/iifjzgUIzHKVagF+fyijVRe2/CbBzO7MkV4FKtDsVClyxx9cSD3x/Wep0L690acS5ieMIiNvgZmmKIQ9m233Vb0azIMwwDoD3CsI5bl3HPPFW0iBhKVs38wUx8zW2CwUa6HYJ4PeYYSrpVyxK9aH1ye/Y/fVEbNGGUYo+AMcwuDKu8Ygbv99tvT1sOFgg7WkUcemVqH6dwY7cNUe3TCMdURQDiHCxx522ruci1gGmams0SuIC9Py0EGN471mmuuGfV85AKqCTta3j+OHRXrZZAfm83FbjR4fVSOVmZ74b2gswrnN6JqlMABgsEKGRz3woUL0z6nTJDdCFcL4m4yzzHuIzeSYRjrMTQ0JDqWEF6QOZ65oOMJwfjZZ58V2yOO5f333xcieiby3z7aHPzYx495GUzFhrCTCTqXaB8hGiinTK5bty7ncWN/mImUuS8I28pplpnI4oOWtlzPtcts8N4gPOPaIYPP4b///W9B+8NsKQhb999/vxAvlCjbcL3nC9cLiHcyEHzwuUOQQSYywzDG8bOf/Uz8jUKchvCdCVzGt956a+rvE9xyyy1p29x8883i9itf+Yru18/s26FPicgXZRuspw3JdIcr2yL0Q5VtixHg2Arp1xcCxBPEr/zv//5v2vu67777RBRk5vlHP/3uu+9O3cc1EvfRdqOuUiHnqZD+vZ5zifeRDUT1YBYCvn8tLS0lvX4yDFMbLnP8nkC/FrnhmXEsaC/Rd1e6whFvhXYxH7IQLtfZk/u3iMRScvjhh4vZX9ddd51qvTxlH55hSg07zC0MpswjGxfxKmiYUMQMnSZM4cS0GWUWN7Lt0BFEg4fnyY4F/LBHw4SlUMEcjRqm4KBYHV4TItC9994rGjb5hwTEYxTVwXRG5FshhgACPlwZmOaDHx7KQnZaf9Bgag6mBZ1//vmiUwkBQXZ+mw3yFtHJxrRNFAqCcAEhC0ILOq6Z+bz4sYNonLPPPlv86JE7t3gf2cD5RCYYpkPhM8aoLvYL1wyENRzDT37yE9PfK8Mw+oAQjrYQ0xTVwGwc/EDHAB86n5j2jfYD2aOItEJ7jboS2A9c6GjfUcQMIjOmYaPNwbRHtIHKAsUyEHqwP7SPGLCEwAN3uFqNhkxX3MEHHyyeAyEW0xzR1kA0UhYUzgT7hTsEx4o2Cu0xBmrV8l71XLvMBucawhY642eeeabIZsR7wKByoUXsINygrd99991FG41zgPeJ4nO4/gFZmME5wHnF9RDnJTNbF1xyySVidhiEEBRKxaA3rru4DsDZk1lHg2GY4kAbhJmSaJvhGkebCzcvxNU33nhD9FvR9wNov0477TTR/4RIjP4uBFP8jaLPJhd81gPaXtQDQjuBv/dFixaJ9hwDrTJyG4I2Ae0XRItcbTTAAC4GctFfh5CMNgTtHV4PLnajwLFhFhHaVsTboA1Uq8NgBLiOoo8MYwmud7jmwm2O3yV77bXXqAKYOB6Yh9AmY+YmTC9ol/H5yXWB9J6nQvr3es4ljhFFZfF+MHiCa4UM6kXhdXCdxutn1jZiGKa2QIyrPANRyb777qtphmkm+D0ArQELrkeZDm+0kWjr0f6iPUI/GjNr0S7m02OgB6EuBvrf+B2E6xiEebTrStMJNCXUa8AAIfrWuNbJ26BvjQSDTBMOw5QMibEM55xzDqwOaevC4bB0wQUXSOPHj5dcLpc0c+ZM6cYbb5SSyeSo5//0pz8Vz7/hhhvS1s+YMUOs/+yzz9LWP/DAA2L9O++8k7b+1VdfFetxC959913pW9/6ljR58mTJ4/FIY8aMkY4++mhp0aJFo47hnnvukfbYYw/J6/VKfr9f2m233aSf/exn0saNG1PbTJkyRfrKV74y6rlf/vKXxaLkgw8+EOvq6uqkCRMmSNdcc4103333ieNbtWpVzvN5xRVXiO06Ojpybof977LLLqqPbdmyRTrjjDOk1tZWye12i/eD86YEx4HXwefy29/+Vpo0aZI4T1/60pek999/X/WYMvnrX/8qffGLX5Tq6+vFMnv2bPF9WL58ed7jzHY+8TrYB8MwxnPMMceIdmlgYCDrNqeffrpotzs7O8X9rq4u6dxzzxVtGdqTiRMnSqeddlrqcbBmzRrp2GOPlXw+n2h3zj//fOmFF15Ia5Nl0N5gX2hv9ttvP9EmZ7ajcvskt1t4LbQLaGPQ1gSDQWnBggXS448/nrc9fuaZZ6Sdd95ZcjqdafvEe0A7VMi1K1s7hf1hv7lQtr25ePjhh6Xp06eLcz5v3jzpxRdfHHXMufaF9Wi7lXz00UfS8ccfLzU2NorvwaxZs6TLLrssbRtcr/D52O32tGuW2nvD9fnrX/96an9777239Pe//1312vzEE0+onofMaxPDMLn59NNPpbPOOkuaOnWqaB/Qb0Vbetttt0nDw8Op7WKxmHTVVVdJ06ZNE+0Z+nmXXnpp2jZ6+re/+tWvxN84/t7RX0Z7fO2110rRaDS1TTwel370ox9JbW1tks1mS/Udc7VVaF+vu+46cRy4LsyfP1+0I2ptdGa7lq3PLP9WUPa5ly1bJu2///7i2PFYrrZaazud7TeJzO233y7OE87/2LFjpbPPPlvq6elJ20buJ+NauM8++4i2FO8bzy3kPBXbv89s6zN/X4H+/n7p5JNPFt8FPJb5OYGjjjpKPPbGG2/kPIcMw1QvchuZbVH2AfVqALju4Tnf/e53VR+H9oJ+PNo/tMN4LS1tHli8eLH4nYFrLLSkm2++WfW6AtA2Hn744eK3CdrvHXbYQfyWUtOcGKZU2PBP6eR5hmEYhmH0gKr1cDG++uqrwpXIMAzDMExtACf8hx9+SCtXriz3oTAMwzBMTcHzfBmGYRiGYRiGYRjGQmzatElEEiCqgGEYhmGY0sIZ5gzDMAzDMAzDMAxjAZCrjppJv//970VuOepEMQzDMAxTWthhzjAMwzAMwzAMwzAW4N///rdwlUM4R4HZ9vb2ch8SwzAMw9QcnGHOMAzDMAzD1ByrV6+ma665hl555RXavHkzjR8/nk455RT6xS9+QW63O+vzUEsAgpYSOEDvuuuuEhw1wzAMwzAMwzBmw5EsDMMwDMMwTM2xbNkySiaTdPfdd9OMGTPoo48+orPOOosGBgbopptuyvlcbHf11Ven7vt8vhIcMcMwDMMwDMMwpYAFc4ZhGIZhGKbmOOKII8QiM336dFq+fDndeeedeQVzCOQck8AwDMMwDMMw1UlNCeZwEW3cuJH8fj/ZbLZyHw7D1CRIgQqHw2Lqu92ur4zC8PAwRaPRvNthKn1dXV0RR8lUAtymM0xlt+l62nW8TubfucfjEYuR9PX1UXNzc97tHnnkEXr44YeFaH7MMcfQZZddxi5zA+B2nWHKD/fVGaPgNp1haqNNr9Z2vaYEczTWkyZNKvdhMAxDROvWraOJEyfqaqy9gVai2EDebSFgoFBStTXYTDrcpjNM5bbpetv1hoYG6u/vT1t3xRVX0JVXXklGsXLlSrrtttvyustPPvlkmjJlivjh8cEHH9DFF18snOlPPvmkYcdSq3C7zjAV3ldvDRANxPJuy3312oDbdIap7DZ9jN9L4bi27auxXa8pwRwjm/IXJRAIlPtwGKYmCYVCouMk/z1qRYxsxgbIM+/7RI7sxdgoEaXNS+4W21dTY82MRv4O/fPtZTR5XKth+x2MJui9jT30/CcdObfrGYhSXzhCny3fTIPhwbTHpP5uMo1Q7uMqO4G28ryu1c9LlSIlohRdcrfuNl1vu96/5O5R/bds7vJLLrmEbrjhhpyvvXTpUpo9e3bq/oYNG0Q8y4knnijyyXPxve99L/X/3XbbjcaNG0cHH3wwffbZZ7TDDjvkfC6TG/l7tOK8A8nvyf4zxTUlWNTr2Cfmn0Wghq29hUyjeVvb2W1eWyZt7tL9nOT64q9nsTV9Re+j2M+8rJ+//NkagC04nswmFB6kSTO+U1hffSBGru/tTeR25NgwQZvveZv76jWA/B1a88/bKVDvTXvMVtekeT/ScE/+jcId+vqHoa3Z96WlHx/qJCOIhYtvH2sJl9+4a0GtEBqO05RfLS6oTQ/HiS6e6SBPHmN6JEl0w4rNVdeu15RgLk8Dwo8tFswZprwUPC3P4SabI/sUfKnwQ2Iq9DsEsdxvYJuOrsT+/gD5Gvz0zIfZO9NjvPhdGCK720c2V8Y3z2liR6F5ElFfjk5+uQiOKe/rW/W81AhFTbXW2K5r7b9ddNFFdPrpp+fcBnnlSgfcgQceSPvuuy/dc889pJcFCxakHOosmBvzPYJYHvC4sm+4eZBc04r40dwVJvtk/eKnrcHgtr1Fpd30T06/32VcuybV5xiYUiG5tovIm+NzyENs1YgQ5M31WWpl88jAdFGfe7k+f3+6UFgotsYJhuzH9Hbd7SBbjgEv7qvXoP5S76VAw0hsmc1bwICVv17cSEM5hOyGKUShLaPX109SF8exvk9le5DQ0GZFjZHSYtEcg0vMKFx1NSVhWqJN99iJ6hz5nludLTt/2xiGYRgmA5/HQXtOaKZGj4ueWdZJvf0R1e0aA3XUPrGZNq8nGghtj5Ww+VtICut38hUsTkMoVltXK2K58jhYNK952traxKIFOMshlu+xxx70wAMPFJTDvmTJEnELpzlTOmQxtlABFWJwIaKpaUJ5rm0NFM1L/fmYsV9DRHMrftYWEssZxmgKEspV9pFTNDcKfwuRmf14pmBioV5yBRrLfRhMjaD/VwHDMAzD1IhoPmdCI311dis1Nqi7X5vq3TRpQlCI5vWBEfdLWVATrLFOXsx8XauI5TJWOx7GskAsP+CAA2jy5Mkit7yjo4M2b94sFuU2iG55++23xX3ErlxzzTW0ePFiWr16NT377LN06qmn0v77709z5swp47upXcwSZi0loOI5Bgmv1fCZVNxnXiQsljOVjp74laKE98DYLOtNaD+DbYaIvwzDWBd2mDMMwzBMDsb7vbTLWC/9N4vLHPj9Hgr5faV1mRcqIhvhwGZRmqkCXn75ZRGjgiWzCJIkjUwtjcVioqDn4OBIHITb7aZ//vOfdMstt9DAwICoyXHCCSfQL3/5y7K8B8YYt3nJKFb0rgC3ea2J2TkxYJCDxXKG0ek0h2iuFs2iRnBs9lgWhmFqHnaYMwxT87z++ut0zDHH0Pjx40W219NPP533OY888gjNnTuXfD6fmIb/ne98h7q6LCKOMkwulM7zQoTvShDLK+EYmbKDnHMI42qLzNSpU8V9ONEBBPJ///vfor0fHh6mFStW0G9+8xuujVOhYq3I6C4VRjnEi9iPbVybNc9NBQjzes6dYa/JYjlTS3hbRhazIl7McJkzDFPVsGDOMEzNA5cgxO877rhD0/b//e9/xRT8M888kz7++GN64oknxHT9s846y/RjZUpPa8BDM5rqc8ayyGTGssBlbnm0COeliHcxmko6VoZhqtvhbHScikXjWSx57stFkZ8Ri+VMTYnkSqFcuS6PgJ5VNM8WzZLNZa5GJfThGaZCeb1CDIssmDMMU/MceeSR9Ktf/YqOP/54Tdu/+eabwnV43nnn0bRp0+iLX/wiff/7309l3DLVB7LMT5s7nma1N2Qt/hkI1lFVOc8rUSRnGIbRielOarPEbYuK5qWkWgV6FsuZqkePmzzPtrqc5uwyrwo4+73yGagQwyIL5gzDMDrZZ599aN26dfT888+Lqfpbtmyhv/zlL3TUUUeV+9AYuLw9DtWlWFr9Hprd5suZY+7z+yrTZc4wDFNFWEZINVvULmD/ZkWLWOacm4Duc1ZMbA6L5Uy1oyN2RevzVEVzPS5zhmFKypEVYlhkwZxhmKokFAqlLZFI9oKNetlvv/3ElKCTTjpJFIBrb2+nYDCoeYSUMYd8wrhR4rlaNAtiWeAynzAxKERzxiKwO55hapZqFnDTYKd51cBiOVPV6Mwoz7oPKxEsfACSXdJMNRIySYMpl2GRBXOGYSoLuHUDrdmXbW5eFGaDiC0v119/vWGH8Mknn9D5559Pl19+OS1evJheeOEFWr16Nf3gBz8w7DUY7fgKEMELEc7xOlMD9TS2wZV1m6qIZmGYUhNoyx0JhMcZptIopZBtwmvZJ1tMmKqU91bgZ1FNYnlDewP5x/mzLnicYYwWzTW7zNViWTjHnGGy0uiWqCnPgm3M1GDKZVh0mrp3hmGYMoERyEAgkLrv8agXbCwENPxotH/605+K+3PmzKH6+nr60pe+JKYWoQgFUxlANB+IJDRvP7nVR0fQiHi3fHN/9v0G6mkgNJAWyyKFTc7JZdSB4Nq3tdxHwTCMDobWhMjpHvmZ4psaLMpl7ppW+PMLjuUoh+sbr9m1VfN7kTZ1mH5I1UApPvdSi+WDzuIeZxjd6MkZ17S/FqIh7lczTK1oMJ8oDIuHH344bdq0SWgxMCzed999ZBZ8OWQYpipBQ61srI1kcHCQnM705tPhGHErY4oQU/2i+RciQdrSH6PefuOifmoJZa47DyQwDJOLwdV9RQvnWgp/VoWjWodozlgDs8VyFr+ZisHjH7mNhAsWzeEyl4a6R7vMQ1uMOsqqJNbXo7reFWwq+bEwlU3AJA2mXIZFjmRhGKbm6e/vpyVLlogFrFq1Svx/7dq14v6ll14qqjLLHHPMMfTkk0/SnXfeSZ9//rmo2owCFHvvvTeNHz++bO+DKRwjioIq4eKfo8H7lxct6xmGYdSEc8tnmZc7U1zj65tV/LOUFDJ7QM/AiNnucrPEcojk8sIwlhfJ5SXXOqPRE8tSxSK5vOTbhmHKDQyLdru95IZFFswZhql5Fi1aRPPnzxcLuPDCC8X/MeUHYMqPLJ6D008/nW6++Wa6/fbbadddd6UTTzyRZs2aJUR0pnZFcxT+BH6/cfE/1YJWMdw00ZyLfzJM1YjmhQrnNSGWG3wcVeG6LwUWEMtZJGcqDi2CeD7hXCXPXDXLnClKBLeicM5FUyub/goxLFaMYA4L/l577UV+v5/GjBlDxx13HC1fvrzch8UwTBVwwAEHiJHJzOXBBx8Uj+P2tddeS3vOj370I/r444/FaOfGjRvp4YcfpgkTqqdgUymo9HY9W/FPFP6cMDGo6jKvRfSK4KaI5pxhzjCmU+ltei2KuNXgMreEu7xMYnmtieQo7jZ16lSqq6ujBQsW0Ntvv51121gsRldffTXtsMMOYvu5c+fSCy+8UNQ+axHT2nW97vFi3eZqxT+1UkUzIIsVva0mmjOVy6IKMSxWjGD+73//m8455xx666236OWXXxYXwcMOO4wGBrYXVWMYhmEqByu261pd5o0eN7XWO6mxwZNVNA8E60atr7XYkcz3iwEEtSXf84qGHeaMChgItdlsqss777yTc5A1c3sUHap1Stmml9plrkk8LcLVDQE131Iu0VyryGxUcVWtmPl6ZkaxGCGW15JILvPYY48JQeWKK66gd999VwjgKPy2dav6gPgvf/lLuvvuu+m2224TxeLQRh9//PH03nvvFbzPWsSUdr1Q8Tvb8yrQZV4Od7RRYjeL5kwtGRYr5lKbOSKME4hRzsWLF9P+++9ftuNiGIZhaq9dR+FPnxvieid9TMTFPzXQNqFNdRABhPp81LGhY5RozgVBGTPZd999hYNFyWWXXUb/+te/aM8998z53LPOOku4F2V8Ph/VOqVu0yGaay0EihxzUwXdEkRyKLeXejfUdCFQs7PLzfjcjRLKaxU4C9HunnHGGeL+XXfdRc899xzdf//9dMkll4za/o9//CP94he/oKOOOkrcP/vss+mf//wn/fa3vxUiSyH7rEUMb9fNzCUvJMc8VF1tY6kEbuyTC4IytUDFXnb7+kacJc3N1h49ZBiGYSqrXYfLfCCSyLtda8BDe7Y3UedAnAVzFZQucYjliKmB816Z9w56BqJEE4Ji4CFTNGcYM3G73dTe3p66D+fcM888IxwscI3nAgK58rmMddt0q2V1GyGc6hbP84jmcFRLmzpynp/k2i5NQrbZRVbNdrJrdpeXUCyvZaEcRKNRIdAi01YGxd8OOeQQevPNN1WfE4lERMyKEq/XS//5z38K3idjgXYdgnskrO4yH2KTRSnd4CyaM7VAxUSyKEkmk/TjH/+Y9ttvP5Ffkw1cKEOhUNrCMAzDVGa7zm26fsE6cynla8sgckV2lkMoV4rlynW77DyWdth5Utb9MIzZPPvss9TV1ZVyG+bikUceodbWVtFeQXDB9FCm9H31UkSz5BVQNQqnRUWrGLHfPMdpVGa3mYJ2ofvWOiBiNbG82qNXMv/20R6o0dnZSYlEgsaOTc+hxv3NmzerPgfRKnCQr1ixQrRHiBNB1q08q6iQfdY6RffVjXKXF7ofLTnmwQKyzoO1VQtCCcezMNVORV6CkaP10UcfpUaIcxWpuOqqq0p2XAzDlID6ZiKXN/vjsaFSHg1Twna9Wtp0s6NGconMysfMOoZMsRzFT/1+T8pdng0hpE8YEUM++2Rd2v44moUBmWKqx+MRi1Hcd999QmSZOHFizu1OPvlkmjJlCo0fP54++OADuvjii0URNLMLD1USNdNX1yGWmw1eI6/bvAinuVaXuVlO81oSyytdJB/T4iOHV70wOkgMxQgy26RJ6YPkyBK/8sorDTmGW2+9VcStzJ49W8wYQvFPDIYiboWpjb46csyloW6qVVjMZpgadJife+659Pe//51effXVvD9o4PjBtCF5Wbdu+w9whmEYprLa9VK26VqLf1YyZrjOM/cHsVyOYpGd5SiU+tXdxohlVnuD6n7UCoEy1YutoVl1RkRqaRiZ+g1xJRgMphb8MFcD2bPZinnKy7Jly9Kes379enrxxRfpzDPPzHu83/ve94Swvttuu9G3v/1t+sMf/kBPPfUUffbZZwadkcqG++rmu8qLer0inOZ6omsgcBvhNi9mP5Umlle7ozwT/L0r//6V8ShKMJvH4XDQli1b0tbjfrZorLa2Nnr66adFcco1a9aINr+hoYGmT59e8D5rmaL76qXILlcp/lmrlFIsZ2G++ml0EzV5ci/YphqpmEsyKqYiUxI/SFAtddq0aXmfY7TziGEYhilfu16JbToEYzAQGijZa8KNrUcIN8rBrfaaiGJRiuUQyL8wMUgzWkd+OE3dJoxv6Y+JHHhsZ4pc1lf9RZ1qAfzwDgQCqfvZ2oOLLrqITj/99Jz7kkUTmQceeIBaWlro2GOP1X1cCxYsELcrV64ULsZapVx9dT3FP/WSU0jNJzyXUCjP9tpZHefysWdxmxvlNAey2K3XcV6s2F6JYnmtgfZc2abnqjexxx57iILMxx13XCoeBPch5OYCOeYTJkwQNSr++te/0je+8Y2i91lLlLqvbnP7SYqqZJRrzTJnWMBmGANxVtIUoEcffVQUY/L7/alsMTiMUMCDYRiGqSyqvV2fNCEoxN/B8OhsYzNjRgpxjcvPMfKYkEeOc6AUy4/YoY1a/dt/SOH/WLdocw/9d1vhVDwHbF6/faChqPPFYnnNiStwFmLRIwhAMD/11FPJ5coeI5CNJUuWiNtx48ZRLVOpbXpBBT9NEsvziaa+uMExLXkiWrKhVzTPFMCziedG5Z+XSyxnodw8LrzwQjrttNNozz33pL333ptuueUW4R6Xa06g/YYwLs88WrhwIW3YsIHmzZsnbhH1AkH8Zz/7meZ9MqVr1yGUZ/5fk3BegcRCvVRtcAFQnRn3fdmLbDPWomIu0Xfeeae4PeCAA9LW4wdOPhcRwzAMYz1qoV1XE3/NRKtYjsgTteMxSsjXIpbLYN2eNNLJ/u9nvWlZ5qU6b0xt88orr9CqVavou9/97qjHILQcfPDBInYFggpiVyAeHHXUUcKRjgzzCy64gPbff3+aM2cO1TJWbtMLEWILLYKpRzTVK5Zmbq9FQNfkNlcRzeX3b5TTvBSFQfUMfpRbLGehXB8nnXQSdXR00OWXXy5EWwjhL7zwQqpo59q1a8lu3542Ozw8TL/85S/p888/F1EsaLP/+Mc/UmNjo+Z9MqVp15VieeZ600XzwBiikIZBQ/SvK6CeTq25yzH44Aps/5u2BFqKwGZuwwK6ZamYSzXcP6V8LWRuocozphRhBBV5l0x54M+DYaqTUrXreJ1QXx9FoxFyuz0UqNI2RI+zPJcIXYhonlnoU8l+OzTSnu1NKbEcn8dAOESxWJRcLjfV+wPkc1d/ZrxhBPOIN+yoL6jY57777iuKw2WCafwo6Dk4OJiaxv/Pf/4z5URErvoJJ5wghJlap6R9dSIKO+soandScLyXJIpSyVr1HAKqVtHUKLFUuZ984nlOt3kOp3m+eBZ87D2r+iiatJPbnqSgI07luMTWuljeNZyn4KtGWurKFyWUD0SlZItLQVyIki9/+cv0ySefFLVPxvx2PeUmx+/9UD9FojHyuF0UDDTk76tzLItpYjk+9ZC9gaLkIjfFKJDsL901tlLRIpRreS6L55aiYgTzUoFRZhQF6ezspHg8Tk6nUxQFwY8oPdN7GWPgz4NhmGLo6uyglZ8up+6u7W1Ic0srzdhxFrW0Vk8bYkbxTiOc5hDL95/cSj7PSHejr7uT1q5aQX09XZRIxMnhcFKwqYXaJk5PFQQ1Ncu8WkXyzG1ZNNcFHOPZmDp1appgAIH83//+d4mOjFGj21VPn9e3UY+7nuI2O9XZndQsDdGOUg+10LAhImtWQbVIsdxMV7EW8Tyn27wA0bxj0EHLu9zUGW+gWH+UnDaJWl1RmuXtF7dWjNQpp1hu1OdvlDiebd/h4SHT9s8wmXR09dCylaups7t3++/95kaaPWMqtbU0FeUyt3mbSRrq3r4iMJYolF7olUmny95IK91TxW3C5iCHlKCWZC/NiK4Wt9mo2ViWYoTyXPtj4dwSbJ+3xAhxFnlnmzZtIp/PJ6ba4hb3sR6PM6WDPw+GYYoVy99b9DZt3bKZ6rw+ampuEbe4j/V43Aha652WELmzMW/BDDr+uN3FLdzfmQ7wYo9P63YQy5d+uJi6O7aQp85LgWCzuMX91cuW0LyAjXYZ6xWiuWFUunAM8VuPWJ75vEKeyzAWF8vfD06iDk+A6hJRaowNUB3FaIvNR4tsY6mL6spyXPlEUwilpYzgyPd6WY8XInEWoThTaIZY/vbGOtrc7yCfU6LWFifVB920Oeqht8ON1BkbieQyUyg3RSzPcQ7S9tU4QdeMgmI/fwjZ8sIw1SSWL3zvI9q0tZN8dR5qaQqKW9zHejzOlM5dDpH8Xc+utMXRSt7kMDUl+sQt7mM9HmdMFMtLtW8L8Prrr9MxxxxD48ePF7NJnn766ZzbP/nkk3TooYcK0yzqGe2zzz704osvmn6cLJhvA+4hOJkx5RYfAqI/kIOGW9zHejxeyummtQx/HgzDFAPaBjjLh4aGhKNc2YbgPtavXLHcsDbEUJHXQA44dFe68pid6Pz9ponbvRZME+v1iOZGCPs4z3CWR4aGhKMc0Tj4PHCL+1jfsf5z+tKkFiGa1zxGit0snDNVAlprOMuHHW5qivWTW0qQp7GOPJQUzvIhm5NW2JrEdsXkZet1l2sRy8tFLqE2p+CbQzQXbnOJhLN8KGajVl+SPE6J7DYSt20tThr2eOlTzxixnVWEcs1iuYVc5SySM1WNq0E4yweHhqmtuZE8Hve2vrpb3Md6PK6rr+4tjRmlGsVynGU4y4fsddSS6CEPxchOkrjFfaxf6Zoy6hpbk0DMLoWgXarXKQMDAwM0d+5cuuOOOzQL7BDMn3/+eVq8eDEdeOCBQnB/7733TD1OjmTZBjKyEfuhlo+N+xjFwOPYTlkshDEH/jwYhikGZJYjhqXBH1BtQxr8furu7BTbBYtoQya3+sRt50BcRImUg2yCNlzlEMrl7HDcXnnYLLp1WyHOnoEovbNwlaaimtkiWrSK6cgsRwyLr8Gv+nlgPR4f7A9Rq89cV6LlMUvc5qgWpsJBZjliWBriQ6OyVHHfTzHqsnkpJLkpSPnjQPSKrnqFUz1CaTGCqJbMaflY1KJasmaby+KxSkxLKNhKneuJAp6hUXnluO/3SNQ56KDw5DZqrEuK9YUWCC3ms9JVuFWjq9xsoZzFcaZWQGY5YliCDfXqv/cb6sXjfeEBagw0lO04awVklsNB7k/0q19jk/3U5WgS2wWT/bUby1IOARuvWWURLUceeaRYtILaQUquu+46euaZZ+hvf/sbzZ8/n8yCBfNtoKAkMrNcLpfq4yjyFA6HxXaM+fDnwWTD1+Ajm3tEpFRDitqIvxUMCnzmakNQbLI/HBbbqTEQSWh+LQjRs9t8tKU/JkRoJb2h7Hm6RmSEZyNTLFceK9bLvLBDM933t6XUsUF/J0yP8xwFPpFZ7nSqfx5YP5gIUzyG8+cp6bmyFGY7weX9s3DOVCAo8InMcqek3j67KEH95KIoOUrmLi9GLDVKGM3cTy4BHceVTTTXk20eiRPFE0SuoHdESekfKYor43ZIFI7aKZKwGTpAUQlZ5SyUE81s9pIrx+B3bDBKy0t6RIwVQYHPkb66+qxHt8tJ4f4BikTzVDSuYYws9IkCn8gsd5H6+XZJceq3O8R2NUs53d5VKJoXQzKZFHpgc3MzmQkL5tvANH0UmIjFYuL/mUSjUfG42mOM8fDnwTBMMSDqI1cbAgEXj2O7YhiMJGjRhm7696q+sjjMM0VrRK1849g5dPZek1KFNjNRiujIXw8E66gjx+/0YpzlygEKFPiMx2Oq5xzr8bjT5SbDRrwqTRQuZWwKu82ZCsSdjJNTSlLc5hBxLK7G9LzyGDnISRK5Kf+Apy7xVmcUSz7B1GxhVN5/NuE8n9tcVTjPcJvj8uJ0EMXiRB5oJw3bjAzbhPNowkZOu0QeR2kn7xvtKDfbVV5NIjnD6MXjdm3rq8dFDEsm0dhIAVCPu3okq1goe9HMcuPGVVRKUIycIoYlk5jNKR7HdjWJFaJRKkA0D4VCaffxO9wMze6mm26i/v5++sY3vkFmwhnm20D0R2trq4j4yMzJwn188Hgc2zHmw58HwzDFEAgGRVZ5fzik2obAXd7c2iq2K4bOcIQ6B6OqYnmp3eVaxHI1/H5P1kzzbMeJ9Vrew8dbhmhjeIjq/QGRVT7YH1b9PLAej/dKLjH4AKd+qG9YU1xMVVCOjHEL5Zr7/L5UQVq1BY8zjD8+TE3RAep3esmZIZajVQmTi1qkIQpsi2MxzF1eQWK5nvzrfPnmuQpiBn0YfCUKDaENVzze4COp3kfhCLLNExT0jMSxmI3mjHITXeV6I3hYLGdqnUCdRK3NjdTXP6D+e79/QDwe9Guru1NrGOkuB4FkP7UkeynsaBiVUy6usfYGkWWO7ayElQchqkW4b6uTaEyeBduASZMmCY1OXq6//nrDj+fRRx+lq666ih5//HEaM8bc3zPVM1xXJMjJmj17thBoOzo6REY2Yj/gZIY46/P5xOOZ+VqMOfDnwTBMMaBtmLHjLAqH5Cxzv3A5w1kOsdzr9dKMmbNU2xA9cSxyfjnIjGPJhlnxIu0Tm0XBTD1i+REz28Xxb1jfV5A4jfeSy22OgYRnlnXSV2cTTZ42kwb6t2eZI4YFznKI5R6vl6Sm8fTs8i5atSVM6zb00WA4fYp/1VJO4Zqd5kwFgdZ6+kAHDTUFqIvqRGY5YljgLIdY7pPiNFPqGZW9arS7vBCxXK84umVQm4NsrK+taNd5Nsd5rpgWW+tYmr1LnEKLuqgzTOT3IoYFznKi8BCRr7GOZs8gsgcaSNpkjhtOl0BukfgVFskZJuP3/oyp1Bfup47uXpFZjhgWOMshlvu8aEem6vu9P1QjEX4mgLM8I7qaQp4GkVWOzHLEsMBZDrHcmxyiGbE1ea+xVYkV3OUV4jRft26d0O5kjHaX//nPf6bvfve79MQTT9AhhxxCZsOCuYK2tjZasGABLVu2TBSURCYOpgGNGzdOiLN4vBbAiC6EauSD4wuuVnizFPDnwTBMMbS0ttH8PfemlZ8uF6J5/7Y2ZEx7uxDL8bhZZHOXGymW64lFQbuOwpsYMMDAARzfcrt+yryJIprlzn+soM8+WWeoaC4PIqzsGaDG9ibaabc9aO2qFSMFPhNhEcPS3DaW/GOn0rIhG63aslWI5ZvXdxfnLq8UEdgKLm8WzZkKYuIEJ3mlLfQpNVG3zSsyyxHD0i4NCrG8hYZzusuzieWq4msJxXKtArmyTR8KE63o2kooDeH1j4hP+UR0I4XztiYn7b1nCy1bNUydWwaoP0HkcBCNayKaNZ6oLWDLem71iugFieMWEcqNFsn1flcKHWRhmFLQ1tJEC+bvSstWrhYFPpFZLn7vj2kVYnmrvwLkKoOES/hz+8hHUXKSm+IUpMGs4rTR7nIZOMx3j3xEK91TRQFQZJYjhmVsvEOI5Xg8H1VX+NNqYrnFRfNAIJAmmBvJn/70J/rOd74jRPOvfOUrVAoqoAUqLRBh5SiQcgvG5QBublmgRhEOXLBwPsolUNf658EwTHFAFEc0S6ivTxT4RH52oMRtCKJFylm4sq+7MyVSo/AmRGrEn8DxHWxuFdvMaKqnSROCBQnmaqI53nOv30ONgTohmssufLzerk0to8T7rv4o0ZB651/3easU8dcKYrkMi+ZMBeCbOiKCQxT/grSJQpJbFPhEZjliWORW3ZAoFh1FPrOJp2YI5SDcI9GWVRL19xAl4kQOJ1FDE9HYaUT+JlvaPrOJo/mEc6355hDNWxvrqa/fS5FokjwD3SKuJd81tmgBXAs6PkOrCuXFiuNa98kiOlMupGhYiOYimiXULwqBIts8GGgQ7Qgez0oknH//Q93pK0JbyIp0kp8+pQnUZfNTXNTjSFCLFKYdaQO1Uv73aSQQxZuHl1DI3iAKfCKzHDEsrL4wRoL88ZUrV6bur1q1ipYsWSKKeE6ePJkuvfRS2rBhA/3hD39IxbCcdtppdOuttwpT7ebNm8V6zBo3M6aZBXMV0Dg3NjaSVZh0zjOp/xczRT1bBmi9fyQHMmAbosv3c9Lg4KD40rlcLlEwb9OmTUKwxhezHKK51T4PLTz1wWZqFFWQ0vG7c1eVDkfTi2j0Rkbu90RGXJpd20SnjoGR9d39Mfr9Sbsadty1yuuvv0433ngjLV68WHzfn3rqKTruuOOybv/kk0/SnXfeKRp1DOTssssudOWVV9Lhhx9e0uNmtLchQY1tiN44FhllHIvSXR4Oj2SblyuLG2L50g8XU2RoKC0Gpbtji4hHgeNbFs2LRRbN5fcaDm/PGH7rs26a3aa4BtnqiNx1ojTfcH+UVocGRN55zWAlsVyGRXOmAsRyGfxwD27LKleSSyzXFcWiUVQtVCwvVAiFWL76A4miw0R1DUReJ4omj5jMhsISTZ0zIppnvo5e4VxPYVDRT/c7iMhB1DJWsfMytCc6RHIrCuVmCOR6X5fFc6bUQBS3uf3UGPSPWm8ZTDS9QCxfRDNoiDzkp8FU1NgWaqQQeWlPWlly0VxcYy2WVV4WrOout7jLXAuLFi2iAw88MHX/wgsvFLcQxR988EGhyaxduzb1+D333CMMveecc45YZOTtzYIFcwsz+5IXVUVvc3JdJZpg76anFg7QKQftmnKGwNENkVx2nsPtze7u/GK5LHarieZG893HPmLRvEgGBgZo7ty5YorP1772NU0C+6GHHkrXXXedGMx54IEH6JhjjqGFCxfS/PnzS3LMjPEUKpZnA2I5nNblyuLGlH04yyGWw1Eut91w2bua3MJxjsfh+DbsNRWi+eb1RCG/jyZMDIpBhAffWk/TxvppbMPodnH55v7UoENRxT4rQfC1olguw6I5UwFieSGYEcVSiFhejCCKNh3OcojlcJTL3XGXm8jZRMJxjscbGkc7vPMJokYI53nPo1kCuk6R3GpCeblE8lzH0z+UvWg5w5iBLI5DOC+pUB4qb58HMSxwlkMsb7GFUi5uD8XJbQtRlxSgFTSeWmh56jGz4lgqGRT+dAUqy2BZ66L5AQccMKrYr5JMEfy1116jcsCCuUU46H/fTP2/v3/Ekah0gA+Eh0c5xfWIMPnc5fW2CAXtQzQguen3/1kzarv/2atdxLTAaV5pbm+zuPG1z1P/b6nf/qfU5HEXvE840DNd5vI+4TLH68Bl3lbvEi7z5gaXcJmfcP9isV1PfzT1/QmFIrTs1+x41sKRRx4pFq3ccsstafchnD/zzDP0t7/9jQXzGmRLf0zVXS6L5RB/yxHHgtgTucBmpniC+1iPx7Edkd2w15XfKyRvWfgOBOvEAALOD2JatGa/lyvGxlQgSFtZNK8xrr32WnruuefEjCEUF+/tTc/nfP/99+nXv/41/ec//xH9oKlTp9IPfvADOv/883PuF9utWZPen7r++uvpkksuMeV9VCN6hXKzoli0iqtGieWbB9UzYiP9Nuro8JDTI9G2CYdpJD2IVrTR+LCHfDniQ3O5zk0RznMJ23pE9AKE8UI/R7OFcquJ5AxjFTSL5RriWCoBZJYjhgXO8kxLIu77bYPUSQHqk3zUSOUx4NQsVneXMyWBBXMLALGzqcEtxE4lgYBHiJ5qonmmCJ5NPM8mlGfipCQ5KEkJslM8EiePJ/2r8fDbm+irOzWI+AmG6GfPLRe3EK4BRGylaG4UcKjLsSyZormSpnoP9QyMfDYNDZ6UaI5ZCrUqmodCEAG3g9kSRldplkkmk6IoLTK3mMrEDHe52G+ZxHKAjHBkliOGRQ2sR+FNbEc0WsQu9rhlt3nHhg4aDNeLdXCch4MR8vtH/hZl8RxCOc5Z0cU+KwGri+U15jKPRqN04okn0j777EP33XffqMcR1TVmzBh6+OGHadKkSfTGG2/Q9773PXI4HHTuuefm3PfVV19NZ511Vuq+358+3ZzJjneKvoJRZkaxaBVUixXLswnlMsmYjZIJG9md6o4su5MoOWijLeEweZ1Jsa7d11hy4VyTeG6QCG6kSK5HKGeRnGF0AoHb32Duawx1Wd4FnQkKfCKzHDEsamB9mBxiu0pyl1dd4U+rU6Eu80qABfMygziNTJSCZ6ZoDjKFcz3CeDbiZBdiOURzNNqZOChBLy3tpPvXf0wRx4iz+pXz9qFa/azg7AZwecuiuQxEbdllXkgsS6bLXCmaK8l0mQO1gRdk4K+746tULXj9PrK7s3/fk1EidCUgbCi54oorRM64Gdx0002icMU3vvENU/bPVIZYLrujlVEs5XRIo6AmCnwisxwxLJlgPR7HdipRwKbkmuNWiOcTm9MGFkCmWF6VxT6tLpbXIFdddZW4zZZ/iKguJdOnT6c333xT1LLIJ5hDIG9vbzfwaBmjxHKjo1iyCaj5RNJ8IrkSu0siu0OiJAp9qkxmxHo8ju3U9p9NPC9GONcinusS0C0skhcilNeqSD690UOe+uwzbiNujvdkGOCmuCjwicxyxLBkgvV4HNsxJYTd5cw2WDAvo0M5JXJucwcrxc5sonk+4bxQBiQP9SW91GwfoD6pjiJKl7kkUR1FqM/WQF2DNmrwb4+RqRXRXI48wWcF8NnJorkeIITnK/xZSDSLmsscyN+bahPNtbBu3ToKBLY71Mxyl6NiMwQXRLLAhcjUlljeu60gbyYQy/s3bC9UUg7q/QGRXY4Cn8gsV8ayIDNusD9MzW1jxXbUZV5hH1n4hnAO5HxzJVXvKq80sdyiLvNSzhzKBeLptMwoQpTLNddcQ5MnT6aTTz6ZLrjgAnI6uettJLUilgN3vUR1wSQNdtupziWlMswBYkCjgzbyNSfFdrlez0jhPJ/r3GwBXa84Xgqh3GiRXO/3RCbX7AKGKZvL3GPATCuNcSzSUDdZnSANUosUFgU+kVmuHEpCSx6WfNROPWK7SnGXl4uazjEH7DI3Be61l5D731mbFqWR5gzWIJqDTOHcONHcRhuSzSNZ5rZhGpRcZJMcwlkOsTxqc9FWe6uoMIRjkgVZZfZ6NYnnyvcF8LkA8RltE80zMSuWJZfLXCaby1z+3uB7AtEcIt5geESYGnrqu1TNQCxXCuZm8Oc//5m++93v0hNPPEGHHHKIqa/FWDuGRekuh1O6FGK57N6Wgau9U3GNgUA+edpMGujfnmWOGBY4yyGWe7xe8Ti2W9kzQOs29KXt28zjzSeQV6W7vNIooWju0zBzqLvEM4eygUiWxx57TOSe5+K8886j3XffXQjreM6ll15KmzZtoptvvrlkx1rtVKpYXogAum5b9GK8JULDvT4a6rSTzZskm0MiKWGjurhLZJs3To6nCenlEM7ziefFCt3FYGU3eaHCuNb9sYDOVDVa4lhCW/Jv06dhGwNBc70jbaAQeUWBT2SWI4YFznKI5V6K0EzaOCrfnGFKSatHooY810+vI3sBz0qGBfMSiuV54zQUojmA6KkUzc12m4ckL32aGEcT7N2iAKg91k8Ol1M4yyGW99tGMmiBUjTPFJkrXTjf+7rtFXgz36MaZsSyGOUyzywgq8R7/O+rXjQ3kz/96U9iqj5E86985SvlPhymzJnloNwZ3MgKv+9vI///2k7t5PM4KdjcSjvttgetXbVCiObILEcMC5zlEMvx+AsrNtOd/1hBn32yzvRjrMointXmLq+CmUMorHnDDTfk3NfSpUtp9uzZul7/o48+oq9+9atCqD/ssMNybnvhhRem/j9nzhxRUPT73/++KPxZDld8NZGvuKcusdwEjBDLZYE8E2cgQb4dBimysY7iYSclk0Q2O1HMP0z28RHqdCSItpkvJ+WJa8wX11KocK5XPLeKQF5qN7nRArme12PxnKlYl7mRxT5D1jBbtFKY9qSV9ClNoC7yi8xyxLDAWQ6xHI8zJaSS41jYZW44LJiXgKc+2Jz6v7JgYy7RXOkUlkXbbBEtRgrnEM1DifFUn4yIQqDxuJ0cDQHhLM9ETTSvVNc5imPKyK5sJfgc5IEMGbVYFi0uc62xLJmiuREuc+Dz14+4zPu7yHvoDTT08sVU6yB/fOXKlan7q1atoiVLlghnIKbSwxm4YcMG+sMf/pCKYTnttNPo1ltvpQULFtDmzSN/416vl4LB3D/kmeoSyvE32dsfKbtYLoNZJE+8vkr8/5R5E8UtRPFdm1poIBwSBT6RWY4YFjjLSymWm4bV3eWVLJZbLJpF68yhiy66iE4//fSc2yCLXA+ffPIJHXzwwaLg5y9/+UvSC64V8XicVq9eTbNmzdL9fEabWK4bg93lxYrl2YTyTNHc4R+g5KCDpLiNbE6J7L7EqK66cl9axfNChXOt4rnZInohAnmpRPJSC+S5YPGcqUjRXIdYXglxLEogirfQMuqTfKLAJzLLEcMiN+uVGMfChT+ZaoAF8xKJ5bIruFDRXEtEi3HCuY0GpJH9iNfKMbdTPp5sTuxKyDlXiuVayBXLYjayaF6Iy1z+bkBQG3mwhUXzbSxatIgOPPDAUc5AiOIoBIdp9GvXbp8lcs899wjh45xzzhGLjLw9U1oGIwlyRBJU7xldsNhMR/nrn3fQg2+tT8WxlIPMWBYI9qG+0cIIxPGGQLrQNBiJV74L3EJibqnFcuXnXvGfo8G0tbWJxSg+/vhjOuigg0Qbf+211xa0DwzC2u12rnVhslheziiWYsRyLUK5EnTNHfXar2taxfNChXOt4rkWYTuXmF6oIF6OuBUrCeTFRPQwjCVE81xiuZY4lgoAiksj6bsWMOnUfI45YJe5odiN3R2j5NXlXWlRHHJEB1C6kOU4D6VbWSnIKp3NmcK0mhtaKY7mQ4uwninKqwFRNlv8R2YeuJVArnfmOVC+X+V7kgcu1JDFaiXyAAnI5QzPh1Y3+qjvkOJ7k/k9gctciXfBT6mWOeCAA0QRxMxFFr9x+9pr26N68P9c2zPlAaJ4tsUMsfyZD7cKsRzucuSHW0WoxKDYlv5YVkEc68USTYjMc+WxVxQ1KpZDKM8nluvZrtbBYCjEbNwmEgnxfyyYeSTHsGBAFREsGEzFjCIsHR3bf4y8/fbbIt4FM5HAm2++Sbfccgu9//779Pnnn9MjjzwiCn6ecsop1NTEbqtChHKri+WFCqcQsvWK5cWi5TVxzNmOG+KxvGQD50he9IJznm0phkKOKd/7zHbeKkUsV1IJx33HHXfQ1KlTqa6uTszaQdubq28Ps0DmooxRxEykzMePOOKIEr0bRrNj3AixXEt+eTZy9es1CpMQcgulEt3lDFMtsMPcBBatCqVlTyujNGTRXOkOLsZpni2ixfB881AkqzivxXFuRac5xPJiKUUsS7ZoFiNd5rJoPrTwRu1vnmFqnJ6BkTYZgjPyw63kMn/g4TdFVMz5+02jVv/29rgzHKGH3t8oHgP/eWdd2rGXW+zXTA2K5YWK33heUZ+rxWJZjObyyy+nhx56KHV//vz54vbVV18Vgstf/vIXIY4//PDDYpGZMmWKiFcBg4ODtHz5corFRq7ByChHfQsUJI1EIjRt2jQhmCtzzRlj41esmlueTywvJ1pc58UUCJXJFKjzuc+NoBCh3ipOcj3fi3xRO4WA99NA2oxXpQTFltGG3nXXXUIsx6Dk4YcfLtpetZk7Tz75JEWj281LXV1dNHfuXDrxxBPTtoNA/sADD6Tuc42JEiOL4Zlu8yKyyistjqWaqbhYlkrOL1fCLnPDYMHcBLEcyGKoUuQESuG8FKK5LJLmEs3xmBZHurx/PcJ5tmKa4O2fH0CVIJCrZbWrxbLkK/5pBmrfo1xZ5vJn6NvWwRZZ5uLBVqJQJ4vmDKMxAkZmw/q+7QNQFhOcn3r6XSHq//jL02i830sbw0P00KIN9NIry8XjmXnruo49m4BairxuK4u3JrrKi32+lb6bVgIzg3LNDoLojUXLLCWZ3Xffnd566y1Dj7PWcE0JFiWU5xTLSxTFYqRYviqkf6bUtED2mLJsx1OscJ5PPM8nZusV0wsVxq0gkhsxYJJtH8UK6VsH+8hq3HzzzXTWWWfRGWecIe5DOH/uuefo/vvvF4WeM0EdIiUYxPT5fKMEcwjk7e3tJh89k5dCBPJioljUCn72FeFCZyyDpWJZcvXfuV9eEXAki8lkuojVIlrMjmcB+QRxPS50LREtWsgU0MsplueKZVGiFssii9P5KCaWJfO7pPweKVEK9vL3Bt8Z5Xdl1HcBLnOGYTSL5Ys2dIvs8o8/2SLc2eUu9AmyiaGvvfwR3fLvVXT9qyvFraliufyYvNSSWA6hvMxieX2g3pD9VF3hUqZqqXaxHCK5vBRCIc/PF9eiJXJES2SLltgULUshKI+vVHEr8nlVLmZSqtcpllAolLZgRo4acIovXryYDjnkkNQ61ITAfURgaeG+++6jb37zm1Rfn36tRMwiHOooxnz22WcLJzpjAka7vrOI5aru8mLiWMoMx7FUKOhz5+t3a9mmyrlDR8wW6O3tFfXjxo0bJwY7d9xxR3r++edNPUZ2mBuMz+NIcx9mc5sX4zRXkuk0z4UWp7m8nVERLVpEc7Od5kZEr+gt/mlGLEshLvPM740Wl7nV8TV4yOHJ/h1NmJBXzTAAbfsLKzbT3z/YSus29JU1hkVLNItSNC+LYC1va5TYakWx3GQhOZ/ILYvkey2YRtPG+kXUDgZFsg3isNOcqQWxPCsqYrlW9IizxYrlhQrkWvepxXmez3GutVikmiCdz4FuNIUI98W6yK0kVGv5LI1mit9B3obs37Mh+8hjkyZNSlt/xRVXqM7o6ezsFDUmxo4dm7Ye95ctW5b3eCDCoB4FRPPMOJavfe1rIjbrs88+o5///Od05JFHChHe4dA+Q4MpMVVS5LNWqLhYlmLRK4JjezP65haPZXlMZ8wWBk4PPfRQ8RjiEidMmEBr1qyhxkZzZxOwYG4gn2wcSInmQE04L0Y0l1HGbGSSK5pFK2ZEtJRLNIdYjrgEWRzW876VgwLKWBace6XTX08sCz7zbO5wLWT7DilRHXDZdrzKLHN5gAQFQEVXGlnmgdZUAVCOZmGYdOQimij0qVYo0wpCZDbRPN9zTBWs8bxihWUriOUldlnn+hxloRzXtqMPnEGnzR0vsurxHW1s8NDfX12ZdUCHRXOm2sVyPbnlWt3lWoVYK4rlxYjneoTzfOK5mSJ6oaK4USK5lQRyKwnn+Vi3bh0FAgHT88MhlO+222609957p62H41wGj8+ZM4d22GEH4To/+OCDTTmWmkYWur0tpojlmt3lanEs2Shjf4nd5RUYy1KoY9ws0dzC3KwzZgvru7u76Y033iCXa0RPgzvdbFgwN1gsV6ImnOcTPJWiuYyaW7jQPHOtlNptboZoLovlQL7VIpyXsvinUagNuqQeyygACpQuc7UCoIDzzBlmNJ0Zf19WRKtoblgMi97n6xWeyyWWlzGGJNfn1zahjc48ZqfU/a/t1E4+z8i1Brdn7zWJxja46InX62jz+m5Vt3lBonmVF/9kqlwsL1EUS6GCaimE8lyvq1U4N1o8N1rw1ks1C+SVIJxDLFcK5tlobW0Vju8tW9LFT9zPlz8+MDAg8suvvvrqvK8zffp08VorV65kwdxMIHoXIprrFcv1wPnlplITLvNi41WqRDQPhUZqOioHQjMHQ+WYrUsvvVRzzNazzz5L++yzj4hkeeaZZ6itrY1OPvlkuvjii02dEcSCeQnIFM7VRHNZ8ASy6Ck7hZVki2YxC63CuRFucznTHPta9uvDi45eURbiU67LJZprdZkbVfyzkFiWYlzmypkJo1zmFRbNwjClpDMUodfXdtIL720UhT4z3btWc+zKx5NNeC2pWK62Py1idA0K5fnYYedJdPaRM+mImdkFAojmp8ybSK31Tnr4P2tpxdJNlsjZz4U/wFFbTPERLMWK5WZFsVhVLDfTda52PvQI6GZQbKFOI0XyYj9zPQVdc70fK4jmWnC73bTHHnvQv/71LzruuOPEumQyKe6fe+65OZ/7xBNPiGz0U045Je/rrF+/XmSYIx+XsZDbvNAIFotkl8PtzFS5aG5UFrnRorlBsSz+Bjf5Xbac29hiEqRwTVFbhcRsff755/TKK6/Qt7/9bZFbjoHNH/7whxSLxcRrmAUL5gbhdY/uuAxFE1nzzfOJ5jJao1nMcJkXGtNSjGguH/PsS14Ut1qFcz055VojWnKhFsui1WVebCxLKV3mDMOMiOVPLt2cVSy3MkUL+aUs3ikL1TUulGcb5Ji3YAb9+LAZtOeEZk37gaje6nPTLUSqojlHszC1KpZnw4wolkoQy812nec7R0YL6cUK40YK5GZ9vpn7LVRAt5LbPB/Iuj3ttNNozz33FNEqyLuFe1yezn/qqaeKTNvrr79+VBwLRPaWlvR2pL+/n6666io64YQThEsdGeY/+9nPaMaMGSJHl7GAcK5RKNflLtcTx5IPE/OhqzWOpZSiedliWYqlwp3m60yK2sIgKfLL77nnHuEoxyDqhg0b6MYbb2TB3Oqs6hzOKaIrhXOtonkh0SzV5DaXkYVzNfG8mGKeuUTzXIMDxbjMs1Eul7n8+eRymXMsC1PryM7ytz7rpnA4ojpzpWpFx1IL1zUulOcTy688Ziea0erXtT+I6xDZIZovWbiy+APkWBbGgoU99YrlpYxiMUNMXdmjzxAzo8lTMtd5IeKrUQJ3NQvkel63EPG8EtzmJ510EnV0dNDll19Omzdvpnnz5tELL7yQciiuXbtWTOlXguJx//nPf+ill14atT8ILh988AE99NBD1NvbS+PHj6fDDjuMrrnmGtOy1BnjXeRZxXI97nKOYykp8mBA1bjNjXKXZ+6zQn9fBjREbRUSs4WZP8guV8av7LTTTuJ6gIgXzEQyg/SrisV5/fXX6ZhjjhEXNJvNRk8//bRlxfJc7nM5ogXkEkplZ7JW4TVTyDULWWDNB4RzPS73fNsqxfNixHK9ZDsutYGKzFkAadsrZg+oCdxGIMe+qGWnK0X9zO9K2uABXOYK5CKgDFMLbbqaWP7fz3qzFvpkKhwLieXZOODQXQsSy5WiOZ6P/WSit0Asw5SqXbdP1DaTQk+BTz1RLHooxF2uV1iFSC4velE+t5Dny8er9ZjxvpWLFck8xkKOUz4nysUKFHosVv2slCB+Zc2aNSJiZeHChbRgwYLUYyjU+eCDD6ZtP2vWLJIkiQ499NBR+/J6vfTiiy/S1q1bhdiyevVq4VzMjAiodazcV9edW67XXV6hgmUlCecV76TnfnTRMVsycswWcsrV2G+//UQMC7aT+fTTT4WQbpZYXnGCOaZdzZ07l+644w6qNCCaK4VzNdFcjulQy7qWkSM/Mh3NpUaraK5VONcqrEM01yKWq7lA9Wyj5/2BXLnymTMF1JDd4npQDrZki3hRG2xRRsnAZa5008Nlvv3BVt3HxDDV1KZvDA/Rx1uGqGcgmnKXZ8ZasLu8grGYWK4mXgux/LBZBYvlMng+9qMmmjNMpbbrOcXyIqNYtLrLzRbLixG58+2zkP0WIg4bIU4Xg1Gvb0VxPBfVKpozldmmS8M9pRPLLZJdXigVLyJbSDiv6Pz4KhfjL7zwQrr33nvFLJ+lS5fS2WefPSpmS1kUFI93d3fT+eefL4Ty5557jq677jpRBNRMKiqS5cgjjxSLlfEpRPHBjAxzANFcjmhRxrNkkhnNolYANLVtllgWo3PMC41okVEeizKuxcxjNCrPPFvxT7Usc63FP83KMldDLc5HmXsvf4ajssy5AChTAW36R5v6aJ88U78Kpbc/Qus29NHm9d0sllcTFSCWg6Z6Yx0TavvjLHOm0vrqeV3lJkSxlAOjhfJ8r6E3uqWYGJB8wqzWeBAzBd5KEMWNyqNnmFK06bLIbfM2F70P3WJ5Nnc5x7FYhqqLarEKKPw5vIkqPWZr0qRJYlbQBRdcQHPmzBE1KyCeX3zxxaYeZ0UJ5lZHKZYr72cK50rRPDOTOlsetRpK8VMms/hnKdBaEFRJOUVys96XnGWutfinEVnmhQ62ZGaZKwuAApFlrhTNGcbCvLOhj+ob/MJFq5y9UwhrOwepd1t80jPLOumDTztUxfKqhcVyy1AfqDdtvzXzfdbAtddeK1wqS5YsEVM6kWWrBFP8ZbdLJshaRAEiNaZOnSqiA5SgGN0ll1xi4NHXHkaK5Xootbu8FGK5VcRzqzidzRDIjfocC82hV743rZ8Lzn0LscDOmEehwnnBYjlTUSjd5kaI56YV/yyFA7yCs8y1xmxhUQMxW5kgruWtt96iUlLVgjnyzbDIhEKhkonlmY+puc0LdZkrizhahUJEc6tQrMs8F2a7zLUU/5RR+95kusxVC4AyjMXb9I6BuBC3vzwtJvKaCxHN0Q4v2tBN/17Vl3KW5xLL2ZFboVhQLFdzl0PUPuygWXT+ftOo1W9MBBv2g/2Bp55+15B9VgPIrj3xxBNFJ/y+++5TdcAcccQRaetOP/10Gh4eziqWy1x99dV01llnpe77/cVF69R6X91osdyMQp+VKpabJZ5b0d1slnPczM8tc9+FCOh6RPP1/UO6988wett0LcK57pxyI7LLgUH9fL2RILUWx5IPdp0z5aaqBXM4ea666irTC37mEsuzieZGucyNJFemtxZBuRpFcy3vSS2Wxcouc7WZCUpwHjKjWbyH3kBDL5s73UUrAb+HHHXZfygkhvNnxjPV1ab3DUTIlXSlxO6pCmfu5FZfzqKecru8OjRAz3y4VeSVA7nIZ02J5dXuLregWJ4NiOWXHjiDfB5ju2ksmo9GblMyi8UpC8NhkcH00VdeeUVVXM8EAnl7e7uBR1u7ffVCxfJsqInlesjmLi8WK4jlRornuQRqs4V0MyNVyv05ya9fyGBGKQYwJjZ4yZdjsHeQHexVSyH6izGieAHu8mLiWPq0D6QyxgjnLJoz5aCiin7qBSHxfX19qWXdunWGi+V6yCasFxshALLlaGslX5FMPK6lkCYEZr0FMysJZZSMWvSNmhCtlj0PMVvGyMGRfG51pYifWfwzk7QCoBANDr3BkGNkGLPadLjCIXq/8FlHakHESjax/PW1nWKbh97fOEosz0ZViuUQylkst4y7vG1CG81qbzBcLFeK5o0NnrTIl2wZ6sxo/vCHP5DP56Ovf/3rebf99a9/TS0tLTR//ny68cYbKR7nAd1C+urFiOV6oljK7S4vtwhrdsHQfEU0jV7MeM9mFGEthkKOpxqy2Zna1F8KEssLcZczVVcc1PDin6XsN3MfvaxUtcPc4/GIxUy0uMszt5cdjVpc5plO4UzyuYWVZBOytQjhym2r1W1eqS5zZSyLVnIV/xz1PZGzzBmmQtr05Zv7U//f0h+jr85upcZtMUgyEMrl7WShXCmWb1jfp6ttrFiqXShnVBmbcW2qFDKndpein5cJnOUnn3xymutcjfPOO4923313am5upjfeeEOICJs2baKbb765ZMdaCeT6DPMK5XnQE8Vipru8WsRyM2JCrEYlfg7yces5/6VymjO1R0mvy/lc5bnEcgsW++Q4Fm2w25wpJRUlmPf399PKlStT91etWiWKNOHHyOTJk8kqKB3j2fLJ1Z6jZVujc8wLEYTk5+QTzqtJNNeTZS4X/yxllrnmWJb+KDmiA2RPxskVT1JTvZd6tjngM4t/1oRYyFR9my5c58s6VdcrhXI1sTwzjqXs7nKI20Y4pWtNJK8gd3khSJJEA+EQxWJRcrncVO8PkM1mI1PPp8HfIVxHnTmituKuEcPApEmT0tZfccUVdOWVV47aHoU1b7gh96yopUuX0uzZs3Ud55tvvime98c//jHvthdeeGHq/3PmzBEFRb///e+L6eqlFvkrsV23tWv8+9AZxVIOd3kpRNrlXfpef1ZLfvNLNQvolhbGJSJX1EmOpI0Sdoli7jiRzfiYFhbNmZL21cMdRMk6osBYYw7MzAKf5e7vM1UnmksSUV/MQZGknTz2JAVdCTKzq240vgYP+dy5DzgRlVAZiKqNihLMFy1aRAceeOCoHyOnnXZa1uzJUpMZr6ImhOdzmVeTuFyJorkaVneZayE50EfOTaupbbiPYtE4eZJEw64GikgtUCtyF/9klzlTwW26mjg+apttYnk4HLGWWJ4pTKoJlbkE4VoTxyscxKQEgtqvmX3dnbR21Qrq6+kim5QgyeagYFMLTZ42k4LNrVRtYGp3IBBI3c8mPF900UWiMGcupk+frvv1f//739O8efNojz320P3cBQsWiEiW1atX06xZs6haKWlfvYAoFq2FPkvlLi9GuNUrkud7rtEierb3Vioh3QqiuNbPSD73niEXBXvryTPsInvSRkm7RJG6GPU1DlDEGzPFbc4wJW3TZaG7UOFcq1BeYe5yxnzRHLEsrkAjlZqOiJOWh73UGXVRPGkjp12iVneMZvmHqM1Toqi+QPX9JigVFSWYH3DAAcJJVWlodY9XItUomlvFZV6oaK5WNBZieXzDUnIMDVHS7aMYecmRjJM30kfjEwO0sW4y9ZOrpl3md9xxh8iY3bx5M82dO5duu+022nvvvbNu39vbS7/4xS/oySefpO7ubpoyZQrdcsstdNRRR5X0uCsZo9p0iOGuZOEj2kqxPJOyusq1it0sileVu3z/3SfS13Zq1ySWL/1wMUWGhigYDJDT5aJ4LEbdHVtooD9EO+22R9WJ5hDLlYJ5Ntra2sRitMvu8ccfFw7xQoAjz26305gx1vxOVlxf3SCxPBulcpeXWijXs18zXOhWEbKt9llgP/6oh2aGghRPOsjRkBBiOURz76CbXFEHdY4JGS6as8ucKVubrhS+84nnet3kNZ5bPty3PZpSjbpgA1ULVneaQyx/u6eBhhIOCjji5HJKFEvaaHPETX1xB+3d1K9NNMfvBp75UBYqSjCvFQrJpC4Eo8TQWhHNS+0yNwp0cjyh9RSLRcgTaKKhWJIokSTJ4aKIs4HqqZ9aoltpqzSe1OYGpbnMq5THHntMOCbuuusu4QKE8H344YfT8uXLVcWNaDRKhx56qHjsL3/5C02YMIHWrFlDjY2lH7VmiiOzwGeobzjlLq8IsZwxTSyXRe1SfQ/gLv/GsXPo7L0m5S34iXYdznIhlje1kNs1UsPd7fGI+3Cc4/Fdm1qyxrPgGpc5k6IWWbt2rRj0xG0ikRDCNpgxYwY1NDSkXSfgED/llFNG7ePtt9+mU089lf71r3+J6wGiWxYuXChceX6/X9y/4IILxHObmqz7w65iMKjIZ6W5y80SysstoFcCpp97iWjCoJ88SSeFnBEixVejxStR3TCc5z7aWtenKZ6FYSoKI+NV8onlFnWXG5Ffnk8oV27Horn5YJwJznKI5a2uWEpm8TgkarXHqDPmEo+3usMVFc9Sa7BgbmEnembhTytTjaJ5PqzsMpfBfjt6uijW30fk8aWEE6/bTkPRpBDIY4468kUGqMUnUdeQLXvxzyoGRdjOOussOuOMM8R9COfPPfcc3X///SILNxOsh8CCQm4u18jnM3Xq1JIfN2OcWA53OcTyjg0d5c8qZ8omlqs5v5XrjPhuZHOXt09spl3GevOK5QCZ5RDFfQ3+lFie2r/NJtbjcWzXEAgWfczVzOWXX04PPfRQ6v78+fPF7auvviqcdcpin1/72tdUB0YHBwfFAGssFktFxfz5z38W+eqRSISmTZsmBHNlrjlTIAVmllvNXW51sVzrMVSbiF6u8+yLuygQ89CgIzZKEO8aipEzmaC2YY/INo9pnMLPLnOm5jDCWV6hvwG0iuW1LpqXMpYFmeWIYYGzPFMQx32/Iy4ex3aN7upMo6gGWDAvEmSRI5M8dT+SGJVjroYyx7xa0CKaVxJWcZkXK5on4zGSkgkit3fUY3UuJw1Hk2SnJDkJHXB3zcWywC2+ePFiuvTSS1PrMG3+kEMOEa5ANZ599lnaZ5996JxzzqFnnnlGTP0/+eST6eKLLyaHg390lJq+cIScMSc1BuqKcpbju85iee2ipQhnqV3n2UCBz0QiTk6n+rUB6wcTYbEdkxtksGrJYcUAqdYp67vvvju99dZbhh0jo00sryR3eaWJ5dUkolvxfLokOzkkOyVs6jOME7Yk9Q8nRSFQPXOQOc+cqRm0iOVGucv7tA2qQpy1olhe66J53s82mCfST8PvBYACn8gsRwyLGm67ROG4TWxHVF26YDWRbktiSkYhYrmRER75RFBEcGQuRuy30lzL+d6PLCwDuWhmpss8E7jMR22nmEGQmT8OionosTtdZLM7iBLqjhS7lCCXC3J59u8XYlkqjVAolLbA5adGZ2enmIY/dmx6fh7uI89cjc8//1xEseB5zz//PF122WX029/+ln71q1+Z8l6Y3GzaGKIN6/to3Ya+gsRyObuc4ymqxFlegLtci1hezPZan9fqSx9szYbL5SaHw0nxeIxi8dEdcazH49iOYWpdLDfLXV4oetzlVhR3tRxzrqXaX78QYrakEMUhmquB9Ulbklb0WfP4GSYvoQ7zhPIaziwvVCw36vlMdjz2pCjwicxyNaLbCoBiu1rljjvuELP06+rqRCwuIg5z8cQTT9Ds2bPF9rvttpvQYcyGHeYFMhRNkFfhLFeS6TKvpIKfuYRx+bF84mk+p3mlR7OUwmWeGc1SjNPc4W0gV0OQIt2dIrc8bXaDJJErMUxD7iBFbHhP24V7q8ay1Dd4yFmX3S0Td44MDEyaNClt/RVXXCGmxxtBMpkU+eX33HOPcJTvsccetGHDBlE0FK/DlJbOjZ3U0NKaGuDy+0d/P2T3uZpYLrvLLQVEX84xL0leeTHid7mc5vX+gMgqR4FPVxOuNSOdcYjncDoP9oepuW2s2I5hajWGxSh3ud44FqPc5VYVd4ulWt9XMQw6YxRyRagp6qWQLZIeyyIR+RIu6nEPie2Wd8Us7+If4wtSgy/7b6X+hPV+XzAlQBa2Awa06XpFci3u8gqbZWqU2F1NTnMr5ZkHXQlqdcdEgU9klitjWTApMZxwUrsnKrarRR7TWUMOMz2/9a1v0fXXX09HH300Pfroo3TcccfRu+++S7vuuqtpx8kOc5Pc4hDJ5aXa0Oo2z4UVhVgrucyzoeY0z+c+R56tt30K1fm8RIN9JMWjRFKSvI4EuWJhits9FPK2izCtzBx2UKkxO+vWraO+vr7UooxcUdLa2ipE7y1b0jtSuN/e3q76nHHjxtGOO+6YFr+y0047CUc6Il6Y0iO7wzev7xZuc3mBII4FQnkusRzPL3fMBpPFLa5lKbFYXsjzi32ttH3ZbDR52kzyeL0jWeWDwxSJJigajYj7WI/HsxX8ZJhqEsuNcpcbFcdihLucReUaw0a0wRemiD1OgbiHnEk72SQSt7gfccTF47KQruf7oeU7Z2SEEMOY6gov5LkWLfRZTMFPdoYXfj5LFZWDLvgs/5DQXFDgczhho6RE4hb3sR6P12pX/WZFDbmdd95ZCOc+n0/UilPj1ltvpSOOOIJ++tOfCt3lmmuuERGIt99+u6nHyYJ5kS5zGavnkWsRqPUI4fm21eLWrCTRvJBjh8s8E7jMM4HLXGs0iyyQyyK51qgWV0Mj+afuTPaGZqJYhOyRfrLFIxT1NFKXfypFXP68+6i0WJZAIJC2oAibGm63WzjE//Wvf6U5yHEfOeVq7LfffrRy5Uqxncynn34qhHTsjykPEL2xoHAnFrRDENAhisviOcAt7lteLC9CCK5YDBDBi6U+UJ9aSimEq82MyEWwuZV22m0P4SSPDA9RqK9b3OI+1uPxXFhuVgXDlFksN6LYpxHCI4vltUnYHaEVgW7hJPckHdQQ94hb3F/h7xaPM0xVIYvfyiXfNnqxuFhuFViAN4c2T5z2buoXTvKhpIO6oi5xi/tYj8drkei2GnKoGae1hhzWK7cHcKRn294oOJLFxAKgubZTXV9hbnSI5rlE1GoqApqvAChc5iiWKbvMM53acJk31XtGuczb6nNHrKhFsxSaaw7R3Dl5V5IiAxQODxE5nBSOuslns1EkwwWvLPxZC2A60GmnnUZ77rkn7b333mJK0MDAgBjxBKeeeipNmDBBTAECZ599thjNPP/88+lHP/oRrVixgq677jo677zzyvxOGCWZmeT4Ow5t+zuWxULL55bXSjRLGQRyNaEbInn7xGbFmmb67JN1mvaVa9DFSHe5Eojiuza10EA4JAp8IrMcMSzsLGcqnuY8RbeKwMxin8U6fVkstx5bOo35TMa25v9NBFF8mStCvrhLFAJFtjliWNIiWhTfFatHszCMbozMI9cjllvROFNicZujWcwBonirO0x9MYco8InMcsSwVGtXPRQKpd2HaTHTuJirhtyyZctU94uZ/HpqzhkFC+YFIueUZ2aZaxXNy4maq6zQmJV8onk+KinPvJABgEKyzOEyb/KY41KGiGKrayApsa3RihVeTLSaOOmkk6ijo4Muv/xy0ejOmzePXnjhhVSjvHbtWjHqKYN89BdffJEuuOACmjNnjhDTIZ5ffPHFZXwXTDaUoriaQG5Jd3ktieYWcdJDLN9rwTQ6ek768fx3xzZ66ul3CxbNzRLLU/tHnFYgSJVM0O8hlzd7XyDmqk0HDmNNd3ktir16RN9aPTd6Xi/nebQRDbq4f84wRVGlznJ2ghsDYllcgcaSvR7E8UY3zLGVZZCV8QTqqc6TO5wkGsHM+7CpdeTKAQvmJRbNM93lyliXfM5hZXSHlcglmmsRmStJNM+k3C5zI4GwnxkjY9XCn2Zw7rnnikWN1157bdQ6xLW89dZbJTgyxkwsL5ZnisrVJJyXUSjPFLEhlh920Cw6bc8JNKM1PaKq1eemVZtm0JKFKzXvV/5emS2Wl4Vq+g4yNUe5in2W0l1uphCsdd/lFNZLLYQXc4zFnietLnN8/2Y06Yv9YpiKpUrF8lJQLpe5loEAvcdlJZd5LbFu3ToRhyujFotbSA05rNezvVFwhrlBZArfEMbVFj3IGdZaikGWm1wO9WrKSS3kvRSbZZ4rz5xhGCKpv7sg4btixHILurGLoswZ5ZnIYvn5+02j8X5vzu20AqHcqmL5YCROW1SuQQxTLe5yozAyjqVUIqxVxGL5WMqxVBKVdrzl5o477qCpU6dSXV0dLViwgN5+++2c2/f29tI555wjagxBtNlxxx3p+eefL2qfTBWK5WX8PaCn4Gc1usvxnrS+Lz3bFkVfFc44C3Vaqo6cu4Aacliv3B68/PLLWbc3ChbMC0R2gStzx9Xc4pqLhpYxv7zQOBYjqSQXc6Zorjx2Ze43XOaZwGWeCVzmRormLK4ztQoEcHnRsm3FYiGxuZKFchnEsMBZnm1m2NRAPU0bF9AtmluRznCErn91JT3+7Adp8UQV/ffA1Bz5xHKrxbGY7S6vRKGY2Q5/dtp47LHHRM0hTO9/9913ae7cuaLg29atW7MWlTv00ENp9erV9Je//IWWL19O9957r4hRLHSfTJHZ5GY6v7FvdpYbQilE6WLEbz3P1TMgoRnuMxsC2l60yQ899BAtXbpU1IjLrCF36aWXprZH/C0ic3/729+KnHPEvCxatChrQoBRcCRLkaK53+1KRbMoRXBlRIsaesX1SqCSo1kyBw2KyWUvJss8H6WKZ2GYSkcpAFrV6VvRueYWFL61ovf7ACEd7vPGBo8QmitZLL/1v6vopVeWW7/YLcNUURyLWWI5C63VAz7LasqHN4Obb76ZzjrrrJSYctddd9Fzzz1H999/P11yySWjtsf67u5ueuONN8jlGvntBCd5MftkDEApagfHGru/Kqaa3OVGvZdi42NKnWPOFFdDbt9996VHH32UfvnLX9LPf/5zmjlzJj399NO06667kpmww9wEp7ksiGcTxUfFtyiemy2/vBCUbmdGn8M+n+t+xGUuUYM9Qk2OIbIN9In7ZrvMS+Egz8xeZ5hqcp5rdaBXBKUWrWWHeAWL5bmQJIkGwn20adMm6g/1ifvA53EK0fyrs1uFG73SYbGcqWSMdpdXahwLi+UakYj8STe1JLzidltXnbEIoVAobYlEIlnd4osXL6ZDDjkktQ5CCu6/+eabqs959tlnxVR9RLJAgIGoct1111EikSh4n4xJrnC9onehz1OjWn4TVIBAb0SkCprwkDNAXa5WcTukYX+muMwZQ4A7fM2aNaLtX7hwoYjFUtaQe/DBB9O2P/HEE8VsIWz/0Ucf0VFHHUVmww7zAlE6fZVOcyC7zavVSV5NLvPc2evZ30uTK0KzfSFqdETIYUtSQrLTgKOfNiSbKSR5DXWZQzRv8rg1Oc1rIY6lsd5FLm/6+VASc1g/859hKs5pXqUiucxgqJuWf7aewn1dlIgnyOF0UHNLG02eNpOCza2p7Zrqs7c9lUrVDCAVAKbqX3PNNfTKK68Id8v48ePplFNOoV/84hciX1HusP/ud78TubYQdOBo+elPf0rf/va3c+7bZrONWvenP/2JvvnNb5r2fhjrkS+OpRB3OYvl2mhK1tH0eBM1JbzkJBvFSaIexxB97uyhHrv1oiCryWU+xttKfl/2miC++JC4nTRpUtp6RKNgmn0mnZ2dQuiWnYcyuI+p+Wp8/vnnom1HW43c8pUrV9IPf/hDisVi4nUK2SdjIjXiFK9VjBDgu13N9LlvB+pxNVPC5iSHFKemWDdNH/yMxvuq/Pd/DffVyw0L5gaL5kAZ0ZKPbNnltSB8mpl1DmHeiGKjaqI5xPK5wV7yUoKGpTqKJ13ktCUpkAxRvSNCnybGUSiEggeelMs807UNl3lTvWeUy7yt3pVymbfU5/7zlL8j8neQvzMMU6OYLZpXsViOTPK6eD9t/nQtOZNR8tb7yVnvong8Rh1bNtFAf4imzp5HgcaRGJeegWjFx7Ew24EogiJDd999N82YMUO4VTA9HxmKN910k9gG0/nnzJlDF198sRBS/v73v4tcxWAwSEcffXTO/T/wwAN0xBFHpO43NvLU33K5y7PFsRiRX15MHIteWCzXLpbPjY6lOslJ/bYoxShJLrJTW8InnObvu7dYUjQ3ixlN1pw9um7dOlEUTkatOFyhoG0fM2YM3XPPPeRwOESBuQ0bNtCNN94oBHOGqRTKFcdSbOSJcj9GiOUf+OfTsN1LDYkwOaUYxW0u6nSNpX5/gCj8Xk7RHC5zV7Cp6ONgag8WzAtEdv3mEs1BLuE8Uyw3Mo6lnORyZmuhnFnm+d+PRDvU95PXkaDuKD7rJLk8DopJDupN2KnVGacJ9m4KJcaLaBZZNNfqMleK5vlc5jIslDMMY5poXsVi+QgSNQ1voZg3Tk2tY1KuYJfbQ06Xm8K9XbRxzUryB5tLcjSdg8YL8is7w3TLv1fROwtXFb+zcubmmwDEbKWgPX36dDHV884770wJ5shJVIKiQy+99BI9+eSTeQVzCOTt7e0mHT1TarLllxeKXnc5i+UakUg4yyGWd9uGibZN9ohSkrppmJqlEef5Ytem1GNMeYBYrhTMs9Ha2ipE7y1b0l3IuJ+tjR03bpzILsfzZHbaaScxmwhxLIXsk6ky2LVrOkaI5YhhgbMcYnlTvCvVbLulqLjf42wRjzf1vUNenQJ/1hzzvg6iYFvRx85UPpxhXgRyvrRSsMwUvSGKy0vmOj2vUTb6u0YvRWCE69so8uWUq23rd8apyR2l/hjGmjJ72Tbqi9opaB+ielv6FFytWeZKlFnmlvguMAxTW5RJLEdRzmyL0fidMfLG+8ntbRgVoYH7cJxDNF+1ZSs9tGgDffyJeVOGw+FIyfPLKy2ORWvebTH09fVRc3Nz0dsAZOdClNl7771FETk5F58x3l1eiXEsemCxXDt+yS1iWOAsV+mqU78tJh7HdswI0wLaZkaXC0RkwSH+r3/9K81BjvvIKVdjv/32EzEs2E7m008/FUI69lfIPhlGUENCajGCt1HO+LAzIGJY4CxXadKpPhEWj2M7hjEaFswLRBYzlaK5LJxDNFdzi+cSypXbG+UYznQ3G4YG0VyPGF1M9EopwXty25PktEkUk7Y31zHF5xWX7CTFY+SkZNbCq3CZZwKXeb4CoIXAIjvD1BAV7AbXKoobLZ67bUmyEzLL1SfcOZwu6h+O0lPvb6D/vLPOUoO+WhH9k9CwpYt9Ihs+3yLn3SIKRV6uv/56Q48D4sptt91G3//+97Nu8/jjj9M777xDZ5xxRs59XX311WLbl19+mU444QSRnYt9M9bH6gU/mdy4JYfILEcMixoxSojHsR1TOVx44YV077330kMPPURLly6ls88+W8RnyW0xorIuvfTS1PZ4vLu7W8wKglD+3HPPiaKfGMjUuk+GqdU4Fisdd8zmFpnliGFRwyXFxOPYLtfr1mzxT7jli8QVbBSRNrmX6owd5EiWIpBzppVxGdkiWnKhJYqlWOHUcGEcjzUUJlhoKf5pVULhYYo32shlkyiqEM1lnNsKgMZto8eitGaZ5yJXNAvDMIxh0SwlEt+LEb7x3GId0r2hCCXJQYk4rrGj2+JEPEZxslHPcFJcu0ohOg9G4uTzGNM9W7Shm255aSUtWbhy1GOV5i7Xk3d7ySWX0A033JBzXxBHZs+enbqPbFvEs5x44okix1yNV199VQgpEFh22WWXnPu/7LLLUv+fP3++EGGQnXveeeflfB5TmLu8kPzycqInjqUW3OXhTWHD9mW3xWjY00pSMk5RGm1UcpODhu1R6ukLUVhKN+j4x/kNOw7GWE466STq6Oigyy+/XMSqzJs3j1544YVU0c61a9eS3b799xcGWF988UW64IILRB2KCRMmCPEc9Si07pMxkP5uIp+Fom5K0AdC1AciPyodvVnmRov8LikqCnwisxwxLJnEbC7xOLYr5HgtTwX216sJFswLRM6a1iKag2zCebXklpuB1bLMQV/UQVvCNpoQiG/LMLelXOYuj5Pq7THqjHtp66BE9dv63MVmmWcWAGXRnGGYshYBzSF0axVhjXKIy/spVPwNxRw05PTRwECYGut9abEsiM8YGgiTx99EWztLE3TbORCnwahcA8VpmlheqfnlWvNuL7roIjr99NNzboO8cpmNGzfSgQceSPvuu68oEKfGv//9bzrmmGPod7/7nXAy6mXBggV0zTXXiBgZIwvbMYVTCQU/rSKWGylom02fNEydiQFqd/ipMzl6kDNgr6PNibDYTsv7tLKIPqvFV7EFPwvh3HPPFYsar7322qh1iFZ56623Ct4nYzDKvpoJMXuVRiU5nsspQvvjIWqKdYsCn8oMc4CguwGHn1pjW8R2hZA1xzzfd5m/wzUBC+YlEM31COPKOBbLx2nkcZkXW/zTmthoRV8dNddHqNkdo/64g2JJO7nsSWqQojSc9NDaCBpcdXHFCJe5eA6L5gzDlEk0zyV2m5Ezbq7b3EY9dWPJ4e4UWeXILEcMC5zlEMvddV7yjJtCtLrLdHf55vXd9MJ7Hmqtd9Ke7U1FCeYvrNhMd/5jBX32yTrVxyvRXa6HtrY2sWgBznKI5ciyfeCBB9IcikohBgU+4Vr/3ve+V9AxLVmyhJqamlgsrxGMzC8vFZUkiufj00SHEMZb7fUUSg6LGBYXOcS6QSkmHi/kvFhZPK/W/HKmSimneF7lfaByYqS7fFBR22d8dCn1twdEgU9kliOGBc5yiOV1yUGaPvhZmvqSTeDHIAXiQzTBhT8ZFswL5zdfmUU/e255XtEcKIXzYlHmW9cCVnSZd0VctHAj0S5jEqIAaL0zQQnJRlsjHtpEbdSbqBt17Ea7zLWI5kYOuCBCZ90dXzVsfwzDWFg0zxHHYrYg3jahjb641yTVx1ZtChniloZYrHwfw84Gap4+lrx9mync10WJgX5yOB3U2DqWxk+ZQUtC8K+Y/+MKgvyKpZvoznCEzj5yJh3hL2zq8sNL1tN9f1tKHRs6alIs1wPE8gMOOICmTJlCN910k5iaL9Pe3p6KYYFYjqn8yCLHtH2AgnFy4c+nnnpKZOcuW7ZM3P/b3/5GW7ZsoS984QtUV1cncsyRnfuTn/ykLO+zkrFKsc91BtYv0BrHYra7vJoE8ky6koO0KLaOdnS0UaujnhyiWkVSOMshluPxQs9ZNYrmDFNWMvslleDchZBqQDZ0JeWX53OZG3G8SpFcSWOki3bcvJDW+HekvroWIneDiGGBsxxieXOsu+jXZhg1WDA3WTRXc5tnw6hin5VAJeeYy6L56+ucNLYpIAqBRpN2Csfx55QkX55+dKEuczXRvFSwWM4wFYqBTnM1sbw+UG+Y83qHnSfRiftPoyN2UHdzrA4N0IOBOnrt5Y+yHl8hYjD211S/O526x240yRajeCxKTpebfA0BWtoVpr9/sN64WJM84FxuXk/CHQ6OmJlfNO8MR2jR5p5UpEsusbyS41jMAEI2Cn1imThxYtpjiOQBKAY3ODgoCowqi4x++ctfTkUA9PX10fLly1OPuVwuuuOOO0R2LvYzY8YMuvnmm7NmozNMKalmoVwJRPE3k2soGK8jt81BUSmhGsNS6Pkrt3Bea3EsTA2h1pczSkRn04ApormZYrlSNA9G3qR+V5BidjcFfCNxLdlCE6siy7zY76vJgzq1AAvmRSI7gtVEc6DVbW6kWA4xFqKstWJZJPI74xnicuW6zEewUTieeyDESJe5GdEseB28HsR6iPZKcKw4Zqud+0afh9y+7D8AorbaGXhiGMNFcw3FPiGS77X3VGrzJMguxSlpc9K7q/pp8/qegsRz7G/mTuPolC9Opv0nt2bdbufWAP34y9Ooqd5NTz39blGieabLHPvrGYiK/Y9vDop1n3SGjM0A1xnPAtEcAvgp89KFXCUrO8P00KIN9J93RqJX8hUmZXd5Osg5z5d1/uCDD4pFz35QPBQLwxSK0e5yrSJ50GasuGwFxPsYGf9iShTH0lw3ngJ12QV9V9Qa2fxMBZGt/6JHSK+xPhCavbAzQDGbWxTEzCUul9sFn08sl8Hx+2N9I3ci6PfrHxRUi2UpKMecqQlYMDdRNAdqbnOlcJ5NKDc6vxyiJ8RbAGc3flSXiiZXhHao7xfxJU6bRHHJRj1RN20kRyq+xAxK8T7Vctq1uOeNdJlznjnDMKVymkPc/tZhU2meu4cSA32USCTI4XDQrrO89FJ9gJYsH3FJa90XgFj+48NmCEFcJjO/ezASF7fj/V46f79p4v8vvbK8KHd7pmguO9e/sMNIzMYL720si1iO94RzA9H8vr+NXLeRa67G3z/YSu8sXKXpPLBYzlQrg/xrpmixvMXuS8WXOMlOcUqKwpnFxJdUOxzPwjAWgPs2qnS7mulz3w7U42qmhM0p4ktQONOI+BKjo2K0iuXZnusrQDQ3BLMLf/J3O0V3dzf96Ec/EpGHqDWEiMRbb72VGhpyzyB488036Re/+AUtXLhQ/F6dN28evfjii+T1ekkr3MU0iVyieS3Fr7R4YjQ32E9eR4L6Y06KSTZy2SRq80SoIbGJPqVxmkRz67rM8xc3zXfsxbrM1b5jhQ644DhwPAzDlJ9seeEFC59FiObysYxrtFFL30pKem3kq/eT0+mieDxGtoEwHT3OSf6GNvq/xflFc1ks32vBNDr9CxNTYrmWQpc+t0OI5o0NHnr82Q9GvZaeaBY10fzjT0YiYQyPNSlANMcA7G2PLqb2iSMiPgj1bXd9aj3GosTyKo1jYZhyoCW/3Ch3uVZXOcTyPV2TyGdzpRXIbHf4RZFMZIGzaG6+aD621VfSOBYu9skw1s8xL1Qs/8A/n4btXmpIhMkpxShuc1Gnayz1+wM0J/yeZTK/ixHLtYjmVRHLUigW/G4Wyre//W3atGmTiFKMxWJ0xhln0Pe+9z169NFHc4rlmO2JGkO33XYbOZ1Oev/994XgrgcWzItEdgVnusy1iOZGU6jYCbEXou8oELWCyJWCkWhmcJi8jiR1R3FORiYBRSWbuN/sjtFkRy/1Do5NPVYcEjXYo+SyJSkm2ak/WT7XdTaXuTKWxegsc/k7pkUsx3e01grIMkylkK+wpvx4QSJoLtE8bxyLRFNcvUQxJ/nHTSCbbaTddrk9IvObervo6PFRGnZMpXfeXi0eyxSzZaEcHHbQLDptzwnCNa76apJEA+EQxWJRcrncZHP7Uq8J0fzsbcVB//7qyqLE7UzRvJxCuRLlufvsk+Kc9AzD1BZ6csrhLIdY3pnc3s5EKSHut9rrxePIAjeKaox9YRiGsUoMC5zlEMub4l0phcUtRcX9HmeLeLypr9sg9aXw2BcjxHLTneYQnTEwwpSNpUuX0gsvvEDvvPMO7bnnnmIdBPCjjjqKbrrpJho/frzq81BH6LzzzqNLLrkktW7WrFm6X58Fc5NF87TtNIrmmYInBNJCkXOoy0HQnaCWuhj1DNqJnJlNp4364w5qgtPcHqX+ZP4GTo6UUaPRMUxTPL3U6IiQw5akhGSn3oSHlg17qCfmKbvLPB9GuMzNiPJhmIog1EHk8OQXfWWhWENOtxWF8mzb6xZEC3SaB1wJCjqGidxjU8J16lhsNvLW+yk6FKIf7DUTK0RUiFIgVwKxHC5xCN8ySnd5X3cnrV21gvp6uiiRiJPD4SSfv4nGT51Bgcbt52mXsV56PVhHHRuoKDJF82qhaLGc3eVMBeCLcyxLoWI5xGvEsMBZrgbW43EUzixW3ObYF2Mohbt8YoP26eoMw2QHudjIxy5F7AlE47ArSJ3BRvIM9VA8OaIhubb1r9Fzr0+ERUwLRO5APERWjX0xEjWXuVqOuaWoYLNLKJT+vfJ4PGIpFDjFGxsbU2I5OOSQQ4RTHFErxx9//KjnbN26VTwGZ/q+++5Ln332Gc2ePZuuvfZa+uIXv6jr9XX50f/f//t/4uC+8Y1v0L/+9a+0xzo7O2n69OlUa8iObrlgIkROILt3M8VuMwTNfI7kcuG2SyKzPJZUH2eMJe1C3IYjvBgglu/s7aAW5xANSw7qS3jELe7PDfaKDPVyoMxPV4r95RrA0EOm852pXqquXYfAJy+Z6zO3sRDFiLV4ru7nKwcN8H8NgwhuR1K06eRQ/6HtcLooEU9Qi9suimdCFFfjG8fOGSWWK4FYvvTDxdTdsYU8dV4KBJvFbW/XFlr58bsU6jWnE1ltTuxKej/Beo+I2Mm24HGmRtv0GqPYOBY9YjmA0xviNWJY1MB6B9nFdsUgx74g5mUwGaWu5IC4xX2sx+O1jJ44Fqb24HbdwljEfSy7tWN2txCvncntM8lj2+oAAZcUE4/DEW5E7AtiXryJYWqM9Yhb3Md6PK7leI2k2H0WMrBhWWHb4DgWlz8oBn9yLv6g2HbSpEkUDAZTy/XXX1/Ua2/evJnGjEn/nYp4lebmZvGYGp9//rm4vfLKK+mss84SDvXdd9+dDj74YFqxYoU5gvn//u//0k9/+lOhzGOEABZ45ZtH4a81a4ybrpeNO+64g6ZOnUp1dXW0YMECevvtt6nc5ItBMVI01+IyziZ4KnO08xWl3L6jwkWcaNImCny67Oql6V32ESc44lMKRxLO8jp7XDjKY5KDJLKJW9xHdvr0eozQqh+DkajG2uQBsSyZyIMvuShm1gFjTNvyxBNPiPYQ2++22270/PPPU6VR9e16NvE88/EyY5SzuSDRXIfbPpqwizadEurCSiIeI4fTIeJZGj1umtXekJa9jesOxHJEqWQTyxHDAmd5ZGiIgk0t5HZ7hIPA5nCRv7GFosNDtHHNSrGdWSJzJQnN2TDkPVjgb4PRR9W36YyhYjlALAqc3sgsVwPrE5QU2xWDMvYFcS+SIvYF6/F4LZ13K7vLJ2n9jcjUTLtuSJse6hwR8aooV7lYjHI4K4ViVzIqnN5xe7pmJIvmMZtLPI74FKNiXxD3YicpFfuC9XjcfPWlSqnw3yHr1q2jvr6+1IIMcTUQlYIZyrmWZcuWFXQMyeSIIff73/++yDufP38+/e53vxORLPfff7+ufWlWKu+++26699576fbbb6c//vGP9Oqrr4oXvfzyy6lUPPbYY3ThhRfSFVdcQe+++y7NnTuXDj/8cGG5twLZXObFiuZqedVGU0ycSDb6og7qGnaJafyjBWuJGpwJ2jpYXNY44lwQwzKQ3J6Rnhn70uyOkt8Zt7zLXG3gRf4uAbMyx+XYF7WZCnLeerWjt21544036Fvf+hadeeaZ9N5779Fxxx0nlo8++ogqCW7XM4TBMgjoWkVuRJtkizcpZH+FCLChmIM29iSpq6eHQsPp7RUE7KGBsBC1fQ0BWh0aoLc+66bN60emZEI4P/OYnVK549lAZjliWHwN/qyxL+HeLhrs3z7dz+/3aDo3et+vcqkkKu14GePgNl0fY33aRdpqFRERs4JYFBT3VAPr8XgxcSyaY19s6sdQ7RjpLudCn9VHudt1U9p0WTivFvHcIi5z0BDro+BwFw24AyrqC9GAwy9iU5A1XiiIc0EMCwqKjlZf0mNfSuUuz7fvQiJuNMP97jQCgUDaki2O5aKLLhL55LkWzJ5pb28f1d7E43Hq7u4Wj6kxbtw4cbvzzjunrd9pp51o7dq1ZIpgvmrVKpH/IoP/v/LKK3TPPfdkHTUwmptvvllY6jFKgDd/1113kc/n0z1KYCSvnLePuC2k2KaaaK5HSJeFTiWZOdiGiJ4Fu8xttKKvjgYTdlHg021PkA2jj/aEuD+UcNDnA8iTKrzkBOJcEOsSz+JSH4l9wWsWF/tSLS5z5eBLttkKmd+hZb8+nKodvW3LrbfeKqouw/GBhveaa64R03zQma0kuF3PEdlSAvKJ2/MWzEgtM3caR3stmJa2Dksh+y3iiGlFyEsbOyL0wefraXNfWIzgx6IRIWK767w0fsoMWtoVpgffWi8yzGUmTQjS7Lb8ogAKfCKz3Ol05Yx9icdyXyuNPgeVIkIbdpzsLq9IuE1Xp6VuAlU7xbickSE+KMVEgU83OUSvHLe4j/V4vBhKFftS7WhxlxdLtQ4MVTLlbtdNb9OrTTwvM2i/p4Q/pbr4EPXWtVLU7qYk2cRth62R6pKDImO8mIKfiHMRsS+SupnPqNgXs0GOuSZK+d00ZIZoZfwttbW1iZkzuRa320377LMP9fb20uLFi1PPRRuI36CY8aIGZsSgGOjy5cvT1n/66ac0ZcoUXcep2brc2toq7PV4cZldd91VHOxBBx1EGzduJDOJRqPiJCkvDJimjTwvBMGXE4jmJ9y/OG8BUAicmW5xWSBHMdBSFGxELIvsdMb0eKUDGi7zrIIvRPN+/X/AXREXLe5ooF3GJKjJHaV6Z4ISko22RjxCLEdBTl8RhhLEuSDWxWlLihiWTLx1DiG+RJPFxL5sQ37/RcTU4Nwro3GsDGJ95AGhaqaQtgXr4bZQArfF008/TZUEt+t5BEMTi4PmE3QPOHRXkQOej4fGBeipp99V3b8ZIi/a9IWbiHZJxGk41kHTWsNU53aRx99EnnFTaElIoof/s5JWLN2U9rzekDZ3osvlFgU+4/GYiGMBsURSNfal1Fi9MGiliPqMeXCbbgztvkbaPFhAlmmFgoKbi2LrUgU5IV4jhmVzImxIQU5l7AtiWMyKfal1OIqlOilnu17yNl0p9FnItW1l1BzVjZEu2rlrEa3x70h9dS00uK0gZ8vgFpqVXF10QU7EuYjYF5tLxLBkkiv2xUx3ufI1fH5PwTnmyOMuC9yPVwXmRBgVMXCHAbtYLEbnnnsuffOb3xSiONiwYYPIJ//DH/5Ae++9t5iVDGMjZsZgVsy8efPooYceEhEvf/nLX8gUwRzVRJ988kn60pe+lLYeI40oPnHggQeSmaCgBTK6xo4dm7Ye97Nl20QiEbFkq9hqJHCYq7m7NT+/SLEcIn2mKxmCp5p7uWCKEM0X9QZFLAqc3hCvw3F89YoZ2xwBcS7IKkeBz96EPWOfEtXbY7RpyL3t9Qp9ka7R93OI5hh0UEbcYFBCLTMesSyZ7n+175E8+AKUAzCFgkGbTHc69o/XUfseVXuF5kLaFhSYUNs+W+EJq1Jp7Xop2/Rycvxxu4uimK0aOnuXHjhDFEV8/NkPaCCkf4ZLIYIx2vTX1zmpfcBN46J+8tR7abizjmh1F4XDG1MxLJl0Dua/ztX7AyK7HAU/XU3utFgWOfalsXWsiH0pB1YVzQ0Vy9ldXrFUWpuupV2XejeQrTG/Q9wXJxo0P8GwajO0IYq/mVxDwXidcHpDvC4mhkUt9gUFPpFZrhb7AnHeqNerxjiWfO5yjmKpXsrZrpdVf5HFc7OF88w+XaH9KRxnFmcvBNiCCkoWAUTzYORN6ncFRSFQZJsjrqW+QCFZCeJcEOuCAp/ILLepxL60xrYUFftSceB7Y8HfB9XCI488IkRyiOIYtDvhhBNEfQcZiOhwkw8Obh/g//GPf0zDw8N0wQUXiPgWCOcvv/wy7bDDDrpeW7PtFqHsc+bMUX1sl112EaOcl112GVkJFMRQVmhFxVYzyRbLkivLvBAKEUwNy6JWCsX4v0a3NUTjcNxFXVGPuDVCLB/BRmsijTScdIosc5dtJPYFt7iP9dliX4rKbS9g4CDn7owc2NgGZi3kI1csSzEDQGbS1OASAn+2BY+bUaG5Gqm0dr3UbbpZ5BJc9YjlwOdx0kVfnEY/OnkPapuQ/qPCXGHXRpu7Y/TeJ9304fJeWrFss3CVZxPLN6zvo4+3DNFgNLuDcDASFwL55GkzyeP1iizzaDSiGvuSmW9uSlHYCoGd5YWzevVqUYti2rRp5PV6RScabhS46mSuvPJK1UJE9fW5+xBqz/nzn/9s6vuptDbdCu26nhzzWgCidUeyuMzycsS+lBP/OL+p+6/EKBYMYOVbmOps1w1v082Ma1HrJ1eR6Il21h/ro+ZIh7i1GeTwxn4Q61KXHKIeZwtFbCOxL7jFfSNiX8zA1BzzYjEsUrFyr6W5aG5upkcffZTC4bAoJIpIqIYGaHwjYAYOjFUHHHDAqPYTM3QGBgZEDToMQOpFs2D+xBNP0P/8z/9kfRyB7v/973/JzOlIDoeDtmzZkrYe97OFvWP6kLJCK05WOYp/monWHHMlykiQTOezJhFZh1BeCnoTdfTJUBt1xb1UZ0tQ0BERt51xr1iP2BdThPEcj2VG22Qr/pmLYpzeslieTTRXKySbq/hnNVdoLqRtwXo921uVSmvXS96mmyCkZhOxUbTyjFP2EY5xrWK5klPmTRRFNc0WzdXEWTjbsy3KNvDvr66kh97fmFM0B8HmVtpptz2ouW0sDQ4OUH9fD0UjQ8JZPmOX3SnQmP6ewiqd/7wicuZnW6HCueFieQWeg2KAQw4DMiiq9vHHH4tCapju+fOf/zy1zU9+8hPatGlT2gJn34knnph3/w888EDa81Ac2kwqrU3X2q7DZW7VHPNyO3eNcJeXMvYFTnKf3U3N9npxi/tYX2zsSy0X++QoluqmnO26pfSXUuaco+9cAcJ5KeJNsoFYlznh94STfNhRR72uJnGL+3PCS4qOfZEJhaOjlrKcGy3fvUL75Gx8sTSaBXNkviAP5qOPPhr1GH5oIEvL6TRvLiQC3/fYYw8x9UgGP3JwH0HwaiB+IbNKa6WiJnBmoiZ0IpbF6ijF5GJE8/cHx9LigXZ6b6Bd3H4wOFasN5UineaIZcmkkAKySjJF8nxO82IjXiq9QnMhbQvWK7cHmOKTbXurUmntejW16UogcsMhDqc4HOOFAtH84m/uRjvsPMkyBTCVwjna+tffXU+LNvfkdJnLovn0XfaknXffj3aa/wVxO2vO3qPEcuXrGCIKGywYYyBEbTECFsuLB5mIELUPO+wwmj59Oh177LFCIMf0dxk4WCAMyAuEgk8++UQ40/PR2NiY9ty6OnP7JJXWphvdrhvpWkWOeamFxS2d1S0ai9iX2Bp6PfI5/Te6Stzifi2K5VoxO4qFxXLrU852vdxtuipGieZa+sZ6+881lrsOUXyPvndoQe+btFfvQnGL+0aK5XrWm1r4Uyt6++aGRipWp7u8YgRzNNJokPfcc08x1QaN5dq1a0XRh5/97Gd000030T/+8Q9TDxZF9u69915x4Vi6dCmdffbZwl6Pqs1WwSqxLGouc2UsS9Euc0tio/6kh3oSXnFrXOxLYWQtoFoAxc5WgGieKZzXgsvcqLbl1FNPTXOon3/++fTCCy/Qb3/7W+FQxJT9RYsWiWytSoLb9dKSTbjeZeex9IWJQUNeY8/2Jtp/94mGibLljAERsRf+IAWb28StITEsJRCOZVEcAxftE5tTi/JaW+znwzEs5gFHHKZ+ZuP3v/897bjjjqPyZNU455xzhEMPYgemj2K6qJlUc5tupsvcKrEsRjmOazX2pZKolc+aqfx23ZL99FIKgwaZTspWSNJk0DMPxEPUEusUtzaDXN/5RHEjRfNMis6b19pH5758RaB5OBKjg6g6ioD173//+/TYY4/RqlWrxI+ADz74gKZMmWLukRLRSSedRB0dHXT55ZeL4nqodgrRKrMQhRVAnIbRoqNasUZlwcZsGF78s8KASGGEiz0reYqAqhX/RCyLctBC7KY/omlGgLLwJ74PWmYf5AP7Uw7q1Jponq9tQccUBSZk9t13X5Gj9ctf/lJM3Z85cyY9/fTTokNbSXC7Xn4gnDbVu6lRQ80BLfjcjqxivdEia6EFMDvzDBrLLnMtIBc91DdcMjE83/uVhfCZO42jU744edT7fuL1VeJ4cT3AtoUUajVFLK8Qd7nWYs6FsnLlSrrtttuEAKEGigeh8BAyEfNx9dVX00EHHUQ+n49eeukl+uEPf0j9/f103nnnkVlwm17bxT+Z6oLd5YwV2vVyt+k5RfNSObrR92Nx03JANA/43TkFel9GzCVyzOuC27Ovy1IE1JR+PLvLy+4wl/nCF75Au+22m2igMcIJwagUHXAZODjXrFkjqi8vXLiQFixYQFbglfP2KdoZLLuAtRRrzLqPPCJntuKf1eMyry6KyTFXI/P7pRTbZRFedpn//qTKEn/NbFtee+01evDBB9O2R34tqjFje7g/jjrqKKpUuF03HzWhFYIp2t5Z7Q0F5ZargUiXXcZ6hWBrtsu8nE5n5KDf+c46evzZD6hjgzU6ifL53mvBNPrxYTNo/8mtYjliZrtYEJlz9pEzacLE4KhrblmxgFjeVu+ksQ2urAse11PMGYK2WtFN5YLZQUo2bNggIlrQtp911lmq+33qqadEwaHTTjst73tCEbb99tuP5s+fTxdffLFwAt54441UCqq1TdfqMs8VzaLHZa41lkVNmMwnZjK1ixZ3OYvl6txxxx2iuBvirdCuvP3225qeh4LLaPcz60icfvrpo64NuA5YkXK265btp1vRaa5TxHcFmwo7nirGTPd4Sb9v+I2k/J2Ueb+SCLSOfLdzLdim1gXzP/3pT6LQERppeUoOch8vuOAC4bqpdbKJ5oWgpVijMpal2OKfarBoXnyWuZZYFrUc80LROtiSTTSXqTWxvJbhdj0HwTGG7CabKxkxHcgch5BqJBBnIdhCNNdyHJUmmkMsv/W/q4RYrubQNuR4dIrIaWL5l6fRzq0jmZ2ZmfRCOP/iZCGaK5+nlVqPYtFazPmiiy4S7VmuBZnlMhs3bqQDDzxQzB665557csaxHH300QU56yAwrF+/XggOZlLtbboR0SzlJJ8QylQW/nF+shpGiOVjfMbExBkJnNWIB7niiivo3Xffpblz59Lhhx9OW7fmvl6vXr1a1KbIFqMFgVxZnBltqNWohnY9Fu4TURdFx11UgmhuACVxQVcBRojrhueYZ2K2UM7ucmsI5pgGBMcNsnpR6GHWrFn0m9/8hl599VV6/vnnxUXrzTffpFonn0ita18FOs3zFf/U6jK3MvnEfq1YdVCg2MKfhYrmGIT5zVdmmf7ajDXgdr18QChF1jgcyGaw54RmOmL+eFFQtBSiuR5ai4iR2hgeEmL5S68sLyjOxGiURTwPO2iWEMtntPqFUJ6tgKtwnc8fr/uaW8tRLHqLObe1tdHs2bNzLihmJjvLDzjgAFHYDAVAlfFbSjAFHm2jlmKfaixZsoSampoMjZCp1TZdi2hupsucYazqLjdCLLfqd/7mm28W7RuysyEe33XXXSLyCvUhspFIJOjb3/42XXXVVWmDpErQJiuLM6OdthLV2K7LwrlyqSrRvMaKfzJMNaNZMEdm1XvvvUc/+tGP0tbDjYMfARid/fKXv2zGMdYE2cRxtfW6XOb1LvIkhqg+ESYviutkFJxil7keJAp6ktTmS4pb3NeLMksdOeblJp/TnKluuF03H6MFahQN7A/1UU9Xh7jNV0QwEDRmcNEKzmeI5bf8e0QsN5Kg10Ztfru41fNZKt3h3zh2Dp2/3zQa7/dSxVBhYrkZyGL55MmTRW45clrRLmLJBKLMuHHj6Mgjj1SNaoEIL/O3v/1NuNER14Vc9DvvvJOuu+66UW2t0dRSm16saF4MhseySES+mIuCUQ/5k+5CupeMgqCtjtrs9eK20ig2iqVaxfJoNEqLFy8WhS5lMLiJ+7nEYtSSGDNmTM6BTsQuYhsI0XBud3VZayZXrbTrprjPzSJP3x5d895kHW1JNIhbuaterYU/zXaM4/QNeILU5xsjbktxicz6XbSam9tqx1OFaFbI/u///i+r68br9dKtt94qRkAZc0TNnkhUt8t8sLeTAkObyTYUIjslKGlzUG/CQ1vsrUSB+lQUCERzWbxVK5AJ0VxLtEipUR632YU/W7xJmtmcoBafRE47UTxJ1DVooxXdDuoasusq/pkLrYU/9YrcjZ6RwZTeSCzn94tF89qC2/XyAKEVcSzIGs/mQlajr7uT1q5aQX09XZRIxMnhcFKwqYUmT5tJwebRTvXZbT7y+z2jikuaUQBUK5MmBKnVp3/21CedIXrwrfX0zsJV4n42d7me99VSb6OZY53U0mAnp4MoniDq6k/Sii1x6hqQNF9bjj5wBp02d3zWgquWhMVywcsvvywEbSwTJ6ZHIykHozANHnUskHfrcIz+nBEPg5oWMi6XS2TtYro89jNjxoyUO9JMaq1Nh2hua1R3i+cDLvOu4Q2qLvMtgx2jRMTNg+YIOf6ohyYM+ikQ85BDstPkSIx6HEP0ubOHeuzlN1ZUEi12H+3oaKNWRz05yU5xSlJnYoA+TXRQV7Lw3wBGxbFocZeblVtuVbFcayHnzs5O4RbPjMPC/cx6FDL/+c9/6L777hOicjYgNn/ta1+jadOm0WeffUY///nPxaAoRHi1tr4c1Fq7LguVusXlUhYBzUFHzEPLh4PUGRlDcbKTk5LU6higWc4OarNbT0+xOiFvK21snk1hbysl7E5yJOPkH+qk8d3LKDDUmbf4Z1kLf5oNi+UlQfMv9WwNtZL999+/2ONhNIrmEDa7BuIpl3nHQCzlMkehUWckRC3hVeRMRinmqaOBmI0clKBAvJ+8yQittk+gUJaP3wzRvGKd6g0t1JLooD3GJ8jnlCgUJYoliFwOovYGiQJ1CVq8kbaL5irgvBnx/vG5qs0i0CKU5xPOCxmUKRetPifVKWZWZDKsvVmrebhdL4+7HNniyBhHbIoesXzph4spMjREvgY/OZ0uisdj1N2xhQb6Q7TTbnuMEs2x/yuP2YluCdQJobncESZyvrdeF7ZWsVwPEMv3mOoin9tGoWGJYkNELidRe9BOAa+LFq+OUS7pXS7YCrH87L0mkdnUena5WUAAx6KlrUR+utb9QIQpR+G4WmzT84nmcJkPOvWJ5lqAALmuQCMGXMTLuwaFWD4z1EyepJMGHTFK2GLkcNipbdAnnObvu7ewaK5DLN/TNYl8NheFksMUowS5yEHtDj8F7HW0KLbOFNG8VFEslSaWS30bSUpmv9ZL4aGRY5uUfv1EPjmiR4oFxZn/53/+h+69915qbc0efffNb34z9X8U1JwzZw7tsMMOwnV+8MEHkxWoxXa9YOG8lKI5+vgZfTOI5W/3t9FQ0kGBuhi5ImGKkYM2JwLUl6yjvd3rqJEqxEVvEbF8ZfveFHX5yBsNkTMRpbjDTb317TToDtCMzW+nRHOGsUTRT8YcCs0qzxbNgnk/3vBG8tkTFHE2UNLuIrLZKGFzUtTtJ5cUozHJzrSROKMywasPSTjLIZZ3DhFFEzaSyCZuw1GJGuuStNsYDFwgoqVwjCj8mfk9yhTLMx/LfLzQ7yHDMNrZYedJouijHrEcDlU4yyGWw1HudnvEDyjc4j7W43G1eBbkaZ/+hYklKwCaTVzG6+M4Co0s6Q2NiEZGif5wlkMs7+yXKBofme6JQJbBKFHAaxePK3MRlOdLFsvPPGankojlhsPucqbKyBfPojeapdAsc12xLBIJZznE8pAzQnF7kiQbidtu2zDVSU6aHm/ieBaNwFkOsbwzOUBRSojThtuwFKEmu5fmONOvgdVUDNZqYrkZhZwhesPxvWXLlrT1uI/c8UzgFkexz2OOOYacTqdY/vCHP9Czzz4r/o/H1UDOOV4Ls44Ya2DpqBZF3xBdcDjLIZa3OiPksSfJbiPy2BLUauunIclNy+Ntqk26K2it3HwrgPMEZznEcv9QB7kS0EokocO44oM0WBekDU2zynOJtIKz2wrHUEKuvfZaEUOFuhWNjfmvWbFYjC6++GIxEFpfX0/jx4+nU089lTZu3Kj7tVkwryC0Cpot7ii5omGKO7xCKAdeeao4hHO3j/zSIHkpu0irVozMii5xI4T+XO8r6B6JYYGzfEROIfI6JZroT9LkIDLNJZrVmqQDpsRFbIuIZUHWuTtObXUxcWvlXzssmjOMORgpSA+EQyKGBc5y27Y2PfU6NptYj8exndXer5zz3RgovK3uhIqtQSzX6sJGVjliWOAsB14X0cQmO01ucdCk5pEs89kT62hKMCHvmQKuOLXWRam92UXtE5uEWP61nUb/SLe8u5zFcqZKKVQ011MAtBAxMvvxuEQMC5zl27qX27ER9dti1JTwkl/iflk+kFWOGBY4y2W8NhdNdDTSFEeTeHy2awwd6N5BONGNyDrXE8eSz11uVpFPq4vlego5o0gzCjOj6KUyKgv399lnn1Hbo6bEhx9+KOJY5OXYY4+lAw88UPw/09kus379epFhjnoVjLXQLJqXSUjsS7ipM1ZHAUdMll9S4L7fNkSdiXoabDCu75gZNVJNDHqCIoYFznKczojTR13+ydQRnEpdgSk04GmkDa270NbgNLE9evRhV5C6PW3iVq/6EuvrGb3OqgM1NSaWy3UsTjzxRFFnQguDg4P07rvv0mWXXSZun3zySRGdiOuAXji7wGD++p096IT7F+fcppicaE3RLIk42ZIJkpxOqnPYaDgWT4nmQ9EEJchBbkqSk+IUCDSoZplXWp65WTnmbvtIZjliWGSxfLxfIpddokiCxAJz/9h6idzjE/RZt0RtTf3UUhcjp02iuGSjrmEXrYu7qCc2clHDMagNSGSjZyAiMun1kMtdriffnGEYY0GmuN4M71gsKjLLEcOiBtYPJsJiu6wzSlQE61JlmaO9a6p362qXZF5f20kP/2ctrVi6ybDjcTttIrMcMSwQy8c3OkTMViROlEgSOexEfp9Ec8cmRPvf5pOoNdgn2nRvIEFTpvrpkHH63wvDMDro7iDyTy5JPIvWaBYtWeYQMFeF5MG27YLnyp50k8rMoI8cPXYRw5JJg89FAwMxaiAXuSVHXuE2vClMtYzb5hCZ5YhhkcXy8Y4guchOESlOEYpTPblprN1Pe7qctDLeSWPsDSXLOi+GahbL9XLhhRfSaaedRnvuuSftvffedMstt9DAwACdccYZ4nG4BydMmEDXX3891dXV0a677pr2fNmVKK/v7++nq666SuR/w6UO1/nPfvYzUXPi8MMPL8M7ZPIBAdNyhTO3RbNEJLv43e+yKWad19UTDY/oJm7MeBFtkpOsZ0EsDRD4kSmuhbjDIzLLEcMCsby7YQIlHC5yJiJkTyYoYXfQsDtAq8bsLlIUQvVjaTgwRvzfIcUpONxFU8KfUmPEpN855crMr0GxHKCtBqgnpIVgMCjqFCm5/fbbxbVj7dq1NHmy9v4lO8xNEs21UoijN/M5owR4h5NcbifZkiNCeR2CWZUPU4LsyL8tcLxEr9PcaGd6pqvczDiZaNImCnxCTAEt3hGxfBDCimQjB6bPJknEtSCeZd9JcWr3RmgobqfuiFPctnujNDfYS02u0RcIrUVLjcDvdqUtmUDMOn5OaRyTDFPNZHNbz1swQ3d2OXC53KLAJzLL1cB6PI7t1EAsC7LDDzh0V83HapS7HGL5F/eaROfvlz+7PLMAqhliOYjGJVHgE5dGOM3RvsPEDrFcZihG1OBO0r4TY9Te6KDBuJ3CYl6Wk6i/m1Z+/C6FeissV5zd5Uyl0bV1ZCmT01xLNEuhLvOEXaKELSkKfaqB/O04SRS1pYvvzGiiUkKI3jhnoMVeL8TyQQkSukR2so2I4skBarR7aT/3VJFtPpiMUldyQNziPjLQlQ70crvLWSxP56STTqKbbrqJLr/8cpo3b55wir/wwgupQqAQQTZt0t5fQMTLBx98IByHO+64I5155pnCxY4im9mc7kz50eT6LbWo6G8hjy0pjBWxLG16lDCwlySPTXtGmBmFKSvFlQ5hHAU+Yw73SMFPh4vcsUFyJBPCcW6TiNzxIRp2N9DSiV+invp28sQHKRDpErddvrH0Scue1OspXQQlY20Q+4WZ2VoiXZSwYG4B0TxXxnQ2R142oR0uc8ldT8m6IPloeCRQS4HXZae65DANOuppiEYazEDAk1V8zuaEhghuxYgWo+mLOqgr0UABN5HHkSSva8RZPjJ/ViIk3QzGbBRJYERZoga3ROG4g6JJ+0jWedJOnREneR1x2snfRy3uYfI7IXrlnyjU019YEU6174yaQJ4pnB84iy8oDJMiOMbQ3WUTy30eR9qiRr0/ILLKB/vDo3LKcR/r8Ti2ywbEajNF82xRLLJY7pNjwfKI5UrRvHMgTmGNThQ99A1J1NWfpOZ6O3ndNuEsV+J2jrTrqFgh2vTY9jbd7q4jb7CJosNDtGH1CuoP9VJfdwcNhPtUM+TzYVTMTF5YLGcqGYuJ5vkESi1Z5jF3nDxBiXwJ1+guoUTUILmoxzFEYVtlFGQvJ33SsHCIo7inx+YUWeZwlstg3aAUFU5ziOoNdg+Fk5G0rHOI6Xgess4LjWnRSznEcgjlWsTyMd7shTLLybnnnktr1qyhSCRCCxcupAULFqQeQ6HOXO5DPPb000+n7nu9XnrxxRdp69atYro/Ms/vueeelADPWBcrRmUEHVFqdQ1TKOHKlF/E/bDkpVbHAAVtw4a65EstgEPEVy5GI9fY80X6yD/USf3eFhp2+YSALifd4PTGnR4hoCfJRhG3n+qiYXIno4TeOm4bhztpyOmlTxvn0PpogELOQNqldrivv/iDLfXATIW4y0OhUNqC9rrcDA8Pi0zzb33rWyL+Sw8cyWJBMgVP3FeLy1DGs6RFszS4qbNpAtljA+QaHskyr3M6KBqNkCsxTAM2N3W5x1CDt476+yMp0VxPNIvWiJZSieqZx6yX7O/DRiv66ijQOCCyzDE9H4K5wzYilseTNuoeshF0LogscJvDda7E60hSHcWorSEi8uWHkw7qtw3Rmkgj9SaM6ZDnmqmgJpbreZxhGOPb9mziONYPjozKpcBo+ORpM2mgf3uWOWJY4CyHWO7xesXjmfnm6ft1EoVJRKOoIYvmegTafM7yow+cQafNHZ9TLM90lZeKFVviNDZgF4PI4cRIFxpRLKIdTxD1x2w0pl4aadOx3uWi5lY/zZkcpPENdRQdjNGGVZ9Sb+cWstns5HA6yB9sofFTZ5CPf2zrBn0Yb464uiHurjKyaN4yRpdoni2ipZh4lkKjWdKwEfU1DpAz5KNAfCTLXHacQ0SP+OL0eaJndL65ChzLQiJOBYJ5q30kZgXiuINsQiyPSQkRtYL/e2wOSkhJcuB6qVBPEONSb3NTu8tPbfYGGqKYakyLke7ycojlWsAgUTg0pGlbhtFKrK+XYp4sM2oKKHpptXgWW6CFZsX7qC/ups64h/yOGLltSYq6/RQelshri9IsZ8eofHPlOVDL0bYSagI51hkiPmeA0zS+exn11o+lmMNLjkRMNNlJm0OI5biPfPPe+nayS3GS7Ggbt+tlEYeXhhz11B1sp966Vqq3R6gp1k3TBz+j5lh35X3Pyi2WNzQT5YsUdYzokpk1Iq644gq68sorR21+ySWX0A033JBzl0uXLhU1KYoBBUC/8Y1vCGPTnXfeqfv5/AvEYmRzlGvJmVaK5pI3SLExO5KjZwNJ/b1kiycomSQacgep39tOgxHjRiNlUTxTcLaiA72QHPOuiIsWb3TQbmMkaqqTRGY5RJT+6IhYPhS3kc81IqZjSj+iWmS8jgSN98XIZU+SJNmoP+6keNJOLd4hqrfH6JOhNopRumiOQYyGBmM+HxbDGaa0ZBOR9RS9VBPNg82ttNNue9DaVSuEaI7McsSwNLeNFWI5Hs9H47aBNQja2ZzNWnPNtYjlZ++lXlSrEPI5sXXNHOjbSl0DEi1ZF6NGn52g2YtOuETUH5Gouz9JNo97pE1PoF23UfPY7WJ5MjYsPoPI8BAF4OxvCIrBi96uLTQ4ECKva6+8n8eWfq4ZwTClEs71iuZqAuKWwY6cojnEynV5+peZWeYRb4xo8iANbhwpAGqXXJS0JanHPUQbfGHqCZUutq/Sgai9KLZOOMSbXF6RWY4Yln4pIh4bkmLks7lTmeUJhQVUZJ7bA+SyOSgpSRSShoXIjpgWiPDYr95s82ILfZZDLNcym4JhzCBTKNYqoOcUM8uQMd3mitDeDR20fDgoCoCGJZuIaWl3dAmxvM1e3jpwZrnRzRLNA0OdNG3LYuqvaxEiOX4Z2aQk1UX7hftcstkoaXeK6Bbkmm9L5aJhh5c6fOMpZneJ7etjYfI6k9TpGkv9/gDNCb+nKprje6h78KYU37Nyi+U6WbduXZqLO1vE1UUXXUSnn356zn1Nnz6djBDLMTPplVde0e0uByyYWwgtBdEy3eaZRUBlRAFQClK8LkB9PX1kT8ZFg9IZdYyUat72HAizxbrMrSyQG0WXo41eW4PGKi4KfCKzHDEssvUnkRwRzAdj8nogUXNdnJz2JEWSNnLbUQzETlHJTr0JJzU6IjTZ00ufUTC1H7NRc7VmCnMMwxgLYlAQh4Is8Vzuci2i+a5NLTQQDokCn8gsRwxLLme5kla/R8SjgJdeWZ5TNC8EiOXtE5vpxP2n0dd2yl8PIZu7HOsHM3NSTGBNV5KWb47TpGY79Q2NtOPyy3rcEjltRIMJm2i/ZeBOCPd2UzwaJZfbQ26Pl2x2u/i/0+WmcG+XGNTA56T1c8kGx7EwjDHCuV7RXM1lriaaZ5Ipmud1mW8TzZcH+8gXd5FLslPMlqRBRPfZRkTXLZ3ahFp2mY+I5q9GPxP/R4FPxKzAaS6TIGQM22kgORLPIiMyz20OEeOCWwjqckwLHOs7OtrozeQaXe5yo6NYWCxnalFA1yJeWsYBDPwt1BbuolbnVupLuEUhUGSbI67FVqDxQ4sYraeYZqEYFb+i91jH9K2mCV2fUJd/EnmjfSLDHIkJ6GFHHHWUxMyh+IBYRw6HMMAgtzxud5ErEaGk3SWKgLqlODXFu6jH2UKf+3agpj7tLvOyiuYVJpYDiNJahOm2tjaxmIUslq9YsYJeffVVamkp7PctZ5iXkUIKfqoJ68r9KAuAQjSHOB5sbqRYXZAS7voRsRzPadj+nGxuZq155lbBzOKfI9jpw61O6onYye+2iUgWZNy6HRIhbguO81hKLEfmuUQ+Z1IUDvXYJRpKjOTgjmCjgaSLmhwRqrcZd4FTfjcy3eW5IiC0CHgMU1MUIDKqCc2FiOUyattChG0IBKmppU3c6hVlZdH8G8fOSeWMG4Eslp995MyixPJS59MjmgWZ5phliE42TidiWUbadDvFtonl0eiIuBKPRYWzHNR5fUIol8Fn4a33U3cXMs1DWV8exUxff3c9dWyovE4ww1RqYVCI5tmyzdUyzbXkmRdSOFFNEJ3V6qNBV4z63BFxWyIPRdXyQXwT9UhD5Ld7yC2CWUjc+m0j2eVwj8t4aHvm+UjWeSwt/zyUHKZWh75M81zuchbLGUafcF5UTEmZxEb0JRudURrrGha3al11o0X+fO7xYtzlWsRyI/PM5RxzgFM3oXuZyDSPOX1Ce0FNoZjDQ8Miu7yfnMnt5tGo3UMRp0+I5XGHhzzxIXJDTN+2r/pEmHpczRR2BqyfmV+BYrlZoKgzCj3jNpFIiP9j6e/fPpiE6JannnoqJZZ//etfp0WLFtEjjzwinrN582axoGaFHlgwN5Hfn7QrNTeYE4mRSzRXQz6OpvrtjaVSNJdRFgBVw1zRXKIG5Es5hsStlsKYRqLFId81ZBfxLJv7beR1EjV7Sdxu7rfTG+uc1BuxU6snTm47XCwj1bI99iTFknbqiaWfb7jNHdiGkuK+7O435b3lEel2Hl85swOafU4xMJRtweMMYxWQGS5HoVgFZIojLgWieduEtqKEczwXy8ydxgmxfP/J6VEkcGSjIKayMKYWsTxzGy3HWIgzHtEsi1fHaHMfijrbqLneJm439zvojfVO6h0eadOdFCdJSopin9HIEDldLvI3No8asHA4XZSIJ8QMgEzgmn94yXq68x8raPN6A50tuWB3OVMr6BDOzRTNtRQA1YOeHGyjHND5gHhcqsKYxcSzbE6EyWd3U7O9Xtzi/n+jq6lXGhbOcYjoTptNxLSIrHNKUlcy3QUaowQ5yE5NbYGKEsu1FPfEd9k0sby7Y/vfpNqCxxlGI/lEc0sVAS1wlmahWe7FArUFBTG7XK2jCmNaBUSzzNj8NjUObKao00f93lZx29S/iWavf53qh3sp7G2jqN1NcbuT4jYnRR0ecibj1BjtShuDdkmoF+KkmM1tXXEb+2KxPI3LL7+c5s+fL/LQIZLj/1ggiMssX76c+vr6xP83bNhAzz77LK1fv57mzZtH48aNSy1vvPEG6YGVJZP5zVdm0c+eW25IHIvac9QyzdMKgCKaZSB9G4jmPQPp4qzWaBazaHQM0xRPr4gpgYicELElHt2FMbUcbyE55oKGFqL+LiGad22wUdAzUvgzmiDqi4zEs/QO22jmODe11MVEfrndJlF/3EFbh1wUd6R3ep3b3mfcVt5xq0oSyxnGqmgRawuZyaEWzVIscuQJRPOxDS564vVVtHm9/qxwWcSGWP7jw2bQzq3pgkKot4s2rl5J4b4uISLLhTF3mDlLU+Z6a44ikNnQmsEuZ5nLonnX5zEKem3kdtooGpeozx3Y1qYnacdxbhrrHKT1GzvI0eQhl8crjt9TN1qsSMRj4n0iLieTwWiClm/u1ySWGxbHwjC1hoaolmwRLYXGs+TLM8+MZsnMMpfF1OVd6n1TPdEsZtJi94l4Ejiu5SxwtcKYVgDHgxiVYLyO3DYHRaUE9Ukjvw96paHU+6jDO7Fh1meUtib7Rda5Ehc5RJRL1GZefKEZYnk+2FXOVFtMS9ZolmxxGehnFSFu6wbHYLIIKrvIlZEnuZzl3a5mEU8CxzVEZESXZBbG1OMcNyvLXBbN/Rv+Q4OeoHCOOxMR4TqHAtMQ6aGNzbNpODBG5JdLNjvVxQapJbKV6uLp16aYbSSixSXpcxmXLJqFhXJVHnzwQbHkAqYsmalTp6bdLwYWzC2OHKsRjuYvEKbMM1eK5kqXeXdGoTG4zHv6czcYheSZ66HJFaGdvf1UZ4+LmJJ40iXE5Bbn9sKYekRzU9kmmkNIGRHJR2edd22VKOhOCJf5Lk2D1OhO0FDCTq60fq8k3ltn3EsDDuMLcCjjWNREOi+UfoZhTBXIjz9udxF/ghgUq8UeyaI54lMgTP/3sxGxp2cgqss9D7662xhVsXzlx+8KRzZiSpz1LlEYM9zTQUs/7BcFTPOJ5nCrd+4fpydeJ12O7EJEc4BoltTMJvdI+44B0rc6/BToTVBjn4dmz5lMh44dpMTwiFte6TDH/aGBMDW2jhXZ8iUpYpoLdpdr4thjjxXTOrdu3UpNTU10yCGH0A033EDjx48Xj7/22mv0u9/9jt5++20KhUI0c+ZM+ulPf0rf/va3c+5XLS7pT3/6E33zm9807b1UE9LmLqIZ6rnjRgjnstM8UzjXKpoXi17RXCtmZZlDLN/TNUnElyCmBM5riMnFFMYsBUIkl3KL6bs626nR7h0llgO8t576KIVtUVPc5aUWy1koZyqdggozFktw7Pb/923Jvz1+I2joh0Lg1+KO1ytEa4lfgVj+gX8+Ddu91JAIk1OKUdzmylsY04hj1ZJjjliWUDi93RWRKpG+0dsOddKE0NvUPxQULvPPGnelfk+QPBliOS4FAw4/tca2kD+O6MQGzd8vzVn5suCtVzhnodyysGBuYZSiZzbhXEsR0GJd5moYJ5pLtEP9iFgOR7kc3BiTHNSbsKcKY/YO4kJlK0ksy2C4WCHDRn3RkT+tD7tttEdbv5jSP2RziGgWlx3FPxI0nHTS2kgjka90YZUslDNMaVCK5cVihst8ZL/OlDC9Z3v2Hx+9KoWlgRw1g4gXJRCO4SyHWO5v3F78Ennf3ro66uvRXhhTzkOHaP7ZJwOmi+ZZ9kahmJMSsTr6bEuc5k9qp2kUFQU+MRgwEsMSE2K5u85L46fMUH1fq0MDYkAin1jO7vLScuCBB9LPf/5zMU0TUzh/8pOfiNxDecombufMmUMXX3wxjR07lv7+97/TqaeeSsFgkI4++uic+37ggQfoiCOOSN1vbLRIYbIKQdqU/gPSNq6tMOFcp9tci2herMtcL+UuAApHNsRyFMKUUSuMWUnIYjoyzzEYgPehHAyAWB73En3u7Mn7E6QUYnmxeeV6xPLmupEBQ4axIkWLmoWK5fJ9LaJ5geB9FZXbrgEIx3CWQyxHIUy5eXNL0bTCmOPIBBe2SeA9+GMjYrqj9wP6pGVP6q1rpfpoiJzJGEVsbiGW1yUHhYMe20PYNzJ7vSDhnIVyy8OCuUXJLNioXJ9PNM8VzZLPZa4nmmW0aC6R3zmS343iluE4vl65e5jYvskdpYHkdrF8O9sLYzbYo9QvtilzLEuayzw/XREXLe5ooJnBYRrrT1K9M0EJyUad8XohlsM5X2wgSq78equ5Whmm2pBjSZQiKHLBZ7U3pMRyq/8dZssUh/A92B+i+liUnC43+RoCmoqM4jmIYYGYrNze5RiJn/I1+IVojsKYKFyaDzjg/QUMPMizAPIK0IoioJr26wvSjB123x43M9AvYljgLIdYHmhsEe59+bzi/4hj6RyMUm/I/IgzAbvLNXPBBRek/j9lyhS65JJL6LjjjhMFg1wulxDTlZx//vn00ksv0ZNPPplXMIdA3t6evwguY7KArsFtriaaA6VwbrRobpbLPJdojtzxzIiSfOA5iC+BmKxGqjBmvE7zPq2YeS7HtCCzHDEscJZDLO+xD1taLDdSKJdz+0NR680WYCofrS5pLSKmLtG80KiMTLFcj2iu5jI3IZYF4jcKWCKTGzEjcE7n66lje8SwwFk+Wn3ZXhgzlGigYLLfUi5zLTRGumjnrkW0xr8j9dW10KDNSW5HUjjLlXEzJYEF8YqHBfMKJJ9orjWaRekyLySaRSk8I1YFTnGI3yh0GZds1BN102cDDdQTyy50jBTHlGhYUs/xFoUx7TFy2UYKY5YCTS5ziOZAKZzL61RE866tThob86QGExLekXzcYsBnqycHn93lDGNOHAvaQbktNCtqwyyXeWZES7788fFTRwThXMRjUfEcxLCo4XS6aDARVi2MqUarz50anCjk/GoWznWAc+Cf2ywGB+J5BhQglsNdjtibFUs3GXYMtQgiUZR4PB6xGEV3dzc98sgjtO+++wqxPBsoKrTTTjvl3d8555xD3/3ud2n69On0gx/8gM444wxNg06MfgFdk3ieQzjXmmterGieiR7RvJgs82LyxyGw4zlwXqshF8bEdpasGFdg5nmy0WV5Z7lRYrlagVuGMZJIaIDc2+Lu8qEUW3OJ52WJZzHYaV5MLIuWDHI1IK5je8SwqB6TFKNhdyNFh/TX2DMaLaI5tlETzYORN6nfFaSY3U0BH2kaTMiFKTMYGMtT3mqDNVT40wh3eb5tlIKpmusYLvNMIJpnApe5DFzm+RjfaKe5wV5q80RoOO6gnqhL3OI+1kNMzwbEY4jryCxXQy6MGcsiqOcS9/MBgatoIJLLS05sFI67qCvqEbdmxsto+f7IMQrTWi2SDV9BQFBBdm0gEBDuwTPPPFNUa87Hm2++SQcddBDV19eL5+6///40NDRUkmNmzAECLtqRQLCOJkwMiuKX8xbMoKMPnJGKErG6u1wNOX+8t2sLuT1e8gebxC3uYz0ezwXEYwjsyCzPdJcDrHc4nKqFMfM532VHv1m587r2Z7NRvT9IweY2casqlkfiItLmmQ+30kuvLC9NHEsFustbvG4xMJJtweNg0qRJIgpFXq6//npDXh9xK2ibW1paaO3atfTMM89k3fbxxx+nd955R4jfubj66qvFti+//DKdcMIJ9MMf/pBuu+02Q46XURfP5UWTcC6L58p99G5IZZuruc2ziYuZomQuETNXNrUWcgm0ai5zZf448sYHk1HqSg6IW9zHejyeC4jHENgRU6JGqjCmZN6gbqmAQ74jOUDJ9vxieS7MFsvxHcv1PcN3UotYju8yi+WMlYFInMutrBZfoipAqzl9i+1zZXOgF4mWQQA5gxyZ497EMDXGesQt7mM9Hs+6fykqxHVklqsxUhgzQW7KX0MvG0ZGnagJ4npiWpojHRTQIZabHYlTkQTGjHzfcy3YpgphwdyiormRwmimE1l2mWcCl7l+IVqiKZ5egsbeHXVRVLKTRDZxi/teR4Km1+Mip245QWwLnOgogDl6m5HCmD0JD/UnC2soGXV3OcTysYHyjxpXIhDLP/74YyGCIMv29ddfp+9973t5xXLk2B522GGicBzElnPPPZfsdm6CKxmI5RDK5biQxkAdnfLFyXTRF6cJsddosdxs8R3HnJk/jtxxm90ubnEf6zeuWZmz8jic1nCjI9M7c7uRmJcwBZta8hbGlI9JPrdGANHcaOE8G3IUyzPLOjWJ5Ux+1q1bJ9zd8nLppZeqbodYFQxg5FqWLVuW2h5FPN977z0RteJwOERGudp3/NVXXxVC+b333vv/23sPOEnqOu//0zlN9+Sd2ZwDGdxliQoIJ/iIgOlBz0dAeVARlIzIkYyIcMCJHKgnQcVDPUHC3fHAkfwjLNEFYQO7y8bZNLFz7v6/vr/emq2pqequ6ljd832/XrW9XVVdXdPd85vqd33r88VBBx1UdF+vv/56HHfccTjiiCOEkL/66qtx6623VuFVYEphSJyrPb4K0ryY9FTKUTWJqiVcDUvzfv+E/HHKHc/L8sdpPi0vJZGpGp0yvdWg+bS8GeNYip1oKIWR96HasrzofrEoZ1oQI00v60oxaa52vFlONIxCQiszyCl7nAyMlEFO82m51pE6VVpTJXrE5lexL0Dc04nu7CgCZcSxqO1vJc1JS0nzcmV6uei5GoBpLTiSpYFQbEqx/Oly4lm0olmq2QBUHs1C2eLUmJOyxh0uG9ITstQtiGRs6HKmRFZ5obJaiQU70YuO3OD4diiGhSrLSZaPN8Yso8xDT5Z5bZt/NpZmrGw1O2vXrsVTTz0lhPeKFSvEPKoY/F//63/htttuw4wZMzQzcr/1rW8JiSOxdGn1T6IxjUGSufP7/FjU6Wvq3798KqaaP07QfZpPzS5FtrlfPX+c1qPollg0JNb1B9qRszhEZTnJcpfHgznzF+uOpjiwJ4CjF3Zh+0AQu3eMTKgyL1dC620KKpfrdILk0CW9OHpW6dx1gmT5v/x1s5DleuBmn6Whq3NoKsUVV1yB8847r+g6FJMi0dPTI6YlS5aIqBWqZF+1ahWOOeaY8XVefPFFfPKTn8Qdd9whhLpRjjrqKHz/+99HMpmsaowMU2Fki0ZMi55moMXiWcySZ+7PO9Hv60AoFq0of5yiW0iMqzXGjOXTYnkrUA1Zrnayox6yXK8oZ5hmRatJo1o0S13jMyqMZ9Eby2I0g5zWo8pqqKxDsS0Rf0A0+KT1KYaFKsupMaYvF8ei9NYaXg9fHvWW4wxDcHljA1Bmile70lwty7qcKnM90SyULW6z5ITkFvcVz53OWWGz5EV2txbU+HJNvBfDGQ/clizabUlxO5TxiPm0vFYUi2UhaV6956netiqFqsunStatfCJJUSlUKU4xLJIsJ0455RRRKf7qq6+qPmbv3r1i2bRp00Qubl9fH0444QS89NJLFe8P03jUKp9rKctrLeLTUv64Xf0KFJvdIZZTbnepjO9FB30IHd19SCbiCAVHxG1Xbx8OOGQ52rt6DO0XRdxc+PHFIvZGDslzPVOl1ebUyPX4I2fj3BUz0aHzRPdTmwbxzvsFiVS36vImjGOpBb29vVi2bFnRyelUfx9zucLxivxvxgsvvIBPfOITuOWWW0peUaTF6tWr0dnZybLcrFXnOiNajFSaK+VmNSvN9VY3O/OUP26BReV7wKT8cR2NMXdnw/Baneiy+sQt3af5pXLQmwEzyHL6jKjJcj0RLKVgWc60ckSLrhiNRjRgLLPKXCuWhU4Y6Mkgp+W0nhaUcX5o+G+iEWbC5saYo1PcTreO4kPJ99Cdq04ldTWrzM0CV5lPLbjCvIUbgWo1ANVbZa6nepuyxbP7KsLTedu4NJcqzR1WyiC3iKzyYpAUH4v1iYp1kvC03UIMS2XnNiupMmfMCckqbxFh5Urvz7qVc+ONN+Kmm26q6Ll3794txLccu92Orq4usUyNDz74QNzSc1MV+uGHH45f//rXOPnkk/Huu+9i8eLFFe0T0zgou1xOX5tDt0w1K5Qr7nQWqsEphkVJlvLH7TaRU663MSZVrZOIp21TDIvRpodSQ9KPzOlBz8eceCDgxljI+Lg+sCMoGrMqBbZWtblcplP0znELOwrjj8GTjhzFYl7oZCZdMXT88ccLmb1p0yYRpbJw4cLx6nKKYTn99NNxySWXiCxyaawn4U5jP/Hoo4+KeBgp5uWJJ57Anj17cPTRR8PtdosIrx/96Ee48sorG/jTNhe5HSPIeUpHx1nnGItYkqS5asW5zmrzalaaV4KeJqApC+WP5+GAFckK88fVGmNyDEt1ZbkajRDlyhNDRsnvHkbep32ckI/qa/rNtC6xcLIiiapWba6sNNdVZU7Hf9WI6qtSE1A9yDPIKYZFPYM8I9YrBknzzuCIqEQnuU7r9/pyda8sp/e72OehEZRqKMsNQKcOLMxNAsWoSJXhJL715pNroTeaharMRyIKed7mxGgkpSuaJRLOYyzrQrc9jrEsSXGLTJqn0GbPYm+SGl3adVR4WxDJ1f8sI+2DJFFaMZplKlaXS1m38kv3i1X1UVQKVQ6WimMpB6la8Wtf+9p4kzjKtH322Wdx3333Va1pHdNYOot8MaxFlXksWZvmaiS0KV98ZHCPkOJyuU2ZzpRL3tHTJ3LKdTfGDOiLMNEjzSme5byjZ5W1jXWDMfzxL5vHY12U0ryaY+jOcBzrd0fEc+mB41gag9frxSOPPCJOqEajUUyfPl30m7juuuvG/2Y8+OCDiMViYqyWj9d0pRBVnhOUp75+/f7oHYfDgbvvvlvEcdHvzaJFi3D77bfjggsuaMBP2drktg2XJdFLivMKpbkcpTSXU2k0SylpHrakMGqLozfrRcqXQ0pRHEORKlQlbkR8i3W121g0Hc0oy2shyuWSfHKIA8NUjl4pKl+vmDzXimhpGFrSnI4xSxznGYllIalNGeTU4JMyy+WCm4ZmilWhynHKKi8FPVaKbanVa0nbNWsGvek+Q4zpYGFeR646cQFufaFQbVpujrl0Ob6aLNGqMpcjVZnLkaS5vMpcLs3lTJbmHmyNdYi8cWUGeYc3h0jShg+iNAg1LgWrVavM6X1Ui9op1fCTmAoNP/Vm3RrJu+3v7xcRK3IymQxGRkbEMjVIwBAHHnjghPmUk7tt2zZd+8c0hyxf1utFTxNeWqgU3JQvHo0U8scps7wQw5IWstzp9mDG3EWGq8SrgVyalwM9rsdnx29fKvzehcNJbFqzveTjtCJdisnyO1/cjNdf3czV5SbnkEMOwXPPPVd0nQceeEBMxaC/H/K/ISTdaWIaL9FLyXNNca5SbW5EmsurzJXSvNp55kWluQX4wD4Kf86JrrwbEZ8N0WisJfPHzS7LjeSVV1JVXokoZ5haEYsk4XcYP3aU5LmWOFcKz5JV5hTLUkHjzapB+1AiIoZ+DrWomVIZ5O5cTCw38mo3Whqbscq8FFxlPjXgDPMGSPNyc8zl2bVaObbyynR5lrmalKcqcyUkzZXIs8yNZpC/n5mOpLvTcH54val+lnke7c4Met1pcWumUpypIMtrlXdLl+iPjY3hzTffHH8syRaqIqeGbmrMmzdPNAOVVx8S77//PubOnVvzn42pbh60WiVyR5tLZFuvmNnVtM0+5VC+OOWM9/ZNRyoZRyQ4Km6pspxyySlqRWpqSXK41LRxKCxEd7WkuTSVA8W6XPqxRfg/x88Rmegn/sPBRYW4fFm3x4FoOIjgyKC4pcphJfSaPLZuSMhyvXB1OcPUVp5LUzE0880V2eZGMs2VYlMuQauZZ16KUWsCbzv3YNAWgztvR5+3veXyx8vB3+8XJxK6sx5xq3WoXitZXiyvXHU/vL1FZTl99vTKcvrcShPDNAMkU/UKVV155rWsMq8DM7wp1Qxyun9oeLWIWzET9RDyNISHHe0YcfWK20rti57PEeeZ14cf/vCHohccXRlK/eT0EIlEcPHFF2PWrFnweDyiePHee+81/NxcYW6SSvNaXZYvj2bRU2VebjTLWBhFM8gbLceNVZnn4bdnRKNSyl6nOBkj0SzdrjQWtyfQ7U7DbskDdgdGUxlsirZhNN3Y6lOW5ZVBVeFUNUiX1dOAm06nxUD8+c9/XkhxYmBgQOSTU075ypUrRSXuVVddJS75P+yww0SGOV3iT1m3//Ef/9HoH4kpE7lIPajPgxl+T11leS1jWSRpfnBnN4aGR0SDT4pnoRgWqbKcxPC//HUzRnXmkJ5+6DQhqwv7Xp1DD+V2tKQ8ie1YJDT+cxzQHYClp/BzLOr04UGfE08/VzihJa8Il95j+vu1YrYLuW1rsCYyKpqeUo67v70bM+YtGj+BoISryxnGXEjSXKvqvGi1uaLSXKy3r9rcSKW5nFJ55kYqzUtFs5A0f9OxC367UzQCTbmy2LmnuU/WtVvKy1KnqvLOnBsL0p3ozHpEU1TKeafoGqrGp9eqHrK8WvErRiQ5wzQ7JM2V1ealYjVKVplXK8e8GGXGsmhVmWtlkFMMi9E6/npVlxeLZiG5nensRSgGOHIptKWDhn6OMVc3tvqXIOjuFg1PKcO9PTGMueH30ZGs7d86rjSvPalUCp/73OdE8eKvfvUrXY+5/PLLRWHjb3/7W1HA+PTTT+Mb3/iGcDZnnHGG7udmYW6CSA0plqWcHHM1aaKnAahENRqAyoV0IzLIqwVJEVdiFAt9EXQ6U0J2Z/IWjKacQnZDhzQnWb68NwKvLYdQ2oZ0zgIvbOh1JdFmz+DtYEfVpXmpWJ94Kqsay8KUx0MPPSQkOUlxq9UqmsD99Kc/HV9OEp2qySnzVuLSSy9FIpEQebYU30LinJrAUWM5prmpZ3Z5vSE53tvTPUlEU9X4g28MjEtmNTmsrNrePhDE0EcyOHpWOxAu/rzyxqlGIm6kyBY5obFh7NyyEeHgsKropueiqwMI+nmU+90/qwufXdGF+YltiI7FRUSN3Vdoijo2vAexaGhC1T0xtu/kMsMwzRnZoirOS0S06JXmxZqAKqNZqt4E1FLINJeL4/CuEgOyCem2erHE1osemw92WJFBDkPZqIiWKVUtL8nyw1J9oto+YkkhjZxoiko571RpTtX4JM3NLstZlDNTFT3SvFTTxpqitwGojlgWPQJayiAvdxuNZsTRhQ+8CzHq6EK200521JDsJlm+pnsFEnYPfKkQ7Lk0MlYHhr19iDoD+FDiHXhrXHHP0ry2fPe73xW3pSIS5bz88ss499xzceKJJ4r7X/3qV/Hzn/8cr732WmsKcyrD/8///E+sXr1aRCNQLMJUg8R4ORWM9agybwZKVZl32BJY0j4Gjy2LSNqOdN4ChyU/QXYXl+Z5UVlOsnwoSb9ahfOiqbwVIykHupxpLPBF8OZYbQSb/IQLUzu6urrwu9/9TnM5ncFUi2qgxqI0MQV4TDd/lbkaa4ZCeGDVjpL53MpKbWp++asnElh1YJ+hkxAkswvV+3bD0pxk+cb33kIqUUp0O3HJcfNFtM5f3toxYXuf/fA8HJTahrFEHP6O7vEKe4fTJarVKed959aN8Ld3NSTXnWFadVxPbw0iXeYxjWN+e1Wqzkmc66k2r1Sa17MJqJJmk+Yky1c4ZsNrcSCUSyCNrMhj77f5RSa7VsTMeFZ5HliQ6RSyfMSSGG+xlEIOI0iInHdavmN6UPX5tWJxqi3LWZSrQ82Ub731VuzevVsUn9x1113iak41qKHzj370I2zcuFEUsyxevFj0LPrSl740vg4dr9MVoL/85S/FeHXcccfhnnvuEesytT1WD4X1XaEY8DurUmluCqFZgypzMzfU1LO/JMvf8R+BhNWDtmwY9vxE2X3g8BtFpTl946bKcpLlHYmh8ap0Zy4FR2IIY+4eIeOpEr+co3QjJ15M8RkzAaHQxBM4LpdLTPWGIlwef/xxfOUrXxFV5S+88IKIxL3jjjsMbcfeymX4Zo9lue/1bVWRno2qMleLZjF7c03tfcxjrmsMbXZgMOaQyW7LJNmtFc/S7syKGBaqLJce7xi/SsCCSMaGLmdKxL3UUnFJVycoT7DM73HX8FkZZmqP6a0Mxa+MJVPYOBoVDTNXv7rR0OMleU63LwxMrKQplh9OV/1Q5Mt5R88SDTuNSPNoIi0qy1M6RLfXaRM/47mHzUBf2/6/v9Qg9MA2Kzb/vdD8VCnE6T7Np21R5IvP344toajumBqC88sLtLsc8BU59nGk+WRwM2CWcT29OWhYomuJc81q8ypK87o2AW1yaU6V5STLh3L7j8NTyIr7PVafWP5KbqtmY09/3iliWKiyfJI9sQARpDHD0YaRTAwxR7osWV6rqnI9orxSSS7FDeXDcZiN3//+9+ISe4pEpL5Bd955J0499VRxVee0aft/H+UFLv/0T/803ofoySefxJe//GWxLj2O+MlPfiKuEqWoxPnz5+P6668Xy9asWQO3m7831WJM1yvKleuriXM1aa5bdtY6lqVOVeaVSPNGVZdL+0uym2Q2yfLOzPB+2Z1PoSMZE7KbZHh78hVN2R1xtIsYFqosVxnSxfxRT5eIramkEl8v0smOlhPngV7AV2JMtBUc2+zZsyfMppOSN910E+oNnVClqnLKMLfb7SIZgE6OfuQjH2lNYV5OGb7Z+cqRc0SWuTyWRY7eWBY9lYa1qDJXoxmkuRqUvd5hSyKac8DhsiE94bWaKLvDGYeqNHda8yLGhWJYJsryAumcFT57VmSj6z0MpdddvP7RpGpDVr2wLGfMRrOP6SRz/QbiQpq1yvy3q3dg/e6IkMAUq7Jpzfaqbr9YlEssHBtvnmlUmudTMRHDold0S9L8tIUTRUU6MiKiXKg6XQ2b3YFsNCLy0fVW3zNMq2LmcV0u0YvJcxLnuqrNDUhzOWaW5oSZxTllllMMC1WWq0HzaXl7xi0yzeWiXILy2ymznGJYlLR5HaDWQ9aMFY68te4RLI0Q5comtmbm9ttvFz2ESHoTJM6p+vm+++5TvYJTugxf4pJLLhFi/KWXXhJSnKrLSbpfd911OPPMM8U61H+or68Pf/7zn0V/oqlOtcd0o7JcjzhXSvOqVpmT8K5TE89KMSrNqyHLpZMR5TZZJYlNMSxUWa6U3U6XXchukuEkxf1p9at+0lanyCynGBY1aH7SYhcZ7/VkKlebb9++HYFAYPy+VnU5jdu33HJL0W2tXbtWnPQsV5ivWrVKVJnPnTsXf/nLX3DRRReJavNTTjml9YR5OSSTSTFpXR5gVopVmRuJZWlElXkzSHO1/aNGpTZLDplc4XV3uBwTpLlcdkuQNCckcZ7KWUTmucOaR94+eVB2WHPI5i2webxQOU7XBZ3MoJMaDDMVaciYHtwLtE+bJHVnzmrH/OkBEePR4229HHOKNbnn9e148vmNQlzXSwCrCXS5NF8xs0vXdtLpFJDPwW4vLbolJGlOt+P743CK3HOKcqHqdCXZTFosH07l8MAbBVneUOizSp9ZhmkSGjGul5LnxarNy5Hm8ipzJcWkuRKj0rwczFxtTg0+KbOcYljUoPk2WNHZG0DOpj72pyxZ0eCTMssphkUuywlb3oqcJYe0JVcTWV5NUV6OJDebINd76T5VOr/55pv4zne+Mz6PqgVJerzyyisln4fkODV/o2p0SdBs3rxZRLvIxUl7e7uoXqdtsjCv7pgejqTQZq88uo7EuRFp3tAs8zrFshiR5tUU5ZWIc9qP4dg+2Z1Xl90eRx4x2IUU19yXXEo0+KQYF4phmfxEHrGcGqKWS7mfIfl7OJXkeSAQmCDMtaCIrPPOO6/oOgsWLChrH+LxOK699lo8+uij+MQnPiHmHXrooSJe6rbbbjMkzCeePm8xbr75ZvGHT5qUlweYBanKWymxCTXhrUUpka4m4anKXImakKUqZwmqMm92SJrLSeetyOatsMsOkNVkdyo3+VeGxDlNaVcA4bwXnV46GFBmWOfRZs9iJOVEJFdarhWr4iekkxvKKwSmyqX7HUUmWs60JmYZ06kRZEdg/xhCnzu9lc+1oJzeFsVE+VA4KWT5Hx5/p66yXA3pucdChZOcyqaeWjhIdNvsQnSrIYluimeRI5fl4n5bQDQJjUfDk3oT0H2aT5EvLu/kSsaGoTjBwzBmptHjOslztQgXSZzLG4RK0lyKaRmX5lJDUIWQlAtNufwslk8tF6xqAtYIxZpWFkOtMtsMpPIku6lBp/rr4vN5YXHbhBTXgpqejtriaMs7xw/VJVlO971ZB0KOJGL2dEWynN7HWsly+lwZkeX0mZSmepHbMTL++6M67Sg04KPfd/nvP40HagwNDSGbzYrqbzl0n6S3FsFgEG1tbSKShaQJVRz+wz/8g1gmPc7oNpnGj+lqleokzbWQi9wJIrrCKJSS6K1Ol0fDVAiJaGlSm18pxcQxLTMiltva7AXZbVH/7p62OOC054QU19xGOigahFLe+WT7AkRtfnSmR+CvQxxLMehzJ01Mgd7eXlE9XmyisbscqG8FTXRiVY7NZkMuZ6xytaHCnMrw6dLoYtO6devK3j6dhaY/lNJElweYMctcTVor41PkGLn8XivSRRn/IlWZT1pPRwwIVZmXEtJmRL6PJLHHsi74rPS658erzJWyO5wpJsUs2BRtQzxL8S1pOK1ZWJAXt3Sf5n8QpT9U1W8MJ51skT438hMtB87QzghmmGoy1cZ0qi4/c1kPFvWYUy4YgUQ0TTvDcfzLXzcLWU6y2gzRItI+DMVSuqW5zx9Ae2c3UvFoUdFNQlwOVZjLJ/rMzpi3CE63R0S4pFNJcaBFt3Sf5s+YuwjB1P59MsNrxtKcafVxPbYlqDnVQpwrmSDNiQqkuVaWtZqIVZO1WtnarSbNKWZlKBsVzT3lONtccPpcaMs7hAwnKa6JBfjAPoqEJYMZzjZ0uF0ihsWesyKQcSFpy2DAG8bSHq8uWU7vj5osl0Pvr/I9pvdfTZbTZ0RLlusV5XJBbraKciX0+y7//ZdXkFcDv98vKgpff/110cCSMtCp8dtUxoxj+mDSojmVG+9SViPMevWV0ZGVrlaRbLTKWUuel4ve59e7XiAXETI7YvMXld3T3AnNrHr6hMwNvw93Ji4yz1NWJ3KwiNuIrw/uXAwLYpuK2hc9n5VyY2dKyXMW6frYtm2bGMvplk6e0v9pikT2v3ck2KminKAK9xNOOAFXXXWVGPPpiiKKlqLYrU996lMwQkMjWWpZht/IjqzlZJlLDUCbNcu8GaNZJmLB1mSHEOZSlnkmb4XXbYU7l9Atu0fTLrwd7MBCXwSdzpSIcaHK9L1Jl3g8LffW8VwCy3KmnkyVMX33jhGRX37QodPGZXk1q7zrzRsDI3hxnyjavCdsygxuajQapuqhjwMfmdNTcn36wjdn/mJEIyHEQqNwenyFGJZMWshySXTL883pZMGDb0yUC2ceMg0dLi9mLTkcIwMfiFx0inKh6vSOnj6xjUBHNzBkwsg3jmdhWmBcL0eAaz3GO694409CkubKqBa1mJZiES164lnMmmdu5lzz97ODQphTg8+EJy9iWBx5m5DlJMFJhpeqSxm1JrBjWgj5WB6BtAvWvEPEsIw640KWz5huq3sES6mK8lKYXYxXeul+T0+PqAzcs2diE0W639/fr/k4qi5ctGiR+P/hhx8u8nCpApryzaXH0TamT58+YZu0bqvS6DFdopgMV1uv15UvGc9Sqgmoruaf1UZv80+d6IlmqQVGZb2e/aR39gDrLryeC2DU3g1fNgxHPi0qy0mWK2U3vbdqVxJ0JIdx4PAbokEoZZ7HLHZRmd6T3iMe35UuXNFidopJ86kU6aLGDTfcIHpQSBxxxBHi9vnnnx/vV0GRW3SSTuLhhx8WJ/C++MUvYmRkROSY04nTr3/962gaYU5l+DQx+6M15A1A5VnmSmneqCxzIw1AmwG51B/LurEm3ou5rjEhzW3WtIhpGUUb1gddQnbrgdZ7Y8wpGoRS5jnFuBQq06tfWc4wZmIqjekDO4IYihaqshsZx1Jp80+S5Xc+vREb1u4S942K8ryOahyLjkoavScq7vnvDUKan7ZY+wuyRHtXDw44ZDm2bd6A4Ogw4mqiex/yhp1yqNnp6XRipLMNsw9YDqSiIvecolyoOp2EO1WiS5jtRANTmjPOOENUqezduxednZ0i15AybqkpEHHTTTeNNz6T4/V6EY1qv9/KZrPEv//7vzddLm6jxvX41hDszuqOrUqRXkygFxPnU0mamy3XfDgXw9qOESzIdKIz60EbHCKTfNAWE7KcZHgxpIr7MJJY50jCm3GIBp+UWU4xLFRZXm4EixK1qvJqivJmleTlQJflL1++HM8++yzOOussMY+u9qL7F198se7t0GOkfO358+cLaU7bkAQ55W2/+uqruPDCC9GqmOFYXa8s1yPOi0lzrSxzQw0Z69X4k6R9rSNiyqTcDHg90rw7N4YjreuxNj1dNACNWtpETIuW7JbeW6U4J2nennxFNAi1+9tEZjnFsFTTvjQyD39Spv0UE+gPPPBAyebDyiuKaXy///77K37uxn/L1wmV39OZAXkZPkFnjSmbbCpiRJqXQm+VeTGatcpcKc3HYn1os6ZEI1DKNheZ424LkDbyRcOCcKa6Wdp00oJOXkiNP+nEBp3goPdN60QLw5iVphrTZY0/SRCTIvOqfDluNkRe+b6YE6OyV48oV65bqTin/du9AwVpDv3S/ODObkTDIYSjsQmiu5QsJ2ge5adTg1cphqcA/c3YX1X+tw2D4ycdmObipJNOEo2BqMJwYGAAV155JT772c/i5ZdfFsvpvrIa5eSTT8aRRx5Zctt0oH7aaaeN3+/oaO0vOE01rssEeilxbhZprodaSnOiUeJcHhEzigTedOyC3+6EM1/ILBcxLEXMiGo0jQWIOeRZ5Y6qyPJKqsrrVk0uixBSJWK+724Up3LuuedixYoVWLlyJe68805x0vLLX/6yWH7OOedg5syZ4znodEvrLly4UEjy//qv/8JvfvMb3HPPPWI5HQdceuml+MEPfoDFixcLgX799deLk6WSlJ/q1GJML0eWKx9fSprLkUtzXdAxa5UKPWrR/LPeVeaVCmK90vw4jGFwjE5eOnXJbq0rCXx0fJ423/hVbaZqQ9FGYG+lMvxmhrLMpVgWQk+VuRFpLq8yl8ey1KPKvNmkOR1BR3KTB2ESZNQArxLKkWz0WsubrurhpKV1+EPPMFN4TKexYI+BE4pmqzIXmeWprKiSp6iTWsnyWojzUDAhpDnt+6cP6C9Z4U9fitsC7WJS5p//ZdsQfvvStqIV9rRMLsPl47j8b4Ipq8s5lqUkl1122fj/6XJNynclWULNghwOh5ACcjHw9ttvY82aNbj33ntLbpsEebG4gFajWcd1eeW5mjxXqzavhjTXg1ya66kyL0Ul0rze1eZFc9QthQaeeiiV415JY89qVZXXrJq8lBhvIs4++2wMDg6KcYaaclJV+FNPPTXetJOkrrzBG8n0b3zjG9ixYwc8Ho/It/3tb38rtiNx9dVXi/W++tWvYmxsDMcff7zYpttt/l5czTimVyrLlduRi3O5NNeKZtGsMjdLLIvJqszrWU1N72igwY05zV5lXkqeszivDQ1t+mkEKsGnMnvlZOYD8HKyzNUo1gBUjXKrztWaj1IlsxHUGoA2YxNQLWpdVaqs0C+HTx06db6cM83LVBjTzQzJ8qc2DeKPf9mMTWu211yWK7dR7nZISpOkJmle6QkLPbJcmi9fRs8vTfJ1mOaHKukeeughHHvssUKWq/Fv//ZvWLJkCT784Q+X3N5FF10ksnepGvK+++6bdLloq9EK43qxxqHKpqAkzeUNQfU2Am1kE9BKGoHKRbY0VZtqbpt+zmI/K71O1ZLlWo09SzX0LNbI03DjTvq8KacWg+JXtm7dKirGKTrlqKOOGl9Gjd3kl+xT5fiGDRsQj8fF2E5XDclluXRC/Xvf+54Q8IlEAv/zP/8jxnem+mP6kA5ZvjdhmTSVK+DlkR1lNQA1CVoS1GzSthh697VazUlrTSMy5PXAzUOnuDCfKlC8hhSNoqz8JtSyyKmi0Gh2rTyyQ9lkVKoyV0JV5uP/l1U8U5V5vai1eNcrzcsR50Yfo1a5L1X5S1E50pUAxT4zDMNUgRJVuuXkh9cCvSdMSZb/6om1dZfl1dieJM3LQapGf2TtblGlbiS7XRLnalO5VCvfvSj74oRaAcqXlU9SFm2lfPvb34bP50N3d7eoUnzsscdU1yOhQkL9/PPPL7lNkjB/+MMf8Mwzz+Azn/mMqHS86667qrK/TIHQjrChqRriXCnNiaLSXAW5INUjzZVythrS3AyCW/7Yagr4UqK82OujfC3ptTYawULvo/y9LFeUl6TF5TgzNSglx/XKc6nK3Ijs1JSLyuPTajTtVMtBr/AYsJbSvNrbbjVpbmZYmlcXFuYmRSlA5VXmatJcLmy0xI0yzkWNqV5lbmQ/65lhLEXgMAzDVArFkpglTqbcanOS1H94/B3c8/r2STErxaB1SZZTZT01EZW2xTSWdqcDHS6n5kTLidmzZ6O9vX18krJqlVCsClUOFpvWrVs3vv5VV12Fv/3tb3j66adhs9lEFq5aNfijjz6KcDgscnRLQVm4xx13nLiEnYQ8Xfp/6623VvQ6TXUqEeDlPl5LmqtVm6tKc40q80qluR6KSfNKq8z1CvBiUy3QI8q1qsrVZLkceg/k74Oyqlwpyo3Gr5QU5SzImRZDjwQvtb6yylwuzQ1VmZslCkUlGqbeURu1EvGtJM3NWmVeM2nu7wUCfcUnWqcFaZoM86kCZZkTt77wwaRlepo5GqlylGeZq1FJlrlaA9BmyTM3sp+SNC9V7VgLua7W/FP6/DAMUzuE4A34MJWodnW52vaNVltL0nwsksQlx81Hj0YDILksJ8H+5PMbx8dsM8hyPT93xa9/i2SZb9++HYFAoQEr4XKpv+dXXHEFzjvvvKLbWrBg/99Lik2hiS7FP+CAA4SYX7VqFY455phJcSynn376eGauESg64Pvf/76oitfab0adcuS40e0GZvkNNwdVNgSV55pPyDQ32ARUD2bIMzcTek4A6K0qJ8qpKi9HlJesJGcxzrQoRmW58nHT3PmijUCbLYe6XOrZALSe+0vS3OxROmb/HE3I6WfKhoV5EzQBlRqAylFrAFoJas0/5ZCYlWJApgpG5H6tqs3pJIQy8oZOWMjjcSRYljNMjSHh2ATxFqWaf1J+ubitsImxWaT508+tF/8/d8VMUY3sddrG41ek6nP6mR98e6cQ7NLjmgl6XWp90qIZIFkuF+Za9Pb2iqkccrmcuFXGvWzevFk0Onv88cfL2u7q1avR2dnJslwnoZ0R5O22+j2fDnlO4ryW0lwuX/fEBsfF7O7Y2KQGoHqlOUni9cOxlpXmZhPlhFr8ipKSleQVoCcWqCT+2lwBwDCVyHLlNrSkuZ4GoBKazT/pmEt+TEqxLGqxKpVCz6Hj+I72UatquJrS3EwCmKV55bA0rxyOZKkjdHkvdeDes2ePuC3V/EneBNRINEsxyo1lKSfLvNmjWaR9rff+ajX+VItlkU5iTCVZ3uawi8+x1kTLGabWSMKVxvFIKIjR4UGEg6XH9UZDAnksmRJV2Xqpp6gtN56FpPmdL27GG7tH958Q2CfLd4bj+Je/bm5aWV61vPMmONlTb6hp3M9+9jMhs6mR3HPPPYcvfOELWLhw4aTqcmraOX36dHz84x9XjWpZtmzZ+P0nnnhCVKO/++672LhxI+655x786Ec/wje/+c26/FxM+dAIvnMoi62jFoTsbnFfjp5cc6PxLNWMZmlEE9BGoCenvBFV5fL3UC2nvGjsisGoFfpsqU3VIL+7sr/76a2F2CLNaat6Y12m9amGLNezLXk0C43jIXsAAzE3gta2SeN63dAr3FViWUpRDWlbL/Fr5Hk4nqVyONO8Mtgs1YnBwUGRlzk0NIRMJgO73S4u/6UvWMWqoEiaS5XmatEslVaay2NZ1KrM1WJZqkGzRLPUY39pu0alvLzK/CefWFqT/WIYpji2RAjr334NsfAostkMXJTD3NmN+YuWorO7x5RV5iSTH1s3hJde325acVxupfkLz7yLsdAivLc4jj5Z741Vm0bw+qubTfvzEj5ZxE9N97NFolmqhdfrxSOPPIIbb7wR0WhUCPHTTjsN11133YRKcKo6f+CBB0TMC2WcKwkGg1i/vnClA+FwOHD33XfjsssuEyfRFi1ahNtvvx0XXHBB3X42xjhjXj+29UxHyOtH1mqDLZfFNHsKC6KD6EpHi0a0lFNpLqEVzSKvNJcjrzRXVplr0SqV5nrlfiWivJQsLyd+pagk10G1RDjDmJliqVIqv7qTUItmGXN1423XEkT8vcha7HDaLejOjWFReAv6/ZaWqsKtpNK83lXSRvaVK82ZRsLCvE6ynKqYYrGYaFJFX6TS6TR27dolvmRRrqWeS4fVollqEc8iVZlLjUfVYlnkWeZy9GaZNyP1lPz0mkkV+vJYFqoyl1f1MwzTGLpdadh2rcNYygF/oB12uwOWfAZDg7sRCYdwyBFHNlyaK6GK66c2DU7I8DYr5UhzYvWrGzGwY2Ll2uDAoKlFuVakl5o4r0o0C0vzcQ455BBRVV4Kq9Uq8tO1IJEuz0wn6U4T01yyfN3MhUg4nPAm47BnM8jY7Nhp9WDE3o8V2D1BmqtFtCiluZwJ0lyaVyKaRY48mqUWeeZml+aVivJ6ZZXrjl/RIcpZkjOtRrGK8FJDlrRc+WtcLJplRyaAbTNWIGH3oCMbgz2fRibjwB5PD0KuNqzENvRA0SOjSWNZKpHmjRK9LM3rRzrMV/WUC0ey1BiqLKLKcpLlJMWpYom+eNEt3af5tNzoZfzFmnVWG6oyL0a5ArcR0SwkoeVTM0S0EPKTEBJqJywYhqkxQjTmsTgQRzYVBzwBOJ2Fcd1ic6KzqweJRAxbNq03XTwLVZev3x0xJMsbmZtd7nOTIJdP5T632lRtWd4/qwszZ7VPmGietFxeeV61aBaC41mYFmJoR7LsiaCRmirLSZa3x8JwZjPiCxLd0n2avzYbUL2MXxnRIo9nkUezTMCk0SxmjGfRG71Sqqq82rK87PiVIrErtYhWYZhmwMj5PbV11US8iNfqWlaQ5YkhWBIxWJGHM59Cd3YUcasb6xKdjYtnqUEsi4QRadtowWuGeJZqbtfs8SzNyJYtW3D++edj/vz58Hg8IjaRrgxNpbT7L8qh7+MUp2ixWPDnP//Z8POzMK8xVEFOMSxUWU5vkhy6T82raDmtZyTLvJI8c2U1uhTvQsgr2NWyzKnKfHxdlcaTRrLMiXrKZ7X9KFee12O/9WSZ/9vZB9d8PxiGmUi7K48uWwTDcQveH45jJJacMK63tQUwOjIsss0bHcuihZnjSRop7EuJ8WpIdJLgvTN7sfiA6fD7XegIuCdMs2cWpDlNVH1eM2nOME2MUnpXsp3to3bshU9Uliu1C92n+UGvH7uGshOagxqV5qXyzOXCVUuaawletVgRNfRK80aLc6Oi3GgEi/z1otdR/lqSKFdGsChluZxqifJyoM+XnolhGs2gRnV5GRfDlJTmVGUec7Uj7OmBIzo2aVzPJlPw5yIYtnUiiMLvvmbltvI4j6rMK6HCCnW90TEkoovJ6FLLzQpnmk891q1bJ6IRf/7zn+O9997DHXfcgXvvvRfXXnutrsffeeedkzysEViY15hkMikyyymGRQ2n0ymW03rF0JLmcsppAtroKvN6yWc9QtyoOK9mtbmeqBd5lTlJ8z99ZXlVnpsxxg9/+EMce+yxIvu2o6P0QQvFL337298Wl/77fD7MmDED55xzDnbu3FmX/WWqjzM+Ars1j2AohV0jMYwk0khnc+PL7Q4HspkMUml9Z76ZxkvzSirIjchzKYKFKsklQa4GSXOaDjqwT4j1mkhzrjJnmpBqSHIlGYcdOZsN6bEkYqHJmRr2bFZkmqdthUKSWkjzYpEexaqe5SiluZos1ivNiUZIc6Oy3kxV5UZEuZFK8mqIcBbpjBkpR5brfWzG5kLWaoc9u/9YPL2vGTzhyGeQtdiQUksopliWJq8yV4px5WQmjO4PSXOzi3OW5tWDIg7vv/9+fOxjH8OCBQtwxhln4MorrxQ9iEqxevVq/PM//zPuu+++sp+fhXmNoegVavBJ0kwNupSAlsubS2khzxSXpLkymqWW0lytylwLI1Xmtcboc5cjzutVZa4WzcLUF/qd/dznPocLL7xQ1/oUu/TWW2/h+uuvF7c0uFNzOBrsmeYklckjk7MgHw1iZCiMwchEYZ5Jp2Gz2+F0cL+BZpDm1dx2sW1J0jvQri3KO33OSdP86QEhzakqXQlXmjNThVqIcgl7OgMrSXF7QaaSNJeL84yt0ADUkd0/r2rSXJonE62ShK1VNIsZpXk5orySqnI9jT2NVpUbEeXFqKfUZoHONDNKaS6vMg/FU7DlqBeFE8nU5MbIaYsdtnwW1gZGD07AwPFcKzQoVVKOxK+GNK+leGdpXjsonaOrqxBhWczB/OM//iPuvvtu9Pf3l/1cLMxLQRm0L7xQuC0DimLp6ekRb6oyz5buh0IhsZzW04OyEWe1pLmRWBY58lgWs1eZG8WIOK/G/mtVmbdK09RW4bvf/S4uu+wyUTGuB/rdfuaZZ/C///f/xtKlS3H00UfjZz/7Gd58801s27at5vvLqJDP48OhbWWP68F4HsMxK2h4SCULVebSOJxK5xCJhNDZ1Y22gL5xvVGxLFNdmtcil1zarlEkOa4FSXOqSleT5hXBVeZME1BSlOfz8MdiZY/pnmgUbcEgEl7fhDxbkuZRkucuj8gy9yUm9n/QI81LYiDPXA9q0Sxa0lwvtYxoqaYoJ/RWlZeKYJFTVlW5AVFuJmlthn1gpgYlq8vzecwI50uO61rbcSWC8MeHEHdO7j9B94MZt8gyD+T2N5KcEMsirzKvdiwLU1VpbuZq86kozUOh0ISpVJKGUTZu3Ii77roLX/va14quR76GUgHOPPPMip6PhXkpnnoKOOkk4P/9v7IeTnk5y5YtE/ENg4ODSCQSIoOHbuk+zaflenJ1rjpxwYT7Wnnmtao0LxXLUmmVeSnpXI6UrkZluxFpXqk41yPNqcr8uW8dU9HzMI2FTqDR77yeSBem+nwsuBlPr/sD/iG4pextbBixIZa2oMcWQy6VwNaRGPYGwwiODsPj8WLewqUV5aWZBbNVMFdLcjeimalWbrxSlB+3sENMHYq/oVrSvBWiWbxOW8mJmXrorSpvj0WxbOd2BEialwGN1P3bB+BMJhFtb0fa4UDeYhG3dB+jccwe2jUpB1ePNK9mNIveKvNq5pnXQpxL2zG6rVKiXCnLjVaV64lgMVpVrkeUm5HcjpFG7wIzxekcAc7YlEPnKDCa0n88LVWZ07+e3evhTMcQ9vQiZXUiBwuiaStG7d1w52JYlN4q1mtGqdmKVeZEuXEx5Yjzeon2Zvx8KbG4O2HxdBWf3IX3bvbs2aJgUJpuvvlm1W1ec8014rtysYnyy+UMDAyIiBa62v+CCy7Q3N/HH38czz33nMgvr5Ti5cMM8B//sf/2tNPK2kRvby+OOuoo8YZTg89wOCxiWKZPny5kOS3XC0nz+17fNkGayyvCldJc2eBTL7RNrax0KZZlJJIerzIfjSbHq8zlTSlbBUma66n2JmmuJ5NcC3psMfH+2rUnlr3tqQSd0ZRDsUd6oo9qDZ0so0zzL3zhC6LpL1N/PjXyfuF29H080zG/rG0M7x7Cm+jB4q4s+t0xJELAqM2Luf39OPjQg9HZ3VPlvWbUhLdRWdwIUV4MuSwnQX7C/HbMo5xzpw093hBe3CfbxvbFcZE0pziX96ip1cB+CUOvQ0U/G0nzoHpDOoZpBMM7k2iz6hO/nZFChWBXNIyQb3Levx7aQiHMW/c+ds+eiUh7O5IeD6y5HNpHRtC3fQAZOqaYpX4MQdI8MMuvuW2S5o75hSuOSJBa5xTGLRKplum9kySspWNiVTlJ2+HEwLjQ3RMbHJe9u2Nj4yJ4e1j7hAHJ5I0qpZgkodcPGzvRIBfde4ZKP7ZSyV5K7OupKtcTwSKnWASL3opyNcoV5PITL8WQPmcM06xIcvyYcCHqcGkojw/a9s/vdE6uOKehTe1CGm9sCJ27X8POrmWiAajVFYAtn0FPeg8WxDbBlx4BFNKUqsxVZTQdY8mPOanKvMIGnrpzzM2SqV4E+Wum2UC1DsgleCIYKblOvSBpbrbs+Fqxffv2CY5Dy79cccUVOO+884puizLLJaj/20knnSSqxn/xi18UfRzJ8k2bNk0qTvzMZz6DD3/4w3iBEkR0wsJcSS4H3HMPMDY2WZjP3ydW6IWn/GKr/gJ9kuJSNAtdlkAfHDrjUk4FIjUAlUtzeZW5PFqlUmkuj2WRomCoynwwmq5IPBeTzpXK5lpTav9rKc3pedf9+FRMdShioljMRC5lGz+7KefGG2/ETTfdpHmG85Zbbin6vGvXrhUnuCqBehlQNAvFMd1D4wxTFyz5PL66dzXas4Xf3U/vE+afHlmPLa7Cl8ugzYVfTDtcVBXqZThuxfCABe1xHzqCLhx19EIcsXgROrtb64CoYhlbQ+T7pSXPzbrvSll+5rIeLOrZL91WzCxk8w3FUkCfB0PRDNbvjojHUTNQlubMlCWfx7TgGGx0zC6EeXj8NmkvHPNmrVbsbe+gSz0NSfOF74UQ9/lEI1DKNqe4FmkLUrV7j4o4V0pzqjL3zmsvKc0nSNfuaROkOUnamH2yNNcDCePNoWzNpHm9Ms6Nxq8QlVSVE4aryqsoyvWKcSOPb4REj28Nwe7U1gzxVInutkxLoxqjks9j/h7ggGxBiC8L7b8NOgpjfcIGvNVpUZXjyirzae7C45Njw1gafwkxVztc/jY4cim0pYPw+XUUUZGorkLjTd3QcayB4ziS1I2U09I+aM0rd99ILFejKttsUS1TRZoHAgFdRYHkR/UWDlNlOcny5cuXiwag1hIeltzO//2//3fCPIrTveOOO/DJT34SRmBhriQaBW64ARgZKRxkS28GVa9cf30hR4sC5s85B/BrV5OoUc0IBrk0l1eZa0lzQhLnWnEt9DhltEsx5FXmxWJZjDaqrJY0r1WjUb3V5tWU5izKa3d2s5wznJXI8q1bt4qznlxdXj98uTRu2PFXdGUToENuuiRTzM+mceOOl0Q22YjNjYd6DkLEZrQXgwWhtB3ZtBsbhjLYNBbD4t5AS2WHy2W0WeWzmfatVNW73+8qKcvl0jyWLIiFneG4uC0mzSuGpTnTBFjzecwcGYI9l5uQTUsCnebTCJ+xWjEUaEfOYGEKre2l7wJFIHFejjRXY0KVuUyaS8iluYTeKnM1aa5FJdK8FtSjqpzQ29iz3KryUqK8UkGuB/lzcAU6Y1bIiX9kbw6eXCFjXBrbnTR/sHDkHrcC77bbRLW5stJcq8qcoMf6kkEgGYTf76yezKxXlXmTxsJUIvSrJc3NxlSR5tWEZPmJJ56IuXPn4rbbbhOx1hJSM09a5+STT8avf/1rrFy5UsxXa/Q5Z84czJeKoHXCwlwJSfC//Q34wheAV14BsvsONOmWDrqPPRZ4+GHDsrwWkDQnSJyXkuaV5prLq8zVqHYsi1I2m7UpaD2k+fa7K2tUMFXRe3bT6BnOSmT5hg0b8Pzzz6O721y50K0OSfCjDz4HD256EkdFdsK+7zCcbkmgv9I2A+csPL0MWb5f1JJeGdgRxF83jWFRp0/Iz1aT5kYjUMwisOsN/dxGXqeD+jzo0IhWI7yuwqHaDHiwrDcthDlB0pwyzWPhmGY+elmwNGdMTs5qxXuz52HBnp1oSyTGK8Dplkb3sNuND/pmiPWIXbsmX8I/fXplPSbKkea1imaRU240i1mkeTmivNGy3Kgor4ckL/XcLM4Zs5G2WXDfQhvO3JHFzPj+Rnt0SyP4dg/w2CwbUrbC2K0mzbWqzItBsR3ucmNZ6iXNi8SyNKrKXG+GOkvzybA0N8YzzzwjGn3SNGvWrAnL6Kp9ybWsX78esTJ72RSDm36qMWcO8PzzgFdx0Eb3Ke9GEfVgFnEux0iluBZa2ei1bv6pbKJpRlle6yp2CZbl5mPbtm1YvXq1uM1ms+L/NEX2ZagSFN3y6KOPjg/gn/3sZ/HGG2/goYceEo/ZvXu3mFKp1sv7NyvbXQGcuuxsxKwTxy+6/7FlZ2OHK1CVRomj0RRW7QhiKFzdjuCV0ChxT9JYmpjiGGlqqWwGWhNM0AiUYYqRcjiwfuacSRXkdJ/mbx2yC1GuJssJaVmxdUqhpyGpEq0moEYbgBYTwaVEspZ0LqcRaDPKchLlWrKcXmtNWa7R1FNvI0967xspy826LwwjCfCQw4KH5tmQVpzPpPu/m2dD2FH8RKfGuUAMJic/Lqb3OL0J8sPN3nC0kgalLJaZ8847T4hxtUli3rx54j5VomtBy8866yzDz8/CXIvXXivEs8ih+zTfpCibdFZDmuuJZZFXmY//v628Ss1GQmJfPlVLmtdD+NMAMDY2hj179ohb+QDCVJcbbrgBRxxxhMhEJ0lO/6eJhLgEneGkfgXSJULUqXnHjh04/PDDRbNfaXr55Zcb+JNMPY6M7kJbbuK4SPePjO6uSlUxVfqOhQpXlIwVaZo8FWFpbgwawyOhIEaHB8Ut3adKc2oI2tfm0JTm/DqXD/WXoTGa4vPoJKgENQY688wzxZjt8/nEOnTysxS0HeX0MF2hyFQNXyIOm+J4h+4nBgrxRUaoVJ4rq8zlUJV5KdSqlCdVNivkrlz6yoWwUhabXZrT81VLltPPLv/56XXR29yzaF65iihXk2wKfKMAAEzpSURBVOXF5DR9soJwYhAecav3k0afHz2foXJgcc6YjRlxQFk4TvenqwzrUiNQI4TC2sfnuqqZ1a6epCrzBlKJkK4XrSjNxZhubcOgtVPcGjl6aMXK+VaFI1m0eOKJwi2dhbjtNgo5Bh57DHj8ceC448Qi+gJbjSae1UQezVJtSsWy1KJ5Zj3QkuPy+aVy2Bv581CO07p16zA0NIRMJgO73S4azFKVcy1jRqYqDzzwgJiKoXbGk2k8/2tsk7h9rGMRvjPnRPx42ws4Y2wjPjG2Ea/4939pbvdY4LRbkMrkEYwbf+/2lOjtMFUxc/NQMxEcGcK2zRsQHB1GNpuBzWZHe2c35sxfjJ6uHpy2sBdv7B7FX/f9XfL6vdWNZJmiXH311ZgxYwbefvvtCfPpxOahhx6Kb3/72+jr68OTTz6Jc845RxzznX766UW3SY2JTjvttPH71epjwxTo2FfYMuprw5u5HhyUGsT0bBR92QhGbB6xjEbwVMCHnNMOayoDZ2h/E08tSJrrjWypZjTLOCWyzI02AC2HesSz6BHzzRDBUkyUj28Cbrxv6cSIxYMMLCISrisfx5L8KLqR0CXEi61TKiu/FPLPJMM0kkXhQoPP9X7guT4bProni6VhYHE4hwFv4fdeHJl725F3OJG1JGGNBcfHdXmWedViWfQ0/5wieeYVie8WimcZtnZgo3OeuM1abLDls+jOjWFRaou4ZVoHFuZanHEGcNhhhSxzkuAUr/Dv/w7MnWtKSWmkCWgxlI0/aTvKynUplmUwmq5p8896RKXorSSX1iv2M1Qqzak6VYIEiJ44FvocvvrqqyKvib68OxwOEQGya9cucTLnqKOOYmnOMPv4z45F+LtnGn7fvUyM62cvPhNnD6/Dtn1xLN0+Cxb32dHdZoXdBmSywHAkhw17MhiO5kvGVZC0pBzz+dMDdbnCp1waKVdZmpeW5Wv//iaS8Ti8bX7Y7Q5kMmkER/ZgQyyMxQd9SEjzRUkf3mszXkVriCmUZf7f//3fePrpp/GnP/1J/F/OtddeO+H+JZdcItZ95JFHSgpzEuRqTYeY6jDm82Fn3ImBvB+wWvC6awZmZsOIWwrHvYmuAMYWzxK3ObsN1kwW7pEQOjbsELfFkCrN9YhzLWluFLUGoPIs82o3AC2WZy4X2tUW53or2M0my/VmlSsrtkmWv2HpQ9xihx8pOJBDPJjGTrsHI9lOHBbcji5UhlymlyvPmyHf/O6778att94qYg0PO+ww3HXXXaLBmxrvvfeeuCr0zTffxNatW3HHHXfg0ksvnbDOTTfdhO9+97sT5i1dulR8x2cawwa/FXvdeawJWMSx+iOzbDgwlEdwXxxL3t+N7MylyAd6AJsdw9kMvNEhuHethz0ypLldimXpdeUnxbJ4/S7j+dJqWea1luZFcswbmWU+FaU5SfK3XAcjbnXDn43AgQzSsGOPrQchVxs+lHxXlzTnLPPmgCNZtKAq8n/8x4IsJ+iW7h933LikJCnp9XpFAz+6pfs0X965tdFZ5kQ9xY2RWJZa53+Xwkjsit7HaP1MpWJZ5LKc0CPLqWqZDuhIlpMUp6scrFaruKX7NJ+Wc3UzwxSgKvLf9xwwYVyn+zSfZPnyeQ70t1sRT+cxEsmLW7pP82m5XjbvCmEolkIsOVFOMAU4NkQdGqupspxkOVWUO50uuJw2+LxudHb1IJGIYff2jfUd002WZR4KhSZMdIVfpVCU2QUXXIDf/OY34lhOD3RCuqurtOK66KKLRDEFCZ377ruP/x5XmQ1jHgzYAxPGdLpP1eUkyfcuX4LYtC7Y40m4R8Lilu7TfFquB70RLWp55sWiWbSyzMuJZtGi0mgWI5EpetC7HdqneshyI3nlerPKlbKcPj1UWU6yPDA2ButYDNmxBJz5LDrTESRsTnzg6zV0KX+tI1zMGtHy+9//HpdffrmIRHzrrbeEMD/11FOxd6/6iV36HrRgwQL8+Mc/Lnri8qCDDhLf4aXppZdequFPwZRiwGvBmnbrhHGd7tN8IcsXr0S+sx9IxgriOhlDpqMfsYVHItPWU3Esi5wJYrdaWeYNjm8xQ/RLM8ez0FhNleUky7uzo3AhDSvy4pbu0/yNjrlVHdOZxsLC3CBml5SSNK9VnjnFstRTUNeKSvbFaMZ5KZSyfPjXX9D9hZ2ucFCLAqL7gUBALJeytBmG0YYqy71OC4YieaQy+y7jz0Dcp/m0XA+DA4Oiyvyvm8bwxsAIS3MNWJpPJhoOiRgWqix3Oqxw2C0TxvS2tgBGR4bFeq322npcdpHRrjXRcmL27Nnib5403XzzzRU9Lx2rUTOhr3/961ixYoWux/zhD3/A66+/ji9/+ctF1/ve974n1n3mmWfwmc98Bt/4xjdENSRTHYqJbFpCleUZtxvu4SBsqQws+by4pfs0f2zRTN1faKspzQ2JSZ0NQLWyzPWiR5qXK86lx1SjqrxUXrnR5p5G8srlaIlytfczBCf2Rm3wBMOTooDovi8bx6jTh7C9+v2OKhHn6a3m++5w++23i5ObNPYeeOCBuPfee8VJTjoZqcaRRx4pqtE///nPi+/pWtBV4iTUpYlOcjLmg0ZhUVnu8gChIVgyKTGu060tPIic04vE9CViPfmFMxTLogeKZTGE1tWSJMS1pHiNZXkzZJk3uzQPWdtEhTlVlquN6f5cBMO2TrFeS+HpAjzdJaZKr5UyJyzMDdIMkrLW0lwey9KKzT/1oiXNjVTOlyvLCaqsozggimFRw+l0iuXVqMBjmFaGMssphiWUUJciNJ+Wt0/rKVpxK0WN0O81VZm/uDmIjUPhKSHNfQHfhGkqU66wTqdTIrPc41b/u2l3OJDNZMR6dcVEVebbt28Xx1fS9J3vfEd1vWuuuUa16aZ8ouIGEtjhcFhzO0qef/55IWt++ctfiqrEYlx//fU47rjjRFNoyj+njHSSN0zllBLYlFlOFeTO8OS8crrvDMeQ6G4X61XrOfWiJTArrTKvpAGoEWmulOClJr1Uo6q8Vs095eipKpe/18GdcWQsVtjz6scBjlxWLE9Za5eSWquGofW8aiiVSololVNOOWV8HhWs0f1XXnmlon3YsGGD6F9B1ehf/OIXsW1bIeKUqR0Ghpv9UGY5xbDEQpPG9UTWAms8hIy/Bzlve9FYFiUUy6KkKrEfSjnexJXlZpTxjZLmFKpFmeUUw6KGI58Ry2k9PZghYoYpDgtzgzSLpCRprtb8sxxpXqsmoo2KZalmdXg1t2VElhNULUFVEZRZrnVwScuLVVU0I26nDZ4iEy1nGCNQg0/KLE9r9DROZwG724VyPlpmzjKvBr0ze8XUP6trwkTzSonzZqyELkUlP5PD4RQNPjMaYzrNt9ntYr2pChUlyCetv29XXHEF1q5dW3QiOfLcc88J2SL9PV20aJF4PFWbn3vuuRO2+eKLL+KTn/ykyMGlpp9GoZ4iO3bsaPjxYbOjR1xTg0+RWU6DtwrWdAZ5u02sV+3nrlY0i9Eq82LUQppXk2LPW2kESzFZTqJcryxXi2DRqiqXv8fOXAb2fA4Zi/prnrbaxHJar5bUW5qHdkbE515z2hkxdNUQFaNls1nReFkO3ac883KhcfmBBx7AU089hXvuuQebN2/Ghz/8YXEilakvnc7i4ys1+KTMcmTVj5Es2ZRYnrO76hfLUqonj1RtXkdZbjaxXct9bYQ0dyItGnxSZrkaaYtdLKf1mNaAm34aRC4p1b6o1VNS0qXEVGFFX77o+ZRV7586tB+PvjP5IMJoI1C1WJbhaGZS80891Lv5Z6Mw2gDUqCwn6P2mywYpb4/igOTvPX02qFJj+vTpYj2GYbRJZfKiwafDXohhUeLweJDJAak6FIrT724kFEQqnYLT4URbYPLVTGaAZDg1Jz7/kwegRyOq67cvbcOGtbsa2mS0mgK8VLPSSmR5LJVFtz8gxvShwd3odPZMGtMjkRB6p/XD5w9QN1rNbXFTVYi/iXoaXv/0pz/FD37wg/H7O3fuFJm4lJVLIkXihRdeEA0+b7nlFnz1q18ta59Wr16Nzs7OljuJbUasqYxo8Jlz2EQMi5Kcww5LJivWMwpJcz2NQCVIAUXdXqScbUKK+jOJSdWRJRuASvNkDUDlMng4MVC0Aagaak1A9TQCrSalBH2tZfkESuSVKyklyiXo/e5MRTHoCojMcovys2HzIDA4iPy2QRQL2wrM8qNSaN/KbQhay6uG6OSnRL3Hx49//OPj/z/00EPFuD937lwRp3X++efXdV+Y4ljo6rpsBrA5gMxk2Z23OcVya2by+EWxLNPceV2xLO724lEalLobzDqRzFvhsuTQHhqGJVCnApASjT+bUcJX2qy03o1AA7mIaOhJDT6d2dFJY3rY2oa+zKBYj2kNWJg3qaSkxqJ0OTGdcaeKdpL0tF/Lli2b8CWxVtJcDYplGYmkx2NZRqPJ8ViW0UidLyGvsCJcGSVTbP/LPQkgxbGUI8sJ+uzR+00nTejzQAecdIUDnbShzyHl+tFyM8o2hjETwXgew5GcaPBJmeVK6EKY3RErgiqXcqrJStLD4XASYwbHhdHhIWzeuB5jo8MieoOqiTs6uzF/0VJ0dpefqVntSBiS5VRFfuHHF+O0xdqNtHq8TjwQcOP1VzdrSnOSzGYVvEoBXquK+Pf2xMXtiv5O8V5HwiGMjgyJzHKKYaHKcpLlHo8X/bMXYdNwBKt2mPcS+2ZizpyJzdLb2gpflBcuXIhZs2aNx7CQLL/kkktEFrlUzUh/b6XGn48++qiIdaHjMuKJJ54QzUSPPvpouN1ukWP+ox/9CFdeeWWdf8LWQm8sijMUhXskJBp8Uma58gttyu+Fd8+wWK/c/SgmzanKvGeWC2NeP7b1TEfI60fWaoPbbRXydEF0EJDJS5Kvjvnt43LWOqd7ssztnhiNRPI3ZuBbHInm7YoYQC3qIc2NVpWbXZZrVXDTp4Teb8ooH3W0iczy3FgCGZsNMZcH7ngUs4d2lTyJIr9KoRJ5bjZpLl0tVAr6jmuz2cS4KofuF2voaZSOjg4sWbIEGzdurNo2mSoRC8ISGhINP/OUYa4Y13OeAOxju2CNGT8+olgWr3/imEQSVqpgJqFLYncw58P6IR+GbN3I5C2wW/LocSSw1GVBr6u2V4nUU0LXm2aS5vS5W5TagpCrTWSVU2Y5xbBQZTnJck8ujkXprbpOjDPNAUeylCkpSUaSpEwkEsjlcuKW7tdDUtLzvPrqq0La0/N1d3eLW7pP82m5HJLmapA0N0NcQCNiWYqJcrXcda35lUSzkCgvV5ZL0MkRqoagkzTxeBzDw8Pilu7TfD0VdgzDABv2ZBBL5dHTZgFdpU9DuNPrQU+nB7G0BRtG6At87cZ1kuV//9vrorrY7fagvbNL3NJ9mk/LK2VM0deiXPTIcmLFzC5cesJ8HHnU/KbKNScxXu+4GJLmb+weRTjvxSFHHIme3n4kEnEER0fELVWWLzrwQxjMuYQs37Pv5DRTex588EHR0J2iAuhvqzR9+tOfHl+HTlyvX79+/D7F9t1999045phjcPjhh+PnP/+5aFh34403NuinaH6MZIjTSN2xYQfsiYTIKs86HchbLOKW7tvjCXRsHKjpF9otIRfWzVyIkbYOONMp+GNhuLMpUWn8dvtsjDhKj4nVzDI3Es1Sy3iWYlnlWvtUqrknoWzuWQtZrhXBUirupCsdxWHB7fAPDiKSsCDsbUPK4UR3ZAzLBjahI2Ys/kOKNSkXM2eaa0EnKJcvX45nn312fB59/6b7NM5Wi0gkgk2bNokxnqkuvYoKb7VhoFgsC43XtoH1sCTjQKAHebtLjOt0S/etyRjcu94fH9e1zvmp5ZjrgWT5a6nZ2J0NwGvNoNueFLe7Ux68tseBwWRr1qE2S8RLPeNZqML8Q8l30ZcdQtzixqitXdxSZfmHku+J5Uzr0Jq/2TVGkpRShTflnFGFN/1xVVZ4l4pNMQptj56XvrzJK9xp23RfqjynM/HKeBaiWLV5MXlOOebKJqLjr0eLxLLoaVBarWr57XefiWpB7zu939X8nDHMVGM4msebW9JY3GcXDT79fpeIYaHKcpLlw3Hp/HIe7a68yDOniJZC1fnk37XdO0bENh6TyWOvy6Y5rlNleSIRQ2fX/rHb6XKJaA6qNt6yaT06urrL/r0eCifx2LohvPN+ZZdyHn7UIlz6sUXi59HDoh6/kOZ3UqzFM+/C7NRalFOlPcXUEPOnq1fV0dUE9F4ro3niqRw2DIyMy3LpCgZl8+iaNf4MTs5SbjXmzZsnfh/lUL4tTcU477zzxCRx2mmniYlpHFRhPu3N9zG2eJZoAJr3e0QMC1WWkyyn5ROqzgM+kWlOMS1UeW6poMqctrd79kwkHE60x8Lj28oH4+gMZEWl8Qe+XnRu2QKfSpW5KlWoMjcSzUJIYrsa1eZ6BLyeCBY9slxONWV5OfJZEtt2hHEIdot4nrTNDkc2A18iVtFJG2nb5VScm63SXA+XX3656C1BPSZWrlyJO++8E9FoVDRiJqi3xMyZM8dz0OmK2zVr1oz/f2BgQERj0ZVEUr8KuuqHelNQDAtFctFJTapk/8IXKitoYmqDJTwM24bXkJ25tNAA1OoHchlYRnfDu3c97JGh/RXn3nYkPC5Ys0k44kHNHPOA36kZyyJVmdP21kT8iDuc6LFEYCEV4PaJSJYeSxJDGRfWD6fQM71QcGMGplqVeb0rzUmKdyVWI2RtEw0+KbOcYlhM8vYzVYSFeQ0lpd7YFCPQ89H21IQo3afL2mg5rUeXlSkpFtFSbo55s8WylCvL5euq/SzKEwFaOebVlOXy917t/WYYxpg0H/4gjfZpPapCvNuTw+KuLLq9OditeWRyFgzHlEJ9PwM7gugIuPHivi/aB/YE0KNyRQ2JUYphoQgOtXGd5o+ODIv1/O0dZcnyB9/eib9tGEQomEClspx+DiOQNL/pY0vxLz4nHv3zWzAr9awqLybNpQgd5XsdS5rncl+GMWt1uRyS4n2vrikqw0mmS1JdNArNZMXjqEJdLtWNEPf5EGlvRyAZn/Tlme5TLMeo0ydiOtTqzOWxLNXOMleLZikmzSsR53qr1PVGsJhJluup0lZWgdN735ao/glOep6pIM3PPvts8d36hhtuENFYdPUONeuUGoFu27YNVuv+YzES4EccccT4/dtuu01MJ5xwguhLQVAjZpLjdIUufTc//vjjsWrVKr5Ct0ZQjjjliUvQEKEcVqjKfDRlKS7N170MeNtFI1CRbR4Lwr6vOj3T1oPE9KXI+LuRcDhgzaXhjAzDP7YO3tiQoVgWiSC8GLb4EbDE9wvxRFRIc7rvt6UxlHYjOLYbHZ0V9BuockRhxVEnda4ubzZpTh+Fds4qrwtnnHGGOOG5d+9e0Q/olFNOEX2FZsyYofkYSgC54oor8PDDDwtfSz2K/vVf/3VS8+iWiGTZsmWLaLwxf/58eDwekS1JZ4DpbHEjkSQlveh0q5TlRmJT9EJvNsl3utxX65I1Wk7raaEV0dLqsSxasSlGZHklj/H53TWR5QzTjJh1XKdK2mDSisEYZZZbJ8jy5dMz6G/LIZ4GRmIWcUv3aT4tV2MsVFpQUxUxZZZTXrUaNJ+W03qNQi7LvS7j59p7/C5cctx8fOqsD8GM1DuCBfty7uWV4hTL8tSmQWwcCovpnYGxCdOaodD4yRd6zOZdoaZvqsq0DmYd02kEd4Wi8AwFxa1Slu9dvkRkndvjSbhHwuKW7tN8Wl6OyM847MjZbEiPTT4WT4ZScOSyyFisSFkNjqUyyasmhbUoFc1SKp5FGaeid5qqsrzSyJRyqPfzNYqLL74YW7duFd9z6fu0sjmz/Gog6Yoh5STJcoJECol12h7Jc7pPYxfT2DG9WDQLIUpZYkFYg4PiVhrXSZbHFh6JTEc/rKkYnJEhcZsM9GNg1krEvOX1A0rBjgxscED9xKLTkhOZ5tQItNrSe6pRDUlfz3gWpj6cdNJJohkzxR/+6U9/EtFZn/3sZ4s+5rLLLhM9hf74xz/ixRdfFGO9PE6xpSrMqUqbcsooA5IuoXr33XdxwQUXiMuw6Eyx2Sg3NkUPtA2qVE+n06qdxOmPGC0v1WVcq9K8Xpg1lsUIapXmxX6udT8+tU57xjDmp7nG9byoLPc68hgSxWGFcZsq0IdiefR4C8uHB/ZXo++XmKWrtyhygxp8UnNHimFRQvNpOa3XaMqR5aVodOPPesty+mxoZbpT3ApF5/S1TT55Is8t15LlNX0dp0gsCzMVxvTCJftUWZ5xuyc0BrWlMuI+ZZ2PLZqJvtdChi+xtqczsGazyNrVZXDaaoM9n4Mzl0FsS0R/888yq8z1UqrSvJoUE/TNLssbRTmV5s1WZc40/5iup8q83DGdKstzTi9s4cGCVLcBtkwK1sgg0u29GOpZitnbhkSOea9LW8orY1mc7V7YkUUinYGXGh1hYpV5Km8VDUApokVAx2JGjy1rdPxWbtV2s2SXm6HSnKk9JL8lKELrmmuuwVlnnSWcqFohMaVt/OpXv8Lvfvc7fPSjHxXz7r//fhxwwAHiKqKjjz66tYS5MgtywYIF4uzCPffcY8qD8EpjU4pB2yTRTpXqchkvifpQKCSy1Gm9UhiV5socc3ksizzHvJliWcqpFFc+Xs/PxLKcYZpgXCchqDbblRcxLIWEpckX2IeSheW0XiHCZSJSBbEWlE/d0dktGnxSZrlyXI9EQqLpI63HNH9luTznnjh0Sa/4jHTIroIq1tRz856wiPtpCCzNmTqP6eXGsZSCYlqogtwZnpxXTved4ZiQ5rQeVaYbyTL3RKNoCwYR6uqCLRiEL7D/6xb9NDGbB73JEPwZfRFZarEsWlnmlUSz1EuaV1JVblZZPlUqvJmpQ6OP06Uq82LxLPJ1s952EcNije8/ASpB9zPREGK+HiTd7XAngkVzzJW0I4bufBh70AFPPjUhp5zanoSzDvQ742i3yZxAOdKcqWr+ulRpzuK8voRCE+PsqJC3VDGvEUZGRvDQQw/h2GOP1UzdePPNN4VMp+gWCYrFnjNnDl555RVDwrwpIlnUINnc1VW86RhdXkVvmHyqB9WITdGCRAq92RTvQpXqlM1DZ3/plu7TfFqut3K9YfEs+Tw8+QT8+Yi4pfvVimWpR7yLkX1hWc4w1RnXazqma8hygvLMKbM8reEQaD4tp/XkVb5U/SvFbgzFtE+s0Xg9f9FSuN1e0eAzlUyKcZ1u6b7H48W8hUur0sg30O7WrG6uFCH3Q0GMDg+KW2XzxGaU5fRaqU29M3ux8MDZ4/eNIlWGkzSXGrGWOrFCyymH/r01e0Sjz1aKYvE6baIpruYk/XIxTYWZj9Up01xklmsM7NZ0Bnm7TaxnFBqp+7cPwJlMItrejpTNjhws4jbo9cMWimJBtFABqUQuapUSd5L0VQrhKkSzSEJbSO08YInbYInYxa2w/RUwvl0VWJZXBzPtC9N6VGtMpypzOcUSnErFs0jLc3YXYHPAklEvOLBmU8hZ7cjaXEVzzNWgsXoJBuBBEntTTiTyNuTyELdDcQs8tgyWuoOTG37qrRqv8VWWUrW4uLIKXuxFQNzmTVxdXs194IiWKuDy65vo7/ns2aJ4V5qkRsyV8u1vfxs+n09EXVPPiscee0xzXepzQc5VWZxMUdq0zAhNKcw3btyIu+66C1/72teKrkdvjvzNojevHshjU9TQG5uiBVWWU2YbVZLH43HRqIRu6T7NN9qopN7S3JuNYHZiMw60bMOi7FYsyW7Gwtw2tOWjpqoup+p45WR0O69de2LF+8lMxOsoyBPNycFipVXH9ZqN6UVkuRS9Qg0+tT5aNJ+W03rl0tndg0OOOBI9vf1IJOIIjo6IW6osP/jwI8Xyctg2FBO52FSVLOH1e6suzYMjQ3j3rVVY/dr/h3fe+Ku4pfs0vxnREuH02vXP6sJBB/Zh9sx2LD5getmvp1Kaj0ZTmtJcyiynynItWd7IWBuGabZjdWoASg0+cxoDe85hhyWTFeuVQ1sohHnr3kdgZAQphxNhb5u47Y6MYdnAJnSlo4YaSColrxK5LJaLZLlgVkNLmmdCNkzbFYBjUwDOD/zi1r6lDZaovaqiXGsfWJbXDz2fP6MM70xiaIf2RMuZ5qLWY3opaa4mzuXzrJkkkE0jb1cvWMzZnLDmMrBl9X32KJZFgiqUexDGCmxEH8YQzzsxnPeJ235bCCvzG9Dr0NguHZtpHZ8VW1Zlxtpm4hUsw/9nOQh/tRwobun+ECpoUlpjWJo3J9u3bxcn16TpO9/5jup6FKtCxWDFJoqGkrjqqqvwt7/9DU8//TRsNhvOOeecuhRnNTSShV4k6m5ajLVr14qKaYmBgQFxedDnPvc5kaNVDHpzLr/88vH7dIazHgfi1YxN0YK2S89BH0I6k0vyXS0CRi/VyDTXE8vS70qibWQbnPkUElY34nCITLAAVZrnkohYpiGU96BeDT/V0BLjyp+l1HM9961jDOwhw7QGtRzXGzWmU8zKcMwqGnxSZvnEWJY86KKW3RFqEqo+/pII1QNJ8Y6ublGdTQ0+KbOcYljKHdclWb5+d+GgvyPgHl9G0rVakBRf+/c3kYzH4W3zw253IJNJY2RwD6KREA44ZDnau8oT/vWuLpfEN0lwqsZX4ve7JryO4v+zgIEd+9cxUvkt5ZlL8SyY2a76+dk+EBxfp5Uqyxnz06rH6s5QFO6RkGjwKc8wJ2iUT/m98O4ZFuuVQi2WRZLmC98LIb7FB/8sLxzZDHyJWOG5uiqQFCSAu4uf6NVCGc2iFs9Csjy2yYt80gq/LweLPY98xoJI2AFrwob0nCjyvuInEvQ0EdWS9ZXI8klMQVleTpY5M3Vo1Jje48ojnrVoZpnryTMvVm1ujQVhDw+Lhp+WfRnmEvSorDsAb3QXXLI4FqOQNO/GOgTTXuR8XXBZMmi3JPZVlquPZ+M0sKhhMOfDa6nZoL9mfsRE89I0bCJiJgSPOBFAP5tZqsunUq55K4r8QCAgplJcccUVOO+884quQ1FQEuQ+aVqyZInIIqdxhfLIjzlmsnPr7+8XRcpjY2MTqsz37NkjljWNMDf6IlFnU+qQSnk1v/jFL0puv9p5OUZjU0hmU0wKfWDokgB60+iPhtHYlGLPYzQDvdrSXJ5jXhKKXYnvhj2fQtTqox8AsGSRgR2RvA1t+RhmWkcQys5QyQmuD8VkeTFpLs8yZ1HOTGVqOa5rjumBXsDuNpatXKKqfCIWbBixIeAqNPikzHK6ip8KE0mWx9KF5WrjViiYEBL0vT1x9HhDWOHqEhETms9kscDfXvm4LpflSmFP0jfk91ZFvNJJ4G2bNwhZ3t7ZPf53zel0wdHpRHB0WCw/uLO7qWT5zFntE8R4p0/7SiJpGUlzOhFB2ylXmtPnhZ5bDsX6sCxnGkXLHqvTCa8NO5AKeEVWOWWWUwwLVZaTLLfHE+jYOFDx0Sg93huNolNxrFxMapbb/FNPlnkpaU7FWsmdbiHLrf7seMSAxZGHvzOPXNgGe9ADb39scvyAAfTKcmWFfClZPqG6XCbLlbSqLGcYM4/p1GiTGm5WIs21oK24d61HzBtA1t8LTyqEPMWw2JxClttSMfQMrTc0piubf5LcFH87SDrbFMeFwUGg3dhV/oah5zAIjenrM72iGn6aM4JcujBoupCB0xLCcD6ADZiBbqyH04SyvFp55maW5lOV3t5ew8kYEhRdSmhFXC9fvlzEYz/77LP4zGc+I+ZRDwaKclET7KYV5kZeJDqzSYM1/fDU4dRqNXeajBSbQpcRUIPPcDgsYliospxkebkfjlqjjGeptOpcjiMbhzsdQcTqLshyORYLEnkXelxJ+OJJRPOTK/vMhFKa/+kryxu6PwxjFho6rssleDF5bkiWFxiOW/HmLjsWd2VFg0+/Ky9iWKiynGQ5LS/FusEYOlwOLOrxF5XmlfLOwBhW7QiOV5bXkmg4JKQ4VZarNbmm+bSc1oPFvOO6miwvJsmVzJ8eEI+RKsHLkebSrbL6nyU500ha+VidKsynvfk+xhbPEg1A836PiGGhynKS5bS8XpCc9c5rr6j5ZzH0SvMtu5PIhO2weHJqh+pifibsQC5mg82XrZool/ZJuc/FMCLL5dXlqtnwdZLlFEeiRs8s8/RfYlqbZhjTy5Xm9sgQvJteR2L6UuQ6upGx+kUMiyu4C/6978ObVY8JlDf+pBxzr7/07yNJ3EnV2PWQ5gYJ5t0YyvoQsMTFGG5zupFNFRpO0xDvt8QwhABivn44oa8RdStIc4LFeXPw6quv4vXXX8fxxx+Pzs5ObNq0Cddffz0WLlw4Lr9prDr55JPx61//GitXrhTJG+eff7642oX6LlAB8ze/+U2xvpGGnw0X5nqhF+DEE0/E3LlzRVdmqtqWMFpSX0+qHZvSCJRV550uJ0aTKcOxLIQtl4Eln0UW+yWE02lDal/wbxY2WJEEtUaqNWq543qqy9VgWc4wJhzXy5DipSApPjxgQbur0OCThq5CDEvpMV3Kpt44GkWHy4k5rhKXbpZJLJnFWDKNPbKxt5ak0ylksxkRw6IGzY9lw2I9ON2mrC5XynKS3+UgBPu+SJVypLlEOY/h/HKm0TTrsTpJ8b5X1yAV8IkGn5RZTjEspj9Sl8Wy6KkyV0NNmve5PMha7UjaNZrf2fKgwi6KaDFKuREsatXl5cpyNdSqy6sty7VEuXJ5tcQ5x7IwZh3T9VSZVyrNfRuG0NbRjpzNBWs2CUd8X+xWhYehUpV5M0nzZN6ODKwihkWCpLkE9V+lQkVaz8xUW5qbodq8FeNYagGlczzyyCO48cYbEY1GRQEyRURdd91141ezUO9IqiCPxfYXHd1xxx3iJB9VmJOLPfXUU/Gv//qvhp/f3L8Z+3jmmWdEowmaZs2aNWFZPYLezRSb0giqkW9OMjqSsSNvscHnyCOqcqBtQxY5WMWg3gzQz/RvZx/c6N1gmKakecd1i2ZWuZmQBL0yjoWqoMdCiX353L0YHDB+eacch8MJm80uMssphkUJzafltF62wbJXK4pFK4ZFSce+/hRajTnVpDnTPNDBNF0Z+Pbbb4umQocffriYf9NNN+G73/2u6gE8HbhroVYc8e///u/4/Oc/j1akecf0wilP1xS4kkNZZa4mza2OPKy2PPxWByhxIJicePI1n7XAYoXINa+0olx6frX9LFuWK6hmbnk5sryUKFdbn6vNmVYf02stzbvoVyhenWa28lgW3dRCmpcRx0JQzjoVI1JmuUvlSDwFm1hO65mdVpTmTGkOOeQQPPfcc0XXmTdv3qRxye124+677xZTJTSFmaScLXoB1CamMVEtyhxzPaRtHiQcbXBkE4VALTn5PNxIImzxIpqv/4FiOdXlLMunJj/84Q9Fjh/JEr0nwyKRCC6++GJxwOnxeHDggQfi3nvvxVRmqozrFK9BMR31YuNQGC/qqJajHHOS5lJ1dbn4/AGRXR6LhCe9d3Sf5tNyWs+slIphIVEuyXL5ffk8ObSNQ5f0on9WV8Wvrx64urw6XH311Zgxg3qoTOTKK68UTdzlE43h1PysFHQJu/xxZ511FlqVqTKm1wu5yJVL3gkCWN7QUiaN5UJZmfmtJqPl0trpy8PdnkMqZhGH6u0uh5jEc+SBfNwKuz8NqzdbUpQ3RJbXqMlnPWQ5w0ylMZ2kuRyS5mqQNKdJL1rrKrcvF/ZKKJZFC6Vc1RS4ZQruakNNSXtsUYTyHjX9gnDeI5bTelMVkub1rvbm6vLmoSkqzBnzSfP7Xt9mfAMWC0KefjgycfgyUSSsbhHDYs9nhCxPWRzYa+1BIOBGKGS+g0wW5AxBzXtJlFAG1q9+9Stdj6H8LDoz+tvf/lacAX366afxjW98Q8iZM844o+b7zNQfkphU0UzxGrt3FAS1iPro89Q0u/yxdUNFK6DljSRFQ9IKoSraOfMXIxrZn2VOMSxUWU6y3OXxiOVmjSLrndmrKcuPW1iQOT1ep2oePcXeFKs6p/e8el1AmFry3//932Jc/tOf/iT+L6etrU1MElSBvmbNGl0nPemkqpnjSJjGUq/YDGU0S7FKcxqqO+ZkkIo6kAha4PTmYbUDbRYHUnEL7G15TFtshSdQfqyYmiiX9ktt37UoJsuVNJMs5ypzphXxtzmRT6TLqjRXinCtqnMjYr2aqEazVLPSvAL5TmP6Uvsggjk3hvJt8CMOuuaTKstJlnssKbHcpIfpdakyH982V5szzVphzpiPrxw5R0xaOeYSlGMur+JOOvwY9s9HxtsJRy4Nby4Grz2HoKUNW60zEbH46p5frlVdTvsuTSzLGQm6NP+yyy4Tlwfp5eWXX8a5554rsgBJmH/1q1/FYYcdhtdee62m+8qYBxLUtYJyy/XIcopioWp3SZZT9bvevOwNa3fhsb/vxZDKz9He1YMDDlmOrt4+JBNxhIIj4pbu03xa3myy/MxDpuEjc3rEdGBPYNJ09Kx29Mn+vmlVm9cari6vnD179uCCCy7Ab37zG3HlUCn+7d/+DUuWLMGHP/zhkutedNFFopcNNSC67777uNp6CqNHoBZrNGkUZSW2EZHt6chh2gFpeLtyyCQtSISs4pbu03xa3ghZLv+ZSsnyUrnltXztubKcYdSRGmsWg6S5VrW5supcOdUKimWRY0iqkuyupNq8CpXqvdYoVjq3o98WQjzvxHDeJ27pPs2n5c2E6smJJqr85ury5oIrzJmKkEvzW1/4QNdjSJoP2tsQy4dAbSgoWWs4ZimcAjURP/nE0kbvAtMiUITL448/jq985SuiqvyFF17A+++/L5pRMEylsvyNgREhs5XI88tJlEuSvJzmkrTuo39+S/z/kuPmo8c/8ZsJSfGDO7sRDYdEg0/KLKcYFrNUlqvll1MkjVpmuYhbcTngddnhddlUt0fLiFU7guMNVulxeqr7q8FUFeWhUGjCfWr2IzX8KQcS2HTZ+de//nWsWLECW7ZsKbp+IpHAQw89hGuuuabktr/3ve/hox/9qJDw0lVFFM/1rW99q+z9ZZqXalYMkwy2TO8t2vyznCpzudDejTG421NIRS3IpS0i25ziWsod0rVEubQvavur+wRACVmup7pcC6PV5SzLGaa0NA+FU5pV5nqqzWsRCUP7pEfoG64yr6TavIqxLiTFexxRBO2FBp+UWU4xLCY5TDddpTlRi2pzluXNBwtzpmpcdeIC3dKcRuekzYPxw0qLuQ4wuaK8+am2WKmEu+66S1SVU4a53W4XHZt/+ctf4iMf+UhD9odpLVleKrOcZLnUgNKIJFfjnfcH8cbCDpzmnxwzQXK8LVBoeKnGU5sG8dLr200hfuXZ4vLqcpLe8spxLUikL+rxl5TmlI9ejde91WU5vZ4+jZMTRHbfstmzZ0+Yf+ONN4qmnEpIaN9yyy1Fn3Pt2rVCZIfDYXznO9/RtZ+PPvqoWJ+uGCrF9ddfP/7/I444QjQIvfXWW1mYM2VB0tc6R7txsRokmWN249JcHtHiaiOpVP6VEUZFubSfcpqlyaeZZHk9on4YpprSnFCK82pJ81IV61o55l5FcYgckqlK+alLmhN6xHkNMtBF5FYLZZXXUprXQpw3syy3ONpgcRb/u2Ip/fWpKWFhzlRdmktc/Z/rxS1FmozskwmNoE3HpfIsyJsHj8umWfVJZAyKFSNyZdmyZWUL81WrVokq87lz5+Ivf/mLuFSfqs1POeWUsrbJ7MfS1gUk9ldOm42CLO2q6jaHQkn8ZdsQ3tsTL1rV/N6aPYaiV6Ts9Wrz29U78Ksn1mJwwBxNkIqxrNcrZHixcYag5YfO7KhbpXkrinKjbN++HYHA/gayWidBr7jiClE5XowFCxaI3hKvvPLKpO1QtfkXv/hFPPjgg5PiWE4//XT09fUZ3vejjjoK3//+95FMJht28rYZmT7dgl27pmaUDcldx3ztk5BqFKsyV6OUNJcgeV4NSS5/3qrIcgO55bXETLLcDOzZnUfYov17G+N4qimPUpprVZtLsrtccV6OLNeKZXG37+9nokVJaa6U4XJ5bpJGoUx1xXkzi3KGhTlTh0gTSZxLeeGj0eR4lvhoJDUutSN1upRdDu0Py/KpLVaMyJVyiMfjuPbaa0Vl4ic+8Qkx79BDD8Xq1atx2223sTCvEkrJ28pyUY8s37wrhIEdwbIEdTFpvmnNdjw5sx2LOn3jFdaloCr4p/62c9K+mO09ItF9wvx2rJjZVVKWyyFp3uFyigp6SZpXG7O9Vo2CxnT5uK5Fb2+vmErx05/+FD/4wQ/G7+/cuROnnnoqfv/73wvBLWfz5s14/vnnxYnPcqAxv7Ozk2V5i0r9hiKLZTFaZV5KmhuR4HrR29zTqCwvlVte60af1YIbfjKtiJcK2JKpsqR5ueK8WrLcSJW5YViSm7rKvBJxzqK8NWBhzjQ8C/yjP31l0rxAwIVQqDoC/blvHVOV7TCtKVaMyJVySKfTYqIYFjk2mw25XPmNs5jiyIVvK8nGbUMxvLF7VFOWU245NfcsV5brqS5/4Zl3xe2lJ8zXLc2bAYpimRfwGZLlEl6nTVSm74lUr3Fcq312zcicORObl7e1FarHFi5cKCK05FDTzunTp+PjH//4pO3QCVGKdVm3bp24/8QTT4hmokcffTTcbjeeeeYZ/OhHP8KVV15Z05+HmTpMyDE3iJY0J0qJ80rQW1VeDVleSRTLVKsu984zdhUDw5QLRZxQ1Em50lwpwbXkea1EeVWrzJmmlObi+ViETylYmNcQaiYVDAbHL79tb283TQM0M0FCW02aV4PXrj2xJttlpi7btm3DyMiIuM1ms6JqkFi0aNG4bKHolptvvhmf+tSnhLQ/4YQTcNVVV8Hj8YhIlhdffBG//vWvcfvttzf4p2kd5JnUyvgRSQJXLh/zaHfl4bQBqSwQFAfzFkP7Vqksl6qYayHL5UivlZZAJ2lOz3XpxxbhwJ7AeBNMiaFwEmP7KokoY33D2l2q229VqFq9Ekz7+gS14w9aGTq5+cADD4grkehkpxI61lu/fv/VdA6HA3fffTcuu+wycSxIfx9ovL/gggvqvOetQS1jWWirqYAPOacd1lQGzlBUx6g+cd/MhjKWRVllriXN9VabV0uUS/uhpGiDzzrQ7NXlnF/OtIo0J7TEuZYYpzkJdzuyNhds2SRciaChMd1IjnmxKnOW5q0tzZmpAwvzGjE4OCgqjYaGhpDJZESjv56eHiHSalXJ2sxwFTjTLNxwww0Tcm2pmRtBl+qfeGLhBA2JExIoEg8//LCoPqRMXJLtJM1/+MMf4utf/3oDfoLWQ2qsqLyVI3K8KxCS3Z4cFndl0e3NwW7NI5OzYDhmxYYRG4bjE68eqAVyWa6FJMvpZ60WxeJZVr+6EXcC+D/Hz8GK/k5RZU3ifONQGA++MTAu8EmWV7PpZaWoncAgwX30rHb0lPhiVA9YljeOefPmCcGthK4QopgvLUiky2O9TjvtNDEx5ibRFcDY4lniNme3wZrJwj0SQseGHeK21lRVbBaJZTFKtarNi4lyI7LczNXl1YSjWJipgl5prlecS8S8PRjqWYqYrwc5qx3WXAbe6BB6htbDGxuatM1qwdLcHLA0Z2pB7b/lNyH0ZWlsbExcTku3al+eSsnyV199Fbt27YLX60V3d7e4pfs0n5bXYz+YxsDvW2tDVYb0nionSZYTdF8uT/r7+3H//fdjYGBAZJrTybTLL7+crzipIv2zunDQgX3q0wHTcNyKPhx/ZD/6u6iFd95QY0uS5cunZ9DflkM8DYzELOKW7tN8Wq4X+mzEIkEM7NyNcFDf+PDOwNgEWa5WXS5llhdr8EkittQkrad8nBYkzW95+O9i/9YMhURe+Z0vbsbTz60XVei0XLk/ZhPCJMvPXNYjssjV4ljoPaL3anhor+73rFzM9tpMJVnOmBtlJTf9FiYDPsR72sWt0d9KkuR7ly9BbFoX7PEk3CNhcUv3aT4t17NP9Lwxnw+hjnZxm6+hCDXSxFIpmdVEtJqwVgrvUtJb6zFmkeVa0PsUsrsx5GwTt3kTVJc34iRMs8Wx0JU7dGKToq6oz8Rrr71WdP0//vGPoliN1j/kkEPwX//1XxOW099zKoShuC26CpT6Cm3YsKHGPwUjSXN59Tb9Dlq6epHpmYmoq33SWFpKcpMsH5i1EhH/dNhTMXiiw+KW7tN8Wq4Hepawox0jrl5xm1eJZTECC9z6QIfmYzk3RnyzMAav4WMCxtycccYZIkaRxnIar7/0pS+JvkOleOWVV/DRj34UPp9PXPX/kY98RLgYI3CFeZUrw+kPLz0+FouJ9SUhRpEsdF/aPm2zmCzjCvXmhN83hqk/C5f2Y/H83nH5SVnURI/PjkxkDMm92xALjiHhSmPenDR2dVqxfsyNHdAT1ZIXleVeRx5DonC7MG5TJMtQLI8eb2H58EDpeBZnKozY5m3YkIuLKnWX04GOzm7MX7QUnd2TD+Rjyayo1l61I1hUlr/z/iB27xgR/1eT5UYkrFRRribNtU4yUPzLr54AZs4qfPEuVlFuFiFMJ1hmz2xHp8+Jg/o8mOH3qK43OjyEzRvXY2x0GNlMBja7veh7VglmeW0YxuzRLJVWhtMXaXp8xu2Ge3j/5fq2VEbcT3S3Y2zRTPS9Fio6qkcCAeyePROR9nbkbDZYs1m0BYPo3z6AtlDtK9SNYiSaRY5RaV4MLUmvS5aXgVp1+TDceK+jE6NOHzIWK+z5HDpTUSyIDsKOxghzri4vDTVjpmKTe++9V8jyO++8UzRppqs6p02bfHXFyy+/jC984QsiIvH000/H7373O5x11ll46623cPDBB4t1fvKTn4jmz3Tl6Pz583H99deLba5Zs0aIGaZ6uOjqvsTkKyBJmu9MtWGrfwmC7m5kLXbYejNwh/Zixsg6BOJDJavNaS5VlqcdXniig+Pjtj2bgi06iLivVyyfvW0I04qI9zFX98T9yGfQgzEsiG1CV7pwnF1OA1CuNK8tgzkf1md6MZT1IQMrrJbp6M6HsQQD6GnQmM5Ul5NOOgnXXnutkOVUgEg9gT772c+Kcb6YLKerPekq/7vuukt4ubfffntSX7lSsDBXqQwn2U1545RBSc36qDKc4hXoj3Mp6UnrkSxVyyun+3Rmg5bTeh0dHTXbD6b+8PvGMI1hXr9/PDNakuXUgLEnn8SWLR/AmY5jWk870hYr3KMx+D0hdLpjWAUvdgxnVAWxBGWWUwxLoQexUp1YEEoWltN6hUzzyZA89sONjuBOZDx5OLs60eb1IJNJY2hwNyLhEA454sgJAlaS5Y+t2/9FQSnLKfJk+0BQyPJKRbmex5WS5pXmptcLiuyRZHkxSJb//W+vI5GIoa0tALvDgUxa+z2rBJblDGOsMpxktzMchTWdRc5hE5XhqYAX0958v6Q0p8xy2g49fvKoDjjDMSHNaT2Xxsk//9J2bFm2BCmXC+5YFLZMFlm7DaGuLiR8Psxb937NpXmpxp/KLHMt9EhzU8jyKlSXkyxfFelEwuVEWyYOez6LjMWGQVcAYbsbC71RdMTCTSnLW726XOoD8eUvf1ncJ3H+n//5n6Ih8zXXXDNp/X/5l38RsoR6CBHf//73RQPmn/3sZ+KxVORG0v26667DmWeeKdah/kJ9fX3485//jM9//vN1/glbH6lhprxKe8TRhfe7jkAk74QvFYI9l0bG6kCkYwa2tXVizrZXJkhzZbU5yfOkm67w6YFTJa9cjOmJkFjuCwSApHocU8jTg23dK5Cweybsx5CnDxF/AIeG/zYuzfU2/5TD0rx2svy11GzE804ELHE4kEXaYcOeVAdC8GAFNrI0bwEuu+yy8f9TtC2N+XQClFwbOTetx3zrW9+a8Pdh6dKlhp+bI1k0KsOpIpzOPkiV4TSflpe6FJsafFJlsdYb53Q6xXJar5b7wdQXft8YpnG0+wpfNqlSmEQ5ZVEf0O1HYmgr7Ehh5vQ+dHe0ob/di0XT2tE3rQe9ARuOnEt51oW8cxLBajKYGnxSNXg6q/7cNJ+W03pyJm4rjxmWEVhzKdh87bA7C+OD0+lCW6BbCNktm9aPjw9DoaSINmmELC9FJRLeDFKY8ssD7e6SspzeC6osp/ems6sHzn1jOt3SfeV7Vgwz5bczTDNDv23ZD+2vDKeKcEs+P14ZTvOpMrzUbyU1+BSV6RoDuzWdQd5uE+up0T/dIirLSZb7gkHY04X9oFu6T/P3zC7shxEZWrHAVAhl1efIaMvsUhEt5VJs27obfOr42UpB78f7lk4kbE50piNw5rPiizDd0n2av71nel0v5efKcn2kUim8+eabIjJFgv4m032qIlSD5svXJ6h6XFp/8+bN2L1794R1qOCJCpy0tslUB0k20+/aB96FSFg96M2PwZlLwYq8uO1IDAl5Pdx/UNHfSZLnAY8TDrsdAcvkDHSfPQ+/JSmWZ2zqv2+0/Z1dy8Tz0fPK96MtukfsH+1nqbGBqsyLLg+NcURLFaFDcKosJ1neY4nAZcnCaoG4neZMIQ4XNmAGx7O0GCMjI3jooYdw7LHHajrXvXv3ikJWuvqI1qMToSeccAJeeuklw883pSrMpS+2IZWKD8qa3rZtm8gvI7mpxGazieXU9EmrMpwgEU5/1Gl7JEuVJBIJsZzWq+V+MPWF3zf9SJ/7ck8ehEtUbJVazrQO0mcoYEng+FndmN5WkKAeVx6Z8CB2DmyH2+1BXPY7SX9WO205xL0O5LJRHDC3De9tiO9vlOkuCPR8ZF8VSSKHeCINZIFMdnIFucOWRzxRWC+fkZ2DTu/PR+vrdMCdGkUsHUAyEUfMlgMy+//8ZvM2DOzYjv4ZO2B1t+GD4QhWDwSRiu03Cen4RGG+5YMh7BkY1Wzwmc8kUCvyowOwtHXpX3/fa9lQ9r0fuZQF2aQL6fj+CJZ41IZI2AkX9v/NjoSCqp8fCavVPv6etQXaEQknEYuEkYrtr5rKJKKIDA8hL/ssaFHL96sqZNVP8hP5bOELaiUnhHlcZySkz1E0N7k3RNzrw6DHA3dqDInMZNOaHQliLOCBq80NV1j7RFUykUQqHkcWOdjUtuNwIBuPI5FIIp+fKNX7+i0Ychf2wxkcQzw9+fG5YBB7PR4ESOyrbJ8IzGhDODVxWSY5uamzgxpmyLBGJwohS0QxdjgnjjcWq/rfCGU0y/jzoRMjidK5oHrpcs9AKBXTlOVqv9n5oMrzK37O/O7JJ2BzitcqvXViJWkITuyw2mCPBhFXvK9i/dFh7Ha40Gt3wpfQn3Hq6rdjeKf2GKlG94zC35twRuNsvEHUPk+lUPu8SYSTmYrG9Vg+p2u58rswfXdW+/5MV2dns1khPeTQfSpIUoNkuNr6NF9aLs3TWoepHOkzFE4pPhNuLwZjVgzk/PDERhDPy455932WLZlh7LYFMM3fjbZ0COHIZCFOJMmvJOIIZa1w5Cb+LsZSQNrmQjoRF+tFMpM/0zFnO/ba2uGLDCOem/x7ZLGMYMDmx/RcGwKZQrVyKqnxGd87DEd7ie/6g8Nw+JvrCg8zQpnl25IOeCxBxCyTx1JHPottGTdm5V1oh/rfoalCOJmtaEwPhcO619E7rhvl29/+trhCiFzb0UcfjSeffFJz3Q8++EDc3nTTTbjttttw+OGHiyuITj75ZLz77rtYvHix7uedUsI8vO9NnD17dqN3hWGmPPT7SJUceqGrM6h55gGL5pZcl9aj9ZnWRhrTb//iR3B7jZ6DLvh+vMJtbN03MY2HlAvp+7WyeX9s4P5M5TGd4HGd0RrXP7ml8GVnEu++XfmT0Pfmx94p77EfVHE/mKmLxse7VY7Vz9+9ueS6bW1tk76T33jjjUJwMK03pi+7T+sqkT9X4Vno5NiTdX58MYHIJ1zqx4uN3oGmotwxffYBK3Stb2Rcp6iUW265pej21q5dK3oBEhSvdf7552Pr1q347ne/i3POOUdIc7W+kLl9RRdf+9rXxmO8jjjiCDz77LMixot6W+hlSgnzGTNmiApfv99ftOGmUegsCn0waNuUUd4sNON+8z43/z7TmU0arOn30QjUfIcun6QrNPQM7tysp/Wp1ZhO8O9tfWjGfW7W/a7VPpc7phM8rjNK+Fi9ufe5Wfeb97n+x+r0HMrfca0qxJ6eHnG17p49eybMp/skc9Sg+cXWl25pHjWSk69D1YhMdeBj9YnwPteHZtxnMx6ruw2M6UbH9SuuuALnnXde0e0tWLBgwt8BmpYsWYIDDjhAvE6rVq3CMcccM+lx0ph+4IEHTphPj6PUByNMKWFOWWezZs2q2fbpQ91Mv5DNvN+8z829z0arEOWDNgsTpl5jOsG/t/WhGfe5Wfe7Fvtc7phO8LjOyOFj9dbY52bdb95ncx6r0wnT5cuXi+pAavQmVRDS/Ysvvlj1MSRRaPmll146Po+afkpyZf78+UKa0zqSICdZRbm3F154YVX3fyrDx+rq8D7Xh2bcZ7Mdq7trdJxOff5oKgepglyrL+S8efPEyYH169dPmP/+++/j4x//uKHnmlLCnGEYhmEYhmEYhmGY5uHyyy/HueeeixUrVmDlypW48847EY1Gxy+3p8vzZ86cOX6p/SWXXCKavP3zP/8zPvGJT+Dhhx/GG2+8gV/84hdiOVVBkkz/wQ9+IPJsSaBff/31QrJIUp5hGIZpLHQS8/XXX8fxxx+Pzs5ObNq0SYzVCxcuHD8BOjAwIPLJKaec/j7Q+E4RLhQHc9hhh4mTog8++KDoefEf//Efhp6fhTnDMAzDMAzDMAzDMKbk7LPPxuDgIG644QbRlJMEyFNPPTXetJMus6dqZoljjz0Wv/vd73Ddddfh2muvFVL8z3/+Mw4++ODxda6++moh3b/61a9ibGxMCBnaJl/1xDAMYw68Xi8eeeQRIb9pvKa4ldNOO02M7VLcSzqdFtXk1BBUgk6IJhIJXHbZZRgZGRHinK4yItFuBBbmVYDeKHoDq9H9tZ40437zPteHZtxnhpnqvwO8z/WjGfe7GfeZYaby578Z97lZ95v3uTmg+BWtCJYXXnhh0rzPfe5zYtKCqhC/973viYlpPprxd4D3uT404z43837XkkMOOQTPPfdc0XUogoXy09Uai9JUCZa82pYZhmEYhmEYhmEYhmEYhmEYZoqx/7olhmEYhmEYhmEYhmEYhmEYhpnCsDBnGIZhGIZhGIZhGIZhGIZhGBbmDMMwDMMwDMMwDMMwDMMwDFOAhXmV2bJlC84//3zMnz8fHo9HdGGl4P5UKgUz88Mf/lB0E6cutB0dHTAjd999twj0p87lRx11FF577TWYmb/85S/45Cc/iRkzZoimMtSZ3ezcfPPNOPLII+H3+zFt2jScddZZouMww0xVeEyvLTyu1xYe0xlmMjyu1w4e02sPj+sMMxEe02sLj+u1hcd0c8PCvMqsW7cOuVwOP//5z/Hee+/hjjvuwL333otrr70WZob+oFAX8QsvvBBm5Pe//z0uv/xy8cfvrbfewmGHHYZTTz0Ve/fuhVmJRqNiP+mPTLPw4osv4qKLLsKqVavwzDPPIJ1O42Mf+5j4WRhmKsJjeu3gcb328JjOMJPhcb028JheH3hcZ5iJ8JheO3hcrz08ppucPFNzfvKTn+Tnz5+fbwbuv//+fHt7e95srFy5Mn/RRReN389ms/kZM2bkb7755nwzQL9qjz76aL7Z2Lt3r9j3F198sdG7wjCmgcf06sDjev3hMZ1h1OFxvXJ4TG8MPK4zzGR4TK8OPK7XHx7TzQVXmNeBYDCIrq6uRu9G00JnX998802ccsop4/OsVqu4/8orrzR036bCZ5fgzy/D7IfH9Mrhcb0x8JjOMOrwuF4ZPKY3Dh7XGWYyPKZXDo/rjYHHdHPBwrzGbNy4EXfddRe+9rWvNXpXmpahoSFks1n09fVNmE/3d+/e3bD9anXo0rZLL70Uxx13HA4++OBG7w7DmAIe06sDj+v1h8d0hlGHx/XK4TG9MfC4zjCT4TG9OvC4Xn94TDcfLMx1cs0114imAcUmys+SMzAwgNNOO01kU11wwQVNsc8MI0FZWu+++y4efvjhRu8Kw1QdHtOZqQaP6Uyrw+M6M9XgcZ1pZXhMZ6YaPKabD3ujd6BZuOKKK3DeeecVXWfBggXj/9+5cydOOukk0fn4F7/4BZphn81KT08PbDYb9uzZM2E+3e/v72/YfrUyF198MZ588knRZXrWrFmN3h2GqTo8pjcWHtfrC4/pzFSAx/XGwWN6/eFxnWl1eExvLDyu1xce080JC3Od9Pb2ikkPdGaTBuvly5fj/vvvF1lPZt9nM+N0OsVr+eyzz+Kss84av1yF7tPAwlQP6o3xzW9+E48++iheeOEFzJ8/v9G7xDA1gcf0xsLjen3gMZ2ZSvC43jh4TK8fPK4zUwUe0xsLj+v1gcd0c8PCvMrQYH3iiSdi7ty5uO222zA4ODi+zMxn4rZt24aRkRFxS1lVq1evFvMXLVqEtra2Ru8eLr/8cpx77rlYsWIFVq5ciTvvvBPRaBRf/vKXYVYikYjIUJPYvHmzeF2pgcOcOXNg1suAfve73+Gxxx6D3+8fzydrb2+Hx+Np9O4xTN3hMb128Lhee3hMZ5jJ8LheG3hMrw88rjPMRHhMrx08rtceHtNNTp6pKvfff3+eXla1ycyce+65qvv8/PPP583CXXfdlZ8zZ07e6XTmV65cmV+1alXezNBrp/aa0mttVrQ+u/S5ZpipCI/ptYXH9drCYzrDTIbH9drBY3rt4XGdYSbCY3pt4XG9tvCYbm4s9E+jpT3DMAzDMAzDMAzDMAzDMAzDNJrGhDsxDMMwDMMwDMMwDMMwDMMwjMlgYc4wDMMwDMMwDMMwDMMwDMMwLMwZhmEYhmEYhmEYhmEYhmEYpgALc4ZhGIZhGIZhGIZhGIZhGIZhYc4wDMMwDMMwDMMwDMMwDMMwBViYMwzDMAzDMAzDMAzDMAzDMAwLc4ZhGIZhGIZhGIZhGIZhGIYpwMKcYRiGYRiGYRiGYRiGYRiGYViYMwzDMAzDMAzDMAzDMAzDMEwBFuaMqchmszj22GPx6U9/esL8YDCI2bNn45/+6Z/E/W9961tYvnw5XC4XDj/88AbtLcMwDFMKHtcZhmFaBx7TGYZhWgce0xlGGxbmjKmw2Wx44IEH8NRTT+Ghhx4an//Nb34TXV1duPHGG8fnfeUrX8HZZ5/doD1lGIZh9MDjOsMwTOvAYzrDMEzrwGM6w2hjL7KMYRrCkiVL8OMf/1gM0h/96Efx2muv4eGHH8brr78Op9Mp1vnpT38qbgcHB/HOO+80eI8ZhmGYYvC4zjAM0zrwmM4wDNM68JjOMOqwMGdMCQ3Wjz76KL70pS/h73//O2644QYcdthhjd4thmEYpkx4XGcYhmkdeExnGIZpHXhMZ5jJsDBnTInFYsE999yDAw44AIcccgiuueaaRu8SwzAMUwE8rjMMw7QOPKYzDMO0DjymM8xkOMOcMS333XcfvF4vNm/ejB07djR6dxiGYZgK4XGdYRimdeAxnWEYpnXgMZ1hJsLCnDElL7/8Mu644w48+eSTWLlyJc4//3zk8/lG7xbDMAxTJjyuMwzDtA48pjMMw7QOPKYzzGRYmDOmIxaL4bzzzsOFF16Ik046Cb/61a9E44l777230bvGMAzDlAGP6wzDMK0Dj+kMwzCtA4/pDKMOC3PGdHznO98RZzOpUzMxb9483Hbbbbj66quxZcsWMW/jxo1YvXo1du/ejXg8Lv5PUyqVavDeMwzDMEp4XGcYhmkdeExnGIZpHXhMZxh1LHm+zoIxES+++CJOPvlkvPDCCzj++OMnLDv11FORyWTwP//zP+LMJ62rhPK2aIBnGIZhzAGP6wzDMK0Dj+kMwzCtA4/pDKMNC3OGYRiGYRiGYRiGYRiGYRiG4UgWhmEYhmEYhmEYhmEYhmEYhinAwpxhGIZhGIZhGIZhGIZhGIZhWJgzDMMwDMMwDMMwDMMwDMMwTAEW5gzDMAzDMAzDMAzDMAzDMAzDwpxhGIZhGIZhGIZhGIZhGIZhCrAwZxiGYRiGYRiGYRiGYRiGYRgW5gzDMAzDMAzDMAzDMAzDMAxTgIU5wzAMwzAMwzAMwzAMwzAMw7AwZxiGYRiGYRiGYRiGYRiGYZgCLMwZhmEYhmEYhmEYhmEYhmEYhoU5wzAMwzAMwzAMwzAMwzAMwxRgYc4wDMMwDMMwDMMwDMMwDMOAAf5/hiDRr5GNN3QAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 21: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 22: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", + "\n", + "\n", + "Iteration 23: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 24: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 25: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 26: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 27: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 28: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 29: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 30: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 31: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", + "\n", + "\n", + "Iteration 32: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 33: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 34: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 35: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 36: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 37: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 38: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 39: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 40: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 41: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 42: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 43: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 44: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 45: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 46: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 47: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 48: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 49: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n", + "Iteration 50: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", + "\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABcwAAAEiCAYAAADETJH2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQe8JFWd/U91zv3i5GEyM6QBJAkYQFFE1oQi6rqAAVcW1FVWBVcBxYy6KPoXUTGsumtCDCiKBF0lOaNIkHlMZIaJL3d6nev/Obdf9VTXq8653/1+Pj09XVXdXV3d79atc889P0VVVRUSiUQikUgkEolEIpFIJBKJRCKRzHMs7d4BiUQikUgkEolEIpFIJBKJRCKRSDoBKZhLJBKJRCKRSCQSiUQikUgkEolEIgVziUQikUgkEolEIpFIJBKJRCKRSHJIwVwikUgkEolEIpFIJBKJRCKRSCQSKZhLJBKJRCKRSCQSiUQikUgkEolEkkMK5hKJRCKRSCQSiUQikUgkEolEIpFIwVwikUgkEolEIpFIJBKJRCKRSCSSHFIwl0gkEolEIpFIJBKJRCKRSCQSiUQK5hKJRCKRSCQSiUQikUgkEolEIpHkkIK5pOv49re/DUVRsGvXLnQC3A/uz+c+97my215//fViW4lEIml2m8S2shrOOusscauESy+9FCtXrqxxD+cfPFY8ZhKJRNJqeD5g/7OX4Lnq2GOP7Zi+vLGNv//++8U2vJdIJJJeQfZnJfMNKZi3EXakKrnJzlZtaB1a7ebxeHD00Ufjwx/+MEKhULt3TyKRdDn/7//9P9G2nHbaaehF9u3bJ9rRRx99FJ2CJmqY3Z773Oe2dd8eeOABcbympqbauh8SiWQu27dvx7/+679i9erVcLlcCAQCOPPMM/HFL34RMzMzbd23X//61x0raH/yk5/EHXfcUVP7bLVaccQRR+A1r3lNR51H2sUPfvAD3HTTTe3eDYlE0uGmwGK3hx56KL8tH1955ZVt3V+JZD5ga/cOzGf++7//u+Dxd7/7Xdx9991zlh911FEt3rPe4qtf/Sp8Ph8ikQh+97vf4ROf+ATuvfde/PnPf5Zub4lEUjPf//73hdPikUcewbZt27B27Vp0AitWrBACkN1ur+p5bB+NgvlHP/pR8RlPOOGEgnVf//rXkc1m0S7e+MY34uUvf3nBsuHhYbRbMOfxovOmr6+vYN3IyAgsFulRkEjawZ133okLL7wQTqcTF198sXAmJ5NJ/OlPf8L73/9+PPnkk7j11lvbKph/5StfaZpozvOBzWarWTB/3eteh1e/+tVVt8+ZTAZPPfWU6If/5je/EWKP8VzSjdB4c/XVV5fc5gUveIE47g6Ho0Awf+KJJ/Dv//7vLdhLiUTSrXzsYx/DqlWr5izvlOsMiWQ+IQXzNvLmN7+54DE7khTMjcsl9cGO/tDQkPj/O9/5Trz2ta/F7bffLo736aefbvqcWCwmHOkSiURixs6dO4VAyraErkWK59dddx06AQ4E0kFZLfoL+3JUK8Y3muc85zldda6kUCeRSNrTVr/hDW8QA4k0SyxevDi/7oorrhCDnRTUu4V0Oi0GK6tpr2s5HzSyfaaT/5WvfKUQzr/2ta+ZPicajcLr9aIb4OBDuQEIDpC2+rhLJJLe4LzzzsPJJ5/c7t2QSCQykqXzYQfyqquuwvLly8UF9/r160W+nqqq+W0uuOAC0TnV84pXvEKIJr/4xS/yyx5++GGxjC4P/bQfOq3f9773CXceO6ucOjk6Olrweps2bcK5554rhGe32y1GPd/61rcWbMMOPKcaHnPMMaKTuHDhQiEkTU5OFmxHt+I//dM/CWfPqaeeKrblFFk67I3Q9fOiF71IvOeyZcvw8Y9/vG5XI19Pu4jS5yBu3rxZOEIolH/oQx8S6w4dOoS3ve1t4rNwP48//nh85zvfKfra//Vf/yUuyri/L3zhC4WTpBK+973v4aSTThLPGxgYEBd3e/bsKdhG28/HHntMvDb3kyPNP/nJT8T6P/zhDyIagq/B38nvf//7mo+RRCIpDQXy/v5+nH/++WJQjo/NYDzHe9/7XtHusQ1nO0aH49jYWH6bZ599Vrj32P4uWLBAbP/b3/52TiRXsdxAY/a4WYb5gQMH8Ja3vEW8P/eDotGrXvWqgloQ+tfh+55yyini/3yeNh1Ue02zDPNKzlf6aaSc5s82jdvyvHHXXXehERTLYjfusz6zlu7SNWvWiH3h5/7LX/4y5/lbtmzB61//enGu1NrZ//zP/xTr6AylU5Xw/KgdL+34mn13O3bsEK5XtvlszxkpYxTutBzcH/3oR2J2FL8/note/OIXC6FPIpGU5rOf/ayYYfjNb36zQCzXYD/qPe95T4EgfcMNN+TbA/7tsk+YSCRq6sumUikx82TdunVim8HBQTzvec8TBhnCdoHucqKfem9so9i/1vbpH//4h3DIX3vttaLvGAwGxfnj+c9/Pu67776yGeZaZCHbEG1GDF+DbT0NI/rnsV1nv1fbr1qya439bu36g/3Wf/u3fxPnPbZt+rgznhP4WZcsWSIGNopFXbHvfsYZZ+SvTW655ZaC9dUcp0r78pXUIzJmmPOcxPb9mWeeyR9L/ob42+Q+6X+D+r4BY20+9alPlXwviUQiMYN97LPPPnvOcmopS5cuFdcvGjzPsC3lOYptH9tMTWMoRbH2sFjNOepQbIPZ7vn9fnEdRb1HIulUpMO8g6HIQEcGO3UUbTmNkSIKL8r37t0rOnSEjc7Pf/5zkcvNTEY+jyI43Q3/93//J16D8P9cRqeHnne9611C+KE7ko0aO+UUM374wx/mReOXvvSlQiTgFER2rLkdnZV6KI6zcWSH+93vfrfoGH/5y1/G3/72N7E/ekciO+lspPm5LrnkEtx2222iE87GmZ1kTeBhI8+LF74vG1aKGmzE682xJDwhaIyPj4vRXArVdMVQIOdUSnZwua88HuyI//jHPxb7yY67sXPLi6RwOCw69vF4XORi8iLh8ccfF69XDIogH/nIR4QQ8/a3v10MVtx8881CvOex00/t5+ADL9C4nxRa6Nbh/ynWcYonHfRvetObcOONN4rjS9GdJyOJRNJY+DfHwUq6/Dj9nH+LFFk1kZnwQpjtM6ekc4CRA5sUyjmQyQthDkCynaH4uXv3btFuUhxgLBedkI2EM2vYIWV7z4t0tusUbPi+ZsU7GQXGKaEUGt7xjneIz0HYma7nfKVBkYnnEIolbKO+9KUviX3k/ujb5mJQ1NEPOhCKIbU43zlNnm03z2Hs3FNg43dLQVt7PQ5U8hjwMY8HjxnPJb/85S9FG87tn376afzP//yP+KzarKZiMTEHDx4Ux5Kfg987PzNFKR5DXqBw4FrPpz/9aXH+/o//+A9MT0+Lffznf/5nMRAukUiKw79RCtnF2i4j7Ifxb5F9KA4A8m+MgiXb8Z/97GcF21bSl6WYwOfzdSmss69OE8pf//pXvOQlLxHtDuOvzCIZNb71rW+JfiXbHorIHGTj63zjG98Q55/LLrtMtGEcFKC5hTFhlUSfsN/Jvi33j/vD16N4/ZnPfEas5/5o+833JhTtG9HvJmz/2UbyPENhXjteHGA455xzcPnll4s4K+38aryWYJ+Y0S/8HDwOHFjkc3he1kw91R6nWvvy5eDgKttunvu18yHjInlje89rri984QtCINfg+YTnVrb1Eolk/sC2wtjHZf+0kv6xnosuuki0qdRUFi1aVNAH53mHGoIG2zr2QdnecKDxf//3f4XW8Ktf/UqI2o2A5xSeK9n+8jzDPjDbdw4iU/Mwux6RSNqOKukYrrjiCtrw8o/vuOMO8fjjH/94wXave93rVEVR1G3btonHf/nLX8R2v/71r8Xjxx57TDy+8MIL1dNOOy3/vFe+8pXqiSeemH/8rW99S2x3zjnnqNlsNr/8ve99r2q1WtWpqSnx+Gc/+5nYju9TjP/7v/8T23z/+98vWH7XXXfNWb5ixQqx7I9//GN+2aFDh1Sn06leddVV+WX//u//LrZ7+OGHC7YLBoNi+c6dO0sez+uuu05sNzIyoo6Ojortv/a1r4n3WbhwoRqNRsV2L3zhC8V2t9xyS8Hzb7rpJrH8e9/7Xn5ZMplUTz/9dNXn86mhUEgs4+tyO7fbrT777LP5bbnfXM7jadwnjV27dolj/YlPfKLgvR9//HHVZrMVLNf28wc/+EF+2ZYtW8Qyi8WiPvTQQ/nlv/3tb8VyfscSiaSxbNq0Sfx93X333eIx289ly5ap73nPewq2u/baa8V2t99++5zX0NpcrZ350Y9+lF/Htmnt2rVi+X333VfQdl5yySVzXottA28aWpuk/f1PTk6KxzfeeGPJz2V8He3cYtaOcD+4P9Werwi3czgcBcv+/ve/i+U333xzyX3UPpvZTTtWxs9RbJ+11xocHFQnJibyy3/+85+L5b/85S/zy17wgheofr9ffeaZZwpeU3/u5PEtdm4yfnfa+Y3nTo1wOKyuWrVKXblypZrJZMQyfiZud9RRR6mJRCK/7Re/+EWxnOcKiURizvT0tPg7edWrXlXR9o8++qjY/u1vf3vB8v/4j/8Qy++9996q+7LHH3+8ev7551fV/ze2UYFAQLy2nnQ6XdAmaG09+7dvfetbC5bzNdj/NPZFjdu95jWvEe2hHq/Xa3reMUPb349+9KOi333gwAH1/vvvF9ceXP7Tn/604Prjec97nvgcGvyMPDe89KUvzbeB5Mtf/rLY/rbbbpvTJ/785z+fX8bjccIJJ6gLFiwQ/fVqjlM9fXmzNl5ru/XncP4O9OcgY5/9N7/5TcHyjRs3mp7LJBJJb6K1jWY3nlv0cBnPHaWgBmLWt/63f/s3oWXEYrH8Mv3/CdvQY489Vn3Ri15Usq0zaw/1n0XrE7OP29fXp1522WUF2/E8QW3HuFwi6RRkJEsHwyJAdBrQfaaHjhe2k1q0yoknnigcCn/84x/zTnJt2j8dIxy94/YcTdRcgnroGtFPpeE2LNTDaYNEczhzhJFTS82g85ruPrplOCKq3eiy4b4Zpz4effTRBftChwmnt9PRp//8nKJOZ4t+u2qdFnxdPo8uGjp5OP2W0yL1GeV07NAZr4fvz9FYulI06Gzh90HnKKeS6mGkAqc3aXC/GZHC1ykGHZacFkV3jP648X05fdd43Hgs9aPB/Gz8fugG5XtpaP/XH0+JRNI4dzmdZto0R7afdHHQjcG2U+OnP/2piHEyuoW15xC2D4wJ0E+LZNukufkaAWfl0HHHqeHGiKxWn6806B7UOxU3btwoZkhV2mbx+NCRqb/xWNcCvzvOstLQzk3avnDWD8+vdCweccQRBc+ttXA0jxfPEXTV6Nt3fi7O4GLkgh6en/SZxcZ9lEgkc6G7mFQ6007rrzGm0NiOEWNkUiV9WfbROLtn69atNX8Ozr4xzlZhe6u1CexHTkxMiBmZzL1l378SOCtRDz8LZ1xqx61WOGOV+8u+LGdq0mFONyFn4uih41vvqGaUIJ2NnDGpL5LM7Xh+MB5/5oizX6/B48HHnEHFqJZajlMtffl64fmQs8v00W6MgeHMpm6q1SGRSBoDY7qMfVxjP7oSjjzySDGLRksNILxO4UxGxvfqZ+3r/89rBbrceU6o9HxSDn4GztCnrqLXPNhGs40tFZMlkbQTGcnSwVCwZgfK2NGnOKqtJ2xoWLySQjnhPRs4XoizUWRxS4o77CSaCeZGAUATDjRhhfl97KxziiSnEbLzyw4loz+0Qma8EGDDyqmcZrDzWuo9tffVizn8fHoRWIMXI9VA0YodbYrdHEgwm07KzrGxgBLfn6K1vtNudvw1uK3ZiYpTRIvB40Yxyey5xBgvwP03CjQcqGBmsHEZaZY4JpHMV9imUhinWK7lsRK2VZ///Odxzz33iAgrQpGAbWcp2I5wEM/4d11tO1cKttMUKyj68FzAgUhGO3FQVT9FsxXnq2rOAaVgm0mRoRGUOwdq4hezIBtFsfOb/njp36/cPkokkrmw70cYsVEJ/Ltjn49tsh62kxS+a2nHGG3FehHsD/Jv+mUvexn+5V/+RQwSVgoNH2YwOobnHdZX0Btaim1vpFS7oh27WuDAH6fy81jyuGl55EaM+6kdX+P5j/1zxuoYjz/POcZCoTzOhAOPPNdVe5xq6cvXC48TzUCMJqDJiYPmFM+Zec/jKJFI5hccqGtU0U+aQliHg/GI1DtonqEuw+V6aIxkrbhHH320oGZHrcYQI9qgsVbTwkg95xyJpJlIwbxHoDjOHFXm7VEwZ1YeO6nsnPOxlrtnJpjr3R16tEJtbCg5EknhnVmQzKWl046dTy6jK46uDYrlxQrfmTljSr1nI2EWuJYnW4x6c9FrhcdNK8Rqdkx4bCs5bq08nhLJfIbZ4vv37xeiOW9G2AZqgnmjKdZppYhfrA3QoGOPbhIW2mQbzroJzK3l5+EspVbTzDaLx8nsdfTu/1btS6Pohn2USDoNXoBTVK20AHu1AkElf5fsg3LwlLWGfve734k8bZpPWJyS+eCVYNZHZbF45qXTwMJaEeyDawUitczwRux/LVQ6oNmKvncjjlMr4AA26w/xHE0HJmtrcGBbM8BIJBJJLVAYv+aaa0QaAK8FOPjHdoWDtxpazTuer1h0mTNfadpj/Qy2RbVemxg1Dy3H3MyswxlDEkknIn+ZHQwrtHN6Ip0xetceHRLaeg0K4ZzGyAIxHEHUhHE2fJpgTodEPQVr6NTgjcI8G0+6ISgYscNP1zb3lQVFG9UB5uczm8LKAkCtgO/P6ZBs4PUuc7PjT8z2lUXgShWw4HHjhQldLporRiKRdC4UxHnBzemSZhFLLApHIYTtIP++ywk1bEe4DdsBfafTrJ2j+4/TGY3QdUf3XTm4P3SZ88b2itM0OfBJQcGMalwl1Zyvmg2Pk1lUidGdWCnasS33XVZ7vMy+43YcL4mkl6HoyILxDz74oJiNWQr+3bHPx/ZRm+2hFell21vr3yWLdDJWiTdG+rFvzkJsmmBei4OPRha2TTzv6J/POJRG0ih3YSVox5dto/6cxusbzugyivAsWsdioXqXOfvdROt7V3ucaunLN+JY0uDEwWv2MTiblAWwb7755rrfUyKRzG+oMdCxzliWK6+8UrSFHEDUz/rhbHzOaKGhRr+cgnk5tJlJPEdqMb5mfW5thj+voRo1Q1QiaQUyw7yDYeV3js59+ctfLlhOZwo7Xeedd15+Gad2cySQ0+7ZMef0R0LhnC5w5m2bucsrgVMzjW4Traq8NmWHGdzc1xtuuGHO85kVaCbyVPL5ue+sYq/BLNliLvZGw/dnVWl97hc/CzuwdH4zqkYPXSEcrNDgfj/88MMF35MR5jnS6cK4G+Mx5mNmSUokks5gZmZGdDQpwDBz3HhjR5SC8S9+8QuxPeNY/v73vwsR3Yj29852hhf9vKjX4JRsCjxG2Nlkm0jxQD+Fcs+ePSX3m6/H2UfG16KwrZ92aUQTISppv6s5XzUbfjYKzzxfaPB7+POf/1zT63GGFAWu2267TYgYevTtdrXHi+cIingaFH74vVOYYTayRCKpnw984APib5PiNIVvI3QZf/GLX8z/XZKbbrqpYJsvfOEL4v7888+v+v2N/Tj2Hxn5om97q2k7jO5wfRvEPqe+TWkE3Lda+vC1QBGF8Stf+tKXCj7XN7/5TRH7aDz+7JN/7Wtfyz/muZGP2WazhlItx6mWvnw1x5KfoxiM6uEsBP7+BgcHW3relEgkve0y5/UD+7HMDTfGsbCdZF9d7wpnrBXbw3JoQrhWS0/rzzIKS8+5554rZn198pOfNK2Jp++zSySdhHSYdzCcPs+cXMarsNFiQTN2pDitk1Nq9FnczLtj55CNIZ+nuRh4kc9Gi7daBXM2eJyew8J1fE8KQl//+tdFo6ddXFA8ZqEdTnFk9hUjCSjg06nBKUC8GNEXtav0IofTdjhl6D3veY/oaFJM0JzfzYYZjOx4cyoniwdRxKCoRdGFnVljVi8vgBiNc/nll4sLIa3Dy89RDB5P5oVxqhS/Y4748nXppKHIxn34j//4j6Z/VolEUh4K4Wz/OG3RDM7A4YU6B/XYGeX0b7YZzCBljBXbaNaS4OvQhc42ncXMKDJzOjbbGU6DZLunL0qsQcGHr8c2kYOUFHroDjery2B0x734xS8Wz6EQy2mPbF8oHumLCBvh69Itwn1lu8Q2mIOzZrmv1Zyvmg2PNQUuds7f9ra3iaxGfgYOJNdazI4CDtv35zznOaJd5jHg52QROp7ziCbQ8BjwuPIcyONizNglV199tZgRRkGEhVI50M1zLdt+On2MtTMkEkltsO3hrEi2yXSNs62lm5fi6gMPPCD6qOznEbZbl1xyiehrUiRm35aCKf822T/TCj1XA9tc1v5h+8C/802bNol2nAOsGlrbwbaA7RbFi1JtM+HALQdw2TenkMy2g+0c348u9kbBfePsIbapjLdh22dWf6ER8PzJ/jBNJDzP8VxLtzmvQU455ZQ5BTC5PzQKsS3mLE0aXNge8/vTagBVe5xq6ctXcyy5jywqy8/DwROeIzRYG4rvw/Mz399Yx0gikcwPGNWqzTjUc8YZZ1Q0o9QI+//UE3jjecjo8GbbyDae7S7bIfabOZOW7WE5zYWaD+thsL/N6x6evyjMsz3Xm0yoG7FOAwcG2ZfmOU7bhn1pphQYTTcSSUegSjqGK664gvaHgmXhcFh973vfqy5ZskS12+3qunXr1BtvvFHNZrNznv/+979fPP8zn/lMwfK1a9eK5du3by9Y/q1vfUss/8tf/lKw/L777hPLeU/++te/qm984xvVI444QnU6neqCBQvUf/qnf1I3bdo0Zx9uvfVW9aSTTlLdbrfq9/vV4447Tv3ABz6g7tu3L7/NihUr1PPPP3/Oc1/4wheKm57HHntMLHO5XOrSpUvVG264Qf3mN78p9m/nzp0lj+d1110nthsdHS25HV//mGOOMV138OBB9S1veYs6NDSkOhwO8Xl43PRwP/g+/F4+//nPq8uXLxfH6fnPf77697//3XSfjPz0pz9Vn/e856ler1fcNmzYIH4PIyMjZfez2PHk+/A1JBJJY3jFK14h2qJoNFp0m0svvVS01WNjY+Lx+Pi4euWVV4r2i23IsmXL1EsuuSS/njzzzDPqK1/5StXj8Yi25j3veY961113FbTDGmxj+FpsY84880zRDhvbTq1N0toqvhfbArYrbF+CwaB62mmnqT/60Y/KtsE///nP1aOPPlq12WwFr8nPwLanlvNVsbaJr8fXLYW+vS3F9773PXX16tXimJ9wwgnqb3/72zn7XOq1uJzttZ4nnnhCfc1rXqP29fWJ38H69evVj3zkIwXb8BzF78disRScp8w+G8/Jr3vd6/Kvd+qpp6q/+tWvTM/HP/7xj02Pg/F8JJFIzHn66afVyy67TF25cqVoF9hHZRt68803q/F4PL9dKpVSP/rRj6qrVq0S7Rj7dNdcc03BNtX0ZT/+8Y+Lv23+nbNvzHb4E5/4hJpMJvPbpNNp9V3vepc6PDysKoqS7yeWaqPYrn7yk58U+8HzwYknnijaD7O22dieFesfa9cF+v71li1b1Be84AVi37muVBtdaftc7PpD48tf/rI4Tjz+CxcuVC+//HJ1cnKyYButT8xz4Omnny7aUH5uPreW41RvX97YxhuvpUgkElHf9KY3id8C1xm/J/Lyl79crHvggQdKHkOJRNJ7aG1jsZu+z1ftdT7Pd3zO29/+dtP11FfYb2e7x/aX71VJW0c2b94srit4bqVe9IUvfMH0fELYJp577rniWoTt9po1a8S1k5muJJF0Agr/abdoL5FIJBKJ5DCsYk8343333SfciRKJRCKRSHobOuEff/xxbNu2rd27IpFIJBLJvEfO+ZVIJBKJRCKRSCQSiaRN7N+/X0QTMLJAIpFIJBJJ+5EZ5hKJRCKRSCQSiUQikbQY5qqzPtI3vvENkVvOmlASiUQikUjaj3SYSyQSiUQikUgkEolE0mL+8Ic/CFc5hXMWmF20aFG7d0kikUgkEgkAmWEukUgkEolEIul5du3ahRtuuAH33nsvDhw4gCVLluDNb34z/vM//xMOh6Po81hHgKKWHrpAb7nllhbstUQikUgkEolEImk1MpJFIpFIJBKJRNLzbNmyBdlsFl/72tewdu1aPPHEE7jssssQjUbxuc99ruRzud3HPvax/GOPx9OCPZZIJBKJRCKRSCTtQArmEolEIpFIJJKe52Uve5m4aaxevRojIyP46le/WlYwp0AuoxIkEolEIpFIJJL5wbwSzOkq2rdvH/x+PxRFaffuSCTzCqY/hcNhMQXeYqmufEI8HkcymaxoW06rd7lcNe6lpBuQbblE0vvtOd/D+PftdDrFrZFMT09jYGCg7Hbf//738b3vfU+I5q94xSvwkY98RLrM60S25RJJ77flsl8+P5DtuUTSPmRb3jzmlWDORnz58uXt3g2JZF6zZ88eLFu2rKpG3B0YAlLRiranmMHCSfOxQZ8vyLZcIun99tzn8yESiRQsu+6663D99dejUWzbtg0333xzWXf5m970JqxYsUJciDz22GP44Ac/KJzpt99+e8P2ZT4i23KJpIvb8qEAEE2V3Vb2y+cHsj2XSLqzLR/2uRHJlN920Txty+eVYM4RT+2HFAgE2r07Esm8IhQKiY6U9ndYKWLEMxWF84R/BazFi7IJMkkcePRr4jnzrTGfT2i/IcfzroZim/2eveUdoqZEJxq4ZxLJ/EBNx5H806eb155nkog8+rU5/bVi7vKrr74an/nMZ0q+91NPPYUNGzbkH+/du1fEs1x44YUin7wU73jHO/L/P+6447B48WK8+MUvxvbt27FmzZqSz5UUR/v9/HLlanirdERJ5nLwgNruXZB0GTE1i7fN7KytLY+mYH/HqYDDWmLDDA7c+ojsl88DtN/QM7dfh4C3Cd91eKz0+liJ/nxkqvzrRybRTLLRELoBi7dGjczXj66gyd9zuwjF01hx7Z9qasspln9grRXOEt2wRBb47LYD87Itn1eCuTY9iBdfUjCXSNpDzdP0rA4o1tJT8eWl4vz6DVEsV/qW1vdi+udHxuvcM4lkftGs9lxryyvtr1111VW49NJLS27DvHK9E+7ss8/GGWecgVtvvRXVctppp+Ud6lIwr//3Q7HcZykhukkqIqzIXpCkxW25wwrFWVxOkL/IeaizeF3mgrlvsPQLlOuDe2dds+HRIusXA9Eir+FZAITLCKXuBUCkeSaabKY7znEWdw3yoK9G05IZ/v7y31U9NPl77ta2nGK5y1rquSrmK/NKMJdIJBJJD1Grq7wYWmdeCucSSVcxPDwsbpVAZznF8pNOOgnf+ta3qs56JI8++qi4p9NcIukUFi9WsH///L2olUgkHUQ5gbzU9qX64f7h4qK5pLugOF7p8kaK6BT4e1g0lzQWOf9RIpFIJJJ6OvkSSS8wD373FMvPOussHHHEESK3fHR0FAcOHBA3/TaMbnnkkUfEY8au3HDDDdi8eTN27dqFX/ziF7j44ovxghe8ABs3bmzjp5FIzEVz3iQSiaRtZpZ6+xN8fqnXoGhu+t6lntPfWqf0fKGWY8bvopLvw+w51T6vGPK7llSIdJhLJBKJpGfw+L3w+D1lt4uFY4iFSxQeZEddOs0lvY7xgrTHZ1ncfffdIkaFN2NRJFXNOXNTqZQo6BmLxcRjh8OB3//+97jpppsQjUZFLY7Xvva1+PCHP9yWzyCRVIJ0m0skkq6nVJ+kmNOconmxaJZmx31IytMIwbtR36N0mksqQArmEolk3vLHP/4RN954o3AO7t+/Hz/72c/w6le/uuRzvv/97+Ozn/0stm7dimAwiPPOO0+8xuBg77szO10oJ2s2LMbyReULnjz59BhG91E4l6K5ZJ5Syr3Vo7995pyXyzpfuXJlXjwnFMj/8Ic/tGDvJJLGIkVziUTSMbj6Sq+PT1UvnNcimpdjnouo2cg0LL5gc168Ue5w/WvJARBJk5GCuUQimbfQLXj88cfjrW99Ky644IKy2//5z38WU/H/67/+C694xSvE1P13vvOduOyyy3D77be3ZJ8l5o5yr9+FQMCJjWuGMOCzV/TcJ/kbCOfc6GP7RueVcCiZ51QyXVr+9iWSrkeK5hKJpGNF8mLbFhPPzfol1Yrm0mXeOKqJNWmkWN7I77ODBkg4WFHzc+OZhu6L5DBSMJdIJPMWusN5q5QHH3xQuA/f/e53i8erVq3Cv/7rv+Izn/lME/dSUozBxUNYf9xK9Psc4nG/11mxWL5moU9sPxlNiMd7lgaxfct+c8e5FA4l8xX525dIuh4t01wK5xKJpOOE8lLPNxPOqxHNe0BE7QmaJZZ34SBIPaK4pD1IwVwikUgq5PTTT8eHPvQh/PrXvxZC+6FDh/CTn/wEL3/5y9u9a/OSNeuGcfKaw+6GYa8dg97KT2vjXjtGo/a8gE6kaC7peeZBcU+JRDIXKZxLJJKm42pgnAeF83pEc+ky732xvBHfaRMHSKRA3v1IwVwikfQcoVCo4LHT6RS3ejnzzDNFhvlFF12EeDyOdDotolm+8pWv1P3akuo5cdXhTth5a4fgd1TmLs8zBOwJx/Dgnlxn5qzjF8Pnc2LryCHziBYpmve2OCy/W4lEMg+QMS0SiaSVKK7yoqkan6zObV6vaF4O6TLvPjpkIKQbRfKAQ4XbWny9IzN/+wxSMJdIJN2BfxCwuUpvk47ni7Tpue6663D99dfXvQv/+Mc/8J73vAfXXnstzj33XFEo9P3vf7/IMf/mN79Z9+tLqoeu8pMXB7Fy0AuPo8SZvggeZ+45mmiud6xL0XyeuaiLFZWStL49n23LJZJOYmhZ/QPvesaezUWCtQPpNpc0At8iHyyu4maFbDyF9stXkk4Wys22NRXPzdzm9fTJWyyuspBmNwqpdeWXt8pd3iGieU99v5I8UjCXSCQ9x549exAIBPKPG+EuJ5/61KeEy5wiOdm4cSO8Xi+e//zn4+Mf/zgWL17ckPeRVMaQxybE8qMXH/6uq2XQ58AJjj70Oe34zbYxsUyK5vM8bkQK5xKJpAkCeSWv32oRXQrnEomknUJ5sedXLJobkS7zzqAdYnmbRPNGCuWp0FRtz0vIop/NQgrmEomk56BYrhfMG0UsFoPNVthsWq05h7KqyovNVvP85YM4qg6xXIPOdDrUWf510/5pjEZTQjRnMdFHionmkt7P5ZYDIxLJvKPZInm1798qAV0TzokUzyUSSa0ozr6Giu5zhHOjaF5PEdAOifCQ6AY29NQyyNHi77ZWsbxWYVzSeixteE+JRCLpCCKRCB599FFxIzt37hT/3717t3h8zTXX4OKLL85vz7zy22+/HV/96lexY8cO/PnPf8a73/1unHrqqViyZEnbPsd8ZdmAu2GvRdGcTnU61hnzohUCPfWkZVixvjDiRyALJ3YOzfwu5PcskcwLKFS3WywvtV+t3D+K53oBXSKRSOrGGSh9q8atruWaV9NXM4qxjYwekdQHvxuz70dbXut31+TvuVqxnCK5dpsP/PGPfxTaCTUSRVFwxx13lNz+/vvvF9sZbwcOHCjYjrXjVq5cCZfLhdNOOw2PPEJ7W/OQDnOJRDJv2bRpE84+++z84/e9733i/pJLLsG3v/1tkVGuiefk0ksvRTgcxpe//GVcddVV6Ovrw4te9CJ85jOfacv+SxqPFu+iOc0pmk9GkoiGh6XTvNOoUMz2+L26/3vy/4+FYwXbxcLR4u8jneYSSU/SiSJ5pzjQpetcIpHUTQkx3HS7RKjyiJZSSJd558exVCOE1xKr08TvthqxfL4I5Eai0SiOP/54vPWtb8UFF1yAShkZGSlICliwYEH+/z/84Q+FXnPLLbcIsfymm24SdeX4HP1289JhzuzgU045BX6/XxyMV7/61eLASCQSSa2cddZZIkrFeKNYTnjP0U4973rXu/Dkk0+KeJZ9+/bhe9/7HpYuXdqmT9CddHp7TtH87BVDeac5o1m8fleB8CqQ7uP2wONewbHn93XcKWtx/Mkr87d16xfkb/rlvHHbOd+x/j17hWrEfzlQIOnitrzXxPJ2OtCl61zSSqpxEKZSKXzsYx/DmjVrxPYUaO666666XnO+0ZS2vIxzvNrnzXGat9Jl3sDCn91AxxavbJXbvEHHp1o3eTo8XfstMnegqd2cd955osbba17zmqqexzZo0aJF+ZvFcliy/sIXvoDLLrsMb3nLW3D00UcL4dzj8eC2225Ds+gawfwPf/gDrrjiCjz00EO4++67xcnxpS99qRi5kEgkEkn30A3t+fJBdz6epd/rRCCQEyKKCqqSjhDK+f1otzUbFmPjmiGRR8/beRsXmt609Wcdv1g8Z16I5hLJPGnLuyl+pRsEdE04lwK6pFloDsLrrrsOf/3rX4UATgfhoUOHTLf/8Ic/jK997Wu4+eab8Y9//APvfOc7hUDzt7/9rebXnG80vC2vRSiv4DWqFs3pMm+EI1rGsjSeeoTvap7bhuKjlQrlRtFbkuOEE07A4sWL8ZKXvETE32okk0ls3rwZ55xzTn4ZxXQ+fvDBB4H5HsliHCmm85OjDzxoL3jBC9q2XxKJRCLp7fZ8wGcXwivZvmV/4UoZ11E5TRach5YMY/HSIHy+nEhEEZxw0GPtgAd9ztyMASNTiRQe3JPrqFI05/P/vmlX8YiWXoC/2XLfh/xdS3qsLe9VkbzSz9yM+BYZ2yJpNHoHIaGD8M477xQOwquvvnrO9v/93/+N//zP/8TLX/5y8fjyyy/H73//e3z+858Xs0Brec35RkPbcqe/9HqHwZSQjJYWzU0iWuqilmgPSWNphEu8Td9jOXd5OaG824XxUKjw79HpdIpbI6BIzrb55JNPRiKRwDe+8Q2RBvDwww/jOc95DsbGxpDJZLBw4cKC5/Hxli1bgPkumBuZns792AYG5IifRCKRdDOd2p77HXYMem0iy5yi+fJFfoRCCTwz0sNCaqNpkSubYjljVjSRnGiROpwpsNDvwqDPYfrcWDIj7jXRXHsNU9G8lwZISonmvfIZJS2lU9vydojlgWVlRKMKCD0bRrOPQSNFdDPHuRTRJdWgOQivueaaih2EFFYYs6LH7XbjT3/6U82vOd9peFtuFMmLrTMTzw2i+Zw8c7rM41PN76fRZR6ZaPzrSppPg7LM6xHLKxXKE5E4aiGZrO9cG3AAbmvx9fbcpRKWL19esJyzdq6//no0gvXr14ubxhlnnIHt27fjv/7rv8TAaLvoSsE8m83i3//933HmmWfi2GOPLbodT6C8FRsRkUgkEknnt+ftassZy6Kx5dBM8Q17SUTtUrH81JOWiQKtmlBOkTw/6OF3wOMo3gvkuhOW9AkH+m+2jR1e7vf0tsu8mGguf8uSHmvLmymWN0IYr/W1GyGot9KBTqSAPj+p1JVYi4OQ0Sp0kNMJzRzze+65B7fffrt4nVpfcz7TcJ2llFhutm0px3ktdFjxT+aYd2xGeCtoZAZ5B80WqFUsr1Ugbxd79uwpKMjZKHd5MU499dT84OfQ0BCsVisOHjxYsA0fM+u8WXSlYM6MrSeeeCJ/8EoVsPjoRz/asv2SSCRNxDsA2A8LmKakSoiakq5tz9vZlutF84lISmSZM+O654XULhfLWbi1Giiarxz04jwAm/ZP5wu9xsy+614bIGnHZynXnsu2vOvoxLa8GUJ5MwXyRu5LLWJ6sx3opFjuuRTSu5MFgx5Y3eZxZyQzk8Jkk12JX/ziF0XcyoYNG6AoihDNGb3SzCJwvUxDdZZqxPJSonm1LvMuElp7jlZnhnfAd1lMLO8loVyDYrleMG82jz76qIhqIQ6HAyeddJIYFGVhYm2Aj4+vvPLKpu1D1wnmPBi/+tWv8Mc//hHLli0ruS2nXrHAh37k03jClkgkEklnt+ed0pYbs8wLhNReE1G7BIraGhTLz14xVDDIUa1obhTanwQwug9ygEQi6bK2vJFieSeJ5PXsc6eK6ETGufQ2lboSa3EQDg8P44477kA8Hsf4+DiWLFkicslXr15d82vOVxqqs9QillchmpfE2CdvlMt8HsWy0AVPN3zPUOcMgmpnBRQTy8sJ5bFIbefXWKrzzpeRSATbtm3LP965c6cQwBn1dMQRR4g2ZO/evfjud78r1t90001YtWoVjjnmGNGeM8P83nvvxe9+97v8a7DNueSSS0TOOd3nfA6LE2v1Kea1YK6qKt71rnfhZz/7Ge6//35xMMvRyBB6iUQikbSnPe+ktlwvmj/+l8OdAEll7nK680m9ArT2Oo0Sy/UYRfNHwvHed5lLJD3Slne6UO5ZWb8AEds13dDPU62Q3k4RXUOK6b3pSqzHQcgc86VLlyKVSuGnP/0pXv/619f9mvOFhuss9YjlFcazzHGZdxE9HctCUXoeuczN3OXViuW1iuSdzqZNm3D22WfnH2sDbBS8WVh4//792L17d349601cddVVQkT3eDzYuHGjKOCsf42LLroIo6OjuPbaa3HgwAGccMIJomixMXJrXgrmnB70gx/8AD//+c/h9/vFASLBYFAU9pBIJBJJdyDb8/kDI1MWLw3C53Ni9cKcWDMZTWAykkRktoOYK6S6p+rXHl4ygGOOHBJxLCzOKpFI5ndb3gixvBEieSNE8Ua8fqXCeiOE9FaJ6Boy2qV3KecgvPjii4UwzkgQ8vDDDwuBhcIJ7xn1QkH8Ax/4QMWvOd9pZVuuODwFj9VkrPInl3KZtyqWZR65zCWNEcvrFcpnIsk5y9w+Bzqds846SwzGFYOiuR622fp2uxgc6GzlYGfXXGF+9atfzR94Pd/61rdw6aWXtmmvJBKJRNLr7bnHaUW/04Fhbxqj0VTxDaXruMBdTrF83foFOHnNAE5fHsT6oZwoczAcFznh2rHUsuErdezTXb5mw2Lh9Kfjn+7yRsNiofrYl8OlQCUSSSe25fWK5fUI5c0WyJu1X+UE9XqF9GLfiRTSJaUo5yCkI9FiseS359T9D3/4w9ixYwd8Ph9e/vKX47//+7/R19dX8WvOdxraltsLBfFSYrl+malwXo/LvNY+eYuKf3Y9HDTg4EGnUMkASBu+WzOxvJRQbiaOV7JdPC3PcZjvgnmp0YlmvNf09LSo/MypRhxdZRERSetp93fR7vfvZOSxkXR6e873CYemkUolYbc74A/U9hsd9DmwHn5MJpKlBfP5jiGKhUIzXeXnrR3CigEPouGQ+C6G7A6cdcQgno3kCjvyuGrMyYavQCynu3zjUB8G/Q7EkhmRRd6I3wNfVysmGg3HMbZvtEcHSFQEnSp42JIZYDrBY9K7bfknPvEJ3HnnnSJHkVP1p6bmOoQoyFx++eW47777hABDZyLdjDZb8W7zxMSEmNL+y1/+Uog5r33ta0UxOj6/V2lp35wXiF4v0nYbbKk03NFo/ldaj1hei1DeCIHcvqp5Intq53Rdn6OUkC6+8ZXDSFpscGTT8Kfj4ntopRu91G+hUiG9VwV0fqpkwIuswwZLMg1HqPyx6URKOQgZGaLnhS98If7xj3/U9ZrznVa05XlhnNePoQgSyRScDjuCAV9rrh8rzTGfR/Brn4YbSdUGh5JGEDNo5aW8eP8kkMgocFpVBB1o6fs3evaA0V1eqVhuJpLzLzLqDCJtccKWTcCbmO7KtrwX6BrBvFVw9HnLli0YGxtDOp0WF0csFsLK2ywqIpk/30W737+TkcdG0ulMjo9h57YRTE6OI5NOw2qzob9/EKvWrkf/YC6DvFrR/LlLKQiP44FIKi/edmwxSLMc8RaKuzw2S5YEcMbqAPqUGTy++TGE+F1k0rBabQj0D2Lx8jXi3ghFc6I/tlpmuV4sJ3qxXMNMNK/19yDc6xTNT1qGRyjqGEXzLmfQncW6gQwGPSpsFiCdBcZjCrZOWDE+c9jB10swI/HCCy/E6aefjm9+85tz1mcyGZx//vmiGNwDDzwgMhYZAWC32/HJT36y6Ov+8z//s9j27rvvFhm6nOr/jne8Q0xzl9RHJBDAgeVLEQkGkbVaYclk4JuexobUKPpi1ReyrEUsr0Ukb6Yo3oj3LSasF/us43DhySk3Jh1epBULbGoW/ckoVkdHMVCkPmCj3ejFfguL9uyFLxSa10VG4wMBTK1bJu6zNiss6QxcEyH0bX1W3Esk7UITy0fHJ7Fl2y6MjU8hnUnDZrVhaLAPG9auxPBgf2Uu80bGstRKA2JZ2p1jPpb1YSS7EGOqD2nVApuSxZASwXrLQQxZIk0v/Dk6A4xMWDA2o4i+J/ugQ24V6weyGHZ3Vpa52fdkFsdSjkrF8mnXEPYObMCoYwgZiw3WbBre2BgWjI/AFyuc8zrg7O7zVjcgBXODCMgctFgsJtyyvDjiRQ8vgOikPe2006QYOE++i3a/fycjj42k06E4+vjf/oKZeAw+XwA2ux3pVAqjowcQCYdw3Imn1CSad3OxzYL1TRbOKW4zX5xRLAvVBJ549Ekk+V0EgrDZ7EinU5gYO4hYJIQNG0+C09cvIm/0BVX3753bOdXE8kqgaC72xWGt6fegFQ+9LzrWs9EsFMtPWpKBx6YilARSGcBuBRb5VARcGWzeh54UzT/60Y+aZidq/O53vxNuRRYa4nR9Tt2/4YYb8MEPflBk49KVbuSpp54S0/v/8pe/iIxccvPNN4togM997nNYsmRJkz9V70KBdNeGI5F0OuGKRWFNZ5CxWRFfOoQtqQA27N1etWjeLKG8HoHcckSZ9rtGsrvHa95fvaBOsXyTshAzAzb4kYQdGaRgwQQGMNMfwDHPbsdAKtrUWJcpjx8Hlq5B3O6AYzyc/y2EBgYQ93qxcsvTVYnmveRCp0h+6KQjkXa54AhHYUllkLVbEVswgGTAgwWbn5aiuaStUCx/+K9PIDYTR9Dvhd3uRSqVxv6DY8Jxftpzji0umjeLYgJrj8eyUCx/JLMSM6odASUOu5JGCjYcyAYwrbpxKnblRfNmieWPHLBiJgUEnIDdAqSywIGogumkFacuytQumpejSd9tOXe5USwvFr2y2zqM3cOnIunwwBWfhiuTQsZqR8i/GHFnEEfse6RANJ8Qs0KBaJr/1n7O6rOr8JRQhp3zOPJFCuazcHoQHbMUASn2aVODGDXBx5qjli5aGTvR299Fu9+/k5HHRtINv1E6iSmO9g8c/h06nE70O4YwOTGGndtH0Dcw2JzfaLtiOsqJ5WbbNnI/de+vFeMc8tgwtncb0vEY/H25451VAYfDCXu/A9OT49izYyvWHHdKwUtRFGeR0K0jhxALx+Dxe0QWulY0tBqiiTRGRrYgEosVtEuV/B4omp+NIdz3zBi2o9dQhbOcYvmYSMbJfXaOM4zNqBiyx7HOm8X4QUMEUWAICI0BmeZlELebBx98EMcdd1xBtu25554rIlqefPJJnHjiiabPYV6uJpaTc845R0SzcID5Na95Tcv2v5fg5RndxBTLvdOHpyMH3IAaC2Pa48eeocUI7g5XNFW50UJ5NQJ5swTxRr6vUVzXPh+nzW8PDyCRdGKBLQlFsSMzlYATWTgQx7jiwrPLlmOpun/O91As3qVaIZ2/hd1Di4VYHoyFoQgxJTeTyK9GMd3nx8HlS+F9MtSwaet6Ab2TxXPuGZ3lFMtd44f/TqzJtHgcHwxiau1SLHykccdGIqnGXS6uH7ftEmL58GCf7vrRgWGHHaPjU2L90EBf9a/fjBzzHobtOZ3lFMvpKNe6vk6kMYSIcJyPZBdgULeu6hxzCtIUps3ePzKOkelhIZYPuQ9HsDitucdjs87zoSXZ9sazNJBKxHIK32zLDy1fL8Ryb3Q0317bMknxOOodxqHB9cJt3iOHpiuQgvksdMYyXsIsh5mPA4GAWM/t9EVEJL33XbT7/TsZeWwknQ4zqhm7QSex2W+UyycnxsV2gWBtv1G9E7pc5nY7Cm3SCW3G6L6Jwn1t8oVEnyWO2PQkgn5/wXeRzmTFvdPtxfj4GBZH6Hqb62Tm56BgXg/MTWcUjMfnF1M+NfeF3aqU/D1oDnUt9qXXYGY5Y1joLEdibsZiKMMYIguCbgXTMzqhiGJ5CwkZ3KIcnOWtmbAgnLEQnPaY64o9Z8GCBQXLGFU2MDBQ9DmS8jCnmtEbdJZrLYgnkPt75GNPYkaI5lGXB754rCFieaOE8moFcmVx62fmqftHK9rnqbgF4wkPAplYXsCw9h3+O+zLKpjIBhALJuHdM15XTrrZ90QRnd9xyOMX37lRKNB+C8nF/XAn+gt+C40qMNrJ4jkzy+kwp7Pc7Ng4wjEhmnM7Z6hDY+QkPQ0d5IxhobPc9PrR7xXruV3QbV6HpuNyzLs0loWZ5RTF6Sw3CtJ8HEAcY6pfbNeHmYbHskynrCKGhc5ys/dnwiLXM9tcd5rpKsyyy4uJ5ZpDnNBBHvUMCWd5/PBlyGGiIUy4huCyBOGMH/7dDM6d+ChpIL13FVgjLFzILGbGS5jBKbjhcFhsJ+nt76Ld79/JtPPYeHwe0+rqetSkgvn3rUj0sKAjM6oZu2EGl2ciYbFdNegFVA1NNH/8L9vQKWI5ndj9vsM9p36vE5PR3F/FnoBzrsDfKNGcr6HbF75vNp1CNssaB+bfhdVmRzYTQVp8F3NFfhbaJBTN9+0Lic/F163695CZuw+pTE7wUC02JJMphGNx2NxmvdPehBHvzItMxcw79Yxn4biLw8aOvNry9lxry5cvX16w/LrrrhOxKEauvvpqfOYznyn5noxNYZ0NSffAoo7MqWb0hl4s17BlMphxWpGy2poulJcTySsRyGsWxQcLB2NqZvxQ1ftDUZ0F2dJZBY4+l6njz6EC4fE0klkL+kocJ33ESzVCOr/DpMMHxeuEN5WGBblzXEKM+JX+LRiz0RshoHeaeM4CnyKznA23CZZUGqrfLbZrNOsG3LB7iqs1qVgSIw1/V0m3wQKfzCxnDIsZDrsN4UhUbIdmCuYtzL3uVFjgk5nljGExg3FbGdUitmuGjTmRzWWWM4alWP80nMoVAq2p/1nJ99ngWBZjHEsxd3kpsVy8js2JGdigJlOmh96SSSJr8SNrKzyvjSeBmPnXKWkAUjCfhY4luoGYxWzmXmKRKK5vtrNJ0v7vot3v38nIYyPpdOx2hyjoyIxqxm4Y4XKu53aNohOKf3IfFi8NitzwDQvMg/8emBWbmyaa66BIPx20I2Cxicxyu2Pud5FJp2Cx2pBSrZhMJDExW0y1mDv+SUBEvVA057Za4c+yvwdrbh8YBWP6e7CW/j2M54IBewqO/6QTCdhtQNLk4zHLnBplss2ZhXv27BEzlzSKnVuuuuoqXHrppSVfa/Xq1RW9J4t9PvIIS7we5uDBg/l1xZ5z6FChGMnB5YmJiaLPkZTHRnE0k4G9zwlHZu4PNU0xPZuB3WRdpWJ5PUJ5OZG8IoG8UWJ4JVT7XuOHxGdwRVXYJoCUA3Aam91IDMmMApvPAdeyICyu3Awis5gXs2NpLDxq9n1QRHdw8FXNIq1Y4VBzwrAzcLjdTlissMaL/xaaJaB3gnhuSaZFgU9mljOGxUjWboOSzojtJJJ24HTYRYFPZpYzhsVIMpUrAMrtOoYezTF3KGlR4JOZ5YxhMZKCFVYlK7ariCpjWZwWFbZsAqmsU8SwmPVP6dVwWts/GFnLTIBS7vJSYjlF74QlAUs2jazVDmtmrrEra3WI9Za0tAe2EimYz8KICeabsnChPpuZMHeL04IXL14stpP09nfR7vfvZOSxkXQ6/kAQ/f2DoqAjM6qNv9FIJIThBYvEdvW4yzuCWUc3xXKyfJEfpy8PYrnf3LmrFdbU8sHH9jVoWmoRFKcXnmA/ZsLjsNkdc76LmWgYfUOLkLa7MT4eKhDb6Sg3xrFQNKdLvn9NTvAQAnuRwQENrz+AQP+gKDLK3HTjPsSiYQwOLRTbGZlJZrAnHMNotLiQ361Mj05g3G/HoqAFY5G5FyUBl4ID09nCOJY2QLFcL5gXg+ejRhWbPv300/GJT3xCCOBazMrdd98t9uPoo48u+pypqSls3rwZJ510klh27733IpvNikLYktpwR6NYgCgmnH2wM7dat46/zJjTjcHIFLwmcSz1iuW1CuUlRfIKBWulbynaiTq1t2B/gwMqhsaiODCWxlDAergdjUWhej0Ih4HFC4G+la7CNnb/aNFjpQnpxY6z0Y3Oln6BksFBxQ8P4khPxQt+C1GrGwtsISweskKBv+Lioo0U0DXxvNXCuSMUFQU9WeBTn2FOuCdJvweeg+NiO4mkHQQDPgwN9okCn8wsn3P9GI5i8cIhsR1SorBKd9CAWJZWE8SMyC5ngU9mlutnDTHfPKS6sMgyLbbTaGQsS9CewZArjQMJZ0GGufb+4SSwyKsi6Oj+77SUu9wolhMHi3xGxxALLIYrMloQy8K2PO0OwDG9H9FQCLHZlr6fU7wkTUUK5rOw4eZUXWYvs3AhL4wYL0HHLEVAj8cj1stChr3/XbT7/TsZ/bGhmOByuURRM4oC8XgcXq933h4bSWfA396qtesRCYdEQUdmVDOGhU5iiuVutwer1qzv/t+oocgnC22uWegTYrnHzLIBYL1zroCUF82b4DLnMR5auhoTu2YQnhqH2+sXMSx0llMsd7g8SAYW467t43l3OcXyJ58em5u3rhsYqHYfjli9DrFISBQZ9Xj9+d8DxXKXy43lq9fN+T1QLB8ZC+PBPa3NlmwJsznkWw+mEXDbMeRTEE+rUFXmuqtw2RTEkqpY34vs3r1bOL95n8lk8Oijj4rla9euhc/nw0tf+lIhjP/Lv/wLPvvZz4oM8g9/+MO44oor8g53OtAvvvhi3HPPPVi6dCmOOuoovOxlL8Nll12GW265RczCuvLKK/GGN7wBS5YsafMn7l6GlzlhH9uPmNMjssqZU83oDTrLKZa7UkksHyssNNkOobyoSF5GIK9UGI+16GrNkzbfLx7fozbOILR5FGPRNAJ+O+yZKJI2N8KRLDxBC9Yf7YHSbyuIfil2XIoJ6eXc6EfunEQIDlFk1N9nFdEBdEOGYYdfTWP1xOEiacV+D9UI6LWK560WzvlufVufRTLgwcxgELZEClCzgGJB2mmHfSaOvm17ZZE4SVtQkzERwbZh7UqRUc4Cn8wsZwwLneUUyz1ul1jPvth8k/9anWPO7u56y0FMq7NZ5ojn21KK5R4lifWWQ40puGniMhfv709gepxZ5i6RWc4YFnqTKJa77cD6gToLfrYhlqUa9O5yTSzPt+WjIwg7ggi5h3NOcs6oUqwihsWajMF76OmCtnwymXs0I8T1+fbX0xqkYK6D7iQ6gbZs2SIKFzKLmfESdMxSBGyUe6nT4UgvBVHmUPPi0KzAY69/F+1+/06Gn33dunVCMKCQQMHBarWK4mYnnHDCvD42ks6gf3AIx514CnZuGxEFQJlZzhgWOssplnN917vLDWI5o0qMUSzCQR0JiYxwOrw9vgDWD5UQzRtE3gnudWJwdQALVx6Dsb07EItMQ1EjIoaFznKK5X+btuTF8h0HwyWd7xTQ9++dFg751Qtzn2PLoRnhnOcggZs9bhP6BoawYeNJ2L1jqygASrGeMSx0llMs53ojB8NxbJvIuVa5f3sOhMXn6np0RTvHoyq2H0rjpBUOLAxYYbUArMc6Gc3i8UMpsb4Xufbaa/Gd73wn//jEE08U9/fddx/OOusscT771a9+hcsvv1w4xzkQfMkll+BjH/tY/jmxWAwjIyNCGNf4/ve/L0TyF7/4xWIg+bWvfS2+9KUvtfjT9Q6acNkXC2PD3u3YPbRYFH1kTjVjWOgsp1jO9Y0Qy6sVymsRyUsJ5KVEceHAnE4imczC4bAg5RxtaL980LW07D54F7lx/GnD2DoyhenROMJpB2w2BYuXu7FhXRDDtApq+1vsRUoI6ZWI6ItWOfHcVAwjMz6MpdyIRNJMe8UiNYZ16iQGl/IDBMvmobdKPG+lcE6HeXDbPhw66UiEF/ZDtVqgZLJwToYRfGKfWC+RtJPhwX6c9pxjsWXbLlHgk5nljGGhs5xiOddTXK8bVx8Qn2rELjdFVKWLejrrREK1wqlkELS0Pl5jyBLBqdiFkexCIZozs5wxLHSWUyzneiMlXebFYlmKMOxK49TBGEbCGYylvSKznDEsdJZTLB8uPXm0qzFGsRiJ09xj34rpFaciEVwE1WKFwui56AT8e/8OR+RwP17SGqRgboBiHyMn2i0Ytws6qjWRmPmbFIl5PNohErf7u2j3+3fyb2Tr1q3ieKxcOesGUFVxjLicwrkUzSXthqJ438AgwqFpUfiRGdWMYem1v1+6rpcsCeC5q/uxKuDNu8spDO/dtRWhqQlkM2khUgf6BrB05Tr0Ob0Y9tpFEU2v34WGdb1mC39S2GZOusb6hR6ofWvRNxDHEpcNAY8HW2eyeHAnxYpMRWK5hn49RXOK2ZoLnIMBpUTzYP8gouFQ/vfAGJZyvwe+/mPbx+bmvne5WE4GvQrWLLAhmVHxzHj6sMPcnls+FetN0fzb3/62uJVixYoV+PWvf110PYV1nvf08Nz3gx/8oGH7OV8xRmQQiuLB3WFEXR5R1JE51YxhqcZZXourvF6hvJhAXs4xPh6fjUQBMDWexjPb4uI+kwGsVqBv0IYVa13iXs/BWOWDnws9w6bvVxIfcNoZSwrE+0AwF3UV07nUi33uUkJ6pSI6j/LgM+OYztiQ9FvgsGQRtKahKPzdOEsWFjUK6LWI550qnMcHApheuwTWRBq+3QehqFmoigVZp0Msd05HpGguabvLnKL40ECfcJqzwCczyxnD0tC+eTmx3D8MhEfbUvhzNO3GSHIAYxmPKLzJLPEhawxHZjOmInUz4fsNKhFMwy0KfDKznDEsNX8VVWaZUzQfcqYxnYoj4ewXmeWMYWnpZVqxAZEGR+0Ui2PRu8s1t3jSN4TYgnXCXe4ef0bMFkplLcjYnZgeXIfE9BRs4Vx/XlfGQ9JEpGBuAhvtvr4+dALLr/h5wWNjpms1eExybSmWaPzfVc/Bww8/LJxTFIbtdrtwTzGvmqIxHdetFkLb/V3U8v4/e+wA+gxVkfxlipiEWRVcxxSnU87CYnj6wnPM09Ucmd+46Fi0EgoEHFDhb8Qsw1wbcOFAQzcIk3/84x9x4403itxZ/s5/9rOf4dWvfnXR7W+//XZ89atfFVP4OUBwzDHH4Prrr8e5557b0v2WVAZ/g4Fg7e1HMXd5qeKU7YDC98mLg1g4255TLN/65F+RjMdEDIrNZhdFL6fGD4oYkoGVx2DQm3OAF9CIWBaDaB4KJbBjSUDsI2FszLA3hYd2TGJytgMZiSSEc7xSp7uZaE43ONvdlYPekr8HXxXZ9WxrKeRz37oeg1hO1i20weNQdBnmuftIQhUxLVw/vqOzfuuS+SeWa7BH4TPJKq9HLK9bKG+ASF5KrKZIvumRcSTjgMsH2NwsJgvs3ZfA6EQUKzcq8PfX1teqRlzXi+wTiX2AC7C4IMrFTSQKnerFPmcxIV3kpZu58k1EdAroxLpiEAMVRLmUKihaq3hej+ucwnkzRHO+4tS6ZUi7XHMzzCMziA8GMbV2KRY+EpKxLJLmk2I77S8qmotr66D5elOSHW5WqFBcpVj+SHwJZrI2BKzJfAzKgbQPU5mVwvHdatGcl+p9zCqvsGFoZJZ5/v0dGcDTe+YMfX55JVAsF/U4Fq5H1u6BPTIqYmqIhccqDmT9w0guPhLW8Jj4ykKzgnsjhPMBB+AtoQy7uBPzFCmYdzAbrv6tqehdj2heHBXvuOmXeOPxvgIhlC5iPu42IbRdUCwvJoiXEs25Ti+aU/jRi+ZGWLiPItHbf/hES0VzDpxw9oGZ016Ik4GAWM/tOmXQqRTRaBTHH3883vrWt+KCCy6oSGB/yUtegk9+8pPi833rW9/CK17xCjHQpE3rl0haHcdCd7kmlnPgis5yiuX+vsH836nd4RSxLMwSj4/tQd/So0Q7Egg4hUu9oe5pnWj+zEgU0fBwfoCW+eQkGj5csI3ntGrfXxPNKbZvXDNUkD1ezGVeD13tLjcRy4NuBYM+C0Jx84sULud6btfuwp+S+UEpsbwYjY5gabRQbiYelxLI9SI22/LtT6lCLPf154SFSCoxO3IAhKYVbBvJYtFxyaY78hZ5+sqK7BTTi322YkJ6VSJ6FS70YgVFi7nP6xXPqxHOm+E2Twa8wmHuCEfn6F587AjHhGjO7Zyy8KekjWiiOIVz47KaXzPenhzqauCENDrLKZYPWQ+7uJ3IiMejaTtGsguE47vTZZaaolmKuMzz0N1Pl38jqXTWQIWxO43Omje6y0naHUTKNwhrfDovlmvwZ6HMhJD2DyHrCcIaO7wvFM5zGeaSZiAF8w7gtbdtLnDamTnA9eKC5hSvRjg3c5cXvI+SQNAyg9sfS8HqnPu6/3LKoq4SQpvNjffvyP9/UDccxyxdQrHb6DIvh1E0178mXeZ8H81lXur3Q0cn2fLpxrue6apmVA9nH5jB4qjMe+d23cB5550nbpVy0003FTymcP7zn/8cv/zlL6Vg3mOYucuZa232NziHJhTQnPP6jI1Yv1xkl+vbIGaWM4aFznKzQS0upwP92DUqlOVBbD8YKYhPabRorhe3K4p+KXbcDEVO9a/LTHPC48CBg3pFcz5/ZyhafiZBM7/jJuOwKbBZgdSM+fpUBmD3g9vJIkKSZjO4pPFiebURLBWJ5RUI5dWI5MUE6AOxKSQiCkZHnbA5VRhPO2zaHR4V42MqEgcTsHobf6XMAtL6/SknqBf7LMWE9GpE9GICOjFzoVcioDdSPK9VOG+UaJ512JC1WWFhw22CJZWG6neL7SSSlkBXuKP4jL+KRXIzd3mi+6KFmFnOGBY6y42COB8HlDjGVL+IRxGO716kEtGcNFo4r5UGx7KUyi/XCneqNieyFjvSiZSp6V/JJKFa/GI7SeuQZ842Q4ewHl74a6I5nX+a+EnhXC+aG0XwYuJ5OaFcw4YsrMgiAwvMZIbvPbIfrzrK1zVCaDP5wJ0j4p4ZwIQCml6wahTFXOZ8X0YFaC5zwrgDTTTXz1BotGjOGQfMtWdUD/9vJJlMivVm61pJKFTYmeL+NGOfstmsGCBgdq2kt8XyXeNRbNo/Lf72OgG6wnmOMMaqsMAnM8sZw2KG1WZHNhMR2y33D4iIlCeXDGB0XxNc1JqgbCJ2m25X52s9sCP3d79x6PCgbrXC+Xg4icfGpvKv1ask0yrSGcBu4//nrrdbIdZzO4mk02h2BEslrvJahXIzYdlMkM6mFGQzCsLZJBSTrrea5c0KNV3cjrgzVF5IXxUwbyP3VGDK0UT1YoJ6KSHdDDMRvR4BXYtw0X+/jRDPGyWcN0o0tyTTsKQzyNqtsJo06Fm7DUo6I7aTSDpFNO8aGlD4kwU+mVnOGBYjajIOOxRReJNZ4t2Qm1RzAdByonmj3eYNdpk3GyVNY2IKFl7Dpeda0FWrA8imxXaS1iEF8w4Ry/WCZynRnBiF82qE8WKkYZkVy7NIJNJwOgt/GlZkcO/WSdz27JNIWHfg3nefjvn6XVGoJhTONNG8UVTqMtdEc7HO68RkNFHgtNR+M8zA3/OVVzVs/xjFwlge5n2bZZhTqF68eLHYrtG4/R5YdFP4zMgmAZ7uli9fXrD8uuuuE1njjeZzn/scIpEIXv/61zf8tSWdI5ZTRKXj2CiW8++Of2udENcRS2REwU/GrrDAJztcjGExkmFHzGoT2xG2JSwayvOK+BzNcMc38vV0znVtsJjny0mfQ7SFetGcx4Nu8XLCubYNj+F9z4xh5OBhoYivbTog3cXucsKYlfFIFouCFl2G+WECLgUHprNNi2Mp155rbblE0kyxvBZXeTmhvB6RXC9UZxJWzGStUNIKFPvhv8OpRDb3Hy7PqJiKp6EqtTvMKxHViwnspUR1iulmn7FYvEvRSBfX0poF9EaJ57UI560UzR2hqCjoGVswMDfDnLql3wPPwXGxXaNZ3eeE01s8QDfh6AL1T9KZonmPuMuJU8mIAp/MLGcMixEutypZUXizW+ga0byBLnN9LIs90IdUKHeOs/mDSIcNNTN8zqpzzG0z07CFx5EOLoIlPDq3LXcGoEweQHiK9SgUBB3S1NIKpGDeZpeyXvCsRDQv5javl6jqxHTWjQFLFNPq4UKgAlWFCwlMZnxIsMoPgBd96cF5I5oz8oRoTk66ujXR3AhF7WKxLOVyzM1E80qzzMX+6X4/+t9MI0VzCuQbNmwQ0TzMtWdmOWNY6CynWO7xeMT6dufc79mzR+ybRjPc5T/4wQ/w0Y9+VESyLFhgUrBK0nUUK/KpR/t7Y5vNPO7RfY2drlct3I8th2YOi8S+AAJ9A6LAJ0Vx46DWTDSMvqFFYruZZDbfdvC8UlFkSiegE8214qKCRciL5hxY1BdC1URxo3jOwRBN9GHhUE0s53HdcyAsXnvOgEiXi+UaWw+mEXDbRYFPZpZzNj+d5RTLY0lVrJdIOolOFssrEcrLieQF++fJIORIwhq2I+vJFLoOVcCSsCLjT0F1HW7btk021nW2tt9ZlcBeTkwvJaKbDSqYiui1COhFCohWKp4Xc52XEs6rcZvXm2vOZ/dtfRbJgEdklTOznDEsdJZTLLfNxNG3bW83GFclvUgtonmFhT67Ib+cBC0JDFljosCnPsOc7nLmm4dUFxZZphHspTiWRojmpF7hvItc5qLmxP4RZN0BUeCTmeWMYUkoTjpNoCRjsOwdybfl08nOF82/8pWv4MYbb8SBAwdE3bibb74Zp556qum2Z511Fv7whz/MWf7yl78cd955p/j/pZdeiu985zsF688991zcddddTfoEUjBvKbf9ZXdB/m2B2FmDaE4aJ5wr2JsdyGWZK3HhtLM6nMJZTrE8qdhxyDKESDSZdzFTNNfTKwK68XPxOylHs2JZanWZG7PwBy/+H3FP4WfmZ2+vaz/oLD/ttNNEEVjm2jOShDEsdJZTLOf6dkOxXC+YN5r//d//xdvf/nb8+Mc/xjnnnNO095F0jlhuzC6nmEqxvJ3ucnFOWOQX55Ets8somi9duQ6xaFgU+GRmOWNY6CynWO5webB0xdoCId0Y59StojmPBzPdycjB3GYnzw5C6uH5jXBgkjMH+N2yLTUOhjwzsge9zHhUxeZdKaxbaBMFPtmtYAwLneUUy7leIpkPYnmjXeWVCOVmgrJRjFYWxGGJW2GJ2ZB1ZgCriqlYFo6kDWlbCmPOEBJTzYsJKyfAGwX1YmK6JqTXK6IbBfRKIlzMxHP9d16J87yc67yRwnmtojkd5gs2P42pdctEAVBmljOGhc5yiuVcL5F0vGheSiivxF0eL11voSHCag2wy73eMYHprAtjGTf8liQcSkZEsFAs9yhJrLcc6viCn1W5zBshmjfKbV6PaF5llrnT50IiUrs+ZwuPwbXjL0guXo+0f1BkltPRQme5EMvDhZ+DojlxWDuvz/7DH/4Q73vf+3DLLbcI7Yi14Chuj4yMmJoNb7/9dmHC1BgfHxci+4UXXliw3cte9jJ861vfyj9udhSwFMxbKJaXzaGuQDQnzRLOQ6obT2cWY6llQhQAdSKGLCyYVnw5sVzJnei4P5porqcXXOenfvL+/P+Nn1F8N4a8YLNYFr3LvFYa5TI3+224X/ONhojmjGah05y59myoGMPSbmd5K/if//kfvPWtbxWi+fnnn9/u3ZG0yFlOyhaBbAU6kZi5408CeZEYC9ziLtA/iHXHPAd7d20VBUCZWc4YFjrLKZZzfU9gEM2fGcldaPF4sL2maK5vo42DmkahvCKxvNvc5aHS8wYoio/vSCHoVkSBT2aWNyuGRSLpdrG8XqG8WIRJMaF5azIKZzCJ4JQXzqgdlqwFNouCGU8C030xJNxzz0kj4xUW06uA9YOemgT1SoT0YiK6WS66WYyLmfvcKKBXIp6Xim1ptHDeCtF84cP/QDLgFQU+mVnOGJbe75lLOopEGPD7yovhmoBeiZvcRCzvFne5xrBtBqe69mEkOSAKgIaTCqyKRTjLKZYPWSLoRsqK5qWoRjQn9QjnDRoQKRbLUgkDTrVo4U+jaG4NjyHrCSKsOmFNJYFYYdxWN/CFL3wBl112Gd7ylreIxxTO6RS/7bbbcPXVV8/Z3lgTjloL0wuMgjl1p0WLFqFVSMG8BfzssQP5/2vu4FpFczO3eSOFc4rmocwSeLMJ2NJZuHxuUDo3Dnlq+2MUlfXu7G4Rz1kcU0MTmfXwezC6zEvFsugxxrLUiiaa1+Iy134b+hxe90s+I+5n7v5gzftEcbyv73BxvW6E+ePbtm3LP965cyceffRR0WAfccQRuOaaa7B3715897vfzcewXHLJJfjiF78oRko5vYi43e6m5LZLOkMsN9YV0P7OOgG63Pew3Vo064Kf1c4pivv7BhCLhESBT8azMIZFP6hFoYIRJGwrCs4dzcgxbxaGTHNN6GYuu/Zdbddtbhz01LYR95Ek9u0L9Y6zvIxYricnkkuhXNJ5tEssr8ZVXotQXkwkN4rQFMUPuaZgT9pgzSrIWFQ8EQ4BfMnGaeOmVCK+m4nqlQjpxs9fSkA3Hs9a3Oe1iOf1COftEs15hnc2IatcIqkKCtzOQENiV7o1t7yYaD5k3YvprBPx6IzILGcMS7f7zWrOM69GNG+EcF6JaF6jy9wsx1zD7XNgpsrZvPxJWCmSzzrIyxGqcLtWkUwmsXnzZqGlaFgsFjEz/8EHC9McivHNb34Tb3jDG+D1Fs5Ouf/++4VDvb+/Hy960Yvw8Y9/HIODzTODScG8idw3Mp53BmtCZzNF88blmyuIzuaYT4f5XsX/AIu5zbvFca4XyyvBzGVeTSxLpTnm1RQArTTLnHj83oIICQrn9Yjm3c6mTZtw9tln5x9z2hChKP7tb39bFDfdvfvw7JBbb70V6XQaV1xxhbhpaNtLes9Vvms8it9sG5vjLjdrf1sN/5b5N61FsxihOO71m3dgH9o7ju89uFcIxDxnjO3TiQ/dIpaXEM2j4eH8YGHBgKjBkMBoHe27nHMcjO/RbQSGqhLNJZJuox1ieSlXea1Cebnok5EJw+t00HVxMVG9EiG9WQJ6XeK5SWRLpcJ5JW7zSiNaGlEMVCLpeNG8ktcwwdRdbhbH0oF9N4rjgZlDCFjQU7RMNK83pqUBonmlLvNaCn92OqFQaI7b2ywShbG9mUwGCxcuLFjOx4z1LccjjzyCJ554QojmxjiWCy64AKtWrcL27dvxoQ99COedd54Q4a3Ww3VUGokUzJsolhvjNFopmjcy35zvYea8Luc273TRnMUwiV5U0X/WUoMBrYhlqTSapSaXueYgDY3Bfdr7MfPwjZiPsLgECyEWwyiCc0RTMj+EcvLovik8uGe6aBRLO/PLjfA8wXZAP8jmcZp3HEbGwkIs//umXR31GRopmlP41qRiDiqQaDgn4CyfHVwoWtTT+LrdDEVzIoVzSQ+6y9spllfrKq9WKK82WuXgWJPt5rMsHCod01Jq/40ier0CerH4llrF81Ku80qE80a7zeezaN4LheIkOsG7FuG8GrG8i9CE1k6imOBLMbhnRXPtNRpYBFRzmVeSYz7oAMY7qIRUv1OFr4Qy7JjNSF++fHnB8uuuuw7XX399w/eHQvlxxx03p92n41yD6zdu3Ig1a9YIjebFL34xmoEUzJvApp2FDXwlorlGJaI5KVYMtFrhnOuMLrxaRPNyMS2dJpprYnmldEIsS6Uuc80Bb+Yy98xeXOQFolkH4nwWzSXdSyyVgb8JQvlMMiNEZYrlRrSMa0ahdBqbtuf2SRvAWzvgwfqhuUdIOwf1HAbRXEMviG/fEsu3h2WLtna7WF6LcK5tpyGFdkkXRbE0UiyvNIKlkUJ5pSJ5q8Txat67EiHd+PlqFdCbIZ7PEc7FBgsaIpyXcptXEtEy3+iVQnGSGoTzWuNX6in22UK6SSzXr6tGOO8a0bwSt7lRNK/BZV5rjnmnsmfPHgQCgbLtKGvd0fF98ODBguV8XC5/PBqNivzyj33sY2X3Z/Xq1eK9GLErBfMuE8u12A0zd7CZaK53CZcTzY2UEs0bF9NSmWhO9C54s2Ka5JEPnYVOFsg1zFzmrYxlqdZlboxm0T6D6e/AkFMsRXNJt/H4/mnYnF64HYed1B7d/6sRyYuJ5WYFIdsmlpuIwXr4t37/3/fnNvU5RRtw/nHD2DjUZ7pty9zllYquRrG2FrQ2rYRwrhUHLfsavYhROG/EMZdIOiS3vNPF8nqE8naK5M0S0qsR0BspnlM413+vxYRzs7iWcsJ5uZiWakXz+egy75VCcfMVNTEFzM7sa2QeuXSWt49qhfOuE82116lDNDeiucy1WJZSOeb9DhWTsxnkAQfzyA+vCzpUTHdQPnkgECgQzIvhcDhw0kkn4Z577sGrX/1qsSybzYrHV155Zcnn/vjHP0YikcCb3/zmsu/z7LPPikHSxYsXo1lIwbzJFBM7qxHNNWqJZ6lENNeWN8ppXgkU0FslmpcTy40u+2KfsZTLvFwsS6tc5vl1umiWSl3mEkm38cjeEDw+f/5vSwxE+auPQhoPJ0U7zb9T/k1tOTQjlheLYiFlxeZGF84sIpZzP0b3mc8kYrvG2JGNaw6LomwXuOzxv2xrzb5X07Zw20YJuCWE87LPmQ9IoVzS40U+64lhqVYsr9VVXk4o73SRvBKMn6FSAb1S93m14nkp13nFcS0lhHMzt7kUzSvPve2lQnHzGU3cVlz9DX29qtzlxfp04SK1amqlTDHITqZSV3QtwnlXiebl3OYVxLNoLvNSxT87PZal0bzvfe8Tdd5OPvlkEa3C2UJ0j2uDoRdffDGWLl2KT33qU3PacIrsxvY5Eongox/9KF772teKwU9mmH/gAx/A2rVrxSykZiEF8wbDzNhYIlNSNCcUZioVzfXiZz2ieTmqiWfR3q/TRfNaneXlqNdlXi3NcJmLAqBdJBJxhNbqLP37zBj+9iS9jz42ZcMCNzaiD4NViOYUyx8bm8qL5Bp1ieUaZmJtJX9v1Yi8s/tjtk+aVF1SHC+1D+1oGxopmndR+9axNGlAtVx7LttySb1FPktSZ2Z5NWJ5u4Ty8P65udn14F9cfZ58PQJ6Le7zSsTzUq7ziuNaDMI5RXNC4dzMbW4W0dIrovkKvxVuX/FCazMWa1W5t71UKE5Sv3Be1lUuo1jaAoXhnhXNtdcqRZ0u82pjWTrNZV4pF110EUZHR3HttdeKehQnnHCCqBuhte+7d+8WA6J6GL31pz/9Cb/73e/mvB7b6scee0zUo5iamsKSJUvw0pe+FDfccENTI7akYN5A/rEvWlBoTS+cF4toaaVoXkk0S6vd5s0UzSmWs8il5qiu1WXejOKf1cay1Osy1/Zf7zIvKAAqVsosc0l3MRlJYZHuz5uiN/8OTl5cmXjCNnjbRCzf3poJ5TsOhvNt7P6906KYZF1UKYa3lXaJ5vMZ4++jE46/LBwq6aUin/qijgbaLZbXKpQ3Whyv5j3qFdL1n7kR7vNKxPNaXeeacF6QcV6j29ws17yXM80rzb3tpUJxktqF84riV0qJ5Z3Qd+pRsbxat3lZ0ZwUE841V3c1wnkjMHObl4hmqcdlXkksSyWiecDReQOqhPErxSJY2P4aWb9+PVTV/LO43W789re/RauRgnmDxXI9xYTzakXzYjEbzaSVbvNmiOaaWE60+0qE804u/lmPy1yffz/HZV5jAVDmUDE3itNjfD4fli1bNmeUUCJpJk/uHIfD4yv4++Pv/zfbahP2zMTyrSOHdG1JizK/57NoPp+iQioZPNFv07TvIYtlfhUeu4pYSsGzYXbILaW/m8nDYqJE0lW55fp1RXLLmyGWN1Iob4VA3g4hvRb3eTHx3CzzvJzrnMK52A8T17kmnFcT01LMbV4qoqWUaF6JyzzLa7glQ0h7XbBF4/DuGzNrzTs297aXCsXNW+LTgM/T3BxyKZa3PI6l1OvUJZo3w23eCMzc5kWiWepxmReLZaHcNOFbBtXpg5KIwDbxbFHRnMtn5MTMpiEF8zbEtJQTzUuJnxrNjGZph9tcKwqq7feWT59bV/xK3j2to5zbvFqXuVksi+Yyb0bxz6a7zKvoYHC6DKc9TkxMiKmT7Nyy6A4dHRwZlEhawZN/3YFo0pb/O12+yI81C31Vv46+fX1s+2GxnY5y/o3MS6HcTLTtoIuQrqbWWQZN+B7W9Gdw0uI0+t0qrAqQUYHJGQWb99uwfbLENHV/F82UkPQsjYpiaaRYXo2rvJuF8mr3tV4BvVrxvBbXeTnhvGxMy/gh8ViLaTG6zZstmk+vWoJDJx2JRJ8fqtUCJZOFcyqMBZufRnDnPnQDvVQobl5DQdvV15zXrQeZX942t3ndonmrYlnKuc31orlJNEsjXObRBWsxveJUJDz9AGOtshnYIpNw7XgEwYM1xGxK6kIK5g3C7Si8sJxJZkq6zfWieSXCZ7XRLN3oNteL/Buu/m3Fonk1OeWVRrQ00mXeyOKfjXCZa99PKZd5ObH897//veiUsqCO3W5HKpUSGVVcTqRoLmkVz4zsyf+OKXDjpGUVi+Z6oZzt6pNPj2F03+HOb7OEcu5r7t5TtG3l32fHifUyoqXpYjl/G2a/C/4u87+FBsW2UCw/a2UaTqsKTmhLZQG7BRjyqGI5KSmaSyQNIrDE13x3eYkoFjM6SSzvJqG8WQJ6NeJ5Pa7zYsJ5RTEtZbLNGyWaFxPL9551AjIOu3CWW9IZZG1WxAeDYjnpFtG8VwrFzXv04na94nmlQnk9fdRyudU95C5vFuXc5nWJ5u1wmVcpmmsYRfNqXObKkrWYWPNiZG1O2JJRZFIpwGZHOjCE2DG52TBOKZq3FCmYN4CdY/GSArpePNe7zTXxUy98GkXzdkeztCvbXBPNNYzieT3FPEuJ5pUODjSq+Gc7XOb6gRVTl3lgqGgsC10edJZTLO/r68tHsDCLkMI5CzBw/bp162Q8i6SlaIUvH+GF79IqXYez7ZYmlrdKKGc7SVe8hj46CQhg374QRmevbztGOG+maD6f4liK/DaGlwxgyZKAGOTUn1t2LAmIeCDTDP2avpOscJZTLJ8Sp4TcFE+K5lMJFX1OVazfPlkknkUi6fBCn/VGsVSCMYal0WJ5LwjllXy2RovntbjOywnnVce0FIloKSWaV4rRZc4YFjrLKZY7piKzrTlgTaVhmYog2efD6HPWwb9zX1e05r1SKE5Sp3herZtcGjq6RjQnNRUD7VTRvIJolnJQNB9NAoeWnyLEcuvMpGjL2dRl0klkefP2I776FNgPbmt4W+7yOuC2F89IT6d4zjHJjpkHdMN5M88f//hHvOIVrxAnOkVRcMcdd3SkWF7Ofa65zfWUch1rhSTNHMxGp7NGIwRrM8oVDdWLT9XEwpTbVi+e1yOWV4t+v/RCc6GwVYhxgENsb4jbqQe9wF7sd2P2m9H/Vvj70A8MaGKNHormZlMYGcNCZ7mxs8rHHo9HrOd2Ekk72nIKitu37K/6Rqe6Jro3mhXrl4sbxVDeFi8NClFUL5YTIZLq/k65Dbev6mJBu3VKpEilInivi+U8Zobjpv0utN/Gmg2LxXe+eqE/L5afsTogbudtXIhTT1qG405Zm3/OnNevAmaWM4Yld7oydpAVxFIQ67ldr/GJT3wCZ5xxhjhfceDXyLe//W3RLpndDh3KRS6YsXLlyjnbf/rTn0Yv00n9cqO7vNlRLLVmllcillNM7mWxvNjnreUz83iWOqb8Hsy+C35f+u+M36f+O+V3rX3f/A1ovwP+NrTfh/ab4e9I+y3lf1/639yscK79RimaawM++gEhY44/XealRHMNZpYzhoXO8rmtOWCLJRDvD4jtugXGrzzzzDPCoPPwww/jtNNOKygUx3barFDcS17ykqKF4th+J5NJ7Nq1C7feemtegJe0uC2nEF7JrVIq7fc2Oo6li93ljcovL/X65d6j5DEqFXVjkiFeM/5h81sxisW96AR+bSBAGzSgy5zQZU7oMid0mRO6zDWiwWVIeAZgT0UL2nKrJSfaKokY0r4BpAeW1fyRJT3uMOd0rOOPPx5vfetbccEFF6CboGhu5jQvlWdu5hYuRTNjWepxm5NGOc4rEezN8sub6TIvFcti5jKvN5alkS5z7XNWmmXOaY3MLKebnB1T/p+uc4rldHAwezAWi4ntJJJ2teWd4sbmQBSF0GOOrP0ilW1nNOyp/jPp/46rEFONg2dF31fGs1SO4fjzGFMcNw6YEE0o57nk9OVBrB/KbXNw9txnnNGkRRIVvE8F3wsLfDKznI5yIPd/iwJk1VyOeTILeJTcdr0GBZMLL7wQp59+upjCb+ZufNnLXlaw7NJLL0U8HseCBaVjPVhs7rLLLss/9vurz23uJprdljfDXV6OThDL5zO1Os8rdZ2Xi2upxnFeym1eLKLFrBio3mleSzQLC3wys5wxLGyx+X9hS8xmRY65JZVG2uMU20kkTW/LoxQ7XbXXa6mGVvRDiwm0RUTdWsRyo7hcrojmvIloaWaOeSlhXFtnNsiid5qXiWapFpfXh6xihS2TgsI+umKDSgOGqsKCNLKZJOD0iEKgktbRVYL5eeedJ26djEfnJo8ZcsyNormGWZ55McyyzNtFNcKy3qmtF88bUZy0VirNM6+n+GexLPN6Y1mqyTLXY8wy1x//SrLMfT6fEMZnZmaE6MAbhXO6ESiWU0jnem4nkTS9LWenXOcW7ERKDRay3aB72GxglH+7m7ZPNOaigesqyM4mx5+80nTmEtuNv2/aVSigVyqal6uN0Mvu8grEcu38sX6hJz/AynPFCUsOX2SsHPSKdn/tQCx/PuH2Iycuxc/ufLzq7yWWUoQw7rYBNgvArgs75yrF8gyQzuaEc27XazDLlhgdino3Im8ajAa49957TcV1IxTImZE7X+iUfnkj3eXV0iixfL4L5c0Qz2uJayklnFM0JxTOzWJaKoloMYrmGrWI5lo0i3CWZ7JIuxwitzzLa4rZBt2STAkhneu5nUTSsra8RuNG1a9dCS10l1dCOfe1fn23i+c1i+bNjGYpJZabbWf8/ZQRzYsVAC2XZe5MRmBRM0jb3VCtdqStjrxgrqSTsGTSyGQzUBLSmNhKukow73T0Yrn+sV4414vm+jxzjWIuczPx00wEbUScSjXU4sZup0jeyM9VafHPVrrMKx1kqchlbiJiLVu2TIjhzBQ0kk7nRD+KBdxOImkJzeyQF3ufCt5PK95ohiaQnn/UUO4C3EQv1gbE7v/7/vzr1eWcr0A0P+usI/Hmk5fOaZu0Abnv+Ry4//6nG+vgr1Qs1+97tzjbqxTLz14xlI9sM0a5kUG/Y06k2/lH5tr4//n1lsJ88zKi+bNhBTwFsD4uHYnUVjQooPPhwUhuu/nOd7/7XRHf8rrXva7stoxgYS7uEUccgTe96U1473vfC5tNdrUbSae5yyt6XSmWt0U8LyWcF3Odmwnn1bjNSxYENRHNi2WaG0XzUnj3jcEenUFsQT8UFVB1zbZqsyLN2UIHJ8R2EklX9tXr6fd1WBRLtXEo2vbdLJyXE82L0il55hTOKxXNa4SieTb0LNzJMEK+xWL2pzobzJKbOWRDVlXgmN6PgcizkJJ56+jpXjxzz3jTCIVCLRPLjevKiebVuMw7jWoiWjqNbnaZm1FR0dhKXOZFxBY6ySkcMIaFznK6yblMi2fR1vNeIml5W16qQ23WQa9XeC0iQmtubWaVm4mjxrgNM3hueP3R7DABvwglKoqaqhXuL8XyK89cKdohoyirnZ+4/7lCwQ1ymVcilpt9b90QB2PY76Elw0V/D5pYTkG8HGZC+uWnrRBt/Tfv2jo3oqXocVIwk1JgUThDCMhkc4XjLLOCuZp3l7e3LTf+rbNAW6uLtNFZTvFb7zo3493vfjee85znYGBgAA888ACuueYa7N+/H1/4whdatq+91C8vFsfSane5XiyvxV0uxfL2i+eVxLWYRbVU6zavKKKlCtFcTymX+T66zGMJEcMixHLRoKsiZ0sVDTpgm0m2uTWX9Bo16yyt7L9VKpbrizlWQg3RG/Xmhne7cF5KNC8ZzVJKNG+mu9zseZX8nmp0mRO20fZUDFBm2/JsJtchZ0fdYhVtuTUVE9sFDJcM9urH8iW9WPSzWj71qU8hGAzmb8uXG4pkNajgZymxXMO4jdlFr4bm7tOEVc2dbCzkaBRoiVHIrRSKMcVuldIMB3srqEeIMnP2081dCWYxKo0u/qlhVjDWiDZwoM8wdr/kMwXbsLr89PS0EMXpmqNwTmc57/mYy7me2zWagN8pBP6SN7+sdt+LNKQt1xfEbGRhzCKvU8xJzL/F89YOlRTLjaL5805cKv4+zYrz1uuu52u+5vzjiorl2n5wHfedA6Ml96MUFMj1t3KU+kytyMZsoliuwUieSsXyUrzu2CX4wGuPEkVBC76fIscp6MzC71JFcU+O37MvLpzlSu4xlwdcqtiuGZRtz2fbcv6t6//22RaYcfXVVxct1KndtmzZUvV+Pvjgg3jqqafwtre9rey273vf+3DWWWdh48aNeOc734nPf/7zuPnmmwsEhflOvW15OXd5PRRzl+vRu8ulWN4ZVFsstFiRULPioKUKgxqLgpYqCGpWDNSsEKiRSouAJgJeJAPenGieTM826LM5W8m0WJ4MeMR2jWaZzy0GD4rduF4yz9rz8FhnRKC0eB9KucsbWWSz2QU7m0mpfa+pCGgxV3e1AyC1iu36rHQTt3uxAqBGtAKgjkAAcVdfTjTPpIRwDostd59OwZKMIePuQ8rdvL6QZJ4J5nT3ULzTbnv26JxXDRLLq6GYsK4JFI1wGOuptNBmOcG4GuG8s0RzFX5bCoOOhLjPTWipHONn0TuxzYqrlsqUr6R4a6NmGBgHWgrW6QZZ9IMrprMDZoUWvWg+NjYm8svptKM4zsxy7cbHXM713E4i6Ya2vJXQSUyxfGEVs3F4fnjnqUfgjS/fUF40rwG+JoXwcucfTbx/5fNXzp2V00TxmmLzcSevwVkvWI1zXnCEuM+35Z0mmnN/iuyTcTBby6/fONRXt1iucfaqBXjnS1aLwZo5+2VgwA247cBMGoinc5nl2o2PuZzruV074d+6/m+fbYEZV111lRC2S91Wr+Zvpzq+8Y1v4IQTTsBJJ51U9XNPO+00MaC8a9euqp/bqzS7La82jqUad3ktUSylmK9ieVBxYdjiFffdJJzr0f8W9KK5XjivRzTXz64wiuZmeNcGkHE7YI0nYI8nZzPLM+Kej7k843YiMdDbRYglHdaeU7Bul3DeqPetM2ajWQI3X7Pdwjl74tPwYlTpE/dqs0XzTqES0byMI54uc0KXuZ6wcwgpm1sI5s50HBYW/8ymxb09HYeVgrnDjXQlRU0lDaOnI1maNXVXL5ZX4i4vFs9SrAhop6KJ5uYRJip8liTsShapaAKqN9DWqdz99gTWeCPodyRhU1SkVQWTSQe2R32YTDkrjmapN8u8XCyLMcu8UdEserRYFi3LvFQsSy5uYe4FBEXzmbs/KFx6jF5hNXXGsLDQpxbJwgKgqVQKFotFRrJIGko7YhgaCcVRiuUnLw5WJZbrxepLT8zVBWBWNakpR7yCHHP+LcciIaRTSdjsDnh8gfzfc+F+oDAzu9H4BoVYfv5pw9hgH4cyE0aWAoDVihUv9ONXD01iPNGaOhAVUeS4coDDeA7RxPLnLh0sOdusVtG8/58cuNnnxIP3PVliS5Wz9cHTE7/eFGd9zp61uUt2Sy6ipdqB5kYTCATErRzDw8Pi1kgikQh+9KMfFXW1l+PRRx8V58MFCw7Hgsx3Km3LWxXHYkYxd7meRrjLWwWFaYdiRVLNYFptn6ll0OLBkdZhDFm9sMGCNLIYy0TxdGYU49nGHStNNK8m57xUcVAtqqVctnmpiJZK4lmMVBvNoloUpD1O4US0pNL5afwsAJq126CozZktJJm/VNw3N4rXtUZiVPs+ldKAOJZmC73siYXgRVKxw6GmEEBU9NdqyQZvhNB+MGbBNscqTFj7kIYNDpsFA2oIR2b3YFANNSeepVg0SzOyzLU+fbHZyJXGs8y6zM2iWUxd5ixCYbEg6fCK9tuWTSHLthwKslY7YLVDZSxuXR9O0tOCOS9etm3bln+8c+dOcUHCvEgWWOoU9FPajUU9y6FlxWrFPzsxjsQoLvdZ41jhnEKfNQGrkkVGtWAqM4lDtoUIqe62iOXHB6fgtmYQSdmQUhXYFRXDzgR8tjT+Pt1XlWheb5Z5qeKfjaTsb4aZ48koFljTmExkWT1iTvFPzVVfLMucf2uEwrjL5RJiAKGgxkiWeDwuRHRtO4mkm9vyRqC1B/zbr3cwjGL14azqaPXZ3mXE8vDUOLbt3oaZyBSymTQsVhsCfQNYunIdAv2Hn7thgVtEjDRVMAewbokNy+O7YE9l4fMFYLPZkU6nMBwexZkrMvjzM8A4OjfPXCv8qp/t1QixnIMa0XAIqVQSdrsDXv/hQQ1C4ea8jQuxb1/ocKa54bcxMaOIfrndlnOU51+bBZyzgMsGJNK57XqN3bt3Y2JiQtxzAJhtD1m7dq0oaq3xwx/+UDjE3/zmN895jUceeQQXX3wx7rnnHixdulREtzz88MM4++yz4ff7xWMW/ORz+/tbVJSqDfRKW66PY2nI63VAFEurBOpK9+Vk+3J4FDtC2ThSyMAOKxZZ/QhYXNiU2tPwfapGOC9VHNSYb14s27wW0VwdGMb0nkOIR61wLhiG/+BoQZ65RrkCoJ5QGBaLgpTNBmtcl1VOoSWdRsblgCWRhWNifs5qkHRYW15KaKxETO+EuJcWitPjSgBPW5ZjQgkgDStsyBSI0zUX1KwBCr3j1n78zXUcZhQXfGoE9mwaqawNBxQfptVVOMW6s3mieb2U+30Zr5NKCed60dw7CDUyjumUFQn7MJwzUwh6B6BEi2fdG7PMxUvGc++TsTpgS8+Itjxf9jObRsbuhlVNwNaEyBkP61Q5ivf5M0leIcyNIp4PdJVgvmnTJnExos+LJJdccgm+/e1voxMw5r9qRT1LFQEttl2lRRyNjuFWZHdr4jLF8qPdo3BZ0ohm7Uhn7bApWQzaZuDNPoudlmUtFs1V4SynWD6RpDiV+8NPqop4POBIYbU3gs1TdHhXJgR0ssu8XLFY7XcziBim9+9CMDIFJZsBY2n77D48mx1EBPaKXOaEogyFcgrmFBIokmsOcz7W1kuHuaTb2/J6nNuVFBKulfOPXCjuvwkUFnissyAmxfJdW/6GZDwOl8cHr88vxOmp8YOIRcNYd8xzCkTzpiKOpYqF2THYVRV9/YvybYrd4UTWFYDLEsa6YArjh2wd7C73iIEFDkzy/ECx/Pyjcvn1tYrlUxNj2L1jK0KT48hk0rByUKN/EEesXoe+gaF8f4JtP7PvibloroDjpjaK5oxGVA/XFbIpuf/nuim915Zfe+21+M53vpN/fOKJJ4r7++67T2SQ64t9XnDBBejrm3tBF4vFMDIyIs6FhC67//3f/8X1118vMstXrVolBHOtbetVWtmWl8svb1UcSyXu8k4Qy1stUJeCwj33ZSx7eKA3iYx4PGTxivUPZp9pyns3Qjg3E83N3ObViOZj6QE89dhujB0E0pl+2JJxDLmX4cjkIQzNiuZ6l7leNDe6zHOF4lJIWazCTW5JZ6GoKlQ6zGerONuSqR5szSU91y/vIjG8VWL5Jst6zChO+NUY7EgjBRsOKv0IsZ3PjrRMNKdYTsmUznKK5QPZyXyb4lRTcKiTmLD0Y0tqGGfYQhW1N1Xvd6MLgFZTN6mEaD46A4xMD2MsnBSpBra0HUP2BNZjBsO2mYp3weVxwJGJI2OxI2uxw5LNwEIzKizIiqKfKqzpBPrsKmYqf1nJfMow54UMhTnjrdMFFrMiahq1XjTPKfypqnBmZuDNhOHmlEsxfaO50IG8BDmxfCrjREq1QoUi7vmYy4fTB1s6pZuxMIxhobN87oW+gkjaigFHEn5buuZBhGZnmTcCTYwn2eg00nufgjU2ATvFbocfaYsd7uQ0lsR3w6cevoDRDwyYZSUzdoXigTZFno8pDvCecDnXa4+7ga985StYuXKlEPqZOUvnYClY0PSKK67A4sWLhUhy5JFH4te//nXL9rcX6Na2vFKM7QjjWFYFvCXPBYXu4WlMT4yKez42wiKRb3vZOqxYX18h63xciKri4O5tQiz3BQeEKK1YLOLe3zeIZDyGvc9sM92XZhF0ZOBTY7C6vHMH4BRFDNAOulJiu7Zj0onWjq1+FhLP2xwcrUcs3/LYZkyMHYTD7Ya/b0Dc8zGXcz3h6zMbnU72JUsCpm05dyEUV8Bxdn6rFMnt1lmxXAzcAtMJRWzXa7CdMWt/9GI5eeCBB/D973+/ZBvGcwd5znOeg4ceekicH1jH4x//+IfId+3mKKlOb8vbFcdSlbtcBfxZBwYzbnHfqu6wXqCmMK3qBGou5/pWRsLQ5U7h3gwu5/pGZ5rXk3FeS7Z5uWKg+kGaPVMzeHjzKA6MpeEJujHoBzxBFw5ErPiLughjKYdpnnkxMnYb3NEoPPEZcT7P2q1IO2zino/t4Rk4QjGojg4YYJb0flsem8jFnDSr8GIjKbWPuvxydn+n0nYcTDqFxqHvDpvFsVQqllOENt7y7wkIZznF8kF1Gk6kYIEq7vmYy7daluVPK63INA9Z/CKGhc7yuSoLhKbA9RPRrGnsiBnF9rtozI1ZAVCzrPlG//6KCOoUyx85YMWBqAKPNYtBRxoelw0Hki48klmF0bS7aPFPY5Z52uKAJxGCO8VzlYqMxYa01QGVhT8ZhRsPwRGfhmpzot8hg1lahTxz9gDOVBiBmQNQZkKwICNcYRHFg4OWIYSa+BVTdKY4PT1jBeZM4cgJGv3WBJRoCKq3NdV8maHOzHLGsJiRylrgtWXgsBTP8jOLZqnVZa7RrixzdnYyY7uhphLClSnsg5ksHE434kkbHOkQltum8FS68PMWuMx1Jwhe/Hu9XlitVuEop8sum82KaBau49Q9Cs/dIhJwyj1dFLfccosQy2+66Sace+65wjloljvLgYCXvOQlYt1PfvITMRX/mWeeMXUgSiRadjkF7krEcrqG9+7aitDURMlIFL4WXxMvA34ccOLxvxyeRlvUCVHCOaEko4hEJ4WzXBOnU2kVdpsiHru9frFvzDb3Fqnw3mgcFpV+CihW83NYWrXApahiu06NYtEjZoDlJgfU3JbTWR6PzyDYP5j/nhwOJ+z9DkxPjmPPjq35dSwkuhF9WL0whL+b/DbYT4imFKQyKmy+XIFPOiiyCjCTAiZiQDKrzLrMJZLWUWl+eaviWEoV+yzlLu/PurA63Y/+jBs2KEhDxYHoFJ62ZJrq7q5YoE67WpJpzvx0RsLQ5W4Gl1thEdu1YkChUsd5NW7zUrnmRqf52Myz2DZiRWwmjeHFfUAiAji8cMaiGPJkMRazYCTjw6BtrihUzGVuS6XhSCREoc+k34q02wkWqVCzOWe5azIMazIFS7I1ph2JxFS07NJChaMpB0aifoylnEinUrApPgxZY1jvmKjKPaynlJisrZumOB0MCGe5mTjN5eNKUGSbB5EzvzXbac4M9bRiEzEsZtjVFCKWXNa69lk0cbgWGh7NwhkMZrEsZSIri11fsW/O38ZMKoYhN2UWN5CMwWlVMWRPisHPkcwAhqylZ7Rp2LNJuNJRWLNJZD2LELd5xEwhBSpsqTicMxOwpROwpHNtv140d3KqqKQpdJXDXDIXWyKEwfBO4RZOWeyIsZFixIYawZKZ3QgouYZcy6ZuRByLBkVnTZxOmWRnU9BgpjlFbOP7N4uUahFTYZhZbobdwox1BclsfT/9Sl3mWpHNYi5ziuYaxvzxUlErxdCL7iQzE0E2Ng04PTmxXA8fOz3wZKJw43A2ux6jMzEYDMLtduPQoUNCNKdAPjQ0JO75mMu5ntt1A1/4whdw2WWX4S1veQuOPvpoIZx7PB7cdtttpttzObNv77jjDpx55pnCXfjCF74Qxx9/fMv3XdJhFIlBYTRGpWL51if/KiJQnC4X/MF+cc/HXM71RlhEdPkiv6mDuNLO3zFHDuH5S30i3oMZ4XoomvNmtdmFgM9CoC2ZKUNBN6sgSy9Nxvy9GP3Ftp7bdSLaOdbs/FALzCznb8Dj889x3POxx+sXojm30+Dvji7zNRsWz3k9uscpjC/w5jLLJ2eA8ZncPR9zOddzO4mk16gmjkWPMY6llFh+fHIhhjMexJUUJpW4uGckCqNSGJnSEQJ1C2CxUeanMxLGDC7PICu2ayX1us3LOc316J3mkVAW42NxeIJ20XYrrsPCveL3wO9UMe7wYzpjq9hlTne5PR5HpK8PDiUL51QEzvGQuLdkVMSH+2CdicMRqqFYuETSKDTXuf7W7v2pQCx/JDQg3MIeawaD1hl4LGkcSPvwSHyJcA8bKeX0NrrIS0HROZlm21lEnEZaZJpr4nQl71+rC13bZxYctalppBRzM0tKsYv13M743FJUvV9mLvNWobu+mo6rGItmQQnFTGahuXRM6cd01jnHZW6ELnNfahoeJDDtWQSLmoY7PgnPzLi4t6kZxH0LYE3GhMtc0jqkYN7NqCrc4X2wZZNI2HzIsPFSFDHyF4EHTiWNpRY2KM0ZcaLoXEqcts0WAKWITVohmkeyDkwmHfDZeXIx7pcKn43Z5g6E06Wd92YDCpXsf6kcebPs+XLUIprryaZTOQem1Say8+esV3jZlIVNdzIu56TXQ5GcRT55323QLb5582acc845+WV0yvMxC7aZ8Ytf/AKnn366iGRZuHAhjj32WHzyk58UheMkEjMoLpcr/kyHAp3ljD5hBEolkSiaCF+syHC+U6fdDFBkP+usI3HlmSsR8HhEFjYzy82Ix5PC7W6zO6ouZF0r00kr9octODQ+jQPRGRyMxfO3fRMx2BMRjMftmJ5owhTUEsetEkTB5Nlzhn5wtR5Y4NNsUEPDZreL9dxOg9EsnMW0cc2QeXzPbDUh3mVVzsDK3Ys+v9TJJfOMhsWxqBDOcpdqw4QSR1LJgpMeI9GZlkSidJpATRc7i40yO90MLuf6Vrjda41pqVU0Nxt4SSWziCVjsNstSOmvwj25gW9HwI10trixhy5zDbrMNbSBVPYSLJksrOmMuOdjVQRmykZd0oF0moiug11u4R7OWIVb2GnJcuIGnEoGQ9YZzGRt2BLxVJyCW6lQrqGJ04lUscFPmygAqhen0eR4lkA2jIHMFCKKz0RlYcKBV6zndnrqEc2LRrNUEsvSLGavDxIZFemsCrvLpF6fwyUGMKmVJdS552NjLIuGJrzzeDqQhi2TElnmWnhCt7XlX6ky+vbHP/4xNmzYILY/7rjj5sTe8lqYtYgYjUuTJnWbrVu3NvUzSMG8TozFO1slJhBrKgZ7MoyU1WU6rBVT7QhaZuBVEjVd8OtvZlB01ovThS5zFV5LCpMZpxCxNZovmivYHvWJkxsLfDosGTGNhfd8zOU7or6GqAHlhJBGuMzrEc0plFhsdigsEqFzabodh//sLSovmyxweCpzO01PT4t8VlZM9/v9ouAZY1l4z8dczvXcrp2EQqGCG3PWjYyNjQmhm8K3Hj4+cOCA6evu2LFDRLHweWzAP/KRj+Dzn/88Pv7xjzfts0i6F7YBIwdjuO+ZMRws0fYx6oQxLIw+MXMP6yNR9NQT2zS8ZADPXd0vXsPtDcAX6Ec8FpmTU87HXO729wP2w072RgnBRYlM4NE9WWx7NoKRHXvx6PZRbN4+Ie7jB/YjlrZi634eU6W5Irl+udk2RYR1njfH9o1idN8E9u0r/N5qwW53lBzU4DRhrud2RpidzizzoSWzIp1vEEGnCrcN2DPNHHMFrAvHx7znYy5nTAu3k0g6nUoKfpbLL6+WYnEsftUhYlgiStK0eWp2ZncnCtRPZ0YRU1OiwKcDVnFYeM/HXM717aQVork2IDOdmQQ9JqGZw+eFvMvc4xUxWDaLCteyWTdiBS7zGa8XSacT/aOjcM3M5DLM3Q5x74jE4Ht2TMS0JAMms9Ekkm4Q0RstpJd7vfAkpjN2EcMSsKXN3cOWJMZUP6ZhIpbWKZYbxelMMoFs8nD7ImrNKB6RZR6YjWNphWjOw7A2uVPUy2OBz4TiYHiiuOdjLud6s555w0XzdrrMZ3Fa2X9mvKFuoeOwppJULSKNgYMslRCxB5GwujEcfgaeVEQU/0zZ3chabXAlw/BO7UHa4UbSFeyq6NvrrrsOf/3rX8WMfEbfMpHADNYOeuMb34i3ve1t+Nvf/oZXv/rV4vbEE0/kt/nsZz+LL33pSyIV4OGHHxZRwXzNeLx5fRqZYV4DM7MiebHCXRTN9VPwqxXRKWBUIpJasmko2QyyinluNqfpuMX4Y7bisZFi4ri2vHDqf06c9tnSQoxmQc1UQoXbZRVieTxrw+4Ep520diRsMuXE36f7sMYbERnrzCxnDMuhhFOI5VxfCdVkmXPavVbcrdos83oo9zuxun2w+4JITIxBtRa+r8tmhToTRtjqQ0JcWCWL55jPQuGZ2eWDg4Mit1t7bLPZRG45xbXx8XFTgbpevD4nbK7S3116tpjr8uWFbko21Ndff33d+8C8duaX33rrrcJVf9JJJ2Hv3r248cYbxXtIJGZQNGc0C9t2s3gWRp1kS7iHc5EokXwkihGtnSrWfpvBtoz7dfaKnCi/8Ii1mImFEZmeEFnmfM9MOiXEcofLjYXL14jt2ObweRSCm814wo6H9wHronEMuqKi0xlXFYzHHUIsH59pwJh/jS7ySp/H72R0X+7/EwtLZ+aWwusPiBx7FvhkZrl+YIXtbiwaxuDQQrFdJbD7QnF8YkZBKKmIvEWrRZS4QCKTy0sccOe2awbl2nOtLZdI9KJhtegLftabX14ujkUTVB0qI1EUpETfO0dSF83UisxuCtAUxilIU6Dne9JZzmXtEKiZ2b4ptUc46zlYwM9Pu8aBTFjsSzMz3RuZbc7vuJZMc32e+UJ/ELZAAtEJJ4IeFSmLAns2J5pnZ0IIzwCLF7oQdEaK/jyMWeY7IjZkrVZ4QyF4olH47Q5E4goUOs1pxFEUJAb8yDah6OcCTxA+T/HBn0im9TMHJG0mMsVKtLn/02zRTJG7llz0CsX3RH4m/WxbnizMK3coGYRVG5IqZ/g3XqTWxOmwyyfEaBbUtCeTyDi8Qiz3qAmsyz5bUmVphmg+mJnEifHHsc2xShT4ZGY5nfALMmNif7m+GPVmmlfkMtf/5vhdNzE7P+hSMOS14EA4g6Fc0EMe+o9oLl3kiCNoqUwXSVkcotBnANPwhqeRtLowo9qE5sfscs4VmnQNImtzdl30LaHIfeedd4qI26uvvhpGvvjFL+JlL3sZ3v/+94vHN9xwA+6++258+ctfFs/l9Q7rzX34wx/Gq171KrHNd7/7XWF2ZFzuG97wBjQDKZg3yGVujLuox2leqaM4a7FBtVjFH1HWkF9FOE2H7uG0QSwvll9eidhiFM5NxelMGmNZrxDLpzJzO1GVFNCsF+7XpimHyI5i1jqnNuZiWKoT781Ecz10WZplf+f3I5oQkQl0mdPlZ3SZU0QrVwBU/5vQO0or+Z0Id+qiFYiGw1CZZU5h3GKFkknBlplBzOLEuHVBvoXnZzE6R/lda987RXGK43SU8/+cLqOHQrkmnreTPXv2IBA4LByZ7Q+z1yl6Hzx4sGA5Hy9atMj0dTn9x263F0TQHHXUUcKRzogXxtNI5nmOuUFI1dqAUjDqxDLrHmYMixEK11okihFmVO84uAB/37Sr4G+1krbtt3/cLv7/zycsFtEvKzeciIO7tyESmkR8JiIcy8HBBUIs53q2OV/+8y7cf//TVYnzNRMZx3iEwvkAgg4Wa1ZFZnkuhqWNYnmVaKL55JFDprOIKoFt+RGr14lZBswqZ2Y5Y1joLKdY7nK5sXz1ujkzFIrBcX9mldutuf9TJNdHHnM518uin5KuY3Buwe5qKJZfXilJhZEoKuywIKkTzVsZidKJAjXf88HsM6LYKAcL+PnbEcNSiXDeSNFcQxPND85MY+GqIA7OWLDv4BSG+gPI2i1QE1mEJjPwBN1Yv2QGShRQjhhEdve4GDBK7ZwWLvPYrrlOSxb9tGQyyNis4v/2VBJ23VecsdugMKJFFv2UtBp9TEYjxfNi4nc5cbQKp7ozX6vNAqcmmutIJtOwKhz8TDfcXV5KnHYoFixSJ4RYPqjWP4Ox1v0amJlEyOIXGeqMhaEjvpIeaDnRvFjhUtMCoHSZ+wbQFnyDUCLjWL/Anssyj1GnyRlNkhkF4bQVbusM1nvDUOwDYl+5/6UiZgJuwJpNI22xi1LhjkwcvPKbSeeObMbqELqfVvSzG6Jvr7nmmoqjb7mcjnQ9dI9TDCc7d+4Umos+Tpd18xj1wudKwbxDneaay9xMNG82GbsHKYcf9ug4EsbiC6oKj5LCRNaLqMpOW6LhAoBeNDcTpz0lRPFWiOYUx8Ppxrm5W+kyNxPNiwnn5bD7+mBbehQyY7uhhCahqFlYmY/o7MO4bQhOux8xQ/Y6P58+Pkf7rtkoUWjev38/hoeH57gcGX9CUbndRT8plusFczMobtMhfs8994jpPpqDnI+vvPJK0+ew0OcPfvADsR0bffL000+LzyzF8g4hNHb4/4GhwsfVwufX2D6KgadF/oJ4pmJ4fAEE+gZEgU+K4sa/q5loGH1Di8R2Bc9zWrFxqA9vPj33mKJ5dfsZw8/ufFzs35tPXsopKXCsPBb+WASZdBJWmwN2jw9TioKpcAzf27TXXCwvUvC0YUQmUNi9VLpGLNfgMdtzIFwQwVUtfQND2LDxJOzesVVE9PB3wUENOssplnO92Ww4M1jMczymYJFPxdiMajimKgIO4EBEkUU/JZIq4lhIWEli0jojCn5OID6nuaLLm8J1s8XiThWoxT50eNJTI0RzDc1lrsffrwBHxxF91oOp8ZCYD+yyKFi8fBDrFyUwnI0DgWGo+yubCcCin77paYQGBuCdnhY/OZ8fiIRzhzrp98BzcFwW/ZS0F2PGdCsE9DoIWlMYsidEwU9mmBf0klQgpLqwyDKNIGaKurnrEctLidMDXkvbk6z5/kFDVnml1CqaN4TwKOBvXB2RYa8Vpx7hwMieGMZmFIRTgC1jwSJ3Cuv9GQybzA7mZ+Nn5DHgsWCOeSIShz8dQjAxjnH3QnjjM4aeORB3BeCa2t/Wop+hUOEgDU2JZsbEUtG3W7ZsMX1tiuGlonK1+2ridBuBFMw7IPe8ZhQFM/4lsM+E4UxHkFQdYqInp8W4kEBUtWFvlqNu5ZvUWtyCetG8FnG6NaJ5/VTjMteL5vW4zMtRba65xRuE4jkWqUlOk0tjOp4bcEnEqhNvKOSxEAMzykdHR4UoTaGYo4hsQD0ej1hfqcux3XAU85JLLsHJJ5+MU089VUzziUaj+alDF198MZYuXYpPfepT4vHll18upgW95z3vwbve9S5RZIJFP9/97ne3+ZPMU8LjgLWEe7sesVz//GqE81mX+TMje8TDY44cOly3oMjL8O9l6cp1wikcnhoXmeVaJApFUYfLg6Ur1s75u9JmMlE0P3nNjMjKfmYkWnX7TRG8eMHiw8fwwfueRMdi/K6rHOxgvrf+fKR9f80ebK8WiuLB/kFEwyFR4JOZ5Yxhqb7NVbB1woqAK4Mht4pQUhUZjHSWUyyPpXPrZfVPSa8xHt/blIKfeRRgh20S/qwDA6oLE9GI+CtqVyRKNwjUvSial4tmWdTfB19fDKvTg/Aqw3A4LFjkdQDTzPBaAIznMl4tRVzm+liW4WVORPfsRdzrRTQYhDMWgy2dRsZhE2K5bSaOvm17ZWsumX8Ceh37xW4V3cG5LHMH/NmkiGFJqlaEsw54lCjWWw7NyTdvhTidCR8uGtmt1BLPYuoyb0Qsi8kM4WpF86H1A5geHxMzNp2JCIL2TO63UYVkw81XhJ9G1B5AyD0MTzIEayaJtNUpxHJHMoYjpkYabIPN4fA54dTVuTOSSHKWRbhpsbedjBTMa0ATKejuM7rMxfISF8JGsbyUA6wS0s4AQv5VCMwcgD0WghMJJKFiWvFhRyaIkFq+EEW7hOZuwvhZKhH7K3WZ60XzSlzmtUJBZWigX7x3Jju39abQT8G/HHSWc+oLRwc5ehgOh0UMC13WFMu5vlu46KKLhPDPasscmTzhhBNw11135Ucud+/enXeSE54kfvvb3+K9730vNm7cKMR0iucf/OAH2/gpJE2nFuGcf+f7JvCkTjTnQJdZhrl46f5BrDvmOdi7a6soAMrMcsaw0FlOsZzri8HX5YAc36+6WJbD25Vzp7ckgqUWig2KcHmx70vXKebxes35x2H9wsJz1Y8DTjz+l23oRNGcbbkvUN1FBtt2YxwbM+A3MyN+IINBjyqmkjKGhc5yiuUNyYiXSOYBxoKQk5Y4/u44iNXpfvgtjo6IRJG0VzQv1pb7gzwPTCDoWgqR7NC3FOrU3nwx20pd5r5QCCu3PI0Dy5ciEgwi4XYjrWSEs5xiuWuiPdENEkk3C+jD9iRODUxgJOrH2IxNCOU2JYtFtgiOxG4MWSJFn1uJu5yuYjPoOC5H0/PA20zFLvN2xrIY2vM+0dyrQB2Ra32JcRw9sQnbnWsw7R5C1hFAOpVGILwfC8ZH4IuNNUUwb2Tsba3Rt1xeanvtnsuoO+m3oYbTLKRg3oQL32LxLA1zlhtI2P0YtfkQU0OwIY1QLIsZOBFSK3MP1yOEFLrMq6dbXObl9r0el3nBdgaXeaNEcwrywuE6C/eB+1IOs8KfhKI4G0I6zZlbzsaSMSzd4izXw/iVYhEs999//5xlp59+Oh566KEW7Jmkl3hox6QYrDpv7RAWFmnzKIr7+wZETjULfDKehTEsZn9X2sCtPldcw0w0Lyekd6wgXs/sgVKi+SzHn7wS5x81JFx/2mAGjy2/q/17pzG2r7XF8RoNzymbtk+Iz2IGRfHxvQqCTnU2dzEX1yKd5RJJfVA032zfD0si1VGRKJLmi+ZmmLrMPX2i8OxCT85oErMBnrQui9/gMi9X/BPPhrDmyRBmvF6k7TaRZz61LTfDQSLpWgG9zcI5RfMh61ZMe5xIqFY4lYwo4qhGi4vltQrl+vWViObdTi3RLBW5zNsBo14aBEXzo8b3I+oMIm1xIjqThCuRi9tqN4EKYm9rjb6lxsL1//7v/55fxqKfXE5WrVolRHNuownkTDh4+OGHRQpAs5D2oTrQF/Y0OsUpjhtvRvTPqadIqIAV0K1uRK1+zCiuwjK9NaMi6Ehj2JUS98XmdJYWYcq7aPRZ2Z1MJZ/FiFnMgSZUU5DR0IvZxozbaorE1VpQruaR1L4+4cbmfTeK5RJJVVQa8TKb6a21jVo7sP1gBL/ZNoaRseKZf/w78vqDCA4wIsR8EOpgOC6Ecl5468Vyvp92o0B++OaB35bC8kFbyba8a6gmaqfEtvrBXr3zX/s/B0TrGRCesyuhREFb3wq2HMpF9fD8lT9Xz8mcZ1a5BaMxi7iXYrlEkhM4NegUrgklF4kymo02TCwPKi4MW7ziXtI60byaGQb6jHuz345ZYVl9VJDSt9T0fRjLQhjLUgy23p5oFIGpaXHfra35V77yFaxcuRIul0vMan3kkUdKbj81NYUrrrhCuA5p4jnyyCPx61//uq7XlNRIZDLn+m2kcK7d2gS74n3WBBbaYuJejRaaEMzyy0uJ4eyFh2wBjNuHxL1ag6jeqIz0dtOQz2D8vRl/K8ZsezNxu9n1mKpE1KJITKNv5hDcOrF8vPZSSG2Jvv3617+O73znO3jqqaeEqG2MvtUXBeWsfc70//znPy+SDBj1smnTprzAzmtiiukf//jH8Ytf/AKPP/64eI0lS5bkRflmIB3mNaAvvEihW7u4rmeKdacx6ExhXTCOQVdKVIhOqwrG43ZsnXZhPGFvuNO8F6JZKnWZV1sAtBnxLBrcH2NBQn4GUbBQIpHU5FrWk8vCXg4sCYiIJormGuuHirvWivHQ3nHc+fhoXohnlIrZoKXWJvfbE1jjjaDfkRRtedybOdyWj4c6oiBmVdSbSz+LNpCweqFfuP2MbFjgxqYlARFz0yj4W/hSOI7Rl6dw6YnLmtpn4Gvzt8LfG89TXTeDQCKZB0JrNQxaPDjSOowhqxc2WJBGFmOZqIx46RCnuRGzaBZjAVDNZV6KamJZeoUf/vCHQmi55ZZbhLDN+kLnnnsuRkZGsGDBgjnbs47SS17yErHuJz/5iYhLfOaZZ4SZp9bXlKDxImYjYjOM+dRdyIR9ADs8azBpH0BGscGqptGfmsDq2HYMpAqPmXSad7DLvBKBvY2DPN0YfXvGGWfgBz/4AT784Q/jQx/6ENatW4c77rgDxx57bH6bD3zgA0J0f8c73iEGSp/3vOeJ1+RAaLOQgnmdwrmZaE7KXQQXyy6vtphjs8Tyk4Yj8FizCKWsSGUV2C0qFrmTCDjS2DzqMxXN68kyb2c0i1l0QSMxyzJvZAFQiUTSgaK5roAMhdJoeBjr1i/Ii+ZipslR5UVz/eyj+54Zw48f2I3tW/bn1pURQd3JKRw/lIDbmkHc4kLG7kA6FcMidxwBJYrNsSI51fpOYCeJ5w0SywnPSW98+Qa8/ujDGXh6WEj1zbkZgEUHJWqBES//M2t6a5ZoronlD+wIYc+BcOHsqA5z0EgklcBih5q7dj5Csfxk+3J4FDtC2ThSyIgioousflFIdFNqjxTN2yyaVxrNYvrcBsayjD1baHhZvFjB/v3dNavsC1/4Ai677LK8C5Ei95133onbbrsNV1999ZztuXxiYgIPPPAA7PbctRWd5PW8pqSDBfRmRrU0SOAs5pren/DgMf+JiFvc8GXCsKkppBU7xuwLEfEHsDH8t6pF81ZkmfP1m+1mr/tzGLPMaxlcqbP4Z/HXnTCdkaAd00pmE3QrV1YZfXvhhReKWzHoMv/Yxz4mbq1CRrLUiSZwGyNVigniXD4nvqXeOJY6YkXmigCqcJZTLB9L2JDMWqBCEfd8zOVcbzalvxsdbMWcmeWPoQqfJYF+6wwUMS0rdzz0zmyzAppGN7cxmqVg2yqjWVoZxyKRSCpAJ06y3dg6ckgImFpb8L1Ne4WwWewcwOW3PLJb3D5131Z8866tQizXYldKk2vLHdkEJpJ2LFjUj+WLglAdToyFk/DYVFHssWw8S6cIrPWI5SbPPfWkZSJPXlVVxCLTmJ4YRTQ8LR7rRfPzNi7E8JKB8sdIu1Usmm/Bt//2LBqJ1r+oqU/BY6S/SSQSU/RxG62CznKK5WPZKJLIiFab93zM5VwvaU1cTalZA6WiWYxRP1osC13mjY5l6USYM6u/sf6RGXSLb968Geecc05+GR2IfPzggw+aPodT85lxy0gWOhfpRvzkJz+JTCZT82tKWgBFRO1WC13m3mW7TWc5xfL+9DgcahJUWXjPx1zO9bXGs/QSPAbT8GJU6RP3SZPIG7rMq6KSWJZKqfHaqNw+x0y0owlRV0jSTqTDvAY0YVKLyDBzmpcSzat5j1YTdGREDAud5XNzTBWxnOu53XTS1pEu82KFKufuU+kCeMWc5ow42OAJiQwzq5JFRrUgao1gb3YAIdXdMJd5Jb+9Sml1bm4z6PPaYXeXdt2nrF0U7CWZV9EsWnuzf/Z6WIts+t6De3HexjROXhwU5xENnle+/+h+/OzOxwueX1NbbjNpy5MqBj2qKPaYK/JYh+OC6zpFWK+C2PQEDu7fhUhoEplMGg67HYG+ASxduQ62MtPkBWafWVtWxqHCcxRFc0KX+6C/vhlFFfU3zPa3mDhe5e+70e25bMvnL7Fd010nBjYTir+MYaGz3Awu5/pg2jVvi4p2Q1yNFstSicu8m2JZFriH4PeYX/sQT3pG3C9fvrxg+XXXXSfyaY2MjY0JoVubsq/Bx8y0NWPHjh2499578c///M8it3zbtm34t3/7N6RSKfE+tbympMVoonm1rvMuimgZizsw2TcgnOVze+WANxMWMS1hWwCBdJHIxDa6zFsBP8d0YDmetizHhBJAGlbYkMGAGsKR4T1Y5LdU5zKvhXLXPGZ9ab34bhTmJV2PFMzrQJ8rrRfNiV44L4XeCWYWx2J0GTcbh0UVObeMYTGDy/2KKrYzo5eyzM0+C8Xy44NTcCODuOpCOmuHTckikA3Ba03g6cxihEK5HPBas8wriWbR//aKDa60+rcjkcw7qoxm0Yvmi5cG823Dbx47iId25JwyWtvAdoLFPCsSyk06bw5PFrZMGqmsB2oyha1PH8gNJo7nBNJUBvBbEnDEI0A4m3tSqc/SrGmKbcKZCmPv0zuhppJweXxw2+xIp1OYGj+IWDSMZeuOx6ZpVbj6czn0BsoNEJQ5Xtr3yoFTnvs9SWtN0SxmM9YeG5sSOfdPPj1mvu+VoonpTRTOJZJOwqwYY7txKBQMLCKGxQwut8Iituv2es7dEldTbzSLlmXO35tZDY1qY1nK0QmxLHv27EEgEMg/ZmHORpHNZkUO+a233gqr1YqTTjoJe/fuxY033igEc0mPC+ddIpqnFIfILGcMixl2NYWo4hPbmTEf8szHrf34W2YV4lY//GoMdqSRgg0HlX6ELB48N7sfQ5ZI5Vnmxt8GxWzvYKHQ7R+uvA/fInPQTMRcw+mmgp+9hBTMa0ATIilkmonmpBLhvJpp061yCCeziijwycxy/t8Il3O92bquzTJXVTx/7Gn839CRuTLYRUVzVRTPYx4wIw6ALOxOK1KqFVMZC4ZsaSy1TCCUWVKXy3zO80qI5hKJpAsoIpprbR0LS1YdaVWm00YdNZ0F7JkYktZcG6afeWPPxJG2KEim1cYIpFrHst1Oc7bn4T34P//ywva8YHBDRWDmAFK2NPr6h0QeHrE7nHC7nQhPjePuzY/i9m1ujO4zmfJb6WesQDTXYrq0/kClormZo5yvwZx7Dr7MEcurcZebbSdFc4mkohiORpNUM8IxTRGYMSxGuDyDrNiup1BVvODZafxxWXBO37xYXI2GFlczZPGK9Q9mn0G7MCv+aURf/JOxLIMu8ziWYpTLMe8EKJbrBfNiDA0NCdH74MGDBcv5eNGiRabPWbx4scgu5/M0jjrqKFFkjnEstbympMuE8y4Qze1qUhT4ZGY5Y1iMpBS7WM/tOpGac8xVFda9KWSW2ku25bwa2eZYhRnFhYHEIVgdubbSiRQc6jTGlSCemgngeZ5IqZdpHMYZo9Ve33RZZJDNF4CthG5pE9cp8zOyUWaYN0A41wuXRpc4L2C1m9ljs+eVEkKL5V03iumkFeNxOwL22WzbZEx3i4rlXM/tilFvljlF82aj38eXHnoCv/vz5/CSQ0+W3NZvS6PfkUQkxXGmuZOpppMWBC0z8CqJurPMeyFCRSKZF9SQ95zLII8JobwZYjlhzMp4TEGAY23J6OF2nCRmEHApGI9kMT3TYNdZm13oL53eid9t+RFeMr2rZFyNKxWBw+PLi+Ua6Qxgc/pgmZmGEg3N/W6q7TCX2f7Xv/wbvvznXfjRP/bjzqcPYtd46d+CsQ7KwXAcI2NhcSsqljcCmW0u6WAK4ipm3bi1YOb2bTeMWWG8CN3SZnA51/daHMu5uyZx948ex0t3TdYfV9OETPNSWeaNQp9jzliWbs8xrwSHwyEc4vfcc0+Bg5yPmVNuxplnniliWLidxtNPPy2EdL5eLa8p6RCqyTfvcIHSnw6hPzWBiNU/ZzIQH0etfrGe2xWjVJZ5s4ty1op1dxKeO6bEfSlCFj8mrH3wqRHTyBo6zimaT8NdOhfc+Jsx/i6qzTIvV6Oo7PNrzOiXdAxSMK8BipmaoFlMNDeLV2lkcU86k5uDgq3TLsTomLbG4LCy5Kcq7ofcQCyeEuvnCsbdy2v2bs7d78vdm0HRxGHJ5uJq1MOfPaX73tOqBRZkYcPhDpuZy7yW71LGq0gkXY6hs6UV7myGWJ5DwdYJK2JpRbTdBW25T0EsqWLrwSIDc/UKoxTNtVujqNDh/JqJp3P3k7l7MxgppqgZWK3mk+ysNjsUNQu7Urwtb7RozjzzHz+wW+TWUzTXhHHjTQ9F8t9sG8OdT+VujPYxFcvrcZebPU8K5xJJS2EWd0xNCce0A1bRA+c9H3M51/car3l6rOC+7riaFlJJ8U/T58V673ushfe97334+te/ju985zt46qmncPnllyMajeItb3mLWH/xxRfjmmuuyW/P9RMTE3jPe94jhPI777xTFP1kEdBKX1PSOLLRkBAxqy7K2OOiOdvt1bHtcGVnMGkbREJxIAtF3POxKxsT63tHYclh25YzCdq2l575klTsSCs22NXctUk2Wbg941mYaR6L5OoiNJR6CoDqKZFfrv09pEwKmEo6GxnJUgda1rQWmVGsGGg5zMT1djKesGPzqA/rXAlRFI61yDi1/0AkJ8CMz4RqFkIqiWVpNhRC/nXHfQimch3YC2aF8gv2bsYuT06UmbZ7cOuqF0JVDo8phcJxpPsU2BUVSZ1orsEs82RKRXr2OXSZNyrLvFQ0SyNgVIyZmC+RSBoYWVFPDngNUSfjMxZs3gesG8gcbssTCRyYzgqxfDzagkxT4+dtcGSLoqp4x6FHEczkOtYXzArmF0yMYJcz576btjpx64IT8o6eZHgK+w85YXFO49il/XDqpnGTTDol2v6UamncvpeNZ4nlC8KSM1bnpq4Xa/N5Pnhgx2EX0o6DYWwdOYSxfYZOf7sjciSSBhX+TO2czjtrCbOcmek8H2AGN7O4tcKWFIEZw3IgE+6owpb1tuX/+uh+BBM5seS1s0I573cFcw7xaacNXzthMdTZmUHtjqsplWVeDC2Wpaoc83nGRRddhNHRUVx77bUiVuWEE07AXXfdlS/auXv3blgsh8/PLCj629/+Fu9973uxceNGLF26VIjnH/zgByt+TUlzMIrmJfOmm13MsQMYSE1gY/hv2OFZIwp8MrOcMSxDqYNCLOf6rkdVYX98Bkoy1+u2zwrmvFcDOZOQ6lCQOs5dENHiUFOwqWmkFBucsznvFM0ts9EszDJnAVBulwpFYQ/kYqxMs8yNv5dmRfbUIbRrMwJKzRqYSPTa8El3IgXzGtCiMyhsGkVzYsw1J8WEc6NYrneqt9NVTNF8fNyGoJOOxFweLqf4V+osr7f4p1mWeaOiWrzpBK596ucYSEWFFzw7K3B7Mwlc99QdYtrFhN2L7y8/HRH74X1gDM3BsIKlgfRshrmSd5nbnTZ4LSmMpd2IWksXsqk1y7wa0bwVvx1VVTE9PY1EIiGK9wSDwTnxBhKJpAGieR2iJ0Xz8b1Kri2PT4nM8ppiWBrlFi/3OqU+KwclDO5mbzaFa5/9MwYy8Vx7PtsuezMpXPfsn3LtudWF7w8dg8jswAbPZWzLbc8ewEwGOOWIw6I527V4LIKsO4iIvlZHI4TnCr57DrQ+tn1sTmyXcXCVaNvwnFKVWG7iEA+6FThsSuW/j3B3CvG7du3CDTfcgHvvvVeIJkuWLMGb3/xm/Od//qeYtq9ts2rVqjnPffDBB/Hc5z636GtTxKFr8b777oPP58Mll1yCT33qU7DZZFe7XahTewtiLVpJoyM7KIozizuYdgnHNEXgXoph8aYyuO6BZzAQT8/2zQ8vv/7Pz+TacpcN3ztmASIOW0FcDQt86jPM9XE1HFTo+uNUReFPtt4xrxdpuw22VBruaFScFTuh8Gc1XHnlleJmxv333z9nGaNVHnrooZpfU9J6Ab1q8bxS0bzD88wpivdPTyBsC4gCn8wsZwxLpVfQpYp/UoRl1nhbc8xTKhwPR2FJqDmjiqJb/lCuPco6FaQ2uDhNKP+0QDaMgcwUDlmH4FAn80+jaK44nAgrHixSJxBAfdG/psU/SxUArVQs17vLa5jpEDNE+PLYzTiDSNucsKUTcCU6M3JnPiB78XWguYHLiead5CKnu1tf+K0o4kJbmRXJi6xvclZtswqARuxuPPfsj+A7m76O0ya2w6bmpt3znv97cGANLj75HQViuT6uZsCbwIAjhUjailTWArsli6A1g3jWht2JPkQzifx+N9pl3inQpbFlyxaMjY0hnU4LQYBFdTZs2IDh4SpONhJJr1BNYcRK28+GuYNn2/JwtoHnEm9Da1fkqbK4TsTqwHOPvRjf2f4rnBbZB9usj5z3oj33LcHFa/5JbGfWlvfFQ4jG3bC73cJZTrF8z0wWv9+jYGzfWPOLCJkcP54ztBk/2uCqWd0LsudAGPv3TtfsLB/0Kli30IZBnwU2ay7Dndn2LZuB0GJ43mJ27de+9jWsXbsWTzzxBC677DIxNf9zn/tcwba///3vccwxx+QfDw4W/5vNZDI4//zzRQG5Bx54APv37xexASxEx2gASefAgoosrNitCPG39/40hQh+6r+ciO/euQXP3ReGbfYz8p5t+QNLAviX8zfkxXINOuwpjDOehpnljGGhs5zL2hlXw1iWhUOVz6htROHP3RPA7qHFCG3wI5ZQYMlk4JuexqI9e+ELFc9FlkjaKZ5XJZz3iNOc6kqgRFZ5V+OwIPaGAbh+Ow3rgTSU2bac9/xvepEN8XODYjvjMVmb3Imwy4cJSz98ahR2uskVO6JKEB41gXXZZw/r76Gp6lzmzRDNm8S0awh7BzZg1DGEjMUGazYNb2wMjgMjcEdlLGKr6Twlrgv47Pnr8YE7R6oWzctRqthnL9EJsSx7PIM493n/gX13vge+zGE3dszqwEuf9x9IW2xFnfcP7wOOWZARBUC9tgwyqoL9UQf2YxhTmcoE/mpc5q2MZjGD39Wer7yqQCx/+OGHEYvFhKucgkAqlRICAR3np512mhTNJZJq6PTYDIO4e/rZx8xpv4wwS7umgqb69zQ7LiYu8z3OAM7dcBH2/fXL8GUPn0djFjteuuEipC3Wom35ixcGMDMTgz0dF5nmz2Tc+OWWJLbtGWvu92MyaKIdq1DIlR9cNQrnRrF8+5b91R1j3bGjWH7SSjs8DgWhuIrUDGC3AYuCFgTcdmzeleo50fxlL3uZuGmsXr0aIyMj+OpXvzpHMKdATgG8En73u9/hH//4hxDZOcWf0/3pZGckwPXXX593r0vqi2WR9DZ7Ai689PUbceArD8KXOjzAG7Nb8JLXH4e01dJxcTW1xLJUA2dIcKaEEcYTMaZIgzNjtyxdhLjdAU9iBkoogYzNitDAAOJeL1ZueRrYLx2Kks5jjtDZCDrcZd7rqH4rZl7TD9/XRwF9tJQNYjms5obMwcwkTow/jm2OVaIAaMTiFTEtw/H92GAfxaAaav5vohLRvNIolhoKfk45B/H00IlI2D2wx0JwZVLIWO0I+Rcjaw9iwZ5HpGjeYqRgXodoTiiclxPNSTXCeWeSxTK/Co9dRSyl4NmwUkEma32xLM3mlMmdBWI54eNTJnfhwcG1RZ9HoeWPe2xY2B8QhUCTWQvCaRs8Oje83h1fr8vcjFaK5nqxnHEFdOhRLKcorkWwMJKFjzXnOd3mMp5FMu9ohsu8CTB+Y8Cbi9iaiGbnRnAU+Qxsz48/eSXeddaqsue0Tav7RRFLCroaVYvnVbjNT4nuLxDLxdOzKZwSPYAH/SZOvcg4xjGIPa5VOPPIINb63UioCn7z6Dj2TW0t2K5plPgNGM8VmnDO5RqmYnkV+0tnOcXyscjh7z+ZhnjMwrBcP76jvQP5IYMrkuca3hoJB3oHBua6kF75ylciHo/jyCOPxAc+8AHxuBiMaznuuOMK8nDPPfdcEdHy5JNP4sQTT2zoPs9XjDnmetT9o1AWF7/IZR40c6F7iaDiwoAlZ0CZyMa6P3qEbfn+cIFYTvj4lANhPLg02LVxNSz8uX6w8WYhDipFd01jh3cY8awDwVhYODDTqioiWbzT04gGgzi4fCncI9M9V1BQMg/d5h3gMud+NqyoqVBZgAPOJZixeODOxrAosU/EUHUiFcWyALAeTEEx1GHg48yuKNILD5+MjfEyFM0HZiYRsvhFIVBmljOuRWGtT0PcTFNc5uVEczOxvEwcS6W/FfbGtzvXCLE8MDOKeCbXYtsySXijo5h0D2NqeD1c0THZlreQHus6th7NFVxKNK9EODe6y/UZ1HzNlqNz963pz+CkxWn0u1UxIJhRgckZBZv327C9omtpFX5bukBcbncsC3n5gb+L+58vPgHXHHshPv34j/HKA4/i/AOPlhTMcygIp+11OefrcZmXEs0blV/O477l0+fOERYYw2KWV87HgUBArOd2fX2HT2CNoM/jhMNTWihJKvNjloakR2ixs5yO4uOX23DEoA0ue+7vdyapYs9EBn/fU8RNPCvoUiw/64Xr8PqjgwimY7Aqdri9gaIDY2evGBJt1p2LanPePbL52bkxIyVc5i+f2i7uf963FtcccRY+vft+vHJqG86f2mYumGsoCmwePwL9fbnoNKUOV3wtVDFwsm9fSLj2NeoRyzlowhgWOsvN4HKu53Y1Zd7X2Z5rbTmLuem57rrrhGO7UWzbtg0333xzgbuc+eOf//znceaZZ4rCcj/96U/x6le/GnfccUdR0Zx56MbicdpjrpM0h6KFP5n3zNznCmEUBiMxGgldx43OMdcYtHhwgm0JVtj64VJyfcYZNYXd6Uk8mt5XsauagnunCczn78i1cXesHcQ1L1yFT9+/A6/aPoF/2j5RVDDv1rgarfCnnoOxUSz0mAs1HBDiwJCRsM2FSYcXnulcPnDBcyhIxWIIB4OwBrxwhhp7fhtwLUHAVfzax57s/oK0ki53m7cAirYUb2thp3sVHgucgGlbv6irZlGzCKYnsTH0KFbN7CybY84mTy8uUx7uBDHVuiunR6RWOZB4ng/2P4Tg3J2GY0+6QDDXil7qhXPufzDbhPNnNTMPNGFcE87rKPCpUe43ErEHMe0egic5N9Oejx0zIcS9Q0i6gnDG5YyhViEF8wZgFDmLieZmwnkzY1joaqa7uRQUQUqJAxTLz1qZhtOqgrVOVRWwW1nwVMVZK1PAgRlsD7uLPr/fnsAab0TEl9gUFWlVwWTSge3RJBKu/rZmtd+56AQ8HliOHy47VYgmF532b7jo2Uew21OZeGHmoNeL5sVc5pVSzmXeDKc5HY16B6MRFvjUMsvpvNP+T8cfhTNOOw+Hw2I7iUTSOQy6szhzuR+LvSnRjsdTquh8uex0GltBM/Oft5mL5mznzj1zMc4dGEd42w5MZdIivsQX6MfCI9bC32feZm4c6sOqM2ubZfSbhT78z6+RE83N4lkMovmdfWvxuHsBfji4Ideer3sVLhrfgt3OQMlZAFp7R7H8+4/uF0J9ywc0dLnmPK+M7uODgYLzN88nPL8UPV9Xua8s8MnMcsawOG2A1aIgk1WRmB2fT2UAnr64XTsVqD179oiBWI1i7vKrr74an/nMZ0q+1lNPPSXqbGjs3btXxLNceOGFIsdcgzOk3ve+9+Ufn3LKKdi3bx9uvPHGki5zSe2E9kXgX9nXUbEsFDIpaBqhS5huYQ3mVDOvulVQLH+eYxWWWALIQkUkm4BVscANO9bbFsCnOPGn1M6SojlfQ4swscECltlk8cxWRJiU41drBvDYsBc/3DAs2vLXv+poXLRlFLur7EO3kmbHspQjabEhrVjgyqSRtNmRUSxI2RXYUilxnrel00i43RhYake0R2OTJfNMNK/EZV5LLAu3NyvYyPeqIl6jUhc2xfIH+56PpMUBVyYGhVoJHBi3D4vlpJhoTsat/fn4krRiE/ElA+mp+uNLGkBmlQMzgzakj3SKtjx8thvJnWlkxAzX6oqZlipqWtZlXo5iLnONckK53l1eJymLA1mLDZZMEkmrC0nFBkVNi6KfPGpcnrX4kbU1/nxo9/fB7rIWXx+f2x+aL0jBvIGYFWvU3L7FhPPOJiuc5RTLIynAY4O4wNYun/0O4LmDE9geXsw/4TnPHnSmcHwwArc1g0jKhpSqwK6oGHYm4LOl8XTaXVHmd7Nc5nSRFzjJFQU/XH5aVa9RS+xMuViWalzmrY5noVhBkfyZZ54RojiLp9GB5/F4hMhgtVrzArpEIukUVKwbyGDIkwUsTHgFfPZsvi3nPwuDVqxbqGJ8TCcwzzqfl/RZsCS+G/EpG1weH9w2O9LpFKYnRjETC2PlhhMLRHOP02r6/1LEEoUdsdcfvVicT79511Y8M7KneKb5LHSRFzjJ2Z4PHVXRe7NtvfPxXbj//qdb6y4v4jY/LJofpuR+1SDsJ9O5GWNHDFqEKG5RgKwKxJIqJiJZMZOMBUC5XTuhWK4XzItx1VVX4dJLLy25DfPKNSiAn3322TjjjDNw6623ln191ua4++67i65n1vkjjzxSsOzgwYP5dZLWxLKYwfxn5kCbQScvHb3dBIXuYcUrRG4WuPRanLDDAgUKrFCwgrmv6hLck9xWVCw/2b4cHsVeUCRzkdUvCmUyD7ydojld5A/qvy625UdVPlugG9g2mcDa/sP95D3hGJbXUdvJkU0Lkfxg3zDSNptwqWY9GTjicfhCYSjsq2ezIqJFIpF0BoxhobOcYjljWBJWF1IWXv8rUDkYavNhc+AUrJjZaRrPQrH8b67jMKO44FMjsGfTSCk2HLIOIWIZwMnZkbaK5pnFDmCxzkWuKEisLm0ErEQ0rxrj4Eqr8u1ryC+3Z5OAzY7RwEqkrU6kkJtxYE/F4I2NI4sMLNk0LGlpTGwlnRqP1DVQ6NRETk00N92uipiMSrY1E1QbDTPLGcNCHYPiuMOau6BOZ3P3ZNgHHN3HUCkjKtYF43BkE5hI2pFULaCfkfd8TBH9CCenpTTqYlyFz5JAv3VG3LfTEad3tlPs1zBz+2u5tMUo9nsq9ptpVBxLMZLJJCKRCKampoQwTqGcRT+5jG49ZphTOGdki0Qi6QyCThWL/VkxO4g30ZbTVZgBstlc7R1mWVM85bZ6OGNmrT8KN1LwBQdgdzihWCzino+T8TgO7tku6hvUA4V13vg6scg0QpNjOG3QjreeuxYr1s/GchijSyrNiy8Bc8Af2jE5VyxvcyFW7ov+VpQa99NmAbxOBUF37ncwk8wJ5D6ngiV9VpFhPh4xybfvUFhDg+7xUjet8CbPVWeddRZOOukkfOtb3xKDvuV49NFHsXjx7JWfCaeffjoef/xxHDp0KL+MAjvF/qOPPrpBn7K3CT1rPv2aLvNysSwaZnEVZgy6SsQ0maAXN9sJI1QWW3NRWBnGHTJSBVbhNE8jI8Rvm2LFkbZhrLD2FxXcKZaPZaNIileBuOdjLuf6Ru/zsMUr7ucb9c48qDRzP6VYEbM6EHV5YM1k4EwlYBWucg+mBgcRDQTgn56GO9rGAWGJpAoamQ/eKRiFYGaWM4aFImnM6hPuYquaFS5xm5oztUw4hvG09/DMOA2223SWUywfyE7CqVJaVcU9H88oTmy1LGugygJMw4tRpU/cWw0u70aiRbQUw8y5b4w6qfr3U6tL3Pg8s9kJVZC22DBj8yLm7IMlmxJCuSWTQtLux7R/CWZ8QyK/3CHjWFqKdJg3AM0dXCzPvNVOYLNYDTq0NfG2krgSsZ0950BTLDlBRV+Dh9oIhXSPHVjtT+AfU3RGHJ5iE3RkMOhKIZSyAmJKtx4FkbQV/XSaW5KIZMtfiOiFZyN91jhWOKfQZ+W0VDrjLJjKOLEl7sRkqvkXOc1wmRejmMu8FrGcv1X+Zvme2sBPKShkjYyMwOVyCWc5xXNetNFVrkWx8PH69etlwU+JpFLMnNNmmdZ1CLgOnVDOv8x8W25h9xpIqgBn4QW9Fjishd3rBUEb1g0pOGLBgGndAjrOI9MTmImG4KkzdzI0OY5d20YQCU0iMxv7ckSgH+89dzG+GXDi8b9sm3u8TPLMKyYyDp4JO0osrzTTvM59ZEFPxq9YEqqIZOH/6Spn0U+/S0FWVbD1YO+5ETWxfMWKFSK3nIO8GpoT/Dvf+Y44p2mFOm+//Xbcdttt+MY3vpHf9mc/+xmuueYaUeSavPSlLxXC+L/8y7/gs5/9rMgt//CHP4wrrrhCzrhqF1XmmGvQ6UvHbyfCvHHeiFNhmIoiRHINyt9s1e2KFeusQ3gmU3jxTtGaMSx0lpvB5VzP4pn1Zpp3cuxLL8Ez9k7vMJx0l2ZUpGx22NMpWLIZWFMpJDxuKKqKBXv2dkSusUTSMJpV/LPCWBZj4c9qc8xZ4FPMBrHkZoXY1MMmOXrMbWoCCYsHu10rsD66peDvN2wLiBgWOsvNsq79agzjShAheBFEfQNl40oAT1uWY0IJIA0rbMhgQA1htfUpUaCzGTTcaV6Jy7xcNEsL2vLd/iOF2TSdgnCY25FANpOFmkkg6fTDqaoIjo7ItryTHeb/7//9P5xzzjl4/etfj3vuuadgHQv96ae7zhfKOYSNBTub7QCuhWJib8zeJ/54KbKYzcrmFG5eYLvtGSGQ63FYVJFZnsqa/0mnshYhbtsVnQpfAxTLj3aPYtA2g7hqxXTGKe75+PjglMhQ70aX+f9n7z3AJLnqq+9T1bl7unvybNDmKMQqoEVIQoAEWAG9xtggAy+YYAwm2yJZwiAQ2PARXowRPIAxIAyYYBtsAyIZJGMsoYSy2NUGbd6dndg5Vfiec3uqt6amurs6zXTP1NFTqq3QPR2qb1Wde+7vb4xYaCRl3k7Z8daNgp+jo6M466yzRGG0UqmEbDYrMC1MlXOdkeJz1d1y2/MukJ0xWs0s5XqHxSGtKrJ51s+02VaxleaoIaaOKwSVvqFyoc/da7Eh7kPYb2/6echLVRUopVLLZvm+x36LTGICPn8QfdEBMSf2xX9qP153ySB2Pb1eMebmtKQYlmbUolluFPycTGs4MasiXdAFbi3kK2PXEjkNmYIuRpMtNzH1zUKfbPN4HmNq3JjM+vCHPywS6ESx/Md//Ae+853v4LWvfe288yE7kA2x4/iHP/yhmDNt/spXvhKvetWr8KEPfajj72k5teXVUuZ2WJZmFO7xPiAW5+REsBaT5aoY1H9GxLJQBV0ReBVrqptmO81rs8luFteL554z5ZuVgX0h5iWrFTGlZcScy1zP7a7aoyT8ouDnYDGNkdQ0QsU8VI8HxYAfmteDUDqDQD4vkueuulvLpS0vpWabLoC5nFLmVtY2ZTaBiWHhtXlJDsCjL/x96myNdRU5T0gY5GaVJL9glvt0+5OaD4owt1kItFWz/D55B8alAQT1Agb0pJhzmTgYYmGWImnuhA/faxIFPwND6C9MYDh9HKFSGqrsQ8kXgu7xIpifhb+UhkftBazzCjXMP/OZz+Dd7363GNbKtMwLXvACfPSjH61sV1VVcI07rc997nPYuHGjSLnyRsbKjOxGNMtimeYDfQuNykYLTZp1LOMD/V2aKHaj7ZlY5DBumjE0yM0qapIo8OmzrK88VtZQKGko6a1QgXSRLA/KikiUl3SPwL5wzmViXzZH0ouCZ2nGcLErrukk6d2MzKn0aoVE7Y4fu4KfRLBEIhGsX78emzZtEkk9zvm7JKal1wp+Ntqm/Mu//ItoB7n/rl27cNttt6HX1A3tebe25Usiwwx3Yog3su+cEgUJU7mylcLRQlZ55DKaJa+URw4ZGlkziFg0iIDPL5jldlKVkkiCe33NX5Rz9MrxQ/tQzGcFCz0cDi7AvgRnT2LdWF+5g7cDaJZuQbF0/PXFhs8U/FSAXAk4NqPhyJSKo9Pl+ZHpMsO8XPBzeYmccx5vdpOhV7/61Xj88ceRyWSEMX733XfjJS95ie3zmMVzIc8H7ERmcp0Jdp4Tl3tbvhjteatYFnLM62lVeGHR0W4TU98n1aTg23olZsnnH4M0w7kuqecFpsVqfNNsZ9KbzHI7+eZMeO7XihYb+7KSVYRHFPz06iqCpSLGElNYNTuJwdMTGDp1GkOnT0NWVSg+d1B5N2s5tuU0zc1TT2kRGNerCifQp6SgSp4FbTmXFMmHoJqDTy8Jg9wsn14U6BYyy+1Ej4VJcL8ptd6o+BqYLCfeZUhPoEzU1sWcy3l/VGBhOumy1MOztBXL0iiapY3FPilvXx9U2QuvVkJAyWIkdQSjyUNYlTqMwdlDGJw9DI+mIhpanqMWp6en8YpXvEKgDPv7+/G6171OIH+r6dChQ2Kks91Er8aQ3fZvf/vbDb02x27lF7/4RXzpS1/CZz/7WXz961/H7bffjr/7u7/DTTfdhMUSEz7veMc78IEPfAC//e1vcd555+Gqq66ax4xcChkJYavZWSsZXM00b8ZMr4fxaF4yHp6NixvnoLecThRrJYgh3KoGnM4yfe4RBrlZiaIHU3kfYr65aOM86ejzqpgu+pHWmk8jE+dCDEtGKxfIsMO+DPqLiHqXPlJUCylTTeaUuVnWDph2y4qKMcQLON78M1VewTEEgyJVzjnX91rBz0bblDvvvBMvf/nLRSP+wAMP4EUvepGYHn30UfSSlro979a2vOfk2DiXsH/aIwxxtt8+WdTeEa2m8e+cAiTyEorqmbaUxTbvPVqAEuxDPpteYBBymetpaocisaoFPOspm04iOTuNUCRaFfuSTcxg2DySqZOmebeqTWY+C3mSV272T4hkYcFPztkZ3g0FP111f1veifa8rSlzYlnqiIU/q2lTrLWkdSdUQZqwU0vkwdkZKol/s/VkkptoFTvjm4Y7sShMn9uJ67m9FRyLY+zLCmSad0J+cut1DYqpc8SvlDDgV+ArFUURULfgZ/drObblVjVjnHddytyCgCGWxSxiWRox4Z6SflRwy4tSUIzv4VUX51z26AoGS5MiRU6D3KyoksSgOou01GfjsgBpKSJM7VgLOBbiXIhhId6lGvaFWJikHG2b6d3I4xtOmVuLcLbIG2+3+B17NAWK7IOPeAe25WoeQSUDr1KA6vGLgp/895AfYlpOesUrXoHHHntMjATliM1f/epXeMMb3lB1/3Xr1uHkyZPzpptvvln4Utdcc828fVmvyLwfvZuOGOZPPvkkLr300soy//3LX/4S//AP/yA4jouhT33qU3j9618vhsWSFfmFL3xBFB0kW7KbZGd02pmcncSz2Jme5JgbIsfcCZblkZkI9k1JKKlzw/W95Xm2CByapWEiC2OcBvl8SdiXCCKryhj0l+CXVcHj4pzLOdWDg5k+G6PbuYhzIdZFqZJSL2Nf+DcXZ1y5NWVejRPfyeKfjapW8Vjr6AQiV1jQk4k7O+MsmUz2XMHPRtuUv//7v8fVV18tUiBnn322GLb/tKc9TVzg9pKWuj3vlba8YTVi2jaJV6n6XHXM88MJGU9MyciWylgWv1zGbfHf01kgWZBwIiWLNLrZnL3rjsfxw2M+pCALVnmpWBA1DDjnsj8Ywti6LS3VLVBKRWiqAq/3THvkM6WbiX2RoeE5G/tw3u6N1WtGNGOam03obk6Xt/G1JXyDoqBnLGj/nXF9LxX8XMla6rZ8MdvzeinzRtVo4c9uEc3y24v7Ma6xY6FslAfmkuHTWhZHtFn4JW9V45uGe1YvYViOVEx2zrnM9dzeihYL++KqrBiKGChmkPaGbI2zQjjsFvzsAa2ktrxn0uZtSJnXw7KcnXkMG7P74dWLImkujHPJg5CaxVn5I/DqOgZK08IgN4vt9tbikwjpeUzLAyhIfrBMKOdc5vpt2rGWWNfEuRDrwv9Xxb5I3paxL113bDlJjjeZLrfrUDGOB37H8cIUMr7YgrY86NWRD8YQyU4iWDhzLWQY55wGe9hA/93vfoef/OQnolYQR7ZcdtlluOWWW0QS/MSJE7aPIQKRtYfME+sLEWlF09wsJtbN+zHo2RHDnEbY0aNH56176lOfKhpzuvbvec970EmxwOD9998v2F6GZFkWy3fddReWSr98+yViMlQrZV7PNHdioFfDaXROEu6eGcET0xJOp4EjCWDfFLB/hkP7ZWSVsjFuZ3xPFXy4f6IPx5Mygh4N/f6SmJ8uBPBQor/lgpzEubDAp7cKBz0U9EDVJRS1VrAvnTVSugXLYoxSMLAs7HC5572Xz9uHhhiHCvLiicPN8/m8MM445zLXc3uvFPxspk3hevP+FNMXS9kGNaOlbM+7tS1fStEAHl7TpiHqVY1zCQ+Ne3EoIYu2nN7TgZnylC5KmC3I2DdNA2Ph7/cXvzqM205EkQtGcTqZxInJ0ygV84gPjWLjzvMFRqUVeX1+yB5vXezLWf0xvO3yTcI0r7xXq5pNmneTWd7x1yJhXyYqEuXDfRL83vIoA865zPXLseDnctRyvTZ3mjJvBsvihGPOwp9WbR04c826Yyi85Kb5jwt7sF+ZxGk1hSeVaewpncZxNYGI5K9pfPOx95WO4pSaQlj2Y1COiDmXub7VgpyLhX1ZCXJyrPKMvTkzgaBaRCIcRdHjFcYZ55l4HP58AWNuwc+u13Jty5fUNF8ErEqr4u/ywuR92JQ9gOHCBFbnj2Jj9iDW5w4KhnlQy2Jz9oDt75cFNy/IP4JRdRJ5KYAZT7+Yc5nrh/T5JnujIs6FWBf+305cTyxMK9iXTqfMF4xQcJoybzNuxYn4He9QDyGo5DAbGIYeDIm2vOQJIBkaQVTNYHRqeRb8vOuuu4SpvXv37so6tj1sg4hFdCK2Xw8++KCgAFj1lre8RbSxF110kegAtAY/68kx0IxO//e+9z0861nPmreePZAsTHHFFVegk2KxC/K7xsbG5q3n8p49e2wfQ5aymafMBGynxISwmQHNlHmt9O68x9Yxyml02pntfH5rmp2vwZpWZlLYLtXsVML4nh3BtuAUhsK6GK7Nm+tTaQn78kNie63HTp32YqwUEElvmtcphYdd6z934lzIKmeBz1lVtjynjohcwsmcf+7vNftHbNKHNVKcTJmb049MmRtpfmJZzCn/VsTjwWyAt1vmTiCzRkZGRM8ff3P8TaZSKYFhYcE0muXc3g2y/taJibGiYpppU06dOmW7P9f3kpayPe/2tnxRZGpD2F6wjWDbkI1G5o1U2bBjXdU6FEabTmxKvb9htF1TORn3n/Bi26Aq2nKOFvIYbfm0R2yfJ1Obd9d9J5HGFoTggxcKdp+9Gi956taqHWTEsoQrFURrK9wXQ6x/ELNT48I8Nz+ngX2hOU/syzpJwu4tg9i3dwSTJybK79NqMNM0T046+tvz3ucKkjgWJvuwLZISBUB5aiKG5VRCE2b5VMZNl/eCeu3avNW2nCnz8Mb4PCyLb1P7RrWRY34q27iRMzYcxvjkQqM5ujqK1MnGzX8norF9Z+mQ4IETcRKRAsKIpvFdwbbUeOxd2mHElaBIetO8bgXDYod9YYFPMsvtsC98je36e8tBdh00jWiwlMF5iaN4XI0hGY4iF/AI1m385LQwy/t6/ZppBajX2vJ2tOc0zRtBmCyJaLpbTVViWUzGK7EsZmOW78ncIcCUudXYZarYMIEHS9M4P/UADoa3YMY3KDjWTJoPl8aFWc7t1UTTfDA3I7AoTHrTvI5pqTlHpLVzI3Eug3pSFPj06wmLywKkpDBG1JPi7y2G+HmZ0/m9Lrvjgt/1U7L34XB0uygAWgz1CQzLYOYk1k7vRVydxPQSW+ZJBx5Lo6KPMjo6Om8d/aXBwUHHHsuXv/xlMfrfPFKH+tCHPoTnPve5Itj5s5/9DG9+85sFG/3tb3+749fn2HG74YYbhHNvp3POOUf0gP7rv/4rukkslkGWzWLJapqbU+adToYzIWxNJjMlbE0w05QxeNo0aczYEBo31YpXCuO7MIZ4ToU/P4NicGAOw+LkRyshpXTi/Us4XOgXxrjBMlfmEudcl9e8VbEvtd6rI3OlRZwCzS6rEWZ3/DTS8WJoIOCv2hFj1/lidLwYx1C94p80xQ00Cy+U2EgSw9LpZPlAnw+BcO3PoiD7Klwrs8jj++AHP9jR19dL6rX2fLHb8qbkNNlsMcspu460F/z+Bbh2V+0OKP6Wv1zLNLf+zfSUMEqnjkuIB3SBZGHR5jKGRarb5j1y34HKqidOqNADfdg5GhJtTn/Ah6jf15RpzrZj7cZtyGZSSM1OCZY5MSylYlGY5XbYl3kdDO0wzbtJ1vNLhwx9cSzkYsJUYYFPMssXC8NSrz032nJXK7ctZ8o8dlZtNqpdylxeP7SQYz40/0bMjmM+nm0NRbIUatX4Fvt24CdPw57GODEvZJYTw8JkOde1A/vS6zKPVmiEqV/PNN917BQywTBKHi98qoLc/pmOWytMwddKwivuYKVl2Za369rciWlOM9rKCl8OsprmA4lppLwxUeCTPGsiOpy5LEC8A6Y1n3e7dhRJOYwpKS6Y5cSwMFlOszysF7DTNwEphyUVTWcz+qZtHTFMmUeGFiV9bj4W1vjSiE/ehbQvjpLsh5pOI1I402ExGCiftKcNhGabJEdikEPVrWHZozTssbBd+9jHPlYXx9Kqcrkc/vmf/xnvf//7F2wzr7vggguQyWTwiU98ojOGOauN8gOpJlY0/d///V90SjToyKoZHx+ft57LZNHYicwvFq8w94hYv+ROSJiOkYCt2dnpZHBnJSFRZPXPEZZlb4vMCexmNKsG8XhuBBsCs8I098glgWmZVEI4UiD2pQV+eS2TooZpbk2Z1/0z6ULVQputdLzQxKo1eoHP1SwbncYVh850qziskW2SIbuez2baFK5vZP9u1VK2573Uli+GRtYMis4ztgFGJ9q5W4bxxovW1zSbRWHNYWDoxV584ednRhHVNc+FpDOscqeytHlMd3/rNmD12vJF6rpVUbxy99oFxrlT0zw2MIRt5zwNxw/tEwVANTUNXfKIZDnNcjP25ZJ1cRzYPow7TphSN05N814sDmr33tomCQnfUO92Lqxw9dq1eaNtuZ1p7jRlTiyLtNrefKTBl/WWOeZT+TKqpVbhzyeT3Y0P6ZTx3awM7IuRfiez3Gn6fSWp3UVleVbvy5c/28ljhWU5dH+5qtfa8uV+bb4YKXOr+HuNWVjlSy1iXXZre/GEvE4UAE0jLDAtq/RpwUjn9sXsE2smZV63w4XfbTV8TzXT3IlMx4j5+DAfG9WOi0hfAJJxPPGWyudHzkKQMIxzQ36P3jUei6F3vvOdeM1rXoNa2rx5s2hjrMWFFUXB9PS0I4+FnYnZbBavetWr6u5LUgJr0BmhTydyDHf+2te+Jrgvjz76qG1lZ3K2GJ3vlPx+Py688EIxLMkQ+clcvuQSe3wEPwR+oeZpOchsmtqlj+0SwuY0czPFP7tZNM0fyo7h/swqPJBZJeYPZ8fE+vZLRzygYSSsIV5iQqZ+42RO8Rvp/npqlmNupMurLVN2HTaNpti7XdbfvV2D2EybwvXm/SlWc662f7dqKdvzZdmWN5kuZ/trmOVic18A1126Hu941qa6JrOx/dzhftz4f3bidVdvExOT6VXb8VYLjVpMW5rmj9y7X0x33PEEbrnjSdx3MoGHJ2dx1NTuCXPfgWia7zz/GXjq7mfiKU+7BNvPvwRbnvr0BYx0Dl9/6zM34vLLt9c/Z1X9bkxteYAdq13kNnVC5sKwdkViG+1IiLaxaK2rptVr1+ZL1pYzZW7imLtapPR76TB+VTiI/y0+KeZc7oRZHpeCGJEjYt5NIqrHlavl2Ja3sz3vmSKgHVAvIEZoil+sPobLlIdxqfqomD9DfbxlRrpVvApPemOY8g2Leceuyq0c8y49FsKWMGWoDgGgmzwWM5WAyN5aE9setjGzs7PzRtlwVA3bIBrcTnAsL3zhCx2hgck5HxgYaAgj49gwZwPOxpowdg7B4Rs4cuSIALKzEMUnP/lJ/PjHP0YnxV7ML33pS+Kkwvj+m970JhGrZzXn5S4nqXSjcKNZTpLLy0MS0loAM2pIzNvBSLdqKKTh4rUKLluv4NJ15fnFo2kMBZpLabfClW9EdqZ5veKfK0X12hT2VJqr0//FX/yFqOL8//7f/xNMPw5Buu+++/DWt74VvaSlbs9XcltuiGb5th2jIpnNTk5Or7xkLa7dPub8OQIeMe0YjuKKDcNiunjzALbsXN25F14l6cyRNXfd/hj+5c4j+MZdx4V5fvvhyXmmuRPjnKNXItE44oMjCPdVRz0xxb7gvVbrEKAZbEzV2vK1ili/5Kr2Hhrp7KhljNd6XtNnVFO9mNJfplrqtnwx2nO7AqBMmZvFlLld8c9mOea9UPizV8T0+4SW6QizfEgO4xLfBjw7sBmX+TeJOZe5frnI3MljV8zW1fLQSmjLF1XtLvhp93xMEJtkTTFbsSBmbEivmeYC+4IMRvRZMW+3yzLtG8T98afj7v5LcG//M8Scy1y/5GoTgsV8fJiPDfNx4cQ07xbjvJ0ie/zqq6/G61//etxzzz1iNA29lZe97GVYs2aN2Of48ePCYOd2s/bv349f/epX+LM/+7MFz/uDH/wA//iP/yjaV+73+c9/Hh/5yEfwtre9raHX57irkj0I//RP/4QXv/jF+PM//3N85zvfwZNPPil6Qx9++GFs2LABndZLX/pSTExM4KabbhIA+PPPP1+YV9YCFUupxeKY18NpNFL8sxGWea/J+t6aFY2UC9eoCHt1JItASYUofrrKn0ZsRMH9E33zip82imVpN8e8Hp7FzDI3jiUzy3ylqF6bwotVVmg2xEISZGS9733vw3vf+15s27YN//7v/y4ucntJS92e90Jb7kiNGIcmY5LFPNesiVV+6/zNXXv2sDC+mxWNcxrSRudqR9vxGgWQmTY3/v6JE0lMPKskECqGAWWY5vUS9E5T6Qveax18SdW2vE9HLKji/hNltveSqJ4pbmLRN/0cTuQa4j2jpW7L29WeT50oILo+3FaeeTUsCw1IqX/tAixLqxzzpSj8uZJFU3y3bx3Ckm8eJ53FRslKJxLGRb+46hUtl7a8WS1ZAVAzbqOeMWqHZukAw9rp/t2ieriZeu+NpvjD0QuQl0PoU1Pw6iUokg+TvjGkozGcm3pgXuFTOyxLxzjmjaJZrMeIBd3j5DO0fl40zbOWmoRW09yKa+lFffOb3xQm+fOe9zzhvbAt/MxnPlPZXiqVsHfvXoFeMesrX/kKzjrrLFx55ZULntPn8+Fzn/scrr/+eui6jq1bt+JTn/qUMOYbUcN3hRdffDF27dolGm/2ftI4WoxG3BA/yMOHDwvuzN133+0opt9tshZdNJuatdLA1VLmzZipdkXmeh3N0jnp2DZYNlgmcyySJ0GHJOZcDns0bIuzYdObxrJYi7M2o1rHjt323mXpL16bcscdd+DWW2+dt/91110nGmzuzx7LF7zgBehVLWV73vNteZOm4vCaEdF5aZjlW8b6WjbLDdGE3hSLCAb6UrfjNLAnTkzjW7ftEWnzb9x3HF+45whSxdK8xLnVGHeaRDeepzHTuE5b7i1vbxnPUg1/Um9qx/PXEY8JHoPzjo12mOyullTL4dqczOVG1HDKfA7L0g2saVeti3x0muWTWgZFqKLV5pzLXM/t3aR6IxKMkQ0UO3FWumhybNy4EcFgULQn1lRhNX37298WI9Ne9KIXzVtPji7XmycmGrtNy6Et7xlZDVAuN8qrblPKvNtM8MUS2+2D4S3CLB9QpuDXi5ChizmXuZ7bW8WzmPnytupQR4jTlLmTpLk1bW410IOR3k6eDw4OilBiKpVCIpEQRnhfX19lO88HNL0vv/zyeY9jYtwacDTENv6BBx4Qz5lOpwWOhR2SdvvWUkN7f+tb38JTnvIU0YAbQ3Xo5tO1z+fbP9Sul/TLt19iy6BmYrdR1TPODdkl1uthWcwsc7NaKby53BUP6Fgd1VDSdCwMRUpIZosYCpYQ93d3USiq2nFlHEvsfPnHl/ZWWtpVc1rW7bkZwVFrauW5G1EVQ5Jm+TVb22OWGxqLBkXB0D+8dhc6rjqFKGmas7PwofsOCcb593/0CD77v4cE35yGtzGNp/KVyby+2sTHzxZKYmSMMWpqQeeAzWdety0vAkNhss0bvDRv1vheRJWZ+RGBsCEK6LzdG4VxXlGXvm5XK6str2WaO0Gz2KkVjIUdlsXV0ous8tWeGEq6hoC0MPzBxDmLjXYb07ydMjqInPwGek1MVxMPwiKYv/3tb3HeeefhqquuWlAUzqpDhw7hXe96F571rGfZbqd5cvLkycrEtrObtJza8q5nmdcyxmttazfqZYWb5ilvDDO+Qfj0AnJyGAU5UDHHiX2JqCmxnft1Dce8XqeK9Rip0alSzzSvZpzXMs9dtV+OI6aMxf/0pz8VXC2D+/Lxj39c9OCSbXXbbbeJJGavFb9rt2n+4q+cgdU3IicGuRWlYZaB06iHZbGmzGsVoexWNEu91+1UTt4fh++fP1bC6j4dqg6omg5+pByyn1PKBC8O6Y9KOvzyfJPFCZaFZk+1Tgx2unQCj2LGs1jRLO++fHPb/56r7tOybc8bNbIXGT3B9oDtFzsx+dsmqoQGdyfE1PrB8Y2CK95x07yG2WptB2mcV0OXOZVxXtu393Rt5JYJz1JuyxWM9enQNKZadORKwHjG0pb7WWnewYvoEYPZ+OzZKb56bVyMPrCOSmPxVle9qeXYltM0Hz4r0BSahSaib1O8kjKX19v/TuthWZj2PZW1N2/IMd8/U6ikhvdOudiPxUaxXOBdK9Armq4JcyWrlzCupZDTy/dBxLN4IMMveRalnjOxO+3ulOGxaTc6olVGfy/IGDJvsLO/8IUv4Ec/+pFIHN5www22j1FVFa94xStw880343/+539EATmrWORt1apV6EYtx7Z8yVTP1HaSIuc+TtnVFuwGDVFzopmmqLkzoFWEiVNT3Yop6UZN+oYx4R+FBhmaJMOjawiraQyWZhDScvDpJWSkPpSk+fcMdliWrlYNNEu948N4n9Zjwmqaq8XyOCtXS2iYk2XFSDuZvWaR6ct4O09gz3nOc1Asul9Uu2SY6Gb2tBOWOY0YkXDXdQTUHLxQEAh5MZWVWFHNMct8JZjmtUSD5ZnrFYyGdfi94uMUCvuBiF/DkUTZaCH/VtElFLX2FxrtlKqZ5q5WhpZle96t3OU5Y5Vt6ciaQZyzfbgplBaHoWXTSSilIrw+P8J9saoFMQUfPFXuNO1GMXHeblU9T/UNYUidENzy4ZAGnwxInCSAH09/UMPhhISZvFxuyzWiWnrfKKeYIKdJbowy2zwWrRx3O0dDGImMzTfN6/DfXXWflmVb3qCYsA1vjDtjmdN4HBptGsvyZFJtC8ecyWeauUVd7UgxzOXOLR+WwvBChiTJ4H99cgADcgiH1BnMaFnBMlehic+322QUjrXD/LDDZqWLbdX999+PG2+8sbKOw+dZ/PKuu+6q+rgPfehDGB0dxete9zphmNuJmEXuMzAwgOc+97n4m7/5GwwNdcc5fTm15QqvVYvzIQZdY9w2glypZprPcarpCyRUHwqajIAaQFwuiGtLJ3JimtuZpD1lEtcR2eWP9+1C2hMFAYllSch5wsh5IlibPwZZV+HRFfj0Ynd1ENTrUKnDu3fSqUI5Mc5ddZFhzpNPNd5LKBTC3//934veUVedl5OUeaCUQix3CkElLSD5Gjzo1wIYl4eRliKLajz3ZuFPHeeNKVgd0cpLGuCdu7bludAXhEi27JuWEfMDpxJFJIp1itilso7QN82kL6uNUOgPnDHliDCoZZq7WjlaNu15dAjw9sbFI3/7LPRpdGqys9P8+6yl5MwUjh/ah+TsNDRVgezxItY/iLUbtyE20B03e+1S+ztodWxbHUR/ICUMcR71Hv6P/cc83n06tgxoODCjwyPJOJWWkChITRvl1lFFjbwf82Nb/RxolhO9QpPckGGWc2QDU41HA1ns3jJYOT+Jv+ma5j2lZdOWL0HK3KnEb6UNxeMNw5dsbeJCaPgq0DCpZvCEOuEWqHQgfnb9UhA+iflxSXyG5bZcQkjyYatnCCw77YGEU2pqSTsj2HmymLJDFnWTksnkgrQ3J6smJydFWtxaaJLLe/bssX3uX//61/jyl78sjOVqIo7lj/7oj7Bp0yYcOHAA733ve3HNNdcIE97jWfoaBcu1LW/UzOxo8c9G+eQ1jNEJ3wj2TmiYLAVEaM4rDWFYn8EO/zRGvLm6hqhT9YpBXq8DwCra44/1PRXTviFIug5V9oh1bMtZWyjhjQMBDQOlWYyUxhFV5rcfXVFItlHT3GYkAmUcJ8ZrrTcawXxMtNU87xvgTVH17Z7GMdPLRY5dMidw9Gc/+9mtvp4VIas56aRYYyMpc28hiTX5I1CLOZQ8QWRlv8haDCGLkHoch+S1QCxSSZmbTfOlSJk7NZIXU3G/gnVxTfQUC3OFDZpeNlhooXPdQAhYH9cxmZWxb9oDeJwnzPl5WwuvsvCnmTdvJ37Pdux6O1nNOGPZbJzXO7a6ScNhL4J13nveeZO2ouW254skk8lq/r3vGAvjig3D5SS4A7N832O/RTGfRSgShdfrg6KUMDs1jmwmhW3nPK0x07wLDdFOnl9YW2IoWITP70VQZucx4JXKF+tEbOkS4PNI2DwAPDmDclsuWnpnRrnZ5CYX3DCgjc7rXz9wXBQ/rfcey4zxcOU4mTjR3OdijGRg50w1s9xg5vcXffbnk0U4Ruq1525b7kzLuS1vxDR3kjKvaC5lvthYFiMdzYKUZGwTG8IkNNEiMTmI+0pHXdO8hpjKZ0cDzfKg5DtjrtBskTRokMS2LZ5BHFSnRSdErxf85DHaDhZ/J6UnTkDXQtW3p3Jivm7dunnrySf/4Ac/2PLfZzG3P/mTP8GXvvQlDA9XH2n4spe9rPJvFtU899xzsWXLFpE6f97znoel1nJuyw0Zxl8zKWCaitaCmosmizE6kffinqkwckUFMa8Cn6ShpMs4le9DQgviouAJYZq322ReTkp6YzgePAs6C/CWr8zFlXf534AKL2Z9g4gpKWzOHjBflS+NqnW2NGOaUw0ifAzVNM+L/Oy6u+O0V+XekfSIrMZm1ZR5xIvS5Al41CKy3j4x7jwUAHJFCRk5Ar+Swqg2ibRc/eKtV9AsnUzHDwZUhPwyJE0TPjjbICLKvXLZLOcwLJouAY+O+0/IgmmOM4V8G+KYd0K1kqtW47yXTHNXrnpRRhvAkSMXbx7A7tVxR2Y5jQAmy2mWR/uHKggWnz8gsCyp2SkcP7wf0f7BqniWpVa99q/T5xXWlgh5NAQ8GmS5nF3JK3Nt+VzKnM6LzHZe1TGVq26W270Xo7P3ogvPwit3r53Ho2WBUnaO/MudR3Bgz8ma79dgjJs7TWma13qM3WszsD/m+hdWszxkgrTzWoLHZfm8313neFeuapnmtWSXMq9gWTosWyyLXk5H0yyf1M78zopQxfKwHBHb79IOd/z19aqIsAnBK4p8ynPnuxxK8EEWvHK27hQRLSVdXdGdD9WK5548uQhA9yo6evQoYrEzhfvs0uUUTW8mvsfHx+et57Idf5xpcRb7/P3f//3KOhbNpLxeL/bu3SuMcas2b94s/tb+/fu7wjBfSWobOsNSTLEmv7yZdLmNeP+/NxVATpUxHJEhlcrHWkDSMBwCJnNe7C0OYthzvG0p8+WoWe8ACnJI2OO8fwloeSiSFyrrToh2nJ2gMlRI6C+1UKCzkU4XGtvNFHVtBs/igHtPWY+XWua5q87JNcyXiWlupMylYga+YgqKJ4Sgx4d8yWSqSxJUfxjRYhYhFIBY0DZlXk3NmuZLYRg7VfX3pEOWdHCUnqKfSZiTbytG89M05+N9wK5RFY+cllBuKnWRaKRJQ6Z5PUxLJ+QU88D9zKa5K1euOsMu37JzNdatijZcxJfMcmJYmCy3GuJc5nom0LlfpFv4kFXafhq5PMc0jsdqTWyHRfJQ1uGRddGG60ZbPscyNyyEs2I6NsTJNPeIi1mONGJbLociGN2yDudunW+2mTn012wdRtRfXjZ3hnAkwdbBMO46b7VYPjCeFoVP651LmRBnvREa7cbnaH2M9dxqZ5YbsjPLNw5Fyq95V3n5HnMB0C4cieBqZaqaab6YKXMDy+KEY26nqO7Hqkg/kln73z0T50xPx5WgyzSvIvLIaa5wzCxRLFxiyU9ibWiWs2WrtOWeODZ4BnBYnek4M76Rgp8Gv7zZgp/mDiHjmO8V0Sw3G+bV5Pf7ceGFF+IXv/iFKHhpGOBcfutb37pg/507d+KRRx6Zt+5973ufSJ4TY2JNths6duwYpqamsHp1+dzsqntM846jNJrRnCmaKHkwmfci5lUX8Mq5HJWLmFTDSGgB9HvsO65WYsrcrpApi3wqkgc+nba4Jjjlsu4Vxrk29+FO+Udx18BlODv9OAZK00h5Y6IAKPeNppMIdguyxuiQqWacOzTNKTvjvJ55LjRVnZnuqjW5hvkSq1Gjsm4aWFUQkHVk5PJXG/R5hWnOm+RcURV148NeCV5daYr73Y1J805wzKcLXhRVGVGfCmXuo2ICkV4D5xQNF05jER3+NSoOTJ/GyEAIQ8ESvJIumGZTeR+OKj7MlKobZey0oDGyFDKb5q5cuWq/aGI2Y5ZTLPBJZjkxLHbyeH3Q1LTYryEtghlqmLlGcvq6S9eLTt3//J9DAlGyWGKn5XTeh9WhkujsVHVTW84dJEBRy6itgBc4b5Uq0ucjA2nRlgf9HkQHPNixKY1tm87C2Mh8rqp4j1VGCxjrdwSiFQxKtqCKY+H7P3qk7rmUxw118nhiDl1m3/lsfMZ2xxlNfZrl56+xv/kcivqxqRjBxZsVUT+Dck1zV8vBNO90yrwRLItfp8krCQyLnbieKWmauhXX19U80eie0jJY7YmKPDkNc7LK/RI/2fKFuaJrUKEjIPlwvm+NMNZH5b5FZ8bX45c3W/CTx/FK0Dve8Q68+tWvxu7du3HRRRfh05/+NDKZDF772teK7a961auwdu1afPSjH0UwGMRTn/rUeY/v7y+f74z16XQaN998s2CAM6XOVPp73vMebN26FVddddUSvENXi1qksU3pcj5PIZ8Q9/cMYQj5g0DxjBHsD/hBClFBn0tKO0iZrxTT3Kx+ZQZ+rYgiaQhznpQODxSZuK1yi85uURb8nPSN4t54DGE1jbwnBFXyivU00HfiGIbmOka7QrXS5tVMc6qOcV4rdW7I28cOyclWXr2rKnIN8zbr3/70Qrz4K/d39G9YizWaU+aTBS90WUbIqyGnzr8go2leLBTEEBdl7qunUVstZd4LpnmnsCyJohfHMn6c3Z8TheJojPvkstFS5iZy+H55mswBQ2ENl67TkFILSJa8KGnlk+mqUBGD8iweSvQL07wTvHZzp0u1dLmRfDSjAqyPuWLH8ioe6MpVN6TLWxGxKyzwSWY5MSxWqUpJbOd+SyYbxjffN3neZGjTsN05GsK5w/2V89SXf7JvEU1zCY9Mh7AxmsegX4MmlXEsoi3XywWdmVJkm01US59fw6UbPcjqKtKlAGKrh/GU0RCkbAKnDzyCsM8r8DjNiib6O561SXwudzx0UpjhlBXHYhR+NkzzZPJMisaug7WaWc7kO5PkTmRbbNo1zV0tV1lS5k7lJGVuxbIUJRUKdMEsJ4bFKq6nAcwEtKvqelg5iU2eQQzKYfF5eeeKf/K6XNP1cluuqyhAQZ8UwDP9G5HSC0vKjF8Mfnm3F/xsVC996UsxMTGBm266CadOncL555+Pn/zkJ5VCoEeOHHHE/DZExMvDDz+Mr33ta5idncWaNWtw5ZVX4sMf/nBVNIyrpTXNuzJlLpLScXgnFHHNSCyrVUVdhldSEJBWXlveiPEfU5JYVTiB/Z7tKEo++HQFJckrzHLDZ6Gh7kcRITWLU4E18OklnJU/IuYK8Wa+MTzgGcAF+UeaM81pUtthfTqZNjeQLw0Y57VS55SL+em8nJ9tXDVkmnNqVjQwjanRIqJDA/3QgnHIxWzZDZhLmQvpOoJaHllPBB7RC7VQ1kKU1eTUCOpmHEttSbh3og+zRWZSymY5TRYhHSioQEkFsiUJBZWFhnT0+XWkFA+KmiwafM7ZgRHyKDg7msCQP4+ol0Z18/EhpwU/zUa51Sy3W++a5a5cLY7YXhu/PXZimhEZVoX7Yoj1DyKXSQmeuVlc5noW/OR+Vhnnj6ptcJ1ilq3o8su3422Xb8IbL1qPP37K6opZbiBKXnf1NpG8XyxNFfz4n5NR5BTA7z3Tlmu6BJUF41QWAC2355IO9HlVpBUP1mwYwa61cUSCQfQPDKOQy+HY/seQmJ5ANp1Y8J00otdccBbe+HubsW3H6AKz3M4MJ2rFmLhsns7dMtyyWW5cRzi9BuhlvfCFL8T69etFMpHD8Vkw7sSJOWA8IIrA/cEf/IHYFolEhFnzzW9+s+7zEpNknb797W93+N2sHFXjMlvNQjOmwkBXmNO51cxHA4NhmJZG4tcwNKvhM5woJRUx48lhMNxnbx7IQZF8dnEstUWD+7+LB5HTSwjAK/jlZbOcyXJNJMz5X1YvioxinxxASiuITgrdxIwnS/5c72qMyBGBa3HVfSJ+5fDhwygUCrj77rvxjGc8Y14bfeutt1Z9LLf9+7//e2U5FArhpz/9KU6fPo1isSiY5//wD/9QMeBdLa2WPF0dHZk/1VDcDwwHFSQVj2GzlFPmc3zzlOIVLPO4fOZ8ZeVm23UELErSvotEQ/z85P2IKfzuJYFh4VQ2y3X4tCK8moKQmkPGGym39LxAlyTxb79exIAyhZwUxD7/JszKUUx4BjGVYbdpl4jGebXRDTTO7XjpNM5tTHweQ9X46zyexBTtvg6m5SI3Yd5lsprk1gKN9dAsvEFTB9ZCLmUQKaWRRRC67IGsleBT81D8IUx5RsugrTmZU+aNoEy6JWneqZQ5TZZfnYzh0pFpxIMAO5KZNGd9D5orNMqnc+xhLpsw3MYicmax2FzEo2IkUMCQv4i85kFayuFwoR+zqc6aE3ZGeTP7uHLlqgFZjGhzGvjSzTFhHhODYZZhmhObZW3P127chmwmJQp8kllODAuT5TTL/cEw1m7Y2nzBz1bTwzZFMWmWv/WZG23bFqariSQxPhcWtVys88iBkzn8LO/FFRsV0Z6zvSaeRdVkMWd7TiLJaMwj2Inr1/bj7DUxBFnlmcZbIY9CLoPkzGmkElPwB0Loiw1gbP1WhMdGm35ddqlu26R3tcdXQf000rlqZZlTh/ceXbYp8yuuuALvfe97hSF+/PhxvOtd78JLXvIS3HnnnWI75+eeey7+6q/+ShgqP/zhDwUCIB6P4//8n/9T87m/+tWv4uqrr16ABnC1uGiWxZJjLIsEHPTOIKr5RYFPc+KZZnlWLwlMiKv6OqBO4SeFvXheYCviUgiqxSzP64owycc8UbHNYy5UwfOt5ENE8mOVL4oRuU8UDm0W09IMv9zAsZg7YMw4Fqf88ka1lAU/Xa0sFdMFFPzSAoZ1x4s2NoNjsTPIjXWphW0ym5MdY0EkjpYwWfQi6jXqlsnCLA95VOyIpCDVx5cv0EpDswyVpnHx7P/i3vjFgk0uS5pArfi0EuS5kGdEzWDSP4yAlkNJ9gt4mSEeYV4o2OffjNPeEWG0Ezk87Mlju3YUQ3oSPYFpcZg4p6zHvxXb4qozcg3zDssoCmZ389oIv9yONV0NzcKq3yQYeWaOw5OehaSQyepB0hNHMrQK2UL5oo2JtnS60DSapbzNvhiZeVu3qBnEzIFUCLOzPuxerWDzoC4Kf9LTYhKRZnlOkRD26SKxSBNd1c9cIPCkuSZcgp8FQnUgrXihaDKGQjlE5BIez42ghPYZ5k5HJLhy5apDMhnI1vavmllullFrwiwmyLed8zQcP7RPFAAls5wYlv7hVcIs5/a2vOYWDVG+3z+8dpdIlddifPPfPF/x/NNobYlWdWCGbTDwvE2KQG0ZhZyN9pw3Qqw/oUle+Hw+k1meQ3b6tEDjsOJzMNwHj8cnkua5bAoh/+6mv4dm2PadEI/Lc9G/Ikzz66+/vvLvDRs24IYbbhDF5Uqlkvjeaaab9Rd/8Rf42c9+hu9973t1DXMa5GTkumpM46d09K1pzTQ3yzHL3GHxz3ZgWWbkPB7yj2NtOiyY2oSJ0Og9paY6ztRejqa5mtfw/OA2eOGBPlf8k8lyfo5MlxvMco4iMpvla+QYfJJHIFySel4gXNqJaanHL29WVn55tYKf1UZiuHK1lDIKPlYzzu3QLHWxLK0iNeqkycV2G9N8JARcNJTF3lRAFABNKZLwWVb5U8IsH/EVAd/8go5W2bHMV2Lhz025J0XK/KHoBTgc2gSPrsEnMCw5DJRm5hAtvBZnspx1K86cd3NyCJOeQWTlEIaUacT0tMC6jEsDSMph7Nb2Yqhb0D7mjptmUC2UzfE0z0DPL159qJUm1zDvItUzPBsxzfVQHEowBqmYQTKVhyZ7MVn0iK7RAR8qxb3apW4zx9spJvJ/enACl6uKKPBJZjnTiOW+TRrlZcM8WzLWUzoGgwq8soa8IsHvlaHosmCbzapeUTl7fWAWB8CGrsl0aA1VS3daZaQ9Xbly1aJsECdbdq4WuIxGVM00j/YPIptOigKfZJYTw9J0srwdxrmlc4DJ8mvPdvZe2XHwykuAL6QLOLCnAXOi3murhpkxPe5wwoPHJzSsi+lIFNl+E6vFLRwtpIEDQpMFDRPHU9A9fjx1LIJscgaKosDj9UPWVHg8XsGU5/eQTkzj+OH94vtp9Pu4eO2QOIf/6HeTmMkU2ma2Gx31rZjmxnMvV9Pc0PT0tMCtXHrppcIsr6ZEIoGzzz677vO95S1vwZ/92Z9h8+bNeOMb3yiK1LX1d7qMxQTs6tVS06a50wKgzYhYllPZWZEKPtpCJx9N85mhPOTxcVHgk8xyF8PSnA5pM3isNI51nrj4DGmMk11OBSQvvJKMjFasrKOG5IgwywtMMUoeYagbmBYm/7d7RnCXdrin+OWuXC0X43zRioA6McvrmeZDcQwHppAoeVAgz1zWEc9PmQfwz5O1+OdyTZk38/qZNL98+he4a+AyUeBzQJlGQCsId6Qg8zyvIS8HEVWT8Gvla2V2g874BlCU/AjqBYRQEKiWgF5CUE9gSopjn3wWBtXH0XVywjhvxjyP2OOWHauvHwjXCPN62usd9pJchnmPyWmKWCTaJQl6oA/R4WGo/ggGbE5OZm6qGR1gRYW0u1Bls6qGMOk8d1XGI6e9mCnIiPolkKDAPk+/RwcDo+mihFLFLIcoBBL2aijOnURZgJXDtcqSkNF8GPAUEGlmzJaFW+9Edma5sb7aNleuXDWPJmnGLDdkxzWn6RaJxhEfHBFzpyZcw7gTvhdjqrV9TsNrRspm+a4R2/NTtfaFpjkZ3vycHKltRq2EfdNeJIoywl5TcSFLW14qlJAvKcjm8wLHQnOcKBx/MATvXAFWfgdMmydnpkRnRjPaMRwVHQ3dlDSnkc8REZddsBYbdqxb0teTTCbnTeTZtkPErZBPPjQ0JArI/cd//EfVfb/73e/i3nvvFeZ3LX3oQx8S+/785z/Hi1/8Yrz5zW/GLbfc0pbXu1LUKjbCSfHDBSzzOeyFYVLOQ2I0gNpwYpAKSRAG74TmMstbFZP5Cb2AsOQXKXPRlsODqFRmlzM9bojMc7LLaZbTUCcGh/82REwOk/9OmebN4FgMtcLDX+4FP12tDFmTxtXUFSnsKuY6L8P7/SrGgoqYSzELk7pO+r1a8nml8cwpOiRnpx9HXEkgK/cJI1xjiy5GCJXvd/pLM5WIYVEOIOcJCS8mrOUR0M+YudwnqmeFaZ5EFwc6DcZ5Pc55LdZ5J4qWulog1zDvoP7xpU91bHQ2gtOw7mtGu5if3xYDM3dTbmakVis2trimuY4+uYABT07MWymM2amE/FROxv0nPDiVlhDyAoMhiPmptIw7j3oxW5AxHFDglzV4JU46ArKGkiZjpjS/x45pcw/3gdbS67bD+ljT5fUM8aes6eKTiUmDYa84vmtN3MeVq0VVB4tntiLraKSmZDbPa5joPK9sis1xsOcKkrIoZnJmEpnUwuKY5japVrHLhuXQVK/blpe8iEs5UftDUxVoagmlYgEerxeR2IAY7m+ITHnuw+R/K2o0FV4rXc5z/+7VcccFP2udW8wd6e083uu150Zbvm7dOsEON6aPfvSjts9HrIpd0U3ztGfPnsr+7373u/HAAw8I1IrH4xGMcrsirrfffrswyr/0pS/hnHPOqfme3v/+9+OZz3wmLrjgAmHIv+c978EnPvGJlj+rlSanprkT9ES1AqBOVK/4p8GibgbP0YjZutSigdytxTGJTyFGhVibsOzHoBwRcy7/b/EQZvW8SI7TRPdKZUwLzfISNExp8zuTyZQnJofJ/07hWOyOGSf8cqOTxziGuwrHMj1Rfq3VJm535cqhaV4vndwWZrPTdHmrfHSLGuavt1E8qyYQwYTUL+ZLVdGgFst+sDSNc1MPYLg0jrwniFnfgJivyx3BaHEceTmMwpyRnpMCKEgh+PQSBtWZhZ0RUKDAg6LUI7jaWsY5Vc04n2eeV9nuqmW57lKH9fFrd+A9P9rb9ue14lmqoVnMN9HTaQvOpc+/AM1SqwAo1Qnm7ICvgJ3hpMCU0ERWBbYkUC6MqQbbWvyz6dc/NxSdRsvUcQnxANPlZZ55olDGs8zmJWxb7cdQsCT45bKkI614cDrng+KZf5HsnXufitTZPqvlYpa7ctVLakfnoh2axamIWiLm4447nkCnOxrZ7u4YC1fMchYnHT+yH+nkDFRVgd/nQ6x/UBQvbZq33gEMSM22XO7Dtnge/YUClJwKXdPhjwQRGxhBIDj/u2XqnEx5JtCb0Xgqj/3TWRwYT7flfTVrlodNoxqM484w8RfU+eD50IQM6KSOHj2KWOzMMNNAwL6j4J3vfCde85rX1HwuYlIMsdYLp+3btwvUCo353/zmN7jkkksq+/z3f/83fv/3fx9/93d/Jwz1RvWMZzwDH/7wh0UqvtrrdlXbNK+HaHGCZrGTU5Z524t/9pCG5LBAlDB1bfDAmy2O2UnxtRCjEleCCzA3s3qu8h6CfBcSR3gWcVpLI6fPvydiAVYy5fn45YZjcQt+ulpMZTMFeIpn2u5wjWAETXOrido2NEuDhnYzaJaF+w0sRGnUUDWWeTvRLFNSDE/I6zAtxYSJ7IWKQT3ZXYUxTab5QGJaFAEtSX749CKiShIzvkEcDG8R84zUJ0zzoJbFsDaNkM1IrRK84n36RTvva61wbDs7YuodQ05Z5+K5nB9nrlqTa5h3uSomRLHUkGluvnmeyFiM8khgAS/VaQHQdpvmNMsvHE4jKCsCU6JoPmEmD3nPFMZsxDTvqCr8VmnOWJmvKc8Ipk7riPtZMVvDOQNZMUQrp8qiwNwZ6eK9TSohZDz2FxHsyDCPAqgnpyMUzKiHTcNd8rm6ctWrqpG2bWtyukED9psPnsT3f/RIQyNrztu9cd62EyeSmDgxXRXpwseOrBnEC5+1EVdsGK6Y5Yf2PIBiPi9QJSGvDxIUzE6NI5tJieKlLRcpraVaGBlb071KW17wYeq0F8GdW3DZOaPInzgAJZeGPxCatx8TyflsGsNjqwRTvpnv6r6TCfzmYGMXvbXwLewwt6th4dQsF8/R58cOlA1Ho6P9kXv3z39QZHGGgdIsNxvm1TQyMiKmZqRp5ZFeZtzLHXfcIQp8fuxjH8Mb3vCGpp73wQcfxMDAgGuWd5hrXs80b4Vlbi3+aWWZN1P8s1fM8t2+dQJhQlQJ09c0lNtZHLPdEia5XttMf6p3Ffrl0AKznOL7YjK93ZgcF8fiaqUrO+cvVDPP7Uzzhop/Lla63M40p8FpZ2waYvLXxJt2yjJvl2lOs/w+eYdIZBNTwuQ1zeR5hTHbbJq3+rp5xo8pyZpGulcvYl9kB6ZDqwW1xXyVwNNASgpjlT6NGHgP08CxQxO6WpK7XUx8pwa6a553jVwkSxfLfNPLf9vdBFczSu3QL3ZDvp2Ysp3jg+vYEimb5UyUl3RWupfEnMtcz8KYi4VnaU/hUgmJohcTeT8emY4gqxqYFrXMPJdVkaTPa14cKbABn38jaHRadCJdbsdFduXKVefbkWaLMDajJ5MZHBxP1eWXG6+THaB/eO0uvP+q7fOm1129TfDFuZ/dRLOc+/zxU1ZXzGMmy2mW98UHRVFMSZbFPNo/hGI+K4pj2mEvFiVd3jBKRMKj+1O4/SSwavNTBLucBT6JZqHByjmXuX7thq1NFXZkh/fe8faZTo0eZzTKrWb5PNN8jq9++XmrsevpW5dFce+7774bn/3sZ4WZffjwYfzyl7/Ey1/+cmzZsqWSLieG5dprr8Xb3/52wSI/deqUmFgg1ND3v/997Ny5s7L8gx/8AP/4j/+IRx99FPv378fnP/95fOQjH8Hb3va2JXmfy0lO0rH1UBR2CIt2s8wbVTdjWZjKplnOYpgsislvwCiOyfXc3ksymPEPKycFu9zAtBjMcy5zPdPzzX53i4VjceWq181zs4FeDc/i2HC1KX7Ya2pbZ4BFbLeZLKdZPqQnEECpXBgTJbHM9SyMudjjT2p1jjgx0odKk4grSWzOHhDp8ml5oIJq4Zzs8rBewDbtmMVl6dDx02onjHlqhXfOop09rL/927/FpZdeinA4jP5+Z++FI0ut+MWrr7563j68dn/FK14hwjd83te97nVIpxsb1esa5oskI+VtRaVUU7WEWD3T3I5nbmaZGzfUdgm1agVAnSEHdES9JQz5C2LuxOSOehUM+IsiWW41js2FMftk52xYJ+Z+S7iEWglGm5Ti/RN9OJXzI+jR0O8viTmT5U6T89aRAM0eN65Z7spV51U2k8PYtmMUm8eilTZ352hIFLlkQcXFEDvenJrlL3/BTrzxovWVTtk+nxeeYhYXxoA/e+YIzrtwg0ifWyea5UaynMplkgLDwmS51TzmcigSrRTHJDLG/FoXzRBv0DTnSKqf/uoAvv9kAaNbdomCq6ViHpnUjJjHh0axcef5nU3NL6Fomp+/ph+XrIsL09zoQOll8UL8e9/7Hp73vOdhx44d4sL53HPPFfgVIwn+ta99DdlsVvDSV69eXZn+6I/+qPI8iUQCe/eewe35fD587nOfE6b7+eefjy9+8Yv41Kc+hQ984ANL8j6Xm5pBSlRL37bKMq9mhDZc/LNL+ePclwgTJsvt1GhxzF5hnrczNd9JHEuj/HIXx+KqG9WoaW7GlrSFY96s7ExNq4lpTSi3UJjRQNMIBrkcxYRnUMyd/KqTclRgWJgsX+iy9EhhzBpi6vyC/CMYVSeRlwKY8fSLOZPlF3YgOb8oaod53qMqFou47rrr8KY3vamhx9EgP3nyZGX61re+NW87zfLHHnsMP//5z/HDH/4Qv/rVrxoeOeoiWbpQ9YZTc7sdoqWW7NAsdizzZtAsxKowKU7zm4UuFV3CTNGPA5k+zJSqG+/l4pg68rp9v40ojCmX4JNaK4zZiBawWhsa3o+qQ/vHSgHxfouaDDXE4eWNpxFduXLVRbIxX61mOdWKWd4ox5yIjx89MrEQnzHvNZYvjA2cipEQt+OPezxe/PGaPsRXb0IwNlBzWLlSKonHEMNip3JxzAOqHIQAAKTxSURBVLQojkncN89hdx5M4sCek+jWwqvGuYCJ/fHNMezadZHoGOB79fp8CEViojOAHQD16kXYfVd3HU003ClaC8fSiKoly+32o2ludMzzGuGh+w4hM51DL2rXrl0iVV5Lt956q5jqpVrMzHResFtTLa4WF8/SDJqlHsvcTlYsixNVw7IwqZw6meoq/jjRJXwMMSx2mlccswe92FrM83aPDDA6UYxOFRfH4molKJ8pwus901aHqoxmN0xzM6alHp5lOagRLAuViK3DntIIpj39UCQvvLqCQXUWW4tPYsim4KUhFrwks5z/txPXpxEuF8Zsc1teD8vC79iu6Guj4vsfzM2IzgG+DzLLByPy8nBZzKZ5NXSLYZrXwgL1iG6++WYxr3f9bRXDLqtWrbLd9rvf/Q4/+clPcO+992L37t1i3S233IIXvOAF+OQnP4k1a9Y4+htuwnyRCn922lSvlzI3yy5l3iyaZU2/jPPisxgJFJBXPJgp+sScy1xPM72aaB7TXCez3E5GYcxSFUO9kdfZ9qJ8NGjMU01JSCk+TBUDYr4YZrnZvLFLlzs1S1y1PqTnrrvuwnOf+1xEIhHx2Gc/+9nI5XrTbOpKJSdrT52QQ4OWbS3b40bN1Ga0dzKFD//0Cdz2gwcc7c8OUZr5hgz+eGJ6Aj5/EH3RATGX0rPIH/0d+tWcuNk3JqtoINNgVxT7jllzcUya5Z/930OCs163g7KWHLW/No9xKGuamuZ4uC+O2MCwmDeDYTG+qx/vn2xboU/jWGPH+KZYpG7nTKPtP/fnNQefn9cK7Shq68pVM6qXlm0GzVJLBibDnAKupW5ImRv8cfLGs1oRU1pGzLnM9dxeSzSQabCTWW6ndhfHXGpMSzuY5fVwLLaPaQLH0ujx68pVNyiXLlYmJ2lzs5FaLWXuSJ0yEZ2kzNuEZTEY5BPB1QjqeQyos2J+2jOMB4K7MOWpztsOh1nqWBXMcjvNL4zZezI6VnglHtdSGFGnxXxZmOWNJs95/IUXp7ZQMpmcN5nr/yyFWHNodHRUjBplOn1qamqeB0PPxjDLqec///mQZVkgGp3KNcxXgGluyIxmqezXEppFx4bALLj7dNGHok4yliTmXA55VGyO0BCwv8FJKV6RRGcBzIX7lAtjzqgBpLXFwRh0St02hJ3FPsdii8dUXi5qZkgPG2qmDq+88krcc889oofzrW99q2ioXbVBKQcXw50yzbtINGBvueNJ3HX7Y009vhZ/nMtcP370QE3+ONPWfbEBUQTTvF9J0cVyLpMS6BIWx2Shy8eecPC91BrJ00qqvEOJdKff1Y9+116z3Di/E5Gzcaj2+aYdnaXslA73uaa5q94wzeuhWeqxzO1MTgOpYXQe2vGpnZqq7WaZt8ofp4HMNDqLYNqJ67m93cUxl4uqdZQYx0orOJZqcnEsrnpF1YxzO0RLLc1LaLeLY+44COdAdbAsTJk3zCDX5xjkTFFrM8hJQez3b6oaDmfBy0E9KQpgLnRZyoUx+bzlwpjtl4GTqaauHUnQSAHNRvjl1rCl3eT0b7bCTa8mGu5m3It1CpeP4XXr1iEej1cm4guXSvRY/umf/gm/+MUv8LGPfUzgFa+55hqoarlDn/WHaKab5fV6MTg4KLY5levaLHN8SycLgJItzgKWZI37Fhj0EtKKB4P+omCV20sS2BYWwOTz+KRyYUzOaxXGdKJWCpV2m8HdTrnJ8uZkDOlhUbdnPOMZuOyyy8SQnm9/+9s4ceJE1cddf/31onDcDTfcgHPOOUf0fv7xH/9xhZXrapHUTtO8ygXN8JqRBTiWTosokN8cn8JHf7inabOc6fd6/HGuZ4FL7ldN3G9s/Vb4g8EFxTFnpqbgD4YxuHoTcsUzI4qaTpe342bGYT0KcruvOXdMYHVaFb+rb9x3vGEMixPxPN/JkQxMre9eHcfFmwewZk0MQ6urp5pcueq0GjUCzaa5owKgPZoybxd/nOiWdhTHXG5qpNinFcfSaLq8llwci6vlaJybTfOmU+aNmJ21rgnrGZgdMCytKXOyxc0Mctl/5tzC5T49IzAtxJHYifts144ipBcEq7wAX7kwJnyNFcZc7nLS4dLqaAWn9y2NGOidMs7r6OjRo6KOjzHdeOONVfel/2Etymmd9uzZ0/RrednLXoYXvvCFArf4ohe9SAQaGU5k6rydcg3zZaZGCoA2mzI3zGiyxT2SJljjYtn0t6mSJsMj6YLdXU2F4IAogDmlhBCUVMQ9BTFvpDBms1oJw8pXarHPdg8XamZIz+nTp8U29myy6vPY2Bie85zn4Ne//nVLr8VVk+ogosXOLLfrlGy3WX774Ul84ecHazLLFzzOxqRmJyX5494a/HFuJ7u7lqL9Q9i48wLb4phnbTtPbCeO5TcHZzBxoslEUINIFfNU97lszPLrLl0/r7hpo5xymuScbn3gGL5x13FRL8Q8mWXdVmvfxe4w5WOfsjomTHN2IFxyrjPunytXS2Ga10Oz1C0Ausgp83apIf54FxTHXG5qR7FPQy6OxVWvaqYgYdoyVZNT09xOS1r80071in82KDsGudk09+klwTQXDPIqYuHL3dpejOkz5cKYUqzhwpg08qshY1rVYqTMrZ0sbT1uqrHF2zki1knnzSIa57FYbN5UKwT4zne+U4QOa02bN29u22vjcw0PD2P//vJ9Mdnm9GPMUhRFYHarcc/t5Bb9tBGHj7PHhCYbDwION2iWVWqnqYwiDOyZQtEWndKorEVAaZrPFsrLfH7+HbsCoDR0ptOlhguAGqZ5KVMQjHGyxku6p2Kal+b+tk8mg1wSrPJaoik+mx0TiXWa8GSWlzEsrX3mdoVK21r8s43iZ1sbf9O6ej1d3i9Y0LV/L4GSvzJcyKwPfOAD+OAHP9j0325mSM/BgwfFnH+XhSXOP/98MWzoec97Hh599FFs27at6dfjyrniIQl+r4SioiOR08umeaw5A7RWW2M3QoeMcJopnei4oln+5Z/sw+G9Rxt+rLVtI1fc7/MJ/jgxLHb8cfLJySmvJ5rixLjYFcdkgTyiY1g0sm77aodjcXjRyfabZre1jZ04YdNhUOU5+RzrVkWxddCZwWUt/En0CtPkR0+lbDuirSKipt75avXaOLCqfYU/m9FYNIihZAYDLXYI1WvPjbbclStDAi0Si0DzeyEXFfiTmZqFQK1FQKsVADW0oACoSUwBZ71lk3Mqv9DctEsX759x3lHfruKfZv44MSyt8MdbLY65ktVKsc9ew7Hop6agR6q313qm9c5eV70vs2k+ENCRCcShyAF4tQL0dALhOqPcmTKvh/hoWrWuLbmtGh6QJqUTw7TyXIPz0sx2xT9pTBsGL9niBoM8gNI801wrFlCSfKIAaD0GOU3xi9XHRGLdKIxJDEujLov5tbWr+OeyVzsRkMZzVT0e23tv2w6NjIyIabF07NgxwTBfvbp8D3jJJZdgdnYW999/Py688EKx7pe//KUYAU1igFO5hrlFExMTYmjA5OSk6IGgKcaeip07dy7qF96qaW4nmvQ06+3EG/BGh4nT1J5VAxjy5jCr0hSXTKZ5EX1eFacLLHTp5DCTkNYW3wRgyjybynaFaV5L7NjodGJ1OYnDhdjraaha7yeHCpF5VUvs/WxGbIypP//zP8drX/ta8e8LLrhAcLa+8pWvLCnzayVoKCJh25gXQ30yvB5AUYGptIZ94wqmOmCam8Xf6iXr4tgxHG2rWU5Tlu38k8kM/uXOI02Z5WbxfCCM3r4YYv2DmDw9LsxzcwcxO5DJJWdKnMa3WQ9PzlY6ZtlRayDCjOKYZi22Wf7G39u84L2yg8HWNG+TaJJT7KRmmpzvlTL+HkcisHPF3DnKTumymV++ibJ7bUY6PpkMYqYv0JRh3s4OU37fw2H38tHV4ik/GMPstrPEXPN6ICsqgtNJ9O87hpMnky2Z5kzw+jbF7VPmQ6Mi/Sv1r12QMh/PTojE8KnsrDBE2cbRIH0yqS5IHe+dys5LmY9PZjtimhv8cRb4JLPcjj/OlHgjxrfY10Vh18WxOMXvNIJjsRsB4eJYXPWy0uFhHBzagUx4GF6fF7KmIJ6bxNrpPVjlTVZS5uG5gAFT5tYUMk3bBYlnGtEWTnjbVMs076AMBvm4NAC/nphncEv+ANJKGKPqJGLawjbB2rkgCmOSVd5iW96MaV5P/H7rjSawe0xHRbRPiyMEOqYlOh47rSNHjojkN+dkkD/44INi/datW9HX1yf+TT+W/skf/uEfIp1O4+abb8aLX/xikRY/cOAA3vOe94j9r7rqKrH/2WefLTjnr3/96/GFL3wBpVJJ1JIjymXNGucjZd07HotZToRCNpsVqXKfzyc+2JMnT4rEOXsiWjHN3335ZnzijnLq1Comws04FTsZ6TUaHPVM88VJmYdwONsvinMaLHNlLnHeH9aQ1wI4mOEBLi0ZEqWVlPly1Eop9mkME6onDhV6zWteU3d4TzNDeozezac85Snz1rPx5snAVRsUHeKVta1ZfuFGH8J+Ccm8jlIO8HmBVXEZsZAP9x8qdcw0Z5vK9pVtcDvNcpqx+6ezot2+78A0Th5vLbEhTNpMae6c4cPajduQzaQEf5zMcoFhUUrCLPcHQxhbt2Wekf7dx0+K12E+b7xy91rbJB2NdaJjDuw52ZxZ7lA0ls/bvRGvvGTtQuY4v+qrIToa6r0Ow3Qnr9tpMpCJ/x8/PF45X5r/hhkHw/OR9ZzETttar4fbuqW2xlCfH+sKYWQHlj/SzFV3iCb56Qu3QwkG4U9lIJdUaD4PsqODKMbCGL3/Cd7dtvQ3DNN8Qcp8zjRfjJR5u0S+OI1x8sbJLCeGhclyrlvJ/PGlUjPFPg0ci6FqOBan6CFXrrrFLD+y5iIU/WEE8wl48iURspuOrELGHwNO3VPTNLdLmTOhvaCAptnsJHvaikrppPi3WuRdG6a0wSBPymHBHCfLnHgWJs5ZsDPiLWBr7smuZ5A7SZk3Y5q3VU46XBb7WGolbd6Duummm/C1r32tssyQIXX77bfj8ssvF//eu3ev8GQpj8eDhx9+WDyGKXIa4FdeeSU+/OEPzwtKfvOb3xQmOUf4E6VLg/0zn/lMQ6/NNcxNKTomy2mW0xQ3jAF+4Fw2kudMm7eCZzFM81pYFhoYtYp50jivZprXk13K3DDNzSlzs2leS6VwPx7PAhsCs8I098glgWkhg5wFOwvBIMLBsiHQrfzw9qfMdcT9KvyyDjkUQUphd+7Sn85WilneiaFCzQzp2bhxo2i82bib9cQTT4gKzq46JybLaZZPps9EKYoKxPJwXzl5PnWw1HY8S6dGgdAsv+toQrTTB8dTFVO2FTHRfGB8GLPryjca0XA/tp3zNBzav1cUAM3n0gLDwmQ5zXKiVozz0zcfPImf/uqAbbtJ09wsmvxOTOp2meVvu3xTVZObLHKeA79gMbStMhLqu4biyKYTC9AyVrHz4D//51CdlPj880yj5xXun0mFkU4HyEVZUhzXuqEQtGI57eHKVSfFFpzJcprlwakzCTtPURHL+aE4ZreuxYl7foc1bUKz2L6OuZS5YZp3KmXeDhn88e2eEVHgk8xyYliYLKdZvpL54yx22gxepteKfS4WjsWVKztNF4G8pXwZj8hTa3ZA8YcRyUxU2nKlUERMnUAyNILjgzsQO/G/FTyL2TQ3ZJjmtinzpUj11sOy0Lg3FyJ1gGWxY5A/Ia8TBUDTCAtMCxnkLNg5FNagWJqFjqFrOpgyb8Q09/cFkZCjZ/AyWqphl8W2o2WpFTQdz/nZFZc2v/XWW8VUz681FAqF8NOf/rTu8xKf+8///M8tvTbXMJ8TeyuIYWGynMrn8xUkC01zplW5nfux+N9Sq1ravJmUeT00S62UuVMG+VIa5I2lzHVEvYooVEr2OnEyjZjmQ4EStsXzGAqW4JV0wJvDTNGPA5k+zJSWjjvrqjU5GdJz/Phx0XtJTvlFF10kjLV3v/vdgp9+3nnnCYY5e0HZ8fav//qvS/2Wlo9oeJuKeZJZTgwLk+VUwAt4ZAmqpqOgQKzndu7XDqY5MRtr1sSwZeyMgUjuNVnP7Vaj2KxaYpt2xx1PVExunju84X5s2XWRLX+c5xWeT8jlNh5nFddbO1pPnEg6Q8fUuuCrg2NhG3355dvnJdx5UWX3Ppg8P3fLcCWhb23b+X1y+5hewIFH7hGdByx4ys6DvtgAxtZvrXQeUF+450il86DaecJY3yoKhn/j5FwYka9xKTVYg1nrylW7RGY5E+ZMllNKwAfdI0NSNXgKJfhTWWGac7+TJzNNoVkaSZkb6naW+XLkjzdrdlNDcrjSgcCiqOS8E13Trg6EdhT7tKbL3WKfrpaTisE48pFheDMJ5FTiWwPQJS8kXYGuFBAuJpEIjQi2uZROIGRhmtuhWRaYn53Esiyh6jHIO22Qt8M0N1LmvDNL1jC765nm075BHAntxLSnXxQ8JcN9UJ3F1uKTGFJNHROLiWVhh0krRTfNRnkz5vkyMs27Va5hPicW+KRBbiBYyMUhP4dxf3JzmCzndu7XKTnBsjQqs2nuJGVuVrWUuV0BUBrSS8Egb5do6AfyM9gSSWPAXxRmt6JLFbMbDkxzmuUXjqQR9mhIljwoaRLC8GAkUECfV8FDif6WTXN2cLCjw9Xiq96QHrYdTJNzlIqhv/zLvxSdb9dff73At9A4//nPf44tW7Ys0btY/qY5C3ySWe5VgJEBGX0BCR4ZUDUgXdAxk9HEdu7XKsyP5uq2HaPYveXMBXon2OXs7DwwvhA906rYpt32gwfEv6/dNWIa7eRjJdDyx5POVTpbDS53tbaQxrXB7Tb/jbpqMVlOs/ytz9xYGZmVmp3C+JH9dc1u4/FW5Im3kMTpA6dQzOcFnibkLRdETUxPIJdNYePOC8TzMFn+6weO10WqUO3gphvPQdOcHdmbHSTNe73Ys6uVLRb4JLNc83qRHelHqS8M3SNBUnX40lkEZ9LQud1fvp2pVQS0mrotZd4u03y58MdbNbv5+N2+dQhLvnmIGnLeialhGr/W87SSLjePdmo1Xd5txT5duWpEmjcATfaKKRMdQykQhS7L8Oka/MUUItkpyLJXFAI1q+mUeScY1ItoTFoN6XYxyJdSU54B7Pdvqmt2Gx0jVuM8HV+Nx4K7kJOC6NPT8GkKSpIXpz3DSAX7cEH+kfab5p3GstiZ5dX2qWWc89jM1O/Ed9WcWKmxJ/S3f/u3uPTSSxEOhzuS8GaKnIb4k08+KfArNL1ojnPOZa7n9mrFAxvFslCGaW1NflP1Cnhak+ZmVcO5WNEvlJ35aldQjDfntUTTvJtV7/X1e/I4Lz4rzO284sFM0SfmXOb6AV+9jhJdJMtplk8WvCKd7vX7UdRlTBd9CHlUbI7Q8FqaM92m4e7+fnpBxpCeVColRpqwcKdRhMJAsDDVanC2zIVFWYQ0k8ngzjvvxGWXXYaVrI615XMp8aKiwyMB64c9GOmTEfFLCHglMefy+iGP2M79KjIl1J2KBuvqtfF5puXO0ZC4QW6XWT6VKuI3x6fwo0cmFrTH7WxzaZqTMc6inHYTjXJur1ewk9usU6dFfArNfrNZfmjPA8Lc9vmD6IsOiDmXuZ7bL90cEx0dhubzwXWEUieEWd4XH4TPH4DEmzp/QCxz/fjRA/OGBXZDcWi787srV71+bS4XFZEoT60bQX6kH0o4ANXvF3Mup9aNQvPIYr96hqHVYDTjLYwUr5HqNVK+RurXztQ0J4VryTBRXTUuw+ymuZ3VipjSMmLOZa7n9nqi2U6znEVQi1DFVTjnXOZ6bl/qdLmhWunylVbs83Of+5y4rg4GgwJ9eM8991Td93vf+x52794t2qBIJCJGdH7961+ftw/P2WTksr4Qh/I///nPx759+xbhnazctnymyOBZuQNTVgrQZQ+SgxuR7xuF6gtD8wRR8IaRCY9ipn8jcpoHXq3cTudMgT2a5pQjxrUJd1KRmSleC5/SrKzpYquhWse47zo0iEM1gsSZkmJ4MHqhMLeDeh4D6qyYc/mB4C5hpltF49yYiGGh2U6zfFCbQUAvQYYu5lzmem6v5rI4SsPbHTvdpHrmemT5ja7oFvWMYV4sFnHdddfhTW96U0een8gVmuM0w3hSJYqFRT855zLXc7uTQoJOTXMmvdshO9PcLLvUut3ftuPvMmVuZ5ozZd5rqm4w6YLBzrdHc5smtw5pgdldCytDZjkxLEyWL+SVS0grHgz6iwL30g5ZRwgshVnO3wW53uPj42JuNpBcuVqStjw2LDArIZ+EaEACcdOKBihqec5lrud2gWPpYuWKqiiWeefBcgEkq9gGM+G+QEy/1Jqq6JF79+Ou2x+rOnF7R4zhFtPlZrENYrK8ntlNNjkLg5J5bhXRYhEtLZLlVl45l7mehVGJe+GoLINb3rAa/H4M2X0HrbLz+bklE7OYmjwt5m5b7qpbrs19yQyUUAAl8VuXICsqZEURcy6XomEoQb/Yz6xmTHNDVU1zk8lpTggbyWHDGDVSxXYMa6u5Wi2pbJdqXolq1ewmxoXJdCbL7cT13M79ljJdbj7GWk2X8zMqxCLIDcfFvBdb8+985zt4xzveIZCGv/3tb8XozKuuugqnT5+uGmj567/+a9x1112iCNxrX/taMZn5th//+MfFqFBiFe+++25hrPM5OQrUVXvb8tnSGaOc4r/TySRynjBKgbKPImkKJK0k5sSd5wMxlHwh5JNnrnnNprlVRhFJwwitxQHvOjnExiwqo71JOXmNbIPIYM9JgabMbsxhXJhMZ7J8ocsC9OkZsZ37OZWjY8bMnzdkV9S1Ax0xwmdJFzA+mxNzcW3uJJHerKLD5c6fqtMwVqp6Bsly8803i3k9GHyzYmI0l8sJ1IL1ZpHLXM/t3G9goD1DfP706etFAVBz8U8zlsVa/JO88nrmuB3L3KxWWOZO0Sy9JhokLFia0XzwBTwozUPYWMzuOYPGalqwwCcxLsSwUD5Lyr+kyYh4VcSIuWmuXqut7IrGWk23Tsgogkuuv8H6J7Zo586djopoulq56nRbHh8ZQNCfB5vxykXV3D8EhIXXGz7pDMO8RRlmJdvRTbGI4za6I3JiPhv71OGCL4raMLR13aqo+NwpmtjEsDgxu8kyv+ZcRTDWzaZ3rM8HSdPgJZLGRh6vD+lMEt/67RF8/xdH2v9e2/j9OMGxzExN4sn9ezEzMwVVUeDxejEwMIRNW3dgYGjlXhy76o72nGxyNeiHpOvQJbbh/I834JJYZoOuhgJiv6DFNG9UddEscyxzA81iZpkbaJZ2scxdNWB2K8GqTHMyz4lxIYbFTlzPoqjcrxlnudvS5eT9s0gu50QZsWMpOJ1E/75jYt4r+tSnPiVqBtH0pmhy/+hHPxIjOzlq0yrryM6/+Iu/EDWDfv3rXwtTnPfxn/70p/G+970Pf/AHfyD2Yb2hsbEx/Pu//7uoR7TS1em2XAnFoflDgK5Bm2vJPWC7zrZcgq5pZcM8EMd0IYHBgF4xzckzN9AstVjmTWNZeN3l9JprhfGi22Hak73OgqVRPQuPPwCtWKhqdsc1+7aOzHNiXIhhsX2deglpucx4R5X23pHazcFv5NgyaSKRw97js5hM5KFoOryyhOF4EDvW9mMk3u+8KKirlZUwb0ZEqiSTyXlTNdH4I4OYCXJiV8gv5zLnRtFPLnO/btRSpMyXC5qFhUo9kgZFt/850Oz2SLooBGpONprTjUVNEsxzn6wvMMvF35A1qLokCqJ2Qgan3ugksRaDbbdZznQGWf8cujc0NCTmXOZ6bnflaqna8sEQ4PN5hBnO/iJZBrxyec5lrvd5JQxGLL/FJrAshmiW714dx8ahSNtwLMZv2K7jkkWYWbSS7OwzKxu8gHeYaO5WWdnlPAf6JFUwy2uZ3dzOQqCUtaOYUph7kWXBLLdTrpjH4UQJd9xXNjxsU/dNJMdtn6PDoln+yAP3YmLiFILBEOIDg2LOZa7ndleulqotF/sPRqH5vPAnMvAIPIsEzecRc0+xJNZzO/ezqiNoFpPmJYXn5KbM26eGzO4qYoFQ5lfJLLcT16vQxH6tfP5Npcvn1K50eToWw+kLtyM7OghvroDgdErMucz1NNGXUtbffbWaYEw633///QKZYoihNS4zQV5PNMd/8YtfiJpCz372s8U6YlVPnTo17znj8bhAvTh5Tlett+dKZAi6xwdPLgFZLYqLckX2QZdkeJQi/PkESrIfmXC5o3660FgtinmJ4XpojU5gWaxqkHPdq1gWJ6a6MLvhAf9Pyf7AArObZnjZ7LYXC4SSeU5muZ1Kkk9s535t1yKnzGmW3/PEBE5N5xAOeDHUFxBzLnM9t7taXC1rw/yjH/2oOCEa07p166rua6TRiGHhvkyRk+HFOZe5nvtYU2vtkJVlbi7SaU2JN2KEdoJlbpUdmqXXTHOa2KouwyuVDXGfpXPBMLvJJbfKMM45xCylhzEQtiskqKPPq2K66EdaW1zO7FPWzEcWtCpeiDJZTjwRk+TsTOKFLOdc5npu78SQ/njAJzp+ak3cx9XKbsuN358ieQQiKZHVkczplTnRLOb92qGtg2GMtbHdI7u8Fo7FUFsQKa0au0sk4lTILjfL6/PD7ysX6LSTqpREAVCvzycKdn7rtj0LkCqnkzq0YBz5bNp2tFkxm0HJHxVteVWzvF3q4PfB98JkeS6fxcDgMPxzbTnnXOb6Jw/s7RiepV577rbly1ONteVnJCkK/MmMMMgrUzI7h2apLqemuWMZCA1TQthIDpuN0Xos83rJZFetmd2GmDxngVAW97QT13N7tYS6VebOjZbT5SYufqvpch7l+/rXQgkGEZxKiM4ljsrgnMtcP7t1bUfwLNqxafH6q07HyudY/tbNv322BXZiMI1hNaa/zeIyTe9q4ghw1hXy+/249tprccstt+D3fu/3xDbjcY0+p6v2tefGsUcMizeXgDc7C18uAU92Vpjl8lxyOFVaeJQaaBYry9yKZakpO4OzkxzzBdsHli2Wpd7rFGY3VPD/hsymuROzO6alRIHQtNRn47IAaSkitnO/RmSLZVlCljmvuZkszxUUDMcCCPg8kGVJzLnM9XuPJ6AHereDpRe1pIY5h1UZJnS1ieZbs7rxxhvFCdSYWHivmpiSZREQYlcoIiZ40uWc4noWHuF+7VSvs8yXg2h8zKoBRGQ21LrFND9jdqeUWt+ThAOZPuRU4ltK8MsqBwyLOZe5/mCGBSKdd7jMzF0gGAlT8nKrpSIXwyyn+DvixSwvjOyQBxyJwe3cz9XKUTe15dM5GfkSEBI/Vx2q7BWJBM6pkA/Il3RMZ5q4dbQMq+tEW2iY5XtO2ycIzG1xrdfWtJpkay+F2Plr7hgO98UQ6x+sanZzPVnmPzycwX/+z6H5Cf2KJKgDa+EPBgW+pVQsQONQ4WJBLPsCIeSia5BN2Xw/Xfo52SmVTAgMS19fzLYt5/qZ6Smxn6uVpU6254205VRgOgVPviiwK5RgmJcMhjmghvzw5Apiv1ZM82YLgDabMrfKTZl3zux+Qp1AVi9hWI7AD4+4Cuecy1zP7b3OLs9FIiJB7k9lbPm+/lQW+aG4QBctlfhbN//22Ra0U9FoFA8++CDuvfdeUcCSDPQ77rgDK1lLeW2eLM6fCrNTQDEH3Rc+wzBXi2Ku6IDqC8FbyiGQPXMd1UzK3FE6uFV1A9Kwh0zzGDIY1JNISeGmzW4eCVuLTyKk5zEtD6Ag+QXah3Mucz231zpiHHWsdCJlXuvewIJWSWSKAsMSC5eDumZxORr2YTKRE/u5WiEM83e+8514zWteU3OfzZs3N/38TL1yciKmyVmNm0O4MpmMMMp5YPImm4xmzrm9XZWjrSzzr9xbZqEuB5Z5L/DM578+CYcL/cIwN1jmxLOEgzKCWt6x2T1TCuChRD+2RNIY8BcFs5zJ9NOFgHg8t4eD7R2ZYObfm7V7U6xjw+/4e+CICzuxk4kFcqsNtXS1PNVNbXmiIOFIUsa2QQ1hL6CQfUueucSOUA8kGThyutC2op9sN9lWtwvF0rVyyNYuj7oJCzO6I0VC5/TQfYdwC4C3Xb6pYlDwnL124zZkMylhbpNZLjAsSkmY5f5gCGPrtgAnijXPT3oojo1bRkQBUTLR87m0SKbHh0YRXbUB9zxZWFKz3N7ob4xfXioVBbOcaXs7cb2aTon9XK0sdbI9b6QtF/snM4geOY3ZrWtQCgfnjHK23ZJgNJNjHj16WuxXSzTNV6+ufQ1H0zx21nyjlKa5b1NcmOby+vltX6sscyaU907V/y2vZNHMpjFOc5vMcmJYmCznumpmt1VTWhb3lY6KAqFknhPjwmT6KTUlHs/tvc4uPzXrKTPLS/Zpe3Yy6dEQNP/S3fYzUMOpnlgPyePxYHx8fN56Lq9atarq4zhCauvWreLf559/Pn73u9+JBDT55sbj+ByrV6+e95zcd7lqqa7NaZCHLJcgnmwC3snDKK3aDtUXEYli4+JcY6BFl9A/fRiBfAL8RQz5z5jm5JlXY5kzZe6NxoUZSsOWiWGBN7FjUdPgrIZKaZI13U7xddslnvm+WjJ7F1F2r5Vn3u3aUSTlMKakuGCZE89S8vchqfgcmd3UkDqDC/KPiAKhZJ6TWc7jaFSdFI/n9rap3SxzhyoommCW+zz2mWa/R0ZK08V+vVOJsve1pB81EQ7dUiCQN9oXXnihSMdyeBZ55TTJuZ7mIE+23N4JJIvZ/HSqRkxzs2jsmJEvFP+ugYUxp8yNRLM52WiknpmsJEd3uZjms2oQj+dGsCEwK0xzj1wSmJYZ9GFvIiDMbififvfN+kWBUDLPiXEpJ9OdHzf8XJtJrhqdLHYdJO0SL4zYmcTfh91FEtmD3N7IDbGr3lc3teX8rT10yovBkIJVEU3wy9ls87qc1xen0jIemqEp0vqQO7aJBru83bK2v2Yt6SifGjcVw2tGcNWzt4jzx30HpoWpTXXKODeb5jsCZaMrNjCEbec8DccP7RMJabPZTbM82j+E6SfOFOs0vzajLgU/+2j/apFGZ4FQMs9pIIciMaRLPFeeRK/L5/OLAp98b8SwWMX13M79jGuNTtbGcNU96qb2nFdOww/vR34wiuzYAEreoCgQR9wEzfPw+AyGHz7QwBXWwsTu8FkBxwVAmQiWVo9UCoAayeGs94xpbhimp7KzojPvaCor0sdPJmv/fphgHp/M2qadUycbG2a+XNQus5v73aUdFgVCyTwnxqVaMr3X0uWUXCyPuiDfnxgWq8j5lzg6w2Zbt4nBG95vk0P+ohe9SKzjKC8uv/Wtb3X8PHyMEd7ZtGmTuI/ncxgGOXnbrLv0pje9CctV3daWhw49AC0yBKV/NUoeb3mlDshaCYHEKfgPP1Bpy6eKZ0zzjohJ4HoYlRWuduJghvQkdmt78YS8ThQATSMsMC2rvQlsSu1xbHZzv8HcjCgQSuY5MS5MprfizlU6WZopImvXCWN3bNXqkGHKPFj+rANeWRT4LKkaAvJCn6+o8r5WEvu5Wjz1TN/EkSNHMD09LeZkm3HYFcXeZDLL2iUafUSz8IRtGObs6V4MA9CaGK6VMq8m3thab2oXI2Xeq7Ka5rPZMfTJRVEIlGxzwRwPSkCpkQSKhJSy8Lti6rLXRRQL0x8s8MmLMHMHEn8vvABleoP7uXK1lG05C3xmS4DXU7kmB8OJRYNhHisXFmq24Cd/z1vG+jpillfrtOxm0WymWf6K81eLc84l6+LCzDZM83aLRrdhcFvPYzTNo/2DmJqeWWB2f+GeI/j+jx6pPMfC5zzTTrN9C9tcRC84H/YQisVQNMZaLUOiwOeAf3hBW55OJzEyugpjI4ufsHHVO1qs9lwuluDNFqCLVHnZMC8bgM7byGopc7Npbk6ZG6a5NWVeMc0tKXNDRsrcMM0NGaZ5rZS5a5q3ZnbXk3hci4PLui1dzuPajwyC00lR4JPMcvNRzrdbjIYRHp8SdQB6QcSpvPrVr8bu3btx0UUX4dOf/rQY/f3a175WbH/Vq16FtWvXVjjonHPfLVu2CJP8tttuw9e//nV8/vOfF9t5fvvLv/xL/M3f/A22bdsmDPT3v//9WLNmTcWUX+larLZcUgqQChlWYa+kWTzEsyjlNnGmKGHAP/9H2nLK3M7oXAzRSDVjO/gazGgPvrYl5GV3StUS8TTNL1YfQxKRM2Y3MpDC5NE7f362b/EGWeVtS5m3ciw5MM3jET+G40FR4HM4Ji+4Nk9lS1g1GEbcw+uEzoR4XfWwYX7TTTfha1/7WmX5ggsuEPPbb79dDLdqVzFDzs8++2yRlCV6wmCZM3nO7TQLO5EyJ8vcwLKYZTbN25Uyt9NKTZnb4VnS2sLOEQMxsFSiQcOOC34f/F7YqcHODTssyxU7OjekjMf+zp07BatuYmJCDK/k74O/F5rl4XBYbO/USAxXva9Ot+W8Pdw2qIoCHU9MSwh4JHBkm6oBBVXHcAhi+9RxHqPSQvO8y9SVHZY2F32G0Wx07DJp9/6rtuOzfX7ccccT9ilzPocTs7nKRSaf03wOMstqdrPT+JsPnqxqllvltJO6V8XPZ9PWHUinkpiZnhTMcnYssIOBZnkoFMamLTsqbbmbLne1JNfmvA7edhbI0orvOwYt4IPukSGpGuRCCYWhuChmOHZP0tGtY7NoFlvVSZkbMlLmrlpTO8zueurFdDnFI7p/3zEUY2HBKieznBgWJstplntzefTvP94z9spLX/pScY/B9oWjvpkK/8lPflIp2klTlwgWQzTT3/zmN+PYsWMi9Mb7kG984xvieQy95z3vEfu94Q1vwOzsLC677DLxnKxP5mpx2vLi6h2iLfed3MNiYQBRLCz2WSpAio8gM7odvvSZAEtHUubmRLA1CdwqloXPZcewXmFYllqvV5jdyCxoy9nhYRRxbUV8nloyOlWaTpnbyWnKvJ7ys5CC/dixth+JTAmTyYJglhPDwmQ5zfJQwIsda1lHrsvuC5e5eibPf+uttwoz2zq1x2CZX8yQJ2GeQNmjyjmXF6OYIVnmhqyJOcouJd7MTazZgLeyrykasXamTbNoABrS3S4nr3EpEuJG54RTddIsN8Rk+TOe8QyRJGcx3KmpKTHnMtd3y/A/VyuzLY8HdAyFdcFQ5CmuoErIliQx5zLXczv3a1ZMNrPNsGsrWxU7QY122a4Ac00tEX/R+Dysr5eG81ufuRGXX769kgZvtw7sOYlv3HUcvzle3XinWfXZ/z3kyCyfPDGBn/7qgDDXredcLvN55nUA9GC63NDA0DB2XfB0jIysQj6fQ2JmWsyZLN91/tOxdk3ZnFiuYhKRRgw7BYw0naGHH34Yz3rWs8Q14Lp16/Dxj3+87vPRxLn22mtFx/Ho6Cje/e53i+DFclan23MWKTSKGfKGxVsowZctiLncxmKG1QzJugVATclhszFqGKbVCoAaZqtdYtktANq9Mr4r8/dn/n6dpMuNY6dd6XJDTJiP3v8EwqenoYT8KAxGxZzJ8tHfPiG295KIXzl8+LBop4lO4f2FIRbzZNtjiMnxffv2iXsRpqTvvPPOeWY5xXb+Qx/6kDDg8/k8/uu//gvbt29f1Pe0kttyLRyHEh2CnEuItlsuFSAXMuU5Gef5JErRYSihuEiZm01zcwFQpswppswppsypumZrJ4p/umor0qWe2b0kshsB0KkCoFR+FiPxEC7aPoJVgyHkCgqm0gUxZ7Kc60cCHTLLI4Pl+8hqU2TljjjtmYR5p9UtxQyNlHcjaBYnSfNqWJZWU+ZW2aXMe0VO0vCGad5o2tyJ2c7PjZ9fL4imOEdbsAOJvwkii9jZ5CbLXS21WOuQaLcqta/E+qi/vF/Dmkuf8Pd8zvZhbB1sfycai4fuGC4bI3cd7VwHbbtEI3xkzSBed/U2XLFhYVLfMM3Z6UrDuhM8c2JfRNL894CL1w4tMMtvuePJhnjqbN9pmlMGYobP8437jldPy3eR6hX8tJrm/YNDSCUTosAnmeXEtayEtpyJQw7Jf+ihh+at52ipK6+8Es9//vPxhS98AY888gj+9E//VBR9ZzrRThzCTrOcnFyaNcSWERvAa8qPfOQji/SOlp9YpLDdxQwbRbMYMtAsdinzVguAulp61UuX26FYjA6QeY+pky6vJ6tZXq0zx2yWG6IpPnb346IDib8JMsuJYVn+rbmrbpfuZaLcxwIptts5UlkORsv7tSBHxT9rabGLfzaAZVnMlHm7+OWNvuZ2Jc2bUUsp80ZU7xijaR4Ahs9ehUSmKAp8kllOXItU6P77wuWonkmYd1rmYoZ2WupihtZCnVbRNG8kbV4N87J0KXMdfXIBA56cmHd83GWLafhG0ubNJNPtMAMGlsHowDBY80Ynh92ohE6KhgoNBA6R5HwlGCyuul9kl7O4p6+KZ8j13M79mjWIt+0YxcWbB+q2o62a5jtHQzXb3m4QzfIXPmtjxSxnIimbTiA5Mwm9mBbLNJzfeNF6/OG1u5pPmldJZRjmNZPmH/+33+HWB45Vpu8+frJhs/zM82YXoHAaHfHTSe3bexoHx88YK/unsxif6/DNNnhws+2OxfsxNDwq5ta2fDniWH784x/jZz/7GT75yU8u2PbNb35TXPN95StfwTnnnIOXvexlePvb345PfepTVZ+Pz/X4448LDABT69dccw0+/OEP43Of+5x4LlfNyVzM0E7NFjO0MxuryZz8tU2Zm4zQeQbpnKqlzM3q1pR5XApiRI6I+XJWI59rNRRLu9LlrYqtdyCZQWgyIebulbmrbpBglGssLGR/3ax7/CK4aGaZW1UvZe5Y5jRwswgVp6a6FdXhgH/dCdOWZ7wEIpiQ+sVc7/KkeSfT5g13OrQ7Ze5QNMf7vTmMBQti7prlSyfXMLcUM2Riljf4ZhnFDLm908UMyTI3yymaxcmNbTUeqx2WxSw7LABT5tVULSVdzYzu9+RxXngcF0ZO4YLIKTHnMtd3u2m+GJgWpyaNGenjytVKVaIgYSorISaaKOsloS7Wczv3a0bLoXhvp5SancKBR+7BgYd/gycfvRuP3ve/OPK7+8T6TopGOKeJE9P48nd+i2/dtkdM/DfNcmP7clH5/WTnmebsQL3vZAKHpjLINdsb1GJHfK9ofHwcr3/960VROOJTrLrrrrvw7Gc/W4wsNHTVVVdh7969mJmxH9bNx+zatavC2DUew2vHxx57rEPvZPmL6VimZovRhTf4RjFDFjlsppihnWluTvOak77V0CzzXo/JGDUMU3Pa2E610CzVtBim+ZAcxiW+DXh2YDMu828Scy5z/UpRvXS5WYZZzu/b+O6rpcutZnm70uWuXHWzUrNJKDNTKATitm25HorBm5qEN7fwd2FgWerJSCYbhmiFBW4Ynk6xLF2M2msm+T0lxfAbzzn4tfdc3Ol5qphzmevb9TfqqZnnbNQ0b4fJbsePXxI0i6uukmuYW4oZ8uaJhUbIN9M0Tcy5vJjFDK2muV3KvB5epVkRy1JLraTM7cxomuJPCU1gyJtDXvcgoQbEnMtcbzbNF5OF3sjfMozzalMnZE2Zu2a5K1eGJOyb9iCrSKLAp9+jQ4Iu5lzmem5vpbp4rQ7DlSiOSKIpfmjPA8gkJhAIBhGND4j57NQ4ju17qLpp3sahr4YxTjOZLPLlZpRXkxmbVm80Wq+JhrN5ahWLxwDEa17zGrzxjW/E7t27bfch49ZsfFPGMre16zGu6ssoZujN5wWrXPX7oEuSmHO508UM67Gka6XMzSljJylzq6qlzDstmuK7feuwyhNFVitiSsuIOZe5frmZ5p0s9Ck6UeoU+qyWLq9X6NOVq16SqCJ0fC+kYg6FyAg0b0C05Zxr0RHIxSz8J59AymSON5Iyb1jtSJn3gGiK3yfvwLg0gKBewICeFHMuc30107wTatY0d5I4b2civapp3m42vmua94xcw3wRixnyRo2VuZlu4tyaZHdSALSdpnkzxT9bTZnPl44NgVkEZQWzagAl3QNaW5xzmevXB2aXFM+ylAVLa2FZnHSwLDf1+bxilEStifu4cjWVk3H/CQ9OpSWEvMBgCGLOZa7n9lY0EPbjqVEJwVIK6eTCUUntEttlY4SPtbOSbVPbCmkmJxdODYjvf/zIfmilPKL9Q/D5A5BkWcy5XMxnMX70AHds7XU6vLhcNia5g84E83mCHaiLjebqVHtutOUsuMmRfcb00Y9+1Pb5brjhBhFoqDXt2bMHt9xyi6hHc+ONNy7yO3bVrDpZzJBJXbZK2UgEyf64mE+s8AKg2z0jCEs+TGoZFKGWk/xQxTLXc/tykZPPsVq6vBEUi6F2F/rsBpUOJ8T7qToddjECrsqSUlOQn7gH0swpFL1haH1D0AMheBMnETx4r0iYV1O9lDmxLPxlTGU0gR2Z1UP2l5ztSplX2x5ton20YazXwrI4NZ759p+Q1yEnBTCkJxAAi2XrYs5lrt8nnzXPZelEuhxten6zeW6dGlVTLHiHrPmG0Cw8jtplnGccvr4u1KFDh/C6170OmzZtQigUwpYtW/CBD3ygJtKQBZ7f9ra3YceOHeIx69evF/hE0kLMsrsf+Pa3v93Q63PdpUUqZsiUOm/WJicnBaOLPHT+HabWqxnxhmn+lXuPVAqALobqFf+kcWNn3DJlbr55r1YA1Ciu2ScX0e8pIKPRELJ+vpJYP+ApiP3SWqCri4G2S9UKfxLLYtdB8fFrdyzK63LlqtdEU3zquIR4gOnyMrO8jGFprS1fHdOxuXAQp/YUMa6r8Hi8iA0MYf3mbegfXFj0sqtVyxjntpiz96MXMkgnZxCORBecK7kcikSRTkzDg8Xl77Zbtp3ENLVXWEqEjPRj07lF+VtHjx5FLHYmAVWtjsw73/lOkRyvpc2bN+OXv/ylwKdYn4dp81e84hX42te+Jgp3MthglrHMbXbi+nvuuaehx7hyrk4VM8wPxvDg+rMgnRWH5vFAVlX0JRLIHD2OjbFC3QKgNEDl9UNtLQBKg3bvVNaR2Zs66cxkdSqyyoc9ESQ1+2teruf2uBJEQl8abOJSoVis6fJGCn1WS5dXk5sud7XcFPfrSBSlsmm+504gHEc47BfMcjmbqNqWM2U+4K/fSTTtG8SR0E5Me/qheULw5lSM+IvYkRzHKH+z9Yp/0tC0mt2LXQC0zcU0k4hgWoohqmdtXBaI9VNSXOwXx+IFTRazeGnbC4DaHUfshLGy6WmaW/n1dsdYu461Hr8P2bNnjyB7fPGLX8TWrVvx6KOPCnRiJpOxrTVEnThxQkzc/pSnPAWHDx8Wo0e57l//9V/n7fvVr34VV199dWWZtfcakWuY1yhm2C7RLL/77ruRzWaF+e7z+URx0ZMnTwpjvtH0OlPmRjqcKfNqbHI7cd9GkulMmRvYj2oGQjOF0GhC+7I5eCQNijDMF0rRZXjkEnyShqXWYprmZrEDwoq7YWcFOy1cs9yVq3pqnlVup6GQhk3aMWjpCAKrhoXppiglTE+OI5tOYue5F7bNNDcKf1J3HU2IDkujs1IYt2vKJuLEiQ4mqmuZ5uaLO6UESVfhrVLMyeP1QVVTkKXGCvPV/bsd1OWXb8dbn7mxcn5lmvCVu9eK853BRe9WkTs+1Neh5y6qePDELB49ujgX5zTLzYZ5NfEaysl11Gc+8xn8zd/8TWWZF9ZkjX/nO98R12LUJZdcgr/+678W12m8XqN+/vOfixTLwIB9wS4+5m//9m9x+vRpjI6OVh7D184LeVftK2bYLtEsP33hdijBIAYKGXgUFarXg+TgIPKRCPpnD6E/m5pnmjMRHN648Caahqi0eqRimhvGadZyl8U08qnsrGhPjqaywnx9MqnWNXDHJ+sb6O2QX/LACxkl2L8mrvdAFvst0eDPrkKxtKvQZ6+my125aso057+VWTq6tkoWMVeHaGHKfMhfxrIMBnSBZQn1+XGi1IcnBi9AXg8hpmcR0EsowYtTWhwJPYRnKJMY8dp08tuZmotxzUlztRWUh0MVJR8UeMD/24nr0wiL/diedzpd3m2mOf9+297zUprmPW6WUzSzzYY2Ay6sG/T5z3++qmH+1Kc+Ff/2b/9WWWYqndfhr3zlKyvhZEP0dVsJr7hIlg6LQ9XZa0KznDdzNFhkWRZzLnM9tzsZ0t8JNEs1LIsdy9yu+KdVVnO3FpqlpMtQdRneKoY413M792uH+FrMUzcgWuxMeLtUPmXumLBL+Lty5aqT0rFtUIVcyOBAyoOEIkHTAb8/gPjAEPL5HI4e3NdWPIthml+yLr6g/aVpvmZNDCNraiRmaqlB7EpNeX2QPV7ReWAnVSmJJL4md38fPTE3VrPcEE2St12+SWzvuJq8QdtzOieMuKkmOrKdmuXswJnMtqHzYwnEIZu8yDam7du3Vy60zzrrLPHv//t//68o+MnhoSzYSTP97//+7/GOd7yj8jzf//73xQhBQ1deeaUwxv/kT/4EDz30EH7605/ife97H97ylrdUTcW7WjqxlZ7ddpYwy1k0ND+tQNJ1eEsKIokEioEA9vpGbD3hVguAmk3WbkOzFHUVCjT4YM9Y53oVmthvpaJY6hX6rHz3bqFPV65sTXNO7RKf6XB0O/JyCAPKlDDLUcwL7MhAaRI53Yc96XAZz1Kv+GctbEat5XqqZ8pXUS0sC1XP7PXr7DZQReeBnbie27nfYprlhpbib3asAGgjqsXMbwTR0k6cyxLWFqomhooHBwcbfgyDKmaznOK1OMkeF110Eb7yla80fK/uGuYdFr84YljssC5c5pfK7VbejhOeuVmdKgJajWVu5uk2WwBPj8QEqzwi87UvrJnN9TNqAGmtdRSNnUHerHm+2FxzM+ammTS/K1euWhfRLkNhHcmSB8cOT+KeQzOYzBYrbTlxJImZKWRSzfN0nZjm7Wh72y0pEEGsfxC5TGrBRQiXub4vPgjV1/3F4liomZ9xtZFbNM23jPVhw451XWGW2xXcpqG9dzLVVtOcz2WY5ctdvF772c9+hieffBIXXnihwL3cdNNNeMMb3lDZh9dsTL8Y8ng8+OEPfyjmTJsz4fKqV70KH/rQh5boXbiqJaJdmDD3p85gXdIpU5I9m0UqHsfRGW/bC4AaMheMNGQ2zZ2qnaY5MSuTagYx2f46l+u5fTniWJyiWOoV+hRyC326ctU21Sr+OVkKIREYQp+assWOxKQ8JvUoEtXQrna8aTsZxmSnDMpauJgmTecYMhjUk0hJYRuXBWI9WeZDUeekguVmmtdLuTdkmtt1xFQ7vuoVmjXM8FpTuxWMA8H+GlO8odpCrWj//v2i5tCf//mfO34M/dQPf/jD867VKV6Hf/e73xWjPl/84hfjzW9+s3juRuQa5h0We104LMAY1msVU0zcXq93xmya26XM22Wa1+OkO0mZW1XdkJZw2juGvOYVLHOfpEKCLuZc5vojBTakrSEVnBjijRrn7TTNG0mZU//2pxeKydXiisN8Lr30UoTDYUfIJg7n/6u/+ivs2rULkUgEa9asEQYKEQCuek/koHtloJQvD+ucnsrgWOLMb9frI3ZEQanU/k4tmubnr+m3TZpT84p/LjJvke0X08ZrN26DPxhGanYKpWJBsOg45zLXj63bwp4F9ILqnefYicx0//CakfZ/5g6ey0mxV8M0PzqVE1Mz5jkfw4mP/83xqXlm+QNPdn448WJo48aNolPn/PPPn7f+3HPPxf/8z/8gn8/j2LFjoi03i7x0a+fQhg0bcNttt4mRg0TxcRipNeXiqjtEDrrm9UAu2SelvYoCTZahVCkk3qkCoGY5TZm3W0+oE8jqJQzLEfjhEVfgnHOZ67m9l+WiWFy56qzscCqNilgWJ8U/FTkAVfZCL5SvzdViucHViuX7aB9UMVq9oFva2EZT5tQSpHnrpcxrmc5su7drRxHSC4JVXoAPGiQx53JYL+DsUHLJL835+pfaOG9KnTbNu1RHjx4VoRFjuvHGG6vue8MNN9gW3TRPJG2Ydfz4cYFnue666wTH3ImYdL/22mvFSM8PfvCD87a9//3vxzOf+UxccMEF4lr+Pe95Dz7xiU809J5dw7zD4lBc3jDRPLMTq79yu5Mhu0YhzmpolmZNczOWxSw7LItZ1ZKOdom3akrqITyeG8GUEkJQUhH3FMR8Uimvn1VbM6YbTY83Ypx3AtFSzTQ3p8xdLY34W2Xj/aY3vcnR/jRNfvvb34qGmvPvfe97IpH4whe+sOOvdcWKZmOHDGMWDVU0wGe55lbUMlJKKZWxIz5f51LfbKtp1prb3o7LIbrFG+7HtnOehv6hMRTyeaQTM2LeP7xKrI/2d2fhpGbFcx7bfyfmtWM1eOyuXhvH5rFoVYOfBvfDk7NiouFN49upDJOcEx9P1AtFlv4dD53EgX29eaHvyhXFoqGyokKzNOhGylzxeiFrmkC0mFO/ZoOzJprFSBjXQLNU01KjWaa0LO4rHcUpNYWw7MegHBFzLnM9t/eqOoliqchFsbhy1RbT3Im8WgEeTYEi218H5YuKqJfmy81WNzmdpszbKSvvukOm85CexG5tL8b0GeSlAGakmJiv0qfxjNBJDMtpdIuWyjRvOmVeTcvcNI/N1RYyploeJkdo/u53v6s5kVduiKHCK664QgQU/+Ef/sHR60mlUsJgj0ajApdYLaRsiPWKGIRpBCXjRl9qiOkh9pzwA+XBYIdVqSc+hswcFvgks9z8eD4/e0RWr14t9nMimuY0smmaG2lwcxFQJ4VAGy386aT4ZysqhfvxUCqAPrkoCnySWV7GsCxdl6dhmtdKerezICgfX898tysA6mrxdPPNN4v5rbfe6mh//qY5/Mesz372s4KfdeTIEcHSddVeo9EwL7O2SRBdYFWYFKf5XS4G6ryN4f5TWQmr+nRM5jJgLbhD42mcFQ9irC+AbCaFoeExRKL1CxS2Q0YB0KXW5IkJ3HdgVKTf10X7sfP8Z4gCqEqpCK/Pj3BfTJz3WIiyFxUOlA018+s3OpN5nmDR1cox2Er6yKFZbhzjW3auxrlbhuum4Q2jm+fw2zOT2F2Mi2sA433ZaTyVx30nE5Vz/oHxMzdUjz0xicN7j0IvOTffXblqp/Q5pApT4jS+/ckzWBWn4mOC00lkRwcFw9z8+FQKkM4KIz49jVAmUzEzh88KzCsAWvX11SgASoN1Kn+8bgFQmub7ZwoVA3fvVNaRGZw66SyxXE80xe/SDiOuBEWBTzLLex3DUs0sbxeKRXSOuCgWV67mmebVkuJGW66F49C9AUhKAXJ2fltsxbIMWNjnxLIMIIFI6jQS8TXwFSbh93sXYEfWSCnEwWsWf/1CjfUKM3ZSxLLYGPpMmTs1bQ3T2WwC0zS/WH0MSUREgc9wX0h8HkudLO/WYqB24udvm/bn9+UUp1OtyKxhmi/FMddhjYyMiMmJmCynWU4U4le/+lVR87Ge6KNeddVVwqf9z//8TwSD9YOsDz74IAYGBhqqL+Qa5lXE4bQcIkAejlFplcY3izw5/eIpGgV8DI13Pid7YohhYVqVXzLxDtzuxIh/9+Wb8Yk7DlaWzaa5VfVM81ric1ZjpVO8QWfKrJZpQ2PXnIqmsVDLfI5EQ0inqn8GzSS5mynsafccTk1zar5xrjfUCWBnmvNvm9/HL99+SVPvw1V3iO0Af+tOkC6uHCgyCPhCwkQke9oQ/51NRZBNlc2OIXVCFOwkg5xYFSbFaX7vm/ZgKud0oFV5/1hQxXBIR1LXMHFiCr/RFZwz5sW6oQGs27yt4U7VRrRxqGyW0sg02mCiQcS6E6i838XWQ/cdAmlwLIhJ3nokOv+islfMch5HF114Fq7ZOjzPUGbntl5MVzoBNkbDuHjzQKWNPrw30zGj3DDIeUwb5weeE5yY5WYZ5jeN8Hqjx9gxbzbLaZIb5zZ2kLhytVQid5zFOjkXSBVFFcZ3/75jYu5UbKX5mGIsjPxQHP5UFnJJgebzohgNI54vYOzo8bpGPA3Q8Ma4SBD7NsVFolheP3TGNJ8zUqX+tRXT3DBcx7MTNU3zaqLBOz6Z7bhpTgmTfBkEnCtmuQ5EdT/8ugdFSUV4xL4tdFEsrlx11jRXosMort4BJToEMB2uleBNTcF/ci+8qdojG4llGZqzP9hGr53eg0JkALOBYcSRha9YghYIIa2EEfEWsCW3H1JUPmN62pmc1czMHpVdWnu48q/uDjw4Mc3ZMhodACxaSl57K3df/HtNJ9ztjqdqnTG1jrNWjfM6v5tu1vHjx3H55ZcLtCFxhvRMDa1ataqyz/Oe9zz80z/9kwgf0ke98sorxYj+b3zjG5UipBS9WtYU+sEPfoDx8XFcfPHFwkxnkPEjH/kI3vWudzX0+lzD3Eb8ku6++27xBTAlymg/kSpMidPwYpS/EdOc+/IxhgHPoQM04Jksb9SAp2n+lXuPLFhvTZnXMs3t0uV8rBXvQvHG2kDB1EuZc4h6K0Up25HU7pa0eb8njw2BWcFi51Aw8tNY4PRwob8mZqaWaX7Pey9vw7tZGTIaTEPsRWykJ7ETIguX7KyXv/zlouPMVesK94URGRqu2qFGk5G/xe3eNPxaAclsEUTWchQ+k+I0v+8/AcemOffj/mXzPYdowI/M1DQOxtZj3art6B88cznaSdP8GgA/3m+6MJozzSvGbatpZ7Ni9d8Tjfp9e0/jR2NRrLsobJteFmiQA5Otm/odQu7QmP7Da3fhFeevnnfeTM5M4fihfUjOTkNTFcgeryhwunvNZmDONKeYum74c6/xXqxG+Tnbz3wPLDpqyJz+dqIDDezL8zm/12wqu2SdMa5cGaJJfvrC7VCCQVGsk/xxIlWYEqfxPXr/Ew2Z5tyXjzEMeD0agqSoCI9PIbL/OPoCC5EZtVLmhmk+T3Mpc8M0p4yUuWGaV1OtlPlimubLRQNaEJuVAQyoIXghwReUkUwUcDycQspfqKTLrYVXrWa5FcVSMctdFIsrV0L9Ph0FTapqmtMsz29+OjR/GHIuQaYhCwFBia+CFoohePDeuqa5WfH8JJ4yfR8OR7cj3TeCjNQHv6RjVJ3ETnlCJKyBBs3QpUqZV1EjKfOlkpHAbsfrtEvKG5qSYnhCXodpKQYFHnihiuKm5LWXv+tFTpm30zRvxjjvQayLVTSyWeiT01lnnTVvm1EviF4s0bb0ZynibunXUlu3bp33mCeffFLUKKKH+7nPfQ7XX3+9eB7u96lPfcoxG92Qa5hbxA+Txja/DDNChWYbl43kOdPmjSQJ+Vg+plXEi1EA1DDNa6FZWk2a15I5ZV5NjabMu11OX//qmI5N2gSCsoKM5oOi+eCVNAx5c4jIpbpsdjvT3DXLy2iEWhgBSivOpYHWrZu3/gMf+MCCIhBGMYqPfexjNZ+TfC12bLUiNvJ//Md/LNqXz3/+8y09l6szGlo9AE/A/rdU/g3p2OqZQr/swclkCCWPDyCShTepuYxIitP8njruHM9C05z7C7xLNIaiJmH96BhiCRmrpjKVFHgnxTZ952gIdxojffr8SMcCwmRdKmOTpqrt+oKK2w9P4l/uPIJH7t3f2h/pYEHTkTWD2DEWXmCW73vstyjmswhFovDyhk4pYXZqXCB4zlqzQ4yy4rmBBUAbSl/bvBdjpIS5/edzr1sVnWeSG7KmvxuR9RxT7Tk6lSiv154bbbkrVxRvl2hs0yw3I1Q8RUUsMyU+u3Utxu5JNpQyo2k+dvfj9oiX1bWfyTDNjZS5oQUp8w6hWWqZ5q7mdyDQLD+vOIag7kVaKqIEDXE5gIFiCGHFB2V9FgXMv6cxF2I1m+WG7LjlKxHFkjuchNeEwViwfa4Io6uVJeJTiFGxMs0TRYhkuTDLUxNn2mulKJa16AiKq7fD02BaNjB1EucWppBOxOHt64NPL2I4WITPWwd5azY1rUbmUpjmVbAs3So7A9m8rlXz3Jo2p1l+n7wDOSmAqJ6FDwpK8GJcGkBSDgtee7OmuZOUeU3T3E7NmubisZbziXEsLgOD3KrXvOY1YqolGuCGeU4xkW5ethPZ5pxalWuYW0RDmylwOzOby0yGcjv3axSr0E4UQ6OmeaPscjOWxZwyt93XhGXplpR5O3AstZ63unGuY608jT6vjskC9y0fQyXdg1lVFonz9YFZzGbHHONZ9vx/V3XgnSxvsYKzOcVdLV3OYhT1GmhzMYpWzPLDhw/jl7/8pZsu75Csv3n+RiNSAXE5h4zuRzjqQWnuxq1UKKGECJLFjMC00PwuM82dSirvP1dY5OSJJA6sjuHJ0ZBoZ4eii1TtqBWWOZPjDgt6tiKa5V/+yb5yArtLzXKzDBOXF2FMltMsZ8FS43rA5w8ILEtqdgqZk4cwGNk0v7ZEvZR5lfdBs5xccprj1u/XDr3CDuujp1KYOFG+sWq0oyRrKVbqJshddbNoaDMFzmS5taXmMpEqNM25XyDZ2LHMx9s9hgnf1RbT3JwyX2o0Sy3T3E2Zm1AsOkSynGb5tJQXX3hfmDaLhqRUwFo5DNYDPB1MYOtgfW45Ozvmccvn5KJYXLmqbZpT4XgcqeiQSJbbteVSLikS6GSbQ6lvtpJjPhjQK4+PlhIIl8o+goQglFQC3mi8YobWxLK0Qx00M7spZe7UNG5H6twwzfktM1lOs3xIP3P8BFCCX09gSopjn3wWBtXHO1oFr2GeeSum+bznWX5Gea/INcwtYvqbzPJqFVbJHydSpZHKqp2S2TR3okYLfbaj+GczKXOrad4Mv7zTqvY+zAbdQvCjJBLnA56CYJuntdqmPj+Do5/7gza/8pUho3JzO4tRtGKW79u3D7fffjuGhpYPH68bFIsG4AkGqv5Go3oJARXIFMvIFZ8lBVUqhhGVs6IQaFOiMdo3JFK498yZm5tiEQxZCwu1WTTkNxUjmBpTsHe8exOGP3piXCTLDVO3qmqZzItklFvFwqXEsDBZbtd5zvV6NoWtoyoO9PmdvZ8aqfJtO0axe8ugOMdSVs64UbzT9rU2YXa3bJBneicB5ar3xfS3YJaTqWUj8seJVOF+7VQ907xeAdBW0CyGad5MAVBqpZvmBreczHJiWJgsN8xyQ0MRH4qqgkDej22hMHSojXPL24xiceVqOZvmLPDJ0Xq+fEmM9rRKUovQ5SgioQCQcsYxb1lLlTLn3+Tf7jE1lLBuk3FO03xWD2E6FxPJcrvOFq6naU62eRyZxWeZN2uaU8uIn78c5bTa2YoRk6jki9PoshOLdXL7UvOQzaY5ZS7Sacci74TMqTcaRZV/W82DJkST3Ji6VXYpdi80eKBBhbzAnKMUXRZMcxYCrSfXLO8uHTlyRFRW5lxVVfFvTun0GYYw0S3f//73xb/ZhrzkJS/Bfffdh29+85viMadOnRIT2xFXnZcifpEywn4JgcCZ3yN/m76AD7FYEIongGIbalLSNCej+8kG043NiuiX3avjAiNitL/mwqeOjOZ6fHIH/HKzDo6nRDqSGJbfHJ/Cjx8ex8njDi+Oza+X/zamJWrPWeCTzHLe2NnJ4/VB0lVsjYYELmXBucr8Hqq8F6tZfsm6OK7YMCymc4f7503cZhZHFbDTdtGT4ewIaBcf35UrhyIqhQU+ySy3E4t1kj/O/ZZKRpLYMEsN87SC6TAZq0ZC2WzAGsasOdVsyMzVNljb5pR53WKXK0zm980Cn2SWE8NiNssNabKOmNcDqFJVs9zKLe8kisVNl7vqdQ36F5rmhiSlAFkrQff6wAF9VjKb7vHDD0XsZ5U1rW5Vbm6Ee3YuqFdIl8N3TJlTBtqjYto6RZ90UbK3GbO6nX+71b/fyuOLuheqNygwLHbiejLNWQi006pp/Fc7rmp1jhjGuauulGuYW0QUi8Eat3JxuMxigtzO/bpF7TLNrSgXs6xpt27EpbQiJuHNU9MmC2RhltM0t5N3rgBoSZfbZpbzuJydnRVVgDmvx3Ny1ZxuuukmXHDBBYKHTpOc/+ZEQ9wQi1Gw7TCqOf/nf/4njh07hvPPP18U+TWmO++8cwnfycpRDgGkpTCCKPCHYjHNPaKmQFIPI+FroVinyTykgXnnwSQOTS2OiTkWDVbaZqI8aNoaxSIdq0FTvJpo3D503yHccseTosDnmfUNFIxcZJPckN1nRuwKC3ySWW4nVSmJ7dFIUJjZLMrZyGfPfclNv+jCs3DNuWO4Zuswtg/1IaDnIBcTYs5OaY4m4EQDh9x6M7u8bnK/nXKNcldLKHLFyRsvRiMLxu5xuRgNC5Y592u37AxMs+FpTg7XNc1NyWSz8WrgPqymuZmj7ZrmzmR9v0VJhQIdcSZWTRqaM88HfV6IS3LP/O+5FrdcfIcWs9ycLucznTpWwKS/D0lvEAkXxeJqhWmoimnuzSXgS09BDcYrbblhnHO0pzcSgy81KfZzKmJZWpbZzLQzL52Y5u0y1uugYpbCNG/n32zWePdLivBRNH/Etn4VWeYsAOrXWwuOmpnptFSYbD+tRcXcbLE0lZavZ5ovoXEuBfohBQeqT4H2YKV7US6SxSIOtWZKlKYXC3wS60AMCxOhNMvD4bDYzv1oTLajiGenZMczb0Rmjnk1LEszxT+7SdXMcfP6eq/djGfJ6AEktBAG5QwSelAkWQ1uMm/raNBNKiGktfaMIzOK0JKrT5QQRz+wQ4fHaCdRIytRt956q5hqydxZYS1O4WoJJEkYl4cR0gro07PI6wFIfg/UYgFhqYSCJ4CT4IUpb2bLLHNesDNxXmaaN9ae08A8uCaG+06WzYvFKABq1K9gypym7WMADu/NtM4zb9JIp2nONvPy81Zj397TPcXGNncMh/tiiPUPigKfNM/N53b+rnOZFPqHV4n9UEiLlPnRnatxYM/Juu/ZMMv5fV28eUCMFAgpGex58EFkkzNQVQUejxexgSGs37wN/YPDtuzyjn+2rkHuqkvEX1//vmMoxsKCVU5mOTEsTJbTLPfm8ujff1zsJwx0uyKebUazmNVONItTnnkjRUBXCp7FrnMgxSKfUUUU+CSznAeDYZbzYJELHqjREjaU67K2zC2fQhCPzYYwMxiBIsnQMwXE1g9g/eRJ9GdTVdPlrlnuajma5kSnWE3z0vheKKEYlL4RePLJMobF44cajEEuZhE5/USlLVdCcYFxYeK8ERO9ZYSGHV96KYqAdoE6ZdA3ymSPI4dhKY1TWgzDSAvTXC2URxHwWElJYazSpxFrEsdi1aTWh73aGCb1PkEIoFnPv79DHsewfGZ0ua1qMfKr4VkMmU1zp6gWPibrjl7vlNyEuY1oND7jGc8QSdBcLoepqSkx5zLXczuNyl//+teCS/yrX/1KzLnM9Uspq8G9WHiWTmBZOp1gd5okd5I6P/M3JRzXBlHQvYhLeTE8SIIOn6SKgp95zYsjBfbQzb/xKqcwy5NT8Vi7++67cfLkSdGRQz4251zm+qU+Fl256galpQgOyWuRlPrgF6U+s+jz65jWInhCXY1SuB9rB724eK2Cy9YruHRdec7loVB9dJJdyvo3B2cWte21tkXDa5q4oKdBbp5aEDEs37ptT0PtWSPasGNd1anRhL2xPxP65M8bokG+duM2+INhUeCzVCxA0zQx5zLXr92wtVzMO+ATHcl8DhrhzZjl+x77LZIzE/CHQoj2D4r59OQ49jx8P2anJxcvQW6eXLnqIjFhPnr/EwifnoYS8qMwGBXz8PgURn/7hNjOwqDjz3gKTj5zF05e8lQx5zLXt1vVjM9W0CzmNLNZRtLcnDK300pOmld7f2MjYRwPp1CQFcSUAEbYyUyjXJUwrAWg+zSs3lRk//o8FIvZLHfKLadZfp80holADEG1iNDUDPylIqb7+rFn7RYcSnbfCNtu1ec+9zkRPAkGg+Le+557WCnGXo899hhe/OIXi/15Tv70pz+9YJ8PfvCDYpt5YrjIVfs1MFeEk7LjjI8VJxA/dC/8yVPQ/CGUIkNi7k+cRPzwvfCnJ1HsG8bslmdiZvtzML31WWLO5VzE2fWpYyyLWU544jTNrUlyu3Ud1mKkzNuBYGnn32AbTbM6JJWEiU2vRfKHUIBPsMvDegHbtGNtKfh5KqXhHnWjMOfDKGJISos5l7meZnrTaBbKKbveSJ1b0+fV1rvqiNyEeRXRFDfQLNYEuWFUZrNZsY4FQskrplHJ/Q1TfakKgNI0N1KH7Uiam9N3UxmlqeKfVjkp/tlJNYJdaTQpn9RDwohbK0+LAqB+T0lgWJgsp1k+q84fRmQ1lZzgWJhwZLKcxyCPNSP9yOPU6NDhdh7D3TTqwZWrpTLN03IYvKzyCsadF7lwAMlUETEph+2rc0AhhJlEFqwpR0zuqj4dsaCK+08AUznZUfFPwzQnLmP/5gGcv2Zxhq+ZR/rMa9tqFdNsVTXQKZ0yymk2b9m5GtddWsaQ2YlFRpnyLr8OZymTP7x2F15x/mpE/fPPk0x4bzvnaTh+aJ8oAKqpaYFhYbKcZjm3G+dYng9n0sV5BaudmOWjfQGRLC/msxgYOtOW+/0B+Ab8SMxM4ejBfVi9/WmV52mKXe4a4K6WgWiKj939uG2CnKb46Qu3QwkG4U9lRIFQMs+zo4MimU6znY9fjAKgNM3DG+PCRPVtigtTVV4/JExzaXX5/sBImdM0z1ruxqwpc7PqFQFdaUnzWh0BRgdCyl/Avtg0zscQvHkfZE1CJChDjZSEWe6NqTWLfPI7sprlVm45LcInpAGks8BAKS2OSX5LflWBL5tCIhzF+Lq1iDyWXGDouOny+frOd76Dd7zjHfjCF74g7qlpgF911VUCezg6OjcUwCTeC23evBnXXXcdrr/++qrPe8455+C//uu/KsscleuqMxoM6BVUimGam9PmNM2nD0wuSJDzETTLExufDs0XhiefgEcpM8+LsVU4HYlh9Og9CGUmbQt/kmMeajS010jK3FCnDXK+njqM9UYT2o1osbEvTt8Lk90X4VAl+U1/xePXsEZKYUtuP4b05s/x89pyeR1yuk8kyg0bJQBFJNv5d/dqo8JE5za+7qqfVytJczu55viSyD1T1JBIjvX394xR2QnTvBqWpZpZw5Q5i5GJf/f5hYHQbViWZsxy62Pt3ou5E4CmeVJdg4hWQCmTE8zyMoZlYbLcrKl/ermj18GOGWJY7DBAXCZKiNu5n/UYduVqRUqSkMP8zqpY1I+12eMISAompTD0kB96OiGQLJM5HcMhHdsGVUwdbwzPQtN073gWh1ZnOoplCfk9lXQz22DR/s61uUslI2HdTr42E/Pks69ZE8MrL1mLi9cO1ezY/cKcqQwM4vDeozWf+7zdG3Hp5tgCs9wQTXEmvrPppCgESjwLMSxGu7t3MoW7jiZw34HpOQRN7c4Cfi4za2LidZJBn0klhBnfF7Nvy8ORqDDN+zNN3AS4JrmrZSj+SgIWVjlvcGe3nSXMcrLMjV+Sp6iIZWJcZreuxdg9C83Kdmqx0CytmubUcjDOnZjlhtas9uC0Pgtf0YuNfQGUPLrAsFiT5Y0U+TSny5Pw43TGgz41VzbLk2fOxeIKYiqNVDyOXCSCcObM8eua5Qv1qU99Cq9//evx2te+VizTOP/Rj36Er3zlK7jhhhsW7P/0pz9dTJTddrNBvmrVqg6+clfVTHM7RMugX8eMBbPCX0NmbIcwy73piUp7LSlFhHMTyPeNYHZkB4KZyXltOf8O/14jsjU6rSZmLdO8C9QJ03ypCos2YprTrE4gJAqBkm1OXIsUlVFq3S9HEhFMSzFESglIlqq0PF/EkMekHhV/vx+5+k9YzzSnGjXOXS2qXCRLg2rEqFwK0TQ3ioBatVSIgF4q/tle011CRg+iGB5AWgu0zSynOOqBzHKObrATufvczv1cuXJlLybOOQoko/vhMwxTv3GTLYH3u0PhMtu8UbHj8L6TiY4XAKUhf8WGYewYqz4UfzFkpKdfd/U2MV1++fa2PO8Lfv8CvP26XeI533b5pppmOcXtN/6fnZXXwcc7xbSELRfG5nN7JBpHfJDGfbymWV4r+W1sO3EiiT2nyxfZNOE1lfUn7Ntyr88nmObJbFaM8OJxVSvFXpFrlrtaQWLinAlzJsuthjiXyTynac79OlkAtN1olmaLgNbDsywHREsjZnnl85GADas80PsUbByrbpYbcsotpxIncoJZ7tXVeWY5lU0q8CoKNFmG4luZWTXWATNP1e5PWDPs/vvvx/Of//zKOlmWxfJdd93V0mvYt28f1qxZI9Lor3jFK3DkSDlk5qq9CkbOBPasJrZdMVCDbU4xcV7qGxLJctu2PJdEPjKMYtC5qVsNyzJPddLc3ax2oVMWA8Hi5DU4EdvufimHUTkl5oYl54u1HhIsSgTqegRW104+qCLZTrPeUF2jv97x5RTR4mpJ5BrmDapXjMpOmebmomhMNS5WsrtdaudrsHuuZjsBGjHLjRENTEoQBVTtgpPbud9yUdDvEYnaWhP3cbVyFHFQX6CWiGfhwBt17lToC/jKxvmcaU48i1eGKATaqBYz6T0U9WPrYFiM9lkUWXAsBiqFBjXNe07X7hoR65oVn/MVL7sYN16xDdduHxPTjmFnBg/3Mx7z1mduFOY9n89snJuXzaOxWpETTAr3oeF9YDwtDHcm1ol5URT7tlwplZBTgMdmCoKNf8/9xzB5osZQ4B7hj9drz9223FUjIp5F83oEhsVOLBCqez1iv07IbJozZW5VVdPcZMa6prkz8TU3ZZabPi/jM6xmltsW+Zw6XdUsp/yaAq+uIZPRFpjllOL1QtY0eEvKskqXJ0+kxTFfdTpRLo63bt06ETYzpo9+9KO2z8fQmaqqGBsbm7eey6dOnWr6dRLtcuutt+InP/kJPv/5z+PJJ5/Es571LKRSvT/SohtlxqLUM80pwzQnnkWTfZCqXBPJahGazPY+4Jhj3rCs5mWrGIxmH18tlVxFzZrd3WCUt/P10DRvxTj36yV4oUL8f66oqFkleOCRNJFsN6stprlrnHelXMO8QXWTUUk8zOzsLMbHx8Wcy2b94bmrFi1pbjZquqX4ZzfLSJfTKG/ULKd4sWkw9q3fO5eZ3uB27ufK1XJXs6Y5WeYaZHhQvsH1+b3CNDdElrmiQSBaOin+ZtPJBGamJsTc+pvuKtmwy2mMv/H3NguDmiltc1K70SKcBoKFXPE3XrS+aurbqYg9oenO5zNej91ravXvNNr+Hz1VTqcfzUuICeRLyrYtn5yewYwUwj3Hi87McleuVqDIMpeVMrPcTprPC0lRxX6tqpbJyS3pYBiHZyQkvUFk5lLmVWUgPqqY5lZ1yjTvFeO8nlHeSbPckGGWW0cTRJU8BooZZAMhcRyYxeVCOIxoIoHQHI5lOZjljejo0aPinsWYbrzxxkX9+9dcc41gnJ977rmCh37bbbeJe+fvfve7i/o6VpKaMc37pTxkrcwsn/dcc02e5vFD1tjeVzfDyTGvp5rFP6nUDHhJNlv0YDzvxewMfRZ0vQyzuZbp7GSfblCrr61Z0zyGDAb1JFJEdVq28RhI6kEMSymBgWlYTkYyuMZ512lljgtrQYZRyQKfZoa52ahcvXp1x41Kg5XOnngm2mnS83Wx4re54ChN8+8/vLBHvhGmuROOeS8U/3RqqllN/lpJUTs2u9P31IxRbsio7s6LTh4LRAFxdAM7bHgMhsNhsd0t+OlqpaiZOgk5BJCWwoj705gqsv+4/HthyrxU1BHzA6fSEhImBqMTNVL0cnZ6EkcO7kNyZkqgNzwer+Bmr9+8Df2Dw+h2s/ySK84RqBRr+ntTLIJ1q6KiACcNaqdFKmmWv/wFO/HHT1ndNhObz0PznR2737ptz7zvh+09jWueD2muO9Vvjk/hzoNJPHxgEiePJ2ob2RbxszAKk5I9//TREfiTCcEqJ7OcGBaOUpuZTWBWlfGYEsc9Dx93zXJXrqqIhT9Z0JMFPs0Mc4o3vMVoGOHxKbFfO2RXAPRQMoDkUzcgGY5ClT0IBmVhoG4+PoGz1nqrFwC14ZkbsvLMzWoX07wX2Ob1DH27ToFmzXJD9Yp8GulyA73Do2H04CFMr90iCnyGCzmUZgtQ2J6Hw/DnCxg7elzst9LMcor3KZzqifeyHo9HhMHM4nI7+eOs77R9+3bs37+/bc/pyt40Nwzsekxzyp9PIJabRDa2GnqizDA3zHLRlodiCCdPiv2aEbEs3mj9Ao0TJT/2TkYwmfdC0SV4JR3DiTx2jAUxEuqdIo3dbIgvBqOdprktgqeGeMxt144iKYcxJcURLWQR9HtFspxmeVgqYod8uoKBMatmAVAnTHOzXL5518hNmDdpVNKQpFGZz+ehaZqYc3kxjEr+nbvvvluY9vx7Q0NDYs5lruf2xUqa9yKWpZponNgl4qutb+U9tWKWG2LHCIcYsoMml8thampKzLnM9eaOE1euVoIa/i1KEsblYZQkH+JSXvDqJOjwyyqGQ0BWkbBvmlfqDtrzBgzL8Bxugmb5nofvx/TkOPyhkCguyTmXuZ7be9Esp2g+E4diJLudaMOOdW03y826ZuuweH4W+mQq3kDG0LQmb37cARs8W1DnmeU0vhsxyyvPk8rgkXv3i+e497SM4qqtCEWHREHx2ekpTCRSSHijuCszgv95uI4h75rlrla42EL37zsGbz4vWOWq3wddksScy95cHv37y2ZlJ5SOxXBo53ZM9/XDXyoimk1BSmQwEYjhofg6TM0VnG4nz7yZpHm9tHm3Jc6dvBa7VHkrZjk//2pmuRXFYpjlFPEj/dkUdh4/gMH0LJIlLzLRKEqBAOLT09i49wn0JdtQkW6Zi+GfCy+8EL/4xS8q63ifzeVLLrmkbX8nnU7jwIED4p7JVXsVNo00t6pe0ly05RN74S1mIcVH4PcHoEOC6gmIgp9cz+1O23IDy2JwzO00z5BNTwuz/J7kIE4ldYQ9Gob8ipifyvlwz9ESJpoIFjetBrEsy1FLkTQf0pPYre3FmD6DvBTAtB5BFn6skhN4uuewKDxaTY4M/kaY+UbivN6UbqxjYIECUSAQqzFFsVLlJsxbMCqNhDf5Z0x486RrTXgzdc4UMNNixLTYFQttRHw+/l3eVJsT7nxuLhvJc/bQm/9OraQ5xXSdUwOdHHMWH7OK6T0aDwaWhcXJxL/7/IvK860qXUdAywtuMVEMBTlYrhrhEB3Trvdx9HN/gHaJ37mBZmnXMebK1UpSWorgkLwWcW1cFAD1e0ooaBpOzZTN8qmc0a9cLv5Jr5uIlnLqXKpqhj503yHRZpAtbmeWh3wyHj64D/l8DvGBocpvljcHvgG/SBsfPbhv3rZqYmHR/dPZSvvbKbPcjDIhF5yGeK1UNrcx2U19/0eP1EyZM1l+2QVrhVnu5DyYTSdFwUwywMN9sbqfkWHA0zRnRy954I2KZvnDk7PzkuWtiqY5RyQdXBPDQGQAw/4YZF3BoUQBU1kJB/aeqp3Od81yV66EmDAfvf8JzG47SxQA1aMhgWFhspxmObdXUoqxiOCZE9HC1LnUQsqcz3dq3VoUAwFETs3AHyvfWvlVBX2lNGZ8fXhsNoRn9efn/Z0FSfO5VDNT5jRts96yiTuVP74gaU7T9+jcSJlaSXOqmbT5YibO41IQfsmDoq4ioZdNLSeGvdNUeaNmeUUNmuWGaJqX7pxEfyQiCnySWU4Mi/Hdr8R0eaN6xzvegVe/+tXYvXs3LrroInz6059GJpPBa1/7WrH9Va96FdauXVvhoHN07eOPP1759/Hjx/Hggw+ir68PW7duFevf9a534fd///exYcMGnDhxAh/4wAdEkv3lL289wORqocJ9gYpZbU6ZO0mahzKTGD16D2ZHdogCn5ocFRgWJstplnM7xV9SLhCH4g3AqxQwVUhgyGLI1xKTx1YzlciNvZkocqoHw74iJDatniACHh3DsoLJohd7x/MYHs5AsgmSdEuyfLHFzy2hBVDQPQhIKuJywTaB3UtJc5rmF6uPIYkItOCgYJYTw9K29+U0ae5qyeUa5h00Kp1iUxoR/x6fz84U5TKHu3E79+NwM7Oqmead4pp3E5alT89gXf44wmoGMlRo8CDriWDKP4pA3HljVc00d4qDaKdZbv7erd+1K1crVc2gWWian1DXIKIVUMrkkEwXMX78RMUQHwpp2DaoYiisiyKg5JrTzJxvqM8XTU4yp7eM9eH8NQt/n6lkApnkNMJ9Udu2nGgOmuaZVBJ9Mft0Ra6oilQ009ETmc6b5SNrBkV7fe6WYbzi/NWOECYGDoX66a8O1ExKG7UwaqXLia45fmgfkrPT0FRFFMwkA3ztxm0CZVPvtRidvuZOXc4nMr6GzXKiXZyiZmrp8N6jOLy3iQe6ZrkrV/NEU3zs7serGuI00g1DXRQJVVTxGKbTDUO9UeUiEaTjcQSz5b/DIo/hOdO8mCwi0p/DjD+C8WOnsOqsQAXNskAWNEs7TPNaiBaqEeO83eb5kBzGds8Ihj0ReDngOejBjCeHg94ZzCC/ZGa5SJfXMcvricdBeI5VbpZrljvTS1/6UnEPfdNNN4lCn+eff74o1mkUAj1y5Ahk+cy1Fw3wCy64oLL8yU9+UkzPec5zcMcdd4h1x44dE+Y4R+PyHvyyyy7Db37zG3c07hKZ5lbZmebBzCSKwbgo8ElmOTEsRlueiwwLQ12PDkOVvfBoCiLZSXiTexDPTzaMZTFQGjR9J3NALKAsMEa5HPWqAtOSKHnQbzbFI0Mr0iinJpQQ9hYHMamGoegyvJKGYU8WO/zTGPHmeh7PEkcGPrkxooIjNAvlmuY9oZ5Ashw6dAive93rsGnTJoRCIWzZskX0DLMXeSllGJU8gXNuNcsbwaY4Fc15mu8+n6/qUDZu5352qoZnccIx71UsC83yrfIpRNUkSrIPWTki5lzepB5DoNTYDYCTNDpNJbMi0WBHzHJXrnpJi9WWN9fGSMjoQcyoIaQU3zyz/MI1Klb16cgpwHQOYs5lruf2eqKxbSg79+9SqQhVdKTat5/kWJNpzv1qiZ2dNMs7li6fE83yNWtiuO7S9cIAb4T3TfExVz17i0iSm2UU4WQbyXNJPbN832O/xezUOALBIKLxATHnMtdzez3ZPT/Nc35+P94/KXAreydTC6bbD08Ks9ww2Wua5TSy7aZ2yjXLWxavk2jE8NqNaURDH/zgB8U66xSJ1C5ga/eYb3/721iu6tprc466TGYQmkyIudksP33hdsE59+YKCE6nxJzLXM/tjYoGKFPEmscDj2JfHVqbzUORZBTlMxmlemiWakVAm8GzVEO0iOdzgGixQ6S0imyhWX5pfDPOigxACQGpkIK8VMKIGsZ5xTEMaMGGCnsutlleLV1OTR5bnLpMy11vfetbcfjwYdFO876ZI7sN0QS/9dZbK8sbN24UI8+sk2GWU2yLaazz+Wiec5ltlqv2t+V+0zU4TXMnRUCr4VkC+QRC6dNibjbLT6+7SHDOfaUsItkpMU9GV+OJVRchERy2NedrYVkq++geYfr6JNO1ffHM4/yyLpjmBc3iptMo75RZ3sWGKs3ye/JrcErpQ1hWMOTJiTmXuZ7bl0Mh0Gbk2NxvBM/iaknUEwlzprTJL/viF78ohlY9+uijeP3rXy+GZ7EHudvULDbFifgcTKqXSiXxb6t4cuN2u21OkuZO1TNYFl3HmDYJv1RERo5UECwqvGK5X8shljuFCW9fZZsTNfp+9vx/VzX18l25Wk7q1ra8+ggXXSTLw15dJE4ME52e92ROx3CovH3quD2epVbxT5/PD4/XC0lTAHlhJ5xSKokCoNxvyWSDYmlGNKmZ0K4kyC3PR5b4G39vMy5eO1TzvMpkeTGfRbT/DKbG5w8ILEtqdgrHD+8XHPh651VzBzDPU4Z47rpz7vxlvNa2dkSYTe5aQ3kbeR5XTes973kP1qxZg4ceemjeeg7df+Mb3zhv3fOe9zw8/elPr/ucX/3qV3H11VdXlpfz6K9ubc/tRGuGyXIlGJxXFNRTVMQyOeezW9di7J5kw3gWIjdkVYXq9Yh/w5IyVzweeHUNfk1B9lAa4Y3lG36nRUDbmTSnWkmbm9W0aa4Du0qrEVS9mJbylVNnERqmkcegHsRmZQD3+05WtlUz9q0dAd1slrvpclfdqsVsy2sVAXXclo/sgOIPI5iegHeun9CrFhHJTKAQHcbxwR2InZhsGMtCgzMQCoiEdKmoIGAOC9I09wdR1MoFQANyG37PRlHHHpXA1xQHkdO8GPacQZUEoIrlSbWcPB/2HO86PAvVaNq8o3KT5l2tnkiY8+aDNyFXXnklNm/ejBe+8IXihuZ73/seulGNYFMaFZ/TQMHQQDCLy8lkUmznfrXUbNK81xRCAX16FnkTr7yyLeBFyRNEsJSGT218yJA1aV4t1eqa5a5cLX5b7jRlbjbLM6l8OTl88ohYJrOcGJakuLa3Xu1JYj23c79GxJR5NBbHwMAQ0umkbVuezaQEvzwSdZ56PDiewr69p5sqQrlAFkOXo2bY5rGztBkZyW4myRs1yykyy4lhCUXsETZcz4Q593Mqs1luFY1yq1nODuCjp1Ki0GfNdHkn5ZrlbdGPf/xj/OxnP7M1A8i9XbVqVWUaHx8XfFwm8OqJBrn5scFgYyMxekm9dG1ORAsT5P7UQl45l/2prDDNuV+jmt2fRl8igXw4Iswcs7icDYQQnpxGVMkvMFytqpY0N9RM0ryRtHmjifNmFNX9GFBDSEtFu9Mq0lJJbOd+1V6TXarcXNyzKbN8Tlaz3CzXLHe1HNWJtjzQF7RNmTdaBNQqIlrINffnEgh7bFBIxSQSoRFkAmd8EAMLY8Wy2InsbeJEkqpfGMJm6YU8UooHw0EFcZ/9iKKVJIGvUcOIeYpli8UfqkxSIIRoUMakNIBEaKztZnCrSfPFSps3ZOzTNF/BafMXvvCFWL9+vbhuZl3IP/mTPxGjgmopn8/jLW95iyB58Nr9xS9+sbhmN4sIr2uvvVaQPkZHR/Hud79b0DiWnWFuJxrGg4O1f3wcdkUD2TwthlrFptQSjQEy0PmlM6nOA4W9wpxzmeu53Ulynab5khjnui4wBlE9jRAL/Oj6AoRJu8QCnzI0qLAf5q9JHki6Jthn7Rbfk2uWu3LVG2251SynWJ+TzPJSletiruf2uTqeDYlt9KatOxAKhgWrvFgoiLaccy4HgyGs27zN8SiktprlJjENTlN73aoort01IoxtM9aE5n4mlUBiekLMrea/Wa+54Cy87upt+MNrd1UmmuXnDte/aGWBTzLLqyFsPF6f2M79OiHDLG9Hoc+mjO9OYF16QNbffTPXTVbxYprpua9//evimqme/vEf/xHbt2/Hs571rLr78sKdoQUWqvvKV75S8/ewEtvzpbouJ89cMMurNOZySYHu9Yj9GhVb6FVHj8NfKCATj6Pk80GXJCRyEhLhKIKlItZNnkTKYrDaoVmqaV4xyjnZmeaGQWw2jSk703yBca4D4ZIP22MD2BSPY6yKsd6q/LoHXkgowR5nFgjLiAR8WN2/sPPC7nXbpcqbMsunTp/psDCpXpFPyjXLXS03tePavJppbkazVDPNqxnn5Jlrsheyaj/6z6MWxXZFdu4rmJPGeiYh2NshFvjMAXlNhqaX55MlP0JaDjuibSho2Wi6vAHDmZcds2oA40pYzDt1GVLB1/j9ZaPcIr+kzeFr5DPvoY3G+bI0zakVappfccUV+O53v4u9e/fi3/7t33DgwAG85CUvqfmY66+/Hj/4wQ/wL//yL/jv//5vYbD/0R/9UWW7qqrCLCeB484778TXvvY1gfNifYxlh2Sxav/+/bjlllvqDhNi9eybb74Zi612YFNqiVgXstyMgqKpVEo8H3tjmiko2iyixYxlIXvWKDpXC8tSSExjqHhaFN/UVF4uy0hLYYzLw0h24HBU4BV/wwNVYFgMheYcLllXoUuyKBhSL3lovA+naJZ73nt5G96BK0NhnwfhOs6k6mvCuXTVs215Jl1APBhpGcFiZ5Yb6BUW+ORhZcKQV8T13G63zdCB8bQozLlxKLIgZR6IDmDrU5+GIwf3iXR0LpMSGJah4TFhlvcPDtd8H2Rr33U0IdpbFjqthYBpxSxnkc9LN8cWpMCbKcB57fYxXLFh/gdWi1tuiNgVPr+ilASGxSpVKYnt3M+JzOepRo6bmp9xMyZ4LTzLMjbI67XnRlu+bt26eevJVSVjvFnRwH7Na14jkCu7d+8W7NZaYhjhm9/8Jm644Ya6z/2hD30Iz33uc4UJz/T6m9/8ZqTTabz97W/HSpCT9nyprstZ/JMFPjWfR2BYrNJ8XkiKKvZrRqm9CWzEEzi1bq0oAFoIhSBrGsbSs8Is78/ON1hpvraKZqGseBaqFqKFssO0nDipYm02ilgpAI8uQ5U0JH0FRGMppPyFhnEttVSUVCjQ4YMsMCyG+sLlzlAPDSoiEcwM4Tr4FeO9Gu/fUCNmuVlWFEutUQErXVMnCijI1dvytOYmcXtNnfJZGikCalcIlGLxT1lT4Pf7AHXh41WPX2z3agXYZeXIMTcb+XZiocqLgifKhSwLYaQ8QYFhWeXPY0ckhREGM4ID6EYUy2IV4KQCfVF4Sz6UdBUBS3tNFcXfJ77Gso2meZtM4VbxLF2NaKFWEKbl+uuvr/x7w4YN4rr7RS96kfBT7ULI7NT78pe/jH/+538W194UR8qcffbZoqDzxRdfLK7FOUL0v/7rv0TNSdYt+vCHP4y/+qu/EvcSDDF3fcKcH4RdkSTzRFPYrOPHj4uhQ9ddd51ICNXSjTfeKD5MYzp69CgWQ+3CptSSUeGbvTHPfvazxZzLzVb7dpI0r1X404lYXHNN/kil+GYaYRThQ0xPY6N2HDGp9YbcmlTPIYBiIIagVk6yz5Ouw6fmkff1oeQJVYzyasP0aw3fN2MgaJS7ZrmrlaSlbMtpFDvFstDwtDPLmcq2muVUoiBhKishJpq+hYPtuZ7buV81sUPtvpMJHJqyR3jQFN914cU4/xnPwrlPf6aYP/XCi2ua5Swi+uCJ2YpZ3nY54Gu3UoCTBrl5cqJwX0yY8exUsDuvcj1Neu7XaVXFsTSrxSgS2qPib93822db0EobRBOAIYNqz2PV97//fbH/q1/96rr7vv/978czn/lMXHDBBeJinIz0T3ziE+g1dbI9X6rrcn8yg+B0EsWoPTalGA0Lljn3a1Z9ySS2PPY7bH/oEWx99DExX3XnI/PMcnMy2c6EbbQIqF3SvBaixc5oDuR8eHpxFOv///buBLit8nwX+KNdsi1vcTaThKwsLZBwk4ZhuSW0GUILbdN2einDQAgM0BRomdAygbINhaZQCpRACfCH0N6WCdO5DWVo/7SUkjD3sqSEspSSQCDBIcGJl3jVvtx5P+fIsnwkH8lazrGe34wxko7lL5b9Wn70nvdDHcL2OPqdEoDG0RTxYUFfM/wRT2o0SvpbofptEUT9MbS4a1Dnc6mgXAvLVZd73KXC+oAzmuoozzZ+JdcIlnzD8lxzy9Oxu5ysolLPzZ1pz8PGCqdzbQKa3m2udZy7Q71oDnUi5G3QH4HlrkdDsAO14bFD1GxjWSSAlXD5dN9+LKtpw/90f4RlTR04vaELk12R4dC7kOC7xGF52TbgrGtGgyOKFlcYfTGnXsSC/phT3S7H6X282cJgCc61t8zrxqvgUN+EY1r6SnDmZ6bu7m7VrHLaaadlndixY8cOFaYvX748dZ00DstYl1dffVVdlvcnnniiCss1K1asUOt+7733rNFhft1116lOn1xklpZG2uwlGJYv3qOPPjrm/UsHd6Fd3OOhjU2RXx4yJkVmlssrGNJZLg9QPmNTxvo8xdxQqhibgWYlY1eC7XAm0zbfVF0mTgwkHWrO+FH2bvTFW3U3zyuYzYYu9xR4QiHUJgbVLHMZz2JPRFVYLqds9fmmqeOMBOLpHfN6/vGDU4u3diKLqHQtl9A828xyuV5ul6BcwvF0qqs8Z/hpw4fdDtR742qDz75IUo1hkeZXCcsDsaHbs9Usue+339ibOiNnqt+bOrtlxGex2VBXb+wFVAnLtc7y9HEsMipk1L+liKFr+gumxdiAUzYB1bogRaPHpb4+2cj9SOe6zHaX+5eZ5TKGRTrLJSx3e2tw1NHzx/17lcxFnj/JW7Fq0D/+8Q/1BDqznki3+YUXXqhO18wcx3LeeeeNeLJtlJwJKJ0s8sdEJZ6LmrGeV+x5udSYDz9FpL5GzSqXmeUyhkU6yyUsdwZDaNy9f1zPPiUcnT7dhprBwVGBassM/X+z1mmudZmLfDrNhd5GoHqd5mJUt3l3GA09tXDGHAh5o2iwyXEOdAWi6LOFUR/zqM7zna7wqF9z4wnN90f6URNzqfsPOKKqo1062yUsDzticLdGcaxv9P2PNX5FZAvKCw3LOYqFrKrSz81Tx9V5VWf3WF3mY20CqoXm3q5dCHkaMFg7Gd5QnxrDIp3lIW89/NFBHNW9K+9anr75p0aeTjY6jvyMO725A3B/U+nD8hyd2WXbgDMt5Jb7kY773rhLjavxO2NqDIt0lktY7nPE1e05P18Rus2L0WVejlEtssaCx8hkfo1K8WKDqwZw5zhr25UoyZmf6aTZ5MEHH0QgEFAd4s8991zWY9vb21W+mpmFyvN1uU07JvP5u3ZZO8b0gbl0QxvtiJZXPKWIL168WLXb2+3mHr9e7LEp5ZLeaZ5veJ5tLIuQTTVlc82BtM033W4HIjLLwGZDKOlBiyeM2mAYg8nibpIVcNThgHdWahSMB2E4E04E3Q0qLA+7/HndX2ZozpCcqp0ZarnWaZ4ZnGvXp8auZAvIpataJ2DuCtqx4wCwoDmuNvj0u4fGsLQPDIXlcnsuWmi+ZF4zTmqJ6wbmRmWG5VJjJSyX+y9FWF6TFkIUugFnrX/0k0MZUSNd97sODgfm8jvjK/Nbcobm0kG+4PP/I20MzIAaw9LYMk2F5dnGwNDEZ7QGPfDAA7jjjjtGBATSbfL000+r52zp9uzZg5deegnPPvtsQWt666230NTUZKmw3Cz1vBSkw3zKjg/Qs2CG2gA06fepMSw1B7tUWC63l4OErvUzRj/vTA/NNWOF5kIb0ZIemgsJzrUgWW9Ei1jgq4Er4cVh98gNOCcd6fi2x5OoH/SocDvgKt7ZTDLm5cP67tQYGHvShTqvHWF/BIONAYR90awd8dq/QzPeESwMy2miqmQtd/obsnZwp8s3NBd1gU7MOrAdhyYdi8GaFoQ9fjWGZVrwgArLG0KdKHq4KYFlrpCyhJ3jBW3AmUYu++0Rdbscl3oRIF86/37puF9a341dg350Rj3oTzpHjq/ROvJhvdDc1PS+XsHi78enZ9++fSMaWXI9x5WzXO66666c9/f++++rbFTIhpyXXXYZPvnkEzXu6eKLL1aheaWboSwxw1yK+LJly9Q8G5mnJV3bmmnTKrBppUHyS0obzaJ1GMkYlko/6MXsOE+fY54rYA4e7oMtGYfb7UMwOnrOler6liA7yyZAxQjNA95aeBIhNPtsama5GsNy5LEw0l2u5/9curjIKyWauMpRy/VGtGhjWMYcpZEjNO/ab0ODJ6k2+JTX+YbGsGTUcvnYLONM3vioG6fObMAkSdyLFJa/81EnPtr5WUk7ywvfgHNAdwNOCcv/e3enmu2eTl6E/G9AfY2Obcn+IqaE4tK5LmG83L90tMsYlkJ+r2a+sCuX05Vk3A1VlJyqma6urk69nzdvHmbMmDHiNtm0U5ocvvKVr+iOapHT0bXT2WXTIdlMVDpivF4vXnjhBfzsZz/Dj370I0xUVnxuLqH41Nf/g0h9rdrgU2aWyxiWYj0r17rMM2V2maeH5rnmmY+QR2guDHWbx22Q0bONNXb166w7NHLedMKeRKPLhQUNNQgdCbF3dRVnnnnrdAeSyQACkQgcCRsG7ElE3bHUr9VCgnIzhOVEVlOOWp6ty7xQEprXBjpVp3nM6YEzFkYrerLWcvl82saj6XPMJdSXcD9bl/kIY4XmFZTagBP6ewa4bXH0J9zquILk+HdLKN7S0KU6zWWDT5lZLmNY8npaXiWh+bi6zC125mchZ7lIbipvxxxzjJpFLt3sMo/81FNHN6dKbZLpHT09PSO6zOW5uFa35P327dtHfJzcrt02oQJz+cNDNqCQt8w/aDJnmZpNscemlFuxxrRIQJ20OWBPyjPX0a9ay6acsjlnrJRj9W02hB0+hAwO+M9FAvb/Ov+EoiyLqFoUu5b39YfRZGDTT21vg4C/1lhorhs6555Vnot8Tgnyd3cH1OiRzA1Ax9LVH8E7nT3YeSg4dlheBoVuwJktLNfI9SqkPh45Q3P5varXuW6Udt+HwxFgSo6ZjlN86msua5Ka//ljWiAT7zoOlGCOOZlKIpHAk08+qZ7oOxyj/8CURohdu3alLsuMxYceekhtWiS1bP78+bj33nvHnAFrZVZ9bi5V3DOOWeWlkB6aa0aNZskjNBdGus3jDjva5Wl33AY4k2j2Dn+vS3huT9hUaB63J7NuvjkuNiDqiUF7aVIvJNfWqheU63WV5zOvvJCwfCzsLierKVUtL2WXuZAjfDKr/Ej2bvOUIdysdGieJVj22OJqg88oHGoMS6ZI0qFul+MK+pxjUONrnONsMqmS0LyaTM7jLBe95+Ei24x0ORtGnnu/+OKL+Pa3v62uk+flbW1tqYBd3t955504dOgQpkyZkqp3Evh/7nOfM7wW8547mUb+YJGCrfdGpWdkQ9D0sSx6pJtbNteUueF6O0N4EUa/rQaDyfKfulxIdznD8uojBVfm+skeBEZfBBsYGMDVV1+tnoD6fD5VnDdu3IhqVexaLh0jMrs7cyPPbKH55NZm1PgNhtUSnBvY/HKUHN3dMrKqJxxVAXjJwvIybBZZyAacY4Xl6Z3mf36/U3XTa28y77zYJDQ/qaVxzDcZE6N1nmuhuXwf0cQwe/Zs9T27aNGiEdfL6ehy2qnU/Vy1TCObpP3rX/9S4/ek7ss4liuvvNLUI0rGi8/N85PZlZwtiE0PbkdtApplI9Bcm4HqbQiqhc72mjgam+Pwx52j9rVu9jjQDDdqmxJDnd8lom3imRmWa5t55uoq1xvBUuqwnKNYaKIpVy1P3wBU6/bOdxPQYh2fjXSZp9MNX022CaNosIfR4gigL+7W34Az4Va3y3GGVWJjTpN28BcTA/3RXn/9dTW7XJ47yzgW2W/oggsuUGd/auG3nAkjo1u0jnGZ2iHjW9auXavGJ8omoKtXr1bHy9me4uyzz1bZy0UXXYS3334bf/3rX3HTTTfhqquuymtcoiU6zMl8ofkT/2zL63T3pjov+mLT4IoF0YigKtwyhsXnSsIRCSBic+GQvQX19V5D4Ve5MSAnOe1Hdo2XQvz4448b+hgp4lL0f/e736lg5m9/+xu+//3vo7W1FV//+tdLvuaJruuzTthcPqB18qhu8lxzuQ13BxcxfJa6JvVQupozO+TyDcvf/efu0q73yGgZmfkONIx7A05tlIzRESdaaK4F1YenRFR4XeMpfP67HiP31x+J4jjpND/y9ZfQfKzvMSKqXtnGsugZazSL0U5zkb4ZqHSai8wRLSJ9TIvY0xpCPFgDf9gFmy8BmyOJ3mAS9rADSVcC8SkhzM/SWLL7sPHn69m6xzOlB+Tp68w1fkVkBuXjDcv1cBQLUXm6zPPpNB+v9LEshmmhuUkCXrUBp7sbvQmv2uBTZpbLGBbpLJfMxWePqdsNj0kxYRf9ROoynwijWYpJmhH/+Mc/qg1EBwcH1ThEaUSRcFsLtqPRqOoglw1BNffdd59qTJEOc+lElz2Jfv3rX6dulzNEZQb6mjVrVH5TW1uLVatW4fbbb89rfQzMqSCXfmFWKjQ3MsdcyOaaXf45qA+2wxXoU5tvyhiWw7Y6FZYP2PIbU1CIpjq3oe7y9Fm2d597bMnXReYnm08IOU3fqFdeeUUVZpkNKK644go88sgj6tVRBubF03mgQ41bkTBcNvesTds4Mu9ws0Qd2h0HuvFxaz2OnVoDtIx9/N6uQbUxpraRsoS1//df+/HJrn0oF3lhQYJ+CbC1cTLappxGN+BMD8vlfg4PRHTnzGfah37MnDYUJMnHyu+YJdPH9+TS73blHbrLx6SfPaWF/nKmAseyEFE+MmeZZ8oWmmvyCc3VIRkjWvSC8zlHeRCsTeKTD2OI9TshZ0H77YCzJQpPaxj7EBt3CJ5PQF5oUK7bVT6OsDzfueXsLica4vI3ApH+vGeZZwvNRa7gvFjd5ZrMWeY5w81yj2jJESRPdgax1HsAuyLNaoNPCcplDMs054AKy+V2Q0zyIsB4WCE0p2EnnniiajA0ckZoOtkzSMYhyls2sjfDX/7yF4wHA3MaV2iu+cXWjw19jITmHc46BJJ9cCKGGJzoCthSm2+agYTlDMmpGGSEy7PPPotLL71UdZVv3boVH3zwgXpFlIpLwkstwNTC82yyhp0lHmfy9ht7MXeqH0umRzEJbsNhuYwxee+DzuxheQnXLUG/zO3WLJGwIi00z7UBp15Y/uGu4Q3XhjrYR0t/7CQ0l4997eNw6uthdBRYJnlxN99OdTl2Tr28mDuY9fMTERUqvcs8m/RNQI2G5iKz2zxbcO5rTODYJUBkMIZE1IaD4aAa1yKlfA5G10u1YWgRw3GN3tlX6UF5+r9D+/dl7SovYlg+FoblROPvMs+l2KF4+safRowZmpskaJZQvMWxH70Jj9rgU2aWyxgWS3SWV9k8c3aZWwcDcyqKHy+bmwrNJbzQgoX0sSyZm2+mXlO2mesUR4bl1tfX1zfispzOk8+sqmLZsGGD6iqXGeZOp1OdNvTYY4/hi1/8YtnXUo3hud688mwhbTnWJOuRkSrSZS6hs8/tMG9YnhrLMqg2udxX71Fn5EjonN6pnW0DzswxLFpYLl//sTqzUy989AdUh7t2loDcRyZ5AcLoqBftzCEjoXn6Y6Nt0ipd7kY/FxFVr1xjWQrtMjcSmgttM1B1Xxnd5pljWjKDc0+dhFJJzMbw+rRNQvMJvvORbUSZkaB8rBEs6WG5FpQXEpZzFAtRaRjpMi+E3M94xrJkdpkbCjhLHZwbDJDVBpyOAmqWWcJyIpNhYE5FDc3TXf/nXSMuS9ginYLq/+vcqfCjrs5j6BT9Qsh9j4Xzya3B53GMGXLFjtw+c+bMEdfLTKzbbrtt1PHr1q3DXXfdlfM+33//fbXJRKGB+Wuvvaa6zOWUoJdfflltNCHd5suXLy/oPqmwrvOsyrBJZjoJgHcdDGB+c7/aeFILZoORuAqZZfRJeli+fcenauSMGdZuhGzQKXPXX/l4+EUreZFANmfN+u/Idl/9g/hk1/ALH+md5+ljd+T3iZHNmyXsllnkuUJzvRcxtNBcXiiYVNujfo/J4yhrG0E2iTXhY2LFeq7VcqJq7DIvNDRX1+foNs82pkVvVEuuQFsvRDdirP07coXkhoLyCoTl1d5dfrA9iX5b9q9BgJsAVyUJmzM30NQby1LK0LxiXcHpwXYxQuhybDJqxrCcXeZlZXPXqLfst8dRrRiYU0k7tTNDcyOkm7AcG39KwMKwfGLat28f6uvrU5ezdZdfd911anf4XObOHflCkFHBYBA33ngjtmzZgnPPPVddd9JJJ6kdoO+55x4G5pVkglBTNv+UcFkCWi0sl45szRsfdauO7IqG5Wld5hJ4ywuQ0qUtI0pkM0w9e/oGVVj+8cGh4EFeDP1o52f5j8CR8HlUx/nwfcjYHSEz66cf1YDDdfrd59lC8yaPG8d6/GMG5ekm+d04CY3AicPXjer8Z2hORGPQ6zLPNZplvKG5yDWmRW9UiyYzQBdGN64eS+bnMhKU59NVLhiWE1lvLIsZQnO9LvO8Q069wNdIOF2OkNzMYXkVheZkfgzMqaLjTb70wKsl/fz/+MGpJb1/MicJy9MD82wmT56s3kpBdnOWNxnDkk52bE7IrlpUORUKNaVDuvXIxp8SOkuHrWnD8gyZa8k2N/y1jw9jX3u/etFTwuxRI1iMrj3zuLQAXaTf50c7A1ln1uuF5pmMhOUaecwkbJ83tU6dJdVxgJt/ElF+Y1mMSO8yLzQ0F2N1m2v0us6zhdp6IXqh4Xjm5887KK9QWE5EhRury3w8oXm+41iyjWUpWmheyTCcTM9MXeakj4F5CclOrr29vQiHw6rDtaGhIbUZGg0H2qUKzbffuKwk90vVqa2tDd3d3ep9PB5XneJi/vz5qKurU/8vo1vWr1+Pb37zmyqwP/PMM/HjH/8YPp9PjWTZtm0bfvvb3+Lee++t8L+G8gvNk2jwJCG5aiQO9IaljudXy1taJ2PBsVPwlZOmYsn0htQMc5lZLmNY0sNy2Rw0awhb7rD8SJe5MDJS5cCBPrVRqCgoKM+1jnRH1qTXfT7iwwbCOGleS1HCciKyNukHjtTXIuF2wh6Jwd03mGclL2+XeWZoni5naC4Mdptr9LrO9QJ0I+G3UUZC8pxBeYnCciPYXU5UerlCc/kJHPQ0IGb3wJkIozbci5oCw/KqDTrN3F1eRV3mE+J7aQJjYF4iHR0d2LlzJzo7OxGLxdSGfy0tLSpQK1VHq1WxC5ys4JZbbsFvfvOb1OWTTz5ZvX/ppZewbNnQizO7du1SL5JpNm/ejBtuuAEXXnihCtslNL/zzjvxve99rwL/golN5lxndhmPucGk1rWcI8yd5EtgQXMck2qScNqBWALoCtjwYbcDXUF79vvMIGNDlsxrHhGWZxozLK+UjNBcvq7ZOrp1v+alCPm1+8zy9U5fq8gVmhPRxBdqrkfPghnqfcLpgD0Wh7e7D40ffqrem1W2eeY5Q3MD3ebqvtP+CtTrOs8WauuF6Lno3UepgvJ8wvJs2F1OVPw55pljWYx0mad3jKcH573eFuxvPg69vhYk7E7YEzFMih/G0f0foDE8+jmn3HehsnWZCwad1mH20JzMi4F5CTrDJSx//fXXEQgE1Me6XC41muGzzz5T93vKKacYCs3ZoW49fMwmrieffFK9jfX4p5s2bRo2bdpU4pWRhOXzjpuOmdP8I/YoeGd3Bw59tA9uewJ9/SH0RiSkthnuNpewfHFrHDXOJPoiQDQOuBzAtLok6r1x7DgA/dB8lKS6r0X1MdQhDK9rOGzuCUfVJp+GwvJKzsZOC80NbaaqfUw51qXRCc9lnTJDPd/QXH6WB/v7EI1G4HK5UeuvZy0nsmh3uITkhxYfg5jXC3f/IOzROBIuBwJTmhGpr8GUHR8YCs3L0aGea5a5kdBc6I1oyTc412QG6EYD8EIC8vQ1pcs2fiVXV7n2tZLHrA9u9B4Iwu30wh8LpR6zQkexsLu89B566CH84he/QHt7OxYuXIgNGzZg6dKlWY//wx/+gJtvvhl79+7FggULcNddd+GrX/3qiN/pt956Kx577DH09PTg9NNPx8MPP6yOpfJSP5N2PyI2F+AcgD/Wl/qZzBaapwfnPZ5J+Lh5CUJOH2qjfXDGo4jZXejyTcWgqx6f635DNzTPFBoIIVw/Wa3DnYyiPtGvO5bFSGguLBmcS+e2FbrMj5A/s3sTHoSTDnhscTTYw5goT8354ot5MTAvcme4/EKWj5ewXI7X/sCW8FQua/cv95nrj292qFsPHzOiyoTlC5fMVt3bx03xpa6PDvRgbqgPh9wRBINhhKPAZ70xvHfIga6wy0C3eVJ1lktY3hmUy0P1WkaydAaTaPEN3d61P/d4lkmeKBbNtGORsw39H7Xj320uNE9qway5C+Cpa1Kbf350cEDNLM/JDBtJGujqNkuoP57QvKe7E20ff4i+w12Ix2NwOJyob5qkHrPG5ha14d3hKfK4uVWnvenOCCCaYMbTHS7hjHyshOXert5UtXZEYupyaFIDeuYfhanbh0ObYq8hn7Es+c4zzwzNxxrRkjmmJTOkTg/PswXbeiF6vsF4XiF5gV3lXfDiA1sTDg06EGuyw5lMoCkyiLmDHXDuaR919wzLzeHpp5/G2rVrsXHjRtVkdv/992PFihXqLM4pU4a/jzWvvPIKLrjgAjUS8bzzzsNTTz2FlStX4s0338QJJ5ygjrn77rvxwAMPqDNF58yZo8J1uc///Oc/8Hq9FfhXVqcuRxN2u+eg29GImM0Jpy+G+mAH5gY+QnO0e8zQXH76PvEfo8LyxnBnqma7ExG4wp3o8bSo2xvCr+as592uZnxcMw99vslD60jG0BzvwfzIHkxFYftMMfAsobpmdPQEsSvSjM54DWJJO5y2BFocARzr7sZkp/pDbUzsMqdCMDAvcme4HCeBqV5nsVyWucZyuxzX2NhY0g51Kh8+ZkTlV1NXkwrLT53ZoIJM0d/Thb3tuzEpEcLkGS2I2uwIhsOY2dOHRl8Q/+8T6Ifmad3mMrNcxrBIZ/noQNyGvsjQ7XLc0Ezz0UGyhOWnHx3H7KkuTGuqR5O/BslkHN2dBxEY6MOc409G12AM733QOfb4GDPRmyduhkDfYGi+bOH0nGH5znd2IBQKoqbOD6fThVgsmnrMjjtpMSY1t+AkNOKVWvOOcSCaKMbbHS4d4XIf8rGjKzng7g+o0FyO8/QNFnUNhW78qddlPq7QPMts89TXwWB4nk8IXkhInrkuI13lucLyN2xTMRAA6uJBOJNxxGwOdHjq0R124LiaQTQGCptfTqUl+/xcfvnlWL16tboswfmf//xnPPHEE1i3bt2o43/1q1/hnHPOUXsGiZ/+9Kd44YUX8OCDD6qPlWY2Cd1vuukmfOMb31DHyH5CU6dOxTPPPIPvfve7Zf4XVqcuWz3e8h+LQMyOuuQAXIkYojYnOl1TMeCvx0n9/xozNB9wNaDXM0l1luvVc7lebpfj/NFe3XEsEpa/4z8ZIbsP9clAah2HHC3o99bh5MC7mFqTyKvL3NLd5hboMu+IurE91IRgwol6RwQuxBGFA+2xOvQmvFjqPcDQnErGyLnkVSGzM1w6wu12e6ozXK6X2zNHLmSSURzSXSyBqR63261ul+NKuQ4qHz5mRJUx55hpmDvVrzrLJSyf5Hejuc6FUOcncCQjaJ0+BS0NdZheX4O5k5tw3MyjcEyrDwtnyq++HD+PdZPUBp8ys1zGsOiR6+X21CjyUSFtEp+fEsfkBgemTmlBc20tbHY73G4PGpomqUB2/ye70TEQwWB/yLyjWIww2/pkPQWsSWq0dJbLYyOPkTxW9ozHbN/HH6rj5Hvt2Kk1qPWzM42oVDK7w6Ur3JZMprrD5XrpDs/17ErGp6iO8CzF3B6NIel0qONKtYZcsnU1G9mMMn0+t95IEgmWM8PlzPBZHdezXzeollBb7y0fRu5D+/y6c8ozusozR7DoheXyWEhnuYTlTdEBuJNx9QevvK/p6kbI5ca+lukjHjN2l5tDJBLBjh07sHz58tR18ntYLr/66qu6HyPXpx8vpHtcO37Pnj1qtEv6MdLcJM1M2e6Tikv9TNpnImjzoDlxGJ5kFHYk1fsWe68Kr6XjOznG3PGo3Y243QlnIqr7eeR6uV2Oy7YO+Tzy+ZpiXSPWIesK2ryqAz7bT3r6TPZcLBfIjnNTzVKS+GTXoF+F5S2OoBrFYrdBvZfLcr10nucTs5j1BQ3Lfd9UiarqMNcCy76+0V0gMs+sra0NPp9PBZyZHA6Hun3fvn1ZO8OFBOHyy17uTwLTTKFQSN0ux5VyHVQ+fMyM0b7fC33hoF/n56WQY8j6tO+heDiASGAAwQEbEvUu9PeHMNjXh/3798Hr9SF45Ocxmhg6PhZPwOt2YlZ9ADOn+NG2P3sgEXJ7EYz1y19qiIWGNyXSuBxJBENS051IelqA6MjOhnp3DHXJIOCYDK90r0QCSMbtSG1ZZHPg4P59iPgcSMhtGR8/Qmz05ycDMr6myYgN8dAg2g8dRqDJjgFPErG0zVfle0ceE5fPh2BwdC2Xx6x9/z5Mnj4TtfX1CA32Ix4eHP3YVcHjlTzybyxVPWctrw7a908gqX8KfNhfix6/F47uHoRio5PaeHcveup9avM4T5YXHcOhMCLBIOJIwKF3Hy4X4sEgQqGwOgOo2GsYSIzdYe6J6Yf5tsjIz9f/QRd8R9ePPGhnJ1xHp/3xv6sd9hkZ3YK798M2Le1F3YG2offNGWc+9u8e/twNrSiGbD/Jyd4D+jd0j95QNNk++gXQxKcjA57oJ8NBg8ws3xuIwxvvRTDtMQ33HwnZ4n1od3kw2elGbSiIrgPGNvkMTMDGF+1nr9Banu1nN/P2zL955W9kvb+T5SzseDyuur/TyWVpPtIjYbje8XK9drt2XbZjqIg5Szitnrn9iPb3oA+1+NTphTfZixDsSERG/sw5bX3Yn/BjeqIO9fLcO/XxbgQGh48NI6TqeV9CxrCMrscRuwuRRBDhcAj90SRqaj3ojwx/b/c5/erz+ALdCCZjsGd839ttPfjUVov9cS/qkaWRpaMLLr+Bv+dD3bDXZtRrMwseAuqaYDY9MRfa+gFfYgABnd+VjkQcbWEnZiXtaLQPbww7lkQoS0dUhdkdeb4qfURfKDauWt7X3z+u2yeyqgrM+4880DNnzqz0UoiqlvwcSmeHUXJWhmyeefz8ow0dL8fKx9DEpdXyt+/+X3gbwP8uweeQP9mfHefH/7GI66Hxkz+5DgN4s0TfM9WolPWctbx6avllwT36B8jrVn96Z3yfZLz3Md6P/7hIxxCZsJZf1p7lZzdNXV3dqL+9ZQPO2267raC1krnr+ZyfyzNzPe8W4bN05vnsPDNAlTU+U4R1EE2sWj7zuCVjHjutSp+XV1Vg3traqrp8/X5/zg038yWvmssTAblvmVFuBVxzeXDNw+QVTyni8nOYD9mMR06nlDMzjJBCzg18JjbW8mFcc3lwzeWv56zlE1+parngz2x5WG3NVlvvRKjl8jkyf771ustFS0uLOjP34MGDI66XyxLW6JHrcx2vvZfrpk8f3sNELi9atGjM9ZMxfG4+jGsuD655GJ+Xl05VBeYyA23GjBklu3/5prfKD6uGay4PrnlIPq94ppPiXI0FmvSxlo/GNZcH1zyM9ZzMXssFf2bLw2prttp6q6WWSyCzePFivPjii1i5cqW6LpFIqMtXX3217seceuqp6vZrr702dZ1s+inXizlz5qjQXI7RAnIJrV5//XWsWbOmqOuvZnxuPhrXXB5cs/lq+URSVYE5EREREREREZnP2rVrsWrVKixZsgRLly7F/fffj8HBQaxevVrdfvHFF+Ooo47C+vXr1eUf/vCHOPPMM/HLX/4S5557LjZv3ow33ngDjz76qLpdup0lTL/jjjuwYMECFaDffPPNqhNTC+WJiIj0MDAnIiIiIiIiooo6//zz0dHRgVtuuUVtyild4c8//3xq0862tjbVzaw57bTT8NRTT+Gmm27CjTfeqELxZ555BieccELqmOuvv16F7ldccQV6enpwxhlnqPtkVyUREeXCwLwIZA6bbF6SbR6bGXHN5cE1E1mHFb/3ueby4JqJrMWK3/9cc+lZbb1WXfN4yfiVbCNYtm7dOuq673znO+otG+kyv/3229UbWYsVv/+55vLgmqkcbEmZEE9EREREREREREREVOWGz2ciIiIiIiIiIiIiIqpiDMyJiIiIiIiIiIiIiBiYExERERERERERERENYWBeZHv37sVll12GOXPmwOfzYd68eWqwfyQSgVndeeedaofxmpoaNDY2wqweeughzJ49W+1ofsopp2D79u0wq5dffhlf+9rX0Nraqjaakd3azW79+vX4whe+AL/fjylTpmDlypXYtWtXpZdFVBFWrOVWqees5aXFWk40jLW8dKxUy61Yz1nLiYaxlpcOa3lpsZZbGwPzItu5cycSiQQeeeQRvPfee7jvvvuwceNG3HjjjTAr+UUjO4uvWbMGZvX0009j7dq16hfjm2++iYULF2LFihU4dOgQzGhwcFCtUX4BWcW2bdtw1VVX4bXXXsMLL7yAaDSKs88+W/1biKqNFWu5Feo5a3npsZYTDWMtLw2r1XIr1nPWcqJhrOWlwVpeeqzlFpekkrv77ruTc+bMSZrdpk2bkg0NDUkzWrp0afKqq65KXY7H48nW1tbk+vXrk2YnP2ZbtmxJWs2hQ4fU2rdt21bppRCZglVquZnrOWt5+bGWE43EWl7dtdyq9Zy1nGgk1vLxYy0vP9Zya2GHeRn09vaiubm50suwLHlldseOHVi+fHnqOrvdri6/+uqrFV3bRP++FfzeJRrCWj4+rOWVwVpONBJr+fiwllcGaznRSKzl48NaXhms5dbCwLzEdu/ejQ0bNuDKK6+s9FIsq7OzE/F4HFOnTh1xvVxub2+v2LomMjnl7dprr8Xpp5+OE044odLLIao41vLxYy0vP9ZyopFYy8ePtbz8WMuJRmItHz/W8vJjLbceBuYGrVu3Tm0qkOtNZmul279/P8455xw1t+ryyy83/XqJNDJn69///jc2b95c6aUQVXUtL3TNRIK1nCYq1nKqJqzlNFGxllM1YS23HmelF2AV1113HS655JKcx8ydOzf1/wcOHMBZZ52ldkV+9NFHYfb1mllLSwscDgcOHjw44nq5PG3atIqta6K6+uqr8dxzz6kdqGfMmFHp5RBVdS2fSPWctby8WMtpImMtrxzW8vJiLaeJjLW8cljLy4u13JoYmBs0efJk9WaEvOophXzx4sXYtGmTmgVl5vWandvtVl/LF198EStXrkydziKXpfBQcci+Gddccw22bNmCrVu3Ys6cOZVeEhGqvZZPpHrOWl4erOVUDVjLK4e1vDxYy6kasJZXDmt5ebCWWxsD8yKTQr5s2TIcffTRuOeee9DR0ZG6zayv1LW1taG7u1u9lzlWb731lrp+/vz5qKurgxmsXbsWq1atwpIlS7B06VLcf//9GBwcxOrVq2FGAwMDaraaZs+ePerrKps7zJo1C2Y9Reipp57Cn/70J/j9/tTssoaGBvh8vkovj6isrFjLrVDPWctLj7WcaBhreWlYrZZbsZ6zlhMNYy0vDdby0mMtt7gkFdWmTZuS8mXVezOrVatW6a73pZdeSprJhg0bkrNmzUq63e7k0qVLk6+99lrSrORrp/c1la+1WWX7vpXvaaJqY8VabpV6zlpeWqzlRMNYy0vHSrXcivWctZxoGGt56bCWlxZrubXZ5D+VDu2JiIiIiIiIiIiIiCqtMoOfiIiIiIiIiIiIiIhMhoE5EREREREREREREREDcyIiIiIiIiIiIiKiIQzMiYiIiIiIiIiIiIgYmBMRERERERERERERDWFgTkRERERERERERETEwJyIiIiIiIiIiIiIaAgDcyIiIiIiIiIiIiIiBuZEREREREREREREREMYmJNpxONxnHbaafjWt7414vre3l7MnDkTP/nJT9TlH/zgB1i8eDE8Hg8WLVpUodUSEVE2rOdERNbHWk5EZH2s5USFYWBOpuFwOPDkk0/i+eefx+9///vU9ddccw2am5tx6623pq679NJLcf7551dopURElAvrORGR9bGWExFZH2s5UWGcBX4cUUkcc8wx+PnPf66K95e+9CVs374dmzdvxj//+U+43W51zAMPPKDed3R04J133qnwiomISA/rORGR9bGWExFZH2s5Uf4YmJPpSBHfsmULLrroIrz77ru45ZZbsHDhwkovi4iI8sR6TkRkfazlRETWx1pOlB8G5mQ6NpsNDz/8MI4//niceOKJWLduXaWXREREBWA9JyKyPtZyIiLrYy0nyg9nmJMpPfHEE6ipqcGePXvw6aefVno5RERUINZzIiLrYy0nIrI+1nIi4xiYk+m88soruO+++/Dcc89h6dKluOyyy5BMJiu9LCIiyhPrORGR9bGWExFZH2s5UX4YmJOpBAIBXHLJJVizZg3OOussPP7442pDio0bN1Z6aURElAfWcyIi62MtJyKyPtZyovwxMCdTueGGG9SrnLKDs5g9ezbuueceXH/99di7d6+6bvfu3XjrrbfQ3t6OYDCo/l/eIpFIhVdPREQa1nMiIutjLScisj7WcqL82ZI8B4NMYtu2bfjyl7+MrVu34owzzhhx24oVKxCLxfD3v/9dvSIqx2aSOVxS+ImIqLJYz4mIrI+1nIjI+ljLiQrDwJyIiIiIiIiIiIiIiCNZiIiIiIiIiIiIiIiGMDAnIiIiIiIiIiIiImJgTkREREREREREREQ0hIE5EREREREREREREREDcyIiIiIiIiIiIiKiIQzMiYiIiIiIiIiIiIgYmBMRERERERERERERDWFgTkRERERERERERETEwJyIiIiIiIiIiIiIaAgDcyIiIiIiIiIiIiIiBuZEREREREREREREREMYmBMRERERERERERERCPj/V87SajAL2O4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "INIT_DATA_SIZE = 2*(townsend.dim + 1)\n", + "N_BATCH = 50\n", + "VERBOSE = True\n", + "\n", + "# generate initial training data\n", + "train_x, train_obj, train_con = generate_initial_data(n=INIT_DATA_SIZE)\n", + "\n", + "# add random baseline\n", + "train_x_rand, train_obj_rand, train_con_rand = (train_x, train_obj, train_con)\n", + "\n", + "# initialize the model\n", + "model = initialize_model(train_x, train_obj, train_con)\n", + "\n", + "# store a list of regrets at each step\n", + "optimal = torch.tensor(townsend._optimal_value, **tkwargs)\n", + "\n", + "regrets_model = []\n", + "regrets_rand = []\n", + "\n", + "for _ in range(N_BATCH+1): \n", + " # log the regrets\n", + " best_f_model = np.ma.masked_array(train_obj, mask=~train_con.bool()).max().item() \n", + " regrets_model.append(optimal-best_f_model)\n", + "\n", + " best_f_rand = np.ma.masked_array(train_obj_rand, mask=~train_con_rand.bool()).max().item()\n", + " regrets_rand.append(optimal-best_f_rand)\n", + "\n", + " # optimize the acquisition function and get new observation\n", + " new_x, new_obj, new_con,acqf = optimize_acqf_and_get_observation(model, train_obj, train_con)\n", + "\n", + " # print the current model and random regret and iteration, plot the acquisition function every 10 iterations .2f\n", + " if VERBOSE:\n", + " print(f\"Iteration {_}: log Regret (CEI, Sobel) = ({torch.log(regrets_model[-1]):.2f}, {torch.log(regrets_rand[-1]):.2f})\")\n", + " print(\"\\n\")\n", + " if _ % 10 == 0:\n", + " fig, axes = plt.subplots(1, 4, figsize=(15, 3))\n", + " plot_helper(model, train_x, new_x, acqf,axes)\n", + " plt.show()\n", + " #clear the axes\n", + " plt.pause(0.1)\n", + " plt.close(fig)\n", + "\n", + " # include the new observation in the training data\n", + " train_x = torch.cat([train_x, new_x])\n", + " train_obj = torch.cat([train_obj, new_obj.unsqueeze(-1)])\n", + " train_con = torch.cat([train_con, new_con])\n", + " # update the model\n", + " model = initialize_model(train_x, train_obj, train_con)\n", + "\n", + " # execute the random baseline\n", + " new_x_rand, new_obj_rand, new_con_rand = generate_initial_data(n=BATCH_SIZE)\n", + " train_x_rand = torch.cat([train_x_rand, new_x_rand])\n", + " train_obj_rand = torch.cat([train_obj_rand, new_obj_rand])\n", + " train_con_rand = torch.cat([train_con_rand, new_con_rand]) " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot the regret\n", + "plt.plot(regrets_model, label='CEI')\n", + "plt.plot(regrets_rand, label='Sobol')\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Number of Iterations\")\n", + "plt.ylabel(\"Regret\")\n", + "plt.title(\"Regret of CEI and Sobol\")\n", + "plt.legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "botorch", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 245013725c4b481dbd701943adaba3ad27fa8d22 Mon Sep 17 00:00:00 2001 From: Fanjin Wang <67814101+FrankWanger@users.noreply.github.com> Date: Mon, 27 Jan 2025 17:10:28 +0000 Subject: [PATCH 2/8] Update notebooks_community/clf_constrained_bo.ipynb Co-authored-by: Max Balandat --- notebooks_community/clf_constrained_bo.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index 254083854e..d937043d67 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -11,7 +11,7 @@ "\n", "In this notebook, we show how to implement BO under unknown constraints learned from a classification model trained together with a GP.\n", "\n", - "To add some context, the recommendations presented by BO to assist laboratory experiments may lead to undesired experiment results, such as failures or infeasible protocols [1]. And in these cases, the underlying feasible region can only be obtained through experimentation. In such cases, these unknown constraints can be treated as an unknown variable modelled by a surrogate classification model. \n", + "To add some context, the recommendations presented by BO to assist laboratory experiments may lead to undesired experiment results, such as failures or infeasible protocols [1]. And in these cases, the underlying feasible region can only be obtained through experimentation. In such cases, these unknown constraints can be treated as an unknown variable modeled by a surrogate classification model. Note that this setting, in which we only obtain binary information about whether or not a proposed candidate is feasible or not, is different from the setting in which we observe numerical values of an outcome that is subject to some constraint.\n", "\n", "The present code is also inspired by the implementation in [2].\n", "\n", From 7a7fb6ff3fd3e3b2b95e5207ddfcdb3e69b2729b Mon Sep 17 00:00:00 2001 From: Fanjin Wang <67814101+FrankWanger@users.noreply.github.com> Date: Mon, 27 Jan 2025 20:07:12 +0000 Subject: [PATCH 3/8] formatting Co-authored-by: Max Balandat --- notebooks_community/clf_constrained_bo.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index d937043d67..bd046fcf4a 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -188,6 +188,7 @@ ], "source": [ "from botorch.utils.sampling import draw_sobol_samples\n", + "\n", "def generate_initial_data(n):\n", " # generate training data within the problem bounds\n", " train_x = draw_sobol_samples(bounds=townsend.bounds, n=n, q=1).squeeze(1)\n", From bdebdc7e3d15327d888341b9cce756502a68ba9c Mon Sep 17 00:00:00 2001 From: Fanjin Wang <67814101+FrankWanger@users.noreply.github.com> Date: Mon, 27 Jan 2025 20:07:34 +0000 Subject: [PATCH 4/8] typo fix Co-authored-by: Max Balandat --- notebooks_community/clf_constrained_bo.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index bd046fcf4a..9e9ffaa446 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -443,7 +443,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 0: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", + "Iteration 0: log Regret (CEI, Sobol) = (-1.27, -1.27)\n", "\n", "\n" ] From 1dd456b2103239dc261e6299c116c6d2925819c1 Mon Sep 17 00:00:00 2001 From: Fanjin Wang <67814101+FrankWanger@users.noreply.github.com> Date: Mon, 27 Jan 2025 20:07:55 +0000 Subject: [PATCH 5/8] typo fix Co-authored-by: Max Balandat --- notebooks_community/clf_constrained_bo.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index 9e9ffaa446..3444e8fde0 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -431,7 +431,7 @@ "metadata": {}, "source": [ "### Perform BO loop\n", - "We initialize the BO loop with 10 random points from SOBEL sequence. We then perform 50 iterations of BO. The acquisition function value, the underlying constraint probability, and the expected improvement value are plotted at every 10 iterations." + "We initialize the BO loop with 10 random points from SOBOL sequence. We then perform 50 iterations of BO. The acquisition function value, the underlying constraint probability, and the expected improvement value are plotted at every 10 iterations." ] }, { From e5d7fd38657a1b4b46961553310cba711faa4ac3 Mon Sep 17 00:00:00 2001 From: Fanjin Wang <67814101+FrankWanger@users.noreply.github.com> Date: Mon, 27 Jan 2025 20:09:54 +0000 Subject: [PATCH 6/8] formatting Co-authored-by: Max Balandat --- notebooks_community/clf_constrained_bo.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index 3444e8fde0..01eec66244 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -310,8 +310,7 @@ "NUM_RESTARTS = 10 \n", "RAW_SAMPLES = 512\n", "\n", - "def optimize_acqf_and_get_observation(model, train_obj, train_con, \n", - "):\n", + "def optimize_acqf_and_get_observation(model, train_obj, train_con):\n", " \"\"\"\n", " Optimizes the acquisition function, and returns a new candidate and observation.\n", " \"\"\"\n", From 52ddfa4cf0a64ab7adb38c64be27ebcb183587b0 Mon Sep 17 00:00:00 2001 From: Fanjin Date: Mon, 27 Jan 2025 21:03:08 +0000 Subject: [PATCH 7/8] improved annotations and outputs --- notebooks_community/clf_constrained_bo.ipynb | 337 +++++++------------ 1 file changed, 113 insertions(+), 224 deletions(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index 01eec66244..2f44cdb0bb 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -61,14 +61,23 @@ "\\end{align*}\n", "$$\n", "\n", - "Subjected to the constraint:\n", + "Subjected to the constraint $c$:\n", "$$\n", - "y_{\\text{con}} = \\left(\\left(2 \\cos(t) - 0.5 \\cos(2t) - 0.25 \\cos(3t) - 0.125 \\cos(4t)\\right)^2 + \\left(2 \\sin(t)\\right)^2 - x_1^2 - x_2^2\\right)>0\n", + "c = \\left(2 \\cos(t) - 0.5 \\cos(2t) - 0.25 \\cos(3t) - 0.125 \\cos(4t)\\right)^2 + \\left(2 \\sin(t)\\right)^2 - x_1^2 - x_2^2 )\n", "$$ \n", "where $t = \\arctan\\left(\\frac{x_1}{x_2}\\right)$\n", "\n", + "And the binary feasibility $y_{\\text{con}}$ is defined by:\n", + "$$\n", + "y_{\\text{con}} = \\begin{cases}\n", + "1 & c > 0\\\\\n", + "0 & \\text{otherwise}\n", + "\\end{cases}\n", + "$$\n", + "\n", "Here, we follow a natural representation where $y_{\\text{con}}=1$ indicates a feasible condition. We will train a classification model to predict the feasibility of the point. Note that in BoTorch's implementation, **negative values** indicate feasibility, thus we need to do conversion later when feeding feasibility into the pipeline.\n", "\n", + "Note that we essentially 'throw away' information contained in the value of $c$ by applying a binary mask to generate $y_{\\text{con}}$ - this is for illustration purposes as part of this tutorial, in many real-world applications the latent value $c$ is not directly observable and only binary information (experiment success or failure) is available.\n", "\n", "[3]: Townsend, A. (2014). Constrained optimization in Chebfun. https://www.chebfun.org/examples/opt/ConstrainedOptimization.html" ] @@ -91,11 +100,12 @@ " def __call__(self, x):\n", " return self.objective(x)\n", "\n", - " def constraint(self, x):\n", + " def is_feasible(self, x):\n", " x1, x2 = x[..., 0], x[..., 1]\n", " t = torch.atan2(x1, x2) \n", - " constraint_value = (((2 * torch.cos(t) - 0.5 * torch.cos(2 * t) - 0.25 * torch.cos(3 * t) - 0.125 * torch.cos(4 * t)) ** 2 + (2 * torch.sin(t)) ** 2 - x1 ** 2 - x2 ** 2) > 0).float()\n", - " return constraint_value\n", + " c = ((2 * torch.cos(t) - 0.5 * torch.cos(2 * t) - 0.25 * torch.cos(3 * t) - 0.125 * torch.cos(4 * t)) ** 2 + (2 * torch.sin(t)) ** 2 - x1 ** 2 - x2 ** 2)\n", + " y_con = (c > 0).float() #binarize the feasibility\n", + " return y_con\n", " \n", " def objective(self,x):\n", " x1, x2 = x[..., 0], x[..., 1]\n", @@ -138,7 +148,7 @@ " X, Y = np.meshgrid(x, y)\n", "\n", " obj = townsend(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", - " con = townsend.constraint(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", + " con = townsend.is_feasible(torch.tensor(np.stack([X, Y], axis=-1), **tkwargs)).cpu().numpy()\n", "\n", " #mask out the constraint region<0\n", " obj[con==0] = np.nan\n", @@ -175,13 +185,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[KeOps] Warning : \n", - " The default C++ compiler could not be found on your system.\n", - " You need to either define the CXX environment variable or a symlink to the g++ command.\n", - " For example if g++-8 is the command you can do\n", - " import os\n", - " os.environ['CXX'] = 'g++-8'\n", - " \n", + "[KeOps] Warning : omp.h header is not in the path, disabling OpenMP. To fix this, you can set the environment\n", + " variable OMP_PATH to the location of the header before importing keopscore or pykeops,\n", + " e.g. using os.environ: import os; os.environ['OMP_PATH'] = '/path/to/omp/header'\n", "[KeOps] Warning : Cuda libraries were not detected on the system or could not be loaded ; using cpu only mode\n" ] } @@ -193,7 +199,7 @@ " # generate training data within the problem bounds\n", " train_x = draw_sobol_samples(bounds=townsend.bounds, n=n, q=1).squeeze(1)\n", " train_obj = townsend(train_x).unsqueeze(-1)\n", - " train_con = townsend.constraint(train_x)\n", + " train_con = townsend.is_feasible(train_x)\n", " return train_x, train_obj, train_con" ] }, @@ -339,7 +345,7 @@ " # observe new values\n", " new_x = unnormalize(candidates.detach(), townsend.bounds)\n", " new_obj = townsend(new_x)\n", - " new_con = townsend.constraint(new_x)\n", + " new_con = townsend.is_feasible(new_x)\n", "\n", " return new_x, new_obj, new_con, acqf\n", "\n", @@ -442,14 +448,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 0: log Regret (CEI, Sobol) = (-1.27, -1.27)\n", - "\n", - "\n" + "Iteration 0: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -0.91\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -461,41 +467,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 1: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", - "\n", - "\n", - "Iteration 2: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", - "\n", - "\n", - "Iteration 3: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", - "\n", - "\n", - "Iteration 4: log Regret (CEI, Sobel) = (-1.27, -1.27)\n", - "\n", - "\n", - "Iteration 5: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 6: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 7: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 8: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 9: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 10: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n" + "Iteration 1: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -0.91\n", + "Iteration 2: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 3: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 4: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n", + "Iteration 5: \n", + " log Regret CEI = -0.91 \n", + " log Regret Sobol = -1.17\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -507,41 +498,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 11: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 12: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 13: log Regret (CEI, Sobel) = (-2.15, -1.27)\n", - "\n", - "\n", - "Iteration 14: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 15: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 16: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 17: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 18: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 19: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 20: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n" + "Iteration 6: \n", + " log Regret CEI = -1.86 \n", + " log Regret Sobol = -1.17\n", + "Iteration 7: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 8: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 9: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 10: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -553,55 +529,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 21: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 22: log Regret (CEI, Sobel) = (-5.23, -1.27)\n", - "\n", - "\n", - "Iteration 23: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 24: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 25: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 26: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 27: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 28: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", - " warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 29: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 30: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n" + "Iteration 11: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 12: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 13: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 14: \n", + " log Regret CEI = -3.15 \n", + " log Regret Sobol = -1.17\n", + "Iteration 15: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -613,55 +560,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 31: log Regret (CEI, Sobel) = (-5.23, -2.38)\n", - "\n", - "\n", - "Iteration 32: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 33: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", - " warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 34: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 35: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 36: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 37: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 38: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 39: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 40: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n" + "Iteration 16: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 17: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 18: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -1.17\n", + "Iteration 19: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n", + "Iteration 20: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -673,55 +591,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 41: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 42: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\fj\\OneDrive - University College London\\UCL-PhD\\0_Projects\\botorch\\botorch\\botorch\\optim\\fit.py:104: OptimizationWarning: `scipy_minimize` terminated with status 3, displaying original message from `scipy.optimize.minimize`: ABNORMAL_TERMINATION_IN_LNSRCH\n", - " warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 43: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 44: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 45: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 46: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 47: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 48: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 49: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n", - "Iteration 50: log Regret (CEI, Sobel) = (-5.23, -2.67)\n", - "\n", - "\n" + "Iteration 21: \n", + " log Regret CEI = -4.64 \n", + " log Regret Sobol = -2.02\n", + "Iteration 22: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 23: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 24: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n", + "Iteration 25: \n", + " log Regret CEI = -7.49 \n", + " log Regret Sobol = -2.02\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -732,7 +621,7 @@ ], "source": [ "INIT_DATA_SIZE = 2*(townsend.dim + 1)\n", - "N_BATCH = 50\n", + "N_BATCH = 25\n", "VERBOSE = True\n", "\n", "# generate initial training data\n", @@ -751,7 +640,7 @@ "regrets_rand = []\n", "\n", "for _ in range(N_BATCH+1): \n", - " # log the regrets\n", + " # append the regrets\n", " best_f_model = np.ma.masked_array(train_obj, mask=~train_con.bool()).max().item() \n", " regrets_model.append(optimal-best_f_model)\n", "\n", @@ -761,11 +650,11 @@ " # optimize the acquisition function and get new observation\n", " new_x, new_obj, new_con,acqf = optimize_acqf_and_get_observation(model, train_obj, train_con)\n", "\n", - " # print the current model and random regret and iteration, plot the acquisition function every 10 iterations .2f\n", + " # print the current model and random regret and iteration, plot the acquisition function every 5 iterations\n", " if VERBOSE:\n", - " print(f\"Iteration {_}: log Regret (CEI, Sobel) = ({torch.log(regrets_model[-1]):.2f}, {torch.log(regrets_rand[-1]):.2f})\")\n", - " print(\"\\n\")\n", - " if _ % 10 == 0:\n", + " print(f\"Iteration {_}: \\n log Regret CEI = {torch.log(regrets_model[-1]):.2f} \\n log Regret Sobol = {torch.log(regrets_rand[-1]):.2f}\")\n", + " \n", + " if _ % 5 == 0:\n", " fig, axes = plt.subplots(1, 4, figsize=(15, 3))\n", " plot_helper(model, train_x, new_x, acqf,axes)\n", " plt.show()\n", @@ -794,7 +683,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -832,7 +721,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.10.16" } }, "nbformat": 4, From df41f120bc5c320d9f3982379f09d92b81db8fba Mon Sep 17 00:00:00 2001 From: Max Balandat Date: Mon, 27 Jan 2025 20:45:02 -0800 Subject: [PATCH 8/8] Remove Keops logs --- notebooks_community/clf_constrained_bo.ipynb | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/notebooks_community/clf_constrained_bo.ipynb b/notebooks_community/clf_constrained_bo.ipynb index 2f44cdb0bb..cf33acd6b6 100644 --- a/notebooks_community/clf_constrained_bo.ipynb +++ b/notebooks_community/clf_constrained_bo.ipynb @@ -180,18 +180,7 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[KeOps] Warning : omp.h header is not in the path, disabling OpenMP. To fix this, you can set the environment\n", - " variable OMP_PATH to the location of the header before importing keopscore or pykeops,\n", - " e.g. using os.environ: import os; os.environ['OMP_PATH'] = '/path/to/omp/header'\n", - "[KeOps] Warning : Cuda libraries were not detected on the system or could not be loaded ; using cpu only mode\n" - ] - } - ], + "outputs": [], "source": [ "from botorch.utils.sampling import draw_sobol_samples\n", "\n",