From 803d5421c3f806da8c4796a1fab6b59660cba6c5 Mon Sep 17 00:00:00 2001 From: pmrobbe Date: Sat, 20 Jan 2024 14:41:43 -0800 Subject: [PATCH 1/4] Added first version of parallel partial emulation --- gpytorch/kernels/__init__.py | 2 + gpytorch/kernels/parallel_partial_kernel.py | 62 +++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 gpytorch/kernels/parallel_partial_kernel.py diff --git a/gpytorch/kernels/__init__.py b/gpytorch/kernels/__init__.py index cc85fe624..7aee8cba3 100644 --- a/gpytorch/kernels/__init__.py +++ b/gpytorch/kernels/__init__.py @@ -18,6 +18,7 @@ from .multi_device_kernel import MultiDeviceKernel from .multitask_kernel import MultitaskKernel from .newton_girard_additive_kernel import NewtonGirardAdditiveKernel +from .parallel_partial_kernel import ParallelPartialKernel from .periodic_kernel import PeriodicKernel from .piecewise_polynomial_kernel import PiecewisePolynomialKernel from .polynomial_kernel import PolynomialKernel @@ -53,6 +54,7 @@ "MaternKernel", "MultitaskKernel", "NewtonGirardAdditiveKernel", + "ParallelPartialKernel", "PeriodicKernel", "PiecewisePolynomialKernel", "PolynomialKernel", diff --git a/gpytorch/kernels/parallel_partial_kernel.py b/gpytorch/kernels/parallel_partial_kernel.py new file mode 100644 index 000000000..1fd5d85d7 --- /dev/null +++ b/gpytorch/kernels/parallel_partial_kernel.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 + +from linear_operator import to_linear_operator +from linear_operator.operators import BlockInterleavedLinearOperator + +from .kernel import Kernel + + +class ParallelPartialKernel(Kernel): + r""" + A special :class:`gpytorch.kernels.MultitaskKernel` where tasks are assumed + to be independent, and a single, common kernel is used for all tasks. + + Given a base covariance module to be used for the data, :math:`K_{XX}`, + this kernel returns :math:`K = I_T \otimes K_{XX}`, where :math:`T` is the + number of tasks. + + .. note:: + + Note that, in this construction, it is crucial that all coordinates (or + tasks) share the same kernel, with the same kernel parameters. The + simplification of the inter-task kernel leads to computational + savings if the number of tasks is large. If this were not the case + (for example, when using the batch-independent Gaussian Process + construction), then each task would have a different design correlation + matrix, requiring the inversion of an `n x n` matrix at each + coordinate, where `n` is the number of data points. Furthermore, when + training the Gaussian Process surrogate, there is only one set of + kernel parameters to be estimated, instead of one for every coordinate. + + :param ~gpytorch.kernels.Kernel covar_module: Kernel to use as the data kernel. + :param int num_tasks: Number of tasks. + :param dict kwargs: Additional arguments to pass to the kernel. + + Example: + """ + + def __init__( + self, + covar_module: Kernel, + num_tasks: int, + **kwargs, + ): + super(ParallelPartialKernel, self).__init__(**kwargs) + self.covar_module = covar_module + self.num_tasks = num_tasks + + def forward(self, x1, x2, diag=False, last_dim_is_batch=False, **params): + if last_dim_is_batch: + raise RuntimeError("ParallelPartialKernel does not accept the last_dim_is_batch argument.") + covar_x = to_linear_operator(self.covar_module.forward(x1, x2, **params)) + res = BlockInterleavedLinearOperator(covar_x.repeat(self.num_tasks, 1, 1)) + return res.diagonal(dim1=-1, dim2=-2) if diag else res + + def num_outputs_per_input(self, x1, x2): + """ + Given `n` data points `x1` and `m` datapoints `x2`, this parallel + partial kernel returns an `(n*num_tasks) x (m*num_tasks)` + block-diagonal covariance matrix with `num_tasks` blocks of shape + `n x m` on the diagonal. + """ + return self.num_tasks From 54859de31ae80b3c27138b2c9c3fb8f607ab4eaf Mon Sep 17 00:00:00 2001 From: pmrobbe Date: Sat, 20 Jan 2024 14:44:11 -0800 Subject: [PATCH 2/4] Added first version of parallel partial emulation example --- .../Parallel_Partial_GP_Regression.ipynb | 285 ++++++++++++++++++ 1 file changed, 285 insertions(+) create mode 100644 examples/03_Multitask_Exact_GPs/Parallel_Partial_GP_Regression.ipynb diff --git a/examples/03_Multitask_Exact_GPs/Parallel_Partial_GP_Regression.ipynb b/examples/03_Multitask_Exact_GPs/Parallel_Partial_GP_Regression.ipynb new file mode 100644 index 000000000..350db45fc --- /dev/null +++ b/examples/03_Multitask_Exact_GPs/Parallel_Partial_GP_Regression.ipynb @@ -0,0 +1,285 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parallel partial GP Regression\n", + "\n", + "## Introduction\n", + "\n", + "Parallel partial Gaussian Process regression, introduced in [this paper](https://projecteuclid.org/journals/annals-of-applied-statistics/volume-10/issue-3/Parallel-partial-Gaussian-process-emulation-for-computer-models-with-massive/10.1214/16-AOAS934.pdf), is a simplification of [Multitask Gaussian Process regression](./Multitask_GP_Regression.ipynb), where intertask similarities are not explicitly learned. The advantage of this approach is that it leads to significant computational savings when the number of outputs (tasks) is large. The difference with [Batch-independent Gaussian Process regression](./Batch_Independent_Multioutput_GP.ipynb) is that a single kernel is learned for all outputs simultaneously.\n", + "\n", + "Given inputs $x$ and $x'$, and tasks $i$ and $j$, the covariance between two datapoints and two tasks is given by\n", + "\n", + "$$ k([x, i], [x', j]) = k_\\text{inputs}(x, x') * \\delta_{i, j}\n", + "$$\n", + "\n", + "where $k_\\text{inputs}$ is a standard kernel that operates on the input data, and $\\delta_{i, j}$ is the Kronecker delta (i.e., it is 1 if $i = j$ and 0 otherwise)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "import math\n", + "import torch\n", + "import gpytorch\n", + "from matplotlib import pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up training data\n", + "\n", + "In the next cell, we set up the training data for this example. We'll be using 100 regularly spaced points on [0, 1] as input data. We evaluate 4 sinusoidal functions (two sine and two cosine functions with different periods) on the input data, and add Gaussian noise to get the output data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "train_x = torch.linspace(0, 1, 100)\n", + "\n", + "train_y = torch.stack([\n", + " torch.sin(train_x * (2 * math.pi)) + torch.randn(train_x.size()) * 0.2,\n", + " torch.cos(train_x * (2 * math.pi)) + torch.randn(train_x.size()) * 0.2,\n", + " torch.sin(train_x * math.pi) + torch.randn(train_x.size()) * 0.2,\n", + " torch.cos(train_x * math.pi) + torch.randn(train_x.size()) * 0.2,\n", + "], -1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define a parallel partial model\n", + "\n", + "The model should be somewhat similar to the `ExactGP` model in the [simple regression example](../01_Exact_GPs/Simple_GP_Regression.ipynb).\n", + "The differences:\n", + "\n", + "1. We're going to wrap ConstantMean with a `MultitaskMean`. This makes sure we have a mean function for each task.\n", + "2. Rather than just using an `RBFKernel`, we're using that in conjunction with a `ParallelPartialKernel`. This gives us the covariance function described in the introduction.\n", + "3. We're using a `MultitaskMultivariateNormal` and `MultitaskGaussianLikelihood`. This allows us to deal with the predictions/outputs in a nice way. For example, when we call MultitaskMultivariateNormal.mean, we get a `n x num_tasks` matrix back.\n", + "\n", + "You may also notice that we don't use a `ScaleKernel`, since the `ParallelPartialKernel` will do some scaling for us. (This way we're not overparameterizing the kernel.)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class ParallelPartialGPModel(gpytorch.models.ExactGP):\n", + " def __init__(self, train_x, train_y, likelihood):\n", + " super(ParallelPartialGPModel, self).__init__(train_x, train_y, likelihood)\n", + " self.mean_module = gpytorch.means.MultitaskMean(\n", + " gpytorch.means.ZeroMean(), num_tasks=train_y.shape[1]\n", + " )\n", + " self.covar_module = gpytorch.kernels.ParallelPartialKernel(\n", + " gpytorch.kernels.RBFKernel(), num_tasks=train_y.shape[1]\n", + " )\n", + "\n", + " def forward(self, x):\n", + " mean_x = self.mean_module(x)\n", + " covar_x = self.covar_module(x)\n", + " return gpytorch.distributions.MultitaskMultivariateNormal(mean_x, covar_x)\n", + "\n", + "likelihood = gpytorch.likelihoods.MultitaskGaussianLikelihood(num_tasks=train_y.shape[1])\n", + "model = ParallelPartialGPModel(train_x, train_y, likelihood)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the model hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iter 1/50 - Loss: 1.185\n", + "Iter 2/50 - Loss: 1.149\n", + "Iter 3/50 - Loss: 1.113\n", + "Iter 4/50 - Loss: 1.075\n", + "Iter 5/50 - Loss: 1.036\n", + "Iter 6/50 - Loss: 0.997\n", + "Iter 7/50 - Loss: 0.957\n", + "Iter 8/50 - Loss: 0.917\n", + "Iter 9/50 - Loss: 0.877\n", + "Iter 10/50 - Loss: 0.837\n", + "Iter 11/50 - Loss: 0.798\n", + "Iter 12/50 - Loss: 0.759\n", + "Iter 13/50 - Loss: 0.721\n", + "Iter 14/50 - Loss: 0.682\n", + "Iter 15/50 - Loss: 0.644\n", + "Iter 16/50 - Loss: 0.605\n", + "Iter 17/50 - Loss: 0.566\n", + "Iter 18/50 - Loss: 0.527\n", + "Iter 19/50 - Loss: 0.488\n", + "Iter 20/50 - Loss: 0.449\n", + "Iter 21/50 - Loss: 0.410\n", + "Iter 22/50 - Loss: 0.372\n", + "Iter 23/50 - Loss: 0.334\n", + "Iter 24/50 - Loss: 0.298\n", + "Iter 25/50 - Loss: 0.263\n", + "Iter 26/50 - Loss: 0.230\n", + "Iter 27/50 - Loss: 0.198\n", + "Iter 28/50 - Loss: 0.168\n", + "Iter 29/50 - Loss: 0.139\n", + "Iter 30/50 - Loss: 0.112\n", + "Iter 31/50 - Loss: 0.086\n", + "Iter 32/50 - Loss: 0.063\n", + "Iter 33/50 - Loss: 0.042\n", + "Iter 34/50 - Loss: 0.023\n", + "Iter 35/50 - Loss: 0.007\n", + "Iter 36/50 - Loss: -0.006\n", + "Iter 37/50 - Loss: -0.016\n", + "Iter 38/50 - Loss: -0.024\n", + "Iter 39/50 - Loss: -0.030\n", + "Iter 40/50 - Loss: -0.034\n", + "Iter 41/50 - Loss: -0.036\n", + "Iter 42/50 - Loss: -0.036\n", + "Iter 43/50 - Loss: -0.035\n", + "Iter 44/50 - Loss: -0.032\n", + "Iter 45/50 - Loss: -0.029\n", + "Iter 46/50 - Loss: -0.026\n", + "Iter 47/50 - Loss: -0.024\n", + "Iter 48/50 - Loss: -0.022\n", + "Iter 49/50 - Loss: -0.020\n", + "Iter 50/50 - Loss: -0.020\n" + ] + } + ], + "source": [ + "# this is for running the notebook in our testing framework\n", + "import os\n", + "smoke_test = ('CI' in os.environ)\n", + "training_iterations = 2 if smoke_test else 50\n", + "\n", + "\n", + "# Find optimal model hyperparameters\n", + "model.train()\n", + "likelihood.train()\n", + "\n", + "# Use the adam optimizer\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=0.1) # Includes GaussianLikelihood parameters\n", + "\n", + "# \"Loss\" for GPs - the marginal log likelihood\n", + "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model)\n", + "\n", + "for i in range(training_iterations):\n", + " optimizer.zero_grad()\n", + " output = model(train_x)\n", + " loss = -mll(output, train_y)\n", + " loss.backward()\n", + " print('Iter %d/%d - Loss: %.3f' % (i + 1, training_iterations, loss.item()))\n", + " optimizer.step()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make predictions with the model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAAISCAYAAAApy5XhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xT1fvA8U9G996Dlpa9Z9lDlCGggoADtV8FBUFZAl8F/foTJ6KgoCguZMgSBEFREAQsUyi07FkodNK9Z9o09/dHSGjapE1LC20579erL5rce5NzS3tyn3vOeR6ZJEkSgiAIgiAIgiAIQpXI73UDBEEQBEEQBEEQ6iMRTAmCIAiCIAiCIFSDCKYEQRAEQRAEQRCqQQRTgiAIgiAIgiAI1SCCKUEQBEEQBEEQhGoQwZQgCIIgCIIgCEI1iGBKEARBEARBEAShGkQwJQiCIAiCIAiCUA0imBIEQRAEQRAEQagGEUwJgiAIgiAIgiBUQ70Jpr799ls6duyIo6Mjjo6O9O7dm7/++uteN0sQBKFeEX2pIAiCINQcmSRJ0r1uhDn++OMPFAoFLVq0QJIkfvrpJxYtWsSpU6do167dvW6eIAhCvSD6UkEQBEGoOfUmmDLG1dWVRYsWMWHChHvdFEEQhHpL9KWCIAiCUD3Ke92A6igpKWHz5s3k5eXRu3dvk/upVCpUKpX+sUajIT09HTc3N2Qy2d1oqiAI9xlJksjJycHX1xe5vG7PpDanLxX9qCAId1t96kcFoV4FU+fOnaN3794UFhZib2/Ptm3baNu2rcn9FyxYwPvvv38XWygIgqAVGxuLn5/fvW6GUVXpS0U/KgjCvVKX+1FB0KlX0/yKioqIiYkhKyuLLVu28OOPP3LgwAGTFwFl76hmZWXRuHFjYmNjcXR0vFvNFgThPpKdnY2/vz+ZmZk4OTnd6+YYVZW+VPSjgiDcbfWhHxUEnXoVTJU1ePBgmjVrxvfff2/W/tnZ2Tg5OZGVlSUuAgRBqBX1sZ+pSl9aH89PEIT6RfQzQn1SryeiajQagzumgiAIQtWJvlQQBEEQqqferJl66623GD58OI0bNyYnJ4cNGzawf/9+du/efa+bJgiCUG+IvlQQBEEQak69CaaSk5N54YUXSEhIwMnJiY4dO7J7926GDBlyr5smCIJQb4i+VBAEQRBqTpWDqRs3bnDo0CGio6PJz8/Hw8ODLl260Lt3b6ytrWujjQCsWLGi1l5bEAThfiH6UkEQBEGoOWYHU+vXr+fLL78kLCwMLy8vfH19sbGxIT09ncjISKytrQkODmbu3LkEBATUZpsFQRAEQRAEQRDuObOCqS5dumBpacn48eP59ddf8ff3N9iuUqk4evQoGzdupFu3bnzzzTc89dRTtdJgQRAEQRAEQRCEusCs1Oi7d+9m6NChZr1gWloaUVFRBAUF3XHjappItSkIQm1r6P1MQz8/QRDuPdHPCPWJWSNT5gZSAG5ubri5uVW7QYIgCIIgCIIgCPWBWcFUdna22S8o7iAIgiAIgiAIgnA/MCuYcnZ2RiaTmfWCJSUld9QgQRAEQRAEQRCE+kBuzk4hISH8888//PPPP6xcuRJPT0/mzJnDtm3b2LZtG3PmzMHLy4uVK1fWdnsFQRAEQRAEocEKDAzkiy++uNfNqDEN7XzKMiuYGjBggP5rzZo1LF68mAULFjBy5EhGjhzJggUL+Oyzz1i1alVtt1cQBEEQBEEQ7lhYWBgDBw4kLCzsrrxfbGwsL730Er6+vlhaWhIQEMBrr71GWlraXXn/uuq9995DJpMhk8lQKpW4u7vzwAMP8MUXX6BSqar0Wvv370cmk5GZmVk7jTXCrGCqtKNHj9KtW7dyz3fr1o3jx4/XSKMEQRAEQRAEoTatWbOGkJAQ1q5dW+vvdf36dbp168bVq1f5+eefuXbtGt999x379u2jd+/epKen13obTCkpKUGj0dyz9wdo164dCQkJxMTEEBISwlNPPcWCBQvo06cPOTk597RtlalyMOXv78/y5cvLPf/jjz+Wqz8lCIIgCIIgCHVFdHQ04eHhnDx5kk2bNgGwceNGTp48SXh4ONHR0bXyvlOnTsXS0pK///6bAQMG0LhxY4YPH87evXuJj4/n7bffNtg/JyeHZ599Fjs7Oxo1asSyZcv02yRJ4r333qNx48ZYWVnh6+vLjBkz9NtVKhWvv/46jRo1ws7Ojp49e7J//3799tWrV+Ps7Mz27dtp27YtVlZW/Pjjj1hbW5cb0XnttdcYOHCg/vHhw4fp378/NjY2+Pv7M2PGDPLy8vTbk5OTGTFiBDY2NjRp0oT169eb9fNRKpV4e3vj6+tLhw4dmD59OgcOHOD8+fN8+umn+v3Wrl1Lt27dcHBwwNvbm+eee47k5GQAoqKieOihhwBwcXFBJpMxfvx4AHbt2kW/fv1wdnbGzc2Nxx57jMjISLPaVimpinbs2CFZW1tL7du3lyZMmCBNmDBB6tChg2RtbS3t2LGjqi93V2VlZUmAlJWVda+bIghCA9XQ+5mGfn6CINx7tdnPAPovmUxm8K/uq6alpaVJMplM+vjjj41uf/nllyUXFxdJo9FIkiRJAQEBkoODg7RgwQLpypUr0tKlSyWFQiH9/fffkiRJ0ubNmyVHR0dp586dUnR0tBQaGir98MMP+tebOHGi1KdPH+ngwYPStWvXpEWLFklWVlZSRESEJEmStGrVKsnCwkLq06ePdOTIEeny5ctSbm6u5OXlJf3444/611Gr1QbPXbt2TbKzs5OWLFkiRURESEeOHJG6dOkijR8/Xn/M8OHDpU6dOklHjx6VwsLCpD59+kg2NjbSkiVLTP583n33XalTp05Gtz3++ONSmzZt9I9XrFgh7dy5U4qMjJSOHj0q9e7dWxo+fLi+vb/++qsESFeuXJESEhKkzMxMSZIkacuWLdKvv/4qXb16VTp16pQ0YsQIqUOHDlJJSYnJdpmrWr8xsbGx0ltvvSWNHj1aGj16tPS///1PiomJuePG1DZxESAIQm1r6P1MQz8/QRDuvdrsZ9atWycplUqD4En3pVQqpXXr1tX4ex47dkwCpG3bthndvnjxYgmQkpKSJEnSBlPDhg0z2Gfs2LH6oOHzzz+XWrZsKRUVFZV7rejoaEmhUEjx8fEGzw8aNEh66623JEnSBlOAdPr0aYN9XnvtNWngwIH6x7t375asrKykjIwMSZIkacKECdKkSZMMjjl06JAkl8ulgoIC6cqVKxIgHT9+XL/90qVLElDtYGru3LmSjY2NyWNPnDghAVJOTo4kSZIUEhIiAfo2m5KSkiIB0rlz5yrczxxmpUYvy8/Pj48//rg6hwqCIAiCIAjCPREcHEybNm0ICgoqty00NJSuXbvW2ntLkmT2vr179y73WJcR76mnnuKLL76gadOmDBs2jEceeYQRI0agVCo5d+4cJSUltGzZ0uB4lUqFm5ub/rGlpSUdO3Y02Cc4OJhevXpx8+ZNfH19Wb9+PY8++ijOzs4AnDlzhrNnzxpM3ZMkCY1Gw40bN4iIiECpVBr8bFu3bq0/vjokSTIozxQeHs57773HmTNnyMjI0K/1iomJoW3btiZf5+rVq8ybN4/Q0FBSU1MNjmvfvn212wdm1pkqKzMzkxUrVnDp0iVAu2jspZdewsnJ6Y4aIwiCIAiCIAh3g1wuR6PR6P+tLc2bN0cmk3Hp0iVGjx5dbvulS5dwcXHBw8PDrNfz9/fnypUr7N27lz179jBlyhQWLVrEgQMHyM3NRaFQEB4ejkKhMDjO3t5e/72NjU25GrLdu3enWbNmbNy4kVdffZVt27axevVq/fbc3FwmT55ssD5Lp3HjxkRERJjV/qq4dOkSTZo0ASAvL4+hQ4cydOhQ1q9fj4eHBzExMQwdOpSioqIKX2fEiBEEBASwfPlyfH190Wg0tG/fvtLjzFHlYCosLIyhQ4diY2NDjx49AFi8eDHz58/n77//rtWIXhAEQRAEQRDuhKenJ97e3vj7+zNhwgRWrFhBbGwsnp6etfJ+bm5uDBkyhG+++YZZs2ZhY2Oj35aYmMj69et54YUXDIKbY8eOGbzGsWPHaNOmjf6xjY0NI0aMYMSIEUydOpXWrVtz7tw5unTpQklJCcnJyfTv37/KbQ0ODmb9+vX4+fkhl8t59NFH9du6du3KxYsXad68udFjW7dujVqtJjw8nO7duwNw5cqVaqcpv3z5Mrt27eKtt97SP05LS+OTTz7RJ70rm9be0tIS0GYo1ElLS+PKlSssX75c/zM5fPhwtdpkTJWDqVmzZjFy5EiWL1+OUqk9XK1WM3HiRGbOnMnBgwdrrHGCIAiCIAiCUJP8/PyIiorC0tISmUzGpEmTKCoqwsrKqtbe8+uvv6ZPnz4MHTqUjz76iCZNmnDhwgXeeOMNGjVqxPz58w32P3LkCAsXLmTUqFHs2bOHzZs3s2PHDkCbja+kpISePXtia2vLunXrsLGxISAgADc3N4KDg3nhhRf4/PPP6dKlCykpKezbt4+OHTsaBEfGBAcH89577zF//nyefPJJg5/J3Llz6dWrF9OmTWPixInY2dlx8eJF9uzZw9dff02rVq0YNmwYkydP5ttvv0WpVDJz5kyD4NEUtVpNYmIiGo2GtLQ09u/fz0cffUTnzp154403AO3ol6WlJV999RWvvPIK58+f58MPPzR4nYCAAGQyGX/++SePPPIINjY2uLi44Obmxg8//ICPjw8xMTG8+eabZv2/maWqi6ysra2lS5culXv+woULFS4QqwvEwmlBEGpbQ+9nGvr5CYJw7zXUfiYqKkoaN26c5OXlJVlYWEj+/v7S9OnTpdTUVIP9AgICpPfff1966qmnJFtbW8nb21v68ssv9du3bdsm9ezZU3J0dJTs7OykXr16SXv37tVvLyoqkubNmycFBgZKFhYWko+PjzR69Gjp7NmzkiRpE1A4OTmZbGePHj0kQPrnn3/KbTt+/Lg0ZMgQyd7eXrKzs5M6duwozZ8/X789ISFBevTRRyUrKyupcePG0po1a6SAgIBKE1BwKwmIQqGQXF1dpX79+klLliyRCgsLDfbdsGGDFBgYKFlZWUm9e/eWtm/fLgHSqVOn9Pt88MEHkre3tySTyaRx48ZJkiRJe/bskdq0aSNZWVlJHTt2lPbv319hUpCqkElSFVbDAV5eXqxdu5aHH37Y4Pndu3fzwgsvkJSUVBMxXq3Izs7GycmJrKwsHB0d73VzBEFogBp6P9PQz08QhHtP9DNCfVLlor1jx45lwoQJbNq0idjYWGJjY9m4cSMTJ07k2WefrY02CoIgCIIgCIIg1DlVXjP12WefIZPJeOGFF1Cr1QBYWFjw6quv8sknn9R4AwVBEARBEARBEOqiKgdTlpaWfPnllyxYsIDIyEgAmjVrhq2tbY03ThAEQRAEQRAEoa6qVp0pAFtbW1xcXPTfC4IgCIIgCIIg3E+qvGZKo9HwwQcf4OTkREBAAAEBATg7O/Phhx/WasEzQRAEQRAEQRCEuqTKI1Nvv/02K1as4JNPPqFv376AtvDVe++9R2FhYbk8+YIgCIIgCIIgCA1RlUemfvrpJ3788UdeffVVOnbsSMeOHZkyZQrLly9n9erVtdBErQULFtC9e3ccHBzw9PRk1KhRXLlypdbeTxAEoaER/aggCIIg1KwqB1Pp6em0bt263POtW7cmPT29RhplzIEDB5g6dSrHjh1jz549FBcX8/DDD5OXl1dr7ykIgtCQiH5UEARBEGpWlYv29uzZk549e7J06VKD56dPn86JEyc4duxYjTbQlJSUFDw9PTlw4AAPPPCAWceIInCCINS2+tTPiH5UEIS6SPQzQn1S5TVTCxcu5NFHH2Xv3r307t0bgKNHjxIbG8vOnTtrvIGmZGVlAeDq6mpyH5VKhUql0j/Ozs6u9XYJgiDUF6IfFQRBEIQ7U+VpfgMGDCAiIoLRo0eTmZlJZmYmY8aM4cqVK/Tv37822liORqNh5syZ9O3bl/bt25vcb8GCBTg5Oem//P3970r7BEEQ6jrRjwqCINxd48ePRyaT8corr5TbNnXqVGQyGePHj7/7DRPuSJWn+dUFr776Kn/99ReHDx/Gz8/P5H7G7qj6+/uLYWNBEGpNfZmeIvpRQRDqqvrSj1bV+PHj+eeff8jOziYhIQEbGxsACgsL8fHxwdHRkYceeqhWE7oJNa9aRXszMzM5fvw4ycnJ5WpLvfDCCzXSMFOmTZvGn3/+ycGDByu8AACwsrLCysqqVtsjCIJQ34h+VBCEhkKSID//3ry3rS3IZFU7pmvXrkRGRrJ161aCg4MB2Lp1K40bN6ZJkyb6/TQaDZ9++ik//PADiYmJtGzZknfeeYcnn3wSgJKSEiZNmsQ///xDYmIijRs3ZsqUKbz22mv61xg/fjyZmZn069ePzz//nKKiIp555hm++OILLCws7vwHIADVCKb++OMPgoODyc3NxdHREVmp3yKZTFZrwZQkSUyfPp1t27axf/9+g184QRAEoXKiHxUEoaHJzwd7+3vz3rm5YGdX9eNeeuklVq1apQ+mVq5cyYsvvsj+/fv1+yxYsIB169bx3Xff0aJFCw4ePMh//vMfPDw8GDBgABqNBj8/PzZv3oybmxv//vsvkyZNwsfHh6efflr/OiEhIfj4+BASEsK1a9cYO3YsnTt35uWXX77T0xduqfI0v5YtW/LII4/w8ccfY2trW1vtKmfKlCls2LCB33//nVatWumfd3Jy0g+TVqahDhsLglB31OV+RvSjgiDUB1XpZ/Ly6k8wpRspWr58Of7+/vo6f61btyY2NpaJEyfi7OzM999/j6urq0GyN4CJEyeSn5/Phg0bjL7+tGnTSExMZMuWLfr3279/P5GRkSgUCgCefvpp5HI5GzdurOZZC2VVeWQqPj6eGTNm3NVACuDbb78F4MEHHzR4ftWqVWKxniAIghlEPyoIQkNja6sNau7Ve1eHh4cHjz76KKtXr0aSJB599FHc3d31269du0Z+fj5DhgwxOK6oqIguXbroHy9btoyVK1cSExNDQUEBRUVFdO7c2eCYdu3a6QMpAB8fH86dO1e9hgtGVTmYGjp0KGFhYTRt2rQ22mNSPcyTIQiCUKeIflQQhIZGJqveVLt77aWXXmLatGmANigqLfdWdLhjxw4aNWpksE23hnXjxo28/vrrfP755/Tu3RsHBwcWLVpEaGiowf5l10bJZLJy+Q6EO2NWMLV9+3b9948++ihvvPEGFy9epEOHDuX+k0aOHFmzLRQEQRAEQRCEBmTYsGEUFRUhk8kYOnSowba2bdtiZWVFTEwMAwYMMHr8kSNH6NOnD1OmTNE/FxkZWattFowzK5gaNWpUuec++OCDcs/JZDJKSkruuFGCIAiCIAiC0FApFAouXbqk/740BwcHXn/9dWbNmoVGo6Ffv35kZWVx5MgRHB0dGTduHC1atGDNmjXs3r2bJk2asHbtWk6cOCESC90DZgVTYjhQEARBEARBEGpORck1PvzwQzw8PFiwYAHXr1/H2dmZrl278r///Q+AyZMnc+rUKcaOHYtMJuPZZ59lypQp/PXXX3er+cIt9bJob3WJLFSCINS2ht7PNPTzEwTh3hP9jFCfmDUytXTpUiZNmoS1tTVLly6tcN8ZM2bUSMMEQRAEQRAEQRDqMrNGppo0aUJYWBhubm4VzsWUyWRcv369RhtYk8SdDkEQaltD72ca+vkJgnDviX5GqE/MGpm6ceOG0e8FQRAEQRCE+0NYWBhz5sxh4cKFdOvW7V43RxDqBPm9boAgCIIgCIJQ961Zs4aQkBDWrl17r5siCHWGWSNTs2fPNvsFFy9eXO3GCIIgCIIgCHVHdHQ0qampyGQyNm3aBGgLxo4bNw5JknB3dycgIOAet1IQ7h2zgqlTp06Z9WIymeyOGiMIgiAIgiDUHYGBgfrvddd5KSkpBAUF6Z+/jxJDC0I5ZgVTISEhtd0OQRAEQRAEoY5Zt24d48ePR61W64Mm3b9KpZLVq1ffw9YJwr1X7TVT165dY/fu3RQUFADiroQgCIIgCEJDExwcTGhoqNFtoaGhBAcH3+UWCULdUuVgKi0tjUGDBtGyZUseeeQREhISAJgwYQL//e9/a7yBgiAIgiAIwr0nl8sN/hUEwcxpfqXNmjULCwsLYmJiaNOmjf75sWPHMnv2bD7//PMabaAgCIIgCIJw73h6euLt7Y2/vz8TJkxgxYoVxMbG4unpea+bprdkT8Rdfb9ZQ1re1ferCkmSmDx5Mlu2bCEjI4NTp04xc+ZMOnfuzBdffGHyuMDAQGbOnMnMmTPvWlsbgioHU3///Te7d+/Gz8/P4PkWLVoQHR1dYw0T7p4SjUROYTE5hepbX8UUqjVoJAkkkJCQJJDLZdhZKrG1VGBvpcTWSoGjtQXWFop7fQqCIAiCINQSPz8/oqKisLS0RCaTMWnSJIqKirCysrrXTat3EhMTmT9/Pjt27CA+Ph5PT086d+7MzJkzGTRoUI28x65du1i9ejX79++nadOmuLu7s3XrViwsLGrk9QVDVQ6m8vLysLW1Lfd8enq6+KOqBzQaidRcFQlZhSRkFZKYVUBmQTFVWfIWG3GOP5YvYsTLb+DfsgNONhZ4OVrj5WiFl6M1no5WWClFgCUIgiAIDUXpazyZTGbWNV9+kZq03CL8XctfN96PoqKi6Nu3L87OzixatIgOHTpQXFzM7t27mTp1KpcvX66R94mMjMTHx4c+ffron3N1da2R1xbKq/Kk1/79+7NmzRr9Y5lMhkajYeHChTz00EM12jihZuSp1JyNy2TbqTi+2X+N9aEx/HM5mUsJ2WTkVy2QAjix53eunQklbO/vAGQVFBORlMOhq6lsCY/ju/3X2RIex6mYDLIKimvhjARBELTCwsIYOHAgYWFh97opgnDfkiTtjdrz8VmEXElmS3gc3x+I5PsD1/ntVPy9bl6dMWXKFGQyGcePH+eJJ56gZcuWtGvXjtmzZ3Ps2DEAYmJiePzxx7G3t8fR0ZGnn36apKQk/Wu89957dO7cmbVr1xIYGIiTkxPPPPMMOTk5AIwfP57p06cTExODTCbTp7Z/8MEHDabvJScnM2LECGxsbGjSpAnr168v197MzEwmTpyIh4cHjo6ODBw4kDNnzpjdFkAfIzRv3hwrKysaN27M/Pnz9dtjY2N5+umncXZ2xtXVlccff5yoqKia+HHfNVUemVq4cCGDBg0iLCyMoqIi5syZw4ULF0hPT+fIkSO10UahGnIKi4lIyiUyOZebWQVVDpjKSk+KJy8rA5lMxukDOwA4tX8n3YeMRpIk7JxccPVqBIBGkohNzyc2PZ/9V1LwcLCiKPEqq7+Yz+LPFgEwZ84cFi5cSLdu3e6sYYIg1HmpuSqOXU/DzkqJg5USe2sl9lZKnG0tsbcy/jEUFhZmVj+xZs0aQkJCWLt2rehPBOEuUalLiMsoICGzkMTsQpKyCylSa+51s+q09PR0du3axfz587Gzsyu33dnZGY1Gow+kDhw4gFqtZurUqYwdO5b9+/fr942MjOS3337jzz//JCMjg6effppPPvmE+fPn8+WXX9KsWTN++OEHTpw4gUJhfKbQ+PHjuXnzJiEhIVhYWDBjxgySk5MN9nnqqaewsbHhr7/+wsnJie+//55BgwYRERGhH+mqqC0Ab731FsuXL2fJkiX069ePhIQE/QhccXExQ4cOpXfv3hw6dAilUslHH33EsGHDOHv2LJaWljXxo691VQ6m2rdvT0REBF9//TUODg7k5uYyZswYpk6dio+PT220UTCTJEnEpOdzJi6LGyl52jVPNeSj5weWey43M43FU8foHy/++4rRY1NyVGxdvYbDB/bz/uJvcbWzFBc/gnAfUak1XE3KNbrNykKOq60lLnaWuNlZ4uFghbeTdYVBUnR0NKmpqchkMjZt2gTAxo0bGTduHJIk4e7uTkBAQK2flyDcL9QlGhKyColNzycmPZ+kbFWNXmPcD65du4YkSbRu3drkPvv27ePcuXPcuHEDf39/QHvDqF27dpw4cYLu3bsD2tGe1atX4+DgAMDzzz/Pvn37mD9/Pk5OTjg4OKBQKPD29jb6PhEREfz1118cP35c/5orVqwwSCx3+PBhjh8/TnJysn5K52effcZvv/3Gli1bmDRpUqVtycnJ4csvv+Trr79m3LhxADRr1ox+/foBsGnTJjQaDT/++KO+IPSqVatwdnZm//79PPzww9X4Sd99VQ6mQkJCeOihh3j77bfLbVu2bBlTp06tkYYJ5issLuHCzWzOxWWSkV870+qC5y7i58/eRFNSUm6bXKHg2dc/Kfd86dGskyHbAdj3x6/67T+tXcczwf/BUiEXFz+CcB8ou94SQFWs0a/h1PcZchk/rdsAwLoNPzNmbDD2Vgp9P6GbtgLoP4BTUlIICgrSPy9qHwrCnSlSa7iRmse15Fyi0vLEyNMdMqdPunTpEv7+/vpACqBt27Y4Oztz6dIlfeATGBioD14AfHx8yo0qVfY+SqXSoM9s3bo1zs7O+sdnzpwhNzcXNzc3g2MLCgqIjIzUP66oLZcuXUKlUplMrHHmzBmuXbtmcDxAYWGhwXvUdVUOpsaMGcPevXsN/gMAvvzyS9555x0RTN1FBUUlhEdnsH3fIbZ996nBBUppxi5gqrIdIGjQSLwaNzMYidKZuXQzfi3alXve2GhWQW6W/vusjHT69OyhfywufgShYSu93tJYX2Osz0hPTeHBvj31j+My8lmzZi0vvfQiarVa32/o/lUqlaxevbp2TkAQGrjiEg3XknOJSMohJi0ftUZ8LteUFi1aIJPJaiTJRNmsfLr8BTUpNzcXHx8fg+mFOqWDroraYmNjU+l7BAUFGV2v5eHhUfVG3yNVTkCxaNEihg8fbvDL8PnnnzNv3jx27NhRo40TjCsoKuHw1VRWHrnBiah0ju7aZpAQoqyyCSNAG0B988YLxEacM7q9Iro7wbp/TQmeuwi5ibm6pckVCsb97zOORqZRWFx+5EsQhPorOjqas6dPEnf1gsF6y7irF4iNOE960u3F6RX1GXKFguC5i/jlRCy5/r1ZssH4501oaCjBwcE1fyKC0IAlZhWy71ISPxy8zq7ziVxPyauxQCrmyjmRJAZtNr2hQ4eybNky8vLyym3PzMykTZs2xMbGEhsbq3/+4sWLZGZm0rZt2xprS+vWrVGr1YSHh+ufu3LlCpmZmfrHXbt2JTExEaVSSfPmzQ2+3N3dzXqfFi1aYGNjw759+4xu79q1K1evXsXT07Pcezg5Od3ROd5NVR6ZmjhxIunp6QwePJjDhw+zadMmPv74Y3bu3Enfvn1ro43CLUVqDWFR6ZyKzSQxPrbChBDFxSosLKxMbt+3cTnXzoSyf8tKrp4+Vm576YQSOvbObji4uOPs4UPPYU8SumsLmSkJ2DsbDgHrVDSaVZpuZOvY9TROxWbQs4kbXfydkcsrDtYEQaj7Sk/J0zG13tLcEfDC4hLiUrQXIzKZDEmSkMnlSDV8Z1YQGrIitYaLCdmci88iNUdVa+9zfM9vHBTrpAHtcpi+ffvSo0cPPvjgAzp27IharWbPnj18++23XLx4kQ4dOhAcHMwXX3yBWq1mypQpDBgwoEZ/dq1atWLYsGFMnjyZb7/9FqVSycyZMw1GkgYPHkzv3r0ZNWoUCxcupGXLlty8eZMdO3YwevRos9pjbW3N3LlzmTNnDpaWlvTt25eUlBQuXLjAhAkTCA4OZtGiRTz++ON88MEH+Pn5ER0dzdatW5kzZ065mrZ1VZWDKdBmYktLS6Nbt26UlJSwe/duevXqVdNtE26RJIkLN7P5NzKVPJV25MachBDmbD+1f6fJ7WUTSjh7ePPO2hAUFhbIZDJ6PzqWkuJilGZkW9Fd8Jh6rvRUQ1VxBy7czMIlL5YlH78rsv4JQj22bt06xo8fj1qtLrfN1HpLKBUkGek7wPjNnZy0RAoUdvrjBEEoL0+l5nRsJn/sO8yv335S4RT/6jJYM33rOqO2k8TMGtKyRl+vNjRt2pSTJ08yf/58/vvf/5KQkICHhwdBQUF8++23yGQyfv/9d6ZPn84DDzyAXC5n2LBhfPXVVzXellWrVjFx4kQGDBiAl5cXH330Ee+8845+u0wmY+fOnbz99tu8+OKLpKSk4O3tzQMPPICXl5fZ7/POO++gVCqZN28eN2/exMfHh1deeQUAW1tbDh48yNy5cxkzZgw5OTk0atSIQYMG4ejoWOPnXFtkkhkLVZYuXWr0+c8++4wHHniAHj1ur3uZMWNGzbWujIMHD7Jo0SLCw8NJSEhg27ZtjBo1yuzjs7OzcXJyIisrq978J93MLGD/lRSSsgsNnv97/TJ2/WT8/0WuUODl35SEqKvVek/dBU7QoJEGz5uztqqszJRElkx7AmcPHzr0HcKuNUsBieHjZnL28N9kpiQw6+tf+eeXHzn8+1r6j3qe0VP+D4Ctyz7i8O9rmfzqNCa+NE6kUxfqhbrez9yLfnTXgX8Z/mD5mQuzl201WG8ZG3GObcs+Ijk+Cjdvf4MR8Flf/4qzh2FmKnVRkf7mjiRJ+ps7bvaWdG3sQmtvB5SKKs9mF4QGKSOviPDoDC4lZKPWSPrP2NKfuzVl9sOtyj1X9sZIRZefdb0fFYTSzBqZWrJkidHnFQoFR44c0deXkslktRpM5eXl0alTJ1566SXGjKl46lh9l1+k5mBECpcScgye1wU09s6mK1k/+/on/P79giq+ozvQGAig84BppMR3Yucq0GhkSBrQaCDyjBVx13qxc3Uig57pgaOrGic3NVY2pjvEsqNZA8aMB8DCyorODz5CTnoKuZlp+qmI4f/8QeNWHZGAkyF/ALD+55+5HhtPSEgIy5YtY9WqVVU8N0EQdO5lP1rZaNOJPb8Tdek0fUc8x5hp8yodAS/9nEwm0z9Oyy1iz8Uk/o1MpbO/C539nbFUiqBKuD9l5Rdz9HoqlxNzSEs0v2bknRg2bka5G74iSYzQUJk1MlUXyWSyBjkyFRYWxtTXZvPQC7Pxamq42DA9KZ4/f/yM0wd2YmFpTXHRrdEqmQzzq/LKgJZAL6D3rX9bAhVnXKmIh18R/i0K8W9ZiH9LFY2aF1YYYOkYu3NljvDwcFFLRqiz6kM/o3O3+tETF64yqH+fcustZ339KxpNif7i7oe3J5KbmY69sxuT5i+vsYs7OysFPZq40aGREwqxFlO4T+Sp1By/kc65+CxKbiWTMOdz11TNyKrQjXoZEx4eTteuXSs8vj71o4JQrTVT9YVKpUKlur2oMjs7+x62pnJZ+cW8+9k3HP/3EFaegYyeog2mdHOPl0x7Qr+vPpACMwIpN+BxLKyeoVjVDXAxsd9NIBqFMoH2fTojk2k4feAPoOTWlxXgDfjc+vIGHEmJsyQlzpKTIdoOTy6XaNK+gPa9c2nfJw83H+O1ryqqXVURUUtGEO6emuhHfRv5mVxvaeziztyC4ObKU5UQcjmZk9EZ9G7mRmtvB7GmSmiwVOoSwqIyOBWTQXGJ4WdkdWpGVkY3Y2bAE+NxdPU0GPUC9Dd8TY1IC0J9Z1YwNXv2bD788EPs7OyYPXt2hfsuXry4RhpWExYsWMD7779/r5tRqaioKA6fv8H5+GwO7tamJy897F46iDJFrlDwzH8X4O4bwNKZY9EGO6OBMcAAQEmx/nqoAEubSwS2KSTi5CLgLBAHFAFQooYzBw1f21THO3rKl7h6P05chDWxEdbEXrUiK9WCyLO2RJ615ffvwTtARfs+uQQNysar8e3Aytxsf8bPV8nX3y2v8nGCIFRNTfWjpqbkBc9dxM+L3kSjMd7HPBw8lW/eeKHai+RLr/WkZQd2nU8kPDqDh1p70si5+iPyglAXXbyZzeFrKfpkVWVVp2ZkZXTlVa6dCTW+gwTggiRl4O3tjaenZ5XfQxDqMrOCqVOnTlFcXKz/vr546623DIK/7Oxsg6rSdUFWQTFNmjQp93zZO7OmAhqdmUs349usHUe2pwC/A49RuoyYp38m1nZ7ibn8Kb0fbcOTM95GJrMnbF9fNn72h8nXHvbCDNr2fNBkxytJGv5Y/iQjXn6DIcHaC53z/0ay/YdL2Nj/h/hrHiRGW5EYbcXen91o1imfPo9m0qFvLspSdd6MraWo6C7WzKW/oG7SntOxmXT2dzb5cxEE4c7Udj8aNGgkF46FcPrAznLbZi7dzPG/DevoVTUJjrFCwSk5KjaHxdLGx5H+LdyxtWzQkzSE+0ByTiH7L6cQn1lg9jGVrWGsSHpSPNfPneDgtrWk3kwAWqG0DKKkuBmS1IjbM1h8AC+gmDVrtvL0009hZWVVpfcShLrOrE+QkJAQo9/XdVZWVnX6j/bCzSz2X0mpdNj94eCpnD/6D3FXz5d/EZkMJBfC9jbnwvxA0m7eTg3q6h1LcdEGilU/8/jkafz82VwgnXNHbtD7Ee2oV9P2Qcxcutnk6FBedkaptyrf8Rq7UIk49TOpN9fSf9RpJi+Yx6Xjdpw+4MDF43ZEnrEl8owt9s5qegzNpkNf33LpjdOT4gAZrl6NaNm1D/s2fl+uDQBqjUTI5WSi0/J4uK03NpaVFwgWBKFq7rQfjYmBFWuVXEh0wsJKQmkpobSQKMxPAdJxdCnkctgRo8cmxUQaLJLPyUjj2plQDm/fwLOvm06yUzotc0WL7C/ezCYyJZc+zdzp5Ockpv4J9U5hcQlHI9M4G5eFxsyAqKo1I0vTlEBClBWfv/or0BfYALQCLFEXVXSkBSNH/oc6fEkmCNVWYwkoLl++zMiRI4mIiKiJl6tUfU5AUVBUwt5LSVxLztU/F3f1gtGAZvayrRz/e5uJhZw+2NgvoCD3aXQJJKztSug2OIO+I7Lxaqw2a7Hp7GVbTQZT9s5uPPv6AtYvnIOTmxd9RzzHkT82kJWadCsInEtuZjq2js6MfvVtJOC3b+eTn51ZbhG5TBZA6C4nju10IjtdG8crLDT0eDiDQc9k4upVok9vrN1mQVZqEkumPYGTuxe9hj9tMk2yvZWSYe298Xe1rfR8BaE21ZV+xhx3ox/dswcefriyvYqBeCAWuAacBMKBM0C+0SNmL9tqMkFFdRbZezpaMaStF54O1pUeKwj3UlhYGHPmzGHGW++Rau1HTmH5Gm6VMVVWoCxJgpvXLbl03J7r52y4ccEKVYGx+/C5wEXgEnAdSLj1lQTc5Nix7fTsWXHSidLqUz8qCDU2t0GlUhEZGVlTL2dUbm4u165d0z++ceMGp0+fxtXVlcaNG9fqe9eU6LQ8dl9INDmfuexwe+k7szKZDE//ZjTr+DinD3QkP+dpCnK1H/yNmhfSd0Qmnn7H2LXmE4oK3wA6mLXYVHeXKicjtdw+uZlpLP+/SQDkZ2fS57Fn2LL0XQCW/9/L+v3yszNZ/+kb5Y4tu4h82AtpDHkujQvH7Dn0mzORZ205usON43+70GtYNgPHpuPiefvusLmFgnNVan49GUePJq70buom7jALggl3ux/19ITRT6mJTChAXSyjuEiGukhOVmoW6UnFgC9gAQTe+uoPvHjr6BLgMnAc2A38DWhHyytKUFFhchuZjOA5C8s9nZytYuPxWHo0caVHoCtykfVPqKNWrvqJkJAQ1E5+1a4PZWoNI0BJCVw/Z8P5o/Zc+Nee9CSLMkdnA/8Ch9He9LiI9kbI7WsXe2c3hr0w49YNUBWNGol1UkLDVa8mioeFhfHQQw/pH+vm8Y8bN67O1ywo0Uj8G5lKeHSG0eR7ZYfddQFL6QBFkjxIiplGUsxkQBtENWlXwNAXUmnRuQCZDLYu22ow7c7cxabvrA3h9KFdbDQjy091svC1Cuqn/16hhI79cunYL5d//0xgxwp7CvKCOPKHM8d2OdLn0SyGPp+GrYMGqLjT19EtMo95+Q2S+vRkeHsfrC3EtD9BKOtu96OdOsFXPxTzy4mEctu0I/JPoV1X4X/rqy1N208iKdaZvCwboN2trxfRBlfHgb+Ancjkp3nujfLZxyrq92zsHfFq3IzYiPPlRrVKNBJHI9OITMllaDtv3O3FnCShboiOjiY1NZXY9HzWbfgZqH59qNJJWXTT8yUJ4q5aEbrLidMHHMjPuf35qbTU0KprPi265KMq2MWuNRORNMaz9OpIkkTjVh3wa9EOewcH/Pz8qnnmglD31atg6sEHH6yXaTWz8ov563wCCVmFJvcpOwJjaWPLz4veRNKUoL1rOwOYB2iHuz0axfHEDIkWnQvISI4n7qrp9QHZGSlAxYtNlZaWdBs0Em8TFyDP/HcBQYNGAtXLwhcfeYm4qxfKdfqJ0SsoyFtLh77zyc+dSeQZWw795sKRP2Q89NR1ho+zR25GTFR27db60Bge6+iDl6OYsiMIpdW9frQEmSweSYpDJjuGJEmMerUjAIunTgGC0GYkHQZ0QFsfrzfwAc7uOaQnqUhPysbVy7ypTgU5WZWmXU/OVrEhNIZeTd3oFuAiRqmEey4wMLDcc9UtIVD689LFqxPh+xw5vtuJhBu3bx7YOZbQtlcu7Xvn0rJrfqnakb1o031TpZ//eVnpBvt8OK4u9TmCULPqVTBVH0Uk5bD3UhKqYk2l+5Yecek2aCQXjoZw5qAc+BxtYV2AMJ6YXkifxzzRzWT76PmB5V6rbCdb1cWmZQOuS8cP0G3w4yb3qywbUNn2zPr6V4Pg78aFxUya34aoS+78tSqAgrzG7NvYlcthhYyekkzT9uUD0coWmcfFRDPmgS508HMy2S5BEO6dyhbCO7iocfaIoWXXSPZt7Aj4AUOB4cAwMpId+Gu1A3+tdqdZp3y6D8mm84AcLK0k7J3dsLa1pzA/1+h7V1ZTp0QjceRaKlFpeQxr742jddmpToJwd8Sm5zPh/xazasEbJmeEBLTuVGEJgfKflx05uuMxjvzRFE2JNvOv0kJDx3659BiaTbNO+SgquZFpThZAuUJB8JxPzTpPQaivzE5A4eLiUuE6FLVaTV5eHiVVLMB6N93NBY3qEg0HIlI4G5dVpeN0HV5GkgNrPpajKRl0a0si8D9gNbOX/WpQCyJ83/ZK10V16j/MrMWmmSmJfP7qKOyd3WjfZxAhm39EU1KCnaMzkxes1I8syeUKlkx7AntnN9r2fJDz/+4jKUa7DkP3e2LsV6uyFO9aSuBVkH0AkjMA7fsm8vTMXOydbgel5i4yb9/IiYGtPVGIu8vCXdDQF05X5/ziMwv45USs0W0VLYTXbTOWiCYjOZuBT+/mYqg/187cTjyjUKbTpsdF8rI+4rGJ41FaWBqt1Td72Vaza+pYWygY0taL5p72Zu0vCDVBN+00LDqdmCvn2Pzle8az+gIWltYUFxXS+cFHeGzC6xUkZRkEvIH2poROGLCSj36drZ9eD8anA4L2OmHJtCcMboKkJcSSn5NZrl2zl20lsFV7pg9qUaVzb+j9qNCwmD0y9cUXX9RiMxqWjLwidpxL4GR4WJVronz0/FBgDvAOYAWogCXAx0AOQLkRpaoW4TO17gi00w3zsjPIy87QB0cAedmZ5aYTvLM2hDmPdSDhhuHUgori85lLN5MUE1nJmis18BVIPwMfAS9z/og3URfUPDE9mU79tXeaza3kfj4+i4y8Ih7t6IOdlRiMFYS6pKI1kbrvy06D9mvRlj+WL6JZx/M8+KSM9CQl4fsc+WeThKrAg/P/9gO2sfnLowx/oUT/2lWtqVP6YrKwuAOd/J14oIUHSoW88oMF4Q5k5BXx1/lEkrK1szJO7PndZCAFUFyk3e/0/p2c3r+TWV//qp9Sr9FA/8d/59Dv/kCXW0eUAJuBz5ArTvPs658YBFK69yxb+gSMJ4aKvnSGpTPH3lHtKkGor8y+shw3blxttqPBuJKondZXpNaY7IhMib5sjbNHPJkpHree2QlMR5tmFGRyOWNnzTdICV7WnXRklko5jtZKZn60lK/enU1JSfk1CAqFksnzPsPBWkm+XGZGMgoZYNge89dcpQKvIJOvwtH1T7JS3fnpQ1869c9hzLTkKgWR8ZkF/Hw8hpGdfPEU66gEod4pHWSF7d1O5NnjhO39HTsnV/KyMmjUNAWZ/C1gCPA60J3EqIGs+kBCodyMq/cPDBjTr0o1dcr24Wdis4jPKODRjr642hm/ISUId0p3HZEYH1tuKrtMJsPB1ZOc9OQKP+N1o7GTPo5l50p34q7plgrkASvQ3qSNAmDm0tujtObWaCt7E8TZw7vatasEob4zK5jSXZwLpumm9e0Pv2i0I/Jv2YGD29bw8H+m0r634RonVYGMXT+5c/A3ZySNDBt7FQW5LwI/G+w366stJqelVKUIn1wmw93BEl8nG3ycrXG1s8TR2kKf/e753tN5fnhfgoKCyh17/HgoXbtqa0VIkkRev5k8NaQXowb3L7evraMzbt7+FbbHnOBv1ldz8Q7IYM8GGfs2unLmkAPXztgyZmoyHn7mv05OoZpfwmIZ0tabVt4ORvcRBKFuMnWRd+i3sjX4frn11R9tUDWSEvWTpMQ9zs3rebz03nOkJ4WzYeEco7MGKruYTHdyIbtQzZC2XrT0Ev2IUHPUJRoOXk3hTKx2eYCx9dCSJJGdllTpa8nkffFo9DM//E/7IWllo6HLg1c49lc/ZLIMk5+X5qzBNpbowtwyJoLQEJkVTLVr14558+YxZswYLCv4w7h69SqLFy8mICCAN998s8YaWdfppvWl5KhMdkQbFs4BYOW7rxp0RFEXrVm/0Ju0m9qfa9eB2fQceohv5/5cpVGmyjoyd3tLmnna4+9ii7eTNRZmTlORy+VoNBr9v6XJZDLsrZT4u9ga7CuTy5E0Gv7vy5+w9WuNRqJce4wFf7o518bOW2kpMXx8Gh365rLmYydS451Zu8CHjv36YO8cgIunIz2HPcmh39aQejOG7PQUo+dz/dJZHpv9PG+++xEvjRokbhIIwj1iaj2GKab6VtMO3frqjHaa9HD+/dOZE3sc8Wp8kbirl4zOGjD3YnLH2QRuNi7ggRYeItufcMcy87XXEcnZKv1zwXMX8fOiN9Foys/80H3OlhcILEbSjCY5VptUou+ILAY9k466OIULx+Q4e7Qvd5NT9/fYuHVHYi6fNd5IEzXadMwpYyIIDZFZwdRXX33F3LlzmTJlCkOGDKFbt274+vpibW1NRkYGFy9e5PDhw1y4cIFp06bx6quv1na764zS0/qg8hpMVrb2xF29gFoNJ0O6cGS7P5JGhrN7MU/NTKJNj3wyUxyqNVxetiNr5O5Ic097Wnja41LFKSmenp54e3vj7+/PhAkTWLFiBbGxsXh6li+8Z2rf5wd3xd3Lh+i0fK4l53I9JRe1RhscGQv+0hJi+WrWsxWet18LFS27ziI1PhB4h7OHvXDzucIT0xNo3KqIxOirJMVEciX8MG17PliurbppOz+tWYNXs7YMbedtdmApCEL1nDkVzjdvvG4QOFV1GnRFfavpC0uA08xeVkhK/Cn2/tyYhBtuxF0dCVzh+N/v023wBeD29CVz12ICnIrJJDlbxSMdfbAX6zGFarqWnMPfF29n/S19o6Fj/6GcPrCz3DETP/iOjZ//D1sH51vrm62Bube+bIAS2veOYfRUCRdP3ZR94zddszNSCNm8kmtnQrGwND0NvqIabYJwPzM7mx/A4cOH2bRpE4cOHSI6OpqCggLc3d3p0qULQ4cOJTg4GBcXl9ps7x2pyewwFWXr0xairGg9UAtgHdADgNbdY3j+rSJs7G9fDFSU4aoi1hYK2vo60rGRU5UDqLJUKhWWlpb6NhQVFWFlZbyIpTn7FhSVcOFmFufis8jMN17wz9R5l55688PbE8nNTMfG/lGUFr+Qk2GLTF5Cv5GXOBnyIHlZadg7uzFp/nIkSaK4WIWFhZXBsbrtrnaWjO7dmrYtm93Rz0oQdBp6FqrqnN9Lk6ew6odv6f7waPqN/I/Rv0VzCo+a6luD5y4yKHCuJ5OBJDF72dZSx40AFgKtbz0+CEwFzutnDZh6H1MZAO2sFDzSwQc/F9ty2wTBFEmSOHItjRNR6QbPb1j0JmF7ttHlwUe4HHaYgtzs2xtL/U57B7QgOyONz175kWLVAkrUfrd2CUGSptF5QCC5mWmVpks3lu3SHObWtVLKZSKbn9CgVelWWr9+/ejXr19ttaXeMDYcb75JwGLADrkiB03JRDwaWWFj/38Ge1V1uNzL0ZqOfk608naosZGW0sGQTCYzGUiZu6+NpYJuga4EBbgQk57P2bgsIlNyKR3OmzpvY1NvCnJ3AI2A5UiaJzn0W3tgPfA8uZkpFQa0paft/B+QlFUgElMIQg2Kjo4mNTUVmUzG9q1bADjx9zZO/L3NYL/qFB4tOxXY1sEJBxd37J3dSU+KQ1NSglwhx83bj5wM7c2V2yNOfwC7gNlos6Y+AJyidffTFObJsbbTmHwfnbJTFPNUJWw9Gc+Alh508neu/g9NuG8UFJXw1/kEotPyAcO1emF7tH8jp/aXH5HSfWDaO7uRk2nLr18FUpg34NZz+QwYc46QLU+Sn53OhaPXKS4qJGTLSqPp0o19rpqjshptgnC/EfMSquhSQjb/XE6mSK0xOee/9Hqgll37sG/j94AjsBx4GgDvgGiyMx4jP/s8p/a7lcuUY64AN1t6NXXD19mmZk+0FslkMgLc7AhwsyM1V0Xo9XSuJudQ0Rip6ak3mcBTIJsE0hK0tTPCgSeB48gVCnoNf5pjf/1icuplq6B+bA6PY2g7b1FHRhBqSGBgoP57c9YmmnOBZirRjk+TVvrpSyXFxciVSjRqtf6x0tKyTPbPYuBTYAParGZPcPlENxZOKmbs7CS8Glec0MfYFMUSjcQ/l5NJzlGJunZChZKzC/njbALZBbdnaJgb2Mjkcp6eOZ+Loa34Y7kHqgI5CgsNJcULyM38mB0r8/X7lk2X7teivUESrMqz8RpXOluuXCbD3lqJg7USR2slDtYWWCrlyGUy5DJQyGXib0Fo8Ko0za++u5Nh4yK1hn8uJ3Mp4fZw+9ZlH3H497X0H/U8o6cYjizppqvFX7vI4qnzgU1AM7Qf4m+i/QA3/qM3585sfQyiKmJOUGVq6o2NgxNjpvwf6z9dBfyKdvpOETATvxaHeOq195DJ5CZHqnTTjEDioU7NeKxvpxo6K+F+1NCnp5h7fuvXr2f8+PGo1eVLLBjz+rfb8G3WttL9qjsFGm73IWVHnEZPOczBbd1JS9C+Tu9HMxk+7iZ2Tgr9Pqnx0RTm55o1RdHX2ZrHOvqKunZCORdvZrPvUpJ+/bBO+L7tZgU2L767m4Pb+hF5VjulNLBtAWNnJxJ39VezA6PS1xgmlyXcmk6o/dbw72X51r30790Db0drHG2UtZLIqaH3o0LDInp6MyRnF7LzXAIZ+cVVqsEgSXDhWAfgX8ASW8cMilWjKVYdMPo+5tyZbexqS+9mDSeI0nG3t+LRjj6k5rpy6GoKUan5lR90S0FOVqn1Ej2AlWhHpr4h7upaQnf9Ra/hj5o8vvQ0o8XA3ouJPNTKU2ToEoQ7EBwcTJs2bYyWWIDymUKf7dGYDp2ak1OoJi1XRVpeEWm5RaTlqcjIK0ajz+xZ/Yxhpka2OvQtoVGznaxdUERW6tMc3eHM5TA7npmdSIsuBchkMha8NLTc65maongzs5ANoTGM6OSLt5OYPiyARiNx8GoKp2IyjW6vvP6iHJjB2o8Hoi5WYmml4ZGXUuk3MhO5Arwam1e/UZcES3e9YoqXfzNys9JQyGQ08g/gpZdeYtP6n4iLi2NY91b4ifIigqAngqlKxKTl89vpeEpu3UUyN21uQa6cnz/z5vy/2mljzTvF8/B/TrFm/jmKTSy1KltotjQXWwv6t/SgmUfDnobmbm/F6C5+RKbkcjAixSBRhb2zG9a29hTm55o83snDjqCBezm++yq5mW8Az3NsZ1f8W5zD1tEZSysbstKSjGb+0gWzZ+OyyCoo5tGOPlgpFbVxmoJwXykbOLm5udG0adNymUItFHJc7SxxtbOk9HJ1lbqE2PQCYtPziU7LI8NEApvKVFRC4p9ffiQrdS0d+l4j/tobpCdZ8O1cf/o9nsFjE1OrlOUPIFelZnNYLEPaedHaW9xZv58VFpew42wCMenm3SQsu0av38i5nNgzGlVBT9TF0KJzPk/PSsLNp+p/B6r8XIPrlXnrD+hvMHQbPIoTe7eRm5bEui2/EdQ6EFtLpT651H9fm1phIipBuF+JaX6VOBObyT+Xk/WPKxqK132gegc+yeoPfUm7aXlrLvMMYFml7/XcnIV0G/y4wXOWSjm9mrrS2d/lvpt3rC7RcDImkxNR6frU8+qiIhKiIoxmH5rxxSaWzhxb6pkH0E6v9AbS0K5X+6dMZq/bymbqcre3ZGTnRjjZWNTkaQkNXEOfnlKV84uLi6N79+7lyiYcPnyYpk2bmpUp1GgbCou5kZLH5cRsbmYWVvtc0pPiuX7uBAe3rSUtIZaC3Czsnd0Y/85KDv7WnrOHmgLgHajihf8loC4+ZbTvMNZ3l9ajiSt9mrmJunb3oZQcFX+cuUlWQeWBT2ZKIkumPaEfOT228xdSb/YA2fcU5llgYaXh8ckp9H40C2O/Srrjb6dLN013vRI0aCTqoiJ83Oxp38iZVl72yKWSex4wNfR+VGhYqjwydfLkSSwsLOjQQbvo9vfff2fVqlW0bduW9957r8Kivg1B0KCRSEhs+HROuW0zl24m4UZvvnzNE3WRHBevYsa/c5Pk2EB+/kxhvD6KTIaljR2q/FyunQnVfyDLZNDO14m+zd2wtbw/BxCVCjk9mrjSxseB/VdSuJaci/LWHTIoP49baWFR5u7xQSAI2IZ2+t9uug0+gCRlGz2+tNiIc3yzfBGXXn2T6c8MxcepYU2rFIS7wc/Pj6ioKP2d7UmTJpULnCrLFGqMo7UFnfyd6eTvTGZ+EZcScricmG2y5IIppmYafP1fXWD0MPbOO0iMsmLJ9MYMGJOhb3PpPuPS8QP6vttYYqLjN9JJyytiWDtvLJWirt394lpyDrsv3K5DWVmh6tIjp6oCOdGXXiPumhMA/i0LCX4zAU8/07/juuNzMtP4YvqTOHt407xzL0J++bHcvjOXbqZpmw6083Wkna8THg6l/wbvz2sOQaiuKvfqkydPJiIiAoDr16/zzDPPYGtry+bNm5kzp3yA0RBdPLbf4LH24t6S7/9XzM+feaMukmPrcJSxs3bh31JF0KCRzFy62ehrPTdnIRa3AtCLofuJu3qBrJjL9PTQMKSt130bSJXmYG3BiE6+PNLBBxtLhX7dg1+L9jw54338WrS/lRbZzcjP+ibaEao1gJKwvYPYv6UX9s6+Ro/X0WXrOrxrK1vC4ohIyrnLZy0IDYOVlZXBDZCavuPtbGtJ72ZuvNi3CU9186OZp73Ru/alpSfFExtxnuHjXjO5j1yhIHjuEN74PppW3fIoVsnZ+3MXFMrfcW/UhUHPTEau0E4Djjh5hLC9v7N46hPsXvu1PtNfaZHJuWwKizVrhEKo3yRJ4mhkGn+eTdAHUmCYBdIUpaUlcVet+XxKACf2OCGTSQx+No0ZX8RUGEiVPt7F04d31oYw86stdBnwCIDB3yBA1wBnJvZvwoOtPMsEUoIgVFWVp/k5OTlx8uRJmjVrxqeffso///zD7t27OXLkCM888wyxsbG11dY7difT/EonnvjurZfIz85ErlAw8KmJnD54gdSExSB1BzQ0bvUbMVeepP+o/+iz/JXNImWO+2gGptnyi9SEXE7hYmyayYxepjJ2PTD6LId+b4+kkRHQJo8X303A0VWjPz47I6VcYeDSmf4e6NiMx/uJTH/3k2Ohx/nfW2+ycOFCunXrZtYxDX16Sn04v4y8Ik7FZnDxZjbFJeX70dkPt6r0NUpP+9Vo4OBWF3asdKdELQOi0Sa5CTN5vKlMf7aWCh7r5EujBpZESNAqUmvYfSGRa8natb3GC8474e7rT7/Hn6dZx+763w1JgsPbndn+gzslxdrZLcFzEmnaoaDa7Sk9dXDQqGcI272FlMQEwsJO4OfnVyPnXBvqQz8jCDpVDqYcHR0JDw+nRYsWDBkyhMcee4zXXnuNmJgYWrVqRUFB9f/oa9udBFOmP3wHAL8AnkAaltaTUCj3UZCbha2jM68sWKm9WC9Rs+q9qfq50P/8spz0xDijr6hUKlm9ejXBwcHVOc37wtWkHP65nEx+Ufmpk2Xnnesyds36+lcSopqy9mMfCvMUuHgWM+HDeHybFAHmXWDtOp/A4DZe9936tftRXEY+r0ydzo6fVzJjxgy+/PJLs45r6BcB9en8CopKOB2bycmYDIMRAnPSUJddQwkQG2HF8v9zJDfTBVABrwHfm9WW0umoFXIZg9p40s7XqSqnI9RxWQXFbD9zk9Sc21mmzPlcWfz3FQry5PyyxIszB7VZ8jr0zeGZ/yZhY18+WVJVOVhI9G/tQ0sv7WvXhyQS9amfEYQqB1MDBw7E39+fwYMHM2HCBC5evEjz5s05cOAA48aNIyoqqpaaeufuJJgy/uE7A/gc7fziU8AYIMrkay3885zBaEr0pTNlEiZohYeH07VrV/NP7D6Vp1Kz63yi0QxJFdWiSY6zYMU7jUiJt8TKRsPz/0ugbc88wvdtZ8PCOUZHBEsv1vVzsWFEJ1+sLUSmv4YoOjqaw+evczo2ix/+N5HsjDQ8PT3566+/kCQJd3d3AgICTB7f0C8C6uP5FRSVcCIqnTOxmfr6Pqbq63g1bk5+Tiazvv4VZw/v8q+VJ2fle7ZEnvG99cxa4BXAeKa20n1HWd0CXejX3F0kpmgA4jLy2XE2odwNvsoC9+HjXsPFeyR/repFRrItCqXEiJdT6D8qs9LpqpVxsFbSq6kbbX0c612pj/rYzwj3ryovyPniiy8IDg7mt99+4+2336Z58+YAbNmyhT59+tR4A+sKwxoQNmjvRj5/a+s6YBJgfFRO92Fatj6Ki4N2mkfZtMGCeeyslIzp2ojw6Az+jUzTp6+HimvRePoVM+PLGH760JdrZ2xZMc+XB8acpetDzbC2c6AgN5uySqetj8so4OfjMTzeuRGudg074cr9prhEQ2BgYKlntBcgKSkpBvWSxBTc+sXGUsEDLT3o0tiZY9fTuXjz9t942anXz835FJ/AlibrV9nYaRj5cihLph0BPkH7OdAZeAK4Wm7/ikpehEVlkJ5XxPD2PiIxRT12Ni6T/VdSDD6DdCqrH/XXT7lAX8AKF69iXng7gYDW1c9QCWBtoaBHE1c6+TmhVIjfK0GobVX+K+vYsSPnzp0jKyuLd999V//8okWL+Omnn2q0cXVTY+Aw2g9QNdppHs9jKpAC7Ydp2buS7XwdeWFgJ7y9vQkKCuK7774jKCgIb29vPD09a6/5DYxMJqNboCtPd/PH2dZ4CvPYiHN888YLxEac0z9n56hh0sdx9ByehSTJOPBrJ5ZMS6Ig17w6IJn5xWw8EUN0Wl6NnIdw72XlF7PpRCzBcxfpEwuA9uJId7GtVCpZt27dPWqhcKccrC0Y0taL//RqTKtAP4NENv4tO+Dg4o6DizsJUVfK9RkGr+PihoPLT3j4vYyldRbQAe36qcdu72TmsML1lDyRmKKeKtFI7LuUxL5LyUYDqYpZAT8APwJW+DW/xn+/ib6jQEomg/aNnBjfJ5CgABcRSAnCXVKtVHGZmZls2bKFyMhI3njjDVxdXbl48SJeXl40atSopttYZ6TEN0UmC0eS3LGyycPRbTp5WdvIzyl/dxOMP2dtoWBIW0+ae2rnLleWNlgwj7eTNc/1bMy+S8lcSTTMvFc6g1LpdLRKC3h6ZhLFhSc5GTIA7VSd5mgXlmfp97O2czDI9KejKtbw26mbPNDSnS6NTVeSF+q+a8m5/H0xEVWxpsI7yaGhoWIKbgPgZm/FpEe60/vUJY5FZ5GrKilXwNdYn6FTOoX1lfAj/PA/e7RZQ38H5gEf4+XfjPycTKN9R1mpOSp+Ph7DYx198HOxrenTFWpBQVEJf5y9SXxG5evEdRlob9d/8gN+RVuyowQn96948jV/bB3K/66Zy9vJmodaeeLtZF3t1xAEoXqqHEydPXuWQYMG4ezsTFRUFC+//DKurq5s3bqVmJgY1qxZUxvtvKckCQ795sz271sgSTL8WhTy4rtJOHvMJS3hOb6a9SzOHj506DuEXWuWAhLDx83k7OG/yUxJ0H+YejtZ80gHH4MisHdab0W4zUqp4JEOPvg4WfP74TNkZ6Qjk8k4fWAHAKf276T7kNEG2bVkMvjPW43wbxXK7991AAYD/wKPAlHM+vpX1MXFbFg4hxEvvwFgUCdEI0nsv5JCRn4RD7b0rHfz0u93JRqJQ1dTOBWTaXS77oaImILbMHUIcKdVI1eOXU9j34kL5GSa7jOy0pI5uHW1/m9fNw3QO8Aee+exIC0mN+tZ4COUFr0Y944z7j7OJqcLllVQVMLWk/E81MqTDn4iMUVdFBYWxpw5c3jz3Q+JVfiSbcZooq621Ph5X6G0sGTJtK/RFpP3QFtM/hmyUvcSvu95GreqejBlY6mgX3N32vk6irV3gnCPVDmYmj17Ni+++CILFy7EwcFB//wjjzzCc889V6ONqwsKC+HnRV6E7dV+uLXuHs34eUVYWkmADHffxvo7lDKZjAFjxgNgYWXFwLEv6+90dmnsTP8WHiIL3F3QpbELXYMfKvd8bmaawWhD6exazTokAlOAP4C2QCgwEplMxqn9O/R3qSUJo3esz8RmkZZbxKMdfURtsHoiq6CYv84lkJBVflqN7k6yh7cvc16bwooVK4iNjRVTcBsgS6WcB1p6MKBV5X0GUO5v39nDm3nr9qCwsCB0VyK/fu2Juvgx1nyk4qX3b+Lua/70vRKNxN5LSaTmqhjQ0kPcnKlj1qxZQ0hICJLLD4x85W2zjtHNjDi1fyc2du8CewAFDi7RWNmMIy3hIJJk/GZfZVp6OfBQaw/xmSMI91iVJ9SeOHGCyZMnl3u+UaNGJCYm1kijKrJs2TICAwOxtramZ8+eHD9+vNbeKzYWXnrSXhtIyUqAmbj7vnMrkLpNeWuaHmiDKItbo0symQw7O2tGdPLhwVaeIpC6i9atW4dSafwDRluMc5H+cWzEObZ+/QG2jlH4NBmPs0cC2lT3IZw+6MjJkO0AhO3dTvg+7ffh//xB3NULxEacJz0pHtAmptgQGkNy9p0tHhZqX2RKLhtCY4wGUrER59iwcA7j533Fh6u2M3nyZEJDQ4mKiqrTdVmq4m72o/VFRX2GTC7HytYe0F70lv3b130G9BqezdRFcTi6qkmMtmLJ9MZEnLQ1um6zIqdjM9l6Kp4CI6UfhLsrOjqa8PBwwsLCWbv+ZwDC/tlR7negNF1R6LirF26NclpzbOdj7NnQDFAAq8jJaE3qzQP6pQC6wH3JtCf46PmBFbbJzkrBiE4+4uadINQRVf4rtLKyIju7fLaziIgIPDw8aqRRpmzatInZs2fz3Xff0bNnT7744guGDh3KlStXauWO8ezZuVw8a4+1nQp4hsK83zh9wI0eD5t398jDwYoRHX1xMpEYQag9wcHBtGnTxiADm07Z7Fon9vxO1KXT9B3xHGOmzaOoMJe3Ht8OjOSfTYPQjlgtoCD39jqq/OxMo6NcOYVqfgmLZXBbL1p7i3SudU1xiYZDV1M4E5tlch/dneTTB3bS+1aG0oY0Bfdu96P1RUV9hqTRoMrXFmGtaIQbILBtIbOWRbP6A1+iL9nww/8aEdguj+vnTK/BMiY2PZ8Nx2MY0ckHTwexDuZeMczuqVXZ74BhMOQH7EZd3A1t0qqZwDLkCgUaE7Fyq6B+JtvT1teRAS09RGkOQahDqjwyNXLkSD744AOKi7VTF2QyGTExMcydO5cnnniixhtY2uLFi3n55Zd58cUXadu2Ld999x22trasXLmyVt5vy5ZGwC8U5rWmMO83wPy7R629HRjb3V8EUnWAXK79NS89n7z8nUM4c2g38dcukhx7jpGTjoPsi1t7fwysBIz8X8pkBqNcAMUlEn+dS+RARAqaKmd4EmpLSo6KjcdjjAZSxn4fTu3fyY3L5wgPDyc6OvpuN7fW3O1+tD7S9RkV7lNmhLs0J7cSnn39OG16RKPRyLh+7gXgO06G7KlwRKOs7IJifjkRy+XE8jcwhbtj2fKVyBXmzXLQCZ676NbnTV+0WR67ASnAYOSK7wieu4iZSzebfM/4yEvlfk9sLRWM7OzL0HbeIpAShDqmyiNTn3/+OU8++SSenp4UFBQwYMAAEhMT6d27N/Pnz6+NNgLait3h4eG89dZb+ufkcjmDBw/m6NGjRo9RqVSoVLcrkRsbUavIunXfMG58MCVqdbltutpR5Z6XyejXwo2gANcqvZdQ8zw9PfH29sbf358JEybw7ffLuREdjb2zGx8EDyi3f9m7jbOXbWXx1FeBr4AXgSZoCzNn6PexsXfEq3EzYiPOlxupPBmdQXJ2IY908MHOSkzFuJdOxmRw5GqqvmBrWcZujORmpvH2uMfQrYxoCLWl7kU/Wp+U7TNWrFjB1WuRZGakl9u3ovpRAJ9MePDWd68DnwKTyctqxeKpT6JNPACzvt5ikNDGGN3NmaRsFf2bu4t1VHfRxZvZaJr2Y+bSX4xm92zUrA2e/k30j9OT4snLysCrcTOUltMpVi0CLIHTwCggmplLt+LXoh1xVy+YfN+yn0XbTsYxpK2X+BwRhDqqyiNTTk5O7Nmzhz/++IOlS5cybdo0du7cyYEDB7Czs6uNNgKQmppKSUkJXl5eBs97eXmZXKu1YMECnJyc9F/+/v5Ves/g4GDW/b7X6DZjtaNsLBWM7tJIBFJ1hJ+fH1FRUYSGhjJ58mROhZ/g+o0o2jQPLFNLyJDh3cbvgBFANvAgcAxt+nStgpysCkcq4zIKWB8aTWy6efWrhJqVq1Lz26l4DlxJ0QdSxtavmP59eB6Fom+DqS11L/rR+qRsnxEaGspfO7UjlbqRbXMzpt0enfgMGMntPuQ4MnlHgucuMijbUFbZ39OT0RlsPRVPflH5m3tCzVKXaNhzMYndFxIpLrl9E6Xs70BsxHmD/7uPnh/IkmljWTz1JsWqL9EGUpvQjlAZjm7rkty4evshMzESKlcomP/l94zq0kgEUoJQh1X7r7Nfv37062d6Xm9d8NZbbzF79mz94+zs7CpfCERGXNZ+I5OBJBmtHQXg7mDFyE6+BmnPhXuvbOp5N0c7ngyywdn2PyZrCenuOGemJOLg4o6zRzyBbb/n0G9PAy3RBlSjgUP6Y0yNVALkqbQpj3s3c6N7oItIX3uXXErIZv+VFAqLDRcmGKs7Vr62lBPaQPoZvL1VjBzZMNZLVUdN9KP1Sdk+w8/PTz9a9cgTz7Fq1UoykhNM1o8qPTphbedAQW42sAPoDWwHmqFQniAvK5zTBxYAxjO5Gfs9jU3PZ/2xGB7p6EMjZ5va/UHcpzLzi/jzbAIpObdHY3WBj72zG217Psj5f/eRHBuJJEkG/3fDxn3Erp/6og2aNcD/AQv0r1O6ZmHpWmXx1y4a/Szas/8wA/v1qtXzFQThzlU5mPrggw8q3D5v3rxqN6Yi7u7uKBQKkpKSDJ5PSkrC29vb6DFWVlZ3vGj8xL8HAbB3cmXYCzMI3bXFoHYUQFMPO4a398FSKaqN1wdKhZxh7b1JvuEM3K4lVDZQLv1hp017n8/y/0sjKcYN2AtMBlYDlU/50UgSR66lkpBVIOa817L8IjX7LiVzLTlX/5zuAreiumO39QfWAgGAmscfT8PW1vdunkKtuVf9aH2mG63SFVd/bdqr/H4ymgwTSTtNr6W9iLZI66+oix7kt+96op0+/LnRKcYmf0+9GrElLI6+zd0IChA3Z2rSteQcdl9IokhtWFNO91kw57EOJNwwTDZx+/+uPdpguQmQAzwH/Knfb9bXv+IT2NKg7ljZGmRlP4ucbc2rUSYIwr1V5WBq27ZtBo+Li4u5ceMGSqWSZs2a1VowZWlpSVBQEPv27WPUqFEAaDQa9u3bx7Rp02r0vaKjo0lNTUUmk3Hon78B7XqJxq064NeiHdZ29jh7aC88ggJc6N/CXXyg1UMDu7TA3cMTW1cvegx90migXPrDztVbwdOzDvPVLBXwNLAKaAfMNfs9r6fkse5YNA+39aaxm22NnYugdTUph38uJ5NfJqW0qTVRpS9g/2/NASytF1FUOAtQoLCIxdrmZd5660dMzAitd+5mP9qQlA4mXeys+E+f5oRcSeF8fPlkJsFzF/HzZ2+iKTGWqi0dpeVI1EWfAy+jnQLYFngVKNLvVfr30ljmOI0kcehqKvGZ4uZMTVCXaDh0LZXTJop3g/azwPT/7ePAOsAeJ/dcslJ7IZNdQpIMAyRTBZx1I18unj689NJL7NiyQdS1E4R6RCbVwKrq7Oxsxo8fz+jRo3n++edrol1Gbdq0iXHjxvH999/To0cPvvjiC3755RcuX75cbg2AqXY6OTmRlZWFo6PptNUGgdGt6X1lfbk3goGtPWnfSFSqr89UKhUZhRr+OJNATmGxvsiyKZkpiSye+iRy+ftkp78KgMJiN69/a49XY/NLA8hk2uLCfZu5oVTc3yOaYWFhzJkzh4ULF9KtW7dqvUZOYTEhV1KILDUaVVr4vu0VXOBCk/ZPoSn5iehL2qlT3YdkMWpKEn7uMl7o16JKbTG3n7lX7lY/ej84H5/F/ivJButqAOKuXjA6bUs3OpEQdZUl00KAJWjrDh0CnmD4uOfYve5ro7+nuqnEZdfqOtpYMLy9N75i2l+1pOaq+Ot8IqmlpvVVxPD/VoZ2Kp92xk6LLnmMeuUM3735OM4ePvQcdvsm3ayvf9XfhDXGyQoe7xqAm70VkiRRVFR0X48Ii35GqE9qZEWjo6Mj77//PiNGjKjVYGrs2LGkpKQwb948EhMT6dy5M7t27TLrAqAq1q1bx/jx41Gr1eUCKblCwQtzFzK6SyP8XcXIQn1nZWWFtxU808Of7Wdukpxd8Qijs4c389b9g8LCgtP7E/j5cy/URUP56SMVEz+Ix9XbvMXhkqRdUB6Tns/w9t6425v/oVkTwUddsmbNGkJCQli7dm2Vz0eSJM7EZXHkWmq5qTmlBQ0aiYTEhk/nGNn6AjfOLwNskMmzGTAmlJGTAgCwsGx4FzN3qx+9H7Rv5ISnoxU7ziaQmV9cbnvZaVu60Qnt/bqvgAhgI9qppcdx941k5tIBFa7lLCu7oJjNYXF0b+JCryZuDSLb393q407HZnIoIsVkls+K2aOd5q0tCdN5QCTBc0tQKN0Npof3fnRspTfp2vk68lBrTywUt8t43M+BlCDUNzV2SzwrK4usLNOFMGvKtGnTiI6ORqVSERoaSs+ePWv8PYKDgwkNDTW67f++38bi/00TgVQD42BtwVNB/jTztK90X+WttRNdHsph6mdxOLiqSYyyYsn0xlw7W7W7w6k5Kn4OjSE8OsPs1Nulg4/6Kjo6mvDwcE6ePMmmTZsA2LhxIydPnjS7rlNKjopNJ2IJuZxcYSClc/HY/jLPOKO9kP0J7YXRISRNB/ZvebhqJ1MP3Y1+9H7h6WDNsz0a09TjdjZb3bQtvxbteXLG+/i1aK9PYFB6u3/Lmzz8n/UoLaKBQDYufpATe28FQ5VkDyyd7U8jSYReT+eXsFgy84uM7l+f1HYfl1+k5vfT8YRcTq5yIGXv7IadY1csLMPRBlLFWFpPIzPlKW5e12Ze1H1GABVO71PKZQxu48XD7bz1gZQgCPVPlUemli5davBYkiQSEhJYu3Ytw4cPr7GG1RVl7yw+3N4LFzuxKLQhslTKGdHRh4NXUzkZnVH5AUBA60JmfRXDind9ib9mzTev+/DQU+d5bKIt5i6jU2skDkakEJGUw+A2Xng4lL8jWXodX+ngY9y4cUiShLu7OwEBAWaf670WGBio/1530ZGSkkJQUJD+eVPBZWFxCceup3EmNgtNqX1iI86Vq9lTOvFExKl/9e8nSQOANYA/UAy8i7YWkAYrW3virl5AkiQUft5A4xo7b6FhsrZQMLKTL0evp3H8Rnq55DWlRyd0v6fj531FYNsuyGQymnY4zU8fJlKQ25ND20YB/4ed47cMH2c86REYz0qZkFXI+tAYBrT0qHdT0O9WH3clMYf9V8qvqzRXSnwTJEIpLlLi4KJm3Ds3ORWSwZE/Thn8X1TGwVrJYx198XayrlY7BEGoO6ocTC1ZssTgsVwux8PDg3HjxhkUgqzvdMUb3Tx9aPPgKE7v20pOaiIBjRpGVi/BOJlMxoCWHrjYWhByOcXgYt0UZw810xfH8vmrqaTE9yZkc2fysrN4YnoyFpbm3/VMzCrk5+MxdAtwoUcTV4O1VHcSfNRFpafS6tqt+1epVLJ69epyx5w4cYKpM//L4Bdm49G0bfntRi4uyyeesESSPkRbSFWOdppVMBCm30OVn2swzWpGPfq5CveOTCajTzN3PB2s2H0hCW2NodvbdKMTut/T0wd20qRdVwDC9v5EQe52PBr9Skr848CHFOYH4dNEzhPTbyc9MpWV0r9lBw5uW8PD/5lK+94DtTWS9h/h9+WLWPzZonoxHbim+jhTUwTzVGr2XU42ua6yMpIEB7c688dyDzQaGT5Nsnn0pSNYWhVy5tAuwHiKe2Mau9rySAcfbCxF4hBBaAiqHEzduHGjNtpR5+jS4V5Kyicjv5gBS/6P4uJiMY/5PtHRzxlHawt2nEuocApZ6Yub/NyJwHhgIcd3OxFzpYSnZ10isI35iSlKNBKhN9K5mpzLwNae+umk1Qk+6rLg4GDatGljcKGkExoaSteuXQ2ei8vI5+1F33Di30NYewYyeoo2mKos5fnjr/yPP5Z/emtBfwe0Gbc63nrVH4GZQJ7RNsoVCl6Z93lNnK5wH2nu6YCzrSV/nLmpX0dl7Pc0/J8/aNyqIxIQtkebJTclfhQwAfiGkuJRfDXrFNqadtEs/vuKyayUGxZq1wKufPdVFv+tTd392+aNHD6wn8XfLGf9iqA6n3G2pvo4Y2swL9zM4mBEarmac+YqKpTxyxIvToZoEyEEDcomfJ8XP75jmB/fWObFsroFutC3mXuDWNsmCIJWjWTzqy+qkx0mv0iNraWoPH6/Ss1V8fvpm2QXlF9cDjD74VZGnh2Cdi2OK5DIlM+Kad6xoFrv38LLnv7NPXCyteDkyZNGg4/w8PBywUd9oDsfuVyORqPR/1v6fE5eiCDkTCQ3Mwv54e2J5GamY+/sxqT5y5EkiSXTnqj0fWZ+tZUvph8DPkQ7WpAMvIyt40HcvP1p2bUP+zZ+X+642cu20q1bEM/2qNo0v4aehaqhn19NKSwu4a/zCUSl5pvoJyrSD/gV8ARS6T5kExnJa2neuSd/r12GRmM8KLC0tuWp195HAn77dj752ZnYO7vxvy9/okcTV5o39q3T04Gr28eVniI4fPhwkpOT8fT0ZOPW7YRFpZEt2ZgcJapMWoKS1R/4Eh9pjVwuMXJyCv1HZXLyH9MZQo1lXrRQyBjS1ptW3g7Vasf9RvQzQn1iVjA1Zkz5zEKmbN269Y4aVJvEH6dQHXkqNdvP3CQxq3yVTtMpt5sCvwEdkMkkXLy+5YX/edG4tXb6mbH1PaYo5TI6+TtjkRlFn549Kgw+6pO4uDi6d++Ov78/EyZMYMWKFcTGxnLixAnsXDw5ej2NRztWPq1WrlCYvKB5bOK3hO8dTXyk+61nfwcmAcnM+GITAW06EX/tIounjim3PlIEU8Y19POrSRqNxKFrqSxf+VOFqfmN8wO2At0BDfAG/R5PITczjdMHdla7TQVF6jpbl8qcGyzGlB51u118XQbcvrwxNkqkY6o/jjhpy5r5PuTnKFAo0xk95Rx9HvPRbzeVAv+5OQvpNvhx/WNHGwtGdPTB01GsjzKX6GeE+sSs9DFOTk5mfwlCQ2NnpeTJID9aeJXP9Bc0aCQzl242ctR1pi++QbfB2UiSjPTEKayZ34y8bO2fXOn1PZVRayTCozPYH63CzcOTrl278t133xEUFIS3t3e9Leyom0obGhrK5MmTCQ0N5czFq1zMUrLmaDRXEnMInrsIuYmKuXKFguC5i0z8/GU8+EQYu36acCuQysXFax5PTD+Df0svHFzccfbwRiaTVZp5TRCqSy7XrsF8c/rLzP56SxWPjgMeoGn782g/qj/n6I4RXAw9Ub22KBQMe2EGnXr2Y/2fIWiqlQ68dunWKgcFBVWpj1u3bh1KpXYGye37w9p/df1ERcr2xxoN7Fnvyvf/a0R+jgJ75+uUqDuRFLPC6PFlp1BeOn5A/72fiw3P9vAXgZQgNGBimp8gmEmSJI5cS+NEVLrB87q7k2VHNoLnLsLTvxnfvHEAVcEngDVyRRw9hm7i7OGP9FNwdFPWstKSObh1dYWjVeqiIpzsbQgKdKW9ryNo1A1iHV9iViFh0elEJueVS/ph6u7v7GVb8WvRrtzPXzsquAJ4EICmHfJ56rVYPP1v37UuW/dFXVSkz7xWeru3k7UYmSqjoZ9fbdl14F+GP9i3XD8BGHwPMPiZyew1mHo6FW2BXwvgLPAkcLVK7z972VaO/72Nw7+vpf+o55nwxgf0b+FOU4/Ky0HcTSqVCstbqcWrUrz2932HGTW4f7nndf2Ejm4UasAT43F09UQmkxlMIX7+rZ/466cgoi5qC+w27XCWpJhh5GUlGPTXdk4uyOUKPn91FPbObrTvM4iQzT+iKSnBztGZyQtW0tLLnoe7tqBJk8Aa+/ncL0Q/I9QnYjGQIJhJJpPRr4U7zrYW/HM5mZJbd3Z1IxulK97HRpxj/advlDr6ALAZTUlzju2cDiQCn5dbsAxUmF5XaWlJXlEJByNSOBGVThd/Zzr5K+vstJ2KSJJEZEoeJ6MziM+sfE2ZsYtQuP3zd3L3xd33E84cfBBJssHCqoTHJqbRd0SmwWJvY3VfSj8uvd3OSnSRQs1o36wxnl5e2Ll6ETTkCUJ3bSE9KQ6Q4erViJ7DnuTYzl/ITE2kz4jn8Axozkb91MBlaIOozWgTqISjTVShG5U1nNIG5QO0pJhIgyQtZ4eM5swpiWaNfXikd0eauNtRF5QOnMwpXnstOZfQG2mcvJKiP8ZYP6GjG4W6dqZ8LcnczGZ8O7cD4A0UAFO4fm51qe3lE0zkZWeQl51BUsw1/fN52ZkG+91H96wF4b5UrSuFLVu28MsvvxATE0NRkWGBwJMnT9ZIwwShrmrfyAlnWwv+PJtAQVEJORkpePo1YcSkOTRu1ZHej47luzdf5Oqpo6WOOg0EASvRFnpcBAwHxgFxyORyLK1tUeXnmp1et6CohH8j0wiLzqC1twPtGznhVQ+mkmTlF3MhIYtLCTkmE3uUZixY1dXd0d1lHjnpJ47ueJDTB7TZD5u2z+PZN5Jx86n89Y1RymX0bOpGtwCXah0vCGX5+fkREx0NciV/X0zS154CjNaj6jZoJN6Nm5W6KD8EdEab3GYA8AuwFCu7D3B2czEYGUEmw9O/Ge37DNInVyl9c8dYUODhYEX3QFdaeNrX+UxzuhsxoTfSSM5WARX3E8ayKVrZ2lNcWFAqmcd04DO0SWoikCufRaM2fj2jSzABEDx3kcn1cPUx06ogCFVX5Wl+S5cu5e2332b8+PH88MMPvPjii0RGRmprwEydyvz582urrXdMDBsLNSkrv5jfz8Sz/NN5HP59Ld0fHk2/kf8xmDZi3ATgS8AOyECbEMH0eoqKFk6X5eFgRftGTrT2dqhTo1VFag1Xk3O4eDOb+MwCqnqj1tQ0vC1LP+XfPwORyd5CkpRYWmt4bGIKfR7LQm7WitDyGrnYMKRN9YtzN/R+pqGf390gSRJHI9MIvWGqj9AqP4UVQIE2M6WurmMoMBaINvk6FSVpKZt1ztnWgi6NXepcHwKQq1JzPj6L8/FZ5BSqy2031U9UnE3RHe20YN3PYDPaPjrH5BFlpw6amopcX5MD1QWinxHqkyqPTH3zzTf88MMPPPvss6xevZo5c+bQtGlT5s2bR3p6xR8MgtBQ6FLxtlRoOHdQm1nrxN/bOPH3NjOOXoF22t96oAfaD+/VaGseZen3kisUPBw8lW/eeMGsrH8AKTkqQi4ncygiBX9XW5q42xHoboeTjUUVz/DOZeUXcz01l6i0POLSC1DfwYL30tPwMpJvkpeVQWyEB0d3vgU0R5KgaYcEHnrqND5NrJHLq54G2VIpp38Ldzo0cqrzNXmE+k0mk9GnuTuu9pbsuZBk8m+j9GhLh75D2LVmKSAxfFwaobumkprwEUg90Y58vwJsMjheFyx5GYxw3TZz6WaDoAAgM7+YkMvJHIxIoamHHW18HGniZnfPRqs0GonYjHzOxmVxPaX8msrSTE3XNT16NBhYA/gAKuAN4KsKWlN+OmVpZbMQCoJwf6hyMBUTE0OfPn0AsLGxISdHe/fm+eefp1evXnz99dc120JBqIMCAwP131fvwvsa3QZ/Rti+ziDNRVvs92G0C81/A+CZ/y4g5so5fZYpc4IpHbVG4kZqHjdStQVp3e0taeJuj6+zNZ6O1tjX8FogSZLIzC8mKaeQxKxCotPySc8rqvzAavjo+WDgU0B3cXgTmM71c1u5fk77TFVG8wCauNsxqI0nDtZ3P+gU7l+tvR1xttEW+M1VlR9pcfbw5p21IfrRlgFjxgNgYWXFwLESqfHJbFhkTfQlZ7TT/x4FpgHZwO1gKe7qBaDy9USllWgkriblcjUpF1tLBS29HAhws6WRiw1WytodsSosLiE6LZ/rKblEpeVTWFxSpXISZQUNGlkmoLQE5gOv33p8AXgO7bo04wY/M5krJ//VTx3Ukcngwc7N2eDtXa7MQ33NtCoIQtVU+YrK29ub9PR0AgICaNy4MceOHaNTp07cuHFDLLIU7hvr1q1j/PjxqNVqs3/vy17AhO3djHZUaifa0apWwDa0xTqnEb5vO/GRFwHMXkdlSmpuEam5t0eO7awUeDhY4elgjYutJbaWCmytFNhZKrG1VBgNECVJIq+ohNxCNbmqYnIK1eQUqvn3WCirvpjPoxNer/QipzoXRLpjho+fS+TZ/igtolAXW6KtvbMM+D90F4+l1zKYw8pCzgMtPGjfSJR1EO4Nbydrnunhzx9nEkjKLl/LrvRoi0WZ5AwefjDt81h+/aqEY3+1BJ4H+gMvoF1jpVXReiJz5BeVcDo2k9OxmchlMrydrPB3tcXfxRZ3eytsLO8suMoqKCYlR0VyTiE3Mwu5mVmgT/CjUzp9eVX7jhEvv4FMppv32wHtTADt9LsO/a7Rpscetnx5ARO1kAHo2H8ow1+cZZAJ1FIpZ3h7b5p62BMVFaXPQjhp0iSzsxAKglD/VTmYGjhwINu3b6dLly68+OKLzJo1iy1bthAWFlal4r6CUJ8FBwfTpk0bgoKCjG4vewfY1tEZN29/eg57kn9+WU56YlypvY8AnYB3gDloE1QM4kr467e2GV8wXlpVg5Q8VQl5qnyiUvPLbZPLZFgoZfp1TZIkIUlQcuvfsnZs/YWIU8fwMuMipzoXRMf//p1rZ3z54e1+qPK1xXd9mqSRcGMo2qxmt+nuxJvz8xCjUUJd4WBtwVPd/NhzMYkriabX6hijUMLD/0nh7OH/oir8gZLiQCAES+uvsLbV/r2UHeEqneiiqjSSdCvgKSQU7Q0aG0sFLrYWuNha4mJnibVSgUIuw0IhQ6mQo5TLUGskCopKKCguobC4hIKiEjJvBVGFxcajGGOJI6pyY6l0f/PA6JextP6EosLZgAVyeQZWNtMZ/eoknD0ewa9ZgNGpkF6Nm5Ofoy1jUXrqoIutBSM6+eJmrw2YqpqFUBCEhsPsYOrPP//kkUce4YcfftDPBZ46dSpubm78+++/jBw5ksmTJ9daQwWhrio7T97V1Q1nr0Z0vZX+ODMlgelLfsbNx19/IRN96QxLZ44t9SoqtCMsvwA/At1v/fsyMBv4V/teJkZeqhOkmKKRJFTFFY+2VeUipyr7lq0Bk3DDjaM7JgH9UOWDvXMB/R8/h0+zU6ycF25y2lJFPw8rCzkDWnrQzleMRgl1h4VCziMdfHCzs+To9bQqJWlx9vDmvZ8XUlxUwG/fZnFijxNFhTP58Z0inp6VRNMOBSbXE9WEgiJtcHQzs/zI2p346PmB5Z6r7MaSsf4mbG88l050pKhQW4eqfe9cnpiehp3jm+V+DmX7kufmfIpPYEuD/QLdbRne3qfOJegQBOHeMDubn1KpxMvLi/Hjx/PSSy/RrFmz2m5bjRPZYYSaFBcXR/fu3cvNkz98+DABgU0IuZLCubhMo3eAjWfp0pEDrwHvAw63ntsEvMnsZYv1C8ZLXzSULjpZuqhkRXdt72QNQsXZsbR0FzlV2Xfrso84/PtatCN1HwGP3dqjEG06+U8A7Wha2WlL6YlxPDvnUxxd3E3+PILataz10aiG3s809POrC64l57L7QiJF6uolMTh72J5fv/YkJ117v7TPY5k8OiEVG7vbr3cnf/93S/i+7SbTjpfORFj6XJZMe7LUXtbcHvFXAinAND7f/SFlZzJnpiSyZNoT5aZCzvr6V5w9vPX7dQt0oW8z9zqfPr6+E/2MUJ+YHUzFxsayatUqfvrpJ6KioujXrx8TJ07kySefxMbGprbbWSPEH6dQ01QqlX6evCRJ5ebJn4vLYv+V5HLZuox9cKclxJKfk1lqLy+0KZAnoA2wCuk+JIZRr8qxsddUKUgxduGkC1z6j3qe0VP+r0rnbe5Fjjn7jnh5Lk3bByGTyfjuzU/Jz5mFNtUzgBrt+oYPgFj9MQ8HT+XqqaP62l6SJPHfoa0rbffdWNfZ0PuZhn5+dUVqroo/ztwkM796tdLyc+T88aMHoX9pR2Ad3dSMmZpMh765yGR39vd/N5lKOz572VYkScMfyxdh7+zK6QN/0X/U8zRu1ZENi95E0oxCWzcq8NYRPyOTz+K5N143SAVfmqnU6qBdHzWkrRctvRyMHivULNHPCPWJ2ZVY/P39mTdvHpGRkezdu5fAwEBeffVVfHx8eOWVVzhx4kRttlMQ6iQrKyt9sgZj8+Q7+Dkxtrs/zraGIyG6NQwzv9pMn8eeYeZXm5n44ff619FKAibRc+h8rGxCAWtO7GnJh/9pwo6Vbjwx/WvkCuPTTOQKBcFzF+kf66a9Hd6+ntiI88RdvWAw5S7u6gViI86TnhRPbMQ5vnnjBWIjzpk876BBI5m5dLPRbTOXbja4WKls39+/+5gl0xazeCrk5/yLNpDSABuANminOsYaHJOblUHkuROE79uu/5kFz11k8uehUChYt26dyfMRhLrG3d6KZ3s0JtDdtlrH2zpoGDsriSmLYvFoVER2mpLVH/jyxXRnTv4TV2oK3HaWTHuCE3t+Iz0pviZPoUaV7mcBstOSCdm8kmtnQrlwNATQ9mVyRRc8/a6jrd0XCMQAo4DnmPXVt/q+yVg/p7x1Y0z3PrpAytnWgrHd/UUgJQiCUdXKj/zQQw/x0EMP8fXXX7Nx40ZWr15Nr169aN++PWfOnKnpNgpCvebpaM2zPRqz52IS15Jz9c+XXcPg7OFtMHXt2M5fyExNZOgLA3hqljPnj0Sza403idFW7NvohoXVq7To0pMrYY+jTQ9+28ylm7F1dCY24rzB2gFjtbDKrkHo9/jzVVp/VZV0y4b7yok46YubTzxpCb6l9toGzAPO646idG2XpJhIo2uvmrQPYubSzUbvYj/11FMEBwdXei6CUJdYWygY1bkR/0amcbySAr+mNO9UwH+/i2bvBlf2/mxPbIQn6z55EFgIvENBbgKxEVn8vGjurf171vrUv6pMMSybifDIHxvISk3ix3mv6PcpLioE3MnNfJe1Hz+ItrBxAbqpwTJZYbk1aOauM23ibsew9t5ifZQgCCaZPc3PlOvXr7Ny5Uq+/fZbsrOzKS6u3pSEu0EMGwv3Wnh0BoevpposPFnRNBMAjQYuHLVj789uxEZY33pWhXZN1Y/AYUDCv2V7YiPOl3+DCsjkcoY9P51Dv681a/3VxdD9rHp/Gu6+jek/6gWTawzAcFpj+94TOfibRF7W4+im4CiUJZSofwSWALcXlJfOgrhl6buVnsPsZVuNBlMuLi7s3bsXSZJwd3cnICCgSj+bqmjo/UxDP7+66mpSDn9fTKr2OiqAA1v38/v3jiA9c+uZPLRB1RdANgGtOxF9+QzdHx7Ds68vMPk6d7reSjfFsPOAR8jNTKv0dUr3i+WnN7ujrRc1DbC79dyvWNq8i5e/3GD904vvLkOhVJq1zlQmgx5NXOnd1E0U8b4HRD8j1CfVCqYKCgrYvHkzK1eu5NChQzRp0oQXX3yR8ePH06hR1erf3E3ij1OoCxKzCtl1PoGMaq6FSE+KJzczg5grXvz2LWhK+uq3KZTXkaQf0ZSspFVQc66ePmZ0rVJ1lM2apbsg6vf4fxgz9R2jwR9oL7x+/+4rmnb8hKgLHbh2xk6/TWmZw8Cni2ja/hjfvflYudGtsbM/psdQbaKOsH3b2VjJOq0O3Xrx5lP9y20v+7q1uXaqofczDf386rLUXBU7zibcUUFs7RqkT4HFQJ9bz2YB36INqpIA3Zok4zdSqrPeyljCHAtLa4qLCun84CM8NuF1s+rn3V6D6UL5ICoceIPZy6bjHdCi3I2pOY9VHvgt/vsKNpYKhrf3JsDNrtL9hdoh+hmhPqnSNL9jx46xcuVKfvnlF4qKihgzZgx79+7loYceqq32CUKD4+1kzXM9AzgQkcL5+Cyzj9PdDb52JrTMlu7AROBZStRNgY+BD7h25gBdH4KwvROBKNMvLJOBJCGXK9AYqVpZOh27sbTDpw/8RY+Hx5S78MpMUXLpuB37NgWSnvgn18/b33o/CYXiACXq5VjZHKR976Vkp6feOtaPnsOeZNeapeRmpnHjQjg9hz0BQLdBI/Fu3MzoyNPMrzYz9IHePNDSA69Vq3j55ZdRq9X67brgSalUsnr16op/0IJQR+nWUe29VLV6VOWL14YCfYGn0E6pbQ+8CcwEVgGflUs/fqc1n4ylOddOz4PT+3dyev9OZn39a6Wv49PkSTr0HcOZg17cDqLCgPfQFkCXgOkGN3Xirp7nj+WLGDZuBn+vW1bhDRlfZ2se6eAj6s8JgmA2s4Optm3bcuXKFbp06cKCBQt47rnncHISdVoEoTp0maGauNux91ISBUWVjx7p5vi3CupbZsTpxK2v2cDTaAOrPpSoBxG2F+AGcBH4E/gHOIk2RfAttwKNCR98x/L/e7nc+z7z3wX6RdsV133xAboxcOxqzv9rSXLsreAJr1v/XgVWg7SWErU2oUReFgYXbS/PX45cJke3Rupi6H7irl7QX6zplF2nNbiNJw+3004tHD9+PB07djRaUDk0NJSuXbuWe14Q6gtLpbYeVSNnGw5EpFCiqXyUtfT6oIeemoiDizu2Ds4kxWxGm6jhUeAttCNVrwKTgL3AGsbO7g5Ur+ZTacFzF5nM6qmzZNoTRl+nSCXjzEF7ju5wJupi6ezBJ7gdRBkW2DV2/j5NWppcVzlz6WZGDu5Hv+buKETac0EQqsDsYGrw4MH8/PPPdOrUqTbbIwj3leae9ng7WbP3YhI3UvPKbTd2Nzg+8jLPvv4J6z99o8zeeWjvKq8CWgEj0F4k9QPa3vqac2vfWLRB1UmQXWHg04+hLvYE7G+9zu0LtEvHD9Bt8OMAPD3zSzYv/QFJ4w00ApoCXYFuaIMp+GeT7kgNcAzthc4O4LTJn4NcoUBTUsIXBjViyl+szVt/QL8Yvc8jT3F23zbSkxPo0Nz4GqiyBZUFoaHo5O+Mt5M1O84mkFVQfspwRSNJ4+d9TV5OBivnvXprYPpPtDdb+qMNqoYDQ4GhbPummAtH4+k78gf+/XMqkqb8e5kqJl5a0KCReJkYWTb2OkWFMq6esuXCMTvOHHagIEdxax+JVkGpRF18BTefq3QfMooTe2LISk1k0sc/4uDshtLS0uT5N27VUftmt0bkdTdkHmjlwYCWHhWegyAIgjF3nIDibpk/fz47duzg9OnTWFpakpmZWeXXEHNwhbrsUkI2ByJSDEapzKklBeXXBBlyolW3j1AoRnIxNB9oSYVVEWT5WFkXoSrIB2QgU2Bj54S6WE6xyvTUF5lMwsMvD3ffNJSWBzl7aBaQZlb7Zy/bSlJMpFm1q9RFRbTwdebBVp442ViUq+0FpgsqnzhxAj8/P7PaVF11uZ8R/WjDU1hcwr5LyUQkGU77M6fv0N2YaNm1D/s2fl9qS1PghVtfTfTPWtkUoSr4A+2o1T60o83av19dMfGKmKoZpeMTOIy2veaTcKMlV0/bUqy63U+5eBXT+5EsegzNwtG1pNJkPeac/5Mz3ufU3q3kpiUSFhZW632DYD7Rzwj1Sb0Jpt59912cnZ2Ji4tjxYoV4iJAaJAKiko4EJHMpQTthVFFBW8BXL39GPj0yyaK/t5m7+zG45PfvDWa5QB0BIKArjRq9iiqAkdyMpSoCiovPae9oLoKxKMd4ToDnGD6krf4atbjZp1n2Wl6uouxigp0+rVoh5u9JQ+08CDQvfKF4ZUVVK4tdbmfEf1ow3XxZjYhV5L12f7MKazdqf8wFBYWZKUmsfDlRynMzy2zpwzoD7LxWFg8R3FR2b+fGOA0QYPa0LSDI55+RXj6F2HrWIKxkm8ZyYksmTYeK5smpCXkoh1B71Lqy3DpgItnMW175dG+dy4tOucjr0J28orOXyaXEzznU2a+8hJd/J0pLi6+K32DYD7Rzwj1Sb0JpnRWr17NzJkzxUWA0KDdSM3jn8vJZBcUmwwwZnyxiYA2nfTBQlpCLF/NepacjNRKX//JGe8bTWV+7K+/2PzlMiSNHdqpfppS/6po0bkJz77xjj7Neem0w7O+/pXIs8crXRdROt152TbozrVssDX3+994etgDdPZzRl7H1zPUh35G9KMNU1Z+MbsuJHAzU5vYobKbE6Wpi4pIiIrQr1squ79P03ZcCs1j3Sd/IZMNpljVFY3G9EoBhVLCwkqDhZWEhaWGwvwS8rMtqHh1gQq54iy9H7GlSfsEAtoocPOufoZgU+f/3so/ePWJwXg6Whs5SqgLRD8j1CfVKtpbX6hUKlQqlf5xdnb2PWyNIJivibsdL/QO4GR0Btuua0eLygYYyltTXHTb3H0b887aEE4f2mUyhbhMLufZ1z+h2+DH6f3oWP3UmNLZvmZ99anJqTgJUZnkZqYxft7XOLp54ObtZ/A6nv5N8G3ahrir5Wtc6RaHT1/yM24+/shkMoNjoXyBzuO7t5CblsSEwZ1p0dil3GsKtU/0o/WHk60FTwX5czwqndDrt4v8mlNYW3lrFNfU/goFtO9jx0dbRqKwsKBYdYPoS1bsXreP6+eysbLpiqrADwgA5JSoZZSoFRSWXwqKpbUGO0c1GcnHgFOlvi6iKVFz5A848od234qSWpir7PkMb+8tAilBEGpMgw6mFixYwPvvv3+vmyEI1WKhkNOzqRvOgzvxg7sH9q7eBqM5ZTNWgfaCqKIU4rO+2qK/Iy2TyfRBTOlsX92HjDbZJmPZu8q+ji6QKnvh9tycT/EJbGmwrqH0sQDOHt68szYEC0tL2jdyYsUnb2Ill8QUnHtI9KP1i1wuo1dTN5p52LOpIN3g5kRFfQeUv5lhbP/SyR2KVSkk3JgDZKMqlAES1nYePPjUdE7vP0CXB58ArAnbu4/stGhUBTewc4LJH3+FJElcPx/OH8s/rXAq4p0ofT6DRj3D6T1bSUyIx9fHu/KDBUEQzGTWNL+lS5ea/YIzZswwe98333yTTz/9tMJ9Ll26ROvWrfWPqzI9xdgdVX9/fzFsLNQ7KpWKzEINh66lEZOWZ7Q4bmmmpsuVnt5jrIimvbMbz76+gPUL52BpZUNWWhKSkSx4Mrmc5974lKBBI42+jkwmw9O/Ge37DOJi6H5yM9MMphOaIpNBa28HejV1w9nW9PnVZXd7eoroRwVTNBqJ0GtJhMflUFwimSysXVpliR3A/MQ45pi9bKvZUxGrQ1IX06uFFz2buiGXcdfWTgp3RkzzE+oTs0amlixZYvA4JSWF/Px8nJ2dAcjMzMTW1hZPT88qBVP//e9/GT9+fIX7NG3a1OzXK8vKykp0mkKDYGVlhZcVPBnkR3xmAcdvpBGVmm9yf3PuMJuqG7P8/yYBkE+myQudzg8Mr7D2lCRJJMVcIynmGgAL/zxX4QWchUJGW19HujZ2qbdB1L0i+lHBFLlcRu+W3rT1d+Ofy0lEpeZX+HcIlBs5Toi6op8C7N+yA2BezSgAhYUFJcXlU6lD+ZEnc6YigmEBYl17TGnsasuDrTxws7/9+yt+lwVBqGlmBVM3btzQf79hwwa++eYbVqxYQatW2rtTV65c4eWXX2by5MlVenMPDw88PERdB0GoikbONozu4kdSdiHHb6QTmZJL2WsP3XQ53R3msmuToOILosqm2FwOP6wvpvv4K/+rdKqOqQs4OysFnfyc6ejnjI1lFVJ1CXqiHxUq42RjwegufkQk5XD4aqrRulSmlJ4CDOgDGVPFb0szFUiBtkiuX4t2ZKYkVmkqYun2mAqmnGwseKClO809Hcw8S0EQhOqr8pqpd955hy1btugDKYBWrVqxZMkSnnzySYKDg2u0gToxMTGkp6cTExNDSUkJp0+fBqB58+bY29vXynsKQl3m5WjNiE6+pOWqOBufxeWEHAqLbwc0Fa1NgoqLaJa+0DGmICfL4DhTI1i61ylNJgM/F1va+jjS0ssepaLydOxCzRD96P2tpZcDTd3tOB2byfGodFTFxgtZmyp4m5ORxrUzoRzevoH+j/+nRtpkzo2figoQS5KEnZMLrl6NsFDI6B7oSlCAi+hXBEG4a6ocTCUkJKBWq8s9X1JSQlJSUo00yph58+bx008/6R936dIFgJCQEB588MFae19BqOvc7K14qJUn/Zu7cy0ll/Px2cRl5JcbraqIqSk2zh7ePPPfBfzyxf+ZNYJV0VQdJxsL2vo60sbHEScb08V/hdoj+lFBqZDTLdCVdr5OHLuextm4LDRl/lZNTQE+fWAnACf+3krnB4Zh6+iMvZMrWWnJ2v5BJlFcWFjh++uyepZNaqFj7MaPqfaUvoHzz+Ukuge6Ym/VoPNqCYJQB1W5ztSIESOIj4/nxx9/pGvXrgCEh4czadIkGjVqxPbt22uloTVBLGgU7hdZ+cVcS8nhRmo+NzMLKNEY/zPPTEk0WTOqdLKIyurVmHqdj376g25tmhPoboePk7U+9XJD1tD7mYZ+fvebrPxiwmPSuRCfjfpWP1FZsfCyFv55DrlSSczlsyydObbCdU+zvv61XFbPylTUHoVCyfc/rmDC+BfMfj2h7hP9jFCfVPkWzsqVKxk3bhzdunXDwkJ7d1mtVjN06FB+/PHHGm+gIAhV52RrQVCAK0EBrqjUJUSn5XMjNY/4jAKD9RLmTLEpraIRrHfWhuDqaIu3kw3z3piBr6MFbo52tX6ugiBUn5OtBQNbe9GziRunYjI5E5dZ4RTg0squiXT28Navf+rQdwi71iwFJIaPm8nZw3+TmZKAg4t7lQIpqHhK8vHjofobu4IgCPdClYMpDw8Pdu7cSUREBJcvXwagdevWtGzZssYbJwjCnbNSKmjp5UBLL+1i7MLiElJyVCTnFJKcrSIjv5j8IjV5qhI0YPRCp3R2wN6PPMXxXZvJSEmkU4vGtGnhjpeDNZ6OVlhbiCQSglAf2Vkp6dfCnW6BLly4mcXOeO3N0opGmcquiSx7c2bAmPEAWFhZMXDsy5WmZTeHrj1yuRyNkbINgiAId1u1JxcHBgYiSRLNmjVDqRRzlAWhvrC2UODvaou/q63B85IkUVBcQp6qBJW6BJlMhm5Snkzmz8Qh13BxsMXOSgmL/0/UaxGEBsjaQkFQgCtegzvztacXLp4+NOnUm13rv9XvU1GAVTpYsijVPxhbC1WZ2Ihz7FjxGa+99R7PP9SBDd7e+Pv7M2HCBFasWEFsbCyenp5VPENBEISaVeUoKD8/n+nTp+sXMUdERNC0aVOmT59Oo0aNePPNN2u8kYIg1D6ZTIatpRJbS1Pdgo3BIxFICULD5efnR0xMNJaWlsTExtFtz6+4enjT59Gx7PttY4Xpy++Uu70lTT3sOb9lHxGnjnHl8E6mPPUlUVFRWFpaIpPJmDRpkrihIwhCnVDlYOqtt97izJkz7N+/n2HDhumfHzx4MO+9954IpgRBEAShAdAFKgGN/YmLidEHMjnvv0FkQibJ+SWk5RWRnldEkbp6U+6sLOR4Oljj4WCFp4MV6qxkivLSkGWn8+dvvwKwceNGxo0bhyRJuLu7ExAQgEwmE4GUIAh1QpWDqd9++41NmzbRq1cvg8xc7dq1IzIyskYbJwiCIAjCvVc6cHGwtqBzE8NC0XkqNel5RWTmF6NSl1BcIqHWaFCXSKg1Ekq5DGsLBTaWCmwstF9OthblyiTIfJ1uf3/rGiMlJYWgoCD981VMQiwIglCrqhxMpaSkGJ2jnJeXd1+kPRYEQRAEwZCdlRI7KyX+rnf2OuvWrWP8+PGo1Wp90KT7V6lUsnr16jtsqSAIQs2qconwbt26sWPHDv1jXQD1448/0rt375prmSAIgiAI95Xg4GBCQ0ONbgsNDSU4OPgut0gQBKFiVR6Z+vjjjxk+fDgXL15ErVbz5ZdfcvHiRf79918OHDhQG20UBEEQBOE+o0t/LtKgC4JQl1V5ZKpfv36cPn0atVpNhw4d+Pvvv/H09OTo0aMGc5oFQRAEQRCqytPTE29vb4KCgvjuu+8ICgrC29tbpEEXBKFOkkn30UrO7OxsnJycyMrKwtHR8V43RxCEBqih9zP/z959h0dR7X8cf+9ueu8JkNB7lS4iNhDFguXauQL2q6hXUBF/2BsKXguKXjsWvKgIYsGCCChIb4L0HkogvWdTdn5/LBtSNsluSOfzep55QmZnZr8nZE/mzDnne5p6+aRhsFqtxdkDDcNQGvTTjOoZaUzc7pkaNmwYM2fOJCMjozbiERERkdOct7d38ZxspUEXkYbM7cZUt27dePTRR4mJieHaa69l/vz5FBQU1EZsIiIiIiIiDZbbjanXX3+dw4cP88033+Dv78/o0aOJjo7mzjvvVAIKERERERE5bbjdmAJ7hp3hw4czc+ZMjh07xjvvvMPq1au54IILajo+ERERERGRBsnt1OglJSQkMHv2bD777DP++usvBgwYUFNxiYiIiIiINGhu90xlZGTw0UcfceGFFxIXF8fbb7/NyJEj2bVrFytXrqyNGEVERERERBoct3umoqOjCQ0N5frrr2fKlCn069evNuISERERERFp0NxqTBmGwfTp0xk1ahR+fn61FZOIiIiIiEiD59YwP8MwGDduHIcPH66teERERERERBoFtxpTZrOZDh06kJycXFvxiIiIiIiINApuJ6B48cUXefjhh9myZUttxCMiIiIiItIouJ2AYvTo0eTk5NCrVy+8vLzw9fUt9XpKSkqNBSciIiIiItJQud2Yeu2112ohDBERERERkcbF7cbUmDFjaiOOSu3fv59nn32W3377jYSEBJo3b84///lPJk+ejJeXV53HIyLS2KgeFRERqXluN6YA9uzZw0cffcSePXt4/fXXiYqK4scff6Rly5Z069atpmNk+/bt2Gw23nnnHdq3b8+WLVu44447yM7O5uWXX67x9xMRaWpUj4qIiNQ8k2EYhjsnLF26lBEjRjB48GB+//13tm3bRtu2bXnxxRdZu3Ytc+bMqa1YS5k2bRpvv/02e/fudfmcjIwMgoODSU9PJygoqBajE5HTVWOqZ1SPikhDpHpGGhO3s/lNmjSJ5557joULF5YaGnLBBRewcuXKGg2uMunp6YSFhVV6jNVqJSMjo9QmIiJ2qkdFREROjduNqc2bN3PVVVeV2x8VFUVSUlKNBFWV3bt388Ybb3DXXXdVetyUKVMIDg4u3uLi4uokPhGRhk71qIiIyKlzuzEVEhLC0aNHy+3fsGEDLVq0cOtakyZNwmQyVbpt37691DmHDx/m4osv5tprr+WOO+6o9PqPPvoo6enpxVt8fLxb8YmINHSqR0VEROqP23OmHnroIVatWsVXX31Fx44dWb9+PceOHWP06NGMHj2aJ5980uVrJSYmkpycXOkxbdu2LR5OeOTIEc477zzOPPNMZs6cidnsXltQY3BFpLbVdT2jelREmhrVM9KYuJ3N74UXXmDcuHHExcVRVFRE165dKSoq4qabbuKxxx5z61qRkZFERka6dOzhw4c5//zz6du3Lx999JHbNwAiIk2R6lEREZH643bPlEN8fDybN28mKyuL3r1706FDh5qOrdjhw4c577zzaNWqFR9//DEWi6X4tZiYGJevoycdIlLbGmo9o3pURBoL1TPSmFRrnSmAuLi44t6pzZs3k5qaSmhoaE3GVmzhwoXs3r2b3bt3ExsbW+q1arYFRUROK6pHRUREap7bYzweeOABPvjgAwCKioo499xz6dOnD3FxcSxZsqSm4wNg7NixGIbhdBMRkaqpHhUREal5bjem5syZQ69evQD47rvv2Lt3L9u3b2f8+PFMnjy5xgMUERERERFpiNxuTCUlJRWPr1+wYAHXXXcdHTt25NZbb2Xz5s01HqCIiIiIiEhD5HZjKjo6mq1bt1JUVMRPP/3EhRdeCEBOTk6pCc0iIiIiIiJNmdsJKG655Rauu+46mjVrhslkYtiwYQCsWrWKzp0713iAIiIiIiIiDZHbjamnnnqK7t27Ex8fz7XXXou3tzcAFouFSZMm1XiAIiIiIiIiDVG1UqNfc8015faNGTPmlIMRERERERFpLNyeMwWwaNEiLrvsMtq1a0e7du247LLL+PXXX2s6NhERERERkQbL7cbUW2+9xcUXX0xgYCD//ve/+fe//01QUBCXXHIJM2bMqI0YRUREREREGhy3h/m98MILvPrqq9x7773F++6//34GDx7MCy+8wLhx42o0QBERERERkYbI7Z6ptLQ0Lr744nL7hw8fTnp6eo0EJSIiIiIi0tC53ZgaOXIk8+bNK7d//vz5XHbZZTUSlIiIiIiISEPn0jC/6dOnF/+7a9euPP/88yxZsoRBgwYBsHLlSpYvX86DDz5YO1GKiIiIiIg0MCbDMIyqDmrTpo1rFzOZ2Lt37ykHVVsyMjIIDg4mPT2doKCg+g5HRJqgpl7PNPXyiUj9Uz0jjYlLPVP79u2r7ThEREREREQalWqtMwWQlJREUlJSTcYiIiIiIiLSaLjVmEpLS2PcuHFEREQQHR1NdHQ0ERER3HvvvaSlpdVSiCIiIiIiIg2Py+tMpaSkMGjQIA4fPsyoUaPo0qULAFu3bmXmzJksWrSIP//8k9DQ0FoLVkREREREpKFwuTH1zDPP4OXlxZ49e4iOji732vDhw3nmmWd49dVXazxIERERERGRhsblYX7ffPMNL7/8crmGFEBMTAxTp051uv6UiIiIiIhIU+RyY+ro0aN069atwte7d+9OQkJCjQQlIiIiIiLS0LncmIqIiGD//v0Vvr5v3z7CwsJqIiYREREREZEGz+XG1EUXXcTkyZPJz88v95rVauXxxx/n4osvrtHgREREREREGiq3ElD069ePDh06MG7cODp37oxhGGzbto233noLq9XKp59+WpuxioiIiIiINBguN6ZiY2NZsWIF99xzD48++iiGYQBgMpm48MILefPNN4mLi6u1QEVERERERBoStxbtbdOmDT/++CNJSUmsXLmSlStXkpiYyE8//UT79u1rK0YARo4cScuWLfHx8aFZs2bcfPPNHDlypFbfU0SkKVE9KiIiUrPcakw5hIaGMmDAAAYMGFBnSSfOP/98vvzyS3bs2MHXX3/Nnj17uOaaa+rkvUVEmgLVoyIiIjXLZDjG6zUy3377LVdeeSVWqxVPT0+XzsnIyCA4OJj09HSCgoJqOUIROR01pnpG9aiINESqZ6QxcXnOVEOSkpLCrFmzOOussyq9AbBarVit1uLv09PTAfuHVESkNjjql4b+nEr1qIg0VI2lHhUBwGhEJk6caPj5+RmAceaZZxpJSUmVHv/kk08agDZt2rTV+RYfH19HNaN7VI9q06atsWwNtR4VKaleh/lNmjSJl156qdJjtm3bRufOnQFISkoiJSWFAwcO8PTTTxMcHMz333+PyWRyem7ZJ6o2m42UlBTCw8MrPKesjIwM4uLiiI+Pb/RdzSpLw9SUygJNqzzVKYthGGRmZtK8eXPM5mpNS3WL6tG6pbI0TE2pLNC0ytMY6lGRU1GvjanExESSk5MrPaZt27Z4eXmV23/o0CHi4uL4888/GTRoUG2F2KTG7aosDVNTKgs0rfI0hrKoHq1bKkvD1JTKAk2rPE2pLCLO1OucqcjISCIjI6t1rs1mAyj1xFRE5HSjelRERKT+NIoEFKtWrWLNmjWcffbZhIaGsmfPHh5//HHatWtXq09TRUSaCtWjIiIiNa9RDET18/Nj7ty5DB06lE6dOnHbbbfRs2dPli5dire3d62+t7e3N08++WStv09dUFkapqZUFmha5WlKZVE9WjNUloapKZUFmlZ5mlJZRJxptOtMiYiIiIiI1KdG0TMlIiIiIiLS0KgxJSIiIiIiUg1qTImIiIiIiFSDGlMiIiIiIiLVoMYUMGPGDFq3bo2Pjw8DBw5k9erVlR7/1Vdf0blzZ3x8fOjRowcLFiyoo0ir5k5Z3nvvPYYMGUJoaCihoaEMGzasyrLXJXf/Xxxmz56NyWTiyiuvrN0A3eBuWdLS0hg3bhzNmjXD29ubjh07NpjfM3fL8tprr9GpUyd8fX2Ji4tj/Pjx5OXl1VG0Ffv999+5/PLLad68OSaTiW+++abKc5YsWUKfPn3w9vamffv2zJw5s9bjbCxUj6oerW1NqR4F1aWqS6XJME5zs2fPNry8vIwPP/zQ+Pvvv4077rjDCAkJMY4dO+b0+OXLlxsWi8WYOnWqsXXrVuOxxx4zPD09jc2bN9dx5OW5W5abbrrJmDFjhrFhwwZj27ZtxtixY43g4GDj0KFDdRx5ee6WxWHfvn1GixYtjCFDhhhXXHFF3QRbBXfLYrVajX79+hmXXHKJsWzZMmPfvn3GkiVLjI0bN9Zx5OW5W5ZZs2YZ3t7exqxZs4x9+/YZP//8s9GsWTNj/PjxdRx5eQsWLDAmT55szJ071wCMefPmVXr83r17DT8/P2PChAnG1q1bjTfeeMOwWCzGTz/9VDcBN2CqR1WP1ramVI8ahupS1aXSlJz2jakBAwYY48aNK/6+qKjIaN68uTFlyhSnx1933XXGpZdeWmrfwIEDjbvuuqtW43SFu2Upq7Cw0AgMDDQ+/vjj2grRZdUpS2FhoXHWWWcZ77//vjFmzJgGcxPgblnefvtto23btkZ+fn5dhegyd8sybtw444ILLii1b8KECcbgwYNrNU53uXIDMHHiRKNbt26l9l1//fXGRRddVIuRNQ6qR09SPVo7mlI9ahiqS1WXSlNyWg/zy8/PZ926dQwbNqx4n9lsZtiwYaxYscLpOStWrCh1PMBFF11U4fF1pTplKSsnJ4eCggLCwsJqK0yXVLcszzzzDFFRUdx22211EaZLqlOWb7/9lkGDBjFu3Diio6Pp3r07L7zwAkVFRXUVtlPVKctZZ53FunXrioev7N27lwULFnDJJZfUScw1qaF+9uub6tHSVI/WvKZUj4Lq0ob6+RepLo/6DqA+JSUlUVRURHR0dKn90dHRbN++3ek5CQkJTo9PSEiotThdUZ2ylPXII4/QvHnzcpVcXatOWZYtW8YHH3zAxo0b6yBC11WnLHv37uW3335j1KhRLFiwgN27d3PPPfdQUFDAk08+WRdhO1Wdstx0000kJSVx9tlnYxgGhYWF/Otf/+L//u//6iLkGlXRZz8jI4Pc3Fx8fX3rKbL6pXq0NNWjNa8p1aOgulR1qTQ1p3XPlJz04osvMnv2bObNm4ePj099h+OWzMxMbr75Zt577z0iIiLqO5xTZrPZiIqK4t1336Vv375cf/31TJ48mf/+97/1HZrblixZwgsvvMBbb73F+vXrmTt3Lj/88APPPvtsfYcmUuNUjzYcTakeBdWlIg3Zad0zFRERgcVi4dixY6X2Hzt2jJiYGKfnxMTEuHV8XalOWRxefvllXnzxRX799Vd69uxZm2G6xN2y7Nmzh/3793P55ZcX77PZbAB4eHiwY8cO2rVrV7tBV6A6/y/NmjXD09MTi8VSvK9Lly4kJCSQn5+Pl5dXrcZckeqU5fHHH+fmm2/m9ttvB6BHjx5kZ2dz5513MnnyZMzmxvM8p6LPflBQ0Gn9JFX1qJ3q0drTlOpRUF2qulSamsbz6asFXl5e9O3bl0WLFhXvs9lsLFq0iEGDBjk9Z9CgQaWOB1i4cGGFx9eV6pQFYOrUqTz77LP89NNP9OvXry5CrZK7ZencuTObN29m48aNxdvIkSM5//zz2bhxI3FxcXUZfinV+X8ZPHgwu3fvLr6RAdi5cyfNmjWr1xuA6pQlJyen3B95x82NYRi1F2wtaKif/fqmelT1aG1rSvUoqC5tqJ9/kWqr3/wX9W/27NmGt7e3MXPmTGPr1q3GnXfeaYSEhBgJCQmGYRjGzTffbEyaNKn4+OXLlxseHh7Gyy+/bGzbts148sknG1RKX3fK8uKLLxpeXl7GnDlzjKNHjxZvmZmZ9VWEYu6WpayGlIXK3bIcPHjQCAwMNO69915jx44dxvfff29ERUUZzz33XH0VoZi7ZXnyySeNwMBA43//+5+xd+9e45dffjHatWtnXHfddfVVhGKZmZnGhg0bjA0bNhiA8corrxgbNmwwDhw4YBiGYUyaNMm4+eabi493pPN9+OGHjW3bthkzZsxQOt8TVI+qHq1tTakeNQzVpapLpSk57RtThmEYb7zxhtGyZUvDy8vLGDBggLFy5cri184991xjzJgxpY7/8ssvjY4dOxpeXl5Gt27djB9++KGOI66YO2Vp1aqVAZTbnnzyyboP3Al3/19Kakg3AYbhfln+/PNPY+DAgYa3t7fRtm1b4/nnnzcKCwvrOGrn3ClLQUGB8dRTTxnt2rUzfHx8jLi4OOOee+4xUlNT6z7wMhYvXuz0998R/5gxY4xzzz233DlnnHGG4eXlZbRt29b46KOP6jzuhkr1qOrR2taU6lHDUF2qulSaCpNhNLL+YRERERERkQbgtJ4zJSIiIiIiUl1qTImIiIiIiFSDGlMiIiIiIiLVoMaUiIiIiIhINagxJSIiIiIiUg1qTImIiIiIiFSDGlMiIiIiIiLVoMaUiIiIiIhINagxJSIiIiIiUg1qTImIiIiIiFSDGlMiIiIiIiLVoMaUiIiIiIhINagxJSIiIiIiUg1qTImIiIiIiFSDGlMiIiIiIiLVoMaUiIiIiIhINTSaxtTbb79Nz549CQoKIigoiEGDBvHjjz/Wd1giIo2K6lIREZGaYzIMw6jvIFzx3XffYbFY6NChA4Zh8PHHHzNt2jQ2bNhAt27d6js8EZFGQXWpiIhIzWk0jSlnwsLCmDZtGrfddlt9hyIi0mipLhUREakej/oOoDqKior46quvyM7OZtCgQRUeZ7VasVqtxd/bbDZSUlIIDw/HZDLVRagicpoxDIPMzEyaN2+O2dywR1K7UpeqHhWRutaY6lGRRtWY2rx5M4MGDSIvL4+AgADmzZtH165dKzx+ypQpPP3003UYoYiIXXx8PLGxsfUdhlPu1KWqR0WkvjTkelTEoVEN88vPz+fgwYOkp6czZ84c3n//fZYuXVrhTUDZJ6rp6em0bNmS+Ph4goKC6ipsETmNZGRkEBcXR1paGsHBwfUdjlPu1KWqR0WkrjWGelTEoVE1psoaNmwY7dq145133nHp+IyMDIKDg0lPT9dNgIjUisZYz7hTlzbG8olI46J6RhqTRj0Q1WazlXpiKiIi7lNdKiIiUj2NZs7Uo48+yogRI2jZsiWZmZl8/vnnLFmyhJ9//rm+QxMRaTRUl4qIiNScRtOYOn78OKNHj+bo0aMEBwfTs2dPfv75Zy688ML6Dk1EpNFQXSoiIlJz3G5M7du3jz/++IMDBw6Qk5NDZGQkvXv3ZtCgQfj4+NRGjAB88MEHtXZtEZHThepSERGRmuNyY2rWrFm8/vrrrF27lujoaJo3b46vry8pKSns2bMHHx8fRo0axSOPPEKrVq1qM2YREREREZF651Jjqnfv3nh5eTF27Fi+/vpr4uLiSr1utVpZsWIFs2fPpl+/frz11ltce+21tRKwiIiIiIhIQ+BSavSff/6Ziy66yKULJicns3//fvr27XvKwdU0pdoUkdrW1OuZpl4+Eal/qmekMXGpZ8rVhhRAeHg44eHh1Q5IRERERESkMXCpMZWRkeHyBfUEQURERERETgcuNaZCQkIwmUwuXbCoqOiUAhIREREREWkMXGpMLV68uPjf+/fvZ9KkSYwdO5ZBgwYBsGLFCj7++GOmTJlSO1GKiIiIiIg0MC41ps4999zifz/zzDO88sor3HjjjcX7Ro4cSY8ePXj33XcZM2ZMzUcpIiIiIiLSwJjdPWHFihX069ev3P5+/fqxevXqGglKRERERESkoXO7MRUXF8d7771Xbv/7779fbv0pERERERGRpsqlYX4lvfrqq/zjH//gxx9/ZODAgQCsXr2aXbt28fXXX9d4gCIiIiIiIg2R2z1Tl1xyCbt27eLyyy8nJSWFlJQULr/8cnbu3Mkll1xSGzGKiIiIiIg0OG73TAHExsbywgsv1HQsIiIiIiIijUa1GlNpaWl88MEHbNu2DYBu3bpx6623EhwcXKPBiYiIiIiINFRuD/Nbu3Yt7dq149VXXy0e5vfKK6/Qrl071q9fXxsxioiIiIiINDhu90yNHz+ekSNH8t577+HhYT+9sLCQ22+/nQceeIDff/+9xoMUERERERFpaNxuTK1du7ZUQwrAw8ODiRMnOl1/SkREREREpClye5hfUFAQBw8eLLc/Pj6ewMDAGglKRERERESkoXO7MXX99ddz22238cUXXxAfH098fDyzZ8/m9ttv58Ybb6yNGEVERERERBoct4f5vfzyy5hMJkaPHk1hYSEAnp6e3H333bz44os1HqCIiIiIiEhD5HZjysvLi9dff50pU6awZ88eANq1a4efn1+NByciIiIiItJQVWudKQA/Pz9CQ0OL/y0iIiIiInI6cXvOlM1m45lnniE4OJhWrVrRqlUrQkJCePbZZ7HZbLURo4iIiIiISIPjds/U5MmT+eCDD3jxxRcZPHgwAMuWLeOpp54iLy+P559/vsaDFBERERERaWjc7pn6+OOPef/997n77rvp2bMnPXv25J577uG9995j5syZtRCi3ZQpU+jfvz+BgYFERUVx5ZVXsmPHjlp7PxGRpkb1qIiISM1yuzGVkpJC586dy+3v3LkzKSkpNRKUM0uXLmXcuHGsXLmShQsXUlBQwPDhw8nOzq619xQRaUpUj4qIiNQsk2EYhjsnDBw4kIEDBzJ9+vRS+++77z7WrFnDypUrazTAiiQmJhIVFcXSpUs555xzXDonIyOD4OBg0tPTCQoKquUIReR01JjqGdWjItIQqZ6RxsTtOVNTp07l0ksv5ddff2XQoEEArFixgvj4eBYsWFDjAVYkPT0dgLCwsAqPsVqtWK3W4u8zMjJqPS4RkcZC9aiIiMipcXuY37nnnsvOnTu56qqrSEtLIy0tjauvvpodO3YwZMiQ2oixHJvNxgMPPMDgwYPp3r17hcdNmTKF4ODg4i0uLq5O4hMRaehUj4qIiJw6t4f5NQR33303P/74I8uWLSM2NrbC45w9UY2Li1O3sYjUmsYyPEX1qIg0VI2lHhWBai7am5aWxurVqzl+/Hi5taVGjx5dI4FV5N577+X777/n999/r/QGAMDb2xtvb+9ajUdEpLFRPSoiIlIz3G5Mfffdd4waNYqsrCyCgoIwmUzFr5lMplprTBmGwX333ce8efNYsmQJbdq0qZX3ERFpqlSPioiI1Cy3G1MPPvggt956Ky+88AJ+fn61EZNT48aN4/PPP2f+/PkEBgaSkJAAQHBwML6+vnUWh4hIY6V6VEREpGa5PWfK39+fzZs307Zt29qKyamSPWAlffTRR4wdO9ala2gMrojUtoZcz6geFZHGQPWMNCZu90xddNFFrF27ts4bU40wT4aISIOielRERKRmudSY+vbbb4v/femll/Lwww+zdetWevTogaenZ6ljR44cWbMRioiIiIiINEAuNaauvPLKcvueeeaZcvtMJhNFRUWnHJSIiIiIiEhD51Jjqmz6cxERERERkdOdub4DEBERERERaYxc6pmaPn06d955Jz4+PkyfPr3SY++///4aCUxERERERKQhcyk1eps2bVi7di3h4eGVLvJoMpnYu3dvjQZYk5RqU0RqW1OvZ5p6+USk/qmekcbEpZ6pffv2Of23iIiIiIjI6UpzpkRERERERKrBpZ6pCRMmuHzBV155pdrBiIiIiIiINBYuNaY2bNjg0sVMJtMpBSMiIiIiItJYuNSYWrx4cW3HISIiIiIi0qhUe87U7t27+fnnn8nNzQXAhaSAIg3e2rVrueCCC1i7dm19hyIiIiIiDZzbjank5GSGDh1Kx44dueSSSzh69CgAt912Gw8++GCNByhSlz755BMWL17Mp59+Wt+hiIiIiEgD53Zjavz48Xh6enLw4EH8/PyK919//fX89NNPNRqcSF04cOAA69atY/369XzxxRcAzJ49m/Xr17Nu3ToOHDhQzxGKiIiISEPkdmPql19+4aWXXiI2NrbU/g4dOuimUxqUqobsOV5v3bo1/fr1o2/fviQmJgKQmJhI37596devH61bt67DqEVERESksXApAUVJ2dnZpXqkHFJSUvD29q6RoERqQskhe/369avw9eHDh/Pbb79RWFhYPPfP8dXDw4OZM2fWZdgiTc6xjDx+2XqMAG8LAd6eBHh7EOjjgb+3B/7eFgK8PfD1tCgjrIiINDpuN6aGDBnCJ598wrPPPgvY06HbbDamTp3K+eefX+MByunLMAyy84vIthaSk19EXkERuQX2r9YCG9bCIvKLDAqLbBQU2cgvMjh2OJ70tBQMA2Z++jkAH34yC58u52NgUJhvxcPLG7PJzEcnXl+xeh2jJ03lw+fKr6f2/MxvCejWkx/+OoqHxYSnxYSH2YynxYyXhwlPi7l48/Yw4+Vhxsty4quHfb/I6a7QZpCUaSUps+JjLGYTfl72hpW/t0fxV0djK8DbgwAfD7w9LFW+39q1a5k4cSJTp051+iClps4RERFxuzE1depUhg4dytq1a8nPz2fixIn8/fffpKSksHz58tqIURqwU7lpeemll+jY/QwycgtIyykgLTef9NwCMvMKybYWkm0twuZmlsiHrxlSbl9WWjJT776qwnMy05LLNaRMJhOGYXAsPQ/PxGy3YgCI37mZ796bxhV3TqRDt154e5jx9rTYv3pY8PE04+Np/+rtYcHXy4Kv54nNy4KPZ9U3jCJNSZHNIDOvkMy8wlL7HZ+ly+94mLiOPfDyMBf3bAX6eBLk+OrrQZCvJ4HeHlX2SjtTnXNERETcbkx1796dnTt38uabbxIYGEhWVhZXX30148aNo1mzZrURozRgrt6AZFkLScy0kpxl5dlX/8vixYt5eMqbXHH35BqNZ9Qj0/jfy5OwFRWVe81ssXDmiOtY+eOXTl8HCIuJ5YLr7mDVT3NISzxKQEh4teJYs3A+uzetYvXCb2jRoTs5+UVAgcvnW8ym4oaVv7cFPy8P/L088PO2EHjiCb2/twcBXh6YzRoaJU2X47O09tf5xHXsQX6hjZTCfFKy80sdl3LsMNnpqVgsZmZ+Zu91/uSzzxkw/CoCfTxo3SKa7h3bl/q8HDhwgKSkJEwmU6nkM2PGjMEwDCIiImjVqlXdFVZERBodk+HmAlGLFy+ucDjfjBkzGDduXI0EVhsyMjIIDg4mPT2doKCg+g6n0Sp5AzJixAiOHz9OVFQUP/74I4ZhEBgSik9IDAkZeSRk5HEsPY+DBw+QnZ6KyWTi3cm3k5WWQkBIOHc+/x6GYeAfHEpYdIsaie/Qrr95ZdzV5fZPmDGX2A7dKnz9/te+oFWXXsW9UkUFBXh4ebn8vo6bubooo4PZZMLf20KgjwdBPp4E+3oS5OtJkI8nIf72p/T1NQ/ldB021dTrmeqUb8HiZfx7/EPFvUtVqeqzlJ58nN/nzix1vQnDO1V53dd/3UmInyehfl6E+3sxuENk8WuOz73jq4PWUBSpe029HpWmxe2eqauvvppff/2Vvn37ltr/+uuv8/jjjzfoxpTUjJLZ7Rw36sdPZL9zeOWXHaXOee7mC8pdJystuVSjpuw5JZUd6uOKim6OKnrdw9OzuDwmk8mthhScehmrw2acHBp1hLxyr3taTAT7eRHq50mYnxdhAV6E+3sT5u+FpZZ7tDRsShzmzP68VO9SVVz5LAGlrldVr/SND71Ikc0gOSuf5Kx8djvOmTYJm61IyWdERKRa3J4dP23aNEaMGMH27duL9/3nP//hiSee4IcffqjR4KRh+uSTT/HwsLfDixspJ76aLRYuHn0/bz08mvidm4vPGfXINMwW5/OAzBYLox6ZVul7lhzqU5WAkHACQyOI7dCda+5/mtgO3QkMjSgeslfV69V1qmV0VfzOzeV+vhUpKLJP/N91LItV+1L4cXMCn608wIzFu/l05QF+2nKUdQdSOJSaQ36h7ZRj05pd4lDyd+HbuXMA2LBkAYd2/U38zi2kHDtc4bmVfZZMZjPefgHlrteme18emP6V03MemP4VfYeOLLe/79CR9BxykdNzmrXtzN/Z/nyz4TB/7kliT2IWWdZCp8eKiMjpy+1hfmBPQjF9+nSWLVvGF198wQsvvMCCBQsYPHhwbcRYY9RtXH25+UXsTcpif1IOB1Ky2bN1c4VD6Vb/Mo9l8z9lyJU3c9U9jxW/VtXwu7JOZdhcYX4+lhM9Tc6G7FX1enW5W8bqmDvjOac/31NlNpkI8/ckOsiHZsG+tAj1JczfvZ9JySGFp+uwqaZez7haPme/C2VV1lNb0WepMhNmzOWVcVeX+90r+/krWbe8/chYcrMySgZe/HDI2WcswNuD6GAfmgX7EBPkQ0ywj7J2itSwpl6PStPi9jA/gIkTJ5KcnEy/fv0oKiri559/5swzz6zp2KSeZVkL2XM8i13Hszicmus0s17Zm6RjB/ewcam9h3LDkgX0v/Cq4oZP2XMqusFyOJVhcyUbRs6G7FX1enWGFZbkahldVfLmr+TPN65jD36f9wl9zr+MrasWuxVv2TLaDIOkrHySsvL5+4j95tLf20KLED9ahPoSF+pLeEDla8l99tlnjB07Vmt2idPfBQfHsDtXuPIZclzP0escEtmMgRdfU2EiGWd1S7ES71W2DguLbkGWtZCs41nsOZ5lf2+TifAAL1qE+NIsxIcWIb4E+ni6VDYREWn8XGpMTZ8+vdy+Fi1a4OfnxznnnMPq1atZvXo1APfff3/NRljC77//zrRp01i3bh1Hjx5l3rx5XHnllbX2fqejnPxCdiRksutYFkfSc6noHqbsTcuc6U8CMOulh4uPKdvweWLWUpdudBxcmQNRW8pmEHOVqzdz7qqoYfn51IkAHNq1BcCteF0pY7a1iJ3HMtl5zL5AUKCPB63D/Wkd4UdcmF+5NX9GjRpFly5dys2pBFi1ahV9+vRxKTapPXVVj1b2u/DA9K8wDBtvPTy6wgcAzj5LyUfjyclMc3o9R8/T458uLu51HnTp9U57nSurW0py5eGNzTBIzLSSmGllY7x9X6CPBy1C7L27saF+Ffbwnq5JWkREmhKXGlOvvvqq0/0Wi4Xly5cXry9lMplqtTGVnZ1Nr169uPXWW7n6aveGf0jFCops7EnMYvvRTA4k57i0tlNIZEypmxYvXz9mV3Jz0qnv2eXOGXTp9ezfupHPp050ekPVd+hIolu2czrUp+TNU02pqPen7JPpssr28LhyM+cuV2/+1v76LR37DiYoNNJpvNUto0NmXiGbD6ez+XA6FrOJ5iG+WI/u5N2Xn+U/L08rdUNoNpux2WzFX6VhqI961GQyYxi2Ur1MVTXmM1MTiYptw+V3TqRlp54MuvR6DmzbxPQHrq+057eqXmeovG5xxt2HN5l5hWxPyGR7gv0hhL+3hdhQP2JDfYkL9SP0RONKSVpERBo/lxpT+/btq+04XDJixAhGjBhR32E0GUfSctlyOJ1dx7NcSj5QttFQ8ial39CRxFRyc3J4zzYO7fq71A27yWRiw5IfXOoBKnvz9NXrT3D2Ff9kzS/zqj0Ur6zqDit03BQu/upDstKSS8VjMpk4un/HKQ0ZBNdv/nKz0vng8X9VGG9NZhzcv/0v3nhvGgEhYWxcuoTHp73Fc1NfxjcwlJiYGOLi4rjtttv44IMPiI+PJyoqyqXrSu2qy3o0KiqKmJgYopu1oMOQkSz/7nPSk46RmZrsdLjq8H+Oo/sg++/omoXz2bN5DesWfUvLTj0xmUyERMbUeM+vK0NyT/XhTba1iB0JmexIyLQn3sjLIDrYl1n/mw1obSsRkcasWnOmGgur1YrVai3+PiMjo5KjTw+5+UVsPZrO30cySM7Kr/qEEqo79A3K37CPf/PrKntH4nduZt6M5/ALCiE8Jq745inhwC7id25h6dcfcWTvDrfiqWwulDvDCp318Py94jcK8vNYPOdDLrvtoeIeHmc/t1Odk1WVip6k19TQyZRjh1n81Yfs3rQKTy8fAJb98i2fn3s5YPDIm7O5YEAvOsYEcuedd5Kfn4+3d+XzraRhOpV6NDY2ls2b97Nuq43FuxKYM/1DwIv3HnsQyAVKD1f98Mm7q6wbaqrnt7JhhDU957EkZw80jh8vvbREU0/SIiLSlLiUzW/ChAk8++yz+Pv7M2HChEqPfeWVV2osuMqYTKYqx/o/9dRTPP300+X2n47ZYQ6l5vDXoXR2H8+iyOb6H2p3MuqlJSbw6r3/wNPbh9TjRzCcDO0yWyxVDlUDe++IPWvdbPoN/Rc9htxM2nErqcfzWPbtTxTm+wEhgD8WjxBatB8Ahh82mw8mszdFBVBUZMJWaKKo0J5VzAByMtKw5mbj7etPQGgwZjOYLQZmC1jMBkVF2Rzd9xeQB1hPfM2l1znnEhoVQm52Ars3Lib56DYgE8gqsWWU2DK5aeIUfAOD+OI//0dWWgq+AcFENI/j7CtuZvfGlaxZOK9UtrCqGliOn29IZDM69jmLRbPfqfDnV1n2wFPJOOj4fXj13n9UehzY/w89zCbaRQXQtVkQrcL96m0B4brUmLJQ1UU9umgRDBtW0asFlP7cZABpQBKQXOJrInAUSGDq97/i4eW8DnP2Garsc1U2q2fy0XjeGH9juZ6v8W9+TUhkTKXv46p1i76t9IHGzY+8xFXX3kCrcH/aRPgT7KtkFnL6aUz1qIhLjanzzz+fefPmERISwvnnn1/psYsXL66x4Crjyk2AsyeqcXFxp82HM7/QxvaEDDYdSicp01r1CSU4bhZ2b1pV5bElh4U5bk4O795a4Q37sYN7StxM+APtgPbFXyNbDAZTC5IOF2AYkW7F3bBkAenYbw5LbqlACpCCt18+I0bfjLefla0rv2Lzn7Podc5gstOTK735q+jn60jrXFnDaO2i+Xz+0sTiYytKH+3MhOGdqiy1o4er7Lo+Qb6e9IwNplvzIPy8XO8Ub2yT9BvTTUBd1KO//QY3jTLIyLZhzSnEVnTqPZR+gUUEhRUSElVISGQBoSe+bv7zI7Ys/y9nX3E+V4+bDLi/lIAryyac6vIE7jzQiAjwok1EAG0i/WkW5IO5lhfbFmkIGlM9KuLSHU3JBlJdNZZqgre392k5tCg9p4AN8alsPZqBtaB6E/8dQ9M69R3Mro0rXR4WVvam4+QwmQCgK5v/bIU15zxi24/m4I4ioFm56yaWW8vTiv3JdPKJLeXE13RO9gplYzLlcPYV19CxTz88PAzMHgYengZvjL8We78UJb6aAAv2j4AH/3rxU4oKIT05nW/ffQ2/gGhadzuTvZu3kJ2RR/ezLsdsDuKvP36nIN+CxTOUqNieHN13CAg8sQUAwYDPifcIOLFVnNDBmgPf/Nfx3XnADDb9XgAk8fYjeTRrE0x4jAeBoYX2LayI4IhCzKYWBITEEhgaQMqxQ9iKijBbzITHxJKZmlzpHJJdG1baowsO4+LR91c478TZ03dXEmFUNL8kI7eAZbuSWLEnmQ5RAfSKC6F5iG+F13HQJP36dar1aLt2B/jof4f4devx4t5t8AJ8sX8+gkpswdh7nCOA8BJbFIGhPcnJ9Kao0EJOpn1LOFA2rv8D/o9l861s+iObgOB0Eg8NAUJYs/AoHfvsIyAkm8DQihOtVJTA4lSTtzjjynBC+3IFKazZn4Kvl4WChF18/sYU7rz9Vj795ONG85BBRKSpqrE5U9u3b2fkyJHs3Lmzpi4pbjqUmsP6g2nsTcyqMKW5M46b5nP/MZagsKhSNwuH92znxodeLJXy3KGim+aiQshMbYW330NYPAbj4XEWGSkRgJmFs5xFkATsAfZgthzEsO3FMA4Bh09syQCYzGanQwcdxr85l9gOXYDsUvsvHnMmP31cPr0/2BuEw0eN49f/XcPldzxMlwE96Df03yWeTHfgwYs6s2Fx6WFORQVwtMK8LF5AICPvnMK3776N/eaw5BYKhJXZIk5sgYAn0Iy8bNi3xb6VFwfEYysqIiwqn9DoQkKjrIQ3txESkUt2hoFvQAHevvZfhJI3gttWLwHs8zJadupBbIdu+PgHFA9jcvw+BISElZvrVWkijBKLnVamyGYUZzqLCfahX6tQ2kcFlBoCeODAAZKSkjCZTHzxxReAJuk3Vq1bt3ayN//Elo79M15e2YbGHc/NZdXP81j+7ff0ueAu+l84jrRED7545b9AS+yfidZAK8CbzBRvMlPCgDsAyMuGD54A+9DdXZxxbjNiWlmJaZ1PTGsrEc0KMFuchgLUbPKW6i6hkJtfxNz/fc7K5b8Tf/Q4h/du57X/vs/7b/fGx7OS4EVEpNbUWGPKarWyZ8+emrqcU1lZWezevbv4+3379rFx40bCwsJo2bJlrb53Q2WzGew4lsn6g6kczzg5FMedMf2OXihnQ/qy0pLLNaTKPkUtyDdxYLsPezb5svsvPw5s86Ew3wyUXlPI4pFEi3ZFtOnmRVD4cb5772ZgB/Z5EifKU8l0qpsefslpo66qm/istNQKX3tg+les/mVeqUZD2SfTVfXGBIVHkZF8vEQ8BWAkExiaDmyouEBO+XCyYRUFRAMxQDSd+13Lge3H8fHrRHa6P/lW84kn9L4c3Q/2hljZ2AqJis1n96bfgJ3AVhw9Z9npKeVuBJ0llqho8eWyouPakZOZ5lZmtYT0PL7/6yghfp70aRlK1+ZBeFrMpW7AHY2sxERN0q8JdV2Plly8tyzHA5KyDaeSSWdKZgDc9PsPQCrb1/6XLv3DsXiCl+808nNzSlzVjL03uB3QFvsQ4o5AJ6AD9t//HmxcCiU/Mx6eNmJa5dO8nZXmba00b2elRVsrvgH2BzhVJW8ZPmpcpetmleRsmYjKEmk4HoZkpiSybtF8AA7vszfc5n4xG/82fejQOpae7eMY0rsrvl5qWImI1JVGlc1v7dq1peZsOZJhjBkzhpkzZ9ZTVPUjv9DG5sPpbDiYSmZe+ZuUqjLvORuy4u0XQEFeLrYKWjRhMbFccN0drPxxDikJ4WxYegbz343mwFYfCgvMpY71DSiiZac8+9Y5j83Lp7D65xm06nIzV/zrMcCEf9DVfPnaY5U0oExAiRuswGACQyMICIkoN7QtLTGBuTOe5ap7JhPXsYfT8tkvWbrhdezgniqH7ETFtaF52y7FC+OW5BMQxHUPPMfn0yYSHB7NoEuuY83Cb0hLPEpki9YEhkbgFxjCsYO7y51rD6fs8J484NCJ7SRvvwB8/H8jN2sB3c+6mhsenEJetpm0RA/SEj1IPe5JcoInqcc8Obq/gMRDJmxFoWQke5CR7AH8i9KSgb+AzZhMf3HetT04sH0Lr99/MrFEQX4eUP7pe+suZxTf7PYbdiVrFs4jPSmBO194n8CQcJcyq5Vt7KflFPDb9uOs2JtMn5ahfPTxJ9xx260UFhYW/3wcXz08PE67z3tNqut6dNSoUYTHtmHEeYPLvXb7M/9l9n/+r1wPzX2v/o/wZnGYTKbiBcHfe+yO4vNyMtKcP1gBwAbEn9iWlHnNzK1PL8Bs6c6xA14k7Pci4YA3CQe8KLCaObTbh0O7fUqd4eF1mDbdDDr1HcPV95zJnDcuw96jdpKzhzJVKfk5ObRrS6UPv5z1ijnqsdysdN597K7i3a8t3ElcmC8dowNpHxWgHisRkVrmUgIKV2zatIk+ffpQ5EKmtvrSFCY0ZlsL2RifxqZDaeXmQ7mTec+VRAIl/evFr8nNHsj2NQFs+dOL7IzSc10Cwwpp3zOHdj1zadczh6i4AlKPVx1PTkaa0yFjZdOhOzJqBQSHYfH0pKigALOHB7bCQiyensx98xmWf/c5Z5x7CVlpyS4lzqiKY8iOY7K5q+eUnLRemJ/P0f07efXef5RrOA274S52rP+zOB2zOybMmFvhPA1HvGdeche5mTFs+mMvcR3/gY9/P3ZtyMD+lN7ZDVYWsA5YDawC/gBO9riZLRY6nHEmO9YtZ/DlN3H1vU9UOknfwVkvaVUT+I/t3cq3M55m2+aN5V5bt24dffr0Kbe/oWgK9UxlqlO+n5b+yYjzBpfrgZowYy4xrToU99Ac3PEX3703jZF3Tiz+Xaks+13F7A9ioPxwQWdJHmw2SEnw5Mheb47s9ebwHvvX1GMVZdLbif0zshJYyY0PjeK7958vV8elJx/n97kzq+ytqurz4MrPwFniF4vZRKtwPzrHBNE20h9Pi7nC80UakqZej0rT0qh6pk5naTn5rN2fyrajGRRWkNrcnTH9VScSMGGfDD4S+AfvTr4EW1HJX5dswmJ2cP61LehwRg6RsQWUzXrtSjwTZsy1v1uZG57bn3mHVl16VTgExsPLq1TjcdMfPwEn13pq2aUXh3ZscdrLZrZYGHjxtaz66asKh+xcfscjxO/cUr5nqwIlk3GUnLTu4eVFYGhEqfkRKxd8SVpSAmddfhMjbhlfnI65sh6sspwNz3P8LNYv/haATb/PPnFEOskJ33HV3ZPZteFh7BP/OwM9gR7EdhhNwoFgCvMDgHNPbA7bgKXA71xx1xAWfm6/0dv0x88MvPiacg06Zw0nRy/psm9ncfbIf7o0gX/5j3OLG1KO3wmz2Yytkjlz0nCFR0RWOEeo5Od67a/fsuev1a7P03PC8ZAi5dghwERYdIty71n299RshojmBUQ0LyC2w47iz9I7jz5IdkYbvHzOoXWX2zi6P4jM1CDsDyQ6AjcD8L+Xc4H+wHKy0pbxyrjbsGftdJSrfG+VOwktKusdd3A2h7XIZrA3MZuly1fy/fsvM+6RJ7li2BBahvkpK6CISA1xuWcqNDS00jViCgsLyc7OVs9UDTuemcf/fljCjBef5rI7Hqr06WZVTy8vHn0/w/85rvh75+l5g4Fr8PIZTYF1MIZxsgcjJDKLtt0T2Lr6EfKyvycgJLBUL1N2ekqpG5Sq1lO58aEXaddzQPHaSZWt6+KMu71rxeedeDJdWXpiV2/cyl6zIlWlWy7MzyczLZnX7ruGkMgY2p9xJou/fL/S9yz5JNrdn8U19z9d6mcdFBbDX8sO8snznwEDgbOAXk7O3Az8eGJbjn2doPK9eP2HX1XccDqZwa1qjgVbHeeYTCai4trRe8iF7Fn3Oxmpyaxdu4bY2Fi3yluXGmM9447qlO9wWi6fL9/j9DPgSo+6owfbWfa7sj2+E2bMpUX7rhQV2H83nb1nZT1BVX+WwrjjuY0c2O7Hsm93k5PREXtSmbK2YPZYha3wV/yCNvOvKc+WaiS58pl1qXfcheUQypbX39tCp5ggujQLJCrQx+k5IvWpqdej0rS43DP12muv1WIYUtah1BzW7E9hf1IOc2d/zq5NK6sci1/VE9zsjIoSMXgCF2N/yno54MOJ6TLYb56/BuaQlvg360tkxi/by3T2FTeXmjNQWTwln6K6MxG7JFfSdJdUUfphZzdorvXcVZ7SuKSK0i2XfD00qlnxz+Lw7q0s/vL9Sq9f8mfo6s/CZDZz40Mv0m/YFaV+1vE7N/Pbl08BW4CPTxwdCgzBy2cE+Xn9gd5AjxPbROyLFi+i9/kF7Nq4A1//wuIn7Gt+mceaX+ZV+XNxcCzmXHYxYMMwOHZwNz/NsvfY/XfRNjItQcX/X9J4VPQZcKUH+4lZS8v1bFXW8+TsM5Z6/IhLPUFVJZq4/I5/ERCyhu6DTPz5/e3Ye6A6AoOAs09snYDu2Aq7A7eRkwGvjNuBfQ7XVzz9xXMuvE/53nGTyUR4s1ZkpBzDsNkwe3hUuBxCVT1fq5bYhyD+89+TuXzo2XSJCVLiChGRanC5MTVmzJjajEOw3zjuS8pmzf4UtuzYU+NrmpQ9PzOtJRaPdygq/Af2tVwctgKzgDnY5wZUzmQ2c/HN9/HHiSenJd8nIzXRfkwl66mUvck6un+HS5kIXR3+40icUTb9cGXpiWM7dKvw2s7mc7mTwa6kssONHD+LkrF17HMWi2a/U3yOs5+hqz+L8W/MKW6AlbzhXLNwPod2bcHT24eYVh1KJJb4kwfemEB60h6mPzAcGA6MAC7CnmnwSjYshg2L84FFwJXAfBzp7F31wPSvyizmXJqjFy6nyMxPWxJYdyCVIR0iaBXu79b7SMNTVaPixoderDD7HeDygxhXh0FX9RDI+Wdsx4lt5onvI7H37p6Dfdhsb+wNrE7AXTx5PcS0vo8zzrmS9Yv/DfyOfc5i5e9jGAZJR/YXfz917triOaRly+1KeQEWffsVQbGdWLYribaR/nRtFkTrcH8NAxQRcZFLjSk9Ba5dNpvBzuOZrNmfSlKmPb15ddc0cdyEZ6YmVXD+WOBG7Guv9D2xARwFPgc+Aza6Fb9hs/Hjx69XGKe766lUlYnQHfe/9kWFc69cTU/s7nwud1RU1pKxpScdY/XPXxMcEc2ZI66r8mforLHlbJ+zJ9dePn5cc/9TAHQ98zyCw6Lw8PIiOz0FSMFk+gLDmI09/fQZnHnJZ2xbHUF6UiT2RtYI4B3gF+w9XPOxL7rsPEbH169ef4Jr7n+qwpvIsvNB1q9by9P/msZdDz/BrVcOI8y/ej9/qX+u9mBX1bvrbF9JrjTaynK319pkMhEa3YK87CxyMudj//0H+/DpIXh4Dicw9DpSj0eSsN+bhP3tgR+wD5f9E/gZ+BHDBh37DGbn+uVOy+KIt+TcTHfKazKb8fLxw5qTVerhV+LRUHYda0GgjwddmwfRvUUwQT4VJeEQERFwsTHVrVs3nnjiCa6++mq8KvljtWvXLl555RVatWrFpEmTaizIpqqwyMbfRzJYdyCV9NyCUq9Vd00Tx034xj9+Ynap8/sBdwPXA/an+RZPGz3OyqJt983MnXEOJpNRYe9RSWVvMMxmS4WJHm586EV6Dbm4ygaLO5OxS3I0Hsslbzgxj8DjxPs64nY2vK5kuUp+X1HPVUhkTKXXrIqrZXW30Vcy3h6DL+SnT6YDBiPGPMBfy34p1wBz1mDPTk8pNdTO0WB3/rM4yPBRiVz3gIW/lm1k5jOLgWuwry92yYktDfgK+xP7FYBRrmcv4cAu4nduYe2v8+l/4VXFP9fKfhcdjdBv58zGM7oDPWODGdQuXGmgG7mq/t9PhauNNqh+r/X4N7+mRfuuHNi2iekPXF/ilXTgewoLvif1+P3YRwKcT58LprNhSR6GrQ0nk7+8wH8fzaHAmo99vayfcZaKvbI5mlWV17DZsObYe8KcPaTLzCtk1d4UVu9LoXW4P91bBNM2Qr1VIiLOuNSYeuONN3jkkUe45557uPDCC+nXrx/NmzfHx8eH1NRUtm7dyrJly/j777+59957ufvuu2s77kYtr6CIvw6l880vv/PV2y86Hc5W1R/+ytY08fDyot/QkUQ068D0B+YC44ABxa+Hx2Rw9hV59B2WQUCwjbTEIhZ+HlbqxsGRrruyxTQdNxg3PDil1BowJeMs+we/osZHdXviHA2Nkskb+l94VfFaT9Udflfy2tWZz1WZ6pS1qqfyzuI99+qxAHh6e9Oh95l89940MlMTixN7uPOkvqqfRVh0FjAFk+lFDKM9MAb4J9AKey/oHXh47cFieZ9/vTgc3wCDnIw04jp2593Jd1BgzWPDkgV07jcEv6AQgsOjGXz5TaVuYitrhB7YYbB8YwSXnNWDM2JDdNPXyFTWeKkNVTXaqttr7dgXEhmDj18AeTlZ5a5tl4y330+c94+VDL48n6Kioxw70I6v31gJDCU3KwD7g6/rgUJgGfD9ia18Pehqeas4iItvvq/UQzrDgH1J2exLyibQx4PuLYLp0SIYf28lAhYRcXCpRhw6dChr165l2bJlfPHFF8yaNYsDBw6Qm5tLREQEvXv3ZvTo0YwaNYrQUGdZjQQgM6+ADQfT2Hw4nfxCG3/8ONel4Wxl/xBWtdBs6nEPln8Xwp/fXwxcceIsK/Al8DajH3sYsPHJcyfn6pS9cXCk665sMU3HDUbCgV2l4qzOU+WqbuxHTXyJAG8PfDzN+Hha8PG04O1hxtPi2JpxyarN+Pp4YzGbMf/fg9gKC/Dx8cZcwRBVA/sQVpsBNsPAZrN/LbQZFNlsFNmg0GajsMig0GajoMgo/nd+of37giIbBUU2rIX2r64UuzrDjVxV8mbP09u7+N/uppx21hB2rxfvC1KPv87Iu35k5/r2/PVHIPl57ShkCm+Ot5FvfQ94G9hUfI2stGTee+xOwL4o61mX3VDqJtZZ9rOyjVD/X3bw9+F0zusURVyYn4s/Nalt/l4WesYG42Ex42k24elhxsNsKq4rjE6RXLxyM55entgME9Zxd5OTl4dh9iz+fOXmF5JbUERuvg1bNXut3Gm0VTaXMzC04lTvYG+MPfPliuI15pyx5mSVe4Di47eLz6fdgGEbiL1n91KgG3Deie1lTOY9rFjgRb9hBq265GGuZOkoZ+WtaF0734AgEg7sPrGMwefc+NCUUq9n5hWyYk8yq/el0C4ygJ6xwfqMiYhQg4v2Ngb1lWrzeGYe6w+ksvNYFolHD7m8sG5aYkKptOFzpj9ZxTv1p/d5v7Lp90BsthPD0MzxBIXNZciVBWz6/ZPiVNi/ffl+pYtEQtXpvB3KxulOenMAs8lEkK8HyQe28/CoS8q9/ueq1Qwa0L/K69Q3wzDIL7I3tPILbeQX2bAW2G8ErYVF9q8F9n9v+WsjD9xwcblrVJVi3R2nknK6OnFU9vuSl21m7aJAln8XwrED3iXO+gOYhv2Ju70qcrb4KFSe+t/ZOe2jAjinYyTBvnU756Opp/St7/IZhkFegY2c/EKyrIVk5tm3LGshWdYC0nMKyMgrpKiC9fhcrdfKKptevKLrlEwqYzKZq0wKU/Z3d+2i+Xz+0sQSR7QBLqVVl8c4tDuSooKTrafA0EK6Dcqix+AsOvbOweLk8WjZOMsPQXSusoXBHSICvOgVF0KXZkFaEFhqVH3XMyLuUGOqlhiGwf7kHNYfSOVgSk7xfnfWFoHSfwjXLvq2zDwosCcCuBJ4EHv2KLv2vXIYcmUqHfuk4uVjPz854RCZKYl4eHpV2ZBzlys3KJ4WE2H+3oQHeBER4EW4vzehfl4E+nhgNptYv349ffv2LV6c1fF13bp19OnTp1pxNVQVlXXpn6vo3K0nuQVF5OQXkZNfSLa1xL/zi8jKKySvoOp08K78rj0xa+kpNYTdZRiwZ7Mvf34Xwl9/+GOzOW7AtgEvA58xYcbsChtyla0N5uwcT4uJvq3C6N86FI86utlr6jcBjaF8hmGQkVdIRm4B6bkFpObkk5pTQGp2Pum5BRU2tMpy5YFE2TqzZKPr/GtvL/58lc3K6VD2d/eT58ezcemC4u9LPuCIaNGd7Wv92bI8gK2r/MnLOTlH0GxJp3O/VM663JOOvbPxqOAZQlpiAlPvuLSSIYjlORtiXZKPp4XuLYLoGRtS5w8vpGlqDPWMiIMaUzXMWljEVz8t5fknJzPi1vKL7Lr7dL2skzeTvsBYYALQHgCLh0Gf8zM45+o0WrQrn0HN3YbcqfAwm4gI9CYmyIeYYB+ig3wI9TuZDMKZQ4cO0b9/f+Li4rjtttv44IMPiI+PZ82ahr1Ia3WcalkLimxk5ZV8Mm+/aXTcQGbmFbLm1/ku/a5V90n9qdq2Zg/vTf4L+Bf2bGcARzn7imQuvdUbb9/yVZPj99/dnrRgX0/O6RhJ+6gA1q5dy8SJE5k6dSr9+vWr8XI19ZuAxl4+m80gPbeA5Ox8krOspGTnk5SdT2p2frlGlqt1ZmWNroL8fILCI8nNTK/wd9cvKKT4/P8+eis5GWmYLRYuuPZ2Nv/5K1npKTz41jelHnAUFsCeTX5s/jOANQuhwBpS/JqPfxE9zsqi9/mZdOidg6VMXpbC/PxKhyA6uPI3qdTxJhNtI/3p0yqUFiG+Lp0j4kxjr2fk9KJZpDUkKcvKX4fS2HY0k9nvz2T7+pVEtiw/F8rdeSpl5WZ5AU8A92JfywQgiaCwr7n+wVi69O9Q4bm1OVfHy8NMixBfYkN9iQ31IzLQG4ubSQBiY2PZv38/Xl5emEwm7rzzTvLz8/H29q765EbmVMvqaTET6u9FaAUpwW02g4yz7uf6CwcxctjZ5V53J+U0lF8PqyY0a+1PYOjLBIV9Q3izp/l7ZU+KCpuxbH4zNiwu4rxrUhg8Mg0fv5M3uNVNVJCeW8B3m47QJsKfHz/8iMWLF/Ppp5/WSmNKGjaz2VT82WkfFVC832YzSMnJJzHTSlKWlcRMK7dM/g8fvzixyjqzugsPO353nxl1brnzbUVF/FqiJ6tsT3FGymH8glI5c4SJTX/cSYG1K55eN+Pl80+yM3xYszCYNQuDCQgupNc5WfQ+P4PWXe1zrDxO1DtQeXIKV/4mlYrZMNh9PIvdx7OICfahT8tQOkQFKCGMiDRpakydgvxCGzuPZbLlcDp/73R/kV13EjakHPNgyZxQVv7YDvukZPAPSsXT+22y0v9DRkoK29fcTJf+zuc/AUTFtaF52y4c2rWl3Gvu/tG0mE00D/GldbgfsaF+RAV618gfzJKNCZPJ1CQbUg61WVaz2USInxctQn1PfF96OOEFnaOIaRdJUpaV45lWUrLyK53UX5NrfzmUzZhWWJDO2l8LWfxlFImHvfjhw0iWzAkr1aiqboZFR8/BoV0mPv/fFwD8b/ZsxowZg2EYRERE0KpVqxoplzROZrOJiABvIgJOfg6v7jOBWy49m3POGlju+JJ15qksPOzh5VWtB13lG3C/U5D/OwX5d2Ef8n0DAcF3kZVuT0i0/LsQQqMK6HNBBv2GZbq9MLi7EtLzWLD5KIE+HvRuGUL3FsF4e2jpAhFpetSYcpNhGBxOy2XrkQx2Hc8iv9AGuJfu2p2n60f3ebH4qzDW/3YyqUSL9rkMuGgPLTvuwmzpzLuToTDf3niL69iD3+d9wvB/jqP7oNIxrVk4v7ghVZ3MewHeHrQK96NNhD8tw/30h7ERiIqKIiYmptxwwl4dWxEbezLzZkGRjWMZeRzLyCMh3crR9FwOHDhQrbW/3FGyEeThaeLMETn0H76fDYsDWTgr/GSj6utQLrwphbMuTXepJ60sZ5/PxOPH6du3b/H3p9GI59NSdYd3OtKAl30gcXaHCMJbhZKQnofn8CtOaeHh6oxYqLgBZgPTckZNvIIzztvLrg1+bFgSyOZlAaQe92TR7HAWzQ4ntkMM51/zF32GZWMrPOLWwuDuyMwr5PedSazcm0LP2GDOiAsh8MRCwLU95FZEpC64PWdq/fr1eHp60qOH/en0/Pnz+eijj+jatStPPfVUpYv61rfqjsF1NKB2Hc9i97EssqyF5Y5xdS6UY7jUiLEP0Lpr7wrnqezf6sOi2WH8vfLkMJSOfbK54PoUOpyRy4MXVX8sv8lkIiquHd3PGsrWVUvISkuuMOFAsK8n7aMC6BAdQEyQT6VznqRhslqtxcMJDcNweTihK//XNTXHzpmiIko1qgDCogu4eEwSfS7IrDQldFmVfT4tFg/efOc9/nXb2BqJu6mP9W+s5bv//vt54403uP/++3n99dddPs+V+Y02m8GiZSsZfu5Z1c6MWZ35gBUlZPENDObuFz8q9dCjIN/E1pX+rP01iG1r/LEV2T/fZotB14HZ9BuaTNdBeXh4nPrcycqGBVvMJjrFBNK3VSjP/N/D1fo/kaavsdYzcnpyuzHVv39/Jk2axD/+8Q/27t1Lt27duOqqq1izZg2XXnopr732Wi2Feuqq8+E8kJzNwq3HyMwr34Aqy5VMY2XT65ZkGLBznR+/fhHGnk329TtMJoOeZ2dxwfUpxHU8mVSisptDAG+/AMZN+6TKtLwAU7/fXOqPZrCvJ51iAukQFUBUkE+V50vTNGvWLMaOHUthYfnffXcnpp+KoiJY/XMwP38aTkayvZegWVsrl92aSOf+Objavq/s89myY3d6xQVzZttwfDxPrce1qd8ENKbyHThwgKSkJEwmEyNGjOD48eNERUXx448/ujW805UHEmUbXe+89x7xB+N5ffZPWL1DSMspqPQ9qrPEREW/02WVfeiRlWZhw5JA1v4aRPzOk3V8YGgh/YZlMOCiDKJb5pe7jqtzJ0v+nes37IpS5xQ/4DOb+GDyHaSnJlfr/0SatsZUz4i43ZgKDg5m/fr1tGvXjpdeeonffvuNn3/+meXLl3PDDTcQHx9fW7Gesup8ODfFp/Hb9uMuHVv2yaLDFXc9in9wCL/P+5Tko/HkZqWXSq/rFxjKod2dWDQ7jEO77H/YzBYb/YZlcsF1KUTFnfwj7O4aJpUpeUPs42mhY3QAnZsFKQuTFHOkcC9r1eo1RLftwr6kbHYfz3LpYcOpys8z8cc3ISz6Ioy8bHuDp1O/bK64K5GYVuVv/Mpy5cm/r5eFgW3C6BUbUu05gE39JqAxla9k72pFQ5trcnhnZY2uzLwCDqflcigll4MpOaTnlm9cuZtZs6o056489EjY78XqX4JYuzCIrPSTI//bdM9h0CXp9ByShZe3/WdU2cPAijIatu81kI1LF9B/+NXc+NCUCjIkmnCsMwcaciuNq54RcXvOlGEY2Gz2eUK//vorl112GQBxcXEkJSXVbHSNTNm5UD99Mp2stGTmvzOl3LH2+VTXAaOAR4DmAJgtVmxFb9Fv2H5ueHBcufNKJgLof+FVVcZktli46J/38uPH5YdQjH9jDkMG9adb8yDaRAS4nX1PTh9l54t4WMy0CvenVbg/53aMJCEjj13H7Fm8nN0kOpxKVkAvH4OhN6Ry5iXpLJodxh/zQ9ix1p+X1/tx1uVpdB+0jF//93yF13ZlrmJufhFLdiSy+XA6QzpE0ibC360YpWH57LPPintXHTfojq8eHh7MnDmzRt+vsqQygT6edI7xpHOM/cYwPaeA+NQcDqbkEJ+SQ05+kdvzAUMiY3jmyxUVpjl3JbFQTOt8Rt6ZxKW3JrF1lT+rfw5m22p/9m3xY98WP+a8kYeX91ecc3VB8dzJtb9+y/6tGzj7iptp17M/YdEtKpw37Fgza80vcxlyxT+5eMy/+eXTN7HZSo6qcCzY7cGU197GZjOUAVBEGg23G1P9+vXjueeeY9iwYSxdupS3334bgH379hEdHV3jATYmIZEx3PufWeTmZGI2mbHZ7E/rPb19KbDmljjSF7gNeAiwD2fw9s3njPP2smX55WRn7GbrqnAO7ToPwzAoKLDi6eldLhFA535D8AsKITg8mq4Dz3O6IOQD078C4MePXy/3ZPbK3s05+4xTSyAgTVtFCSyioqKKjzGZTDQL9qVZsC/ndIzkWEYeW49msCMhk9z80sNQayIroH+QjZF3JnHWZel8914Em5cHsmx+KCsWXEBRwa+s/uV7p9d2JxNgclY+32w4TPcWwVzY9fSu1xqzUaNG0aVLF+e9q6tW1eti4MF+ngT7BdO9RTCGYXA808qB5Bz2J2dzNC2v0uyaJTlLc16dbHwWD+gxOJseg7PZtnoXX795iML8f5KR4k9+7s0s+BDsaxrOIDdrHvE7t/C/aY8A9mGElWUkdKhqJMUD07/Es0M3PvpzP/1ahdKteVCdLbYtIlJdbjemXnvtNUaNGsU333zD5MmTad/evmDsnDlzOOuss2o8wIbI8XS9//CrWPPLvFJPwqfcelG54082pIKBe4AHAPvNqF9gHjmZj2PNfYdVP2YWn1M2E2BZWWnJvPfYnQDkZKRx40NTWDT7Had/TB1P5GOat+CWW25j7uxPOHToEK1jm5/qj0KauOqshxUdZF+k+ZwOkexLymbpuq1s338Ym0GNZgWMaF7AFf9aS8c+Hiyd25Okw8HA66z4fist2ibQon1SuWu7++Q/Kav84tfSOJXtXW1ITCZT8edmQJswrIVFxKfksDcxm/3J2WRbK26ggPNe1+SjB5k741muumey2w8uNiz9gJSEeZxx7vf8vdJCgXU0MBI458SWALwHvMOIMdcQv3MLbbr35YHpX1XZYCo5WqKixl9GbgG/bT/Oqn3J9G4ZSs9YpVUXkYbL7TlTFcnLy8NiseDp6VkTl6sVNTVnyjFuvHnbThzZu6PU+HHniSGaY29A/QsIPLFvLzCV+18bQfLRXZVmAjxzxHWs/PHLSjMFtus5wOnk5cnvzmNI7850jPAhPMjf7YxuIqeqprICOhsieHL+hRl7b+8LQMSJfZ8BD9O+V6tqLzYcE+zDjQNaunVOUx/r39jK50o2vobM0Wu1NzGbfUnZHMvIc3pc2flWc998huXffe50fpMzJec8OW8QNQfuAO7EMSwdCoH5wOvAH0yYMdfpvOGSJsyYS0BIuFvJNnw8LfSKC6ZPy9BTThAjjUNjq2fk9FatdabS0tKYM2cOe/bs4eGHHyYsLIytW7cSHR1NixZNc9iY4w9NZkoi6xbNB+DIvp2Affx4x76DCQqNLPN0riPwMDAacDwB/wt4iai4deRmJRMSeRMWj6oX0z1zxLVVrkFScgjT1TeNoVuMH93iIsrNhWrqi+FKw1Jy3kpZFS1I6oyzIYKlhxa9B8wBngfuAv6J2XwVuzc9xppfvgOo9nwtabyq07vakJTstRrULpzMvAL2JGaz53gWh1Jzi4cDenh5lWoQbfrjJ8D1XmBnc55KOwI8jf3zdSX2URbnA/8A/oG37052bzIICGlBaFRYpQsBuzrktuQDlLyCHmw4mEaPFsH0bRVavP6XiEh9c7s2+uuvvxg6dCghISHs37+fO+64g7CwMObOncvBgwf55JNPaiPOeuf0D82JPwy5Wel88Pi/indfN34p8A1wRYmDlwIvAT8CMOqRr2nWuiMeXl789uX7Li+mW9nrXt7edIgOoHfLEJoFKyOfNAyVzVt5+8ufKAhtXbz4dVklbw6dDRH09gso8yAiFftN3geEN/uO5KPNgFf58/vNHIv/iN2bVrHs28+58aHySWGk6aosMURjE+jjyRlxIZwRF0JeQRH7krLZdTyLA0nZbi0eX5Yrc57sCrE/tJgDdAXuB27GmtuRb98FH//dtOx8lF5DEkotBPzHN5+QdOQgGSmJgGtDbss+QMkvtLHuQCqb4tPo1iKIvq3CCPZtuKNhROT04HZjasKECdxyyy1MnTqVwMDA4v2XXHIJN910U40G15BU/YfGAlxFcMQ0vny19Yl9NqJbbuX4obsxmVYwYswD/LXsEGmJRykqLOTo/p2lbhKdLabryDRWWSYyb08z3ZsHc0bLEIJ89IdFGq6y81b6tQ6ja482/HUonY3xqeXmhrhyc+hQ+gHDOpKPtgBuBV7CZuvBrg0vA+1Y88v/MeSKf57SfC2RhsDH00KXZkF0aRZEfqEN65vvMenfd1NU5H4vcN+hI4lu2c7N5Ta2Yh++/ij2Ybb3kpfdiuXftmHlj63ofe5Ozv1HOi3a5ZNwYBfHDu5hx7pldB14XoVXrOoBiuMzuyk+nS2HM+gUE8iA1mGE+ldvgWERkVN1SutMBQYGsmnTJtq2bcuBAwfo1KkTeXnOx3PXlBkzZjBt2jQSEhLo1asXb7zxBgMGDHDp3FOdM+V8gcQgHH9EoC0AHp42+g5N47xr0ohuWUiB1T6J3dPbu3jtkImXVT3MqOxiumXHxPtabAxoH0OPFsF4eSjjkTRcrsxbKSyy8fXPv/PU448y4taHiOvYo9LFqU1mM14+flhzsko9iFi36FvSEo+WODICmAaMPfH9UeDfgD3TZdkn9SWHFvXv379Jzpmq63pU6k5Fa8OVXE+tIhWtlTjshrvYsf5PUo4dAkx4+/qRevwIRrlEHhZM5quIaPYqiYdPzkdr2fk4x+PvJS/7KwJCwhl55yP8Pu8Thv9zHN0HlX5g4nwdqtLKfmZNJugQFciANmFEBjbeXkc5SfWMNCZu90x5e3uTkZFRbv/OnTuJjIyskaAq8sUXXzBhwgT++9//MnDgQF577TUuuugiduzYUSpVc93ogH14w1gg4MS+JDy9P+S2p7vhG2DF0zsUaIFnmSEmHl5elfZ0OZ4glh324Pg+ItCbvi1D6RQTqLWhpFFwZd6Kh8XM8p/msn39Svr2XkiPM/pU+rTcsNmwnlis1DAMjh3czbGDuwG4/7UvmP7A9SeOTAJuAT4G/gt0Ar4EFnDl3ScXGXc0ogJCwk6u5da/f238OOpVw6pHpbaU7QWOCfbBZCoene5U2REQKxd8SVpSAmddfhMjbhlPUYF9DTmLpyeHd2918rksYvwbNxHbIYcD2w7y+r//BK7h4PYo7J+5zWSlTePzqZOBAj588u5yDSNX/jaWZRiw81gmO49l0jbSnwFtwjTUXUTqjNs9U7fffjvJycl8+eWXhIWF8ddff2GxWLjyyis555xzeO2112opVBg4cCD9+/fnzTffBMBmsxEXF8d9993HpEmTqjz/VHqm4nduZu6bL5BwoD0wDmvuOSWO2oI9m9EsILfU+ZVlKXPe03XyCWLZ7GWxob70bx1Gay0kKk3IgQMHSEpKwmQyMWLECI4fP05UVBQ//LCAvUlZLN+8m+kTb3dp7RzHzZajAVb+HC9gEvB/gDdePjYuuSWJrmf+zYIPX2bj0gV4evlQkJ9HQEg4j77+MRd1iyEiIoJWrVq5VJ6G/kS1PupRqTuV9QLvPXiIBx96mMvumEhQrPMeoLIjICpai61sL5bja8kesHWLvuXzaW9h2MZhzwLomBpwCHgNL9/PufflGeWG3Fb1t9EVsaG+DGwTTstwP5eOl4ZF9Yw0Jm73TP3nP//hmmuuISoqitzcXM4991wSEhIYNGgQzz//fG3ECEB+fj7r1q3j0UcfLd5nNpsZNmwYK1ascHqO1WrFaj25ToyzHjVXZKZamDujiAPbvwZaA2AyGTRru4ej+8Zh2H4pd447WcoqSirhmHy7a/kCHhp1Cc1D9KRNmp7WrVsX/9uRRj0xMZH+/fsV7w+PjCIwPJp+wx1r6MSTk5lW7lqO7JZpiQnFT9hLZxXLx2R6FsP4ghbtlnF4TwTfvB3FN2/vA+y9VAX59qHKWWnJTB5zGZNPnFlDq0jUq/qsR6VuVNYLPHXqVNauWMZZ/ftwzzXD2XZice0s68k5Vq6uxVbZPF6H0j3Lz2KfX/VvIBZ4mfzcx3hl3FvYH0YedzJ8r/qLEB9KzeVQ6iFign3o3zqUdpEBLi3TICLiLrcbU8HBwSxcuJBly5bx119/kZWVRZ8+fRg2bFhtxFcsKSmJoqIioqOjS+2Pjo5m+/btTs+ZMmUKTz/9dLXf85tvjjLtNTMrl7XBVtTOvtOUSp/zk+l59h5iO3iRk/EvXhlXvjFVMmV5RZz9MUpJOERGahKHd29l8x/2zH+rF31Pwt5xHDUMt56QizQGJVOnO26YHF89PDyYOXMm11xzDSaLB5sOpbP6yhvZ+dcGpj9wfYU3WyVTL6cnHSuVVcxx03frU1t59uZZwFRgILDuxL+fBU42HhwxNAX1UY9K3Ss5fPbgwYPFPb9ffPEFALNnz2bMmDH4GwbD4sIxAprz95EM9iVlU2RzrdHianrzk9KxZ7R9FRiFfdmQLth7iSfQ4YztJB3xJKJ5gUsNtYqUHdGRkJ7Hd5uOEh7gRd9WoXSOCdLweBGpUTW2aG9tO3LkCC1atODPP/9k0KBBxfsnTpzI0qVLWbVqVblznD1RjYuLc7nb2GR6DnAsdrgKeBv4AjiZZKPsIoXOhjpUpuyQigcv6lzi/Z3fKDaS/zIRl1U0aX7dunX06dOn1L68giJ+WLmFW64Y5vKinxUNXbIPQ3odw/Ya9vVyALZjX5x0WYUxVKYhD0+pj3pU6lfJ3piq/qbk5Bey7WgmW4+kk5SVXyPvn5aYULxAb+leYhNwOfZMgGfa95gNeg3JZOgNKUTHZbk03LCsuTOeY9n8TytcrDjQx4O+rULp3iIYT4sSNzVUDbkeFSnL7Z6pZ555ptLXn3jiiWoHU5mIiAgsFgvHjh0rtf/YsWPExJS/eQL707lTWU/ktde6MX78BxjGDGBDqdccw/hO5QkanBxS4eVhpmdsMB989DF33XFbpU/pRZqqspPmnfHxtPCPIb0Ysncfqw6ks/t4dpVPxSsaulR6GNKVwAygM/AH9mQVE7nrrrt4++236devX7nrNjb1UY9K/XKl59fBz8ve0OjbKpQjablsPpzOrmOZFBRV/wFeyR6sw7u3smj2OyUadd9hGN9y7QNL2bysL9vX+rNxaRAblwbRdWAWQ29IoU23vAqHGzp6oboOPI/1i3/gnKtHV5pOHSAzr5AlOxJZtS+FnrHB9I4LxdfLUu3yiYi43TPVu3fvUt8XFBSwb98+PDw8aNeuHevXr6/RAEsaOHAgAwYM4I033gDsE6dbtmzJvffeW2sTp2cvWMqNl55Xbn/JnidXJ+w64+tlKV6A0cfTXqG785RepClwJXV6ReJTcli6M5HETGulx1X43qUmuwdjH+p354nvDwP/4v772/L666+7dL2G/kS1PupRqV+n8jclr6CI7QmZbD6cTlIln7Gyw+ucKdlL5axH+fAeb377IpSNvwdi2Ow9am175DDsxhT8Alfx/fulr+/ohXJFRcmgPC0mLCl7+d8bL/LKf6Y1iYcmTYHqGWlM3O6Z2rBhQ7l9GRkZjB07lquuuqpGgqrIhAkTGDNmDP369WPAgAG89tprZGdnc8stt9Tq+0LlE2FdnbBbUoC3B31ahdCjRUiFa0S58pRepClwJXV6ReLC/Bg1sCWbD6fz555kcvOLXLqxA/sN4LwZz+EXFEJ4TBz9hl3JigX/IfXYd3j7fkZGSgtgJp9/PpAxY8ZgNIF5i/VZj0r9qs7fFB/Pkw/8Dqflsik+jd3Hs8rNrXIkTFr76/wKP3NVzbNq0c7Kzf+XQK9zVjD3zTyy0i9n72Y/3t3sR0BwAVnpzfhj/ucMuWIUmSmJrFs0v+oyV5AMqmQdsWbhfJb9voRnXvkvb7/1Bi2U7ElE3OB2Y8qZoKAgnn76aS6//HJuvvnmmrikU9dffz2JiYk88cQTJCQkcMYZZ/DTTz+Vm0xdk8IiIk5pGF9ZQb6e9GsVSrfmQXhUMF47KiqKmJiYck/ptQaMNGXeZdZjc2domclkomdsCB2jA1m2K4l5b1V9Ywf2G8D92zYy+PKbuPreJzCZTMx761lgJ9bcGOApYDPJyXtLPdlvzPMW66MelfpVU39TWoT40iLEl2xrIVsOp7Nk3VaOHU/EZDJVObzOwZWHj7s3zSIj5VN6nXM7ZstENi9vQ1Z6G2Aeaxf+zdqFU4DZQPm1qMqqKBnUH/NnsXvTKpbM+ZBdG1cCsPjHb3jl80sJ8/diUNfWnNe3K2YlqxCRKtRYAoply5Zx+eWXk5qaWhOXqxXVXWfql78OVXsYn0N4gBf9WoXROSbQpcrZarUWP6U3DMPlp/Qip6uS61VddNHFJCUlEhASzp3Pv1fqxi7l2GGy01MxmUy8O/l2stJSSh23d8s6vnvvJaeLhjrmmIwaNarCOJr68JSmXr6mqjb+priSaryytRZLcva5PCkCe0r1+7APxQXYgz074MeAs2QZJqB0MqiS7+FsHauy3vt9D73iQujePFjzquqY6hlpTNxuTE2fPr3U94ZhcPToUT799FPOPfdcPv/88xoNsCZV58P5+feLefKxR6scLlSRqCBvBrQOo32U1rgQqU3OspZhMkGJKu6VX3YwYbjzxUpLcmTpLMuVOSZN/SagqZdPXDdr1qzi5BZlOYbX9R060qVrufK5hCBgHDAeiDyx7xAwDXgPyAVg2A13sWP9n8XzsTJTE/nuvWns3lQ+W6UzZWP3MJvoGBNI77gQooJ8XLqGnBrVM9KYuD3M79VXXy31vdlsJjIykjFjxpRaCLKp+P7r2S4NFyqrRYgv/duE0SbCvxajExEHZ1nLHA0pi8WDGx6aAsCoR6bxv5cnOe15Kju/wtEo07xFkfJGjRpFly5dnCa3ePS/XxPeqovL17p4zP389PH0Ko7KAKZgX+T3DuxrVcWe+H4y9jWsZtBzyEWMuGV88SiS3758n92bVtGp72B2bVzp9LNfUtmhgYU2g61HMth6JIPmIT70jA2hQ1RAhUP1ReT04nZjat++fbURR4NScrjQz9/NBaoeB+7QKtyPAW3CiA31q8uQRU57ld3YrV69Cr/m7VmyI7FMOvTSHDdRaYkJBIZGEBnTnIn/vkfzFkWqUDa5xcheLfBrHs2Gg6kurVmVlVb5FIHSSaBy8Av6mKCw30g6ch6F+eOBNsAUME1izcI0MMVj2I6Xms91eM92bnzoRWa99HCl71GZI2l5HElLYImnhc7NAunZIpjwAA3BFzmd1UgCiqamdevWJ785MXQoKy251M1XyXHgJhO0iwxgQJswojUEQKTeOcta1jkmiFZh/izZcZxDu+zHVZSl05F1rEVEIDcNbOVWdkGR00lFyS2aN4shtkUw3VsEcyA5m3UHUjmQnFPq3JJzmBwNHuDk8NwTXx3ZNgdefA1/fPMJSUcOcv345+h+1jCKCgowTFbWLzrEkjmRHDsYzB/fBPPHNxHAO8DLgH3+VVZacoUNqZJDA11JMJVXUMTGg2lsPJhG8xAfujUPpkN0AN4edTu3au3atUycOJGpU6cqrbtIPXGpMXX11VVP1HSYO3dutYNpKEoOF6LMU6qSw4DMJhMdowPo3yaMCD2ZEql3VWUt8/WyMKJHMwJtXXk/LILgiIqzdHqcmKwP7mcXFDlduLKsQatwf1qF+3M8M4/1B1LZkZCFzTB47uYLnF+0xDDdwNAI7nv1f4Q3i8NkMpFwYBfHDu5h96ZV9Bh8YXEyqIEX59B/+AG2/BnAr5+HcWi3PzAB+xyrj7GvH7en+C3CYmK54Lo7WLngS9KSEjjr8ptKDQ10h723Ko8lO47TLjKALs2CaBnmVyeZAD/55BMWL17Mp59+qsaUSD1xKQGFO+uPfPTRR6cUUG1yZ0JjRYscTpgxl1adutOlWRD9W4cS4udepSsitcvVrGVpmTks25vGruNZFWbpjAn24cYBLd16/6Y+cbqpl09qX0ZeARsOpvHRx5/w6UuPVDh/8YYHp3DGOSPISE2sNANn2aH3hgE71vnxwwc+HN4TcWJvEfAV8CL3v/Z/tOrSy+UMva6uW1dSgLcHHWMC6RgdQLPgml23quRUhBEjRnD8+HGioqL48ccfm8RaeKB6RhqXGkuN3hhUpzFVdhjQf+cs5MZLzyXIx7OOohaR2rQ9IYPF2xPJKyh/Q6fGVHlNvXxSd/IKivjix6WMvWJouddKpjR3JdOfsxTsh3b9zSvj/gNMAi4r3t+6awKX3FpAux65uJJkd+6M51g2/1OGXHkzV93zWNUnlBHo40GHaHvDKibI55Qz+zrLXFp2qHJjv7VTPSONiVLRVMAxXKhrjzO4YfwzdOzei+joaC4d2FkNKZEmpHNMEDcPakXrCCWNEalLPp4WesSGAJQaUlvWqEemYbY4n4tktlgY9cg0p68FhIQTGLqDuI7/x7Cb/otf4AKgiP1bY3jroThevz+OTX8EYHOS3C/l2GHid27h0K6/Sy1IfGjX38Tv3ELKscPlzonfuZm3Hh5N/M7Npf6dmVfI+gOpzF4dzwfL9rFo2zH2JGZRUFS9DKGfffYZHh72WRqORpPjq4eHB5999lm1risi1VOtBBRz5szhyy+/5ODBg+Tnl87Ss379+hoJrL45xoFnFYCflwc+no9pArpIExXg7cFVvWPZcDCVZbuSKLQ17qe6Io1FyXmOt9xyK2+98y7x8YdKzV90JQOnM5mpiUTFtuHyOyfSslNPRowxOH5wD3/Mj2L1L0Ec3OHLx8/6EtE8n/OuSaXfhRl4eds/+87mc1WWiApgzcL5xUupGAZOl1XJzCvkr0Pp/HUoHQ+zidgwX9pEBBAX6utyVsDKMpeuWrWqyrXw6pK1sIj4lFzaRwXUdygitcbtxtT06dOZPHkyY8eOZf78+dxyyy3s2bOHNWvWMG7cuNqIsd54e3tTsu2khpRI09a7ZSixoX78uOUoyS6kcxaRU1M2gcW//nUXVquVQxkFrNmfSkJ6XqnjKxrW5syahfPZs3kN6xZ9S8tOPTGZTORbN3M8fhq3Pf0Ye7cMYtm3ISQd8WLO9Gh++jicsy5PZ/DlaS6vR1cyI+H6xd8CsPbXb4uPXffbdxUuq1JoM9iflMP+JHuWQz8vC7GhfsSF+RIb6keon2eVQwKdZS6tbynZ+exLymZfUjZH0nIxAfcN7VDfYYnUGrcbU2+99RbvvvsuN954IzNnzmTixIm0bduWJ554gpSUlNqIUUSkzkQGenPjgJb8vjORxExrfYcj0uSVfFBpMpnw8fGhvY8P7aMCOZicw+r9KaSFhBMYGkFIZMUZOMF5uvWS60Qumz+L3ZtW0azNl1x1T0cuuC6FVT8Fs3RuKKnHPPnls3AWfRFK537/ILLFco4d/KZcvCV7w5z1YOVmpRf/OycjrdLerJJy8ovYeSyTnccy7T8XTzPRgT7EBPsQHeRNdJAPgSemGVSVuRTqJm16kc3geGYeR9PzOJqWx9H0XDLzCksd41EHWQ1F6pPbCSj8/PzYtm0brVq1IioqioULF9KrVy927drFmWeeSXJycm3Feso0oVFE3HE8M4+oQPfWjmvq9UxTL580TEfScvlz51EOphVUmoXPlWQVQLlsgMERLdi8PIClX4dyYFvJ7HsLgTeB7wF7z89NE6fSb9gVAKxb9G2FPVglOXqz+g4d6WKJnfPxtBDm70mYvzcBHjaiQgII9ffG38sCtsJSDdP777+fN954g/vvv5/XX3/9lN7XZjNIzy0gJSeflGz7lpqdT2Kmtcph0R5mk9s9U6pnpDFxu2cqJiaGlJQUWrVqRcuWLVm5ciW9evVi3759jT57jIhISe42pESkdjQP8eWaAW05npnHmn2p7DqeiclJOvPKhueV5Gz+U8tOO7h6XCpH94UzZ3oqhQWXAxcCF+Ljn0RR4XQKrDPYvWlVcWOqsvlcJVU2t8sdeQVFHEkr4kjaieGPBzKLX/P2NGNNPYYtJwMfLwufzvofAJ/O+pyzL7kaT7OJ0LAIYlu2xGwy4egvKrTZyC80KLTZKCgyyC+0kZNfSJa1kGxrETn59q823eOJOOV2Y+qCCy7g22+/pXfv3txyyy2MHz+eOXPmsHbtWrcW9xURERFxR1SgD5f2bEZKdjir96WwIyGz1E2+q40bh5Lzn8oP2WsF3A3cTl52BPAM8CjrF8+lXY8jRLdKISAktPhoZ/O4Su6rznpV7rAW2Jhw9dnl9qcmJ3HdxecVf1/ZUEMRcZ/LqdG///57bDYb7777LpMnTwZg3LhxfPjhh3Tp0oVnnnmGt99+u9YCFREREQEI8/fi4u4xjD2rNT1jg53Oy6ks3brDA9O/Kh56N+qRaZjNJVOwH8C+RlUscCuwAfClMH8U/3v5PF67rx3P3TwHD88oAkMjiO3QnUtumYDZ4oHZYuHSWx8ktkN3AkMjCAgJL5XtrzIl06q7q7pp5GvaqZRBpLFxuWfqyiuvJDo6mrFjx3LrrbfSrl07AG644QZuuOGGWgtQRERExJlgP0+GdolmYNtw1h1IZcvh9BPrS5VOVpF8NJ6czLRKswH2HTqSv1cuZuPSBWXeJQ/46MR2FnAXcB3QC5jBq/fZ6Hn2TgZclEm7nnmce/VYADy9vTnjvEvITEkkKy25OCHG2l+/Zf/WDZx9xc2069m/VIY/KJ1i3d0erOqmka9pJctgMZm44Pm7ajURhkh9crkxtW/fPj766CM+/vhjXnzxRc4++2xuv/12rrnmGnx9fau+gIiIiEgtCPD24NyOkQxoHcaGgyGEzV5CER6YTCYGXXo9yUfjeWP8jU6zAZbMALhj3bLSFzaZoFSj688T2wOERD6MxeMeko8Gs25RKOsWhRIaVUDfoRn0uzCDqNgCnh89tFysuVnpxO9M53/THgHsw+6qykJYNq26KypqOLo73NDV4ysqQ3ZaCuuXLGbGjBl89NFHbpVBpDFwO5sfwOLFi5k5cyZff/01Hh4e3HDDDdx2223079+/NmKsMcoOIyK1ranXM029fNI0WAuL+OtQOusPpJKTb09GUZifj8XTs1w2QFczADprnJx9xc1kpLTnrz9isHj8k6JCv+LjW3bOJbL5CtYvuQXDdtDpNUeM+Ted+5/Dq/f+o8r3r2yuU8kGT2BoJK/e+49yDcfxb35NSGQMc2c8x7L5nzLkypu56p7Hqnzfio53vGf/4Vex5pd57N60qsprrVu3DsMwiIiIoFWrVhUep3pGGpNqNaYcMjMzmT17NjNnzmTlypV0796dTZs21WR8NUofThGpbU29nmnq5ZOmpaDIxt9HMlh3IJWM3AKnx1SW3txkNnP57RNZ/NX7BISE03XgeWz5cxHHDu4GwDcgGLD3NvkGxnDBtfPZuqol+7dFYdhKTktfDnwFzAEOO43DbLFUukiwY26Xs56isg2esg3HpMMHyMvJwmQy8e7k28lKSymXHr5kz1fJXqaKjl8y5yOWzf+U5m07cWTvDjr1HcyujSurzKToUNntp+oZaUxOqTEFsHfvXj788EPefvttMjIyKChwXlk1BPpwikhta+r1TFMvnzRNNpvB9oRM1h1IISkrv9zrh3b97XSe0YQZc4nt0I3C/HwmXubO/KUorrpnM5t+D2Dv375glEyCsRb7ulU/AOswW8zc+NCLGBh8/tLECmNwcDSc+g+/irNH/tOlBpIrvW8le75cOd43IIjcrIzioZC+AcEMv3kc899+odLzPDw8mDlzJqNGjarwGNUz0pi4nRodIDc3l6+++ooPP/yQP/74gzZt2jBhwgTGjh1bw+GJiIiInBqz2UTX5kF0aRbI3qRs1u1P5XBabrnjKppn5OHl5fIaVvaepIfpOzSNIVemEb8zhbceno/NdjUF1r5AvxPbU0ACXfpbMZm92LjkYaexgPP5SGt+mceaX+aVOsfZ+llQ+fpbJdPDO7hS1tysDPs/TsSYm5VeZUMKYNWqVfTp06fK40QaC7caUytXruTDDz/kyy+/JD8/n6uvvppff/2V888/v7biExEREakRJpOJdpEBtIsM4EhaLmsPpLI3MctpBkBHggqH6i7QG9cxjGe/GsXR/Tt59d7LgUtObBcBMfy9Ev5eCfAZMBlMS+gxyMLR/TPJzd5OQEg4z4w6161ylm0guZvlr7LjzWYLNlvlDcrAsJZ07DOOdb8mAGcC0ZjNF2Cz2dwqh0hj4HJjqmvXruzYsYPevXszZcoUbrrpJoKDg2szNhEREZFa0TzEl5EhvqRk57PuQDDBs5aA5WQGQEeCCmeqWqC3LA8vLwJDIwgMLSIkci0DL27Nyh9f4NCuUOwNq/OBM4AuYHRh858AdwKHmTsjmF7n/M5fy57HsK0DkqosW2Vp0CtLD+/K8Tc+/CKzXirZixYIdAd6AD2BAWSl9mbdr6VvMXv2HEpCwmaioqKqfE+RxsTlxtSwYcP43//+R69evWozHhEREZE6E+bvxYVdozmrXTibDqWx+VA6OflFThtSJXuwegy+kJ8+mQ4YjBjzAH8t+6Vcb1ZJIZExPP7p4uLEEIMuvZ7/TrqFXRseOnFEKHAO9obVedgbKC3Y8ifAEOCnE8clAttObFuB3cAhIB5IA8o3kOJ3bmbejOfwCwohPCauwt63israb9gNrPhhNelJfuzdMhh4FWh/IsbW5c41DPALzCO6VRJtu1p57O52nHnmz5hM+Xh7ezt9P5HG6pQTUNSV559/nh9++IGNGzfi5eVFWlqa29fQhEYRqW0NuZ5RPSpStcIiG9uOZrIhPpVkJ8kqSmbKK7BaAfsCvSXTrVfGWaY8Z+79z3yWzvuLzctSiGhxHQXW7qQnBVR6bZMpF0yHadkpgsAQD3wDivAJsLF/6xLidyyjTbcz6HXucCxmMJkNbEVFFBV5UmA1U2A1kZyQzO6NfxMVN4CiwjAyUsxkp3uQl2Op4qd2CNh8YlsPrABOpoN391ZT9Yw0JtVKQFEf8vPzufbaaxk0aBAffPBBfYcjItLoqB4VqZqHxUyP2GC6twjiYEoOG+PT2JeUXbx2b8nGkmeJXhaTyVRlQwrguZsvcCmO1OM72bflVSCFvOxPuPGhKXz20lP4Bw6kbfd/sn1tEjmZzQlvfg5ZaX5kp3tgGL5gtOfAtrJXuwq4in1/w76/K3vXcKAjGU7adz5+RYQ3LyA8poDQqDwiWhQR0TyHpCM/MO+t8RUmtxg18SWXyivSWDWanimHmTNn8sADD+iJqog0SI2hnlE9KuKe9NwC/jqUxpbDGeQVuLaOUkUqXdfKxXlMr/yyo1xPWL7VRHqSB2mJHmSlevDplKeAkBJbAGAptXUfdCEG2ZjIxcOriL9X/kCBNQlv31wuHHUNvgF5RDT3JrZ9BD7+NkwmJ8FQeWr51p26c9/QDlX/YEpQPSONSaPpmaoOq9WK9UQXPNg/nCIi4jrVoyIQ7OvJkA6RnNk2nJ3HMtl8KJ2j6XnVulZlmfLGv/k1CQf3MNuFNOZle8K8vA0iWxQQ2cK+3qfN1qHKdOh9h3ZzuqaUNRe+f//l4u9LrkFVGXeTW4g0BeaqD2m8pkyZQnBwcPEWFxdX3yGJiDQqqkdFTvK0mOnWPJgbBrTkn2e24oy4ELw9K76Vit+5mbceHk38zs1OXzed6Ooxlejy6Td0JA9M/8rp8Tc8OIW+PPo8OgAAGs1JREFUQ0e6FGvfSq7zwPSviq8z6pFppd6/rE59z67yvRzJKmI7dOea+58mtkN3AkMjKkxuIdKUuNQzNX36dJcveP/997t87KRJk3jppcrH0m7bto3OnTu7fM2SHn30USZMmFD8fUZGhm4ERKRJUT0qUj8iA705v3MUZ3eIYPfxLLYeySA+NYeSHTJrFs5n96ZVrP11PnEdexTvd2VdKyg/7G/b6qX0G3aF27E66zFyJMKIbtkOH//Ak4vwlnF4zzYO7fobwzDwDw4lLLpFuWOcZSp0JRmHSFPgUmPq1VdfLfV9YmIiOTk5hISEAJCWloafnx9RUVFuNaYefPBBxo4dW+kxbdu2dfl6ZXl7eysFp4g0aapHReqXp8VMl2ZBdGkWRGZeAYvXbmXDzoNk5BWycekPAGxYsoD+F15VqkFSWeMjICQc/6BQAkLC6X7WUBZ/9T62oiJ2rl9eZcOmpMoaba4uBJyVllxqSGJFQ/5KNpxcTcYh0hS41Jjat29f8b8///xz3nrrLT744AM6dbKPs92xYwd33HEHd911l1tvHhkZSWRkpFvniIjISapHRRqOQB9PrhhyRok99uFzzhoklTU+QiJjyM5IJTsjlWMHdxfvz85Ic6lhU/I6FTXaOvYZzM71y10uW8n5WiJykttzph5//HHeeOON4oYUQKdOnXj11Vd57LHHajS4kg4ePMjGjRs5ePAgRUVFbNy4kY0bN5KVlVVr7yki0pSoHhWpfZ999hkeHo5n1aWTMJgtHox6ZJpL1xn1yDTMFufrO5ktFpev4+HlVTwnKvX4EY7u38mhXX9zZG+5/OmVemD6V0TFtal0DpjI6cjtbH5Hjx6lsLCw3P6ioiKOHTtWI0E588QTT/Dxxx8Xf9+7d28AFi9ezHnnnVdr7ysi0lSoHhWpfaNGjaJLly707du33GtrVq8irkM39iVlsy8pi6PpeVSU9K6yrH8PTP+K2A7dnJ4Xv3Mz3703jcvveLjUPC1wfY0rcD7PqqI5YCKnM7d7poYOHcpdd93F+vXri/etW7eOu+++m2HDhtVocCXNnDkTwzDKbboBEBFxjepRkbplNptLfQV74ooBbcK4vn9L7jqnHRd1i6Fr8yACfSp+vu0s619FSjZ4yqqst8tkMhEWE4t/cCj+wWHFmfliWnfELzCEzNTkUnPADu36m/idW0g5drjKmESaMrd7pj788EPGjBlDv3798PT0BKCwsJCLLrqI999/v8YDFBEREWlMoqKiiImJIS4ujttuu40PPviA+Ph4oqKiSh3n62Wha/Mguja3L0yblpPPodRc4lNyOJqeR5qLWf8cmflMJlOlSS+qWuOqRfuuFBXY16lyzLOaM/1JAN577I7iY11NSiFyOjAZ1VxVbefOnWzfvh2Azp0707FjxxoNrDZoRW0RqW1NvZ5p6uUTqSlWqxWvE/OVDMMgPz/f7cyYuflFHEhMJyXXRmKWleMZeaRl5pbLlOds4d2yHA2eQ7v+5pVxV5cbxjdhxlynQwfXLfrWhcV/R+JhNhHk60mInyfBvp6E+HkR6udJiK8XwX6ebpVb9Yw0Jm73TDm0bt0awzBo165diYmWIiIiIlKy4WQymaq1xICvl4XOLcJK7bMWFpGaXUBytpXU7ALScvMZ9/RrvP3MQ9iKys9pL5uFz9U1rhwq68364offGDSwP0E+HgR4e7g0DFGkqXG7FZSTk8N9991XPIl5586dtG3blvvuu48WLVowadKkGg9SRERERMDbw0JMsIWYYJ/ifZf1/De3XjbEadKLz79bRLsuPcgvsmEYYGsdypDfN2DxsA/ju3/c3dgKC/Dz88FiNuFpNuPjacbH04KPpwVfLwtbQzJ4BfvcL5vNVvy1bWQALUJ867D0Ig2P242pRx99lE2bNrFkyRIuvvji4v3Dhg3jqaeeUmNKREREpJ6UbfB0iA6kT+uwqk+sRPNmMS7NARM5HbndmPrmm2/44osvOPPMM0t153br1o09e/bUaHAiIiIiUjVXk15UR2xsLPv37y+eA3bnnXdWaw6YSFPkdmMqMTHR6QczOztbY2VFRERE6kFtN3hqYg6YSFPk9jpT/fr144cffij+3tGAev/99xk0aFDNRSYiIiIiLvP29i61JpUaPCK1z+2eqRdeeIERI0awdetWCgsLef3119m6dSt//vknS5curY0YRUREREREGhy3e6bOPvtsNm7cSGFhIT169OCXX34hKiqKFStWOM0iIyIiIiIi0hRVa4Godu3a8d5779V0LCIiIiIiIo2G2z1Tw4YNY+bMmWRkZNRGPCIiIiIiIo2C242pbt268eijjxITE8O1117L/PnzKSgoqI3YREREREREGiy3G1Ovv/46hw8f5ptvvsHf35/Ro0cTHR3NnXfeqQQUIiIiIiJy2nC7MQX21bWHDx/OzJkzOXbsGO+88w6rV6/mggsuqOn4REREREREGqRqJaBwSEhIYPbs2Xz22Wf89ddfDBgwoKbiEhERERERadDc7pnKyMjgo48+4sILLyQuLo63336bkSNHsmvXLlauXFkbMYqIiIiIiDQ4bvdMRUdHExoayvXXX8+UKVPo169fbcQlIiIiIiLSoLnVmDIMg+nTpzNq1Cj8/PxqKyYREREREZEGz61hfoZhMG7cOA4fPlxb8YiIiIiIiDQKbjWmzGYzHTp0IDk5ubbiERERERERaRTcTkDx4osv8vDDD7Nly5baiEdERERERKRRcDsBxejRo8nJyaFXr154eXnh6+tb6vWUlJQaC05ERERERKShcrsx9dprr9VCGCIiIiIiIo2L242pMWPG1EYcldq/fz/PPvssv/32GwkJCTRv3px//vOfTJ48GS8vrzqPR0SksVE9KiIiUvPcbkwB7Nmzh48++og9e/bw+uuvExUVxY8//kjLli3p1q1bTcfI9u3bsdlsvPPOO7Rv354tW7Zwxx13kJ2dzcsvv1zj7yci0tSoHhUREal5JsMwDHdOWLp0KSNGjGDw4MH8/vvvbNu2jbZt2/Liiy+ydu1a5syZU1uxljJt2jTefvtt9u7d6/I5GRkZBAcHk56eTlBQUC1GJyKnq8ZUz6geFZGGSPWMNCZuZ/ObNGkSzz33HAsXLiw1NOSCCy5g5cqVNRpcZdLT0wkLC6v0GKvVSkZGRqlNRETsVI+KiIicGrcbU5s3b+aqq64qtz8qKoqkpKQaCaoqu3fv5o033uCuu+6q9LgpU6YQHBxcvMXFxdVJfCIiDZ3qURERkVPndmMqJCSEo0ePltu/YcMGWrRo4da1Jk2ahMlkqnTbvn17qXMOHz7MxRdfzLXXXssdd9xR6fUfffRR0tPTi7f4+Hi34hMRaehUj4qIiNQft+dMPfTQQ6xatYqvvvqKjh07sn79eo4dO8bo0aMZPXo0Tz75pMvXSkxMJDk5udJj2rZtWzyc8MiRI5x33nmceeaZzJw5E7PZvbagxuCKSG2r63pG9aiINDWqZ6QxcTub3wsvvMC4ceOIi4ujqKiIrl27UlRUxE033cRjjz3m1rUiIyOJjIx06djDhw9z/vnn07dvXz766CO3bwBERJoi1aMiIiL1x+2eKYf4+Hg2b95MVlYWvXv3pkOHDjUdW7HDhw9z3nnn0apVKz7++GMsFkvxazExMS5fR086RKS2NdR6RvWoiDQWqmekManWOlMAcXFxxb1TmzdvJjU1ldDQ0JqMrdjChQvZvXs3u3fvJjY2ttRr1WwLioicVlSPioiI1Dy3x3g88MADfPDBBwAUFRVx7rnn0qdPH+Li4liyZElNxwfA2LFjMQzD6SYiIlVTPSoiIlLz3G5MzZkzh169egHw3XffsXfvXrZv38748eOZPHlyjQcoIiIiIiLSELndmEpKSioeX79gwQKuu+46OnbsyK233srmzZtrPEAREREREZGGyO3GVHR0NFu3bqWoqIiffvqJCy+8EICcnJxSE5pFRERERESaMrcTUNxyyy1cd911NGvWDJPJxLBhwwBYtWoVnTt3rvEARUREREREGiK3G1NPPfUU3bt3Jz4+nmuvvRZvb28ALBYLkyZNqvEARUREREREGqJqpUa/5ppryu0bM2bMKQcjIiIiIiLSWLg9Zwpg0aJFXHbZZbRr14527dpx2WWX8euvv9Z0bCIiIiIiIg2W242pt956i4svvpjAwED+/e9/8+9//5ugoCAuueQSZsyYURsxioiIiIiINDhuD/N74YUXePXVV7n33nuL991///0MHjyYF154gXHjxtVogCIiIiIiIg2R2z1TaWlpXHzxxeX2Dx8+nPT09BoJSkREREREpKFzuzE1cuRI5s2bV27//Pnzueyyy2okKBERERERkYbOpWF+06dPL/53165def7551myZAmDBg0CYOXKlSxfvpwHH3ywdqIUERERERFpYEyGYRhVHdSmTRvXLmYysXfv3lMOqrZkZGQQHBxMeno6QUFB9R2OiDRBTb2eaerlE5H6p3pGGhOXeqb27dtX23GIiIiIiIg0KtVaZwogKSmJpKSkmoxFRERERESk0XCrMZWWlsa4ceOIiIggOjqa6OhoIiIiuPfee0lLS6ulEEVERERERBoel9eZSklJYdCgQRw+fJhRo0bRpUsXALZu3crMmTNZtGgRf/75J6GhobUWrIiIiIiISEPhcmPqmWeewcvLiz179hAdHV3uteHDh/PMM8/w6quv1niQIiIiIiIiDY3Lw/y++eYbXn755XINKYCYmBimTp3qdP0pERERERGRpsjlxtTRo0fp1q1bha93796dhISEGglKRERERESkoXO5MRUREcH+/fsrfH3fvn2EhYXVREwiIiIiIiINnsuNqYsuuojJkyeTn59f7jWr1crjjz/OxRdfXKPBiYiIiIiINFRuJaDo168fHTp0YNy4cXTu3BnDMNi2bRtvvfUWVquVTz/9tDZjFRERERERaTBcbkzFxsayYsUK7rnnHh599FEMwwDAZDJx4YUX8uabbxIXF1drgYqIiIiIiDQkbi3a26ZNG3788UeSkpJYuXIlK1euJDExkZ9++on27dvXVowAjBw5kpYtW+Lj40OzZs24+eabOXLkSK2+p4hIU6J6VEREpGa51ZhyCA0NZcCAAQwYMKDOkk6cf/75fPnll+zYsYOvv/6aPXv2cM0119TJe4uINAWqR0VERGqWyXCM12tkvv32W6688kqsViuenp4unZORkUFwcDDp6ekEBQXVcoQicjpqTPWM6lERaYhUz0hj4vKcqYYkJSWFWbNmcdZZZ1V6A2C1WrFarcXfp6enA/YPqYhIbXDULw39OZXqURFpqBpLPSoCgNGITJw40fDz8zMA48wzzzSSkpIqPf7JJ580AG3atGmr8y0+Pr6Oakb3qB7Vpk1bY9kaaj0qUlK9DvObNGkSL730UqXHbNu2jc6dOwOQlJRESkoKBw4c4OmnnyY4OJjvv/8ek8nk9NyyT1RtNhspKSmEh4dXeE5ZGRkZxMXFER8f3+i7mlWWhqkplQWaVnmqUxbDMMjMzKR58+aYzdWaluoW1aN1S2VpmJpSWaBplacx1KMip6JeG1OJiYkkJydXekzbtm3x8vIqt//QoUPExcXx559/MmjQoNoKsUmN21VZGqamVBZoWuVpDGVRPVq3VJaGqSmVBZpWeZpSWUScqdc5U5GRkURGRlbrXJvNBlDqiamIyOlG9aiIiEj9aRQJKFatWsWaNWs4++yzCQ0NZc+ePTz++OO0a9euVp+miog0FapHRUREal6jGIjq5+fH3LlzGTp0KJ06deK2226jZ8+eLF26FG9v71p9b29vb5588slaf5+6oLI0TE2pLNC0ytOUyqJ6tGaoLA1TUyoLNK3yNKWyiDjTaNeZEhERERERqU+NomdKRERERESkoVFjSkREREREpBrUmBIREREREakGNaZERERERESqQY0pYMaMGbRu3RofHx8GDhzI6tWrKz3+q6++onPnzvj4+NCjRw8WLFhQR5FWzZ2yvPfeewwZMoTQ0FBCQ0MZNmxYlWWvS+7+vzjMnj0bk8nElVdeWbsBusHdsqSlpTFu3DiaNWuGt7c3HTt2bDC/Z+6W5bXXXqNTp074+voSFxfH+PHjycvLq6NoK/b7779z+eWX07x5c0wmE998802V5yxZsoQ+ffrg7e1N+/btmTlzZq3H2VioHlU9WtuaUj0KqktVl0qTYZzmZs+ebXh5eRkffvih8ffffxt33HGHERISYhw7dszp8cuXLzcsFosxdepUY+vWrcZjjz1meHp6Gps3b67jyMtztyw33XSTMWPGDGPDhg3Gtm3bjLFjxxrBwcHGoUOH6jjy8twti8O+ffuMFi1aGEOGDDGuuOKKugm2Cu6WxWq1Gv369TMuueQSY9myZca+ffuMJUuWGBs3bqzjyMtztyyzZs0yvL29jVmzZhn79u0zfv75Z6NZs2bG+PHj6zjy8hYsWGBMnjzZmDt3rgEY8+bNq/T4vXv3Gn5+fsaECROMrVu3Gm+88YZhsViMn376qW4CbsBUj6oerW1NqR41DNWlqkulKTntG1MDBgwwxo0bV/x9UVGR0bx5c2PKlClOj7/uuuuMSy+9tNS+gQMHGnfddVetxukKd8tSVmFhoREYGGh8/PHHtRWiy6pTlsLCQuOss84y3n//fWPMmDEN5ibA3bK8/fbbRtu2bY38/Py6CtFl7pZl3LhxxgUXXFBq34QJE4zBgwfXapzucuUGYOLEiUa3bt1K7bv++uuNiy66qBYjaxxUj56kerR2NKV61DBUl6oulabktB7ml5+fz7p16xg2bFjxPrPZzLBhw1ixYoXTc1asWFHqeICLLrqowuPrSnXKUlZOTg4FBQWEhYXVVpguqW5ZnnnmGaKiovj/du4uJKpFDeP4s9NGg7QuxI/AAoUs0hAUwwqk26CPq4Ji8KKQ0G4lSWICSyREhOiDIgq8SEIKQiVKS6gkCNMQMkPFCmokIUhK8GPefXFOc442spu1m1nj+P/B3CzXwPMyrsd5XTrHjh2LRszf4mSW+/fvq7S0VFVVVcrIyFB+fr7q6+s1Pz8frdghOZll586d6uvrC/75ytjYmDo7O7V3796oZP6TYvXadxs9uhA9+ufFU49KdGmsXv+AU4luB3DT5OSk5ufnlZGRseB4RkaG3r59G/I5fr8/5Pl+vz9iOX+Hk1kWO3XqlDZs2PBLyUWbk1mePXumGzduaGBgIAoJf5+TWcbGxvT48WMdPXpUnZ2dGhkZUWVlpWZnZ+Xz+aIROyQnsxw5ckSTk5PavXu3zExzc3M6ceKETp8+HY3If9RS1/63b980PT2tNWvWuJTMXfToQvTonxdPPSrRpXQp4s2KvjOF/2loaFBra6vu3bun5ORkt+OEZWpqSl6vV9evX1daWprbcf61QCCg9PR0Xbt2TUVFRTp8+LBqa2t19epVt6OFraenR/X19bp8+bJevXqlu3fvqqOjQ3V1dW5HA/44ejR2xFOPSnQpEMtW9J2ptLQ0JSQkaGJiYsHxiYkJZWZmhnxOZmZmWOdHi5NZfmpsbFRDQ4O6urq0ffv2SMb8LeHOMjo6qvHxce3bty94LBAISJISExM1PDys3NzcyIZegpPXJSsrS6tXr1ZCQkLw2NatW+X3+zUzMyOPxxPRzEtxMsuZM2fk9Xp1/PhxSVJBQYG+f/+uiooK1dbWatWq5fP7nKWu/dTU1BX9m1R69D/o0ciJpx6V6FK6FPFm+Vx9EeDxeFRUVKTu7u7gsUAgoO7ubpWWloZ8Tmlp6YLzJenRo0dLnh8tTmaRpAsXLqiurk4PHjxQcXFxNKL+o3Bn2bJliwYHBzUwMBB87N+/X3v27NHAwICys7OjGX8BJ6/Lrl27NDIyEnwjI0nv3r1TVlaWq28AnMzy48ePX37I/3xzY2aRCxsBsXrtu40epUcjLZ56VKJLY/X6Bxxz9/Mv3Nfa2mpJSUl269Yte/PmjVVUVNj69evN7/ebmZnX67Wamprg+c+fP7fExERrbGy0oaEh8/l8MfWRvuHM0tDQYB6Px9ra2uzz58/Bx9TUlFsjBIU7y2Kx9ClU4c7y4cMHS0lJsZMnT9rw8LC1t7dbenq6nTt3zq0RgsKdxefzWUpKit2+fdvGxsbs4cOHlpuba4cOHXJrhKCpqSnr7++3/v5+k2RNTU3W399v79+/NzOzmpoa83q9wfN/fpxvdXW1DQ0N2aVLl/g43/+iR+nRSIunHjWjS+lSxJMVv0yZmV28eNE2btxoHo/HSkpK7MWLF8GvlZWVWXl5+YLz79y5Y5s3bzaPx2Pbtm2zjo6OKCdeWjizbNq0yST98vD5fNEPHkK4r8v/i6U3AWbhz9Lb22s7duywpKQky8nJsfPnz9vc3FyUU4cWziyzs7N29uxZy83NteTkZMvOzrbKykr7+vVr9IMv8uTJk5Df/z/zl5eXW1lZ2S/PKSwsNI/HYzk5OXbz5s2o545V9Cg9Gmnx1KNmdCldinjxl9kyuz8MAAAAADFgRf/PFAAAAAA4xTIFAAAAAA6wTAEAAACAAyxTAAAAAOAAyxQAAAAAOMAyBQAAAAAOsEwBAAAAgAMsUwAAAADgAMsUAAAAADjAMgUAAAAADrBMAQAAAIADLFPAIl++fFFmZqbq6+uDx3p7e+XxeNTd3e1iMgBYHuhRACvFX2ZmbocAYk1nZ6cOHjyo3t5e5eXlqbCwUAcOHFBTU5Pb0QBgWaBHAawELFPAEqqqqtTV1aXi4mINDg7q5cuXSkpKcjsWACwb9CiAeMcyBSxhenpa+fn5+vjxo/r6+lRQUOB2JABYVuhRAPGO/5kCljA6OqpPnz4pEAhofHzc7TgAsOzQowDiHXemgBBmZmZUUlKiwsJC5eXlqbm5WYODg0pPT3c7GgAsC/QogJWAZQoIobq6Wm1tbXr9+rXWrl2rsrIyrVu3Tu3t7W5HA4BlgR4FsBLwZ37AIj09PWpublZLS4tSU1O1atUqtbS06OnTp7py5Yrb8QAg5tGjAFYK7kwBAAAAgAPcmQIAAAAAB1imAAAAAMABlikAAAAAcIBlCgAAAAAcYJkCAAAAAAdYpgAAAADAAZYpAAAAAHCAZQoAAAAAHGCZAgAAAAAHWKYAAAAAwAGWKQAAAABw4G9ztnzWSKfQxAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set into eval mode\n", + "model.eval()\n", + "likelihood.eval()\n", + "\n", + "# Initialize plots\n", + "f, axes = plt.subplots(2, 2, figsize=(8, 6))\n", + "\n", + "# Make predictions\n", + "with torch.no_grad(), gpytorch.settings.fast_pred_var():\n", + " test_x = torch.linspace(0, 1, 51)\n", + " predictions = likelihood(model(test_x))\n", + " mean = predictions.mean\n", + " lower, upper = predictions.confidence_region()\n", + " \n", + "# This contains predictions for all tasks, flattened out\n", + "for task, ax in enumerate(axes.flatten()):\n", + "\n", + " # Plot training data as black stars\n", + " ax.plot(train_x.detach().numpy(), train_y[:, task].detach().numpy(), 'k*')\n", + " # Predictive mean as blue line\n", + " ax.plot(test_x.numpy(), mean[:, task].numpy(), 'b')\n", + " # Shade in confidence \n", + " ax.fill_between(test_x.numpy(), lower[:, task].numpy(), upper[:, task].numpy(), alpha=0.5)\n", + " ax.set_ylim([-3, 3])\n", + " if task == 1:\n", + " ax.legend(['Observed Data', 'Mean', 'Confidence'], frameon=False, bbox_to_anchor=(1, 1))\n", + " if not task % 2:\n", + " ax.set_ylabel('Observed Values (Likelihood)')\n", + " if task > 1:\n", + " ax.set_xlabel('x')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gpytorch-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From e226b9bf31885ad57ae4b00ac61f7a07c9da8a46 Mon Sep 17 00:00:00 2001 From: pmrobbe Date: Sat, 20 Jan 2024 17:53:33 -0800 Subject: [PATCH 3/4] Added tests for parallel partial emulation --- .../test_parallel_partial_gp_regression.py | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 test/examples/test_parallel_partial_gp_regression.py diff --git a/test/examples/test_parallel_partial_gp_regression.py b/test/examples/test_parallel_partial_gp_regression.py new file mode 100644 index 000000000..7f7a99766 --- /dev/null +++ b/test/examples/test_parallel_partial_gp_regression.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 + +import os +import random +import unittest +from math import pi + +import torch + +import gpytorch +from gpytorch.distributions import MultitaskMultivariateNormal +from gpytorch.kernels import ParallelPartialKernel, RBFKernel +from gpytorch.likelihoods import MultitaskGaussianLikelihood +from gpytorch.means import ConstantMean, MultitaskMean + + +# Four sinusoidal functions with noise N(0, 0.1) +def eval_functions(train_x, noisy=True): + train_y1 = torch.sin(train_x * (2 * pi)) + (torch.randn(train_x.size()) * 0.1 if noisy else 0) + train_y2 = torch.cos(train_x * (2 * pi)) + (torch.randn(train_x.size()) * 0.1 if noisy else 0) + train_y3 = torch.cos(train_x * pi) + (torch.randn(train_x.size()) * 0.1 if noisy else 0) + train_y4 = torch.cos(train_x * pi) + (torch.randn(train_x.size()) * 0.1 if noisy else 0) + return torch.stack([train_y1, train_y2, train_y3, train_y4], -1) + + +class ParallelPartialGPModel(gpytorch.models.ExactGP): + def __init__(self, train_x, train_y, likelihood): + super(ParallelPartialGPModel, self).__init__(train_x, train_y, likelihood) + self.mean_module = MultitaskMean(ConstantMean(), num_tasks=train_y.shape[1]) + self.covar_module = ParallelPartialKernel(RBFKernel(), num_tasks=train_y.shape[1]) + + def forward(self, x): + mean_x = self.mean_module(x) + covar_x = self.covar_module(x) + return MultitaskMultivariateNormal(mean_x, covar_x) + + +class TestParallelPartialGPRegression(unittest.TestCase): + def setUp(self): + if os.getenv("UNLOCK_SEED") is None or os.getenv("UNLOCK_SEED").lower() == "false": + self.rng_state = torch.get_rng_state() + torch.manual_seed(0) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(0) + random.seed(0) + + def tearDown(self): + if hasattr(self, "rng_state"): + torch.set_rng_state(self.rng_state) + + def test_parallel_partial_gp_mean_abs_error(self): + + # Get training outputs + train_x = torch.linspace(0, 1, 100) + train_y = eval_functions(train_x) + + # Likelihood and model + likelihood = MultitaskGaussianLikelihood(num_tasks=train_y.shape[1]) + model = ParallelPartialGPModel(train_x, train_y, likelihood) + + # Find optimal model hyperparameters + model.train() + likelihood.train() + + # Use the adam optimizer + optimizer = torch.optim.Adam(model.parameters(), lr=0.1) # Includes GaussianLikelihood parameters + + # "Loss" for GPs - the marginal log likelihood + mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, model) + + # Training + n_iter = 50 + for _ in range(n_iter): + optimizer.zero_grad() + output = model(train_x) + loss = -mll(output, train_y) + loss.backward() + optimizer.step() + + # Test the model + model.eval() + likelihood.eval() + test_x = torch.linspace(0, 1, 51) + test_y = eval_functions(test_x, noisy=False) + test_preds = likelihood(model(test_x)).mean + for task in range(train_y.shape[1]): + mean_abs_error_task = torch.mean(torch.abs(test_y[:, task] - test_preds[:, task])) + self.assertLess(mean_abs_error_task.item(), 0.05) + + +if __name__ == "__main__": + unittest.main() From b32df02cd8505576bd349ad58c4d22a3ea91ef54 Mon Sep 17 00:00:00 2001 From: pmrobbe Date: Sat, 20 Jan 2024 18:37:44 -0800 Subject: [PATCH 4/4] Added documentation for parallel partial emulation --- examples/03_Multitask_Exact_GPs/index.rst | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/examples/03_Multitask_Exact_GPs/index.rst b/examples/03_Multitask_Exact_GPs/index.rst index c7fcbfd90..537a2d03d 100644 --- a/examples/03_Multitask_Exact_GPs/index.rst +++ b/examples/03_Multitask_Exact_GPs/index.rst @@ -14,6 +14,9 @@ Multi-output (vector valued functions) - If the outputs share the same kernel and mean, you can train a `Batch Independent Multioutput GP`_. - Otherwise, you can train a `ModelList Multioutput GP`_. +- **Partially correlated output dimensions**: for cases with a massive number of outputs. + See the `Parallel Partial GP Regression`_ example, which implements the inference strategy defined in `Gu et al., 2016`_. + .. toctree:: :maxdepth: 1 :hidden: @@ -21,6 +24,7 @@ Multi-output (vector valued functions) Multitask_GP_Regression.ipynb Batch_Independent_Multioutput_GP.ipynb ModelList_GP_Regression.ipynb + Parallel_Partial_GP_Regression.ipynb Scalar function with multiple tasks ---------------------------------------- @@ -41,11 +45,17 @@ This setting should be used only when each input corresponds to a single task. .. _Bonilla et al., 2008: https://papers.nips.cc/paper/3189-multi-task-gaussian-process-prediction +.. _Gu et al., 2016: + https://projecteuclid.org/journals/annals-of-applied-statistics/volume-10/issue-3/Parallel-partial-Gaussian-process-emulation-for-computer-models-with-massive/10.1214/16-AOAS934.pdf + .. _Batch Independent Multioutput GP: ./Batch_Independent_Multioutput_GP.ipynb .. _ModelList Multioutput GP: ./ModelList_GP_Regression.ipynb +.. _Parallel Partial GP Regression: + ./Parallel_Partial_GP_Regression.ipynb + .. _Hadamard Multitask GP Regression: ./Hadamard_Multitask_GP_Regression.ipynb