model_tester.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "from tqdm import tqdm\n",
    "from natsort import natsorted\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Layer,Input, Dense, Dropout, Activation, Concatenate, Flatten, MaxPooling2D, Convolution2D, Convolution1D, MaxPooling1D, GlobalMaxPooling1D, BatchNormalization, LSTM, GRU, Bidirectional, Lambda\n",
    "from keras.regularizers import l2,l1\n",
    "from keras.optimizers import SGD,Adam,RMSprop\n",
    "from tensorflow.compat.v1 import InteractiveSession\n",
    "import keras.backend as K\n",
    "from keras.preprocessing.image import array_to_img, img_to_array, load_img\n",
    "from keras.callbacks import EarlyStopping, ModelCheckpoint,ReduceLROnPlateau\n",
    "from keras.models import load_model\n",
    "import keras.metrics\n",
    "import tensorflow_addons as tfa\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import tensorflow as tf\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from keras.utils import to_categorical, plot_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plots\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import average_precision_score\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "#confusion matrix\n",
    "from sklearn.metrics import plot_confusion_matrix\n",
    "from sklearn import metrics as sklearn_metrics\n",
    "from sklearn.metrics import r2_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "le = LabelEncoder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1.0\n"
     ]
    }
   ],
   "source": [
    "print(tf.__version__) #should be TF 2.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = 153924"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load directly from npy files #this step skips the data loading from folders as images\n",
    "off_dataset = np.load('off_dataset.npy')\n",
    "target_dataset = np.load('target_dataset.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((153924, 4, 28, 1), (153924, 4, 28, 1))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "off_dataset.shape, target_dataset.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get both types of output\n",
    "output = pd.read_csv('output2.csv')\n",
    "y = output['y']\n",
    "freq = output['freq']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = le.fit_transform(y).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[1],\n",
       "        [1],\n",
       "        [1],\n",
       "        ...,\n",
       "        [0],\n",
       "        [0],\n",
       "        [0]]),\n",
       " (153924, 1))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y, Y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[39.],\n",
       "        [39.],\n",
       "        [38.],\n",
       "        ...,\n",
       "        [ 0.],\n",
       "        [ 0.],\n",
       "        [ 0.]]),\n",
       " (153924, 1))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "freq = freq.values.reshape(-1,1)\n",
    "freq, freq.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((153924, 4, 28, 1), (153924, 4, 28, 1), (153924, 1), (153924, 1))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#data summary\n",
    "off_dataset.shape, target_dataset.shape, Y.shape, freq.shape\n",
    "#should be ((153924, 4, 28, 1), (153924, 4, 28, 1), (153924, 1), (153924, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#now model\n",
    "def clear_sess():\n",
    "  try:\n",
    "    del model, history\n",
    "  except:\n",
    "    pass\n",
    "  from keras import backend as K\n",
    "  K.clear_session()\n",
    "  return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "clear_sess()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#metrics for classification\n",
    "metrics_c = [\n",
    "    #keras.metrics.FalseNegatives(name=\"fn\"),\n",
    "    #keras.metrics.FalsePositives(name=\"fp\"),\n",
    "    #keras.metrics.TrueNegatives(name=\"tn\"),\n",
    "    #keras.metrics.TruePositives(name=\"tp\"),\n",
    "    #keras.metrics.BinaryAccuracy(name='accuracy'),\n",
    "    keras.metrics.Precision(name=\"precision\"),\n",
    "    keras.metrics.Recall(name=\"recall\"),\n",
    "    keras.metrics.AUC(name=\"auc_pr\",curve=\"PR\")\n",
    "]\n",
    "\n",
    "#metric_r = tfa.metrics.r_square.RSquare()\n",
    "metric_r = tfa.metrics.r_square.RSquare(dtype=tf.float32, y_shape=(1,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #model compile is one of the most important step\n",
    "# model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),\n",
    "#               loss={'r': 'mse','c': 'binary_crossentropy'},\n",
    "#               loss_weights={'r': 0.001,'c': 1.0},\n",
    "#               metrics={'r':[metric_r],'c':metrics_c})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # data split for 1D- not used, squeeze is used for removing the channel dimension\n",
    "# use of indexes to refer data later\n",
    "img_indexes = list(range(0,samples))\n",
    "\n",
    "\n",
    "#for conv2D\n",
    "off_dataset_train, off_dataset_test, target_dataset_train, target_dataset_test, Y_train, Y_test, freq_train, freq_test, train_index, test_index = train_test_split(off_dataset, target_dataset,Y,freq,img_indexes, test_size=0.1, random_state=10) # seed=1, fixed for test set; hold out\n",
    "off_dataset_train, off_dataset_valid, target_dataset_train, target_dataset_valid, Y_train, Y_valid, freq_train, freq_valid, train_index, valid_index = train_test_split(off_dataset_train, target_dataset_train,Y_train,freq_train,train_index, test_size=1/9, random_state=2) #mostly 1 but can be 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((123138, 4, 28, 1), (123138, 4, 28, 1), (123138, 1), (123138, 1))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#train summary\n",
    "off_dataset_train.shape,target_dataset_train.shape,freq_train.shape,Y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((15393, 4, 28, 1), (15393, 4, 28, 1), (15393, 1), (15393, 1))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#validation summary\n",
    "off_dataset_valid.shape,target_dataset_valid.shape,freq_valid.shape,Y_valid.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((15393, 4, 28, 1), (15393, 4, 28, 1), (15393, 1), (15393, 1))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#test summary\n",
    "off_dataset_test.shape, target_dataset_test.shape, freq_test.shape,Y_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "############################### load different models\n",
    "\n",
    "model_name = 'best_model_seed10_epoch50.hdf5'\n",
    "\n",
    "#model = keras.models.load_model('models/'+model_name,compile=False)\n",
    "model = keras.models.load_model(model_name,compile=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "##### predictions on train-valid-test set\n",
    "\n",
    "yreg_pred_train, ycls_pred_train = model.predict([off_dataset_train,target_dataset_train])\n",
    "y_label_pred_train = np.where(ycls_pred_train > 0.5, 1, 0)\n",
    "\n",
    "\n",
    "# predict on valid set\n",
    "yreg_pred_valid, ycls_pred_valid = model.predict([off_dataset_valid,target_dataset_valid])\n",
    "y_label_pred_valid = np.where(ycls_pred_valid > 0.5, 1, 0)\n",
    "\n",
    "\n",
    "# predict on test set\n",
    "yreg_pred_test, ycls_pred_test = model.predict([off_dataset_test,target_dataset_test])\n",
    "y_label_pred_test = np.where(ycls_pred_test > 0.5, 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ###### ROC Curve for train set\n",
    "# fpr = dict()\n",
    "# tpr = dict()\n",
    "# roc_auc = dict()\n",
    "\n",
    "# for i in range(1):\n",
    "#     fpr[i], tpr[i], _ = roc_curve(Y_train[:, i], ycls_pred_train[:, i])\n",
    "#     roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "    \n",
    "# fig, ax = plt.subplots(figsize=(8,7))\n",
    "# ax.plot(fpr[0], tpr[0],label=' (AUC: %0.3f)' % roc_auc[0], alpha=1)\n",
    "# ax.plot([0, 1], [0, 1], 'k--')\n",
    "# ax.set_ylim([0.0, 1.01])\n",
    "# ax.set_xlim([0.0, 1.01])\n",
    "# ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xlabel('False Positive Rate', fontsize=14)\n",
    "# ax.set_ylabel('True Positive Rate', fontsize=14)\n",
    "# ax.tick_params(axis=\"x\", labelsize=12)\n",
    "# ax.tick_params(axis=\"y\", labelsize=12)\n",
    "# ax.set_title('ROC Train Set', fontsize=14)\n",
    "# ax.grid()\n",
    "\n",
    "# ax.legend(fontsize=12)\n",
    "# plt.savefig('results/'+model_name+'_train_roc.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ###### ROC Curve for validation set\n",
    "# fpr = dict()\n",
    "# tpr = dict()\n",
    "# roc_auc = dict()\n",
    "\n",
    "# for i in range(1):\n",
    "#     fpr[i], tpr[i], _ = roc_curve(Y_valid[:, i], ycls_pred_valid[:, i])\n",
    "#     roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "    \n",
    "# fig, ax = plt.subplots(figsize=(8,7))\n",
    "# ax.plot(fpr[0], tpr[0],label=' (AUC: %0.3f)' % roc_auc[0], alpha=1)\n",
    "# ax.plot([0, 1], [0, 1], 'k--')\n",
    "# ax.set_ylim([0.0, 1.01])\n",
    "# ax.set_xlim([0.0, 1.01])\n",
    "# ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xlabel('False Positive Rate', fontsize=14)\n",
    "# ax.set_ylabel('True Positive Rate', fontsize=14)\n",
    "# ax.tick_params(axis=\"x\", labelsize=12)\n",
    "# ax.tick_params(axis=\"y\", labelsize=12)\n",
    "# ax.set_title('ROC Validation Set', fontsize=14)\n",
    "# ax.grid()\n",
    "\n",
    "# ax.legend(fontsize=12)\n",
    "# plt.savefig('results/'+model_name+'_valid_roc.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ###### ROC Curve for test set\n",
    "# fpr = dict()\n",
    "# tpr = dict()\n",
    "# roc_auc = dict()\n",
    "\n",
    "# for i in range(1):\n",
    "#     fpr[i], tpr[i], _ = roc_curve(Y_test[:, i], ycls_pred_test[:, i])\n",
    "#     roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "    \n",
    "# fig, ax = plt.subplots(figsize=(8,7))\n",
    "# ax.plot(fpr[0], tpr[0],label=' (AUC: %0.3f)' % roc_auc[0], alpha=1)\n",
    "# ax.plot([0, 1], [0, 1], 'k--')\n",
    "# ax.set_ylim([0.0, 1.01])\n",
    "# ax.set_xlim([0.0, 1.01])\n",
    "# ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "# ax.set_xlabel('False Positive Rate', fontsize=14)\n",
    "# ax.set_ylabel('True Positive Rate', fontsize=14)\n",
    "# ax.tick_params(axis=\"x\", labelsize=12)\n",
    "# ax.tick_params(axis=\"y\", labelsize=12) \n",
    "# ax.set_title('ROC Test Set', fontsize=14)\n",
    "# ax.grid()\n",
    "\n",
    "# ax.legend(fontsize=12)\n",
    "# plt.savefig('results/'+model_name+'_test_roc.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "######## important auc PR curve Train Set\n",
    "precision = dict()\n",
    "recall = dict()\n",
    "average_precision = dict()\n",
    "for i in range(1):\n",
    "    precision[i], recall[i], _ = precision_recall_curve(Y_train[:, i], ycls_pred_train[:, i])\n",
    "    average_precision[i] = average_precision_score(Y_train[:, i], ycls_pred_train[:, i])\n",
    "    \n",
    "# A \"micro-average\": quantifying score on all classes jointly\n",
    "precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(Y_train.ravel(), ycls_pred_train.ravel())\n",
    "average_precision[\"micro\"] = average_precision_score(Y_train, ycls_pred_train, average=\"micro\")\n",
    "#print('Average precision score , micro-averaged over all classes: {0:0.2f}'\n",
    "#    .format(average_precision[\"micro\"]))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,7))\n",
    "ax.step(recall['micro'], precision['micro'], where='post')\n",
    "\n",
    "ax.set_xlabel('Recall', fontsize=14)\n",
    "ax.set_ylabel('Precision', fontsize=14)\n",
    "ax.plot([0, 1], [1, 0], 'k--')\n",
    "ax.set_ylim([0.0, 1.01])\n",
    "ax.set_xlim([0.0, 1.00])\n",
    "ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_title('Precision-Recall Curve Train Set', fontsize=14)\n",
    "ax.tick_params(axis=\"x\", labelsize=12)\n",
    "ax.tick_params(axis=\"y\", labelsize=12) \n",
    "ax.grid(linestyle='-.', linewidth=0.7)\n",
    "ax.text(0.5, 0.1, 'aucPR={0:0.3f}'.format(average_precision[\"micro\"]), bbox=dict(facecolor='red', alpha=0.5),fontsize=14)\n",
    "plt.savefig('results/'+model_name+'_train_aurPR.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "######## important auc PR curve Valid Set\n",
    "precision = dict()\n",
    "recall = dict()\n",
    "\n",
    "average_precision = dict()\n",
    "for i in range(1):\n",
    "    precision[i], recall[i], _ = precision_recall_curve(Y_valid[:, i], ycls_pred_valid[:, i])\n",
    "    average_precision[i] = average_precision_score(Y_valid[:, i], ycls_pred_valid[:, i])\n",
    "    \n",
    "# A \"micro-average\": quantifying score on all classes jointly\n",
    "precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(Y_valid.ravel(), ycls_pred_valid.ravel())\n",
    "average_precision[\"micro\"] = average_precision_score(Y_valid, ycls_pred_valid, average=\"micro\")\n",
    "#print('Average precision score , micro-averaged over all classes: {0:0.2f}'\n",
    "#    .format(average_precision[\"micro\"]))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,7))\n",
    "ax.step(recall['micro'], precision['micro'], where='post')\n",
    "\n",
    "ax.set_xlabel('Recall', fontsize=14)\n",
    "ax.set_ylabel('Precision', fontsize=14)\n",
    "ax.plot([0, 1], [1, 0], 'k--')\n",
    "ax.set_ylim([0.0, 1.01])\n",
    "ax.set_xlim([0.0, 1.00])\n",
    "ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_title('Precision-Recall Curve Valid Set', fontsize=14)\n",
    "ax.tick_params(axis=\"x\", labelsize=12)\n",
    "ax.tick_params(axis=\"y\", labelsize=12) \n",
    "ax.grid(linestyle='-.', linewidth=0.7)\n",
    "ax.text(0.5, 0.1, 'aucPR={0:0.3f}'.format(average_precision[\"micro\"]), bbox=dict(facecolor='red', alpha=0.5),fontsize=14)\n",
    "plt.savefig('results/'+model_name+'_valid_aurPR.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAHBCAYAAAAb0dNLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeXxU1d24nzOZmeyTlSSQELKRBAggSQiIG660blWrv1q1tmrV1lr7Wvt2EXG3Wq3Vtmpbq9W2Lq91r4o7big7CrIkISQhBEhCCGRPJpM5vz9uGDIhe2Y7yXk+n/kwM2e5z5wMc7/33LMIKSUajUaj0WgmJiZ/C2g0Go1Go/EfOhDQaDQajWYCowMBjUaj0WgmMDoQ0Gg0Go1mAqMDAY1Go9FoJjA6ENBoNBqNZgKjAwGNph+EEE8LId4cZt7FQggphIj3tleg0PN5LxzotUajUQcdCGgCmp4Tsux5dAkhyoUQvxdChHv50D8DLhtm3i+AycAB7+kY9GoLKYRoEUJsEkL8wNvH9QRCiEghxF1CiG1CiHYhRK0Q4mMhxHeFEAH3W9Snrft7PD2Gum8XQmwZRr4gIcSvhBDbhRBtQoiDQoj1QogbRvFZdKCm6RezvwU0mmHwAfA9wAKcADwBhAM/7ptRCGEGuuUYV8qSUjaOIK8dqBnL8UbI1cCbGG3wHeApIcQ+KeW7PnQYEUKIaGAlEAPcAqwF7MDxwDJgFVA5yrqtPX8DTzO51/Ozgb/3ea/dC8fsy23AdcD1GG0WAcwDUn1wbM1EQUqpH/oRsA/gaeDNPu/9HdjX8/x2YAvwA2An0I3xYxkFPA7UAc3AJ0Bhn3oWAiuAVqAR+BCY0t9xgROB1UBLT941QF5P2mJAAvG98l8AfA10AruBpYDolV6JcUL8G9AEVAP/O4z2kMCFfd47ADzY6/VYP/s3gM+Ag0AD8C4wYzCP/rz65H+s51gp/aSFACG92uUXfdI/Bh7p03a3A/8ADgEvYgQSD/YpZ8M4WZ/f89oK/K6nrVuBdcCSYX4PLwRkn/fOATYAHUAFcA9g7fMd2Nzj0NDzd0jE+K7KPo8fDHDcr4C7h+F3BbCtx6UUuBEw9Wqv3seq9Pf/a/0IrEfAdcdpNMOgHaN34DDpwCXARcBcjJPvW0AyxpXcPOBTYIUQYjKAEGIu8BFQBhyHcWL8D/30kvX0MryOcUU7F1gA/BEj6DgKIUQBxsnpFWA28GvgNxhXdb25ESNYyMc4Qd0vhDh2uI3Q0238/4BYoKvnPeGBzx4OPAwUYQQ5jcAbQgjrcN36eJqAi4FnpZTVfdOllB1Syo4RVvtzoBgoBG4GngEu7nOL4dsY35W3el4/BZyE8V2ZDfwT43PNHeGxEUIsAZ4FHgFmAVdiBAu/7UlPAv6v5xgzMALJf/cUfwF4ECjB6GGY3PNef9QAi4UQiYO4XN1z3Ft7jnUT8CuMngSA+T3/Xt1zrPl969BMcPwdieiHfgz24Ogr8yKgHnih5/XtGCfBxF55TsG4cg/tU9dXwC97nj8LrB7OcTFOtBI4aYC8i+nVI9BT94o+eW4Hqnu9rgSe75NnB3DLEO0hMU5uLYCj53U9kOWpz97PMcMxgp7j+3gMq0cASOhJv3EYx6pkeD0Cb/TJE4dxq+HUXu99APyt53km4ARS+5R7DXhsGF5uPQIYwdWyPnnO62l7gRHcSWDaAPXdDmwZxnFnYlzpO4GtGLfFLsC9d6kK+F6fcv8DbBvO30c/9EP3CGhU4Bs9A+M6MLqAPwV+2iu9WkpZ2+t1ARAG7O8p1yKEaAHyME4IYFwpfzicg0spGzACg3eFEG8JIX4uhJg6SJEZwOd93lsJJAshbL3e29wnz16MkyZCiL/2ce/N/wLHAKdjnOBvkFKW9aSN+bMLITKFEM8JIXYKIZqAWoyBxaO9Ly1GWW4w1vd+IaU8gHEL41KAnt6PkzF6CsA4MQtgW592OYsj7TISCoClfep6DiNoSgI2YQQiW4QQLwshfiyEmDTSg0gpt2H87RZgBAFxGL03bwkhTD11TgX+1sflvlF+Ls0ERA8W1KjAp8A1GFf+e6WUXX3SW/u8NmGcvE7op66mnn9HdHKSUl4hhHgY4/75ucA9QojzZP8D9ATGFVi/VfV63vdzSI7M5LkV+P0AddT0nPjLhBAXARuFEBullMV45rO/AewBru3514FxVTqqWwPAfozxBjOGkdfZj5+ln3x9/+ZgnPQfF0JcB3wXY2zGyp40E0b7zufodh/NoD8TcAfGLaC+7JdSdgshzsC47XIGcBVwrxDiJCnlppEcSErpxBjPsA54SAhxGcZthhOB7T3ZfoQxe0WjGTE6ENCoQFuvK97hsBFjUJZTSlk+SJ5TRiLR8wO+CfidEOJt4PsYV6F92YYxGr43x2P0XDQP81h1GIP9hspXJoR4BbgfI0AZ02cXQsRhnLB/IqX8qOe9fMbwWyGldAohXgAuF0LcKfuMExBChPTk68AIGib3ScsFvhzGoV7HGCR5NkbPwLNSysOB15cYAUbS4c81RjYCuYN9L3uOvQpYJYS4E6Nr/zsY3yE7EDTKY2/r+TdCSlkrhNgDZEop/zVIma4xHE8zztGBgGY88gFG1/zrQohfYgwqS8K4mv9ASvkZ8ACwWgjxOPAoxmjrE4D3pJRVvSsTQqRjXB3/F+MKOQOYA/xlgOM/CKwTQtyO0V08H2MA180e/Ix9j7dJCFHEGD87xoj6euBqIcRujEGHD2D0CoyFmzHGUqwRQhyePtgJHIsxmPIsjHv/K4ArhRD/xQgKltJ/j8BRSCk7eoKiWzAGdV7WK61UCPEs8LQQ4iaME3lsj1O5lPKVEX6eO4E3hRC7MLrqHRhd+EVSyl8KIRYCp2EEirUYt2OmcuQkXglM6wmyqoBmKWVn34MIIV7C+Ht+gTFwMB24FyNIPNwDcDvwZyHEIWA5RnvlA8lSynt7He9UIcQnQKeU8uAIP69mPOPvQQr6oR+DPehn+mCf9NvpZ9AVEIkxsr8a4+prN8Yo7sxeeY7HuO3QjjEN7QNgct/jYlxhv4IRBHRi/HDfD1h60hcz8PTBw8fub/rgoIPiBvi8/Q76wjiJv+ehz34KxpTMjp5/l2AMgvvBQB4DefVxjMKYYlfcU3ddz2e+mCNT3WzA8xgzFfZgjHx3a5f+2q5X2ik9Lhv6SbP0fF/Ke9qlBiO4KxjG97C/6YNnYEyzbMO47bIeuL4nbQbwNkYQ0IkxQ+OXvcoGAy9h3DIZbPrg1T1/m8P1HP5bzuqT77sYwU1HT50rgYt7pZ+DMRi1Cz19UD/6PISUA93K1Gg0Go1GM97RswY0Go1Go5nA6EBAo9FoNJoJjA4ENBqNRqOZwOhAQKPRaDSaCcy4mj4YGxsrMzIy/K0xIux2O1braNdp8T2q+YJ29gWq+YJ29gWq+YKazhs2bKiXUo545UoXvpyigLHpynqMaTBPD5H3RozpPY0Yu4wFD1V/bm6uVI1Vq1b5W2FEqOYrpXb2Bar5SqmdfYFqvlKq6Qysl2M4N/v61sBe4O6eE/uA9Ozs9WvgVCANYwGXO7wtp9FoNBrNRMMv6wgIIe7G2Jf8BwOkP4ex6MXNPa9PxVguNGmweqOSpslz7/g3luBQTyt7DafTicnkuXjsvHnJnDt3isfq60tXVxcWy7AWegsYtLP3Uc0XtLMvUM0X1HQWQmyQUhaOtnygjhGYhbFu+GE2AYlCiDhp7DLmQghxDcaGNCAEr915FXMuv43gqHhAEB4eTkdHB8HBwbS1ue9TYrUGI5EEmYLocnTR7TiyiqrJZCIkJBS7vROz2UJHh/u+JCEhoTgcXVitwXR0tON0Ol1pQWYzFrOFbmc3AoHd7r5yaFhYOJ2dnYSEhNDU1ERQ0JFAwGKxIkwCgaDb2Y2jq9f+KEIQHmZ8HqvVSnt7m1u9e1skLa1tnJ4dQ2VlJY2Nja60yMhIsrKy2Lt3L1FRUZSWlrqVnT17NtXV1eTk5LBx40bsdrsrLSEhgdjYWDo6Oti9ezfd3d1uZYuKitixYwdZWVmsW7fOLW3atGk9nzmM+vp69u/f36sNQ5gzZw47duwgOTmZLVu2uJXNzc2loaGBlJQUSktLaWk5sglfTEwMKSkpHDhwgNDQUHbu3OlWdt68eVRUVJCbm8tnn31GWFiYK23y5MmEh4cjpaS9vZ29e/e60kwmE0VFRRQXF5ORkcHGjRvd6s3IyMButxMdHc2ePXs4ePDISq3h4eHk5uZSVVVFfHw827dvdys7a9YsampqyMjIYMuWLbS3H/lOxcfHk5CQQEtLCyaTiS1bthAREeFKLywsZOfOneTk5LB69Wq3eqdOnYrZbMZisdDY2Eht7ZGNGC0WCwUFBZSUlJCamsqmTe773WRnZ9PU1ERiYiIVFRU0NTW50mw2G+np6dTW1mKz2Y76zsydO5eqqipycnJYuXIloaFHAvDExESioqLo6urC4XCwe/dut7ILFy6kpKSEzMxM1q9320iQtLQ0nE4nERER1NXVUV9f70oLDQ0lLy+P8vJykpKS2Lp1q1vZGTNmUF9fT2pqKsXFxbS2Hvk/HxMTQ3JyMocOHcJqtbJ582a3Ns7Pz6e8vJzc3FzWrl3r9n96ypQphIaGIoSgtbWVffv2udKCgoKYP38+xcXFpKen8+WX7tsiZGZm0t7eTlxcHNXV1W7fmYiICLKzs6muriY2Npbi4mK3snl5eezZs4fp06ezefNm6uvrXc6TJk0iPj6etjbjd2DXrl1uZefPn09ZWRnTp09n7dq1bmmpqak9v3EhNDQ0UFd3ZFsLq9VKfn4+JSUlpKSk8PXXX7uVzc7OprGxkSlTplBWVkZz85HtM6KiokhLS6Ouro7w8HC++uortzbu/Z1Zv349jl6/uUlJSdhsNhwOB3a7nerqI1tSCCFYsGABJSUlZGRksGHDBjen9PR0HA4HNpuNmpoaDhw4cpoICwtj5syZVFZWkpCQwLZt29zKzpw5k7q6OtLS0ti2bRt1dXUu57i4OJKSkmhqasJsNlNRUeFWtqCggPLycnJyclizZg29L6xTUlKwWq2YzWaampqoqalxpZnNZgoLCwf8f5mVlUVraysJCQkj/i0fDYHaI7ATY9OTd3peWzCWBE2XUlYOVO/06dNlTU0NNpuNN954g/z8fM/LBzDnPfo5tlAL/7qyyKP1SilpaLW7bZsXE2YlyOSN3WU1Go1GMxLGa49AC8aa44c5/HzQndvMZjOff/4555xzDieccALPPvss5513ntckPcGaNWtYsGCBx+pr7XSwbW8Tew61IwCH08m+xg6CzUFUNRhXDk4pqW3qoM3ejdkk6Op2sutAG+HBZrqdkn2N7TglmAR0dUsa2/vu2grnzp3Cn747z2Pe3sTTbewLVHNWzRe0sy9QzRfUdB4rgRoIbMXYPew/Pa/nArV9bwv0x5w5c1izZg3nnXceK1euDPhAwJM9MiEWE6vLGzjzT58Nmi/UEoTZJGjudDAtLoxwq5mwYDMHWjvJmhRBcnQoB9vspMWFE2IxYTWbaLV3MyMpkoqKSj7aCzVNHR7z9jb+6PUaK6o5q+YL2tkXqOYLajqPFZ8GAkIIc88xg4Cgnr3GHVLKvluc/gtju9BngX0Y24o+PdzjJCUl8fHHH7sGfJSVlZGamqrc3NCR8sCFc9m617iX1OlwMi0uHGuQCZMJokOthFhMRASbMQeNfnDialHDPzYfoKK+lV++tIkddS2EWYPo7HLS5ZTcctYM5qfFeuojaTQajcbL+LpH4Bbgtl6vLwPuEEL8A2Of7plSyiop5TtCiPuBj4BQ4OU+5YYkJCQEgJaWFk466SSmT5/Oyy+/TFxcnCc+R0AyNTaMqbFhQ2f0EK9+uYeUmDCqDrQxPTGC9bsOsq6yQQcCGo1GoxA+DQSklLdj7AfeHxG9X0gp/wD8YST19zflIyIigvvvv5+rrrqKBQsW8NZbb5GTkzOSar1KSkqKvxVGREpKCpX3LTzq/Y6ubnKXvcOfPyxjYUYc+akxfrDrH9XaGNRzVs0XtLMvUM0X1HQeK+Nqr4GB5uNfeumlrFixgqamJhYuXMiHH37oY7OBUe12xUC+5p4ZBO1d3Tz0/tins3gS1doY1HNWzRe0sy9QzRfUdB4r4yoQGIxFixaxdu1akpOTefjhh/2t48JsDtTxmv0zkK85yMTO357J9IQIPttRz98+2cm9b2/n3re389D7pTi6nf2W8wWqtTGo56yaL2hnX6CaL6jpPFbG1SfuvQBIf6SlpfHFF1+4Xh88eBCbzUZQUJC31QakqamJ2Fh17qkP5htkEuyoMxb9ufdt94VRvpGXxIzJNrf3Wjsd1DR1cLDVTl1zJ0Emwck5CVjNno1PA7mNpZQ0dThoau+iqaOLdns3ew61U7+/ng5zAwCdXd10OSWXLZxGcnRgrpoZyG08ENrZ+6jmC2o6j5VxFQh0dR09370vNpvNlfcb3/gGCQkJPPfcc0RGRnpbr19qampIS0vzy7FHw1C+r163iDUVDZyck0BsuJWVZfu58YVN3PjCVxxq68IkoKXTQVNH34kiBn/7XgFLZrmvJO10Sg602qlt6qD6oLEWwqKseGwhw1sGtK9zV7eTpvYuJBAfETysOgbD0e2koc3OgRY7LZ0Oqg+24XRC2f4WgoSgor6Vrm4nDa12DrV3YXc42XvIWFXQ4Rz+VKXlX+/jtBmJhFmDCDIJrj0xk1Cr/4LY3qj2PQbt7AtU8wU1ncfKuAoERoLFYuH73/8+N9xwA8cffzxvvPEGqamp/tZSnnmpMczrNVCwtdNYjri4xlgLKjrMwukzk2jtdDApMpi4CCuJthCcUrL01S089H4pT35WQUOb3XV13B+//EYO1y3OAoyr6voWO43tdvY326lpaqeyvo2axg4sZsHn2w8R/9UXrKs8iElA73Pvf68/jjkp0a7XnY5uGtu72Heog8b2LuPqvLmTlk4Huw4YQUhpbTNWs4nimmaCzSY6HUPf9gi1BBEeHERSVAiWIBNnzp5Mm72bGZMjabd3k5kQQbdTMjU2DItJsLe8mEVFBdhCLViDTGTf8ja7DrTx5MojS5yu2nmAmVNsNLTacXRLdh9swxJkonx/C6GWIOzdTs6aPZk7vpUHQLu9m+bOLhrbuqhvsWPvdtJu72ZeajSJtpDh/Hk1Gs04ZMIGAgDXXXcdWVlZXHTRRRQVFfH6669PuBWlvM1lC6dx2oxEYsOtg3b5H2y187u3i10BA0DmpHBOm5GILdRMfEQwU6JCSIkJ44f/Ws/975Tw7Ooq6po76Ooe/Kp6UpgJ+6EOTsqeRIjFREpMGPUtnbz+1V7OfeRz5qfFsGl3I+YgQZu9e8B6Qi1BtHd1MyclipZOB986Zgrt9m5yJ9twOiXp8eFYzSYSIoOJiwgmKtRCbPjolmJeXW9mSq/bAJ/98mQAosIsbNvbxMWPr2ZNRQNrKhoIMgm6nZKshAia2js4Zmo0je1dbKw6xD9X7eLFDdWDfi6Aey+YTVVDGxaToGx/C2FWMyU1zUSGmOl0OLlucSanzkgEoNspjV6d9i4aWu20d3WzZk8nFWurcDglHfZuTpmRQOakiEGPqdFoAoNxFQgIMfIf3DPOOINVq1Zx9tlnc+2117Jx40aP7gY4FKoNTBmNb1LU0FebMeFWvrr1DJxSDnvBo8gQM/ERNmLCrSRHh3LM1GiEEKTEhJIcHUqCLZhgcxDr16+nsNB9Ge7S2mZe/8rYbGjvoQ4WZcVhDTKRHBNKfM9JPD0+nMgQM0lRIUSHDh7IeJq+7dx7fYiFGXGs/NXJRASbCQ82Yxmgvf73xU28uKGagmkxzJxso83ezfTECLq6JdNiwwgKElzxlLFJ1G9eObKxjDXIhL3bSUZ8ODVNHexv7uSqf64n0RZMbVNnv8cCYN2ROu5Zvp3Lj53GJQtSyU2yDVxmhEgp6XQ4abN3E2IxEWYd/f8f1f7vgXrOqvmCms5jxS+bDnmLwsJC2Xcns+Gyf/9+mpubycjIoKurC7PZPKrAQqNRifL9Lew60MbU2DBiwixEhVqOCsSyl76NvdtJUXosM5Iiaet1KyMlJpRgcxAJtmBCLUHERVgpusd9em5aXBjdUtLZ5SRjUjiPXVpAS4eDuuYOmjscHGq3s/dQB50OJ91OJ6W1LUQGmymuacYWaqasrgVLkHELpqHV7lb33ecZtz06urrp6pacPy95WIGnRjOeGOumQ+MqEMjLy5N9t7IdKVJKLr/8cpxOJ08++aRrhUJvUVJSElALHA2Far6gnX1Bf75pv34LgPzUaDq6nGzb19RfUTfMJoHo2ewqNTYMk4C0+HCaOxzkJkW6emWe+rxywDpSY8MIMgk6urqZEh3K3y8vJDb86LnhqrUxqOesmi+o6awDgV7k5+fLvvvHjxQpJffddx8333wzxx57LK+99hoJCQkeMjya9vZ2t33cAx3VfEE7+4Lh+K6vbOCnz3/JhQUpTIkOJUgIpsaG9RpXYR12V39rp4N3t9aQm2QjPDiIqFALx9z5PgDz02Jo7nC4jTe5/uQs8pKj+EbekRkpqrUxqOesmi+o6awDgV7MmDFDbt++3SN1vfTSS1x++eUkJCTw5ptvkpeX55F6+7J69WoWLjx6yd5ARTVf0M6+IBB9N1cf4txHPnd7b3JUCJMig7E7nEwJtvOPH582rLqcTsmh9i4aex61TR10OyVldS2YhLHJV7DZxNUnZhBs9t6UzkBs58FQzRfUdB5rIDDxRkUMkwsvvJC0tDTOPfdczjzzTHbs2EFw8NjnnGs0Gt8wJyWayvvOYsOug3xSup8/fbiDUEsQB1rstNodFLd18fpXeyira8FsMlFaa/Qg7Gtsp7Wzm5ZOYxxDt1My3OUefv9eqWtK6WULUzk+K55TZyQOOKBTowkEdCAwCIWFhaxdu5aKigqCg4ORUuoBhBqNYhRMi6FgWgw/Pz3b9V7mzcsB+Nn/feWW1xIkiA6zEhduJSbcwrzUaOwOJ7mTbXR2GYMkkRiDJC0m4iOCSbSF0NjexYLffsgJ0+Pp6nayuryBZ1ZX8czqKp66Yj4n53jv9qJGM1Z0IDAEKSkprt2oHnzwQSoqKvjjH/84IaeYaDTjhdW/OZWn3l7NOSfMIzrMQlx48Jimh4ZYgqi87yzX649L6qiob+WON7ZxxVPr+L9rFrIgPVZfSGgCknF1NvN21/2BAwd47LHHKCsr44UXXiA6OnroQkOQlZXlATPfoZovaGdfoJrvpMhgrjxlFvHxnlvjoDeLcxI4LsvJHW9sA+Dix1cDRu9ESU0zodYggoTgmR8WkZUw/OXNVWtn1XxBTeexMq5uXA216dBYuffee3niiSdYsWIFixYtory8fMx1tra2esDMd6jmC9rZF6jmC953tgSZWH/LaXy3aCpgrEy5v7mTY6ZGkxAZTE1TB/e/UzKiOlVrZ9V8QU3nsTKuZg14YvrgcPj444+54IILsFqtlJaWujYyGg2qTVVRzRe0sy9QzRf867xzfwunPvgJYGx8tfyG40kYxn4PqrWzar6gpvNYZw2Mqx4Bu90+dCYPsHjxYtasWcPvfve7MQUBAJWVlZ6R8hGq+YJ29gWq+YJ/nTMnRfDQd+YCUN/SyUMflHKw1U73ENMTVGtn1XxBTeexMq4Cge7uwTdW8STTp0/n+9//PgBvv/02t9xyy6huTTQ2Nnpazauo5gva2Reo5gv+dz5/XgovXGPMV39+7W7m3fU+mTcvp6lj4O3U/e08UlTzBTWdx8q4CgT8xfvvv88999zDd77zHdra2vyto9FoFGFBRhz3XziHrIQjOzXOuf091lc24Bzu4gUazRjRgYAHePDBB3nwwQd5+eWXOemkk9i3b5+/lTQajSL8v8KpfPDzkyi755uu9y786yrW7zroRyvNRGJcBQK+3D64N0IIfv7zn/P666+zfft2ioqKqKmpGVbZyMjhTx0KBFTzBe3sC1TzhcBzNgeZ2HDLaZw/LxmA9bsajsoTaM5DoZovqOk8VsbVrIGCggK5YcMGvzps2rSJ559/nnvvvXdYi4d0dnYqtXSxar6gnX2Bar4QuM6ryw+41h3YuOx0t50TA9V5IFTzBTWd9ayBXvhq1sBgzJ07l/vuuw8hBMXFxTz88MMMFmzt3bvXh3ZjRzVf0M6+QDVfCFznhRlxrucFd7/P7oY2WjodSCkD1nkgVPMFNZ3HyrgKBIKCvLfr12h44oknuPHGG7n66qsHDFKioqJ8bDU2VPMF7ewLVPOFwHY+PJtASjjh/o/Iu+1dfvXy5oB27g/VfEFN57EyrgKBzs5Ofyu4cf/993PLLbfw5JNPsmTJEhoajr7nV1pa6gez0aOaL2hnX6CaLwS284KMOFb+6mQAvlNorEz4n/XVvL9umz+1Rkwgt/FAqOg8VsbVXgOBhslk4q677iInJ4errrqKhQsX8sEHH5CamupvNY1GE+CkxIS5NjJat6uB8v2t/OqjRvYFlTI3JZpgi4lFmfF+ttSMB8ZVj0Cgctlll7FixQpmzpxJQoLejlSj0YyMl3+0yPX84Q92cMXT67jk72v4z/rdFNc0+dFMMx7waSAghIgVQrwqhGgVQuwSQlwyQL5gIcRDQoi9QoiDQojHhBAWX7p6muOOO47XXnuNkJAQDh48yPPPP+9vJY1Gowgx4VYq7zuLa+eF8+PFmSzKNAYU/vKlzZz1p5U0D7IaoUYzFL6+NfAoYAcSgWOAt4QQm6SUW/vk+zVQCOQBQcAbwC3AbYNVrspGEQ8//DB33nknGzZs4NZbb/W3zoiYPXu2vxVGjHb2Pqr5gprON5w9n/DwcDq6uvnJsxsJtphY/nUNdod3d14dLSq2sYrOY8VnPQJCiHDg28AyKWWLlHIl8F/ge/1kPwf4k5SyQUq5H/gTcOVQxwiE6YPDYdmyZVx//fU8+OCDnHfeebS0tPhbadhUV1f7W2HEaGfvo5ovqO0cYgniyR/MJz81BoBHPirjjje28sN/rmPxAx9x1p8+448f7PCnKqB2G08kfNkjkA10Syl7D8ncBJzUT17R8+j9OkUIESWldNsRQghxDXANQHJyMql26a4AACAASURBVKtXr+6dxoIFCygpKSEjI4O+iw2lp6fjcDiw2WzU1NRw4MABV1pYWBgzZ86ksrKShIQEtm1zH607c+ZM6urqSEtLY9u2bW57DMTFxZGUlERTUxNms5mKigq3sgUFBVx//fXk5OTws5/9jPz8fB544AESExNJSUnBarViNptpampyW6HQbDZTWFhISUkJqampbNq0ya3erKwsWltbSUhIoLKy0m3zjMjISLKysti7dy9RUVFHjYydPXs21dXV5OTksHHjRregKiEhgdjYWDo6OoiMjHRrY4CioiJ27NhBVlYW69atc0ubNm2aqz3r6+vZv3+/Ky0kJIQ5c+awY8cOkpOT2bJli1vZ3NxcGhoaSElJobS01C1giomJISUlhQMHDhAaGsrOnTvdys6bN4+Kigpyc3Npampyc548eTLh4eFIKWlvb3ebN2wymSgqKqK4uJiMjAz6bmudkZGB3W4nOjqaPXv2cPDgkWVgw8PDyc3Npaqqivj4eLZv3+5WdtasWdTU1JCRkcGWLVtob293pcXHx5OQkEBLSwsmk4mDBw+6ORcWFrJz505ycnKOav+pU6diNpuxWCw0NjZSW1vrSrNYLBQUFAz4ncnOzqapqYnExEQqKipoajpyv9lms5Genk5tbS02m+2o78zcuXOpqqoiJyeHlpYWN6/ExESioqLo6urC4XCwe/dut7ILFy6kpKSEzMxM1q9f75aWlpaG0+kkIiKCuro66uvrXWmhoaHk5eVRXl5OUlISW7e6dybOmDGD+vp6UlNTKS4udttbPiYmhuTkZA4dOoTVaj2qjfPz8ykvLyc3N5e1a9e6bSI2ZcoUQkNDEULQ2trqtox4UFAQ8+fPp7i4mPT0dL788ks3p8zMTNrb24mLi6O6utrtOxMREUF2djbV1dXExsZSXFzsVjYvL489e/Ywffp0Nm/eTEdHh8t50qRJrNlp/H966vPKI58zRFB5QLJ1bxMzIzs4df4s1q5d61ZvamoqJpOJkJAQGhoaqKurc6VZrVby8/MpKSkhJSWFr7/+2q1sdnY2jY2NTJkyhbKyMpqbm11pUVFRpKWlUVdXR3h4+FFt3Ps7s379ehwOhystKSkJm82Gw+HAbre7nZB9/Vt+2Hk4v+Xl5eXk5OSwZs0atzVj/PVbPhp8trKgEOIE4EUpZVKv964GLpVSLu6T927gZOA8jFsDrwNFwBQp5YAL+c+cOVP2/SMHOo888gh//etfef/995k8ebK/dYZk48aN5Ofn+1tjRGhn76OaL4wP53Z7N698Wc2C9DhSYkIJsRhrqSz47QfUNnUSZBL859pjqahvxe5wkp0YQWFarN98VUBF57GuLOjLHoEWwNbnPRvQ3E/ee4Bo4CugE/g7MA+o6yevCxWXSy4sLGTTpk0EBQXhcDhYuXIlixcv9rfWgKhy+6U32tn7qOYL48M51BrEpQumHZXv41+czIxb36HbKfn2X75wS9t8+xnYQnwz9no8tPFEwJezBkoBsxBieq/35gJ9BwoipWyXUl4vpUyWUmYAB4ANUspuH7n6lMMrIj766KOcfPLJ3H333UoGNRqNJjAItQbxyf8uZtYUG/ddMJvnfrjAlfavLyr9J6YJSHzWIyClbBVCvALcKYT4IcasgW8Bi/rmFUIkAxLYBywAlgFX+crVX/zoRz9i/fr1LFu2jJKSEp544gnlNr/QaDSBwbS4cN664QTX6y+Xnc68u96nM0BnGGj8h68XFLoOCMXo4n8e+LGUcqsQIlUI0SKEOLzkXibwBdAK/BP4tZTyvaEqN5vVWyix9wJDwcHB/Otf/+Luu+/mmWee4dRTT3UbXBcIqLggknb2Pqr5wsRzjunZxfDPK8pwOn3T4zjR2lhVfBoI9EwHPE9KGS6lTJVSPtfzfpWUMkJKWdXz+lMpZZqUMkxKmSOlfHY49asYCMTGug/cEUKwdOlSXnzxRbZv386uXbv8ZNY/fX1VQDt7H9V8YWI7X/Pv9exrbB864xiZyG2sEuNqieHe031UoaOjo9/3L7zwQiorKyksNAaCBspGGAP5BjLa2fuo5gsT0/m2c2YC8MH2Oo69dwWf7fBuj+NEbGMVGVeBgIoMFrxERkYC8NJLLzFz5kweeeQRX2kNiIrBlnb2Pqr5wsR0vuK4dLbcscT1+vFPy8eqNCgTsY1VZFwFAipO+6iqqhoyz5IlSzjzzDP56U9/yvXXX++2CIevGY5voKGdvY9qvjBxnSOCza5dDT/bUc+XVQeHKDF6Jmobq8a4CgTGK5GRkbz66qvcdNNNPProo5x99tluK01pNBrNSDln7hQAdh/0/lgBTWCjAwFFCAoK4ve//z2PP/44K1asYMWKFf5W0mg0CnNJkTFJ64bnv+Rvn+wcIrdmPKMDAcW4+uqrKS0t5fzzzwdwW7dco9FohkthWozr+b1vF/PqlxNvsx2Ngc/2GvAFhYWFsu8GJoGO0+nEZBpdPLZ69WqWLFnCY489xqWXXuphs/4Zi6+/0M7eRzVf0M6HSfv1W67nf/teAU6nZHFOAqHWoDHXrdvYN4x1rwG1Pu0QqDjtY8eO0W8VOn36dPLz87nssstYtmyZT0a7jsXXX2hn76OaL2jnwxweOAhw7b838ONnNzLj1nd48L2SMdet21gNdI+An+nu7nbtNTAa7HY7P/7xj/nHP/7BRRddxNNPP01YWJgHDd0Zq68/0M7eRzVf0M69+ai4jsc/Lee6kzP53pNHtiy+49xZfH9R2qjr1W3sG3SPQC967z2uCuvWrRtTeavVyhNPPMEDDzzASy+9xJNPPukhs/4Zq68/0M7eRzVf0M69OTk3geevWcgJ0ye59RD8/t2x9QroNlaDcRUITFSEEPziF7/g888/5yc/+QmAX9ca0Gg0alN531lceVy6vzU0PkIHAuOIY489FpPJxO7du5kxYwZvvPGGv5U0Go2iOKWkudPhsw2KNP5DBwLjELPZTHR0NN/61rf4wx/+wHgaB6LRaHzDv1cbG55l3Lyc5o4uP9tovMm4CgSsVqu/FUbMtGnTPF7n5MmT+eSTT/j2t7/NTTfdxLXXXktXl2f+I3vD19toZ++jmi9o56F4/SfHuZ6/u7V2VHXoNlaDcRUIaI4QFhbGCy+8wNKlS/n73//OXXfd5W8ljUajEHnJUdxzfh4Av3hxE/UtnX420niLcRUIqLYIBODVqX4mk4m7776bV155hV/84hceqdObvt5CO3sf1XxBOw+Hw8sQAxTe/QHt9u4RlddtrAbqnTkHQcWR8vX19V4/xvnnn4/NZqOtrY0lS5bw8ccfj7ouX/h6Gu3sfVTzBe08HIQQbL/zG67XlzyxekTldRurgQ4E/Mz+/ft9dqyGhgZ2797N6aefPur1Bnzp6ym0s/dRzRe083AJtQbx1a2nA2ANGtkpQ7exGoyrQEAzOCkpKXzxxRecfPLJ/PCHP+SXv/wl3d0j6+rTaDQTj+gwKwmRwaypaBjx7QFN4KMDgQlGdHQ0y5cv57rrruOBBx7w2NgBjUYzvqlrNgYLzrj1Hf76yU49LXkcMa4CASGEvxVGTEhIiM+PaTabefTRR/nLX/7C9ddfP6Ky/vAdK9rZ+6jmC9p5pCy/4QTX8/veLmZtRcOQZXQbq4HedMjPBMKWl1JKbrzxRi677DIKCwfftyIQfEeKdvY+qvmCdh4tj35UxgPvlvCPHxRySm7ioHkDwXekqOisNx3qxUTbhthT1NbW8vrrr3PiiSfy0ksvDZo3EHxHinb2Pqr5gnYeLQvSYwG45dUtrK8cvFcgEHxHiorOY2VcBQIqriyYnJzsbwWSkpJYs2YNxxxzDBdddBG//e1vB7z/Fwi+I0U7ex/VfEE7j5ZQq7FF797GDi786yp27m8ZMG8g+I4UFZ3HyrgKBNrb2/2tMGK2bNnibwUAEhISWLFiBZdccglLly7lhhtu6DdfoPiOBO3sfVTzBe08WmZNieKd/zmBeanRAIPOIggE35GiovNYMftbQBM4hISE8Mwzz5Cbm8uiRYv8raPRaAKU3CQb1y3O4up/qTUmS9M/46pHQDN2hBAsW7aMU089FYDHH3+c7du3+9lKo9EEGnsPGT2wZ/95JQ2tdj/baMaCTwMBIUSsEOJVIUSrEGKXEOKSAfIJIcTdQog9QohGIcTHQohZvnTVQFNTE7fffjvHHnss77//vr91NBpNAHHM1GjX8/y73mfJQ5+ydW+jH400o8XXPQKPAnYgEbgU+MsAJ/iLgCuBE4BYYBXw76EqV3H+Z25urr8VBsRms7F69WqmTZvGN7/5Tf7yl78EtO9AaGfvo5ovaOexMndqNJtvP8P1uqS2mbP+tNJtl8JA8h0uKjqPFZ8FAkKIcODbwDIpZYuUciXwX+B7/WRPB1ZKKcullN3AM8DMoY6h4l4DDQ1DL8rhT1JTU1m5ciXf/OY3ue6667jpppv8rTRiAr2N+0M1Z9V8QTt7AluIhcr7zmLDLae53nvgnRLX80DzHQ4qOo8VXw4WzAa6pZSlvd7bBJzUT97/A74jhMgGKoDvA+/0V6kQ4hrgGoApU6awevXq3mksWLCAkpISMjIy2LBhg1vZ9PR0HA4HNpuNmpoaDhw44EoLCwtj5syZVFZWkpCQwLZt29zKzpw5k7q6OtLS0ti2bRttbW2utLi4OJKSkmhqasJsNlNRUeFWtqCggPLycnJycqitraWurs6VlpKSgtVqxWw209TURE1NjSvNbDZTWFhISUkJqampbNq0ya3erKwsWltbSUhIoLKyksbGI910kZGRZGVlsXfvXqKioigtLXUrO3v2bKqrq8nJyWHjxo3Y7Ufu+SUkJPD000+zdOnSo9oYoKioiB07dpCVlcW6devc0qZNm+Zqz/r6ercNPUJCQpgzZw47duwgOTn5qNG6ubm5NDQ0kJKSQmlpKS0tR6YpxcTEkJKSwoEDBwgNDWXnzp1uZefNm0dFRQW5ubns37/frY0nT55MeHg4Ukra29vZu3evK81kMlFUVERxcTEZGRls3LjRrd6MjAzsdjvR0dHs2bOHgwcPutLCw8PJzc2lqqqK+Pj4o8ZWzJo1i5qaGjIyMtiyZYvbLJf4+HgSEhJoaWnBZDJRU1Pj5lxYWMjOnTvJyck5qv2nTp2K2WzGYrHQ2NhIbW2tK81isVBQUDDgdyY7O5umpiYSExOpqKigqanJlWaz2UhPT6e2thabzXbUd2bu3LlUVVWRk5PDgQMH3HwTExOJioqiq6sLh8PB7t273couXLiQkpISMjMz6bsIWFpaGk6nk4iICOrq6tx2gwsNDSUvL4/y8nKSkpLYunWrW9kZM2ZQX19PamoqxcXFtLa2utJiYmJITk7m0KFDWK3Wo9o4Pz+f8vJycnNzWbt2LU6n05U2ZcoUQkNDEULQ2trKvn37XGlBQUHMnz+f4uJi0tPT+fLLL92cMjMzaW9vJy4ujurqarfvTEREBNnZ2VRXVxMbG0txcbFb2by8PPbs2cP06dPZvHkzbW1tLudJkyYRHx/v+u3ZtWuXW9n58+dTVlbG9OnTWbt2rVtaamoqJpOJkJAQGhoa3NrBarWSn59PSUkJKSkpfP31125ls7OzaWxsZMqUKZSVldHc3AzAk2fGcNXyg7ywfjdFk4M4KSfxqDbu/Z1Zv36928VbUlISNpsNh8OB3W6nurralebL3/KWlhaX80h+y9esWeM27dpfv+WjwWcrCwohTgBelFIm9XrvauBSKeXiPnmtwAPADUA3sBs4RUrp/lfow6xZs2TfH4ZAZ8uWLeTl5flbY9gc9v3www/JzMwkLS3N30pDolobg3rOqvmCdvYGab9+y/X8tnNmMj+qNaB9+yPQ27g/VFpZsAWw9XnPBjT3k/c2YD4wFQgB7gBWCCHCBjtA7wheFXpf5apAS0sLnZ2dXHHFFRQVFbFq1Sp/Kw2Jam0M6jmr5gva2Rs8c9UCLj/W6AXce6g94H37Q0XnseLLQKAUMAshpvd6by7Q3yX8XOAFKWW1lNIhpXwaiGEY4wQ03ic4OJj33nsPm83GySefzHPPPedvJY1GEwAcPz2eO79lXE2X728dIrcmUPBZICClbAVeAe4UQoQLIY4DvkX/swHWARcJIRKFECYhxPcAC1DmK1/N4OTm5rJmzRoWLFjApZdeyu233663JdVoNC4+LK7j3i+ahs6o8Tu+nj54HRAK1AHPAz+WUm4VQqQKIVqEEKk9+X6HMZDwK+AQcCPwbSnlocEqDwoK8p65l4iJifG3wojo7RsXF8f777/PFVdcwZ49e/xoNTiqtTGo56yaL2hnb3LlcekAbKrrYslDn3Ltv9dTfbBtiFKBgSpt7EnG1TbE+fn5su8o70CntbWV8PBwf2sMm/58pZR0d3djNpspLS3FZrORlJQ0QA2+R7U2BvWcVfMF7exteg8cPMxTV8zn5JwEP9gMH5Xa+DAqDRb0OiquI9B7mosK9OcrhMBsNuN0OrnwwgspKipi8+bNfrDrH9XaGNRzVs0XtLO3Wf2bU/nzeRmU3fNN13tXPLWOls7A/p1WqY09xbgKBEwm9T5OaGiovxVGxGC+JpOJp59+mu7ubo477jjefPNNH5oNjGptDOo5q+YL2tnbJEWFsDAzHnOQicr7znK9n3fbu1z77/V0dA28a6E/UamNPYV6Z85B6OzsHDpTgNF3IZxAZyjf/Px81q5dS3Z2Nueeey4PPfSQ3wcRqtbGoJ6zar6gnX1Bb98vl53uev7u1loefK+kvyJ+R7U29gTjKhDQBAbJycl8+umnnH/++bz88stK3rLRaDSeJSbcSuV9Z/HXy/IBeHPzviFKaHyFL5cY1kwgwsPDefHFF2lpacFisdDQ0IAQYkKOyNVoNEf4Rt5kTs1NoLa5w98qmh50j4DGa5hMJmw2YzHJSy+9lGOPPZayMr0UhEYz0alvtbNlTxOdjsAcJzDRGFfTBwsKCmTfzSgCnc7OToKDg/2tMWxG6/vpp59ywQUXIKXklVde4aST+ttryjuo1sagnrNqvqCdfcFAvoenFt57wWy+W5R6VLo/Ua2NQU8fdEPFwYJ9d7MKdEbre+KJJ7JmzRoSEhI4/fTTeeqppzxsNjCqtTGo56yaL2hnXzCQ7wvXLATgw+11NLZ3+VJpSFRrY08wrnoECgsLZd8tTTWBxaFDh7jooosoLS1l69atRERE+FtJo9H4mMa2Lube+R4AZ85O4rFLC/xspDa6R6AXvfceV4V169b5W2FEjNU3Ojqa5cuX8+mnnxIREYHD4fD63021Ngb1nFXzBe3sCwbyjQqzcNqMRACWf13Djtr+NqH1D6q1sScYV4GAinR3qzVYxhO+FouFadOMrUp//vOfc8IJJ3h1rwLV2hjUc1bNF7SzLxjM94nvFxJsNk5By17fwp1vbOOjkjpfqQ2Iam3sCXQgoPErS5YsYceOHRQVFaHaQE+NRjM2nvnhAgBWlzfwj88ruOKpdbyxaa/fFyGbaOhAQONXzjrrLL744gvMZjMnnngir776qr+VNBqNjyicFsMxU6NdiwwB/PT5L0n/zXKe+nziDdrzF+MqELBYLP5WGDGTJ0/2t8KI8Ibv7NmzWbt2LXPmzOF73/se+/fv92j9qrUxqOesmi9oZ18wlK8Qgtd+chzfyJtMxb1ncuNp2a60O97Y5pcNilRrY08wrgIBFTcdUm27S2/5JiYm8tFHH/HBBx8wadIkwHP36lRrY1DPWTVf0M6+YCS+Qgh+dtp0Nt16Bj9YlAbgl1sEqrWxJ1DvzDnOUO1emDd9Q0JCWLjQmF/8+OOPc8opp1BfXz/melVrY1DPWTVf0M6+YDS+UWEWUmL8twOgam3sCcZVIOB0Ov2tMGLa29v9rTAifOVrs9lYs2YNCxcupLi4eEx1qdbGoJ6zar6gnX3BaH03VzcCUHTPhz5fcEi1NvYE4yoQ6OoKrBWqhsPevXv9rTAifOV78cUX8/HHH9Pc3MzChQv54IMPRl2Xam0M6jmr5gva2ReM1rcwzdicrL2rm3e31Pj0Kl21NvYE4yoQ0IwvFi5cyNq1a5k6dSrf/OY3KS8v97eSRqPxAZcfm8b/9SxD/MuXN/PICr1ZmTfR2xBrAppp06bx+eefs3z5cjIyMvyto9FofMQxU6Ndz/c26i2LvYnuEfAzqs108IevzWbj4osvBuCzzz7j/PPPp6mpadjlVWtjUM9ZNV/Qzr5gLL4hliAq7zuLSZG+3QlQtTb2BHrTIY1SPP300/zwhz9kxowZvPnmm66lijUazfjk8JbFG245jbgItbYH9hV606FedHSo13001hHxvsbfvj/4wQ9455132L17N0VFRaxevXrIMv52Hg2qOavmC9rZF3jS941NvhnEp1obe4Jx1SNQUFAgVVuv3m63Y7Va/a0xbALFt7i4mLPOOos9e/awevVqjjnmmAHzBorzSFDNWTVf0M6+wBO+z67ZxdJXtwBw3wWzubgo1RNqA6JaG4PuEXCjra3N3wojZuPGjf5WGBGB4pubm8uaNWtYunQpc+bMGTRvoDiPBNWcVfMF7ewLPOF7SVEq0+LCAPi4xLPLj/eHam3sCcZVIKCZWMTHx7Ns2TJMJhO7du3iJz/5yYRcDESjGc8IIfjkf08G4J2tNeTd9i5fVh30s9X4QgcCmnHBhx9+yGOPPcYpp5xCbW2tv3U0Go2HKUqLBaCl08HWvcOfNaQZGh0IaMYFV155JS+//DKbNm2iqKiIr7/+2t9KGo3Gg/znR8eydump/tYYl/g0EBBCxAohXhVCtAohdgkhLhkg31+FEC29Hp1CiOah6g8OVm9qiWqL5ASy7wUXXMBnn32Gw+Fg0aJFrhkFgew8EKo5q+YL2tkXqOYLajqPFV/3CDwK2IFE4FLgL0KIWX0zSSl/JKWMOPwAngdeHKpyFTcdstvt/lYYEYHuW1BQwNq1a7ngggvIy8sDAt+5P1RzVs0XtLMvUM0X1HQeKz4LBIQQ4cC3gWVSyhYp5Urgv8D3hlnun0Mdw2xWb8Xk6OjooTMFECr4Jicn889//pOIiAhaW1t54oknlNuQSoV27o1qvqCdfYFqvqCm81jx5ZkzG+iWUpb2em8TcNIQ5b4N7Ac+7S9RCHENcA1AUlKS2wIzQggWLFhASUkJGRkZ9F1jID09HYfDgc1mo6amhgMHDrjSwsLCmDlzJpWVlSQkJLBt2za3sjNnzqSuro60tDS2bdvmNnUxLi6OpKQkmpqaMJvNVFRUuJUtKCigvLycnJwc1qxZQ3h4uCstJSUFq9WK2WymqamJmpoaV5rZbKawsJCSkhJSU1PZtGmTW71ZWVm0traSkJBAZWUljY2NrrTIyEiysrLYu3cvUVFRlJaWupWdPXs21dXV5OTksHHjRreoOCEhgdjYWDo6Oti9ezfd3d1uZYuKitixYwdZWVmsW7fOLe3wyn9hYWHU19ezf/+R6T8hISHMmTOHHTt2kJyczJYtW9zK5ubm0tDQQEpKCqWlpbS0tLjSYmJiSElJ4cCBA4SGhrJz5063svPmzaOiooINGzZwxx138Pbbb3P33XcTGRnJ5MmTCQ8PR0pJe3u7225jJpOJoqIiiouLycjIOGoqUUZGBna7nejoaPbs2cPBg0dGL4eHh5Obm0tVVRXx8fFs377dreysWbOoqakhIyODLVu2uM1wiI+PJyEhgZaWFkwmE1u2bCEiIsKVXlhYyM6dO8nJyTlqEaWpU6diNpuxWCw0Nja6DZa0WCwUFBQM+J3Jzs6mqamJxMREKioq3JZuttlspKenU1tbi81mO+o7M3fuXKqqqsjJyWHdunWEhh7ZQz4xMZGoqCi6urpwOBzs3r3brezChQspKSkhMzOTvquBpqWl4XQ6iYiIoK6ujvr6eldaaGgoeXl5lJeXk5SUxNatW93Kzpgxg/r6elJTUykuLqa1tdWVFhMTQ3JyMocOHcJqtbJ582a3Ns7Pz6e8vJzc3FzWrl3r1sM4ZcoUQkNDEULQ2trKvn37XGlBQUHMnz+f4uJi0tPT+fLLL92cMjMzaW9vJy4ujurqarfvTEREBNnZ2VRXVxMbG3vUYjZ5eXns2bOH6dOns3nzZurr613OkyZNIj4+3vXbs2vXLrey8+fPp6ysjOnTp7N27Vq3tNTUVEwmEyEhITQ0NFBXV+dKs1qt5OfnU1JSQkpKylHjbbKzs2lsbGTKlCmUlZXR3Hzkrm1UVBRpaWnU1dURHh7OV1995dbGvb8z69evx+FwuNKSkpKw2Ww4HA7sdjvV1dWutMO/5TvLjP/nD7y9lUmde4gKNq5lPflbXldX53Ie6W9573V5/PVbPiqklD55ACcANX3euxr4eIhyHwK3D+cYubm5UjVWrVrlb4URoZqvlFIuXbpUWiwWmZubK8vKyvytMyxUa2fVfKXUzr7A0777mzvktF+96Xq8urHao/VLqV4bSyklsF6O4fzsyzECLYCtz3s2YMBBgEKIqRg9Bv/yopdmnHP22Wfz/vvvU1dXx4IFC1i1apW/lTQazSiIjwjmz9+d53r9Py985Ueb8YMvA4FSwCyEmN7rvbnA1gHyA1wOfCGl1BvRa8bESSedxOrVq5kxYwZJSUn+1tFoNKPknLlTqLzvLAAsQcLPNuMDnwUCUspW4BXgTiFEuBDiOOBbwL8HKXY58PRwj6Hi9pG9xweogGq+cMR5+vTpfPrpp6Snp+N0OnnuuecCdqaJau2smi9oZ1/gTd+rjk8n2Bzk8XpVa2NP4Osz53VAKFCHMSXwx1LKrUKI1J71Aly7SQghjgVSGMa0wcOEhIR42tfr5Obm+lthRKjmC+7OQhhXEG+++SaXXnopF110kduAskBBtXZWzRe0sy/wpu9722po6XQwY9k7tNkdQxcYJqq1sSfwaSAgpWyQUp4npQyXUqZKKZ/reb9KGmsGVPXKua2x1QAAIABJREFUu6on35ALCR1GxfmfVVVVQ2cKIFTzhf6dzznnHP7whz/w6quvctJJJ7nNHAgEVGtn1XxBO/sCb/qePWcKAO1d3fz3K8/9/1WtjT2Ben3pg6DiOgLx8fH+VhgRqvlC/85CCG688UZef/11SkpKKCoqCqhdx1RrZ9V8QTv7Am/6/uobudx1nrFo2K9f+Zq/f1ruNn1vtKjWxp5gXAUCHR0d/lYYMX3nmgc6qvnC4M7nnHMOn3/+OSEhIW5z6P2Nau2smi9oZ1/gbd/LFqQSHWYB4J7l20n/zXI6urqHKDU4qrWxJxhXgYBGMxrmzJnD9u3bWbx4MQCrVq3yyJWFRqPxLkIIvrr1DM6Ymeh6750tNYOU0PSHDgQ0GowV+AC++OILFi1axFVXXaXkmBONZiLy+OWFPHXFfIAx9whMRHQgoNH04thjj+W2227jqaee4owzznBbqlSj0QQuaXHGtL9fv/I1f/1k5xC5Nb0R46kLND8/XwbSgK/h0NzcTGRkpL81ho1qvjA65+eee44rr7ySlJQU3nrrLXJycrxk1z+qtbNqvqCdfYEvfbudksybl7u9Fxdu5fx5ydxy9sxh16NaGwMIITZIKQtHW35c9QiotsMc4LYRhQqo5gujc77kkktYsWIFTU1NfPLJJ16wGhzV2lk1X9DOvsCXvkEmQeV9Z3HeMVNc7x1otfPEygo+3F47SEl3VGtjTzCuegQKCwtl353MAp3u7m6Cgjy/Opa3UM0Xxubc0NBAbGwsYMwvTk1NHaKEZ1CtnVXzBe3sC/ztm3nzcrqdxjlu061nENUzw2Aw/O08GnSPQC96b+uqCn233g10VPOFsTkfDgJKSkqYOXMmN91001HbMHsD1dpZNV/Qzr7A3747f3smibZgwFh4aDj429kfjKtAIFDXjR8M1YIX1XzBM86ZmZlcddVV/OEPf+C8885z24PdG6jWzqr5gnb2BYHg+z+nZY8ofyA4+5pxFQhoNN7CbDbzxz/+kUcffZS3336b448/fkIuRarRqEZVQxsAb24OrGXEAwkdCGg0I+C6667jrbfeorKykkcffdTfOhqNZgjiI4xbA//dpAOBgVBvcf5B0HsNeB/VfMHzzkuWLGHDhg1MmzYNgJaWFiIiIjx6DNXaWTVf0M6+IBB8rzo+nXe31BBkEsPKHwjOvmZc9QioGAgkJCT4W2FEqOYL3nHOysrCYrGwf/9+5syZw1133eXRZYlVa2fVfEE7+wLVfEFN57EyrgIBFQcLtrS0+FthRKjmC951ttlsHH/88dx6661cdtllHtv4SrV2Vs0XtLMvUM0X1HQeK+pdQo8zTCa1YjHVfMG7zsHBwfzzn/8kNzeXpUuXUlFRwWuvvTbmqwrV2lk1X9DOvkA1X1DTeayMq0+s4iYxlZWV/lYYEar5gvedhRDcfPPNvPjii3z11VfcdNNNY65TtXZWzRe0sy9QzRfUdB4rukdAo/EQF154Ienp6aSlpQHGraqJeHWh0WjUQv9KaTQepKCggLi4OOx2O6effjqPPPKIv5U0Go1mUHQgoNF4ga6uLiIjI/npT3/K9ddfj8Ph8LeSRjNhWVvZwKryA9S3dPpbJSAZV5sOFRQUyA0bNvhbY0Q4HA6lpj2q5gv+c/7/7J15WFTX3fg/BwYEQVBAQEBkZ1DiAggao41tlqZJE02a2uxpmvhm+yVvk2Zp0ixNmzb65k3SJU3SpnnTrDW2MYvNYhZNYlSIS1xQdhBBAREFQZDt/P5AR0ZAGJi5d854Ps8zzzPcc869Hw6XO9+595zv6e7u5pe//CVLly7lvPPO46233iI4OHhIbVXrZ9V8QTsbgbv4xt3/HwCevHwaP8qMOWVdd3F2BL3oUC+OHlUv2istLTVbwSFU8wXznL28vFiyZAkvvvgin3/+OVdcccWQ26rWz6r5gnY2Anfx/ere+QBDyvXhLs5G4lF3BFRchlhzerBmzRrCwsJIT083W0WjOe3Y03CEuUtX8z8/msrlWRPN1nE6+o5AL1paWsxWcJgNGzaYreAQqvmCezifffbZpKenI6Xkzjvv5JVXXjllfXdwdgTVfEE7G4FqvqCm80jxqEBAo3F3jh49yvbt27nuuuv41a9+pWQ2TI1GVe751za+++QafvbyN3R06f+94+hAQKMxED8/Pz7++GNuvPFGHn/8cRYtWsSRI0fM1tJoPBqL94kFh8rqW/isoI7n1px+YwEGQq2hkRqNB+Dj48Nf//pX0tLS+MUvfkF9fT2ff/45QgxtdTSNRuMYE4L9KfjN96k+1EpTawcL/7KOptYOs7XcBo8KBHx9fc1WcJiJE9UauKKaL7insxCCu+66i+TkZKSUfYIAd3Q+Far5gnY2Anfy9fPxJnF8z3LhAb7eA9ZzJ2ejMPTRgBAiRAixQgjRIoTYLYS48hR1E4QQK4UQh4UQ9UKIpUa6GoVq81VV8wX3dv7hD3/IxRdfDMCLL77Iu+++C7i3c3+o5gva2Qjc1belvYsX15az/3DfKefu6uxKjB4j8CzQDkQAVwHPCSGmnFxJCOELfAJ8DkQCMcBrg+1cxVurPj4+Zis4hGq+oIZzV1cXL730EgsXLuTJJ59U7mKkQh+fjHZ2Pe7ue8mf1/bZ5u7OrsCwQEAIEQBcBjwkpWyWUq4F3gOu6af69cBeKeVTUsoWKWWblHLbYMfo6upyqrMRNDY2mq3gEKr5ghrO3t7efPrpp1x22WXcc8893HrrrUqtpqlCH5+MdnY97uqb+8D3gJ7HBSfjrs6uxMivHSlAl5SyqNe2rcB3+qk7C6gQQnwIzAR2AP9PSrn95IpCiMXAYoCIiAi7OaBCCHJycigsLCQhIYGT0w/Hx8fT2dlJUFAQNTU1HDhwwFY2evRoJk+eTEVFBeHh4ezcudOu7eTJk6mrqyMuLo6dO3fajfwODQ0lMjKSpqYmLBYL5eXldm0zMzMpKysjNTWVwsJCamtrbWUxMTH4+vpisVhoamqipqbGVmaxWMjKyqKwsJDY2Fi2bt1qt9+kpCRaWloIDw+noqLC7oQeM2YMSUlJ7N27l+DgYIqKiuzannHGGVRVVZGamsrmzZvtPoTCw8MJCQmhra2N3bt32/kCZGdnU1xcTFJSEt98841d2aRJk2z9WV9fz/79+21lfn5+TJ06leLiYqKjo9mxY4ddW6vVSkNDAzExMRQVFdHc3GwrGzduHDExMRw4cAB/f/8+2cBmzJhBeXk5Vqu1Tx9PmDCBgIAApJS0trayd+9eW5mXlxfZ2dkUFBSQkJDA5s2b7fabkJBAe3s7Y8eOpbq6moMHD9rKAgICsFqtVFZWEhYWxq5du+zaTpkyhZqaGhISEtixYwetra22srCwMMLDw3n66aeJiYnhmWeeobS0lGeeecb2dy8tLSU1NbXPPOeJEydisVjw8fGhsbHR7nf18fEhMzNzwHMmJSWFpqYmIiIiKC8vp6mpyVYWFBREfHw8tbW1BAUF9Tlnpk2bRmVlJampqRQVFdkdNyIiguDgYDo6Oujs7GTPnj12bWfNmkVhYSGJiYmcnAQsLi6O7u5uAgMDqauro76+3lbm7+9Peno6ZWVlREZGkp+fb9c2LS2N+vp6YmNjKSgosMstMm7cOKKjozl06BC+vr4UFBTYOWdkZFBWVobVaiUvL89uamdUVBT+/v4IIWhpaWHfvn22Mm9vb2bOnElBQQHx8fFs2bLFzikxMZHW1lZCQ0OpqqqyO2cCAwNJSUmhqqqKkJAQCgoK7Nqmp6dTXV1NcnIy27ZtY9++fTbn8ePHExYWZrv27N69267tzJkzKSkpITk5mby8PLuy2NhYvLy88PPzo6Ghgbq6OluZr68vGRkZFBYWEhMTw/bt9pfdlJQUGhsbiYqKoqSkhMOHD9vKgoODiYuLo66ujoCAgD593Puc2bhxo90aHJGRkQQFBdHZ2Ul7eztVVVW2Mldcy2dO8KW2pY2mpia7a3l1dbXN2ZFreW5url3mQrOu5cNCSmnIC5gL1Jy07SZgTT91VwEdwAWAL3APUAb4nuoYVqtVqsb69evNVnAI1XylVNP5kUcekU888YTZGkNGxT7Wzq7HnX0n3bdSTrpvpVxTWGe33Z2dBwLYKEfw+WzkGIFmIOikbUHA4X7qtgJrpZQfSinbgSeBUCDNtYoajXvw/e9/n/vuuw+AL774gtWrV5tspNF4FhdPiwLgupfy6DzNkwsZGQgUARYhRHKvbdOA/H7qbgMcXgRBDxZ0Par5gtrOUkoefvhhzjvvPF588UWTrQZG5T5WCdWc3dn36UXTbe8PHjmRU8CdnV2FoYsOCSH+Sc8H/I3AdOAD4EwpZf5J9VKBLcDFwGrgDuB2IO3YHYJ+0YsOaTyRxsZGFi1axMcff8zdd9/NkiVL8PYeeB60RqMZGq9u2M1D7+zgmwfPYfyYUWbrDBvVFh26FfAH6oA3gVuklPlCiFghRLMQIhZASlkIXA08DxwELgEuPlUQANDW1uZSeVdQWFhotoJDqOYL6jsHBwezcuVKbrvtNv73f/+XhQsX2g00dAdU72NVUM1ZNV9Q03mkGDpZWUrZACzoZ3slEHjStreBtx3Zv4qZBWNjY81WcAjVfMEznC0WC3/+85+xWq1s2LABPz8/k8z6xxP6WAVUc1bNF9R0HiketeiQu31LGgonTxtxd1TzBc9yvv3223n11VcRQlBeXt5nuqZZeFIfuzOqObu7b351z7S8l9edmBbo7s6uwKMCAY3mdOD4oNg77riDefPmsXz5cpONNBo1yUkIAeCb8oOD1PRsHA4EhBA5QogHhBDPCCH+2PvlCkGNRtM/L730EhkZGfz4xz/m8ccfx8iBvxqNJ7BwRgwAeRUNPLCiT7660waHAgEhxC+A9fSkAJ4OnNHrle5sOY1GMzDjx4/ns88+4+qrr+ZXv/oV1157LUeP9l1ERaPRDMyM2LEAvJFbyQfb9w1S2zNx9I7AncAdUsoUKeXZUsr5vV7fdYWgI4wapd70j5SUFLMVHEI1X/BsZz8/P1555RV++9vfsmvXLruUrUbiyX3sTqjmrILvilvncOmMaABufX0zXuNiTDYyHkcDgSB65v67Jb1zg6tC79zuKqCaL3i+sxCCBx98kK+//pqAgACam5v75Kx3NZ7ex+6Cas6q+D61aDqJ4wMAWFtUO0htz8PRQOBN4PuuEHEGqi3dCj2Ls6iEar5w+jgfvyN25513kpOTw8cff+xsrQE5XfrYbFRzVsn3rnNTAfjj1zWD1PQ8HA0E9gC/FkK8LoS4TwhxV++XKwQdQaVlW49z8mpW7o5qvnD6OT/yyCPExcXxgx/8gGeffdaJVgNzuvWxWajmrJLvhVMnABA06vSbTOfoV+gb6Vk86Mxjr95I4ClnSA2Xrq4uMw8/LFS5dXYc1Xzh9HOOjY1l7dq1XHXVVdx+++0UFBTw9NNPu/SO2enWx2ahmrNqvldkx/Lh1j2DV/QwHAp9pJTxp3gluEpSo9E4xpgxY1ixYgV33303b731lt2a8BqNRtObYd8DEUIECiECnCmj0Wich7e3N08++SQ7duwgOjqa7u5u9u07PadHaTSagRlOQqHbhBCVQCPQJITYLYS41flqjqPiimxBQUFmKziEar6gncePHw/A448/zrRp01i3bp3T9n2c072PjUI1Z9V8VxfUceioZH3pAbNVDMXRhEIPAE8AfwfOO/b6P+AJIcT9ztdzDBUXHYqPjzdbwSFU8wXtfJxFixYRHBzM/Pnzef311526b93HxqCas2q+k6N6Apc1RXUmmxiLo3cEbgYWSyl/LaX87NjrUeCWYy9TMSuZykhQ7dmtar6gnY+TkpLChg0bmD17NldffTUPPfSQ03Jv6D42BtWcVfN96fqZ+HoLszUMx9FAIBzob7mzPMD0CaNeXupN+1Dt1plqvqCdexMaGsqqVau44YYbWLJkCTt37nTKfnUfG4Nqzqr5ArR3SV74ooyu7tNn7Q5HPzmLgCv72X4lUDhynZGhYp71oqIisxUcQjVf0M4n4+vry4svvsjmzZtJT+9ZIuTIkSMj2qfuY2NQzVk1396U7W82W8EwHA0EHgUeFkJ8KoT4tRDiUSHEp8CvgEecbqfRaFyCEMIWBLz11lukpaWdluuwazQnc8Xk0QA8/am6QYyjOJpH4G0gB6gBLgIuPvY+W0r5jvP1NBqNq0lOTqarq4s5c+bw/vvvm62j0ZhKSkhP4q0PttdQXHvYZBtjcPihupRyk5TyaillppQy49j7La6Q02g0rmfGjBnk5eWRlpbGJZdcwlNPPYWUp8/zUY2mN2lhPrb35z79JS9+VWaijTGIwf7hhRAhUsqG4+9PVfd4PbPIyMiQmzdvNlPBYVpbW/H39zdbY8io5gvaeagcOXKE6667jn/961988cUXzJs3b8htdR8bg2rOqvlCj/M72/fzy7e327Ytv3k2M+NO+fFnKkKITVLKrOG2H8odgf1CiPBj7+uB/f28jm83FRUXHaqsrDRbwSFU8wXtPFRGjx7NsmXL+OCDD2xBwFDvDOg+NgbVnFXzhR7nK7JjqXjiQuYmhwFw+fPr2VHdaLKZ6xjKHYHvAF9LKTuPvR8QKeUXzpRzlKysLLlx40YzFTQaj2HTpk3cdNNNLFu2jOTkZLN1NBrDqTvcRvbjnwHw/SmRPH9NpslG/ePyOwJSyi+klJ293g/4Gq6EsxjpFCgz2LRpk9kKDqGaL2jn4dLW1kZlZSU5OTmsWbPmlHXdwddRtLPrUc0X7J3Dx/hR8cSFAHyU77mDBx1NMTxZCJHa6+dzhRCvCSF+KYQwPdG/igOcOjo6zFZwCNV8QTsPlzlz5pCbm0tERATnnnsuL7300oB13cHXUbSz61HNF/p3tkaOAaCo1jNzCzg6a+DvwAwAIUQM8C4QAtwG/Na5ahqNxmwSExNZv3498+fP52c/+xnvvKNnCWtOP346Jw6A295QazD6UHE0EEgDjvfE5UCulPIHwDXAFc4U02g07sHYsWP54IMP+POf/8xFF11kto5GYzg/ypwIQFjgKJNNXIOjgYA3cHxo/veAD469L8UN1hqwWCxmKzhMRITp3eYQqvmCdnYGFouF2267DYvFQk1NDQsWLKCqqspW7m6+Q0E7ux7VfKF/Z28vwY+zYvDx0AWJHA0EdgC3CCHm0hMIfHRsezQ9UwhPiRAiRAixQgjRIoTYLYTob90ChBDXCyG6hBDNvV5nD7Z/b2/Thyk4THBwsNkKDqGaL2hnZ1NcXMznn39OdnY2x2fpuLPvQGhn16OaL6jpPFIcDQTuA24C1gBvSimPZ1y4mJ4VCAfjWXruKEQAVwHPCSGmDFB3vZQysNdrzWA714MFXY9qvqCdnc3cuXNZt24dvr6+zJs3j3//+99u7TsQ2tn1qOYLAzuX1DWzr7GN332wS8nPmlPh6FoDXwLjgTAp5Q29il4AbjlVWyFEAHAZ8JCUsllKuRZ4j57xBactnZ2dZis4hGq+oJ1dQXp6Orm5uUybNo0f/ehHLF++3Gwlh3H3Pu4P1ZxV84WBnTdXHgLgr1+W8Zc1pUYquRyHH6pLKbuAgydtqxhC0xSgS0rZe0mnrcBASYpmCCHqgQbgVeD3x/MZ9EYIsRhYDD3PdjZs2NC7jJycHAoLC0lISOgzpzU+Pp7Ozk6CgoKoqanhwIEDtrLRo0czefJkKioqCA8P77Nu++TJk6mrqyMuLo6dO3fa5TAIDQ0lMjKSpqYmLBYL5eXldm0zMzMpKysjNTWV7du3s2fPHltZTEwMvr6+WCwWmpqaqKmpsZVZLBaysrIoLCwkNja2z2pxSUlJtLS0EB4eTkVFBY2NJzJhjRkzhqSkJPbu3UtwcHCf5UHPOOMMqqqqSE1NZfPmzXZZGsPDwwkJCaGtrY3i4mI7X4Ds7GyKi4tJSkrim2++sSubNGmSrT/r6+vZv/9EAko/Pz+mTp1KcXEx0dHR7Nixw66t1WqloaGBmJgYioqKaG4+MXVn3LhxxMTEcODAAfz9/Skttf/HnDFjBuXl5Vit1j59PGHCBAICApBS0trayt69e21lXl5eZGdnU1BQQEJCAienrE5ISKC9vZ2xY8dSXV3NwYMn/hUCAgKwWq1UVlYSFhbGrl277NpOmTKFmpoaEhIS2LFjB62trbaysLAwwsPDaW5uxsvLi23bttk5Z2VlUVpaSmpqqt05DjBx4kQsFgs+Pj40NjZSW1trK/Px8SEzM3PAcyYlJYWmpiYiIiIoLy+nqanJVhYUFER8fDy1tbUEBQX1OWemTZvGCy+8wGuvvUZkZKSdV0REBMHBwXR0dNDZ2dnnnJk1axaFhYUkJiZychKwuLg4uru7CQwMpK6ujvr6E08d/f39SU9Pp6ysjMjISPLz8+3apqWlUV9fT2xsLAUFBbS0tNjKxo0bR3R0NIcOHcLX17dPH2dkZFBWVobVaiUvL4/u7m5bWVRUFP7+/gghaGlpYd++fbYyb29vZs6cSUFBAfHx8WzZYr/0SmJiIq2trYSGhlJVVWV3zgQGBpKSkkJVVRUhISEUFBTYtU1PT6e6uprk5GS2bdvGvn37bM7jx48nLCzMdu3ZvXu3XduZM2dSUlJCcnIyeXn2N2xjY2Px8vLCz8+PhoYG6urqbGW+vr5kZGRQWFhITEwM27dvt2ubkpJCY2MjUVFRlJSUcPjwibn1wcHBxMXFUVdXR0BAQJ8+njZtGpWVlaSmprJx40a7D93IyEiCgoLo7Oykvb3dbgyKkdfy6upqm3Pva/naOzJ4ZtUu/lXQyktfFpPpX293Lc/NzbW7U2DWtXxYSClP+aLnW3tQr/cDvgbZz1yg5qRtNwFr+qmbAMTTc8fiDGAn8MvBXK1Wq1SN9evXm63gEKr5SqmdjWD9+vWyra1N3nnnnbKurs5snSGhWh9LqZ6zar5SDu583Uu58uI/fWWQzdAANspBPh9P9RrKo4EDgOz1/lSvU9EMBJ20LQjok6pJSlkmpSyXUnbLnnEIjwE/GoKrRqMxic2bN/PCCy8wa9asPndDNBqN+zLoowEp5U/7ez8MigCLECJZSll8bNs0IP8UbWyHBjxz3oZG4yHMnj2bNWvWcMkllzB79myWL1/Oueeea7aWRuNUjrR3sbWqke1VjcSGjibY32fwRm7OoIsO2VUWIhKwSCmrTtoeA3RIKWv7b2mr9096PtRvBKbTk4fgTCll/kn1LgA2SylrhRBW4F/Acinlr0+1f73okEZjPpWVlfzwhz8kPz+fl19+mauvvtpsJY3GacTd/x+7n/9182yyTF6i2IhliHvzKnBBP9vPP1Y2GLcC/kAd8CZwi5QyXwgReyxXQOyxet8DtgkhWugJFt4GfjfYztva2oag4F4UFhaareAQqvmCdjaC3r6xsbGsXbuWRYsWkZGRYaLVqVGtj0E9Z9V8YXDnv19n/3lb23TUlTqG4OgdgUNAjpSy8KTtKcAGKaWpYVFmZqZUbbWrzs5OpTIiquYL2tkITuUrpeQvf/kL11xzDUFBJw8TMg/V+hjUc1bNF4buXFR7mPOe/pJnr8zgwqkTDDAbGKPvCFiA/pIt+w2w3VBUXIZYtUcZqvmCdjaCU/lu376dO++8kzPPPJOKigrjpAZBtT4G9ZxV8wU1nUeKo4FALv0nDroN+Kaf7RqN5jRn6tSpfPTRR1RVVZGdnc369evNVtJoNL1wNBB4ELhOCLFOCPGbY6+v6ckO+IDz9TQajSdwzjnnsGHDBoKCgpg/fz7Lli0zW0mj0RzD0RTDG4DZQDlwKT0pg8uB2VLKdc7X02g0noLVaiU3N5czzzyTgIAAs3U0GqdQWNM0eCU3ZzgphrfSs2CQ2+Hr62u2gsPExcWZreAQqvmCdjaCofqGhoby2WefIURPWpCPP/6YefPm4e/v70K7/lGtj0E9Z9V8YejOre1dAPzx8xL++HkJAFsfOU/JvAKOPhpACBEhhPiFEOIvQoiwY9vmCCHina/n+fTOZ64CqvmCdjYCR3yPBwG7d+/moosuYv78+XZ52I1CtT4G9ZxV84WhO0+bOLbPttc27O6npvvjUCAghMgECum5I3AjJ1IGnws87lw1x/HycjiuMZ3AwECzFRxCNV/QzkYwHN9Jkybx1ltvsX37dnJycti2bZsLzAZGtT4G9ZxV8wXHnCueuJCKJy7k6/u/C8DRTvUCH3D8jsCTwB+klDOA3lkUPgbmOM1qmKi45GXvVb9UQDVf0M5GMFzfhQsX8tVXX9HZ2cmcOXP4z3/+M3gjJ6FaH4N6zqr5wvCco8ca/2jLmTgaCGQC/+hn+z4gYuQ6I0PFQKD3EqsqoJovaGcjGIlvRkYGeXl5pKSk9Fny1pWo1segnrNqvqCm80hxdLBgKzCun+1WetIGazQajcNER0fz9ddfM2pUT16y/Px8UlJS8PFRb+CVRqMajt4ReBd4RAhxPIugFELEAUuAfzvRS6PRnGb4+fkhhODAgQOcddZZXHDBBRw8eNBsLY3G43E0EPgFEALsB0YDa4ES4BDwK+eqOY6KgwXNmDY1ElTzBe1sBM70DQ0N5ZlnnuHLL79k9uzZlJSUOG3fvVGtj0E9Z9V8YWTOf/ysmKa2DifaGIOjiw6NBtqBeUAGPYHEZinlp67RcwwVlyHu6urC29vbbI0ho5ovaGcjcIXvl19+yaWXXoqUkhUrVjBv3jyn7l+1Pgb1nFXzheE7916eOCk8kE9+Ps82VdbVGLbokBDCG2gEUqSUn0spn5RSLnWXIADg6FH1loMsKyszW8EhVPMF7WwErvCdN28eubm5hIeH8/e//93p+1etj0E9Z9V8YfjOWx461/a+pK6ZI8cSDqnAkAcLSim7hBC7AbdN36fiwKLIyEizFRxCNV/QzkbgKt/ExETWr1+Pn58f0DO1KywszCmPAVXrY1DPWTV1hC8IAAAgAElEQVRfGL7zuABfKp64kL9+WcrvPihwspVrcfS/6TfAE8czCrobra2tZis4TH5+vtkKDqGaL2hnI3Cl79ixY/Hz8+PIkSN85zvf4bLLLqOlpWXE+1Wtj0E9Z9V8QU3nkTKcwYJnAdVCiFIhxLbeLxf4aTQaDdAziOvmm2/mvffeY+7cuVRXV5utpNF4BI7mEfgXIAFjRkBoNBrNMYQQ3HnnnSQlJfGTn/yE7Oxs3nvvPTIzM81W02iUZkiBwLHZAv8DLAB8gM+A/yelPP1SMGk0GlO58MILWbduHRdddBF33XUXa9asMWx0tkbjiQz1jsCvgeuB1+nJLngl8BxwuWu0hsfxAUUqkZaWZraCQ6jmC9rZCIz2PeOMM8jLy6OrqwshBG1tbYwaNcqhgEC1Pgb1nFXzhZE7l9b1jF9ZXVjHRVOjnKHkcoY6RuBS4GdSysVSyjuBC4EFx6YUug16rQHXo5ovaGcjMMM3IiKCqKgourq6uOyyy7jhhhtob28fcnvV+hjUc1bNF0buHOjX8/16xWZ1xrAMNRCYCHx1/AcpZR7QCbhVuOPr67YzGwckNjbWbAWHUM0XtLMRmOnr5eVFdnY2L7/8Mueee+6QL+Sq9TGo56yaL4zc+aGLJmONHIPFW53HVUMNBLzpySjYm04cH2zoUtra2sxWcJiCArXmm6rmC9rZCMz0FULwyCOP8MYbb5Cbm8usWbOG5KNaH4N6zqr5gnOcC2oO83F+LZUHjjjByPUM9YNcAK8JIXqn7vMD/iaEsP2mUsqLnSnnKN3d3WYeflg4Yz60kajmC9rZCNzB94orriAuLo4FCxawcOFCduzYccpUse7g7CiqOavmC8513rmvidjQ0U7bn6sYaiDwj362veZMEY1Goxkps2fPJjc3l4aGBry9vZFS6hkFGsP54I65/OCPXw1e0U0YUiAgpfypq0U0Go3GGcTFxREXFwfA/fffT3t7O08++aRyi99o1OdopxrrDai3bu8pUPEffdy4cWYrOIRqvqCdjcAdfaWUtLe388wzz3DJJZdw+PBhu3J3dB4M1ZxV8wXnODe09Aypu/Of3454X0bgUYGAirMGoqOjzVZwCNV8QTsbgTv6CiF4+umnee655/joo4+YM2cOu3fvtpW7o/NgqOasmi84x/nMxFAnmBiHoYGAECJECLFCCNEihNgthLhyCG0+F0JIIcSgjzFUzCNw6NAhsxUcQjVf0M5G4M6+N998Mx9++CGVlZXMmzfPNrvInZ0HQjVn1XzBOc5eXoIbz4onwFeNu9RGT/97lp5piBHAdOA/QoitUsp+l3sSQlyFA47OWJrUaFS7i6GaL2hnI3B333PPPZf169eza9cuWwZSd3fuD9WcVfMFNZ1HimGfnEKIAOAy4CEpZbOUci3wHnDNAPWDgUeAe4d6jKNHjw5eyc0oKyszW8EhVPMF7WwEKvimpaVx6aWXAvD666/z4IMPIqU02coxVOjn3qjmC2o6jxQj7wikAF1SyqJe27YC3xmg/u/oWc+g5lQ7FUIsBhZDT8rRDRs29C4jJyeHwsJCEhIS2LRpk13b+Ph4Ojs7CQoKoqamhgMHDtjKRo8ezeTJk6moqCA8PJydO3fatZ08eTJ1dXXExcWxc+dOjhw5kTgiNDSUyMhImpqasFgslJeX27XNzMykrKyM1NRUDh06ZOccExODr68vFouFpqYmampO/PoWi4WsrCwKCwuJjY1l69atdvtNSkqipaWF8PBwKioqaGxstJWNGTOGpKQk9u7dS3BwMEVFRXZtzzjjDKqqqkhNTWXz5s12qVrDw8MJCQmhra2NtrY2O1+A7OxsiouLSUpK4ptvvrErmzRpkq0/6+vr2b9/v63Mz8+PqVOnUlxcTHR0NDt27LBra7VaaWhoICYmhqKiIpqbm21l48aNIyYmhgMHDuDv709paald2xkzZlBeXo7Vau3TxxMmTCAgIAApJa2trezdu9dWdjxLXUFBAQkJCWzevNluvwkJCbS3tzN27Fiqq6s5ePCgrSwgIACr1UplZSVhYWHs2rXLru2UKVOoqakhISGBHTt20NraaisLCwsjPDyc5uZmvLy8OHjwoJ1zVlYWpaWlpKam9un/iRMnYrFY8PHxobGxkdraWluZj48PmZmZA54zKSkpNDU1ERERQXl5OU1NTbayoKAg4uPjqa2tJSgoqM85M23aNCorK0lNTaWxsdHOKyIiguDgYDo6Oujs7GTPnj12bWfNmkVhYSGJiYls3LjRriwuLo7u7m4CAwOpq6uzyxTo7+9Peno6ZWVlREZG9lk7Pi0tjfr6emJjYykoKLCbEz5u3Diio6M5dOgQq1at4pVXXmH37t08+OCDjBo1ioyMDMrKyrBareTl5dnlJYmKisLf3x8hBC0tLezbt89W5u3tzcyZMykoKCA+Pp4tW7bYOSUmJtLa2kpoaChVVVV250xgYCApKSlUVVUREhLSJ5lNeno61dXVJCcns23bNrvzYvz48YSFhdmuPb3HPwDMnDmTkpISkpOTycvLsyuLjY3Fy8sLPz8/GhoaqKurs5X5+vqSkZFBYWEhMTExbN++3a5tSkoKjY2NREVFUVJSYjcIMzg4mLi4OOrq6ggICOhzHvc+ZzZu3Gj3ODcyMpKgoCA6Oztpb2+nqqrKVmbktby3syPX8tzcXLvA8mAjtLR3UVNXT9uRZsOu5cNCSmnIC5gL1Jy07SZgTT91s4Bv6QlU4uhZ+tgy2DGsVqtUjfXr15ut4BCq+UqpnY1ANd/u7m55yy23SEDOmjVL1tTUmK00JFTrZ9V8pXSec+Iv/yMn3bdSPvHhLqfs71QAG+UIPp+NfKjeDASdtC0IsJvTI4TwAv4C3CmlVG/0n0ajcXuEEFx77bX8+9//ZuvWreTk5Cg5sE3jvqy84ywADrd1mGwyOEY+GigCLEKIZCll8bFt04CTBwoG0XNHYNmxjGDHh11WCSEul1IOmK5p9Gj3T+V4MhkZGWYrOIRqvqCdjUA1X+hxnjVrFl999RWrVq1i7NixZisNimr9rJovOM/ZGhlEaIAaAw8NuyMgpWwB3gYeE0IECCHmAJcAr55UtZGeVQ2nH3v94Nj2TCD3VMfQgwVdj2q+oJ2NQDVfOOGcmZnJL3/5SwC++eYb/vSnP7ntIELV+lk1X1DTeaQYPd/uVsAfqAPeBG6RUuYLIWKFEM1CiNhjjzxqjr+A46PLaqWUp1xs/Pi0IJWwWq1mKziEar6gnY1ANV/o3/nFF1/kjjvu4LbbbqOjw/1u6arWz6r5gprOI8XQQEBK2SClXCClDJBSxkop3zi2vVJKGSilrOynTYWUUgxlvICKK12dPJrX3VHNF7SzEajmC/07P/fcc9x7770899xzXHjhhW43bkC1flbNF9R0HinqZeDxMFRbOlk1X9DORqCaL/Tv7OXlxZIlS/j73//O6tWrmT17tt20L7NRrZ9V8wU1nUeKDgQ0Go3mJG644QY++eQTMjMzCQsLM1tHo3EpOhDQaDSafjj77LN57bXXsFgs7Nu3jzfffNNsJY3GJXhUIODj42O2gsNERUWZreAQqvmCdjYC1XzBMeelS5dy5ZVX8sADD5h661i1flbNF9R0HikeFQiouOiQv7+/2QoOoZovaGcjUM0XHHNeunQpixcv5ve//z2XX365XUpxI1Gtn1XzBec6H2hp57UNldQdbnPaPl2Bep+cHsaxpEnKoJovaGcjUM0XHHP28fHh+eef56mnnmLFihXMmzfPbr0Bo1Ctn1XzBdc4Vx1sHbySiXhUIKDiaE/Vpjyq5gva2QhU8wXHnYUQ/PznP+fdd99FCGFK3hLV+lk1X3Cu88s/nem0fbkSjwoE3DEByGCY8a1iJKjmC9rZCFTzheE7//CHPyQ3N5dx48bR1tbGZ5995mSzgVGtn1XzBTWdR4pHBQIajUZjBMfHIy1dupRzzz2XpUuXum1aYo1mMHQgoNFoNMPknnvu4cc//jH33XcfP/vZz2hvP2UWdI3GLTFy9UFNP3h7ew9eyY1QzRe0sxGo5gvOcfb39+eNN94gNTWVxx57jLKyMv79738TGhrqBMO+qNbPqvmCms4jRXjS7aysrCy5ceNGszU0Gs1pyOuvv87dd9/NF198QWpqqtk6GjdgTWEd1//fN7x965lkxI5z2XGEEJuklFnDbe9Rjwba2tx7rmZ/FBQUmK3gEKr5gnY2AtV8wfnOV111FWVlZaSmpiKlJD8/36n7B/X6WTVfUNN5pHhUIDBq1CizFRwmPj7ebAWHUM0XtLMRqOYLrnEePXo00LOc8fTp0/nb3/7m1P2r1s+q+YJznfcfPgrAnz8vcdo+XYFHBQJmZfsaCVu2bDFbwSFU8wXtbASq+YJrnRctWsQ555zD4sWLufvuu+nq6nLKflXrZ9V8wbnOKRFjAPiqeL/T9ukKPCoQ0Gg0GncgKCiI999/nzvuuIOnnnqKBQsWcPjwYbO1NAYzbeJYLpkeRfRY9061rAMBjUajcQEWi4U//OEPPPvss6xatQo9kPn05Wine2e91YGARqPRuJBbb72VsrIy5s+fD0B9fb3JRhojeffbvexrbOPtzVVmqwyIRwUCKg4WTExMNFvBIVTzBe1sBKr5grHO0dHRAKxatYq4uDjeeuutYe1HtX5WzRec7/ybBekA3PXWVlrbnTNWxNl4VCCg4qJDra3uvSrVyajmC9rZCFTzBXOcZ8yYwYwZM1i0aBG/+c1vHE5LrFo/q+YLzne+ZtYk2/u0hz/i1fUVTt2/M/CoQMBiUS9RoqsykLkK1XxBOxuBar5gjvP48eP59NNPueaaa3j44Ye55pprHMp/olo/q+YLrnF+97Y5tvcPvZtPR5d7fWn1qEBAxTzfVVXu+9yoP1TzBe1sBKr5gnnOo0aN4h//+AePP/44r7/+OsuXLx9yW9X6WTVfcI3ztIljqXjiQtvP+XubnH6MkeBRgYCz5uoaycGDB81WcAjVfEE7G4FqvmCusxCCBx54gLy8PK6++mpgaF9kVOtn1XzBtc7zU8cD8NcvS112jOHgUYGARqPRqMTMmTMRQrBr1y6SkpL48MMPzVbSuJC/XzcTgA+211C2v9lkmxPoQECj0WhMZsyYMYSGhnLRRRfxpz/9yWwdjYvw8hK292X7W0w0scejAgEvL/V+ncDAQLMVHEI1X9DORqCaL7iXc0xMDF999RUXXXQRd9xxB7fffjudnZ196rmT81BQzRdc7/z+7We5dP/DQb1PzlPg5+dntoLDpKSkmK3gEKr5gnY2AtV8wf2cAwMDefvtt7nnnnt49tln+cMf/tCnjrs5D4ZqvqCm80jxqEBAzxpwPar5gnY2AtV8wT2dvb29Wbp0KStWrOD2228HsMs14I7Op0I1X3C9c/exv+e60gMuPY4jGBoICCFChBArhBAtQojdQogrB6j3EyFEoRCiUQhRJ4T4hxAiaLD9q5hHICQkxGwFh1DNF7SzEajmC+7tvGDBAkaNGsXBgweZN28ea9euBdzbuT9U8wXXO3ceS3z30tflvL91r0uPNVSMviPwLNAORABXAc8JIab0U+9rYI6UMhhIACzAbwfbuSOJOdyFgoICsxUcQjVf0M5GoJovqOF86NAhamtr+d73vserr76qhHNvVPMF1ztnTgrh/CkRAGza7R7TKw0LBIQQAcBlwENSymYp5VrgPeCak+tKKfdIKXuvzNEFJBljqtFoNO5BfHw8GzZsYM6cOVx77bW88MILSqZS19jzwjVZBPv7mK1hw8h76SlAl5SyqNe2rcB3+qsshDgL+A8QBBwBFg5QbzGwGCAiIoINGzb0LiMnJ4fCwkISEhLYtGmTXdv4+Hg6OzsJCgqipqaGAwdOPLMZPXo0kydPpqKigvDwcHbu3GnXdvLkydTV1REXF8fOnTs5cuSIrSw0NJTIyEiampqwWCyUl5fbtc3MzKSsrIzU1FQOHTpk5xwTE4Ovry8Wi4WmpiZqampsZRaLhaysLAoLC4mNjWXr1q12+01KSqKlpYXw8HAqKipobGy0lY0ZM4akpCT27t1LcHAwRUVFdm3POOMMqqqqSE1NZfPmzXbjLcLDwwkJCaGtrY22tjY7X4Ds7GyKi4tJSkrim2++sSubNGmSrT/r6+vZv3+/rczPz4+pU6dSXFxMdHQ0O3bssGtrtVppaGggJiaGoqIimptPzLsdN24cMTExHDhwAH9/f0pL7RN0zJgxg/LycqxWa58+njBhAgEBAUgpaW1tZe/eE7fnvLy8yM7OpqCggISEBDZv3my334SEBNrb2xk7dizV1dV2yUcCAgKwWq1UVlYSFhbGrl277NpOmTKFmpoaEhIS2LFjh11O87CwMMLDw2lubsbLy4uDBw/aOWdlZVFaWkpqamqf/p84cSIWiwUfHx8aGxupra21lfn4+JCZmTngOZOSkkJTUxMRERGUl5fT1HQi41lQUBDx8fHU1tYSFBTU55yZNm0alZWVpKam0tjYaOcVERFBcHAwHR0ddHZ2smfPHru2s2bNorCwkMTExD7L88bFxdHd3U1gYCB1dXV2q/X5+/uTnp5OWVkZkZGR5Ofn27VNS0ujvr6e2NhYCgoKaGk5MUVr3LhxREdHc+jQIXx9ffv0cUZGBmVlZVitVvLy8uw+cKOiovD390cIQUtLC/v27bOVeXt7M3PmTAoKCoiPj2fLli12TomJibS2thIaGkpVVZXdORMYGEhKSgpVVVWEhIT0+Taanp7O/v37+fDDD7niiit4+eWXEUKwePFixo8fT1hYmO3as3v3bru2M2fOpKSkhOTkZPLy8uzKYmNj8fLyws/Pj4aGBurq6mxlvr6+ZGRkUFhYSExMDNu3b7drm5KSQmNjI1FRUZSUlHD48GFbWXBwMHFxcdTV1REQENCnj3ufMxs3brSbGREZGUlQUBCdnZ20t7fbPas38lre29mRa3lubq7deI7BruXQk7yotbXVqdfyYSGlNOQFzAVqTtp2E7BmkHbRwKNAymDHsFqtUjXWr19vtoJDqOYrpXY2AtV8pVTPubu7W95zzz1y3759ZqsMGdX6WErjnKc++rF85N0dTtkXsFGO4PPZyDECzfR8u+9NEHC4n7o2pJTVwEfAPwc7gL+//7DlzCI9Pd1sBYdQzRe0sxGo5gvqOQshePjhh4mMjKSzs5MbbriBb7/91mytU6JaH4OaziPFyECgCLAIIZJ7bZsG5A9QvzcWYNBFolWcPlhdXW22gkOo5gva2QhU8wW1naurq/nkk08466yzeO+990y2GhiV+9jVNLZ28PK6Co52mr9GjmGBgJSyBXgbeEwIESCEmANcArx6cl0hxFVCiFjRwyTgceCzwY6hYkKh5OTkwSu5Ear5gnY2AtV8QW3nSZMmkZeXR1paGgsWLODJJ5+0ez7tLqjcx0ZRWHPKm+KGYPT0wVsBf6AOeBO4RUqZf+xDv1kIEXus3mRgHT2PE74GCukZT3BKeg/YU4Vt27aZreAQqvmCdjYC1XxBfecJEybwxRdfcNlll3HPPffwwAMPmGjWP6r3sSt56fosANwhfjM0A4+UsgFY0M/2SiCw188PAg8OY/8j8jMD1XIfqOYL2tkIVPMFz3AePXo0y5Yt47HHHuOiiy4yyWpgPKGPTwc8KsWwRqPRnG54eXnx6KOPkpXV8w3zySefdM6UMs1pgw4ENBqNxkOoq6tj6dKlzJo1i9WrV5uto1EEjwoEVFxrYPz48WYrOIRqvqCdjUA1X/BM5/DwcHJzc5kwYQLnnXceL774okFm/eOJfeyJ6EDAZMLCwsxWcAjVfEE7G4FqvuC5zvHx8axbt47vfe973HTTTTz4oMPDrZyGp/axM1ldWDd4JRfjUYGAijm4VZvpoJovaGcjUM0XPNs5ODiYlStXcvvtt5uaIMeT+3ikTBw3GoAVW8zPtaDeV2iNRqPRDIrFYuFPf/qT7ef33nuPGTNmMHHiRBOtNMdJjhjDhVMnsKagDiklQgjTXDzqjoCKmQVPXijE3VHNF7SzEajmC6eXc3NzMzfeeCPZ2dl9FgZzJadTHw+HUd5etLR3Ef/LD/jXpqrBG7gIjwoENBqNRtOXwMBAVq9ejZ+fH/PmzWP58uVmK2mAe79vZfrEsQD8YvlW1pXWD9LCNehAQKPRaE4DpkyZQm5uLhkZGfz4xz/m8ccfN1vptCcy2I93bpvDs1dmAPC3L8tM8dCBgEaj0ZwmhIeH89lnn3H11VfT3Nxsto7mGPNSemYqrC7cz3efXEPlAWMHWQoV0/IORFZWlty4caPZGg7R1dWFt7e32RpDRjVf0M5GoJovnN7OtnXovbz49ttviY6Odsn8+dO5jx3luTWlLPmoAID/++lM5qeGD7mtEGKTlDJruMf2qDsCKuaILikpMVvBIVTzBe1sBKr5wuntLITAy8uLjo4OFi5cSE5ODjt37nTKvntzOvexo9xydiIrbj3TlGN7VCCglyF2Par5gnY2AtV8QTsD+Pj4sGzZMo4cOcLs2bP5+OOPnbp/3cdq4FGBQEtLi9kKDpOXl2e2gkOo5gva2QhU8wXtfJzs7Gzy8vKIi4vjwgsv5C9/+YvT9q37eHgc7egy9HgeFQhoNBqNxnFiY2NZu3YtF1xwAR9++KGSWVo9AR/vno/km1/bzPtb9xp2XB0IaDQajYYxY8bwzjvvsGzZMry8vNi3bx+NjY1ma51WTJ4QxB3fTQLg2z2HDDuuDgQ0Go1GA4C3tzejR49GSsnChQuZM2cO5eXlZmudNnh5Ce46L5XAUcZm//eoQMDX19dsBYeJjY01W8EhVPMF7WwEqvmCdj4VQgh+97vfUV1dTU5ODuvWrRvWfnQfq4FHBQIq4uWl1p9ANV/Qzkagmi9o58H47ne/S25uLsHBwcyfP5/XX3/d4X3oPlYDj/qNVfwDqjblUTVf0M5GoJovaOehkJKSwoYNG5g9eza/+93vHF7YTfexGqj3yXkKOjs7zVZwmIaGBrMVHEI1X9DORqCaL2jnoRIaGsqqVav45JNP8PX1pbW1lSNHhpYCV/exGuhAwGTq6urMVnAI1XxBOxuBar6gnR3B19eXqKgoAG688UbOPvtsampqBm2n+1gNPCoQ0Gg0Go1rufzyy8nPzyc7O5utW7eareORdHR183lBHUatBaQDAY1Go9EMmQULFrB27Vq6u7s566yzWLlypdlKHsfRzm7K61soqTNmhUiPCgSEEGYrOIxqUx5V8wXtbASq+YJ2HgkzZswgLy8Pq9XKT3/6Uw4fPtxvPXfxdQR3cP7DT6YDPQGBEehliDUajUYzLI4cOUJRURHTp09HSklXVxcWi7HJcDyRT3bWctMrG5mdEMqbi2cNWl8vQ9wLFZchLiwsNFvBIVTzBe1sBKr5gnZ2BqNHj2b69J5vr0888QTnn38+Bw8etJW7m+9QcAfn7PgQAA60HDXkeIYGAkKIECHECiFEixBitxDiygHqXSeE2CSEaBJCVAkhlgohBg0z3eGWjqPExMSYreAQqvmCdjYC1XxBOzub6OhovvrqK2bNmkVxcTHg3r4D4Q7Owf4+fH9KJAJjHncbfUfgWaAdiACuAp4TQkzpp95o4L+BMCAH+B7wi8F23tra6jxTg9i+fbvZCg6hmi9oZyNQzRe0s7O59tpr+eyzzzhw4ACzZs3iiy++cGvfgVDReaQYFggIIQKAy4CHpJTNUsq1wHvANSfXlVI+J6X8SkrZLqWsBl4H5hjlqtFoNBrHmTt3Lrm5uYSHh3PBBRdw4MABs5U0Q8DIUR0pQJeUsqjXtq3Ad4bQdh6Q31+BEGIxsBggIiKCDRs29C4jJyeHwsJCEhIS2LRpk13b+Ph4Ojs7CQoKoqamxu6kHT16NJMnT6aiooLw8HB27txp13by5MnU1dURFxfHzp077TJthYaGEhkZSVNTExaLpc/qXZmZmZSVlZGamsqhQ4fsnGNiYvD19cVisdDU1GSXtMNisZCVlUVhYSGxsbF95vAmJSXR0tJCeHg4FRUVdkuIjhkzhqSkJPbu3UtwcDBFRUV2bc844wyqqqpITU1l8+bNdqlEw8PDCQkJoa2tjba2NjtfgOzsbIqLi0lKSuKbb76xK5s0aZKtP+vr69m/f7+tzM/Pj6lTp1JcXEx0dDQ7duywa2u1WmloaCAmJoaioiKam09MpRk3bhwxMTEcOHAAf39/SktL7drOmDGD8vJyrFZrnz6eMGECAQEBSClpbW1l794T6357eXmRnZ1NQUEBCQkJbN682W6/CQkJtLe3M3bsWKqrq+2ehwYEBGC1WqmsrCQsLIxdu3bZtZ0yZQo1NTUkJCSwY8cOuztYYWFhhIeH09zcjJeXFwcPHrRzzsrKorS0lNTU1D79P3HiRCwWCz4+PjQ2NlJbW2sr8/HxITMzc8BzJiUlhaamJiIiIigvL6epqclWFhQURHx8PLW1tQQFBfU5Z6ZNm0ZlZSWpqak0NjbaeUVERBAcHExHRwednZ3s2bPHru2sWbMoLCwkMTGRkwf4xsXF0d3dTWBgIHV1ddTX19vK/P39SU9Pp6ysjMjISPLz7S8LaWlp1NfXExsbS0FBAS0tLbaycePGER0dzaFDh/D19e3TxxkZGZSVlWG1WsnLy6O7+8SI7aioKPz9/RFC0NLSwr59+2xl3t7ezJw5k4KCAuLj49myZYudU2JiIq2trYSGhlJVVWV3zgQGBpKSkkJVVRUhISEUFBTYtU1PT6e6uprk5GS2bdtm5zx+/HjCwsJs157du3fbtZ05cyYlJSUkJyeTl5dnVxYbG4uXlxd+fn40NDTYJdHx9fUlIyODwsJCYmJi+nxDTklJobGxkaioKEpKSuxmDAQHBxMXF8eyZcvYtm0bXl5edn3c+5zZuHGjXRK4yMhIgoKC6OzspL29naqqKluZkdfy3n3syHk2HAcAACAASURBVLU8NzfXbt7/SK/lR44cobD2MOs2b8er/cR5PNi1fFhIKQ15AXOBmpO23QSsGaTdT4EqIGywY1itVqka69evN1vBIVTzlVI7G4FqvlJqZyNYv369fO+99+Sll14qm5ubzdYZEu7Sx79+L19Oum+l/OsXpYPWBTbKEXw+GzlGoBkIOmlbEND/BFRACLEAeAK4QEpZP1C944waNWpEgmaQkpJitoJDqOYL2tkIVPMF7WwEKSkpVFdX88477zB37ly7b/nuirv08T3npwLQZcAUfyMDgSLAIoRI7rVtGgPf8v8+8Dfgh1LKIY3e6OrqGrGk0fS+fa8CqvmCdjYC1XxBOxtBY2MjN998MytXrqSkpITs7Ow+j4LcDdX62BkYFghIKVuAt4HHhBABQog5wCXAqyfXFUJ8l54BgpdJKfNOLh8IFacPHl/IQxVU8wXtbASq+YJ2NoLjvhdccAHr1q3D19eXefPm2aYXuiOq9bEzMHr64K2AP1AHvAncIqXMF0LECiGahRCxx+o9BAQDHxzb3iyE+HCwnauYUKikpMRsBYdQzRe0sxGo5gva2Qh6+6anp5Obm8tvfvMbkpKSTLQ6Nar1sTMwNBCQUjZIKRdIKQOklLFSyjeOba+UUgZKKSuP/TxfSmk5tu3464LB9t97lK8qDJSj211RzRe0sxGo5gva2QhO9o2IiODuu+9GCEF+fj633HILR48akz1vqLhbH7d1uP6Rt0elGNZoNBqNGqxevZrnn3+ec845x26KqKaH42voPfNpMUfaO09deYToQECj0Wg0hnP77bfzz3/+k40bN5KTk9Mn78bpjp+PN9+1hgPQfFQHAkPG29vbbAWHCQ4ONlvBIVTzBe1sBKr5gnY2gsF8Fy1axJo1a2hpaWH27Nl9EuuYgTv18fFAwNV4VCCg4qyBuLg4sxUcQjVf0M5GoJovaGcjGIpvTk4OeXl5/OQnPyEtLc31UoOgWh87A48KBHqnq1SF3qk9VUA1X9DORqCaL2hnIxiqb2xsLM8//zy+vr4cOHCA3/72t6Zdz1XrY2fgUYGAl5d6v05AQIDZCg6hmi9oZyNQzRe0sxEMx3f58uU89NBDXHzxxXZrXxiFO/Wxt1fPiMEnPigYpObIUO+T8xS42zSUoaDanFXVfEE7G4FqvqCdjWA4vjfffDPPPfccq1atYs6cOVRUVDhf7BS4Ux+fPyUSgLrDrv1s86hAQKPRaDTqc/PNN/PRRx+xZ88esrOz+6wCeroQEuBLRuxYDutZAxqNRqM53TjnnHPYsGEDU6dOJTo62mwd0+iWsHXPIeYu/dxlx9CBgEaj0WjcEqvVyqeffkpERAQdHR384x//OL48/WnDbxekA7CnodVlx/CoQMDf399sBYeZNm2a2QoOoZovaGcjUM0XtLMRONN32bJlXH/99Vx55ZW0trruQ9Hd+jg9Opg7v5c8eMUR4FGBQHt7u9kKDlNZWWm2gkOo5gva2QhU8wXtbATO9L3qqqtYsmQJy5YtY/78+dTU1Dht371x5z5ucdFYAeFJt1mysrKku691rdFoNJrhs2LFCq666irGjx/PypUrOeOMM8xWcjl//bKU331QwDWzJvGbY48KeiOE2CSlzBru/j3qjsCRI0fMVnAY1QIX1XxBOxuBar6gnY3AFb4LFy7kq6++ws/PzyVJh9yxj6+dHQe4bs0BjwoEVLy7oVo2RNV8QTsbgWq+oJ2NwFW+mZmZ5OfnM2PGDADWrFnjtOu/O/axn483sSGjXbZ/jwoENBqNRnN6YLFYAPjwww+ZP38+N998Mx0dHSZbqYnFbAGNRqMezzz8MId6Darav38/H40fb6KR43iy89jYWP77sccMMDKf888/n/vvv58nnniCsrIyli9fztixY83WcjrdUvJ5QR2dXd1YvJ37Hd6jAgEfHx+zFRwmMjLSbAWHUM0XtLMrOFRZyaO9Vmk7NHaschdfT3Z+1OC0vANhxHns5eXF73//e1JTU1m8eDGzZ89m5cqVJCYmDmt/7vq/19HVTWNrB5t2HyQnIdSp+/aoRwMqLjoUFBRktoJDqOYL2tkIRo0aZbaCw2hn12PkeXz99dfz6aefUl9fz5YtW4a9H3f93/vfy6cD0N7V7fR9e9QdARVxx4Epp0I1X9DORtDd7fyLk6vRzq7H6PN43rx5lJSUEBwcDEBpaanDdwbc9X/Pz8d1X3TV+wp9ClT7JwH1kiCp5gva2Qi6urrMVnAY7ex6zDiPjwcBmzZtIi0tjfvvv9+hzwbV/vecgUcFAiqOGK2qqjJbwSFU8wXtbARmrBs/UrSz6zHzPJ46dSo33HADS5Ys4Uc/+hEtLS1Daqfa/54z0I8GNBqNMrz87bf89N13bT9HBgYyNzaWJeecQ/y4cQDEPfMMuxsbAfCzWJgUHMzPZszgF2eeiRBi2Mf+oqKCu1atIr+ujqgxY7h3zhxuzjp1MreiAwe495NPWFtZydGuLqaMH8+jZ5/N95OS+v19epN3443MPLbq3vbaWm7/8ENyq6oIHT2a/8rM5KF580b0+3g6Pj4+PPfcc6SlpXHXXXcxd+5c3n///dN6JcOB0IGARqNRitE+PpTecQdSSgrq6/mvlSu5+J//5Nv/+i+8jw0YfnjePG6ZOZO2zk4+LSvjlv/8h6BRo/ivQT64B6L84EF+8MYb3DB9Oq8tXMjaykpu/eADxo8ezWWTJw/Y7qI33iBh3Dg+u/ZaAnx9eX7jRi755z/ZeeutJIaEsGjKFFtQcJx7PvmErysryYqKAqDp6FHOffVV5k2axMqLL6bRYuH6d98lwMeHu888c1i/z+mCEII777yTpKQkfvKTn/Dqq69y//33m601Iv76ZRkJ4wOJHuu8RfY86tGAiqgW0avmC9rZSD4qKWHu//0f45YsIWTJEs5/7TV27d8PQMWhQ4hf/5qNe/fatRG//jX/2rnT9vPew4e56u23CV26lNGPP870559ndXn5ifr03AmYMGYM8+PjeeQ732FHXR0lDQ22OmNGjSIyMJC4sWO5MSODqRERrCorG/bv9fzGjUSNGcOffvAD0saP56bMTK6bNo0n168fsE39kSMUNzRw35w5TIuMJCkkhCfOOYfO7m62HFswx9/Hh8jAQNsraNQo3i8s5MaMDNs58Pq2bRzp6OAfCxZgDQnhssmTuW/OHJ7asMHts6m6y3l84YUXsnXrVu69914AGo/dMeoPd3E+mbDAUVi8BF8V1/P6ht1O3bdH3REICAgwW8FhcnJyzFZwCNV8QTsbQUxMDAAt7e38d04OUyMiaO3s5LdffskP33yTnbfdNqT9tLS3852XXyY8IIAVixYRPWYMW2trT9nG/1j+kI5+BoRJKfli92527d9PckiIXZn1lVdOud+5kybx4VVXAbC+qorzEhLsys9PTOQfW7fS0dWFj7d3n/ah/v6khYXx6rZtzIyOxt9i4a+bNjHG15c5Eyf2e8y38vNp6ejgp9On27atr6pi7qRJ+Pv42Pr5/MREHlq9mopDh2yPRNwRdzqPE479/SorK8nOzubnP/859957b58Pfndy7k1cWADbHz2f6Y+toqvbuQGgRwUCbf+/vbOPj6o6F/XzxklCyAfkwySQgCRAkhMQrhAFtGg9Um1VqtUrHrVWKRW5WutHW6XXcolei0q9t71o5SitCvaI2oOiWKXFi1gRC5JU5MsghkgTCCEJJiQkkI91/tiTOJMvZpLMntnJ+/x+80v27LX3frKyZq931lp7rcbGYCv4TVFREdnZ2cHW8Bmn+YI620FlZSVJSUmdmsmfv+oq4h57jG1lZaT78Hz2Szt3Ul5Xx0fz5pE01JpbfWyHCtyT0tpafr1lC+lxcWQlfj3JyoMbN5K/aROnWlpoam1liMvFTzrc4DfOmUNCD+eOcn19eyyvq2NWh0AgJSaG5tZWKk+cYERsbKfjRYQNN9/M9155hbhHHyVMhISoKN656aYu0wM8W1DAlVlZXvvL6+ra864tn1NiYtr3hXIgEIrl+Mwzz+Tiiy9m4cKFfPbZZzzzzDNERES07w9F5zaiIs4gEA0WAyoQcNpkG/B1lOoUnOYL6mwH8e7K6Ivqaha99x5by8o4Wl9PqzG0GsPBmhqfAoF/lJczKSWlPQjoivqmJmKWLMEAJ5qamDJiBK/NmUOEx7fy+6ZPZ96UKRytr+fBjRu5dOxYzu/wLXxqRgZndPFNvjs63n/bmuW7a0o2xnDH22+TOHQoH8ydS1R4OL8vLOTaV1/l49tuI61DfuyuqOCj0lL+fOON3V67LZ9Pd+1QIRTLcVRUFC+99BI5OTnk5+dTXFzMmjVrSEpKAkLTOdDYGgiISALwB+BSoBL4hTHmpS7STQT+DzAVSDTG+FTanbgMcUFBAdOnTw+2hs84zRfU2Q4OHz5Meno6s1evJi0ujmeuvJK02FhcYWHkPv00p1paCHNXWp792k0dnov3pc97aHg4nyxYQJgIKdHRRHt8m2sjcehQxiUkMC4hgTVz5jD+ySeZlpbGxRkZ7WniHnusx4rUs2sgNSaG8ro6r/0V9fW4wsJIjOp60NbGAwdYV1RE9QMPMHzIEACevuIKNhQX8/wnn/DLCy/0Sv9sQQGj4uI6DR5MjYmh3P3oW1s+V7i3U0K8OzRUy7GIsHjxYrKyspg7dy75+fk89dRTQOg6BxK7WwR+B5wCUoD/BvxZRHYYY3Z3SNcEvAo8Day1V1FRlN5QdeIEeysr+d3ll7dXuIWHD9Ps7rs/0/0t/7BHhfqJe9BcG1NGjOCPO3dSeeJEt60CAozroUm/I/FRUfz4vPO49y9/4R+3395e+a//3vcY0cO88p5dAzPS01lbVOS1f0NxMXkjR3Y5PgCs1gqgPQBqI0yE1g4BT2NzMy9++ik/mTatU/oZ6ek88O67NHrMeLehuJiRsbGMcdhaCaHGDTfcwPjx48nJyQFCd1bBQGPbUwMiEg1cCywyxtQZYzYDbwI3d0xrjCkyxvwB6BggKIoSosRHRZE0dCgrCgvZX13N+yUlLHjrLVzuR/qiwsOZnp7O4x9+yO6KCrb885/8bMMGr3PcePbZJEdHc/XLL/PBl19y4Ngx3iwq8npqoDfcee65FFVV8SePpxMy4uLaWw26enk23S/Iy6O0tpZ71q9n79Gj/L6wkBc++YSfzZjRnub1vXvJeeopytyT/swYNYqEqCjmvvEGO8rL2VdVxc//+leKjx3jyqwsL7//3LOHmpMn+eE553Ryv/HssxkaHs6ta9fyWXU1r+3dy2ObN3Pf9Okh3zXgBPLy8oiJiaGuro4ZM2bw+uuvB1vJduxsEcgCWowx+zze2wFc1JeTish8YD5ASkoKf//73z33MW3aNIqKisjMzKSgoMDr2IyMDJqbm4mLi6O8vJyqqqr2fUOHDiU3N5eSkhKSk5PZ43EDAcjNzaWiooIxY8awZ88er26JxMREUlNTqa2txeVycaDDTWzq1KkUFxeTnZ3NV1995eWcnp5OREQELpeL2tpayj2+MblcLvLy8igqKmL06NHs2LHD67zjxo2jvr6e5ORkSkpKvB6RiY2NZdy4cRw6dIhhw4axb98+r2PPPvtsSktLyc7OprCw0GuazeTkZBISEmhsbKSxsdHLF+C8887j888/Z9y4cXz88cde+84666z2/KysrOSo+1EygCFDhjBp0iQ+//xz0tLS2LVrl9exOTk5VFdXk56ezr59+6jz+CYZHx9Peno6VVVVREVF8cUXX3gde84553DgwAFycnI65fGIESOIjo7GGENDQwOHPB5nCwsL47zzzuOzzz4jMzOTwsJCr/NmZmZy6tQphg8fTllZGceOHWvfFx0dTU5ODgcPHiQpKYm9e/d6HTthwgTKy8vJzMxk165dNDQ0tO9LSkoiOTmZuro6wsLCOHbsmJdzXl4eX3zxBdnZ2Z3yf9SoUbhcLsLDw6mpqeGIxyj78PBwpk6d2m2ZycrKora2lpSUFA4cOOA1c11cXBwZGRkcOXKEuLg4rzJz9OhRmtLSqKmpISkpicbGRg6VlfHURRfxvz76iIlPP83Y+Hh+ddFFfP/NN6murqa0tJQl06Zx/wcfcO6KFYyJi2P57Nl8c+VKqqqq2md0e/u66/ifmzYxe/VqTrW0kBkXx+Lp0yl1/30AVVVVxMTEeJWntnxsbW2ltbWVI0eOeM02el1WFovfe49L09MJd7loaGjwmkVuxIgRHDt2jKSkJMrKyry6KRJiY1lzzTUsfO89lm/fTkpUFA9Nn860uDjKyspIS0ujtLKSoqoqDpaVYdz5uPJb3+I3n37KxStX0tzayvjhw/n9JZeQ3NJCaWkpERERJCYmsnzrVr6VkUHY8eOUHj/eft3k5GSa6ur46/e/z/w33uCKN95geGQkt02YwK3Z2TQ2Nrb/jZ6f96NHj9LS0sL+/fsZP34827Zt88qn0aNHExYWxpAhQ6iurqaioqJ9X0REBFOmTKGoqIj09HR27tzZqczU1NQwcuRI9u/fz3EP32HDhjFmzBgqKiqIjo7uVI4nT57MwYMHyc7OZvv27V7fwFNTU4mLi6O5uZlTp055/W/suJcnJiYSFRXF0qVL+fLLL7nrrrtITk72+V6+detWrzITqHt5c0srW4ur2LF3P6NSEjrdy3uD2PUcqojMBP5kjEn1eO824CZjzDe7OWYc8LmvYwQmT55sOmZoqHPkyBFSUlKCreEzTvMFdQ4E+bfe6rUMcV1dHTHukexOYSA755eUkP/CC4EXOg2hXo470tzczB133MGKFSu44oorWL16NbHdPOERLPIeeZfKupMAFPxyFokxkYhIgTGmd7NlYe+EQnVAx2HDccDxLtIOGpzWJ+U0X1BnO3Digl/qHHicVo5dLheLFy9m+fLlrF+/nvnz5wdbqRNv/vgCclKt4OSPfz/YL+e0MxDYB7hEZLzHe5Ppx3EA/jwKFCqE6trX3eE0X1BnO3Dio7vqHHicVo7Bcl6wYAHr16/n0UcfDbZOJ0YOj+L1Oy4A4Dfv7qPhVN9XpLQtEDDG1AOvAQ+LSLSIXABcBbzYMa1YDAEi3NtDROS0nwAnrj5Y3mHUdKjjNF9QZzuo6/BonRNQ58DjtHIMXzvPmjWLMWPG0Nrayg9+8ANefvnlIJt9TVTEGVw2wepyaWhyUCDg5g4gCqgAVgP/wxizW0RGi0idiIx2pzsLaODr1oIGoKjT2TrgtGYowGtQixNwmi+osx14Dnx0CuoceJxWjqGzc319PSUlJdxwww089NBDIbO+w/ljk/rtXLbOI2CMqQau7uL9g0CMx3YJnSfyUhRFURRbiY2NZcOGDdx+++3k5+dTVFTEc889xxD3JFHBIizMqiKXrv+sz+caUFMMK4piD8NHjya/pKR9++jRo5zpsBa5gew8fPTo06ZRfCcyMpLnn3+enJwcfvGLX1BbW8tbb70VVKfvTExl0dpdHK7p+xo7AyoQCAtz3qrKQ3uYUz0UcZovqHMguOfhh722P/30UyZNmhQkm96hzoEn1MtxV3TnLCIsXLiQ8ePHt69LEEySYiKZPKp/Zpa0bR4BO5g6darpONFEqNPc3IzL5Zx4zGm+oM524DRfUGc7cJov+Of8xBNPkJuby+WXXx5gq6656ncfMjwqnFXzpjlmHoGA4zkbnlMo8WhedQJO8wV1tgOn+YI624HTfMF355MnT7J69Wpmz57NsmXLQmYQYW8YUIGA0yJPsKYQdRJO8wV1tgOn+YI624HTfMF358jISN5//32++93vcvfdd3PnnXfa/wi7Mby/7+jp052GARUINDb2fdCE3XSc9zrUcZovqLMdOM0X1NkOnOYL/jnHxMSwZs0a7r//fpYvX87VV19ta8vAxTnJZCb1fSlq532FVhRFUZQQISwsjMcff5ycnByam5ttXRHynllZ3DMrC/l5386jgYCiKIqi9JG5c+e2/75u3TqGDx/OzJkzg2jkOwOqa0BRFEVRgklrayv5+flccsklrFq1Ktg6PjGgAoFgz/TUG3Jzc4Ot4BdO8wV1tgOn+YI624HTfKHvzmFhYbz77rvMnDmTW265hQcffDDkV40cUIGAE9caqKioCLaCXzjNF9TZDpzmC+psB07zhf5xjo+Pb1/GeMmSJcyZMyekF8XTCYWCjNMm3HCaL6izHTjNF9TZDpzmC/3rbIzht7/9LcXFxSxbtixgAwlFRCcUakMfHww8TvMFdbYDp/mCOtuB03yhf51FhHvvvZcnn3wSEWHnzp0UFhb22/n7iwEVCIR6P0xXnDhxItgKfuE0X1BnO3CaL6izHTjNFwLnbIzhzjvvZObMmaxduzYg1+gtAyoQUBRFUZRQRER49dVXmThxItdccw1Lly4NmWmJNRBQFEVRFBtITU1l06ZNXHfddTzwwAPMmzcvJNbIcdYojtPgtEEpAImJicFW8Aun+YI624HTfEGd7cBpvhB456ioKFavXk12djabN28O6LV8xXk1Zw+Eh4cHW8FvUlNTg63gF07zBXW2A6f5gjrbgdN8wR7nsLAwHn74YZqamggPD6eyspLq6mqysrICfu0ufYJy1QDR0tISbAW/qa2tDbaCXzjNF9TZDpzmC+psB07zBXud27683n777UybNo2NGzfadm1PBlQg4ESc1p3hNF9QZztwmi+osx04zReC4/zEE08wcuRILrvsMlasWGH79QdUIBAKgy785cCBA8FW8Aun+YI624HTfEGd7cBpvhAc54yMDLZs2cKsWbOYP38+P/3pT21t4R5QgYCiKIqiOJFhw4axbt067rrrLl577TVqampsu7YGAoqiKIoSArhcLpYtW0ZhYSEJCQk0NTVx6NChgF9XAwFFURRFCSHi4+MBuP/++5kyZQrbtm0L6PV00aEg0/b4iFNwmi+osx04zRfU2Q6c5guh5bxnzx6uvPJKDh8+zMqVK5kzZ06X6XTRIQ9OnjwZbAW/KS4uDraCXzjNF9TZDpzmC+psB07zhdByzs3NZevWrUydOpXrr7+eRx55JCDTEg+oFoG8vDyzffv2YGsoiqIoSr9x8uRJfvSjH7F27Vp27tzJmDFjvPZri4AH9fX1wVbwm61btwZbwS+c5gvqbAdO8wV1tgOn+UJoOkdGRrJq1SoKCgrag4Djx4/32/ltDQREJEFEXheRehH5UkRu7CHtvSJSLiI1IvKciETa6WoXTmuRcZovqLMdOM0X1NkOnOYLoessIu1TEC9fvpxJkyaxa9eufjm33S0CvwNOASnATcByEZnQMZGIXAYsBC4BxgCZwEP2aSqKoihKaJKXl0djYyPnn38+69ev7/P5bAsERCQauBZYZIypM8ZsBt4Ebu4i+S3AH4wxu40xx4D/Ddxql6uiKIqihCrnnnsu27ZtY+zYsSxatKjP57NzUuUsoMUYs8/jvR3ARV2knQC80SFdiogkGmOqPBOKyHxgvnvzpIj0T1uJfSQBlcGW8AOn+YI624HTfEGd7cBpvuBM5+y+HGxnIBADdJwzsQaI9SFt2++xgFcgYIx5FngWQES292XkZDBwmrPTfEGd7cBpvqDOduA0X3Cuc1+Ot3OMQB0Q1+G9OKCroY8d07b93n/DJBVFURRFsTUQ2Ae4RGS8x3uTgd1dpN3t3ueZ7kjHbgFFURRFUfqGbYGAMaYeeA14WESiReQC4CrgxS6SrwLmiUiuiMQDvwRe8OEyz/aXr404zdlpvqDOduA0X1BnO3CaLwxCZ1tnFhSRBOA54FtYff0LjTEvichoYA+Qa4w56E57H/AAEAWsARYYY5w3h7CiKIqihDADaophRVEURVH8Y0BNMawoiqIoin9oIKAoiqIogxhHBQJOXKvAV2cRmSgifxGRShEJan+NH863iEiBiNSKSKmILBURO+em8Nf330SkyF0mKkRkpYh0fKTVFvwpyx7HbBQRE4w8dl/f13y+VURaRKTO4/VNm3X9vV9kishbInLc/Rlcaqerh4evefzvHfL3pIgE5fFqP5xFRB4RkTL3Z3CTdDHFfAj5RorIb0TkkIgcE5GnRSQ8CL4/FpHt7v/xC6dJ26t6z1GBAM5cq8AnZ6AJeBWYZ6Nbd/jqPBS4B2smrmlY+f0zuyQ98NX3Q+ACY8wwrDLhAh6xzdIbX50BEJGbsHcCsK7wx/kjY0yMx2uTXZIe+Hq/iAA2ABuBVCAd+KONnp745GyMWeCZv8Bq4E/2qrbja7m4DvghMBNIAD6i66fGAo2vvguBPGAi1sy4U7CeYLObQ1j3qed6StSnes8Y44gXEI31z8vyeO9F4LEu0r4ELPHYvgQoD2Vnj/3jrH9L6OdzF8feB6xzgi/W7JWrgLdDPY+BYVjzcEwHDOAKZWesdUE22+3YB9/5wAfB9O1Nuehw3HHgolB2xnoK7FWP7QlAYwj7bgeu89i+EfhnEMvHI8ALPezvdb3npBaB7tYq6CqSm+De55kuRUQSA+jXFf44hwp9cb6QrieICiR++YrIN0SkBuvGeS3w28ArdsLfPF4CLAfKAy3WA/46n+NuYt8nIouC0J3hj+90oERE3nE7bxKRs22x9Ka3n71rgaPA3wIl1gP+OL8MjBORLHcT+y1A35fO8w9/fMX98txOF5FhAfTrC72u95wUCPTXWgV24o9zqNArZxGZi9WM9kSAvLrDL19jzGZjdQ2kA78GSgJq1zU+O4tIHnAB8KQNXj3hTz7/Das5NRmrkroB+HlA7Trjj2868G/AMmAk8GfgDXeXgZ309n5xC7DKuL8G2ow/zoeBD4AioAGrq+DegNp1xh/fd4C7ReRMEUkFfuJ+f2gA/fpCr+s9JwUCTlyrwB/nUMFvZxG5GngM+I4xxu5Vu3qVx8aYMqxvIy8HyKsnfHIWkTDgaeBuY0yzTW7d4XM+G2OKjTEHjDGtxpidwMPAf7fB0RN/ykUDVlfGO8aYN3t1NAAABNRJREFUU1jBbCLwL4FV7ERvPnujsFZwXRVAr57wx3kxcC4wChiC1X+9UUTsrFj98f0V8A/gE2ALsBZrLFdFIAX7QK/rPScFAk5cq8Af51DBL2cR+TawApjtvunbTV/y2AWMDYhVz/jqHIfVyvKKiJQDH7vfLxWRmYHX9KIv+WzwbmK1A398P8VyDDa9yeMfAFuMMcUBNesef5wnA68YY0qNMc3GmBeAeCA38Jrt+OxrjGkwxvzYGJNmjMnEmg23wBjTYpOrv/S+3gvWwIdeDpZ4GWt0bDRWc2kNMKGLdN/G6k/NxSpoG/FhsFuQnQUrSs7FuikNASJD3PlfsT4cFzqkXNwEjHbn9VnA+8Broers9kz1eJ3rLhtpQEQoOrvTfQdIcf+eA+wCFoewbzZwApgFnIHVXP1FKOexR/oi4Id2e/YynxcDm7FG64cBNwP1wPAQ9U3D6ioSrHEk/wQuDUL+utz1waNYAxuH0MWAYfpQ7wWt8PQyQxKwmmfqgYPAje73R2M1i4z2SHsfcASoBZ4neJWqT85Yj3uYDq+SEHd+D2h2v9f2eieEfX8FlLrTlWIt1JEYynnc4Zi2MmL7UwN+5vMT7s9ePVCM1TUQHqq+7veuAfa77xeb6KHyDSHnGe50scFw7UW5GIL16N5hdz4XAt8OYd8LscYQncAKuG4KUv7m07luyO+mTPSq3tO1BhRFURRlEOOkMQKKoiiKovQzGggoiqIoyiBGAwFFURRFGcRoIKAoiqIogxgNBBRFURRlEKOBgKIoiqIMYjQQUBQlaIjICyLyVnfbiqIEHg0EFGWQ4q50jfvVLCIHRWS5iMQH201RFPvQQEBRBjfvAiOwZi38ETAba6EjRVEGCRoIKMrg5qQxptxYC8H8FXgFuLRtp4jMFZE9ItIoIvtE5F73qoht++PcrQiH3Wn2isj17n2JIrJaREpFpEFEdruXq1YUJYRwBVtAUZTQQEQysRYuaXJv34a1TsBdQAEwEWulySbgKRERrDXb44G5WCu7ZWPNKY/7ZyHwONbc57OAZ0TkoDHm/9v0ZymKcho0EFCUwc23RaQOa9W9tgr8PvfPRcD9xpj/dG8fEJHHgDuAp7Aq9hlYC/TsdadpXw7XGFMG/NrjWs+KyL8CNwAaCChKiKCBgKIMbv4GzAeigNuAscAyETkTGIX1DX65R3oX1rKsAOcAhz2CAC9E5AxgIXA91pKukUAE1up+iqKECBoIKMrg5oQxZr/795+IyHtYLQFtlf8CYEs3x0o377fxM+CnwN3ATqwlU5cAyX0yVhSlX9FAQFEUTx7C6vd/FigDxhpjVnWTthAYISL/0k2rwDeAdcaYFwHcYwqygK/6X1tRlN6igYCiKO0YYzaJyG7gl0A+8KSIfAW8DYQDU4A0Y8yjWP38W4E1InIv1mDBcUC0MWate/t6EfkGUIk16DAD+Ie9f5WiKD2hjw8qitKR/wvMAzYAPwRuBnYAH2CNJzgAYIxpBb4DfAj8EdgL/D+scQAAjwDbsFoY/gbUA/9h1x+hKIpviDEm2A6KoiiKogQJbRFQFEVRlEGMBgKKoiiKMojRQEBRFEVRBjEaCCiKoijKIEYDAUVRFEUZxGggoCiKoiiDGA0EFEVRFGUQo4GAoiiKogxi/guPfdL863h3pAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "######## important auc PR curve Test Set\n",
    "precision = dict()\n",
    "recall = dict()\n",
    "average_precision = dict()\n",
    "for i in range(1):\n",
    "    precision[i], recall[i], _ = precision_recall_curve(Y_test[:, i], ycls_pred_test[:, i])\n",
    "    average_precision[i] = average_precision_score(Y_test[:, i], ycls_pred_test[:, i])\n",
    "    \n",
    "# A \"micro-average\": quantifying score on all classes jointly\n",
    "precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(Y_test.ravel(), ycls_pred_test.ravel())\n",
    "average_precision[\"micro\"] = average_precision_score(Y_test, ycls_pred_test, average=\"micro\")\n",
    "#print('Average precision score , micro-averaged over all classes: {0:0.2f}'\n",
    "#    .format(average_precision[\"micro\"]))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,7))\n",
    "ax.step(recall['micro'], precision['micro'], where='post')\n",
    "\n",
    "ax.set_xlabel('Recall', fontsize=14)\n",
    "ax.set_ylabel('Precision', fontsize=14)\n",
    "ax.plot([0, 1], [1, 0], 'k--')\n",
    "ax.set_ylim([0.0, 1.01])\n",
    "ax.set_xlim([0.0, 1.00])\n",
    "ax.set_yticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_xticks(np.arange(0, 1.1, 0.1))\n",
    "ax.set_title('Precision-Recall Curve Test Set', fontsize=14)\n",
    "ax.tick_params(axis=\"x\", labelsize=12)\n",
    "ax.tick_params(axis=\"y\", labelsize=12) \n",
    "ax.grid(linestyle='-.', linewidth=0.7)\n",
    "ax.text(0.5, 0.1, 'aucPR={0:0.3f}'.format(average_precision[\"micro\"]), bbox=dict(facecolor='red', alpha=0.5),fontsize=14)\n",
    "plt.savefig('results/'+model_name+'_test_aurPR.png', dpi=500, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "### #### confusion metrics for the sets\n",
    "# #print(sklearn_metrics.confusion_matrix(Y_train, y_label_pred_train))\n",
    "# tn_train, fp_train, fn_train, tp_train = sklearn_metrics.confusion_matrix(Y_train, y_label_pred_train).ravel()\n",
    "# tn_valid, fp_valid, fn_valid, tp_valid = sklearn_metrics.confusion_matrix(Y_valid, y_label_pred_valid).ravel()\n",
    "# tn_test, fp_test, fn_test, tp_test = sklearn_metrics.confusion_matrix(Y_test, y_label_pred_test).ravel()\n",
    "# print('Training Set   - ', 'True Negatives',tn_train, ',False Positives',fp_train, ',False Negatives',fn_train, ',True Positives',tp_train)\n",
    "# print('Validation Set - ', 'True Negatives',tn_valid, ' ,False Positives',fp_valid, ' ,False Negatives',fn_valid, ' ,True Positives',tp_valid)\n",
    "# print('Testing Set    - ', 'True Negatives',tn_test, ' ,False Positives',fp_test, ',False Negatives',fn_test, ',True Positives',tp_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  Classification Report Training Set\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      1.000     1.000     1.000    117336\n",
      "           1      1.000     1.000     1.000      5802\n",
      "\n",
      "    accuracy                          1.000    123138\n",
      "   macro avg      1.000     1.000     1.000    123138\n",
      "weighted avg      1.000     1.000     1.000    123138\n",
      "\n",
      "---------------------------------------------------------------------------------------------\n",
      "                  Classification Report Validation Set\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      0.990     0.991     0.991     14708\n",
      "           1      0.806     0.781     0.793       685\n",
      "\n",
      "    accuracy                          0.982     15393\n",
      "   macro avg      0.898     0.886     0.892     15393\n",
      "weighted avg      0.982     0.982     0.982     15393\n",
      "\n",
      "---------------------------------------------------------------------------------------------\n",
      "                  Classification Report Testing Set\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0      0.989     0.993     0.991     14690\n",
      "           1      0.840     0.770     0.803       703\n",
      "\n",
      "    accuracy                          0.983     15393\n",
      "   macro avg      0.915     0.881     0.897     15393\n",
      "weighted avg      0.982     0.983     0.982     15393\n",
      "\n"
     ]
    }
   ],
   "source": [
    "######## classification report train set\n",
    "print('                  Classification Report Training Set')\n",
    "print(sklearn_metrics.classification_report(Y_train, y_label_pred_train, digits=3))\n",
    "\n",
    "\n",
    "print('---------------------------------------------------------------------------------------------')\n",
    "######## classification report train set\n",
    "print('                  Classification Report Validation Set')\n",
    "print(sklearn_metrics.classification_report(Y_valid, y_label_pred_valid, digits=3))\n",
    "\n",
    "\n",
    "print('---------------------------------------------------------------------------------------------')\n",
    "######## classification report train set\n",
    "print('                  Classification Report Testing Set')\n",
    "print(sklearn_metrics.classification_report(Y_test, y_label_pred_test, digits=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training_r2 0.9190660227020315\n",
      "valid_r2 0.6108414652928285\n",
      "test_r2 0.5601188649477067\n"
     ]
    }
   ],
   "source": [
    "# Regression\n",
    "print('training_r2', r2_score(freq_train, yreg_pred_train))\n",
    "print('valid_r2', r2_score(freq_valid, yreg_pred_valid))\n",
    "print('test_r2', r2_score(freq_test, yreg_pred_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### best model, do not regularise classification, put 0.0005 in regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}