models/GRU.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T09:19:01.460968Z",
     "start_time": "2018-11-27T09:19:01.438023Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import requests\n",
    "import csv\n",
    "from bs4 import BeautifulSoup\n",
    "from datetime import datetime, timedelta\n",
    "import statsmodels.api as sm\n",
    "from statsmodels.tsa import stattools\n",
    "from statsmodels.tsa.seasonal import seasonal_decompose\n",
    "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n",
    "from statsmodels.tsa.stattools import acf, pacf\n",
    "import os\n",
    "from pandas import Series\n",
    "from pandas import concat\n",
    "from pandas import read_csv\n",
    "from pandas import datetime\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "# import tensorflow as tf\n",
    "# config = tf.ConfigProto()\n",
    "# config.gpu_options.allow_growth = True\n",
    "# config.gpu_options.per_process_gpu_memory_fraction = 0.4\n",
    "# sess = tf.Session(config=config)\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.layers import LSTM, RNN, GRU, Dropout\n",
    "from math import sqrt\n",
    "from matplotlib import pyplot\n",
    "from numpy import array\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "os.environ['CUDA_VISIBLE_DEVICES']=''\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (15, 6)\n",
    "\n",
    "from numpy.random import seed\n",
    "seed(1)\n",
    "from tensorflow import set_random_seed\n",
    "set_random_seed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-23T17:42:03.029781Z",
     "start_time": "2018-11-23T17:42:03.023893Z"
    }
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('lstm_data.csv', header=None, names=['datetime', 'load'], index_col=[0], parse_dates=[0], infer_datetime_format=True)\n",
    "df = pd.DataFrame(columns=['time'] + list(map(str, range(int(data.shape[0] / 288)))))\n",
    "for idx, time in enumerate(sorted(set(data.index.time))):\n",
    "    df.loc[idx] = [time.strftime(format='%H:%M:%S')] + list(data.at_time(time)['load'].values)\n",
    "df.index = df['time']\n",
    "df = df.drop('time', 1)\n",
    "dt_df = df.diff(1, axis=1)\n",
    "dt_df = dt_df.dropna(axis=1)\n",
    "scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "scaler = scaler.fit(dt_df.values.reshape(-1, 1))\n",
    "dt_df = scaler.transform(dt_df)  # dt_df is now a numpy array\n",
    "split_idx = int(len(dt_df) * 0.8)\n",
    "train, val = dt_df[:split_idx, :], dt_df[split_idx:, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(data, nlags):\n",
    "    '''prepares data for LSTM model, x=last nlags values, y=(nlags+1)'th value'''\n",
    "    data_x, data_y = [], []\n",
    "    for i in range(data.shape[0]):\n",
    "        for j in range(0, data.shape[1]-nlags):\n",
    "            data_x.append(data[i, j:j+nlags])\n",
    "            data_y.append(data[i, j+nlags])\n",
    "    data_x = np.array(data_x)\n",
    "    data_y = np.array(data_y).reshape(-1, 1)\n",
    "    return data_x, data_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nlags = 10\n",
    "train_x, train_y = prepare_data(train, nlags)\n",
    "val_x, val_y = prepare_data(val, nlags)\n",
    "train_x = train_x.reshape(train_x.shape[0], 1, nlags)\n",
    "val_x = val_x.reshape(val_x.shape[0], 1, nlags)\n",
    "df_last_nlags_plus_one = df.loc[:, df.columns[-nlags-1:]]  # slice last nlags+1 days from df, will be used in prediction of yesterday's data\n",
    "dt_df_last_nlags = df_last_nlags_plus_one.diff(1, axis=1).dropna(axis=1)  #taking last 21 days, differencing and dropping the nan value\n",
    "dt_df_last_nlags = scaler.transform(dt_df_last_nlags)  # df is now a numpy array\n",
    "X = dt_df_last_nlags.reshape(dt_df_last_nlags.shape[0], 1, nlags)  # nlags=20\n",
    "load = np.load('25nov.npy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:20:00.307575Z",
     "start_time": "2018-11-27T17:19:59.867621Z"
    }
   },
   "outputs": [],
   "source": [
    "del model\n",
    "batch_size = 1\n",
    "model = Sequential()\n",
    "model.add(GRU(1, batch_input_shape=(batch_size, train_x.shape[1], train_x.shape[2]), return_sequences=True))\n",
    "model.add(GRU(1))\n",
    "model.add(Dense(train_y.shape[1]))\n",
    "\n",
    "model.compile(loss='mean_squared_error', optimizer='sgd')\n",
    "es = EarlyStopping(monitor='val_loss',\n",
    "                              min_delta=0,\n",
    "                              patience=3,\n",
    "                              verbose=0, mode='auto')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T17:34:56.853629Z",
     "start_time": "2018-11-27T17:20:08.602631Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/20\n",
      "11270/11270 [==============================] - 59s 5ms/step - loss: 0.0374 - val_loss: 0.0231\n",
      "Epoch 2/20\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0371 - val_loss: 0.0238\n",
      "Epoch 3/20\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0363 - val_loss: 0.0225\n",
      "Epoch 4/20\n",
      "11270/11270 [==============================] - 54s 5ms/step - loss: 0.0325 - val_loss: 0.0208\n",
      "Epoch 5/20\n",
      "11270/11270 [==============================] - 57s 5ms/step - loss: 0.0283 - val_loss: 0.0211\n",
      "Epoch 6/20\n",
      "11270/11270 [==============================] - 54s 5ms/step - loss: 0.0270 - val_loss: 0.0201\n",
      "Epoch 7/20\n",
      "11270/11270 [==============================] - 57s 5ms/step - loss: 0.0261 - val_loss: 0.0213\n",
      "Epoch 8/20\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0256 - val_loss: 0.0195\n",
      "Epoch 9/20\n",
      "11270/11270 [==============================] - 56s 5ms/step - loss: 0.0251 - val_loss: 0.0199\n",
      "Epoch 10/20\n",
      "11270/11270 [==============================] - 57s 5ms/step - loss: 0.0248 - val_loss: 0.0203\n",
      "Epoch 11/20\n",
      "11270/11270 [==============================] - 54s 5ms/step - loss: 0.0247 - val_loss: 0.0191\n",
      "Epoch 12/20\n",
      "11270/11270 [==============================] - 65s 6ms/step - loss: 0.0245 - val_loss: 0.0203\n",
      "Epoch 13/20\n",
      "11270/11270 [==============================] - 64s 6ms/step - loss: 0.0244 - val_loss: 0.0190\n",
      "Epoch 14/20\n",
      "11270/11270 [==============================] - 51s 4ms/step - loss: 0.0243 - val_loss: 0.0192\n",
      "Epoch 15/20\n",
      "11270/11270 [==============================] - 50s 4ms/step - loss: 0.0242 - val_loss: 0.0195\n",
      "Epoch 16/20\n",
      "11270/11270 [==============================] - 47s 4ms/step - loss: 0.0242 - val_loss: 0.0193\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_x, train_y, epochs=20, batch_size=batch_size, verbose=1, validation_data=(val_x, val_y), shuffle=True, callbacks=[es])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T16:49:14.606946Z",
     "start_time": "2018-11-27T16:40:28.941836Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0308 - val_loss: 0.0195\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0284 - val_loss: 0.0199\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 52s 5ms/step - loss: 0.0270 - val_loss: 0.0221\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 55s 5ms/step - loss: 0.0263 - val_loss: 0.0201\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 50s 4ms/step - loss: 0.0259 - val_loss: 0.0202\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 51s 5ms/step - loss: 0.0259 - val_loss: 0.0202\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 51s 5ms/step - loss: 0.0257 - val_loss: 0.0196\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 52s 5ms/step - loss: 0.0256 - val_loss: 0.0196\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 52s 5ms/step - loss: 0.0256 - val_loss: 0.0195\n",
      "Train on 11270 samples, validate on 2842 samples\n",
      "Epoch 1/1\n",
      "11270/11270 [==============================] - 52s 5ms/step - loss: 0.0256 - val_loss: 0.0208\n"
     ]
    }
   ],
   "source": [
    "# fit network\n",
    "early_stopping_counter = 0\n",
    "last_loss = np.inf\n",
    "for i in range(10):\n",
    "    history = model.fit(train_x, train_y, epochs=1, batch_size=batch_size, verbose=1, validation_data=(val_x, val_y), shuffle=True)\n",
    "    model.reset_states()\n",
    "    val_loss = history.history['val_loss'][0]\n",
    "    if val_loss > last_loss:\n",
    "        early_stopping_counter += 1\n",
    "    else:    \n",
    "        early_stopping_counter = 0\n",
    "    last_loss = val_loss\n",
    "    if early_stopping_counter == 3:\n",
    "#         break\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T16:39:56.901506Z",
     "start_time": "2018-11-27T16:39:49.968241Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2842/2842 [==============================] - 6s 2ms/step\n"
     ]
    }
   ],
   "source": [
    "val_y_pred = model.predict(val_x, batch_size=batch_size, verbose=1)\n",
    "inverted_val_y = scaler.inverse_transform(val_y)\n",
    "inverted_val_y_pred = scaler.inverse_transform(val_y_pred)\n",
    "Y = model.predict(X, batch_size=batch_size)  # predict for today's values\n",
    "inv_Y = scaler.inverse_transform(Y)  # invert to detrended values' scale\n",
    "rescaled_Y = [x+y for x, y in zip(inv_Y[:, 0], df.iloc[:, -1])]  # last day's values added to inv_Y to get it to original scale\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T16:39:56.917191Z",
     "start_time": "2018-11-27T16:39:56.908065Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "172.73769459771862 75.56106737716667\n"
     ]
    }
   ],
   "source": [
    "val_RMSE = np.sqrt(np.sum(np.square(np.array(inverted_val_y_pred) - np.array(inverted_val_y))) / len(inverted_val_y)) \n",
    "RMSE = np.sqrt(np.sum(np.square(np.array(rescaled_Y) - load)) / len(load)) \n",
    "print(val_RMSE, RMSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-27T16:39:57.498441Z",
     "start_time": "2018-11-27T16:39:56.920639Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f39083a1278>"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3kAAAFpCAYAAAAhueFnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd0VVX2wPHvSSedVAhJSIDQQwkhEKrSpAsoKs2OBRUdyziOzuhv1NGxjQ3FwigoShcEQanSA4QWWiABAqRAGmmkv3d+f9wACUUCJnkh2Z+1sl7euefeu28WEPY75+yjtNYIIYQQQgghhKgbrCwdgBBCCCGEEEKIqiNJnhBCCCGEEELUIZLkCSGEEEIIIUQdIkmeEEIIIYQQQtQhkuQJIYQQQgghRB0iSZ4QQgghhBBC1CGS5AkhhBBCCCFEHSJJnhBCCCGEEELUIZLkCSGEEEIIIUQdIkmeEEIIIYQQQtQhNpYO4Fq8vLx0UFCQpcMQQgghhBBCCIvYuXNnutbau7L9a32SFxQURHR0tKXDEEIIIYQQQgiLUEqduJ7+Ml1TCCGEEEIIIeoQSfKEEEIIIYQQog6RJE8IIYQQQggh6pBavyZPCCGEEEIIUb+VlJSQmJhIYWGhpUOpVg4ODvj7+2Nra/unriNJnhBCCCGEEKJWS0xMxMXFhaCgIJRSlg6nWmitycjIIDExkeDg4D91LZmuKYQQQgghhKjVCgsL8fT0rLMJHoBSCk9PzyoZrZQkTwghhBBCCFHr1eUE77yqekZJ8oQQQgghhBDiGpydnavkOq+99hrvvfdelVzraiTJE0IIIYQQQog6RJI8IYQQQgghhKgkrTUvvPAC7du3JzQ0lLlz5wKQl5dH//79CQsLIzQ0lCVLllw4580336Rly5b06tWLw4cPV3uMUl1TCCGEEEIIcdP4v6UHOJicU6XXbOvnyqsj2lWq76JFi9izZw979+4lPT2drl270qdPH7y9vfnpp59wdXUlPT2d7t27M3LkSHbt2sWcOXPYs2cPpaWlhIWF0aVLlyqN/1IykieEEKJWSsoq4Oy5YkuHIYQQQlSwadMmxo0bh7W1Nb6+vvTt25cdO3agtebvf/87HTp0YMCAASQlJXHmzBk2btzI6NGjcXR0xNXVlZEjR1Z7jDKSJ4QQotZZsieJFxfG4OfWgKVP9cLJ/vp/XWUXlNDA1ho7G/k8Uwgh6pLKjrjVtNmzZ5OWlsbOnTuxtbUlKCjIYpu3y28+IYQQtYbJrHlrxSGenrOHZl7OJGSc4x+L9184fq6olFOZ+de8TnZ+Cf3fX8+/lx+qznCFEELUQ71792bu3LmYTCbS0tLYsGEDERERZGdn4+Pjg62tLevWrePEiRMA9OnTh8WLF1NQUEBubi5Lly6t9hhlJE8IIUT1iPoczCbo8WSluidnFfDsvD1EHctkfLdAXhvRjs9+j+fD1XFENvfE2krx1opYsvNLWDa1Fy19Xa56rQ/XHCE9r4jl+1L45/C2WFnV/b2VhBBC1IzRo0ezdetWOnbsiFKKd955h0aNGjFhwgRGjBhBaGgo4eHhtG7dGoCwsDDuvvtuOnbsiI+PD127dq32GJXWutpv8meEh4fr6OhoS4chhBDieqQdhs8iwcEVXjgGVlZorfntwGm2Hz/L87e1xNHu4ueMv8Sk8NKiGErNmtdGtuOu8ADAGNmb8HUUUccyAejo78bJzHyCvJxY8FgPrMuSN7NZX0jk4lNzGfzhRhq7O3Aqs4AlT/SkY4B7Df8AhBBCVKVDhw7Rpk0bS4dRI670rEqpnVrr8MpeQ6ZrCiGEqHorXwFtgoKzzFy8jJ92J3LH51t47Ptd/G/zcR6ZtZPCEhNaa/676ghP/LCLZt7OLJ/a+0KCB2Btpfjons4MaOPDO3d24KcpPXl1RDt2n8xi5pYETGbNp2vjaPvqrzw3by8p2QW8vuwQDeys+eb+CKwUrD50xoI/CCGEEKLmyXRNIYQQVSt+NcSt5JvS23jA5jdO7lrJjO3W+LjY8/aYUJSCFxfu46kfd+PtYs8P205yZxd/3hoTiq315Z89+ro68PV9F6e23N7JjyV7knj3t8Msi0lm18ksugY1ZOneZJbuTabYZOaVYW1o4eNMeJAHqw6e4blBrYyTY5dDThJETK6pn4YQQghR4yTJE0IIcU1nzxXj4mCDzRWSsApMpejfXibVujGfq/u41+0IL3mnMbx3D1o1crkwRbOg2MRrSw8CMOWW5rxwWyuUqty6OaUUb44OZeAH64k7k8eHd3fi9k5+JJ4t4INVxlq8eyODABjYxpc3lx8iMfMc/gemw5p/GRcJ6AaNO9zQz0IIIYSo7STJE0II8YeKSk30e/937u4ayN+GtK5wrLjUTKnZTKlZ42Jvg4pdikqL5dXiZ3hyRDus03rDgSV09ncFK+sL593fMxhHexusleKOLv7XHZOf+8WtFXxdHQAI8HDkv3d3qtBvQFtf3l6+n/yFT0LSImg3GuLXwvr/wD2zb+CnIYQQQtR+10zylFIOwAbAvqz/Aq31q0qp2UA4UAJsBx7VWpcopW4BlgDHyy6xSGv9r7JrDQY+AqyBr7XWb1fx8wghhKhiMYnZnM0vYXbUCZ7s1wLnsj3rXl2yn5lbT1zo18zLiX+7/U5XrEjw7M2nEYFwoA/smgWnY8Cvc4Xrll97dyOaeTtfs0+wlxMvuq6mZdIi6P089HsFfn8b1r8NKTEymieEEKJOqkzhlSKgn9a6I9AJGKyU6g7MBloDoUAD4OFy52zUWncq+zqf4FkD04AhQFtgnFKqbdU9ihBCiOqw7VgGALlFpSzcmQjAvsRsZm49wW3tfHlpSGv+OrgVjdwcyDx5kBNmH14c3sGY2hnUy7jI8Y2WCf7sCR4oncMqczg5Pf8GSkH3x8HezRjNM5th/yJY9CjkZ1omRiGEEKKKXTPJ04a8sre2ZV9aa7287JjGGMm71nybCCBea31Ma10MzAFu/xOxCyGEqAFRxzJp3ciFTgHufLslAbNZ885vsTR0tOXdsR15tG9zptzSgh8md2eQby4egW25tZWPcbJrY/BsAQmbqi/AvDRY/X+Qe7piu9aw/HmsrKz5Z/F9zNqSYLQ3cDcSvdhlML0nLHgAYubA5g+rL0YhhBDiEs7O156RcqMqtYWCUspaKbUHSAVWaa23lTtmC0wCfi13SqRSaq9SaoVSql1ZWxPgVLk+iWVtQgghaqkSk5mdJ87SvZknD/QM4nj6Od7+NZaNcek8cWsLXB1sL3Y2m7HJOo57wCWTNIJ6w4ktYCq99g3zMyF+TeUDzD0DM4fDpg9g3n1gKrl47OASiFuJdb+X6dS+HZ+uiycpq8A41v1xcPSE4nMw+gtofyds/wryUit/byGEEOISJpPJ0iEAlUzytNYmrXUnjNG6CKVU+3KHPwM2aK3Pz8XZBTQtm975CbD4eoNSSj2ilIpWSkWnpaVd7+lCCCGqSExiNgUlJroFezA0tDG+rvZ8ueEYfm4OTOzetGLnnEQoLTRG7soL6gXFuZCy99o33PAefD8Gsk5d+fiBn2B6L2Pk7th6I8HLOgk9psKpKFj9mtHv0DJY+jQ0CoVuj/HyMGNT2Td/MSp60sAdpu6Gp3ZCx3vglpeM2Dd/BEBRSQkLZ33CwbijlfxJCSGEqOsSEhJo3bo1EyZMoE2bNtx5553k5+cTFBTEiy++SFhYGPPnz+fo0aMMHjyYLl260Lt3b2JjYwE4fvw4kZGRhIaG8sorr1RrrNdVXVNrnaWUWgcMBvYrpV4FvIFHy/XJKff9cqXUZ0opLyAJKL/K3r+s7Ur3+RL4EiA8PFxfT4xCCCGqTlTZeryIYA9sra2Y2K0p7686wl8GtsTB1rpi5/Q449UrpGJ7cB/jNX41+He5+s20hsPLje+ProUu913eZ9uXkHEMznxkjN7ZOsHEhdC0B5QUwNZPIf0IxK2Exh1h7LdgbYN/QxueuKUF7686wndRJ4hNyeHnPck0cnPgrvAARnUOwLvDPbDja3ToWE7+8Bx35EWzLi2Kts9JFU4hhKhVVvwNTu+r2ms2CoUh164JefjwYWbMmEHPnj158MEH+eyzzwDw9PRk165dAPTv35/p06cTEhLCtm3bmDJlCmvXruXpp5/m8ccf595772XatGlVG/8lrjmSp5TyVkq5l33fABgIxCqlHgZuA8Zprc3l+jdSZZsdKaUiyu6RAewAQpRSwUopO+Ae4OeqfiAhhBBVZ9vxTFr6OuPpbA/A5D7N+HhcZ+4Iu8Iy7Ix44/XSkTxnH2jaE/YvMBK5q0mPg7NlhZmPXmHKZl6aMVrX40l4Pg5GfQ4PrjASPIDb3oQm4UaC1+MpeGg1eDS7cPrkPs1o6unIPxbvZ8HORG5t7YOzgw1vLj9Ej7fXMJ070KYS+PIW/HNjOKkaE5ITRda5osr+uIQQQtRxAQEB9OzZE4CJEyeyaZOx5vzuu+8GIC8vjy1btjB27Fg6derEo48+SkpKCgCbN29m3LhxAEyaNKla46zMSF5jYGZZdUwrYJ7WeplSqhQ4AWwty+nOb5VwJ/B42fEC4J6y4iylSqkngd8wtlD4n9b6QNU/khBCiKpQYjKzMyGTMeUSOgdba0Z29LvyCelxYOcCzr6XH2t/B/zyrPHJ6/ltC7ITwcoGXBoZ74+sMF6b3QLHfgezqcLeehz5FbQZWg8HJ0/oNL7iPWzsYdIi47q+7biUg6010yd2YffJLIaFNsbN0VhPGJ+ay/T1x3h7WyKOjiPoYNrHooCXmByUhv/ml1ixbQtD+t167R+YEEKImlGJEbfqUpb3XPbeyckJALPZjLu7O3v27KnU+dWlMtU1Y7TWnbXWHbTW7c9viaC1ttFaN790qwSt9ada63Za645a6+5a6y3lrrVca92y7Lw3q++xhBBC/FmxcXE0KUmgezPPyp2QEQ9eLYxtCi7VdpSR0O2bb7wvyoOvB8CMQVBaNlJ2+FfwDYWwe6EwG5J2XRLQMnALNKbUXI2D2xUTvPPaNHZlfLfACwkeQAsfF94b25FFU3qw0GMyL3l+xAuTRuHfdQQAmXuXV+rxhRBC1H0nT55k69atAPzwww/06tWrwnFXV1eCg4OZP9/4fae1Zu9eY016z549mTNnDgCzZ1fvUoBKFV4RQghRz2iNzy8PsNDuNbo1quSnjhnx4Bly5WNOntC8P+xfaOxNt+m/kJsCWSdg+5dGVc1TUdBqMDS7FVAVp2wW5cHRddB62JWTyCoQFtiQJU/2YvnUXrg42KLcA0hv0Iygs5tJzzMS0YU7E1lQtlegEEKI+qdVq1ZMmzaNNm3acPbsWR5//PHL+syePZsZM2bQsWNH2rVrx5IlSwD46KOPmDZtGqGhoSQlXbE0SZW5rsIrQggh6ocTG3+gae4BUOCy7yvo/48/PqE4H7JPgecfrDEIHQtxv8G+ebDlEwi9CwrOwoZ3jVE+bYaWQ8DRA5qEGVsp3PI349yja8BUBG2GV91DXkX5qTRWLQcSvmcGi3YfJV814PVlB3FxsGFUJz9js3chhBD1io2NDd9//32FtoSEhArvg4OD+fXXX7lUcHDwhVFAgDfeeKNaYgQZyRNCiHqvxGTm2bl7ePmnfRxMzuFgYgas/RdHVSAFLYbBtunGSBtASSGc2nH5RTLLthrwanH5sfNaDQFbR1jypLHWbsBrMOh1KMqFlf8AJx/w62z0bd4PkqKNJBCMLREaeEBA96p67Erx6DgMe1XK9nWLeX3ZQYI8HcktLGVvYnaNxiGEEEJcD0nyhBCinvvPilgW7U5i/s5Ehn68kXlfvEFTTuM64t80GPiKsWH4lk+M6pYzh8OMAXAyquJFLlTWvMp0TQB7Z2g1FMwl0PMZcGsCPm2MNXjmEmg5CKzKfi0172+M7B1ZCSe2GiOArYaCdQ1PQAmMpNjakS7F0Qxo48v8x3pgpWBjnOzhKoQQ9U1QUBD79++3dBiVItM1hRCiHvt1/2m+3nSc+yKb8peBLfl5+xFGbVhEQaNIvDsPN9a/tRsF274w1tPlpYKVLRxaCoHlRtXSzyd5zf/4hj2eNK7Z46mLbbe+DCkx0LncVE//cLB3hZ8eMd5b2ULnCVXz0NfDxg6rZn0Zc2oXd7fahe26WbzZsJQlh++EAS1rPh4hhBCiEiTJE0KIeupkRj4vLNhLB383/j6sDfY21txbuhDMWTD0zYsFTvr+DQ4shtJCeOAXWPdviP0FBr1xsU9GHLg2ATunP76pX2e44+uKbc4+8Mi6im3WtjDkHUg/DP4REBABTl5V8+DXyabNUGziVsCvL4CDG+MKs+mat468o9/i3LybRWISQoj6SGtdY1sQWIr+o/1kr4MkeUIIUQ+dzMhnwowoFDBtfBj2NtaQcRS2fgodx4F/l4udfVrDA8uhYTC4NjamTf7yLKTFGtMtoayy5h+sx7sRncZV7fVuVMfx0DDIeH43fw5vWYLLyr/g+P0QGPIfiJhs6QiFEKLOc3BwICMjA09Pzzqb6GmtycjIwMHB4U9fS5I8IYSoZ+LO5DJxxjaKSs1891A3AjwcjQO/vgTW9kZBlEs17XHx+/NJXuwvRpJnNhvTNTuMrYnwa561DQT3ufC2WfeR9Flp5n8uX9Nm+fNgKobIJywYoBBC1H3+/v4kJiaSlla310Q7ODjg7+//p68jSZ4QQtQjKdkF3P1lFFZKMfeRSFo1cjEOHPnNKG4y8HVwafTHF3FtDE26wOHl0Od5Y5+7omwIjKz+B6gFbK2tCG0eyGPJz/B7Wy/Ub3+nsKAAh1ufq7Y9/IQQor6ztbUlODjY0mHcNKS6phBC1CNztp/ibH4xP07uZiR4WhsjckufNipjdnuschdqNRSSdhoblK9+FUJug/Z3VG/wtUjvlt6cyCrhA9cXWW3TB4cNr7Pp3TtZt+84ZnPZeooqWlchhBBCXC9J8oQQop4wmzULdibSs7kXIb4ukLQLvhsFc8aDg5tREMXGrnIXaz3MeP3xHqPYyshP6tUoVp8QowjMJ78nML3hC2xoMpke+WtoMn8Y895/itIZg+F1b9gxw8KRCiGEqI9kuqYQQtQTUccySMoq4L8dTsGMf8KpKHBwhyHvQviD17cHnXdroxDJ2eNw5//Axbf6Aq+Fmno6MX1iF5q4NyDU3w3oQ2n8MALnPUjLc99xrKgZTb1aY/3by8Z6Pq8/2D9QCCGEqGKqqsp0Vpfw8HAdHR1t6TCEEOKm95e5e8g7tIqveMOoFtntMeg0ARxcb+yCB36CrJPQ8+kqjfOmVnyOtTHHeWTRSfo2NvH1uadQns3gwZU1v5G7EEKIOkMptVNrHV7Z/jJdUwgh6oGcwhJW7E/hEY89YOcCU7ZB98dvPMEDaDdaErxL2TnRL7w9n47vzJokK34NetFYu7jpA0tHJoQQoh6RJE8IIeqBX2JSKCkpofO5zdBqMNj++T14xNUNbt+YrkEN+TClHYSOhd/fhkPLLB2WEEKIekKSPCGEqOOKSk18H3WCMR4J2BSdhba3WzqkemF4Bz8On8klPuJ1aBIG8++HuFWWDksIIUQ9IEmeEELUYaUmM8/M2cOB5Bym+B4AW0do3t/SYdULQ0IboRT8HJsLExaAb1uYOxGOb7R0aEIIIeo4SfKEEKKO0lrz95/2sWL/af45rBXBqWshZBDYOVo6tHrBx8WBbsEeLItJRju4waTFFDbw5dzyVywdmhBCiDpOkjwhhKijPlkbz7zoRKb2D+HBwFQ4lwptR1o6rHpleAc/jqWd41BKLr+fKuWrrC44pO5lze4jlg5NCCFEHSZJnhBC1EGHUnL4eE0cIzv68ZcBIXBwCdg4GCN5osYMad8IayvFB6sO8/j3uzjlFoG10sxbMIcle5IsHZ4QQog6SpI8IYSoY0pNZl5cGINbA1teG9kOVZQD+xcaa/HsXSwdXr3i6WxPj+aerD6UipeLHc8/PAFt68go9ziembuHxbsl0RNCCFH1ZGdWIYSoA2ISs0jJLqR9EzeW7U0mJjGbT8Z1xsPJDpb9DfIzoM/zlg6zXnqwVzAZecVMmxCGj7sTBEZyW/ZhugV78Pz8vXg42dGnpbelwxRCCFGHSJInhBB1wGPf7SQ5u/DC+4FtfRneoTGc2g7R/4Nujxll/EWNu7WVD7e28rnY0KwvVqv+yVdP+jP2+xIe+34ncx7pTgd/d8sFKYQQok6R6ZpCCHGTS8stIjm7kPsim/L6qPY83CuYf48ORZlLYenT4OoH/V62dJjivOC+ALgkbWHmgxE0dLTjoZnRFJWaLByYEEKIukKSPCGEuMntT8oGYEhoYyZ1b8orw9vi7WIP0d9A6kEY+p6sxatNGnWABg3h+Hp8XR341+3tSMstYuvRDEtHJoQQoo6QJE8IIW5y55O8dn6uFQ/ErwavltB6qAWiEldlZQVBveHYetCani28cLSzZuXBM5aOTAghRB0hSZ4QQtzk9iVlE+zlhIuD7cVGrSEpGvwjLBeYuLpmt0BOIpzajoONFbe08mbVwTOYzdrSkQkhhKgDJMkTQoib3IHkHNo3cavYePa4UVHTv4tlghJ/rMUAsGkA/xsE77fmWfNM0nIL2ZOYZenIhBBC1AGS5AkhxE0s81wxSVkFhDa5ZKpm4k7j1b9rzQclrq1hU5iyBYZ9AI070OLoTHpYx7LygEzZFEII8edJkieEEDex8+vx2vtdMpKXuANsHcG7jQWiEpXi0Qy6PgR3zQIHN55y3cjKg6ctHZUQQog64JpJnlLKQSm1XSm1Vyl1QCn1f2XtwUqpbUqpeKXUXKWUXVm7fdn7+LLjQeWu9VJZ+2Gl1G3V9VBCCFFf7DtfdOXS6ZpJ0eAXBtayHWqtZ9sAOk0gonAT2WnJxKfmWToiIYQQN7nKjOQVAf201h2BTsBgpVR34D/Af7XWLYCzwENl/R8Czpa1/7esH0qptsA9QDtgMPCZUsq6Kh9GCCHqmwPJ2TT1dMStQbmiKyWFkBIj6/FuJl0ewFqXMtZ6Pb8dkNE8IYQQf841kzxtOP+xom3Zlwb6AQvK2mcCo8q+v73sPWXH+yulVFn7HK11kdb6OBAPSNk3IYT4E/YlZV8+VfP0PjCXyHq8m4l3Swjqzf32vzNv+wlKTWZLRySEEOImVqk1eUopa6XUHiAVWAUcBbK01qVlXRKBJmXfNwFOAZQdzwY8y7df4RwhhBDXKSu/mFOZBZdX1kzcYbw2Ca/5oMSNC3+ARubTNM3expI9yZaORgghxE2sUkme1tqkte4E+GOMvrWuzqCUUo8opaKVUtFpaWnVeSshhLhpHUjOASD0SuvxXP3BtbEFohI3rPUItJM3U5zWMW1dPCbZM08IIcQNuq7qmlrrLGAdEAm4K6XOr+j3B5LKvk8CAgDKjrsBGeXbr3DOpff5UmsdrrUO9/b2vp4QhRCi3og6lgFAO79Lt0+IlvV4NyMbO1SX++lWsoPSjGMsi5HRPCGEEDemMtU1vZVS7mXfNwAGAocwkr07y7rdBywp+/7nsveUHV+rtdZl7feUVd8MBkKA7VX1IEIIUZ+cySlkxqbjDGzrS0MnO8jPhENLYe2bkHVC1uPdrMIfAisbnnFZy6dr4zHLaJ4QQogbUJna2o2BmWWVMK2AeVrrZUqpg8AcpdQbwG5gRln/GcB3Sql4IBOjoiZa6wNKqXnAQaAUeEJrbaraxxFCiPrhPytiKTVpXhnWBgqyYHovyEkCFHi3hpZDLB2iuBGujVHtxzDi4DL+mXo7G+LSuKWVj6WjEkIIcZO5ZpKntY4BOl+h/RhXqI6ptS4Exl7lWm8Cb15/mEIIIc7bdfIsi3YnMeWW5jT1dIIlT0DuaRg3F4L7gJ2jpUMUf0b3x7GNmcs9NuvZkRAqSZ4QQojrdl1r8oQQQlhWRl4Rr/18AF9Xe564tQXEr4Hd30PPqdBqsCR4dYFfZwiM5CG7Vew5kWHpaIQAYPXBM3y7+TjH089ZOhQhRCVUZrqmEEIICyoxmdlxPJN50adYvu80xSYzn47vjBMFsPRp8GoJff9m6TBFVer2GI1P3keTxBWYzD2wtlKWjkjUY9kFJUyds5v8YhMsPUiQpyOP9m3OXeEB8mdTiFpKkjwhhKiFikpNrD2UyrKYFDYcSSO3qBQXexvGdwtkQrdAQnxd4Ne/Q3YiPLQSbB0sHbKoSm1GcNatHc9lfUf8qcdp1VS2lRWWMz/6FPnFJr66N5zT2QX8tDuJlxbt4/uoE/zr9nZ0aepRoX9GXhEeTnYodY0EcO2bcHgFPLYRrtVXCHFdJMkTQohaIr+4lG3HMlkbm8rSmGSy8kvwdrFnWIfG3Nrah94hXjjalf2znXEUtn8JYZMg4LLl0eJmZ2VN4aB38J03nLPr/g33T7N0RKKeMpk1325JICLIg4FtfQGY2L0pS2NSeGv5Ie75MopFj/ck1N/Yr3P5vhSmzN7FgDa+/Ht0e3xc/+ADqAM/QUYcpB0Gn2rdglmIekeSPCGEqAU+Wh3HtHXxFJvM2NtYMbCtL2PDA+jVwuvK06FWvwrWdnDrKzUfrKgRjdr2ZIHVQMYk/AinH4NGoZYOSdRDqw+dIfFsAS8PbXOhTSnFyI5+9G7hxZCPNvL0nN0sm9qLjLxiXlwYQ1NPRzbGpTHgg/W8Pqo9tzcthcVToN0oiJhsXCQ7yUjwAOJXSZInRBWTJE8IISwsNbeQT9fFEdnci8m9g+ka5IGDrfXVT0jYbOyJd+sr4OJbc4GKGqWUYmPA4ww4tY2Gy/8KD66wdEiiHvpm83GauDe4MIpXXkMnOz64qyMTZmzjtZ8PEJ+aBxq+f6gbJSYzz8/fy6x58xji8jF2RZmQfRK6PmxMzTy+3riIvRvErYIeT9XwkwlRt0l1TSGEsLAft52ixKR5bURbeod4/3GCZzbDypfBtQlEPlFzQQqLaBUcyNfFt8HJLcaG90LUoEMpOUQdy2RSZFNsrK/8X8YeLbx4pE8z5kUnsutkFv8eE0qAhyPNvJ35secZfrR7kzNFdpzr+hRknYTk3caJx9aDo6cx5fzkVijKq8EnE6LukyRPCCEsqLjUzOxtJ+jb0ptm3s7XPiF5t/HV90XZLqFP7aMzAAAgAElEQVQe6Bzgzj4dbLw5c8CywYj6wWyCo+swH9/EZz+txc1ecU/XgIvHC84aBVNyT19oem5gK/q29OaRPs0Y0dHPaDywGPvFD2Nq1Imxptd5+lQftJWNsQ5Pa2MkL7gvhAwCUzEc33BZKFprSkzm6n5iIeokma4phBAW9OuB06TmFvGfO4Iqd0LCRuO11dBqi0nUHh0C3InVQcab0/sguLdF4xF1mNYQuwzWvgFpsVgBnwBFdu7YJ3wCbUfCuXT4bpTxZzE7EUZ/DoCdjRUzHyxXAOrQUlj4EPiH02DiQp7dl8VfF8Rwqkk3Ag8uhs4TITcFmvWFwEiwczbW5bW++O9aQbGJh2buICu/hJ+f7HnVkUQhxJXJ3xghhLCgmVsSCPJ0pG9L78qdkLAJvFqBcyX7i5uas70NHr7+ZFk1hDP7LR2OqMt+eRbmTgSzibRB03jI9DL/8/gLdt7BMG8S/DwVvhkK6XHQ7FaImWNU+b3UiS0w/wFo3AkmLAB7F8Z28adHc0++z+lsTNnc9KHRN7gv2NgZr3GrjUQTYwuZR7/fyZajGRxMyeGXfSk1+IMQom6QJE8IISxk98mz7DxxlkmRQVhVZkNhUymcjIKgXtUfnKg1wpo2ZL8pkNLkvZYORdRlh5ZBq2GYHt/KlJhmbLfuyJD7XkQ9uBJ6TIVdM43RuwkLYMyXYG0P6/9T8Rq5Z2D+/eAeCBMXgoMrYBQRGhvuz5zcDpitbGHvD+DeFDzKpiKHDDCKsqQfodRkZuqPu9lwJI23x4QS4uPMtHXxmM26Zn8eQtzkJMkTQggLSEg/x6Pf7cTbxZ6x4f6VO+n0XijOhaCe1RucqFXuiwzioDkQnXoYXVps6XBEXZR7Bs6lQlAv3lkVz46Es/zfyHY0dmtgjLQNeh0eWgWT1xhThp19IOJh2DffGNkD40OoBQ9CYQ7c/R00cK9wi9vaNcJk58YRxzCjoVnfiwdbDATAvOYN3vp2Eb8dOMOrw1tzT4tSnuvhxpEzeaw8eKYmfhJC1BmS5AkhRA07lZnP+K+iKDVrZj/cDVcH28qdmLDZeG0qI3n1SatGLgS3j8SWEtZt3mzpcERddGYfAJvyGvPF+mNM7B7ImLBLPnwKiACfi3vl0fMZsGlgTPPc8B7Mvw9ObIIRH4Jvu8tu4Whnw5DQxnyX28VoCC6X5LkHUBrxKObY5fzj1EPs9fgbD2zoAx935rb1o+jWMJdp6+LRWkbzhKgsKbwihBDVSGvN4TO5rDmUSuzpXFJzCjlyJheTWfPjI91p6etS+YslbALPENkbrx7qd0s/OASr162mXedIfF0dLB2SqEtOG0nesxtKiQhqxD+HX56kXcbJCyKnwIZ3jcqYto5G4tfxnqueckeYP/fu7M7Y7r50anv7hfZSk5lHUseyp7AzX3Q6SldTDDQMAs8WqLVv8LnDR0Qm/ZV50ae4KzwApSoxvV2Iek6SPCGEqCbbj2fy7Lw9JJ4tACDQwxFfV3t6tvDisb7NaefnVvmLmU3GXlLt76imaEVtZu0VgtnanhYlx3lxYQzf3N9V/qMrqs7p/aRZeWNt78FnE8Ows6nkRK9bX4aIR8HeBWyv/cFDt2APfNxd+CCzB7OsL85g+M+vsayNTeWNUT3o2n1cxZPc/PGYM46P3X7k0YV2/Lw3mVeGtaVNY9freUIh6h2ZrimEENUg7kwuD8/cga21FW+NCWXb3/uz4a+3Mv/RSD5ttY/2DunXd8HTMVCUI0VX6itrG6x82zLYK53fD6cxd8cpS0ck6pDi5Bj2lATwUK9gvJztK3+iUkal30okeABWVooxYU3YFJfGmkNn0FqzZE8SX208zn2RTZnYvenlJ7UeCr2f57ai35jTaR8HknMY+ekm4lMvbp6eV1TK4A83sFyqcApxgSR5QghRxVJzCrn/mx3Y2Vgz68EIxkUEXpxed3ofLC0rRZ55vPIXTdhkvDaVoiv1lm97GhfG06OZB68vO8ipzHxLRyTqgpICbDLjidWBDO/gV+23G98tED/3Bjw0M5phH2/ixYUxRAR58Mrwtlc/6da/Q8shdI99m/WD01EoZm1NuHB40a5EYk/n8u2WhKtdQYh6R5I8IYSoQiaz5uFZ0WSeK+ab+7sS4OFYsUPsL4ACUxHMGgk5yVe/WNYpWPMv+Olx2PYFeDQH18bVGr+oxRp1QOVn8N4QH5RSPD9/r5SVF3+aTj2EFWaKvdrTyK3613o2dmvA2udu4Z07O1BQYsLTyZ5pE8Kw/aPNzq2sYew30LQnbr8+xV+Dj7NwZyK5hSWYzZqZWxJQypgin5xVUO3PIMTNQJI8IYSoQstikolJzObtO0IJ9b/CmrvYXyCwO0xcBPln4esB8MPdsPBh2Pnthc2AyUmGb4cZmwYfX28UOej5dI0+i6hlGrUHwK/gKK8Ma8O245msP5Jm4aDEzS7lcDQAzUO719g97WysuCs8gDXP9mXd87fg7VKJKaK2DWDcj9AolAdTXqNhyWl+2p3Epvh0jqad46l+IYDxb7AQQpI8IYSoMiaz5pO18bTydWHElaY9nT1hlCpvPQyahMHEBeDZwkjoTkbB0qeNhC/tCMwaBfkZ8PAqePYgPPI7dLmvph9J1Cbny9Kf2ceozk2ws7FiU/x1ru0U4hIph7eTpx3o061rjd/bykpVvsgLGJur3/UdylzCVPfNzNp6gm+3JODlbMcTtzano78bS/ZIkicESJInhBBVZvm+FErS4vne/i2soqZdHJU77/By47XVUOM1sDvc9zM8thGe2QdD3oFj62BaV8g6AePmQJMuNfsQovZycDPKyifvwcHWmvCmDdlyNMPSUYmbmNYa69QDpNg3w8P5JtmWwz0AFXIbI8xrSUjNYm1sKuMjArG3sWZkpyYcSM6pUJRFiPpKkjwhhKgCZrMm6rcfWWb/D7zSd8DKl40pmMXlimPE/gLebcCz+eUXUAq6PQoPr4EWA+Du7yG4d809gLg5+HeFxB2gNT2ae3IoJYeMvCJLRyVuUjsTMmlmPo5V41BLh3J9utxPg6J0RjaIwcZKMaGsKufwDo1RCn7eK6N5QkiSJ4QQNyjzXDH/WnqQd36NZem3b/P6udcxuQWgntwB/f8J+xfCjEFGRc38TDix2Ziq+Ucad4CJCyFkYM08hLi5+EdAbgpkJxLZ3AuAqGOZFg5K3Izyi0v5eNEaXFUBTdpEWDqc6xMyEFyb8KLXFl4a2uZC9WJfVwe6B3uydG8y+tKZFELUM5LkCSHEDZqx6Rj/23ycLzYcJSxhBrE2LXGZshY8gqH3czB+HuQmwxd9Yd69oM3XTvKE+CP+4cZr4nY6+LvhZGfNlqOyLk9cH601f1u4D+fM/QA4+HeycETXycoawu7FN20LD7VTFQ6NDmvC8fRzrDp4xkLBCVE7SJInhBA3oKjUxJztpxjQxpf4KY0IsEojZMiTWNs7XezUchA8GQ2dJ0DCRnBtAn6dLRe0uPk1CgWbBnBqB7bWVnRr5slWWZcnrtM3mxPYsXcf7zj9CC5+F4v63Ew6TwJlBbtmVWge3bkJIT7OvPHLIQpLTBfaZWRP1DeS5AkhxA34df9pMs4VMymyKerAIrCyxbbdiMs7OnrAyE9g8joYP9dYeyfEjbK2NT4oSNwBQI/mnhxLP0dKtuwNJionKauAT5fvYIHL+zipQpgw39ie4Gbj1sQoYrX9a8g9faHZ1tqKV0e042RmPjM2HQdgzaEzhL+xms7/WsnwTzby6pL9lJrMlopciBohSZ4QQlwPUwnMHkvKms8J8nSkd3MPOLAYmveDBg2vfl6TMGMURog/K6ArpOyFkkIim3sCyGieqLQftsTzuc37+JmSUPfMvrD/4k1p4L+gtBBWvFihuVeIF4PbNeLTtfG8vSKWh2dF4+vqwNDQxrjY2zJz6wlW7D99lYsKUTdIkieEENdj33yIW8kDOZ/zZPtSrJJ3Qk4itB9j6chEfeEfAeYSSNlLm0auuDvasjlekjxxbYUlJry2v0s3q1jUqM8huI+lQ/pzPJtD37/CwcVweEWFQy8Pa4NZa6avP8qIDn4sfLwHb44OZfbD3Qj2cuKrjcdkCqeo0yTJE0KIyjKbYOP7nLEPIp8GjDr5byPps7a/uPedENXNv2zT6sTtWFkpIpt5sv5IKtkFJX/qsrrsP8Syx1jdtW31fB5gCadDxkGHsZYOp2r0mAo+beGX5yA1FvLSwFRKgIcjH9zViX+PDuWjezrRwM4aMDZgf6hXMDGJ2Ww/LpVpRd0lSZ4QQlTWgZ8gI57Xz41iReCz2KTsgu1fGeW8HVwtHZ2oL1x8wT0QTm0H4JE+zTibX8JLi2L+1MjET7uTeHtFLDM2HauqSEUtonPP0GH7iyRYBeI79gNLh1N1bOxgxMeQkwyfdYP3WhhfSTsZ1qEx47sFoi5ZC31HmD8NHW35auNxCwUtRPW7ZpKnlApQSq1TSh1USh1QSj1d1j5XKbWn7CtBKbWnrD1IKVVQ7tj0ctfqopTap5SKV0p9rC79WyeEELWV2Uz2b29xxNyE034DGTbuSWg9HNDQbrSloxP1jX/EhU3ROwc25PlBrVi+7zSzt528ocvlFpbw7+WxAGyMS5dpbHXQ2YXP0MB8jv09/ouyc7R0OFUroCs8thHGfAVD3gV7F5h9F2Re+QOLBnbWTIoMYvWhMxxNk5FrUTdVZiSvFHhOa90W6A48oZRqq7W+W2vdSWvdCVgILCp3ztHzx7TWj5Vr/xyYDISUfQ2umscQQojqtXnZt7jlxbPG+15mPdwdN0c7GPER3PoKtLlCVU0hqlPAxU3RAR7t04w+Lb3517KDHEzOue7Lfbg6joxzRYzt4k/i2QJOZORXdcTCgnR6HO4JK5ilRtCvzy2WDqd6NAqFDndBt0dg4iJjX9Lv74BzV95H8t7IptjZWPHVBhm5FnXTNZM8rXWK1npX2fe5wCGgyfnjZaNxdwE//tF1lFKNAVetdZQ2PiKcBYz6E7ELIUSNKCwxoXd/R6qVDw89+iyOdjbGAScv6PsC2NhbNkBR/wRGGq9H1wDGOqMP7upIQ0dbJs7Yxv6kbMBYZzc/+hQfr4mrsGdYeUfO5PLtlgTu6RrI47c0B2Bj/B9vsJ5fXMrma/QRtceRn96iRNvg1GvKxX+/6jKvEGPLmpxk+DQc5t8Pu76D0qKLXZztGR8RyLzoUxw5k2u5WIWoJte1Jk8pFQR0BraVa+4NnNFax5VrC1ZK7VZKrVdK9S5rawIkluuTSLlkUQghaqsFUUcIN+/D1GoodnZ2lg5HCGPUwqMZ7L84icbL2Z4fJ3enga01476MYvHuJMZ9FcULC2L4YNURRnyy6ULyV95/VsTibG/DX29rRbCXE03cG7ApLu0Pb//+yiNM+HobpzJlxK+2O3gkjqDEn4lyHcT4/uGWDqfmBETAfUuNolgno+DnJ2HJE1BuKvLT/UNwtrfh9WUHZYqyqHMqneQppZwxpmU+o7UuPxdkHBVH8VKAQK11Z+BZ4Ael1HVVJFBKPaKUilZKRael/fEvGiGEqE7FpWb2rP8ZB1VC4/DbLR2OEAaloP0dkLAR8lIvNDfzdmb+Y5F4u9rzzNw9HEjO4e0xoXz7QFdyCksYNW0zv8SkXOh/PP0ca2JTub9HEA2d7FBK0auFF1uOZmAyX/k/vTmFJczdcQqA6BNSnbA2S88rYvu8/2CrSul89z8uK0BS5wVEwKjP4NlDcMtLRjXk3d9fONzQyY6nB7RkY1w6vx+W/2+KuqVSSZ5SyhYjwZuttV5Urt0GGAPMPd+mtS7SWmeUfb8TOAq0BJIA/3KX9S9ru4zW+kutdbjWOtzb2/v6nkgIIarQ4j1JdC7cRqmNEzTtaelwhLio/R3GuqODSyo0+7k3YP6jkbw4uDVrnu3LPRGB3NLKh9+e6UNbP1deW3qA/OJSAGZtTcDWWjGhW+CF83uFeJFbWEpMYhYAB5NzLnwPMGf7SfKKSrG1Vuw6kYWofUxmzextJxj+3m/cXrKC7MCBuPq3sXRYlqMU9HkBgvvC8hcg9RCUFkNKDJNCnQj2cuKNXw6ycGciryzex0uLYig1mS0dtRB/yjUnZpetuZsBHNJaX1pzdwAQq7VOLNffG8jUWpuUUs0wCqwc01pnKqVylFLdMaZ73gt8UlUPIoQQVc1k1ny+Lp55dnuxbnGrrL0TtYtPG2N/sP0LIWJyhUOezvYX1ted5+5ox6sj2nLH51v5euNxHuwVzPzoRIaFNsbH1eFCv54tvADYFJdOYYmZB77djlnD9w91o3OgO99sTqBbsAe21lbsPHG2+p9TXJdSk5nxX21je0ImH3j9QsO8PBjwvKXDsjwra6P65vReMOM2KC0AUzF29m58FPY6I9d58dz8vTSwtaagxESbxq7cGxlk6aiFuGGVGcnrCUwC+pXbFuH8rr/3cHnBlT5ATNmWCguAx7TW5+dzTAG+BuIxRvhW/NkHEEKI6pCeV8TkWdE4ZB7C25yOainFgEUt1H4MnNx6ocrmtXRp6sGQ9o34Yv1Rvlx/lLyiUu7vGVyhj4eTHe38XJm/M5EHv91BQENH/Bs24OGZO/h4TRwp2YVM7t2MsKYNiT2dQ15RaXU8mbhBa2NT2Z6QySc9Chh9bh50mgiB3SwdVu3g4gtjvzV+Ht0eg9FfglcLOmydSlToUlZN7cb+/7uNHs09eX/lEc6eK7Z0xELcsMpU19yktVZa6w7ltkVYXnbsfq319Ev6L9RatyvrF6a1XlruWLTWur3WurnW+kktq1yFELVMcamZX2JSGPzhBjbFp/NGu7JZ5SGDLBuYEFfSbozxeuCnSp/ywm2tKCo18/HaeDoFuNMpwP2yPr1CvDiZmY+fuwM/TO7OzAcisLe15pO18TTzdqJfax/CAt0xa4g5JVM2a5Mftp+kuUspw4++inJvCkPetnRItUtQT5gwHwa9Dh3vhgd+hZ5P0yjuR0LivsHaSvHqiHbkFZXywaojlo5WiBt2XdU1hRCirjqVmc9z8/YS/sYqnvhhF17O9ix9shddCreDX2fjE2AhahvP5safz71zwVy5NUTNvJ0ZX7YG74GeQVfsMyGiKWO7+PPj5O54u9gT4OHIzAci8HNz4C8DWmJlpegc2BBApmzWIqcy89l1JIHpLv9D5Z6GO2YYG4OLq7Oxg4H/gpDbIOozKMqjVSMXJnYLZPa2E/x+OJX41DxSsgssHakQ16UebJYihBDX9urPB9h6NIOhoY0ZGtqI3iHe2GUdhcQd0PdFS4cnxNV1nQxLpsDuWdDl/kqd8vxtrQjxcWZYaOMrHg/0dOTdsR0rtLX1c2Xz3/pdqNDo1sCWlr7O7DopSV6tcC6DlAX/ZLPdQlwyC2Dg6+DfxdJR3Tz6PA8zBsLOb6DHU/xlYEt+3pvM/d/suNDl63vDGdBWPvATNwcZyRNC1HtpuUWsP5LGfT2CeP+ujvR3TcJuwSSYFgHWdtButKVDFOLqOo2HoN6w8p+Qk3Lt/oCrgy2TIoOwsb6+/wZcWoI/LLAhu05mYb7Kdgui5pgXTaZL8g8cdO4Oj26AnlMtHdLNJSACgvvAlk+gpBB3RzuWTe3NZxPC+HhcZ7xd7JkXfcrSUQpRaZLkCSHqvSV7kjCZNXd2aQLn0uHb4XBiM/R8GqbuAp/Wlg5RiKtTCkZ8BKYiWP58hc2eq1tY04ZkF5RwLP1chfbT2YUs3p0kyV9NOXsCq6Nr+LhkNLnDvoDGHa99jrhc7+ch7wzs/g6AJu4NGBramJEd/RjZ0Y91h1PJypdiLOLmIEmeEKLeW7griY7+brTwcYEtHxultR9cCQNeAzf/a50uhOV5Njc2e45dBvsW1NhtuzQ11uXtKrcuLyu/mPFfR/HM3D28vHifJHo1oCh6FmYUG5wGcUsr2V/4hgX3Af8I2PwxmCpWjR3duQklJs3yfactFJwQ10eSPCFEvXYwOYdDKTmMCfM3RvG2f21sMu3d0tKhCXF9Ip+EgG6w+HE4srJGbtnMywl3R1tW7E8hp7CEolITj363k8TMAkZ3bsKP20/x/Py9srF0NTKVlpIXNZNN5lBeuGvAdU/BFeUoZUxzzT4JcRX/DrXzc6WFjzOLdxsVl7XWfLc1gSV7kpBi8aI2kn8JhBD12qJdidhaK0Z29Ctbi5EPff5q6bCEuH7WNjB+Hvi2hbkT4ei6ar+lUoq7uwaw7nAaPd5ay13Tt7LteCbvju3Af+/uxPODWrJodxJDP97Im78cZFNcerXHVN/MnTsTT1MaKuxeepRtZC/+hJaDwbmRUYClHKUUozr5sT0hk1OZ+Xz2+1H+seQAT8/Zw91fRBF7OsdCAQtxZZLkCSHqrVKTmcV7kunX2oeG5MD2r2QUT9zcGrjDpMXg2QJ+HAcZR6v9li8NacOyp3oxoI0PB5Jz+OvgVtzeqQkAT/YL4f2xHfFwsmPmlhNMnLGNFfsqVxxGXNvvh1Nxi51DvrUbvYffa+lw6gZrWwibBHGrIKtioZXzf66nztnNu78dZnTnJrw1JpS41FyGfLSRoR9t5NUl+4lOyLRE5EJUoGr7EHN4eLiOjo62dBhCiDpoxcZtHP5tOhMCzuKdexDyUuGJbeDdytKhCfHn5KTARx2h8wQY/t8au21xqRk7myt/flxQbCLy7TUMaOPLe+W2Z3hl8T48nez5y0D5cOV6/eWb1bxz4m6suk3GWjY9rzpZJ+HDDtDnBej3coVDY6dvYUfCWfq39mH6pC7YWltx9lwx30WdYPvxTHadPEupSbP1pX54Ottb6AFEXaSU2qm1Dq9sf9knTwhR/5w5QOnv7zLo0BIG2YBVaSsI7gttRkiCJ+oG18bQ4S7Y8yPc+go4edbIba+W4AE0sLOme7AnW+LT0VqjlCI1t5Dvo04C4O5oywM9g2skzrogPa8I36MLsbUphTAZxatS7oEQMtCostn3RWMqdJnnBrVi6d5k/jG8LbZl6x8bOtkxtX8IAHFnchn43w3MjT7FlFtaWCR8IUCmawoh6ptz6fDNEExHVvJV6VD2jd2EeiIK7vgK2o60dHRCVJ3IJ4xKsTv/Z+lILujZwpPk7EJOZOQDsC42FYCO/m68vuwgaw6dAaDEZCYpq4CdJ87y6/7TpOUWWSzm2mrJrpNMsFpFvl93Yx2mqFpd7ofcFIj7rUJz92aevDk6FAdb6yueFuLrQmQzT2ZHncQklWWFBclInhCifln3JroojztK3yGgdWcea9fO0hEJUT182kDz/sZa0x5TweYqU8cKzkJpEbg0qvaQzhcG2Xw0nSAvJ1YfSsXPzYEfH+nO3V9E8fjsXbg62JJxrqjCdn/DQhszbUJYtcd3s9BaczJqMQFWadDzPUuHUzeF3AauTeCX58DexdheoZImRTZlyuxdrItNZUBb32oMUoirk5E8IUT9cXo/7PyWLQ1Hcdjsx9+GyCbnoo6LnGJs7rx/0dX7LJ4C03vDuYxqD6eZlxONXB3YEp9BYYmJTXHp9G/ji6OdDTPuC+f2jn4MaOPD1H4hvDUmlG/u78rtnfxYE3uG/OLSa9+gntiXlE3/3CWcs/eB1sMsHU7dZG0D4+eCnTPMHAmrX7ts77yrGdjWF19Xe76LOlG9MQrxB2QkTwhRP2gNv72E2d6Np88MZnxEIE09nSwdlRDVq3l/8G4Nmz6AdqPAtkHF48XnIH4NmIpgxV/hzhnVGo5Sih7NPfn9SBpbj2ZQUGKifxsfAHxcHXi3XEGW8xxsrVmyJ5nfD6cxNLRxtcZ3s1i7aRPPWO+jMOLvRjVIUT0ahcKj6+HXl2DTf8HWCfq+cM3TbK2tGBcRyIer40hIP0eQl/yuETVPRvKEEPXD4RVwfANbAx8h3eTExO5NLR2RENVPKf6fvfsOr6rK+jj+3emVkJBCDSQh9E7ovYqAIlZsoKjYUXGcsYy+lnFGxxkso2IXUVQQERApAtJ76BBaQodAgEACpCfn/eMESKQlkOSm/D7Pc5/c7HPOzboRc++6e++16PsmHNsBM/5y4fHdi+wEL7wHbJ4EW38t9pA61g0k8UwGH82PxcvNmfbhly8K0zYsgCrebsxQ6wUATqZkELztW7KMKx7thjs6nPLPzRtu/AAaDYLF/4HE3QW67K62obg4GSZE77/yySLFQEmeiFQMa77GqlSTVw+1o3VtfyJDfB0dkUjJiOxtl4Jf9x2sHZf/2I5Z4OYLQ8ZD1WYw/ZliX7bZqa6d1EXvPUHnuoGXLGBxlrOT4bomVfljWwJpmdnFGlupdzqB7V8/ym3WHE7XvRF8ghwdUcXR7y1wcoEZz0EB2o8FV/KgZWhllsUV/zJokYtRkici5V/qSYibz5Fa/dh5LI072tRydEQiJav7CxDeHX77C8RvsMcsC3bMhoge9mzFTWPs/1e+uQFOXGIv0a4FkH76mkKp5udJeO7ytd4NC1aUYkDTaqRkZLNg+9Fr+tll2ubJ5LzXnNYJk1lXZQCVB6vgSomqVB16vASxc2DrtAJd0qZOAFsOJmk/qTiEkjwRKf+2z4ScTCamROHj7sIA7euRisbJGW75ErwCYMrjkJ0JhzfaJeLr9bPPqdoE7p4ISQfg856wd3n+xzixB8YNgkXvXHM4HetWwRjo3qBgM1HtwgLw93Jl5uaKt2TzwIkUsrNzYP6bHDQhDOJdIoZ/Yf+3lJLVdoS9T2/m3+wPRK6gTVgAWTkW6/Zd+VyRoqYkT0TKv5gp5FSqwZjYytzQvDre7qo5JRWQdyD0fweObIIVY2DH74Cxmz6fFdETHpoHHn52Qpd86Pyx3Yvtr5smQU7ONYUyslck39zflmBfjwKd7+LsxHWNqzI35gjfrdjLu3N2VIg9ej+u2kfnt+dzzz8+heOxfJTSi5t6daWKzyXaYUjxcnaBGz6A0wl2oncFrWv7Ywys2p1YAsGJ5KckT0TKt7QkiPuDbcVvCtIAACAASURBVP49Sc3MYYiWakpF1vAGqD8AFvwLNvwANVqBT3D+cwIj4Y7v7IIsO/I0gt6zxP6afAD2/WmWr5CCfT3oWq9w+8lubFGdMxnZ/H3KZt6ft5PHxq9laeyxa4qjNLEsCyvPXq99x1N4fXoMrUIr84j/WjJxITagJ8M61nFckGL/P9P1L7DxxysWKqrk4UrDqpWI3qskT0qekjwRKd+2z4LsDD480pimNfxoVtPP0RGJOFb/f4NxgsS480s1/yy4IfjVgti59veWZSd5dfuAqxdsmnj+3GM74UhMsYfdMSKQhc91Z+WLvdj0al/CA73566SNnErLBCDmUDKvTttCcu73Zc1rv8bQ/l/zmLEpnuwci2d/Wo+zk+HDIc3plrEIl/p9+WlUf9xc9NbN4bo+Zxcq+vVpOH35faJt6vizdu9JMrOvbfZbpLD0l0JEyreYKaR6VmXmyZo83iMCY4yjIxJxLL+a0OsVwFy6kbYxULe3XWglKwNO7LZn8OpdZ1+zZUru+F74ojeM6QA/3QfHYos19NpVvAmp5IGvhyvv3Nac+KRU/jljG5PXHmDwx0sZu2wPXy4uWIn70mTGpnjGLttDZrbFY+PXcv37i1i95wSv3diY6iej4fRhTLPb9fertHB2hcGfQnoyfDsYErZe8tQ2YQGkZmaz5VDyBce2xidzJl1FWaR4KMkTkfLreBxW7Dxm57QlPMiXvo2qOjoikdKh7Qh4ZguENL70OZF9IOM07F9xfqlmWFdoehuknYRt02HiUHuWr8MT9h6/j9rAxx1g4jBY9XmBSs1frda1/XmoSzg/rNrHqIkbaBlamS6RgXy9dPe52b2y4ODJVJ7/eSNRNb1Y9kQTnr++AXuPp9C/aVUGt6wBm36y21xcatZVHCOkkb2s+VQ8fNoNlv3PntXOOJPvtLZ17AI5q/Psy7Msi//N28n17y/mH79dOkEUuRZK8kSk/MnJsd9gftKZLCc3PkruzKPd6+LkpE/BRQB7ps6vxuXPCesKTq6w83c7yfMOgsB6dnEWryow5TGIXw+Dx8B1b8JT6+1lbJVrw6G1dvP16C+L9Wk806ce3esH8Ui3CL57oB1/va4ByWlZjFt+iRYQhZSVncP7c3eyeGfRtm5ISslk/f6T/LHtCE/9sI4cC8YG/4jH/5ryiNMUVr3QnQ+GtMRkpkDMr/ZeSlfPIo1BikC96+Cx5XYbkt//Dh9GwT+rwxd9zn3AEVzJg9pVvFi1x07y0rOyeXbiBv47ZweVvVyZvvGQ+j9KsVCJOREpX7Iz7dmF7TMgohdPJA8jxdmXQS2qOzoykbLF3Rdqd4Sdc+1laXU628mhsys0Hgyrv4DOz5xf8ukTDD1etO/n5MD4W2H2SxDa0Z71yMmBQ+vANwQq1bAf6xp5uDoz9v62575vWtOP7vWD+HLJbu7vVAcvt2t7mzN53UHenbsDgC6RgTx/fQMaV7/yvt5TaZl4uDrj6pz/s/Sk1Ew+XRjHV0t3k5Zp79EyBj4aFIrPnMl28jzvdfy2z7SX1e6cY8+mNh9yTc9DipFPMNz5IxxYDYm7Ye8SWDvOLk5UuyNg98ubt/UI3y7fw+eLd7MvMYVn+9SjWa3KDPtqFQu2J9CviVr7SNFSkici5Ydl2Rvht8+A6/5JTOg9zP7fEv7vhrAL3myJSAFE9rFnKMBO8s7q9jcIrA9Rwy9+nZMTDP4ExnSCScOhz2sw/83zjdi9g6FBfxjwrn1uEXqyZyS3jFnGu3N20L1+MAZoVdsfD1dnwF4q98b0rUzbcIjsnBwsoGeDYEb2jKRObpN2sGdc3p+7k2Y1/bixeXU+nB/LTR8t5ZfHOtGkxqUTvZwci1vGLMPJGCY+0oFKHq4ATN94iJd+2UxSaiaDWlTnhmbVqeLjRjU/T6puGgPZGTB0ChzZAr89a/clbHKLfQvvVqS/IylixkCttvat4UDYPBnWf38uyWtbJ4BJaw7w8tQttAytzGuDGtOjfjBZ2TkE+rgzZd0hJXlS5JTkiUj5seAtWP+d/Qa0w+PMn28XgRjQTC+eIlelbt4kr8v5cZ9gaDfi8tf6BNuJ3nc3w/e3g18oDHwPcrJg90JYMxZqd4JmtxdpyK1r+9MlMpDPF+/m89wiLM1r+jFueDv8vFz5bNEuvlq6m94NQ6he2YOUjGx+3XCIqesPcVvrmrw4oCGVPFz5cdV+Dp5M5V83N6VrvSAGt6xBv/cX85efNjDtic6XrHK5ak8iO46cBmDEuGi+Gd6Wn9cc5KUpm2hZqzKvD2qSP0nMyYbVX9m/3+CG9q3xYPuYk3OR/m6kBLh5Q6Ob7OJE1/8b3Ly4vmlVdh07Q6+GwUTV9j9XQMfF2Ykbmldj/Ip9JKVm4ufp6uDgpTwxVjFuii4KUVFRVnR0tKPDEJHSbttv8ONd0OJuGPQRGMMdny7nVFoWM57qcuXrReRClgXvNYWsNPjLzqtbYrn2W/v6VkPBJbeJd04OfNbNLuDyRPT58SKSlJrJtvhkjDHsOXaGv0/ZTGSID8M7hfGXSRvo37QaH97Z8tyb7YTkND5eEMe3K/YSGuDFu3e04KFx0YQHevPjiPbnzpsbc4QHx0XzZM+6PNu3/kV/9rMTN/D7lsO80L8hL/6yiYbVKrE1PpmeDYL5+O5W52YUz9k+E34YAreNPZ/cSdm2ZwmMHQA3f37FDzE27D/JoI+W8vYtTbmjTWgJBShlkTFmjWVZUQU9X+uXRKR8iP4aKofCDe+DMZxKy2TN3hN0q1+4hssikocx0Pcf9u1q99C1uhfaPpQ/kXNyspdwntwHq4u+OIufpyvtwqvQNiyA29vU4rOhrYlNOM2zP22gcfVK/OfW5vnaEQRX8uDVGxvz/YPtOJ2exU0fLeXoqXSeu65+vvN6NwrhllY1+XhBHBsPnLzg555Oz2LGpngGNq/GXe1CeeH6BmyNT2Zgs2p8MqAKHpt/vLDi6OovwLcaNBhY5L8HcZDQjvbr0frvr3hqs5p+hAV688u6gyUQmFQkV0zyjDG1jDHzjTExxpgtxpincsdfNcYcNMasz731z3PNC8aYWGPMdmPMdXnG++WOxRpjni+epyQiFU7qCbufV6Ob7KIQwPK442TlWHSrpyRP5Jo0vql4Cn9E9ITw7rDoHUhLKvrHz6N7/WC+vq8NvRuG8Nm9UXi6XXwZZLvwKvz2ZGe61gvi5lY1iMotf5/XKzc0IsjHnUe/W8uhk6n5js3YGE9qZja3tq4FwIiu4cwd1ZX3h7TEbd7LMPUxWDL6/AW7F9sN51vfd+5vl5QDTk7Q/E77dSnp8smbMYZBLaqzcnci787ZQcKptJKJUcq9gszkZQHPWpbVCGgPPG6MaZR77F3Lslrk3mYA5B4bAjQG+gEfG2OcjTHOwEfA9UAj4M48jyMicvW2z4KcTDvJy7Vwx1G83ZxpFervwMBE5LJ6vwqpiXZxln0rL99Xz7Lg5P6r/lEd6wbyxbAoqle+fCuC4EoejBveltG3t7jocT9PV74YFkVyaiZ3f7Ey35vyidH7CQ/yplVoZcB+A1832Bfn9CS7FYWHH8x7HTZNgpip8N0tUCUS2jx01c9LSqnmQwAL1n13xVOHdahD93pBvD9vJ53e+oNXpm4mPUttFeTaXLHwimVZ8UB87v1TxpitwOWa6wwCfrQsKx3YbYyJBc7WN461LGsXgDHmx9xzY64hfhER+81SpZpQoxVgV89buOMoHesGXrI4goiUAtVbQu/XYPF/4au+ENLEruIZ0hiCGtjLGL0DYeuvsOQ9SNgCw361e/g5UJMafnx9fxvu/XIV936xige72BV8o/ee4K/98i/xBOz4szNg6DQ7yZvyqN3upWYbuGsCeF04YyhlXEA41O8PS9+HlnfbLTEuwd/bja/vb8uuo6f5csluxi3fy9b4ZD65pzVVfIp2v6pUHIV692OMqQO0BFbmDj1hjNlojPnKGHP24/IaQN6P2g7kjl1qXETk6qUlQ9w8aDTo3J6h3cfOcOBEKl21VFOk9Ov8NIzaCgPfBTcfu1DLtCfhyz7wXhN4sypMfsiuyunmAxsmODpiAKLqBPD50Cj2n0jhuUkbeXrCelycDLe0usib+U0/gX8YhLaHIePt9hMNb4ChU5XglWf93gIrB2YVbIdSeJAPbw5uyod3tWTjgSRu+ngp+46nFHOQUl4VuIWCMcYH+Bl42rKsZGPMGOANwMr9+l/gEg1zCscYMwIYARAaqkpDInIZO2bbn5A3GnRuaOGOowB0i1SSJ1ImuPvYPfeihtuVN0/shuOxkHwITh+Bqs2gXj+Y+rg9KzZwdJFX5LwanSMDWftyHxKS00k4lYaXmwshlTzyn3TqMOxeBF2fsz+I8gqARxYXSTN4KeX8a0O35+zZ2x2/Q72+BbpsYLPq1PT34o5Pl/PV0t28emPjYg5UyqMCJXnGGFfsBG+8ZVmTASzLOpLn+OfA9NxvDwK18lxeM3eMy4znY1nWZ8BnYLdQKEiMIlJBxUyxl3TVbHNuaOGOo4QFehNaxcuBgYnIVXFygioR9u3PmtwCG763i5U0GFDysV2Eh6szoVW88v+9mfuqPYPT/QXY8gtgQdNbzx9XgldxdHjSnn3+bRTsuhEyU6B6C7vYzmW0qFWZ1rX9id6bWDJxSrlTkOqaBvgS2GpZ1ug843m7Cw8GNufenwYMMca4G2PCgEhgFbAaiDTGhBlj3LCLs0wrmqchIhVS+imInQcNb7TfGALHTqezZOcx+jQKcXBwIlLkwruBZwBs/tnRkVxa/EZY8q69F+vTrnaLiKpNIejiffWknHNxs1v7ZJyBNWNh4wSY+by9J/MKouoEEHMomdPpWcUfp5Q7BdmT1wm4F+j5p3YJ/zbGbDLGbAR6AM8AWJa1BZiIXVBlFvC4ZVnZlmVlAU8As4GtwMTcc0VErs7abyErFZrdcW5oyrqDZOVY3Nr60pvcRaSMcna1l2Zvn2m/aQaI32C3USktlowGN1+4fZwd4/Gd0PQ2R0cljlS7A/xtN7x0CAZ9aL9uHbnyW+A2dfzJsWDt3lL071vKjIJU11wCXGxdwYzLXPMm8OZFxmdc7joRkQLLzoTlH0HtzlCzNWBX1Zy05gDNa1WmXoivgwMUkWLR9FZY87XdhuDQWnt2JKgBDJsOPg7Yh5uWBO6V7CWYx2JhyxS7mEyjQRDWzS660uKuko9LSqezWwsOrLaXbV5Gy1B/nAxE70lUITEpNNUWF5GyacsvkHwAOo08N7TpYBLbDp/iNs3iiZRfoR3sfbi/joQ130CLe+DEXhg3CFJKaP+SZcHOOfDNDfBWKPwwBM4cg6Xv2QVh2j9mn+dZGdo+BG7eJROXlH5+tcAnBA5EX/FUH3cXGlWvxOo9msmTwlOSJyJlj2XZ+12CGkLdPueGf4o+gLuLEzc0r+7A4ESkWDk5Q7uH7Z56w2fBTR/BnT/Y1TjHDbqmhukFcuYYfNUPxt9qz9xFDYe4P2BMJ9jwI7QaCj7BxRuDlF3G2LN5B1YX6PQ2dQJYt/8Emdk5xRyYlDdK8kSk7ImbB0c2Q8cnzxVcScvMZur6g/RrUhU/T1cHBygixarzM/DoUrvvHEBEDxjyPRyPg487QPRX9odBhWFZkHQQsvMUucjOhMTdkJlqf388Dr7oDfHr4YYP4KkNdn+/h/4Aj0pgnOy/SyKXUzMKEuMKNPPcpk4AaZk5bDmUXAKBSXlS4D55IiKlxrL/2cu18hQz+D3mCMlpWdweVesyF4pIuRXZGx5bBtNGwvRnYONP0Pv/zieCef36tP0me+i08+0MVn0OM58DJ9fz7RuOx0FOJhhne9/fqUN2IjdsOtQ637aFqk3h4UVw5ihUVn9fuYJz+/Kir9g7L6q2P2Dvy2tRq3JxRybliGbyRKRsORIDuxZA2xF2aepcP0Xvp0ZlTzqEV3FcbCLiWP51YOhUe5bteCx8dR18dwuc3Hf+nIwUu4z97kWwPbcWXMYZWPRvqN4KOjwOAREQEA4dn7Afq8so8KthN2V/YE7+BO8sV08leFIw1VvaHxYUYMlmcCUPalfxYvUe9cuTwtFMnoiULSs/ARfPfI1kD55MZUnsMUb2jMTJSU2GRSo0Y6D1MLsK5+ovYMHbMOcVuG2sfTx2rt2Q2s0X5r0B9frZs3hnjsId4yG0nUPDlwrAzRtCGhd4X15U7QAWbE/AsiyMufA1Liklk0U7jzKwWbWLHpeKSTN5IlJ2nDlufwLf7HbwCjg3PHnNASwL9cYTkfPcvKHTU/YHQlt/hdMJ9njMVPCqYu+lO7rVbsew9H2o21sJnpScmm3g4BrIuXJBlY4RVTh+JoMnf1jH8dPpFxx/bfoWnvxhHZsPat+enKckT0TKjrVjISsN2j1ybignx+KnNQfoEF6FWgFejotNREqnqPshJwvWfWcXUNkxCxoMhCa32HvpfvsLpCZCjxcdHalUJDXbQHoyHNtxxVNvalmDZ/vUY/aWw/R5dxG/bzl87ti2w8n8su4gADM3xxdbuFL2KMkTkbIhOxNWfQHh3SGk0bnhVXsS2ZeYwu1tNIsnIhcRGAl1utgzdrFzIeO03ajcyQl6vgJYUL8/1Gjt6EilIjlbfGX/ivzjhzdd0EPP2cnwZK9Ipj/ZhRqVPXl0/FoWbLdnpt+ZtR0fdxea16rMrM2HsQpbVVbKLSV5IlI2xEy1K9u1ezTf8E/RB/B1d6Ff42oOCkxESr2o4Xbxld//Dh6VIayrPR7ZBwa+B/3fcWx8UvEERIB/GMx+CbbPtMfWjoPPesD3d1x0GWf9qr78MKI99UN8eWz8Wr5aspt52xJ4tHsEt7Wuya5jZ9hx5HQJPxEprZTkiUjpZ1l224QqdSHyfLnppJRMZmyKZ2Dz6ni6OTswQBEp1RoMBO8gOLHHvu+c20vTGHs5p59WAkgJc3KC+2fYr2s/3AnfDoZpT4JPCKQcg8MbL3qZj7sLY+9vg7+XG69PjyGkkjv3dwyjb+MQjMm/ZDM9K7ukno2UQkryRKT027PEbj7c4Ylzzc8BPvhjJ2lZ2QztUNuBwYlIqefiBi3vte83GuTYWETOqlQd7p9p/5uM+8N+jXtwjn0s7o9LXhZcyYNvhrclIsibvw9ohKebM8G+HrSpHcCszfZ+vfnbEmj+2u9MjN5fEs9ESiG1UBCR0m/ZB+AVCM2HnBvadfQ03yzbw5A2tWhYrZIDgxORMqHTSHuWpG4vR0cicp6bl93eI2n/+T6LIU3tJK/LqEteVjfYh3nPds831q9JVV6fHsMPq/bx6rQtpGfl8O6cHQxqUR13F612qWg0kycipVvCVtj5O7R72G42nOufM7bi4erMqD71HRiciJQZnv7Q/hFw0ptdKWWMOZ/gAUT0gH0rIONMoR6mX5OqALwweRO1Arx4f0gL4pPSmBh9oCijlTJCSZ6IlG7L/geuXtDmwXNDi3ceZe7WBJ7oWZcgX3cHBiciIlLEInpCTibsWVqoy6pX9sxtJ+TJdw+048bm1Ymq7c/H82O1P68CUpInIqVTdhYsec9uft7ynnPNz7Oyc3hjegyhAV7c36mOY2MUEREpaqEdwMXjsvvyLuWLYVHMHdWNqn4eGGN4unc9zeZVUEryRKT0ObYTvuwDc/8P6vXL16T4h9X72XHkNC/2b6g9BiIiUv64ekDtThA3r9CXeru75Htt7FS3yrnZvLRMzeZVJEryRKT0+eVhOLEbbv0K7vjO3ksDJKVmMvr37bQPD+C6xiEODlJERKSYRPSEYzvg5LVVxzTG8Gzf+sQnpfH5ol1FFJyUBUryRKR0ObkfDq6BTk9Dk1vsDem5/jdvJydTM3l5YCNMnnEREZFyJaKn/XX15xdtjF4YHSKqcH2Tqny8II74pNQiCE7KAiV5IlK6bP3V/trwhnzDu4+dYeyyPdwRVYvG1f0cEJiIiEgJCW5ovw4ufR/G3QiJu+HMcTi6HVJPFvrhXuzfkGzL4q2Z24ohWCmN1CdPREqXrb9CcGOoEpFv+GxD12f7qmWCiIiUc8bA7d/Cum9h1gvwQYvzx2q2Pd80vYBqBXjxcNdw/vdHLK1C/cmxLBLPZDCsYx0CfVSlujxSkicipcfpBNi3HLr97YJDi3cepVVtf7VMEBGRisEYaDUUwrrB5kng5gMHVsOmSZCSeK7qdEE92j2CSWsO8H/Ttpwb23XsDB/d1aqoI5dSQEmeiJQe234DLGh0Y77h46fT2XwwmWf71HNMXCIiIo7iXxu6PGvfr94SNv0EuxdC48GFehgvNxemPN6JhOR0qlf2YPzKfYyes4PbWifQvX5wMQQujqQ9eSJSemz9FQLCIbhRvuElsccA6FIvyBFRiYiIlA7VW4GbL+xacFWXh1TyoGlNP6r4uPNwt3DCg7x5ZeoWtVcoh5TkiUjpkHrC/mSy4Q35KmoCLNl5DD9PV5rWUMEVERGpwJxdIKzLVSd5ebm7OPOPQU3Yl5jCx/Njrz02KVWU5IlI6bBzDuRkQYP8VTUty2LxzmN0rhuIs5PaJoiISAUX3gNO7LErbl6jjnUDGdyyBmMWxrHlUNK1xyalhpI8ESkd4uaDZwDUaJ1vODbhNIeT0+gcGeigwEREREqR8O72190Li+ThXh7YCH8vN56ZsF7LNssRJXki4niWZS89CesKTvn/LC3aae/H61xXSZ6IiAiBkeBb3f5wFGD3Yphwr91qIforSDpYqIcL8Hbjnduas+PIad6epT565YWqa4qI4x2PhVOHzn86mceSnUcJD/SmVoBXiYclIiJS6hhjv17umGkXLJs03G6vkJUGmSngWw0eWQreVQr8kN3qBXFfxzp8vXQPPeoH01WFzso8zeSJiOOd3UAe3i3fcFpmNit2JdJFSzVFRETOi+hhFyybcA9UbQpProEXDsLw2ZByHKY8Cjk5hXrI569vQL0QH56esJ6DJ1OLKXApKVdM8owxtYwx840xMcaYLcaYp3LH3zHGbDPGbDTG/GKMqZw7XscYk2qMWZ97+yTPY7U2xmwyxsQaYz4wxqiKgojYSV7lUPAPyzf8e8wRUjOz6dOoqmPiEhERKY3CuoGzu73NYehUuzG6kxOEtoe+b8LO2bDio0I9pIerM5/c05rMrBxGjIsmNUP788qygszkZQHPWpbVCGgPPG6MaQTMAZpYltUM2AG8kOeaOMuyWuTeHskzPgZ4CIjMvfUriichImVYTjbsWWy/YP3pc58fV+2jVoAnHSMKvuRERESk3PMNgZHr4J7J4O6b/1jbh6DBQJj7KuxfXaiHDQ/y4f07WxATn8wLkzdiWVbRxSwl6opJnmVZ8ZZlrc29fwrYCtSwLOt3y7Kyck9bAdS83OMYY6oBlSzLWmHZ/2LGATddU/QiUvbFr4e0pAv24+09foZlcce5I6oWTmqdICIikp9fDXB2vXDcGBj0IVSqARPuhqQDhXrYng1CeLZPPaasP8SszYeLKFgpaYXak2eMqQO0BFb+6dBwYGae78OMMeuMMQuNMV1yx2oAef+VHcgdE5GK7Ox+vLD8+/EmRu/HycCtrWuVfEwiIiJlmac/3DUBMlLghzsh40yhLn+0e11qBXjy9dI9xROfFLsCJ3nGGB/gZ+Bpy7KS84y/hL2kc3zuUDwQallWS2AU8L0xplJhgjLGjDDGRBtjoo8ePVqYS0WkrNm1AEKagM/5Sl5Z2Tn8FH2AHvWDqern4bjYREREyqrghnDrl3B4U6ELsTg7GYZ1qMOqPYlsPqgm6WVRgZI8Y4wrdoI33rKsyXnG7wMGAnfnLsHEsqx0y7KO595fA8QB9YCD5F/SWTN37AKWZX1mWVaUZVlRQUEq4SpSbp05DvtWXjCLt2D7URJOpXNHG83iiYiIXLV610Gf1yFmKix8u1CX3hZVC09XZ75Ztqd4YpNiVZDqmgb4EthqWdboPOP9gL8CN1qWlZJnPMgY45x7Pxy7wMouy7LigWRjTPvcxxwKTC3SZyMiZcvCtyEnC1oPyzf8w6p9BPm606NBsIMCExERKSc6Pgkt7oaFb8HmyVc+P5efpyu3tK7B1A2HOH46vRgDlOJQkJm8TsC9QM88bRH6Ax8CvsCcP7VK6ApsNMasByYBj1iWlZh77DHgCyAWe4Yv7z4+EalIjsVC9JfQaigE1T83vPvYGf7YnsCdbWrh6qxWniIiItfEGBj4LtRqD1Meg0PrCnzpsA51yMjK4cfV+4sxQCkOprSXRo2KirKio6MdHYaIFLUJ90DcfHhyrV0KOter07YwfuVelj7fk2Bf7ccTEREpEqePwmfdwTsQRiy4oG3RpdzzxUqWxB7Dxcng4mx4okddnugZWZyRykUYY9ZYlhVV0PP1MbmIlLx9K2Drr9DpqXwJXlJqJhOj93ND8+pK8ERERIqSTxB0GWW3Ltr/50L5l/baoMaM7FmXEV3DaV3bn9FzdrDlkIqxlHZK8kSkZJ05BlMfB5+q0OHxfId+it5PSkY2wzuFOSg4ERGRcqz5EPDwg5WfnB87ud/+4PUSIoJ8GNW3Pn/t14CP72qNv5cbf5+ymZyc0r0asKJTkiciJSf9FIy/1W7Mevs34OZ97lBWdg5fL91D27AAmtTwc2CQIiIi5ZSbt70XPmaa/VqcehLGDbK3UOxaeMXL/bxceWlAQ9btO8mPq/djWRZ7j59hf2LKFa+VkqUkT0RKRlaG/SISvxFu+wZC2+c7PCfmCAdPpmoWT0REpDi1HQFYsOoz+PlBOLnXXl0z82+QnXXFywe3rEH78ADe/C2GNm/Oo9s7C7jhwyWkZWYXf+xSYEryRKRkrBlrNz6/8QOo3y/fIcuy+GRhHLWreNGnUchFLxcREZEiUDkUGgyApR9A7By4/t8wcDQc3WpXvb4CYwz/HNyUyBBfukQG8ki3CE6mZDJjU3wJBC8F5eLoAESkArAsiP4KqreElvdccHh53HE2HEjiCc5iSgAAIABJREFUn4Ob4uxUsGpfIiIicpXaP2bvw2s1DKKG22MRPWH+m9DkFrsC52WEB/kw5fFOgP1B7azN8fy4aj83t6pZ3JFLAWkmT0SK374V9ieEZ19I/mTMwjiCfN25uVWNEg5MRESkAqrdER5fZffPM8a+9XsLMs7AxKGQuKvAD2WM4Y42oazak0hswuliDFoKQ0meiBS/NV+DeyX708E/2XQgicU7j/FA5zA8XJ0dEJyIiEgFFFQfnJzzf3/j/+y98x93gMWjIadg++xubV0TFyfDhNX7iilYKSwleSJSvM4chy1T7LLNeappnvXJwjh8PVy4u12oA4ITERGRc1rcBU+sgsg+MO81uxhLAQT5utO7YQg/rz1IepYKsJQGSvJEpHht+B6y06H1/RccWrA9gRmb4xnaoTa+Hq4OCE5ERETyqVQd7vgOOjwBqz+HlZ8V6LIhbWuReCaDn9ccLOYApSCU5IlI8bEsu6pmrfYQ0ijfoX3HU3jqx/U0qFqJJ3pEOiY+ERERubg+r0P9/jDrb7Bzbv5jJ/bCtzfDyfPLM7tEBtG4eiVe/GUTT/+4jqOn0ks4YMlLSZ6IFJ9D6+B47AUVNVMzsnnkuzUAfHpPazzdtBdPRESkVHFyhps/h5DGMGk4nD56/tj8f0LcPHvfXi5nJ8PPj3ZkZM+6/LYpnl7/XUDcURVicRQleSJSfLb8Ak6u0HBgvuF3Zm9n6+Fk3hvSgtAqXg4KTkRERC7L3Qdu/RoyU2Deq/ZYwjbYOAHc/WD9eDh1+NzpHq7OjOpbn5lPdcGy4B/TYxwTtyjJE5FiYlkQMwXCu4On/7nhnByLaRsOMqBpNXrUD3ZYeCIiIlIAgZHQ/lFY9x0cWAML/mUXUrt3MuRkwYoxF1xSN9iXkb0imb/9KPO3JzggaFGSJyLF49Bae61+48H5htcfOMmx0xn0aRTioMBERESkULr9FXyqwuQH7Q9w2z8GNaOg0U0Q/RWkJV1wybCOdQgL9OYf02PIzM5xQNAVm5I8ESkeZ5dqNuifb3je1iM4Oxm619MsnoiISJng7msXYkncBR5+0OFxe7zz05CebCd6f+Lm4sRL/RsSd/QM3y7fW8IBi5I8ESl6lgVbpkJEj3xLNQHmbU2gTR1//LzUMkFERKTMaHY7RD0AA0aDZ2V7rFpziOgJS96D43EXXNKrYTBdIgN5d84OjiSnlXDAFZuSPBEpegfXQtKFSzUPnEhh2+FT9G6opZoiIiJlijEwcDQ0vTX/eP//2JU4v7slfwVOwBjD64OakJ6dw2u/binBYEVJnogUvZjcpZr1/7xU09583bOBlmqKiIiUC1Ui4M4JdpXNH+6AjJR8h8MCvXmqVyQzNh1mTswRBwVZ8SjJE5Git20GhHXlRI4XPf+7gJE/rCMpNZO5W48QHuhNeJCPoyMUERGRolKrDdzyhb2S56N2sPKzfMneiK7hNKjqyytTNzNv6xE+XhDLv2ZuJS0z24FBl28ujg5ARMqZYzshMQ7aP8or07aw73gK+46nsGbvCY6eSmdYx9qOjlBERESKWsOBdluFBW/BzOdg0Ttw/0wIrIursxP/urkpN49ZxgPfRJ+7JCLQh9vb1HJg0OWXZvJEpGhtnwnAHzkt+XXDIZ7qFcmkRzvi4mzIyM6hT6OqDg5QREREikVET3jgdzu5y0qH356xi7EBLUP9mfhwByaMaM+GV/rSoKovXy/bg5V7XIqWkjwRKVo7ZpEV1Ii/zDlBs5p+PNo9gha1KvPbyC6Mf7AdbcMCHB2hiIiIFKfaHaH3K7B7EWyceG64TZ0A2oVXwc/Llfs61mFrfDKrdic6MNDyS0meiBSdlETYt4IFVmtOp2fx39ua4+Js/5nxcXehU91ABwcoIiIiJaL1cKgRBbNfhNQTFxwe1KIGfp6ufLN8T4mHVhEoyRORohM7F6xsPjlcjzuiahEZ4uvoiERERMQRnJxg4Lt2gvf7yxcc9nRzZkjbWszecoRDJ1MdEGD5piRPRIrO9pmkuFZhTVYY93ZQgRUREZEKrVoz6PgkrPsWVn95weF729fGsizN5hUDJXkiUjSyM7Fi5zIvpwXtwgOpp1k8ERER6fkyRPaFGc9B7Lx8h2r6ezGgWXU+W7SLj+bHqghLEVKSJyJFY+9STHoyv6Y2Y2iHOo6ORkREREoDZxe49SsIbgg/3Qe7F+c7/M6tzbihWXXemb2dkT+uV++8IqIkT0SKxpYppBkPtnm3oU+jEEdHIyIiIqWFuy/cNQHcK8E3A+Hr/hD3BwAers68P6QFf+vXgOkbD/Hx/FgHB1s+XDHJM8bUMsbMN8bEGGO2GGOeyh0PMMbMMcbszP3qnztujDEfGGNijTEbjTGt8jzWsNzzdxpjhhXf0xKREpWdRfaWqfye1ZKb20Xi6qzPj0RERCQPv5rwxCro9zac2APfDob13wNgjOHR7hF0jQzi57UHycnRss1rVZB3YlnAs5ZlNQLaA48bYxoBzwPzLMuKBOblfg9wPRCZexsBjAE7KQT+D2gHtAX+72xiKCJl3J7FOKclMiOnPUPahDo6GhERESmN3Lyh/SMwch2EdYVfn4YDa84dvrlVDQ6eTGWleuddsysmeZZlxVuWtTb3/ilgK1ADGAR8k3vaN8BNufcHAeMs2wqgsjGmGnAdMMeyrETLsk4Ac4B+RfpsRMQhrC2/kIIHmWG9qOrn4ehwREREpDRzcYdbx4JvCEy4G+I3wIYJDNj3X1q7H2Dy2gPnTt1z7Ay7jp52XKxllEthTjbG1AFaAiuBEMuy4nMPHQbObsKpAezPc9mB3LFLjYtIWZadSdaWafye3Yobo8IdHY2IiIiUBd5VYMgP8GUf+LQrYCcmY9xD6bepGqmDmnD0VDqDPlqKj7sLi/7aA2cn49iYy5ACJ3nGGB/gZ+Bpy7KSjTn/S7YsyzLGFNniWWPMCOylnoSGaumXSKm2exGu6SeY59SJfzeq6uhoREREpKyo2gTungSHN0LtTpByjOBvB/NIzo9MXd+Cb5bv5Ux6FkmpmczflkBvFXYrsAJVRzDGuGIneOMty5qcO3wkdxkmuV8TcscPArXyXF4zd+xS4xewLOszy7KiLMuKCgoKKuhzEREHyNo0mdOWJ76N++Lp5uzocERERKQsqdMJ2j9qN06P6InVejgPusxg8tSf2XY4mU/vbU1IJXe+XbHX0ZGWKQWprmmAL4GtlmWNznNoGnC2QuYwYGqe8aG5VTbbA0m5yzpnA32NMf65BVf65o6JSFmUlQ6L/oPZNJHZOa25MSrC0RGJiIhIGWf6vs4p96q85fwJz/UIpVfDEO5sG8rCHUfZe/yMo8MrMwoyk9cJuBfoaYxZn3vrD7wF9DHG7AR6534PMAPYBcQCnwOPAViWlQi8AazOvb2eOyYiZc3hTTCmE/zxBqtd2zDW+wHa1glwdFQiIiJS1rn74nHzx4Q7HeZR5ykA3Nk2FGcnw/cr9zk4uLLjinvyLMtaAlxql2Ovi5xvAY9f4rG+Ar4qTIAiUvpkz3mNjOSjPGdeZHpSE14Z2AgnbYYWERGRIuBevyc0vR2z9H1oPoSQwEj6NgphYvR+nulTDw9XbQ+5EnUsFpHCyUghZ9dCfkxtx+nQHvzyWEeGdw5zdFQiIiJSnlz3Jrh6wW+jwLK4t31tTqRk8nOe9gpyaUryRKRw9izG1crgRI0ejL2/LS1D/R0dkYiIiJQ3PsHQ62XYvQg2TaJDRBXa1PHn37O2c+x0uqOjK/WU5IlIoZzZ/BtnLHf8G/d0dCgiIiJSnkUNh+otYc4rmKx0/nVzU1IzsnljeoyjIyv1lOSJSMFZFmbHbJbmNKFd3WqOjkZERETKMydn6PM6nDoE0V9SN9iXx3pEMHX9IRZsT7jy9RWYkjwRKbiEGLzSDrPCJYoGVX0dHY2IiIiUd2FdIawbLB4N6ad5tHsEEUHe/H3KZtIysx0dXamlJE9ECm6H3dryTGgPVdMUERGRktHrFUg5BivH4O7izOuDmnDgRCoTo/c7OrJSS0meiBRY+taZbM6pQ8N6DRwdioiIiFQUNaOg3vWw9H+QeoKOuUVYxiyIIz1Ls3kXoyRPRAomJRHXQ9H8kdOCDhGBjo5GREREKpKeL0HGKfiiD2bfckb2iiQ+KY1Ja9RS4WKU5IlIwWz+GSdyWOXWnnohPo6ORkRERCqSqk3h7kmQnQ5fX0/nmNcYWP0UH8+PIyMrx9HRlToujg5ARMoAy8Ja/SXbTTh+4W0xRvvxREREpITV7QWPrYD5/8Ss/JQPc75lWXYjxv80kuDG3ank6UL78Cq4OmseS78BEbmyvUsxR7fyZUZv2tfVUk0RERFxEDdvuO5NGBWD1fMV6rsmMHjbs7z6/R/c++Uqfli1z9ERlgpK8kTkiqxVn3PGyZe5Tp3p3TDY0eGIiIhIRecTjOn6LH4P/4afSxZ/NJpO/RBffll30NGRlQpK8kTk8pLjsbZO5/uMLjzWpynV/DwdHZGIiIgIAC4hDTDdn8d31wyerbmVdftOsvdoMmRnOjo0h1KSJyKXlbbyK5ysLFYHDub+TnUcHY6IiIhIfh1HQrUW9Nr1Np+4vkvIp43hnQjYv9rRkTmMkjwRuaTUmFlYyz9iYU5zRt52HS7ayCwiIiKljbMLDPoI56xUWrrt5w/TFsvTH8bfCglbHR2dQ+gdm4hcID0zk+hxL+A+cQi7sgKJbfsPmtTwc3RYIiIiIhdXtQn8bS/z+s7hsVPD2dH3W3DxgG8Hw4k9jo6uxCnJE5ELzPvsb0Tt+pjlXj3Iun82Dwzs6uiQRERERC7PxY3+Tavi6myYtMsF7p0MmSnw0/2QU7F66SnJE5F8oncdISrhZ3b5daDTc5NpHlbN0SGJiIiIFEhlLze61Qtm6vpDnKlcH/r/Bw6thXXjHB1aiVKSJyLnZOdYzPx5LMHmJDX6PgFqei4iIiJlzINdwjh2Op2nJ6wnp/GtULsTzH0NUhIdHVqJUZInIueMX7mXrsnTSfWsinuDfo4OR0RERKTQ2odX4ZWBjZgTc4S3f98O/d+BtCSY97qjQysxSvJEBIB9x1P4YfZiujhvwqPtfXalKhEREZEyaFjHOtzTPpRPF+5i1IJM1la9HWvNWNL3r3N0aCVCSZ6IsDU+mVs+WcYtzMMYg2k11NEhiYiIiFw1Ywz/d0NjBrWozh/bExi2uxfJlicHp73h6NBKhD6qF6ng1uxN5P6vV+PrCvd5LcXUvA78ajg6LBEREZFr4ursxPtDWgKQlZ3DlNFzufnoBKyjOzBB9RwcXfHSTJ5IBXYmPYsR49ZQxcedqdedxiUlAVoPc3RYIiIiIkXKxdkJz86PkWG5kDD7HUeHU+yU5IlUYGOX7eH4mQxG396cwJ0/g08I1O3j6LBEREREilyvqCZMMT2pEjsZkg9B4i6YNBzW/+Do0IqclmuKVFDJaZl8tmgXPRsE0zIgC3bOhvaPqeCKiIiIlEsers4cazoCNs4h8/u7cT0WA1lpcHANNB9SrlpHaSbvKvy2MZ70rGxHhyFyTb5cvJuk1ExG9akHmyZCTha0uNvRYYmIiIgUm+u7tmdaTkdcD6+FyL7Q82U4sQcOrnV0aEVKSV4hbT6YxOPfr+XZiRvIybEcHY7IVTmZksFXS3ZzXeMQmlSvBOvGQ43WENzA0aGJiIiIFJuIIB9+rfEsw93+Q8rgr6HNg+DsBpt/dnRoRUpJXiE1qeHH89c3YPrGeN74LQbLUqInZc97c3dyOiOLZ/rUg/gNkLBFs3giIiJSIYzo05z5p6rz4uRNWB5+dj2CLZMhJ8fRoRUZJXlX4eGu4QzvFMbXS/cwZmGcEj0pU1btTuSb5Xu4p11tGlStBOvHg7M7NLnZ0aGJiIiIFLsOEVV4pnc9pqw/xPer9tnvgU7Fw77ljg6tyFwxyTPGfGWMSTDGbM4zNsEYsz73tscYsz53vI4xJjXPsU/yXNPaGLPJGBNrjPnAmLK7s9EYw98HNOSG5tX596ztPPLdGhJOpTk6LJErSs3I5q+TNlDT35Pnr29gz+KtHQeNBoGnv6PDExERESkRT/SoS9d6Qbw2LYb5tMZy9YLNkxwdVpEpyEzeWKBf3gHLsu6wLKuFZVktgJ+ByXkOx509ZlnWI3nGxwAPAZG5t3yPWdY4ORnevb05z1/fgPnbj9Jn9CImrz2gWT0p1f7z+3b2HE/h7Vua4Z2dDBPuAa8qcN0/HR2aiIiISIlxcjK8d0cLgiu5c//4GGZltuDUup+JOXDc0aEViSsmeZZlLQISL3YsdzbuduCyzSWMMdWASpZlrbDsLGgccFPhwy1dXJydeKRbBDNGdiEiyJtREzfwwDfRxCelOjo0kQus2HWcr5bu5t72tekYFgCTH4JTh+H2ceAT5OjwREREREpUgLcbs5/uyif3tOJI6AB8s5PwOLDE0WEViWvdk9cFOGJZ1s48Y2HGmHXGmIXGmC65YzWAA3nOOZA7Vi7UDfbhp0c68vLARiyLO0bf0YvYfDDJ0WGJnJOUksmoCeupHeBlL9Nc+DbEzoXr34aaUY4OT0RERMQhvN1d6NekGvcNfYicfm8T1qSDo0MqEtea5N1J/lm8eCDUsqyWwCjge2NMpcI+qDFmhDEm2hgTffTo0WsMsWQ4Oxke6BzGrKe64u7qzKvTtmjpppQKlmXx0pRNJJxK5/0hLfHeOw8WvmVX02x9v6PDExEREXE8F3ec2j+C8Ql2dCRF4qqTPGOMC3AzMOHsmGVZ6ZZlHc+9vwaIA+oBB4GaeS6vmTt2UZZlfWZZVpRlWVFBQWVrGVmdQG9G9alH9N4TzNp82NHhiPDz2oNM3xjPM33q0dw70V6mWbUZDPgvlN36RyIiIiJyCdcyk9cb2GZZ1rllmMaYIGOMc+79cOwCK7ssy4oHko0x7XP38Q0Fpl7Dzy7Vbo+qSb0QH/41cxvpWdmODkcqKMuy+GRhHH+dtIG2YQE80qkmTBgKGLjjW3D1dHSIIiIiIlIMCtJC4QdgOVDfGHPAGPNA7qEhXFhwpSuwMbelwiTgEcuyzhZteQz4AojFnuGbWQTxl0ouzk682L8h+xJT+GbZHi3blBKXkpHF49+v5a2Z27i+aTW+vq8NzjG/wJFNMOhD8K/j6BBFREREpJiY0p6AREVFWdHR0Y4O46rc++VKFu88hq+HC7WreNE61J8BzaoTVdsfJyctk5Pi8/KUzYxfuZfnr2/AQ13CMQCfdYfMVHh8pZZpioiIiJQhxpg1lmUVuFretRZeqXiyM2Hak5Cw9YqnfjCkJX8f0JDBLWvg7+XGj6v3c/uny+n89h/EHEougWClItp7/Aw/rNrHXe1CGdE1AmMMHFgN8euh3QgleCIiIiLlnIujAyhzju2Arb/C+u+hw+PQ7W/g5n3RU/293XiwS/i570+nZzFv6xHe/G0rT/6wlulPdsHTzbmkIpcKYvScHbg4G0b2jDw/uPJTcPeDZkMcF5iIiIiIlAjN5BVWSGN4Yg00HwJL34f3msLEobBiDJw5dtlLfdxdGNSiBu/e0YJdx87wxm8xJRS0VBRbDiUxdf0hhncKI7iShz2YHA8xU6Dl3eDu49gARURERKTYKcm7Gt5VYNBHMHw2RPSEg+tg1vMwcViBLu9UN5ARXcP5fuU+Zm2OL+ZgpSJ5Z/Z2/DxdebhbxPnBNV9DTja0edBxgYmIiIhIidFyzWsR2t6+ASweDfNeg4RtENzgipc+26c+y2KP8+j4tbStE8CAZtUY3LIGvh6uxRy0lEeWZfHunB0s2H6UF/s3wM8z99/R6QRY8QnU6wdVIi7/ICIiIiJSLmgmr6i0GgrObrBmbIFOd3Nx4uv72zCyZyTHz2TwytQtDPlsBafSMos3Til3LMvirVnb+OCPWO6IqsUDnc/vA2X2S5CVCn3fcFyAIiIiIlKilOQVFe9AaHgDbPjeLlNfAIE+7jzTpx5zR3Xj86FRbD98ioe/XXNVDdQX7jjK8dPphb5Oyr7//r6DTxfu4p72ofzr5qY4n23PsWsBbJoInZ+BwMjLPoaIiIiIlB9K8opS1HBIS4ItvxT60j6NQnjntmYsizvOMxPWk51T8P6Fh5PSGPbVKj6cH1vonytl24b9J/loQSy3R9XkjUFNzvdfzEyD6aPAPww6j3JskCIiIiJSopTkFaXanSCwHkR/fVWXD25Zk78PaMiMTYd5b+6OAl83f3sCAEtjL1/dU8qXrOwcXpi8iWBfd14e2Mjuh3fWwrchMQ4G/BdcPRwXpIiIiIiUOCV5RckYaH0fHFgFGyeCVfDZuLMe6BzGHVG1+N8fsfy+5XCBrpm31U7ydhw5TcKptEL/TCmbxi7bQ0x8Mq/e0Dh/wZ7di2HJu9DyHqjby3EBioiIiIhDKMkrai3uhqpNYfJDMHaAvS/qSAwk7oacnCtebozhtUGNaVbTj1ETNxB39PRlz0/LzGZp7DFa1KoMwPK440XxLKSUO3QyldFzdtCrQTD9mlQ9fyAlEX55GALCod/bjgtQRERERBxGSV5R86wMIxbCwHfh6DYYNwjGdIAPWsB3gyEr44oP4eHqzJh7WuPm4sSADxbT771FPDQums0Hky44d+XuRFIzs3miR138PF1ZslNLNiuCj+bHkpVj8dqgxueXaVoWTH8aTh+BW75Q43MRERGRCkpJXnFwcraLsIxcB3f9BLd9A91fsGf1pj1RoGWcNSp78t0D7RjSJpSa/p6s3pPIMxPWk5WdfzZw/rYEPFyd6BwZSIfwKiyLO451FctEpew4djqdSWsOcEurGtT09zp/YMsvEDMVerwENVo5LkARERERcSg1Qy9OHn5Qr+/5740zzP8H+NWCXi9f8fJG1Svx6o2NAZi1OZ5HvlvL5LUHub1NLcDuj/bHtgQ6RgTi4epMp7pVmLXlMHuPp1An0LtYnpI43rfL95KelZO/H17qSZj1PFRrDh1HOi44EREREXE4zeSVpK5/sZumL/4PbJ9VqEuva1yVFrUqM3rODtIy7T56cUfPsC8xhR4NggHoWDcQgKVxWrJZXqVmZDNu+R56NwyhbnCe5ZhzX4UzR+GGD8BZn92IiIiIVGRK8kqSMTBgNFSJhDkvQ3ZWIS41PH99Aw4npzF22R5SMrL4KXo/AD1zk7zwQG+q/n97dx5dVXX2cfy7MwcSkpCEmYAMAUQGMTIIIg4ogy044zyguCzW2lLfKtXX8a2tS21rHVFRbAW0ikMRFByQijILBoJgGAIhIYGQEJKQeb9/7APGSAIBkhtufp+1zrr3nnPuuc/N2dnhYU8twrSUgh97Z3U6uUVlTBpepRUv7RtY9RoM/hW06++74ERERESkUVCS19ACg2Hkw7BnE6yeUae3Du4Sy3k9W/H0gk30e3gBLy3ewsBTWtI+OhxwieDQbnF8szmHyjospi4nh/3FZbzy3y306xjNmZ1j3M6dq+HfN7kuwCPu82l8IiIiItI4KMnzhR5jIOEsWPQ4lOyv01v/OLYXZ3WLZeKwLrxxy0DeuGXgT46f2zOe3KIyHpmboglY/EhWfjFXvrSUnbkHmDIy0c2omfIBvDYGgkLg2n9rNk0RERERATTxim8YAxc+Bq+cB58/BsPvgeZuPB3lJW4La3HYt3aNj+D1mwce9hjA2D5tWT00j+lLtlJaUclj404jIMDUx7eQBpKSkc+tM1aw70AZr950JsMT42HTJ/D2DdBhIEyYCRHxvg5TRERERBoJJXm+0uEM6HsVLHvRbc3j3dIKRXsgIAgunQanXVbnyxpjeODiXoQGB/DCos0UlpTz50v7Eh4SWA9fQurThsx8nv0ilXnJmcRFhPLW7UM4rX2UO7j0eYhKgBv/A8Fhvg1URERERBoVJXm+NO456Hc1ZKe4LSAIItvBDwvg/ckQlwht+tT5ssYY/ueiHkSEBvHkgo1syirgxesG0ClWyyo0VtZatuwp5MuNu1m9PZe16Xns2HuAiNAg7jinKxOHnUJsRKg7OTfNrbk4YqoSPBERERH5GdPYx20lJSXZlStX+jqMhrU/C6adA4EhMGkRNGt5zJf6YmM2d89eQ6W1jO3Tlm6tIugQE05phaW4tIK20WEM7hJLcKCGZ/pCcVkF05ds5a0VO0jLKQKgfXQ4/TpGMSAhhsvP6EB0s5CfvumLP8GXT8DdyRDd0QdRi4iIiEhDMsasstYmHfX5SvIaqfSV8NpoaH8GXPE6RLY55kvt2FvEgx+uZ+2OPHIKS392PKZZMKNOa8Md53QjIbbZcQQtdfHZhiwemZtCWk4RQ7vFclHvNpzboxUdW9ZyDyor4G99Ib4HXD+n4YIVEREREZ9RkudPkt+BDyZDSHO3yHWvi4/7kjkFJWTuKyYsOIDQoEA2ZObzUXImC1OyMMCDv+zNFWd0YFVaLjOXbyc0KJBrBibQp0PU8X8fOeRfS9O4//11dI1vzkO/7M3Z3Y9y4pTUT+Ffl7nEv/cl9RqjiIiIiDQOSvL8ze6NMOc2yFwLLbtAdCc3Tm/EfRBy4lrdduYdYMrba1i6ZS9tWoSxK7+YyLAgyissB8oq6Nshir4domgbFU6f9lFuhkc5Jhsy8xn33BKGdInllRuTjtxVtjAHMte4brtfPgHbl8KU7yEotGECFhERERGfqmuSp4lXGrv4HjDxU1j+Euxc5Sbd+PoZN17v/AdO2Me0jw5n5q2DefWrrSzalM1d53dn/OntKK+0zFmVzntrMpj7XSZ5RWUA3HRWZ+4f24sgjeWrk6LScn4961uiwoN56sp+R07wCnbDtBGQn/7jvsG/UoInIiIiIjVSS97JaM7tsH4O3PENxHVr0I8uKi3n6QWbeOWrrZzdPY4bh3Rm8+4CduUXc/XABBJbRzZoPCeTwpJypr6XzIdrM/jXxEEM7RZX+xsqyuCN8bBzJVzyEgQGQ3E+9BgN4dENE7SIiIiI+JynIBm+AAAQQUlEQVS6azYFBdnwjzOgQxJcN8ctrt7A3lqxnfvfX0dZhSs/wYEGg2HKhYncenYXArUA+yGFJeW88U0a0xZvJreojLsv6M7dFyQe+Y3z/+DWULzkJeg3of4DFREREZFGSd01m4KIVnDe/TD/f2Ddu9Dn8gYP4aozExh4Six7CkpIbBVJWWUlU+ck8/j873lz2XbatAgjIiyI8ae355f92jV4fI1BRt4BZny9jVnLt5NfXM45ifH85oLuDEiIqf2NlRWw6HGX4A26QwmeiIiIiNTJEVvyjDHTgYuBbGvtad6+h4DbgN3eaVOttfO8Y/cBE4EK4C5r7Sfe/lHA34FA4BVr7Z+PJkC15NWgohxeHgG7kiEqAToNgdjuENkaYrtBwpAGb+Gz1vLh2gz+szaD/cXlZO4rZvveIn57QSJ3nd+NgpJyXluyjT0FJfxhVE+ah/rX/zFUVFqWpO5h8abdLNu6l/UZ+wAY3actt53dhf4dj6KLZcFueHcibP0S+l8Lv/i766YpIiIiIk3WCe+uaYwZDhQAb1RL8gqstU9WO/dUYBYwEGgHfAoc7Je2CRgJpAMrgKuttSlHClBJXi0K98C6OZD2lZtxsSDrx2OD7oCL/gQBvpsYpbS8knvnfMec1TsZnhhPcnoeuUVlGAM9Wkfy8g1Jta8JV0VRaTnNQnyfFBaWlLO3sJSI0CDCQwLZW1hKVn4xX2/OYdby7aTnHiAkKIDTO0YzpGsslw3ocNTfkX074dULoWgPjHkSBlxfv19GRERERE4KJ7y7prV2sTGm81Febxww21pbAmw1xqTiEj6AVGvtFi/I2d65R0zypBbN42DQJLcBlJe4RO+b52HZC1CwC8a/CMFhPgkvJCiAp67oR4eYZjzz2Q8MT4xnyshE8g6UcefM1Yx7bgkTzuxITLMQopoFEx0eTEzzEOIjQmkfE05QgOHrzTk889kPrEzL5Y9jenHz0M4YH4xBBEjN3s9VLy097ILyAEO6xHLv6J5c0Ks1YcGBdbt4SQHMvAqK98EtH0O7009AxCIiIiLSFB1P08idxpgbgJXAFGttLtAeWFrlnHRvH8COavsHHcdny+EEhUJ0Aox6HFq0g4UPwJYvIbINNIt1U+/3HNOgIRlj+N3IRCYOPYWoZj92O/xg8lB+M3sN0xZvobzy563JgQGG2OYhZO8voVVkKEmdYnhkbgo/ZO/n3lG9+G5nHqvT8qi0lsiwIFq3CGPkqXVPrkrLK/nn0jTW79zHw+N6Exl2+K6RaTmFXPPyMgICDI9f2ocDpRUcKKugZfMQWrcIpVt8JAmxx7huYWWF66KZnQLXvq0ET0RERESOy7EmeS8AjwLWe3wKuOVEBWWMmQRMAkhISDhRl206jIGhd7mxeZvmQ9FeyN4As6+GYb9zk7YE1LGl6ThVTfAAusRH8J9fD8NaS0FJOXlFZeQVlZFbVMqu/GLScgpJzz1AUqcYrkjqSEhgAE8u2MjzizYza/mOQ1+zam/juIgQbjqrM9cP7vyzz6uustIyf90unvjke9JyigBIzzvAjJsHEh4SSHFZBQtTsigqLafSwrOfp1JWUcnsSUPo0eYELhNxIBc+mgKbPoaxT0G3C07ctUVERESkSTqqJRS87ppzD47Jq+mYN+kK1trHvWOfAA95pz5krb3I2/+T82qjMXknSFkxzL8HVr8BnYbB6ddB1/PcRC0nkQXrd7EuI5+kTjEM6BRDeHAgBSXlrM/Yx7TFW1i0cTfRzYKZcmEPrhmYcGgph+KyCm+rZGHKLqYv2cbWPYX0aB3J1LG9yD9Qxl2zv2V493gu7tuWvy7cRMa+4kOf2yIsiDdvHUyfDlF1D7o4HwKCIKRaS1/KhzDv925s5blTYfjvj+dHIyIiIiJ+ql7Wyaue5Blj2lprM73nvwUGWWsnGGN6AzP5ceKVz4DugMFNvHI+sBM38co11tr1R/psJXkn2KoZ8PmjUOhNjNr1PDfJR2zXn59bnA9lRWAC3AyP4UeY+r8RWJ+xj8fmbuCbLTn0aB1JTPNgUrML2FPw03F0/TpEMfHsLozt0/ZQIvjWiu384d3kQ8enXNiDbq0iAIhuFly3iV8O5MGXT8C2xZC1HsKi4Pr3oV1/1/z4+WPw3yehTV8Y9xy07XtifgAiIiIi4nfqY3bNWcAIIA7IAh70XvfHddfcBtxeJen7I67rZjlwt7V2vrd/DPA33BIK0621/3c0ASrJqweVlZCVDJs+ga//ARWlrhUpJBLSV0DWOjfTY+n+n76v1alw6ng47TKI6+ab2I+CtZZ5ybt49otUwoMD6N7KjZcLDw4kJCiAXm0jGZAQc9gJXOYnZ2KM4aLerY99gpfKCnjzCtiyCDoPg46DYO0sKNkPN7wP69+DJX+HATfA2Ke1RIKIiIiI1KpeWvJ8SUlePcvPgHn3wPdz3esW7aFtf4ju6J6HRoCtdK16PyxwSzWAm97/3PtPuu6eDWLBA/D1M3Dx3yDpZrcvdxu8/gvYnwmVZZA00bWg+nCJCxERERE5OSjJk2OzKxnCW0JU+9rPy8+Ar5+F5S9BUBiMfATOnNgwMZ4M1r4F701ySdzFT//0WG4azL4Wuo6AkY82+GL1IiIiInJyUpInDSNns5s0ZPPnMHgyXPhog8/Y2ajkZ8CnD8N3s6HTUDf+LijE11GJiIiIiB844YuhixxWbFe49h34ZCosfc51RzztUgiLhoh4iOvhs0XYG4S1bszdzlVufbuNH7tumMN+B2dPUYInIiIiIj6jJE+OXUAgjP4LxHR2yd7Gj348ZgIhLtEtG1BS4GbpDAiEwFCXAAWGuu6enYZA0i1u8fbKSshcA6GRENfdZ1/rqCx7ET6+1z2PSoCeY90yCC1P8W1cIiIiItLkqbumnBhFe6EgG0ryYV+6WzYgax1UlLnJW4KbQ2U5VJRAeal7LNkP6Std8pcwxLWIFeW4NeXGvwB9r/Td9ykpcAuUdzrLJaBVZXwLr4x0C5dfOg3CWvgmRhERERFpEtRdU3yjWUu3AXQc6LpuHo29W2HFK5D6KXQb6dbt+/afMOc2lzQm3Qx5O1xC2K5//S83YC2kvA8fT4X9Ga618cxbYdhvoXmci+OdWyCiFYx/XgmeiIiIiDQ6asmTxqe8BOZMcslWVeEx0PNiiO8JedtdEpY4GvpdffxLEZQWwYYPYeVrsGMptOkDI+6DDXPdZCq2EiLbuqQvLw1u+si18omIiIiI1DPNrin+obICVr3m1ueLTnBdOr+fBxvnu0XaQyJdK1r+TrfY+PB7ICcVtn0F5cXQqhe07gM9x7gxfgelr4Idy6BwNxTtgUJv2/2962oa0xmG3Aln3AyBXkP37o0uAczZ4hK8vlfBGTf65MciIiIiIk2Pkjzxb+UlUFroWvWshbUzYeH/urF84JK00EiXmFWUQkRruOAhN35u4YPufHDj/prFQvN49xjTCfpc6ZY/0ALlIiIiItKIaEye+LegULeBW0z89OvczJZp37gultEd3bGKMjepy8IH4P073GyfJsAtcTBkslv4XcmciIiIiPghJXly8guPcd0yqwoMdssz3LIAkt92XTQH3QHxib6JUURERESkgSjJE/8WEAD9JrhNRERERKQJUH81ERERERERP6IkT0RERERExI8oyRMREREREfEjSvJERERERET8iJI8ERERERERP6IkT0RERERExI8oyRMREREREfEjSvJERERERET8iJI8ERERERERP6IkT0RERERExI8oyRMREREREfEjSvJERERERET8iJI8ERERERERP2Kstb6OoVbGmN1Amq/jOIw4YI+vg5BGQ+VBqlOZkKpUHqQ6lQmpSuVBqqteJjpZa+OP9s2NPslrrIwxK621Sb6OQxoHlQepTmVCqlJ5kOpUJqQqlQep7njLhLprioiIiIiI+BEleSIiIiIiIn5ESd6xm+brAKRRUXmQ6lQmpCqVB6lOZUKqUnmQ6o6rTGhMnoiIiIiIiB9RS56IiIiIiIgfUZJXR8aYUcaYjcaYVGPMvb6OR3zDGLPNGJNsjFljjFnp7WtpjFlojPnBe4zxdZxSP4wx040x2caYdVX2Hfb+G+cZr874zhgzwHeRS32poUw8ZIzZ6dUTa4wxY6ocu88rExuNMRf5JmqpL8aYjsaYL4wxKcaY9caY33j7VU80UbWUCdUTTZAxJswYs9wYs9YrDw97+08xxizz7vtbxpgQb3+o9zrVO975SJ+hJK8OjDGBwHPAaOBU4GpjzKm+jUp86Fxrbf8q09veC3xmre0OfOa9Fv/0OjCq2r6a7v9ooLu3TQJeaKAYpWG9zs/LBMBfvXqiv7V2HoD3d2MC0Nt7z/Pe3xfxH+XAFGvtqcBgYLJ331VPNF01lQlQPdEUlQDnWWv7Af2BUcaYwcBfcOWhG5ALTPTOnwjkevv/6p1XKyV5dTMQSLXWbrHWlgKzgXE+jkkaj3HADO/5DGC8D2ORemStXQzsrba7pvs/DnjDOkuBaGNM24aJVBpKDWWiJuOA2dbaEmvtViAV9/dF/IS1NtNau9p7vh/YALRH9USTVUuZqInqCT/m/a4XeC+Dvc0C5wHvePur1xEH6453gPONMaa2z1CSVzftgR1VXqdT+y+o+C8LLDDGrDLGTPL2tbbWZnrPdwGtfROa+EhN91/1RtN2p9f9bnqVLtwqE02I163qdGAZqieEn5UJUD3RJBljAo0xa4BsYCGwGciz1pZ7p1S954fKg3d8HxBb2/WV5Ikcm2HW2gG4LjaTjTHDqx60btpaTV3bROn+i+cFoCuuK04m8JRvw5GGZoyJAN4F7rbW5lc9pnqiaTpMmVA90URZayustf2BDrhW2p4n8vpK8upmJ9CxyusO3j5pYqy1O73HbOA93C9n1sHuNd5jtu8iFB+o6f6r3miirLVZ3h/xSuBlfuxqpTLRBBhjgnH/mH/TWjvH2616ogk7XJlQPSHW2jzgC2AIrqt2kHeo6j0/VB6841FATm3XVZJXNyuA7t7MNyG4AbEf+jgmaWDGmObGmMiDz4ELgXW4snCjd9qNwAe+iVB8pKb7/yFwgzd73mBgX5XuWuLHqo2pugRXT4ArExO82dJOwU22sbyh45P6442VeRXYYK19usoh1RNNVE1lQvVE02SMiTfGRHvPw4GRuHGaXwCXe6dVryMO1h2XA5/bIyx2HlTbQfkpa225MeZO4BMgEJhurV3v47Ck4bUG3vPGuwYBM621HxtjVgBvG2MmAmnAlT6MUeqRMWYWMAKIM8akAw8Cf+bw938eMAY3aL4IuLnBA5Z6V0OZGGGM6Y/rkrcNuB3AWrveGPM2kIKbcW+ytbbCF3FLvRkKXA8ke2NuAKaieqIpq6lMXK16oklqC8zwZkwNAN621s41xqQAs40xjwHf4v5jAO/xn8aYVNwkXxOO9AHmCEmgiIiIiIiInETUXVNERERERMSPKMkTERERERHxI0ryRERERERE/IiSPBERERERET+iJE9ERERERMSPKMkTERERERHxI0ryRERERERE/IiSPBERERERET/y/zPICb9upZE1AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(load)\n",
    "plt.plot(rescaled_Y)\n",
    "plt.legend(['load', 'pred'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-26T18:38:21.891195Z",
     "start_time": "2018-11-26T18:38:18.452738Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] Converting notebook LSTM-v2.ipynb to script\n",
      "[NbConvertApp] Writing 9421 bytes to LSTM-v2.py\n"
     ]
    }
   ],
   "source": [
    "# !jupyter nbconvert --to script LSTM-v2.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-11-26T18:38:21.901581Z",
     "start_time": "2018-11-26T18:38:21.895444Z"
    }
   },
   "outputs": [],
   "source": [
    "# ## get today's load\n",
    "\n",
    "# def get_load_data(date):\n",
    "#     load=[]\n",
    "#     url = 'http://www.delhisldc.org/Loaddata.aspx?mode='\n",
    "#     print('Scraping ' + date, end=' ')\n",
    "#     resp = requests.get(url + date) # send a get request to the url, get response\n",
    "#     soup = BeautifulSoup(resp.text, 'lxml') # Yummy HTML soup\n",
    "#     table = soup.find('table', {'id':'ContentPlaceHolder3_DGGridAv'}) # get the table from html\n",
    "#     trs = table.findAll('tr') # extract all rows of the table\n",
    "#     if len(trs[1:])==288: # no need to create csv file, if there's no data\n",
    "#         with open('monthdata.csv', 'a') as f:  #'a' makes sure the values are appended at the end of the already existing file\n",
    "            \n",
    "#             for tr in trs[1:]:\n",
    "#                 time, delhi = tr.findChildren('font')[:2]\n",
    "#                 load.append(delhi.text)\n",
    "#     if len(trs[1:]) != 288:\n",
    "#         print('Some of the load values are missing..')\n",
    "#     else:\n",
    "#         print('Done')\n",
    "#     return load\n",
    "\n",
    "# yesterday = datetime.today() - timedelta(1)\n",
    "# yesterday = yesterday.strftime('%d/%m/%Y')\n",
    "# load = get_load_data(yesterday)\n",
    "# load = [float(x) for x in load]\n",
    "# np.save('25nov.npy', load)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TF",
   "language": "python",
   "name": "tf"
  },
  "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}