From 0fde7bbaed3df28c7e8d2971b7ba23151ac1871e Mon Sep 17 00:00:00 2001 From: Karen Leung Date: Thu, 5 Aug 2021 18:20:36 -0700 Subject: [PATCH] cleaned up notebooks --- README.md | 19 +- examples/Motion planning.ipynb | 1540 +++++++++++++++++++++++++ examples/Neural networks.ipynb | 1185 +++++++++++++++++++ examples/VAE.ipynb | 1166 +++++++++++++++++++ examples/models/bump.npy | Bin 0 -> 768 bytes examples/models/bump_0.00.model | Bin 0 -> 2455 bytes examples/models/bump_2.00.model | Bin 0 -> 2455 bytes examples/models/bump_data_0.00.npy | Bin 0 -> 448 bytes examples/models/bump_data_2.00.npy | Bin 0 -> 448 bytes examples/models/intent_0.00.model | Bin 0 -> 3783 bytes examples/models/intent_0.10.model | Bin 0 -> 3783 bytes examples/models/intent_test.npy | Bin 0 -> 11648 bytes examples/models/intent_train.npy | Bin 0 -> 184448 bytes examples/models/phi1_margin=0.0.npy | Bin 0 -> 920 bytes examples/models/phi1_margin=0.05.npy | Bin 0 -> 920 bytes examples/models/phi2_margin=0.0.npy | Bin 0 -> 920 bytes examples/models/phi2_margin=0.05.npy | Bin 0 -> 920 bytes examples/models/psi1_margin=0.0.npy | Bin 0 -> 920 bytes examples/models/psi1_margin=0.05.npy | Bin 0 -> 920 bytes examples/models/psi2_margin=0.0.npy | Bin 0 -> 920 bytes examples/models/psi2_margin=0.05.npy | Bin 0 -> 920 bytes examples/models/stlvae.model | Bin 0 -> 13959 bytes examples/models/stlvae_stl_loss.npy | Bin 0 -> 528 bytes examples/models/stlvae_train_loss.npy | Bin 0 -> 528 bytes examples/models/stlvae_vae_loss.npy | Bin 0 -> 528 bytes examples/models/vae.model | Bin 0 -> 13959 bytes examples/models/vae_train_loss.npy | Bin 0 -> 528 bytes setup.py | 3 +- 28 files changed, 3897 insertions(+), 16 deletions(-) create mode 100644 examples/Motion planning.ipynb create mode 100644 examples/Neural networks.ipynb create mode 100644 examples/VAE.ipynb create mode 100644 examples/models/bump.npy create mode 100644 examples/models/bump_0.00.model create mode 100644 examples/models/bump_2.00.model create mode 100644 examples/models/bump_data_0.00.npy create mode 100644 examples/models/bump_data_2.00.npy create mode 100644 examples/models/intent_0.00.model create mode 100644 examples/models/intent_0.10.model create mode 100644 examples/models/intent_test.npy create mode 100644 examples/models/intent_train.npy create mode 100644 examples/models/phi1_margin=0.0.npy create mode 100644 examples/models/phi1_margin=0.05.npy create mode 100644 examples/models/phi2_margin=0.0.npy create mode 100644 examples/models/phi2_margin=0.05.npy create mode 100644 examples/models/psi1_margin=0.0.npy create mode 100644 examples/models/psi1_margin=0.05.npy create mode 100644 examples/models/psi2_margin=0.0.npy create mode 100644 examples/models/psi2_margin=0.05.npy create mode 100644 examples/models/stlvae.model create mode 100644 examples/models/stlvae_stl_loss.npy create mode 100644 examples/models/stlvae_train_loss.npy create mode 100644 examples/models/stlvae_vae_loss.npy create mode 100644 examples/models/vae.model create mode 100644 examples/models/vae_train_loss.npy diff --git a/README.md b/README.md index 0a32fba..95173a2 100644 --- a/README.md +++ b/README.md @@ -1,24 +1,11 @@ STLCG ====== -A toolbox to compute the robustness of STL formulas using computations graphs (PyTorch). - -The `wafr20` branch reproduces the results from our [WAFR2020 paper](http://asl.stanford.edu/wp-content/papercite-data/pdf/Leung.Arechiga.Pavone.WAFR20.pdf). Note that the stlcg code in the `master` and `dev` branches have been updated since. So the `wafr20` branch works in isolation. +A toolbox to compute the robustness of STL formulas using computations graphs. ## Installation -This was done on a linux machine running Python 3.5. You may need to change some of the packages in requirements to make it work on your setup. If you are running Python3.6 or higher, you may need to remove `importlib==1.0.4`. -First create a virtual environment -``` -python3 -m venv stlcg-env -source stlcg-env/bin/activate -pip3 install -r requirements.txt -``` -Then, since this project uses IPython notebooks, we'll install this conda environment as a kernel. -``` -python3 -m ipykernel install --user --name stlcg-env --display-name "Python 3.X (stlcg)" -``` -where X is the python3 version number. +You need Python3 and PyTorch installed. The vizualization code here is constructed from https://github.com/szagoruyko/pytorchviz but with modifications to represent STL operators. @@ -27,6 +14,8 @@ The vizualization code here is constructed from https://github.com/szagoruyko/py `demo.ipynb` is an IPython jupyter notebook that showcases the basic functionality of the toolbox. +The `examples` folder contains example usage of STLCG in a number of applications. These are the examples investigated in the WAFR 2020 publication (see below). + ## Publications Here are a list of publications that use stlcg. Please file an issue, or pull request to add your publication to the list. diff --git a/examples/Motion planning.ipynb b/examples/Motion planning.ipynb new file mode 100644 index 0000000..97dcc6e --- /dev/null +++ b/examples/Motion planning.ipynb @@ -0,0 +1,1540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Motion planning example\n", + "This jupyter notebook was used to run the motion planning example, and used to produce the plots. We set up the problem as an unconstrained optimization problem and apply gradient descent. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import sys\n", + "sys.path.append('../src')\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "import numpy as np\n", + "import os\n", + "import pickle\n", + "import torch\n", + "import pickle\n", + "import stlcg" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib\n", + "fontsize = 24\n", + "matplotlib.rc('xtick', labelsize=fontsize) \n", + "matplotlib.rc('ytick', labelsize=fontsize) \n", + "\n", + "# figure settings\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"sans-serif\",\n", + " \"font.sans-serif\": [\"Helvetica\"]})\n", + "# for Palatino and other serif fonts use:\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Palatino\"],\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#### Settings ####\n", + "save_fig = False\n", + "fig_dir = \"figs/motion_planning\"\n", + "data_dir = \"models/motion_planning\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# obstacles\n", + "obs_1 = torch.tensor([0.0, 0.9, -1.0, -0.5]).float() # red box in bottom right corner\n", + "obs_2 = torch.tensor([.2, 0.7, 0.8, 1.2]).float() # green box in top right corner\n", + "obs_3 = torch.tensor([0.0, 0.0, 0.4]).float() # blue circle in the center\n", + "obs_4 = torch.tensor([-1.0, -0.7, -0.2, 0.5]).float() # orange box on the left" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the environment given the obstacles\n", + "plt.figure(figsize=(10,10))\n", + "plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "plt.scatter([-1], [-1], s=300, c=\"orange\")\n", + "plt.scatter([1], [1], s=800, marker='*', c=\"orange\")\n", + "plt.axis(\"equal\")\n", + "plt.grid()\n", + "\n", + "plt.savefig(fig_dir + \"/configuration.png\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing the STL formulas" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def inside_box(xy, obs):\n", + " x = stlcg.Expression('x', xy[:,:1].unsqueeze(0))\n", + " y = stlcg.Expression('y', xy[:,1:].unsqueeze(0))\n", + " r1 = stlcg.Expression('x1', obs[:1].unsqueeze(-1).unsqueeze(-1))\n", + " r2 = stlcg.Expression('x2', obs[1:2].unsqueeze(-1).unsqueeze(-1))\n", + " r3 = stlcg.Expression('y1', obs[2:3].unsqueeze(-1).unsqueeze(-1))\n", + " r4 = stlcg.Expression('y2', obs[3:4].unsqueeze(-1).unsqueeze(-1))\n", + " inputs = ((x,x), (y,y))\n", + " return ((x > r1) & (x < r2)) & ((y > r3) & (y < r4)), inputs\n", + "# ϕ1 = stlcg.Eventually(subformula=stlcg.Always(subformula=inside_box, interval=[0,3]), interval=[0, 12])\n", + "\n", + "def always_stay_outside_circle(xy, obs):\n", + " d1 = stlcg.Expression('d1', torch.norm(xy - obs[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0))\n", + " r1 = stlcg.Expression('r', obs[2:3].unsqueeze(-1).unsqueeze(-1))\n", + " return stlcg.Always(subformula=(d1 > r1)), d1\n", + "\n", + "def control_limit(u, u_max):\n", + " u_abs = stlcg.Expression('u', u.norm(dim=1, keepdim=True).unsqueeze(0))\n", + " um = stlcg.Expression('umax', u_max.unsqueeze(-1).unsqueeze(-1))\n", + " return stlcg.Always(subformula=(u_abs < um)), u_abs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### initializing solution $z$ as a straight line" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "dx = 0.04\n", + "n = np.stack([np.arange(-1, 1, dx), np.arange(-1, 1, dx)]).T\n", + "x0 = -np.ones(2)\n", + "xf = np.ones(2)\n", + "N = n.shape\n", + "u_max = torch.as_tensor(0.8).float() # u max" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting up linear dynamics matrices\n", + "\n", + "$x_{t+1} = Ax_t + Bu_t$, wher $A = I$, and $B = \\Delta t\\cdot I$. \n", + "\n", + "$Z = (x,u)$ (i.e., concatenating $x$ and $u$\n", + "\n", + "$E$ represents a massive matrix that computes $Ax_t+ Bu_t - x_{t+1}$ and $d$ represents what it should equal to over each time step.\n", + "\n", + "The last 4 rows of $E$ and last 4 elements of $d$ correspond to the end point constraints." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Slightly convoluted way to get a initial straight line guess. but oh well" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "Δt = 0.1\n", + "A = np.eye(2)\n", + "B = np.eye(2) * Δt\n", + "E = np.zeros([2*(N[0]+1), (2*N[0] - 1)*N[1]])\n", + "d = np.zeros((2*(N[0]+1)))\n", + "\n", + "for i in range(N[0]-1):\n", + " E[2*i:2*i+2,2*i:2*i+2] = A\n", + " E[2*i:2*i+2,2*(i+1):2*(i+1)+2] = -A\n", + " j = 2*i + N[0]*N[1]\n", + " E[2*i:2*i+2,j:j+2] = B\n", + "E[2*(N[0]-1):2*(N[0]-1)+2, :2] = A\n", + "E[2*N[0]:2*N[0]+2, 2*(N[0]-1):2*(N[0]-1)+2] = A\n", + "\n", + "d[-4:-2] = x0\n", + "d[-2:] = xf\n", + "\n", + "Q = np.zeros([(2*N[0] - 1)*N[1], (2*N[0] - 1)*N[1]]) # no state cost\n", + "R = np.eye((N[0]-1) * N[1]) # control cost\n", + "Q[N[1]*N[0]:, N[1]*N[0]:] = R\n", + "c = np.zeros([(2*N[0] - 1)*N[1]])\n", + "\n", + "# building up the KKT matrix\n", + "K = np.zeros([Q.shape[0]+E.shape[0], Q.shape[1] + E.shape[0]])\n", + "K[:Q.shape[0], :] = np.concatenate([Q, E.T], axis=1)\n", + "K[Q.shape[0]:, :E.shape[1]] = E\n", + "D = np.concatenate([-c, d])\n", + "\n", + "KK = torch.as_tensor(K).float()\n", + "DD = torch.as_tensor(D).float()\n", + "\n", + "# matrix describing the dynamics and state constraints\n", + "CC = torch.as_tensor(d).float()\n", + "EE = torch.as_tensor(E).float()\n", + "\n", + "# solving the KKT matrix (i.e., straight line) and getting only the states (not the lagrange multipliers)\n", + "Z = torch.as_tensor((np.linalg.inv(K) @ D)[:(2*N[0] - 1) * N[1]]).float().requires_grad_(True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "save_fig = True\n", + "fig_path = 'figs/motion_planning'" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "margin = 0.05 # can add a margin so things are not right on the boundary\n", + "T = 5\n", + "γ = 0.3\n", + "lr = 0.05\n", + "keepdim = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing $\\phi_1 = \\lozenge\\,\\square_{[0,5]} \\text{inside red box} \\: \\wedge \\: \\lozenge \\, \\square_{[0, 5]} \\text{inside green box} \\: \\wedge \\: \\square \\, \\neg\\text{inside blue circle}$ \n" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "Z = torch.as_tensor((np.linalg.inv(K) @ D)[:(2*N[0] - 1) * N[1]]).float().requires_grad_(True)\n", + "X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + "x = X[:,:1].unsqueeze(0)\n", + "y = X[:,1:].unsqueeze(0)\n", + "\n", + "U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + "ux = U[:,:1]\n", + "uy = U[:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "inside_box_1, _ = inside_box(X, obs_1) # ((x,x), (y,y))\n", + "inside_box_2, _ = inside_box(X, obs_2) # ((x,x), (y,y))\n", + "\n", + "has_been_inside_box_1 = stlcg.Eventually(subformula=stlcg.Always(subformula=inside_box_1, interval=[0,T]))\n", + "has_been_inside_box_2 = stlcg.Eventually(subformula=stlcg.Always(subformula=inside_box_2, interval=[0,T]))\n", + "always_stay_outside_circle_formula, _ = always_stay_outside_circle(X, obs_3)\n", + "\n", + "ϕ = (has_been_inside_box_1 & has_been_inside_box_2) & always_stay_outside_circle_formula\n", + "θ, _ = control_limit(U, u_max)\n", + "\n", + "box_inputs = ((x, x),(y, y))\n", + "circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + "control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + "\n", + "robustness_1 = torch.relu(-ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze())\n", + "robustness_2 = torch.relu(-θ.robustness(control_inputs, scale=-1).squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: loss: 0.126 robustness_regions: 0.421 robustness_control: 0.000 cont: 0.000000\n", + "100: loss: 0.114 robustness_regions: 0.364 robustness_control: 0.000 cont: 0.004397\n", + "200: loss: 0.097 robustness_regions: 0.299 robustness_control: 0.000 cont: 0.007472\n", + "300: loss: 0.083 robustness_regions: 0.247 robustness_control: 0.000 cont: 0.009299\n", + "400: loss: 0.073 robustness_regions: 0.208 robustness_control: 0.000 cont: 0.010409\n", + "500: loss: 0.065 robustness_regions: 0.181 robustness_control: 0.000 cont: 0.010576\n", + "600: loss: 0.059 robustness_regions: 0.159 robustness_control: 0.000 cont: 0.011084\n", + "700: loss: 0.054 robustness_regions: 0.141 robustness_control: 0.000 cont: 0.011568\n", + "800: loss: 0.049 robustness_regions: 0.122 robustness_control: 0.000 cont: 0.011981\n", + "900: loss: 0.045 robustness_regions: 0.109 robustness_control: 0.000 cont: 0.012503\n", + "1000: loss: 0.041 robustness_regions: 0.093 robustness_control: 0.000 cont: 0.012879\n", + "1100: loss: 0.037 robustness_regions: 0.077 robustness_control: 0.000 cont: 0.013470\n", + "1200: loss: 0.033 robustness_regions: 0.064 robustness_control: 0.000 cont: 0.013350\n", + "1300: loss: 0.029 robustness_regions: 0.050 robustness_control: 0.000 cont: 0.013779\n", + "1400: loss: 0.026 robustness_regions: 0.040 robustness_control: 0.000 cont: 0.013711\n", + "1500: loss: 0.022 robustness_regions: 0.029 robustness_control: 0.000 cont: 0.013606\n", + "1600: loss: 0.018 robustness_regions: 0.016 robustness_control: 0.000 cont: 0.013428\n", + "1700: loss: 0.015 robustness_regions: 0.004 robustness_control: 0.000 cont: 0.013557\n", + "1800: loss: 0.012 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.012095\n", + "1900: loss: 0.009 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.008907\n", + "2000: loss: 0.007 robustness_regions: 0.001 robustness_control: 0.000 cont: 0.007348\n", + "2100: loss: 0.007 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.007081\n", + "2200: loss: 0.005 robustness_regions: 0.001 robustness_control: 0.000 cont: 0.005085\n", + "2300: loss: 0.005 robustness_regions: 0.001 robustness_control: 0.000 cont: 0.004477\n", + "2400: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003860\n", + "2500: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003445\n", + "2600: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002931\n", + "2700: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002515\n", + "2800: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002001\n", + "2900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001486\n", + "3000: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001559\n", + "3100: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001731\n", + "3200: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001009\n", + "3300: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001402\n", + "3400: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001385\n", + "3500: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001437\n", + "3600: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000784\n", + "3700: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000782\n", + "3800: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001042\n", + "3900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000501\n", + "4000: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000938\n", + "4100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000489\n", + "4200: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000522\n", + "4300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000423\n", + "4400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000428\n", + "4500: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001055\n", + "4600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000446\n", + "4700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000367\n", + "4800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000368\n", + "4900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000482\n" + ] + } + ], + "source": [ + "for _ in range(5000):\n", + " X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + " x = X[:,:1].unsqueeze(0)\n", + " y = X[:,1:].unsqueeze(0)\n", + "\n", + " U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + " ux = U[:,:1]\n", + " uy = U[:,1:]\n", + " \n", + " box_inputs = ((x, x),(y, y)) # changes as Z changes (points to the Z tensor)\n", + " circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + " control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + " \n", + " robustness_regions = torch.relu(-(ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze() - margin))\n", + " robustness_control = torch.relu(-θ.robustness(control_inputs, scale=-1, keepdim=keepdim).squeeze())\n", + "\n", + " robustness = robustness_regions + robustness_control\n", + "\n", + " cont = (torch.matmul(EE, Z) - CC).pow(2).sum()\n", + " \n", + " loss = cont + γ*robustness \n", + " loss.backward()\n", + " with torch.no_grad():\n", + " Z -= lr * Z.grad\n", + " \n", + " if _ % 100 == 0:\n", + " xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + " u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + " # plt.scatter(past.detach().numpy()[:,0], past.detach().numpy()[:,1])\n", + " plt.figure(figsize=(10,10))\n", + " plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + " plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + " plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "\n", + " plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + " plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + " plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + " plt.scatter([-1,1], [-1,1], s=300)\n", + " plt.axis(\"equal\")\n", + "\n", + "\n", + " xs = [x0]\n", + " us = u.detach().numpy()\n", + " for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + " xs = np.stack(xs)\n", + " plt.plot(xs[:,0], xs[:,1])\n", + " plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + " plt.grid()\n", + " if save_fig:\n", + " plt.savefig(fig_path + \"/phi1_margin=\" + str(margin) + \"_\" + str(_).rjust(4, '0') + \".png\")\n", + " print(\"%i: loss: %.3f robustness_regions: %.3f robustness_control: %.3f cont: %.6f\"%(_, loss.detach().numpy(), robustness_regions.detach().numpy(), robustness_control.detach().numpy(), cont.detach().numpy()))\n", + "\n", + " plt.close()\n", + " if (robustness < 1E-2) & (cont < 1E-6):\n", + " print(\"FINISHED!\")\n", + " break\n", + " Z.grad.zero_()" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [], + "source": [ + "np.save(\"models/phi1_margin=\" + str(margin), Z.detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAJMCAYAAABzQDsPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXxU1f3/8ddNMlmGEEJYww5BQJaRTVzKV6lbRbRFHVsrUG3V+DX9dYm4lKq17Vdrsca0fvnWpWmtBdqqsdUqjmul1aqoIARREAZky0ICJGQyWSbJ/f1xQyRkJiQhmZvJvJ+PRx4h55575xMGyJtzzj3XME0TEREREYlcMXYXICIiIiInR4FOREREJMIp0ImIiIhEOAU6ERERkQinQCciIiIS4eLsLsBuAwcONMeMGWN3Gd2uqqqKPn362F2GdJDet8il9y4y6X2LTNH0vq1fv77MNM1Bx7dHfaAbM2YMH374od1ldLu1a9cyb948u8uQDtL7Frn03kUmvW+RKZreN8Mwdgdr15SriIiISIRToBMRERGJcAp0IiIiIhFOgU5EREQkwinQiYiIiEQ4BToRERGRCKdAJyIiIhLhFOhEREREIpwCnYiIiEiEU6ATERERiXAKdCIiIiIRToFOREREJMIp0ImIiIhEOAU6ERERkQinQCciIiIS4RToRERERCKcAp2IiIhIhFOgExEREYlwCnQiIiIiEU6BTkRERCTCKdCJiIiIRLg4uwsQERH7HKg6wHXPXcc/d/2T2oZau8vpGf5ldwHtlxCbwHljz+OPC//I4D6D7S5HbKQROhGRKHbdc9fh2eFRmItQtQ21eHZ4uO656+wuRWymQCciEsX+ueufdpcgXUDvoyjQiYhEMY3M9Q56H0WBTkRERCTC6aYIERFpwbzHtLsE26xdu5Z58+bZXcYJGT8z7C5BehiN0ImIiIhEOAU6ERERkQinQCciIiIS4RToRERERCKcAp2IiIhIhFOgExEREYlwCnQiIiIiEU6BTkRERCTCKdCJiIiIRDgFOhEREZEIp0AnIiIiEuEU6EREREQinAKdiIiISIRToBMRERGJcAp0IiIiIhFOgU5EREQkwinQiYiIiEQ4BToRERGRCKdAJyIiIhLhFOhEREREIpwCnYiIiEiEU6ATERERiXAKdCIiIiIRToFOREREJMIp0ImIiIhEOAU6ERERkQinQCciIiIS4RToRERERCKcAp2IiIhIhFOgExEREYlwCnQiIiIiES7O7gJEREREOqrMV0v++n1sLTrCDIefH/71Iyalp3DVrBEMSE6wu7ywszXQGYbhBpYDF5qmubMT56cCy4CZQBrwOvCUaZoburRQERER6RE27S3n/9bu4F/bSgGorW8kY1o9z20uJPHjYnJf+4x5EweRNW88p41Mtbna8An7lKthGKmGYdxuGIYXeAYY18nrzAR2AV7gKuDGpmutNwzjgq6qV0RERHqGVe9+ztWPv8drn5RQW99IbX1ji+M1TW2vflLC1Y+/x6p3P7ejTFuENdAZhpEJHMYaVcsHyk/icm8Aj5um+bhpmuWmaW4wTfMqYCfwWtPonYiIiPQCq979nPte+pTqQAOm2XZf04TqQAP3vfRp1IS6cI/QHQJuMk2zv2madzR93WGGYdwOpAKPBTmc3/T5650rUURERHqSTXvLue+lrVQHGk/c+RjVgUbue2krBftOZvwoMoQ10JmmmW+a5uNdcKlvAOUh1t291vT5qi54HREREbHZ/63dQU19Q6fOralv4Ldv7ujiinqeSN22ZCbW1GowHzZ9nh2mWkRERKSblPlq+de20hNOs4ZimvDmtlIO+mq7trAeJuICnWEYR2+iCDpda5rm0XFVraETERGJcPnr9530NYwuuk5PFnGBjk7eFSsiIiL28Xq9ZGVlkZKSQkxMDCkpKWRlZeH1ets8b2vRkVZ3szZUlVPt/ZDyd/5K/ZHSE752TX0jW4srT6r+ni4qNxZuuts2E2DIkCGsXbvW3oLCwOfzRcX32dvofYtckfzeRWrdXUHvW/c4cuQIXq+X8ePHc8899zS3G4bBP/7xDzIyMkhJSWlur2topKa+kUZMpjUcwjQ+Zfv2z9i7y8veXV4qDh9s7vv12aMYkjSHpdPq26whJa6QtWt7780RURnomm7MeBxg9uzZ5rx58+wtKAzWrl1LNHyfvY3et8gVMe/dv1o3RUTd3UTvW9fzer24XC78fn/IPk6nk4KCApxOJy//+x1e/c+7bP+4gF2fbefQ/s+tToZBXP/hJKRPo/+M8cQPySB+SAavxjuZVl1Pzua2I83lM4Zx7bzpXfid9SyRGOiO3gyRdoJ+vTeGi4iIRIicnBwCgUCbfaqrqzltzpdo7D+K+GETSRg2kcQZmQydsI+vpR1h3BQXqSPH8+BLuztVQ2JcDJOG9u3UuZEiEgPd0ZshTnTTQ4cfJSYiIiJf8Hq95OTksGrVKnw+H8nJySxevJilS5eSkZER9Jw9FX62lFVSXd9IUlwM2w8cbh3oYuKIHzKOhPQJJAybRPywCTj6DwPAwGRoaiJjhvTl1OFTmDra+nFvmibQuUBnAu5ZIzp1bqSIuEBnmma5YRgQ4uaIY+6CfT1sRYmIiPQyHo8Ht9tNIBBoDmSVlZXk5eXx5JNPkp+fz/z581uc8/lhH54PNrFjy2Z2ftL0sWUzsSmDSWgaeUsYNon4IeMw4uIBqK88SF3hNqoKXuWV1Y9SVFdLo/VzvoXDVXWd+j4MA748cRADkhM6dX6kiLhA1+R14ALDMGaaprnhuGNHn+P6VJhrEhER6RW8Xi9utzvourejAe/KK6/k2WefpaysjA0bNrBhwwY+WL+BmkADCUNPIXHEZFJPuYzBZ32fhrgkABoDtdQV7+DIhhepK9xGbeE2GirLAEhJSeGMcQPYU+Hno5IKGo7Zd84AXt9Y3KnvJTEulqwvj+/UuZGkxwc6wzCWAwdN03zgmObHsILbTU0fx7oK2BAk6ImIiPRqnZkiDaa9694uufQyHANHkzx6KkMmf4URs2+izpGCFcFgYEoCowf1YeRAJ7+9+UrqSj+HxtZPfHA4HCxZsgSAUf2cAC2mbacM7EvV5KFs+vxwhx7/leSI4c5LJuEa0fu3prU70I075nOrNW+GYVwA3N7069ePhjTTNPMNw3gcyDQM4zXTNPOb+tyO9YSIWeEoXkREpKfozBTp8fZU+Hlvxx6GzJnH10jg3y88y4F9e5uPN0+dpk8gftgEEoaMx3BYU5mJTgfDBzgZPtDJqIFORg3sQ59EK2aUFe6nriT0fnMOh4Ps7Ozmr0f1czYHu6MWnzUGgPte2kpNfUObT44wDGtk7s5LJjWf19uFPdA1jbhdQMs1cK8ZhrEB2Gma5rHPYP0QOBriWoy4maZ5k2EY64GbDMP4HdbNEhuAscc8LUJERCQqnGiK1O12U1BQ0DxS19jYyM6dO9m0aRMbN27kvQ83sHHTRsqKCgGISehD2qTTGTLpIhr7DSch/RRi+/QHwKyvo7bEi2/Ty/zhwXuYMbI/I9OS2HukutV0aawB6bEBnE5ni7AJVpBzOBzk5+e3awRx8VljcI1M5bdv7uDNbaUYWJsGH5UYF4OJtWYu68vjo2Jk7qiwBzrTNO/oQN9y2hhtO3Y/ORERkWh2oinS2tpabrjhBiZPnsymTZvYtGkTPp8PgNiEJIafNpcRF36bsUPHUxOfxpFAbPO5dWV7qN65ntrCbdQVfdY8dZqSksLXpn/xYzjUdOmoCWdRUFBAbm4uK1eubJ4OXrJkCdnZ2R2aDnaNSOXRJbM56Kslf/0+thZXkhJXyOUzhjFpaF/cs0b0+hsggrF7ylVERCSqddW6txMFuoaGBtauXcv6jzZy6pnnM++GrxI7aCzlRgp7jzTQYJocBvomxTFqYB9GD+rDqEFOhqcl8a3pl7a63rHr3o4VbLoUICMjgxUrVrBixYp2f09tGZCcwE3nWr8/a9eW9+pNg9tDgU5ERMQmJ7XurQY40PRRAilpAwjU1VHtO+aZpUYMjgEjiB96CvFDTyEh/RT6jjqVkvpGSoDUegfThvfj0pmp1MeZDO6fRGqf+BYvc2D/XoI5ft2b2EuBTkRExAbt2RrE7Xazfv16Ghoa2Lx5M5s3b6agoADeAiqOOSEeBp86hhFT59Bn9FRIHUFFYxL7yqowYx0ANNb6aSjbxXVnj8E1oh+u4amMTEuiaW/XoNuF1Fb7eerhX7WoraPr3iQ8FOhERERs0J6tQfx+P1OmTKGx0Vr4HxcXx8SJE2FUDI5RI4kfOo741AziHRnExp3GrkAjNEBcucGINAczx6bwym/vpbZoO0blATIzb+THl5wa9LWCrX8b6YxlyoghbEhJOal1b9L9FOhERERs8Kc//ak50M1dsJC6mhref+PlVv3iEhL5+W/yiEkbxUGzD1tLqjiyt4QYrIX/jdRQZ+xiVkYawwc4GTnQydDUJGJjDBobG/nbd98EwOl0nnCKNNj6t9O7cN2bdB8FOhERkTDzeDxUVVUBVpj7yjev5e7Fl/Plq5Yw+fwrqEsawNv/+ZDyujgcA0fxiDcOvOX0TfQxZVgKvriXqDO81MV4CRj7wWjkyrMKW71OWdF+TZFGCQU6ERGRMDq6du6oRbcs4/fL72XYt3LYlT6RnbsAjuAcPJGGbR/QsH8zT+T8jKnD+jWveTN+dnar68YatFj/VlPt5++P/prMzExNkUYBBToREZEwOn7tXFXlEbZX9SU1fSLnu4YwelAfhg9w0jcxlkXTF5KZmckl09JPeN0ZQ/q1WP82e2w61zz95+78VqQHUaATEREJo6Nr5+YuWMiiW5bxx9wcUuZcxeRhTi6ZNby534H9ezu0NUio/d8kOsTYXYCIiEi0OLp2bu6Chdx874NUHCzjs+pUYhwJfPXMMc39aqr9rH7ofq17k3ZToBMREQmDY9fOLbplGQmJSfz+17n0nXEJs8elMrhfIqZpcmD/Xh6561Y2/uv10JsKixxHU64iIiJhcOzauYHpw/nPS/+gYsQ5JMfGcMnpowAwTZObzz8Dh8NBZmamneVKhNEInYiISDfzer3k5eU1r52r9vn4y/NvkjR2Jl+dM7L5cVtlRfsBPVZLOk6BTkREpBt5PB5cLldzmLv53gd5/IH7ccy8kqHORr40eTDwxbo5QGvnpMMU6ERERLrJ8c9rXXTLMv7z0gtsYwxx8Yl8e/5UYgyDhvp6HrnrVt5e8xzJyclaOycdpkAnIiLSDbxeL1/72teawxxgTbW+/AHOjNO5bM5IBqUkAmDExPD2mudwOBxce+21dpUsEUyBTkREpIsdnWbdsmULYD3e68G/v0rOLx+i71lXM2VYEudMGdLcX2vn5GQp0ImIiHSh46dZ5y5YyHfu/B8e+9WviJmzmAGJsPi8CRiGAXyxds7pdGrtnHSati0RERHpIsGmWa/+wW2s+MkyfJMW0iepD/996TQSHLGYpklp4T5WP3Q/615dw6effqowJ52mQCciItIFPB5Pq5G5b/7wDp557LcUpp9H0qCR3HDRRAamJACt95xTmJOToSlXERGRkxRsmvXGe+7nzw/n8KljMonp4/n2+eM5ZVjf5nO0bk66kgKdiIjISTr2KRAAV2Vl8+s7fsj2JBeJI6ey6NxxTBmV2nxc6+akq2nKVURE5CStWrWqeePgq79/Gyt+ejflEy4jaeh4rp47hpkZaQAt1s2V795BQUGBwpx0CQU6ERGRk+Tz+ZqfArFx4ydUnraIpH4D+fYF45kysl9zv9LCfdx8/hk4nU6FOelSmnIVERE5ScnJySy6ZRm1Zhx/22pixMbzrTMHtghzmmaV7qRAJyIicpIWL17MwPThbC+spJ5YKl/JZdqkMYA1zXpg/14euevW5mlWPdpLupqmXEVERE7S0qVLeWNPEfsOmtBQx4gBzuaNgzXNKuGgEToREZGTlJGRQXpsgD0HjlBXsotxp04BrGnWpx7+laZZpdsp0ImIiHSBBXPPpOhwDTVF2xkz6VRK9+/jyV/czZQRQzTNKt1OU64iIiJd4PODVdQ2QF2Jl8wF32Xq1KncdN6f7S5LooRG6ERERLrAx4VHrF8c3sPEiRPtLUaijgKdiIhIF9iyvwIa65mUnorD4bC7HIkymnIVEZEWjJ8Zdpdgr3917rTBtfcSU9qH9Q3r9HsoYacROhERkZNlQnxDBnVFO2Co3cVINFKgExEROUlx5hBijb7UFXttCXQJsQnhf1HpURToRERETlK8ae0vV1fihSHhf/3zxp4X/heVHkVr6ERERE5SfGMGZmMDdY2fQxgHyxJiEzhv7Hn8ceEfw/ei0iMp0ImIRDHzHtPuEnqUtWvXMm/evHb19Xg8uN1uAoEA8QszCCTvgQMBHPc5cDgc5OfnazNhCRtNuYqIiHSQ1+vF7Xbj9/utQDdkPHUlOwAIBAL4/X7cbjder9fmSiVaKNCJiIh0UE5ODoFAgLkLFrJ8zTvE9kmlrtjLlNPPau4TCATIzc21sUqJJgp0IiIiHbRq1SrOuGgBN9/7IDWOVADqSnaQ9YuHmLtgIWAFupUrV9pZpkQRBToREZEO8vl8LLplGYlJTvYd9INp0sf0M3TkaBbdsqxFP5FwUKATERHpoOTkZAamDwdg30E/ZmUJYydMAGhuP9pPJBwU6ERERDpo8eLFHCwuxDRN9pZW4d/zCeMmTwOgrGg/AA6HgyVLlthZpkQRBToREZEOWrp0Kc+syOHAoSNU1jRQW/QZGVNd1FT7Wf3Q/YAV6LKzs22uVKKFAp2IiEgHZWRksPSGa3ny0TwAaot3kJI2gEfuupV1r67B6XSSn59PRkaGzZVKtNDGwiIiIp0wf/58/nOkP6vWH6C+9HPu/ObX6Nu3L5mZmWRnZyvMSVgp0ImIiHTS3qoYYnwHuOj8eXg8HrvLkSimKVcREZFOME2Tgn3lVO7ewsyZM+0uR6KcAp2IiEgn7C+v5rA/QE3hNgU6sZ0CnYiISCcU7KsAoK54B7NmzbK5Gol2CnQiIiKdULCvAsNspE+gnNGjR9tdjkQ5BToREZFO2Ly/nNjKImZOd2EYht3lSJRToBMREekAr9fLzVlZvLVlD4e9Bbz11ltkZWXh9XrtLk2imAKdiIhIO3k8HlwuF3/Mf5GYhD7UFW+nrq6OvLw8XC6Xti4R2yjQiYiItIPX68XtduP3+4kZOBaA2uLtAAQCAfx+P263WyN1YgsFOhERkXbIyckhEAgwd8FCFnzvHgyzgVh/GV+65GvNfQKBALm5uTZWKdFKgU5ERKQdVq1axRkXLeDmex/kYG0sVBQybtIUsu7LYe6ChYAV6FauXGlzpRKNFOhERETawefzseiWZcQnJrGvzI/v848ZN8VFYpKTRbcsa9FPJNwU6ERERNohOTmZgenDKa2ooba+ker9Wxk/1QXAwPThLfqJhFuc3QWIiIhEgsWLF3OwuJA9/iQA6oq3M26KFejKivYD4HA4WLJkiW01SvTSCJ2IiEg7LF26lGdW5LCruAKjsZ64msOkjxlHTbWf1Q/dD1iBLjs72+ZKJRop0ImIiLRDRkYGS2+4lo8KtmMe2sOYSZMpK9rPI3fdyrpX1+B0OsnPzycjI8PuUiUKKdCJiIi00/kXfoXG5MFU7tqEt+AjvnvhWRS89U8yMzMpKChg/vz5dpcoUUpr6ERERNrps5JKAg0mNYWf8cQTT3DNNdfYXZIIoBE6ERGRdtu0rxyAuqLPmDVrls3ViHxBgU5ERKSdCvZW4DDrSGr0c8opp9hdjkgzBToREZF22rSvnJjDe5kxYwYxMfoRKj2H/jSKiIi0Q3VdA9sP+Di4/SNNt0qPo0AnIiJyAl6vl28v/QkNjSb+fZ/wyCOPkJWVhdfrtbs0EUCBTkREpE0ejweXy8Ur738KQF3RdmpqasjLy8PlcuHxeGyuUESBTkREJCSv14vb7cbv9xM3OIP6yjIaqg4DEAgE8Pv9uN1ujdSJ7RToREREQsjJySEQCAAQn34KdUXbW/UJBALk5uaGuzSRFhToREREQli1ahVnXLSA3JffxZE2nPrSnQwb2/LRXoFAgJUrV9pUoYhFgU5ERCSE6edewM33PkhNfH8Aqvd9ysIbspi7YGGLfj6fz47yRJop0ImIiISweOmPSUxysqfMD1g3REycMZtFtyxr0S85OdmO8kSa6VmuIiIiIQwYOgyAvaVVxAd8xMfCsDEtp1wdDgdLliyxozyRZhqhExERCSHeMAHYW+anvmwnYydPJSYmhrKi/c19HA4H2dnZdpUoAijQiYiIhHTa0P4cqaql3B+gfPsGMqa4qKn2s/qh+3E4HDidTvLz88nIyDjxxUS6kQKdiIhICKP6OUlotH5U+vd8wqDhI3jsJ7dT8NY/yczMpKCggPnz59tcpYjW0ImIiLSp6HANBiZ1B7zcusjN5Mk/sbskkVY0QiciItKGgn3lJDf6cMbHMXHiRLvLEQlKgU5ERCQE0zQp2FdBQ+lOpk+fTmxsrN0liQSlQCciIhLCvsPVHKqqo+ST95k1a5bd5YiEpEAnIiISQsG+CgB8e7Yo0EmPpkAnIiISQsH+cmINk7rSzxXopEdToBMRETmO1+slKyuLFatfwF+4HRrq+d///V+8Xq/dpYkEpUAnIiJyDI/Hg8vlIi/v98QOGkNd0XYA/vCHP+ByufB4PDZXKNKaAp2IiEiT2tpa3G43fr8fs+9gYhL6UFtsBbpAIIDf78ftdmukTnocBToREZEmJSUlBAIB5i5YyE2/WQ1AXdF2TnHNaO4TCATIzc21q0SRoBToREREmhw8eJAzLlrAzfc+SEVDIrE0Eji4l+/cdS9zFywErEC3cuVKmysVaUmBTkREpEljYyOLbllGYpKTvWV+EusOEx8fT8bkaSy6ZVlzP5/PZ2OVIq3pWa4iIiJNYmJiGJg+nIZGk32H/BglOxg98VRi4+IYmD68uV9ycrKNVYq0ZlugMwwjFVgGzATSgNeBp0zT3NCB859p+rL8uMOpTZ+Xm6b5eheUKyIiUWDAgAEcLC4kkJhGfYPJka0fcPrkaQCUFe0HwOFwsGTJEjvLFGnFlilXwzBmArsAL3AVcCMwDlhvGMYFHbjUBU0f7uM+jranhj5VRESkpSFDhvDMihx2FVnjBJWfb2bsqVOpqfaz+qH7ASvQZWdn21mmSCt2jdC9ATxumubjTV9vAK4yDMMLvGYYRn/TNI8fdQtlFtYIH7QOcO0a7RMREQFISEhg6Q3X8qPn/0Vs6njqDxXSf9BgHrnrVta9ugan00l+fj4ZGRl2lyrSQtgDnWEYt2MFr8eCHM4Hbge+Djwe5Hgr7Z2iFRERaY/58+fz8KfxbN/2KWCy/Lvfpm/fvmRmZpKdna0wJz2SHSN03wDKTdPcGeTYa1iB7iraF+jaO4onIiLSLoGGRnYeqiMlUI7L5WLTpk12lyRyQnasoZsJBAtzAB82fZ7dzmsdOvlyREREvrC9xEdtfSPFn7zPjBkzTnyCSA8Q1hE6wzDGNf0yaBAzTbPcMAxo380MacdcczlWUByHtW7usWPW50W3mgPw7nWcU/Q6/DlgdzX2i0mAIefBWX+ExMF2VyMiPdDH+ysAKP1sPTOvucPmakTaJ9wjdONO3KXD1/M2fd6JNQU7E3jMMIzXuvi1ItO710GRhxgU5gBorIUij/X7IiISRMH+chJjof5wkUboJGJE8sbCqTTdHXvsejzDMJZjrcO7wDCMzGAjdYZhZAKZYN2ivnbt2vBUbINzil7X40CCaCx6nX9HwPvu8/l69Z/P3kzvXWTy+Xy882k1idUHAJPKykq9jxFAf98iONA13d06K0j7HU373F1AiJsrmkLe4wCzZ882582b173F2knTrEHFECAS3ve1a9dGRJ3Smt67yOP1evn32//Be7AvRz56C8MwePHFF1m6dKnubO3h9Pct/FOuR0fS0trsdfJ3ry5v+tzVU7wiItILeTweXC4XnxVXYsTFU1fixTRN8vLycLlceDweu0sUaVO4R+iO3gxxopseQt0F215Hz9e2JsFcY9pdQfj92bC7AhHpobxeL263G7/fT0kgAYC64h0ABAIBAoEAbrebgoICjdRJjxXWEbpjnv4QdOTsmLtgT/b5q0cDo57jKiIibcrJySEQCDB3wUL8yek4YkzqDxcxZc7ZzX0CgQC5ubk2VinSNjvWy78Ozc9zPd7R57g+1dYFDMNYfkz4C+boPnb3d7w8ERGJJqtWreKMixZw870Psr/KwNlwBDD53i9/zdwFCwEr0K1cudLeQkXaYEegO/rIr5uCHLsK2HD847yaAtztxzQ9RfBHh2EYRirWGrqrOvA8WBERiVI+n49FtywjLj6RQp9J48HdDBiazqBhI1h0y7IW/UR6qrAHOtM087HuMM00DMN9tL0psM3GCnUc034B1jYky4+O6jUFvnGGYTxjGMYFhmGkGoYxrmk7kjewwlx+mL4lERGJYMnJyQxMH05xeQ0NJlTs3MSYiVMAGJg+vEU/kZ7Kli3KTNO8CWuE7ibDMA4bhuEFTgfGBnnG64dY+80dP3J3B9ZavNeAXVgjdqmmac4yTVNr50REpF0WL17MweJC9h/0A1Cy+R1GT5oMQFnRfgAcDgdLliyxrUaRE7FtH7pj94I7Qb9ygu83lw9oFE5ERE7K0qVLuen2Oxl4yfdwGI3Ule1jzKTJ1FT7Wf2QtRTb4XCQnZ1tc6UioekhAiIiEtUyMjJYesO1bCz4jOR664aIvv3TeOSuW1n36hqcTif5+fnaskR6NAU6ERGJel/5ysUYKUMxD+0G4Off/gYFb/2TzMxMCgoKmD9/vs0VirQtYh/9JSIi0lV2H/JTHWjEKNnJnDlzWLdund0liXSIRuhERCTqbSmsAKBwyzpOO+00m6sR6TgFOhERiXpbCo8QGwMVe7cq0ElEUqATEZGot6XwCEOTTGioV6CTiKRAJyIiUc00TT4prMBZewgAl8tlc0UiHadAJyIiUcvr9XL9/7uFMl8d617OZ8CAAfzoRz/C6/XaXZpIhyjQiYhIVPJ4PLhcLp55/T0A6kp2kp6eTl5eHuXhg0gAACAASURBVC6XC4/HY3OFIu2nbUtERE7A74cPP4TNm6GgAD7+2Pp1ZWVbZ80LeSQtDc4+2/o46yw4/XTo06erq5a2eL1e3G43fr+ffgNGA1B3YCfDJv8XH3/8MYFAALfbTUFBgTYUloigQCci0sQ04YMP4IknrI/a2u55nUOH4MUXrY9g0tPh+9+HG2+EAQO6p4Zol5OTQyAQYO6ChSSddz3F5bWYddWMG38KvPoqAIFAgNzcXFasWGFztSInpilXEYla27fDddeBYVgfMTFwxhnw6KPdF+bao6gIli2DgQO/qO288+D556G+3r66epNVq1ZxxkULuPneBynzQ1L9EQBcs09n7oKFgBXoVq5caWeZIu2mQCciUcM04c9/hpQUKyRNmABPPml3Ve3z5puwcCE4HFbt55wDn31md1WRy+fzseiWZZgx8Rzy1dF4aA9JfZIZmp7OoluWtegnEgkU6ESkVzt0CL73vS9G4BYtOtHat8jw1lswcaL1fblc8NFHdlcUWZKTkxmYPpzCw9UAVO7ewsjxEzEMg4Hpw1v0E4kEWkMnIr1OQwPceScsX969rzNgAEybBlOnwvDhkJxsTYnW1cG2bbsYPnwstbXW1z4f7NljBa/S0q6tY/NmmDnT+vWIEfD009bNFhLa4sWLOVhcSGF5PABFBe8w50tnAlBWtB8Ah8PBkiVLbKtRpCMU6ESk1/jsMzj3XCgu7prrTZ4M3/kOXH21Fdg6Yu3a3cybN7ZdfSsqYN06ePllWL0aDhzoRLFN9u2z7p4FuOkmWLEC4vQvfStLly7lptvvpP/F3yPREcORwp2MHH8tjY2NrH7ofsAKdNnZ2TZXKtI+mnIVkYhmmvDgg9bU48SJnQ9zX/4yrFoFVVXWNU0TtmyBpUs7HuY6ql8/uOgieOghKCn54vU//BC+9a3OX/exx6w1d5MmdV3I7S0yMjJYesO1bP74M/rgB6Bv/zRK9+9j3atrcDqd5Ofna8sSiRgKdCISkXw+68aAmBi47baOnz90KPz979DYaIWnf/7TWl/ndHZ9rZ01a5Z108bRgFdZCT//ecevs22btRWKYcC//tX1dUaqiy++mJiUodTu2QLA/97xfap9lWRmZlJQUMD8+fNtrlCk/RToRCSi1NXBvHnQt691Y0BHXHEF7NplhaOiIuuuUcPoljK7RXIy3H23VX9DgzUC11Hz5lnfs3bjgH2Hq/EHGhmVEkdaWhoNDQ1Mnz6dFStWaGROIo4CnYhEhMZGuPZaSEjo2CjTNddYa9RME559FsaM6bYSwyomBjIzre+rsRGeeqpj53/rW1awe+ed7qkvEmwrtm53PrB9I1OmTMGIpHQvchwFOhHp0UzTGpWKjYU//an95730knXu6tXWvnO9mWHA179ufb+BAHz3u+0/90tfss4vKuq++nqqrcXWZsI71r/FlClTbK5G5OQo0IlIj7VqlTUSde+97ev/la/A4cNWsInW5U9xcdadraYJf/1r+88bNsza6qSurvtq62m2FleSnhJPRVkxU6dOtbsckZOiQCciPU5ZmTVq1N4twB5+2Jp2fPllSE3t3toiyTe+YQW7Tz+FPn1O3P+996wp7bvu6v7aeoJtxZUMcgQANEInEU+BTkR6lF/8AgYNal/fBx6wAsvRJ0FIcJMmWXcFHz4M48efuP9991m/nzt3dn9tdqmtb2BnWRXx1WWAAp1EPgU6EekRSkutEHHnnSfu+73vWSNyndmuJJqlpsL27fD55+3rn5HRO0frvF4v1//wxzQ0mnj++nsMw+Cee+7B6/XaXZpIpynQiYjt7rsPBg8+cb+vftVa9P/wwxqROxmjR1sjm6+/fuK+R0frjhzp/rrCwePx4HK5eOGtDQAESj/HNE3y8vJwuVwc6S3fqEQdBToRsU1FhRUWTjQK1Lev1ff55/UYq650/vlWsGvPM2/79YO//KX7a+pOXq8Xt9vNzC9fxMU3LyM2xiCm+jDpY8YRCATw+/14vV6N1ElEUqATEVu8+Wb7bmB4/nlrdKi3bz1ip9tvh/p6mDOn7X7XXAOjRlmbGkeinJwc5lx4CTff+yAVAQcDnDHUVlVyyeLvMHfBQgBM0yQ3N9fmSkU6ToFORMLu5z+H885ru096OtTWWtOs0v1iY2HdOvj3v9vut3evNUq6Z0946upKq1at4hvfv43EJCdFh6txNj3DddzkqSy6ZRlgBbqVeoyGRCAFOhEJq5kz4Z572u7zj39AYSHEx4enJvnCf/2XtRfdwIFt9xs9+sThr6fx+XwMTB9OdW09Ff4AMb4DAAwfO56B6cNb9BOJNAp0IhIWfr+1Xu6jj0L3OToqd9ll4atLWnM4rLuOn3ii7X7nnguPPhqemrpCcnIyZUX7KamoBaC25HOS+/Wnb/80yor2t+gnEmkU6ESk223bduKNbR99VKNyPc1118GhQ233uflmuP76sJRz0hYvXsxTD/+K/aUVABze9THDx46jptrP6ofuB8AwDJa0d0drkR5EgU5EutUrr1gb27Zl82a46abw1CMd07+/dSfs4sWh+/zhD9aedaYZvro6Y+nSpbz/2ku8uuYVYg0o3rqBtCFDeeSuW3l7zXOAFeiys7NtrlSk4xToRKTbPP00XHxx230qK0GP0ez5Vq6EP/4x9PGdO63n7gYCYSupwzIyMsjPz6esso6a0t0cLini3VfW8Paa53A4HDidTjIyMsjIyLC7VJEOU6ATkW7xzDPWs0RDOeUU62kPWq4UOa691roTti3x8VBTE556OmP+/PlkzPgSgxOt4UTDMEhJSSEzM5OCggJStD+ORCgFOhHpcs8+C1//eujjd9wBn32mpz1EojlzrLWObUlKsva164nq6hspqgwwfVw6AJs3b6aiooIVK1ZoZE4imvZcF5Eu9be/gdvd9vHLLw9fPdL10tOhutoKbqE4HNYIbE8L7bsPVtHQaFJ/eB+GYSjESa+hEToR6TJ//ztceWXo42vXKsz1FomJVmBLSwvdJyam590o4S219pgr37ONMWPGkJiYaHNFIl1DgU5EusSLL8IVV4Q+/uab1r5l0nsYBhw8CBMmhO7Tt2/46mkPb2kVAPs/3cCEtgoXiTAKdCJy0jZubHsz4DfegHnzwlaOhNm2bdCvX/BjVVVtB75w8x7wkd4vke2ffszEiRPtLkekyyjQichJqaiAGTNCH3/99RM/t1Ui3+HDoY9t3w4LFoSvllC8Xi9vfLiF3ZvX4fP5eOyxx8jKysLr9dpdmshJU6ATkU4zTUhNDX38tdfg/PPDV4/YxzCsNXWhvPQS5OSEr57jeTweXC4XhxsSqDmwG4Da2lry8vJwuVx4PB77ihPpAgp0ItJpp5wS+tgLL8AFF4SvFrGfYbS9Xcmtt1pPBQk3r9eL2+2mNiaJmPgkAof2NR8LBAL4/X7cbrdG6iSiKdCJSKf8+McQ6uffAw/ApZeGtx7pGWJj295Y2OWC2trw1QOQk5PDnAsv4dY/WI/3mjZlAjGxsS36BAIBcnNzw1uYSBdSoBORDnvtNbj//uDHzjwTbrstvPVIz5KQYN39Gkq4dwrZUVrOjT/9JbVx1i231cU7GZExgbkLFjb3CQQCrFy5MryFiXQhBToR6ZADB+Cii0Iff/fd8NUiPVdaWtt/Fm64IXy1XHFzNolJTkqP1JLoiOGAdwvDxoxj0S3LWvTz+XzhK0qkiynQiUi7mSYMGRL6uN8fvlqk5zvzTFi2LPix3/8eXnklPHUMSh8GQNmRWgamJFBWuJ/BI0YyMH14i37JerCwRDAFOhFpt5tuCn3s00/bfhSURKdf/AL69Al+7OKL4ciR7q+hxme9yCFfLX0dJnW1NQwZMYqyov3NfRwOB0uWLOn+YkS6iQKdiLTLrl3wu98FP7ZyJUyaFN56JHJUVIQ+FmpD4q40oV8S1f4qDlbWEd9gDSOnDhzM6oe+WAjqcDjIzs7u/mJEuokCnYi0y7hxwdtPPx0WLw5vLRJZYmND3xEN8Ic/dO/rnz5hDA0HSmhoNKHKulvjjfy/8Paa53A4HDidTvLz88nIyOjeQkS6kQKdiJzQD34Q+th774WvDolc48bB448HP3b99VBX172vP+EUawh5z7vWwr2P3vonKSkpZGZmUlBQwPz587u3AJFuFmd3ASLSs+3dCw8/HPzYO+9AjP5bKO10443w/e8H36du2jTrmbDdZc8ha6r11JGDKR46lKKiou57MREb6J9iEWnTqFHB2+fMgbPOCm8tEvnKyoK3f/YZvP9+973u3kN+YmMMind+wtixY7vvhURsokAnIiH94hehj2m/OemMPn1g+fLgx844w9oapzvsOeRnWGoin+/0MmbMmO55EREbKdCJSFD19XDnncGPrV2rqVbpvNtvD32sra1xTsaeQ35GpiaxZ88ejdBJr6R/kkUkqCuvDN4+eTKce254a5HeJ9Rdr7/7XffsTbf3kJ+0BJOGhgYFOumVFOhEpJXqavjHP4If27gxvLVI7zRuHFx6afBj06Z17Wt9vHU7Zb46/pq3AoDvf//7ZGVl4W1rLxWRCKNAJyKthBqB+8lPwOEIby3Se4X6T8OePXDoUNe8hsfj4eyLvgpAddle63N1NXl5ebhcLjweT9e8kIjNFOhEpIXDh+GDD4If++lPw1qK9HKGAatXBz92+uknf32v14vb7aY+MRWA+vLi5mOBQAC/34/b7dZInfQKCnQi0kKo6a7f/tb6ASzSla65Jnj7zp1QXn5y187JyWHOhZdw9Y+sR3ydNn0qCcc9cDgQCJCbm3tyLyTSAyjQiUiz/futj2Buvjm8tUj0eOaZ4O1nn31y191RWs6NP/0ltTFOkuJj8ZUWMm7yNOYuWNjcJxAIsHLlypN7IZEeQIFORJpNmRK8/emnw1uHRBe3O3j7p5+e3B2vV9ycTWKSk4OVtaQlx1NauI8hI0az6JZlLfr5fL7Ov4hID6FAJyIAVFZCRUXwY1ddFd5aJPqEWkt3zjmdv+ag9GEAlFfV0b9PPIdLD5A2ZCgD04e36JecnNz5FxHpIRToRASA664L3v7KK2EtQ6JUqLV0mzZBXV3nrlnjs4b3KvwBkmIbaKivp//gIZQVfbGuwOFwsGTJks69gEgPokAnIgD87W/B2y+6KLx1SPR64ong7f/935273oR+SVRW+qiuayCuoRqAvqn9Wf3Q/c19HA4H2dnZnXsBkR5EgU5EePHF4O333BPeOiS6hRolDhX0TuT0CWOoLy2xvqi21hP8829P8faa53A4HDidTvLz88nIyOjcC4j0IAp0IsJllwVv/8lPwluHyA9+ELx98+bOXW/yhFMB+PxtawPhze++RUpKCpmZmRQUFDB//vzOXVikh4mzuwARsVeoGyFGjIAY/ZdPwuyBB+A3v2ndvmCB9QSJjio5UgPA2TMm897zUFNTQ3x8/ElWKdLz6J9rkSgXajH6G2+Etw4RgFBZa+9eMM2OX6+4KdBVFO9l0KBBCnPSaynQiUS5l14K3j5hQnjrEDnq+eeDt3dmLV1xRQ194mMpLdzDsGHDTq4wkR5MgU4kir37bvD2X/4yvHWIHOurXw3efv31Hb9WyZEahvRLpLCwUIFOejUFOpEo9p3vBG+/7bbw1iFyvJkzg7f7/R27TvGRGoamWIEuPT395AsT6aEU6ESi2Natwdt1M4TY7dlng7f/7Gcdu05JRQ2D+yZQXFysETrp1fTPtkiUKisL3v5//xfeOkSCGTMmePsDD7T/Gtt37KCo3M+ff/9bGhsb+dWvfkVWVhZer7dLahTpSRToRKJUqD3mMjPDW4dIKJdc0vlzPR4PM846B9OIoeZQMQC1tbXk5eXhcrnweDxdVKVIz6BAJxKlHnkkeHucdqeUHmL58uDtH33U9nler5ecvCe59XfPAHDhMTtnBwIB/H4/brdbI3XSqyjQiUShUPt5ud3hrUOkLVOnBm+/8862z1v1wstcf/d9xPRJA8Bh1gJw+vlfae4TCATIzc3tkjpFegIFOpEoFGrB+YMPhrcOkc440Wxp+vQzSEhyUuEPAFB7qBDDMLj2ji/WGQQCAVauXNmdZYqElQKdSBRaujR4++jR4a1D5ET+3/8L3t7WUyPShljbk1RWBzCA6kPFJPdLZciIln/AfT5fF1UpYj8FOpEoFOyZmCkp4a9D5ERCTa+uWRP6nEMlRQBU1TSQGB+Lr/wwfVP7U1a0v0W/5OTkripTxHYKdCICwF132V2BSGtDhwZvv/vu0OcUbVxHbbUff209fRLi8FWU4+ybwuqH7m/u43A4WLJkSRdXK2IfBTqRKLNrV/D2664LaxkiJ2XjxtDHFl92Mb//nzs5fMRHUkIs5WUHOFhcxNtrnmvu43A4yM7ODkOlIuGhQCcSZUKtAx80KLx1iLTX977Xsf4ZGRksveFatn+yle0fvMXubZ9yuLQEsIKc0+kkPz+fjIyMbqhWxB4KdCJR5k9/srsCkY5ZvDh4e3196HPmz5/PyIxJZIz4Ys42JSWFzMxMCgoKmD9/fhdXKWIvBTqRKBNsL1XdECE92ezZwdvfeaft83wBkwvPPRuAe+65h4qKClasWKGROemVFOhEhGuvtbsCkdBiQvyk+vvfQ59TV9+Ir7aeBKMBgLS0tG6oTKTnUKATiSJ+f/D2b30rvHWIdIW//S30sYpqa1NhR2MdoEAnvZ8CnUgUeeON4O2zZoW3DpGO6t+/dVuw/RSPKvdbQS6mvhpQoJPeT4FOJIqECnSGEd46RDrq8ss71v9w02O/zBrraRAKdNLbKdCJRJG29u4S6cmuuKJj/Y+O0DVUHwEU6KT3U6ATiSJbtthdgUjnnHtu8PbKyuDtn+22HvP1sx/fBsDMmTPJysrCG+w2b5FeQIFOJIqUlbVuczrDX4dIR4V67OqOHa3bPB4PP/3FrwCorjgIQFVVFXl5ebhcLjweT3eVKWIb2wKdYRiphmEsNwzjNcMw1jf9eqZd1xGJVlOm2F2BSOcdf2OE1+slJ+9JLlicSYwB5y64jNi4OAACgQB+vx+3262ROul1bAl0TYFrF+AFrgJuBMYB6w3DuCDc1xGJZgp0Esn27m359aoXXub6u++DeCd9EuNobGggbfBQ5i5Y2NwnEAiQm5sb5kpFupddI3RvAI+bpvm4aZrlpmluME3zKmAn8JphGKlhvo5I1FKgk0h2/Ahd+vQzSEhyUlXbgDMhDl9FOcmpqSy6ZVlzn0AgwMpQDzUWiVBhD3SGYdwOpAKPBTmc3/T56+G6jki0U6CTSLZ7d8uv04akA1AbaCDREUtNVRVJzmQGpg9v0c/n84WrRJGwsGOE7htAuWmaO4Mce63p81VhvI5IVBs/3u4KRDrv+BG6QyVFgPXor/i4GOpqa0hISqKsaH+Lfsmh7rIQiVB2BLqZWFOiwXzY9DnEo5i75ToiUaGhIXi7tueSSHZ8oCvauI7aaj+B+kYccQZ1NTXEOhysfuj+5j4Oh4MlS5aEuVKR7hXWQGcYxrimXx4Kdtw0zfKmX7a59q2rriMSTcrLg7c33QAoEpGKilp+vfiyi/n9/9xJdU0djtgYqqt87N76CW+vea65j8PhIDs7O8yVinSvcP9TPu7EXcJ6HZGocfBg8PbGxvDWIdJZhgGm2bLt+K8zMjJYesO1ZL5Ywr73X6W0cF/zMYfDgcPhID8/n4yMjDBULBI+Ufl/c8MwMoFMgCFDhrB27Vp7C+pG84K09ebvN5R5Qdoi4ffB5/N1WZ3WlOu8Vu3//vfb9OtX3yWvIV/oyvdOLHFx5xAItJ5YOv73OSkpiX5pA5k86kusefMxZsyYgdvtZsCAAQwePJiEhISQ743et8ik9y1KA51pmo8DjwPMnj3bnDdvnr0Fdac/t27q1d9vKBH6+7B27dourXPQICgtbdl29tlzGTSoy15CmnT1eyfgcEAg0Lo92O9zwxsvc9rUU3mhsZGzzz6bH/7wh+16Db1vkUnvW/hvijh6E8OJlmGHWO3T5dcRiSoxQf7Ga8pVIsXkya3bbryxdZtpmtTUN5AQF0NNTQ1JSUndX5yIzcId6I7exHCimxVC3b3a1dcRiSrBAl2ou19FepoJE1q3nXNO67ba+kZME+IMa4GdAp1Eg7AGumPuPg16U8Mxd6++Ho7riEQbBTqJZDU1rdsSE1u31QasYedYrD/cCnQSDezYh+51aH4O6/GOPn/1qTBeRyRqOJ2t2yoqwl+HSGdUV7duC5bVqgNWkItpVKCT6GFHoDv6qK6bghy7CthgmuaGYxsNw1je9Kivk7qOSLQbPrx12759rdtEeqL2jtA1BzrTunvbGex/MiK9TNgDnWma+Vh3mGYahuE+2t4U2GZz3OO6DMO4ALgdWH7saFxHryMiMGJE6zYFOokUZWWt24I9wWv7zs8B+PEdtwFw4403kpWVhdfr7cbqROxlxwgdpmnehDWydpNhGIcNw/ACpwNjgzyb9UNgA0FG3Dp4HZGop0Ankco0YWeQf9XHjGn5tcfj4aqrFwFQU3XE+lxTQ15eHi6XC4/H082VitjDlkAH1l5wpmleaJpmf9M0M0zTvOqYmx2O7VdumuYs0zRnncx1RESBTiJXaSlUVbVsczph8OAvvvZ6veTkPUnWAysAcN+Y1XwsEAjg9/txu90aqZNeybZAJyLhp0AnkSpYBhs3znoc2FGrXniZ6+++jz6pAwHo08daO+c6+4u9TQKBALm5ud1aq4gdFOhEoogCnUSqYNOt447buCp9+hkkJDkJNFjblpiBWgAuu+6L3YcDgQArV67stjpF7KJAJxJFdJerRKpggS4jo+XXaUPSATjsqwOgqnQ/AKMnTmnRz+fzdX2BIjZToBOJIoMHQ9xxT3CuqIByrTqVHq49I3SHSooA2FNaRf8+8eze/AED04fRUN/yAbDJwW6NFYlwCnQiUSQmpvWoBsD69eGvRaQjQq2hO1bRxnXUVvvZXeZn1CAn2ws+Yuzkaax+6P7mPg6HgyVLlnRztSLhp0AnEmVOP7112/vvh78OkfYyTdi+vXX78f85WXzZxTz2i//hsK+OwU4o2bub0v37eHvNc819HA4H2dnZ3VyxSPgp0IlEmTlzWrcp0ElPtns3FBe3bIuLa70HXUZGBhdf9nUAVt/93wB8vnULYAU5p9NJfn4+GcGGqUUinAKdSJRRoJNI89Zbrdtmz4aEhNbtsYPHEWPAlPS+ABiGQUpKCpmZmRQUFDB//vxurlbEHnEn7iIivclpp4HDAYFj1okXFlp3uwbb1kTEbsEC3X/9V/C+G/eWc2p6CmZaKtOmTaOgoKB7ixPpITRCJxJlEhNh+vTW7Rqlk57q7bdbt82d27qtsdGkYG8F00em8v777zMn2HC0SC+lQCcShTTtKpGirAw+/bR1+5e+1LrNW+qjsrae4YkBDh48qEAnUUWBTiQKBfs5t25d+OsQOZFgo3NTpsCAAa3bP9prbahYV/QZAGeccUZ3libSoyjQiUShYIHunXfgyJHw1yLSlo6un+ubGMeugvdwOp1MmTIleEeRXkiBTiQKTZgA6ekt2+rq4KWX7KlHJJQOBbo95UwfmcoH77/PrFmziDv+sSgivZgCnUgUiomBhQtbt//97+GvRSSUwkL48MPW7cFuiPh463Y+KazglT8/zrvvvst7771HVlYW3mCPmBDphRToRKLU5Ze3bluzBmpqwl+LSDBPP209JeJYp5wCo0a1bPN4PMy97JtgGPh2bwYgEAiQl5eHy+XC4/GEqWIR+yjQiUSpefMgNbVlW1UVvPaaLeWItPKXv7Ruu/rqll97vV5y8p7k8h89CMAlCy5sPhYIBPD7/bjdbo3USa+nQCcSpRwO+OpXW7dr2lV6gp07g2+lc3ygW/XCy1x/930crHOQlhzPwT07SEkbwJcu+Vpzn0AgQG5ubjdXLGIvBTqRKBZs2vX556G+Pvy1iBzrr39t3eZyweTJLdvSp59BQpKTPaVVjB7Uh+0FG5hw2kwWL/1xc59AIMDKlSu7uWIReynQiUSxiy4Cp7Nl26FD8O9/21OPyFHBplu/+c3WbWlD0ikpr6HcH2CIs5H9O3cw4bRZDEwf3qKfz+frpkpFegYFOpEo5nTCxRe3bv/jH8Neikizjz+2Po73jW+0bjtUUsSGnYcwDKj8xPqfyJkXXUJZ0f4W/ZKTk7ujVJEeQ4FOJMpdeWXrtqeegpKS8NciAsGnW888E8aObd1e+NE61u84yCnpfVn34tNkTHExIH0Yqx+6v7mPw+FgyZIl3VixiP0U6ESi3OWXt36MUl0dPPqoPfVIdKuthSeeaN1+/M0QR80841wOVQUYbB7E+/Empv/Xl3nkrlt5e81zzX0cDgfZ2dndVLFIz6BAJxLlkpIgM7N1+yOPWMFOJJxWr7Y2FD5WTAx8/evB+39YCo4YeObO6wB49tHfNIc5h8OB0+kkPz+fjIyMbqxaxH4KdCJCVhbExrZsKymxNnYVCZfGRvjVr1q3X3FF60fVAQQaGnmxoIgLpwxl+OABDB8+nJSUFGJiYkhJSSEzM5OCggLmz5/f/cWL2EyBTkQYMSL4Wrrf/Kb1Tv0i3eXFF2Hr1tbtt98evP/b28s4VFXHtL417Nq1i5/+9KdUVFTQ0NBARUUFK1as0MicRA0FOhEB4Ac/aN324Yfw3nvhr0Wi0/Llrdu+/GU4/fTg/Z/buJ9+SQ62rf0b8fHxXBnsfyUiUUKBTkQAOOssmD27dfuvfx3+WiT6/Oc/8M47rdtDjc5V1dbz6pYS5k8dwtN//QuXXHIJ/fv3794iRXowBToRAcAwgo/SPfMMFBSEvx6JLg880LrN5YKvfCV4/9c+KaE60MBo8wBFRUVcc8013VugSA+nQCciza66CoYObdlmmnDbbfbUI9Hhk0/gH/9o3X777dZ/NIJ5buN+hvVL5MOXn6Jv375cfmf90wAAIABJREFUeuml3VukSA+nQCcizRISgk9xvfoqvPxy+OuR3s804dZbW7ePHh16q5IyXy1vbS9jwbQhPJufzxVXXEFSUlL3FirSwynQiUgLWVkwblzr9ltvhfr68NcjvduLL4LH07o9OxscjtbtXq+Xb935axoaTX727UupqKjg4MGDeL3e7i9WpAeLs7sAscGfQ8xhiGCN0i1fbk2/HmvLFmsH/xtvtKcu6X1qauCHP2zdPmpU8D9nHo8Ht9tNvyv/Byp3ESjbDcDLL7+My+UiPz9fe85J1NIInYi0cuWVcPbZrdvvvhsqK8Nfj/ROOTmwc2fr9oceAqezZZvX6yUn70nueup14odN5Munn4IRY/0Iq6+vx+/343a7NVInUUuBTqJTTILdFfRohmH9sD1eSUnwuxFFOmrPHrjvvtbt559vPRnieKteeJnr776P3VXW393EwzswGxtxnX1Oc59AIEBubm53lSzSoynQSXQacp7dFfR4Z54ZfFF6Tg5oEERO1q23QnV1y7a4OHj44eB3tqZPPwNHYhLrvYcYNySZ9WueZsjI0f+/vTuPq6rO/zj+OsCVRUTc09RSLCsbK7UxWzW1smWaZrBpsz0smxazNLOmbcqxiazfWFZji2FNJpVlRqUm7plb4o5eN0QQ2Xe4wPn9cS6EcEFQuJcL7+fjcR7I2e733CP3fO73+/18vzz40u/fMBwOB1FRUY1ccpGmSQGdtCw+/tB1FAz52NMl8Qr/+he0anXsuoICGDNGCRJy4n7+2RrfsKpHHoFzznF9TPsuXYnbn8nR7CLOCCli8+rlDL0xnE7duh+zX25ubiOUWKTpU1JEc3ebNRFnbGwsQ4cO9WxZxOv06gWPPgqvv37s+jVrrMSJKVM8Uy7xXrm58NBD1dd36QLPP1/zcalJh/lhUxanhAaw6fNIgtqEcO2Y+0hNSjxmv+Dg4AYusYh3UA2diNTqH/+wAruqXngBNmxwe3HEy/397xAfX339v/4FbdvWfNzKtdtIySri/A7FrFscww13R+DXqhWfvjG1Yh+bzcaYMWMaodQiTZ8COhGpVZs28Mkn1fs1lZTAHXdAfr5nyiXeZ84cmD27+vrBg+HOO2s+rrikDHtZN/wL01gx62WC24YyeOQoZj77JCsXzq/Yz2azMX78+EYouUjTp4BORI7r0kth0qTq63fuhKefdn95xPvs3u26qTUoyBrf0KeWp9G8DQkk5Ti4uksB239dQ35ONk/8aXhFMGez2QgKCiI6OpqwsLBGugKRpk0BnYjUyYsvwvnnV1//n/9YU4OJ1KSoCG65xeo/V9WMGXD22TUfW+go5T9L9jDwtHZsWzKPDh06cP/99xMSEoKPjw8hISFEREQQFxenQYWlRVNAJyJ10qqV1WTm72IIv7vvhqQktxdJvMTTT8PGjdXX33ab9X+nNp+tPUhydiEjOhfw85IlTJkyhffee4+srCxKS0vJyspixowZqpmTFk8BnYjUWb9+Vuf1qpKS4IYbIC/P/WWSpm3BAnjzzerrw8Jg5kzXY86Vyy8u4Z3YPVwc1oHP3nyBbt268eCDDzZeYUW8mAI6EamXRx+1RvOvasMGK0mitNT9ZZKmads218kONht8/jmEhNR+/Mer95OaW8xloZmsXLmSKVOmEBgY2DiFFfFyCuhEpF58fODjj6FTp+rb5s93nTwhLU9CAlxzDWRmVt82bRoMGlT78dmFDt5btpdhfTvx8evP07NnT+67777GKaxIM6CATkTqrXt3+PZbCAiovi0yEt591/1lkqYjPR2uvhoOHaq+7brr4PHHj3+OD1bsI6vAwR8DU/j111957rnn8HfVgVNEAAV0InKCLrrIGp/Olb//HX780b3lkaahoAD+9CfYsaP6tjPOsGp3a+s3Z7fbuf/hx3gzZjN5u1bx99tvJCQkhEsvvbTRyizSHCigE5ETNno0TJ1afX1pqbVtyxb3l0k8p6TEGp5k1arq2045xQryO3as+fgFy9ew5GAGpUPuwGgVRPu0zZSVlZGXl8fAgQOJiYlpvMKLeDkFdCJyUiZNAlddm3JyYMQIiItzf5nE/UwTxo2zmuKratMGYmJcTyFXbl38fnJDOtMqtDMrdxzlgl6h5B/eTWDrYEpLS8nPzyc8PBy73d54FyHixRTQichJMQxr+AlXma8pKTB0KKxb5/ZiiRuZJkyeDP/9b/VtrVpZyTKuBqWuLD6rAP/AIJbEJVNaZtIxcxuH7Lu5bfzvU5E4HA6mT5/ewKUXaR4U0InISbPZIDra9Yj/GRlWsLdypfvLJY2vpAQiIqzM1aoMA6Ki4Morj3+egOAQDqXms2rnUQb2ast370yl55lnc9Utv4974nA4iIqKasDSizQfCuhEpEGEhsL330PPntW35eTAVVfBokXuL5c0noICq6/krFmut7/1Ftx8c93OlZSYyGcr9hMcaCNvzeckH9zPPZNfIP3IsVOQ5LqaP0xEFNCJSMM5/XRYsQL69Km+raAArr/emjlAvF9mpjXO3Pz5rrc//TQ88kjdz/fBvFiSMwsZ0rmAH2a/w9W33sWZ5w/k0zeOzboJDg4+iVKLNF8K6ESkQfXsCcuXW9OEVVVcDH/5izVLgHivw4fh8sut++zKM8/Aq6/W/XwbDqSTEXoOrdN38tVLD9O5e0+uuf1uZj77JCsX/h4x2mw2xowZc5KlF2me/DxdABFpfrp2hdhYa3DZqpOyl5TArbfC1q3w4ovg6+uRIsoJio+37uv+/a63v/WWNT1cXeUXlzDhi82c0qYVG//zAo4Cq0l1/PXDqu1rs9kYP378CZRapPlTDZ2INIqOHeHnn+Hii11vf+UVGDUKUlPdWy45cT/+CJdc4jqYs9ngf/+rXzAH8NoPu9ifls+YvuAoyMXPzw+bzVbl3DaCgoKIjo4mLCzsxC9ApBlTQCcijaZtWysIqCnLcdEiGDhQw5o0dQ6H1SfummtcB+CtW8PChdagwvWxek8qH6/ez+0XduO1Jx/gzDPP5LfffiMiIoKQkBB8fHwICQkhIiKCuLg4Ro0a1TAXJNIMqclVRBpVcPDvD/tvvqm+/eBBuPRSmDED7r+/9mmhxP0OHrTu3Zo1rrd37GhlN194Yf3Om1Po4KnoOHp3bM3hmHc5dOgQq1atol+/fsyYMYMZM2acfOFFWhDV0IlIowsIgK++gpdfdh2wFRdbY5ndf7+VDStNwzffWAMC1xTMnXaaNc1XfYM5gH9+t4OkrAL+2j2Pjz94n6eeeoqLLrro5Aos0oIpoBMRt/DxgWeftaaAat/e9T4ffmgFBzUFEOIeRUXw+OPw5z9bA0O7MnIkrF0LZ55Z//P/vPMIc9cncPfgU3l1QgT9+vXjxRdfPLlCi7RwCuhExK2uvho2bIABA1xv37bN6ng/bhxkZbm3bGL1ZxwyxMpWdcXXF6ZOhR9+gC5d6n5eu93OuHHjaNupG3fN+ImStIPMmXwbR44cYfbs2fj7+zfMBYi0UAroRMTtTj/daqq77z7X203Tmh/27LPhyy+t36VxpaZazd6DB8OmTa736dEDli2zEiR86vH0iImJoX///syaNYtWQ27HJzCElG//ze6dOzAMg5SUlIa5CJEWTAGdiHhEQIA1ZdR//ws1Vc4kJUF4ONx4IyQkuLd8LUVpqRU8n3mmdS9qCp5vuMEK9C65pH7nt9vtRM6aTeSCpUz6ZhOtzxlKmyPrcaTsA6CkpITw8HDsdvtJXolIy6aATkQ86v77rb5YAwfWvM+CBVZt3fTpVv8uaRhr1lh9FseNq7mvnM1mve/ffAMdOtT/NeYs+IH7nnuFgHan8NUvCfToGETrI5swKmXHOBwOpk+ffoJXISKggE5EmoDzzrOCujfftMY0cyUvD554wponduZMBXYn49AhuPtua9DnmppXAc49F1avthIkTnQ4ma7nD6ZVQCDzVh+kqKSMs9jLrz8t5IZ7xlbs43A4iIqKOrEXEBFAAZ2INBG+vvDYY7B9O1x/fc37HTpk1Sj16QPvvKPArj527oR774XevWH27Jr3CwmxkiI2bYJBg07uNdt36cov8WlsS8hi2JkhfP7Pp+jzh/O57fGnj9kvNzf35F5IpIVTQCciTUrPnvDttzBvnjUnbE0OHYKHH4awMHj7bSgsdF8Zvc3atfCXv8A558BHH1kzP9Tkrrus+VoffRT8GmDo+T17E/jm10Oc0TWY9R/8g+KiAh6d9n9kHD1yzH7BwcEn/2IiLZgCOhFpcgzDSobYsQMeeqj25r7ERPj7363A7o034OhR95WzKTNNa9q1YcPgoovg669rzxa+4AIr8/jjj+s3HEltSkrL+PKXw/gY0DV9Hb+tWMqdTz1Hh67d+PSNqRX72Ww2xowZ0zAvKtJCKaATkSarbVurWXXjRrjpptr3PXwYJkyAbt2s2qgFC6CkxD3lbEpSUqxp1AYMsOZejY2tff/QUKuGc906q09dQ3p7qZ2jDn8C439g7mvPcd4lVzDgiuHMfPZJVi6cX7GfzWZj/PjxDfviIi2M5nIVkSbv/POtqcM2b4aXXrL+XZOSEqs26uuvrZqmMWPgnnus5sbmKjsb5s+Hzz6DxYutoUiOp107eOQRq2n1RLJXj+e3hEz+7+fd/Kl/V378+geKCwvZtnYV40b8Pr2XzWbDZrMRHR1NWFhYwxdCpAVRDZ2IeI3zzrMGGv7tN6sW7niOHIHXX4d+/awBc//zH9i1q3kMVFxYaAWtN99sBa533WU1sR4vmOve3RqG5OBBePHFxgnm8otLGD/3N7q08afN7hji4+N56623GDt2LCEhIfj4+BASEkJERARxcXGMGjWq4Qsh0sKohk5EvE55YBcXZ9XYffnl8Y/59VdrAWvGg5EjrWX4cOjUqXHL2xBKS63rXb7cWpYsqd/UaGefDZMmwa23QqtWjVdOgFcW7mB/Wh7/uDSUB258nttvv51HH30UgBkzZjTui4u0UAroRMRr9e8P0dFWrduHH8Inn0By8vGPS0iw9v/wQ+v3Cy6AESOs5fzzrQDvRMddayjFxdact+UB3MqVVtNqfV10kTVV1w031G+6rhP1884jfLr2IHdf1INpE26ma9euCuJE3EABnYh4vb59Ydo0eOUVq9nxo4+soU9qG56jsk2brOXf/7Z+79DB6nNXdenatWEDPdOE9HSw261lzx7r5+7dVnkKCk7svD17wm23WbVx/fs3XHmPJy23iInRWzjrlDakLJnFrl27WLx4MaGhoe4rhEgLpYBORJoNPz+47jprSU21kgQ++sjqc1cfaWmwYoW1VNa2LZx+upUZWtPStq3VPLphQxd27oT8fCswy8///d8ZGb8HcZmZDXPtHTta/eluuw2GDHFPbVxlpmny9FdbyC5wMO6cUu4b/x8ef/xxhg8f7t6CiLRQCuhEpFnq2NHK4Hz0USug+/ZbWLQIfvnlxIczycqyMm3r5uwTe5F6aN3aGs7lttus5mKbrdFfshq73U5kZCRfbDhE8LCx5K38hEffWkifPn149dVX3V8gkRZKAZ2INHvnn28t//gH5OTAsmVWcLdokTV4sbdo0wYuvRQuv9xaBg4Ef3/PlWfB8jUkldrof9eTLGq3A5+sRA6smgeYHDp0iNjYWGWwiriJAjoRaVHatLHmii2fL/bQIStjdMkSq/Zt504rIaEp6NABLrvMCt6uuMLqD9cQ03E1hHXx+8kN6Uw7/0De/j4eP19fhnQtIh5rTJjCwkLCw8OJi4vTGHMibtBEPhpERDyje3drDLe77rJ+LymBfftg+/Zjlx07TjxJoTb+/tC7tzV1WZ8+v//s08da7+6+cHUVn1VAYEgoizYnsf9oHjf2D2HWg8/Su19/9m6LA8DhcDB9+nRluYq4gQI6EZFK/PzgjDOs5cYbf19fVmYNd5KWZiUy1LRkZVl92bKzk+nV6xQCAyEoyFrK/926tTUWXp8+cOqpTTdoq01AcAgpWYX89Fsy558eyrK3n6GstITxke/wyDWXAlZAFxUVpYBOxA0U0ImI1IGPD5x2mrXURWzsToYOPaVxC+VBKYcT+WprITY/H7rn7+Cb1cu5/7lX8KuSmZGbm+uhEoq0LF74vVBERDxt9pz57E7K4eo/dOTzf/+DXmf344obw/n0janH7BccHOyhEoq0LAroRESkXrLyHaR3GoR/wVF2zX+btOQk/vrgY7z3/CRWLpxfsZ/NZmPMmDEeLKlIy6EmVxERqZfXftxJia8/R79+jfgEa9yX1x+LqLafzWZj/Pjx7i6eSIukGjoREamzTQcz+OzXg9x98emc1aU1AH5VxlKx2WwEBQURHR2tIUtE3EQBnYiI1ElJaRlTvt5KlzYBnF2yl/Xr1/PMM88wduxYQkJC8PHxISQkhIiICOLi4jSosIgbqclVRETqZPaaA2xPyubN0efyxOhhnHPOObzwwgvYbDYNTSLiYQroRETkuJKzCnnjp10M7duJuIWfsG/fPhYvXozNExPIikg1CuhEROS4XvpuGyVlJhEDQxk+7lVGjx7N8OHDPV0sEXFSHzoREanV0l0pfL8lmUeu7EPki5Px8fHh9ddf93SxRKQS1dCJiIhLdrud1yKn8705gLKSYibeeCsFuTk88cQT9OzZ09PFE5FKVEMnIiLVLFi+hiUHMyi55G5823aha+ZvFOTmADBz5kxiYmI8XEIRqUwBnYiIHGNd/H5yQzpTGtSe2G0pDAprz5ndQyu2FxQUEB4ejt1u92ApRaQyBXQiInKM+KwCWgUE8uWaBFr5+XDp6X58/f4M/jDksop9HA4H06dP92ApRaQytwd0hmGEGoYxzTCMRYZhbHD+e0A9j1/kXOZVWcrXj2jMaxARac4CgkPYnpDFnuRcrh3Qja/+byqlJSVEPD+1Yh+Hw0FUVJQHSykilbk1KcIZuC0BJgFTgd7AZGCDYRgjTdNcXMdTHS9ge+/ESyki0rIdOZzIwg05dArxp3NpEiu++5q/PvgYflXGnMvNzfVQCUWkKndnuS4B3jdN833n7xuB0YZh2IFFhmG0M00zs47nGgi0d/47tMq2jSdfVBGRlmn2p99ypPMQ7hrWi2+mTyIouA1X33YXn0x76Zj9goODPVRCEanKbQGdYRgTsQIvV7Vn0cBE4GbgfRfbqzFNU0GbiDQ9KSlw991cvngxOByeLk29Ffq1wueB9zjvcDw3X3M9LwPPAA9cPoAHqu6cnQ2G4f5CNqKhni5Ac+fvD1deCR9/DJ07e7o0zYo7+9D9Dcg0TXOvi22LnD9H1/Fcda3FExFxr7vvhpgYfLwwmAP4ZMB1JIV0YtKyj/gXEAg87ulCSfNRVAQxMdbfiTQodza5DqDmptD1zp+D6niu9JMpiGEYEUAEQJcuXYiNjT2Z03mF3NzcFnGdzY3um/e5fPFirx0+IMu/NW9fdDNX7F1Pl4Nb+AwYD3T0dMGk2SlbvJjlDfjZps9KNwV0hmH0dv7TZSBmmmamYVXbV+0L50r7SuechhUo9sYKFt+r1D+vRs593gcYNGiQOXTo0Dq8rHeLjY2lJVxnc6P75oW8tGYO4N3B4WQFtmHistn8C7ABEzxdKGmWfByOBv1s02el+5pcex9/l3qfz+78uRerCXYA8J5hGItqO1BERKpLDu7AR4Nu4M/blhKSso/ZwP1AV08XTETqxBtbBkKxauPCTNMcaJrmSNM02wGvObePcDapiog0DabZ5Je3Zv9MaUAgE2a/xL8feQTTz4+JBw54vFzuXmKXLvV4GZrlIo3O6wI60zQ3OgO5vVXWTwLKx7Gra3KFiEiLtycll7nrErh98GnYirP573//y5133knPnj09XTQRqaNaAzrnrAvmCS6V+8OVB1/tXb1OJSebvTrN+bOhm3hFRJqt13/cRVArPx65sg9vvPEGxcXFPP30054ulojUQ61JEaZpjmyg1ylPhjhe0oOrIU3qo/x4DWsiIlIHGw9m8MO2ZJ4YeSYU5fLOO+9wyy23cMYZZ3i6aCJSD25pcq00+4PLmrNKWbB1nfqrJuUB48meR0TEq9ntdsaNG0dISAg+Pj6EhIQwbtw47HY7AAez8vl+TzJPfhlHSKAfV/XvwltvvUVeXh7PPPOMh0svIvXlzj50i6FiPteqyudmnVvbCQzDmFYp+HOlfBy7qbXsIyLSLNQUtEV9G8OSgxlc+cgUXpu/mEuuvZGcnBxmzZpF//79WbB8DRuSM9m4P5O9R3IZeV5XVu3cx2v/fp2rr76afv36efrSRKSe3BnQlU/5NdbFttHAxqrTeTkDuImVVs3F9dRhOPvsTQNG12M+WBERr7Rg+RqXQdv2xBR8e55Jx26n4uPjQ+dTe/Dgy//m4uv/SqktiOJWIWzKMLEn57FwQyId2/hzUd+OLP16LkWFBSxbtoyYmBhPX56I1JPbZoowTTPaMIz3gQjDMBaZphkNFXO8DgIGVt7fMIwRWPO7YhjGYmd260bDMHobhjEPK7Bbj5VoMQIrUBxtmqaaW0WkWbHb7URGRjJnzhxyc3MZ/pebuefZV+gYGARASOdu3Djhn+SHnM5pw2/kmw1HSc0pIj23mMLiUoocpZT1u4ce/e4B4MM1GUAGAHcN64WjsIAFH7/HBZdfyablPxMeHk5cXBxhYWGeumQRqSd3Tv2FaZpjDcPYAIw1DOO/WMkSG4FeLmrV1ju3UaXmbhIwGWv+10znfotM0xyIiEgzs2D5GpJKbVz5yBT6h9/NnDemMuyuR9mwP49dh5M4cDSPnIISa+eeI1i2O48gWz5tbGW0NYpoSwFQREjbYJbOi8IsLuCBKS/Q5ZTOhATZOCU0kAUfv092Rjojwm9j0/KfcTgcTJ8+nRkzZnj02kWk7twa0AFUnnbrOPtlUqXWzrk+GohuhKKJiHhUTTVxQT6t2HIwi12JZeQNfoj3V1k1bG1aQVDRURz7t5Nq30JO4h4c6YmYxQW1vs67D6zl7IF/pHvvM+l2em+++WAm51x4EWt+/A4Ah8NBVFSUAjoRL+L2gE5ERKqrWhP36RtTueSOR/h6fQqb9mVQUmri72cQSg6hib9xYOW3HNi/HYAeZ/TlgvMHYTu7Kzs3rmfU7XfTvnNXQtq1p0279piYvPvcU8StXg5AYV4euzZtYOva1TiKigA4tXcfVi6cX1Ge3Nxc978JInLCFNCJiHjYuvj95IZ0pmNgEKVlJolFrTGGPsLHv2TSys+HPiEOUn75hs0LoigrLSG0Y2f6DR7CgAfH0n/IZbTvcgqFBfnMfPZJ9m3fQtzqFdz+xGQ6dj2V1KREPntjakUwVy4/J/uY37euXXXM78HBwY1+3SLScBTQiYh4QOXm1dfmL6Zj1+6s2J7Cki1HyM530D7Yxll+h9nx1Tv8uOM32oS248Z7H+Sy628ioHVrPpv+L8658CJCO3UmJTGBT9+YWlHDtnLh/GNq2+rLZrMxZsyYhrpUEXEDBXQiIm5WtXm1sFV73vxuF4fS8gnr0ppuGRtZOXMam7IzOa3v2Yx7JZJLr/sz/gGBFTVxdQna/Pz8KCkpqfjdZrPh6+uLaZoUOZtaXbHZbIwfP77BrldEGp87x6ETEWnxKppXu51KcanJ6kMGby3cRVZ+MVd0K2Tn/93Hj29Opt8fL2LCm+/RPexM/nDRpdha+ZOSmFARzNXEZrMRFBTEBx98wNixY48ZdDgiIoKtW7fy9ddfExQUhM1mc3lsdHS0hiwR8TKqoRMRqaeq2ajBwcHccccdTJgwgdrCoLIyk9WHskgt8uNQWgab9qaTle9g4GmtSYp5h08WzOOUnqfz3KzPOGvgH5n57JOs+v4bVn3/TY3n9PX1JTAwkPz8fIKDgxkzZgzjx48nLCyMe++912WmalhYGHFxcUyfPp2oqKiKa6h8rIh4FwV0IiL14CobdeXC+cyaNYvZs2eT59yvxPBhT4cebD0ljG0LtrEtMZvtSdnkFllNoD6GSRszj64HlxPzzhyKCwu57s77uW3802Snp9WpJs5msxEdHc2oUaPqfR1hYWHMmDFDQ5OINBMK6ERE6qhyNipA51N78NA/X8c0fFm3Pg6fLr15pksftnUJY2en0yiy+QPQas1+2hl5BKUfJG3bOtJ2rcORmgBlJbTt0JH+Qy7jmtvu5oW7R7Pwk1kuX7u2mjgREQV0IiJ1FJ9VgK11CPtT8jiYmkdiWj6H0gpIPvceujrns/+6MJeQZDutNy0kN9lOyhE7JRmHwSyjV69elBU7uDF8NGf2v4BeZ59Lu85dKCosYOazT7p8zZOtiRORlkEBnYi0KLX2f3NR25WV72DDwXTW78/ghx1HOJi6j5JSEwB/owRbQSq+Sbs5/NtyipPtlGan4AucgzXJ9AXABbGxnHfeeYSGhjJu3Dh2JCYw/K+3ENqpM0cPHzpmyJHKQkJCVBMnInWigE5EWozj9X+bN28e5w4eyvoD6azbn8GGA+nEH7FmTPA1IMCRRau0fWRtXUnGzl8pzU3HPzCQbqeHURC/FYB1wLlAQOUXvuKKin9OmDCB/v37E/tNzTMYBgUFERcXpyBOROpMAZ2ItAiu+r9FvPRvigI7snN/Cv6nnsPYmHR8ly8FINDXJLQkg5ADW9i/fgm5B7ZhlhTRuXsPzhnwR866fiJ9LxhE51N78N7zk9i3wwroBh2nHGFhYURHRxMeHo7D4cDhcFRsq9y8qmBOROpDAZ2ItAjxWQX4BYUQfzgbe3Iu+47kcjA1n+KwP9M+DEoykync/xtG2j4yd2/AkXoQm82PQYMGEfHnYVx88RS+/fZbDmTm8bdHn6qYVuu95yfVe1aGUaNGadgQEWlQCuhEpNkqKzPZnpTNyj2pfPXbUfamWP3fDEyCyvIwkuPJ3rKC7D0bKc1NA6zZFV599VUuvvhiBg4cSEDA742n55133nGbS+tKw4aISENSQCciXqPSorv4AAAgAElEQVQuCQ2HMvJZuTuVlXtSWW1PIz2vGIDA0lxsR3eTtn4RWbvXYRYX0OOMvvQ782xW/pZW8RplZWU89dRTLl+/Ls2l5Oc34jsgIuKaAjoR8Qo1JTR8EPUZ/1u5gxvuf5KE4tbsS7WG9g32LSUw6wDFG38mJW4ZpXkZdOnRkwuHXE7/B27n3MEX0yogsNpwIcHBwbWW43jNpfTp02jvgYhITRTQiUiTVzmhoaS0jGzfUMJunsSR3n+iKKADho8vsfsLaF9yCJ/4Xzm0YTGO1IN06dKF4cOHM/z+11m6dCmHcgr5y9hHKvq/ffDP547p/2az2RgzZsxxy6PmUhFpahTQiUiTt/FIDnszYVtCEvGHcyguKcPAxN/HIGvNXAr3b6bo8C6SfQ2uueYaHnv2CUaMGME555yDYRgAXHHFFcft/2az2axaNhERL6OATkTcpq6D+pqmya4jOSzZkcKi7UfYnJCJCfhTjJG8nfS1P5C7dyO+ZgkljuKK4wJat+Hbb791+doaLkREmjMFdCLiFjExMdWCqZycnIpBfT//Yh6hZ17Ikh0pLN5xhEMZBQC0JwfHluWkrP8BR8o+up7WmyuGjmDAUw/T4ZRuPHbd74P25uXl1VoGDRciIs2VAjoRaXR2u53IWbOJXLC0ov/ap29MZfWSJbTqPZDAMwbz8JI8fFb8ip9h0ib/MIXrfiR1SyyJhdmEtOvA3+68j8EjRtGtlxV0FRbk1zuhAdT/TUSaJwV0ItLo5iz4gfueewX/wCBSsgrZlt4K32GP0KPfvWD4UJKbTv6OFRTsWUvB/s10CG3Dddddx3Xj3+Wqq65i8uTJ7NgTzyXX3khZWVlFQHgiCQ0iIs2RAjoRaXS2PgNZtiuL3/btJzmzEIAARybFO1aR9tsSipN2AyatWrVi9YplXHjhhfj6+lYcX5f5T5XQICItmQI6EWkUe4/msjAuiYVbktiZnAOYBBQcJW/jj2TE/YxvUQ5/GHIpSUnxFceUlJRw0UUXVTuXEhpERGqngE5E6ux4War7UvP4fksS38UlsSMpG4CQ4lRy135HZtxSWplFXHjlVQyZOo3zLr6crPQ0NsQurjh/bX3glNAgIlIzBXQiUicxMTFEzprN6L9P4MpHplT0Y/so+ju+2JrF2VfdRkKutW+boqPkr48hffMS2viWctoZfbnnlakMGjYSWyt/wEpq+PSNqRXnr0sfOCU0iIi4poBORI6rPEv13udeISAwiLScIrak2Si97GG6nFsEwJ74nTjsa8ncspS2tjJuuukmwqfM4corryQhIYGxE6cQdu55x2S5Vk1qUB84EZETo4BORI4rMjKS6yLGs35/Huv3HORgqjUBvS3vCNkbYsjeuozSnKOcc845/O/Lzxg6dKg1Ub1TWFgYE+6/i/AbhqkPnIhII1BAJyI1KiopZenOo8xP7UzgsjRKy0xshenkrF9I1paltGllMnjktfy45igAhw4dYuTIkS7PpT5wIiKNRwGdSAtzvMQG0zTZlJDJ1xsTWbD5MJkFDnw6h5H32/ekr/8eW2EaF19zA5dFvMPZgwaTlnyYH/83G4Dc3NxaX1t94EREGocCOpEWpKbEhlmzZhH11ffc/cI7bM0NYl9qHn6UYR7azJHVX1O4/zfad+7Cw5OeZfDIUbTyDwCqJzbUZaYGERFpeAroRFqIqokNACGdunHhvc+S0us6ilp3ZcF+E1vGNlLXzCd/1you+eNAJk6KYO3atcyZM4f1SxfR94JBLhMbNFODiIjnKKATaSEiIyMZ/fcJtAoIZFdiNr/uSWPLgUxKSk18fPzJWP4JeduW0sbHweQnn+S2296nV69eAIwYMYK5c+eycuH8YzJTK1OWqoiI5yigE2khPv1qIWVX3Mevq7aRnluMb2kReTuWkbHxBwKL08lOSwWgtE0bpkyZcsyxmqlBRKRp8/F0AUSk8ZSWmfy88wgPfLKe0Dv/ww+bkknft52j30wj4e07OYODTHzpeV753zcVx+Tl5bk8V3mWakREBCEhIfj4+BASEkJERARxcXGMGjXKXZclIiJVqIZOxEvVlq0a0KEbX6xLYN76BA5nFWIrLSD71+/IjfuJbp1DufXm27n8hvcIbhtKYUE+M599suK8tSU2KEtVRKRpUkAn4oVcZavOeeNfzFkax9fpnxFw+gWYgHFkJymrv8KWspPu3boSn3uUHhf/kUHDRhLUJoSUxAQlNoiINAMK6ES8jKtpuNYn+5A1KIL255ZSkpNGxuq55G7+iYvP68uLUx4kPDycpKQk+vfvz6rvv2HV99+4PLcSG0REvJMCOhEvExkZyV8ffoI9R4tZtSORXYdzwDRxJGwm49dvKdi7Hh8DbrnlFj799NOK45TYICLSfCkpQsSLZOQVE701i/dXZfLhkr3E70skc8UcDr97L10Px/LwYw+AWUZZWRnfffddteOV2CAi0jyphk7EC2xNzOKTNfv55rdEgi6+jaN7tpDxy1cEZO3nmtG3MvzVGDqc0o2UxISKY2qahkuJDSIizY8COhEPqi1TtcdpvfglqYQZM1ez/kAGPmUl5GxdQta6bwky87h/0vNcMupP+NlsgKbhEhFpydTkKuIhMTEx9O/fnx2Hj/La/MV8sS2B1+YvZsuRXC66/yUGvfg9724uYuOOPaQv+S9pH47lb73L+Mvwi8jPzmLjsiWkpyRTVlZGSmICM599UtmqIiItlGroRDzAbrcTHh7OgGFX8cAL/8I/IJD9KXms3F1C4pl/o7UJR3auJ3vjAsKCinnt4XHcfnsUbdq0wW63s2DBAk3DJSIiFRTQiXhAZGQkDoeDWx5/mq2JBSzbdoDE9AIoKSR70w/kbY7BkX6YZ555hpdffhnDMCqOVbaqiIhUpSZXEQ/4dN7XBA74E++uzOCzFQdI2LeXtB9mkPP5k1x9bjtmfPUtpmnSsWPHY4K5cspWFRGRylRDJ+JGB9Ly+GjVftqO+Q8+rQJJjd9E5i/R9Az14eZ7HmDwiFH4+vlVZKuWlpbWeC5lq4qISDkFdCINpKaM1SeeeIJMv/bMWrGXH7cdAbOU/F2ryF73DaE2B89Me4t+Fw6pOE/lbFVfX19PXY6IiHgRBXQiDaDGuVWXbeeb/AXYTjkTw1FA5voF+NhXcFrnULZkJHC0pISfPo+iU7fudOx6KqlJiRVzq9psNjp06ODpSxMRES+ggE7kJFWdW7XQUcqOTH9yLrTmVnVkHCbtp5l0zNnDK+Mf5a673iE5OZn+/ftTUlJSY7aqzWajc+fOHrgiERHxNgroRE5SZGQko/8+gSLTj0XrDrFqRwrFpVCcuJ3MtV9RsOdXfH0Mrh07lnHjxgF1z1T19/f31GWJiIgXUZaryEn6bMFift5bystfbGHplmQyti4n5bOJnJ2/gZdfewnMMkpLS5kzZ84xxylTVUREGopq6ERO0NbELGbG7qHtra+zdmcyOZt/omTHYq7603WMmvg/Qjt2Ou7cqspUFRGRhqCATqSK2uZX7d27N7/sTeedpbtZsScNHIVkr19A0bafCL/3fq7+1/cEtm4NaG5VERFxHwV0IpW4ylb99I2pzJr1Af9bvo0//O1JDub5YBZkk7n2K05zHKBPuxCWZR1l3/Yt5GSm4x8YeEy2KmhuVRERaVwK6EScqmarAnTo2p3B9z3H4bCbKA3sgD0xmey1XzKwfQlPv/AEV199NXv37qV///6aW1VERDxGAZ2IU3m2akBgEMUlZayNT2Xxb4nkFJk4cnPIXPQBBbtW8de/3MS8efMqjtPcqiIi4mnKchVxmjNnDsEduvDzlmRe/Pw3vl57iKN7tpL29Suck/sL+TuWY5aV8tNPP1U7VhmrIiLiSaqhEwGyCx34nHstL36+meIyHwr2baRo07cMHzaEaz+YiaO4iMVfWMOOuMpWBWWsioiI56iGTpo1u93OuHHjjqk1GzduHHa7HYCsfAfTF+3ion/+ROjlY8iMX0/W1y8wvFse//k0itufmExgcLCyVUVEpElTDZ00WzExMdX6teXk5DBr1iw+mfsVt7/0AcsOmxSWGuTHr6Fo43xyE3YweOS1XH7DXwgMbkNKYoKyVUVEpMlTQCfNkt1uJzw8nAHDruL2JyZXTHz/yVtvsiM7gDYXXMsPB8vI37mS1vtX8NJDd3L5P7/gwgsvZM2P37Hmx+9cnlfZqiIi0hQpoJNmKTIykj+OvJYHXvgXAYFBZOYVs/JgGcln30pIGeTtWEbWmrlccX5fYtYvw2azAShbVUREvJICOmmW5syZw2vzF1NY5seCVfv5JT6VsjKTvK0/E3j4V9I2rwFg3brsimAOfs9WnT59OlFRURUzRYwZM4bx48crmBMRkSZJAZ00S/mmjeX7S/glPo7SsjJy4xbTPms7t991Fxdc/iQ39+sBaH5VERFpHhTQSbOSklPI20viOXXsf1m1M5XcLYvpmL2Tu++7l/4XT8YwDFISEyr2V8aqiIg0BwroxGvY7XYiIyOZM2dORVPoHXfcwYQJE2jbpTtvL4kn6pf9OEpN8nYsp2zbTzw4eTIDr3gawzAAKCzIrxiCRBmrIiLSXCigE69Q0xAkH86Zy7x4ByEDr6fE9CFv21LOcOzh4TtvJiLifVYs+IqeZ/StyHKtOgSJMlZFRKQ5UEAnTZ6rIUgSDiTwwdzFZIf2xWgVQNb2ZZyWs52Pn3+KoUOHYhgGHTp0IDw8nLU/LVTGqoiINGuaKUKavPIhSB765+sEd+zKwnUJzIhNIafzeRTY13H4g3FkxrzJkHN7M2zYsIrmVc2vKiIiLYVq6KTJmzNnDi9H/8TS7WksjUuiBD/ydq6mU/ZO/nrDNUxfcAiAqKioapmpylgVEZGWQAGdNGmFjlI4azgzfj6CAz/y49fRMWsb991zJ/0ufIyysjKmP/EQ4HoIEhERkZZAAZ00ScUlZfxv7X7+/f1W2l95P9n7NhJ6dCP33n0H5w5+uGK/1KTEin9rCBIREWmpFNCJR9Q0BMnj459gc6aNV7/dTIbDl8JDOzHiFnBKMEx8+yMCg1pXnENDkIiIiFiUFCFuFxMTw9iJUzhv9D18uHYH7yz+hf6XDydq2TaufG0JT325leSEfbTZGMWsW/qx4quP2LN5I+8+9xQpiQmUlZWRkpjAzGef1BAkIiIiqIZO3MxutxM5azb3PvcKAYFBmKZJSmkwOeeNocO5/hSnHuDo/Km8/tgdPPjg/yoyVqOjozUEiYiISA0U0IlbRUZGMvrvEwgIDGL34Wy+WLqDtGIbjox02PkTSSu+xM/Xh23bzq8I5uD3IUimT59OVFRURTPtmDFjGD9+vII5ERFp0dTkKm41Z84c8v3a8u+5vzLzxz0cScuiZN3n/LVPEW+8/TqYZZSUlBAVFVXt2PIhSLKysigtLSUrK4sZM2YomBMRkRZPNXTiNvajufhfOY63Fu6mND+Pku0/ceOw8xg+7lV8/fxISUyo2FdDkIiIiNSdaujkpNntdsaNG3fMbAzjxo3DbrcDkJRVwP3v/czw15cS2HsQOb/M44qgPbw5/QWuCr8FXz+/YzJWQUOQiIiI1Idq6OSkxMTEEB4ejsPhqEhWyMnJYdasWXwy90uunfAW6zIDKSszcez8me7Z29i0ZjkHgq8n4+g1dOx6KqlJiXz6xtRjMlY1BImIiEjdKaCTE2a32wkPD2fAsKu4/YnJFcFZ1Jv/ZluaHyF/vIm1mQEU7VrB7ee14x+fvkxqair9+/dn5cL5FQFcVRqCREREpH7U5ConLDIykj+OvJaH/vk6nU/tQZkJGw8Vkdz3FkIvu4PCA3Ekf/wo13VMJ/KlZ2jbti1hYWFER0cTFBSEzWY75nw2m42goCANQSIiIlJPCujkhM2ZM4e/PfoUrfwDWb75AFM+Ws1P27PJT9zNKfu+4+jXr1B89ADR0dHHHFc+BElERMQx/e4iIiKIi4tj1KhRHroiERER76QmVzlhubm5HMr1462PVlDgE0zx0cP0dOzjzntvofOpPRj9xbsV+1VVPgTJjBkz3F1sERGRZkcBnZyQ1fHJnHL7NOasTsKRmU3HrNXcM+Ymep5xM8AxQ5AoY1VERKRxqclVjnG8IUh2HM7kqpe/5LYPN+DbtisFqz8h4vKOPP/S0/Q8oy/AMUOQKGNVRESk8amGTirUOgRJ9AIuvPdF9pmdKCsupU3iz0y4/gIe+eg7Fn9eTJdup9Y4BIkyVkVERBqXAjoBfh+CJD8/n0uv+3PFMCQHDxxk5uyFFJ86kL0lBr77lvHKrZdx219fxzAMunbqQHh4OGt/WlgRBIIVyNlsNmWsioiIuIGaXJux1Nwi3l1m5/HPN3EgLZ/HP9/Eu8vspOUWVds3MjISh8PBpdf9mYf++TqhXU5l7o8b+L9FhynuOZjC+NUkf/gQ13TJ5/bwGzEMA1DGqoiISFNgmKbp6TJ41KBBg8z169d7uhgNanNCJm/H7mHZrqMAFJWUMeEPJURu8SPAzwcTGNq3E+OG9uG8HqEAhISEkJOTw9uLfmH9vkxid2RS1ioYx4FNXB4WxCWXDeaRay4lJCSErKwsD15dyxIbG8vQoUM9XQypD+eXnWO08M9Zb6K/uUbSyH8XLem+GYaxwTTNQVXXe6zJ1TCMcGAaMNI0zb0ncHwoMBkYALQHFgNzTdPc2KAF9TJz1uznle93UlhS6vJvpbCkDICfth9heXwqU649izuGnE5ubi6BZwzhjYV7KPEPxZGWyICORdw68VYCgoIoK7OOczUEiYiIiHiWWwM6ZxAWAYwFep/EeQYAS4BJwFTnuSYDGwzDGGma5uIGKK7XsYK5HRQ4yo67r2lCgaOUV77fwda9iZxyx+u06taXgrRDnFls566H/kpIu/YV+6cmJQIagkRERKQpcltAZxhGBPAekAm8jxXYhZ7g6ZYA75um+b7z943AaMMw7MAiwzDamaaZebJl9iabEzJ55fuddQrmypUV5ZOVlsbnjh74tOlI+g//oW9Hgwden0FAYFDFfuXDkGgIEhERkabJnUkR6cBY0zTbmaY5yfl7vRmGMRErEHzPxebyOaZuPrEieq+3Y/dQWFJap33LHEUUH92P0SoAv9btyNsey/mdfSndvYL1S35g5rNPkpKYQFlZGSmJCcx89klWLpyvIUhERESaKLfV0JmmGX38verkb0BmDf3uFgETgdFYtYAtQmpuEct2HXXZZ25Ar3ZcO6gbHY/u5rHrevDu57EUBnbB1u5U8uPXYGvXjdbnDGW3w4ePPpvHPbeNZu1PCyvGkQNrCJKgoCANQSIiItJEeeM4dAOwmlhdKU9XrZb90ZxFbzjkcv2AXu24+dKemGUms5btZktRJgSfSsmBTZTaWtO67yUV+xpARmhf4uLimD59OlFRUeTm5hIcHMyYMWMYP368gjmRE+Uqw0+apKGeLoDICfKqgM4wjPJECpfNtaZpZjrHRzvRvnleaWdSNkUl1fvOXTuoG638fJn8dgxFQadB2nauHXAKA0aP4ZXo7cfsW1hSxs7kHMZecT4zZsxgxowZ7iq+iIiInCSvCug4iczYypwJGhEAXbp0ITY2tiFO6zEX2PIJ+0NJtfUdj+6GVLiicwH56Ru46W9/xNfXF1L3MMHF/iF+h4mNbVG5JE1ebm6u1///bGmGeroAIl6gzGZjeQN+tumz0vsCugbhzI59H6yBhb19MMLHP9/E/C2Hq61/dvQZtA/255rTz8Vn/1bKTj+XMiA9t4jI2G3V9r/pgm7cNfR8N5RY6qolDZYpIi2Hz4gRDfrZps9KTf3VLJzVNQR/v+q38vv1hymukvlaXFLK9+urB38Bfj6cdUqbRiujiIgI/v4wahR8/LGnS9Ls1FpDZxjGImDECZ67McaCK89sbV/rXtZYdy1G+MDuTF8UX239xn0ZgNWXrqNp1cx9v/5wxfrKTOd5ROQkOdPNVWPgnXTfxFvVGtCZpjnSXQWpo/JkiOMlPdR7KjFv1jHYnyv6dmLR9iPVhi7ZuC+DjfsyrLlcXTSzgpWAN6xvJzoE+7uhtCIiItLQvKrJtVKNn8vkiEpZsC1u6q+Hh/YhwM/3hI4N8PNl3LA+DVwiERERcRevCuicFkPFfK5VlTcPz3VfcZqG83qEMuXaswi01e+WBtp8mHLtWfTv3qJGehEREWlWmnRAZxjGNOdUX5WVT/k11sUho4GNpmnWNPBws3bHkNOZcu3ZBNp8jzuOqWFAoM2XKdeezR1DTndL+URERKRxeHLYkt6Vflbr82YYxgisabwwDGNxeZBmmma0YRjvAxGGYSwqn1LMGfgNAga6o/BN1R1DTqd/j1DeWbqHpbuOYmANGlwuwM8HE6vP3LhhfVQzJyIi0gy4NaAzDGMaVrNo5T5wiwzD2AjsNU1zdKX163FO8VW1xs00zbGGYWwAxhqG8V+sZImNQK9GyKz1Ov27h/LumEGk5RYRveEQO5NzCPE7zE0XdOOsU9oQPrC7EiBERESaEbcGdKZpTqrHvpnUUttWeXBgca1DsD9jr7DmX42NzdSgwSIiIs1Uk+5DJyIiIiLHp4BORERExMspoBMRERHxcgroRERERLycAjoRERERL6eATkRERMTLKaATERER8XIK6ERERES8nAI6ERERES+ngE5ERETEyymgExEREfFyCuhEREREvJwCOhEREREvp4BORERExMspoBMRERHxcgroRERERLycAjoRERERL6eATkRERMTLKaATERER8XIK6ERERES8nAI6ERERES+ngE5ERETEyxmmaXq6DB5lGMZR4ICny+EGHYFUTxdC6k33zXvp3nkn3Tfv1JLu22mmaXaqurLFB3QthWEY603THOTpckj96L55L90776T75p1039TkKiIiIuL1FNCJiIiIeDkFdC3H+54ugJwQ3TfvpXvnnXTfvFOLv2/qQyciIiLi5VRDJyIiIuLlFNCJiIhIk2QYRrhhGHbDMHqf4PGhhmFMMwxjkWEYG5z/HtDQ5WwK/DxdABERb2AYRigwGRgAtAcWA3NN09zoifNI3Zzs++08fp7z18wqm0OdP6eZprm4AYorVLznEcBY4IQCOed5BgBLgEnAVOe5JgMbDMMY2dzumWromjl9uxE5ec7/8/sAOzAaeADr4bDBMIwR7j6P1E0Dvt8jnEt4laV8fWjNh0p9GIYRAWRgBV7RVA+i62MJ8L5pmu+bpplpmuZG0zRHA3uBRc7AsdlQUkQzVMO3mzDTNPfW8zyVv918we/fbsKBZvftpqlQjULTYxhGBtaDYVKV9Xasv4t2pmke98HTUOeRummI99v595QBDMT6e4TqAdzG+n6+imuGYYQD7U3TfN/5e/m9qtczzDCMicA0V8cZhjENmAiMLX+dZsE0TS3NaMEK5EysD6Bpzp8m0PsEzpWB9eCvut7uPGeop6+3uS1YQVyG8z6GOn+f53y/R9TxHKHO/Wtbwj19rd6yYH3wu/wbcv6NmUCEu86jxe33LdR6VHr+mlriUul5U69nGLAByKhh2wjnORd5+voaclGTa/OTjvWto51pfStNP5GTOL/dhALvudgc7fx584kVUWrRkE0EA4GRzmV0lUX9terub0Cm6bp2YJHz52g3nkfqpiHfb9Waep8BWJ+brqx3/mxWU4UpKaKZMU0z+vh71cnxPgwnYn0YNp/qag+rQxA9ESuIrtN7bqqTfUMZQM0BcH0eDA11Hqmbhny/T+iLsXhGpT7jLu+baZqZhmFAM+v7qBo6qUmL+3bTBKhGoYmpy4PB+c9aHwwNdR6pmwZ+v9uXn9MwjHnOJDPTmSQW0QDFlYZ3wpmx3kwBnVSjh4/HNGQQrRqFhtFQD4YW+YDxoIZ+v3tj9eXqjfU3mon19/qeYRiLajtQxF0U0Ikrevi4mWoURJqsUKym2zDTNAeapjnSNM12wGvO7SP0dyVNgQI6kaZBNQoiTZAzMWlg1a4QzqSz8qF/lMzStJTfq/a17tXMuqYooBNpflSj0HAa6sHQIh8wHuSu93ua86daNZqW8paO47VoNKuxAxXQNQHOWRjME1waox+bHj5eTDUKDaqhHgwt8gHjQe56v8uP12dhE1Kpi4rLQLtSF5dmNbi6AromwFmDYpzg0hgfJHr41FEDBuOqUWiCGurB0FIfMJ7ixve7/G9Y963pWQwVMx5VVT7t21z3FafxKaCTavTwqbsGDMZVo9B0NdSDocU9YDzspN9v59zVtX35Kc86n1r/4klDcd6niVVWl4/nOdbFIaOxpmtrVmN1KqCTmujh40aqUWjS6v1g0AOmSWiI+zYX1wN9l8/xOg0Y3UgtJWLpXeXnMQzDGIE16Pq0ys8r5yD77wMRzvlhy/efiBWIN79uJ56ee0xL4y7UYR48rA+liVXWhTuPe8/F/ouADZ6+tua2ON9XExjgYltETdtc3Mva7nX5eTQPb/3uzXtUmQMX6yGSUfX95vd5Iqvdr/qcR0vTuG/Oz9B5zu2hWIFFBNZcoXWaX1lLve/bNOf7m1HpnpjOdfOq7BvqXO/ymeS8V4uc5yq/l83y889wXrA0U4ZhlN/gkaZpVquVcX67KR/GYqBZ6RurYRjvYf0xjDadU4o5v91Mdu7b4vvQNSTnt8h5WHO5jq2ybRHQ3jTNgVXWTwPSTNN8zfn7AGCaaZojXZw/FNgHPGA23BRxLYYzM3g01rf7dKxM4gfMKrUzzvd5CUDV+1Wf80jDONn75vy7nIw17E8m1iDfi8r/5kSaCgV0zZDzIT8C65tk5T5ZG4G9pjXZe/m+evg0IfUJomsKxg3DsGPdp/ewHj7tsf4/jAUmuQrsRUTEuymgE2liVKMgIiL1pYBORERExMspy1VERETEyymgExEREfFyCuhEREREvJwCOhEREREvp4BORERExMspoBMRERHxcgroRERERLycAjoRERERL6eATkREREJRx84AAAAQSURBVMTLKaATERER8XL/D3ZNyx2yuEsOAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "# plotting environment\n", + "plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "# plottign optimization results\n", + "plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + "plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + "plt.scatter([-1,1], [-1,1], s=300)\n", + "plt.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u.detach().numpy()\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "plt.plot(xs[:,0], xs[:,1])\n", + "plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing $\\psi_1 = \\lozenge\\,Int{[0,5]} \\text{inside red box} \\: \\wedge \\: \\lozenge \\, Int{[0, 5]} \\text{inside green box} \\: \\wedge \\: \\square \\, \\neg\\text{inside blue circle}$ " + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "Z = torch.as_tensor((np.linalg.inv(K) @ D)[:(2*N[0] - 1) * N[1]]).float().requires_grad_(True)\n", + "X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + "x = X[:,:1].unsqueeze(0)\n", + "y = X[:,1:].unsqueeze(0)\n", + "\n", + "U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + "ux = U[:,:1]\n", + "uy = U[:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [], + "source": [ + "inside_box_1, _ = inside_box(X, obs_1) # ((x,x), (y,y))\n", + "inside_box_2, _ = inside_box(X, obs_2) # ((x,x), (y,y))\n", + "\n", + "has_been_inside_box_1 = stlcg.Eventually(subformula=stlcg.Integral1d(subformula=inside_box_1, interval=[0,T]))\n", + "has_been_inside_box_2 = stlcg.Eventually(subformula=stlcg.Integral1d(subformula=inside_box_2, interval=[0,T]))\n", + "always_stay_outside_circle_formula, _ = always_stay_outside_circle(X, obs_3)\n", + "\n", + "ϕ = (has_been_inside_box_1 & has_been_inside_box_2) & always_stay_outside_circle_formula\n", + "θ, _ = control_limit(U, u_max)\n", + "\n", + "box_inputs = ((x, x),(y, y))\n", + "circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + "control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + "\n", + "robustness_1 = torch.relu(-ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze())\n", + "robustness_2 = torch.relu(-θ.robustness(control_inputs, scale=-1).squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: loss: 0.575 robustness_regions: 1.917 robustness_control: 0.000 cont: 0.000000\n", + "100: loss: 0.124 robustness_regions: 0.280 robustness_control: 0.000 cont: 0.039556\n", + "200: loss: 0.074 robustness_regions: 0.143 robustness_control: 0.000 cont: 0.031612\n", + "300: loss: 0.047 robustness_regions: 0.049 robustness_control: 0.000 cont: 0.032145\n", + "400: loss: 0.028 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.028179\n", + "500: loss: 0.020 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.020475\n", + "600: loss: 0.017 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.016565\n", + "700: loss: 0.012 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.012489\n", + "800: loss: 0.011 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.011138\n", + "900: loss: 0.009 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.008741\n", + "1000: loss: 0.007 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.007296\n", + "1100: loss: 0.006 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.006156\n", + "1200: loss: 0.005 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.004790\n", + "1300: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.004216\n", + "1400: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003190\n", + "1500: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002720\n", + "1600: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002442\n", + "1700: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001783\n", + "1800: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001422\n", + "1900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001114\n", + "2000: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000892\n", + "2100: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000959\n", + "2200: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000577\n", + "2300: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000604\n", + "2400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000426\n", + "2500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000325\n", + "2600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000304\n", + "2700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000233\n", + "2800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000209\n", + "2900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000375\n", + "3000: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000107\n", + "3100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000129\n", + "3200: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000073\n", + "3300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000089\n", + "3400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000044\n", + "3500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000077\n", + "3600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000033\n", + "3700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000022\n", + "3800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000271\n", + "3900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000023\n", + "4000: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000012\n", + "4100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000008\n", + "4200: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000005\n", + "4300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000004\n", + "4400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000380\n", + "4500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000016\n", + "4600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000008\n", + "4700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000004\n", + "4800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000003\n", + "4900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000002\n" + ] + } + ], + "source": [ + "for _ in range(5000):\n", + " X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + " x = X[:,:1].unsqueeze(0)\n", + " y = X[:,1:].unsqueeze(0)\n", + "\n", + " U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + " ux = U[:,:1]\n", + " uy = U[:,1:]\n", + " \n", + " box_inputs = ((x, x),(y, y)) # changes as Z changes (points to the Z tensor)\n", + " circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + " control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + " \n", + " robustness_regions = torch.relu(-(ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze() - margin))\n", + " robustness_control = torch.relu(-θ.robustness(control_inputs, scale=-1, keepdim=keepdim).squeeze())\n", + "\n", + " robustness = robustness_regions + robustness_control\n", + "\n", + " cont = (torch.matmul(EE, Z) - CC).pow(2).sum()\n", + " \n", + " loss = cont + γ*robustness \n", + " loss.backward()\n", + " with torch.no_grad():\n", + " Z -= lr * Z.grad\n", + " \n", + " if _ % 100 == 0:\n", + " xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + " u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + " # plt.scatter(past.detach().numpy()[:,0], past.detach().numpy()[:,1])\n", + " plt.figure(figsize=(10,10))\n", + " plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + " plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + " plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "\n", + " plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + " plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + " plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + " plt.scatter([-1,1], [-1,1], s=300)\n", + " plt.axis(\"equal\")\n", + "\n", + "\n", + " xs = [x0]\n", + " us = u.detach().numpy()\n", + " for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + " xs = np.stack(xs)\n", + " plt.plot(xs[:,0], xs[:,1])\n", + " plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + " plt.grid()\n", + " if save_fig:\n", + " plt.savefig(fig_path + \"/psi1_margin=\" + str(margin) + \"_\" + str(_).rjust(4, '0') + \".png\")\n", + " print(\"%i: loss: %.3f robustness_regions: %.3f robustness_control: %.3f cont: %.6f\"%(_, loss.detach().numpy(), robustness_regions.detach().numpy(), robustness_control.detach().numpy(), cont.detach().numpy()))\n", + "\n", + " plt.close()\n", + " if (robustness < 1E-2) & (cont < 1E-6):\n", + " print(\"FINISHED!\")\n", + " break\n", + " Z.grad.zero_()" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [], + "source": [ + "np.save(\"models/psi1_margin=\"+str(margin), Z.detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "# plotting environment\n", + "plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "# plottign optimization results\n", + "plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + "plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + "plt.scatter([-1,1], [-1,1], s=300)\n", + "plt.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u.detach().numpy()\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "plt.plot(xs[:,0], xs[:,1])\n", + "plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing $\\phi_2 = \\lozenge\\,\\square_{[0,5]} \\text{inside orange box} \\: \\wedge \\: \\square \\neg\\text{inside green box} \\: \\wedge \\: \\square \\, \\neg\\text{inside blue circle}$ " + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [], + "source": [ + "Z = torch.as_tensor((np.linalg.inv(K) @ D)[:(2*N[0] - 1) * N[1]]).float().requires_grad_(True)\n", + "X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + "x = X[:,:1].unsqueeze(0)\n", + "y = X[:,1:].unsqueeze(0)\n", + "\n", + "U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + "ux = U[:,:1]\n", + "uy = U[:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [], + "source": [ + "inside_box_4, _ = inside_box(X, obs_4) # ((x,x), (y,y))\n", + "inside_box_2, _ = inside_box(X, obs_2) # ((x,x), (y,y))\n", + "\n", + "has_been_inside_box_4 = stlcg.Eventually(subformula=stlcg.Always(subformula=inside_box_4, interval=[0,T]))\n", + "never_inside_box_2 = stlcg.Always(subformula=~inside_box_2)\n", + "always_stay_outside_circle_formula, _ = always_stay_outside_circle(X, obs_3)\n", + "\n", + "ϕ = (has_been_inside_box_4 & never_inside_box_2) & always_stay_outside_circle_formula\n", + "θ, _ = control_limit(U, u_max)\n", + "\n", + "box_inputs = ((x, x),(y, y))\n", + "circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + "control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + "\n", + "robustness_1 = torch.relu(-ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze())\n", + "robustness_2 = torch.relu(-θ.robustness(control_inputs, scale=-1).squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: loss: 0.126 robustness_regions: 0.421 robustness_control: 0.000 cont: 0.000000\n", + "100: loss: 0.122 robustness_regions: 0.392 robustness_control: 0.000 cont: 0.004564\n", + "200: loss: 0.110 robustness_regions: 0.349 robustness_control: 0.000 cont: 0.005420\n", + "300: loss: 0.098 robustness_regions: 0.300 robustness_control: 0.000 cont: 0.007834\n", + "400: loss: 0.086 robustness_regions: 0.258 robustness_control: 0.000 cont: 0.008602\n", + "500: loss: 0.076 robustness_regions: 0.219 robustness_control: 0.000 cont: 0.010257\n", + "600: loss: 0.067 robustness_regions: 0.186 robustness_control: 0.000 cont: 0.011051\n", + "700: loss: 0.058 robustness_regions: 0.155 robustness_control: 0.000 cont: 0.011562\n", + "800: loss: 0.048 robustness_regions: 0.117 robustness_control: 0.000 cont: 0.012834\n", + "900: loss: 0.039 robustness_regions: 0.088 robustness_control: 0.000 cont: 0.012876\n", + "1000: loss: 0.031 robustness_regions: 0.058 robustness_control: 0.000 cont: 0.013351\n", + "1100: loss: 0.023 robustness_regions: 0.028 robustness_control: 0.000 cont: 0.014438\n", + "1200: loss: 0.015 robustness_regions: 0.004 robustness_control: 0.000 cont: 0.014081\n", + "1300: loss: 0.011 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.011186\n", + "1400: loss: 0.008 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.008150\n", + "1500: loss: 0.007 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.007253\n", + "1600: loss: 0.006 robustness_regions: 0.001 robustness_control: 0.000 cont: 0.006043\n", + "1700: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.004470\n", + "1800: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003663\n", + "1900: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003458\n", + "2000: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003229\n", + "2100: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002064\n", + "2200: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002024\n", + "2300: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002181\n", + "2400: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001199\n", + "2500: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001269\n", + "2600: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000912\n", + "2700: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000787\n", + "2800: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000633\n", + "2900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000940\n", + "3000: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000892\n", + "3100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000347\n", + "3200: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000297\n", + "3300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000326\n", + "3400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000229\n", + "3500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000280\n", + "3600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000408\n", + "3700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000140\n", + "3800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000128\n", + "3900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000566\n", + "4000: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000094\n", + "4100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000082\n", + "4200: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000524\n", + "4300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000058\n", + "4400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000045\n", + "4500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000055\n", + "4600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000046\n", + "4700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000048\n", + "4800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000037\n", + "4900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000030\n" + ] + } + ], + "source": [ + "for _ in range(5000):\n", + " X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + " x = X[:,:1].unsqueeze(0)\n", + " y = X[:,1:].unsqueeze(0)\n", + "\n", + " U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + " ux = U[:,:1]\n", + " uy = U[:,1:]\n", + " \n", + " box_inputs = ((x, x),(y, y)) # changes as Z changes (points to the Z tensor)\n", + " circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + " control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + " \n", + " robustness_regions = torch.relu(-(ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze() - margin))\n", + " robustness_control = torch.relu(-θ.robustness(control_inputs, scale=-1, keepdim=keepdim).squeeze())\n", + "\n", + " robustness = robustness_regions + robustness_control\n", + "\n", + " cont = (torch.matmul(EE, Z) - CC).pow(2).sum()\n", + " \n", + " loss = cont + γ*robustness \n", + " loss.backward()\n", + " with torch.no_grad():\n", + " Z -= lr * Z.grad\n", + " \n", + " if _ % 100 == 0:\n", + " xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + " u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + " # plt.scatter(past.detach().numpy()[:,0], past.detach().numpy()[:,1])\n", + " plt.figure(figsize=(10,10))\n", + " plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + " plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + " plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "\n", + " plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + " plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + " plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + " plt.scatter([-1,1], [-1,1], s=300)\n", + " plt.axis(\"equal\")\n", + "\n", + "\n", + " xs = [x0]\n", + " us = u.detach().numpy()\n", + " for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + " xs = np.stack(xs)\n", + " plt.plot(xs[:,0], xs[:,1])\n", + " plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + " plt.grid()\n", + " if save_fig:\n", + " plt.savefig(fig_path + \"/phi2_margin=\" + str(margin) + \"_\" + str(_).rjust(4, '0') + \".png\")\n", + " print(\"%i: loss: %.3f robustness_regions: %.3f robustness_control: %.3f cont: %.6f\"%(_, loss.detach().numpy(), robustness_regions.detach().numpy(), robustness_control.detach().numpy(), cont.detach().numpy()))\n", + "\n", + " plt.close()\n", + " if (robustness < 1E-2) & (cont < 1E-6):\n", + " print(\"FINISHED!\")\n", + " break\n", + " Z.grad.zero_()" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [], + "source": [ + "np.save(\"models/phi2_margin=\"+str(margin), Z.detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAJMCAYAAABzQDsPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3gU5frG8e/sZtOzKSQkIfRQhdCrKNIRRBQFFAQrRbByVOxH+elBsZdjoYigqKhBsYFIPAQbSFU6QuhNOiQQUuf3xyaRspsESHazyf25Lq6EmdmZd1kJt+/M87yGaZqIiIiIiPeyeHoAIiIiInJxFOhEREREvJwCnYiIiIiXU6ATERER8XIKdCIiIiJezsfTA/C0yMhIs2bNmp4eRqk7ceIEQUFBnh6GnCd9bt5Ln5130ufmnSrS57Z8+fKDpmlGnb29wge6mjVrsmzZMk8Po9QlJyfTqVMnTw9DzpM+N++lz8476XPzThXpczMMY7uz7brlKiIiIuLlFOhEREREvJwCnYiIiIiXU6ATERER8XIKdCIiIiJeToFORERExMsp0ImIiIh4OQU6ERERES+nQCciIiLi5RToRERERLycAp2IiIiIl1OgExEREfFyCnQiIiIiXk6BTkRERMTLKdCJiIiIeDkFOhEREREvp0AnIiIi4uUU6ERERES8nAKdiIiIiJdToBMRERHxcgp0IiIiIl7Ox9MDEBERz9l/Yj+3zr6V/239Hxk5GZ4eTtmw0NMDKD4/qx9danVh2rXTqBxU2dPDEQ/SDJ2ISAV26+xbmbt5rsKcl8rIyWDu5rncOvtWTw9FPEyBTkSkAvvf1v95eghSAvQ5igKdiEgFppm58kGfoyjQiYiIiHg5FUWIiMgZzKdMTw/BY5KTk+nUqZOnh1EkY5zh6SFIGaMZOhEREREvp0AnIiIi4uUU6ERERES8nAKdiIiIiJdToBMRERHxcgp0IiIiIl5OgU5ERETEyynQiYiIiHg5BToRERERL6dAJyIiIuLlFOhEREREvJwCnYiIiIiXU6ATERER8XIKdCIiIiJeToFORERExMsp0ImIiIh4OQU6ERERES+nQCciIiLi5RToRERERLycAp2IiIiIl1OgExEREfFyCnQiIiIiXk6BTkRERMTLKdCJiIiIeDkFOhEREREvp0AnIiIi4uUU6ERERES8nAKdiIiIiJdToBMRERHxcgp0IiIiIl5OgU5ERETEy/l4egAiIiIi5+tgWgaJy3exYe9xmttOcv/MlTSItTOgZVUqBft5enhu59FAZxhGf2AC0N00zS0X8Pow4FGgBRABJAGfmqa5okQHKiIiImXCnzuP8lbyZhZuPABARnYu8QnZzF69B/81+3h1/l90qh/F6E51aFotzMOjdR+333I1DCPMMIyxhmGkAJ8DtS/wPC2ArUAKMAAYnneu5YZhdCup8YqIiEjZMGPRNm6ctJj56/4mIzuXjOzcM/afytv2w7q/uXHSYmYs2uaJYXqEWwOdYRgjgCM4ZtUSgaMXcbofgUmmaU4yTfOoaZorTNMcAGwB5ufN3omIiEg5MGPRNv4zZz3pWTmYZuHHmiakZ+XwnznrK0yoc/cM3WFgpGma4aZpPpz3+/NmGMZYIAyY6GR3Yt7XgRc2RBERESlL/tx5lP/M2UB6Vm7RB58mPSuX/8zZwKpdFzN/5B3cGuhM00w0TXNSCZzqBuCoi+fu5ud9HVAC1xEREREPeyt5M6eycy7otaeyc3h7weYSHlHZ461tS1rguLXqzLK8r63cNBYREREpJQfTMli48UCRt1ldMU1YsPEAh9IySnZgZYzXBTrDMPKLKJzerjVNM39eVc/QiYiIeLnE5bsu+hxGCZ2nLPO6QMcFVsWKiIiI99mw9/g51aynyz5+gOlvvUxuxkmXx5zKzmXDvtTSGF6ZUSEbC+dV244AiI6OJjk52bMDcoO0tLQK8T7LG31u3subPztvHXdJ0OdW9jS3nSQ+IdvpvoN7dvDmlHGsT0/niQF7qVwtnpMZzo+1++whObn8FkdUyECXV5gxCaBVq1Zmp06dPDsgN0hOTqYivM/yRp+b9/Kaz27huZu8YtylRJ9b2XP/zJXMXr3nnO1xJzey4r1/Exwayn+eGU/1LleTmZ3Dd7/sYMXWI+cc3695FW7p1MwdQ/YIb7zlml8MEVHEceU3houIiFQQDWLt+PmcGVdS//iexW+PJbZGTfpP+JRvjlYlMzsXXx8rvVtVOecc/j4WGsSEuGvIHuGNgS6/GKKooofzXkpMREREPC8lJYXRo0djt9u5+6pWnDp1CgDTzOXIwukcnvdfEi7tyGVjJzF37TH8rGDmlcGGB/mecz4T6N+yqjvfgtt53S1X0zSPGoYBLoojTquCTXLboERERKREzJ07l/79+5OVlUVWVhYAJ7csI6BmSw59/wYn1y8kuFlvqgx8mJ82HKFdvUgGxB7DsFkBOHIi84zzGQZ0rh9FpWA/t78Xd/K6QJcnCehmGEYL0zRXnLUvfx3XT908JhEREbkIKSkp9O/fn5Mnz6xYPfbrTFKXzCZj9zrCugzD3uoa1u1KpWezGHo0i8W6/Ti5QGZ2DnOWnfm8nb+PldGd67jxXXhGmb/lahjGhLylvk6Xv+TXSCcvGQCscBL0REREpAx7+eWXC2blTpe1fwsZe9ZTqe/DhLa+lrw7dRw4luGYkTPhcFoGn51VEBFgs/B47wY0qVr+W9N6eoau9mlfz3nmzTCMbsDYvO+T8kOaaZqJhmFMAkYYhjHfNM3EvGPG4lghoqU7Bi8iIiIlZ8aMGU4DHYAtqiaBtVo4npUzTQyLhRVbj7Bi6xEeSMjm5eS1BccahmNm7vHeDRjSvqabRu9Zbg90hmFMwHFb9PRn4OYbhrEC2GKa5ulrsC4D8kPcGTNupmmONAxjOTDSMIzJOIolVgC1TlstQkRERLxEWlpawfcNW7Zh85o/CY+Kpu/Dr5C03ULWiWMcmfcmQQ06Et7oMgwcTYPz+ftYMHE8Mze6c50KMTOXz+2BzjTNh8/j2KMUMtt2ej85ERER8W7BwcGkpqZS65IENqxYSp2EZlz56Ft8++dhYir5waZEdm/4BZ89q/jtw3+TuHwXG/alYvfZQ7/mVWgQE0L/llXLfQGEM56+5SoiIiICwODBg5k8eTJb162mdbcrSbj5Kb7+4xD1qoRwa+faHG9zH8vnfM7QoUOpFOzHyCviAUhOPlqumwYXR5kvihAREZHy4/QecxaLBbvdzujRo1mzZg1btmwhNzeXXjcPp9rAJ/lx7SFa14lgePc6+PtaiYyNw2azMWbMGE+/jTJHM3QiIiLiFs56zKWmpjJ58mQmTpyIaZrcMfIuNsdfw7qUI/RsFkuPZjEFVa2H9+0lMTGR+Ph4T76NMkmBTkREREqdqx5zANnZ2QD4h8ewpfa17DycwcD2cbRrEF1wTE5WJs3jImldr5XbxuxNFOhERESk1LnqMZfPFlmDyIHj2HHoBO/fcSk1o4NYezCV9OxcAnwsNIqJonpooBtH7F0U6ERERKTUFdZjzr9GU6L6PUZu5ikOf/4EHSesBlCAOw8KdCIiIlLqTu8xV6N+Q7ZvXE/DVm25dMTTJG3OIvPgDvZ//jTmicMeHKX3UpWriIiIlLrg4GAAoqvVYPvG9Vx+9XVcNuZNklJyiI8JptaBheSkHiw4Ts6PAp2IiIiUuoEDB2IYBn/v3M51o8YQe81D/LBqP63iIxjZsx5D738Qm83G0KFDPT1Ur6RAJyIiIiXCVY+5n3/+mV9++QXTNBn2f6+Q1rAfv286RPemMQy6vAY+Vot6zF0kPUMnIiIiF62wHnPvvvsuAQEBPPbMBOYbl3Bwz3Fu6FCdtvUiC16vHnMXR4FORERELkpxesxZwqvyg9mU1FO53N65BpfUqFRwjHrMXTwFOhEREbkoRfWY86/RlPB+j3E8NY0v7u9GSJBNPeZKmAKdiIiIXJTCeswFNe5CpSvvJevwLv6e+xKNXtgKqMdcSVOgExERkYtyeo+5SjFVOLRvDz0G3ULkFUP5desp0rf9wYEvx2Nkn/LgKMs3VbmKiIjIRcnvHRcSFs7hv/dy88PjsHcZya9bT9Gipp26J1ZgZp5Uj7lSpEAnIiIiF+Wqq64C4FT6Se5/7T32VunE0s2H6dEshps6xTNkzMPqMVfKFOhERESkSK56zH300UfMmTMHgIcmJ7IovTqb96Zy42U1uLJ5FQzDUI85N9AzdCIiIlIoVz3mJk2axDvvvEO1atV4ZMJ/+WizlezcTIZ3r0P9OHvB69VjrvQp0ImIiIhLhfWYy8nJAeB4UFU+2B1JoK+FEZ1qUrXyP2FOPebcQ4FOREREXCqqx1xw056E9hiN7dRR5jzUjwwzVz3mPECBTkRERFxy3WPOIKzjUELbDyQ9ZRlHF7xN9IuDAPWY8wQFOhEREXHp9B5zAUHBZGVmMPLZV9ji24B1+zJIXTmXw/PfwWJ4cJCiKlcRERFxLb93nI+vL1abjUemfMY6WwLr9mXQs2kUDW27wcxVjzkPU6ATERERl9q2bQtARFQ0D78/m3m7g9l+4ARDr6hJzxbVGPKvR9VjrgzQLVcREZEKLiUlhZdffpkZM2aQlpZGcHAwN910E4GBgSQlJWGxWLh74pfMXHqQXNNkVM+61I5xzMipx1zZoEAnIiJSgbnqMTdx4kRM06Rz5850Gno/03/dR2iQH8O7x1M51L/g9eoxVzYo0ImIiFRQhfWYM00TgD8zoti60Uq9ygHc2LEGoSH/hDn1mCs7FOhEREQqqEJ7zBkWIrqNJKTFVcRk7eWre25j/8kM9ZgroxToREREKihXPeYM3wAi+44lML41xxZ/zpGVs/F/eRjVQwMV4MooBToREZEKKr/HXP1mrUhZu4rI2CoMffJFvlx9gky/cA59/yZpf87DYlFTjLJOn5CIiEgFFRQURPW6Ddj4xzLqNW3B/ZO+YN4eO5aQykTt+IG0P+cBqMecF9AMnYiInMEYV8Fb/i/09ADc49SpU8TGxrJp0wY6XTuQznc+ydRfdhJgs3LPVfXwSa/E8k/fUo85L6EZOhERkXIqJSWF0aNHY7fbsVgs2O12Ro8ezZIlS+jWrRubNm1i0H0P0+KWx5iWvJ3IED/uu7o+VSICiYyNA1CPOS+hGToREREv52f1O2ebq/5ykydP5t1338Vms/HJzE/5/lR1Zi3exSXV7Ay9ohZ+NisAh/btITAwUD3mvIQCnYiIiJfrUqvLGb8vrL9cdnY2ABabP98cjubX7Ye4vGEU17SpisXiuN2ekZ7O/lVLWbVqlcKcl1CgExER8VJ+Vj+61OrCtGunnbG90P5ygDUonPD+/+bXbak83bcRXRpHn9FfrlWtGAY1G13Ko5eSpEAnIlKBmU+Znh5CmZKcnEynTp08PYyL5qq/HIAtsgaVBzyFxT+EtLkvceuEZAD1l/NyCnQiIiLlTH5/OQC/gEAyT6XT9/Y7qdPtBmYtP0zWyVT2ffQwOQe3eW6QUqIU6ERERMqZoKCgglBnj6jEvRPe4Ghwbb5YvJOYSiGwKZHd+7dgt9s9PFIpKWpbIiIi4kVctSJJSUkBYPXq1fj5OapeL+3Vl+dnzWdNRiyJi3bSIM7OPX0acMu996m/XDmjGToREREv4aoVyZQpU5g2bRqDBg1ixowZhISE4Ovry3WPvMjbSTs4lJpBl4RoerWogtVi4Bsbp/5y5Yxm6ERERLzA6a1Izi54yMrKIj09nalTp9KpUydWr1nLHa99wX/nbiLHNBndqy59WsVhzWtLcnjfXvWXK2c0QyciIuIFimpFAmC1Womp25SRiZtYtQuuqBNG1xaxBAcFFByTk5VJ87hIWtdrVdpDFjdSoBMREfEChbUiyRfQpCfJfu2IOHySd25qQa+EWHYcO3lGj7lGMVFqUVIOKdCJiIh4gdNbkZzNGhxBpV73EVC7JelbljPvqbFUtvsDjv5yCnDlnwKdiIiIFzi9FQlAQvvLueOJZ9l6zODr5fvJNuHQvLewbPmVyvZ/e3Ck4gkqihAREfGwolqRLFmyhODgYAACQ+w8+u4HPDzxY37ebWP2n8epUjmMKlu/IWNtklqRVFCaoRMREfGgwlqRvP/++7Rv354FCxYQGRmJr68vExLnsiMjhOe/WMuJU9n0aBZD96axHGo1mtXzPlcrkgpKgU5ERMRDTm9Fcrb8gLdgwQJGjRrFhAkTmPrtz3z8xyn2HD5CzagghnWLp1pkEABRsXFqRVKBKdCJiIh4SHFakfj4+JBuDeah2X/x/VqT8KBshl5Rk2a1wjEMo+A4Xwv06tWrtIcsZZQCnYiIiIcU1YrE8A0guP0N/M//UoI2HeDBHvXo2SSGdYfTyDH/Oc5qQNPocDeMWMoqBToREREPObsVSUR0LDc/9AR1mrZgyvTZHAxLwBoUxonVSSz55Dmi81qR+NmsZ/aWiwxRa5IKTlWuIiIipaCoytW9e/fi4+OYV7H62Bg85hHe+uFXYlp0Y8bykxyJu5wATrF3+v1k/jK1IMyBo7dcr/horqsfS6/4aIU50QydiIhISSuscnXatGn069eP2bNnk5OTg8Vi4fnPviM4rg4f/rybtTuPER7sy82dahFri+S+idsZOmKEh9+RlHUKdCIiIiWoOJWrH3/8Mb179+aBBx6g74DBrDxmZ9GSddisFnq3qMIVjSpj87GQmxuKzWZTKxIpkgKdiIhICSpO5arVaqV6rXg2WWtQ7c73+G3DQdrVj+TK5rGEBNgKjju8b69akUixKNCJiIiUoKIqVwH86nXg29zmzJ27gc71o7j6Ejs5QQFYbf+EuZysTJrHRdK6XqvSHrKUAwp0IiIiJejsytXg0DAG3vUvmnfswgfvfchO/7r4VWlA5v6tfDKmLZfVjQRgx7GTZ1auxkSp2EGKTVWuIiIixVBU1SrAvn37CipXLVYr/YbfzTs//k7ba4cyfyvsr301AVHVODjnNU588URBmANVrsrF0QydiIhIEQqrWp0+fToffPABf/zxB6+88kpB5er4md9QpV5j5v+5j1/WH8BqMejZLJZGEVk8+OZCRqhyVUqQAp2IiEghilO12r9/fwBuuOEGhg8fTt9+17M9N5r3E9eSkZlD67qV6NUiltBAX3Jzc1W5KiVOgU5ERKQQxalaNQyD/v3789HHnzBrxS7qjfmIOSv20rCqnataxlElIqDgWFWuSmlQoBMRESlEcapWTdPkfxv20+v1n/jr7zSaVg3lvoRwgioFY7X5FhynylUpLQp0IiIihTi9ajUkPILUI4eJrlaDPrcMZ8OKpSxduZ7wTrfhXz2BzOxc3hrcgt4JMRiGocpVcRsFOhERqbBSUlJ4+eWXmTFjBmlpabz88st89tlnPPDAAwW3RAMCAgqen7P5+jJy3At0ue4GjpzMYV/M5cQmpJJz4ignf3qf+T9/hs36TwOJ6qGBCnDiFgp0IiJSITmrXM3NzS2oXJ0wYQLz5s0rCHP9R9/P9SPvJSPXylfL9rJo40F8rBY61A4kccwght928xlhTsSdFOhERKTCKU7l6j333IPdbueBBx7g7bff5urh95O05gA/rTtAdk4u7epH0qNpLMH+VmaTo6pV8SgFOhERqXBcVa7OnDmz4HuLxcLAgQP5v/HPk1W3C+MT13Iq26R57XCubBZLVKg/AAf37FbVqnicAp2IiFQ4ripX//jjj4Lvcw0LX607ysoXFnAwzaRltRA6NqlMtcqhBceoalXKCgU6ERGpcE6vXDUMA4vVStf+g7muZ1c+TJzNHztSCeswGJ/QytSpHMzEoQ1oWSNcVatSZinQiYhIuXF21WpwcDBDhgw5o2p127Zt+Pj4kJWVhWEYdLl+EP1H3U9klTjWLF3NqfajiGycScaev0hfOIVP1v6CYRiAqlal7FI5joiIlAtz586lSZMmTJkyhdTUVEzTLFhvtUmTJkydOpVhw4ZRt27dgvVWn/34K0Y98yIHc0N49esNTFubjY/VwnXN7Bya+TCDujQvCHMiZZlm6ERExOsVp2r1jjvuwNfXlzvvvJMbbriBnj17khtZh9e/28iOAyeJCPZlSEMrzdo0BEwmar1V8SIKdCIi4vWKs96qxWJh0KBBvPHGGyz86wCtH/uMKUlbCA/yZcCl1WldJwLfnevItRgc3LNHlaviVRToRETE6xVnvdXc3Fy+WZbCde/8xsodR4kLC2DEpWHUqhGOn79/wXGqXBVvpEAnIiJe7/SqVQBff3+63zCUy/v045tpk1i+djuhlw3GP64h+49nML5fAv1bVsXXx3JG5aoFg7bVVLkq3keBTkREyqyiqlZN02TevHlYLBZycnLwsdnoe8co+t4yguCwcP7ak4rlinuIbpxO9vH9nFg4hQU/z8LXx/l6q8l7NyrMiVdSoBMRkTLJ2Vqr+VWr06ZN47777mPevHmsXLmSoKAg0tPTefHLH6gWX4+Ne1L54be/2Lb/BGFBNno2DOb9Owcw4o7bzwhzIuWFAp2IiJQ5xalaff7556lduzZTp06lXbt2tGrVmsPWKBK/2cCuQ+mEBdq4vn012tathMWAGRZDVatSbinQiYhImVOcqlWr1UrPnj0ZcvMtzF65m4SHP+WD5G1EhvgxsEN1WsVH4GN1zMZpvVUp7xToRESkzClW1aphJfHPA/z5YjK7j6bTMNbOjW3sxFYJxebnV3CcqlalIlCgExERtynO0lz5KzzkMwyDVl16cP3IewmtFMmHr73EmgNgb9UXa1A4MaH+PHttYzrVj8IwDK23KhWSAp2IiLhFYUUO06dPZ+bMmZw4cYJXX3214DVV4+sy9q2pxNWMJzU9i5/X7edg09sIz8olfctysld9R+L6xWcsz6X1VqUiUqATEZFSV5wih2uuuQbTNKlbty6XX345ixYt4vFJMzCCo5i1aAdLNh0iO8ekSc0wmsfA+FeeZcSIEVprVQQFOhERcYPiFDkA9O7dm2+++YYtW7bQqteNfLM+g3U712GxGLSMj6Bz42iiw/zJzc3FprVWRQoo0ImISKkrTpGDaZr88tsivlm1lyk/7yPs+nFs2ZdKt6YxdGgQhT3QVnDs4X17VbUqchp1VxQRkQuWkpLC6NGjsdvtWCwW7HY7o0ePJiUl5YzjTi9yALBHVOL6Uffx/GffcdlV12L4BWFvcx0hg17hvpl/cCIzm//0a8zkQQ3okRB5RpjLr1rt1auXW96jiDfQDJ2IiFyQooocPv/8c4KDg3nnnXcKXhNaKZJbHv43HXpdg4/NxqHUDKpd9xA1Gt6MafUla/da3runF53rV8ZicTwbp6pVkaIp0ImIyHkrTpFDnz59ME2TsLAwEhISWL9+Pc9/9h1RVaqy5e80flm/k1Xbj2IAl1QNIfnFu7nt2m50bRh9xvlUtSpSNAU6ERE5b8UtcujcuTPffvste/fupWnLNmw85se0JevZd/QUAb5WOjeO5rKGUdgDfEh+bKeKHEQukJ6hExGRAsV9Jq64RQ7Lly9n5/Ecpq1OJ+6uD/jy9134WA1u6FCdp25IoE+rOMKCfFXkIHKRNEMnIiJA0c/EJSYm0qtXL7Kzs88pcoirXYfuNwyhcdsOzJ78Fr/M/ZbAeu0JaHEVPV/7CV8fC32axtGqii8+oYH4+GppLpGS5LFAZxhGGPAo0AKIAJKAT03TXHEer/8877dHz9odlvd1gmmaSSUwXBGRcq04z8Rdd911DB06lG+++aZgX5Watbnr+ddo0MwRxo6eyKTODQ+zu/5gcm2B5Bzfz6O9GjCgVTUignwBFTmIlAaPBDrDMFoAPwIPA88BtXGEu+WGYXQ/jxDWrYj9Ey98lCIiFUdxnok7deoU7733HldffTUZGRkkJSXx5HufEBlblfW7jrF440HW7jyGaULt2DCWTHqSm3u0YuQVt51xHhU5iJQ8T83Q/QhMMk1zUt7vVwADDMNIAeYbhhFumubZs26utMQxwwf/zMzlK9Zsn4hIRVecZ+IAAgMDmT17NikpKTTv2JMlewyW/bKG4yezCPLzoVPjaNrXjyQ8yMbip1bzrzEfuWH0IuL2QGcYxlgcwcvZ7FkiMBYYCExysv8cxb1FKyJS0aSkpPDyyy8zY8YM0tLSCA4OZsiQITzwwAPnFB+c/UycK+lZJp8u3cHny/4mYujrLFizn4ZV7bRuW5VG1ULxsTpq7Q7u2a0iBxE38sQM3Q3AUdM0tzjZNx9HoBtA8QJdcWfxREQqlOIUOPTo0YOFCxfy6aefYhgGpmkCEFWlKtePuo+OV1/PsUMHmPHKcyxbtZnghG4ENbiMh2etJj4qiEd6NaB2aC7HfHyx2nwLrq0iBxH380Sga4HrW6HL8r4W96fA4YsfjohI+VKcAoe+ffsSGhrKoUOHCAoKIj4+nq1bt9Kme2/ufu5V/AMCOZKWyR8HfDjZdhQxjbPIzThJDfbz2ugbaV4tDMPQSg4iZYVbA51hGLXzvnUaxEzTPJr3A+LsZ+GciTjtnBNwBMXaOMLixNOez6vYTu2HRbfScW8SfFz08zHlnsUPortA+2ngX9nToxEpFcUpcMjOziYsLIx3332X3r17s3fvXpo0acKA+x/jj50nWbllN5v3pmICdWNDuLSWP+/fNYQFK5YRXz38jHOpyEHE89zdWLh20Yec9/lS8r5uwXELtgUw0TCM+SV8Le+06FbYOxcLCnMA5GbA3rmOPxcRL1Lchr9Q/AKHAwcO0L9/f7ItNv446kenpz7jzeRDfPbrDo6eyKR7sxge79+IUVfWpXPLeBJnfqxn4kTKKCP/mQm3XMwwuuF4Ti7JNM3uLo4xAUzTNIo4VwtgMjDg9OfxDMOYgOM5PICRzmbqDMMYAYwAiI6Objlz5swLeDfeoeOeHgpzTuRi46cqP3h6GEXKf5BdvE9JfnbHjx8nJSUF0zQ5/We2YRgYhkF8fDx2u519+/axaNEi5s2bx+bNm8nJycE/IIDmLVvRpv2ltGjZivTUY6QdO0qWabA1I5j9AdVZfSCHbBMq+Rs0q2zQrLKFqsFGwS1VAAMI9bOVyPspy/R3zjtVpM+tc+fOy03TPOfRNDc4qdsAACAASURBVK8NdEVcZz6OHnUur5OvVatW5rJlywo7xLt9fMF/jOXfYPf9t3+hkpOT6dSpk6eHIRegpD67lJQUmjRp4vR5uHw+Pj7UqlWLTZs2ARQUODRu24GH3pxCsD0UgMzsXFZtOcCXc37mRGAVLDZ/ou1+9E6I5eqmVWheLYydx9NZ+fcxck7762E1oHl0aIW4raq/c96pIn1uhmE4DXTuvuWaP5MWUehRF1+9OiHva0nf4hURuWjnc/u0uM/DnTx5kldeeYWNGzdy5513YrPZuGv8K9gCglm1/Sgf/bSNpz5Zxce/7saIjCd97QLan1zMoke68tTVjWhRPRzDMKgeGkjz6FACfBz/PAT4WCpMmBPxZu6ucs0vhiiq6MFZS5Pzkf96tTVxxgtmpkqcZiqljCjueqn5Pvzww2I9D5eamsqYMWMAGDLyXj5dsY8v15xi875V5OSaBPhaaVYrnOa1w6lVOYjbXxnAs2+twmI59++GihxEvI9bA91pVaxOZ85Oq4K92PVX8wOj1nEVkTKjOO1Err/+et588002btzIggULSEtLKzgmNCKSy6/uR7seVxEeVZlPXn+BX76bDRhkhsTx0ryNJK3/mw37UgnpdAcHjp7ksoZRNKoWSq3oYKx54U1Nf0XKH0/0oUsCuhmG0cLJKg/5a7N+WtgJ8gofJrpoTgz/9LF77sKHKSJSuMJWYnCmOLdP09PTGTZsGDabjXbt2uHr60tmZiaXXnk1d+X1hwPIyMqh451PcTjuco77VsYaFM47C1NoWSOcx3o3oGvDaA4fOci2TENNf0UqAE8Euok4gtvIvF+nGwCsODvo5QW4Q6ZpvpC36dO885xT8GAYRhiOZ+gGnMd6sCIi56WoW6effPLJOa8p7u3TwMBADhw4QGBgIKNHj2bKlCkMefBxDqXD5i1/s3F3Kpv2ppKTa+IX1YCMNT/RoWYI749/iLDAf8JbfFQw0Wr6K1IhuD3QmaaZaBjGJGCEYRjzTdNMhII1XlsBLU8/Pq8ydmze90mmaa4wTXOFYRi1DcP4HEewW4aj0CI/KA4wTVO3W0WkWM5nzdP844u6dZqSksKvv/7KgQMHWLp0KUuXLj3j9mlhTp06RUBAAJv3p1Gn1+1U2l+JN386wsmMgwBE2f24rGEUl1QLpWZUILe3GcBLq1adEeby6Xk4kYrBEzN0mKY50jCM5cBIwzAm4yiWWAHUcjKrtixvH2fN3D0MPIqjDcrRvOPmm6bZEhGRYjrfIgUo3q3Tp59+muPHjwNgtVpJSEjAZrMVvK5Dr74MefBxImPjOLh3NzNeeY7ff1mEf42mBMe3pM34HzmQmgFAbKN2VK1ko1F8VerEhBAe/E9w0/NwIgIeCnQAeQ1/i1yeKy/gnRPS8mb2EkthaCJSQRRnpq1///6sWrWqIDAdOXKE6dOnFxno6tSpw9q1a1mwYAHNmjUjICCg4PZp2x5XceczL5Ke68OKLUfYtDeHtDZ3Etd4GAB+uRm0r12JS+Mr0T6+EtUjAlm2abuehxMRlzwW6EREPK04M22nTp2iX79+REZGsn79evbt23fG/iC7nYYt21K/eSsiq1Tl9x/msPiH7xg8eDBjx46lffv2ABw9mUnHgSP5fF0avp2G8txXKaSdygYg0M9KnZgQWgdk8+kTw1mRPIc6deqccZ3W9WrqeTgRcUmBTkTKhfN9Dg6Kt+Zpbm4uq1evpm3btlx55ZVccsklPPXUU6Snp9Oh9zWM/s/LBZWnAG269sTi68/erAAqXdqfez9ZyZ+7jrL9kGMWMLjdDaRlGTSsaqd6ZBA1KwcRGxGAxTAwc3O5bvLr54S5fHoeTkRcUaATEa93vs/BpaamsnDhQlJTU4t1fsMwWLx4ccHvt27d6qg8feAxDB8/dh48we7D6ew4cJKdB0+wp/FtJB6FwA43s3TbYZpWDePG1tVpWi2UhLhQkrfvJ8vJQj2+Fs55Xk9EpDgU6ETEqxW3We97773Hhg0bSEpKYsmSJWRnZ59xbNMOVzDiqeeoXLU6B/fu5qNXnstr2gshISEcP5XF5v1pbP47jaAOQ6l0OJaJvx7lyIkDBefw97VSPTKQLo2jCdixgqFXdaRtkwbnjKtpTLjT9VKbRoeX0J+KiFQ0CnQi4tWK26x38ODBWCwWWrVqxdixY+natSszZ85k2rRptO1xFaOefQn/gEBOZGST5hNOy1uf4EhMOw6mZRNWvQFNnv6h4Hy+PhbiG7XAHmKlXb1IosP8iQkPINLuh8UwOLhnNzEhMU7DHFBw2/SM5+EiQ3Q7VUQumAKdiHi14jwHBxAQEMCePXsIC/tnKekaNWrw8ayvaTF4DF+vOMBfe1I5nJZZsN8W3RhrzmYur1+ZFvFVqFs5mDqVg6kWEYjVYrD0r20uK09P7Cm855yehxORkqRAJyJerbjPwWVkZBAWFsaprByWbjvML5sP8uvmg0QNf4+vVqXi72ulTkwwHRpEERPuT3SYP6EBPgRvt9Cr1+VOz1lY5Wnynm0l+C5FRAqnQCciZUpxq1X37t3L5MmTMQwD0/znYbS23Xtx6yNPn9aw93mWLl9DWP22DJ68mGXbj5CZnYvNatCiejgP9KiH6WsSU+mfxevz2cgtskhBM20iUhYo0IlImVFUternn39OSEgIb731FrNmzSI7O5tq1aqxZ88ecnJyuOyqaxn17EucyLay+K9D/LUni0MthhPbOBeAIyezuKV9DTrUiaRNrQgCfR0/AnccO6kiBRHxagp0IlImFKdatU+fPpimSVhYGPfccw+jRo3CYrHQpEkTTqafovWQfzHtp938tcdxGzYsyEZCjXBiA7IY2qQyrRrXd3rtoooU0tNh+XJYvRpWrYI1axzfHztW2Dvq5HJPpUpw6aXQoQO0bw+tWkGgJvlE5CIo0IlImVCcalXTNOncuTPffvstgXkJ6PCJTIa/8jmz/vybL/44TligjV4tYmlWM5xIux+GYYBp0qpBlULPXT00kGr2QJYvh/ffh+vfdwS50nDoEHzzjeOXM3FxcO+9MGwYRESUzhhEpHxRoBORMqG41arLly8nMDCQVbuOMv237Xyzag+Z2SYt69fkkhohNK9f5Zxn4QJsVqfn2rwZxo93BLiyZPduePhhx698Xbs6Ql7v3uCjn9wichb9WBCRMiEtrfA2HwBYfcit3opr3/qVP3YeJcjXyg2tqjG0fQ3qRYe4fBauUWQIAKYJn34Ko0bB0aOl9EZKyY8/On7l69gRpkyBunU9NyYRKTsU6ETE47KysvD19SUjI6NgW5tuV3Lbo+OIjI1jy9YdfJj4P44G1cQaFMbxU1mM69uI61rEEeJvK3iNs2fhqvqE8PK/A3njDbe/rVL1009Qr57j+yZNYPp0aNbMs2MSEc9RoBMRjzFNkzlz5vDggw+SkZFR0ILksquu5c5nXmTXsVy+W7CVNTuPQXQzQo5vJyH9L2b+62nHs3FOVA8NJC44kCeegOefL93xR0Q4wlTjxo7n3oKDISsLMjNhw4atxMXVIjMTMjIgLQ127ICVKx3P0JWkVaugeXPH99WrO2Yh27Ur2WuISNmmQCcipaKofnJr1qzhX//6F/Pnz6devXpMnDiR+++/n/T0dHoMf4jpP+/hrz2pBPlZ6dw4mksbRJJ7PJqu1cNdhrlNm+CKK2Dv3pJ5Dw0bwm23waBBULXq+b02OXk7nTrVKtaxR47A77/D99/DRx/BwYMXMNg8O3Y4KmfBcWv5jTf0zJ1IRaC/5iJS4grrJzdt2jQ6derEvHnzsNvtvPrqq4wePRpfX1/Coqtyz8Tvmbr4CP42K9e2qUr7+pHYfCyOEwdVIT7+zGpV04RXXoEHH7y4MXfuDHfcAf36ub+FSHg4XHml49drr/2zfelSePNN+PDDCzvvO+84fjVsCAsWQHR0yYxXRMoei6cHICLly+n95M6uWs3KyiI9PZ25c+cyZMgQNm/ezP333w8WHyb/tIVnVloJatqTdrXtPNa/ER0bVf4nzHFmtWpamqMwwGK5sDAXEwNffgm5uY5Q+L//wU03la1+cK1bwwcfOMZnmpCaCuPGnf951q93vF/DcDx7JyLljwKdiJSo4vST8/HxISQkhIiICH5Yu48ery7kP3PW06pGOD+M6ciEgS2x+595AyG/WjUzEzp1gpAQ+Pnn8xvbddfB1q2OcLR3L1x7rSPkeIvgYPj3vx3jz8mBd989/3NccYXjPc+YUfLjExHPUaATkRJVnH5y2dnZfDxnIYMn/86ID5fjY7Uw7bbWvH9bG+pUdqzQ0Dw6lIC82bkAHwtNo0J58t5A/Pxg4cLij2fQIMeKDqYJs2ZBzZoX8ebKEIsFRo50vK/cXPjkk/N7/dChjmD322+lMz4RcS89QyciJcpZP7mrbxvJTWMe5ciBv/ng9dfYmFGJ4KY9WL/vOP93TSMGt6mOj/XM/7/MX/TeNOGpp6D3M+c3jjlzoFevi3kn3sMw4MYbHb+ysx0NiN95p3iv7dDB8XXvXsdtWRHxTpqhE5ESFRwcXPC9xWrl/pfe4taHn8Kw+rDmsI1DCUMJadqDjFXfs/DBztzcvuY5YS7fRx85ZqKeKWaY69HDUTFqmhUnzJ3NxwfeftvxZ3A+s3axsY71ZTMzS29sIlJ6FOhEpER1yJ/yAR7+71Qu79OPtTuPMeHLdXy7bA/xscGMuDyS/vEGoYE2p+c4eNAx6zRkSPGu+cYbjtuO8+ZBWFhJvIvy4cYbHcFu3ToICCj6+EWLwM8Pnnyy9McmIiVLgU5ESoRpmkyYMIF58+ZhsTh+tDTv2IXvV+7hvaQUbFYLI3vUYVi3OtSPr86YMWOcnue55yAqqnjXfOEFR2C55x7vKm5wt4YN4eRJx+xlnTpFH//ss44/z61bS39sIlIyFOhE5KJlZGRw66238sgjjzBw4EBmzZpFYEgoU3/YwA9/7KN1nQj+1bcB9ePsAFhysomPjz/jHPmzco89VvT17rnHMSP30EOl8W7Kr7AwR/PlbduKd3zt2o6qWhEp+xToROSi7N+/n65du/LBBx8wbtw4PvnkEy7tciWXPzWL9ftOcWXTytx4WY2C5+QMTFpWO3MKrrizcldf7Vha6403NCN3MWrUcMxsJiUVfewzzzj+rI8fL/1xiciFU6ATkSKlpKQwevRo7HY7FosFu93O6NGjmTNnDm3atGH58uV8+umn/Pvf/2bd3uNc89avbD+axcShrXisdyMC8xoCB/hYaBkTRvVQR/feY8eKNysXHOw49uuvtYxVSera1RHsJkwo+tjQUMcasSJSNinQiUih5s6dS5MmTZgyZQqpqamYpklqaiqTJk3iqquuIjU1lZ9++omBAwfyw9p9DHh3EQCf39meno1iqB4aSK/4aK6rH0uv+OiCMJecXLwChtmzHSsk2O2l+CYruLFjHTOfrVsXftyNN0KtWo6mxiJStijQiYhLhS3jlZP3r/rJkycJDw/n3YUpjJyxnLqVg/nqrg40jgt1ed5nn3WsnVqY2FjIyIBrrrnotyHF4OMDS5YUvTTYtm2OY3fudMuwRKSYdPNCRFwqzjJeORjc+s6P7LJV5aomsbw8oCn+p625erZWrWD58sKv+9VX0LfvhYxYLtbllzt60cXGwqFDro+rXt0R/i6/3H1jExHXNEMnIi4VtYyXJcBOxHVPsctWlfu61uW/g5q7DHPp6Y7n5QoLczExjlk5hTnPstkcVcdTpxZ+XMeOMHGie8YkIoVToBMRl5wt45XPVqkaMTe/gl9sPQ5+8yJjutfDcFF6+tdfEBhY+LXefdex/JSv78WMWErSbbcVPksHcOedMHy4e8YjIq4p0ImIS6cv4wVw7bDRfL5uFw99+jNxt72OxcePfR8/gnXXSpfnmDcP6tcv/DqrVjkWmpeyJyLCUQlb2KodU6ZA3bqO40TEMxToRMSlIUOGFKz60G3AYG7612P8uuEgn688RkylEKru/h7z4FaGDh3q9PWffQZXXln4NY4fh4SEkh65lLQPP4Rp01zv37zZse5uEY9cikgpUaATEZeaNWtGbm4uCe0uY8RTz5O8dj9f/r6LS6qGcm+fBtxyz73YbDany3glJsINN7g+d506jtUeQkJK8Q1IibrlFvj998KP8fWFU6fcMx4R+YcCnYg4tXTpUsaMGUPdunV5+L9TWbXjON8u20OzWuHc1qU2fjYrUbFxJCYmnrOM16xZMGCA63OPHetYgkqrPXifNm1gz57CjwkIgOxs94xHRBwU6ETkHFu2bKFPnz5ER0fz888/sz8tl49/3k7t6GAGXVYDi8WRxHwt0KtXrzNe+8UX0L+/63N/8UXxViaQsis2tuhZOJtNz9SJuJMCnUgF5mxJr9tvv51u3bqRnZ3N3LlzSTWCmLpgG5VCfLmta21sPo4fG1YDmsaEn3G+2bPh+utdX2/BAujXrzTfkbiLn5/jlnmlSq6PsVgU6kTcRY2FRSqouXPn0r9/f7Kysgp6zaWmpjJt2jRM0+TFF18kokpN+r39K34+Ft4Y3Jwj2dmkZ+cS4GOhUWRIwTJeAN99V3hYW7AAOnUq5TclbmUYjn519es7WtM4ExIChXS/EZESokAnUgGdvqTX2cy8KZWnnhnPfJpzKC2LmSPa0bSa64VXV66EPn1cX+/HHxXmyrONGyE8HI4ePXffiRNQr57rwCciJUO3XEUqoCKX9DIshPS4h40H0nljUPNCw9yxY9CihetTJSVBly4XMVjxCocPu963aRP07u2+sYhURAp0IhVQUUt6RXQbgX98G07+PI3ul0S7PM40Icx11uOHH6Br14sZqXgLw3A8U+fK3Lnw0kvuG49IRaNAJ1IBFbakl71NP0Ja9OHY77M49PuXhZ6nbl3X+77+Grp3v9ARijcyjMLblTz0EKxe7b7xiFQkeoZOpAIKDg4mNTUVAKvVhyq14xn/yTcs3biXr1alcmL9TxxNnobd7rrr72OPQUqK830TJsDVV5fGyKWss1odLU38/Z3vb9LEsd/Pz73jEinvNEMnUgENGTIEHx8f/AICCAmP4MkpH7MvDb5dk0aNyADq56Zgs/m4XNJr/nx47jnn527b1tE4WCouPz84dMj1fldhT0QunAKdSAV09913k5ubS25uLo++M50c/3Cm/i+FSiG+DOtRlyFjxrpc0mv/fujRw/W5Fy8uxYGL14iIgEWLXO8fNsx9YxGpCBToRCoY0zQZP348ubm53Pv861Sp14j3klIwMBjevQ5Bfj4ul/QyTYh2XSOBky4oUoG1awePPup833vvwbx57h2PSHmmQCdSwYwfP56PPvqIZ555hst6XsX0BVs5nJbJbV1rUynE8WCTsyW9AEaMcH3e9esda3iKnG78eAgMdL7vyivh+HH3jkekvFKgE6lAEhMTeeKJJ7jpppt47LHHWLDqAJv2pjLw0urUjg4GnC/pBbB1K0yZ4vy8H3wADRqU5sjFmxUW2kJD3TcOkfJMgU6kHHK2Rmv//v0ZOnQo7du3Z8qUKXy4eAdfrdzD4HbV6dgwCoAAHwvNo0PPWNIrX+3azq/VujW4qJ0QARyVr64qogHef999YxEpr9S2RKSccbVG66xZszAMg7vvvpslO1IZ981aul8SzbN9G2OxGIWe8777XO9TEYQUR+3aMHEijBx57r7bb4ebbgJfX/ePS6S80AydSDly+hqtzlaCME2TO8c+zagZy6gfY+e1G5oVGeZ27oQ33nC+77ffwKKfIlJMI0a47j/XpIl7xyJS3uhHsUg5UtQarRb/EOx9xpJ1Kp0pt7QiyK/oSfrq1Z1vb9MG2re/0JFKReWqP93GjbBkiXvHIlKeKNCJlCOFrtFq8SGq32NYgytxcPZ44sKKLkkdP971vsJ6jIm4EhTkWEnEmbZtHa1xROT8KdCJlCPO1mjt2n8wn67ZwdWvfY9/9QQOzX2DYykrizxXdjY8/rjzfcnJutUqF66wlUTuvNN94xApT/QjWaQcCQ4OPuP33QYMZtQzL/LrxkOs2n2KzpdUonmtsHOOc6Z/f+fbGzaEK64oidFKReaq6nXSJPWmE7kQCnQi5ciQIUOw5E2dte95FSPHvcD6Xcf5eulumtQI46o21RnywGMu12jNl54OX33lfN+ff5b0qKUiql0b+vRxvq9xY/eORaQ8UKATKUcqV65Mbm4uAPe99DZb959g+oItxEUEMOjyGlgMg8iYKk7XaD2dqxm4J58Em62kRy0V1ddfO9++c6fr4gkRcU6BTqScmDp1KuPGjaNdu3YEBASwbtMupsxPITzYl+Hd6+BnswJgyck+Z43W0x09CkuXOt83blxpjFwqKsOAGTOc72vTxr1jEfF2CnQiXsTZChCjR4/mtddeY9iwYfTs2ZPk5GRmJy/lkyUHCfK3MurKuoQEOKbVDExaVosq9BoJCc63v/224x9gkZJ0003Ot2/Z4vifCxEpHq0UIeIlXK0AMWnSJHJyckhISOCLL75g57FMHp23h0h7EK/d1JxDWVmkZ+cS4GOhUWSI02W98u3eDbt2Od83alRpvCsR+OwzGDjw3O3t28P69e4fj4g3UqAT8QKnrwBxtpycHAA2b97M8o3beXDubiwWg4+Gt6NWZNB5XadRI+fbP/vsvIcsUmwDBjjfvmGDo+LVbnfveES8kW65iniBolaAAMj1D2XEJ2vIzM7lo2FtzzvMpabCsWPO97n6B1ekpLh6lq5jR/eOQ8RbKdCJeIFCV4AALEFhVOo/jhNZJh/e0ZZ60SHnfY1bb3W+/YcfzvtUIufN1bN0f/4JmZnuHYuIN1KgE/ECzlaAyGcJsBN9w3+wBkdwIPFpGseFXtA1vvjC+fbu3S/odCLnbepU59u1eoRI0RToRLzA2Ss7BIeG8cKs7/ngj220evwz/CrFsX/W/+F7fPcFnf/bb51vf/rpCzqdyAW57Tbn299/373jEPFGCnQiXuCmm24qWAEiLDKK1+cspGq9RryXtJWDJ3K4uVNN2jevX+QKEK5cfbXz7U8+eaEjFrkw993nfPvq1e4dh4i3UZWrSBmXm5tLRkZGwQoQz8z4En97BFOSUthx8AQ3d6pFk5rhxN33MF2rh5/3+V0VQlSrBhb9L5+42QsvwOuvn7v9qqtgxw73j0fEW+jHtUgZlp2dzS233ML7779P3759CQgIICgqjrfn/sXWv9MY3LEmTWo6QlxkbJVCV4BwZfBg59t//PFiRi5yYXx9nW/fuRNM071jEfEmCnQiHuZq9YfVq1fz+OOPM2PGDJ599llmz57ND78u57/fbeTvo6e4o1s8LWpHFJwnIG9pr/M1Z47z7XXrXtDpRC7aV1853+6qaEJEdMtVxKNcrf4wefJkJk6cCMCkSZMYPnw4G/Yd519zdpOZA3f1qkv1qH8KJawGNIo8/1YlixY53/7cc+f/XkRKSt++zrcPGwZ33OHesYh4C83QiXjI6as/nN1jLjs7m9zcXG6++Wa6dOnC0m2HGfjuIiyGwaxRl3JdQhwBPo6/vgE+FppHhxa6pJcrt9/ufPvYsed9KpES1aKF8+0nTrh3HCLeQjN0Ih5SnNUfEhISeOSNj1gV0pq48AA+vKMtcWEBABcU4M62YYPz7SqGEE+bNQtq1Tp3+7hxjsIJETmTfmyLeEhRqz8ArEu3s8SvGQ1iQki889KCMFcSDh1yvv2//y2xS4hcsJo1nW9/8UW3DkPEayjQiXhIYas/ANjbXEdSaiwZO1bx8fB2RAS5KP+7QK56zI0cWaKXEblgvXt7egQi3kOBTsRDzl79IbxyNC9/lcRna3cy4O0fCe98O3X9jpM+71WC/Er+6Yh33nG+3UcPYkgZ8fzzzrevWOHecYh4AwU6EQ+55pprMAwDgGp16/PG3J+pVrchn/22kyXb02lXN4zrq6Uz9KZBJX5tV/28+vcv8UuJXLCEBOfbH3/cveMQ8Qb6f3ERD0hOTua7777DzEtWj737AYaPP+8lpbBh93F6No+lR9MYzE3HGDNmTIlfPzHR+faXXirxS4mUuO+/9/QIRMoezdCJlAJXzYI3b97M66+/Trdu3YiOjmbixIkEBgaS7R/Bq99s5K89xxlwaXV6NovFMAx8bLYLWv2hKA8+6Hx7jRolfimRi3LXXc63a9UIkTNphk6khBXWLHjSpEnk5ORw7bXXMn36dOx2O7barXnuu7/w87Uyulc9akf/82ydJe+WbElztiZmyPn3JRYpdU88AW+9de72b7+Fq692/3hEyirN0ImUoKKaBefk5GCz2XjhhRcICg7hxXkbGJe0hzrRITzYt8EZYc5qgL+P+/6KPvGE2y4lUmwxMc63u6rSFqmoNEMnUoKK0ywY4MXX3yKjxWAW/nWAG1tXY9w1jfj7RAZrD6aSnp1LgI+FRpEhbNlT8oFu61bn22+7rcQvJVJq/vzT0yMQKVsU6ERKUHGaBRNahbk5CfinHGR8vwQGt60OOFZ+OHv1hy2lMMYPP3S+PSqqFC4mUgLuvRfeeMPToxAp23TLVaQEFdUsOLB+B2KGvgRWX2aOaFcQ5txp+nS3X1LkogwZ4nx7To57xyFSlinQiZSg05sFW6xWBo95hM/W7uStpMU0vv1Zoq59lMwD20id9QQta0R4ZIxbnEz72e3uH4dIcbVs6Xz7b7+5dxwiZZkCnUgJOXLkCNHR0QCEhIXz4hfzuH7kvZzKNvlqXSapUc0IOryew4n/Zsj1Zas875ZbPD0CEdcsLv6l+uIL945DpCxToBMpAUlJSSQkJLBt2zZsNhvPffYtNetfwq6DJ3ntmw1s3pvKgEurc8+NHbFZjFJpFlwcJ086365AJ95IgU7kHwp0IkVw1SQ4JSWF9PR07rvvPrp3705ISAiLFy/mq6++IqpKdZL+3Mdr324gO8fkrl71aF8/kqjYOBITE0ulWXBx/Pij8+0tWrh3qdPRgQAAIABJREFUHCLnKzz83G3O+imKVFSqchUphKsmwVOmTOH9998nKiqKnTt3cu+99/L8888TEBDA9kMnuHX6UrbuP0GzWuFc374aQX6Ov2q+FujVq5fH3k9SkvPtpdS/WKTEXHcdvPeep0chUnYp0Im4cHqT4LPlB7xdu3Yxbdo0brnlFkzTZOaSHfzft+uwGAY3X1GTZrX/KXywGtA02sk0gxv98YdHLy9ywRToRAqnW64iLhSnSbDVamXp0qUcSM1g+AfLeOSL1TSrFsYPYzoy7NJaBOSt9BDgY6F5dOg5febcbd06j15e5IJdcYXz7cePu3ccImWVZuhEXChOk+Ds7Gxm/ryWRa/9RGpGNk/2uYTbLq2JxeK4h+npAHe2gwfP3XZapxWRMisoyPn2zZv1DKgIeDDQGYYRBjwKtAAigCTgU9M0V3jiPCJnK6pJsOEbQHiXYQQ37Um03Z9PbmxGvWjvW+H+kks8PQKRC7dzpwKdCHjolqthGC2ArUAKMAAYDtQGlhuG0c3d5xFxJjDwzNm1Bi3a8HbSYj5ft4vHE3+h1l3vEdykO+krvmL2XR28MswBNGrk6RGIXDhVuoo4eGqG7kdgkmmak/J+vwIYYBhGCjDfMIxw0zSPuvE8IgWys7N59913z7jd2r5nH+5+/jV8fP35fuVe/r+9O4+Pqr73P/46yUw2JgshEJIQIBl2JOxaWlS0Uo3YFu2gVaGt91asafuwgFfL7XJ7b/UqXiNd9PaK/Kw2aesSrdpKWoMVFawLYGVT1MGFfQ8mBsIkOb8/ziQmmQkkYTJnlvfz8ZjHJN9zcvgkh2Te8z3n+/0+v7mWrP4DSNn2NFNHJZHkiN7bURXoJJop0IlYwv4qZBjGLUAWcH+QzVX+5yvDdRyJX53nlAP4xz/+wfTp0/n+97/P9OnTSUlJAeAbt/yEvZ+0sPzP21m9aT/TRwzg3+aO47qF19k2SXCoKNBJNFOgE7HY0a1wFVBrmmaQFSWp8T/PC+NxJE6Zptk2p9yECRO4+OKL+fznP8/Bgwd57LHHePnll3nyySfpN2Awq71N/HrVuxxvbOJfLizm6zOHkZKUSE5evm2TBIfKiBF2VyDSewp0IhY7LrlOwbo0Gsx6//O0MB5H4lzrnHLPPfcc119/Pffccw8ul4vmFpODWWMZVvYgb+44yoUTcpk9cTDJzsS2r01t93Gka24O3p6dHbxdJBoo0IlYwhroDMMo9n94JNh20zRrDWvK+qxwHEekPYfDQVJSEi6Xi40fH+UnT21h655P+Lx7ADd+0c2Rpiaazc/2TzRgfE70DISo7eJu0sToyaQiAfbutbsCkcgQ7h664tPvEtbjSBz68CD8Z5BFvZuamqh8/ClcFyzkkTd2kpuRzL3XTGbOhDwMw+DjYw1sPVTH8aYWUh0JjM9Jj7h55k7l8OHg7S0t4a1DpLcMA0yzY1vnz0XiVVxOLGwYxkJgIUBubi5r1qyxt6A+NCtIWyx/v12ZBew5Crc/BQ+8AAkJcP755zN79mxSUlJoMWHbiSxe+XQgj6/fySXDnXx1RCKpR97lxRffbTtOqv8BsGMnBLuBM5Tq6+tDdr6sS66zAtpfemktmZlNIfk35DOhPHdicTjOw+cLvPU7lD9nnbfopPMGhhnGtzf+ueFqgNWmac7uYh8TwDTNLpcLD9VxAKZNm2auX7/+VLtEtz8E+favia+3tIcOHeLObw7kvhpoaoFvz4Ifz4U/j3uNnLwCNr/zIX984V1Opg3Ct3sbL9z9nYiZU27NmjXMmjUrZMcbODBwtYgDB6x2Ca1QnzuxVosIsrRySHvpdN6iUzydN8MwNpimGTBGINyjXFs7NE53G/bp5o4L1XEkSnm9XsrKysjIyAg6/QjAsWPH+OlPf0pRURHLq+HKz8H2u+E3/wIF2dAvJ48nXt3F716rJTk7j4F7XmRu5kcRE+b6QkKQ33hdcpVoEWxVk29/O/x1iESicF9ybR3EcLrBCqe7khWq40gUqq6uxuPxtI1OBdqmH3n44YeprKxk+/bt3HXXXRw9epR58+bxn9MfZ2yB9fXHW5J5+NBl/OqJrZw42cy54wZx8eQ8Pj2UwxeH9rfxO+t7wQJdV6NfRSLN6NHQ+YLKeefZU4tIpAlroGs3+jTooIZ2o1dXh+M4En28Xi8ej4eGINddWgPeFVdcAcCcOXP4+c9/zuTJk+EPBo0tDh45cgn3HriSg03ZjCnox2XT8snPtgY2pObl43bnh/X7CTcFOolmx48Htvnn/haJe3YMilgNXGQYxhTTNDvPI9e6/uqjYTyORJHy8vIOS3IFYxgGl19+OU888QQATc0tPHFkNr/afzW7fYM4p99m/nfYnew8r2Pej6Y55XorLcig3GPHoLAw/LWI9FSwQJeaGtgmEo/sWCmidamuG4Jsmwds7BzQDMNY5l/q64yOI9GvsrLytIHONE1Wr15NS4vJ0//czezlL3HrrpvIcdRSUfRjHileyvR+2zp8TbTNKddbQ4YEtu3aFf46RHrjxInANvXQiVjC3kNnmmaVYRgrgIWGYdSYplkFbWuzTgOmtt/fP6L1Fv/Hq1tDWk+PI7Ghvr6+W/s1DR7Ppb96mXf21TFmcDorhv2c2RmvYbQb9JvqSIjaOeV6q6AgsE2BTqJF5xHaAC5X+OsQiUS2zENnmuYNhmFsAG4wDOMBrEEOG4Ei0zQ7j0xd799G5x63Hh5HYoDL5aKurq7t8/SsbPKL3dxW+ScO7tnFgw9UsCvJTXL+KBqbWvjV1ZO5bEIeCY+8FnCsUnduOEuPCOqhk2hlmrAjyDC34cPDXopIRLJtYmHTNFcAK7qxXy2n6G3r7nEkNsyfP5+VK1fi8/mYOWcu7216k5zB+Xx4sIFVm05wcHgpab56xp/YzJOLbsGRaMddBZFLgU6i1cGD8OmnHdvS0iA3/t6XiQSlVzuJKkuWLCHBP1Tz2sVLqas9Sp37Yu5d9S4HPznB5ecMYfGlRSz//jyFuSAU6CRatZtisk1xMR1uoxCJZ3G59JfEhswBORxvbOJY2lCmubPxfH4oSY4EWlpagCB3T4sCnUStYJdbi7Wqt0gbdWFIVCkvL/cHNvjonW0kpmUCMDI/nSSH9d/58L49LF++3LYaI5kCnUSrYIHO7Q5/HSKRSoFOokr7aUsevbecxH5WoHOlWJ3NJ443UFn+31RUVNhWYyQbNAgcnfrljx2DWg0hkginHjqRU1Ogk6jSftqSf65dQ0KqFej6JSdyYPdOfvPjm1n77FPdnt4k3iQkBH8R3LAh/LWI9ERX99CJiEWBTqKKq92kU8NGjSWxn7Wcb+OxQ/z+njtY++xTAftJR2efHdj2+uvhr0Oku0wT3nsvsF2BTuQzCnQSVc7zr8Q9c85chowcRfog66awYcOHcuNtdzNzzlycTicLFiyws8yIpkAn0ebjj2Hfvo5tDofmoBNpT4FOoobX6+X5558HrClL9n/8Ea7coSQ7E0hyJJCSmsa1i5ficDhYtGiRzdVGLgU6iTYvvxzYNnWqlv0SaU+BTqJGeXk5zc3NAAwYnM/uHe/jHFBATnpy2z45eQV88YtfxK3hb12aOBGczo5te/bA7t321CNyOsEC3cyZ4a9DJJIp0EnUaD/C9f3Nb3L803qaU7LJzfrsbfqhvbt56aWX7CoxKqSkWKGuM/XSSaQKFujOPTf8dYhEMgU6iRrtR67+7Y+/w3Amc4IkBmVage7E8QZ+f88dGuHaDcEuu74WuNytiO0OHYK33w5sVw+dSEcKdBIVqqurMU0TsAZEtLS0kDl0LAC5WSm0tLTw9yceYe2zT2mEazco0Em0WLcusG3cOBgwIPy1iEQyBTqJeF6vF4/H0/b5NYt+yNbX/8Hwsy8AYFBmCgkJCUy7YLZGuHZTsED3yivwySfhr0XkVHS5VaR7FOgk4pWXl7fdOwdwsrGRI/v3klU8kQQDBmZYgyJy8gpwOp0a4doNo0dDXl7HtpMnobrannpEuqIBESLdo0AnEe93v/tdh0C3zj95cENqLsMHuXAkWv+ND+3dTVVVlUa4dkNCAnz1q4HtTz4Z/lpEurJ3L7zxRmC7euhEAinQSUSrrq7m008/7dD2l4cfYPjEc9hf18zo/HTAGhDxh+V3UlpaakeZUemKKwLbVq2CEyfCX4tIMI89Zq0S0d6IETBsmD31iEQyBTqJWJ3vnWt1/NN6Jnz5WwCMzE/nkyOH+c2Pb+atl54Pc4XRbdYsyMrq2FZfD6tX21KOSIBHHglsu+qq8NchEg0U6CRidb53DiBzQA7ZuYNJGlpCalIiQ3P6kZSaisPh0GCIHnI64ctfDmz/05/CX4tIZx98AK++Gth+9dXhr0UkGijQScTqfO8cwLHDhyj9xvVs31PHyLx0EhIMUlLTuPqmWzUYohcuvzyw7emnoakp/LWItBesd27CBBg/Pvy1iEQDBTqJSMHunQPol5HJwOmXUXe8iRmjc9rac/LyNRiiFy6+GFJTO7YdPgxr19pTj0irYIHu618Pfx0i0UKBTiJOV/fOAfzrj25n3fufUJCdyij/gAiAVGdiuMqLKWlpcMklge0PPRT2UkTabNsGmzYFtivQiXRNgU4iTrB75zAMvnDpVxgw+UIOHGvkggm5GIYBQLPvJONz0oMcSbrja18LbPvjH2H//vDXIgLBe+fOPhuKi8Nfi0i0UKCTiFNZWRkQ6LIH5nL9f9zJ6rf2ke1KYuLw/gA0NzUxPMlkaGaaHaXGhCuugOzsjm0nT8L999tTj8S3kyfhwQcD2zUYQuTUFOgk4tTX17d9PP2LFwNw+cLv8cqO43x8qIFLpuSRmGD1ziUmJjJ91HA7yowZqamwcGFg+29+Y724ioTTH/4Au3d3bDMMuPJKe+oRiRYKdBJxXC4XADPnzOXir38DgMTcUTz31l6murOZWvxZd5LunQuNsjJI7PSj3LcPHn/cnnokPrW0wF13BbZfcQXk54e/HpFookAnEWf+/Pk4nU6uXbyUw/v3kpCawbqDLnLSk/najELdO9cHCguD30v3y18GztQv0leefRbefjuw/dZbw1+LSLRRoJOIs2TJEpxOJzl5Bez76EMyplxKfWMLC2YVkeJMxDRNDu3ZrXvnQuymmwLb3ngj+OSuIn1h2bLAtlmzYPr0sJciEnUU6CTiuN1uqqqqOLJvL/s+/pD0IaPI6udkyAArvB3eu4fCEwd171yIzZgBU6cGtv/yl+GvReLPunXWozP1zol0jwKdRKTS0lImF+Sw96MdJA0YwsCMFMC6zDq5IIfS0lKbK4w9hhG8l+7xx2Hz5vDXI/El2L1zJSXW5NcicnoKdBKxpo0cxsFdH2P2G0BORjKpjgTOKRyonrk+dOWVkJvbsa2lBW6+2Z56JD5s2wbPPBPYfsst1hsNETk9BTqJWAcOHOC4z6Q5IZkL3QMpdefqnrk+lpxsvYh29txz8Le/hb8eiQ//9m+BbUOHaqoSkZ5QoJOI9f777+PILgBgeE4/m6uJH9/9LhQVBbbffDM0N4e/Holtf/kLrFoV2L54MTid4a9HJFo57C5AbPCH6LiG8f5L4Ow/C4CiV6fBP3fZW1CcSE6GO++Eq67q2L5lizWD//XX21OXxJ4TJ+AHPwhsLyzU/zORnlIPnUSs9/ZBUnY+CTRTmLTP7nLiyrx51qjXzn7yE6irC389EpvuuQe83sD28nJI090VIj2iQCcR6/39kDk4n3znQZITmkJ78ITk0B4vxhiG9aLa2f798D//E/56JPbs3Am33x7YfsEF4PGEvx6RaKdAJxHr/f2QPCCfouQ9oT947oWhP2aMmTHD6qnr7O67g/eqiPTEzTdDQ0PHtsRE+PWvNbJVpDcU6CQimaYV6Jpc+QxL3hu6AyckQ14pzHgodMeMYXfeCUlJHduOH4dvfEMDJKT3XngBHnsssP3734fx48Nfj0gs0KCIWHeNtRDnmjVrmDVrlr21nILX66WkpISGdm/ZE1IzyHK4+NVje7h9PaSlpbFp0ybcbreNlcaX4mLrRbbz5ddXXrGWafr3f7enLole9fXwne8Etg8aBD/7WdjLEYkZ6qGTiFBeXo7P5+vQ5uifD0DTUeuSq8/nY/ny5WGvLd799KcwbFhg+3/8B2zcGP56JLp9//vw7ruB7XfeCZmZ4a9HJFYo0ElEqKysDAh0Tn+g87ULdBUVFWGvLd5lZEBFReB9TU1NMH++dQlWpDsqK+GhhwLbzzkHvvnNsJcjElMU6CQi1NfXB7Q5svMxW5ppqt1/yv2k7517bvAVJN5+G5YuDX89En3eew9uvDGwPS0NfvtbSNCrkcgZ0a+QRASXy9Xh8wGD83DljyAnI5Xf1Kxj5py5QfeT8PnP/4SJEwPbf/lLqKkJfz0SPRob4etft+6f6+zXv4axY8Nfk0isUaCTiDB//nyc/nV+Zs6ZizMpmZRBQ8nJTGFQQSE33nY3s77qYcGCBTZXGr+Sk61LZslBpvD71rdgn+Z+li4sXRr8fsurr4brrgt/PSKxSIFOIsKSJUvaAt287y5i/86PaEnNZmCGlR5SUtO4+qZbWbRokZ1lxr2zzoI77ghs37MHvvKVwHnFRP7yFwg2lqm4GP7v/zTnnEioKNBJRHC73VRVVZGWlsaJhgYSXDm0GA5ys1La9snJy9eUJRHgppvgwiDzMr/xhjVIoqUl/DVJZNq61ZqzsDOnEx591BpwIyKhoUAnEaO0tJRNmzaxY/M/SRpozZOR1z+1bXuqM9Gu0qSdhARrpGJOTuC2P/0Jbr017CVJBNq5Ey65BI4eDdx2550wbVr4axKJZQp0ElHcbjcc3U/yYKsnrjXQJRowPifdztKkncJCeOaZ4PfT3X03rFgR/pokchw9aoW5XbsCt116KfzgB+GvSSTWKdBJxPn4ve1kF08g25VEalIiqY4EJudmMjQzze7SpJ0ZM+Dhh4NvKyuD554Lbz0SGY4ft+6n3LYtcNuIEdb/GU1RIhJ6+rWSiLN582aSBw1n0pAsrhidR6k7V2EuQl11Fdx+e2B7czN4PLBlS/hrEvs0NVkjV9euDdyWmwt/+1vwS/UicuYU6CSi1NbWsmvPPk44MxkzWJdYo8HSpda0JZ3V1cFFFynUxQvThO9+F55+OnBbejpUV1sjW0WkbyjQSUTZunUrzgFDaMFgtAJdVDAMuP9+uOCCwG3798P558OGDeGvS8LHNOHf/z34vZNOJzz1FEyeHP66ROKJAp1ElC1btpA0cDgAYwZrToNokZQETzwBo0cHbjtyxJrmZN268Nclfa+5Gb7zHWvkajAVFcGnuRGR0FKgk4iyZcsW+uWPxJloUDywn93lSA/0729dVissDNz2ySfwpS/B88+Hvy7pOydOwLx5XY9q/sUvrPssRaTvKdCJ7bxeL2VlZWRkZHDvvfdC/wJSTh7j4w8/sLs06aGiInj5ZQg2/3NDA8yZY60cINGvthYuvtiaezCYW2+1JqEWkfBQoBNbVVdXU1JSwsqVK6mrqwPAmTOM/e++SUlJCdXV1TZXKD01bJgV6saNC9zW2AiXXw6PPRb+uiR09u617o186aXg23/4w+BLxIlI31GgE9t4vV48Hg8NDQ34fD4AEpL74cgYSOO+HTQ0NODxePB6vTZXKj2Vlwcvvhj8RvimJusy3E9/at1/JdHlvffgC1+ATZuCb1++3ApzWqNVJLwU6MQ25eXlbUGuldM/IOLkoQ8B8Pl8LA+2srdEvJwc+PvfrQmIg/n5z61VAw4fDm9d0ns1NfD5z8MHQe6GcDjg97/XKhAidlGgE9tUVlZ2Geh8Bz+0nn0+KioqwlyZhEpWlrViRLApTcDaNnUqrF8f3rqkZ5qarGlJLr4YDh0K3N6vHzz7LFxzTfhrExGLAp3Ypr6+vsPnAwsKcRWOJjUpkV//6VlmzpkbdD+JLi6X9WL/la8E3/7RR9YlvJUrw1uXdM/OnTBrlnUZ1TQDt7f2xH7pS2EvTUTaUaAT27hcrraPZ86ZS1JyMv2GjCGvfyq5Q4Zy4213M3PO3A77SXRKTbVGQ/7XfwW/t+rkSbj+evj2t62pMCQyPPMMTJrU9RyCw4ZZy3ydfXZ46xKRQAp0Ypv58+fjdDoB+NqNN7HnAy8trkHk9U8FICU1jflL/p0FCxbYWaaESEIC/OQnsGqVNWddMP/v/8H06fDqq+GtTTo6eRIWLYKvftWaGDqYL37ROk/BJpMWkfBToBPbLFmypC3Q1R05QmJWHi2Gg4IBqW375AzOZ9GiRXaVKH3gkkuspcCmTAm+fcsW68b7733PmpBYwmv9emsgyy9+EXx7QgLcdhv87W8weHB4axORrinQiW3cbjdVVVWkpaWx+dW1JA0eCUBhTlrbPgnNTbiDzVIrUa2oyLqM9y//Eny7acJ998HYsfDkk8Hv3ZLQOnQIFi60Lp9u3Bh8n4ICWLMGfvQjSEwMa3kichoKdGKr0tJSNm3axPbX1pJRPBFnosHgLKuHzsBkauFAmyuUvpKSYl1ifeABay3YYPbsga99DebOtW7Ol9Brbob/+z/r0ukDD3Qdni+7DP75Tzj33PDWJyLdo0AntnO73Zz8tI7MogkU5qSRmGCQ6khg6uAshmamnf4AEtW+/W147bWuL8GCdXP+uHHwy19a93dJaPzjH1aP3I03dn2vnNMJ99xjnYOcnPDWJyLdp0Antqurq2P7u+/h65fL+SMGcsXoPErduQpzcWTSJCvU3XOPNadZMPX11qS1I0ZYPUqNjeGtMZbs3m1d7v7857u+vApw1lnWKNZFi7Tyg0ikU6AT27355ps4BhTSTAITh2TZXY7YxOGwgsPWrTBnTtf77dxp9SiNGAG/+Y2CXU+88w78679a9zD+9rdd75eRYQ2K2LhRU5KIRAsFOrHd+vXrSc6zBkRMGJJpczVit2HD4M9/hsceO/Uoyl27oKzMCnb/+78Kdqfy+uvWvYjjxsGDD0KnBVo6+OY3Yft2uOkm63KriEQHBTqx3fr16+nvnkR6soOiAV1cb5O4Yhgwbx68/TZ85zun3nfXLvjud8HtthaGD7Y0VTwyTWtptQsvhHPOOf1o4UmTrMurDz2k6UhEopECndhuw4YN9Cscx4QhmSQk6EYd+UxWlnVZdeNGa5LbU9m9GxYvhvx8qzfqL3+x1iCNNwcOWFO+TJ1qrb36wgun3j8ry9p//XprCTYRiU4KdGILr9dLWVkZ6enpvOvdQUNSFvu2vYbX67W7NIlAkyfDU09ZwW7u3FPv6/NZvVFf/jIUFsKtt1r3jsWyujqoqIDSUivQfu978Oabp/6a/v2tlTvee8+6dK155USimwKdhF11dTUlJSWsXLmS+vp6kgYVYyQ6Wf/cE5SUlFBdXW13iRKhJk+21oR98024/PLT779vH9x1lzVB8YwZVk/Ue+/FxkTFjY3w9NNw1VWQmwvf+Ab89a/WvHKnUlBgjSb++GNrbV1NRSISGxx2FyDxxev14vF4aGhoaGtrXSGiYec7NDc04PF42LRpk1aIkC5NmmT1wr31lhVKnnzy9F/z6qufrRE7bBjMnm09LrwwOkJNc7O1LNpLL1mP1auhtrb7Xz9mjNVbec01XU/kLCLRS4FOwqq8vBxfpyF2yXkjaf70KM11BwHw+XwsX76ce++9144SJYpMnAhPPGFdUn3wQeuy4759p/+6jz6ClSuth2FYPX+zZ1sLzk+aBAMjYIESn89a87Y1wK1dC8eO9fw455wDP/whfOUr1jqsIhKbFOgkrCorKwMCXVLeSBr3vtf2uc/no6KiQoFOum3MGOvS6n//t3XZ8be/taY+OdX0HK1M07o3b+NGWLbMasvJsab46PwYPDj0E+weOQJeL7z/vvXs9VqXhd98E9p1ZPdIYSFcfbX1mDhRkwKLxAMFOgmr+vr6to/PmX0pr7/4AkkDhnLhOWP56MQm1j77VMB+It3lcFhrjl52GRw8CH/4gxXu3nqrZ8c5dOiznrH2srJg+HDruatHZqZ1eXTDhly2b7dC2fHj1nPrx0ePfhbejh4Nzfc+YABceaUV4r7wBfXGicQbBToJK5fLRV1dHTPnzOVzF8/hn+98DIbBmKI8Lr3tbgDWPvsULpfL5kol2g0caE2Oe9NNVm/X009DTY21xNjpBg50pbbWWqC+e8b27h/pgX79rFG/11xjXTLWRMAi8Uvv4SSs5s+fj9Pp5NrFS9mxdTMp+aMBGDowjZTUNK5dvBSn08mCBQtsrlRiyeTJ8LOfwbp1cPiwNQXK974Ho0fbXVnPuFxwySXWpeW1a63vpbISLr1UYU4k3qmHTsJqyZIlPPzww+TkFbD9zfX0H/MV+ruScKVYr0Y5eQU4nU4WLVpkc6USqzIzrUmKWycq/vhjeP5567Fpk7Xs1cmT9tbYKjsbzj0Xzj8fzjvPuh/Oob/aIhKE/jRIWLndbqqqqvhw107e27SRwvMWU5T72eXVI/v2UlVVpSlLJGyGDoXrrrMeYK0usWMHbNvW8fH223DiROj/facTioutpctGjPjsufWhe+FEpDsU6CTsSktLefiJZ2hJ6U9TYgpFg6z1W5t9J5lckMP0UdNsrlDimcMBo0ZZj/arUjQ3w86d1oCJ2tquH598YoW0Tz7ZT1FRLqmpkJZmPdp/XFhoBbYhQ7RKg4icOQU6scWx3R+SPGQcAMW5LlIdCYwfPJChmWk2VyYSXGKiNcJ1+PDu7b9mzdvMmpXblyWJiLRRoBNbvPLKKwwYPZ3MVCffObuIhARNlCUiItJbujtDbLFu3TpSh05g2rD+CnMiIiJnSIFOwm7nzp3sOfwJJ5IymTY82+5yREREop4CnYTdK6+8QnKBNenq9OH9ba5GREQk+inQSdi98soruIomkuRIYMKQTLvLERERiXoKdBJ269ato/+oaUwckkmyQ/M1iIh4sT3QAAAfHElEQVSInCkFOgkLr9dLWVkZ6enpbHxrCydSB3J4+xt4vV67SxMREYl6CnTS56qrqykpKWHlypXU19eTlDcSI9HJG6seoaSkhOrqartLFBERiWoKdNKnvF4vHo+HhoYGfD4fQNuEwg0fbaahoQGPx6OeOhERkTOgQCd9qry8vC3ItUoZMo6TBz+ipfFTAHw+H8uXL7ejPBERkZigQCd9qrKysi3QfeHSr5KWkUm/YSWcPXk0M+dYC2X6fD4qKirsLFNERCSqKdBJn6qvrwdg5py5XPbN6/ElZ9OSmMS44lxuvO3utlDXup+IiIj0nAKd9CmXywXAtYuX8u5bG9vunyse5CIlNY1rFy/tsJ+IiIj0nCPc/6BhGFnAUmAKkA2sBh41TXNjD77+cf+ntZ02Z/mfl5mmuToE5coZmj9/PitXriQnr4Ctr79C1ugZZKY56e9KAiAnrwCn08mCBQtsrlRERCR6hbWHzjCMKcAHgBeYB1wPFAMbDMO4qAeHusj/8HR6tLZndf2lEk5LlizB6XRyYPdOtr3xGs6C8YzMS8cwDAAO7d2N0+lk0aJFNlcqIiISvcLdQ/c8sMI0zRX+zzcC8wzD8AI1hmH0N02zc69bV6Zi9fBBYIDrVm+f9D23201VVRU/u+M/aHRm0OJIYUReOgCNxxuouu8eqqqqcLvdNlcqIiISvcIW6AzDuAUreN0fZHMVcAtwJbAiyPYA3b1EK/YrLS1l3bp1vH0sBYDi3H4c2rub/W+9zv133a4wJ7HlwAH41rc4b/Vq6DRlj0S+WXYXEOuSk+HCC+Ghh2DQILuriSnh7KG7Cqg1TXNHkG01WIFuHt0LdN3txZMIsWXLFgaMm8HQAWksnF4EFMGsaXaXJRJ63/oWVFdrxJlIMI2NUF1t/Z6sWmV3NTHFME0zPP+QYZjARtM0pwbZlgUcxQp8/U9znCxgg2mave7WMQxjIbAQIDc3d+ojjzzS20NFjfr6ettGkra0tDD38ivIWfgg5w7rx3VnJdtSRzSy87xJ75z3pS+RoJ45kVNqcTp56bnnQna8ePpbecEFF2wwTTOgRyQsPXSGYRT7PzwSbLtpmrX+m+S7M5ghu90xl2GNli3Gum/u/nb353XJv88KgGnTppmzZs3qxj8b3dasWYNd3+ebb75JY9ogWhKT+dq5E5g1Md+WOqKRnedNeklhTuS0Eny+kP5t09/K8I1yLT79Lj0+ntf/vAPrEuwU4H7DMGpC/G/JGVqzZg0pw0oAmFE8wOZqREREYk/Y56ELgSz8o2Pb349nGMYyrPvwLjIMY2F3euokPNasWUP22PMYlZvOwHRdbpU4FKZbW+TMqaenj/inqpK+E3X37ZqmudE0zamdB1eYpnkr1iTFYA2ukAjQ3NzMiy+vxRg0ghlu9c6JiIj0hVMGOsMwagzDMHv5aH8/XGv4yg7277RzpqNXl/mfQ32JV3rA6/VSVlZGRkYGDoeDE/3yaDEcFPfTvUUiIiJ94ZSXXE3TnB2if6d1MMTpBj0Em9KkJ1q/XtOa2KS6uhqPx4PP58Pnvzk8ZdhEzJZmyjyzGfiH31FaWmpzlSIiIrElLJdc263+ELTnrN0o2DNdf7U1MGodVxt4vV48Hg8NDQ1tYQ4gZVgJJ/d7+bT2EB6PB6/Xa2OVIiIisSec99Cthrb1XDtrXcf10VMdwDCMZe3CXzCt87Lc0fPy5EyVl5d3CHIAhjOZ5PzRnPhoEwA+n4/ly5fbUZ6IiEjMCmega13y64Yg2+ZhTTrcYTkvf4C7pV3TowRfOqx1wuFlWKNfdcnVBpWVlR0C3aSZs0guGIeR6OT6sn9l5py5+Hw+KioqbKxSREQk9oRt2hLTNKsMw1gBLDQMo8Y0zSpoW+N1GtBhBQnDMC7CmoYEwzBW+0e3bjQMo9gwjMexgt16rIEWF2EFxXmmaepyq03q6+vbPp45Zy5D3CP5MPEACQZMHjecSbfdDcAr1c/YVaKIiEhMCuu0JaZp3oAVvG4wDOOoYRheYDpQFGSN1/VY88117rm7FetevBrgA6xgl+WfykRhzkbtl125dvFStr7xDzJGncOwQf1IdiaSkprGtYuXxs3yLCIiIuES9omF2y+7dZr9aunUa+dvrwKq+qA0OUPz589n5cqV+Hw+0rOyeWfLNvLPLWRkXnrbPjl5BSxYsMDGKkVERGJP1E0sLJFryZIlOJ1OAF6rWYWzYBwYBqPzM9r2ObJvL4sWLbKrRBERkZikQCch43a7qaqqIi0tjT89cC9p7mmkOBMYOrAfAI3HG8hL9OF2u22uVEREJLYo0ElIlZaWsmnTJo7XHiG1aCrDs50kYHL8k1pGpCXy5fNm2F2iiIhIzAn7PXQS+9LS0vjEcOHq15/rZo7ia2MLgAK7yxIREYlZ6qGTkFu9ejWpxdb80eeNGmhzNSIiIrFPgU5C7rnnniNj1DmMGuQiLzPV7nJERERingKdhJRpmtS88CKO/LGcP1q9cyIiIuGgQCchtXnzZj5JzsU0EnW5VUREJEwU6CSkampqSCmaQrLDYPrwbLvLERERiQsKdHLGvF4vZWVlZGRkcPPNN5NaPJWM4/vZ/fGHdpcmIiISFxTo5IxUV1dTUlLCypUrqaurw5GZizO7gPfXPkNJSQnV1dV2lygiIhLzFOik17xeLx6Ph4aGBnw+HwApRdZ0JfXvv0FDQwMejwev12tnmSIiIjFPgU56rby8vC3ItUotmkJT7T6ajuwGwOfzsXz5cjvKExERiRsKdNJrlZWVbYFu5py5DBk5lrTiKUw/azgz58wFrEBXUVFhZ5kiIiIxT4FOeq2+vh6wwtzVP7iVgycSwZHMpFH53Hjb3W2hrnU/ERER6RsKdNJrLpcLgGsXL2XbG6+SWjSVBANG5qWTkprGtYuXdthPRERE+oYCnfTa/PnzcTqd5OQVsPGlv+Ma/TmKBrlISUoEICevAKfTyYIFC2yuVEREJLYp0EmvLVmyBKfTyf6dH7H5rS0kZhcyrjCzbfuhvbtxOp0sWrTIxipFRERinwKd9Jrb7aaqqooHb/8x5I4BaAt0jccbqLrvHqqqqnC73XaWKSIiEvMcdhcg0a20tJSnnnqKXUfyyEwxyEl3cmjvbva/9Tr333W7wpyIiEgYKNDJGXvl9fWkzf4pV0wdxrxxQ2DcEJg1ze6yRERE4oYuucoZ2blzJ946B2aCg4vG5tpdjoiISFxSoJMzUl1dTeqI6aQ6DaYPz7a7HBERkbikQCdn5NlVq0gfNYNZo3NJcui/k4iIiB30Ciy91tjYyJp/vg9pWXxRl1tFRERso0Anvfbyyy9jFEzAwGTW6IF2lyMiIhK3FOikR7xeL2VlZWRkZDB79mxS3WeT4TvKsf277C5NREQkbinQSbdVV1dTUlLCypUrqaurI6FfFsn5o9j5mtVeXV1td4kiIiJxSYFOusXr9eLxeGhoaMDn8wGQWjwdgPp3X6WhoQGPx4PX67WzTBERkbikQCfdUl5e3hbkWqW5p9P0yQF8Bz8AwOfzsXz5cjvKExERiWsKdNItlZWVbYFu5py5jDtnJqnFU5k+bigz58wFrEBXUVFhZ5kiIiJxSYFOuqW+vh6wwtx1P/ovPj7iw3AmM3VMATfedndbqGvdT0RERMJHgU66xeVyAXDt4qW8++Z6nMMmkWiYjMhLJyU1jWsXL+2wn4iIiISPAp10y/z583E6neTkFfD635+j36gZjC7IaFsdIievAKfTyYIFC2yuVEREJP4o0Em3LFmyBKfTyYHdO3lr87skpudQ0m7t1kN7d+N0Olm0aJGNVYqIiMQnBTrpFrfbTVVVFb+9/cc0DxoDmIwrzACg8XgDVffdQ1VVFW63295CRURE4pDD7gIkepSWlvLMM8+wu3E8BRmJpCUlcmjvbva/9Tr333W7wpyIiIhNFOikR17asI2kCy/junNH4xlbAGMLYNY0u8sSERGJa7rkKt32wQcfsNPsD8CXxg22uRoRERFppUAn3fbnP/+ZtJGfozg7maED0uwuR0RERPwU6KTb/rSqhpTC8Vw2qdDuUkRERKQdBTrplmPHjrFx30kwEvjSeF1uFRERiSQKdNItf/3rX0kuns6AFIPx+Rl2lyMiIiLtKNBJl7xeL2VlZWRkZHD1/G+SUjSFfse87Nixw+7SREREpB0FOgmqurqakpISVq5cSV1dHSlFk0lwJrPxmYcoKSmhurra7hJFRETET4FOAni9XjweDw0NDfh8PgDSRn6O5uN1fPrhWzQ0NODxePB6vTZXKiIiIqBAJ0GUl5e3BbmZc+Zy4deuIW3EOZw1rD8zS78MgM/nY/ny5XaWKSIiIn4KdBKgsrISn8/HzDlz+c7P/4e3Pz5IQmo654wv5Mbb7mbmnLn4fD4qKirsLlVERERQoJMg6uvrAbh28VIO7t7FiYzhJNDC6IIMUlLTuHbx0g77iYiIiL0U6CSAy+UCICevgNee/ytpIz+He1Aqyc7Etvb2+4mIiIi9FOgkwPz583E6nRzau5vXX9+EIzOXqaM+m0z40N7dOJ1OFixYYGOVIiIi0kqBTgIsWbIEp9PJg7f/hCOOQWCajC/MBODE8QZ+f88dOJ1OFi1aZHOlIiIiAgp0EoTb7aaqqop/vvwCaaM/T56rhdSkBA7s3skDP/shG194jqqqKtxut92lioiICAp00oXS0lImnleKM7uA91c9xFVnDeXWy2czfkgumzZtorS01O4SRURExM9hdwESmY4cOcL7jS4yMdn63B8YlJ5id0kiIiLSBfXQSVB/+ctfSB05gzEDkhTmREREIpwCnQT1yLN/J2lQEZ7P6T45ERGRSKdAJwEaGhp4fc9JAEon5NtcjYiIiJyOAp0EqKmpwVk0neEZBgVZqXaXIyIiIqehQCcBHnnmbyTnj8Jzzgi7SxEREZFuUKATALxeL2VlZaSnp/Pspt0AvPGnFXi9XpsrExERkdNRoBOqq6spKSlh5cqV1NfXkzbqC5w88AF/XPErSkpKqK6utrtEEREROQUFujjn9XrxeDw0NDTg8/lI6JdF8pCxNLz7Cj6fj4aGBjwej3rqREREIpgCXZwrLy/H5/MB8IVLv8rAKZdgGAks+bfvMXPOXAB8Ph/Lly+3s0wRERE5BQW6OFdZWYnP52PmnLmUzr8OM388/RJOMm70cG687W5mzpmLz+ejoqLC7lJFRESkCwp0ca6+vh6Aaxcv5Y2X15IytITJ7hwMwyAlNY1rFy/tsJ+IiIhEHgW6OOdyuQDIyStg47v7MBISOXvMZ5MJ5+QVdNhPREREIo8CXZybP38+TqeTza+upTF7JKk0UjDgs8mED+3djdPpZMGCBTZWKSIiIqeiQBfnlixZgtPp5OHyu0gZNpFJxdkYhgHAieMN/P6eO3A6nSxatMjmSkVERKQrCnRxzu12U1VVxeHEARiJDkYNdNLS0sKB3Tt54Gc/ZOMLz1FVVYXb7ba7VBEREemCw+4CxH5jxowhbdQXSDxRyy++dQ319fW4XC4WLFjAyk2bFOZEREQinAKd8McnniZl+ES+NjmXu35xzO5yREREpId0yVV4bN07GIlOrjl3rN2liIiISC8o0MW5vXv3sscxGJfRyMQhmXaXIyIiIr2gS65x7pEnnyZ1+CRmjx3QNrpVREREoot66OLcH1/aipHoZMH54+0uRURERHpJgS7OeL1eysrKyMjIwDAMPmzOJuF4LRm+I3aXJiIiIr2kQBdHqqurKSkpYeXKldTV1WEkpZE6fDLHtr7IxIkTqa6utrtEERER6QUFujjR2NiIx+OhoaEBn88HQNrIczAcTurffpmGhgY8Hg9er9fmSkVERKSnFOjixP79+9uC3Mw5c1n+57/Tb8y5JDZ9yvTJYwDw+XwsX77czjJFRESkFxTo4sThw4fx+XzMnDOXG2+7G+8720kZPokxuSmU3XY3M+fMxefzUVFRYXepIiIi0kMKdHGipaUFgGsXLyUlNY2XN7yL4Uji/GmjSElN49rFSwGor6+3s0wRERHpBQW6OJGQYJ3qnLwCGo83sK8pHUdTA8V5GW3tAC6Xy7YaRUREpHc0sXCcGDBgAE6nk0N7d/Pulq0kD5vMyIEmCf7JhA/t3Y3T6WTBggU2VyoiIiI9pUAXJ3Jzc3E6nfz+njuozyzGKLyQC84uBuDE8QZ+f88dOJ1OFi1aZHOlIiIi0lO65BonkpOTqaqqYsPf/8aeky4ST9YzPDedA7t38sDPfsjGF56jqqoKt9ttd6kiIiLSQwp0caS0tJS7lv+alGGTqdu6hqsnDOPWy2czfkgumzZtorS01O4SRUREpBd0yTXOPPvWToyMwTxz38/43Ijf2F2OiIiIhIB66OKIz+dj81EHyU2fcnbxILvLERERkRBRD10MO1TfSNWGXbyz9xMmOxso/+n/I7HgLKbmQUKCYXd5IiIiEiIKdDHorZ213LfmfV7cfhCAxqYW3BOaeGXTO6RPKOS1A03cULGeslkjmFiYZXO1IiIicqZsu+RqGIbHMAyvYRjFvfz6LMMwlhmGUWMYxgb/x1NCXWe0qfzHh3x9xavUbNtPY1MLjU3WChEtLc04XDk0Nxyj2XDw3Lb9fH3Fq1T+40M7yxUREZEQCGug84ewWwzD8AKPA70Nc1OADwAvMA+43n+sDYZhXBSqeqNN5T8+5PZVb3Pc14xpdty2ffu7pAw9i5bjdQCYJhz3NXP7qrcV6kRERKJc2AKdYRgLgaPAUqAKqD2Dwz0PrDBNc4VpmrWmaW40TXMesAOoMQwj7q4jvrWzlttXvcNxX0vQ7a95D2IkOknMyOnQftzXwu2r3mHTrjM5HSIiImKncPbQHQFuME2zv2mat/o/7zHDMG4BsoD7g2yu8j9f2bsSo9d9a97nRFNz0G2m2cI+I5vmT2tJcKYEbD/R1Mz/vvB+X5coIiIifSRsgc40zSrTNFeE4FBXAbWmae4Isq3G/zwvBP9O1DhU38iL2w8GXGYFmFLUH8+oJhwF4ynOamFKUf+AfUwTXth+kMP1jWGoVkREREItGke5TgE2drFtvf95WphqiQhVG3YFbZ9S1J8rZw7lvvtewMiYxCUzJ1A0xLrkuvGDox32NfzHueF8Lf0lEnKGpgmKFrPsLkCkl6JqYuF2I2KDXq41TbP1RrC4uofunb2ftI1mbe/SafkkORLZeTyFhONHGTVsEEmORC6dlh+w74mmFt7ZVxeOckVERCTEoq2HrlejYjvzD9BYCJCbm8uaNWtCcVjbTHY24J7QFNCec/A9OAQ3fHEMR44cI/GjrVa7CUuC7J/h2MOaNRocEUnq6+uj/v9nvJlldwEiUaDF6eSlEP5t09/K6At0IeG/l28FwLRp08xZs2bZW9AZ+sEjb/LU5j0B7T+eN5JsVzKjh0PCh1toGX4WAEfqGylfszVg/8sn5/PNWZP6ulzpgTVr1hDt/z9FRDpLuOiikP5t09/KKLvkKsGNycsg2RF4Klet38PJTiNfTzY1s2p9YPhLcSQwZnB6n9UoIiJCcjKUlsJDD9ldScw5ZQ+dYRg1QG8n6u3f7p62UGkd2Zp9mv3i6rqhZ+oQlte8G9DeOvDh0mn55JhWz9yq9XsCBkQAmP7jiMgZ8g83V49BdNJ5k2h1ykBnmubscBXSTa2DIU436CHYlCYxK8eVzPmjB1KzbX/A1CUbPzjKxg+OsmRCU9DLrGANwLtg9EAGuJLDUK2IiIiEWlRdcm3X4xd0cES7UbCrw1NR5PjurBGkOBJ79bUpjkTKLhgR4opEREQkXKIq0Pmthrb1XDtrvTz8aPjKiQwTC7P40aVjSHX27JSmOhP40aVjKBkSVzO9iIiIxJSIDnSGYSzzL/XVXuuSXzcE+ZJ5wEbTNLuaeDimzZ8xnB9dOpZUZ+Jp5zE1DEh1JvKjS8cyf8bwsNQnIiIifcPOaUuK2z0H3PNmGMZFwC3+j1e3hjTTNKsMw1gBLDQMo8Y0zSr/PrdgrRAxNRzFR6r5M4ZTUpjF/77wPi9sP4iBNWlwqxRHAibWPXNlF4xQz5yIiEgMCGugMwxjGdZl0fb3wNUYhrER2GGaZvs1WNfjX+Krc4+baZo3GIaxAbjBMIwHsAZLbASK+mBkbdQpGZLF/y2YxuH6Rqo27OKdfXVkOPZw+eR8xgxOxzN1iAZAiIiIxJCwBjrTNG/twb61nKK3rf3kwBLcAFdy29qsa9bUatJgERGRGBXR99CJiIiIyOkp0ImIiIhEOQU6ERERkSinQCciIiIS5RToRERERKKcAp2IiIhIlFOgExEREYlyCnQiIiIiUU6BTkRERCTKKdCJiIiIRDkFOhEREZEop0AnIiIiEuUU6ERERESinAKdiIiISJRToBMRERGJcgp0IiIiIlFOgU5EREQkyinQiYiIiEQ5BToRERGRKKdAJyIiIhLlFOhEREREopwCnYiIiEiUM0zTtLsGWxmGcRD4yO46wiAHOGR3EdJjOm/RS+cuOum8Rad4Om/DTNMc2Lkx7gNdvDAMY71pmtPsrkN6RucteuncRSedt+ik86ZLriIiIiJRT4FOREREJMop0MWPFXYXIL2i8xa9dO6ik85bdIr786Z76ERERESinHroRERERKKcAp2IiIhEJMMwPIZheA3DKO7l12cZhrHMMIwawzA2+D+eEuo6I4HD7gJERKKBYRhZwFJgCpANrAYeNU1zox3Hke4505+3/+sf939a22lzlv95mWmaq0NQrtD2M18I3AD0Ksj5jzMFeB64FbjDf6ylwAbDMGbH2jlTD12M07sbkTPn/z//AeAF5gHXY704bDAM46JwH0e6J4Q/74v8D0+nR2t7VtdfKj1hGMZC4ChW8KoiMET3xPPACtM0V5imWWua5kbTNOcBO4Aaf3CMGRoUEYO6eHfjNk1zRw+P0/7dzWN89u7GA8Tcu5tIoR6FyGMYxlGsF4ZbO7V7sX4v+pumedoXnlAdR7onFD9v/+/TUWAq1u8jBAa4jT39+yrBGYbhAbJN01zh/7z1XPXoNcwwjFuAZcG+zjCMZcAtwA2t/05MME1Tjxh6YAU5E+sP0DL/swkU9+JYR7Fe+Du3e/3HzLL7+421B1aIO+o/j1n+zx/3/7wv6uYxsvz7n+rhsft7jZYH1h/+oL9D/t8xE1gYruPoEfbzlmW9VNr/PcXjo93rTY9ew4ANwNEutl3kP2aN3d9fKB+65Bp7jmC96+hvWu9Kj/TmIP53N1nA/UE2V/mfr+xdiXIKobxEMBWY7X/M6/TQ/VrddxVQawbvHajxP88L43Gke0L581avafSZgvV3M5j1/ueYWipMgyJijGmaVaffq1tO98fwFqw/hrHTXW2zboToW7BCdLd+5qZusg+VKXQdgHvywhCq40j3hPLn3as3xmKPdveMBz1vpmnWGoYBMXbvo3ropCtx9+4mAqhHIcJ054XB/+EpXxhCdRzpnhD/vLNbj2kYxuP+QWamf5DYwhCUK6HX65Gx0UyBTgLoxcc2oQzR6lEIjVC9MMTlC4yNQv3zLsa6l6sY63e0Fuv39X7DMGpO9YUi4aJAJ8HoxSfM1KMgErGysC7duk3TnGqa5mzTNPsDd/m3X6TfK4kECnQikUE9CiIRyD8waWrnWyH8g85ap/7RYJbI0nqusk+5V4zdmqJAJxJ71KMQOqF6YYjLFxgbhevnvcz/rKsakaX1SsfprmjE1NyBCnQRwL8Kg9nLR1/cx6YXnyimHoWQCtULQ1y+wNgoXD/v1q/X38II0u4WlaBBu90tLjE1uboCXQTw96AYvXz0xR8Svfh0UwjDuHoUIlCoXhji9QXGLmH8ebf+Duu8RZ7V0LbiUWety749Gr5y+p4CnQTQi0/3hTCMq0chcoXqhSHuXmBsdsY/b//a1ad689M66vyOnpcnoeI/T7d0am6dz/OGIF8yD2u5tpiaq1OBTrqiF58wUo9CROvxC4NeYCJCKM7bowSf6Lt1jddlwLw+ulIiluJOzx0YhnER1qTry9q/Xvkn2V8BLPSvD9u6/y1YQTz2bjuxe+0xPfr2QTfWwcP6o3RLpzaP/+vuD7J/DbDB7u8t1h7+n6sJTAmybWFX24Kcy1Od69bjaB3enp2b++m0Bi7Wi8jRzj9vPlsnMuB89eQ4ekTGefP/DX3cvz0LK1gsxFortFvrK+vR4/O2zP/zPdrunJj+tsc77Zvlbw/6muQ/VzX+Y7Wey5j8+2f4v2GJUYZhtJ7g2aZpBvTK+N/dtE5jMdVs947VMIz7sX4Z5pn+JcX8726W+veN+3voQsn/LvJxrLVcb+i0rQbINk1zaqf2ZcBh0zTv8n8+BVhmmubsIMfPAj4ArjdDt0Rc3PCPDJ6H9e7+CNZI4uvNTr0z/p/z8wCdz1dPjiOhcabnzf97uRRr2p9arEm+a1p/50QihQJdDPK/yF+E9U6y/T1ZG4EdprXYe+u+evGJID0J0V2FccMwvFjn6X6sF59srP8PNwC3Bgv2IiIS3RToRCKMehRERKSnFOhEREREopxGuYqIiIhEOQU6ERERkSinQCciIiIS5RToRERERKKcAp2IiIhIlFOgExEREYlyCnQiIiIiUU6BTkRERCTKKdCJiIiIRDkFOhEREZEo9/8B8baWuv487PUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "# plotting environment\n", + "plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "# plottign optimization results\n", + "plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + "plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + "plt.scatter([-1,1], [-1,1], s=300)\n", + "plt.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u.detach().numpy()\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "plt.plot(xs[:,0], xs[:,1])\n", + "plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + "plt.grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Constructing $\\psi_2 = \\lozenge\\,Int{[0,5]} \\text{inside orange box} \\: \\wedge \\: \\square \\neg \\text{inside green box} \\: \\wedge \\: \\square \\, \\neg \\text{inside blue circle}$ \n" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "Z = torch.as_tensor((np.linalg.inv(K) @ D)[:(2*N[0] - 1) * N[1]]).float().requires_grad_(True)\n", + "X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + "x = X[:,:1].unsqueeze(0)\n", + "y = X[:,1:].unsqueeze(0)\n", + "\n", + "U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + "ux = U[:,:1]\n", + "uy = U[:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [], + "source": [ + "inside_box_4, _ = inside_box(X, obs_4) # ((x,x), (y,y))\n", + "inside_box_2, _ = inside_box(X, obs_2) # ((x,x), (y,y))\n", + "\n", + "has_been_inside_box_4 = stlcg.Eventually(subformula=stlcg.Integral1d(subformula=inside_box_4, interval=[0,T]))\n", + "never_inside_box_2 = stlcg.Always(subformula=~inside_box_2)\n", + "always_stay_outside_circle_formula, _ = always_stay_outside_circle(X, obs_3)\n", + "\n", + "ϕ = (has_been_inside_box_4 & never_inside_box_2) & always_stay_outside_circle_formula\n", + "θ, _ = control_limit(U, u_max)\n", + "\n", + "box_inputs = ((x, x),(y, y))\n", + "circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + "control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + "\n", + "robustness_1 = torch.relu(-ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze())\n", + "robustness_2 = torch.relu(-θ.robustness(control_inputs, scale=-1).squeeze())" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: loss: 0.575 robustness_regions: 1.917 robustness_control: 0.000 cont: 0.000000\n", + "100: loss: 0.147 robustness_regions: 0.382 robustness_control: 0.000 cont: 0.032289\n", + "200: loss: 0.096 robustness_regions: 0.235 robustness_control: 0.000 cont: 0.024917\n", + "300: loss: 0.064 robustness_regions: 0.138 robustness_control: 0.000 cont: 0.022985\n", + "400: loss: 0.038 robustness_regions: 0.057 robustness_control: 0.000 cont: 0.021156\n", + "500: loss: 0.018 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.017924\n", + "600: loss: 0.012 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.012204\n", + "700: loss: 0.010 robustness_regions: 0.001 robustness_control: 0.000 cont: 0.009703\n", + "800: loss: 0.008 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.007541\n", + "900: loss: 0.006 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.006107\n", + "1000: loss: 0.005 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.005391\n", + "1100: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.004276\n", + "1200: loss: 0.004 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003666\n", + "1300: loss: 0.003 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.003175\n", + "1400: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.002264\n", + "1500: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001913\n", + "1600: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001509\n", + "1700: loss: 0.002 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001680\n", + "1800: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.001105\n", + "1900: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000873\n", + "2000: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000655\n", + "2100: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000678\n", + "2200: loss: 0.001 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000550\n", + "2300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000398\n", + "2400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000499\n", + "2500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000323\n", + "2600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000263\n", + "2700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000199\n", + "2800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000145\n", + "2900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000114\n", + "3000: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000087\n", + "3100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000084\n", + "3200: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000063\n", + "3300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000050\n", + "3400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000041\n", + "3500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000033\n", + "3600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000027\n", + "3700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000032\n", + "3800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000030\n", + "3900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000016\n", + "4000: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000013\n", + "4100: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000011\n", + "4200: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000008\n", + "4300: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000019\n", + "4400: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000008\n", + "4500: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000005\n", + "4600: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000004\n", + "4700: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000003\n", + "4800: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000002\n", + "4900: loss: 0.000 robustness_regions: 0.000 robustness_control: 0.000 cont: 0.000002\n" + ] + } + ], + "source": [ + "for _ in range(5000):\n", + " X = Z[:N[0]*N[1]].reshape(N[0], N[1]) # first bit of Z\n", + " x = X[:,:1].unsqueeze(0)\n", + " y = X[:,1:].unsqueeze(0)\n", + "\n", + " U = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1])].reshape(N[0]-1,N[1]) # last bit of Z\n", + " ux = U[:,:1]\n", + " uy = U[:,1:]\n", + " \n", + " box_inputs = ((x, x),(y, y)) # changes as Z changes (points to the Z tensor)\n", + " circle_inputs = torch.norm(X - obs_3[:2].unsqueeze(0), dim=-1, keepdim=True).unsqueeze(0)\n", + " control_inputs = U.norm(dim=1, keepdim=True).unsqueeze(0)\n", + " \n", + " robustness_regions = torch.relu(-(ϕ.robustness(((box_inputs, box_inputs), circle_inputs), scale=-1).squeeze() - margin))\n", + " robustness_control = torch.relu(-θ.robustness(control_inputs, scale=-1, keepdim=keepdim).squeeze())\n", + "\n", + " robustness = robustness_regions + robustness_control\n", + "\n", + " cont = (torch.matmul(EE, Z) - CC).pow(2).sum()\n", + " \n", + " loss = cont + γ*robustness \n", + " loss.backward()\n", + " with torch.no_grad():\n", + " Z -= lr * Z.grad\n", + " \n", + " if _ % 100 == 0:\n", + " xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + " u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + " # plt.scatter(past.detach().numpy()[:,0], past.detach().numpy()[:,1])\n", + " plt.figure(figsize=(10,10))\n", + " plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + " plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + " plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "\n", + " plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + " plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + " plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + " plt.scatter([-1,1], [-1,1], s=300)\n", + " plt.axis(\"equal\")\n", + "\n", + "\n", + " xs = [x0]\n", + " us = u.detach().numpy()\n", + " for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + " xs = np.stack(xs)\n", + " plt.plot(xs[:,0], xs[:,1])\n", + " plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + " plt.grid()\n", + " if save_fig:\n", + " plt.savefig(fig_path + \"/psi2_margin=\" + str(margin) + \"_\" + str(_).rjust(4, '0') + \".png\")\n", + " print(\"%i: loss: %.3f robustness_regions: %.3f robustness_control: %.3f cont: %.6f\"%(_, loss.detach().numpy(), robustness_regions.detach().numpy(), robustness_control.detach().numpy(), cont.detach().numpy()))\n", + "\n", + " plt.close()\n", + " if (robustness < 1E-2) & (cont < 1E-6):\n", + " print(\"FINISHED!\")\n", + " break\n", + " Z.grad.zero_()" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [], + "source": [ + "np.save(\"models/psi2_margin=\"+str(margin), Z.detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "\n", + "plt.figure(figsize=(10,10))\n", + "# plotting environment\n", + "plt.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "plt.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "plt.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "plt.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "# plottign optimization results\n", + "plt.plot(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\")\n", + "plt.scatter(xy.detach().numpy()[:,0], xy.detach().numpy()[:,1], c=\"black\", s=100)\n", + "plt.scatter([-1,1], [-1,1], s=300)\n", + "plt.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u.detach().numpy()\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "plt.plot(xs[:,0], xs[:,1])\n", + "plt.scatter(xs[:,0], xs[:,1], c=\"lightblue\")\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plotting combined plot (always operator)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"sans-serif\",\n", + " \"font.sans-serif\": [\"Helvetica\"]})\n", + "# for Palatino and other serif fonts use:\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Palatino\"],\n", + "})\n", + "\n", + "linewidth = 10\n", + "markersize = 50\n", + "fontsize = 24" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "obs_1 = torch.tensor([0.0, 0.9, -1.0, -0.5]).float()\n", + "obs_2 = torch.tensor([.2, 0.7, 0.8, 1.2]).float()\n", + "obs_3 = torch.tensor([0.0, 0.0, 0.4]).float()\n", + "obs_4 = torch.tensor([-1.0, -0.7, -0.2, 0.5]).float()\n", + "\n", + "x0 = -np.ones(2)\n", + "xf = np.ones(2)\n", + "Δt = 0.1\n", + "A = np.eye(2)\n", + "B = np.eye(2) * Δt\n", + "u_max = torch.as_tensor(0.8).float()\n", + "\n", + "ts = np.arange(0, 5, Δt)" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [], + "source": [ + "margin = 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAQwCAYAAAD4uqg4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXxTVf4//tfJ2hXSAgKySFMW2SEpuM0gS4riglsD7sso7Wyfj+Myrcw4jp+fjjV14aujM7bMOPqZ+ajQunxmVEZbto+ziNAAIrI2KKsitGFpoUtyfn8kNyRptrZpm7av5+NxH6X3nnty7r3RvnNyzvsIKSWIiIiIiMhD1d0NICIiIiJKJAyQiYiIiIj8MEAmIiIiIvLDAJmIiIiIyA8DZCIiIiIiPwyQiYh6KSGEobvbQETUE2m6uwFElBiEEDYAhe04NUNK6YxjOwwAlgJYIaW0x6vevkYIYQRQCSC7u9vSFYQQJgCLARTH8/3YgfYo72MTgEwAVWjHezrWerzlyr2/Bl+/8kHJJqWs8patBpArpXS0pT1EfQV7kIlIcRxABTwBVYbfpvyxLQnabwaATghGlsITqJdHK0iheYPjagAF3d2WLlQOz/tmaXc3xBus7wNQA8AKYAkAI4BqIYSlE+uxeLe8oE3ZbwB8/80WeevhtwxEIbAHmYgUTgCVwT1KQohaeP6w1gQFw3YhRGf0PlUCyAdQ2gl1h+QNRJYCcEgpi7rqdTuDN+CpBFAmpazq7vZ0oVJ4nmFldzcEwGp47n+Z93c7AKsQogZApRAi1m9d2lOPGZ6eZuBcz7HC1+sspawQQiz2voY55isj6iMYIBORohatv5qNJu5DILxBXUa8643CBk8PW48Ojr1sAIw9PdBvKyllCTzfcnQrIUQhPIFpqA94FfD0ci8CUBbieIfraeMQjiUA6oQQtr72fiGKhkMsiAiAp0eprT2OUkprZ7WniykfDHr0eEzv0Ip8RAm+qFMtBuAMM7ZX6d2O5b+b9tTTpg+43t7nCgCFHGpBFIgBMhF1KSGEyRvIdaSOfCFEuRCiUghhi1SfEMLiLVfn3SpDjN+sjfF184QQpd46SoUQ+R25jk6g9ALaYikshDB6ryk/+B4KIQzeY3mxPq94PNug+pTnXO39mReneo3eumO+tjYwIfwHrU3enzmdVE9M7+MgSg91t4/dJkooUkpu3LhxC7vBM0FIAsgPccwET49lJYBC775SAHXwjGdWyhnhmUQlg7a8oPqM8EwqKvc/3++4xVt3obeskqmhVfu8x6q9dSmTlUq9ZSuDrkG5xnJ4gstS/7Z566rx7jfC89V3vvecOgCWttwXb/v970M1PBkGlPPzvfuU46UxPqs6AHVhjpm8r1vtvRf5aP088v3uc/CxwjD1xvRs2/F+qVHq8J6n3I8av60yXL3e/Qbvtdi85Q3efwe31RbL/Y3h/huD318hykgAMt71+N0z5Xko7+lqhPhvN0Rd1Z35/xFu3Hra1u0N4MaNW2JvCBMg+wVcynEl84T0/4PrLVcHwOT93RgUpBi8+5U0VTWh/mD7BW2tgpkQdRm9rxmqbD6Acr86y71llWCi3LtZ/NpVp5wTpk0SnnG/bbkvrc4Nc12WUMdClDWFC6r82qRcZ6W3TUqw7/88Cr3HTX73SzlmClFv1GfbxvuiPLvSoNcy+JW1edtlCvEM/QNkG859gFI+ACljew0I/KAS/CEnVDaIsFvQM+1ogNzmenAuqFbex5V+9yRaXcozMURqFzdufWnr9gZw48YtsTdE6EH2HlcCIqVn1+ANGpTePQtCB6rloer1Cw6CA+SacIFFcF1KUBSmrAlBvaF+54fq9VR6nU1h6lMCsMqg/RHvi7eM0ivaqnfWWzbmXj2cC2TD9jb7XWeoYD/kB5Og82xB+9v0bGN8vyjHQz2LygjHlOcU6l7KCO1R2hockPv34MeyGdG9AbLSy24MKuf/gSXcf8PKfY3pwxg3bn1h4xhkIoqXTVLKEimlU3om/OUCgJSySoaeIa9MNApeyKLVOEpvGjYjwk9CUsZqmr2TjSwIk2FDSmmXnowHsVoU9BrBlPG+4fLbhrwvXsXen6HyFS9F27JqKJOsYpmotSLEvqqgn/6UZxUwXrcdz9ZfuPsSaUxwpMmUka5bObYyxDHlXgRfm1lKKdqwdesET+/72hzcDu/zUZ5puMmByv2J93hsoh6Lad6IKF6i5p/1To7LhSeYU/4YxzJ73ldWCFGH1inpDPAExDU4N3GpPROWgturfBUPGT5vrcOvvDFEoBT2vkhPLlonAKMQwiS9Kbq8E8cMsm1ZRQZ4fx5vwzn+lOsLdX7Ue9mOZxvuvij3LxeeDAv+jPBkdohnesF4LnSjtD0zYqnorxmvehRKGsNwAbDyfJnJgsiLPchE1Om8mSaUSVLFUsoCxJhpIYhTSpkhpcz29pYpm/J7Cc79kY9Hb5ivjnBpsIIC4vYE5UpKNv9e5CK0/f4oge2AiKWin98mcXy2CiWrQr5/1gpvxhAj4r+oRYc/SIWoK1qgGa23OV71BJeLFlB3+xLdRImCPchE1KmEEEoWCXMHev6UP/Cx9HApZTscIEsp7UII5VcjQgzb8AucnRF6mSMpxblFH5QgeZE30GyLttyjuIjTsw0gpXQIIczwDDEp967W6IDn3me18x63mbdHPOZ76R0m4vS+X0K+9/xSykX8ZiBe9fhRriNceaWnOp4fFoh6NAbIRNRpvMFjHkJ/Ld6WQM5/GEOelDL4q3cf/6BWCFHYxvHG4V7bCM/CDaGCQCVYCTW+NSpvQFgFwOLtMc1E+xb6iPVr+biI47NtxfsMawEUxeH5tZcNnolvMRFCZHu/TVCepSnEfVHGqYcaAx4s5nqEEDZ4JhmG61FWhh0VhzmuvId79EI5RPHEIRZE1JlCjkX1TrpbHmsl3l5DJWhc7j0/gHdhC+V1fAtmhCobQ3v9KXXlhxlmUQDPV9MdWarX5vezAKGXF45GCW7acr3+BgT9jCYuzzYUIUQlPBkXujI4Dvhg0YFJesqzC/UNgBWAPTjg9Q5TKQwq25Z6ViDMe8b7nrUBsEbofTd6rznuS8cT9VTsQSaiaJRAKFxGAiVAahVYeXsCnfBMrquG54+42VtnMTx/uGPq8ZRSFni/WrYAqBZClOHcRK8Z8H7V7y1bIoRQ9vmXdcITQA4Iyr6gBDdLhRDZ3vYVSCkd3ol0ZfAu3iGEyFWCIe+4WAuAeSGCj7D3JcS1VXmHEhgBVLQnI4L3a/kqhM+m4d+mUPfcEPQz0vkdebax3BcLAHgnZG5C67GxlVLK4F72SPX6X3e4IDEuQ1P83y9CiErl2w5vAJyDoDHU3qEchd5/VylBalvq8T4Lo3fISyk89ywTnvtYAE9wHHJ4hTIhFLEP1yDqGzqSI44bN269c8O5Vej8FxpQFiCwecvkITBXbJ339+B8ssGroCmLKvgvQFGJwIU2Qubj9R4vDHrdaoRf5S0PgQsmKKvhGYLKGXAuF2wdQufL9a9LWVAkbP7iaPclzHWFzbcc43PLQ4g8wQhcoCPgnodor3JP80LUG3C/2/Js23JfvGWD33vBW6Vf2VDtD15ARHnN4HzVJr/jNaGefTufhbKyX5233vLg953fe686wvs91nr874NvxcYY2xkytzQ3bn15E1JKEBElCu9X9NXwfIUc74wFCUsZmtDRa1Z6XWVgvuUewzskYDk8QbVV+vWme3s7C+DtcQWQLbs5/3BP5+39N0gpI+WsJupzOMSCiBKN8rV8Xwt8FqN9Y4+DLYEn+4NBdlHGhzirBpAppcwIPuANhou8HybalGWCWvPeRxPCLyBC1Gdxkh4RJRol6NnYra3oenmy9bjaNpOesapV6Fgu4m7h7SE2Ivp4WCfASWVxYANQJiNkhSHqqxggE1GimeH92Wf+aHsnXsXzeq3wpAiLNGEvEcW6QIYJnFTWId4Jppmy7fm2ifoEDrEgokRjgadXq1cPsfAGKCvhud6lALLiVbf0ZLQwA1iN+K8812m87bbDE9yHWrZb+TCRiR50XYnGO87bCmBed7eFKFFxkh4RJQTvIhmLAUBK2avHRHqHEtT47cqVYdJw9TXe4K3a+2sRzvUUG+H5IGGANwVfNzSPiPoIBsgxGDhwoBw1alR3N6PHq6+vR2pqanc3g7pAe571yZMnodfrodfrO6lViaOlpQXHjh1DS0sLBg0a1KOvubP+u66rq8PJkyfR2NgItVqN1NRUpKSkoF+/fnF/LYoN/x/ed/SlZ11dXX1MSjkoeD+HWMRg1KhR2LRpU3c3o8dbt24dZs+e3d3NoC7AZ9138Fn3HXzWfUdfetZCiK9D7eckPSIiIiIiPwyQiYiIiIj8MEAmIiIiIvLDAJmIiIiIyA8DZCIiIiIiPwyQiYiIiIj8MEAmIiIiIvLDAJmIiIiIyA8DZCIiIiIiPwyQKeFUVFQgNzcXubm5yMjIgNlsRklJSXc3q5WysjJYrVbk5uZ2d1OIiIgojrjUNCWUoqIi2O12VFZW+vZVVVUhNzcXeXl5MBqN3di6QBaLBaWlpXA6nd3dFCIiIoojBsiUMOx2O0pKSlBXVxew32KxwGKxJFRwDABGoxFGoxF2u727m0JERERxxCEWlDCqqqoAAAaDodWx0tLSrm4OERER9VHsQaaEcfz4cQCeMch5eXkBx4J7j+12O0wmEwD4hjiECqwVFRUV2LhxI7Kzs7Fo0aKQZWMpU1VVhdLSUjgcDuTk5MDhcLTtIomIiCjhsQeZEkZBQQEA+Ca+FRUVoaKiIiAILSgogBACZrMZDocDBQUFyMjIQEZGBrKzs1FRURFQp91uh9lshsFgwNKlS+F0OpGVlRUwLCKWMk6nE7m5uXA6nSgvL0d5ebnvXCIiIupdGCBTwjAajaiurobFYkFVVRVKSkpgtVqRnZ3tC4htNhsKCwsBeCb0Wa1WSClRXV0No9EIq9XqG6rhdDoxb948FBQUwGKxwGAwoLCwEJmZmSgqKoq5DADMmzcPJpPJ17NtNBpRWloKi8XSxXeJiIiIOhsDZEooJpMJlZWVkFKipqYG5eXlsFgssNvtKCgogMFgQHZ2NgBg6dKlvgDVZDL5enVtNhsAYOXKlXA6ncjJyWn1Gps2bYq5jNPphN1uD5nOLdKwDiIiIuqZOAaZEpaSJSIvLw9ms9kXsPof92cwGGCxWFBbWwsAqKmpAQAUFxcjMzPTV2bGjBm+YDeWMkqPtHKciIiIejcGyJQwHA4HMjMzQ/bK5uTkxBSg1tbW+nqDBwwYAMDT06xM6AsWSxmlPQ6Ho1UZ5kAmIiLqfTjEghKG3W739dYGq6qqgtVqjXi+w+GA3W73jR1WgtkVK1aEPSeWMkrAHZxqzul0turVJiIiop6PATIljNraWhQXF7fKDKFMoMvPzw/Yv2TJEl8PrpLRorKy0jf0QllgpKSkBCUlJb6ydrsdZWVlMZcxGAzIz89HVVUVCgoKfGOSlyxZknCLlxAREVHHMUCmhKGsljdv3jxkZGQgNzcXVqsVVqs15EIhDofDl97NZrOhsrKyVVaJyspK2Gw2rFixAhkZGTCbzVixYgUWLVrUpjKlpaUoLCzEypUrkZGRgaKiIixfvhxGo9EXnDMnMhERUe/AMciUMIxGoy8TRSxWr14dUxaJwsJCX2q4jpSx2Wy+DBmKtrSXiIiIegb2IBMRERER+WEPMhER9UlH64/i7vfuxpp9a9Doauzu5vQM67u7AR2jV+sxN2suXrv+NZyXel53N4cSGHuQiYioT7r7vbuxau8qBsd9SKOrEav2rsLd793d3U2hBMcAmXqUkpIS3zhgq9WKioqKbm4REfVUa/at6e4mUDfhs6doOMSCepRYJtMREcWCPcd9F589RcMeZCIiIiIiP+xBJiIi8pK/lt3dhIS1bt06zJ49u7ub0S7iv0R3N4F6GAbIfUhzv18Apxo93xso/68Q3i3aPpXf/lj2hahPPjwdzfc+1OWv265z4t2u7nrd9tLpof3FUx2ogIiIqOfiEIu+5JR3zJV/4CTQdfsQY7nOeN2ufL1E2tdeTRyfR0REfRcDZCIiIiIiPwyQiYiIiIj8MEAmIiIiIvLDAJmIiIiIyA8DZCIiIiIiPwyQiYiIiIj8MEAmIiIiIvLDAJmIiIiIyA8DZCIiIiLqVg6HA2VlZd3dDB8GyEREREQ9SEVFBcxmMzIyMgI2IUTIzWq1+s612+0oKiqC0+mMW3s6UqfVakVGRgays7NRUFAQ13Z1hKa7G0BEREREscvLy0NeXh6qqqqQm5sLAKiurobJZPKVcTgccDgcKCoqgtFo9O23Wq1wOBwAAJvNFpf2dKROm80Gh8Phu45EwR5kIiIioh7IP/D1/7fyu8ViweLFi5Gdne3bX1BQAIPBENeAtCN1Ku00GAxxa088MEAmIiIi6oEyMzOjljEYDAHlCgsLUVdXB4vFErd2dEad3Y1DLIiIiIh6qfz8/O5uQo/EALkvSdcDpxoBCUB49yn/7op9/rr6dbvy9RJpX3vp9B04mYiIEoEy4a29wxccDgeqqqqQmZkJk8nUahhHrG0oLi72jYk2Go3Izc3FokWLIrYrHq/dEQyQ+xDtyae69fXFunXQ1tzerW0gIiLqK6qqqlBbW+vrRbbb7di0aRPKy8uRm5uLwsJCAJ4gdtOmTaisrERFRQVeeOEFFBUVoaSkJKC+wsLCVpPwwtWpHJs3bx6WL18Om80Gp9OJlStXoqCgAJmZmcjLywvZ7lhfuzNxDDIRERFRD1dbWxvwu9PpRGVlpe/3qqoqFBcXo6ioCFVVVQFli4uLYbPZUFJSAofDgWeffRYDBgxAXV0d6urqfIFpSUlJwLmR6gQ82S0WLVrkC4QNBgPy8/MDguhgS5Ysiem1OxsDZCIiIqIeLjs7OyD3cUZGBsrKynwT9CwWC8rLy7Fo0aJW59pstoBg2mw2o7CwEAaDAQaDAYWFhb4gt7y83FcuUp3AuVRzwRYvXhyQks6f0gsd7bU7GwNkIiIioh6upqYGUkrfVldXF3KCXqRxv8qxOXPmtDq2ePFiAAgZ8Iar02AwoKqqClarNaD3N9KY4lDBdqTX7iwMkImIiIh6uOCUb0pe4uChF+3Vnol+y5cvB+BZ+S83NxdCCGRnZ7caX9wZr91RDJCJiIiIeiGLxRK33MSx5FwOlpeXh5qaGhQWFvp6jJXV/cxmc6e+dkcxQCYiIiLqhQwGQ5enRwtmNBphs9lQU1MTMOnObrfDbrd3a9siYYBMRERERHFntVoDflcm3SljoxNteWl/DJCJiIiIeiD/8cXxGmvclteMxOl0RpxUZzQa29y73VXXCDBAJiIiIuqR/APQWDM8KKvrHT9+POyxkydPRj0/Wp21tbWw2+0oKioKKFtWVoaVK1cGpJXzryNSEBzqtTsLA2QiIiKiHqSiogJmsxm5ubm+fVarFWazGRUVFRHPKSsrA+BZeMNsNvvSsGVkZPjKFhQUBNTtz+FwIDs7G2VlZRHrBDyT9CoqKnzZK8xmM2pqarBv3z5f73HwawdfV7jX7mxcaroPqKiowMaNG5GdnR117XMiIiJKbHl5eWGXaW7POcGZLtatW4fZs2cH7DOZTJBShqw3nFgW9oilTLjX7kzsQe7FnE4nzGYzDAYDli5dipqaGmRlZXVpom1KbKF6CUpKSlBQUNBNLSIiIup+DJB7saKiIixevBgWiwUGgwE2mw1Go7HVeCDqexwOB0pKSrBp06ZWx0pLS5Gdnd0NrSIiIkoMDJB7sbKyslZfm1gslrDjk6jvMBqNKCwsRGZmZkAPsjLrOF6J5YmIiHoiBsi9lDJAPjiFyowZMwB07XrmlLg2bdoEk8nk+33lypUAELCPiIior2GA3EspqVCCJ+Qpv3dlqhRKTA6HA06nEzk5Ob59NpuNvcdERNTnMUDupcL1EHfHeuaUmOx2OwwGg+9DU1lZGYxGY8je45KSEt+KSGVlZcjIyIDT6YTT6YTVam01qe/NN9+E1WpFdna2b0hPUVERsrOzfUuLWq1WlJSUdOYlEhERtQvTvPVS0VK5MdUbbdy40dd7XFFRgZycHBQVFbUKdu12O4xGI2pqanzj2p1Opy8JfPAwHqvVirvuugvXXHMNzGazr7xSrzIJ0Gaz8QMbERElJPYg91JK4BE8lEJZoYaBCdntdtTW1qKkpMTXk6xM0vPv2TWZTKitrYXD4cCiRYsAeMa22+125OXlweFw+Cb6Kd9cpKWl+epS6jYajVi8eDGqqqqQl5cHo9HID2pERAni+PED+Pf7Rdj4xlXIPuL5+e/3i1B7/GB3N61bJHyALITIE0LUCCHatmD3ufMNQgibEKJSCFHt/Xevn4Gk9OoFD7XwD1iob1PeA3l5eb5xx8q+wsLCgLLV1dXIzc2FwWDwDZFQksNXVVX5zi8tLcXixYsBhM6iogTbwb3ORETUPXZ/uQb2v8xB2qpsTHP+P8zAKoyQn2EGVmGa8/8hZZUR9r/Mwe4v13R3U7tUQgbI3qC2UAhRA6AcQHuDYxOAfQBqAFgBLPHWVS2E6NUzkZRxpEo2C0V1dTXy8/O7o0mUYMrLy1FdXe0LVo1GI+rq6loFx4DnfaS8bzZu3OgbLuFwOAKC3aqqKphMJhw+fBgbN25stQiJ8n7kJFGi+KiqqoLZbEZGRoZvE0IEbBkZGcjNzW3190ChDIHKzs72LQlstVqZ7agP2PDRkxhhvwpTxXroVc1IVjUFHE9WNSFJ1YypYj1G2K/Cho+e7KaWdr2EC5CFEPkA6gAsBVABoCN/SVcDKJNSlkkpnVJKu5TSCsABoFII0au7UQsLC1FcXOwLRpxOJ6qqqrB06dJubhn1JMEZUex2u69nuKqqCjk5Ob4/vMof1CNHjgDwBN0Oh8O3OZ1OWCwWVFVV8Y8vURxYLBZUV1dj6dKlvomzdXV1kFJCSomamhrff3OhgmSHw4GsrCzfJN28vDzU1taioqIC2dnZ/O+0F9vw0ZOY8t2TSFY1Qi0iL+OsFhLJqkZM+e7JPhMkJ1yADKAWQIGUMkNKWeT9vc2EEIUADABKQxxWVspY1L4m9gw2mw1Lly71ZRkoKipCZWUlh1dQm2zatMk3nALw/EFVvqFQxhn790JXVFTAbDYDODfBz2q1orS0FHl5eb73Iv/wEsWP8t9g8BA6o9GI8vJy33+zNpst4LyKigrft0eVlZUoLy/Hvn37fPVx2fneafeXazDl6BNIVjW26TwlSN6zY20ntSxxJFwWCyllvJZ5WwzAKaUM9Ve4EkAhPMMuyuL0egmpsLAw5FfmRLGyWCwBY4lramp8/w5+f1VXVwMA1q1bh/Ly8lb7lfr86yCijovW8WGxWGC321t9MFWCYv/zDQYDSktLkZubG3I5eupZpJQ4fPgwqqurYbfbUV1djfvGf4zsKU3RTw5BJ5pwqvoJYPycOLc0sSRcgBxHJgD2MMeU/+JzwhwnIiLqNZShUqEmzoaaNKukgOSE2p5FSolDhw6huroa1dWb0LhrJya4m5AqJPY5T6B8y3Z813gcK28C1O0cQ6AWEhPkP1B7/CAyBwyP7wUkkF4ZIPtlvAg5PENK6RRCAJ4hGERERL1aVVUVDAYDioqKAvYHD7lQKD3NHGKRuKSUOHDggK9XWNmOHj2KUYZ+eP/WmzB01BCkajVQqVRodrmQb56Kw5q1AL7o2GtDYNe/X8Il1zwdn4tJQL0yQEY7s14QERH1Jna7HUVFRTAYDKisrIy5R7i4uBgWi4VZjxKElBJfffUVPvzwQ7z66qvYunUrXC5XyLKDUpLxjx/ciszkJGhU57qJtWo1tGo1sgc3Q6frWHuSVU3QnOxYkJ3oemuA3GHebBr5ADB48GCsW7euexvUC5w+fZr3sY/gs+47etuz7qnXsnXrVgCeoRTDhg0DABw+fBgAYDabsXDhQuzfvx/79++PWM/hw4fx5ptv4siRI3j22WcD7gefdddwu904ePAg9uzZgz179mD37t3Ys2cPTp8+HdP5D1ycg/56XUBw7E+jaY5LO4eovkvYexgPDJDDkFKWwTuBLycnR86ePbt7G9QLrFu3DryPfQOfdd/Ro5/1+ta7euq1tLS0+P596NAhAOeyzBQXF+Pxxx+HwWDA8uXLA7LSKCoqKmC1Wn2pGQHg3nvvhc1m85Xns46/lpYW7NixA3a73bfVOmpwxcjzkZGchMxT9Ti4axdON5yJqT6VEFhingK9JkJ45+5g97HXN+5BCXEPO0tvDZCVabrR1lPmagVERNRrBGejMJlMKC8vR0lJCYqKimC1WlFTU9NqqIXJZIKU53LhlpWVoaCgAFarFeXl5SGDamqbxsZGfPHFFwHB8Oeff46zZ88CAPrr9fjLjVdh1vdMEAJI0mjQ0NyMpy2z8NYXO/DTD1ej2e2O+BqZyUnQa9QRy8jGQZDuPRCq0EM0YnHGrUOLYVK7z+8JEjEPcjwok/OiTcJjIlYiIur1/NMxlpa2Xh4gOGDOz8/3jT8uLi7u3Mb1QidPnsSKFSswa9Ys6HQ6CCGQlJSEnJwc5Ofn45VXXsFnn33mC45TtBqsv+dmXD5qBJK1GiR5e4BTtFokazVYNPFCVCxaCBHldZtdbqhE5FLuExM7fH0CEuMu+WmH60lkvbIH2S9LRcjZCH5ZLkKvu0lERNTL+K9sGYvc3FyUlZVxUZ8IlEwSW7ZswdatW7FlyxZs2bKlzfdsiWkKRhn6+QLjYKk6Lb43cjjmZ4/CRzVfha3nRGMj9p84idGZGeFfzJUC1+lRUKXVIMww5YhcUuBLfA+mXpziDeilAbJXFQCLEMIkpQzOh6wkglzRxW0iIiLqVkpvsdPpjLjAiHKMuZA9GhsbsWPHDl8QvHXrVmzduhV1dXUYlp6GK8dkYbhWC6lT45BajcYwWSZCeeCSHKRotRHLpOt1ePjSGREDZAB45p8b8fwVc5CqC1/f2aNmqJNqkNyO4chNUod086/afmIP0ysCZCGEDcBxKWWJ3+5SeALhAu/mzwrAHiJwJiIi6nWUCXsAsHjxYgCeccYmk6nV4iEKu93zJ3Lp0qVd08gEcvz48Y43YlAAACAASURBVIBe4a1bt+LLL78MmAwJABlJSXj35usxzzgSLrcbGpUKjS4XBASe/L9Psezf0VciTNVqMSglOaZ2TRk8KGqZ/966HXkTxuLSEcM8QbIEUA+gBYAAGrTNeH7TAXyrAZ67DUjVx/TSAIAzbj0+H/QoLurlq+gBPSNANvr9bPWdhRDCAs+y0RBCVClBr5SyQghRBiBfCFGpLGEthCiEZwU9c1c0noiIqLMpK+WFs2TJEgCescgmkwmAZ1U9ZdJeKMXFxcjPz+/VE/RaWlqwevVqPPfcc1i/fj2ampoghAiYsBhOuk6Hf953C0b0Sw/IGqH8+7HLL8aglGT8YvUnEeuRkEDU0cWxc0mJG1b+FY/Nuhj/OdYE/Qm18kKQAtC6VJjiGoT7/qUH0IjnbgOStYg43MIlBZqkzhMcX/Fo3NqayBJykp4QwiaEqBZC1PntrvTuKw8qvgmeJaVb9QhLKZXe4wIhRJ0QogbADABZUkoOqiIiol5B6R12Op2+YNnpdKKqqgpmsxkVFRXIy8sLWDnPZDLB4XAgOzsbVVVVvvOUc/Lz80NO6OuRJICTAPYA+CeAd4Dp06cjJSUFV155JSorK9HU1OQpGkNwDABF35uJ4UHBsb9UnQ4/njkNFw6MnFCrobkFh09Fz3HslhKfHToS8pharcbtt9+Oxx57DMnJyWhqaUHTURdcxySEFJ4NAiopoFWpccXQUfjn/FvxxnodLn8CeHcTcLZZoNkVeC1n3DqcdWuxVc7GQfOqPhMcAwnagyylLIpeylfWiQi9wf75jImIiHqbqqqqgCWkMzLOTdAyGo0wmUxYvny5r+fYX2lpKcrLy2G1WuF0OmE0GmGxWFBeXt5jxx6fOnUK27dvx+eff45t27Zh27ZtwGcAglIJy8GHUHSJGRlJSdjnPIG3vtiJYzHmG9aoVCjImRp2Up1/uZ/OnI6ffrg6Yrnn/rURxZZZEccNNzQ34y81+5GdnY2DBw+iqakJqampuOuuu/DAAw9g1apVuP/+++F2uzE6zYCHLsxBsiZ0fXq1BiNS0vHIhJn45ef/wIubZ2H6f7yMb3f8BZqTX2CI6jt84x6EFsMkjLvkp71+Ql4oCRkgExERUWwsFkvMvZ7B/NO59TQtLS3Ys2dPQCC8bds27Nu3L+J5w9LT8Pai6zBuYCb0GjU0KhUampvx1Lzv47UtX+CBv6+FK8r9HGXoB3WUdGoAoFOrcfmoEVHLvbrlC9w1bSImDBqA5BCT9VwqNfSTpuLN4hchgl7X7Xbj5z//OZ5//nnfvp+MnQ6ViDxIIEmtQf7oqXhyx2f4+OOPodfrYcx+GkAPXxQmThggExERUY/w3nvv4bHHHsP27dvhjrJoRigDU5Lxz3tvxaCUZGjV5xbUUDJI3DFlIjKSknDHux9GrEclBGL9SBItL7FarcaFEyfiT24d7k/tj+yWsxBqNYTLDWg0gNsNzcxLoZ5/Tavg+MyZM7j99tvxzjvvBOyfO3gk9OrIC4YobSv6wRLo9W2YqddHMEAmIiKihCalxC233IIVKzqWnbXospkYkJwUEBz7S9Vpcc1YI3LOH4JNh78JW8/XzpMxTatrcbnw6cHDAftUKhWuuOIKXHfddTCZTJg0aRKSk89lsZCnT0Hu2g555gxEej+ICydC6JNa1f3dd99h4cKF+PTTT1sdixaU+7v7rrtiLtuXMEAmIiKihFZcXIz1H7yPxy6/BLdOHo80nQ5HTp3GS59txsrtu3AmKP1aKFqVCj+YPjnspDpFkkaDBy4247Z3PghbptHlwmtbtmOJeUrEpZ2b3RK/q94GIQRSUlJwxx134OGHH0Z2dnbYc0RaOoT54oht3L17N3Jzc7F///6Qxz87fgTZaf2hUUXuRU5JSkKGeVrEMn0VA2QiIiJKWCdOnMCnf34NO37yA6gEfGN0z0tNwfNXzMHjsy/D3NdXYJ/zRMR6RvRPj6nXV61SIef8IVHLPfXJp7hpwhgMDBqu4aPVImX6TGx66oUYXjV2n3zyCa6++mqcOnUqbJkXd9lx04ixEQNkqRLQzLkIIsLEwL6MATIRERElrPLfvoD/vu7KkBke0vU6pGg1WHPXYox/+VWcjdCT7Jay1RjeSGVD0ev1mDRpEqZNm4apU6fi8IXjcN6ebcDx7wC3C3C7Aa0WkBJixqVQ514T20XG6K233sKdd96J5uZmnKdPwQ0jxmCgLhnHms7g3QN7cLSxAQCw1fkdyvfvRt7IsUgNlclCJSDSUqC+aX5c29ebMEAmIiKihFRfX4+BO7YiKWtk2DJqlQr9k3SwThiLP3/+ZdhyB06cwtmWloip1ACg2eXC+q8PAPDkSrZYLJg6dSqmTZuGcePGQRM8RCN3PuS3R+DeuR2y8SxERiZUk6ZBJKfEfqFRSCnx9NNP4xe/+AWS1Bosv2gBbhwxBi4pkazW4IyrBc9MuxxvH9iNH26sRKPbhYKNH8PZfBYFo6cCQoUklQoQAtBqgKGDoHnoHghDv7i1sbdhgExEREQJqfCBB2C7YATUkZZ5A5Cm0+GnM6dHDJBdUuLljZvx80tnhEylpmh2u/H1kJHYs2cPRo8eHVM7xeChUA8eGlPZtmpubsaPf/xj/OEPf4BGqLDq8hsxPWMwktTnQjill/iG4WMwMqUf5q8rh0tK/HzzeuyfNhrP5d0BccwJJOuhzpkEkdX38hq3FQNkIiIiSjjbt2/Hprf/BlX+zTGVH5qeFrXM89s3IW/aOBjT+gcEmD5aLVIvnY2nrry2rc3tFCdPnoTVasXHH38MALCOHIupGechJcwCICkaLaZnnAfriHF4a/9OPPHEE/jlL38Z89ASOocBMhERESWcx+/8Cd4fcCM0qtiCu1ONTb5/9+/fH5MnT8bkyZMxZcoU/Gjjj4DzgIakFsySb6LUPR83qScAapVn3LBKDQgB1excqC69vJOuqG0OHDiAq6++2rMSoNdDF85AmkYX8bw0rQ4PXZiD945+hUcf7TtLQ8cbA2QiIiJKKEcOHcZT341GukYHUSeAgZHLNzQ340tNEj744ANMnjwZw4cPD+g1/dG3P/L9+6Rowi3q9+F+6A3IPTsgm5og+vWHGDMeIkoKuK6yefNmXHPNNTh8ODCH8oR+A2I6f0L/Abj33ns7o2l9RmK8E4iIiIi8/uen/4UfqJOhFirgCwCXAYgwty4pORk3/fJRiLT0mF9DpKVDTJ/Z4bbG24cffohFixahvr6+A7UIPPDAA3FrU18UedQ7ERERURfavHkzhv7rINKENyI+BGAXgObWZaVb4mxzC7S33NOm4DhRPfHEE7jmmmvCBsdfnjweUz1nBvSLuBgJRccAmYiIiBJC/enT+DTv17gpdWzgxLKtAP4B4DsALgAtnp8tX7vx0VcSqjEXdkt748XtdiMvLw+PPfYYZJgczADw7I6NON3cFPY4ALi1GmTcfl28m9jncIgFERERJYRV1z6MW9yjQqd1O+zdtPBEL03A2WYXLnphcdc2Ms7OnDmDG264AR999BEA4LKBw3Dd8NHop9Fhz6k6/OXrL/HtWc8CIOUHduG+7MnIyRwSOpOFVgP16JEQF0/tykvolRggExERUbf7S+kfce1XOqSooix93AzfcAttRjqGX3tZp7etsxw9ehQLFy7Ehg0bMDrNgPe+fz3OT05DsloDtUqFhpZm/HrypXh933b8zL4GLilx9fp38LscC6wjx0Gt1UIrAei0gNsNcck0qO/Lgwi19DW1CQNkIiIi6lZbtmzBrkdfxQ3pM2I+p97djPRf39pjc/zu3LkTV111Ffbt24dhyWn4h+UW9NfqA3rPlV7i20dNQLpGh7s3rEKj24Wfbvs/DH3wXswfMBw4VQ+kp0I1czJEv+i5oCk2DJCJiIio2+zbtReOhU9gafoMaEX0nk8pJVrgxtMN1Xj6uhe7oIXxt27dOtxwww1wOp0AgF9PuhTpQcGxv1SNFtcNH42puwbhiE7g/fffx4wZsX+YoLbjJD0iIiLqFp999hk+txRhnnpYTMExADTDjadObMBp6/RObl3n+POf/4z58+f7guNUjRaLRo6DNspy2nqVCvePM2PDhg0MjrsAA2QiIiLqcu+88w5+dPlCXK4ZFn3csR+XlHineV+Py/MrpcTjjz+OO++8E83N53LWZaX2R4t0Rz1fo1JjXtY4jBo1qhNbSQoOsSAiIqIuVV1djZfveABvD1qIFBF7KNIkXfis+Rs8t+JPPSrP744dO3D99ddj9+7drY65pBsCsY2jHnDeoHg3jcJggExERERd5vDhw/i/a5d6gmOVNuZJds3ShWOuM8h+91FkzZjcya2Mn5UrV+KWW26B2x26l3jvaSdcEXIfK1wqAX1Oz7nuno5DLIiIiKhL7N27F7+5xIp7dBciVaWLuedUSolVDV/hd/O1PSo4XrNmDW6++eawwTEANLvdKKvZijMtLRHrUqvVUF/5vXg3kcJgDzIRERF1uuPfHIVt1q14TncJklV+4YcEosXJJ9yN+MGp1bA/sqVT2xhP//rXv3D11VdDSgmDVo+7jBOxYKgRGiGw4fgRlO7div0NpwAAxV9uwLXDspGV2h9J6hChmU4LVd58iEGZXXwVfRcDZCIiIupU8mAtmub+BiWai5DchjHHAHDG3YI/ntmOtypW9phxx2+99RbuvvtuNDY24rYLxuN3ORa44clYAQAzBwzFT8eaULZ3Kwq3rEd9SzO+X/UmXjZbcN2IMdAlJUElBCAEoNNAdes1UM+e2b0X1ccwQCYiIqJOI880ofmm38LQqIJGFSbsCNOLfMbdjGMGNRZ9UArjhHGd2s54kFLiqaeewqOPPgoAuG7YaLycY0Fy0LLQSi/xfdmTcdblwq+2/QMnm5vwMmpxpe0BpB4+DjQ2AYMyISaOhoiSAo7ijwEyERERdRr5181wO+uhEVGCvKB5ai1wo/kGE7J+cytEsq7zGhgnTU1NKCgowGuvvebbt8w0x7caXiipGh3uH2fCsl2bMO+6a/H6668jOTkZyLqgC1pMkTBAJiIiok7j+uP/Qd3oatM5De5m7FliQs4v7+6cRsVZXV0dbrrpJqxdu9a377KBw9Bfq496rltKPPK9+XjorbegYk9xwmCATERERJ3n2xOBvys9xWEm5rVIN3RDM2F+5M5ObVa8OBwOXH311di5c2fA/tHphphydKRotLjvymsZHCcYPg0iIiLqPKGGR0i/zU+9uxn1SQJJ5f8JoU78EKW8vBwTJ05sFRwDQKPLFXx5IUkA6QMHxL1t1DGJ/+4jIiKiHksumIxGGSLHr/T7KYGz7hb8f6c24OSK+yCGJ346s0ceeQSLFi3C2bNnQx5fd/QAtDH0CoskHVTmCfFuHnUQA2QiIiLqNHsvOS/8SnHe4Pi0qwmLj/4Ns//0SxinJHawKKXEgw8+CJvNFrHcN2frUfXN12hyRRl/nZIMMWlMHFtI8cAAmYiIiDrNxiN7seT4R2hwN8MdIlCudzfjlVNb8XVWMhYuXNgNLYxdY2Mj7rrrLixbtgwCwBVDRuGj2Xk4eN0P8fXCfLx+0QJMyzjPV75g48f4trEBja4wq+Ql6aD5+Q+Yxi0BcZIeERERdZrNmzejvGE3DrhO4df9L8X3koahUbqggxq7W+rwmxOf4t2GPbjnhnu6u6kRHTt2DDfeeCM++eQTJKk1+Ov3b4A5czDStefGWFtHjsXC4aPxyt4tWLr1E3zXeAYzP/oziqfOwq3Zk6BLSvJMTmxugZg4Guo7FkIMG9x9F0VhMUAmIiKiTrNli2d56E8bj2DB0beRoUrCeapknJBN+MZV7ys3bdq07mpiVLt27cLVV1+NmpoaAMB/X7wAMwcMaZXjWKNSQ6NS44ejp+FAwyn8bs8W1LU0oeWe65Fy1z2QXx8CXG6IYYMhMvp1x6VQjBggExERUaeQUvoCZEWd+yzq3K0ntk2fPr2rmtUma9euxY033gin0wkAMKb2xxVDs5CsDh9CpWq0+NXES1C6dyv+9v77WLBgAQBAjO8ZS2UTxyATERFRJ/nqq69w4sSJ6AUBTJ06tZNb03avvvoq5s+f7wuOAeD2rAkxBU9aocLji+7wBcfUs7AHmYiIyEv8VyxLO/Rh69tY/ssYy2UA/Zf1b2trOo3b7cYvfvGLkJkqRqX0hz5C77FCJQTuu2lRZzSPugADZCIiIuoc38RYbkintqJNGhoacOONN+Kjjz4Kefx40xm43G6oo2SeSEpJRv8LRnZGE6kLcIgFERERdY4EDZD1an3I/Zs3b8b48ePDBscAsHL/Lpxxh0nb5kcjVBBTxra7jdS9GCATERFR54g1QB7aqa1oZW7W3IDfW1pa8Jvf/AYzZ87E/v37AQB6lRrDktPQXxsYTG+s/Qb7Tp9AszvCAiA6LcTlMyCSQgfilPg4xIKIiIjirx7AyRjLdlEPsl6tx9ysuXjt+td8+/bu3Ys777wT//73vwEA49Iz8IsJF+OGEWPgkhJaocK2E9/h6S8/w/8e2gsAuO7/3sU/cm9Fpi4JScHjkXVaiKzhUN95XddcFHUKBshERNQnyV+HWf6YQlq3bh1mz54dc/mqqipcu2wBbhw/BuMGZqDR5cJqx35sOHgkoNygQYPw7bPfQoiunSAppURpaSkeeughNDQ0AABmDRqO975/PZLUnnzGCnPmEPzp4ivxJ8cXeGjzOhw8cxqmv/83fj1zLvKNU6B2uwEpAUM/qBbOgWruxRAadbiXph6AATIRERHF3em1H+HQwz8EAKTqtHBLiYcvm4HDJ09j0cq/4cvvjgMAxo4d2+XB8ZEjR3Dvvfdi1apVvn0GrR7vfv96pPmtjOcvTaPDPcZJ+PTYYZQf2I1x5um4+e0/QT9wIHCqHlCrgdTkLr8W6hwcg0xERERx5frnWswRTUjX65Cu10ElBDQqFdJ0OozONGD9D27GmEwDAPh6b7tKeXk5Jk2aFBAcA8CdWROhihLcpml0WDrhYmg0GqxZswbnnXcehEoF0T8dIi2FwXEvwgCZiIiI4kbWn4Z77d+Rogn9JbVKpUKaTotlCzwT5Xbu3Nkl7XI6nbj99tuxaNEi1NbWtjp+V9ZEpAYtHR3K6HQDHr4vH0lJSZ3RTEoQHGJBREREceO2b4AEEKkvVa1SYdao4Tg/PQ1HTtd3eptWr16Nu+++GwcPHgxbJl0TemhFsGbpxg/vuideTaMExR5kIiIiihu53wHREj1P8NmWFkwZPAhpaWmd1pZjx47htttug8ViiRgcA8ChM6diqjNVp8fISRPi0TxKYAyQiYiIKI7aMA5XAHfeeWfcW9DU1ITnn38eo0aNwhtvvBHTOb/bswWnmpsilpEA1JPGQqSlxKGVlMgYIBMREVHcCOMYNLrdUcslqTX4/OgxPPDAA3F7bSkl3n33XUyYMAEPPfQQ6us9wzcuSOuHO8dMxJJxU3D5kBEhQ/j3Du3F8cYzaImwAIjQaaGyXhG39lLi4hhkIiIiihvVtJmQH74bsUyLy4VKx1dYdM+9yM7Ojsvr2u12PPjgg1i/fr1v3/kpafjTrCtx8XnnwyXdUAkBl1viVHMT7v90Df73672+ss1uN+auWYG1827G4NR0JPmH0VoNIARUP7kVqjEXxKW9lNjYg0xERERxcxbAA6vWoqGpOeTxFrcbJxub8LMP1+Keezo+2e3w4cO4++67kZOTExAcD0lOxYbrbsP3Bg9DskaDNK0OKRot0nU6nJ+ahtcvX4Bbs8cH1NWUnoKdP7gaqT++FcgaBvRLAwZlQFx9OTTLHoH6oikdbi/1DOxBJiIiorjZtm0b/lj9Oeobm/D8gjnQqVXQq9VwS0BC4otvj+H2tz/A0cYmjB8/PnqFYTQ0NODZZ5+FzWYLmUt52cVzkKlPhlYVui8wRaPF7y6z4G/7a3CquQnXX389ysrKMGjQIACAalZOu9tGPR8DZCIiIoobu90OAHjri50o374L80ePwtgBGWhyubF2337sPObJQTxjxgxotdHzDgdzu934n//5HyxduhSHDh0KWWaAPglXjTCGDY59dUmJO0ZPwIzC+3HXXXdxoQ/yYYBMREREcVNdXe37t0tKrNqzD6v27GtVzmw2t7nu9evX4z/+4z+wbdu2iOVMAwej0dWC5DCLlSjStDrcc9FlyLn77ja3hXo3jkEmIiKiuFF6kKMxmUwx17lz505cd911mD17dtTgGIBnyegYO4PHjh4Tczuo72APMhEREcVFU1NTTAEsEFuAfPToUTz++OMoKyuDy3Uu/dqF/TIxIjUdp1qasOnYt2iRgWnlttcdg14VPcRxqVRIndz+cdDUezFAJiIiorj44osv0NwcOnuFP61Wi0mTJoU93tDQgGXLlsFms+HUqXMr3F15fhaeNs/CBWn90Ox2Q8Az8e+3OzajeNsGX6B8sP40Pj16GJcPHeHpTQ5DrVJBdfnFsV8g9RkcYkFERERxEevwikmTJkGv17fa73K58Nprr2Hs2LF49NFHA4Lju7In4q3Lr8EEwwCkarQw6PTor9PDoEvCgxNz8Ld5N0DtFww/8Ola1Lc0wy1l6EbodFAtmAPRv1/bLpL6BAbIREREFBcdGX9cWVkJs9mMe+65p1V2imEpaXhx5jykaEJnvUjVaHHxoPPxw3HTfPv2tzTinaxBEJkGwD8Y1+kArRaqa+ZBdR1XxaPQOMSCiIiI4sI/g0Uk/hkstm3bhsLCQvz9738PW/6HY6ciWga2VI0WD03Iwcs7N+O+++7DE088gSFDhkBKCbljD9xf7AKamyGGDYXqoukQyUkxtZX6JgbIRERE1GHNzc34escOPHixGbMuGAG3lFj71QH899btONHYGFDWZDLhwIEDePDBB/H2229DhhsG4XXdyNFIUkcPWTL1Sfjx4lvx8vLlvn1CCIgJY6GaMLZ9F0Z9EgNkIiIi6rBdr/8Ru398D6SUSNF5hkLMGTUST865DA9+vA5/3OzJbqFSqbBixQq89NJLMU3oAwCdSh1TOZeUKHzwwfZdAJEfBshERETUIa4N/8QFjp1I0gaGFaneQPnZ3Nk409yCN77YASklli1b5iuTptFiauZ5UAuBnSdqcfRs62Wjd52oxai0/hEzUgBAij4JGVPCZ8cgihUDZCIiImo32dwM98cfIEkdvpc3VafFc/NnY8X2nXB5h1MM0Ceh2DQLi0aNQ5PbDUAiSa3B6iP7UbhpHfaccvrOf3GnHd8bPBzpWl34dghAc/E0iKTW2TGI2opZLIiIiKjd5I7YFgbRqlVYMDoLADAoKRkbr74Dt2RdiBRvyjaDLglJag2uPH8U/n3VbZhsGOg7d82R/fi87jucbWkJW7/Q66G+gVkpKD4YIBMREVG7ub87CjQ1Ri2XpNFg7IBMAEDZJVfgvKQU6ENMvFOrVEjT6vDOnOt9+ySAZ1uOoyVrGKDTIiClRZIeSEuFZumPIAYPbFUfUXtwiAURERG1m9Bo4BYCIkomCrdbosnlwtDkVMwdMhK6CEMyVEIgU5+E2UNG4GhmOp555hksWLAAQgjIrw7CtfpfwLfHgOQkqC4zQ5gmQWhim8hHFAsGyERERNRuInssmqtWIfzoYA83JNbs24+5Q0b6loSOJFWjRcHFs5BX/ho0mnPhihg1HJp7F3Ws0URRcIgFERERtcuBAwdQ8F9PwHHsONzu8EGvy+3Gju+O48tjx6FXaxBlzQ8Anl7k+ZfPCQiOiboKA2QiIiJqk2+//Rb3338/Ro8ejT/84Q9YXPE3nGpqhqvFDdQDOAWgAYAEWtxunGhswm3vfgAA2HuqDm5EHo4BAC61Cv3Hj+nU6yAKhx/LiIiIKCa1tbUoKSnBb3/7WzQ0nMtXXFN7Au9/WoObR10IqZKeWXXebuK9zXW49sN38fWJkwCAT749iNPNzeinjZyOTa1SQXVZTmddClFE7EEmIiKiiE6ePInXX38dWVlZsNlsAcGxWgi8P+9GXD9iDNRCBSEFBITnpxQYLtPx83EzfOUlgAc3rkV9S4RV9HRaiCtmQaSldOJVEYXHAJmIiIhCamhowLPPPguj0YjXXnsNJ0+ebFXmjuyJyBkwGKkabcg60rQ63GYcj0sGne/b58hMxf7LpgJajSdtm0KjBrQaiDmXQG29Ku7XQxQrDrEgIiKiAI2NjSguLsYzzzwT0Fscys8nzkBahBXuACBJrcFDE3Lw8/3b8OSTT+Lmm2+GSqWCPFUP9/oNkNt2Ai43MPoCqOddBjEoM56XQ9RmDJCJiIgIAHD27Fn84Q9/wOOPP47jx49HLZ+i0WBUWv+o5dQqFWYNHYmdH5dDpzsXTIv0VKivmQtcM7dD7SaKNwbIREREfdyZM2ewfPly2Gw2HD58OObz1EIFGUNGCgBISU4OCI6JEhkDZCIioj7qzJkzKC0tRUlJCY4cORJwbMbAIcgfMwXGdAPqms7iDccO/PVATcAiH6eam3CiqRGDkqJPptOMPD9qGaJEwQCZiIioj2loaMArr7yCkpISfPvttwHH+ml1+N+5N2BaxiAkqTVQqzzz+WcPGYEXW1pw1eq38XndMV/5F3fYsXTyRUgJM0kPAOpdLeh3raVzLoaoEzCLBRERUR9RX1+P5557DllZWXjooYdaBccqIfB3Sx7MAwYjVavzBccA0E+rx8CkFKyevxgXpPbz7S/dvRW1TWfR7HaFfM0zLS04pJYQ0yd0zkURdQIGyERERL1cfX09nnnmGWRlZeHhhx/G0aNHQ5a78vxRGNc/E0nq0F8wq4RAikaDRybPhF6tRtGlM/Hlj+9Bxkg9hE5AQsItPWOSG10tONPSgo8P78O66VkQKoYc1HNwiAUREVEvVVdXh5deegnLli1DXV1d1PI/m2BGepSUbVqVGrdkjcfMKcOR3T8dKVrv0IpkAE2A+7REY0sLXv1iG5Z9UY2vTp/EWz+6LQ5XoIeBNgAAIABJREFUQ9R1+HGOiIiolzl06BAefvhhjBw5Eo899lhMwTEAjO0XW/5hrVqFCZkDzgXHCh2gzhTQDlThGnM2vj7tWVhk9erVbWo/UXdjgExERNRL7N69G0uWLIHRaMRzzz2H06dP+44NTU7FzIFDMdkwECohQp7f6Ao9jjiYRqihluHTu6lUKvRP0iPXOAoAsGLFitgvgigBcIgFERFRD2e32/H000+joqICMihwnTFwCJ6a/n3MHDgUje4WqIUKZ10tWPZlNZZ9uQkuv/J/PbAXPxw3FfowY5AVQoOoXWxpOh2s48fiY8dXAYE6UU/AHmQiIqIeSEqJtWvX4oorroDZbEZ5eXmr4HjBsCxU5lpx+ZARSNZoYNAlIV2rw6CkFPxyysX437k3QO3Xm/y7XVt8k+zC0qiBDDUQuhPaRyUE+un1AIC0tLR2XSNRd2GATERE1IO43W689957uOSSSzB37lx8/PHHIcsZdHq8MeuasPmJUzVaXHbeMPzneJNv377TJ1B28jBc6jDhgU4LZI8A0qOHD40tLdhbWwe1Wo077rgj+oURJRAGyERERD3AmTNn8Jvf/AYDBw7EDTfcgA0bNkQsf2f2RERbBTpVo8WDE3IgAMydOxfr16/Hw+9XQPefdwPnn+cJiJOTgCQ9mnVaqK61QP3Ij9EcJdMFALgl8Mct26DT6fDAAw/EfqFECYBjkImIiBLYN998g5dffhkvvvgiTp48GfN5i0eNQ2pwlokQUjVa/OTGRfjt2+cm0qmmT4Rq+kTIQ99A1p0AkpLwz/01mD13LgDgM8NATHM6kaoLXX9DczM+2OPAvhMn8cEHHyA7OzvmdhMlAgbIRERECWjr1q1YtmwZ3njjDTQ3N7f5/GR19OAYANyQ+PnPfhbymBg2BGLYEM8vB/f59v/v3n0o/+QTFM+dBSGAJI0nnHC53TjT0oJP9h/ED/72d1x77bVYsGBBm9tO1N0YIBMRESUIt9uNDz74AMuWLcPatWtbHR+anIqfXDgd946djAxdEs66WvDX/Xvx3PZN2Fr3XUDZ3SdrMaF/JlRRVrBL1Scjc+qkNrWzuroan1Rvwft7avAj8zRcNcYIrUqFz49+h/+3oRqfHjoCAJg9e3ab6iVKFAyQiYiIull9fT1ef/11vPDCC9i9e3fIMuYBg/H33Dzo1WrfUtApGi3yRo3DwpGj8eDGtXh1zxe+8i/v3IL5549Cmir8eGEJQDNhDES/9Jjb6na7sXnzZgDA/pOnsHTtJ1i69pPQbTabY66XKJEwQCYiIuomhw4dwksvvYTS0tKIq90ZdHqsyr0J/XX6Vsc0KhU0KhWenzEHO0/U4l9HDwMAPjl6EJ87j2HGoKHQhsnJJnRaqBdd1aY27969O6a8xkIITJ8+vU11EyUKZrEgIiLqQlJKrFmzBldddRVGjhyJp59+OupS0HdmT4RWqCOWSVJr8MspFwMA+vfvj1/96leYuPxZ6MYaAb0O8F89T68D9Dqof3YPxKjhbWp/dXV1TOXGjh2L9PTYe6aJEgl7kImIiLpAXV0dXn/9dbzyyivYtWtXm869b+yUqBkpVELg8iEj8IKtBPf86Ie+4FT+8ieQe76C++NPIL/5DkKvg7hkOlSX5UAkJ7X5OmINkDm8gnoyBshERESdaOPGjfj973+Pt956C2fOnGl1XC0EktQa1LeEz1SRqYstkNXodPiP+5ZA+PXcCiEgxmZBNTar7Y0PgQEy9QUMkImIiOKsoaEBb775Jn7/+9+HDSjnDBmBRyZfhFmDh8MNiUaXC6/XbMey7Zuwv/5UQNnaprM4Lzkl6uuqJIDU5HhcQkj+E/SiYYBMPRnHIBNRj+R0OlFQUAC73d7dTSHy2blzJ+6//36cf/75uO+++8IGx7+edgnemXM95gwdCbVKBa1KjTStDkvGTIH92juRM2BIQPnluz9HfQy5kMX40RD61hP54mXv3r04depU9IIAJ+hRj8YAmYh6nIKCAmRkZKCsrAwGg6G7m0N93NmzZ/HCCy9g2LBhGD9+PF588UWcOHEibPmFI7Lxs/H/P3v3HR5VlT5w/HvvlFRCEnqHhCadJICAIiUREVBRAjYUV0zUteEqse3aV8O66+ouSmLdtZP8cMWKCX0pLiR0UDBB6VIHSCFl5v7+uMyQkGkJyWSSvJ/nyUNy7rl3zpAy75x7zvvGOV1TbDYYCDMH8E3C9YQazx//98/bKdNs7gdiNqFem1Dj5+GNH9es5u8JYzn4wD2c+sP95N07i0eHDSEysPISkJ49exIWFlanYxGiLkmALIRocBYsWABAeHg4UVFR9Twa0RRpmsYPP/zAPffcQ6tWrXjooYc4ePCgV+c+NXC4xw13RkXlpqhLAOjSpQvP//UvBD11PwQFgvGC1ZGqogfHt1xXa+uMnWlx6ABjf9zKrEH9aRkcRJDJRKewMJ687FJ2JP+OAa1bOvr27NmzzsYhhC/IGmQhRINisViwWCwATJs2rZ5HI5qagwcP8sEHH/D+++/z448/Vvv8tkEh9G4e6bFfqMnM3X1iuDr1WSZPnozBoKd4015OwZr9X7Rl66CwCMwmlNh+GCaMQencvtrj8ZZt/z56bNuEQVHAUDndXLDJRKDRyOKbEuk1/x1Ol5Ry4sSJOhuLEL4gAbIQokHJz893fC6bgIQvnD17lkWLFvH++++zePFibLaqSx1URSGhfRe6N4ug1GZl6aG95J2xVOkXbg6g1Gp1VMJzp3fnLsRcd12lNiU8DOPUq2Fq9Yp7XCzb0ixUJ8/bTlUUAgwGbu3bhzdyN7Fp0yYfjk6I2icBshCiQakYIMfFxdXjSERjpmka69ev5/333+eTTz5x3LVw5sZuvfnb0NGYVQNmgwGrpqGikHP8MLet/Ib9Reerzh09W4TZ4L7gh525peeZZl/QysrQdv3oohbfeaFmM3fHDOSN3E1O09kJ0ZDIGmQhRIORm5tLWlqa4+vY2FgiIiKIjY0lOTm5UvAsRE2sWrWK4cOHYzQaGTZsGG+++abb4HhWz/7MH5FAy8BgwswBBBqMhBhNBBmNDGvVjnWTbqVdUIij//GSs/zv6CHPAwk0o44bWRtP6eIVF4PiXbjQMlhPMScV9ERDJwGyEMLvzZ07l9jYWFJSUhxBcHh4OHPmzCEuLo7c3FzS09OJjo4mJSWlnkcrGpqDBw/y+uuv06dPH0aNGsW6deucLqO4UGRAIH8dMoZgo/MNdybVQERAIK8MGV2pfe6uTZSiub6wokBgIMqQgdV5GnUnMABsVq+6niopRVEUZsyYUceDEqJuSYAshPBbmZmZRERE8Nlnn7FkyRKysrIcx+Lj40lNTSUrK4ucnBxHNou5c+eSnp5eX0MWDcThw4eZN28eo0aNomPHjjz44IPs3LmzWteY2b0vNs1NoAuYVJVJnaKJDAhk0KBBvPfee/xnx2YC77wRzCZQL3gZNpsgLBTjE79HMfnHKkjFHIDSzXO2mKKyMt7bvA2j0cjs2bN9MDIh6o5//Pa5oChKOPA4EANEAtnAZ5qmeVUZ4Nz5Gee+vPAemT15aqqmadm1MFwhRC1KTEwkMzOTqVOnkpGR4Wi3zyAPGTLE0RYTE0NWVhbR0dGAnic5KSnJtwMWfu/IkSMsXLiQBQsWsGLFCpezxEEGIz3C9JeI3actFFvLnfYb176Lx3RtACU2K1/8800umzXzfOOooag9umJdvBJt/RYoK4PwMNSEy1AvG4IS5F1paV9RxsRT+OOPBLsJ2q02jXc3b+VPf/qT43dRiIbKbwNkRVFigCVACvASEIUeLOcoipJQjaA23sPxNA/HhRA+Zg+Oo6KinAbHoAfFFUVFRZGUlOSYPc7Pz6+UI3nu3LlkZWWxYcMGLBYLMTExxMXFkZqaKsVGGrFjx47x+eefs2DBApYuXep26USrwCCeHjSCW6L7YD3Xz6CqfPDzdp7btJZjJZU3nhk8blvThYSEMGL4iCrtSrvWGGdOhZlTq/GM6sdvQSH8eflKXhh9OUEGA2qFme9Sq5VSq5VrMz/nWHGxvDkVjYLfBsjowXG6pmn2e6W5QKKiKHlAlqIoEZqmud45UVks+gw0nJ85tpM6tUL4kZSUFDIzMwEqLakAKpWVdpbBouKslT1Azs/PJyEhocoGvtzcXMfa5aysLOLjPb2XFg3F/v37ef/990lPT2ffvn1endM+OJS1E2+mRUBQlSwTv+vRn8mduzP8q484XFzoaF995CDDW7cnyMUaZDuTBkqHtm77+Lvc3Fzm5Wxiw6HfePTSIUyIjkJRoKTcygfbtvPqDznsOXWKDh060Lp16/oerhAXzS8DZEVR5qAHss5mdzOBOcA0wKuFht4uyRBC1C+LxcLcuXMBSEpKqlIlb/369YC+Qc/TrK/93LS0NPLz80lKSiI5OZnw8HDy8/NJS0tzBOKJiYns2bNHZpIbKJvNxvr16/nqq6/46quvapSD95MrJtEyIAiTkxRsZoOBVgFBfDRqIuMWL3C0v71rC4/2H1KlfyWKgtKnO0p4wy67vHHjRgB+OHiIqQsXoQABRiNnyysvP7nwzo4QDZW/btKbDlg0TXOWs8k+pZTo5bW8nWUWQtSzihkokpOTqxy3zyC7yn9sD6DhfIBsD47T0tKIiYkhKiqK+Ph4MjIymDNnDqAH5rKxr2E5ffo0mZmZzJw5k7Zt23LppZfywgsv1Cg47t08koGRrZwGx3Zmg4G4lm3o3kx/E9WpUyfu/+OTlCdcpm+scyXQjOHm61wfbyAq3r0B0KBKcAwwePBgH41IiLrllzPI6JvyXM36bjj3r7cVAqTeZX07ewTWzmTUoWz4uKy+R+P/1ABoMxaGvw+BTetWpT1IjYmJcToTZV8m4WqWyv4iPnXq1ErnpKamOu2fmprqmLHOy8ur+cCFT/z888+OWeKVK1dSVub+70lMizb0jWhBuc3GmiMH+bXgtNN+Ezp200soe6Tw2MQp9H0wiWHDhqEoCpqmYWvRAtsX3+vp2UpK9a4BZggPw/jAHShtW1Xzmfof+wyyJzKDLBoLvwuQFUWx31N1GthqmmZR9D9k3twLjaxwzVT0wDsKPfhOq7C+WdSltTPh0Ld+e7vC79hK4NC3+v/bmG/qezQ+402FPHsfZzvkc3NzHccff/xxR3t8fHyVpRoVxcTEkJuby4kT8l7a3xQXF7NmzRq+/fZbvvrqK3766SevzhvVtiPzhsfTIThUzzas6enW1h09yF2rv68SKAcbTJhUz9XtAoxGZk6/GcOllzraFEXBMHEs6riRaOs3Yzv4G5hMqP17oXTviuJV4O3fjh8/zq+//upVX5lBFo2F3wXI6AFsbV8vDz0ozkcPmmOANEVREjVNS3B2kqIoSUASQJs2bVi+fHktD6vpGHUoW4LjGrAdymZlA/25KygoqPbvTE5OTqWvLzx/165dbo8/88wzAPTo0YPTp087jk+YMMHtWM6cOQOA0WiU3/MaqMn32pXS0lJ27NjBxo0b2bRpEzt37vQ4S3yhhPZdyBh7jdPiHZe16cC6Sbcw7MsP2Vt4xtH+S8EpCsvLaGYyu722zWhg59HfOObu+bY5V0HuwK/6RyNw4e+mK2FhYeTl5UlFy0agNn+vGyp/DJBrUzjnsl9UXM+sKEoq+ka/eEVRkpzNJJ9rSweIi4vTRo8e7ZsRN0ayrKJGVMpoqD93y5cvr/bYjx075vg8ISGhyvkVA+QL00hlZ2ezYsUKAL777ju3M8YX2r17NwCPPvqo3B6ugZp8r+1KS0v54YcfWL58OcuWLWPt2rWcPXu2xmMxqSofXTHRZWU7o2qguTmAtJFXMuH7/3O0f753N/8c7jmLidFgoO+t01DcrTluhCqu7Xdn2LBhjBkzpo5HI3zhYn6vG4tGHSCfy14R66Q95Vye5Xj0zX6y1EKIelYxqHU2A2VfI+ws+LVv6MvIyKhWcGxf8zx16lQJjn2grKyMDRs2sGzZMpYtW8bq1aspLi72eJ4CBBmNFDnZFFbRdZ27o3pY0mBUVUa07kCnkGbsKzxDdHQ0d9xxB+Ude8DqXCh18YbebEKdHN/kgmPwfv2xLK8QjYk/Bsj2V8ZIt70uPjtFKnqAXNtLOoQ3bnZfnrVJ+rjhr1W8GBUD1LS0NEeGCTv7BrwLA9nY2Fjy8/PJyMiotDnPG/YiIW+99VYNRy3cOX78OF988QXz588nNzcXq9VarfPjWrYlZcAQru4UBSiU22x8nLeTv21bz+7TVV8C4tt3Icwc4PG6ZTYrz8y4g1F/uJ/u3bsDoGkaVnMg2tLVYLOB9VxBEYMBVAUl/jLUiWOrNf7GQCsvp92Rw6y7/Ra6Ng+j1Grjy915vL4hh59OnKzUV95kisbEHwNk+04ZT5vwLnaRk/18SQMnhJ9ITU0lJSWF/Px8EhMTeeuttxy5iTds0BPY2EtM2/tYLBZycnKq/eKcnJxMfn4+OTk5kv+4FhQUFJCTk8P69esdH3v27Knx9Wb17M9fho4m0GDAcK5qm0lVua1HX26M6s3UpV+w5ODeSucYVe92OwQHBzNzxnTUc8Ex6JvtjDddgzZmONasVWi79JcIpVc0hoTLUdq0rPFzaai0gjOUvvlPnhzQl2bm8+uzbx/Ql1v6XcITy1fxRu75tHotWrSoj2EKUSf8LkCukKXC6cxuhSwX3paadsX+inix1xFC1JI5c+awfv16MjMzHR/x8fHExMRgsejvZdevX++ojJeSklKjsraZmZmOCnoy61V9JSUlbNmyhfXr1/Pll1/y+9//np07d6JptXNnaGirdvxl2GhCnKwlNqkqJlUlY+w19Fv4PgeLChzH1h89zJQuPQj1sNnOqKoondo5Paa0bYVxxvUX9wQaAU3TKH8nDU4crxQcg54T2mww8OLoy/n11Gm+ztPfTHz++edSkVI0Gn4XIJ+Tjb6BLsZJFTz7b99n7i5wbiNemotiI3A+j/JLNR+mEKK2ZWRkkJuby0svvUR+fj4bNmwgO/v8+9ioqCimT59e48A2NzeXxMREMjIy5MXcC8ePHycrK4v58+ezZs2aameVsItuFk6b4GAsJSXssBx32/exAUMJ8pB2zaCoJPUewDO5axxt/zn8K38xerFJrFULlE7tvRp3U6Xl/QzHj6O6edMTYjLx/BWXOQLkDz/8kHnz5vlqiELUKX8NkNPQA+Hkcx8VJQK5FwbO5wLi45qmzT3X9Nm561RJ46YoSjj6GuRETdNkiYUQfiYmJoaMjAzH1+np6Y6NeK6KfngjPz+fcePGkZaWVu31yo2ZpmkcOHCAnTt3snPnTnbs2OH4/OjRoxd17Umdo3g+7jK6NWtOqdWKUVU5UXKWF3LX8v7u7VX6GxWV8R27onpYLhFkNHJb9768fWQv119/PTfffDNDhgxB+34lts+/c7vZznC7fO89sa1bA6WlHvtFhTenR0Q4u09aKCgo8NhfiIbCLwNkTdMyFUVJB5IURcnSNC0TQFGUOegzv5UyUyiKEo+etg1FUbI1TcvVNC1XUZQoRVEy0APlDegb/+yBd6KmabK8QogGwJ6H9WKWQ+Tn5xMbG8vjjz9eo2UZjYHVamXPnj1VguCdO3c68kHXpgf6xvBs7EhCTPpSCXv6tVCTmb8NH0Nsq7bcv2ZJpXNCTCZsXq7UaBsewb59+yo3XjUaFAXb/32rV7azB3mBAWAwYLj3NtQe3S7maTUJmuWk505AqdVK29BQdp+0EBoaWsejEsJ3/DJABtA0LVlRlBwgWVGUt9A37+UC3ZzM+m44d4wLZpZTgMeBLPTNeBuALE3TqqR+E0L4L/sGveqkcKvIYrGQkJBAUlJSlewYjVlpaSnr1q0jIyODzMxMDh8+fNHXNCgKVi/WGveLaMlzcSNd5iQONZm5pfslLN6/h6/2nl8JV1DmedbSzhjWzPkYx1+BOmoYtrU5aL/sB6MBtU9PlMF9UQyeK+YJUIKD8eZ9ikFVOV1SgtFoZMaMGXU+LiF8xW8DZKhcrMNDPwvO8x1nApl1MDQhhA/ZU7zZM1hUh8ViITY2lvDwcKZPn16lrLR989+JEyeIjIxs0EsvbDYbW7ZsYcmSJWRnZ7Ny5UqKioou+rqj23dizsChjG7fCVVROFlylje3b+LNHZs4etZ5HuMH+8ViUtwvkwg1mZkzYGilANmqaXx7eC+T23fF4C6nsdmEOma4y8NKUCCGsSPdPzHhkho7hNL8fAzl7tecnykpZcuRowQGBTF79mwfjU6IuufXAbIQQtiDY6jZDPK4ceMchUdiY93fPIqPj29wAfKePXvIzs4mOzubpUuXVqpIWBuej7uM+/oNIshochThaBEYxB8GxnFP30GMXvQpP52qejt+YucoTF7M1g5p1ZZ2rVozbOQIpk2bRkJCAi3OllH+wmuu1xEDGAyooy6t8fMS7il9+1OW8SmKprksvlJYWsrLa38AReH//u//iI6O9vEohag7EiALIfyafXkFVH8NckpKSqUAuzE4evQoS5cudcwSe5trOMxsZmLnKCIDgzhWXMTXe/Mp8JCRYlpUL+7rN9ixhriiIKOJANXA95MS6f7J25TZbJWOB3jIQmGnGo0c2PsrSmBgpXbD3TOwzv9AL9pRXqHAiMkIJiPGR+5GCQ3x6jFE9SlGI2+Xw60lJQQbTZiNlb+fBaWl/GfXz8zfuJlrrrmGCRMm1NNIhagbEiALIfxaVlaW4/PqziCnpqZeVNYLf5GVlUVKSgqbN2/GdkEg6olJVfnriNHc3qsv5TYNk6pSZrNhUBXe2rGFx9atdLmm+E+xI5wGx3aqqhJiNHFd1+5k5O+qdGxf4Wn6mD0X11DMJgioWv1OHdQX5YU5WLNXoa3NhZISCAlGHTMCddSlKGGyIayuZW3Zyl//u4qHh8Zxx4B+GFUVg6Kw/dhx/rLuf2T8qH/PR46UpSyi8ZEAWQjh1+wzwDXdoNdQlZeX89VXX/Hss8+yadMmzyc4oSoKX1x1HcPbdiCowmY5+1ztrEsGEBUWztTFX1TZkBUdFk7HEM9BaJg5gDt7DyAjfxeqqtKhQwdiYmI4NqgPtoMnUMvKXZ9sMKBcMRzFxS18pWUkxhuvhRuv9TgOUfs2b97MwTMF/GHJcuYsXUF4YABny60UXnDnYeDAgfU0QiHqjgTIQgi/ZbFYHOuHm0rFuyNHjvD2228zf/78qinMqmlqVE8ubdve5SxwiMnEmPadmNQlmi9/zat0LDIgkFKblWBczyDb9e/ajU2bNtG3b1+MRv1lRSsto/xPc+GERV8m4UyAGUPCFdV7UsInjh07xsGDBx1fWzWN48VnnfaVAFk0Rt4VrhdCiHqSkZHByZMnKxUOaWw0TWPt2rXceuutdOrUiSeffNJpcNwuOIR+kS1pG+zd2ttHBg3xWHY51GzmkUFVs4McPVuE2cuUaK17dGfgwIGO4Bj0pRPGx+6D1i2qLqEIDICwZhhT7kMJD/PqMYRvbd682at+bdq0oW3btnU8GiF8T2aQhRB+Kzw8vMFllaiOoqIiPvnkE+bNm8fGjRtd9ruqSzeeGTqCPpEtKLFaCTAY2H7iGM/8sIbFe39xeV7/SM9rgAEGt2wNQEhICO3bt6d37956VbozVrC4LyBSbjQQcIXzdGtKeHOMz81B27EL2/I1aCctKCEhqJcPQxncD8UoL0H+ytsAWWaPRWMlf52EEMLHfv75Z958803ee+89Tp50X7Hs4UFx/HHocMcyicBzQWVs67Z8etVknv3fGv6+Kcfpua7W9l7IbDZTVFREUFBQpXbbpm1Y3/7Qdbo1RaHcbCZwQB+X11ZUFaVfb9R+vb0ai/APEiCLpk6WWAghhA9YrVa++uorJkyYQI8ePfjb3/7mMTge0qZtpeD4QiEmE08PHUFca+e3uPNOXVh01Dm1XZsqwTGAOqgf6qQrwWzSyzZXZDZBWDO2xY+Q6nSNkATIoqmTAFkIIeqQ1Wrl5ZdfJiIigsmTJ/Pdd995fe4jg4cQ6CH4DDQYeHhw5QIogYGBDBkyhD1RnbCZPNwoDDBjuHKMy8OGq8ZifPT3KHED9bXEBgO0iECdcjXG51IoCQ32+vmIhqG0tJQdO3Z41VcCZNFYyRILIYSoI8uWLWPWrFmOTBzVNaFLNwyq+3kMg6oysWsUvXv35uqrr2bmzJn069cPRVHQysooT30dDh+Bcifp1kxGlHZtUeIGuX0MpUsnjHfNqNFzEA1P/rq1zBs3hmt7difIaOS3wiLeyN3Ie1u2YSkpcfQzm8306tWrHkcqRN2RAFkIIWrZzz//zKOPPsp//vOfi7qOt1kkgkxmdu7cWaVdMZkw/uH3WN/5EO3H3aBpYLWC0QAoKH16YfjdLSgGA5oGBw7Ali2wbRts3Xr+w31tktFux2Y0wogR+sfw4fpHq1ZePS1RD6w/rKXz14u4pe8ljlLhXZqH8afLRvDIsCGM/fgzfjqhLw3q3r07JjeFZIRoyCRAFkKIWmKxWHj++ef5xz/+QdkFxRSamwOY3qsXvSNaUFRexre/7GH1wQNur3esuIjW3qR0C3Vd0EMJCsR43yy0o8ex5WxCO11AkSmMz3YP4h9vRrD1Xq+eWo2Vl8PKlfqHK6NHw/33wzXX6AG1qB+2vJ+xffmFnvn6gjdnISYTQQYD2TdNo0faO5wtL692VUchGhL5UySEEBepvLyctLQ0nn76aY4fP17l+NPDhvNwbBw2TSPEZMamadw7YBCHiwq54asv2HnihNPrvrl1M3NihxLkLmo0GlFHuS71e+AAvP46vPNOC44fH1ft5+YLy5frHxUlJcEDD0DfvvUxoqbJlrUYylxkLEEvLR5sMpHYqycfbN/Bnj17fDg6IXxLNukJIcRF+PbbbxkwYAD33Xef0+D4pZGX81BMHEFGEyHninaoikKo2UxUWHNWJt5EVPPmVc4zm82cuKR0BMH1AAAgAElEQVQH5lAPM8gBZtTLzuchtlrhrbf0CUBFgY4dYe5ccDI0v5aeDv366c9BUfQlGj/8UN+jary0wkK0vb967NfMbCZ5sL4xr7S0tK6HJUS9kQBZCCFqYPv27Vx11VVcffXVTtf/AnRpFsa9Awe7TNOmqiqhJhMvjxzlaOvYsSOvvfYap06d4o1//5uAPzygL6EIuKAiXkAANAvF+NDvOVIUyh136IGk0ajPvja2u99r18Kll+rPsU0byM6u7xE1MkWFXq9vaROiZy4JCfGuoqMQDZEssRBCiGo4evQoTz/9NOnp6VitVrd9kwcMxFOpDoOqMr5rN64dF8/jL77AsGHDKh1X2rXF+NxTaBs3Y1u1Gq2gEKVZKIeiRjDlmYHkvFz3m6S6dIH+/fUZ3Y4dISxMn6kuLYVt23bTpUsPSkuhpERvKyiAffv0DX55ebU/niNHICFB/9xsho8+ghtuqJqqWVRDYBCUu/95tjtx9iwAt99+e12OSIh6JQGyEEJ4YceOHcyaNYu1a9d6fc6Idu0dle/cMQUFsTAtDTU6yulxxWxCGRaHLTaOlDnw6rNeD8EjoxF+9zu46SZ9GYPZ7PmcipYvP8Do0T287l9SAps3w5o18N13sHhxNQd8gdJSSEw8//XSpTDGdVpn4YLSrBlKu7Zo+/e77VdQWsrbm7eiqiqzZ8/20eiE8D1ZYiGEEB68/vrr9OvXr1rBMYBN07zqZ7QvGHZh5049NZrJBK++Wq0hVNK5Mzz9NOTn6xnfNE3fk5WWpmeSqG5wXBMBATB0KDz0kB4g28dRUgKffqqngbsYY8fq/5VPPNH4lpnUNTV+PCUefmZLrTY+3r6TSZMmER0d7aORCeF7EiALIYQbr7/+Og8++CCal8FuRYt//YUiN1kBHKxWlPbtKjXZbPDSS3qw16cPHDtW7Yene3f4/nv9WpoGv/4KzzwD3bpV/1p1zWyG6dP1mWV70HzwIDz2WM2u99JL+kbFkSPB4l3F7SZPvaQPH+47QGFpWZUUbiXl5ZwqKWHCgkwKy8qYNGlSPY1SCN+QAFkIIZzQNI1nn32WBx98sMbXeHf7VhRPC2MNBpSYQSiBgYC+fnf0aD24e+KJ6j/mjBl6YKlpsHu3vla3oa7NbddOD3Q1TQ/yFy6E4GpWtl6zBiIi9P+D3Ny6GWdjoWkaT2UtYVLmQhbv+YVymw2rzcbpkhLm5W5i0Dv/YuNvRwDoK/n3RCMna5CFEOICxcXF3HHHHXz22WeOtjCzmRl9+nDXgIFEBgZyvLiYt7Zs4cOdOzjtIt3V0eJi0g8d4P5u0ajOSj2rKoSGYLhmEmVlMHEiZGVVf7xvvAF33dW4i2woCkyZAoWF+tdLl55/M+Ct2Fj936++0v+vRWVHjhzh+PHjrAau3a8XsTEbDJQ62YwqAbJo7GQGWQghKjh06BBXXHFFpeB4cOvW7L5zFs+PvIw+LVrQNiSEvi1b8sJll7HrzlkMclI7uUuXLixZsoRHFmZivHHauVRtAfpCYrMZjEaUHt0xPPIwSbNDMZurFxzPnAnFxfrs6j33NO7g2JmxY/UiKJoGq1dXb2Z50iQ94N6ype7G1xBt3769Spuz4Lhjx440d5K7W4jGpIn9SRVCCNc2btzI5MmTOXDgfAnodiEhfD81keYBAVX6h57b1fZ9YiL933+f34qKCAkJ4ZVXXuGuu+7CcK5cr2FILGrsYLRdu9GOHUcxGlF69eDFeRH8sZpxxvffn09xJnQjRugzy2fP6hk5PvnEu/MGDtTft+zdqy/DaOq2bdvmVT+ZPRZNgcwgCyEEsHDhQi677LJKwTHAvQMHEXAu0HUlQDWQPHAQ999/P4cPH+buu+92BMd2iqqi9u6F4bIRfPDTUNTICP74R+/GdvXV+kYzTZPg2J3AQPj4Y/3/af58784pKIDISH1W2UNa60bP2QyyM/369avjkQhR/yRAFkI0aZqm8eKLL3LDDTdQVFRU5fisAQM85jIOMplIGTWK119/ndDQUJf9du/Wb+3PnOnd2F59Vd+c9vXXIHe0qyc5WQ+UN2zwrv/XX+vLVObOrdtx+TNvA2SZQRZNgQTIQogm6+zZs8yYMYOnnnrKZZ/Ic9klPDF5SOc2cyb07OnduJ5/Xg+MH3qo4Wag8BexsXqgfOgQhId77p+Sov+fb91a92PzJ5qmeb3EQmaQRVMgAbIQokn67bffGDNmDB999JHbfme9ve9ucl7yedcuPeD61788XyIpSQ+Mn3pKAuPa1rYtnDypF13xxoABel7mGqS/bpAOHjzIqVOnUACj6j40uOSSS3wzKCHqkQTIQogmZ/PmzQwZMoR169Z57PtlXh7lnkqyKQpK/6qzajNnQq9ensczfrxeMjktTQLjuta7tx70Llzoue+CBXomPg/Vlxs8TdM4vGwpq265iaJHZlPw8IPsvSeZR4bGEXZBecWuXbu6XUYkRGMhAbIQokn54osvGDlyJPv27fOq/ysb1lPiaRbZaMQweozjS29njTt0gNOn9ZLLLiagRR2ZMkUPlFNSPPft1Alefrnux1QfNJsN66cf03vrZoa1b4dBUVAVhbahITw1Yjgb77iNDhUCYlleIZoKCZCFEE2CpmnMmTOH6667jkJ7tQkvbDpyhDkrVlBUXo7Tu+0mE+p116J0aA/Affd5N2v8ww/6zGSzZl4PRdSBl1+GkhIYOtR9v8cf19/0VONHp0GwrViGtm0rZidrSYJNJtqGhPB14g2Otvbt2/tyeELUGwmQhRCNnqZpTJ48mb/85S81Ov+/5WUU3TgdtUcPvQa02ayXiO7ZA0NyEobhwykt1QOoefPcX2vsWH2dsaeATPiO2ay/YfFmj1poKPznP3U/Jl/QrFZsy5eBmw2mJoOBzmHNGNmhAwD5+fm+Gp4Q9UoKhQghGr0HHniAr7/+ukbnTpgwgc8++4xmzZrBiBFoZ89CUREEB6Ocy3Cxdy906eL5Wv/7HwwZUqNhCB/o21d/83LFFbBqlet+U6bAtdc2/EBZ++UX/Ql7EGw0cnu/vqw+cIC1a9fW/cCE8AMygyyEaNTeeecd/vnPfzq+VoC49m2Z2DOKSzu2Q3WzK+6RRx7hyy+/1INj+/mBgSiRkY7g+JtvPAfH48bpcYgEx/5PUWDlSs9lv7/4Qu/boIuLFBd5tStUVVXahASjKIrTXOFCNEYygyyEaLQWL15McnKy4+vfDe7HH68YQViAGatmQ1UUSsqtpP73f7z+Q66jn8FgID09nd/97ndur//oo/DKK+7HsH49xMVd1NMQ9SA+Xi9d3by5vkbZFaMRTp2CsDDfja3WhIZ6lcfOarOx/0wB4eHhWBv0OwIhvCcBshCiUdq4cSNTp051vKD/edzl3DNkECHmC9JFBMCzY0YwoE0rZi1aTPPmzVm0aBGjRo1yeW1Ng6go+OUX148fEqKXh/ZQhE/4sYAAPUh+4w34/e9d92veXM9c0qOH78ZWG5TOXfT0Ke7eAQBny8t5b+s2WrVqRYLUOhdNhCyxEEI0Onv37mXixIkUFBQAMLxTe+fB8TkhZjPX9+nB5F7R5Obmug2OCwr03LjuguPkZL2fBMeNw733woED7vv07AmLF/tmPLVFUVXU+ARK3Uwil1qt7Dh+gg2HD9O6dWtmz57tuwEKUY8kQBZCNConT55kwoQJHDp0yNH2h+FxBBoNbs8LNZuZe91EoqKiXPY5fNhzWraMDJg/v1pDFg1A+/ZQXu6+z1VXeV5y42/U4SP5/uRJCktLsV2wYa+gtJR8yymu+T+9qkqfPn2Ijo6uj2EK4XMyvyGEaDRKSkqYMmUKO3bsqNQ+pltnDB7K5wJEBRjRbDYUJ30PHdKDJHd274bu3as1ZNGAGAz68poxY2D5cud9Hn0UNm+GDz7w6dBqTFEUHlu1mlaFhfxhaByjO3fCqKrsOXWKv/1vA5/9+BNnz70z6NHQ1pAIcREkQBZCNAo2m4077riDFStWVDlm9CI4BlBQnG5aOnzYc3BcVARBQV49jGjgli2Dp56CF190fvzDD+HECahhZkGfKisrIz8/n13l5az+3P06ko4dO/poVELUP1liIYRoFJ588kk++eQTp8d+PXXau4uEhKAYKi/FOHwY2rVzfcrgwXoKNwmOm5YXXoDMTNfHv/kGbr3Vd+OpqT179lDuae0IEBQUROvWrX0wIiH8gwTIQogGb/78+bz88ssuj/9tzQYKSkvdX8RoRL208ua8335zHxzfcQfk5nqVSlY0QjfcoC+ncOWjj8Df97T99NNPXvXr0aMHqpd3YoRoDOSnXQjRoH355Zf83l0OLuDTbT9y8Ewhpa5yuCoKBAWjDhnuaDpyBNq2dX3Ne+6Bd9+tyYhFYzJggP6z4srf/+56KYY/2LVrl1f9evbsWccjEcK/SIAshGiw1q9fz/Tp06vsvr/Q2fJyRr/3KduOHKOgtIxKq4zNARDZEuOsB1CCggE4ehTatHF9vbvv1nPjCgHQqpWe89qVp57y38wm3s4g9+rVq45HIoR/kU16QogG6ZdffuHKK6+kuLjYq/7HiooZ8c4nrPrkQ4aaFDhtgdBmqIOHonTrjnJunURxMbhbapmUBG++WRvPQDQmzZvrb6xatXJ+/J57IDwcbrzRt+PyRAJkIZyTAFkI0eCcPn2aK6+8Eou7aTsn0tLSGDHtJpfHNQ2Cg12ff9ddkJZWrYcUTUjLlrBvH3Tq5Pz4TTdBZCRceaVvx+XOrl27UBWFQKOBojLXm/V69uzp9ZtRIRoDCZCFEA2K1WrlpptuYvfu3Y622NZtuLnXJbQODmbfmTN8+OMOdpw4Xum8p556ilmzZrm99uDBro/deSekp1/U0EUT0LEj/PQTuJpwHT/ef8pSF2zdwtuXjWBsl85oQEl5Oe9v3cbfN+Sw9/SZSn179erFpk2b6megQtQDCZCFEA3Ko48+yjfffANAm+Bgvpg8hV4RkQQaDBhUlTKbjXsHDGLd4UNM+2YRp0tLmTFjBs8995zb677wguuMBDfeCG+/XdvPRDRWPXtCTg7Exro+XlICZrNvx1WRdUk2xuzvie/aBfXc8iKT2UzSoIHc1q8fEzIyWX/oMACtW7cmPDy8/gYrRD2QTXpCiAbjrbfe4tVXXwWgmcnMqsSb6N+iJSEmk6NSnklVCTaZGNGuPdlTpmFSVd5++23HGmNnVq2CP/7R+bGePcFFemUhXIqJcV1tDyAgwGdDqcK2cye2pdkYrFZHcGxnNhgICzDz9dTrCTsXwXfu3Lk+hilEvZIAWQjRICxbtox7773X8XVS/wG0DgrGdEFhD7tAo5Hu4eHc0m8AZjdTdUePwqhRLg/z4481HrJo4q64AhYscH38vvt8N5aKbNmLoazMbR+jqnJL30sAKCws9MWwhPArEiALIfzerl27uOGGGypV/HpwUCzBJpPb80LNZv40arTL4zab+4wVp09LERBxcRIT4aGHnB+bN08vW+1LWmEB2sGDHvuFms3cOWAAAPn5+XU9LCH8jgTIQgi/dvLkSSZPnszJkycdbQEGA628rO3c3uR69rhFC9fnbd4MzZp5PUwhXHr1VXBVhG7sWPc5lGtdUTG4uOtyoYjAQABKPVWhFKIRkgBZCOG3ysrKmDp1apVqX1ZNc7umuCLVRTCQmuo6MElP1yukCVFbSkpcH4uI0FMM+kRICLiqKHmB384trQh2l/tQiEZKAmQhhF/SNI3777+fpUuXVjlWbrOx9dhRr66jREdVaTt8GB57zHn/yZP1fMdC1CajUU/v5srYsb4ZhxIcjNKtG57i8TMlpby5UU/rdvPNN9f9wITwMxIgCyH80uuvv06am6ocr+Ssp8DTrV+zGXXcmCrN7dq5PmXRIm9HKET19Ojhugrj8uWQleWbcagJ49HcLLOw2WwUlpeR8ZMe0aekpPhmYEL4EQmQhRB+591332X27Nlu+yzY/RPL9u+j0NVufLMJZUgsSvfKM8gvvuj6mkVF1R2pENVz992u8yNfeaW+cbSuqd2i2NGjJ0VlZZResNyisLSMY8Vnif9kAWfLy+nevTvR0dF1Pygh/IwEyEIIvzJ//nzuvPNONA+LMjVg2jeL+MemXArLy9DMZj25bEAABAehThiPYdoNldYqHz8OTz3l/Hrffgte7vsT4qKsX+/6WEKCb8aw9mwpQ//1Ie9t2caxomIKy8rYYznFn/67mr7vvMeuc5tiBw4c6JsBCeFnpJKeEMJvXJjr2BOrpvGX7VuYmvYGvQwmfQq4WShKj+4oTm4ht2zp/DqdO8NVV9V01EJUj6LAvn3QqVPVY0uXui9VXVv27NnDrpMnuT97CfdnL3HZr1u3bnU7ECH8lATIQgi/sG/fPq699toqM8cKuNxQpCgKCxYs4BIvUk789a+uj/38s/fjFKI2dOwIDz8Mf/tb1WO9e9d9Vos9e/Z41U8CZNFUyRILIUS9O3z4MOPGjePMmTMABBmNJPcdyE+33knxPbMpvvsh1iXewtTonlRM7vbaa69xlRdTvxYLPPKI82NffAEe6o0IUSfcvWl75pm6fWwJkIVwTwJkIUS9OnbsGPHx8ezevRuAiIBA1k29hZdHjKJbWHNURcGgqsS0akP6mCtZePW1GBSFe+65h/u8rNXrqiBIy5ZwzTW19UyEqL6NG523P/usXsmxrvzyyy9e9evatWvdDUIIPyYBshCi3lgsFq688kq2b9/uaMu4ajJRYc0JcTKtG2o2M7pDZ/48YhSvvfaaV8VC1qxxnRlg//4aD12IWjFoEAwe7PxYRETdPObp06c5ceKEV30lQBZNlQTIQoh6cebMGSZMmMDGClNol0REEtemLQFG19sjQkwm7h0Qg9HLfFgjRzpv//RTPeGFEPXtf/9z3m6zwbJltf943i6vaNu2LUGS2kU0URIgCyF8rqioiMmTJ7Nu3bpK7dN79MakeP6zZDKb0Xb+5LHfl1+6PjZ9usfThfAJoxE+/tj5sbqosCfrj4XwTAJkIYRPlZSUMGXKFFasWFHlWNvgEExuKnzZqQpQ6Lmqh6v1xV7GB0L4zE03uT6WkVF7j6PZbLBzBytuuZFjD/6eIw/cyxc3XMcVnavmnJMAWTRlkuZNCOEzZWVlTJs2je+//97p8YOFBZRarZg9BcmqCqGhbru8/77z9ogIkGWVwh/t36+nf7vQtGm1k/ZNKyvD+k468SePEdChvaN9fLeuXN6pIwt/2s1d3y52pFWU9ceiKZMZZCGET1itVm699VYWLVrkss8nu3Zi9SYS0DSUPu4rKdxxh/P2nzyvzBCiXnTo4PrN2xdfXPz1rZ99jLZvLwEXbG5VVZVQs5kbevXkqRGXOtpDQkIu/kGFaKAkQBZC1Dmbzca0adNYsGCB2367T1lYeWAfZ8vLXXcym1BHX47iJnlxaqrz9j59oFUrLwYsRD3ZsMF5+3XXXdx1tZMn0XbuADe/WyFmEw8NjSPg3B2cH3744eIeVIgGTAJkIUSdslqtTJo0iYULF3rV/+bvv2bnyeMUlJVWPWg2o/TvizrJdXEQTYPHHnN+TF7vhb9r0QLatXN+7Jtvan5d28Ycr9ZpaJrGVVH62uOlS5fW/AGFaOAkQBZC1JmSkhKuueYavv32W6/POVNWyuULP+XH/pdA+7ZgNIDJiNIjGsOs2zDccSuK6vpP14svOm8fN87jsmUh/MLmzc7bJ06s+TW1U6fAavXYz6iqtAkJBqCwsLDmDyhEAycBsmjwsrOziY2NJSIiwvGhKEqlj4iICBISEsjOzvZ4vczMTKKjo8nPz/fB6BuvM2fOMHHiRL65YNqrdVAw/SJb0tFNtPrWu+8y/P57MT35KKbX5mL6eyrGh+5F7XuJx+Igf/yj8/aLmX0TwpdatXJd/TErq2bXVEJC9M2tHpTbbJwqKQGgWbNmNXswIRoBCZBFgxcfH09OTg6PP/44FosFi8XCyZMn0TQNTdPIy8sjPj6e7Oxsl0GyxWJh7ty5REdHk5iYKMHxRTp58iRjxoxhyZIljrZR7TuyfMp0fp4xi+XXT2f7zb9j0423MzW6Z6Vz58+fz2233Vajx/3vf523T5oEZnONLilEvdi61Xn7lVfW7HrqwEHgRQpFk6rybZ6eB3HGjBk1ezAhGgEJkEWjERUVBUB4eDjh4eGV2jMyMoiJiQEg9YIdXOnp6URERPDSSy8xderUSueK6tuzZw8PPPAAOTk5jrbbe/dl0cQpjGjXgUCjkTBzAEFGI30iW/DW2PH8efjlALz66qskJyfX+LEvv9x5e23mkRXCF9q1c70kqCZ5vJU2bVE6dsLdIouisjI+2LaD06WlqKrK7Nmzq/9AQjQSEiCLRsNTYBsfHw9QZXY4MjKStLQ0Tp48SWpqKpGRkXU2xsZuy5YtjBw5kv379zvaejQP57XLxxLsIutEiMnE3f0GMim6Bw899FCNH/vsWeftAQEQGFjjywpRb3bscN4+ZUrNrmeYcTunVQNFZWVVjhWUlrLh0GEeXrocgPHjxxMdHV2zBxKiEZBCIaLJsFgswPlA2W7q1Kn1MZxGZ9WqVUyePJlTp05Var9/QAxGD2sfQ01m/jL+InYgAXff7bx99eqLuqwQ9aZT1eJ2gOtNfJ4oIaH8raScs6tWM3toHK2Cg1GBPIuFv/ywno+276TcZgNg2LBhNXsQIRoJCZBFk5GdnU14eDgpKSn1PZRGZ9GiRUyfPp2zTqZxp0T38FwZD4hSDGhl5Simmv1Z+te/nLfHxtbockL4hffec170ZuFCuP766l/vl4MH+WxDLq9tyCXIaMSmaZQ4yW7RzlWuOSGaCFliIRq93NxcEhISCA8PJycnx7FWWdSOd999lylTpjgNjgECjd4FvIqqgpNbv95wla714YdrdDkh/Mbttztvv+GGml3v4MGDjs+Ly8udBscA7du3d9ouRFMhAbJodCwWC9HR0URHR6MoCrHnphAff/xxCY5rkaZppKamcuedd2I7d1vWmYMFBd5d0GCAwIAajWXcOOftrirqCdFQKAp06eL8WKmTWjqeVAyQ3ZEAWTR1EiCLRikvL4+8vDxOnjxJTk4O4eHhJCYmEhERQWZmZn0Pr8Gz2WzceeedPOaqZF0F/9iS67wqXkWqinLpELcFQFxxNencvDl4OXkthF/7+mvn7dVdLaZpmgTIQnhJAmTR6FTMZhEeHk5MTAwZGRmkpqZisVgkz/FFKioqYuzYsbz33nte9f94105OlZQ4Nv84ZTJhiB9do/G4qpy3cmWNLieE3+nb13n73/9eveucPn2a4uJij/0MBgOtWrWq3sWFaGQkQBZNxpw5cxyfp6Wl1eNIGq49e/YQFxfHihUrvD6nqLyc0Z9/xuHiIqwXbsAzmyEoCMODd6O0qFl6vWefdd4+YECNLieEX3JVO2fvXu+v4e3scdu2bTF4sbFWiMZMAmTRpNjXIMsMcvVlZWURFxfHzp07K7UHGY20CQomwM0LqhYRju2JP2C+7WaU7lHQqiV06YR6/TUYX/gjapfONRqTpjlvT0io0eWE8Fvz5jlvv/de768hyyuE8J6s0BNNkmzW856mabzyyis89thjlTbjXdauA0/EXcqo9h2xajZUReXbX/L5c84PbDp2xNGvb9++LFmyhDZt2gCgxgystbF9+63z9tdeq7WHEMIvuKqq52p9sjOH9+/npj69Gd5BD4BX7z/A57t+pvSCTBYSIAshM8iiCbFYLI6Z4+nTp9fzaBqGwsJCbrzxRubMmVMpOL63/yC+nHQ9Yzt2xmwwEGQ0EWAwMLlbNMumTOe6qO4AjBw5ktWrVzuC49p2333O2y+5pE4eToh69eijzttdZGqr3GfLJq7duZV/XjmOu2MGcXfMIN4Yn8CB++9mSs8elfrWV4BssVhITk4mNze3Xh5fiIokQBaNhr1Snit33XUXoK9FjomJ8cWQGrS8vDyGDx/OggULKrUPa9OOFy+9nBCTCVVRKh0zqCohJhPvjZtA94hIsrOzad68eZ2Ncc+eqm0BNcsUJ4Tfe+IJ5+0ff+z+POvWLdgyPiUAjWYVfkGaBZhpHhDAe5Ou4poe58tK10eAnJycTEREBOnp6ZU2WgtRXyRAFo2GfXbYYrE4gmWLxUJ2djaxsbFkZmYydepUUj0kx7VfpymvU/7uu++Ii4tj69atVY6lxAwlyMMGHpPBwJs33kJgYGBdDZHffnPe7mqtphANnau48fHHXZ+jWa3YPs9wW4Qn2GTijfEJjje89bFBz/5GPDw8XJbACb8gAbJoFLKzsyuVkI6IiEBRFCIiIkhOTiYqKoqcnBwyMjKcnp+SkkJsbCwRERGOtoSEBGJjY0lMTKzz8fsLTdP485//zNVXX+10Rl4BxnfphuohX7FZVbksuFkdjVLnajbNWVleIRqLCn+iHA4ccN1f++lHKPe8BiPQaOTKbl0BWLNmTc0GV0MVJzWmTZvm08cWwhXZpCcahfj4eDRXKQ284GlWuSk4c+YMM2fOZOHChS77BFWj8obBixfli/Huu87ba1BrRIgG46WX4O67q7YXFkJISNV27fAh8FSoBwgyGujXqiXf5e9h2bJltTBS71W8W2evfCpEfZOXEiEEu3fv5tJLL3UbHIOe07jMmx1BAKFOXq3r2C23+PwhhfCp3/3OebvLzC0X7BNwRdPAdm6SoaioqAYjq7mKAXJcXJxPH1sIVyRAFqKJW7hwIbGxsezYscOr/h/t2lklLdSFrKqKOmpEbQzPKSdLowF4/vk6e0gh/ILJ5Lz9ySedtyvdurk+qYJSm5XV+/W1GqGucsrVgdzc3EqFm+xL3WJjY0lOTm7Se0FE/ZIAWYgm6vTp09xxxx3ccMMNnDlzxuvz/rZxA6U29wGyzWBAHXHpxQ7Rpfffd97erVudPaQQfqM6VSKVLt0gxH3Aa9M0DhUU8sPBQwDc5oNzN2oAACAASURBVKpsXy2aO3cusbGxpKSkOILg8PBw5syZQ1xcHLm5uaSnpxMdHV1pf4kQviIBshBN0MqVKxkwYADvu4o03cg7beGG776kTFWrzkyZzRAczLbRw1HqcInFv/5VZ5cWwu8995zz9rNnq7YpioLhltuwudg/YNM0isrKuGXR147+s2fPrq2hVpGZmUlERASfffYZS5YsISsry3EsPj6e1NRUsrKyyMnJcWSzmDt3Lunp6XU2JiGckQBZiCakpKSEOXPmMHr0aH799VdHu1FVmRLVgy8nTeF/025l0aQpXNMtGoOT9YutW7fm1S+/IOjPf0IdPw5aREJwMLRuhTp5AsbnnqAovO5yHwMcP161rXPNqlUL0eBMmuS8vUKsWYnasRO7R41l029HKCwro6C0lDOlpRSVlbH5yFHGfPQZm37Tq1926dKF6Oho5xe6SImJiSQmJhIfH09OTo4j37F9BnnIkCGOvjExMZWC5+Tk5DoZkxCuSBYLIZqILVu2MGPGDLZs2VKpPbp5OFnXJRJmDiDMbHa0j2jXAUvJWRL+k8Ge06f0thEjWLRoES1atADAMCEBw4QE3z0JN26/vb5HIIRvuEpT/PnnMHmy82MHNLjq/Q/p17IlMe30ypYbDh1mx7HK7za7dOlSm0N1SExMJDMzk6ioqErpNiuuMb6wgFNUVBRJSUmO2eP8/HzJkSx8RmaQhWjkrFYrr7zyCkOGDKkSHEcEBLL8+um0Cw6pFBwDhJnNdAgJZfn102luDuChhx5i5cqVjuC4vpw86bzdB8smhfBr7pLQnDhxAoBtx47x763b+ffW7VWCY4DIyMhaH1dKSgqZmZkAlWaFgUplpZ1lsKg4m+1uw559vbJs6hO1RWaQhWjEfv31V26//XZWrFjh9HhSvwGEmc0YXCQPNqgqYeYAkgYMYu6rr9blUL322WfO27t39+04hKhPXbpAhVVSAJw65bq/PUD2pLYDZIvFwty5cwFISkqqMgO8fv16QN+g56nE9IXnWiwW0tPTeemll5wWNhLiYsgMshCNkKZp/Pvf/6Z///4ug2OA3/cfTJDRfQqoEJOJR4bVXcq26pINekLA9ddXr399BcgVM1A4W0dsn0F2lf/YHkDD+QA5Pz+fhIQEIiIiyMrKkkJPok5IgCxEI3Ps2DGmTp3K7bff7jF9W5vgYK+uGa74z5+KdevqewRC1D9XAbLN5ry9vgJk+/rhmJiYKmuM4fyyCWfH4HwAPXXqVEebxWIhPDycvLw8srKypDy1qBP+86onhLho77zzDp07d/ZYEc+uzNWr6QWUapSYrg833FDfIxDCt4YPd96+YYPz9pOuFu9foDYDZG8q5Nn7OMuckZub6zj++OOPO9pjYmLIyMiQDXuiTkmALEQjcODAAUaNGsWsWbMoLi72+ryl+/c6ysu6pCgol/S8yBHWrfHj63sEQviWq0wWrt4b18cMcsUA2VUAbOcsgH7ppZcA17PPQtQlCZCFaMDKysp45ZVX6NmzJ6tWrar2+X/JXU9xebn7TkYjavyYGo7QN1zNpgnR1HzzjfP2+giQK26cczbbu6HCdPeFAXB2drYj80XFtHBC+Ip/3zcVQri0bNky7rvvPnbs2FHlWIjJRJugYArLy/itqMjlNVYd3M97ebu4p98ADOVOykebTajxY1Cj/KOGs6sl1ZLBQgjd1q1V27TiIiZFhPHePXfSKjiYorIyFuz8iX+szyXfUjn1RW0GyBWDYmfp1/Ly8qr0s7Nv6JOlFKK+yAyyEA3MwYMHufnmmxk7dmyV4LhvZAs+mTCJQ7PuYf1NM9h9+yw233I7N/Xs7fRat912G/d89R/Mt94ErVrqpaMDA/V/27TGcOtNGK72n/ULP/3kvD0w0LfjEMIf9O3ruY/222HK//oS9/TuQdfw5oSYTbQKCWbWoAHkzrqNqb0rL5+qzQC54qxwWlpaleP2JRYXzh7HxsaSn59PRkZGpc15QviSzCAL0UCUlZXxz3/+k6efftppdooxHTuxcNJ1BBoMGFQVe8x4SWQL3hgbzxUdO3H3Uj1Jf7NmzViwYAFXXXWV3iluMErsIDhyDK2wACU0FKV1Kx89M+9t317fIxDCf3Tt6v53QispofytN6CoiGBT5Zf7AKMBMPD2pPHsOXWKnEO/AfqyiM61WLc9NTWVlJQU8vPzSUxM5K233nLkO7YvsbCXmLb3sVgs5OTkyLpjUa/8egZZUZRwRVFSFUXJUhQl59zn1f6Nqa3rCFFfVq5cSUxMDA8//LDT4Dg8IIDMidcSYjI5LfoRYjIzrWcvbu19CePHj2fv3r3ng+NzFEVBadMKNaqbXwbHAE5WkwjRZHmKY20bN0B5mds+gQYDT4681PG1s5neizFnzhzHLHBmZiYREREkJCSQkpLiWKO8fv16EhISSEhIIDk5mby8PAmORb3z2wD5XAC7B8gDEoG7gCggR1GUeF9fR4j6cPjwYWbMmMEVV1zBtm3bXPa7/ZK+qIri9lqhJjPPjxrDt99+67Filb+SGWQhzvMYIP+wBkpL3fZRVZWEbl0dM8wffvhhLY3uvIyMDHJycpg6dSoxMTFs2LDBUV0P9DXIqamp5OXlkZSUVOuPL0RN+PMSiyVAuqZp6ee+zgUSFUXJA7IURYnQNM2b2pK1dR0hfKbcCvOy4E/39OL06dMe+9/auw8hJvcV8QDaBYeAxQIREbUxTJ+TGeT6l52dTVpaGvn5+eTn5zuKNkRFRREXF0dCQgLx8fEN9k1YQ+JxJURhgVfXKbfZiAwMpKisgIIC786pLnvuYrv09HTHRjyphCf8kV/OICuKMgcIB5zd68k896/H0jm1dR0hfGnZdoh9Ch76AK+CY4BQs9mrfqrRCGdLLmZ49WrPnvoeQdM1d+5cIiIiSE5OJiEhgYyMDE6ePMmyZcvIyckhOTmZDRs2kJiYyF133VXfw20SPAbIgUFeXcdkUDl9bqY5NDT0IkflnZycHMB1BT0h6ptfBsjAdMCiaVrVvDCQde7fRB9eR4g6t243xP8Zxv4Ztuyt3rl7vQyksVohLKz6g/NjHTrU9wgaN4vF4lgzOm3aNMdt8Iqpt6KiokhKSnLcRpe0XL7hKkC21/5RY4foGWk8+OHAIU6XlKIoCjNmzKjFEbpm36AnPyvCX/lrgBwDOAtqAeyZxZ3Xrayb6whRZzZt2sTkyZMZ/gwsqeEa23lbNnLGw1pDAKV7NEpIcM0exE810NUiDUZiYiLZ2dkkJSV5tYErISHBadU0UfvatHHebi+mqQ65FJxs2q2osLSMF1evA/SNurNnz67NIbpkT/Fmz2AhhL/xuwBZURT720mnZX8qrBd2u8Cttq4jRF358ccfmT59OoMHD+arr76qcrxlUBCjO3ZidMdORHpI9Pv1nnwOFRbipNTHeSYT6sSr3PVokCRArjtz584lOzub8PBwr9eJxsXFER8v+599ISDAefvx4/q/SnAIhttmUa6qlFor/3WwaRqFpWU8t2oNS3/Rb1kNGTLEJ29uKpaYru0Z5IrV+4S4GP64Sa+2flvkvo3wS3v27OG5557j3//+NzabrcrxLs3CeGXUFVzZtRslViugEWAw8nV+Ho+uWsEBJ5toLhs1ilZPP4nh0ww4dRpKKqwzNhkBBcPMW1G71F5+U38hAXLdsc8YJyUleb3pTtaU1r+yCpnd1G5RfN+9D/s+/YgZ/ftgUlUURSF7z6+krvkfq/cfcPTt0qWLT8bnrsR0TSxYsMDxeXZ2tvwMilrhjwGyX1AUJQlIAmjTpg3Lly+v3wE1YKOdtDXF/89jx47xwQcf8M0331BeXu60T/fwcP47/WbCzGaMqkqQ8fyv6HXdezC6U2eGf/IRv57R1xw3b96cJ554gqFDh7Jj/z6UEUOJPHSY9rvzCSguxmowcLRTB37r1pWy48fAR//vBQUFdfI9vvHGKD79tHKQ37z5Lyxf/kutP1ZTt2vXLkd54ODgYJffz7r6XgvP9LXGo6u0r179A3v3Fju+/u/2HbyyeAn3L15CiMlEcXk5NvtC5QpOnz7t9ntZW9/rjz/+2PH53r172bu3mpsugBUrVpCens7BgwcrtaekpJCSkkL79u15+OGHiY2NvejxNkXyey0Bskvn0sKlA8TFxWmjR4+u3wE1ZB9XbWpK/59Hjx4lNTWVefPmcfbsWbd9P716Ms3NZqfFPoyqSnhAAB9dPZErMhfwyCOP8MILL2A0uv81bg50v5gnUAPLly+vk+/x4sVV2y65pCujR3et9cdq6o4dO+b4fMaMGS5vhdfV91p4VuaiBsiAAcMYOPD81xVzqBe6Ogno1q2b2+9lbX2v9+3bB+jLK2p6vdGjR/P0009f9FiEc/J77Z8Bsn1TnaeC8J4WGtXWdYSoEYvFwl//+lf+/ve/e5VbdFCr1kSHhzsNju2Mqkr/lq04uHETrfv3q83hNgjO/mucrFIRtcA+ewwQGenpz6ioD8XFztsvzOxS7KrjBYKCvEsLdzEsFovjZ0uWQgh/5o8Bsn1TnacFb66yU9T2dYSolvLycp588klee+01Skq8zzmc0KULZg87zgECAsyEHHe697TRkwDZdyquOT5x4oQU/vBDzm5ItWypf1TkTwEy6JX1pJiM8Hd+l8WiQnYJp/fzKmSnyPbFdYSojjNnzhAbG8vcuXOrFRwDBBqMbmeP7VQN+H/27js+qip9/Pjn3mnpQGjSm3RQ6U2kigviWgAVBXXdn6Jfe8G6TdfVxbquDRF1FRSUoIIUgVCkt1BDD71DgIS0aXfu74+bhCRTMoFkkkme9+s1LzLnnnvzDJDJM+ee8xzN9xzmys5k8m6TBLlsFJxSkZgob5MVka+811fBm4qUIFevXp2RI0dKciwqvAqXIOdKBFAUxdf9l7z6QT+E8DpCBGXcuHFs27btss5NSbtAZoD5gfksFpTatS/re4Q7X58fgvkrEyVXsFRbMPWPRej5GkH2leNWpARZiHBRURPkvHfjcT6OjQI26bq+qWCjoigTcreWvqLrCHG5zp07x7Rp0wq1NYiJoU18PNX9FSwt4OeUFJRgvpGqoLRvd3lBhjlfU2FPnw59HFXFCy8Yb6mbNm1i0qRJ5RyNKCocR5CFCBcVMkHWdT0Bo4LEw4qijMxrz02Au1Jke2hFUQYDLwATCo4Wl/Q6QlyJFStW5H99T9u2bH/gAXY++CArR4/myLhxzLrtNjrVqeP3fIfmZvrhVehKgB3xLBbUW4aj+JprUAU0bOjdduxY6OOoKiZMmJA/1WLcuHGFNngQ5S/YEeTs7OygricJshCXVMgEGUDX9XEYI7/jFEW5oCjKfqAb0EzX9aIL6zYCm/AxIlzC6whx2Q4fPgzAp4MH8/GgQbSOjyfSbCbOZiPCbOampk1ZetddDGvWzOvcvn37cuAD+L97N2NqsA4UNygF5g5YLGA2o948FFPvXqF6SRWOJMiht2jRovz5ol26dOHFF18M2P/AgQMy2hwivu6exMYWfq57PLRUdeaNHsGxpx/hyFPjmHr7zXSp571PtSTIQlxSEatY5CtYi7iYfmmA32rgwV5HiCtx9uxZ7mrdmrvbtCHGavU6rqoqUarKd8OH02ryZM7m5NC1a1e+/fZb2rZtC98bEyxM9Teg1tqB50xH9Oj7AVBatkTt1QOl6G+/KqZo+SqQBLmsNW/enIMHD/LQQw+RkJDA22+/zaRJk7jzzjvp0qULGRkZpKamsmHDBjZt2kRiYiIzZswo77CrhAM+hngKfv7WXS60qV/xdP3a2FQFVTHeY+5o05Kbr27O/7Ym88zCpfn9JUEW4pIKnSALEU7Onj3Lyz17+kyOC1KAJ3r0YNi77/rd5UmxZmNquA7uWVsGkYavOnXAbIaCGxGmpUFmJsTElF9clV316tWZMWMGBw4c4PPPPycxMZEff/yRSZMmERMTQ506dWjevDmjRo1i0aJF5R1uleErQW7R4tLX2s8/oB8+SKSp8M1is6pitqo8cG17jl3M4L21xtbPkiALcYkkyEKUEue5czT3NcRZRJTFwnMDBxIlW6CWmMkE9etD0Z1pjx+H1q3LJ6aqpHnz5kyYMKFQm+y4VX727/duy6vOp6ddQN+5vfCnySKirVZe6tOD/67fhMvj4cKFC2UUqRDhp8LOQRYi3Fw4fRpXkEV5LbpextFUXjIPWQiDrxHkvATZsyUJgnifURQY0qIpADNnzizF6IQIb5IgC1FKNu7ejSWIjT4AlBo1yjiayksSZCGMDXIOHvRuz5tioaddAE0r9jomRaVeTDQAc+fOLc0QhQhrkiALUUqOp6Yy/+BBtGJGkTOcTtQbbghRVJWPJMhCGNOKnEUqQlavDvmfvaOijeHhYmi6h4sO40LBloMToiqQBFmIUpCeng7Ah+uSwOP/l5Jb83AqKwulQ4dQhVbp+EqQ9+wJfRxClKdA0ysATB2vNVa0FsOimliw/xAAsVW8So4QBUmCLEQp2JObob1XvT/aNg+4gaJ3N92gOhReX7Khym70URp8fbbYsCH0cQhRnoqrYKHUa4BS5yrcAeYhZ7tcTNuxi3SHA0VRGDt2bBlEKkR4kgRZiFKwe/du+sc0opUtHmuaCVYDB4BMIAe4AOwEdZ3Ca40Hl2us4a5rV++23bshdxBfiCrB112TgiPIAKYxD3LO7iDH5V3JIsvpYvvpszy9wKiDbDabeeaZZ8oiVCHCkiTIQpSCPXv28Git64hWLUaDGzgKrAfWAJuBVECHpnYL+hnJ5i5XjRrQqpV3+8aNoY9FiPKyerV3W9FShw6Llc6TvuW9tRs4n2Mnx+XG4dY4mn6RV5euYNDUGdhzy8BNmDCBFgWHoIWo4qQOshClICkpidtttfN3qgpEtVnQT6eh1KkWgsgqp+7dYe/ewm3r18OgQeUTjxCh5HAY/9+L6tOn8POtW7dyNjOT15ev4Y0Va4mPjEDz6Fyw2wv1s1gsPProo2UYsRDhR0aQhSgF69evJ0NzFt8RQPOgRNnKNqBKrnt37zZfCYMQldGGDUaSXFCdOtCyZeG2devW5X/t0XVSs3O8kmOAa6+9loiIiLIIVYiwJQmyEFcoPT2dCxcu8N2FXeR4XMWfEG2DZnXKPrBKTBJkUZWtWOHd1revd1W39UH+UHT39QMlRBUnCbIQV2jZsmWAUcItQgk8aylLc6E+MBAlyA1FhG/XXQcWS+G2EyeM2rBCVHb+EuSiJEEW4vLJb2khrlBiYiJ1zVF8WG8giqaAjvEoQtd1jrgzUEdfH/IYKxubzUiSiypwR1mISknTfC/QK5ognz9/nn379gV1zR49epRCZEJULpIgC3GFZs2axZ9rdEQhNzl2cylJLvBQNIWGNtliurT4GvTylTgIUZkkJ3uXNIyNhWuuKdy2Icji4NWqVaOVr7IwQlRxkiALcQVWrVrF0aNHuT22JZFqgekVGkaiXPChY5SBO3KuXGKtbHwNes2aBQH2RRAi7PmaXtGrl/emeeuCvJ3SrVs3VJnyJYQX+akQ4gq88MILAESowVVMVM0mcHoX7RclN2SI96KklBTYsaN84hEiFGT+sRChIQmyEJfJ7XazZs0aAE65stCDGbp0aXBV9TKOrGqoW9e77ivAzz+HPhYhQiEnB+bP924vmiB7jh1mTKyFjQ+PZdWf72F8727UjPRdxk0SZCF8kwRZiMs0c+ZMdF3nOlsdulvrGXOQA1EVlH7tUOIiQxNgFXDHHd5tP/0U+jiECIX58yEjo3BbXNyl6Ua6y4V76mRcX3/KbVc35ZqratOtwVW82q8n+59+iDvbt/a6piTIQvgmCbIQl0HXdf72t78B8HGdQUQqZr/VK/LZLJie+ENI4qsqbr/du23LFjh4MPSxCFHWpk3zbrv9dsjb40Ob+R36wX2objemAvOKoywWoiwWJv1xCIOaN85vb9SoEfXq1SvrsIUIS5IgC3EZJk6cyN69e2lpqU4HWy2jUaNw5Yo8upFQK7d2R2leN/TBVmJNm0KnTt7tMs1CVDYZGTBnjnf73Xcbf+pnTqHv2w1u/2scoiwW3r6xX/7z9u3bl3aYQlQakiALUUInT57k2WefBaCjrTZawWw4r3qFp8BDA8WtwNmLoQ+2CpBpFqIqmDULiu4SXasWDBpkfK1tWAMerdjrNK9RnTa14gFjF1AhhG+SIAtRArquM3r0aOx2Owpwf2wHYhSLd8fcxDh/VBlASimVCV/TLFavhlOnQh+LEGVl+nTvtpEjC+womXoaPJ5ir+PyaDStXg2ArVu3lmKEQlQu8htbiBJ4/PHH+f333wH4V3xf+tkaFr84DyDKinq99wIZceXatYOi+xzouowii8rj3DlYsMC7ffToAk+stqCupaCQ7XIBkJOTUwrRCVE5SYIsRJA2btzIp59+CkC8GsFjcZ2IUi3FL87LpQzzsTeyuGKK4nsUeeJE2TREVA4zZ3pPLW7QAK4vsGu92uG6oJJkVVFYd+wkALGxsaUZphCViiTIQgRp/Pjx+V8/X60rFiX3xyfvrqa/ZMxqwjRhNEqktUzjq8ryFioVtH07LFsW8lCEKHW+qlfcdVfhWVtK245oxXwizHG5+XLTdhyahqqqjB07tpQjFaLykARZiCCtWrUKgPdr9OepuC6YlQI/PkUrWOQ+dEC9sxfqkGtCHm9Vct11hUfT8nz4YehjEaI0JSf7/qBXaHoFoJjNfJWjk+l04vExFznb5SL5zFn+umQlADabjWeeeaYMIhaicpAEWYgguVwuXozrzp9iOmJRTN4jxnkL8wpWr7BaUTo0CnmsVdFTT3m3zZ4NBw6EPhYhSss773i3tWwJXboUbvN4PLz93XSu/3Iac/cdwO5yk253kOFwcj7HznurNzLwfz/mjx7PnDmTFi1ahOZFCBGGzOUdgBDhIlI182K17kTnzTv2tzavYOLs9qD0aeWnoyhNt90GjRrB0aOX2nQdPvkE3nuv/OIS4nIdOQLff+/d/tRTxtz7gtasWcPhw4cBGPHDbGpGRtCkejWcmsaus+cKTb946623GDp0aFmGLkTYkxFkIYLgcDi4ObIFnqLDxoGm/FlMKH1bodSJK9PYhMFshsce827/8kvIzAx9PEJcqf/8x3txXq1a8Kc/eff9vkgmfS7HzqaTp0k+k1ooObbZbDzyyCNlEa4QlYokyEIE4dChQzRUY7AppkuNgRbnqQrUjsP077tCEZ7I9dBDEBlZuC09Hb75pnziEeJyXbgAkyZ5tz/xBERFFW5zuVz8+OOPQV33lltuIS5OPrQLURxJkIUIQkpKChm6E3fRVeIevBfnAXRohPnXZ1HiY0IaZ1UXHw9jxni3//e/Qe2hIESF8emnkJVVuC0qyvddkkWLFpGamhrUde+5555SiE6Iyk8SZCGCkJKSwvycg6i+Jh7rFN5a2mzG/M7dKNWjvPuKMvfkk95te/fCnDmhj0WIy5GTY3yoK+r//T+oWdO7vej0Cn+qVasmc4+FCJIkyEIEISUlhRNaJon2Q9g9br/9NAWU9g1Qrq4bwuhEQR06wKBB3u0vveQ9n1OIiuibb+DMmcJtJhP4qsqWlZXFL7/8EtR1R44cSURERClEKETlJwmyEEFISUkB4MHUBRzWLpLjcXn1sXvc2GPMmCY+EOLoRFG+Eoldu+CLL0IfixAl4XTCu+96t999NzRt6t3+66+/klV0LoYfMr1CiOBJgixEEPIS5HTdQa+T3/HuxY2c03LI8rjI9DhJ9zj4KGMTOyfcKFUrKoBhw6BvX+/2v/8dLl4MfTxCBOu//4X9+73bC2zkmU93u1n/80z6NmlIg9jA6x3q1atHv379SilKISo/qYMsRDFcLheHDh3Kf56pu/hn+hreTF9LfVMMKgrHtUzceDh+XbvyC1TkUxSj9nH37oXbz56Ff/8b3nyzfOISIpATJ+C117zb//AHuPbaS891lwtt2QI8G1bxarO6eJr+EZvZzIbjJ3lx0XKSTpz2usbdd9+NyWTyahdC+CYJsigf3/vbZaPiOXLa99xVDZ2jWkb+80gr1FvawP8GIiKkunWDe+7x3mjhgw/gkUegcePyiUsIf1580btmt6oaH+ry6C4X7q8/hjOnUNxu4iJs+cduaNqIxPvvZOQPs1h84Eih68j0CiFKRqZYCFGMFO/BGJ+uruu9u5UoX2++CTZb4Ta7HV55pXziEcKfVatg6lTv9kceKTx6rC39Dc6c8rviNNpq4cc7/0iU5dL4V6tWrehSdG9qIURAkiALUYyUU8H1K/XCFaqt+D4ioCZN4Omnvdu/+w42bAh9PEL4omnw+OPe7TVrwj//eem57najb1wTVDmWuzq0yf/6nnvuQZFP70KUiCTIQhSjJCPIparuwFK+YNX08svG9rxFPfccFN33RYjy8MUXsGWLd/u//mVsfpNHP3ksqClcsTYro9q3yn8+evToUohSiKpFEmQhihF0gnxVKX1D1Qb1hkKv/5XSBau2atV8L3xasQImTgx9PEIUdO4cvPqqd3vnzsbGIIW43QS7yCHSYgFAVVVatWpVTG8hRFGySE+UvXuMYbply5bRv3//8o3lMqT8sy2wu9h+V9+zGAbKqG9F9NBDRvmsPXsKtz/3nPFP1rp1+cQlxF/+AufPe7d/9JGxOUhBSo140IqfXuHSPOw8cw4AXW6TCHFZZARZiAA0TWO/r6KkPlhyR2xExWOxwIcferfn5MDYseDy3vdFiDI3f77vuxhjx0Lv3t7tSvV4cqrFex8owqVpTNxgzNmIjo6+0jCFqJIkQRYigGPHjuEqkD21qlmDx7t34vne3bijbUusBYZ4pk+fXh4hiiDddBOMG+fdvmGDMddTiFA6cQLuu8+7PTYWJkzwf96EpGSynf4/0WW7XCw6cJjtZ1JRVZX777+/FKIVouqRKRZCBLBv3z4AGsbF8N2I4Vx3XfPb1AAAIABJREFUVW1Awawq5Ljd6Dr8dclKJm7cytSpU/nkk0/KN2AR0LvvwuLFkLsxYr433oChQ6FHj/KJS1QtmmaMEqemeh97/XWoV8/3edu2bePNb6aSdHVTpo0aDjrE2KyAMWrs1DwkHjjMmIS5AFitVp7xte+6EKJYkiALEcCOHTu4KiaatQ+NIT7ChrnAiLEl9+u3Bt9AjNXK+2uTyitMEaSYGKPWbJ8+RpKSR9NgzBijkoDckRZl7d//hiVLvNtvugmefNL/eX//+98BWJByiMbvfc7ojm0Z2b4VkWYzO86c47MNm9l22si6zWYzP/30Ey1atCiLlyBEpScJshABJCcn8+agvtQokhwXFG218Nd+vZh98GiIoxOXo0cPo2rA668Xbk9Jgeefh88+K5+4RNWwciXk5rmFXHUVfPutsXOeL0lJSfzyyy/5zzOdLr5I2sYXSdu8+prNZlauXEkPuSUixGWTOchCBHBw9y5GtGuZP1ocyPv33hmCiERp+MtfjK2oi5o4EWbPDn08omo4f97Y/rzg3QswduCcMgXq1PF/7l//+tegv89zzz0nybEQV0gSZCH88Hg8cOYUDs1TbN9Ii5l+TRqGICpRGiwWIyGJjPQ+NmYMbPMelBPiiug6/PnPcNTHjaaXX4bBg/2fu2bNGubPnx/U94mNjWX8+PGXGaUQIo8kyEL4ceTIEbJzcoDg6ojaImRr6HDSurWxaK+ojAwYPhxOngx9TKLy+vBDKDBDIl/v3vCPfwQ+tySjx08//TQ1a9YsWXBCCC+SIAvhR3JyMrvOnsNmCmKqvsmE0kQWw4SbRx+FYcO8248ehVtugays0MckKp+EBHj2We/26tXh+++NOxr+LFu2jMWLFwf1fapXr86zvr6REKLEJEEWwo/k5GTS7A5m70nB7SlmmoWiYOruo7K/qNAUBb77Dtq29T6WlAT33us9X1SIkli2zPh/5GtDuy+/hCZN/J/rcTp557XXMCnBbS/9/PPPU7169csLVAhRiCTIQviRnJwMwEuLlpNud/hNkp2A2mcASrUaIYxOlJbq1WHuXKhd2/vYrFnwwguhj0lUDlu3wq23gtPpfezxx+GOO3yf50nZg/vLT3C98QrTe13D+Ref4ItbhtAy3n/yW7NmTZ4MVCNOCFEikiAL4Udegnw8I5Pek79n++mzZDtdODUNj66T4XCS6XSyt25j1AE3lXO04ko0a2ZUr4iI8D72/vu+twMWIpBDh4zNZy5e9D52yy3wwQe+z9OWLECb9jX64QOo6ESYzURazNzTsR3rHhpD38a+FwO/+OKLxMbGlt4LEKKKkzrIQvjgcrnYtWtX/vODaen0+OI7rqlbiyEtmhFhNnHgQjo/79pH0rZtKEHeAhUVV8+eRmWLUaO8jz3+ODRtCn/4Q8jDEmEoNdXY9MPXQs9evWD6dDD7+O3r2bMTz6ql4PLeStpiUrGYrPxy9220/Ggy53Ps+cfq1q3LY489VpovQYgqT0aQhfAhJSUFp4/7ottOp/Lu6g28sXwt32/fhaaqXH311eUQoSgLI0fCW295t2uacTt84cLQxyTCS1aWUQVl717vY23bwq+/QlSU73M9yxb6TI4LUhWFB65tX6jtlVdeIcrfRYUQl0USZCF8yJteUZw2bdpgCbQEXYSdF1806tUWlZNj3BqfNSv0MYnwYLfDnXfCunXex+rXh99+A38V2PTsbPRTJ4r9HtFWC/df1yH/eUxMDA8//PDlhiyE8EMSZCF8CDZB7tChQ/GdRFhRFGO76UGDvI85nTBiBEybFvq4RMWWnm7MOZ43z/tYtWpGcty4cYALOHJALX7HToBqBWquu91uInxNnhdCXBFJkIXwQRLkqs1iMWrXdunifUzTjLJdX30V+rhExXTqFPTvb5R0K8pmMxaAduxYzEWiotE9wdUUPJV5qUC3w+EIOk4hRPAkQRbCh+3btwfVr2Oxv/VEuKpeHRYvNnY6Kypv2+CPPgp9XKJi2b8f+vSBLVu8j6mqcbfhhhuKv45ii2CvUzO2uA8gw+Hkk/Wb859L5QohyoYkyEIUkZOTQ0pKSlB9ZQS5cqtWzViY52u6BcCTT8K//x3amETFsXmz8QHqwAHvY2YzfPst3H57cNdavXo1f/rf99jd/keRNY+HTKeTGTv35n4PM2PHjr2c0IUQxZAEWYgidu3ahe5r26siYmJiaBxwUqGoDKKjYc4cuPlm38dffhleekl23KtqliyBfv3gzBnvY1FRRrWKe+8N7lrZ2dk88MADbDxxigdn/0a2y4XD7S7UJ9Pp5Gx2DoO+/RF77jGr1cozzzxzpS9FCOGDJMhCFLFkyZJCzxvExjCgWSP6NG5AlOVS8dIWLVqgqvIjVBVERMBPP/mukQwwYYKRQJ87F9q4RPmYMcNYkJeR4X2sZk0jeS5JzexXXnmFffv2AfDTrn1c+9k3fLJhC8cvZnIhx86e1PO8lLicdp98Rcr5NFRVJSoqioSEBFq0aFFKr0oIUZBsFCJEEVOnTgXg2rq1eXtIP3o2rI9DcwMKFlVl6radvLp4hc86yaLyslrh+++N0cFvvvE+vmCBsahv5kzfi/tE+HO74fXX4Y03jHnoRTVubPw/aNMm+Gv+/vvvfPjhh4XaDqdf5KXE5byUuNyrv6qqPPzwwzz//POSHAtRhiRBFqKI5ORkejeqz9x7RxBtNWocRxYYOb7/uvYMaNaYgVMSyitEUU7MZqN6RXQ0fPqp9/HDh40FW59+Cg8+GPr4RNk5fhzuuQeWe+esAHToYJRya9Ag+GtmZmbypz/9Kej+FouFpKQkWRwsRAjI/WEhCtB1HUXXmXnXrfnJcVERZjONq8Xy1gAf5Q1Epaeq8PHH8NprRs3kohwOo8LFww8bG0eI8Dd3Llx7rf/kuE8f41hJkmOA8ePHc/DgwaD7/+Mf/5DkWIgQkQRZiAIOHDjAra1bYDEFLtgfYTYzsn1rdHtOiCITFYmiwN/+ZiRONWr47vPFF3D99caosghPTic8/7yxdbS/+eW33GJUOvH3/8CfRYsWMXHixKD7d+vWjRdeeKFk30QIcdkkQRaigKSkJP7Y5mribNbiO6sm9CPBj/6IymfoUEhKgk6dfB9PSoLOnY15yUEURhEVyMGD0LcvvPee7+OqatxF+PlnY156SaSnp/NgCebg2Gw2vvnmG8xmmRUpRKhIgixEARs3biTa4ntqRVE2m9VYtSOqtGbNYNUqeOAB38fPn4eRI+G22+Do0ZCGJi6DrhtVKjp1gvXrffepV8/YROZvf4NibjZduu65s7jnzMT1779ifu81lo8Yygt9ulMzsvhtot944w3atm1bglchhLhSkiALUUBSUhLbz6Tm1xkNRAWU+FplH5So8CIjjcV7n39uVLvwZfZsaNcOPvxQaiZXVCkpRrm+O++E9HTffYYOha1bja2lg6Vt34z7s/fQk9ZCTjZWRaFhtVheuaEHOx9/kGvq+n8f6dOnj9Q6FqIcSIIsRC6Px0NSUhJfbQpum2mqx6NcVb9sgxJhQ1GMhXkrV0KjRr77ZGbC009Dr16+tyYW5SMrC/7yF2jfHubP993HbIa33zY2jaldO/hre44fxTPrB3C5oMg20lEWC9UibCwcO8rntK7IyEi+/vprTMEOUwshSo0kyELk2r9/P+np6Ry9mMG3W3aQFaDOsW42Yxp6WwijE+GiWzfYtMlYvOXPhg3QtSuMH28kZ6J86LoxP7xtW/jXv4xFeb40aQIrVhj/XiXdG8jz+0IjOfZDVRSsZhNjr2nndWzChAm0bNmyZN9QCFEqJEEWIldSUlL+10/OX8IPyXvIcblwuC/dD890OslxuzGPuBe1RavyCFOEgVq1YNYsYy5rvXq++2gavPuuUT/3p5+8BhdFGdu9G266yZgfHmhu+O23w+bN0LNnyb+H7nKhp+wptl+M1cq4btcWahswYACPPfZYyb+pEKJUSIIsRK6NGzfmf+3RdR6Zs4jOE6cwceMWVhw+RuKBw7yauIInD55BbXdNOUYqwoGiGMnXrl3w6KP++x06BCNGGIvCJFEue+fPw4svwjXXwKJF/vs1amR8wJk5s+Ql3PLZc0AJ7tdsrSKlML766ivZyl6IciQ1Y4TIVXAEOc/+C2mMX/h7obZ37hoTqpBEJVCtmrGz3pgxxhzlHTt899u2zUiUO3aEv//dGLmU/Kj0HDsG778PkyYFntZitRpTKV5+2dgx8YrYbOAJbkVmut2R/7WiKDRt2vQKv7kQ4krI268QXFqgF4wuXbqUcTSiMurd25ib/MYbRt7kz/btxsjztddCQoKMKF+pXbuMbb+bN4cPPgicHA8dCsnJxr/RFSfHgGK1ccxkxVNMEexsl4uvNl9aHBwTE3Pl31wIcUUkQRYC2LdvHxkZGUH17dy5cxlHIyorqxVefdVIggcODNw3ORlGjTIS5R9/lJLbJbVunTEK364dfP11wHVyNG0Kv/xi7IxYmmvidu/ezUPfTifHFfgfz+3x8PXmZADMZjP33Xdf6QUhhLgskiALge/pFb60bNmSatWqlXE0orJr2RISE40tinv1Ctw3ORnuusuYE/vCC8aIqPDN7TaS3AEDjEV1v/wSuL/NZkxn2bkTbr3VmDdeWlwuF2PHjmXxvgO8ungFWU4XWpHbAU5NI9Pp5NZpv5CabWxbb7Vape6xEBWAJMhCUHiBXiBdu3Yt40hEVaEocOONxi58CxcaUzACOXUK3nnHGBHt2dPYlMTfZhZVia7D2rXw5JPQoAEMHw7LlgU+JyoKnnoK9u6Ff/zD2OiltL3xxhv57yufbtjCTVMSmLP3AC7Ng9vjIcvpYnLSdjpP/JZVR46jKAqRkZEkJCTQokWL0g9ICFEiskhPCIIfQZYEWZS2vER58GBj++J//MNImgNZt854PP003HEH/OlPxpSNqrSob8cO+P57mDYNDh4M7pz4eHjiCXj8caMUX1lZt24d//rXvwq1rT9+klE/zgbAZjLhKLCdoqIoPPjgg7z88suSHAtRQUiCLKo8j8fDhg0bguorC/REWVEUI0keNAiWLDES5ZUrA59jtxtJ4vffG1Mwbr7ZSLYHDoTq1UMSdkgdOgQ//GC83m3bgj+vYUN4/nn485+hrNe/ZWVlMXbsWLQA+4k7ihybO3cuQ4cOLdvAhBAlIgmyqPISExPJycnJf241magXE42mezh+MZO89eeKotCpU6fyCVJUGYpiJMkDB8LSpfDJJ/Drr4EXmYGx2cXEicZDVY0d/QYPNhLmXr2MBYLhRNfhwAFYvvzS48CBkl2jbVuj5vHo0aF7/ePHj2ffvn1B93/00UclORaiApIEWVR5b7/9NgB1o6N4qW8P7r+uPWBsAXvR4eTDNUl8tH4zUbGxxMXFlWeoogpRFCNJHjgQUlPhu++MagxbtxZ/rsdzaRrGv/5lzLnt189Ilnv2NBLHijbC7PEYCxALJsQnTpT8OjabMZL+wAPGn6GcdjJ//nw+++yzoPu3bNmSd955pwwjEkJcLkmQRZW3fPlymlWvxso/jybOZsVmvvRjEWWx8Nf+vRjRrhU3ff9TOUYpqrJatYxFZU89ZWx7/PXXRsJ8/nxw52dnw/z5xiNP/frGgr+ij5o1y+Y15Ll4Efbvh5SUwn9u3w7nzl3eNVXVGHW/5x6jtFt5FJpJTU3lwQcfDLq/yWRiypQpRJdGwWUhRKmTBFlUeS6Xi9n33E58ZAQmH8NNURYL7erU5N8Dry+H6IQorFMn4/HOO8bUi6+/ht9+K/mGIidOGI/ExMLtdepAq1ZGoly9euCH2Qy7dsWiKEYSnp0NOTmF/8zMhCNHLiXCZ8+W3t9Fjx5GUnznnXDVVaV33WB5jh/Fs3oZ+v69WDIz+eWWQXyweiM/7dqHq5h/kFdffZUePXqEJlAhRIlJgiyqtMzMTHo3qk+D2BifyXGeKIuFe69ph263o0REhDBCIXyz2Ywd90aOhAsXjIV9ixYZCe/+/Zd/3TNnjEfwQrdwVVWNDwe33WbMKy7Pgg/a4nl41iw3ii/rOlEmlc716vLp8Bt54fruDP5mBhfsdp/ndu3alb/85S8hjlgIURKSIIsqbcOGDYxs15ooS/E/CorJhH5wH0rbjiGITIjg1agBI0YYDzDKni1aZDwWLzYS6HBksUD37nDDDcajd2+oCMsAtE3rjOTYx8rJWJuVVjVr8Mvo2+j39XSv4xEREUyZMgWLxRKKUIUQl0kSZFGlrV69moaREahBrOSxWa3gcIQgKiGuTLNm8PDDxkPTjHnLixbB+vXGQriUFKO9oomMNJLgvIS4R4+y2cTjSugeD54lvwUsK2Izm7mmbm261K9L0onThY698847tGnTpqzDFEJcIUmQRZW2atUqumRdwOF2F1qc54uqqhAn20yL8GIyQdeuxiOPwwH79hlbLBd87N1bfDm50oinaVO4+mpjikTeny1aGFtwV/RydPqJo0F9ULaZTTzYqWOhBHnIkCH83//9X1mGJ4QoJZIgiyrL4/GwZs0aduoexvfpXvwJFgtKU9nlSoQ/mw06dDAeBblcxvzlY8eMbazT0vw/LlwwahVr2kXq1IkjKsoY7Y2KotDXkZHGwr+8ZLhxY2NxX9jKzDBq8BXDrKo0iovNf16jRg2++uqroO5WCSHKXzi/TQlxRXbv3k1aWhppwOw9KdzSugVRfuYF6mYzpoFDUeSXm6jELBZo08Z4BGvZsk3079+/zGKqcCIiIX/7IP88uk5qdnb+888++4wGDRqUYWBCiNIkv+1FlbV69er8r/88awHLDx0j0+nEU6A8k1PTsLs1TNcPwtS1Z3mEKYSoQJRGTdE8xSfIWU4XU7btBMBsNnPXXXeVdWhCiFIkCbKoslatWpX/tVPT+OO0n7l12i/M23eQI2kXOXAhjf9tTub1k2mYBgwpx0iFEBWGqjIl5TBZTv+Ttd0eD6ezslh68CgA999/f6iiE0KUEpliIaqsgiPIeVYcPsaKw8cKtX366aehCkkIUcHNnDmTR76dTtyImxlydVNiiqwqtLvdpNkdDJs6EwCr1crLL79cHqEKIa6AjCCLKik1NZW9e/cG1bdPnz5lHI0QIhxkZWXx7LPP4tF1RifM4dFfF7H11BncHg9OTeN8jp13V22g02ffcCjtIqqq8vPPP9OiPHc0EUJcFhlBFlWSr9FjX2JjY2nfvn0ZRyOECAdvvfUWR48a0yZ04Icde/hhxx5sJhNWk4kMpzO/r6qqLFy4kEGDBpVTtEKIKyEJsqiSgk2Qe/bsiclkKuNohBAVXUpKCu+8847PYw5Nw1Fk55WXXnpJkmMhwphMsRBVUrAJcu/evcs4EiFEOHj66adxFhghDqRhw4a88sorZRyREKIsSYIsqhyn08mGDRuC6ivzj4UQc+bMYe7cuUH3f//994mOji7DiIQQZU0SZFHlbN68GbvdXmw/RVHo0aNHCCISQlRUdrudp556Kuj+AwcOZOTIkWUYkRAiFGQOsqhygp1e0bFjR+Li4so4GiFERaSfT0U/eZxfZ87Efe5sUOeYzWY++ugjlCC2ohZCVGySIIsqZ+HChQB0rFOLZ3p35fa2LYm0mEmzO/hq03Y+WbeZ4xmZdOjQoZwjFUKEmn76JNqvCegnj+FRVAZmZ7D9//7EumMneGxuIvvOp/k994knnqBdu3YhjFYIUVZkioWoUnRdZ/ny5Yy9th0r/jyauzu0JtpqQVUU4iMjeLxHJ7Y+dj/dG9TjzJkz5R2uECKE9JPHcU/+L/rRQ+B2o7qcxNlsRFrM9G3SkFX/715a16zh89y6devy97//PbQBCyHKjCTIokrZt28f7WvE8dHNg4iyWjAXKeEWYTYTZ7Mxd8wd7N26uZyiFEKEmq7ruH/4BvxUqjCpKrFWC1NH3Ozz+Ntvv021atXKMkQhRAhJgiyqlGXLlvFy3x5EFFPb2Kyq3NmqeYiiEkKUN/3oIcjKCNjHpKpcHV+Da+rWKtTeu3dvxowZU4bRCSFCTRJkUaWs+n0ZQ65uiqoG/q8fbbXwUNdrQxSVEKK86QdTwOUqtp9JUejXtFH+c0VR+Pjjj4t9TxFChJcKuUhPUZTqwMtAZyAeSAR+0HV9UwnOn5H7tOiKiuq5f07QdT2xFMIVYULXdZJWr0ZreisEsTle3bjYsg9KCFEh6JoGul5sP1VRMBdIhh955BE6depUlqEJIcpBhUuQFUXpDCwGXgTeAppjJMtJiqLcWIKkdnAxxz+//ChFONq7dy/7jh7DpAZXgskSJ/MJhagq1DpXoVlt4HQE7GfX3Ow8ew4wRo/feOONUIQnhAixCpcgYyTHk3Rdn5T7fBMwSlGU/cAiRVFq6Lruv85OYV0wRqDh0shxnqBGo0XlsWzZMpyaxoKUg9zcsnnAW6KaomLr2TeE0QkhypPSpgPM/rHYfna3xqL9h/Ofx8fHB+gthAhXFSpBVhTlBYxE1tfobgLwAnAnMMnHcS/BTskQVcOyZcsAeGv5egY1a0KU1X+CbLJaUTvLLnpCVBWK2cz66nVpf3Q/0VaLzz7ZThdPzluMJ3cqRkxMTChDFEKEUEVbVXAXkKbr+gEfxxbl/jkqyGsFO8osqgBd11m6dCkAG0+c4vG5i8l2uXBpWqF+drcbp6JgGvMwSlR0eYQqRHg4cwaGDeOGIUNAUcL+4VEUHnrsacYvXEa2y0VmgXJvGQ4nWU4Xj85ZxE+79gGwELiYkVHucYfy0X/AgHKPQR65j4gIGDbM+DkUZaJCjSBjLMrzN+q7MffPrkFe6/yVhyMqiz179nD69On851O37WTzydM807srd7RrSaTZ2Envy03bufPt/9CyUZNyjFaIMPDAAzB/foUbZblcPwO7gF2btjM9eTf3dGzL9Y0bAjpLDx3lh+TdZLvcAHSn+EUuQpQphwPmzzd+DufNK+9oKiVFD2LVbigoitIc2A8k6rp+o58+OoCu60oQ11oE3AhMwEi8m2Mk358XmN8c6BoPAw8D1K1bt8v06dODfzHCp8zMzHK7JTl79mw++OCDYvvFx8eTkJCAogT8LyaKUZ7/1iI0bhgyBDWIsmjhQMf4JbElyP6zgD+WXThCBM1jsbB84cJSv25Veg8fMGBAkq7rXoOvFWkEubR3ZchLuDcBBzAW63UGPlcUZZS/JDxPbhI9CaBr1656//79Szm8qmfZsmWU19/jZ599FlS/IUOGMGDAgDKOpvIrz39rESKVJDkGmEfwyfE1wPAyjEWIklBdrjJ5r5X38Io3B7m0VMdIjFvout5F1/UbdV2vAbyde3xw7gixqAJ0Xc9foFecqv6GIERVowP/LEH/V6m8vziFEJdUyp9zXdc35SbGB4q0v4ix6QgEv9hPhLndu3dzJsiFDJIgC3EFdD3sHksSE1kX5Mtr3bo1I9zuco+5vB7Lli4t9xiq/EOEzBUnyIqiLFIURb/MR8HaxHnJbHFFJa+0OsWE3D9Le0qHqKCCHT2uV68erVq1KttghBAVSkk2+njllVcwmYLYhlMIEfaueA5ycXN5SyCv6kTRDT2K8lUCriTyzpcycFVEXnm34vTv318W5wlRBejZ2XAxjU3btvF7kB+gmzVrxujRo8s2MCFEhVFhFunpup6Wm5z4HNnNrUwBl6ZIXK68BPxKryPCgMw/FqLq0FNOoCWsRE85gWIxo/Rtjzq8B0pclHH89Em0xHno+/eC2Uyr7GwOPfMw763eyCfrN6MFuIX90ksvYbH43kBECFH5VJgEOVcixgK6zj52wcsrO/lDoAsoijIBo5Sbv5HmvFIeb11+mCJc7Nq1i7Nnz+Y/jzCbibNZuehwYne7C/WVBFmIik1PvYhnzgb0g6ch0obavwNK95agedBe/x591U5wa6B50AF97zE8kxegvnIXSotYtO8mX6q+obmJMKnUi43htQF9GNKiKbdO+9lnktygQQPuv//+kL5WIUT5qmgJ8ucYifC43EdBo4BNRRPn3IT4nK7reRUqfsi9jtfUj9w5zxOAUbquyxSLKmDGjBkAdKlfl1f69mBIi2Z4dA8mVWXpwSP8a/la1h47Sd26dWnZsmU5RyuE8EXXPGgfzEL/Za3R4DQ+3GrzN6JF28hpFEfknpOYXJ7CJ9qNZDjz71+j9jcRYfa97CbaaqFP4wY817srb6/a4HV8/Pjx2Gy2Uns9QoiKr0IlyLquJyiKMgl4WFGURbquJwAoivICxshvl4L9FUUZDLyQ+3VibvWKTYqiNFcUZQZGorwRY+FfXuI9Std1mV5RRXz77bfc3aENE2+5kQiTCVVVAWORzY0tmnJ944Y8t2ApKzIdMv9YiApA33UM7Zf1cPoCxMei/rEbnrkb0Bdsyk+M8+U4UbIdRKddDPjzG1XfgqZ7/B4HI0l+umcX3l29EU+BUeTatWvz0EMPXdFrEkKEnwqVIAPouj5OUZQkYJyiKF9gLN7bBDTzMeq7MfcYRUaWXwRexthNLy233yJd17sgqgxN07BdTGPinfcS5WPuoKooRFstvHfTAP4w7edyiFAIkUdPz0Z7cjL63hNGIuzRQVFwztmAigd/6a9qUtAppvzVVWCyFF+0yWY2c03dWmw5dWla1nPPPUdUVFQJXokQojKocAkyQMFd7Irpl0aRUeXc9gQgoQxCE2Fk06ZNPNWzCxZT4F+MNrOJJ7peG6KohBBF6U437gc/hqOp4NIKHNAxaTq6aiTLPikUf/cnyMpsmu4p9GG6Ro0aPProo8GdLISoVCpkgixEaVi4cCHj2rXCUkzdUrOqcmvrq0MUlRDCs+0wnv8tQ1+1x1hUF2uDbHvh5DhPMAlwcXJAj9VR1MDXsZnMHEm/mP/8qaeeIi4u7sq+txAiLFXKnfSEAFi0aBFRluA+A1pNKron8BxFIcSV0z5biPbnz9AXb4dshzGdIi3Ld3IcDA8UN8NmI9uWAAAgAElEQVSCo7n9irH55GmOXcwEwGKx8MQTT1xeTEKIsCcJsqiUMjMzWb16Nedz7EH11602FFV+HIQoS9r8zXi+WmJUl/AEuW2uTuAEOIjL5Jx3c/Jclldpx4KyXS5eWbwi/7miKMTHF7exqxCispKMQFRKv//+Oy6Xi8mbtpOTV/fUDw0FU5eeIYpMiKpFz8hB+24lrlem4XltRn7ptaAFMfLrcLlxebRC1Sfy5GguUuwX6PHNVDadOE2Gw4mnwN2ibJeLLKeL+3+az+qjJ/LbXcW8bwghKjeZgywqpYULFwIwccMWHuveicgAG2CZrBZMvW4IUWRCVA26ruP5cimeTxYYC+zsLmNIxtc04Ly81t8UYQ1joZ2P43aPm+POTB7YPZ9XG/Wkf7VG2D1a/ujPF6e38c+ja8j2uOn/vx+4oUlDnujRmda1amB3afy4Yzdfb07mXJG7TbGxsZfzsoUQlYQkyKJSWrRoEQCns7L5w5QE5o8ZgdWkEm215vfJdrlQzRaixz6MUr1GeYUqRKWkTVqMNnERqsP/tIZ8HgJXmtAhx+UiW3FjVY2Ouq5jUU38emE/jx9OJE1z8MddP1PHEkXziGo4PR6Ss1Nx6oXnNi8/fIzlh48FDMdsNjN27Nji4xZCVFqSIItK59ixY+zatSv/+aaTp2nz0Vfcd107Hu5yLfGREaTZHXy1aTu3/O2f9G3crByjFSL8eYB9wObp09m8eTMpG7fxvxOtiFBK8CsmwChyluZi3sUD3Ht4Lr1j6tPcVg27R2NpxhHOuY2RX0VRUBSFjjf0okmTJuzcuRN1SzqKw4PZbCY+Ph673U56enqxoVitVp555pngYxdCVDqSIItKJ2/0uKALdjsfrt3Eh2sv7ScTFRXFP/v3D2FkQlR8utuNvmMr2urfIf0CmC0o7Tpi6tkXJb4WDoeD5ORkNkP+YxuQBTB6NABPxXdGq93S/5QJXzyAAh5Vx667ceXufKfrOu+f2ciEM+sBWJ15gjVZJ2nbti05DhVFU4iNjWXs2LE888wztGjRIuC3OXfuHN988w0vv/wybre70Hxks9mM1WolISGh2OsIISo3SZBFpZM3/7g4/fr1w2azlXE0QoQPPeMi7q8+hswMcDrz293rVuJYs4K3tuxkwm+LcQeoBgHQLeIqolUfE/+LmWuseTwcd2Ty4PHfqG2O5LxmZ0Xmcdy5K/VMJhNWq5WZM2cydOjQy3mJ1KxZk2effZZbb72VDz74gClTppCZmUlMTEzQSbYQovKTBFlUKh6Ph8TExKD63njjjWUcjRDhQ/d4sE/+CDXtvFd5IxNgUhXGd2jF6h07WXrwaMBruf3VXivYXCRJzvG4yfA4uelQAvudaYBRi9hks6A5nSUaJQ5GixYt+Pjjj/n444+v+FpCiMpHEmRRqWzZsoXU1NSg+g4ZMqSMoxGi4tI0jeTkZFavXs3q1asxHUzhveu7Emez+j0nymrh9QHX0/fgtIDXXph5iFtiWhBr8nGtvLrGKujo6MB5LYePz23m8/NbOacZc4qtVivbt2+nVatWl/8ihRDiMkmCLCoVX/OPfalfvz7t2rUr42iECB3d5ULfk4x+/hyYLagt26DUrpt//OLFi6xduzY/IV67di0ZGRn5x2eNvi1gcpznmrq1aRAbw/GMTL99Zmbs5b9XDQx4HZdbY1HWYUYem50/hQKMaRQ2m42EhARJjoUQ5UYSZFGpBDv/+MYbb0RRSrKCSIiKSdd1PGtX4Fnym9HgcoKq4k6cy3mzjY+On2PuylVs374d3cdGGnkaVYsL6vs5NI2rYqMDJsgOXWPsiXlMazCcKB9zkV0ejTSPg8dPJRZKjmNjY7nvvvtkHrAQotxJgiwqjezsbFauXBlUX5l/LCoLz++L8KxcaiTGeTRjo4xqzgwei9T5+sD+gMkxQFqQ27JbVJWLdkex/eZnHuS2o7/w8VWDqW+JRteNKRUWxcSq7OM8dHIBx91Gkh0REUFycrIkxUKICkMSZFFpLF++HGfuyvs4m5X+TRsRZbFwMC2ddcdOFuo7ePDg8ghRiFKTmprK2gW/MXDPJix+7oZYTCZqRNh4c1BfHpz1W8Dr/W/LDq69qg6xxUyzOJOVzb7zaUHFuCz7KB0OfE3niLq0t9XErXtYkX2MY7mJccHpFJIcCyEqEkmQRaUxY8YMoi0WPhg6gLvat8apeVAUUFBIs9t5fsHv/Lx7H23btqVu3brFX1CICiQrK4sVK1aQmJjI4sWL2bJlC/8c2Id+PbtgMft/K7eYTIxo15Knf1vCRYfTb78ZO/bw9pB+AWPIdDp5c8XaEsXdqFEjGnbqRPUmTUhJSSFtxTGUrJLVLhZCiFCTBFlUGgvnzGH5g3fTMr4GERYzkQWmPsbarHx92x+otTCSjXqgPW2FCC3PsSPoKXvQXS7UWrVR2l+DYrXhcrlYt24dixcvZvHixaxduxaXy1Xo3H5NGhERIDnO49A8tK1d0+tOSkE5bjfDps5k4X0jiTSbsZgK/5xkOp38sH0332zZ4fN8BWjdpg2dOnXKf1x33XXUqlWr+L8EIYSoYCRBFpXC0aNHGdehJVfHVyfC4vu/dZTVwrs39afT5O9DHJ0Q3vSzZ3BP+x+kXQC3C3Qdp8mM56cf+O7YaZ5N+IXMTP8L4Uoi2OWom06epuvnUxjfpzv3XtMWBQWzqpB8JpW3V65n5q59+X27AJ0KPK4Bogts8S6EEOFMEmRRKSyYN49xXa8j0uJj964i7msvpaNE+dIvnMM96b/o9pxCyatJc2MCRtWpwZFOHXijmOkMyw8f47p6dYodRbaaTOw6ey6o2A6lXeSxuYk8NX8J8ZERZLtcZDovjVybzWYsFgsbc3KCup4QQoSjohsmCRGWti5djBrEMFmkxczwNleXfUBC+JGSksLejz9Ay87yO7IbbbUwvnd36sVEB7zW5xu3UkxxClyah5927Q04/7ig6tWrM3ToUP7x+uu8N/FzRt//AHFxcaiqSlxcHOPGjWP79u1BXUsIIcKVjCCLsOdwONi4fh16k1uC6l8rPr6MIxLiEpfLxapVq5gzZw5z5szh3NEj7H/iIUx+pgIV9HCXa3nt99V+jx+9mMG7qzfwbK+uRFu97564NY00u4NXElf4vUarVq3o3bs3vXv3pk+fPrRp0wZVvTR2MmbMGCZNmlRsrEIIUZlIgizC3ooVK9h54hQ2U/GL79yah7hWbUIQlagK9KwscNghKholIiK/PTU1lfnz5zN37lx+++030tPT84/d0KQhDs1NZDEJcqTFTN/GDYqN4Z+/ryHD4eSv/XoBxuizS/Og6R52nDnH6IRfOZmZld+/W7duDBw4kN69e9OrVy9q165d0pcthBCVniTIIuzNmzePiw4ns/ekcEe7VphV/zOHFIuZ6jfeHMLoRGXk2ZmMtmQRnDoJJhNoGpl1r+KX9Ewmz1/AmjVr/G7MUdyUiMvp+5+1SUzcuJXb2lxNsxrVsLvdLEg5xM7ceceqqmKxWPjxxx/54x//GHwAQghRRckcZBH25s2bB8Bfl6wiy+nC4yercHh0zG06otRvGMrwRCWjLZiHNn0qHD8GmgZOJ2gaUceOckdaKnXPnQ24a932M2exmYofm8h2uUg8eDjouOxuN3MPH2edJZoNpkgOZ9tRFIW4uDgeffRRduzYIcmxEEIESUaQRVjbv38/e/bsAeBgWjr9v57O7Htup1qEjRirFVVRsLvd6DpcqN+YxiPvLeeIRThz7UxGW74Mk0fzOqaqKlGqytfD/8DGk6c4ejHD5zXS7A7jbkfbll61hgtSUPhqc+DFcFarld69ezNo0CAGDRpEt27dMAdRF1kIIURg8k4qwtr8+fMLPd9x9hxXfziZQc2bcEfblsTZbOxOPcf03SlsP3wUJYh5ykIU5HQ6Wbx4MQkJCfxJc9CjXuBdGFVF4dHO1/HKMv8L415I/J0BzRpTI8LmM0nOcrr469KVnM0uXEpNURQ6d+6cnxBff/31REVFXd4LE0II4ZckyCKs5U2vKEgHEg8cJvHApdvTw4cPJ6LAIiohAnE4HCxatIgZM2Ywa9Ys0tPTiTSb+eiZx4s9N8Js5u52bQImyCczs+j55VSm3HYznevVRUfHpCg4NA23R+fFxN/5ZquxY52iKIwePZoRI0bQv39/4qUKixBClDlJkEXYys7OZunSpUH1HTZsWBlHI8KJnpmBvn8/uN1QqxZK4ybY7XYWLFhAQkICs2fPJiOj8BSJaIsFTfdgCWLpRlQQJdyOXcxkwLc/cHWN6gxu3gSb2cT+82n8tv8Qbo8Hk8mExWLhp59+YujQoZf9WoUQQpScJMgibC1btgy73R5UX0kwBICelYk2MwF99y4wmdB1Hc3t5oLTyRMLFvHTTv9bJac5HARbgOJUgbJqxUm5kIYlux5RUVHsOn4KTdeJi4tj7NixPPPMM7Ro0SLoawkhhCgdkiCLsOVreoUv7dq1o2nTpmUbjKjw9Kws3B9+ABkZRvUJtxsF402wttnMV0MGY9V1pu/a7fN8t8fDjF17GN2uTcDFdZlOJx9t3BwwlsjISAYNGsTw4cMZNmwYjRo1uoJXJoQQorRJgizCkq7rzJ07N6i+Mr1C6LrOqf99RfULFzArvjd4jrJYmHjTjcw/cJB0h8Nnn7fXrOeO1v6rT2geDxcdTqb5GIlu1KgRw4cPZ/jw4QwYMIDIyMjLf0FCCCHKlNRBFmFpz549HDp0KKi+kiBXXSkpKbz22mt0ateOqJR9fpPjPB5d57727fwe33v+Arcl/EKGw0mW01XoWIbDyamsbAZ+9wPZLjcAnTt35s0332Tbtm0cPnyYTz/9lGHDhklyLIQQFZyMIIuwFOz0itjYWPr06VPG0YiKJDU1lR9//JEpU6awdu1aAPo2bIhL84Al8LkxVivDWjTno03+p0gsP3KMlp9N5oFr2nPfNR2Is1o5lZXFp0mbSdi9D4emYbVa+eabb7j77rtL86UJIYQIEUmQRViaMmUKAO1q12Rc12tpWyueLJeLGTv2MnPnXhyasZHDjTfeiNVqLc9QRSnTdR1OnUK/eBEiI1EaNsTucPDrr78ydepU5s+fj9vtLnSOSVXQg1xiF2ir8jzn7XbeX5/E++uTsNlseDwe3G43MTEx/Pm++2RxnRBChDlJkEXY2bp1K7u2b+eHUbdw09VNsahq/pzQG5o05D9/GMBt039h9dETMr2iktG2bMEzb56x0E5Vcbtc5LhcvL1uHW+vWeM3Bd5z7jwRQewwZ3e72XDqVLH9ateuzR133MHIkSPp168fFksxQ9NCCCHCiiTIIuy89NJLTBs5nIHNGxNVJDGJtdkAmHvvCG74apqUd6tEtCVL8CxcCK5Lc3/NQKyq8lKXLrSvUYP7/Ey9OZmVxcpjxxnYpDFqgHnIOvD55q0+j1111VX5SXHfvn1lS2chhKjEZJGeCDvnd2xnQDPv5LigSIuZNwf3pX79+iGMTJQV++HDOOfNK5QcFxRttTK8eXPubN3a7zWeX7KMLD/ng7G985dbt3H44sX8tvr16/Pkk0+yfPlyjh07xieffMKAAQMkORZCiEpO3uVFWPF4PIzr3AGb2X8dWgBVUbihSSP0zAyUmNgQRSdK29atW5k8eTLdDh1iZIsWEKD+cIzVyvhu3fhxzx6fx3eeO8eN02fw8x23Em2xEmcz5qZnu1woisLnW7by8u/LATCbzXz//feMGDECNYg5yUIIISoXSZBFWFm/fj3t69QKaiGV06Ohp52XBDnMpKenM23aNCZPnkxSUhIAR8eNC7g5R552tWoRZTaTXWSRXp5Np0/TbOIXDGnalJtbNCfKaib5bCpTkneSmpODyWTCarUyc+ZMmZ4jhBBVmCTIIqzMnj2boW4tqL42ixUliKRKlD9d11m5ciWTJ09mxowZ5OTkFDpuDfLfUfN4sAVIkMGodfzbwYOsPHuWRo0acfjwYXLsdtneWQghRD5JkEVYmT17NjmxEXSsW5toa+DKAdYIG9SpF6LIRDD0jAw8a9biWbce7HY0m40Vbhcvz0wgaedOv+cdSE+nS0REsdd3aprfXfDAmDoxbNgwxowZw/Dhw2XDDiGEED5JgizCxoEDB9ixYwcnIiL4x4DeAfu6dLD1vEFGkCsQT8p+tMlfgkeD3J3mTNnZdHU5mXtDf246e5atZ8/6PPfDpCQ+GTyY2AA1rR1uN19s24ZH9y721qtXL8aOHcuoUaOoVatW6bwgIYQQlZasPhFh49dffwXggt3On37+jWw/FQlyXG5M9eqj3jA4lOGJAPTUc7gnfQEOR35ynCfGYiU+IoKFI0ZR088o8cy9ezly8SJOzff0Gs3jIdPl4sNNm/LbWrZsyWuvvUZKSgqrV6/m0UcfleRYCCFEUCRBFmFj9uzZ+V//vHsft077hc0nT5PtcpFmt/P/2bvzuDirs2/gvzMw7EkGspGYFbKY1WTAXWtUcM2mgkvV2qoBl/pU37bQvLZan5qmpH3e+rhUIba12sUIJlETjUI0UaPZmOx7IPuewISd2c77x33PMDPMwACzAb/v53N/YObezswNM9ecuc51LjY1o7bZhFXnjYh6/L8gOHlDWNi0aRPKfvMCzE1NbW4XHRGBx6ZM9bjObLMh44MPsOPcOdSZTLDabI51Nc3NOF1fjxnvv4/T9fWIjIzEhx9+iH379uGFF15gPjEREXUYUyyoWzAajfj6669d7lt7+BiuXPwvjE3SYVRiPzSaLdh04jT+/NprDI5DrLm5Ge+88w7eeOMNbN68GdVPP9PuQLs4rRa5Uy/Dok0bPa6/0NSEq//9b1wzdCjmTZ2K4X37oqqxEe/u2oVPDx2C0GgQGxvLChRERNRlDJCpW1i1ahUsXioTHKgy4kCV0XF71qxZwWoWuamsrMSbb76JoqIi1KgTbsRERCLax1zwAbHtD8T77uRJfHfyJJKSklBfXw+TyYQ+ffqwAgX1eGVlZcjPz0dlZaXjPqPR6LKNTqdDeno68vPzkZHROs3MaDSiqKgImzZtQmVlJVJSUpCZmYmcnJyAt5+oO2GATN2Cc3pFW6ZPn45hw4YFuDUkjRchq6ogtFpYBw/C56WleOONN7Bq1SpIt0FyzVYLWg+b86ze7L08GwAkJCTggQcewOOPP47LL78coo1po4l6moyMDJSXl2PRokXIz88HAFRXV0On0wFQPqDm5+ejpKQEZWVlKC0tdQmSy8rKkJ2d7RJUGwwGlJSUoKCgAOXl5Y5jEfV2DJAp7JnNZnz22Wc+bTt79uwAt6Z3sx0+AtvHKyCPHIUtIgJmkwlNzc3YsKUcZZs2tAqOAUAC+OxQJe4cnYKINiZ4abZasWTfXo/rrrnmGjz++OPIzs5GQkKCvx4OUbeUkpICQOktdg5oU1JSUFxcjLS0NBgMBhQUFLgEyPn5+UhJScHixYuh1+tRWVmJkpISR690dnY2SktLg/54iMIRA2QKe99++22rrxG9YXpF4Nj27IX1r+8AavUQjcWCaADRUVH4uT4dNw0fjluWlsDsNIDOrmDTRtw8YiTi2wiQLTYbXt+yxXF7wIABeOSRR/DYY49hwoQJ/n44RN1We728GRkZMBgMLqkYgJJeUVpa6giwU1JSkJeXB0AJnsvKygLTYKJuiFUsKOz5ml4xdOhQ6PX6ALemd7I2NKB58V8dwbG7OK0W0wYORl76FR7Xbzp9GvO/+Rr1ZnOrOsVWmw31ZjMe+3wVKi4aodFo8Prrr+PEiRP405/+xOCYqIPsHQruOcg6nc4RHDuzB8mAknJBRAyQKcxJKR31j9sze/Zs5qT6WV1dHd544w28NHsOmtop0xav1eKZaXpEeLkGb23fhpnLlqLsyBGYrFY0WixotlrxSWUFbvxgCZZXViAmJgYrVqzA008/jag2JgUhIu/Kysqg0+kcecp2q1ev9rqPvVeaOchECqZYUFjbs2cPKioqAACpiTqkDx0MADCcOuNSuQJgeoU/HTt2DK+//jqKiopgNBrx5T33IkHbfsAaKQSmDBiIrefOely/7uQJzFy+FLGRkegTFYU6iwWNZjMSEhLw5JNPsgoFURcYDAbk5+dDp9O5pFLYtRX8Go1Grz3MRL0RA2QKax9//DEmDEjCm3dmYnryIEd+q1ajwY6z5/HkylLsOHsecXFxuOmmm0Lc2u5vw4YN+POf/4ySkhJYnWati430ra60DRIx7ZR0S0xMxKOPPoonn3ySwTBRFxiNRsf/kD3fOCMjA/Pnz+9QoFtUVAQAKCgo8H8jibopBsgU1so/+xTf/OQBJGi10Gg0iHValz40GWseuR83v/cBBk65DDFepimm1qTJBLnvANDYCGt8PD7atQP/75VX8P3333vcfm/VBUwbOLDNKhQAEB0RiSO1NR7XpaWl4emnn8b999+P2NhYj9sQUcfYv2EzGo2orKzEwoULkZ2dDZ1Oh8WLFyMrK6vdYxQUFECv17MWMpETBsgUts6cOYPnLx2NhKgoaDzktWqEQHyUFv+5eyae3ns4+A3shqTFAuvHKyHXfQ8pBMwmM0wmE66zWrCmvhGew2Pg9W1bMHfMGMRr2k6z2HD6JE7V1ztuR0dH4/7778dTTz2FK67wPICPiDrHOWVCp9NBr9ejuLjYUSc5OzsbFRUVbfYm2/OU28pPJuqNOEiPwta6kg8wStfPY3BspxECgxPiII4dCWLLuidptcL65tuwfvMdYDJDNJsQJSUStFr0j4nFy1dfhz9ee4PHfcvPnsF3J0+i0eK5igUA1JvNmP/tNwCUEm0FBQU4fvw43nnnHQbHREHkXJWisLDQ63YlJSUoKipCaWkpB+cRuWGATGHr7OYNiNS0X5UiJjISlw8eEIQWdW/Hl32Epn37ofEyZXe8NgqPT56K9EHJHtdnrfwY3544gXqzCRanWsd1ZhPqTCbcu/JjlJ89g+joaPzjH/9AXl4eBgzgdSEKBXuvsXstZDuDwYB58+Zh9erVHJhH5AFTLCgs1dbW4tDBg9AMaT/A0giBOOYfeySlxDfffINFixZhUeIgJOsS29w+JiICz01Pw4Ofr2y1rtFiwZ0fLUXaoMF4+rJpuDSpPxotFizZvxf/3rsHTVIiLi4OJSUlzDEmChOegt/KykrcfPPNKC4uZu14Ii8YIFNY+uyzz7D91Fk0WqzQtlMVoc5kxuDJU4PUsu7BZrPho48+wqJFi7B+/XrEa7UYNe+pdveL0GgwY9jwNrcpP3sGj5Z+jr59+6K5uRkmkwl9+vRB7sMPO8q0rVmzxk+PhIg6yj5gDwDuu+++VusyMzOxePHiVhOJEFELBsgUlpYvX44vKg/DZLUAaHtgmE1K3PzUM8FpWJhrbm7Ge++9hz/+8Y/Yv3+/436tRgObbGNHJ94m+rC74YYb8Nxzz2HmzJmIaOfDCxH5n32mPG/mzZsHQMlFdu4hNhqNSEtLQ35+fqvqFvZjVlVVMeWCCMxBpjBkMpmwcuVK2KTE05+uRoOX6Y0BZWDYscl6pI4dF8QWhgdptcJ2oAK27TtRu2sPCv7wB4waNQrz5s1zCY4B4GJzM+rMJp+Ou6eqqtV9Wq0WDz/8MMrLy7FmzRrMmTOHwTFRiNh7h41GoyOwNRqNKCsrQ1paGkpKSpCVldWqrvHNN9+MyspK5ObmQgjhsiQmJiIxMRGpqantBuBEvQF7kCnsfPXVV6ipUWrpLtt7AFqNBm/NzISUQJ9opTe5zmSCgMD+MRNwxSOPhrK5QSdtNthWlcH21VrYrDaYTCZYzGbc09iILX36Ycnp0633AfDm9q34uf5yxEZ6/7evNZnw5y2bHbf79++PJ598Ek899RSGDBkSiIdDRB1QVlbmMoV0YmLLuIKUlBTo9XosXry4VW5xfn4+DAZD0NpJ1N0xQKaws3z5cpfbH+zeh0/2VyB70njcMGIYIIBvj57AN9U12Ff5SohaGRrSZoO16O+w7lWqUWgAxACAVosErRZv3XgLRvTpiz8aNrXa97VtW/CTiZMxKDbOY153o8WCnRfOY+XhSiQmJqKgoAAPPfQQB9wRhZGMjAxI6WO+lJOCggLOlEfUAQyQKazYB5e5a7RY8O62XXh32y7HfU899RQ07czs1tMcX/YxdDt2IkZ4ftzxWi2eT78KKw9XYnfVBZd11c1NuK74P/ho1l1I6dcPsRGRiNBoYLJaYZE2rDl+DA9+vhKRUVHYuHEjxowZE4yHREREFHYYIFNY2bhxI06dOuXTtnfddVeAWxM+ysvLsWDBAvx3bD8kJya1ua02IgLPTNXjyTWlrdadqK9D+vvv4fLBybh/3KUYEBOLo7U1eHfvLhyqq0NUVBSWlZQwOCYiol6NATKFFff0Cm90Oh1uuMHzrG89ybfffosFCxZg1apV6BcVjfcefaLdfbQaDe4YNbrNbTadOY2tVRcghIDZbFbKtOXmOsq0ERER9WYMkClsSCmxbNkyn7adOXMmtFptgFsUGlJKlJWV4eWXX8bXX3/tuD8qQgOrj7mH2jZST5KTk/Hss88iNzeX08sSERF5wACZwsbevXtblSfzZu7cuQFuTfBIqxVoaIRNG4kVn3+OBQsWYNOm1oPsqpqaXKZ4bst+Y3Wr+8aNG4df/vKXePjhhxEdHd3ldhMREfVUDJApbPjaexwdHY1bb701wK0JPHnmLKyfr4Ys3wqr1QpptaLf6ZNIPH3O4/ZWKfHX3Tvw5JRpiG6jBrFSqq3ccfvKK69Efn4+5syZ0+sGNRIREXUGA2QKG/b844QoLdKHJCMqIgL7L1Th8MUal+1uueUWJCQkhKKJfmPbfxDWN/8Kq8mECAARAKDR4Nqhw7Bk4GC8snUzXtr0fav9/mfLJjw0fiIio6MR4SHYbbJYcMBYjRWHKzBy5Ei8++67uP766yHamR2PiIiIWjBAprBw/Phx7KfNkMoAACAASURBVN++HW/ekYkHJl8Ks9UGCYnoiAhsPXMO/+eLr1B+6gyA7p9eYb54EebXCqG12eCpHzheq8Wz09Kx+ewZrDxS6bLuTEMDfvDhf/DZ7CwkxsSgb5QycYrFZkWz1Ybys2dw96fLoY2OxurVqzngjoiIqBMYIFNYeG/xYnz/6A8xrG8fxERGAk7j764eNhRlD9+LuUuW45tjJzBr1qzQNbQLzGYz/vnPf+L0v5bgqZRxbQ4yjNdq8X/Tr2wVIAPAwYtGjHvvbWSOGIUHx09A/5hYHK65iLd37cBOYxWioqKwtKSEwTEREVEnMUCmsDBq7w4MHz0c0V6mQY7XalGcNQtXLPkYAwcODHLrusZsNuPdd9/FggULcOjQIWx/4MeI86ECx9QBA5EUHYOq5qZW6ySAL44exlenTrBUGxERkZ8xQKaQqzp1EneMGuY1OLbTCIFr+3efsmQmk8kRGB8+fNhxf19tlE/7m2029I2K8hggJyYm4mc/+xmeeeYZJCW1PXEIERERdQwDZAq5zUs/hN5qc0mr8KRvdDRmpo4KSpu6wmQy4R//+AcWLFiAI0eOtFp/uqEeQ30YZKjVaHC+qdHlvkGDBuEXv/gFnnjiCfTp08dvbSYiIqIWDJAp5DZ8/x30yf192jYhJibArek4WVsH27r1sG7fhXNnzuKz3Tvwx++/wZGLRo/bv7FjC165/ib0ifLek2yz2VB67AjqzGYAwPDhw5GXl4fHHnsMsbGxAXkcREREpGBRVAqp2tpalHy5BtqI9v8UmywWiCFDg9Aq31nXbYD5+d+h+ePPIA4fxaDGJjwwIgWb7n0Yr//gZmg8lFcrPrgftSYTrG1M+tFoteLlTevRr18/vP322zh48CB++tOfMjgmIiIKAgbIFFKffvoptp86jQMXWs/85smkh38S4Bb5zrzJANO/iyEsFpfskKiICMRFavHguIn44zU3tNqvyWrBzcs/wNnGBtSZTa7rLBbUm834yerPsPNiNTZs2IDHHnsMUW30NhMREZF/MUCmkFq6dCkA4LkvvkKDmk7gSb3JjHOXjMSoy6YFq2leWa1WvPfuuzj95tuIlNLrdvFaLeZNnIpBsXGt1lXUGDHxX3/HL9etxe6q86hqasTxulq8vmMLpn/wHj4/dQLLly/H+PHjA/lQiIiIyAMGyBQyTU1NWLlyJQDg22Mn8MDSFagzmVDb3NKr2myxoNFswVYbMPrpZ0PVVABKXvD777+PSZMm4a38+YjXeJ/u2U5C4uHxEz2uq7eY8dfdOzDt/Xcx9J1CpL73Nhbu3Io7H3oQO3bswO233+7vh0BEREQ+4CA9CpnS0lLU19c7bn928BCGvfIW7pt0KeaMG4PoyAhsOX0WReXbUFy2GsLD1MrBYLPZsGzZMrz44ovYtWsXAHgNet3FRmoxIdH7AES9Xo/f/va3mDlzJqeDJiIiChMMkClkPvzww1b3NZgt+PvWnfj71p2O+0aMGIG0tLRgNg0AIKXEihUr8MILL2Dr1q0u6xotFkh4T6+ws0mJeg+pI+np6XjxxRdx5513MjAmIiIKMwyQKSTMZjM+/vhjn7a9++67gxZEyrPnYTt3Hpu2bsEvXn0F6zZu9LjdmhPHEOVDikW92YxPDlc4bl9++eV48cUXcccddzAwJiIiClMMkCkk1q5di+pq3ypX3H333QFuDWA7UIGGfxUDp86g0WzGGAF8POUK/DUiFi9sXIcmq8Vl+/NNjVh5pBIzR6Z4nQHQJiUumpqx+vgRDBo0CO+88w5uu+02BsZERERhjoP0KCQ8pVd4MmjQIFxzzTUBbYtt2040/fkviD5zDtEaDXTR0egXFY0+2ijkTpqKNXPvQ0xE6yD4qbVlOFFfhyaLpdU6q82GOrMJcz9dhqjoaKxbtw633347g2MiIqJugAEyBZ3VasWyZct82nbu3LmIiGg/laGztm/YiPq/vA2tl3Ri+yC759OubLWuurkJV5b8C3/fuxN1ZhMuNjfD2NyERosFK49U4tpl7+NAQz2WLVuGMWPGBOwxEBERkX8xxYKCbv369Thz5oxP295zzz0BacPevXvxwgsvYNCeA/jdldcBbeQTx0ZG4olJ0/Dfm7+H2W32u4umZvzsmy/xq++/xuSkAYiKiMB+YzWaIiPwox/9CM899xxSU1MD8hiIiIgoMBggU9DZ0ysGxsXixlEjEB0RgUrjRaw7dsJlO51OhxkzZvj13IcOHcJLL72E9957DzabDatn34sEbfuz1AkBTOk/EIZzngP7sRMn4v++9BLmzJnDNAoiIqJujgEyBZWUEitLirHk7lm4fcxomKxWJaCUwMXmZvy8dA2W7TsAAJg1a5bfplg+efIkFixYgMWLF8PsVHYt2sf0DZuUHredMGECXnrpJdxzzz3QhKhOMxEREfkXA2QKqk+XfohPZt2KoQnxiI6MRIxTBYg+0VH42+zboPsiGn/fttMv6RXnz59HQUEBXn/9dTQ1NbVav6vqPPQDByGynZJtMRGROFRz0XF77NixePHFF3H//fcHNEeaiIiIgo8BMgVV7fISDB062GtptHitFq/cchM+rTyMW265pcPHl1Yr5I7dMK35FucqKrH76BFU7twKi8nkcfu/7NyKe8dc2maAbJMS606fwOmGeowePRovvPACHnroIUR6eQxERETUvfEdnoJGWMy4LXmQ1+DYTkLiJ1MnITY2tkPHlxeqYP6fN9BcbUQMgGQAyUOHI33AIPyPyYRbPinGgYtGl322XTiHsuNHkDlsJOK0Wo/HbbRYMH/9N3j55ZeRl5cHrZftiIiIqGdg0iQFTc3+/bC4VYHwJE6rxS2jR3Xo2OaaWtT89g+wXqhCjNu6vlHRSI6Lx1dz70f/GPe1wIOlK7Hq6CE0WMwwW62O+2tNJlw0NeOeLz7BS39djOeff57BMRERUS/AHmQKmu3btuKqBN8G3UVrffvTtNlseP/991Hx9jt4JuVSRHoJYCM0GvTRapEz8TIsNGxwWWeyWXF/6QpMSEzCE5OmYUJiEhosFiw/UomE669G0VdlLNVGRETUi7AHmYJm2TffugzK86bZYkVDUv82t5FS4pNPPsG0adPw4IMP4odDRyK+nd7d2Egtnp4y3ev6PdVV+M32zVh/+VTctORd/H3XNrz21lsMjomIiHoZBsgUFAcOHED5nr0orTwMaztpFjYpMfbBR7yuX7t2La677jrMnj0bO3bsAAAkx8X71I4BMbHwVKU4NjYW+fn5OHToEH7zm9+gT58+Ph2PiIiIeh4GyBQU9slBfvXl16g3m2GTnud2rjeZcSp5KEZO17daZzAYcNttt2HGjBn47rvvXNa5z3DnjVVKOJ85KioKzzzzDCorK/GHP/wBSUlJvj0gIiIi6rEYIFNQlJSUAAAOVBlx03tLcKKmFrXNJkeg3GA2o9Fiwcoz5zHu2V869pPVRlSs+x4/ufc+pKWl4fPPP/d4/C+O+dYz/dXxIwCAiIgIPProo9i/fz9effVVJCcn++NhEhERUQ/AQXoUcIcPH0Z5ebnj9vaz5zHmjbdx06gRmDkuFfFaLfacv4B/7tiNl//8CiAEbBsNqP3wI2iqL0JnteDVfsm498578NtN32Hj2VOtzvGnrZtwy/BRiG9jNrtGiwV/3LoZY8eOxYoVKzBu3LiAPF4iIiLq3hggU8AtXbq01X0SwOrDR7H68FHHfRqNBnPnzEH9O/+GXL8ZcRoNEBGBGHWmupuGjcA1yUPxky9XYdmhAy7H23T2NBZt2Yi86Vd4HKxXbzbjjR1bsKHqHHZ+vZMD74iIiMgrplhQwNnTK9pzzTXX4MtXXoNl3QbEeOgJ1giBOK0Wf7vpNlwSn9Bq/ULDBjz21Srsqb6AerMZxuZm1JvNOGCsxtPfrMbvdxqwdOlSBsdERETUJvYgU0CdOHEC33//vU/bbtmyBanJoxA/YFCb20UIgZyJl+HFTetarVtaeQBLKw8gta8Og+PjcaGxEadsFjz88MPY/txzDI6JiIioXQyQKaA+/OBv+MWdwNQRgC4OMDYA248C73wNnK913VZrtmBiYtv1jwEgJjIS948d7zFABoAJEybg5Zdfxl133QUhPBV1IyIiIvKOATIFxP7dX6LO8DvkJK2F7R4gLrplXUMz8N9ZwGfbgIUfA5srlfvjtVqYbTZEqTnHbYmLbJ1nPHLkSLz00kt46KGHEOHDMYiIiIg8CescZCFElhCiQgiR0sn9dUKIAiFEqRCiXP29dYFd8qsNn7+M4YY7cJlYixitdAmOASVYjo0C5qQBa34N5N6s3H++qRERPvb4Hqtr6X4eNGgQXn31Vezbtw+PPPIIg2MiIiLqkrALkNWgNk8IUQGgGEBng2M9gEMAKgBkA5inHqtcCJHhr/aSqw2fv4yp515GrKYZEcLzZCB2ERogPhr4nweVILnZasWyygOw2Kxt7ldrMuG1HQZERUXh5ZdfRkVFBZ555hlER0e3uR8RERGRL8IqxUIIkQOgEIARQBGAHAC6Th5uNYAiKWWRetsAIFsNvEuFEIlSSmNX20wt9u/+0hEcd4Q9SN5cCfzesB6zRqciQeO5F9hsteJ8UyM+OnII3333HdLS0vzRdCIiIiKHcOtBrgKQK6VMlFLmq7c7TAiRByWwLvSw2l5z7N7ONZG8qTP8DlHC1Kl9Y7TA/NnAPmM15ny6HDUmE+rMrseqMZlwtK4Wt61ajpLlyxgcExERUUCEVQ+ylNK3grntuw+AUUpZ6WFdKYA8KGkXRR7WUydcuHAMk7Cu3bQKbyI0wB3TgAF9gG9OHUfqPxfj4XET8aNLJ6GPNgrH62rxt4N7MeDGH6B04waWayMiIqKACasA2Y/0UFIqPNms/kwPUlt6hf3fv45p6FpJNSmBR64H/udT4KKpGa/v3IJDI4diwa8XIOOyy8DEcaIwx7KKPdqMUDeAKIh6XIDsVPHCY3qGlNKo1sbtbG4zeRBZswOxms6lV9jFRSv1kgHg2muvxcKFC3H99df7oXVEREREvutxATI6WfXCnTpgMAcABg8ejDVr1vjjsD1WqrgAdC67wsWQAbH4/e9/g6uuugpWq5XPezdVV1fHa9fDzQh1A4gINq0WXwfgtZav4T0zQPYLtfpFEQCkp6fLGTNmhLZBYW7Tv/tjuB+Oo5twI+b/cL4fjkShtGbNGvB/hogosDQZGQF5reVrePhVsaBuytJ3ChptUV06RqMtCpa+U/zUIiIioh4qOhq4/XbgnXdC3ZIeq8s9yEKIUqDT46cCUYvYXrkiqZ3tWAPZj8Zd/VNoPvtzl44hIDH+6p/6qUVEFFBSyaliT1PvwWtNvUmXe5CllJlSStHJJRBBqn1wXnuD8DyVgKNO6t9/OHbhWlhl50axW6XAblyHpP7D/NwyIiIioo7pcSkWTkG3x8F6TlUuyoLTot4jQf8bmGTn0ixMMgp90n7j5xYRERERdVyPC5BVZQAghNB7WGdPB1kSvOb0DuMm3oTtA3+NRlt0h/ZrtEVj+8BfY+yEGwPUMiIiIiLfdfsAWQhRoE4t7cw+xXSuh12yARiklN4mEqEuuPLWXzuC5PbSLaxSOILjK2/9dbvHNhgMyM7ORlpaGoQQSExMRFpaGhYtWoTKSmbMEBERkX+Ee4Cc4vbThRAiA8q00QXOvcXqlNVFAHKEEFlO2+dBmUEvO2AtJlx5669xPO0zbJMz0GTTtqpu0WiLQpNNi21yBo6nfeZTcJybm4ubb74ZmZmZWL16NaSUKC8vR0ZGBvLz85GZmRmoh0NERES9TNjVQRZCFEBJg3AOikuFEAYAlVJK5+B2M9Qppd17hKWUuUKIcgC5QojFUAbvGQCMDtDgQHIydsKNwIQbUXXhOPZ9/zoia3YiWXMOp20DYdFNxvirfwq9jwPyFi1ahKKiIpSXl0Ovb8maSUlJQUFBAfr374/S0tJW+xkMBixcuNCxXTCE4pxERETkX2EXIEsp8zuwrRFAWhvrHZN9UGgk9R+Gq2f+AUDnSgQZjUbk5+cjIyPDJTh2lpGRgU2bNrW6Pz8/H2VlZUENVENxTiIiIvKvcE+xoF5u8+bNAJTeYm/0er3HgFSn07W7r7+F4pxERETkXwyQKazZB9+VlbVdlc9TQJqU1N5cMS0MBoNfBvp15JxEREQUnhggU1hLT08HoATK2dnZPgexBoPBEVQvWbIE+fn5yM3NRUlJiWMb+zGFEEhLS0NqaiqEEC7bOB+vqKgImZmZWLRoEQBl4GBiYqJjgKAv5yQiIqLwxwCZwpper0dWllKIpKSkBKmpqY6gND8/HyUlJTAaXcdclpWVYeHChaiqUiZVrKysRGVlJaqqqhwpEAaDAWlpaZg/fz6klKioqEBenlItMDs72+WY9sC3oKDAEQBnZ2ejqKgIRqMRVVVVPp2TiIiIugkpJZd2lrS0NEld99VXX3V638LCQpmSkiIBeFyysrJa7ZOVlSUByOLi4lbrSktLZV5entd9CgsLW63Ly8uTAKROp5MFBQWyurpaFhcXy4yMDJ/O2Zt05VpT98Jr3XvwWvcevelaA9gsPcR+7EGmbiEnJwcVFRWorq5GeXk5CgsLkZOT41hfUlKC/HyfC6AgIyPD48A+e7pERUWF133T09ORl5cHnU6HrKwsjyXmiIiIqPsKuzJvRG3R6XTQ6/WOkm8FBQW4+eabYTAYUFJS0qnyamVlZSgtLYXRaHTkOLunbTjjpCREREQ9G3uQqVvT6XRYvHgxADjyf32Vn5+P1NRUGI1GzJ8/H4WFhR3qhSYiIqKeiT3IFPbKysqQkZHhdb29xFtHag9nZ2ejpKSk1ex8REREROxBprBmn0mvLfbJRObPn+/zMUtKShzpGu7riIiIqHdjgExhraqqCgaDoc3ANTc3Fzk5OY5ycO7cayd7yzM2GAyYN29eF1vs+ZxERETUfTBAprBmD2JHjx6NRYsWobKy0jGYrqioCKmpqcjIyEBhYWGrfe0pFwsXLkRubi4yMzNRWVkJvV7vqE2clpaGoqIi5ObmIj8/39EL7Smf2d6WCxcueG2vt3MSERFR98EAmcKaXq9HcXEx0tPTUVhYiNTUVIwePRq5ubkoLy9HaWmpx+AYUFIuMjIyYDQa8cEHHyA7O9sRwK5evRp6vR4GgwEFBQXIzMxEaWmpI3AuKSlxBLclJSWOQBoAioqKkJaWhtzc3A6dk4iIiLoHDtKjsJeVleU1faItOp3Oa41ivV6P8vLyVvfn5OS41FcGlF5hX8/f1jmJiIioe2APMhERERGREwbIREREREROGCATERERETlhgExERERE5IQBMhERERGREwbIREREREROGCATERERETlhgExERERE5IQBMhERERGREwbIREREREROGCATERERETlhgExERERE5IQBMhERERGREyGlDHUbwp4Q4hyAI6FuRw8wAMD5UDeCgoLXuvfgte49eK17j950rUdKKQe638kAmYJGCLFZSpke6nZQ4PFa9x681r0Hr3XvwWvNFAsiIiIiIhcMkImIiIiInDBApmAqCnUDKGh4rXsPXuveg9e69+j115o5yERERERETtiDTERERETkhAEyERERUQ8nhMgSQlQIIVI6ub9OCFEghCgVQpSrv+v93c5wERnqBhARUfgQQugAzAegB5AEoAzAEimlIRTHocDp6jVS9y9WbxrdVuvUnwVSyjI/NJc6Qb1GOQByAXQqMFaPowewGkA+gIXqseYDKBdCZPbEa8weZAo4fmol6h7U/6tDACoAZAOYB+WNsFwIkRHs41Dg+PEaZahLlttiv1/nfVcKJCFEDoBqKIFsCVp/iOmI1QCKpJRFUkqjlNIgpcwGUAmgVA3EexQO0qOA8PKpNVVKWdnB4zh/av0ALZ9aswD0yE+t3RF7onoGIUQ1lDfBfLf7K6D87yVKKdt9k/XXcShw/HGN1P/bagBpUP7vgdYBsaGjr/vkH0KILABJUsoi9bb92nbovVgIkQegwNN+QogCAHkAcu3n6SnYg0x+x0+tvQt7onoG9U1QB6DQw+oS9ee9wToOBY6/r5H6ulymLiVuC4PjEFGff38ErfcBMHq5lqXqz2w/nCesMECmQKiC8mkyUe2dqOrMQfhG223480NMGoBMdcl2W5i7Glj+ehPslW+m3Yw/rxG/Cej59FBezz3ZrP7scdNSc5Ae+Z2UsqT9rXzS3ot4HpQX8R71tU534sOHmDwoH2J8ukYcwBVSenj/ENKRN0F/HYcCx5/XqFMdINQ9OI0d8nidpZRGIQTQA7/hYw8yhbNe+am1m2FPVA/gy5ug+mubb4L+Og4Fjp+vUZL9mEKIYnUwtlQHU+f4obkUep2ufNHdMUCmsMQ32m7Dnx9i2BMVOv56E+y1b6bdiL+vUQqU8QcpUF4LjFBeFwqFEKVt7UgUzhggU7jiG22YY08UUa+ng5KqkSqlTJNSZkopEwEsUtdn8P+XuisGyETUWeyJIurF1AG5ae4pVurgbHtJRg7I7N7s1zapza16YIocA2QiCgfsiQotf70J9to3024kWNeoQP3JbwO7N/s3hO19E9jjyvkxQCYAgDpLnezkEog8YL7R9iLsiQo5f70J9to3024kWNfIvj9fo7sxp1Q5jx90nFLtetwkTgyQCQCg9tiJTi6BeAHkG22A+PHDEHuiegh/vQn25jfT7iKI18j+WsFr3f2VAY5JodzZJ4NaErzmBAcDZApLfKMNHD9+GGJPVM/irzfBXvlm2s10+RoJIQqcXoc9sVevWdjx5lGoqNc1z+1ue537XA+7ZEOZTrzH1bBngEzhjG+0YYw9UT1Oh98E+WbabfnjWi+B5wmCoH7TVAAgO0DfMFLnpLj9dCGEyIAyuVOB8/uuOvlXEYAcIUSW0/Z5UD4I9cz0NyklFy4BXaBUJpAAUtrYpgBAntt9Wep+hR62LwVQHurH1tsX9TpIAHoP63K8rfNw7dv627AfRxfqx9vTFygBjwSQ5XRfHoBq92sE5UOq9HSNO3IcLt33Wquv7cXqeh2UwCsHQDmAjFA/Ri6O19dy9bpKp6UcQLHbtjr1fo/vreq1LVWPZb/2PfZ1WagPmihghBD2P7JMKWWrXkD1U6u9jFeadOq5EEIUQvmnzJbqFNbqp9b56rbMQQ4htTehGECRlDLXbV0pgCQpZZrb/QUALkgpF6m39QAKpJSZHo6vA3AIwDzpvynMqQ1qtZBsKD1DVVCqi8yTbj2B6rVZDQDu17gjx6HQ6eq1Vv//50Mpx2iEMjlQqf1/m6g7Y4BMAaEGQRlQehScc1QNACqllNlO2/KNthvryIcYbx+GhBAVUK5rIZQ32SQofz+5API9fbAiIiIKFAbIRNRl7IkiIqKehAEyEREREZETVrEgIiIiInLCAJmIiIiIyAkDZCIiIiIiJwyQiYiIiIicMEAmIiIiInLCAJmIiIiIyAkDZCIiIiIiJwyQiYiIiIicMEAmIiIiInLCAJmIiIiIyAkDZCIiIiIiJwyQiYiIiIicMEAmIiIiInLCAJmIqBsRQuiEELpQt4M6RgihD3UbiMh3DJCJKOwIITKEEMVCiHIhRLUQQqo/y4UQhUKIrN4UJAoh9OrjLgdQDSAn1G0KV+pzVRDqvw/1g0yBEKJUCCEBLA5le4ioYxggE1HYEELkCSGqARQCKAWQLaVMlFIKAGnq/ekAitG7Ao5KKI+d2lcMIA/A/FA2QkppBLAEgCGU7SCizmGATEQhp/a2lQIoAPCBlDJVSlkkpay0byOlrFTvSwNQAiVoDFV79WoPd0EwzielNEopDQDKgnG+bq4QgBHKBywXIbhuBihBMhF1MwyQiSgcFAPIAFAkpcz1YftSABWBbVKbCgBkAbgQwjaQB1LKReq3Dp4+TPC6EZFPIkPdACLq3YQQeVCCYyOAfB9326xuHyr2c4esF5s6hdeNiHzCAJmIQs3eY1yk5m22S/3q2iMhRBaATAApUAKhcillkS/HFUKkQAnWqwAYnFM83FT5cjwfz9np9nbyfCkA9ACSAJQ5P0Z1YFuGerOtx+98PD0Ao4/b5sD1sS6RUpZ0oN2+XJu2tHvd2no89ufH1zZ3hNNzo4OSt1zYycdIRH7AFAsiChk1GElRb27q4rFShBAVUIKMAgDZAMoBFKoVMDKcttWplTIKhBAV9ooDUNI2CqGkfFR4ylVV22w/1n3qMQrVQNee55qjVi/IU++zt6HU6Tg+t7cLz4leHfhYrlb+yFEfY7H6OCvU+6Cer1pdZ3/8eV6Om6Lm8kq1zRVqpZGsNravAFAlpcwGMA/KdS9Wn3/7UtrVa+P+3Duvg5fr5lQ1pVp9PHq3fQucKogUt/F8Z9mrVqhLBVo+AHrbJ0M9rw7KNyi56vkd14aIQkBKyYULFy4hWaDkg0p1SenCcXRQgxcP6zLczwElIC11ut9e+UCnLnlO6zLcjlWsnsseHNoDygwogU0elGBOqr8XOx2rvDPtdVpXYD+uD8+JvS32tpaqbUlRz1/gdJ48db1e3TfHaZ3ew3GrnbZNcTuWzm37FHX7Qg/XzL5PgXpOvR+vTV4HrptOPbf9umV5eAyO58TLc12utj3F6b5C92vv5VoXeFjn8fnkwoVLcJaQN4ALFy69d3ELdjodCDgFInov6+0BV6nb/fZz53jYxx7YFraxLsvL+ewBY7VTcJdlP38X2utzgOyhrZ6CcXtA6Cl4s+9X4HZ/hpeAzr59jpc2t3qunB6np3WdvTb257bVc+TDdWtvfasAWQ2ePQa56nr7h0BPz3GFp4C7reeTCxcuwVmYYkFEoeScc5zUhePcq/70lrNp/zrePW3Bfv4PPOxjL8+V4mGdrzZLpaqCUUpZIqXMVO/vbHu7wlO5sTK3n87s6SAuj19KWSal9DSY0r59qtv9bT1/bQ2a6+y1CfbgTXt96oVe1nu8xk7p+DUfvwAAIABJREFURd7aa98vrfNNI6LO4iA9Igol5+AhA0CHB6epA6d0gGNyhjbPI4RIkb4NfvJHoOWpFm+g2tsZ9vN7Knvmy4C2DLQMLLMHq+4z2NnbngmlfrWzFCgD4jo6mUYoK5i4ywDavJbeOJ4vNQe5Cq6Pyz5YL5TlDIl6LfYgE1HISNdatb7UP/bE0YvobXphtwDT1woUfqtU4SZQ7e2MTtUDtg+ggxLELZRK7Wpvk2/Ye1hznAfxqQPQUtC5HtJAPic+UytrdJVRKnWbU6WUaU6L/fYiP5yDiDqIATIRhZo9ANB3ZtS+W++jx4DFKRA1dqKnz6+6W3vdCSHsg+ay1bSRNtunBvv22Q/tVStKoaRijA5g73jAydYl8jrCvm9H9yOiIGCATEQhpeaz2oOFQjU3s6Ps+9/nZb09EPWUzxoK3a29ABxBYBY8p0V4DfTUbasA5Ks9o5lSyvxwC/6dtMqHb6Psnv1aevtwl97OfhBeyuMRUegwQCaicJCJlvzLck81bp2pdXWdAxL7oLEcLz15uejYTH3O2ho82Nmv2APZ3o7o7/azPR7zjNUPNYu97aT2GOcEIF2gswM7vV03e+pGtvOd6jUqbL054HT/fPcPd+ptj3/L6ocDe879Yk8fDNUa0OxhJgoBBshEFHLqV9Wj0TKIK0+dLKNQnfghQ52EoUANtirglIcqlZnNiqAEbuXOuaFqIJ0B4GYPPZb24KOtQMtTgGLv/ZuvtrHULR/Vvo/HwNMP7fU1oHXex9Nj1Ln9bGt/e0+wUW1nuXptCqEEgfYqDp7Ok6HuU60+V8Vui6fe185em7aeo/aum30SkAz7ZCPq4zsELx9W1KC/DC3X0v43WwzlebnZW1vV3G33fbPsf+tQaisTUSiEus4cFy5cuDgvaJl4wj5zmb2ecAWUqhBe68JCrTWsbm+fDMJbPVz7se3Hd685rHdaX+F8XigBTanTvjlO5y93O245PNTr7WB73Y9rn+wio43nwnnCEvtSqj6/3o6X5XZO53V5Ts+Lfd8K+z5wnVykFE6TnKjHqnY7n/tS2pVr48tz5O26eXiuK9yOoYfrxCYV7tfU6fm2t73QS1s91ZDOc2u74/nmwoVLaBYhpQQREVEgqCkCi6EE5tnSdWBbCpR0Evu00KmyGw/aI6KegwEyEREFjFoOLklKmdjGNqVQ0jDSZMdrIhMR+R1zkImIKCDUHuIUeJ6pz5kRaFUCj4goZBggExFRoNgHUrZXiUGP9oNoIqKgYYBMREQBIZUqHAYoVSG8TYqSB6VSRban9UREocAcZCIiChh1kJ69XFk+WnqKUwDMh9K7nMvBeUQUThggExFRwKmzxWVCCYyNADYBMEgpmVpBRGGHAbIPBgwYIEeNGhXUc9bX1yM+Pj6o56TA4jXteXhNeyZe156H17Rn8sd1LS8vPy+lHOh+f2SXjtpLjBo1Cps3bw7qOdesWYMZM2YE9ZwUWLymPQ+vac/E69rz8Jr2TP64rkKII57u5yA9IiIiIiInDJCJiIiIiJwwQCYiIiIicsIAmYiIiIjISVgP0lPrZ86HMstSEpT6mUs6Oh2p03FSoNTcrARQyGlNiYiIiMhd2PYgCyH0AA4BqIAyw9I8KAFuuRAiowPHyVGPs0k9RrZ6zHJ1BiciIiIiIodw7kFeDaBISlmk3jYAyBZCVAAoFUIkqtOYeqUG2YUAsqWUJU6rFgkhUgEUCCGK2jsOEREREfUeYdmDrPbs6qAEt+7sge69PhzqPvWnp5maStWf6R1rHRERERH1ZGEZIEMJbI1SykoP6+yBbbYPx9GrP1Pa2KaqIw0jIiIiop4tXANkPZSBdJ7Yp7TzpefXfozF6kA9Z7kASjhQrwezWQGbLdStICIiom4m7HKQhRD23l6PPbtSSqMQAlBSMNpTACAHSsB9SAiRL6UsEkIUqMfypReauouGKuDYRuDo98DR9cBJA6CJBJKnApfogaF6YOh0ICkF0ITrZ0Oi7m37cSP+s/EoapssSBkQj5SBCUgZGI/RA+LRJ0Yb6uZRN1ddb8KCT/dgzb6zeOKGVDx+fVtfEBN1npBShroNLtQKFaUAyqSUmV62kQAgpRQ+Hq8YrgG1QUqZ1s5+OVCCawwePDjt/fff9+0B+EldXR0SEhKCes5uRUpEN59Dv4u7oTPuRr+LexDfcNSnXS0R8ajtk4qavmNR22csavuMQXP0AEC0++fUKcJmRpTJiJomC6J1QwJyDgqNcPo/bbRIRAggKiIwf8ftOXzRiuUHzdh6zup1m37RAslxAkPiNUiO1yA5XiA5XoOBsQIRmtC025Nwuq7UwnDGgnd2mVBjUuKWmAjgzYw4CB9eu3lNeyZ/XNcbb7yxXErZKiuhxwfI6vZ5UOogAy2BshFKdQtPA/hcpKeny82bN7e3mV+tWbMGM2bMCOo5w5apHqg9rSxnd7f0ENec8N854gcqPcx9hwLRfYCYvkB0X+V3+0/HfertCC1QdxaoPaW2z/2n+nvDeQCAhAbih0uAcbf4r90UUsH+P5VS4kK9CQfO1OHA2VrHz4Nn63C+zgQAiI+KQGJ8FPrHRyExPgpJ8VFIiotyuS8ZFzDUWI4B0+6AiB/QpTbtOnkRr5QdQOnuM50+hjZCYNbUofjtnEnoGwa9zHz9DS8XG8x46ZNdWLql9Wv+/pdvR1Rk+98I8pp2npQSRy40YMOhCzhe3YiR/eMxYUgfjB3Ux6fnPpD8cV2FEB4D5LBLsfA3IUQpAEgpE9Xb9mBZB6VcnHsJOOqs2jPAvk8BcyMQGa0sEdFAZJTbT6d1QrQEmXVn1ODyTEuQWXcGaK7x7fyaSGDIZcCIq4ERVwHDrwKkFThhAE5uUVIuThiARg/ZO/XngAOf+/f5cCNgA3Yv71YBssliw+e7TuPg2To0WaxoNtvQbLGiyWxDk9mKZovy0/l3i01ixriB+O3sST717PQWK7efwlf7zkIboUFcVATioiIQGxWBOG0E4qIiERsVgVit0/1RkbhQ14z9Z2px4GydspypRXWDuc3z1JusqDc14nh1o8f1kbDgy6ifY6DmHAxlf8G/JxZixviBuH7MQPSL8z043Xu6Bq+UHsCqXadd7hcCuHPKEFw/dgAOX2hA5bk6VJ6rx5ELDTBZPY8JMFsllm45ga3HjHjr4TSMG9zH53ZQz/bl3jP41Yc7cLa22eP6RpM15EFaTyOlxMGzdVh/qAobD1Vh46ELOFPT+vnXRgikDkzAxKF9MXGIskwY0heJ8VEhaLX/hWOAbB9Yl9TOdu3WLhZCFAJItwfHACClXCSEKIJSZ1kPJU+ZAXJXnNwCrH8T2LkUsLX95u1XUQnA8CtaAuJL0oCo+NbbXXqHsgCAlIDxiNJmR+C8FTDVBqfNvgb7IVbbZMZ/Nh7F3749jNM1TR3e/x/fH8GdU4fiitHt/Rv3DofO1+On/zEgkF/YRUVqYLNJWGxtn2SyOIwRmnMAAL3cg18YNqKkfCgiNALTh+swY/xAzBg/CBOH9IXGQ9rDvtO1+N/V+/HpjtOt1t05ZQh+ljHWY4BrtUmcqG5ExXklYLYHzofO1zv+xirP12PO6+uwKGsqZl02tDNPA/UQFxvNeHnFbhSXH3e5f+60ofj6wHlU1SvfmDSYLeiH0H/r0J1ZbRJ7T9dgQ6UaEB+ucjy/bTFbJfaersXe07VYipbe/SH9YjBBDZhHJMV1OHvxqpT+GJ4U19GH4XfhGCDbu/faG4TnrcqFsxwAi9zvVAf62WfUY4Z/Z1gtwN5PgPVvAcfWB/ZcGi3QZwjQZzDQbzgw/Epg5NXAoElARAf/hIUAEkcpy6S7lPtsNuDCQeDMDqCxGmiqAZpr1UX9vamm5ffmGuW2zQzEDVDblqwuQ1r/PLUV+M/9yrnMnnv1wsXZmib8bd1h/Gv9EdQ2W7p0rFMXw/uxBtO+0zV+C45jtREYOzgBYwYlYOygPhg3WPl5SWIsNAKoabKgqt7kWKrrTahqaLl9+ck1QHXL8W7TbMRfrHNhtUlsPlKNzUeq8acv9mNAQjRuGDcQM8YPxA/GDsS5uia8UnYAK3ecavVYbpuUjJ9ljMWEIX29tjtCIzCifxxG9I/DjeNd13209QR+9eEONJqtaDRb8cx/tmDLUSPm33EptBHsHext1u4/h199uB2nLrZ8OB+QEIWX507BbZOTceOf1rQEyCbvOe+kfAtY3WDChTrl//9CfbPL76cuNqH8SDVqm9p+ve8TE4nLRyVh7OAEHD5fj92nanCsyvNr/KmLTTh1sQlf7j3bqTa/+sB0BsieOFWp8Bi4OlW5aDN3WJ1FD1CCYE/nqRRCGME6yB3TUAUY3gU2LgZqjrdeP+wKYOg0wNIMWE1uP5sBi6nlp6VJSYGIH6QEv32GAAmDW4LhPkOUJTYxYAPoACgVLQaOU5aOsFkBTUT721U5/QmaGjp2jiA5eLYOi7+uxLItJ1p9DT4gIRp36y9Bv1gtYrQRiNFqEB2p/IyJjEC0VqPcHxmBN7466PjKvb6Zb1x2NU5vPtOG63DHlGQ0mKxoNFnRoC5NZisaTBblfrNyX3x0JMYOSnAEwWMGJeASXazHnl27frFa9IvVYvQAD9+mAMB/ClwC5Ed027Eu9hFsP3HRJfA9X9eMDw3H8aHhODQCkECrwDhz4mA8mzEWk4b268Sz0mLOtEtwaXJfPPHPchw6Xw8A+Nu6Q9h54iJef3A6BvWJ6dLxqXuobTLj95/uwX82HnO5f9ZlQ/HS7ElIUr+6j9W2vO42MkB2uNhgxp/L9mPniYu4UG/Chbpml9eejkiM0+KK0Um4cnR/XDE6CROG9G01kLamyYy9p2qx++RF7DlVi92narDvTC1Mlp5RXjXsAmRVGYAMIYTeQ53iDPXnknaOYU/BSG1jGx2ADzrRvt7n7F5gw1vAtvcBi9unRk0kMOlu4KonlDSH3sKX4BgAtE6fhM31gWlLJ5UfqcJbays9DrBKGRCPnB+kYO70SxCj9e2xDtXFOn5vMHWtB7onqWlsST2aNlyHnB+09bIUQFIqg1ydDK7fi48eH4YL2svx9YFzWLPvHL7ef84l19k9a+PmSwfh2YxxmDKsa4Gxs/HJffDRT6/FLz7Yhi/Uv8eNh6sw89Vv8ZcH9UgfxXSdnuzbA+eR/+F2nDC2vL8kxUfh5bmTcccU1+o/cVEtr0fsQW7xzneH8c53hzu178A+0bhydBKuTOmPK0cnYczAhDY/iANA3xgliHZOpbNYbag8X489p2qw+2SNY/BwRwxPjG1/oyAI1wC5EEognKsuzrKhlGlzCZzV2sYXpJSLAEcPcSWALAD57idQy7gZPa0jlcUEVKwGNhYBFV+2Xh83AEj/CZD+GNCX5cu8cs6LDoMeZJtNYvXesyhcW4HNR6pbrZ8+QocnbkhF5oTB7b5AuouPbnnjYg9yC+evL/vGhPBl9/wBz4NU93yC/tc8g7umD8Nd04fBapPYftyINfvOYc3+c9h+3AgpgRnjB+LZjHGYNtyXMvQd1zdGi7ceSsNbX1fgT5/vg00CZ2ubcX/Rejx/5wT8+JpRHPjZwxyrasCfvtiHj7aedLn/9snJ+N3cyRiQEN1qn1iXAJkfxO0OX2jdAaMRygcN+9I/Phr9E+y/R6F/QjQmDOmLUf19K5fXnsgIDcYN7oNxg/tgzrRLuny8UArLAFlKWaIOpMsRQpTaq0yoFSjSAbh0U6ql4fLU38ucgudsAOVCiGIA86SURnUbe9Ccbb+PVKZ64GAZsGcFsP9zoPli620GT1F6iydnAVp+9dkulx7k0AbI5+uakfPuZhiOtv6zz5gwCLk3pCJ9ZGKnXyjjolpeUvjG1cI5QA7pZBlHv2v5PTJGSXMCgD2fANc841gVoRGYPiIR00ck4rnMcTA2mCAlgjI6XaMReGrGGEy9RIf/en8LqupNsNgkXvpkN7YeM2Lh3VNc/s6oe7rYaMZfvjqIv6877JLWpYvT4ndzJmPm1CFeX4eYYuGZ82vuS7MnYdZlQ9EvVhtWNca7k7B9lZFS5gohygHkCiEWQ8kVNgAY7SGo3ayug3PPspTSIIRIBLAYSqBsdDpOGoNjVWO1Egzv+UQJji0eqhYIDTD+DuCqJ4GR1wY2J7incelBDl2KxZEL9fjR3zbiyIWWIF0bITB32iXI+UEKxvqhtJZzD3JdFwf59SQ1TS3pCn1jQ/iye9RpQO2VTwDfvaaMAzi2Aag55fWbIF1c8Ms2XTd2AD555jo89c9ybDuufFD/aOtJ7D1Vi7ceTvOeY01hzWSx4b31R/DalwdgdCtZePvkZLw0Z1K7OedMsfDM+bkYNSDekbNNnRO2ATIASCmLABT5sJ0Rbr3Kbus4pbS72tPA3pVKUHz4G8DmJZjRjQQmzQXSH1UqP1DHhUEP8s4TF/Hjv2905INpBPDotaPx+PUpSO7nv28B4l16kPnGZVfrFCCHtgfZKf/40plKbfBDXyu3964ArpgXmnZ5cYkuFh88cTVe+mQ3/r1BmSlz35lazH7tW/x29iTcNf2SDqcBUWhIKfHpjtMoWLUXR6tcXwenDdfh+Tsn4HIf88xjnV9nzHydsXN+zXX+EEGdE9YBMvlRY7VS9/dEOXBwtdJjBC91pwZOACbMUpbkKewt7qrIaAACgFQqelgtHS9P1wXfHjiP3Pc2o1598YyO1ODVB6bj1knJfj+Xaw4ye5DtXFMsQvSyW3MKqD6s/B4Zq0yqM2F2S4C8+6OwC5ABIDoyAr+/awqmDdfh18t3wmSxobbZgp8Xb8O73x/GC7MmIm0kB/CFs82Hq7Dg0z3Y4pbaNSIpDnm3jcedU7ynU3jiHPw18YO4g/NrLgPkrmOA3BOZm4AzO5Vg+Phm5WeVx2p3LS5JUwLiS2cBA8YEp529hRBKmoWpTrltrgci/Df6vy0fbzuJn3+wFWar8mGob0wk/vrjy33uqemoOPYge+Q6SC9EPcjOvcfD0pWZLSfMAj79JQAJHFkH1J8Hujj1dKDcmz4cE4copeDsswRuO34R97z5PWZOHYJf3X4phiWGvnYqtag8V4eCVXvx+S7XKjn9YrX4r5vH4qGrRiA6suOBHFMsPGs0O/cgM7zrKj6D3Z25SekVOqn2Dp8oB07vbH9GO6FRcoknzAIuvRPoNywoze21tHEtAbKpAYgJfID8128P4XcrdjtuD+kXg388ekVAp/FlDrJnNS4pFiF62XXOPx5xldqYZGU2ymMbAGlT0q7SHglN+3ww+ZJ+WPXsD/DWmgoUfVPpqLe6YvspfLH7DOZdPxpPzhiDhGi+tYXSsaoGLP6mEv/ecNRlZseoCA1+fO0oPD1jTIemNXfnUsXCzNcZO+fKQfHsQe4yvoqEKymBRiNQewqoOaF8PVpzEqg9qfysUe/3VLLJE00kMHiy0lM87HJgbGbY9hT1SFFxgH18XoDzkKWU+MOqvShc2zLZ5JhBCXj30Stc6hQHQnw0q1h4EhZVLJx7kO0BMqCkWRzboPy+5+OwDpABICE6Er+4dTzuu3w4ClbtxYrtpwAog7/e+KoCH2w+jl/eOh5Z+mHMTw4iKSU2HqrC39YdQunuM61qZ8+ZNhS/uGW8X2ZIi2MVC48anV5zYxkgdxkD5HDz4TzgpAHXVx8D1jZ3/jhJqUowbF+Sp7AkWyhpg1PJwmy1If/D7VhqOOG4L21kIv76SHpQKhE4D9JjHWSFlNJtkF4IXnabapS0K0D59mjYFS3rJswCvnhe+b1yrfLBPDYwdY79aXhSHF7/oR4/vqYKv1ux21Hp4lxtM/JKtuMf3x3Gb2ZOxFUp/UPc0p7NZLFhxfaT6syHNa3WXzk6Cc/fOQFTh/nvb4qpXK3ZbNJlwCJTLLqOz2C4MR4BLhyEz5/9NJHKdMz23uFL9MDQ6UAcB62ElajAV7JoMFnw1L8MWLPvnOO+jAmD8NoD+qD1JsSxgH8rTWabIwc8KlLj86yEfnV8o5JCASivFTF9W9YljgSGTANObVVSs/Z/Dlx2X/Db2Enpo5Kw7KlrsXzrCRSs2oszNUrHwq6TNbi/aD1un5yM+bdPwIj+zE/2pwt1zfjXhqN4b/0RnKtt3Znzg3ED8dh1o/GDsQP8PrmL8+sZe5AVTRarYyr46EgNax/7AQPkcNN3aMvv2jjldt+hQJ+hSo3SvpcoAbH9/viBvk95TKHjXOotAD3IVfUm/OSdTdh2rGWU+H3pw7HgrsmIjND4/XzeOKdYsAdZ4dx7HLJZ9Fzyj69uvX7ibCVABpQ0i24UIAPK5CJ364fhtsnJKFxbicKvK9BkVj4QfLbzNMr2nMGtk5Lx0FUjceXoJM7G1wV7T9fg798exrKtJxw54HbRkRrcrR+GR68d5Ze66t44TxTCD+IK5570eObg+wWfxXBz4/PADfn4dlsFrsu4kyXWegrnyUL83IN8rKoBj/xtIyrPtwTez9w0Bv8nc1zQAwF7z4XVJmGy2mCy2BAVGbwAPRzVhEP+8REv+cd2E+YAq/9b+f1gGdBcB0QnBKdtfhQXFYnnMsfhvsuHY9GqvViuTl9stkqs2H4KK7afQurAePzwypG4R39JSCZA6Y4aTVas2XcW/9xwBOsOXmi1fnDfaPzo6lH44RUjgjLbIqtYtNbg1CERG4pvqXogBsjhZsBYAIBFe4bBcU/i0oPsvwB57f5z+Nn7WxwzUgkB/PfsSXj46lF+O0dHCCEQFxXhGJTWaLIyQA51D7LFBJzY3HLbUw/ygDHAoInA2d3KTJoHS4FJdwWvjX42VBeLV+6fjkeuGYWFn+3FxkMtg5krztXjdyt2Y9GqvZg5dSgevGoEpg/XsVfZTYPJgi/3nsVnO07jy71nXUqI2V02rB8evW407pgyBNogflPlkmLBiUIAuFbzcK4mRJ3HAJkoGFxykLueYmGzSbz65QH87+oDjryzqAgN/vf+abh9iufpgoMlPirSESDXmyxdKufUE4S8gsWpbS3TxyeO8jqdNCbMUgJkANj9cbcOkO2mj0jEB7lXY8+pGvx7w1Es23LCUX6w2WLDh4bj+NBwHBOG9MWDV47A3OmX9OoScXXNFqzecwaf7TiNNfvPOtJUnGkEcPvkIXj0ulHQj0gMyQcLDtJrzTmlLZYD9PyCzyJRMLhUsehaD3J1vQnPLtmKtftbBuMN7huNvzyoD4sZxTibnquQV7A4+l3L7556j+0mzAbWFii/H/hCqbHeQyrfTBjSF7+bOxm/uv1SfLztJP65/gh2nWypuLDnVA1+vXwnFn66B3OmX4IUWHGd1RbU/P1QqWky/3/23ju+rfre/38eyZIsecR2NmQ6IUCAAE4Iuw2QQEsHUBLCaOmgJJ23vR2k/d3v7b29bS9N2tvS3SSlgzIaktJJaUmAsEcSBxJGQmKH7G07XrJlS+f3x9H4HI946QwdvZ+Phx4+OpKOPpaTo7deer1fb9a9eZh/bD3EMzuOdvMVp5gysoj3nTOWmy4Y7/hAlog06XVDfR0kAzk7SIEsCHaQpRSL1/Y28JkHqtnfEE3vu7hyOD++5XxGloSGssKsYWrUkzcv56fo9TQgpCdGnwUVlVBXawy1qXkSzrjW+vXZSFGogFtmT+DmC8azZd8JHnh5N3997UBaKW2JxXnw5T0A/OjVtVxYWcHFU0Zw6dThTBtV4olc5baOOG8caGTznnqe33mM53YeS6esdOWMMSW89+yxXHvOGEub7gaKWCy60xJTx0xLaZcN5FUUBDsYYoqFrus8+MoevvnXN4nFMwrPp+dM4cvzprlK6TI10IiCTGPUQQU5kehSIF/S+301zVCRn7/HuP7W3zxXIKfQNI1zx5dx7vgy/uN90/lT9T4eeHkPO440p+/T1N7JureOsO6tIwAMLwpy0ZThXDplBJdMGc7E4RHX+5Z1XWdffZTNexvYvKee6j0NvHngRK8FMcD0saVce84Y3nvOWKaMdGejpsRJdkdVkCOiIGcFKZAFwQ6GkGIRjcX5jz9vNQ3/KCks4P8WnMvVZ43J1gqzhmlYiCjIznqQj+/ITNsMV6SbgHtlulIgb/8HxDvA720P+bBwgI9dOpmPXjKJDe/Us3rjXp54Yz91beYi8nhLjEe3HOTR5OS+U4YVcnGyWD5jbAnjyiMMCzv7WrXGOtm67wSb9zZQvbuezXsbeswo7sqMccN479ljee/ZY5g0oqjP+ztNYUGmAGzrSJBI6J5Q94eCqiBLk152kAJZEOxgkCkW7xxr4VP3b2Lboab0vjPGlPDLD8907RuZOQtZ1B1HPci7u/iP+1I8T6mCYePhxF5oa4Bdz8DUq6xdo0vQNI3ZkyuYPbmCp0bUMemc2bxQc4wXdh7nxdrj1LXETPc/cKIt3eSXorSwgHHlEcaVhxlfYfwcVx5hfIXxcygNgNFYnEONbRw8EeVgQ1t6+9CJNg4kr3ddY29UjijivAllnD+hnDnTRmZl/LOd+Hwa4YA/ba+IdsTzPvtXVZDDgfx+LbKFvIqCYAcmBbl/FovH3zjElx9+jSalyLyxahzfvv5s2ybjDQZTk558/WnKQS61W2FU7RUTT9Kgl0LTjDSLl35uXH/rr3lTIKtomsbkEUVMHlHEbRdOJJHQ2XaoiRdqjvFizXFe3lWXTsNQaWzr5M2Djbx5sPvIZYDySIDRpYX4fRqaBj5NQzOeEM34kfxpXPdpGk3tnRw8EU1HOQ6U4lAB540voypZEJ83vsyWrGKriQQzBXJrTApkNcVCFOTskN//ogTBLgagIHfGE3z/8bf55dM16X1Bv49vXncWN18w3vW+R1MEk0zTc1ZB3qMOCOlHgQzmAnnbo/C+H+T9tE6fT2P6KaVMP6WUT15eSUc8wdb9J3hh5zE27a5nb32UffWtPcaiqdS3dlA/yEK3P/h9GpUjiqiaUM75E8qomljOlJHFnhw7rI5slyQLcw6ymwWUXEIPctiDAAAgAElEQVQKZEGwg36mWGw71MhXV29h6/4T6X2nloX5xYermDGuzMoVZg01YkgU5K6T9Gw85TYegIbdxnZBGMbM6N/jxl8IRaOg5Qi0HDWK7EmXWbfOHCTg91E1oZyqCeXpfbquc6w5xr761nTBvLfO+Lm/Psq++qipwXagFPg0RpcWMnZYIWPLwowdVsiYLtdHFIc8WQz3hKlRr0POM6oYUSQpFllBXkVBsANTDnJ3i0VHPMEv1tfwkyd3mDrM55w+knsWnpdTI3HFg2xGTbGwNeZNVY/HzYKCfv4b8vnhzPfDxl8b19/8qxTI/UDTNEaWhBhZEuJ8pXBOkUjoHG1u52hTO7oOOjq6DgldR4fkwB89eZtxXdd1CgP+dPGb741oKjJu2owqRoiCnB2kQBYEOziJgvzGgRN8dfUWk28xWODjS/Omsejyypx7U4xIDrIJx3KQTfFu/bRXpDjzg5kC+a2/wXu+Cz73RAnmIr6kAjy61BvDV5wmLMNCTJgHhUhplw3kVRQEO+jBgxzrTPDTp3by86d20pnIqMbnTyjje/NnMHWUe4L5B0KR5CCbcMyDbPIfn2RASE9MugzC5RCth6YDcKDaUKEFwSWovQ5SIJvFCMlBzg5SIAuCHXRJsdi67wRfXfOaKb4tVODjK1efzicum5zTPkL1jas5z5v0EgndlHZgW4HcdgIOvW5saz4Yd8HAHu8PwOnvg1fvN66/+RcpkAVXETZ5kPP7PAMQNU3SkwI5G8h3ZoJgB4qCHGtr4fqfP28qjmdNLOexL1zOne+qzOniGDBlveb7lKuWWCepLwciQb99Ew/3bsBwsgJjzoHC0oEfY/oHM9tv/TVlkhUEVxAxpVjk93kGzDFvMmo6O8irKAh2oBTIwUQbiUQc8FEY8HHXNWfw0Usm5XxhnCJiykHOb2WnyakEi8HEu3Wlcg4ESyDWBPXvwKGtMLafSRiCYDHSpGcmqqjoEclBzgqiIAuCxTS3d3L3P7cT1TMpAoXEmD25gn9+4V05b6noSpEpBzm/lR3HxkwPxX+coiAE067JXH/rr0NbkyBkkbB6npEC2ZQYJE162UEKZEGwiHhC56FX9jDne+tZ/kwtrYTSt33zPZP4w50XuXZc9FBQlZ18j3lrbFMj3mx60+psh/2bMtcHqyCD2WbxphTIgnuISIqFCdOoafEgZwX5mCEIFvDsjqN859G3TD7jKCHAuH7TucPBQ6qxSvFAYt7e+BO88FM4bR5c9qX+Z/XmCOYEC5sU5IOvQWebsV0+GUrGDP5YU+caQ0Y6o3BsOxzdDiNPz846BWEIhANisUih67opB1ma9LKDKMiCkEV2Hmni4795hY/c+4qpOB5TWkgopOSf9jFuOpdR/W99Nuk9tgT2b4T1d8O98+DYDotXZy+OeJB3v5DZHop6DEb6ymlzM9ef/xEk8rsYEdyBKQc5zyfptXcm0s3AQb+PgF3NwB5HXkVByALHm9v5xl9e55p7nuWp7UfT+yNBP1+aN42nvjKHUCicecBJxk3nOkG/j4KkOt4R14l19jJetzMGzYcz1w++CsvfBZt+65nEBNMUvbBNCrJpQMgg/ccq06/PbL/6ADx4k5GPLAgOIk16GdTfXxr0socUyIIwBNo74yx/uoY531vPfS/uJp78GK9psHDWeNZ/ZQ7/dtVphIN+Er6MB7mncdNeQdO0/o2bbm/svq+jFf72BVj1YWits2iF9tFot4KcSMBepUCeeMnQj3nWDXDG+zPXd66DlVcZdgtBcAgpkDOo39Sp8XfC0JACWRAGga7rPLrlIHN/8DR3P7aNJqUIvGTKcP7++ctYOn8Go5SxsnG/UiB7WEEG8zS9lt5sFm0nMtvhChh5Rub6tr/DLy6B2vXWLNAmbB8zfeztjLobGQ7Dpw79mD4/3HQfXP7lzL66GqNI3v7Y0I8vCINATbFoy/NBIWYFWVrLsoUUyIIwABIJncffOMT1P3uezz5Yzd66aPq2yhFF/Or2WTzwyQs565Rh3R4b96seZO8qyGA+Sfeq7qgF8rBxsGg9XHBnZl/TQbjvenj8Pw07Rg7SZHeKxZ4u/mMtS42gPj9c9Q1Y8NtMpnesCR66BZ75nmcsMULuIApyBvVbOmnQyx7yUUMQ+kFnPMHftxzk5+t38vbhZtNtZZEAX7zqNG67aOJJmyPyVkHuzWKhFsiFwyAQhvd930hO+MtnofUYoMMLPzaU5BvvhZHTLF13tmm0OwfZ5D8eYoNeT5x1g6FKP3QrnNgD6PDkt40hItf9HELF2X9OQegBSbHIoEa8SYGcPURBFoST0NYR5/6XdnPF/63ni6teNRXHwQIfd1w2mae/cgUfu3Ryn53DCV9+pFgAXTzI/VCQCxXF/fT3wKdfMArlFIe2GA18G3+dU2qlOebNDgU5CxP0+mLMOYbaP+nyzL43/wK/vsaYuCcINmDOQc7vFIuWmIyZtgIpkAWhB5rbO1nxTA2XL3uK//fn101WiqKgn8XvquS5u67gP98/nWGR/imDJotFh8ctFkE1C7kfTXqFZebbSkbDravhPUshpbx3RuHv/w5/uA2aDpML2DpJ78R+aNhjbAci1o6FLhoOH/kTzF6c2Xf4dVhxBdQ+bd3zCkKSiEzSS9MqGciWIB81BEGhviXGb154h9+98A4nlIguMKwUn7h0Mh+9eFK/i2IVk8XC8wpyP7KQTQpyaffbfT646FMw+XJYcwccfcvYv/1Rw3Jxyefhks9BqCR7C88y5pg3i0+3qno8bhb4LS7I/QG4dpmhKD/6JYjHIFoHv78B3nM3zF6UPQ+0IHRBtVjk+yS9VrFYWIIUyIIA7K1r5XcvvMODr+zppkaMLg1x5+WV3DJ7gsk6MFDMCrK3C2STgjxQi0VXRp8Fi56Ctf8Fryw39nW0wNPfhY33wpyvQdVHrS8IB4GtCrLV/uPeqPqIMV1v1YeNXGs9Do/dBQe3wPt/AAWhvo8hCANEHRTS2hFH13W0PP1A1ioWC0uQV1LIWzriCZ546wgPvrKHZ3cc7WZtnTg8wqffPYUbqk4lVDD0T+X5koMMUBwaRJPeyQiEDbXy9PfCv/4DjryRPPhRePTL8NIv4Kr/gjM/4CrV0lYPcrYHhAyE8bMNX/IfboMD1ca+V++H4zth4f1QPNLe9QieJ1hgDCTqTOjEEzqxeCIr5+lcpFVSLCxBCmQh79hb18ofNuzh4Y37ONrU3u32M8aU8JkrpnLt2WMoyOLIzrxVkHuNeVM9yH0UyCmmXAGfeha2rDLSExr3G/uP74SHPwLjZsPV37K/QOyBzngi/btrGhRbqexEGwwPMIDmg3EXWPdcvVF6Cnz8McMn/tqDxr69L8HKK+HWPxjfBAhCFgkH/elvaaKxeP4WyEoO9FC+5RTMyCsp5AV9qcWaBu86bSS3XzyRK88YZclXdeYcZG8XyCYPcn8U5FAPHuTe8PnhvFuNyLGXl8OzP4D25LH2vWKkKZzxfkNRdjAWrln5vYtDBfh8Firb+zYAyX/UY2Y458sOFML1P4fR0438anQjDu7eq+HGXxnfAAhClogoBXJrLE5ZxOEFOYQoyNYgBbLgafpSi0eWhFg4azwLLxjP+Aprz67mHGRvWyz6pyAPwGLRE4EwXPZFqLodnv0/eGWF0SgGxiS+7Y8Zt835GpSMGfjxh4itU/R2dxkQ4iSaZjRQDj8N/ngHxJqNy0O3wNz/hku/4CobjJC7GOcZ47wezeNpetKkZw1SIAueo6E1xuNvHOZvWw7w3M5jvarFt8yewFVnjuozvzhb5FMOcrEpB7k/MW+DKJBTRCrgmu8YqQlPfhu2Pmzs1+Ow6Tfw2kNw5gfh/A8b2b0+e/7ejXb4jxNxePGn8OLPMvtcYC8BjDzrO9bCQwuT8XM6rPsvOLodPnCPNO8JQ0aSLAykSc8a5JUUPEF9S4zH3zzEo1sP8cLOY3Qmug+TGFUSYuEF47lplvVqcU/klwd5oDFvQyiQU5RPhBtXwsWfhbXfgF3JPN7ONqNo3vowlE00CuXzbjXGW1tIY9RiBfnodvjzZ2D/xsy+4jFQOSf7zzVYRk+HO5+CVR/JjMF+7UGoq5XmPWHIyLhpA8lBtgYpkIWcpb4lxr/eOMSjWw/yYs3xHovilFp864UTuPIM+9TinjDnIHvbYjHwSXoD8CD3xSnnwe1/gZon4MnvZFIVABp2w1Pfgaf+F6ZcaUSUnX6tJWqmZQkW8U548Sfw1N0QV2xDY8+F638J4bLeH+sERSOMv8ff/91ItgBp3hOyQrg/H8TzAJmkZw3ySgo5RV2yKP7H1oO8UHOceA9FMcC548t43zljuPacsYwrd0fnhijICom42WIxkCa9/qBpxqjqqXONPN7Nv4ctD0NbQ/IOulFA1zwB4QqYsdAolrNYrJkzkLN0qj2yDf78aXPR7wvAnCVw6RddmQUNQEEQrvspjDpDmveErGEeN52/CnJUPMiWIAWy4GoSCZ03DjTy7M6jPPv2MV55p67Xovi88WW875yxvPecMa4pilXMOcjeLpBVD3JzTx7k9qbMdqjUSKawirEzYOz3YN63jOa9zb83JvGliNbBy78wLqecb6RjjL/IUKKHoCyrHuTS8BAL13gnvPBjWH93phERYOx5cP0vDCuD2zlZ8968b8Il/ybNe8KAUD3I+WyxaFFECDVBSBgaUiALruNAQ5Tndhzj2Z3HeH7nMepaYr3e9/wJqaJ4LKeWhW1c5cAxK8gtoOueLQgiSoHc4xtXtv3H/SFQCOfMNy71u+HVB+HVB+DE3sx9Dmw2LgD+kFEwT7jQKJjHXwhFw/v9dFlTkA+/CX/5TGZdAP6gkc5xyRfAn2On8Z6a99Z+w/BUv/8eQ20WhH4QVuwErfmcYqHY2MJiscga8koKjtPS3snLu47zzNvHeHbHUWqOntyfWzWhjGvPGcu154zlFJcXxSq6r8D4OjzRAXoCOtuNos2DFAX7mKQ32AzkbFE+Ea74Orz7LkNN3ny/oS6r6my83fDK7n0J+JGxb/hpmYJ5wkV0i0hRMHuQB6Egxzvh+Xvg6aXmdZ1SZWQNjzpz4Md0Cz017736gPHBZeHvjWQSQegDs8Uifz3Iqo2tSCwWWUMKZMF26ltivLq3gc176nl5Vx3Ve+rpiPdeaIwoDnLZ1BFcdtpILj9tBKNLc7ioDEYyxWFHq2cL5K45yLqum4evOKEg94TPD1OvMi6tdfDW32DPi8bY5vpd3e9/fIdx2Ww0m11aUALbJ0FkOERGJH8Oh0gFkw61cLEvRp1ewijGQGfM8Ai3N0K03ni+aJ0xBS+13Vpn3Batg+M15jX4g3DF/wcXfz73VOOe6Kl5b/dzcO88uPVhGD7F2fUJrkdSLAzU3z0sBXLW8MBZVnAzHfEE2w42sXlvPZv3GEXxO8dP7r8NFviYPamCy08bwWWnjeDMMaXWTiGzk0BRpjiMtXhWKQsW+Aj6fcTiCeIJnfbOBIWKXzBrGcjZJFIBMz9qXACaDsPel43Lnpfg4GuG+q8Q6GyCQ1t7PNxtwG0pt8BTyYvmN/KZB8qpM+G6nxtNbl4i1bw3fAo88U1j3/Gd8Ku5cPODMNHhoSeCq1GLwXwdFBLrTKQTnAp8GkEHk5q8hhTIQtbQdZ0DJ9p4LakOb97TwNb9J2jvTPT52DPGlPCuaSO5bOoIZk+uMBdTXiKoNA92RJ1bhw1EQn5ircbfvjUWN/9N3aIgn4yS0TD9g8YFjL/X/mrDcrEnWTinUzH6yUCL44JCmPN1uPhz3lCNe0LT4PIvQcVk+NOnjNzqaB3c90HjQ8GMBU6vUHApERkUYrJXhIN+8zd1wpDw6BlXsBJd1zna3M7bh5p5+3ATO4408fZhY1ttTOqNoN/H9FNKOX9CGeeNL+PiKcMZVeJNq0E3AmqB7PEs5GABDa2G4trS3klFkdJ8ZVUGspUEwjDpUuMCkEjw4uNruPicqYY1ovUYtB5PX17Y+jb+tjrKaWJypJ1Ae53hPQ8UGWp1uNy4RCqMqDl1O3X7iGnuyzW2irNugNJx8IdboOWo4bt+5JNQVwPvXuLZhlZh8KhWrny1WKi/d5E06GUVeTWFXkkVwjVHWnj7cJNRDB9u5u0jTenCpz+MKw9z/oRyzh9fxvkTyph+SimhAo8qxH0RLMpsezzqTY0baunaQJMLCnJf+Hy0F46CU6t6vPn/bV9PbaPxIWjd597F1BFFkOiUlIaTMf4C+OQ6eOAmOLbd2Lf+bmPy3gd/IuOpBRNhyUE2T9GTiLesIgVyHpNIGAXwvvpW9tVHlUsr+xui7K+P9sseoVJSWMDZpwzj/AllnD+hnPPGlzGyRN7U0pgUZG8XyKZGva7T9Npc6EHOMo2mmLcA+Hzgk+K4T8onwR2Pw+qPZvKqt6yChr1w8wOe9e0LA6dfI+09TqsMCbEMKZA9hq7rNLZ1UtcSo66lnePNMepbYxxviVHXHKOuJcaRJqMoPtDQRiw+sAI4RVHQz2mjS5g2uphpo0vSl9GlIfFAnQzVg+z5cdMnefPygoLcB5aNms4HwmVw2xp49MtQ/Ttj354X4FdXwa2rYcRUZ9cnuIKwpFiYxAcZM51d5NV0GW8fbqKuJcZrRztp3XqQaCxOa0ectlicaEec1licto44rbFOoh0JorE4Le2d6SK4viWW7mjNBsPCASYOj3DaKKUYHlPCKcMKpRAeDAHFYpHXCrLS3OZEDrLFtHfG09++FPg008QvoZ/4A/CBHxkJF2u/Yeyrq4V758LCBzJecCFvUf9f5WuKRbRDsViIgpxVpEB2GUv+uIXNe5LFw6Zqy5+vPBJgXHmEceVhTi0LM648zLjyCKeWhzm1PEzpYAYcCL2TRwqyOm6627AQjyvIXafoyYfJQaJpcOkXDNvFI4uSCRf1cN91MO9/YPYi76Z7CH0iTXpm8UGa9LKLvJouIxtKU1HQT0VxkIqiEMOLgpRHggwvDlJRZFxGFAeNIrgsTFFI/gnYSl55kE9isXBjDnIWaerqPxaGxvTrjISLh26GliNGHvW/vg6bfw/vXQaTL3d6hYIDRKRJz/R7y5CQ7CLVkcs4c2wpnXGd1uYTjBs9knDQb1wCyUtyOxJUtwsoiwQYXmwUw57NEPYCaoHs+RQL8zQ9Ex5XkBujGf9xaVhOs1lh3Ey48wl48GY48oax78ib8Lv3w1kfgqu/DcNOdXaNgq2EpUnPlBAkY6azi5y5XcZ/vn86AOvXr2fOnJkOr0bIOsH8yUE2Kcj5bLEIiYKcNcomwKKn4MWfwTPfy3wL88Yj8PY/4fIvwyWflzi4PCEik/S6jJmWki6byExCQbCTQP7kIKse5Ga1SU/XzTFvHmzSkwQLCykIGZP3PrcRzr4xs7+jFZ78FvzsQtj+T+fWJ9hGoZKn39aRIJHFBvVcoVUUZMuQAlkQ7CSYTx5ktYFGUZBjLZmRy4GIJwdnqApyaVgUZEsYdirM/zV87FEYdVZmf/0ueGghPLAAjtc4tz7BcnxdEmLyUUVWm/TEg5xdpEAWBDsJ5E+KhXmSnvLG5XF7BUCjKMj2MekyWPwMvPd75n9POx6Hn18E674J7c3OrU+wlEieZyGrTXrSdJ9dpEAWBDsJ5mcOssmDrBbIHrRXQA9T9ARr8RfAhYvg89VQdTuQjNWLx+C5H8BPL4CXl3ve1pSP5Pu4abVJT3KQs4sUyIJgJ3mVYpE5WTf3ViB7VEFWPciloiDbR9EI+OBP4M4n4dRZmf1NB+Cxu+Ces+HpZUaWsuAJTApyR/4lWURjMknPKqRAFgQ7yaMUi6LeQvw9noEM0BhVPMiiINvPqVVwx1q4/hdQNCqzv/U4PPUd+OHZ8K//gMYDzq1RyAqqBzkfLRYS82YdUiALgp3kUYqF2YOcvwqyeJAdwueD826FL26Ba78PwyZkbos1w4s/hXtmwF8+B8d2OLdOYUjku8VCBoVYhxTIgmAn+Zpi0d5bk543PcgySc9FBMIw+074t2r40EoYNT1zW6LDmMb30wtg1Udgf7Vz6xQGRb6Pm26RJj3LkAJZEOzEpCB73GKhTtIzeZAbMtseVZDVFAuZpOcS/AGYcRN8+gW4ZRWMv1C5UYe3/gorr4D7rqO8rhoS+Vds5SL5Pk3PpCDLFN2sImduQbCTvFKQzRYLXdfRNM08JMSjBbIoyC5G0+D09xiX3S/Ccz+EHf/K3F67nnNZD+/cC+febNg0hk9xbLnCyYkE1GEh+fehxuRBFgU5q4iCLAh2UlCIKYIq7l3FI+D3ESwwTjEJHdo7E8YNeRDzJh7kHGHixXDbw/Cp5+GcBaApb4mN++DZ78NPquDX74Hq+8wf7gRX4Ioc5PZmY0KoA7SaUixEQc4mUiALgp1oWpcsZI/bLFQVOWWz8HiTnq7rXRRkKZBdz5iz4cZfGTnKF36aWKDLB7c9L8JfPw/fnwaPLILa9ZBIOLJUwUzYaQ/yM9+H7443PkR1ttv61B3xBLGk8ODTIFQgJV02kVdTEOwmr7KQVR9y8s3LFPNWZvOKrCfaEaczYahJoQIfoQJRdXKGisnw3u/y4sW/hoX3w+nXgqb8/TqjsGUV3Hcd/GgGPPkdqKt1br2CSTW1PcXijT/Bk98CPQF7X4Lt/7D16Vu7ZCBrmmbr83sdVxfImqaVaZq2VNO0tZqmbUpuV2XhuIuSx1yajXUKwoDIIx+ymoWc9sp5XEEW/3Huo/sCcOYH4JaH4Mvb4OrvmNMvAE7shWeWwY/PhxVzYP1SOPCqY1+15yuOWSyObIM/f9a877VV9j0/XYeEyAfxbOPaAjlZCO8CaoAFwJ1AJbBJ07S5gzzmfE3T6oF5wBJd15dka72C0G/yKMkiEuqhw9zjMW8yRc9jFI+CSz5npF8sehpmL4Zwufk+BzbD+v+FFe+GH5wJf/sCbH/M898QuQFTDrJdk/TaGmHVh7tb5HauhZbj9qwBGTNtNW4+ez8BrNB1fUXyejWwQNO0GmCtpmnluq439P5wM5qmLQcWAfN0XV+X/eUKQj/JUwW5OWWx8LiCfEKZolcSFgXZM2ganHKecbn6W/D2P+HVB2HHWtAV5bLpIGz6rXEpKITJ74Jp74Fp18CwcU6t3rPYPklP1+Evn4HjyeEyBWEoPQXqaiDRCW88YuRu24CMmbYWV76imqbdBZQBy3u4eQ1wF3ATsKKH23s6Xqo4nqLruhjGBGcxeZC9rSCr0/Ra00163o55EwU5DygIwfTrjEu0HnY+AW//C3Y8bs757mwz9u14HB4FRp8D066GSZfDuFkQKnHsV/AKtlssnr8H3vpb5voHf2x86P/HV4zrW1bZViCr+fKiIGcft569FwINvRSzazEK5AX0o0DWNG0RRnG8RIpjwRWYUizyR0FuicWhow3iyU5vfzAZe+ctJMEizwiXwznzjUu8E/ZtgLcfMwrmo9vM9z281bg8+39GpNyYc2DCxcbQkgkXQ+lYZ36HHEZNsbC8Sa92PTzxP5nrsxcbw2dajsM/v2YoyPs2wPEaW7KzW5Xc54hkIGcdt76iVRiWip7YmPw5q6+DaJqWUqFrdV1flqW1CcLQyKMUi24e5K4ZyB7sujZN0ZMmvfzCX2BkK0+8GOb9D9TtMtTj7Y/BO88Zo61T6Ak4+JpxefmXxr6yiUahPCFZMI84HXyubRVyBRG7Juk17IU1nzD+bgDjL4Krv21sFw2H067OpFhseRiu+Lp1a0nS2q4UyDJFL+u4rkDWNK0yuVnX0+26rjcko0z6kw+1KPlznXLsVArGuoF4mAUha+STBzmkepA7Pe8/BlGQBYWKyXDhYuPS3gQ1T8KuZ2DPS3D4DaBL4kXDbuOy5Q/G9cIyGHeBkdM8+mwYfRYMn2qMzRYAswc52mFRNnVHGzx8O7QmG/CKR8NNv4OCYOY+M25SCuRVMOdrlgsA6gcCVYwQsoMbz96Vfd+l3yxM/lyr+JDTaJq2TJIsBNsJ5KfForU9bhQJKTxbIKtT9KSQEZKESjK+ZYBoA+zbaAwh2fuysd0ZNT+mrcFIRti5NrPPHzSU5dFnKZezjbQND34j0xfmHGSLFOR/LoEDyS+1fQWw4LdQMsZ8n2nvNb4Va2+E+l2G1WL8bGvWk0T1XBdJk17W8formlKLVwJ3A1MwlOmvY/iY79I0bYOu62u6PlDxLjN69GjWr19vy4JTNDc32/6cgrWk/qaTDx5lYnLfru1vsLt9vZPLspSDezPF4vbad3it5Q3OTV6viybYkuP/xnv6f7qtJjNN6/C+d1i/fr/NqxKGin3n3wLwXw6TLkeb0EFxcy3DTmxj2Ik3GXbiLYIdJ7o/JB7LeJkVYoFhtBRNpDUyjmh4TPIylrbC0ST8IRt+F2eob8uoxg3N0V7/boP9m445uI4ztv82fX1H5cfYvysGu7of6/Ty2Yw9ZIRk7X/sB+yY9qkBP99AeL02lt4+dvgA69cfs/T53IiV/1c9WyArVg2AO7sUwUuS/uRFwFKMZAwTyXi5FQCzZs3S58yZY+Fqu7N+/Xrsfk7BWtJ/U99G2GPsmzxuFJM9/Hc++MoeHtpmvJFXjBzLudOaYYtxW8XYiTn/b7yn/6d/PrQZ9hwAoOrsM5kzU6K9cg1XnH913ZjSd/BVw46RupzY2+Pdgx0nCDZsobxhS/cbS8ZC+WQon2TYPsonZ35GKnJaeT4R7YD1jwMQx9/r321Qf9P91fCskgVw9nxOu/H7nNbb6zXRD78zCuRT61/m1MvuM9swssym2HZ4eycAZ0yZzJw5p1n2XG7Fyv+rbiyQU0kTFX3cry//cNqj3JNCjFEYLyK7lg5B6Bs1xcLjTXomD3LXJj3PWizEgyxkAU0zkhCGT4Gzb8zsjzbAkTeTBfPryZ9vdh9aodJ00LjseaH7bf4QlIw2iuji5M/U9ZIxUDzG+Bkud2UhbWrS64ij63p2Ri63HDd8x3XsOsUAACAASURBVKnUnVHTjUi3kx174qVQOg4a90G0DnaugzOuHfpaeqFVJulZihvP3qnmvL6a8PqKbDvp7bqu16b+E2maViYNe4JtqCkWJ3tT8wBFwS45yB7PQAYZNS1YTLgMJl5iXFIkEtDwjlEo19UaHti6XcbPhr3mQSZdibdDwx7jcjL8IcPnHC43XyIV3felLqFSCIQtLawDfh8Bv0ZHXCee0InFE4QKhlgsJuLwxzsyan2oFBbebxY3esLngxkL4LkfGte3rLK4QJYmPStxXYGspFT0qOwq1omTTsNTjtMXDVIcC7aSRwpypGsOch4oyKaYt7DrTrGCF/H5oKLSuHQl3gEn9pmL5vp3oO4dIzGjvbH7Y3oi3m4UjL1YPHpHg2Cxcd4LRpI/U9eLjKbl1HZBoWFJ8AeNgtwfMIay+JP7um5rPtB8nBvYS1MiQQIf7Qe3EQqHjKLc50/ex0+w/bjxOug6oBtxbelt3bx/8++h9qnMr/ChFf3PNZ6xMFMgb3/MUPzD/QndGjgt7aIgW4lbz97rgLmaplXput41D3lu8ueqfhynGqjq6ThJD3LquQTBPgL5FPN2shxkbxbIqoIsOciC4/gDht+4YrLRpt6V9mZoPgxNhwwbRvPhpCXjkPkSa+rhwf1BNx476Mf3zRqAVB/ivT3f5xKAFwdx8Hd9FU5/b//vP+pMGDMDDm0xPlS89Veoun0QT9w3rTJq2lLc+oouxyiEFycvKguA6h4K3qXA8S4DQZZgTN5bSPfBI4uU+wiCfQTzadS0oiC355+CLB5kwfWEio1LXwppezO0HDEU0Wi9cul6PXWpMx7TNboul5hyFcwZxMCPGQuNAhmMoSGWFcgyatpKXHn21nV9jaZpK4BFmqatTTXZaZp2F8YEvZnq/TVNm4sR24amaetSxbOu6+uSxzHFuSXv/3VggYyfFmwnnxRk1WLR3mn+OteDBXIioRsDUZIUy/hXwSukCumBkogbQkD60mze7mg1ttubjAi7znbDFhJv77IdM26PJ/d1tidtEnFqjzYR64jjJ8H48kIK/Ri+az1h+LP1BO3tUUKhpB9a8wEaaCjbmnl71Jnw/nsMm8ZAOWc+rP1P4/nfedbwgZeNH/hx+kAUZGtx7Suq6/piTdM2AYs1TVuJ0bxXDUzuwTO8MXkbXZXlLsdZitG81wDMlOJYcIS8HTXtfQW5OdZpWBkxGhQL/DImWMhzfH4oLDUuFnHXL15g4+56AB6+/mJmT+4egvWindF9JWOgco4xORFg62q4/EtZfxpRkK3FtQUymLOI+7hfA11U5cEcRxBsIZg/KRYRZQxsS6wTve0E6dZZC98wnUISLATBfsLBLr0ObmDGwkyBvGUVXPbvWU/zkEl61iLyhiDYTSB/UiwK/D4KA8ZpRtdBjypf/nhQQW6SBAtBsB3zuOmTRNrZyRnvz3xbeHRbxpOcRdQCOSwKctaRAlkQ7CaYPx5kMCsbmsc9yI1RUZAFwW5U/22rWwrkULFRJKfY8nDWn0JVy4skBznrSIEsCHbTtUkvkXBuLTaQ8iEX0ImW+kCg+YwsVI/RJAkWgmA74S7T9FzDuQsz21tXQzx79o94Qqetw3jv0DQoHOpwFKEbUiALgt34/EYgfopcjkHqBykFuQRFLQ+VunJs7VARD7Ig2I/a6xB1iwcZYPIcKBplbDcfhl1PZ+3QUeWDQDjgx+fz3vnUaaRAFgQnyKMki1QWcqmm/J4etFdAlyl6oiALgi2Ym/RcpCD7C4zItxRb+jPfrH+0tqsJFnKusQIpkAXBCdRx015Pski+eZkUZI8WyKIgC4L9hN3YpJdihmKzeOtvxvCULGDOQBZ7hRVIgSwITpBPCnIwPxVk8SALgj2oFgtXKcgAY8+FEacb2x2tsP0fWTlsi2QgW44UyILgBHmUZJFq0ivNAwVZTbEoDYuCLAh24MoUixSaZm7We+0PWTmsKMjWIwWyIDiBKQvZ2xaL4rQHWfk9PVogN4kHWRBsR7VYtLkpxSLFOQsy27VPQdPhIR/SNCRERtpbghTIguAE+aQg95Ri4dkCWfUgy5uWINhBxI2T9FTKJsDES41tPQGvrxnyIdUmvXBAFGQrkDO4IDiByYPsbQW5KPnmlQ8eZLOCLBYLQbAD16ZYqMxYCLufN7a3rIKLPzukw2VFQdZ1iHdAPAaJDiOnOdFh7Et0Jn92vd4Jetwo9BMJ42f6ejy5rSe3E4A+8HVNvATKJw3ud8oiUiALghOYUiy8rSCnY9665iB7kEZJsRAE21E9yFE3WiwApl8H//gqxNvh4GtwZBuMOqP7/XQdOtsh1gztTYaAEmsx3ic6osmfrYzfsY9P+XcT1mKcfywEf49kbu9sM47R2W48X2d7cl/M+Jne186gClirufFeKZAFIW/JpxSLVJNennmQxWIhCPYQyQUFOVwGp78H3vyLcf2Pd0DRCCP2Ldac+RlrNlTaPpgNzE59Bj+avAhZRc7gguAEJg+yty0WKXWnFGVioGcLZPEgC4LdhAMuzkFWmbEwUyAfft3ZtaTQ/OAPgj8AvoLkz4Ax5MQXMO/3B41tzWdMhNV8xuPT1zXjuum2QUz4K5uY/d9zEMgZXBCcwJRiIQqyF+iIJ9LqlU/L5D8LgmAtYbc36aWYOg+GT4XjO09+P18AQsUQLDF+BiKGqBLIXDYeiLLxQDttBLlo2jguOmMCBMJQUJj8GTK2/aHkdkjZFzR+FoSMYlboETmDC4IT5FGKRXpQiCnFwnse5GZFPS4OFeDzDUI5EQRhwOSExQKgIAif+BfsetpQV9UiOFiU2S4I9XmoR/60lQf37AHgW9PO5qLZ7lBdvYSlBbKmaVcCVbquf9/K5xGEnCOfUiySTXolHk+xkDHTguAMhQWZArm9M0E8oeN36wfUohFw9o1DPoxqJYlIzJslDDoHWdO0r2ia9q/k5cu93O0mYOlgn0MQPIspxSLa+/08QErd8fokPXXMtEzREwT78Pk0kw/ZlcNCskyLkoOcsrEJ2WVQBbKmaaswCt95wBTge5qm7dA0ravG3zDE9QmCNwnkkcUiVIBGgmK1Sc+DMW+NkmAhCI6RMzaLLKHG2YWl38ESBlwga5o2GVgArAPKdV2fquu6D1gJrNM07Vzl7sezs0xB8BjB/LJYlBDFpyXzNoMlnmwMUS0WMmZaEOxFbdRzdZJFljApyEHvnU/dwGAU5CqMZOnFuq6fSO3UdX0ZcA1wb5ciWRCErgTyZ1BIOOA3jZnWPWivgK4FslgsBMFOTApyh4uTLLKEqpKHpUC2hMEUyA0Auq6/0/UGXddrgbkYlosrh7Y0QfAwwfwZFOL3aYwMtKWv6x60VwA0RsViIQhOodoM8sFiYRo1LRYLSxjMq7oR0DRNu0LX9ae63qjregNwtaZpj+PKGYaC4AJMCrK3LRYAo4JtkDyfdwZLCTq7HEuQFAtBcI5IrgwLyRJq3nNEFGRLGLCCnLRVfA14Iplk0aMcpOv61YM5viDkBXmkIAOMKMgoyJ2BYgdXYh0yZloQnCOcZ0166u8YCcn5xgoGVcAm/cblwBN93G8eRvOeIAgqeZRiAVDhzxTIsYISB1diHRLzJgjOkTPT9LJAIqGbPciSg2wJg/7YkVSSN/fjfp8a7HMIgmdRc5BjLaDrg5tZnyNU+DMRb+0eLZDNFgtRdATBTvLJYtHWmfn9CgM+9w5FyXHEAiEITuAPgC9ZROlxiMecXY/FDPNlVPKo36sWC/EgC4JT5FMOcku7Yq+QBj3LkAJZEJwi0EVF9jBlypjpVq3oJPfMXUwWC1GQBcFW1BSLqMcn6ZnGTEuDnmWYzuK9NdxlC13XG608viDkFMEItCejxDtagQpHl2MlxUoOcotHC2RRkAXBOSJ5NCikJaYOCZEP41aRfmU1TbsKWI4RzWaFoaUGY5CIIAhgbtTzeJJFiZ5RyJs8WyCLgiwITpFPFgsZEmIP6bO4rutPAFMdXIsg5Bdq1JvHs5AjaoGMNwvkRnWSnqRYCIKtmEZNe3ySnprSURSSAtkqxIMsCE5h8iB7W0GOJJrT2w2JsIMrsYa2jjixzgQAAb9GqEBOrYJgJ3mrIAfk2yqrkLO4IDhFMH+ykAvjGQW5Ie69Armr/1jzcGSfILgRtVD0foEsCrIddG3Su9LC56rTdf1VC48vCLmFyYPsbYtFqLMpvV2XiJzknrmJTNETBGcJ51GTXqukWNiC2qR3PsYIaauoAT5t4fEFIbdQh4V4WUHWdQJqgRwPObgYazD5jyXBQhBsJ5JHk/RaJQfZFtQmvc3A1Q6uRRDyi3xRkGMt+HTjhB7Vg5yIec/ZJQqyIDiLOm7Z6xYLNeZNFGTr8N47lSDkCvmiILdn4s8bidDa7j11R8ZMC4KzmHKQ82pQiJxvrEIKZEFwinzJQW47kd5s1Ito8aC60xhVM5DFYiEIdqMWil73IIuCbA9SIAuCU+RLDrJaIBOhxfMKshTIgmA30qQnZBspkAXBKfIlB1kpkJv0iCcbaMSDLAjOYmrS64ij67qDq7EWadKzh34XyJqm/ULTtBs0TSvt5farNE37UPaWJggeJ19ykNvMHuSWdu+pOzJFTxCcJeD3EfAb+ePxhE4snnB4RdbRqnisI5KDbBkDUZCnAn8E6jVN25EsmD+UKpiTo6oX9lZAC4LQhXxJsWhrSG826hGiHXHiCW+pO42iIAuC46hJFl62WaiNzpGAFMhWMZACeT5wE/ArYDiwGFhNpmBeBVQB3836KgXBi+RLioVqscD4UOA1m0WTKQdZCmRBcALVbuDlqDf1dysKyfnGKvpdIOu6fkLX9TW6ri/Wdb0CIzN5ZfKiAQuAKcBCS1YqCF4jT1MswHtvXmYPslgsBMEJwsH8yEJulRQLWxj0Rw9d19cB6zRNuwpYktxdmZVVCUI+kC8pFl1ykAHPJVk0RmWSniA4Td5YLCQH2RaG/Mrquv6EpmlXArXJaXyCIPQHNcWiI+rcOqzGpCCnLBbeevNqahcPsiA4Tb6MmzYVyNKkZxlZiXnTdf1JYJ6maedl43iCkBcE889ikfIgN3tMQZZJeoLgPOEuUW9eRNd1s8VCmvQsYyAxb3WapsU1TdvQU+Sbrusrga9LioUg9BOTguxhi4Ua86Z7r0lP13UZFCIILkBVkNs89i1VivbOBKkQoGCBjwK/jLOwioG8sqsxmvHKMRIsUpFvxzVN+4OmaXdjeJAlxUIQ+kMeKsgnMD4UeCkLuTWWia0rDPgIFsgbliA4QT6kWKj9G9KgZy0D+S7wLqBc1/WbADRNmwvMxYh2u0m5XyXwmaytUBC8SkEhxmdOHeLtkIiDz4MnvB49yN5RkEU9FgR3kA8WC1PEmzToWUq/X11d109omrZK07TzdF1/NZVikbpd07TJGMVyrQXrFATvoWlGFnKs2bgea4FCDzqUevQge+fNS414kwxkQXCOiCnFwjsfwlXUAjksCrKlDOhsruv6HzVNG9bLbbuAXVlZlSDkC4FIpkDuaPVegdzRZqjjQFwroI0gYJ4Eles0SgayILiCSB7kIKvfvhVJgWwpAzbL6bp+ou97CYLQL4IeHzetZCC3F5RgWEqgxUNvXo2SYCEIriCsWA68moMsCrJ9SDeJIDhJwOPjphV7RUegJL3tVQ+yDAkRBOcIBzIljXcVZPEg24UUyILgJF5PslAK5LhSIHspB7kxqniQw/KGJQhOkQ8pFqq4IAqytZjO5lZnGOu63tj3vQQhjwiEM9tezEJWCuREKNO+0OqpJj1JsRAEN6AWjNEO73wIVxEF2T7Sr66maVcBywGdlFEwu9QA11hwXEHIXVSLhccV5EQo8/m7xVMWC6VJLyRvWILgFPnQpGfKQZYx05aSPpvruv4EMNXBtQhC/qFaLDzuQdYKFQXZQ29eaopFaVgUZEFwCpOC7KFzjIr6e8mgEGsRD7IgOEnA4ykWSoHsC2cK5BYPeZCbJMVCEFyB6kGOenRQSIupQJbzjZVIgSwIThL0eIqFEvPmj5Slt71lsRAPsiC4gXywWKgDUERBtpauTXpXWvhcdbquv2rh8QUh9wjkT4qFP1Ke3vZWk55M0hMENxAOeN9i0SJNerahNumdD3zNwueqAT5t4fEFIfcweZC9bbEIFWcKZG/FvImCLAhuwKwge+ccoyIxb/ahNultBq52cC2CkH/kUYpFIDIMTdPRdWjvTNAZT1Dgz32XlynFQhRkQXCM/MhBVhRkSbGwlNx/dxKEXMbzCnLGg6yFy0xfCbZ6pIlGJukJgjsIFWRKmvbOBPGE7uBqrEG1p4UD8oHcSqRAFgQnySMFmcJh5q9APeBDTug6TYpdpFgUZEFwDJ9PM/uQPfIhXKVVGYAiCrK1SIEsCE6SRznIFA6jWBmk4QUfsmI/pjhUgN9nxYwlQRD6i9d9yKqwICkW1iIFsiA4SR7lIBMqNU1+8sKbV7Qz8xWu+I8FwXm8PiykVXKQbUMKZEFwEi/nIMc7M75qzQfBYtMJvcUDFovWjkyBLP5jQXAeVVX1osWiRXKQbUMKZEFwEi/nICtDQgiVgs9Hkce+/lQtFqIgC4LzhD2cZKHrepdR03LOsRIpkAXBSbycYtHWkNkuNMZMF3nMg9wqFgtBcBURDw8LicUTdCaTOQJ+jWCBlHBWIq+uIDiJl1MsTA16pYB58pMX1B1VQS4Ni8VCEJzGy+Om1YJfTesQrEEKZEFwEi+nWCgZyBSWAZia9Fq8oCB3iIIsCG4i7DEbl4ppzHRIzjdWIwWyIDhJoEuBnEg4t5Zs0yXiDbynIJstFqIgC4LTRDycYhGVMdO2IgWyIDiJzw8FhZnrnVHn1pJteiqQQ2qKRe6rOyaLhRTIguA4qvXACx/CVdTknyJp0LMcVxfImqaVaZq2VNO0tZqmbUpuVw3xmJWapi3XNG1tttYpCEPCpCJ7tEAOJT3IqsXCA19/isVCENyFmmLhtZg3teAXBdl6XFsgJwvhXUANsAC4E6gENmmaNncIh14OLBr6CgUhS6hZyF4aFqLGvCUVZDWWyAujpmVQiCC4Cy9P0lN/nyIpkC3HzWf0J4AVuq6vSF6vBhZomlYDrNU0rVzX9YbeH94dTdPmA7OyvE5BGBpdfcheoUcPsscUZLFYCIKrMHuQPdTTgblJTzKQrceVCrKmaXcBZRhqb1fWJH/eNIhDfx1YktweUHEtCJYR9OiwkD49yLmvIJsm6YXlDUsQnMY0aroj9z+Eq0Rlip6tuLJABhYCDbqu1/ZwW8o7vGAgB9Q0bSlGwV03xLUJQnZRs5C9NCykpxxkj3mQo5JiIQiuwss5yKqoIAWy9bi1QK4CeiqOATYmf/bbKqFpWiUwV7FrCIJ78KyCnA8e5My2eJAFwXnCAW9FSaqoTYcRyUG2HNcVyMliFnpRehXfcdkADrsco8lPENxHwKPjpvvIQfaCgqzmIIsHWRCcx8s5yGo0ZkQm6VmOGz+CVPZ9l/6TTLyo1XW9eoCPW0Qy7WL06NGsX78+m8vqk+bmZtufU7CW3v6mp9c1Mja5vW3rZg4dG27ruqzioobDpBKeX3p1G23b62mMZQrKhuZoTv8b70zopN5/fRq88sKzaJrm7KKErCDn39xlR32mKD50rC79d/TC33THrvb09oG977B+/X4HV+MOrPy7urFAzjZLgasG+qCkHWMFwKxZs/Q5c+ZkeVknZ/369dj9nIK19Po3bfk7HHoSgDMqx3PGhT3cJxd5KXMyv+jd8yBSQVtHHJ78JwAx3ZfT/8brWmLwuNESUVIY4IorrnB4RUK2kPNv7jJi/wl4+TkACgqLmDPnXYA3/qb/OPYa7N4HwLnTT2fO7AkOr8h5rPy7us5ikU2SaRjLBxoHJwi2YvIge8RikUiYPcjJQSGhAh++pMga60zQEc/dGKamto70tiRYCII7MFksZFCIMATcWCCnmvMq+rjfSYteTdPKgIXSmCe4HlOKhUea9GJNQNJOESwBv1FAappminrL5SaaRqVDryQk/mNBcAOmRuAcPr/0hPr7yKhp63FjgZxqzuurCa+3lIsUK4EqTdN09QKsTt4+X9k/pPHVgjAkAuHMtldSLHpo0EthatRrz91GPVVBlgQLQXAHYQ836bVKDrKtuO6srut6Q7LRpcdmPSXlYl0fh9pAz0V0FTA3edsajEJcLBiCcwQ9mGJhingrNd0UCXljFGxjm6IgS4KFILiCrhYLXdc90zyrKsgS82Y9bn2F1wFzNU2r6iF9Ym7y56qTHUDX9WU97U+Om54LVOu6vqSn+wiCragWi7xTkHNX4WkUD7IguI6A30fAr9ER14kndGLxBKECb6itpgJZFGTLcaPFAjIjphf3cNsCjOLWVDhrmrY02ZQnCLmFSUHOgwJZnaaX0xaLzNolA1kQ3EM44E2bRWu7WCzsxJUFsq7razAi1hYlFV8gnUoxiy5jppNZx3cBS/vhJ74g+VN8x4I7MCnIXrFY9FNBzuE3L/EgC4I78WqjXotJQZZzjtW49hXWdX2xpmmbgMWapq3EaN6rBib3ENu2MXkbPQ0ESfqWl2P4mlMe5kpN02owvMiLdV3vq+lPEKzBiwpye/eItxQRU4qFKMiCIGQXVV31UoEcFYuFrbi2QAbzsI4+7tcAzDzJ7bXAvCwuTRCyhzpqOi88yKrFInffvBqjoiALghvxYpJFRzxBLJkb79OMTHnBWuQVFgSnCao5yHlgsQh5JeZNUiwEwY2oHuRc/pZKpWsGsleSOdyMyB4Woes6TU1NNDY20traSjw+sE+xw4YN46233rJodYLf7ycSiVBaWkpJSYmzJxtPKsiKC+pkCnIOv3k1tUuKhSC4EVVBbvXIND210JcpevYgZ3UL0HWdI0eO0NLSQkVFBWPGjMHv9w+oCGtqaqKkpMTCVeYvuq4Tj8dpbm7m2LFjRKNRRo0a5VyR7EUP8klzkL3RQGOapCcKsiC4hogHLRYmBVkykG1BXmULaGpqoqWlhYkTJ+L3yyc9t6FpGgUFBZSVlVFSUsLu3btpamqitLS07wdbQdcUC12HXP/6rN8e5BxWkCXFQhBciRdTLFqVfg3VQiJYh3iQLaCxsZGKigopjnMAv99PRUUFjY2Nfd/ZKgqC4Eue0PU4xGPOrSVb5J0HWQpkQXAL4S7T9LyAarFQs+QF65AC2QJaW1spLi52ehlCPykuLqa11WFrg9eykE0FcpnppogHcpBbY53mSXpisRAE1xAxDQrJ3Q/hKq2SgWw7UiBbQDweF/U4h/D7/QNuosw6XvMhnyQHWVU/crHDXNd1vrp6Cx1xHYDRpSEK5StPQXANXsxBljHT9iMFskVIBEvu4Iq/lZeSLHS9i4LcpUlPVZBzMAf55+treHTrwfT1r1x9uoOrEQShK2HlHOOVJj018UcUZHuQAlkQ3IBJQc5xi0VHKySSJ/OCMBSETDcX57AH+clth/n+49vT16+aUMCCWeMdXJEgCF3xooIsU/TsRz6GCIIbMHmQc1xBPol6DLn75lVztJkvPPQquuGs4KLKCm6Z2ubsogRB6EY4R88xJ8OkIEuTni2Igiy4noaGBpYsWcKKFX1OHc9dvORBNmUgD+t2synFIkc8yI1tHdx530aakor3qWVhfnZrFQU+F9hzBEEwocagRTty4xzTF2rMWyQg2qYdSIEsuJ4lS5awbNkyKisrnV6KdQS8VCD3HvEGXRTkHPAgJxI6//6HV6k9alhfCgM+ln9kJsOLQ308UhAEJ8jVb6lOhnlQiCjIdiAFsuB6Nm7cCMDcuXMdXomFBL1qseheIIcKfGnlNRZPEOtM2LWyQfHDdW/zxLYj6etLb5zB2ad2/70EQXAHXrRYyKhp+5ECWXA9tbW1VFVVOb0Mawl4qElPLZBD3T3ImqZ1UXjc+xXoY1sP8pMnd6avL353Jdedd6qDKxIEoS8iHkyxMCnIkmJhC1IgC66ltraWJUuW0NDQQHV1NZqmMXPmTJYtW+b00rKPlxTk9pMryNDVh+zON7Bthxr58urX0tffNW0kd11zhoMrEgShP0Q8PklPFGR7kAJZcB0NDQ3MmzeP5cuXc8EFFwCwdOlSampqqKysZMmSJcybN8/hVWaZPPIgg7lAbnVh1Ft9S4w779uYVm0mDY/wk5vPxy9NeYLgekxNei79AD5QREG2HymQBVdRXV1NeXk5CxYsYOnSpdTV1QFQVVVFZWUlq1evZu7cuaxbt45169Y5vNosoqZY5Pqo6f4UyIoC0uyyArkznuDzD21mb10UMNa64vZZDIvIOGlByAVyxcI1ENRv2kRBtgcpkAXXUFtby1VXXcX8+fNZtGgRADU1NQDMmjUrfb8FCxYARjHtGdQcZE8pyN09yGD2CLqtiea7j23juZ3H0td/uPA8po0ucXBFgiAMBDefXwZLVCn0JcXCHqRAFlzD4sWLaWhoYOXKlel91dXVlJWVUVZWlt5XUVEBYNqXuu+CBQtyMy856KFR06Yc5LIe76Ke4N00Te+R6n386rld6etfnHsaV581xsEVCYIwUAoDPrSkG6q9M0E8oTu7oCzQ0i4WC7uRAllwBbW1taxbt465c+eaCt/a2tpu+ce1tbVARlVes2YNM2fOZObMmaxZs8a+RWcTr6ZY9MeD7BKFZ8u+Br72yNb09aunj+bfrjzNwRUJgjAYNE3rMizEHeeYoaD+DmKxsAcpkAVXkPITp+wTKWpra032CoBVq1ZRWVmZjn5btWoVixcvpr6+3p7FWoGXUiz6USCrX4G6wYO861gLH//NhnQm82mjivnBwvPwSVOeIOQkaoHsBR+y+k2bKMj2IK+yQ0z62qNOLyFrvPPd9w35GCmvsaoWp5TimTNnmvZVV1ezfPny9L7Vq1cDRvpFzuLVFIsecpDB3KTn9JvX4cY2PnLvyxxviQEwLBxg5e2zKA7J6VEQcpVwc2BOZwAAIABJREFU0A/JL+NyPckintBpT3541zTDQiJYj7zKgmtJNeGpRfOCBQuoqqpKN/F5hoCHUizaVQ9yLwqymoPs4LjpE60d3H7vK+yrNxIrCgM+fv2xWUwaUdTHIwVBcDNeGjetigiRgB9Nk2+27EAKZMEVpPKO165dm97X1WucGhryxBNP2L9Aqwl6VEHupUAudkGTXjQW547fbWD74SYACnwav7htJjMnVjiyHkEQskfYQ0kWraaIN/lmyy7klXaIvmwJTU1NlJTkT7TU/PnzqaysZNmyZQwfPpxFixaxYcMGysrKqK2t5e677wYyVgzPEfBIikVnO3S2Gdu+AATCPd5N9SA7MUmvI57gsw9Ws3F3xrf+vQUzuOKMUbavRRCE7BNRPMhtOd6kZxoSIhFvtiEFsuAaNm3axN13383y5ctZsmQJYES5rVq1iqVLl3ZLs/AUapNeLqdYmCLeSqGXrwLVk7zdHuREQmfJH7fw5LYj6X3/+f7p3HD+OFvXIQiCdXS1WOTymB/1Wza1+VCwFrFYCK6hrKwsPVJa143cyptuusn7xTF4R0Huh70CuijINnqQdV3nf//xFo9U70/v+8ycKdxx2WTb1iAIgvWEXdQIPFTUiLciaR62DSmQBVeSatBTEyw8TSAMJNXWeDskcvQrwX4WyMWmJj373rx++XStaRDIzReM56vXnG7b8wuCYA+qgpzrKRbqOTIiGci2IQWy4Eo2btwI4H3lOIWmeSPJok2J2jupgmy/urNqwx6W/nNb+vo1Z43m29efLR3hguBBvDRuWi3wpUC2DymQBVeyadMmgG5DQk5GXV0dkMONfF5IslAj3nrJQAbz14R2NOn9641DfF2ZkndRZQU/uvl8CvxyChQEL6JaLHJ9kl6LqUAWi4VdyCstuJLUZD117HRv1NbWsnTp0rTqvGLFChoaGliwYAFz5861dJ1ZxRMKcn89yIqCbLHF4qXa43z+oc0kDFs7Z51SysrbZ1EozS6C4Fm6TdILObiYIRKNicXCCaRAFlxJbW1tepR0X1RWVpom6+UspiSLHFWQB+FBtnLU9Ov7T3Dn7zamR0hPGh7htx+fTUlhLve0C4LQF90GheRwgdwSkyY9J5BXWnAlNTU1+eM/TuGFJAtTgdy7+t/VH6jreta9wDVHm/nYbzbQlCzAR5aE+P0dFzKyJIffKQVB6BdhDzXpmQaFyDdftiEGPMGV5F1xDF08yLlqseiSg9wLwQIfAb9REHcmdGLxRFaXsf1QEwuXv8Sx5nYASgoLuO8TsxlfEenjkYIgeAFPjZpWvmWTQSH2IQWyILiFgGKxyFUFOVqX2T6JxQK6qMhZzEJ+ff8Jbl7xYro4Dgf8/PpjF3Dm2N4LdkEQvEU4kDm/5HqTXmuHjJp2AimQBcEt5HqKxTvPwZt/zVwvHn3Su1vhQ67eU88tK1+ivrUj/Ry/v2M2F0yqyMrxBUHIDbyUg2xSkKVJzzbko4gguIVcTrE4XgOrPgwJozBl1Fkw6fKTPiTbX4G+XHucT/x2Q7qhZVg4wH2fmM254/tOQhEEwVs4kbVuFS2Sg+wIUiALglvI1RSL1jp48CaI1hvXi0bBravAf/LTS8SUhTy0N7Dndhzjk/dtoK3D8DJXFAW5/44LmX6K2CoEIR8Je8iDHJUcZEeQV1oQ3EIuplh0xuDh2+H4TuN6QSHc8gcoG9/nQ4tDahby4N/AnnjrMJ9+oDod5TaqJMQDn7yQ00aXDPqYgiDkNmohaXiQc3diZovkIDuCFMiC4BZyzYOs6/Dol+CdZzP7bvgljJvZr4erb2CD9SD/8/WDfP6hzXTEjSkgpwwr5IE7L2LyiKI+HikIgpfpbuHK3XJHFGRnkFdaENxCIMcsFi/8BDb/PnP9yv8HZ93Q74cXDdEj+JdX9/Olh18jnhyRN6EiwgOfvFCi3ARBME3KjOZ4gSwKsjPk7r8YQfAawRxq0nvr77D2G5nr594Cl39lQIcwe5AHZrF4eMNeljyyBT05PrpyRBEP3nkRY4YVDug4giB4k65NeroedHA1Q8OkIEsOsm1IzJsguIVcUZAPvAqP3Akkq9MJl8AHfgQDnISnxry1DsBi8fsX3+GuP2aK49NHl7Bq8cVSHAuCkCbgzwwjSujQkd1ZRLbS0i4WCyeQV1oQ3EIwB5r0Gg/AQzdnCvjyybDwfigY+PhmVeFp6WeBvPKZWr7zj7fS1886pZTf33EhFUW5qw4JgmAN4YCfjrhxbsnVIItEQjcNOpFR0/YhBbIguIWAy0dNx1rgwYXQdNC4XjgMbn0YioYP6nBFwf5bLDriCb75tze4/6U96X3nTyjjtx+fzbBwYFDPLwiCt4kEC2hsMwrk9mQjb67RtTj2+3I3jSPXkAJZENxC0MWjphMJeGQRHNpiXPcVwE33wchpgz6k6qU7WZNeQ2uMzz5YzfM7j6f3zZ5cwa8/doHJpiEIgqCifkuVxWn2ttIqQ0IcQ95dBMEtBFwc87buv2Db3zPX3/d/UDlnSIdUi9uWXt69dh5p5pO/28A7xzOvxwfOPYXvzZ9h6lIXBEHoijosJJajCrIqHkiDnr1IgSwIbsGtKRabfgcv/Dhz/eLPwcyPDfmwarNJTx7kp98+yucerKapLXPbl+dN43NXTkUbYEOgIAj5h+cU5ICUbHYiKRaC62loaGDJkiWsWLHC6aVYixtTLGqeMoaBpDj9Wpj3P1k5tJqDrOZ86rrOr5/bxcd/80q6OA4H/Pzitio+f9VpUhwLgtAvwsqH8Fz1IIuC7BzycURwPanieO3atU4vxVrclmJxcAus+ggkkifoMefAh1aCLzsnaTUHOaWSxDoT/NdfX+ehV/ambxs7rJCVt8/i7FOHZeV5BUHIDyIBjynI4kG2FSmQBdezceNGAObOnevwSiymqwdZ1wecLZw16nfDA/Mh1mRcLz0VblkFoeKsPUWxooY0t3dS3xLjU/dv4uVdden9540vY8XtMxlVIhnHgiAMjLDJYpGbCrJkIDuHvNqC66mtraWqqsrpZViPzw/+EMTbAR06omZV2S5a64ziuPmwcT00DD78Rxh2alafRj3ZH21q57qfPc+euoxyfv15p/DdG6UZTxCEwRH2hAdZxkw7hXiQBddSW1vLkiVLaGhooLq6Gk3TmDlzJsuWLXN6adYRdDjJoiMKD90Cx942rvuDcMuDMOrMrD+VmoPc1NaZLo41De56z+n8cOF5UhwLgjBozBaL3FSQzRYL0TTtRApkwXU0NDQwb948li9fzgUXXADA0qVLqampobKykiVLljBv3jyHV2kRaqOe3UkWiTj88ZOw96XMvhuWw6TLLHm6nhpOIkE/yz88k8/MkaQKQRCGRsQU8+bgQoaAKMjOIQWy4Cqqq6spLy9nwYIFLF26lLo6w49aVVVFZWUlq1evZu7cuaxbt45169Y5vFoLcEpB1nV4bIk56/iau+HsD1n2lAG/z3TCP7UszJpPXcLVZ42x7DkFQcgfzCkWDi5kCKgKcpEUyLYiBbLgGmpra7nqqquYP38+ixYtAqCmpgaAWbNmpe+3YMECwCimPUfAoSSL5++BDSsz1y/+HFz8Gcuf9iMXTQTg0qnD+fNnL2X6KaWWP6cgCPlBxANNemqBHBaLha3Iqy24hsWLF9PQ0MDKlZlCrbq6mrKyMsrKytL7KioqAEz7Ghoa2LhxIw0NDWm1OSdRx0132GSxeG0VrPvvzPWzPgTzvmXLU3/92jP53JVTKSkM2PJ8giDkD6Ymvd6n2bsa1WJRJDnItiIFsuAKamtrWbduHXPnzjUVvrW1td2K3draWiCjKi9btowlS5aY7jN//nxWr15t8aotwG4FueZJ+IuiFE+6HG74Jfjs+3JJimNBEKzAEwqy4g0JS9OyrUiB7BT/ffKhByU2LSMr/PeJIR8i5SdO2SdS1NbWpu0WKVatWkVlZSVVVVXpKXtr165l7ty51NbWsnjxYtasWcOyZcu46667hrw2WzF5kC1WkA9ugVW3ZwaBjJoOC++HgpC1zysIgmAD3mjSUzzIISnZ7EQ8yIIrSHmNVbU4pRTPnDnTtK+6ujqtGNfW1rJ06dL0EJFUIx+Qm5P3TCkWFirIPQ0CuW0NhMtO/jhBEIQcodADMW8tkmLhGFIgC64l1YSnFs0LFiygqqoqrSpXVlZ2U5jLyspy2INsQ4pFT4NAbluT9UEggiAIThLxQIpFVHKQHUNebafow5bQ1NRESUlOGS2GRCrvOGWVgO5e49TQkE2bNqUfp/qVVVJWi5zD5EG2wGLR1ggP3WweBHLzAzB6evafSxAEwUG84EFuMRXIoiDbiRTIgiuYP38+lZWVLFu2jOHDh7No0SI2bNhAWVkZtbW13H333UDGinEyli1bRmVlZe75j6FLikWWFeSW43D/h+Dgq5l9N/wSJl+e3ecRBEFwAeFA7o+ajorFwjGkQBZcw6ZNm7j77rtZvnx52mNcVlbGqlWrWLp0ab9sE7W1tSxfvvz/b+/+YuM60zqO/x47SRMn9o7d1GnpnzT2AumyrLZ2uqLAokqxBSsBKqydsKCy4iI2aG9RTJCQ2KuVc4GEEIhxgAq4KKkj2psVK9mBaPemS2Ov6EW7RXiidNtumj/2NHH+x3m5eN/jOZmO7bF9ZuacyfcjHY3nnJkzb/N2Zp55z/M+bzbzj6XaVbG4+rH0Ly9Ll98v7fuNcemLX0/uNQAgRR6cpJf9EWQm6dUXOchIjVwut7yktHP+w+zQoUNVB8fFYlHDw8OanJxskhzkhFIs5gvSP/16LDg26bf+WvqlP07m/ACQQs2Qg3wjVsB5ByPIdcXPEaRSNEEvXsFiLcPDwzpx4oT6+vpq1azaS7qKxSfvSv/6cmlCXssW6XcnGDkG0PS2b22RmeScdPe+tHTfqbXFGt2sqjnndONuLAeZOsh1xQgyUuns2bOSVPVI8ODgoMbGxrIdHEvJVrH4cEZ69Wul4HjLdun3XiM4BvBQMLMH8pBv3s3WMPKtu/cVLqZq25YWbWklZKsnRpCRSlGliqiCxWoGBwcl+VHnaOT5ypUryykXUVWMTHhgBHkTKRbnvi+99g3pzqK/v61d+v2T0rO/srn2AUCGtG1rXV5s48ade9qVoTzeB5aZJr2i7rLzfwoeKtHKeiuVcYuMjo4uPza6jevt7c1WgPzACPLNjZ3j/f+QXv+mtHTb39/RJb3y79LPPL/59gFAhsTzdm9mbDm9G9RAbij+xZFKhUKhqnSJfD6vfD5fhxbVydZNTtJ7Z1J6Y1Ry4YO1/QnplTel7v3JtA8AMiSeYnEj0wEyI8j1RoCMVJqbm8tuJYrN2LaJSXpv/4P03T+VFJLWOvdJf/im1PlsUq0DgEzZERt5zVqAzDLTjUWAjFR6KINjqWwEeR0B8g/+Sjr97dL97i9Ir7whtT+eXNsAIGPilR+ylGJx+96SLnx6a/k+KRb1x784kCbb1rlQyL070tRfSD/8+9K+J/ulPzgltXUl3z4AyJD4yGt80lsj3LhzT+cuX9dP5m9q4cYdzV/328L1O5q/Eb+9q8XbD7Z15yOMINcbATKQJvEqFmvlIBc/kCb/SProbGnfs1+VvvGa9Eh7bdoHABnywCS9OpR5u7t0Xx8u3NS5y4sqXLquc5f9Vrh0XReu3lr7BCt4qrNt7QchUakOkM0sJ+mYpD5JXZKmJZ10zs2u8xwjkl6Q1COpIGnKOTeRfIuBTdqyzS/mcf+e3+7d8fvK/fi70pt/It36tLRv/29KX/9Haev2+rUXAFKsrYZVLC58eksz5xf0Px8WNXdxUecuX9cH8zd07/7ml7VubTF1tm1VZ9s2/fzj7Rr5tYc07bCBUhsgm1mfpNOSxiR9Rz64PSZpxswGnXOfren12XMMSJqUFK8V1idpyMzGJPU754qJNx7YjK07pdsh8L17/cEA+d4dafovpbf+trSvZYs08G3pxW9Jlp1VogCg1toSmqR3d+m+3vvpVc2cX9DM+QXNnl/Qx5+ub0R4S4vpmUfb9OyjO/XYrkeU27lVXW3b1LlzW+k2/N2+fYtaMrTqXzNKbYAsHxxPxEZ6ZyUNm9mcpCkz66wiuB2XHzE+4pybNbMeSUNhf4988DxYm+YDG7StrRQg37kh7ej0f1dKqeh4Shp+VXr6K/VvJwCk3EZTLOav39Hs+QXNfOAD4nc+LOrW3ftVPfeJz23Xvt07l7fex3Zp3+6deqpzB6vhZUgqA2QzOyo/6lupwO0pSUclHZK0VppETtKgc64gSeH2uPlRtnFJGVpBAg+NSpUsKqVU/NzXpJf/jsl4ALCCtq3VTdK7t3Rfsx8UNf3eJ/rPH1/U/11cXPPcO7a26stP59S3N6cvPPE57du9U8/ubqPiRJNIay8ellSMAtsyU/IB8rDWDpArnsM5d9zMxiWfyrGenGag5uKVLG59Kn3vz0mpAIAN2LFt5YVCFm/f0/f/95Km3/1E//X+RS3cuLvquZ7q3KH+vZ3qe6ZT/Xs7tf/xdkaEm1haA+Q++ZSKSqLryweqOM/BVY4V5UeYa5KD7JyTEbxkgnObn1CRqHgli5OvSNc+Lt0npQIAqla+1PRHxZs6/d4nmn7vot6au6I7S5XTJra1tuiLT3YsB8R9ezu1p4MJ0A+T1AXIIU9YkuYrHXfOFUPgmat0vPyxqxzOaeVR6k1pbW3V0tKStmxJ3T8vKlhaWlJra4pqTG7dUfo7HhyTUgEA6xKvYvHGjz7Sv739kxUfu6fjER18bo8GnuvWL/fu1vatKfpeQN2lMYKreS0TMxsJf46t8ZgRSdqzZ4/OnDlT9fnb2tp06dIl7dq1a8NtXFpa0rVr1zb8fFRvcXFRxWJxXX280dep5jV+4eoNPRa7f99aVej5pj584rel/36nZu3D+lXbp8gW+rV5FD4p5R3fvvfZ0eJn2lv0fHervtzdqr0dLWqxK9KFK3rrQj1biY2q5Xs1jQFyPYxJml2tFnI4NiFJBw4ccC+99FLVJ7969aouX76s7u7uDY9MXrt2Te3tLPZQa0tLS7p06ZL279+vjo6Omr7WmTNnVNX/Rze/J13+of+74ym1DL+qzz/9FX2+pq3DRlTdp8gU+rV5PH7hqv7mRz9Yvr+11fRi724NPNetg8/t0ZO5Has8G2lXy/fqQxcgR5PztHp+8qa0t7fr5s2bOn/+vLq6urRr1y61traSk5wSzjktLS1pcXFR8/Pz2rlzZ7p+jLz4LenaT6Vde6SX/oyUCgDYoP2Pd+j40Jc09fa7+p1f/ZK++rO71b59a6ObhQxIY4Ac5QSvFRWse3KdmQ3Jp03UdIEQM1N3d7euXbumq1ev6uLFi1paWl+B8lu3bmn7diYE1Epra6va2tq0e/dutbe3p+vHS+5p6dA/N7oVANAUDh14Wt2Lc3rpF59odFOQIWkMkKPJeWtNwlvX5LqwMt8JSQdrMTGvwuupo6Njw5ftz5w5o+effz7hVgEAAGAtqSvgFxvZrThZL1blYs2lpsuec1rSMDWPAQAAsJrUBcjBtLQ86lsuWv3uZDUnMrOc/OIiR5xzVQfVAAAAeDilNUCOlpgerXBsWL4CxQMjwWY2Hpaoju/LSZqRNO6cO1V+LGw1LysHAACA7EhlgByC2QlJI2FinSQpBMAH5INkxfYPyC8/PV426nxaPlUjb2YuvklaCNtcCKQBAACAVE7SkyQ550bNbEbSqJmdkJ+8NytpX4UKFGfDMUUjy6GcW6UUDQAAAGBFqQ2QpQcX61jjcUVJ/WX7xrTKSnkAAABAJalMsQAAAAAahQAZAAAAiCFABgAAAGIIkAEAAIAYc841ug2pZ2aXJJ2v88vulnS5zq+J2qJPmw992pzo1+ZDnzanJPp1r3PusfKdBMgpZWZnnXMHGt0OJIc+bT70aXOiX5sPfdqcatmvpFgAAAAAMQTIAAAAQAwBcnqtuUAKMoc+bT70aXOiX5sPfdqcatav5CADAAAAMYwgAwAAADEEyECNmdmQmc2ZWU+j2wIAANa2pdENQImZ5SQdk9QnqUvStKSTzrnZhjYM6xb6ckTSqCQC4yYS69sX5Pu2IGnKOUeOY0aFPh2XNKBSn85KGnPOFRrZNiQjDFCMSepxzg02uj1Yv/A+nQx3i2WHc+F23Dk3ncjrkYOcDmbWJ+m0/Bv4dfkP6WOShiQNJtXhqD0zG5GUl38DT8gHUzlJvXzZZpuZDch/QOcqHC5I6nfOlX9wI8VC4DQj36fT8u/bAZX6mPdtEzCzKfl+nSZAzqYQIC+s8bBh59ypJF6PEeT0OC1pIjYKNStp2MzmJE2ZWSdfvJkxL2k06kszG1LlgArZMy4fCB9xzs2G4Goo7O+RD5758s2WIfk+PRh9xoYv4hn5Ps2LPs208BnMIiHNo1/+Krv02e/WxK64EyCngJkdle/kfIXDpyQdlXRIlKnJhKR+vSKVcvJXdAqSFG6Pm5lUukSPbBmUH3VaHoBwzhXNbFTSlAismsEx+auz0ZU9ZFi90k6ZpJcOhyUVV7iMNxVuh+vYHgCVVXyfOueOR3+HdClkx+wKn71nwy3pFRlmZuPygfF8o9uCRNTtBw4Bcjr0aeUP4ehDmlEMoPEOrnKsWHaLDHDOja1wKJpcW+nKHjIgpEANMIG2qdTthw4BcoPFSn9V7PTYZT9yWIEGW2MeQE4rXwlC9hyTn9BFcJVdeUlHGt0IJKZL8nGTmU2G8qnOzGbC5PhEESA3HiXAgIyLfTivNBqJjAhfvnlJOaodZFeoOFOgTGrT6ZE0p1I5xqL8Vfh8qFSSGAJkANi8MflcVkYbMyos6OPk532MSBoII1RDDW4aNmZc/GBtNjn5KhW9zrl+59ygc65TUjQHZCDJkWQCZADYhDAJSFo9PxnpN+ucM+dcr3POVFrkZ5IgOVtCZag8pVGbi3NuNgTGhbL9Y/I1zKUECxoQIDde1NFdqz6KiT9A6oTAaUS+9Bvv0Qyr8KU7oVJpzWP1bxE2ItSwPszVnIdONFCRWNoqAXLjRZPz1pqEx8QfIEVCObcT8gtM8P5sTlFOI3NFsuOEpL4weWt5U2mJ4qHYfkoyNo/oMzixgQoWCmmwUJBeWuEDOFblgqWmgZQI78vT8gtMMAkoo8wst8bIf3SMH0DZ8bYq91ef/EI+BfkFuHLiymwziQYZE4uVCJDTYVo+ubyvwpdttDLXyTq3CUAF4RLulPxy0/xwzbYRM5tdpR+jEcbv1KtB2Jz4oj1xIR1qQD7XnMl7GRMt+LLK1bporYjE3qukWKRDVIh+tMKxYfk3NKNU2dVTdouMCsHxjKTx8iXFzSwXNvo5O6a1+kIgxyRNsHw80HAntcJ7NXwuj6tsyfjNIkBOgfDhOyE/mrE8WzrMxD0glpnOHDMbD8XLF2K7p8K+yRWfiLQ7Lf9DJ18hx3EhbHPhAxspFwYeekI5t4Go38LfM/LBcaWBC2TPC+GWvOMMir1XJ6P3aqhZPqJSuluiP2TNOZfk+bAJoaOH5YPiefl6f0eYHQ80XrjEd7TKh3fyvs2Gss/dnHyO6rT8VQJyjzMsXM3Jy/+ojV/ZKYRtlD7OjjCAeEz+R05R0llJUyul1Wz69QiQAQAAgBJSLAAAAIAYAmQAAAAghgAZAAAAiCFABgAAAGIIkAEAAIAYAmQAAAAghgAZAAAAiCFABgAAAGK2NLoBAIDmVGnJ7fWuMJjEOQBgvRhBBoA6MLNxM3Mb2HJm1hee/5lgMa1CWxdi22lJJzZwqsnw3Pi5AKCmCJABoD6uSDolqVdSZ2yLRkOPl+3vl5ZHSyclHZV0rL5N3riyUd5B51y/c254A+cZdM71S4qey+gxgJojQAaA+ihKmnLOFZxzxWiTNB+Oz8X3O+dmJRXCsXz0/Aa0OwlnEzhH9G8xv+qjACABBMgAUB/zKgV51ZqVJOfccedcp3NuOvlm1VSSo72MHAOoGybpAUAdOOdObeA5605JAABsHgEyADQRM+uR1CepS9K0c64QO5aTNBDuzsaPrXCuEUmDknLyo9n5tZ6zzrbm5POqe8JWkE8jeZ1KFQAaiRQLAEixUMFixMymzOxohWNHzWzGzIZCQDsnP6kvL2ku7JOZDchXgJgM21z5+WLnHTCzBfnAeEzSqHzQvXy+JP67JJ2T9HYYKT8oHxznVQriAaAhCJABIKVCUHtM0rjKgsYQYEbH++SD2EGVqmQcDw/Nh0B4TFK/c87CYyVpPJyn/DWnJE2E3OdC2AZj50ui3Nyk/EjxKclXvXDOTcTaDQANQ4AMACnlnJsOo6uvVzg265w7LimauFd0zg3HqmSMqTQp8HAolxZN+puQLzknSYfLTp0Pjxmr0KToOYc2/l+1LEqrKHdSYXIiADQKATIApF81+bgnK+ybLruNi0rGLQepYTS5Z5XXiwLu/iras5aipAEzmwyj1pKWA//E8pwBYCOYpAcAzSsKdK9UOFapnnAULOdCDvK8HgyWo8l6cwm07Yh8msWQpCEzk3wAng8j4wDQMATIANC8KgXG1Sg65zoTbUkZ59wpM+uVz4ceUinlYtzMDofV8wCgIUixAABEotSGJCbhrSnkS48556KJhVHec1/55EEAqCcCZABAJF4zeaiWL2Rmk/H7YWLhcUkTYRd1kAE0DAEyADSvR8tuVxUW54gC1BOVRnHNLLfZMm/h+ZUqWEQKTNQD0EgEyADQWFGg2LvKY6KAtFKgGx3rWuXYagHtA8ecc6PyVS9ykmbMLB8WIRkys3FJM6ucq1pd8mkU4/GdYRGSQ/L1nAGgYQiQAaDOzKwnrH63ENsdrYg3HnvckJnNSBope8xAWEFvTqUFRPJhtb2eCs8biVbbq9CcgXBseVW9sCjImHzFihH5ahPHJF1xzvUmtAz0KfnqFc7M5kJ7eyXtY/QYQKOZc67RbQAANKHYctWdmw2qzaxHvrxcIUyAsqykAAAAoklEQVTqA4CaYQQZAFArSVbDqEtlDQCQCJABALVXKT+6EecAgKqQYgEAqAkzi75gpuXzmAvOuUrLXq92jiH54HhUUp8kOecsyXYCQDlW0gMA1MpxlVbzW6u020qi55wMGwDUHCPIAAAAQAw5yAAAAEAMATIAAAAQQ4AMAAAAxBAgAwAAADEEyAAAAEAMATIAAAAQQ4AMAAAAxBAgAwAAADH/D9QWJnlBYDppAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "\n", + "fig, axs = plt.subplots(2,1, figsize=(10,15), gridspec_kw={'height_ratios': [2,1]})\n", + "ax1 = axs[0]\n", + "ax2 = axs[1]\n", + "\n", + "# plotting environment\n", + "ax1.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "ax1.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "ax1.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "ax1.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "Z = np.load(\"models/phi1_margin=\"+str(margin)+'.npy')\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "u_norm = np.sqrt(np.sum(u**2, axis=1))\n", + "u_norm = np.concatenate([u_norm, [u_norm[-1]]], axis=-1)\n", + "alpha = u_norm/u_max.numpy()\n", + "\n", + "ax2.plot(ts, u_norm, label=\"$\\phi_1$\", linewidth=3)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* (alpha)\n", + "\n", + "# plotting optimization results\n", + "ax1.plot(xy[:,0], xy[:,1], c=\"black\", linewidth=linewidth)\n", + "ax1.scatter(xy[:,0], xy[:,1], c=\"black\", s=markersize)\n", + "ax1.scatter([-1,1], [-1,1], s=300, zorder=10, c=\"orange\")\n", + "ax1.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "ax1.plot(xs[:,0], xs[:,1], \"black\")\n", + "ax1.scatter(xs[:,0], xs[:,1], zorder=3, color=colors, s=markersize)\n", + "\n", + "Z = np.load(\"models/phi2_margin=\"+str(margin)+'.npy')\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "u_norm = np.sqrt(np.sum(u**2, axis=1))\n", + "u_norm = np.concatenate([u_norm, [u_norm[-1]]], axis=-1)\n", + "alpha = u_norm/u_max.numpy()\n", + "\n", + "ax2.plot(ts, u_norm, label=\"$\\phi_2$\", linewidth=3)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* (alpha)\n", + "\n", + "# plotting optimization results\n", + "ax1.plot(xy[:,0], xy[:,1], c=\"black\", linewidth=linewidth)\n", + "ax1.scatter(xy[:,0], xy[:,1], c=\"black\", s=markersize)\n", + "ax1.scatter([-1,1], [-1,1], s=300)\n", + "ax1.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "ax1.plot(xs[:,0], xs[:,1], \"black\")\n", + "ax1.scatter(xs[:,0], xs[:,1], zorder=3, color=colors, s=markersize)\n", + "\n", + "\n", + "ax1.grid()\n", + "ax2.grid()\n", + "\n", + "ax1.set_title(\"Trajectory (margin=%.2f)\"%margin, fontsize=fontsize)\n", + "\n", + "ax2.set_title(\"Control magnitude\", fontsize=fontsize)\n", + "ax2.legend(fontsize=fontsize)\n", + "ax2.set_ylabel(\"$\\|u\\|_2$\", fontsize=fontsize)\n", + "ax2.set_xlabel(\"Time [s]\", fontsize=fontsize)\n", + "\n", + "ax1.text(-0.95, -1.1, \"Start\", fontsize=24)\n", + "ax1.text(0.9, 1.07, \"Finish\", fontsize=24)\n", + "\n", + "ax1.text(0.55, 0.0, \"$\\phi_1$\", fontsize=36)\n", + "ax1.text(-0.45, 0.45, \"$\\phi_2$\", fontsize=36)\n", + "ax1.text(-0.97, 1.22, \"Speed\", fontsize=18)\n", + "ax1.text(-1.15, 1.02, \"0\", fontsize=18)\n", + "ax1.text(-0.6, 1.02, \"$u_{max}$\", fontsize=18)\n", + "\n", + "ax1.text(-0.91, 0.1, \"B1\", fontsize=24)\n", + "ax1.text(0.37, -0.8, \"B2\", fontsize=24)\n", + "ax1.text(0.39, 0.96, \"B3\", fontsize=24)\n", + "ax1.text(-0.04, -0.04, \"C\", fontsize=24)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* np.arange(50)/49\n", + "ax1.scatter(np.arange(50)/49/2 - 1.1, 1.15*np.ones(50), color=colors, s=250, marker='s')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plotting results\n", + "\n", + "fig, axs = plt.subplots(2,1, figsize=(10,15), gridspec_kw={'height_ratios': [2,1]})\n", + "ax1 = axs[0]\n", + "ax2 = axs[1]\n", + "\n", + "# plotting environment\n", + "ax1.plot([obs_1[0], obs_1[0], obs_1[1], obs_1[1], obs_1[0]], [obs_1[2], obs_1[3], obs_1[3], obs_1[2], obs_1[2]], c=\"red\", linewidth=5)\n", + "ax1.plot([obs_2[0], obs_2[0], obs_2[1], obs_2[1], obs_2[0]], [obs_2[2], obs_2[3], obs_2[3], obs_2[2], obs_2[2]], c=\"green\", linewidth=5)\n", + "ax1.plot([obs_4[0], obs_4[0], obs_4[1], obs_4[1], obs_4[0]], [obs_4[2], obs_4[3], obs_4[3], obs_4[2], obs_4[2]], c=\"orange\", linewidth=5)\n", + "ax1.plot([obs_3[0] + obs_3[2].numpy()*np.cos(t) for t in np.arange(0,3*np.pi,0.1)], [obs_3[1] + obs_3[2].numpy()*np.sin(t) for t in np.arange(0,3*np.pi,0.1)], c=\"blue\", linewidth=5)\n", + "\n", + "Z = np.load(\"models/psi1_margin=\"+str(margin)+'.npy')\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "u_norm = np.sqrt(np.sum(u**2, axis=1))\n", + "u_norm = np.concatenate([u_norm, [u_norm[-1]]], axis=-1)\n", + "alpha = u_norm/u_max.numpy()\n", + "\n", + "ax2.plot(ts, u_norm, label=\"$\\psi_1$\", linewidth=3)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* (alpha)\n", + "\n", + "# plotting optimization results\n", + "ax1.plot(xy[:,0], xy[:,1], c=\"black\", linewidth=linewidth)\n", + "ax1.scatter(xy[:,0], xy[:,1], c=\"black\", s=markersize)\n", + "ax1.scatter([-1,1], [-1,1], s=300, zorder=10, c=\"orange\")\n", + "ax1.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "ax1.plot(xs[:,0], xs[:,1], \"black\")\n", + "ax1.scatter(xs[:,0], xs[:,1], zorder=3, color=colors, s=markersize)\n", + "\n", + "Z = np.load(\"models/psi2_margin=\"+str(margin)+'.npy')\n", + "xy = Z[:N[0]*N[1]].reshape(N[0],N[1])\n", + "u = Z[N[0]*N[1]:(N[0]*N[1] + (N[0]-1)*N[1]) ].reshape(N[0]-1,N[1])\n", + "u_norm = np.sqrt(np.sum(u**2, axis=1))\n", + "u_norm = np.concatenate([u_norm, [u_norm[-1]]], axis=-1)\n", + "alpha = u_norm/u_max.numpy()\n", + "\n", + "ax2.plot(ts, u_norm, label=\"$\\psi_2$\", linewidth=3)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* (alpha)\n", + "\n", + "# plotting optimization results\n", + "ax1.plot(xy[:,0], xy[:,1], c=\"black\", linewidth=linewidth)\n", + "ax1.scatter(xy[:,0], xy[:,1], c=\"black\", s=markersize)\n", + "ax1.scatter([-1,1], [-1,1], s=300)\n", + "ax1.axis(\"equal\")\n", + "\n", + "# plotting states from simulating controls\n", + "xs = [x0]\n", + "us = u\n", + "for i in range(49):\n", + " x_next = A @ xs[i] + B @ us[i]\n", + " xs.append(x_next)\n", + "xs = np.stack(xs)\n", + "ax1.plot(xs[:,0], xs[:,1], \"black\")\n", + "ax1.scatter(xs[:,0], xs[:,1], zorder=3, color=colors, s=markersize)\n", + "\n", + "\n", + "ax1.grid()\n", + "ax2.grid()\n", + "\n", + "ax1.set_title(\"Trajectory (margin=%.2f)\"%margin, fontsize=fontsize)\n", + "\n", + "ax2.set_title(\"Control magnitude\", fontsize=fontsize)\n", + "ax2.legend(fontsize=fontsize)\n", + "ax2.set_ylabel(\"$\\|u\\|_2$\", fontsize=fontsize)\n", + "ax2.set_xlabel(\"Time [s]\", fontsize=fontsize)\n", + "\n", + "ax1.text(-0.95, -1.1, \"Start\", fontsize=24)\n", + "ax1.text(0.9, 1.07, \"Finish\", fontsize=24)\n", + "\n", + "ax1.text(0.55, 0.0, \"$\\psi_1$\", fontsize=36)\n", + "ax1.text(-0.45, 0.45, \"$\\psi_2$\", fontsize=36)\n", + "ax1.text(-0.97, 1.22, \"Speed\", fontsize=18)\n", + "ax1.text(-1.15, 1.02, \"0\", fontsize=18)\n", + "ax1.text(-0.6, 1.02, \"$u_{max}$\", fontsize=18)\n", + "\n", + "ax1.text(-0.91, 0.1, \"B1\", fontsize=24)\n", + "ax1.text(0.37, -0.8, \"B2\", fontsize=24)\n", + "ax1.text(0.39, 0.96, \"B3\", fontsize=24)\n", + "ax1.text(-0.04, -0.04, \"C\", fontsize=24)\n", + "\n", + "colors = np.ones([50,4])\n", + "colors[:,:3] = np.array([250, 128, 114])/255\n", + "colors[:,1] = (127/255)* np.arange(50)/49\n", + "ax1.scatter(np.arange(50)/49/2 - 1.1, 1.15*np.ones(50), color=colors, s=250, marker='s')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/Neural networks.ipynb b/examples/Neural networks.ipynb new file mode 100644 index 0000000..868abd2 --- /dev/null +++ b/examples/Neural networks.ipynb @@ -0,0 +1,1185 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Neural network examples\n", + "This jupyter notebook was used to run the neural network examples, and used to produce the plots. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import sys\n", + "sys.path.append('../src')\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "import numpy as np\n", + "import os\n", + "import pickle\n", + "import torch\n", + "import pickle\n", + "import stlcg" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib \n", + "matplotlib.rc('xtick', labelsize=20) \n", + "matplotlib.rc('ytick', labelsize=20) " + ] + }, + { + "cell_type": "code", + "execution_count": 270, + "metadata": {}, + "outputs": [], + "source": [ + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"sans-serif\",\n", + " \"font.sans-serif\": [\"Helvetica\"]})\n", + "# for Palatino and other serif fonts use:\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Palatino\"],\n", + "})\n", + "\n", + "fontsize = 24" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bump example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### generating bump data" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(1)\n", + "x = np.arange(-2,2,0.1)\n", + "y = np.zeros(4*10)\n", + "y[:10] = -0.5\n", + "y[10:30] = 0.5\n", + "y[30:] = -0.5\n", + "y += np.random.randn(40)*0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,5))\n", + "plt.plot(x,y)\n", + "plt.scatter(x,y)\n", + "plt.grid()\n", + "plt.xlabel(\"Time steps\", fontsize=fontsize)\n", + "plt.ylabel(\"s\", fontsize=fontsize)\n", + "plt.title(\"Bump data\", fontsize=fontsize)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "# save bump data\n", + "np.save(\"models/bump\", np.stack([x,y]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## creating a (very simple) neural network" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "class Bump(torch.nn.Module):\n", + "\n", + " def __init__(self, n, m, hidden_dim):\n", + " super(Bump, self).__init__()\n", + " self.network = torch.nn.Sequential(torch.nn.Linear(n, hidden_dim),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(hidden_dim, hidden_dim),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(hidden_dim, m))\n", + " \n", + "\n", + " \n", + " def forward(self, x): \n", + " return self.network(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "#constructing neural network.\n", + "hidden_dim = 8\n", + "\n", + "# n=1 (time), m=1 y value\n", + "# vanilla model to train with STL\n", + "torch.manual_seed(0)\n", + "bump = Bump(1, 1, hidden_dim)\n", + "optimizer = torch.optim.Adam(bump.parameters(), lr=0.01, weight_decay=0.10)\n", + "\n", + "# model to train with STL\n", + "torch.manual_seed(0)\n", + "bump_stl = Bump(1, 1, hidden_dim)\n", + "optimizer_stl = torch.optim.Adam(bump_stl.parameters(), lr=0.01, weight_decay=0.10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### creating input data" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "xx = torch.as_tensor(x).float().unsqueeze(-1)\n", + "yy = torch.as_tensor(y).float().unsqueeze(-1)\n", + "a = torch.as_tensor(0.48).float()\n", + "b = torch.as_tensor(0.52).float()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### creating stl formula" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "◻ [10, 29]( (y_exp >= input) ∧ (y_exp <= input) )\n" + ] + } + ], + "source": [ + "y_exp = stlcg.Expression('y_exp', yy)\n", + "ϕ1 = y_exp > a\n", + "ϕ2 = y_exp < b\n", + "ϕ = stlcg.Always(subformula=ϕ1 & ϕ2, interval=[10,29]) \n", + "print(ϕ)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### training network without STL" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 loss = 11.056 mse = 11.056 robustness = -0.384\n", + "50 loss = 2.622 mse = 2.622 robustness = -0.439\n", + "100 loss = 2.206 mse = 2.206 robustness = -0.434\n", + "150 loss = 1.531 mse = 1.531 robustness = -0.396\n", + "200 loss = 1.148 mse = 1.148 robustness = -0.366\n", + "250 loss = 0.905 mse = 0.905 robustness = -0.329\n", + "300 loss = 0.841 mse = 0.841 robustness = -0.279\n", + "350 loss = 0.790 mse = 0.790 robustness = -0.261\n", + "400 loss = 0.761 mse = 0.761 robustness = -0.273\n", + "450 loss = 0.739 mse = 0.739 robustness = -0.233\n", + "500 loss = 0.742 mse = 0.742 robustness = -0.238\n", + "550 loss = 0.707 mse = 0.707 robustness = -0.223\n", + "600 loss = 0.692 mse = 0.692 robustness = -0.240\n", + "650 loss = 0.684 mse = 0.684 robustness = -0.245\n", + "700 loss = 0.678 mse = 0.678 robustness = -0.227\n", + "750 loss = 0.670 mse = 0.670 robustness = -0.226\n", + "800 loss = 0.665 mse = 0.665 robustness = -0.222\n", + "850 loss = 0.669 mse = 0.669 robustness = -0.211\n", + "900 loss = 0.659 mse = 0.659 robustness = -0.204\n", + "950 loss = 0.653 mse = 0.653 robustness = -0.217\n", + "1000 loss = 0.651 mse = 0.651 robustness = -0.218\n", + "1050 loss = 0.648 mse = 0.648 robustness = -0.197\n", + "1100 loss = 0.645 mse = 0.645 robustness = -0.214\n", + "1150 loss = 0.644 mse = 0.644 robustness = -0.212\n", + "1200 loss = 0.642 mse = 0.642 robustness = -0.196\n", + "1250 loss = 0.640 mse = 0.640 robustness = -0.212\n", + "1300 loss = 0.639 mse = 0.639 robustness = -0.208\n", + "1350 loss = 0.638 mse = 0.638 robustness = -0.196\n", + "1400 loss = 0.637 mse = 0.637 robustness = -0.211\n", + "1450 loss = 0.637 mse = 0.637 robustness = -0.208\n", + "1500 loss = 0.637 mse = 0.637 robustness = -0.196\n", + "1550 loss = 0.633 mse = 0.633 robustness = -0.205\n", + "1600 loss = 0.633 mse = 0.633 robustness = -0.208\n", + "1650 loss = 0.631 mse = 0.631 robustness = -0.205\n", + "1700 loss = 0.625 mse = 0.625 robustness = -0.208\n", + "1750 loss = 0.620 mse = 0.620 robustness = -0.201\n", + "1800 loss = 0.622 mse = 0.622 robustness = -0.204\n", + "1850 loss = 0.616 mse = 0.616 robustness = -0.205\n", + "1900 loss = 0.616 mse = 0.616 robustness = -0.199\n", + "1950 loss = 0.619 mse = 0.619 robustness = -0.204\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "##### hyperparameters #####\n", + "γ = 0.0 # weighting on robustness loss\n", + "###########################\n", + "\n", + "for _ in range(2000):\n", + " optimizer.zero_grad()\n", + " y_pred = bump(xx)\n", + " ϕ_input = y_pred.unsqueeze(0) #.unsqueeze(-1)\n", + " robustness = ϕ.robustness((ϕ_input, ϕ_input), scale=-1)\n", + " mse = (y_pred - yy).pow(2).sum()\n", + " loss = mse + γ*torch.relu(-robustness).squeeze()\n", + " loss.backward()\n", + "\n", + " optimizer.step()\n", + " if (_ % 50) == 0:\n", + " print(\"%i loss = %.3f mse = %.3f robustness = %.3f\"%(_, loss.detach().numpy(), mse.detach().numpy(), robustness.squeeze()))\n", + "plt.plot(x +2, bump(xx).squeeze().detach())\n", + "plt.plot(x + 2, yy.squeeze().detach())\n", + "plt.plot([0,4],[a.numpy()]*2, 'k--', linewidth=1)\n", + "plt.plot([0,4],[b.numpy()]*2, 'k--', linewidth=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "γ = 0.0 # weighting on robustness loss\n", + "PATH = \"models/bump_%.2f.model\"%γ\n", + "np.save(\"models/bump_data_%.2f.npy\"%γ, torch.cat([xx, bump(xx)], dim=-1).detach().numpy())\n", + "torch.save(bump.state_dict(), PATH)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### training network with STL" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 loss = 11.823 mse = 11.056 robustness = -0.384\n", + "50 loss = 3.456 mse = 2.694 robustness = -0.381\n", + "100 loss = 3.037 mse = 2.290 robustness = -0.373\n", + "150 loss = 2.427 mse = 1.740 robustness = -0.343\n", + "200 loss = 1.807 mse = 1.292 robustness = -0.258\n", + "250 loss = 1.374 mse = 1.044 robustness = -0.165\n", + "300 loss = 1.120 mse = 0.973 robustness = -0.073\n", + "350 loss = 0.837 mse = 0.742 robustness = -0.048\n", + "400 loss = 0.772 mse = 0.772 robustness = 0.000\n", + "450 loss = 0.705 mse = 0.642 robustness = -0.031\n", + "500 loss = 0.617 mse = 0.596 robustness = -0.011\n", + "550 loss = 0.667 mse = 0.607 robustness = -0.030\n", + "600 loss = 0.604 mse = 0.548 robustness = -0.028\n", + "650 loss = 0.547 mse = 0.547 robustness = 0.007\n", + "700 loss = 0.615 mse = 0.593 robustness = -0.011\n", + "750 loss = 0.540 mse = 0.526 robustness = -0.007\n", + "800 loss = 0.554 mse = 0.537 robustness = -0.009\n", + "850 loss = 0.538 mse = 0.532 robustness = -0.003\n", + "900 loss = 0.552 mse = 0.496 robustness = -0.028\n", + "950 loss = 0.525 mse = 0.523 robustness = -0.001\n", + "1000 loss = 0.539 mse = 0.539 robustness = 0.012\n", + "1050 loss = 0.508 mse = 0.508 robustness = 0.004\n", + "1100 loss = 0.585 mse = 0.530 robustness = -0.028\n", + "1150 loss = 0.536 mse = 0.511 robustness = -0.012\n", + "1200 loss = 0.524 mse = 0.524 robustness = 0.007\n", + "1250 loss = 0.517 mse = 0.485 robustness = -0.016\n", + "1300 loss = 0.562 mse = 0.495 robustness = -0.033\n", + "1350 loss = 0.539 mse = 0.480 robustness = -0.030\n", + "1400 loss = 0.544 mse = 0.509 robustness = -0.018\n", + "1450 loss = 0.515 mse = 0.509 robustness = -0.003\n", + "1500 loss = 0.513 mse = 0.513 robustness = 0.013\n", + "1550 loss = 0.530 mse = 0.480 robustness = -0.025\n", + "1600 loss = 0.514 mse = 0.509 robustness = -0.002\n", + "1650 loss = 0.536 mse = 0.482 robustness = -0.027\n", + "1700 loss = 0.501 mse = 0.501 robustness = 0.002\n", + "1750 loss = 0.504 mse = 0.486 robustness = -0.009\n", + "1800 loss = 0.512 mse = 0.505 robustness = -0.004\n", + "1850 loss = 0.494 mse = 0.490 robustness = -0.002\n", + "1900 loss = 0.494 mse = 0.481 robustness = -0.007\n", + "1950 loss = 0.526 mse = 0.526 robustness = 0.004\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "##### hyperparameters #####\n", + "γ = 2. # weighting on robustness loss\n", + "###########################\n", + "\n", + "for _ in range(2000):\n", + " optimizer_stl.zero_grad()\n", + " y_pred = bump_stl(xx)\n", + " ϕ_input = y_pred.unsqueeze(0) #.unsqueeze(-1)\n", + " robustness = ϕ.robustness((ϕ_input, ϕ_input), scale=-1)\n", + " mse = (y_pred - yy).pow(2).sum()\n", + " loss = mse + γ*torch.relu(-robustness).squeeze()\n", + " loss.backward()\n", + "\n", + " optimizer_stl.step()\n", + " if (_ % 50) == 0:\n", + " print(\"%i loss = %.3f mse = %.3f robustness = %.3f\"%(_, loss.detach().numpy(), mse.detach().numpy(), robustness.squeeze()))\n", + "plt.plot(x +2, bump_stl(xx).squeeze().detach())\n", + "plt.plot(x + 2, yy.squeeze().detach())\n", + "plt.plot([0,4],[a.numpy()]*2, 'k--', linewidth=1)\n", + "plt.plot([0,4],[b.numpy()]*2, 'k--', linewidth=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "γ = 2. # weighting on robustness loss\n", + "PATH = \"models/bump_%.2f.model\"%γ\n", + "np.save(\"models/bump_data_%.2f.npy\"%γ, torch.cat([xx, bump_stl(xx)], dim=-1).detach().numpy())\n", + "torch.save(bump_stl.state_dict(), PATH)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### plotting results" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABZgAAAGoCAYAAADLmIB6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3xV5f0H8M+TvYAQZtiGKQ4gQXCgggSpglZrcFtcgLO/attQ21pa21/7ww5b26pBqa1aWwx1ULRqUBEXSoKCA1DD3iMJkEHWfX5/POfmnnX3vvfzfr3OKznnnvGc55x77/c+5xlCSgkiIiIiIiIiIiIiIn+lRDsBRERERERERERERBSfWMBMRERERERERERERAFhATMRERERERERERERBYQFzEREREREREREREQUEBYwExEREREREREREVFAWMBMRCEhhMiPdhoosoQQ+UKIsminIxbx/UBERER6jA2SD2Nl9/h+IEo8LGAmooBoAVOpEGKxEKIGQH2000ThpV3z+UKICt01r4x2umJBvLwfhBCV/KET/h81we7fl+2FEFVCiNJgjkNEROETL7EBhQ5jZffi5f3AWDkyGCsnJhYwU8IRQpQLIaQQol43SSFEuZ/7qbTZj3NfteFKfzzQPqi3QQVM5QCKA9wPr1V8mQhgMYArEeA1D5azJogzcNddZymEqNWWLY5kMBGq90O4CSEqAZQCWBXttESadt8s1u4RCcB534Qk8Ax2/wFuXwmAgTMR+Y3xV/gxVk5ajJXt08RYOYaZ41BtqtE+N0JyrRgrJwkpJSdOCTkBKAJQC0DqptIA9lMM9YRVAiiL9nnF2qTPY16r5JlCcd39PF4+gArd/VEFFaDOB1Cm/V+hu/5SS2NE74NI54sf6arU0lUc7bRE4dydnws1zvPX7qdy3b1SHq39B7O97j2RdNeVEydOwU+MvyKWz4yVk3BirBwb+eJHupIyVtbuD+llqgzyGIyVk2SKegI4cQrnBPUE2fwBWRTAfqoA1Ef7fGJx0vIm6CAhHq6VFtw705kf7bxPhOvu47FKdcFwhbe814JoffAcVFAUq/niR5qcwVfAhajxOmnBZ727zwRTYOp34Bns/kORPu2HWn0gn5ecOHHiFA/xV7xPjJWTc2KsHP188SNNSRkrQxXcOu+BGu29Ww5V2K6/PySAigCPwVg5iSZ2kUGJ7oj2t0G3rCqA/TQAqAs+OeRBPFyrGqgvMUgpG7ysSyEgVB9oVVDBxRwp5QJveS+lXA7gJADrtUVlQvX1lnS0Zm2LAWyVUj4Y7fREwWKoe2eh3YtanjTo1o30/kORvgVw1VoiIvJXPMRfpMTDtWKsHGGMlYOT5LHyRO3vQilliZRyoZTyQSnlHCllTwDLdevOD7C7DMbKSYQFzJQspuv+LxJCBBKMUWTEw7ViwBwBWhDjHBjlQS0Y9okWWE+H61oVCyGSMah4XPtrG5QlMqEG/5ivzT7nYVXna6XCjwFHgt1/qNInpVwF9QOxVHBQGiIKXDzEX6TEw7VirBwBjJVDImljZQDD4aFgXUo5B8BW3SK/+jJmrJx8WMBMSUFKuR7AHN2iUiFEILXVKMxi/FrVmf5SeHWNui2l9Dvo0wJn/XbzhRBFoUhYPNAGtCgG0ODPD44E4gyCG7zU5NH/MPcncA52/6FMn/MHYax8VhJRnInx+It0YvxaMVaOLMbKQWCsjCJ4r9Wr/2wZ7uf+GSsnGRYwU9LQvjT0T+fKQ/0ESwhRqo226hyBtUYbwdfnWnEUF9cq5mpl2JxPvW6U6Li7/7Tr7QxwlwS6HynlEhivVzLVTnCeq6cn/onsKu3vVo9ruZqHAsAZEdx/KNPnvMZFrJlBRIGKg/iLNHFwrRgrhxlj5ZBI9li5CsZuMOxU6/4v8HP/jJWTDAuYKaloT3ZX6RZVBtiXkIEQIl/rt6oS6oN6BoASqA/k+QC2aU9I7bYr04Idj83btKCoQghR78M6taZlNVoQVelmuyLndqaAa77d+pEQa9fKzX7ytbwr1oLTSi0f9VOlEKLczfbSzb7LbPblaT9V2rlsharR0hOumi3l2jm5/SIN9L7xRggxX7ufnJM/12+B7v9gm37qg8Yr9S9o+TdfO9dy3fLF2rlL7X1RGUyNDu2aLtamcm1yzs83rTvfzXo+H1/7oeS8j33KP+1ertTOu14IUeXLeyGGOfPLW1Cqr2XlzzUOdv8hS59Wq8O5n6vs1iEi8kWsxV+Mld2LtWvlZj+MlT1grGw4DmPlCJNSLpFSeotD9YXK6/w8BGPlZBPtUQY5cQrnBG1UUZvltXCNNloP7yPtVgKodfNasbYP25FJtW2dx8rXlpWZ0iAB1LjZt3k96es6UEGg22PA1dl9PdQXaw2sI8Z6HFUYoRsZOyavlS4fLXlsmophHMVWanlT6uZYzhG2y2xeK9K2q9Ltq9zNfpzpKnVzzjX6fYTivvHluuvyol7bn1+j9przNsh7y3w++vtev7xce83TtZ4fyPtBy+8K075qtbQV26xbrkufcz2fR2OH+oxxHsdr3uvWr9fSuViXD5Z7NB4m3fl7HfVa/56N1P5DnT7d/WU7yjYnTpw42U2I0fgLjJXj5lrp8pGxsh/XHYyV7d6njJVjbDLdG4Heo4yVk2SKegI4cQrnBPeBWJG3oMC0vqdAzPnFYvtlajpWpbYsX1te5i0N2nrOYM82SNFeLzWdk3NeHwhXmbargk0gqm2rDxzcfpm4CxIS6Fo5g53FutfqtfQ6p/m6fegDI7fBhu6auD0f3TW0/VLVpcljoRiMwWGRbnlA94236w5XwFxlvrd8vBfM19yvYMbN+8MQhOveV/ofSpXaPbLYeUxtvUrT9m7Pydv7wXR/eAyWdMf1+/z1afZhXWfgWGs+N91+bM9Z23ZxMNcnXJOv+Wxa1+PnSyj3H+r0wfgDIKgfmpw4cUqeCbEbfzFWjp9rxViZsTJj5TiMlX3MJ+cDGJ8rYei2ZaycZFPUE8CJUzgnuAnEtNfMwYLbDy64CcRgfArv6YvUGaxZnpbBh+BJW89rcArjU/xa/Qen9mVdabN+uZt96fPHU96ENWiOt2sFY8DnLtg11xKwDYrgCoot6TUdx7ZGhs1+vAbAvtw3nq47XEFhwIGUzfUONmg2B+GlutcsAbWH+8q5jtuaGd7eD6a02P64060bcD7q7mNvx3DmtbuaSvnu7mXde8rnWhs2976/k8daYjb552tQ6tPncCj3H+r0md43HmsPceLEiZNzQoLEX9p6jJXj4FqBsTJjZcbKno4XsVjZj/vMa8sID9eHsXISTeyDmZKWlHIVrKPm+tuPmrP/Hm8jmzr7+8kX1kEkwjXK8mKpRpkGAEgpFwCYZ1pnIdwMCqHlj/OcojqacAxdK6+k6sfKme9XulnN3GfeAjfrlQFY4ia9+vzw1i/Vr3X/l3o5L1/uG1ta/3ZXApghAxjJ2oNQD7ziLr+W6M/dRJ+H/o6g3MV0fxS56ytOd3//2u51Hzj7S3N7r2v3gbPPwHnSpg827d5bDhXs6rcthfoxtlX6N+q28/wDnbzd6/pzC4RPn8fB7j9M6dO/FneDFRFR7Imh+IuxshcxdK28YqzMWNkTxsqRiZV9VKH9nePlM8GCsXJyYgEzJTUp5YMwjpxa4efgCl3rap3+u/ug0n8gBxqA+jsas2U0XPMXg5RyvbsvC+1cnF9Q/o4YG3Jxdq2WaX/zzWnUgo0iqIFFnMGT5QeAtl0RVGBip2tACbtgR0+7xr6el9f7xkzLz1oAEwGUaD9ygmE+n2DvP8O19pBftW6WwxRMB/sjUh8Iu/txsQDufzD5wnnO3n6U50P9kPQU+FYAXfeuPtheBTXoj8+klKuklCVBTD79GDPlmz/3j0/5Hez+w5Q+/WsB/7AjItKLs/iLsXL8XCvGysFhrMxYOahY2RshRAXUdVwQyP3KWDk5sYCZkp6Ucg6MX9Jv+PLEzLSOc7AD50i6hgnq6fpWqC+ZUD5VdCuAp4zF2ii8VdrT9cVwffHGxBO+OLpW+i9h8yi1C+EKhpxPhfNtRq5eAGCVhwDP30BSvx+3QV+AQVqttk/9aMzBMAd6M4Lcnz6v3NW68EdQ7wctQHXms6XmjvaDqRjufzB5ZLrf3V5P7VrPgGsUdXfrOe9n53V4HECdlHJGEEF9JPlyvZzrBPKeD3b/oUqf/n0T9YIOIkoccRR/+YWxsgtjZQCMlZ0YK7vSkSyxsoFWO3w+gIVSStsWHH5irJwkWMBMpMyA68slH8AbPmyj/1DaCqCneZJSCt00PBa/ZLRAuR7qC3q9lsYZWnOviAT4for5a6U9wXdu2xUMa028nM2lYPrCvs+0myvhOWjq+qL1sQmR/lqG+h7U/0ioCKBJpoGW7/rgNthAXF8zZpnbtSLLee0D+cHkkem+9XhvaLUkfKmVsBVAsXYPl8FLoB0jAqlV5rZmThj2H870has5ORElr5iPv8KFsTJj5RBgrOw/xspRoNXCrgDwoNYqIhiMlZMMC5iJ0NUMSP8lUCyEqHS3vm4bpwIpZYN5CktiQ0gIUQMVmK3SgsRgm2uFXRxdK2fzOX3fYQthDYacwZMzIHF+sdd5uR7+Nk/UB08h/TEkpZwBa5PMoAJnGIPbYj+beJp19SkIN/0oRoG+6V9Xv4LaD6D5CLBGho1QPZ3fqu1rMTz3vxdLnPe5x/eH6UdndQT3H+r06a91zH//EFF8iaP4K6QYKzNWDgXGygFhrBxh2j1UBZX+UHS1wVg5ybCAmUijBSj6ASTKhBDlXjbrqh0QREf0Tt62D2nTOyHEYmhPq7XmdHEjBq6VL/SBfJmHYKhC97/znBbarGem//Kc6EN6nF/MWwN92u+Jdg/pA9KgAmftibn+iz/QJnBFcNXKWBgrP2ala0AQwDiYzJVQ1yhUffOF6l5vgMrHMrjvC88rIcR8u+a2fkwefyCbOAN7b+/5rvePnz8Ggt1/qNOn38cRD+sREQUkBuIvxso+ioFr5QvGyoyV3WKsHJFYWX/cIqjWDsu11hmhwFg5ybCAmUhHa4al/+JfrD0hd0cfuJibbfnL29PTUPTXpedsahSLTfu8ivK18soU9FwFFTBbgiHtS7BrABNd00DLACIm+uDBlyDGGTRXeFwrCFowom9KFWztDP2I3KUB7st5vstD1IdYKOmvhfOeXIjQXKNwDTq0KsgfHpEcGbtK97+nzwbnjyp/RvgOxf5DnT597Y64qzVDRPGBsXL8YKzMWNlHjJVDK55iZQBdhcs1AKpD/DCNsXKykVJy4pSwE4BydZv7vV0NAKmbagDU2qxXbFqvOMhj2W4PFSB1HcfDvqq8raNbt15bt95T3mmT5dwDOWYCXKt6b/nh4brVA5jvZr35pvRX+bj/Wt12pR7Wm+8p3YFcQ0/bmM5HujtvH4+z2LSvsgC2dZufpvui3Mv+pA/78ysvTdewLNj3kW6/+vdvfgj257z33d5nsTjp8tfTNXN+hlg+E6BqOlQAWBym/Qe1vWm9rvdKtPOdEydO8TPFSfzFWDl+rhVjZR+2AWNlxsoxMsE1qGdNENszVuYEKSVrMFPC6wX4PLCD3nQYmxzZ9mkl1RN1/ZOyGrsnx0KIIiFEhZsmK/qn9JX6/rOEGq26BuppW6ifsnU1CxJCdD0F1tJaBVWTIJI1NuLhWnX1A+UcbEK7RuaBJ5z0faPlSze1AkzLi+H7U3l98yXDveOk5ediqDwKdoRpn2jno3/6XaG/x/zc10IYa51UatfH7X0ihMjXrl851AAVETnvAOmbM1YidP3e6T9XgqrRpeV1PgDIOOh70sR575Ta1drS3rvFUPeJ3Wfs41A/Asvd3MPB7j/Y7fWc73/WyCAif8RD/MVYWYmHa8VY2QeMlf3CWDlMtHQ7Pz+rhRCLtXunQghRqZuqhBA12lRl2g1jZXKJdgk3J07hmqA+KJ1PvMrh55NJWJ/ie6qZUGFat+vpui4NVXZp0NJZb7O94QkwdE97YfNk1GY/Hp9eQ32Rmo/l3H6+to6+xkORD8cM6IltHF2rcpttPea1bh3bp7p26fLz3EtN12C+lp/OEYzrtfOzzVN/7xt/rrvNPVbvy/49XGNzDZwq7ZrM1861XPc+qYIPNW9grPVhe91trmW9m/sjoPeD6Zws77NAJ11aPN57PuynzPk+CVXaIjmZ3rfluveHc3mlh23195xtzYlg9h+K7W3uI4+1izhx4sTJOSF+4i/GyvFzrRgr+3Hdbe4xxsqe98tYOYSTzf3iy1TrYR+MlZN8inoCOHEK9QT3gU0gAYm++ZLHpl5wPU3XN+Op1b6UvTXXyId6Iqvftl7/4efmC6Bc94VmF/w6J3cBU6kWKDjXr9Sva0qPhNZE0M0x9VNFAl+rxbrt3Dbl063vDOI8BkNwBf4+fUHa3D+Lbc6nAu4DWr/vGx+uuyU4086rXru3ytzdi36ca7F2rjW69NZr5+sMor0Gnm7eTx7vPTfrOn+cBPx+gKt5qE/NPf3IK+f7K6hgF64fdEEF39GctOtUYbpnqty9P3TbOX+U1nr6bAh0/yHcXl9wEHQzT06cOCX2hPiMvxgrx8+1YqzMWJmxcoxP3j5b3Nzvls8OMFbmpJuEltlE5IbWdGQi1BdxrA18QDq8VhSPtOZeVQBmyBA2q9PeD/Xa7HAZ4IjoQohaqKBujpTS34HwKAKEEIuhfigskaEb+ZuIyCeMv+IHrxXFI8bKFCzGypHBAmYiIqIo0vo3XCilHB6GfZdD1WJ5UKo++gLZhzNQKJHe+zajKBBC1EPVzuopgxu5nIiIiCimMFamYDFWjgwO8kdERBRdC2AcwCRkpJQPQg1kUR7AoEDQD6bBgDk2aT+M8qF+eDFgJiIiokTDWJkCxlg5cljATEREFCXaaObhbqY6T/sbSGDuHG05oCaDFF7aD6HFAFZpP5CIiIiIEgZjZQoGY+XIYgEzERFR9CwGENY+ELXaFHMAzNfXsvDRGdpfBs2xqRLq2syJdkKIiIiIwoCxMgWDsXIEsYCZiIgoCoQQZVAjL/863MfSBhxZAKDSz+Z/ziC7KvSpomBozf2KoPr7Y3M/IiIiSiiMlSkYjJUjLy3aCSAiIkoGWpDTC8AyqGDUOaBIRAIeKeUSIQSgRo/3ZwTuhWxSFpN6gQEzERERJQjGyhRijJUjTEgpva9FREREQRFC1EI9RXdaL6UsiVZ6iIiIiIhiBWNlovjGAuYY17t3bzls2LCIHKupqQm5ubkROVa8YJ5YMU+smCdWzBOrTZs2obm5GRkZGejZsycGDRoU7SRFHe8TK+aJVaTzpKam5rCUsk/EDkgBi2ScDPD9aYd5YsU8sWKeWDFPrBgrW/E+sWKeWMVKrMwuMmLcsGHDUF1dHZFjrV69GlOnTo3IseIF88SKeWLFPLFinlgxT6yYJ1bME6tI54kQYkfEDkZBiWScDPD9aYd5YsU8sWKeWDFPrJgnVswTK+aJVazEyhzkj4iIiIiIiIiIiIgCkjQ1mLWRQO8DUAygAKrT9mVSyvW+bu9L5+DO9bTjVWqLzds5RyVdLKX0p/N4IiIiIqKQYpxMRERERMFIigJmIUQxgDcALATwa6iO4+8DUCOEmOFj8FqvjSjqzXoAzo7oS72sW+HLDomIiIiIwoFxMhEREREFKykKmKGC5iVSyiXa/HoAc7RRSquEED19qHXRAFeNCrt1na8tNC0vgaoJol/HyadaIUREREREYcI4mYiIiIiCkvAFzEKIcqiA1a4WxHIA5QCuBLDE5nWzEndNBYUQFQCKzLU8fG1aSEREREQUSYyTiYiIiCgUkmGQv6sANEgpt9q8VqX9nePDfuo8BM35AOYDWGB6yWtfdEREREREUcI4mYiIiIiClgwFzMUA7IJmAKjW/k70YT+ealg8DtW00HycOh/2S0REREQUDYyTiYiIiChoCV3ALIQo0v61DWB1/cmZ+3yzW9e29oY2MEoZrH3KFTjTIISoFELUCiGkEKJGCDHfpxMgIiIiIgoDxslEREREFCpCShntNISNEKIUqnnfKinlDDfrSACQUvo09LXN9jUAlkkpHzQtLwJQq82uhwreJ8IVpHtK03yopoTo169fyb/+9a9Akua3xsZG5OXlReRY8YJ5YsU8sWKeWDFPrJgnVswTK+aJVaTzZNq0aTVSSl9q7cY1xsn+4/vTinlixTyxYp5YMU+smCdWzBMr5olVrMTKCT/IXzg5B0YxB82afGijcOubBAohFkMNmFIqhJivG7G7i7ZsCQBMnDhRTp06NRzJt1i9ejUidax4wTyxYp5YMU+smCdWzBMr5okV88SKeRKfEi1OBngv2mGeWDFPrJgnVswTK+aJFfPEinliFSt5ktBdZISTVvNiMaxN/gCoUbGllCXm/uaklAsBOEfQ9mXQFCIiIiKiuME4mYiIiCi5JHoBszNoLfCyXiCjWFcAWC+lXB7Atou1v0Ue1yIiIiIiCg/GyUREREQUEoneRYZz0BJvg5O4Gz3blhCiDEApANu+4XzgPF4gATsRERERUbAYJxMRERFRSCR0DWbd6Ne2NSB0o2evsnvdzTb5AB6HqpXh83YmXQOYBLg9EREREVHAGCcTERERUagkdAGzZhUACCGKbV4r1f4u82N/j0MFvrZ9ymnHWqwLyu04R1v8tR/HJSIiIiIKJcbJRERERBS0ZChgrtD+LrB5bQ5UDYv1+oVa4FtuXlkIUQqgDMBWL7UylumOa95HPlTfcnN0NUeIiIiIiCKNcTIRERERBS3hC5i1wUWWAJiv9QkHANAC44kwjVCtBcflABbb1OZwBsOL4YEWiBcJISqFEKVCiHwhRJEQYj6AN6CC5kAGPSEiIiIiCgnGyUREREQUCok+yB8AQEq5QAhRA2CBEOJxqEFN1gM4yaZ2RLX2GvQ1NrRAuwhAg5RyiQ+HXQjgPgBVUIOUVAOoklKWBHs+REREREShwDiZiIiIiIKVFAXMAKAFu14DXi2QtgS3UsoHATzox/GWA2DtCyIiIiKKaYyTiYiIiCgYCd9FBhERERERERERERGFBwuYiYiIiIiIiIiIiCggLGAmIiIiIiIiIiIiooCwgJmIiIiIiIiIiIiIAsICZiIiIiIiIiIiIiIKCAuYiYiIiIiIiIiIiCggLGAmIiIiIiIiIiIiooCwgJmI/CNltFNARERERBSbGCsTEVESYgEzEfnm0BbgL5Nx7jtXAu/8PtqpISIiIiKKHWsfBX41EJM+ugPYtzHaqSEiIoooFjATkW/efhA4tBmpjjbgjQeAuq3RThERERERUfQ11wGv/wRoa0ROy16g6qfRThEREVFEsYCZiHzz2XLdjATWLY1aUoiIiIiIYsa+DYCjwzW/9S2gs8P9+kRERAmGBcxEFJjDX0U7BURERERE0Scd1mVHGCsTEVHyYAEzEfkmf4hxvmFndNJBRERERBRLcvtYl+3bEPl0EBERRQkLmInINze+bJxv2Ak4bGprEBERERElk8LTgXO/Z1zGAmYiIkoiadFOABHFiR6DgewCoKVOzbc3AUe+BvqMim66QmX/Z8DOD4ARpUDBSdFOTfJpOgK8+3ug9Rgw/AJg1DeA9Oxop4qIiIjIN4XjjPOJVMDc2QFseRnoaAVOvoQxWjRsfxdY/zTQvRA45XKg/+mAENFOFRFRFxYwE5FvhFCB89a3XMv2bUiMAuZdHwF/mwV0tgEZ3YDb3wN6Do12qpLLf74DbF6p/l//lLoO//MJkNs7uukiIiIi8kXheOP8vo2qtV9KAjQa/u8PgOq/qv/HfhO48qnopifZNOwEnrkC6Dih5t99CBh3LXD5o9FNFxGRTgJ82xFRxFhqZnwSnXSE2qqfq8JlAGg7Dqx7IrrpSTaNh4DNpi5Yeo9k4TIRERHFj/whQFa+a77tOFC/LXrpCZVDX7oKlwHgi5eAuq3RS08y+rTSVbjsNOTM6KSFiMgNFjATke8Ssenfnhpgx7vGZR8/HZ20JKsvXwUgjctOm+N+/XVLgUNbwpokIiIiIr84W/vp7f04OmkJpQ/+bF22+ZXIpyOZ2eX32Evt1z1SC3zyLHDiWHjTRERkwgJmIvLO0QlICQywafonpf028eL9P1mXtdSr2hoUGVtsguZTv2W/bt024OV7gb9MAh6bArz3MHB0T3jTR0REROSJo1P9TbTKGI0HgQ3/si63i90oPI7vB/ZUG5cNmgRk97Rf/+OngRdvB347Enju28Cm/6i+s4mIwox9MBORd5+/ADw/T/WLq9d6VDX9KyiKTrqCVb9dNfOzs3V1YvQvHevamoHat4zL5r8NdOtvv/5n/3b9v/9TNVX9FDjpXGDaT4Ahk8OXViIiIiI7T31TjenRaSrIi/cC5o+WWM8JAHZXA63Hgcxu1tcotL581Tg/YAJw82v26zocwKdarNxxQv3O+eIlILMHMOE64LwfADkF4U0vESUt1mAmIu9ajwHSoQqUzeI5cP7gEXVeetN+Atz+ATBpXnTSlGy2rgY6WlzzPQZba/84San6oLO+AGxbA/z1QmD5LcDR3aFNY2cH8NHjwEa7YxMREVHSO3HUviB234b4be3X1mQ/LsnlS4DvbWbhcqSYu8cYPcv9wJG7PwKO7rQubz0KrH0E+FOximk7O0KbxqN7gBXfUa1AiShpsQYzEXln14fXwImqILDHkMinJxSa66x9LV/2KDD+2uikJ1ltMQ3uN/oi1YehHSmBs+9Whczb1lgfDgDAZ8vVgIFT7lHrZuQEl76tbwOv/hA4+AWQ2wcYNRPI6h7cPomIiCixtNrEyiNnqli5sw1Iy4x8moL18T+MBYZZ+cA9nwOZedFLU7JpbVSVMfTGXOx+/e4DgXO/p2LlBpuC5pZ64JXvq0Ebv/FroGhqcOlrb1HdDb77ENDeDKTnABf9X3D7JKK4xQJmIvLOHDSfvxCY9qPopCVUqv+qAiGnboXAqWXRS08ycnQCW0zN/kZf5H79lBRgwvVqOr5fdd3yaaUaqFGvowVY/Sv1AGHGA8Apl7svtHanbhvw+k+AzStdy5oOAWt+A1z4C//2RURERInNXBnj+18DeX2ik5ZQcHRaB/c74xYWLkda7ZR+Aw8AACAASURBVJvGmvH5Q4C+Y92vnz8YmP5T4IL7gd3rVJz82fNA82Hjege/UN26jJmt4lp/uzuUUsXhVT8Fju5yLf9oCVByI9B3jH/7I6KEwC4yiMg7c9CcHed9d7WfAD6sMC6bfBuQlhGd9CSr3dXGgDezOzB0im/bdusPnHk7MO9N4MZXgP6nWdc5ugtYfhPw5MW+d+XSehxY9TM1iKC+cNlp/VNqHSIiIiJAFbaZK2PEe2unTSuAhh2u+dQMYNKC6KUnWW35r3F+9CzfKk0IAQyeBFz8G1XrfPoiID3Xut7mlcBfJqvY19f4dt8GFVsvv8lYuAwAstO+WxUiSgosYCYi706Y+l6O96D50+eApoOu+Yw89bSdIsvcPcbIGYEV8g87Rw0MeMkfgZxe1td3vq+aeXricKh1/lSimvl1tlnXGXcNcMdaY5+DUnJkbiIiomTW3gw4XH3aOkR6fHaJ4SQl8N7DxmWnXwV06xed9CSrzg7rAH+eusdwJz0LOPde4O4aYJxNV4CdbcB7f1SDn3vSeAhYcTdQcb6Krc1yegGz/wBctNi4nHEyUdJgATMReWeulZEZ5wXMJ44Zn+KX3Ahk59uvG68Ds4TC4a+Bmr8BR2rDs3/LoCUBBM1OKanqOt69HjjrLiBF1wNUdgEw7T732+76CHjiAuClO4DGA9bXB04Ebn0DuPwxoHuhWtbRBmx8Dnj8AtU8kIiIiJKTqaVfR1qQ4z9EW+txIMNU2/Xsu+3XlTJ5Y+XODtXV22fPA23N3tf3164PgZY613xWD2DIWYHvr3shcPmjwK1vqthWr+RG+9aAgIp53/+TGiBw/VMATNc7JQ04804Vg0+8ScXkgBr4b9XPgN+NBg58EXi6iShusA9mIvLO3EVGvNdgPvsuYMJ1QPWTwLqlqnsMvbptwJZXVAFowTDgm3+JSjKjRkpVi/fNX6iB9DK7q64oeo8M3TEOfwUc+co1n5IGjCgNfr/Z+cDM/1WB8ms/Ar56Hbjgx0B2T+u6zsD30+fs99WtECj9OXDaHONo3Qc3AU9dBjTu187lS9UneVaP4NMfj47tUzVZBk4Eeg6NdmqIiIgiq9VcwJyLuO50Las7cONKYO/HqmCxoxXoM9r1emc7sON9FStveQX41hPAkMnRS280HNsHVN4I7Fqr5kdfDFz9rP9jfniyxVQRY+RMIDU9+P0OKgFuqVL9M69apGrgT/uxdT0pgS9fU/F0nZvKJiMvBGb+yvob4e3fAKt/rbrMAIAPHwUu/VPwaY9XO95XAyyOvDA015AoRrGAmYi881SDufEgcGwPMGBCZNMUrOyeqrnYOf/jetIOqNqsS2e45g9+Dsz+I5CaJB+XJ44CL95h7H+49RjwwV+AS/4QwgMJYPx1qulf8xFg2BT3tcg9Jbe9E7vrW9Dc1oFOh4RDSjgk0OkogGPyo8gb8j7q8yaic/MBdDrQtY5sP4HCPa9i/OcvWpvypGaqmjpT7rEfzKZgOAy1N9oagY+fAc660+/0x71dHwHPXKHukYw8YN5bQJ9R0U4VERFR5HiqwdzZoR6oZ3YDegyKcMKCNGACUPZXNeCf3n++C3zyjGt+y8vJVcC8431VuKxv9bblFdU38YDxoTtO/9OBYeeq48nOwLrHcCclBRh3FTBmFnDgcyC3t3Wduq3AV6/ZFy73GqkKlkddaL//PqNchcuAavU3/WdArk1XdolMSlVAv/YRNT9yJnCdm4otRAkgSUpMiCgo5hrMjg7g2atVIHV8L5DXH/j+luikLVj6wmUAGFAMZOUDJxrUfEu9qp0wzMfB5+LZwU3AsuuBI18bl1/6Z+C0stAeq/cI4LJH1I+WXR8CsK/xIaXEocZW7Kprxs66Zuw80oIddU1d8weOeevXLRXAx7avXJqyCw9nGPta/qrXdOyf/COcNHIsBmZk26cqLQM441bgrf91LfuwQtWEN99Piaxuq/FhTFsj8PnzwNQfRi9NREREkdZqHKukMzVHdZuw9lFg/6dARwsw9b74/X40xzbDpxkLmDe/Asx4ILJpigYp1TV9/SfGwtOiacD0+0NbuAyoAuBxVwHNdcBXVaFp6WeWmef+4UBBEXDI9Psus4e6jyfN81wTd/QsoMdg1yCAHSeAmieB874fmnTHiw/+7CpcBlSB/fH9arByogTEAmYi8s4UOCN/CLD1LRUsAKqrgET5skxNA0bNBDYucy3b/EriFzB/9m/gpbtUMzm97J5Az2FAenZ4jpuSihMDJmN3fTN2bj6AnUeasbOuBTvrmrsKkVvaO73vx0/ZOIH70v/ZNb/JMQQ/7/g21u4ZCzx/AMABdM9Kw8mF3TF2QHf1t7A7RvbLQ2ZaKlByE7Dmt0CnVsDdsEON9H3y7JCnNWa9ZNMfo10f1kRERInMUoM5F2hrAnZ/5Fq4b0OEExVGI2cAKemAo13NH/lKdX0Wyq7UYk1rI/Cf76h42U7vMLbeyilQBc2R9sWLwI731P8iBSieC1zwE/vazmapacCk+UDV/a5l655QLUeTpYuIQ1uA1++3Lm88mBi/mYlssICZiDyTUg32oZfdE+h3CrCnxrVs34bE+bIcfbGxgHnLy6pf31D2qxYrOtuBqkXAWpt+pgvHAVc+HXS/una1kPUFyPuPnQhq/4GYnboWhaIOB2U+Huq4Ass6p8Fh6izj2IkOfLitDh9ucw2wkpYiMKJvHs4d2Rt3jbgMPbbo7pMPH0uuAubLHwX+YBoQxtzagYiIKNHZ9MGMwnHGdfZ+EsEEhVlWD1XxYutbrmWbXwamfDd6aQqnI7XAv64DDm2yvnbu91T/xYnWgk1K1T0eAJx0nuoOw90ggO4U3wCs/j+gvUnNH98HfPFS6FtFxqo+o1VrzRdvNy4/cdR+faIEwAJmIvKsrVEN9KbpTMlEamq6CpzNBcyjZkYhgT76sEIN2jZmlvcgcMR0IDUD6NS6T6jfDhz8QhWqJ5LjB1Qfcjvft742/npg1m99rrms+kJ2FiA34/1NrXhmR3VYayEDQIoACntko2duOlKFQEqK6PqbIoDUFIEUIZBqWt6UcjXuab8Ynx0Bag83w+H9UACADofE5v3HsXn/cbwrxuO/mboC5u3vAPs2AoWnh+VcY07+EODyJcAL813LGDQTEVGyseuDuc8YYyx5fK+quZjXNwoJ9EFbE/DGL1QXYL1HeF9/zKzkKGDe/DLwwm3249Fc/pjKh0QkBHDz66oVq91A2b7I7gmMv0bVXHZa+2jyFDADwPhrgZe/Z2whyliZEljSFDALIfIB3AegGEABgFUAlkkp1/uxfaU222B62Tky1WIp5apQHpco6myC5lTAWjMjlpv+NdcBq36mvtwLitRgbBNuANIy7dfP7AacdD7wdZVr2eZXEquAeeda4Lm5qnsTvdQM4OLfqGZwuhrbnmoh76hrctMXcmi6S8jLTMOQghw19crB4IIcDNXmB+RnIyPNMkyfX1raOvHlgeP4Yt8xbNp3DF/sPYbN+4+jsbXD43ab5FB80DkWZ6V+0bVs72sPoe8NS5GWGlya4kb+YOM8g2aiuMQ4mSgIdjWY0zKAvmOBfbqay/s2AiPD0I9uKHz8D+DDR1VrrDGz1EDHgya6X3/0RcAruv50d6+L7QJ0fzk61Vgb7/zO+lrfscBVzwC9hkc+XZGUkhJ44bLT5NuMBcx7qoFd64DBZwS333hy8iXGlrHmhxVECSQpCpiFEMUA3gCwEMCvARRBBbM1QogZ5mDXA28RQUWYjksUPbITGHSGKmhuPYY2mYNMIL4KmKuXup4c121VfedO+LbnbcbMMhYwb3kZOP8H4UtjpEgJfLREjWjsMBagyu4DsXvGY/gqfTR2vr+9qy/knXVN2FXXgpb2TmSgHenoQBMC65N5rNiOQnEE7zpOQysyAKhy7AE9sjGkIAeDC7IxtFcuBjsLlAty0DMnHSKM3ZNkZ6Ri3OB8jBuc37XM4ZDYVd+ML/Zqhc77jmHTvuPY09Bi2Pavnd8wFDD32rYCF/3qBUwrGYsrigdhdP9uYUt3TMjqYZxn0EwUdxgnEwUpt4+Ki7VYuSNN++4vHGcqYP4kNguYOzvUYGQAAAlsXqma93sqYO4xCCgcrzs/qcaiKJkb7tSGX9MR4N+3GGtoO51aBlz6MJCR63775jrVb3KgPl0O9D1ZFWTHe/d8vUcCI2YYf1OtfQQY/GT00hRp5liZlTEogSVFATNU8LpESrlEm18PYI4QohZAlRCip5TSXNvCnRKoGhaAq0aGk7m2RSiPSxQd+UOAW12/8WpWr8ZUQAU9+gE+ju5SAVlur2ik0r32E8CHS4zLJt+mapZ4MvoiYKWuqd/ej4Fje4HuA0KfxgiRUqJh05vo+d9yy2sfidNw28E7UfeP4wCqLa8PFgdwXdqbmJO6Gk91XIg/dl7h17GdtZB/1PEuphx/BR2pWWgoPBdtk+9G75PPDboWcqilpAgM7ZWLob1ycdFphV3LG5rb8PaXh7C8Zjfe/fow3nAUY6ejD4akHAIAZIoOXHTiFTy8JgtL1mzF6YN6oKxkEC4dF7/3DQBV473nMGs/6wyaiRIB42SiYExeoCbNntWrMRIABowH1v/dtZ6byhjtnQ58eeA4WtrC052YNz23v4zhDTu65h0pGdhYeBU6ttd52Aoo7D8NA3UF6A0fv4ive11iu+5X9Z3I87K/WHHS299Fr23GwmWHSMPuM36EgyffCOxtBWBquefoRI+9a9Bn8zPovvcdfHrF22jPLYQndnmS0t6E8S/cjhRHG1rzBqNhcCl2l5RDpmWF4Myio/tJ12OUroBZfvESNn7+uW3+xMN9kpWeilH9uhl/u0gJbPqPqq1sfijAWJmSiZQyoScA5QAkgCKb1xZrr833YT/5Krsie9ySkhIZKXPnzpVauiQAWV1dLaurqw3LFi1aJKWUsrCwsGtZcXGxlFLKefPmGdbds2ePXLFihWFZRUWFlCoTuqbZs2dLKaWcPXu2YbmUUlZUVBiWrVixQu7Zs8ewbN68eVJKKYuLi7uWFRYWSimlXLRoUVDnNGvWrIQ7p2Cv01lnnWU8p0XdZcXsrNg/p9lZUi7qHvh1ujpb7nn5N7bnNHLkyJi5ThdfPEt+deCYPHPqDMPyGb9fLftdfLf1nO7NMyzLGzdTDl24Umb0G961LCcvT3b+tIdcdH6GYd3+c/8g+8/9g2HZKbNvkeWVG2Ruj4KuZePGT5AOh0POu/VW4zndmydXVPwibt9Pe+qb5dmzrrKc01NX9TYsK5h5lxz5o1fi4pxs771P3pIrbujl/TqNSpPyl/3j45z4WR5X5zR37lwZSQCqZQzEsJGYwDjZL4yVGSv7ck6+xsqbvt5uWGYXg6XmFcihC1fKHudcY1jXLgbrcc41cujClTI1zxWDZfQbLocuXCnzxs00rDvwjr/LPlfcbzwnm1g5e/gZcujClTJ7+BmG5UMXrpRjv3GtYdnyq7rJ4XcsialzKph5lxy6cKXP51Qw8y7jdbo6W264Z4DXcyrIy5ByUXefYmVP5zRmfLFh3Y++OzTk59TnivvlwDv+HrXrtOfePHnbnKlxfU49iy8yntOycrni6mzj+8ldrPzf+xLyc4/nFN1zipVYWajXEpcQogYqeLV0ICSEKAVQBWCVlHKGl/3kA9hmt59wHnfixImyutpamzAcVq9ejalTp0bkWPGCeWJlyJOX7gI+ftr14vRFwLn3RiVdthwO4JHJwOEvXcvOuguY+b++bf/O74A3HnDND58O3PC8ZbVI3idSBtIXslEG2vFcxs8xXOzD99tvw2sOz/2gdUMzPsy8EznCte/lI/4PLSMu7urGYqCpL2TbPNn1EbBU95GX2R34Qa332uQxTrY0wPG7sUjtaOpadk/b7XjBca7t+r3zMvGt4oEoKxmEUf1ivAuN4/uBJ0pVCwVAXbMrnwKGT1PzUgIPFEA/ECh+csjna8rPWCvmiVWk80QIUSOl9NA2PHEwTvYP359WzBOrrjxpPwH8agAgdTWTy7dh14ksPPnedixbtxNNUaq17DRJbMJzmb8wLJve+hvUyoE+bC3xTsZ3MVhrxQUAC9ru8RpXxoOJYjP+mfG/+FiOwJ1t38EheP5ouz61Cr9Mf7Jr/oDMxzmtD6PDzwbjv01/DGWpa7rm/9rxDTzQ4aVbvzhwbeob+FX60q75epmHs1r/hBNwMx5OHLkqfQ0Wpz7mWjDsXOCqp139V9f8HfjPd1yvj78euOwvPu+fn7FWzBOrWImVk6GLjGJYm+Q5OSNSX39E+NNeI5THJYpNheOMBcyx1g/zV68ZC5dFquoew1ejZxkLmLetUf3rZXUPXRptnGjvxO56ZwFyc1dfyM5C5Zb24H6MtCEdt7fdg2zRiq3S1XVDigAKtb6QnQPqDeqp+kROXXclsNF1rcscrwFn3u7fgTe/bJwfURr3hcsAILLzkVpygxoYR/Od3Cq82DgFUlr7zjvc2Iola7ZautDIz4mxvGhrAp69ylW4DKg+lvd/6ipgFkI1/WupN66T1juyaSWiQDFOJgqX9CzVl+6Bz7oWPfzsv/HHrQPR6YiNSl7z01Ya5ld1TvCxcBkABKocJbg55dWuJTNSaxKigLlajsH1bT9CjRzpUyHxC51T8MO0fyJPnAAA9BMNKE1Zj1cdk3w+Zio6cUGK8WOxylHiX8Jj1POdU1Ce9i/kC1UZo6doxOWp7+KfndOjnLLgnJ3yGX6Z8rhh2bEdG/DfNRtx1sQzMKRXjk0XGez5iRJXQhcwCyGKtH9tA14pZYM2cJS5jzg7Bbp9LoYKjIugguMK6eo/LtTHJYpdheON87FWwPz+n4zzp14B5A/2ffs+o4GCIjUwIKD6m/66Su0nCJ5qIe+sa8b+YyeC2r8nuRmpGNIrF0MK+lkG0zPXQjZIm2coYMbWt4Ajtf6NoL3lFeP8mFn+n0CsmjQf+LACqrUScNLAQrx/0Rl4/ovjWF6zG9sON9lutnH3UWzcfRS/XLkJpWP7oqxkEM4b2QdpqVHuk9rRCSy/xTg4EQBMvBk4+27jsszuxgLmE0eBXBYwE8U6xslE4Sf7nw6hK2Bu3FaDTod1XIbs9FScXNgtrIMamw3s2InSIx8blr3d+xqUZPjUEAEAsKNtKlDvKmCemfYxlhV2h0OkGtY7evQoevQwFbTFuA6cjXHeV9P0xHvHLsDMFlese0feahzqOdPtFuY8ObntMxTUN3bNN4o8dA46EyUiMYps3jp+MS5vrgQAtIhsjO4pUJJrvNfi4T7ZfrgJR5raMFLsxmPpf0C6cFX8aZXpuLH1Xqx/qxF46y2M6d8Ntw48jjL9DtgHMyWwxPi0cq/I+yp+768WKljeChVMFwOoEELM0TXjC+q4Qoj5AOYDQL9+/bB69epgduezxsbGiB0rXjBPrPR5ktLZinORAgGteXz9NrxbtRId6XnRS6Cm27EvUbLjPcOy6oyz0Ojn9RyeczoGOwuYARxY8zdsOmwcyNDuPmnrlDjcInGw2YFDLRKHdH8PtkiEq0WkAFCQJdA3W+J7jr9hY/4FaMsfiT7ZAn1zUpCXDgjRCaBRTScAuRfYsRfY4WXfxd1GoftxV43wXS88gNoRN9mua86T7OY9mKyrTe4QqXh/fxY6jqy2bhynxvY5G52p2dg96BI05Q0DNm3CKQIYWyLxdUMW3tregvWHBU7YXPu2Tgde+XQ/Xvl0P3pkCpxVmIZzB6ZhNLYiraMZDfmnAiJyhc4jvnocg/b817DsSEEJPsuZDfn224blJR2p0Hf0UfPemzjefRd8wc9YK+aJFfMkbBgn+4n3ohXzxKqxsRGvv/EWPtjbgbyt6fie7rVTU7YDujigR6bAjCFpmDo4HXkZ7RFN5+jNlYb5Y91GYvrpozBdtPm8D+EYhfb385DeoQpGu8nj+NGADTiaf6phvcbGTuTl+b7fSMhp2o1Bu1fg6xE3w5Ea/CB6uY0zgWpXAfPpbZ+gfOg2tOTY1wg358nwr98DdM/rm/qU4I6xDgCxlW+ByjwxE80b3sPeARdhX+F0DEvLxd2mc/P3PknpbEN+w6doyS5ES05kBtR2yDTsOXQUF29+EN0dzYbX7mm/HevlqK75zfuP46kD9SjT9QRy/PBe1PjxmcnPWCvmiVWs5EmiFzCHUj600a2llF2lTUKIxVADlZQKIebra2gEStvHEkD1LRepvlTYl40V8wTAW78CNr+iuoXI7I4NWZMxbuo9rte3jAEOftE1O2VEd+Ck86KQUJPnnjTOF03FxEtu9n8/J2UCT74I9DsVGH0x+p18CfoVnm6ohfz+e+uRmzXQ776QA+Wqhax1Z9Ert6sW8oD8LGSmpQLv/RGoeh2lh1cDJb8CzrjVOqqxv/LvAV50dYsx+MjbGDz3MSA927Kq5b3z3sOG11OGTcGUGbODS0+sOf98QAjYjRk+DcDI1asx+exz8drn+7G8Zjfeqz0Mu2EQjrZKvLW9CTP2LMXE1HcAAO0nXYD065ZFpkuRtY8Ce4xNZtH/NPS66SWcn2nTZ/SAxUBHi6rJnNUDJX1GAxm5Ph2Kn7FWzBMr5klcSPg4GeC9aCfp80RK4JEzgfQcIKs72tLy8MOm67HmQAcON7ahWJyE7+kKl04V2wAAI/vmYd55Rfjm+AEqbou04weAd9YYFnX/xo8x9ZRp/u+rYTbwxYvA8AuA0RdjwphZQE6BYZWYu0/amoEn7gMOfoEBHTuAOX8H+o4Jfr8HngV2fdg1Oznlc2DqdbarGvJESmDjPYbX+51/E/qdMjX4NMWSmWUYIQRGuHnZr/tk30Zg2XVAw04gJQ345iPAuKtClVL32pqAJy8GHIcNi5dm34RXTpxpWX277Id72m7HMeRAZPXAI9dfiKn9T/b5cDH33okBzBOrWMkTFjD7SEq5HoClEyQp5UIhRDGAUgBzoAW8RAmjbitw4NOu2Ywxo4yvF44zFDBj34boFzDXbQM2rTAuMzfr98GJ9k7szhyLg7PfwJetvVRfyK83Y1fdGpu+kL90ux9/CQEM6JGNwQXZGFqQiyG9cgxdWfTMSffchHLnh8Cqn6v/O9uAV74PNB0Gpt0XXMJOuRx49T5X32Et9cDnLwLjr/G+bSJ3j+HkQwF+dkYqLpswEJdNGIg9DS14Yf1uLK/Zje1HXDUg+qEOFRm/x/gUV8359G1v4v2Hb0DrRQ/j3FFh7EJj88vqGut1GwBc+xxgV7gMAKMuDE9aiChuME6mpNXeDBza3DUrZTqeb70Wzlqnm+QQOKRAilBPlItS9uOp68fg3FOKItodhsVHFSpGdMofCoy5JLB9zfg5MPshICMnNGmLhFcXun6/HNoMPD4NuO1d/7p+szPxFkMBMz75BzD9ftvKGAaHv3R1yQcAqRlqrJJEE6p7/rPngRfvUBUcAMDRAbx0J9BjIDBsSmiOYcfRCfz7VmsXciU34ZbZD+HC+ha8/sUBvP75fqzbXgeHBI4hzzXwdzOwXQzCKOueiRJCohcwOz+lCzyuBQTb0/piqMDZ2eQvUsclCr8TxwyzHWmmmomDJgIHN6mC5sJxQNHUiCXNrbWPANLhmu97CjDcOoiElBKHG9sM/R/vOOKuL+QDIU1iXmYaBhfkYKg2mJ7PfSF701wHLL/JOGJ5Vj4w4frgE52erfbzwZ9dy6qXei9gbjpsDLYBYPRFwacnzg3Mz8ZdF4zEndNGoGZHPZbX7MaujW/jIfwWfYX16+HsY69i8TM/RXnOHHxrwkBcUTIIo/q5KfQNxJ4a1e8ydNWqM/KA654Dukem2SERRRTjZKJgmeLkYzAWJLYgC+vkaHTP64beIyehz8hJOG9kYegK2gLR2gisW2pcdtZdQGqARQPd+gefpkjasAxY/5Rx2ZhZatyVYI39JvDqD4EWrYv5Ew2qMHSCfS3mLuaBsIed6/7BfjJzOIC3fgm88zub19qBZdcDt74R/IMCd177kbXSzIhS4OLfAkJgcEEObplyEm6ZchKONLbijc0H8VDVl9h31PWb8nBja2jjd6JYIqVM2AmquZ4EUOthHQmgJsjjFOn3E8rjlpSUyEiZO3eu1NIlAcjq6mpZXV1tWLZo0SIppZSFhYVdy4qLi6WUUs6bN8+w7p49e+SKFSsMyyoqKqRUGdA1zZ49W0op5ezZsw3LpZSyoqLCsGzFihVyz549hmXz5s2TUkpZXFzctaywsFBKKeWiRYuCOqdZs2Yl3DkFfJ1GpUm5qLs8b+IpkTmntR8Yz+kHd0vZctS3cyrvI1dcnW1Ydu/PfyOffHerYVnuyEly6MKVMnv4GYblQxeulAUz7zIs63PF/XLgHX83LMsbN1MOXbhSZvQb3rUsNa9ADl24Uuafc41h3fLHXpCPPPHX8F+nCYVSLuouZ49KC/91mpcrq+fl2p5Tr169XOc0ZpiUi7rLecXpfD95OafOR8+VFbOzjOd0dbbcc2+e7b3XY/Co0J3TwAxeJ55TTJ7T3LlzZSQBqJYxEMeGewLjZL8xVmas7PGcRqXJ2vtHWeLK3fXN4Tmnt18zntPCe6Rsb/XtnO7Ns8TK4bxOI0eO9O2c/row/NdpdGZkY+UfT7Q9J0OsPKQbYzBfz2lRD59i5bCcU2FKUNcpe/gZ8qVP9iTHdeI5JWWsLNRriUsI1R5JSml5TKyNYl0L4EEp5cIgjlEMoEa/n1Add+LEibK6ujrQpPklVvptiSXMEwCPnA0c/LxrtrrkocD6MvaHw6H61DI/IQaAtCwgt4+a8voCfU8GSn+mbSax6b+P4pR1rib++2QBzmv9A9rD0GAjLzMNQwpykO1oQsnooZ5rIbefAJbOAPZvBPqdBsz5G9Bb1wNZa6OqeT3lHiA1PbAEvfdHoOqnxmVn3w1c+MvA9ufOU98Etq52zZfcBFzyB8MqhvfOv64DNuv69D1/ITDtR6FNU6w6tAX4IC5m8wAAIABJREFUtBKY+iOsXrPG++dJ3Vbg8QtU9yMAduZPRs+Gz9ANTV2rtMgMXNV2PzZKV+2MjNQUzBjbD2Ulg3DuyN7+daGx9xPg6cu6jtll9h+AifaDOIYKP2OtmCdWkc4TIUSNlHJixA4YRYyT/cP3p1XS58mudcBSV1cGGxxF+GbbLzFhSD7+fvMkdM8KMKbz5tCXwBOlQOtR62tZPYDcvipOzu0DFH8bGKFryfdEKbB7nWv+vB8AF/wkPOnU+HSfbH8X+PslgHQAZ38HmP5TY0y8/T1VIzjQbtbamoEnphu79kvLUjVe+5/qfjt/1W0FHp5gXDb/bWDAeMOirjw5fgD43Wio8iLNPV+o7h4SXWeH9htBAqdc7tt98u4fgFWL1P8p6cComcbfGYCqAX7986EZu0RK4M1fWGtNdytU946X6/STFz/FM2t3ds0vumQsbjrnJJ8Pn/SfsTaYJ1axEisnehcZALAKamCRYqn6h9NzRgPLPO1AG6CkQuoGLTFxZuyvQ3lcopjQ6qWLjHDYttq+cBkAOk4AR3epCQCaDqO5rQP/rtmNpe9uw/YjQzFePIB5aSvxjZR1eLJjZsCFy772haw+0L0M1lB1vypcBlSf1kvOBxasUU24ThwD/jEH2LVW9QN3+RL/mynq+112GnQGMH2Rf/vxxcRbjAXMG58DZjygBoI0a28Bat80Lht9cejTFGtq3wQ++Avw9So1P3gyAB9+ZBYUqYcPT38LmPJdDJn2Y8jt78Dx9BVIkR0AgGzRhicyfofLWh/AXvQGALR1OvDyp/vw8qf70KdbJr41YSDKSgZhpC9N8N79vbVw+Zz/CXvhMhHFBMbJRMEwFfAek6of4jH9u4WvcBlQ3QTYFS4DwImjajrylZo39+U7dyWwcRnw/p/UAGmT5ocvnb5qOqy66XJ2cff+w8CRr4Fr/qnmt74NPHuV6mv36n+oQkV/6ftddrpocWgLlwEVyw2fDtS+4VpWvRS49E/263/5KgyFy4XjE79wufU4UP0k8NES9ZuuxxDf+wA/53+AA5+pe+KqZ4DBk4AXFqh72mn7O8DKe4Bv/jn47miO7gI+rDAuy8hT45P4cJ1652Ua5o80trlZkyj+JUMBcwVUoLpAm/TmAFhvDmy1QPmIlPJBbdEybT8zzDsXQuRD9S03R0qp7yvO7+MSxSRLH8wRGMCj5u8+r/p1czbK/u9NNDS3dy37RI7Ane3fxRBxAHXScwFbbkYqhvTKxZCCbAzumYOhvXK0eTd9IR/dDWypBDZsAmb/3rdEfvGSCqD0RkxXAWhLA/CPMldNks/+rUZCvuxRIMXHUcXd9btc9mTgtaE9GX2xemp/fJ+ab29SQd2kedZ1t65WA+A4dR+o+upOdJ886ypcBoC1jwKDv+PbtkVTgbvWdfUfJ4qmQlzyELDCNVBlX9GApRm/RVnbIjSZ+ns8dLwVFWu2omLNVowb1ANlJYNwybgByM9xU4vjskfVD7sd76n5ybcBpT+3X9dO0xH10MT5g7ZbITDS8nVJRLGJcTJRMExx8nGoOLmPqVAppBoPWvvs9SS3j3E+PQsomQtMuEG1UszrG7q0OTpVTLv5ZWDABODUb/mwjQN4fj7QuN+4/Ixb1N+v3wD+da2qZAKofnav+ad/g+DZ9bt82hygeK7v+/DHGbcYC5g/Xa5aFGb1sK6bDANhm3W0Am/+EuhsVfNHd2r5YFNZxUwIVVjfUu8aI+RS7WHJzg9c633yjGotOuWe4NKaPwS4rhJ45gr1myajG3D9cqDwdJ8275WXidFiJwpFHbqjGcN3VANHbwF6DAouXUQxKOELmKWUy4UQSwDMF0JUSSmXA4AQohyqRoVhxGshRCmAcu3/VVLK9VLK9UKIIiFEJVRAXA01MIkzMJ4jpVyl34+/xyWKSQ6HpQZzZ2qYC5gbD1qbOfU7TRVcNR10BZeadYfS0NDRDjs7ZT8IAQz0oRayV53twNILgb2637tTvquCDk/qtgEv3W1clj9UBUJCAG1N6pz1Ni5TTb4u/ROQ4qWrA4dDPbU/tse4/PIKIH+w520DlZqmAvK3/0/Np+da7pMujQeAzO6u10dfFN2BbSJl8u2qawyn2jeQU3C5a/6Ll9QDhv6n2W9vHpyk+NuqJs97f+xadHLKTrw46Fnc2nI3dhxphp0Nu49iw+6j+MXKTe670MjIBa5dBjx9OTD0HNXljD/XaOcHqksbp1EXsYCZKE4wTiYKkin+Oa7VYO7TLYwFzJ88q2ryOmXlqwf4TQeB5iMwDHQNAHmmAmanlBT3cUggvnwdePF2oPmwmh8+3bcC5vf/aCyMBYAp97oKkI/vM8b/nW2q+7Vrl/k2uPihL1VtVr1eI4DZD4UvJh05U10TZ3zeY5AqADXnt5RaRQyBrlrMydDSL7c3cPqVwMdPu5Z9+BhwUrn6v71FVc458077Vp3p2WpySssErvqH6gKlfptr+aqfqTz352GEnaFnq4caL9ymatAP9P0rqnduBn6Y9k9MS92gFuwFsH8yC5gpISV8ATMASCkXCCFqACwQQjwOoA7AegAnmWpTACooXq9tp685sRDAfQCqoEa1rgZQJaV0++ni53GJYk9bIwxNttJzIT3Vqm06Auz7RDUlKrkxsGOag+ZeI4Hb3oFDAm9vOYhn3vkcX2/bht44it7iKPZL4yD06akCl4wbgEvGDcCwXrn2tZADkZqughe9Lf8FJpsrXul0tAHLbzY2YUxJV10gOGsw9BgIzP0P8LdZrm4/APXUPTUNmPWQ50Lm9x8GvnrduOzs7wCjv+HTaQWsZC6w5WVV0Hz6VfbdYwDqPhh3raodu+UV4JTL7ddLNINKgEGTgN0fdS0auGcl4LgOWP1rYM2D6uHEvNVAbi/f9jn9Z8CRWtcDmLx+GHn5j7F6QDGqd9RjefVurNy4F01tnZZNvXahkdlN3YdpWf7/2DJfe3cPG4goJjFOJgqCpQazKvSyLWB2ONTD4n0bVCWAIWf6fzyHA1hvaul33g+As+/SXu9ULduaDqoKDE2HVGFqJPQc6ipcBoBta1T+uIsRAWDnWuCNXxiXDT4TmPZj1/yE61Whsr6QuOME8OzVqibpsCnu99/WDFTOVa3tnNKygDl/V7FPuKSmqZZ9ez9RtZmHnWsfXwmh4q/jB1RXGbs+AvqdEr50xZIzbzcWMO94D3m9twJHR6ga6/s2qPvX17FkcnupbiuWlqqKSQBw8qXAkLNDk96iqcB3PjYWbPugV14m9sNUQYuxMiWopChgBgAp5RIAS3xYrwE2tSa0mhXLw3Vcophk/vJzFyC2twB/nqSaNwGASFWFjn5+AUNKS9DcPv4GLF+3C0vf3YavDzZqS/tjB/obyr57ZKfj+jOH4NtnDUO/7ln+HddXoy82Nr3a/LLnAuZVPzPWeAaAC38BDCw2Lus51FXIrK+JXPM31V3Gxb+1D0p3rgXeeMC4bNAkNShKuHUfANz2rm/rpmUAw6epKZmceTuw3FXA3H//m8C/rtH62oOqyVI5F7jhBd+6MklJAb61BHjyYvUQ5tplQI9BEADOGFaAM4YVYNGlY/Ha5/tRWb0bH2w9AvM4vt3RhEPH4epCY3A+ykoG4dLTB6BHjp/vVydzc88TbvqEJKKYxTiZKEC+1mDesAx4+V6t8gZUoWkgBczb31GDyDmlZgDjrnHNp6SqGst5fSJfUNl7FFAwHKirVfOOdtVdmLtazM11Wr/Lugfj2T2BsqXWWqsTb1aF569837WsowX4x5XA9f8Ghp5lf4z/ltv0u/xg6PtdtuNP1wzd+qnKGyVh6rIjFvU7BTjpPPUgQjPi66XA5l+pgmVA9RPe71Rg3NW+7bPPKODKp4FnvqUq3Fxwv/fWoHodbeq+zXAz5pC/v20B9M7LwJfSVMDMWJkSVAiq9RFRwjJ/+WW6KWBOzzZ+ectO4MAX9ut60noMGFCsgmUAHSId33hrEO57/lNd4bLRsF45+MU3T8EH912AH8wcE77CZcDaJ9qO91QfynY2vwKs/Ytx2ehZqn9bOwUnqULmvP7G5eueAF69D5aSwuY6VTvaEpT/NTz9LpP/Tr5ENY/UpDraXIXLTjvXAntqfN9nRq7qB+7mV22b1uVkpOHyCYPw7Lwz8U75NHxvxigM7aWC2tkpH+CdzP9Bsfiya/0Nuxpw/4uf4Yz/XYU7n12Pt7YcREenw7Jfj1jATEREycr0nefsg9k8sBfy+roKlwFVOzMQstPYzcLJl/jeEirchADGmLp3cDdot5TAi3cAx3Ybl19e4b7rgEnzgJm/Mi5rb9IGyl5nXX/DMmMNWQA47UrV7RjFhjPvMMzmH/3MVbjstPYR9XDBV0XnA3d+BJQu8q9wuf0E8NwNwD+vVpWnQqRXXiaOwVRgfYKNdCgxsYCZiNw74WMNZsA6cNu+j/0/XlYPoGwp9ty8Hn/OuBlL2i9CbbN9gfGkYQVYckMJ3vjeVNxw1jDkZESgQUav4UDv0a55RwfwVZV1vYZdqg86vR6DvY9k3Gu4KmTONQ228uGjQNVPjYXM6TmqP2O9yx4LX7/L5L/UdOCMW92/ntsHuHGl/zWY8vr61KxzUM8c3D19JFZ/fyreLN2LhzP+gh6iGX/LWIzTxFbDum2dDry8cR9uenIdpv/+bWw9ZP9AxxYLmImIKFm56SLDUsBsjpMPblIFWv4afgGw4B1g3luqm7KJt/i/j3AabaqM8eXrahwTs7WPAF/+17js7LuBUTM97/+sO60DEbcdVzVW95haDfY/TdWqduo1Mrz9LpP/Rs4Eep7k/vXRs4AbX/Z94HMn81gm3rQ1u1oZblujBpLsaPVvH250z0pDkzAWMLc3sYCZEhMLmInIPXMXGe5qMAM2BcyB1czYvP8YLv/bFvz2WCke7DA2h0pNEbh03AC8dOc5eO62s3DhKf2RmhLhINFcM8M8IGFnu6pZrH8ynZIGlD0J5Bj7i7bVZxQwdwWQY6qN8v7DwJu/cBUyp2cBs36n9pvRLTL9LpP/Sm4E0mya0xWOB+avDqx5rCdtTUDTYcMiUfM3FL37faRA1UzuLlrwj+zfIA/2AwPuONKMRSs+9/2Y5s+F1mP+1TQhIiKKV6ZY+ZjMQVYqkJtpqviQU2AcGNrRYe26wVdCqO7WLn0YGHZOYPsIl8GTgJzervnWo8B2U5dqu2uAqkXGZQMnAtNNy9yZ8l3ggp8Yl7UeA56+zPj7o99YVRB/+tVav8t/AzLzfD4VioCUFPetO88rB656JvR9ZTfsMs63NgLPXgnUvula9vUq4PX7Q3I4IQSkKVZubawLyb6JYg0LmInIvaBqMPtfwFyzow5XPvYBDh43PjHulpmG+ecVYU35NDx8zQSMG5zv975DZsxs4/zXqyAcupoZb/7SMLAbANUn8uAzfD9G35OBb7+kurzQe+d3wNuLjctO/RZw+7uR6XfZm84OYNNKYHc1Mk8cUv2YJbucAmtTzNP+n737jpOruu///zo72/uudiXQqiAJENgUNWzANhYgjFtcEdjGNRiwndhOnF+QSeLYcWJj4ZJ849gxEMctdqiuxIktyYhuQBIdRFNBBUnbd2dn68z5/XFnd+femdkyOzN3yvv5eOixe+7cuXN0EbOf/cznfM6lSVtczEnfK05/5p9dNrm074/fgzv/wn2eCVD/rm/yf5ve5mqhEeveFzrYfWSGG5CUBJwPOWIN96fwFxAREckzcRXM1TRUJCl+SFMxRk4rCcQXPMS2yRjsgds/6vS5HVfZMPsWb+f9Nbxxk/vYUC/8+F1wNOZD8opaePf34JMPZKfv8nSCx+DB70AkTOXgK37PJjesvtxdWFNWA5f+GC7429m1uJiJp38B/7YOHr7JGQ/1OtXv++51n9eyEt7wufS9rud36NEBrfaTwlQ0m/yJSAoio04rhtFopeOUFcyr3OOjzzgJxtLyGb3UXbuP8cmf7mRo1N3/9R1nLuQr7z6Nusoc6Su8cI3TJzl4xBmPBGnqfhK4yGmXcf+/uM8/6U1wzqdn/zrHnQ4f+iX8+B3ulgPbr3P68J4bc82mE2Z//XQKtsOO/3Q2aOw7BCe/mVOPvgyPfg5O3OD0rl75luQbZhS6i74MkTF6XniQxvM+4SSc070888iTTmJ5fJPIX37S+X9yq6caqKTM2TznVe9kEfDpC0/izy84kR37u/nCL59i95HJxPB/3LuXb2z0/DKcTGWDs0R13FAvVPn4QZCIiEg2GEPElFJixwBnk7/68ikSzM/+ZnJciAlmcNoaPPpfk+Pdv4XVb3VW4f36z51NjmO987vOhteztf5aZ+Xgfd+aPDbYBT96B1zx+8k2CcbMvmVCuu1/EB6+0fnvHxmFyBhnP/T38NK3nE3ET/0TWLTO3zn6paIO3n8L3P01jvWGmH/JN9K/QaW1TqHOH/7RGf/vJqeQ58F/g8Oeto4LTnN+B6ttTdvLl1Q1QUz3uUiyPXxE8pwqmEUkuVUfgL99Bb7QAdfshQ1fSn5uTQvUx1RkRkah/dkZvcyvHjvElT/eEZdc/sg5S/mXy1blTnIZnE/SPZUZ8zofcr6paXX3Eatb6PRFTvXT94Wr4EO/cCf2KxvhhNendr1M6d4H2786mdx8/nc09O52lis+/XO44woIdfo6RV+VVcLbv8Vjq69zdgfPRO+/uzdP3n9wKjS8yeVAubPU8FXvdB02xnDWCc38xYaTXcd/9dghjvbNsD+k+jCLiEgx+uid/OYdj3PK0A84a+g77LZLpqhg9hRjFGqCefl6d3uwvoPUBvc6Sb6Fa8DE9NN97Sfg1Ld7rzAzxjgr+M71FHIsWufaZDknPPoTJyYer9zeFk10djzvFKfc9RX/5pYLFp8FH7yDZ169Kf3JZXA+1Lg35oMIG3Z+P/Eml49fFd10PX3JZYCyGk/RheJkKVBKMIvI9AJlzlL/6XoIe5f+HX5s2kv/8P697Ljtel7DkxgmE8x/ueFkvvSOV1OS7R7LM+HZwKSl42GIRJyE8NV3w6vfDabEqRSd687ebWvhg3dAea2zfOyjd8LC1XO7ZrotWufe0Rzr+m/JgtPdfQcl/d75HWg9JfnjpVXw/pun7NN90asWuNpljIYtP3pg38xeXwlmEREpUu3BEYaooJ0mRimdeYuMo08n3gDPK9QFd10HvQfnPtlsKK92NiOM0dLxkFNw8YbPwcd+6ySAj1/lrPKaC2Pgon+E10Y31z7l7XDpT5wP93PJWZ7NGCOe/+4rPXu8SHo1LXV+L2OK3ysXvSa6D84M9syZpco69zUDIzNsQyeSZ5RgFpH0mUVvOWst3/r9c/zzbx7m70p/ys/Kv8pd5X/FJ0p/zVfefiKf3XASJld3eV52ntMfLKpipAteiX4CXtngbLx31XZYem56Xm/xa5wk80fu9CRyc4QxU+9i7t0YUdKvsgE+cIt7Y51xZTXwwdvhxAunvESgxHDF6907ef/0oZcZGB6bwesn2OhPRESkCHQE3XtOJE0w186HuuMnx+FhaN89/Qs8fjPc/TX4l9Php5fCnu2pTzZbPLHfxGo/cDY4/sR9zqqq0oq5v5Yx8Obr4B3/5mzkN8P2fFnVtja+gj2WEsyZt/It8KZ/SvzY0tfDh34eXzCRJtX17n11Ske1V4kUJiWYRSR9ZphgDkcsX/jVU/zrH17kPYF7qTDOp/gnlBzl0/X3cfm5J2V6pnNTVhmfrNsds4GJMfH3Yq6WnO3shp2rTt8Yv9HbuJVvye5cilXTCfC+n0Eg5pe1inqnzcoM26pcsnYRjdWTLWl6B0e5bceBKZ4RpQpmEREpUu2ezakbkvVghtlv9Gct7Pxh9PsIvPA7OLRz9pPMtpPf7Kzmi6oL7nX3Xq5uhsbF6Xs9Y2DNh2a3UWC2eauYxx1/JjTkWEuPQnXOn8Haj7mPLT8fLr/N6QWdIbUN7gKQynDQ+X9bpMAowSwi6RO39O8pCLurH0fGInz25kf5rz++DFjeF7jL9XjNOX+a/h2DM+EUd5sMdv+PP/PIFRW1cOb74o+PL4GU7FjyWqdaedFrnID5Y791js1QdXkpH3yte6Od/7x/H+HINEGwEswiIlKk2oPuBHN9sgpmmH0f5gMPQcdzk+OSUlj1wVnO0Ac1LbDYE3/EFmMUo9PeCxUJKmQ9rfckg4yBt34dXv+XMP/VcM6fOy3kyqunf+4cNNXXMWxLJ8aldhTGZrjPiUgeyYMsjojkjbrjoGb+5HhsyNm8Iio0MsYVP3qEO594BYA15gVWlsT0kzMBWHV5tmY7Nye9aWKTklBVG5z8prhketFJVJmx8i2Z2dROklt2Hnx8C3z4lym1VPnwuUspD0yGBy93hfj900emfpISzCIiUqTiKpinTDDPsoJ5vHp53MlvhroFM5+cn8bbPpSU0dW02llpVczKa2DV++OPq5VcdgXKnI3rP/UAXPyVrPTrbqmrpA9PEluxshSg0ulPEZGi9dtrYKjHWWZf2eDs9DwVY5yN7l74/eSxVx6DBa+ie2CEj/3wER470DPx0AdK/+B+/sq3OEnqfFDdDO++ARau4uGnDrF+/Xq/Z+S/+afC0tfB/vsnj52S4s7g4pv5dZW8a/VCbt0x+eHPjffu4S2nH5/8ScvOc5bCVjY4f1S1LiIihe7YbrjrK3yiJ0h7aQXP20XcGj5/di0yjjwJkTCUBOLPHeyGp3/hPuZd3p/LTnsPNCyCEzfwxB93sX7ler9n5L91V8BD35scNy6FBaf5Nx/JipbaCr4/9lZKiNBPNbainn8qr/V7WiJppwSziCT33G+hN6b/6poPTf+c4890J5gPP8aRZe/hQ99/iBeOBScO1zPA2wN/dD83n4JmgDM2Rr855Os0csrbvgk/fBuEOuGMy2D5er9nJCn4+BuWuxLMj77cw879XaxdmmRn7WXnOX9ERESKRe9BePbXvBOgFO4Nn8at4fOnbpFRv9DZkDfU4YxHQ85qv/mnxp/7xK3uZfQNS2DF+en8G2RWwyLnj0xqPRnWXwvbv8ZYoILSt35DK/2KQHNNOd8Lv2NiXDII/1BWQ4KPlUTymhLMIpLcUJ97XFE//XOWnQf9rzgVjMefyb7SZVz+7w9wqGfQddonmndSGYrZdbthcX4FzZLY/FPhr57nga2/5tyL3+P3bCRFJy+oY/3KVrY/1z5x7KZ79rL2Q0kSzCIiIsVm2L3EvZ9qGqrKKCuZImFoDKz5MNiwU5Rx/CpoWhZ/nrWw80fuY2s+lLjSWfLL+s/Da67igQcf5ryT3+T3bCQLyktLaKgqo3fQ2dg+YqEnNMK82oppnimSX5RgFpHEIhEYTjHBHK1kPNY/xOXfiU8uv/aEJq4O3wOhmINrPqyguVAEShmpUCIy3135huWuBPPvnjnCvo4BTmip8XFWIiIiOcJTiNFvq2mtqwCm2Rh3wxenv/bBHXDs6cmxKYHVebC5n8xMdTORQOZ7/0rumFdbPpFgBugIKsEshUeb/IlIYiP9uALkshoIzPwzqdDIGB//0Y645PKbXrWAH785QKD9mcmDCppFcs65K+Zx6vGTHypZC/95/14fZyQiIpJDhrwVzFW0pithlGhzv/qF6bm2iGRdS437vaEzOJzkTJH8pQSziCTmbY9ROYPq5ahwxPLZmx/jiYPuwPs9q9v47uVrqHj8J+4nKGgWyTnGGK46z71s99YdB+geGEnyDBERkSIynKyCeY6GeuHpn7uPrf3o3K8rIr6ZV1vuGnconpYCpASziCSWSnuMqH/6n2fY8sxR17E3ntzK9ZecQeloEJ66w/2ENR9JdZYikkFvP2Mhx9VPLuEcGo3w04f2x59oLQx0QOdLcGgn7L0ni7MUERHxgbdFBmlKMD95m7P537j6Njhxw9yvKyK+Oa4ajqOTk8xB1prnGDnynN9TEkk79WAWkcRSrGD+wf17+cH9+1zHTj2+nu9cvobSQAnsUtAski/KAiV89HUn8LX/3T1x7IcP7OfK85ZTURrTMz08Cl9fMTk2JfD3XdoZXURECpe3gpkqls+1RYa1sOOH7mOrtbmfSL47L/i/fLHy6xPjR/e8F9AG91JYVMEsIomlUMG85ZmjfPlOp7dyPQOcU/I0n6v5P+44/ifUlkcDY29PudUfmlVvZxHJrve/Zgk15ZO/2HYEh/nVo4fdJ5WWQ1n15NhGYCSYpRmKiIj4wFOM0TebFhnWQtceeOrnsOWLsOvHzvHDu+Dok5PnaZ8SkYJQVtvkGhtPD3eRQqAEs4gkNssK5icO9vCZ/34UawEs91V8lv8u/wqfCf+Y6mduge59TjC94Ytw6p+ACQBGQbNIjmuoKuOys5a4jv3HfXuw1rpP9H4IpcBZREQKWVwF8ywSzE//HP51Ndz+Mbj/XybbxzUvh4uvg5aTnfGJG6BxcRonLSJ+qPIkmAMjfUnOFMlfKhsUkcSGPcmhyoakpx7sDvGnP9zB4Gg4esTwjF3K2ebZyZNeeRyalzmB8okboP8I7LtPQbNIHvjY607gRw/uIxxxksrPHw1y9/PtrF85f/KkygYIHpkcD/VB8rcNERGR/Jaogrm2gmMzee5xZ7rHrzzuFGJUNcE5n4KzPwkv/xFK09DTWUR8V93Q7BqXjvb7NBORzFEFs4gk5q1gTtIio3dwlI/94BE6gsOu4w3L17lPfOVx97juODj9krnOUkSyYHFzNW857TjXsZvu3eM+yfshlCqYRUSkkHmKMfqppqWufGbPbV4O5XWT48Fu6D0wOTYGlp4DbWvSMFER8VttwzzXuDKsVnJSeJRgFpHEvD2YE7TIGBmL8Mn/2skLx9w/IK9+43JOXXOe+2RvgllE8sqVb1juGt//YidPH4755dr7HqEEs4iIFDDrKcYYoJp5NTOsOC4pgePPcB87/FiaZiYiuaahqdU1ro4owSyFRwlmEUksroLZXZ1oreVvfvHm9A2HAAAgAElEQVQkD7zU6Tr+ttOPZ9PFp8DxSZb+iUheOnNxI69Z5l7e9/17904OvBXM3g+pRERECoW1MOxe4l5a3UigxMz8GoliZREpSHWeFhl1hAiNjPk0G5HMUIJZRBKbpoL52394kdt3HnQdW7OkkW9eeiYlJQbmnQhl1ZMPhjqg71CmZisiWeCtYv7144d5pXfQGahFhoiIFIuRAYwNTwyHbBlN9bWzu4YSzCJFw1TUEY5Jv1WbYTp7B3yckUj6KcEsIom97ZvwmUfhqrvhI7+B5esnHvrFowf51pbnXacvnVfNTR9eR2VZwDlQEoDjTndf86EbVMUskscuPGU+y1tqJsZjEcsPH9jnDOISzD3Zm5iIiEg2lVVz7zvu5cLhr/Pu4X/gY6PX0Fo3yw35vAnmF7dA/9H0zVFEcocxhEy161B3d4dPkxHJDCWYRSSxygZnA5KFq2DZec6mfMDurjDX3P6E69TG6jJ+8NGzmFfrCay9gfMD/wrfPRu6PJuDiUheKCkxXPGGZa5jP3voZYLDY/EbgXrb7IiIiBSKkhIOjTXykm3jUXsSD0ZeTUvtDDf4GzfvJCitch/75slw51+mb54ikjMGS9yrHPq7O5OcKZKflGAWkRl78ViQbz86xGh4sgq5PFDCTR9ex/LWBMsCvQlmgFAXNCzO4CxFJJPeu2YRzTWTv0T3D41xyyMH1CJDRESKSnv/sGs86wrmQCkcd1r88crGOcxKRHLVSFmdaxzsVYJZCosSzCIyI53BYT72w4cZGHUf//rGMzjrhObET0qUYF59OQTK0j9BEcmKyrIAHzx7qevYf963l3C5t4JZCWYRESlc7UFPgtm7km8mGpfGH1vz4RRnJCK5bKzMHSsPBbt8molIZijBLCIz8m93vciBrkHXsb++eCXvXNWW/Emtp7g3+gMFzSIF4MPnLKW8dDKEONQzyI4jYfdJSjCLiEgB6/AmmGdbwQyw4gL3ePl6aF6W6EwRyXPW005uONjt00xEMkMJZhGZkftecG9CcNm6xXxq/YqpnxQog9d9dnJ89qecvs4iktdaait47xr3h0t3PNPvPmlYPZhFRKRwxbXISKWC+bT3QNMJzvelVbDhS3OdlojkqJIqdzu50QFtiC2FpdTvCWSLMaYRuBZYAzQDW4FbrLW7ZnmNq4CzgOXAHmCLtfbGJOfeFh163znGG2ttttZunc3fQyQrRgbg3m86m3ZV1mOr53Gg271xyeffcgrGmOmvtf7zcNKbwFpnw0ARKQhXvH45//3wgYnx/UfL6D75YpqaW5x+zE2qwBLJF4qTRWZp7z28tfOnnB4oo58qnogsp7XuvNlfp6wKPvVH2HcfzH8VNEyxMlBE8trwcWv5zb4j9Nka+qnmUGSR31MSSauiSDAbY9YA24BNwHU4Qe+1wE5jzEUzCV6NMRtwAuHYXRfWAJcYYzYBa6213gB5wzSXvWGGfwWR7Ap1OgnmqEjtcQyNfmtiXFdRSmP1LPoot61J5+xEJAecOL+WC0+Zz7bdxwA4RCs3Lvwym958is8zE5HZUJwskoI92/nY6M0QDYe/NXoJrXVXpHatsio46aL0zU1EctLIqo/w6XsnVwCvHKmb4myR/FMUCWacoPnGmAqKXcBGY8xLwBZjTFOCoNdrM04lxpXW2l3GmOXAJdHjy3GC6kSRwVqcShBwB93j8xDJPUPupe0jgVrXeHFz9cyql0WkoF182nETCWaAg92DU5wtIjlKcbLILI2GeogttQiVVNNQpU2sRSS5Fk8bnc6B4SRniuSngk8wG2OuwQlYE1VB3A5cA1wKxC3f82gELrLW7gGIfr0+mmTbTJIqjNksLRTJGZ7eqYMlNa7x4uaqbM5GRHLUokb3e8Gh7pBPMxGRVChOFknNSNCdYKaiXsUXIjKl5hp3y8mugRHCEUugRO8dUhiKYZO/y4Ce8YDXY0v068YZXCfhNay1149/H11i6HrOjGcpkks8Fcz9eBLMTdXZnI2I5KiFngTz4Z4hn2YiIilSnCySgtGQ+5+vqfIW4IuIuJWXlrhWOkQsdIdGfJyRSHoVQ4J5Dc6SvUR2RL+um8F1LpzisR7P13FdM7iuSO7xVDB3hytd4yXzlGAWETiuwf3ecLR/iNFwxKfZiEgKFCeLpCAy2Osal1UrwSwi05tX665i7gwqwSyFo6ATzNH+b5AkgI3pJzdtRDBN77lG4is3msfnYIy5zRjzkjHGGmN2GmOumsH0Rfwz5A6aO8bc/aJUwSwiAJVlAVrrJt8frIUjvUMwNgzBYzCqnswiuUpxssgcDPe7hpV1SjCLyPScPsyWGgZppYeOoPowS+Ew1lq/55Ax0R2ttwBbrbUJt+Y1xlgAa21KjW+iQfANwNUxm6OMB+0vRYe7cIL3dUwG6VPN6SrgKoAFCxasvfnmm1OZ2qwFg0Fqa2unP7GIFOs9WbL/dpbv/cnE+Ee8nS8OfWBi/NXXV7GwtqA/n5qVYv13MhXdk3iFek++/OAge3qdquV/K/tX3ly6i1LrVGM8cfoX6ZrnXRU/qVDvyVzonsTL9j05//zzd1prZ1K1m9cUJ8+e/v+MV6z35PR7P868cPvE+B8WfJs3nroEKN57MhXdk3i6J/EK/Z5UDLVz2kOfpToSImAsh+w8frLyRs5emHxrtEK/J6nQPYmXK7FywW/ylwWbgF2xQXNUI9FduGMrNowxm3E2TNlgjLkqwfOIHrsRYN26dXb9+vWZmrvL9u3bydZr5YuivSdb7oK9k8P2MXfF8nsufiOVZYEsTyp3Fe2/kynonsQr1Hty66Gd7HnyCACGyERyGeCMlUvhtPVJn1uo92QudE/i6Z7ktYKJk0H/FhMp1nsSute958DKU09n/frVQPHek6nonsTTPYlX8PdksBv+OADRj2zrCDF/yQrWv35Z0qcU/D1Jge5JvFy5JypBnINoEAwJ+s5Za3dZa9d6Nzyx1m4CtkaHM9k0RST7PC0y+uzkRl6NFUbJZRGZ0Baz0V+fdW8I6n0vEZHioThZCpa1VIYHXIcamub5NBkRyRsV9a5hvRmkKxjyaTIi6VfoCebxoLV5mvNmvYu1MeYSnOV5F03Tdy6R8YB7+ZRnifjFs8lfv52sYG6tSmmVrIgUqIWxCWY8/dmVYBbJZYqTRVIxEqSEyQ1tB205LQ1ari0i0ygJMFLqfq8I9s76R6xIzir0BPP4piXT7bqQbPfshIwxa4CbgAu9lRczNP4cvZtIbhryJJhjkkYt1Uowi8gkVTCL5C3FySKpSBAnt9ZWJDlZRGRSuKzONR7sT7jPrkheKugEc0zFRMIKiJjds7cmenyK52zD6Rm3K8WpTWxgkuLzRTJrygrmgn7bEJFZiq1g7qfK/aDnl3ARyR2Kk0VSYz0fnvbbKlrrlGAWkenZSnebjJGBbp9mIpJ+xZAp2goT1RReG6Jfb5nJhYwxjTi7bV9prU0a9BpjNscE5YmM77Z43UxeVyTr4iozJpNGapEhIrFUwSyS1xQni8zSQJ87IRQ0NdRUlPo0GxHJJyVV7kVDYwNarCOFoxgSzDdEv16d4LGNODtbuyosooHvNZ5jjcBOYLO19nbvY9E/48HyLTGvi/dcnN5yG1PoSSeSHZ4K5ti+qq3VxfC2ISIz1VhdRnW5s/GnejCL5B3FySKz1NfT6RqPBGqSnCki4haoanCN7aBiZSkcBf9Rq7X2dmPMjcBVxpgt40FvNDBeB6yNPd8YswG4Jvr91pigehvOEsIbjDEJg+Loc5qstbuMMcuNMbfhBNA7cDZQ2YATwG+cqrJDxHfv/T6EOmG4j+t/9TAddvIHoSqYRSSWMYaFjVW8eCxIn1WCWSSfKE4Wmb1D1aeyaeTz1BOizoRoaGnjLL8nJSJ5obTGXcFcEQ4SGhmjurzgU3NSBIriX7G19mpjzE7gamPMTTibmuwCliWojtgRfYzxoNkYsxlItHRwKpuAa3GWCvZEr7vFWrt2ymeJ5IKl5wAQHB7juzdPJpfLAoamSiWYRcStLZpg7lcFs0jeUZwsMjtHxmq4N3LGxPjNLcf5OBsRySem0p1grjcDdAZHqG4uitScFLii+Vdsrb0RuHEG5/Xgqdaw1m7CCYRn83q3A7dPe6JIDjvQFXKN2xqrKDFKMIuI2/hGf3E9mIe1yZ9IPlCcLDJz7f3DrnFLXblPMxGRvFPpbpFRT4j24DCLm6uTPEEkf6iZqogk5U0w6wefiCTS1lgJqAeziIgUvvagO8HcWlvp00xEJO9U1LuGdSZEZ3DEp8mIpJcSzCKS1MtKMIvIDLQ1ORXMA1QStjGrHEZDMKagWURECoe3grm1rsKnmYhI3klQwdzp+dBKJF8pwSwiSR3sHnSNFzcpwSwi8RY2VEW/M/ShNhkiIlK4lGAWkZR5E8wmROeAijGkMBRND2YRmaGel+HgI1DRQPnhQywEDtMCwOLmKmfrHxGRGOM9mAF2R5bQEBjmVcvanCDaWh9nJiIikl5t3Q9xcUknfVTTb6tYULnK7ymJSL6onU939TL2BEvps9U8GVnGQL8qmKUwKMEsIm4v/xF+fiUAfwOcVnYOnxn9NABLmqvpUoJZRDyOa6ikxEDEwvtH/w5GYfcH3kxlWcDvqYmIiKTVJcGfsab8mYlxe/AUoM2/CYlI/lh6LndtuJPP3fr4xKE/UQWzFAi1yBARN8+mXP12si2GWmSISCJlgRIW1Ls3OXqld8in2YiIiGRGOGKpDA+4jtU3zvNpNiKSj+bVutvqqAezFAolmEXEzdMvtR8nqVxbUUpjdZkfMxKRPNAW0yYD4JCnh7uIiEi+6w6NUId7E+yK2kafZiMi+ailttw17lCCWQpERhPMxpgLMnl9EckATwVzn3WSRoubqzHG+DEjEckDCz0J5sM9SjCLTEexskh+ae8fpt64K5ipaEh8sohIAi1xFcxqkSGFIdMVzJszfH0RSbehxBXMi5uqEp0tIgLEJ5gPKcEsMhOKlUXySEf/ELV4fr5V1vszGRHJS03V7grmrtAI4Yg2xZb8l3STP2NMA3DlHK49D1gzh+eLiB+8LTKiPZiXNKv/sogk19akBLMUF8XKIsWnu6ebgJlMBI2YCsoDaiEnIjNXXlpCQ1UZvYOjAFjrtN/xVjaL5JukCeao64FUP0oxc3iuiPglroJ5skWGiEgybY3OJn8XlzzMJ0t/zfznRuDrw3DGZXDxV3yenUjGKFYWKSJ93Z2u8XCglvIk54qIJPSLT3KHeZDKin7qCLFx5It0BIeVYJa8lzTBbK3tNcbsig63pnDtJuDjKc1KRPyTpIJ5cbNaZIhIcm2NzntFnRlkVckeGMP5M9Dh67xEMkWxskjxCfZ1ucZjZbU+zURE8lbni5wY2et8zAzUM6A+zFIQpqtg3gF8z1r7WCoXN8asTeV5IuIjTwVzHzWAWmSIyNQWRiuY+6znvcKzcahIgVGsLFJEhvq7XeOINvgTkdmqdL9v1JsQHcFhnyYjkj7TbfJ3A7BnDte/bg7PFRE/xFUwO5XLi5qUYBaR5Ooqy6irLJ3YGHSC5z1FpMAoVhYpIiMDPa6x0QZ/IjJbnveNOkJ0qIJZCsCUFczW2kfneP2dc3y+iGRbXA/malrrKqgsC/g0IRHJF22NVfQdrXEfVAWzFDDFyiLFZSzkTjAHqlTBLCKzlKCCuVMVzFIApqtgnqsbMnx9EUmnSBhG+l2HglSpPYaIzEhbYxW93gpmJZhFpqJYWSSPRDyFGOU1jT7NRETyljfBTEg9mKUgTNeDOSljTD1wKbACSPSTtRnYkOr1RcQHw+7kcr+tIkIJi5u0wZ+ITG9hYxWPqAezCKBYWaTQjIYjBEb6oWzyWEVtk38TEpH8FFfBPMBzA6pglvyXUoLZGPNe4NbxIWCZ2AMTYsZ2TrMTkezyJIL6cRLLi1XBLCIz0NZURTCuB3M/RCJQkulFUyK5Q7GySOHpDI5QbwZcx0rUIkNEZqsivgdzuyqYpQCkWsF8W/Tr7cAWYCOwOXqsCbgR+CqgsiWRfFJZD2/ezJ2P7Obw0WMMUgEowSwiM7Ow0Vn10G+rqDOD0aPW2eivSsuIpagoVhYpMO39w/whvJoeW0udCbG0eox3Llrn97REJN+oB7MUqFknmI0xy6LfbrbWXhs9ttZauy3mnD3Addbai9MzTRHJiqomOPsT3LTzfh4fm9zEZHGTEswiMr22RmfVQx/V1DE4+cBQrxLMUjQUK4sUpvbgEDvtSnaGVwLwhgUtvHPFa32elYjknUp3TKwezFIoUlmv2oiznC92U5KeaJ85AKy1u4C9xph3z3F+IuKDg10h13hxs3owi8j0JhLM6sMsxU2xskgBau93Vxi21lb4NBMRyWsJejAPjoYZGB7zaUIi6THrBLO19lHAWGv3xRzeQvwmJTuB61Ofmoj4YWB4jM6ByU9QS0sMxzcowSwi02utq6C0xNDv7cOsBLMUEcXKIoUpLsFcpwSziKSg0t2DuR6nuEtVzJLvUt1x53ZjzJnjg+iSv82xx4CrgeVzmZyIZN+Bbnf1cltTFYESk+RsEZFJgRLD8Y2V8RXMw33+TEjEP4qVRQpMhyf506IKZhFJhaeCuc44v393DKgPs+S3VBPMnwfuMsZcF3Ps58AuY0ynMSYMrAZ2zXWCIpJdB7oGXWP1XxaR2VjYUEUfNe6DqmCW4qNYWaTAqIJZRNLC2yKDEGBVwSx5b9ab/AFYa/cYYy4EmmOObTLGLAfeGz3UA1w59ymKSNb0HqT3wHPMp5t+qhikgsXNSjCLyMy1NVXRd6CaURuglxrKaxqpD5T7PS2RrFKsLFJ42vuHOdXsZ4BK+m0V82tSrdUSkaJWWgmBcoZtgK5wFX22mjLCdARVwSz5LaUEM0z0l/Me22iMaQCWJ3pcRHLcPd/gkp0/4JJKZ/iF0Y9yfPOn/Z2TiOSVtsYq/nHsQ3xp7COA4c/OXcFfn36K39MSyTrFyiKFpaN/kK3lf0OJsc6BnwFf6IRAyr9Si0gxMgb+5hW+9fsXuOHuPROHO5VgljyX9o9drbW94wGzMebj6b6+iGSQp09qv61WiwwRmZWFjVWECQBO7/bDPUP+TkgkxyhWFslPoWDvZHIZsGXVSi6LSGoCpbTUuNvsePu8i+SbTK/r2ZTh64tIOg25E8x9VLNELTJEZBbaGqtc40Pdg0nOFBEUK4vkhcGRMGa4333Q00dVRGQ25tW6W8ipRYbku5Q/cjXGXABsJPHu181AY5LHRCRH2eG+aM2ho99WqweziMzKQm+CuUcJZilOipVFCkdHcJg6E3IdMxX1Ps1GRApBS627glmb/Em+SynBHN0R+5rx4RSn2ikeE5EcEw71ut4UwuV1NFWX+TYfEck/CxsrXeMjfUOEI5ZAyVThgkhhUawsUliO9Q9ThzvBTKUSzCKSOm8Fc+eAKpglv806wWyMWcbkcr7bgVtwdsHuSuO8RMQHkaFe17i2oRljlBQSkZmrLi+luaacrgGnCiMcsRztG4qrbBYpVIqVRQpPe398BTOqYBaROVAFsxSaVCqY10S/XmOt/UY6JyMi/jKeTf4am1p8momI5LOV9SO8c/hG6k2IOkJU3fEDuOJ2v6clki2KlUUKTEdwmHo8LZ9UwSwiqXr2Tlqf+TU3lb1AvQlxW/iN3BF6I2PhCKWBTG+VJpIZqSSYm3GW892Y5rlklDGmEbgWJ+hvBrYCt1hrd2XyOul6XZGMi4QpGxtwHZrfMs+nyYhIPlvYUMH7urdPjEeOHPBvMiLZl3exsuJkkampgllE0urYs5Q8eQsXBZzhjsjJWAvdoVFa6yqmfq5Ijkrlo5FtTN1LLucYY9YAe4GXcDZbuRJnU5WdxpgNmbpOul5XJCs81cv9topFzbU+TUZE8pl39UPpaD9YtZqVopFXsbLiZJHptQeHqVcPZhFJl8oG13D8/UV9mCWfzTrBbK3dA3wduGq6c40xv0tlUhmwDbjRWnujtbbHWrvLWrsR2ANsiVZPZOI66Xpdkcwb8iSYqWJxc7VPkxGRfHZ8cz0hO1l9UUIERoI+zkgke/IwVlacLDKNxBXMDYlPFhGZjjfBHH1/6ehXH2bJX6k2d/kqcJYx5gpjTH2SP8uAdWmca0qMMdcAjcANCR4ebwh5abqvk67XFcmauArmapYowSwiKWhrrKIfz6Z+ng+xRApcXsTKipNFZqYjOEydKphFJF3iKpidVpWqYJZ8lmqCeSdwCU5vue4kf17ECRz9dhnQE60m8doS/boxA9dJ1+uKZMVYqMc17qeaRU1KMIvI7C1srKLP1rgPDvX6MxkRf+RLrKw4WWQG1INZRNLK8wFVnXE2Ee0IqoJZ8leqCeY7cHrLGaA3yZ9c6T23BmepXSI7ol9nUj0y2+uk63VFsqK7q9M1Hg7UUFUe8Gk2IpLP2pqq6MP9AZUd6klytkhBypdYWXGyyDSstU6CmUH3A6pgFpFUJatgDqqCWfJXaYrP+z2w2lr7pqlOMsZ0pXj9tDDGLI9+m3Ae1toeYwxMUz0y2+uk63VFsqm7q4PWmHG4XEGziKRmXk05z3gSzKG+LmqSnC9SgHI+VlacLDIz/cNjDI9FqCv3tshQD2YRSVGyHsxKMEseSzXBvAPYNYPztqZ4/XRZPv0pGbnOnF7XGHMV0Y1hFixYwPbt2+dyuRkLBoNZe618UUz3ZM++QXaNrafOhKhjkAMlbQn/7sV0T2ZK9ySe7km8YrsnIyXuBPOjOx9hrLPWdazY7slM6J7Ey9N7kg+xsuLkWcrTf4sZVQz35JVgBIC7wqs5YFtpCQxyZsMwzz2zj8F9Y3HnF8M9mS3dk3i6J/GK6Z4ExkK8IWZcH+3x/tz+V9i+vXvieDHdk5nSPYmXK/ck1QTzrcCm6U6y1l5qjDkBaLTWPpbiaxUda+2NOD37WLdunV2/fn1WXnf79u1k67XyRTHdk0eGj+PLeyZ/5/vzVSdy+fqVcecV0z2ZKd2TeLon8Yrtnmx95Caiq/0AaGmq5xTP37/Y7slM6J7Ey9N7olg5Q/yKkyFv/y1mVDHck4f2dMJ9f+Tfw++AMKw+vpFffOp1vDbJ+cVwT2ZL9ySe7km8oron1sL9JWCdD7CqzTCljEFlI+vXv27itKK6JzOkexIvV+5Jqj2YVzCDvmjGmN8BLwE7jTFhY8z/GWPqUnxNEcmgl7vcfeWWNGuDPxFJXaDK3WZnsN/Xrlki2aZYWaRAtHuWrLfWVvg0ExEpGMbEbRRaR4iOfrXIkPyVaoIZYIUx5j3GmFWJHjTGXAlchLOByTaczU5OBPYZY5bO4XVnY3zzkOZpzptu56HZXiddryuSNQe63H3lFjVX+TQTESkEZTVNrvHwQHeSM0UKVq7HyoqTRWag3ZPwaa1TgllE0iBBH+bOgWGstT5NSGRuUm2RAXDN+DfGmG5grbV2f8zjFwEWuN5ae23MudfgLGu7eA6vPVPj5VLTbRKSbBfrVK+TrtcVyZqD3e4E8+ImVTCLSOqq6t25o3BIuSIpOrkeKytOFpkBJZhFJCO8CWZC7B+NEBoJU1Mxl1SdiD9mXcFsjHkvzuYcsdUW+4Fdxpj6BE+5IXZgrb0e6DXGXDD76c6OtXb8t9mEm4nE7GI95QYrs71Oul5XJFsGhsfoCI5MjEtLDMc3VPo4IxHJd7UN89wHhnr9mYhIluVLrKw4WWRmlGAWkYyIq2B2Ni/pjPm9XCSfpNIi4zKcXbGbrLVvstZeaq1dC1wb/eNird2X4BrXAWtSeO1UbAUwxiR6vQ3Rr7dk4Drpel2RjDvYPUg5oziFVLCwsYrSwFw66IhIsWtsanGNzchAkjNFCk4+xcqKk0Wm0REcpoSIswEX0KIezCKSDp4Ecy1DQHzfd5F8kUoGaTnwcWutqxQpuqPzTAPhPcBZKbx2KsarQq5O8NhGYJe1dlfsQWPM5ujyxLlcZ9avK+KXA10h7iz/G16o+DC7Kq7ituFPQudLfk9LRPJY4ylv4MLhr3PW0HdZOfRDLh/6a0bGIn5PSyQb8ilWVpwsMo324DCrzQu8WPlhnqn4GOff+Qa4/U/9npaI5Ls3XwefeYw/X3QHK4Z+wu8izo/9TiWYJU+lkmDeY619LMljsUvdpuurNt3jaWGtvR2nj91VxphLxo9HA+N1OEEsMcc34PTM2xxbVTHb68z2fBE/vdwVos4MUmbCNJsgC8KvQKDc72mJSB6rqGmkr3Y57TQyTDnWwtG+Ib+nJZINeRMrK04WmV57/zB1xtmrpNoMUz54DAa1r4CIzFHjEmheRmVDK2ECE4c7B9QiQ/JTKgnmLcaY93gPRvvNrTDG/FX00Lro8US7YF9IFjfusNZejVMhcbUxptsY8xJOVcgya613HjtwljXGVU7M8jqzPl/ELwe6Q9TjWb5emahNpIjIzLU1VrnGB7sHfZqJSFblVaysOFkkuUjE0hEcoR73ZtiKk0UkXebVugu7OvpVwSz5adZbU1prbzLGvBitYBjffOMi4CrgduAkY0w4erw3emxiiZ8x5gRgM7Ap9WnPXnRZ4o0zOK8HWDvX66R6vogfDnX2U2Mmf5BZDKa8zscZiUghaGus4rEDk1Veh3uUYJbCl4+xsuJkkcR6BkcJRyz1AU+CuUIJZhFJj1ZPX3dVMEu+mnWCOepNOBUM433TTPTrV621jxljVuBUXlwJvM8Y04kTYDfibNyxx1r789SnLSLp1NXZ6RpHymoJlGiTPxGZm7YmdwWzEsxSRBQrixSA9mglYR2en1+qYBaRNImrYFYPZslTKSWYrbV7jDFrgU8Ay3CW8N1grd0bffyi8XONMVtxltKN91LbhRNQi0gOsNbS29vpbpijoFlE0mBhQ6VrfEgJZikSipVFCsNEgtl4K5gbfJiNiBSieTWeCuagKpglP6VawUw0QJ526V50B+0VxphlQJd3R20R8QqTRSMAACAASURBVFfnwAhlo/0Q83OtpEpBs4jM3dre3/GZwCPUmwHqGOT+jiuBM/yelkhWKFYWyX/tQWdz2jr1YBaRdOs/Ak/cyqkdx/iH0t102Aa+HX6PKpglb6WcYJ4JY8wF1to/wESQLSI55kBXKG7Zn6lUgllE5m7F3p9xetnjE+N7et/q42xEco9iZZHclrSCWbGyiMxV8Chs+QKtwEdK4dnIYr4dfo96MEveynST1c0Zvr6IzNGB7sEEy/5UlSEic1dW3egaD/d3Ya31aTYiOUmxskgO64guVY/rwaxYWUTmyvM+Umec95nu0Ahj4YgfMxKZkykrmI0xDcDngd9ba++KOf7/zeDa84A1c5ueiGSaU8GsZX8ikn6lNe4Ec2V4gO7QKM015UmeIZJfFCuLFLbkFcyKlUVkjjwrIeoZAMBa6AqNML+uMtGzRHLWdC0yrgWuAa7CCYLHvYnpNx8xgMqURHLcga6QKphFJCO87XbqTYhD3YNKMEshUawsUsAmEszeYgzFyiIyV573kXozSAkRIpTQGVSCWfLPdAnmW4FLgBs8x28D1kUf70ny3Cbg43OanYhk3IHuEKu8y/5UlSEi6ZCgMuNQzyCnL1LvSikYipVFCthkBbNiZRFJs0AplNfBSP/EoVpC9FFLZ1B9mCX/TJlgttbuAk5M8NAOYKu19hNTPd8Ys3YOcxORLHi5K8QbVMEsIpmQqIK5ZzDJySL5R7GySGFrDzoJ5npVMItIJlQ2uBLM9WaQPltL58Cwj5MSSU1Km/xZax8lvlIjketSub6IZMdYOMLhnqGJfk8TVJUhIulQ4U4w1xHisBLMUgQUK4vkv9FwhO7QCIYItdrkT0QywfN79/jv5eOrJ0TyyXQtMpKy1m6bwTl3pHp9Ecm8V3qHCEcsh0wrj0WW01QyxNKaMaieN/2TRUSmk6CCWQlmKRaKlUXyW9fACNZCBWM8bE+hyQyysjECkbCztF1EZK4SxMpY6BxQiwzJP3P+yWiMuQ6n91wz8BJwnbX2F3O9rohk3oEuZ7nfd8Lv4jvhd7F6SSO/+NTrfJ6ViBSMJD2YRYqJYmWR/DReQThMOe8b+QIrF9Txu784z+dZiUhBqYxf7QfQGVQFs+SfKVtkGGOWGWNeMMb8zhhzizHmBM/jt+DsnL0CZ6OSdcDtxpjvZmi+IpJGB7rd/eQWN1X7NBMRKUiqYJYCp1hZpHB5l6i31lX4NBMRKVhxxRjO7+cd2uRP8tB0PZgvwQmItwJfs9buG3/AGNMAbIwOdwFrcQLni4E3KXAWyX0HutyJnsXNVT7NREQKUlxfuRAdwRGGRsM+TUgk7RQrixSodk8FYUttuU8zEZGC5ennXm+cHsyqYJZ8NF2LjMuAzdbaryd4bEPM9xdYa/ui328FTjTGvGiMOSE20BaR3PJyl7uCeUmzKphFJI28y/6M855zuGeQ5a21fsxIJN0UK4sUKFUwi0jGqYJZCsh0FczLSL4D9lnRrzfGBMyxNgObUp2YiGSeWmSISEYlCZoP9wz5MRuRTFCsLFKglGAWkYxLUozROTCMtdaPGYmkbLoEc9MUVRVrAAvsTPL4VmB5ivMSkSw44KlgXqwKZhFJp/JaMJOhRrUZpowxDvWEpniSSF5RrCxSoLwtMpRgFpG0S1KMMTQaYWBELeUkv0zXImOXMaY+SdXFuujXHUme2xVzjojkmNDIGB3BEeoJcmf539JHDW2/WgT1C+G9N/k9PREpBMbApT/mlsc7+dnjvfRRwxglHFIFsxQOxcoiBWq8gvlDgd/zkcDvmX9fKzw1D854H5x5mc+zE5GCsHw9vO9nUFHPR//7eZ4amtwTSX2YJd9Ml2Deg7M5yfdjDxpjlgGNOFUZe5I8tzl6jojkoIPdzgZ/9SbEkpJ2oB3274OGxb7OS0QKzKl/wmjvfh5/7KmJQ4d7Bqd4gkheUawsUqA6osmdhaaTE0sOQ+dh6ASWnuvvxESkcDQtdf4AXfWGjr7eiYfUh1nyzXQtMr4GXG+MOdNzfHP0654kFRvg7KqdLKAWEZ+93OksvxlfhjPBs5OtiMhctTVWucaHupVgloKhWFmkQI1XMNfFxcoNCc4WEZmbeTXlrnGHKpglz0xZwWyt3WWMuR1n+d8WYC/OjtjLcSoyNid6njGmHrgWeCS90xWRdBnf4K8OT6KnUglmEUmvhZ4E8+FeJZilMChWFilMQ6Nh+ofGAKgzipVFJPPm1br7vHcGR1jo01xEUjFdiwystVcbY17CqdCIdZu19j9iDxhjLsQJpNdEDyXbVVtEfHagywmWx3eqnaAKZhFJs4WNla7xKz1DRCLaGVsKg2JlkcIzXr0MiSqYFSuLSPq1xCWYh1kY8GkyIimYNsEMYK293hhzA85GJMuBHdbaRxOcty0aODcDjYnOEZHc8HLXeAWzJ2hWVYaIpFldZRn1laX0RavBRsIRLfuTgqJYWaSwxP6MiivGUKwsIhnQUutukdE5MAJ6u5E8MqMEM4C1thfYFv0z3Xm9U50jIv47ON4iQxXMIpJJnS/BsWf4SNUjDIx28VhkBbvsyRzSRn9SYBQrixQOdwWz5+eVYmURSac92yHUydqO/VwdeJ4fhi9mmHLag8NKMEtemXGCWUQKh7WWA11JNvlTVYaIpNMTt8LdX+OvAMrg/429m11jToK51u+5iYiIJNAeU8FcbwbcDypWFpF0+vnVEDzCamB1GfwqfC5HmEenVvtJninxewIikn1dAyMMjIQBVTCLSIZVNriG4x9qHVYFs4iI5ChVMItI1nhj5ejv553BET9mI5IyJZhFitCB7slAWT2YRSSj4oJmpxLscM+QH7MRERGZ1niCuYQIdUYJZhHJoLhiDCdW1n4lkm+UYBYpQuPtMQDq44LmBkRE0iZJBfPBblUwi4hIbhpP7NR6q5fLaiCgLpMikkaeAq/xCubu0CjhiPVjRiIpUYJZpAi9HJNgVgWziGRUkqBZLTJERCRXjVcwK04WkYzzFGPEvu/0jyrBLPlDCWaRInSwOybB7O3BXKkKZhFJoyQVzIeUYBYRkRw1vslfXHsMxckikm5JejAD9KsNs+QRJZhFitCBrtgezOorJyIZ5K3KiAbNvYOjDI6pKkNERHKLtTZ5BbPiZBFJN8/7Sn3M+07vsGJlyR9KMIsUodgWGSOUEglUTD6opX8ikk5JNi4B6BpS0CwiIrklODzG0GgEgDIzRo+twZror82Kk0Uk3ZJsiA3QN6JYWfKHdigQKTJj4Yir9+nbRq7j6b+9mJpABIb7oKrJx9mJSMHxVGXUMoQhgqWEzsGIT5MSERFJrCM4uSb9gchpvK3qv7h/0/kwMgCRUR9nJiIFaaoezEowSx5RglmkyLzSO8RYzG60LbXl1FRE3wpKW3yalYgUrJIAlNfBSL8zNJY6Bumjhs5BBc0iIpJbxttjjGutqwBjoKLWpxmJSEGbogdzn1pkSB4p+ASzMaYRuBZYAzQDW4FbrLW7ZnmNq4CzgOXAHmCLtfbGJOfeFh32eB5ujH7dbK3dOpu/h0i6HOh295Jb1FTt00xEpGhUNkwkmMEJnPtsDZ1qkSHiO8XKIm4JE8wiIpmSZENsUIsMyS8FnWA2xqwBtgGbgOtwAt5rgZ3GmItmErgaYzbgBMGNMYfXAJcYYzYBa6213uB4wzSXvWGGfwWRtDvY5d7Ub3GzEswikmGVDdB3cGLo9GFuVYsMEZ8pVhaJ194/5Bq31CrBLCIZpB7MUiAKOsGMEzDfGFM9sQvYaIx5CdhijGlKEPB6bcapwrjSWrvLGLMcuCR6fDlOQH1RguetxakCAXfAPT4PEV/s7xpwjZc0V/k0ExEpGp5NkepNCCyqYBbxn2JlEY/YHsygCmYRyTBVMEuBKNgEszHmGpxgNVEFxO3ANcClQNzSPY9G4CJr7R6A6NfrjTHgBM4JKzBms6xQJJse2tPlGp8wr8anmYhI0UiyeYl6MIv4R7GySGJqkSEiWeXZELtOPZglTxVsghm4DOgZD3Y9tuAEzRuZPmhOeA1r7fXGmM3gLC/0BMnTVXqI+KJ7YIRdL3dPjNea53j7Mz+GA03OD7ZF6+CMS32coYgUpDPfD0tfx0hZHZ/95V4ej6wAoHvYMhaOUBoo8XmCIkVJsbJIAu3ByQTz50pvZcNTP4Zj851Yed2fwrwVPs5ORApOVROc/7dQ2cBgSQ3X/GLfxEN9IxZrLdEPbUVymrG2MD8RMcZYYJe1dm2CxxqBbpyAuGma6zQmWxpojOnGqdpYMR5YR6+901qbcuRhjLkKZ6MUFixYsPbmm29O9VKzEgwGqa3V7sixCu2ePHh4jBuemAyaP159D38X+d7E+Oj8N/Lsqz435TUK7Z6kg+5JPN2TeLonjk//YYD+mNXH33xjFfOqlGAep38n8bJ9T84///yd1tp1WXtBn+RrrOxXnAz6/zORQrwnX3pgkH19zh4Bt5d/iXUlz0889uiqr9Lb+Oopn1+I92SudE/i6Z7E0z0Bay1XbQkxGrNNyb9vqKaqVAnmcfp3Ei9XYuWCrGCO9n4D6Er0uLW2J/oJkLffW8Jzp3i4kfiqjeaYOWzG2eRkOU4vuRsS7aad4DVvJFotsm7dOrt+/frpnpIW27dvJ1uvlS8K7Z788uZHgcMT47MXV8P+yccXLD2JBdP8fQvtnqSD7kk83ZN4uieOE568jycP9U6Ml5y6irNOaJ7iGcVF/07i6Z6kXz7Hyn7FyaB/i4kU4j0ZemAb4Gz0VxfTCxVg9dnnwXGnT/n8Qrwnc6V7Ek/3JJ7uiWP+Q3/gUM/gxPhVq1/DUrW1nKB/J/Fy5Z4UasnQ8ulPmZto9QQ4u24nev2Xol/34CwDXAPcYIzZkum5iSQSjljufr7ddeyUZs8KBk//JxGRdFvYWOkaH44JoEUkaxQriyQQHB5ztciI7YUKKFYWkYybV1vuGncEh5OcKZJbCjXBnA2bcJYVeqssGnEqMFZYa9daay+KLi28Pvr4hpiAWyRrHjvQTXdodGLcUFXGwopR90mVCppFJLPaGqtd44PdSjCLFCjFypJ3Hnypk3BksgCjwXh+RilWFpEMa6l1byzaERxJcqZIblGCOQXjG5YAF3ofs9buigbLezzHNwFbo8ONGZ6iSJy7drurl887uZWSkT73SarKEJEMUwWzSOFTrCz56p6Y1X4lRKjB8zNKsbKIZNi8GncFc6cSzJIncirBbIzZYoyxKf6J7RE3HrBO19Rx1jtYG2MuwdlY5KJpes4lMh5sZ3xZoojXH3Yfc40vOKUVhjwJ5sqGLM5IRIrG2DB07YHDj3LG6OOcZXZPPKQEs8jMKVYWyax7XphMMNd6k8vldVASyPKMRKQohLqg/Tk48DBnje1kIR0TD6lFhuSLnNrkz1p7UZouNb5hyXQbk+yZ5nEXY8wa4CbgQm/VxQyNP2fWwbrIXBzpHeKZVyaTycbAeSe1wlNKMItIFhx9Cm66AIDXAF8sO4G3j3wVwLWJiYhMTbGySObs7xxgf+dkz+WmgNpjiEiWbP0i7PoxAJcCjwWu4GdhZxFQpxLMkidyqoI5XWKqJRJWP8TsnL010eNTPGcbsNFauyvFqY0H8TN+XZF02P6cu3p51eJG5tVWxFcwa9mfiGRChfvDqzomf4E/1D2Itdb7DBHJIMXKIvHu8WyGffbCMvcJipNFJFM87y/1DEx83zGgFhmSHwoywRy1FSYqKbw2RL/eMpMLRZcUbgGutNYmDXiNMZtjAvJE1kW/XjeT1xVJl7j2GCvnO98MeyuYFTiLSAZ4VkfUm8kE88BImL7BsWzPSEQUK4u43P18h2t8Tpsnwaw4WUQypdK9oKguJlZWBbPki0JOMN8Q/Xp1gsc24uxq7aquiAa913iONQI7gc3W2tu9j0X/jAfKt8S8Lt5zcfrKbUyhH51IyobHwtz3ojtgPv+UaIJZFcwikg2eX8qdBPNk1bLaZIj4QrGySNRoOMKDL7nj5dULPL8qK04WkUzxFmPErPbr0CZ/kicKNsEcDXBvBK6KbjYCQDQoXodnd2pjzAbgGmCzp5JjG87ywRu8m6UA3dE/LxljGqNB+HJjzG3GmA3jAbUx5iomlwy6Am+RTHt4bxehkfDEeH5dBa9eGA2QVcEsItlQWgGlVRPDABFqGJoY7+scSPQsEckgxcoik3bt72YgJl5uqa1gcbVndY3iZBHJlClW+x3uGWQ0HMn2jERmrWATzADW2qtxqjKuNsZ0G2NeAs4CliXYeGQHsIuYag1jzGYg0bLBqWzCCbK3AHtxqjQarbVrp1oyKJIpd+1295M7f+V8jDEQHoXRyR9cmBIor83y7ESkaFQm78N87wvt3rNFJAsUK4s47vH8HDrvpBZKvIUYqmAWkUzxxMnzYjYZDY2EeWRfl/cZIjmn1O8JZJq19kac6ozpzusB1nqObcIJgmfzercDqryQnHGXZ4O/5O0x6sCYLM1KRIpOZT0Ej0wM602II3YeANuePUYkYikp0XuQSLYpVhaBezz9l887uRX6e90nqYJZRDLF8/7SVjVKzGI/tj17jHNXtGR5UiKzU9AVzCJZ170Pfv0ZuPMvoXu/37Nhb8cAezsml56XBQyvPyn6g2nYEzRXuD81FRFJK09lxvyyyaj5WP8wTx/u8z5DREQKzTO/hpsvhwe/A9ZOf34WdAaHeeqwOy5+/Ukt8a3kVMEsIpniiZNbSodc423PHsXmyHumSDIFX8EsklW//DPYf5/z/ZGn4Irf+1oVfNdud/Xya5Y1U1sR/d++8QT465dgqNf5Y9XXSUQyyBM4v3ZhKfftmxxv232U0xfpg668Ya1WvYjI7BzbDbd9xIk5d98JVU2w6gN+z4r7Xuxw5bpPa6unpbYC1l8Lr/2Es+pvqBfqF/o3SREpbJ44ucYGKQsYRsPOm9O+zhB7OgZY0aqWlnmhSONkVTCLpMtA52RyGeDgw9D5kn/zIUF7jJXzJwclJVDTAvNWQNsaWLQuy7MTkaLiCZzPOi7gGv/B84GY5Kj7/x9ctwT+/Vw4+rTfsxGRfPLoT9wFDb/5rH9ziXH38+7+y284qdX5pqzKSSrPPwWWvBYaF/swOxEpCp44uWS4j7OXz3Md2/bs0WzOSFIx2A0/eCv80wK483MwNuL3jLJKCWaRdGl/Nv7YS9uyP4+ogeExHtrj3gxgov+yiEi2eZYWv7rZvczviYO9HO1zLweUHLP/Adjy906LpWPPwE8vhZA2nRGRGTr4iHscHoHhfn/mEmWt5d4XPP2XxxPMIiLZUl4LJiY9Nxpiw8lNrlO2PqtijJz3v5tg//0QHoYd34etX/J7RlmlBLM42p9n8ct3wH9cBAcemf58iXcsQYK5rDr784i6/8UORsKTVSJL51WzvKXGt/mISJHzVGbUMcDyBncY4m3rIznmnq+7x30H4RefgIhaLEmBGxuGF7Zy0vP/Dv/1Xr9nk79GQu5xWTWEOv2ZS9Szr/TT3j88Ma4pD7B2adMUzxARyQBj4ooxNiyvco137u+mJ1RcFbF5pWsPPHmb+9gfvwPP3unPfHygHswCv70GHr6BFePj3XfC4rP8nFF+8iaYL/gCrPmQP3MhcXsMU4R9gEQkR3gSzAz1cWZrgD29k8nJbbuP8b7XLMnyxGRGDu6El/4Qf7yizqlCLKnM/pxEsmEkBN86BYZ6aRs/1r0Pmk7wb075KDwGHc+5j/3l01Dd7M98ou55wd0e45wV8ygvVQ2WiPigsgGGeiaGbZUjtNUaDgWdVX/hiOXu59t556q2ZFcQP933z/H7WpVVQ2TMn/n4QD89Jb737nO/9Wce+c6bYJ7/Kn/mgbPc767d7oBZ7TFExFdxCeZeVs1392G+74UOhkbDWZyUzNi934g/9vZ/gff+B5QpuSwFrLwaFpzmPrZbsfKsde1xPowaV7vA9+QywL2eBPN5J6s9hoj4JFGs3OquCVWbjBzVcwAe++/441ffC69+V/bn4xNVMAucdBGYANjoL/Udz0PHi9Byor/zyifWxvdgnn+qP3PBWe53JKaXaVVZgNcu8wTxu/8HDj8GlfXOcpwl50DryVmeqYgUjfmnwpnvd95vKhugbS1LDpdwXH3lxPvV4GiYP+7pZP1KfSCWU448Gf/h80X/COs+5s98RLJt5VudnorjnvstnPMp/+aTj4494x63nuLPPGKERsZ4ZG+365ir//K2L0Np1WSsfPpGCOjXZxHJkJVvhYWrnDi5ogFq57Nqfjf/s3d04pTtzx1jNByhLKBa0ZzywL9CZNR97NpDUFHrz3x8op+QAlVNcMLrYe/dk8ee+x9oyY2dnfNC8KizY+i4smpoXOrbdLztMV53YguVZe5KQZ7/P9j148nx2/9ZCWYRyZyl5zp/YphXtnPBqfP52UMvTxzb9uwxJZhzzb3fdI/b1sK5n/ZnLiJ+OOWt8Pu/nRzvf8DZ4DIHKnDzRvtu99jHlX7jHtrT5dqvZElzNSeM71cSCce/951xaRZnJyJF5/xr4w6taHyB5ppyugacFSD9Q2Ps2NfNOSvmZXt2kkz/Udj5I/exd3z7/2fvzOOjqs7//74zmWyQZJIQ9iyELSBrwqYCsiRF0WqrBGzVLrZC129trURav9/267dqoVptbVWwtra1/gqkarVuTdjRCiQB2bcEwk6AZLJvM3N/f5zZ7izJJJlkJuG8X695Jefcc885cyF3nnnu83ye6865DFIiQ2In43ZtW6b+dQx3eYyksaAL3p/XZrdCWfMzvKT7NdVo225FBSQSiaQnWOgm37P5aAWqqgZpNxIPrhyHQ29r++Y+KorRSCTXCwnpWoeoaoET/w7efnoj7hHMQcz0s7PtuLs8xgBno9nNTg6PAZ1bsIZEIpF0MzpFYd5Y7Xf5TUcuB2k3Eq/85wWwOIvFEjscJt0bvP0EEelglgjG3qZtn90FdVe8j5V40pb+cl2FKAbTQ1TVt7D3jDbdb763aEB3w9ld80kikUh6gJtGDiDCpaDSeVMjxy7XBnFHEg07fw24OPwHTYQxt/oev3+DiO6USPoaYxdr20ffC84+eisetrLNwWy1Csk2S88XQXIv8KeRx3APxIiUgRgSiSQ4ZI8bpGlvOip1mEOG+muw54/avtkPQ1i49/FNNbDp/8Dc7P14L0c6mCUCYwq1/Ue4dKhCQkHiH+5RGWERUPA/8NJseGY0bP1lj21l+4krWF18ARmDYxhqjPIcKCOYJRJJCBAVrmf2qAGavk2ygEloUHlKOIxdmfuI9+jl1kZ45/vw5kOQ/yDUX+2ZPUokPUWGm4P55CZobfI+VqLF3AzXSrV9V49D/jfgmVGw7hY4X9SjWzpX1UDZlXpHO0ynaFPO3QMxpJ0skUiCxJzRAzDonbbXqav1lF2pC+KOJA52vQStzs8S+g+Cqfd7H3txP6ybJwpn//vxHtleTyMdzBIH1xJnajvcC/pIfOOuKxcVDx//Bi4fEO3SzaIQYA/gLo+xIMOHlqlHBLM0nCUSSXBYME57n5KpfyHCx887CwADDBgD4+70HNfaBH/Icer6116EN5eLyESJpK8wZCrN4S6ay631cGp78PbTm7h6QnsviUuGsq1wMB8arom+0s09uqXtx7UPwTJT4omJNDg7ZASzRCIJEWIiDcxK12ouy2CMEKDRBLvWavtu+j4YvAT3nSyEP2RDpe1h6+51cOit7t9jDyMdzBIHVwe4OZhLt0BLQ3A209uISxYvO5lfgXAXUfe6y3D5ULdvw2JVPfTk5vtyMDdVa9syMkMikfQE5hYR3Xqt1OFwcH8QtvesiWt1fTN1rNfQ2ghH/qXtm/OIdw1SQySMWqjtK90EO5/1HCuR9FZ0Oq4OmKHtOyZlMvzC3ATDpwsdY4CkDBi5QDvm5KYe3dL2tvSXQdrJEokkOKgqNNdBzQXxsuFuKxfKYIzgc7JQG7QXlQBZX/c+dlgWxGilTvjn9z2ze3o50sEscVDXf4TWSWpuhLItwdtQbyL3T/DDg/DYWfhGIRhTYcRc7ZjS7jec952twtTQ6mjHRRmYmmz0PlhGZkgkkp7muYnwiyT41Uh4IZPwFnEfGhIXxfghznuQqsLWY7IOQFAxRMH3i2HB48JgNqbChCW+xy/4b0i5Udu35Sk4vbN79ymR9CCe2X4fyEh9fxg+Db5ZCKvOwsMH4danPR3MF0qgobJHtmO2WPm4VBvBPHeMW0FsmeknkUh6mmMfwhOJ8PQw+PU4eO8RxyF3Heai8iqqXb73S4LAxCWwfJszu+/G70JEf+9jo+Ih9zXQuWTKtNTCxq/1Kbkt6WCWOFEUz2J/R6VMRoeIjIXk6eJauhvOPZD65y6PccuYJML0Xv7MLa3iAYIdRaeNuJZIJJLuQG/QNMPMTs2yhW4yGe73M0kQiDLC3Efh4QNw7xugD/M9Vh8G97wK0S4pnKpVaKzWyX9LSd+gKn6iMwoXRIbahZLgbai3oShgTIYBoyFmMAy8wXlMtcKpbT2yjX1nTdQ2OYsKJvQLZ8JQt2LXslaJRCLpacKjtXJCLpkUyQnRjBnk/L5usapsPS7tq6AzdAos+yt851OY8VDbY4dlwaIntX2X9sNHP+m+/fUw0sEs0eJeIfv4h2C1eB8raRt3B3P5f7pdcmTzUXd5jCTvAz2M5hjvRZskEokkkERqv8BrHczayIxtx6/QYpaRgSFBRH8YPKH9cXHD4IvrtH11l0ThP2lLSPoAqs7gKQdzVMpkdJpRPR+MAbD9hDZ6efaoAeh0bnZws5tEhoxglkgk3U2k+4Mu7X1oQYbWVpY6zCHEwHGe/37emLHcs55J0atw8B/ds68eRjqYJVrSZkOEyx9Gw1U4uzt4+wkEqgo1F3t+3YR0kVJsx9IM5Z9023KXqps4ctHpOFYUuGWMrwJ/7rpyftwMJRKJpKu4fUF3dTBPGhbHgP7hjnZd7Ki4nwAAIABJREFUs5k9p3smXVoSQEZnC61mV8q2wg6pxyzpI2Tcrm33haLYLfWiWFFP46HD3DNFsT31l70EZMgIZolE0tO432fcHMzZbtl+W49V0GqRwRi9CkWBu34H8Wna/nd+0Cf0mKWDWaJFb4DROeL3oVNh/uMila23UnsZfjMZfp0Bf/lCz0ZQKYr3okfdxJZj2ieYU5ONJPQL9z7YQ39ZOpglEkkP4Hav0VucDmadTmH+WK3hLCMzeinzfgKpN2v7tj4Np7YHZz8SSSAZnQOKXkiLjb8LZv+oR5yi3UbJX+GXqfDsWNj7t55dO+UmCItytmvOwdUT3bqkqaGF/ee0zvS5owd4DvTQYJa2skQi6WY8Ipi196GpKfGa7/c1TWaKy6t6YmeSQBIZJ/SY9S6+mpZa2PDVXq/HLB3MEk/m/wR+dASWb4VbHoW44cHeUefZ9ASYysXvZVvg0FuBnV9V23Za96AOs7teqbujRoMsXCKRSIJBGxIZ4KnDvOnoZdTe7LjpbTTVwIH8rj+Mdegxuzht7HrMtbLquaSXExUPD34Ej5bC0r/A5GW9V2asqRrefxSsrWBuEjqQFnP753WEtu4nhkhIc3sY1c1FsXeevIrV5WMlY3AMA2MjPQfKYAyJRNLTuEcwN9cI+8mGXqcwb6w242LTEWlX9SindkDF0a7PM3QqLHpK23f5AHz4WNfnDiJtVGuRXLckjgz2DgJDayPse13bd75EVPsMFJVl8NJNkDQWBo6H4dNh+jecx0fMFVEudrH+K0eh+lzAnfbNZgsfn9Tqyc3PaMPB3MfS/pqbm6msrKS2thaLped1PuPi4jhy5EiPrxvKyGviSTCviV6vJyYmhoSEBCIiIoKyB8DjXuPuYJ49OolwvY4WW7pf+bUGSq/UM2qgLELaI+x5RTyY3fIUzPkRTFrmUZjRb2KHwN3r4PV7AJs3p74C3vwmPPA26PQB27ZE0uMkTw/2DgLDkXe1RZ+bTFBzHuJTfZ/TUQp/Bvs3QFKGsJUnLYVhmc7jIxfAyUJn++QmmPXtwK3vhrs8xi3e5DHAMxhD2spdQtqFnshr4kmwrknI2Mn6MFFItqXW1qESZtbWcFqYMYg3S8472puOVPDT28f34CavYyxmeOd7UFUO4++EOT+GIZM6P9/0b8LpnXD4bWdf8Z+EbG0gfVY9iHQwS/ouxz7QtqPiIeeJwK5RcVhEfFz8TLyqz2kdzJFxwul89lNnX+kWyHwgoNvYfaqShhansTgoNoIbhrZhCPehCObm5mbOnDlDfHw8aWlpGAwGlB6OJKqtrSUmJqb9gdcR8pp4Eqxroqoqra2t1NTUcObMGVJSUoJnPEcaNU13B3P/iDBmpieww6UA0+ajl6WDuSdoqYf//F78XlkK//wuNFbBTd/v/JyjFsLcH8P2Xzn7EkeB1SwdzBJJKLB/g7Y958eBdS4DVByBusvidWobDJ/m5mB2k5M7vRPMzRAW+M8pVVXZflwbkDFntJ8FsaWt3CWkXeiJvCaeBOOahJSdDMJ/4HAwe9rKc8cMwKBXaLWIh/dlV+spu1JHepK0lbudg/+AqtPi98P/FP6mHx2Ffomdm09R4M4X4NJ+EbgIwmfVix9oSokMSd/lwEZte/KXxFPBQFLh9oR1oJenhz2gw+xNHqNNw3FUNnzln7D0r3DX72Hq/QHfU09RWVlJfHw8AwYMIDw8vMcNZokk1FEUhfDwcAYMGEB8fDyVlUEsnOchkdHgMWRhhtRhDgrFr0HDNWc7IhamBuBh6LxVkDZH6NXe8yrc8Vy3OI4kEkkHqbnoqYs+aWng12nPVk4aCzFDnW1zI5z5T+D3AZyoqONSjVPfMtKgY1pavPfBtz8L9+U771uJo7tlTz2BtJUlEt+ElJ0MHg+z9BatrRwTaWDmCK1D090XIOkGrFbY8Yy2b/K9nXcu24mMtekxR8DwGbBiB4z5XNfmDCLSwSzpmzRUwokCbd/E3MCv42E0j/Mc467DXLY14MUGt7h9qMxrS38ZoP9ASJ8nUjum3i+kPHoptbW1xMb23qd8EklPEhsbS21tbfsDu4vItiUyABZkDNK0i8qrqG5o7dZtXfe0NsHHv9X2zXgIoozex3cEnR7u+QMs39Zr0/0kkj7JwX/gkK8BGDJZOHsDSVO1kNywowsTWQyuKAqM6pmaJe7yGLPSE4k0+MimGDJJFHScuASmPQj9fUQ69wKkrSyR+EfQ7WRot14JwAK3YIxCqcPc/Rx5B64ed7YVHcz+YWDmHjIZvvoufP19MCYHZs4gIR3MkvapOg3/eRGO/zvYO/Gfw2+LgiV2EkcJIfVA44+DeehUbVp4Y5WQ0wgQp67Wc/qa88mmQa8w21s17D6KxWLBYOikRqhEcp1hMBiCor3owA+jOSUxmtEukhgWq8rW4zIyo1vZ9zrUXXK2DdEw6zuBmz9mMNaEkZy4XMvfd5+hsr4lcHNLJMHGYhZFfz76KbR4ZmWELAfc5DEmdkf0slshpMRREBbuOc6jKPaWwO8F2ObmYJ7rSx6jjyFtZYnEP4JuJ4NftnL2OG0wxp7TMhijW1FV2O4WvTwxFxLSA7dGykxH3ZPeXOBcajBLfHN6J7y/EioOifboRb0nXH+/mzzGxKWBr/BtboFrJ7R9SRme43R6GLtYaM+NWii05gIYIeKeEjNzRCL9I66vP22Z6ieR+EfQ/1Y8jOY6r8MWjhvEiQrnsc1HK7hryrBu3dp1i6UVdj6v7Zv2IPTr2oPKhhYz+86aKCmvori8ipIzJqobxZcfY7SBWycM6dL8EklI8O//hpK/iOJ4AKk3Q8bi4O7JH64ccwt2UGDCPYFfp+Kwtu0tEAMgfT4YU0R23cgFMOKWgG+lqdXC7lPa1Pe5vgr89UGC/vkvkfQCQuLvpAPBGHZb2WJV2XbiCndOHuoxVhIAjn8Elw+4dCgw+0cBm/5qXbOwlW02s0VVees7Nwds/p7k+vJCSTpGVLzTuQxC2qG5DiJCXEDedAbOfKLtc03LtT8R6uoHSGWpKFRkJ3aY73TiL77UtbXawFMe4/oxliUSSS/DD6MZYOG4gby8rdTR3nrsCmaLlTC9TLwKOPvXQ/VZZ1sfATd+r8PTXDA1UmwzjIvLqzh8sQaL1XsERnF5lXQwS/oGrY1O5zLAsfd6h4PZvbjfiLkQ6/I3qaqBCczwp1YJQHQCPHzA+7EAsftUJc1mq6M9zBjFyKR+3bqmRCKRdJiI9uXkwDMYY9ORy9LB3B2oqrZYNQiZ0YFeAgv9wGpVOXmljqLTdpu5UpONDqBToK7Z3CuDBnvfjiU9x8DxYEwFU7loW5qFJtr4O4O7r/ZwL+43bBrUVYhKn+eK4NweWL4F4oZ3bR33qAxv0cvdTH2zmV2nrmn63DWZJBKJJGTwMJq9p5NPTTZijDZgsqX7VTe2UnLGxIwRCd2+xesKqwV2PKvty3xA62jyQqvFypGLNRqH8sXqpjbPcaW4vKozu5VIQo+MxbDnFWf72Ifi70rnQ9c3FFBVT1t5zK1Ck/lcsbCT+w+Ee//W9bWuuDmYg2Ar23HXX547ZkBoRCtKJBKJKzIYI7Qo2wrni7R9c37s9+n2jL7i01UUnxFRyjVN5jbPsaqw74ypV8qeSgezxDeKAhm3w6cvOvuOvR/aDmZV9ZTHmLQMCn8OZz919p3bEwAHsx/6y93Mx8cuMMp6mtMMopFI0hKjSU/yI8L86HtgaRHOnsg48TAhPLr7NyyRSK5voowweKLQpY+I5VqNGW+xFmF6HfPGJPH2vguOvk1HL0sHc6A59BZUljnbujC4+Qcew0wNLew9Y6KovJLi8io+O1tNY2vHNQpjIsPITInnxpFdrLgtkYQKqbOFLdVcI9oNV4WNmTIruPtqi7O7ncEjAGGRMHwavJrj7Is0BiaK2d8I5u6k/irUVbDdTcu/Tf3l+quiWHhkrPj37T8IksZ080YlEokEiE+DYVniO3pkHA2qd59FZko88dEGqlyCMYrLq5iZLm2sgOKuvTzmVlEE1gcdyehri8MXq6WDWdIHGbtY62A+/qEoZqIP0f86lw9qoyUUPdzwRWFIaxzMRaK/KwTbwdxoYvwHS/gg4hgmtR+Ptq5g2Ngl7Z8HUPA/cO2ks/2dT4PiIJd0ncLCQtauXUthYSEmkwmj0UhCQgJGo5GyMuE4ys7OZvXq1aSnB7AQgcRvTCYTWVlZ3HnnnTz33HPB3k5wiYiBb+10NI9v3erVwQwi9U/jYD5Swarb5H0qYFitnkbz5HtR45Ipu1InDGNbtMXJCu9a2e0xYkA/MlPimZYWT1ZqPKOS+qPTyYhBSR8iLBxG54joXztH3wttB7N7cb8xt4psP1dHeZMJrpXCgFGdX6fuCtS7RA3rIyBhROfn6wzHPoQNXwFLM09Yx/E9/ourxKHXKdw0qo0v7leOwtvfcraTZ8E3Pur+/Uq6BWkrhz7SVnYh8wHxsnFl61avw/Q6hfljB/Lm3vOOvk1HK6SDOZCUfwLlO7V9LtHLXc3os6PXKdwwNFZjMw+Ji+rq7oNCiHoJJSFDyo1Ci7nRls7aWCUctWmzg7svX7hryo1cAP2TYPh0bf+5PV1fK8gOZvXf/83wxmMAGJV6Xgn/NafMgDq+/YiTphpt2y1tXdJ7yM7OJjs7m9zcXPLz89m4cSPZ2dmO42vWrCEvL4/CwkJOnTqF0ehDJ7wXYzKZ2LBhA8uXLw/2VrzupbKykrKyMj777LM2zpS4M3dMEnqd4njqf7KijvJr9aQmSs3MgHDsPc0DWSs6Hr+SzQf/V+CIhukI4WE6Jg+PIzM1nmmpCWSmGEnsHxHIHUskocnYxZ4O5pwnAl9cOhBYWuHgm9q+SUtBpxMRc2VbnP3n9nTNwewhjzGmZ6VD6q4IJ7GlGYBZuiP8M+Jxlrc8QmTyVOKiDL7PdbeTI6Wd3JuRtrK0lfsqC8cN0jiYC49c5ieLZTBGwHALxGhNvYWd9akUf3SMovLKTmf0xUaGkZUaz7S0BDJT4pmcHEd0eN9wzfaNdyHpPvRhMHoR7P+7s+/oe6HrYD5RoG1PWip+ujuYL34G5hYRedIZWhu1acXgn66c1QqXPoOTm6B0C9z5W0gc2eHlW05uJXzvXzz6R+z/NVjL4c7ftS150SwN575GQoJ36YCVK1dSUFBAYWEhhYWFLFniZ5R7L8FkMhEfH092dnbQjWZfe0lPT6eqqgq9PoQ1OUOQuCgD09Pi+bSs0tG3+WgFX7+5hyPg+hiXa5ooOlXJ1I/+TxM9/o5lFm+cDAf8cy4nxUQwLVVEWWSmxjNhaBzhYVL3T3IdMjoHdAaw2v52Kkvh6nFIGhvcfXnjfDE0Ou+pRBphlE0aY/h0rYP5fBFM+VLn16o4qm37K4/RVAOndwhbubWx84WyP3zMGSBjY5hyjY3h/8vm+P8FbvJ9rrudLAMx+gTSVpa2cl9jzpgBhOkUzLZgjLIr9Zy6Ws+IATIYo6uo54pRSjdp+u4/PpddxzoeqJg+oJ8tAEPYzSP7cEZfn3cwK4piBFYBmUACUAisV1W1pAPn20V9TW6H7Y83V6uqWhjIdUOKjMWeDuZFT4VmZMbyrXDiIxHJXP6xiCoBiBsGMUOg9qJom5uEnMawzM6tc/U44KKlY0yFcD9u5BsegKP/crZLN3fYwXyo/DLGN77FMF8DDv5DpDXe+4Z43+6YW8T7t6PoINwP3WZJr6Uvp/vZo0xCIdqkrb0YjUZqa2t7eku9noUZg6SDuQuYLVaOXqrVpO6dNzUyWTnJPyOOacb+3vwFn/PoFBg7ONZhGGelxjM8PkoWyOojSFu5i0TGicALV+fs0fdC08GcMgsePggH84WtnDzDGWwxfJp2bFez/TpTDLvmIjw/Aay2Akg6A9z+jH82tivH/y3eoxeilWbuOPoYbDHBLXkietsdGcF83SFt5Z5B2sqBJTbSwMz0BD4+ec3Rt+nIZb45p+/+f+4umlotHDhfTdFpYS8vPv0Ud7sc320dyy61/c+x6z2jr087mBVFyQQ2AXnA00A6wpAtVhQlx93QbYPsdo6v7aZ1Q4ORC4Vumi3FDFO5MBoH3RDcfXnDEAnj7xKv1ibRtjN8Ghx519k+V9R5B3Nni5YMn+7pYJ7xkF+ntpit/G7LSS5te5U1YRc1x6rVaOKUBmfHxX3wynxY9jdIdove9ojKiAnNhwWSgFFUJCrfuqYD2ikpKWH9+vUO7TNfkQ2FhYWsXr3aMdfSpUtZvXq1xkAsKSmhsLCQ0tJShg8fzu23305mpuffWElJCUaj0WHMl5WVtWnYFxYWUlBQ4BiXk5Pj8V68RaWYTCaKiorIzs4mPz+f9evXs2rVKseeysrKMJlMXvdYWFjo9Xr5cx187eXAgQPMmTPH6/WwX7eRI0eSnZ0dkOvWF1g4biBPvu+8335ado3aplZiIttIbb6OqW5spcRWobq4vIp9Z000tHim7n2mjuLW5l/yw7B8FumLeN8ygxMuRWRiIsKYkmIU6XupCUxOjpPXvI8ibeUAkXG71sF87H2Y86Pg7actjMkw+4fi1eoScDDMzcF86SC0NHS+CHRnbOXYIRCXDFWnRNvaCqd3wphF/q+rqrD9V5ouk9oPo1KvHbftl+L7zBdf9nRgN1dr2zKCuc8jbWVpK/dWFmYMcnMwV0gHsx9U1DZRUl4lHMpnqjh4vppWizOAcAtf4xP9KP5L/yYpuiu8YP4i4OkzGdBfZPRNS5MZfdDHHcwIw3WdqqrrbO0SIFdRlFKgQFGUeFVV3SMtfJGFiK4AZzSGHfdIi0CuG3wi+kP6PBEZbOfo+6HpYHbF1bkMwrmrcTDvgZmdTBOKThRFUSoOg+mM//rLoxZC4c+c7VPbhR6evu0v7ocv1PDIxs84crEGmEO9NZyfG14jSakhX7eIYYsf5cZd3xNFSezUXYbXbhcyHJPvdfY3uRnNkXH+7b2XkfbYe8HeQoc4/cvbu2XeNWvWUFJSQkFBgcawM5lM5Obmkp6eTl5eHgC5ubmsXr2a4uJizdicnBwyMzNZu1b4B/Lz88nLyyMvL88xbsWKFVRWVrJ69WoSEhJ44YUXHEa4/bwVK1awYcMGTCYTa9euJSEhgdzcXMc6S5YsYePGjbjiOq997ZycHFRVpayszLH3DRs2UFhY6Dhn7dq1lJWVkZ2dTUlJiWPcsmXLKCoqIi8vD5PJpFmzrKyM3NxcSkrELV1VtRV/27oOlZWV7e5l/vz5bN682ef7S0hIYN26dQG5br0KVfX5kCs9qT8jBvTj1FXhGGi1qOw8cZXbJg7pyR2GJKqqcvpagy0yuZLi8iqOX/a/GN9RNYUVrT9igrmMWGMCd6cNE9EWafGMHhiDvo+m7kk8kLZyIBh7G7zvLPzDuSKovQwxg4K3J39wtZX7JUJCulMCTrWIgIXUNqQk2mL4NEAVUhnN1R2zlff8wdku3dwxB7OiwP35UPhzKPojVnTc37KKCbrTPBH2J8IVl4duR96BylPwpTfAmOLs94hglrZyKCBtZWkrX5e2sts1dmfhuIE88S9nxsie05VUN7a2rTN/nWGxqhy/XEtRuQjCKCqv5GxlY9vnoCffcgtvW25moa6EHdaJKAqMHRRj00+OJyslgeQEmdHnSp91MCuKshJh3K71cjgfWAksBdZ5Oe5BB9IEA7puyJCxWOtgPvYe3PJo8PbTGQJZ6G90jngBNNcKJ7E/DLwB+g2E+grRbqmDs7sh7Wavw1stVl7aWspvN51waCuBwnvWWexsnsBvhhaQ88Bq4uITYUIBvPkQHP/QOYGlGd5aISQxsr5m2697BHPfNJqvZ9asWcOePXsoKytj2rRplJaWejy9X7hwIQkJCQ7DDGDjxo2MHDmSvLw8R7/dOLMbreDUqrPPuWbNGjZs2EBVlVPr8OGHHyYiIoK8vDxGjhzJypUrWbt2LVlZWQ5DctmyZY5zHnroIfLz81mzZg0rV64EhGG/bt06iouLHWutXLmS0tJSQEQ/rFq1ivz8fEf1bxBpjsuXLyc+Pp6ioiJycnKoqqri6aefxmg0smTJErKzsxk5UitPk56eTnFxMVlZWQ7D2U5718FkMrW7F2//Tu7Xzf7eu3LdQp5ta0RqdnMNcxqqIPZZyPyKz+ELMgby6s5TjvamoxV908FstcLht0kvfQdGx3pk2NhT9+xSFyXlVVyrb+nwMuF6HROGxToKi2SmLmRgTGT7J0r6HNJW9o8LpkZe2VGGQa/jwrkWSlqOEabXodcpGPQKYTodYXqF22PHk1hj/5KvcmDL37k4chkG29gwveL43aBzOV+vI8x2PEzn/N1xnk7puS+vw6dra4yc29N5B/OiJ8VPVYWaC0Kqzh9GLtA6mE9u8j3WF5FxcMdzMDGX1za+xcGmdA5a0im1DuWvMS8Q2eKizXz5AKybD9/dLZzsIGuVXAdIW1nayiGL1QLr5omgsKZq5jbXwbyrPoMxUhP7MWpgf05WiCADs1Vl+/ErfH7yUK/jezX112DPH0gpPwstM3xm2NQ1m9l7xikPt++Midpmc4eX6xeuZ2rKAMam3sd9qfFMSTESKzP62qTPOpiBZYBJVdUyL8cKEMZrLv4Zrx2JoAjkuj3CC5tOcKG6kauXm/m08SiRBh0RYXoiDToiDeJnrDWTBSgodt3hC3s5feoEYcZhtjF6IsN0hOlDOB1gyBRQ9CIiA0T6Xf01pzHZWSJi/B+r0wnD2VXTunSzVwfzsUu1PLJxHwfP13gcS4qJ4KkvTmPe+GXOzshYobu86Qn4+HlnvzEFMj7vbEtduT6PPdLCaDSyadMmD52zkpISSkpKNAag/TxwpgmWlZWRn5+vMaztuPbl5eV5TRdcuXKlI2rBbtDZ18jOztYYea+88gr5+fkUFBQ4+isrKx1rua5n/91oNDrS4xISEjRfDFzfs30+1/fbVrpcenq6xmj25zr4uxdXuuu6hTwNlXDtBAB68MyqcGOhm4N5y9EKrFa1bxXHsFrgnf+Cfa+TAvCnD6i891/sahwujGMvqXv+MqB/OJkptkiL1HhuGBpHpEEW0ZEA0lb2i8s1Tfzp49POjrKTXsdd0Y/nEYMziqxiz1ss/2RUQPZgdzQb3Bzb3pzUep0Og6vD2ofj2qBXbPPqbL/rmF6bwkKXdU99tp3tyl22Odzm04s5Dl0xE37yqsbprrft1XlOAmH1Lc7zXPbu4TxPmwO6MKcO87UTIlvQNcLYT6oHTufJShP2uil71Axq7v+IyPceFLVY7Ez5kvb7gLutLIMx+hzSVpa2csii08PVE2AWEbY6gJZ6kVXug4XjBjoczCB0mPucg/laKfz5Tqg5RzrAG6fhK++gKgrnqhodzuSi8iqOXarB2nGTmeHxUZoC1hmDY2VGXwfpyw7mTDzT8ewU2X5O83Hcncr2hwRuXUVRlgPLAQYNGsTWrVs7sHzHyd/VSHmNFYCC8lKf494MH0mmzmlU/+EPv+d1S45mjF4Bgw4MegjXKY6f4Xp7v0K4y3HRr2DQQbjLOaKtuP0UY7U/IVxtRVUUVF37T5Oy+qUSU+f8PrP/wz9Rmej7n6Ouri7g139QyxBckwRr9r1Nid6pNWWxqnxwqpW3T7Zi9nJjnDVEz/3j9BgqjrDVXd8OwDCfgeMUMo7+DqtOz95Rj1C/54Dj8IAr/2GCy/CrdS0c7MB77I5r0hXi4uL6REGIrr6H1lYRRd/Q0MCiRYt4+OGHef7555k/fz7bt2/XjN25cycAL730Eh9++CFxcc4vTmlpaY5r+q9/Cb3wwYMHe+wvKSmJ2tpa9u3bB0B0dLRmjMVioba2lilTprBv3z7279/PiBEjiIgQRQ6GDRumGa/X60lLS+PkyZOO/qSkJKZMmcK6detYt24dU6ZMYd68edx9991MmTLF4/2779FoNDJ16tQ2r63ZbPY4bjaLL7X2fn+ugz97UVXV0e/rutnpynVrj6ampqD+DaddqiLNpX362H5Ot2z1Od5sVYkKg0a7r6G+hT++s5lRxr7hJFWsZjKOPMegKzudneYmzv5lOd9teQIr/j+4VYBh/RVGxesZbdQxOl5PUpSCotSBtY7aU2f59FS704Qcofa504folbZyT9vJx6s8dcy9UWCdxiM4C8vN1h0kmiYa6HqGgMWqYrGqNJutnTq/Pw3U0b6W8sdKHAtdahFFXi7hZ+8can+B4l2d2heI+5ZeB2GKKCiq18FryiiyFKfs2+rf/ob3w7LFcftLB3pFcfldvHSK4pivukVcNztD+yscLrvIsdGPk2F5nqSrn3ItIZMDhvng8v9o4sXTuIaf7D9RTmXlVvwl1O5Z0lYWSFtZ2sr+/B8Ktp0McKMukgicEg7/2fIhzZEDfI5PbNJ+ThUcusCmzaY+4xztV1fO5M/+h/BWl2fZp3fw8q9W8nLDAkzNHfcm6xVIjdUx2qhjVLyeUUYd8ZE6oBqaq7ly/DRXjgfuPXQ3ofK50ycdzIqi2B+HeTV2VVU12Z6W+1NKNcFlztUIozgdYRivddGOC9i6tjnXAUybNk2dN2+eH9vsPIaSbVDTvm5jgWWaw8F8xJpMveppMFtUsFhA3OPsf+ideHzUAb4UtoXH9G9QqLuJTWFzORY+gfBwg4jAtkVi2yOyI8IncSNOB3NLzQXKBqU6IrXtP+3jyz/bS8b4aR5R3YauRGrX3QBHn3M0Y2tLmTd9IvRL5GRFLY9s3M9nZxs8TkvsF86TX5zArRP8STGcB+c+j67hGtPHfE57aO95cPmuMGBYOh35P7Z169YOje9ujhw5QkyMZxR5d+m0eaO2ttbrHnoSg0E8YImOjiYmJobnnnuO7du3U1JSwi9+8QtNREJTkyjqs2rVKp+FSlzHXbp0yef7u3z5MiCMddcx9msyatQo9u3bR0pKCjExMfTrJwrpREZGesyps1Vyd+3fu3cv69ZGnmbgAAAgAElEQVStY+PGjRQWFrJv3z6ef/55Nm7cyJIlSzTv39se9Xp9m/82YWFhHsfDwsI0+/DnOrjiay+Kojj6fV03O129bm0RGRnJ1KlT/RrbLUQchnJnFkfaoHjS2rmnLLhUwnv7ncVNTVHDmTdvbHftsNupaWpl3xkT+05dYvbeHzOo6VOPMZN1ZTygL+DPFt/ao/3C9bZifKJK9dSUeN+ae2VbRf2AwRMD9C56jlD73OkL9GZbuaft5IjSa7DL82/UnaNqMmetSSTrrtCkGthhnUg8tQFxMHeV18OfIhwLb1tu4h3LTVzSuE+dHFVTaFINRCrCETdEqWQw13yODwQqYLaCa/LyZv0ksgxOB/PE1v281LCgy2vdNiWNefNsxQYXLILda0mc/CXmRbn9dzv5pOZ/6KRpN0PqjX6vE2r3LGkrC6StLG1lf/YWdDsZ4OBAuOqUBblx6ngY5LtQ6myLlRcPFGJqEPfu+lbonzaJmendd+/uKWpK9xC53s25bONLDX/j1eap+GOqxEcbyEqNJys1gazUeCYNd8voU1Uo+TPccHevzPAOlc+dPulgRhi1gZ6vFGEolyEM6UxgraIouaqq5riM63U0tfoXmfGedSbNrQYKrJmcVUOnaMmdysfEKfXcoxZwT2sBv2y4l5ctd3odq9MN5sZwZ7uxbBdPHFvodayDT7Z5dOl1CpFhOiJs0iCRBj0RBj0RYTqno9rNuW0fE2nQsTQmgwG1dsNZ5eDOt9kWfgu/2XSCFrfolC/odnJv4knGfOW3JCR1QHd0eJb3fg8N5t53A5X4h10nbs2aNZpq0vYUsuLi4jbPt6exFRQU+DSuXatMe8NkMmE0Gn2mvrWHyWRi+fLljvXz8/PJzc1l7dq1GqM5kJhMWgPGn+vQUbr7uoU07sWS2pHIACGT4epg3nS0gh8v6h0OZlVVOVvZSJGtEF9xeRXHLtcSqTaxzvBrMvUHfZ7747ANfGSZ5nDuDI+PEoVFbKl7YwfF+CdNZWmFd74v0szH3wXzVvlfcEvSV5G2sp+kJkbz+O3jMFtVjp8sJSU1DbNFxWxVMVus4qfVitmisq3y2zRj4GBUFo1qJOOsVkZZRBRtq2OsOE/TZ3HOYT/eaotatnQmz9eFEcpFpujEZ814XTkrw9Yzo/lFKvG0/1oJ44A6gumKM2xrqu4kH1h71kmxwzqRR9ngaN+sO4geCxY8M1cUrLxseJ4Caxb5lrmImGjvzB2T5GzodDDr294HSg3m6wZpK3cOaSt3M+73nHZs5TC9jvljB/LW3vOOvs1HK3qdg9lqVSm7WuewlxtLP+HJhv8lXPFekC9OaeBxw+v8oPV7HsdGDezvsJezUuNJH9Cv7XoGJwvh3R+IArE3/wBmLIfwfgF6Z9cPfdXBHEiM2Cpbu2rFKYqyGqERl60oynLX6IzexmO3ZWBqaOXQ0eMMTx1BU6uFZrOVplaL7WW19SVxqHUcCWYr/VyONZttY8yW9oqcBpwhXONG/WFN30fW6T5Gw151tKY9WVeKghW1AynIRmqpsfajvkWlvsU/57w7Sthovh3mjMw4suNtfmUe7DEuPaqBNYY3CK81wZ9uhltXw8QlPkX+/cL9A0oazX2W9PR0Nm7cSG5uLrm5uZw6dQqj0egwnjds2EBeXp5PjbXs7GyMRiP5+fmUlZV5HZeenk56ejqFhYVexxQVFbFq1SpH264V5w8lJSUUFRVpDNUlS5aQmZnpsY63ed2NX2+4G60mk8lR1dqOP9eho3vpzusW8nTQaAaYN3YgiuIspH3kYg0XTI0MNUZ1wwa7RrPZwsHzNY4q1cXlJq7WNWvGxNDAH8PXMF2nzb07bR1EolJDjM2QjlEa+dPgf3Bq4ctkpcYzKLaTkZB7XxfOZYDD/4RjH8IjRyE6oXPzSSRa+rStPNQYxTfniHv0VvUs8+aNaWP0pICvb7WqWFThhG61WrHYfprdHdc2J3Wrrd/u/E7+7DlN5lrlgCwemzVbzGVVabW4OMotKkrZdLjgvDfdN6wC45Bkh/O71eJyntXKlavXiIkzOo5bLGaizDVUEquZ12x1/m6fw+zDeX5QHUGl2p8ERWRYxikNTFZKKVE9r/2X9FtYpC9ikb6IL+h28hPzNznjJRBmcrKRm0f66Wxx/1ySwRh9FmkrS1s5JHEPxnB/6OWFheO0DubCI5dZtTi0gwkaWyx8ds7kLGB9psoRhX2T7iB/MDxLtKK1oQ9Y05ioO+1o36X/hHe5hdrhtzjqjWSmxGOMDsdvVBW22ArTNlYJJ3PFEbi7V5otQUU6mNvBVhHbIxRUVdU8RVEygWxCqBBJZ7hjkhCA39p0innzOl+MRFWFsdlkFs7nZlfns8ZRbWubtX3Nrg5t+xxmz3ObWy002frvsn6i2cM+azqnVN9RvqfUwZjUfsTQwFE1hb3WUUTTTD3+OyleMLzAdN0xStWhHFOT+Z35C5SpHRPR326dxLd519Geoz+AEFx2Oo4X3TCI34S/SPgR24dtwzV453uimnfcsA6tp8GsvUlLo7lvYDeq3I2zJUuWsHz5ctatW8fChQspLi7GaDSydu1aVqxYQVZWFq+88oojSiA/Px+j0egwVF955RVyc3PJyspi9erVLF26FBAG99KlSx1z5eTkkJubqymUkpeXx7Rp07wW1PDHoK2srGTt2rWOdUAY0iaTiby8PM3YwsJCh1Hrul5bxmZmZiYlJSXk5eWxbNkyioqK2Lhxo6PfFX+uQ3t7ca2ADXTbdQt5OmE0J/QTheqKy53XcNPRCh6YlRro3XWYq3XNwii2FRY5cK6aFotvndRImnk9/Ckm67Rf2EoZzoupz3Jz3b+5u+pVR/+46h2MG1wDsR3IYHHF3Azbn9H2Tb1fOpclAeN6sJWDiU6noEPUKInyEsHbJqoKH7yv6Rp40wMszUr2fc6hz8HGv4l79bAsZk+Yzeypvh3nIi3XRT6i6jT8ZjL0SxKZEskzYcHjPranOhzN7o7ryH8thBP/dIx96cZqzk+5yeFUt1hVdLUXmfH+eoe+xmz9Id4Y9h7bpz6HxeZsN1utJMVEsHDcIP+Lkdde1LZlMEafQNrK0lbuNXQi22/umCTCdIrjwV3plXpOXa1nxIDQiMJVVZUL1U0Om3nvmSoOXajx+qDxZt0B/mh4hgibXJOdF8138qw5l/ciHidDKXf0r0vfge7rj3V+c8fehwt7tX03frfz813HhJSDWVGUAoQR2hniVVW1303s39ra+/bU1bvPasR+7Y/TemrdkERRFMLDFMLDdMRGtl9wLxCoLz0Bl53t1Hlfo3DCXG1ktVuk9Zaq17hiGEKdNYJms4XcVrdobRfn9tWqGgwRUTaHuBg3RjlHpNLKDUo5N1DO7813dXjfxdYxNKgRjidyg5UqxijnOK4mExdl4Im7buDOfodR/vYP7YnzHuuacxmcUWx2Ekd2bT5JUMnPz2f9+vXk54vCQnl5eaxfv57Vq1c7nvSvXbuWwsJCSkpKHEby8uXLSU9PZ/Xq1Tz00EOYTCays7NZsWKFJp1uyZIlFBcXOyo1r1ixgszMTJYtW+Yw8rKzsx1jsrKyyMzMJCYmhsWLF2v07PLy8hz7fPrppyktLfWoNl1WVkZubi6rVq0iIUHcSkeMGOGIYkhISHAY/nbWrl1LXl6eIx3QtYp1SUkJubm55OTkeKTs2SNW1qxZw5o1a8jOznb0AeTk5Diuhz/Xob297Nu3z/HeMjMzvV63hIQEcnJyunTd7F+AQpZOGM0gIjNcHcyvfXyKK7XNDImLZHBcJEPiIhkSG0VsVFjbKXBdwGpVOV5R64y0KK/i9DVPzfy2aCKcXdZxGgdz84AJpH/9nzzbbwBbtxjg5D44XwxDM+Hzz0NSF+RAiv8MNeecbX0EzP1x5+eTBBVpK0s6xPliqHKp7KkPFzI5bTFyAXx3DySOEjISHaXClqFXfwVOXQGL2edQRVEI0yuE6dFqYQKM/5zGwTyo4mMGpfxcO+bvD4PZpY6MoR/D732eLxvbcKC3R80FCI+BFlsxsH5Joi3ptUhbWdrK7tetL9rKsZEGZoxI4JPSa46+zz23jeHx0aQmRpOaEE1KYj/SEkV7eHy05303gNgz+vaeEZHJxeVVXK5pbv9E4Lg1mfNqIunKJUffpiHLGTbzYbalxnNp+yXYuxIUIXWkm7fK92TtYbXClqe0feM+D0Mmd37O6xhF7WlNgx5AURQjUAWUqarq1XumKIoKlKiq6kOo1q91HHpzqqpmdce606ZNU4uKitofGABCRRjcby4fhpdcIiYUHfzoKMQETh/a45o0VMKaEY6mqjNw7tulNKu6Np3a9ojtZpsDu7nVyrITjzCu9j+Ouf4Wt5yzGd/gwZvTGBhhhhdvhGoXZ/CgibB8C+i76LyvOAJvrYCLn8HYxZD7GoRFtHuanVD7f3LkyBHGjQtu+k8oFC4JNeQ18SRUrknQ/2bs0W124pLhh751iO2cOHOBv619mlz9NuKUet63zOR1S7ZHKnR0uN7hcB4cGyUcz0bRjok0OGQ2VFV1lqJVwdFS0fS3WCwcOFdD8RkRbVHb5NtZ4osog57JyXFMsxUWmZoch3HLY1D0Rxg+A+7bCLYiU1u3bmVeRiKUfwLTvwm6Lhj/rY3wmylQ5zTQmfltuO2XnZ8zCPT0546iKMWqqk7rsQWDQF+xlXvSTobQs4Ha5f2VsNvFyTLu87Ds9YAu4XFNdvwaNv2vsz3tQbjjOY/z2qX6PDznUtRK0cHKU457JYffgQ0PaM+5dTXM+lbH13JFVWHXy7DlabA0w50vwKSlHZoi1P6fBP1zn9CxgUIJeU08CYVrEgp/LxT8DD5+3tle8N9+BQe8+eG/adr5EvP1+7igJvJ3y3zesdxEM55yEYoCQ2IjSUmMJi2xHymJ0aQkRBMXZSDSoCfK4Kwj5Wzr0eu8B3FcrmmipNzpTD54vqbNjD5fxESEMTU1nnmDm/nyoRVE1p+HRU/Djd9xjNm6dSvzIo+K4qtddQQfegs2fs2lQ4Fvf9JmUcVQJFRs5ZCKYA4ULhWovYr/uFSwLvR2vAPYH8UV9vC6oUP1eRER24HKygHjwAZtO31eQJ3LXqk4omkqA8aQnBTnY3A7fPoF+NDpYL5vwEm4LUM0PvyJ1rms6ODO33bduQwiXXH5NjA3gSH09EslEkkfp6NRGVdPwO51jNr3Bj83OCPVloe9xzf177PVOpm/WD7HNuskVHQ0tFgou1JP2ZX6bti8fwyNi3QUFZmWmkDGkBgM7qnZi5+F+BHC+RLRX3ts8ETx6ipFf9Q6l8OiYPYPuz6vpNcjbeUewmqBc0UQN7zrGWgdxdIKB90y4SZ2zFHaKdxsZQZ28kt63DBIGgdXbPOpVji1TURgN5rg/Ue144dNgxkPdW4tVxRFFP+b9iDowrr2kE8ikUg6Q0dsZYtZSDzsXsfdp3c4PHxDlEqydCf4SdgbrLfM43VLNufUgY7TVBUuVDdxobqJT8v8168O1+uIMOgcDucog566ZjPnTd4L8bVHamI0WS428+iB/dHZndgz34Wzu2DKlz1P7OrDRBCf0Vue1vZNuLvXOZdDiT7pYLZRiCgqkmnThnPFnlq4vq0JbMVJ1roWLHHD7rF3/V/Z5XVDnqZq2LUOjr0ntGrikuHhA10rPNdRrFY4kK/tm7Ss+9e94m40d+Hp5qiF4qeig2FZkDZbtM8Vw66XtGNnfQeGBTCVR1Gkc1kikQQHd9335lpxT3dNxbZa4WQB7FoLpZsAV4V6JzpFZYF+Hwv0+3iy9cu8Yrmj+/btA71O4YahsWSmxDsMZL+KD+p0cPN/dd/GWuphp1vU4Ixvdv+DWElvQtrK3cW5Iij5Mxz7QEhFLHgc5j7a/nmBpGwrNFx1tiPiYPTnun9dDwdzF2zlkQuE7R0ZJwJJ+iWJ/sKfaR+e6cJEIEYgncEdyO6TSCSSgOKPg7mhUnzO7HkVqs/6nCpeqeNbYf/iQf0HzGz+PVV0TVO+xWKlxWLtVEZfRJiOScPjyLQV4stMiScppo17beLI7pXzPPgmXD3mbCs6uKULWs6SPu1gXoswUlfYXq7kIlLvNEatzUi+pqrqGlvXets8Oe6T21L8ViMqZrvqxHV43V6HzgA7ngWz7SlV9Vm4dAAGTRBGdPVZEdVcfRZMZ50/79sYuOiNs59qb6RhUZBxe2DmbotAGs2Jo+DeNyDlRmexJUsrvPN9EaVhx5gC83/S+XUkEokklNDptfqWqKLQX5RRGNB7/wa712l1Q9vBjJ69cdlE1gq5ou4kLsrgcCRnpsQzOTmO6HAf5tSFfXChRETC9TS7XxGfyXYM/eDmh3t+H5JQRtrK3cWlA1DyF2f76PvCwWxuhupz3u3khDS46/eB28N+t0y/8XeCITJw83vDYoarx7V9SV2wlad/A274ogiysDuPT++E4te042b/EAbd0Pl1JBKJJJRoqyD2pQMiAOPARpGR7CfnkuayaMgNlF9r4ExlAxeqG+lutVx7Rp89CGPckFjCw1wCSlQVdj4vPp8SvCY2dR8WM2x1i16euBSSxvTsPvoYfdbBrKpqvqIo64DliqIUqKqaD6AoykpENIVG101RlGxgpe33QlVVS1RVLVEUJV1RlI0IY7gIUZTEbhTnqqqqSeHr6Lq9kvBoGDlfpGLY+ctdIlrK0oZwu6nct4PZaulY1MF+t8CWjMUQ0Um9pvqr4qbtz00tkA5mRfF0in/yW6g4pO2743kID43qrxKJRBIQIuNcHMwIx3KUEU4UwEdtFOroP0g4a2OHQdGrjorPYTfcSX7uPaiqSnVjKxerm7hY3cjF6iYaL5dyojGW87WigCs4E24UFEdotOLW7/hdgaFxUSJ1Ly2e9AEuqXttcXY3vL4EmqtB0UPWVztwgXxw+RD8+3HhhIod6ntccy18/Btt36xvQb8BXd+DpM8gbeVuZMyt2vaFEnhmDNRd9j4etA+E3LFaRGSVv9mCLfVw9D1tXwd1hJ1rW4XTOG64p5yPO1WntN8F+g2EfomdWxc8o9dam+DdH7iNGQ1zZOFSiUTSh2grgvnDVXB6h+9zU2+GrK8JR/Tev0KjKJCdvvhhfpk+yTGs2WzhbGUjZ67VUXX2CAeaBnKuqpHGVjNNrVYaW0QNqaYWC01mZ9uXU9qgV5gwLM4RmZyZamRIXBsZfaoKH/0EPn1RRGE/+IH4nOkKVisU/wkuH2xf+3//eqgsdbYVPdyysmvrS/qugxlAVdUViqIUAysURXkFqARKgBFukRQgDOIS23muURN5wCqgAFHRuggoaKvwSAfX7Z2MXax1MDf6odtjOgupXvrPl8Bb34J7/gBDJnkZ4Ia5BQ69re3rqKbc5cMidfjcHmEMj10MX/p/bZ+jqoF1MLtz9SRsXa3tm3SvU0pDIpFI+gqRcVBzztm2G87j7xIO1NqL2vHDp8OMFeJ4mK1QSeYDQlJo9zphSAOKomCMDscYHc64IbHivv3yl4XjJutr4tWWYzYQtDbC8Y/g7e9Aq00H+t0fiAeFE5e0fa4vWhpg22r4z+/AaoYP8mDZX32P//Rl7edyRCzc+L3OrS3p00hbuZuIHSLkz84XO/vaci6DiGRWVe9O5A9XQUsd3P6sfxJnR9933n9APJRLne3f3u0U/QkO/1O8h+Ya+PIGGLOo7XMqDmvbgbSTAbb/Cq6d1Pbd+dvuj8yWSCSSnqQtB/PMFZ4O5rBImJgrjtlreExaKrKgD/5DBHCMuEVzSkSYnlED+zOq+Qh88gXuSb1ZFJfOuMNpa7uhqirNZitNrRbhhG4VwRuqCulJ/Yg0+BkwWH1eRA/vtdmy1Wfgz3fC1z/ovJTb5UPC3j63R7QzbodR2d7HWlqFXe3KlC93rxzHdUKfdjADqKq6DljnxzgTXiImbFEV+Z5nBGbdXsuYW0UkhdqBVGTXonV26q/C+geEo+HVHPj8b2FyO1rKJwugyeW7R1RCx52wVrO2SOC5Pb6Nejt1Fdov7GFRYEzr2Lo+92MVN0TXqI/oRFj0VGDml0gkklAiOgGi4mlUI4gyOguOoDeICOUtT4I+HG64G2YuF44abwzPguFrfa9z5lMRxQDCkNy2WkS7pcyE5JmQPAsGjO5aDYHWJji3G07tEKnb54vA0uI2SBX76KyD+WC+tpr4kXeEtuvY2zzHNprgPy9o+278rlOKSSJxQ9rK3cTYxVoHc3u0NghNTfeI38/+Drtt97nLB2HZ60I+rS3cM/0m3KPVufeHSwegbIuzfW6PHw7mbgzEuHxIex8EyPo6pN4UuDUkEokkFIiIFU7jyDjqrQb6ud7zx9wGcSnCtxKXLJzCmV/xbucZomDq/eLliz2viJ/lH4tXWJSwu5NnQMosEeRhm1tRFCJtxf06RM1F4RQ/vUPYy95k8BquiQCTzjiYVVXIjLp+5v7rR/CdT0X2vTt7XxfZ9XZ0hp6vk9BH6fMOZkk30T9J3Mx2u30viIgDY7K42bn/dH8iZDFD/tedUWzmJnhrubgxLHpSOBq84a4pN+Fu32N9MXA8GKKFMQ8ius1UDvFpvs/xiMrI6Lix7ou9f4Xyndq+W1d3La1QIpFIQpWvvguKwq6tW5k3b572mC0amayvQf+BdAn3zyiAayfEa+/roh0Vb3M2zxSG9NCpbUcImpuFo+X0TmEkn9vTtjwUwLyfdC3tbsp9QnPU1XB+/1FIm+OZsv7pi9pIl0gjzPp259eWSCSdI+vrsOcPbhkZCsQM8WIrp4if7lFrFz/TSkJc/AzW3gJL/ijk6rxRdwVKN2v7OiOPMXy6kCKyY48Ka4vucjBbLcJ5YHUpKtV/MOT8b2Dml0gkklAiaSw8LrJe9rjbyvow+NwTorjpmNtEu7PUVcCht7R95kbhl3D1TQwYqw3OSBzZdnBG7SVhJ9sdyq5SFN7olwQPvA2DJ3TufSgKLH4G/rDQGQBpKoftayD759qx5mbY/oy2L/MBiPeWai/pKNLBLOk8t60RERGNJqGXY/RiGLeFaoUBY+DUdm3/7rVwaT/kvgYxg7XHLK3iyZorHZXHAHEjHpqpvXGeK2rbwXzlqLbdlaIl7hhTYOHPRPrKmU9EOkdnI90kEokk1GnLKO0/MDAaaKoqHDnh/UVquS8aq+D4h+IFIophyGTIeQLSbtaOvVYKL93UoaIqfO4XcNP3O75/V3R6oce/bh6oQkea6rMivXDRk85xqirkOVy56fsd+2yWSCSBoV8ifOc/cGaXiKCKSxZSFT5Sj70SFinOu3bC2ddYCa/fDQv/RxTudL+fnt7hvE+AsFcHdeJL+/Dp2vb5EpFx11ZwhYeDeXzH1/VGS53Ibkm5Efb9Tdy3b39G3tskEknfpL3Muhu+GJh1GquE07gtTWeAq8fEy168NjpRZI/k/sXzM2Hzk8Kx6y8xQ+Er/+x6cb1hmTBjOex62dn3yQtCOsS1COz5Em3NA32E1PEPIAEKv5RclyiKiPYae6t42tRRIy8sXGjJ3fWi+MN25cx/RITGmV3afr0BHj4AS/4kUg8TR4v0jc4wfJq2fa6o7fHdpSvXVC3SnUv+LJzLhn5ClL4rKdsSiURyvaMocOtT8MhREdUwZIqQdmoPa6uQufAWxRyfBmERnv3exk29Hx78d9edy3aGTIIbv6Pt+/RFEdFoR1Hgm5tEEUBjivgCMPNbgVlfIpF0nKh4YSePmAsJIzrmXAYRxfbQZhjrVhRatULhz2HDV0RRT1cm3A0/+AwW/DckZcCk3M7ZlIkjRQaEneYaUezPF+ZmT33kpLEdX9cbF/bBkXeFLnRjFYz7vHhJJBKJpPMkjYWv/UtISUz7hiim7Q8N16Cq3PsDx4EZ7Z+vM4hI6Hmr4Nsfd925bGf+T4XD2o7VDO8+LB6O2km9EX6wT2Tj6www7esQNyww60tkBLMkBJh6HwwaD+u/otVprrsEr90Otz4tbgB249gQJYznCXeLiObOOmLdIzPaS/3rrqiMiFioPgdVp4Xz445ft6+tJ5FIJBL/iIiBGQ+JV3OteJh4djec/RTO7oGWWs9zDNHOIimu6PSiOrdrkVsQWngj5gjJirTZIqOnO5i3ShS5rT4r2qpNv/+bm8TeQGToTL1fZPdcPe4poSGRSHoXkbFCd3nnr2HzLwDVeezIO3DlmDju+gU9Pg3m/hjmPKKVlegIiiKCMU4WOvvO7fHtPLh6Qhs5HTs8cBHGMUNEmnVrPSSki4eGEolEIgkMA8cJH8TtzwppibO7RR2Ts7tttUxUz3NSZnmfy1tBWZ0te3yEzU5OnimKXweayFhYvAbWu2hOn9sNJa+JLBg7sUPFe735B8LmlwQM6WCWhAZDp8LyrfCPB6Fsq7Pf2grv/1ikMtzxa8+Iso5qL7viHsF8ab+IvvAWnaaqUOEmkRGoCGZFgS+tF86O/oNk9VKJRCLpLiJihG6pXbvUahEPD89+6jSmTeWiuImvz5e0OXBxv9NITpvTc7pt4f2EQfyGizTUhb1C53XmCu3YsPDOa9lJJJLQQqcTDuOhUyD/G9pi11ePwSsL4Isvw7g7tOcpShdt5emeDubMB7yPdZeSC2SBv6Qx8MODovDg0ClSGkMikUi6A0URDyjj05za/U01IrPvzC5hL58rErJFyTO9zxEzCAbeIPw2DofyrJ4LeMi4Q2S6uwaDFPxcZAK5FxCUQX0BRzqYJaFDv0S4/03Y/H+w8zntsc/ecFbODtQX+ZjBzgqsAJYW4TRInu451twsot8qjgipjCaTePIVKHQ6WQVbIpFIehqdXjhhB08QmTIgCpM0mnyfM2O5KJoXLBmjMYtg/Bfg8NvOvk3/JwxqmeInkfRtRmXDim0iOuvSAWd/Sy2sv09ELM//qTOjoat0RE7OmCIKG145CpcP+5cm3RGiEyD9lsDOKZFIJJK2iYyFkQvEC2zBGcLavx0AAB9LSURBVIdFfQBfrNjeteKDXUFRRK2wsm0i6wWguRo+WiUK5Eq6FanBLAktdHpR6XPpX0RhJlcu7Yd1t3hWxu4Kw7O0bV8yGYZIyP4ZfPnv8PB+eOS41EiWSCSSvkjM4LYdI/qw4N//b/2lkFey01ILH+YFbz8SiaTniE8T+u6T7vU8tuNZ+NsSaKgMzFrD3OzkisOems92kmfA55+HBz+Ex8qFBrREIpFI+hY6vZCRizL6HhMs57IdYzIs+Km27+A/4ESh9/GSgCEdzJLQZPxdoqhJ4mhn39jF8LlfBE77GLxUyG6n0J8dQ2Tg9iCRSCQSSUeIHQIL/0fbd+RdOPq+9/ESiaRvER4tJDFu+5XQtgRRkG/Wd+Gm/wqctmVUPAxwLb6kClme9lAU/wqiSiQSiUTSHcxYAYMnafve+xG0NARnP9cJ0sEsCV3slbMzbHpyZz4VWsxVp4UmciDoaKE/iUQikUhCgWkPwjC39PWPn4eW+uDsRyKR9CyKAjOXw9feEzU8mkxQvhMuH4LGqsCt436fkbayRCKRSEIdfRh8/jeAS9ahqRz2rw/alq4HpINZEtpExsLSv4pIrcYqKHoV/ngrlH8SmPkHTwKdS/ET0xmovRyYuSWSHiA/P5+cnBwURUFRFEaOHElWVhY5OTmMHDnS0V6xYgUlJSXB3q5EIgkUOr1IR1dctFbP7oJDbwVvTxKJpOdJmSX0LpNnwcXP4N8/hdfvAYs5MPN3RIdZIglBpK0skVynDMv0LIJd+DPfUk+SLiMdzJLQR6cTRUu+tUMULvnqO5B2c2DmNkTCELfUCX9lMiSSEGDJkiUUFBSQnp4OQEFBAcXFxRQUFFBaWkppaSmvvPIKgMN47iwmk4l169YFZN8SiSQADJ4I8x5ztodlwaRlwduPRCIJDjGD4avvwj2vQs4TcN/GwGlgesv2C1QmoUTSA0hbWSK5jpn/U63UU/bPISImWLvp8wRZfVsi6QCDJ4pXoBk+Hc4XO9vn9kDG7c52Uw3UXoKE9OAL1kskPjAafRdayMzMZO3atYwcOZK8vDwqKyvZuHFjh+Y3mUzEx8eTnZ3N8uXLu7pdiUQSKOY+KiIM6ypErQK9of1zJBJJ3yMsHCYuCfy8A8eDIRpabbqV9VdEmnF8mnNMZRmEx0D/pMCvL5EECGkrSyTXIZGx8OBHcPxDMKZA2uxg76hPIyOYJZLh0yFhpKjGvfgZmPxl7fFT2+H30+GpIfDSbNj+THD2KZG0QUJCQrtjVq5cSXp6Ovn5+eTn53dofrtR3pZxLpFIgoCiwMgFMPleYURLJBJJINGHQepNQoLjxu9B7p8hOlE75v2V8MwoWDMSXrvDv0KAEkkPI21lieQ6JToBpnxZOpd7AOlglkgm3AP/VQJ3r4UZD0HSGO3xiiPip6UFLh8Q0cwSSS/FnvZXUFDQqfP9Mc4lEolEIpH0Ie7Lh298BIuehBu+4JlebLeVG67C6R2gD+/5PUokAULayhKJRNI5ZL6/RKIobR+vOKxtDxzXfXuRBJ6fx3XuvCGTRdEcb6ydKwrp2OiQitPP/397dxMbx3nfcfz3SIpsx5azpJU4Tpw3Mm9oEbRdSpcWaZN6eejLraSM9tBDUVO3oAUKEjoVPRnUrceVixRoLpapnnopQLowkAYtKpFBgaIvacnmxUnaRBa3cpzEUux/D/PMcjgz+z67M/Ps9wMMVpzZGc78OXz40+wz8/zfePtTkPj5c3t7e915t27d0osvvtgd2KTVamlnZ6fbA+Po6EhbW1uSpFdeeaW77s7OjprNZu76X/7yl3XhAs+3AgCg9vpk5bM/e0u6//rJjDPnpKc+NYOdQmHIyqeQlQFgPPRgBgb54b+f/voDP1fOfgAFiEPzvXv3JElbW1vdwU6Oj4+1vb2tvb09vfDCC911FhcXde3aNUlRIN7d3dXu7q6azWbP9b/0pS/N/uAAAMBMPf7Wd07PWFyOngcN1BRZGQDGQw9moA/37kPp7jdOz/zAZ8vZGaAAR0dHkk5u37t8+bLW1qJBgRqNhjY3N7W7u3uq10aj0VCz2eyuFwfvfuu/9tprszgcAABQosff+vbpGdzph5ojKwPAeLjADPTx2E++L737s5MZF56RHlsob4eACcWhudVqSVI38Erq3rbXaDTU6XSG2t6k6wMAgPp6/K1vnZ7BnX6oObIyAIyHC8xA0ttvRiNfv35buvyH9MoIwTSe45Z63tybb75Zm2eo3b59W9LJACbxM+NWV1d15coVNRqNU70uBpl0fQAAUBNmUufb0nfvSD97IP3i7+ZkZe70qx2y8ilkZQAYDxeYgdgrvy/9299I9m709Yd+iV4ZCMre3p5u3bqljY0NNZtNdTodrays6MqVK9rY2Bh5e5OuDwAAauLuf0p/+ZvSWz+Ivm58tMcFZrIy6ousDADjY5A/IPbo+04uLkvS63eyofn99MpAPXU6Ha2vr6vRaKjdbkuS7ty5o06no+Xl5VPvTT5TLi0e8GTc9QEAQA297yPST45Pvu58W/rff9X5h4nb/M8+Ii18Yvb7BhSArAwAk6EHMxB79rJ08FcnX79+m14ZqI34eXFpnU5HN27c0NbWlpaWlrS7u9tdFg9e0m63u700bt682ff7xD07jo6Ous+mG2V9AABQQ+95VPrg56TvHZzM+/pXTr/n4qels/z3EtVEVgaA6aIHMxB79vLpr7/599Egf0nv/8zs9gcY0tWrV7uheXl5WQsLC91pZWVFt2/f1s7Ojg4PD089863ZbGp7e1v37t3T+vp6933xe1ZXV7uDkUjq9uaIe3eMuj4AAKixdFY+SF1gZqwSVBRZGQCmj4+YgdjFT0vnL0gP3oy+fvhjueTyxsekR54oY8+AvtrtdjfQjmpzc1Obm5un5u3s7OS+d2NjI/P8uF7r12kwFwAAMIRnL0v/lMgbcWaOcYEZFUVWBoDpowczEDtzVvpws/dyQjMAAADm1bOX+i8nKwMAMLe4wAwkpW/9SyI0AwAAYF4tfFx671O9l5OVAQCYW1xgBpLyLjB/5reiEbE/8POz3x8AAACgCpzLZGXTGemjvyw9+az0vo+WtGMAAKBsPIMZSErd+veuO6szv/MX0vn3lrRDAAAAQEU8e0n6xt92v/yfD/66nvmDvy5xhwAAQBXQgxlIevxidPufd8bekb7/z+XtDwAAAFAVqR7MT97/j5J2BAAAVAkXmIG09GMyXr9dzn4AAAAAVfKhpiTX/fLxH39H+kmnvP0BAACVwAVmIC19gfm7d8rZDwAAAKBKHn0yO5jf9w7K2RcAAFAZXGAG0lLPYdbrXGAGAAAAJEkfXjn99ev75ewHAACojOAH+XPONSRdk9SUtChpT9JNMxvqo3bnXMPMBt73Fb/Pf78dPzu9XsO/bpvZ3lAHgNl7+nPR62ML6px/Ro2Lz0g/vR/12AAAAAgIWRkje+YXpK9/RXrqkzp+571aKHt/AABA6YK+wOyca0p6VdKWpBclLSkK0PvOudUhg+uxc27wu6QDSfHH+a0B720Ps0GU5Nx56eOfl775VT350zelR89K9k7Ze4U+zExD/p4Cc83Myt4FABVCVsZYlr4Yvb7xX3r8PU9KD98qd38wEFkZGIycDEwm6AvMigLzDTO74b8+kLTunDuUtOucWxiix0VHJ70p8t4bL9tKzV9R1Ask+Z4YDyqruuf+VHr593TmrR9In2pJj9E3o6rOnj2rhw8f6vz582XvClB5Dx8+1NmzZ8veDQDVQVbG6C5+UvqVP5K+9ueSzkif/e2y9wh9kJWB4ZCTgckEe4HZObepKKzm9YC4JWlT0hVJN3KWp630uk3QOdeWtJTu4THsbYWoqI9clv74X/TV1/5On2/9Rtl7gz4uXLig+/fv6+LFi2XvClB59+/f14ULF8reDQAVQFbGRFb/TPrVP9E/fO0f9Wvp8UtQKWRlYDjkZGAyIQ/y97ykjpkd5Szb9a/rQ2znXp/A3JC0IelqatHA59ChBs49onfOPVb2XmCAxcVFHR8f6+7du3rw4AG3NgEpZqYHDx7o7t27Oj4+1uLi4uCVAMwDsjIm88gF2Zn3lL0XGICsDPRGTgaK40L9A+OcM0kHZraSs6wh6VhRqO777APn3I6Z5YZr59yOolB9NTGvIWnfzJYn2PcNRWFcTz/99MrLL7887qZG8qMf/UhPPPHETL5XXVCTrCrWxDmnRx55ROfPny/l+XI81y6LmmSVWZM4PL/99tuV+o9lFduTslGTrFnX5Itf/OK+mQXfJbOuWbmsnCzx+5mHmmRVsSZk5eqhJlll1aSqOVmqZntSNmqSVZWsHOQjMpxzS/6f9/KW+xGspezz3vLe2yswNyWtSZmBkxcT+7CtaETuJUXPkmsnnnHX73vekL8d8dKlS/aFL3xh0CqFeO211zSr71UX1CSLmmRRkyxqkkVNsqhJFjXJoibFq3NWLisnS5yLeahJFjXJoiZZ1CSLmmRRkyxqklWVmoT6iIylwW+Z2EuStnoMfLIk6dC/Him6DbApqe2c2815PwAAADArZGUAAAAUJtQLzFMVD4piZtdzFjcU9cBYNrMVM1v1txbG7235W/sAAACA4JCVAQAA5gsXmEeUuJ1vK2+5mR34sHyUmr8lKR49e5gBUwAAAIBaISsDAADMn0pdYHbO7TrnbMwp+Yy4OLAOGgJ0nBGs24oGRLk1xrrb/nUWtyUCAAAgIGRlAAAAVFGlBvkzs9WCNhUPWDJoYJKjActPcc6tSWpJGnc/4+83TlgHAADAHCMrAwAAoIoq1YO5KInBRHJ7PyRGzt7LW95jnYaiwUoOzGzo9VLiED/u+gAAAMBEyMoAAAAoUpAXmL09SXLONXOWtfzrzRG295Ki0Jv7PDn/vbYTgTzPJf/64gjfFwAAACgaWRkAAACFCPkCc9u/Xs1Ztq6od8VBcqYPvZvpNzvnWpLWJB0N6JFxM/F909toKHqu3Hqi1wgAAABQBrIyAAAACuHMrOx9mBrnXFvShqKgesvP25R0TdKp0at9MN71X64kA7Vz7lDRLYRXzezGgO95KOlAUXi+o2jwlJai8L416i2DzrkfSvrWKOtM4KKkuzP6XnVBTbKoSRY1yaImWdQki5pkUZOsWdfkY2b2/hl+v9LUPSvPOCdL/H7moSZZ1CSLmmRRkyxqkkVNsqhJViWyctAXmCXJObehqBfGJUUDmhxIeiHdM8L3mnhVksxsJTF/U1Fvio6ZLQzx/dYUhfKmogFK7kjaNbPrhRzQFDnn7pjZpcHvnB/UJIuaZFGTLGqSRU2yqEkWNcmiJtNFVh4e52IWNcmiJlnUJIuaZFGTLGqSRU2yqlKTc2XvwLT5XhR9e1L493UkreTMvy5p6MDre3/cGmUfAQAAgDKQlQEAADCpkJ/BDAAAAAAAAACYIi4wI2lg75U5RE2yqEkWNcmiJlnUJIuaZFGTLGqCquBczKImWdQki5pkUZMsapJFTbKoSVYlahL8M5gBAAAAAAAAANNBD2YAAAAAAAAAwFiCH+QPwGB+RPdtSatmdjTG+g2djAi/KGlP0k0zOyh0R2do3Jr4Wuz4LzupxQ3/um1me5PvJQAAAKaNrJxFVgYAJHGBOWBFBZmQAtGkxxJSIPLHsiHpqqSlCbbTlPSqpC1JL/ptXZO075xbrUMtYkXVRFJrwPL2BNueuURdLiuqy5GkXTMb+VlPobQnRdQkpPZE6h7PtqLzP67JgaStUf8zHth5MlFNQjtP0pxzS4r+fiyZ2eqI6wZxnqA8ZOUssvIJsnIWWTkfWTmLrJxFVs4iKw9Wq6xsZkwBTv4EOlbUqDf81zuSTFJr1tupwlTEsfj1bMC0VvaxDnEcG35fjxU16Mf+66UxtnWsqMFOzz/022yUfbyzrEniHGkq+kPZkrSWmkauc4l1aSVqkZ4OR/n5htKeFFWTUNoTfyxLiZrs+p9rskZDn/MBnSeF1CSk86TH8e3GNRpxvSDOE6bypqLOoZDOxSKOJZQ2S2TlqdVEZOV+2wqiPSmqJqG0J/5YyMpTqklI50mP46tNVmaQv0A5544l3TCzrdT8Q0W/yAtmlv50Z2rbqYIijsV/AnQsaUXRJ0DSyadisQMb49a5WfK3tC2a/wQ5UYPlUfbdObepKGBm1nPObUvalHTVxvj0ftYKrElD0rGZuens6Ww55/b9P18wswP/CWp8S6Qk7dmQn6SG0p4UVZNQ2hOp2xY8L+m5+Gfoj29f0c92Hs+TQmoS0nmS5tvdlxQdz9DniF83iPME5SErZ5GVT5CVs8jK+cjKWWTlLLJyFll5sNpl5bKvxjMVPykKKrmf+Chq1E3Sxqy2U4WpwJo0ol+b8o+p4Poc9qrPgPX2FQXEvGUtjfFJW1WmCWrS6FWTOk6+Dnm/N/HvlA25nZDak6JqEkx7ouiT9byaxO3AUL8TgZ0nRdUkmPMk59j2ddIjbmeE9YI5T5jKmcjKU61JkG0WWbnQmpCV87cTUntCVs4eC1l5ejUJ5jzJObZaZeUzQoiel9Sx/E9odv3r+gy3UwVFHkvlPw2coaai5yTlueNfL81oX6rkXtk7UKDc3xszux7/2z9bcJCQ2pOiaiKF05706hUQtwPD9hgI6TwpqiZSOOdJl++519Z47WVI5wnKQVbOIitPB1k5H1k5K6T2hKycRVbOIiv3UceszAXmMBUVZEIKREUeS0iBaGz+ViepRz3s5HaL9O0poVuUovo453acc4fOOXPO7TvnNsreuTE812dZJ/XaT0jtSVE1kQJpTyx161VC3E4MO1hPMOdJgTWRAjlPYv7vR8vGvyU8mPMEpSErZ5GVC0ZW7omsnC+k9oSsnEJWziIr91bXrMwF5sAUFWRCCkQFH0togWgSk4wcHbol+VvDFDXsHUWNfNs5t9tvxaqx/s9laqj3J6NdIbUnUjE18eahPbmm6HlhA8NRaOdJH0PXxAvxPGlLemGcFefoPMGUkJWzyMpTQ1bujaycEFJ7IpGVR0RWziIr1zQrc4E5PEUFmZACUdHHEkwgwlQ0JB0oGvBkxcxWzWxBUnxLWKvGf+i6EsfQ65PnpJDak55GrEksyPbEB7y2olHChx2MIujzZMyaxII5T5xzLUlHZnYw5iaCPk8wE2TlLLIyZomsnBVSe9ITWfkEWTmLrBypc1bmAjMwmrkIRBifmR34c+MoNX9L0p7/si7PxepnS9Fzsyo/6vkMjVqT4NoT59yac84UPdtrQ9ExHPoRkOdSATUJ7TzZ1mj/sQRQL6G1WSgYWXmukZXJyhlk5YzaZmUuMAMjmKNANIy4BosD3hfcA/cnsO1fa/3psx9wQOr/fLW5Mk5NAm1PDszMmdmymTlJVxWd7ztzHJwnqklI54lzblNSe8CtswBqLKQ2qwBk5dGRlQNFVu4iK2eRlb26Z2UuMIenqCATUiCa1bEEEYhGED/TZ9Cze0YZ/TV0cS3q8HuTy/+R35C0OsIfvpDak4wxazJILduTnGB3Q1LcS+XagNWDPE8mrMkgtTlPnHMNSc8X0JMryPMEM0VWziIrTwdZeXRk5f5qWRey8gmychZZORJCVuYCc3iKCjIhBaJZHUvtA9EoEuEgt7FOPFx+L2/5nIrPwVrWxDnXlPSSpOeGHJgjFlJ7csoENRkkpPYkfu7ZoGAX7HmSY9iaDFKn8+QlSU0/6Ep3krTjl68l5jf7bGeezhNMB1k5i6w8BWTlsZCV+6tDe3IKWXkoZOUssnINs/K5ojeIcplZxzknTRhkitpOFczwWGodiMa0p+iZRs2ch9C3/OvNGe9TafytX+0+4emSf31xRrtUGP978qqk9VEHHAipPUmapCZDqE174pxrDOiNEi/rG2JCOk+KqskQanOeSLqt/ONtKvp7cSTplvzo8r02EtJ5gnKQlbPIylNFVk4gK+cLqT1JIitHyMpZZOVctc/K9GAO057U/bQwbZQgU9R2qmDiY3HObSd+GfPUNhANwx//Zmp2279ezVllXdHzlIoOE5WRU5ObOqlJ+r0NRbforNftmUp+33clvWBm4/4hCqk9mbgmgbUnG360417in/kwxxLKeVJITUI6T8zsupltpSedtJkHft7VIXo4hXKeoDxk5Syy8oTIyllk5ZGE1J6QlU8jK2eRlVOCyMpmxhTYJGlNkin6dDi9bFfSfs78bUmbk26nqlMRNVHUyO322H5D0rGktbKPdcz6mJ9aPZa3Eu9pppa1/fy1xLxNX4+lso9t1jWRdKjoNpaWPy+WFD1zbL/Xtqo8+WM4lLTRY1kj/XOeg/Zk4pqE1J74Yznss/y4x8892POkqJqEdJ70qUX8M9/psTzY84SpvGmccyj0c7GImoTcZomsXFhNRFaeh/aErHx6f8nKU6pJSOdJn1rUJiuXXiym6UyjBJl5CURF1CSkQOQbon1//JaY9tONlz/W/V4Nka/Brt9WXKNG2cdYRk18Y77v1zv2ddmc1TFMoSb7qVr0mhr+/cG3J0XVJLD2xPzxtFLHvS9pO+f983CeFFKTkM6THnXajms1j+cJU3nTKOfQvJyLRdQkpDZLZOWp1ERk5eDbk6JqElh7QlaeUk1COk961Kk2Wbn0YjFNb9KQQUZzEoiKqIkCC0RMTP2mxB+zUQJi0O1JkTUJqT1J/VzjsNjuFV5CP0+KrElI50nimJb8cRymfmcO/fyleTlPmMqdJs2Fo26nDtOkNQmxzWJi6jUVmQsT26x1e1JkTUJqT4rKhaGcJ0XWJKTzJHFMtczKzn9TAAAAAAAAAABGwiB/AAAAAAAAAICxcIEZAAAAAAAAADAWLjADAAAAAAAAAMbCBWYAAAAAAAAAwFi4wAwAAAAAAAAAGAsXmAEAAAAAAAAAY+ECMwAAAAAAAABgLFxgBgAAAAAAAACM5VzZOwAAQD/OuUZ6npl1Zr0NAAAAoErIyQCqgh7MAFAjzrlt55yNMTWcc02/fiZEVpXf1+PE9Kqkl8bY1I5fN7ktAAAABIKcTE4GUB4uMANAvbwh6ZakZUkLiSnuZXA9NX9F6vZC2JG0KenabHd5fKneE6tmtmJm62NsZ9XMViTF69IrAwAAICzkZHIygJJwgRkA6qUjadfMjsysE0+S7vnlh8n5ZnYg6cgva8frl7DfRbhTwDbiWtzr+y4AAADUDTl5MuRkAGPjAjMA1Ms9nYS/YR1IkpldN7MFM9srfremqsheFPTIAAAACBM5uTrbAjBnGOQPAGrEzG6Nsc7It8oBAAAAdUJOBoDycIEZAJDhnFuS1JS0KGnPzI4SyxqSWv7Lg+SyHtvakLQqqaGol0h70Doj7mtD0fPylvx0pOj2xlcYARsAAABFIicDQBaPyACAOeBHxt5wzu065zZzlm065/adc2s+6B4qGuykLenQz5NzrqVoZOkdPx2mt5fYbss5d6woMG9JuqoojHe3V8RxSfpvSbd9D5TnFIXmtk7CPQAAAJCLnAwAk+MCMwAEzofda5K2lQqTPnjGy5uKwu2qTkbfvu7f2vYBeUvSipk5/15J2vbbSX/PXUk3/DPtjvy0mtheo4DD21HUA+OWFI2mbWY3EvsNAAAA5CInA0AxuMAMAIEzsz3fa+GVnGUHZnZdUjygScfM1hOjb2/pZLCU581s1Y+4LR9Q42fdPZ/adNu/Zytnl+J1rox/VF3x7X5pN+UHbQEAAADykJMBoBhcYAaA+THMc9Zu5szbS70m7frXbnj1vTSW+ny/OIivDLE/g3QktZxzO743iKTufwgKe34dAAAAgkZOBoAJMMgfAGCQOAC/kbPsXs68OEQ3/LPl7ul0iI4HMTksYN9eUHT735qkNeecFAXztu9xAgAAAEwLORkAxAVmAMBgeYF5GB0zWyh0T1LM7JZzblnRc+7WdHIr4LZz7nkzK6L3BwAAAJCHnAwA4hEZAIDixbfcFTE4yUD+OXhbZhYPuBI/z66ZHlQFAAAAKBE5GUCQuMAMACha95luzrm1aX4j59xO8ms/4Mp1STf8rGGepwcAAADMAjkZQJC4wAwAGOSp1GtfZtbRSXB9Ka93hHOu4ZybqOeGXz9vZOzYEQOYAAAAYIrIyQAgLjADQCjiALnc5z1xUM0LwPGyxT7L+gXdU8vM7Kqi0bQbkvadc23n3JqftiXt99nWsBYV3d63nZzpnNuQdEXSagHfAwAAAPVGTvbIyQCmhQvMAFBTzrkl59y+H4E6tunnbSfet+ac25e0kXpPyzm36Zw7lNTyy9rOuV2/7fR6G369vNv5Wn7ZZjzDzFYVPeftwG9jR9I1SW+Y2bLvwTGpW4pGxTbn3KHf32VJn6BXBgAAwHwiJ0siJwOYIWdmZe8DAAA9+f8YNCQtTBq2nXNLkg4V3RbYrxcLAAAAUGnkZABVQQ9mAEDVFTnK9kxG7AYAAABmgJwMoBK4wAwAqIu8596VsQ0AAACgSsjJAErFIzIAAJXmnIv/UO0pej7dkZntjbiNNUWh+aqkpiSZmStyPwEAAIBZIicDqIpzZe8AAAADXJf0hv93QycjgY8iXuemnwAAAIC6IycDqAR6MAMAAAAAAAAAxsIzmAEAAAAAAAAAY+ECMwAAAAAAAABgLFxgBgAAAAAAAACMhQvMAAAAAAAAAICxcIEZAAAAAAAAADAWLjADAAAAAAAAAMbCBWYAAAAAAAAAwFi4wAwAAAAAAAAAGMv/A2tMmvnvmq46AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(20, 6))\n", + "a = 0.48\n", + "b = 0.52\n", + "\n", + "\n", + "bump_data = np.load(\"models/bump.npy\")\n", + "x = bump_data[0,:] + 2\n", + "y = bump_data[1,:]\n", + "\n", + "plt.subplot(1,2,1)\n", + "γ = 0.0 # weighting on robustness loss\n", + "data = np.load(\"models/bump_data_%.2f.npy\"%γ).T\n", + "xx = data[0,:] + 2\n", + "yy = data[1,:]\n", + "\n", + "plt.plot(xx, yy, linewidth=4, label=\"Reconstruction\")\n", + "plt.plot(x, y, linewidth=4, label=\"Data\", linestyle='--')\n", + "plt.plot([0,4],[a]*2, 'k--', linewidth=1)\n", + "plt.plot([0,4],[b]*2, 'k--', linewidth=1)\n", + "plt.ylim([-0.8, 0.8])\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.legend(fontsize=fontsize-4)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.title(\"Neural Network Only ($\\gamma$ = %.2f)\"%γ, fontsize=fontsize+8)\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "\n", + "\n", + "plt.subplot(1,2,2)\n", + "γ = 2.0 # weighting on robustness loss\n", + "data = np.load(\"models/bump_data_%.2f.npy\"%γ).T\n", + "xx = data[0,:] + 2\n", + "yy = data[1,:]\n", + "\n", + "plt.plot(xx, yy, linewidth=4, label=\"Reconstruction\")\n", + "plt.plot(x, y, linewidth=4, label=\"Data\", linestyle='--')\n", + "plt.plot([0,4],[a]*2, 'k--', linewidth=1)\n", + "plt.plot([0,4],[b]*2, 'k--', linewidth=1)\n", + "plt.ylim([-0.8, 0.8])\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.legend(fontsize=fontsize-4)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.title(\"Neural Network Only ($\\gamma$ = %.2f)\"%γ, fontsize=fontsize+8)\n", + "plt.grid()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intent prediction example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### generating data" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAGoCAYAAABbtxOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdd3Rc133o+++ZPpiCGbRB741gB4tEkWKRSNmWLBdZlGzHJXKR7MQ3zstLpJt3fW/uzc2zo+S93CTXJbRsy5ZlOxal2JbVSUkUxU6CnSBAotfBYAqm9zn3jxmAAFEIdlLen7XOgjhzzp599sxa+s2e3/5tSZZlBEEQBEEQBEFIU9zsDgiCIAiCIAjCrUQEyIIgCIIgCIIwiQiQBUEQBEEQBGESESALgiAIgiAIwiQiQBYEQRAEQRCESUSALAiCIAiCIAiTqG52BwRBEARhJpIkNQObgRpZlp+42f0RBOEPh5hBFgThliJJ0pOSJO2QJMkjSZIsSVJn5t+PS5Jkudn9E64/SZIeliSpE2gBngZW3uQuCYLwB0YEyIIg3BIyQZEH2EI6KFoB1ABPATnANtIB020hM/spXAFZll+UZXn8vb8ubrf353brryDc7kSKhSAIN13mf/7bgR/O8FN6F/CiJEk7gLEb3rnLJEnSZtLBfA5gvcndud11XesGb7f353brryB8UIgZZEEQbgVvA1wiz3Q74L4x3bkqzUA1t0df/xDdbu/P7dZfQfhAEDPIgiDcVJIkVQMWLj1buHMe59wKxme5b4e+/iG63d6f262/gvCBIAJkQRButvHcypy5TpJluYs5goTMT9FPcGG2bYcsy/8wnw5kgnS3LMs3LIUjk1byKOn7zwGOAC2yLP/wKtt9ElhFehwgPWY7Zmv3Vhu3K2kzs3izOnN0ybJ89Br047LavJHjLgjCDSDLsjjEIQ5x3LSDdIAoZ45tV3C9BdhBegFfc+axhzPtdQLVs1xXnblOnnR4SOd7biMdrF5JX7ZPeu0nM8fTgGXSedsyz2/OXNM86bqW2fo8j9f2TH6tTLvj92iZ4fxbZdyqM/fvmdRmy+QxmeOet13Ul/H+N1/J+3OFbV6XcZ/v50kc4hDHtT9uegfEIQ5xiCPzP/+Lg63HZwpIZrnWM0Mg8uRswVWm7c5MYGKZIUiVgacv8x42T+rL5KCqE+icdN6MgVPmufHAbNr9zOP1d0x+nYue89zC43bxlwVLpv2WSW3O1BdL5rknJ/17/D2QLx6L+bw/l9vm9Rz3+X6exCEOcVyf46Z3QBziEIc4SM8gTg6IZpq928ZFs5qkZ9Jk4PEZ2rRMur550uPb5gpAJwVD09qc572MBzo7ZnhufKZw1pnySX2+rNn02QK48XG6FcdtPACc4/nxLwwzBcjVswSsM/Z/nu/PZbd5A8Z91v6KQxziuH6HqGIhCMJNJ8tylyzLK0jXPv4H4EWm5htXk5m9zOSojns88/fIDG2OTWpjJaRrLWeu+Y586RzX61E14K8zf3fMcc54Hurjc5wzkzGgWpKkpy/eUEWW5YvrCd/0ccvk7FYD35njtFnHSU7npK+Y4fExYDxfuPri5+dyhW1et3EXBOHmEQGyIAi3DFmWj8qy/JQsy1tlWa6RZVkivXHIzkmnbYMp1S9g9gV+48FcTebveIB61Yu4rtD4gsS5gszD4/9x0ZeBSxlfDPYk4JEkqUWSpG2Z4HbCLTRu4yX9rrjNycG6JEkWSZI2ZwLvS93ftWzzeo67IAg3iQiQBUG4pcmyvFOW5S2kZ5UhnZsJU2fytme2ph4/OjNbFZO5bnwmcjxAvaySWZlASZ7l8MyzjfkGu5P7Zpnva2dmK5/iQpDVTHrGcntmPMbv/YaN2yVMrvZwxTJbk7cAz2Ta3MlVBvKX0+Z1HndBEG4SUeZNEITbxTbSObwzzb6uyPw8PquLfv6u5vICs0fmOP/pebYxOfVgrmB57KL/nvdry+kyYf+QKSG2hfR4jZcq2870mcnrPW7Xrc3MF44W0uO64qKZ3yvt1xW1eT3GXRCEm0vMIAuCcNNJkrTtMk4fz9+8OEd5ThflzjbPeuLM1/4wk/Ix0zGvusWZ1x/vw7Q810nG72Usk5s9r9eeNFM5Puv+lCzLNcDWi9q9YeN2DdqcK0ViB+mUhSfmkRc9X5fd5vUad0EQbi4RIAuCcCt4ZB7nbMn8fQomFlSNTX5sHsZ/Jv/rOc657LzVyzCeSz3X/Y4HXPO9p3HPzPSgLMsvkh6nrsy/b5VxGx+LudqccevxSZt4wAwL3riCAPQq2rye4y4Iwk0iAmRBEG6qTGBikSRp1qoNmZ+unyQ9szc5F3Q80Ng82yx0ZpGV5aLzLZIkbZ/h3Ke5sJDqSo0HQTMFVF+d9PqzpWb8NXB0vjPTkzRfXEUBLowvF3K44dYYt0u1Ofmxudqe8mVDkqQdXPiSMdN1c70/V9Lm9Rz3+fZXEIRr7WbXmROHOMTxh32Q/h//eP3XHaTzN5szjz/MhR3WZqyvy4U6sZPrJT+eebyFi+rHMnWXtPHzxzerGN8IQwYevsL72XxR+zsm94ELtZBlpu/gtiNzv5e7Sch4Dd2J3dkyjzdnHtt+K47bLH14mgu7xo2P1Uwbbkyumz25L+OfmRk3LZnr/bncNm/QuM/5eRKHOMRxfY6b3gFxiEMc4sgEAePBiGdS0LGdeWw8wYXd3Mav9WT+vXmO19uROW/83PFA9aoC5EwbT150HxfvmlY96X7HvxjM2t95vJ6F6ePXeak2b4Vxm9Rm56Q+bM48N/nLhIdJG4ZwYRvm8b5vm/Tc5K2wp23dPdv7c7lt3sBxn/PzJA5xiOPaH5IsywiCIAhpmXJb1cBWOZ1HKsyDGDdBED5IRA6yIAiCIAiCIEwiAmRBEARBEARBmEQEyIIgCIIgCIIwiQiQBUEQBEEQBGESESALgiBMlXPRX2F+xLgJgvCBIapYXIW8vDy5srLyhr5mMBjEYDDc0NcUbi3iM3DthUIhent7iUajJJNJAJRKJVqtlsLCQqxW603u4XS3wufgdhy3D5Jb4TMg3FziM3D1WlpanLIs51/8uOpmdOaDorKykiNHZtqR9PrZtWsXGzduvKGvKdxaxGdAAPE5EMRnQBCfgWtBkqTemR4XKRaCIAiCIAiCMIkIkAVBEARBEARhEhEgC4IgCIIgCMIkIkAWBEEQBEEQhElEgCwIgiAIgiAIk4gAWRAEQRAEQRAmEQGyIAiCIAiCIEzygQiQJUmySJK0TZKk7ZIkdUqStEOSpOYraKdakqSnM9dbrkdfBUEQBEEQhFvbbR8gZwLZFmC7LMtbZVmuAbqAFkmSqi+jnSeBHcBhWZa3yLI8dn16LAiCIAiCINzKbvsAGfhroEuW5Z3jD8iy/ETmP5+aTwOSJG0HHgVWyLL84rXvoiAIgiAIgnC7+CAEyI+Tnvm92NHMc3OSJOlpYLMsyyvErLEgCIIgCIJwWwfImRQKC+mUiosdyZwzay5x5vonmedMsyAIgiAIgvDBd1sHyMB4jvFMM7+dmb85c1z/NIAsyz+EicV+YnGeIAiCIAgA9LqCpFLyze6GcIOpbnYHrtJ8gtm5znkYOCpJ0mZgG5mAW5KkncDWmVIuJEl6nEzqhs1mY9euXZfb56sSCARu+GsKtxbxGRBAfA4E8Rm4EezBFG90x1lTrKIhR3mzuzON+AxcP7d7gDzX7PDYRX+nmFQGrhrYkjncpBf9PQm8Day4+LrMbPMPAVauXClv3LjxSvp9xXbt2sWNfk3h1iI+AwKIz4EgPgM3wuunhimKOklY9WzcWHuzuzON+AxcP7d7ioV7jucslzhnPD3jBVmWn5JluUuW5TFZlp8ivcCv+XLKxAmCIAiC8MFy1u5HqYABT5hhb/hmd0e4gW73AHl8cd5MgWwuwByVKcYf75zhuV/P0a4gCIIgCB9wzkCUUX+UjfUFqBQSR3o8N7tLU6RSMp5I6rq/zrkRP88f6MUTjF3317qVfFAC5GmpEKSD27lqGo9fmzvHOUeupFOCIAiCINze2u1+AJaXW2gqNnOsb4x48voHpPN1tM/D7zriDI1dv5ntSDzJSy0DnBny8b/f6eDssO+6vdat5rYOkDOzw0eBzTM8vZkLM8HARFm38Wu7SAfJM127Cjgq6iILgiAIwh+mNrufApOWXKOWVZVWwvEkrUO3ToDYPpIO4I/1Xb9QZVe7A18kwaOryrBmqXlufy9vnrH/QVT1uK0D5IyngOrMVtHAxLbRRybvipfZEKRz8nnAE6RzjR+edF4z6aB563XvuSAIgiAIt5xIPEm3M0BjoQmAmnwj1iw1R3pvjTQLWZbpGg0CcGJg7LoErKP+KHs6nKyosLKszMLXNtawqtLKrvZRfrynG18kPuu18WQKb2j2528Ht3sVC2RZ3ilJ0grgaUmSHiU9K9wly/KWi049TDrv+Ogs1z7BhbSLKjF7LAiCIAh/mDocAZIpaCwyAyBJEisqrOw868AdjJFj0Mx6rSzLDHjClFr1SJJ0Xfo37I0QiiWpMCvwRxKcdwRoyATz14Isy7xycgi1UsGHFtoAUCsVPNRcSmWegd8eG+S773Tw6VVlVOcbp13/+xNDHOn1cGd1LlsW2NBrlFPajsRT+CJxfOF45m8CbziOQiHxsaXF1+w+rsZtHyADyLJ8lHSZtrnOeZEZcpLnc60gCIIgCH842ux+9GolFTlZE4+trMjh7TYHLb0etjTZZr321KCXXx3q5+EVpayosF6X/nU4AgCsKlRxLKbkWJ/nmgbIZ4f9nBsJ8NElRZh06inPNZdbKc7W88uDvfxoTzdbmmxsrM+f+DLgi8Q51OMCWeK3xwZ5+fggdTYj1iwN/kgCXzhOLDl9xjtLo8Rm1l6ze7haH4gAWRAEQRAE4VqQZZl2u496mxGF4sIMcHaWmroCIy29Hu5tLJjy3GR7O1wAvNM2wtLSbFTKa5/N2jkaoMCkxaiWWFKQTUuvh0g8iU599ZuZxJMpXjk5hM2s5c7qmesYFGbr+JNNtfzm2CBvnRmhzxVi68pSsjQq9ne66B4NkmfUYdKp6HeHeK/dic2sZXVVDo2FZrL1asx6FSadmmy9GpNOhfo6jNPVuLV6IwiCIAiCcBMNeMIEosmJ9IrJVlXm4A3HOZ+Zwb1YvztEnztEU5EJdzBOy3XIWU4kU/Q4g9QUpFMblpdZiSdlTg96r0n7u8+N4gnFeXBpMcpZvgQA6NRKPr2qjAeXFnHe4ee773TQOepnb4eTUX8MTyjGUx9u4MWvreF/fmIhtQVG+j1hkrLMigorS0otVOUZyDFobrngGESALAiCIAiCMOHssA9Jgnrb9NzaxkITBo2SI70z70G2r9OJVqVg68oyKnKzeKfdcc1Lw/V7wsSSMrWZ3N+yHD15Rs01qWbhCcZ479woS0qzqZkht/hikiRxV00eT6yvQQb+/vU2jvV5SKZk8oxa3m4bRaFQsKIih7/Y0sCd1bkc6HLxTzvaael1I8u3bjUMESALgiAIgiBktNv9VOZmkaVJZ6F6grGJQE6lVLC83MrZYR+BaGLKdd5wnJMDXlZWWtGpldzXZMMXTnCoe65Nfy9fhyOAJEFVngFIB6nLyy10OYNXvZnHq6eGkYD7FxVd1nVlOVn86cYaIvEUfa4QSVnm3gX5tA75OJcpR6fXKPnY0mK+samWHIOWF1sG2ba767rWcb4aIkAWBEEQBEEAvKE4Q94IDYXp9Ipd7Q7+4c32KUHuqkoryRQc65uaPnGwy4UMrMnk7VbnG6ktMLKr3UE0kbxmfewcDVBq1U+pDLGsLL0Y8Hj/lc8idzj8nBnysbGxgOws9aUvuEiPK0SWWolapcCSpaZnNESeQcPvTwyRmDSLXmzR87UN1Ty8ogRXIMp33+3g5RNDhGPXboyuBREgC4IgCIIgAG329EYgCwpN7O908eaZEdRKibfbLgS5BWYd5TlZHOnxTMwsx5MpDve4aSw0kWu8UIlhywIbgWiS/Z2ua9K/SDxJvztETb4RTzDG0ZEEyZRMjkFDVV4Wx/o8V5S2kEimePnEMHlGDXfX5l1R3/Z0OBkYC5Fj0PAXW+qx+6PU2Yw4AzHeP++ccm66bN5MaRdX1v/rQQTIgiAIgiDcVOdH/NNSFm6G9hE/OQY1/Z4QL58YYkGRicfWVuGPJNg3KchdVWnF4Y/S706nB5wcGCMQTXJXTR6hWIL3zo0SjiUpz81iQZGJ3eec12SGtMcVJCVDZW4WvzjYy8nRJJ2j6QWDy8utjAZiDHguP2VhX6eLUX+UB5YUTau60Trk43vvdvDeuVG84Zk3/+hzhWgd8uGPJFlRkcOmhgIKzTo6HAEWFpl5t90xY/rHxWkXu9odJG+RXfpEgCwIgiAIwk1zdtjHT/b28PbZkZvaj1giRYcjQJZGxX8cHaQm38BnVpdTlWegqcjEe+2jhGLpIH5RSTZalYLDPemFZns7XNjMWgpMGn64u4s3Ttv5+YEe4skUmxfYCMeT7O1wXqIHl9bpCKJWSrTbAwyORVBITGx/vag4G5VC4tgcaRavnRrmSz89hDd0IVj1ReK80+agsdBEY+H0yh37u1zYvRHeOG3n6Tfa+Onebk4PeqekTbzfMUqfO5heoLiiFEmS2NSYz2ggRlV+FhLp/ObZjKddfGVd9XUpi3clbo1eCIIgCILwB8cXifNSywCQ3pziZv683uUM4ApEaRv2UWrN4vNrKibKj923sJBYMsV77aNAusTZ4pJsTg16abP7GfZGWFqazTPvdzMWirOhPp9uZ4gXjvRTaNaxqMTMng4nwaucJe9wBNCrlezvcnFndQ6lJgVn7T5kWUavUdJUbOZE/9iU4HXciX4P//r2eU4OePnero6J7anfOG0nmZJ5YMn0hXnhWJKu0QBra3P5iy31bKjPZ9gX4RcH+/jO6238/sQQrUM+jvR48EcSVOYZWFZmAdIBe75Jy+EeDxsb8jkzacHeTCRJuqLc5+tFBMiCIAiCINxwsizz4pEBYskU6+vy8IbjDHsj1/X1OhwBIvGZUx32nHfSORqkJt/IH99ViVZ1YRGczaxjeZmFfZ0uvKF0msGqyhyiiRT/cXQASYL9XW4C0QRfWlvFhxcV8tElRZwe9PHKqWE2NxYQS6Z4//zoFfc/EE3Q7wnR4wpSlK3j/sVFlJsV+MKJibSKZWUWQrEk50am1mne1e7gb19pxRmIolYqeLdtlNdOD9PrCnKsb4x1dXnkGafvYtdm95GSYWEm2P3QwkKe+lAjj62tpLbAyKFuN3/3aisHu1xE4km2LLiwgYpCIbGpIZ8RX5Qcg5Z84/QFe7cyESALgiAIgnDD7e1wcd4R4IHFRayrSy8Ma7fPPsN4td5qHeGZ3V3869vn6HUFpzw36Anxu+ODFGbr+PLdVVMqRIzbvCC9vfTOTCpIWY4ek07Fvk4XTn+UVErmq3dXU56b3p56bW0e6+vy2N/pom0kwLJMgO2PzJzHeykdI346RwMYNSo+vaoMtVJBmVGRTrMYTqdZ1NtMGLVKjvWnK2zIsszzB3p4+vU2ovEUC4vM1BUYiSaSvHx8kO++00G2Xs3GhvwZX/PMkA+zXkWpVT/xmEIhUW8z8ZnV5fz55jo0SolYMkUiBYe6PfziYC/tdj+plMzSUgu5Bg27z43y0SVF6QV71yDV5EYQAbIgCIIgCDfU0FiYN8/YaSoysboqB5NOTalVPxHoXWtvnx3h+QO9dDkDHOx2863fnuaFw30kUzIOf4TvvttBIgVfXFOJSTfzz/xWg4Y7qnNo6fPg8EeQJIloIsmAJ0x2lprH11dTbNFPuebDiwpZVpbNG6ft5Ju0JFMyu9qvbBb51VPDhKJJHl1dRoFZB4BWJVGZa+BsZtyUComlZRbahv34QjH+7pVWnt3bS4lVzyeWl6BUSPgiCXQqBX3uMEd6PSwqNk+ZLR8XT6Y4P+KnqciMJM28o96pQS/BWJICk5aPLS1iY2M+3aNB/mXnOf7qxRMkZZmNDfkMeSOkgEUlZt5tczAWurp6zTeCCJAFQRAEQbhhYokU/364nyytkoeaSyeCr6YiMwOe8BXPsM7m1ZND/PPO80QTKT65vIQPLSwknpTZtrubz/zwAP/5pZPYvREaC02srLTO2dbGhgI0SgVvnRmh3e7nQJebLI2SlRU5E0HrZJIk8anmUmryDexsHaHUqudQt/uyA8Q+V4h9nS4ai0ysqsyZ8lxTsZkRXxRXIAqk0yx8kThf+tkRdp1zcnddHt/9zHJGfBH63CHcwRj+aJJgNI4kweEeN/YZUlvOjwSIJWUWFk9fuAfp0nA7z44QiiXJMaTTLx5YXMT6+jxiSZnj/V5eOjrA8nIr1iw177Q5uH9RIRLwysnZF+zdKkSALAiCIAjCDfPaqWGcgShbV5Rh0KomHm8sMgHXLs1ClmV+sreLf955HpNOxbceWMBn76jg8fU1/OiLK/nsHWX0e0Ic7Ruj2xnEGYhyot87aykzAKNWxd11eezrdPF3r7SiVkg81FzC+RH/rLm1KqWCz91Zgc2so88VIhhL8G67Y973EY4leXZvN7IMn1xeMm02d0FROoAdX+TY6wxyuNtNjyvIF9aU8zcPNuEMxjgz5CMcT9FgM+ILxwnHU9Tmp+sU/2x/z7QvJq3DPnRqBZW5hhn7dXLQyzl7AK1KQXmOnoVFZl4+McTrp0fY0JBPUbaOFw73E4ol2FCfT787jCsYY2NjwSUX7N0KRIAsCIIgCMKMQrEE8Wu4qKp1yMfBbjd31+ZRW2Cc8lyhWUe2Xj2RLnA1PMEY//OVVn55sJ+aAiPf++xylpRaJp5XSOCPJNjYkM+DS4qJJlJ4w3F+d3yQp99o45ndXRzsck2UdZssx6Che9RPrzvIvQsK+NjSYoKxJG1zBPY6tZI/XluJ1aBhLBhjb4cLZ2bGdy6yLPObY4MMeNKbgzQVm5FlmT5XiH99+zz/cCjMLw72EooleP30MP9rxzn+/o129BolC4uz+eiSYiRJ4nCPm25nkAKzlq9trEGjUpBIySgVEmoljPqiPLe/l1gi/V6nUjJnh30sKDTPWHZNlmXePG0nGEuQrVezuNTCr4/0c6DLzd11efzR6nK+sKYCXyTBz/f3sqLCilmv4p02B3fX5pE3w4I9TzA2UbLuVqC69CmCIAiCIPyhiSaS/MvO82hVCr5wV+WMVQ4uhzcc56WjA5RYdGxpsk17XpIkFhSZONrrIZ5MTZRYuxyyLHO0z8PP9/dy1u5jTXUO/+WBBejUF8KdSDzJs3t7cAVifHldNb5wjMGxMBa9Go1KQb3NiCsQ47fHh3j5xBANhSY+sbwEs07N8f4xXmwZoDLPSLvdT02+kboCE9l6NYd73CwqyZ61b2admsfWVvGvb5/neP8Yr5+28/k7K+a8n8M9Hk4NeimxZqFWSQx6wmw/MsDZYR+djgCxFLx+yk4ilWLEF0EhSeg1SpaVWhjyRvjuOx2srcvlZ3szNZkbbRzq9lBbYGRwLJ3OElcrKTCp6XeH2N7Sz2dXl9PjChKKJWmaJb2iczTAsf4xzDoVJp2acyN+YokUn1hWzB2ZrbY3L7Dx0tEBXj9t56HmEjbU5fP7k8P0uUM8uLSYZ/f28H6Hk5UVVt5tH+VQtwu9Wkm9rfGWqIV883sgCIIgCMJ1lUrJ7Gp30NLrmfc1+zpd+CIJAtEkP9jVSddo4NIXzUKWZbYf6SeRTPHoqvJZA6DGQjOxpEzXaHDG5+cSiCZ4/kAvz+7tod8TYsuCQv7LA01TguN4MsXP9/cyNBbms3eUU1tgpM0eoM5m5MkPN2Az62izB6jON/C19dXcXZdHhyPAqyeHOdTt5oUj/VTmGlhWmo1Zr6bHGUSSYEWFlfOOwEQJuNlKyeWbtHz17mpyDBpePNJPv2f2+3T4IrxycohSq45hb5hz9gAvHBnA7o0QT6S4Z0EB31iqYXFJNqFogkRSpjovi/90Tx1bFtrIM2o4MTDGs3u6Oe8IIMvptIg+d4jP31lOUbaeUCyJLMNoIEquUcPpQR9vnhmhddiHSiFRZzPO2LfXT9nxR+KY9WoGPCFSKZkv3lU5ERxH4kmcgSiPra0imkjyo/e7WVWVg0mXnkWut5losBl5bl8P3371LAe7XKyosPKNe+puieAYRIAsCIIgCB9o0USSXxzs5c0zI7zYMsCe85cusxWOJXn/nJMFRSa+cU8tBq2Kn+ztpqXXfUV9eD9TY/iBJcXkm2afia7ON6BVKS47zaJ1yMe/7DzH0b4xYokUa2vy+PrGGnTqC9UZUimZXx7so9sV5JGVZSwoMpNIpjg34qex0ERhtp4/2VjD+ro8DnZ7eOnoAItKstlQn89bZ0b42b4e6guMPLCkiB53mPsXFzLsi3Jq0MuKCiuyDEd63Rzt8/C3r7Ty4z3ddI0Gpm1+Up6bxTfvrSMcT/L06+0TG3ZMFk+m2La7k15XkDa7nw5Huj7zfU02JGTKc7O4szqH94eShGIJzFnp2W+TXsMnl5fwyeWlfH1jLWU5WYBEjkFDc7mFR1aV8uFFhXx4URG1BUay9WqSskw4lqTXFaI8R8975xzsPDtCnc04Y3WLEV+E9zuc6NVKOh0BCrP1fH1jLfW2dA55OJbkmd1d/K+d5+lw+KkrMLGv00XXaIB1tXmcHwnwUssAHY4AA54w4XiSP99czyeXl5KtFxuFCIIgCIJwnXnDcZ7Z3cVZu5+PLiliUYmZV08Ns/vc3KXG3j8/SjieZPMCGzkGDV/fUENlroEXWwZ584z9sna8GxwL81arnYXFZlZdokqEWqmgpsBIm31+u+pF4klebBng5wd6kSTQKhXU20x8ZX31lAWAAO0jftrsfh5YXMTSzG5vPa4Q0USKBls6lUClVPCRxUV8eV0V0WSKH+zqpN8dYsQXIZJI8tnV5RzucaNSSHx6VTmFZh07WkfI1qupLTDyTpuDl1r6KTRpsXvDPPN+N9t2d9F+0f00V1j5xLISzg77+cne7onnUimZ1iEff7X9BLvanViyNJRY9NQWGKguMPDD97s4PeTDHYzz2qkRRkMySLC+roCHmksYGgvz/Xc7cAdjNJRElykAACAASURBVBaa6HUFcfgimPVqPrSwkHsbbWyoz0ejUlKbb6TEqifPqMWkUzHsjTDsjWDJUnN60DdrsPrqqWEGx0KEogkMWhX/z/2NFGanK3hEE0l+tr8nnY8ty7TbA6RkmbFQjO++04FSgrN2H7882Et1vpHH11ej16huybJvIgdZEARBED6Ahr1hfravl0g8yRfWVNBYaObO6lxekPp5/bQdGdhQP32DiEA0wb5OF0tKsyfq+uo1Sh5bW8XLJwbZ1T46UYVCo5p7ni2aSPLrQ30YtCoeap5egWEmCwpNtA75GPZGptUVnqx1yMvvTwzhjSRYUW7hrN2HxaDhy+uqMM9Qy/hQtxuTTsWdmTQASFfMUCkkagqmVmqoLTDy5/fW89vjg5wc8HJfk40RX4S9XU6O9npYWmbBrFdz30Ibz+3v5UiPmwabke1H+qm3GZHlKKuqrOQYNOzvdPPTfT2UWHRsbChgYXG6rvBja6s42ufh9dN2Cs06LFka9nc56RgJ0DkaYEGxmYVFZt5uc+AKxDg/EkCjUrCy0kpOlga1UsHIMFTlGfny2ioc/gh2b5Q+d4gf7OqgKs+AWqkgGEuSZ9KyrNwy5R6r8w10u4IsLsnmeL+HQrOWUwNeagoM6FQKjvR4uKsmb8qMvzcU45cH+0gmZSwGDVuabJRa0xujJJIpfnGgj15XEINWCZKUXsBXYuLssI+3WkfocQWpKTAST8jct9BGoVlHnzvE708MsXVVKZ5gfMpiyptJzCALgiAIwgdMm93Htve6AHhiQzWNhekZUqVC4tGVZSwtTW9e8W7b9HJj77WPEkumuHdBwZTHlQqJTywr4YHFRZwZ8vHM+134LlGz+LVTwziDMR5ZWUaWZn5zcg2FJiSJOdMsXj4+yDf//TgdjgCfXllKx2gQhSTx5XVVWA2aaeePhWK0j/hZUWFFqbgQpLfZfdTkG2ZMJdBrlHx6VRl/saWeP7u3llqbiX8/2E8oluSumnSQ3VhooiI3izdb7ezrdKGQJMZCcRSK9AK7g11uPra0iE81lxBNpPjFwT7+eed5jvWlFyKurLDi9Ef5+zfaePqNdC7uiQEv8WSKEW+EXecc9DiDeEIxNCoFC4vNJFPgi6Sra1RbFDyxvprsLDVVeQbyTVqWlVmIJVL8dG8PeUYNsaSMQauiOm9qPnF1vhFZhiWl2eSb0hVEsvVq9ne6WVBkQqdW8LN9PQSj6deKJpL8zctncPgirKzIoSrXwB1V6XFIpWT+/XA/5x0BVlbkoFQoWFOTy4AnxH8cHaIqL5064/BFMaiVxJMpdraOoFIqeHBpMYNjYb79ahuvnbJPVNK42USALAiCIAgfIPs6nTy3v5d8k5Y/2VRDUfbUWViFQuKRlWUsL7PwVusIb2e2ToZ0SsbBbhfLyywUmGbe+GJdXR6fu6OCUX+U77/bybA3PGM/Tg96OdTtYX1dHjX5My/2msn4rnozlU1LJFO82NLPD3d3YdKpMWhVbNvdTSyR4kvrqmbNbz7ck16cuHrSJhuj/ijOQIyGwpkrNYzfb75Ji0Kh4IHFhQyMhYkmUhMz25IkcV+TjRP9Xs4O+2gsNHJ22MeIN8LS0mxUSgU/P9BHlzPIE+ur+cSyYoa8Yf72lVY+88wBDnS5USgkIvEk/nCcwbEIkgQ1BUaWlFqoyTMiSenNQP7rA038+eZ6/utHF/A3Dzbxn+6tY12JeiKVRKVU0FBoot8dIkujJNeoxeGLEoknsOjVKBRTZ+9LrXrUSomhsQifai5FRqIiN4tIIknXaJAHlhThDcd5/kAv7mCM77/byYEuFyVWPc0VFgxaFY2FJmRZ5sWjA5wZ8vHRJUV4QjHUKokRb4RkCkKxJGadmq0rSsnSqoglZSLxJL8+0s8bp4cpMutwB2P0uEI81FxyyV8lbpRboxeCIAiCIFyVVErm5RND/P7EMAuKzHzl7plTDSAdJD+8opTmcgs7zzrY2TqCLKcrXaRkmXsXTC/DNllTsZnH11cjI7PtvS7a7FNne73hOL85NkipVc/mS7Q1kwWF6V31Js9QB6IJfrK3m98cG8SSpeFvHlxAKJbkvMPP8nLLtC8C41IpmSO9buoKjFNml8c3JGksNM2rT85ADEuWmlgyxeDYhS8FZ4fTm4SM+CIc7/cCEgVmLcf7vSwqNnNXdQ47Wkf46nNHeHZfDypJosFmIt+kZdAbJpFMYs3ScHdDAcvKLHz7k4vY9vmVfGldFXZfhFyjlqc/tZi1dXmU5WSRpVHNmqrSVGSmfSS9+O1bDzSSkmUUkkSHIzAtz1etVFCek0XXaICGQhOrKq30uoIUmHR4IwlePj7EQ80l9LhC/P9vtXOifwy1UsGnmkvocgZZXp6ejf/9yWGO9Y2xpamA2gIjnaNBkNO5559eXcYPPtdMYbaOYCyJSafC4Y/yjXvqyFKr+NH73Tz+fEs6uLcZOdxzZYtArwcRIAuCIAjCbS4ST/Lc/h72d7omNmqYKW1gMoUivQ3yigorb7c5+I+jgxzqdrOqMoecGdIULlZs0fMnG2vJN2l5bn8vezucyLI8paTbIyvLrqhs18W76g2Nhfneux2cGfRh0KjYuqKUPR0ubOb0Fsf7u1ycHvTO2NZZuw9fOMHqqqlbNLfZfRSadTOmZMxkX6eThUXZlFp0/P7E0MQXiucP9KJRKfCE4uhUCh5cWkieUUuuQc229zrZ3jKAXq1ABgKRBGa9mhKLjkKzjjurcvjQwkJUSomTA142NuSzqdHGqD/Kj9/vJhhLsqmhgGJL1rz6qFMrGPFFyDNqsRq0yKS/APgjCb7z+tlpKTFVeQaGfRHCsST3Ly4impAxapSsKLeyt8NFtzPI/YvT9xNPpsg3aanIMZBMwcpKK2+1jkx85jY1FLCv04mEnE4fqbSytjaPEmsWT2yoIc+oRatSZCpz+Pjy3ZUEYwk8wRhKhYRKqWBoLHJNN6a5GiJAFgRBEITbmDcU54e7uzjvCPCJZcXcv7ho2s/ps0kHySWsqrTywpF+BsfCbJxh4d5ssvVqvnJ3FQuKzLxycpjfHhtkR+sInaNBHlw6d0m3uaQXralpG/ZxasDLtvc6iSdSmPTpn/Wr8g0MeMI81FzKN+6ppdSq59eH++lxTq8rfKjbjVmvYsGkVIpwLEm3MzgRiF/K0FiYbmeIdXV5fHhREZ2OAN9+7Szffu0ssWSKjy8roTRHj8WgYV1tPg5/LDPjrEGW4Y6qXJ753AqWlGbzbruD10+PUG8z8t8fXMi3PrqQr62vwaxTMeKLsL/LyY/3dKNSQrFFx6KS2VNAJosmkrx8YogCsw69WkFLr5tANMkX76pkTW0u50YC01JixvOQu51B4skUuUYNWVoVS0qzKTBreXZvDzazlpUVVkZ8Ue5rstE67J9IgdnVPsrqKisfWVRIOJ7kWN8YuUYtILF00mK7HIOGJzZUs6LCSjSR4oXD/XSOBkkkZTbU5/PldVXkGNTEEjPXj74ZRIAsCIIgCLepAU+I7+9Kl/X640kbNVwOSZJYW5OLUiERT8rs63RNlB2LJpIz1umdTK1QcFd1Djq1gm27u/i39zqptxlZUTF3SbdL9anBZuTtNgfPH+ylMFtPZZ6BlAxbV5ZxYsCLUatkSakFrUrJF9dUYs1S89z+XkZ8kYl2PMHYxMKxUDzJqyeHcAWinHf4ScnzT6/Y1+lCo0wHfYFognMjfl5qGaTEoue7n1mOJEF1npFSqx53KMaDS4v40021PPOFFTzUXMI7bQ6++cIJPKEYX1hTwQOLizjvCPKTvT04A1E+tqyYb95bx6g/yn9/uZXWYR9LSi2olcppW3LP5o3TdjyhOJ9qLsETTvDmmREMGiV3VufyoYWFlFmzCMUS/NuuTvZ1pmf7yzJ5yF3OAGeH/Zh0arY02Tg95OOzq8tJyTL/76tnef5gL3qNgk0NBdh9EbI0St44bWdpaTYfX5quTnKo2008KaOUJHIM6TzyyUw6Nd+8t57l5Ra6nEH+o2WAexcU4I8mqMoz8FcfauSxtVVXtIPi9SDKvAmCIAjCbajPl+Td3V0YtCq+vrEGm3n6orrJjvZ5GB6LkG/SUmDSUmDWTlSWeKd9lLoCI03FZnafd5KSYUmpmZ/t68WgVfHoqrIpJddkWabfHebEwBinB734Igk0SomNDfn0uUN0OgL84mAfy8osNBaaLjvNIhJP0jEapN8dZmWFlXW1efzyUB+bGvKxGjS0DftYW5s3UZHCoFXx2NoqfvBeJz/Z081nVpcTTaR4/fQw3c4gasUo//ud8wSjSbL13RRZ9ETjSfzhBN5QHLN+9rzeQDTBsT4PuQYN33+vA08whlatxGJQc//iIiKJFKcHfdzXZCMUS3Kgy8X6unwKzDq6RgP0uUOE40nCsSQbG/L5ozvS20sf7vHw2qlh/vXt82xeYKO2wIhaqaC2wIg1S82/H+onlkhdMlUGoMPh50CXm3W1eayrzWNfZzrlZGVlDrlGLUvLLLx+2k5zuZWxUIzfnxjm9KCXh5pLKc/Jons0iNMfJceg5pGVpXzv3U6OD4zx+TvL+dGeHmQZPrqkiLYRP2OhGG3DfhaWmNm6sgyFQiKZkjnQ5abUomPQG2Fjff6M46nXKHlwSRH7Olw4gzFysjQEowl2tY/y8IrSOcv63WgiQBYEQRCE28yhbjfv9CdYvVDH5++swDTLYrxx8WSKl48PEb2ohJZRq0SrUtDSO8adNTksz2yg8crJIV440s/CYjORRJLv7+pg8wIbNQVGTg94OTXoxROKo1JINBSaWFKaTUOhCa1KyYgvwpEeDycGxjgz5EOvVrK41MyyMiuVuVmXrIXsCkT5+YFe3IEotQUGcg0aXj4xSHG2jnsaCzjQ5SYlw+KSbAY8IUb90fQRiJJMyeztcLK308mCQjOnBr3IssyJWBKbScvyhVbeOzfKqf4xii16fnGob2IcSix6ii16Sq1ZlFj0E0Hz9iN9HO8fo95mpN5mQiVJqJUKNtbnc7zfQ7czSLZezd11+cSSKd5td/CNXx1jU0MBfe4Q1iw1f/2RRvrcIfZ0uPjd8SE+vqyY1VU5NBSaePn4IK+ftiNJYNKp+B8fW4hJp+I/v3iSgbEwP3ivk2VllolNWy6W3ixlkHyTlvsW2lArFcQTKXyRBBsb0ukyZp2augIj7SN+/uq+eo71j/HKyXRwnm/U0u8JoZAk1mc2Edm6spQf7OpEQuKexnwOdbv5zOoyvvN6G55gjBUVVj6zunziC8qZIS/ecJzynCwGxiIsK5u5lvHJgTHe73Bx30Ibe86P8uLRAdbW5HK01829jQXzzge/EUSALAiCIAi3kUA0wasnhygyKPjq3dXz+km6wxEgmkjx2NpK8oxaRv1RHP4IDl+UN87Y8YXjDLjDPLuvF1cgwqlBHylZxpKlZuuKEt444+Af32xPz3DmG1hcamFzk42mIvOU7ZwBbGYdDywp4iOLCukcDXCsf4wT/emSb5YsNcvKLOkycjPMeHc4AvzqUB+yDF9aV83+TievnbZTkZvFV+6uRqmQONLrxpql5tm9PYTj6ZxVhQS5Bg0VuVmUWMo40O0imkiiUkiU5RjYvMDGR5cWoVUpyTdp+bf3utiy0MaWBYUMjoXThyfMecco4xklRq0ShQTvnXNiM+t4fH0N50bSM7Wfai6hodDEUy+dpM0e4FsPLECjUqBWSkiAKxDjULeLz91Zwfr6fNRKBYtKslEqFLx3bpRkSuah5hKy9Wo+d2cFpwd9tPS6eWBJMXlGLcFoAp1GxZfXVoGUTvE40T/G6qocNjUWTKlO8srJYfyROF/bUDPxWRgLx5BlmRWTNgdZXm5N52m7QqyoyKG2wMTvjqcXZrbb/ZRas2gqSuc7l1qz2NRQwNttDv7ojnL+8r4GdrSO0Drk4+76fD53Z8WUz92+Thc5BjVjoRhF2bpZ39vtRwaoyMniM6vL+W+/O8WJAR8do0GSKZl32x081Fx6yc/yjSICZEEQBEG4jew57ySekrmjUDnvfM3Tg170aiXVeQZUSgU5Bg0NhSb6XCGO9Hr47OoyVlbm8OYZO6+fsrO6KgcJ2H3OycEuNxvq81hdlYPdG0GnUbK4NJvlZZY5Z4MVCok6m4k6m4loIsnZYT/H+zzsPjfKrvZRirN1LC+3sqQsG5NWxf4uF6+eHCbPqOULayrINWo53O1iaCzCJ5tLsJl1DHhCDHsjIINRp+KP7iinwKQlx6CZksZhzVLzndfbUCkl/sfHFrJiUv1js05FnlFDu93Phvp81tRcyNuOJVLYvREGxkL0u8O82NKPVqXgWw8swBWMTaQxrKzMIZpIIiERT6bQqdOv3Wb3o1IoqMrLYkGheUq5PEmS+NBCG0qFxDttDpKyzMPNpSgUEotLs1lcmj1xbtdoerFhU3E25blZrKnJY1e7g0Pdblp6PdxVk8v6+nz6fEnOuj1sasinLCcrcw9J7L4o2Xo1A2MRijIVMJqKzGhVCo71jVGdbyRbr+bzd1bQVGTmG786yrkRHz3OIOU5WSgUEpsaC2iz+/jtsUEeai7lp/t6sWSp+b+31E35UjTgCdHrCrGhPo/3zjn58KLCaZ+FobEwzx/oJdeo4QtrKtFrlHx8WQm9rhCplEwyJfOTPd1oMlt9K+e5yPR6EgGyIAiCINwmQrEEB7pcLCnJxhJyzeuaZErm7LCfxqLpucBvtdoxapWsqcll9zknLb1jbGws4NOrymgb9mH3Rehzh2goNPGlddV4gjFeONLP9iMDtNv9fHxZ8bx2yNOqlCwrs7CszII/EufUgJdj/WO8emqY104PYzPpsPsiNBWZ2LqyDJ1aiTcU58ywD5NOhSmzGUZLrwe7N4LNrOWTy0tYVJI95XXiyRSvnRrm/Q4nBq2KQrOWgbEwzbI8Ecy32QNsbMgnmkjxq0P9fGNT7cRP+xqVgvLcLMpzs3g7NkJtgYmvrKtEBn5/YogGm5GPZALA9885MelULCu18NopO7X5Rna0jmDNUpNv0jLij+KPxKekv0iSxJYmG0oF7Gh1IMsyW1eUTas60jkaQKtSTCx0y9ar+fiyEtbV5vH2WQe7zzs50OVmeDDBwvp06sm4vR0uEskUtfkGWod8rMp8OdCo0rPYx/vHcAWjmHXpnfOyNEqydWqSKZmXTw5xasjLIyvLsJl1bF1Zxnff6eDHe7oIxRJ8fUMNBu3UdJ59HS60KgWKzPguueg9cQdj/HRfDzq1ksfuqkKvSQfXd9XmseOsg7PDPprLLPzm+BDfe7eD+xbaUCounXd9vd0aSwUFQRAEQbikPeedxJIpNjUWXPrkjG5ngHA8yaLiqYFL52iAztEg6+vyef20nXfbR1lVaeWPVpejVio41ONhWZmV2nwjvzs+hC8cw2rQ8NW7q/nQQhunB738y9vn6XBM3/FuLiadmrtq8/jTTbX8xZZ6NjUUoFTAvY0FfO7OCnRq5cTubCqFgrvr8jg3EiCeTLG7fZRIPMmamtxpwbHDF+EHuzo50OUm16DljuocHl5RxoEuN7vaR4F0VQu7L8Kikmw+d2cFKVnm+QO902rveoIx3js3ypLSbMx6Db882E++ScunV5ejUEh4Q3F2nx9laZmFz62pwBmI8fzBPoa9EfJM6Zxehz/CeUdgxjG4p9HGhxbaON7v5ddH+kleVCmkczRAdb5hWuCca9TyyKoy/uyeOmryDaSArStLp3zxebttBHVmJjadWnOhdNqG+vyJsnEDnjD7u1z8+nA/3nCCaCLFWCjOKyeH+eNnD/F//fo4r54cwqxXMTQWocisY3FJ9kSFEwBfJM7JwTGayy2cGfJRkZs1JY84EE3w7N5uEkmZL62tJDvrQnCtVSl5cEkxWpWCcw4/WWolgVgC5LmrptwoYgZZEARBEG4DoViCfZ0uFhVnYzPrODvP604P+tAoJepsF8qFybLMW2dGMGqVdDqDtNv9bGrIZ0uTDUmScAaidDgCbGkqYH1dHv/t5TP88P0u/vK+RhQKiY0NBdTZTPz6cD8/3tPDutq8iQVilyPfpGVLk40tTVN32zvQ5abDEeCTy0sIxhK8dWaE3edGabX7WFFu5f7FRVPu5Wifh5ePD6FWKvj8neX85tggC4vMPNRcQjIl81brCCadingyHXw1FprJM2p5ZGUZz+3v5TfHBtm6onRilvm108MArKnO5bn9PSgV8MU1lROpBW+esSPL8OGFhVgNGhoLTbzUMsBdNbmMZMqg9btDtA/7aC6fudzdxoYClAqJ107ZSaZkPr0qvamKJ5iuoXznHCX7CrN1fH5NJaWR7ik7CMYTSU4OeGksNLGs3MqR3jHOjwQmvkzkm7Q8uqp8ytj9+kgf4yHpPY0FZGmVvNc+StdoEIcvQnluFt5wnEgiyb/t7sKoVVKYrafEoqPfHSYUTVKdb2B/l5uPLS2eaDuaSPKzfT14w3G+vK5qWl5yKiWzoMhEcbaeN8/Y0agUbF1ZiqS4NeZuRYAsCIIgCLeBfR0uoonUlJ/TLyWVkmkd9lFfaJoSvLaP+Ol2BtCqlLTb/Ty4pIi7avMmnj/c7UYhwYqKHLL1ahaXmNnROsLWFWVU5BoAKLHo+camWt44Y2dPh5PzDj+PriqbdcvnuZwb8eOPJMjWq4glZF4+MUh9gZFVlVYc/ihvnrbzo/e7kSSJJzbUTJQ+i8ST/PbYICcGvNTkG9i6sow+V4hANMnqqlwkSeKh5hIC0URmi2o1eUYNecb0LOeCIjObFxSw86yDMmsWa2py6XAEOD3oo7HQxHP7e0nJMo+trZyYGe13hzjWP8bGTMk5gOJsHeF4Ek84hkJSsKzMQrczyJHeMR5dVT7rxi131+WjkCReOTnMLw/18dnV5XSOpmed51P/+OIc8P1dLoLRJHfX51OVa0CvVtI67Js22z5OlqHTEWRtbR7nRvzo1EoeWFzMA4uLOT3o5XfHBwnGkiwqMXNXTS5alZI+d4geZ5ADnU7O2v1olAr+cvsJ/JEknmCU7Uf6kGWJNruPQDRBZa6Bf3yzHWSQgaSczjlOplL4wgl6XEEiiSRKhYQzEBN1kAVBEARBmJ9wLMneTicLi80UZs9d73iyfk8IfyQxJb1ClmVeOTFMjytETb6BR1eVTynLlUimaOn1sKDITLY+/ZP4n91bx9d+fpTvvtPBP25dOnGuRqXgY0uLaSw08WLLAN9/t5MtTTbursu7ZDm3cacHvfziYN9452gd9hOJJ0ml4P97qx2jVsXpIS+9rhD3NhYwGogSTaRIyTIvHx/CE4px30IbG+ryUSgkDna7sGSly5oBqJQKPntHOc/s7uLkoJePLCqc0rd7GgsYHAvzyskhbGYtvzs+iCsYpXVIpjw3i0+vKsvsDpcZu5PDmHQqNmR2HIwlUhzp9bCoxEzrkI+VFTl8YnkJe847GfCE6PeEJr5UzGRtbR7nR/z84mAfpwa81NsMmHQqCq5gF8K32xyolBL3NBagUEg0Fplot/tJpeQZg/R+T/rLxOKSbKKJFN2TdiJcVJJNVZ6Bf955joPdXiSkKW2kAKUkUZytZWAsgk6twB2K4w7GGPFHicZT5Bk1RBMpnIHoRI4yQCIp4wxEicSTKCQwaFQopHQ6kDwpX/xm+kAEyJIkWYCngRygGegCnpJl+ehlttMMPAN8R5blF695RwVBEAThCuzrdBKJX97sMaTTK8ZrFY/b2+HknXYHlblZPLa2inrb1N3kzgz5CMaSrK66UPmhKs/IpsZ8drY6ONztYlXV1J//620mvnlvHS8c6Wfb7i5+e2yQtbV5NBSaqC0wTisFN84TjPHS0QFKrXoeWVnGzrMjuIIx1tXmkW/S4o8kGPaGGfFGiCdSyLLM9iMDE9dbstQ8vr56IgB1BqJ0jga5r8k2NZiTZSQJ/JE4Y6H4lD5IksTWFWV8f1cH3379LMNjEcpyslhbl8f9iwqn5PeeHPDS5w7xqeaSiXva3+XCF0lw/+Ji/mlHO+F4ErVCwfr6fJ55v4uTA945A+S9HU7aRwI0FZk51j/Gng4nqyut9LlDlOdcum70uEg8yakBL3UFRqxZ6ZntpiIzx/rG6HEFqc6fPiN9ZsiHUgENhSbcwRhvtY4QiiUmFl72uUMEY0k+ubyEepuJLI0Sg1ZFlkbJrw720VRk5lPNJWzb3c3WlaUsL7Pw0tEBdrSO8OFFhdzXVIherZzyXpwcGOM3RweJJpIsL7ey57yTYquOY31j1BYYSaZkVEoRIF+1THDcAjwhy/LOzGPbgBZJkmpkWe66jOa2A9XA2LXvqSAIgiBcvkg8yd4OF01FpsvaaUyWZc4MeacEqAOeEP+04xxapYKnPtw4Y+B2qNtNjuHCDOy4r22oYV+Hi+/t6uQnFVYUF+WKesNxXIEYJq2KAU+YV08N83/Ye+/gyA7zyvd3O+cG0N3IOQwm58DJwyRSFDNFiVpZWRRt76737T7L2q3afbu1r+x99pbLXq1sWbJlBSoxKFLDzOHkiEkY5BwajUbnnO+9748GmsAAmKEy6b2/KtZMze1u3L5oVp379fnOuTQRQq0SaHaY6ay20lltpdKqRxCK7Ws/vDSNLMPHdjeSyYv0eqLcubaSj+0u+mRFSeZrJ0apMOuothv47IFW6sqNxNJ5UjmRNpellIoA71hDti+qufbFMzx7bpJIKs+966sZ9iWYCqZodJhKjzHq1GyotfHd85NY9Br+8FArW2/yDudFiVd7vdTaDSVfcToncmLQT2eVBXc4RWeVFRnomgyzv93J9y5McWrYz0OLvLmLfz/HB/283jfHhlobT+1q4Pmuab781giToTRfPT5Ko8PEoQ4X62tsq9o0Su99IkQsU+Aji6wyHVUWNCqBvtnYMoEsyzJ9nhhtruLno9VV/CyM+ZNsrLPjj2d57tI01VY9D2+pLU3RAcYDSUKpPI9tyl9mEwAAIABJREFUq+O6O4pWLbC+xsaoP8GVqQj3bajmsW1LM43TOZGfXSvaYRZuiE6P+LEZtfzxkXa+e36KSDp3y/f4u+S9YfT49fhPwNiCOAaQZfmZ+b9+6d2+iCAIfwn8UhNnBQUFBQWF3zbnRoOk8yJ3rau6/YMX4YlmCKfybKgtphaM+RP8xcv9ZPIS//7ejhXFsS+eYSyQZGdzxbLJZZlJx4d31jMdSvOza7Olf5dlmXOjQb56fJS8JPGn93Xy0V0NVFn11JQZuaPVQTov8kqPl799c5i/em2Qn16d4ZtnxpkIJHh8ex02g4bnu6Yx6zQ8svUdMXlswEffbIwmh5mGChNjgQROi55Wl4WNdfYl4ngla8iIL85Xj4+SyYs8fbCVP7ijEZtRw0vdnlIaQ16U+Nm1Gb51dgKXRc/mejuTodSya3N6JEAkleeBzTUlsXpq2E86X5yEDs0leHhLLW0uM6/1Fpvx2lxm+mfjxG4SfrIs81qvl9f75tjWWMa/2t2IRq2iscJEe6WFZoeJaruBZKbA9y5M8ddvDHJ2NLAkkSJbEJmIiqX3cazfh05dTP1YQK9Rz59DbEn6BMBcLEswmWPDvP2mrsyITi0wFkiSyYs8e24CjUqg2Wnmy28NE8+8M3k/OxrApFOzuc5Oz0yUtdU28qLE811uXBY9D25eekMw4ovzt28NcWMmyr3rK/mjw20YtCquTEbY0VSO1aDlwc01PLmj/j2RgQz/AibIwBeA/7HCv1+ZP/bMCseWIAhCK1AGvAF8GAj9Jk9QQUFBQUHhVyGTFzk1HGBdjZW6X2J6DNA7E0UlFBfRJEnmBxen8MWz3NlZycEO14rPuTQeRiXAzqaVkxf+1a5GXrnh5dnzE9y/sZh48aMrbnpmYnRWWXhyZwNmvYY2l5kqm4GXe2ZRC/Cpfc0gF5cDh+biHB/00TMTo8qm59JEmOvTEeZiWT69r7n09f5EIMnbgz7MOjVOi54Wl4kBb3xVj+rN1pDzY0Feuu7BZdXzqb3vLNndv6Ga57vcXJ4M0+w084MLUwz5EmhUKv7k7g7UKoGTwwHqy43saCq+ViyT58Sgn/W1NtrmJ7HxTJ6zo0E219sZ9SfQqgX2tDpYX2vn6yfH+PJbI+jUKmKZPGdGgnxwPnlDlmV+ft3D+bEQd7RW8PCW2tL7GQsk2VJvZ021lfNjIe5a66LGbuT0SICXrs/yZp+PPa0V87nVfo5PF7grlKbMrKXHE6WhwrjsW4b1tXZ+cnWGuVh2iX+91xNFEGBdTdFio1GraHSYGfcneL4rRzCZ43MHWjjaPUtOlLk4HuLudVWEkzl6PTEOdTiZmvcwb6638eJlN5m8yGf3t6DTFOevuUJx6n5uNIjLqucTR5qoLy9O7s+OBhFlmQPzgn6h6OS9wvtaIC8StivZKLqA7YIglMmyfDvLxF8CTwMf+Q2fooKCgoKCwq/MubHi9PjOzl/OewzQ44nR4jRj1mvo88QY8ydxWfQ8vLV2RYGZFyWuTIXZUGtfUm6xGI1GxdOHWvjzowP89etD6LUqIqk8H9xYvWQxTxAEDnQ4cVh0PHdpmr9/e4RP7G1id0sF62qsTASS7G1zsKu5nFF/El88y56WipJXOpMXeb5rGqteQzJbYEuDncYKMwOzbmYi6ZLIWsyCNaTNaebn1z2cGw2yttrKR3c1LPFAb20o4/xYqGSn0GlUOMw6auwG7llfhU6tYiaS5qdXPVTZDNSXm3ijd46CJJVKQgDeHvSTFyX2tjn4xqlxdjSVY9ZrMOs1fPG+Tk6PBDgx5COWzvON0+PsbK7AYdbx4hU3V6ciHOpwcv+ihUFJkhnzJ9nSYOfhLbXkChLHBvx8aFMNf3i4jalgilMjfk4M+Tk24MMdSiGJMgPeGHqNimg6v0RsL7C2xgpXoX+++OVot4f/cG8nfZ4YjRWmJb/rVpeZb54ep9Jm4PHtdTgsejzRDGoVXBgPcXiNi/NjQQRgb6uT1/q8GLQqfPEsQ3MJHt1aWxLh06EUL3RN40/k2N/u4L4N1aWEikxe5PxYkA21xbi99yLva4FM0S8MK3uGR+f/rFjlOACCIHwYeEOW5ch7YWtSQUFBQUEBil+hnx4O0Fll+aWna75YBn88y95WB/FMnm+cHmM2muahLbWsqVo5PqxnJkrqpuW8lbizs5KvnRjjxctuHtpSyzOH2pb4eRezrsbGHx1p49tnJ/j6yTGe2F7HlakIOVHiX9/ZXhJT8Uwe86JGvp9f8xBN59nX5uD0SJAdjRVUWHQIAgzMxpcJZH88y1ggyZFOF985P8nQXIID7U4+uLG6ZIcoiBLDvgSNFSZ0GoGemRgb62w8tr6eV3u9PLy1tiSkn9rdyN+9PcL3LkzxxPY6Lk+F2d/mLIm5cDLHxfEgO5vLGZlLUJBk9i/y/hp1au5dX8X+dgcTgRS9nhh/+Wo/kgzI8OCWGu7srFwiZt3hNNmCRJvLgiAIPLG9npwocfTGLDqNit0tFXzc0UQgkeUrx4aLaR5pmWfPT2IzaNBrVOxsXv67sxm0NFaY6JuNIQiQyIqcGw3giWaWCH4oer5nIhl2NJWzt9XBpYkwAPdvqOHojVmuTIW5NFG8iTLp1fR5YtTYDRztnqWu3Ehh3q4SSOQY8yewGrR87kDLssi6SxMhMnmJQ6t8k/FeQLjZk/J+Yl7cvgDcu9iDPH/szyhOhnfcKs1CEIQXZFl+cv7vXwC+dqvnzD/mCwBVVVU7fvjDH/5G3su7JZFIYLHcPhtR4V8uymdAAZTPwf8J3PAXuDwn8kCrlkrT8pWhW30GrvsLXPYWWO9Q0x+SGA6LbHKqeaxDh0Gz8jDo5fEc6QI83q5dNTkhK8qcmSnQFxQZDotscan57Kbbx86lCzJvT+UZCIlIMjzYqmWtY+UZ3WhE5JS7wNZKNZ6EREaEx+bP6eWxHAUZHmjR4o5LFGRQC9AfKp6PTSeQFWFHlZr2MnXRzyrLTMQk+oIi0axMRgS7TkCrhkxBRiMIOE0CD7Qsfd+BtMTL43kkGfQqeHyNDv18usIpd57xmMSjbVpeHs/jNKq4p2nlqfuVuTzPDeYo06uI52VcRoHd1Rq2uDRYdO/8vOv+AlfnRJ5a+87vSJRkjk0XmElIHKzT0FamJpWX+dFwjnqrQCiR42pAIJ4HnRoeadfRWa7GaRSWvJduf4FzngIqQUCrAqF4WXi8Q4dNX3xcJCPx0miOiZjM3Y0a9tVpeWsqTygt80SHhheG8wRSMjlRZpNLQzAt0RsUKYjF1Ikmqwq1qnhdbTqBSpOKrZXq0jVbQJRkfjScx6YTuL9l5Wv2u+TOO++8LMvyzpv//f0+Qb7VbW7kpj+XMb+Yt5J/eVVkWf468HWAnTt3ykeOHPllnv5rc/z4cX7XP1PhvYXyGVAA5XPwL51sQeTMa4Mc2mrkIwdaVnzMap8BUZJ55cfdZLQpogYLTQ0CFa4C//lD65YkESxmLpbhtdAwT26s5tCalad6U8EUP7w0hWTL83/treHNPi9nRoOUt21hy6Ic5dVYG0jwn358A1GSsdXXsX9nw7JSiHAyx/G3hrljk4HHttXxt28O88TG6lLmcMTu5oUuN8ejZuZL8ZBkmUvBEKlcgZSgo73SQkin5XxSJhDP4olmyBUkLHojBoOKdDrP04c7OLTGxb/5/hVi6QL//dGtK07pWyZDvHh5hke31rJnvtluLpbh9fAwH95SnCiXJ2f47MGWFWPUALYksrwwdpqsSsWfP7mBeKbApfEQ51MyO10V3NlZid2kZfjkGDsqRO6/u2PJ8w+JEt8+O8FYIMmejkYmgkmqE0H+5N41nDpzhrDWxHggydaGMnIWPVcyMjV6AzubytnaWIZJp2F9LMPF569j0Kp4cHMt3z47wZ62Ch6+bx1QTJj4++MjtLVI7DBqyYkSBw62c/xoP511Ok4mcmR0SUbmIlTaDAj2crJSGp0hRZPdwFN7GtlQY8dp1WPWqW8ZTXd5Mow94uYz+5uXRQy+l3i/C+RbLdOV3eoxC/7lXzYrWUFBQUFB4bfNxfEQiazI3evevfe4GOsW42fXZuiajLCruZw/PNzKc5emaawwrSqOoegv1aiEJfFoi1/31HCA13q92I1anjnURkOFic5qK12TYf7u7RG+9okdtxRF6ZzIC11utjWUsb2xnLeH/IRPjvGJvU3Y5j2wkiTzXNc0AB/d2cCF+ci2zXU2ut0RLoyF6PVEmYtn2VBn5yM7Gyg3aXnxspsLY0HuaHXwyb1NmHQaut1RLo4HUakEtjWWsa2hjEqrHlkuRrBdngyzttqKWhDQalTEM4UVz3tHUwUdVdbSOQK83jeHTq3i8BonXz85Tq3dQItz5ZzjdE7kB13TmPVqkGFttZUau5HDHS7eHvTRNRni8mSYXS0VTIVS7G1bXi+tVav4xN4m/vn0BN85N0EmL3JoTSUOix6bFmKZAgLwqX0tbK63c306QtdkmJe6Z3mlx8uGWhvbG8tIZvNY9Ea2NpbxlbcLJTuJJMk8d2mKcCrH0wdbGQskeb13jr7ZKKlcgVg6T4vTTGeVhfFAkn1tDr74gU7+/fPXqLQZ+NzBVo68S4988bPkp9pmWBYj+F7j/S6QF5bzWlc45gC4xYLeCxSX+L6wwrHL8/+jPzM/MVZQUFBQUPidkCtInBoO0F5puWXBxGImAkle6fEyFUqRyYt0VFn44n2dhFM5wqk8922oXvW5uYLE1akwG2ptWPRLZUEyW+DFy24GvHE21Np4Ynt9KVrNNZ+P+1yXm5dvePnQ5poVX1+WZX5ydYZoOl/yK9eVm3i+a5q/e3uET+1tprbMyIkhP5PBFB/ZWY/dqOXcaJCCJPH3x0dJZEUqzFoe3VaHy6qnrsxYilN7pcdLfbmJ//fhDfR74/xs3r/cXmnl3vWVJU/vAutrbXz5rWLcXEOFCaNWzdEbHjqqLCvWHC8Wx9OhFH2eGPeur8QdzuCLZ/nIzvoVbw4S2QL/fHocfzzLR3c28nzXNCeG/Dy1qxG7qfheDq9xcWzAx4WxIJJMKSHjZvQaNZ/e18wXX7zO0Fycz+4vfqsQyBRb6RAEWpwmDFo1e1od7Gl14Imk6ZoMc20qwqlhP/5EDpVKxZA3jkmnJp0vRsa90T/H4PyCXZPDjIAAzHFmJIgvnqXSauCx7XW82TdHe6WFbF7k9T4vY/4k9y2a7r8bBrxx5mKrX7P3Ev9SBPKOFY61Ardqw3ua5RaNJyn6i79EMSbulykZUVBQUFBQ+LW5NBEininwsd23n8r5Yhle6/XSNxvHZtTwxPY6Lk2EKIgyDoue1/vmMOnUrJ/PQl5AlmXSeZFoOs/50SDToTTtLgs/ueomli5ODWOZPImsiEYl8NCWGva2OpaJmk/ua+LNAR/fPjfB3WtdGHTLZcWliTA3ZqLct6GqtMy3vtbGM4db+fbZSb52YpTDnS7e6vexud6OTqPif742wOmRAB1VFjbWlbGnpYKOyqLQjWcKXBwP8p1zk1ybCmPQqjjQ7uTvT4wRTedprDDx4R11y4TxApU2A+tqbPzzmQn2tFRwsMPJN05PcHo4wJ23aSp8rdeLRa9mX5uT756fxGbUsLl+ub0kmiouRkbSeT61rwmzXsMb/XOcGvLz+Lb6UgxauVnHEzvqOdLpYtSfvOVUNS9JWA0amhxmfnrNg8OiZywqATJlJi2BRA6X9R0/eG2ZkYfLjHxwYzX/680hpsNpwskcf/3GEEatCn8sw6khP8cH/exuKS8tZ9aVG9FrVFwcD5PMFti5sRy9Rs3gXIKHNtdybizI10+OY9ar+cLBll9K6J4a9lNm0q54zd5rvK8F8nzyxBXgnhUO30NRBJcQBKF1oVlvJWvFfNU0wJuK9UJBQUFB4XdNXpQ4MeSnzWVe9Wt7mM/g9RR4PTyMTq3iAxuq2N/mJFMQ+fHVGe5ZV0kyW6DXE+WOVgdatYozIwF6PVGi6TzxTIH8vIm3zxNDlCR6PFEseg02gxabUUtduRHPfKTa2mrbikLIoNXwyb1N/M0bw3zn3CRfONy25PhcLMMvuj20V1qWTRpr7Eb+9Z1tfPf8FEe7vaRzBYZ9cbrdUdzhFK0uM3/+6MZl1pB1NVZe6fHiGw1gmLdHjPoTtLostxTGi6/xTCRNXZmBiUCSR7bWsaHWxvFBH9sby7GbVl4cG/HFGfUneXBzDeFUjlF/kvs3Vi8rtvDFM3zrzASpnMhn9rfQ4jQjyzItThNj/hQ9nmipiW8Bh0V/SwsMwIlBPypB4D9/aB3Pd03zzTMTTIZFzDoNNqOWAW+MdTW2Zc8TJZlYpsBn9jVzeTLMWCCJLMtcmY4w4I1z97oqHtr8TjycWiXgsOh4o2+O9TU27l1fxclhPxqVwF3rKjk26GMmkuZP7m7HZtTd8pwXMxVMMR5I8eDmmvdMGciteF8L5Hm+BLwhCMKfybL8V1BKsOiSZbk0QZ5fyPszQRC+tPC4FVgw/9w640ZBQUFBQeG3wML0+KldDbd83LPnJxkJizy2wcGdaytL1ogrU2FkGTbU2rk6FUGUYFdzBUNzcX7RPUut3UBjhakkgnMFkXgmz4c21XDv+io0iywGZ0YCXJoIMxPJcGE8RH25kY11djbW2paIuQc21vCzqx5e6p7lka21VNmLRRV5UeIHF6fQa1TLvlKXJBl3OM3gXJxcQcSfyFJu0tJQbmJTXbHYYm+bY0XR2OwwE0xk8UTSGHVqWp0WnjncelthvMDJIT/hVJ7/+wNr+MlVD893TfPkjnqG5uK80jPLU/M114spNt/NUWbSsqelgh9fnUGvUbH7pli1Xk+UF7rcaNUCnz/YUoqjEwSBXU0VDMzGuTgWWiaQb0c0nefiePF5TQ4znzvQytdOjhLKyFRV6tlYZ1u1ROXGTJS8KLOzuQJJBlGGR7fV8l9+2oM/nsUbzfCTqzPcubayFGOXyBaIZ/Ic7nRi0Kq5OhVhU72diUCKuVgGo1ZN4wpZ1Lfi5LAfo1bNzuZf7r3/vnjfC2RZlt8UBGEH8JeCIHyUoi1iTJble2966CWKiRYrTY7/EtjOO5PoFwRBeBP4H8okWUFBQUHhd8HC9LjFaVo1EQFgNppmOpRmZ7WGh7YsrfTt9cRwWXS4LDq+fyFUEsP/fGacSquePzzStsRn+7NrM5SbdBzudC0Rx/2zMY7emGVDrY37N1bT54lxYybKqz1eXu3xUms3sLHezqY6O06Lnj860sZ//HE3/3ByjP/60AYAjnbPMhfL8tn9zVgNWtI5kWFfnAFvnCFvnGRORBCgscLEZ/Y3s7nOjsOi5+xIAEmGHau0+aXzIslcgZwo01lh5k/vW0N75btLQwgnc5wY8rO53s6WhnJEGV7octPjiXGow8VbAz72tCaXTe97PTHc4TQf3lFHMifS7Y6wu8VR8mPLssyb/T6ODfioLzfyB3ualk2i19bYKDfr6PFE8cUyVNpuH4+3wMkhP5IslywgFWYdTx9sZXR8ioZyI3e0OPjRlRlmo5llTXpXJsO4rHrqy43oNE40KoEb7ijNDjOtTgtbGsq4MRPl6nSErQ1lHFnjoncmhlatYl2NjfNjQbIFiY11dl7omkavVtHiNNHvjXPP+qp3dVPij2fpm41xZI0LvUZ928e/F3jfC2Qo2SVuFsQ3P+ZFVvEky7L8pd/GeSkoKCgoKLxbuibCxNIFntxx6+nx5ckwGpVAm2XpQlkqV2DMn+DQGhfT4TS+eJYnttfxUreHRKbAJ440LRHH2YJYnAzW2Uv1zgCeSJrnLk1TV2bkIzsb0GlUHFrj4tAaF+Fkjh5PlBszUV7vneP13jlq7AY21trYUGPj7GiQnpkosgwXxoNsqS/DE83w9qCPyWAKSQaTTs2aKgud1TbWVFmW/OyF91dXZqDGvnK19pWpCLIMZp2atVWWVRfbbkaWZY7emAUoFWRsayijfzbGG31evnCwtZj+cN3Dv7mzvVQwIkkyb/TN4bLq2dZQzhv9c0gyHJgvBknniq1/A944O5rKeWRr7YrLfu2VFiqteuZiWS5NhFddaryZxdPjCvM7loYyo3a+KtrG2hobgjBD/2xsiUAOJLJMBFOlxr4qmwGdRsWoP8kn9zbxSo8Xh1nHF+/r5NRwgPNjQY71+xj0xqi2G+ifLVaDr6uxcmLQTzon4rDqWV9jY9SfZDyQvOXN3AKnhv2oBYF9i8pUbqZ/NoY3muFIp+s9scD3L0IgKygoKCgovJ8pzE+Pmxwm2lyre48LosTVqQjra23oU4Elx/pnY0gybKi1cX4shF6jQqMWuDoV4e61lcva57rdUbIFaUlzXjSd59vnJjBo1Xxib1NpmWyBcrOOgx0uDna4iKRy9MzE6PFEeaPfR16SCcYz/LsfXqXCrEMtCEgyXHdHqbEbOLTGxdpqKw3lppL4vBlPJI0nmuHhmybjC8iyzKXxIEatGrtRy/6O24upTF7k8mSY82NBAokcH1hfRZmpKDQFQeDRrXVMBlP85KqH+zZU8XyXm0sToVLu8dXpML54lo/vaSQvSVwYC7G+xkaFWYcvluHZ85OEkjke3lLLHa0Vq56PQaumo9JKKJnjylSY+zYstbSsxs3T4wX6Z2NEszJatcDwXBxkmVd7vMgyZAsSOVHk6mSEYV+c2mkDPTNRsnkRfyLHHa0VHOgoLgZed0e5f2M1D2yq4UC7kz/+3mVEWUaWZb51tlihbTVo6J+N01ltZWguwcNba/naiTHOjAZvK5BjmTxXpyLsaCpflpKyQCSV44UuN+UmLQc7nGjUikBWUFBQUFD4P57Lk2Gi6TxPbK+7peAb8MZJ5UR2NJXj6V96rNcTo8ykxWHW0e2OsK7GytF53/GRzuVRXBfHQ1TZ9DTNJ0tkCyLfOTtBNi/xzOHWJfFmK1Fm0nGgw8mBDifRVJ5eT5SZcIoeT4xoOs/nD7SwvamCzirrqotvN9M1Px3f0mBf8fioP8lkKE2FWcfnD7awa4Vq5QV88QznRoNcnYqQLUg0Vph4alcVm+uXvrZZr+Hx7XV8++wk3miGVqeZ1/vm2FRvRyUIvNlftE0s3Hik8yIHO5z0zER58bIbnUbF0wdbab7FUuUCa6qtXJ2OEEnl6ZmJUmkzMBFMMhlM4Y1m0GtVmHUajDr1fPW2zEvXPWyotRFJ5ciLEiadmrlYhr95c5i5pMTp4SAqVQhPJIM7nEYGLHoNWrVA72ysWEOtVaFTq6gw69hYZ+fudVUAbK63M+CNMxFM0eI0M+CNU5Bk7mhxoNeoODbowxfLcnE8zO6WciaDKZocJiqtBna3VHBiyE8omVsy2b6ZsyNBRFnmQMfK02NRkvnBxWkkWeZjexrf1U3D7wJFICsoKCgoKPweKYgSx4f8NFaYaL9NeULXRAi7UUu7y7JEIGfyIsNzCfa0VtDtjpIrSAQTOTJ5ic8daFgmOmYiadzhNA9tqUEQhPmyiGlmYxk+tbd5VXvDathNWna3VLCzqQJvLIteo8Jp1dPqMr9rcVwQJa5PF6fjN9suFrg0ESKVLVBp07Oxzr7sZkKWZQa8cc6NBhn2JdCoBDbV29nX5qCuzMiNmSiJbAHrTeJ/bbWN3S3lnBoJ8OjWWsavJfnRZTf+eJZYOs+TO+qRZTg7GqC+3Ej/bIwTQwEaKox8fE8TduPt32NelDBqVSQyedzhFH/+cn/JO203aqkrM5AXZeKZPN5YhnROZGguji+exaLX8I+nxgGIpfPF6XE6T50B/mBvEzV2A6Fkjm+cGuPDO+rZ1eJg1J8gkRV5alfDqk2H62ttaNUC3e4ItWUG3ugrTqC3N5XTPxuj2WFmb6sDs0HDjqYKLo6HS9P9O1odnBzyc34syAObVraLZPIiF8aDbKy1lxYAb+b13mJ+98d2N6z6mN8HikBWUFBQUFD4PXJ6OIAnkubRI7eeHkdTeYZ8CY6scS2zKAzNFSd/G2rtvHxjFpUgMBNJc9+Gaqrty5fBLo4H0aoFtjUUF+Fe7pmlfzbOw1tq6ay2Issy/bNxLowH0WlUbKqz01ltveWC1YXxEImcyBfv6+SHF6d5tcfLlakIayot7Gt3lnKMV2PxdHwlEtkCfZ4Yeq2KVudS73I6V7RRnBsLEErmsRk1fGB9FbtaKkpf608Ekvzg4jQOs47PHWih/Kap5wObahjxJTgx5Mdl1vHs+Ul2NVfw+YOttDjN9HlizMUy2I1aTgyl2dVczsNbaledeKZzIpOhJBOBFBPBJDPhNHlRwp/IolWp0KhU3Lehii31ZcvOBYp2l796dYAHNtVw97pKklmR4bk4P7k6g0mnpsZuwJCL8ItuD88caqOj0kK5Wc/gXIJdLQ6uTIbRa1TLMrAXo9eoWVdjo9sdxahRMxfLUmnV441lMOmKx6rsBh7ZWserPV5UAmyan8DbjVo21tm5NBHi7nWVK342Lo6HyOQlDq4yPe6fjXFyOMAdrRXvuWxkRSArKCgoKCj8nuifjfHlY8NIMrzR5yWWybO53r6i2LgyXYxwW0lA9npiWPRqtCqBMX+SVK7A5voyDnUst1Zk8iLXp6Nsri/DqFNzbjTImZEg+9sd7Ggq58JYkDMjAfyJHHajFkmW6ZmJoVMLrK2xlcTy4kW0VK7AW/0+1lRZeGxbHeOBJAatms4qKxcnQnzzzAROi469rQ62N5WXao4Xs3g6vhJXp4rFFfr5dAUoFqWcG3vHRtHkMHHfhmo21NqXZe0OeGOoBEjlRP7h5CifO9BC5aJiDb1GzePb6vh/ft5LriBhN2qpsRtonregvNIzy6gvydoaC49tq1/i3V5MMJHlh5emmYmkkWVQCcXyjX1tDpocZq67I3S7iyW/2YK0ojgGODHkB4rCvcKsY8yf4PxYEIdFh82o5dGtdfhHu+kpyPzTqTGePtjKuhorV6ciJLN5ej0xtjTYV1wYXMyW+jKzwdw/AAAgAElEQVS6JsK8dMNDhVmHN5Ihksrz6NY6RnxxxvzF3ORud4T2SssSH/H+Nifd7ihXJiPLarILosSZ0QBtLjMNFcsj4SKpHC9edlNrN6w6gf59oghkBQUFBQWF3wPd7gjfOTtBQZJ5cHMNqZzIj6/McLR7lm2NZexpcZSmv7Isc3kiTKvTvCwbOC9KDHrjbG0oo2syxHQoSXullQ/vqF9xGe76dFFM7i7lI3tocZrQqVX85asDpHIi9eVGntrVwKa64rRwPJjkhjtKz0yUbne0OJmssbGp3k5HpYU3+31kCyIPbCpaNjbW2Tk55OfT+5o50umixxPj3GiQl7pnea3XS0eVhfpyE5m8yEwkw1QwybmxIA0VJv6/VwcQBFALAipBQCWAShA4PxYkmRNRCcUJ+HV3BHc4Pe9ZLmNfm2NZxNliBmbjlJt0fHRXPd85N8k/nhzjM/tbSs+JpvK83udDQECnUfPQ5hquu6P0emLMRYuNhe2VFr5wqG3VCnBJknmua5pgIsfdaytpdpppKDctWXaUZJludxSXVc/lyTD3rKtaJuaj6TyXFiVXjAeSfPvsBFaDhlROotqmZV+bg5MzKj67tYVvnBrnG6fHObLWxfmxEG/0+cgWpHeVt7ymyoI/niEnStSVGQmlcmyev56iLDPY46XXEyOcynPP+qolz22oMFJfbuTcWHDZguJ1d4RYusAT2+uX/cwF37EoFX3HtxPxvw8UgaygoKCgoPA75uJ4iJ9em0GtFlhbbeXDOxooN2mZCqW4MB6iayLM+bEQTQ4Tu1sqsOo1BJM57lq3vAp5xJcgW5BYU2XhK2+PIAgCD26uwWVd7ueUZZmL4yFq7Aa0aoGvvD1GLF1ABiaCKdZVWznQ4aLZYVoidtpcxTi1h7fUMupP0D0vHK9OR5BlmclgksOdrpKHdFOdneODfno8UZoqzIiSTEOFkXgmz3V3hLOjQSQZykxa1tfY0GlUuCx67lpbiVmnQZJlJLkoOEVZxhfLUJBkTHo1Bo0a27zn9wMbqtjdXIF5lXSEBWYjac6OBjHrNRwfCvD5A6188+wE/3hqjE/vayYvyjx3aYq8KPOnH+jk5LCfEV8Ch1nHi5fd9HliWA1a/tvDG5ZMnW/m7UEf06E0H9vdsKploL3SgkoAm0GDP55lwBtjQ+3SxcETi5IrxgNJvnVmnDKTjmaHmYsTIT65t6l081NXZuQz+5v5xulx3u73Icsyxwd9NFSYaFxhcnsz/kSWvCijVglcmQxj1mtKN1et84uHR2/MolULrL+pqU8QBPa1OXi+y82wL8GaqqKnWpZlTg4FqLEbVqzPfq/6jhejCGQFBQUFBYXfIaeHAxy9McuaKguRVB6DVl1KAWhymGlymHlwcw1XJiNcHA/yQpcbdziFWhCoXqFcomcmilGrxhtNM+JLcNfaymVfdy/gDqeZiaTZWGfjT1+8TiiZY3N9GXtaKtjX5lxRVC9GpRLoqLLSUWXlka0SI/4Ef//2KJF0nlFfkr94uZ+NdTaQYTyQ4H++NkjH/CKaTi1QM5+tXD4fkTY0lyCeKVDIiRzudPHxPU0r/tznLk2xvsZGXpI4vKaS++dzjN8Nc7EMf/XaAKFUjjvXVdLnKSY7PHOohW+cnuC//6IPg1ZNu8vCx+9opNJqoKbMwFeOjWA1aEjmCmjUAp/Y3XhLcTwdSnFswMe2hrJb+mkNWjXNDjPJbAGbUcOl8dASgbwwPd7RVE40nedbZ8axm3Q8sq2Wfz49zvbGsmWJGQ0VJj69r5lvnZ1gOpwimCjGzr2bPOFXe7zU2A3MhFN4Ihn+7V3tVM1/zurKjOg1KiKpPJvq7CtaYzbV2Xmlx8vZkUBJIA94i8uFNzcownvbd7wYRSArKCgoKCj8DpBlmbf6fbw14GNTnZ3Da5x85e1RjnS6mI2mlyRHmHQaDnQ42d/uYMAb57+/1IcoyPzvYyO0uczsbqlAlGRESZ7Pp7XwvQvTGLRqnj7YuqIwKogSz3dN0z8bo9cTRZLgswda+NCmmlVTI26FRq1CQMCs1/Cl+9fisuq54Y5yfTqKShCoLzcyF83yyNYaWp0WnBb9MsuHJMn0zca4OhVeVdSncgV6ZmJU2vR4IpllU8xbcWUqzE+vzuCNZdnbWsEfHW7j5RuznBoOYNZpsBs1+GJZzHo1Tx98x5NcZTNw7/oqXpkXjzq1ioMr+LkXyBaKZSE2o5aHt66c4byYNdVWXu3xsqelgosTIaKpfCntY2F63Oo0l8Tx5w8083yXG61axQdX8es2O818Ym8TX3zhGr5YFodl9ei1BYbn4gzNJXhgUw3/7aVeBAEe315XOq5SCTQ7TAzOJZbF4y2gUavY01LBm/0+/PEsVoOGX3R7qDBrlwng97rveDGKQFZQUFBQUPgts9DidmYkyI6mch7fVseb/XMIAvTNRjk55OcjO5fHcQmCQCJboNlp5pN7G/HGslwaD/GDi9N4Z3Mci/Yw4I0TTmXp98Z4eEstWo0KWZaXiORsQeTvjo3yao8XrVqgrtzEn9zVUUok+FUQJZmXb8zitOg40O5Eo1axodaOJMkIQjFK7u/eHkWrVq1aq6xSFf3KG+tWP48rkxEKkoxOrcKiV1NffvsIurwocbR7lgvjIRrKDWQLEnvbikkKH9xYzVQoyd+8OUR9uZH/cG8HA944L3S5kWXYNu/bPdDuZMAbYzyQYku9vVQushIv35glmMzx+QMtK05Zb2btvEC2G4sy7PSInyaHmfoyI5fGixXhP73mwW7S8fTBFsYDSUb9SR7eUrtkSS4vyUtet9VppsVpYSqU5tnzU3RW25acTzyTZ3C+8U+W4ZUeLxVmLdF0DlGSqbEbKEiwOLRuc0MZ4VSezurV67x3t1RwfNDPubEguYJEOJXnCwdbl3ir3w++48UoAllBQUFBQeG3iCTJ/OTqDF2TYfa3O/jQ/OTsujtCXZkRdziNQaviua5p0nmRO1qXTlK7JsJUWvWsrbaxrkbgcIeLEX+CXxyfwytKZPMi58dCxQixeJb/8fIAeo0Kl1WPy6LHYdFyeTJCz0wUs05NQ4WJj+5q/LXEMRR91L54lk/c0bQk6mx2PgqtrsxIuUnLDXeUHU2rF3rcClmWuTQRor7ciDeWYWOtfdUWvgVCyRzfvzDJTCTD4TVO6sqMTF+cZu28wLsyVVzusxo0GLRqGh1m9rU7efbcJM93ucnkJfa2OVCpBJ7c0cDPrs1w19rl3u8F+mdjXBwPc6jD+a5qlwEqrXrsRi1j/iR5UeKrJ0bZWGtHqxGIpPPkRYlKm4GnD7agVas4emOWujIDexYlZ1wcD/G9/hxZp4d71lVh0KqZDKbQadTsaq5g1Jfgm2cm+Mz+5pJIfqXHy9WpCDajlngmz2y0eI1+0T1LbZkBp8VAryfKzkUFLNsby2+77Gc1aNlUb+eNXi8GnZp71lUts4G8H3zHi3lvy3cFBQUFBYX3MQVR4oeXpumaDHP32ko+NJ/yMB1KE0rmMemKwuWZQ22srbbys2se3h4oLlpBMcZsKpRiZ3N5aSKsUgkIFCdyoUQWtVpAoxbY1+pgc30ZdWXFBbzpUIq3B338zZvD/OTqDIFEFgm4Z30V+9tXtjO8W9I5kTf752hzmVlX885kMZUr8A/HR/mnU2PkRZmNdXZG/AnSOfFX+jmTwRS+eJb6ciOZvFSKd1uN/tkYXzk2QiiZ52O7G9jT4uDcWJB0roAvnuX5rmlevOymqcLMl5/aRovTzLPnJgkn83xqXzPraqz8/LqH44M+oFit/en9LatOwBPZAj++4qbGXrRkvFuSOZFsocCLl93E0nlMWg3VdgMnBwOM+BIlcWw1aHmr30c8U+CRrXWlm4N0TuS1Xi8mjcDZ0SB/++YwfZ4Yl+ezjx/eWkuV3cBEIMGz5ybJFSQiqRzXp4vxcq/1enmt10ttmYFeT4y8KNFRaaXFYeLa/GN+WbbU2xnyJUCWufumG4oB7/vDd7wYZYKsoKCgoKDwWyBXkPj+hUkG5xI8sKl6iYf1ujuCRiWQzBaosRuothv4+J4mfnTZzet9c6TzIh/cWM3lyTAqAbYusl5k8iI/uDhNn09kKh2nIMroNCoK8y1yCywI6lROpNKqp9KqZ3tTOQ9tfnfLW7fi2ICPdF7kQ5trlrxW93SUHk+xyW/El6Cz2sqYP8l3z0+wpaEcq0GDRa8p/Xm7WuGFQpNMTkSSZKwGDdOhFNmCRLYgksyKJLMFopk8F8eC9M3GMWpVNDvN/ODiNLIsc206gs2g5WfXPKgEOLzGyQfWV6NSCXx6XzNfPTHKN8+O88eH2/n4niZevDzNa71zZPIS922oWvVaybLMj68UJ86fP7i8rXAlEtkCp+bb5+biWaxGLZ/Z18xbAz6G5+JkRQmjrGZjrQ2rQYs3muHsaIBdzeVLsoTfGih+Ru5p0rBzVxs/vuouLuiFUjywqZqNtXZODgXY1lDGNXeEZ89P4pz3JB/pdPH9C1NY9BruaDXRNxunymagscJEk8PM24M+Ypn8bavGb74W50aDmHVqzHotqkXXLJrK80LX+8N3vBhFICsoKCgoKPyGyeRFvnNugolgise21S0plZAkmRszUZqdJkb9ydK0Ta0SeHJnPQadmlPDAZLZAkNzcdbW2JZUI18YD5HOi9RZVIQkDS1OMy1OM39239rShFGWZXyxLF89McraaitPH2xFq1H9Rnyf/ni2JNpurqQ+2jNLviCxsdbGkC+BSasmkS3wau8cY4HUstcyatVYDBqseg0yMrmCRK4gkRUlEpkCF8dDOCw6uibCGHVq/v746LLXyIsSk8EU6VyBVpeZ3S0ObEYtVr2GVK5ANJ3nka217GlxYDFollyDMpOOT+9r5msnxvjm2XH+8HAbH9nZgF6j5sSQn2xBXDUN4tJEmP7ZOA9urimlPqzGYmGcl2S21pfx+TYHXztZTADprLJyfNDP5jo7e1oreHvQj9Oio2syjEGr5r4N76R2+OIZzo0G2dVcTnk0SKPDxL+9q4NvnR3n6lSYK1MR2lwWLHo1oizzxPZ6nrs0xWuBJE/sqGdXczn/+61hoJg2sa7GOr/oaaWzysqxAR833FH2t6/cfrcS58dCDM4leHx7Pb2eGAPeOOtrbUXf8aWp943veDGKQFZQUFBQUPgNkswW+NbZCTyRNB9dYfFuLFCMNmt2mJFlliyoCYLAQ5trMGnVvHjFTSCR5ZFFqQjZgsjpYT/tLhPPD4vY7VpsBi27miuWeHOzBYnvX5xCoxL45N5mTLfJCf5leLVnFq1axT3rlloKAvEsVybDdFZZ+YvHNvFPp8eZjWZ4alcjvZ4o/+7uDnKiRDxTIJktEM8UiGcLxDN5ktkCAgI2oxatWoVOrWIimKTabuCutZWcGg5wZ6eLrQ3l6DSq0n+BeJaXrnsw1Vh5dFvdMq/sG31zlJt1HFrjWjWpo8Zu5A/uaOSbZyb47vlJPr2vmUe21mLQqjgxFCBbkPjw9qWlK4FElqPdHtpcZvatkr4BxaW4U8MBLiwSxneurSzF6TU7zPTMxBBlidoyI//5Q+uoLTPy7XOTfO3kGIIg8LkDLUvO/ZUbXrRqFfeur6br3AjA/DKcwIF2J3XlRl7qniWazhFN5/nIzgYujoe4PBkhmMjy9oB/vk46S7XNQLPDXBLIlVYDtXYD192Rdy2Q/fEsr/QUYws/tquB//n6EGdHA6yvtfFGn5fJYIqndr0/fMeLUQSygoKCgoLCb4hoOs8/nx4nlMzxib1NrK1e7pm9Nl1sootn8rjmrQ+LEQSBe9ZXcXokwEQgyfmxEB1VVvQaNV0TYeKZAjaDllhOZm+NjZwkL6mflmWZF7qmCSSyfPZAy6pVxr8KI74EfbNx7t9YvWSqDfCjebvBR3c1oFareGpXI18+NsyIL05BkpmJpEsJEbdDlmX+11vD3NHqoNlpZmguwcNb67DPF4TIsszJ4QCv9XpxmnU8fUfrilPcgdkYzQ7TbWPs2iutPLGjnhe63PzoipuP7Gzgvg3V6LVqXu+dQ5RkPrqzAZVKQJJknu+aRq1S8eSOhhWnywvC+PxYkIIks7WhjDs7K5flTLe6zHz5rRE6q6z8lwfX0zjf0PfEtjpe7ZlFlGQci35/Q3NxBrxxPrixekmaRTSVZ9Sf4K7OSu5eV8m16QjfPjvBlakI3zozxlwsw6E1TqbDGabDGTqqrHiiGaxGDRPBJBVmLa55Abu5oYxXe7yEkrlSPvdqiPPXQqtW8fj2etRqFXvbHLza4+XEkJ8TQwH2tFQsu0l8P6AIZAUFBQUFhd8Qv+j2EE3n+fT+ZtpWSDTIixI9M1HaKy30zcY4ssa1qsDKixIPballPJDkG6fH+fieRt4amCOcyjETSWPXzRd3OM1LIsiODfjom43z0OaaFc/hV0WSZI52z1Jh1i6bmoqixBt9c9SXG0p2ErtJy0d2NvDNM+P441l6PLF3LZCnQ2nmYlke315XSrFYEMeZvMgLXdP0zcbZXG/nsW11K0arRVN5PNHMuy4V2d5YLOZ4vXcOu1HL/Rtr2NvqoM8T42j3LNfdEXY0ltPriRbfS0MZz3dNkxMlCqJMQZLIiRL5gky2ICLDqsJ44Xr2z8ZJZApsbSyjfVHj3MmRAM1OMxa9hu+cm+SZw61UWQ0c7Z7FYdYtu/5XpsPIMmxvKi5zbmssp8Vp5o+/d4WfXPUgyfCl+zvRqFWcHPITy+S5o9VBPF3g6lSEO9dWlj6HW+rtvNrj5fp08d9vxVv9c7jDaT6+p7H0+9nVXM5b/XOlApIPbX7/+I4XowhkBQUFBQWF3wDZgsigN87O5opVhemgN062IGHSqZfZKxZzdSqCJMOTO+vxx7P88OI0//FHNxjzJ2mvtGAzqDDbVaTzErsWRXL1eWK82e9je2PZqsUbvypdk2G8sQwfX8FL+lqfl3Aqz1O7l05UO6utHOl08Z1zk5wdCfDkjvp3lRN8cSKEXqOi1Wnmx1dm+MB8QsRsNM33L0wRSuZ4cHMN+9ocqy7RDXhjAKy7RX7vzRxZ4yKWznNiKEAsXWA0kCCWLqDXqLg6GWHMlySRzVNXZqLMpENGxqRTo1Gr0KoEtGoVWo0Kg0bF9qbyVW0Fsizz02szuMMp1tUUvboLzETSnB8LcqDdyeE1Lv7hxBjfPDPB9sayFWP1ZFnm6mSYFqdpycS3zKTj7nVV/PiKmzKTlld759jaYKfCrCMvyvzxna38xdEBpoLJUgTewvOa59MsjnSufAMHMBlMcnzIz/bGsiWfY5NOw87mCq5MhvlX7zPf8WIUgaygoKCgoPAbYMibKEab1a4eRXbdHcGiVxNJ5agwa6mxL7cFyLLM5ckwTQ4TlVYDLoueDbU2/uq1QYxaNRvrrEyFMmTSxeKMBXHji2V4vmua+nIjj26r+7WTKhaTyYu80eelxWliw03vT5Rkfnp1BptBU8p4Xsy966u5MhXh+KCPC+NBDq+59VQynRPpdkfY3ljOWCAJwNoaa6kVz6grtt4lsiLhVH5VG8DgXLxoHbhNffZiBEHgnrVVHB/08fVTY+xpqeBf39lGfbmJN/u9/M0bw1TaDPyvp7b+Wr7uN/t9XJoIc2dnJclcgevTUQqihFol8LNrM5h1aj6wvhqjTs1n9zfzd2+P8NXjo9y7vmpJrB4Up+3+RI5Da5Y3/WnVApm8xH+8v5VMQebEkA9Rgg/vqMNpMVBp03NjJor2pmzpzfVl/Py6B28ss2wRE4qfh+e7pikzanloy/LmwAc31XDvuiqMutvfDL1XeX/KegUFBQUFhfcYPZ4oFr2aZod5xeOZvMjAbJzOahuj/iQba+0ritjpUBpfPMvOpnJSuQLfPT/JWwNz1JUZ2Vhr4+fXZ2koNxLJFr3HGrWKdE7k2fOTaNUCf7Cn6Tc+tTs+6COZE3lgU82yc+6aCDEZSnNwjRPjCl5ftUrgjw63odeoefbcJHlRuuXPujYdIS/K7GqpoH82ht2o4cJYkBe63DSUm3jmUCvnxkJ878IUf/36ID+67CaUzC15jYWYubXVtl/qRqHPE+PLx4YxaNVsqrMhCCDNn24iI+Ky6rHoNfyiexbppha7d8u50SDHBnzsbCrn3vVVdFbZyBYkJkMpLk+GmQ6l+eCmmpK4rLQZaHGaSedFouk8mfzS63dlKoxWLSz7NkKWZWbCaYw6FYIgcO/6Kv7krg6e2F5cZpRlGUkGp0XPqZHAkuduqrejEuD6dHTF93C0e5ZwKs+TOxtW/EZApRLe1+IYlAmygoKCgoLCr02uIDHojbO1oWzVpre+2RgFqfiVvHQLe8XlqRA6tUCZSctXjo0QTecx6zTcu86GjMBMJM14IIksw46mCiRJ5rlLRdvB0wdbsZvefX7tuyGUzHFmJMj2xnLqy01LjomSzI+vutFrVNy/oZq8KPG985P44tliGoWmmEihVQvU2g1cm47wX3/Wy/52J1q1gHb+uEGrYmOdHZ1axcXxEHVlxcl5rydWzDlOFzi8xsneVgffvTDFTCTNvesrSeVELoyFuDIVZntjOXeuraTCrGPUX5zm3zxtXY1UrsBL1z1cm45SYzfwqX3N2IxavnZilG+fm+BQh5ML4yE+urMBg664uIfAsnSL29EzE+Wlbg/raqw8Nj/lb3WZUavg2lSEvtkYLU4T2xYttfliGYZ9xQg1dzjFd85N8Jn9LcXsa0mm2x1lY619mVAdnIsTyxTYUGtnwBvnQIeLSpuhVHrii2WIZwocWuOkfzaOJ5Kmtqw4LbboNbRXWuh2R5ZlQfd6onRNhjm8xkWLc+WbwX8JKAJZQUFBQUHh12RorugtXk30AlyfjlBu0hKIF6uY68uXf3WdLYhcm4qg16r55pkJ7EYth9a4OD7op9lp4dxYiH9zVzu9nhi6VLFO+vVeL4NzCR7dWrus3vc3wSs9s6hVwopNcVemwoz5/3/23js6rsO+8/3c6TOYgjIz6L2RAHsRe5MoSra6VWxHstclthKnvOQlL97N7r59+17Oyfqd9xJn45fETrxed1XLsi3Jkij2ToINIHrHAFMxvZd73x8DggQBkiBF2SJ9P+fgUJo7M7gYzCG/87vf3/cbp9FmpLXMzK8uTtHnjrKiyoIoSWSy+cW1WFqk1KJD7VRwbMiXL6LQq5GuGsL2u6NsbbLiCid5clUF+/vcnJ8IsrTMxPMbaigxavjng8Mk0lme31BDe0X+td7WbONQv5dTI1eEciKTQ6tSXHeafzVdkyHePD9JPJ1j91I7O1pssx7fL2yu458ODPGNX/eyoqqQB9tK88ckeK/bDSxeJA97o7x8eoKaYgOfWV8z+xidOn/V4cxMKczjK+faY97uzMfqvbCxlhFvjJ+eHuenp8Z5YWMtExGRRC7Hmtr5KRGH+r0UGtQsr7BwdMhHMpObI6Ivl8o8uaqS7xweZl+vhxc21s4eX1ldyKtnHIz749TOvI6RZIY3zk5SYdGxe+mNrTJ3O7JAlpGRkZGR+ZBcmgph0ChpuI5AjaayDHqibGoo4eSInw0NxQte+u8YC3BpKkyZRcfGhhI+tbqSbx8axmrU0OuKYDdpebCtjD1tZew/MEXXZIj9fV7uqy+aU0Zypxj2RumaDLOnrXQ2peAy2ZzI+5dcZHMiO1ts9LsjnBj2s7XJumBygShKqJUKHIEEVqOWP9rVSKFBQyYncrDPy6EBH4l0Do1SIBTP8L1jo+jVSr7+iSUE4xm+fXAYrVrBizsaZyedAJYZH+z2FhsH+72cGp7m7HiAtgoL4WT2uh7laCrLL85P0TkZorJQx5e21s/z2xYXaCg3a9FrVCQzOd7qdPLI8vLZdIf3ut0IwNM3EcnOUIIfHB+juEDD5zfVolHNtcC0lpkY8sbY3Gil7Cpfep8rMtvEaNSqWF5lIZ6u4Ofnp3i9w8FgQMRSqqbBOncpdGw6xogvzmMryqko1HN40MeAO8ryKsuc5y4z6ygv1LO50cq+Xg/ucHI2Lq+t3IxaKXB+IkhtSQGSJPF6h4N0Lh/lt5jmwLuZe/unk5GRkZGR+YjJ5ER6nBHaK8xMBhN0jPnJXuOz7XSEECUwaJVkRWl2+nk149NxvvXBIKlsjs/eV83zG2oY9sXwRFIUGTQE4hkeW1mOUiGgUAiE0xKvdTioKTbckfroqxFFiQsTQV7rcGDRq9naPL804ux4kGFfnHKLjpYyIz8766DcomNP+/xJM+R9qcsrLRQa8pPjl09PIJBPPdjRakOpyE+rI6ks+/o8M9m6FQx5YvzwxBg2k5av7WyaI46vxqJX8/jKCj63qY5Cg4ZIMsP/+14fPzvrIHCVR1mSJC46gnzz/X56nGH2tJfyhzub5oljVyjJvxwcZsgX5892N/NQexknhv386+ERQokMu5bY2b3UztnxID87N4kkLexJ9sfSfO/oKDq1ki9tqV8wk3lNTRE7Wqw8cNVUNidKvNXpxGrUsKnhSiLJhoYS9rSVcm4iyGRUZHXNfFvPoX4vBo2StXVF1BQbMGiU9MykekDeDz86HaN1ZsFzS1MJWpWCfb2e2fvo1EqWlJnpmgwhihKnRvJteQ8vK5u1adxpbtfX/VEgT5BlZGRkZGQ+BIOeKKmsSE2xge8dHSWRyXGgz8tD7WW0V+SXxC44gpSatThDSUw6FbXFV7y8kiRxdHCaN845CCYyfHFLHVuabEiSxP5eDyatklFfjPYKM032vKCJp7N8MJ6lskrB8xtr7tg0TxQlzjuCHOj14I2msZu0fGpN5bylv2xOZH+fh6wosqTMzPGhaVJZka+sr77hguCySgsnR/ysqy3i2PA0b3e5eHxlBQaNCqNGxYAnSpFBzSeXV3BieBp/LEOP08mySjPPrq2eN3ldiMlgnDprAX+0q4mOsQCnR/x0jAVYV1fEutpiDvZ7uTQVpqpIzzNrq2ep9TUAACAASURBVOYVjKSzIvt63Rwe8KFXK3l2XRWrqwsRBIHqYgOvdTj41r4BPntfDQ/MtAnu7ckLy6fXzLVHRFNZvnd0hGxO4g921F/XH16gVfHwsrlT95Mj03gXiHUD2NlqI57O8TPX1JySGMh7i7udER5YYkerylsqWktN9LsiiKKEQiEw4I4iSswmoBg0KjY2lHBowMsDkSR2U/41WVFloXMyxImRad7tctFsN84R63eCbE6k1xXh3HiAaCrHH+5svKPPf7vIAllGRkZGRuZD0DkZQqtUcHx4GgmJp9dUcnjAx49PjlNTbGBLYwlj03HuX2LnyICXNbVFZESRMW+cIU+UfncUVziJTq1kWaWZPe35Yos+d4SpUJJCvRoEcTZCLZMT+cnJceJZiec31GLWffilvGxO5NxEPorNH8tQbtHN+HwXToE4Ox7EHU5i0CjRqZUMeGI8vrICs17Nvx4axhtNoVYKaJTKK9XQSgGVUsAZTHB8eBqTTsXPOhxEkvnvd2zIh0apYEmZGaVCoN8dISdK7G4rZU9b6aIn5D3OCFVFeioL8187mm0cHPByesTPqZEAKoXAw8vK2NZknTd57XdHePP8JP5YhnW1RXxiedmcie+ySgt2k5YfnRjju0dG+MSycu5fYkeS4INeDwLwqRmRnMrm+P6xUUKJDF/eWn9LU9d4Osvebg9NduOCi4aCIPDIinLU3t55WcsH+71olMKcHOwl5SbOTQRxBBLUlBjoc0fQq5XUXPVBbWuzleNDPg70enlufTWQt37o1Ap+ecGJQaPk6bVVd+RKhSRJTIWSnB0LcH4iSDydw6RTsbq6cFbE/7aRBbKMjIyMjMxtks2J9DjDpHIiU8Ekn9tYS1uFmTU1RXSMB9jb7ebv3u8nksrQWmpkxBdHq1ZyetRPTgSVQiCaylKgzU/62srNWPRqJEliX68HAYlAPM3upaUUFWgQRYmXTo0z5I2xpUJFTYnhJmd4YzI5kTOjAQ4NeAnGM1QV6XlkeQVLy03XFUKXp8dKIV+MMTYdZ3mVhQ31RbxyxsHIdIw1NUWIokQqJ5LO5r9iqfyfggDnxgMsr7Lgj6f5/rFR6koKUCoVPL+hhtHpOAf7vSiVAp/dUMOaRbbvQX6JzBFIzBaLQL7R7/GVFexottE1FaK51Dg7Ib1MOJnhrYtOLjpC2ExavrKtnobrlL3YzTq+tquJ1zocvNXpxBGI8+TqCiTyLYaCAI+vrODHJ8aZCiZ4YWPt7JLbYtnb4yGZzfHIArF6V6NRzj0Wimc4PxFkY0MJBVflNDfbTSgE6HGFqS7W0+cK01JqnCNEjVoVGxpKODLo4/6ldqxGLWqlgvYKCx1jAZ5aXTnPh36rRJIZLkyE6JgpnVEpBJaWm1lbW0Sz3fixEMaXkQWyjIyMjIzMbTLkjTHhT6BRCjyxupK2mRINQYDKQj331RdzbMiHK5Tinw4MoVQIrKy2sKbGSqPNiAB89+gogViGfneEZRUWJEliyBtlfDqOKEmUGLVsb8lbLl4766DbGeHxlRWkJqZv+7zTWZHTo34ODXgJJ7LUlhh4anUlzXbjTSeEHWMBArE0aqWAM5SircLCp9ZUcXo0wAVHiD1tpTesKB5wR/gfR0d5YWMNVqOWb+0bJJHJUWrWsbPVxtdfu4g/nuGvHl5yS+IY8otnkJ+YXovFoGZL01wvtSTlvbW/vuQim5PY01bKtmbrTS0rOrWS5zfUcLDfy3vd7tmGQUmS2N/nZdATJRDP8PSaSpaWX784ZiE84SQnh6e5r654zsLeYjgyk2e89ZqfU6/JJ2X0uSK0lZuJpnKz/uOr2dZs5cTwNAf6vDyztgqAB9tKWVJmumFCy424bKE4Ox6gzxVBlKCqSM8TqypYUWVZ0JP9ceDjeVYyMjIyMjJ3AYcHvDgCcT61ppIHl5biCMQ51O9jyBslns6RSGcRJXhiVQVnxwKolAoiySxalZLqIgP/dmQYs15FXYmB6WiK8xNB0jmRUCJNLJ2lQJNvp1MrBX5xYYpz40H2tJeyqbGEAxO3fr6pbI4Tw36ODHiJpnI0WAt4dm01jbaCRV06z0+PvRQZNFxwBNGrlTyztopwIsOvLjppKTWys3V+o9vVNNiMGDRKLk2GeW59NZ+5r5ofnRjHolfxaoeDYqOWZFakyXbrkXW9rggWvZqyRdgZXKEkb5ybZNwfp9FWwJOrK69bDb0QgiCws9VOVZGen56a4P/bP8Rz66rY2ZqP5dvTVsq6ultPFnmr04lGpWD3ArF6NyKeznJ61M/K6kKKFkjuWFJu4u1OFydH/AgCtJTOF8gmnZr1dcWcGJ7m/plMaYtejeUWxbEkSUwGE5wdD3JhxkJh1qnY1mxlTU3RR7bkdyeRBbKMjIyMjMxtEE3myyXKzDp+b0MtoiTxk5PjpLIirWUmmuxGRn0xDFoVDy8rI5bO8fjKCgY9Ed7rdvPGOQeJdI4vbWvgrYtTPL+xhuICLa+cmaDHGcZm0rKyqpD2CjPvdbs5Mexne7OVnQtUCt/0XFNZTo1Mc3Rwmng6R7PdyP1L7Lecm3xmLEAokcGsU+GJpPjDnQ3UFBv41r5BDFolz66rvqnQVioE2srNdE7m65XbKyy0lZvonAzTWmai1KTjQL+X06MBVt3CBDmby7fnrZpZqLseN1rCux2a7Cb+eFcTPzk1zg9PjLOr1cbXH2ql8DrxcjeizxWh3x3lkeXlGG+xyvrEcH5Rcsd13h9Lysy83emiYyxATbFhjgXjara32Dg14udgv4enVlfd8s8wNh3j3UsuRnxxVAqBtoq8haLJ9vGyUNwMWSDLyMjIyMjcIpIk8e1DQ8TSOf70gVqMWhVHBnwE4hm+vLWOJrsJSZL4oMdNk83I6HQcnVrB+roiNjWW0OMM85/f7CKbk3j/koucCOvrSiiz6Dgz6ufiRBBXKIlaqeCDXjcHZrKOH15WdktCzhNOcnTIx7nxfH3zkjIT9y+xU118697lbE7kQJ+XUpOGD3q91M7Ey73a4SAQT/PV7Q2LFnXLKi2cGQsw4Ili0qnodka4r76Yh9vL+Nt3etjebGXYF2PQE6XJvrAX+FpGfDFSWXGOpUGSJLKiRCKTI5nO4YmkeLszX5O80BLe7VJUoOGr2xt48/wU+/u8TAQSrKouxGbUYjNpF1W7nBMl3ro4hdWoYWPDrU2e01mRY4PTLCkzzUvluIzVqMFq1OCLpmfTKxbColezrq6I06N+7m8tXXQzozuc5N1LLnqcEUw6FY+tKGd1TdFdWzktC2QZGRkZGZkFODro49SIn6fXVM1bhjvQ7+XMqJ9GWwHbW2wk0jn29Xpothtno9gm/An8sQw7W+280+liabl51ts66InSYjeye2kZZ8cDlFvUlFl0TPjjDHlj1JQYaLKbODzgxRlK8sjycp64pmHtekiSxKAnypFBH/3uKGqlwOqaQrY0Wj/Upe3TowGC8TSCkM/R/fzmWs6MBeiaDPPwsrJbWkRrtBWgVyvpmgyRFSW0KgWPriind8aj+ujKCl45M8HeHvc8+4coSrgjSRyBBNFklmQmRyKT4+SInyFPlHcvufjVxSmSmRzJjEj2mmxdm0nLV7c33PGaZLVSwdNrKqku0vN2p5NBT3T2mFGrxGbKi2WbUYfVpMFm1FJk0MxOVU8MT+ONpvn8pvmxbjejYyxALJ1j+w2uLgiCwJIyM0cGfQv6j69mR4uN06N+DvR7eGJV5Q3vG4il2dvj5txEEI1SwZ72UjY3lsxGzN2tyAJZRkZGRkbmGiRJ4uSMYPn2oSEeai9jW7MVQRDyFolLLlRKBTtbbKiVCvZ2O0lmczy8rGz2Oc47gqgUAga1kkQmx7KZchB3OMmJ4Wk2NJRw/1I7u5ZcETX7et24QknaKsw81F7GD4+PUmTQMBGIs7/Pw65W+3UvU2dyIhcmghwZ9OEOpzDpVOxpK+W++uLrXk5fLJmcyIH+fELDkDc/1a0tMfBvh0dYUmZi+wJFIjdCpVSwdCZ6TJQkdjTb0KmV9DjDGLX5RsJdrXbePJ9vC9SplYxNxxnzx5nwx0lmcviiKSx6DQVaJVqVgiFPlCKDBpNOhV6dj5/TqRXo1MrZ/y/Q5pfVPqoWOEEQ2NBQwrq6YvyxNL5oCm9k5iuaomsyTDwduPI6KARKjBpsJi1DnhhNduMNp7sLIYoShwe81JYYqLtJqsnWZmu+HfAmy3+FBg1raoo4MxpgZ6t9wfSKWCrL/j4PJ4f9AGxrsrKj1faxXbq7Ve6Nn0JGRkZGRuYOkhc0afa0lzIZSPBOl4sRX4wH20p56dQEGqWCcoue5VWFBONpjg1Ns6q6cLblTRQluiZDLCk30e+JoFUpaC41IkkSv7wwhVal5MGZJaz3ut1Ek1k2NZZwdHAavUZJe4WZN89PsqKqkE+vr+adLid7ezz0u6M8t66KkquWySLJDCeH/ZwcmSaaylFu0fHM2ipWVlnmCMFIMoMosuhL5ldzetSPK5Qkm5MAgR0tNl4948CoVfPsutvLxl1WaeGNc5MUF6jZ3GQlmxPpc0Wosxo4Ox7EEYgz6Inwn37exdJyMwqFQJlZx+qaQnRqBb/ucrOmppDnN9biDif55t4BnlpdeUcrt1PZHPt7PWxpsmK6hbxppUKYnRgvvaZ1O5bKzhHOvmgKdyiJUgGPrrhxrNtCXJwMEYhneHQRbYoWvXpOPvKN2Nlqp2MswOEBL4+uqJi9PZXNcWTAx+EBH+mcyNqaInYvXbwV427hnhDIgiAUAt8AioE1wDDwdUmSzi7isd8AngEaZh73GvC3kiQFP7ozlpGRkZH5OHNpKl/Lu6amiJ0tNo4PT/PWRSdvdzqpKtKzqqaQQXeUllITPz8/CTAne3fYFyWSzLK8wsIvL07RWmZCrVTQNRliyBubbY/L5kSOD02TFUWC8RRTwQRra4u4MBGkolDP5zbVolMr+fT6GpaUBfn5+Un+cd8gj64oJ5AUeb3DwfmJIFlRYmm5iS1NVhqsCydSfPfICO5wiqoiPW3lZtoqzNhN2puKqkxOZF+vB38sTbFBTU2xAVc4STCe4cXtjfMmhmfHA1QXGbCZbpwIUVmoIxBLU11soNcZ5sigjxPD07jCSfpcUXRqBcsqLQx7o9y/xMb2Fjs6df6y/dudTnRqJZecYaajKXpn4t1uZh24VU4M+znY7yOays3Gnn1YCrQqCrSqW85GXghJkjjU78Vu0i5YKPJhKC7QsKq6kFMjfna02NCrlZwa9bO/10M0laO9wsyettK7IpHidrjrBfKMOO4AXpQkae/Mbd8GOgRBaJQkafgGj+0gL4z3AmeB3cBfzfy59qM+dxkZGRmZjyfdzjA1xYbZS8ubG630uyOcnwgSS+U4OjjNtiYrvplotu3NVgoNV1ILzk+E0KoU6NQKoqm8vSKdFXmr00m5RceGmSnnoDdfU51I53ir041eoySSylJdZOCLW+pmBSHAyupC6koKeLVjgtfPTuKcylCTCrKurojNjdYbCtJALI07nGJJmYl4Osd73W7e63ZjNWpoKzfTXmGhuli/oFg+PeqneypMkUFDRaGByWACVyjJoysq5nmzO8b8vNYxSbPdyJe21t/wNe4YC2LSqRjxRvnZuUmC8TTFBRo+v7GWRrsRu0mLKMHfv99PnyvKg215+4okSVx0hKgpNjAVTHB4wIcrnKSyUPehiyyuJp0VOTLgRaUQODseYHvzh/NwfxRMRiWcmSTP3KGGu2vZ2Wrn3ESQ1zsceKMp/LEMDdYCPrex7EOX1HzcuesFMvAfgOHL4hhAkqQXBUH4KvB14MUbPHYNUHR5WnyV2F4jCMIzkiS99hGet4yMjIzMx5BQPN/GdrWf+Nx4gD5XlK9sa2AiEOfn56aoKtITPj+FXq1kR8uVYoxMTqRrMsSySgu9M0tyLWVGDvXn2+qe3VY16yPumgyjUysYcEeYDMRptBspt+j40tb6Bb2cFoOaL2+t58xYgJOihy99YsmiPJ+D3ijBeJoig5q1tUVoVAo84ST97vwy36EBHyadanay3GDN+3QzOZE3zk4ST+d4cpWNo4M+gvE06+tK2dI091K9M5TgzfNTqJUCg94o4WTmujXYmZzIoQEvSoWAJ5LmiVUWJoMJyiw6Nl9VcqEU4P6ldl494+DSVJhllRbGpuOEEhkeXlbGiC/KieFpcqLEQ+1lC36v2+X0qJ9oKsfnNtbyypkJ3u1287mNtXf0e3xYOn05isrUrKy6vRKPm2EzaVlVVci5iSDlFh1f3LK4Mpl7gXtBIH8V+NsFbj87c2xBgSwIQgPwf19tpZAkKThjufg2sJ683UJGRkZG5neIS84QADajhkP9Xgo0Kn5+fpJ6q4HHV1bwq4tTNNkLcAaTHB3w8aWt9XOirPpcEVJZkRWVZl4/N0lLqYl4KsehAS8rqiyzFcY5UaJ7Kkx1kYF3u1wkMvl2sy9vbbjhJFQQBNbXFRMbVS56IeqdThej03GOD09zfGapCvLpCqVmHemsSDCR5r1uF3t73Jh1apZXmpGAzskQGxuKsRhUDHii3FdXxDNr5+YdJzM5fnJyHL1ayWfuq+E7h4a5MBFkW/PCqQpHBnycGQ1QU6ynqEBDOJklEM8s2MC3qqqQA70e9va4aSs3c8ERRK0UWFpuorpIzztdLuLXaYa7XTI5kUP9XhqsBbRVmNnRYuO9bjfj0/GPzeR00BPBHRN5rOnmzX8fhsdWVrCmtjDf/Pg7IIwvc1cL5BmRW0jeO3wtZ8hPggsX8hPPWC++vsDjLj/X7Xd4ysjIyMjctXRPhbGbtJwc8dPtDNM940euKtJzdMjHyVE/WxpLmAgkcIeTdIwHKC7QzCZMXHAEMWqVqFUKwoks7e1m3u5yAvDJZeWIooQ3muL4kI8eZ5jR6Zlpq17N8xtqKb6NgokbcaDXw9FBH8sqzfzHR9oIxtP4Y2mmY2kCsfx/JzI5RCnfpBZOZBj2RTk/ESAngVGj4g92NPLXb3ShUQl8eVvDnA8EkiTx+lkH/lia39+Wj0+rKtJzbnxhgewKJfjWvkHUSoE/291Mx1iQC478h5KFEhwUCoEHlpby0ukJLjiC+eXHMjNalRKtUYlRo2IykKDkDr5uZ0YDhJNZnl1XDcDmphKOD0/z7iUXv7+t/rcuFIe8UX54fAyzVmB9/a3Vcd8qeo1yNrrwd4m7WiCT9w8DLLRQNzTzZ/F1jt/sOffe8F4yMjIyMvcc8XSWEV+MjQ0lHB/yAVBTbGBNbRGRRIZXTjvodoYZ88VJZ0UeW1lOVpTY2+NmxBfjiVWV9DojrK8vpnsqglLIe1kP9/totBfwypkJJoMJUlmREW+EqVCCrJi/lN1eYSGczNyxn0WSJPb1enjz/BQWvZoXNuYLTYxaFVVF86eg2ZxIIJ7BPyOap6Mphr0x1jcUc3LEz9h0nM+sr5pXMnJsaJquyTCfWFY2my28uqaQX15w4golKbsqUmzYG+Uf9g4QT2f5y4daaS41k8pKXHCEqC7WXzcpYkWVhf19Hl7vcJAVJVbMWApyooRKKWDSqTg54l9wAn2rZHMiB/vzsWmNM3XXWpWSXa12fnFhigFPdMGa5t8UA+4IPzwxRnGBho316rs+b/jjiiBJ0s3v9TFFEIRngFeBB6/2IM8c+yvyyRZrF5NmcdXjOsh7mp+9zvGvkrduUFpauvall1663dO/LaLRKEbj4lqFZO5N5PeADMjvg4+KgUCOo5NZ2kqUHJ3MoFcLbKtU027Ni5BDjgznPVnSOUiLUG7ITxLTIoRSEga1gCDAshIFp105sqJEMicgShINhQqsOgVWgwKzWuLnQxkiKTBoBJ5rVnPWm6PKqGBb1eIWzW70HpAkibOeHJ3eHBoVpLISn12iRae69cmnJy7yg0sp0iL82RotBrVizrF3RjJUmRTcX62anawmshKv9KVpK1Gyviw/ixsJ5Tg8mcUVFakyKfjMEg0KQSArSrw+kGGFVcnSkuuLvbFwjp/2pjFpBF5coUWlEHBGRd4dzaBXgyjBsy0aVB+yzrg/kOPYZJYHa9VUmq78rDlR4o3BDBolPNag/q1MkSciIvsnMlg0Anvq1OSSMfnvgQ/Jrl27OiRJWnft7Xf7BPlGYYfBa/68KTPit/B64hhAkqTvAN8BWLdunbRz587FPv0d4cCBA/ymv6fMxwv5PSAD8vvgo2Li+ChL9Uk0SgXStIdPrKnk85vqEAQBSZI48es+lpmyZHISX95ah0WvYcgbZcgbpdMRomsyBIKAT2kAbYwWWwGxVI4XNtayrTnvFR3xxfj2wSESgo9Km47Pb6rl8VWV/PTUOKO+GDt2LFmU+Lree0CSJN7qdOILTPPklmLc4fyUet36ajI5kTKzbtHiLpbK8g8f9KMpCPDE8nI+ua1hzrF/3DfI0kb4k/ub51UKewtGmQwm2L59CceGpun3O2mpU1EST/PU6ko2N15ZxntgV35Yd6PzymRzvOk4gcmgYdfOdSgVAm9ddFKdneZzG2v53rFRDDXlc5b8bhVRlDj9fh/r21X83s7GeedT3BTglTMOipuqWVldeNvf53a4NBVi76lx1i7V88UtdRg0KvnvgY+Qu10g+29wrHAR95lFEIQ15D3JcrybjIyMzO8gqWyOAU+U9gozr5xxYDVqeWLVlXpnRyDBdDRFPJNjfW3RrC/TZtKysaEE6T4JRzBBLJmdSYfwolUpWFVdxM5WG5IEe7vd7Ovz4A4n0amUbGmy8onl+SaJZruRi44QnkiK0tuME5MkiV9cmOLEsJ8tTSU8sMTO37zVQ2Whnm/u7ScnQqlZy+qaIlZVF940Fu31sw5coRTVxQbuq7syk5IkiVfOTBBLZXlxR8M8cQywqrqQHmeY7x0dYdAbY1mlmUxOJCNKrK2d65tdjGAf9Mawm3UoyGctr68rps8VpsFWQEuZiboSA4cGfGxoKEF5m1Pk844g/liGR5YvXLqxqrqQwwM+3ut20V5h/kiX466m0xHipdPjVBUZ+MLmugVfb5k7y2/mN/vRcXmhrmGBYyWQT6a42ZPMxLtdtmrIBSEyMjIyv4MMuKNkchKuUIJgPMOnVlfOyTbumgzhCicxalQ8vKx83uMFQaC6yEBrmYkBTz7JQpTy7WjBeIbvHB7mg14Pq6osxNNZio0ant9Qg3pGZDXZjbPncTuIosTPzk5yYtjPjhYrjywvZ8QXY2w6TrczTF1JAU+sqkCnVvLrLhff+HUv3z0ywtnxAKlsbt7zDXoi9DgjlJl1FBk0LC03zx470Oel3x3l0RXlC/qZIS/4x6bjvNftZnNjCbuXlNLvjrKhvvi2fLMXHUEqLDraKszs681/yPBG0ywpy5/XzlY7oUSG8xO398+4KEoc6PVQbtFdt3RDEAQeai/DH8twZiyw4H3uNOfGA/z09Dg1xflsbFkc/2a4VwTyQlPfBhYR0zYjjj8Anr1RqYiMjIyMzL1N91QYjVLg6OA0pWYtn1x+RQRLksTpUT/JTI719cVzFs+uxR1OMTYdJ5bKsrnRiiuc5L/vG8AVSvLp9dWAgC+a4alVlXOKJwoNGmxGDYOeyC2fuyhKvNbh4MxYgAeW2HmovYxMTuL7x8fwRJLsbLXxxS31bGwo4Q92NPIXe1q4v9WOP5bi1TMO/vbtXl45M8GgJ4ooSkiSxDudLsw6FalsjmWVFjSqvGQY9ER5v8fN6urC69Y6J9I5fnRiHFGSMOvVPNhm59iwD6UgLLrq+GrSWZEeZ4TlVRb2tJcRjGd4+fQEcCX5oqU0nyF9qN/L7exXdU6G8EbT3L/EfsOJdkupkXqrgX29ngU/WNxJOsb8vNrhoMFawBeuKY6R+Wi5qwXyzLT3cgPetewGXr76hplYuGv5gEXWUsvIyMjI3JtkcyI9rjCxdA5/LMNTaypnyzwApkJJuqbClBRoeHBp6Q2eCTodQcb9ccosOiLJDD89NYHdpONPH2impEDDLy5MYTVqeGJVxbzHNtqNjPhiZHPiLZ37T0+Pc24iyJ72Una3lRJJZfnXw8Ncmgyxob6Yp9dUzbEdWI1adreV8pd7WnlxewMrqy30OMN898gI33i3l385OMyQN0aT3Ug6J7Fqxm8bSmR4+fQ4NqOWJ1YvbEMIxTN8+9AQY/4Yn9tUh9Wo5ex4kLNjQdbUFl43qeJGzGZLVxXSbDdSW2LAGUpSatZSNBPvJggCO1pseCKp2arwxSJJEvv7PNhNWtorzDe87+UpciSZ5djQR5cIe2ok30rYZDPy+U11clrFb5i7WiDP8HWgYSa1AphNsDhzdRPeTAHI0DX3e5+8V/lFQRBenfl6f+arY8aXLCMjIyNzjzPii+GLphmbjmE3a3lgyVwRfKjfiz+W5pMryrEYbizw9vZ6yOREUpkcFydD7Gq18dXtDRg0Sn56apxYKsuetlL0C5R8XBak4/74os47mxP5yalxuibDPLK8nF2tdpyhBP+0f4gJf5yqYgMPLyu/7kRUEATqrAU8tbqKv/7kUn7vvhrKzDp+dXGKYW+UzskQZr2KBmsBOVHipVPjZHISz2+oWVCwhRIZ/vngEMF4hi9srueTy8ooNKh58/wUOUlia9PCxSE344IjX0tdX1KAIAg82Jb//Vxt+wBYXmmhpEDDwVucIl+aCuMOp9h1k+nxZWpLCmgrN3Gwz0s8nb21H2YRHBvy8ca5SZaUmfjcptrZ6b3Mb467fUkPSZL2CoKwFviGIAifJm+7GJYk6cFr7nqafKLFWQBBEL7NlcnzQpNluHFKhoyMjIzMPULnZAiHP45SIbChvpjiAg2djhDHh33oVAp+dHIchQBmnZpORwijTkWBVolJq0anVsyKqgl/jGOD02hUAkUFGj69voZGmxFJkvj5uUkmAwkqi/SsuWpJ7VC/l3AywyeWldNoM6IQ8jaGy4171yMrSvzwxBj9ma3uPAAAIABJREFU7iiPr6xgU2MJPc4wL5+eQKdWsr3FxuEBH832xcWAqZUKllfls5iXlpu5r64IfzzDyqpCFAqBdzqdjE7H+fT66jnWkMskMzm+f2yUZCbHV7Y3UFmoB6C9wsw/7hvk2bVV2Ezaxf5K5jxvnyvCffXFs1P9RpuRz2+qpa6kYM59FQqB7S023jg3OTsBvxmSJLG/14PVqGFF5eIrm/e0l/EPHwxwsM87u2h5Jzg84OXtThdtFWY+u776N7YIKDOXu14gA8zYI64VxNfe5zWu8iRLkvQi16mhlpGRkZH53UGSJD7ocSMBJUYta2uL8UVTvNoxgVGrwh1O4gmnaLAZefeSe97jlQoo0KrQqxS82+0mlEjzwsYa/vj+5tkq6LPjAS44QlQW6WcFKMCZUT/vdLkA8MfSfPa+GqqKDAx4ouxpv/45p7I59o5lURRGeXpNJWtrizgy4OPtLieVhXo+t6mWX11wYtGrb0mUJjM59vV6WFpu5rn1NbO3d0+FOTTgY2ND8azd4mpyosRPTo7jDif5d5vrZsUx5C9VZ3MSRYbba7rrdobJihIrq+Z+32unx5dZXVPI3h43B/o8ixLIva4IU6Ekz6yda6u5GaVmHaurCzk2NM3mRutNrywshv19Ht675GZFlYXn1lXfdhqHzIfnnhDIMjIyMjIyt0vXZJh+d5RGWwGFBjXtFWZePjOBUiHwle0N/Jc3L1FZpOff/t1aNCol0WSWaGrma+a/vZEEPz45wbg/jrVAQ06E7xwaxqBRkstJHBnyYTfpGPWlKDXr6XdH8EVTvHl+ima7kZXVhbzT5eJ/Hh2ltsTAkUEfiXRuXmJBJJnh7HiQ0yN+XHGR/+WBKlZUFfLm+SlOjvhprzDz3LpqVAqBwZnIulsptDjU7yWezvFQeymRZIZ3ulyoFQLnHUGqivQ8ssCk9PJ0fMCTF+tXt8yJokTXVJjKIh1TwcRt/X4uTgQpMqipLtbf/M7kJ+Fbm6y80+Viwh+f1/x37bnv6/VQZFCzqvrWK5t3Ly3loiPE3h43T6+tuuXHX30eH/R4+KDXw+rqQp5ZW3VLYl3mziMLZBkZGRmZe55oKsuAO4JJp6bQoKZQr0alVCBJEj86MYpCAVVFeuxmHZemwoxNx3l2XRXD3ijD3uiM7SI/iTVq5/7T6Qol+POXR3CHk7SVm3l+Qw2iBIlMjlgyy+FBH9FklmKDSJ87RkaU+N7RUbqnwqiVAiqFwOh0HK1Kwf6+vFgDGPBEWFFViChKDHiinB710+MMI0pQbzXwYI2aJWVm/uexUQY9UXa02HiovRRBEJjwx0lkcouaoF4mlMhwZNDHyioL4USW7x8bJZbK0TUVQiEI/M2TC1/uP9Dn5cxYgPuX2FlXN9eZ2DUVIhDP8FB7GV2TYdzh5C1lPMfTWQY8UbY1W29J6N9XX8yBPi8H+728sLH2uvcb8ERxBBI8tbrytqa1RQUaNjQUc2xomm0tVuymW8+v9sfS/PLCFL2uCGtri/jU6lubZMt8NMgCWUZGRkbmnue9Sy5Oj87NrTXpVCQzOQ4N+KgpNjDsi1Nq1vHGOQdt5Wbay838zVs9KBQCu6+TXNHvCvPnL19gMpRgTXUh/+eTy+bkAv/q4hS1JQV8flMtY9NxjFoPL+5o4AfHx2ivMNFgM9E9FSKSyiJJEqmsyMXJENFkFnc4RV1JAcFkGgUCdpOWLY0lrK8vwWbS8ov3xvnng0P4YymeWVvJ2tor4nTQE0UQuCWBvK/XTSYnks6K/PDEGOUWHeUWPcF4mgKtip+cGmd7s5UHlpbOZjefHQ/wXreb1TWF7F5qn/N8kiRxqN+Lzajh8ZUVdE+FOTceWDBD+np0TeY/EKyourXWOp1aycaGYvb3efGEkwt6pi9Pjy16NWtqbr8Vb2ernTOjAd7vdvP8huuL8WvJ5EQO9Xs50OdFqRB4ZHk5W5pKfisV1jLzkQWyjIyMjMw9TTYn0jUZpr3CzKbGEoLxNMF4Bm8k7zPOiRKpbA5fNIUnnCQjSgiCwN+81cO4P0ZNsYFlVfOXt44OevnrN7oIJzI81FbG//F4+xxLRK8rzNHBaTY3lrCkzMTbnU4a7Ube7XIz7o9TUqBhMphgS7OVupIChr1R+t0RlAJ0RkJcdARxR5IU6jVUWHRkRYmO8SDuSIpyi463htNUVWX50pb6eQt9A54IlYV6CrSL+2feE0myv9dDMiPS646ws8VKLJ3j9GiAJ1dXsr3FxtudTg72++h2RnhmTRXpnMjrHQ4abQV8anXlPGE35I0xGUzy1OpKTDo1zXYj5ydCPNRetmgReNERxGbUUH6D3OnrsbnJypFBHwf7vTy7rnre8eGZEpXHVpZ/qEU4o1bFtmYre3s8N7V0XKbXFeaXF6bwxzKsrLLwieXlN201lPnNIgtkGRkZGZl7mgFPlEQmx/q6YhqvEpK/uDCFSatmY4OeUrOWYDxLKiuyq9WG3awjEE8TS2VZUm7CfFV27+Wa5b9/f4CsKPLlrfX80a6mOaIvlMjw2hkH5RYdDy8rwxVO4o0kmQok6HFFqCrS01xq4qH2MqqLDbjDSQLxNGqlglKzjnRWZNgXQ6NQUG81oFEq0KkVqBQCzmCSAXcErVLgD3c2YjXOXcJLZnKMTcfZ3rK4SLVsTuSb7w/Q64qwo8XO8xuqOTcR5PRogO3NVh5sy9s2PrWmiuWVFl4/O8nf7+0nEE+zvNLCCxtrFxSYhwe8GLVKVs9MZ1fXFPHS6YlFp0uEkxmGfTHub11c9Nq1GLUq1tcVc2J4mgfbSue0IgLs7/Vg0uXv82HZ0mTlxPA0715y8eWt9dc930Asza8uTtHtjGA3afny1vpbmvLL/OaQBbKMjIyMzD1NpyOEQaOk0XYlEmzCH+fE8DQFWiUVhXqcoSTJTI7tLTaenJmGeiMpjg5Os6ziyvQ4mxP5f97t47WzDtRKBf/xk0t5as3c5SxRlHj1zASZnMhn7ssvzP26y8WJYT+CILCi0sIf399Ek91ILJ3jh8dH6XZGUCqgrdzCZ++rwaRT8Y1f95HJioDA0gozoUQWbyQFQIFGhdUsUFIwPxlixBdDlFhUvJs7nOQ7h4Y5OeJn1xIb/+vuZt7qctExFmBnq409M+L4Ms2lJr60tY5//3on7lCSFrsJdzhJ7TVxa65Qkn53lD1tV+wYbRVmtCoF5yeCixKFXZMhJAlWLDC9XyzbmvPC9fCAj8dWXilmGZuOMeSN8cjy8tnz+zDo1Ep2tdr55UUnQ94oTfa5VdWZnMiRAR/7+zwoBIGHl5WxpbFEjnD7GCMLZBkZGRmZe5Z0VqTbGWZltWVWjIiixBvnJtEoFBRo1agEgVFfjFU1hTyx6opVoGMs71lunxHI4USGf/+zTk4OT1NoUPNfH29na/P8Ke2hAS9D3hhPr6kkkc7xnUPDvHpmgkQmx9NrqvjLPS0oFAoGPVFePTNBPJ1jT3sp6+uKZxcAJUnCbtZiM2oJJzKMTcd5fkMtxQYNe3tcHB700TeeJfTLS3x2fQ111oLZGuIBTxSNUqDmJukNRwen+fUlJ/3uKKuqLfzFgy388oKTcxNBdi+1L1i5nMzkeOnUBDXFBn5/az1HBn18+9AwWxrzk+bLhRaHBrxolAIbGq5MZ9VKBcsqLXRNhnh8ZcVNyy8uTIQot+gW9A8vlkKDhtU1RZwe9bNriX329d3X66FAo2R9/a0nV1yP++qLOTLo49ddLv5ol3H2tet3R/jlhSl80fzE/ZHlNy+bkfntIwtkGRkZGZl7ln53vqJ4eeWVJayjQz6coSTLKsx0TYXodoVRKRU8u7Z6VkD1OMMcGvCyuroQi0HNoDvKf/jZRYZ9eU/yf3msjVU188XViC/G+91u6koMdE+F6HFFSWayJDMi21ts/NnuFiQE3r3k4mC/F6tRyxe21FFumRthJggCzXYTPc4wf7yriW/u7ed/f7OLEqMGi16TX96bFjg6MM2lyTBNdiOVhXpqrQUcHfBSby247nQyFM/wakfe6lBsUFNTbODpNVX8/PwUFx0h9rSXsqvVPu9xOVHip6euZB23lJpYU1vEu5dcHBn00esK8/SaKooMGi5MBNnQUDKbA32Z1TWFdIwF6HGGWblAnvJlArE04/44e9pvXOu9GLa3WDk7HuDYoI897WVM+OP0u6M81F56R+ubVUoFu9tKefWMg87JEDXFBn510cmlqTA2o4Yvb62bN1mW+fgiC2QZGRkZmXuWyxXFJp2KUyN+mu1G9na7WVpuIpbKkhMlxv0J9rSVsmymRc0dTvLy6QkqC/U8ubqS97td/N17/UzH0iyvsvC/PdQ6O1W+TCYnsq/Xw95uN9OxNJmciEGjYmtTCW+en8KsV/Pnu5uJpbK8dDqfl7yutohHV5YvKNIkScKgUdLtDPPf3ulBmrktEM8vBD6+qoKDOheKijZePjNBThRRKRUcHfRxZiyIN5om8m4vdSUF1FkLqC0xYDNqOT8R5BcXppAkeGp1BUcGfJSZtQx4IvQ4I3xiWdmC3mVJknjz/CT97iifuirrWKdW8sSqSpZVWvjZWQffOTyM3aRFArY2Wec9T4O1AItezbnxwA0F8sXJEMC8cpDbwW7S0VZu5sSwn+0tNvb3edCrlWxsKPnQz30tq6oKOdTv5VcXnaQyOSRgT3sp25qssp3iLkMWyDIyMjIy9ySXK4rX1RVzoM/DufEgxQUaBEHggSV2vrVvkCFvDI1Swe9vqwcglsryg+OjaFUKPr2+mn87PMzrZx2ksiIbG4r5o13NtJbNnQIOeiL8/NwU3miKUCKD3aRlR4uNjY3F/OTkBN5Iil1LbExHM/zs3AiSBJ+9r3rB6DJPOMn5iSAXHEHc4RS+SIrWUhOfXl9NXYmBV844ODHin71Ev73FRqFBzSsznueH2krzRR9tpQQTGfrdEc6OBwHQqRUkMyK1JQaeW1fNsDeKJ5Ki0KCmxxnhsRXlbF5A1EI+6/j0aIBdrbYFl9oabUb+9IFm3r3k5vjQNCurLBQv4I8WBIFV1RYOD/iIJDOYdAtbDS5OBKku1i/4HLfDzlYbl6bC/OL8FD3OCLuX2mctKXcShULgE8vK+f7xUdrKzTy6onzecqDM3YEskGVkZGRk7kl6nGEyOYnllRZ+cHyUQDxD52SIv3qoFWcoyWQwQTCe5uFlZRQXaMnmRH5ycpxQPMOTqyv57x8McHjAh1ohsKXJyle2NcxZLoumsrzd6eTceBCrUUOT3ciwN8YXt9TRbDfy45PjDHqj2E1aRBF+cmqc6mI9n1lfM0f4RVNZzo8HOTceYCqUzOcX24w8sLSUCosOs149W6v8wsZaXuuY4N1LbspyWXaSzwjWq5X8+OQ4PzgxRm1JAY+sKEcQBCRJwhdNMzadjzQrNevY3FhCVpR495JrdunvydWV152onrsq6/jBtutbHrQqJY+vrGBTQwlm/fXlxeqaIg72+7joCLFlAUHujaSYCiV5dMXi85JvRlWRgSa7kXMTQbQqBZsbF/4gcCdoLTPxnx9pm9eCKHN3IQtkGRkZGZl7kgszFcXZXI5oKksmJ6IQBETyPuSpUIKSAg0Pt5cjSRIvnR7nyKCPcouOH58c58JEEINGyZqaQr60tYF6az6pQZIkzo4HebvTSSqbY1erjYpCHT8+OcGWphJaSk28e8nFpakwZUYdh11ejDo1D7bZebCtbE5j29h0jB+fHCeSzFJVpOfRFeWsqLLMTlZdoSTHh6ZJZ0U0KgVKhcBz66oRJXj/9BSBWJqiAg3NpSa+uLmOr/3kLJIErnCScoseQRCwmbTYTNo5LXeH+zx0jAWoKNTzzNqqeQ14lxn0RHn97PWzjhfCZtLe8HipWUeFRcf5ieCCAvmiI4ggMGt5uVPsbLUx6ImyubHkIxevsji++5ENMTIyMjIy9xyXK4pXVFnocUVxhZLYTVoebLOzt9vNe5fcaFUKGqwFRFNZ/tPPu/je0TFESaLOWkCZWYtFr2JldSFf2dY4K4590RTfPTLCax0ObCYtf3J/M5sa8z7jcouOh9rL6Bjzs7/XQ0mBmuMjPgwaFX+4s4GHl5XPEcenRvz86+FhNEoFf3J/E3+0q4ktTdY5toMmu5GsKDE6HZu9TRAEPrmsHIR8GsNlFIr8Yl+JUcN3Dg0z6rvymKsJxFP8y8EhBEHgS1vrryuO84kV45QUaHl+w8JZx7fL6poiHIEEnnByzu2SJHHBEaK+pOCOF2c02ox8ZVs99y+Zv4AoI3MtskCWkZGRkbnnuFxRvLzSwsnhaZKZHJsaS3h+Qy3dU2GmgglEUWLUH+dHJ0a54AiyqaGYb356Fc+urWJ0Oo5Bq+KxFRXUlBjI5kT293r4h70DTAYTPLmqghe3N2A3aXmtw0EinWNnq40zowFePTNBKJFhMphEIShmyiCu+JZzYn7h7Y1zkzRYjXxtVyMVhfoFf466kgJUCoFBT3TO7RaDmiVFSs6OB2ZtEoOeKAatkr94sAWTVsX/ODpCjzM853HJTI7/+otuAvEMX9vZyJoFkjguc6DPSyyd47n11Xd8Irqy2oIgwLmJ4Jzb84UqqQ+VfXwjGmxGeVlOZlHI7xIZGRkZmXuOyxXFOUmiczKfp7u0zMyb5ycZ8UVJpHMkMyLraovRa5Q8uLSU//xYGyVGLXt7PDgCcVZUFbKhvpix6Rjf2j/Ie91ulpab+drORuxmHceGpvlv7/TyxtlJ3JEkPz01wY9PjjHkjWHWq2myG2kpNbK+/sqENprK8t0jw/lEhWYrX9hcNy8K7Wo0KgW1JYZ5AhlguU2JSiHwQY8buFIvXVlk4Ks7Gik16/jRiTHOjufznBPpHP+0f4hLU2EeXV7OA0uv7ycOxtMcHfSxuqaQyuuI9w/DlerpIJIkzd5+0RFCIUD7HbZXyMjcKrIHWUZGRkbmrmIymOD0iJ/HVlbMsSxc5uqK4l+cnyKeztFeYeG7R0bodoYwaFVY9ArMejWSKFJk0PD5TXVoVUp80RTvdjkx69U83F7Ky6cnODTgBfKX6CeDcf7u/QFgxsbhjlBnLeCTy8pwBJP0uyKsryvms/fV8MuLU1QXG2YX8qaCCX54YoxYKstz66pYfYPp7dU02o28d8k9L/VBrxLY3GTlQJ+XjY3ROfXSRq2KL2+t50cnxnj1jINoMku3M8zp0WlaSk18YUvdDb/ne5fcCALsucFS3odldU0RL5+eYMQXo8FmRJIkLjryLXuX86hlZH5byBNkGRkZGZm7isP9Xk6O+Dk/EVjw+OWK4gZbAR/0eKgp1uONJMmKEhWFelZWFVJTYiAYzzDgi/H8hlqKZkTsG2cnGfBEUSsU/F9v9fDdIyOEk1lMOjWCAJWFBva0l/LChhrKLTq2Ntv4yz2tjPjijE3H2dJk5U8faMasUzPhT9BekU+fuOgI8i8Hh5Ak+Or2hkWLY7hSGb3QFHl7sw2dWsErpx3z6qV1aiVf2FzHskoz3z0yzP5eDyad+qbRY45AnHMzC3QfZURZW3m+evrcTAydI5DAH8t8ZPYKGZlbQf6IJiMjIyNz15DJifS6IkB+QW1VddG8KfJFR95ScaDPSzSV5f6ldvpmHmMzagklM2RyIjqNEq1KgUal4MiAj5Mj07xyZoKcKOGPpyk2aPi9+6pZW1tMqVk3Jzf3zfOTBOMZ1tQW8r2j+dzkFzbWzBaIXK6pbqsw8+uufGtebYmB5zfUXDf793pUWPQYNEoGPdF5wlqvUbK92cZ3Dg9TbtbNq5dWKRVsbbLy1kUnEvm4s/+fvfuOjuu+77z/vtMbpmAGddABAiwA2JsoierdiiwXybZck3jjjdeb3ZzEm82TPMlzzuZ5nM2JcxI7LllbrnGRbKtYlSoURYq9gQBJ9D4YzGB6b/c+fwwIEgTYQVpUfq9zdEjN3HvnAoLmfOeHz+/73d62cBDIGYqi8MoJL2admu2LDAxZSjqNilXVVk5MRnh0TTVdExE0KomVVaJAFn73RIEsCIIg3DQGfPG5oR37hoqryOvrz2Z8Q4kso4EkHW4rb5zyUWkzkMoWmAilkBWZVImeRKaAP5bhlmYnXRMR/uzZ49SVmpkMJckXFBqcJrY0O/nEpjpqHKYF93BqKsquvhkAjo5FWF5ZwuPr3PMK3+7JCC6Ljpe7puidjrO5sZRHOquuaoOYSiXRXGZhwB9HUZQFrdZuaXHyz2/2k8jkF1w/ky/wq8MTdLht3NLspMJmuGjm+bQ3xtBMgkdXV1+XQRrnW1vn4MhYmJOeKF2TYVorLKJFmvC+ICIWgiAIwk3jxGQEo1bNwx1VuO0G3jrtoyCfs8lrMoKiKAz7E2TyBZqcZqajGRLpHGpJxfGxCEdGQ4STOYKJHDUOIzq1ivtWlDM8k0CvUfFwZzVfvnPZosVxNJ3j2zsHGZ6JY9Kp+fBaN5/ZWj+vOI6kcpz2xhgJJOj3xXlsTTWPrXVfU/eElnIL0VR+rmPFuZKZAnaTjmxBWRDDeLXbiz+e5eMba9neVs7ySusFX0OWFV7p9lJm0bGpcfHWb0utyWXGatTwSreXaCq/6HRBQfhdEAWyIAiCcFPIF2ROT8VYUVWCRq3iruUVBBO5eVnkrvEwuYJMOJ3DbtQiA6FEhni2QCiZJZUrYNSqWV5ZgkGrpqmsmNn9q+e7iaZzfHJzHZ/f1rDoKmYyk+d//voEJ6eibG128l/vWcamxtIFK7qvnJiixxPBatDyB7c1sfkCE+quRMtFcsj9vjjlVj01DiM7Tk7PdYXo9cbYNxTk1hYXzWWWBeed7+BIEH8ss6Bf8/WkUkmsqbETSeXQqSWWV5Vc+iRBuAFEgSwIgiDcFIZmEqRyhbkJayuqSqi2GXj7tB9ZVvDHMgzNJIikcrgsegxaDZFUlmgmTzYvk84XcJl1PLrWzfc+u5GPb6jBE05x0hNhKpLGZdHzyc11i06LG/DF+fNfdXHaG+PxdW7+9N42XJb5E+P8sQzPH5vkl4fGcZr1/Nn9bXMDRq5VqVmH06xjwL9YgRzDYdLxSGcVY8Ekp70xEpk8vzoyQaXVwH2rLt2JIp0r8MapaRpdJlbc4CL1TK56RZUVvUbEK4T3B5FBFgRBEG4KJyYi6DWquU4NkiRx94oKfrxvlKPjIUKJLGPBJK0VFpxmHUP+OJKi4I2kkRUFnVpNjcPE5sZSkGDAH0erVlFpNxLLFCjICn//ai8dNTa2NjlpdJnJywqv90zz+kkvo4Ekj66u4o+2N88V0bKscNobY+9QgAFfHFlR0GvVfGZL/ZJ3gGiZ7RtckJW5FV5ZVhj0JVhZbWVDQynv9s/weo8Xp0VHKlvg89sa0F5GtGNXn594psBntlZd1jjppVRpM/Do6uq5VXJBeD8QBbIgCILwvifLCienonPxijPOrCK/dcrHTDxLQVZ4oL2SN0/5yOZlIqkcyWwBjVrCZdZTZTdSYTXwjbcGCCWzrK93cGQsxPbWMoxaNU6LjiF/gu7JKFU2A7KiMBVOk87JbG4q5fdvbUKSJOKZPAdHghwYDhJO5rAZtdza4iRfUFBJEmvqlj5L21JuYf9wkLFgcm5lejKcIpUrsKzcglolcfeKcr759iBqFXxqcz1VtksP+Ygkc+wemGFNrY3a0oW56xtha/O1x1AEYSmJiIUgCILwvjc0k5gb+HGuM6vIo8EE+4YDtFVYKCvRMxVJk8kX8MXSFGQZg0ZNg6s4Mvr5o5PkZJkv3t40147tzx9oY0NDKbF0ni9tb+Yj69wAZPMyDU4TTouOJzbUEkxk+eWhcf7upVM8e2iCcDJHqVmLoijsHgiwbzhIjcNIpdWw5N+D5jILkgSD5+SQB3xxJOlsRrnWYWImniGRyXPLZWafXz/pRVHgvpWVS37PgnCzEivIgiAIwvtejyeCTi3RWrEwH7uiqgRvJEM0leNz2xo4NRXFH0sTz+RJ52QURWFllZWJUAqdRs3qWjsf31DL0EyCQ6Mh7mgto9FlwW7UcdobZcepaT6xqY4NDaX0eCL8YM8INqOWf3t3iNFAknSugFmvobzkbBHc4DJT4zBS4zBR4zBel5iCUafGbTfS74tzz+yEuzPjpc16DbKs8OyRCWpLjWhVKo5Phue1wFuMJ5zi6HiY21pcc8NSBEEQBbIgCILwPifLCj2eKG2VVnSahb/49IRThJJZbEYtyUyBA8Mhoqk8yWweWVawGLRYDBoGZxL80fZaPrKuBoBvvzOIVi3xxdubAHCYdWxvLeONUz42NcQ4PhHhG2/1E03nsRq1mLRqGl1m1tbZaXRZcDuM1DiMF+0rvNSWlVt4p89POlcgW1AYDZ0dL72r389oIMnnb2lg71CQN0/5WF1jv2B7OUVRePnEFEatmjvaym/Y1yAINwNRIAuCIAjva6PBJLF0nnb3wh6+sqzwg/dG0Kol1tU5eO6Yh+7JCIlMnpysoFUXN/Wd9ERZWWXlI+tqkCSJ3f0z9HpjfKizivJz4hDbWlz85ugkf/DDQ0TSeVQS3N5axgOrKtnUWHpdRy9fjpZyC2/3+hn0x/EmZGSl+JgnnOKNU9N0uG2srXNgMWh5es8IB0aC3NLsWvRafdNxBv0JPtRZJYZzCMJ5RIEsCIIgvK91T0bQqiXaKhfGKw6OBDnpidLgsvDJzXX8vy+fYiSQxKBRIRdkapwWUtkCCvD7tzYiSRL5gsz39wxj1qn5/LZGoDiBb/9wkOeOTdIzGSGQyFJtM/C/Hu9gc+P7ZwNZXakJvUbFgC+OJ66gM0tU2wx8+50hzDoNj62tRpIklpVbaHSZ2NnrZ0N96YKVd1kurh67buBQEEG4mYgCWRAEQXjfUhSFbk+EZRUlC3rkxtI5Xu32IisK25qdrKm1MxZMks0XkFBocJopMWgZmklw2zIXnTXFDX6vdHsZCyb5xMZaJkIpDhyZ4Oh4mGF/As1sIT4dTVOT1iBRAAAgAElEQVTrMNHhti12W8iyQjJXIJHJE0sX4xzxTJ54Ok+13TjXq3mpadQqGpwmBn1xJhMy6+vNvHnahy+W4QvbGubiHpIkcd/KSr6za4i9QwG2z8Ywzjg0GsIXy/CpzXXXNOFPED6oRIEsCIIgvG+NB1NEU3naVy2MV7zS7SWQyFBpM7C61s7ugRli6TyyUpzQ9mB7JT8/NIFZp+azW+uRJIlYOsdP9o2iAibCKX64d4RQIksmX2BNnZ26UhOD/gQPtFdydCzMzw6M47LoSGSKxXA8kyeRyZPMFVCUBbc051Ob665bkdxSXsJLJ6aIZRRMejV7BgJsbXay7LwNjA0uM60VFt7p9bO5sRSDtvgBI5MvDgWpd5pYVX3h0dOC8B+ZKJAFQRCEJRHP5Nk7WFytXGwz3dXo9kRQq4pT1s416I9zdCxMmUVPXlaoLTXydz85Ra4go5Kg1KRjOp4mnsnxwKoKWsotnJqK8o23+jnljbK80opZryGdLVBq1rGxoRSXRc+rPV42Njj48Fo3Zp2GXf0zeMJqzHoNFr2acqsei96MWafBrNdg1qux6M/8XYNOreLf3h3i2cMTlFv18zpdLJVlFRY4AQUFuiYilJXoeWDV4i3a7l1ZwTffHmR3/8xc54t3+4ofJD69pf6GDwURhJuFKJAFQRCEJXFwJMhbp31AsTC7Voqi0D0ZYVl5ydzqJ1DsZXzMg92kIZOTWVFl5fWeaU57Y0gSOC16akpN7OjxUaLX8uSmOnac8vHyiSmOjIVx24w8sKqCfl+CUouOD691k87J/PuBMVZUlfDYGjeSJPFgRxX3r6pEpbqyIvKpzfV84+1+frJvjP98R/O8e18K5SV6SgwaQhmZWlnhiY21F/xAUuMw0e62sntghq3NTvKywq5+P501v7uhIIJwMxDBI0EQBGFJ9HpjQHFscTCRvebrTYZThJK5Bd0r3hsM4I9lWFPrIJWTMes0vHzCSzKTx6zTsKmhFFAIJrKsr7fjKtGzu99PPJ1Hr1FRbTcy4E+wrcXJV+5ehlql4hcHx6l1mHhyY928gvhKi2MAm6lYlM/EMzx7eALlYlmMqyBJEs1lZnQqiXtXVeK2X3xa3r0rKsgWZHb1+Xnj5DSyonD/BVacBUEoEgWyIAiCcM0SmTxjwSQbGxyoVRIvdXmu+Zrdk1FU0vx4RSpbYGevn7YKC9FUDrUEh8eC9HgiKAo0lpnpcNvwR7NIksTaOjs7e/1MhtP0++LkCjKtFSX80e3NPNJZTTiZ48d7R3GYtHz2lvoli4Y0l1l4sL2SHk+UXf0zS3LNM7onI5yYjNDiULF9Wdkljy+3GlhTa+e9wQCHx0JsbXJRKoaCCMJFfSAKZEmS7JIkfUeSpGckSRqUJGmHJEnrrve5giAIQlHvdAxFgU2NpdzRVsbJqRh907Grvp6iKPR4IjSXWeYN4ninz0c6X+DuFeV0T0ZI5WR6PFHi6Rx2s46WMgveSHGKnsOsZdCX4LvvDBZ7I2fzfKizmj+9r5U6p4lIMsfTe4o9lD+/rXHJB37c2lLsnPFaj5cB39V/L851dCzEzw6M4babuLtOe9kr3PesqEBWFAwaNXcuv3RRLQj/0d30BbIkSXbgMPCMoigfUxSlGRgCDkuS1HS9zhUEQbhWvmiaf36zf8mKpwuJpHJ8a+cgvlj6ur3G6akYJQYNbruRW1tcuCw6fnvcQ74gX9X1vNE0M/HsvE4QkWSOPQMB1tTaiabzTEXS+GNpxoNJVJLE8goLGrWKPl8cnVZFe7WVXx+dZGgmgdWo4c62Mr589zI0ahWpbIHv7xkmnSvwuW0N12XMsiRJPL7OTXmJnp8dGCd0jbGT/UMBnjk8QaPLzBdubUCvvvz4R6lZxxMba/nUlrobOvlPEG5WN32BDPwFMKQoyhtnHlAU5T/N/vWr1/FcQRCEqxZMZPnenmGmIml2L/Gv4M93ZCzEWDDJoZHQdbl+viDTNx1jeWUJkiShUat4uLMKfzzLe4OBi547E8+wu38GX3R+8d49GUWSYOU5bcjeODUNFDO1B4aDTIRSTEfTpLIFyqx6LAYtoWSWYCJDKpunayJCJi9j1KnY3lrOV+5qxaLXkCvI/HjfCMFElk9vrafKdvEM77XQa9R8anM9BVnh3w+MkbvKDwy7+vw8d8xDW0UJn72lYUFP6MvRWWOnucxyVa8vCP/RfBAK5C8COxZ5/Mjsc9frXEEQhKsSTef43u4hcnmFdreVfl+ceCZ/XV5LURSOjYWBYkuwpd4wBjASSJLJyyyvPFvMLq+0sryyhLdO+4imc4ue1z0Z4RtvDfDSiSm+/kY/39o5yKGRIJl8ge7JCE0uMxZ9cbXTF01zeCzEliYnRp2KV7u9pHJ5Ypk8FoMWp1lPOldgNJBkPJQili5g1KkpsxRbrd22zEWd04QsK/zi4DgjgSQf21BzQwrGshI9H99QHEry/DHPFf03UBSFN05O80q3lw63jU9trkMrBnsIwnV3U/9fNhuDsFOMRZzv0Owx9qU+VxAE4Wols3m+v3uYRKbA57c1zGZD4cRE5Lq8njeaxhfL0OA0EUnlGA+mlvw1TnujaFQSzeXmeY8/3FlFQVZ4tds773FZVnjlxBQ/3T9GWYmeP76zmYc6KknnCvzqyCR/9Vw3+4cDlFn0c8Xkaz1edGoVd7SV8dP9Y0yGUuTyMkatGrtJi6wo9HpjDM8kUAGVNj0SxUz0PSsqODIaQpYVXuzy0OOJ8khHFZ01N+4tfmW1lTvbyjg8GuLAcPCyzlEUhZdPeHnztI/19Q6e3Fgrpt4Jwg1ysweRzuSEw4s8Nzj7Z+kFnr+WcwVBEK5YOlfg6T0jBOJZPntLw1wf2kqrgWPjYbY2O5f8NY+NhVFJ8LENtXx9Rx8nJiPUOZeu/62iKJyeitFcZl7wa3+XRc+2Fhfv9BUnudU7zUTTOX5+YIzhmSRbmkp5uKMKjVpFjcPErS0uxoJJfrh3lGAiy67+GYYDCepKTXRNRLhvVQUvdXn4xcFx0vkCpSYtLoueyXCKYCJLQVYoteipsRuYCKepKzXxN4+uZCyY4qf7x/j+nmEG/Qm2t7q4pcW1ZN+Dy3XPigomwyle7PJQZTNe9L+Doig8f8zD/uEgW5udfKizSgz1EIQbSFqKX7dJkvQ48J8oFpZ/ryjKyDVf9PJe96PAM8C95+aIZ5/7c+BrwHpFUY4s1bmSJH2R2fhFRUXF+p///OdL+BVdWjwex2IRGbL/yMTPwM0pLyu8MZpnOilzZ62GOuvZYvKEP8/h6QIfadVRoru8Iuhyfg4UReGZvhylBol76rW8MZojmFb4WKt2yYqtcEbmuf4cm6s0rHAuzMXmZIXf9OcwamB9hZpdEwVyssIt1Rqa7YvnaJ8fyCJJ0OZQ0xfKc9Qnky3IuIwqEnmIZWTyMlSYVHiTMrEsSBLYdOC2SEwmwKCGx1q0rKvQoigKLwzmCKUVmu0qbnVrfmfFZiav8OJQDlmBDzVrMWoW3oesKOyezDMUlukoU7OuXL3o/Yr3AkH8DFy7O++887CiKBvOf/yKV5AlSbobeB34rqIoX5IkaS3w7OzTTmCHJEnrFUWJXtMdX57SizwXPu/PJTlXUZTvAt8F2LBhg3LHHXdc4haX1s6dO7nRrym8v4ifgZtPQVb49/2jSLYYX7m7hrV1jnnPr0lm8bzai6WugjuWl1/WNS/n52DIH8cWGuZjG2tZXWvHNhbil4cmaO5sXrJV5F19fqoSXp68v+2CnSDKWkL805v9vB1UsaKphE9tqafCuvgI5pl4hteCfTzSWcW2FhenpqL8w2unCSVzJDJ5wrksyUIBl1lPDJk8edRqhQqrDrNeg8tmJKlKsbLayn9+vGNuit2yNUl6PFHuWVGB+iqGfyyljnCKb78zyITOxBdubZx3P/mCzM8PjpMyRfnsxgrubLvwz4N4LxDEz8D1czVhpnuB/6Eoypdm//0JQAE+OluBP0Fx9fVGuFiQy36JY67lXEEQhMuiKAq/OjzByakYj66uXlAcA9hNOhpdJo6Nh5d0E93xiTB6jYrlVSVAceCGRiVxYnLp8s693hhVNsNccZzOFeY9n84V6PZECCdzJDN5vrCtcV5xrCgKqezZc7pn721VtZVCQea7uwaZjmbY3FhKY5kZjVqFzaDBqFORK4BGrcKoU6Eg4TDpWFFlpaAoPNheOW/Ec43DxP2rKn/nxTFAtd3Ih9e6GZpJzMtnZ/MyP943So8nyoc6qy5aHAuCcH1dTYHcRDGacMY9AIqi/Hr2zyNcfHV2KZ3ZYLdYz2Ln7P1caAX5Ws4VBEG4JEVReOG4h6PjYe5bVXHRjPHqGju+WIapyNL0Ks4XZE5MRFlZZZ3LBhu0alorLJyYXJpuFqlsgZFAgrbKYgF+0hPlb188yY/3jjAZTjEVSfHNtwc4NRXjC9saqHOa2DUwv6Xd4dEQf/HrLn6yr3hOjydKjcOIQavm71/vpWsiyto6B9FUjkFfgtZyC2UlBmQFKqx6svlicW3WqfnLh1fS44niMGnZ3vb+Hoaxts7B1mYnuwdmOD4eJp0r8IP3hun3xfnIOvfvJCMtCMJZV7NJ7/yuD+tY2CrtRg3ZOHMv6xd5romz0Y+lPlcQBOGSXj85zb6hILcvc3FH68ULto4aGy8c93B8PEy1/dr78vZOx0jlCqypm9+pod1t4+RUjLFgknqn+QJnX56+6RiyAitm27vtHQpg0qkZnknyNy/0EEnlWFZu4Yu3N1HvNKNQHHaxqaGUSpsBRSn2Bj7tjTERSrGrb4ZAIssjHVV88+0B3u3zU1tqpFAocGo6jkGrYjqaBkmi1mFiPJggU1AoK9Hx1JZ6VBKMBZM82FF5VX2Cb7SH2ivxhFP8+sgELosebzTNkxtrb2h3DUEQFnc1K8g7gK9JkrRGkqRvUYxXzK0oS5Jk4wYVyLMrvEeYXcU+zz3AL8594NzpeFd6riAIwpV4p8/Pzl4/mxodPNBeeclNYSadhrbKEo5NLE3M4vh4BIteTct5fX6XMmZx2hvFoldT4zASTGQZ8MXZ2OCgrdJCJieDopDJy+zqn2EqkuLelRUYtGpePF7sBTzkj3NkNIRZp2F5pYWpSJohf5yn3xvm9R4v+YKMLCsMziSJJHPYjFpyMlTb9diMWkaDKUw6NZsbS3mwvZJfHZlEo5a4Z0XFNX9tN4JGreKTm+vQa9X4Yhme2lIvimNBeJ+44gJZUZQ3KW5eO0Kxc8URRVH+jyRJNkmS/hB4k8V7C18vXwWaZjtPAHNdKA4pivLsOY99DRg897jLPVcQBOFK7B8K8Gq3l84aG7+32n3ZHRNW19iJpvIMzySu6fXTuQKnvVE6auyozsvcLlXMQpYVer1xWitKUKkk9g8HGPLH+dedg+zqm+FTW+p4+nObeLC9kiF/nH9+c4BfH5lkfZ2doZkEewZm+JsXTxJKZikr0aPTqNGpJVSSREFWGJsd+DEeTJDI5Km2G5AArVpiS1MZXZMRJAlayy1saXbii2Xp9caothlpKb95dvVbDVq+tL2ZL9/Vwooq66VPEAThhriqjuOz45gdQLOiKBtnH4tQHLDxVW7gFLrZFm3rgXslSTosSdIzgFNRlHvPO/QgZwv7Kz1XEAThshwfD/P8cQ9tFRY+tr5mQYF6MSuqrOg1Ko5PXNv2hx5PhFxBYc0FViM7ZgvxsWDyoteR5QsX0KPBJKlcgRVVVjyhFP+2a4ixYJKCrKBVS6yrc2A2aLh7RQV/fv9y7l5ezoAvzq6+GXqnovzNiz2c9ERprSjhqw+0cWoqRt90jLpSI/mCQkGBEoMWSVLhCaeYjmaIpfNsbXRwYDhAMJHBpFXTVGZhe2sZO056Kcgy7W4rJt3N1eLfYdZdsKuHIAi/G1f9LjJbEEfOe+zoNd/R1d3LEYrdNS52zLMskiu+nHMFQRAux6mpKL88NE6D08QnN9df8dQznUbFyiorJyaifKhTvuqpacfGI5SatdSWLp5lXl5ZMhezuFAOeTKc4rvvDHLfqkq2LbJh7PRUFJWkMBPP8K87BxgLJllRVcKX71zGG6em+dHeEb50RzMmnQajTs09KytoLDPzL2/2E0pm8cczSEg81FHFM4fHyRVkQKLfl0Ctgo+ud1Neoufp90bIFxTi6RzT0TSeSBqtWoWiQKlZx63LXEyEUkyEUliNWppuwOhoQRA++MTMSkEQhCUQiGf42YExqu1GPrO1AZ3m6t5e19TZSeUK9E3Hr+r8WDrHoD/O6hr7BaMdBq2a1sqSi8Ys+rwxsgWF33ZN8XqPd8FxxyfCzMSzvNLtZWQmgcOk45FONy8c93DbMhfhZI6f7hsjX5DJ5Au81DXF93YPU2418LWPdmLRa8jLCi+fmGJn7wzjwSR6rYpahxGTVs2x8TC/PDSBSpJodJlRqyQkSSFXkFGpivndBpeZ21pcvHFqGoNGhc2gpdF1bRsPBUEQQBTIgiAI10xRFJ475kElSTy1pX5e/90r1VJmwaIvFohXo2sigqKwoHvF+TrcNqKpPKOBxWMWI4EE5SV6NtQ7eLvXzwvHPXORi31DAXb2+ufiFJm8zMOdlQz4il0tDgyHeHRNNUMzCb79ziBf39HH7oEZNjWU8t/uaaWgKBhnN+aFklkCiQzZvEytw0g8W5y0NxFOkc4V2Njg4PG1buwmHWpJhSwrqJFwmnV8ZK2bkUCS6WiGxjILSNI1d+YQBEGAa4hYCIIg3AwUReHFrincdgPr669Pi/aj42EGfHEeXV2Nzai9pmupVBIdNXYOjQRJ5wpXXGwfGw/jthsoL7l4pvXcmEXDeauuiqIwFkzSWWPjsTVuzHo17/TNEEvnMevUvNg1hUYt0Vlj48hYmHqnmUqrga7JKA+2V/JKt5fJUAqNSuI3Rz10uK38yT2tc6/zzKEJjFo1D3VW8/UdfRi1KhxmLemcTDqbp6XcQjKbZyyQYtCfQKNSIUkSjWVmHu6oQq2SmI5muG1ZGd99d4hKa3EDn8uiu+bvvyAIAogCWRCED7jRQJK9gwFUEpSXGKgtXZoRy2ckMnle6pqirtTElqalKcDX1NjZOxigxxNlff3CyXsX4o9lmAileKij8pLHGrRq2ipL6J6M8Ehn1bw4hi+WIZ2TqSs1I0kSD7RXkcrJfG/3MDq1RF2pCa3aiCecxmrQ0OA00+OJsbbWzm3LXOwbCvCtdwZZVVXCrS1OsnmZ5Oy0vMlQihMTEbY2O3m3r7gKrdOoiKbyZPIZahwmGl0WhvxxPrG5jkJB4aQnQjKbZ1NDGU9tORtfOTQSZCae5anNdfzqyCSrqkUXCEEQloaIWAiC8IG2q9+PSaemxKDll4fGyeQLlz7pCrx0Yop0rsDj6y6/ndul1JYaKTVrrzhmcXw8jCRx2b10O9w2ouk8I+fFLEZm28zVO00oisKegRmOjIZocpkotxromogQTeVZXlWCWa8hnSuQyRcoL9HznV1D+GMZ7EYt1XYT//OhFdSUmvjloXE84RT/fmCUvCwTS2XpmghjM2rJ5GQ0aolNjU6e/txGmsvMtLttfOWuZfz3e5cRz+aJpHKYDRrONAXJF2TePO2jxmGk1KwjlSssWAkXBEG4WqJAFgThA8sXTXNqKsbWJicf31BDIJHlt8enluz6A744R8fCbG8tW9I2XZIksbrGzqA/Tiydu6xzFEXh+ESYJpf5smMGbZUlaNULh4aMBpNY9MW+xD94b4Tfdk2xrMLC3z3eSbPLzEw8Q64gMzKT4NRUlJ19frzRDK/2TBNMZHlyUy1ffWA5gUSWI2NhPr21Hq1a4u9fO82vjkwQSubYNxwkV1AoL9FT7zSxocHBH9zWRCiVY9Cf4O4V5Rh1aqaiabJ5meWVJfiiGZ7eM0Iik+fgSIhwMsd9KyvmCnyxQU8QhKUiIhaCIHxgvds/Uxws0ezEotewvbWMnb1+2ipLaHfbrunauYLMc0cncVl03Lm8fInu+Kw1tXbe7vXTNRFZtM3a+SZCKWbiWbZfYqT1uYpDQ0romYzwSEfVXM/msUCSshI9//LWAJm8zEMdlVRaDfx0/ygvdk2hU6sIJbM8f8yD1aClsczMF29voqXcQplFjyRJyLLMO31+vr9nmE63DX8sw+6BGULJHM0uI1qNmoKsgKIQTORpd9vZUO/gX94eoMyiY3OjE4DfHJkkW1D46gMryMsyvz4yyTffHiAvKzS6TLSUWzg0Oo7NqMVhEvljQRCWhiiQBUH4QIqmcxwbD7OhwYFFX3yru2dFBQO+OL8+Mkmtw4TtGgqqt077CCSy/P6tjWivsl/xxZRbDVTbDBwbD19WgXx8IoxGJbGq+soK/w63jR5PlNFgkkaXmVg6RyCRRadVcdobY2WVlVe7vQQTWfqn48iKwt0ry2lwmvnp/jHUqmLnjluaXSiKQo8nymlvjP7pGL5YhpGZBLKscNeKct7p9aFRgV6roc8bQ61WYTHImPRqYukc7/T58McyfHpLPWqVRDKTZ2efn2XlFjpqil+Xy6LnJ/tGiaXzfGJTHVCMhDSVmZcs4iIIgiAiFoIgfCC9NxCgoCjziku1SuKJjbXIisIvD41fdFLcxUxFUuzq87O+3jFvrPFJT/SyIxGXY3WtfXZlOHPR42RZoWsiQltlCUbdwq4XwUSWr+/oY+9gYEE/4+VV82MWZ9q+DUzHCCdzOC062mY7Xtze6uKWZhef3FRPXlZwmLS4LDp29/sZnklwZCzET/ePcdITpcFl5lOba/n9WxuJZfJ8480Bopk8OrWKU1MxcrJCk8vEZ29p4Ct3L8Ni0PCtd4aoLTWyoqoEgGePTJDMFPjwOvfc/daWmvjju1r43C0NNLrMBBJZouk8DaK9myAIS0gUyIIgfOCkcwX2DwdYVW3FZdHPe85l0fOh1VUMzSR4d2Dmiq8tywq/OTpZbFN2TrcIXzTNj/eN8sap6Wu+/zOKwz6Km+8upphVzrOmdvHNeXsHA/hiGV447uEXB+dvVNRrznazkGWF0UASiWKh3Ogy8WB7FUP+BM3lFtbU2tGqJewmLQeGgzgtev76QyuxGrQ8vWeY3x6fQiXB5sZSoqkcT+8Z5ek9wxwfDzMdS2PQqFlba0enlrAZtfz1I6v47NYGHmyvosllIZLKFWMXFIv6N05OU2bVcVvL/NiI1aClrbJYRJ/ZUCjyx4IgLCVRIAuC8IFzaCREOidz+7LF87jr6hy0u6283uNlIrT4oIwL2TccYDyY4uHOKky6sym1gyMhALono3NF3rWymbQ0Os0cHw9fcOIdFHsfG7SquaLxXLmCzJGxEO1uK/etqqBrMsI33x7EF03PHdPhthFL5xkJJBgNJigoCvFMgU63jR+8N4JZr+bz2xoZCSRpcJrZPxxkOprmztYy2t12vri9GbNOw45T05yYjPCD94Z5tdvLeChJrqDQXm3FrNewrMLCdCyD06JjW4uLF7umGA0kCCWyDM8kuLOtDE84zRunfLzW4yWQyHJHW/miq+JnDM8kMOvUlJXoL3iMIAjClRIFsiAIHygFWWH3wAyNLtMFex5LksTja2soMWgXrKheTCSZ4/WeaZbNrqaekZ8tQq1GDclsgUH/1Y2JXsyaOjv+eJbJcGrR53MFmR5PlPZq26JZ6O7JCMlsgc2NTu5sK+cL2xpJZfN88+2BuTZyZ7pZHBsP4wmnmI6kyOQL/PLQOAO+OB/fUIssK0xF0iyrsPDicQ+lZh2/t7YYfbDoNayoKkEtQSpboKXcwu2tZTQ4TTy+zs2aOjt6jYqJUIpsQaazxsEXb2/CbtLy472jPHdsEkmCP76zhQ31Dl447uHlE1OUmnVsbLh4b+mRQIIGl8gfC4KwtESBLAjCB0rXRJhIKsftl+jmYNSp51q/vdS1sPVbNJ0jX5Dn/l1RFF44PomsKDy2dn7P45NTUZLZAo+tcWPQqi4ZibgS7dU2NCqJ4+ORRZ8/NRUlk5dZfYF4xf7hIGUWHc1lxQhCS7mFL9+1DLfDyC8OjvP8sUnUkkRbZQn7h4PkcjJjwRTJTB6DVoPLouPpPSP84uA4sqIwE8/gCae5f2UldpMOKH4oOTEZwe0w8lBHFQ+0V+GPZ+hw2/m9NW7eGwxg0KhQSRI6tYpKm4H2ahuf2dqArEDfdJxtLS7sJh2Prq4ikc4x7E/gMOlYWXXh4R+RZI5gIifiFYIgLDlRIAuC8IGhKArv9s9QXqKnrWJh3OB8TWUWtreWcXAkRPc5vYBT2QJf39HHd3YNkc4VV5d7PFFOTsW4Z0UFpWbdvOscGA7iMGlZXlnCqupiV4jcOcX1tTDq1LRWltA1EV50U+Hx8TBWg4amRYpEbyTNaCDJpkbnvILeZtTyB7c2cfsyF/uGgnxn1xD1pSa8kTTDgQS+WAatWsWf3NvKXzy0gqYyMztOehn0xXjm0DglBjVPbqqdu17fbMcKm1GH1ajht11TtJZb+Ny2Bn51ZBxPOE2Z1UCn20quoKBRS6hUEmUlej69tZ41tba59nT9vgSlFj0GrZpgIkMmf+Hv43CgmD8WA0IEQVhqokAWBOEDY8AXZyqS5vZW12X/yv3u5eXUOIz8+sgkkWSxA8XR8WKG2RNO8f09w4STWV487qHaZuDW81quBRNZBv0J1tc7ePmEF4tBTSYv0z+9dDGLtbV2ouk8Q7Mb0s5IZvP0TsforLHP9TA+1/7hABqVxLr6havLKpXEgx1VPLWljpl4hh0nfQTiGfp9cbKzvY/vbCvDZdHzxMZaqu1GAE5NxXCZ9cQzxQ8OiqKw4+Q048EkY8EkPZNROtw2ntpSz7A/zi8PTWDSqWl0muiotVNq1jEdSRNMZIHi5ronNtZh0Bb7Ir/aPYVFp2FldQlWo5af7Bu94IeNkZkEeo2KqiUc0iIIggCiQBYE4QNkV/8MVoOG1Zc5ahlAo1bNtX575qoy9HwAACAASURBVPA4siyzfyhIjcPIJzfXMRlK8VfPdxNO5XhsrXtBIXpwJIgkQaXVwO6BGd7p9ZPI5OmaWLqYRVtlCXqNasHo6eKGwGJO+XyZfIGjY2E63LZ5mwnPt6raxpfvbMFp1jIZThJO5rAZNfz3+9rmPmQM+hIYdZrZyIWeUrOW/+fFHv72xR7++oVuXjjuIZLK4TDreGJjLU9urCWQyPK1V3tJ52Q63DYsBi0mrYb2ahs2o5bnjk4u2Hh4cCSIP56lym7AZtTxxduamAyn+NXhiUU3KQ7PJGhwmhb9cCAIgnAtRIEsCMIHwmQ4xYAvzi0tLjRXOLjDZdHzSGcVg/4EzxyexBfLsKWplFXVNu5oK+PUVIx0rrCgU4IsKxwZDdFWUcJYMIlKgganGX88wzt9/sve/HcpWrWKdreN7snIvNXUY+Mhyiw6qm0LV1C7JiJk8jKbmy6+yQ3AadFz98pyUrkCClDjMM57/rQ3ij+aZjKUpN5pQqNW449n2NM/w9HRMHajls4aGx9bX8PmJifBZJbv7hpiJJCgskSPTqNiQ72DsWCS9Q0O7m+vpN8X5/jE2VhLOlfgzVPTNDhNBBNZllVYWFPn4L6VFRyfiLCz1z/vnuKZPL5YRsQrBEG4LkSBLAjCB8K7fX70GhWbGy9dEC5mfX2x9duvj0xQkGU63HbyBZnuyShrau0YdWp+8N7IXCYZ4LQ3RjSdZ0O9gx5PlJZyC5/f1sj6Ojt903GeOTi+VF8ea2ptZPIyvd4YAImcwvBMkjV19kXjJAeGg1RY9dRdoJPHufIFmW/tHEKWQa9RISHxjbcGODUVZf9QgJ8fGKNrMkw8k8dm1LK+3sH//aFVfPvT67AZtcQzeQb9CUoMGsLJLN/bPcxUJIVeq8Zi0FJm0VNWoicvK6yusbOl0UmNw8hLXR6S2TwAu/r8xDMF1szGSTpmR4Fvby1jba2d109Oz8uJi/7HgiBcT6JAFgThphdKZDkxGWFTYykG7cKeubF0bl5huxhJkrh3RQWxTJ5oKodCccOfL5bhD25r5KnN9YwHk/zwvZG5leFDo0FKDBrsJh2BRJZV1TZ0GhVfuWsZVTYDzx338Havb0m+xiaXhRKDZi5mMRQu3sNicZKJUJKJUIrN523Ou5AXjns4NBJErZJodJnn2r79aO8oP90/xkQ4hUmnYUuTk699pJOPrK9hRZUVrVpNbamJ9fUOcgWZV7u9/MtbA6SyBcw6DQVZxqxXc3tbGX3TcewmLbWlRlQqicfXuUlmC7xywksklWP3wAyra2z44xk0KokVs90rJEniw+vc1DiMPHNoHM9su7uRQAKtWsJtN17sSxMEQbgqokAWBOGmt2ewOBFvW7NrwXPJbJ5/eqOf/++V07zaPUX0IqOgT05FaXKZMeo0/OLgOG+d9tFZY2N5pZV2t40nN9YxNlsk+2MZTntjrK93cNobRZKYG5Gs06r5+IZatCqJV054eb3He9FBH5dDpZLorLHR642RyhYYisjUlZpwWhYOyDgwHESnlli7SDb5fN2TEZ45NEE2L2PWa7htmQskiYc6qvjo+hraq60YNCrqnWbuW1WJ/pwPIIdHQ+g0KiqtBh5qr+Ku5eUYtCpubXEyHkwiIdHgMrOm1kbfdIxOt22uYK+yGbltmYtDoyF+un8URYH7VlbQPRmltcIy74OOVq3i01vrMeo0/GjvKLF0jpGZBLUO0xXHaQRBEC6HeGcRBOGmlszmOTgcZHWtHZtJu+D5HSenSeUKNJeZ2dU/w/9+tZfnjk4yE8/MO06WFQ4MB1ldY+f+VZWcmoqhUUs80lk1d0xHjY0nNtYyEkjyD6/1ki8oc/GKBqeJEsPZ119Ta6fBaabSpuftXj8vnZi65iJ5dY2dZLbAnz97nKFwgc6ahT2C07kCx8fDdNbYF11NP1cwkeX/vDtMJJVFp1HhMOm4a3kFOrVE33ScdXV29gwG0GrUVNsNbGhwzJ2bzcscGw/TWlHCVDTN8iorD7RX8Wf3L+e0N0YgkcVm1HLfykoGfQlkpfj9O9ddyysoNWsZD6bY2uwklskTSeVod9vOv1WsBi2f3lpPMpvnR3tH8UTSIl4hCMJ1c+GtzYIgCDeB/UNBsgVl0bHS09E0B4aDbG4s5ffWuJmJZ9jdP8Ph0RAHRoJ0uIv9d6vtRvp9cULJHA+0V7Kyyko8k2dFVcm8ohegs8aOLCv85XPdVNkMZAsyU5H0vEIaoLbUiMOsw2HSsay8hD0DAXIFmcfWuK966luNw0g4mWUkkCSVUuj1xllfPz9WcnQsTLagzNuclyvIjAYS1DhMc8fmCzI/em+EAX+MGoeJUDJLpdXAymorI4EEPZ4IFVY948EkbruReqeZKtvZOEOPp7gJ0GXRoSjFASQAY4EkR8ZC5GWF1ooSNjY4+OHeUZxm3YI4hE6j4mPra3m338+dbeW8eXp6XrzifG67kY+tr+XfD4wBov+xIAjXjyiQBUG4aeUKMu8NztBaYaHyvE4OiqLwUtcUeo2ae1ZUAMVuFY+tdXPXinLeG5hh31CQrokIrRUWQoksFr2alVVWNGoVH11fc8HXtRg0uO1GJAn+5c0BCrKyYOKbJBUjEe/2z/DxDTXoNCp29vrJ5RU+ur7mqlqTTYZT5AoyVTYDOkOaQX+cb749wCc311FlM6IoCvuHA9Q4jNQ4TERSOfYNBTgwHCSZLaDXqFhX72Brk5P9wwF2D85QV1osmvMyrK2zYzNq6XDbODYW5ju7htCqVZRadGyod8y7l8OjIUrNWtK54nXPbAbc1e9jMpTCrFPz+Do36bzMoD/O9tayRT8YNLjMNLjMKEpxGt/58YrzddTYuC9Rwb6hALWlIn8sCML1IQpkQRBuWkfHwsQzBW5bZPX4tDdGvy/OI51VmPXz3+qsBi0PtFexvbWc/cMB3jw1zd7BIB01VnqnY6yssl50lffgSIjaUhMPtFfyv146hd2kxWJY+HbaUWPnnb4Zejwx7l9ViU6t4vWT0+RkmSc21F5RflZRFF4+MUVNqRF/NMsmp5p7b2viZwfH+NbOQR5dXU1ZiZ7paIZbW5z84uAYXRMRFGBllZXVNXZOeaMcHA7yyokphvwJDFoVj61x869vD2DSqVk1G22othsZ8McJJ3OUWXRYDdp5o6xDs8NR7llRzrHxMI0uM2qVxHgwyb6hYjG+tdnOmlo7+4eDKMrimwnPNRZMEk3laV+1MF5xvjvbyrnjAgW3IAjCUhAFsiAINyVFUdjd78dtN9BcNv9X7fmCzMsnpiiz6NjS5LzgNYw6NXe0lZPKFpiKpCk16/jJvjHKSvRsb3XR4baj08wvYhOZPD2eCFuanLRWlFBWoieXl/nR3lE+s7Ue7TlFb7XNgMuio2sizKbGUu5cXo5Oo+K3XVPk8qN8asv84y+mxxNl0J/ArFNTatYSzRZXX//LXcv4+YExnj08wUw8QzCRRZZljDoNtzS72NrsnBuN3VFj45YmJ//X892EklmqbQZePjHFZDhFbamJ1ooSfLE0P3xvBK1aosllJluQ6aixzVvVPTwaQpKgyWXmjVM+NjaU8uapad467WMimESvUfPUlnokSaJrIkx5iZ4K68LNhOc6MRm5aLzifKI4FgThehKb9ARBuCmdnIrij2e5fZGVxH1DQWbiWR7urEZ9iShDQVY4Oh7mtmVl/OVDK3lyYy0alcSzhyf52xd7+MZb/Tx/bJKjYyFm4hmOjIUoyLCxoZSTnigui56nttQz6I/z473zxyIXYxZ2hmYSxGa7Z2xrcfHhtW76fPF5LeMuJl+QeeXEFDOxDKlsgVKLnv5QgXxBRi1JLCu3EEhkODAcJJLKcUdbOf/jweU83Fk1Vxyf+Vpf7PKQyOTZ3lrGn97fxlQkTSJbIJTM8nqPl398vY9sXuYPb2sCwKLXsLHhbJ5ZURSOjIVoLrMwk8iSyubZMzDDG6d8tJSZyeRlVlZb6XDbiKRyjASSdNbYLlrQXm68QhAE4UYRK8iCINyU3u2fwWHS0l49/1fy8UyeN09P01phoa2y5JLXOTUVJZbOs7mpFJVKYnWtnc4aG4P+BEP+OGPBJEfHwuwbCqIoCr3eGK4SHSc9UfYPB3CYtNyzsgKHWcuvjkzyvd3DPLWlHstsrGN1jY23Tvs4MRnhltk2dJsaS9GqJZ45PMH3d4/wuVsaMOouXBi+Nxjg4GgIl0XHw53VlFv1/E3vCN96Z5CZWIZsQaHMYqDTbcPtMLJ/OEhtqWlBN4jXe7wcGA7hMBVHQje4zBi0KmxGLW67kWcPT6DXqHiwo4pqu4HWSgtqSaLBeXbYyKA/QSiZ496VFTx/zEPfdAyXRcenNtfxm6OT+OIZ7pmdfueLplGU4sbGizkTr+hov/wR4YIgCNeTKJAFQbjpjAYSjAaSfGh11YLNbm+cnCabl3m4o+oCZ8+3b6hY5LaWny2mJUmipdwy15lBlhV8seIK7Ugggc2o4+XuKY6Oham2GfjnN/upLTWyusbG8fEI39o5wGe3NlBuNVBuNVBh1XNi4myBDLC2zoFWreLnB8f4wXsjfH5bw6Krp/F0ju/uGiRfkPn4hlrW1zt45tA4E3GFnaf9fGJzHbc0l/LzA+PUOU08ubHY5eGn+8fY1uLkgVWVaNQqTnujvNbjJVsocNfyStbXO3jjlI9QIotKAoNWw4fXuWgus3BkNMSP9hY7RTzQXjlv9ffwaPGDwq4+P3sHA7S7rfy3e9sYCSR44dgkFp2GaCrHLw6Oc9ITxaBVsavPT4PLTJPLjOOcFe0zuiaK8Yrll/GBRhAE4UYQBbIgCDedXX1+TDo168/rrDAVSXFgJMjWJiflVsMFzj7LH8sw6E9w36qKi3aVUKkkKmdbui2vtPIXDy3n8EiQRDrP7W1lpLIFuiYipHMyBVlmLJDkX3cO8tSWOlrKS1hdUxyVHEnm5vVqbnfbeJI6fnZgjB++N8LntjWg15wtkhVF4Wuv9uKNZvjS9mZubXHxg/dGGAkkWFeuQmM3c3uri1g6jz+e5WPLy7GbdHzxtiZe6fayZyDAWCDJujoHr5304otlWFFZwofXFTt0HBgOMB3LoChw9/JyPr6xFrVK4u7l5fR4ogz44mw8p/dxIp3ntZ7iBxCU4pjnp7bUk8jk+dsXeijICv/l7hYeX1vDKW+Uf3itj1qHgR5PlEOjIQDsJi2NLvPcP06zjm5PhNbKEhGvEAThfUMUyIIg3FT8sQynvDHubCtfUEy+1DWFUavm7hXll3WtA8NBVBILWpgtJp0r0DURZm2dHb1GzYA/Qb3LzBMbapEkCUVRmAileKV7itNTMXq9Mf7pjX4+vaWejhobr5+cpmsyvKDjRru7OHzk5wfH+fHeUT57SwNatQpFUfjp/jH2DgXY3lrGh9dW8+yRSQb9CR5dXUVoyM97CRUHhoPE0nmMWjUds5EKjVpV7MuswPf3DPP8cQ/VdgMVVgMfWV+LRa+hayLMnoEA6VyBNbUOntxUO7dSrFGrWF1rn9e5whdN8487+hgNJPnwumqWlZews9ePy6LnH3f04QkXh4Xcu6ISlUoiEM9SaTPwJ/e24TBp8UbTDM8kGJ5J0D8d4+hYcWS2WacmkS3Q2X7p7hWCIAg3iiiQBUFYEmOBJHlZpqnMct1eQ1EUdvb60KgktjbP705xpsvDo6urMeku/daWK8gcHg3R7rYtGAaymOPjYXIFhY0NpaRzBfqn42xuKp0rKiVJorbUxB/e1kSPJ8oLxyY5PBrmf7/ey0fX1eC2G+iaiCzakq6zxk5eVnj28AQ/2TfKU5vreO3kNM8dnaTGYeS/3t3C271+jo6Faauw8GLXFOZkgVUtNvYNBcgXFG5bVjZXWA/6E+w4Oc1YMMmaWjvJXB4JiU2NpaystuKNpPn6jj5imRwlBi0Pd1RdcBOdLCvsHphhx8lpBnxxNjc6+OM7Wvje7mFKzVp+cXCMXm8Uh1nH9tayuRXyrokwNQ7j3CbBKpuRKpuRW5pdKIqCP5aZK5gT2QLLq0S8QhCE9w9RIAuCcE2KRaufHaemAfi91dVsvkhrtWt5nZdPeDkyFua2Za65TXAw2+Whe4oKq57NjaUXucpZXRMRUrkCmy7z+IMjQf5/9t47Oo7Dvvf9zPZdLLahLnonwQL2IpKixKJu2ZbkolhykXsSx0neyXFOct+97977bl7sPOe8OMWxfC1LtixZlmR1q1CNpNgJAgRIkEQHFotdLLb3PvP+WBAiBBCEKDkxpfmcwwOe3dmZ2Zkh+J3ffH/fn92so9qi58xkmJwosbJqftVTEARWVZtZVlnMwQEvvzw6zkOHRqmy6Ck1avDH0pQY50eera+zIs6I5P/6fB+RZBatSsGXr6tnyBvnjfPTtFUYGfMXot4GJ0VMsTQTgQRqpZLNjTbGfAVhPOKLY9aruWtdNRvqreRFibOuMKuqzAx4ojx6bBxvNE1TaRFT4fQcG8WleKNpnj7lxBFIUGvVk8zmuaOjipwoMeKNE0llyeZFrAYNGpVydhS1L5ZmMpS6rA9cEIRZf/bv41qRkZGR+aDIAllGRuaqSWRyPHlygn5PjDU1ZjJ5kedOu4imcuxpL//QsmpzeZFnuibpnghRZzPMWgkucnjYTyCe5Ws7GpY8oe7EaICyYi1NSxhXPBlKMhlK8ck1VQiCQJ8rglGrpN5muOxn1EoFe9or2Nhg48f7h9jX56HPFabeZuDP9rQueGw2Ntg4OuLnue5J9GolO1pKqbLoefTYOA0lBoLxDEqFgj+5sYVfJVxMBhOM+uLYzXpe6nUx4IlRrFNx5xo7mxpssxnLSoXA+jorR4f9vNjrQhQlllWa8ESSWA1q6kvmH4Pz7gi/PuFArVRw76ZaJoIJJkNJ1tRaGPTEOOeOUGnSUqRVIaolinXq2RuGM84wwLzzJCMjI3OtIAtkGRmZq8IZTPD4cQeRVJZPrqlia5MNSYJnuyd588I00XSWT62pvqqRypeSzuV5/LiDAU+MlvIihqZjPHJkjL/Y20qxTk00leXtC9O024tpKV/aY3pXKIkjkOATHZe3FlxK51gAtVJgba2FbF6kfyrKmlrzkr6bWa/mb25rZ3tzKX/zzBl+eWycWCbPfVvq5gnTty9M4wqlWFVt5owzTCqb59cnJigp0qBXKxkPJHhgWwPWIg2ry1RoFUZePjtFOJmlzmbgzjVVbG0qmTPcJJcX8cbSnBwLcnTYz/LKYhLpHKFkhnPuMJsbbPO+x3l3hMeOj2M36/nSdfXo1Upe6nXRbjehVyt55PAo8XSOFVVluMIpkGBFlWm2ya7HGaKhxDCnIVFGRkbmWkIWyDIyMu8LSZI4MRrgpV43Rp2Kb+1spnamkioIcPf6aop1Kt7u9xJL5bh3c92Sp8W9l3g6xyNHxpgMJdnSaKNzPECN1cBUOMWz3ZN8cWs9+/o85ESR21YtLdYNCtVjtbJQVb0SmZxItyPEqmozeo2S8+4I6Zy4oL1iMXa2lfG3ty/nh/sG2N8/zbg/we7lZdy60o7ZoObAgJd95zysrjYx5otDjZnjYwHKi7V8bkMtBwe97F5egd2ixx1OcmAiy9m4B2uRmmxOIp7JsarahCOQYCqcwh1O4g6nmI6myOZEJoJJdi0r444OO/+4b4Bqi45MTpqXBHJhKsLjxx3YzXq+ur0RvUbJ2ckwsXSeDfUWnuqc4PxUlDU1FjyRNLUWA85QknV1hYY+TySFJ5LmzjVLPx8yMjIyf2jIAllGRmbJpHN5nj/totsRoq3CyOc31c5riBMEgZtXVlKsU/Nir4uHDo3ypevql9Q4dynBeIaHD48SSma5dUUlb/VPU2rU8tXtjZwaD/K7M25e65vilCPI9uZSyooXH2V8kVQ2z+mJEB01lkWHc1zkzGSYdE6cnSbX54qgVSmWZM14Lzvbytg/4CWXF/HHMuzr83B2Mkw4mWVwOkapUct0JMl4IIFaqSCczBKKZ/mfL52j1qZHEAT2D3iRJInxQJ6sSuKm9kqGpmMcG/bz5Z+fYLndhEqhoFinwm7W0VZRSjydJ533MeJL8I/7+kllRcLJLIJQmOx3kf6pKI8dc1Bp1s2KY4AuR5BinYoLU1E6x4OUFGlQKQW0KiUGrRKjVknrTPW+1xlGEGR7hYyMzLXNR2LUtCAIFkEQHhQE4SlBEIYFQXhdEIT1S/zsD2Y+I838/IEgCPI4JxmZ9+CNpvn3/cOcngixt72cr2xrmCN6c3lxzpjl65pL+MLmOiaDSR48MEI4kV3ytjyRFD85OEw0nePu9TUcHvahVSt4YFtBtG1vKaGx1MDPDo2iAHYvX1qsG0C3I0Q6Jy65ma9zLECZUUNDiQFRlDjvjrDCbkJ1FVXxYp2aZRXFVJn13NFhx2JQE07m8ETSrLSbuWVlJemciEWvodSo5Qub66gwa9Gqlayrs3JHh5319Rbi6RzhtEQsnSOUzNJUVkSVVY9aoUCvUvLd3S387e3tPLC9kVtX2dGqFZh0Km5ZWUHfZIRxf5wjw37KjNrZhsEBT5RfHRunwqSdI44jqSz9U1EUApwYDdJSVoR+Jprt+tYSRrxxVtdYUCoKUXdnnCGaSouWlAwiIyMj84fKNS+QZ8TsKeApSZI+K0lSMzACnBIEoekKnz0FfBPoAp4GbMD3gDd/v3stI/Mfx7g/ztFhPxOBBHlRuqp1nJ0M829vDxFN5XhgWwN72ivmeHfDySz//NYQP3ytn3F/fPb1VdVmHtjeQDiZ5ccHhvBEUlfc1pgvzoMHRkCCL21t4O0L02TyIl/d3jjraRUEgZV2M5FkFgTQqZf2q+yiPaTaoqPGqr/i8tORFGP+BBsbCnFuo/44iUyeFVWmJW1vITpqLAQSWXa0lHJHh50irYpPdNj5/j2r0aoUCIJAXYmBb+5sQqlQsKbGwrd2NhFL5zk7GabHEaKpzIhZK/CJ1Xb+/u7V/NdPrODWlZWsrjEDEo+fcMy5IRn3J6i1GqgvKWJZZTFbGm04gwkiqSyHBn2cd0d49Og45cVavrqjcU5lvdsRwhVKMRVJs7nRitWgZjKYoNyoIZTI4omkyOdFXjnj5omTE3hjmSuOlpaRkZH5Q+eaF8jA3wAjkiS9cfEFSZK+NfPXv77CZ9cDjTPC+rNAIwVxvV4QhM/8XvZWRuY/iEA8w2PHx/nJgRFe6HHx4/3D/I8X+/jfB0fY1zdF/1SUZCa/6DryosRLvS4eO+6gwqTju7tbaa2Y2wgXiGf46cFhIsksKqXATw+OcGTYhyQVxHhTmZFv3dAEEjx4YIRRX3yhTQGF5rCfHx7FqFXytR2NvHZuikA8wxe31lNxyWS8bF7k8LCPdXVW8nmJI8P+JR0TRyDBVCTF5saSJTXnnRwLolTA+hmfbp8rglop0Fpx9VnPq6pNKISCdWP38gr+6uY27ttSz1Qkxctnp0AqVMQD8QyOQIJ7NtTwhS11WAxqnj41SSonsrOtFK2yYGVRKwuienNjCZm8xK2r7ERTOR48OIw/liady+MKJakvMdA1HqRIq6Kj1ozVoGGF3cSvT4zzvad7AfjqjnefCuTyIocGvfz47SEGpgvXysBUjB/vH8EdTuGOpPjl0XFcocL0wiMzN2HNZUWyvUJGRuaa56PgQf4m8PcLvN418963FniPmeryP0iSFLr4miRJIUEQfgA8CGyiUFWWkbmmSGXz7O+f5vCQH4UAe9vLWVdnZTKYZDwQZ9yf4MCAF1HyIghQXqyloaSIuhIDDSVFWA1qBEEgnMzy6xMOxv0JtjWXcNuqynm2Am80zc8OjZDLS3z9+kZKirQ8dWqCF3vcOANJPr2uGo1Kgd2s59s3NPPw4VF+fmiUezfXzmtyOzUe4JmuSaoser64tZ4Xelw4Agn+aFPdvOEjhwZ9BBNZvnF9I0eG/bx6dorWcuMVx0sfHwmgVSlYU3tlAZfLi3Q7grTbTRi1KiRJos8VprWieM4Ev/eLQaOitdxIrzPMLSsrKTFqkSSJRw6P4Q4l+fymWirNOn57apIdLaWsrjbz8pkpQokM6+ssKASBV89OYVALLK9892ZlTa2Zl8+4cQaTfP36Rh4+PMZPD46we3k5ogTVVj1PdTpZVW2mZyKMVqXk3k01PHJ0nCKtklSukJhx+2o7VRY97wz5ePjQKBemojSUGNhQX0jwyORF1tdbuXdTHb85OcHe9nJuXWVHp1Z8aLF+MjIyMv/ZXNMCeUbkWihUfd9LJ4VKsOVSEXwRSZJGWLjCfHFdSytJycj8gSCKEp3jQV4/N0UsnWd9nYWbV1Zi1hdsCbYizcwj+EKz3UQgiWNGMJ+eCHF8NABAsU5FfYmBMV+cbF7ijzbXLvjI3B1O8vNDowB84/omKs0FcfrFrfW83T/NG+enmYqkuG9LHSVGLdYiDd++sZlfHBnnseOO2YEikiRxYMDLa30eWsqN3Lelltf6PPS5ItzZYZ/d54uEk1kODHhZWWWipbyYCpOOf3pjkKdOOfn2Dc0oLxO9Fk/nODMZZlOjbUkC95w7QjyTn23OcwaTRJI5Vq68envFRTpqLTzV6cQZTFJrM/B2/zQHBrysr7eye3k5Dx0apam0iJvay/nNyQl6nGG2t5Ry+6pKnu6apNsRotWqmBPPplUpWVdnoXMsyB0ddr65s4mHDo3y0KFR9BolsVSOdE5kXa2Z509PYtKreL7HTWt5MX/36dWcdYV58/w0//r2EB3VZo6PBnAGCxXhRx7YhEmv4fuvXKBIq+Kvbl6GM5TEpFdzw7LyJTU7ysjIyFxLCBcfg16LCIKwF3gduOlSi8XMe98DfgA0z4jhpa7zmxQqyBskSeq6zPvfBKioqNjwxBNPfIBv8P6JxWIYjb+/Ub4yf/gsdA24YiInp3IEUxLlRQKbK1WU6pfuoBIliVBaYjoh4UmITMdFdCqB66tVWHTz1+NN6oOtgwAAIABJREFUiLw+nkWlELilQY1ZO1+UOqMiB50FH+zOGjU1xYX1ZEWJAxM5nFGRNeVKsnk458/TaFawo1pFnz9PlyfPylIlmyrn3sNH0hLH3TncCZG7WjQUawrbHQvn2T+RY225krXlC9/3n/Xl6JzK86kWNdYFvtOlSJLEq2M54lmJe1oLFfXOqRx9/jz3LtegVX6wSmkmL/FEf4blViXLrAr+uTuNQoA/XqPhrYk8ogS3NKg46sozFRfZWKlkZYkSQRAQJQlHRMQqJDGb5l4HwZTI80NZNlaqWFWqJJKW+PeeFJk8rC5TkhPhxhoFP+zMoFXC+goVtzSo0akK3yedl+jx5nnHmWU8ImJUC9xUr2ZXnRpvQuSnvWlMWoHvrNXy3FAWrQpub9R8oGMhc/XI/x/IyNfAB2fXrl2nJEna+N7Xr+kKMoXq8YexzKV8C3h6IXEMIEnST4GfAmzcuFG68cYb3+fqPxj79+/nP3qbMr8fzk6GOTDg5Zs7m95XTvCl14A3muaVs27OB6LYa9R8bbWdlVWmD/SoW5IknjrlJJTI8Knrm+ata9QXZ/+RMVqblHx9RxPWossLpNvjGX51bJxzkRT2inJ2Ly9M19stSjzbPcmp8SCo4J7rS/hEh50uRwh3yMntWyx8dmMNglBIRhjxxTk85ONCMIrCAl/dbmdHa+mcbelPOuh1hmlZ00yNde6EO0mS6Nw3wLZyFXftbF70+8fTOZ7snEBhjnHv6sJ2JEni1OsDXF+j4ZYdje/ziC6Mp2gchz/O/nAalS7Kf7tzBYOeKJbyGH+0qY43L0yjtKT48z01rFsgr/lyvws8B4aJp3PccEMbkgRHYmcIxDPojVr2LC9nzB8nIQ6yubWM//vujjkjuwF2ZvIM/rqLsBhleaWJr92xglqbnn/fP4zW4Obz1zXQ2lKCITjMXeuqlzyqW+bDR/7/QEa+Bn5/XOsCebHfzKH3/LwiM9Vhy0zDnozM75XTEyGcwSTn3ZH33fWfzOR584KHo8N+1EoFt66qZFtzyVUP5LiU7okQ3Y7CPxt3OEWV5d20h0FPlEePjWM1aPjqjsZZ+8blsBVp+PYNzTx3epI3zk/jDCb53MZa9Bol96yvptKkQ6kQ2NpkY3A6xjNdTprLirh7fTV5UaLHGeLIkA9XOEWRRsmuZeVsabJhWiBC7JNrqhnxxXmq08l3drfMORbD3hj+eIa9KyoW3V+HP8HjJxzE0znuWlfNpoaCMPVE0vhiGXa0lC76+SshihL+eAZ3OEkik+PQkI9kJs/e9goSmRz9nhg3tJXy0hk3yUyeB7Y3LHk64EW2NNp4stPJsDeGQaNCEAS+vK2BaCqL3azj/93Xj06j5Lt72uaJY4D9A9M4Q0luW2XnL29qRadW0e0Ics4dwW7RsaLKxOmJECqFIDfjycjIfGT5TxXIMxFtb/L+qryfvaS6G1hkOcsSlrl0X9ZT8CRveB/7IiNzVUiSNJvm0O0ILVkgi6LEeX+ed/b1k8zm2dRgZW97xYeWORuMZ3jhtIsaq56pcIpT48FZgdznCvPEiQnKi7U8sKNxQXG1EBqVgs9uqKHWauClXhf/9vYQ922tw27Wz1aBL46trjDpuGtdNQcGvBwfDRBN5agwabl7fTVray2L3gAURHcNDx8eY1+fh93Ly/HF0nhjaY6PBCjSKFl1mXg2SSokYbx8xo3FoOarOxp5tstJJieyo7WUPldh+MX7iXdLZfMzE+1STEWSuEIppiMpMnlpdpvRVI4ijZLdy8t5sddNfYmBk6MBlEoF39jZRLXlylF072VVtZmXet0cHw3QODPMZGWViWAiy88ODpNI51heUbzgoJNEJsdTnU6KtCru21KPTq0incvzat8UGmUhS7mhxMALPS6WVRbL3mMZGZmPLP+pAnmmee6DCNKL3uKF8o5LLtnGoswI9acoeJmXXHGWkbla3OEUiUweW5GaAU+UaCp7RZErSRK/PunguDvHjjU67uiwYze/fwF1OURR4qlTEwD80eY6Xuub4vREiNtWVdLnivBk5wQ1VgNf2dbwvoWRIAhc11xClUXH48cd/Pv+wuP5dXVWAvEMvzgyhiRJ2Io0/NMbg+REiWUVRnZsLKW5zHhZy4goSoSSWbzRNN5oGl8sTSKT41/fHuSVs+7ZY6oQ4I4O+4LDPVLZPL/tcnJ2MsKKKhOfWV/D4SEf3liGoyM+treU0OeKUG8zXPEcdY4FOO+OMBVJEYi/m0OsVyuxm3VsarRhN+uoNOuxGtR8/RedqBQCr5/3oFYKOAMJrEUaHtjeiG0R68piqJUKNtZbOTTkI50VMevV5ESJXxwZIy9BsV7N6hrLnAa/i7x6doqJQILPbaylrqRgUznQ7yWSzFFh0mHUqZgMpYimcrOjpWVkZGQ+ilzrFouLAnkhkd3EEmLaLqlif/b9NPPJyHwQRryF6vGn1lbz8OExemdSChZj3zkPZycjbKgoZAR/2JFah4Z8jPoSfGZDNbYiDevrrPQ6wzzTPcnpiRCNJUV88bp6dOqrrxrWlxTxnd0t/PqEgyc7nQxOx+h2BBnxxrGb9Qx4omyot7KtpYTy4oUj205PhDjniswK4twlw08MGiWtFUZiqRwAn99YQ7XVgK1Is2C6hSuU5NcnHATiGW5fXcmOllIiqRzvDHop1qkIxLP0OkO4wynuWG1f9LtNR1L8tmsSq0FNrc3AxnodlWYdVWY9Jr1q3vk6OxnGpFejEAQ8kRR6tZKmMiNf3taw5Or85djUaOPgoJcTYwFubCvjrQvTiJJEW0Ux3RMh1i4Qc3fRe11q1PC5TbVA4YnCO4M+VlWZOOeOsLbOwumJIHq1kmUV78/6ISMjI3MtcU0L5Jnc4i5g7wJv7wW+cekLgiA0LSCC3wT++nJNeTIyvw9GfDFKjRraKoqptujodgQXFchdjiD7+71sbrRiCfk+dHHsDifZd26KlVUm1s80hLWWG4kmszx5coJPdNi5b2v9h+JxLtap+dqOJl456+bnh8aIprJsaLBy68pKNjfa5oyvfi9djiBPdTqxGNTYzTraKoyUFmspM2opK9ZSNCMsx/1xHjw4wrA3TrXVwIs9Lsx6NdtbStGoFIWmu/Egz592YdAq+cb1TTTMWA7eOOchL0l8ZVsD/75/mNf6PEDBprAYPc6CDeOPb2xekuXl7GQYu0lLJi8STuboqLFw7+baD5SxfJFSo5Zqi57TE2FMehWHhvxsby7hQL8Xk049a724lCc7J/BFM/zpruZZb/nLZ90oBGirKOasK0KtVc/hIR/r66xXNWpbRkZG5lrhmhbIM/w18LogCN+TJOkfYDbirVOSpNkK8swAkO8JgvDXlyz3OgWv8rcEQbg4UOTic0Mb8A1ZOH88yeVFlArh9zL4QBQlRrzx2WEV6+qsvNTrxhNJzZkWd5Fxf5xnuyZpLivik2uqeefg0Ie6P9m8yG9OTmDQqLhrXfXsdz4w6CWUzKIQBD61tupDEccXUSoE1tdZecXs5lNrqrj/uvrL5hdfZGg6ym9PFZr4vrKtYVGBVl9SxIY6K0+dmuDNCx5KirTkRInjowFuWlHOiDdOlyNES7mRz2+qna3YusNJTjmCbG8upcqiZ7m9mOe6XexoKVk0rUOSJHqdIZpKiy4rjvOixHQ0hSuUYiKQ4DedE4VR2QhsabRx/5Y6lB/iMbabdWRyIl3jQVQKgbaKYn5zcgKLQT0v5SOSzPJc9yQ1Nj2fWFNFOJHlzQuFJxY3r6jAHUmhVgrEM3myeUm2V8jIyHzkueYFsiRJbwiCsAH4gSAIn6dguxiRJOmm9yx6kkKiRReAIAgP8m7leSEPMyyekiHzEeW8O8Ivj46jUggYtEqMGhUGrYoijRKDVoVRq8SgUWHUqjBolBRpVRRpVRjUygV9ne9lMpQknRNpKi1kV66ptfDyGTfdjiC3rpr7GD8Qz/Do0XEsBjVf2FJ3RRF5Nezr8+CJpPnKtobZCuyhQR/7+jzc2FbGsDdGnyvKjlbth7rdI8N+yop1fG5T7RW/lzuc5FfHHJQX67h/a/2i4jiezrG/30uXI0gykyetFfmz3S3E0jmePDnB//XCOdQKgc9vruVzG2pnz5kkSbx8ZgqdqtA0B9BSbiQQz1zRDzwZSuKLZdjZVgYUBrFMhQti2B1OFhr1wqlZO4grlMQZSFBrM7C1qYRgIsOLvW4+tbbqQ7spExBQKwW6HSG+uqMJZyhJNJ2jo8Y8zybz88OjxNN5/nRXLa/1TXF8pNDbvL2lhOtbS/mXt4ZoLC2i1xnGVqSmzmZYaJMyMjIyHxmueYEMMFPlfa8gfu8yT3OJJ1mSpG9xmTHUMh9v3hn0YtarWVtrJpbOk8jkiKfzBOMZ4pkcqay44Of0aiX3bKieN0L5vYzMpFc0lRUecxu1Ktoqijk9EebmFZWzgi2VzfPLo2OIEnzpuoZFrQeL0e0IMuyNc8/66nnia2g6xqEhH1ubbCybGVucyhYi5JZVFPywP94/zKnxINtbSj408RZNZemZCLGxwXrFhr9wIssjR8bQqhV8ZVvDZT3QqWyew0M+3hn0FcYh11n54tZ6fnV8nNfPe1hdbSaZzdNQYkCnUtDrDKNWKLh5ZSEFZHA6xtB0jE902Gf3KZuTUCkE0rmFz/lFep1hBCTGfHHeGfDii2e4OIPJoCk06G1rLqHSpGPYG2PQE6HWZuBfvrCOKrOe1/o8HBjwolAI3Nlh/1COsyOYwKxTE0xmWF1t4uUzUwC0vsc7PB1J8cqZKSwGNYeG/ORFifV1Vva0l2MxaAgnskxH07TbTRwc9LJ7Wbk8UlpGRuYjz0dCIMvIfFi4w0lGfQluW1U5Ww18L7m8SCKbJ54uCOeLArrLEeRXxxzsWlbG3vaKy1aTR7wxyou1cx7Fr6uzcOHEBCO+OC3lRkRR4okTDrzRNA9sb6Ss+Oqqt5Ik8daFaXyxDPUlhtmxyVDIUn7q1ARlRg23XVK5PjkWIJUV2dNegSAIbKi38vxpF65w6qpixxbi+EiAnChdsTExmcnz8JFR0lmRb9/QjNkw376QzYucGA2wv3+aWDrPyioTN6+ooHzGrrKnvYLnuifpGg/RWmHk/7hpGVq1grcuTHNk2MeZyTA3LCujezxISZGGLZcMvrgwFaG+xMBEIEE6l1/QHyxJEqcnQoQSWbonQrRXFrOm1oLdrKfa8m6DXjiZ5TcnHQxNx9GoCjnQ1ZZCJfaWlRXkRYlDQz6UgsDtqys/kAhNZvI4AglUSoHyYh2nHEH6PVGMWhUNJe/6j9O5PH/77BmmIimaSm2ssJvY014x53ob8kaBwg2IJMFa2V4hIyPzMUAWyDIyl3BsxI9aKbCxYf7ksouolApMSsW8YRUbG6y8cNrF2/1eJkNJ7t1UN686mhclxv2JeR7OdrsJrUpBlyNIS7mR351x0++Jcde6alrKr36MqCOQwBfLoFcreeXMFO1206zf9vnTk8RSOb54YzMaVcGykMuLHBry0VxWRO3MY/Q1NRZ+1+vm1HjwQxHI2bzI8VE/7fZiSo2XF/65vMivjo3ji6X5yrZGKs1z/dmiKNHlCPLG+WnCySzNZUV8aWXl7H5fZH2thZ8eGKZYp+ae9TWzIvv21XY2N9p4+YybXx0bZyqc4ls7m2ftHolMjlFfnB2tpZx3RznvjrK2dr44HPbGODUjru9eV83GhvnOrAtTEZ7qdJIXJTbUWwoe7Pp3lxNmRLEozYhkBdyy8upFsiOQwBVKUmHSUWnS8vChMSpMOmxFGupLDLM3Fc92T3JyLEhrhZH/9smVC8YGDk3HMGqVjPvj1Nr0i54zGRkZmY8KchuyjMwMiUyObkeINTWWq7IzqJUK7l5fzV3rqhn2xvjXtwdxh5NzlnEGE6RzIs1lxnmfXV1t5pwrwqFBL0eG/exoKf3AY3y7HEE0SoEHtjeQyed55YwbgJ6JED3OMHvbK+Y0bPU4Q0SSuTnVc71GyYoqEz0TIXL5xa0GS6HXGSKWzrOt+fLVY0mS+G2XkxFfnHvW18y5SZAkibOTYf7pzUF+2zVJsU7F13Y08vXrm+aJY4BDQ36ayozUWA08fHiUcOLdfOJSo5bPbazFZtBgMag5MuzjoUOjeCIpzrsjiBLsWlaGWa+mZ2J+RLooSvz04AiRZJb7t9bNE8e5vMjLZ9z84sg4Zr2aP93VQiYnYtIXBm5ciiAIfKLDztYmGwcGfLx+zrPkY/pezkyG8EXTlBo1OIMpREmi1Kih0qRjwBPjH/cN8FKvi353hBKjhh99fu2C4liSJIamY5QWa5mKpFlXe/kbRxkZGZmPEnIFWUZmhlPjQbJ5iW0tJVe9DkEQ2Nxoo9Kk47ET4/xk/zB3r69hzUzl8WL+8UIxW+vrrbx1wcOjx8bZ1lzKbasqr3o/oFCp7ZkIs7LaTK3NwPWtZezv99JWUcxzpyepsxm44RIhLEkSBwd82M06Wt9Ttd5QX8hEvjAVZdUHGC8sSRKHh/xUmnQ0l80/Bhd5rc9T8GSvrGBdnZVsXmTUF2fQE6N/KoI3lqG8WMt9W+pYWWW6bKU1mspyfNTPyioTO1rK+PnhUX52aIRv7GyafQLwzqAPlVLB3316Na5wkjfOTfOjNwcp1qow6wuJD2trzbwz6COezs02MoqixBMnJ+h1htnZVsbOtvI52w7EM/z6hANnMMnWJhu3r7aTFyUGPDG2NNkW3GdBEPjkmiryosTb/V6UCoE97YuPx16I1895SGTzhJM5blxWxjmXFmcoyVQkRSSVo85moKWsiM6xILeurKTaunDT3VQkRSydx6wXUQjQUSOPlpaRkfl4IFeQZWQoiJ1jI34aSw1YDRo6xwIfqFpaV2LgO7taqLbqeeLkBL/rdSOKEsPeGHazblZkXYpBo2AimCSVzfP5TbVLSsRYjHOuCOmcOJtrvGtZOVaDmh/u6ycvSnxuY82cbVyYijIdTbOzrWyeeGspM2LSq+hyBD/QPg1747jDqUUb/o6N+DkwMM3yymKUAjx0aJT/+eI5Hj48xrERP0admrvWVfPne1pZVW1e1IZwoN+LM5jk9ESIE2MBHtjeQDSV46F3Romlc4QTWd4Z9LKmxkxDaRHbmkv5q1va2NJoI5bOsba2sP41tRZEqdCMBwWh/3SXk0NDXipNOu5ZXzNnu2cnw/zLW4P4Ymnu21LHp9ZWo1YqOOeOkBMlOqov7+MVBIG71lWzod7KG+enebt/esnHV5Ik3jjn5uiwH4UgYDGoGfLGGPHFGfHGKTFq+dJ19XxtRwOvnZtCrykMnbkcQ9MxkCR8sTTLKosXvG5lZGRkPorIv+1kZIB+T5RAPMstKyt5+8I0Bwd9jPjifHZDzVX7QC8OxPjdGTeHhnw4AwnGAvEFG9MSmRyPHnVQYdJi0qlJ58QPNLEOCvYKs149W6nVqBTUWg281ufh+tZSSt7jJT044MVqUNOxQIVYoRBYV2vhnUHfksZiX44jwz6MWuVsRf1S4ukcr5/z8MTJCZQKkKSCaC8v1rKlyUZbRTH1NgM/PTjCiDd2RfvJoCfKQ4dG0agUtFYY6XYE2bO8nC9dV88jR8Z4+NAopUYtkgQ3r3y3Wm/QqPjkmirsZj1NpYXKaqVJR4VJS48zxNYmG892T9LtCM3mVrdVFCru2bzI73rdHB8NUGvTc++mujkRcb0TISwGNbW2xb3cgiBw97pqRFFiX58HpSDMaxqVJIlgPMNkKFn4E0xwdNhPlyNEOifSWGKgSKOi2qJnU72Nfk+U+7fUYTZoeLHHxagvwWc31My7Di5laDqGSimQzkkL+q9lZGRkPqrIAllGBjg67MekV9FcZuSZrklMOhXdjhAWvXqOeHq/KBWFR+Y1Vj2/PDJGvyfGzSvmri+XF3nsmINwMsuf3NjCk51OeiZCC6ZoHB328/RAhmnjBC3lRprLjLNTzy4lnMwyOB3jxkuqwVPhFOfcEVZWFTMRSM7J9x33xxnzJ7hzjf2ylev1dVYODPjomQizo3Xx9ImF8MXSXJiKsntZ+ezQEXc4yRlnmMHpGP2eKOddEUx6NbevqmJFlYnW8uI5yRXj/jiucAp3JMXeWHrBhrFsXuTN8x4eO+Ygmc3zlze1sqbGyj+8doFDQz7uXFPF/Vvr+cn+Yd447+GrOxrniNhAPMNvTxX8z1VmHX+yqwWlolBFfu3sFL8+4eDMZISdraUcHw2wqtqMSqnA4U/wTLcTTyTNztZSbl5ZOSffOZnJMzgdY0dL6ZJuuhQKgc9sqEGUJF45O4VSIXBdUwnn3BFOjgU4diHDvmD/7Hf2RFIkMnmMWiW1JXr+6d51c8Tv3hUFq0Y4meXJzglKijTcu6nustu/aGsRJdCqFLTbF58kKCMjI/NRQhbIMh97vNE0g9MxblpRTpcjiDucoliroqPGzNv9XqxFmjnxaFfD+jorg54YA54Y+/qmKNap2NhgQ5Iknj/tYsQX53Mba1hXZ+XoiJ9ux3yBHEpkePWsG0GA/qko3Y5C01h5sZaWciMt5UYaS4vQqZWcngghSYUpfVAQ4U92TqBTK/jjG9v56cERXjg9yZe3NSAIAgcHvBg0SjbUX74Jq9yko9amp3M8cFWZyEeG/SgFgS1NNtzhJG+cn+acK4JCgJIiDalMnq1NJfzVzW2YDQsP5jg1Xmg6FCU4POTjU2ur57w/7I3xXPck7nChMe3+rfWz3uC1tRY6xwLsaS+ntdxIiVHLOXcEZzBBJieiVgocHw3w6tlCXvDWJhvHRgIcHPSya1k5a6rN/OzgCO5wins31VJj1XNwUGRZpZFnupycHCtU7L+yrWE2U/pS+lxhRAlWvw8fr0Ih8LmNtaRyeX72zihPnpzAoFVhNaipNyvZs7aKZDbPgQEvRm3hZunosJ81tZbLVoafOeXEE07xwPbGBWPzLnLeHSGdFUlm89zQVvahTlKUkZGR+UNHFsgyH3uOjvhRzYw+/te3hgglCpVVk15NW4WR57onMevVtFXMFz3vh3Ayw00rKjDp1fy2axJnMInZoKZzPMiuZWWzYnZdrZUXely4w8k5yQIv9RYSKG6pV3PHTe24wymGpmMMe2OcHAtwZNiPQoAaq55zrgh2sx7rjAB6/ZwHdzjFl7fVU2XRc9OKCl7qddPnilBerOWcO8qe5eUL5vxeyoY6K89dRSZyMpOnazxIY6mBl3rd9DrDaFUK9raX01Fj5pdHx6m1GWayjhcWx+lcnl5nmNU1hUf9p8aD3LSiAoNGRTKT5+Uzbjpn4tZW2E1oVApuuaT6v7OtjC5HiGMjfqosemLpHPdvreOcO8pPDw6jVioY8ydoKTdyz/pqLAYNiUyet85Ps6KymO6JEPFMHrtZzS0rK3j8hINYKsuzXZOkcyI7W0vZ3X75Y3hxCt37OW7+WJojw35GvHGiqSzBRIZ7N9XyuY217D/gJhDPcHCw0Fh526pKHj48SpFWOWv5eC8Of4JX+6aosuq5vcO+4DJQOF8v9bpRKQX0glIeLS0jI/OxQxbI1xBPnpyg35kldXYKk16FSafGrFdj0qkp1qk+cFPXx5FUtiDcVlebGfXF6XMVYq8aSgycngjxF3taefTYOI8fd/DNnU1UXWUOcCYn4ggk2N5cyi0rK9l3booDAz4AVlebuWnFu0kFa2rN/O6Mi67xEHd0FLbXPxWlzxXh1lWVSC4fgiBQZdFTZdGzs62MXL6w/qHpGKccQc5PRUlk8/yv352n1mZg2BtjS6ON5ZWFx+TXNZXQNR7kxV4XjSVFqJUCW5uvnN7RUWPhpavIRH7zvIfz7gjBRAarQcOuZWVc31qGUiHw0KFRwsksX9ux+ECUvpmmww31VgwaJafGgxybGVf9Yq+LeDrHDW2lbGkq4f97fYC1NZY566sw6Wi3F3N40Ideo6LUqOHzG2t54uQEjx4bx2rQ8Bd729h6ScLEnWuqGJqO8YPX+tEqFexoKcUXS9M5FuSZrkl0aiWrqs18el31rB95IWLpHMPeGNe3zm2AzOZF3r4wTbvdNBtRJ0kSo744h4f9nHcXKuwd1Ra+uqOB/Re89DjD2C16XhnNogr6ZhMyXuxxkclJ2Iq0NCyQkiJJEk+cdBBNZbl3c+2C1pyLvHzGTTydo8yoJZUTF0xdkZGRkfkoIwvka4hIKstUXOKdQS+iNPc9QYBirQqTXo1JN/NTr56tfBrl7vMF6Z5paNraZOMXR8aJprLct6WODQ1W/vnNIXomw3xpWwM/OTDMI0fG+OMbmrEWLVzhXAxHIE5ehKYyIwqFwK2r7NRYDQxOR7ljddUc0WTQqFhWaaLHGeK2VZXkJYkXeiYpL9ayrtbM/lFp3vpVSgVNZUaayowks3kiyRyf2VCNM5hkeDqG3aTjttXvVlMVCoFPr6vmR28Ocs4V5jMbapd0jVyaiXz7qkpUV3jsHohneOO8h0cOj6HXKLltVSXXt5ZRpFWRFyUePz7ORDDBFzbXUV+yuAjrmqkON5QYEASBWquehw6PUmM1UGcz8JVtDVRZ9Lxyxk1OlNi1vHzeOq5vLeNAvxeAb1zfxC+PORiajrGlsYREJseIr3AjcfF0GLUq7GYd+/u97G0v54Ht9fz5Ez383cvnSeVEvrajkdtXX3k0dN9kwV5xaUyaJEn85uQEL/a4qLbo+cKWOhQKgcODPlzhFAaNkhvbytjSVDIrZu/bauDRo+O8enaKUFrizzbX0lFjIRjPcGo8SI1NjyeSpn6BPOguR5BT40HqS4rYu0h03NB0jM7xIBvrrXQ5gvNEvYyMjMzHAVk1XUN8/fom9ucd3HDDKmLpHJFUjkgyW/hz8e+pLP54hlFfgmQ2D0CRRsmn11V/oPzaPwQkSWIqkqLSpPtQ/sOWJImjI35qrHqSWZETYwGay43ctLICrUpJc1kRR2cGdnzlEpH87Rua503IuxLD3jg/I36SAAAgAElEQVQKAeovGQ6xqtp82XOyrtbCOVeEIW8Mhz/BRCDJcnsxP9w3gGMiQ8Lq4LZV9nke0lxepNcZpqPGzIZ6GxvqL79PtTYDxVoVp8NpWsuXbh+5XCayO5xEKQiUm3SEE1ne6vfQORYkGM9gLVLzl3vbZgdp5GdGab9xfprmsiLOuSOM+ePoVEr0GiU6tRK9WolOrUCvUZLK5hnwRLl1xjJxdNjPgCfKdCTN7uXlPLCtEYVCIJbOcWzEP696fBG7SUsklSWZKQxNERQCn15bxeZGG0eG/bzU6+ZphZPPbChE4B0c8DLsjbG62sREIM6P3hwilc2TzOS5vq10SeIY4MxkmDKjBvsl0wD39RUa/ow6FaO+OP/nc2cpM2pZX2/hrnXVrKuzzPP9qpUKvnhdPUeH/YSMPjpm7Cb7B6ZRCAIlRRqiqdy8757M5Hm2u2AFuXON/bIpJJmcyLPdToxaFSPeGErF4lMlZWRkZD6qyAL5GkQQBIp1aop1i/sZM7lCZ/sLPS4eO+5gTY2ZT66tuqopcX8InBoP8tuuSW5cVjbHW3q1DHtjeKNpPruxhkePjpHNFyqCFz2k21tK+eXRcc5OhllTa+H+rfU8fHiUXx0b54HtDVesnl7KiDdOjdWw5Oi25ZXFaFUKHjs2To8zjEapwFakYX2dFXNqinPuCOfdEW6YsSpcFFIXpqIkMvnZ7OPFSGbyZPMidrOOt/sLucNLselcmom8qtpMIpPjtb4pTo4FMWpVrKwy0TkWREJic6ONUV+cXF6a3SdRlPj1CQcvnHZRpFVh1BYEYjKTJ51bOHt6MpjAFUohSnBw0Ec6J7Kq2ozdrCeays1WfN8Z8JK9TPUY4JWzHmKpHPFMHqVS4Du7W2cTLLa3lJLJi+zr86BSClSadLxydoqmUiOZXJ7ne1zEMyJf3lbHj94cpsZiWJI4jqayjPji7FpWPrv8ydEAP3pzCINGgVIQiKSytFUUIwgCtiINHTXmyzbFqZUKdraVsd9VWFcwnqFzLMiWphIGPdHZCvtFJEniqVMTDHpitJQXzRtocilvnvfgDqXQqRVkVUq+ur1RHi0tIyPzseTaVEoyS0KjUsw2Ph0c8PLmBQ8jvjifXlvNiqprK7Ipns7xytkp1EqB/f1e6myGDxw7dXTYj1GrRKsSODEaYHOTjdWXVESXVxZTZtRwaMhHR42Z5jIj96yv4clOJ890TfLZjUvLSE5l8ziDiQVj2xYiEM9wYtTPiDfGeXeESrOeb+5uZEdLGTq1kv3hQdZsauPls25ePzdN51iQ21fbWVllotsRpFinmjcJbyFOjAXIS/Dl6xp488I0J8YCbG0qIZ7O0eMM4YmkEEWQAFGSkCQJUSrkE0eTOV4Ym2TQE2VwOkY2L2HSqXAGkwRiaba3lrJrWTnRVI5jIwHu7CjEx4mixK+Oj/NM1yQWg5oHtjdwfeu7sWeiKJHK5UnNpCckM3mSmRw/PzxGnc3AzrYyUjmROpuBNTVmuhwhnj7lZHA6RpVFf9nqsSRJHBjw8uDBYaxFGtrtWqwG9WwT40V2LSsnmxN5qdeNP56mwVbEmD+OWqngC5vruDAVxRPJoBAKx2QpnJ2MIF1irzjnivA/XupDqxLY0lRCOJmlyqxjS1MJNVYDL/W6+MmBYb50XcOc+LmLZPMiL5x20T2eZeTQKD3OEBOBBMU6FYeH/DSXFTEdTZMTJfKixJgvzpi/cIO2t73yslYaZzDBvnMeQokMTWVGHtjeMGcMuYyMjMzHCVkgfwxQKgR2LS9nub2YpzqdPHpsnHV1Fu7sqHrfVoH/LF7rmyKVzfPHNzbzXPckT3U6+c7ulgUFxFIIxDOcn4pyY1sZPzs4ikIh8Cc3tMwRvIIgcF1zKS/0uHAEEtSXFLGuzkoomWVfnwezQb2kSva4P4EoQXPZ5UWrJBVGEB8f9XNhKooA1NkMjPkT3LWumr3tc7djLdJw35Z6hr0xXupx89hxB9UWHcPeODevqLhiJTibFzk85KOl3Mie9nJGfXF+fcLB2ckwY/6CX9qoVaJQCAgIKARQCIWfgiAgIeEMpvDHM9TZilhXV4xCEEhm89y22j47HvnVs1NoVQrW11sRRYlHj43zVOcE5SYtf76nbd7AEIVCwKBRcWmQxdB0DJ1ayWc31s5bfk2NmX19U7wz6KPaoiMrSty4fO6NiDea5sUeF6/1TVGkUfF3n15VyDrummTYG6PlPfaSPcvLCwI5lqHKrGdDvZXbO+wUa1X8/PAYr5xxYzfpmAgmyebFK8afnZkMUV6spcKkY9AT5b88ewYBgS9f18CRkQAWgxq9RsWJUT83r6ykrFjL48cd/NvbQ9y3pY6m91w3vc4QneNBUlmJYCIzc20akGbyipvLjJSbtCgVCqYjKWLpHJsbbexZXs62BYbUQMHy8sjhMYamY2xqsPLNnU2LNh3KyMjIfNSRBfLHCLtZz5/c2Mzb/V72908z7I1x97qaOZmtkiRxbCTA8sriq2pG+33g8Cc4ORbk+tZSaqwGvrClnn99a4jHjo3z7Rubryqf9fiIH4GCIDvjinDzigqqrPPtKuvrLbx+zsOhId9sE9mNbWWEEhn293uxGjSzE91EUVpQmI54Y6gUwhz/8UUSmRynxoMcHwngj2co1qnYtayctTUWHjo8gt2sIy9efuR1c5mRP9vdwomxAL84MsbgdIx1dRYSmdyiVprTEyGiqRy7lhfz8pkpxvxxzrkiBOMZPr+pjvX1ljkRcxdJZvK8ft6DN5am1magqczA39+1GoVCgSRJfP+VC0xH0wCEE1nOTIbZ1lyKVqXgoUOj/LbLSbVFz9/c3r7oDcOlnBoPoFcrF3zqoVIq2Npcwsu9bs67wmxqtFFeXBB2qWye/f3THBrykcqKFGlVfG5jDU1lRupsIvvOeTgw4JsnkE+OBynSKrlvax3XNZXSckk1fm97Ob856aDcpCWdy9P/Hh/2ewkns4z5E+xZXk7/VIT/9kIfWVHkb25dzlv9XkRRJJrKksmJ9DjD/K+XznH/1nq+ubORx09M8NChUT65pootTe8mjJwYDVJm1LDOqiZkKSKUyPJXNy/j0JCPRKZwE6lSKvDH0vzb28Nc11TCt25oRqO6/L+TpzonODjoZW2thT/d1bLodD0ZGRmZjwOyQP6YoVIquGlFBe32Yp4+5eSRI2NsrLdyR4cdnVrJRCDJCz0uXCEr92yo+c/eXURR4vnTk5j0KnbP+EptRRo+u7GGXx4d58UeF3evf3/7mcmJnBwL0lZh5MmTE+jVSh7Y3rjgslqVks2NNg4OemcnzwmCwKfWVBNOZHn+9CTFOhXD3hinxoPcu6lu3pCIEV+cWpt+npA/Oxnmyc4JsnmJhhIDN62oYGWVCZVSwatn3YSTOT69toreyQihRAbLZfKBFQqBrU0lHBnyoVQI9E9F+eFrA+xdUc7WxpJ5oj2SzPL4cQfTkRTPd7tQKQXa7SZayo30T0VZVlk8TxxLkkT3RIhXz04RS+fY0mjj1pUVvHLWgyucosZa8L02lxsZmIrONkBKwHVNNn5yYIRnu500lRXx3+9cRaV5adXJZCZPnyvChnrrZW+EtjTa+MWRMVLZPN9bXj5nX6OpHC3lRoLxDBa9mhuXFa4hlVLB9pZSXj07hSuUnI3vi6ayvNY3RXOZkfu31M+z0EwEktRYDWiUCuLpHKcnQosK5LOTYSSpYHf6/isXSKTzfHd3KxPBJNFUFkEQ6KixcNuqSv5xXz89zjCPHx+nSKtmRVUxCgGeO+1iKpLiEx1VeKNpHIEEd6y2Exp1cWo8yKYGG2aDmvFAnBqrHpVSQSYn8thxBwD3ba1fVByfGPXz8OFRaix6/svtKxYdHiIjIyPzcUEejfQxpcZq4Du7WrihrYxTjiA/enOQoekYJ8YCQCFzNpe/fOXyP4pjI35c4RR3dlTNaXBrt5vYtayMk2NBOmf2ean0OkMks3kyWZExf5xbZx5rX47rmksQgCPDvtnXFAqBP9pSR1mxhv/+Qh/Pn55keDrGI0dG6XYEZ5dLZvJMhpLzqqXRVJZnuiapMOn47p4WvnVDM2tqLaiUhcfi7wz62FBv5ZZVhWEO3ROhRb+TO5zEG8vwhS11fHdPK1UWHS/2uPnntwrnNZcX6XOFefToGH/92156nWGayox8cm0Vf3t7O/dvref+rfWUGrU8f3qS7CXn3hNJ8b/fGeGpTidmvZo/3dXCp9ZWs6mhBJVCoMvx7r61lBuJZ/I4/AlOjAZYYS/m0WPj/LbLybKKYr5/V8eSxTEUzlU2Ly064U+UZvzAUmGwxk8OFPZVo1TQUFLIgI6lc3x6XfWca2hLow2tSsHBAe/sa6+cmSKXl/hEh50HD47wdv/0nG31OEOsrTHTbjcRSeU4Mxkmmckvsv9hJEni8eMOAoksn99US53NQI8zXEjqmIm+sxg0fHNnMyvsJjY22GirMNIzEcYTThFLZXn+tIsHDwxzaMhbGGpTb6HXl0dA4Ma2cjI5kclgkvqSIiRJ4tluJ1ORFPdurl3UhtQ3Geb7r1ygSKvi/7m7QxbHMjIyMjPIFeSPMSqlgltXVbLCbuLpUxM8eHCYqXCK1dVmgoksw974giNz/6OIpLLsO+ehrcLIygUer+9tr8ARSPBCj2t2aMaVkCSJI8N+ijRKjo74KSnS8ql1VYt+xqxX01FjpnMsyN72ilmRlcmJiCJEUzni6RzNZUbUSgVPdjpJZvJsaynl/2fvvIPbus90/aB3EoW9d0pU79USZcuy3GLHjp3ESZy2jr3p28vs7uy9O3fr7G42xemJHTtx75btWJJN9UpRoihK7AUAQQIgei/n3D9AQqJYJMXbEuOZ0ZADgAcHBwfC9/vO+73vkDuMKDJLR/pmp4NkWuCBtRVZScD0/r12dgyVXMbupZmBqhqLlo5RH61N8/vRnhnxIZPCigojOpWcL26tpdsR4K3zDn56eAiVXEo8JUwNJUq5qbGAv7mrZUZ3WSGTcs/KMn52ZJiDvS62NBTw3iUnR/rdqBUyPrqqnHU1puw+aJQyllzliTy9EHjnwjiRRJLusQAnhrysrMzn7+5ZivYG/bjbR70U56kWdGs53OfCqFFgj8f4+7cuUV+oo8yoZiIQwx9NclNDAdubC2dJTtQKGRtqzRzqd7MrnMATTtBh9bGjuRCHP8bIZISRyQjlRg1NxQYmQ3Fs3ii3Ly1hcWkePeNBBpwhuuw+1tXODlnxRRKcGvYQTaRICSI3Lyrk3pVlfPf9ARQyCYmUwK0txdkrA5VmLbUFOobcYf54VzPxlMBZq4/2EQ/nbD5e6bARTQrcuayUeDJNvzfNPS0m8rUKBl0hBDFjI3hsYJKzVj+7WooXTH88a/Xx3ff6SAsif7Z70Q0tXHLkyJHjd51cgZyDKouWr93SyHff66dj1Ee1RYvVE+FHBwdYWWkkmc5Mw6cEkVRayPwUMj/T6cztALuXlrCx7tppbNfLW50O0oLI3SvK5iwMpVIJn1hfxXfe6+OXJ0b46o7Gaw4dDk9GcPiiCIhMhhPctqTkuib1tzQUcNbq5/Swl62NBUwEYjx5dJhwPMUf3NrIv77bS78rxKbaTPfvjU4HoXiKeCqNQpYJtZimeyxApy1TwFxZHAOcs/mnnEbKsm4Dq6pMvNJhx+6LzrmvaUHknM3HopI8dFN/I5FIWFKWT1OxgaMDkzgDMZZXGJFLJfzk8BC7l5bMqZduLDawoiKf186OcaDXRTItsq7GxG1LSrLbvpLV1SbOXeGJnK9RUGxQcajPRSSRxh9NsrHOwt/e3YLiGjHWV+MMxLB6oty5gNdwMJqJeg7FU0jI6J4TKRGHP8aaKhM7Fxcv2BXd3FDAkQE3bT1Oht1hzDoFrc2F/PDAIEUGFVKJhOdPWfnaLY102vxAxo3CqFVyz8oy/vnXPbzdNT6rQBZFkSePDjPsDlOSp2ZFZT6f21zL+z0u/NHE1CCinJsaZw4Ubm0s4Onjo3SN+VleYWRTvYVN9RbGfFF+fHCAV89mhg3P2/34IwKleRpiyTQjk5Gp54U95x20lBpobZ7fNeXkkIfnT1vxRZLcsayUTdeRopgjR44cHyZyEoscAMilEmRSCdubCinN16CSSxhwhvGEEsRSmUvIKrmUfK2CojwV1WYdTUUGllXks67GTLlRw2tnx2bICz4I/c4Q52x+tjcVLujDqlfJ+dT6anyRJC+0WxGvYb11fHASXzSJO5igOE89r1/u1VSYtNQWaDk64KZvPMgPDgyQEkQe2VaHUi6joUhPcZ6atj43aUFkZaWR93tc7Okcp8qszXomx5JpXjtnpzRfPcv2LZZM89Z5BxUmDeumAjUgE0V9tZThSnonggRjqTm9jxUyKdubCnlgbSXNJQYO9bnQq2QLShY21lvocwa55AjQUprHkrJ8ZPO4Ykx7IrePXH7f1QopnTY/4/4Y25uK+Lt7ltxwcQwZ32upBFZWGee8v98Z4i9eOU+/M0RJvppyo5pwIo1KIeWbtzRy/5qKa0oG8jUKVlWaeLPTgcMf456V5Yx6ooz5Y9zUWMBDG6pICSLPnRrlrNVLtUWb7fje1FiYXYCM+aLZbYqiyFvnx9l/0YlSLqWuUMfDG2sIRJMcG5ykUK8ikkhzx7KSWdrgxSV5FOiVHOpzzziXy4waivI03Le6nM11lqxf9Ctn7fzdm9388sQIvnCCXxwbxqhV8MDaynkXFYf6XLx8xkY4nmJxad6Cj82RI0eODyu5DnIOAGzeKA5/jHtXZibmeyeC/PzIMLcuKbkuz+RkWuDJo8O82G5DrZB9II/iVFrg9bN2zDoF2xfogk1TZdFy57JS3uh0cKDXlR3Euhp/NEnHqJdoIoWIhKXleSy6AQnJ5voC/mNfH/+2r5fmEgOf3VSDUavguVNWlpXn8+C6Cr7+zFn2dI6ztsZItUXLySEPRXkqUmlhavguMzj2mY3Vs4rOfRcnCMVTPLypekZ3V6PMHM9Oq487l5XO2q8zo150ShlNxQu7Qoz7Y/RMhNjVUjzvwFsqLfDmuTGaiw1UmXVcGg/Q7QggkUBpnpraQh01Fh01BTr0KjlSqYRVlSYO9bkIxJLIJPDSGRuxlMCdywr567sW/0bFV1rIDNotKs2b5dvriyTYc97BmREvFx0BTDolSrmU5hIDJfka5DLJDYVbLCvP4wcHBrJSiieODKFXyVhRaczKTp48OsxkOMGXWxuyfyeVSvjStjq+9kwHPzk0yN/cvQRBEHmlw86RfjfxVJqSfA33riqnzKjmu+/3o1HICMRS1BZoZ3huX7nNrQ0FvHp2jOHJCLUFGeeUcX8sO5y3rtZE+4gX30Ani1bV0jsR5EcHB3GHEqgVUlZWGnn+tJWGIj0NRXoK9aqMNZ8osv+ik/2XnFld8m1LSn5jq8QcOXLk+F0mVyDnADKXXFVyadZntr5Qj1Yp47zdd10FskIm5dMbq/np4SGeOTnK57fUZr/cb5RD/W5coQSf21xz3RZum+otjHgyQQeVZm1WCxtJpOgZD7KsPJ+TQx5GJiMYtYrs5e3rLd5EUcThi2L3RynJU/Potkzc9KArhDuUYMeiIkxaFZ9YV8U7XQ5SApwd9SGXSXAF4zxxdJitDQWcGPJk7equZMwX5ejAJBtqzXPKKFZVGTlv99M7EZxxeySR4pIjyPpa8zWT/Q72uVDJpWyoM8/7mLe6xrH7YpmBsbI84qk0Vk80GzZxcsjDkf5JAAoNKmoLtBg1SqLJFN/e18uRgUkcvijlRg3bFtBMX4vprviaq7rikUSKx9v6GffHmAhk7OTWVJu4b3UFTcV6LowF+OWJUbodgeuKVp/WpFt0SkRErN4wPRMhbm0pyp57q6pMvH5ujK6xwCwJz+LSPJZX5HNq2MsFu5+3u8YZD8RQyCWkBJHdS0tYW2Pm/UtOJgJxagsy3tZ3LZ9bNjT9fHu7Jzjc58p+hk4Oe7LDeSq5jM31BbRZpdQV6rPR3A1Feu5eXoZEAn3OIBcdmXMlX6PIWtW1j3hZWp7HoCtMpVnL5py0IkeOHDnmJFcg5yCWTNNp87Gi0pgdQJNJMx3Wc1b/dYUhQGbo6XOba/jhwUGePDrMI9vqFhyumgtvOMH7l5wsKcu7oQFBiUTCfavLGffHePbkKF/e0UDveJB3uyeIJNKctfo4b/eTEkTMOiUGtWJW6MR8pNICL3fY6Rj1sa2hAG80iXvKB/j0sBe1QsrSskwxtrHOzJEBN6uqjAiiyJA7jEya8V3e1z3Bsop8dk6FaEwzPZinU8rY1TJ38EhTsQGdUsaZUS/lV9zeacu8poUkE5Dpup6z+thUb5nXH7nL7ufYwCRbGwqyiyLVlHxkusBKpQXGfDEujQc4Z/Oxp9OBN5xgwBUilhSQSCToVXLWVhsZcIWu5/DOyekRL3qVbJZH908PDXF6xEtpnppIIs2uJSX86W3N2WKzpTQPs07BoT73dRXIF8YC9EyEeHBdJaeGvTxzwopCJmHDFZpiURRRyaWUGTW8eW6M2gId+ZrL0o17V5bxL7/u5QcHBrgwFmB5ZT59E2GqzFoeXFuJKxjnvUtOqi1aRiYjrKsxLThQqpRL2VhnYf8lJ65gnHyNgo7RTGE713u3t3uCiUCcx7bV8dHVl88OTzhB30SQfleI7rEA0WSaTfUWoomMNv5jayquK1o8R44cOT6M5DTIOThn9ZFIizN0rwDLyo3EUwI948F5/nI2OpWcL26pRaOU8cSRIVxToRHXy5udY0iAu5bPlhJcC5Vcxqc2VDEZTvCNZzp4pcNOSZ6aWxYVcaTfzbGBSSpMGkQx03G+nqI/mkjzxNFhOkZ93NpSxDd2NqJRyKZCGTI2XysrjVktqUWvornYwJkRL2q5jLuWl7Cs3MhkKEG/K4QnnCCSSM14jvYRL6OeCLuXlsw7ZCiTSlheaeSSI0g8Lc7425I8NaXXcCA43J+xqNs6T5KaJ5zgxXYbFSYNty2ZWcCnBRG7L8qxgUle7rDzYruV93tceMJJCg0qWsrysOhV6NVylpblsbWxAGcwzq+7J+gZDyx8gOcgFE9xyRFgdZUpK0Nxh+L84zuXePXsGEV6NY3FBpaU5/G5zTUzOrFSqYQtDQWMeiKMTg2uzUcsmeaNzjHK8tXcu7KcknwVB3szYRlXDiTavFH80RQPb7qsRxaEy+/BqioTdYU6LjoCBGNJOq0ZG8FPbahGKoFXOmzIpRIQRZRyKbfOswi6ko31GQu9I/1uztt9xJIC6+dwyrD7orx93kGRQcl9q8tn3GfWKdlQZ+FTG6r5qzsX8xd3LKKpSM9Zq5/WpqJcUl6OHDlyLECuQP6QI4oiJ4c8lOWrqbgqSa6uQIdeJctO718v+VoFX5gK3vjZkSH8keR1/d1FR4BuR5CbFxfPG4qxEMFYkrZeF+FYClcoTpVZy+/dVMvOlmJiSYFYMk04nkIhk7Khdn6ZwTTecIIfHBhgeDLMg2sruHlRMRqlnA21Zrrsfg73uUkJsxcWm+oteMJJeieCrKg0cdfyUix6JTUWHRfGAvz5y+cZ82aKt0gixTtd41RbtHMO2V3J6iojKUFk2J8Z0HIGY9i8UVZXGxeUMkQSKU4Pe1lRaZzzuKbSAs+cHEUqkfDQ+qqsF/Nb5x388MAA/+eNC3z3vX5ePzdGvzNEoUHFriXFfHFrLX9zVwv1hXo21FpobS6kodjAn+9exGc21pBKi/zb3j5ePmObtShYiLOjPgQxI50IxjJhLP/49iUO9rhYXWXk/927BF8kyYoK45xF3ppqExqFjEP9l/2NU2lh1gDn/otOgrEU96wsRyqVkKdWEE0KszS552w+5FIJW+oLuWdlGUPuCPsuTmTvN6gVrKgwEkmkSQki8ZSAQa1gXY2ZU8NehtwRlpTnMeKJsnNx8SxN9VzoVXJWVxs5M+rlcJ+bQr2SmquSGOMpkV8eHyGWFNi1pATZAgs+qVSCUibNLDAMqgUdLnLkyJEjR05i8aHH7stM7H9kDis1qVTC0vJ82ke8xFNpVDfgRFBoUPH5LbX86OAgPz0yxJe21S1YGCRSAm+cy3x5b7lBXWRaEDk2MMm+ixOkBZH71lQQjqc4Neylyx4gLQqMB2KsrzEz4A5j0imv+Vqsngi/ODZMWoAvbKmd4WO8qd7CoT4Xr50do6Usb9bl8sYiPTJpJmCj1qLjlQ47tYV6/n5rHS+dsfHqWTtf+VUHf3xbM65gnGgyzT0r59ekTlNu1FBoUNE1nOa1s3bOWn0MuUMMOEOMeiKkBTH7L3XF79FkmnhKYFvj3EXR213j2LxRPr2xCpNOSTCW5CeHh4gm0pQZNayvNVNl1lJp0mLUKmbs57GBSXomQty9ohR/JEkkkaY4X0OhQc2BXhcyaabL3T0W4PZlJayuMi34OkVRnOqKqzhn83O4L2M1l0gJrKoy8Se3NXNy2EMiLWSTFa/m6vRDrVLGd97rw6JT8empVDmHP8rRATfra8xUWbQk0wI2b5RKk4bOKfcUiUSCIIict/lpKs5ofVdVmRh0hWnrdVFToMv6DNcV6kikBYrzVJh0KhLJNNFkire7HNRatAy7IxQaVDdkg7iloYC2HhfD7jBf2lY/47gJgkibLUVan5H6LOR3PM273RMEYkke21Z/Tb16jhw5cnzYyf0v+SHn1LAHhUzCqnmstJZXZHyQLzmuX2YxTZlRw2c31+CLJLJRwPPR1uPEG0lyz8qyG/ry7ncG+fb+Pvacd1Bj0fKNnY3ctqSEj6woo8qs5cV2K999rx+lTMrOlmKqzVrSaZFnTo6SFua2hOt3hvjxoUEUMimPba+bFfJh1CopN2npcwZZWTlb5yqRSLDolcSSAseGJrH7MguQwjwVj7XW83/vWYpUAn/7+gXevTDO5vqCWdHOcyGRZBwOYimRc1YfZ0a8KEnGDbcAACAASURBVKRSJsMJXME4/kiSaDKNIIrIpRJ0ShkmrYIKk4bdS0vmDILosvs5OjDJlgYLS8ryEQSR505ZiSXTfHlHPb/fWs9dy8tYXmHENBWzPY0zEOPtLgfNxXo21Vm4fVlpNp5cKpXQVKxHp5LztZsbKTCoeLHdzo8ODjIRiM37GkcnI5yz+eidCPLeJSeLSvPYUGdGp5LzwNoK9Go5JwY9LCnLW1AisKneglSSkZb8+sI43kiSfleIp46PEE+mebVjDK1Sxm1LMnKHjlEfkUSa+9eU4/DH6HNm9NPDk2ECsdQMvfrdK8ooMqh44bQVfzRzdUQQMkVruVFLsUFFvlbJ4+8PkEqLlBk1TIYT3LW8dF67vLkoMqhRyqS4QnGWVcwclN17cQJHKLNo0KnkVFsW9vIemQxzfHCSjXUWqq7x2Bw5cuTIkesgf6iJJdOcs2YCCa6M4L2SGouWPI2cTrv/uofarqS2QMdDG6p46tgITx0b4XNbZjtTuIJxDvW5WVVpnFWMzoc3nOCtLgdd9gAWnZKHN1XPsJaTy6Q8tL6Kv3rtPEPuCLctKabbEcgWyW90Onj21CifWFc1o2hx+KM8fXwEs07JF7fWYlDP7aOrkGZeQzI9d5EtiqBTy3i1w87ty0pnJAGurzXzo4fX8revX8DqjTIRiGH1RKg0X7twWV9rJrJYRUVLFdGkwEPrq1hWce1htLnwhBO8dCajO949VSi+3+NkwBXm/tXlCxbtqbTAs6esqORS7l9TMWdXuL5IT7cjiEIm4dFtdbSPeHm7a5xv7+9ja0MBNy8uynbyRVHkrNXH4239WD0R7ltdzt0rMgmH328bYHlFPisrjZyz+RnxhBd04oDp9EMjB3qcyKQStjUVUmbU8GK7jb9/6yKxlMDH11WiUcoQRZHDfa7scegaC3Cw10VTsYFzNh8quZRFJZffP6U8c2597/1+nj9l5Ytba7k4HkCjlJNICWiVMoxaBccHPXx1RwOnR7wsLjVcV5f3ShIpAUEUMagVXHIE2TDVfR6ZDNPW46LRJEWrzCQjli3wXiVSAi+22zBqFLP05Tly5MiRY25yHeQPMZ02P/GUwPqa+YsNiUTCsvJ8eseDC3aAF2JRSR4fW1PBoDvMsydnDjiJosjr58aQyyTcvuzaw0vJtMD+ixP8+75eesaD7Gop5hs7G+f0XZbJMrrLcqOaJWV5xJICWxsK2NxQwF3LS+myB3j21OVOsj+S5Imjw6gUUj6/ef7iOJZMM+aP0lhk4PSwd8brgYxjhD+aRCOX4QknuGVR0awC0qJX8S8PrOCrOxqweaM83jbATw4N0u8MXTPsBDKyBY1CxqLS3ywKfFp3DPDJKd1xvzPE/ktOVlUZr+mKsbd7Aoc/xn2rK7LH6chUt3b6eDYWZfat3xlCIpGwtsbMH97axOoqEwf73Pz73j4ujGWs6777Xj/PnrQyGUpw94pSHtteT5FBzfOnrBjUCu5dWY5EImH/xQnG/TEO9blmhHPMxaY6Mz0TQULxNDsXF7O6ysSdy0o5PuRhMpRg6dSi5dJ4EFcowdaGAhRyGVvqCxhwhRmdjNBlD7C41DAr0KMoT809q8oZdId587yDS+MBjBo5I54IzmCcUCyjde92BEgJArcvvfGh0/N2H0q5lOXl+RzuzwSHiKLInvMO8jRy1pfKGZ2MUGHSLOhG8W73OO5QgvvXVNyQTCpHjhw5PszkCuQPMaeGPZTkqak0L3x5f1l5PilB5KLjxh0JpllVZeLuFaV0O4K8eMaWLQLP2/30O0Pc2lI8b0EKmcvXHaNevrWvl30XnSwqyeMPb21ix6Kied0o9nSOoVXK+af7l9M1FqC2QJvt0m5pKODOZZki+blTVsKxFD8/OkQ8KfD5zbULJrBNLyzuXVnOZDjBxaucGgZcYVzBOHpVRt4wnwuIWiFjZ0sxf7q7mduXluAKxvnp4SEebxvgwph/zkI5lkzjjQkZO7GK/Ov2ib6ady5kdMf3r67ArFMSiCV57tQohXrVNfXQ/c4QB/vcbKwzZxcmp4Y9vNnpoK3HxRNHh4km0hToleRrFPRfYfemU8m5f00Fj22vQ6OQ8fTxUX5+ZJhYKs26WhPNJQbumIqWfrvLgSuU4GNrKtAoZbiDMQ71uakwadCp5DxzcnTBRVu/M4xClumyyqcKyDFflBqLFoNazlPHR0mmBQ73ucnXKLK2cOtrzagVUp49NUokkWZ5xdxXTlZXmVhTbeKNc2PYPJGM/jpPhSsYZ9AdprlYz8E+F5vrLRQarj+4ZJqTQ14KDWruXlGKO5TgoiNIp82P1RNlV0sxogiOQIway/x+40PuMEcHJtlYZ856g+fIkSNHjmuTK5A/pNh9UWzeKOtqFx6aAqgya8nXKDhvn9vNYswX5Vv7enmx3bagvnRzfQE7FxfRMepjz3kHsWSaPZ0OyvLVbJzDwgoyHeYuu59vv9fH86dtqOQyvri1loc2VC3odNEzHszYWTUX4gzG8UWS3HTVkNrWxkyRfM7m409eOocrGOczm6rn1OpeyalhD8V5Km5eVIhJq+DIlIXaNBfG/Dj8MdZUG9lUZ+H40OS8emfIFMrbmgr549uauXdlGZFEiqePj/KtfX2cGfWSSguMTkZ4sd3GP7x1kV9eTBBJpK/pejEfXXY/R/on2VxvYWn5lO74pJVESuBTG6oW7DJGEileaLdSaFBlu6K9E0Fe7bDTVKzno6vKGXSF+MGBAbyRJA1Fegac4Vld9mqLjq/e3MBHV5Xz0VXl/MHOJoKxFEatkvpCPT3jQY4PetjaUJD1YH717BiheIoH11Ty8bWVTIYTvH52bM6FxLT38PamQhQyKZ12P4OuEGdGfdy3uoJPb6xmwBXiO+/10+8KsbnekpXaqBUyNtRa8EaSaBQyGovmLyw/sqKMSDxFvyuMRinjL+9YTFGeGq1SzqA7TCIlUG68cc3vdHLe+hozy8qNmLQKDvQ6+fWFcUrz1ayqNOGKiogi1BTMvf14Ks1L7TZMWgW7l1776kyOHDly5LhMToP8IeXU0NRwXuW1iyyJRMLyinyODriJJtIzvHqtngg/PzKMTAqdNh/tI16ai/VsbSykvlA3q/i+eVER0WSaI/2T9E2ECMZTfHpj9axLxKIo0u8M8W73BDZvlEK9kk+ur2RZef41C/p4KuPyUGRQsa2xgB8cHKTQoJozVnpLg4X9lyY4Pexl95JiahfoxkFmMWDzRrl7eSkymZTN9QXsOe/APpUeJwgCe7snMKjl3LemAlcwzi+OjdA9FrimVlghk7KhzsK6GjOddj97u8f5znv9hGJJ8tQKykwaJMCAL43BGL9m538uPOEEL5+xU2HScPtU0bTv4gSD7jAPrK2g6IrBN1EUZxxrUczEKIfjKR7eVJN1g/jViVGK89R8cn0VaoUMi17JL4+P8v22ftZUm4gm09h90Vkaa5lUwvopuz1/JEmfM8SO5iLCiTQvnbFRkqdm15RmNpFMs+e8g3Kjmh2LipBKJdyyqIh9F53UF+lYU22esZ+vdtiRyyR8YUsNPzsyzKFeN4IoYtIq2NFcNCWZEPnnd3oQRWYNqW5usHB0wM2yirwFh0ZD8SSecAIArVLO3u5xGov01BRo+dGBQeQyKYf6XDes378yOW/a2/knhwbRqxV845YGpFIJzoiARMGcyYsA716YYDKc4JGbanPSihw5cuS4QXId5N9hRFFkX/cE73Q5OGf14QrGEUWReCqTLLesPH/eYIqrWVaeT1qAbsflLvKgK8RPDw+hUUr5cmsDf7Z7EbtairH7ovz08BDfe7+fc1bfjO6pRCLhzmWlrKoy4gzGWV9jnlU4DbvD/PjQID87Mkw4nuJja8r55s4mllcs7Pc7zb7ujCPG3ctLefLYCHs6HdQVzC7WAd46P04sKXDf6nI8kSTPn7bO6nZeyampwmXlVEG1tsaESi7lSF+mi3xs0MOYL0ZrcxEFU6EhZp2CY4Puebd5JaIoMuKJ0DseJBBNoZZL0ShkIAFPKM6QO4wA9DlDnBryXNc2p5nWHQuimNUd904Eeb/HxdpqU7YjLYoiL7bbeOLo8Izu7JnRjG3erS0llBs1+KOXNduf3VyTHfSsL9Tz+631qOQy3r/kwhOKz5BZzMWZUS+imPF6fqXDTjSR5uPrKrMSkhc7bASiKR5cW5ldTO1oLqKuQMfrZ8dwXnHl4syol0F3mNuXlpKnUbK1oYDxQAxnMM5HVpZl9cQNhQbyNQqUcinPn7aRTAvZbeSpFXz15oYFtcPJtMB/7OsjkkiTr5Fj80YZcIW5Z2U5A64wNzUVUmHS8E7XON1j1+8lnkgJs5LzFpcYmAjEEEWRhilt90RYpDRPPeeA7bS0YlO95boHX3PkyJEjx2VyHeTfYXonMkNXkkyIFwAquZSUIDDoCrO22oTdF6XYoLqmtVqFSYNZp6DT5mdNtZneiSBPHx/BpFXyha212ejdHYuK2NpYwFmrj0N9bp49ZcV4YZwt9QWsrTGhVsiQSCTcv6ocg0rO1sbLyW42b4S93RP0ToQwqOXcvaKU9TXmG7J9s3kjHBlwU1+o46Uzdtp6nRi1SrrG/NyyuGiGzvlIv5vD/W421Vu4e3kpB/vcvNM1jkQCD6ypnNXVTqSE7MJiunBRK2SsrTFxbGCS7c2FPHfKik4l494pBwapVMLGOgtvnR/H4Y/O6wwRjqc4M+rl1LAXVzCOSi5lbY2JdTVmSvPVHOl38619faRFkSajjKhcwffaBvBFk9zaUnxdC4dp3fGnNlRh1inxR5I8d8pKSZ6aj6wsyz7uYJ+b9hEvAFZPlCqLFncozhvnHNQX6tjWWEAsmebJo8PEkwKPbq+bEb0MGR/sL++o5+njI7xxLsDb5x20TnkLX40oipwZ9VJXoGPIHaZ7LMCdy0qzUpdwPMUbZzNpcdO2bNPH9sF1lXxnfx/PnLTy5R31xFMCezrHqS3Qsq4mU/CvrDSy76KTSrNmhhvF0QE3hQYVt7YU8W63k6eOjfCZTdXZorzIML/URhBEvt82wPs9LgRBQKdSsKQsD6VcyuE+F4Foise21xFJpPnD587yz7/u4d8fXIlJd+0AnLmS8w4PTGLRq1DIpHjCCfI1ClxRgc0Fs694xFNpXmy3YtblXCty5MiR4zfld6JAlkgkRuCfADOwGhgE/kwUxTM3uJ3VwI+BfxBF8cX/9B39gIxORmbEDC+EKIq8e2Ecs07B129pZDKUwOGPYvfFeKndRiSR5nC/myMDk8ikmWKgzKihzKim3KihyqydUcxk3CyMHOpzcXrYw2tnxyg0qPjC1tpZASAKmZR1NWbWVpu4NB7kcJ+bPecd7L80wYZaM5vqC+gZD3Kwz02n3c+WegvDkxEujAXQKmXsXlrCpjrLLOeAa5EWRF44bWXCHyMtiLiDceoL9Xx+Sy2vnbXz7MmMJZdUKuG8zc+e8w6WlOVx19RQ2PamQkRR5NcXJhBFuHdV+YzuXNeYn1hSYG3NTFnK5voCjg5MZj1+l5blU3yFjnlNtYm93RMc7Z/M+gRPv0cDrjCnhj10jwVICSJVZi0fW1PO0vL87GVxXyTBgV4Xm+otfGRlGSdPnCJuKudAr5t9F504g3EeWLuwQ0H3WIAj/ZmO4tLyfNKCyDNTDh4PbajKFoX9ziC/vjBOS1keA84QxwcnKTdpeP60FalEwgNrKhFEeObkKBOBGJ/dXDNv0a9VyvnCllqsngjHBz08c3KUB9ZWzhosHJ6M4A4lWFNl4s3OTBG+peFycbincwx3KM7nt9TMWizlaxQ8sLaSJ44Os6fTQTyVJpkWsq4XkLH8++bOxuygHmSGHU8Oe1hank9rc2ZA9KUz9llF8lyM+SL867u9dFh9SMgMoGqUcv5gZyO/PDHKs6es3LK4iOopuc6nNlbx1JSm/Ks3N1xzYC8znKfKJue5gnFODE5y+9ISuh0BjvS7WVlpJC0wK10P4NcXJvCEkzlpRY4cOXJ8AH7rC+Sp4rgdeFQUxX1Tt/0QaJdIJPWiKA7ewOZeAOoA33/+nn4wYsk0Tx4bxjOeZHMsuaDjA0CXPcCYP8aDU4VTpvjVUGaMcmxgkkduqmVRaR5jvihjvhgOf5Se8UC2c9hSlscn11XOKEiWV+TzyhkbPzwwwKpqE5/fXLugREMikbC4NI/FpXlYPREO97s52Odmb/cEdl8UlVzKmE/C3u4JCvRKPrmuituWlszryXwtnj9tZW+3kyqzlrpCHaIItywuylqWvdhuY9/FCRqLDTx/2kqVWcvH183sFLc2FyGS0W/2TATZVGdhS0MBOpWc08MeCvRKaq/q2pl1SlpK8+iy+8lTK1heMVMnrVXKWVVlpGPUx+3LStAq5QhCRsbQYfWhUcjYUGdmXY15VvhFPJXmqWMjJNMij2yrpsigxm6QUru4mD5niBqLjm5HgB8eGOQzG6vn7FB6wwlebLdRblRzx5TueG/3OCOTET6xrjJbsHnDCZ45aaVQr+LBtRW80zXO6WEvGqUMqyfKQ+uryNPIefWsnd6JEPetLr+mt69cJuXTG6sZ9UQ53OcmEMtozq9cVLWPeFHJpJwf82eL8Onj5wzEeOfCBAV6FTsXz90NbS4xsK2xgDc6x0gL8OBVWmpg1jnVPuLN2v4BWQ3zQkWyMxBj/yUnb58fZzwQZX2NGUGEWouWiWCc4jwVhQYlJq0CVzDBry+Ms6ulmLtXlNM+7MXqjfCjgwN8YWvtvIsKhz/KqCfCnVOLNoB3uhwoZFLuXpEJ0Wkf8WZfT/VVmvlBV4hjOWlFjhw5cnxgfhc0yH8BDE4XxwCiKD469eufXe9GJBLJPwE31HH+70StkPHJ9ZUEEiI/OjiIL5KY97GCILK3e5ziPBUrrrKoOjk0PfxjokCvYnmFkd1LS/j8llr+8o7F/PntizKhGmMBnjk5SuoKXabdG8HujyKSiV++Xv0yQKVZyyfXV/FHtzaRFkSG3GFGJqNEEyluX1JCbYGODqtvTl/haxFLpnnq2DA/OzxEoUHFN29txBtOUpqv5papOOI11RlLrre6HHx7fx+mqXCRuTqFO5qL+MqOehqK9LT1uvjndy7xq5Mj9IyHWFtjnlMmsHtpCSsrjZj1yjkLk011BSTTYvb1PX/aSofVxy2LiviLOxZx1/KyWcXxtBbYEYjxyfVVMy75V1t01Bbo8EQSfGZjNd5Igsfb+hmZDM/YRiie4omjwzN0xxcdAQ70utlQa84OjyXTAr+aShf89MZqVHIZG+ss+CIJXj5jY3WVkWUV+Rzsc3NyyEtrcyHrFvDPvpKaAh1VZi3LK/IZ80X5flt/VjMcT6XpsvuRySSM+WLcs7JshsXenvMOJkNxNtSZZxW9V7K9uRBPKMGEP8ay8oWHIQVB5Ei/e4btH2SK5PtWldPvCvH08ZGsJnkyFOf501a+tb+Pg70uREQ+u6mGtdUmtEoZaVGkzKjmcP8kl8ZDPNpaz9ZGC209Ll44bUOnlLGpoYBCvQpRhB8fHMLqicy5b6eGvdnhPMgUvN2OINubCzGoFdzUWEA8JXCw14VeKZkhbYmnMsONFp0yJ63IkSNHjg/I70KB/CVg7xy3n5m675pIJJI6wHjFdm5s+um/iYYiA7fVKAjFU/zgwCCuYHzOx3VYvbhCCXYuLp7RHc0M/8zU0F6JRJL5wm1tLuIjK8rodgT51VSRfHTAzcsdYywty6dAr5ox0HQjXHQE8UeTtJTmsbXRQqVZx4PrKvmT2xZRY9Gy57yD773fP28BcTU940G+ta+XVzrGKDdp+NcHV3DRESAQS/KxNRVEk2nevTCOP5KktakQmydKvzPE/avK5zwG01SYtHxqQzXfvKWRJeX5vH1+nE6bD7s3wmRo9nEv0KuoKdAhlUioL5ytCy3JV1NXoOPogJtnTo5yzuZn99ISdrYUz3s5f/9FJ132AHcsLaV5DgeOHc1FBKIpwvEUX25tQK2Q8eNDg5wezpy+kUSKnx0ewhtJ8PCmaix6Fd5wghdO2yjLV3Pn8swAmiiKvH52DJs3yoNrL3eU8zUK3KEEgViSu5aXcs7q452ucVZU5LOr5foLMJVcRpVZSyIt8shNdSTTIt8/MEC/M8j7l5zYvRFcwRirKo0z3B76JoKcGfFi0imznd75aOtxUWbUUF+k44V224yF3dV0jfnxRpJsbSicdd/amkyR3OcM8dSxEV4+Y+Pf9vbSZfdTa9GiV8u5eVERD66tpGciSHOxAWcwTjwl8HbXOMsr8rm5uYh7V5aza0kxHVYfTxwdZl2NCalUwopKIxqllJ8eHmLwqsHF6eG86c+nKIq83TVOvkaRff2l+Roai/SkBJEi7cyF2rS0IhcIkiNHjhwfHMn1pHb9b2WqsB0AHrhaMzwls/gSYBJFcUHJhEQieQF4BHgQ+CGwZj79skQi+dLUdikuLl7z7LPPfuDXcSOEQiHiMi17R5IA7KpRYFZfLrDSgsgr/UlUMrirTjGj29nnTXPEnmJ3rYIS3bXXRj2eNMfGUkgkkBahJk/K8gIpbw6m2FAqZ7Hlxr6EvTGB53sSTEZFNpTKuKlCwUt9CSxqKbtqFBkHh4DAyfE0kZTIIpOM1cUylLLZHdt4WuSkI8WATyAtiiTS0FqpIE8lYe9wkqUFMlYUyXhnKMlkVEQuzbyGlJDxji0zSNldo0B6HcNtaUHk6YtxUgIoZJLMZfV8KcsLZJiuOPbvjyZxRUUeaFLM2WUe8KV49lKSfJWEHZUKWixS4mlQy2c/dtifps2aosEkZUuZPLs9R0igxxVhW40OCfDmYJKEAB9tUJAUoM2awhESaDJLmYyKeOMit1QpKNdLSQsibw8n8cdF7q5TkqfKbHP6fV5eKGN18eVFwyFbkrPONHIpbC6Tc86dplAjZVe1fEY89/XQ6UpxZiLNxxcpSQuwbzTJZCTFObdILAUNRglfW61GM6U7F0SR1weSDPnTWNQSPrlYhWKe55yMCrwxmKTJJKNMJ6HNmmJJgYx1JbMXQKIosmcwSXzqmM33/vd50xwZSyGVQJNJRqlWwkF7CpNKwm21CiajIu8MJVlVJOOwPUVahGazjJ1VM4/NgC/zmctTSZBLIJSEO2vl7BtNEUqK3FypoNwgvfycV3w+B3xpDtlS3FQhp954+bM2FhJ4dzjJSlOSleWZqxXjYYF3hpIstsjYUPpbr5zLcZ2EQiH0+pyU5sNM7hz44OzYsaNdFMW1V9/+2/4/ad3Uz7kK4IGpn+Z57gdAIpF8DNgriqLvepwARFH8EfAjgLVr14qtra03sr8fmLa2Nu5qbWXbVOpaV1Lgs+uqs1rEowNuDD4HX9xak7WDmuZi2wDL9Wk+vrPxulwPtosiqbYBXj5jp6XMwF9+bAVqhQzr3l5kKhmt2+qve7/Tgsi39/cRkTnZttTMH+1qRqOUoaly8db5caqX1mW1vZ9IptnbPcGxwUlOx+Xctbx0hv9x91iAV8/aielS3LfMQseol+I8NZ/bVM1/vNfP8mYpX2mt57nTVlTmII8sK+HHh4aweaM8sKaCNdUmXjpjJ1FYwO7riADutPko8Vn5/JYaSvLVHOlzc2LIw8mIQEu+gdbmIipMGg7vuUhriYEdaytnbSOVFhg5MYp8xEpzlZHfv2cpz5wa5ZIjyKPb62Z42dp9Ud47MMDGZRp+b2ttVgcuiiLf3t/PcHiQm0pauHlxMYVNfn55YhRLQyUrKo3cKoi8etbOL46NIJNK+Ju7W7Jd2T2dDhQ+N9/YUJVNjbN6Iuw7OMD2VXo+u6kme8XhnNVHxGPl0dsKOdDr4rg7zLoGE4+11i/YeZ+Pek8ER9sAZc2Z/dyZTPP5n58kmvaiU8sJoeDNiTy+cUsTTSUGTg55UE5aqdSk2LGomFuvGG68EkEQebytn6baFH+wswmNUobprJ3jgx5KF9XM6rwPu8MovIPcv6KMTfVzh9MAtAK7PRHy1AriqTQ/PDhIS4OMR7fXo1fJebNzjMqkh7paE3vs/bQuKuIPb22apXVuBbY7M5KNaCKFKiVQ2lzN/2vN4+eHh7gYjLGiMfN+XPn5TAkix9/tZd0SOV9orZ/1ed3oCjF0/hStra3EU2m+vb+PpY0SvnZLQ657/CGira2N/+7voBz/u8idA/91/LZLLK7Hff9aj/n4VNH7W0WhQcWj2+rQqWT87PAQ/c4ggWiCN86NoZJLGXSFeebkKN/Z38f33u/n3/f28v4lJ6l0JsjicJ+b9pGMe8KwO4wzECMYS2YvTYuiyFvnM7ZgdywrQa+S86sTmWje5RX5DE9G8EeT172/712a4OiAmzKjhoc31WT1yxvrLOSp5bx7YTzruatWyLh7RRlfbq0nX6PgmZNWnjg6jM0T4dmTozx1fAS9Ss5XdjQQS2RcCz66qpx3Lkzgjya5f1U5b3U5OGf1s6W+AJs3SnGemntXljM8mRkWXFRi4ECve874bKsnwr+928OwO6PnPTXsxahV0FCoJ0+t4PZlpfzp7mZ2Li5iyB3h8bYBvn9ggHAiPWecb2pK33tpPMidy0sIRJP8/VvdvHlujCF3mCeODGcjk4OxJE8dG0GnkvOpDVUzhiSH3GHGAzH0SgnvXXJi9URYUpZHoUFFW48LURRJiyKecIICvYpCg4r9l5y4Q3G67P6spd10cRyMJXn6xAj5GsWMYcXJUJxXOuxUmbVsrLPgDSfwhhN8dHXFb1QcA5QbNWgUMvqdGVlBJJFiyB3GpFXyrQdX8ol1lQxPRvjzlzv54YEBXj9nRymXoVcrFtQ6Hx2YxO6L8ZEVZdlz6o5lpZTmq3nhtHXWOXqo341WKcsObi5EpVkLEvj50WGkEvj8loxjiyiKdI8FKMlX80pH5vP2ldb6eYdLG4r0PLa9HpNOyehkhNfOjqFTyvi9m+ooN2p55uQoTx4d4tJ4gPVT+/LmyQAAIABJREFUGvfD/W780SS3Ly2ZczFbV6jPdqrf6RrHG8lJK3LkyJHjP5Pf9g7yQlNCvqt+zmJqMO8f/lP36L8YURTxhhO4QnFcwTgVJg1v2Xx8/dmzaOQyfNEkLaUG2npdmLVKCvQZV4NL40GiyTTheIq2XhcLKWuUMgmxVJpYUmDn4mLuWl7KmVEvL53JdCZvX1rCvotOuux+tlxDGwoZb+LnTlmRSCR8cn0VVVdYUylkUlqbi3j93Bh9ztAMV4QKk5bf317P8cFJnjk1ygunrRTlqdhQa6Gp2MDbXQ72dk9QX6jnZ4eHODowSUm+mr/b082QO0JpvprDUzHQu5eUsGNREb0TQV44bcUdjCMIAs+fsvL1WxpnuD+ctfpwhRI8cXSY+1aX0+8MsXNx0Qw9t1Yp55bFxWxpKODkkIfD/W6kEmi4okBOpgVsnghPHhvh0niAarMWqydK+4iXtCjSUpqPUSPnUJ8bhUzKN3c28PTxUaKJFI9ur5/lVHJ0YBKtUsa2OgXnkgpeOG3lqzc30tpcyAunbVwY83N6OBOS8eUd9Rg1Cn55YpTH3x9ARKTCpMm6WAiCyLMnrUQTaR7bfrkrnEoLPHsqY+l2/5pyfnliFL1aTlOxgb6J4CwHj+tFKpVQX6SjzxlCFEX+5dc9RBJpvrmzidZFRbQuKmJVlYkfHxrgVydHkUqgschAU7F+VmLguD+GRiFDEDPDqItLDSwpu+xvrJBJ+cT6Sr73Xj/Pn7ps7ecOxbnoCNDaVHhdFoLRRJonjgwTTaR5ZFsd5qlzxOHPhI4I/hjheIqbGgvJXyD2HDIa9N9vbcAfvcixwUle6bBz3+oKvrC1hjfPOXilw85EIMYpiwdBFHjvopOWUsM1nSgGXCGOD3rY0mD5jd+bHDly5Mgxm//RAnnKom0/19cJnuaBK/TBCw3TGRd6zPRg3o16Jf9PIYoij7cNcOZigne9PdnbNQoZq6tNdI8FuDAWYF2NiT+/fTEWnTLbfUykBEY9UbY2WPj4uqqpND2BSCJNJJEilkxP/Z4mEk/xbvcEHaM+ivPUuENxhicjUylrEl46Y+Ot8w6KDCo6bdcukJNpgZ8dHsIx5VBwU+Psx6+rMXGoz8Xe7gkai/QzOmbRZJoRTwSlLGNVp1PJGfVEGXaHuTAWQCWXkq9R0DHqwzJlt3ZmxMuWBgt3LC0hKYicHvawZsoVoKnYwNdvaeTFdhudNj8j4wGeODrM125uyB6vfmeICpOGaCLNf+zrQ6+Ws7Z67rWYWiFjW1MhG+vMXHQEuODwM+aLYfdGGfdH6ZkI4Y8mWVRioLkkj3hK4ILOj0Yp43sPrSSWEvnHty/ybvc4XWM+ivM0fG5zDWXGmUWhN5yg2xFgW2MhareTB1ZU8JNDQ7zd5eCu5WXsvTDBt/f3Y9YpuW91RTYV7ys7GvjFsWEC0RQPrb/ckX7nwng2XvrK55oOE/n0hir2dk9g9UZ4eFMN7SNeTo94uWVx8Q3rj6dpKNTTZQ/QafOx/6KTojwVD2+qzt6/qd6CVinjT188RzwlcNERQCGT0GH1saoyk6LoCsZ5vK0fi06JQZ3RZt+zonxWl7XIoOYjK8t5sd3Ge5ec7Gwp5ki/G5lEsqC0YhpRFPnliRFcoRif21xD+RXH6KzVR+9EkKVl+VSZtTQWX5/+L1+j4K/vbOH3fnGap45lOvc3Lyri7hVlnLV6WVyaWRx+v20QTzhOc4lhwXCZpCDyUruNAr2SXS0lcz4mR44cOXL8ZvyPFshTw3NrPsAmpj2O6+a4z3LFc8zFC8DqqaG7q2mf+sJ99H+L/EIikVBh0hAxy9i+qpxCQ+YSuk6ZSabb0zmW6WqJMOgKz7AM6xrzE02ms5eqJRIJaoUMtUKW7YpNM+wOI5E4+drNjehVco4OuPnRwUGqzFq2NxXysdXlvHjGTjotAiK+SALjAt2zPecdnBzysKQ8j4c2VmcLGVEU6Z0IUW3RolbIuGVxES+227kwFshKALrsfl47ayeaTHPn8hK2NxURiCaRSiUc6nUhlUr50rY6Om0+fNEkH1leyltd42xuKOD3bqpFIZPyxJEhnMEE7SM+dkxZvhnUCj63uYYj/ZP86uQI73ZPkKeR88WtdQRiSZzBOLuXlrCsLI8vPHmacCJFJJkin7m9p0VR5I1zDk5PeUjrVTKK89SkRZGiPBVfu7mB1uZCBlwhfn5kmNbmQlyhBEcGJjHrlPz1HS18/bkOzoz6WFkpYS55+ImhSQA21pk5687EOW9tKOBwv5vmEgNpQWDAFea2JcWsr71czJt1Sr66o4FEWsh2iTttmZTDjXXmbCENl8NENtebGZoM02XPJNotLc9HLpPw5NERuscCLKtY2EZtPhqKMoXkP75ziXhK4ItbamcFf3Q7AqysMuGPJLk0HkAmlfDCaSsnBj3cvrSEPecdpIWMxEEilfDwxuoZtnBXsqbaxIArxHs9Tkry1bSPeFlRabymh3jmGPkZcIW5d2XZDC1/Ki3w7MlR5FIJH11VzssddsrmKWDnQquS8+i2Oh5vG+C1s2P4IkkqzVpSAjy0oRqtQsqgO0RNgY6e8SAXxgJUmjWsrzGzrCJ/hoSifTxNQJPkSzfV3XCoTo4cOXLkWJjfdonFdIE8V5FdByyUhvcIsyUaD5BxqPgzMjZxNxIy8l/OPSvLafP1zSiAION1e2rYy/2rKzKWXefGiKXS7GjOFIQnhzwUzhFwMRfHBidRK6TsWlKMSi5jS0MB7SNeDvW5eOr4CEWGjLfy8UE3Q+4I7VNdxbkYcAZ55sQoeRoFj00NN02z/6KTlzts1Bfq+cymalZVmjjQ42LfxQmqzVrePO+g0+anLF89I1jBpFNi90U5OjjJ+loToihyfNDDiop89l9yYlDLsyEPvRNBeiZCKGQSTo94aG2+HHUskUjY2lhATYGWv3uzm2dOWAFYVZkpGBuK9IwH4tQV6JBJJfz00BCPbKub5VUMGXut0yNetjUWsLmhAJVcwtPHR5HLpDxyUx1rqk2M+aI8fXyU4jw1X9pWx8+PDPPiaRtmvZJwIk04kaKuQEs8JfDk0RHW1Zi4e0UZaoWMRErg1LCXJWV5MxYju5YU0zsR4B/fuoRFr6SpWI8vmpq1f3KZNNv1nQjEePmMnWqLljuXXR5Q9EUuh4mo5DLe73GxpcGSTbRrKjJg0io4MTT5GxfIZp2SdFrgvC1T9D141TDjyGSYTpufm5sLOT7kQauUoZRLMagVuEIx/vq1LpJpgce21/Otfb0Y1Ao21C7sxXzPyjJsngi/OjmKKDLnFYyrSaUF3u0epyRPPUP/LIoiPz8yjN0X4zObqrKa56u7/ddiQ52F9y45EYHTI17OjF5Oznvy6DAFehV/vKsZiQQ6Rn2cHPLw0hk7b3Y6WFVlZH2tmXA8zSVPmo9ts1CTk1bkyJEjx386v9Vth6nu8Blg5xx37wSeu/KGKVnF9N+eEUVx35X/uOx8MX3b/6oCeT7aepwk0wK3LSnhoQ3VrKo08u6FCd7pcjARiDEyGZk34OJKArEkXXY/GoUsO9yklEvZVG/hj3Y18+DaCiSSzCVmiURCMJrkiSND2QGzK4kl03zv/QFC8RQPb6rOaikjiRRPHh3ir147z3sXnbzYbuNvX+/mwpifnS3FXHQE+avXurgw5ufWliK+vKNhxiVmQRB5ud2GXiXn5uZiXjpjI08tx+qJIIjwuc2ZQSpBEHnrvAOzTsE9K8vwhJMMuMKz9rPCpOXfHlxBY7Ge505ZebytH6kEyvLV/5+99wyz8y7PfX/v6r3MmjW9d2nUe7Gqi2xjbAwY2/QW7HBBSEgCO+y9z9l7B0JyOIGEmNAMmGLccZeLiiVZvU/vfVbvva/3fFijsUYjyYbsnB2R9ftiXZrV1/jS/T7/+7lvzk75seqV/PWe9oJIPjqxKHv66IiXw8MeNjaWcPuyClRyCb8+MV2wL8wlZvhjBT+zWiHlU1saUMmlbGoqYToQRwT80TTpbJ4Kg5p0Nk82l+fiTJB/2j/CqDtK12yQeDrHluaF4k4mETBrFMwGE2gUMh5YX8uoO7ogQzqdzfPIwRH+6plupn0xfnNyCoVMMl8aAoWEkSfPzJAXRRpLdbw15GFtvXlBm5tEIrChsYQxT2y+5OP3RRQLpxmZXJ7P3dSI9LLpsSiKvNLtwKCWYdWrSGbyPLSjibtWVBFNZclmRTK5PIJQuCCx6pSUaBWMexd/p5ejlEl5YEMdUkGgrVx31QucKzk94ccfy3DH8op53/ml13dszEttiZp7VlZjDyaQCAV/8e9D4fu3kMuL83nSW5stjHmiDLmi7GovQ6uUoVHI2NpSyp/f0soXtjextNLA2ckA3z8wyi+PT6JXCkVrRZEiRYr8O3FDC+Q5vg40CYLwtUt/Mffns5dnI88t5I1dfrurcMmc+N4qwv4DEIpnODXuZ02dGateiVQicN+6GjY2lnB42Msvjk0ilcCa97C1f2bCjyeSwhFK8nKXY8HPpBKB1XVmvnJzK5/e0kBHhR6TVkGPLcxfPnWR352fwXtZgcaTp6fpsYVY32CmsVTL3m47/+OlXj7yo+P8/WuD+KMZZFIBfyzNsVEPn/vlWf7Lc9302YIMOsJsbrRQaVRjDyYIxTPk5tr1jo15sYeSvH9FFYdHPPhiaQQBwsksn9hUP19ycXYqgCuc4o5llayoMaGSSzg3dXXLulYp5+/uXU5bmZ4eW4gxT5Sjo14uzARZWmXAolPyuW2NiKLIo0fH59/n+ekAr/Y4WFZt4O6VVaSyeR47NsmEL8b962pZXWcmlsry2LEJsjmRz2xpmG8+M6rliGJBHC+tMvCDj67lw+tqKNUp6ZoNEYpn8ESS/OTIGI8dm6RsbsJ4iUspI0OuKHs6y8nk8qjkUtRyKYeGPUDhYuQnR8Z4tcdBjy3IV5/uYsYf58ENdQsa2Pb1u5jyxWmv0HN01MuyagMfXL3Y17uuoQSpBE5N/GE9OqfGvdiDSbTKxSkSXbMhZgMJbltaQddsEKNaTmuZnptaS/n4xjouzgZJpHN8aVcrK2uMfGJzA5VGNW8Nud/1eatMar58cwsPrK9719smMzkODrpptmppLXvHW3x42MPxMR9GtZy1dSbMWgX2YAKrXnnNopfrceliJ5bO8t/vWsr6hhL29jgxa+SLPNKCINBYWijUKbQuVlJXomF7taxorShSpEiRfydudIsFoijuFwRhLfAPgiDcT8EWMS6K4q1X3PQMhUSLRUt5c+J5De9Mop8RBGE/8O3/KEt8+bzI+ekArtjChrCDQy4Ads/5a6HwD+o9q6pQyCT88vgk6xtKFtgbrkYuL3J8zEc0lUWjkDLoCDPtiy9InLj02O0Vetor9GxqsvD157o5Pu7j5ISfXxybYlmVAX8szalJP0qZhClfnK8/10M4kSGezhJL59AqZVQYVaysMXFizEsslSOeyTHmiaGaSyf43QXbomphrUJKMptjSaUerVLK8VEvCBBKZHlgfe38UXMyk2Nfv5MGi4bOKgOCILCq1sTZyQB3r8xdtSLbrFXw4MY6eu0hBODRudxkQYST44X3ksuL9NlDdM8J5357mEqTmjKdklMTfrpmg8z44zywvpYVNSbS2Ty/OjFFMJHhs1sbF7yfIWeEKpOaUp2Cj2+sp9qsptqsZltLKX+7d4A+W4gas4YZf5xpfwKpBGYDiflq5H39rvnYtvctq+CnRyd4vc/JqhoTJyf8jLgivNrj4OxkgHqLlkgyw4Q3hkWnmI/TAxh2RTg87KHCqKTHFqKtXMf962oXJHZcQqeUsazKyPnpwLwF572Syub4waFxBEFgSYWeCW+MxtKCAE1n87ze66TapKKpVMNz52fZ1f5Oaki/I0JrmQ69SsbeHgd3Lq9kS7MFmVTg5S7H3GNd22aQy4uMuKLUlSyslr4ah4c9xNI5br8sXu3clJ83+ly0lesYckZYVl1Y+HSEkjSX/WEB/UaNnJU1hd/JmzvKuTATwBFK8uCG2usK7ktT5a0tpRw6NP0HPXeRIkWKFHl3bniBDAW7BHClIL7yNs9yDU+yKIpf//d4Xf87yYkiBwbduJxZPiKKCEIhtursZIBNTZYFMWVQELJmjQKLVoE3mmLGH7+uOOizhxh1R8jk8qRzeaZ8cV7ptvPFXS3XvM+KGhM72qy80eskmxexBRNEUhm8kTSZXB6FVGDEHUWjkM6L0lKdkrX1JrJ5+MrNrSTSOQ4Ne6gr0XBTs4WjYz7c4RSeSCE9wKJTEklmiCSzRFNZUtkcNy8p57Fjk4QSGQwqGbcvr1hQUXxoyEM0leOTm9+xCKxrKOHkuJ+LM8FrphhIBIEaswaLToEANJVqubWznGQmRyKdJ5HJUW5Q8mafk5e7HNSY1WgUUg4OFSa2Ugk8uKFQ+pDPizx1ZpqZQJyPbqhb4BMVRZFee4htraU8uKFuQX6uQi7lL29t4/sHRpAIAnlRxBNNMeKO8pfPdPGBVVW43Vlcfk/Bp7yi8B4/sq6W7x8YwRZMkMvn+dbeASxaBUa1nKVVeo6N+qg2qWmwaHjs+CQPbqijyqTmmbMzSCXgDCZptGr52Mb6RYtzl7OxyULXbIie2RDrrpNPfCUH+l0MOMI0W7VsbCph1B1ld0fBXnBsLvP3I+tqOD8dRBSZnzD32kKcmwqwp7OC7W1Wnj03yyvdBVF8e2cFOqWbg4NuPndT41Wf1x9L88TpaWYDCRpLNXzhOuU2oUSGY6NeVtYY54tbhpwRfnfeRkuZjrZyPcOuKEurDESSGcLJ7O+1oHcl29pKuTAT5O0RD+emAtSWqFle/Yf5u4sUKVKkyP9e/igE8n8G5FIJ6xvM/Hx4kvPTQdbWm9nf70ImEdjZbl10+0Q6x/4BFytqTYQThUKIL+1queYG/6FBDzP+OBadkjV1Zk5lfbzS7eCmllJW1F49hS+by+OOpFAppDzywGqemRMvglCIU1tdZyKVyTHuiRFIpMnk8xjVKo6N+akwqPjnAyPIpQLLqwzkRJGsCN+8Zxn/cnCU8zMBvrd/mPevrOK2zooFMVuvdNsZdEZQySVsarawo+2d9x+IpTk26mV1nQmtUsYvT0zywnkbn9naWPAVT/qvKZDHPFGWVxsxqAtRcveuqWZFzcL37gonmfbFEYQI6xtK+OKulrnJdh6pIKBWSBFFkRe7bPQ7Ity9smo+leMSznASfyzDzvayq5ZLmDQKPrS2hp8fnSAQT/OlXS3IpRKePjvLz45OQjrD53Yb+MCqd2wQJVoFd62o5Jcnppjxx0lmcpRo5ISTGU6M+RFFkboSDUsqDdiCSX59YhKFTEownkYqEWiy6vjk5oZ3PbJvsGgoNxQm5u9VIIcSGR47PolEEPj8toKQPTrqJZXNkcrmOTzsobPKQGOplmfPzdJSpqNEqyCUyPD8BRs1ZvV8vNzHNtZxZMTLgQEXI64IpXolI67IVS8Au2aCPH/BhkQQaCnTMeaJEk1lr3macmDARV4Uua2z4Oud8cf57akpKo0qPraxjsdPTVOqU1CmVzLsKhSeVJl+P//x5VQa1bSUFTzfAB/dWPeeGi6LFClSpMi/P0WBfIOQzOQ4NuIlkhZ5o89BqU5B12yIne3Wq4reA4MuEpkc96yqQhThR4fHeOL0NJ+7qWlRjq0zlOTNfiepbJ6d7WV8eksDuzrK+LMnLvD3rw/y3Y+sotygJJnJz03OCtOzw0MeZv1xpILA998axRNO4o6mqDGq+bsPLuPIsJfZQIJtbYU2u1W1JtLZHGcng7x/ZSXZPKypNzHqjvK78zaC8TT7B1383b3L+MYLvYy4IhwccDPoiLCi1sitS8pJZHK81uMkkcmytaWcu6/IwH3xYqFwoSSg4L+/0MPJcT/ZvMg39/bTUa7HrJVjDyYWJQ/k8yJjnijLqozc1llOjy1EZ9VCYRuIpfn5sQnMOgXf3LyM587b+NnRCf5kWyOZnIg9mKCzysBbQ25OTwTY2W69qhjvs4URBMjmRb7zxiA3tVhZ32BeMLntrDJi0sjpmi1YLTY2WdizrIJnz87yxNv9GNXyRTYIg0qGJ5wkmc6SE+HYmI+OCgOCBKrNWnzRFGcmA3xtTzvfenWAY6OF+LPNzRY+s7Xhmk1wlyMIAhsbLbzUZV8gSkVR5Nlzs/TaQgiCgFQiIBEKy32D9jA9thAWnZJ+e5hwMkPXTIi/3zuIRiklm89z+7IKxjxRAvEMezor5h8vm8vzkXW187+zgiCwo83Kimojr84lnQy7wjxxZpqv7ekACnaOl7scnJsKUG/RcP+6WuKZHI8cHGXIGWbtVTKt3eEkZ6cCbGm2UKJVEElm+NWJSXQqGZ/a0oAowrgnyrbWUgRBwB5KAL9/gsWVbG8tZdQdZVm1Yb4uvkiRIkWK/J+nKJBvEFRyKXuWVdI7NsOQM8pPjoyjkkvY3rp4euyOJDkx5mN9g3k+AeKDa2p46swMe3scvH9lFVAQhfFMjh+8NcKUL86aehNr6kwcH/MRSWZZWqXn8JCXzzx2mo4KPSr5O78u8XSWPnuYCoMKhUyKJ5LCE01TbVJRaVTy0yMTWPVK7lpRyYEBN9UmDbcsKef7B0e4bVkFe5a9EzFm1Sk5M+EnlMgQTmR59vwsX7+9nW++OoAApHN5emdD9NnD5PMi0/44uzqsPLihDqlEIJnJ0WcP8dagh9d7nVSZVLgjSca9MUr1Cu7orGTfQGERrdeeQS0f4W8/sGyB19MWTJDM5Gkp06GWS+msMnK5/oymsvz82ASZrMhDOwpxbzqVnB8fHuOvn+nGoJYhlUjY1FSwcqyuM80nFFxJrz1EQ4mGE6NewoksL3XZOTbq5bbOcpZXGxEEgUwuT16EeouGN/tddFQYMGrkfGxTPVPjIxwb87Gk0jCfDtI1E+TpszM0W3VcmAkw649jnmtSbC7TsbujjJ8cGafHFuLFLjupbB6pVCCSytJaXnjP75XVdSbe6HNyasI/L5D3D7jncpyNaJUycnkRUQRfLMXrvjhyqYTdHWWUG1WU6BT0OyJEUhlqSjTs7iijVKdkX78LtVzK0ioDJ8Z8jLqjfGBV1fzi5eWYtQo+vqmeUXeEfz4wyhu9hfvu7ijjjV4n3lia3R1l3NxR8DKbRBGjWk6//eoC+fU+JwqphF3tZYhioYAjlc3zJ9ua0KvkXJgOkBdhaWXhoskeTFCilb+ni4rr0VKm48Nrq2mvMLz7jYsUKVKkyP9vFAXyDcT6BjNLS6WcD6aZ9Mb42u3tV104e63HiVwq4ZYl5Zyb8uMIJYmncmRzeX769jiHhzwY1HISmRyBaIq3hj3IpRIsOiUvzaVXKKQCpVol1SYVsVRuLvbKwpIKA1qFlGfPz2LVKfnL29q5OBPkkbdGyOZFNjSU0GsPI5dm+G93LuHJs4V84Y9vqpuvfd5+RRatTCrhfSuqeOz4JMurDfTNFVbsbLPSYwuhU8oQBCjXK3lzwMXSKgOf3NzAqDvKxZkgQ84I2XyeSW+cRquGnW1lHBn2oJRJ+fxNjdzaWU46l8cfTXFuOsBrvU6C8Qx/dnML9RYtjlCSN3qdjHui7Ot38cy5GXJ5MKhlNJfqqDGrOTbmI5LM8LmbGik3qIimsvTbwyQyOca9UVrKdMgkAr85OcWdyyv50Jqaqx6XeyIpXOEUq2qNTPji3L++FrVcyuu9Tp44PcPbZi97OisIxtMkM3m+uLOZl7scPHFmmi9sa0IiEVhfIaUro+DZc7P82c2tnJ8K8LsLNhLpHFqlFJlUgkmtAAEC8Qwf3VCHSaPgC9ub+C/P9fDIwVEqjSp2tlupMWk4OuJDgrBgMe16qORSVtWaOD8d4M7lFYx7YhwcdLOu3swH1yyc6P/k8CixdJZVtSb+592d8z/L5Zn/PKFwwdVvD7O+sQR/LM1rvYUK6Sszv6+kpUzP331gGV99+iKv9Th4uctOY6mWv7iljY7Kd0SnIAgsrTJwdtJPKptbsGA44Y0x4IhwW2c5WqWME2M+hlxR7l5ZNb9Y2WcPY1DL5muvr3YK8YcgCMJVBXuRIkWKFPk/S1Eg30AIgsCWKhn9MSnRVHxRJi8UUgkGnRFu7yznwICbUxOFBAaNQkq9RUMwnsEWjLOsphK1TMJjJyZRSCV8cWcT719VjVYhI5PLU6pTIJFIODDgmo+f6rOFWV5tZNIXJ5Qo5Bur5BIcoQRTvjglWgUapYwvbG/i+KiXfz08Sjon8uktDchlEs5OBlhTZ75q8157hZ6OisIS1O2dFeztLaRQXBJjE94Ybw64KNEoaLFqeeTgKKlsHr1KxobGEpQyCftyLkwaOeenA8TTOW5dUs6dyyuRSATev6KKn7w9xo42K/sG3JyZ9POpn5+myqSm2apjwhdDKghYdAqWVRvQq+RM++MMzR3fR5JZ1taZOD7q47UeB1P+eKFspKWUj2+s5/FTU3TNBtEqZezprLhmHXOfPQSAN5LGoJaxvNqIVCLQWqbj4myQff0ufnZ0HEcwSUuZjjV1ZiSCwNNnZ9k/4OK2zgrkc1F+Pz48xrf3DjATSJBI52iyagsnBiL49Wm6Z0NIBOZ9xe3leupLNAw4whhUMj67tZFqk5qXuuwcGfGSzOa4Z2X1VRMsrmRjUwmnJvzsm6slryvRcM+qqgXieNgVYW+vC4VUwqe3NCz4WUuZjtd7nYSTGQyqQlV4Ni+yutbI02dmUMkl3HuVqLmrIUgELDolo54Y7eU69Co5L1y0c1denE8xAVhaWZhMj7ii875wURR5rbeQv7y1uRR3OMlrvQ7aynVsaioI10wuz4grwpp6M4JQOLHwxzK/15JikSJFihS5sSgK5BuIQCyNM5anwqgimcnxUpedW5aWz2/c5/Mir3Y7MGvkzAYS9NrDbG8tXTAZjKayPHJwlAlvlFxeJBDL0Fll4KEdLUgxM0CKAAAgAElEQVQkAhPeGI++Pc7qOjMfXlvDluZCnXGVSU0qm+fRtyeIp7JsbrYQiKX56tMX6bGFqTKpuW1pOfetrcWokdM9G+LIsIcv7W6hrVzP3h4HOVFcsFB3Je9bUck/7R/GFUlx29Jy3ux3IREEumeDNFl1KKVSFDIp9lCS5dVGVtYaaSrVkRNFvr13AHswgUwiIJdKaLJqeXBjHaFEhmfOzTAbSGALJumxhVDKJFhKNKRzeXyxNGp5Ap1Sxn1ra7h7VfX869mcF3ni9DS+aJrlNUamfHF+c2qKZCZPiVbB8moDMqmATCrgCCUIJ7LIJBJOT/j4wOqaq77HPnsYk1rObDDBbZ3l80JaIhFYU2dmebWRFy/a+OnUBDKpwFNnZrh1aTlr680cGvbQZC34VGvNhdf/eq+LmhI1d6+sYnd7Gb86OYVaKaNEgGXVBuyhJIeGPNy5vJI3+pyMeqKU6ZVIJAKv9Tj59NYG7p5r7Ds05CGZyXPf2prrJllAYcGswqDk1yemWFNv4mOb6hbcJ58Xef7C7Lwve9dlMYTwTu30mDs6H8FXY1bTZw9jDyX55Ob691QJPeqO8szcKUXrnJVkfaOFl7vsPH5qmmardn4S3FSqRS2X0u94p868zx5mxp/gQ2uqkQjw1JkZFFIJH177zgnAiCtKOlcQ21CYHgP/pgSLIkWKFCnyH5uiQL5BSGZy/PDwGKeH02xYouJDq6v51muDfP/ACP/woRUIgsCpCT8zgcLSXPdsiCqTikNDHs5PB6gr0VBj1lBjVnPrkjL++0t9JNI5FDKBT2yuRyIRCCczPHF6GqlE4NxUgLZyHStqTGxtLmX/gIt7V1ezt9uOI5wkkcnxao+TeDrL7nYrH91YR71FiyAIjHmihJMZLDoFnkiKaDLDqXEfq2pMWHSL/aSXKNUp2dpcypERL3+6o4mNjSUcGnIz5Ysz7onxJ9sbWVlTKGm43D/83NlZjs95ctsr9Ay5onxwTQ0lWgVPn5nBFkiwobGE25aW83K3g0w2j0Im4Ys7m3mttxDZ5vREOTTkobVcz5JKw3xld7ctxJJKA85QkkxO5L61NaysNRFLFawVXTMhnjw9w4Ajgkkjxx9L89tT0+zprFxkfwnG08wGEuhVMuRS4ao1yXKphFQ2z6amEjY2WTg57qPHFmJNvRmjWs7TZ2dpF/J87bluLkwHMWvlhRKJdTW8eNFOJJlBIhHoqDDwcLuVrz/XzZOnp6kxq/nXQ2MYVDK+vLuZ587bOTcdQCYV+MSmevZ0VqCWS3mt10kyk+NjG+uvm2iRy4sE4hlCiQzbW60YrhCz56cDHB/1oZBJ+MzWxkWT4CqjCo1Cyog7SqlOiTOcZEOjmSMjXjY2lrCk8vqe3FxeZP+Ai8PDHkq1Cr5ySyvnp4IcH/Nyy9IKvrSrZX7C/c8HRtjSXMrNS8roqNQz6IjMF8+80eek3FBIbnmz34U9lOTjm+oWiPM+e6Fd8lJusz1YaBL8tyRYFClSpEiR/9gUBfINgkouxaSW44zlEUWRLS2l7Ggt5c0+F4+8NYpZo+DpszP4oilUcilNpVokgsBsII4rLCGYyNDvCJPJiQw4wiTTOdzhJGatnPZyPYl0lidPT5PM5Hh4RzMvXrTzu/Oz5PMi4WSGfnuYc1MB8qJIs1WHLZigTK/ia3va2dH+znQwGE/zxKlpqoxq7lpexet9Tn57appMXrxqHN2V7Ooo48JMkFd6HDy0rYkxT5TjYz7K9Eo2NJZgVC+0Z5wc8/KzoxOU6ZV8dGMdz1+wsbrOxMpaE65wkouzwbkpemEpUKOU8fjJKTzRFEOuKF/Y3kQ6m+e587OMeqL8075htrSUYtYoeKXbjlQiYdIXp9mq5RNLKxYUp9zUWoo7kuATj56hrkTD5mYLr3Q76LGFePTtMb58c9uC19pnD5PJ5QnE02xptqBRLP7fLxhP028Ps23uNd/UWsrBOUtIOluI1dvnTCFVBXnf8ko+tLaGR9+e4EeHx3GHk6SzearNGu5fX4tOKeOeVdX84tgk33i+B0T4b+9bwpJKI722CL5YimFXhN+enuajG+rY3mZFJZfywkUbPz82wac2N1zV4w6wt8dBIp2jo1LPlD/OTXN/L4oi6VyeV7rtuMIpllUb2HaF5xwKdqFL0WtyqYBAId3DolVwx/Lr1ycHYmmePDPDtD/Ounozd62sRCmTclOrjJPjPg4Pu7l3dQ2bmy0srzGyr9/JsTFvIWvYrCaSKpSmeCIpvNE0n9xcz5Q/zpGRQrb05ekl+bzIoDNCR6V+ftpvDyUwqGTvacJdpEiRIkVuTIoC+QYhmc7yRr+TPIXEgq88eRGTRk4sk+OxY5O0V+jxRVPUl2h4cEM9gUSaAUeEW5dWEE1lmQ0kKNHIsQUTVBnV5PIirnCSdFbkO28OEU/nCMQz7Gq3MuGNoZJLOD0R4OJMiGVVBhpLNZydCnLvqkqUcinHxnzoVDJi6RziXHFJJpfn8VPTZPMiH99Uj0Wr4MJMgJe67Hx4bc2iZryroZJL2dNZzrPnbBwe8RBOZGko1eKPpXn2nG1+qUsURQ4Ounn07QlUcin/9c4lPH/RTolGwd1zKR37Bwr+1+2X2TpW15q4MB3kjT4nx0e98ykH96yqRiGTcGbSzyvddqKpHEa1jG0tpdy8tJxqk5pkJs+MP04qmyOZyZPM5HjkrVHCyQyf2FRPvUVLuUHF9/YN88PD42xoKGFj8zvisM8eIpsTUSukbG1eLBqh0NonAhsbC/FwBpWcD6yuZmtLKa/22Dl1dAJvPM/mKg0tZTpS2Tybmyx8/+AIOqWMtnI9H91QN5/1+8D6Wvb3u7AFE3zjzg4651rgtrWW8sJFO+sazJydDPDU2RkeXF9He7me5dVGnr9g4+ykn4e2N7O6zrTAPnFuys/xMR/b26xIBHh7xMvREQ8nx/2YtQoaLBrOTwdRyiR89irT40u0lOnoni0UgWRyeRIZ+NSWhus29PmiKX58ZJx0Ns+DG2oX5FQb1XLWNZg5M+lnd3s5Ro0cnVLGvatr2Nho4cCAi15biF5biCdOT5EXC2UwDRYN3z84SolGwftWVC54vnFvjHg6x9LLJtr2YIJKY3F6XKRIkSJ/zBQF8g2CIAio5VIEBGzBBO5Iio2NJXxxRzM/OzbOgD3E0mojf7qzmVPjfvyxNHcsq5if3p2e8PPdfcP4Y2m2tpTSbw+zps7Esmoj/fYw6WyetjIdiXSOV7odaBRSdnVYGXXH2NpayoA9zKAzQrctTEOplv/x/k6G3VHeHvGSSOf4wKoqXrhgYzaQ4BOb6uejuarNapLZPFdqpCFnhNd6Hdy9smo+quwSa+rMHB3x8sjBUZbXGPnuR1byv17u55mzM2xrKaXRquW5c7OcHPeRR+TTW+o5Nx0kkszw8I5mVHIp9mCCXluYmzvKyIuF4hS5VEAmLSx/XZgK0G0L0WMLYgsmuLmjjF3tZSytNPCjw6PEU1nay3XYQwl+eXzqqt+JI5jg/HRgLlYuxWwwQaVBxUPbG/nBoXH+9PHz/MOHV3LLkjKiqSzj3hjJTI4VNcarXixkcnnOTPpZWmlY1IyoV0npt4cRBIEKrYA7kuL7B0ZRK6Sksjlc4SSKueQSnUo2f9Eik0r4f+9biS2YWNA2uKbezP4BF8FYmlW1Rl7ucnBw0I1Vp0QQBBotGvodEf5x3xCrak1sb7Oyrr4EZyjJCxfstJTpuL2znFMTfrptQWYDCdordAw4wlyY8uONplhebbxmKQtAy9z37gmnkMsk3LG84rptj5Fkhl8cmySXF/nizuarfobbW62cnvBzZMQzH2cIhbziT2xuwBZM8O29A7zR50KrkPLZmxp57ryNcCLDQ9ubF4nzPnsIuVSgrVw//x15IqkFgrlIkSJFivzxURTINwhKuZS/3tNOz8ULiKVNHB72MOKOUl+iIZeHWCZPo0XDm32FPNjPb2uica7eOJPL02ML0WTV8r7llbzYZWPCG2NXRxl3r6zi7VEvOqWM//vupSikEv710BgdFXpuW1rOc+dtPH1mBqkgwaRR4Iqk5iO02iv0qOVSDg666XeECcYz3N5ZztK5ZaZUNsegI8LqOhNDrigz/jg1ZjUHBtwcGHQD8PwFG1+5uXXRUpggCISTWRotWmrMGr5x5xK++Ph5vvlqP6vrzHgiSTQKGUsrDJTqlLza42RPZ/m8wHqz30k8lWXIGZl/LijUQSukUkREJr0xvvF8LwqpBKtOiTuSQiYRkAgS6ko07GizolbIUMklqORSVHIpSlnhz5lsjr95vodmq47HPr0eo1bBkDPCE6enUcgENjaVcG4ywN++3MeUL0ZLmQ5/NF2YHrdcfXrcNRMkns6x5QpRGUtl+dpz3Qw5I9y9ooqVcjtL1qylzxbi4ICLA4MecjmRWC7Hr09OcmrCR5VJzdLKQvlEvUUzv2AGhfrlIWeERCbHU2dmWFJlQCGTEIilabbq+NzWBsoMKt7sc/LCRTueSIqXuxy83uvAE0lTV6JhQ6OZHx0ZnzuZUFCqV/AXt7Tx8G/OMeaJopRJ+MwVyRVXYtYq0Cml9NuT7OmsYGdb2TVvm5w7KYkkM3x+W9M1TyPMWgVr6gpT5KuV6FSb1Ny/voY+e5jaEg0HBtxM+gq11VfmLYuiSL8jTGu5ft6P7QwlyYv/9oKQIkWKFCnyH5uiQL6BWFtfQmRCyo4tDXRWGfnn/cP86Mg4UomASS1j/4CHu1dV8aXd71RK5/IiT56eZswT4yPrapFLJRwcdFNlVJNM5/jG872Y1HLKDSp+d95GuUGJN5rm6KiPMU+MrS0WHj0aJ5HOc+vSMuLpHEOuMDUlGiZ9MQLxNNFkhtMTfswaOScn/EwHElQZVbjCSXzRNF/c1cRz5208c3YGs0bBsDvK6joTy6qM/PrkFG+PeBekHOwfcOMIJbm5o4wxTwxvNEVDqZb719fy6xNTSCVB7ltby9ujXtY2mNnX76LZqmVHm5VkJsdrPQ6ePjOLVa8kls5y29JyFDIJ6WyeVDZPOpcnldEzE0gw6YvRaNEWkiiCCRyhJL5YmmarFpNWwa72xaJNFEW+88YQ4USWr9zcinFu2tteoeehHU388vgUarmUarOaUCLDc+dm0atkJDJ5drZbaSvXXfUxj4/5qDCo5i9sAPyxFH/1TDfTvjgPbqjlszc1cviwg2qTmjK9knNThQl2R6UBq07Ovn43gXiGWDpHnz2MUibBqC5YDawGJRIgmMgChal0hVFFo0XLn+5q5u1hLwcG3ZwY93PPqkLFdySV49xUgPUNZl7pdjDhiWEPJuh3hGkr1/OhNdWo5VJ+c2qa03M+6WA8w+YmCxubrj09vvSeNQoZ7RV67l9fe814uWwuz29OTuEMJ/nk5obrTpkBdrRbOTcd4Niod957fjn2YBKpRGB7ayl99ggi4I6k+H/eGOSmllK2NJeiVkiZDRSSSTo7F9oroCiQixQpUuSPnaJAvgERBIEKg2ouFitEPJ3DoJIhl0IwlmLWnyAnxgnGM4y4IwzPlR4sqzby3TeHyOTz7O4oKyz9hZ3oVXJyeZEjwx7yeZG75m773LlZvvG7HmLJLFqVDBGQSQQeOz7FqYkAKrkUnVLKxkYLjVYt9SUFYecIJTg6WliK0iikPH5ymng6VxCARiWf3tLIns5yFDIpy6oL1cwra02UaBX0zIbmSyduWVrG9/aNsLfHwSc3N/DhtTV0zQSRSyX0O8KUaOSMuaLIpBJuXlLOK92FeuHu2SA6pYw/v6WVlTWmawqv9go9n/r5aXQqGV/e3QrAk6enMajlNFg0HBxws6zKuGiyeGbSz+FhD51VRu5YvlCAVRrVfHFXM784NsGEN4ZZoyCRzuKNppBKBHJ5kVQ2v6iBbdIXxxFKLijamAnE+JvnenGFkzy0o4n71tUuuM+BARenJ/w0WArFGOUGJWWGQlTarUvK8EbT9NlDuCNppvxxemwhTBo5mxot3LO6imarjr09To6PeYmncty8pIxsXuTwsAepROCuFZXcu7qaSCLNr09MkcrmqbdoyObzc2kbOZzhJFubS9EqpPzy+CSRVBapRGBZjfFdM4yHXBHckRQfWFV9zXSTfF7kqbMzjHli3LeuhvYK/XUfEwppKCtrjJwc97O9zbpgGdITSdE9G6Kz0sD+ATdNVh1/f/tyUtk8Bwbd7B9wc3TUy9bmUmLpLBIBOi57TnsogVouxawpLugVKVKkyB8zRYF8AyGKIqmsyLFRD0+eLmzxK2SF5rRkNk8inePgkIdhd4wlFXoQBFRyCe9bXsnmZguHhtzMBpOY1ApKtAqGXFEe2t5Ek1XHaz0Onr9gI5TM8IE1hcIQf6wQSyaXSlApRI4Me1leY6REq6DCoOKzNzVSqlPwRp+TPkcYTyRNY6mGm5eU44kkiaay3Lq0nElvoWktL4r4Y2kODXk4Oe6jTK/CqJbjCCX5+dFx7llVzbPnZuZLJ2RSCbs6yni918mwK0JbuZ4v7W7hW68O4IulWV9votsWpt6i4advjyMRCgK1xqzhvnU1rK4zX/fzrCvRYFDLsQUSjLoi1JRo6HeEWVtvZndHQZw/f2GWP9nWNC/2ArE0j749gUIq4eEdTVctBDGo5Dy8oxlnKMnJMT+CIBBL56gyqfBFU/zLwRE+sq6Wess7k+LjY17Ucikr55bOemZDfGtvP6FEhq/c0spdK6oWPIcjlOC3p6ZRyCR8amsDFXNLY/eurmbKF2fIFeXhHc3cL9RiDyVJpLOo5FKOj/nomgnyi2OTrKwxsarWxIlxL2+Perl7ZRV7OsvJ5vMcm4toW1NnZjoQZ8ofR6OQ8pmtDdy9qopQIsORYS8nxny8PexhxBXFF0sjkQg0lGoJxNIk0rlrpmDk8iJ7e5xYdYprTppFUeTlbju9tjB3Lq9gzbt8n5ezs72MizMhjo/6uOWyyu83+pzzOdkvdYX55JaGeXH+iU312IMJDg6+YwFqtmoXCGx7MEmVSfWeCkyKFClSpMiNS1Eg30B8+7VBzg2lCHX3k8zkCCcy6FUy7lpRxZQvPnfEnSOfz7Os2sAH19TOC5RIMsOhIQ9SAVRz+bPNVi23LCkvNM2trOTiTJAZf5wfHhpDIowx7U9QqlOws60MZyiJJ5pEAD6wupqLM0EEAbpnQxwe9rK+wUyZXsXRUS+/PD7JiDtKR4WOdDaPLZjkjmWV3NZZzg/eGqVUr2RVjQl7MIEjnCCby/Nqt5O9PU50Khl7DCre7HdRYVTRVKqhRCPnlW4HX7lZR4VBRSCeJp7O4QzFMagVhdrkNisbG0t46uwMlUbVfArE9RjzRGm26pgNxPnVySnet7ySTE5kVa0JvUrOncsreO68jdMTfjY2WRBFkd+enmImEOf9K6oWVBlfiVIm5eu3d/DlJy4w5o6QzYmIIqxtKGHSG+PHR8bZ2Wbl5iXlRJPZ+Wg3uVTgrSE3Pzw0RjKT46u3tnPrZQIPIC+K/OjwGO5Iik9vaVggHPUqOfeurubxU9O8NejmlrkEjkt8ZJ2G25aWc3TUy9nJABdmgiTSWQ4OuNg159l93/JKvJEUvzg2yZOnpwtLjEvKMKvlDDkjhBNZyvQqPry2hvX1Zr792gDhZBYREalEwpd3t3Bw0MPpSf81i2FOTfjwRFJ8cnP9NVsH3xpyF6bAraVsa333iMDLKTeo6KwycHzMx02tpajkUqZ8MfrsYdbVmzg14ceslaOQXpHPbFLz8U31OEIJjo/6WFX3zmJjLi/iDCXZ9C7WkSJFihQpcuNTFMg3EFadklRWxKiTo1dJqTap+c59K6gr0SKKIk+dmeZ7+0ewh5I8f8HG0irj/BR1X7+LRCaLIAiEEhkarVoe2FCHRCKQz+d57rwNq17JAxtq+NGhcUbcUXRKGesbLGTyIlqlFFcEjo54GXZFMKnlfOf1QUKJDLUlGjY2llBpVLO52cJTZ6bn47vOTQXZ3VHGgxtq0ank3LG8kjf7XNRZNNzWWci7DcbTfO6xs/hiKW7vrEAEToz5yM6VOYQSaWb8CRLpLKJYOCYPJTI0WLR8aVcL6xtLkEsljLojTHjjvH9l5XVLLi4x6o7SYNGgV0oZcUV4Jp2j3KCkbs7jurbezMWZIK/1OumoNNBnD/H2iI8as4YPr7t6U97lmDQKbu8s53uOMGqFlHgqy6tddh7e2YItmOCtIQ89thDBeIYZfxyZVOBfD41xcKDQIPjnN7eye0n5osc978px0uFnbYOZD61d/DqWVRtZXWvirSE37RX6RZ5dk0bBXSuq2N1RxslxH/v7C5XkX3+2mw2NJYQSGezBBIFYCmc2z+2dFfz5rW1EU1l+fHiMx45P8PCOZtLZPE+dnaHCqObLu1t5/oINgFuXVjDli3N8zMvWZsuiBcxEOseBATfNVu0C+8LlnBr3sa/fzeo6E7cvu34u8rXY1VFGn32UE+M+drZZea3XiVYpZcIXw6RRsLlRRb8jwvarLAdWGtWLPltPJEU2LxYLQooUKVLkPwFFgXyDkMzkGHFHyIrQbtEQTWW5Y1kldXO+X0EQuH99Hc5wiqdOz2ALJvm/Xuzlf92zjDK9kuNjPhRSgUFnCJNGQalWwVNnZgjG04y6owy7ojRZNRwc9GBQy1lWbeQL2xqpKdESThYa04KxNHt7HJybCuKNpOizh6kwqtCr5Dzy1hhKmYQGi4YjIx5kEoHGUj1lBhWBeIbvvDHE2oYSNjWWcHE6yEsX7TTdokMhk3B42EOlSUWJTkFLmY7bOivIz+U0DzkjDLnCOENJXu12oFYUClMUMgm3Li1jy1wihCiK7Ot3Y1TL2dCwuKHuSkRRZMwTo71Cj0Qw8Nz5WS5MB3hoe/P88bkgCNy7upp/PjDC4yenGHVHyOTyhepi/XsTSaV6JZmcyPoGM6FEhkFXhF8cm+Cv9rTTUaHn+JiXI8MeZFIJjxwYxR4qLJB1VOi5OBNk2h/HrFVg0Sop0SqQCPDaRIbSEi1fvaV1QaPg5bx/ZRXj3hjPnJ3hS7tbr3rBoJZLWVJpIJXJ0+8IcXLCz6AzQqVJxe6OMkSgaybE0mrDfIrHJzc38Ojb4/zgrdHCVBz4/LZGaswaOqvfKdjY1mrlseOT9NhCi6wubw25SWRyvG9F5VWtCr22EC922Wkv1/GhNTV/sJ2h2qSmvVzHsREvZo2cKV+ccoMSVzjFZ7Y2MOOPc2DQTSSZeU+lH/ZQYv5xixQpUqTIHzdFgXwDIZNIaDFJaLBo8cXSC7yVUBB0f7a7hRFXlD57iEgyy/98uQ+JIBBNZUmkc8TTOSqNatyRFCaNHINKTjCeocKgpNmqI5zIYNWrWFFjZEd72SJxcu+aGv7lwAi/OjFFXhTprDLwxZ3NBBMZJr0xnr9o4+J0EKteiUYpo6FUi1mjwBlKcGrcy8lxH5VGFePegtezRKvg5JiPba2l2IIJHj81zaAzTDiRxR1Jkc7lyeXzqBUFr7VKJqHMoKSz2ogjnMIbTVGqUzLkijDtj3Pv6upFE8ur4Y6kiCSztJTpKNEqebnLTjYnMumLkc+L84t9Fp2SmzvK+Md9w2RzImvqzdxylanutTg3FUAhFSjXK/mbOzr46tNddM0G+d6+Yb5x5xLW1Jnpt4dRygQmfQlay3VsbrLQbNXhj6fxR9NM+uKksoXPYdAZIZkT+Ytb2ii9jkhXK6R8eG0NPzs6wRt9zvlMYFEUsc1lRPfZQ3ijaQQBtjSXYtaE2dxkIZnNM+qOIZcWsonPTgbY2lyKRaektkTDLUvL+darA5i1Cv7xvpVXTXRoK9dRpldydMTLqlrT/O+RL5ri+JiXtXVmKo2L7zfuifLUmRlqzRoe3Fh3TfvFtRBFkXAyiyeSxBVOkc2JnJkKMOWPU2FQ4gwl2dJSSlu5Hr1Kxv4BN4POCOvfw0WVPZhALhUovU5depEiRYoU+eOgKJBvEFRyKQ/vaObgUTdDoSR3Lq+Yb0u7HIlEwldvbeW/vtBLMpMjmswiIrCq1sCp8QBbWyzc3lmBO5LCFkww7ArgjqRYWqlHo5DRWqan2qxmdZ3pmpO7SpMKi05BKiOlezbES112HtxQx6Ajgj+aZlWtiT/d2YwtmGTUHaXXFgYKvtxcPs+AI4wrnOSf9g8RjGcRBDg/HSCTE/HF0gw6w1Sb1GgUMtQKKWq5jBKNEgEBVzhJMJ7FHkww6o7xw0NjPLC+ljd6nZRo5aytf2+LXKPuKADNVh1GtZxUNk+pXkEgnuHYmHeB5zUriiTSOTLZPLcsKbvm4tmVZLI5To37aSvXkxMhkcnz7Q+t4OvPdnNhOsg3X+3DqFYw4Y1h1SkpN6i4Y1kFty+rWPDZF0Rfhp8eGSecyLDLmmTTdQo4LtFSpmNLs2W+qtsXS9NrCxGIZ5AI0GTVsa3VytIqAzqljB8fHiOQyPCXt7Yx6YsBYNUXmgFfuGjns1sbmPEneGvQQ0eFHkEQODbq5cNrF095BUHgptZSfnfexrg3RvNcKcjrfU5kEgm3di6+yHCEEvzqxBQlWgWf2lJ/3Ua9K4Ww+9J/wykSmdz87TQKKaVaBbl8Ydp96TMGqDCoMGvk9NvD70kgO4JJKoyqa6aiFClSpEiRPx6KAvkGotqs5oI7R129gs3XWRRqLtNze2cFL3bZUcgk+GNp3uhzoZBJUMqkHB3zUa5XUW/RMuNPcPfKKr64q/max/WXc3rCz7mpIB/bWEfXTJBBZ4SzUwGc4RSBWBqLTslf3trGirnWNnEuuWLME2PcE2XMU/A2RxUynMEkWoWUtQ2FaWKZQUkwlubCTJC7VhSi5goCWTrXIihyYtxPpVGFPZTguXOzHB3xMOWLM+2Lsa2tlBNjPlrnppfXO5ofdUcp1SkwaRQ4Q0lUcikSQUqNWc2+fhedVYW0DkcowYF+Fxatglg6hyeSes/f1+klQ0YAACAASURBVMFBD9FUjs9sbWTEHeHoqJeHdzTzV3va+N6+EfrtEeRSCVUmFUaNgp3t1kXiuPAZwstdDnyxDA/taCY03vWeX8OezgpGXBFeuGhHKim01928pIwllYYF6QwA29us/OrEFN220ILFvz2dFbzUZWdvj4MzkwF0Shlf3t3J+ekA+wfcGNRy9nQu9gmvqjXxZp+ToyNemq06Jrwxem1hbltajuEKS4M/luYXxyZRyaV8dmvjotf2zmch8uJFO92zoUVCuNygnGspLFxslBtUaBVSxr0xHn17AoD719fO/54LgkBnlZGT4z6Smdyi6L0rn9cWTLD6sqW9IkWKFCnyx0tRIN9AnJrwEUqJ3LGscpGNIJTIMO2LM+mLMeWLMeGNEUlkkEkLRRHhZJZas5p7VlWxodGCQibhhQs2LDoFH91Y957E8ZQvxktdNtrKdXxsYz1VJjX2UBK5tOCZHfdEMWoULLvMiyoIAhadEotOyYbGEkRRxB1JMeaJYgsk2NletiBnOJ8X+cFboww4w9yxvGLRFPFSoUihyc/AP83VZzdadWjkUl7tcUAPGFQymst0tJbpaCnTLfCY5vIiE97YvNi5OBOYF9QVBiWeSIrnL9j45KY6njk7iz+eodaiYVmVkfPTQVbXmWgpe/c83r29DtRyCXcsq8A6peSVbgcz/jjbW63M+hO83GUnk8tTaVSztaWUu67iyRVFkRe7bPTZw9y1opLVdWYOjb/rU8+jkEn49NZGZgNxWsv0151+d1ToKTcoOTLsYfVltoiNjSXs63fyg7fG2Nlu5Qs7mjCo5OzuKCM8l45iUMkX1UrLpRI2NVnYP+DGFUqwt8eBUS1f1CQYTWX5xbEJsjmRh3c0YrxOxvDxMR+nJvysqDFSb9FQpldRblCiU8queUHUVKpla4uFKpN6kR1kaZWBo6NeRlxRltcYr3p/KAj4VDZ/VVtIkSJFihT546MokG8QUtnC5n+lTkJHhQ53OMnkZYLYH8sAIJcK1JVo2NNZQUeFgRF3hJlAgiqzmvZyA6/1OpFKJDSWajg96WdLs2VREcbVCMUzPH5qGrNGwQPrC+kXu9rL6JkN8VqfA2coSTonsrPdet0jaEEQ5qd7V0MiEbhnVTU/PDzGwQH3oiKOy6k2qdEqZfTZw/zdB5exqtY8v3Q44o4y5IxwYToIQIlWTo1ZQ41ZjSAIJNJZmq068nmRCzPBeXE05Ipy29JyXu528N19I7gjKRRSCStqTDywvpbvHxiZq8duu25ShiOYYMgZYXOTBaVcytr6QuPfsVEvD2yo40Nra3CGk3ijadbWm7lnVdVVBd6+fhenJwLsbLdes6L63SjRFnKv3w1BENjWauXZc7MMu6LzpRz9jjCBeBq5VKDGrJ6f/gqCwD0rq4kks7zcbUevki24OALY2GTh8LCH356ewR1J8ZF1NQs+t2Qmxy+PTxJKZPj8TdeukAaYDcR5rdfB0ko9D6yvfc/Le4IgLMqRvkR9iQatQkq/I3RdgewIJQGKCRZFihQp8p+EokC+QZBLJGTzeabDOf7i6S5EseBLNqpl1Fu0bG4qpd6iocqknl9siqezfHffMIpwijuWVXL3yiqePjvDS112EuksJo2C3R2LI66uJJPL85tTU6SzeT5/U+P8FFIiEfjUlgbOTwc4Pu5ja3MJq2r+7UfQdRYN6+rNHB31sqbefE0xnc+LJDM5pBIB2dx7NmkUrGsoYV1Dyfyx+Lgnxkwgzow/TvdsCFsggT2UoMzg5O0RD/9fe3cWXNV153v8u87R0TzPA0LiSMwYjADbgAewIZ46Uxlwd3U7ZacrcKu6qyvVVW0q9+G+3IcUqb4P3bf6VuFUnHSn0okDiSudlJNmiIcYiG0kD2BGDYAEmgc0z+s+7H3EQToaEEhHw+9TpZK09z57ry1tHf332v/1XxUNnTxSmEp2YjQXaztIivFRlB7HL85WsyQlhvyUWF5Yl43P6+GbG/P44Z+qOHGxnhcmCN7/6/NbDA1bXlzvbBPt87KlMJXTFU083z1AUqyPV7cVcrm+g8eWpYUM9k6XN/Hu5Ua2FKbwlTVTHxh4PzYsSeL4hXrev+KUiCu70crR0hpWZCWyY2Umf65soaqpa2Q6bI/H8PKWfH70YRW/PFtNd7/z++gbHBqZ2ntw2HKktJpVWQl8eqOVj6pa3HXOoNH+wWFe2VrA0rTxp5DuHRjiFx9XEx/l46UQOc/T5fGYkRJ+g0PD4w7wvNnWg8cw7rUoIiILy+TP1WVOCEzKUdPplD/rGRhkYGgYC3T0OoPWrtR38EVNGzeau+nsGyTG5+XplZnkJsew1Z9GtM/LK48VsDIrnnM32+kZGBqpNTweay1vl92kprWHfZvzx/TwpcRF8p0n/PT0D9LSNcDnNW0MTbLPqXhuXTbRPi+/+ewm1obe36fVrQCszkngdEXzmPXGGJakxPLkigz++tECXn9uFf/zhVUsz4pnXZ6TY3ymopkbLd0c+7Ken39yg4rGTv7jzHXaevpJjfVxo7mb3OTokdnW/BnxPLLMCd5rWrtDtqurb5APy5vISoy6q1dyW1GaU+O5sglwKmRsK0oP2eP+6Y1WfvtFLWtzE/nGw3kPLCCcTITXw+PF6VQ1dfObz25ytLQGf3oc3368kOfWZZMS6+PtshoGh4ZHXhMV4ZR/S47x8fanzmt++3kt//1lPR9caaSmpZvu/iEwzkDFCI8hJdZHQWocG5Yk862thazKHn/SFSfv+CYt3f28vCV/3Pzk6Vqbm0jvwPDIwMRQbrX1kJUYPaVUJBERmf/UgzxPGGN4a/9W3nv/fdZtepjmzn6au/po6eqnpaufyqYuPqtpIziWjHIfZS9JiRmZLMJaaO0eYHNBCpFew7+9W87fPFowZjKJgFPlzXxa3cZX1mSxJjd0EPPEigwORa/n/SuN/PJsDccu1PNEcTqbClMmrEQwkbioCJ5dm83bn97ks+q2MbV0B4eGOXmxgfzUWNYvSeKdc3XcbOuZtEZtZISH3oEhnlubzdOrMrne3M3TqzLZuDSF6tZuuvqG+LS6lfVLklmXl8SF2nZn6ua6jpGUg+fX5XCproNfl93k73YWjylF9lFlM02dfXx1Q+5d558SF8na3EQ+rmpl56rMcX82l+s6RgLTl7fkz3rVhC3LUvjjJWcWu1XZCXflqH9jYx4/PnWN96808kxQubv4qAj+/unlNHf1ERXhdQeEeujuc55iJMb4yEmKZv+T/nsOMstutPJZ9W12r8kc6bl+kIoz44n0Gr681R4yt9xay622HlZkTZ53LiIiC4MC5HkkMsJDpNeEHGwETipEa7cTMLd09tPU1c/t7n62Ft3JXf3kWgsNHX18a1sBqXGR/PTMdd74oJJvbMwbUyLtan0H75yvZV1eIjtWTjzV78alKTycn8ylug4+uNLIb7+o5eSlBrb609halEZciJJ0k9lSmMLZ6y3OTHbZiXcNMCu93kpr9wBffziPgrRYTl5s4FR5E/s250+4z2tN3QxbKM6M41JdO32DwzyxIoOijHg25Cfz6LI0/s+xy+Qmx1B7u5d/eHo5pddb+c+PrvO3j/tZmhZLtM/L1zfk8dM/X+eDq43sXHknTWVwaJjjF+uJ8UWEnJL4ieIMzt9sp+x625hBbQA3mrv52UfXyU6M5pWtBWHpsYyK8PLVDTncauvl2bVZd6UdrMhKYMOSJN673Mj6Jcl35a9HRnjGDGI7frGBYQuvbS/kaKlzszOVkmoBjR19zqQy6XHsCDHj3YPg83pYnpXAhdp2vrZhbC54e+8gnX1DmiBERGQR0fPCeeR0eRMN3cPjrvd5PWQmRLMqO5Ftxel8bUMur2wtpDjTqUHbOzDEiYv1+NPjWJOTSE5SDH+3s5iCtFiOltbwuy9uMeymRzR19vHzj6vJSogOWec2FGMMq3MSOfBUEf/jKb8TuF5q4Ad/uMRvP79Fa1f/PZ2vMc6Avc6+QY5frB9ZPjA0zB8vN7A0NZYVWfFE+7yUFKTwRU0bHb0DE+6zvKGTCI+hIC2Oz6rbSIrx4Q/qlcxIiGJZehy1t3vJS45ma1Ear24vJCHax7+fuUZDuzNYa01uIuvyEvnjxYa7Sr+du3mbmpYecpKiWB0ibWBpWiz5qTGcrmgakzpS397LT05fIynGx6vbCycsOzbTNi5N4cX1Y6ulALy4Pgef16mCMl76CzhpCWU3WtlWlEbJ0hRyk6L58OrY8x7PwNAwP//4BhFeD/tmuCd9TW4i7T2D1LT2jFlX686gl6MAWURk0VCAPE/0Dw7z/tVG3qkc4MenqqhuCZ3/OpH3LjfQ1T/EC0HlxOKiInht+zK2FaVxqryZN09V0drVz0/PXMcYeGXrxBM2jKcgLY5vbS3ku7uWsy7PqTX7z8cu88tPqqlzKwJMRV5yDI8uS+XPlc3canMClU+qWmjvGWT3mqyR89hWlMawhY8qWybcX0VjJwVpsfQNDnO5roOH85PGBP+P+tMwBv5ivdObmBDt49uPL8PrMbx56hq3u50g/GsbcvF5Pbz9aQ3WWqy1nCpvondwiJKlKeOWVHu8OJ2mzn4u1XWMLGvt6ufNU1X4vIbXti+b0tTH4ZIQ7eO5ddlUNnVRdqM15DbWWt45V0usz8sOd0bGx5en09DRx5X6zikd5/fn66i93cvezUtIipnZn8fq7EQ8xqnYMVptm3O95iRpgJ6IyGKhAHmeiIzw8I+7V7Apy0tNaw//770KfnKqatyBYqO1dPVzqryZjfnJYx4Vez2Gr27IZc+mPK43d/PPxy7T1NnHXz2ydErlwSaSlRjN3s35vP7sKrYVpXOhtp1/OXmVn5yqorKxk4Gh8XvEA76yJpu4SC+/+ewWfYNDvHelEX963EjPOEB6fBSrshP4qKp53H129g1Se7uXosx4vqhpY9gyJrcZnEoO33t+FYVBPcupcZG8tr2Q3oEhfnSqiu7+QRKifby4Ppuqpm4+rmrhRks35Q2dJEb7eGiCah7rcpNIivFxqrxppF0/PlXFwKDlte3L7vtnPhu2FKZQkBbLO+fq6OwbHLP+Ym0HFY1dPLM6a+RGYf2SZBJjIvjT1cZJ9//lrducqWjm8eL0CQfwPSgxkV6Wpcdx4dbYAPlmWw/p8ZFh7dEXEZHZpQB5HomK8PJQRgT/9OxKvrI2i+rWHv7t3Qr+48y1kd7V8fz3l3UYA18JMeNZwKaCVPY/6ScjIYqvbci9KwC9X0mxPl5cn8Prz61k95pMalp7+OGfqvhfv/mS//27C/yrGzT/uqyGkxfr+eRaC5frOqi93YPF8vy6bG60dPPmh9fo6HV6j0fbVpROZ98QX9S0hWxDhTu9dHFGPJ9Vt5GTFLoec6DXeLScpBi+tbWA1q5+fnL6Gn1uT3FRRhy/P1/HsS/r6eobJD0hitU54w/o8ngM24rSqGh0JnT599PXaOsZ4FtbC8ieJ72Uxhi+uTGPvsEh3jlXe9e6waFhfn++lsyEKB5ddiff2OsxbCtKp6Kxa8Lrta27n1+V3mRJSgzPhpiSeqasyU2koaNvzGyJt9p6Qub8i4jIwqVBevNQtM/LzpWZbPWncaaimT9dbeL//rGcNbmJ7FqdOWag1I1mp/7vM6syJ31UnZ8ay3d3rZixtsdGRvD0qiweL87gYm07LV393O4ZoL13gPaeAW7d7qWjd2yPZITHmcnvcl07O1dm3tW7G1CUEUd2YjSnypspWZoyJnWivKGTGJ9TYaG6pYcXHhr/ZmE8/ox4/vKRfH720Q3+86MbvPJYAd/cmMe/nLxKZVMX0T4vRRlxk6ZIbClM5Y+XGnjzwyqGreVvHisIeU5zWVZiNE8uz+Ddy42ULE0ZuaH6qKqFps5+Xt1WOCZv+JHCVN691MCH4wyoHB62vPVJNcPW8vKW/HHrEs+EtTlJ/PbzWi7UtvNUgjMotad/iNbuAR5ZNj9uXERE5MFQgDyPRfu87FyVydaiNE6VN/FheRP/equddXmJPLMqi+ykaKy1/O7cLRKjI3hixfRmYpsJkREeNuSHTkMYHBqmo3fQDZoHR4Ln/JRYjl+op66jl9auflJGpSIYY9henMavym5S2dRFUcadHnBrLRWNnfgz4jhXcxtjnEf+07E2N4lvbszj12U3+VVZDfs25/PcumzeOVdLZISXtbnjz8gWEBPpzK53uqKZvZuXsDpn5tMIZsLOVZmcu3mb33x2k394ZjkDbvm94sx4VmSNfQIROO8/Vzbz7NrsMTdsJy81cK25m32bl5AeP/kMjw9SUqyPJSkxXLjVzlMrnAD5ljtATxUsREQWFwXIC0C0z8szq7PYVpTOh+VNnCpv4vzNdh7KSyInOZrqlh72bMqbdk3i2Rbh9ZASFzkmAAb42sN5vPFBJW+eqmL/k/4xPbUb8pP5w/k6Tpc33RUgt3T109o9wBPLnZ9RUUb8fQ382lKYSmffIMe+rCcuKoIXH8qhb2CYYxfqWTPFYPf5ddlsKUydN2kVofi8Hr7+cC4/+vAa715qoH9omN7BIV58KGfcyifbi9M5U9nMmYpmnlt3pxe/orGTdy83sKkgJWRu+GxYk5PIsQv1tPcOkBjtG0kFUQULEZHFRTnIC0hMpJfda7J4/bmV7FiZwZX6Do59WU9uUjQlYQo4HrTspGhe3VZIe88APz51jZ7+obvW+7weHvWncbGug+bOO7mk5W7+cbTPS0vXABuX3v+U2DtWZLC92Kn+8d6VRi7WtbMkJSZkYB9KhNczr4PjgOLMBDbmJ/PB1UbOVDSzpTBlwvNKHZkwpYW+Qef319k3yC8/qSY9LpKvbhh/Cu+ZFpgM56I7WK+2rZfEmAjip1HHW0RE5i8FyAtQbKQzC90/PbuS59Zls29L/qxNVTwblqbF8srWAho7+kYGywV71J+Kx8CZyjvTT1c0dpEU4+N6cxc+r5lyL+9EjDG8+FAOD+cncezLeqpbesadbXChe2F9DlERXnxeD7tWTz6w7oniDHoGhii93oq1lqNnq+nuH+IvH1ka1icdmQlRpMdHjpR7m8rsjCIisvAsiADZGJNsjDlsjDlijKkwxhw3xpRMYz9+Y8wh9/X338UYZnFRETy1IiNkpYb5rjgzgZe35FPd2s3P/nyDwaDSbonRPtbnJXP2Wiu9A0N38o/TYzl3s521uYkPrGSXMYaXSpawIiseY5wSbotRfFQEf/v4Ml5zJ1WZzNK0WJamxnKqvIk/XW3icn0nzz+UHfZqEcY4N08VjZ209w7Q2NlHbpICZBGRxWbeB8huIFsKHLHW7rXWFgGVQKkxxn8P+3kdOA58Yq3dba0NXStM5ox1eUm8VJLH1YZO3jpbPTILIMC24jT6Bocpvd7Krdu9dPcPEeH10N0/xMP5DzbdJMLr4ZXHCvjuM8vvmnp5sclNjqEgbeqVOJ5Ynk5L1wC/P1/HmpwEtoaYmjsc1uQmMjQMH1xpxFrISV54N5giIjKxeR8gA98DKq21JwILrLUH3C8PTmUHxpgjwMvAJmvt0QffRJkpmwpSefGhHM7fbOftoKmPl6TEUpgWy+mKJq7WOzPWtXb3Ex/lZfkDrO8cEOH1kLkAe+pn0pqcRNLjI0mK8fHSFKcznw35KbEkREeMzMqoFAsRkcVnIQTI+3F6fkcrc9dNyBhzCNhlrd2kXuP56fHl6Ty9KpOz11v5/fm6kSB5e7HTQ/nBlSbS4iK51tTNhvzkMbV5JTw8HsN3nvTz908XExs5dwbBeTyG1TkJDA5bYiO9Mz7NtYiIzD0mEEzMR24KRQWwd3TPrzHmME6AnDJe4Bv0+gPW2jemeMz97n7Jysra9Itf/OI+zuDedXZ2Eh//4HtA5ztrLR/VDXGpeYiSLC/rMyIYtpZfXx2gs9+SHG1o67X8RZGP9Jj5fV+oa2Dm1XQMc+L6ADnxHp4tnJsBsq4D0TUgugbu386dO0uttZtHL5873TbTE8gxDhUAV7ifU8dZD3AIIBAcBwbmTdST7G77BsDmzZvtjh077rnR9+O9995jto85X+ywliNna/i0uo1HlubymD8N35JG3jlXR1ykl6VREby0a/mceZQ/XboGZt7g0DDX/3CJx/xp7JhCVY5w0HUgugZE18DMme8B8lQqTUy0zR6gzBizCziMG3AbY07g9Eor5WIeMcbw0qYl9A4O8V+f3yLa5+UxfxpDw5Y/nK9je3H6vA+OZXZEeD384+6VREbM76cNIiIyPfP93T91gnVtoz7fJagMnB/Y7X6kAD8AdgEnH1AbZRZ5PYa/emQpy9LiOHK2mvKGTixO8PzwOFNbi4QSE+nFq3x1EZFFKaw9yG5Kw0mm1hMcsNdaW+Z+3TLBdsmTbBNIz/iltTa42sVBt0e5xBjjt9ZW3kPbZA7weT28srWAH31Yxc8/vkFMpJdl6bFTnuFOREREFrewBshuCsOm+9hFIHgNVe84LegYoQSWV4RY9xZQ4u5XAfI8FO3z8uq2Qt74oJKGjj6eWTU380hFRERk7pnvOciB4DVUkO0HJqppHHjtRLMTnJ1Oo2RuiIuK4NuPL6PseqvSK0RERGTK5nUOsts7XIaTMzzaLpye4BHBM+u5qROV47x2C1CmQXrzX1KMj52rMjXYSkRERKZsIUQNBwG/O1U0MDJt9Nng2sjuhCAVwdsBB3ByjfcEbVeCEzTvnfGWi4iIiMicM99TLLDWnjDGbAIOGWNexukVrrTW7h616Sc4ecdl47z2AHfSLpap91hERERkcZr3ATKAW9VidEA8epujhMhJnsprRURERGTxWAgpFiIiIiIiD4wCZBERERGRIAqQRURERESCKEAWEREREQmiAFlEREREJIgCZBERERGRIAqQRURERESCKEAWEREREQmiAFlEREREJIgCZBERERGRIMZaG+42zFvGmEbg+iwfNh1omuVjytyia0BA14HoGhBdAw9CgbU2Y/RCBcjzjDHmrLV2c7jbIeGja0BA14HoGhBdAzNJKRYiIiIiIkEUIIuIiIiIBFGAPP+8Ee4GSNjpGhDQdSC6BkTXwIxRDrKIiIiISBD1IIuIiIiIBFGALDJPGGP2G2Mqwt0OERGRhU4B8jxgjEk2xhw2xhwxxlQYY44bY0rC3S6ZecYYv/u7rwAOAf5wt0nCxxhzyH0PsO7nQ8aY5HC3S2aPe6NcGnQNHNY1sHgZY0rc62FPuNuy0ChAnuPcN75S4Ii1dq+1tgioBEqNMQqWFr6DQIX7ez8b7sZI+BhjSoH9QBlwFEgFXgdOhrNdMnuMMYdwbpTPAgdw/hfsR9fAYnYEKAHawt2QhUaD9OY49w2xxFq7e9RyC7xhrT0QnpbJbDPGHAH2WGtNuNsis8/9m0+x1ra53wdunv3AXmvt0XC2T2aee5P0TOAacJcdB3YBm6y1ZWFrnMw6Nz7wA3uA3dbaE2Fu0oKiHuS5bz9wPMTyMnediCxw7tOiHwQHRu7Xh9xvt4SlYTLb3gq+BlyHw9ISCSv3PSGZO/FBSxibsyApQJ7Dgv4AKkOsPutuo9wzkQXOWltprT0YYlXgvaF5Ntsj4WGt/UGIxVuAMvUeLzqHcFLwZIYoQJ7bAjnGoXKLAtUMUmepLSIy9wTeI/RodRFyB2vvAp4Jd1tk9rgD8o6HeJogD5AC5LltKr3D6kEWWbwOAEfVe7i4uBWNSnFy0FuAfWFuksyul621mkFvhilAntsm6h1uG/VZRBYRY8x+INlauzfcbZFZd9hauwkowvkfcNgYo1zkRcAdmPf9cLdjMVCAPLdNlHSfPIVtRGQBch+tHwQ2hbstMvsC1Qrc3PS9OEGyBm0vcIFxSXpiNDsUIM9tgQE4oeodp8HISHYRWSTcgblHcMo66e9fQIO2F4sjwH53khjrln4MPDkITB6jG6UHJCLcDZAJBQLkUL1EfpzJAkRkkXADoJM4dY9DVbeRBcoYs2eCWtepQJtumBa87zA29XIvztODgzjlX/W+8IAoQJ7DrLVtxpgynFHKo+3C+WORxUO9Q3ISOKhHrItSaqgg2b1pKsEJlGQBC/V376ZbAZzQ+8KDpRSLue8g4DfGvB5Y4H59VjNnLQ7GmMNBs2VhjKlwR7GXTPJSWUDcayAZOOD+/o8YY467H6W6Hha8E8AP3RJfwJh0G/0/WJzS3M8q+fqAaarpecD9x3cI5w+gEhhv0gARWYDcCgWT5RZqqtkFzp1uvoQ7/wvOAoeUbrP4uNUsAnWwwRmoeQL4vnqSHwwFyCIiIiIiQZRiISIiIiISRAGyiIiIiEgQBcgiIiIiIkEUIIuIiIiIBFGALCIiIiISRAGyiIiIiEgQBcgiIiIiIkEUIIuIiIiIBFGALCIiIiISRAGyiMgMM8YcNsZYY0zrBB/W/Sg1xiQbYyrc6WRFRGSWKUAWEZl5bcBua21K4MNdngwsc5cZoAhoAVIBP1ASnuZOnxvc7w93O0RE7ocCZBGR2VE56vsWAGttW2CBtbYSaHM/p1hrd89i++6bMSYZaAX2hrstIiL3IyLcDRARWQS+HxwIT+Ig3B04zxfW2jZjDDg95iIi85YCZBGRGXYvwa7bexzojfVba8uC1xtj/EByYLkxxh94zejtQi0ftU0J8DJOqkeptfaNydpnjNkF7MZJAakEjltrT4zarGW6x3PPL/jnUMKdXvXptkdE5J4oxUJEZA4xxuwxxlTgpCocClq+3xjTClQA3zPG7Ap87w7uO+xuN3r5mIF+bp7wceAAcNg9zgF3YGDyBG07HPSag0AzcNxd5zfGHHE33efuq8IYUzKV4xljDgWd356g8yh1z6XVGLNnqu0REbkfxlob7jaIiCw6bhDsdwfnjV4XyOU9EZyH7PauVuD0lJ7ACTRbgCPALuCo+/3o5buDe1WNMaVAyzj7fsNae2CCNm0K7tU2xhy21h4I9HjjBLRHuZMqUjmV47mviIK4YgAAAqdJREFU34cT7Ja553fYff0ud7k/cC6TtWfcH7yIyBSoB1lEZI4ZLyUjKM2gzVp7wFpb6W570F3uH2d5cGBaglMd466e1qB9bx6nWanu57uCz0Awaq1tCwpUW9w2VE71eG57z7rLKq21BwPbuMF94BwCPeITtkdE5H4oB1lEZG6aKG95dD5u4Puz4ywPTpsIBMAHjDG7Rx2nknHyh91gtwzY75ZxC/TyvjU6T3qU6Rzvk3GOX4lb+u4+2iMiMikFyCIi81xQ9YipLA8Ey4emMihv1P42ucHoXpzUjRLgdWPMXmvt0XFeNu3jhdBG0M3BNNsjIjIppViIiCwugQBz072+0BiTbK19w1q7282dDtQ7niitYdrHC8GPk998P+0REZmUAmQRkblp3GoS9ykwWG9foKTaVLi5xPuCl7m9tGWMTflIDfp6WscLcfxABYvvT6M9IiL3RAGyiEh4pMJIdYgJt5lM0D7G235kuTsY7gBuLWK3rJzf/Xh9gmmiU3HyiEfa6wapyQSVo3Ptcvf7+jSPd8hdlxw0dfUBnIoVgRzme2mPiMg9UYAsIjKL3Hq/x7nTQ3wyUMPYXb/HXQ9QYow54tYS3u+WSwOnTvCRoODxpLt8l7t8dE/tnuDlbi7wbpxBfT/EKbd2GKd6xHh5woHBdFXGmFK35nEgaA3usQ2kNxzBHZA3jeOVuftpDZybm0YRfJyptkdE5J6pDrKIiMwJbg9wKXDQWvuDcLdHRBYv9SCLiIiIiARRgCwiIiIiEkQBsoiIiIhIEAXIIiIyVwRm3dsS1laIyKKnQXoiIhJ2xphDOJU9AmXcknEG60005baIyIxQgCwiIiIiEkQpFiIiIiIiQRQgi4iIiIgEUYAsIiIiIhJEAbKIiIiISBAFyCIiIiIiQf4/7Eu9f3rEQ0QAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(1)\n", + "xx = np.arange(-2.5, 2, 0.1)\n", + "N = 256\n", + "x = np.stack([xx for i in range(N)])\n", + "y = 0.5*np.tanh(x * (0.3 + np.random.rand(N,1)*2)) + np.random.randn(*x.shape)*0.05\n", + "np.save(\"models/intent_train.npy\", np.stack([x, y], axis=-1))\n", + "\n", + "\n", + "N = 16\n", + "x = np.stack([xx for i in range(N)])\n", + "y = 0.5*np.tanh(x * (0.3 + np.random.rand(N,1)*2)) + np.random.randn(*x.shape)*0.05\n", + "np.save(\"models/intent_test.npy\", np.stack([x, y], axis=-1))\n", + "\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(x.T + 2.5, y.T, alpha=0.6, c='#1f77b4')\n", + "\n", + "plt.grid()\n", + "plt.xlabel(\"Time steps\", fontsize=20)\n", + "plt.ylabel(\"s\", fontsize=20)\n", + "plt.title(\"Seq-to-seq dataset\", fontsize=26)\n", + "plt.tight_layout()\n", + "# plt.axis(\"equal\")\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing data" + ] + }, + { + "cell_type": "code", + "execution_count": 271, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "np.random.seed(1)\n", + "xx = np.arange(-2.5, 2, 0.1)\n", + "N = 1\n", + "x = np.stack([xx for i in range(N)])\n", + "y = 0.5*np.tanh(x * (0.3 + np.random.rand(N,1)*2)) + np.random.randn(*x.shape)*0.05\n", + "fontsize = 24\n", + "\n", + "\n", + "plt.figure(figsize=(20,6))\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.plot(xx[:10] + 2.5, y[:,:10].T, c='black', linewidth=1, zorder=-1)\n", + "plt.scatter(xx[:10] + 2.5, y[:,:10].T, c='forestgreen', linewidth=3)\n", + "plt.grid()\n", + "plt.title(\"Intent Prediction Set-up\", fontsize=fontsize+8)\n", + "plt.xlim([-0.2, 5])\n", + "plt.ylim([-1, 1.5])\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.tight_layout()\n", + "\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.plot(xx[:20] + 2.5, y[:,:20].T, c='black', linewidth=1, zorder=-1)\n", + "plt.scatter(xx[:10] + 2.5, y[:,:10].T, c='forestgreen', linewidth=3)\n", + "plt.scatter(xx[10:20] + 2.5, y[:,10:20].T, c='deepskyblue', linewidth=3)\n", + "plt.grid()\n", + "plt.title(\"Intent Prediction Set-up\", fontsize=fontsize+8)\n", + "plt.xlim([-0.2, 5])\n", + "plt.ylim([-1, 1.5])\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 272, + "metadata": {}, + "outputs": [], + "source": [ + "# setting up the model and dataset function for training\n", + "class PredictionDataset(Dataset):\n", + "\n", + " def __init__(self, fname, history_length=10, prediction_length=10):\n", + " \"\"\"\n", + " Args:\n", + " csv_file (string): Path to the csv file with annotations.\n", + " root_dir (string): Directory with all the images.\n", + " transform (callable, optional): Optional transform to be applied\n", + " on a sample.\n", + " \"\"\"\n", + " self.data = np.load(fname)\n", + " self.history_length = history_length\n", + " self.prediction_length = prediction_length\n", + "\n", + " def __len__(self):\n", + " return self.data.shape[0]\n", + "\n", + " def __getitem__(self, idx):\n", + " x = self.data[idx, :self.history_length, :]\n", + " y = self.data[idx, self.history_length:self.history_length+self.prediction_length, :]\n", + " return {'x': x, 'y': y}\n", + " \n", + "class Encoder(torch.nn.Module):\n", + "\n", + " def __init__(self, lstm_input_dim, lstm_dim):\n", + " super(Encoder, self).__init__()\n", + " self.network = torch.nn.LSTM(lstm_input_dim, lstm_dim, batch_first=True)\n", + " \n", + " def forward(self, x):\n", + " return self.network(x)\n", + " \n", + "class Decoder(torch.nn.Module):\n", + "\n", + " def __init__(self, lstm_input_dim, lstm_dim):\n", + " super(Decoder, self).__init__()\n", + " self.rnn_network = torch.nn.LSTM(lstm_input_dim, lstm_dim, batch_first=True)\n", + " self.proj_network = torch.nn.Linear(lstm_dim, lstm_input_dim)\n", + " self.h0 = torch.zeros([1,1,lstm_dim])\n", + " \n", + " def forward(self, x, rnn_state, ph):\n", + " bs = x.shape[0]\n", + " y_out = []\n", + " for t in range(ph):\n", + " output, rnn_state = self.rnn_network(x, rnn_state)\n", + " x = self.proj_network(output)\n", + " y_out.append(x)\n", + " return torch.cat(y_out, dim=1)\n", + " \n", + "class Predict(torch.nn.Module):\n", + "\n", + " def __init__(self, lstm_input_dim, lstm_dim):\n", + " super(Predict, self).__init__()\n", + " \n", + " self.enc = Encoder(lstm_input_dim, lstm_dim)\n", + " self.dec = Decoder(lstm_input_dim, lstm_dim)\n", + " \n", + " def forward(self, x, ph):\n", + " enc_out, rnn_state = self.enc(x)\n", + " return self.dec(self.dec.proj_network(enc_out[:,-1:,:]), rnn_state, ph)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "metadata": {}, + "outputs": [], + "source": [ + "#creating the model and training data\n", + "\n", + "hidden_dim = 4\n", + "\n", + "# n=1 (time), m=1 y value\n", + "# vanilla model to train without STL\n", + "torch.manual_seed(0)\n", + "pred = Predict(1, hidden_dim)\n", + "optimizer = torch.optim.Adam(pred.parameters(), lr=0.01, weight_decay=0)\n", + "\n", + "# model to train with STL\n", + "torch.manual_seed(0)\n", + "pred_stl = Predict(1, hidden_dim)\n", + "optimizer_stl = torch.optim.Adam(pred_stl.parameters())\n", + "\n", + "\n", + "dataset = PredictionDataset(\"models/intent_train.npy\")\n", + "\n", + "train_loader = DataLoader(dataset, batch_size=8, shuffle=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### setting up STL formula" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "metadata": {}, + "outputs": [], + "source": [ + "yf = stlcg.Expression('yf', yy)\n", + "ϕ2 = yf > torch.as_tensor(0.4).float()\n", + "ϕ3 = yf < torch.as_tensor(0.6).float()\n", + "ϕ = ϕ2 & ϕ3\n", + "ψ = stlcg.Always(subformula=ϕ, interval=[0,5]) # feeding trajectory not in reversed, so this time interval is actually the end of the trajectory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### training the network without STL" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "metadata": {}, + "outputs": [], + "source": [ + "γ = 0.0 # weighting on robustness loss" + ] + }, + { + "cell_type": "code", + "execution_count": 246, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 loss = 0.012 mse = 0.012 robustness = 5.900\n", + "1 loss = 0.008 mse = 0.008 robustness = 6.089\n", + "2 loss = 0.010 mse = 0.010 robustness = 5.869\n", + "3 loss = 0.019 mse = 0.019 robustness = 5.762\n", + "4 loss = 0.014 mse = 0.014 robustness = 5.668\n", + "5 loss = 0.008 mse = 0.008 robustness = 5.163\n", + "6 loss = 0.004 mse = 0.004 robustness = 4.387\n", + "7 loss = 0.005 mse = 0.005 robustness = 4.285\n", + "8 loss = 0.006 mse = 0.006 robustness = 4.250\n", + "9 loss = 0.007 mse = 0.007 robustness = 4.284\n", + "10 loss = 0.004 mse = 0.004 robustness = 4.216\n", + "11 loss = 0.004 mse = 0.004 robustness = 4.176\n", + "12 loss = 0.005 mse = 0.005 robustness = 4.195\n", + "13 loss = 0.005 mse = 0.005 robustness = 4.262\n", + "14 loss = 0.005 mse = 0.005 robustness = 4.217\n", + "15 loss = 0.005 mse = 0.005 robustness = 4.237\n", + "16 loss = 0.004 mse = 0.004 robustness = 4.236\n", + "17 loss = 0.004 mse = 0.004 robustness = 4.189\n", + "18 loss = 0.003 mse = 0.003 robustness = 4.115\n", + "19 loss = 0.004 mse = 0.004 robustness = 4.208\n", + "20 loss = 0.004 mse = 0.004 robustness = 4.111\n", + "21 loss = 0.004 mse = 0.004 robustness = 4.206\n", + "22 loss = 0.003 mse = 0.003 robustness = 4.129\n", + "23 loss = 0.004 mse = 0.004 robustness = 4.240\n", + "24 loss = 0.003 mse = 0.003 robustness = 4.149\n", + "25 loss = 0.005 mse = 0.005 robustness = 4.177\n", + "26 loss = 0.004 mse = 0.004 robustness = 4.188\n", + "27 loss = 0.003 mse = 0.003 robustness = 4.225\n", + "28 loss = 0.004 mse = 0.004 robustness = 4.151\n", + "29 loss = 0.003 mse = 0.003 robustness = 4.225\n", + "30 loss = 0.004 mse = 0.004 robustness = 4.213\n", + "31 loss = 0.005 mse = 0.005 robustness = 4.168\n", + "32 loss = 0.002 mse = 0.002 robustness = 4.195\n", + "33 loss = 0.004 mse = 0.004 robustness = 4.259\n", + "34 loss = 0.004 mse = 0.004 robustness = 4.183\n", + "35 loss = 0.005 mse = 0.005 robustness = 4.219\n", + "36 loss = 0.004 mse = 0.004 robustness = 4.217\n", + "37 loss = 0.004 mse = 0.004 robustness = 4.191\n", + "38 loss = 0.003 mse = 0.003 robustness = 4.222\n", + "39 loss = 0.003 mse = 0.003 robustness = 4.258\n", + "40 loss = 0.010 mse = 0.010 robustness = 4.303\n", + "41 loss = 0.004 mse = 0.004 robustness = 4.134\n", + "42 loss = 0.004 mse = 0.004 robustness = 4.196\n", + "43 loss = 0.003 mse = 0.003 robustness = 4.224\n", + "44 loss = 0.004 mse = 0.004 robustness = 4.293\n", + "45 loss = 0.004 mse = 0.004 robustness = 4.260\n", + "46 loss = 0.003 mse = 0.003 robustness = 4.251\n", + "47 loss = 0.005 mse = 0.005 robustness = 4.218\n", + "48 loss = 0.004 mse = 0.004 robustness = 4.240\n", + "49 loss = 0.004 mse = 0.004 robustness = 4.120\n" + ] + } + ], + "source": [ + "for _ in range(50):\n", + " for batch_idx, data_dict in enumerate(train_loader):\n", + " x = data_dict['x'].float()[:,:,1:]\n", + " y = data_dict['y'].float()[:,:,1:]\n", + " optimizer.zero_grad()\n", + " y_pred = pred(x, 35)\n", + " y_loss = y_pred[:,:10,:]\n", + "\n", + " y_future = y_pred[:,-35:,:]\n", + "\n", + " robustness = torch.relu(-ψ.robustness((y_future, y_future), scale=-1)).sum()\n", + " mse = (y_loss - y).pow(2).sum(-1).mean(1).mean()\n", + " loss = mse + γ*robustness\n", + " loss.backward()\n", + "\n", + " optimizer.step()\n", + " print(\"%i loss = %.3f mse = %.3f robustness = %.3f\"%(_, loss.detach().numpy(), mse.detach().numpy(), robustness.squeeze()))" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "metadata": {}, + "outputs": [], + "source": [ + "PATH = \"models/intent_%.2f.model\"%γ\n", + "torch.save(pred.state_dict(), PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### training the network with STL" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "metadata": {}, + "outputs": [], + "source": [ + "γ = 0.1 # weighting on robustness loss" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 loss = 0.480 mse = 0.143 robustness = 3.362\n", + "1 loss = 0.460 mse = 0.184 robustness = 2.765\n", + "2 loss = 0.386 mse = 0.185 robustness = 2.007\n", + "3 loss = 0.154 mse = 0.154 robustness = 0.000\n", + "4 loss = 0.012 mse = 0.012 robustness = 0.000\n", + "5 loss = 0.023 mse = 0.023 robustness = 0.000\n", + "6 loss = 0.012 mse = 0.012 robustness = 0.000\n", + "7 loss = 0.012 mse = 0.012 robustness = 0.000\n", + "8 loss = 0.022 mse = 0.022 robustness = 0.000\n", + "9 loss = 0.012 mse = 0.012 robustness = 0.000\n", + "10 loss = 0.012 mse = 0.012 robustness = 0.000\n", + "11 loss = 0.014 mse = 0.014 robustness = 0.000\n", + "12 loss = 0.009 mse = 0.009 robustness = 0.000\n", + "13 loss = 0.009 mse = 0.009 robustness = 0.000\n", + "14 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "15 loss = 0.007 mse = 0.007 robustness = 0.000\n", + "16 loss = 0.008 mse = 0.008 robustness = 0.000\n", + "17 loss = 0.014 mse = 0.014 robustness = 0.000\n", + "18 loss = 0.013 mse = 0.013 robustness = 0.000\n", + "19 loss = 0.011 mse = 0.011 robustness = 0.000\n", + "20 loss = 0.011 mse = 0.011 robustness = 0.000\n", + "21 loss = 0.007 mse = 0.007 robustness = 0.000\n", + "22 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "23 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "24 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "25 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "26 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "27 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "28 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "29 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "30 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "31 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "32 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "33 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "34 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "35 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "36 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "37 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "38 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "39 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "40 loss = 0.006 mse = 0.006 robustness = 0.000\n", + "41 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "42 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "43 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "44 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "45 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "46 loss = 0.004 mse = 0.004 robustness = 0.000\n", + "47 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "48 loss = 0.005 mse = 0.005 robustness = 0.000\n", + "49 loss = 0.005 mse = 0.005 robustness = 0.000\n" + ] + } + ], + "source": [ + "for _ in range(50):\n", + " for batch_idx, data_dict in enumerate(train_loader):\n", + " x = data_dict['x'].float()[:,:,1:]\n", + " y = data_dict['y'].float()[:,:,1:]\n", + " optimizer_stl.zero_grad()\n", + " y_pred = pred_stl(x, 35)\n", + " y_loss = y_pred[:,:10,:]\n", + "\n", + " y_future = y_pred[:,-35:,:]\n", + "\n", + " robustness = torch.relu(-ψ.robustness((y_future, y_future), scale=-1)).sum()\n", + " mse = (y_loss - y).pow(2).sum(-1).mean(1).mean()\n", + " loss = mse + γ*robustness\n", + " loss.backward()\n", + "\n", + " optimizer_stl.step()\n", + " print(\"%i loss = %.3f mse = %.3f robustness = %.3f\"%(_, loss.detach().numpy(), mse.detach().numpy(), robustness.squeeze()))" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "metadata": {}, + "outputs": [], + "source": [ + "PATH = \"models/intent_%.2f.model\"%γ\n", + "torch.save(pred_stl.state_dict(), PATH)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### preparing test set data" + ] + }, + { + "cell_type": "code", + "execution_count": 273, + "metadata": {}, + "outputs": [], + "source": [ + "dataset = PredictionDataset(\"models/intent_test.npy\")\n", + "test_loader = DataLoader(dataset, batch_size=16, shuffle=False)\n", + "for batch_idx, data_dict in enumerate(test_loader):\n", + " x = data_dict['x'].float()[:,:,1:]\n", + " y = data_dict['y'].float()[:,:,1:]\n", + " break\n", + " \n", + "xx = np.arange(-2.5, 2, 0.1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting comparison plots" + ] + }, + { + "cell_type": "code", + "execution_count": 274, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = Predict(1, 4)\n", + "\n", + "plt.figure(figsize=(20, 6))\n", + "\n", + "plt.subplot(1,2,1)\n", + "γ = 0.0\n", + "PATH = \"models/intent_%.2f.model\"%γ\n", + "model.load_state_dict(torch.load(PATH))\n", + "model.eval()\n", + "y_pred = model(x, 35)\n", + "\n", + "for idx in range(0,1):\n", + " x_history = xx[:10]\n", + " history = x.numpy()[idx,:,:]\n", + " plt.plot(x_history+2.5, history, c=\"forestgreen\", label=\"History\")\n", + " \n", + " x_future = xx[9:20]\n", + " future = y.numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"deepskyblue\", label=\"Future\")\n", + " \n", + " x_future = xx[9:]\n", + " future = y_pred.detach().numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"coral\", label=\"Prediction\")\n", + " \n", + " \n", + "\n", + "for idx in range(0,10):\n", + " x_history = xx[:10]\n", + " history = x.numpy()[idx,:,:]\n", + " plt.plot(x_history+2.5, history, c=\"forestgreen\")\n", + " \n", + " x_future = xx[9:20]\n", + " future = y.numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"deepskyblue\")\n", + " \n", + " x_future = xx[9:]\n", + " future = y_pred.detach().numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"coral\")\n", + "\n", + "plt.plot([0,4.5],[0.4, 0.4], 'k--')\n", + "plt.plot([0,4.5],[0.6, 0.6], 'k--')\n", + "plt.xlim([-2.5, 2])\n", + "plt.xlim([-1, 1])\n", + "plt.axis(\"equal\")\n", + "plt.legend(loc=\"upper left\", fontsize=fontsize-4)\n", + "plt.title(\"LSTM only ($\\gamma$=%.2f)\"%γ, fontsize=fontsize)\n", + "plt.xlabel(\"Time steps\", fontsize=fontsize)\n", + "plt.ylabel(\"s\", fontsize=fontsize)\n", + "plt.tight_layout()\n", + "plt.grid()\n", + "\n", + "\n", + "\n", + "plt.subplot(1,2,2)\n", + "γ = 0.1\n", + "PATH = \"models/intent_%.2f.model\"%γ\n", + "model.load_state_dict(torch.load(PATH))\n", + "model.eval()\n", + "y_pred = model(x, 35)\n", + "\n", + "for idx in range(0,1):\n", + " x_history = xx[:10]\n", + " history = x.numpy()[idx,:,:]\n", + " plt.plot(x_history+2.5, history, c=\"forestgreen\", label=\"History\")\n", + " \n", + " x_future = xx[9:20]\n", + " future = y.numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"deepskyblue\", label=\"Future\")\n", + " \n", + " x_future = xx[9:]\n", + " future = y_pred.detach().numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"coral\", label=\"Prediction\")\n", + " \n", + " \n", + "\n", + "for idx in range(0,10):\n", + " x_history = xx[:10]\n", + " history = x.numpy()[idx,:,:]\n", + " plt.plot(x_history+2.5, history, c=\"forestgreen\")\n", + " \n", + " x_future = xx[9:20]\n", + " future = y.numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"deepskyblue\")\n", + " \n", + " x_future = xx[9:]\n", + " future = y_pred.detach().numpy()[idx,:,:]\n", + " future = np.concatenate([history[-1:,:], future], axis=0)\n", + " plt.plot(x_future+2.5, future, c=\"coral\")\n", + "\n", + "plt.plot([0,4.5],[0.4, 0.4], 'k--')\n", + "plt.plot([0,4.5],[0.6, 0.6], 'k--')\n", + "plt.xlim([-2.5, 2])\n", + "plt.xlim([-1, 1])\n", + "plt.axis(\"equal\")\n", + "plt.legend(loc=\"upper left\", fontsize=fontsize-4)\n", + "plt.title(\"STL + LSTM ($\\gamma$=%.2f)\"%γ, fontsize=fontsize)\n", + "plt.xlabel(\"Time steps\", fontsize=fontsize)\n", + "plt.ylabel(\"s\", fontsize=fontsize)\n", + "plt.tight_layout()\n", + "plt.grid()\n", + "\n" + ] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/VAE.ipynb b/examples/VAE.ipynb new file mode 100644 index 0000000..6779465 --- /dev/null +++ b/examples/VAE.ipynb @@ -0,0 +1,1166 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "diagnostic-price", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import sys\n", + "sys.path.append('../src')\n", + "\n", + "import torch\n", + "from torch.nn import functional as F\n", + "import numpy as np\n", + "from abc import ABC, abstractmethod\n", + "import stlcg \n", + "import stlviz \n", + "\n", + "import matplotlib.pyplot as plt\n", + "from ipywidgets import interact, interactive, fixed, interact_manual\n", + "import ipywidgets as widgets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "abandoned-acquisition", + "metadata": {}, + "outputs": [], + "source": [ + "# figure settings\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"sans-serif\",\n", + " \"font.sans-serif\": [\"Helvetica\"]})\n", + "# for Palatino and other serif fonts use:\n", + "plt.rcParams.update({\n", + " \"text.usetex\": True,\n", + " \"font.family\": \"serif\",\n", + " \"font.serif\": [\"Palatino\"],\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "biological-powell", + "metadata": {}, + "outputs": [], + "source": [ + "RNG_seed = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "considered-hollywood", + "metadata": {}, + "outputs": [], + "source": [ + "# function to generate multimodal trajectory data\n", + "def generate_data(N=50, plot_fig=False):\n", + " λ = 0.7\n", + " ω = 0.5\n", + " A = 0.7\n", + " B = 1.1\n", + " σ1 = 0.05\n", + " σ2 = 0.02\n", + " alpha = 0.2\n", + " tmax = 10\n", + " dt = 0.25\n", + " t = np.arange(0, tmax, dt)\n", + " y1 = A - np.exp(-4*λ*t) * (A * np.cos(ω * t) + B * np.sin(ω * t))\n", + " y2 = np.exp(-λ*t) * 5 * B * np.sin(0.5 * ω * t)\n", + " y3 = 0.5*(A - np.exp(-4*λ*t) * (A * np.cos(ω * t) + B * np.sin(ω * t)))\n", + "\n", + " noisy_y1 = (np.expand_dims(y1, 0) * (1 + σ1 * np.random.randn(N, 1))) + σ2 * np.random.randn(N,len(t))\n", + " noisy_y2 = (np.expand_dims(y2, 0) * (1 + σ1 * np.random.randn(N, 1))) + σ2 * np.random.randn(N,len(t))\n", + " noisy_y3 = (np.expand_dims(y3, 0) * (1 + σ1 * np.random.randn(N, 1))) + σ2 * np.random.randn(N,len(t))\n", + "\n", + " if plot_fig:\n", + " fontsize = 24\n", + " plt.figure(figsize=(16,8))\n", + " plt.plot(t, y1, linewidth=4)\n", + " plt.plot(t, y2, linewidth=4)\n", + " plt.plot(t, y3, linewidth=4)\n", + "\n", + " plt.plot(t, noisy_y1.T, alpha=alpha, c=\"lightskyblue\")\n", + " plt.plot(t, noisy_y2.T, alpha=alpha, c=\"orange\")\n", + " plt.plot(t, noisy_y3.T, alpha=alpha, c=\"green\")\n", + "\n", + " plt.xlabel(\"Time\", fontsize=fontsize)\n", + " plt.ylabel(\"x\", fontsize=fontsize)\n", + " plt.xticks(fontsize=fontsize)\n", + " plt.yticks(fontsize=fontsize)\n", + " plt.savefig(\"figs/latent_space_data.pdf\")\n", + " return t, np.concatenate([y1, y2, y3]), np.concatenate([noisy_y1, noisy_y2, noisy_y3])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "valid-monitor", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualizing trajectories (not the actual training data used. This code block if purely for visualization purposes.)\n", + "N = 50\n", + "fontsize = 24\n", + "alpha = 0.2\n", + "\n", + "\n", + "np.random.seed(RNG_seed)\n", + "t, data, noisy_data = generate_data(N)\n", + "y1, y2, y3 = np.split(data, 3)\n", + "noisy_y1, noisy_y2, noisy_y3 = np.split(noisy_data, 3, 0)\n", + "\n", + "\n", + "plt.figure(figsize=(16,8))\n", + "plt.plot(t, y1, linewidth=4)\n", + "plt.plot(t, y2, linewidth=4)\n", + "plt.plot(t, y3, linewidth=4)\n", + "\n", + "plt.scatter(t, y1, linewidth=4)\n", + "plt.scatter(t, y2, linewidth=4)\n", + "plt.scatter(t, y3, linewidth=4)\n", + "\n", + "plt.plot(t, noisy_y1.T, alpha=alpha, c=\"lightskyblue\")\n", + "plt.plot(t, noisy_y2.T, alpha=alpha, c=\"orange\")\n", + "plt.plot(t, noisy_y3.T, alpha=alpha, c=\"green\")\n", + "\n", + "plt.xlabel(\"Time\", fontsize=fontsize)\n", + "plt.ylabel(\"x\", fontsize=fontsize)\n", + "plt.title(\"Training data\", fontsize=fontsize+8)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.grid()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "split-steering", + "metadata": {}, + "outputs": [], + "source": [ + "# Defining the VAE neural network model\n", + "# Uses LSTM for the encoder and decoder\n", + "# hidden_size is the dimensions for the LSTM hidden state\n", + "# latent_size is the size of the latent space\n", + "# A discrete latent space is used\n", + "\n", + "class VAE(torch.nn.Module):\n", + " def __init__(self, hidden_size=32, latent_size=16):\n", + " super(VAE, self).__init__()\n", + " self.latent_size = latent_size\n", + " # LSTM encoder\n", + " self.rnn_encoder = torch.nn.LSTM(input_size=1, hidden_size=hidden_size, batch_first=True)\n", + " # LSTM decoder\n", + " self.rnn_decoder = torch.nn.LSTM(input_size=1, hidden_size=hidden_size, batch_first=True)\n", + " # projection from encoder state into latent space\n", + " self.fc1 = torch.nn.Linear(hidden_size, latent_size)\n", + " # projection from decoder state into output state\n", + " self.fc2 = torch.nn.Linear(hidden_size, 1)\n", + " # projection from latent state into initial LSTM decoder state\n", + " self.fc_to_rnn1 = torch.nn.Linear(latent_size, hidden_size)\n", + " self.fc_to_rnn2 = torch.nn.Linear(latent_size, hidden_size)\n", + " \n", + " def encode(self, x):\n", + " '''\n", + " The encoder takes in the signal and passes it through an LSTM network.\n", + " The last output of the LSTM is projected the probabilities used to construct the discrete latent space.\n", + " '''\n", + " o, h = self.rnn_encoder(x)\n", + " return F.softmax(self.fc1(o[:,-1,:]), -1) # last output state [bs, latent_size]\n", + "\n", + " def reparameterize(self, p, k, temp):\n", + " '''\n", + " Reparameterization for a discrete latent space\n", + " During training time, we sample from a RelaxedOneHotCategorical distribution to backpropagate through the network.\n", + " The relaxation is controlled by a temperature parameter that anneals over the training iterations.\n", + " During test/eval time, we sample from the OneHotCategorial distribution.\n", + " '''\n", + " if self.training:\n", + " # At training time we sample from a relaxed Gumbel-Softmax Distribution. \n", + " # The samples are continuous but when we increase the temperature the samples gets closer to a Categorical distribution.\n", + " m = torch.distributions.RelaxedOneHotCategorical(temp, p)\n", + " return m.rsample(torch.Size([k])).view([-1, self.latent_size]) # [k*bs, latent_size]\n", + " else:\n", + " # At testing time we sample from a Categorical Distribution.\n", + " m = torch.distributions.OneHotCategorical(p)\n", + " return m.sample(torch.Size([k])).view([-1, self.latent_size]) # [k*bs, latent_size]\n", + "\n", + " def decode(self, z, x, probs=0.1, t_max=None):\n", + " '''\n", + " The latent vector z is used to initialize the initial LSTM decoder state.\n", + " A linear projection is used to project the LSTM decoder output state into the signal state.\n", + " probs is the probability that the previous output will be used as the next LSTM input. \n", + " Otherwise the true input value from the dataset will be used instead.\n", + " '''\n", + " if t_max is None:\n", + " t_max = x.shape[1]\n", + " h = (self.fc_to_rnn1(z).unsqueeze(0), self.fc_to_rnn1(z).unsqueeze(0))\n", + " xs = x.split(1, 1)\n", + " os = []\n", + " ys = [xs[0]]\n", + " ps = torch.rand(t_max).to(device)\n", + " if not self.training:\n", + " probs = 1\n", + " xi = xs[0]\n", + " for ti in range(t_max-1):\n", + " oi, h = self.rnn_decoder(xi, h)\n", + " os.append(oi)\n", + " yi = self.fc2(oi)\n", + " xi = yi if ps[ti] <= probs else xs[ti+1]\n", + " ys.append(yi)\n", + " return torch.cat(ys, dim=1)\n", + " \n", + " def forward(self, x, temp, probs, k=1):\n", + " p = self.encode(x)\n", + " z = self.reparameterize(p, k, temp)\n", + " return self.decode(z, x.repeat([k,1,1]), probs), p, z\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "advisory-scholar", + "metadata": {}, + "outputs": [], + "source": [ + "# training parameters\n", + "\n", + "batch_size = 16 # training batch size\n", + "test_batch_size = 4 # test batch size\n", + "test_k = 1 # number of times to sample from the latent space (for plotting purposes)\n", + "epochs = 50 # number of training iterations\n", + "seed = 1 # random seed number\n", + "log_interval = 10 # frequency to print training progress and plotting \n", + "\n", + "use_cuda = torch.cuda.is_available() # use GPU if available\n", + "torch.manual_seed(seed) # set seed number \n", + "\n", + "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", + "kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "completed-nurse", + "metadata": {}, + "outputs": [], + "source": [ + "# network parameters\n", + "hidden_size = 16 # size of LSTM hidden state \n", + "latent_size = 3 # size of latent space. Chosen to be 3 based on the three trajectories in the dataset\n", + "\n", + "# instantiating the models. Using the same seed to make sure they are intialized identically\n", + "torch.manual_seed(seed) # setting seed \n", + "vae = VAE(hidden_size=hidden_size, latent_size=latent_size).to(device)\n", + "torch.manual_seed(seed) # setting seed\n", + "stlvae = VAE(hidden_size=hidden_size, latent_size=latent_size).to(device)\n", + "# optimizers\n", + "vae_optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)\n", + "stlvae_optimizer = torch.optim.Adam(stlvae.parameters(), lr=1e-3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "further-olive", + "metadata": {}, + "outputs": [], + "source": [ + "# Dataset structure\n", + "class VAEDataset(torch.utils.data.Dataset):\n", + " def __init__(self, dataset):\n", + " self.data = dataset # [bs, time, state_dim]\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " return self.data[idx,:,:]\n", + "\n", + "# VAE loss function\n", + "def vae_loss_function(recon_x, x, p, k):\n", + " '''\n", + " recon_loss is the reconstruction loss. We use the sum of the error**2 over each trajectory, then mean over the batch\n", + " kl_loss the the Kullback–Leibler divergence term for the categorical distribution. It is compared against a uniform distribution\n", + " '''\n", + " recon_loss = ((recon_x - x.repeat([k,1,1]))**2).squeeze().sum(1).mean(0)\n", + " kl_loss = (p * (torch.log(p) - np.log(0.5))).sum(-1).mean()\n", + " elbo = recon_loss - kl_loss\n", + " return elbo\n", + "\n", + "def phi_func(c, ϵ):\n", + " '''\n", + " The STL formula used to guide the latent vector to correspond to each trajectory mode\n", + " ϕ = Always_[30,39](s>c-ϵ/2 & s Epoch: {} Average loss: {:.4f}'.format(\n", + " epoch, train_loss / len(train_loader.dataset)))\n", + " return train_loss / len(train_loader.dataset)\n", + " \n", + "def stlvae_train(epoch, temp, probs, scale, phic, k=5, λ=0.1, ϵ=0.1):\n", + " '''\n", + " Performs a single training iteration with the VAE+STL model\n", + " epoch is the training iteration number\n", + " temp is the temperature for the RelaxedOneHotCategorical distribution\n", + " probs is the probability that the previous output will be used as the next LSTM input. \n", + " Otherwise the true input value from the dataset will be used instead.\n", + " scale is the STL scale used for the softmin/softmax\n", + " phic is the matrix of STL parameter values\n", + " k is the number samples to draw from the latent distribution\n", + " λ is the coefficient on the STL loss term\n", + " ϵ is the tolerance used in the STL formula\n", + " '''\n", + " stlvae.train()\n", + " train_loss = 0\n", + " vae_loss = 0\n", + " stl_loss = 0\n", + " for batch_idx, data in enumerate(train_loader):\n", + " data = data.to(device)\n", + " stlvae_optimizer.zero_grad()\n", + " recon_batch, p, z = stlvae(data, temp, probs, k=k)\n", + " vae_loss_i = vae_loss_function(recon_batch, data, p, k)\n", + " stl_loss_i = stl_loss_function(phi_func, phic, recon_batch, z, scale, ϵ)\n", + " loss = vae_loss_i + λ * stl_loss_i\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " vae_loss += vae_loss_i.item()\n", + " stl_loss += stl_loss_i.item()\n", + " stlvae_optimizer.step()\n", + " if batch_idx % log_interval == 0:\n", + " print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f} VAE loss: {:.6f} STL loss: {:.6f}'.format(\n", + " epoch, batch_idx * len(data), len(train_loader.dataset),\n", + " 100. * batch_idx / len(train_loader),\n", + " loss.item() / len(data), vae_loss_i.item() / len(data), stl_loss_i.item() / len(data)))\n", + " print('====> Epoch: {} Average loss: {:.4f} Average VAE loss: {:.4f} Average STL loss: {:.4f}'.format(\n", + " epoch, train_loss / len(train_loader.dataset), vae_loss / len(train_loader.dataset), stl_loss / len(train_loader.dataset)))\n", + " return train_loss / len(train_loader.dataset), vae_loss / len(train_loader.dataset), stl_loss / len(train_loader.dataset)\n", + "\n", + "def save_image(test_output, epoch, model, tmax=10):\n", + " '''\n", + " Saving an image of the trajectories\n", + " '''\n", + " fontsize = 24\n", + " plt.figure(figsize=(16,8))\n", + " plt.plot(np.arange(0, tmax, 0.25), test_output.squeeze().detach().cpu().T, linewidth=1)\n", + " plt.xlabel(\"Time\", fontsize=fontsize)\n", + " plt.ylabel(\"x\", fontsize=fontsize)\n", + " plt.xticks(fontsize=fontsize)\n", + " plt.yticks(fontsize=fontsize)\n", + " plt.ylim([-0.1, 1.0])\n", + " plt.savefig(\"figs/latentspace/%s_epoch_%i.png\"%(model,epoch))\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "correct-deputy", + "metadata": {}, + "outputs": [], + "source": [ + "# Generating training and test data\n", + "np.random.seed(RNG_seed)\n", + "_, _, dataset = generate_data(N=128) # generating training data\n", + "x = torch.tensor((dataset - dataset.mean())/dataset.std()).unsqueeze(-1).float().to(device) # standardizing training data\n", + "t, _, test_dataset = generate_data(N=test_batch_size) # generating test data\n", + "test_x = torch.tensor((test_dataset - dataset.mean())/dataset.std()).unsqueeze(-1).float().to(device) # standardizing test data\n", + "\n", + "train_loader = torch.utils.data.DataLoader(VAEDataset(x), batch_size=batch_size, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ranking-fleece", + "metadata": {}, + "outputs": [], + "source": [ + "# setting up latext vectors to generate test trajectories\n", + "z = torch.zeros([test_batch_size*latent_size, latent_size]).to(device).float()\n", + "z[:test_batch_size,0] = 1.0\n", + "z[test_batch_size:2*test_batch_size,1] = 1.0\n", + "z[2*test_batch_size:,2] = 1.0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "educated-faith", + "metadata": {}, + "outputs": [], + "source": [ + "# setting up parameter values\n", + "λ = 4.0\n", + "ϵ = (torch.tensor(0.05).to(device).float() - dataset.mean())/dataset.std()\n", + "phic = (torch.tensor([[0.7], [0.35], [0.0]]).to(device).float() - dataset.mean())/dataset.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fifteen-handle", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 1 [0/384 (0%)]\tLoss: 3.287097 VAE loss: 2.970942 STL loss: 0.079039\n", + "Train Epoch: 1 [160/384 (42%)]\tLoss: 2.890382 VAE loss: 2.576140 STL loss: 0.078560\n", + "Train Epoch: 1 [320/384 (83%)]\tLoss: 2.709659 VAE loss: 2.397420 STL loss: 0.078060\n", + "====> Epoch: 1 Average loss: 2.5135 Average VAE loss: 2.2033 Average STL loss: 0.0775\n", + "Train Epoch: 2 [0/384 (0%)]\tLoss: 2.580169 VAE loss: 2.252566 STL loss: 0.081901\n", + "Train Epoch: 2 [160/384 (42%)]\tLoss: 2.534223 VAE loss: 2.224168 STL loss: 0.077514\n", + "Train Epoch: 2 [320/384 (83%)]\tLoss: 2.333697 VAE loss: 2.016391 STL loss: 0.079327\n", + "====> Epoch: 2 Average loss: 2.1370 Average VAE loss: 1.8245 Average STL loss: 0.0781\n", + "Train Epoch: 3 [0/384 (0%)]\tLoss: 2.121210 VAE loss: 1.805065 STL loss: 0.079036\n", + "Train Epoch: 3 [160/384 (42%)]\tLoss: 1.277940 VAE loss: 0.966795 STL loss: 0.077786\n", + "Train Epoch: 3 [320/384 (83%)]\tLoss: 1.259483 VAE loss: 0.934533 STL loss: 0.081237\n", + "====> Epoch: 3 Average loss: 1.6196 Average VAE loss: 1.3005 Average STL loss: 0.0798\n", + "Train Epoch: 4 [0/384 (0%)]\tLoss: 1.037055 VAE loss: 0.732979 STL loss: 0.076019\n", + "Train Epoch: 4 [160/384 (42%)]\tLoss: 1.000820 VAE loss: 0.649214 STL loss: 0.087902\n", + "Train Epoch: 4 [320/384 (83%)]\tLoss: 1.000775 VAE loss: 0.623596 STL loss: 0.094295\n", + "====> Epoch: 4 Average loss: 1.0657 Average VAE loss: 0.7225 Average STL loss: 0.0858\n", + "Train Epoch: 5 [0/384 (0%)]\tLoss: 1.147606 VAE loss: 0.798683 STL loss: 0.087231\n", + "Train Epoch: 5 [160/384 (42%)]\tLoss: 0.789854 VAE loss: 0.456711 STL loss: 0.083286\n", + "Train Epoch: 5 [320/384 (83%)]\tLoss: 0.868217 VAE loss: 0.514031 STL loss: 0.088547\n", + "====> Epoch: 5 Average loss: 0.8189 Average VAE loss: 0.4651 Average STL loss: 0.0884\n", + "Train Epoch: 6 [0/384 (0%)]\tLoss: 0.721449 VAE loss: 0.375160 STL loss: 0.086572\n", + "Train Epoch: 6 [160/384 (42%)]\tLoss: 0.650319 VAE loss: 0.322197 STL loss: 0.082031\n", + "Train Epoch: 6 [320/384 (83%)]\tLoss: 0.636622 VAE loss: 0.328301 STL loss: 0.077080\n", + "====> Epoch: 6 Average loss: 0.6732 Average VAE loss: 0.3394 Average STL loss: 0.0835\n", + "Train Epoch: 7 [0/384 (0%)]\tLoss: 0.577198 VAE loss: 0.265802 STL loss: 0.077849\n", + "Train Epoch: 7 [160/384 (42%)]\tLoss: 0.633906 VAE loss: 0.294854 STL loss: 0.084763\n", + "Train Epoch: 7 [320/384 (83%)]\tLoss: 0.476720 VAE loss: 0.180912 STL loss: 0.073952\n", + "====> Epoch: 7 Average loss: 0.5693 Average VAE loss: 0.2448 Average STL loss: 0.0811\n", + "Train Epoch: 8 [0/384 (0%)]\tLoss: 0.479417 VAE loss: 0.175942 STL loss: 0.075869\n", + "Train Epoch: 8 [160/384 (42%)]\tLoss: 0.521703 VAE loss: 0.190074 STL loss: 0.082907\n", + "Train Epoch: 8 [320/384 (83%)]\tLoss: 0.526384 VAE loss: 0.169511 STL loss: 0.089218\n", + "====> Epoch: 8 Average loss: 0.4903 Average VAE loss: 0.1714 Average STL loss: 0.0797\n", + "Train Epoch: 9 [0/384 (0%)]\tLoss: 0.485898 VAE loss: 0.155646 STL loss: 0.082563\n", + "Train Epoch: 9 [160/384 (42%)]\tLoss: 0.468565 VAE loss: 0.141811 STL loss: 0.081689\n", + "Train Epoch: 9 [320/384 (83%)]\tLoss: 0.395766 VAE loss: 0.092686 STL loss: 0.075770\n", + "====> Epoch: 9 Average loss: 0.4413 Average VAE loss: 0.1225 Average STL loss: 0.0797\n", + "Train Epoch: 10 [0/384 (0%)]\tLoss: 0.435473 VAE loss: 0.112630 STL loss: 0.080711\n", + "Train Epoch: 10 [160/384 (42%)]\tLoss: 0.418636 VAE loss: 0.093150 STL loss: 0.081371\n", + "Train Epoch: 10 [320/384 (83%)]\tLoss: 0.300681 VAE loss: 0.051062 STL loss: 0.062405\n", + "====> Epoch: 10 Average loss: 0.4116 Average VAE loss: 0.0933 Average STL loss: 0.0796\n", + "Train Epoch: 11 [0/384 (0%)]\tLoss: 0.433997 VAE loss: 0.084867 STL loss: 0.087282\n", + "Train Epoch: 11 [160/384 (42%)]\tLoss: 0.397567 VAE loss: 0.079717 STL loss: 0.079463\n", + "Train Epoch: 11 [320/384 (83%)]\tLoss: 0.372697 VAE loss: 0.061628 STL loss: 0.077767\n", + "====> Epoch: 11 Average loss: 0.3922 Average VAE loss: 0.0756 Average STL loss: 0.0791\n", + "Train Epoch: 12 [0/384 (0%)]\tLoss: 0.378323 VAE loss: 0.069856 STL loss: 0.077117\n", + "Train Epoch: 12 [160/384 (42%)]\tLoss: 0.384658 VAE loss: 0.051838 STL loss: 0.083205\n", + "Train Epoch: 12 [320/384 (83%)]\tLoss: 0.392313 VAE loss: 0.067153 STL loss: 0.081290\n", + "====> Epoch: 12 Average loss: 0.3793 Average VAE loss: 0.0613 Average STL loss: 0.0795\n", + "Train Epoch: 13 [0/384 (0%)]\tLoss: 0.449396 VAE loss: 0.074186 STL loss: 0.093802\n", + "Train Epoch: 13 [160/384 (42%)]\tLoss: 0.392203 VAE loss: 0.063801 STL loss: 0.082101\n", + "Train Epoch: 13 [320/384 (83%)]\tLoss: 0.345192 VAE loss: 0.035292 STL loss: 0.077475\n", + "====> Epoch: 13 Average loss: 0.3692 Average VAE loss: 0.0505 Average STL loss: 0.0797\n", + "Train Epoch: 14 [0/384 (0%)]\tLoss: 0.340616 VAE loss: 0.042786 STL loss: 0.074457\n", + "Train Epoch: 14 [160/384 (42%)]\tLoss: 0.433700 VAE loss: 0.054105 STL loss: 0.094899\n", + "Train Epoch: 14 [320/384 (83%)]\tLoss: 0.339668 VAE loss: 0.036174 STL loss: 0.075874\n", + "====> Epoch: 14 Average loss: 0.3942 Average VAE loss: 0.0462 Average STL loss: 0.0870\n", + "Train Epoch: 15 [0/384 (0%)]\tLoss: 0.347100 VAE loss: 0.040965 STL loss: 0.076534\n", + "Train Epoch: 15 [160/384 (42%)]\tLoss: 0.367851 VAE loss: 0.039572 STL loss: 0.082070\n", + "Train Epoch: 15 [320/384 (83%)]\tLoss: 0.345310 VAE loss: 0.037093 STL loss: 0.077054\n", + "====> Epoch: 15 Average loss: 0.3509 Average VAE loss: 0.0379 Average STL loss: 0.0783\n", + "Train Epoch: 16 [0/384 (0%)]\tLoss: 0.310395 VAE loss: 0.035231 STL loss: 0.068791\n", + "Train Epoch: 16 [160/384 (42%)]\tLoss: 0.371950 VAE loss: 0.044614 STL loss: 0.081834\n", + "Train Epoch: 16 [320/384 (83%)]\tLoss: 0.406020 VAE loss: 0.064620 STL loss: 0.085350\n", + "====> Epoch: 16 Average loss: 0.3471 Average VAE loss: 0.0356 Average STL loss: 0.0779\n", + "Train Epoch: 17 [0/384 (0%)]\tLoss: 0.353527 VAE loss: 0.035771 STL loss: 0.079439\n", + "Train Epoch: 17 [160/384 (42%)]\tLoss: 0.338951 VAE loss: 0.020802 STL loss: 0.079537\n", + "Train Epoch: 17 [320/384 (83%)]\tLoss: 0.325170 VAE loss: 0.026829 STL loss: 0.074585\n", + "====> Epoch: 17 Average loss: 0.3426 Average VAE loss: 0.0321 Average STL loss: 0.0776\n", + "Train Epoch: 18 [0/384 (0%)]\tLoss: 0.339316 VAE loss: 0.029635 STL loss: 0.077420\n", + "Train Epoch: 18 [160/384 (42%)]\tLoss: 0.313240 VAE loss: 0.026373 STL loss: 0.071717\n", + "Train Epoch: 18 [320/384 (83%)]\tLoss: 0.323108 VAE loss: 0.020978 STL loss: 0.075533\n", + "====> Epoch: 18 Average loss: 0.3372 Average VAE loss: 0.0295 Average STL loss: 0.0769\n", + "Train Epoch: 19 [0/384 (0%)]\tLoss: 0.370444 VAE loss: 0.036684 STL loss: 0.083440\n", + "Train Epoch: 19 [160/384 (42%)]\tLoss: 0.286096 VAE loss: 0.021904 STL loss: 0.066048\n", + "Train Epoch: 19 [320/384 (83%)]\tLoss: 0.344616 VAE loss: 0.031448 STL loss: 0.078292\n", + "====> Epoch: 19 Average loss: 0.3366 Average VAE loss: 0.0302 Average STL loss: 0.0766\n", + "Train Epoch: 20 [0/384 (0%)]\tLoss: 0.370552 VAE loss: 0.035394 STL loss: 0.083790\n", + "Train Epoch: 20 [160/384 (42%)]\tLoss: 0.349190 VAE loss: 0.033302 STL loss: 0.078972\n", + "Train Epoch: 20 [320/384 (83%)]\tLoss: 0.363349 VAE loss: 0.036697 STL loss: 0.081663\n", + "====> Epoch: 20 Average loss: 0.3329 Average VAE loss: 0.0344 Average STL loss: 0.0746\n", + "Train Epoch: 21 [0/384 (0%)]\tLoss: 0.362622 VAE loss: 0.043387 STL loss: 0.079809\n", + "Train Epoch: 21 [160/384 (42%)]\tLoss: 0.274300 VAE loss: 0.013161 STL loss: 0.065285\n", + "Train Epoch: 21 [320/384 (83%)]\tLoss: 0.297650 VAE loss: 0.025708 STL loss: 0.067986\n", + "====> Epoch: 21 Average loss: 0.3217 Average VAE loss: 0.0356 Average STL loss: 0.0715\n", + "Train Epoch: 22 [0/384 (0%)]\tLoss: 0.325194 VAE loss: 0.031435 STL loss: 0.073440\n", + "Train Epoch: 22 [160/384 (42%)]\tLoss: 0.309774 VAE loss: 0.031319 STL loss: 0.069614\n", + "Train Epoch: 22 [320/384 (83%)]\tLoss: 0.298090 VAE loss: 0.026432 STL loss: 0.067915\n", + "====> Epoch: 22 Average loss: 0.3147 Average VAE loss: 0.0415 Average STL loss: 0.0683\n", + "Train Epoch: 23 [0/384 (0%)]\tLoss: 0.265269 VAE loss: 0.020090 STL loss: 0.061295\n", + "Train Epoch: 23 [160/384 (42%)]\tLoss: 0.283792 VAE loss: 0.023197 STL loss: 0.065149\n", + "Train Epoch: 23 [320/384 (83%)]\tLoss: 0.264125 VAE loss: 0.012035 STL loss: 0.063023\n", + "====> Epoch: 23 Average loss: 0.2842 Average VAE loss: 0.0278 Average STL loss: 0.0641\n", + "Train Epoch: 24 [0/384 (0%)]\tLoss: 0.274912 VAE loss: 0.016700 STL loss: 0.064553\n", + "Train Epoch: 24 [160/384 (42%)]\tLoss: 0.284593 VAE loss: 0.037592 STL loss: 0.061750\n", + "Train Epoch: 24 [320/384 (83%)]\tLoss: 0.246826 VAE loss: 0.011423 STL loss: 0.058851\n", + "====> Epoch: 24 Average loss: 0.2559 Average VAE loss: 0.0160 Average STL loss: 0.0600\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 25 [0/384 (0%)]\tLoss: 0.264399 VAE loss: 0.025428 STL loss: 0.059743\n", + "Train Epoch: 25 [160/384 (42%)]\tLoss: 0.258223 VAE loss: 0.018504 STL loss: 0.059930\n", + "Train Epoch: 25 [320/384 (83%)]\tLoss: 0.228273 VAE loss: 0.000467 STL loss: 0.056951\n", + "====> Epoch: 25 Average loss: 0.2441 Average VAE loss: 0.0135 Average STL loss: 0.0576\n", + "Train Epoch: 26 [0/384 (0%)]\tLoss: 0.262034 VAE loss: 0.028786 STL loss: 0.058312\n", + "Train Epoch: 26 [160/384 (42%)]\tLoss: 0.211307 VAE loss: -0.002464 STL loss: 0.053443\n", + "Train Epoch: 26 [320/384 (83%)]\tLoss: 0.211437 VAE loss: -0.003063 STL loss: 0.053625\n", + "====> Epoch: 26 Average loss: 0.2284 Average VAE loss: 0.0084 Average STL loss: 0.0550\n", + "Train Epoch: 27 [0/384 (0%)]\tLoss: 0.225020 VAE loss: 0.001282 STL loss: 0.055934\n", + "Train Epoch: 27 [160/384 (42%)]\tLoss: 0.237208 VAE loss: 0.011608 STL loss: 0.056400\n", + "Train Epoch: 27 [320/384 (83%)]\tLoss: 0.218771 VAE loss: -0.001486 STL loss: 0.055064\n", + "====> Epoch: 27 Average loss: 0.2243 Average VAE loss: 0.0049 Average STL loss: 0.0548\n", + "Train Epoch: 28 [0/384 (0%)]\tLoss: 0.229259 VAE loss: 0.018978 STL loss: 0.052570\n", + "Train Epoch: 28 [160/384 (42%)]\tLoss: 0.239728 VAE loss: 0.017272 STL loss: 0.055614\n", + "Train Epoch: 28 [320/384 (83%)]\tLoss: 0.277246 VAE loss: 0.057750 STL loss: 0.054874\n", + "====> Epoch: 28 Average loss: 0.3084 Average VAE loss: 0.0793 Average STL loss: 0.0573\n", + "Train Epoch: 29 [0/384 (0%)]\tLoss: 0.305582 VAE loss: 0.068462 STL loss: 0.059280\n", + "Train Epoch: 29 [160/384 (42%)]\tLoss: 0.374529 VAE loss: 0.097875 STL loss: 0.069164\n", + "Train Epoch: 29 [320/384 (83%)]\tLoss: 0.353242 VAE loss: 0.107907 STL loss: 0.061334\n", + "====> Epoch: 29 Average loss: 0.4146 Average VAE loss: 0.1634 Average STL loss: 0.0628\n", + "Train Epoch: 30 [0/384 (0%)]\tLoss: 0.459373 VAE loss: 0.216106 STL loss: 0.060817\n", + "Train Epoch: 30 [160/384 (42%)]\tLoss: 0.334692 VAE loss: 0.121084 STL loss: 0.053402\n", + "Train Epoch: 30 [320/384 (83%)]\tLoss: 0.265007 VAE loss: 0.032470 STL loss: 0.058134\n", + "====> Epoch: 30 Average loss: 0.3909 Average VAE loss: 0.1512 Average STL loss: 0.0599\n", + "Train Epoch: 31 [0/384 (0%)]\tLoss: 0.218207 VAE loss: 0.017775 STL loss: 0.050108\n", + "Train Epoch: 31 [160/384 (42%)]\tLoss: 0.205645 VAE loss: 0.001879 STL loss: 0.050942\n", + "Train Epoch: 31 [320/384 (83%)]\tLoss: 0.234063 VAE loss: 0.022856 STL loss: 0.052802\n", + "====> Epoch: 31 Average loss: 0.2426 Average VAE loss: 0.0364 Average STL loss: 0.0515\n", + "Train Epoch: 32 [0/384 (0%)]\tLoss: 0.221524 VAE loss: 0.017394 STL loss: 0.051032\n", + "Train Epoch: 32 [160/384 (42%)]\tLoss: 0.237916 VAE loss: 0.023607 STL loss: 0.053577\n", + "Train Epoch: 32 [320/384 (83%)]\tLoss: 0.205960 VAE loss: 0.008031 STL loss: 0.049482\n", + "====> Epoch: 32 Average loss: 0.2241 Average VAE loss: 0.0203 Average STL loss: 0.0510\n", + "Train Epoch: 33 [0/384 (0%)]\tLoss: 0.194409 VAE loss: -0.006343 STL loss: 0.050188\n", + "Train Epoch: 33 [160/384 (42%)]\tLoss: 0.223633 VAE loss: 0.024431 STL loss: 0.049800\n", + "Train Epoch: 33 [320/384 (83%)]\tLoss: 0.196277 VAE loss: -0.001116 STL loss: 0.049348\n", + "====> Epoch: 33 Average loss: 0.2051 Average VAE loss: 0.0082 Average STL loss: 0.0492\n", + "Train Epoch: 34 [0/384 (0%)]\tLoss: 0.214772 VAE loss: 0.022850 STL loss: 0.047980\n", + "Train Epoch: 34 [160/384 (42%)]\tLoss: 0.225480 VAE loss: 0.020545 STL loss: 0.051234\n", + "Train Epoch: 34 [320/384 (83%)]\tLoss: 0.252722 VAE loss: 0.049269 STL loss: 0.050863\n", + "====> Epoch: 34 Average loss: 0.2247 Average VAE loss: 0.0273 Average STL loss: 0.0493\n", + "Train Epoch: 35 [0/384 (0%)]\tLoss: 0.199892 VAE loss: 0.006685 STL loss: 0.048302\n", + "Train Epoch: 35 [160/384 (42%)]\tLoss: 0.214810 VAE loss: 0.021809 STL loss: 0.048250\n", + "Train Epoch: 35 [320/384 (83%)]\tLoss: 0.202525 VAE loss: 0.006425 STL loss: 0.049025\n", + "====> Epoch: 35 Average loss: 0.2222 Average VAE loss: 0.0281 Average STL loss: 0.0485\n", + "Train Epoch: 36 [0/384 (0%)]\tLoss: 0.183210 VAE loss: -0.005780 STL loss: 0.047248\n", + "Train Epoch: 36 [160/384 (42%)]\tLoss: 0.196391 VAE loss: 0.006612 STL loss: 0.047445\n", + "Train Epoch: 36 [320/384 (83%)]\tLoss: 0.205728 VAE loss: 0.010440 STL loss: 0.048822\n", + "====> Epoch: 36 Average loss: 0.2057 Average VAE loss: 0.0135 Average STL loss: 0.0481\n", + "Train Epoch: 37 [0/384 (0%)]\tLoss: 0.197350 VAE loss: 0.003457 STL loss: 0.048473\n", + "Train Epoch: 37 [160/384 (42%)]\tLoss: 0.185429 VAE loss: -0.008313 STL loss: 0.048435\n", + "Train Epoch: 37 [320/384 (83%)]\tLoss: 0.231007 VAE loss: 0.040131 STL loss: 0.047719\n", + "====> Epoch: 37 Average loss: 0.2109 Average VAE loss: 0.0198 Average STL loss: 0.0478\n", + "Train Epoch: 38 [0/384 (0%)]\tLoss: 0.348920 VAE loss: 0.158874 STL loss: 0.047511\n", + "Train Epoch: 38 [160/384 (42%)]\tLoss: 0.247577 VAE loss: 0.057347 STL loss: 0.047557\n", + "Train Epoch: 38 [320/384 (83%)]\tLoss: 0.183190 VAE loss: -0.008134 STL loss: 0.047831\n", + "====> Epoch: 38 Average loss: 0.2092 Average VAE loss: 0.0173 Average STL loss: 0.0480\n", + "Train Epoch: 39 [0/384 (0%)]\tLoss: 0.226953 VAE loss: 0.034232 STL loss: 0.048180\n", + "Train Epoch: 39 [160/384 (42%)]\tLoss: 0.189318 VAE loss: -0.001534 STL loss: 0.047713\n", + "Train Epoch: 39 [320/384 (83%)]\tLoss: 0.220675 VAE loss: 0.029371 STL loss: 0.047826\n", + "====> Epoch: 39 Average loss: 0.2094 Average VAE loss: 0.0171 Average STL loss: 0.0481\n", + "Train Epoch: 40 [0/384 (0%)]\tLoss: 0.233664 VAE loss: 0.040096 STL loss: 0.048392\n", + "Train Epoch: 40 [160/384 (42%)]\tLoss: 0.179644 VAE loss: -0.010040 STL loss: 0.047421\n", + "Train Epoch: 40 [320/384 (83%)]\tLoss: 0.273604 VAE loss: 0.083272 STL loss: 0.047583\n", + "====> Epoch: 40 Average loss: 0.2223 Average VAE loss: 0.0316 Average STL loss: 0.0477\n", + "Train Epoch: 41 [0/384 (0%)]\tLoss: 0.186829 VAE loss: -0.002099 STL loss: 0.047232\n", + "Train Epoch: 41 [160/384 (42%)]\tLoss: 0.226707 VAE loss: 0.035495 STL loss: 0.047803\n", + "Train Epoch: 41 [320/384 (83%)]\tLoss: 0.185022 VAE loss: -0.004940 STL loss: 0.047490\n", + "====> Epoch: 41 Average loss: 0.2155 Average VAE loss: 0.0251 Average STL loss: 0.0476\n", + "Train Epoch: 42 [0/384 (0%)]\tLoss: 0.181879 VAE loss: -0.007873 STL loss: 0.047438\n", + "Train Epoch: 42 [160/384 (42%)]\tLoss: 0.181694 VAE loss: -0.006340 STL loss: 0.047009\n", + "Train Epoch: 42 [320/384 (83%)]\tLoss: 0.224442 VAE loss: 0.031493 STL loss: 0.048237\n", + "====> Epoch: 42 Average loss: 0.2071 Average VAE loss: 0.0166 Average STL loss: 0.0476\n", + "Train Epoch: 43 [0/384 (0%)]\tLoss: 0.189241 VAE loss: -0.001318 STL loss: 0.047640\n", + "Train Epoch: 43 [160/384 (42%)]\tLoss: 0.178906 VAE loss: -0.010223 STL loss: 0.047282\n", + "Train Epoch: 43 [320/384 (83%)]\tLoss: 0.267575 VAE loss: 0.078357 STL loss: 0.047305\n", + "====> Epoch: 43 Average loss: 0.2145 Average VAE loss: 0.0241 Average STL loss: 0.0476\n", + "Train Epoch: 44 [0/384 (0%)]\tLoss: 0.263971 VAE loss: 0.072247 STL loss: 0.047931\n", + "Train Epoch: 44 [160/384 (42%)]\tLoss: 0.192702 VAE loss: 0.000901 STL loss: 0.047950\n", + "Train Epoch: 44 [320/384 (83%)]\tLoss: 0.175552 VAE loss: -0.013263 STL loss: 0.047204\n", + "====> Epoch: 44 Average loss: 0.2028 Average VAE loss: 0.0134 Average STL loss: 0.0474\n", + "Train Epoch: 45 [0/384 (0%)]\tLoss: 0.178377 VAE loss: -0.010819 STL loss: 0.047299\n", + "Train Epoch: 45 [160/384 (42%)]\tLoss: 0.271743 VAE loss: 0.081352 STL loss: 0.047598\n", + "Train Epoch: 45 [320/384 (83%)]\tLoss: 0.188281 VAE loss: -0.002507 STL loss: 0.047697\n", + "====> Epoch: 45 Average loss: 0.2093 Average VAE loss: 0.0191 Average STL loss: 0.0476\n", + "Train Epoch: 46 [0/384 (0%)]\tLoss: 0.182921 VAE loss: -0.006653 STL loss: 0.047393\n", + "Train Epoch: 46 [160/384 (42%)]\tLoss: 0.182119 VAE loss: -0.007802 STL loss: 0.047480\n", + "Train Epoch: 46 [320/384 (83%)]\tLoss: 0.195687 VAE loss: 0.005736 STL loss: 0.047488\n", + "====> Epoch: 46 Average loss: 0.2083 Average VAE loss: 0.0179 Average STL loss: 0.0476\n", + "Train Epoch: 47 [0/384 (0%)]\tLoss: 0.204967 VAE loss: 0.012747 STL loss: 0.048055\n", + "Train Epoch: 47 [160/384 (42%)]\tLoss: 0.192232 VAE loss: 0.002024 STL loss: 0.047552\n", + "Train Epoch: 47 [320/384 (83%)]\tLoss: 0.190892 VAE loss: 0.000539 STL loss: 0.047588\n", + "====> Epoch: 47 Average loss: 0.2054 Average VAE loss: 0.0147 Average STL loss: 0.0477\n", + "Train Epoch: 48 [0/384 (0%)]\tLoss: 0.179875 VAE loss: -0.008169 STL loss: 0.047011\n", + "Train Epoch: 48 [160/384 (42%)]\tLoss: 0.192004 VAE loss: 0.001894 STL loss: 0.047527\n", + "Train Epoch: 48 [320/384 (83%)]\tLoss: 0.231242 VAE loss: 0.037248 STL loss: 0.048498\n", + "====> Epoch: 48 Average loss: 0.2014 Average VAE loss: 0.0100 Average STL loss: 0.0478\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 49 [0/384 (0%)]\tLoss: 0.187437 VAE loss: -0.000636 STL loss: 0.047018\n", + "Train Epoch: 49 [160/384 (42%)]\tLoss: 0.174144 VAE loss: -0.016466 STL loss: 0.047652\n", + "Train Epoch: 49 [320/384 (83%)]\tLoss: 0.216348 VAE loss: 0.026952 STL loss: 0.047349\n", + "====> Epoch: 49 Average loss: 0.2018 Average VAE loss: 0.0104 Average STL loss: 0.0478\n", + "Train Epoch: 50 [0/384 (0%)]\tLoss: 0.185187 VAE loss: -0.006103 STL loss: 0.047823\n", + "Train Epoch: 50 [160/384 (42%)]\tLoss: 0.186763 VAE loss: -0.006190 STL loss: 0.048238\n", + "Train Epoch: 50 [320/384 (83%)]\tLoss: 0.220691 VAE loss: 0.029652 STL loss: 0.047760\n", + "====> Epoch: 50 Average loss: 0.2073 Average VAE loss: 0.0167 Average STL loss: 0.0477\n" + ] + } + ], + "source": [ + "# VAE+STL training\n", + "tmax = 10\n", + "torch.manual_seed(seed)\n", + "losses = [[],[],[]]\n", + "for epoch in range(1, epochs + 1):\n", + " # annealing parameters as the training iterations progress\n", + " probs = 1/(1 + np.exp(-20./epochs*(epoch - epochs/2)))\n", + " temp = 1 - probs\n", + " scale = 0.1 + 10/(1 + np.exp(-20./epochs*(epoch - epochs/2)))\n", + " # perform a gradient step\n", + " loss = stlvae_train(epoch, temp, probs, scale, phic, λ=λ, ϵ=ϵ)\n", + " [losses[i].append(loss[i]) for i in range(3)]\n", + " # plot information and save plot\n", + " with torch.no_grad():\n", + " stlvae.eval()\n", + " test_output = stlvae.decode(z, test_x, probs=1., t_max=x.shape[1])\n", + " save_image(dataset.mean() + dataset.std()*test_output, epoch, \"stlvae\", tmax=tmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "fatal-rotation", + "metadata": {}, + "outputs": [], + "source": [ + "# save losses (train, vae, stl)\n", + "np.save(\"models/stlvae_train_loss\", losses[0])\n", + "np.save(\"models/stlvae_vae_loss\", losses[1])\n", + "np.save(\"models/stlvae_stl_loss\", losses[2])" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "silent-sharing", + "metadata": {}, + "outputs": [], + "source": [ + "# save model weights\n", + "torch.save(stlvae.state_dict(), \"models/stlvae.model\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "amino-gallery", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 1 [0/384 (0%)]\tLoss: 2.970942\n", + "Train Epoch: 1 [160/384 (42%)]\tLoss: 2.572201\n", + "Train Epoch: 1 [320/384 (83%)]\tLoss: 2.391666\n", + "====> Epoch: 1 Average loss: 2.2016\n", + "Train Epoch: 2 [0/384 (0%)]\tLoss: 2.243097\n", + "Train Epoch: 2 [160/384 (42%)]\tLoss: 2.231023\n", + "Train Epoch: 2 [320/384 (83%)]\tLoss: 2.002829\n", + "====> Epoch: 2 Average loss: 1.8199\n", + "Train Epoch: 3 [0/384 (0%)]\tLoss: 1.808337\n", + "Train Epoch: 3 [160/384 (42%)]\tLoss: 0.967865\n", + "Train Epoch: 3 [320/384 (83%)]\tLoss: 0.916489\n", + "====> Epoch: 3 Average loss: 1.2873\n", + "Train Epoch: 4 [0/384 (0%)]\tLoss: 0.715151\n", + "Train Epoch: 4 [160/384 (42%)]\tLoss: 0.613706\n", + "Train Epoch: 4 [320/384 (83%)]\tLoss: 0.554739\n", + "====> Epoch: 4 Average loss: 0.6802\n", + "Train Epoch: 5 [0/384 (0%)]\tLoss: 0.735316\n", + "Train Epoch: 5 [160/384 (42%)]\tLoss: 0.431258\n", + "Train Epoch: 5 [320/384 (83%)]\tLoss: 0.453716\n", + "====> Epoch: 5 Average loss: 0.4199\n", + "Train Epoch: 6 [0/384 (0%)]\tLoss: 0.339874\n", + "Train Epoch: 6 [160/384 (42%)]\tLoss: 0.295207\n", + "Train Epoch: 6 [320/384 (83%)]\tLoss: 0.303742\n", + "====> Epoch: 6 Average loss: 0.3005\n", + "Train Epoch: 7 [0/384 (0%)]\tLoss: 0.216596\n", + "Train Epoch: 7 [160/384 (42%)]\tLoss: 0.270402\n", + "Train Epoch: 7 [320/384 (83%)]\tLoss: 0.158000\n", + "====> Epoch: 7 Average loss: 0.2103\n", + "Train Epoch: 8 [0/384 (0%)]\tLoss: 0.142880\n", + "Train Epoch: 8 [160/384 (42%)]\tLoss: 0.156495\n", + "Train Epoch: 8 [320/384 (83%)]\tLoss: 0.141938\n", + "====> Epoch: 8 Average loss: 0.1391\n", + "Train Epoch: 9 [0/384 (0%)]\tLoss: 0.128062\n", + "Train Epoch: 9 [160/384 (42%)]\tLoss: 0.114316\n", + "Train Epoch: 9 [320/384 (83%)]\tLoss: 0.068841\n", + "====> Epoch: 9 Average loss: 0.0962\n", + "Train Epoch: 10 [0/384 (0%)]\tLoss: 0.090866\n", + "Train Epoch: 10 [160/384 (42%)]\tLoss: 0.073294\n", + "Train Epoch: 10 [320/384 (83%)]\tLoss: 0.038340\n", + "====> Epoch: 10 Average loss: 0.0751\n", + "Train Epoch: 11 [0/384 (0%)]\tLoss: 0.070461\n", + "Train Epoch: 11 [160/384 (42%)]\tLoss: 0.068385\n", + "Train Epoch: 11 [320/384 (83%)]\tLoss: 0.049844\n", + "====> Epoch: 11 Average loss: 0.0623\n", + "Train Epoch: 12 [0/384 (0%)]\tLoss: 0.057555\n", + "Train Epoch: 12 [160/384 (42%)]\tLoss: 0.041647\n", + "Train Epoch: 12 [320/384 (83%)]\tLoss: 0.058305\n", + "====> Epoch: 12 Average loss: 0.0504\n", + "Train Epoch: 13 [0/384 (0%)]\tLoss: 0.056850\n", + "Train Epoch: 13 [160/384 (42%)]\tLoss: 0.051218\n", + "Train Epoch: 13 [320/384 (83%)]\tLoss: 0.026828\n", + "====> Epoch: 13 Average loss: 0.0408\n", + "Train Epoch: 14 [0/384 (0%)]\tLoss: 0.037437\n", + "Train Epoch: 14 [160/384 (42%)]\tLoss: 0.040779\n", + "Train Epoch: 14 [320/384 (83%)]\tLoss: 0.025955\n", + "====> Epoch: 14 Average loss: 0.0340\n", + "Train Epoch: 15 [0/384 (0%)]\tLoss: 0.031506\n", + "Train Epoch: 15 [160/384 (42%)]\tLoss: 0.027187\n", + "Train Epoch: 15 [320/384 (83%)]\tLoss: 0.027338\n", + "====> Epoch: 15 Average loss: 0.0283\n", + "Train Epoch: 16 [0/384 (0%)]\tLoss: 0.029887\n", + "Train Epoch: 16 [160/384 (42%)]\tLoss: 0.031581\n", + "Train Epoch: 16 [320/384 (83%)]\tLoss: 0.053160\n", + "====> Epoch: 16 Average loss: 0.0258\n", + "Train Epoch: 17 [0/384 (0%)]\tLoss: 0.022314\n", + "Train Epoch: 17 [160/384 (42%)]\tLoss: 0.010096\n", + "Train Epoch: 17 [320/384 (83%)]\tLoss: 0.018939\n", + "====> Epoch: 17 Average loss: 0.0219\n", + "Train Epoch: 18 [0/384 (0%)]\tLoss: 0.015983\n", + "Train Epoch: 18 [160/384 (42%)]\tLoss: 0.017568\n", + "Train Epoch: 18 [320/384 (83%)]\tLoss: 0.009856\n", + "====> Epoch: 18 Average loss: 0.0185\n", + "Train Epoch: 19 [0/384 (0%)]\tLoss: 0.021781\n", + "Train Epoch: 19 [160/384 (42%)]\tLoss: 0.019201\n", + "Train Epoch: 19 [320/384 (83%)]\tLoss: 0.017457\n", + "====> Epoch: 19 Average loss: 0.0176\n", + "Train Epoch: 20 [0/384 (0%)]\tLoss: 0.014752\n", + "Train Epoch: 20 [160/384 (42%)]\tLoss: 0.012101\n", + "Train Epoch: 20 [320/384 (83%)]\tLoss: 0.010756\n", + "====> Epoch: 20 Average loss: 0.0203\n", + "Train Epoch: 21 [0/384 (0%)]\tLoss: 0.020715\n", + "Train Epoch: 21 [160/384 (42%)]\tLoss: 0.010473\n", + "Train Epoch: 21 [320/384 (83%)]\tLoss: 0.011804\n", + "====> Epoch: 21 Average loss: 0.0205\n", + "Train Epoch: 22 [0/384 (0%)]\tLoss: 0.003357\n", + "Train Epoch: 22 [160/384 (42%)]\tLoss: 0.010558\n", + "Train Epoch: 22 [320/384 (83%)]\tLoss: 0.012691\n", + "====> Epoch: 22 Average loss: 0.0288\n", + "Train Epoch: 23 [0/384 (0%)]\tLoss: 0.023746\n", + "Train Epoch: 23 [160/384 (42%)]\tLoss: 0.020081\n", + "Train Epoch: 23 [320/384 (83%)]\tLoss: 0.001536\n", + "====> Epoch: 23 Average loss: 0.0300\n", + "Train Epoch: 24 [0/384 (0%)]\tLoss: 0.021339\n", + "Train Epoch: 24 [160/384 (42%)]\tLoss: 0.070244\n", + "Train Epoch: 24 [320/384 (83%)]\tLoss: 0.036534\n", + "====> Epoch: 24 Average loss: 0.0441\n", + "Train Epoch: 25 [0/384 (0%)]\tLoss: 0.068569\n", + "Train Epoch: 25 [160/384 (42%)]\tLoss: 0.031204\n", + "Train Epoch: 25 [320/384 (83%)]\tLoss: 0.038092\n", + "====> Epoch: 25 Average loss: 0.0620\n", + "Train Epoch: 26 [0/384 (0%)]\tLoss: 0.102622\n", + "Train Epoch: 26 [160/384 (42%)]\tLoss: 0.075387\n", + "Train Epoch: 26 [320/384 (83%)]\tLoss: 0.046135\n", + "====> Epoch: 26 Average loss: 0.1292\n", + "Train Epoch: 27 [0/384 (0%)]\tLoss: 0.093291\n", + "Train Epoch: 27 [160/384 (42%)]\tLoss: 0.191852\n", + "Train Epoch: 27 [320/384 (83%)]\tLoss: 0.509725\n", + "====> Epoch: 27 Average loss: 0.2695\n", + "Train Epoch: 28 [0/384 (0%)]\tLoss: 0.261325\n", + "Train Epoch: 28 [160/384 (42%)]\tLoss: 0.107980\n", + "Train Epoch: 28 [320/384 (83%)]\tLoss: 0.182839\n", + "====> Epoch: 28 Average loss: 0.3346\n", + "Train Epoch: 29 [0/384 (0%)]\tLoss: 0.378063\n", + "Train Epoch: 29 [160/384 (42%)]\tLoss: 0.236965\n", + "Train Epoch: 29 [320/384 (83%)]\tLoss: 0.366123\n", + "====> Epoch: 29 Average loss: 0.3823\n", + "Train Epoch: 30 [0/384 (0%)]\tLoss: 0.388701\n", + "Train Epoch: 30 [160/384 (42%)]\tLoss: 2.081073\n", + "Train Epoch: 30 [320/384 (83%)]\tLoss: 2.165102\n", + "====> Epoch: 30 Average loss: 0.8414\n", + "Train Epoch: 31 [0/384 (0%)]\tLoss: 0.361891\n", + "Train Epoch: 31 [160/384 (42%)]\tLoss: 1.667571\n", + "Train Epoch: 31 [320/384 (83%)]\tLoss: 1.904497\n", + "====> Epoch: 31 Average loss: 1.0232\n", + "Train Epoch: 32 [0/384 (0%)]\tLoss: 1.836227\n", + "Train Epoch: 32 [160/384 (42%)]\tLoss: 0.992350\n", + "Train Epoch: 32 [320/384 (83%)]\tLoss: 2.118160\n", + "====> Epoch: 32 Average loss: 1.3171\n", + "Train Epoch: 33 [0/384 (0%)]\tLoss: 1.719831\n", + "Train Epoch: 33 [160/384 (42%)]\tLoss: 1.076046\n", + "Train Epoch: 33 [320/384 (83%)]\tLoss: 1.311325\n", + "====> Epoch: 33 Average loss: 1.3833\n", + "Train Epoch: 34 [0/384 (0%)]\tLoss: 2.047475\n", + "Train Epoch: 34 [160/384 (42%)]\tLoss: 0.968365\n", + "Train Epoch: 34 [320/384 (83%)]\tLoss: 1.474731\n", + "====> Epoch: 34 Average loss: 1.6383\n", + "Train Epoch: 35 [0/384 (0%)]\tLoss: 2.009158\n", + "Train Epoch: 35 [160/384 (42%)]\tLoss: 1.148303\n", + "Train Epoch: 35 [320/384 (83%)]\tLoss: 1.312066\n", + "====> Epoch: 35 Average loss: 1.6623\n", + "Train Epoch: 36 [0/384 (0%)]\tLoss: 1.965621\n", + "Train Epoch: 36 [160/384 (42%)]\tLoss: 2.197543\n", + "Train Epoch: 36 [320/384 (83%)]\tLoss: 1.225801\n", + "====> Epoch: 36 Average loss: 1.8625\n", + "Train Epoch: 37 [0/384 (0%)]\tLoss: 2.005820\n", + "Train Epoch: 37 [160/384 (42%)]\tLoss: 1.890587\n", + "Train Epoch: 37 [320/384 (83%)]\tLoss: 2.022861\n", + "====> Epoch: 37 Average loss: 1.9866\n", + "Train Epoch: 38 [0/384 (0%)]\tLoss: 1.999997\n", + "Train Epoch: 38 [160/384 (42%)]\tLoss: 2.067119\n", + "Train Epoch: 38 [320/384 (83%)]\tLoss: 2.209812\n", + "====> Epoch: 38 Average loss: 1.9199\n", + "Train Epoch: 39 [0/384 (0%)]\tLoss: 2.080935\n", + "Train Epoch: 39 [160/384 (42%)]\tLoss: 1.533925\n", + "Train Epoch: 39 [320/384 (83%)]\tLoss: 2.291311\n", + "====> Epoch: 39 Average loss: 1.9635\n", + "Train Epoch: 40 [0/384 (0%)]\tLoss: 2.327537\n", + "Train Epoch: 40 [160/384 (42%)]\tLoss: 1.899534\n", + "Train Epoch: 40 [320/384 (83%)]\tLoss: 2.407310\n", + "====> Epoch: 40 Average loss: 2.0542\n", + "Train Epoch: 41 [0/384 (0%)]\tLoss: 1.603349\n", + "Train Epoch: 41 [160/384 (42%)]\tLoss: 1.695653\n", + "Train Epoch: 41 [320/384 (83%)]\tLoss: 1.708975\n", + "====> Epoch: 41 Average loss: 1.9776\n", + "Train Epoch: 42 [0/384 (0%)]\tLoss: 2.545129\n", + "Train Epoch: 42 [160/384 (42%)]\tLoss: 2.037652\n", + "Train Epoch: 42 [320/384 (83%)]\tLoss: 2.056539\n", + "====> Epoch: 42 Average loss: 2.0251\n", + "Train Epoch: 43 [0/384 (0%)]\tLoss: 1.582168\n", + "Train Epoch: 43 [160/384 (42%)]\tLoss: 1.492371\n", + "Train Epoch: 43 [320/384 (83%)]\tLoss: 2.159848\n", + "====> Epoch: 43 Average loss: 2.0113\n", + "Train Epoch: 44 [0/384 (0%)]\tLoss: 2.315844\n", + "Train Epoch: 44 [160/384 (42%)]\tLoss: 1.946497\n", + "Train Epoch: 44 [320/384 (83%)]\tLoss: 1.881635\n", + "====> Epoch: 44 Average loss: 2.0313\n", + "Train Epoch: 45 [0/384 (0%)]\tLoss: 1.807862\n", + "Train Epoch: 45 [160/384 (42%)]\tLoss: 1.996638\n", + "Train Epoch: 45 [320/384 (83%)]\tLoss: 2.101772\n", + "====> Epoch: 45 Average loss: 2.0251\n", + "Train Epoch: 46 [0/384 (0%)]\tLoss: 1.502114\n", + "Train Epoch: 46 [160/384 (42%)]\tLoss: 1.887619\n", + "Train Epoch: 46 [320/384 (83%)]\tLoss: 2.778258\n", + "====> Epoch: 46 Average loss: 2.0328\n", + "Train Epoch: 47 [0/384 (0%)]\tLoss: 2.602746\n", + "Train Epoch: 47 [160/384 (42%)]\tLoss: 2.032587\n", + "Train Epoch: 47 [320/384 (83%)]\tLoss: 1.989703\n", + "====> Epoch: 47 Average loss: 2.0206\n", + "Train Epoch: 48 [0/384 (0%)]\tLoss: 1.940129\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 48 [160/384 (42%)]\tLoss: 1.975650\n", + "Train Epoch: 48 [320/384 (83%)]\tLoss: 1.879667\n", + "====> Epoch: 48 Average loss: 2.0172\n", + "Train Epoch: 49 [0/384 (0%)]\tLoss: 2.410706\n", + "Train Epoch: 49 [160/384 (42%)]\tLoss: 1.482435\n", + "Train Epoch: 49 [320/384 (83%)]\tLoss: 1.855611\n", + "====> Epoch: 49 Average loss: 2.0128\n", + "Train Epoch: 50 [0/384 (0%)]\tLoss: 1.935903\n", + "Train Epoch: 50 [160/384 (42%)]\tLoss: 1.838868\n", + "Train Epoch: 50 [320/384 (83%)]\tLoss: 2.087361\n", + "====> Epoch: 50 Average loss: 2.0008\n" + ] + } + ], + "source": [ + "# VAE training\n", + "torch.manual_seed(seed)\n", + "vae_losses = []\n", + "for epoch in range(1, epochs + 1):\n", + " # annealing parameters as the training iterations progress\n", + " probs = 1/(1 + np.exp(-20./epochs*(epoch - epochs/2)))\n", + " temp = 1 - probs\n", + " # perform a gradient step\n", + " loss = vae_train(epoch, temp, probs)\n", + " vae_losses.append(loss)\n", + " # plot information and save plot\n", + " with torch.no_grad():\n", + " vae.eval()\n", + " test_output = vae.decode(z, test_x.repeat([test_k, 1, 1]), probs=1., t_max=x.shape[1])\n", + " save_image(dataset.mean() + dataset.std()*test_output, epoch, \"vae\", tmax=tmax)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "sapphire-concentration", + "metadata": {}, + "outputs": [], + "source": [ + "# save training loss (i.e., vae loss)\n", + "np.save(\"models/vae_train_loss\", vae_losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "general-zambia", + "metadata": {}, + "outputs": [], + "source": [ + "# save model weights\n", + "torch.save(vae.state_dict(), \"models/vae.model\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "sufficient-dressing", + "metadata": {}, + "outputs": [], + "source": [ + "# generate new outputs \n", + "with torch.no_grad():\n", + " stlvae.eval()\n", + " vae.eval()\n", + "\n", + " stlvae_output = dataset.mean() + dataset.std()*stlvae.decode(z, test_x, probs=1., t_max=x.shape[1])\n", + " vae_output = dataset.mean() + dataset.std()*vae.decode(z, test_x.repeat([test_k, 1, 1]), probs=1., t_max=x.shape[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "consolidated-rebecca", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fontsize = 24\n", + "color_list = ['#1f77b4', '#2ca02c', '#ff7f0e', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']\n", + "colors = color_list[:3]\n", + "\n", + "plt.figure(figsize=(20,5))\n", + "\n", + "plt.subplot(1,3,1)\n", + "plt.plot(t, y1, linewidth=4)\n", + "plt.plot(t, y2, linewidth=4)\n", + "plt.plot(t, y3, linewidth=4)\n", + "\n", + "plt.scatter(t, y1, linewidth=4)\n", + "plt.scatter(t, y2, linewidth=4)\n", + "plt.scatter(t, y3, linewidth=4)\n", + "\n", + "plt.plot(t, noisy_y1.T, alpha=alpha, c=\"lightskyblue\")\n", + "plt.plot(t, noisy_y2.T, alpha=alpha, c=\"orange\")\n", + "plt.plot(t, noisy_y3.T, alpha=alpha, c=\"green\")\n", + "\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.title(\"Training data\", fontsize=fontsize+8)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.grid()\n", + "\n", + "\n", + "plt.subplot(1,3,3)\n", + "for i in range(3):\n", + " plt.plot(np.arange(0, tmax, 0.25), stlvae_output.squeeze().detach().cpu()[4*i:4*i+4,:].T, linewidth=3, c=color_list[i], alpha=0.5)\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.title(\"STL + VAE ($\\gamma $=%.2f)\"%λ, fontsize=fontsize+8)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.ylim([-0.1, 1.0])\n", + "plt.grid()\n", + "\n", + "\n", + "plt.subplot(1,3,2)\n", + "for i in range(3):\n", + " plt.plot(np.arange(0, tmax, 0.25), vae_output.squeeze().detach().cpu()[4*i:4*i+4,:].T, linewidth=3, c=color_list[i], alpha=0.5)\n", + "plt.xlabel(\"Time [s]\", fontsize=fontsize)\n", + "plt.ylabel(\"Signal\", fontsize=fontsize)\n", + "plt.title(\"VAE ($\\gamma $=0.00)\", fontsize=fontsize+8)\n", + "plt.xticks(fontsize=fontsize)\n", + "plt.yticks(fontsize=fontsize)\n", + "plt.ylim([-0.1, 1.0])\n", + "plt.grid()\n", + "plt.tight_layout()\n", + "# plt.savefig(\"figs/latentspace/latent_space_results.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "athletic-excerpt", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax1 = plt.subplots(figsize=(10,5))\n", + "ax1.tick_params(axis='x', labelsize=fontsize)\n", + "ax1.tick_params(axis='y', labelsize=fontsize)\n", + "\n", + "ax1.set_xlabel('Training iterations', fontsize=fontsize)\n", + "ax1.set_ylabel('VAE loss', fontsize=fontsize)\n", + "ax1.plot(vae_losses, label=\"VAE only\", linewidth=3)\n", + "ax1.plot(losses[1], label=\"STL+VAE\", linewidth=3)\n", + "# ax1.tick_params(axis='y', labelcolor=color)\n", + "ax1.grid()\n", + "ax1.legend(fontsize=fontsize-4)\n", + "\n", + "\n", + "eps = np.arange(epochs)\n", + "probs = 1/(1 + np.exp(-20./epochs*(eps - epochs/2)))\n", + "\n", + "ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\n", + "color = 'tab:green'\n", + "ax2.set_ylabel('Decoder sample probability', fontsize=fontsize, color=color) # we already handled the x-label with ax1\n", + "ax2.plot(probs, color=color, linewidth=1, label=\"Sample probability\")\n", + "ax2.tick_params(axis='y',labelsize=fontsize, color=color)\n", + "ax2.legend(fontsize=fontsize-4)\n", + "plt.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "organic-steering", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "@webio": { + "lastCommId": null, + "lastKernelId": null + }, + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/models/bump.npy b/examples/models/bump.npy new file mode 100644 index 0000000000000000000000000000000000000000..53127d19a274c41ed19b0309733e0ca5d0eda4de GIT binary patch literal 768 zcmbWy?MqW}6bJAX6rmy!#zK0yR5p!)52;0&X9z17+Jp#-mD^|=hURh`nr6#P=;1{L z&aw%u7aC?tqePL&v#e0VAj*YqZtmV`Dwz-Id_bAGbN_?BZ!YJ1KKI_=uln@a?40u( z1jT~uB8}E~$sjt)h|+XNL}Esy(;G|%b)iyk&}c*b33Y){yWSh~)K|6Zb8M2BNlu6p zGdGz3O_+d>Lq`c>A7vGj4u!IUwNFD?#^72gi>M*DfM3YXV*GRUpK5V=(-CKrU} zR;aF+W!I{7SYz|M%HII7X@X$_kyV?b}w@E#gy*^mndN-xW!@{XMZSKzb0jM&k zEPQzBhf3%1lQkR%6<2g`>+4u(eR3;)h2`My_I-|Sn;SA8R7N+Z4uj1b<#KLx!JhWg zTA|Dfk|w#eV*7=3yb7sKIzs4Soi j^Pz3EW+AKEj}ep6Q&Ts+XfewwEh;DGMa=I`leqC8obYx5 literal 0 HcmV?d00001 diff --git a/examples/models/bump_0.00.model b/examples/models/bump_0.00.model new file mode 100644 index 0000000000000000000000000000000000000000..c5c945a3c6237b5dbf7d9f3d7f49c1f1f9f3beef GIT binary patch literal 2455 zcmbVOdrVtZ7{7%AU6}oaJ`=eLl)fd;RS} z;f_En6`)$Tdfl`Th)O%~WR5~a-A>Va{eeAlg?umNZS&BO<);0JT<+|oy}qE(8K7D^ zy}ni_O|=L80cV#=2-z~3BM)JNXr`-;0zLx~T77;Oy^{$FA;-Z(a}<#4$VQ{PqZ9H- z0S$s?k{|^n?;xxpd3X>W@nApsG_1A5Jq{7eREyUY1d#_RdiWlOQ3(Z}BvWCMsTb}g zdA%TJSk}={WQY4$OH(Z^?S2-I3f3bYGYt&sZ;_}2pTfuN-&3@F*B|LO9-}P#?`Pj1luy> z8nA|-DH-n!w#aQ{o}g&pgmXTNAaJ)WTR0-3m{mBn3ae#3r)*L+^q0A(;n>Ni8wLxm z#0P4RB?{(lRZ4!_9v9}nJ#wXL(1c}g|3Vi_(8_VYo9t$`tkPh*l z!S12>+3`0MpAYv(Izm$8T=^yG+`^ABtgq_sZdrxCY9;!+KMI?A4?bxcLsi^|w)MMj zZ$w(rI_F;&MZCuiMs3M{!&?(y>aS6v*s!=IcIuVr$R|QUtnYOD$P=&fjWhj2G3v$r zvCn>=HoS1D+9(((j411-4a&X}sr2U8(S2p_Cgy`(3F+uUeCG$BCUn=vM&s36;-~C? zRE)U$I@kp~Ne*Ul| z5&riJnf6yj>|)LH(#WJZ{%kf8u1DVUjXm|}N0s`f>*Du&k4)(Pp0{o~Ob}u7J39U7 zA))^A!1q&UTR|KKp#tRtrJo9%_t# zc$F|wlcX_vAZn_5#%VZvwaZk~Ts(Pv_m~0mKkhoSeHG`YS;_g`XgX&)(Ik%t{>d?w zZ4;Zn`dDl{`P#mQS&vEIw__oS^|QotPpv{5y5+l7*sz}-gj@Q}Jw(_b3+Dr7hA4a-HR*FL_p?lc{` z@6yq=3NALiZrRugE>_9KrspIZt3X@K(p7P>>G{USzLCShs=3(oTw!Bxaj_aMHa!Q} z*p6I|u9k~UKf!`Kn~a_=rePOz#zyAmRxeK4kX@6SzVsEfH2#E(8Z|rqj6n_Il22NE VkD-SDwvjnV0Hq81;rYzm{{SreZ9)J5 literal 0 HcmV?d00001 diff --git a/examples/models/bump_2.00.model b/examples/models/bump_2.00.model new file mode 100644 index 0000000000000000000000000000000000000000..19bcfc8bdad84e6141505f49fdaf450ffe856e37 GIT binary patch literal 2455 zcmbVOZA@EL7`~-^l&%8K%?$?#$biD=H!w;mtQ%d-ov!Pgsr(R2Tib?Gc-vbxe^iIa z+}O;FI}obMy8* zANQR1J?9!oej-5#1VmiRAl4FQkHz6^w@IyL$}DMXcIkC#L<6fGOt4s5T`rr2a<;m? z!rdOL&119fa9SuK5Mm?nicJ}a+HIruw|bf-GRc0M)9#=k!9ukna!I3)a=N_2Mvtw@ z=X6;cDVy8d>S=6O2!UT*Y)U~`FPdq#+aQsF2=%U3Gqslq3L(kFLvv)1Y~rKQ(&mE{ zQb2)V4@r;$l6MGFNgf`AM;zGC8VW>4xX+ZvGS%cXdm+t%6dj2UhEWdbjtEmmgsBVe zCwX14mSK5-f^|k%&w4e*(yKkl;!(f`#8XGXM#hog5M(mO9%8sQQIKVXY?dR1B;qKC z#iWFX8ArK`j`Fahe1_!_3JQ#{ndL~epj_cD}f+zH!NE?X~ZU0;YekA-3CtCL~H0wy|Q+Ca%XKo z+(z%4Z=prOXUBdT%;=x%nJdcqyR#O{e%_p3m5bgS_j}0}uw~_XUG8$SQT>yle0pY9 zPTS|)bfBb#Zs*0N&!Z~tM$5XO z9O`oLOZz(N-W)iR-K_2Z@ayW~f3B*nx6h7C=U*S6EW9Zh?#w$qw};$p|9(1{_`;=d znd4^oGbLYBapRBbfN1POdeZUU(uEU+yS8Ob6v^Mv^tn4V-@Nu%DD_WWNIo?xeQNB- zzR3*Dz;jQ3s>!zWgq}PX4D~I{s?UFQU7hab4TW$2n)8Hcq+lTJ-_XmM&2-nJFVZuC z5nAjUrBnC|l|OWz>g^rrC<;vs(H{{nRaljWD&Ic6wc?_3{^Eg=adAJD`qto$(R|Sb zdu6@ju=?j~XVvDs-r!VecTj(2qlD=3Wj*emde@}nSL5|Pb%j1k;8P6sd+l!`dw-RB z9YMU3xqYJK;4d}WU7ysSjwj-#0zw%g>ui&x<^M}8?tX;+asaCRoUUgVo z=(-c`e(!+x*7ye#qN}@Wo-wNGK0YeGbf;n@g!P?u$M>#6zkDV74f^X7SYzTZl^b1T z1n$ePVLDM8UBkuWMz5>>-y(@tOZpDRK~@|)-4-5%*D#N*w~z8V`XTGS-J`?Ha6eb*jJM{SS1%5n=5SW z?_8{ki;c|zHnuI9qg&3!#_nMH-9<)E(=ph^oH3Be$y*jDx5AD++5{SV`Nc2ocW literal 0 HcmV?d00001 diff --git a/examples/models/bump_data_0.00.npy b/examples/models/bump_data_0.00.npy new file mode 100644 index 0000000000000000000000000000000000000000..595a8f5c6877bd7390257dee0658651054c3db48 GIT binary patch literal 448 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+l>qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I#y2098xnmP)#3giMV1_p)$_G=mU8ykP#|HOl7e_GnJ{hd#k_RpGmbH82# z^Zv7E&g{P|&9Wb;Y=6ae7NEM#`(=Y!f$Em+KlF|jsBY%|dy-%FojudD-{n#1J_d${ z{U6e%*rlbV?T@nAYj^gH&;BLH@7fs~8}ENH>8;(YnUec2d4943+Pi-T!*`(knSBek z{|1WB+~;D>U=LKkZ`ULyAbn=9&N~)+pgQ#hp6npLt=Ljdki1oo^RoxPkV6Hr{zKEdxh$UgfHu2&%Y?Kd5}19Ff3g^)g=y$$vgJ7$C2YkxIe~^X)IZ{JRer9`;M_eBB2OAN%U_Z}$Pi%Rb=H G(|rK&7_%Dy literal 0 HcmV?d00001 diff --git a/examples/models/bump_data_2.00.npy b/examples/models/bump_data_2.00.npy new file mode 100644 index 0000000000000000000000000000000000000000..761c178b2c4ca6d90ec252116e8d5603089fb74f GIT binary patch literal 448 zcmbR27wQ`j$;eQ~P_3SlTAW;@Zl$1ZlV+l>qoAIaUsO_*m=~X4l#&V(cT3DEP6dh= zXCxM+0{I#y2098xnmP)#3giMV1_p)$_X`>J8ykP#fA}!N{XD=Kk(< z#{Fl{oY|khlW{*#+5TW|CZM{_`z>Obfa;d*mtM~VR5x?~e+Fitx}N=WW7_sHFf{D9 z)A?qXmX@|ZNsQV4>=_?0ZES1|rf1ER1k*r!q4H<;fz$!b0neka zwovozpz6Ui(0yPUsLmcDE(xZA_JL`jd0-mo9{U)9-*!Ov*`Jc1y$|SKd(LhSko)aV z{pJGs$9~NcZjk@%Kdfa3`PZIlDac=E>@_U@?*oR1y|>!;eZcUs&l7pS4;WtdlbD|G F0{{+{pA7&2 literal 0 HcmV?d00001 diff --git a/examples/models/intent_0.00.model b/examples/models/intent_0.00.model new file mode 100644 index 0000000000000000000000000000000000000000..9f6eb05520ee36d19c22f9d3c80e57132e209884 GIT binary patch literal 3783 zcmbW43se->8OLW~c`XR55k!0hCBao-dB4K$9U)zNq6qGr-Gm!LZc@KW1*hLcp7S`B{Z=IOFOf(+MTI-D#N*F zmYMtiec%1={l0rgOLeh+EQ*(mRsnWipssp8jG#ON*ioeLumr^ zGSL;R5v8Guww2mthDu9um95llpe^P0ib_Luk_>t)6na0FVP|_9ODs^zOJthT3M0Ll ze<*`KdI{Sn0s88_*}G|974)OzH1yA>2ue;#8esq>;cl`fE9X}r4TE%W&f}c3x||EP zvbL>KE6+}ZAyz+XH4WuFQ`!jUQc{jNk7qtZ!}&TGst*$lxY%a2yN4SlASS^DERppx z+(m4F3n@thjNoaDXt-Dhmpq!r`?pj;ONP(#v`9B?8An^r)1qkjoDM#(U(EVuwwRQa z<>iJ)PDr$XnF3evOvS@EuH@smis#1AFjfcSp2X#SRSLMNFrJTP!oyf5^07?fxydw4 z(ZN)G#3TImh-aFBng-K(Z!_Ex$mAmM0#D4Mp-KnUk0o0!cJb9my5 zG<-=1bM*_{KJKfm*dq!m)Ch1Ha1D!-(r_(@lThpuTE`E2J&&YlxIqUu>O&ue|5omP>lracZcv)>v;J*3?_4f!To6eXBwNV7bM;uC9z&MB-;ZtA zj$ovXyzwl15 z^Y3B!!0B&MpWzh1MS0{q{vSA}YADcIH-O%{5lRMY7GU4?FQbz`Jb{we?;?vL!ok7e zUR2Pw2z_;V0&VP#AvY^dg0|zGsw4fsXS(Wg&@a;W0NJJU=#x9;jJNGDx)L&6Y?G8i;-hHOny zBE$02Ahr7p8ozM?d>Pk@xcE5-cAq4;>dm&Nh+h&Hzt_KTqI|-Oyc_s682vzwZxq?k zXO0o(%Aci-bH`87#}grBkHHJsji=NLU$_XE_$y$2Z!}8XV?x(e0j~MG0y^utx#QYX z*iYu{|D*mx5RwxMPHg%adUt0pn!7(7EUJ44NYi3bRwjkK2Cp;DUq*r8rYV$NatJA6 zwyBKowxID1&FUXbcd5DYU$Yt&v#_7S*~gznGc5^!165E?4u4mRYNK95%P)1HfqO@p z+hvJrOG%Hq`oyd1iT$rL-!8t-Xnx#->UJMPYmEI&y3Y?>@lR@a|5vlHpUT<)t+Z3M zs<}<2PV&OvL^gqK_Zso&#R8OHS3z!iV;J2Um|}*i!$FHF4*auo1RQZ7mH$u9fbPMy zSouNSy_^X?@(dGILq)&k#YP8#M>AV^|J_*6Dyb^3FoI&*~+MGk#(WJF_1>W=T z<7lKk1;@xIL1F2iko0>q%wKff=%8OXR`yJzvZ>dAZ1mUQ>+V<_wtNB{Z3lRC-6%6O z5J!eKHKX@ha>?9NDPUJ*KF$ny6ZGBc19xF7BCEQcrGynJ?)c*AVKV}&bIG-v&5YwM z4Vv#A1;%Hx!KGUy3c4SJ!!K@O+Als&UQKKP-29nyl0Kcq`c32F*A?c2Cws;|HqG_H zq21m%(0LNQeK3IR*xJtQ9ZFNBf()?Lw;jyc>y686Uj$%!5-sr>2kTxLWj?RRF8hOR z-_^`w{?a-7gK~rFn%^?@N<};x3+h5+f4!&rDDW`&XiE_o8tGQw94JF^aZRY*(gbeP z-r#1L5#9HXAeSyX3`VvGFx>bT7S?yn!hQy4-#oSt1!f%wbr;T}@1H&I;(eIAF_7CK zxb~!cOcB=8OifP0|6TVVYy#V_>RmY?X;s}}w;6(KkGB~@kPmITH%m=U)>9jOV4S@t z%eV;sp{=CQi?z%(EhXV@56|SDyC4@4;Uzwyi`AZcQ?NjKiXEz_IzByt#5f-<1+!;Yj`LGL!AcELG Iu0P-RKZoohFaQ7m literal 0 HcmV?d00001 diff --git a/examples/models/intent_0.10.model b/examples/models/intent_0.10.model new file mode 100644 index 0000000000000000000000000000000000000000..29f107115fb75b4613c7cf6ed26cebb88bcfee51 GIT binary patch literal 3783 zcmbVP3se(V8lDiI;S~gYprR|{0z!DdG;;?Lu^5pUK(khiAsI;o!5ao#*Ub^Ds2pv< zR&i;Svb(I>9*@i@bo19r^$&igx+E>nXBnoqn^<#)|QrKXZjJ#1g*x!V5lf7qYaF? zqP$X;XED+i+L&cFFfvF)YM>-SJD#Ja%MFThnpsz2DOIea%_SyAXEy1|;-HIxso+Eu zx+=z8Rw>h2=;A7KnNi2k<&_l{U3G#CN+Tk)9vnv{w^Cn1LsuRm%Py zf=W^gLwL4{44kBalb_7S+ZQTeON3K+wy6%b-(a?BJX;t8r)yxib`ocskv1qS<>k63 zzK|IL&LsF-o-<;^kCD6|qj=t#42;&mm}l|wwkia?$uO4pW!#7_<9S~u@Vto(Owzz) zZO9Ysb@FG5fHeiC^46v~Jdln(FpFoL%|N9Fl22#k?F0hGR7mlR84kudm@$)QoXfy0 z4Vr^bgm410n(Pol*8hKmG* z=`fEYlrT_jC#;2wv3(kzET4e|8dz9mg-f(v9HDLv&FFC|!=?5d&_-yvSpxpf3YXb4 zteUn|a%l`-R7ooBX~d;1TyBL$Ci{#xx7aC>;R-9%@lSBdaZv?VTA`kw@#klp;|vyC zp@DxYcRY3W7&KZTZGT)xyL<{OvY+QC`gs4ghN|xZC zueLRVz#m&}VF?;GXXr9IH~2A`ly5}2w}(+lKLUj{FQIWCeF4r7xv;cyIja8r1lm!Q z$_@wmvE4E80NXiboUb&4+Y#>1veQ*)XMA=hK@1HHlPI_u%nSS)-Hhr&(H&Os2UQ~Y z{(TC>t-25NdCep+MxmbkZ0hg}JJD+sGTGsft7zxYUggmRNhFo?A-Z{L3knSX0Cfz8 zvUHyYWoBgnVuuUWagGJ)&EJxr(eCV;34@^ZyLZv-M|mt3Gbcv3kJ)+=Wgl!Fbu|01J5^=3T_4}uM^yR%CU58DoWv{c!x>i{cTj)1v-m3F*D1R8Pzv5M1w%9^G#u+bgz%-HYmgN7HmF?5}6Q zywVWczuRKiH?5mMa_&0_`|q2Y^DYFg-dukU|0Q7m-JN?4h1Q2tt0Z!&Vd;RaeU&e` zWBi#sSvD5zy%7K=|2+xR9Q+hb+*b=Ou0KWI2CmeN@7@9}EvHe=^{bs&KRKvQf!`hO z&!L})^-qM=gI=&7oIP5AKK|nw^2$XiwX#!2ZT~4n*-vi(X9pjkGZ|8p=hlSwmiVwP zlsm{+qz5|vF5gOr^Zh4z}Kzhk{r1lSdXVLR~#E zw$JL@fFXC9?b_*eU~cPm)aCsrtmjrjufPW7c)-q{Ws zQb`m!JeKX6Vo`>C5Cx9B7mYfn{esTt__4>Am{GT@f_=FERit$9BM)Nd#+=a&N2Mj6{tUxe~zykfhx>=O_= z!wVH`>{gyCY$k(y7u&vluO40Uyn@c%l~A(i9N@XfXwUzRpC7LqMf|2<|1IolK(k-2 z0dJEpqSnR&)Ci{{Rd^q8le-{8`xx+-9r2wWD^7v{!}o~1bRD^etU;4^Poj!{sGGI5 zjj+ehef`{Rqj-O*SpQgY4Y_-f*a{NFi_uzF1%fe z-tXHFPTwZjhN=#w_r5vQWv@11@#`XS{BCYN@cJn9)3AP2dk>m3B&C*5^kv7iEw$H! zS=O)m@d<(Zv+^-XSWnZlGvog6y8rkP_@!E5*StXL;<#gm!2Ri({sc9m={PL2GiN`y z=woqiOq5{{UTQ8Wbm5e7SF0p=7`c->pMuyU!Y00b*{@o ztlCY4jTd8`YpM|2;4Z=@h_TM~P>7Xt-vI)f6UA8PS|-Fch_OjxtaBa6JwoYUWjcGW7EZ0=ZM93y*s!lxi2vvN5_3$SD2ZNsl{P-wrgy+6rIj^oOV~#UazQg zR!ecqdd0Js+^@PjUOaKh-RaE#ecr&)&Ew4C=RKSqFP~ZbSV?XBmi0KzE$h`cZCQVN z{r}I!!^XOn5oQ(h&1oCEF%8zmNoYT6Q*Kty#LluV4nnp~JpTnZCia|lu@l()wO_3# zc4GCci;eJY{P2KnEE8M!%et_{^&7YDy2HerSober{vMvI`zDxJE$j7jm{O6?+8~o| zY#ZzQ&0=wuaoEPZE-aF@{tR~Et+TpK9uu2mE%yr>+k-b7dqu}ivDW*Ey`ZhC4GUyo z)vWcVu+gWHW5scFOqI3XBu2yQ`R`Tf#==?a{lE%)zkS;++Ko-I)*Hh*6K9yEzI2Sh zx_=n^y8KFm&^j6xzoG9qt+ejFH6-jh>wXH>n4*l+4J2Z#S+8%!Dhs%<>j^cO1?%fI*lj}KJO8WY7#r*3 z0&E9k#NwJrCHC+A_^LB_?)O;bPAg0|=Ko$$fUnUKsr)OOjUWGaKYli~>q&ZC8UEzI z_3_awnAzjgM0_>t>lD1ye)~jiaS~pXwICCJ%-`DAvx9~=`S5>gxSq2#d=BgWLHzb>XZU3OyYK`5em{7vXh)TLv2Hv+YrS#&f@E%;jU*YL#(Mn^ z{F>zkpKxawcsh3J3>yC0zxNLx7j}BVC610?&06m_ zzUF6hto%8~|JIwqcN&~ADgMgD>$BFI#ZT{DsrX!=3(sV&H;0e9=Kj-Krw4zXwcY~$ z`vQ*hfKE65-|uf3Az1m0Ls%3YJoBD=Tv@Qa13X_F{JO)M+5w&&EPoq(Q=oz8kFiZ9 zsd=5?Ssz#Uu5Tp`Jo`Py6${pp!1LjgU-|-ETEMeR+T;rL$qw-BStr(P_N5g(Ck;rN zXq+a3XU)g}agtRVc#i5C8d$Za6+Extx^GS7X$8;z`(r&+>{`I{5YeI6*R>fu>x_1N zJ7L)Xp65EVOg4r$gJx&(Ogv8?2&@6me}8@a?z;OUc(%xj zxm)E?44$hxF0~vukPn_ceBw8YA58_%S4fE)hW!%3GZ)wL6ce%c;90%>$nFa10`TlR zEVFjU%Oda`5n-v|hrWZ=Vb3P}ndhSUCcy?Zk7YS}@=4&? zX})odtrrPAYns!G+*h=MXTz!}rWij3JZoNl7vbtp0neV&CtcJio#0s`$VV!YiwK@& z4g~heo*;tfU3|NqdBnGY=kCBO6Go5Pz_Y>B98a`V2YA-B(`o&aOa#yO#X7_`P9e`< zxz-A{ZEFP2Gk-;FH3}QSGvD}osUK`a@N8Q=u{&i=J$Tl5+SM3qTn(Nd9ZTk@Zm$8) zPR(5HgE^Jp`H?~RZ|&S#@EjjSdjI%!CGz}WI_aHb8hE}C@9FG8F9px9=MTK%41Wop zwe<6I*5!xbm-3l6Ahnm4L;%l9t*Z92mqPGM`8<`$n=DjX2A+@1G08 zYx3;%Cu70$)W@EySJxGS=Wx18lu=Lxc%IR$(*YkvrZSV}a3=W+J?*_;i{;5l>ML3y=(Oz=F^!RbRe*9D$&*>b)1N?qXD zv@kyxT1_xs=b@l~h&*#1Ma$@jqX&0AGj z>NZi}nP00tRB=87JpUr*)1vjVz_WL323eQA0rHvIfzzsJO9aof9tG<0SM}ieJT1AZ z*1r}!t2$mieX_q5JWuymAJU0#1)_Gu$|FOylvpwd@HYYdNK(-=WY&) zrB0&0u`I9u&UT9y@Jw`>xjjup`8?oB{JeUO1fEA-#4UwoJHhj4I{w3Vr%v$9P7mC7 zQ5og4;bBaTv>f#fw;Qf=HJ?y_cK_pOW*ycEo;44=KG&(#4f&i#*_@wz1$kEX;tCIn zK>fLKT)5NaDGfY}gh%YPq|w2%nxDY5Svnm&2WXW`SC^sw>}XQa(ojeN&$3~s+1~ll z!E>Vbq;~FKDtO*tP@=JN6B#^{vN=X4<|*KL-Y@#ez1{8Ld1g7@fo#|co?BGaTo3ZK zfM=_djhkk1M{g)6&$bb;r%&dLT!B=Q_XBaidQ(jcGN1Zv!DR&+x?e@()) z!-`NotGtwDoKQ!eaS!XwW`B1>-+1MFWz0mO2l83#6zBf9v0m`Jqk(auGZ}fdy|Z`M zoqig4*3&-x`?ppPo`>p}D|qYD!Sg23uXVyh4DhU}7hP!Xgq{bRVzutt?L(e3a{^n9 zUQ)pGFemoN_SI+bJSX-hS;DOrJPWfc+g0>sfoEJ~z}Pk^A;D8M{>nP@Jw{?Ykec$1)jYdH_@j< z(DPuWlhXmUK;${uUC>Ma)?;=SD&%W6rJ}%zK^G_RZ2fZ{Z z^o`umn&rWtkY`^D&j5uGl+PsrgmS`AH{|nS&7^au@)?lN!prJSHpZj*#-o@I^(i(e zpN&j!{q`qN!L#ac;t~H$G~eLvuumU}K=Tdt*-|&+%`Qt;e&G=d#meRkqzN;Q99WJ*x{5&EWY)e2DjptOoEbE5;@wsEXzr z&X&K{t{Vyf&*l?mcX_s>{``GYTbM&q9(XpkIAL|?Qx$ktkklbW$RN*m!y}b%HMBuK zf8HW^{AP9wc;4UjO4UW33Z8A2vAJ36bU{A9Xj}Gk>KhgE`999`=)Extcy`M;=Q~=r z`TURI6K8@tAfG+$N1~<^d%*L$o$kX= zv9O#}@rXhP&--?WCOu6@^SW;{ShMzn9>`}k{Dqr> zVhr&7MKJ93u|g(zPIa(4`H)P9d=^caRHrGUd`=tCmAOyt0?&UnEf?%|cR}BnuxT*n zS%>;Y*mY%clP2;!R4>ZidlBXHrrU}A7kp`u&ldLKqJWbR$T%-N} zaNa`stal}L>R>L)XNJy3sgt^$;MwN!%UyayRLEyFkKq+FN4p@O2@JihB^xP_&#o%C zlWJV3Z&+(I5qEacz%$n`-aRxaCV0jfknXjXF~D<5(`%hAAA2C5uOCdlW9HTkePgop zv{X754LsjHcIK7H;yji$?$h8TT;3{ejq^nLT%`8kM-3j$pTCy+<;r_?f#>Vr1LCEA zq4|cg_rukJXBf~oHf$lMaK)njY@nJdEjP#n&wGjR?-#tb&;y?D4)=XqR=@<$5gzMJ z>#rcs+AH05#a2+k^M^x(u*9vWV@hpS{o^83$ z#2TJ$0ne6lWBh3|+0Zve@|0(D-wtGGw8L|F(DqmG=H8Ac(ClPeF=Crp$BLB z+tq+)osb7g(!ZO*v$&Px-xmgrkk7cnN87h_kRhM>Y{rUH(kLjOD=t;)tYShwzxmUw zQmBXK&w>&51d0F+Joh?Zs;jR?`CP;Qp=y;-CwNY6rhLdy=mpQ-s|wa!{nQ2d+%7a9 zq1}%9hH&3gUNL#(`N8+O*B7sMfoIeCij%(jD4(V0+4v95AbKY{x5!-?lYESX>erJa?9FUEQ;R0{Oh-ws4}QGZ{R8kP`Xm zd#N4rS%#>#L*IB?_`vnq`DXC^o9~d5 z2pgJjgz5?sGM=@A=V>cyacDJ~KYvzIIAwCE5j>l!B)dl$H$XnSik>W#ywL{v>>p?P z%H$*wJdbVE(?9r#4EbEI%or-uWI#Uu*z#j1O$Oz&XHtmcuVO0XvoS6wh)bIaeZz#* zCqCwhJU6{;a|z-?^SX@f8!X%&)4=m@E92dd&8gry-{OjKkTjatP5jl1ar)8>p7$9_ z$X$*=^SXxe>*=)jB=C&?71R;4wFNvos*x4>g^1v}+U(4i>F8SUd=U5MU789BJO`fM zX{xS@Ja-8DIudfK!1MG0bvD(DP2l;MQBw8?`&#fky;}24TN!J5K7nfSZ-{Kwi~E5M8+eZ>Eqj0VpR->P@Y zi)BIIkQ?hD9>10Z`D{I$G@GV@JRcp|E`$G&4W4@pPl!GBE(Oo|ZoN|pFUr94LX4xd z-6{fj{`scA+2>s)c>c}IiTk>j0G@O3<75X?BY6H8&&?CPiwJ$gDb~cFJ-8V>UzYjW zK2kx1e6G#?nfw>E-j^BeZMN-b^RdEGdB*=RhPKO24dq9v+>=Fc8Ro81b&)q`j6dJozB zt~&4>l=D68__{ps-1WjaV_L5qJmcsEGw=HUlh6ATNCcrW@J!BXq7>wz=RvE<>1{O$ zN#MD$sUvc`Y%X{XR-qc?^JaqQZ9AyD-31BYnZ$g4({34h9<0*yj*zy@g1(_TJg)Bb zq7XbkI$*%DS*092|EzW%6REBQ&!#;BhaTwEf#<64JNqJS(EOPrqq}4msRcZHWjlXS z&S?S9TITtYw;eu%=YB6yzUkv6@GPt_e=t|O6+E9;(abR{YXZ;j$~2-s1h;}`={al9 zT|1Zh_zZrHqTRBh<&EI^?|XdJh$|I5?;n*_;6&kNN1<~{1*5clxRxc9ryt?(ib_mMn%6(_9+TmNl^KoOn zH@CL8fM*3CDPiwB4Uo^0INtvJCttv`5hF+<-3-m^^bZL?u8t>wXJdQCV&BIv!E>`* zq|%y!Qt*sj^*(625Cfi9J$V*bXB-CkJUDxNmCgk;uM2f!OLqTK37)Tn)IajDtOU>Y zLNltXM^N9eTl4%$S7t)#t@T{5M)DXLP zUW4`D<8yXGZ_~;>pY|iq1BwF^OdEN6p7UGZi7|@@EUtbNDz%d}7 z4=-GojZj0+gO;NFlG;@?@NCr+u4omE=5>2gxU6}t(Rn1vhxzVDFQex{pDKY}?Thy> zokxn&_X+q;q(Ogf!5#FGA4Z-Z-{=kXxzq{yEMA;QJ;Kojp5OGFnnZbafajO&zn%%6 z?gY=tyz7FK`CGwrs~CB$%`7^PWFN${aVxPJJVzhC%~q^h4W45hOroq`B!g#@<-ZN@ zX?Q??X6rHzx$?6DJb!6=Nv11TKt88+$cpqhG=XPb)0z_}0-M3J90&6Zm9G`@*@}{p zp1A01={%CDczx!aMF)5`x}ix?Xh8Ei=dwq~8aX?_bLWSVtxvOQ;2Brduqk5)ns4B8 zB&2-z zC7Lg{r9`6sT*+t77^v@pe6BxF5ak^EkLT5QyY4TZCtAv9wsb6alN8ElrtLi!ZDTaA zI~n=9Uu$t*uynqTTgKLb{V2-kcbj$NKR=*==iHJX0-r}a!82#5lx3_U+E1|^{Y<(= z?*Px8_j`T91JHiAUqDc7`+xQaedTNGM^>W!L65tmN3PhSzCmwdQwwq=gXikAa{MbJ z(f;82vql3k4QPLG|IXUF$4PbI*&@}HLrw$DH#Ft>ymL!x!Sm*=H@pRTE5I|y&ZCD@ zWeL!q^#{2_i{{F~^9nil5y{cTdGr7J^TymaVVN&ez_TT}MELi;XOPe7cXlcTjz)uL z&wWkZ+e1shvyO##(Q_R%fBq;MwQac>@_cYOK;3w(4m|%TZ6VwAHiGAIcJ4okLM`C= zVfXQSa${&-XC*xRQXr)UJRe)*g%htt=j&zz-iDJeqW!_L4?8B^W81)U!f);%WkIyx zZE*GetCD!sH~RQ0`g^C)es}Rm+|MI?Xg`JD)PRa_Z3E9znDfi@!*u8yY#UsDZ4_XF z=f+wA*Q51lUiWH7F=w6!^$o)(Zy)9t(IKB{kusZWvr&KMj<{Nqu$XU4o~zo&O;l9S zyv|!XZ+Grlv_E)ng42~vjS8M~Wqyf2dx7>-#E)XF;(cWp?0r?!mv@$!$ zAcE)6i)ECdZ;g=8k8K;mS0$moL39sO)ZRe^&w_XRZg^j70?#YkyS#-hGQqQ?OZ=^Q zTr7BYHfg!g821T0pFX5Uz8ZTK^4aiHfB$!mT=49=q1$NG7M-t~dYoPNmVxFQcz!Oc zuoY;3FrN4_`px3=+R}N^_uSQ;yK>R|d6WH#*JBza@N5@sH#sBN4t--dMegd_JhVUf zcd&C?^qY3b=Q7)rG(HhB^k?GW`E@S{D4#teDb2SY(IKDxW~|+f^-$la9gs-BUbgi2 pF@rz#NiHHG80GUjzO0YL73jQZ_@x_F8B{c{BX1nf?A=Jm|36+7D~JF9 literal 0 HcmV?d00001 diff --git a/examples/models/intent_train.npy b/examples/models/intent_train.npy new file mode 100644 index 0000000000000000000000000000000000000000..0fa670eeea92fcde050b867d09cff497a7a88a1f GIT binary patch literal 184448 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 C4&2KC literal 0 HcmV?d00001 diff --git a/examples/models/phi1_margin=0.0.npy b/examples/models/phi1_margin=0.0.npy new file mode 100644 index 0000000000000000000000000000000000000000..bc13e7b762efea2dc105c32cf38d1d3c847603c8 GIT binary patch literal 920 zcmbWr`&ZL-9LMnihjCg$Dj^9v3C`HSjUb3*?fZIXI8ZRqbB4H}1CyJl)|MLuIs^`q z2dzL*JRH;+g5ViyM?C`}_WfA4sMK@392Db38gSexh#i4pg_QjZJ%4*X4rgS&y+!LK z_*h_(78aQcOj2c-R8^cHm4``-jiyqQ&X8v`6&C&HDLTEm=$V^$>OL%b_OiI7b@C{A z*xs=Jov3uGip>kF*<9Z)_S;w)yHruY7&9{0+AOB&Dq&Vf3j6YlJk}yz$NssH&6Igj z?Bc^rR;~?Um5Cc!kLY<;-uosq-0<+L^hs>=%3WTc`zjl|W9Oe7TFYu(hxxyjOPFpz z#~UWa%qL70@O?B|mpVz~lZsmhgJMl*F9)9A?WmNXX^N}M? z%x@ZUL}y%w!0YKifbv@)(qat{f;U(ch! z;DoSOK%cB~A)NQ6yJlZ1bcty8$qE{jEv3ctGP0S1$kU~y*1iz3dp48Vy@o=%x01|9 zLhb$A$bBV>#)5N6_=|#adURCU6Gxc`OK9>tH8s|KKz=P+%Iq|g*RY76>p#e>SUOMOL70W0=9*NsH_gcgz^|(E1Ba4r)_8)@8fK5_2WIKkvsd&54b%S zO*8KfW4$GuMof=jYYw5D$5WX7NkT34m!UPkLPow8OXP`^-{y_g9wn7!JGtjhzfRi= zX1IpMcv?E(4@qboJzNx{b|!|3Pb)w*3Q`OuVc%6b^_)vaja^QDsp%NXR?q|c7W~;A zL(zU3#M)zN|As8+%i~G2O9SyjA`N`D6|vPS+-%s4-6iSB*Q;TXZpRIQ3dN&4aD7QE je(ii8X-C%6e6tDaaZsS646_j&b;&Fct5vl6K?VK=sH=is literal 0 HcmV?d00001 diff --git a/examples/models/phi1_margin=0.05.npy b/examples/models/phi1_margin=0.05.npy new file mode 100644 index 0000000000000000000000000000000000000000..d63a372c078e2aec50bfcd16315626637ed299fd GIT binary patch literal 920 zcmbV|{ZrEg9Do(a2l+6`Ija%Rpb zn^DOW8Eu7DMlNQQ#VL$T%oLlgcB^6AR<7^gihF(X|TFB4aZ z|2IKXqt%ojxQh&t+bLE4A$2GV=q;0ldbQcq?KV*ys>nQrY#q^tk*k$S6<8AKiUTqw2?cx?jdk51Gt>w zG3c=t+|;YbArF z^+96rEb0>AFC&S#&>e>M6KXuaBMJ@Q=Ab(+8a0@UC0_|q5^KOd zuLuLnjp#fm!SO}!q2|xUxM!gmH)SdCOt=lJnsst=|nh*Nn2S@fsl3*Tg!79=LvvWo`GbLtSpYvLU<^vX3Mo|J_00 zTV&W;=!G8!Vo|zf3{1}%6u7T}>gyzI{cSG@FK41gvJ@`8(x9X3nX-2Jlq|Q9l}J|M z1@B4r^sj)A^!L~^E+zhx_muU;DX`fy3%1qBv9vt|&fk&a4!?OY^t}R&bwU{LX7Ny^ z2-eqRVtuy=TyhoeDqR47eYXZZrSm~L#e-E><^bcE4<#%gI^T~6)vXt7^W!vV?eAwp jf>f}vOpP;@(a?WTjrG|QXdKX>#Sst56>9AHWGVa$H3n`~ literal 0 HcmV?d00001 diff --git a/examples/models/phi2_margin=0.0.npy b/examples/models/phi2_margin=0.0.npy new file mode 100644 index 0000000000000000000000000000000000000000..4b80535a24e75c9a1a003a7c980c0de10113cd79 GIT binary patch literal 920 zcmbWr`&ZL-9LMpw6EFvjxELg!!=U95hbedloBO`rDukH0gNSG8fjBU?Fc#22grhh{ zLee>0jNqU|o*AA_qA4f9q3!$efF0-v=Y$232?Tn;Lj((mixp=7LeJlxj~eZv{RxNH z2=WCd~uHm`oW~Aj9o`1+TRg_|r zLRuvK--#c(6|>L#E$r;ELROHO#YBB(RxqE;Brzt|soTeH4jCBARLoMF%5qI|W-L9- z-dyr!!q$Uq(p$*t!nCX_X_z+IeMh42uq`HWBH|nX$+Z zW?bZyQ^UN@<0)tM>E?g(2*X%=3x8`U6*YqmysfhwJ@!IgcBl!}k2HL~vki4G{_Wrb zyO7d;!ts{pJ!DN*sYI$DP=DOa^;A5>-qIOPdDKXP-7N}BJ-$Od4d-Hw9uC> z#S|A_1}lGa4<{21k=-K@I!qSc*ys#yasHk}L(FOS}u0I$l6;e>yHi3~>4*R&+TUIcrHZ zyu0;Wh3iEWq`yKs_iG5~eTgbtZ(*cSL=mzcpi@9&rv|V-ehwACjw3ts5yIbhqVAg? z;gh(El4n0-C1nlGRj#K&i3?fp`O&qa8(@z&kTdQKEUSUkzz1UY8v#_CAj77bmucIb z9T?SlQ`2Yya?VO<`mr8i0q*24IF5~OBD%1p1b1Rw$mUg!hF&54qOQWzdI3#ze1Z@6 z{Da>=JrC{oD-b#xvAJsz7T$)N{tNK)zKr4T{(xZq3yAw?aX;ewlI$#lz_aTXjx+V}MaxeXz-3n~P~7DM3-^=vSdN(N*H zunXD_BHG2Wb2uZhP-Jkn?}u(M2+eROHg@nrwhT^QIvyg=gzR7F`P=jHVP5|8+X|L0 zF)VpQTB^~%u9GH8cxsZ1m-+pDY6srJ0KS68a}&ofn8z2=eYcdPbk9{m&YO-Zs1 zGSOS2|6Q;;z{natu47uy0XF!RmMt66v(YaL*yuNvtoF@J_J?~HD+-EdzG5{ytysfm zZAHvo9KseZ>|jORxA}9?FR^IJ5FZ|}l@0ZM#JieuSctxYKWkR9@`WgV@q7k*Q54AA z%F|eA!tb_AS5jG8e4p+9_bJTLV6=I~DJ-!|VB38yj;TzRBvK4N}nXTJBrk)a?13sr`d)i zG7ICW>Q^FRL<*^IDoMj{A^ZFbbiXX0VphLGnV}^l%qykYuPbP4QzdEht7+J7pzZT@ zBoi3v;IaL>$Wz#V&|4HdFn*0!#?f=owiK96jlz zKbDMxd0F(VV;%mC$)d%^P()8<(T}~iIRE#u>BzY|+$m!$ngs(~c5F7Le=~B{&nxku zSjL&3Zh|TOqM~iQ9YR|y&3QU;%^OACCJUUFFp~M&QR5QOV}%o_ZuR2Cpa-g}vv^oM zhbo;L+(uu@b$O5*&|A3DF{C=zmgD9dO<|IAW~4CqCn%>m=#3+QTg k;Fpm;=t>;O{lS9vR0pKSetaTx!0zow?OF$}J~x1W0bYHAF8}}l literal 0 HcmV?d00001 diff --git a/examples/models/psi1_margin=0.0.npy b/examples/models/psi1_margin=0.0.npy new file mode 100644 index 0000000000000000000000000000000000000000..cadbbb3672bcf6497d7ce910d110fbe509467675 GIT binary patch literal 920 zcmbWr`&ZL-9LMpIo-swnMdZMa72d@jbM@?Kqn+jHYMANtYs_PJvXM*c8NReI-C!;&n>Df8 z=1ewKS;Ru}=b2Snz+9dv)-<+`nLiYq9ekl{xnwd z^Si?9k`!i1C&6|;i5ZHg2D;`F*i2u}z(;*?%y>ktn_LpZ)MvKxcYKjdwJpG({XoJ} z*3R<>wIcRLWh%x^_l2R`M&zn43cm6Ne7*amkl3^z+g7&-`D3Rb%{B{9G6cw{5`=@p z7a@-89vF6jdXIflJq@gB>dzi-`#2&z2_m5$V*jW zUNY~Kkf)#n$rBQ4z3>HM+7{6uI}CN}V%oL#5cb@QpmRx|;nAm&bi#8075*p+&ud5N z%2=9lwm}}Tj7ENM#$#IoJ=foa(ifIf{v|KMTR9qDS_@}=DqX&5N8kJ^TGIO}E~_-u zTbBpT@@(4jbQNT-C|V(2istYjf`M?z>b`{}(umR<0oaO;AyC86`pp!4;vaG50!OzF z+=bejNG};CF;O2&<$E6>Ll;k<%l&v$nnv9%n{oZ7id3^V`1x@aS#J;VRq70C>$=Ye zJC$VcNzne6f)X_{IQ~ecA7azt-65xSJG7W><49glIHcp~VOBo4og8&D13Y>;SymRJ z{cti>x{A=hS3%p46(W?VB~oO^A2Xaq3Sw9glV+&Mc>#Yqj_n8Mtj# literal 0 HcmV?d00001 diff --git a/examples/models/psi1_margin=0.05.npy b/examples/models/psi1_margin=0.05.npy new file mode 100644 index 0000000000000000000000000000000000000000..55ebc1131270886ea888889d2bc4c3386c483ff4 GIT binary patch literal 920 zcmbWr|5sCW9LI64q6cOIOL3Yor?PLd6}WN0;J#m;BTY~tOr@qC5ZcfsxG|7`tkLny zNe(Blfr83nlpf_A6%A2@-47*b#}i?vR66N61Ee5+2-o4Hgk}Fi&)=R8XZp6Z3?mm% z67Yf2WG;Hwu6$jlOv=+MH8N$M)n07R*_Um#o6P^YAt%4c{KAX&UC@%_gpZnO=4xU28B->;@GozCTzuPOnt;9JWW(HUt^ij zdvYaWbqO=pah_#|!rA;250kD=ikVwd%lpoSu(u0F`N=E6EI%!R zI{P`+)U=*{8krD|?Jpr+?e{{Yt(GGCE(`gEm#Aa!ap7X@ElTJv5K?j;P|ymMuz1H1 zJ#1p0=9phe=)c~T*FQ$jW#B7ECurdD7_U}O(zTfc+E_kCJ?aCL(fKze?D(Ai9N{1- z>?T+D9F*+$k=z@MFV}In9UX!nhQw&Ee;I-2R=~ed0`nI-JgZp>_v2*b&n$!Dug$o> zAqs82?I^dXkn74ufhPujrwM~wc`W|cg2cFVRA{Xj8O_4ZYsF|Uvtq5W9B<4xP%*m# zePR)IHMpqwJrVv{;3DbLd6+9|q;KReVZ8Jdd8+24Yi9#ZYzak3>v6i|5aXAU1S}Pricn9fv9KloVwa2c1={#D%UxGNh`|nVL(Jp|8R?mO=bcJyu(J zy4RbCuofk?-V8^1ZYcSe{6-hrXVc-+eRQYJKvTLt(h7|bjWlHhmg zG`VkuqVlb|NWU3`KYDyLR2_*M%UkID&sq#ijZ|Huho!!oKlE`N?9E1AJQ9P#x`X`o zV;Wep+IY91hTh@jy-p>vS94T4Pl4+AFsfWGhyVQus`@bs#o-FNE0d#Tm6klg3Z&kN zr5iO$$T&SUcc_tkPe*5tYH-33OXBOZ5cH;odbV7lsG%qtzsu8;s zmAqPMvEIDbBz;{XRhF!m$|ceggQ>!#+h1rf73=@|8eO?rzx2(eI-`E6UrO4zK`xU^ z4om(w0!KgtTQybBnlIO|mpukn@`;(}s zMemo1uFv;eL6NpeX-*%6ps_`DBGUu=L;x~$qY$1~VoSv%1f`kr=QSSXrSqg zS{yYDR^x*nOgg0xWrOOA&P{eAf291T~wXA8c97_y=|ztyppE3oIjdn?EC=oCkyb;TQIP1 z4slOfV9uO|x9kga9G!&q%{J6U_#o)E!m%)cHFg{BBt1a+x-+=hHIBU8ub??Nh8IL% gBc^T?$z^t|{lN>B;T(2nd0`iK!7lJ3)zpQ50UvvTZ~y=R literal 0 HcmV?d00001 diff --git a/examples/models/psi2_margin=0.05.npy b/examples/models/psi2_margin=0.05.npy new file mode 100644 index 0000000000000000000000000000000000000000..dc43d1887ac5fead6af45f79cf46a49b042dab20 GIT binary patch literal 920 zcmbV>|5MX-9LGOQrhE}1O58{aSZtxV06hZX^L#N8@PSmUS~82D(?m*gmnga*=~BvOc+Y^FZB5B@pv3rS6aBfB7m#s z8WcLcd5cN0DprwYSgA;gRTzw>T9f8=wb7*0|JPNTYO{W>o409d^mG1PN=AB8Vp42l z?EfZ2E4DGO&&m@1+{N;kk+qDNna84L&;GQ7MZ^@b0{>RFzZI zm#|AG%Gpf{W#;}3%zxP@L>H}N9e)i8xAO~F^rMqPzMx{)?KWYwKbMu9$rYNVIV@SW zNGQ$$<9FV2<}FBPab3rq%Q+>}Ue0oU>VAf`S3c$t?TTa($pQS>q?ox9kMgEv_k`?` zfB4jp8-k}wi9ubzkiqGYz3;p*lXwu$lWoGQWv3tsvI-S1UcuX3wvaq<4fD$$I+cUt za4Kt^4Z;M<9PydmCAT3;v+d%l8TuZYibe#g+6?$Yy$St&TL^+v$GO4w9GF(fzCSWSFv2Q=pCh zI988On&Rm9v06Y9Pm4Fb0ZWdIK8UJDu_%G!rgi90E9ltYl^A|)DGmD8g9}p96T`VE z*QL_3hLxCk^9Axc;}NRo$!!crPC_1;d%gU`q?A&NuJgvJTd=fE@~70Dhz#6~hlWnH z_+6OEu%mS%j0_zDEnaZW+hUX+Ktf_#H9>=2Pq0J{3~g-_ktIYN^eG?OiV5NtQg%pkG2Ii zBR^S0U)uI#^r-;S<{d!xYL4P7T5(4`iz|JHapLqN{N_G~zPoNrlwUx&!;Ne2UqtL- eH#Q!+gda?9q^#}17n|n()gJI0+^Ct?i+=%#7kfki literal 0 HcmV?d00001 diff --git a/examples/models/stlvae.model b/examples/models/stlvae.model new file mode 100644 index 0000000000000000000000000000000000000000..0bc0e77ec013c08bc00ed62c19edebc3359c79c1 GIT binary patch literal 13959 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 hFVOXVxFs~ou|DX- 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