diff --git a/docs/anp-rnn-mcdropout.png b/docs/anp-rnn-mcdropout.png new file mode 100644 index 0000000..46875d9 Binary files /dev/null and b/docs/anp-rnn-mcdropout.png differ diff --git a/docs/anp-rnn-nodropout.png b/docs/anp-rnn-nodropout.png new file mode 100644 index 0000000..5b396c6 Binary files /dev/null and b/docs/anp-rnn-nodropout.png differ diff --git a/readme.md b/readme.md index 72c8dce..15814df 100644 --- a/readme.md +++ b/readme.md @@ -14,6 +14,7 @@ This repo implements ["Recurrent Attentive Neural Process for Sequential Data"]( - [Example ANP-RNN outputs](#example-anp-rnn-outputs) - [Example LSTM baseline](#example-lstm-baseline) - [Replicating DeepMind's tensorflow ANP behaviour](#replicating-deepminds-tensorflow-anp-behaviour) + - [Using Monte Carlo Dropout](#using-monte-carlo-dropout) - [Usage](#usage) - [Smartmeter Data](#smartmeter-data) - [Code](#code) @@ -103,7 +104,26 @@ And a ANP-RNN It's just a qualitative comparison but we see the same kind of overfitting with uncertainty being tight where lots of data points exist, and wide where they do not. However this repo seems to miss points occasionally. +## Using Monte Carlo Dropout +One more experiment is included: + +The model tries to estimate the how unsure it is, but what about when it is out of sample? What about what it doesn't know that it doesn't know? + +We can estimate additional uncertainty by using Monte Carlo Dropout to see how uncertain the model acts in the presence of dropout. This doesn't capture all uncertainty, but I found that is does improve (decrease) the validation loss. The loss is calculated by the negative overlap of the output distribution and the target value so this improvement in the loss shows that MCDropout improved the estimation of the uncertainty. + +|Name|val_loss (n=100)| +|--|--| +|MCDropout| -1.40| +|Inference| -0.64| + +With MCDropout: +![](docs/anp-rnn-mcdropout.png) + +Without +![](docs/anp-rnn-nodropout.png) + +For more details see the notebook [./smartmeters-ANP-RNN-mcdropout.ipynb](./smartmeters-ANP-RNN-mcdropout.ipynb) ## Usage diff --git a/smartmeters-ANP-RNN-mcdropout.ipynb b/smartmeters-ANP-RNN-mcdropout.ipynb new file mode 100644 index 0000000..8cb958e --- /dev/null +++ b/smartmeters-ANP-RNN-mcdropout.ipynb @@ -0,0 +1,1152 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# This notebook tests ANP-RNN + MC Dropout \n", + "\n", + "Ideally a NP should learn uncertainty, but it may also be overconfident. In neural network monte carlo dropout often provides a more robust uncertainty. Here I compare it and find that the uncertainty from MCLoss improved the validation loss when added to the models estimation of uncertainty." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:03.606115Z", + "start_time": "2020-02-16T06:52:01.153439Z" + } + }, + "outputs": [], + "source": [ + "import sys, re, os, itertools, functools, collections\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import collections\n", + "from pathlib import Path\n", + "from tqdm.auto import tqdm\n", + "\n", + "import optuna\n", + "import pytorch_lightning as pl\n", + "from optuna.integration import PyTorchLightningPruningCallback\n", + "\n", + "\n", + "import math\n", + "%matplotlib inline\n", + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:03.654891Z", + "start_time": "2020-02-16T06:52:03.609144Z" + } + }, + "outputs": [], + "source": [ + "import logging\n", + "logging.basicConfig(stream=sys.stdout, level=logging.INFO)\n", + "logger = logging.getLogger(\"RANP.ipynb\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:03.704343Z", + "start_time": "2020-02-16T06:52:03.657808Z" + } + }, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "import torch.nn.functional as F" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:03.821105Z", + "start_time": "2020-02-16T06:52:03.707186Z" + } + }, + "outputs": [], + "source": [ + "from src.models.model import LatentModel\n", + "from src.data.smart_meter import collate_fns, SmartMeterDataSet, get_smartmeter_df\n", + "from src.plot import plot_from_loader\n", + "from src.models.lightning_anp import LatentModelPL\n", + "from src.dict_logger import DictLogger" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:03.884144Z", + "start_time": "2020-02-16T06:52:03.826825Z" + } + }, + "outputs": [], + "source": [ + "# Params\n", + "device='cuda'\n", + "use_logy=False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load kaggle smart meter data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:12.710878Z", + "start_time": "2020-02-16T06:52:03.886598Z" + } + }, + "outputs": [], + "source": [ + "df_train, df_test = get_smartmeter_df()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:13.433355Z", + "start_time": "2020-02-16T06:52:12.713575Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Show split\n", + "df_train['energy(kWh/hh)'].plot(label='train')\n", + "df_test['energy(kWh/hh)'].plot(label='test')\n", + "plt.title('energy(kWh/hh)')\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train helpers" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-01-27T23:41:43.464247Z", + "start_time": "2020-01-27T23:41:43.410516Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T06:52:19.284380Z", + "start_time": "2020-02-16T06:52:19.220689Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "now run `tensorboard --logdir /media/wassname/Storage5/projects2/3ST/attentive-neural-processes/optuna_result/anp-rnn-mcdropout\n" + ] + } + ], + "source": [ + "PERCENT_TEST_EXAMPLES = 0.5\n", + "# EPOCHS = 5\n", + "DIR = Path(os.getcwd())\n", + "MODEL_DIR = DIR/ 'optuna_result'/ 'anp-rnn-mcdropout'\n", + "name = 'anp-rnn-mcdropout' # study name\n", + "MODEL_DIR.mkdir(parents=True, exist_ok=True)\n", + "print(f\"now run `tensorboard --logdir {MODEL_DIR}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T07:16:27.209738Z", + "start_time": "2020-02-16T07:16:27.136390Z" + } + }, + "outputs": [], + "source": [ + "def main(trial, train=True): \n", + " checkpoint_callback = pl.callbacks.ModelCheckpoint(\n", + " os.path.join(MODEL_DIR, name, 'version_{}'.format(trial.number), \"chk\"), monitor='val_loss', mode=\"min\")\n", + "\n", + " # The default logger in PyTorch Lightning writes to event files to be consumed by\n", + " # TensorBoard. We create a simple logger instead that holds the log in memory so that the\n", + " # final accuracy can be obtained after optimization. When using the default logger, the\n", + " # final accuracy could be stored in an attribute of the `Trainer` instead.\n", + " logger = DictLogger(MODEL_DIR, name=\"anp-rnn\", version=trial.number)\n", + "\n", + " trainer = pl.Trainer(\n", + " logger=logger,\n", + " val_percent_check=PERCENT_TEST_EXAMPLES,\n", + " gradient_clip_val=trial.params[\"grad_clip\"],\n", + " checkpoint_callback=checkpoint_callback,\n", + " max_epochs=trial.params['max_nb_epochs'],\n", + " gpus=-1 if torch.cuda.is_available() else None,\n", + " early_stop_callback=PyTorchLightningPruningCallback(trial, monitor='val_loss')\n", + " )\n", + " model = LatentModelPL(trial.params)\n", + " if train:\n", + " trainer.fit(model)\n", + " \n", + " return model, trainer\n", + "\n", + "\n", + "def add_sugg(trial):\n", + " \n", + " trial.suggest_loguniform(\"learning_rate\", 1e-5, 1e-2)\n", + "\n", + " trial.suggest_categorical(\"hidden_dim\", [8*2**i for i in range(6)])\n", + " trial.suggest_categorical(\"latent_dim\", [8*2**i for i in range(6)])\n", + " \n", + " trial.suggest_int(\"attention_layers\", 1, 4)\n", + " trial.suggest_categorical(\"n_latent_encoder_layers\", [1, 2, 4, 8])\n", + " trial.suggest_categorical(\"n_det_encoder_layers\", [1, 2, 4, 8])\n", + " trial.suggest_categorical(\"n_decoder_layers\", [1, 2, 4, 8])\n", + "\n", + " trial.suggest_categorical(\"dropout\", [0, 0.2, 0.5])\n", + " trial.suggest_categorical(\"attention_dropout\", [0, 0.2, 0.5])\n", + "\n", + " trial.suggest_categorical(\n", + " \"latent_enc_self_attn_type\", ['uniform', 'multihead', 'ptmultihead']\n", + " )\n", + " trial.suggest_categorical(\"det_enc_self_attn_type\", ['uniform', 'multihead', 'ptmultihead'])\n", + " trial.suggest_categorical(\"det_enc_cross_attn_type\", ['uniform', 'multihead', 'ptmultihead'])\n", + "\n", + " trial.suggest_categorical(\"batchnorm\", [False, True])\n", + " trial.suggest_categorical(\"use_self_attn\", [False, True])\n", + " trial.suggest_categorical(\"use_lvar\", [False, True])\n", + " trial.suggest_categorical(\"use_deterministic_path\", [False, True])\n", + " trial.suggest_categorical(\"use_rnn\", [True, False])\n", + "\n", + " # training specific (for this model)\n", + " trial.suggest_uniform(\"min_std\", 0.005, 0.005)\n", + " trial.suggest_int(\"grad_clip\", 40, 40)\n", + " trial.suggest_int(\"num_context\", 24 * 4, 24 * 4)\n", + " trial.suggest_int(\"num_extra_target\", 24*4, 24*4)\n", + " trial.suggest_int(\"max_nb_epochs\", 10, 10)\n", + " trial.suggest_int(\"num_workers\", 3, 3)\n", + " trial.suggest_int(\"batch_size\", 16, 16)\n", + " trial.suggest_int(\"num_heads\", 8, 8)\n", + "\n", + " trial.suggest_int(\"x_dim\", 17, 17)\n", + " trial.suggest_int(\"y_dim\", 1, 1)\n", + " trial.suggest_int(\"vis_i\", 670, 670)\n", + " \n", + " trial.suggest_categorical(\"context_in_target\", [True, True])\n", + " \n", + " return trial\n", + "\n", + "def objective(trial):\n", + " # see https://github.com/optuna/optuna/blob/cf6f02d/examples/pytorch_lightning_simple.py\n", + " \n", + " trial = add_sugg(trial)\n", + " \n", + " print('trial', trial.number, 'params', trial.params)\n", + " \n", + " \n", + " # PyTorch Lightning will try to restore model parameters from previous trials if checkpoint\n", + " # filenames match. Therefore, the filenames for each trial must be made unique.\n", + " model, trainer = main(trial)\n", + " \n", + " # also report to tensorboard & print\n", + " print('logger.metrics', model.logger.metrics[-1:])\n", + " model.logger.experiment.add_hparams(trial.params, model.logger.metrics[-1])\n", + " \n", + " return model.logger.metrics[-1]['val_loss']\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Default params" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T07:16:27.430570Z", + "start_time": "2020-02-16T07:16:27.377936Z" + } + }, + "outputs": [], + "source": [ + "default_params = {\n", + " 'attention_dropout': 0,\n", + " 'attention_layers': 2,\n", + " 'batch_size': 16,\n", + " 'batchnorm': False,\n", + " 'det_enc_cross_attn_type': 'multihead',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'dropout': 0,\n", + " 'grad_clip': 40,\n", + " 'hidden_dim': 128,\n", + " 'latent_dim': 128,\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'learning_rate': 0.002,\n", + " 'max_nb_epochs': 10,\n", + " 'min_std': 0.005,\n", + " 'n_decoder_layers': 4,\n", + " 'n_det_encoder_layers': 4,\n", + " 'n_latent_encoder_layers': 2,\n", + " 'num_context': 24*4,\n", + " 'num_extra_target': 24*4,\n", + " 'num_heads': 8,\n", + " 'num_workers': 3,\n", + " 'use_deterministic_path': True,\n", + " 'use_lvar': True,\n", + " 'use_self_attn': True,\n", + " 'vis_i': '670',\n", + " 'x_dim': 17,\n", + " 'y_dim': 1,\n", + " 'use_rnn': False,\n", + " 'context_in_target': True\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T07:16:14.744691Z", + "start_time": "2020-02-16T07:16:14.694113Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-15T07:05:44.545917Z", + "start_time": "2020-02-15T07:05:44.487280Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train ANP-RNN" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-15T07:40:36.819548Z", + "start_time": "2020-02-15T07:40:07.785566Z" + } + }, + "source": [ + "# ANP-RNN 2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T07:27:29.632597Z", + "start_time": "2020-02-16T07:16:32.547803Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:root:gpu available: True, used: True\n", + "INFO:root:VISIBLE GPUS: 0\n", + "INFO:root:\n", + " Name Type Params\n", + "0 model LatentModel 3 M\n", + "1 model._lstm LSTM 807 K\n", + "2 model._latent_encoder LatentEncoder 394 K\n", + "3 model._latent_encoder._input_layer Linear 66 K\n", + "4 model._latent_encoder._encoder ModuleList 131 K\n", + ".. ... ... ...\n", + "70 model._decoder._decoder.3.linear Linear 262 K\n", + "71 model._decoder._decoder.3.act ReLU 0 \n", + "72 model._decoder._decoder.3.dropout Dropout2d 0 \n", + "73 model._decoder._mean Linear 513 \n", + "74 model._decoder._std Linear 513 \n", + "\n", + "[75 rows x 3 columns]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validation sanity check', layout=Layout(flex='2'), max=5.…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 0, {'val_loss': '1.5792388916015625', 'val/kl': '0.500720202922821', 'val/mse': '0.27271074056625366', 'val/std': '1.0320733785629272'}\n", + "\r" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "608b592f59e6418f8cca7486a1557fc2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(flex='2'), max=1.0), HTML(value='')), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=234.0, style=Pr…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd3hUxfrHP7MpJCEJJaFDEiAUAZEOYrAjiF5FBQGDggXs/cdVwSuoFxVQURRFUFEUBRsI2MWr0lS60iFAQoBAes9my/z+mN1kN9ndbM0usN/nOc/uzpkzZ3bOnHnn7UJKSRBBBBFEEOcuNP7uQBBBBBFEEP5FkBAEEUQQQZzjCBKCIIIIIohzHEFCEEQQQQRxjiNICIIIIoggznEECUEQQQQRxDmOICE4CyGEkEKIZH/3I4gggjgzECQEQdQbhBBXCCH2CSHKhBD/E0Ik1lH/YSHEESFEqRBirxCis8W5B03nioQQW4QQKQ7aeVkIcVAIUWy6/201zvcSQmw19WurEKKXxbnLTH0tFEIctdH2/4QQ2aZ+7BRCXF/Hf3peCPGPEEIvhJhR49w1Qoj1QogCIUSWEOJdIUSMg7acqi+EaGrq4/o6+naLECLdNN4rhRBNa5wfa3oOpUKINCHEEDvtdDM9k3zT8bMQopvFeSGEmCWEyDUds4QQwkG/HD0fl9oKwg6klMHjLDsACST7ux81+hQPFAKjgQhgDvCHg/p3AX8D3QABdASams4NBEqBvqZz9wLZQIidtp4FuqI2PgOBfGCw6Vw4kA48CjQAHjL9DjedHwDcCkwGjtpouycQatGvYqCVg/81Abga+BqYUePcLcBwIApoAnwHLHDQllP1gUXA78B6B211N/X9YiAa+ARYZnF+qGlcBpnGsQ3Qxk5bjYEk07MJMY3p3xbn7wb2A21N7ewB7rHTVl3Px+m2goeD99PfHQgePnioFoQAaAQsMS2U6cDTgMZ0Lhn4zbRA5wDLTeUCmAucBoqAf4AeHvZpMrDR4ndDoBzoaqOuBjgGXGGnrTHAXzXako4W4BrXrwIeN32/CjgOCIvzGcDwGtdcaYsQ1KgzAKgABjjRh49rEgIbdW4E/nFhjGvVBwYDm4Db6yAELwCfWPzuCFQCMabfG4E73XjuocD9QJlF2UZgssXvO7GzKajr+bjSVvCwfwRFQ2c/3kARgw7AJcBtqEUB4HngR9Rusq2pLqiX72Kgs+nam4FcACHEkyZRhM3DQT+6AzvNP6SUpUCaqbwm2pqOHkKIYyYR0LNCCPN8/Q4IEUIMFEKEAHcAO4CsugZDCBEJ9Ad2W/Trb2laRUz4206/7LW5RghRAfwJ/ApscfbaOnCxRT9drm8amzeBB1CE0hFqPp80FCHobGqnH9BMCHFICJEphHjTNJbmexXUFM+Z5kMFal69YO9epu/dLa77Wwhxi0VdR8/HYVtBOIdQf3cgCN/B9AKPBXpJKYuBYiHEKyhRx3uADkgEWkspMwGzDFkHxKDEKX9JKfea25RSvgS85EZ3olFciSUKTfepibamz6uA81Gihh+BTJSYoxj40tRfARQAV9dYLOxhAWqx+MGiX4VO9ssmpJTXCiHCUFzDeVJKo7PX2oMQYihKjDTQg/oPAX9KKbcKIc6vowlH49ACCANGAUNQ8+NrFHc5DUBK2bhmg1LKxkKIhqZ+pTu4VyEQLYQQUqGnk/2qsy2H/ziIKgQ5grMb8agX2PIlTEfJUgH+jVpI/xJC7BZC3AEgpfwFtZOcD5wWQiwUQsQ6e1MhRIIQosR8mIpLgJptxKIW9ZooN33OllIWSCmPAu8AI0zld6K4mu4oGfJ4YI0QonUd/ZoD9AButlgkXOmXXUgpdVLK74CrhBDXme6322IcbCpW7fRzEEpGP0pKecBUNsSird1O1G+NIgTTnLyto3EwP483pJQnpZQ5wKtUPw+7MHF+C4AlQojmdu4VC5TYWbjrej6utBWEHQQJwdmNHKp3/WYkoGSuSCmzpJSTpJStUUq3t4TJ7FRKOU9K2RelrO0MTAEQQky1XORrHqZrM6SU0ebDdN/dwAXmTph2ih2xLfrYjxJLWL7Mlt97AWuklAeklEYp5ffASZQ83CaEEM+ilLRXSSmLLE7tBnrWsDTpaadfziAU9b+QUna3GId1zlwshOiN0mHcIaVcay6XUq6zaKt7XfVR+opWwB4hRBbwOjDAZF0UYuPWNZ9PB5Ry9oCUMh/Fjdl7HnVBg1JomzcgVvcyfbc33nU9H1faCsIe/K2kCB7eP7BWFn8MrECx0onAPuAu07nRQFvT9+6onV8HlAx9IIqbaAh8DzzrYZ+aodj2m1BWQ7NwbDW0BFhj6ndbU7/vNJ2bABww9VWgLFrKsKF4NtV/CjgItLRxzmyV8jBq4XsAa6sUjam/V5vKIyzOdTWVR5rGajyKgPVx8L/CTG18AvzX9D3EdK4HcAoY4+SY2q1v+i8tLY6HUTqMWmNg8fyLUKKfhqZ5Y2k19BywGWiO0imtA56309ZQoDfKYigWmAecACJM5+8B9qIIQ2vUwl2X1ZC95+N0W8HDwVzydweChw8eqjUhaGJ6qbNRljjPUG01NBvFHZSgFLeTTeVXoBRyJSiuYikQ7YV+XYla0MtRStUki3MLsDB9NC0gy1AiAHO/hemcMC1MGabze4Fb6xgPren/mI+pFud7A1tN/doG9LY4d6npesvjV9O580yLazFKT7EZuKGOMfjARnsTTecWA8Ya/dztoC2n6wMTcWA1ZKpzi2lMS1E6gKYW58KAt0z/Mwu1uEdYnC8Bhpi+jzY95xLTvPsG6GlRV5jmXp7pmI21VdBuINXJ5+OwreDh3GF+sYIIIogggjhHEdQRBBFEEEGc4wgSgiCCCCKIcxxBQhBEEEEEcY4jSAiCCCKIIM5xBAlBEEEEEcQ5jjMuxER8fLxMSkrydzeqYDCow9sID/d+m2cadDrwtlHbuTSuUqox9CXCwuBsDPpsNKr3ur6NKn05nlu3bs2RUjazde6MIwRJSUls2eKtmF6eIzsbSku9326rVtCggffbPRMgJeTnQ1FR3XVdgUYDCQnebTNQISXk5UGxS4EyXEebNmrxOttw7JhvNnh1wZfjKYRIt3fujCMEgQat1jftlpaem4RASjhxwjc72XPFZcZMROvj/56NY6rT+YcIgP/GM6gj8ABGI+j1vmm7rMw37QY6Skt9L844m5GXB4WFZ+cCXV+oqPB3D+ofQULgAXzFDYAiML5sP1BRUlJ3nSBso6DA++K0unA2Ehx/vndBjuAMRGWlb9s/17gCvd63u7GzcdEyo7RUEYL6xtk4pkGOIAiX4Oudw7kmIglyA+4jN9ffPTg7YDD4TtzrDM5KjkAIMVwIsd+U3u5JG+cThRBrTanpfhVCtLXVTqDBaFQ7sHNRdOMrVFb63sIFzs4drF6v5qQ/cLaNp6+4Aa22gn37/vFN416AzwiBKfnFfFS89m7AOCFEtxrVXgaWSJWa7jngRV/1x5s4dUqZjfrasuBse8nsQauFrCz/WWqc6fC1iPJcQXGxUrb7ApMnj+Tqq3uybdsm39zAQ/iSIxgAHJJSHpZSVqJiy19fo0434BfT9//ZOB9wqE8l7rlCCAoK/LejPRvgT0JwtszRkhIlXvPVZiQj4zAAe/fudFjPX+PpSz+CNqiEImZkUjsR907gRlQavRuAGCFEnJQyYCWe55oC19cwGKC8vO563oKUZ58nbFBE6Tl84RRqif/974Bvb+Ah/K0s/j/gEiHEduASVLasWjRZCDFZCLFFCLElOzu7vvtohfokBGfLbssRfP0CngsIcgSewWAIHEuhs1FZfBxoZ/G7ramsClLKE1LKG6WUvYFpprJaRnBSyoVSyn5Syn7NmtkMlVEvCKQJc7agvgnB2bBwWcJXsa7OJZSV+W5eZGefYs6cqezfvwuAQM0I6UtCsBnoJIRoL4QIB8YCqywrCCHihRDmPjwFvO/D/niMwsL6vV+Azhmv4Vx1mvMm/K0oDuQ5+uqrr3L99dfzxx9/OKzny83I2rWreeutF5k6dTKXXprMkCHtHdY/6zgCKaUeeAD4AZVc/DMp5W4hxHNCiOtM1S4F9gshDgAtgJm+6o8nkFJZCgW9Nr2LoO275wgSUvvYvHkzq1atIi0tzW4drda3XH6HDl2YOPEhbr/9YTIzj3LiRAbaAHxoZ1zy+n79+sn6jj5aWqrMResbYWEqGuHZiKIi35nqOULbthB6loRa1OuV2a0/HaDi4iAmxn/3t4fy8nJ27NhBVlYW/fv3p23b2i5KRqMKcFhf43fkyEFatGhNVFRDu3Xi4yE62jf3F0JslVL2s3XO38riMwL1adViiTOMRjsNnU5FyAzCdRgMamNSXu5/IhCoSE9Pp3nz5nz00UeMHDnSJhEAtRExj19a2n4OHtzj0361b9/JIRHwJ4KEwAkEFcTeRV6e/4jcmU5ci4sVd3rqVGAQgUAcz++//56SkhIKCwsRDmyFze91fn4ut9xyGePGXcaRIwcB5QnsDWzZsoGsrONOK4nPOh3B2YLKSv+9cIH4krmKmk465t1sEK5DyvoJw3Gm4+677yYtLY277rqLxYsX8+2339aqYxlCPj8/lx49+pKQ0IG8vGxGjbqIqVPv9rgfRUUFjB6dwuWXdwZg3bqfeOSR8XzxxQcet+1tnCXSUt/Bn4vWmU4IKiqqF664OPXi+UMvcLagvDzwTEUDdY526NCB3bt3c8cddzBixAhGjBhhdd4yoGOHDp15773VGAwGTpzIYPv2Pzh69BDl5WVERka53YeiokJ69RpIgwYRCCE4duwIX3+9lPDwcEaNmmjzmrPRs/isQFAs5D7MVkElJRAbWz/xmepCoC5cziDIDdQNrVZLA1Nqv44dO3LbbbfRp0+fWvVsRfYNCQmhXbv2LFq0ioEDL/GICAC0bZvIihXVpquDB1/OnDmLOe+8Czxq1xcIEgI7kFLFwAlyBO6hvLz6ZZMSTp4MxhPyFAFodRhQc1RKSY8ePWjfvj1Lly6lW7dufPjhhzbrmufmmjWfcd55F9CxY5eqc5dffo1P+peUlExSUrJP2vYUQUJgB7m5wfj4nqDm2AUKEQikhcsVSBk4Yxio2LlzJ4cOHaKsrIy4uDiHdSsrFeF48sk7KS0tYcOGDFq3bufwGldhNBrRaFxTwwaVxQEGf3tswpm7aBmNweB83oa/RWr2EEhztEePHpw4cYJNmzZVLcAFBQUcPny4ltWOTgcVFeUMGXIVF154mRURWLfuJx5/fAJffrnEo/5MmnQ9gwa14Y8/fqsqW7t2DUuXLqCkJLDkfEGOwA4CJTvYmRgt05exW85VBCohCCSEhobSqlUrq7J27dpVmZLGxsYCam7q9RAZGcXbb39Zq52MjDS++moJDRpEcNNNt7ndn+PHj3Lq1AliYxtXlb344hTS0vbRv/8QOnfuXuuaoLI4gKDXBxcyTxDIEUXP1OcaqIQg0MczMTGR0tJSSkpKqghBXdz+oEGXMWfOYjp1qr1Qu4I1a7aTlZVJ8+atq8qGDbuRvLxsjxXR3kaQENhAIDjqmHGmcQRGY9DSyhcINEJgMEBISGARgi+++IKffvqJUaNGMXToUAB27dpVq56Z2y8tLSE8vAFhYWFW5zt27GKlPHYXoaGhtG2bZFU2ZYrjcGpBHUEAwVtiocJCa6VpIL00vkJ5eWD/z0DumyN4kxBs2vQ/brhhEIcPO58spbS0euyKipQVWKBh3bp1LFy4kN27d9utYzRWm+G++up/6No1go8+equeehi4CBICG/AWIcjJgaNH1ffSUvj7b9fbPtMWrqDXsG/gTUIwefL17NjxJ3PnPuP0NcePVy/+GRnVPiKBND/HjRvHW2+9xeWXX27zvNGoQnOYzXBLSoqQUtKkibWFkVar5ccfV7J69bI671lRYS1BMD+nXbu2ce+9N/Puu69a1dfr9WRnnyIvL8dme0GOIIDgDiFYuXIpKSlJdOigISUliRUrllaZoB4/Dvv3q0Xy4EHXHnYgvWjOIGgt5Bt4kxAsW/Ybb731BU888ZJT9Y1G5VNz7BhkZqo5XV4eeM960KBB3HvvvfTs2bOqbM6cOZx//vl8/PHHFBZa+2LMmvUe+/ZVMHToSKt2Kiu13H33DTz11KQ675mXBwcOqPf0xAnYuVNt+g4eTOP77z9nw4YNVvU/+GAeAwa05M03/+vZn/Uyzmkdgdkuu6apr6uEYOXKpUydOpnycvVmHD+eztSpk7nzTkhJSeWYRebmoiLFGbRsCS1aeND5AERFReDbup9phNUMbxKC7t170717b6frFxRUP9fMzOry3FzwY8JAp5Cbm8uuXbtITz9mM59IeHh4rbLo6BiuumokjRo1qdMXoKSk+p02c8N79kBU1CAeemgZTZq0oLISzLeJj29B06bxhIaG2WzPX/PznM1HIKWa1AaDdQxwKSE93bW2UlKSOH689kXx8Ym88cZRu9ddcAFERjpuu00blZfgTEBBgToCGc2bQ1RgGWw4hWPHvK8w1uv1VFSUEx2tEgpkZ6v3oOacTEuznY+jQQNISQkcYrBmzRpCQkK49NJLiTT9iYyMDPLz82nYsB2hoU29fs9t2+q2QoqOhoQEFWalLsTEqLhcvkAwH4ENFBdXv1iWKSjdsRg6cSLDZnluru3y6vOu3yuQEQhOeHXhDNv3VMFbnJZOp2PBglmMHz+U3r2bVokocnPVgv/PP2ojlJamjvx8+7kjlHeud/rlDdx1112MGDGCfIsOJyQk0L37BYSFWROBjIzD3HDDIGbMeMjt+2m1zs35khLFJRw6VPd4Bf0I6hFSWi/+Op2Sd0ZFuacfaN06wSZHEBeX4PC6vDyVMauuvp4pCBQnPFsIdJGVIxgM3psH2dlZzJr1ZNXvv/9OY//+ak7OaLS2CHKUmS/Q5uZVV13FqVOnaNrUetHPz6/d14yMw+zY8ScNGkTYbMtgMFBUVEBUVEO7dRwFAdyz5zfy8jLp0iWFZs0SAWU8YjRCp06BZxLuU0IghBgOvA6EAO9KKV+qcT4B+BBobKrzpJSydvBwL6OoqDabnZ+viIE7CrD/+7+ZVjoCgLCwBowZ49hmuKxMyRUdiYcC7WWzB7O3ZiCivFwp8aKizky9jDdFQmFhYdx552MAXHzxo4SHt/UoW1wgzc8lS2qHhEhLy+S1196hceOm3Hnno1XlvXoN5PPP19uV/0+ePJJfflnDwoVfM3TodTbrOCIEP//8Nps2LeeBB5ZWEQKAU6e0PPLIZRiNJXz//d+1rjvrOAIhRAgwHxgKZAKbhRCrpJSW+eCeRiW1f1sI0Q34FkjyVZ9AKTRtybF1Ovd3tCNHpgIwa9Y0srIUZzBgwChSUlJt1l+/finLl08jJyeDFi0SePLJmVVtnKkIZG/srCz1KWXg9tERvEkIoqJacu+9r6DVKjNQTxHo45mRkcebb/6XLl16WBGC6OgY+vW7yO51TZrEERvbmMpK+yFfHQWl7NIlBRC0bNnJqjw0NJxDh7ah02kpKCijcePAUFj5kiMYABySUh4GEEIsA64HLAmBBMwqlEbACR/2B6NRsbq+mLwjR6bSv38q7733FqtXz2LDhk/Yv389Y8bMtCII69cvZdGiyVRWKu7h1Kl0nnxyMno9jBpVmxgE+otmRqCKhfT6avHGmTKWNeFNQpCejpX1jNFo4N137+HYsX+YPn2dXWsWewgUkZtOp0On0xEZGWmVnjIuri2PPDKD1q0di2lrYs6cxTbTXBqNStZfUeFYejBs2AMMG/ZArXIhBM888xuRkY3Yt68B7dsHBpfqS2VxG8DCcJJMU5klZgDjhRCZKG7gQVsNCSEmCyG2CCG2ZDsSWtYBX2d4WrBgOh9//Dg5ORmAJCcnnUWLJrN+/dKqOsuXT6siAmZotWXMnj0t4MIIuAJ/EwKdDvbtUw58lk5tZrksBAlBWRkcOXKMU6fSqKxUcUA0mhB27/6FQ4f+5MSJfS63GShjunHjRho2bGjlTKbTQWxsUx5+eDqjR99eVS6lZMqU2/nss/fR2knyYC/XcXq60u1ZEoE9e35j9uxrWbHCsSjYjOTkgbRp0xUI4cgRpUg2d+NcdSgbB3wgpWwLjAA+EkLU6pOUcqGUsp+Usl8zD2zVfO31+vHHz6HTWQfaqawsY/nyaVW/FZGojZycjCovZEsEyotWF/xNCHJzlcgvK0vZdKelKcJg6cMBZ854WsJbhCArC7766nkeeSSZ3377oKp8woR5TJ/+Oy1bup40JVA2L2VlZTRo0ICYmJiqMnsWPX//vYUvvviAWbOecJjc3oyKCjV2J08qz+Ta9y5g+/ZvOHhwU1VZXt4JKipKnUpaX1SkHE39CV+Kho4Dlpke2prKLHEnMBxASrlJCBEBxAOnfdEhfwVDszQjjY9PICfHtoVRdjY0aQJNvW/u7HPUByGQUi08oTZmrSWjKKVta5czkQh4I7dDcbHacebkQGRkLPHxicTFVb+affq4n5ErUMb06quvpqKiAr2FxYKZEGRnZ7Fz52aSk88jKSmZTp26MXv2+2i1FTYdygD+/PN3Xn55Gr16DWTixJdrbSjMyMj4h+TkgTz22IoqfYCUkoceSsRg0LNkSQVhYQ2srtm2bQ379q2jf/8b6NRpEKD0DadOQVKSZ+PgLnzJEWwGOgkh2gshwoGxwKoadTKAKwCEEOcBEYD7sh8H0Ot9a9ViNCoHMluwNCMdM2Ym4eHWCqLw8KgqC6MjR6z7GSgvWl2oD0KQkaEceI4etQ4VUFbmXOjrM1FZnJ/v2bzV62H3biXXNhph/PiXeeONox4t/pYIFB2BGaEWuwTzHJk//wUmTbqO7777AoCoqIaMHn0748ffa7ediopytmxZz969O216JANkZx/lySd78eqrN9Cnz7W0a6fCVut0FcTENCM6umktIgDw998/snr1bA4d+tOqPCPDfxyWzzgCKaVeCPEA8APKNPR9KeVuIcRzwBYp5SrgcWCREOJRlOJ4ovSRq7OvxUJarVrkLRXBYL3IgznkxG42bPiYvLxM4uISrBTKOp2SQ3bsqOqfCQuXXu+7BcG8q7OMeJmVpY4mTZRXuL0XtSbOhLEENZZarRpXTxPWOzM2RqORtWsXkpm5iwkT5rmUXjGQx9Q8d/r1S+Hgwd20bFmH044FevUawKef/krz5q3JsR0fjpMnDxATE0/z5h0JCaleSsPDI3n7bft2L336XEvjxq3o3HmwVbnB4D8T7HMmxER2tu8SphiNykFt//5q09Dc3Ixai7yqayQ1NQRQCqnp09fRpUttM7bevZULf7Nm0LChb/rtLZSWOnY8chdSWsdw8RQhITBsmHOu/v7E6dPeC+h25IhtuXZN3HdfG/LzT/Dqqwdo1apT3ReY0K8fJAdAPvbZs2fz888/89hjjzF8+HD0euu4SGY899wjNG3ajNTUe2pFHbWFoiKlzLUHnU5LeXkRe/f+xsmTB7j88knExrqvxxw0yHfiIUchJs4Zz2Jf6QeKixXrnZ2dzmOPdSYsLJL337cfcOfUqTRCQsIwGHRIKcnLq6k2UcjJUXGGApVOWybM8VV8oZwc73JyZ4JoqKTEu1E9LT3oCwqyeOKJC2jXrgdPP73Wqt411zyOEIKoqEYutR8o47ljxw5++uknJkyYAFiLDs0oLMzno4/mYzQaGTu27siiUDdHFRbWgLCwZqxePYe0tL8477xLPCIE/hK1nROEoKzMd7I3M5dRXJyNXl+JwaB4u7lzb2L37v9xyy2zufzyu6rqt2rViY8/ruSPP74gPDyCrl0vttlubq4iBIEIg0HtWlu0UP/fF/oBc1BAb7cZyDAYlGmit6DVWm+A8vNPUlR0mqKi2uzbNdc85tY9AkVHMH36dCZMmMD5558P2N5AlJQU89JL73L69Eni45vX2ebixa+zf3821147vZZ/xd9//0i3bpdVlQ8ePI5u3S4lNrY5u3at5ZNPnqBXr6u5+ebna7Wr1ZaRkfE3UhpriYfOOs/iQIIjD0BPYSYErVt3Y8qU1eh0aiuyf/9GSkvzWbRoEitW/LdKT2D2KI6PV2KjqCjbcgpzuItAXLyKitQik5XlGwJbVqb0JHZMvN1GoHME+fneXVhr7mYTE3syf/5xtFrvyUgDhRB06dKFLl1UesnKytrv/AsvTGHRopd56qk53HvvkzZasEZxMbz++n8pLMzh0ksfoHHjllXnSksLePHFYbRo0ZG5cw8ihGDEiEeqzh84sJEjR7bSps15Nts+dSqNZ565kDZtzuPll63lTkFC4CMYDL5NoGEmBBERUfTpcy2g9ASlpdVbu5ycdBYsuB0hBHp9ZVXZokWTAeyGosjNrTsoXX1DymoFpi+ijWq1Si9wrsHW4uUuKiqUWK2mklOjCaFp09Y2r5FScuTINjIy/uaSSyY6ZV+vrvO0t96HLa6qQ4cuxMQ0oqLCOVnjoUMwbNgjSGkkNNTa8qeg4CStWnWmYcMmNsepb99/8fzzfxIZaXuT17hxSzp06EerVp1rnQvmI3ASriqLCwvth9H1FEYj/PVX7fIHH0yy6StgC9HRTVm0yHY86iZN4MILA0u5WVzs2/DZmZm2RUKW8ZnM3JQ9AuoIw4apcQ00ZGV5R49VXKwc6Vzl1KSUTJ4cT0lJHm++mWHlZ+AIPXqow9945ZVXiIiIIDX1LgoKapts6nQ6QkJCnLKI0mph+/a672kw6KushXQ6LTk56RgMetq27eZy/83o3RtMjI3XcU4ri+uDGwDYseM7Pv98OomJF9j1HraFkhL7QuFAE2VI6fvEM7asj2rGZ3KGm7KHQBFlWKKion6IwNq1izh6dDuXXDKR5OQBVueEEPTvfyNabWmVeNMZBML8NBgMPPHEExgMBm680bYSOMyF7E7Omuxamozu37+emTOvpGvXi5k+/Ten71UTQdGQDyClb5OlWBKZgwc3cfjwZnJy0u16D9tCdLR9E7ZAeMksYZnMxxeomVPWDFvxmcyhO1wlBIE2pmBt2eMuSkvr5gR27vyOzZtX0L37ZbUIAcDkyYtcvm8gENbKykqeeeYZTp8+jV5v21PYFey5Rp8AACAASURBVJgJQVFRDtnZR2jUqAUFBScpKDhFhw79aNSouRURAIiLa0fz5h1o2rQNGzZ8yqlTaQwceJNdPQEoLkxKacWlBK2GfABfZ1CylOl26TKECy4YTqtWnenYcUAtxzJbCA+PYsKE1+2eDySOwJzA3JewZ+9uj8OqKwOcLQTCwmUJrdY7JrIHDtRNpIcNe5Bu3S6jQweb0gG3EAjzMzIykmeeeQat1jqpjrswE4Lvv3+dFSv+y003zeD06TTWrfuIkSOnsnLlC3TqNIgZMzZULeKtWnXm9dfTAJgz5zq2bVtNQsL5dgnB3Lk3sXXrap588nt69KgOlBfkCHwAb1udWEKvtyYEPXsOpWfPoVZ13n//PsrLbRsiazQhTJq00OGONpAIQUmJ7xZRo1E5PtkznbTHYQmhYf36pW7pCgIFnnoOg5rnzsz17t0vo3v3yxzW0esrOXFiPwkJ5zt170AirN4gqHp9NaffokVH2rfvQ2xsPFFRsaxb9xErV74AKBNQe/qGwYPHOSQCAEKEYDDoKCmxVrgFlcVOwhVlsa+8iffvd14BvX79UhYsuB2DodrYPjw8itGjnyM8PJJGjVowcOBNNq+NjoaLLgoM5eaJE74Ts9Xl/VpTR2CJ8PAoLrlkAtu3f+uUIvmyywIj/juoRfTYMc9f/rw8xRF4CqUwbkZJSS4LFpyiUaO6be07dYK+fT2/tyfYuXMnGo2Ghg07odHYTivpLAoKlIjN9n1+4JVXriclZTz/+te/bVr9VFaqIHN1WV2VlRUSGtqA8HDr/nbrBj17ut19hzhnk9f7giPQam0TgX371vPjj29x6NBmq/KUlFQGDLgRUBMjPj6RSZMWkpubyeLF97NkycN272U0BgZHUFnpOyJgNNY2c6yJlJRU2rTphnkMrftWxk8/LTBxDLZzQNS8X6DAW34izmx2KipKWb9+Kfv2rbNbRwhB27bdadmyE++8cwdPPz2wVmC0mggErvWJJ56gZ8+erF37o0ftFBfDcduO/gD06HEF77yTzeTJ79okAosWTWbixChmzEip815RUY1qEQE4d/MR+Ay+CuBkT3zxxRfTWbz4fj7+2NpD8/PPZ7B9u0rDbLlbbdWqExERMXYjloL/XzAzfOmQl59ft2y7oqKEI0e2oOIS2oJ1ec0cEFY1A2RMwTtiIWfbyc4+yvz541m0yHFohaefXsvcuQcID48kLe0vsrOPOqwfCOOZkJBAcnJnOnRw3+4yN1eFirE1lkajgaKiHDSaECIjY2pXMKFHjyuJiYmnf/8b3e5HUFnsZfhKP2DPhj4urh0RETG0aFEdgWv9+qV89dVzmBeqnJyMKrPHq666j6uuus/hvQJhtyWl74L1Qd3B6tavX8onnzzhcrv2FMmBwhHodN6bo848n9DQcC68cKyVh6wtmK1hbrjhaUaMeJTWre3LuaF6jjrpf+YTLFy40GMx8GkbGVAKC08zdWqfqnhgzZu35/XXD9tt48ILb2bQoNFWYmB7OHp0BytXvkDr1l2swlAElcVehi+CzFVU2N8d33vvB9x77wdWZWpXanu36oyCMxAIQWWl70xGdTrHlkiOdAPVENjiFCxzQFjC3+Nphrf8W5xNv9qqVSceeuhTp9tNTLzAqXqBMp6eKIorK22b8EZGxlYRgaioRsTExNfZlhCC0NC6TVgrKor588/PTbGGqglBwHIEptSRFwCtgXJgl5TSJxnEvAlv5x8oL1dKTVfgqdljILxkvszjUNd42vIfAGVxJaWRuLgEevcewW+/fegwB4QlAmFMwXtcli/Fds7A35sVrVaL0RiG0ei+lNuejio8PII33kgnJiaeBg2iqgJKegNt23bnwQc/rSUaDjgdgRCioxBiIXAIeAmVX/g+4GchxB9CiNtt5RcOBBgM3o2IWVqq4t84mwDFjPh427vSuLgEjh3bzbhxGlJT7dPiQFAW+yp897FjdUfatEdIpTTyySdG3njjKHfc8RaTJi2kYUOV3zM6Os6hWW4giIZ0Ou8p352dkyUl+VRWOk/Vc3MzWbVqNmvXOnYy8/f8fOONN4iLi+att150uw1Hxgrx8Qk0aKAyCtZ0IvME0dFNGTx4LJ07X2hVHnCEAPgv8DHQUUo5TEo5Xko5SkrZE7gOaATcWh+ddBXe3sXm5dX9gO6/P4Fx4zR88cWzVWWO0lLGxMQBEqPRPl/v75dMSt/oWgoLHVtnmOGIkAJVAfzCwiKqgvwlJw+s0zfD3/CEGzDnbZZSpex0NiHQ++/fy4QJUWzatNyp+vn5J/j00ydYu3aBw3r+3qwcP36c8vJyGja0r8R1fL1vw9C4ioDTEUgpxzk4dxp4ra7GhRDDgddRqSrflVK+VOP8XMDs4RIFNJdSNnai3w7h7V2sM0HWlGhCotGEVJWZFyRbGcuMRiOvvnqAmBj7SSz8z3Z7fv/KSrDMD24wwGH7+jYr2Ev9ef75V5KaGkpUVGMWLcph587vq85363apwzYDgRB4svCcPq1EaqGhrlnFGY0GQkLCHM43SzRv3p5rrnm8KiG7Pfh7POfOncudd85ASte11Tk52E1Kb8batQt59927CQkJ48knv6NHjyvc7GltbNmyipyco6Sk3Ep0tHIW8pfy3SleRwgxGEiyrC+lXFLHNSHAfGAokAlsFkKsklJWBeCWUj5qUf9BoLcrnbcHb3IE5eXOEZa5cw9RXJxNo0bW3kopKak2d6gajabOlID+3m15SlCNRpXmr317aGRKfHXsmPNchj1CGhMTz//+9x7l5UrD16PHlZw+fZj27fvyr39Ncdimvxcuo9F9sZCUyrEPXDeNfuSRzzEajdg3wbVGbGwzxo9/2el++Qt6PURHu5ZVzQxnuNKDBzcBYDDo0Gq9yzp88cUzpKfvpEuXFCtC4A84oyz+COgI7ADMcgwJOCQEwADgkJTysKmdZcD1gL0MoOOA6U702SF0Ou9auTibMSo6ujHR0R4zMwEFTwlqeroiJkePKm/JU6dUuGVXYIuQVlZW8PTTa+nUSWV3Gjx4DIMHj3GqPX8TAk9Ebbm5nl3vSlJ6Z+Hv8XSXqBqNzs3vSy+9g2bN2tO4cSs6dbqw7gtcwIABo+jc+SKr9KDmzV8gcgT9gG7S9VgUbQBLxisTGGirohAiEWgP/OLiPWrBmzJtKX0be/8//7mQvLxjPProCpKT+9us4y/lpsHg2ViWl1eHjSgvVyEQvJUXIjw8gvz8kzz+eNeqsBKjRj1Ly5bJFBXl0L//9Xav9bey2JMxdZWIeors7HTy8jJp166H3VzG/hZfTpyYSlmZnhdeWEhsrPOcgbPiua5dh9C16xA3e+cYN974dK2yQFQWm7ELcOyF4jnGAl9IKW3u5YUQk4UQW4QQW7Lr0I55ixAUFcHOnc5PmClTzufhh5M5efKg0/fIyNhJXt5xTp7cb7eOvxYuT80bazrouEsEfvrpbcaNE9x3X3WqNrN/gXVYibuYMSOFuXMde3X6ewfryfx0V7eQnZ3O1Kn9ePvtiS5d9/bbE5gxI4XDh7fareNv8eU336zkm28+c5nbCSQFcSDALkcghFiNEgHFAHuEEH8BVdNYSnldHW0fByzTHLU1ldnCWOB+ew1JKRcCC0EFnXN0U2+Z5WVmuiYjP358N1JK9Hrn3/Rrr/03ZWWFtUzILOEvQuDJi2I0Om/NUhdyc4+Z2qwWitvyLzDbeJtN/Rz1zZ9wlxDodO73vbAwiyNHtjqdftKMxMQL0Ou1Ds0m/U1Y3377MwoKioiKaujSdc5udE6c2M/s2deQmHgBjz76pRs9tA+9vpLCwtMIoalKIeovDsuRaMg5TZF9bAY6CSHaowjAWOCWmpWEEF2BJsAmD+/n1UQ0ri6E1147heLiXLserbYwevSMOuv4Y+EyGDxTFOfluRfnyVY6ylGjnuOKK+6moqLac8p+BjjB4sWOA+/4c+HyZDH3ZF63bduD5593HDzOFhzlyjDDn6IhKeHii69x61pn3+/Tp49w6lQap06luXUfR9i8eQXz5o2lZ89hPPWUsnwLOGWxlNL9fGvqer0Q4gHgB5T56PtSyt1CiOeALVLKVaaqY4FlbuggasFbiWi0WtcXsltumeX5jW3AH4TA22IhZ+BKOkp7+Qns+R0ECjwRC3lCCCIiGtrMSOYN+JOwejImzs7xCy4Yxq23zqVTp0Hu38wOuna9mMjIGKsk94HIEQAghLgRmAU0RwV2EYCUUtaZUl1K+S3wbY2yZ2r8nuFCfx3CW/oBb5mf5uUpG/roaNvnzWGBe/ceQd++tiVt/iAEnvx/rdZ1D2ywn47y7bcnANbEwJ5/gb2wEpbwp2jIX4TAU0gprcRKlZVqjphNgv1FDE6ezOGTT76kZcu2XH6585xBRYXz80AIwYgRj7jZQ8do0qQVixblWYneAllZPBu4TkrZSEoZK6WMcYYI+APeIgSuioVKSgp49917+eyz/1SVFRbC//0f/Oc/1SatR49aP+g1a+awdu07/PrrYrtt1/fEkNIzsZC7Vlb2xD1Go4H5829l4cK7qspSUlKZNGkh8fGJCCGqcjx8882rpKaGsmzZVPc64WN4Mq6eEIKtW1ezYsVMjh7d4dJ1e/f+zt13t2D27GvJy6tePF95BR56SFmF+ZMj2L8/jWnT7uH115+tu7IFfBlN11XU1L/4iyNwhhCcklLu9XlPvAB/cQSnTx9i7doFVWnsALZsUe1kZcHatfDqq/DUU7BiRfV1nToNplmzJBITe9ltu753sJ56E7tLCByLdSR//PG5VUlKSiqXXnoHSUl9yMlJZ+HCu6isLMNoNHD6tP1odv7iCIxGz+JfeTK3N2/+is8+e5rDh53L7GdGeHgURUWnycpqwgMPwPz5cPCgirtVWQl//ulfq6EGDZowduwkrryyLruVahgMjrPh+QNSSgoKskzf/dMHR1ZDZju8LUKI5cBKrK2GvvJx31xCYaH3EtG4yhGEhUXSrFkSDRpUWy5stkhU9vHH1U5uX36pnKuSk6FLl4vYseNbvvzyWX77bbHNFIv1vXB5smstL3d/t2VL3GPddm0l8DffvFrlXWw0Grj//o/Q6bS0a2c/366/XjRPNymecAR9+15Po0Ytad/etZySiYk9mT//OGvWtOC772DjRsXVmrFlC0yY4H6/PEFFBSQldebFFxc6fU1lpUoz6y2OQKuFOXOgSxcYPVrpxvbuVelly8vhnXega1e49lr7bZSVFTFlSnfKygp49918pAwNOB3Bvyy+lwFXWfyWQMAQAq3WcVx7WzAaYdcutUAnJVXnBZbSdULQrl135s07wubN8O9/w7hxqm0hoG3b6ngm3bqpkAuvvQbJyUvZtm0yOp1j5Wh9TwpP9AOeON+lpKSyatVsjh372+Z5WxzD+edfwalThxk27AE6dhxIRsZOk9VROhpNCEajgfj4RCsC6y9C4Gm4Dk8ISf/+I+nff6TL14WGhtO0aWv++ae67MQJCAkBjQYOHVLP3B9j6o5589Gj3hUL7d5dfUipOP+iomppwO7dsG0bXHABtGtnu42oqFjCwyOorGxATk46LVp09F4HXYAjQvAT8IOU0oe+td6BM9FBa+LEierJlJ4OjRurhbuiwvm2apo7xsbO5NixVF5+WRGa886DsWPhv/+Fq6+Gm26C6dPVhMzNnYair9WwlbTGV0lhbMFo9GzB8fQlKyxU7LFGE2rlN2BPEWxp113T6sgc1bUmgfWXaMifHIEnyM1VPjUREdC0qXpvBg9WeRC2b1fioevtO3L7DGVlUFRUSEVFGY0aNaFBA8dJ6wsKnA8X4yzSLCxKLUW+WywkcFIqicBTT9lv55lnfqdRoxZoNJqA1BG0Az4XQqwTQswQQgwUrnqk1APcCYWg1VYH7wK1+Jvlhs7mkbXl3Xr48HggHqNRJU4fMAA6d4YPPlBcQng4zJgBjzwC4FzSmvqcFJ7uWj311pwyZQ033jidm2/+Lw0bKhZNowmhR48r68zoZi+JDVjnMPbHS+ZpOG+dzrN+79u3nszMPaagc7aRmanm5ldfWYsj16zZBUCzZkd46CEYMgTGjIG+JinTxo31P6Y6nRIDf/TRfAYObM28ec85rG80up5UyhmYo+i2aaM+u3VTG72oKAgLU8YiUVFKp7JmjX0dUZMmrao8owNORyClnAXMEkLEAFcCdwALhBB7ge9R3EK9q11qDpSri4/RqCh5zXfi2DFFHJzdedlfeHKByYSEQP/+avGy9H5v0AAGDoSIiAQqKmrbwtd0SKvPHawni5Ve7/muNzm5f1XMpV27fmbXrp8xGg1s27bKZn29Xs+8eTezbduaOvPEmgmsP140TxdyT7gBnU7Ls88OQaMJ4aOPrBuqrFQbnwYN4OWX1WZo/351xMWpebtnjwpbrdH8SGLi3dxnSrPd2xQneK8fzEjM8yw0NIy4uOY0bhznsH5GhvfzakhZzRFMmaJEQu3bq/Dgc+eqsY2Ph1GjYMkSWLoUvvtOiY4TEx23G2g6AgCklMXACtOBEKIbcDUq+ugwn/bOBmoujK4SgkOHbNu5GwyuiWHse7cClBEbO424OPu72KFDZ7J69WQsxUO2RCBnCiHwduyWSy6ZSFlZARkZ/9C8eXubdb755hU2b15h81xNhIQk8NprMH489OvnzZ7WDX/qB7TaMrp0SUFKo1U8HoNBiSwPHlSEQKtVO9uCArWDrYYKq37bbSOs2jX7xngjZ4WrMBuF3H33FO6+23HY8aIi3wTry8lRRDQ6Gpo3hxYW0edjLYzrhw9XYucVK9Rmc9YseP55RWjN+P33Jaxbt4QhQ27juutu835nnYCz+QjaAIkW9TdLKV/xWa8cwJydSQjXbd69JSdcv34pGo3GYXaxggLHeYlHj07lu+9Ar58GVIdUqCkCqa+XzFPxhSf6gfXrl7J48f2UlRXSsGFTJk6cZzePg+U1X33lWCRQjSj0+pn8+adaGB54wP2+ugNP8wp7whFERzdhxox1tcq/+04RAVDPPTYWnnxSvV8bN0LDhko/8Pvv0KEDdOtmre0MNa0E5vexPuGKGW5diWfchZkbSE52HDJaCLjwQiVKe/FF2LdPfT7zTDXByMlJZ9eutSQnDwpcjkAIMQsYg8ojYJmP4Hcf9sshSksVJS4rc23QvEUEFi2a7JAIQG0RT02EhUHfvqn8+WcqF16oTM769Kldr77ik3sansNdjqCmkre0NK9KuQvUij1kmazGXmJ7y2cTGZlAefkLtGuXyrFjvsvBbA/eyE/sLUVxdrayWIuJqRbpTJmiRBiNGlV7Ct9wQ/U14+zkKdRoqjdj3jLbdhbOEgKDwXmdn6swE4IOHZyrHx4Ojz+u9DDHjytiMG2aWscGDx5HcvIgWrZMDmjP4pFAFynlCCnlv0yH8x4cPkBhobLZdTXCZWGh5/d2pJQ0w9lwB/1NKQg2bVIy2i++qF2nviaGpzJUdwmBvdASH374MO+8c0eNUNOTWb9eKeLteyIb+fRTiTkaSmTkQSCVK69U5+t70fKUGzAavTNvQXEBhw+r8OqVlWqn2qcPJCRUEwFbyMzcwxdfPMuGDZ9YlZu5Ak8c5dyB+RlOmXI7118/gF27ttms5+nY20JlpXpfd+5Uvzu6YO0ZHQ1Tp0LLlspy8Pnn1RrWsmUyPXsOtSsCrQ84QwgOA2G+7ogr0OlcX3hKS72jMHKsGxBERalwB3VZuYB6ETWaicBcAL7+Wim2aqI+iIEnY+OO74UZ9sazpCS3Kjm9GZbWP/Y9kRN44w0YP34Jt966hby8cOLi4HyTj1l9EwJPTWrT0z1r48cf53PXXU1Zvvx51pkkRGPHKlPmO+90ro3MzN18+eUMVqyYaWV5ZCYE9WnaajBU680OHNjF339vRm/noXqbGzAY1OI9b161yMlZjsCMpk3h6aehVSv1rk+dCqtXV1stBpxoSAjxBkoEVAbsEEKsxdqz+CHfd8978FZ2LHuRL8PDE6msPMrEiZCS4lxbGg1MmnQJoaHh7N6t5ddfG7BggbIsaGzKellfLvyeZiNzt4/2xtMezNY/tj2Ro4CZbNwI27ePr1L+DxmiRHFQv34ZlZXuEZ7yciWf1+k8D4dQWHia0tJ8TpzoTEmJsli57jrXRI39+l3P4MHjuOGGp60UziEh6rM+OQLLe73++qfk5+fQqVM3m3W9RQgKCxXR++knZWzSuLGymurcufo9dQVxcYqgvPGG4iw++QQ+/dTADTds5PbbfZMNrS444gi2AFuBVcDzwEbTb/NxRsFb7PWYMTMJD7dOfhIeHkWTJkoU1KyZa+1deuntpKSkcuutDWjaVNk7P/KI8lKE+iECBoNnO2VPrDLsjWd0tG2TwOjoBIxG68BzSgyUSJ8+C5k3L5Xu3dViWlmpLGGuvLJ60apPjsAecV206BW6dGnAXXddR36+tb+mTqcUipmZ3omJc/nlzzBpUiG5uTcBcOmlruubQkPDefDBT2jbtluNcvVZnxyBJSFISkqmd+9BNGxYO7yvlN4hBNnZ8OCDMGkSfPaZKrv3Xpg8WY2lu2jYUG34HnkEOnY8jZQhfPNNktdC6bsKR4SgEPhOSvmhraO+OugNlJd7b3eQkpLKbbdVJ+wwR77UalNNv91rNypKWRL07asWkMWLlYVLfbCKru7opKxepIqK3Ms/YIZ5QTejSZM2TJq0kAkTXq9FICCK4uKZPPusEpmkpKQyb95R4uONwFFuuCGVZs2UEu62234kMfFK2re/jbi4akJQnxyBPULwxx+/UllZydq1q9m7d2dVuZTKksebNu+vvqph0aJY0tJCCQ1VRgmeQEpZFdTPPKb1SQicJeRlZd4xvf7nn2o/EClh6FAVK8wb0GiUT9HddxcQFXUarbYd33zjnbZdhSOrofHAfCFEGYob2ABslFLuqpeeeRGWXsTewGWX3UH//iMpLs6mTZvzqKxUkRk1muqYRc7il1/eZf36j+nR40puvPFp/u//4KWXFMu4cSN07+7dvtuCq4QgO1txLkVF3ondMnjwOD788GH0ei3z5h0mNDQcUAviJ59Mo6wsA40mAaNxJmFhqRw4oFz2U1JUHJecHMWim+W1QkBJyXrS09eSm6s4i0DiCF56aRH33TeKmJhGxMZWyxZOnnQvl4M9ZGae5vDh5oSEGBgwIIS+fZXFkLuQUvLUU31IT9/Bm28eIzRU5ZH2h2jIaDQye/ZTxMQ04v77a4cd99Y4mk1sx4xRc82RM5i7aNeuM/ffrwLYLVsGs2crjqE+4cizeBSAECIJGGw67hZCJKD8CEbYuzaQUFmpFgpvQqPREBsbT2ys2v6bg61Z7jydxdatq9m79zfKygq58canAbjkEkUIfv8d7rorsDgCo1GJLcCzIHOW0Gg0LFpU+yGlpaVSVpZadd8uXeCxx5Rzzk8/wbp1VClA+/Wz9uDu3fsaDhzYROfOagtc34TAUdjpZs1a8vnn663KKiq8b/O+cuU64CYiI3cxYUIrGjVq7lF7QgiaNUskN/cYJ08eICREEQJve+06gnlMS0tLeOed2TRsGF2LEOj13tv8HTigPnv0UJ7DvkLv3sqvoKhI6TPjHDtLex3OeBYfFUJEAJGmw/y9TgghhgOvo1JVviulfMlGnZuBGSjF9E4pZa28xp7Al8kz9HqYObN60rkjFurX7zrKyvLp2bPaSbtvX7UjOHJEKacG+CbLYBVcIQSnTtWPKCA7WxFCIdRLUlkJ99yjXpYJE1QQv1WrFCHQ6Wor6LOyDpGVdZBdu9by++8fMGrUTCC13kRDri6Ohw97d56eOpVGgwZqr9ay5UliYuyH5nYFkya9S3R0EzSaEL9wWeZ7hYSEMGXKCzbrpKd7h0spKVHvdliYilDsKxiNBnJzj6HRtAHC6pWwmuHIamgqcCHQDNgP/AG8CUyWUtb5OgkhQoD5wFAgE9gshFglpdxjUacT8BRwkZQyXwjh2ZbFBry1a7XEtm1reO+9+2jc+AYOH67WF7gzWS677E4uu8zaji88XJmW/vwz/PAD3OJV0lgbzi7slZXV3IA3YTRahz8AZUprMKgF/v77a1/TvLnilsaOVbuo1q2rz9nKf/z++8pJTa9PrRcHPXsv8+efL+bQob2MHDmehIQOnDx5jCZNzvOqSAhgxowUCgq+BXozduxwNM4YijsBMxcM1cri+lq4LGM2RUU15L77aof0LC523b/IHsxioY4dq/+rL1BWVshDD7VHiDSgQ737ZYBjZfFtQGtUgLmlwCdSyu3OEAETBgCHpJSHpZSVwDKgZsDaScB8KWU+gJTSA7VjbWi1vvEkPXZsF3l5x8jMVLLsvn2VzPrmm713jx491Gdmpm9FQ0aj8wrUY8d8o2z97bfFjBsnmDQpjvx8ZU73669qsbb0crWF6GhrIgD2ndRA+SDUxw7W3uK4Zs1yFi6cw5492+nRI4Zrr+3D0aPeDSglpSQqqj1wASEhkk6dvNp8FcyLY31xBM4skJ4YLtSEWSzkq/EzIzw8ivj4RL+Y45phlxBIKbuidvNbgEuBFUKIv4QQi4QQtzvRdhvAUuqZaSqzRGegsxBigxDiD5MoyWvw9i7LjF69RjBs2IO0aaPk1z16KEuCCMch0W2isrKCTZs+48cf3wLUbvbBB5N47TUNkMTJk0u92PPacHbSeXOnVbttxbYZjWFMn64cbAwGJf6pucg7A/tOf6q8PhYue1zW6NF38NRTc7jkkqtp0yaRVq06kJfnJScXE4QQ3HLLRkBDcrIgPNyrzbN06RTuu68NZWVKr1NfVkOW98nPz2Xr1o1kZByuKjMavZdzIC9PJZcC5S/gS4SHR/DGG0dp1UpZO/gj94RDhkdKmQesEUJ8D/QFLgbuRoWktp9x3bX7d0IRmrbA70KI86WUVvnGhBCTgckAbdo4juFjCW/5DtREYmJPJk6c9lLauQAAIABJREFUx1STjsoT+WFJSR7z5o0BICqqUQ0nqXQOH57Mp5/CxIl1eyq7A2cJwfHjPrk9ANde+39cfvlkNm3S8f77ygX//vtVQC93YN9JTc0dnQ4indJyuQcp7XNO115bzTb+9tsRduwQXt0BHjsG779fLdY47zzvtW2GVltGfv4JIiLUPK2vhctynP7663fuuedGhg69noULVwJq8fYGx/r55yovgxm+5gjM8FfIDnDAEQghrhNCvCSEWAecBl4G4oDHgZZOtH0cldzGjLamMktkAquklDop5RHgAIowWEFKuVBK2U9K2a9pU+c9tnxFCEDtKs1WHgnO06ZaaNy4JWFhkURFNWLZsqdqiTSkLOOZZ6Z50FPHcGbSlZe7ngrUFWg0GqKjG7N1q3q2w4a5TwTAvpNaeLhy+vP1wuUsx5Gb610icOgQPPecckgzGtW8vPhi77VvxsiRU5k37yjNmtWv1ZDlc4uKiqZ370FWXsXesg5cbzLo6tZNOZI5isPkTfjDQa/q3g7OTUT5Dvwb2GqS87uCzUAnIUR7FAEYC9RUe64ExgGLhRDxKFHRYbyAsjLfUdaNG5fz11+H0Oun0bKlcgZzFxqNhiVLyli/finz54+3WScz03FIa0/gzBh50w+jZnpPc0TR3FwVB98bTk+WEUpzczOIi1P3WbIk1e2wD67AXvvl5WWsW/cjzZq1pFevQV4d1927VeBCldQ9k4qKGxg0aCStWnl/E9G0qZLwmsN21MfCVTPK6ZAhQxkyZGjVb53OO5uV/HylZ4iIUHGAXDUHdxezZo3g6NHpwEC/cASO/AhuBBBCXF2TCAgh7pFSLnDUsJRSL4R4APgBZT76vpRytxDiOWCLlHKV6dxVQghziOsp3sqR7Msd7E8/zWffPiXP89TBZP36pXz44cOUlNj/223besBy1IG6FkW9HlauXMqyZbbDQbsCW9Y8ixZNZt26jzhw4FqkfIB+/TxzejLDnM9Ar9dTUpJD48YtWWpSt/iLIzhxIoO7776B9u078+WX+9myZS2LFz9A586Dufvu99y+344d8OqrajG86CJo3Xopn3++hbKyy9xu0xnU5w5Wr3dsNOGtWGJmBXFycv0RAYDc3GPodCr8QUARAgv8RwihlVL+AiCE+DdwGeCQEABIKb8Fvq1R9ozFdwk8Zjq8Cm8nqrZEUlJfjh7tSUWFZ04mNRdGWxAiimefrTuktbuoS6b66adLWbiw9uIN2CUG9nb99qx5/vlnG1J+D8AVV3j4hyzw/fdv8OGHDxEV1Zj33suvNxmsPUIQEhLKFVf8i+bNW5GVpXInnDixj5gYN+OSmLB4sfpPV14Jt98OWu19DBjwLyIjvUBRbaCkJJ8vv5xBevp4oH+9EIKa95BSYplC3Vtiof371WeXLt5pz1k8+uhXLFzYmn37Ak80ZMZ1KIXxFGA40JXaZqABBa3WN7HIQTl55eXNrVpUPFEUO5PboFGjhdx8s28UxVB3PJY337S9eC9fPs0mIbC361ffbYu4pMxBo9Fx2WV76NHjAjf+hW00btwKAKNRrcxmW3pfi4bsEdekpGTefXcVFRVqF9+hQ39mz/6HJk3cMI0yITdXiTIiIxUR0GggMjKmVoA4byIkJJTvv5+HEP2pL0JQk3g/9NA4Nm36hTlzPuCii0Z4zULQX4SgVatOVWElAsqhzAwpZY4Q4jrgZ1TU0VGmnXzAwpIbsLc7dRdLlihlHKiXz5XEFDXhOLcBQCJhYb4jAnUFtDMYIDvbdh/N4aBrwt6uf/nyaQ6teaZMCaNXL+8RAVBe24sXFxMRoaJT1pcooy5CYw7YFxHRkHbtenh0L7N1UKdOeM1prC5ERsZw222vsWXLhezZUz872Jr3yMo6Tm5uNpGRDb0mFqqoUAljhPDMWMFdBKQfgRCiWAhRJIQoAg6hFLmjAXNZwMJMCMy7U3tZrlzFqVOKCISHG3nkkRxeeUVflcTbHdhProLJ6mVmnbJRT1CXWKigwH7KTXvl9ohbbm4GY8bMrAooV40oYmNncoF3aQCgwiebiQDU34tmjxBUVlZiMBi96o9hJgSWtu6ffvoUy5dPo6TEu/4Jlrj66odp3VrtguqDENScq8uW/coffxynd++BXosesHev4pATE31rXmwLmzYt59gxlWnNHxyBI4eyGCllrMURIaWMNpfXZyddgVZbHXLa0e7UHfz2m/o0GJbz2mvN2LhxniddtWnmCBAdHcetty4EUn1KCOoSC+Xnqz5qNNZaM0epOO0Rt7i4BFJSUpk4cb4FMWgOLKRt2zjef/8+TpzY7+I/cA3+Fg0tWDCLTp1C+eyz56vKvvvudd55505yc92LOGfL+/Wnn95i5UrbcXi8ifq0e685piEhIbRo0Zrw8AiPxcA6Hbz1lor+CcpstL6xc+cPnDz5T1V/6huOOIIkRxcKhbbe7pCnsJQVOtqdugqjUQVBAwgL+xTAbvIUZ2GZXEUIQXx8Ivff/zGLFuVw0UVKJOTLSeGII9DrFWeVkpLKPfd8UFXetGlbh6k47dnwmwnHFVfcxaRJi4AuwHFCQlI5ePBefv75bQ4d+tPDf1QbTzxxAXfc0Yjdu3+tl4XLYLBPuCsqypBSEh5evd38668v+fXX9zl1Ks3le1VWKp2VpShDSklq6suMHv0cDRu6kT7LSZw8eYDTp/dV9cPXsLdpKSnxPO/Ahg0qeKFGo2Jb3XSTZ+25g0GDbqZjxz5A4CmL5wghNMDXKN1ANiryaDLKaugKYDrKKSxgYGk2ak8mbU+sYQ+ZmbBypVLMNWsGr722ymvyWLOZoyXmzLmePXs2ADl+4whycqrPDxkynrffnoCURh599AuSkwfavc6eDb/lf2zf/hYaN76VggLBoEGQm9uOnBxJ69bed4M9ffowFRUlZGbuQqO5FPAtIXDEbfz73y8yfPjzFBVVD/zw4Q+RkjKeli2t/SjLyor4+usXSEm5lXbtbCelOHxYEZ6EBGtflp49h9KsWZInf6NOrFv3Edu2RQDT6s2PwIy0tP289NK/6dVrIDfeWDsXgav45Rf1edddnmUd8wS9eg1n61ZISwswQiClHC2E6AakokJKtELlL96LMgmdKaX0QUg3z2DJEdjKa+tIrGELubnwn/8oRZIQarfga6VcdvYRKiqUokOv911WLUeEoGaaxJdf3kN8fCLh4XUHVNq0aRldu15MXl4m+/evZ/78W1m+fBpjxsxky5bf2Lr1efT6nwkNncaGDdVK/OTk/h7+o9oYN24WOl0Ffftexx9/qDJ/EQK9HsrKQq0iWQ4cOMpm3TVr5rBq1Sy+++51liwpt1ln+3b12bkzpKfvpLg4lxUrnic9fQcvv7yPxo1buPs36kT79n1p3bqSEyd8v3DVzNudnn6In39eRWWllqFDPSME6elKzxIVpSL++hP+DDFRV6yhPZhDNp4BKC21HkTzLvSDDx6ktDSfqKjG3H77my5ZDa1fr4hAly4qV2kL371bVbjllllkZR3i44+NGAwan71o9ghMUZEKKwGQnv43Tz3Vi4YNm9pMHlMTer2ebdvW1Co3K+p1ujuQ8mdgEnp9udU5sO+b4C6uuuq+qu/18aI5IgSuhDzp0+df7N79C127Vicz1+lUwvPiYmjQQCUvApU5a/XqOWzYoIwgEhJ6cuTIVnr39l3uqP79R5KZqfL4+nrhqrlhOf/8frz99pdER8d6nILWzA2kpKgx9Rfy809SUKADEgJLWXwmwtaLlpKSSlJSbwDatDnPru37gw8mMW6chgcfTKqyKpKyOgPWddcpImA0Gpk4MZo772yC3kdax169rmb48AcJDVWPxxehtME+R2Bp1XLo0B9IKdHpbO9Ka6KysoxevUYQElJ7j1FZWYaUq1EpKMprnXNXie8szJycvwjB00/fwSuvjLTSXRUX57J9+7fs2fOrVd3k5AE8++wGxo2rzuX088+webOyXNu5U+WtuOMOFQa9WbNE2rTpxuOPr6RZsySb4+9t1Jc5bs152qxZC4YPv5F+/a706Fnu2AH/+5/67k1HRnewZcvX/PHHx0AAcgRnGmwRgkcf7Uxe3nESEnoyaFDthAGOHKBatUrl+HGVFcucsLqkJA+tViXqDfVltgrUi6bV+u5Fs0UIpLR217/kkjvo2HEAy5ZN5d57W9O79zVMnrzI6ppqX410NJoQjEZHsiz7inp3lPh1Ydu2Nfzyy7skJvYkNPQ5wLdWQ47EeJs3/0Rubia33fZaVdmRI9uYPfsaunW7lG7dLrV7bVmZStEJKhlPZKSaky1N4R/HjJlZJfLs16++/D31QGiVHstXyX7sbVg84QZ27lSxmQwGlZDek8CR3kB8fALx8RHk5AQJgUcoLq6df6CsrJisLGVoPW3aWqvsSqAWsLffnlBr4TLvTs8/X3EPgwdX734iIqKZPPldKip85LoM7NjxHT/88CZ6/TIgxmesoq1Fq7jYeqEMDQ0lKakX4eERFBScrGXZU5OQOiYCEBGRQHQ0XlHiO4Nt29awdevXHD26nQ4dFCHw5Ytmb9HSauGBBz6hqCibRo2qg/f+P3vnHR5Vlf//15lJJr2HklASmnSlWYBYUFQsIKxtMSoiiL27roJ9BevquogiYmEVEMuKBUXFRQTXVRGRLiDSEQMkIb3N+f1x5mbuzNxpyb0z4fvj/Tx5MuXemZOTc86nvz+tW3eib98z6dx5kMf1s2dfR3HxXi666GE6dOjDokWxlJUpF+WoUdZ3WAsGp9PJvHm3AjOorm5ASnvEBMHHH79NbW0NHTueAzSNnuO999T6HzECrryy+WNsLvr3P5dhwxQFdosKFmsQQvwbeAX4VEppbislk1BdrfKpvbNrbDYbf/rT/ezdu9lQCLz88iS/B9eBAzsbzUY9la/DEe/TWtJsbNjwFatXf4IQpVgpCIwOLX9VmsOHX0/r1p3o1cuTyCwUmgwNdnsCffsOpE2bLnz++YxmBfFDRe/ep7Nli2pir2mQ0UjJLS3Fw9+voW3brkye/DkAu3dvoKRkH336nMGGDUvZt28zq1Z9xAMPLOPrr9UivOQSXyFQUrKfxMS0kAL5ZsFms5GQkEBVFVRX1yGldQxt3uv0+ecf5Zdf1vLYYz+Snx++IKirc6fdXnxx9IWqhkh3fPP47hCueQEYD/xTCPEO8JqU0trKnzDx66++m1tPLZGV1YHXXruZrKwOjBp1NxDKAdaRzEy46KLmEcs1BT16nMy6dV/y+++xVFVZV2lodGgdOuTp6tGQltaGyy//OwMGnO9xfXCaDIWkpAx69x7G99//m+TkTK65ZlbAFFOzMHjwJQwerFyCzz+vXrNyo/mzCIIFiqWUPPDASVRVlTFjxm5uvPFNHnqogPr6WoqLD3HwoIpxGHXLev31m1i5ciG33voOxx8/uvl/RIgYN+4pZs4EIeItb6eqxznnXEheXm+ysppG/btjh1oD7ds3j0LebLTUfgQASJXisUQIkYbqHbBECLELeBl4U0oZBY+WG9XVvr5Cb3fFwYM7+fxzdQqcddZNxMcnBjnAFL3DffdBTo7nO5s2reDddx+iY8e+XHnls+b9IToMGHA+Awacz113qc5gkYoRVFXBl18aM6KWlu43zOzxzx+kEBMTR1JSBpdc8jdqa6vYsGFZY9A+KSmDWbMmEhPjsEQIgKdCEBfXEZhKXZ11/E3+LIJduw7w1VdvkJ2dxwkn/MnjPSkllZWltGvXi61bv6OoaDvduw/l5ZcP4XAk8PvvNqRUNSxGYamysoM4nU7atGkG8VUTEBOjVGkra13Ad53eeuuDbNzY9MZTGi1HNPiE/GHHjp+ZP/9fwN9bVmWxHkKILFSjmonAT8BzwADgC8tG5gfeC86Iftafti+EjbIylRLjjwpB0SnMIimpsDEQp8fGjctYv/5Lli9/I9yhhw1t01thEUjpu8FKSgJbSrW1lbz88jUer/mjyQDl7rn22leYOXMfDkcCixb9nfLyQxw8uIsVK+aSkJBKSck+fv99C2PHCo+MLTPgzTVVU7MDmMR//2tNH2h/QqCiAvbu/ZU33rjDkPrhb38bxsSJGYwZcx9z5zbQvbvqzBMfn4TNZmtsyJ6dbfwF99//H+bMqaR9e+PCM6ugT8eNpCCoq2te98GWKAhiYhzU10evH0FQQSCEeB9YjlKTR0opR0kpF0gpbwaaQbnWNHhPkpEg8K/tS1q1UuakPyqEPn0mAVOoqLBxyy2+B1N+fn+OOWaIj4vETNTX17J69afU1Cg2LSsEgZELo6wsuKuntraKw4fdk67RZNjtrnZVKF9xVlZeIxWFP/I/Le9dQ3NJAb1hLNQq+fBDa9JU/bmFiosVHcmIEbdw0kkX+7yfmdmeHj1OISbGgc1mo6hoOx9++ASrVi0CaBQEW7a8yf79xg38YmPjsEWKftSFn39W9SJ79+6OmCAoKzvMhg2/UlMTWlzKCL+62DxakiDIyTmG8eOfA1qoIAD+KaXsJaV8TEq5T/+GlHKQv5usQn29+2AsLzfOsQ9EfKbBm+cnOTmLhoYG1qx5BfDPVtq//7k8/PA3XH/96+b9UV4oLt7HE0+cy++/rwesqSMwOrQOHw7MiApgt8dSV+c5oIKCQleTkIVAPRddJHn++e2N7p633ppsSP73n/94pqFqr5tVT+BPqBUXW9P6059FUFSkgsLjxj3HqFF/9Xl/4MCRSOnkmGOGALB9+2rmz7+Hd999gCefPJ9PPvkQgNjYvbz22o2WjL0pqKpSikpFRXXEBMGyZYsZPborL7zQtFSfkhIlWOPioEOH4NdHCjabncRExUHVUgVBhhDiT14/ZwghWls+OgNIqbh/iopUs24j+NP2L7nkUWpr1SH200/w1VeFdOy4nbFjnVxxxT9oaKgBPB3yzTmYmlpmkJGRg90eixDqZLFCEHgfWpWVSsheeunUAMVIgoaGOh56qMBHax89+lVgJDEx0qM4p76+3m99gL+MLbPqCfwJNSFszJ1rvnvISLiWlAS36AYPvpSHHlpORUUJTz01kjffvJPzzruTIUPG8tNPiygqUts0I6OaCy980OPexYunM3nyQJYtm2PWnxEy+vc/C4DMzI4RdA1J2rTJIzu7aYFirfFMly6R698QKjSa9BYZLAYmAIMBVzIlp6FI6DoJIR6RUvp1lgshRqDiCXZgtpTyca/3rwKeQjW3B3heSjk72ICKigjI6W5EfJaUlMULL1zB0qWzuf76r5g+3U2jsGoV/PnP/rMt9AfTtm0rKSraQceOx5KT083vPQCZmUpwaWONiwvNzRMT4+DNN2t54glV/RgJ15BWg1FQUEhR0Q4++GAaNTUVugIxAajdbkQJIaW75iJdR3r5v/8t8DsGf8VnZtUTGHFNqbE2MGmSGn9hoXmBYyOLQONsKinZT21tJWlpbYiLM46pxMUlsWrVx8TFJVFYqDiR27btxhtvnMYff8ANNzxM586e9+zc+TO//baqscgxErDbIS0NsrNVJoUQjogJgvPPv5SOHS+lsgmeoa++gtdfV497ms9v2Gx88cVzwK3U1TmJNOlDKN8WC/SUUl4opbwQ6IU6EU4EfO1cF4QQdmAGcI7rnrEuEjtvLJBS9nP9BBUCocJuj2HixJn861/VTJ++vZEDf+PGZdxxRz5VVXPJydkM3AXA++8nk5xsrGVoB9OKFXN58MEC/vGPi/jrX48N6stOT4dcVxfC1FTo0yc8K8HKdDJ/ggBgzJjJvP56OfPnS+bOrXdpX5473dtS0jStQV7OQv/WlOCMMyYFpKxuLjT3n3c/BYDKykqmTDE3VuA9p7W17rqMRYue5tZbO/PZZ9P93p+cnMGddy7k4Ye/AUAIQadOxzfGCFq39j1tL7vsKR555FsGDbI2bTRF1/44KwsyMqITLJbSrcCFg+XL4aWXlFI1eDCcb12Ir8nYskXx3NfURL5cKxRB0F5Kqeei/APoIKU8BATyZp0AbJVSbpNS1gJvEcFex7NnX8vjj5/DBx88zooVc9m16+fG9+rrVfZIjx4vkpu7iIyMr119js9Fab5uaAeTFvCsr1fqeV1ddcDAphBKa0pIUGl/nTtDbGx4pez6rCGzN5q39lpW5p9zyZ+v/cCBHaxYMZc9e7awYYNS0bwDcIEC91df/YJPP4ZAvQ6agoKCQpx+org7d5obK/CeU71wjYtLJjs7z6Oq2AiDBl1ATIyD/ft/pb6+lnXr1gLJ2O1lJCcL1qz5nDlzbmus8E5OzqBbt5PIzGx63+NQ0Lq1Wsfa4/R0qKlRnO9FRfub3RMgEPSf3ZS9sGcPvPKKenzFFXDzzRAfgdq7cAvVRo68DYCGhsj7rELRT78SQnwMvON6fqHrtSSgxP9ttAP0bZd2o6wIb1wohDgF2AzcLqX0adUkhJgETILgwUxQB5pGAfHFFy/S0FBHba23GlHJ2rXvM336dsrKYPLkuRw48Dremu+pp46joKCQm2/OD6mJe24u7N2rNCjN59e5s3tRtHZFVqqqYJ9H6N0TN9zQjuLiJ4DLqa1Vm8FuYvGm9+ZautQ/51KgWoGXX55E//7X4nQ+A+wgI8PTqvJ3r+bjNerHYDb8jaGjyQQz3odhWZmqERBCcNFFD3LRRQ8a3+iFl16awJYt3/Lgg8vJyTkbgNxcZdH+9NMnLF78HKmprQL2hTAbqanqp7KSxvassbGVQDqHDh1CSutoefXzOm7ccPbvP8jtt78bUt1EdTU895xa40OHwjnnmFtJnJmpxldSohS3Vq3c+7p7d9i1S6UPh4LevU/m/fejIwhC+cYbgdeAfq6ffwE3SikrpJTDAt4ZHB8B+VLKY1E1CYYRLynlLCnlICnloNTUVgE/0Js6orT0d8rLjZuaar5/ZfZOwZsRE2DlSpWxEWq3s8xMVYSWkeF+zXvhtW4dvC9qdXUFoFkf1loElZUwZ86tfgVdoFqB2tpK1qx5C4C0tN983g/WsSwSMBpDYmIiU6eaOwZvi+Dbb5fzwAOD+eWXb0L+jB07fmbLlm8BlTSgxRhycxVH8vHHj+GSSx6lX79z2LNnE7NnX2dq7YUR4uLcP/rK5g4dMgFISWkTseZJmzevYceO1X7Xo/e9M2aowzg3FyZMMJ9OIjFRBZ61ucnLU0SAbdsqq6l9GD0cW2w/Apeff4nrwH8vzM/eA+gTtNrjDgoDIKXUn9CzgSfD/A4fhMN9k56ew/btq2nbtmuAVMO9QOjdzhwOlZYWyj8zPd2/v3Py5M/46KNOfP+98jWbvdH0NAsLF84NKCw1jX3GjMsNr6mq+h2AUaNO83kvlI5lVsPdl2IKFRU7SU7uyMyZU00NFIPnoVVfD++99yRbt37H2rVLGovEguG331QD86FDC2nTpgsrVqjXtT4YvXqdSq9epwKwfPmbfPnlS5SXH7R0PlN1Hcr1nP1t2yr/SmJiZsQEwYsvrmbbtn2kpQVPWvzgA1i5EpKS4K67rGlIn5SkXL7HHuu22PPz3ePOyFAWVCh9lUtLdwPtKSkpBdLMH2wABGtM0yCEcAoh0qSU4dby/QB0E0J0QgmAPwOX6S8QQuToahNGobqfNQuhct8ojcLGvff258QTLwrgwlAH/aWXTmXWrIkeOfRGmm1srNI6QmlykZ7u3z3UteuJZCqFy/IYwcyZ/oOmmqArKCj04R/SYLd3pKHBmAdHuzeSB7+/MZSXFzJnDlx6qaSw0HymMf2clpXBzTfPZ/Hi6YwYcXPIn9GlywmMHHk3xxwzhAMHVKYLuJMO9Oja9QTGjXuOVq3MIcPq2VNlOR065Pm6XhAYvW5lsNhbECQl5dK5c/B4iJSqfwPADTf4UsWYBY2ryNttq09N7dpVWSUHjXWtRuzc+SPQnuLiEiItCEJxDZUDa4UQrwgh/qn9BLtJSlkP3AR8hjrg35ZSrhdCPCKEGOW67BYhxHohxM/ALSgaiyZjxYq5rsImI2QhRDv1KKsD11wzi/T0NgghSEtrG9SFUVBQyCmnuItYjAKbcXHhmZ4pKYFzmfWmotnBOP2hVVTkX3jqBZ2/OWpomIrd7iQr65D37S0CQkC7dvDBBw8D8O233wW5o2nwrIBVlOWjR99LfHzoBfht2vRGiCdYtuwCHn5YVc4fcwycdJL7mqKi7axYMZf6+jpGjLiFgQNHNnnMmZlqDeblqeSGbt1UQkNenhI+drt/QeBQYQuqq2sp9kdb20wY8WGFgt27lUBLS4N+/cwfFyilLxSFLz5ezWuwSuYOHboD4HCkWZqFZYRQgsX/dv2EDSnlJ6j+xvrXHtA9vhfVrqrZ0GIDRkzZNlsiTudzXHppIRfo8paMtFS9C+Oii/5Gly4nNL43ceJLXHzx3/j99y2Gpr62MUKFzaY2WYlByP2ddx5i2bIc4FrTXUNOp3uDSam0fiNNPzk5y2OOtMevvXYzlZXFxMUl06/fTL77rpCGhv/y2mtPc8cdTVoqliItTbnrYmKUP6yiogn5h0Hgzd3k3RsjFNTWwjPPuFtQgjqQ777b88D55JNnWbz4n1x88SN+G9uHgrZt3W4MTSERwtP6aNfOf5KCtt7LyspZufJ7Once0eSx+IN+TleuXMnLL79Kjx4nM3To2ID3rV6tfh93nHWFY+Eyl2ZnKxfR778bv9+xYw8AEhLSLW30Y4RQ2EfnCCESgI4tjX5ag78GM6CKlqScBRQyZEjgz9G7MF5//VZmzlQWQHZ2XqNfOy2ttV//ZLiCQH220izq6jwFwsaNyygrKwDMN7311kBVldL0X3jhSg8h6nAkMm7ccz73DhlSyNKlhWzYAH37wvffq9eFmEpWVgsib9EhK0v9HjfuZv7+dzj++NNM/w5vzXXr1l/48stXaN++N6eeOi6k+597TgmBlBSV5hgfr+bYO9WxV69hLFv2Gh07Hhv2OB0O9f+3290UC4EOykCZaprFarPwc54PAAAgAElEQVTF4XBY0/BXv1Z//nk1S5a8SF1ddciCwCprAFR8IFzk5ankDCNFQd+PQC+cI4FQSOdGAquBxa7n/YQQH1o9sFCwYsVcrrkmmxkzLvdLV+B0OpGykKFDYc2aWUyffplhc3Xvz9Xz4IRKhtZUQdClizIb9cVmubnHYLe/CNiYNy+ft94yLzPEO2NIFV69THp6DhA4n3/pUtiwQT1euVIJqNGjYd68RYaCI9oQgsZYS9u2SoDX11sbH6ipgT17NvPxx0/x3Xfv+L9Jh48/VhXuyclw//1w8slw/PHG+e6DBl3Arbe+49MkKBR06KB6HPfq1fx0ZG292+1JDB3a3ARCY+gF7DHHDGHcuOcYMuTPAe+pqlIFjkIoQWoVmtLLQAjl6jO6V/t/VFfXuQLGkUMorqGHUMVhXwFIKVcLIToHuiES8O454B8dsdtVJ6Inn3yWvXs3IYRgwIDzmTAhg4aGOh555H907Nin8Y4FC6b4NGuvra3kxRfH8e67D/LXv35qSC/RFEGgISZG+Wa3bYP//W8uy5e/SUOD+tsqKnZw002TiIszhxJBnzGk+VyHDbuaYcOuDnhfaSnMn68eX3xxLWvXFpOVlcZFF0WuM5Y/2O1KoGqkYhrS090bzMoOUN6CIDe3B3/+82O0bh08kLt5M7z9tnp8/fXBydCEEBx33Nlhj1ETijabOQVV+vmMRLC4VatejBhhRE7giXXraExeSLaQH7kpFgGoeevRQylUeh4xbZ2WlJSwfPl3jBkTufLnUIyPOoOMoai3rAwlTdRmUw1mzjhDpd/16jWMnJzudOo0EIDKyhJqaipISEjxuM9f5pHT2cD+/b/y6KOnG1oHoQSOAqFVK7VA3nnH92+rqjKPEsHbIggFUsKrr6rimGOPhY8+asWmTW3p1OkFUwvdmorUVHXIde4MvXurgy4pCY+eEr/9tg6Ar7/+yvTv9y7Qy8npxgUX3MPgwZcGvK+8HKZPV/+Tc8+FAQNMH1ojMjLMLUq025VQkRLq6qyRBHqhHcparawEjU9w4EDzxxMTo/5HJ5zQvHRUh0NZZYmJag6FcAtWIeKorw/c+9tshGIRrBdCXAbYhRDdUNk9/7V2WMERLE3UZrMjhIoNnHeeem3ChBc8rrn77kUUF+8lI6Odx+vBum4dOrTbsFtXcywCUItBpZQa/21mUSLoN5emkUyePIja2kpuumke+fm+jtWvvlLxgIQEVZgzbVoramsrqKw8zBVXxCOE4J///I309MAUClYhTZdtl5Ji7Buur1cnSVlZ07ns/UHPBxUqW6yUiv/mwAFlzYwN7PZuNrKb1uc9IBRDrp1rrrmcTz4xv7BNq8epq4MffvgMuz2Wrl1PJD7eVx3X5nP/fuWLH2F+7Jq8vObvcw0Oh1KqQBFTrl+vvZ7KeedFjI0HCM0iuBnojSpznQ8cBm6zclChIBDVhMORyFlnzaGhoZAuXdy0Dt7o3/9cTj99IjFeTHCBKmk1GNFTm7VAcnON/zazKBH0FoG20bZv/4k9ezY2cinp8ccfMMdV8z1+vJrPZ57ZzNy59YwceTf19TXU1VWTnGzBSaNDUpK7sMobesZTfzjGVeiQn9/DxFEpa0DfLrW6GoqKdrBp0woOHvRhTGnE11+rOEtCguK/aSpteTC0aqV+QpmjcGG3K0vgjz+CJMk3EZrSUlkJr7xyHVOnnkFJiXHxzU8/uZWV224zbz+mpipB3batm2/JbLRq5Sb2s7r1pxGCCgIpZaWUcoqU8ngXzcMUKaUFDPnhwd9hnZycxTXXzKK0VGnq+vzr+vpaduxY00jY5Q8aa2VyclbA6/T0EkKYt/DuumuqTxZGQoJ5lAiaIHA63RvtvPPu5KSTLiU315efd+5c5e448UQoUIlM/Pe/87n55nzGj09CCLWMbr+9q2V0BzabCqh36qQ2pd7FERcXms87O1udhDk55oa4yst9XUPLl7/Bww+fzJIlMw3vqaiAefPU4/Hj/Qu45kKLnVjFv+9wqH/Eyy9/ZPpnNzS457WiAnr0OIUePU5xJTX4YpFq6Maf/oRhm9mmIiVFHdT5+eZ9phE0ivGGBv9NjqxCUB1ECHEMiqs5X3+9lPJ064YVHN60B+npORQWPkVBQSE1NTDbRWh9oo6Xa+nSV3j11RuIj09mypQlvPbazbRr15MbbvClOCooKKRfv/NYsuRFPvtsuqEWoqeXMEsIAIwerf62hx+eQkmJarr+7LPmUSJoh7+eBqOw0JjdY/16pWXFxcGVVyqB5x2o19JOjfoUNBcdO6oDLDbW7ZNt1UppaTt3qmrNtBCLMDXhYWawWErfVMDqasUT1K3bYL9Vv+++q+7r3t0tXK2AlcFScDewlzI2yJXhwzs+YLRPNWzfroKv8fFwusknU1ODwuFCxXAkDQ2Cfv16sW3bhsh8MaHFCN4BZqK4gCIspwKjoKCQrVu/o6RkH9dd91pjBeeqVUor69bN05Rr3bozQghiYuLYuvV7tm37gX37NuGH647k5HRGj74XKSVvv+3tBvKklzBTEIASBnZ7IbfcooJTF15o3mdr2kawPgdOJ/zrX+rxBRe40zCDNbj3ZmRtKuLiFDWAUWFNXJz6/+bkhG5Gx7rOqi1btrByZSmDvJsnNAG1tZ4HVn29+hk2bALDhk0wvGf3bvj8c/V3jR9vbeFQSkrwa5oDbU6taJ6kV1SCVRR/4ipbPe20pqV1BkKkBAEo92BDA/z2204aGhqwRygTIxRBUC+lfNHykTQRV13ly3axeLH67a1pHXfc2cybp7TXX375hmOPPZvMzOD0gAUFhaxa9RE7dqymvr7GgzgtPl5prVaYcu5N5sTpNMeu149TEwQ7d67jiy9eIC/vOIYPv7bx/XXrlNadmUljwB2CB+rNajXpTwjoEY7Gq/ngi4tL+fjjj00RBN7kgqEEiufPV0J2+HAVfLQSVlsE2jn117/eyIcfTiXdxECEZ1JDPfX1zsYGU3oUF8N//6vWitkB4lBpJMyC3a4W/I8/7sIWwYqyUL7pIyHEDUKIHCFEpvZj+ciaiK1bVV52UhKccor/67p3H8q99y7m2msDN0V79dUbuf32bmzd+j/S0tpwww1vMH26uzF7crI6KK0IIt10k2r+W1paZlrwSL+5tENs1aqPWLLkRd56y5Pt4/PP1e/hwz0tnmA9IcxoNelw+A/yNxVKEMwFRvHwww+Tn5/f7N7F3m6mYJrxhg3KYo2PN9fK8werBYGmrCxfvpT9+/cHvjhM6IXs2rUruOKKOKZOPdPnui++UArOoEHmx1rMti6CQVNWEhMzAvCmmY9QBME44C+olNEfXT8rrRxUqNi//1fmzLmVJUteanxNMxFPP735RTOqwngWDQ1qRRpVGFu5UNzN6+tNEwRGGUOZme3IyurYWF8BKp1t1Sql8Q3zKhoNlFXV3F4DNpuqpejf3/zg5tdfz0X1N1Lxnh07djBp0qRmCQN/FsHzz1/OxImZ/PijZxD1LdW6gZEjrcni0SMhwbpMJA1ui+AftDUzQotnLKu6uhybze7T77m21s0yeu65pn49YL0g9Ya+K2FEvzfYBVJKczhuLcCaNZ+zePE/iY9PZvjwazl0CL77Th0gZ/spvLzxxo4UF+8hISGFyspSjyCzNxYsmEJDg6fK5+0Dt9J/+MorHzNuHMTHZ1liEWiuoVNOudKDWRXU5pJSZV15H1j6HgMHDuxobEKv52RqKrKyrDsgX399CuAZ29B6Fzc1EO9tEWiCoKKimIqKYg+tbtcu2LJFKQ9WHFreiMQhplkExx9/ll+W0qZCX0MwYMD5vPlmHfX1noGt5ctV6m6nTirwbjYiGR8AtyC47767ueuu8zj11FMj873+3hBC3C2lfNL1+GIp5Tu696ZJKSdHYoCBkJLSqlGbBVixQvleTzjBTTTmjdLS/UjppLJSFUuXlOzzm+kSSlcyKy2C9HS1k82koTYSBN44fFiZ2wBnnWV8jVU9Bsx2B+nhj267OYV63haBpsndfvt71NRUEBfnPkmWL1e/Bw+2tmduYqISpv72gJnQDi6NIdcsb4aeIVebYyEEsbGeDvv//Ef9Pvdc84Pudnv0BMHHHy9k+PB2ERMEgYxvPbOTN1W0BTV74eOkky5ixozdPPLIf5HSvdFOPtn/PUlJvrmGRsVh4N8Xrgkeh8OtEVkBzS9vJvuoUYygqGgHhw8faHx94UKVpXHccf6bzViBhARrs1xatza3UE+f565BE64ORzwpKVk4HOrEdzpp7DYWKHbVXGRmQp8+KoEhEoeYdnD95z+f8f33P5j2uXoB609hOXBAcXPFxSnlz0z07KlI/yIZKAb3fN5552OceaZvPMQqBBIEws9jo+dRx/btKi0vOTkw9az+wNPDKNMlWLMaqwNJM2Yo4VRcfMhSQfDwwydz7bWteO21mykqUtaAENZTHnjDSmsA4PrrpwLm9S42qkfwd2itW6eyW9q2VWmvViAnRwnuSNIXa4rQ7NlPs2DBW6Z9rl4Q1NXBxx8/zRNPnMuaNZ83vr7SFak87jhz07e1PiHRgCYIzjzzQnr1Ck6wZxYCLRnp57HR86jg8OEDVFaqah7NGhgyJHCALDnZOOHJKNNFqzDOzs5DCF96Zqs1rj17VPuHujqn6a4hRRTm+V5GRi6LFqlrhgyxPrVRg92uqjataieo4fzzC4FZCKH+n3l5ecyaNavJ8QHv+dO78ObMuZUXX7yK0lJFhapZAwUF1tQN5OdH7v+lh7bXBg48k+OO62/a5+oFal0dbNv2I6tXf8rhw0WNr//gMkCOP960rwWUMhnJpjB66F1tEf3eAO8dJ4Q4jNL+E1yPcT0PycMphBgBPAfYgdlSysf9XHch8C5wvJQy5Iykxx47m+3bV9Gt2/3s3PkIENgttGLFXCoqfFvqxcQ4/Ga6BPKFW20RTJhwAzfdBLGx5rSu0/tdtYWm2nvaAMGSJTMpL++InqgvEujcOTL+bKW9FpKYWMihQ83XIr0tAv3m/e67dyku3ssllzxKfb3KwAKCNkdqCux26ygqgkGzCMaOvZvLLgt8bTjwFgRjxtxHQUEh+flK2Bw+DBs3qr+9v3nyB7C+CC8QNEHw3/9+Axxi5MimtyEN63v9vSGlbFZJmxDCDswAzgR2Az8IIT6UUm7wui4FuBUIu5Gs01kPnM3WrfcjJZx6quJU8YcFC6YYtrKMj08JK/CZna18h1YvmFNPVbXyUsbidDY/GOftFvKmilDusUmkp0N+fmSazTsc7oplq6GnmDCjANBfoBhg/PgZVFaWkJKSxcaNiiunXTtrrJ6UlJahwZpJlKYXBLW10KFDb4+2nD/+qL6vd2/zLfOWIAgef/w+OnXaETFBYKU38QRgq5Rym5SyFngLMOJW/RvwBBA2kd1jj/1MTs6nSBnLWWfBpEmBN4S/LKCKitCbrtvtSoPt0MF8WglvaNqWdnA1d6N5ZwwZU0VUUls7JWIHS+vWkTvE3DnataSlxfHrr7826/MCWQTHHz+aU0+9CocjwTIXhoZo+bPBvUbLyqrZtWu3KZ+ptWrU4C1wQXXKA09SSbMQ6doBPbT5PPbYoZx1VvjNh5oKKwVBO0DPwbvb9VojhBADgA5SykWhfqhe61q3DvbtE2Rmqh6vwYJkwbKAQkGrVpELxu3apWIEDQ2+m6Mp8LYI/AnGykpzKCJCgdUBYj3cGV4O6upq2bZtW5M/y+kMbBHor9OCmlYJgpagwT722HUMGGBOcNMo9vLpp8/x5ZezXAzCqh4jIUGl4pqJSBThBYL23bfc8igzZkSO2SeC+QWeEMox/QxwZwjXThJCrBRCrNy7V3LQRX3+2Wfq9/Dhof3zgmUBhQKTiycDYseOLYBSM6uqzLUI6ur8C8ZgFBJmwcwmH6FA6wQF8PrrHzC4GadIWZn/1NH6+jqWL3+TlSs/ZNs2lS2Una2KnsyGzRZdDVbbdw5HCmlp6dQZqe9hQm9ZSQm1tU7eeOMOZs++FhXLUu+dfLL59RhWV3sHg94LEMmeBFbKvj2Avvtqe9drGlKAPsBXrurLtsCHQohR3gFjKeUsYBaAEIPk88/Dn/8Mq1Y5gTp69twBBE9411fEHjy404M8LhRkZ1tbCOSNY47pjRB1SOmgpsZci2DRorlUV5f7XGO3N48iIhTYbKoKNFT6aDMRE6OE4BlnjGryAWpEPQ1ui6CyspQXXriC5OQsBg5U6connGCNCyya8QFwC/LrrpvOtGnTTamr8Y4POJ31nHfendTUVFBXF9uYgTV8ePO/S0NSkoovRppbyBva/NXWSg4dKiU1NZ74CBw6VloEPwDdhBCdhBAOVIHah9qbUspSKWW2lDJfSpkP/A/wEQLesNth0yZ46CFQw59LVlboVR8FBYVMn76defOcHuRxgZCcrPqfdu0a8teYgg4dOpHkioRVVRn7SsOBJggWLpzLs89Oorzcu6tUFhddNMuSimE98vOjIwTAHTCuqYG5c+eSn5+PzWYLi4CuvNw42KwdYDabjaFDL+PYY8ezYoU6qP1VaDcX0ZpHDZpFYGb1u3fGUEyMg8LCJ7n66hmNDd+7dlVxOrPQrl30hQC453PmzGdp0yaDJZr5YzEsEwRSynrgJuAzYCPwtpRyvRDiESHEqKZ+buvW7kYlffqsZdSo/T49h81GTo61FcSBoDFmjh2bT2pqeAeWNzRB8NRTU6ip8e0nIEQyF1xgrhDo1MmzOjMrK7JxAW9ogmDYsL6MHz+eHTt2IKUMi4CuosL3NeXCUI+TkzO56aa5ZGc/RUODsgbMSu+Mj1fuydRUdRjm5przuU2FZhGYlTXkXd/irfzscLUSN7PiPS5ONYVpCdDOmfj4NFJSUqisNKe/drAsOUvDIlLKT4BPvF57wM+1p4XymQkJ8Mwz6ndqal+gb7PHGQhxcZFLbzRCbe0c4Ab++EMtCO3AAsIqhNLTIezbZxwMlnKnqW6Gzp3VoZ+crAL7VvnJw4Gmce3atQHwVGFDJaAzKvbxfq262s2Kef75TRysAbp0iW5w2BvafP7441IKCu7g0UcfZtSoJut5Pv0c6uqUq624eB9paa3ZuVNtRpPadwNKsEbTvaaHJgjOPXc899wzwbTU2GBsplELFjcHbdpELmWuTZvoLpLKysn4Y8wMB/rm6m3aGO+i5GTzdld6ulvzT0pStB9W9c0NB+6kAmM/RjACOn8uEP1Gq6+v46efKqisVILPLJdi69YtSwiA++AqL69k7drVbN++vVmf592JrK4O1q5dwl139WTWrImNFoFZVdRJSdG1UL3hdrXZTA0WB2uYdEQKAoCtW3/gscdG8Oabf7Hk8+PjoX376FVsgvLlw17D98JhzJTSUxBMmmTUTyCRiy82L0jczstbF2nyLn/QXENt2hifJMEI6PyV/utf37hxGf/8p+qRcdxxYQ/RL7zntCVAEwT5+cezePHKRmu1qfAWBJWVYLPZadu2G+np3di/X/0PzZiLVq1UQVqEukGGBH3rT7NiLvB/WBB88skzrFnzGYsWPc3NN+d7NIsxA127KkEQrUWycOFcJk/2v6nCYcysrPT0EZ58sptDSTGG5JGaOouzzjInPpCa2vI0Vw2axjVx4lQSE8MnoDMSBFLCvn3u5w0N9QihmCP79GnWcBsRE9NyhKkeWowgMbE1PXsObFaGS329b0ygvFwV5z377GZOPvkJpFRxETNidh06RN9C9Yb2dx0+XMGf/jSCE088sdmfqTKvAl/TwqYhNKxYMZcffni/8blR57DmICYmurnZAE8/PYWqKuNAUbiMmXprAJTWpWVPXXedE9hOr17mBYnbB28DHTVogqCqKo4//eli8vLCI6Az8rXu3OkZQO7UaQRS9sXhMI9pNCHBnM8xG/q8d6dTKRw///wz55xzDrNnB24D6w1vrbW21nO+zXQLJSREtoYlVLgFXALffLOM77//ntLS0mZ9Zih9tKNYQ9d0LFgwhfp6zx3p3TmsOYhmyb6GvXv9u37CYcx0On0Pr6oq2LVrPa++egPl5fcDw03zuaant4z58wfNwnvmmUeAtQwbNowHH3yQgoICuoVwantbBJWVntYAwPr16nf37uYdNi1dENTVwbvvvs6qVV+SkZHK4sWLycnJYeLEiSF/lrdbyFuBMVMQRDvt1h/cPUhszJu3iGOPzSOlmeZ1KG0vj0iLIJTOYc1BS1gkubnGrp+EhMSwsoVqajzT+jTf46+/fs+mTV+zZ49aefn5zRmtG9GgQg4H2sEVF6c219KlS7n66qtDOrCMaD6MCsvWrVO/zXILQcvIcTeC3iL4/POFzJ//Jt26dWPevHkMHz6ct94KvUeBt+Za7qp3nD37Ou68swcbN5YA5mQMtVRlRV+XMXjw6XTp0gVbM/1XoVgER6QgMIMzCJQLo317X99rSxAEd901lYQEz92fkJDIM8/MCutzvBeBlpack3MM3bufgs2mGtabcYC3atVyNVcNmkUwf/43FBZeo3s9eDDISLMq9y3OZtUqJR0qK//dpDEaoaXOq14QXHzxRP7+9xcZPXo0F1xwAVdffTWXXXYZf/zxR9DPqa31zXXX5jYlJYuammqKipS/1oy12lIFgT5Y7K3ENQXV1aEx7R6RgsCIAiFcziAtGNy+PfTo4T4g4uLMo5GIjW16MGr06EKmTZtFXJwK6Kam5jFt2ixGjQrP9eVtbmu+7O7dh3LjjctoaEgiNdUcjpVI9BRoLrQCvUmT8pk3bzYdO+bx5ptv8h+t+a0f+KOV8HZfVFdDaWkqUIuUq80adosVBJoSVV8Pp556Ppdffh35+fkkJiYyZswYLrnkEsq8J8kA3gqL0wkLF87i7bfvp1u3wTidXaitjSEzs/mKWlJSdInlAkHfnvaPP37nnnvuY/LkpreHNyp+NMIRKQgKCgpJS9PY33w7hwWCECqfPTvb/VpCgvLntmljbtl6QoJn0DncrI/RowsZMmQ74GT8+O2MHl0YVv9ip9PXp61fGFrKd35+82slhGi5WpYehw/PBSZx4ICqKN65M7SK4tJSX4vAO5gJ7nhBq1Z1DBt2pSljjolpWYFNIdzKkqbBagWLCxe+x4MPPsj69euZP38+b731Fl0CNQlxwVsQVFTAN9/M4/33H8XhSGTs2C8BVaTY3LG3pLoBb+hjLk6nkyefnMrMmTORTTANpAxdELRQuRgcM2fuC36RF2JilPZvlBGUmmr+QZaQoP6xhw+rx61aqb7K4eQHawvjt9820LPnIOLjE9m790BIGqKRb1BzDW3atILly9OBPqbEB1JSWl4qnhH27ZuCvwI9f7GXujolCLxh5Bba7aLk79w5ibZtzakkawnWgM3mXrcJCUoQVFd7uobq62H27H/www8ryMzMpHfv3v4/UAcpfddqaSmceeb19Op1Grm53RupvEOQKX6RkqLujyRxZLjQU3a0bp3DnXc+xKBB3XE6nSG5L/Worg79rDliBUFT0KaN9WmhQrg7icXHq99JScr1YrOp34dC74PTuNGESKC6uora2hoqK0M7HIyqNDUNds6cW9i+/UGgjyk+12jT94aK2lrjhIIdWkqKASorja0wI0Gwx8Wva2bxV0sQBKmp6u+tr1eBa8261RJaKivVodO37yD279/J2LFjAWhoaGDjxo3k5eWxdetWFi5cyMCBAxtpKL744gvatOlAamoPj+8rLYXBgy9tfK61jmiqIEhK8nQBt1ToBSsIbrrpQTp2bJqSFao1AEeoa8jZxJK7SJiE2oEYF+d2t2Rnu//BKSnKxxnqwalpCKmp7Xn88TksWPA1ofBQNTT4HlT6+1JSWgFKYzPDHdYSAuyhIC7Of0JBudHJDn7nO5Ag2L//Y/bu/SXc4Rki2jUtoNZzWppa04mJaj3b7W4X6+HDas3df/+zrFu3g9auzXb++efTt29f7rnnHgYMGMAjjzzCe++9B4CUkgkTJnDccT1Zt25V43fV13vGXurr3W7MpriGrBQCgT5TfwaECr0g0IrrmsI7V1///4EgWLTo74wda+O220Kv1snMjExlZny8Ouz15qd+MQihmA7T00Pz+2ruqqqqWEaOvJJBg4bS0BA8N/jwYV8tVn9w3X33Z9hsXRGi+TQasbHm9421Cp07TwW8mxM5uPfeew2rYv3NdWUlfPrpXG6+OZ+xY22N1e2aa+ibbyaza9faZo+3Q4eW4dOOi1MCKTnZrZ3Gxyt3J7gFAXgeXMceeyz5+fl8/vnnja9d5upyX15ezumnn06PHn3p1atf4/slJVBZeZjVqxeze/cGdu1Sh2LbtuGvs9RU6NXLOvbghAS3EuRwuLnJhFBzE27ar3YmaF0Jy8oOM3/+h8ya9XZI9QAajPZ/IByRgmDfvs2AdDWvDw2R6iwWE6MO+VAWQCi+Sm2jFRd7brBAWoLT6ZvN4n1PUZG6Liur+YFIM5kgrUaHDoXALFJTVUVxu3Z5PPHEq9x55zRiXKkkUrpjAt7uNVDzNnv2XGbNUkFnkI3V7b//PhchnJx99ghycrqHPT4hlNbbv78i6msJ/EIOh7u7m56JNz5eKTVCKCVDS0zQ+6anTZvGb7/9xsqVK/niiy/YsGEDZ5+tevGmpKTw0kuvM2bMldx2WyEVFUpTKS2F3bvX8cQT5zBz5ni01tJNcQt17WqtOyg2Vu33uDglsBMS1JxkZKizIFxL2Tvmsnv3diZNuoCpU+9l3z7Yvz/4Ad/QYLz/A+GIjBFMnPgS559/F7W1BrvUAJmZkcto0RZdKIsvPt44JVEPvSC4//7x7Ny5msmTn+aUU84gPd3Y9Dx82DhIpDcVteyWpgjImBilqRYVKUGijfFIgDrrC5kwoZBbbnG/XlamDryUFHWoFReruTUKuO/cCW+8MYXaWk9prJ5PoU2bQq666skmjc1fMkMkoA8I66G3pPXrLT5erUaVhx4AACAASURBVPOUFLXmDh5UPEBSKgGalOSuz0hLS2O4QUux8nL497//xS+/rGX8+Nvo3/9ESkrAbnfQp89w2rfv1eT4QKhWd3PgcKg5yclxv6Y/axwOJRyMFAp/nwduQdC1a09OOeVsevY8DqfTSVWVjdLSwK7l0lJfYRFMeByRgsBms5GbG5q2FRNjXtVsMISreYRjEZSUwNatH3H48EFWrlzB0KFnUF7uS+7mdBoLl9paz0Pt6afvBP5OSkoxEF5Xjq5d1UKMJjNruIiLUy4eN9eQ+71nnnmAr776hEsvncDdd19PiSpg5dAhX0ErJRw44L+6HXY2SYvX2ndGUwjk5qq1471+/LlUtblMTVX3/P479HW1B9EEgYb6+nqcTicHDx5k5cqVOBwOkpKSad9+MJMm/YX6+jrat8+ntFS5gbp0GcSUKV8AcM896jPCjQ/oU8StQiiCJjtb7d/y8uAHsrdrKDY2ljlzFntcU1qq5tbI3eUdX9FQXBz4e49IQRAOOnaMXA52uILAZnMfUP6g+YeLi2Ho0Cuoq/uN448/GVALIjnZ87DyZw3oaeKdTidSql3VoUN4uXTt2h05GUIaHA6lsXmnO9bVqedffvkRGzaspk2bdlxxxfUe8+e9ccvK1L3Z2R1dbiFvdCQt7SD79h2iVas8YmKCLz4hlBCINGOrzaZcGIcPu10ZmZnqt5TuQ8WfwqKtu7Q0lTar51zSGG/tdujevTubN2/mlltuITk5mWnTpjVeN2HC7dx33zONz3/xiq83NMBeFxN7OEkNdrv1DaVsttD2vN2uLOf4eGVFB4ImXBsa/Lem1ZQRvRWiobjYWNgEK+62NEYghBghhPhFCLFVCHGPwfvXCSHWCiFWCyFWCCF6hfK5f/lLH+68syc7d64LeJ3DEVm3RVOqFePj3QFmI2jjLy2Fyy9/lmefXciQIacDaqMePKi0DU3jMLIGDh3yTVnt0eNqAPLyQs9NzMoyt+AuUtDiNXa7ZwGUZiGNGnUZp512DiNGXOgjRBcunEtBQT6dO9soKMjn7bfnsmLFXCorfQsLbLZEYCo//DCVO+44hqIi/ympenTtGp2sq4wMte68+/WmpqrxZGWp9wKtayHcikFRkbsdqtOpDvCaGrjuuusA6N+/PyeddBJnnHEG/fr1Ize3AxMn3tn4WTU1bs21vr4WKSW//64OxOzs8AKvWVnW17WEq2AmJQUPdnu7hkBlV+3fv5f1639qvK6mxre2pbra0/2rFaGVlwfPPLJsqoQQdmAGcA7QCxhrcNDPk1L2lVL2A54EniEIyssPsXv3evbu3cRjj50VkHo60i3omhKUSk9X49Q0MfAsgdeEhOby8U5ZLC93C4IDB3ytASndrI0rVqgsl8LCGDZv7gnMNdQqjKAV4xyJ0A4QIdz/o4YG9+Zo0yaXLVs28Je/XEVBQb6rIZC7J8SePaoKec+eHTz++HheeulqKitLPL4jOTmLhIRZQCFnnnk8QthISgpuOuXnR5aaIylJWZGBlA89gmXbCOEWYqWlnm6JhgblLrruulvZvHkz48aNY+TIkSxZsoRly35i2bJttG3bDiklK1YsYcaM5xoPr2ee+RPjxyezYsXPQHgKSFJSZMgPm+JpyMoKLFj1FoHmvty48WdOOqkdt9wy1uPakhK3N6G2tp5//OMlj/evv/5C1q//KagVAtZaBCcAW6WU26SUtcBbwAX6C6SUev01CQia8KTXskpK9vntQ2C3Rz7trimCQBNUmmYVE6MWi7ZJ9RrXli07mTPnH7z//pshf762WFasmMvLL7uzXJzOHcAkNm8O3sMhNlbx6rf0ymGjQ0tPz2CzeVoEhw4ZH/a33345vXsnc+edV/r0hGhoqKO+3rc7TWxsMhUVhSQmwoUXjuWRR74lNTWwOdqmTeSy2TSkpCjt2qzv1a/Pw4d9/dNSQlGRjby8bgjXYq+vV0IjRnci3nrrWKZPv41Dh1T+bUVFMTU1lZSUKEd/qIIgLk652SJRONaUlFSbTZ1L/vaSNiX19Wrv1tZCly49ycpqTU5Oexp0DHJSKkF76BDce+8j3HffjRw+rBSUDRtW88sva3njjZkcOBB8XFbGCNoBu3TPdwM+7XaEEDcCdwAO4PRgHyqlp8rrrw9B27aRJ5Zq7uJLTlYL2WZTG7akxO3H3bULvv76c1auvJ02bXIZM+bykD5T8w0uWOCb5QKVvPvuFE49NTBHU7duLYvrxgixscqNUVurLCMtlVHvThDCUxCUlsJTTxk3AKqsDKMaByguVsHjzp3V/6xr1xMCXp+aGrkkBg12u/n0CnqLwEgQgLJS9+1T6zs2Vq1rveUqhOC00y6kvDwWIdQJ+dBDK6iqKuPFF1X0PNQU5by8yK3Vpn6Pw6GEsZHfXqsi16yBAwcgNzeOH374vVGQ6qFSnSXbtv2GlJJt2zbTr98JCGGjsrKChIScI4N9VEo5Q0rZBfgrcJ/RNUKISUKIlUKIlUbve/chSEiITv61GYJHO6hsNnfxToYrqaesbDdCCPbv3+vhwvCH2lq3z7WpPRxyco4MMjntgNMCw1oFt979IYSn6Q2wb585PSxAnYY2m+ES9UBcnBKukXRbgjU9DfQWQWmpclUaJStofbMPHTJ+f8KEmYwfP53MzHauzxUkJqaye7c6okLpepeaan2AGNR+zMxsnsBJTDQeq9Ye9+BBtX81YaEXAjt2/OqhvAgheOaZf/Hhhyvp108pID169OWrr3ZxzjkPhTQeKwXBHkBv0LV3veYPbwGjjd6QUs6SUg6SUg4yet+7D0GXLtFxY5htjiYkuCuRYS5btz7V6EPds2cHkydPCigM9BqHvx4OSUn+d47D0bLbTurhneuelaXmzdt816fnAbRqZVY1nBOwsWnTiKAtU485xrpK10CwShC4FRX/dN2BUFVlfE91NWE1q4+EhZWcrBSM1NTmC3JNcLVu7RYKsbHKm6H1wa6u9pybdetWce21Y+jbN5VFi95pfF0IQe/e/T2e791rp6FBsmjRMxQV6Z0zvrDyuPwB6CaE6CSEcAB/Bj7UXyCE0HNEnAdsCfdLvPsQRIJYzh/MFgRaqbraaFNoaPB0YVRVVfL001MM762ogAUL3BQI1dXGpYbV1WV+D668vJZF0pWU5D83PFSXh7dFcMklU4mPb94JqfIiDgOS2tqDAftnt2kTeTqO1FRf2hOz4G0RgG/rzmDQrq+urmD16sVs2rScqVPP5LXXZiClsvCCWdu5udZ1cYuJcbtsM8IruQmK1FQ17pQU99+oKV9a2uyGDbB1K5SVST78cD52u51585Zy7rkXsXXrRrZs2eBDU33woMri2rNnI++//yiPPWaoYzfCMkEgpawHbgI+AzYCb0sp1wshHhFCjHJddpMQYr0QYjUqTjAu2OfGxSVhs9kx6kMQExM9DVafkWLmZ7oXn7ELw6i3cUODLwVCebkx5Wl9fS0LFvgKk9atW0ajGc2y03Kxk5NVSq1eG4uJCd0tp48RAAwdWsiECbNISWnaH2uz2ZHS0wmrxa28YbdHfn3abErbzMqyxhWltwg0zbW0NHSitIoKt+U6c+ZVPPHEObz//qOsW7eEbdtUoCdYoDguztp5TUhQwig31zrFSB9r0f7ePTr/yYEDsH69YOTIp/j3v3/ihBNORgjBjBnTOOus3sydO7Px2poaN1vrggVTcDobuPTSBwN+v6XhVCnlJ8AnXq89oHt8a7if2a5dD6ZONfbDtm8fHZMbrFkgmiBQGldHwDcvXUrJgAHZPPDAc4werQTir7/Cm28aBYeN4R0nSEqKfCDTHzQSLyndQiEpSbl4ioqUHzUcMkE937uGgoJCCgoKGTvW/0kphO+BHxPjMMwgAuPYS25u5Nen1YFTjWY9Jka5MWpq1P9j377Q0o31hY59+gynqGg7p5xyFaeffg0ffHAGAJ06Bf6MTp2sdQVrc2h18klysorpaYJAswj0qKiAjRsVkZ7DAZmZ2bRq1ZZBgwoAlW20aZNb0bnttneoq6shMzOwGRr1YLFZaNcuupQHVgoCpXH5smZqKC4+yN13X83ChXPZu1cF5PxTIPjCO8aSn98yUkXj4tSPw+F72MfGKi0tIyM8vv7uLmaSzZt938vONk4+z87O44Yb5pCc7LYakpOzGD36VcD4Hu85jVZnLKsZdzVLWEso0KyCAwdUamMgSoX9+z2zjIYPv5apU39g6NCxJCRcxG+/ZZCUBMOG+f+MlBTrK90jJby1/a5lSBkJAlACd9my35g48QJ+/XUT3323l+7d+yAlbNniSZ9it8cQHx/cF9kCtnt42LbtR266qaOHD7ZbNyVFI52FAW62USs2nMb4qBa6Ys1UbjFf1NXVMm3aFHa6zn9/wWFveMdYkpMjT3XgD8GqbTVzOpyY0IknKsGyfTuNnEIaLr10Kg6HN0W1mp+CgkJefvkA8+dL5s+XvPzyATZtKgSmuiqKfe/RIysrOtZqJKjXbTZfQSClmuN164yJ+8rKPK0BPZxOmDdPPR41KvD/NxKutkimTgvhFgT79vnvMGa3Z7Js2ad8880SyspKkVKwebNxJ71QcMQJAoCDB3c1BuRSU6Pry46LUwe1FWlrmmDTWDGhMGBTHr0VcOmlU/0KDQ1GvZ4jXeBkBCGUlm9F8C8xEbQOimu92gUUFBRyzTWzyM5WFNWBemGvX68OucTEQsaPD35PtHoKRMI1pO9X7Z39U1Gh5rmoyG0dHD6sNFd/1sLSpaoaPjMTRozw/90aFYaViImJrHWszWV6unJfHjxofF1iYhq33fYe//znDv74I51Nm4ITywXCEUs6pwXkrr02eMN6K2HlRtNXHbdurbSolJSOlJUZc9jo3REFBYXMmjURp9O4miQ7O4/p07d7vBYXF/0AcWys8qVbZd3ZbIrr/6ef4Oef4eSTPd/X4gWBsGMHvPqqenzeeTB8eCHDh/u/Jy4uOrUYdrv1fm1NEOiLyrzR0KDiVjt2qP9vIErmQ4dgrsvYv/zywPsrErVCkS6k1LwAubnKYt271z9f2sCBIwFCqhz203zP/b1hjrNF4eDBnVF3Y0RCENhscMop6nFi4lTsdmMfQ3V1Oa++egPXXJPN2LGCurpqhLD5XG/kugDrMkvCgTebqtkQAgYOVI/XrAm9ubeGpUth8mS1Qdu0gXPOCX5PqHxOZiMSbiFNEGgW8aZN/q+trw8sBJxOJWCrqmDAADjpJP/Xavn8ViPSgkCLE+Tmquf+4gThoLIS7r038DVHtCDIzY1+aywr/b7egiApCfbvL+SCC17zCFxqKC8/yBdfvEh5uduelNJJQ4MTyAIEGRn+3R1m50iHCyGsrwERQvmVs7OVhbUljMqV/fvh9dfVgXXmmTBtWvBAdVxc9JIYIiUIbDY49VT1++uv1Tw1BfPnw48/qjm9+urACkGkmAMiHdfRBKv29337LSFRRPhDQwM89xyNsUN/OGIFQUJCInfd5avVRhI2W+RM7/h40Bo87dxZyKxZB/xmufiiAUhm3DgnL7yw3VAIxMZGv0l6QoL1BWxaloumbb7xRmhWgZTwyivKbztkiDqoQolhtG8fWStLIzXLy4uMxqytz5wc5WZzOuH998P/nI8/Vj92O9x6a2AXpdYOMhKIlkUwdKiKE2zZ0rT5BGWBvfyysnyDrYUjUhC0a5fHtGmzGvPmo4VILBJtYQCcdZY6sFeuhI8+Ci9FFHYGDLz5a3sZKdjtkT24xoxR7oxff4XFiwPfs2EDTJ2qgp7JyXDllaF9V1xcZLpkadBSahMTI/e/1K/PMWPcVoFReq4/LFvmjgtcfz0cd1zg6yOxTjIzlVYeDYtAI5288Ub1/N//hhdfVG63UF2Zhw7Bo4+quY2N/T/oGurbdyArVmyPuhCAyAuCzEy1UYRQZnRSUuiusWDppJEg6/KH5GSlOUfSp52YCOPHq9feeAMefBCWL1cbrbhYHf61tUpL/dvfVJZQQgJce23oB5HW2D0SSE6OTsGaNp+gXGAjRijr6e9/D96NS0oVc5k1Sz2/8kqlCQeD1RQdQqiDOBrpvvoMpT594JJL1Dx9/TU8/DBMmqTck/74nGpr4cMP4c47Vbe3zEx44AHo2TPw9x6xWUMtAZEQBFoWgYbBg9UieP11qKiYihCTkDJwBXFMjMMwOKxBn/URaWgUBZHUYLXvGjRIabGffKI02M2b4e233QyZ+jaiY8aoDKFwDqFIuS80kr1oWHT6+QQYO1ZRpq9dC/ffr4rBzjjD1zIqLVVr+H//U89Hjw4t8A7W17loDemjAb3iB2peBg+GJUvghx9U/OWzz5TScu65cPbZSgmoq4OvvoKFC93dCAcNggkTQiu4OyoImgBNAETKIvBelGefrQ7uWbMKXVkYU1D0E3ZUPECg9fhJTs5i3LjnAqZEJiVFr5I4OTmyxHbeG+2SS1TR0rffwnvvqVQ8u11p13v3qmuvu843zTQYNPM+EoiPbzkHV0yM8vE/9phyuy1cqNyYQ4aoTKC0NEWRsGiRymaJj4errnJnxQWDFT0VvBEJy9QfvOcTlKVVWKh+duxQxXZr1sC778IHH6iC2j/+cKeR5uUpgRzMxabHUUEQJmw2VXQVqYPTaGGACnZ26QJffVXI+vWwebPeMpA4HIl+s4O8EWk2TD0inV9vJFjj45XmOnSosgrat1da1N69yixvSoZKWlrk1kg4FBtmw2g+k5KUO23TJqXJfvut0mCXL/e87rjjlHsunKyqSKzVliYI9MjLU/7+DRuUEFizRj0GtW4vugiOPz78tXdUEIQJrVlMpBBoYbRqBRdfDF9/PcXHPeSvc5sRopEtpLmjohWMM4LDofyyGrRc7qYgkqm4VmvIgeBvPoVQfumePZXVtXy5yoApK1Nd3AYOhH79wrdkImFlRXs+Q5mTXr3Uz+HDSnmJiYFjj2362XRUEIQBfSl9JL8z2D+3qd3HNETaIoiJUVpgtINxViJSMRe7PbptREM5uNq0UZqqGbB6rcbERLcHh3dMMBhSU1UsoNnf2/yP+L8Pm00twIyMyPdBDmWj+csI8mbANILNZq1rwXvsQihLJlp04aEI1uYiNjZy7oVoaq8QugZrFqy2XqPpFoLIrE8jHBUEISAtTR1e0eCLCWVhBGLNDAYrKR0cDuVf18x5Lbsl2j5Yqw8uK7VWfRGjwxH9ftJCRE6oa5TkViA2Vu3xaHNtRUsQHHUNBYGeaz0a0NIrA5Xta3GABQumcPDgTrKyOjZSJweDVYdWTIw7qJ6VpeYxKSl6loCGSGw0K7XWVq2UBdfQ0DLaiGo59w6HZ7MfK2BlfCA9PbpJExoibWFpOCoIgiDaFbdahzJ9TrsRQmHNNIJViz8jw/PAtbp5SKg4ki2CtDS3G68lCAFwz2fr1rB7t7XfZZUgiI1tGUIAoicILNWNhBAjhBC/CCG2CiHuMXj/DiHEBiHEGiHEl0KIUMlzLEd6uqdbI1rQV21aASv+vri4lrOxvHGkC4KWBm0u/VElmwmr9mJLUVJAKU//p1xDQgg7MAM4E9gN/CCE+FBKuUF32U/AICllpRDieuBJ4FKrxhQqbDa16aJNyQzuMbRurToWaVkNDQ2KVKqurumfHR9vjb8+mnQVwaAXBHFxqoK4OXPoDYfDGj+2w9Ey2od6Qz+X2dlugsTqavVTVaXWaXNht5vfqEjb5y1JadHWZ3q6SrO129UcHjyoqE+Mur2ZAStdQycAW6WU2wCEEG8BFwCNgkBKuVR3/f+Ayy0cT8iIJGlXMGjjiIlx8+jr4XSqCs2qKnWgVVWp3OJAbiQNVmhCGRnRz7wIBI07PzvbPU6nUzXuqKtTh1ZpqXouhHoeDg2wVYdKS51T/T7p2tX4mtpadYDV1rpJ06RUc1tRodZrMGFhhTXQtm10U2+NoPFg9ejhfi05Wf3k5bkVFz35XEODms+YGPVYE8La3Iayfq0UBO2AXbrnu4ETA1w/AfjU6A0hxCRgEkC7dub0IBBCbVop1eGpn9ho0zHrEUwg2WzuhaJHQ4NaCOXlbiFx+LDn32m2IEhIaJnuCz2E8E2X1ffcBU83nJRK0NbWujeZ9ryiwrfd4v/PgsAfQrGSKitVsVl5uerM5W2lmS0IYmNbnhCA4K5Lmy34WtCfBVKqeQ1mSbSIYLEQ4nJgEHCq0ftSylnALNe1RZ06iR0mfXU2EEKjt6jj6DjNx5Ey1qPjNBf/P4/TbwzWSkGwB+ige97e9ZoHhBDDUaxpp0opgzo0pJSmhaWEECullCbU5VmLo+M0H0fKWI+O01wcHacxrAw//QB0E0J0EkI4gD8DH+ovEEL0B14CRkkp/7BwLEdxFEdxFEfhB5YJAillPXAT8BmwEXhbSrleCPGIEGKU67KngGTgHSHEaiHEh34+7iiO4iiO4igsgqUxAinlJ8AnXq89oHs83MrvDwGzovz9oeLoOM3HkTLWo+M0F0fHaQAhvdMejuIojuIojuL/K7TAEpWjOIqjOIqjiCT+TwsCIYRFxAzmQwgRwVYmTYcQIsr8jKHh6HyaCyFEBEgkmo8jZc+3tPn8PykIhBDJQoh/AJ8KIV4SQvwp2mPyByFEohBiBrBYCHGzK5MKIUSL+t+45vRZYJEQ4lEhxLBoj8kIR+fTXAgh4oUQLwJLXYkep7teb4nz2eL3fEudzxb1zzQDQoh2wBuoDu7nAstQHEYtFXcAWcA4IB6VTouU0hnopkhCCNENeB9oAK4GioDJUR2UfxydT3NxNdAaVez5G/CqECK+hc3nkbTnW+R8/p8TBEA1MFtKeauU8nfgbWC1EOLYKI+rEUKIeNfvGMABzJNSbpJSPgUUuTTFqGsJOlQAs6SUd7lIAz8B9gkh2kd5XMDR+TQbQgg9YYkAvpVSHpRSvgZ8C0xzXddCGLla9p4/EuazpWyMJkMI0V0IMVMIkQAgpTwIfKW7pAPQGfglCsPzgBDiGCHEXGC6EGKQq9YiGRisu+w64AohRPtoaQmuOW3UqKSUe/HkgUoEekgpLWagD4yj82kuhBBdhRBvA68LIc4TQmisNq11l/0FGCOE6CKllNE4vI6UPX+kzCcc4YJACFGAMgknoVwCCCGElLJCd5kD2B4KfYWVcC3al4CfgTXAjUKICcATwHVCiGwAKeUu4E3gmiiN8zzg38BdwtVDQggRI6Us112WSfQ32dH5NBEua+kfwDrUnhoJPAD8CzhXCNEHwCWsPsDlypIRzj8/Uvb8kTKfGo5oQQAcRPncjgHGCyHyDCayP/ArgBDimiiai12ACinlk1LK6cBsYAyQALyIZwHJZhRbazTMxf1AIWpO/yqESJZS1gshbLqx9ALWu8Z3mRDimAiPEY7Op9nIAUqAqVLKD4C/oXqJdEMJ3CnCnZGzGDCL+DFcHCl7/kiZT+AIFwRSyo2ongdbgS+AR8DHF3wGkCWEeA+4DOVPjDiklOuAfCHEKa6X1gBfAnejSPcyhRAPCiEuASYCVa77IqohSClXAptcc7oYmOl6S+jGUgC0EkK8jzrkTGztEvI4j85nM6EXilLKPSgG4DN1z18EprkEbQXwsBBiIsrqOhSJMRqMs8Xuef0YWvJ8GkJK2eJ/UKZzqu658H4MpABbgTO87v0UpW1dFKGxZgNt9OMDbK7HNwNv6t7rB7ziuucY4Ergc6AwGuM0mNNUlFZzvO69ONSh+yNwSQTGmQMM8XqtJc6nzzhb8HxO8HrN7vp9FbBC93o6KvDaD8hAuTfeiuB8TvDzXovZ86i+K08DjpY8n0H/jmgPIISJvh9FWvcW8JDrNZvXNdrE3wZ87Ho81nUInxbBsd4HbALeBR7Xj831uCvwHjDO9TwLRcrXNsJzajROf3N6P7DU9XiE6/foCI51PUqTHuB6rhdYLWI+g42zpcyn67t/BO7w874N+A9wm+61fwF9IjyXAcfpNZ9R2/OoRIR1wPOoJAXvPdQi5jOkvyXaAwgwyUkodtIFQBuUhlcK5Lve99FgXY+LXde9AsRHaKzxwOMoad/KNd5KIFNbELprz0L5LwcAlwBLgY4tYZxe1+rntB4oA54DYiM0Vptrc32KMp1vB5Ja0nyGME5/azQa8/m06zt9vs9rbANR+e2jUa1jfwR6RXA+/Y4zwJgjuudxW6TT/R3quK2WqM5nyH9TtAdgMIHprt8xwGlAjO69l4Gr/dyXhhIca4ChkRyr63GO7vFpwHygt5/FcT3wT9eisHys4Y5T9362a85/ivQ4da89D9zlOjRPaWnzGco4W8J8Aj1RfcFTUErV1cBJXtdrB9wFwMPA10BBSxun7tqI7nmvcdqAtShlqrdrHFehU6pwWy0Rnc8m/W3RHoBu0rJcm+lz4Bagq+49gUoJWwr083O/DTg2SmPt4Xo9BqWhbgf+DnyPMle1BaHXZO0tdZy6+2MitMH047wZ6Ol6vSvwuuvxHSiN+zagvbYuojifIY8zyvN5i26cD6EC0f8FHkRlqlypW5/C6rGZMU7d/RHZ8wb/976u16cBz7pevxZVGDhNt89sVo/NrJ8WkTX0/9o7t1A7zjIMP292DpZWAhKl1lPcktTWNhYRI15IsQepVNHa3hSqloJgiBXaQvVCRA0oCAUhFXshaLxQkd4oHlI8lbZiEUrSIhSspCK09ECqraVJk53Xi29WOobu7uxkzaw1mfeBRWbNYfGsmbXzzfz//32/pA9Sj9bPAruoDpibW7usoX4YL/Mq011ClRCw/XDHqsu57mgcjgIPAYu2b6XuAm5p/HErocn20rx6thyP2n6gZ8+3tjwfA56XtACcD3wJ2O4m8crNX1uz3Pf5PGnPluMszudbqCcmqKeVbwCX2/46NXHUjpaf6YnT8ZzQx9/8Mtf9pmbzpEny57bvAm4HzqVJGPMcleFYibmYvJ4aSXGH7Z/C8cqRlzWZeEdsL0labJafURWUqjuxegAABOxJREFUWj/Zf05cXwcctn18wmnbv5J0G/Ujfzyeq/JcR42vv5h69P8H1X5sSVts/z2eJ+15eXPd/2P7m5Mdbf9S0i3Uf259j2MfsucVzbZ7qSz29zWejzSJjIMJABN6DwRNFuD/3XnYflTSv1rbjlBNQ+3MwMuAsyTtoe66bp8z10PtYyRdQN1B/BN4Ip6r9jwC7Jd0P3Cf7XskvZOa+7rTceFnoOe7Jte9deyF1HV/nPm57kPxXGy2PSZpN/BlVT2rReqp+kCXnl3Qa9OQpHXtE31CosiLrW2bqburNpuAi6hxudtt/2lOXTdIuoEa7fQH25+z/XI8T83T9ldt39MsH7D9LVfZiHiegqektZI+RQ3H/r3tG5tgFs9Tu+77qGar+4Ff2L7alTw2KHoLBJJ2Ar9T1eD+OFSbZDsbr7W8CDzYrLtG0kaqbO9m253P5Xk6rlQBsb1UG/Gd8Tzta39ul25j86RG2twLfGCer/tQPCWdZ/ug7btt/6BLzy7pPBBIeoOqOeejwFeoTpfPNo/PxztUJG3zK50rFwJbJf0GuI7qD3jU9ksDcF2w/XSXriPy/DQ9tLeOyPNaaiTLwRObYOJ5ytf9aFd+veLuh14tUJUCJ2O+F4Ef0oxdp3rZ9wD3AecBbweep8rK9pbBOiTXeMYznuPx7OVcdHBy11KJNW9rrTuntbyGShjZ0ry/Athxwmfc2NMPYRCu8YxnPMfjOYvXtE/0xdT49KeAnyyzzwXAr5fZtn6aPmeCazzjGc/xeM7qNe0+gmepVP93UyWCrwSQtNDqhX8zNUcrkrarmbRbktzhqJUBu8YznvEcj+dMmGogsP0k8DPbz1FtbZNZd5aoMhEA7wXWS/oOlZ49Oba3rMYhucYznvEcj+esmPqoIb8yCmUPcEjSzc36Y03k/TDwEeCg7Q/Z/uO0HU6WobjGM57xHI/nTOiy3YkalvVgs7yt+fcTtDpr5uU1FNd4xjOe4/Hs7Xz0cMJ/CxymKvNtmvUXPhNc4xnPeI7Hs49XZwllqsm5d1E98Tttf8ytQmfzxFBc4zld4jld4jlcJokU3Xy4dBVVx+bwijvPmKG4xnO6xHO6xHOYdBoIQgghzD9zMTFNCCGE2ZFAEEIIIyeBIIQQRk4CQQghjJwEghBCGDkJBCGsgKQlSfsk/U3Sfkm3qjV71TLHbJZ0fV+OIZwOCQQhrMxLti+x/R6qRv1VwNdWOGYzkEAQBkHyCEJYAUn/tX1O6/0i8FdgE/AO4MfA2c3mnbb/LOkvVObqAeBHVAnkbwOXAhuAO23f1duXCOE1SCAIYQVODATNun8D5wMvAMdsH5K0hZr05P2SLgVus311s//ngTfZ3iVpA/AAcJ3tA71+mRBehbWzFghh4KwDdku6BFgCti6z35XANknXNu83AluoJ4YQZkoCQQirpGkaWgKepvoKnqImNVkDHFruMOCLtvf2IhnCKkhncQirQNIbge8Du13tqhuBJ20fA24AFppdXwBe3zp0L/AFSeuaz9kq6WxCmAPyRBDCypwlaR/VDHSU6hy+o9n2PeBuSZ+h6tu/2Kx/GFiStJ+aGvG71Eiih5rZsJ4BPtnXFwjhtUhncQghjJw0DYUQwshJIAghhJGTQBBCCCMngSCEEEZOAkEIIYycBIIQQhg5CQQhhDByEghCCGHk/A/AV+BfG3LGQgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 2194, {'val_loss': '-0.8957019448280334', 'val/kl': '0.002843243535608053', 'val/mse': '0.010960877873003483', 'val/std': '0.12809321284294128'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=234.0, style=Pr…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 4389, {'val_loss': '-1.1492339372634888', 'val/kl': '0.0010864834766834974', 'val/mse': '0.009058449417352676', 'val/std': '0.08994901180267334'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='Validating', layout=Layout(flex='2'), max=234.0, style=Pr…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "step 6584, {'val_loss': '-1.084285020828247', 'val/kl': '0.00045751998550258577', 'val/mse': '0.01010067667812109', 'val/std': '0.07211266458034515'}\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mLatentModelPL\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrial\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 33\u001b[0;31m \u001b[0mtrainer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# plot, main metric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 700\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 701\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 702\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msingle_gpu_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 703\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 704\u001b[0m \u001b[0;31m# ON CPU\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/distrib_parts.py\u001b[0m in \u001b[0;36msingle_gpu_train\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptimizers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 441\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_pretrain_routine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 442\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 443\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdp_train\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/trainer.py\u001b[0m in \u001b[0;36mrun_pretrain_routine\u001b[0;34m(self, model)\u001b[0m\n\u001b[1;32m 839\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 840\u001b[0m \u001b[0;31m# CORE TRAINING LOOP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 841\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 842\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 843\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/training_loop.py\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[0;31m# RUN TNG EPOCH\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 332\u001b[0m \u001b[0;31m# -----------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 333\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_training_epoch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 334\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 335\u001b[0m \u001b[0;31m# update LR schedulers\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/training_loop.py\u001b[0m in \u001b[0;36mrun_training_epoch\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 386\u001b[0m \u001b[0;31m# RUN TRAIN STEP\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 387\u001b[0m \u001b[0;31m# ---------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 388\u001b[0;31m \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_training_batch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 389\u001b[0m \u001b[0mbatch_result\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_norm_dic\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_step_metrics\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moutput\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 390\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/training_loop.py\u001b[0m in \u001b[0;36mrun_training_batch\u001b[0;34m(self, batch, batch_idx)\u001b[0m\n\u001b[1;32m 510\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 511\u001b[0m \u001b[0;31m# calculate loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 512\u001b[0;31m \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0moptimizer_closure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 513\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 514\u001b[0m \u001b[0;31m# nan grads\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/trainer/training_loop.py\u001b[0m in \u001b[0;36moptimizer_closure\u001b[0;34m()\u001b[0m\n\u001b[1;32m 492\u001b[0m \u001b[0;31m# backward pass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 493\u001b[0m \u001b[0mmodel_ref\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 494\u001b[0;31m \u001b[0mmodel_ref\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muse_amp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclosure_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopt_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 495\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0;31m# track metrics for callbacks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/media/wassname/Storage5/projects2/3ST/pytorch-lightning/pytorch_lightning/core/hooks.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, use_amp, loss, optimizer, optimizer_idx)\u001b[0m\n\u001b[1;32m 153\u001b[0m \u001b[0mscaled_loss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 155\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \"\"\"\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.pyenv/versions/jup3.7.3/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m 97\u001b[0m Variable._execution_engine.run_backward(\n\u001b[1;32m 98\u001b[0m \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m allow_unreachable=True) # allow_unreachable flag\n\u001b[0m\u001b[1;32m 100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "name = 'anp-rnn-mcdropout'\n", + "\n", + "params =default_params.copy()\n", + "params.update({\n", + " 'det_enc_cross_attn_type': 'ptmultihead',\n", + " 'det_enc_self_attn_type': 'uniform',\n", + " 'latent_enc_self_attn_type': 'uniform',\n", + " 'dropout': 0.2,\n", + " 'hidden_dim': 128*2,\n", + " 'latent_dim': 128*2,\n", + " 'attention_dropout': 0.2,\n", + " 'use_deterministic_path': False,\n", + " 'use_rnn': True\n", + "})\n", + "trial = optuna.trial.FixedTrial(params)\n", + "trial = add_sugg(trial)\n", + "trial.number = 3\n", + "\n", + "checkpoint_callback = pl.callbacks.ModelCheckpoint(\n", + " os.path.join(MODEL_DIR, name, 'version_{}'.format(trial.number), \"chk\"), monitor='val_loss', mode=\"min\")\n", + "\n", + "logger = DictLogger(MODEL_DIR, name=\"anp\", version=trial.number)\n", + "\n", + "trainer = pl.Trainer(\n", + " gradient_clip_val=trial.params[\"grad_clip\"],\n", + " checkpoint_callback=checkpoint_callback,\n", + " max_epochs=trial.params['max_nb_epochs'],\n", + " gpus=-1 if torch.cuda.is_available() else None,\n", + " early_stop_callback=True\n", + ")\n", + "model = LatentModelPL(trial.params)\n", + "\n", + "trainer.fit(model)\n", + "\n", + "# plot, main metric\n", + "loader = model.val_dataloader()[0]\n", + "vis_i=670\n", + "plot_from_loader(loader, model, i=vis_i)\n", + "\n", + "print(trainer.test(model))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-15T07:01:21.281138Z", + "start_time": "2020-02-15T07:01:20.834255Z" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-15T09:29:14.568668Z", + "start_time": "2020-02-15T09:29:14.505166Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "# # plot lots of metrics\n", + "# loader = model.val_dataloader()[0]\n", + "# for i in range(0, len(loader), 10):\n", + "# plot_from_loader(loader, model, i=i)\n", + "# plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-15T07:00:04.268233Z", + "start_time": "2020-02-15T06:57:58.700Z" + }, + "scrolled": true + }, + "source": [ + "# MCDropout test\n", + "\n", + "https://towardsdatascience.com/bayesian-deep-learning-with-fastai-how-not-to-be-uncertain-about-your-uncertainty-6a99d1aa686e\n", + "\n", + "We will apply mcdropout by:\n", + "- replacing dropout with a class that will still be on during test\n", + "- doing multiple inference" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:04:40.304317Z", + "start_time": "2020-02-16T08:04:40.252530Z" + } + }, + "outputs": [], + "source": [ + "from typing import Callable\n", + "\n", + "def convert_layers(model:nn.Module, original:nn.Module, value: bool):\n", + " \"\"\"\n", + " Turn dropout on\n", + " \"\"\"\n", + " for child_name, child in model.named_children():\n", + " if isinstance(child, original):\n", + "# print(child, 'from', child.training, 'to', value)\n", + " child.train(value)\n", + " \n", + " else:\n", + " convert_layers(child, original, value)" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:09:11.284347Z", + "start_time": "2020-02-16T08:09:11.231084Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "LSTM(17, 256, num_layers=2, batch_first=True, dropout=0.2)" + ] + }, + "execution_count": 171, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 199, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:12:10.678207Z", + "start_time": "2020-02-16T08:12:10.593955Z" + } + }, + "outputs": [], + "source": [ + "from src.plot import plot_rows\n", + "loader = model.val_dataloader()[0]\n", + "device = next(model.parameters()).device\n", + "\n", + "# Get data\n", + "i = 670\n", + "data = loader.collate_fn([loader.dataset[i]], sample=False)\n", + "data = [d.to(device) for d in data]\n", + "context_x, context_y, target_x_extra, target_y_extra = data\n", + "target_x = target_x_extra\n", + "target_y = target_y_extra\n", + "\n", + "# for plotting\n", + "x_rows, y_rows = loader.dataset.get_rows(i)\n", + "max_num_context = context_x.shape[1]\n", + "y_context_rows = y_rows[:max_num_context]\n", + "y_target_extra_rows = y_rows[max_num_context:]\n", + "dt = y_target_extra_rows.index[0]\n", + "y_target_rows = y_rows" + ] + }, + { + "cell_type": "code", + "execution_count": 200, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:12:11.095623Z", + "start_time": "2020-02-16T08:12:10.841864Z" + } + }, + "outputs": [], + "source": [ + "# do MCDropout estimation\n", + "model.eval()\n", + "convert_layers(model, torch.nn.modules.dropout.Dropout2d, True)\n", + "model.model._lstm.train()\n", + "\n", + "y_preds = []\n", + "y_stds = []\n", + "with torch.no_grad():\n", + " for i in range(10):\n", + " y_pred, kl, loss_test, loss_mse, y_std = model(context_x, context_y, target_x, target_y)\n", + " y_preds.append(y_pred.cpu().numpy())\n", + " y_stds.append(y_std.cpu().numpy())\n", + "\n", + "y_stds = np.stack(y_stds)\n", + "y_preds = np.stack(y_preds)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:12:29.839499Z", + "start_time": "2020-02-16T08:12:29.783715Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted std 0.08 \n", + "std of std 0.01 \n", + "mcdropout of mean 0.04\n" + ] + } + ], + "source": [ + "# Lets add variation to std, since it it's unsure.. std should be higher. Although this is small\n", + "# When it's unsure of the mean, we will also add that, this is large\n", + "# This is just a quick and dirty uncalibrated one sure, we could use\n", + "y_std = y_stds.mean(0) + y_stds.std(0) + y_preds.std(0)\n", + "y_std = y_preds.std(0)\n", + "print(f'predicted std {y_stds.mean():2.2f} \\nstd of std {y_stds.std(0).mean():2.2f} \\nmcdropout of mean {y_preds.std(0).mean():2.2f}')\n", + "y_pred = y_preds.mean(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:12:11.518700Z", + "start_time": "2020-02-16T08:12:11.157247Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd3hUxd7HP5PeSEISCIQAoUpHEBUxKmIvV7Eigl2wgnoVG+rFgl6wXQsWsLyoqIgVsYs1CkoTpQiGEloIaaS3zc77x+Tsnt09Z1uymwXyfZ48SU6dnZ2Z7/y6kFLShja0oQ1tOHQR1toNaEMb2tCGNrQu2oigDW1oQxsOcbQRQRva0IY2HOJoI4I2tKENbTjE0UYEbWhDG9pwiKONCNrQhja04RBHRGs3wFekpaXJrKys1m4GVitYLI7HamtdjxkhNhbCw12PR0aCEC3TvlCEUZ/pUV+vfnyBEBAfr/o+MtK4X/WIivLt+QcLGhvVjzMaGqCuzvy+yEiIjnY9frD1o7fjzlN/6REXB2EGW+3W6rtVq1YVSSk7GJ074IggKyuLlStXtnYzKC+HkhLHY+vXQ0WF53uTkqB/f9fj6emKJA5WlJVBaan5+R07YM8e3587cKDq+379IDnZ/DohoHt3359/MKC0VPW/M3btUj9miI+HwYMdj4WFQbduLdu+1oSUkJfn3bXbtkFBgXfXZmVBp06ux1NSIDHR6+a1GIQQpp+yTTXkJxoaXI95u6soKzOelFZr89oU6vAkLRn1qTfYurV59x8KMBtbnsZsdbX3zzrQoH12b6R4DbW13l+7f7/x8dJS3yXfQKONCPxEc4gA1O7XGUai+8EET5/P34W8pkb99iSyH8pB9P4SgZTG38vBMFarqtTvQBGB9nxnSAnFxd4/JxhoIwI/4Tw5Ghp8W2iqqlyvP1h2WmbwtHhoC7q/aJMIzOEvEYBxvx4MY1VbqL0dN1ar9/YB7blmYz7UxmobEfgBq9X1C/ZH1HO+52DYZbmDu51XXZ1vk8wI3kyuQ1UqMBpb9fXGqh+j67x53oEEKdV4rK/3XiLwRRrQYLa5sVpDayy2EYEfMBo4LUEEB8MuywxSul88Kiub/45Q07uGEozGlrOzgxkORtWQ1n5vPf20a32Fu3tCqQ8DSgRCiNOFEJuEELlCiLsNzncXQiwVQvwphPhBCJEZyPa0FJprHzC7J5QGRkvD02fzxtvKE9okAnMYEYG3euqDUSLwhwj82axoRFBXV8vff/9l2IZQQMCIQAgRDswBzgAGAOOFEAOcLnsCeENKOQR4CHgsUO1pSRgtOP6oNZzvOZglgmAQQZtEYAwpXcdWXZ33fd4mESgVT36+7+/RiGDy5LGcccYQVq9eZjvni5E60AikRHAUkCul3CqlrAfeBc51umYA8F3T398bnA9JGE0Mf8TGNonAfs7Mw8IXmHm4OF9zqKE5aiE4uCUCq9W7DdjWrf6NHW1d2LFD+Thv3LjWpQ2hgEAGlHUBdur+3wUc7XTNWuB84BngPKCdECJVShlizlWOaCmJ4FCyEbjb/bQECWhoaFDRsG2ww2hc+dLnB7NE4A1KS/2XWDVj8fffb25WGwKN1jYW3wGcIIRYA5wA7AZcukcIMVkIsVIIsbKwsDDYbXRBoCQCIxH+YIE7ImgJtZCGNonAFUZjyhc12sEsEXiD5vj8Nzaaj8lQ6sNAEsFuoKvu/8ymYzZIKfdIKc+XUg4Dpjcdc4nHk1LOlVKOkFKO6NDBMFVG0GAUL2Cx+PelGk2wQ5EI/CFRM7TZCVxhlmPIWxyMRODtPJPSfVoUT9i/v4BZs+5l06Z1Tc+zLx6h1IeBJIIVQB8hRA8hRBRwCbBYf4EQIk0IobXhHuC1ALanRdBS0gCoCeZMKgfrQuZu4Wlu/IAe3kTKHmowWvR8IQLN516PUFrEzPDUU09x7rnnsnz5cpdz3ra/rKx5n3X16k959dXHuPfeyYwe3ZvjjuthO3dIGIullBbgZuArYCPwnpRyvRDiISHEOU2XjQY2CSE2A+nAzEC1p6XQUvYBDc4LV0vujkMFRguJHi1JBKEWsRkKcCYCT1lgjXAg2glWrFjB4sWL2bJli8s5b9ve3FQQGRmHccEFU7nqqlvYtWs7e/bsoK5pwIdS/wU0+6iU8nPgc6djD+j+fh94P5BtaGkY7Tibs3jX1zum+T0YicBiMd+JSxlcIjgUJQLnBccfsqyvd82M29joOe13a6GmpoapU6dy8cUXc+SRR7qc92YRbq5aCKBfv+MYMeI4Bg2CgQOHk56eQXTThNeii0Mh9XxrG4sPOARaIqivP/jsBM67T72E0JIkAAevaq05cB5PLRH8CKG1o9UjLy+Pjh078uabbzJ27FgyMx3jVI2cMrZs2cQ//2xwOFZc3DLqm8pKtcHr0aMPcXHxDudCpQ/biMBHtKSNAIwnWEsvjq0NowR9mvtiS0tAFRXuvZAORYnAedHzRyI4kFRDX375JZWVlZSVlSEMttvO7S4tLebSS09k/PgT2bbtH0BFAu/b1/y2bNr0CyUluyksNB54odKHbUTgA8xUHC0pEcDBpx4yIgItXD8QpLdly8EnVTUHLaUa8vTcUMF1113Hli1buPbaa3n99df5/HMH7bQhEQwadATduvWkpKSQCy88ljvvvI7y8ua1o6pqPzNmZPPvf/elqAh+/vkbbr11Iu+//3+2a0LFYNxGBD7AaDI0V8dtdO/BTgQWS+AkAu2ZZpXO2iSCg18iAOjZsyeVlZVcffXVzJkzx+Gcc7t79uzLq69+yqJFOXTs2Jk1a5bz889fUlfnRWpWN6iuLqN376Pp2fNI6uoEubnb+OSTBfz++0+mbWktHHClKlsTLZVsTg+jhfBg03M773rq6wMrEQDN3s0dLDDy2PJnfBmlqw6VRUyPuro6mzG2V69eXH755QwfPtzhGjNpMTw8nK5dezBv3mISEk7Aao1rVls6dOjOww/bXVeHDh3D44+/Tv/+Q23HQqUP24jAB7S0oRiM85VLGTreBM2F0UKk5YGvrw+c9KNPoaAZB8PDDz2JoK6uZSSCmhpXL6FQWcQ0SCkZNGgQPXr0YMGCBQwYMID58+e7XKf//EuWvEf//kPp1esw27ExY85ixYqWb196em+GD+/tcCxUpP821ZAPCIREYKZaOlh03EZ9ph2rqgqcRNDYaJ9kVVUHn5TlLYwWGn9jLZzzE4UaEaxdu5bc3FzWr19Pamqq4TVWq10alVJy993XcPLJ/dizx54Wzd9MAa7vcpzEZhvJUBibbUTgAwIhEYDxZD0UiGD//sAuJtrCVV4eGpOtNWAkcfpLBM7eWKFGBIMGDWLPnj0sW7aMsDC1tO3fv5+tW7faUjtUVOhTUNdw3HGncswxJ5KRYc+G89133/DCC1fw009vNKs9Tz55Ljfe2IUNG34EFMEsXbqEBQteorLS3pktmWvLX7SphrxEY2Pzk3eZoaYGkpJc33cwZNE06h9tIfIlFbI/qKqC1FSVJkDry0NJNWS1Gve/v2PWuTBLqG1WIiIi6Ny5s8Oxrl272lxJExISKSuzn4uNjePFFz9wec62bVv4+ec3iIqK4fjjL/e7PYWF2ykt3UN8fDKg+v2xx6axZcvfHHnkcfTtOxBQ/dq+PYS14ra8jQi8hNkuqqWIwBmhNsn8hTsiCHQ6iMpKtfBXVEBiYmDfFYqoq3MlPqOkid7CqEKX1dq6C5gndO/enaqqKiorK5Ey0at5NWTIiVx//etkZg5s1rsfe2wNJSW7aN8+A1B9f9pp51NSUkhsrN0QLaVaA+LjzZ4UeLQRgZdoIwL/YNQ/wfKdrq5Wi5fVav/+DiWJoCXtA9q9dXWOKVFCqT/ff/99vvnmGy688EJOOeUUAP78cx1hYaqdu3Y5Xl9VVUlUVDSRTqJ3evphnHDCYTQX4eERdOiQZfvfYoFp04zTqbV2jqwQ5vLQQiCJ4GA1Fjc2GuuRg6Wvt1igqCi47wwlmNln1q//nvvvH0l+vmuxFE8IZfXQzz//zNy5c1m/fj2gFv/8fDUGKytdx+JTT91Pv34xvPnmCw7HA+XA4E4aa+3AsjYi8BJGk0q/02wO6upcB2moGeL8gZk0EMxdpFbH6FCUCIzGUG2tMmLm5v7GokUPuF7gAc7SaygRwfjx43nhhRcYM2YMoNra0AD79hnHlVRWliOlpH17Rw+jioo6Vqz4mF9/fdfvtmzbtpr//e9iPvvsKYfjNTUWCgsLKCkpcjjeRgQHCNx5vwDk5CxgypQsxo8PY8qULHJyFvj0fGcxPpQmmL8w6jNvB3xFRcv0gfaMQ1EiMCKCigq4//4fufXW9xk//r8+P9P5Ow2lcTpy5EhuuOEGhgwZAijV4MsvP86JJw7mvffecrl+1qxX+fvvWk45ZaztmJRQVVXHU0+dx7x5k/xuS0HBFn77bRGbN//icPz//u9ZjjqqE88//4jD8dYmgjYbgRcwy6eviZA5OQuYN28y9fUq/LKoKI958yYDkJ09wat3OBuLQmmC+Qt/PVY2bID//hcyMuDee1vG0Ku991CXCMrLoUePYfToMcyvZxplkg1V1NTA/v3FbNq0jvz8nYbXREVFOfxfXw8xMe0YMWIs8fHtsVqtNldUX9Cnz0imTn2XpKR0h+PJyemkpKQREeFol2htDYCQofxNGmDEiBFy5cqVQX1nTQ0UFLgeLyxUCc6mTMmiqCjP5XxaWneee267V+/o1k0tfBpiYyE93fz6AwF79rgu/CUlsNmNarq8HO6+254HvksXuO8+SE5ufntGjFB92q5d858V6mhshJ1Oa19tLfzxh/4aC/X1NcTGet8hiYkwYID9/7Q0SEhoZmNbCEuWLCE8PJzRo0cjRCx798Lu3TsoKyslI6MryckpHp9RXq42IoFCr15gVm03MxMiArg1F0KsklKOMDrXphryAmYBH9oiV1S0w/B8UdEOlizxju0PxFKA7iClZ3WaEV55RZFAnz5qYuzeDc8+2zISklFp0IMVZtKAxdLA4sWzmDnzFCZNSuGjjx5xvdANnIk9lCTXa6+9ljPPPJN9+0p1G4luDBgw1IUEduzYynnnjWTGjKkOx301FBcU+JYmwp0KqDXVQ22qIQ9obDR27wT7pEhL62YoEUA3FiyA33+HqVPV7skMoax79Qc1NcaLrjsisFhgxQqVY+mWW1Rem7vvho0b4eOP4fzzm9em1nbRCyaMFpXycigr28s779xtO1ZQ4FrG0ZfnhtI4PfXUU8nPL6C2NsUj4e/YsZU//viN6OgY27H6eti7V/1ttTZSVbWf6Oh4oqJiDJ+xezfcdZfa4T/wgAoK07Bhw4+UlOzisMOy6dChu+24p/HfWgioRCCEOF0IsUkIkSuEuNvgfDchxPdCiDVCiD+FEGcGsj3+QAtKMoJGBOPGzSQqyjFToRCxnHnmTFJS4J9/YM4c97vRg40IjLJVgvuJoO3i2rdXEcHJyXDjjerYBx/Azz83r01tEgGEh0dy5pn/5swz/83zz+/kttt8qxTr7PUVSv35xhtvsHDhVw6Le37+Lp588n5effVph2sPP/xoFi3K4c47HwOUJLBunT0tyZNPjmXy5DT+/PNr0/fl5Kh+3rsXZs509Ez69tsXmTNnoouxuKqqjgsuGMXppw9xed5BSQRCiHBgDnAGMAAYL4QY4HTZfaii9sOAS4AXCCE0NrrPA6IRQXb2BCZNmktamsb83enS5S4uu2wCjz2mjMB//60GGhh7GIXyTstXSNl8ItAwZIiSBKxWeOEFeOcd/yfMoeQ55EwEWrbX5OROXHbZk1x22ZOkptpLOG7YoHa1P/7o+dn6fgy1ceqsptm/v4Tnn3+ERYtecziekNCOESOOZfjwYwDXfFQJCanExydjsRjriqSEX39VfyclKeng0UftcRaHHZbNMcdcQqdOfZzujGLdutVs2vQXNTWOk0Qb160huQZSNXQUkCul3AoghHgXOBfQm2IkoPmEJAEm5USCj7o65X/sTlev1ydmZ08gO3sCN930BiUlD7Br14NMmfI648bN5OyzJ7BwISxaBPv3L+CVV1w9jCIjYdAgRw+jUC4O7g61teYLhLtBruUeSnGy6V10kZps8+fD4sWwdi3cdBN07er6DHdoTnqFAw3eViWzWht58MF32Lz5EiCCbdugZ0/3fWux2KOLQ4UIGhoaqK1toK4u1qE8ZefOmdx66wwyMrq5vd9543L99a8blrnUsGWLWh+Sk5U08PDDkJcHs2bB9Olw2mk3c9ppN7vcZ7EI3n33RxITk4iKinY6p36XlblXIwcCgVQNdQH0fgu7mo7pMQOYKITYBXwOTDF6kBBishBipRBiZaEWIdQMeDLuSOmZBOrrXXemCxY8SEnJDUAeIG2LfFLSAhITlYrorbem20jA/qxq3npruss7QmWS+QozaQDc971GBHqJQMOpp6oJ1rGjfcL5msv9UJIInMemRgTFxTspKNhCfb3qvMrKcBsJpKfXYrHAiy+6l7r0pBIqY/TXX38lMTGeSy8d43A8OTmFW275DxdddJXtmJSSadOu4r33XqOuaTfnPGbdkYB6n/o9ciTs3fsjqalXEhe3n9xc+Owz8/ssFhg27Gh69epHuNMuT6vT4W7+BAqt7TU0Hvg/KWUmcCbwphDCpU1SyrlSyhFSyhEdzHyvvERFhdLpGSXQ0mAUju4Mo0VoyZJZgOsi/+GH0xk9Wv1fXm7sYVRcvMNlUoXKJPMVZp4XFovvqiE9BgxQBNCjBxQXw4cf+tauNokAPvzwYW69tTc//vh/gFJpQAQZGRU8+KAkLQ22bVOSlxn032Go9Gd1dTXR0dHEx3t2hf3zz5W8//7/MWvWXbYF38whxAhWKyxbpv4+9liort7P+vXz6dJF2Rs++wzy8vZSW1uFs3u+u82IxaKkgdbo00ASwW5AL2BmNh3T4xrgPQAp5TIgBgiIUGS1qoWmuFj9X1ysFvziYsdFXUocUtWawXjgGI+m4uId9GlSFUZGGouoqandDhqDsdli72myaUTgrBrSIyYGrrlGeRZ9/rmrr7w7tHb0ZjDhTATaZ4+NTSQtrTupqWpqarWde/VqR1JSLNddp/7/8EPYvt342aEoEZxxxhnk5tby0kuuu4PCwr18++2nbN+eC0CfPgOYPfs1brvtIaKiomhocF2gN278iRkzjuOtt+5wed7GjaqWRseOEBn5F717H82///0RkyZdzuGHq3F+zz3vctVVCVgsjg+WEr7+egn//e9drFmz3OXZVVUHHxGsAPoIIXoIIaJQxmDnfcYO4CQAIUR/FBE0X/fjBCnVzke/wEupEpJVVKjfWucrX2vPzzQS3yIju7seRC3yPXtq/7l6GEVFxTFu3EyXBfRAjCVwl0vIkyrHzEbgjF69YMwY1T/ffut927QSoAc7pDSXCCZOfILnntvO8OFnAXYi0IIZBw1SarjGRnMVUSgSgaaqjTCIyJoz51EmTTqHL75QHlJxcfFcdNFVTJx4A2C8Qamvr2HTphzy8ta6nNOkgcMP38899xzOU0+dx/DhZ9O160DGjVPnpLyBuLi+REZGu9z/7bdf8/LLs/njj99MP0+wx2nAiEBKaQFuBr4CNqK8g9YLIR4SQpzTdNntwCQhxFrgHeBKGYBQZ63eqhksFrUbLSmx70q9eaYzYmNnAsaLfEqKMiw1NEzguOOmkZraFSEEaWndmTRpLtnZEw4KzyF3JOqJCDyphvQYOVL93uKDG/yhQAJgPNbNpDSNCAoLv+T112/GarUyfrzyjd+xw+7pZvasUOlT5zKaeowYkc2oUWPo1CnT8LzRpq5Xr6O4//4fuPpqR0dGiwV+a1q/u3XbQLt2aXTs2IvwcEVAWVkwfDhANOecs8nwfQMHns20aY8yfPgo0zYHu18DGlAmpfwcZQTWH3tA9/cG4NhAtgHcDxINRtkJ3cF5UWtshKoq5fWTmjqdkpIdpKZ2Y9y4mbZ8Q716wapVsHTpZmAnQghuvnkBhx2muuBgUA25swG4Uw1J6d5Y7AxNwsrL03aC3rUvVBauQMIfIli58r+Ul//I6affQufOfTjuOKUeWrkSDj/c/FmhMkafeGI2P/30Ldde+29OOOF0h3Nnn30xZ599MQAPPXQrKSkdmDDheiCV9u2NiSAhoT0DBpzgcvzPP5VKOTMTTjppFMcfv4OamnJ+++198vM3M2bMJE45pQOrV8PSpfCvf7kW7jnssFMZOPBUt6lOgl3wp7WNxQGHVv2nJaFZ9/X455/dTRNwNM8/v52337by3HPbHZLOaYuXEEc1tU1SUmI3mxwMROCvRFBdrSX8grg48+s0xMUpdYbFonau3uBA7E9/YPQdWCywf/9errsunUceOQlQ/V1YqBacs846j8sue4q4OFUzdURTRppVq1z7zVkiaG1yVcFgf5CT8w2lpcWm15WVlfLmm3N4+ukHaGxsZPt2pRr2ZX1Y3qTWH9W0mY+MjCYxsQOffvo4CxdOJz9/M0OGKPtBYaFjbic99u1z/56DSiIIBdTUtPwCYDRwduzQxI5/gC48/fQFrF//PZdeOpsxY64F7ERw2GG3ctppmURFxdCv3/G2ZxwM+YbcSQTeuI56sg/o0bOn2tFu2YLOBmOO1l6wggWjHW5DA5SW5lNevo/ycmWGKyhQfZKeDuecc4vD9VlZKrq7uBi2boXevR2fpYfV2rrxLtXVMHXqfzj//Cvo12+w6XWVlRX897+vsG9fPqmpHcnNhdxc883LF188Q3l5IRdc8B8iIiKxWmHNGnUuOTkHi+VoWxbRUaPGM2DAaBITO7Jhw1IaGtYDU/nuO01VZEddXTUrVvzJ/v1WjjjCWD100NgIQgWB8Mk1IgKLJQuAgQOVwXjTpl+pqipl3rxJtujhwsIFQBZ//x3GggV3UF1dRlycPcey8wQ7EBcus0lVV+eekDX7gC9ZRnv1Ur+3bvXu+lDYvQYaVqs5EXTvPoQ5c3Zz222qYLuzoVgPIeCII9Tfq1a5PkuP1uxTKZWqplevwzjhhNNITzf4MMCjj04jO7s7xcWF3HDD3TaJ3qgolIaPPnqEjz+eSWWlkjJyc9W7OnRoZO7c47jjjv4299Azz7yVSy+dRefOfSgu3kVp6VO2e5xRULCFe+45hrvvvtbt5womDgmJIBjPLClRec0HDepBTs4CqqpKbOeKivJ46aWrmnyW623HnGsWhNIE8xdmEkFLeQzpoUkB3hqMQ7E/Wzp63Mj90GrVdM7hpKTYF8rdTVrJjAylpty2bTU7dvzJCSdciRCCESPg668VEWjeMBoaGkAr9duaKjdvYn4AevY8jHbtkqitVZPXm+DCM864FSmtREQozx9NzXPYYWVERPQlPr69YeDZEUf8iwcf7M8jj1gpKwujutpR3Zmc3ImePUfQr19f03e3EUELor4+MOoVI+OzVq8gPR3efnu6i/9wY6PrCllfX838+VNtRHCgew01NpoP4ObGEOTkLGDhwukUFe0gLU0Z4Y86agLh4aooeW2tsi+4g9UaWmRgtargxs6dW84waBQoaUbO+fnqtyYRPPbYqVRWljB48Mmkpnalf3/Vrl271FzS13AJBSLQx/zMm/ck0dExjBt3LdHRri6bF1xwBRdffLWtyIw36abPO88x2l8jgmOPTeGmmzbR2GifsA0NdRQV5dHYaCEzcwB9+x5FRoZyZtizx1G1lpjYgZkzV9C/v/vPFkwc1KohX1MQeAsjIti+XWWn+/XXh03rExihstIuORzoEoG/9gFw7zGkVYBTqb7tqTt+/30BmZmqn3xxIw0VlJSoPvPGq80bNDYaL3Da97J06TxeffVGcnN/B9QCD4qIhBAceeT5jBo1noYG9ZCICGX01FKuGD0TWo8IqqrU5qmxsZFZs+7iP/+52TQ1RGRkpEOlMV/TjZSWqojrqCh7YR7NZRRg06Yc/v3vw3j11Rtsxzp3Vr81wnWGOzIKdp8e1BJBoNRCzlKGilpWu5BNm+a7qU/gioQEe+HsA50I3HkMufsuamvtulQjIli40Dg/08KF0xk5cgJ5eSrIZ+BAz21sTSmrrEwlzwO1iGm794qKlqmaZra4ad/L2rVfsGLFRwwceCIdOx5FXp5a7LOy1PnJk+e53Nupk5Ja8vOVy6TRu1prnGoLaUNDPVOnPkBR0T6X0pNm8IYIysuLKCzcRlJSOt98YwF60rdvbRMBOC6dqald6dixJykpXfjll3coKNhCQsJ1QAebLcYZtbUSq1UalsJskwhaCFIGRiIwEr3374fGxijCw8s49tizDOsTGCOOK654xvafpsvVcKARgT8SQWUlPPKISmeQkAD9+rleYyZhFRfv4Pgmp6vly72b3K3Vp1KqcVJcrIy5RUX2c/X1LbNpMet/7fhpp03hiiuepWfPEaxdq9o0YIB7lVqnTuq3865Wv5ttLXLVPldMTCxTpz7AQw897/W93oyVL798hvvuO4rvv3+db79VBBMV9SkTJ0bywAPHYNV98M6d+/LMM1uYMuVtfv31HRYtup+oKDVujSSCp5++gJNOimb58h8M391GBC2EurrAdKYREWj2gZ49k7jiimds9QliY91VXQ8H5jJsmGPq6VCM2vQW5qmOzcXg775Tap0OHWDGDPuOWY+0NOP8TEKEkZe3gB491A7b2bvFCK3lkquNx4oKpWZx/m4LCpTfeXMWVU9EMHDgiZx++hQ6duxh03c7B4tZLPXs2PGX7X9NvaFV7tIQCjUJmpM7yhsbQXp6L3r0GE5FxXCqq1WqtNWrJzTdX21a1H7UqPGMHXsvffuqtGlGEoEQ4VgsDaZxD21E0ELwtfaotzAiAm2SdOxoP5adPYHXXivjppveIjw80uH6qKg4kpJeBSbwzTffOZzT7wwPNGOxPx5Dmu757LNVoXojmElYVmsj8+ZNJirqRiCLZ5+1F/oxQ2uRqzfSaVWVkhr8hSci0GC1qghZcCQCKSU33JDBXXcNoaxMfTFmEkFrE4GUdiLYsGEtf//9F3V13qsAvJEITjjhSh59dBV79vwLgNGjK4mMDOPEE6/h1lsXmTy3llGjLmHcuJkMHqxcyffuderagvwAACAASURBVO2jyZPn8c47NZx11kWGz2kjghZCIDJNmvloa2541dW/kZu7wuFcdvYEjjrqfEAZsbTcQrGxQwFYsuQTh+v1C8GBJhGY9bk7tYc3aSWysyfQpcsAtD7Uo76+mk2bXsK5BoQZGbQWuXqr+qmo8K5ClS/1oC0WqK2tIidnAX///bPNHz493b7QgzIYZ2YOpFOnPrz88tXcd9/R1NerCCp3EkFrjFP9WJs16y7OOGMIP/1kXlZSD6vV+ypgu3bB+vUQGwuXXtqLl18uZPLkV+jc2dX1c968yVx5ZRwzZmQDymVU5RezZz3WoCK4Y0zHY7DHaRsR+ACzFLGa6LdmzWzeeuvfDucWLZrBmjUq3ZLm9pidPYH0dNXA6OhhDtc7J70LBTKwWNSCXVCgFoS9e11LeLrL9d/ciOLa2kq2bVuJKmhnBOec78qQbHhlK/Sn1eq9l4pmS3AHLTWE8zvM1F4NDVBYuJ05cyYyb94k1jYl1Dz8cBU4psd99y3l6ac3ExUVy5Ytv1Nfv5nISNUmPZm1tkSgn98ZGd3o0aMvPXse5tW9vpSC1FRoQ4fWkpAQTmysuVV/0KCTadcujSOPPN92TFOtmRmMzcZFWxxBCyFQRGAETSKIitpJerrddSUnZwEffvgQ2kJVVLTDFkR27LETWLsW+vS50uFZdXWOPvFSuk7WYKKsTC0CzgOzrk650mku2/7mGPKUcTQnZwFvv32X9w1uQnGxsYG5NWwEvtqrqqoUMRoFmjU02FNDOB83Q0MDREREccwxl5Cc3ElXg8D1Ws0l8rzz7uPMM28jI6M/6elqZ7x3ryoKBOr71hKjtQYR6D/vY4/N9eleb9XGZWX7eO+9DcBoli+/lq1bf+WZZ8zD2I855mJGjrzIIWYoI0PVL8jPh6FD7ddu3/4HH3/8KEOGHMa99z7s8qw2ImghBIsI9Im7Xnnld1uQDdC0KzXerd56qzI6Ge0USkvtO4nWlAgKC83JT/Mtz8xUROWPx1BDg8r6GhZmnFpCix9wdh11hMBIUkhNNTYwB7s/vdnhG6GqChKdfA2sVscSqvqsq2b9r3nPde7ch6lT3wFUkXpwXxe3e3f7qtWpkysRgD1JYGurhnyFt0QQHp5IQ4NKEBkb+zvt2nmumSWEICLC7sKqBes5J0asra3gt98WUVMzCjgAiKCpdORQIANVgmudlNJD7rzWhbsI1+bAyD6Qn29P3BXpaBN26/ao98ZwTjkbCkTgTaBTY6NSF8TF+Zd+Wlsgk5ONI2uN4gdApUqQ0kpqajeGDTuTH3+c73CdVgPCCMHuz7Iy/xwXKitdiaCw0LGf1U7f/rcRqqpcpSBNX52a6nq9EcwCo+rqFBG0pkRQV1fnEizmCd7mH9u+XYnlmZlWHn98s0MksbfQ3KH/+stRus/MHMiUKe/Qv79xMauQMRYLIXoJIeYCucB/UfWFbwS+FUIsF0JcZVRfOBQQCGlASuMBpO3ojTxezNweU1O7UVy8Hsg3NCTpPZNay7jprqazHhpZuPNYMfs+PBmKzYhUSqstzffVV7/ApElziYtLAwRCdLUV+jG+1+SDBAAq9bN/99bXuy76zoSq1y+b9b+WgqGyspT6+hoaG9VGQwj3dpni4l0sXjybpUvnefQcak2JYP785xg4MIEXXnjMq/vKy80jfZ3xV5MX7ZAhapnTRxJ7i6wsFR9TVORocE9ISGHUqEvIzDzG8L6QIQLgEeAtoJeU8jQp5UQp5YVSyiHAOUAScFkwGukrAkEENTXGX45mH1i//kXGjw/j/fcftJ0zcnvUdqvt2qUCqoKRs3pIb/hrLYnA27QHWr/4U6dYIwKznak7IgVs+ZwiI2Oori4BqpByh0tshh7BtBE0dxzqydgso6gGM6OjRgSvvXYDV1wRx9KlnyKlitdwV8yntHQP77xzF0uXvmRzi9YHwYFd0mlNIigo2E1tbY1XRevr6+Gff7x/h0YEg80zW3tEWJj9fs1lVw99hLkeIeM1JKUcL6X8yah0pJRyn5Tyf1LK+e4eLoQ4XQixSQiRK4S42+D800KIP5p+NgshmuFFbUcwDcXaIi7lekASFma38GmBZWlp3V3KUiYmdmTkSOUxZLRD0T5Da0yy2lrv+9BqNVY/aHBX+c2TodiMSAcPPpkJEyK44QalgF279kvAiqqIaidnIwSzP5tLOhUV9gXBHRGYfV9Wq32RsVobCQ+PpLFR9ZkntVDHjj0466zbGTNmsu3akhLHazTyCfaipa+Lff/9T7N27X7OP/9yw2v138GuXd57DP3zj8otFBHRwKxZ8UycGMW6dUv9au+QIer3X385Hl+5cjFffvksubmu9XFDzkYAIIQYBWTpr5dSvuHhnnBgDnAKsAtYIYRY3FSeUnvGbbrrpwDDXB7kB1qDCG677TE6dryFpKR0h/PZ2RMM1RRhYWH07p3E8uXGBuP6euWR0xpE4GvZTm3XaQR3NaA9uY5q/bZw4XSKi+2lP9u1S+P771+lpka9eNCgk9m3byv790t274adO6GvSYbfYC5azSUCq1V9F+3aGdsZtIXYTI1XWWn/vLfeugir1cqvv6r/PRFBYmIHJk58ArC/u6TE0Z7VWqoh5/mdmGgQjo7q/02boH9/1VZPVcH0WNQUL9a581fs3FndlNDPv+ImmkSwfr2jgf/99x8gL28t/fplM2hQewcJLeSIQAjxJtAL+APQhrYE3BIBcBSQK6Xc2vScd4FzgQ0m148H/uNFmz0iEERgtCOzWu2LeJ8+7YiL8y1zmGZX0LJA6tFaEkF9ve/FfMx2WXV17lVM3gaTORNpfX0t9923lD59VHWnUaPGMWrUOD75BN5917g/NRxIEgG4J2Up1fdl1sfO94aFhdn63J3HkDOio5Weu7JSPVPz8GoticDbfi0tVe3dvdu3bKMbN6rde2wsjB+fytatD5Kc3Jk+fYz1+Z6Qmqrm+u7dKrmiZkA+6qgL6dv3WGJjkygtVWlWNIQcEQAjgAFGKiIP6ALs1P2/Czja6EIhRHegB/Cd0XlfESyJoKhILYLJyd7V2XXGwoX/Aj5l2zYLUkY4xAtoi2uwJ5m7HbyvMDOU5uaqz+VPMRqAqKgYSkvzuf32frb6BBde+CBCHAkMcFvD+ECSCEC1153BubTUfNEwInRfPIYKC/MoKdlF166DSElJorJSfWfORADBjXfRz+9bb52AxWLh0UfnukgG2md1tzEwwpdfqt9nngnDhh3DsGH+EYAevXsrItizx04E559/n+28sy0tlIzFGtYBnTxe1TxcArwvpTScOkKIyUKIlUKIlYXOIZUGaGmDoFHqaXCs8DRt2mBuuaU3+fneW6N2714KFFFbG+HiOdQaYndLZcHUYEQqjY3w6KPw0EP2CeqOCL755kXGjxfceKM9B7JxfYJreeedkYCVzZvNpZoDTSLwBE/pvUEt6PfeO4IXX7zSo4FejxdfvIIZM7LZunWVoZ1Ar6tvrX79+uuP+eyz91zcRxsb/ffY0jYSRxtuW/2D1n/O81yD8/cYMvUIhBCfolRA7YANQojfAZumUkp5jodn7wa66v7PbDpmhEuAm8weJKWcC8wFGDFihNsh55zKuSVgFh6udx3duHE9UkosFu+dxv/1rzv54YcSSkrSyMtzFNdbQzXkS+i9JzQ2GtsOSkrsg16TstyphoqLlVBptdq3gUbxBcrHuwIhlmGxHMuaNXDssa7PC+YEa+2kgZpuv6xsL9u2rUIIYWuTN0TQvftQLJY6wsMjbGTtvJBZLCp+xjkWJpDQE8Hzz79HZWU5cXHxDteUlPg3d7TIbSFUIN2ePZuYPfssuncfaqv17A+M+s9iqaesbB9ChBET41hrOZRUQ08089krgD5CiB4oArgEuNT5IiFEP6A9sKyZ7wNadjEDtWiZCSF6ieDss6dRUVFsGtFqhIsumkFtLXz+uSpppxULB/vnCOaAaMmFyygtBbj2ZVycPZ2GUTnKCy98iJNOuo7aWrtF1LwCnOCyy47ljTfg999bnwhaK+U1aJW71N+ZmYN4+OHfAJg9Wx3zhgj0tTL+/lv9dvYc0oigtSSCMWPOcjhXX6+cBbxQHBhi7171WTp1Up9r375tFBRsoaCgeSXwjCSCFSs+4tlnL2HIkNO4554vHdRrIUMEUsofm/NgKaVFCHEz8BUq+f5rUsr1QoiHgJVSysVNl14CvOuHDcIQLZ1+2p0rol4iOP30WX49v1sTbzjrtQ90InBeMDQ4e25o0oBzOgktiyjgYiw2qwCXltaNo46CN96AtWuN6xgfbKohM+jTesTExNO791HU1yuX1PBw47oP7mAmETQ0KKNqqPSrVtfBX2hzWksNMXToaVx22dP06TPS/4dil/b1/dev3/HExraz1S2prVV9qdWHDqbdxRuvofOBWUBHVGIXAUgppbuqK6Au+hz43OnYA07/z/ChvR7hTd5350LcRqioUDsLd14beonAH+TkLGD16m3AfaZEcCCqMlTpTuNz2iQdORLWrbMn4jIrR/nii1cAjmQwbtxMlxxEWqBeaqpKprZliyIDZz1vsBYsq7V180QZbYi0RSglxTc1jpSS1FTh8AwNrTFONSIoKSniyy8/oFOnTJtk4Bz05iuciUAIwZln3tq8h+IoEWgLfPv2nZk3r8QWsVxTo4igpERJJMEkAm+Gw2zgHCllkpQyUUrZzhsSaC14kggqKlRqWXeeBA0NShR2RwLl5cqdLiYGoqL288orN/Dee/f71NYlSx7n998fRggLe/c6ktiBLBHs32/+LE0iGDIEXnoJLmuKTTdT91itjcyZcxlz515rO2YWqPfZZ08xYUIE0dHK7WPNGtfnBas/W1MaAMd5sGrVp3z00Uw2bFCFob3NMbRx409cd106s2efbRpUFmxblpT2sZWXt4Xp06/nmWdUNH9FRfM1As5E0FKIjVVqUE0q06BPW6E5OGh9HMy57w0RFEgpNwa8JS0AvV7UCOXlaoG3WhUR/PUXrFjhagzeudPzRNYPmMLCXJYufYmPP37Up/b26TOKDh0yaNeuGCkdyUnzyDgQicBMLQR2iaBjR8c0y2bpJBQky5c7VoTKzp7A6NFXk5U1nKKiPObOvZb6+uqmCNqfAeUP7oxgLdChRAQrVnzIe+/dx+rVamejJZHzhKioOMrL91FausemwnM2wgZbItC7jiYlteeSSyZx8snKb8XMI8cXBIoIwNxzSErJ/v17qa1V35u2AQ2mlOXOa0irrrBSCLEQ+BhHr6EPA9w2n+FuN7B9u2uVJc1rZdcupcOLilKs7E0EoqYW6tIFIiNj6dAhi+joePc3OeGww47ljz8+p7y8M9CN776bSe/edhWIu2IvgUBLDTx3kcYaEeiDZ8BY3aNHTU2Fy7HPPnvKFl1stTZy001v0tBQR0bGYG65RX2PxcWOO+BDRSLQS5dHHHEuiYmd+OUXVStjpJfq7u7dhzBnzm4SEzsQEQHx8WrOlJfbbQzBlgj0/dqzZ19bLQIpm08EUgaeCHbuVO3U0nlXV5czbdpAqqv38847pZSVqSU52KpFdzaCf+n+rgZO1f0vgQOGCMrKXElAD6tVEUVcnLmrqDP0A6Zr14E8++w2n9rqmms/j59+msyAAXZ9uN5POxhoCSKoq3OfibS0VOmnndUT2dkTWLx4Njt3GmTmwlhiGDz4JAoKtnLaaTfTq9fR7NixtsnrKA/ln9DI3Xd354orZtr6VJOyAq17bW0i0M+FI48cS1LSWD79VBnnBw3y7hkREVGkpNhXxNRURQQlJaFBBHpowZ3NQWmpItB27dRPS8NIvRYXl0hUVAz19dHs2JFHbKyqFhRKRPAN8JWUsgUEruDAjAi8STtbUuJepeEMJREs4PPPp7Nw4Q6HMpTewNgXXhWt0Z7R0HDgGYudS1jqUVSkBndamnH1rbIyxdZhYREOcQNm9QX0ft2uxKpWjMpKR++j1l6wggXnufCz0pZx7LH++/unpCjvNv2ONtiqIX2/lpeXUVtbTVJSe/LzY8xv8oD6enj5ZXvOpkBIA2CuGnrggZ9ISkonLCzM5mQRqJoqZnA3JLoCi4QQPwshZgghjhaiNYsmeoZRPpGaGv8jDN1hy5YFwGQqKuzRrXPmTGTSpDTTwul6uCtao6G+/sCTCNzVMTBTC2mYNm0J55//Hy6++BHi45VSOiwsnEGDTvZIsGZFbEB5H7366nSbNBCMPm1NInAujbl+/S/8+qsi1uxs3571xx9fMnv22Xz99RzT6GJoHYngzTfncPTRGcye/ZDP+bH0WLUKfv3VniY60ETg7NnUvn1nl8jokJEIpJSzgFlCiHbAycDVwEtCiI3AlyhpoSA4zfQMM326O5WQv6ipgcrK6SiNmSMqK4tN/d/1MPOF1wekHYiqIXdEoNletPz2zujd+0h69z4SgHXrvmXdum+xWhtZvXqx4fUWi4Vnn72Y1auXONSJNUJt7Q5KSowLCAUCrU0EGhoa6njkkcuBLaSkSLp3920vV1FRxJo1nxEREUVWlgr+d4yOVb9bgwgiIiJJTe2IEF66QZlg7Vr1u29f9TlOPLFZjzOFpzQTejQ2Blcb4FFIlFJWSCk/klJeJ6UchipY0wHP2UeDCiP9YEsYkIygvHvMM5tpdYndwSjXPjiqQIJpLG6JnbJWm8AMniQCPU444Up69hxBREQ0GRn9DK/57LMnWbHiI48koNDNVlY0lCSC5uxkzaBXz9XVVdO16+kAtlgAXzBo0ElMnfouEyc+aSgRtKbX0HXXTSMnp4CTT77d7+dJaa8TcPXVKgdWnz7NbKQJzIjgp5/eYObMk/npJ/uSGjISgR5CiC5Ad931K6SUTwasVX7AiAjKywOTifT77xegONR8tutVPEbQ59pXaqJuREY62hiCSQQtMZGrqty3V5MInIkgJ2cBr79+E9XVZcTHp3Dllc+a1nHQ3/Phhw951a6wsDis1pk2IggGvCGCujqVo37QIOVn3hKoq3OMhk9IaM/YsXN47jnfs7yCUlscc8w4QEXtguNCpuX2aq1+9aXGgBF277Ybv7t29Xx9c6D1f2mpY26moqI81q1bSu/edneuYNsIvIksngWMQ9UR0Ncj+CmA7fIZRkQQCGkgJ2cBP/44GXckAHiVc0hb7KxWuPxy9Rn0Uc8WS/B2WoFWC4HyzAJHHayzkbeqqsSmWgNccg/pCdSssL3Vav9u0tK60afPoyxbNoH8/OAtWt705/btasLv3q3SFLcEtm51fbenSnDewiyoLJhODXoikLJ56STAbhcYPDjwSfOiohQZlJSo71wjnlGjxtO790g6dbIPglCUCMYCh0kpWziLT8vC2VAsZcvm1tewcOF0rFb38ryZl4sRbropk4qKYuLjyykvj6S83J6XJJi7gpaYyO7UHMXFyl4TG6sKemswSy0xf/4t1NZW2OoSO+ceclfY/p13JOPHhwGSO+/8nL17B7JsGUGTCMy+t7Iyu1vizp328VlUBJmZrnmRfEVVlXEMR3OJYNeuDSxfvojU1P7AxbagMs11JFi2LH1UMcAtt1zFhg3rueaal+jRY7hfz9SIQCsnGWgMHKg8uNautRNBp069HUgAgk8E3nDgViAy0A1pLpwlgoqKls9ECu4yX+JSl9gblJcX0tBQS3S0Uq7rJ3IwB0NLqYbMsG6d+t2/v6PrqFl/VlYW20hAg9724qmw/aRJc7nvvqV07tyHTk3VNDQ34kD3qZFaSCubuHat0kk7uzSvX2/PfOkvjCSyr7+ew5dfvg80hwjW88EHM/jssweJi5M0NDjaIYJFBM5jdPPmdWzZsqIpBbnvWL5cfRdCNK9AvS/QcmtpBmozhIxqSAjxHEoFVA38IYRYimNk8dTAN887GA1EX+vueouUlG6UlBhlvuzOc89t9/l511zzEhERUfzwQzyFhY5EoC0owQiAai4RSOm+SIpGBAMHOh43854yg2Z7cZd4DmDMGHtuok6dVP/t2+dbyUJ/YUQEml7YLNaloUGpiqT0PgWEM4yIoKxsH42NKoLMXyIYMeJcRo0az3nn3cezzwqqq5WEl5hob3swVEPO77jjjnfIzy8iM3OAz89aswaee04984IL7FXXAo3Bg9VY/Ptve3bcwsLtrFq1mPbtu3D00RcAoeU1tBJYBSwGHgZ+bfpf+wkZGO38WzodtYbjj58JOHr7uFMFhYW5L2M5evRVZGdPICVFCV3OEgGEjk4bFOnW1bleX1tr3k4p7UTgHNVq5D0VFRVHcrKxS6C24zdLPGckiUVGKgO1lEo32xoSgd53fMmSJ7nssmgef/wcKiocDVm7d/vv4GBEBBdc8AAdO6rCDP4SQUREFFOmvE1m5gBDz5dgqob0aN++N336jCQmJsHnZy1erMbw2WcrIvAX0dG+bdISE6FnT9VnWi6sPXs2MX/+LXz33VzbdaFkIygDfpVSNtMuH3iYBZIFAklJ2kIzFSghLa27YURxYiKkp6vJZ7WqoBV3X6wWsm8kEQSj+pM7IqirU6qAoiJ7cF56uj26FNzbB/bsUfclJrp6Zmj9NmfORADat+/CtGmziI2Fe++dTE2N8Y5fu9dMBffbbx+wePEsMjL6cdNNb9Cpk5IIfK1f6w+cF/KGBsegxo0bf8BiqWf16k/Jy1vLoEFjHO7Nz/fdg8ViMR7zUmLLX9NcYzFASooEhGnJykBCP0YtluapfjXPqjPOaJ603aWL+uzbmjLMREV5ljqHDrWnSR82DDp27MGpp95MZqZdXA5EpUV3cEcEE4E5QohqlDTwC4oY1gWlZT7AaEB4U5fAHyjPlwmMG3cuRx65ky5d+rtcExGhdOHaAAsLU94CRl5M3333Cjk5bxEZOR04xVQ1FGgYDTptgBu56BUUKDLQpB13RLB+vfo9cKDxpBs1ajzz59+CxVLHnDlbOeYYe7GIJ56Yzp49O0hN7cakSTO57LIJ1NcbZxbVY8eOtWzduoJ9+7YCSt3y55+KCIItEThHkk6aNI///e9CYmOTiI931Unk56v2Rnjl3K1gZJ/Zv7+Ahx46h7q634iJcS+ZegMpJatWvQjcyO7d5YDSDdXXB181VFlp5e237yEuLomxY+/16Tnl5WpjExPTPHIMD1eeVOHhag1KTlaJ+YqL1TphJtkNGQIffmifF5079+Wqq55zuKaxMbhBie4iiy8EEEJkAaOafq4TQnRDxRGcGYwGegNnIrBYAhM/YLXajTyHH55gSAKgBpfzgpeWZkwEq1Z9ysaNP5KaeixwioNtI5gpEYwm8ubN7j2vtm+HAU3qWXdEoBXdMQvUCQsLY948tVom6KT8sWMnMHasyg9UUIDN6Bsbqyadu9Qhw4adxebNy+jbV6lFNJfVYEgE+glcV6c8hPRITu7EjBk5pvdbrYo8tM/rDG33r0+MZpTj6YcfXiM/X51ISrLgZdiQKYQQtG9voawM9uypRiOC1pAISkoq+fTT2cTEJPhMBJqhPiOjedKAPmdWZqbj8bAwNX+MkJWl3pufr/rOiPCDLRF4E1m8HVgNrAH+APYBXoW/CCFOF0JsEkLkCiHuNrnmYiHEBiHEeiHE29433Q5nUSxQaqFt29Tik5IC3bubX2cUuJOcrHTVzhgx4hz69TuOgU1WVGf3v2B5DzgPuvJyz+635eV2cvOkGgLvcrgYuVBqhcT1SE93/5y9e3PZu/cfPvzwIaZMyaK4WOV/CrZEsGWLfxO6wCB5y/btytaycqXrIuMsERQUbGHMmEmcdtpjAKSkGGT500GzZXlSQY4dqyrGWa32LyRYtTP0/VhfH864cY9y7rm+kQC0XKppd2MwJcU8lUp0tLJZNTbSFNvSSGHhdvLz7V9qyEgEQoh7gWNQ6SQ2AcuB54HJUkqPTRRChANzgFOAXcAKIcRiKeUG3TV9gHuAY6WUpUIIk64zh1H0baDUQlrFq65dt3PzzcfTpUs/7r33a4drwsKM68EKoXYKzm6DJ554DSeeeA15efDTT6FDBN5kbAW1OCUkuDfO63dgxu+22pJueetLn5xsro81qn/8xRcqBqGiwju33uZAm8Ba7n49fvjhdXbv3kh29kTS03tSXGysXqypUfdqnjnl5Y55sxoa1PPj49V35/yeGTOy2b9/L5dfrpg6JcV86xsfb3efVDYFRZhGxufMTDW49TYCvVNDIL3b9GNUynjGjr3Hr+e0BBHExXlWtXXpYh75nJlpt1m1b1/G1Kk9iI9vzyuvqI4NJa+hy4EMVIK5BcDbUso13pBAE44CcqWUW6WU9cC7wLlO10wC5kgpSwH8MUwbLQSB8hhavVr9Tkr6nZKSnWzdutLlmvbtzXdV7kL8jYzFEDwRUf+Omhrvg/EaGiA31/x8dbWSoiIjzUsk/vjj64wfL5g0KdVrIhDCPGeRUZBaQ0M1MD0oaTs0IjAah8uWLWTJksfZvn0NV13VjnvuGY7V5AvWk7FRBK32HRUXO0fcShISUomPb09trRpY7nTh+nNCKJIdNMh4vDrX3oXgJZ7Td1NzNnstQQTepOuIjjZfCzRV0q5dygkiLa27Q2yMJmEFiwzc2Qj6CSFSULaB0cDdQogEYC3KaPy6h2d3AfTa0V2AUylx+gIIIX5BVRKZIaX80pcPECyPoZISpRqKioJTTulPbOwUkpNdHb7d+SO3a6cGh36BqK+vZdWqxZSVFSPEDVRULODmm6dTXKzSKtxxx0xuvjnwu1j9gPO2OI8GdzUItMWsUyfzSaG5UEopfYquTU52zKujwTzob0dAggz10EtwRmNz9OirGTz4ZA4//AzS0roTHR1PVVUp7dq5smRpqVpwk5ON7Uv799t3lnoIIXj8ceXT8XrTLPWWCPTIyHBNJxETA5GR1TQ0xPHzz59z/PFn2saO1WpcZ6KloL2nsRGKiorJz99EUlIn0tN7+vScliACLfrfE2JjUv5VBgAAIABJREFUjQ35mleYIoIYlxikYHoMggfrkZSyBFgihPgSOAI4HrgOlZLaExF4+/4+KKLJBH4SQgyWUjqYAYUQk4HJAN26OUaUGk22QKiGNCPxoEHQu/dgevd+1vA6T5WNUlIcd3qVlSU8+6xK6hUTk0ht7WSKi+0qjRkzJtOhA1x9dWDJQJtklZXNz9+ihzeT7uyz72DMmMnU1pb7RAQJCWrhcdalmgepdQsKEWgwkgiOOeZi29/PPrsNTyU+tm9XHkRGO8PKSrsHjBk0g7rZYh8drVRDRkhIUKopZ7VTdHQpDQ1x7NypxNdgebdpfVBbC3///RNPPXU+I0acy+23f+z1MxoalP3FyO7kLeLivFdhmhGBXiIwgtanjY2+eY/5C1OuEUKcI4T4rxDiZ5SB+AkgFbgd8KYLd6OK22jIbDqmxy5gsZSyQUq5DdiMIgYHSCnnSilHSClHdHDSBwTLdfTvv9Vvd2X+wsM9DxBnkTI5uRORkbHExSXR0HAvzjUOamurmTHDfUrrloA2ybTEcC0FT/YBgMjIMBISkunUqZtPg14IY3uMWZAazAx4sR89EXjyJ/emzlNDg93ryghbtri/X1MfmakyPEXUGtVvyMpSD+vZ80LAcfcaSOiJIDo6gT59RtKli29RxVoaj/R0Y+cNb+BLFlez9UDzWNq713gN00tZwYA7oeNKoBC4E+gkpTxOSnm3lPITKaU3e8YVQB8hRA8hRBRwCSpKWY+PUdIAQog0lKpoq7eNt1qNg3cCYW3XiKBfP/j114W8+uqNrFjxicM1CV4EOGrqIQ1hYWG88UY1V101h8ZG4xm/a5f7lNbNhaaPLCvznEHUV2gSgZY2ISdnAVOmZDF+fBhTpmSRk7PA5n3hTypmo4XMKOr4qqvmAhNaVSKoq6tmxYqP+eef5S32PiOp45df3uH22/vxwQeP2nacZh4snvzok5JcF8zMTPVFFRfbTwTDqUFbFOvrYciQU3jooWVccsmjPj2jOWqhDh1UDIAvxY3MxnRUlCIjq1W1adasM7nlll7s26ci0/QSQTDgzkZwPoAQ4owmY68NQojrpZQvuXuwlNIihLgZ+Aql/39NSrleCPEQsFJKubjp3KlCCC3F9TRfaiQb7bhaeiEDpSfdt099qd27wxtvzOHvv39m9+6NHHmk3f7tDRGA0i9quu2cnAXMn38LlZXmH7tLF88prZsDjUzNdrA5OQtM00F7gl4iMPLmmTdvMqtWvUlu7nrGjBnPrFmzfWq7kUQA9qhji8VCZWURiYmdePnlwKf2dicRFBXt4KmnzqNz57489dQm1q1byuuv30zfvqO47rpXW6wNhYXb2bNnE/n57aipUSoQowVfCLtXkjskJzuqCzWhXG+bCEYsgZ4IvEFdndrcdOyo2vbVV7BokTrnT+2BLl18zxDrbnOTmakkgl27oLh4J/v2baWmRun5gi0ReCOI3y+EqJNSfgcghLgTOBFwSwQAUsrPgc+djj2g+1sC/2768RlGu7tA1CfWpIE+fZThJivrCIqKdtCnz0iH63wlAteC666Ijo7j/vu9S2ntLzQiMArCM1u8wbwUp544oBswk86dJ/C//xmnnF616nsaGurZts1DSkYDREeryWmkDvzyy+eYP38qcXHJvPpqqc2eUFfn/XflK/QeNM4LVnh4BMOH/4v27ZV4FBYWzp49f9OunZeWRy9x2mk3M2LEufz8s9r2DjDRnrRr550h0pkIEhMrgQRWr17P1Ver+JdgeLdpRKNqMkuPqrUXX4Tff4e771Z6+vnz1fEhQ+Css3x7d0KCf2nC3d2TmaliQnbsgNtu+xAhBKmpdoayWkNAItDhHJTBeBpwOtAPVzfQVoHRwhVIIujf5O59xRVPc8UVT7tcZ2Z0c0ZsrDI4uSu4ruHOO+dy/vmBNRRrg82oP83qBSxcON2QCFzJLQ+YzOrV5t48DQ0NXHnlVIYOHWN43hMSEoyJQPPqslrVB4uKUh5lgYozUe9Sv412rZ069WbaNLt2tGfPI5k9+y/at2/Zaumxse3IzBxgs/e4IwJv4Cx1paerBbi4OMK2IAdbNfTcc+NZv/47rr/+/xg2zDXJQWmpIgEpFQFoY/uyy/zLL2Tm+uwJYWHmG5V+TRVYly+HceP6uJByMGMJPBKBlLJICHEO8C0q6+iFTTv5VofzwlVT46ozbY5aQ4PePmCGqCh7ZTFvkJbmvrYBQGJiB04+eULAJ5jWj0YSllkbzUpxGpObIg4zb56MjG785z/P+NJkB+htLnqMGHEOr79eYctOqRmiA5mKWpu43sSyxMTE07WrG++DZsBiUfUPwJwIvFELgeo3vfdQ165qxxMe3pvGRisREeEBX7T0kcv19VBSspvy8kKio413X7/8Yr9eswt06QKnneZf0Ju/RABq42dEBIMHq3Vg3z4VMe5cHCeYEoE7r6EKIUS5EKIcyEUZci8CtGOtDudOcpYGtN2pWnykTa2Rk7PA63fs26dyxUREqPSxAAUF2ygp2YNFx0S+qhpSU82LqyjEcdFFTwdlV+BONeSpAIwz3BHHuHEziYhwZMuoqDimTWue6stM/I6IiHJIUawZPQOVggTcE4HFUm8aPNaSeOede5g792Xq6pRtxsw+4K1EAI5SQUyMIobGxnDKy1XgQGNjcPpVU7k98MAPzJmzm969nUOT1DU/NRXSHaMTMi+91L84h8RE3zZ5zjCzE4SFwYknqr/fe28nb7xxG7m5v9vOBzPNhCkRSCnbSSkTdT8xUsoE7XhwmucezguXczSsmVrj3Xene7XLtlqVnhHgyCPtg+Hee4dx001d+OoreyyBt2ohDdHRMHGiq5sjQFhYKjCX3r0nBEX36k41NG7cTMLCHGePu/oL7ogjO3sCV145x0YGYWHhXH/9XDZvXs/999/Ili2b/Gq/mUTgDI0IAhV5Du6JYPHiWUycGMGHHz5sO/bFF8/w8svXUFy80/UGP/HNNy/w88+KkM2kgYQE3wKVnMe3s8FYs70Eaqw6q9zCwsJJSckgKspxFyAl/PGH2rwlJMBVV8GFF8LYsSrlsz/whTCN4L4eifoetmzJ4Isv3mXHjr9YsECpi4KpGnInEWS5u1EoZLq7JtBwLmTtHFjjbnf64IMqd9CKFa4pEqxWNZheeUWphZKT4cor7ee1hTEhwS4v+mN8PPtsVzfHm256iyFDioAJFBUFxy3PnUSQnT2B66//P9v/KSmZbktxjhs3k/Bw88I9J510LZMmzQOgQ4csTjppAq+//j/eeutF/vjjN7/a744I7rprKFdfncT69T/YVEOBtBG4iyquq6tGSklUlH2L+PvvH/DDD69RUOAhIMDr90smTHiCjIzLAHN1prdqIQ3O8R2JiUopsGGDmmPaOHWXfLA58EblVl4O06fD7CbHs+xs1e4LLoBx4/zPg9RcInB3f0qKRlDhHH30fCIiRrNkifJukjI0jMWPCyHCgE9QtoFCIAbojfIaOgn4DyooLOhwXiCVJ4HjNe4iTDdtsg8YIeCRR5TqR0pVwm65ztX7uuscJ868ea6unr5KBKCeaVRcZeHCL4HT+frrxZx00jmtqhoCOO64ibz44hVIaeW22943FMc1ZGdP4JNPYNeu6YCxXWbUqEsZNepSIiIiiIyEwYNHsGfPDnr3Nk7r7QlalSgjwty3byu1tZXs2rWOqKjRQOtJBOPHP8bFFz+MlPYv9PTTp5KdPZFOnRzjKKury/nkk0fJzr6Mrl0HOj/KLYYMOYVPP80CoJuJ9tHX2gTORFBVtQY4gXXrtnD++d1sC1Z1dWA8svQSwZ49m3j77Tvp3ftohxTUH3+s0sCoeQUXXdQy727u54mOVtKoWQzLgAGqcFVc3Kk29/eqqhAxFkspLxJCDAAmoFJKdEaFvW5EuYTOlFIGcG/lHs5MabQTMaprC3EcccRMunVTaSMaGpQY+eab8MADysi0fLnSg44Zo9jaXTQxqGv9CQM325U1NPwDnE5RUWPAS9bpCdVdsNUTT2wgLa27iyjujPJy2LXrEoQYR9++Z5Ob+x1z5lzGwoXTGTduJn/88QVFRXn07TuKZcsWUly8g4wMlVNp6NAj/f4c0dHGO/3x42fR0FDLEUecwy+/qGPB0GWbGaTDwx0HytFHX2h43ZIlj7N48Sy++OIZ3njDc4Pz8tZSUVHMRx89zPbtm6mp2UV4uDCtf+yrK6Tz+O7WLZHNm0HKLMA+H7WSpS2dhVTfr3v35rJq1WIaGupsRFBcDN9+q6659173aeJ9QWxsy6R4SEgwT+TYu7f6nZtrH8M1NY5BZYHM4QSecw1tAAKf38APOO9ejYggO1t53MydeycWSz7QjcMPn8ntt09ACLj4YsW8t92mVECvvQbLlql7L7/cbsjxBH93DNHRxqmUs7OP57PPoGPHEwO+K9APNiPCycv7k3vuOZz4+BRb8Rh3WLasEQhHyjvYtOkr23HNUC+lpKGhhtzc32hsVMyze3ce996rYhPGjvXPVdbMRe/UU2+0/a3ZCAKlGtL3X3M9k4YP/xfr139Hv37HeXX9p58+zi+/KCeI9PRLqa4WZGSYL2LNJYKjjx7WtPCqeqX6NBN1df753LuDXtLq2XMEt932AbGx9p3URx+pjczIkS1HAtB8tZAGd0SQlQVhYZJdu6CszAJEUl9vH0OBTuYHXhSmCVU4SwRmu7ywsAlYLLuBMjp1upS77prgsFuJj4dhwxYAWXz7bRhVVVl0776A0aONn2e1WrnyygSuuaa9zWvIH7WQBiOpYPjwoQDU1ibbFuhASQWe1EK5uctti7cnKG8N1VAh5rmcr6+vJjw8goiIaBsJaKipqeaJJ/zfc3hjMA40EeizYxrpdl966WqefHKsg+2qoqKYNWs+Z8OGHxyu7d37KB588BfGj/+vV+/u0KE7XboM4PbbPyYmRgU6mqmFIiP9W1j0ZGBkLNYQiDQeeokgOTmdo446n8GDTwbUJu6775QUcqGxgOU3WooI3D0nKgraty9CSkF5uT1th2bzDIad4IAlAm8kgrIymDNH0XBKypOccoprwpWcnAUsXz4ZFfgkgTzy8yfbdlfOqKwsoa6uiurq/UQ0zYzmEIHRANF8ljVjMbQeEZxwwtU89tga+vU7gRtuyGDu3Eku12j5gy69VLB1awwgkNLYw7iurhKLxXi7vGeP/zmVzHagq1cv4YknxrJo0QMB9xrypBb6669vWLnyEwcbwbZtq5k9+yw++ODBZr173LiZPPHEekaMOJf+/acA5mkU/N2t64lAlWmUlJSo/gwmEehRWQnPP6/mx7/+5VseIG/QUkTgaY3o2tV1AdPsBcGwEwQhwWlg4OwxZLTLW7CgHinbA9/w6KM3k5TkGMqfk7OAF1+8AqvVkXLdRc7GxCQwefIr1Nbakxo1x5hkNNB27vwKOIWSEkl9vdq6BSovuTvXUYCIiAiysg4nKiqG/fvzyc119OxxjSR2v33R4g/MAsv8hZlEsHr1Elat+oTt29fQt+9DQOA9W8wWwilT3qa8vJCkJJW8t6QEvvpqJD173kqfPo7O5q+8cj2lpXu48MIH6dp1EBER3qfK1GoktzQRREba55kQVhobVXjRnj0NdOhgb18giaCuDpYtew+LpY6hQ8/g7bfTKC5W6V9ayjisITW15VRc4eGKDIxSUgOMHNmdP/5wPBZMicAjEQghPgReBb6Q+q1MK0O/cGkGKj3KymDZskjAytChn5OUdIrDeW0BcyYBDWaRs1FRMZx44jW2/+Pjm7dAx8W55tTfvPk7YAhSdqa0NLCVitxFFetx8sk30LFjDwYMcDSceJMmQ0NkZAw9ehxBenovvv56jsN9sbFx3HGH/4FlZhN24MAx/POPKmKvSQKBkgj0uXCMoNf3S6nck9esaUdKytOMHQu7dm1g//58Bg06iQ0bvic/fzOrV3/KAw/8SP/+x5u+d//+AuLikmyGfI0IzFRD3sZdOEOvTgoLCyMiIg+LpS95ebUMGmQngkBEbmvqUYsFPvroEXbu/IsZM1azfLna3N1wQ8vm7Y+MVLr7lkRcnDkRaAZjPTQiMNuktSS8WcJegP9n77zDo6rSP/450zJJJg1CCaEElGYFRbFkdS34s4trxawdcF2xY8WyuwqrK5YVRcS6rlHBjl1RV2WtuGIFFZDeQ0lCenJ+f5w5mTsz987cmdxJgXyfJ09m7tx758y555z3vO37chbwa7A+weAUt8kWjAun2Q7v8cdLaWjoD3hYteolnnjiUubMCTFbxlvArDJnI5FoPLYZIrWCIUN+R1qaClFNdS6BmWkoRBUtmv+mTz+boqJ92Gef48Ouj0eToZGZmcfw4cfy1Vcv8Z//PBaWP1FY2I8pU2Ym7SgG68XtwANP5847v+XCC6e3mo/Azo74yy9DNbA3b4aXXpLccssBTJ58JJs3r+aSS55uTryrqIjtpH/yyQlccEEWX331Clu3qsitjAxrWoRk6L4hmo561Chlo9+2LStsPqYiwKGpKdSv++9/CgceeCZr1+5Kba1aRK2io5JF377J1yuwQqyQ3YICZVkQImTe0qah1hAEdriG5gJzhRA5wJjg65XAI8DTUsoUM7ybwzjwIh3FH31UypdfjkcXeSkrW8G77z4AwFFHTcDvz4i5gMXKnF20aB4vvPAX+vbdk3POudeSBjkRBALh9Bj77HM8w4bBF1+E6tGmOmNTDzYrRtRt29abso5a52ooeDxpZGbmcfrpt1FXV81PP31EYeFQiotLyMzM48knx+L1+lokBEDtVnNyoms+G7mm/H7FhFpbmxoSv1g+gm3bNvHOO6+Snt4fIQ5nTpB77ogj4IMPJG++Cfn5V1BdfRsbNy5j8OCDeeSRzfh86bjiqJwVFWU0NTXh8w1h9mx1rE8f6xDOZM0dkQ7mggL1BevWRZsv6uuT1zzM0NgYGqOnnnorAP8M0lONtE5rSRpOzOtIxBLAK1d+S13dRLp334veve9m9erQWG4vGgFCiK6oQjVjgW+AfwL7AO+lrGUxEEm7EKkRlJZOIrLSF4AQLioqFJ+uFRWCy+WOmTm7cOFH/Pjj+3zyyb8BZ5xJZlqF0WGcSpqJSB9BLE2prq6KRx4JdxabVQPT8PkyuOiix5gxYy0+XzpvvHE3lZWbKStbybx5pWRmZrNhw1qWLfuV/v0FxcVFvPKKfR6oSPTvH774RXJN1dQoJtSvv07+O2Ihlkbw73/X8/LLF/LMM4dTWqrU/t13hwsugNzcV2hsFKxf/zeGDGmif/+DAUVKp4VAY2MDNTXmdoWbb/6ABx+sYvr0wXz4oTo2YoR1O51wFkOo1KOVIHASDQ3hC2JtbUijcloQeL0t4xayQixB4PH4qKubi8v1erPm0K5MQ0KIl4FPgAzgBCnliVLKWVLKS4EUsbrHRmTHRFJLVFRY7fYl3bqpIGOrcoZHHDGeWbMmhVXQMqKoaDiDBh3EPvscT1aWM/G9kc7mhoY6amoWAiGNIFWmoUiNIJ6pp66umhdf3M5nn6k2FReXcOKJMwHVryoZHfLz+zULVCvyv08/De9bnU+QrDDw+8MrT1kxoX70UWpSY6zoJdasgc8+6wk0kZu7nv33h6uvhhtuUP6loUNfomfPO8nIqGXRIsErr2xmzpw7+d//3mi+x7PPXs9llxWxfr15Ab8FC9IoLxf07QtTpsDxx5uelnToqL7WiJ9/VmXLV6yojkp8dFIQaKqFhgaVcb1+/RLmz6+lthZ22SUUyuoUEs26tou0NGt/YkHBIB57bBt33fVjs6DWpqHWoJmx4165X0r5odkHUsoY+47UIdJRHDnovN6+1NdHmyuMdn+94581axJlZSvIzOxCdXUlc+fOQLNsmxVhGT782Gb+cyf8A6AGRyAQevBbtqzlgw9uAZ5ny5bUaQRmIX/xTD3QjxdeULFwXq/aeWZnl6AS0P/NlVcG2G+/k8OueO65G03J/957LzrXQOcTJGsq6t49VP3NSqhZbxRaBivT0LPPQlOT4PDDBePG9Yi6bsSI4ykre4Azz7yM++6Dt9/OpLr6dvr3H8TcuQ/h8fgYOfJUPv98Nk88cQnXX/9W1D00JcrRRyvNyAotiYKJFCANDUuAaqqq0qmqCi+07qQgMPqxvv32be6//wy6d38TOCam5pMsUlW0CKyL2btcbjIyspvPAXWejhZMdRF7O6ahPCHEHyL+jhBCWFRBTT2MgiBSGwDw+SajFBjjsQxOP/126upCnsLi4hKmTVvGM880cc4599HYWEtkqQUdSmoGpwQBhMcZ5+UV4HKpOPzKSpkyH4HxnrpPFWmc1YgTwHJ8viKglNdfV0d1AfXddgswcOCBYVc0NDRYRmBZRWy1JJ9AZ2uDtflPCBelpc6bh8xMQz/+qKpQpaVZhzceeOAZ/OUvn7DLLmVkZv5EdXUaAwe+wEEHjeGbb97g++/fY/fdj6B79wGccsqtYde+/fY0rrvuCL7/vgm3O7ZJCOLXKI6FSI3gsMMuoHt3NV/Wr09dLoG+lxqjkvz8ftTXKza9XXZx7ns0UqURgD1HvT6nujq0qUi1eciOILgQeBS15StBOYmvA/4rhDg71oVCiKOFED8LIRYLIa43+fw8IcRGIcSC4N9YO402dkp5RN5SZSVs316C2x3O6llQMITp08/mjjuObj536dL5TJt2Fq++egd77300VjAuZEuXzueLL15k7dpfHd05GCeZx+Pj9tsVPUNVVeqqPxknru7T4uISTjnlr3i9uiq83gYKVMId1NUpW/vPP5fyyy8hQXDGGSeTm9sz7Ds+/3yW5fe7LWwULckngNCOzsp/IWUj48ePd1wY6PBGo2bwWLAU8VFHVVJX9xu1tdaRan5/Jtu3XwTAqlVHceihV3P11a8wceIccnK6c8st/4kqj7pixbesWDEAKV3ssUdsn1Ug0LLomsgdaY8eA+jXT/Xv2rXRgsCpxcuoERx44Bn885/LqKpSao9TIZ6RbAOpQiyNbPr0c7j77pPx+1VHtjdB4AWGSilPkVKeAuyGWhFGogSCKYQQbuBB4JjgNWOCJHaRmCWlHBb8e9ROo42dElmsXsdQd+16DGPHzuCpp2qYNm1ZcyjewoUfNdv+Fyx4m08/fZbXX7+L7Ox88vPNSUq0SWnevFJuvbWY++47leuu24vXXnNuIYmMsNC7kqqq1JmGzDQCgKOPvpHMzC2A5KCDGujatR9aCIRQBUziqaeUKcbtNp+UVtqUEIIzzxxPenr4Qt3SfAIITeTiYkXzHVlPAaCqqopJk5z1FTQ1hZuFXn1VLZC9ekFDw+1cfvkA3nlnmuX1gUAeV189kV13raC6WvDee4IBA/bj73//P2666a+8/LKMylE466y7GDBgKqB4dqwghNo9t4QMzsw0EcthHLlJSxaRIc5r1ypncX6+c5m/AwfS7PNzmifJiFjaxpdfvsT8+a/g9apBVFXVvgRBbynlesP7DUAfKeVmIJYCuD+wWEq5VEpZBzyHQ7WOjUlQkaGjWhCUlb3FHXccw6uv3sG8eaWsXBkqjK5t/+Xl6+nVawiDB6tEH2X7D58pOpRUOzwbGmqD313TIsdmJCLVbr2YpZKO1khf0dgYyh+44AIXW7cW0b17KZdcYp1cB8tZsqQUKcHnW8ILL0TvC6zs9FJKbr99OlOmzKSw0Ll8AghfHIqLSyyrgq1Y4ayvwBjrXl6uBAHAuHGQkZFOfn6/5qxiK4wYcRJHHrkZgLfekixa9A1SdmXZshuYPVtw7bXlTJ9+e3OGd0VFHkuX5jT7a6zg9yefP6ARKQgqKspYt+5NIFojUJ87kxUbbhqiuRazU9pAfr6qC9C/f2q1AYj9DC6++EmuuuolAgHV0a2pEdhxP/xHCPE68Hzw/SnBY5lArFLxhYCx7NIqlBYRiVOEEIcAvwBXSimjSjUJIcYD4wH69u3b3CmR2gBoQVBKU9MlALz33kM0NtZTVxcuMerqqvj669eYNm0ZoBbBDz54jMid76GHnktxcQmXXloU5fBsqWPTiEhBcM01fYCVVFVJ6utFSkxDxrR9s6LzW7aM59NPYzuQ3e7xdOu2gXXrXueddz7jrLPuDPvc6trCQqV9jR5d4kj/GRE5ma3a0Ncq9TZJGDWCZcvUIjhokGTIEMGQIbc2x7/Hw9y5Y4B/UFlZzOrVx3HssUt5/XWlMm7YkM2GDTewdOmvXHklvP++uubgg2M7OZ3Y5brd4XUfamoq+eqre4Fj2bo1etHXxaJyc6NulRCMGsHkyUeyYsU5wDkxneJ2IUSIrTQjI7aj3QnEeg6aklzXSDcGwrQHjeAS4AlgWPDvKeASKeV2KaVNomZLvAYUSSn3QuUk/MvsJCnlTCnlCCnliG7dujUvYGbe9x9+KAXGI6XKxti2bR2VldGFZCB8pztr1iQaG6MzgebPV5k/Vjvbljg2jYgUBLW1FcA2QLB1a2o1gpoa+Ne/Lo8SdPX1Vc11BKxyBRobq6iuvoN+/coYMiSaBsHsWifMP7HgdofvvMzakJGRweTJzrZB19OFUOTSunUv8/PP/7V9j+XLv2Xx4s+AWwB46SV47z31Y665Bvbaax1CwOrVQ7jllgbefVdtcI46KvZ9nUruMmoFOTndKS5WcaqVleZj1InaD0ZBsGLFd5SXq8KITmgE2dnhc6+lWlM8CBHfGd3unMVBO/8HUsoXpZRXBv9ekJGhNeZYDRhpr3oHjzVDSlkmpdRWz0eBfePdNLIqWeRn69ebJ5OZITe3gGXLFlBTU2m50G/ZsgawjkBpqWNTI1IQ3HjjO+Tmqu3Dtm2p9RG8+mppTGGpbe1WKC/fyB13LOCGG96O+kxfqx333bs7Y/6JB+PuWLchO7sfIPD5+jFt2kxKSpxtg1Ej0IKgvPw/fP/9XNv3+O23/wFw8MG9GDNGHauthcGDYZ994IbnPwnaAAAgAElEQVQbejJ9upthw6CqykNjYzqBwM9xd7KpEAQ+XzqnnXY5oASB2WLV0gWsoSE05xsaYMqUBfj9asPhhCBoqbaSDKw0t/Xrl/D++4+wfPkngBIEWiNINfFcTEEgpWwEmoL0EoniK2CgEKK/EMIHnAnMMZ4ghDDGMJyIqn4WE7EEwYYNIKW9HbraIbq44YbhzJhxvuVCr4+fccZkvN5wvc7Jna0Q4cJg111HkpOjZu+2bamNGnroIWunqXaUFxeXxHWmW8EYpvvaa8tSLgQgOrS3uLiEyy5bBjSx++6/cdppzrehqSm08K0KFnA99NADOf74q23fY5dd9ueEE67lgANO44QT4JhjlIZj5NnPzYWrroI99lC20SOOiO+VdcoBGuknMPqyIuk9oOXJUEZBUl8PjY29qKnxkJPTslBYjbYQBFYO7oULP+bRR8fz9ddPA0oQ6DVOytSwumrYMQ1VAt8LIR4TQtyv/+JdJKVsACYA76AW+NlSyh+FEH8TQpwYPO0yIcSPQohvgctQNBZx7ht6HSkInnmm1PInBQJd8fvVE+jatQ/jxs0kN7cHQghycnpaZhprzqHi4hIOOeSc5s+ccmyGf1/4ez3JUq0RbNhgLTyNnEtWfXT44eNZuPBjKis3x/y+rCxrIjSnkZcXHSEzY4baYq9YscLxHZZmx6yvV/+1IDj99DH4/fbjjPv02Z2zzrqTESNOQghVKe/JJ8PLpW7cuIwvvijl7LOX88ADcOaZ8Ut8pkIjAKisXIYQkupqRYdiRujXEq1AL346c1n3a9++LS+HmZaWelOQGawc0kVFwznkkHPZay+Vi2OMGgJzn6hTsOMsfin4lzCklG+i6hsbj91ieH0DcENi9wz9NwqCTz7RRHPRM9zny+Dcc/8ZxR9kxiekM427du3Lqafexi677N/82dixD3PaabdRX/8rxx9/cCLNtgWjRvD8839h6dJi4EjKy1PrI8jP78vGjdHO1ECga1gf6ddPPnkp27dvIS0twNixM5gz505mz57EfvudzFVXmQ+VzEwYMiT1Jfc0PB5FHLY1LJxBzaraWul4f+px2dioBPf27coW7MSuNXLxffPNe3n77fs57bS/8Yc/2CtsnypB8Nhj45HyGSCfqiqVWBZZKrKhIXkmT2OE4JIl83n11aXA6fSITtBOGG2hDYASPpHU8wBFRcO4+OInAXjqKSUEqqtVH3g8Ice70/WgwYZGIKX8FzAb+FxK+S/953xT7MGM810XmDHzDcQjkTPCaMLYd9+TmDHjHK66alAY51BOTncOOsh5IQDhk2Xhwo+oqVEBVBUVqTEN6V2W2vWHqyNaeEaiuLiERx/dzLPPSp58soLi4hL8/gAul5uuXS0qoaCoH1pLCGhEah8XXnhv8Hi/lNAkg5q02j+QlraMjz92fqrsttthpKdn0bfvXrbObwm/UCQitdY+ffbE61XzrrJSmWcjF7iWaARGR/Hy5Qv45Rfls+vIgkCI+GGq2pRnjBxqakqdVmCHdO4EYAHwdvD9MCHEnNhXpR465HHcuHwefPCPKHdGNKRsahYC778/k2nTzuJ//3s95r1VKGmIB0fnHcybV0p6uoo5TgWMk6xXr0G4XNcBLv71L8XK6eTipYvd1NXBwQeXMGTIIyjiOBFGGGcHf/vbp5SWNpgKDo22UMEjd+MFBcqXUV8vHDcNmQmCLVve54svnre+KEmMGHESl1/+fFSRICs4SQcd6Ws4++y76ddP9WtlpRICkYlkLREE+jmpUNyD6N1bpSJ1d4DgxkmKmERh5Seorq5g+fLvTLOLwZxSxwnY8RH8BZUcthVASrkAGJCa5sSH3hm/8oqKe7eKdtEwOjLffPNePv30WT799FkALrwwj/POC7BixQ9h18yaNSmqWHtdXRUPPXQuEybsym+//erAL4mG1gjmzSvlk0+epqlpIyCpqlrODTc4S4mgFy5t083MPAdYxpVXNjFt2rK4QqCmporvv3+f8vLYRVM0UpmtaQWPJ3zXp80adXXOm9q0j6CxMWTHHjasP7/7XUwWlqQghGDvvf+vmaQsHpzse7N76d2t3q1GhnW3ROgaTUO9e++GlCo8qqWCIDOz9TXUyO83w333ncr11++NEGrFj/QTpMphbEcQ1EsdlB9Cm5esfOih+CUSIwvM7LbbYRQUDKZ/fxWlWlW1ldra7aSnh4tnq1DSpqZGVq1aQknJ4Y5lFBuhBYEZfXJNTRU33eQcJUKkINC2dLvq8p//XMCUKUfyySdPxT3X7U4Nv7sdGCmKlyxR8fybN29NiUagFy2tEfzf/x3OgQee4ewXJQEnNQIzzU6HQ2oBECkInNIIpFSmJ2i5IGhLbQCsNYJevYbSq9cQfD614ldXhzvgNZ+V07DjLP5RCHEW4BZCDERF93zqfFMSQ6xIFzD3DVx44fSwc6699g22bFlDXl5h2PF4VMxr167ixhsVPXUqooasBNHKlc5RIhiTyQCWL18D9KKy8icUNVRsZGd3o7Z2O1VV5Zx9th8hBPff/1sU6Ry0jVlIo0sXJWDr66GpSdksmpo8KfER6D5do8zYYbUR2hJOCgKPR41TvUtdsOBtvvxyFTC2WQBEFopKduEyhp7W18Onn35Iff1hBAKSjIyWeUzbWhB4vSqYILKvzj33PgCmTlUsCcYQUo36eucpqe1oBJcCuwO1wLNAOXCFs81IHFZx/6A0gYsv/ldc88bw4cdy+OFj8UT0aqxMWg1NL+Ek4tEn9+7tHCWCXgirq/UuQzk+/H6L6toRuOeeXygtbeCEE66loaGW+voaAoF803PbUhAIEdIKBg7cN3gsPaqQSkudcJpnSEcNCSHZuPG/lJVFMaa0Opw2yxnv5/P5qa9XKpDuw9racBOGMSksEUSy4z799IMAdOlSa3GFfbS1IIjXBt3HkRoBpMY8ZCdqqEpKOUlKuV+Q5mGSlDJF5b/tY8wY88U6EOhq6ehsaKhj+fLvmgm7rKAzUQOB2EHvTtFLaGjTkEpeC9/G+f0ZTJrkHCWCnmR1dXpX4sflqqaoaLCt6z/99FkuvbSI88/PbK5KduWVu0ZVdIO28Q8Yoc0IXbqoF1K6w4j8GhtVAfmWRGbV1an7bN1KkIRvO7ffXszcuTNa2PqWw+n+Nwr2XXc9gNNOuxIIF6aRO91kTHFGTaKhAbp3HwVAQUHLtsOp9g9oipN4YZ6xBIGRZqI1BEHcHhVCDAImAkXG86WUhzvfHHtobIQDDyyhsREefPCPKMbQvpxxxuSYppoPP3yMxx//M35/gEmT5vLEE5dSWDiUP/85OsSvuLiEYcOOY+7ch3jnnWls3bo26hyn6CU0XC41iLQQKy2dxNatK3C7+3LDDZM56STnzFBGznztH+jePZ2MjPjb90iCOinVzcwqukHbagSgFsLMTGW71mYi7TB2u2nmcmpJvLsO89uyRb3Pyqqhb98D6dYtxSxmceD3O++fMT5Pn89Pfr6SNEZBUFkZXgBex8IngkiNYM89L+KXX+wLArcb+vQJsZXm5CgfWCr9VV6vCm31eNQY02ZCM5gJgoqKMm655UAqKq4GLmrOIzD2X1v5CJ4HZqC4gFLMeGEPWkIWF5ewaNE3vP/+VNxuyfHHxxbB3bsPQAiBx5PG4sVfsnTpV6xduwgLrjsCgVxGj74BKSWzZ4ebgRKhlzAyNsaD368WrOLiEoYOLWHCBOVYOvJIZ3cC2v7a0BCiBsixSSQSr8D9rFmT2pUgABVKqmzYtUAa33zzDf37D6e6OrSAJSsIjGYhLQj69s3nmmva3JWWEhNI5POMdBaDM36CSI0gUUdxfr5alNeuVc9nwABn/SVm0EIAlMCJNfc9ntAGRSM9PZt1634FlLVBk/bV1IT6uU1MQ0CDlPIhKeWXUsqv9Z/zTbEPI6Ph73+vinL06iXi7jj23vv/eOaZJj76aBOHHbYPBxzwf4wadXrc5I4TTyxh+PADSEvzJ8yb73IlFuFgTJTR7aqqUuUqnaxLUFcXcvgtWaIGXW2teWH0SMQrcF9WtgKXKzTp4pkmEsmUzMqCwsLEsyt1NFRDg1J/PvjgfTZtCjcJJbvT0huThgZ1P3Amo9gJpEIQRD7PefNUsZ3y8lAHRvpcyssTX8DCS9I2sH69Gvx251OPHmqc9O6txkwqhEB6eqggfWZmtNYTb2MRufnyeLzce+8ixoy5EQgJVKPDOFmfSyzYEQSvCSH+LIQoEEJ00X/ONiMxGAWBri1il1p+l11UJMmhhx7Ms8++zT//+WhUSjwo6ZuZCbNnX8L55w/km28+Jz+/B/fc82/mzbNPnJafrwaL3Z1mfn7o3Asv9AH11NWJ5l2DU7uBurrQvRYu/BmAVavet9nG2J3dtWtfunSB3XdX2b3xFm2zCZqREa3Gp6Wp+3m9idu9AwF1ncv1ElDEY49dywEHFIWFAScbUqonqVEQpCrpMFGkQhCkpYXb2H/9VSVoVlSEdim1teH0HtpMYsZFZAX9PGpr4aef5vHLL+sAe4IgOztE95yfn7oIri5dQhnsZhp1PDOU2TgZNGgwvXqpXaDWgiL7zWnzkB1BcC5wDSpk9Ovg33xnm5EYtCBYv34J77zzEaBsgbEghFINjXHlGtnZ4Q+xa1dF8rVkSSlz5sykPrhirl69PKGqZF26hAajXfOIyxUq/6dq+ipbg87WdEIQ6Lq6oXv1DLbXnu01VlSVzt3o2lVNgl13jX+/yEXd71fPKTc3fNIb6XuTMTd9/XUpjY0TgeWAjHqeLdUIjKahb755hLFju/D1168ld1MHkJaWOnu4sf//8IdLAaiuDh8/S5aEj1cpo01GsaCfx/btUFlZBfQCGmMSFwYCaswZx50QqeHnycxUm4vMTDXXzfo63gZQbziNyM4O1ZZep2Rfyh3GdqKG+pv8tVlmMYQEwXffvcuKFWpUDIjRIq8XdttNLSoHHdSXAQPc7LVXLv37C0aO7MUrr5TSr59afLp1U1oDwNSpk2hsDF8d7IaN5uaG78biFaMwQi9+M2asp2dPJbm0Hd+JAaDvof9nZ+8JwEknnW/remONAaC5JrCmpjj00JJmwWpnAmpbqj6/W7fQe21HjeRnSaQ/NZ54IrpWhfF5JiMIjMVojM7ipqaVbN++BZGKFcgmUhkiaRQEv/udKk5TVeUKM1nU14c0do1ECtVojaCqCnbZ5VgA8vJczaaYSGRlwdChSgNIhQCMfJTG5EurvrZjCYjUcD766BnmzBkXDEFW49Isl8BJWG4BhRDXSin/EXx9mpTyecNnU6SUNzrbFPsI2WT7A3vgcpUzdKj5kwgEYNAgY7LWeqRsoqJCrawbNqy1TA6zCg+NFzbq9UZn6Kalqd2+HRu/16vbmx1GRQ3OqIR64dL/E3UWgxIGkSG6Ho9qX5cuWE5WM7jd6jfX1anfHRnap9tlvKfHE4oAsov162M/z2T6tq4unHlUm4YuuGAS3btfTlpaiovgxkCygiA9XV3b1AQbN5qfY9TiPB71vqZGLfRGIR3JO1Rfr/7iLZDGZLKqqpCZKSfHXLB266ZYT1MZFpqVFfo9aWn2Fnk7Aik/H5YvD60NCxd+xscfP0ogMJXKyhzWr4/e+LSmRnCm4XUkVfTRzjbDPoyJQLW1qhkHH5xt6ij2eFRlJ+PDyMqKXu2sdvlW4aHxwkbN0seFSMycoc+NFARODADjDhZg0ya13WgpG+MuuyiTWkFB/HON0IIAzG3/Pp+58zVRrUCTzkVCP89knHCRkS1aI+jePY2srK74fLGdGb17p27xsvM8tWlD938goJys6enquJWPx9j3a9b8jMejvMOR9BK1tdGbHztagdFfYyx6Y/abhgxRY8/pbFsjhFDfrZ+V3bHn8cTXit3ukJ9BCDjxxDOYMOERevVSX7ZuXTQ/lhMlQI2IJQiExWuz960GY2d89ZX6v//+5uf26xcttbdsMSdJM9vlT5w4mfT0xOrtulzWPCLa0WkHGRnw6KN/4qefXgFCrIO68ElLECkIVq9W26133725RffNylILSaILtMsV6heryA6zSR6rWLsZJk6cjBDh0jjyeSbqMA6PbFET1Ou117bsbCUI7PhREkVGhr2x1quX2k0XFirfVH5EcnhWFs1mUyOMm5qvv55DZaUiYjTL0I5ctOItYkZfS2OjEiYff/xO8H1YtVtT7TsV0Bq9HtuJjHE7z0E7jTMyYP/9iznmmLEUFalBpP0EWtuEUL84hViCQFq8NnvfatCL4KZNsHQppKVJ9jKhZc/ONncM5+aah3OY7fJHjy5hypSZFBb2sx02mpVlvQPQjmA7O8CMDFi79hcaGtQo0IJAysQiLyJhLHmn+HdASrUd6d7dQoLZgFnonF24XCGtLZEQP683sfNPPrmEPn1CdNtmzzNR85BRQ9NmlLw8eOqpy3noofPYtm2D5bW65m5envJxOakZ2Fkcjb4ZiB2JFdm2tLTQtf367U1Ojlrt7AiCmhrrqnu1tSq6SF+jNYw1a9RmxesNqzTUajUFjBq615tYvomdc3NyVB9rAeP1hjTrtcFc1pUrw/ssEcd7PMQSBHsLIcqF4kPdK/hav9/Tzs2FEEcLIX4WQiwWQlwf47xThBBSCDEi3j11R3zzjfpfW/sC998/Ouo8s7CsV14pZevWLVHHvV6f5S5/9OgS5s1bxtKlTbbCRq20AQ3jw46F9HQ48cTrGDJEEcBt2xZapFqiFhoXrro6eOutUmBXwMWHHz5oShFhB4n4F4zQC4yeXIkuhvH6OxI9e5YAy/jLX8yfZ6KCQJ9v9A/k5cEXX7zAxx//i4aGurDzCwtVEfqRI8PHQffuMGxYck5wM9h5HokI0Uifj9HUuddeRzF4sKqlaSYIIjcuUqod/6pV4eOxulrtfo1amV7s+vQ5EoD+/cMJIpMdd4lC/1a/P/ExZ8dP4HKpceP3Q2VlBV9++ToVFYoKR2sEtbWqApyGk+Yhyz2clLJF+xMhhBt4EBgFrAK+EkLMkVL+FHFeFnA5EJsAKAgtCFY2c3l9RmZm9LbATDWfOnVSMx2CEZmZWY6wiGZk2NsVZ2TELzCRkaES4DZsgEWL1MTRaeYt0QiME++DD0p57rnx6EiasrIVphQRGkIoM0ZamprExjjxZB2TeoHRDsdEkZmpFmC7iXZ6UlpNomQFQWQOwXHHPUhV1VayspS2lZYGAwfGNhl5vSoM+uefE2uDhl7Y6+vtLVYtEQSgFke9UOvfZSYIrHauTU0qTr5nT+WE3RZJdm+4trFR9WNBQfhcbw2NIJJGPRWCAJQgcLlUQMtNN51Aly6/Bz5sFgSgtAOtKdTV2afuiGdGSiC2I2HsDyyWUi6VUtYBzwEnmZx3G3AnYGt50xNec75fe+1Uxo2bGXaOVSk4q2ifbdtiF123C7uLod8fP6pGZ+bqgb51a3i0T7LJT8aF67nnJtHQED5LNUWEhibQAmW+6NpVTfqeEWzTiU4O4/1BPbNEbf76ukQEiJ6Ud901nuXLl0R9noi6beSGN9q18/Jgv/1Gc+ih5+HzpZOTA3vtZe/35eUl3w+DBqnvKSqyF7XlhCAAkFKSn69WmvffjxamsXau9fVqU2EmBCC06TFzFmdlpdZBrBE5vhKNCE5EEGRmQn5+Dw444BiGDdsNtxvKykILuZERAOyP13jaQyoFQSFg5OBdFTzWDCHEPkAfKeUbid5cC4LevV14POE9HQiYP6xko4DswOezvyDZXbzKyn7m3XdvAtQiY9QiklULjRWfrKgiysrUcZdLRWTsvTcMHx7uc8nJCQ3w7Ozk7dvGBSZZCoBEvlt/R1OThxUroik1Qmys8WEVMWSMcHK5Erf/282SN6J//xCrpp3MW6OD3g7M5pMWBFVV25g9uwtC/Mby5fBaRA5dTU3sAIdYn+lxvmaN6txAILQKtpZZqKU5CW63veevfWWBQBb33/8m48Y92PwsjSYh4/i0W7qyLQVBTAjFXXwPcLWNc8cLIeYLIeaXl2+kokLtEDTlQCSsdlTJRAHZRTy+okjYsQVv2vQrP/ygKoBt3RqudicrCIyOYiuqiK5d+yKEEgJ6px+5SOvEL48nlICXDBLJN3DiHnpSH3bYxQwffqDpOVu3mh6OgpUgyMlp4JNPnmb+/Dn07p24gMvOToyryO9PvGJXom0yy87VgiAjI4f0dDdZWSq16KWX1C5WQ8rkIlwaGnRAQxPl5erLjXkErVVTwAmOokSFiRYcWvPWDmMIXwfq6+OvBbW18S0IqRQEqwEj8UPv4DGNLGAP4D9CiGXAAcAcM4exlHJmsBbCiOzsbs3aQEPDAv70p26sXr0w7HwrQZBMFJBdJEp5kJERfwEbOnT3Zpvotm3h6nNVVcs43l99tZTq6miDrqaIGDAg/kTr1k3ZvVsyUZyIlElGI+jRY08yM80HSl2dvUI1kYJACxC/fzvTp5/NzJkXJJxToVFUFL7wer3WzyOZ70jmmUWO1/R0HSUnePzxch5++Fn22Uf1xXffhZ+bTIRLiHmzAchFiIbm6KRkTYnJwIks5URZbd1uyfbtW+nRQw0yI511ZF+WlythW1ZmvibY2TSmUhB8BQwUQvQXQvhQCWpz9IdSym1SynwpZZGUsgj4HDhRShmXx0gLgsbGb6mo2BTFexNrgCQaBWQHydTkdbniq7b9+/fnnnu+IytL+UY2bw7trKRMrqpWY6OKnpo8eTzbt5eFfaaL+px+eolp6G0k/P6Wq+dOaATJCIL6enjppVKKi4sYMMBFcXE4AV1ZWfwJFJlDELJjSw4++Cx+97uTk+a4SUtTOQYa/fop808kPB7zMOl4SGZxM4scGjw4XBveMxhP+NNP4edu2pS4VqD9A9u3q8bm5Xma+zMry5mxEw8ejzPfk2h/X3HFSYwdm4eUPwKhNQ+ik/aqq5WgqKiIzuS2y++Usq6UUjYAE4B3gIXAbCnlj0KIvwkhTmzJvVetUv/3228Ip5zyl7Caw2lpqeccj0SyfPvZ2bF3CnrweL2lQBEXX+zi978PLVh6J2AXOnN26tRJ1NZGjw6/P8Axx5TEJfBzEk5oBMmYht58809cf/35rF69HCmjCeh0ofS6Out7GSOwtm0LmYYKC3OZMKGU2257JMFfEo7CQmV2y8sLsdgaacpBvU9moUpGEJgJNY8n3KexW7Dc9U8/hY/NzZtVyPeW6OhtS2hBbEaBkmxwQqJwai1JtL+7dOlKenoW2dkqAdYoCGprox3yeixWVIQCaioq1HWxxrBGSmWqlPJNKeUgKeUuUsrJwWO3SCnnmJz7ezvaAIQ65dBDR3LqqbeG1Rw2o5RONZKN/dZp61bweuGVV+5ky5ZxaMbMdetCC1ZjY/TuIBb04LGKniorW8Guu6aGqdEKra0RhGrBzqahIZyvI5JqREq1kzUuaDU1avelQ/dA7bjKy9UE9XpDGwMnbNjduqldt4bR55CWlhy9studXLSN1bPy+eCll27n+uuHs379HAIBtfBvMMml22Se2G8KLQg2bFCD3Ogobi3/gFPkdV5vYvPqjjse5fHHyznqqCMANeaMIdJW876pSQnbdeuUVms3HLrNnMUtQShiKPx4fn7r88AnGr4YiYwM6wHidsOsWdcjZbiNwrhgbd5sn39IDworzp1u3fq2ujbV2oIgJHjNPcKRQlKX8mxoUJNv/Xp1TFe9AvW59g/k5kJjYz1CbENK50tJeb3Kie/1qpyOZDSqZMtxWj0rrxe2bFnD8uULKCtbFqYVRGLLFvs5H1oQ/PSTSqxYu/bj5s9ayz/g1HwQItFsZDcul/qdublqzBkd8LE2gBUViecadThBoG3lHk8Tjz12LE8/fU3zZ22hDbTUVhmLjC5W3QO9YDU1qcXJjuNYC4IJE6LrCfh8GYwf3/LoqUTR2qYhHYXh8dgPJd62TZkjN24MaQdShl5HCoKFCz/izDNzOe+81HAzpqerfIFkzSPJLm5WGxaPB4466k9Mnjyfww8fz9Ch6riZINA71ngwUqlUV6sJkp2tOjwQSC3LqIaR+sQJJNrvWmsrDFq+tUkcon0BLUWHEwTa3uXzzeD779/ijTemcumlRXzxRWnSO51kkZbmTElCM9PSK6+UNtNjm8G4YOl6rvH8BVoQHHJICeefPxPNudO1q6ojcPzxLXecJwonNAIh7N9H29gzMqKFYVpa4qHEjY1qBxauETSQkREgMzN1huyWjPVkF7dYfbzrrnsxYMC++Hx+dt9dHfvmG1i4MPrczTbyN4072sxMJVl+97tRQOvUwHa5kve/WCGRdm/ZUsbttx/NTTeNbBYERj/B1q2tRzrXLqF+fCnV1RObj23atJyHHrJfOcwp5Oc7Y083GyBTp06iutrc3W+2YNXWxre/akFQUQGDByvOnW7dmnjggWUUF5e0ulkInJtodu+jQy23bz+DkSNPIz9fhRLn5/fjkksSDyWurFQCOMSXD8OGHc1331Uwc+YrCd2rtZAKQWAcOw0N3xIIfMP27XDbbfDRR+HnbtmibN5Wu9q6uvCCNpHO4tYQBPn5zged+P3214vs7Fx+/PEjliz5km7dlI3MGEIKhFFPtBStkKDtLNROYVKU3by2VtnNnQgHtQMjh74T99KFPTRiFb+56CLzBWv7djVZI5PsNB+JjhqqqICffloGFFFf/zOgvJFt4R9wyjHtdttzjGVng8/XQF2dh08+eZXddhvOKafcyuDBxfTqNRApE2uTttUaKRDsZpK2BRK1VRsRSxB4vfDRR0/yww/vk56eTWXlTHr3nsOqVcfwxhtw6KGhc5uaQgv9oEEhv57mHlq1KvxZaqez9u84RcwHoXwEY4ZuorVD7EKbmuzs5N1uN7fd9gZpaf3YsEFNTKNpCFS/OFXPooNqBMlVDnMSTpfCi1yErWgvfL4MDjywxDK1vKJCaQaaj2jdOqVSaoenTkT75RelZ9ynwNAAACAASURBVJaXf2W4tyM/xTacVLvtTga322jOK+Snnz7k4YcvYObMsQnX1IXQ+UbTUGubKBNBS55xLAHp88H8+a8wb97T9Ow5kAkTnuL447fhcjWyapW1c3Px4pAP5ttvYdmycCFQXg7LljUBdVRVvQ84u0h7PGrjZOTOMlJsO41E2r7vvofTo8cu9OmjJsqaNeHm38ZG6wpykYgXQtrhBIEaJKnjDLILp3fPkQuZGR0GZDB2rCLYi+Vwq6xUg2blyhDPi16o9ISUUvVVQYH6IR5P6+9infw+u0LF7Yb8fKUI7733WMP1qjGJCgLdn0ZB8N//lnLGGYfyzDMzrS9sZbhcaucdWXgm0XtYweuFww4bywUXPMR++41mxIiTeOyx82hq+gIp4ddfza9ralJ+hFWrzHfKP/wA4MLr/RKPp6GZjNEpaMHo94e/ThUSEQR6Q5GTo7SW7duVsDQiUnuygpGryAwdThAA9OoV7dBzijPILpzePUcuipoOo6BA2bCF6AfMZO+9lUlo48bkKCb0wtXUpLLGjj/+NKD1zUJOf2ciGkFDg0rQ+/bbq4K+gae5+eYPAPskXqAWMR3iaBQEmzYt5csvP25VDTUefL74CYzxEE8Q7LPP8Ywa9Se6dSsiLS2DESNOpqBAxTwmQ639/vszefXVrwHw+T6hqGi44yYbY3/oDOlUCgJd6cwOtm5dx6xZNzFr1o0cd5w69tBD4c72hoZwHiIzKILJ2Od0SEEwYkQJOTlalxN06+YcZ5BdOL1wmiX4jB5dwgcfLOOZZ5ro3XsZUNLsMKqvjz8AzKB3vHpgaHqCthAETk5qu5Pr9ddLWbx4PDpBb9Om5TzyyPjmgjwbNtiLaoFw7cEoCI477jyeffZDTj31PLvNTzmc2LjYcRZ/8cWLPP/8raxc+SOXXfYsY8acAMAvvyT+ffPmPcOKFWqe33zzDeTkdHdcEBj7JTNTmYRSPRfsCmOvt4lXXpnM3LkzOOEEyR57KFPZY4+Fn7dmDfz2m4rSMqOdsRNR2OGcxaDS7seMCa2CPXqY87CkCqlwBlrdTw+awsIVrFzZlylTHuGpp8YBagB0757YJNcawdq1tUAaQqwE+rS6IGhpIl4k7D6Pu++eRGOjeQ0GXYxn8WIYOjR+nH5IuwpFwOTkQJ8+fejRoxV5OmzACUEQy26ux+lbb93Hzz/PIxDoQp8+uzNokDq+eLH9Iioa++57HYsWFZKV1UjfvuoBp1Ij8HjU80t1Zr1dh/GAAQWccspf6NVrMEI0ccklbiZMgAUL1NjTGoyUIdPP0qWK70kINS63bVOfxev3DqkRRBb7TpQCuqVIhVPVaiFzu9VObPhwZbOorx/dbBM0Rl/YQU2NuqahAcrLvUAjr79+OZB6R3Hk5EoklM4OdP/FE2hW5ppNm5Y3v25qUslQ8RxxWhCUl6trAgE14dqjs9iJNsXSCPT4GTBgBPn5fTnooDEAZGU1kp9fS10d/Oc/vzJ79q3Mnx9imPnuu/dYvXqR6T2FOAaAYcPczWPFSUEgRPQC2Ro1DuzOtbQ0wR//eCsHHXQmLpeb3FzF9tvUpH0n0aiqUg73pUvh66+VSa7NuYZSgawsyM0N5ah7PK1PK5GK3bMQ1sLA54ORI3chL28r0I3vvw99tmmT/cgBvXCpVHUXsIaCgiIg9epw5E7L6Z2dXqRyc2MLmFgBBTU1Ib1aSliyJDyJB0KZ7ToCC6KrZ82b9yqPPHI3S5YkWXMyBUi1aUhvWM45516mTVtOTo4qkPCPfxzPpk3K7PbYYwN5+eVzmDfvXUBVNps580ImThzKb7/9L+qemsp6r71Cx5wcN2b8P63Bs5WIUI7kVBo2TP1fsMD6mvXrlTkoER9ihxME3brBG2/czZgxLq64YiAFBa1Trk4jMzN1zIexBEFamp9Ro9RK89//hn/+22/2ol30OVpwDBnSh7PPvgdIvSBITw/fbTktCDSRWnp67Ik2cWJ0RrHH4+PEE2/A44m2Va1cqUxw27erfvv2W2Xv/vprePvtUi69tIjrr3cBRYBa8N58899MmTKRn3/+Pup+bYFECc+sEM8PYyZs+vbdi7y85/H5PgfKgV3w+y8DlODdfffD6dNnT/r1GxZ23dat5fz0k1rJNLU1OGtObCvNLRGh7HKVM3/+HD77bDYQEgTffpsY83Dc73HuVq2HtWt/ASRNTQ1RtXMTQaIJTbm5ShClKszSSqDpgXPwwer//PnhyWdNTfDjj/Era2mNQAsCYyhhazjIcnKUIO3Z0/lJ6HKFBHSse48eXcKECeH0Ghdd9DhjxkwJY7E1YsUK+P57pSFo2+4nn5TyyCPjgyYlCSxnzRrldB416kQuvPBKBgwYbHq/1oZTZr94c8Xse848cwrTp7/FQw8N5fTTVY3on38ehJSQnp7FxRc/ySGHnMMDD5SEaWSffbaShgY3Pt+i5g2E0/H9bSUIXC77a0h5+TLuvvsknnvuBkBRfuflqfDxRMzCcdvk3K1aD2PHPszddy/i739/OalFOTcX+vRRndqvnz0fg9udeupbq9+iF+kXXzyftLQF1NYqYWBEYyMsWqTiiiN3Cvq91gh0pqYWBB5ParUqbTbQ5S1TEZ6nmRoh/gQfNaqE3NxlQBOnnrqMjIzEo81mzZpEXV24GtbUVMXs2ZM45ZRzuOmmexgyZE+Lq1sXTvp/4oWQRp+vBnVGRg4nnjicvDyV5LjI4Bb4+OOn+Oyz51i16sfmY0uWqPT4wsJQ2XOnNyutnUCZzHcPHTqU4cP/j5EjT6WpqQkhVA1xgK++in1tIuiQUUMul4tevQaH8bTbhfIxhB/LzVWLZCxVKzs79RWRrASBNqP873+vUVubDkznv/+F4uLoc1etUppBly5qsG3YoGLjs7JCTqOvVWg2r746muLiv7PnnkMd/y1GtNbOS/dfvO9zu1X/bN0KDz+sjuXlPcDJJ7sZNepiW9+1aZOV07n95A5oONn/Lpc1jXR2djhVshGNjQ1I2cT++9fxzjsBnnhiM4MHl3P88X054YRraGioJz+/qPl8HTZaUjKq+ViigkBXATRLvvT5nKWqSBRer3UFPCFCa5HX62Xq1LfDajuMHAn/+Q/MmQP77utMxGSH1Ag0EuUkz8gwdyx7vdFagTGqxedrnYpIVrtyPWCLi89m770rcLma+O678BrGRlRWKrVx8eJQFTMd3rhypfqDzUj5Jjk5BY5pOsaJajS7tbYKbkcQ6GLv6rk3sWXLBN55x/4WMT/fuqbDkiU/89tvv1JnJ1yjFeDkTjrWZqhHDxV2GzmOr7pqMH/8o5fS0mtoalKSd+XKLsydW8R111Wy++5nc9hhF5Cbq6hhf/lFjdG0NJrDT5P5HdnZ4TTx2dmhTVUkH1drI5ZGEPk7I9emYcPgiCNULtG99yZXsjYSKdUIhBBHA/8E3MCjUso7Ij7/E3AJ0AhUAuOllCYs5uG45po9kLKRRx99niFD9rDRDiU0Yj383NxQpmjXrur8xkZ1rLV3tJFIT1e/4dxz7wXgrrvgf/+Dzz6DoxOkvP/0U/X/wAO9jBo1l0Ag17GQufz8UJRNRoYSQNu3t09BcNZZqqziQQfBo4++zeefH8vGjWdTVxc+SefNK2XWrEls2rSC/Py+nHGGyl6vqoqWwj5fBuPGTea8845m1aplfPDBL/TvP9DJn5YwnKYOiWejz8lRQtbIlHnkkX/i3/++iqKi4QQCXVm4cArbtvWlqmoPamuHcc89cMABSptYuzYULbTvvhKvN/SFiQgCIUJCICtLzeu8PHW8qqptEiiNiCUIfD6lvWvNKyNDsnnzWrZtW0///sMBOOccFSL6228wfTpMnBgtpKWUiOADM6sNYUTKNAIhhBt4EDgG2A0YI4TYLeK0Z6SUe0ophwH/AO6Jd9/Kys2sWvUjq1cv4txzj4pJPZ2WpnwB/frF3wF4PGoA9+0b0jScZBi1A6sJK0S4GqtNQi+/nFgN2E8+KWXOnCLAxY8/7klZ2cqw0ootgd+v+krb/zMzQ21ubUFgFh9uhNutfBWjRql27rvvFtzuIurq/EyYUNScZTxvXrhDeNOm5cyYcT4PP3wBVVXhnvnMzK6MGzeTY48t4aKLrsXlcpGdHaMOaRDdu6eWVtlpf4wd82jkXDv66Mu5555fOOSQc9l33xO4664bmTnzj0ybtgf5+coJX1oKb7+tomFcLuje/UXmz+/Bd9+913wfq8XbGBWl2VVzckLzKSsrnDK+LU1CGj6f9XP3esPXguXLv+WSSwp54IExYddfeaUav998A6WlTTz//Owws929957Cb799w9q18Ne/xm5PKk1D+wOLpZRLpZR1wHPAScYTpJRGRvJMVPhFTGzcGEr82bBhbVjBcSP8fhWdkuhuqDXr9UYi1uKVkQFr1/7Km2/eR11dKbvvrsw9Dzxgr/SfXtSamtSiVl6uqBW++sqZGg5afc3MVH2enh7SZNoiOiPWdxr7WfdLY6Pql4qK5Tz44B8577wA06efE+UQbmysp6Eh2uSTnh6guLgEnw/++MeLefHFz+jatVvMNmZkqL/u3VNnemwLQZCZGf69LpeLgoKBzbtTjbw8D9deCwcdJPF6HwGu5sILN3HffZCbew91dRvJyAipq1aCoKBAbeD0pq+wMNwP6PG0rWPYClZFrSK1uIEDh5KT050uXXrT1BRKDujWDSZMUHPszTddvPTS6Uya1EBFBSxbtoCVK7/n3Xcf47774peuFNLJYFTjjYU4FThaSjk2+P5sYKSUckLEeZcAVwE+4HAppQVPYfP5UQ0uLOzHvHnLwo5169b6GcdOYPlyc6f12rUwefLVvPHGPeTl9WLKlNVcf73yE4wZAyeeGPu+l15aFJY9q9GzZz8++2yZ7fa53WrgNTaGt7NPH/WZTmvXg3zTppYxXiaLLVusfShbtoRI0Kz6JVEIISgtbWSvvUTMcaejm+rqVL8YhVJNTfJkglYoLHRWEJeV2SPmW7Uqmj8/Fh599E+43V5OOul6unQpREpJdXUFPl86Ho/6ASNHRm/UfD7o1SuBH9DOsHFjNEV3795qjBqPL14s2bTJfJf63/9Knn76e7Zu7Ql0p6gI9txzNe+++yoZGSeyZUtvevWCNWvE11LKEWb3aHNnsZTyQSnlLsB1wE1m5wghxgsh5gsh5pt9HkkbkKrCEq2BWA7jmppKhBBs2bKGm28u4ne/U7v5F16ITzNrFc2yfr39KBeXS0263r3Dd7B+f2gHoyM1NFojZd8MsZ6/cWfpVJSPlJKLLy7g+ecfjHlet24qYKFnz+hn7fc721+pMG3ajZzLz1djxK4ZZuzYGZx//jS6dFF1GYUQZGRkNwsBqxyCVDKFtgYin7c2a0ZaMgKB0I9fv34JtbUhTfXggwXTp+/JdddtoGdPRTHx2muF1Nb+mS1beuP3w7XXxm5HKgXBasDIvNU7eMwKzwGjzT6QUs6UUo6wkmaRtAGJUL22N0SGtmrMnVvKJ588jdbgNm1azrvvjmfQoFLq62HmTOtwNICcHPMol5yc2PwcHk9o4czLCw1Q4wSP3AEb+76tknb8futFwigIrKJ/ksG2beu5++4bo0yVeXnKbp6fH3+DkpWVXE6H2W9NxSJp955+P+y+u/pzwlltZRbqqBs+DZ8v3Gyln33kGNDz7bff/sfdd5/MBRdk8/nnzzd/LoRg2LA9uPlmFUBy5JFw2mlwxRWS446bQSCwklhI5XL5FTBQCNFfCOEDzgTmGE8QQhhDKo4DYpqFzGBWh6A9OIOShdHJasS990YnMNXVVbFp0yQCARUVcOmlMHt2KFR03jxFgTBmjIvKygpU8FY4tm+vsHS46wLeBQVqJ2umBQjRfk1wVkJV01EAnHFGNOVEolBxEQqVleVhfiufT+36srLshTsLkbhWkJ6uNAxtnjMedxqJkgVqx7wd1NRsZ8GCt1m06BMmTx7Fc8/d2PyZlSBo6+gfJ2CcV3pcRgrPzEyldX766bO4XG5uvvlDRo48ldWrF7Jq1U/NG8QuXeDcc+HCC+EPf4DCwoW8/faN/P3vpnvsZqRMEEgpG4AJwDvAQmC2lPJHIcTfhBDaoj1BCPGjEGIByk9wbrz7pqVl4nK5EUJQWGheh6Cj7xK6do2ebFasmVu2rOD662HIEGVTfPllJRCuuaaUhx4KRbw0Nm5GRemGo76+jqlTJ0Udd7uVENA7erPFXjs726v25fdbLxR6Z1tcXMK4cTMJBJILLHe53EgZ3q/V1VXNfZoMIWIgkNhuXueBGMtw+nyJ59nYQTJ8/T162DtvxozzuPPOY3j55dv54Ye5LFv2TfNnZt/ZkTV/I3QdBAjNt0hB4HZDnz6CkpK7uOOObxgy5HcIIXjllSlcc83uzJ07w/Tes2ZNoqmpkTPOuDVmG1KaRyClfBN4M+LYLYbXlyd6z759h/Duu6auAkAtTO2RBjgRuN1qkBs9/b169WX16minppSSO+7I59xz/8mZZ5YwZ47KMVi1ahJgr+5ipJDJyFBmjHiTrCNoXn6/Ofd7WlooEae4uITi4hLGjIm11XUTKUg9Hp9pBBGoPk10QdfQVBxr1oQcx/o+kdEfaWnhG59AQGmEqUyY8vvjR6EYkZ6uhFVlZewItz32OJKNG5dxyCHncfjh48jO7t78mZkg6Oj+AQ2d61Bebq0RgPLNpaWpcFuNrKx8cnN7MniwCc0AcMUVz1NfX0uXLrHV9g4nT2PZGwsKQhmjHR2RO3DzGsYKlZVlPPzwBWzcWMo116iQUrDvBDX6WPx+tQjZ2WnpENH2DKtNgdnCkp/fz/RcVc7yX2FaQyDQlYsuetzyml69+rZoMdYaWUaGaqtViKnZsR49UmsySWYB3m032H9/FcVkhSOPvIjJk7/i4IPHMHLkqQwdekjzZ2abjo6wEbGL3NzwWhZWfqJu3dS5Gzb8xtSpJ7FmzSKmT19Dnz7mibVutwe/P77ttsMJgkWLvubgg/tG2bWNTs0dAZGDXNcwdltIwoaGOmbNUuYI5Zi05wQ1+lh0Ul1b5lI4Dav4cbOxYuYv8PkyOOOMyRQXl/DII5t49lnJs89KHnlkE8XFJabXpKdnMHny5Bb3o8+nnkdBgRLMZmY4M0GcKnZcjZawgPbsmfi1+fnRG6Mdbb67XOp3akEghPVmrE8fCAS6sGDBW/zww1yqqrZF5Wgk/P0turqNsGbNyqhEsvaYMNISuN3RO6/Ro0toiqFbl5WFtIAzzpjczPxohUgfS3r6jmFzNcJKIzDb1Wp/QX5+P4QQ5Of3Y9y4mc0lLM0QeU1hYT/+/veZnHuu8/WzIzPMIzNQWwuRfoJETLFer33nMajf19dkT7MjaQMafn+4JmD1bDMzoW/fHK688kXuv385mZnxM9jjIWUJZamCMaHMmEiWm2sdJdJRUV4eXUi9uLjI1FcAyoQxbdqy5vfnnJNOfb25Mbdbt358+eWysGNdu7YOuV5rY/VqRdBlRE1N7CpPiSI9PUQP7PEoe24qUF0dyhnJymo78jRjwp7mx7eLmhpFRR0IKK6cWAl0u+xiLjh69txxfARWWLfO2hejiSTXr49eI8yQkQEnndSOE8paAqOTc0dSEzXMBvrEiZPxWmzBamoqefzxPzNuXD5jxgjq62sQwoXbHX6+JkeLxI6mVWmYdZfT48VooknlLj09PdT2tlwIjf0XuZONB78fioqUKWRgDE6+3r3NhYCZtrwjItY40mHGgwapGu4trSfSoQWB0cm5Iy5iPl+0qWb06BL+8Y8nyM2N3gpWVpbx3nsPUVkZIoWXsommpiYCga5h5o4zz4w2XXT0aCsrmI2NZMIgY8HIG5Pq0qn6u9qDIBAiOikqEeTmqoWsW7eQMPV6Fce+lVa1MwgBsD+O8vMVNbXdMF3T70r+0raF0cnpdreNrbQ1kJYWnTE8enQJo0eXxDQTGSFlI35/gEce2QQo52OkCcjj2fH8AxpWAi4QUAvQ5s32aj5bIS0tnE8p1WNRU1G05ZjXc87jCQmDZPswPz/Uf3V18efzjqj9myGRDYXHo4Rnr16hYlTV1cqEpIMOYl7fsqa2DQoL+zFx4uRmJ+eOqA1omAkCDaskMzNoR3IgoKIOIrEj96HVb9NmCZ9Pcbsni4KC8EiYVGsEYM1c2ZpISwv9Vqe0STvjcEceq0YEAkq4xqKOiYSm3o9EvDHZ4QTBnnvuy5w54QllO/LAiLX7sUoyM0N+fl8GD7ZeQHZUsxCEaIgbGswTmrp2VayvybB+6hh/I3ZU7TQSaWmh39qac3Bn0QiEUGNr3TrzpEgn0eGNAZEhdTsaYg36WElmRni9Pm68cXLMXeSOLEyFUCpznz7m5q9E+HCMyM+HPfeMvmdraATtAWlpofFpLA6TSvh8O1aeSzy0FpdXhx6yXq+SmDvybtblUr8vMvwRaDaNTZ06idWrl+N2u2lsbEQI0UxClZfXlVtu+WcUH1MkdmRBoKFLlpaXR39WUKC0he3blYaQm6vsrJWVym6tC+zo51BYaB1quzNpBMZF2edL/c51ZxinkWgN53iHFgS5uTu2ENBITw8tQF6vMnHo9A+9wN9443iqq5W3TkpJenqGKSGfGbSw2RmQnW0uCNLSYMCA8GMZGclFYuwsgiByZ64TEuvr1RhNBXYWs5AROnrQTiXCZNFhTUMdufhMosjLU+qhx6MSaSJZJadOndQsBDSMDJjx0F5ppFMBjye140ZTc++MyM1VgjOVSW47o0YAqdcKOqwg2BHpEKyg2SgLCtRCk5MTvthYRQ/ZjSrSNMY7C1Ip+HYW/0AsGMkIc3JCi1gs/hw70GGqOyNSrQl12GG7IzuIraBNDh6PWsw0jbJV9FBk5TYz+P07j1lII5W/d2cxC8VDly4qCksLgbo61e/bt6s61smgtRzS7RGdGoEJdvRIITvo0kX9eb3m0UNmldvMsCNyC8VDKgVBp0ag4PWGL1462icQSH53u7NqA6D6zGzcaprylgrIDjlsA4GdxyxkBZdLmXT8/vDooTVrVtCrV9+whLtY99gZBarLpRbsVDg0OzWC+OjSRWkG2dkqC7bOvLZPFHZGR7ERhYWKhK66WvVZbm6oT6qqYOPGUBBJouhwgkCI9pFV2V7g86nFXNNOJIJE68/uSNDRV6m4bydiw5h/0L27qsRmJyJmZ9YINPx+czORripYXa02Otu3J5YgmdJ9tRDiaCHEz0KIxUKI600+v0oI8ZMQ4jshxPtCCPNyTwa43Z3aQCQ0/bbLpSaLHixGM0VOTvQitTNqAxqpWFRcrp0nks0p6Eg4O2OxUxDERmamEgZduoSYW3Ny7JkrU6YRCCHcwIPAKGAV8JUQYo6U8ifDad8AI6SUVUKIi4F/AGfEum+nEIiGz6cevNkD18RTupazdtTt7H6WVOzcjUXIO2EfmhStthbKytRONjMzPN9jZ3YUJwOdkZyZqYRBvHoRqVxW9wcWSymXSinrgOeAk4wnSCk/lFLqAPjPgRSV89jxYSX109NDC34gEFoA09J2bqGait1lZH5HJxJDWpoKke7dW+1qc3LCP+tEcnC54ud2pHIpKARWGt6vCh6zwoXAW2YfCCHGCyHmCyHmb9y40cEm7nzQE2xn97M4oRFE0it0LlYthxChfjUyB3SahVKLduEsFkL8ERgBHGr2uZRyJjAzeO5GIYQ9ys34yAeSjGpuVXS203l0lLZ2ttNZ7MzttPTBplIQrAaMzNi9g8fCIIQ4EpgEHCqljEtZJaVMgifSHEKI+VY1PNsTOtvpPDpKWzvb6Sw622mOVJqGvgIGCiH6CyF8wJnAHOMJQojhwMPAiVLKDSlsSyc60YlOdMICKRMEUsoGYALwDrAQmC2l/FEI8TchxInB0+4CAsDzQogFQog5FrfrRCc60YlOpAgp9RFIKd8E3ow4dovh9ZGp/H4bmNnG328Xne10Hh2lrZ3tdBad7TSBkMnmJHeiE53oRCd2COzEkeSd6EQnOtEJ2MEFgRAiifpSbQMhRIeI7BdCpLDsiHPo7E9nIYRwLFovlegoc7699ecOKQiEEAEhxH3AW0KIh4UQf2jrNllBCJEhhHgQeFsIcWkwkgohRLt6NsE+vRd4QwhxuxDisLZukxk6+9NZCCH8QoiHgA+DgR6HB4+3x/5s93O+vfZnu3qYTkAIUQj8GxDAscBHKA6j9oqrgK7AuYAfFU6LlDKFFUoTgxBiIPAy0AhcAGwEbmzTRlmjsz+dxQVAd1Sy52/A40IIfzvrz44059tlf+5wggCoAR6VUl4upVwHzAYWCCH2auN2NUMI4Q/+9wA+4Bkp5SIp5V3AxuBOsc13CQZsB2ZKKScGSQPfBNYKIdoFN1RnfzoLIYSRNUkAn0kpy6SUTwCfAVOC57UXGrh2Pec7Qn+2l4mRNIQQg4UQM4QQ6QBSyjLgP4ZT+gADgJ/boHlhEEIMEkKUAtOEECOCuRYB4EDDaX8CzhZC9G6rXUKwT5t3VFLKNYTzQGUAQ6SUq1q9cQZ09qezEELsKoSYDTwphDhOCKHZk7obTrsGOFkIsYuUUrbF4tVR5nxH6U/o4IJACFGMUgnHo0wCCCGElHK74TQfsMwOfUUqERy0DwPfAt8BlwghLgTuBP4khMgHkFKuBJ4GxrVRO48DXgImimANCSGER0pZaTitC20/yTr700EEtaX7gB9Qc+oE4BbgKeBYIcQeAEFh9SpBU5Zs5fjzjjLnO0p/anRoQQCUoWxug4DzhRD9TDpyOLAEQAgxrg3VxV2A7VLKf0gppwGPAicD6cBDhCeQ/IJia20LdXE9UILq0+uEEAEpZYMQwmVoy27Aj8H2nSWEGNTKbYTO/nQaBcBWYLKU8lXgNlQtkYEogTtJhCJy3gacIn5MFB1lzneU/gQ6uCCQUi5E1TxYDLwH/A2ibMFHAF2FEC8CZ6Hsia0OukogrgAACUxJREFUKeUPQJEQ4pDgoe+A94FrUaR7XYQQtwohTgfGAtXB61p1hyClnA8sCvbp28CM4EfC0JZioJsQ4mXUIlffmm0MtrOzP1sIo1CUUq5GMQCPMrx/CJgSFLTbgb8KIcaitK7NrdFGk3a22zlvbEN77k9TSCnb/R9Kdc42vBeRr4EsYDFwRMS1b6F2W6e2UlvzgR7G9gGu4OtLgacNnw0DHgteMwg4B3gXKGmLdpr0aTZqV7Of4bM01KL7NXB6K7SzADgo4lh77M+odrbj/rww4pg7+P88YJ7heC7K8ToMyEOZN55rxf680OKzdjPnUTVWpgK+9tyfcX9HWzfARkffjCKtew74S/CYK+Ic3fFXAK8HX48JLsK/b8W23gQsAl4A7jC2Lfh6V+BF4Nzg+64oUr6erdynZu206tObgQ+Dr48O/h/dim39EbWT3if43iiw2kV/xmtne+nP4Hd/DVxl8bkL+AC4wnDsKWCPVu7LmO2M6M82m/OoQIQfgAdQQQqRc6hd9Ket39LWDYjRyZkodtJZQA/UDm8bUBT8PGoHG3y9JXjeY4C/ldrqB+5ASftuwfZWAV30gDCcexTKfrkPcDrwIdC3PbQz4lxjnzYAFcA/AW8rtdUVnFxvoVTnK4HM9tSfNtppNUbboj+nBr8z6vsi2rYvKr59NPDH4IK8Wyv2p2U7Y7S5Vec8IY10mtWiTkhradP+tP2b2roBJh2YG/zvAX4PeAyfPQJcYHFdDkpwfAcc3JptDb4uMLz+PfAssLvF4LgYuD84KFLe1kTbafg8P9jn37R2Ow3HHgAmBhfNQ9pbf9ppZ3voT2Aoqi54FmpTdQFwQMT5eoE7Cfgr8DFQ3N7aaTi3Ved8RDtdwPeozdTuwXach2FTRUhradX+TOq3tXUDDJ3WNTiZ3gUuA3Y1fCZQIWEfAsMsrncBe7VRW4cEj3tQO9RlwN3Alyh1VQ8I407W3V7babje00oTzNjOS4GhweO7Ak8GX1+F2nFfAfTW46IN+9N2O9u4Py8ztPMvKEf0p8CtqEiVcwzjU6S6bU6003B9q8x5k+e+Z/D4FODe4PGLUImBUwzzzJXqtjn11y6ihoQQB6BU603A7SgHzGWGU1yogVGHSblLUBQCUsrvUtxUq7b+OdiGBuB/wAAp5dWoXcBVwfYjDQlNUsrG9tpOQxsbpJT/beV29ja0czFQLoRwA4OBy4GRMph4JYOzLfi6tfvTdjsNbWyL/ixEaUygtJW/AUdKKf+KKhz1Z0P7JK2ElrRTozXmvMVzvzD4sTZJPi+lfBi4DuhJMGFMtiMajnhoF8XrUZEU90gpn4Nm5sgjgpl49VLKRiHEgODrjUIRSvn0+e2krX6gVkrZXHBaSvmGEGIiapAv62xnQu30ouLr90Sp/ktQ9mMphBgopfy1s52223lk8Llvk1Lepk+UUr4mhLgKtbi1dhx7R27nqOBnH6Gy2PcJtvP7YCJjhxEAGq0uCIJZgGE7DynlIiHESsNn9SjTkDEz8AggXQjxFGrXdV07a2uN8RohxFDUDmI5sKaznQm3sx74VggxD/6/vbsJsaqOwzj+fRzHITQGYooSqmlirKwmF5HQIiTIMCx60U1g5SYopja1qEW0EQqCINCoRVC2iBZuWlQjvWJFEoQGQYtg2okWU2TiGI6/Fr8zeRgab87cc+49nucDF+/buTz3HOE39//KgYjYL+kacu/rSseFX4A5r52/7qVj15PX/Rf657o3JedY8drPknYDzynXsxojf1VPV5mzCrU2DUkaLJ/oBRNFTpReGyX/uiobAW4ix+VujIgv+jTrkKQd5GinzyLisYj42zmXljMiXoiI/cX96Yh4KXLZCOdcQk5JKyU9QA7H/jQidhbFzDmXdt0Pkc1WXwEfRMTWyMljjVJbIZA0CXyiXIP7Xsg2yfJsvNL9MeBg8dyDkobJZXtHI6LyvTyXk5VcQGyKbCPe45zLvvaXV5mtbTnJkTZfArf183VvSk5JayNiJiL2RcRbVeasUuWFQNIlyuacu4HnyU6XR4ufz/92qEiaiLOdK+uBdZI+AraT/QE/RcTJBmQdiIhjVWZtUc6HqKG9tUU5t5EjWWYWNsE455Kv++mq8tUqqh96NUCuFDg/5nsMeJti7DrZy74XOACsBa4C/iSXla1tBmuTsjqnczpne3LWci4qOLkryYk1V5aeW1O6v4KcMDJePL4LeHLBZ+ys6T9CI7I6p3M6Z3ty9uLW7RN9Mzk+/Sjw3iLvuQH4cJHXVnUzz4WQ1Tmd0znbk7NXt273EfxGTvW/nlwieDOApIFSL/wV5B6tSNqoYtNuSYoKR600OKtzOqdztidnT3S1EETEEeD9iPidbGub33VnjlwmAuAWYJWkV8jp2fPH1jarsUlZndM5nbM9OXul66OG4uwolL3ArKSni+fPFJX3DuBOYCYibo+Iz7ud4f9qSlbndE7nbE/Onqiy3YkclnWwuD9R/Hsfpc6afrk1JatzOqdztidnbeejhhP+MXCKXJlvpNdf+ELI6pzO6ZztyVnHrbIJZcrNuXeRPfGTEXFPlBY66ydNyeqc3eWc3eWczTU/kaKaD5e2kOvYnOr45h5rSlbn7C7n7C7nbKZKC4GZmfW/vtiYxszMeseFwMys5VwIzMxazoXAzKzlXAjMzFrOhcCsA0lzkg5J+lHSYUnPqLR71SLHjEp6uK6MZsvhQmDW2cmI2BARN5Jr1G8BXuxwzCjgQmCN4HkEZh1I+isi1pQejwHfASPA1cC7wOri5cmI+EbSt+TM1WngHXIJ5JeBTcAQsCci3qztS5idgwuBWQcLC0Hx3B/AdcBx4ExEzEoaJzc9uVXSJuDZiNhavP9x4LKI2CVpCPga2B4R07V+GbP/sLLXAcwabhDYLWkDMAesW+R9m4EJSduKx8PAOPmLwaynXAjMzlPRNDQHHCP7Co6Sm5qsAGYXOwx4KiKmaglpdh7cWWx2HiRdCrwB7I5sVx0GjkTEGWAHMFC89ThwcenQKeAJSYPF56yTtBqzPuBfBGadXSTpENkMdJrsHH61eO11YJ+kR8j17U8Uz/8AzEk6TG6N+Bo5kuj7YjesX4H76/oCZufizmIzs5Zz05CZWcu5EJiZtZwLgZlZy7kQmJm1nAuBmVnLuRCYmbWcC4GZWcu5EJiZtdw/mbTK8BvASucAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# with 3 sources of uncertainrty: model output and std of mean\n", + "y_std = y_stds.mean(0) + y_preds.std(0)\n", + "plot_rows(\n", + " y_target_rows,\n", + " y_context_rows,\n", + " y_pred,\n", + " y_std,\n", + " legend=False\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:12:11.961152Z", + "start_time": "2020-02-16T08:12:11.521075Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Try without MCDropout\n", + "model.eval()\n", + "with torch.no_grad():\n", + " y_pred, kl, loss_test, loss_mse, y_std = model(context_x, context_y, target_x, target_y)\n", + "\n", + "plot_rows(\n", + " y_target_rows,\n", + " y_context_rows,\n", + " y_pred.detach().cpu().numpy(),\n", + " y_std.detach().cpu().numpy(),\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:13:21.017398Z", + "start_time": "2020-02-16T08:13:20.967852Z" + } + }, + "source": [ + "## Full test" + ] + }, + { + "cell_type": "code", + "execution_count": 253, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:22:41.740593Z", + "start_time": "2020-02-16T08:22:41.686313Z" + } + }, + "outputs": [], + "source": [ + "from src.plot import plot_rows" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:22:41.979140Z", + "start_time": "2020-02-16T08:22:41.918436Z" + } + }, + "outputs": [], + "source": [ + "\n", + "\n", + "def eval_mc(model, loader, i):\n", + " loader = model.val_dataloader()[0]\n", + " device = next(model.parameters()).device\n", + "\n", + " data = loader.collate_fn([loader.dataset[i]], sample=False)\n", + " data = [d.to(device) for d in data]\n", + " context_x, context_y, target_x_extra, target_y_extra = data\n", + " target_x = target_x_extra\n", + " target_y = target_y_extra\n", + "\n", + " # do MCDropout estimation\n", + " model.eval()\n", + " convert_layers(model, torch.nn.modules.dropout.Dropout2d, True)\n", + " model.model._lstm.train()\n", + "\n", + " y_preds = []\n", + " y_stds = []\n", + " with torch.no_grad():\n", + " for i in range(n_mcdropout):\n", + " y_pred, kl, loss_test, loss_mse, y_std = model(context_x, context_y, target_x, target_y)\n", + " y_preds.append(y_pred)\n", + " y_stds.append(y_std)\n", + " y_stds = torch.stack(y_stds)\n", + " y_preds = torch.stack(y_preds)\n", + "\n", + "\n", + " mean = y_preds.mean(0)\n", + " sigma = y_stds.mean(0)\n", + "\n", + " dist = torch.distributions.Normal(mean, sigma)\n", + " log_p = dist.log_prob(target_y).mean(-1)\n", + " loss_mc = - log_p\n", + "\n", + "\n", + " # Try without MCDropout\n", + " model.eval()\n", + " with torch.no_grad():\n", + " y_pred, kl, loss_test, loss_mse, y_std = model(context_x, context_y, target_x, target_y)\n", + "\n", + " dist = torch.distributions.Normal(y_pred, y_std)\n", + " log_p = dist.log_prob(target_y).mean(-1)\n", + " loss = - log_p \n", + "\n", + " return loss_mc.cpu(), loss.cpu()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "n_mcdropout=10\n", + "n_steps=100" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:23:05.222197Z", + "start_time": "2020-02-16T08:22:42.120345Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f05a4efde45043ce911ba6600c305b9e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Get data\n", + "inds = np.random.randint(0, len(loader.dataset), n_steps)\n", + "\n", + "losses_mc = []\n", + "losses = []\n", + "for i in tqdm(inds):\n", + " loss_mc, loss = eval_mc(model, loader, i)\n", + " losses_mc.append(loss_mc)\n", + " losses.append(loss)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "metadata": { + "ExecuteTime": { + "end_time": "2020-02-16T08:23:05.279301Z", + "start_time": "2020-02-16T08:23:05.224402Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lower is better, validation loss\n", + "MCDropout: -1.40\n", + "Inference: -0.64\n" + ] + } + ], + "source": [ + "loss_mc = torch.stack(losses_mc).mean()\n", + "loss = torch.stack(losses).mean()\n", + "print(f\"Lower is better, validation loss\")\n", + "print(f\"MCDropout: {loss_mc:2.2f}\")\n", + "print(f\"Inference: {loss:2.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "We can see that we get a better (lower) loss when we not only use the models estimate of the loss, but we take a step back and add an " + ] + } + ], + "metadata": { + "file_extension": ".py", + "kernelspec": { + "display_name": "jup3.7.3", + "language": "python", + "name": "jup3.7.3" + }, + "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.7.3" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "384px" + }, + "toc_section_display": true, + "toc_window_display": true + }, + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +}