18_convolutional_neural_nets/04_time_series_prediction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to use CNN with time series data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The regular measurements of time series result in a similar grid-like data structure as for the image data we have focused on so far. As a result, we can use CNN architectures for univariate and multivariate time series. In the latter case, we consider different time series as channels, similar to the different color signals."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports & Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.197611Z",
     "start_time": "2021-02-23T06:16:59.204248Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import sys\n",
    "from time import time\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import spearmanr\n",
    "from sklearn.feature_selection import mutual_info_regression\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.autograph.set_verbosity(0, True)\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras.layers import (Dense, \n",
    "                                     Flatten, \n",
    "                                     Conv1D, \n",
    "                                     MaxPooling1D, \n",
    "                                     Dropout, \n",
    "                                     BatchNormalization)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.204076Z",
     "start_time": "2021-02-23T06:17:02.199550Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using CPU\n"
     ]
    }
   ],
   "source": [
    "gpu_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpu_devices:\n",
    "    print('Using GPU')\n",
    "    tf.config.experimental.set_memory_growth(gpu_devices[0], True)\n",
    "else:\n",
    "    print('Using CPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.214395Z",
     "start_time": "2021-02-23T06:17:02.206329Z"
    }
   },
   "outputs": [],
   "source": [
    "sys.path.insert(1, Path(sys.path[0], '..').as_posix())\n",
    "from utils import MultipleTimeSeriesCV, format_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.226944Z",
     "start_time": "2021-02-23T06:17:02.216250Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "tf.random.set_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.239648Z",
     "start_time": "2021-02-23T06:17:02.228669Z"
    }
   },
   "outputs": [],
   "source": [
    "sns.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:02.269799Z",
     "start_time": "2021-02-23T06:17:02.257853Z"
    }
   },
   "outputs": [],
   "source": [
    "results_path = Path('results', 'time_series')\n",
    "if not results_path.exists():\n",
    "    results_path.mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:12.560399Z",
     "start_time": "2021-02-23T06:17:02.272776Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 4706 entries, 2000-01-03 to 2018-03-27\n",
      "Columns: 3199 entries, A to ZUMZ\n",
      "dtypes: float64(3199)\n",
      "memory usage: 114.9 MB\n"
     ]
    }
   ],
   "source": [
    "prices = (pd.read_hdf('../data/assets.h5', 'quandl/wiki/prices')\n",
    "          .adj_close\n",
    "          .unstack().loc['2000':])\n",
    "prices.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute monthly returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:12.817259Z",
     "start_time": "2021-02-23T06:17:12.561990Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "DatetimeIndex: 215 entries, 2017-12-31 to 2000-02-29\n",
      "Freq: -1M\n",
      "Columns: 1511 entries, A to ZQK\n",
      "dtypes: float64(1511)\n",
      "memory usage: 2.5 MB\n"
     ]
    }
   ],
   "source": [
    "returns = (prices\n",
    "           .resample('M')\n",
    "           .last()\n",
    "           .pct_change()\n",
    "           .dropna(how='all')\n",
    "           .loc['2000': '2017']\n",
    "           .dropna(axis=1)\n",
    "           .sort_index(ascending=False))\n",
    "\n",
    "# remove outliers likely representing data errors\n",
    "returns = returns.where(returns<1).dropna(axis=1)\n",
    "returns.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create model data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:12.822778Z",
     "start_time": "2021-02-23T06:17:12.819050Z"
    }
   },
   "outputs": [],
   "source": [
    "n = len(returns)\n",
    "nlags = 12\n",
    "lags = list(range(1, nlags + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.035948Z",
     "start_time": "2021-02-23T06:17:12.824294Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "MultiIndex: 305222 entries, ('A', Timestamp('2001-03-31 00:00:00')) to ('ZQK', Timestamp('2017-12-31 00:00:00'))\n",
      "Data columns (total 13 columns):\n",
      " #   Column  Non-Null Count   Dtype  \n",
      "---  ------  --------------   -----  \n",
      " 0   label   305222 non-null  float64\n",
      " 1   1       305222 non-null  float64\n",
      " 2   2       305222 non-null  float64\n",
      " 3   3       305222 non-null  float64\n",
      " 4   4       305222 non-null  float64\n",
      " 5   5       305222 non-null  float64\n",
      " 6   6       305222 non-null  float64\n",
      " 7   7       305222 non-null  float64\n",
      " 8   8       305222 non-null  float64\n",
      " 9   9       305222 non-null  float64\n",
      " 10  10      305222 non-null  float64\n",
      " 11  11      305222 non-null  float64\n",
      " 12  12      305222 non-null  float64\n",
      "dtypes: float64(13)\n",
      "memory usage: 31.5+ MB\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-10-8629bb5ba869>:15: FutureWarning: null_counts is deprecated. Use show_counts instead\n",
      "  cnn_data.info(null_counts=True)\n"
     ]
    }
   ],
   "source": [
    "cnn_data = []\n",
    "for i in range(n-nlags-1):\n",
    "    df = returns.iloc[i:i+nlags+1]        # select outcome and lags\n",
    "    date = df.index.max()                 # use outcome date\n",
    "    cnn_data.append(df.reset_index(drop=True)  # append transposed series\n",
    "                    .transpose()\n",
    "                    .assign(date=date)\n",
    "                    .set_index('date', append=True)\n",
    "                    .sort_index(1, ascending=True))\n",
    "\n",
    "cnn_data = (pd.concat(cnn_data)\n",
    "            .rename(columns={0: 'label'})\n",
    "            .sort_index())\n",
    "\n",
    "cnn_data.info(null_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutual Information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.042983Z",
     "start_time": "2021-02-23T06:17:14.037315Z"
    }
   },
   "outputs": [],
   "source": [
    "# mi = mutual_info_regression(X=cnn_data.drop('label', axis=1), y=cnn_data.label)\n",
    "# mi = pd.Series(mi, index=cnn_data.drop('label', axis=1).columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Information Coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.052460Z",
     "start_time": "2021-02-23T06:17:14.044732Z"
    }
   },
   "outputs": [],
   "source": [
    "# ic = {}\n",
    "# for lag in lags:\n",
    "#     ic[lag] = spearmanr(cnn_data.label, cnn_data[lag])\n",
    "# ic = pd.DataFrame(ic, index=['IC', 'p-value']).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.060023Z",
     "start_time": "2021-02-23T06:17:14.057316Z"
    }
   },
   "outputs": [],
   "source": [
    "# ax = ic.plot.bar(rot=0, figsize=(14, 4),\n",
    "#                  ylim=(-0.05, .05),\n",
    "#                  title='Feature Evaluation')\n",
    "# ax.set_xlabel('Lag')\n",
    "# sns.despine()\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(results_path / 'cnn_ts1d_feature_ic', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.068055Z",
     "start_time": "2021-02-23T06:17:14.061524Z"
    }
   },
   "outputs": [],
   "source": [
    "# metrics = pd.concat([mi.to_frame('Mutual Information'),\n",
    "#                      ic.IC.to_frame('Information Coefficient')], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.078296Z",
     "start_time": "2021-02-23T06:17:14.069484Z"
    }
   },
   "outputs": [],
   "source": [
    "# ax = metrics.plot.bar(figsize=(12, 4), rot=0)\n",
    "# ax.set_xlabel('Lag')\n",
    "# sns.despine()\n",
    "# plt.tight_layout()\n",
    "# plt.savefig(results_path / 'ts1d_metrics', dpi=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We design a simple one-layer CNN that uses one-dimensional convolutions combined with max pooling to learn time series patterns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.086146Z",
     "start_time": "2021-02-23T06:17:14.079979Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_model(filters=32, kernel_size=5, pool_size=2):\n",
    "    model = Sequential([Conv1D(filters=filters,\n",
    "                               kernel_size=kernel_size,\n",
    "                               activation='relu',\n",
    "                               padding='causal',\n",
    "                               input_shape=input_shape,\n",
    "                               use_bias=True,\n",
    "                               kernel_regularizer=regularizers.l1_l2(l1=1e-5,\n",
    "                                                                     l2=1e-5)),\n",
    "                        MaxPooling1D(pool_size=pool_size),\n",
    "                        Flatten(),\n",
    "                        BatchNormalization(),\n",
    "                        Dense(1, activation='linear')])\n",
    "    model.compile(loss='mse',\n",
    "                  optimizer='Adam')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set up CV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.102526Z",
     "start_time": "2021-02-23T06:17:14.087401Z"
    }
   },
   "outputs": [],
   "source": [
    "cv = MultipleTimeSeriesCV(n_splits=12 * 3,\n",
    "                          train_period_length=12 * 5,\n",
    "                          test_period_length=1,\n",
    "                          lookahead=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.112680Z",
     "start_time": "2021-02-23T06:17:14.105420Z"
    }
   },
   "outputs": [],
   "source": [
    "input_shape = nlags, 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.122020Z",
     "start_time": "2021-02-23T06:17:14.116430Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_train_valid_data(X, y, train_idx, test_idx):\n",
    "    x_train, y_train = X.iloc[train_idx, :], y.iloc[train_idx]\n",
    "    x_val, y_val = X.iloc[test_idx, :], y.iloc[test_idx]\n",
    "    m = X.shape[1]\n",
    "    return (x_train.values.reshape(-1, m, 1), y_train,\n",
    "            x_val.values.reshape(-1, m, 1), y_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.129958Z",
     "start_time": "2021-02-23T06:17:14.124608Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "epochs = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.138644Z",
     "start_time": "2021-02-23T06:17:14.131601Z"
    }
   },
   "outputs": [],
   "source": [
    "filters = 32\n",
    "kernel_size = 4\n",
    "pool_size = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:17:14.251032Z",
     "start_time": "2021-02-23T06:17:14.140382Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1d (Conv1D)              (None, 12, 32)            160       \n",
      "_________________________________________________________________\n",
      "max_pooling1d (MaxPooling1D) (None, 3, 32)             0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 96)                0         \n",
      "_________________________________________________________________\n",
      "batch_normalization (BatchNo (None, 96)                384       \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 1)                 97        \n",
      "=================================================================\n",
      "Total params: 641\n",
      "Trainable params: 449\n",
      "Non-trainable params: 192\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "get_model(filters=filters,\n",
    "          kernel_size=kernel_size, \n",
    "          pool_size=pool_size).summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cross-validation loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:31:01.216587Z",
     "start_time": "2021-02-23T06:17:14.254466Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01 | 00:00:22 |   3 |   2.5 ( 32.73%) |   2.5\n",
      "02 | 00:01:10 |  15 |   2.8 ( 27.18%) |   2.7\n",
      "03 | 00:01:30 |   1 | -0.78 ( 76.06%) |   1.5\n",
      "04 | 00:01:52 |   1 |  -2.0 ( 43.56%) |  0.64\n",
      "05 | 00:02:12 |   9 |   2.5 ( 32.85%) |   1.0\n",
      "06 | 00:02:24 |   1 |   4.8 (  6.08%) |   1.6\n",
      "07 | 00:02:41 |   3 |   1.6 ( 54.00%) |   1.6\n",
      "08 | 00:03:15 |  17 |   1.5 ( 56.27%) |   1.6\n",
      "09 | 00:03:31 |   2 |   2.0 ( 44.74%) |   1.7\n",
      "10 | 00:03:50 |   4 |   2.8 ( 28.15%) |   1.8\n",
      "11 | 00:04:04 |   1 |  -1.0 ( 69.06%) |   1.5\n",
      "12 | 00:04:18 |   1 |   3.9 ( 13.20%) |   1.7\n",
      "13 | 00:04:37 |   4 |   3.4 ( 18.15%) |   1.8\n",
      "14 | 00:04:60 |   8 |   4.4 (  8.41%) |   2.0\n",
      "15 | 00:05:14 |   1 |   3.4 ( 18.66%) |   2.1\n",
      "16 | 00:05:41 |  15 |   1.9 ( 46.11%) |   2.1\n",
      "17 | 00:05:52 |   1 |   2.4 ( 36.05%) |   2.1\n",
      "18 | 00:06:08 |   6 |   2.4 ( 34.88%) |   2.1\n",
      "19 | 00:06:45 |  18 |   4.0 ( 11.75%) |   2.2\n",
      "20 | 00:07:28 |  23 |   7.8 (  0.24%) |   2.5\n",
      "21 | 00:07:42 |   1 |   3.4 ( 18.18%) |   2.6\n",
      "22 | 00:08:19 |  18 |  0.71 ( 78.30%) |   2.5\n",
      "23 | 00:08:35 |   2 | -0.47 ( 85.55%) |   2.3\n",
      "24 | 00:08:55 |   3 |   1.6 ( 52.45%) |   2.3\n",
      "25 | 00:09:17 |   5 |   5.3 (  3.95%) |   2.4\n",
      "26 | 00:09:37 |   5 |  0.79 ( 75.95%) |   2.4\n",
      "27 | 00:10:04 |  10 |   1.9 ( 46.07%) |   2.4\n",
      "28 | 00:10:18 |   1 |   6.8 (  0.84%) |   2.5\n",
      "29 | 00:10:37 |   2 |   1.3 ( 62.52%) |   2.5\n",
      "30 | 00:11:05 |   7 |   5.3 (  3.85%) |   2.6\n",
      "31 | 00:11:50 |  20 |   2.7 ( 29.13%) |   2.6\n",
      "32 | 00:12:07 |   2 |   5.2 (  4.22%) |   2.7\n",
      "33 | 00:12:26 |   4 |  -0.5 ( 84.51%) |   2.6\n",
      "34 | 00:12:48 |   5 | -0.39 ( 87.93%) |   2.5\n",
      "35 | 00:13:19 |  13 |   4.6 (  7.65%) |   2.5\n",
      "36 | 00:13:47 |   9 |   2.9 ( 26.24%) |   2.5\n"
     ]
    }
   ],
   "source": [
    "result = {}\n",
    "start = time()\n",
    "for fold, (train_idx, test_idx) in enumerate(cv.split(cnn_data)):\n",
    "    X_train, y_train, X_val, y_val = get_train_valid_data(cnn_data\n",
    "                                                          .drop('label', axis=1)\n",
    "                                                          .sort_index(ascending=False),\n",
    "                                                          cnn_data.label,\n",
    "                                                          train_idx,\n",
    "                                                          test_idx)\n",
    "    test_date = y_val.index.get_level_values('date').max()\n",
    "    model = get_model(filters=filters,\n",
    "                      kernel_size=kernel_size,\n",
    "                      pool_size=pool_size)\n",
    "    \n",
    "    best_ic = -np.inf\n",
    "    stop = 0\n",
    "    for epoch in range(50):         \n",
    "        training = model.fit(X_train, y_train,\n",
    "                             batch_size=batch_size,\n",
    "                             validation_data=(X_val, y_val),\n",
    "                             epochs=epoch + 1,\n",
    "                             initial_epoch=epoch,\n",
    "                             verbose=0,\n",
    "                             shuffle=True)\n",
    "        predicted = model.predict(X_val).squeeze()\n",
    "        ic, p_val_ = spearmanr(predicted, y_val)\n",
    "        if ic > best_ic:\n",
    "            best_ic = ic\n",
    "            p_val = p_val_\n",
    "            stop = 0\n",
    "        else:\n",
    "            stop += 1\n",
    "        if stop == 10:\n",
    "            break\n",
    "    \n",
    "    nrounds = epoch + 1 - stop\n",
    "    result[test_date] = [nrounds, best_ic, p_val]\n",
    "    df = pd.DataFrame(result, index=['epochs', 'IC', 'p-value']).T\n",
    "    msg = f'{fold + 1:02d} | {format_time(time()-start)} | {nrounds:3.0f} | '\n",
    "    print(msg + f'{best_ic*100:5.2} ({p_val:7.2%}) | {df.IC.mean()*100:5.2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:31:01.228794Z",
     "start_time": "2021-02-23T06:31:01.219004Z"
    }
   },
   "outputs": [],
   "source": [
    "metrics = pd.DataFrame(result, index=['epochs', 'IC', 'p-value']).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-23T06:31:01.954217Z",
     "start_time": "2021-02-23T06:31:01.230579Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACr70lEQVR4nOzdd3hb5fXA8a+G5SlvW/J2nNiOneksEgIEQkwWIWG1hDLKpoWWltJf6WCPltFFoWWkbEjZCSSQHQiQRRInTmxnecR7D9nykDV+f1xLsRM7Xpr2+3kePbakq6tXtizfc895zyuzWCwWBEEQBEEQBEEQhGGTu3oAgiAIgiAIgiAII4UIsARBEARBEARBEOxEBFiCIAiCIAiCIAh2IgIsQRAEQRAEQRAEOxEBliAIgiAIgiAIgp2IAEsQBEEQBEEQBMFORIAlCIIg2KSmpnLq1CkAHn74YV566aUBbTtYn3/+ObfeeuuQHutMmzdvZt68eWRkZJCbm+vq4QiCIAgeQARYgiAII8htt93GP//5z7Nu37JlC3PnzsVoNA54X48//jj33HPPsMdUWlpKampqj+e+4ooreP3114e97zPt2bOH8ePHk5GRQUZGBgsXLuSTTz4Z8v6eeeYZHnroIbKyskhPT7fjSAVBEISRSgRYgiAII8iVV17J2rVrOXMN+c8//5xly5ahVCpdNDLniYyMJCsriwMHDvDb3/6Whx56iJMnTw5qH9ZgsLy8nOTk5CGNw2QyDelxgiAIgmcTAZYgCMIIsmDBApqamti3b5/ttqamJrZv386KFSvIzs7mxz/+MTNmzOCCCy7g8ccfx2Aw9LqvBx98kL///e+266tWreKCCy7gggsu4OOPP+6x7ddff82KFSuYNm0a8+bN41//+pftvhtuuAGAmTNnkpGRQVZWFp9++ikrV660bXPgwAGuvvpqpk+fztVXX82BAwds991444384x//4LrrriMjI4Nbb72V+vr6fn8WMpmMBQsWEBgYyMmTJzGbzbz66qssWLCA8847j/vuu4/GxkbgdJbto48+4uKLL+YnP/kJGRkZmEwmli9fzoIFCwDIz8/nxhtvZMaMGSxdupStW7f2+Hk98sgj3HHHHUydOpU9e/Ywf/58Vq1axbJly5g6dSp/+MMfqK2t5fbbbycjI4Of/vSnNDU12fbxy1/+krlz5zJ9+nR+8pOfcOLEiR77f+yxx7jzzjvJyMjg2muvpbi42Hb/iRMnuOWWW5g1axbnn38+L7/8MsA5X7cgCIJgfyLAEgRBGEF8fHxYvHgxa9assd321VdfkZSUxPjx45HL5fz+979n9+7d/O9//2PXrl28//77/e53x44dvP7667z++uts2rSJXbt29bjf19eXZ555hn379vHKK6+wevVqtmzZAsC7774LwA8//EBWVhYZGRk9HtvY2Mhdd93FjTfeyJ49e7jlllu46667aGhosG2zbt06/vznP7Nr1y46OzsHVF5oNpvZvHkzzc3NpKSk8Pbbb7Nlyxbeffddvv32W4KCgnj88cd7POaHH37gyy+/5K233iIrKwuAtWvXsmXLFjo7O7n77ruZO3cuO3fu5E9/+hMPPPAABQUFPcZ59913c+DAAaZPnw7Apk2beOONN9i4cSPbt2/njjvu4P7772fPnj2YzWbeeecd2+MvuugiNm7cyK5du0hPT+eBBx7oMb7169dz77338sMPPxAfH28LgFtaWrjlllu48MIL+fbbb9m0aRNz5swBGNDrFgRBEOxHBFiCIAgjzIoVK9iwYQPt7e0ArFmzhiuvvBKAiRMnMnXqVJRKJbGxsfz4xz/mhx9+6HefX331FVdddRUpKSn4+flx77339rj/vPPOIzU1Fblczvjx41m6dCl79+4d0Hi//vprEhISWLFiBUqlkssvv5ykpCS2b99u2+aqq65izJgx+Pj4sGjRIvLy8vrcX3V1NTNmzGD27Nm8+OKLPPvssyQlJfHBBx/w61//Gq1Wi0ql4t5772Xjxo095ob94he/wM/PDx8fn7P2e+jQIVpbW7nzzjtRqVTMmTOHSy65hPXr19u2ufTSS5k+fTpyuRxvb29AyuCFh4ej0WiYMWMGkydPJj09HZVKRWZmZo/mGddccw0BAQGoVCp+8YtfcPToUZqbm233Z2ZmMnnyZJRKJVdccYXt5/D1118THh7Orbfeire3NwEBAUyZMgVgQK9bEARBsJ+RX4wvCIIwysyYMYPQ0FC2bt3K5MmTOXLkCC+++CIAhYWF/OUvf+HIkSO0tbVhMpmYMGFCv/usrq5m4sSJtusxMTE97j906BDPP/88J06coLOzE4PBwKJFiwY03urqaqKjo3vcFh0dTVVVle16RESE7XtfX19aW1v73F9kZCQ7duw46/by8nLuuece5PLT5xblcjl1dXW261qt9pzj1Gq1PR5/5jijoqLOelx4eLjte29v7x7XfXx8bK/FZDLx97//nQ0bNlBfX297noaGBtRq9Vn76v7YiooK4uPjex33uV63RqPp8/UKgiAIQyMCLEEQhBFo+fLlrFmzhsLCQubOnWs7MH/00UdJT0/nr3/9KwEBAbz55pts3Lix3/1FRkZSUVFhu15eXt7j/t/85jfccMMNrFq1Cm9vb5566ilbiZ9MJut332fur6KiggsvvHBAr3WgtFotTz/9tK10r7vS0lLg3GONjIyksrISs9lsC1YqKipITEy0y/i++OILtm7dyhtvvEFsbCzNzc3MnDnzrIYlvYmKiuqRSevuXK9bEARBsD9RIigIgjACrVixgl27dvHhhx+yYsUK2+16vR5/f3/8/f3Jz89n9erVA9rfokWL+Oyzzzh58iRtbW22jFj3/QYFBeHt7U12djbr1q2z3RcaGopcLqekpKTXfc+bN4+ioiK++OILjEYjX375JSdPnuTiiy8e9Os+l5UrV/KPf/yDsrIyAOrr623zxAZi8uTJ+Pr6smrVKjo7O9mzZw/btm1jyZIldhmfXq9HpVIREhJCW1sbf/vb3wb82Isvvpja2lrefPNNDAYDLS0tHDp0CBj+6xYEQRAGRwRYgiAII1BsbCwZGRm0tbVx6aWX2m7/3e9+x7p165g2bRoPPfTQgIODefPmcfPNN3PzzTeTmZnJ7Nmze9z/yCOP8MILL5CRkcFLL73E4sWLbff5+vpy9913s3LlSmbMmMHBgwd7PDYkJISXX36ZN954g/POO49Vq1bx8ssvExoaOvQfQC9uuukm5s+fz6233kpGRgY/+tGPyM7OHvDjVSoV//nPf9ixYwezZ8/mscce49lnn2Xs2LF2Gd+KFSuIjo7mwgsvZOnSpUydOnXAjw0ICOD1119n+/btzJ07l4ULF7Jnzx5g+K9bEARBGByZZSC1B4IgCIIgCIIgCEK/RAZLEARBEARBEATBTgYUYO3YsYOFCxeSmZnJq6++etb9FouFJ598kszMTJYtW0ZOTo7tvjfffJOlS5dy+eWXc//999PR0WG/0QuCIAiCIAiCILiRfgMsk8nE448/zqpVq1i/fj3r1q3j5MmTPbbZsWMHRUVFbNq0iSeeeIJHH30UgKqqKt5++20++eQT1q1bh8lk6rPLkSAIgiAIgiAIgqfrN8DKzs4mISGBuLg4VCoVS5cuZevWrT222bp1KytWrEAmkzF16lR0Oh3V1dWAFKC1t7djNBppb28nMjLSMa9EEARBEARBEATBxfpdB6uqqqrHwosajeas7kNnbqPVaqmqqmLSpEnceuutXHLJJXh7ezN37lwuuOCCfgd14MABfH19B/M6BEEQzqmjowNvb29XD0MQhBFGfLYIwuiVlpbW6+39Bli9NRk8cyHGvrZpampi69atbN26FbVazX333cfatWtZvnz5OZ9TJpP1OWBBEIShyMvLE58rgiDYnfhsEQThTP2WCGq1WiorK23Xq6qqzirzO3ObyspKIiMj2blzJ7GxsYSGhuLl5cVll11GVlaWHYcvCIIgCIIgCILgPvoNsCZNmkRRURElJSUYDAbWr1/P/Pnze2wzf/581qxZg8Vi4eDBg6jVaiIjI4mOjubQoUO0tbVhsVjYtWuX3RZkFARBEARBEARBcDf9lggqlUoefvhhbr/9dkwmE1dffTXJycmsXr0agJUrVzJv3jy++eYbMjMz8fX15emnnwZgypQpLFy4kCuvvBKlUklaWho//vGPHfuKBEEQBEEQBEEQXERm6W0ClYtlZWWRkZHh6mEIgjCCiHkSzvXhDyW8siOfjb+6CKVCrGkvjFzis8W9dHZ2UlpaSnt7u6uHIowgPj4+xMbG4uXlNaDt+81gCYIgCMJgbT9WTX6NnmNVzUyIDnL1cARBGCVKS0tRq9UkJiae1ZRNEIbCYrFQV1dHaWkpY8aMGdBjxGlFQRAEwe5yynUAZBU3unYggiCMKu3t7YSFhYngSrAbmUxGWFjYoLKiIsASBEEQ7KqprZPi+lYADhQ3uHg0giCMNiK4EuxtsO8pEWAJgiAIdpXblb0K9FGKDJYgCIIw6ogASxAEQbCrnPImAK6dEUdhrZ4GvcHFIxIEQXCegTRq27dvH0uXLmX58uVOa8ixZ88eDhw4YLu+evVq1qxZY5d9FxYWcscdd5CZmcnixYu57777qK2tHdK+nnnmGZYuXcozzzxDfX091157LStWrGDfvn3ccccd6HS6Ph87nNdUWlrKF198MaTHnkk0uRAEQRDsKrdcR6Tam8x0Df/9rpCskgbmj9e4eliCIAhu4/PPP+fWW2/l6quvHtD2JpMJhUIxrOfcu3cvfn5+TJs2DZCWWrKHjo4O7rrrLh588EHbWrm7d++mvr6e8PDwQe/vgw8+YPfu3ahUKtavX09SUhLPPPMMADNmzDjnY4fzmsrKyli3bh3Lli0b8j6sRIAlCIIg2FVOuY4J0YFMjg1CIZdx4FSjCLAEQRh19uzZw4svvkhISAjHjx9nwoQJPP/883z88cds2LCB7777jp07d/L888/z7LPP8u233yKTyfjZz37GkiVLbI+PjIwkLy+PRx55hH/961+EhYVx9OhRMjMzSUlJ4e2336ajo4OXXnqJ+Ph4tm3bxn/+8x86OzsJDg7m+eefp729nf/973/I5XI+//xzHnroIXbt2oWfnx+33Xabbf9tbW3Ex8fz9NNPExQUxI033sjkyZPZs2cPzc3NPPXUU2cFOV988QVTp061BVcAs2fPBqTg69FHH+XIkSMoFAoefPBBZs+ejclk4vnnn2fv3r0YDAZ+8pOfcN1113H33XfT1tbGtddey9KlS3n//fdpb29n+fLlfPDBByxZsoSPP/6Y0NBQ1qxZw3//+19kMhmpqak899xz/Otf/7K9puLiYh577DEaGhrw8fHhiSeeYOzYsTz44IMEBARw5MgRampq+O1vf8uiRYv461//Sn5+PsuXL+fKK6/kpz/96ZB/9yLAEgRBEOymvdPEyZoWMtM1+KmUpEWpRaMLQRBc4pP9pXy4r8Su+/zRjDiunh474O1zc3NZv349kZGRrFy5kv3793Pttdeyf/9+Lr74YhYtWsTGjRs5evQoa9eupaGhgWuuucYWxBw+fJgvvviCuLg49uzZw9GjR/nyyy8JDg7m0ksv5dprr+Xjjz/mrbfe4p133uGPf/wj06dP58MPP0Qmk/HRRx+xatUqHnzwQa677jpb8AGwa9cu2zj/7//+j4ceeohZs2bxz3/+kxdffJE//vGPgJQ9+/jjj/nmm2948cUXefPNN3u8xhMnTjBhwoReX/97770HSEFYfn4+t912Gxs3bmTNmjWo1Wo++eQTDAYD1113HXPnzuXll18mIyODtWvXAhAeHs6RI0d4+OGHz3rO//znP6xevZrQ0FAaGxvPeu6HHnqIxx57jMTERA4dOsRjjz3G22+/DUB1dTXvv/8+BQUF/OxnP2PRokX85je/4fXXX+eVV14Z8O+3LyLAEgRBEOzmWGUzJrOFCdGBAGTEhfDpgVJMZgsKuejsJQjC6DJ58mS0Wi0A48ePp6ys7KwM0P79+1m6dCkKhYLw8HBmzpzJ4cOHCQgIYNKkScTFxdm2nTRpEpGRkQDEx8czd+5cAFJSUtizZw8AlZWV/PrXv6ampgaDwUBs7LkDwubmZpqbm5k1axYAV155Jffdd5/t/szMTAAmTJhAWVnZoF7//v37ueGGGwAYO3Ys0dHRFBYW8v3333Ps2DE2btxoG8OpU6d6vNZz2b17N4sWLSI0NBSA4ODgHvfr9XqysrJ6vA6D4fR84AULFiCXyxk3btyQ54qdiwiwBEEQBLuxrn9lXVx4WkIw7+w+xfGqZtKiAl05NEEQRpmrp8cOKtvkCCqVyva9QqHAZDKdtY3FYunz8X5+fn3uTy6X267L5XLbvp988kl++tOfcumll9rKDO3xGro/R3fjxo3jhx9+6PWxfb02i8XCn/70Jy688MIhjelcPzPr/YGBgbZM2Jm6/xwdQXQRFARBEOwmp7wJtY+SuFBfAKbFhwBiPSxBEIS+zJw5k6+++gqTyUR9fT379u1j8uTJQ95fc3MzGo0077V7Rz1/f3/0ev1Z26vVagIDA9m3bx8Aa9euZebMmQN+vmXLlpGVlcXXX39tu23Hjh0cO3aMmTNn2jrzFRYWUlFRQVJSEhdccAGrV6+ms7PTdl9ra+uAn3POnDls2LCBhgbpf8uZJYIBAQHExsby1VdfAVLAdfTo0XPus6+fz1CIAEsQBEGwm5xyHelRgbZFGeND/QjzV3HgVKNrByYIguCmrM0qli9fzs0338xvf/tbIiIihry/e++9l/vuu4/rr7++R+ncJZdcwubNm1m+fLktmLJ65plnePbZZ1m2bBl5eXncc889A34+Hx8fXn75Zd555x0uu+wylixZwmeffUZYWBjXX389ZrOZZcuW8etf/5o///nPqFQqrr32WsaNG8dVV13F5ZdfzsMPP9xrdqwvycnJ3H333dx4441cccUV/OUvfzlrm+eee46PP/6YK664gqVLl7Jly5Zz7jM1NRWFQsEVV1xx1jyzwZJZ+suxuUBWVtaA1hAQBEEYqLy8PNLS0lw9jBHNZLYw4ZENXD8rgYeXpdtuv/2tHyio1bPtNxe7bnCC4CDis8W9iN+H4CiDeW+JDJYgCIJgFwU1LbR3mpkY03OuVUZ8CAU1ehpbxYLDgiAIwsgnAixBEATBLs5scGFlnYeVVdzo7CEJgiAIgtOJAEsQBEGwi5zyJryVcsZG+Pe4fUpcEHKZaHQhCIIgjA4iwBIEQRDsIqdcx3itGqWi578WP5WS8dpAkcESBEEQRgURYAmCIAjDZrFYOFLWRPoZ5YFW0xKCOVjSiMnsdn2VBEEQBMGuRIAlCIIgDFtpQxu6diMTontfTHhafAgtHUZOVDc7eWSCIAiC4FwDCrB27NjBwoULyczM5NVXXz3rfovFwpNPPklmZibLli0jJycHgIKCApYvX267TJs2bdh95QVBEAT3c7rBRd8BFiDWwxIEYcSrqanh17/+NQsWLGDJkiXccccdFBYWOvQ5b7zxRg4fPnzObd58803a2tps1++44w50Op1dnj83N5fU1FS+/fZbu+zP0/UbYJlMJh5//HFWrVrF+vXrWbduHSdPnuyxzY4dOygqKmLTpk088cQTPProowAkJSWxdu1a1q5dy6effoqvry+ZmZkOeSGCIAiC6+SWNyGXwXht7wFWQpgfof4qskSjC0EQRjCLxcK9997LrFmz2LJlC19++SX3338/dXV1rh4ab7/9do8A67XXXiMwsPfP7MFat24d06dPZ/369XbZn9FotMt+XKXfACs7O5uEhATi4uJQqVQsXbqUrVu39thm69atrFixAplMxtSpU9HpdFRXV/fYZteuXcTFxRETE2PfVyAIgiC4XE65jrERAfiqFL3eL5PJyIgLFp0EBUEY0Xbv3o1SqWTlypW229LS0pgxYwZ79uzhrrvust3++OOP8+mnnwIwf/58/va3v/HjH/+Yq666ipycHG677TYWLFjA6tWrAc75+O4eeeQRrrrqKpYuXcoLL7wASMFVdXU1N998MzfeeKPtOevr63nuued47733bI//17/+xeuvvw7AqlWruPrqq1m2bJltX2eyWCxs3LiRv/zlL3z33Xd0dHSQn5/PNddcY9umtLSUZcuWAXDkyBFuuOEGrrrqKm677TZbzHDjjTfyt7/9jRtuuIG3336bbdu2ce2117JixQp++tOfUltbC0B9fT233HILV155JQ8//DCXXHIJ9fX1AKxdu5ZrrrmG5cuX8/DDD2Mymfr/pTmAsr8Nqqqq0Gq1tusajYbs7OxzbqPVaqmqqiIyMtJ22/r167n88ssHNCiz2UxeXt6AthUEQRiI9vZ28bniQAeL65is9T3nzzjWt5OtNXr2HjyC2rv3QEwQPI34bHEvnZ2dtiyN4siHKLJX23X/pskrMU38UZ/3W0vlumeKrDo6OjCZTLb7jEYjBoOBtrY2zGYzYWFhvPnmmzz33HP87ne/480336Sjo4Orr76aFStWnPPxJpOJjo4O2tra+NnPfkZQUBAmk4k777yTefPmce211/L666/zyiuvEBISYnvO9vZ2FixYwHPPPcdVV10FwJdffslLL73E1q1byc/P55133sFisXDffffx3XffMX369B6vKysri+joaCIiIpg+fTqbN2/m0ksvpaOjgxMnThAbG8vnn39OZmYmOp2Oxx57jH/84x+EhoayceNGnn/+eR577DFMJhP19fW89tprAOh0Ot566y1kMhmffvopL7/8Mr/5zW/4xz/+wfTp07ntttv4/vvv+eCDD2hvbycnJ4d169bx+uuv4+XlxVNPPcUnn3xiC+yGq7Oz86y/9bS0tF637TfAsljO7vgkk8kGtY3BYGDbtm385je/6e/pAJDL5X0OWBAEYSjy8vLE54qD1LV0UNdawPnj40hLS+pzu4WqWt7K2oPeN5JZqZF9bicInkR8triXvLw8fH19pSteKpDb92SOwksF1v33wsvLC6VSeXoM3Xh7e6NQKGz3KZVKVCoVvr6+yOVyFi1ahK+vL+np6RgMBsLDwwHw8fGhs7PznI9XKBR4e3vj6+vLmjVr+PDDDzEajdTU1FBaWsqUKVOQy+X4+PjYHm+9npGRQUNDAzqdjoaGBoKCgkhKSuKjjz5iz549tmxca2srFRUVZ722zZs3s2zZMnx9fbniiitYu3Ytl19+OUuXLmX79u3ceeedbN68mb///e9UVlaSn5/Pz3/+c0BKqkRERNhewxVXXGHbf3FxMb///e+pqanBYDAQGxuLr68vhw4d4sUXX8TX15cFCxYQFBSEj48PWVlZ5OXl2TJ07e3taDSaXn8XQ+Hl5TXgv/V+AyytVktlZaXt+pmZqd62qays7LHNjh07mDBhgu2NIgiCIIwc/TW4sJoSG4xcBlnFjVwiAixBEBxt6krp4kTJycls3Lix1/sUCgVms9l2vaOjo8f9Xl5egBT4qFQq2+1yuRyj0djv4wFKSkp4/fXX+fjjjwkKCuLBBx/sdbszLVy4kI0bN1JbW8vSpUsBKYFy5513ct111/X5OJPJxKZNm9i2bRsvv/wyFouFxsZGWlpaWLJkCffddx+ZmZnIZDISExM5duwYycnJfPDBB73ur3sw9OSTT/LTn/6USy+9lD179vDiiy/axtUbi8XClVdeOeCEjiP1Owdr0qRJFBUVUVJSgsFgYP369cyfP7/HNvPnz2fNmjVYLBYOHjyIWq0+qzzQ+ssSBEEQRhZrgJXeT4Dl760kVRsoGl0IgjBizZ49G4PBwIcffmi7LTs7m7179xITE0N+fj4Gg4Hm5mZ27do1qH0P5PF6vR5fX1/UajW1tbXs2LHDdp+/vz96vb7XfS9dupQvv/ySjRs3snDhQgAuuOACPvnkE9tjqqqqzmrWsXPnTsaPH88333zDtm3b2L59O5dddhlbtmwhPj4euVzOv//9bxYvXgzAmDFjqK+vJysrC5DK7k6cONHrmJqbm9FoNACsWbPGdvv06dP56quvAPjuu+9oamoCYM6cOWzcuNE2xsbGRsrKys7xE3WcfjNYSqWShx9+mNtvvx2TycTVV19NcnKybcLdypUrmTdvHt988w2ZmZn4+vry9NNP2x7f1tbGzp07efzxxx33KgRBEASXySlvIibYl2A/Vb/bTosP5vOD5ZjNFuRyWb/bC4IgeBKZTMaLL77I008/zauvvoq3tzcxMTH84Q9/ICoqikWLFrFs2TISExNJT08f1L4H8vjx48eTnp7O0qVLiYuLY9q0abb7fvSjH3HHHXcQERHBO++80+NxycnJ6PV6IiMjbUmSCy64gPz8fFsGy8/Pj+eee46wsDDb49avX8+CBQt67Ouyyy5j9erVrFixgiVLlvDss8/aGuSpVCpeeOEFnnzySZqbmzGZTNx8880kJyef9Vruvfde7rvvPjQaDVOmTKG0tNR2+/33389XX33FzJkziYiIICAggNDQUH71q19x6623Yjab8fLy4uGHH3ZJgz2Zpa88mwtlZWWRkZHh6mEIgkM0thp4e9cpfn7xWJQKsda3s4h5Eo4z//mvSdYE8MqNM/rd9pP9pfzmo0Ns/NVFpGrVThidIDiW+GxxL+L3MfIZDAbkcjlKpZKsrCweffRR1q5d6/DnHcx7q98MliAI9rUuu4K/bT7OnLFhzEwMdfVwBGFY9B1GCuv0rMgY2BnCjPhgALKKG0SAJQiCIAxaeXk5v/rVr2xZqieeeMLVQzqLCLAEwckKaqRa5uNVzSLAEjxeXoUOi6X/BhdWY8L9CfHz4kBxA9fNinfw6ARBEISRJjExscecLHck6pMEwckKalsAOF7Z7OKRCMLwne4gGDSg7WUyGRnxIRwobnTgqARBGM3ccPaL4OEG+54SAZYgOJk1g3WsSgRYguc7UtZEmL8KTaD3gB8zLT6Yk9UtNLV2OnBkgiCMRj4+PtTV1YkgS7Abi8VCXV0dPj4+A36MKBEUBCfqMJoobWgF4FhlMxaL5ayFuwXBk+SU60iPDhzU+zgjPgSAg6WNzEuJcNTQBEEYhWJjYyktLaWmpsbVQxFGEB8fH2JjYwe8vQiwBMGJTtW1YrbAlLhgDpU0UttiIEI98DP/guBODEYzJ6qbuSglaVCPmxInLTh84FSDCLAEQbArLy8vxowZ4+phCKOcKBEUBCeylgcumqAF4IQoExQ82PGqZjpNlgE3uLAK8FaSolFzQCw4LAiCIIxAIsASBCeyNrhYOEFamVzMwxI8Wa6twcXgAiyAaQkhHCxpxGwW8yQEQRCEkUUEWILgRAU1eiLV3rZW1cdFgCV4sJzyJvxVChLD/Af92Iy4YJrbjeTXtDhgZIIgCILgOiLAEgQnKqhpISnCH5lMRopGzTHRql3wYDnlOtKiApHLB9+oZVqC1OhClAkKgiAII40IsATBiQpq9SRFBACQqlVzvKpFtJIVPJLZbCGvQjek8kCApHB/gv28OHCq0b4DEwRBEAQXEwGWIDhJg95AY2snSeFSOVWKRk1Lh5HypnYXj0wQBq+oTo/eYBrwAsNnkslkZMQFiwyWIAiCMOKIAEsQnMTa4CIpQgqwUrVqAI6LMkHBA+V0NbhIH2IGC6T1sE5Ut9DUJhYcFgRBEEYOEWAJgpPkd7VoTwqXSgRTIqUAS3QSFDxRTrkOL4U0l3CopnUtOHyopNFOoxIEQRAE1xMBliA4SUGNHi+FjNgQXwCC/LzQBvqIDJbgkXLKm0jRqFEph/5vZEpcEDKZaHQhCIIgjCwiwBIEJymoaSEhzB+l4vSfXYpWLTJYgsexWCzklg+9wYWV2seLVI2aA8WN9hmYIAiCILgBEWAJgpMU1OptDS6sUjUBnKhuwSQWWxU8SJWugzq9YcgNLrrLiA/mYHGDWHBYEARBGDFEgCUITmAyWzhVp2dMRM8AK1mjxmA0c6pO76KRCcLg5ZQ3AQw7gwVSowtdu9HWBEYQBEEQPJ0IsATBCUobWuk0WRjb1eDCKrWrQcBxUSYoeJAjZTpkMkiLGn6AZW10IdbDEgRBEEaKAQVYO3bsYOHChWRmZvLqq6+edb/FYuHJJ58kMzOTZcuWkZOTY7tPp9Pxy1/+kkWLFrF48WKysrLsN3pB8BAF1g6CZ2WwpIDreJU4ey94jpzyJsaE+ePvrRz2vpLC/Qny9RKNLgRBEIQRo9//jiaTiccff5w33ngDjUbDNddcw/z58xk3bpxtmx07dlBUVMSmTZs4dOgQjz76KB999BEATz31FBdeeCEvvPACBoOB9naxqKow+uTXWNfA6pnB8lMpiQ/1E40uBI+SU64jIz7YLvuSy2VMjQsmSzS6EARBEEaIfjNY2dnZJCQkEBcXh0qlYunSpWzdurXHNlu3bmXFihXIZDKmTp2KTqejurqalpYWfvjhB6655hoAVCoVgYHDLykRBE9TUKsn2M+LUH/VWfelaNSiVbvgMRpbDZQ1ttmlwYXVtPgQjlc3o2sXCw4LgiAInq/fDFZVVRVardZ2XaPRkJ2dfc5ttFotVVVVKJVKQkND+f3vf8/Ro0eZMGECf/zjH/Hz8zvnc5rNZvLy8gb7WgTBbeWcqibKX97r+zpM2cH2mhYOHclFpZC5YHSjQ3t7u/hcsYODFW0AqI2Ndvt5hstasVjgi++zmRZ97v8PguBuxGeLIIxeaWlpvd7eb4BlsZzdOlcmkw1oG6PRSG5uLg899BBTpkzhySef5NVXX+VXv/rVOZ9TLpf3OWBB8ESVn5VxwbiIXt/X53eU8cHhg3iHxzJeKzK8jpKXlyc+V+zgu5oCoILFsycSFuBtl33GjOnkT1sqqbUEkpaWbJd9CoKziM8WQRDO1G+JoFarpbKy0na9qqqKyMjIc25TWVlJZGQkWq0WrVbLlClTAFi0aBG5ubn2GrsgeISWDiNVuo6zGlxYpWqlToLHRJmg4AFyypvQBvrYLbgCCPTxIjkygKwS0ehCEARB8Hz9BliTJk2iqKiIkpISDAYD69evZ/78+T22mT9/PmvWrMFisXDw4EHUajWRkZFERESg1WopKCgAYNeuXYwdO9Yxr0QQ3FRhVwfBsX0EWEnhASjlMtGqXfAIOeU6u6x/daZp8SFkFTeKBYcFQRAEj9dviaBSqeThhx/m9ttvx2QycfXVV5OcnMzq1asBWLlyJfPmzeObb74hMzMTX19fnn76advjH3roIR544AE6OzuJi4vjz3/+s+NejSC4IesCqmd2ELRSKeWMCffnWKVo1S64tzaDifyaFhZP1Pa/8SBNiw/hfz+UUFCrZ1xk738rgiAIguAJBrSIybx585g3b16P21auXGn7XiaT8cgjj/T62LS0ND799NNhDFEQPFt+jR6ZDBLC+p68n6JVc7i0yYmjEoTBO1qpw2yBdDt2ELSalhAMwIHiBhFgCYIgCB5tQAsNC4IwdIW1emJDfPFWKvrcJlWjpri+lVaD0YkjE4TBySnXATAxxv4lgknhAQT6KMV6WIIgCILHEwGWIDhYQU0LSeHnPiOfopHuP1ElygQF95VTriPI14uYYF+771sulzE1PoSsYtHoQhAEQfBsIsASBAeyWCwU1ur77CBolaLp6iQoGl0Ibiy3vIkJ0YFnLdVhL9PigzlW1UyzWHBYEARB8GAiwBIEB6rUtdNqMPXZ4MIqIcwflVLOCRFgCW6q02Qmr7LZIR0ErabFh2CxwKESMR9REARB8FwiwBIEByqwtmgPP3cGSyGXkRwZwDFRIii4qfyaFgxGMxMc0ODCakpcMIAoExQEQRA8mgiwBMGBCmqlAKu/DBZIjS6Oi8WGBTeVUyY1uHBkBivIV1pw+IAIsARBEAQPJgIsQXCggpoW/FQKNIHe/W6bolVTqWunqVXMPxHcT065Dh8v+YBOFgzHtPgQskoasVjEgsOCIAiCZxIBliA4UEGNnjHh/gNqCpDa1ejieLXIYgnuJ6e8ifHaQBRyxzS4sJqWEExjayeFXdlfQRAEQfA0IsASBAcqqG0Z8Bn/FG1XJ0FRJii4GYvFQm6FzqHlgVYZ8SEAHBDrYQmCIAgeSgRYguAg7Z0mShvaSOqnwYVVdJAPAd5KjotOgoKbKalvo7nd6NAGF1bjIgJQ+yjFPCxBEATBY4kASxAc5FRdKxYL/a6BZSWTyUjRBIgMluB2csqltunOyGDJ5TKmxgVz4JQIsARBEATPJAIswWM1t3fSZjC5ehh9KqyVWq4nhQ+8KUCqVs3xqmYxwV9wKznlOhRyGaldZayONi0+hONVzbR0GJ3yfIIgCIJgTyLAEjzWDav28MDHh1w9jD7ld62BNWaAGSyAFI2ahtZOalo6HDUst1Xe2MbRSp2rhyH0Iqe8iXERAfh4KZzyfBnxwZgtkF3S6JTnEwRBEAR7EgGW4JEKa/UcKm1iT0Gd22Z7Cmr0aAK9CfBWDvgxKdZOgpWjb8Hhx77I4aev/+C2v8/RLKfcOQ0urDLirI0uRJmgIAiC4HlEgDXKdZrMfLivhE6T2dVDGZSNOZUA1LYYqGhqd/FoeldQ2zKo8kA4HWAdG4WNLo6U6ajUtVPa0ObqoQjd1DR3UN3cwYQYxze4sAry82JcZIDoJCgIgiB4JBFgjXI7jtfwfx9n88WhclcPZVA2HKlE7SNlhrJLG107mF5YLBYKavQDbnBhFR6gItRfxYlRFmA1thooa5QCq/2iuYFbcWaDi+6mxQeTVdwgMpqCIAiCxxEB1ihX0DVP6MvDFS4eycBVNLVxsKSRW+eOwUsh41Bpk6uHdJaG1k6a2joZM8AW7Va2ToKjLMDKrTg992rfqXoXjkQ4U0659LtJd3qAFUJDaydFda1OfV5BEARBGC4RYI1yBbVSgLXjeC269k4Xj2ZgNh6RygOXT40mVavmsBsGWAU10hyqsQNcZLi7VI2a45Wjq5NgXoUUUI7Xqtl/qtG1gxF6yC3XER/qR6CPl1Of17bgsMhoCoIgCB5mQAHWjh07WLhwIZmZmbz66qtn3W+xWHjyySfJzMxk2bJl5OTk2O6bP38+y5YtY/ny5Vx11VX2G7lgF0W1etQ+SgwmM1tyq1w9nAHZkFNJiiaApIgAJscGk13a6HbBiDUzONgSQYAUrRq9wWQrmRsNcst1RKi9WThBy7FKHc0eEuyPBjnlTU4vDwRIjgxA7S0WHBYEQRA8T78Blslk4vHHH2fVqlWsX7+edevWcfLkyR7b7Nixg6KiIjZt2sQTTzzBo48+2uP+t956i7Vr1/Lpp5/adfDC8BXW6slM0xAd5OMRZYJ1LR3sLaxn0QQtAFNig9C1G92ujCi/tgWVQk5siN+gH5tq7SQ4isoE8yp0pEcFMiMxBLMFskRzA7ega5dK9FwRYMnlMqbGB4v3giAIguBx+g2wsrOzSUhIIC4uDpVKxdKlS9m6dWuPbbZu3cqKFSuQyWRMnToVnU5HdXW1wwYt2EebwUSlrp0x4f4snhTlEWWCm3OrMFtg4UQpwJocGwy4X6OLgho9CWF+KOSyQT822dpJcJS0ajcYzZyobiYtKpCpccHIZaLRhbvI65p/NSHaeR0Eu8uID+FopQ69WHBYEARB8CD9BlhVVVVotVrbdY1GQ1VV1Tm30Wq1Pba57bbbuOqqq/jggw/sMWbBTorqTi+Eu2RSlEeUCW7IqSQu1Jf0KOmMenJkAD5ecrLdbB5WQU3LkMoDAYJ8vYgK8hk1GayT1S10miykRwei9vEiVRsoAiw3kWMLsJyfwYLTCw4fcrMTKIIgCIJwLv2ugNrb3BaZTDbgbVavXo1Go6Guro5bbrmFpKQkZs6cec7nNJvN5OXl9Tc0YZi+LZIyJBZdNT5KFRH+Cj7YeYI0X/c8sNcbzHx3ooblaUEcPXrUdntSsBe7j1eQlzf4bJEjmMwWTtXpmaZRDvl9HBMg49CpmlHxd7A1X3q/+bTVkJfXxNhA2Jpfx5Gc3CFlAPvS3t4+Kn6e9rQzr5oQHwV1ZYXUlTn/+f07TABs3HecEEON8wcgCAMgPlsEYfRKS0vr9fZ+AyytVktlZaXtelVVFZGRkefcprKy0raNRqMBICwsjMzMTLKzs/sNsORyeZ8DFuxnW+VJoJr5Myfi763kigJ4Z9cpYsaMc3rHsIFYe7AMoxmuv2gCaQkhttvPO2nmf3tLSE5JRalwfWPMolo9RnMhM8cnkJYWN6R9TCuEN3cWuc1rcqSP83Px8arj0lmTUchlLGgvY92xg8hCYkizY2laXl6e+FwZpNKNNUyOD3Xpz23s1lrK2r3E705wW+KzRRCEM/V75DZp0iSKioooKSnBYDCwfv165s+f32Ob+fPns2bNGiwWCwcPHkStVhMZGUlraystLVKWpLW1le+//57k5GTHvBJh0Apr9USqvfH3luLspZPdu0zwq8OVRKq9yYgL7nH75Ngg2jpNnKxxjzlLBbXWFu1DKxEESNGoMRjNnKp3r+YdjpBXoSNVG2jLVk3vCp5FmaBrdRhNnKxucVl5oNW0+BAOFLtfp1BBEARB6Eu/AZZSqeThhx/m9ttvZ8mSJSxevJjk5GRWr17N6tWrAZg3bx5xcXFkZmby0EMP8cgjjwBQV1fH9ddfzxVXXMG1117LvHnzuOiiixz7ioQBK6rV91gINyMumOggH9Znu183wTaDia+PV7Nwghb5GWVjpxtduMc8LFuL9vDBr4FllaKRHnu80j3LNe3FYrGQW6EjPUptuy02xBdNoDf7ikSA5UrHK1swmi0ua3BhlREfQr3ewCk36xQqCIIwGBaLhYMlja4ehuAk/ZYIghRAzZs3r8dtK1eutH0vk8lsQVV3cXFxfP7558McouAoRXV6FqRpbNdlMhlLJkXx9q5T6No73apM8JvjNbR3mlk8UXvWfWPC/FF7K8kubeRHM4ZWkmdP+TV6Qvy8CPFXDXkf4yIDkMngWFUziydF2XF07qVS105ja6etaQlI78PpCSEig+ViOeXSCQuXZ7ASggE4UNxAYvjQs8KCIAiutOFIJT977wDv3DaLC5MjXD0cwcFG9uQOoU+69k5qWwxnHbAscdMywY05lQT7eTFrTOhZ98nlMibFBrlRBqulR2ZwKPxUSuJD/ThR5R5lj46S29WlLi2q50H89IRQyhrbqGxqd8WwBKQOggHe0vvQlZIj1QR4K8V6WIIgeLQdJ2oB+GR/qYtHIjiDCLBGqaLarhbtZwQC7lgmaDCa2ZJXRWaaps+GD5Nig8ir0NFhNDl5dGcrrNWTFDH08kCrFI2aYyO8Vbs1wBp/RoA1Q8zDcrmc8ibSowPPKsl1NoVcxtS4YA4Ui/eCIAiea1e+FGBtzKkSa/uNAiLAGqUK+wiwrGWC356opanNPRYd3plfS3O7kUW9lAdaTYkNptNk4ZiL5yw1t3dS3dwx5DWwukvVqCms1btF0OgoeZU6EsP8CPDuWa2cHh2Ij5ecfafqXTSy0c1ktpBX0ezy8kCrjPhgjlY202oQByWCIHiessY2iupaWTJJS1uniQ1HKvt/kODRRIA1ShXW6pHJ6LX8x93KBDfmVBLgrWTuuPA+t5kcK03EP+TiMkFr4DqcBhdWKVo1JrPF1jRjJMot151VHgjgpZAzJTZYZLBcpLBWT1unyeUNLqymxYdgMls4VOIeZcCCIAiDsSu/DoBfzE8mLtSXz7JcsLCg4FQiwBqlCmv1RAf54uOlOOu+jLhgYoJ9+fKw68sETWYLm3KquGR8ZK9jtYoJ9iXMX0W2izv0WIOh4bRot0rVSJ31jo/QMsGWDiOn6lt7NLjobnpCCDnlOpG1cAF3aXBhlREfDEBWiQi4BUHwPDtP1hLmryJVo+bKqTF8n19LlU7MMR7JRIA1ShXV6vssY5PJZCyeqGXHiRqXlwnuK6qnTm9g0YS+ywNBGvOk2CAOl7n2DHdBTQtyGcSHDb8xwJhwf5RymcvLHh3lWKUOi+XsBhdWMxJF1sJVcst1qJRyxkUOPxNrD8F+KpIi/DlwqtHVQxEEQRgUi8XCzvw6Zo8NQy6XsSIjBosF1h4UWayRbNQEWJ0mMz96ZRcf7itx9VBczmKxUFirJzGs7yzL0slRdJosLi8T/OpIJSqlnItT+29pOjk2mONVrp2nUVCrJzbED29l39m2gVIp5SRF+I/YDFZuhfS60vvIkkyLtza6EPOwnO1IeROpGjVefTSVcYWMuBCyihvEgsOCIHiUwlo9lbp2zh8bBkBSRABT4oL59IAIsEYy9/nv6WCfHihlb2G9ywMGd1CvN6BrN55zTZmpblAmaLFY2JhTyUXJEfh7979k25TYIMwWqb20qxTU9J0ZHIqR3Ekwt1xHkK8XUUE+vd4f7KdiXGSAmIflZBaLhZxynduUB1pNSwimTm+guF4sOCwIgufY2TX/6vyxp+eRX5URw9HKZvIqXHe8IjjWqAiwOk1m/rXtJAAnqkf2ukIDUVRnbcTQdyDgDmWC2aVNVDS197q4cG8mWRtduGgeltksZQbt0eDCKlWjpqS+bUS2dM2t0JEeFYhM1ncb8BldCw6bzSJr4SzlTdLiz24XYHVlNMV6WIIgeJJd+XVEBfmQ2G3qwLIp0SjlMtHsYgQbFQHWpwdKKW1oY2pcMKfq9LR3jty21wNhbcRwrgwWuL5McENOJUq5jEvTIge0faTah6ggH5fNw6rUtdPWabJvBksrNboYaScGTGYLxyp1fZYHWk1PCEHXbuRkzch6/e4sp+vvJ91NOghapWjU+KsUYj2sEaimuYN73jsgstXCiGM2W9hVUMecsWE9TiaG+qu4ODWCtQfLMIkTiCPSiA+wDEYpezUlNog7LkzCbIGTI+xgdbCK6vQo5TJiQ3zPuZ21THC9C8oELRYLG45UMmdsGMF+qgE/bnJsENkuatVuDVztGWDZOgmOsEYXhbV62jvNfTa4sJouFhx2upxyHTIZpEWpXT2UHhRyGVPEgsMjjsFo5p73DrD+cAV3vL2PElECKowgx6qaqdcbepQHWl2ZEUuVroOdXQsQCyPLiA+wrNmrXy1IIUUjlW6dqB5ZB6uDVVirJy7Ur98J7NKiw1q+dUGZ4PGqFgpr9Szsp3vgmSbHBlNYq3dJWWNBrRS427NEMC7UD2+lfMTNw7LWnffVot1qTLg/Yf4q9hWJg2pnySnXkRTuj5+q/3mPzjYtPoS8CrHg8Ejy5Ppc9hbV88BlKRhNZm5/ax8tI7AkWhidrPOv5nQ1uOju0rRI1D5KPhPNLkakER1gGYxmXtwuZa8uTo0gMdwfL4WM41WjO4NVWNvKmH7KA62WTHJNmeCGI5XIZHDZBM2gHmddcPiwC7JYBTV6/FUKNIHedtunQi4jWRMw4joJ5lbo8FLI+m0DLpPJmJYQIrIWTpRb3uQ2CwyfaVpCMCazxSV/34L9fbivhLd3neKOC8dw7/xk/v2T6ZysaeG+1VmibEoYEXbl15IY5kdM8NkVQz5eCpZOimJDTqU4aTQCjegAq3v2SiaT4aWQkxQeMOLKrQbDYrFQ1E+L9u5cVSa4IaeSGQkhRKp77zDXl8kxwQBklzXaf1D9KKjVMybC/5xNG4YiRaMecQFWXoWOcZFqVMr+P4KmJ4RQWKuntqXDCSMb3Rr0Bsqb2t2uwYVVRpxUMnpANLrweFnFDfzpsyNcMC6c3y0aD8AFyeE8uiydrUereXbDURePUBCGx2gys6egnjm9lAdaXZkRQ6vBxKYc0eF6pBmxAdaZ2SurZE0Ax0dxiWCVroO2ThNjwge2EK4rygRP1enJq9ANujwQIMjPi8QwP7JdsDhtQU2LXcsDrVI1aqp0HTS2Guy+b1fJLdcNeI7PDDEPy2msSxy4awYrxF/FmHB/kdH0cNXN7dz97n40Qd78a2UGym7l6jfOSeTG2Qm8sqOAj8S6lYIHO1Kuo7nDaFv/qjczE0OJCfblU9FNcMQZsQHWmdkrK2vb69Gaji2slRoxjBlEIGAtE9zspDLBDUcqAYYUYIE0Dyu7tNGOI+pfe6eJssY2uza4sLJ2Ehwppa21LR1UN3f0O//KamJMECqFnAMiwHK4nHLpxIS7ZrAAMuKDxYLDHsxgNPPzdw/Q1NbJKzfMIMT/7CZGDy9LZ+64MP7w2WF+KBILjQueydq8orf5V1ZyuYwVGdF8d6KGal27s4YmOMGIDLD6yl4BJHd1ZTsxQg5WB8saYCUOMIMFzl90eENOJZNigogLHfgYu5scG0R5Uzs1zc4rKSuq02OxMOC5bYNh7SQ4Uhpd2BpcDPAg3sdLwcSYQPaJAMvhcsp1xAT79nrQ6y6mxYdQ22KgtKHN1UMRhuDxdTnsO9XAs9dM6fMzwEsh59/XTycuxI+73tkvOgsKHmlXfh3jtWrCA849L/vKjFjMFvj8ULmTRiY4w4gMsPrKXgG2ToIjbU7LQBXV6VEp5UQHnbtFe3fOLBOsbGonq7iRRQNcXLg3k2ODATjsxHlYhV0t2sdG2L9EMCrIB7W3csTMHcwtH1gHwe5mJIZyuLRp1K9h52g55U0DDnxdxbrgsCgT9Dwf/FDMu7uLueuiJK6YEn3ObYP8vFh18wzRWVDwSB1GEz8U1Z8ze2U1LjKAybFBfCq6CY4oIy7AsmWv4oLPyl4BJIT5o1LKR9zCrQNVUKMnMcwPuXxwjRiWTo52SpngptzhlQeCVN4kl8EhJ87DKrCVXto/gyWTyUjRqkdUBis6yGdQ65tNiw/BYDLbStgE+2s1GCmo1bt1eSBIJ8n8VApRMuphDhQ38NCaHC5MDuf/uppa9CcpIkB0FhQ80sHiRto7zb2uf9WbKzNiyK3QcWyEnEgVBhhg7dixg4ULF5KZmcmrr7561v0Wi4Unn3ySzMxMli1bRk5OTo/7TSYTK1as4K677rLPqM/hE1v2KrnXbm4KuYxxEQGj9k1cVKcfUhAwJTbIKWWCXx2uZFxkQL/tu8/F31vJuMgAp87Dyq9pQRvog7+3Y9YOsnYSHAnzTnIrdP0uMHwm64LDYj0sx8mraMZicd8GF1ZKhZwpscGik6AHqda1c/c7+9EG+fCvlRkoBnGC74LkcB4RnQUFD7Mzvw65DGaNCR3Q9sumRKOQy/g0q9TBIxOcpd8Ay2Qy8fjjj7Nq1SrWr1/PunXrOHnyZI9tduzYQVFREZs2beKJJ57g0Ucf7XH/22+/zdixY+068N4YjGZe3NaVvUo5O3tllaIJ4MQIyQYMhslsobiulcQhBFjOKBOs1xvYU1jHomFkr6wmxwZzuKzJaQFJQY3eIQ0urFI1ATS2djp1XpkjtHeayK/RD7oMLULtTWKYn5iH5UC5HtDgwmpaQjB5FTraDKJk1N0ZjGZ+9t4BmtuNvHrT9EFlrq1uEp0FBQ+zK7+OSTFBBPl6DWj78ABv5qVEsDarHLPI1I4I/QZY2dnZJCQkEBcXh0qlYunSpWzdurXHNlu3bmXFihXIZDKmTp2KTqejuroagMrKSr7++muuueYax7yCbj45UEpZY9/ZK6sUrZrypnaa253TdtxdlDe2YTCZGTPANbDO5OgywS25VZgtDGv+ldWU2CBqW6Q1fRzNYrFILdodGGBZOwl6epngiaoWTGbLoDNYgLTg8CnRPc5RjpTpCPHzIipocGvPucKMhFCMZgtfH6t29VCEfjz6RQ77TzXw3LWTGa8devAuOgsKnqLVYCSrpOGc61/15sqMGCp17ewuqHPQyARn6reeqaqqCq329AGvRqMhOzv7nNtotVqqqqqIjIzk6aef5re//S16vX7AgzKbzeTl5Q14e4BOk4W/bywhNdwbjamWvLy+36C+Bmksm/ccIS3S/Q8m7GV/mdSJSa6vJS9v4L8PK5XFQqS/kg92HmeCn/0P9D/eU4kmQIm8qYw83fC66aiNUmD15e4jXJBg/8YT3TW2mdC1G/Ez6Qf9vh0oWbt0pv7bQycJN9Y65DmcYesJqcGFd2sNeXmNg3psjHcHdXoDW/ceJiZwYGcFu2tvb3fY72ck2F9QRWKQkqNH3b8MK8JsITbQi2fWHyZO3jCokjPBeb46ruP9PbVcOzGIsV5N5OUNbw7lfTMC+HW1jtve2MMLl8egCRj854AjiM8Wobv9Za10mizEeg3umCBObsbPS8Yb23MI6Yx04AgFe0pLS+v19n4DrN7OFp+ZHeprm+3btxMaGsrEiRPZs2fPQMeKXC7vc8B9Wb23mGq9kWd+lEF66rnfmP6RrTy2rQqDbxhpafGDeh5PtrehCKjk4unpRAYOLbBcUSTjje8LiU4cN+DU90A0t3dysKKIm+YkkJ6ePuz9JRlN/HZDBXUWNWlpA5tQPVTS2dRTzJmYRFo/773hCFtXQSN+g/7bcCcfnMjBX9XAJTMnDbrRiiK0mX/t2kGjMpQFabGDfu68vDyP/tk5UqfJTHFTEbfMjfWYn9HvjMH8YnUW+Z1BLJ8a4+rhCGfYf6qe/+wt5KKUCP5y/Uy7BcFvxyRy5Uvf8+fvGvnk5+cT4KB5r4MhPluE7tYWHcVLIeOqi6bgpxrc+/PyY0bWZ1fwwtgUfFUKB41QcIZ+SwS1Wi2VlZW269bM1Lm2qaysJDIykgMHDrBt2zbmz5/P/fffz+7du3nggQfsOHzJQOdeWcWG+OLrpRgxC7cOVGGtHn+Vggj1uddkOBdHLTq87Wg1BpPZLuWBAN5KBeO1gU5p1V5QI72Pxg5i8eahkBpdePZ7Nrdcx/iowEEHVwDjIgII9FGy/5QoD7K3E1UtGExmt2/R3t3SSVGM16r5x5YTGE1mVw9H6KZK187d7x4gOtiXf103uKYW/RkrOgsKbm5nfi0ZcSGDDq4AVmTEoDeYbB2VBc/Vb4A1adIkioqKKCkpwWAwsH79eubPn99jm/nz57NmzRosFgsHDx5ErVYTGRnJb37zG3bs2MG2bdv429/+xuzZs3n++eft/iIGOvfKSi6XkawJGHVrYRXW6kkM9x/Qz6gv1m6C67PtuyDexpxKItTetjVu7GFybBDZpU0OnzBaUCOtLRYTMvC1xYYiVavmRFWzx06AtVgs5FXoBrX+VXdyuYxpCSGik6AD5NgaXLh3B8Hu5HIZv7kslcJaPZ8cEJ233EWH0cTd7+5H32Hk1RtnEORn/zI+d+gsaLFY2HCkkkX/2MFj28TBsCBpau3kSFnTgNa/6s3sMWFEB/nwWZZYE8vT9RtgKZVKHn74YW6//XaWLFnC4sWLSU5OZvXq1axevRqAefPmERcXR2ZmJg899BCPPPKIwwduZc1eTR1g9soqOVI96gKsobZo704mk7F0chTfnaylqdU+TULaO01sP1rDwgmaIWU2+jIlNpjmdiNFdYOfbzYY+V1rizl6HkiKRo3eYKKssc2hz+MopQ1tNHcYh9TgwmpGQggnqlvs9t4TJDnlOny9FA5Zx82RFqRFMiUumBe2nqTDKDoKuoNHP88hq7iR56+dQmpXcx5HuGlOIjfMjnd6Z0GLxcK3J2pY8dL33P3ufk5Wt3CgvE1k0gQA9hTWYbbA+UMMsORyGcszYvj2RK3Hdw0e7Qa0Dta8efPYuHEjW7Zs4Wc/+xkAK1euZOXKlYB00P3II4+wZcsWvvjiCyZNmnTWPs477zxeeeUVOw5dMtjslVWqNoDq5g4aWw12H5M7MhjNlDa02eUAylomaK8U9o7jNbR1mlg0Icou+7OaFCudjc8udezitAW1LU45ME3VSiWInnpiIKdcanAxnDK0aV3rYR0oFlkse8ot15EWpfa4ZhEymYzfXpZKWWMb/9sr2ne72nt7TrF6bwn3XDKWJZPs+3nem0eWTXBqZ8H9p+pZ+dpubvzvXmpbDDx7zWSeWDERg8lCcX2rw59fcH878+vw8ZIzNT54yPu4KiMGk9nC54fsWykkONeAAix31T17NW8Q2SuAZI10Zs3T57QMVElDKyazhcQhtmjvzt6LDm84UkmQrxfnJQ1sQb6BSo4MwMdL7tAAy2gyU1zXSlKEY+dfwen3rKe2as+r0CGXQapm6Ge1p8YFo5DL2CfmYdmN2Wwht0LnUeWB3c0dF8Z5Y0J5cftJsS6WC+0rqufRz3O4ODWC+zNTnfKcXgo5/75+OrEhftz1zn5KHBTk5JbruO3NH7j6P7s4Wa3nsSsmsO2BefxoRpyt5NlTT3wJ9rUrv46ZiaF4K4feoCJZo2ZiTCCfiUWHPZpHB1gf7x9a9gqkcisYPR+KRbVSmdwYO6zVZM8yQYPRzJa8KjLTNXgp7Pt2VCrkTIwOIru00a777a6koQ2j2UKSEzJYgT5eRAf5cLzSM9+zuRU6xoT7D6szkp9KSXpUIPvFgsN2U1zfSkuH0SMWGO6NTCbjgYWp1DR38NauIlcPZ1SqbJKaWsQE+/JPOze16E+Qnxerbp6B0WTm9rf20dJhtNu+C2pauPf9Ayx54Vt+KKrn/xalsuP/Lubm8xNtB9DjIrsqCzz0c1mwn5rmDo5VNQ95/lV3V2bEcqRMx4lRcow6EnlsgGUwmnlp+9CyVwDRQT4EeCtHzZu30Bpg2SGDBVIHL3uUCe4uqEPXbmTRBPt0DzzTpNggjpQ3OazLmLWDoDMyWCAtOHzMQ7OueRU60u2QJZmeEMLBkkY6Rec4u7CWbk6M8cwMFsDMxFDmpUTw8jf5o24BeVezNrVoMxh59aYZdl2+Y6DGRgTw0k+m2a2zYFljG7/7OJvMv+9g29FqfjF/HN/+bj4/v3jcWZ3h/L2VaAOUHltZINiPdYHg8we5wHBvrpgSjUIuE80uPJjHBljDyV6BdNYzWRMwaj4UC2v1BPt5EeKvssv+JscGERsy/DLBDTmV+KkUXJA8/A+k3kyJDaa908zJGscEJQU1UuA61g6ZwYFI1ajJr27xuLbUTW2dlDa0kRY1/EnvMxJDaO80k1ehs8PIhJzyJpRdnVU92QOXpdLY2sl/vyt09VBGDYvFwsNrcjhY0shffzTFVhniChcmRwy7s2BNcwePfp7DJc99zWdZZdw8J5Ed/3cJv7ks9ZyBY0KwatRUwwh925lfh9pbyUQ7VANEqL25MDmctQfLPbZz8GjnkQHWcLNXVimRak54aDZgsApr9XaZf2Ulk8lYOml4ZYIms4VNOZVcMj4SHy/HLKg32droosQx87AKalsI8fMi2M8+gWt/UjRqDCYzRXWeNaH6aFcwNNQW7d1N72p0Idq120dOuY5kjXpYcwbcwaTYIBZN0LLq20Ia9KOjeZGrvbunmA/2lfCL+eNYNNHxTS36M9TOgk2tnTy38SgXPbudd3af4urpMXz924t5eFk64QH9rxuZGKKioEaPwehZJ74E+9qVX8t5SaEo7TTd4cqMGMoa29hTKOYceyKPDLCGm72yStYEUKc3UNsy8lthFtUOv0X7mYbbTXD/qQZqWwwOKw8ESAzzR+2j5JCD5mHl1+idVh4I2Noee9rZ0lw7BlhRQb7EBPuKeVh2klOu89j5V2e6/7IU9AYjr+wocPVQRry9hfU89nkO88dH8usFKa4ejo21s+AfPzvCvn46C+o7jLy0/SQXPruNl7bnk5muYcv98/jzVZOJDh74uobxwV4YzRaHLwkiuK+yxjaK6lrtUh5odVm6Fn+VQjS78FAeF2DZK3sFnnuwOljtnSbKm9rtHmANt0xww5FKVEo5l4yPtOu4upPLZUyKCXJYJ8HCWr1TGlxYjYsMQCaDYx42oTq3XEd4gIoIdf9ngwdiekII+07VY7GI0onhqNa1U9vSMWICrBSNmuVTonlzZyHVze2uHs6IVdHUxs/f209cqB9///FUu65fOFxeCjkvXT+NmBDfPjsLdhhNvPF9IfOe285zG48xa0wYX913IS+szBjS/8nEYKmCwdM+lwX72ZXfNf9q3PAbXFj5qhQsmhjFV4crae8UHVI9jccFWPbKXsHpToIjvUzQelYt0c6BwHDKBC0WCxtzKrkoOZwAb2X/DxiGybHBHK3U2X0h0ub2TmqaO5yawfLxUpAQ6udxJwXyKnWkRQUO+2/WanpCCFW6Do9ddNldHCmXTjx4aov23vxqQQqdJgv/3p7v6qGMSO2dJu5+Zz9tBhOv3jjdJU0t+hPsp2LVzTPoPKOzoNFk5oMfirnkua957ItcUjRqPv35+ay6ecawFkCPDfJCIZd53OeyYD8782sJ81eREmnfeYhXTYuhucPI5twqu+5XcDyPCrCs2auM+OFnrwAi1d4E+ihH/IeitUW7IzItQy0TPFKmo6yxjYUOLA+0mhIbRKfJwtEK+/6erQ0ukpzU4MIqRaP2qPdsp8nM8coWu5QHWlnnYYkyweHJKZNKN+3RfMRdJIb7c+30WN7fUywCcDuzWCw8tOYIh0qb+NuPp9rW5nNH3TsL/up/WXx+qJzL/r6D331ymMhAH967/Tzev2M20+JDhv1cKoWcxDDPO/El2IfFYmFXfh2zx4bZPZs7OykMbaCP6CbogTwqwPpof0lX9irFLmfCZTIZqVrPOlgdioJax2Sw4HSZ4PpBlgl+daQChVzGgjSN3cd0pslxwQB2Xw+roFbKfDqrg6BVqlZNUV2rx5QMFNToMZjMpNuxDG28Vo2/SiECrGE6Ut5EYpgfah/3y0IMxy8uTQbgX1tPuHgkI8s7u0/x0f5SfnlpslNOjg2XtbPglrxqfrk6Cy+FnNdumsFnPz+fuePs27lWOvE1sqthhN4V1bVS0dTO+XZY/+pMCrmM5RnRfHO8hrpR0C9gJPGYAMtgNPPSNil7dZEdW3ond30ojuS5HEW1eiLU3g4pxbOVCZ4YeJmgxWJhw5FK5iSF2a1t/LlEB/kQ5q/ikJ3nYRXU6JHLIC7Uz6777U+KRo3JbLFl0NxdboX0cx9OCc6ZlAo5U+ODRSfBYeg0mdmZX8fMxFBXD8XuYoJ9uf68eD7aX2pbA1AYnqziBh7/IpcFaZH8qiuA9QQ3zUnkiRUT+ed1U/nqvgvJTNfYrVS5uxSNmqI6vcec+BLsZ2d+LWCf9a96c1VGLCazhS8OlTtk/4JjeEyA9dH+Esqb2u2WvbJKiQygqU2aSzNSFdbq7bbAcG+WTo7CaLawcYBlgierWyio1bNwonPOgMpkMibHBnHY3gFWrZ64UD+nt7f2tOYseRXNqJRyu5eoTk8I5Wilzja/QhicvYX1NLcbyUx3fBbZFX5+yVi8FDL+seW4q4fi8SwWC499kUuov4q/uVlTi4G4cXYCy6fGOHTcqVo1Fov0/00YXXbm1xEV5ENimGNOtqZq1aRHBYoyQQ/jEQGWo7JXACldB6sjecHhwtpWEsMdl2WZFDO4boIbjlQik8FCJx7YTY4N5kR1M60G+x2MF9Q4t4OgVWKYP14Kmce8Z3PLdaRq1HZbG8RqekIIZgscLG60635Hi825VXgr5VyYPPz5rO4oUu3DT88fw+eHykV3t2H6IruCgyWNPLAwlcARVk5qL9amWZ5y4kuwD7PZwu78OuaMDXNIZtTqqmkxHCptIr9GBPCewiMCLEdlr6D7h+LIfNM2t3dS29LBmHDHdbobbJngV0cqmRYfQmSgj8PGdKbJsUGYLVJzDXswmy0U1rY4tYOglZQNCuC4Bxw0WiwWcit0dm1wYZURH4xMBvtOiUUYB8tisbA5t4oLk8PxVXn2AsPncve8JAJUSv62+Zirh+Kx2jtNPPPVUdKiArl6Wqyrh+O2EsP8UCnkHnPiS7CP49XN1OkNDisPtLpiSjRyGXx2QGSxPIXbB1iOzF4BhAd4E+qv4sQI/VAsqpXWABnjwAwWDLxMsLiuldwKnUMXF+7N5NhgwH6NLip07bR3mp3eQdAqRav2iH/k1c0d1OsNDulSF+jjRapGLRpdDEFeRTNljW0jtjzQKthPxW0XjmFjTpXdm9yMFm/tLKKssY0/LklD4WGlgc6kVMhJivD3iBNfgv3sPCmtfzXHAQ0uuosM9OGC5Ag+yyrDbB65PQNGErcPsByZvbJK0QR4xMHqUBR2rYHlyAwWDLxMcGOOFIAtctL8K6sItTfRQT52W3C4oCtNb+/FmwcqVRNAaUOb288/yi2XMobpDlpnaXpCCFnFjZjEP5xB2ZJXhUwG88eP7AAL4LYLxhDi58VfN4m5WINVrzfw4vaTXJIawQUOOME50khdiUdmNYzQu535dSSG+RET7Ovw57oyI5qyxjZ+KBJVG57ArQMsR2evrFI0ak6O0E6ChV2d5hIcNPnSSiaTsXSyVCbY2Groc7sNOZVMiA50euc9kLJY9jqLbe3gN9YFJYLQfZFs9z4xkFshBVjjHbTO0ozEEFo6jGKOzSBtzq0iIy6YCLW3q4ficGofL+6eN5ZvjteIA5NB+ueW47QaTPxhSZqrh+IRUjRqyhrbaG4fWEddwbMZTWb2FNQxx8HlgVYLJ2jxUylEswsP4dYBljV79WsHZq9AatXe3GGkoqndYc/hKkV1emKCffHxcvw8i6WTpDLBTX2sOF6la2f/qQanlwdaTYoNoqiudcDt5M+lsFaPv0pBpIsOUD2lk2BuhY64UF+HTYyfkSC1GN9fLMoEB6qiqY3DZU1kprv/Okb2ctOcRCLU3jy38diIPJHmCPk1Lby3p5jrZsa59YLC7sR24kt0EhwVjpTraO4wOmT9q974qZQsmqBl/eEKsRyAB3DbAKvDaOKlbSeZFh/MhQ4uTUjVjNxOgoW1eod2EOyuvzLBTS4qD7Sa0jUP63DZ8MsE82ukBheODPzPJS7EDx8vOccq3fsfeV65YxpcWMWG+BKh9ma/yEwM2Ja8agAy0yNdPBLn8VUpuPeScewtrOfbE7WuHo5H+MtXR/FWyvnVghRXD8VjWI8lxDys0cG6/tXsJOcEWABXTouhud3ItqPVTntOYWgGFGDt2LGDhQsXkpmZyauvvnrW/RaLhSeffJLMzEyWLVtGTk4OAB0dHVxzzTVcccUVLF26lBdeeGHAA/toX6nD515ZpWikMi93L7caisJaPYkOXAOru/7KBDfkVDI2wt9lZ0MnxUrzgA7ZoUywoEbvsgYXAHK5jORItVtnsFoNRgrr9HZdYPhMMpmMGQkh7BONLgZsc24VY8L9XVbe6irXzYojJtiXv24SWaz+7C6oY3NuFT+/ZNyoKCO1l9gQX3y9FCPyZK1wtl35daRq1E79Gzl/bDiaQG8+Fd0E3V6/AZbJZOLxxx9n1apVrF+/nnXr1nHy5Mke2+zYsYOioiI2bdrEE088waOPPgqASqXirbfe4vPPP2fNmjV8++23HDx4sN9BmS0W/r3dOdkrkDpNRai9R9zk1Aa9gaa2Tqc2YuirTLBBb2B3Qb3LslcAQb5ejAn3H/Y8rPZOE+VNbSQ5uHFIf1I07h1gHa1sxmLBoRkskBpdlDa0UaUbeSW+9tbc3smu/Foy0zUuy766irdSwS8vHceh0iY291HGLEhLUDy5PpfoIB9uu2CMq4fjUeRyGSmaALf+XBbso8No4oeieod3DzyTQi5j+dQYvj5WTb2+7/nuguv1G2BlZ2eTkJBAXFwcKpWKpUuXsnXr1h7bbN26lRUrViCTyZg6dSo6nY7q6mpkMhn+/tLBvdFoxGg0Duifuq7D7LTslVWqmx+sDkVBrbWDoPMCrEkxQcSF+rI+u2eZ4Ja8KkxmC4smRDltLL2ZFBM07E6ChbV6LBYY48IMFkCqNoDq5g4a3PRDNq+rwYUjM1ggBViAaNc+ADuO19JpsrAgbeR3D+zN1dNiGRPuz982Hxetjvuw9lAZR8p0/HZRqlPm7o40yRrRSXA0OFjcSHun2Wnzr7q7MiMGo9nCuuxypz+3MHDK/jaoqqpCqz2dddBoNGRnZ59zG61WS1VVFZGRkZhMJq666iqKi4u5/vrrmTJlSr+Damg1khbhTbixhrw859TLh3kZ+KGomZzcXOQj5MzuznwpYDQ3VZKX57w5KudFq/gsp4a9B4+g9pb+QX+0u5JIfyUKXRl5ea77UNB6tVPR1M73Bw4T6tvv279X3xZJ/zxlzdXk5dmn7ftQ+BqkNc427z3CJK3jW8QO1vc5Nfh7yWmuLCKvynF/UwqTBZVCxqYDJxmjbOxzu/b2dvLy8hw2Dk/w8e5qAr3l+LVWkpc3OrM4P0rz55lvq3llwz4uHjO6yiT702E08/S6EpLDVKR460b938tAdf9sCZa1UtPcwe6sIwT5iAB1pPr8YD1yGYQYa8nLc/7JvTEhKt77/iQzg9uc/txCT2lpvXdZ7fcIs7da9TOzSufaRqFQsHbtWnQ6Hffccw/Hjx8nJeXck2Y7zfD7ZVNIT4nob3h2M7u5mLV5hwnUJrqkhbgjrC8+hkJey8UzJ+GlcF4/k5vVTXx85DuKjEH8aGocLR1GDr5bxI1zEkhPT3faOHrT4lvPq/t20e4bSdoQz+JvrTgBVHPprIn4qYYWpNlDcHQbD22ppMMnlLS0RJeNoy+V2+uZGBvslN/51PgmClvMfX7QAeTl5Z3z/pGu02Rm/wfFXDYxmokTXPt36EqpqRbWHP+Wj3L13LFwOkonfja6u5e2n6RGb+JfP5nJBCdO3Pd03T9bLlTUsGrfXgiKIk38DEesE9/sYlJMEDOnTHTJ86+sUfH0l0fxDo8jaZTNp/UU/f5n0Wq1VFZW2q5bM1Pn2qaysvKsbQIDAznvvPP49ttv+x2Ur5fMKXOvurO2Vx1J6+kU1umJC/F1anAFMDEmsEeZ4Paj1RhMZpfOv7KaEB2IXAaHhlEmWFCjJyrIx6XBFYA20Ae1j9ItJ1SbzBaOVjY7vDzQanpCCDllTbQZROvavvxQVI+u3ThqywOt5HIZ91+WQkGtXkwU76amuYN/bz9JZrrGqV3RRhpbJ0E3/FwW7KPVYCSrpMFp61/15oopMchksEasieW2+j3ynjRpEkVFRZSUlGAwGFi/fj3z58/vsc38+fNZs2YNFouFgwcPolariYyMpL6+Hp1OmofR3t7Ozp07SUpK6ndQ4X5Kp0/ATu7qJHi8euR8KBbV6kl04vwrK5lMxpJJUXx/UuomuCGnkvAAb6bFhzh9LGfyUylJjlQPq9FFfq1rOwhayWQyae6gG7ZqP1Wnp9VgIj3aOQHWjIQQjGaL3RaSHok251ahUsq5KMV1BwXu4rJ0DZNjg/jn1hN0GEVQDvCPLcfpMJr5/eLxrh6KR9MEehPooxQB1gi2r6iBTpPFJfOvrLRBPswdG85nB8tEV1Q31W+ApVQqefjhh7n99ttZsmQJixcvJjk5mdWrV7N69WoA5s2bR1xcHJmZmTz00EM88sgjAFRXV3PTTTexbNkyrrnmGs4//3wuueSSfgfl6+X8ko1AHy+ignw4MUImp1osFqe2aD/T5ZOiMZotfHGonO1Hq7lsggaF3D3mtk2ODeJwadOQPpQsFgsFNS1ObRxyLilaNceqmt3uAzavQjq4cHQHQStr8C7atffOYrGwJa+KC8aFuzzz6g5kMhm/uSyVssY2PvihxNXDcbkTVc2s3lvMT86LF+VGwySTyaQOr2544kuwj535dXgpZMxIdO1J4yszYiipbxMNns5hd0Eds5/eyu8+zmZPQZ1TmxsN6D/tvHnzmDdvXo/bVq5cafteJpPZgqruxo8fz5o1a4Y3QidK0ahHTIlgTXMHrQaTyzIt1jLB5zcdp9VgYtEE15cHWk2OC+aj/aWUNbYRGzK4+Xa1LQaa240ub9FulapR835bMdXNHWgCfVw9HJvciiaUchnjIp3zcwrxVzE2wl/8o+nDsapmSurb+PnF41w9FLdxUXI4sxJD+de2k1w7PQ5f1ehtSPD0l3n4eyu5TywqbBcpWjXrsyuwWCxuuxyCxWJhx4lazhsTKrpFDtKu/Foy4kJcfrJq0UQtf1pzhE+zypiRGOrSsbirDUcqqdN3sC67nA/2lRAb4stVGTFc2dVR1pHE7N5uUjQB5Ne0YBoB7XutLdpdlcGSyWQsnRRNU1sngT5Kp68VcS6TY6QFh4fSrr2w6+fqDiWC4L5zB/MqmhkbEeDUf9wzEkI5UNwg2m/3YkvXuk+XpkX2s+XoIWWxUqhp7uDtXUWuHo7LfHeilu3Harj3knGE+qtcPZwRIVWjpqmtk+rmDlcPpU878+u4+fW93PLGD7QajK4ejsdoauvkcFmTWxzT+HsrWThBw/rsClHq3Id9p+qZkRDKD39awD9+PJUx4f68uP0klzz/NVf9+3ve2X2KxlbHLHUjAqxukjVqOoxmiutbXT2UYStywRpYZ1o6SVrzakG6xumNNs5lfJQaL4VsSAFWQY1U9jHWTcpoUqxzB92s3j+3XOe0+VdW0xNCaGztpKBWlOacaXNuFVPjgolUu0+W0x2clxTGhcnhvPxNPs3tna4ejtOZuhYVjg3x5ebzE109nBEjxQMaXewrakAmgz2FUqDV0iGCrIHYW1iP2YJL5191d+W0WJraOtl+tNrVQ3E7LR1Gcst1zEyUso0rMmJ457bz2PX7S/nDkvHoO0w8tOYIs57ayt3v7GdTTiUGo9luz+8+R71uINVNswFDUVirR6WQEx3cz/pIBj00nIIO+7/miTGB/HZhKj+/eKzd9z0c3koFaVGBQ2qIUFCrR6UcwM/VScICvAkP8Har92y93kClrt1p86+spnfVw+8rEmWC3VXp2jlU2kRm+ujuHtiXBy5LpaG1k9e/K3L1UJzukwOlHK1s5v8WjRdlYnZkPfHlTp/LZ8oqaSAlUs0LKzM4UNzIjf/dQ1Pb6DvJMFg782vx8ZIzNT7Y1UMBYO7YMCLU3qIjai8OFjeSQjE3ljwMWx6DI59AzXE0AV7cedFYNvzqQtb/8gJunJPAvlP13PnOfs57eguPrD3CoZLGYc9tF7Odu7HOFzlR1ewWLcWHo7BWz9hQLxRNp6CpDHRl0FR6+mtTGehKoa3bwaiXP6i10iVAA+ooUGsgQNvzdp8gGEBduUwm455L3HPOx+TYINZmlWM2W5APovlGQU0LiWF+btOwA6R/5u50pjSvQuoc6qwW7VZJ4f6E+Hmx/1QD182Kd+pzu7MtXQsKXyYCrF5NiQvmsnQNq74t4ObzEwj2Gx1lcq0GI89vPMbUuGCWTY5y9XBGFOnEl8qtPpe7M5stZBU3smSSlssnR6OUy/nF6gPcsGoP79w2a9T8DQzFrvw6ZiaG4q10jxMSSoWc5VOieWtXEQ16AyGizNfmUEEp//H6B+EVTVC2BcxdWVqlD0SmIdNMZIJ2EhMmTuT3l8zg25JOPjlQyv9+KOGtXadIivDn6mmxrMiIIWYIJ9VFgNWNv7eS2BBfjld7QImR2Qz66q5gyRo4lUFTCejK+HN5ISGWBvjnGRG4TzAExUqXuFkQFAP+EVKg1VwpXVqqoOIgHN8Infqzn1vp23vgZQ3I1FHSdd+QAQVirjA5Jph3dxdTWKcfVLlfQY3eVv7hLlI0aj74oWTQwaKj5JZbAyzn/pxkMhnTE0JEo4szbM6tIiHMz2kNRzzR/ZelsPif3/LKjgJ+t2h0tCl/dUcB1c0d/OeGaW7biMGTpWjUHHPTrsSFdXqa2jrJiJOy/osmann5hun87N0DrHxtD+/eNouwAG8Xj9L91LZ0cLSymSumRrt6KD1cOS2GVd8Vsu5wBTfOTnD1cNzGpENPES+vRnbDFxA7E2qOQlUOVB6BqsNwdD1kvQNIwdAlQfFcop1Ix0Vp7GuP4X8lwTy/sZnnNh5jTlIYV02LYfGkKAK8BxY6uWeA5cKW09K6Qi4+62TqhJZqaK6QLroKaC7vCqBKpcyTrgLMZ6TzvfwgMAZLYAzbTJPRxo7lwhlTITAGguIgMBq8B3mQ1dF8OvBqroSWyp6BWFUOnNwKhl5+ZgpvKdBSeoNMLgVbMjnQ9VXGGdfPvN/6tauStbdtfAK7Xl9s19cYCIwF//BzBneT46RGF4dLmwYcYHWapPl57pbdTNWqaes0UdbYRlzo4LoiOkJehQ5NoLdL/kFPTwhlS141dS0d4gABqQZ958k6bpqTgMxihpbabn/DFdBcBSYDeKulzwaV+vT33uqu613fe/m57QmT4RqvDWTZ5Gje/L6IW+Ymjvi5atW6dl75poAlk7RMTxDdxxwhRaPmw33uc+KruwNdJ6GmJQTbbrs0TcOqm2dwx9v7WPnabt67fTYRavEZ2t3ugjoAznfhAsO9SY8KJEUTwJqsMhFgdTEd/ICLWjexXXMLlyReIN0YNUW6WFks0v9Ba8BVeQSqjuB9fANzLWbmAv9U+1PlM5a91dHs/SyaT9cmEDd+JktnpnDBuPBzVjO5ZYDl03AUHp0PcgXIFN2+ys+4fq7b5b1spwBVAPiFStkV3+Cur9brIcwIbubAiXo6jSa87J0CtlikTJGuvOsAp+vrmddbqoEzgky5UgqQAmMhbnZXINE9sIi1ZYzKGlr57TPb+fPUSTBtmKVS3l0HXOHJ597OoD8jCKuS3rgt1WDqkF67xSy9LovljOvmrsuZt3Xbrtf7zVB3EvK+kA4Su1N4Sz+vHoHX6Z/XuIBofL3kHCptZEVGzIB+FCX1rRjNlsGvE2M0gKFFClYNLdDRIqWqI1KlQHCYuncSdIcAK7dC5/T5V1bWdUkOFDeOnjlHZjO01nUFTJU9Aih9WREfKopIy22F/TVg6aXTlEze9XfVD5lc+vz0Vp/+6h3Q9X1gt6As4PTnhjoKEs4HhZf9X7ed/WpBMusPV/Dv7fk8esUEVw/Hof666ThGs3nUZOtcIUWjptXgPie+ussqaSTQR3nWciMXpUTwxk9ncttb+7ju1V28f8dst1r+w9V25teh9lYy0ckNnPojk8m4MiOWZzYc5VSdngQXdY92G/WFsP5+fjCn0Hzer/veTibrOq6OhpTLTt9uaIWaPKjKQV55hKiqI1xRuZPlXlJ1Dieg6JiGbxSJyGKnc8ltf+51924ZYBl9w+GiB8Bskg4IzCbpAKDHdZN0YNHj+rluN0sHtU2lUHlYCnR6KX/7GfAzL7A8fZct6Dp9Ce32fbD01a/bbWZTt4xTxRkZqK6DH1MvbVv9wrrK66JAO1n6Zau1oO76GhgNfuFSIDkAha5o0a7yh7Cx0sXZLBbQ19rKI23zy6xzz4q+k37+3Q4ulcABpQ91ByOgYdzpzFdQ7OnvfYJ6BEa6kyVcIT/MrLpC+N58+r7ugZPt+2639fY7t1JHg3aSdImaLH0NThzw7xq6TaiuamaBi4OKDqOJk9UtLmsHPikmCC+FjH2n6kdGgNXZDg2F0nvZ+hnSXCFlj20BVdXp2vLufEMxmYPRy9V4Jc+BQG3X54z2dHlvgEYKfjrbur1nddL7tvv7+6z3uPX2FukkSvftzgzifIJh/OUwYQWMmQdK95wjkBQRwNXTYnh/TzF3XpTkNo1s7C2vQseH+0u4de4YcSDmQKna0x1e3S3AOnCqganxIb1m1s4fF85bt87iljf28uNXpCBrpP4tDNau/DrOSwpF6UZdka2WT43mmQ1H2ZRTxR0XJbl6OK5j6oRPbsNokfErwz18mDSEYxGVH8RMly5dZBaLdIxZeQRjRTY+J/czoSoHdclBwKMCrAg4/0+Of6LOdmhvlIKtrktpeRlvbc3ixxMCGKfuhLb6rqxTmVQO11rf+7yk3nj5SQc0gdHSfCdrEBUYdfp7tVYqobOjIjdbq8nhZDIIiJAuMdN638ZklA5EuzX7OHQwG11VETHtTciqc6X7z2Eq8IIK2Nntxh5n9LvO5gcndDuzf0aplXV7gOo8KdivzIaTW04fmKrUoJ0oBdvW4Csyrc/3idrHi5hgX7eYUH2iqgWj2TL4BhdGg/R3JpP3W955Lj5eCibGBNlKYDyCtUyh9gTUnYDak11fT0BjMWdls31DTn92RIzvNv+x55xIo8yLJU9tYX56JHOvnHruMaj8pAvDDEotFjC2dwViOqnmPXct5H0OB9/tCraWwoQr3TLY+uWlyXyWVca/tp3gz1dNdvVw7M5isfD0l3kE+njxi/nu2YBopEi2VhZUNXNpmvuc7GnpMHK8qpmFE/oudZ81JpS3bzuPn76+lx+9sovVd8x2uyDR2cob2yis1XODm5bgRQf7EhXkQ0754JefGVG2PwVl+3kn6lHMirghNafolUwGwfEQHI9y/BK0l3Tdbu67+sMtAyyn8fIBr64Dki7hY02s2rwBv4hkfp3Zx6r2xg5oa+wWmNVLgZdccTqgUmulshkXzFkoqNXjp1IQKeqnT1MopcxUUIwU7AJVfmXc97+DfLXsQikgMHZI5ZrWLFiHrkfJ04vfV7KtsI1Pf3VZ15wU/0Flms4y7tLT33e2SynpysNQkS19PfielDUAqUQ0YvzpgEs7WQrCfKWSuBRNgFu0BM6r0OGNgUnqFul1WP82Wuukv5XWOul6W/3p71vre87hU6khdAyEJkkZ0dAkCO36GhDZ79/U9PgQ3t59ig6jyW06PQFS2UHdybODqLqTp3/PIL2vwsZC7AyYslIqzw2KO51x8hpYyc6+gjoaWzvJdObBnUwGXr7SJSBCeh3jl0p/W/nbIGeNVNJ78D0pQzz+ckhfAUkXu0WwFRvix/Wz4nl3TzETY4KIVPsQ7OdFsK8XQb5eBPl5udd7apC+OV7DtydqeejydNEpzsECfbyIDvJx/ZzuM2SXNGK2wLSEkHNuNz0hhPfuOI8b/3s6k5XownU1XW1nvnX+lXusf9WbtKhA8irc6/3mVPnb4bt/YJn2U1YdmczMMU6YX3qOY8DRHWD1wsdLQUKoHyeqz/EmVXp3dctzn7NS3RXVSjW4ojPUuU2ODQYgu7RRCrCU3l0H9mN63X7Hpl3IIyxSAG1vXj4QnSFdrMxmqTysMvt04JW/HQ6tPr1NUDxETeZWo5b3a4PprE/AKyT+7CDEYpFKWM2d0nw1k7Hb951SiZn1e1Nn1319fN+u6xkg2b5vYEVzDdf6dMBbfbxO78CustpQqew1PKXr+zDwC5HGVV8gXSqzpYPx7iVnqoDTwZc16LIGYgEakMmYkRjCqu8KOVKmY3o/BxF2ZzZLAfqZQVTtCals1UYmBU3h4yDuJ1IQFZ4MYcnS+8sOf7ubc6tQKeVclBIx7H0Nm9IbUhdLF2OH9D7O+axnsJW6VCojTLrEpcHWPZeMY/3hSv742ZFe7/f1UhDs1xVw+Xp1BWAq6bau223Xu+4P8vUiwFvp0s9ko8nM01/mkRDmJybCO0myRs1xN+skmFXSCMDUrv9/5zI5Npj37ziPG1bt4cev7uK922eP2m6kO/NrCfVX2dZLdUdpUWq+OV5De6dp9K1rp6+Fz+6C8BTKZz9E5c49zHD2//8ziACrF8katVtkA4aqqK7VZU0GPElCqB9qHyWHSpv48cz+ty+o1TN/vBMPVuXy0/PaJlx5+vaW6tNBV9flgtr1XKi0wAvPg3eQdIDaI0Ay9P08QyLrNgcxVJqzpp3MhhPtNKLmxvkZUtDkGypt4xcmbT/YZgemTqnuua4r6KrPl75W5UgtVrvPPfLyg9AkLg5M5HdKGfpdR8FynhSAqftY58fUKc0/MrZDZ6uUSTS2DfBr++nHdjRLE2vrTkr3W6nUUhCVOFcKnsLHSV/DxkpZHgexWCxsyati7tgw/AfYUtZplN6Quki6WIOt3DXS7/PQ+9L7d/wS6T3vgmArMtCH7353CdW6DhrbDDS1ddLY2kljWydNrWde76SwVk9TWyMNrZ0YjOcoF5HLbFmw2Ulh3HdpslMbCHy4r5TjVS385yfTUCndbw7JSJSqVbOroA6jyew283YOnGpgXGQAQX4D+yyeEB3E/+6cw09W7ea6V3fz3u3nkap13yDDESwWC7vy65iTFOZ2HSG7S48KwmS2cLK6hYkxQa4ejvNYLLDmZ1Jl2Q2fsK9cmvfu9BOsZ3Cz/7zuIVWjZtvRavcrMRoAayvxJZPcq5W4O5LLZUyODSK7tLHfbXXtndS2dAy+g6AjBETCuAXSpUtuUQV/euUDHj/PwiSvMinrI/eSAhqFV9f3KqlUsq/vFaqu692/72U770Ap4yDv+bdhsVj442ObuHxKNEyfZJ/XqvA6naU6k8koBV/1+V3BjRR8+dQf43ZlIV5Hv4CjXdt6+THWOxQ2yLoFVG29d9UbCJlcWg/Oy0f6qvKDkEQYc9HpICo82ZZVc7YT1S2cqmvlTnef7HxmsFXwtVRGeHS9lKm1BlvpK2DsJXafr9oXHy8F8WF+xDO4eSftnSYaWzu7gjCDLQhrauuksc1AY6v0OfLRvhI+PVDK7Rckcde8JNQ+ju2y2NJh5G+bjzMzMcTtlpkYyVI0agxGM6fqWwe13qKjWCwWskoauXT84Cb+p2rV/O/OOVz/2m5Wvrabd287j3Q366TnSEV1rVQ0tTPHjcsD4fTak7nlutEVYO15GU5sgsXPgXYS+3YfIcBbyXgXnwgQAVYvkjUBmMwWCmv1jNd61odIaUMbJrOFMeGu/zD3BJNjg1n1bUG/KfWCmq7GIW5agz42JpJDJLPZP5lJfc0ddLCyxjZ07UbnZU8Vyj5LOn//v30cP3GUtSujkNUXQH0hbeXHUYVEnA6KvLoFSIP9qvBy6zWhNudKDVsWuNHk+n4pvSFloXQxGqRgK3cNHF13OthKXSyVEY6d77RgazB8vBRogxRog86dmSqua+X5Tcd4cftJ3t9bzC/nj+P68xIclll65Zt8als6eO2m6aJ03Ims5WTHK5vdIsA6VddKvd7Q7/yr3oyLDOCDu3oGWZNiR8dB/M78WgDmjnOv9a/OlBDmj59KQW6FztVDcZ6KQ7D5YUhZDLPuAOCHonoy4oNdnjUWAVYvuq8r5GkBVmGtVO89Jnx0d/wZqCmxQXSaLBytbGZqXHCf2xXUSD9Xd+3M6OOlIDHM36UTqq2Ta93hzGbGmAg+PlhFcchsErqaiZTn5RGUlubikTnH5twqpsQGee4aNkqVtC5JymVg/AcUfiPN2Tq6DrL/J2VRky+TGr8EdS2vEBwnLXvgBs0y+hMf5scLKzO448Iknv4yj0e/yOWNnUX8dmEqSydF2TUIqmhq47VvC1g2JZqMeNeWzIw24yIDkMngeFULi+2U1B+OrBKpu2pGfPCQHj8m3J8P75rDda/u5vpVu3nr1llMGwXvqZ35dUQF+ZAY5t7HVQq5jFStmrzREmB1tMDHt0pTEJa/BDIZuvZOjlU1s3hiH9MCnEgEWL1IivBHIZdxws0mpw5EYW0rgMhgDdCkbo0uzh1g6VHIZcSHumeABVLm1ZWt2nPLdchkuDwtD6drr/cVNYy6tX6qde0cLGnkgctck8m0O6UKkjOliy3YWiMtbXDk4zM2lkndFoPiTgdd1u+tX32C3Cb7OCk2iPfvOI+vj9fwzFdHuff9LF6LK+T3i8czO8k+5UjPbTyG2QL/tzDVLvsTBs5XpSA+1M8tltAAOHCqkQBvJcmRQ/+Mjgv148O7pUzWjav28Oats5iZ6IRubS5iNlvYnV/HvNQIj8j+pkcF8vmhciwWi0eMd1g2/E6aGnDz5+AvfV4eONWAxQIzEl0f+IsAqxfeSgWJYe7zoTgYhbUtBPooCRngBNbRLjrIh/AAFdml5147oqC2hbgQX7eeHJ6qUbM5t8plHYRyK5oYE+aPn8r1HyspkWrUPkr2nWrg6umxrh6OU209Wg1AZvoInGvTPdgCaR6drlyai9dYIq1x11QiXSoOShmvMxu8qNRdgVdst8Ar7vRtAVqp/NRJZDIZl6RGclFyBJ8eKOVvm49z3au7uXR8JL9bPN5WUTEUR8qa+CyrjDsvShr16xi5SopGzTE3OZbIKmlgSlwQimE2aogJ9uWDO+dw/ard3PTfvbz+05luPz9pqI5XN1OnN3D+WPcuD7RKiwrkvT3FlDW2ERsygv/mD38MWe/ChQ9Ic5+77D/VgEIuO+cJc2dx/ZGQm0rReGaatai2lTHhokX7QMlkMibHBvfb6KKgRu8eDS7OIUWrxmyB/JoWJkQ7vzY+r6KZSW4ysVYulzEtPsSzFhy2k825VcSF+pKice/3q114+Z7utNkbsxn0NaeDrqbSboFYMZT+IK3P1p1MIbXKV/mfbvoiV3b73to4RtmtgcwZ1+WKvu+z7sN2mwLkShRyL64NVLL8Kjlf5TbzyaGTPPjP75mXFs1P5owlPNDvjH0rT1+37UspNWAxG7GYDPzti33E+7Rz76xAKRA1G7s6i5qk781dyzVYr1uXbLAu6WDdxtT1VSaTGrcExkg/Ix/XlwO7O3dpmtVqMJJX0czPL+7jb2WQtEE+/O/O2fzktT3c8uZeXrtpBhcmu8GSEHa286S0/pWnBJBpXXOgc8t1IzfAaiiCdb+G2Flw8YM97tpX1EB6VKBbdM91/QjcVIpGzYacSo9bT6CwVs9MN0iNepJJMUF8fawafYex1z9Ks9lCUZ2eC9x8gqttQnVVs9MDrOb2TorrW/nxzDinPu+5TE8I4e9bjtPU1kmQ7+jI6Oo7jHx3spYbzksQJ1lAWurAumZh7Izet+lo6Qq4umW/msqktv22oKNTCjKMBjDru60d1+0+63pxPQKVzkEPWQUs77qgAvK7LoMkA163XvnX4B8/ICq1FGgFRncFXVHdvu/66hviNiWZruAuTbMOlzZhMluGPP+qN5HqriBr1R5ue2sfr9wwnUsG2aHQ3e3MryMxzI+YYMctq2FP47VqZDLphOdlE0ZgFYOpEz65Xfr+6lU9ln7pNJnJKmngupnxLhpcTwMKsHbs2MFTTz2F2Wzm2muv5c477+xxv8Vi4amnnuKbb77Bx8eHv/zlL0yYMIGKigr+7//+j9raWuRyOT/60Y+4+eabHfJC7C1Fo8ZiwaPWE2jvNFHe1EZi+OgqiRquKXFBmC1SOc15vcx7KG9qo73TzBg3bXBhlRjuj5dCxrFK588dPNrVXMPaJtYdzEgIwWKBrOIGLk4dWf/0+/LtiVoMRjOZ6R7UPdDVvAMgcrx0sbceC3z3EnyZTd2ud7t0u62mSc/nWcUcKKwh0BuWpIczJzEYJcbTmSdrtslkBIsZk0zBf3eWYJQpueviFBSKbhmuMy/dsmins2LKMzJlXReLCZqrpMW0deVdl67v87dBSyVYzlgLTOlzRtAVLTUj6R6Y+UdIwfAIZF0zytVNsw4UNwKQEWffE7BhAd6svmM2N76+hzvf2ceL109j4Qg5sDeazOwpqJOWHvEQ/t5KEsP8PbICa0C+/rNUeXDN6xDSc8H03HId7Z1mt5h/BQMIsEwmE48//jhvvPEGGo2Ga665hvnz5zNu3DjbNjt27KCoqIhNmzZx6NAhHn30UT766CMUCgUPPvggEyZMoKWlhauvvpq5c+f2eKy7spbXHK9q9pgAq7i+FYtF6vQjDNzkrkYXh/sIsE63aHfvkisvhZyxEa5pdJFbLn2Yp0e5z9/KlLhgFHIZ+0+NngBrc24VQb5eIovtLmSyrnXllENeWDoCuG0GzCpt4i8b8rhxfx3xhX62joO9LXz6/q4intbl8NpNM1DYO9jubU06K5MRWqp6Bl66MmiukL4v3gW6irMze3KlFGxpJ0PcLIidCdEZDl2M21mSwgNQymUun9OdVdzAmHB/Qvzt32UzxF/Fe7fP5ubX93LPewf453UZLJ3s+i5uw5VTrqO5w8j5HlIeaJUeFcjhsnPPK/dIBd/At3+DjBth4tVn3b2va0rAjAT3aLrSb4CVnZ1NQkICcXFS6c/SpUvZunVrjyBp69atrFixAplMxtSpU9HpdFRXVxMZGUlkpHRgExAQQFJSElVVVR4RYFmzAcc9qJOgNRAQAdbghAd4ExPsy6E+Gl1YW7SPdfMMFkiZ1/0umHeUV6Ej1F+FJtB91iby91aSFqVmX9HomIdlNJnZdrSK+eMjXb7+h2B/k2KDePe289hxopY/f5nHL1Zn8dq3BTy4eHyPCfi69k7+vuUEs5NCWZDm5BMLCiUExUgXZva+jdkMrbVnZ8Eai6HsgNSYBKSgSztJmmcROxPiZkJwgseVG6qUcsaE+7ukssDKYrFwoLiRi5IdV+Ye5OvFO7fN4pY3fuAXqw9gNE9l+dQYhz2fM+zMl+Zf2aujp7OkRalZf7iC5vZOhy9i7jT6Ovj0TggbB4uf6XWTfUX1xIb49rsOobP0G2BVVVWh1Z5O92o0GrKzs8+5jVarpaqqyhZcAZSWlpKXl8eUKVP6HZTZbCYvL29AL8CRYtRKDuRXkJdncfVQBmRvXiMAhroy8porXDsYD5MYKGNfQXWv77v9J2rx9ZJRW1pAnZv/cw+Rt1HW2Ma+Qzn4q5x3kL2/oJr4QAVHjx512nMORJIaNp6s50hOLp2GDrf4XHGUI1VtNLR2khbYOaJf52gXCTyfGc62Ah/eOVjP9a/tYWaML7dODyMxRMXr++uo1xu4Pt3X7f4ee/IBkkCdBGogBpgAivZ6fOty8K07gm/dYXz3v4V87ysAGH1CaQubSFvYRFrDJtEemoZF6fqDqfb29nP+zWl9LRwpqXPZ32VVSye1LR1EqRz/GfiHuUE82tHGr/53kB/yTnH1xCB83Lj77rlszq4gMdiL2tICal09mEFQm6TlejbsPsJEjev/PobNYiH2uwfwb62j6Pxn6cgv7mUTC7vza5ga5ev0v7O0PtbX7DfAsljODi7OnDzd3zZ6vZ5f/vKX/OEPfyAgoP8yK7lc3ueAnWliVhsHSxrdYiwDoc/JJjyghRlTJrh6KB5nbpUX3284RlTCWIL9epZQNO7cQ7ImkPT0dBeNbuAusFTxVtY+5CHRpDlpAUijycyppiJunpPgdn8rCwzlfH40C0tQDD7N5W43Pnv6tCAXlULO9fMzCHCDDkqCY02cAHcuMvHWziJe3H6Se74oZfnUGNYfbeaqjBiuuGCqq4c4DHNPf2syQnUulO5FWfID6tK9qLN3SPfJFKCdKGW54mZJjUxCxjg9y5WXl3fOz5YZZUq+Kz5OwthklyxjcfxgGVDC4lnjSXPClIcPxo/ntx8f4t1DFWwpbOM3l6Vw1bTYYbeHdyaD0Uzu+0VcNzPe4/5vBEe38cjWStq8Q0hLS3T1cIZvzytQ/j0seoak2ct73eRUnZ6GtkIunZxIWlpCr9s4W79/6VqtlsrKStv1MzNTvW1TWVlp26azs5Nf/vKXLFu2jMsuu8xe43aKVI2addkVfXaXczeFdXoSR9miqvYypds8rDNbzRbUeE5nRmuTiXWHKpjmpACrsFaPwWi2tYd1JzOsCw6fqme2e5RlO4TFYmFzbhVzxoaJ4GoU8fFScNe8sfx4ZhwvbT/JWztPIZPBAyNpUWGFEqImS5eZXd3D9HXSRPfSvVCyFw6+Dz+8Jt3nHyGVFMbOkAKvmGlSy30XStUG2JpmWef8OlNWcSO+XgqnLQLvq1Lw4vXTuPn8ep5cn8dvP87mje+L+OPSNOa6eTdeq4MljbR3mj1u/hWANtCHYD8v29xoj1Z5GDb9CZIXwnl39bmZdSqAuzS4gAEEWJMmTaKoqIiSkhI0Gg3r16/nr3/9a49t5s+fz7vvvsvSpUs5dOgQarWayMhILBYLf/zjH0lKSuKWW25x2ItwlOSuttcnq1uY4gaLlvWnqFbPvJSRtw6FM1gbmWSX9gyw2gwmyhrb+FG4+7QfP5fYED9umB3P698Xcv7YMBY4oZtcble3ovRo9wuwooN9iQ7yYf+pBmaHev6E+b7k17RQVNfKbReeowGBMGIF+6n449J0fjp3DM3tnUR7SEvpIfMPg9RF0gWkborVuVKwVfqDdDn2pXSfTAGaCVIDjYgUCO+6hCRKnRKdwLpY9LHKZhcFWA1Mjg1y+tzMmYmhfPaz81l3uIJnvjrKT1btYf74SH6/eLzt+Mpd7cyvRS6j18ZX7k4mk5EeFej5nQQNevj4VvANhRX/Pmdmet+pBtQ+SlIi3ed91W+ApVQqefjhh7n99tsxmUxcffXVJCcns3r1agBWrlzJvHnz+Oabb8jMzMTX15enn34agP3797N27VpSUlJYvlxK691///3MmzfPgS/JfqydBI9VNbt9gNXSYaS6uYNE0eBiSIJ8vRgT7s+hksYetxfWdnUQ9IAGF1Z/WppOVnEjv/noEOt/eYHDFxvMrdCh6upg6I6mJYRIjT8yRu5B56bcKgAy00R79tFMWqtn5L7P+yRXSA0xtJNg5m3Sba31p4Otkr1wYhMcfPf0YxQqacK8NeCKSIXwZAhLBpV9PzMTwvxRKeUu6STY3mkip1zHHRe55uSLXC7jiinRXJausZWzLvzHDq6bFc+vF6QQoXafxkjd7cyvY2JMkMeuoZgWFci7u09hNJk9t+nRhgeh9gTctAb8z5353FdUz/SEkF67qrrKgGpJ5s2bd1ZQtHLlStv3MpmMRx555KzHzZgxg2PHjg1ziK5j/VA84eL2qgNRZA0ERIA1ZJNjg9hbWN/jtoJaqfOTJwVYPl4K/v2TaVz+wnfc834WH901B5UDJxnnlutI1gTg5aYf4jMSQliXXUF1ixHPqqQfuC25VUyODXKb7kmC4HJ+oZCyULpYtTVIB2w1x6D2uHSpzIa8z3uu3xUU35Xt6gq6IlKlIKyfg7y+KOQyxkUEuKQr8ZGyJoxmCxndTxK36yB/K5zaBX5hUjbPegmIdMgcNms567Uz4nhh6wne3X2KtVll/Ozisdx2QRK+KudkEweizWAiq7iBWy8Y4+qhDFl6VCAdRjNFdXrGuVFWZ8COfAoH3oYL7oeki8+5aWOrgRPVLSyf6l7rlYli/XNw5YfiYFkzLSKDNXSTY4NZe7Cc6uZ2ItXSgWqhh7a+Twjz59lrJvOz9w7wl6+O8vAyxzXoyKto5pJU9y1NnZEoTb7KrWnHM3Lng1PT3EFWSSO/XpDi6qEIgnvzDZGaYcTN6nl7ZzvUF0DtMajpCrxqj0HR92Bs6/b40NOZrvCuoCsi5ezFlXuRqlWzu6DOzi+of1ldCwxPD26BPa9KpZNF30lrkSl9e74+kG7rHnD1uCQMe22yUH8Vj14xgZvmJPDMhqM8v+k47+0p5oHLUrkyI8YtMhA/FNXTabL0WP7A01jnROdWNHtegNVwCr74FcTMgEv+0O/mB4qt86/ca6K1CLD6kaIJYM8ZWQ13ZM1giSYXQzcltmseVkkTC9KlAKugVk90kI9LOj8N1+JJUfz0/ERe/76QWWNCWTRR2/+DBqm6uZ3alg63bHBhNV6rxk+lILe63dVDcYhtR6uwWCDTCfPtBGFE8vIBTbp06c5shqYSKetV25X1qjkOR9dD69u2zVK8/OHAHIjvusRMOysQSdGo+SyrjKa2TueUnZnNUJ5FbNZ/2eL7PWGvFUm3hyXD7J9B6mKpCYi5ExpLoKHo7EvhN9DZ2nO/6qi+A7AAzYCzX0kRAbxy4wz2FNTx9Jd5/OajQ7z+fSF/XJLG+S5uhLEzvw6lXOYxza16My4yAC+FjNxyHVdMca/MzjmZjPDJ7YAFrvkvKPr/W/mhqAGlXGZrVuYuPO+o0clStGrWHCxH195JoBsv2FZYqycqyMet0uyeJj06ELkMsksbbc0hCmpaGONB5YFn+v2S8WQVN/Dbjw+RHhVIfJh95xZYuxS5Y4MLK6VCztS4YPKq3b/Udyg251YRE+zrtA5hgjBqyOVS1iYkAZIX9LxPX2fLdOlyvyak6Shse6LrcV4QnQHxs7uCrtmkaqU5qieqmh13pt3QKgVFx76E4xuhpYrLkFPoOwkufBJSFkP4uJ6PUSilLFxELxlwiwX0NX0EXzvg0P+Absv0KH27fl6J0sU3VJrPpvIHL/8zvpeunxfhz2e3T+GLvEae3XiC61ft4dLxkfx+yXiXZV72nKxiZpw/frJO6GgHi0lqpGI2nf7e9tUMZmMv95m7vhp73qbyk94TDl5KQKWUMy5S7XmNLr75i9Qd9Or/Su+hAdhf1MCEmCC3O/4VAVY/rB1JTlS1MD3Bfc9miBbtw+enUpKiUZNd1gRIra8LavSsyPDc1ei9lVK73KUvfMs97x/g45/NwVtpvw+hvAopaEnTum+ABdI8rBcL6mhq7STIz31PlAxWq8HItydqWTkr/qz1CQVBcCD/MPCfAwlzqPQ7j5C0NKmxRsleKN4lXXb/B3a+AMCFoSk8rYzFcKAIgpZCcIJ9DrKbq+D4Bjj2FRR8LZX8qdSQvICG2Eu5ZK0Xv8o8j3HnD2E+kUwmzckKiDy7rBKk0sqmPrJfRd+BYWDTK+TAcuAKLz/a1d7UFSrRv+hDSYAaTXgYKl81eHUFZyp/6Xu5EkyGrkunlImzfm/qPOP2Xu7rcbtBypyYDFhMBj6zBo1PDf5HNiCpS2HFS1LJqgOlRan57oQHLZFc+C3seB6m3gCTrhnQQzqMJg6WNnLTbPdY+6o7EWD1w9pe9XhVs1sHWEW1ehZPinL1MDze5NggtuRVY7FYqGnpoLnD6FENLnoTF+rHc9dO4a539vP0+jweWz7RbvvOrdARE+zr9kHLZRO0vLDtJGsOlnHz+YmuHo7dfHeilg6jmctEeaAguJ5faM/28Z1tUJ4FxbtQntrN5XXfEZi9DbL/IJXaxc+G+POlr5oJA2sbb7FAVY4UUB3/Csr2S7cHxcO0m6TSv4S5oFSxM7uCRg4wzVHHLl4+XfPRknu/32SUSgwN+tNfDXro7PpqaO3xvczQgm9nKxGtzejKqihqaKRGX018QBWhKiPyzm6PsZilTKFCJWXhFCrpIu/2fffblT7gHdjn9ia5F61GGQUNBrYea+DamQnEhQVIvxO5Umr3L1eATN73bbKu223fy09vY92+eBdsfQxemQc/ekvKdDpIelQgnx4oo7alg/AA9+zWaKOvg0/vgLCxsPiZAT/sSJkOg9HsVutfWYkAqx+xIb74eilc0l51oBpbDTS0djJGZLCGbVJsMB/uK6W0oY3yRmnyb5Kbth8fjIUTtNx2wRj++10hs8aEsXSyfYLxvAqdW8+/spoYE0RymIrVe4u5aU7CiMn2bM6tItBHycwx7jW5VxAEpHlYCedDwvnILoSbX/yWFFkJz8zUQ/Fu6WA75zNpW5VayhJ1lRQSM/10u3ijAU59JwVVxzZAU7F0e8wMmP8nSF0CkelnZcQOFDfgrZQz3lUVBgolKALBZ3DP7w2kI63v95evjrI5t4qoIB9+uzCVFVNjsPXBGMDnuMViobG1k6rmdiqb2qnStVPZ1EFVcztVje1U6tqp0nVQp+/A0pW4UnsruefyBWDHag+buJnS7/jjW+C/l8HCp6UFtB3wPym9639zXoWux/qebsdigc/vhdY6uP4D8B74Mdf+U1KPhOkJ7vc/UARY/ZDLZSRrAjjhxp0ErR0EPa3TnTuyNboobULX3gmMnNb3v1s0nv2nGvjdJ9lMiA4cdsfJ9k4TBTUtLPGQzOmilED+tauWgyWNZMS739muwTKZLWw7Ws0l4yPdtkW+IAinpWiD2JLXDrOuh1l3SDc2lnQFWzulr9uflG6XKyFqKqi1UPANGJqlOU5jL4F5v4XkhaA+d+bausCwI5fpcKSxEQG8dtMMdhfU8dT6PO7/0NoII505Y8No7zRR1RUgVeraqbIGULp22+1VunY6jGd3eQzzVxEZ6IM20JvJsUFEqn3QBvmgDfQhRau2ayn9WeJmwl074LO74MsH4NROuOIF8LbvnDNbJ8FyNw+wdr0kzRtc+GeImjKoh/5Q1EBimJ9brqcmAqwBSI5Us+NEjauH0SfRot1+xmsDUSnkZJc1YjZbUCnlXYt3ej6VUs6L12ew9IXv+Pl7B/j05+fj4zX0fyLHKpsxW06fJXN3F48J4L/7G1i9t3hEBFhZxQ3U6Q2ie6AgeIhkTQAf7CvpWbIVHCddJl8rXW9r6DaPazdUHoaJV0lZqjEXDXgR5A6jiSNlOn46N9ExL8aJZieFsfaeuXx+qJxnNxxl5Wu7CfRRoms3nrWtj5ccbaAPmkAfMuKD0XR9rw30QRvkTaTah8hAb8cGUAPhFworP4Cd/4StT0jrsV37FmjtV8If4q8iKsjHvRtdHHwfNv0Rxl8udbccBIvFwoFTDVycGumgwQ2PCLAGIFUbwCcHSmlsNRDsp3L1cM5SVKtHLoP4UPt2iBuNVEo5aVFqskua8FMpGBPm7xbrcthLbIgff/vRFG57ax9PrMvlqSsnDXlfuV0f2p4SYPl5yVk+NZo1WeU8dHk6ajfuCjoQm3Or8FLImJfixmcmBUGwSdWentPd55wY35CzF0gegtxyHQaTmWnxwcPaj7uQy2WsyIhh0UQt7+4+RVGd3hZIaYN8bIFUoI/Sc0rA5XK44NdSu/yPb4VVl8KS5yHjBruVDKZFBdr+V7udnM9g7T3SQsJX/3fQr7mwVk+d3uC27fQ9M2/sZMm2RhfuWSZYWNdKbIifx5YBuJtJsUEcKWviZE2Lxze46M2laRrumpfEe3uKWXuwbMj7yS3XofZWEhviORm+62bG09ZpYu3BclcPZdg251UxOynM4wNFQRgtUq3HEpWOn9N9oGuB4ZGQre/Ox0vB7Rcm8eSKSdw7P5lrZ8RxYXIEKRo1Qb5enhNcdZc4F+7+DuLOk+Yirfm51PjDDtKjAsmv0dPeabLL/uzm+CZpvavYWXDd+1LDlEHaV2RdYNg93+PiiHwArJ0Ej7lpo4vC2hZRHmhHk2ODae4wcqqudUQGWAAPXJbKjIQQ/vDpYfJrhnbiIK9Cx/gotUdl+CbHBpEeFcj7e4qxWCz9P8BN5de0UFCjF+WBguBBItTeBPt5ccwJJ2uzihuICfZFEzj4A1fBBQIi4MbPYN6DcGg1vHYp1Bwb9m7TogIxmS2crHajBEHht/DhjaCZCD/5UGq9PwT7TtUT7OdFUrh7NiITAdYARAf5EOCt5MT/t3fv8VFXd/7HX9+ZZHKdEBKYmQTCJZDEhFvCtXZd0Ui4iBSKrUIVu3Rt7U9/q8hu+f3Aioq2XffRB1W7tF1+rF3r2nipXAq09ZKtxXWVEkgaIAEDMrlgMrlNyD1z/f0xJEoFMjP5zi35PP8y4Xs50yYn38/3nPM+YVhgud1uzC09IyaIIRx8fjfwcP3FHa5orYaffqOAmGgtD71ygl6bb2+3XC43VQ0dETM9cICiKKxfNInKhg5OXt7vLBK9U2kBYEmuFFhCRApFUcg26IPyLFFW207+CJkeOGpotHDrVtiw17PB8+5boeKNYV0yL/2zoIuwUF8Kxes8mwjfuxdix/h9qdIaK/Mnjw3bl7xSYHlBUTxJguEY1d7c1U9Xv4MpqbL+Si3TDYnEXQ5/GKkjWABpY+LYedcczjR28uRvT/t0bp21h26bMyIi2v/a6vx04qK1FP+5NtRN8du7lRZmTkgifYQEsAgxWmSbEjlr6QzoCHpTRx8X23uZO8KmB44a0wo9UwbT5sDe++HgJs+mzn6YnBJPvE4bHuuwGk/Cf66FhPFw3wHPZt1+au3q55Pm7rCMZx8gBZaXsg36sFyDZW7pAWDqCNirKVxoNQozJ3gKh5E6gjXglhwDD906jddK69h7ot7r8wbehg28HYskSbHR3DE7jQPln9LV/8UUqnDX0tXP8VqrjF4JEYFyjHo6+xw0dvj3wOyNz9ZfJQfsHiLAktLgmwfhbzbB8V/Cvy+B1vM+X0ajUbjBpA99gdVSDb9aA7pE+OZvPdsPDMPxGs/6q3ANuAApsLyWZUykrdtGS1d/qJtyhQstnqJPNhlW1y05BrIMiYyJH/kBAo8uyWbR1BQe23fK66krlQ0daDXK4PrESLN+0SR6bE4O/iXywi7+q6oJtxtZfyVEBBpc0x3AoIuyWis6rYYZEfgCTHyONgqKnvLEubfXwe5boPKAz5fJTUuiqqEjdOuOrTXwq9WelMD7fgvJk4Z9ydIaz8/4zAn+TzEMNCmwvPT5eNVwcqGlh2itQnqyLGRV04O3TOPtR28OdTOCIkqr4YX1BcTrtDz4ygl6bEOP6lQ1dJA5LmFY+2iFUkFGMjeY9BE5TfCdKgsTkuMibv2bEOKzAiuQzxJlte3MmJAU+r2ehDpylsN334dxWfD6ffD7/wsOm9en56Yl0dnn4GJ7bwAbeQ0dDfCrr3hSETfsh3HTVblsqbmNWRPHhPUziBRYXsoOYryqL8wt3UxKiSdKK/9XqklRlMiMe/WTMSmW59cVcK65i8f3D70eq/LTjoicHjhAURTWL5xERf0lTkVQ2EWvzcn71c0syTWMqp9PIUaKsQk6xutjArbkwO50UXGxXdZfjTTJk2DjH2DR/4KjP4dfLod2714QhizoorsVXl4D3S2eQAuVNlHuszs5efFS2MazD5Cnci8Z9DEkxUbxcThFXeLZaG2qJAgKFdyUNY5/KMzizRP1vF5ad83j2ntsfHqpLyIDLj5vTcEEYqI0ETWK9cG5FvrsLoryhjd/XQgROjlGfcBGsM40dNJnd8n6q5EoSgcr/hnu+pVnTdMv/hbO/mHI024w6VEUqGoI4gBBb7unuLKa4RuvwcR5ql26ov4Sdqeb+WEccAFeFlhHjhxh2bJlFBUVsXv37i/8u9vt5plnnqGoqIhVq1Zx+vRnb8C3bt3KjTfeyB133KFeq0NAURRyTMGJV/WWy+XG3CoFllDPI7dl8eVpqWw/cOqaawQGFstG+hS1MXHRrLwcduHNtMhw8E6lBX1MFAunhvcfFiHEtWVfLrBcLvXXxJyo9Sz+lxGsESxvNXznPUjOgOK74Z0nwHntv2HxuiimpiZQ2RCk2Rq2bvj1XdBUBXf/J0y5SdXLl9a0ATBvcnj/jA9ZYDmdTnbs2MGePXs4fPgwhw4d4ty5c1ccc+TIEcxmM2+//TZPP/00Tz755OC/rV27lj179qje8FDIMuo52xjYeFVfNHT00e9wySbDQjVajcJz6/JJjInmwVeO032VlL2Bt2CRPoIF8I2Fk+jqd3DoLw2hbsqQnC43JWcs3HKDAV2UTD4QIlJlGxPps7uos/aofu2yWivGpBjSxsi67BEtdRr8/bswbyN88By8tAo6rh3a5Am6CMIAgb0PitdD/TH42r9DVpHqtzhutjJtfAIpCTrVr62mIf9KV1RUMHnyZDIyMtDpdKxcuZKSkpIrjikpKWHNmjUoikJ+fj4dHR00NTUBsGDBAsaMCd+UD19kGxLp6HPQ1BkeSYLmlm4AGcESqjLoY3lhfT4XWrp5bN/JL7xQqPy0g/H6GMbrY0LUQvXMmzyWLEMiv46AaYLlde20dNkkPVCICJc9GJql/pKDE7We9VeyRnMUiI6FVc/B2v8HDX/xTBk8/h9X3TMrLz2J2rYeOvvsgWuP0w5v/B1c+BOs3uUZaVOZy+W+vMFw+M/iiBrqAIvFgsn02Xx/o9FIRUXFdY8xmUxYLBYMBoNfjXK5XFRVVfl1biDF9nsSWN49dpq56aHf2Pd/znimajmsDVRVNYe4NWIkGQvcM2csL5d/yqQ4GyuyPxutKrvQxOQkbVj+jl5PX1/fVdtcODmGfzvWyuEPyslMCd+i8dXjrWgVSKONqqrICeYQYqS7Vt9yLS6bC4D/PnmeiUqbau1o73VS29ZD0dTYiOufxTBEz0K3ZA/pH+0g7uAjON5+Euv0O7FOX4sz1lOIJDo8o6V/+OgUM40BGN10OUk/+iRjat+hce4/YY0pgAD8DNa027jUaydd59vvXCDl5uZe9ftDFlhXmw73129GvDnGFxqN5poNDqXxGf3wdgO9urHk5maGujn85nwlsdFt3DR3JhqNvK0S6noqx425+8/84lgbyxfkkpeehM3hoq7jAktnZ5Cbe0Oom+iTqqqqq/YraZNt/LKshKMtUaz8m/Drdwac+N173DhtHAvmqJPEJIRQx7X6luuZ8HsLVlecqs8671RagBqWL8ghd0r4v+EXasqFhSvA/D5R//OvjD+9h/FnXoY56+DGh0hOz+OJkkZ6Y8aSmztF3Vu73XDwYah9B5Y8hemmTQQqhqnsaC1Qz1e+PCPsZ28NOUXQZDLR2Ng4+PXVRqb++pjGxka/R6/C2bjEGFISdFQHKF7VV+aWbqakJkhxJQJCo1F47u58xsZH89CvT9DZZ+dcUxd2pzuiI9r/WnK8jttnmthXdpFemzPUzbmqT5q7ON/cLdMDhRghckzqJwmW1VqJ0ijMCuPNV0UAKQpMvRnueR0eOgb566HiNdi1ENOh+1gad4ZKtbclcbvhrW1w4ldw8/fgpk3qXv+vlNa0kZqgY0pq6GeRDWXIAmvWrFmYzWbq6uqw2WwcPnyYwsLCK44pLCxk//79uN1uysvL0ev1I7LAAs/i1I+bwiNJUCLaRaClJsbw0/VzqW3rYevek59LENSHuGXqWr9wEp19Dg6fDM+wi3erLADcljsy+1UhRpssYyKfNHdjd7pUu+aJWit56UlhvfmqCJLx2bDqeXj0NNyyDeXTMna7d/Cdqr+Dv7zq00bF1/XHH8JHP/Psz3XrY+pc8zqO11iZPyUy1hgOWWBFRUWxfft27r//fm6//XZWrFhBVlYWxcXFFBcXA7B48WIyMjIoKiri8ccf54knnhg8f/Pmzaxbt44LFy5w880388YbbwTu0wRBtlFPtaUr5EmCDqeL2rYeKbBEwC2cmsI/Ls3mUEUDL5RUExutYeq4xFA3S1ULp6aQOT4hbPfEereyiby0JCaODf+3dkKIoeUY9dicLmpau1W5nsPpoqL+ksSziysljINb/g9sOsWhyVtxOmyw7wF4fja8vxN6rf5f+4Pn4ci/QMEGWP4jzwhaADV19lHT2hMRARfgxRos8BRQixcvvuJ769evH/xvRVGuKKo+b+fOncNoXvjJMurp6nfw6aU+JiTHhawd9dZeHC63RLSLoPjuzdM4dqGNP55tZs7EMWhH2LRURVH4xsJJPHO4io8tnWQbw2eErq3bRmlNG/+7MCvUTRFCqGSgjznb2MV0w/D7m7OWTnpsTtlgWFxddCz9s+9l6dkZfHCni/SqF6HkKTjyYyi4F770XUjxIVvg2B54ZzvMvNMzUhaEEaXjZk8xOG9KZLxEkM1UfJRjHIhXDe00wQuX33plSoElgkCjUdh5Vz4ZKXEsykwNdXMCYu3ciei0mrAbxSqpsuByw1JZfyXEiDHdkIhG8RRGaiirbQdkg2FxbXnpSbjRUKpbAPcdgO/+tydKvfRFeGEuvHYv1H7kWVd1PeXFcPgfIXsFfPXfQBOcKamlNVZiojTMTI+MNYZSYPko2+iZGvVxY4gLrGZPgSUjWCJYxiboKNl8C1tXRFZ6oLdSEnQsm2li74mL9NnDJ+zi3SoLaWNimTGCgkWEGO1io7VMTk2gWqUC60StlXGJOiaODd3MGhHepo1PJFqrUPmpZy01plnw1Z/DppNw06Nw4X14cRnsWQKn94HT8cWLVB6AAw/C1MXw9f8AbXTQ2l9qbmNORjK6qMgoXSKjlWEkOV7HeH1MQDYI9IW5tRt9TBSpYb6TtRhZdFGaiFhc6q/1CzO41Gvn96fCI+zifHMX751tpijPOKL/dxdiNMo2Jqo2glVe206BbDAsrkMXpWG6QU/V5bCqQUlpsOQJ2FwJt/8Yelo9Gwb/tAA+/Bn0X/4ZrX4HfvP3MHEBrPu1Z6PjIOm1OTn9aQfzJ0fOCK0UWH7IMeqpDnGS4IWWbqaOT5DOVAgV3ZiZypTUeIqP1oW6KdgcLja9Wk6cTstDt04PdXOEECrLMeoxt3QPe8Tc2m3jk5ZuWX8lhpSXljSYBvwFugRY+G34h+Nw9yuQNAHe2go78+DgJs8UQkMufON1iAlu0FV5XTsOl5sFEbS/mxRYfsgyJlJt6cLlCl2S4IXLe2AJIdSjKArrFk7iz+Y2zoX4JcpP3v2Ykxcv8c9rZ2NMCt6bQiFEcGSb9LjcnpHq4Sivawdk/ZUYWm6anubOflq6+q99kEYLuXfAt/4A9/8XTF/i2ecqeTJs2AdxyUFr74BScxsQWT/jUmD5Iduop9fupN7aG5L79zucXGzvlYh2IQLga/MmEq1VePXPoRvF+vB8K7/403nWL8xg+UxTyNohhAicbJVCs07UWtFqFGZPjIzF/yJ08i6v5f3CNMFrmTgPvv5Lz/TBb5d4Yt9DoLTGSo5Rz5j44K35Gi4psPygVqfor9rWHtxupMASIgDGJcawNM/EmyfqQxJ2canHzubXy5mamsDjd+QF/f5CiOCYkppAtFYZ9prustp2bjDpidd5tfOOGMXy0jwF1mDQhbf0JogJzfYlTpebEzXWiIlnHyAFlh+yLicJqrU41VcXWjwJglJgCREY6xdOwtpj563TjUG9r9vtZtu+kzR39vPcunx5YBJiBNNFacgclzisVGKny015XbusvxJeSY7XkT4m1vsRrDDwsaWTzn5HRAVcgBRYfkmKjSZtTKxq8aq+GiiwJKJdiMD48rRUMlLigr4n1psnLnL4ZAObl2Yze2JyUO8thAi+bJN+WC9rzzV10dXviKi1KSK0cq8XdBGGSms8GwxHUsAFSIHlt2yjPmRR7ebWblISdIyJi5y5qEJEEo1GYd2CSXz0SRufDHMBurdqWrt54sApvpSZwgM3TwvKPYUQoZVtSKTe2kt3/1X2HPLCiVrPw2eBFFjCS7lpSZxvHn56ZbCUmtsw6GMibo83KbD8lG1M5FxzF84QJAleaOmW6YFCBNjX508kSqPw2rHAh13YnS4eebUcrUZh5135aDWy/YIQo0G2ybOupbrJvxc5ZbVWxsZHMyU1Xs1miREsLz0Jp8tNdYj3c/VWqdnK/CmRt8ebFFh+yjLqsTlc1LR2B/3eEtEuROAZ9LEsyTXyxvF6+h2BfdP305Jqyuva+dHa2aQnR9ZbOiGE/3IGQrP8XId1QjYYFj7KTfMxSTCEGi71crG9l/mTI2t6IEiB5bfBTjHIbwC6+x1YOvrJHC8FlhCBtn7RJNq6bbxTaQnYPY6Z2/jXP57ja/MmsnJ2WsDuI4QIPxkp8cRGa/xah3Wp1865pi7mSsCF8MHklHjiddqIWIdVavZMgZ0fYQmCIAWW36YbPEmCwY5qN18eMZMRLCEC72+nj2NCcuDCLjr67Gx6tZyJY+N58iszAnIPIUT40moUphsS/XqWGNhgWNZfCV9oNAo3mPQRUWAdr7ESr9MOxstHEimw/JQQE8XEsXHBL7BaegCJaBciGDxhFxl8cK41INOBt+8/RWNHH8+tyycxRiLZhRiNPKFZvj9LlNVaURSYk5GsfqPEiJaXnkRVQwdud/BzBHxxzNxGfkYyUdrIK1cir8VhJMeoD/oiwQstnvtNGScLWoUIhq/Pz0CrUXhV5bCL/WUX2V/+KY/cliURy0KMYjlGPZaOftp7bD6dd6K2nRyjXl7OCJ/lpiXR2eeg3tob6qZcU1e/g6qGjojb/2qAFFjDkGXU80lLF3anK2j3vNDSgzEpRjYgFSJITGNiKbzBwBulddgc6vyu17X18Pj+U8yfPJYHb5FIdiFGs4EkQV/WdLtcbsprrTI9UPglEoIuymvbcblhfoTtfzVACqxhyDYmYne6MbcEL0nQ3CoR7UIE2/qFGbR02SipGn7YhcPp4tHXygH4yd35ETn1QQihnuzLoVm+BF180tJFR5+DAgm4EH64waRHUaCqIbjLXHxxzNyGRiFif8blL/swZIcgSVD2wBIi+BZnG0gbE0uxCtMEf/7eeUprrDy9ZiYZKTLVV4jRLn1MLIkxUVT7UGCdqG0HkOnFwi/xuiimpiZQ2XAp1E25puM1VnJMSehjo0PdFL94VWAdOXKEZcuWUVRUxO7du7/w7263m2eeeYaioiJWrVrF6dOnvT43kk03JKJRfHvrNByXeuy0ddukwBIiyLQahbsXZPB+dTN1bT1+X6es1spzJdWszk9nTcEEFVsohIhUiqKQbUzkrA97YZXVWkmKjSJTngeEn3LTk8J2BMvhdFFWa2VBBMazDxiywHI6nezYsYM9e/Zw+PBhDh06xLlz56445siRI5jNZt5++22efvppnnzySa/PjWSx0VompcT79NZpOC5IRLsQIXPX/AwU4DU/R7G6+h1seq0cU1IsO1bPVLdxQoiIlmPyJAl6m+pWdnmDYY1GNhgW/slLS6K2rYfOPnuom/IFZxo76bY5mRehARfgRYFVUVHB5MmTycjIQKfTsXLlSkpKSq44pqSkhDVr1qAoCvn5+XR0dNDU1OTVuZHO33hVfwys9ZIRLCGCLz05jltzDLxeWudXsM1Tvz1NXVsPP7k7nzFxkTnlQQgRGNlGPdYeO81d/UMe29Xv4KylM2LXpojwMLC31BkfRk6DpdTcBkRuwAXAkFF0FosFk8k0+LXRaKSiouK6x5hMJiwWi1fnXo2iKFRVVXn1AULt0QUJQEJQ2psTC7//ZiaOtnqq2gJ+OyFGnOH+nv7TokQgkXMfn/X53G/N1PGtmZnQZ6FKhbAMIUT4GG7f8qUUz9/31voLtHpx/O/uywScEfOsJMKPCc/PHL3h9zdp0eXfh44GMx0NoW7N9UVFRZGVlfXF7w914tWGqxVF8eoYb869mvz8/CGPEUIIIYQQQohwM2SBZTKZaGxsHPzaYrFgMBiue0xjYyMGgwG73T7kuUIIIYQQQggxUgy5BmvWrFmYzWbq6uqw2WwcPnyYwsLCK44pLCxk//79uN1uysvL0ev1GAwGr84VQgghhBBCiJFiyBGsqKgotm/fzv3334/T6eTOO+8kKyuL4uJiANavX8/ixYv505/+RFFREXFxcfzwhz+87rlCCCGEEEIIMRIpbm8zQYUQQgghhBBCXJdXGw0LEQ4KCgqu++8bNmzg5MmTQWqNEGKkkL5FCBEI0reMXlJgCSGEEEIIIYRKQlZgDVXVC3E1R48e5YEHHhj8eseOHezduzeELRLhRvoW4Q/pW8RQpG8R/pC+ZXSSESwhhBBCCCGEUMmQKYKB1N3dzYMPPkhHRwcOh4NHHnmEJUuWUF9fz7e//W3mzZtHWVkZRqORn/3sZ8TGxoayuUKICCF9ixAiEKRvEUJ4I6QjWDExMezatYt9+/bx0ksv8eyzzzIQalhTU8M999zD4cOH0ev1vPXWW6FsqggTWq0Wl8s1+HV/f38IWyPClfQtwlfStwhvSN8ifCV9y+gU0hEst9vNzp07OXbsGBqNBovFQktLCwATJ04kNzcXgBkzZnDx4sVQNlWEiQkTJnD+/HlsNhv9/f18+OGHzJs3L9TNEmFG+hbhK+lbhDekbxG+kr5ldAppgXXw4EHa2trYu3cv0dHRFBYWDlb2Op1u8DitVisV/yjncDjQ6XSkpaWxfPlyVq1axZQpU8jLywt100QYkr5FeEv6FuEL6VuEt6RvGd1CWmB1dnaSmppKdHQ0H330kbztEdd07tw5MjIyANiyZQtbtmz5wjEvv/xysJslwpT0LcJb0rcIX0jfIrwlfcvoFpI1WANV/apVqzh16hRr167l4MGDZGZmhqI5IswVFxezefNmNm3aFOqmiDAnfYvwhfQtwlvStwhfSN8iFPfA6swgOnPmDN///vf5zW9+E+xbCyFGMOlbhBCBIH2LEMIXQZ8iWFxczMsvv8y2bduCfWshxAgmfYsQIhCkbxFC+CokI1hCCCGEEEIIMRKFdB8sIYQQQgghhBhJglJgNTQ0sGHDBlasWMHKlSt56aWXAGhvb2fjxo0sXbqUjRs3cunSJQCsVisbNmygoKCAHTt2XHGtDRs2sGzZMlavXs3q1atpbW0NxkcQQoQZNfsVm83G448/zrJly1i+fLlsECrEKKZW39LV1TX4rLJ69WoWLVrED37wg5B8JiFEcAVlimBTUxPNzc3MmDGDrq4u7rzzTnbt2sXevXtJTk7mO9/5Drt37+bSpUt873vfo6enh8rKSqqrq6murmb79u2D19qwYQNbtmxh1qxZgW62ECKMqdmvvPDCCzidTh599FFcLhft7e2kpKSE8NMJIUJFzb7l89auXcvWrVtZsGBBkD+RECLYgjKCZTAYmDFjBgCJiYlkZmZisVgoKSlhzZo1AKxZs4Z3330XgPj4eObPn09MTEwwmieEiEBq9itvvvkmDzzwAAAajUaKKyFGsUA8s5jNZlpbW5k/f37A2y+ECL2gr8Gqr6+nqqqKOXPm0NraisFgADwdWltbm1fX2LZtG6tXr2bXrl1IRocQYjj9SkdHBwDPP/88X/3qV3n44YdpaWkJeJuFEOFPjWcWgEOHDnH77bejKEqgmiqECCNBLbC6u7t5+OGH2bZtG4mJiX5d48c//jEHDx7klVde4fjx4xw4cEDlVgohIslw+xWHw0FjYyNz585l3759FBQU8OyzzwagpUKISKLGM8uA3/3ud6xcuVKllgkhwl3QCiy73c7DDz/MqlWrWLp0KQCpqak0NTUBnjnP3kzLMRqNgGfY/o477qCioiJwjRZChDU1+pWxY8cSFxdHUVERAMuXL6eysjKwDRdChDW1nlnAs0mx0+lk5syZAWuvECK8BKXAcrvdPPbYY2RmZrJx48bB7xcWFrJ//34A9u/fz2233Xbd6zgcjsEhebvdznvvvUdWVlbA2i2ECF9q9SuKonDrrbdy9OhRAD788EOmTZsWsHYLIcKbWn3LgEOHDsnolRCjTFBSBEtLS7nnnnvIzs5Go/HUdJs3b2b27Nls2rSJhoYG0tLSeP7550lOTgY8HVlXVxd2ux29Xs+LL75Ieno69957L3a7HZfLxY033sjWrVvRarWB/ghCiDCjVr8yffp0Ll68yJYtW+jo6CAlJYUf/ehHpKenh/DTCSFCRc2+BeC2225j9+7d8uJGiFEkKAWWEEIIIYQQQowGQU8RFEIIIYQQQoiRSgosIYQQQgghhFCJFFhCCCGEEEIIoRIpsIQQQgghhBBCJVJgCSGEEEIIIYRKpMASQgghhBBCCJVIgSWEEEIIIYQQKvn/NLefL021xOgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = metrics.IC.plot(figsize=(12, 4), \n",
    "                     label='Information Coefficient',\n",
    "                     title='Validation Performance',\n",
    "                    ylim=(0, .08))\n",
    "metrics.IC.expanding().mean().plot(ax=ax, label='Cumulative Average')\n",
    "plt.legend()\n",
    "sns.despine()\n",
    "plt.tight_layout()\n",
    "plt.savefig(results_path / 'cnn_ts1d_ic', dpi=300);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "240.391px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}