\n", "(Be careful not to confuse this $\\Sigma$ matrix, the kernel's covariance matrix, with the covariance matrix of the GP we met above).
\n", "We are going to implement its most straightforward version, the isotropic SE kernel, where the $\\Sigma$ matrix is equal to $\\sigma^{2} \\mathcal{I}$. In this case $\\sigma$ is usually termed 'characteristic length scale', in that it can be roughly interpreted as the distance you have to move in the input space before the function value can change significatively. \n", "\n", "Complete the code below to compute, given the input vectors $X_{p}$ and $X_{q}$, the covariance matrix and its gradient with respect to the log-transformed length scale ($\\log{\\sigma}$), the second of which we will need later when we want to optimize $\\sigma$ w.r.t. the input data. Here the formulas you should implement:\n", "
\n", "
\n", "We said that the covariance matrix of the GP is determined by the kernel function $\\kappa(x, x')$, but this was actually a consequence of the fact that we assumed the observations $y_{i}$ to be noise-free. Let's consider instead the case where our $y_{i}$s are noisy observations of the function $f(\\cdot)$ we want to model, i.e. $y_{i} = f(x_{i}) + \\epsilon$, where $\\epsilon$~$\\mathcal{N}(0,\\sigma_{y}^{2})$. In this case the covariance associated with our observations will be $K_{y}=K+\\sigma_{y}^{2}\\mathcal{I}$, where $K$ is determined by a kernel function $\\kappa(x,x')$ as usual. What we are enforcing in practice is that our regressor won't have to exactly interpolate our data, but it will just have to pass as close as possible (depending on the value of $\\sigma_{y}$) to the observations.\n", "\n", "PREDICTIONS
\n", "Given a training set $\\mathcal{D}=\\{(x_{i}, y_{i})\\}$ with $i=1,...,N$ and a test set $X_{*}$ we want to predict the objective function $f(X_{*})$, in short $f_{*}$. From the GP definition, and assuming zero-mean for simplicity, follows:\n", "
\n", "where $K_{*}=\\kappa(X, X_{*})$ is $N\\times N_{*}$ and $K_{**}=\\kappa(X_{*}, X_{*})$ is $N_{*}\\times N_{*}$. Then for the theorem about conditional probabilities for Gaussians, the posterior will be:\n", "
\n", "Both kernel parameters and $\\sigma_{y}$ can be optimized with respect to the observed data. This is not strictly necessary for the exercise but for completeness I will say en passant that we will take an empirical Bayes approach and use a continuous optimization method. Check the code or paragraph 15.2.4 of Murphy's textbook if you want to know more.\n", "\n", "A REMARK ON COMPUTATIONAL STABILITY
\n", "From the formulas above you have seen that for prediction (and actually for fitting the GP to the data) we need $K_{y}^{-1}$. For numerical stability it is unwise to directly invert the $K$ matrix. More robust approaches would be to compute a Cholesky decomposition of $K$, i.e. $K=LL^{T}$ with $L$ a lower triangular matrix, and than solve $\\alpha = K_{y}^{-1} y = L^{-T}L^{-1}y$ or to solve $\\alpha = K_{y}^{-1} y$ using conjugate gradients (CG). With this second approach modulating the number of iterations of the CG algorithm we can tradeoff the time complexity with the level of approximation on the estimation of $\\alpha$. \n", "\n", "\n", "\n", "\n", "
EXERCISE INSTRUCTIONS
\n", "In the following box you will have to complete the implementation of three functions: \n", "1. _compute_K, which returns the matrix $K_{y} = K+\\sigma_{y}^{2}\\mathcal{I}$\n", "2. _invert, which takes $K$ as input and inverts it (I suggest to use Cholesky decomposition but it is not mandatory)\n", "3. predict, you will have to complete the computation of the posterior mean $\\mu_{*}$ and covariance $\\Sigma_{*}$ as in the equations above.\n", "\n", "Hints: in case you opted for Cholesky decomposition check scipy 'cho_solve' and 'cholesky' functions (already imported)." ] }, { "cell_type": "code", "execution_count": 73, "id": "909c1eee", "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "d7044688a6ac45f17a9abe102452c6a9", "grade": false, "grade_id": "GP", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "class GP(Regressor):\n", " '''\n", " GP regressor for 1d observations\n", " '''\n", " def __init__(self, kernel : Kernel, noise_sigma : float = 0.1, noise_bounds = (0.01, 0.3)):\n", " self.kernel = kernel\n", " self._noise_sigma = noise_sigma\n", " self._noise_bounds = noise_bounds\n", " self._obs = None\n", " self._obs_scaler = 0\n", " self._K = None\n", " \n", " @property\n", " def noise(self):\n", " return np.log(self._noise_sigma)\n", "\n", " @noise.setter\n", " def noise(self, noise_sigma : float):\n", " self._noise_sigma = np.exp(noise_sigma)\n", "\n", " @property\n", " def noise_bounds(self):\n", " return tuple(np.log(self._noise_bounds))\n", "\n", " def _compute_K(self, obs : Optional[Coordinates] = None):\n", " if obs is not None:\n", " self._obs = obs\n", " self._K = None # two terms: one is the kernel function, the other the noise associated with the observation process\n", " x,y = self._obs\n", "\n", " self._K = self.kernel(x) + self._noise_sigma**2*np.identity(self.kernel(x).shape[0])\n", " \n", " @staticmethod\n", " def _invert(K : Matrix) -> Matrix:\n", " '''\n", " 3 options:\n", " - directly invert (this could give errors in other parts of the exercise)\n", " - invert solving system after cholesky decomposition <---- strongly suggested!\n", " - conjugate gradients on system (time complexity is tunable)\n", " '''\n", " Kinv = None\n", " \n", " c = np.linalg.inv(np.linalg.cholesky(K))\n", " Kinv = np.dot(c.T,c)\n", "\n", " return Kinv\n", "\n", " def _nll(self, theta : List[float], compute_grad : bool = True) -> float:\n", " '''\n", " negative log marginal likelihood and gradients\n", " '''\n", " self.kernel.theta = theta[:-1]\n", " self.noise = theta[-1]\n", " if compute_grad:\n", " K, K_grad = self.kernel(self._obs[0], compute_grad=True)\n", " else:\n", " K = self.kernel(self._obs[0])\n", " K += self._noise_sigma**2 * np.eye(K.shape[0])\n", " L = cholesky(K, lower=True)\n", " alpha = cho_solve((L, True), self._obs[1])\n", " l_likelihood = -.5 * self._obs[1].dot(alpha) - np.log(np.diag(L)).sum() - len(K)*.5*np.log(2*np.pi)\n", "\n", " if compute_grad:\n", " dummy = np.einsum('i,j->ij', alpha, alpha) - self._invert(K)\n", " # directly compute trace\n", " l_likelihood_grad = [-.5*dummy.ravel().dot(K_grad.T.ravel())]\n", " # add noise\n", " l_likelihood_grad.append(-dummy.ravel().dot((self._noise_sigma*np.eye(K.shape[0])).ravel()))\n", "\n", " return -l_likelihood, l_likelihood_grad\n", " else: \n", " return -l_likelihood\n", "\n", " def fit(self, obs : Coordinates, optimizer : str = 'L-BFGS-B', n_restarts : int = 40, verbose : bool = False):\n", " '''\n", " only for bounded minimization\n", " '''\n", " assert obs[0].size != 0, 'cannot fit model if no observations are provided'\n", " self._obs_scaler = np.min(obs[1])\n", " self._obs = (obs[0], obs[1] - self._obs_scaler)\n", " def objective_func(theta):\n", " return self._nll(theta)\n", " theta_opt, func_min = [], []\n", " for i in range(n_restarts):\n", " bounds = [tuple(b) for b in self.kernel.bounds]\n", " bounds.append(self.noise_bounds)\n", " if i > 0:\n", " temp = [np.random.uniform(b[0], b[1]) for b in bounds]\n", " gp.kernel.theta = temp[:-1]\n", " gp.noise = temp[-1]\n", "\n", " theta = self.kernel.theta\n", " theta = np.append(theta, self.noise)\n", " opt_res = minimize(objective_func, theta, method=optimizer, jac=True, bounds=bounds)\n", " theta_opt.append(opt_res.x)\n", " func_min.append(opt_res.fun)\n", " best = np.argmin(func_min)\n", " if verbose:\n", " print(f'Nll minimum : {func_min[best]}, optimal hyperparameters : {np.exp(theta_opt[best])}')\n", " self.kernel.theta = theta_opt[best][:-1]\n", " self.noise = theta_opt[best][-1]\n", " self._compute_K()\n", "\n", " def sample_functions(self, X, n_functions : int = 1, plot : bool = True):\n", " Ks = self.kernel(self._obs[0], X)\n", " Kss = self.kernel(X)\n", " Kinv = self._invert(self._K) \n", " mean = Ks.T.dot(Kinv).dot(self._obs[1])\n", " covariance = Kss - Ks.T.dot(Kinv).dot(Ks)\n", "\n", " samples = np.random.multivariate_normal(mean, covariance, n_functions)\n", " if plot and len(X.shape) < 2:\n", " fig, ax = plt.subplots()\n", " ax.scatter(self._obs[0], self._obs[1], marker=\"o\", s=50, c=\"C1\")\n", " for i in range(samples.shape[0]):\n", " ax.plot(X.squeeze(), samples[i, :], lw=1, ls='--')\n", " #plt.savefig('samples_Wtrain_noise'+str(self._noise_sigma)+'.png')\n", " plt.show()\n", " plt.close()\n", " return samples\n", "\n", " def predict(self, X : Coordinates, compute_std : bool = True, compute_covariance : bool = False):\n", " assert not(compute_std and compute_covariance), 'choose at most one among std and covariance'\n", " Ks = self.kernel(self._obs[0], X)\n", " Kinv = self._invert(self._K)\n", " mean = None\n", " \n", " mean = Ks.transpose().dot(Kinv.dot(self._obs[1]))\n", " \n", " if compute_covariance:\n", " Kss = self.kernel(X)\n", " cov = None \n", " \n", " cov = Kss - Ks.transpose().dot(Kinv.dot(Ks))\n", "\n", " return mean + self._obs_scaler, cov\n", "\n", " elif compute_std:\n", " dummy = Kinv.dot(Ks)\n", " var = np.diag(self.kernel(X)).copy()\n", " var -= np.einsum(\"ji,ji->i\", Ks, dummy)\n", " var[var<0] = 0 # there could be negative variances because of computational errors\n", " return mean + self._obs_scaler, np.sqrt(var)\n", " else:\n", " return mean + self._obs_scaler" ] }, { "cell_type": "code", "execution_count": 74, "id": "079ac478", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "555fc98ecc0928d03d02c1abc51ea67c", "grade": true, "grade_id": "compute_K", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "##### DO NOT CHANGE #####\n", "# ID: compute_K - possible points: 1\n", "\n", "# compute_K - 1 point\n", "kernel = Matern52()\n", "gp = GP(kernel=kernel)\n", "test_framework = Frame(dim = 1, func = 'func_2')\n", "\n", "np.random.seed(12)\n", "observations = test_framework.get_samples(n_samples = 2)\n", "gp._compute_K(observations)\n", "answer = np.array([[1.01000000e+00, 1.47418222e-05],\n", " [1.47418222e-05, 1.01000000e+00]])\n", "assert np.isclose(gp._K, answer).all(), 'ooops...'\n", "\n", "# similar hidden test\n", "\n", "##### DO NOT CHANGE #####" ] }, { "cell_type": "code", "execution_count": 75, "id": "072b7df8", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "7089b0d4dfacfd679321c3de3e7da855", "grade": true, "grade_id": "invert", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "##### DO NOT CHANGE #####\n", "# ID: invert - possible points: 1\n", "\n", "# invert - 1 point\n", "kernel = Matern52()\n", "gp = GP(kernel=kernel)\n", "\n", "K = np.array([[1, 1],\n", " [1, 5]])\n", "Kinv = np.array([[ 1.25, -0.25],\n", " [-0.25, 0.25]])\n", "assert np.isclose(gp._invert(K), Kinv).all(), 'ooops...'\n", "\n", "# similar hidden test\n", "\n", "##### DO NOT CHANGE #####" ] }, { "cell_type": "code", "execution_count": 76, "id": "57a7a6a1", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "295b053b4ef06c8360d5e75f42d03943", "grade": true, "grade_id": "predict", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "##### DO NOT CHANGE #####\n", "# ID: predict - possible points: 1\n", "\n", "# predict - 1 point\n", "\n", "test_framework = Frame(dim = 1, func = 'func_2')\n", "kernel = Matern52()\n", "gp = GP(kernel=kernel)\n", "\n", "np.random.seed(12)\n", "observations = test_framework.get_samples(n_samples = 4)\n", "gp._compute_K(observations)\n", "val, cov = gp.predict(X=np.array([5, 6]), compute_covariance=True, compute_std=False)\n", "true_val = np.array([-1.6872044, -0.10250491])\n", "true_cov = np.array([[ 0.23048763, -0.06465079],\n", " [-0.06465079, 0.6058542 ]])\n", "assert np.isclose(val, true_val).all() and np.isclose(cov, true_cov).all(), 'ooops...'\n", "\n", "# similar hidden test\n", "\n", "##### DO NOT CHANGE #####" ] }, { "cell_type": "markdown", "id": "2fe3273c", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "markdown", "checksum": "b68b4a1f819bca17165e1f9bf5afba8c", "grade": false, "grade_id": "cell-e6e17befe4a23495", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "Let's have a look at the effect of the kernel parameters on the GP.\n", "\n", "As stated above the length scale controls the horizontal scale over which the function changes. Given a set of observations let's see what the predictions of the GP will be varying the kernel parameters. \n", "\n", "(If you had problems implementing the SE kernel you can use Matern52 or Matern32 kernels from the utils file.)" ] }, { "cell_type": "code", "execution_count": 77, "id": "1ad4f7fa", "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Plotting the observations and the ground truth\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
Try it out on different datasets (read comments next to uppercase variables).\n", "\n" ] }, { "cell_type": "code", "execution_count": 119, "id": "e649bb93", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlA0lEQVR4nO3dd3iT570+8FuS95L33hsbL8wyIYwEMASSkGbvpJSepqQNJadp6Dm/pD3n9NC0TZs2m7TNKKUkaQIkhBEgjBAMGGNjDHgPeWOMLeMlWdL7+6PgExIMHpIe6dX9uS5dVyy/40ax5a+e932+j0KSJAlEREREZPeUogMQERERkXmwsCMiIiKSCRZ2RERERDLBwo6IiIhIJljYEREREckECzsiIiIimWBhR0RERCQTLOyIiIiIZMJJdABzM5lMaGlpgbe3NxQKheg4RERERGMiSRIuXryI8PBwKJVjG4OTXWHX0tKCqKgo0TGIiIiIJqSxsRGRkZFj2kd2hZ23tzdw6cXw8fERHYeIiIhoTHp6ehAVFTVc04yF7Aq7y5dffXx8WNgRERGR3RrPLWWcPEFEREQkEyzsiIiIiGSChR0RERGRTLCwIyIiIpIJFnZEREREMsHCjoiIiEgmWNgRERERyQQLOyIiIiKZYGFHREREJBMs7IiIiIhkgoUdERERkUxYtLBbt24dpk2bBm9vbwQHB2P58uWoqKi47n4ffvghUlNT4ebmhoyMDGzfvt2SMYmIiIhkwaKF3YEDB7Bq1SocOXIEu3fvxtDQEBYtWoS+vr4R9zl8+DDuv/9+rFixAsXFxVi+fDmWL1+OsrIyS0YlIiIisnsKSZIka52so6MDwcHBOHDgAObMmXPVbe6991709fVh27Ztw8/NnDkT2dnZeOONN657jp6eHqjVami1Wvj4+Jg1PxEREZGlTaSWseo9dlqtFgDg7+8/4jYFBQVYsGDBFc/l5+ejoKDgqtvrdDr09PRc8SAiIiJyRFYr7EwmE1avXo0bbrgBkydPHnG7trY2hISEXPFcSEgI2trarrr9unXroFarhx9RUVFmz05ERERkDUNDQ+jt7R33/k5mTXMNq1atQllZGQ4dOmTW465duxZr1qwZ/rqnp4fFHREREdkNk8mEhoYGnDx5EmfOnEF8fPy4j2WVwu7JJ5/Etm3bcPDgQURGRl5z29DQULS3t1/xXHt7O0JDQ6+6vaurK1xdXc2al4iIiMgaLl68iLfeegs9PT3w8/NDXl4e4uLixn08ixZ2kiThRz/6ETZv3oz9+/ePKmheXh727t2L1atXDz+3e/du5OXlWTIqERERkdUMDAzA3d0dXl5eyM7ORmJiIqKioqBQKCY0X8Ci99itWrUKGzZswMaNG+Ht7Y22tja0tbVhYGBgeJtHHnkEa9euHf76qaeews6dO/Hiiy+ivLwcv/jFL3D8+HE8+eSTloxKREREZBVarRavv/46jh8/DoVCgZtuugnR0dFQKBQTPrZFC7vXX38dWq0W8+bNQ1hY2PDj/fffH95Go9GgtbV1+OtZs2Zh48aNWL9+PbKysvDPf/4TW7ZsueaECyIiIiJ7MDAwgA0bNkChUCA5Odnsx7dqHztrYB87IiIiskVDQ0PYsGED2tvbsWLFCgQFBV11O7vpY0dERETkqA4dOoTm5mY88MADIxZ1E2W1didEREREjuyGG25AfHw8oqOjLXYOjtgRERERWVBZWRnOnTsHFxcXxMTEWPRcLOyIiIiILGRwcBDbt2/H0aNHrXI+FnZEREREFnL48GHo9XrMmTPHKudjYUdERERkAT09PTh8+DBmzpwJtVptlXOysCMiIiKygIMHD8LZ2RmzZ8+22jk5K5aIiIjIAubOnYu0tDS4ublZ7Zws7IiIiIjMTK/Xw9vbG97e3lY9Ly/FEhEREZlRfX09XnrpJXR2dlr93CzsiIiIiMxEkiTs3r0bvr6+8PPzs/r5WdgRERERmcmZM2fQ3NyMhQsXQqm0fpnFwo6IiIjIDAwGA/bs2YOkpCTExcUJycDCjoiIiMgMent74eXlhZtvvllYBs6KJSIiIjIDX19frFixQmgGjtgRERERTVBXVxfq6+shSZLQHCzsiIiIiCbo6NGj+OCDD2A0GoXmYGFHRERENAFDQ0MoKSlBTk4OnJzE3uXGwo6IiIhoAk6fPo3BwUHk5uaKjsLCbqL0ej1qa2vR29srOgoREREJcPz4cSQkJMDf3190FM6KHa/q6mocPnwYDQ0NMBqNUKlUWLRoEWbMmCE6GhEREVmJyWRCYmIiIiMjRUcBWNiNTWFhIby9vZGamgqDwQCFQoGFCxciNjYWVVVVCAkJAQC0tLQAAMLDwwUnJiIiIktSKpWYN2+e6BjDWNiN0uHDh/H5558jPz8fAJCamorU1NTh74eGhg7/95EjR1BaWoqEhATcddddcHd3F5KZiIiILEen0+Grr77C9OnT4eXlJToOwHvsRudyUXfjjTdi5syZ191++fLluOuuu9Dc3IyPPvoIJpPJKjmJiIjIesrKyvDll1/CYDCIjjKMhd11HDt2bLiou+mmm6BQKK67j1KpxOTJk3H33XejpqYGX3zxhVWyEhERkXVIkoTCwkIkJSXB19dXdJxhvBR7HTExMbjppptw4403jqqo+7qEhATcdtttCAsLs1g+IiIisr6Wlha0tbVh/vz5oqNcgYXdCE6fPo2kpCSEhIQMT4oYj5ycHOBS80KtVovAwEAzpiQiIiIRjh8/Dh8fHyQlJYmOcgVeir2K06dP48MPP8Tp06fNdsxdu3bhnXfeQU9Pj9mOSURERGLk5ORg2bJlUCptq5SyrTQ2YHBwEDt27EBqaiqys7PNdty5c+dCoVDg/fffx9DQkNmOS0RERNYXHR2N5ORk0TG+hYXdN+zfvx86nQ6LFy8e8z111+Lt7Y377rsP7e3t2LFjh9mOS0RERNZ18OBBs17VMycWdl+j1Wpx7NgxzJ071yIzXCIiIrBo0SKcOHECFy5cMPvxiYiIyLKGhoZw6NAhnD9/XnSUq+Lkia9Rq9V49NFHERERYbFzTJkyBUFBQfDz87PYOYiIiMgyqqurodfrkZaWJjrKVXHE7pILFy5AkiTExMTAycly9a6TkxPi4uIAAHq93mLnISIiIvM7c+YMgoODERQUJDrKVbGwAzAwMIA///nPOHjwoNXOuXXrVnz00UdWOx8RERFNzNDQECoqKpCeni46yohY2AHYu3cvDAYDpkyZYrVzxsXFoaKiAs3NzVY7JxEREY2fQqHA7bffjszMTNFRRuTwhV1zczOOHz+Om266Cd7e3lY7b0ZGBgICArB//36rnZOIiIjGz8nJCenp6TZ9n7xDF3aSJGH79u0ICQnBtGnTrHpupVKJefPmoaqqCo2NjVY9NxEREY3N0NAQPv74Y5w7d050lGty6MLOZDIhIyMDS5cuhUqlsvr509PTERUVhe7ubqufm4iIiEavpqYGpaWlZu1xawkO3e5EpVJh5syZws6vVCrx3e9+1+Z/SIiIiBzd6dOnERQUZLOzYS+z6IjdwYMHceuttyI8PBwKhQJbtmy55vb79++HQqH41qOtrc3s2dra2vDZZ59hcHDQ7MceC4VCgf7+fhQWFgrNQURERFdnD7NhL7NoYdfX14esrCy8+uqrY9qvoqICra2tw4/g4GCzZzt8+DAqKyvh7Oxs9mOPVWNjIz777DPU1taKjkJERETfUFNTA71ebxeFnUUvxS5ZsgRLliwZ837BwcEWWdLrMq1Wi7KyMixatEjIvXXflJycjJCQEBQWFiI+Pl50HCIiIvqayMhILF++3OYvw8JWJ09kZ2cjLCwMCxcuxFdffXXNbXU6HXp6eq54XM/Ro0fh4uKCnJwcM6YeP4VCgZycHFRUVKCvr090HCIiIvoaLy8vZGdni44xKjZV2IWFheGNN97ARx99hI8++ghRUVGYN28eTpw4MeI+69atg1qtHn5ERUVd8xxDQ0MoKirC1KlT4erqaoF/xfhkZGQAAMrKykRHISIioktqa2uxY8cOGAwG0VFGRSFJkmSVEykU2Lx5M5YvXz6m/ebOnYvo6Gj87W9/u+r3dToddDrd8Nc9PT2IioqCVquFj4/PVfc5d+4cPDw84OXlNcZ/hWUdOXIEkZGRiIyMFB2FiIiIAGzZsgVNTU148sknrXbOnp4eqNXqa9YyI7H5difTp0/HoUOHRvy+q6vrqEfeTCYTcOkePlsksvUKERERXclkMqGqqgpZWVmio4yaTV2KvZqSkhKEhYWZ5VhlZWV45ZVXrhjhszVnzpxh6xMiIiIb0Nrair6+PiQnJ4uOMmoWHbHr7e1FdXX18Nd1dXUoKSmBv78/oqOjsXbtWjQ3N+O9994DALz00kuIi4tDeno6BgcH8ec//xlffPEFPv/88wlnkSQJhw8fhp+fn03dW/dNjY2NOHnyJHJycuDkZPMDqkRERLJVVVUFV1fX696/b0ssWjkcP34c8+fPH/56zZo1AIBHH30U77zzDlpbW6HRaIa/r9fr8fTTT6O5uRkeHh7IzMzEnj17rjjGeNXV1aGtrQ0PP/zwhI9lSdnZ2SgoKEBVVRUmTZokOg4REZHDSktLQ1BQkE20Rhstq02esJaRbjjcuHEjtFotfvCDH9j8El7r16+Hl5cXHnjgAdFRiIiIyMomMnnC5u+xMweDwYDz588jNzfX5os6XBq1q6qqQm9vr+goREREDqmqqgoHDx6EvY1/OcRNXE5OTnjyySeHZ8XausmTJ8PFxQUuLi6ioxARETmk4uJiaLVazJkzR3SUMZH9iJ0kSeju7oZSqbSbyQgeHh7Izs5mYUdERCSA0WhETU0NkpKSREcZM9kXdq2trXjppZeumKRhD/r7+/Hxxx+jpaVFdBQiIiKHotFooNPp7LKws48hrAkoLi6Gl5cXIiIiREcZEzc3N9TV1cHV1RXh4eGi4xARETmMqqoqeHp6mq2PrjXJesTOYDDg1KlTyMrKsqupygCgVCqRmZmJU6dO2c36dERERHKQkpKCRYsWQam0vzLJ/hKPQUVFBQYHB5GdnS06yrhkZWVhcHAQtbW1oqMQERE5jJiYGLtaRuzrZF3Y9fb2Ij4+HkFBQaKjjEtQUBD8/f1RXl4uOgoREZFDqKqqwokTJ0THGDdZ32M3Y8YMTJ8+XXSMcVMoFLjtttugVqtFRyEiInIIx44dw9DQEKZMmSI6yrjIdsTu3LlzGBwctIuGxNcSGxsLPz8/0TGIiIhkT6/Xo66uDsnJyaKjjJtsC7stW7bgs88+Ex3DLA4cOICjR4+KjkFERCRr9fX1MBgMdtnm5DLZFnadnZ12e+PjN3V2dqKoqEh0DCIiIlmrqqqCr68vAgMDRUcZN9kWdl5eXoiPjxcdwyxSU1Nx7tw5XLhwQXQUIiIi2YqPj8fcuXPt+jYu2RZ2kydPtsv+M1eTkJAAlUqFiooK0VGIiIhka9KkScjJyREdY0LkUflcRWZmpugIZuPq6oq4uDgWdkRERBZSW1sri7+zsm13EhAQIDqCWc2bN090BCIiItkqKCiAwWBASkqK6CgTItsRO7mJjIxEZGSk6BhERESyYzAYUF9fL4t781nY2ZHS0lLs27dPdAwiIiJZaWpqwtDQEBISEkRHmTAWdnakq6treKiYiIiIzKO2thbu7u4IDQ0VHWXCWNjZkZSUFOj1etTX14uOQkREJBuBgYHIy8uTRTcN2U6ekKOQkBD4+vqioqICiYmJouMQERHJgpw6adh/aepAFAoFUlJSUFFRAUmSRMchIiKye+fOnUNDQ4Ns/q6ysLMzubm5WLp0qWx+AImIiEQ6duwYtm7daterTXwdL8XameDgYAQHB4uOQUREJAs1NTWyur2JI3Z2qL6+Hrt27RIdg4iIyK51dXWhq6tLFv3rLmNhZ4e0Wi0KCgrQ19cnOgoREZHdqqmpgUKhQFxcnOgoZsPCzg5d/gGsq6sTHYWIiMhuOTs7IzMzE25ubqKjmA0LOzvk4+ODwMBA1NbWio5CRERkt7KysnDHHXeIjmFWLOzsVHx8PAs7IiKicbp48SLOnz8vuy4TLOzsVFZWFubMmQOTySQ6ChERkd0pLi7G+vXrZfd3lO1O7FRERAQiIiJExyAiIrJLtbW1iI2NhUqlEh3FrDhiZ8fq6+tx4sQJ0TGIiIjsil6vR2NjIxISEkRHMTsWdnastrYWu3fvlt0wMhERkSU1NDTAaDTKqn/dZSzs7Fh8fDwGBgbQ3t4uOgoREZHdGBgYQHh4OAIDA0VHMTveY2fHIiMj4eTkhNraWoSFhYmOQ0REZBcyMzORmZkpOoZFcMTOjjk5OSEmJoZtT4iIiEZJr9fLeuUmFnZ2bsqUKbJavJiIiMiSKisr8dvf/la2xR0vxdq59PR00RGIiIjsRm1tLQIDA+Hp6Sk6ikVYdMTu4MGDuPXWWxEeHg6FQoEtW7Zcd5/9+/djypQpcHV1RWJiIt555x1LRpSF5uZmrhtLREQ0CnV1dcNrrsuRRQu7vr4+ZGVl4dVXXx3V9nV1dVi6dCnmz5+PkpISrF69Gt/73vewa9cuS8a0e4cPH8bevXtFxyAiIrJp3d3d6OrqknVhZ9FLsUuWLMGSJUtGvf0bb7yBuLg4vPjiiwCASZMm4dChQ/jDH/6A/Px8Cya1b/Hx8di2bRsGBwfh5uYmOg4REZFN6ujogIuLC2JjY0VHsRibmjxRUFCABQsWXPFcfn4+CgoKhGWyB/Hx8ZAkCfX19aKjEBER2aykpCT87Gc/g4eHh+goFmNThV1bWxtCQkKueC4kJAQ9PT0YGBi46j46nQ49PT1XPByNn58f/Pz82PaEiIhoBJIkwWAwyG5t2G+yqcJuPNatWwe1Wj38iIqKEh1JiJycHKjVatExiIiIbFJnZydeeOEFNDU1iY5iUTZV2IWGhn5reaz29nb4+PjA3d39qvusXbsWWq12+NHY2GiltLZlzpw5uOGGG0THICIiskl1dXUwGo0ICgoSHcWibKqPXV5eHrZv337Fc7t370ZeXt6I+7i6usLV1dUK6WxfZ2cnJEmS5dp3REREE1FbW4uIiAjZ1wwWHbHr7e1FSUkJSkpKgEvVcklJCTQaDXBptO2RRx4Z3v4HP/gBamtr8cwzz6C8vByvvfYaPvjgA/zkJz+xZEzZ+OCDD3Do0CHRMYiIiGyKyWRCfX094uPjRUexOIsWdsePH0dOTg5ycnIAAGvWrEFOTg6ee+45AEBra+twkQcAcXFx+Oyzz7B7925kZWXhxRdfxJ///Ge2OhmlmJgYNDQ0iI5BRERkUzo7OzEwMCDr/nWXKSRJkkSHMKeenh6o1WpotVr4+PiIjmNVp0+fxocffog1a9Y43L+diIjoWvr6+uDm5mYXs2InUsvY1OQJmpjo6GgAuGIUlIiIiABPT0+7KOomioWdjHh7eyMmJgZ6vV50FCIiIptgNBrx8ssvo7y8XHQUq7CpWbE0cY8//rjoCERERDajpaUFnZ2d8PLyEh3FKjhiJ0MDAwMYGhoSHYOIiEi42tpauLq6IiwsTHQUq2BhJzNarRYvvPAClxcjIroKSZIwODiI7u5utLW1oaGhARUVFejr6xMdjSykrq4OMTExDnF/HXgpVn58fHzg7e2NhoYGpKSkiI5DRGRTent78eKLL17xnJubG370ox8Jy0SWMzQ0hMbGRixYsEB0FKthYSczCoUCMTExnBlLRHTJuXPnsGfPHnznO9+Bh4cH7rrrLri5ucHNzQ2urq5wd3eHp6cn+vr6sGnTJsybNw8JCQmiY5MZODk54Qc/+MGIy5LKEQs7GYqOjsaZM2eg1+vh4uIiOg4RkTAlJSX47LPP4Ovri4GBAbi5uWHy5MlX3Van00GhUOBvf/sb0tLSkJ+fD7VabfXMZD4KhUL2a8N+E++xk6GYmBgolUqcP39edBQiIiH0ej22bt2KLVu2ID09HStXroSfn9819/H398fjjz+OO+64AxqNBq+88grq6uqslpnMb8uWLTh58qToGFbFETsZCgoKwrPPPgsnJ/7vJSLH1NLSgrKyMtx+++3Dy1qOhkKhQFZWFlJSUrBt2zY4OztbNCdZzuDgIE6ePInIyEjRUayKf/llSKlUQqlUwmQyQankoCwROZ7Y2FisXr0anp6e49rfzc0Nd911F3Cpwe3Q0BDc3NzMnJIsSaPRQJIkh1gf9uv4V1+mysrK8Lvf/Q4Gg0F0FCIiqyktLcW2bdtgNBrHXdR900cffYQPPvgARqPRLMcj66irq4OPjw/8/f1FR7EqFnYy5evri/7+frS2toqOQkRkFVqtFp999hl0Op1Ze5ZNnToV9fX12Llzp9mOSZZXV1eHuLg4KBQK0VGsioWdTIWFhcHZ2ZltT4jIIUiShK1bt8LFxQW33HKLWY8dHx+PW265BYWFhTh27JhZj02Ws2TJEsycOVN0DKtjYSdTKpUKkZGRaGhoEB2FiMjiCgsLUVtbi9tvv90iPcumTp2KmTNnYseOHTh37pzZj0/mFxMT4zDLiH0dJ0/IWExMDI4ePcpJFEQke11dXZg6dSoSExMtdo5FixYhOjra4fqi2aNjx47B2dl5TDOi5UIhSZIkOoQ59fT0QK1WQ6vVwsfHR3QcoS6vfWiuG4iJiGyZNT/EdnR0sMCzYS+//DLi4uKwbNky0VHGZSK1DIdxZMzT05NFHRHJ2pEjR1BUVARcavVkDRUVFXj11Vc5Oc1GabVadHZ2Olybk8tY2MncgQMHOJOLiGSpr68Pe/futfoqO4mJiQgKCsL27dshs4tesnB5tZDY2FjRUYRgYSdzer0ep0+f5psPEcnOsWPHIEkSZs+ebdXzqlQq3HLLLWhsbERpaalVz03XV1dXh5CQEIe9YsXCTuaio6Nx8eJFdHV1iY5CRGQ2er0ex44dQ25urpA/4HFxcUhLS8Pu3buh0+msfn4a2eTJkzF37lzRMYThrFiZi4qKAgA0NjY6XPdtIpKv06dPQ6fTIS8vT1iGRYsW4cSJEw7XANfWJSUliY4gFAs7mfPw8EBgYCAaGxuRlZUlOg4RkVlkZWUhNDQUvr6+wjL4+vripptuAi41SGaBJ15dXR16enoc+u8dL8U6gGXLljlk920ikiedTgelUmkzzWcLCwvxwQcf8F5mG3D8+HEUFhaKjiEUCzsHEBsbi8DAQNExiIgmzGQy4c9//jP27dsnOsowLy8vnD17FpWVlaKjODSTyTS8PqwjY2HnAPR6PXbt2oWmpibRUYiIJqSyshIdHR2Ij48XHWVYamoq4uLi8MUXX3DUTqCOjg709/ezsBMdgCzPyckJxcXFqK6uFh2FiGjcJEnCoUOHEBUVhZiYGNFxhikUCsydOxft7e2oqqoSHcdh1dbWQqVSDU8adFQs7ByAUqlEVFQUR+yIyK5pNBo0NTVZvW/daMTExCAqKmq4OS5ZX0BAAGbPng1nZ2fRUYTirFgHERkZicOHD1t1LUUiInO6cOECIiIibLKdhUKhwMMPPwwXFxfRURxWcnIykpOTRccQjn/hHURUVBR0Op3Vl94hIjKXnJwcfO9737PZD6cuLi6QJAmNjY2iozicrq4uVFZWwmg0io4inG3+dpDZRUREYN68eXB1dRUdhYhozOrq6tDf32/zveKqqqrwl7/8Bc3NzaKjOJRTp07hn//8p+gYNoGFnYNwdXXFvHnzoFarRUchIhqToaEhbNq0CQUFBaKjXFdiYiL8/f3x5Zdfio7iUGpqahAXFweVSiU6inAs7BxIZ2cnjh8/LjoGEdGYVFVVQafTITMzU3SU61IqlZg9ezbKy8tx7tw50XEcgk6nQ2Njo021wBGJhZ0DaW5uxrZt29DX1yc6ChHRqJWWliI8PBxBQUGio4xKZmYmfHx8cOjQIdFRHIJGo4HJZGJhdwkLOwdyubcP254Qkb3o7+9HZWWlXYzWXebk5ISbbrrJZpY8kzuFQoHU1FSusHQJ2504EF9fX3h5eaGxsREpKSmi4xARXdfAwACSkpIwefJk0VHGJDs7W3QEh5GYmIjExETRMWwGR+wciEKhQFRUFKfiE5HdCAgIwP333w8vLy/RUcasv78fO3fuxMWLF0VHka2BgQE0NzfDZDKJjmIzWNg5mNTUVISHh4uOQUR0XVqtFuXl5Xbbm0yhUODEiROctGZBlZWVeOutt9Df3y86is1gYedgsrKykJ+fLzoGEdF1lZSU4OOPP7bbws7d3R1ZWVkoKiqCwWAQHUeWamtrERISYpcjupZilcLu1VdfRWxsLNzc3DBjxgwcO3ZsxG3feecdKBSKKx5ubm7WiOkwLly4wBUoiMimSZKE0tJSTJo0ya6X6Zo2bRp6e3tx9uxZ0VFkR5Ik1NTUICEhQXQUm2Lxwu7999/HmjVr8Pzzz+PEiRPDI0bX6u/j4+OD1tbW4UdDQ4OlYzqUjz/+GPv37xcdg4hoRC0tLejs7LSr2bBXExwcjNjY2GsOaND4dHR0oLe3l21OvsHihd3vf/97rFy5Eo8//jjS0tLwxhtvwMPDA3/9619H3EehUCA0NHT4ERISYumYDoUTKIjI1pWWlsLLywtxcXGio0zYwoULsXTpUtExZKevrw/BwcGIjo4WHcWmWLSw0+v1KCoqwoIFC/7vhEolFixYcM2lYXp7exETE4OoqCjcfvvtOH36tCVjOpyoqChotVr09PSIjkJEdFUhISG48cYboVTa/63gERERCA0NFR1DduLi4vDDH/7Qri/VW4JFf2POnz8Po9H4rRG3kJAQtLW1XXWflJQU/PWvf8XWrVuxYcMGmEwmzJo1a8SmujqdDj09PVc86NouNyrmqB0R2aopU6ZgxowZomOYTUtLC9avX8/Zm2ZiNBrR3d0tOoZNsrmPQnl5eXjkkUeQnZ2NuXPn4uOPP0ZQUBDefPPNq26/bt06qNXq4cflooVG5u3tjYiICOh0OtFRiIi+5eTJk2hvbxcdw6x8fHzQ3t6O4uJi0VFkoampCS+99NKIg0SOzKKFXWBgIFQq1bd+Qdvb20c9LO3s7IycnBxUV1df9ftr166FVqsdfnAUanRWrlyJKVOmiI5BRHQFnU6HTz/9FJWVlaKjmJWXlxfS09NRWFjIZrpmUFNTA3d3dwQHB4uOYnMsWti5uLggNzcXe/fuHX7OZDJh7969yMvLG9UxjEYjTp06NeKae66urvDx8bniQaOj0+nstj8UEclTVVUVDAYDMjIyREcxu+nTp6O7uxtVVVWio9i92tpaxMXFyeIeTHOz+CuyZs0avPXWW3j33Xdx9uxZPPHEE+jr68Pjjz8OAHjkkUewdu3a4e3/67/+C59//jlqa2tx4sQJPPTQQ2hoaMD3vvc9S0d1KO3t7fj1r3+NlpYW0VGIiIZVVlYiJCQEvr6+oqOYXUREBMLDw1FWViY6il27vIwY+9ddnZOlT3Dvvfeio6MDzz33HNra2pCdnY2dO3cOT6jQaDRXVNxdXV1YuXIl2tra4Ofnh9zcXBw+fBhpaWmWjupQAgICoFKp0NTUxPsSicgmGI1GVFVVYdq0aaKjWIRCocA999wDb29v0VHsWmdnJ9zc3Ni/bgQKSZIk0SHMqaenB2q1Glqtlpdlr+Ovf/0rvL29cffdd4uOQkQEnU6HgwcPIiMjQ/btQXQ6HVxdXUXHsFsmk0nWl2EnUsvI91Wh64qMjByxjQwRkbW5urpi4cKFsi/qSkpK8NJLL0Gv14uOYpcGBwdlXdRNFF8ZBxYZGYmLFy+ir69PdBQiIhQVFUGr1YqOYXExMTEYGBhg8/1x6OzsxAsvvID6+nrRUWwWCzsHlpycjLVr18LT01N0FCJycJ2dnfj0008dYkKXn58fEhISUFRUJDqK3amqqoJSqRyxUwaxsHNoTk5OcHZ2Fh2DiAiVlZVQqVQOc0N8bm4umpqaZNeI2dKqqqoQExPD+xOvgYWdgzt48CA2btwoOgYRObiKigrExcU5zB/slJQUqNVqtLa2io5iN/R6Perr65GUlCQ6ik2zeLsTsm3Ozs6ora2F0WiESqUSHYeIHNDAwAA0Gg0WL14sOorVqFQq/PjHP+b77hhcXj6Mhd21ccTOwUVGRsJgMHC9PSISRq/XIzMzE8nJyaKjWJVKpcLQ0BAuXLggOopdiI6OxjPPPIOAgADRUWwaCzsHFxoaCqVSybYnRCSMWq3G8uXLZbnaxPX885//xObNm0XHsHmSJMFoNMLV1RUKhUJ0HJvGws7BOTs7IywsjIUdEQlhNBpRWlqKwcFB0VGEyMzMRGNjI86dOyc6ik3r6OjAb37zG96TOAos7Ai33norFi1aJDoGETmgxsZGfPzxxzh//rzoKEKkpKTAw8MDJ06cEB3FplVWVsJoNCIwMFB0FJvHwo4QGhrKtQuJSIjKykp4enoiPDxcdBQhnJyckJOTg5KSEgwNDYmOY7OqqqoQHx/PFl2jwMKOMDQ0hM2bN6Ourk50FCJyMBUVFUhOTnboJaKmTJmCoKAg9Pb2io5ikwYHB6HRaDgbdpQc9zeJhjk5OaGmpga1tbWioxCRA+ns7ERnZ6fDzYb9poCAAKxYsQJ+fn6io9ikxsZGSJLEwm6UWNgRFAoFIiMj0djYKDoKETmQoaEhJCcnO8xqE9ciSRIaGhrQ3d0tOorNSUpKwtNPP+2Qs6bHg4UdAZf62TU3N8NkMomOQkQOIjQ0FA888IDDrDZxLUajEZs2bcKRI0dER7EpkiRBkiTeBz4GLOwIuFTYDQ0Ncco9EVmFXq9HdXU1Jwxc4uTkhOzsbJw8eZKvyde0trbij3/8Izo7O0VHsRss7AgAEB4ejltuuQVeXl6ioxCRA2hoaMCGDRt46fFrcnNzMTAwgPLyctFRbEZVVRUGBgZ4GXYMWNgRAMDFxQXTp09nYUdEVlFbWwtvb2/2JfuawMBAxMTEoKioSHQUm1FZWYmEhASuqTsGLOxoWFtbG7766ivRMYjIAdTV1SE+Pp7LQ33DrFmzEBsby/udAfT19aG5uZmzYceIhR0Na29vx+7du9Hf3y86ChHJWF9fH9ra2jgb9ipSUlIwb948h+7rd9nlFlyJiYmio9gV/uTQsMjISABAc3Oz6ChEJGO9vb2IiIhAXFyc6Cg26eLFi9i/fz8MBoPoKEJNnjwZq1at4ozYMWJhR8P8/f3h4eGBpqYm0VGISMZCQkKwcuVK+Pj4iI5ikwYGBrB//36Hn0ShUCgQFBQkOobdYWFHwxQKBSIiIljYEZFFtbe38x6yawgODkZ0dLRDT6I4e/Ys1q9fD51OJzqK3WFhR1fIzMzk5REispgLFy7g9ddfR2VlpegoNi03Nxd1dXUO27/tzJkzMBgMbF49Dizs6AoZGRmYPXu26BhEJFN1dXVQKBSIiYkRHcWmpaWlwc3NDSdOnBAdxeoMBgMqKiqQlpYmOopdchIdgGxPc3MznJ2dERwcLDoKEclMbW0twsPD4e7uLjqKTXN2dsYtt9yCgIAA0VGsrqamBnq9noXdOHHEjr7lk08+QUFBgegYRCQzJpNpuH8dXV9mZiYiIiJEx7C6iooKBAYGcnBhnDhiR98SGRkJjUYjOgYRyUxvby9cXFx4H+8YVFZWora2FosXLxYdxWpuueUWaLVa0THsFkfs6FsiIyPR0dGBwcFB0VGISEZ8fHywevVqFnZj0N/fjyNHjuDChQuio1iFJElwcnJyyEvQ5sLCjr4lKioKANj2hIjMamBgALjUWolG5/IkiuPHj4uOYhXbt2/HZ599JjqGXWNhR98SEBCAyMhIh+96TkTmYzAY8Pvf/x6FhYWio9gVFxcX5OTkoLi4GENDQ6LjWJTRaERZWRlbnEwQ77Gjb1EoFPje974nOgZZmMlkwtmzZ3H06FEAQFBQEBYvXgxnZ2fodDq4uLhwZIXMprm5GUNDQw45GWCipk6dioKCApSVlSEnJ0d0HIupr6/HwMAAZ8NOEAs7uipJktDT0wNvb28uRi1DBoMBb775Jjo6OhAXFwdPT0+cO3cOTk7/ekv4y1/+goGBAdx2221ISkoSHZdkoLa2Fm5ubggNDRUdxe4EBATg4YcfRnR0tOgoFnXmzBn4+voiLCxMdBS7xsKOrqq+vh7vvvsuVq1axbX6ZGJoaAilpaXIzs6Gk5MTcnNzERkZicjIyG9te9NNN+H48ePYuHEjFi1ahJkzZ3L0jiaktrYWcXFx/KA4TgkJCcClD91y/F2UJAmVlZXIyMiQ5b/PmljY0VVd/sTU1NTEwk4G9Ho9/va3v6GpqQkBAQGIjY3FzJkzR9w+NTUVycnJ2Lt3L3bt2oWLFy9i0aJFVs1M8mEwGHD+/HlkZmaKjmLXdu/ejb6+Pixfvlx0FLNTKBR44oknuIawGbCwo6tyc3NDcHAwGhsbZX1PhyMwGAz44IMP0NbWhhUrVlx1hO5qlEolFi5ciODgYPj7+1s8J8mXk5MT/v3f/51/tCfIy8sLBQUFuPnmm+Ht7S06jllJkgQPDw/RMWSBY+I0osjISLY8sXMmkwlbtmxBXV0d7r///lEXdV+XlZWFqKgoGI1GbN68Ga2trRbJSvJlMpmgUqng7OwsOopdy87Ohkqlkt36sSaTCa+//jpOnTolOoossLCjEUVGRqK3t1f2U+zlTKFQwMfHB3feeeeEl3EaHBzEuXPn8N577+HixYtmy0jy9/bbb+PAgQOiY9g9d3d3ZGZm4vjx4zAajaLjmI1Go8G5c+fg4+MjOoossLCjEWVlZeGnP/0pP2XbqfPnz0OhUGDRokVmaR/g6emJhx56CEqlEtu2bYMkSWbJSfI2ODiIpqYm2V06FGXatGno6+tDS0uL6ChmU1xcDF9f3+Hm+DQxVinsXn31VcTGxsLNzQ0zZszAsWPHrrn9hx9+iNTUVLi5uSEjIwPbt2+3Rkz6BpVKBYVCwT/gdqigoACvvvoqzp07Z9bjenp64tZbb0VFRQVKSkrMemySp8bGRkiShJiYGNFRZCE0NBRPP/20bIqggYEBnD59GlOmTOGMaTOx+Kv4/vvvY82aNXj++edx4sQJZGVlIT8/f8Q/OIcPH8b999+PFStWoLi4GMuXL8fy5ctRVlZm6ah0Fdu3b8emTZtEx6AxqKqqwq5duzBr1iwEBweb/fipqamYMmUK+vv7zX5skp+GhgZ4enpyAo4ZeXp6wmAwyOJ3sLa2FkajEdnZ2aKjyIZCsvBwzIwZMzBt2jS88sorwKWbJKOiovCjH/0Izz777Le2v/fee9HX14dt27YNPzdz5kxkZ2fjjTfeuO75enp6oFarodVqeb3eDPbv34+jR4/imWeeYW8hO6DX6/Haa6/Bz88PjzzyiMX+n8m1lxaZ31//+ld4eXnhnnvuER1FVt58802Eh4fj1ltvFR1lwrRaLdRqtegYNmUitYxFR+z0ej2KioqwYMGC/zuhUokFCxagoKDgqvsUFBRcsT0A5Ofnj7g9WVZkZCQGBgbQ2dkpOgqNwuHDh3Hx4kUsXbrUooXX5Uv0+/fvv+6tFeTYHnjgAfZAtIDU1FSUlpba9aidXq+HJEks6szMooXd+fPnYTQaERIScsXzISEhaGtru+o+bW1tY9pep9Ohp6fnigeZz+X2GI2NjaKj0ChMnz4d99xzDwIDAy1+LoVCgb6+Pnz++ec4f/68xc9H9snNzQ2+vr6iY8jO1KlTAWB4rWd79Pnnn+O9994THUN27P5OxXXr1kGtVg8/5HJDqa1wc3NDUFAQ+9nZOEmS0NfXBw8PD6SkpFjtvAsXLoSPjw+2bNkiq/YLZB5HjhzB1q1bRceQJU9PT0yZMgVHjx6FTqcTHWfM9Ho9Tp06Na7emnRtFi3sAgMDoVKp0N7efsXz7e3tIy4EHRoaOqbt165dC61WO/zgyJL53XfffcjPzxcdg66hpKQEL7/8Mnp7e616XhcXF9xxxx1obm7mJVn6loqKCvT19YmOIVuzZs2Cv7+/XV6pOnPmDHQ6HaZMmSI6iuxYtLBzcXFBbm4u9u7dO/ycyWTC3r17kZeXd9V98vLyrtgel9bHG2l7V1dX+Pj4XPEg8woICICLi4voGDSCy5dDk5OT4eXlZfXzR0VFYcqUKWZvrUL2zWAwoLGxkW1OLEitVuP73/++Xa7nXVRUhPj4ePj5+YmOIjsWXyt2zZo1ePTRRzF16lRMnz4dL730Evr6+vD4448DAB555BFERERg3bp1AICnnnoKc+fOxYsvvoilS5di06ZNOH78ONavX2/pqDSCgYEBbN68GTfccAPfpG3Qnj17IEmS0BvUly5dyh5UdIXW1lYYDAa+Z1hBS0sL+vv7kZiYKDrKqAwMDECr1XJSjYVYvLC799570dHRgeeeew5tbW3Izs7Gzp07hydIaDSaK/4gzJo1Cxs3bsR//ud/4uc//zmSkpKwZcsWTJ482dJRaQSurq7QaDQIDw/nm7SNaWhoQHFxMZYtWyZktO4ypVIJk8mEyspKJCYmwsnJ4m8tZOMaGhrg7OyMsLAw0VFk76uvvkJzczN+9KMfQaVSiY5zXe7u7li9ejWb31uIxfvYWRv72FnG3//+d5hMJjz88MOio9DXtLe3o7CwELfccovwEbPOzk68/PLLWLZs2fCMPXJcWq0WHR0ddjOKZM/a2trwxhtv4I477kBWVpboONdkMBjQ29vLmdLXYbN97Eg+oqKi0NjYCJPJJDoKfU1ISAiWLVsmvKjDpXsx09PTcejQIc6QJajVahZ1VhIaGoqkpCQcOnTI5t+jKyoq8NJLL6G7u1t0FNkS/9eA7EJ0dDT0ej1vkLcRJpMJmzdvhkajER3lCnPmzEF3dzdKS0tFRyGBOjo68Nlnn3FGrBXdeOON6OjoQGVlpego11RUVISoqCiO2FkQCzsalYiICNx5553sEG4jKisrcfLkSZu7RyUkJASpqan48ssvbX7kgCynpqYGJ06c4Gx6K4qOjsaSJUsQEREhOsqIWltbUVtby1s1LIx3ONOoODs7IyMjQ3QMutSM+ODBg4iJibHJySxz586FRqOxuaKTrKehoQERERFwdnYWHcWhzJgxQ3SEa9q/fz/8/f05GdLCOGJHo9bU1ITPP/9cdAyHV1NTg5aWFsyZM0d0lKsKCwvDjBkz7GJ2HpmfJEloaGiwyQ8djuDkyZP4xz/+YXMfrIxGIzw9PTF//ny+N1gYCzsatZ6eHhw+fBharVZ0FIdWWFiIiIgIxMfHi44yIqPRiE8//RTl5eWio5CVdXZ2or+/n4WdID4+PqioqLC5+1xVKhVuu+02XvmxAhZ2NGqX1+Hlsm1i3XnnnfjOd74DhUIhOsqIVCoVOjs7ceDAAZsbOSDLcnV1xYIFC7hutyBxcXFIS0vD7t27bWYN2ebmZhQWFnK2vJWwsKNR8/b2hp+fHws7gfr7++Hi4oKAgADRUa5rzpw5aG1tRV1dnegoZEXe3t6YPXs2XF1dRUdxWIsWLcLg4CAOHjwoOgoAYO/evTh27JhNfxiVExZ2NCbR0dE212LDUTQ1NeH3v/89WltbRUcZlbi4OAQEBKC4uFh0FLKiw4cP4/z586JjODRfX1/Mnj0bzc3NwmenNzQ0oLa2FvPnz7eJfpuOgLNiaUwyMzP5pi3IwYMH4evrO7wcn61TKBTIycnB/v37odPpOILjALq7u/H555/D398fgYGBouM4tBtvvBFz584VPkq2b9++4TZIZB0s7GhMEhISkJCQIDqGw2ltbUVlZSXuuOMOu/rUO2XKFEyaNIlFnYNoaGgAvnY/LolzeeZpfX09ACA2NtbqGTQaDerr63HffffZ1fuWveMrTWNWV1fH+6as7KuvvoKvr6/d9X/y8PBAQECA8MtBZB2NjY0IDAyEp6en6Ch0yYEDB/DJJ5/AYDBY/dyRkZF44IEHkJKSYvVzOzIWdjRmhw8fxqFDh0THcBiSJEGSJOTl5dll/6cLFy7gT3/6E1paWkRHIQvTaDQcrbMxixcvRldXF44ePWrV8w4NDUGpVCI5OVn45WBHw8KOxiwqKgqNjY0chbEShUKBu+++2+a7yo9ErVbDYDBwEoXMSZKEhIQETJo0SXQU+pqQkBBMmzYNBw4cQE9Pj1XOqdPp8Oabb2Lfvn1WOR9diYUdjVl0dDT0ej3OnTsnOorsGY1GnD171q77P6lUKmRnZ6O0tBRDQ0Oi45CFKBQK5OfnIzk5WXQU+ob58+fDxcUFe/futfi5JEnCtm3b0NPTw2bEgrCwozELDw+HUqlk2xMrqKiowPvvv2/3RXROTg50Oh3OnDkjOgpZSHNzM2fM2yh3d3c89NBDWLx4scXPdeLECZw6dQq33norZ0YLwsKOxszFxQU5OTlwd3cXHUX2CgsLERUVhbCwMNFRJiQgIACxsbGorq4WHYUsZPfu3di9e7foGDSC0NBQuLu7o6urCydPnrTIOc6dO4ft27cjNzeXo3UCsd0Jjcutt94qOoLsdXR0oK6uDt/5zndERzGLu+++mx8GZMpoNKK5uRnz5s0THYWuo6SkBAcPHoSnpycSExPNemx/f3/MmzcPM2fONOtxaWw4YkfjYjKZ0NraisHBQdFRZOv48ePw8PBAWlqa6Chm4enpCaVSyZ8ZGWpra8PQ0BBnxNqBuXPnIjExER9++KHZLp1LkoSuri44OTnhxhtvhLOzs1mOS+PDwo7Gpa+vD2+++SZqampER5GtsLAwzJ8/H05O8hlYLygowKuvvmrXk0Ho2xobG6FSqRAeHi46Cl2HUqnEnXfeCR8fH2zcuBEDAwMTPmZRURFeeeUVdHV1mSUjTQwLOxoXb29v+Pn5cQKFBWVnZ2PatGmiY5hVTEwMLl68yA8EMpSSkiKrDyFy5ubmhvvvvx8GgwFtbW0TOlZ5eTl27NiBnJwc+Pn5mS0jjR8LOxq3qKgoFnYWIEkS9u3bJ8sZhuHh4QgNDcWJEydERyEzmjlzJu655x7RMWgM/P398eMf/xhxcXEYGhrC2bNnIUnSqPcfGBjARx99hE2bNiEhIQH5+fkWzUujx8KOxi0mJgZtbW28Z8rMNBoNDhw4gO7ubtFRLCI7OxuVlZVmuQRE4ul0OvT19YmOQeNweYS1vLwc77//PjZu3Djq9x2FQoFz587hjjvuwP3338/76mwICzsat5iYGPj5+UGr1YqOIiuFhYXw9/dHfHy86CgWkZaWBmdnZ7vvzUf/UlFRgd/+9rfo7+8XHYXGKSMjA/fddx/a2trw6quvoqCg4KorC/X19WHr1q3o7u6Gm5sb/u3f/g1ZWVlcMszG8IYIGrfAwED8+Mc/Fh1DVi5evIgzZ85g4cKFUCrl+bnLx8cHzzzzjF2ue0vfptFoEBAQAA8PD9FRaAJSU1MRGxuLL774Art27UJiYiKCgoKwZcsWlJaWApduE3Fzc0NGRgZ8fX1l+x5l71jY0YT19fXB09NTdAxZOHnyJJRKJbKzs0VHsSiVSoXBwUGoVCpewrFzjY2NiI6OFh2DzMDNzQ233HILsrOz4eXlBVwazbs821mpVCIlJQXe3t7/t5OuFzjyGlD0NnCxDfAOBXIfB2b+EHD1EvVPcWgs7GhCTp48ia1bt+JnP/sZXF1dRcexe5MmTYJarZZ9I9+BgQG8+OKLWLZsmeyLWDkbHBxEe3s7ZsyYIToKmdHX29YkJCQgISHh6hvqeoF3bgHaTgHSpUu3PS3A/nVA+Tbgse0s7gTgOCpNSHh4OEwmExobG0VHkYWAgACHWIrH3d0dYWFhXDvWznV2dsLZ2Zkjdo7qyGtXFnWXSaZ/PX/kNVHJHBoLO5qQwMBAeHp6or6+XnQUu7dv3z4UFRWJjmE1aWlpqKmp4axqOxYREYFnn30WAQEBoqOQCEVvf7uou0wy/ev7ZHUs7GhCFAoFYmNjWdhNkE6nw+HDh9Hb2ys6itWkpaXBaDSioqJCdBQaJ5PJBJVKxVmRjuridZobX+/7ZBEs7GjCYmNjceHCBRgMBtFR7NaZM2cwNDSErKws0VGsRq1WIzo6Gp2dnaKj0DgYjUb87ne/G54xSQ7IO3Ri3yeL4OQJmrDs7Gzk5uZy6vsEFBcXIyEhAb6+vqKjWNWjjz7Ktid2qr29Hf39/VCr1aKjkCi5j/9rosTVLscqlP/6Plkd/xLThDk7O0OpVF61oSVdX2dnJzQajUPODlWpVDAajQ51CVouNBoNVCrVFTMoycHM/CEQmvGvIu7rFMp/PT/zh6KSOTQWdmQWX3zxBd577z3RMeySn58fHn74YaSmpoqOIsSmTZvw6aefio5BY9TY2IiwsDD2IXRkrl7/amkyby3gE/6vgs4n/F9fs9WJMLwUS2bh5eUFjUYDvV4PFxcX0XHsilKpHLlPlAOIj4/Hnj17MDg4CDc3N9FxaJQaGxsxefJk0TFINFcvYO4z/3qQTeCIHZlFbGws+9mNQ2VlJd59913odDrRUYSZNGkSjEYjKisrRUehMfjBD36AWbNmiY5BRN/Awo7MIigoCB4eHmx7MkYnTpzAwMCAQ6/a4evri4iICJw+fVp0FBoDDw+P4WWniMh2sLAjs7jcz66hoUF0FLvR29uLyspK5OTkiI4iXHp6Oi5evMgJOHbiwIED2LVrl+gYRHQVvMeOzCY/P5/3SI1BaWkpFAqFQywhdj0zZ87kZT07Ul5ejuDgYNExiOgqLDpid+HCBTz44IPw8fGBr68vVqxYcd22BvPmzYNCobji8YMf/MCSMclM1Gq1Q19SHKvTp08jNTUVHh4eoqMIp1QqIUkSLl68KDoKXYder0dbWxuioqJERyGiq7BoYffggw/i9OnT2L17N7Zt24aDBw/i+9///nX3W7lyJVpbW4cfv/nNbywZk8zok08+wVdffSU6hl145JFHkJ+fLzqGzTh69ChefvllrmBi45qbmyFJEgs7IhtlscLu7Nmz2LlzJ/785z9jxowZmD17Nl5++WVs2rQJLS0t19zXw8MDoaGhww8fHx9LxSQzGxgY4Nqfo2AymeDq6sqf7a+JjY2FXq/nfZo2rrGxEa6urggKChIdhYiuwmKFXUFBAXx9fTF16tTh5xYsWAClUomjR49ec9+///3vCAwMxOTJk7F27Vr09/ePuK1Op0NPT88VDxInNjYWzc3N0Ov1oqPYLIPBgJdeegllZWWio9iUkJAQ+Pj48IOBjcvIyMBdd93FJQSJbJTFfjPb2tq+dXOtk5MT/P390dbWNuJ+DzzwADZs2IB9+/Zh7dq1+Nvf/oaHHnpoxO3XrVsHtVo9/ODlAbFiY2NhNBrR1NQkOorNqqysRE9PD28+/waFQoGUlBRUVlZCkiTRcWgEfn5+SEpKEh2DiEYw5sLu2Wef/dbkhm8+ysvLxx3o+9//PvLz85GRkYEHH3wQ7733HjZv3oyampqrbr927VpotdrhBxvkihUUFAR3d3f2s7uGkpIShIeHs7C7ipSUFAwNDXHtWBt14cIF7Nixg/9/iGzYmNudPP3003jssceuuU18fDxCQ0Nx7ty5K543GAy4cOECQkNDR32+GTNmAACqq6uvuuySq6srZ2LaEKVSibvvvhuBgYGio9ik3t5eVFVVYcmSJaKj2KT4+Hg8/fTTvMxno+rr63Hs2DHMnz9fdBQiGsGYC7ugoKBR3TSbl5eH7u5uFBUVITc3F7i0ULzJZBou1kajpKQEABAWFjbWqCRIfHy86Ag2q76+HiqVimtsjuByQTcwMAB3d3fRcegbGhsbERwczH6VRDbMYh+LJ02ahMWLF2PlypU4duwYvvrqKzz55JO47777EB4eDlyaNp+amopjx44BAGpqavDf//3fKCoqQn19PT755BM88sgjmDNnDjIzMy0VlczMaDRi27ZtqKqqEh3F5kyePBlr1qxh77prqKiowG9/+1te7rNBjY2NvI+ZyMZZ9HrH3//+d6SmpuLmm2/GLbfcgtmzZ2P9+vXD3x8aGkJFRcXwrFcXFxfs2bMHixYtQmpqKp5++mnceeed+PTTTy0Zk8xMpVKhoaEBZ86cER3Fpuh0OphMJhZ11xEREQGTycQPBjamv78f58+fZ2FHZOMsuqSYv78/Nm7cOOL3Y2Njr5j9FhUVhQMHDlgyEllJYmIiysrKIEkSFAqF6Dg2Yd++fdBoNFi5ciVfk2vw8vJCZGQk19G1QTfddBNiY2NFxyCia+AdymQRCQkJuHjx4rcm0Dgqo9GI0tJSREdHs6gbhZSUFNTU1HAVChvi4eGBOXPmQK1Wi45CRNfAwo4sIiYmBk5OTqiurhYdxSZUV1ejv78f2dnZoqPYheTkZJhMJn4wsCGlpaVob28XHYOIroOFHVmEs7Mzbr/9dqSkpIiOYhNKSkqGl8ij6wsODsYzzzwzPNGKxDIajfj0009H7CdKRLbDovfYkWPLyMgQHcEmGI1GdHZ2YsqUKaKj2A2FQgEXFxcMDQ3BycmJl68Fa29vx9DQECdOENkBjtiRxRgMhuEJA45MpVLhiSeewLRp00RHsSttbW34zW9+w8t/NkCj0UClUrGfKJEdYGFHFqNSqVBSUoLTp0+LjiLUhQsXoFAooFKpREexK4GBgVAoFKioqBAdxeE1NjYiPDwcTk68yENk61jYkcUoFAokJiY69ASKtrY2/OlPf0JdXZ3oKHbHyckJiYmJqKysFB3F4QUFBXG1FCI7wcKOLCoxMRGdnZ3o6uoSHUWIkpISeHp6Ijo6WnQUu5ScnIzm5mZcvHhRdBSHNm/evDEtBUlE4rCwI4uKi4uDQqFwyFE7g8GAkydPIisri5dhxykpKQkKhQJNTU2iozisrq4unD9/XnQMIholFnZkUW5ubsjPz0dERIToKFZXWVmJgYEB9q6bAE9PTzzzzDOYNGmS6CgO68iRI/j73/8uOgYRjRLvhCWLmzlzpugIQvT19SExMRHBwcGio9g1d3f34aUH2fbE+jQaDducENkRjtiRxRkMBhw7dgxtbW2io1jVtGnT8NBDD4mOYfe6urrw4osvorGxUXQUh6PT6dDW1sZ7RInsCAs7sjilUon9+/ejrKxMdBSraWlpQX9/v+gYsqBWq2E0GlFVVSU6isNpbm6GJEkcsSOyIyzsyOKUSiUSEhIcZjkiSZLwz3/+E7t27RIdRRaUSqXDt80RZWBgAEFBQQgKChIdhYhGiYUdWUVCQgJaW1vR29srOorFaTQaXLhwgZMmzCgxMRGtra1se2Jl6enpWLVqFZRK/qkgshf8bSWrSExMBC7NFJW74uJi+Pr6IiYmRnQU2bj881NfXy86isMwmUwYGBgQHYOIxoiFHVmFl5cX5s6di4CAANFRLEqn0+H06dPIycnhKIcZeXp64qmnnuLqB1Z07tw5vPDCC+whSGRn2O6ErGb+/PmiI1jcwMAA4uLikJWVJTqK7Pj5+YmO4FA0Gg2USiXb9RDZGQ4pkFWdOXNG1pfTfH198cADD8DX11d0FNnRarV4/fXXodFoREdxCI2NjQgLC4OLi4voKEQ0BizsyKoKCgpw+PBh0TEsoqurC+Xl5TAajaKjyJK3tzd6eno4O9ZKNBoN+9cR2SEWdmRVaWlpqKmpweDgoOgoZnfs2DFs3boVJpNJdBRZutw2h/3sLK+vrw+9vb3sX0dkh1jYkVWlpaXBaDSioqJCdBSzGhoaQnFxMXJycuDs7Cw6jmwlJSU5TNsckTw9PbF27VokJyeLjkJEY8TCjqxKrVYjMjISZ86cER3FrMrKyjA4OIipU6eKjiJrCQkJAMDLsVbg5OQEJyfOryOyN/ytJavLy8uTXX+swsJCJCYmwt/fX3QUWfPy8sLKlSsRGhoqOoqsvf3220hOTsYNN9wgOgoRjRELO7K69PR00RHMymQyITMzEyEhIaKjOISIiAjREWRNp9NBo9EgMzNTdBQiGgdeiiUhWlpacOLECdExzEKpVGLmzJmIi4sTHcUh9Pb24r333mPjXAtpamqCJEmcOEFkp1jYkRC1tbXYvn079Hq96CgT0t/fj+3bt3MNUyvy8PBAS0uLQyxPJ4JGo4GbmxsCAwNFRyGicWBhR0KkpaXBYDDYfeuKkpISFBUVcfkwK2LbE8tqbGxEdHQ0f6aJ7BR/c0kIf39/hIWF2fXsWJPJhMLCQqSnp8PT01N0HIfCtieW853vfAf5+fmiYxDROLGwI2HS0tJQWVlpt5dja2pq0NXVhWnTpomO4nAutz2pra0VHUV2vLy8EBAQIDoGEY0TZ8WSMOnp6RgaGrLbJbgKCwsRGhqKyMhI0VEcjre3Nx566CHOkDWz0tJS1NXV4bbbboNCoRAdh4jGgYUdCePv74+bbrpJdIxxW7hwIQYGBvgHUJDExETREWSnsrIS3d3d/JkmsmO8FEtC9ff348CBA3a5dmxQUBAXSReor68PH330Edra2kRHkQ2NRsOfaSI7x8KOhDIYDNi/fz9KS0tFRxm1oaEh/OUvf0FdXZ3oKA7Nzc0NFRUVslt3WJTu7m709PSwfx2RnWNhR0L5+PggNTUVhYWFkCRJdJxRKS4uRlNTE3x8fERHcWgqlQrx8fFcN9ZMNBoNALCwI7JzLOxIuGnTpqGjowMNDQ2io1yXwWDAoUOHMHnyZM4ctAGJiYloamqS3drDIsTExOCOO+6Al5eX6ChENAEs7Ei4uLg4BAQE4NixY6KjXFdpaSl6enowe/Zs0VHoUmEnSRLbnpiBWq1GVlaW6BhENEGcFUvCKRQKLF68GC4uLqKjXNfZs2eRmpqKkJAQ0VEIgK+vL+644w5ePpyg3t5efPXVV8jLy+MtBkR2joUd2YSkpCTREUbl/vvvt8sZvHLGUaaJa2hoQEFBAfLy8kRHIaIJstil2F/96leYNWsWPDw84OvrO6p9JEnCc889h7CwMLi7u2PBggVcD9KBNDU14R//+IdNNiw2mUw4f/48lEolPDw8RMehr+nv78eOHTvQ0dEhOordamhogL+/P0friGTAYoWdXq/H3XffjSeeeGLU+/zmN7/Bn/70J7zxxhs4evQoPD09kZ+fzxESB+Hk5GSz7SsqKirwyiuvsHiwQc7OzigqKkJlZaXoKHaroaEBMTExomMQkRlYrLD75S9/iZ/85CfIyMgY1faSJOGll17Cf/7nf+L2229HZmYm3nvvPbS0tGDLli2Wikk2JDQ0FFFRUSgsLBQd5QqSJOHLL79ETEwMgoKCRMehb3B2dkZcXBzbnoxTf38/2tvbWdgRyYTNzIqtq6tDW1sbFixYMPycWq3GjBkzUFBQMOJ+Op0OPT09VzzIfk2fPh11dXU2NTJWU1ODlpYWzJkzR3QUGkFiYiI0Gg10Op3oKHZHkiTMnTsXcXFxoqMQkRnYTGF3eVmgb842DAkJueaSQevWrYNarR5+cHacfZs0aRI8PT1x4sQJ0VGGHTx4EBEREYiPjxcdhUaQmJgIo9GI+vp60VHsjqenJ+bPnw+1Wi06ChGZwZgKu2effRYKheKaj/LycsulvYq1a9dCq9UOPxobG616fjIvJycnPPjgg5g/f77oKMClhsQhISGYO3cuF0a3Yf7+/li0aBEvlY9DcXExOjs7RccgIjMZU7uTp59+Go899tg1txnvqEZoaCgAoL29HWFhYcPPt7e3Izs7e8T9XF1d4erqOq5zkm0KDw8HLq3J6uzsLDSLk5MTli5dKjQDXZ9CocCsWbNEx7A7g4OD+OSTT7Bs2TKupEIkE2Mq7IKCgiz2iTguLg6hoaHYu3fvcCHX09ODo0ePjmlmLclDSUkJ9u/fjx/+8IfCGhefOnUKfX19mDFjBkfr7MDAwAAKCwuRkZEBPz8/0XHsQmNjIyRJ4sQJIhmx2D12Go0GJSUl0Gg0MBqNKCkpQUlJCXp7e4e3SU1NxebNm4FLn7hXr16N//mf/8Enn3yCU6dO4ZFHHkF4eDiWL19uqZhko6Kjo3Hx4kUcOnRIyPkv90ZrampiUWcnlEol9u/fz7YnY9DQ0AAvLy+O1hHJiMVWnnjuuefw7rvvDn+dk5MDANi3bx/mzZsHXOoNptVqh7d55pln0NfXh+9///vo7u7G7NmzsXPnTri5uVkqJtkof39/5OXl4fDhw8jJybH6CMzu3bthNBqRn59v1fPS+Lm6uiImJgZVVVWYMWOG6Dh24XL/On54IZIPi43YvfPOO5Ak6VuPy0UdLk2z//o9ewqFAv/1X/+FtrY2DA4OYs+ePUhOTrZURLJxN954I9zd3fH5559b9bwNDQ0oLi7GggUL4O3tbdVz08QkJSWhvr4eer1edBSbJ0kSwsPDMWnSJNFRiMiMbKbdCdE3ubq6YuHChXBycrLqMmMnT55EREQEcnNzrXZOMo+kpCQYDAa2PRkFhUKBJUuWYPLkyaKjEJEZKSRJkkSHMKeenh6o1WpotVque0jjIkkSBgYGuCasHZIkCV988QXS09OHZ9rT1bW1tcHNzW3Ua3kTkfVMpJbhiB3ZhZMnT6KkpMSi5+jq6kJdXR0UCgWLOjulUChw8803s6gbhZ07d2Lnzp2iYxCRmbGwI7tQX1+PnTt3or+/3yLHlyQJ27dvx+bNm2EwGCxyDrIOvV6PoqIidHV1iY5iswwGA5qamtjmhEiGWNiRXbj55pshSRL27dtnkeMXFxejqqoKS5YsgZOTxSaLkxUoFArs2LEDZ8+eFR3FZjU3N8NgMLCwI5IhFnZkF7y8vDB37lwcP34cDQ0NZj32mTNn8OmnnyI3NxepqalmPTZZn7OzM+Li4tjP7hoaGhrg6urKS9ZEMsTCjuzG9OnTER0djcOHD5vtmCaTCQcPHkR6ejqWLl3Kfl4ykZSUBI1Gg8HBQdFRbJIkSUhJSYFSyT8BRHLDa05kN5ycnPDAAw8MF19GoxEqlWrcx5MkCUqlEo8++ihcXFz4R05GEhMTYTKZUFtbi7S0NNFxbM7cuXNFRyAiC+FfMrIrrq6ucHFxwfnz5/HKK69Ao9GM6zjNzc1466230NPTA3d39wkViGR7/P39MX36dHh6eoqOYnP6+/uh0+lExyAiC2FhR3bJx8cHPj4+2LBhw5iLu/b2dmzYsAEqlQqurq4Wy0hi3XLLLZwccBVHjhzBn/70J8ishSkRXcLCjuySi4sLHnzwQYSFhWHDhg2jmlDR39+PAwcO4J133oFarcYDDzzAwk7GjEYjzp49y7Yn31BbW8v1YYlkjIUd2a2vF3cffvjh8AjE5VYOuHQfXU9PD3Cpv9lXX32FtLQ0PPzww3B3dxeanyxLkiRs3rwZp06dEh3FZgwODqK5uRkJCQmioxCRhXDyBNk1FxcXPPTQQ2hpaYFCoUBfXx/eeustuLi4IDY2Ft3d3RgYGMDq1avh6+uLn/70p3B2dhYdm6zAyckJ8fHxqKqqwpw5c0THsQl1dXWQJAnx8fGioxCRhXDEjuyes7Pz8L1U7u7u+P73v48bb7wRer0e/v7+WL58+fBlJxZ1jiUpKQlNTU0WW7HE3nR1dSEwMBB+fn6ioxCRhXDEjmRFqVQiPDwc4eHhuPHGG0XHIcGSkpIgSRJqamqQkZEhOo5ws2bNwowZM0THICILYmFHRLLl4+ODnJwcTpK5tD6sQqFgax8imeOlWCKStdtvvx3JycmiYwhXWlqK3/3udxgaGhIdhYgsiIUdEcmayWSCRqNx+LYntbW18Pf3532mRDLHwo6IZE2SJGzatAlFRUWiowhzeXk1zoYlkj8WdkQkayqVCsnJySgvLxcdRZj29nb09/ezsCNyACzsiEj2UlNTcf78eZw/f150FCGam5vh7OyMqKgo0VGIyMI4K5aIZC8+Ph5OTk6oqKhAYGCg6DhWN3XqVKSlpcHJiW/5RHLHETsikj0XFxfk5uY6ZNuTy0vteXh4iI5CRFbAwo6IHMKSJUswdepU0TGsrra2Fn/84x9x8eJF0VGIyApY2BGRw7hw4QLa2tpEx7Cq2tpa6PV6eHl5iY5CRFbAwo6IHMbWrVuxd+9e0TGs6nKbk8vrJRORvLGwIyKHkZqaitraWuh0OtFRrKKvrw+tra1ISEgQHYWIrISFHRE5jNTUVBiNRlRXV4uOYhX19fXApVnBROQYWNgRkcPw8/NDSEiIwzQrnjRpEp544gn4+PiIjkJEVsLCjogcSnZ2tsO0/lAqlQgJCREdg4isiN0qicih5OXliY5gFU1NTdixYwfuvfdejtgRORCO2BGRw+nv70dTU5PoGBZVXl6Orq4utjkhcjAs7IjI4Rw4cAAffPDB8KoMclReXo7k5GQolXybJ3Ik/I0nIoeTkpKCnp4etLa2io5iEZ2dnTh//jxSUlJERyEiK2NhR0QOJyYmBm5ubrKdHVtRUQEnJyf2ryNyQCzsiMjhqFQqJCcn4+zZs6KjWMS0adPw+OOPw8XFRXQUIrIyFnZE5JDS09OhVquh1+tFRzE7Z2dnREREiI5BRAKw3QkROaSUlBRZ3oNWWlqK06dP45577oFKpRIdh4isjCN2ROSwLi8vJqfZsadPn0Z/fz+LOiIHZbHC7le/+hVmzZoFDw8P+Pr6jmqfxx57DAqF4orH4sWLLRWRiBycRqPBhg0bZNPTTq/Xo6amRpYjkUQ0OhYr7PR6Pe6++2488cQTY9pv8eLFaG1tHX784x//sFREInJwMTEx8Pb2xqlTp0RHMYva2loYDAakpqaKjkJEgljsHrtf/vKXAIB33nlnTPu5uroiNDTUQqmIiP6PUqnE5MmTcfLkSeTn59v95cuKigoEBAQgMDBQdBQiEsTm7rHbv38/goODkZKSgieeeAKdnZ3X3F6n06Gnp+eKBxHRaGVkZKC/vx91dXWio0zYggULcOedd4qOQUQC2VRht3jxYrz33nvYu3cvXnjhBRw4cABLliyB0WgccZ9169ZBrVYPP6KioqyamYjsW1hYGCZNmgSTySQ6yoR5enoiPDxcdAwiEkghjWE62LPPPosXXnjhmtucPXv2ivs73nnnHaxevRrd3d1jDldbW4uEhATs2bMHN99881W30el00Ol0w1/39PQgKioKWq0WPj4+Yz4nEZE9+vLLLzE4OIiFCxeKjkJEE9TT0wO1Wj2uWmZM99g9/fTTeOyxx665TXx8/JgCXO9YgYGBqK6uHrGwc3V1haurq9nOSUSO6fK6sWFhYaKjjJkkSSguLkZsbKzoKEQk2JgKu6CgIAQFBVkuzTc0NTWhs7PTLt9oici+fPbZZ/Dw8MADDzwgOsqYnT9/HhcuXEB+fr7oKEQkmMXusdNoNCgpKYFGo4HRaERJSQlKSkrQ29s7vE1qaio2b94MAOjt7cVPf/pTHDlyBPX19di7dy9uv/12JCYm8s2KiCwuIyMD1dXV6O/vFx1lzE6dOgVXV1ezXjEhIvtkscLuueeeQ05ODp5//nn09vYiJycHOTk5OH78+PA2FRUV0Gq1wKVFuUtLS3HbbbchOTkZK1asQG5uLr788kteaiUii0tPT4ckSThz5ozoKGMiSRJOnjyJ9PR0ODs7i45DRIKNafKEPZjIDYdE5Nj+9re/wWAw4PHHHxcdZUw6OzuhVCrh5+cnOgoRmYHVJk8QEcnZ1KlT0dDQAJPJBKXSprpBXVNAQIDoCERkI+znnYuIyMImTZqExYsX201RNzg4iNdeew0ajUZ0FCKyEfbx7kVEZCX9/f04evSoXTQsLisrQ0dHB3x9fUVHISIbwcKOiOhrOjs7sWPHDlRXV4uOcl0lJSVISEjg/cRENIyFHRHR10RGRiI8PBxHjx4VHeWaOjo60NTUhJycHNFRiMiGsLAjIvoahUKB6dOno6amBufPnxcdZ0RnzpyBm5sbUlJSREchIhvCwo6I6BsmT54MT09PHDt2THSUEd14441YuXIlnJzY3ICI/g/fEYiIvsHJyQn5+fnw9vYWHeWqjEYjVCoV25wQ0bewsCMiuorMzEzREUb00Ucfwd3dHbfeeqvoKERkY3gplohoBE1NTfj4449tqvVJf38/KioqEBgYKDoKEdkgFnZERCMwmUwoLS21qdYnp06dgiRJNj2iSETisLAjIhpBVFQUwsLCbGYShSRJKC4uRnJyMjw9PUXHISIbxMKOiGgECoUCM2bMQHV1tU20PtFqtejq6sKUKVNERyEiG8XCjojoGi63Pjl+/LjoKPD19cXq1auRlJQkOgoR2SjOiiUiugYnJyfcf//9CAoKEpqjo6MDnp6e8PDwEJqDiGwbR+yIiK4jMjISrq6u0Ov1Qs4vSRI2b96Mjz76SMj5ich+sLAjIhqF6upq/P73v0d3d7fVz11ZWYmWlhbMmjXL6ucmIvvCwo6IaBSioqLg5OSEPXv2WPW8kiRh3759iImJQXx8vFXPTUT2h4UdEdEouLq64uabb0ZZWRkaGhqsdt7y8nK0tbVh/vz5UCgUVjsvEdknFnZERKOUlZWFsLAw7Ny502qrUfj4+OCGG25AbGysVc5HRPaNhR0R0SgplUosWbIEPj4+0Ol0VjlnREQEFi5caJVzEZH9Y7sTIqIxiI6ORnR0tMXPYzKZsGXLFsyYMQMREREWPx8RyQNH7IiIxqG8vByHDx+22PHLyspQWloKSZIsdg4ikh8WdkRE49De3o49e/ags7PT7Mfu7u7Gzp07kZKSgsjISLMfn4jki4UdEdE4zJo1C97e3ti5c6dZR9X0ej02bdoEFxcX3HbbbWY7LhE5BhZ2RETj4OzsjMWLF6Oqqgq7d+82W3HX3d0NnU6H+++/H56enmY5JhE5DhZ2RETjNGnSJCxZsgTV1dVmWW5MkiQEBwfjySefREhIiFkyEpFj4axYIqIJmDFjBqZMmQJnZ2cMDQ3B2dl5XMcpLy/HsWPHcO+998LV1dXsOYnIMXDEjohogpydnTEwMIDXX38dhYWFY97/3Llz+Pjjj+Hi4jLuwpCICCzsiIjMw83NDUlJSfjss89QUlIy6v26u7vxj3/8A76+vrjjjjugVPJtmYjGj5diiYjMQKFQYPHixRgaGsLWrVvR29uL3NxcuLu7j7hPX18fXn75Zbi5ueHhhx/mJVgimjAWdkREZqJQKLBs2TIolUp88cUXmDx5Mtzd3VFdXQ0vLy+EhISgvr4eJSUluO222+Dp6Yl77rkHsbGxLOqIyCxY2BERmZFSqcSyZcuwcOHC4WJt9+7daG9vh5ubGwYHBxESEoKLFy/C19cXKSkpoiMTkYywsCMisoCvj8CtXLkS9fX1qK+vR2xsLBISEqBQKITmIyJ5YmFHRGRhTk5OSExMRGJiougoRCRznH5FREREJBMs7IiIiIhkgoUdERERkUxYrLCrr6/HihUrEBcXB3d3dyQkJOD555+/7nqKg4ODWLVqFQICAuDl5YU777wT7e3tlopJREREJBsWK+zKy8thMpnw5ptv4vTp0/jDH/6AN954Az//+c+vud9PfvITfPrpp/jwww9x4MABtLS04Dvf+Y6lYhIRERHJhkKSJMlaJ/vtb3+L119/HbW1tVf9vlarRVBQEDZu3Ii77roLuFQgTpo0CQUFBZg5c+Z1z9HT0wO1Wg2tVgsfHx+z/xuIiIiILGkitYxV77HTarXw9/cf8ftFRUUYGhrCggULhp9LTU1FdHQ0CgoKrJSSiIiIyD5ZrY9ddXU1Xn75Zfzud78bcZu2tja4uLjA19f3iudDQkLQ1tZ21X10Oh10Ot3w1z09PWZMTURERGQ/xjxi9+yzz0KhUFzzUV5efsU+zc3NWLx4Me6++26sXLnSnPmxbt06qNXq4UdUVJRZj09ERERkL8Y8Yvf000/jscceu+Y28fHxw//d0tKC+fPnY9asWVi/fv019wsNDYVer0d3d/cVo3bt7e0IDQ296j5r167FmjVrhr/u6elhcUdEREQOacyFXVBQEIKCgka1bXNzM+bPn4/c3Fy8/fbbUCqvPUCYm5sLZ2dn7N27F3feeScAoKKiAhqNBnl5eVfdx9XV9Yo1GYmIiIgclcUmTzQ3N2PevHmIjo7G7373O3R0dKCtre2Ke+Wam5uRmpqKY8eOAQDUajVWrFiBNWvWYN++fSgqKsLjjz+OvLy8Uc2IJSIiInJkFps8sXv3blRXV6O6uhqRkZFXfO9yh5WhoSFUVFSgv79/+Ht/+MMfoFQqceedd0Kn0yE/Px+vvfaapWISERERyYZV+9hZA/vYERERkT2zmz52RERERGQ5LOyIiIiIZMJqDYqt5fKVZTYqJiIiInt0uYYZz91ysivsOjs7AYC97IiIiMiudXZ2Qq1Wj2kf2RV2l9ei1Wg0Y34xaPwuN4ZubGzkpBUr4utufXzNxeDrLgZfdzG0Wi2io6OHa5qxkF1hd7kJslqt5g+hAD4+PnzdBeDrbn18zcXg6y4GX3cxrreww1X3sUgSIiIiIrI6FnZEREREMiG7ws7V1RXPP/8814+1Mr7uYvB1tz6+5mLwdReDr7sYE3ndZbfyBBEREZGjkt2IHREREZGjYmFHREREJBMs7IiIiIhkgoUdERERkUzIprBbt24dpk2bBm9vbwQHB2P58uWoqKgQHUv2Xn/9dWRmZg43r8zLy8OOHTtEx3Iov/71r6FQKLB69WrRUWTtF7/4BRQKxRWP1NRU0bEcQnNzMx566CEEBATA3d0dGRkZOH78uOhYshYbG/utn3eFQoFVq1aJjiZbRqMR/+///T/ExcXB3d0dCQkJ+O///u8xrxcrm5UnDhw4gFWrVmHatGkwGAz4+c9/jkWLFuHMmTPw9PQUHU+2IiMj8etf/xpJSUmQJAnvvvsubr/9dhQXFyM9PV10PNkrLCzEm2++iczMTNFRHEJ6ejr27Nkz/LWTk2zeQm1WV1cXbrjhBsyfPx87duxAUFAQqqqq4OfnJzqarBUWFsJoNA5/XVZWhoULF+Luu+8WmkvOXnjhBbz++ut49913kZ6ejuPHj+Pxxx+HWq3Gj3/841EfR7btTjo6OhAcHIwDBw5gzpw5ouM4FH9/f/z2t7/FihUrREeRtd7eXkyZMgWvvfYa/ud//gfZ2dl46aWXRMeSrV/84hfYsmULSkpKREdxKM8++yy++uorfPnll6KjOLTVq1dj27ZtqKqqgkKhEB1HlpYtW4aQkBD85S9/GX7uzjvvhLu7OzZs2DDq48jmUuw3abVa4FKRQdZhNBqxadMm9PX1IS8vT3Qc2Vu1ahWWLl2KBQsWiI7iMKqqqhAeHo74+Hg8+OCD0Gg0oiPJ3ieffIKpU6fi7rvvRnBwMHJycvDWW2+JjuVQ9Ho9NmzYgO9+97ss6ixo1qxZ2Lt3LyorKwEAJ0+exKFDh7BkyZIxHUeW1xFMJhNWr16NG264AZMnTxYdR/ZOnTqFvLw8DA4OwsvLC5s3b0ZaWproWLK2adMmnDhxAoWFhaKjOIwZM2bgnXfeQUpKClpbW/HLX/4SN954I8rKyuDt7S06nmzV1tbi9ddfx5o1a/Dzn/8chYWF+PGPfwwXFxc8+uijouM5hC1btqC7uxuPPfaY6Ciy9uyzz6KnpwepqalQqVQwGo341a9+hQcffHBMx5FlYbdq1SqUlZXh0KFDoqM4hJSUFJSUlECr1eKf//wnHn30URw4cIDFnYU0Njbiqaeewu7du+Hm5iY6jsP4+qfmzMxMzJgxAzExMfjggw9424EFmUwmTJ06Ff/7v/8LAMjJyUFZWRneeOMNFnZW8pe//AVLlixBeHi46Ciy9sEHH+Dvf/87Nm7ciPT0dJSUlGD16tUIDw8f08+67Aq7J598Etu2bcPBgwcRGRkpOo5DcHFxQWJiIgAgNzcXhYWF+OMf/4g333xTdDRZKioqwrlz5zBlypTh54xGIw4ePIhXXnkFOp0OKpVKaEZH4Ovri+TkZFRXV4uOImthYWHf+pA4adIkfPTRR8IyOZKGhgbs2bMHH3/8segosvfTn/4Uzz77LO677z4AQEZGBhoaGrBu3TrHLOwkScKPfvQjbN68Gfv370dcXJzoSA7LZDJBp9OJjiFbN998M06dOnXFc48//jhSU1Pxs5/9jEWdlfT29qKmpgYPP/yw6CiydsMNN3yrdVVlZSViYmKEZXIkb7/9NoKDg7F06VLRUWSvv78fSuWVUx9UKhVMJtOYjiObwm7VqlXYuHEjtm7dCm9vb7S1tQEA1Go13N3dRceTrbVr12LJkiWIjo7GxYsXsXHjRuzfvx+7du0SHU22vL29v3XvqKenJwICAnhPqQX9+7//O2699VbExMSgpaUFzz//PFQqFe6//37R0WTtJz/5CWbNmoX//d//xT333INjx45h/fr1WL9+vehosmcymfD222/j0UcfZWsfK7j11lvxq1/9CtHR0UhPT0dxcTF+//vf47vf/e7YDiTJBICrPt5++23R0WTtu9/9rhQTEyO5uLhIQUFB0s033yx9/vnnomM5nLlz50pPPfWU6Biydu+990phYWGSi4uLFBERId17771SdXW16FgO4dNPP5UmT54subq6SqmpqdL69etFR3IIu3btkgBIFRUVoqM4hJ6eHumpp56SoqOjJTc3Nyk+Pl76j//4D0mn043pOLLtY0dERETkaGTbx46IiIjI0bCwIyIiIpIJFnZEREREMsHCjoiIiEgmWNgRERERyQQLOyIiIiKZYGFHREREJBMs7IiIiIhkgoUdERERkUywsCMiIiKSCRZ2RERERDLBwo6IiIhIJv4/eaY7WM50iTgAAAAASUVORK5CYII=", "text/plain": [ "