promotions/propensity-scoring-lstm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Propensity Scoring Using LSTM\n",
    "\n",
    "In this notebook, we demonstrate how customer propensity scoring can be performed using models with sequential inputs such as LSTM. \n",
    "\n",
    "### Use Case\n",
    "We assume a marketing scenario where customers need to be provided with personalized *treatments*. Examples of such scenarios include personalized ads, personalized coupons, and personalized  retention offers. The treatments can be applied at different stages of the customer lifecycle including acquisition, cross-selling, retention, and reactivation to improve customer engagement, conversions rates, and lifetime value.    \n",
    "\n",
    "We assume that personalized treatments are chosen based on a numerical score that quantifies the propensity to a certain outcome such as offer acceptance, conversion, churn, or store visit. The methods presented in this notebook compute such scores based on historical customer interaction data (event histories).\n",
    "\n",
    "### Prototype: Approach and Data\n",
    "We build several propensity scoring models using GBDT, dense NN, and LSTM with attention that predict the outcome based on customer account features and event histories. The outcome probability is interpreted as a propensity score.\n",
    "\n",
    "We use a small dataset created based on statistics from a digital media company that sells services on a subscription basis (see `datasets.md/KKBox` dataset). Files are located in the `tensor-house-data` repository under `/promotions/media-dataset` folder.\n",
    "* The dataset includes about 9,000 customer profiles with the daily service usage data. \n",
    "* Each profile is attributed with an `outcome` label. \n",
    "* The `outcome` label equals to one for users who took a specific action of interest (positive outcome), and zero otherwise (negative outcome).\n",
    "* Half of the profiles have positive outcomes and the other half have negative outcomes.  \n",
    "* The dataset includes two tables:\n",
    "    * Users:\n",
    "        * `uid` - user ID\n",
    "        * `location` - location ID (city or region)\n",
    "        * `age` - user age\n",
    "        * `gender` - user gender\n",
    "        * `registration_channel` - ID of the channel though which the user had been acquired\n",
    "        * `registration_date` - registration date\n",
    "        * `outcome` - binary flag that indicates whether the user took a specific action or not\n",
    "    * Usage logs:\n",
    "        * `uid` - user ID\n",
    "        * `date` - activity record date (activity is recorded on a daily basis)\n",
    "        * `views` - how many media items user has consumed\n",
    "        * `items` - how many media items user has interacted with\n",
    "        * `duration` - how much time user spent\n",
    "        * `previews` - how many items user has previewed\n",
    "\n",
    "This demo dataset can be replaced with the actual data that include account data and interaction events.\n",
    "\n",
    "### Usage and Productization\n",
    "This notebook can be used to do the preliminary data analysis and answer the following questions:\n",
    "* Can a sequential-input model outperform traditional look-alike models with aggregated features? \n",
    "* Can a sequential-input model significantly simplify feature engineering? \n",
    "* How a sequential-input model can improve explainability and support customer behavior analysis?\n",
    "\n",
    "Once this evaluation is done, the model architecture can be tuned and production-grade training and inference pipelines can be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.10.2 | TF 2.8.0 | Keras 2.8.0\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Imports and settings\n",
    "#\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import lightgbm as lgb\n",
    "from tabulate import tabulate\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, roc_curve, auc\n",
    "import platform\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential, Model \n",
    "from tensorflow.keras.layers import Dense, LSTM, Input, Concatenate\n",
    "from tensorflow.keras.layers import Lambda, RepeatVector, Permute, Flatten, Activation, Multiply\n",
    "from tensorflow.keras import backend as K\n",
    "import keras_tuner as kt\n",
    "\n",
    "pd.set_option('display.max_columns', 500)\n",
    "pd.set_option('display.width', 1000)\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set_style(\"whitegrid\")\n",
    "plt.rcParams.update({'pdf.fonttype': 'truetype'})\n",
    "warnings.simplefilter(\"ignore\")\n",
    "\n",
    "print(f'Python {platform.python_version()} | TF {tf.__version__} | Keras {tf.keras.__version__}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Visualization and helper functions\n",
    "#\n",
    "    \n",
    "def plot_roc(y_test, y_hat_prob):\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    false_positive_rate, recall, thresholds = roc_curve(y_test, y_hat_prob)\n",
    "    roc_auc = auc(false_positive_rate, recall)\n",
    "    plt.title('Receiver Operating Characteristic (ROC)')\n",
    "    plt.plot(false_positive_rate, recall, 'r', label = 'AUC = %0.3f' % roc_auc)\n",
    "    plt.fill_between(false_positive_rate, recall, color='r', alpha=0.025)\n",
    "    plt.grid(True)\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.plot([0,1], [0,1], 'k--')\n",
    "    plt.xlim([0.0,1.0])\n",
    "    plt.ylim([0.0,1.0])\n",
    "    plt.ylabel('Recall')\n",
    "    plt.xlabel('Fall-out (1 - Specificity)')\n",
    "    plt.show()\n",
    "    \n",
    "def plot_confusion_matrix(y, y_hat_prob, labels):\n",
    "    y_hat = np.where(y_hat_prob > 0.5, 1, 0) # probability to 0-1 binary\n",
    "    cm = confusion_matrix(y, y_hat)\n",
    "    accuracy = accuracy_score(y, y_hat)\n",
    "    plt.figure(figsize=(4, 4));\n",
    "    sns.heatmap(cm, xticklabels = labels, yticklabels = labels, \n",
    "                annot = True, cbar=False, fmt='d', annot_kws={'size': 16}, \n",
    "                cmap=\"Wistia\", vmin = 0.2);\n",
    "    plt.title(f'Confusion Matrix\\n({len(y)} samples, accuracy {accuracy:.3f})')\n",
    "    plt.ylabel('True Class')\n",
    "    plt.xlabel('Predicted Class')\n",
    "    plt.show()\n",
    "    \n",
    "def print_df(df, col_width = 10, rows = 10, max_cols = 10):\n",
    "    def short_srt(x):\n",
    "        return x if len(x) < col_width else x[:col_width-3] + \"...\"\n",
    "    df_short = df.head(rows).applymap(lambda x: short_srt(str(x)))\n",
    "    \n",
    "    if len(df_short.columns) > max_cols:\n",
    "        df_short = df_short.iloc[:, 0:max_cols-1]\n",
    "        df_short['...'] = '...'\n",
    "    \n",
    "    print(tabulate(df_short, headers='keys', tablefmt='psql'))\n",
    "    print(f'{len(df)} rows x {len(df.columns)} columns')\n",
    "    \n",
    "def normalize(df, columns):\n",
    "    for c in columns:\n",
    "        df.loc[:, c] = (df[c] - df[c].min()) / (df[c].max() - df[c].min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------+-------+----------+---------------+---------------------+-----------+\n",
      "|   uid |   location |   age | gender   |   reg_channel | reg_date            |   outcome |\n",
      "|-------+------------+-------+----------+---------------+---------------------+-----------|\n",
      "|     0 |         15 |    17 | female   |             3 | 2014-10-21 00:00:00 |         1 |\n",
      "|     1 |         13 |    40 | female   |             9 | 2006-05-26 00:00:00 |         0 |\n",
      "|     2 |         14 |    23 | male     |             9 | 2007-03-25 00:00:00 |         1 |\n",
      "|     3 |          1 |    19 | female   |             3 | 2014-11-02 00:00:00 |         1 |\n",
      "|     4 |          1 |     0 | nan      |             9 | 2014-11-08 00:00:00 |         1 |\n",
      "|     5 |         21 |    21 | male     |             9 | 2007-10-12 00:00:00 |         1 |\n",
      "|     6 |          1 |     0 | nan      |             7 | 2014-04-16 00:00:00 |         1 |\n",
      "|     7 |          5 |     0 | nan      |             9 | 2013-02-06 00:00:00 |         1 |\n",
      "|     8 |         13 |    18 | female   |             9 | 2013-02-06 00:00:00 |         0 |\n",
      "|     9 |          5 |    29 | male     |             9 | 2013-02-12 00:00:00 |         1 |\n",
      "+-------+------------+-------+----------+---------------+---------------------+-----------+\n",
      "8979 rows x 6 columns\n",
      "+-------+---------------------+---------+------------+------------+\n",
      "|   uid | date                |   views |   previews |   duration |\n",
      "|-------+---------------------+---------+------------+------------|\n",
      "|     1 | 2015-02-18 00:00:00 |       5 |          2 |        209 |\n",
      "|     1 | 2015-04-12 00:00:00 |      12 |          3 |        376 |\n",
      "|     1 | 2015-06-01 00:00:00 |       4 |          2 |        136 |\n",
      "|     1 | 2015-07-22 00:00:00 |      12 |         17 |        562 |\n",
      "|     1 | 2015-09-12 00:00:00 |      40 |          8 |       1021 |\n",
      "|     1 | 2015-11-02 00:00:00 |      46 |         17 |       1261 |\n",
      "|     1 | 2015-12-22 00:00:00 |      18 |          6 |        539 |\n",
      "|     1 | 2016-02-11 00:00:00 |       5 |          9 |        238 |\n",
      "|     1 | 2016-04-01 00:00:00 |      20 |          6 |        559 |\n",
      "|     1 | 2016-05-23 00:00:00 |       6 |          0 |        197 |\n",
      "+-------+---------------------+---------+------------+------------+\n",
      "2324214 rows x 4 columns\n",
      "Profiles with positive oucomes: 4556 (50.74%)\n",
      "Users without events: 76\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Import data\n",
    "#\n",
    "data_path = '../../tensor-house-data/promotions/media-subsription/'\n",
    "df_users = pd.read_csv(data_path + 'users.csv.zip', compression='zip', index_col='uid', parse_dates=['reg_date'])\n",
    "df_logs = pd.read_csv(data_path + 'usage_logs.csv.zip', compression='zip', index_col='uid', parse_dates=['date']).drop(columns=['items'])\n",
    "\n",
    "print_df(df_users)\n",
    "print_df(df_logs)\n",
    "n_positives = df_users['outcome'].sum()\n",
    "print(f'Profiles with positive oucomes: {n_positives} ({n_positives/len(df_users):.2%})')\n",
    "print(f'Users without events: {len(set(df_users.index).difference(set(df_logs.index)))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------+-------+---------------+-----------+---------+------------+------------------+---------------+------------+-------+\n",
      "|   uid |   location |   age |   reg_channel |   outcome |   views |   previews |         duration |   time_bucket |   reg_days | ...   |\n",
      "|-------+------------+-------+---------------+-----------+---------+------------+------------------+---------------+------------+-------|\n",
      "|     0 |         15 |    17 |             3 |         1 |    2677 |       4600 |  86544           |        -21397 |        856 | ...   |\n",
      "|     1 |         13 |    40 |             9 |         0 |   23010 |       7136 | 635905           |        -42349 |       3926 | ...   |\n",
      "|     2 |         14 |    23 |             9 |         1 |   52578 |       5000 |      1.32565e+06 |        -43688 |       3623 | ...   |\n",
      "|     3 |          1 |    19 |             3 |         1 |    5422 |       2072 | 145091           |        -28555 |        844 | ...   |\n",
      "|     4 |          1 |     0 |             9 |         1 |   20754 |       7240 | 509117           |        -38909 |        838 | ...   |\n",
      "|     5 |         21 |    21 |             9 |         1 |   12494 |       1585 | 347797           |        -23126 |       3422 | ...   |\n",
      "|     6 |          1 |     0 |             7 |         1 |    1713 |        343 |  42942           |         -8416 |       1044 | ...   |\n",
      "|     7 |          5 |     0 |             9 |         1 |     262 |         81 |   6729           |         -2235 |       1478 | ...   |\n",
      "|     8 |         13 |    18 |             9 |         0 |     489 |        591 |  16577           |           -69 |       1478 | ...   |\n",
      "|     9 |          5 |    29 |             9 |         1 |    4464 |       2072 | 127716           |        -32342 |       1472 | ...   |\n",
      "+-------+------------+-------+---------------+-----------+---------+------------+------------------+---------------+------------+-------+\n",
      "8979 rows x 11 columns\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Basic feature engineering\n",
    "#\n",
    "profiles = df_users.join(df_logs.drop(columns='date').groupby('uid').agg('sum'), on='uid')\n",
    "profiles['reg_days'] = (profiles['reg_date'].max() - profiles['reg_date']).dt.days\n",
    "profiles = pd.get_dummies(profiles, columns=['gender'])\n",
    "profiles.drop(columns=['reg_date'], inplace=True)\n",
    "print_df(profiles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 1: Baseline Using GBDT\n",
    "\n",
    "We start with building baseline models. The first baseline is a typical look-alike model that is based on gradient boosted decison trees (LightGBM) and aggregated features.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Train test split\n",
    "#\n",
    "x, y = profiles.drop(columns='outcome'), profiles['outcome']\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 4 folds for each of 90 candidates, totalling 360 fits\n",
      "Best params: {'colsample_bytree': 0.65, 'learning_rate': 0.05, 'n_estimators': 64, 'num_leaves': 24}\n",
      "Best score: 0.6989967440225928\n",
      "Fitting with params: {'max_depth': -1, 'num_leaves': 24, 'learning_rate': 0.05, 'max_bin': 512, 'subsample_for_bin': 200, 'subsample': 1, 'subsample_freq': 1, 'colsample_bytree': 0.65, 'num_class': 1, 'metric': 'binary_error', 'verbosity': 0, 'n_estimators': 64}\n",
      "[LightGBM] [Warning] Using too small ``bin_construct_sample_cnt`` may encounter unexpected errors and poor accuracy.\n",
      "[LightGBM] [Warning] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000169 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n"
     ]
    }
   ],
   "source": [
    "train_data = lgb.Dataset(x_train, label=y_train)\n",
    "\n",
    "# Model hyper-parameters\n",
    "params = {'max_depth' : -1,\n",
    "          'num_leaves': 64,\n",
    "          'learning_rate': 0.07,\n",
    "          'max_bin': 512,\n",
    "          'subsample_for_bin': 200,\n",
    "          'subsample': 1,\n",
    "          'subsample_freq': 1,\n",
    "          'colsample_bytree': 0.8,\n",
    "          'num_class' : 1,\n",
    "          'metric' : 'binary_error',\n",
    "          'verbosity' : 0\n",
    "          }\n",
    "\n",
    "# Parameters to optimize\n",
    "gridParams = {\n",
    "    'learning_rate': [0.02, 0.05, 0.07],\n",
    "    'n_estimators': [8, 16, 32, 64, 128],\n",
    "    'num_leaves': [20, 24, 28],\n",
    "    'colsample_bytree' : [0.60, 0.65]\n",
    "    }\n",
    "\n",
    "# Create the classifier\n",
    "mdl = lgb.LGBMClassifier(boosting_type= 'gbdt',\n",
    "          objective = 'binary',\n",
    "          n_jobs = 5, \n",
    "          max_depth = params['max_depth'],\n",
    "          max_bin = params['max_bin'],\n",
    "          subsample_for_bin = params['subsample_for_bin'],\n",
    "          subsample = params['subsample'],\n",
    "          subsample_freq = params['subsample_freq'])\n",
    "\n",
    "mdl.get_params().keys()\n",
    "\n",
    "# Create the grid\n",
    "grid = GridSearchCV(mdl, gridParams, verbose=1, cv=4, n_jobs=-1)\n",
    "\n",
    "# Search for optimal parameters\n",
    "grid.fit(x_train, y_train)\n",
    "\n",
    "# Print the best parameters values\n",
    "print(f'Best params: {grid.best_params_}')\n",
    "print(f'Best score: {grid.best_score_}')\n",
    "\n",
    "params['colsample_bytree'] = grid.best_params_['colsample_bytree']\n",
    "params['learning_rate'] = grid.best_params_['learning_rate']\n",
    "params['num_leaves'] = grid.best_params_['num_leaves']\n",
    "params['n_estimators'] = grid.best_params_['n_estimators']\n",
    "\n",
    "print(f'Fitting with params: {params}')\n",
    "\n",
    "# Train the model on the selected parameters\n",
    "lgbm = lgb.train(params,\n",
    "                 train_data,\n",
    "                 num_boost_round=200,\n",
    "                 verbose_eval= 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAHsCAYAAADLkTRCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABpFklEQVR4nO3ddXxV9QPG8c8a2OhSke5QAQOQkhiMFIYwOiUE+UlJKSFdBqGYdIOgdIwRgiDS4RCRRqRrg+U9vz8ODJAc7O7ce/e8Xy9e59bufXYYe/ie+B43wzAMRERExOm5Wx1AREREEoZKXURExEWo1EVERFyESl1ERMRFqNRFRERchEpdRETERXhaHUCSlvz585MvXz7c3d1xc3Pj5s2b+Pn5MXDgQF566aUE/7y3336b6dOnkypVqgR/b4DZs2cze/ZsYmJicHNzo1ChQnTt2pUXXnjBLp/3X/PnzycqKoomTZowe/Zsrl+/Trt27RLkvWNjY5k2bRpLliwhNjaW6OhoKlSowAcffIC3tze9e/cmb968tGnTJkE+70mtX7+ePXv28MEHH8Tr68aOHUv27NmpU6fOQ18zYcIEChQoQOXKlZ/o9f8VFhbGBx98wJdffsny5csZOnQoL774IgCGYRAWFsZrr73G4MGD8fHxAeCPP/5g7NixHDlyhBQpUpAiRQratGlD5cqV49732rVrjBs3jt9++y3u306TJk2oX78+ACNGjKBChQqUKFEiXutEXJAhkojy5ctnXLx48Z7Hvv/+e6NBgwYWJXp6I0aMMFq2bGn8888/hmEYRmxsrLFo0SKjTJkyxpkzZxIlQ69evYzvv//eLu/98ccfG507dzauXbtmGIZhhIeHG++9957Ro0cPu3/2o4wbN8745JNP7PLeTZs2NVasWPHUXz9gwIC4r//xxx+Ndu3a3fN8RESEUbduXWP27NmGYRjGnj17jLJlyxrr1q2Le83hw4eNGjVqxL0mIiLCqFWrlvHtt98a0dHRhmEYxqlTp4zKlSsb8+bNMwzDMK5du2bUrFnTuHnz5lNnF9egkbpYKiYmhjNnzpA6deq4xyZOnMjq1aux2WxkyZKFAQMGkDlzZs6fP8+AAQM4cuQI7u7uNGzYkObNm3P9+nWGDh3KoUOHiI6OplSpUvTs2RNPT0/y58/Pli1b6NixI61ataJq1aoAjB49GoAPP/yQ+fPnM3v2bGw2G2nSpKFfv37kzp2b3r17c+XKFU6ePMlbb73Fhx9+GJfx33//Zc6cOaxfvz4uu7u7O3Xq1GH//v188803DBgwgIoVK1KjRg02b97M9evXadWqFY0bNwYgJCSEiRMnEh0dTbJkyejVqxfFihVj/Pjx7N69m3PnzpE/f3569+5N//79uXjxIufPnydLlix88cUX7Ny5k5CQEDZv3kyyZMm4dOkSly9fpn///lSsWJG6deuyZcsWzpw5w9tvv02XLl0A+Pbbb1mwYAG+vr689tprrF27lpCQkHv+Xk6dOsWSJUvYtGkTfn5+AKRIkYJPPvmEnTt3xr1u165dNGzYkAsXLpA3b14+/fRTUqRIwYIFC5g7dy7R0dFcvXqVtm3b0rhxYxYuXMiCBQvittB88803DBw4kOPHj3PlyhV8fX0ZM2YMuXLleuDf9yuvvMKcOXOIjY0lZcqUdO3a9Yn//i5evBi3ZWHcuHGsWbMGLy8v0qZNy/Dhw1mzZg379+9n1KhReHh4sHbt2rjX79mzhyFDhnDz5k28vLzo2bMnpUqVumednTlzhnXr1vHxxx8/9Of9ypUrhIWFxf3MjB07lg4dOvDWW2/FvSZ37tyMGjWKli1bEhgYyPLly0mRIgVt27aNe83tn4Ho6GgAUqZMSbFixZg7dy4tWrR46OdLEmD1/yokacmXL59Rs2ZNo2bNmkbp0qWNihUrGoMHDzYuXLhgGIZhLFq0yOjSpUvciGTOnDnGu+++axiGYXTq1MkYOXKkYRjmyKRGjRrGsWPHjN69exvTpk0zDMMwYmJijB49ehjffvtt3OddvHjRWLBgQdyoKSYmxihTpoxx9OhR47fffjMaN25s3LhxwzAMw/jll1+MgIAAwzDMkWiLFi0e+H2sXLnSCAwMfOBza9euNWrVqmUYhmFUqFDB6Nevn2Gz2YwzZ84YJUqUMA4ePGgcPXrUqFmzpnHp0iXDMAzj0KFDRunSpY3w8HBj3LhxRtWqVePWwZQpU4xvvvnGMAzDsNlsxrvvvmv88MMPcRlvj5bvHsFWqFDBGDFihGEYhvHvv/8aL730knHixAlj48aNRtWqVY2rV68aNpvN6NOnj1GhQoUHfn/16tV76N/j7c9+5513jBs3bhgxMTFG3bp1jUWLFhlhYWFGgwYN4r63Xbt2GUWLFjUMwxy9vv7668b169cNwzCMFStWGIMHD457z379+hmDBg0yDOPhf993f5/x+fu7va7++ecfo3jx4kZkZKRhGIbxww8/GGvWrDEM496R+u3XR0VFGaVLl44bTe/bt8+oWbOmERsbe8/6mD59utGrV6+4+z/++KNRvHhxo3bt2kbVqlWNEiVKGEFBQXEjcMMwjKJFixqHDh164Pp94403jAMHDhiDBg2KWw+PsmrVKqNJkyaPfZ24No3UJdFNnTqVdOnSceDAAdq1a0eJEiVInz49AOvWrWPfvn3Uq1cPAJvNxs2bNwH49ddf40bLKVOmZOnSpYC5j3Xfvn0sWLAAgIiIiPs+s3r16owaNYrz58/zxx9/kCNHDnLkyMG8efM4fvw4DRs2jHvttWvXuHLlCgCvvvrqQ7+PmJiYBz4eFRWFm5tb3P3GjRvj5ubGc889R9myZdm8eTM+Pj6cO3eOli1bxr3Ozc2NEydOAFC0aFE8Pc1/ni1atGD79u1MnjyZY8eO8ddff/HKK688NNdtlSpVAiBz5sykT5+eq1evsmHDBgICAuKOMWjSpAlbt26972vd3d2x2WyP/YzKlSuTPHlyAPLmzculS5fw9fXl66+/ZsOGDRw7doyDBw9y48aNuK/Jnz9/3Og/ICCArFmzMn36dI4fP862bdsoVqwY8PC/77utX78+3n9/mTNnpkCBAtStW5dy5cpRrly5+0bddzt06BDu7u5xo+kiRYqwZMmS+1535MgRsmXLds9jr732Gt988w02m42vvvqKpUuXEhAQcM9rHvdz5ObmhvEEs3m/+OKLHD169LGvE9emUhfLFC5cmD59+tC7d28KFizIiy++iM1m4913343bRB0VFcXVq1cB8PT0vKcsT548Sdq0abHZbIwdO5bcuXMD5i/1u18HkDx5cqpWrcrSpUvZtWtX3AFGNpuNt99+O648bDYb586di9s8miJFigdmL1q0KMePH+f8+fNkzJjxnud+++23uGK6nfs2m80WV5ilSpXiiy++iHvuzJkzZMqUiTVr1tzzuaNHj2bv3r3Uq1ePEiVKEBMT80S/5G8fiAXEFYOnp+c9X+vh4fHAr3355Zc5cuQIYWFhcQUMcPbsWfr168e4cePu+95uf8a///5LUFAQDRo04NVXXyUgIIB169bFve7u723WrFnMmzePJk2aUKtWLdKkScOpU6fi3vtBf993e5q/P3d3d2bMmMG+ffvYsmULw4YNo2zZsvTs2fOB68LDw+O+n6dDhw6RK1eu+77/h/1HyN3dnffff59du3bRu3dvvv76awCKFy/Ob7/9RsGCBe95/d69e/Hy8iJXrlwULVqUmTNn3veea9euZfv27fTq1Stufbm764SmpE4/AWKpmjVr8vLLLzN8+HAAypQpw4IFCwgLCwPMfY63f9mWKlWKH3/8EYDr16/TokULjh07RpkyZZgyZQqGYRAVFcV7773HjBkz7vusBg0asGjRInbu3Bm3b71MmTIsW7aMc+fOAebR7E+yTzJz5sw0a9aMbt26cfbs2bjHf/zxR1avXn3P/s+ffvoJgH/++YfNmzfHjQw3b97M33//DcCGDRuoXbv2A7cybNq0iRYtWlCnTh3Sp0/Pr7/+SmxsLGAWzsNGeg9Svnx5Vq9ezfXr1wHitm486PurVasWffv2jfu7CAsLY+DAgaRJk4ZkyZI99DP2799PunTp6NixI2XKlIkr9NuZ//u91a1bl/r165MzZ05CQkLiXvewv++7v+en+fs7ePAgNWvWJHfu3LRv356WLVuyb98+4MHrM1euXLi5ubF582YADhw4QIsWLe4r8Jw5c3Ly5MlHfvaAAQPYvHkzwcHBAHTv3p3vv/+eDRs2xL3m77//pk+fPnzwwQf4+PhQpUoVwsLC+O677+LWzcmTJxkxYkTcf2TBPA4iV65cj/x8cX0aqYvl+vXrR+3atfnll1+oX78+Z8+epUGDBri5ufH8888zYsQIAPr378/AgQOpVasWhmHQvn17ihQpwkcffcTQoUOpVasW0dHRvPnmm7z77rv3fU6RIkXw8PAgICAgbhRbpkwZ2rZtS+vWrXFzc8PPz48JEybcNzJ7kO7duzN//nzee+89oqKiiIqK4qWXXmLOnDlkyZIl7nWnTp0iMDCQiIgIPv7447hfvIMGDaJbt25xI+iJEyfi6+t73+d06tSJUaNGMXbsWLy8vChevHjcZvpy5crFrZ8nUapUKRo0aEBQUBDJkiUjb968cZvP/2vAgAF89dVXNGzYEA8PD6KioqhcuTKdO3d+5GeULl2aBQsWEBAQgJubG2+88Qbp0qXj+PHj9722devW9O/fP+4/F0WLFuXQoUPAw/++o6Ki6NGjB4MHD6Zfv37x/vsrUKAA1apVo169eqRIkYJkyZLFHdxWsWJFPvvss7gD0AC8vb0ZP348w4YNY9SoUXh5eTF+/Hi8vb3ved/KlSvz/fffExsb+9AtINmyZaNt27YMHz6csmXLUqhQIX744QfGjh3LsGHD8PDwIFWqVHTu3DluM723tzeTJ09m9OjR1KpVCw8PDzw8PHjvvfcIDAyMe+9ffvnlvk37kvS4GU+yHU9EnkrFihUZO3asXc7Bfxr79u1j165dNG/eHIDJkyezZ8+ee3YDyNPr168fpUqVonr16on6uWFhYTRs2JAff/zxnt0ukvRo87tIEpIzZ062b99OzZo1qVWrFlu2bKFPnz5Wx3IZt0+RfNBuFHsaP348ffv2VaGLRuoiIiKuwm4j9T179tCsWbP7Hg8JCaFevXoEBQUxb948e328iIhIkmOXA+W+++47Fi9efN8BONHR0QwfPpwFCxaQPHlyGjVqRIUKFe47JUhERETizy4j9WzZsjF+/Pj7Hv/777/Jli0bqVOnxtvbm1dffZXt27fbI4KIiEiSY5eRetWqVeMmkLhbWFgYKVOmjLvv6+sbdw7so+zYsUOTKtjZ7UlRxL60nu1P69j+kuQ6Ngy8Tp+Gu+Zb8Lg138N9L3V3x+brC09waux/3YyN5e8bN3B3cyNf4cIULVo0Xl+fqOep+/n5ER4eHnc/PDz8npJ/GHd393tm6JKEFxoaet+sVpLwtJ7tT+vY/pLUOrbZ4JdfoHlzuDU/BLf7yDAgeXJo3BgCAiBNGvNxb294xARNDxMZGUm+IkWIjo4mZMUKDC+veL9HopZ67ty5467GlCJFCrZv357o12IWERHhyhWIiYGrV2HrVjhz5t7n//0Xtm+HnTvh+nWzpIOCYMIEuHXthITm4+PDlO++48UsWcibOzehR47E+z0SpdSXLFnCjRs3CAoKonfv3rRp0wbDMKhXrx6ZM2dOjAgiIpJUGQasXw+ff26OvNevh7u2Gj+Qjw+8/LI5Ci9WDGrWBDsd1P3btm38ERpKqxYtqHD7MrxPcEGlB7Fbqb/44otxp6zVqlUr7vGKFStSsWJFe32siIgkRf/+CwMHgud/am3HDvPPXVP/UrQoXLwInTuDry+8+irkynXvPvBkycDL66n2i8fHps2bqVa7Ns8/9xyNbk3f/Cw097uIiDi2yEj470HVhw7Bpk3mcytWwK+/3nnu1qWcAbOcGzeGIkXgrbegQAFzn7cDWLd+PTXr1iXriy+yduXKZy50UKmLiIij2rYNjh+Htm3Nfd8PkymTuXm8WDH48MP7S9vOo+2nsXrNGt5+5x1y5czJ2pUree655xLkfVXqIiLiWGJiYORIuHX1PABq1TJH2ncrUADeeMM8Av0pjhS30r79+8mfLx9rli9P0AnYVOoiImK96GhzlL12LZw+DZcvm4/PnAklSsCLLzrkiDu+rl+/TsqUKenetSud3nsvQTa53y2JzR4gIiIO58YNCAyEsWPhuefMUfmkSbB5M9SrB1mzukShz//xR3IVKMDeffsAErzQQSN1ERFJaL/9BrVrm+eCP8lBadHREBVllnr79i5R4P81c/ZsmrduzZulSpEzRw67fY5KXUREns2lS/DHHzBsmDnr2unTZqE3bgwZMjzZe1SuDFWquGShT546lTbt2/NW+fIsWbgQX19fu32WSl1ERJ5emzbmpvK7NWgAXbqY538ncatWr6Z1u3b4V6rETwsWkCJFCrt+nkpdRETiJyYG5syBRo3uPDZxIpQvDzlygIeHZdEcTYW33mLY4MF0/d//7LIP/b9U6iIi8nCrV0P37ubtW5vGC9460AuAcuXgs8/gpZcsCOe4Jk+dSs3q1cmYMSN9evZMtM9VqYuICPz+O5w8ad7++WdzP/nBg3D4sPmYv795PjhwLUMGUqVIYU6zWr48JLXLsD7GsJEj+ah/f/r07MmwwYMT9bNV6iIiSdXZs7Bxozk3+siR9z//8svm+eEffwwtW8aN1E+HhpIqqVx6NR4Mw+CTIUP4ZMgQmjRqxKABAxI9g0pdRCSpuX7dHJWXKWNO8uLmZo7C+/SBqlXN1+TODSlTWpvTiRiGwUf9+zN81ChaNm/O919/jYcFxxao1EVEXE1UFKxZAz/+COfP33ua2Nat5mNglvaaNfDaa2apu+DpZInl+vXr/LhoEe3atGHihAm4W7RLQqUuIuLsLl40zw+/fBk++AD277/3+VdeuXP7+efNy5N26mSeG16sWOJmdTE2mw2bzUaqVKnYsnEjadOmxc3C/xyp1EVEnNH167BsmXl0+uTJdx7PnNksbMOAZs0gTx5Ilcq6nC7MZrPRoVMnwsLDmTFlCunSpbM6kkpdRMTpHDhgXh8czE3mpUqZm9DLlDGvWvbCC9bmSwJiY2N5t0MHpkybRt9evSwdnd9NpS4i4iyOHDEPYLutRw/o3Rv8/LQ/PBHFxMTQok0bZs2Zwyf9+9Ovb1+VuoiIPERsrLlfPDgYNmyA48fNg98OHrzzmhUrzOuL6xzxRNeuY0dmzZnDsMGDE3VimSehUhcRcRTR0VC3LuzebV4UBcDHx5zgxccHsmUzTznr0ME82E0s0bJZM1556SU+6NzZ6ij30U+FiIgVrl2DJUtgy5Y7c6UvWwZ//23e7tfPnHrV3x/sfBEQebyIiAhWrlpFnbffplzZspQrW9bqSA+kUhcRSQwffQSLFoGXl7n/e8+eO8+lSWMu3dzMqVdHjNBI3IHcuHGDOu+8Q3BICAd27aKgA8+mp58aERF7iYqCtWthwABzbnWAGjXM8n7xRciUCTp2vP9iKA5y0JVAWFgYtQID2bBxI5O+/dahCx1U6iIiCe/0afPqZUeO3Pv45s3mqWfiFK5du0b1t99my9atzJgyhcYNG1od6bF02KSISEILCLhT6B06mGV+/rwK3cmsWLWK37ZtY86MGU5R6KCRuohIwho69M40rTdu3DkITpyGYRi4ubkRVL8+rxUvTu675wZwcBqpi4gkhJMnoWdP8zKlAF9/rUJ3QufPn6dsxYr8umULgFMVOmikLiLybMLCYOzYO2UOMHs2BAZal0meyr///kulgACOHD1KWFiY1XGeikpdRCS+DAPWrTP3k9+9r/W998xT1zJmtC6bPJXTp09TsWpVTp0+zfKff6bCW29ZHempqNRFROLrf/+DCRPu3Pf1hT/+MK+QptPRnM7Zs2cpX7ky586fZ9XSpZQpXdrqSE9N+9RFRJ7UtGlQuDBMn27eX73anNL1wgV47jkVupNKnz49b5Uvz5rly5260EEjdRGRJ9OkCcyadef+p5+ac7KL0zp8+DC+vr48//zzfP/111bHSRAqdRGRxzl+HBYvNq9hvmABZM+uq6M5udDQUCpVq0bePHlYv2aNw1w69Vnpp1JE5EFuT/H62muQI4d5lHtAAOTMqUJ3cvsPHOCtKlWw2Wx8NW6cyxQ6aKQuInKv2FjzFLXu3e99/IsvICjIkkiScHbt3o1/9er4+PgQsnIl+fPntzpSglKpi4gAXL4Mo0fD8OF3HqtTx7xq2uuvm9czF6dmGAYfdO9OihQpCFm5kjx58lgdKcGp1EVEFi+Gt9++97EDByB3bh3R7kLc3NyYP2sWN2/eJEeOHFbHsQvtGBIRGTvWXDZpYo7YIyIgTx4Vuov4ZdMmWrRpQ3R0NJkzZ3bZQgeN1EUkKVm3DpYsuf/xkBBz+cMPKnIXszYkhNr16pEta1auXLlCRhef7U+lLiKu7/p1s7C7djXvp0x57/OenjBihArdxaxavZo69euTJ3duglescPlCB5W6iCQFP/98p9BnzoR69azNI3a3bPlyAoOCKFSwIGuWLydDhgxWR0oUKnURcU1XrkDFihAaeuexXbugYEGNyJOADBkyULZ0aebNmkW6dOmsjpNoVOoi4ho2bYJPPyVnaKh5gZWdO+8816YNZMkCBQqo0F3cwYMHKVCgACXeeIM1K1a41MQyT0KlLiLOLTISqlUzD4IDkoF5v1o1yJQJvvwSvLwsjSiJY8asWbRo04aZU6fSsEGDJFfooFIXEWf199/m5vUTJ+48tnw5oenTU7BoUctiiTUmTZnCux06UKF8eWrVqGF1HMvoPHURcS7Hj5ub0PPkuVPoHTqYj1eqpJnfkqBvvvuONu3b41+pEkt/+glfX1+rI1lGI3URcR6bN0OZMuZtT0/47juoXRv8/KzNJZb5IzSU9zp3pka1aiyYM4dkyZJZHclSKnURcWxnz8K+feYFVZYtMx9Llsyc+U1XS0vyChUsyNJFi6hcqRLe3t5Wx7Gc/kWIiOMKCYHnngN//zuF/vXXcO6cCj2JGzVmDOvWrwegerVqKvRb9K9CRByPzQbvv2/uIwcIDITgYLh5E1q10n7zJMwwDAYMGkSvjz5izrx5VsdxONr8LiKOZ/Ro81Q0gFWroHx5nV8uGIZBn48/ZuSYMbRu2ZKvxo+3OpLDUamLiOP55BNzuWYNlCtnbRZxCIZh0L1nTz4fN44Obdvy5bhxuGsXzH20RkTEsfz+u7mZvWNHFbrEMQyDCxcv8r9Onfhq/HgV+kNopC4ijmHSJHM619sKFbIuizgMm83GxYsXyZgxI5O/+w53d/ckOVPck9J/dUTEWn37mgV+u9Bz5zb3p7/7rrW5xHKxsbG0bteOUuXKce3aNTw8PFToj6FSFxHrXLoEw4ebV1Tr2BEOH4YDB8xC1y/vJC0mJoZmrVoxdfp0WjRrRqpUqayO5BRU6iJijV9/hfTpzdtBQfD555A1q8pciIqKomHTpsyeO5cRQ4fSr29fqyM5DZW6iCSuf/6BHj2gdGnzfrlyMGCAtZnEoXw8YAA/LlrEZ6NG0atHD6vjOBUdKCciiefYMciZ8879Hj1gyBCNzuUePbt3p+grr9C4YUOrozgdjdRFxL6iosz95AcO3DmivWRJOH8ehg5VoQsAN27cYODgwURGRpIhQwYV+lPSSF1E7KtwYfMAuLuFhICHhzV5xOGEhYVRs25dftm0iTJvvknl29MDS7yp1EXEftavv1Po06ebyxIlVOgS5+rVq1R/+21+27aNGVOmqNCfkUpdRBKeYcCYMdCzp3k/JOTOgXEit1y+fJmqNWuya/du5s6cSb26da2O5PRU6iKS8DZtulPo5crBm29am0cc0qnTpzlx8iQ/zplD7Vq1rI7jElTqIpKwDOPOnO3Ll0PFijoYTu4RHh6Or68vLxUpwt+hofj6+lodyWXo6HcRSRgnTsAff0Dlyub9115Toct9zpw5w+tvvsmoMWMAVOgJTCN1EXl2e/fCK6/cuZ8nj3nZVBW63OXUqVNUrFqVf86cocQbb1gdxyWp1EXk2X3zjbns3ds8F71kSUiRwtpM4lCOHz9OxapVOX/hAquWLqW0jrOwC5W6iDybAwfgq68gXTpo2xZefNHqROJgbt68SYUqVbh0+TLBK1bwxuuvWx3JZanUReTZVKxoLn/4QYUuD5Q8eXI+6d+fwoUKUbxYMavjuDSVuog8vZ074dw583ZAgLVZxOGEhoZy6vRp/CtXplmTJlbHSRJU6iISf2vXwurVMGqUeX/GDHDXyTRyx779+6kUEICfry8H9+3D29vb6khJgkpdROJvwADzeuju7pAmDdSubXUicSC7du/Gv3p1kiVLxsolS1ToiUilLiJPxjBg82a4cMFcVqkCixebz+nUNbll2++/U7VmTVKlSkXIypXkzp3b6khJikpdRJ5M8+bmZvbbAgNV5nKfOfPmkTZNGtatXk327NmtjpPkaCeYiDxaVJR5qtrtQl+yBH77DVq0sDaXOJTY2FgAxowcyW+bNqnQLaJSF5FHq10bvv/evD1lirnZvWhRHRgncdaGhPBS8eIcP34cd3d3MmbMaHWkJEub30Xk4Q4fhlWrzNuHDoFGX/IfK1etom6DBuTNk4fkyZNbHSfJ03+1ReThSpQwl59+qkKX+yxZupS333mHAvnzE7JqFZkyZbI6UpJnl1K32Wz079+foKAgmjVrxvHjx+95fvHixdStW5d69eoxa9Yse0QQkWexZw9Urw6XLkGOHNC6tdWJxMEEr11LYFAQr7z8MiGrVpEhQwarIwl2KvXg4GCioqKYO3cu3bt3Z8SIEfc8P2rUKCZPnszs2bOZPHkyV69etUcMEYmv3bvNaV+LFoUVK8zHhg/XxVnkPq+9+iptWrZkzfLlpE2b1uo4cotd9qnv2LGDsmXLAlC0aFH2799/z/P58+fn+vXreHp6YhgGbjotRsR6NhvcPS/3N99As2bg4WFdJnE4K1etInOmTKRJk4avv/zS6jjyH3Yp9bCwMPz8/OLue3h4EBMTg6en+XF58+alXr16JE+eHH9/f1KlSvXI97PZbISGhtojqtwSERGhdZwIHHI922xkGj0arzNnSAVE5MnD0XnzzKPbDx2yOl28RUZGOt46dhE/LlpE/0GDeLdVK7r+739Wx3FtNhv4+MT7y+xS6n5+foSHh8fdt9lscYV+8OBB1q9fz9q1a0mRIgUffvghK1asoFq1ag99P3d3dwoWLGiPqHJLaGio1nEicMj1fPo0TJ0KmTJBwYIkGzeOgoULW53qqTnkOnYBX339Nf0++YSAKlV4r107rWN7s9kIPXIk3l9ml33qxYsXZ+PGjQDs3r2bfPnyxT2XMmVKkiVLho+PDx4eHqRLl45r167ZI4aIxEf//rBrF5QrZ3UScTBfjBtHpw8+oFaNGvy0YAHJkiWzOpI8hF1G6v7+/mzevJmGDRtiGAbDhg1jyZIl3Lhxg6CgIIKCgmjcuDFeXl5ky5aNunXr2iOGiDyJJUvMpaenpn2V+1y8eJGhI0dSr25dZk2bpouzODi7lLq7uzuDBg2657G7J/Vv1KgRjRo1ssdHi0h8nD0L771n3q5Z09os4nAMwyB9+vRs3biRbNmy4eXlZXUkeQzNKCeSVJ05Ay+8YN5u3Ro0tafcYhgG/T/5BIDBAwfqSmtORDPKiSQ1Bw7A6tV3Cj1nTtCpSXKLYRj06tuXIcOH8+/ZsxiGYXUkiQeN1EWSkrFjoUuXO/c9PWHvXl2cRQCz0Lv26MHYCRPo2L4947/4QvOIOBmVuoir27cPWrWCo0fNaV8BJk6EggXNyWZ04JPc8r+uXZkwcSJdOnfms9GjVehOSKUu4sq+/BLef//O/Vdfhe++Ayc+D13sp1TJkvj5+TFs8GAVupNSqYu4ssOHzeXcueZ10bWZXf4jJiaG3Xv28Nqrr9K4YUOr48gz0r9wEVcUEwPR0bBxIyRPDm+/rUKX+0RHR9OsVStKv/UWf//9t9VxJAHoX7mIq2neHLy8zH3lO3fCzZtWJxIHFBUVRcOmTZkzbx5DdNqay9DmdxFXEhMDc+aYtz/+2Jwhrl49zRQn94iMjKR+o0YsWbaML8aM4YPOna2OJAlEpS7izAwDVq6EoUPN27/+aj7etCn062dtNnFYU6dPZ8myZXw1bhzvtW9vdRxJQCp1EWezf785G9wPP5gHwN1WsaL5x9sbBg60LJ44vrZt2lCoYEHKlC5tdRRJYCp1EWexdat5etqOHfc+XrCgWeJvv63N7PJQ169fp13HjgweMIA8efKo0F2USl3E0f35J3ToAOvX33nsu+8gb14oXhx8fCyLJs7h6tWrVKtdm22//079evXIkyeP1ZHETlTqIo7sl1/uXN88d27o3NkseI3I5QldvnyZqjVrsmv3bubOnElgnTpWRxI7UqmLOKKoKChUCG6fOxwYCDNn6lxziZeLFy9SuVo1/ggNZeHcudTS5XVdnkpdxBFt3Xqn0CdNgkaNVOgSb97e3qRLm5afFywgoGpVq+NIIlCpiziaffugfHnz9tat5kVXROLh33//xc/Pj5QpUxK8cqXmcU9CVOoijiAyEk6cMDexb9hgPtalCxQtamUqcUKnTp2iYtWqFMifn8ULF6rQkxiVuojVzpyBbNnM2eBuy5cPhgzRAXESL8eOHaNi1apcvHSJqT/8YHUcsYB20olY6Z9/4PXXzUJPmRJmzICLF2HvXnP+dpEn9Pfff1Pe35/LV64QvGIFpUqWtDqSWEAjdRGrrFkDVaqYtwMDYepUczY4kXgyDIOGzZoRHh5OyKpVFNNumyRLpS5ilUmTzGXz5jB+vApdnpqbmxtTf/iB2NhYXipSxOo4YiFtfhexipcX5MgB334LyZJZnUac0N59+/hkyBAMw6BQwYIqdFGpiyS6BQvAzw/mzdOBcPLUdu7aRYUqVfh+8mQuXLhgdRxxENr8LpKIkm/fbm5uB/OKag0aqNgl3n7bto2qNWuSJk0a1q1aRcaMGa2OJA5CpS6SGGJiwN+fHLcvylK3LsyerUKXeNv8669Uq12bjBkyELJqFdmzZ7c6kjgQlbqIvUVEQMOGd66ytnAhVK+uQpencvbcObK++CKrly0jS5YsVscRB6N96iL2tGgRJE8OP/8MhQtzaM0aqFFDhS7xdnu/eWCdOuz+/XcVujyQSl3EXkJDzfPPAQoXhtWridW+T3kKy1esIGf+/KxavRoAL01MJA+hUhexlxUrzOVXX8GOHZAhg7V5xCn9vHgxderXJ1/evLz26qtWxxEHp33qIgnt0iVo2xZ27TLvBwZqc7s8lQULF9KoWTNeLV6clUuWkCZNGqsjiYNTqYskJJsNXnwRbt407zdrBqlTW5tJnNLuPXto2LQpJUuUYPnPP5MqVSqrI4kTUKmLJJTdu6F9+zuFfvkypEhhaSRxXq+8/DLjP/+cZk2a4OfnZ3UccRLapy6SEA4dgmLFYNs2835oqApdnsrU6dMJDQ3Fzc2N99q3V6FLvKjURZ7VxYuQP795u2NHc6SeK5e1mcQpfTlxIi3ffZdRn31mdRRxUip1kWfVurW59PODIUPAXf+sJP4+HzuW97t04e1atfh6wgSr44iT0m8fkWcRGwuLF5u3z54FX19r84hTGjF6NN169uSdwEDmz56Nj4+P1ZHESanURZ6FzWYu69QBTx13KvEXExPDqjVraBQUxOzp0zWxjDwT/RYSeRZnz5rLV16xNoc4HcMwiIyMJFmyZCz76Sd8fHzw8PCwOpY4OY3URZ7FokXmMnNma3OIUzEMg559+lApIIAbN26QIkUKFbokCJW6yNMyDPj9d/N27drWZhGnYRgGXbp3Z8znn1P05ZdJliyZ1ZHEhWjzu8jT+OsvKFjQPFAOQL+Y5QnYbDY6du7MN99/T9f//Y9PR43CTVMISwLSSF0kvqKiIF++O4X+yy/m6Wwij9G3Xz+++f57en/4oQpd7EIjdZEnFRsLW7dCmTLm/cKFYft2nZcuT+zdVq3IkD493bt2VaGLXei3kciTsNmgaNE7hQ6wZYsKXR4rOjqayVOnYhgGefLkoUe3bip0sRv9RhJ5EgMHwv795u3gYAgLA00QIo8RFRVFUJMmtG7XjvUbNlgdR5IAbX4XeZRr12DnzjvXRt+798487yKPEBERwTsNG7JsxQrGfvopFd56y+pIkgSo1EUexjDA3//Oldfy5DEPkBN5jBs3blC3fn1WBwfz9YQJtG/b1upIkkRo87vIg6xcae4v37YNXn/dvL98OWhfqDyBnbt2sXHTJiZ9+60KXRKVRuoi//XxxzB06J37S5dCmjSWxRHnYbPZcHd3p0zp0vwdGsoLL7xgdSRJYjRSFwG4cAF694bkye8U+owZEB6uQpcncuXKFcpVqsTsuXMBVOhiCZW6CJhzuI8cCRER5qlrmzZB/fq68po8kUuXLlG5WjW2/f47yTW7oFhIv7FE4M7o/NgxeO457TuXJ3b+/Hn8q1fn4J9/smjePGpUr251JEnCVOoiBw7A8ePmgXEqdImHsLAwKlSpwt9HjrD4xx+p4u9vdSRJ4lTqIqNGmctu3VToEi++vr7Ur1ePsqVLU7FCBavjiKjURTh0CLJnh8GDrU4iTuLkyZNcuXqVl4oUYcDHH1sdRySOSl2StogI8yItadNqlC5P5NixY1SoUgVPT09C9+7FUwdTigPRT6MkbdHR5rJxY5W6PNbhw4epGBBAWFgYq5ctU6GLw9FPpAjAiy9anUAc3J9//knFgAAiIyMJWbWKoq+8YnUkkfvoPHVJmgwDPvzQvCa6yBMYOnIkMTExrF+zRoUuDksjdUlaIiKgeXOYP//OY82aQY0a1mUSp/DNl1/yzz//kDt3bqujiDyURuqSdMTGQs+eZqHnywevvGJesOX773U5VXmg7Tt2ULVGDa5evUry5MlV6OLwNFKXpOH06Xv3m8+YYZa6yENs/e03qtasSbq0ably5QqpU6e2OpLIY2mkLq7v88/vLfT9+1Xo8kibNm/Gv3p1MmbIwIbgYLJnz251JJEnolIX12YY5ib3rFlhyhS4dg3y5rU6lTiwXzZtomrNmmR54QU2BAeTLVs2qyOJPDGVuri2zp0hJgaKF4dGjcDHx+pE4uCyvvgi5cuWZf2aNWTJksXqOCLxolIX17Zggbn87DNrc4jD27V7NzabjRw5crB88WKee+45qyOJxJtKXVzXiBFw9ixkzqzJZeSRfvr5Z0qUKcNo/edPnJxKXVzTV19Bnz7m7cmTrc0iDm3+jz9Sv3FjihcrRvt337U6jsgzUamL62nVCjp1Mm8vWACVKlmbRxzWzNmzadi0KSVLlGD1smWkSZPG6kgiz0SlLq7lwgXzKHeAuXOhVi1L44jjOnv2LO06dqR8uXKsWLyYVKlSWR1J5Jlp8hlxLQ0amMsBA6BOHUujiGPLnDkzwStW8MrLL5MiRQqr44gkCI3UxXUcOQLr1kHq1PDBB1anEQc14auvmDx1KgClSpZUoYtLUamLa7DZ4Pa83CNGgK+vtXnEIX36+ed07tqVpcuXYxiG1XFEEpxKXVzD6tXmsmxZ80A5kf8YNnIkPXr3pn69esyZMQM3NzerI4kkOJW6OL89e6BaNfP2sGGgX9byHwMHD+aj/v1p0qgRs6ZNw8vLy+pIInahUhfnFhkJRYuat6tWhddftzSOOCZPT09aNm/O1B9+wNNTxweL69JPtzi3gwfNZZky8PPPGqVLHMMwOHnyJNmyZePjPn0wDEOb3MXlaaQuzm3gQHPZtasKXeLYbDb+17UrRd94gxMnTgCo0CVJsMtI3WazMXDgQP7880+8vb0ZMmTIPdcj3rt3LyNGjMAwDDJmzMjo0aPx0dWzJD4iI2HnTli+3Lx/e5+6JHk2m40OnTrx3aRJdO/ShaxZs1odSSTR2KXUg4ODiYqKYu7cuezevZsRI0YwceJEwNwk1q9fP8aNG0f27NmZP38+p0+fJleuXPaIIq4oOtrcj35703vz5uDhYWkkcQyxsbF8PGAAPy1ZQt9evRjyyScaoUuSYpdS37FjB2XLlgWgaNGi7N+/P+65o0ePkiZNGqZOncqhQ4coX768Cl2eXHg4+Pndub9kCZQoYV0ecSgTvvqKn5Ys4ZP+/enXt68KXZIcu5R6WFgYfnf94vXw8CAmJgZPT08uX77Mrl276NevH9mzZ6dDhw4UKVKEUqVKPfT9bDYboaGh9ogqt0RERDj8Ova4dIl8ZcoAYPPx4fCSJcRmygT//GP+cQKRkZEOv56d2VvlyjFiyBBq16zJwdtbciTB6ec4Edhs8BS7pe1S6n5+foSHh8fdt9lscaeRpEmThuzZs5MnTx4AypYty/79+x9Z6u7u7hQsWNAeUeWW0NBQx17HBw6YR7jf4n7iBPmc8IpaDr+enVBkZCQfDxhA7w8/JH369Hh7e2sd25l+jhOBzUbokSPx/jK7HP1evHhxNm7cCMDu3bvJly9f3HNZs2YlPDyc48ePA7B9+3by5s1rjxjiSoYONZelS8Ply+CEhS4JLyIigsAGDRjz+eesWbvW6jgilrPLSN3f35/NmzfTsGFDDMNg2LBhLFmyhBs3bhAUFMTQoUPp3r07hmFQrFgx3nrrLXvEEGdns5lXWzt7FrZuhZw5ITgY3HUmpsCNGzeo8847BIeE8M2XX9Lw9hX6RJIwu5S6u7s7gwYNuuex3LcvtgGUKlWKBQsW2OOjxZV89RUMGWJedS1FCqheXYUugHncTq3AQDZs3Mikb7+lZfPmVkcScQiaUU4cU2QkdO5s3p47F7Q1R+5y/fp1zpw5w4wpU2jcsKHVcUQchkpdHFOlSuayc2ez0HVqkgDXrl3D19eX559/nr07duDt7W11JBGHom2Z4jgMA86cgWXLYPNm8zFddU1uuXTpEhWrVqXD++8DqNBFHkClLo6jQgV44QWoWdO8/9FHoF/cApw/f54KVaqw/8AB6taubXUcEYelze/iGPbuhQ0bzNvjxkHBgnBrVkJJ2v79918qBQRw9NgxlixciH/lylZHEnFYKnVxDLcnlpkxA+rXtzaLOAybzUaNOnU4fuIEy3/+mbfKl7c6kohDU6mLta5cgcqV4fp18369epbGEcfi7u7O6OHD8fb2pkzp0lbHEXF4KnWxVrlysG+fefu333QeugDmhZ82btpEi2bNqFihgtVxRJyGSl2sExt7p9AvXICUKa3NIw7hr7/+omJAADdv3qRWjRqkS5fO6kgiTkPDIkl8N29ClSpw6yI/dOmiQhfAvFBIeX9/IiIiWLtypQpdJJ40UpfEExNjzuF+91Ht5cvfmTlOkrT9Bw5QKSAANzc31q9ZQ+FChayOJOJ0VOqSOKZOhZYt730sPPzOaF2SvA0bN+Lp6UnIypXkz5/f6jgiTkmb38X+/vrr3kJfvVqFLnEiIyMB6PTeexzYtUuFLvIMVOpif1On3llGRJib3FXoAmzZupW8hQvz+/btAKRJk8baQCJOTqUu9vXHHzB0qHn7nXc0j7vE2fjLL1SpUQMfb2+ey5zZ6jgiLkGlLvbx11/m7HCFC5v3GzcGDw9rM4nDWBsSQrXatXkxSxY2BAeTNWtWqyOJuARtA5WEd+QI5Mtn3vbzM6eA/eEHjdIFgB07d1Kzbl3y5M5N8IoVZNYoXSTBaKQuCa9vX3PZvDmcOgU//6yZ4iTOyy+9xP86dWLd6tUqdJEEpt+0kvB8fMzlxImQPLm1WcRhrFi5krNnz+Ll5cXIYcPIkCGD1ZFEXI5KXRJGTAysX2+OzqdNA39/7UOXOHPnz6dWYCB9+vWzOoqIS9M+dXl6e/dCixYQGQmhofc+17Gj9qELANNnzqTlu+9S+s03Gfvpp1bHEXFpKnV5OoYBI0bA7t1QtSoULGheoKVzZ3jzTY3SBYBJU6bwbocOVChfnsULF+Lr62t1JBGXplKXp9O7N8yebd6eNAm0f1T+IzIykjGff06VypVZNH8+yXV8hYjdqdQl/gwDJk82b+/ZA+nTW5tHHI5hGPj4+LBu9WpSp05NsmTJrI4kkiToQDmJv3nz4Px56NcPChTQvnO5x+hPP6VRs2bExMSQOXNmFbpIIlKpS/wYhnlBFoD69a3NIg5n6IgR9Lw1T4FhGBanEUl6tPldntypU5A9O9hs5mQyL7xgdSJxEIZhMHDwYAYNHUqzJk2Y9O23eOqiPSKJ7pEj9aioqIf+kSSoe3ez0Nu0gU2bzClgRYBBQ4cyaOhQWrdsyeTvvlOhi1jkkf/yAgICcHNzu28zmpubG2vXrrVrMHFAy5aZy3HjdOlUuUflihW5evUqY0aOxF1TAotY5pG/mUNCQhIrhzi6I0cgPBwaNlShCwA2m41169dTqWJFSr/5JqXffNPqSCJJ3iN/OwcFBeH2kCOb58yZY5dA4qD27TOXTZtam0Mcgs1mo32nTnw/aRKb1q1ToYs4iEeW+meffZZYOcSRffop9Ohh3tYkM0lebGwsbdq3Z+r06XzUuzdvlipldSQRueWRpZ4lSxYAjh8/zsqVK4mOjgbg3LlzDBo0yP7pxDH06mUu69SBwoUtjSLWiomJoXnr1syeO5dBAwbQ7/ZldkXEITzRES29bv1S37lzJ6dOneLKlSv2zCSOZNIkc073Dz6AuXPB29vqRGKh4LVrmT13LiOGDlWhizigJzriKVmyZLRv355jx44xfPhwGjdubO9cYqU//zRnivPygltbZ6hQwdpM4hACqlZl52+/UaxoUaujiMgDPNFI3TAMzp8/z40bN7hx4wZXr161dy6xyvnzZqGDWegffABr1kC1atbmEsvcvHmT+o0a8cumTQAqdBEH9kSl/v777xMcHEzt2rWpVKkS5cqVs3cuSUxRUfitXQtlykCmTOZjgwebp7CNGgX6+06ybty4Qe3AQH5ctIi/Dh+2Oo6IPMYTbX5/5ZVX8PPzo2DBghiGQfny5e2dSxLLiRPwxhtkPXv2zmPvvw8ffqgLtSRxYWFh1Kxbl182bWLyd9/RolkzqyOJyGM80Ui9R48e7N69G4CjR4/Su3dve2aSxLJtmzmX++1C37QJbt40T2FToSdpYWFhBNSqxabNm5kxZYoKXcRJPFGpnz17lkaNGgHQtm1bzp07Z9dQkkjq1DGXPXoQum0bvP66eaEWSfKSJ09Orpw5mTNjBo2CgqyOIyJP6Inn+zx69Cg5c+bkxIkT2Gw2e2YSezt2DN58E86cgbRpYcgQOHjQ6lTiAC5evEhERARZsmRh2qRJVscRkXh6olLv27cvXbp04eLFi2TKlIlPPvnE3rnEnkqWvLPJfdEibWoXwJxUqnK1ari7u7Nj61Y8PDysjiQi8fTEB8rNmDGD06dPkzVrVnx9fe2dS+xl9+47hX7jBugXtwBnzpyhUkAAx44fZ8nChSp0ESf1RKW+atUqJk6cSGxsbNzlWDt27GjvbGIP8+aZy8mTVegCwKlTp6hYtSr/nDnDisWLKa9TGEWc1hMdFTV58mTmzZtHmjRp6NixI8HBwfbOJfawdCkMH27e1mmJckvnrl359+xZVi1dqkIXcXJPNFJ3c3PD29sbNzc33NzcSJ48ub1ziT3UqmUuv/oKbl2sR+SbL7/k5KlTvFq8uNVRROQZPdFI/fXXX6dbt26cPXuW/v378/LLL9s7l9iDnx8UKQKtW1udRCx26NAhOnTqRHR0NJkyZVKhi7iIR47UY2JiCAkJ4c033yQqKopChQqRIUMG1q9fn0jxJMGMGQNhYVC2rI52T+L+CA2lUkAAsbGxfNitG7lz57Y6kogkkEeWeo8ePfDw8ODChQv4+/uTO3duPv74Y5o3b55Y+SShDBpkLt95x9ocYql9+/dTKSAADw8P1q9Zo0IXcTGPLPUTJ06wcOFCoqKiqFevHl5eXkybNk2/CJzNgQNw/Tq89JJ50RZJknbt3o1/9eokS5aMkJUryZcvn9WRRCSBPbLU/fz8APD29sZmszFp0iTSpEmTGLkkIc2ebS6/+MLSGGKtmJgYsrzwAgvnztV/zEVc1BNPE5s+fXoVurO6etWcDrZ0aauTiAVOnz5NlixZeP2119i1bRvumt9fxGU9stQPHz5M9+7dMQwj7vZtn376qd3DSQJYtQomTDCPfJckZ+Mvv1CjTh0+GzWKtm3aqNBFXNwjS/2LuzbXNmzY0N5ZJKFFRUHNmubtAQOszSKJbm1ICLUCA8mRPTs1q1e3Oo6IJIJHlvobb7yRWDkkoRkGVKkCMTHQqxd07qxT2ZKQlatWUbdBA/LmyUPwihVkypTJ6kgikgi0Lc5V3bwJGzaYt9u0UaEnIadPn6ZugwYULFCAdatXq9BFkpAnPlBOnNSQIZA9u9UpJBFlyZKF6ZMnU6lCBdKmTWt1HBFJRBqpi7iIufPnszYkBIB3AgNV6CJJkErdVe3ZY3UCSUTTZsygcfPmjPn8cwzDsDqOiFhEpe6KGjSAN980b2vWMJf3w+TJtHz3Xd4qV44Fc+bgpuMnRJIslbor+ecf84j3+fPN+0OGQO3a1mYSu/rq6695t0MHqvr7s/Snn/D19bU6kohYSAfKuZJff4U1ayB/fvj+e9ApiS7NMAy279xJrRo1mD97Nj4+PlZHEhGLqdRdyfTp5nLGDNA1713atWvXSJUqFd9NnEhsbCze3t5WRxIRB6DN764kLMxc5s1rbQ6xq8HDhlH09dc5d+4cHh4eKnQRiaNSdwVbt0KTJhASAiVKQPLkVicSOzAMg34DB9L/k08oU7o06dOntzqSiDgYbX53dsOHQ9++d+7XqmVdFrEbwzDo1bcvoz/7jDatWvHNl1/i4eFhdSwRcTAqdWcWGnqn0OfMgbffBl2FyyWNHT+e0Z99xnvt2jFh7FhdbU1EHkil7oxiY6FVqzsHxg0YAHXrWptJ7Kp506bExsbSrUsXnYcuIg+l/+47o3Hj7hT67NnQp4+1ecQuYmNjGTdhAhEREaRLl47uXbuq0EXkkTRSdzYxMdCtm3l7zx4oUMDaPGIXMTExtG7XjukzZ5I+fXqaNGpkdSQRcQIqdWczZYq5zJbNnGRGXE50dDTNW7dmzrx5DB44UIUuIk9Mpe5MZs6Etm3N2wsX6hrpLigqKopGzZqx8KefGDVsGB927251JBFxIip1Z7BrF5w4AU2bmvf79IHCha3NJHZx7Ngx1m/cyBdjxvBB585WxxERJ6NSd3SxsVCqFERGmvd79DCPdtco3aVER0fj6elJvnz5OLR/vyaWEZGnoqPfHd3vv5uF3ratOXOcCt3lhIeHE1CzJkOGDwdQoYvIU1OpO7q5c83l229DsWKgeb5dyvXr16lWuzbrN24kZ44cVscRESenze+O7OZN+OIL83bJkpZGkYR39epVqtWuzbbff2fWtGkE1a9vdSQRcXIqdUd2+3z08uUhZUprs0iCio2NJaBWLXbs3Mm8WbMIrFPH6kgi4gJU6o5q3z74+mvz9uzZ1maRBOfh4cF77dqRNk0aatWsaXUcEXERdil1m83GwIED+fPPP/H29mbIkCFkz579vtf169eP1KlT06NHD3vEcG63f9G3aQM6cMplXLx0iZB166hYoQLNb5+iKCKSQOxyoFxwcDBRUVHMnTuX7t27M2LEiPteM2fOHA4dOmSPj3d+ERHmeemvvQbjx1udRhLImTNnaPHuu9Rv3Jhr165ZHUdEXJBdSn3Hjh2ULVsWgKJFi7J///57nt+1axd79uwhKCjIHh/v3GJjoWhR83aRIqBrZruEU6dOUb5yZf79918WzZtHqlSprI4kIi7ILpvfw8LC8PPzi7vv4eFBTEwMnp6enDt3jgkTJjBhwgRWrFjxRO9ns9kIDQ21R1SH43X6NHn+/BOAP1u2xJZI33dkZGSSWceJ7fTp07Rq144rV6/y5dixZMyQQevajvSzbH9ax4nAZgMfn3h/mV1K3c/Pj/Dw8Lj7NpsNT0/zo1auXMnly5dp164d58+fJyIigly5chEYGPjQ93N3d6dgwYL2iOp4kic3l998Q/5SpRLtY0NDQ5POOk5ks+fNIyw8nJBVq/Dz9dV6tjP9LNuf1nEisNkIPXIk3l9ml1IvXrw469ato3r16uzevZt8+fLFPde8eXOaN28OwMKFCzly5MgjCz3JuX7d6gSSQAzDwM3NjYH9+tGqeXNy5syp0Y2I2JVd9qn7+/vj7e1Nw4YNGT58OH369GHJkiXMvT07mjzctGnmMnVqa3PIM/kjNJQSZcpw9OhR3N3dyZkzp9WRRCQJsMtI3d3dnUGDBt3zWO7cue97nUbo/3HwIIwZY96uXdvaLPLU9u7bR+Vq1fDw8CAiIsLqOCKShGjud0fy0Ufmsn59cNdfjTPauWsXFapUwdvbmw1r1mi/o4gkKjWHo7h0CRYuNG9/842uxOaEdu/ZQ8WqVUmZMiUbg4PvOZZERCQxqNQdxcaN5rJ9e/D1tTaLPJWcOXIQUKUKG9asIVeuXFbHEZEkSKVutVWr4J13oG5d836jRtbmkXjbvmMHN27cIHXq1MyZMeOBUyKLiCQGlbqVDAMCAuDnn83Z42bP1iVWnUzw2rWUq1SJHr16WR1FRERXabPUl1+ay+efh+3btR/dySxfsYLAoCDy5c3LwH79rI4jIqKRuqXCwszlr7+q0J3Mz4sXU6d+fQoXKsS61avJlCmT1ZFERFTqlrp61VzeNU++OL6bN2/SqUsXihUtytqVK0mvS+OKiIPQ5ncrffaZudSV2JxK8uTJCV6+nBdeeEFXWxMRh6KRulX++AOioswD5Ly9rU4jT2Dq9Ol81L8/hmFQoEABFbqIOByVemK7dMk8D71wYfN+gwban+4EvvvhB1q1bcu2338nOjra6jgiIg+kUk9sa9bAjRvm7TFjoGdPa/PIY305cSLtOnYkoEoVlixahLe2rIiIg9I+9cRms5nL3btB84I7vC/GjaPrhx/ydq1azJ05Ex8fH6sjiYg8lEbqVtEmd6fw/PPPE1S/PvNnz1ahi4jDU6mL/IdhGBw8eBCAoPr1mT19Ol5eXhanEhF5PJV6YoqKgq5drU4hj2AYBv0GDuTl115j565dALhpq4qIOAmVemI5exb+9z9zCZAli7V55D6GYdCzTx+GjhhBy2bNKPrKK1ZHEhGJFx0ol1jq1IGtW83bmzdDypSWxpF7GYZBl+7dGffll3Tq0IFxn3+Ou7v+zysizkWlnhgMA7ZtM2+Hh4OnVrujWfjTT4z78ku6/u9/fDpqlDa5i4hTUrskhl27zFPZypVToTuowDp1+HnBAmrVrKlCFxGnpe2LiWH4cHPZpYulMeReMTExdOnenUOHDuHm5kbtWrVU6CLi1DRsTAzJkpnLKlWszSFxoqOjadqyJfMWLCB3rlzky5fP6kgiIs9MI3V7unzZHJ3PmAFZs2rTu4OIiooiqEkT5i1YwJgRI+jcqZPVkUREEoRaxp4yZoTYWPN25cqaRc4BRERE8E7DhixbsYJxn32mQhcRl6JSt5c1a+4Ueni4rpnuIGJjY7l2/TpfT5hA+7ZtrY4jIpKgVOr2cvvqa+vXa7O7AwgPD8dms5EyZUrWrV6Nh/6TJSIuSG2T0AwD6tc3r8IGULKkpXEErl+/To06dfD09GTtypUqdBFxWSr1hDZnDvz4o3l72TLtR7fYlStXqFa7Nr9v387MqVN1ypqIuDSVekLbssVc/vYbFC1qaZSk7tKlS1StWZM9e/cyf/Zs6r79ttWRRETsSqWekMLCzPnd06QBXQzEcs1atWLvvn0snDuXmjVqWB1HRMTuVOoJaeFC+P13qFXL6iQCfDpyJCdPncK/cmWro4iIJApNPpOQoqLM5aefal+6Rf755x9GjhmDYRgUKFBAhS4iSYpG6vagQrfEyZMnqVi1Kv+ePcs7deuSO3duqyOJiCQqjdTFJRw9epRylSpx7vx5Vi9bpkIXkSRJI/WEsncv3J6hTCP1RHX48GEqBgQQFhbG2pUree3VV62OJCJiCZV6Qhk71lzmyAFZslgaJan589AhYmJiCFm1iqI660BEkjCVekKx2cwrsYWGgrv2aiSG8PBwfH19qVG9Oof/+IMUKVJYHUlExFJqn4Ry8aJZ7Nr0nij27N1LnkKF+OnnnwFU6CIiqNQTRnQ0LFkCN29anSRJ2L5jBxWqVMHT05PChQpZHUdExGGo1BPCwoXmskoVjdTtbOtvv1EpIIDUqVKxMTiYvHnzWh1JRMRhqNQTwuTJ5rJPH2tzuLhjx47hX706GTNkYENwMDlz5rQ6koiIQ1GpJ4TQUHOpkrGr7NmzM+Cjj9gQHEy2bNmsjiMi4nB09PuzMgw4cQIaNAAfH6vTuKTgtWt5/vnnKVyoED26dbM6joiIw9JI/VkcOnTn9LWICGuzuKhly5dTo04duvfsaXUUERGHp1J/FmXLmsucOWH8eGuzuKCffv6Zug0a8FKRIsyaNs3qOCIiDk+b35/WuXPmHzc3+OMPTTiTwOb/+CONmzfn1eLFWblkCWnSpLE6koiIw1MTPa1Gjcxlv34q9ARmGAbfT5pEyRIlWL1smQpdROQJaaT+NGJi4OBBSJUKevSwOo1LiYmJwdPTk4Xz5mEYBn5+flZHEhFxGhpixtf69ZA8OfzzDwwYoCPeE9C3339PuUqVuH79Or6+vip0EZF4UqnHx4ULUKGCOVLv1QuaNrU6kcuY8NVXtO/UiXRp0+Ll5WV1HBERp6RSj4+JE83lK69A//6gfb0J4rMvvqBz167UqV2bhfPmkSxZMqsjiYg4JZV6fBw/bi4XLgRPHY6QEL76+mu69+pF/Xr1mDdrFt7e3lZHEhFxWmqmJ3H0KLz5Jly6BFmymH8kQVT196dL586MHjECT/1HSUTkmWik/iTat4d//4V8+eDjj3UltmdkGAY//fwzNpuN3Llz8/mYMSp0EZEEoFJ/lAsXIFs2WLMGUqSA336D1q2tTuXUDMOgR69e1G3QgPk//mh1HBERl6Lh0aO0bw8nT5q39+zRfvRnZLPZ+KBbNyZMnEjnjh1p8M47VkcSEXEpaqlHuXYNvLzMTe86Z/qZ2Gw23nv/fb794Qe6d+nC6BEjcNNuDBGRBKXN7w/y779Qty4EB0Phwir0BLBv/36mTJ9O3169VOgiInaikfp/TZkCrVrdud+ypVVJXIJhGLi5ufHKyy+zd/t28uXLp0IXEbETjdT/a8sWc/nxx3DlCrz3nqVxnFl0dDSNmjVjxqxZAOTPn1+FLiJiRyr1B3nuObPUkye3OonTioyMpH6jRsydP59z585ZHUdEJElQqd9t0yb49ltzbnd5ahEREQQ2aMDPS5Yw/vPP6dali9WRRESSBO1Tv9vu3eby/fctjeHMoqOjqR0YSHBICN98+SXt3n3X6kgiIkmGSv22P/6AP/80b7dpo1njnpKXlxdvlipF44YNadm8udVxRESSFJU6QHi4eeW1mBhzghldJSzerl27xslTpyhcqBAD+/WzOo6ISJKkfeoAUVFmob/3HuzYASlTWp3IqVy5coUqNWpQuVo1wsPDrY4jIpJkaaQO8M035jJXLihQwNosTubixYtUqVGDffv3M3/WLHx9fa2OJCKSZKnUAcaONZfFilmbw8mcO3cO/+rV+fPQIX6aP5/q1apZHUlEJElTqYO5H715cyhb1uokTmXI8OH8dfgwSxYuxL9yZavjiIgkedqnLk9t1PDhbFy7VoUuIuIgVOoSLydOnKB+o0ZcvnyZZMmS8dqrr1odSUREbtHmd3liR48epULVqly5coVjx4+TNm1aqyOJiMhdNFKXJ/LXX39RrnJlrl+/ztqVKylWtKjVkURE5D80Uu/TB06dsjqFQzt48CAVAwKIjo4mZNUqXnn5ZasjiYjIAyTtkfqKFTBihHn77muoyz1SpEhBjuzZWb9mjQpdRMSBJc1Sj4qCLl2genXz/rBh8OablkZyREeOHCE2NpZs2bKxef16ChcqZHUkERF5hKRZ6kuWmBPOpE0LY8ZAt25WJ3I423fs4LU33+TjAQMAcNMFbkREHF7S3Ke+cqW5XLIEXn/d2iwOaMvWrQTUqkW6tGlpr0uniog4jaQ5Uv/+e/DzA51jfZ9fNm2iSo0aZMqYkY1r15IjRw6rI4mIyBOyy0jdZrMxcOBA/vzzT7y9vRkyZAjZs2ePe37p0qVMnToVDw8P8uXLx8CBA3F3T+T/XxQqBIn9mQ4uLCyMwKAgXsyShbUrV/LCCy9YHUlEROLBLq0WHBxMVFQUc+fOpXv37oy4fYQ5EBERwRdffMG0adOYM2cOYWFhrFu3zh4xHuz2pUErVUq8z3QSfn5+LJg9m/Vr1qjQRUSckF1KfceOHZS9dXGUokWLsn///rjnvL29mTNnDsmTJwcgJiYGHx8fe8R4sNtXYvPzS7zPdHBLly3jx0WLAChfrhyZM2e2OJGIiDwNu2x+DwsLw++u0vTw8CAmJgZPT0/c3d3JkCEDANOnT+fGjRuULl36ke9ns9kIDQ195lwe58+T76+/AAgNCIAEeE9nFxwSQreePSmQPz9v16qFp2fSPHYysURGRibIz7I8nNax/WkdJwKbDZ5iwGuX3+B+fn6E397MjVnKd5eFzWZj9OjRHD16lPHjxz/2dCl3d3cKFiz47MH27jWXPXpQsEiRZ38/Jzd3/ny6fvghb7z+Ol+MHs1LL71kdSSXFxoamjA/y/JQWsf2p3WcCGw2Qo8cifeX2WXze/Hixdm4cSMAu3fvJl++fPc8379/fyIjI/nqq6/iNsMniuHDzWW9eon3mQ5qxqxZNG7enDdLlWLV0qWkTJnS6kgiIvKM7DJS9/f3Z/PmzTRs2BDDMBg2bBhLlizhxo0bFClShAULFvDaa6/RokULAJo3b46/v789otwREQF79pi3b+9XT8JOnT7NW+XKsXjhQnx9fa2OIyIiCcAupe7u7s6gQYPueSx37txxtw8ePGiPj320LVvMZefOkIRnR7tw4QIZMmSg94cf0qNrV+1DFxFxIUnjRO0DB6BiRfN2Et70Pm7CBPIWLhz3nyoVuoiIa0kapX7ihLls2xZKlrQ2i0VGf/opH3TvTsW33iJXrlxWxxERETtIGqV+9Ki5bNIkSW56HzpiBD379iWofn3mzJiBt7e31ZFERMQOkkapL1xoLtOntzaHBebMm8fHAwbQrEkTZkyZgpeXl9WRRETETpJGqadIAdmzQ968VidJdIF16jD+88+Z/N132ocuIuLikkap//orpE6dZDa9G4bBmM8+48KFC3h7e/N+x454eHhYHUtEROzMtUv93DmzyC9ehKtXrU6TKGw2G527dOHDPn2YOn261XFERCQRufb22NtXf0udGtautTZLIrDZbLTv1InvJ03iw27d6Nali9WRREQkEbn2SD021lyuWwdZs1qbxc5iY2Np3a4d30+axMd9+jBy2LDHzqkvIiKuxXVH6hcvmqewpUjh8oUOcPnyZX7dsoVBAwbQr29fq+OIiIgFXLfUZ882l926QapU1maxo+joaNzc3MiQIQM7tm7VhVlERJIw1yv1q1ehZUv4/Xfw9ITeva1OZDeRkZE0aNyYVKlSMW3SJBW6iEgS53r71END4aefzIPj3n/fLHYXdPPmTerWr8/ipUspVaKE9p+LiIgLjtRvGzYMqlWzOoVd3Lhxg7fr1WPtunV8N3Ei77ZubXUkERFxAK5b6i4sqEkTQtavZ8r339O8aVOr44iIiINwvVJPApPM9OjalSaNGtGwQQOro4iIiANxrVK32SAgwLydL5+1WRLY5cuXWR0cTFD9+pQvV87qOCIi4oBc60C5/v3NZbFi4ELXDL948SKVAgJo0aYNJ25fG15EROQ/XGukPnOmuRw3zmUu3nLu3DkqV6vGob/+YtG8eWTLls3qSCIi4qBcp9QjIuDYMWjUCN54w+o0CeLMmTNUCgjg2PHjLF20iMqVKlkdSUREHJjrlPqcOebS3XX2KKxas4YTJ0+yYvFi7UcXEZHHcp1Svz0tbI8e1uZIADabDXd3d1o2b05Vf3+ef/55qyOJiIgTcJ1hbUgIvPACFCxodZJncuTIEV557TW2bN0KoEIXEZEn5hoj9cWLISYGPDyc+gC5v/76iwpVq3Lz5k18fHysjiMiIk7GNUr999/N5YIF1uZ4BqGhoVQMCCA2NpZ1q1fz8ksvWR1JREScjGuUupub+eeVV6xO8lSOHj1KeX9/PDw8WL9mDYWcfBeCiIhYw3X2qTuxF198kfqBgWxQoYuIyDNwjZG6k9qxcycvPP88zz//PF+OG2d1HBERcXIaqVvk1y1bqFClCu06drQ6ioiIuAiVugU2bNxIlRo1eC5zZiaOH291HBERcRGuUeqDB4NhWJ3iiawNCaFa7dpky5qVDcHBvPjii1ZHEhERF+Ea+9TTpAE/P6tTPJbNZqPXRx+RJ3duglesIFOmTFZHEhERF+Iape7pCdWrO/zEM+7u7ixdtAhPT08yZMhgdRwREXExrrH53cH9uGgRjZs3JyYmhueee06FLiIiduH8pf7nn3DhgsPuU58zbx5BTZpw7Phxbt68aXUcERFxYc5f6vv2mcuiRS2N8SDTZsygSYsWlH7zTVYtXUrKlCmtjiQiIi7MuUv933+hfn3zdsmS1mb5j6nTp9Py3Xd5q1w5lv/8swpdRETsznlL/coVuH06WLlyUKCApXH+K3++fLwTGMjSn37C19fX6jgiIpIEOG+p//wzxMaat5cvN4+AdwA7d+0CoGSJEsybNYvkyZNbnEhERJIK5y3124UeGgpeXtZmuWXUmDG8WrIkS5ctszqKiIgkQc5b6re5O8a3MHjYMHp99BENGzQgoGpVq+OIiEgS5BjbrJ2YYRj0/+QThgwfTrMmTZj83Xd4eHhYHUtERJIgxxjmOrFtv//OkOHDadOqlQpdREQs5bwj9S1brE4AQIk33mDd6tWUK1sWdwfZFSAiIkmT87bQb7+Zy7RpE/2jbTYb3T78kA0bNwLwVvnyKnQREbGc847UvbzA3x9Sp07Uj42NjaV9p078MHkyfn5+lC9XLlE/X0RE5GGct9Td3CCR91/HxMTQul07ps+cSb++ffmkf/9E/XwREZFHcd5ST2TR0dE0a9WKufPnM3jgQD7u08fqSCIiIvdwzh3BkZGwY0eifqS7uzteXl6MGjZMhS4iIg7JOUfqt6/M5u1t94+KjIzk0qVLPP/880ybNAk3Nze7f6aIiMjTcM6R+u1rp7doYdePuXnzJm/Xq8db/v5ERESo0EVExKE550g9EYSHh1M7MJB1Gzbw3cSJJEuWzOpIIiIij6RSf4Dr169To04dNv/6K1N/+IFmTZpYHUlEROSxVOoP0K1nT37dsoVZ06YRVL++1XFERESeiHOW+s2bdn374YMHU69OHV1tTUREnIrzHShnGNCokXnb1zfB3vbChQv06NWLqKgoMmTIoEIXERGn43ylHhUF//wDDRpAAk3RevbsWSpUqcKXX3/Nnr17E+Q9RUREEptzbn4HKFw4QaaJPXPmDBWrVuX4iRMsXbSI1197LQHCiYiIJD7nLfUEcOrUKSpWrcqZf/9l5ZIllCtb1upIIiIiTy1Jl/q58+eJjIpi9bJllCpZ0uo4IiIiz8T5Sv348Wd+i8uXL5M2bVqKFyvGXwcO4J0I082KiDiD6JgYTp05Q0Rk5MNfA4QePpx4oVxcMh8fXnz+ebw8n72SnavUT5+G/PnN27lzP9Vb/Pnnn1QMCODDrl3p8r//qdBFRO5y6swZUqZKRY506R46NfbNiAiSa5bNBGEYBhcvXeLUmTPkzJr1md/PuY5+P3jQXJYsCYGB8f7yP0JDKe/vT0xMDJUrVUrgcCIizi8iMpL0jyh0SVhubm6kT5fukVtG4sO5Sv22wYPjfeT73n37eMvfH3d3d9avXk2RwoXtFE5ExLmp0BNXQq5v59r8PmvWU33Z1atXqRQQQLJkyQhZuZK8efMmcDAREUlo3373HdOmTWNtcDA+Pj707tOH6tWr33OmUumyZdn8yy8ABAcHM3X6dDAMIiIjadO69VNNJDZv3jzmzJuHp4cH73XoQIUKFe55vmu3bly4cAGA06dP88orr/D5Z58xZcoUlq1YAUD5cuV4v1Mnrly5woc9exIWHk6aNGkYMmgQ6dOnf9pV8ljOU+qXLsGkSebt556L15emTp2asZ9+Ssk33iBXrlx2CCciIgltydKlVK9enWXLlxNYt+4jX7tz1y6mTJ3KN19/ja+vL5cvXyaoYUPy5M5Nnjx5nvgzz58/z/QZM/hxwQIiIyNp3KQJpUuXvuf4q88/+wwwB4zNW7akT+/enDx5ksVLlzJ/7lzc3Nxo3LQplStX5ueff+bVV1+lQ/v2/Prrr3z2+ecMHTLk6VbIE3CeUo+NNZcjRkC+fE/0JZt//ZXw8HCq+PvTuGFDO4YTEXFB06bBlCn3Pexts4H7U+69bdkSmjd/7Mt+27aNbFmz0rBhQz7s2fOxpT5//nxaNG+O763pw9OmTcv8efNIlSrVPa/76OOPOXHiRNz91KlTM2H8+Lj7e/fto1jx4nh7e+Pt7U22bNk4+OefvPzSS/d95vgJE2japAmZMmUiOjqa77/7Do9bu4ZjYmLw8fbm8OHDdO3SBYDixYszyI6FDs5U6rc94dHq6zdsoGbduuTNk4fKlSrh/rQ/gCIikujmL1hA/XfeIVfOnHh7e7Nnz54Hvu723uhz586R9T9Hj6dOnfq+1z9ulBwWFkZKP7+4+76+voRdv37f6y5evMiWLVvo07s3AF5eXqRLmxbDMBg1ejSFChYkZ86cFCxYkJB16yhUqBAhISFEREQ88vOflfOU+gNW6sMEr11L7Xr1yJkjBysWL1ahi4g8jebNHziqjrLzKW1Xr15l48aNXLp4kekzZxJ2/TozZs4kRYoUREVF3fPamFtbcV944QXOnDlDgQIF4p7bsXMnGdKnJ3v27HGPPW6k7ufnR3h4eNz98PBwUv5ntA+wctUqatasGTcyB4iMjKTvRx/h6+vLgP79AWjXrh1Dhw6lZatWlC1blufiufs4vpyn1KdNM5fp0j3yZStWrqRugwbky5uX4BUryJQpUyKEExGRhLJ4yRLq1atHrw8/BODmzZtU8vendatWrFmzJu6U5O3bt5Pn1pwlgXXr8ulnn1GiRAlSpEjBxYsX6du3L2PHjr3nvR83Un/5pZf44osviIyMJCoqir+PHCHfAw6u3rJlC+916BB33zAMOnbqRIkSJWjXtm3c49t//523336bkiVKsGr1aooXK/Z0K+UJOU+ph4SYm97r13/ky5YsW0bhQoVYvWyZXY8wFBER+5i/YAGjRo6Mu588eXKq+PsTERFBihQpeLtuXXx9ffHy8mLQoEEAFCtWjAYNGtC6TRs8PT2JiIykW7duFLg9YdkTypgxI82aNqVx06YYNhtdu3TBx8eHw4cPM2PmTAYOGADA0aNH79ncHxwczLbffycqKopfbh2N361rV3LmzEmvW5voM2XOzDA771N3MwzDsOsnJIBdu3ZRrFo1qFEDJk584GsiIyPx8fHBZrOZm0tSpkzklM4tNDSUggULWh3D5Wk925/W8bMJPXyYgndtwn4QzSiX8EIPHqTg3Ufp22yEHjlCwUKF4vU+TrGz2S0iAs6evXME/H/MmjOHIsWKcerUKdzd3VXoIiKSJDlHqd8+MKJcufuemzp9Ok1btiRLliykSZMmcYOJiIg4EOco9eho88Z/pnb97ocfaNW2LZUqVGD5zz/jd9dpCCIiIkmNU5S6x9Wr5o27RuLzFiygXceOBFSpwpJFi0iRIoU14UREXIwTHGrlUhJyfTtFqRvu7pAjh/nnFv9KlejZvTuL5s8nmQ7YEBFJEMl8fLh46ZKKPZHcvvRqMh+fBHk/5zmlLXNmcHNjzrx51Kldm7Rp0zJy2DCrU4mIuJQXn3+eU2fOcP78+Ye+Jjo6Gi8vr0RM5dqS+fjw4vPPJ8h7OUWpe4SFQUwMg4YOZcCgQYwZMYLuXbtaHUtExOV4eXqS8z/Trf5XaGjovadficOwy+Z3m81G//79CQoKolmzZhw/fvye50NCQqhXrx5BQUHMmzfvid7zY5uNAYMG0aJZM7r873/2iC0iIuLU7FLqwcHBREVFMXfuXLp3786IESPinouOjmb48OFMmjSJ6dOnM3fu3Edu5gE4BQzdtYu2rVsz6dtv75lrV0REREx22fy+Y8cOyt66iH3RokXZv39/3HN///032bJli7t6zquvvsr27dupVq3aQ9/vAtCpfXvGff457m5uoAM4Ep5haL0mBq1n+9M6tj+tY/t7yvVrl1IPCwu755xxDw8PYmJi8PT0NC9rd9eMb76+voSFhT3y/Qq+9BJFixfnzyNH7BFXALy8CD182OoUrk/r2f60ju1P6zhRRN6eoyUe7FLq/710nc1mw9PT84HPPck87UWLFrVHTBEREZdil33qxYsXZ+PGjQDs3r2bfPnyxT2XO3dujh8/zpUrV4iKimL79u0Us/Ol6ERERJICu1ylzWazMXDgQA4dOoRhGAwbNow//viDGzduEBQUREhICF9++SWGYVCvXj2aNGmS0BFERESSHKe49KqIiIg8nlNMEysiIiKPp1IXERFxEQ5V6vaYiU7u9bh1vHTpUurXr0/Dhg3p378/NpvNoqTO63Hr+LZ+/foxZsyYRE7nGh63jvfu3Uvjxo1p1KgR//vf/4iMjLQoqXN73HpevHgxdevWpV69esyaNcuilK5hz549NGvW7L7H4917hgNZtWqV0atXL8MwDGPXrl1Ghw4d4p6LiooyKleubFy5csWIjIw0AgMDjXPnzlkV1Wk9ah3fvHnTqFSpknHjxg3DMAyja9euRnBwsCU5ndmj1vFts2fPNho0aGCMHj06seO5hEetY5vNZtSuXds4duyYYRiGMW/ePOPvv/+2JKeze9zPcunSpY3Lly8bkZGRcb+fJf6+/fZbo2bNmkb9+vXvefxpes+hRupPOhOdt7d33Ex0Ej+PWsfe3t7MmTOH5MmTAxATE4NPAl0OMCl51DoG2LVrF3v27CEoKMiKeC7hUev46NGjpEmThqlTp9K0aVOuXLlCrly5rIrq1B73s5w/f36uX79OVFQUhmHg5uZmRUynly1bNsaPH3/f40/Tew5V6g+bie72c/GdiU7u96h17O7uToYMGQCYPn06N27coHTp0pbkdGaPWsfnzp1jwoQJ9O/f36p4LuFR6/jy5cvs2rWLxo0bM3nyZLZu3cqWLVusiurUHrWeAfLmzUu9evWoUaMGb731FqlSpbIiptOrWrVq3ARtd3ua3nOoUk/omejkfo9ax7fvjxw5ks2bNzN+/Hj9z/spPGodr1y5ksuXL9OuXTu+/fZbli5dysKFC62K6rQetY7TpElD9uzZyZMnD15eXpQtW/a+EaY8mUet54MHD7J+/XrWrl1LSEgIly5dYsWKFVZFdUlP03sOVeqaic7+HrWOAfr3709kZCRfffVV3GZ4iZ9HrePmzZuzcOFCpk+fTrt27ahZsyaBgYFWRXVaj1rHWbNmJTw8PO6gru3bt5M3b15Lcjq7R63nlClTkixZMnx8fPDw8CBdunRcu3bNqqgu6Wl6zy5zvz8tf39/Nm/eTMOGDeNmoluyZEncTHS9e/emTZs2cTPRZc6c2erITudR67hIkSIsWLCA1157jRYtWgBmCfn7+1uc2rk87udYnt3j1vHQoUPp3r07hmFQrFgx3nrrLasjO6XHreegoCAaN26Ml5cX2bJlo27dulZHdgnP0nuaUU5ERMRFONTmdxEREXl6KnUREREXoVIXERFxESp1ERERF6FSFxERcREqdZEEdurUKYoXL06zZs3i/kyYMOGhr+/duzcbN25k4cKFz3yBlytXrrBkyZIHPvf111/fMwnLmjVr6N69e7zef+/evbRu3ZpWrVrRokULJk2a9Ex5b9u4cSNz584F4PPPPycwMJApU6Y8cr29//77APz555/8/vvvD33d2LFjOXz4cILkFHF0DnWeuoiryJMnD9OnT0/0z/3zzz8JCQmhVq1a9zx+5swZDh06RIcOHQAYMmQImzZtomDBgvF6/0GDBjFy5Ehy585NdHQ0DRs2pGTJkhQqVOiZcpcrVy7u9vLly1m0aNE905M+yO3CX716NRkyZOD1119/4OtatWpFjx49+Pbbb58po4gz0EhdJJHExsby0Ucf0aZNGwIDA/niiy+e6Ov++OMPGjVqRNOmTWnTpg3//PMPp06dokGDBnGvadCgAadOneLrr79m69atcaPe22bPnk3VqlXj7hcvXpyBAwfG+3t44YUXmDlzJvv378fd3Z3Zs2dTqFAhFi5cSKdOnWjRogW1a9dm1apVAGzbti0ue58+fYiOjiYiIoKuXbsSFBREYGAgu3btittKMWHCBP7991/at2/Phg0b6Nq1KwDz588nMDCQOnXqxF34onTp0pw9e5ZFixYxZcoU9u7dyzvvvBOXtUuXLuzdu5dUqVLh4+PDwYMH4/39ijgblbqIHRw+fPieze9nz57lzJkzFC1alB9++IHZs2cze/bsJ3qvjz/+mP79+zNjxgwaNWrEiBEjHvraDh06ULJkyftmrtu2bRv58+ePu1+9evWnmtd/2LBhpE+fnoEDB/Lmm28ycuRIoqKiALhx4waTJ09m0qRJjBgxgujoaPr168eECROYMWMGmTNnZtGiRcyZM4csWbIwd+5cRowYwZ49e+Le//333ydjxoxMmjSJZMmSAXDx4kW+++47Zs2axcKFC7l+/XrcfNiZM2embt26tGzZkpdffplkyZJx+PBhrly5wqlTp3j55ZcB82pi27Zti/f3K+JstPldxA4etPk9LCyMffv2sXXrVvz8/OLK8L9WrlzJzJkzAejVqxfnzp2L20z++uuv8+mnn973NY+bGPLy5ctxV+B7nP9+fpEiRQCIjIzkwIEDdOrUiU6dOnH58mX69u3L3Llz8fX15fXXX4+70l+qVKk4d+4c586do0uXLgBERERQunRpLl26FLe5PV++fOTLl++RF7U5efIkefPmjSv5vn37PvS19evXZ+HChbzwwgvUrl077vGMGTNy9uzZJ/r+RZyZSl0kkSxcuJCUKVMyaNAgjh8/zrx58x5YxgEBAQQEBMTdz5QpEwcPHqRAgQL8/vvv5MiRAx8fHy5evEhsbCzh4eGcOnUKMC+fa7PZ7nvP2xfbeNx+6gd9/m1ubm58+OGHfP/99+TLl4+0adOSJUsWvL29AThw4AAAFy5cICwsjOeee47nnnuOr776ipQpU7J27VpSpEjBoUOH2LdvH5UrV+bkyZN88cUXj7zEb7Zs2Thy5AhRUVF4e3vzv//9j48++uieXLe/54CAACZNmkSaNGkYO3Zs3GuuXr1K+vTpH/u9izg7lbpIIilVqhTdunVjx44dJE+enOzZs3Pu3LnHft2QIUMYPHgwhmHg4eHBsGHDyJgxI6VLl+add94hW7ZsZM+eHTAL8NChQ0yZMoWWLVvGvccbb7zBnj17eOGFF546v7e3N1988QX9+/cnNjYWNzc3XnrpJerVq8fixYu5cOECLVq04Pr16wwYMAAPDw8++ugj2rVrh2EY+Pr6MmrUKIoXL07fvn1p2rQpsbGx9O3bl7/++uuhn5suXTratm1L06ZNcXNzo0KFCvdc1KJIkSKMGjWK3LlzU7JkSV5//XUuXbpEmjRp4l6zd+/euP3zIq5MF3QRSQJOnz7NyJEjGTdunF3ef+HChRw5coQePXrY5f3jY+DAgVStWpVSpUoB5ml+vXv35uuvv7Y4mYj96UA5kSQgS5Ys5M+fn3379lkdxa5at25NREREXKEDTJkyRaN0STI0UhcREXERGqmLiIi4CJW6iIiIi1Cpi4iIuAiVuoiIiItQqYuIiLgIlbqIiIiL+D84OhSPfv6cWAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# \n",
    "# Plot accuracy measures and diagnostic information\n",
    "#\n",
    "\n",
    "# Predict on test set\n",
    "predictions_lgbm_prob = lgbm.predict(x_test)\n",
    "\n",
    "# Plot feature importances\n",
    "lgb.plot_importance(lgbm, max_num_features=21, importance_type='split',\n",
    "                    height=0.5, color='#1f77b4', alpha=0.8, figsize=(8, 6))\n",
    "\n",
    "# plot ROC\n",
    "plot_roc(y_test, predictions_lgbm_prob)\n",
    "\n",
    "# plot confusion matrix\n",
    "plot_confusion_matrix(y_test, predictions_lgbm_prob, ['Negative', 'Positive'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 2: Baseline Using Dense Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------+\n",
      "|   uid | age        | reg_days   |   gender_female |   gender_male |   reg_channel_3 |   reg_channel_4 |   reg_channel_7 |   reg_channel_9 |   reg_channel_13 | ...   |\n",
      "|-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------|\n",
      "|     0 | 0.07033... | 0.18147... |               1 |             0 |               1 |               0 |               0 |               0 |                0 | ...   |\n",
      "|     1 | 0.09730... | 0.83230... |               1 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     2 | 0.07737... | 0.76807... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     3 | 0.07268... | 0.17892... |               1 |             0 |               1 |               0 |               0 |               0 |                0 | ...   |\n",
      "|     4 | 0.05041... | 0.17765... |               0 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     5 | 0.07502... | 0.72546... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     6 | 0.05041... | 0.22132... |               0 |             0 |               0 |               0 |               1 |               0 |                0 | ...   |\n",
      "|     7 | 0.05041... | 0.31333... |               0 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     8 | 0.07151... | 0.31333... |               1 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     9 | 0.08440... | 0.31206... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "+-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------+\n",
      "8979 rows x 30 columns\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Feature engineerign for Keras\n",
    "#\n",
    "x, y = profiles[['location', 'age', 'reg_channel', 'reg_days', 'gender_female', 'gender_male']], profiles['outcome']\n",
    "x = pd.get_dummies(x, columns=['reg_channel'])\n",
    "x = pd.get_dummies(x, columns=['location'])\n",
    "\n",
    "#\n",
    "# Column-wise normalization\n",
    "#\n",
    "normalize(x, x.columns)\n",
    "\n",
    "print_df(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 5 Complete [00h 00m 04s]\n",
      "val_accuracy: 0.6628062129020691\n",
      "\n",
      "Best val_accuracy So Far: 0.6645879745483398\n",
      "Total elapsed time: 00h 00m 23s\n",
      "INFO:tensorflow:Oracle triggered exit\n",
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 30)]              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 8)                 248       \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 16)                144       \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 8)                 136       \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 1)                 9         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 537\n",
      "Trainable params: 537\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Test score: 0.6329279541969299\n",
      "Test accuracy: 0.6645879745483398\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# Train test split\n",
    "#\n",
    "x_train, x_test, y_train, y_test = train_test_split(x.to_numpy(), y, test_size=0.25, random_state=42)\n",
    "\n",
    "#\n",
    "# Model specification\n",
    "#\n",
    "def build_model(hp):\n",
    "    dense_1_dims = hp.Choice('dense_1_dims', [8, 16, 32])\n",
    "    dense_2_dims = hp.Choice('dense_2_dims', [8, 16, 32])\n",
    "    dense_3_dims = hp.Choice('dense_3_dims', [8, 16, 32])\n",
    "    \n",
    "    input_agg = Input(shape=(x.shape[1]))\n",
    "    dense_1 = Dense(dense_1_dims, activation='relu')(input_agg)\n",
    "    dense_2 = Dense(dense_2_dims, activation='relu')(dense_1)\n",
    "    dense_3 = Dense(dense_3_dims, activation='relu')(dense_2)\n",
    "    prob_outcome = Dense(1, activation='sigmoid')(dense_3)\n",
    "    model_dense = Model(inputs=input_agg, outputs=prob_outcome)\n",
    "    \n",
    "    model_dense.compile(optimizer='rmsprop', \n",
    "                        loss='binary_crossentropy', \n",
    "                        metrics=['accuracy']) \n",
    "    \n",
    "    return model_dense\n",
    "\n",
    "#\n",
    "# Hyperparameters optimization\n",
    "#\n",
    "tuner = kt.RandomSearch(build_model, objective='val_accuracy', overwrite = True, max_trials=5)\n",
    "tuner.search(x_train, y_train, batch_size=16, epochs=10, validation_data=(x_test, y_test))\n",
    "best_hp = tuner.get_best_hyperparameters()[0]\n",
    "model_dense = tuner.get_best_models()[0]\n",
    "model_dense.summary()\n",
    "\n",
    "#\n",
    "# Model training\n",
    "#\n",
    "score = model_dense.evaluate(x_test, y_test, verbose=0) \n",
    "print('Test score:', score[0]) \n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "#\n",
    "# Model evaluation\n",
    "#\n",
    "predictions_dense_prob = model_dense.predict(x_test)\n",
    "plot_roc(y_test, predictions_dense_prob)\n",
    "plot_confusion_matrix(y_test, predictions_dense_prob, ['Negative', 'Positive'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 3: LSTM Model\n",
    "\n",
    "The second step is to build an LSTM model using Keras. We use a model with two inputs:\n",
    "* One input is a 3D tensor that consist of ordered usage histories aggregated by weeks. This is input is processed by LSTM.\n",
    "* The second input is the user profile. This input is proceed by a dense layer.\n",
    "\n",
    "Output of the two submodels are concatenated and processed by several dense layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------+\n",
      "|   uid | age        | reg_days   |   gender_female |   gender_male |   reg_channel_3 |   reg_channel_4 |   reg_channel_7 |   reg_channel_9 |   reg_channel_13 | ...   |\n",
      "|-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------|\n",
      "|     0 | 0.07033... | 0.18147... |               1 |             0 |               1 |               0 |               0 |               0 |                0 | ...   |\n",
      "|     1 | 0.09730... | 0.83230... |               1 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     2 | 0.07737... | 0.76807... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     3 | 0.07268... | 0.17892... |               1 |             0 |               1 |               0 |               0 |               0 |                0 | ...   |\n",
      "|     4 | 0.05041... | 0.17765... |               0 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     5 | 0.07502... | 0.72546... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     6 | 0.05041... | 0.22132... |               0 |             0 |               0 |               0 |               1 |               0 |                0 | ...   |\n",
      "|     7 | 0.05041... | 0.31333... |               0 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     8 | 0.07151... | 0.31333... |               1 |             0 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "|     9 | 0.08440... | 0.31206... |               0 |             1 |               0 |               0 |               0 |               1 |                0 | ...   |\n",
      "+-------+------------+------------+-----------------+---------------+-----------------+-----------------+-----------------+-----------------+------------------+-------+\n",
      "8979 rows x 30 columns\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Feature engineering for Keras\n",
    "#\n",
    "x, y = profiles[['location', 'age', 'reg_channel', 'reg_days', 'gender_female', 'gender_male']], profiles['outcome']\n",
    "x = pd.get_dummies(x, columns=['reg_channel'])\n",
    "x = pd.get_dummies(x, columns=['location'])\n",
    "\n",
    "#\n",
    "# Column-wise normalization\n",
    "#\n",
    "normalize(x, x.columns)\n",
    "\n",
    "print_df(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# plot how the number of activity records per user is distributed \n",
    "#\n",
    "plt.figure(figsize=(20, 5));\n",
    "sns.distplot(df_logs.groupby('uid').count()['views'], bins = 200, kde = False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+------------+------------+------------+\n",
      "|           | views      | previews   | duration   |\n",
      "|-----------+------------+------------+------------|\n",
      "| (0, -104) | 0.02357... | 0.05372... | 0.15709... |\n",
      "| (0, -103) | 0.01817... | 0.05228... | 0.11822... |\n",
      "| (0, -102) | 0.01799... | 0.05314... | 0.12069... |\n",
      "| (0, -101) | 0.00971... | 0.05458... | 0.07107... |\n",
      "| (0, -100) | 0.00503... | 0.04108... | 0.04295... |\n",
      "| (0, -99)  | 0.00233... | 0.01407... | 0.01507... |\n",
      "| (0, -98)  | 0.00503... | 0.02872... | 0.05008... |\n",
      "| (0, -97)  | 0.01421... | 0.02729... | 0.09132... |\n",
      "| (0, -96)  | 0.00143... | 0.00861... | 0.01189... |\n",
      "| (0, -95)  | 0.01097... | 0.02212... | 0.06178... |\n",
      "+-----------+------------+------------+------------+\n",
      "507445 rows x 3 columns\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# aggregate daily activity records into buckets (e.g. weekly) and normalize\n",
    "#\n",
    "df_logs['time_bucket'] = -((df_logs['date'].max() - df_logs['date']).dt.days / 7).astype(int)\n",
    "df_logs_weekly = df_logs.groupby(['uid', 'time_bucket']).sum()\n",
    "normalize(df_logs_weekly, df_logs_weekly.columns)\n",
    "print_df(df_logs_weekly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# plot how the number of weekly activity records per user is distributed \n",
    "#\n",
    "plt.figure(figsize=(20, 5));\n",
    "sns.distplot(df_logs_weekly.groupby('uid').count()['views'], bins = 200, kde = False);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input tensor shapes: x3d (8979, 113, 3), x (8979, 30), y (8979,)\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Feature engineering for Keras: 3D tensor for LSTM (n_users x events_per_user x n_features_per_event)\n",
    "#\n",
    "a3d = df_logs_weekly.sort_values(['uid', 'time_bucket']).groupby('uid').apply(pd.DataFrame.to_numpy)\n",
    "n_users = len(df_users)\n",
    "events_per_user = df_logs_weekly.groupby('uid').count()['views'].max()\n",
    "n_features = len(df_logs_weekly.columns)\n",
    "x3d = np.zeros((n_users, events_per_user, n_features))\n",
    "for uid in df_users.index:\n",
    "    if uid in df_logs.index:\n",
    "        n_events = min(events_per_user, len(a3d[uid]))\n",
    "        x3d[uid, -n_events:, :] = a3d[uid][-n_events:, :]\n",
    "        \n",
    "print(f'Input tensor shapes: x3d {x3d.shape}, x {x.shape}, y {y.shape}')\n",
    "\n",
    "#\n",
    "# Train-test split\n",
    "#\n",
    "x3d_train, x3d_test, x_train, x_test, y_train, y_test = train_test_split(x3d, x, y, test_size = 0.25, random_state = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "421/421 [==============================] - 12s 25ms/step - loss: 0.6386 - accuracy: 0.6482 - val_loss: 0.6262 - val_accuracy: 0.6663\n",
      "Epoch 2/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.6137 - accuracy: 0.6723 - val_loss: 0.6046 - val_accuracy: 0.6834\n",
      "Epoch 3/10\n",
      "421/421 [==============================] - 9s 22ms/step - loss: 0.6040 - accuracy: 0.6816 - val_loss: 0.5937 - val_accuracy: 0.6892\n",
      "Epoch 4/10\n",
      "421/421 [==============================] - 9s 21ms/step - loss: 0.5913 - accuracy: 0.6953 - val_loss: 0.5777 - val_accuracy: 0.7034\n",
      "Epoch 5/10\n",
      "421/421 [==============================] - 9s 22ms/step - loss: 0.5771 - accuracy: 0.6990 - val_loss: 0.5621 - val_accuracy: 0.7167\n",
      "Epoch 6/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.5656 - accuracy: 0.7100 - val_loss: 0.5557 - val_accuracy: 0.7186\n",
      "Epoch 7/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.5598 - accuracy: 0.7158 - val_loss: 0.5502 - val_accuracy: 0.7198\n",
      "Epoch 8/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.5554 - accuracy: 0.7168 - val_loss: 0.5485 - val_accuracy: 0.7251\n",
      "Epoch 9/10\n",
      "421/421 [==============================] - 10s 23ms/step - loss: 0.5536 - accuracy: 0.7217 - val_loss: 0.5528 - val_accuracy: 0.7198\n",
      "Epoch 10/10\n",
      "421/421 [==============================] - 9s 21ms/step - loss: 0.5521 - accuracy: 0.7238 - val_loss: 0.5409 - val_accuracy: 0.7317\n",
      "Test score: 0.5648325681686401\n",
      "Test accuracy: 0.7113585472106934\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAHsCAYAAADLkTRCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABn9klEQVR4nO3ddXxV9QPG8c96bKNbFKRDUEAQkc4NGEhIp3QYIEgpISBp0GLR0iUhNUYIPwyQ1AEijUjHguU9vz+ODJAasLuze/e8Xy9f59bufXY29/A98T0uhmEYiIiIiMNztTqAiIiIJA6VuoiIiJNQqYuIiDgJlbqIiIiTUKmLiIg4CZW6iIiIk3C3OoCkLAULFqRAgQK4urri4uLCzZs38fPzY+jQoRQrVizRP+/1119nzpw5pEmTJtHfG2D+/PnMnz+f2NhYXFxcKFKkCL169eKZZ56xy+f91+LFi4mOjqZly5bMnz+f0NBQOnfunCjvHRcXx+zZs1m1ahVxcXHExMRQpUoV3n33XTw9Penfvz/58+enQ4cOifJ5CbVlyxb27dvHu++++1hfN2HCBHLlykX9+vUf+JrJkydTqFAhqlevnqDX/1dYWBjvvvsuU6ZM4YcffuDjjz/m2WefBcAwDMLCwihVqhTDhw/Hy8sLgD/++IMJEyZw7NgxfHx88PHxoUOHDlSvXj3+fW/cuMHEiRP5+eef4//fadmyJY0bNwZg9OjRVKlShTJlyjzWOhEnZIgkoQIFChiXL1++67FvvvnGaNKkiUWJntzo0aONdu3aGX///bdhGIYRFxdnLF++3Chfvrxx7ty5JMnQr18/45tvvrHLe3/44YfG22+/bdy4ccMwDMMIDw83unXrZvTp08fun/0wEydOND766CO7vHerVq2MtWvXPvHXDxkyJP7rly5danTu3Pmu5yMjI40GDRoY8+fPNwzDMPbt22dUqFDB2Lx5c/xrjh49atSpUyf+NZGRkUbdunWNr776yoiJiTEMwzDOnDljVK9e3Vi0aJFhGIZx48YNIzAw0Lh58+YTZxfnoJG6WCo2NpZz586RNm3a+Me++OILNmzYgM1mI0eOHAwZMoSsWbNy8eJFhgwZwrFjx3B1daVZs2a0adOG0NBQPv74Y44cOUJMTAxly5alb9++uLu7U7BgQXbu3En37t1588038ff3B2DcuHEAvP/++yxevJj58+djs9lIly4dgwYNIm/evPTv359r165x+vRpKleuzPvvvx+f8Z9//mHBggVs2bIlPrurqyv169fn4MGDfPnllwwZMoSqVatSp04dduzYQWhoKG+++SYtWrQAIDg4mC+++IKYmBi8vb3p168fJUqUYNKkSezdu5cLFy5QsGBB+vfvz+DBg7l8+TIXL14kR44cjB8/nt9++43g4GB27NiBt7c3V65c4erVqwwePJiqVavSoEEDdu7cyblz53j99dfp2bMnAF999RVLlizB19eXUqVKsWnTJoKDg+/6uZw5c4ZVq1axfft2/Pz8APDx8eGjjz7it99+i3/dnj17aNasGZcuXSJ//vx8+umn+Pj4sGTJEhYuXEhMTAzXr1+nU6dOtGjRgmXLlrFkyZL4LTRffvklQ4cO5eTJk1y7dg1fX18++eQT8uTJc9+f90svvcSCBQuIi4sjderU9OrVK8E/v8uXL8dvWZg4cSIbN27Ew8OD9OnTM2rUKDZu3MjBgwcZO3Ysbm5ubNq0Kf71+/btY8SIEdy8eRMPDw/69u1L2bJl71pn586dY/PmzXz44YcP/H2/du0aYWFh8b8zEyZMoGvXrlSuXDn+NXnz5mXs2LG0a9eOhg0b8sMPP+Dj40OnTp3iX3PrdyAmJgaA1KlTU6JECRYuXEjbtm0f+PmSAlj9rwpJWQoUKGAEBgYagYGBRrly5YyqVasaw4cPNy5dumQYhmEsX77c6NmzZ/yIZMGCBUbHjh0NwzCMHj16GGPGjDEMwxyZ1KlTxzhx4oTRv39/Y/bs2YZhGEZsbKzRp08f46uvvor/vMuXLxtLliyJHzXFxsYa5cuXN44fP278/PPPRosWLYyIiAjDMAzjxx9/NAICAgzDMEeibdu2ve/3sW7dOqNhw4b3fW7Tpk1G3bp1DcMwjCpVqhiDBg0ybDabce7cOaNMmTLGoUOHjOPHjxuBgYHGlStXDMMwjCNHjhjlypUzwsPDjYkTJxr+/v7x62DmzJnGl19+aRiGYdhsNqNjx47Gt99+G5/x1mj5zhFslSpVjNGjRxuGYRj//POPUaxYMePUqVPGtm3bDH9/f+P69euGzWYzBgwYYFSpUuW+31+jRo0e+HO89dlvvPGGERERYcTGxhoNGjQwli9fboSFhRlNmjSJ/9727NljFC9e3DAMc/RaunRpIzQ01DAMw1i7dq0xfPjw+PccNGiQMWzYMMMwHvzzvvP7fJyf36119ffffxslS5Y0oqKiDMMwjG+//dbYuHGjYRh3j9RvvT46OtooV65c/Gj6wIEDRmBgoBEXF3fX+pgzZ47Rr1+/+PtLly41SpYsadSrV8/w9/c3ypQpYzRt2jR+BG4YhlG8eHHjyJEj912/r7zyivH7778bw4YNi18PD7N+/XqjZcuWj3ydODeN1CXJzZo1iwwZMvD777/TuXNnypQpQ8aMGQHYvHkzBw4coFGjRgDYbDZu3rwJwP/+97/40XLq1KlZvXo1YO5jPXDgAEuWLAEgMjLyns+sXbs2Y8eO5eLFi/zxxx88//zzPP/88yxatIiTJ0/SrFmz+NfeuHGDa9euAfDyyy8/8PuIjY297+PR0dG4uLjE32/RogUuLi5ky5aNChUqsGPHDry8vLhw4QLt2rWLf52LiwunTp0CoHjx4ri7m/97tm3bll27djFjxgxOnDjBn3/+yUsvvfTAXLdUq1YNgKxZs5IxY0auX7/O1q1bCQgIiD/GoGXLlvz000/3fK2rqys2m+2Rn1G9enVSpUoFQP78+bly5Qq+vr5MmzaNrVu3cuLECQ4dOkRERET81xQsWDB+9B8QEMBzzz3HnDlzOHnyJL/88gslSpQAHvzzvtOWLVse++eXNWtWChUqRIMGDahYsSIVK1a8Z9R9pyNHjuDq6ho/mi5atCirVq2653XHjh0jZ86cdz1WqlQpvvzyS2w2G1OnTmX16tUEBATc9ZpH/R65uLhgJGA272effZbjx48/8nXi3FTqYpkXXniBAQMG0L9/fwoXLsyzzz6LzWajY8eO8Zuoo6OjuX79OgDu7u53leXp06dJnz49NpuNCRMmkDdvXsD8o37n6wBSpUqFv78/q1evZs+ePfEHGNlsNl5//fX48rDZbFy4cCF+86iPj899sxcvXpyTJ09y8eJFMmfOfNdzP//8c3wx3cp9i81miy/MsmXLMn78+Pjnzp07R5YsWdi4ceNdnztu3Dj2799Po0aNKFOmDLGxsQn6I3/rQCwgvhjc3d3v+lo3N7f7fu2LL77IsWPHCAsLiy9ggPPnzzNo0CAmTpx4z/d26zP++ecfmjZtSpMmTXj55ZcJCAhg8+bN8a+783ubN28eixYtomXLltStW5d06dJx5syZ+Pe+38/7Tk/y83N1dWXu3LkcOHCAnTt3MnLkSCpUqEDfvn3vuy7c3Nzu+X06cuQIefLkuef7f9A/hFxdXXnrrbfYs2cP/fv3Z9q0aQCULFmSn3/+mcKFC9/1+v379+Ph4UGePHkoXrw433333T3vuWnTJnbt2kW/fv3i15erq05oSun0GyCWCgwM5MUXX2TUqFEAlC9fniVLlhAWFgaY+xxv/bEtW7YsS5cuBSA0NJS2bdty4sQJypcvz8yZMzEMg+joaLp168bcuXPv+awmTZqwfPlyfvvtt/h96+XLl2fNmjVcuHABMI9mT8g+yaxZs9K6dWvee+89zp8/H//40qVL2bBhw137P1esWAHA33//zY4dO+JHhjt27OCvv/4CYOvWrdSrV+++Wxm2b99O27ZtqV+/PhkzZuR///sfcXFxgFk4Dxrp3U+lSpXYsGEDoaGhAPFbN+73/dWtW5eBAwfG/yzCwsIYOnQo6dKlw9vb+4GfcfDgQTJkyED37t0pX758fKHfyvzf761BgwY0btyY3LlzExwcHP+6B/287/yen+Tnd+jQIQIDA8mbNy9dunShXbt2HDhwALj/+syTJw8uLi7s2LEDgN9//522bdveU+C5c+fm9OnTD/3sIUOGsGPHDoKCggDo3bs333zzDVu3bo1/zV9//cWAAQN499138fLyombNmoSFhfH111/Hr5vTp08zevTo+H/IgnkcRJ48eR76+eL8NFIXyw0aNIh69erx448/0rhxY86fP0+TJk1wcXEhe/bsjB49GoDBgwczdOhQ6tati2EYdOnShaJFi/LBBx/w8ccfU7duXWJiYnjttdfo2LHjPZ9TtGhR3NzcCAgIiB/Fli9fnk6dOtG+fXtcXFzw8/Nj8uTJ94zM7qd3794sXryYbt26ER0dTXR0NMWKFWPBggXkyJEj/nVnzpyhYcOGREZG8uGHH8b/4R02bBjvvfde/Aj6iy++wNfX957P6dGjB2PHjmXChAl4eHhQsmTJ+M30FStWjF8/CVG2bFmaNGlC06ZN8fb2Jn/+/PGbz/9ryJAhTJ06lWbNmuHm5kZ0dDTVq1fn7bfffuhnlCtXjiVLlhAQEICLiwuvvPIKGTJk4OTJk/e8tn379gwePDj+HxfFixfnyJEjwIN/3tHR0fTp04fhw4czaNCgx/75FSpUiFq1atGoUSN8fHzw9vaOP7itatWqfPbZZ/EHoAF4enoyadIkRo4cydixY/Hw8GDSpEl4enre9b7Vq1fnm2++IS4u7oFbQHLmzEmnTp0YNWoUFSpUoEiRInz77bdMmDCBkSNH4ubmRpo0aXj77bfjN9N7enoyY8YMxo0bR926dXFzc8PNzY1u3brRsGHD+Pf+8ccf79m0LymPi5GQ7Xgi8kSqVq3KhAkT7HIO/pM4cOAAe/bsoU2bNgDMmDGDffv23bUbQJ7coEGDKFu2LLVr107Szw0LC6NZs2YsXbr0rt0ukvJo87tICpI7d2527dpFYGAgdevWZefOnQwYMMDqWE7j1imS99uNYk+TJk1i4MCBKnTRSF1ERMRZ2G2kvm/fPlq3bn3P48HBwTRq1IimTZuyaNEie328iIhIimOXA+W+/vprVq5cec8BODExMYwaNYolS5aQKlUqmjdvTpUqVe45JUhEREQen11G6jlz5mTSpEn3PP7XX3+RM2dO0qZNi6enJy+//DK7du2yRwQREZEUxy4jdX9///gJJO4UFhZG6tSp4+/7+vrGnwP7MLt379akCnZ2a1IUsS+tZ/vTOrY/p17HsbG43jED4p1cYmJwDQ2FO753l7g4XMPD73lt3BNeGfJmXBx/RUTg6uJCgRdeoHjx4o/19Ul6nrqfnx/hd3zz4eHhd5X8g7i6ut41Q5ckvpCQkHtmtZLEp/Vsf1rH9ucQ6/jcOfh3Nsp4338Ply/DzZsweTKkTQvu/6nBy5cf/d65csGt0jYMCA+HwED44AOz8FOlgv/MY5AQUVFRFChalJiYGILXrsXw8Hjs90jSUs+bN2/81Zh8fHzYtWtXkl+LWUREHNx9ZieMFxYGjRrBpk0Pfs2tIs+bF0qXvvf5TJngQXMNZMpklnoCJqh6XF5eXsz8+muezZGD/HnzEnLs2GO/R5KU+qpVq4iIiKBp06b079+fDh06YBgGjRo1ImvWrEkRQUREHI3NBr/+Cp99BremJg4Kgr//TtjXjxwJd8zuiIsLVK1qFvOt+8nAz7/8wh8hIbzZti1Vbl2GNwEXVLofu5X6s88+G3/KWt26deMfr1q1KlWrVrXXx4qISHJis8E//8Dy5XD16t3P7d0LP/5obq6+3z76/151LlcucHMzX//ee/f/GgAvL+jeHe4z7XJys33HDmrVq0f2bNlo/u/0zU9Dc7+LiEjiCguD9evht9/M0fKj1K0L9zu+qmxZ8726dYPy5eHOfczJZJT9NDZv2UJggwY89+yzbFq37qkLHVTqIiKSWC5fhvnzoU8fiIq6/Xjx4tC5M9SpAxky3P01rq73HqyWAmzYuJHX33iDPLlzs2ndOrJly5Yo75vy1qSIiDy98HDzyO/ISFi8GL77Dv69PC1g7sv+/nvIkgV07NQ9Dhw8SMECBdj4ww+JOgGbSl1ERG6LjoZt2+DwYVi71tx//R+FVqyA/1x3Pt7bb5uby/PkcYpN5IktNDSU1KlT07tXL3p065Yom9zvpFIXERHzHOspU+49t/u558DP766Hop97Dq+oKOjRwyxuLy9o3NjctP4E51anFIuXLqX7O++wad06XixWLNELHVTqIiIpz/r1cPaseapY+vRmMf/4o/lc69bmEeZt25qbzvPmvWfEfcwRJp9JZr6bP5827dvzWtmy5H7+ebt9jkpdRCSlOHkS/lsoLi5QsSJUqgQdO0KTJpZEc2YzZs2iQ5cuVK5UiVXLluFrx1PtVOoiIs5uxw6zrG9N2pIuHaxcCc88A88+q33fdrR+wwbad+5MjWrVWLFkCT4+Pnb9PJW6iIgz+eAD2Lfv9v3r12H7dvO2uzv06gXDhj144hZJVFUqV2bk8OH0eucdu+xD/y+VuoiIMzhwAN56yzxyHeDWRbAMAwoWNMu8XTuNypPIjFmzCKxdm8yZMzOgb98k+1yVuoiII+nUyZyp7b8j7V27bt/esQNKlUraXBJv5JgxfDB4MAP69mXk8OFJ+tkqdRERR9GkiTnRC4C//93P+ftDmTIwYIA2rVvEMAw+GjGCj0aMoGXz5gwbMiTJM6jURUQcwciRtwv90CHIndvaPHIXwzD4YPBgRo0dS7s2bfhm2jTc3NySPIf+OScikpxt3myecvbBB+b99etV6MlQaGgoS5cvp3OHDnz75ZeWFDpopC4iknzExJhHrt+6lvasWTB16u3nv/wSbl1vW5IFm82GzWYjTZo07Ny2jfTp0+Ni4cGIKnUREauFhZkHulWpcv/nv/jCnOlNU7AmKzabja49ehAWHs7cmTPJ8N8r0FlApS4ikhSioyE42FwCrFgBV6/C7t1w+vTdr1261Dz1zMXFPPgtY8YkjysPFxcXR8euXZk5ezYD+/WzdHR+J5W6iEhiMgz46y9zH/iqVebFTtzczGuN30/RombRd+sG5cub/yWTgpD7i42NpW2HDsxbsICPBg9m0MCBKnUREadz4QJkz357nzhA8+a3N5vbbOaFUm4VQMGCkDp10ueUp9K5e3fmLVjAyOHDk3RimYRQqYuIJIboaGjV6nahz5wJFSqYc6uLU2nXujUvFSvGu2+/bXWUe6jURUSe1sSJ8O67t+8fPWpeh1ycRmRkJOvWr6f+669TsUIFKlaoYHWk+9J56iIiT+uTTyBtWmjaVIXuhCIiIqjXsCENmzYlJCTE6jgPpZG6iMiTMgzzgLjTpyFLFpg92+pEksjCwsKo27AhW7dtY/pXX1G4cGGrIz2USl1E5HH9/jts2gRDhsC1a+Zj06ZZGkkS340bN6j9+uvs/Okn5s6cSYtmzayO9EgqdRGRxxEeDq+9Bjdu3H7szz8hZ07rMoldrF2/np9/+YUFc+fSuFEjq+MkiPapi4gkRFgYvPgi+PmZhV65Mpw9az6uQncqhmEA0LRxYw7t3+8whQ4qdRGRhGndGg4cMC+u0q0bfPcdZMqkqVudzMWLF6lQtSr/27kTgLx581qc6PFo87uIyP2sWwe1at37+NSpkD9/0ucRu/vnn3+oFhDAsePHCQsLszrOE1Gpi4jcKTISTp26XegNG5ozv7m6mrPDqdCd0tmzZ6nq78+Zs2f54fvvqeKgV8NTqYuI3HLkiFngt5QqBfPmaS52J3f+/HkqVa/OhYsXWb96NeXLlbM60hPTPnURkRs3zP3lc+ea9ytVgjlz4McfVegpQMaMGalcqRIbf/jBoQsdNFIXkZRs504ICoLBg28/5uJijs4zZbIulySJo0eP4uvrS/bs2fnGSeYZUKmLSMrxxx8wahTExcGxY/Dzz7efe+01eOstyJpV1y9PAUJCQqhWqxb58+Vjy8aNyebSqU9LpS4izuv8edi+Hfbtg/nzzXnZAXLlMq9xniGDOW97nTrm3O1O8oddHu7g779TLSAAFxcXpk6c6DSFDip1EXE20dEQEAC//gpXrtz7/LBh8P77twvcif6gy6Pt2buXGrVr4+XlRfC6dRS888BIJ6BSFxHHFx1tjsbr1KHwxYu3Hy9YEDp3NieMKVrULHCVeIplGAbv9u6Nj48PwevWkS9fPqsjJTqVuog4NpsNvL3NK6YBhrs7Lu+9B4MGgaenxeEkOXFxcWHxvHncvHmT559/3uo4dqFT2kTEsURFwbJlUKUK1K9v7hv/t9BZvpzDW7bA8OEqdIn34/bttO3QgZiYGLJmzeq0hQ4aqYuIo/j1V/NUs8WLzQupgDnLW7Fi5kVW5s6FZ5/FCAmxNqckK5uCg6nXqBE5n3uOa9eukTlzZqsj2ZVKXUSSH5sNrl6F77+H2FjzVLOYmNvPe3vD5s1QvLhZ7CL3sX7DBuo3bky+vHkJWrvW6QsdVOoikhwcPQr9+4OPjzn3+uLF93/d/PnmJncd8CaPsOaHH2jYtClFChdm4w8/kCmFTCakUhcR67VrBzt2gJeXOflLtmzmKLx6dXj9dfPyptmyqcglwTJlykSFcuVYNG8eGTJksDpOklGpi4i1rl83Cz1tWvjnH50/Lk/l0KFDFCpUiDKvvMLGtWudamKZhNDOKBGxVtWq5vKVV8z949q0Lk9o7rx5vFCiBAsWLQJIcYUOGqmLSFIKDYXZs8251ydNMveh799vPjd/vrXZxKFNnzmTjl27UqVSJerWqWN1HMuo1EUk6WTKZM7+dqe6dc2j21OntiaTOLwvv/6arm+9Rc3q1VmxZAmpUqWyOpJlVOoiYh9RUTB0qLkp/bffYP3628+dPn37giopcBOpJJ4/QkLo9vbb1KlViyULFuDt7W11JEup1EUkcQQHw6lT5m3DgPbt731N/fowciRkyZKk0cR5FSlcmNXLl1O9WjU8NYugSl1EntDu3eZlS318YPr0+7/G3d28UtqtP7YalUsiGfvJJ5QuVYoqlStTu1Ytq+MkGyp1EUm46GgoX96cpvXvv28/ni2buU/8q68ge3bzMVdXeO45zfgmicowDIYOH86wjz+mc4cOVKlc2epIyYpKXUQSbvx4cw52NzfzALeGDaFp09unoonYkWEYDPjwQ8Z88gnt27Vj6qRJVkdKdlTqIpIwCxdCv37m7b//hnTpLI0jKYthGPTu25fPJ06ka6dOTJk4EVdtBbqH1oiIPNj69eakMPnzQ7Nm5mM1apizv4kkIcMwuHT5Mu/06MHUSZNU6A+gkbqI3Cs8HHbuhG++MQ+Iq1kTcuSA998352PXpnZJIjabjcuXL5M5c2ZmfP01rq6uKXKmuIRSqYvIvd59F7791rydLRusWKEilyQXFxdHhy5d2L5jB7/9/DNp0qSxOlKyp1IXETh/HoKCzHPN580zL3/q5QU//GAewa5ClyQWGxtLm/btmb9wIcOGDFGhJ5BKXSSl2rDBnG999244cODu5woVMo90L1/ekmiSskVHR9OiTRuWLl/O6I8/pl+fPlZHchgqdZGUJCoKIiLg0CHw9zcf8/U1lyNGmNcuz5pVB8KJpT4cMoSly5fz2dix9Hr3XavjOBSVukhKER0Nzz4Lly7dfmzMGHjnHV3uVJKVvr17U/yll2hx64wLSTCdEyDirL7/3hx1Z8pk/pctm1no9erBuHEwdSp07aqJYyRZiIiIYOjw4URFRZEpUyYV+hPSSF3EGR05Yh69fuECdO58u7Q9PMzLnObObW0+kTuEhYUR2KABP27fTvnXXqN6tWpWR3JYKnURZ7FyJSxYYB65vny5+VjWrOYBb25ulkYTeZDr169T+/XX+fmXX5g7c6YK/Smp1EUcnWGY+8UnTzbv58xplnmrVjBggApdkq2rV6/iHxjInr17WfjddzRq0MDqSA5PpS7iaH79FY4dg2nTzEuabthw+7k5c6BxY/O29pNLMnfm7FlOnT7N0gULqFe3rtVxnIJKXSS5O34cRo6EVavMfeSGcffzpUubm9xnzIBixazJKPIYwsPD8fX1pVjRovwVEoLvrdMq5amp1EWSs8uXIU+e2/c9PMwj1itVMi+yki8fuOt/Y3Ec586do1pAAO1at6Zvnz4q9ESmvwYiydmCBeayQQOYO9fcP67N6uKgzpw5Q1V/f/4+d44yr7xidRynpPPURZKjiAjo3t08/QzMg+Dc3VXo4rBOnjxJperV+ef8edavXk2lihWtjuSUNFIXSU5sNmjb1hyV39KmDWTIYF0mkad08+ZNqtSsyZWrVwlau5ZXSpe2OpLTUqmLJCc3bpiFnicPvPoqfP45pEtndSqRp5IqVSo+GjyYF4oUoWSJElbHcWra/C6SXGzdenumt65dzaPZVejiwEJCQtgYFARA65YtVehJQCN1EavFxUGWLHDlinnf3R0CAqzNJPKUDhw8SLWAAPx8fTl04ACenp5WR0oRNFIXsVJkpFnitwo9KAjCwqBgQWtziTyFPXv3UqVmTTw9PVm3apUKPQlppC5ipcuXzaWPD5w6BalTW5tH5Cn98uuv+AcGkiZNGoLXrSNv3rxWR0pRNFIXsYLNBr16mdc3B/jkExW6OIUFixaRPl06tgUFqdAtoFIXscLXX5tXTwOoWBHq17cyjchTi4uLA+CTMWP4eft2cuXKZXGilEmlLpLUTp0yj24H+PNP2LgRMma0NpPIU9gUHEyxkiU5efIkrq6uZM6c2epIKZZKXSSptWljLqtUgeeeszaLyFNat349gQ0a4O7uTqpUqayOk+Kp1EWSUNYRI8zz0QFWr9a0r+LQVq1ezetvvEGhggUJXr+eLFmyWB0pxbPL0e82m42hQ4dy+PBhPD09GTFixF37V1auXMmMGTNwdXWlUaNGtGjRwh4xRJKPgwdh1iwyzJtn3p8+XVdXE4cWtGkTDZs2pUTx4qxfvZr06dNbHUmwU6kHBQURHR3NwoUL2bt3L6NHj+aLL76If37s2LGsXr0aHx8f6tSpQ506dUibNq09oohYzzDuvs55cDCUK2ddHpFEUOrll+nQrh1jRo7U3+9kxC6b33fv3k2FChUAKF68OAcPHrzr+YIFCxIaGkp0dDSGYeCiTZDizFq1MpdNmnB05Up47TVr84g8hXXr1xMZGUm6dOmYNmWKCj2ZsctIPSwsDD8/v/j7bm5uxMbG4v7v5sb8+fPTqFEjUqVKRY0aNUiTJs1D389msxESEmKPqPKvyMhIrWM78Dh9mmd/+QVv4EinTkSkSUPIoUNWx3JqUVFR+l22k6XLlzN42DA6vvkmvd55x+o4zs1mAy+vx/4yu5S6n58f4eHh8fdtNlt8oR86dIgtW7awadMmfHx8eP/991m7di21atV64Pu5urpSuHBhe0SVf4WEhGgdJ6aLF80D4ho3Nu/XrUuBihW1npOA1rF9TJ02jUEffURAzZp069xZ69jebDZCjh177C+zy+b3kiVLsm3bNgD27t1LgQIF4p9LnTo13t7eeHl54ebmRoYMGbhx44Y9YohY47PPzAu03Cr0Fi1g6lRrM4k8hfETJ9Lj3XepW6cOK5Yswdvb2+pI8gB2GanXqFGDHTt20KxZMwzDYOTIkaxatYqIiAiaNm1K06ZNadGiBR4eHuTMmZMGDRrYI4aINaZNM5cjR5pXWytSRKeuicO6fPkyH48ZQ6MGDZg3e7YuzpLM2aXUXV1dGTZs2F2P3TkHcPPmzWnevLk9PlrEWjabOUtc6dLQu7fVaUSeimEYZMyYkZ+2bSNnzpx4eHhYHUkeQSfKiiSmt94ylzoiWByYYRgM/ugjAIYPHaoLszgQzSgnkpiio83lwoXW5hB5QoZh0G/gQEaMGsU/589jGIbVkeQxaKQukph++gmyZQNfX6uTiDw2wzDo1acPEyZPpnuXLkwaP17ziDgYjdRFEkO3bubBcL//DpcvW51G5Im806sXEyZPpufbbzN5wgRcXVURjkYjdZEncfkybN4MY8aY56SfPGk+3rcvtGypo93FIZV99VX8/PwYOXy4RugOSqUu8rhmz4a2be9+rH59ePNN8xQ2EQcSGxvL3n37KPXyy7Ro1szqOPKUVOoiCWWzwYwZ0LGjeX/cOKhaFQoV0hXXxCHFxMTQpn17lq1YwR979+oodyegv0Qij/L33/D99+ascLcuTlShArz9tjazi8OKjo6meevWLFuxgrEjR6rQnYRKXeRBIiKgUSNYt+7ux/fvhwIFVOjisKKiomjcvDmr1qxh/Cef8O7bb1sdSRKJDm0UeZDx428X+pgxcOIEXLkCBQuq0MWhzZozh1Vr1jB14kQVupPRSF3kQcLCzOWpU5A1q7VZRBJRpw4dKFK4MOXLlbM6iiQyjdRF/is6Gn79FUaNMu9nyWJtHpFEEBoaSvPWrTl69CguLi4qdCelUhe5k80G5cvDK6+Y97WZXZzA9evX8Q8MZPHSpey/dbCnOCVtfpeU6+pV85zzNWvAx8d87Pvvbz+/fDm89pqKXRza1atX8Q8MZM/evSz87jsa1q9vdSSxI5W6pDyxsfDll7evqAbw/POQOjUUKwbe3jBnDuTObVlEkcRw+fJlqteqxR8hISxbuJC6gYFWRxI7U6lLymGzwW+/mdc6v6VUKfjuO8iVSyNycTqenp5kSJ+e75csIcDf3+o4kgRU6pIyxMZCvny352h3dYXDh+G551Tm4nT++ecf/Pz8SJ06NUHr1mke9xREB8pJyhAaahZ61aqwcqU5sUzOnCp0cTpnzpyhYrVqtGjTBkCFnsJopC7O79w5eOYZ83ZAAGgzpDipEydOUNXfn8tXrjDr22+tjiMW0EhdnNfRo+Y55rcKPXNmaN3a2kwidvLXX39RqUYNrl67RtDatZR99VWrI4kFNFIX57RlC1SpYt5u0sQ8OK5LF/DysjSWiD0YhkGz1q0JDw8neP16ShQvbnUksYhKXZzLvn3mTHALF5r3c+aESZMgXTpLY4nYk4uLC7O+/Za4uDiKFS1qdRyxkDa/i3NZscIs9IIFYcIEOHJEhS5Oa/+BA3w0YgSGYVCkcGEVumikLk5qzx5wc7M6hYjd/LZnDzVq18bHx4fuXbqQOXNmqyNJMqCRujiXJUusTiBidz//8gtV/f1JnTo124KCVOgST6UuzuHCBShRAm5drELn5oqT2vG//1Gjdm0yZsjA1o0bya3pjOUOKnVxfP37m9c737sXPD1h40ZzxjgRJ3T+wgWee/ZZtm3aRK5cuayOI8mM/vKJ4zEM8wC4Tp3M8h4zxnx87Fg4exYqVrQ2n4gdXLp0CYCG9euz99dfyZEjh8WJJDlSqYvjGTfOPLr9m2/Mgm/Vyjzq/d13IU0aq9OJJLof1q4ld8GCrN+wAQAPDw+LE0lypaPfxbHExEC/fubtyZOhenVdIlWc2vcrV9K4RQuKFS1KqZdftjqOJHMqdXEsa9eaywoVzM3vIk5sybJlNG/dmpdLlmTdqlWk05wL8gja/C6O4+ZNeP118/bHH1ubRcTO9u7bR7NWrSjzyitsWLNGhS4JolIXx1G5srnMmhVeecXSKCL29tKLLzLp889Zt2oVaXSsiCSQSl2St6++gsKF4YUXYP9+87Fjx3QeujitWXPmEBISgouLC926dMHPz8/qSOJAVOqSfE2aZF5Z7dAh82j3WrVg3jxw16Eg4pymfPEF7Tp2ZOxnn1kdRRyU/jpK8mMY5j7zQYPM+0uXQmCgtZlE7OzzCRN4r29fXq9bl2mTJ1sdRxyURuqS/PTqdbvQ27eHOnWszSNiZ6PHjeO9vn15o2FDFs+fj5eXl9WRxEFppC7Jy/795iVTAU6eNA+K0/5zcWKxsbGs37iR5k2bMnv6dNy1e0megn57JHnp1s1cjhkD2bJZm0XEjgzDICoqCm9vb9asWIGXlxduulywPCVtfpfkY9Ag+N//zNtvv21tFhE7MgyDvgMGUC0ggIiICHx8fFTokihU6pI8hIfDiBHm7U2bQH/gxEkZhkHP3r355PPPKf7ii3h7e1sdSZyISl2sFxcHX35p3g4MhPLlrc0jYic2m41ub73FxClT6PXOO0yeMAFXXSZYEpH2qYv1ataE4GDz9vDh1mYRsaOBgwbx5Tff0P/99xk5fDguOghUEplKXawVEWEWevHiZqEXLmx1IhG76fjmm2TKmJHevXqp0MUutN1HrHVrU3vx4uaIXX/oxMnExMQwY9YsDMMgX7589HnvPRW62I1KXaxx6hT4+MCePeb9kSOtzSNiB9HR0TRt2ZL2nTuzZetWq+NICqDN72KNXLlu3z50CDJmtC6LiB1ERkbyRrNmrFm7lgmffkqVW1cZFLEjlbokvc6db9+OiNDpa+J0IiIiaNC4MRuCgpg2eTJdOnWyOpKkECp1SVq//w5ff23ePndOhS5O6bc9e9i2fTvTv/qKN9u2tTqOpCAqdUk6Fy7AlCnm7Y8/hgwZrM0jkshsNhuurq6UL1eOv0JCeOaZZ6yOJCmMDpSTpHHwoHlxli++AA8PaNzY6kQiieratWtUrFaN+QsXAqjQxRIqdbE/wzBPVwMoVgzOnr37QDkRB3flyhWq16rFL7/+SipN+yoW0uZ3sb/PPjP3n+fKBb/+qnPRxalcvHiRGrVrc+jwYZYvWkSd2rWtjiQpmEpd7GvkSPjgA/P28uUqdHEqYWFhVKlZk7+OHWPl0qXUrFHD6kiSwqnUxb5WrDCXEyZAkSKWRhFJbL6+vjRu1IgK5cpRtUoVq+OIqNTFji5dMje3ly4NXbtanUYk0Zw+fZpr169TrGhRhnz4odVxROKp1MU+DAMGDjRvV6xobRaRRHTixAmq1KyJu7s7Ifv34+6uP6OSfOi3URJXeDgsWWLuP//+e/Ox+vUtjSSSWI4ePUrVgADCwsLYsGaNCl2SHf1GSuK5etWcw90wbj+2fz8ULGhdJpFEcvjwYaoGBBAVFUXw+vUUf+klqyOJ3EPnqUviWLPGnCHuVqEfPAjnz6vQxWl8PGYMsbGxbNm4UYUuyZZG6vL0jh+HwEDzduHCsGsXaLOkOJkvp0zh77//Jm/evFZHEXkgjdTl6fXtay7HjjWvj65CFyexa/du/OvU4fr166RKlUqFLsme/vrK07HZzAPjANq10+Qy4jR++vln/AMDyZA+PdeuXSNt2rRWRxJ5JI3U5cldvQrdu5u3mzUD/dETJ7F9xw5q1K5N5kyZ2BoURC5dq0AchEpdntwHH8CXX5q3NQGHOIkft2/HPzCQHM88w9agIHLmzGl1JJEEU6nLkzEM8zKqWbNCSAjky2d1IpFE8dyzz1KpQgW2bNxIjhw5rI4j8lhU6vJkDh0yl2nTQp482pcuDm/P3r3YbDaef/55fli5kmzZslkdSeSxqdTl8V2/fvviLEOHWhpFJDGs+P57ypQvz7jPPrM6ishTUanL44mOhnTpbt/XFLDi4BYvXUrjFi0oWaIEXTp2tDqOyFNRqUvCRUSAn595u1gxCA0FNzdrM4k8he/mz6dZq1a8WqYMG9asId2d/2AVcUAqdUm4vn0hJsa8vXQpeHpam0fkKZw/f57O3btTqWJF1q5cSZo0aayOJPLUNPmMJMwff8CUKebtc+fMed5FHFjWrFkJWruWl158ER8fH6vjiCQKjdQlYW5dRrVbNxW6OLTJU6cyY9YsAMq++qoKXZyKSl0SZsYMczlqlLU5RJ7Cp59/ztu9erH6hx8w7rxEsIiTUKnLo924AX/+ad728rI2i8gTGjlmDH3696dxo0YsmDsXF82tIE5IpS6Pduuc9G7dwFW/MuJ4hg4fzgeDB9OyeXPmzZ6Nh4eH1ZFE7EJ/oeXhBg6Es2fN28OGWZtF5Am5u7vTrk0bZn37Le66NLA4Mf12y8NNn24uf/wRdMqPOBDDMDh9+jQ5c+bkwwEDMAxDm9zF6WmkLvdq1QrKlIFXX4XLl83rpL/yitWpRBLMZrPxTq9eFH/lFU6dOgWgQpcUwS4jdZvNxtChQzl8+DCenp6MGDHirusR79+/n9GjR2MYBpkzZ2bcuHF46QAs69ls5nXRFy8271evDlWqaCpYcSg2m42uPXrw9fTp9O7Zk+eee87qSCJJxi6lHhQURHR0NAsXLmTv3r2MHj2aL774AjA3iQ0aNIiJEyeSK1cuFi9ezNmzZ8mTJ489okhCGQY0bHj7fPQtW6BsWUsjiTyuuLg4PhwyhBWrVjGwXz9GfPSRRuiSotil1Hfv3k2FChUAKF68OAcPHox/7vjx46RLl45Zs2Zx5MgRKlWqpEJPBrxDQm4X+uHD8PzzluYReRKTp05lxapVfDR4MIMGDlShS4pjl1IPCwvD79aFPwA3NzdiY2Nxd3fn6tWr7Nmzh0GDBpErVy66du1K0aJFKfuQUaHNZiMkJMQeUQXwOHOGfG+8AcCpCRMIv3kTtL7tIioqSr/LdlS5YkVGjxhBvcBADh06ZHUcp6Xf4yRgsz3RvCB2KXU/Pz/Cw8Pj79tstvjTSNKlS0euXLnIly8fABUqVODgwYMPLXVXV1cKFy5sj6gpm80Gf/0FNWua97NnJ2fnzjoX3Y5CQkL0u5zIoqKi+HDIEPq//z4ZM2bE09NT69jO9HucBGw2Qo4de+wvs8tf75IlS7Jt2zYA9u7dS4ECBeKfe+655wgPD+fkyZMA7Nq1i/z589sjhjxK69bw78/mUvv2sHevCl0cSmRkJA2bNOGTzz9n46ZNVscRsZxdRuo1atRgx44dNGvWDMMwGDlyJKtWrSIiIoKmTZvy8ccf07t3bwzDoESJElSuXNkeMeRRdu2CfPmge3culSlDJl1LWhxIREQE9d94g6DgYL6cMoVmTZpYHUnEcnYpdVdXV4b9Z/axvHnzxt8uW7YsS5YsscdHS0Lt3g1Hjpjno/fogaH9Y+JAwsLCqNuwIVu3bWP6V1/Rrk0bqyOJJAva1poSLVkCpUqZtzt2tDaLyBMIDQ3l3LlzzJ05U4UucgdNE5vS/PorNG5s3vb3N2ePE3EQN27cwNfXl+zZs7N/9248PT2tjiSSrGikntL8OwkQH31knpeuA+PEQVy5coWq/v50festABW6yH3oL3pKcu4czJgBadNCv36giTnEQVy8eJEqNWty8PffaVCvntVxRJItbX5PSVauNJcVKqjQxWH8888/VAsI4PiJE6xatowa1atbHUkk2VKppyS3ros+caK1OUQSyGazUad+fU6eOsUP339P5UqVrI4kkqyp1FOKBg1gxQrzto+PpVFEEsrV1ZVxo0bh6elJ+XLlrI4jkuxpn3pKEBt7u9AnTwZNMiPJ3PHjx5k1Zw4AVatUUaGLJJBG6inBpUvmcsgQ6NTJ2iwij/Dnn39SNSCAmzdvUrdOHTJkyGB1JBGHoZF6SlC/vrn09bU0hsijhISEUKlGDSIjI9m0bp0KXeQxaaTu7E6cgJ9/howZNXucJGsHf/+dagEBuLi4sGXjRl4oUsTqSCIOR6XuzAwDcuc2b7dpo5G6JGtbt23D3d2d4HXrKFiwoNVxRBySNr87o59/hq++gtdeu/3YyJHW5RF5iKioKAB6dOvG73v2qNBFnoJK3dn8/DO8+ip06QI//WQ+dvq0poOVZGnnTz+R/4UX+HXXLgDS6cwMkaeiv/TO5tVXzeWoUfDXX3DxImTJYm0mkfvY9uOP1KxTBy9PT7JlzWp1HBGnoH3qzmTTptu3e/bU6FySrU3BwdRr1Iiczz3HpnXreOaZZ6yOJOIU9FffmaxZYy63blWhS7K1+7ffCGzQgDy5c7Nl40YVukgi0l9+ZxAcDCVLwuefm/dLlrQ2j8hDvFisGO/06MHmDRvIqs3uIolKm98dXVwcDB8Oe/ZAnTpQsSJ4eFidSuQea9eto2SJEmTNmpUxOhtDxC40UndU0dFw5IhZ4lu2mI8tXmzuS9dlVSWZWbh4MXUbNmTAoEFWRxFxahqpO6oCBeDkydv3t28HNzfr8og8wJzvvqNdx46Ue+01Jnz6qdVxRJyaRuqO6Jtvbhf63Llw+TKULm1tJpH7mD5zJm07dKByxYqsXbmS1KlTWx1JxKlppO5oRo2CgQPN25s33z1rnEgyEhUVxSeff07N6tVZvngxqVKlsjqSiNNTqTuS7dtvF/r06VC2rLV5RB7AMAy8vLzYvGEDadOmxdvb2+pIIimCNr87kuXLzeWYMdCypQ6Ik2Rp3Kef0rx1a2JjY8maNasKXSQJqdQdjZ8fvPuu1SlE7uvj0aPp++/WJMMwLE4jkvKo1B1FTAxMm2aeyiaSzBiGwZBhw/hwyBBat2zJ3Jkz8dB8CSJJ7qH71KMfUiCenp6JHkYewDCgXTuIiIDq1a1OI3KPYR9/zLCPP6Z9u3Z8NXUqbjq9UsQSDy31gIAAXFxc7tmM5uLiwqY7Lx4i9jVyJMybZ96ePVv70iXZqV61KtevX+eTMWNw1XUHRCzz0FIPDg5OqhzyIFu3wocfmrf374eMGa3NI/Ivm83G5i1bqFa1KuVee41yOr1SxHIPLfWmTZvi8oBR4YIFC+wSSP61YwfUrQtXr5r3q1QxZ5ETSQZsNhtdevTgm+nT2b55swpdJJl4aKl/9tlnSZVD7rR/P5Qvb94uWdIcqdeqpc3ukizExcXRoUsXZs2Zwwf9+/Oa5ksQSTYeWuo5cuQA4OTJk6xbt46YmBgALly4wLBhw+yfLqUaN85cdutmXk5VZS7JRGxsLG3at2f+woUMGzKEQbcmQxKRZCFBR7T069cPgN9++40zZ85w7do1e2aSXbvM5aefqtAlWQnatIn5Cxcy+uOPVegiyVCCSt3b25suXbqQNWtWRo8ezaVLl+ydK+Wy2eDQIbPMdRSxJDMB/v789vPP9OvTx+ooInIfCWoNwzC4ePEiERERREREcP36dXvnkt69NUqXZOHmzZs0bt6cH7dvB6BE8eLWBhKRB0pQqb/11lsEBQVRr149qlWrRsWKFe2dSzRftiQDERER1GvYkKXLl/Pn0aNWxxGRR0jQVdpeeukl/Pz8KFy4MIZhUKlSJXvnEhGLhYWFEdigAT9u386Mr7+mbevWVkcSkUdI0Ei9T58+7N27F4Djx4/Tv39/e2ZK2b780lzqYhhiobCwMALq1mX7jh3MnTlThS7iIBJU6ufPn6d58+YAdOrUiQsXLtg1VIplGNC9u3m7alVrs0iKlipVKvLkzs2CuXNp3rSp1XFEJIEStPkdzBF67ty5OXXqFDabzZ6ZUq6DB81l2bK3J58RSUKXL18mMjKSHDlyMHv6dKvjiMhjSlCpDxw4kJ49e3L58mWyZMnCRx99ZO9cKdPixeayRw9rc0iKdOHCBarXqoWrqyu7f/pJV1oTcUAJPlBu7ty5nD17lueeew5fX19750qZRo82l+XKWZtDUpxz585RLSCAEydPsmrZMhW6iINKUKmvX7+eL774gri4uPjLsXa/te9XEkdUFMTEQJYskD271WkkBTlz5gxV/f35+9w51q5cSSWdsirisBJ0oNyMGTNYtGgR6dKlo3v37gQFBdk7V8rTuLG57N5dk85Iknq7Vy/+OX+e9atXq9BFHFyCRuouLi54enri4uKCi4sLqVKlsneulOfPP81l+/bW5pAU58spUzh95gwvlyxpdRQReUoJGqmXLl2a9957j/PnzzN48GBefPFFe+dKOa5ehY8/Nud7r18fsma1OpGkAEeOHKFrjx7ExMSQJUsWFbqIk3joSD02Npbg4GBee+01oqOjKVKkCJkyZWLLli1JFC8FmDPHvF46QOnS1maRFOGPkBCqBQQQFxfH+++9R968ea2OJCKJ5KGl3qdPH9zc3Lh06RI1atQgb968fPjhh7Rp0yap8jm/devM5V9/wb/XrxexlwMHD1ItIAA3Nze2bNyoQhdxMg8t9VOnTrFs2TKio6Np1KgRHh4ezJ49W38IEsulS7B2rXk7SxYdICd2tWfvXmrUro23tzfB69ZRoEABqyOJSCJ7aKn7+fkB4Onpic1mY/r06aRLly4pcqUMP/9sLt99Fzw9rc0iTi82NpYczzzDsoUL9Q9zESeV4GliM2bMqEJPTBcvQmCgefuNN6zNIk7t7Nmz5MiRg9KlSrHnl19wdU3Q8bEi4oAeWupHjx6ld+/eGIYRf/uWTz/91O7hnFpAgLnMlg1eftnaLOK0tv34I3Xq1+ezsWPp1KGDCl3EyT201MePHx9/u1mzZvbOknL89Rf89pt5++hR0JScYgebgoOp27Ahz+fKRWDt2lbHEZEk8NBSf+WVV5IqR8qycaO5HDsWPDyszSJOad369TRo0oT8+fIRtHYtWbJksTqSiCQBbYuzwq1dF7c2wYskorNnz9KgSRMKFyrE5g0bVOgiKUiCD5STRHL4sLnJPXVq0ClFYgc5cuRgzowZVKtShfTp01sdR0SSkEbqSW3RInM5erTOS5dEtXDxYjYFBwPwRsOGKnSRFEilntRuFblm5ZNENHvuXFq0acMnn3+OYRhWxxERi6jURRzctzNm0K5jRypXrMiSBQtw0RYgkRRLpZ7U5s2zOoE4kanTptGxa1f8a9Rg9YoV+Pr6Wh1JRCykUk9K330HISHmbXcdoyhPxzAMdv32G3Xr1GHFkiWkSpXK6kgiYjE1S1L67jtzuWgRaGYveQo3btwgTZo0fP3FF8TFxeGpaweICBqpJy13d3jpJahXz+ok4sCGjxxJ8dKluXDhAm5ubip0EYmnUreCDmSSJ2AYBoOGDmXwRx9Rvlw5MmbMaHUkEUlmtPldxAEYhkG/gQMZ99lndHjzTb6cMgU3XTNARP5DI/WkEhkJq1ZBXJzVScQBTZg0iXGffUa3zp35aupUFbqI3JdG6knl6lVzmS+ftTnEIbVp1Yq4uDje69lT56GLyANppJ4UbDaYOtW8XbWqtVnEYcTFxTFx8mQiIyPJkCEDvXv1UqGLyEOp1JNCcDCMGGHeLlHC2iziEGJjY3mzUyfe7d2bpcuXWx1HRByENr8nhfBwc7lgAZQubW0WSfZiYmJo0749CxYtYvjQobRs3tzqSCLiIFTqSSlnTp3OJg8VHR1N89atWbZiBWNHjuT93r2tjiQiDkSlnhTmzrU6gTiIEydOsGXbNsZ/8gnvvv221XFExMGo1JPCrc3vhQtbm0OSrZiYGNzd3SlQoABHDh7UxDIi8kR0oFxSefll8PGxOoUkQ+Hh4QQEBjJi1CgAFbqIPDGVur2NHg1r14JhWJ1EkqHQ0FBq1avHlm3byP3881bHEREHp83v9hIXB++/D59/bt5v29baPJLsXL9+nVr16vHLr78yb/ZsmjZubHUkEXFwGqnby8mTZqGnTw/TpkHXrlYnkmQkLi6OgLp12bV7N4vmzVOhi0ii0EjdXm5NCzt2LLRpY20WSXbc3Nzo1rkz6dOlo25goNVxRMRJ2KXUbTYbQ4cO5fDhw3h6ejJixAhy5cp1z+sGDRpE2rRp6dOnjz1iWKtUKXOpg57kDpevXCF482aqVqlCm1atrI4jIk7GLpvfg4KCiI6OZuHChfTu3ZvRo0ff85oFCxZw5MgRe3y89Q4dMpdp0kCtWtZmkWTj3LlztO3YkcYtWnDjxg2r44iIE7JLqe/evZsKFSoAULx4cQ4ePHjX83v27GHfvn00bdrUHh9vvRYtzOVnn4GrDlsQOHPmDJWqV+eff/5h+aJFpEmTxupIIuKE7LL5PSwsDD8/v/j7bm5uxMbG4u7uzoULF5g8eTKTJ09m7dq1CXo/m81GSEiIPaImuuc6dcJvzx4AQkqWBAfJHRUV5TDr2NGcPXuWNzt35tr160yZMIHMmTJpXduRfpftT+s4Cdhs4OX12F9ml1L38/Mj/NYsapil7O5uftS6deu4evUqnTt35uLFi0RGRpInTx4aNmz4wPdzdXWlsCPMxrZ2LezYYd5etozCL7xgbZ7HEBIS4hjr2AHNX7SIsPBwgtevx8/XV+vZzvS7bH9ax0nAZiPk2LHH/jK7lHrJkiXZvHkztWvXZu/evRQoUCD+uTZt2tDm36PBly1bxrFjxx5a6A7l0iVzuXUrvPqqtVnEcoZh4OLiwtBBg3izTRty586t0Y2I2JVddvjWqFEDT09PmjVrxqhRoxgwYACrVq1i4cKF9vi45CMuzlxmymRtDrHcHyEhlClfnuPHj+Pq6kru3LmtjiQiKYBdRuqurq4MGzbsrsfy5s17z+ucZoR+y9ix5tLDw9ocYqn9Bw5QvVYt3NzciIyMtDqOiKQgOjQ7sVy4AJ6e4OZmXjddUqTf9uyhSs2aeHp6snXjRu13FJEkpRnlEkvhwnDlinleuouL1WnEAnv37aOqvz/p0qUjeN068uTJY3UkEUlhNFJPDJs2mYVety5MmGB1GrFI7uefJ6BmTbZu3KhCFxFLqNSf1oEDUL26efu99+A+0+GKc9u1ezcRERGkTZuWBXPn3ndKZBGRpKBSfxorVsCLL5q3S5WCMmUsjSNJL2jTJipWq0affv2sjiIiolJ/InFxsHMnNGhg3p80ydwE7+ZmbS5JUj+sXUtggwbky5uXoYMGWR1HRESl/kTmzYPXXjNvp0oFrVqBt7e1mSRJfb9yJfUbN+aFIkXYvGEDWbJksTqSiIhK/Yl8/bW5XLLEnEXOx8faPJKkbt68SY+ePSlRvDib1q0joy6vKyLJhE5pe1xRUfDjj+Ztf39w1ypMaVKlSkXQDz/wzDPP6GprIpKsaKT+uPbuNZcNGpiTzUiKMWvOHD4YPBjDMChUqJAKXUSSHZX647p+3Vy2bWttDklSX3/7LW926sQvv/5KTEyM1XFERO5Lpf44fvzR3OQOoFFaijHliy/o3L07ATVrsmr5cjy1hUZEkimVekJdvQoVK5q3O3SAsmWtzSNJYvzEibzVsyev163L8sWL8dZZDiKSjKnUE+rXX81lrlwwcSK4atWlBNmzZ6dp48Ysnj8fLy8vq+OIiDyUmimhxo0zl7Nm6Yh3J2cYBocOHQKgaePGzJ8zBw9dTldEHIBKPSEaNYKgIPN26dLWZhG7MgyDQUOH8mKpUvy2Zw8ALrrqnog4CA05H+XECVi2zLy9fr1G6U7MMAz6DhjAJ59/Tqf27Sn+0ktWRxIReSwaqT9KcLC5HDECKle2NIrYj2EY9Ozdm08+/5weXbsybcoUXHXchIg4GP3VepTly81lnTrW5hC7WrZiBROnTKHXO+8wafx4FbqIOCRtS36UVKkge3YoXNjqJGJHDevX5/slS6gbGKh96CLisDQcSYi0aa1OIHYQGxtLz969OXLkCC4uLtSrW1eFLiIOTSP1h7HZ4I8/wDCsTiKJLCYmhlbt2rFoyRLy5slDgQIFrI4kIvLUNFJ/mK++gt9/17XSnUx0dDRNW7Zk0ZIlfDJ6NG/36GF1JBGRRKGR+sP8e54y33wD2izrFCIjI3mjWTPWrF3LxM8+U6GLiFNRqT/M/PnmslAha3NIoomLi+NGaCjTJk+mS6dOVscREUlUKvWHSZcOSpTQddOdQHh4ODabjdSpU7N5wwbc3NysjiQikui0T/1BbtyA06chZ06rk8hTCg0NpVa9erz+xhsYhqFCFxGnpZH6g/z0k7lMndraHPJUrl27Rq169fh11y6+mzVLp6yJiFNTqT/IrVJv0sTaHPLErly5gn9gIPv272fx/Pk0eP11qyOJiNiVSv1+FiyAIUPM25p4xmG1fvNN9h84wLKFCwnUNL8ikgKo1O/nzz/N5Q8/QJEi1maRJ/bpmDGcPnOGGtWrWx1FRCRJ6EC5h6lYUeenO5i///6bMZ98gmEYFCpUSIUuIimKRur3ExlpdQJ5AqdPn6aqvz//nD/PGw0akDdvXqsjiYgkKY3U/2v+fBg50rytUbrDOH78OBWrVePCxYtsWLNGhS4iKZJG6v81b5657NULdD6zQzh69ChVAwIICwtj07p1lHr5ZasjiYhYQqV+P8WLw+jRVqeQBDp85AixsbEEr19P8ZdesjqOiIhlVOrisMLDw/H19aVO7doc/eMPfHx8rI4kImIp7VMXh7Rv/37yFSnCiu+/B1Chi4igUhcHtGv3bqrUrIm7uzsvaB4BEZF4KvU7GQasXm0uJVn66eefqRYQQNo0adgWFET+/PmtjiQikmyo1O/0999WJ5CHOHHiBDVq1yZzpkxsDQoid+7cVkcSEUlWVOr306mT1QnkPnLlysWQDz5ga1AQOXVJXBGRe+jo9zvNnWt1ArmPoE2byJ49Oy8UKUKf996zOo6ISLKlkfqdbp2bXriwtTkk3poffqBO/fr07tvX6igiIsmeSv1Onp7QsSOUL291EgFWfP89DZo0oVjRosybPdvqOCIiyZ5K/U5Xr1qdQP61eOlSGrdoQckSJQhau5YMGTJYHUlEJNlTqQNcuACurhATA9HRVqdJ8QzD4Jvp03m1TBk2rFlDunTprI4kIuIQdKAcwCef3D43XftuLRUbG4u7uzvLFi3CMAz8/PysjiQi4jA0UgeIizOXN2+CJjOxzFfffEPFatUIDQ3F19dXhS4i8phU6gCffWYudf10y0yeOpUuPXqQIX16PDw8rI4jIuKQVOoAfn5QrJjVKVKsz8aP5+1evahfrx7LFi3C29vb6kgiIg5JpQ7g4WGexqaRepKbOm0avfv1o3GjRiyaNw9PT0+rI4mIOCyV+h9/6FQ2C/nXqEHPt99m3uzZ2uwuIvKUUnaph4fDCy+Yt/PlszZLCmIYBiu+/x6bzUbevHn5/JNPcHfXiRgiIk8rZZf6uXPm8uWXoUcPa7OkEIZh0KdfPxo0acLipUutjiMi4lQ0PALo3l3705OAzWbj3ffeY/IXX/B29+40eeMNqyOJiDiVlD1SlyRjs9no9tZbTP7iC3r37MmEzz7DRf+QEhFJVCp1SRIHDh5k5pw5DOzXj3GjR6vQRUTsIGVvfm/c2FyqYOzGMAxcXFx46cUX2b9rFwUKFFChi4jYScoeqf/xh7msWtXaHE4qJiaG5q1bM3fePAAKFiyoQhcRsaOUW+rduplXZOvVC7JntzqN04mKiqJx8+YsXLyYCxcuWB1HRCRFSJmb3w0Dpk0zb3fsaG0WJxQZGUmjpk35Yd06Jn3+OW917251JBGRFCFllvrRo+by5Zc16Uwii4mJoV7DhgQFB/PllCl01j+aRESSTMos9dhYc/nOO9bmcEIeHh68VrYsLZo1o12bNlbHERFJUVJmqd+ig7YSzY0bNzh95gwvFCnC0EGDrI4jIpIipcwD5Y4csTqBU7l27Ro169Sheq1ahIeHWx1HRCTFSpkj9UaNzKWfn7U5nMDly5epWacOBw4eZPG8efj6+lodSUQkxUp5pX74MMTFQbVqUKuW1Wkc2oULF6hRuzaHjxxhxeLF1Nb6FBGxVMor9VvFU60auKbMvQ+JZcSoUfx59Cirli2jRvXqVscREUnxUlarnTwJx49DtmzmpDPyVMaOGsW2TZtU6CIiyUTKKfXoaPD3N28PGqRR+hM6deoUjZs35+rVq3h7e1Pq5ZetjiQiIv9KOZvfu3c396cDNGtmbRYHdfz4car4+3Pt2jVOnDxJ+vTprY4kIiJ3SDnD1V27zOXhwzrq/Qn8+eefVKxendDQUDatW0eJ4sWtjiQiIv/h/KX+zz/w9tuwbx9UqQLPP291Iodz6NAhKtWoQWRkJMHr1/NyyZJWRxIRkftw/lJv3BgmTzZvv/mmtVkclI+PD8/nysWWjRt56cUXrY4jIiIP4Nz71ENDYft2ePVVmD0bcuWyOpFDOXbsGLly5SJnzpzs2LJF10IXEUnmnHuk3r+/uSxUSIX+mHbt3k2p117jwyFDAFToIiIOwLlL/eZNczlunLU5HMzOn36iWkAAadOkoYsunSoi4jCcu9QBnn0WUqe2OoXD+HH7dmrWqUOWzJnZtmkTz+vAQhERh2GXfeo2m42hQ4dy+PBhPD09GTFiBLnu2Py9evVqZs2ahZubGwUKFGDo0KG42mMymO+/B2/vxH9fJxUWFkbDpk15NkcONq1bxzPPPGN1JBEReQx2GakHBQURHR3NwoUL6d27N6NHj45/LjIykvHjxzN79mwWLFhAWFgYmzdvTvwQMTFw5Qpcv5747+2k/Pz8WDJ/Pls2blShi4g4ILuU+u7du6lQoQIAxYsX5+DBg/HPeXp6smDBAlKlSgVAbGwsXl5eiR9i/Xpz2bs36CCvh1q9Zg1Lly8HoFLFimTNmtXiRCIi8iTssvk9LCwMvztmbXNzcyM2NhZ3d3dcXV3JlCkTAHPmzCEiIoJy5co99P1sNhshISGPlSH9Tz+RDThWqBBRj/m1KUlQcDDv9e1LoYIFeb1uXdzdnfssR6tFRUU99u+yPB6tY/vTOk4CNhs8wYDXLn/B/fz8CA8Pj79vs9nuKgubzca4ceM4fvw4kyZNeuTpUq6urhQuXPjxQoSGApCnQgXIkuXxvjaFWLh4Mb3ef59XSpdm/LhxFCtWzOpITi8kJOTxf5flsWgd25/WcRKw2Qg5duyxv8wum99LlizJtm3bANi7dy8FChS46/nBgwcTFRXF1KlT4zfDJ7p/Nydjr/d3cHPnzaNFmza8VrYs61evJrXOEBARcXh2GanXqFGDHTt20KxZMwzDYOTIkaxatYqIiAiKFi3KkiVLKFWqFG3btgWgTZs21KhRI3FDeHvDa6/pdLYHOHP2LJUrVmTlsmX4+vpaHUdERBKBXUrd1dWVYcOG3fVY3rx5428fOnTIHh9727Fj8OefkC+ffT/HAV26dIlMmTLR//336dOrl/ahi4g4EeecfObcOXNZpYq1OZKZiZMnk/+FF+L/UaVCFxFxLs5Z6rfoQI544z79lHd796Zq5crkyZPH6jgiImIHzlnq06ebS3vMUueAPh49mr4DB9K0cWMWzJ2Lp6en1ZFERMQOnLP1YmLMZdmy1uZIBhYsWsSHQ4bQumVL5s6ciYeHh9WRRETETpyz1AGefx58fKxOYbmG9esz6fPPmfH119qHLiLi5Jy31FMwwzD45LPPuHTpEp6enrzVvTtubm5WxxIRETtTqTsZm83G2z178v6AAcyaM8fqOCIikoS0PdaJ2Gw2uvTowTfTp/P+e+/xXs+eVkcSEZEkpJG6k4iLi6N95858M306Hw4YwJiRIx85p76IiDgX5yv1/fthzhzzCjcpyNWrV/nfzp0MGzKE4UOHqtBFRFIg59v8vnixuaxbN0VcRz0mJgYXFxcyZcrE7p9+0oVZRERSMOcbqU+ZYi7/M/e8M4qKiuKNZs14s1MnDMNQoYuIpHDOV+qZMkGRIuDkVx67efMmDRo3ZuXq1ZQtU0ab20VExAlL/coVs9SduOQiIiKo17Ah6zZs4OsvvqB7165WRxIRkWTAufapHzgAly/DzZtWJ7Grpi1bErxlCzO/+YY2rVpZHUdERJIJ5yr1y5fNZaNG1uawsz69etGyeXOaNWlidRQREUlGnKfU4+Jul/kzz1ibxQ6uXr3KhqAgmjZuTKWKFa2OIyIiyZDz7FMPDzf3p7u7Q8mSVqdJVJcvX6ZaQABtO3Tg1KlTVscREZFkynlG6reMGAFp01qdItFcuHCB6rVqceTPP1m+aBE5c+a0OpKIiCRTzlPqV65YnSDRnTt3jmoBAZw4eZLVy5dTvVo1qyOJiEgy5jylfmsmucyZrc2RiNZv3Mip06dZu3Kl9qOLiMgjOU+pL1pkLl9/3docicBms+Hq6kq7Nm3wr1GD7NmzWx1JREQcgHMcKLd3L+zaZd729rY0ytM6duwYL5Uqxc6ffgJQoYuISII5x0j90iVzOXMmeHhYGuVp/Pnnn1Tx9+fmzZt4eXlZHUdERByMc5T6H3+Yy2eftTbHUwgJCaFqQABxcXFs3rCBF4sVszqSiIg4GOco9U8+MZfZslmb4wkdP36cSjVq4ObmxpaNGylSuLDVkURExAE5/j710FA4fRrSp4d8+axO80SeffZZGjdsyFYVuoiIPAXHH6lHR5vLt992uCuz7f7tN57Jnp3s2bMzZeJEq+OIiIiDc+yRumGYB8eBw80i97+dO6lSsyadu3e3OoqIiDgJxx6pd+kCX39t3n7pJWuzPIat27ZRp359nsmenS8mTbI6joiIOAnHLvULF8zlL7/Aiy9amyWBNgUHU7dhQ57PlYtN69bpPHQREUk0jr35HaBYMXOU7gD70202G/0++IB8efOyZeNGFbqIiCQqxx6pOxhXV1dWL1+Ou7s7mTJlsjqOiIg4GccfqTuApcuX06JNG2JjY8mWLZsKXURE7EKlbmcLFi2iacuWnDh5kps3b1odR0REnJhK3Y5mz51Ly7ZtKffaa6xfvZrUqVNbHUlERJyYSt1OZs2ZQ7uOHalcsSI/fP+9Cl1EROxOpW4nBQsU4I2GDVm9YgW+vr5WxxERkRTAsUt9926rE9zjtz17AHi1TBkWzZtHqlSpLE4kIiIpheOW+tWrcObM7WupJwNjP/mEl199ldVr1lgdRUREUiDHLfWoKHP51lvW5vjX8JEj6ffBBzRr0oQAf3+r44iISArk+JPP+PlZ+vGGYTD4o48YMWoUrVu2ZMbXX+Pm5mZpJhERSZkcd6SeTPzy66+MGDWKDm++qUIXERFLOe5I/aefrE4AQJlXXmHzhg1UrFABV1f9G0lERKzjuC20b5+5LFs2yT/aZrPx3vvvs3XbNgAqV6qkQhcREcs55kj92DEYOtS8XbRokn50XFwcXXr04NsZM/Dz86NSxYpJ+vkiIiIP4pilfvCguaxTB5JwhBwbG0v7zp2Z8913DBo4kI8GD06yzxYREXkUxyz1WwYOTLLrqMfExND6zTdZuHgxw4cO5cMBA5Lkc0VERBLKMUt90aIk/0hXV1c8PDwYO3Ik7/funeSfLyIi8iiOWepXr5rLggXt/lFRUVFcuXKF7NmzM3v6dFySaMuAiIjI43LcQ7ZLlgQ7X/ns5s2bvN6oEZVr1CAyMlKFLiIiyZpjjtSTQHh4OPUaNmTz1q18/cUXeHt7Wx1JRETkoVTq9xEaGkqd+vXZ8b//Mevbb2ndsqXVkURERB7J8Ta///MP/PADGIbdPuK9vn35386dzJs9W4UuIiIOw/FG6l9+aS5z5bLbR4waPpxG9evramsiIuJQHG+kHhNjLufOTdS3vXTpEn369SM6OppMmTKp0EVExOE4Xqn/8ou5dE+8jQznz5+nSs2aTJk2jX379yfa+4qIiCQlx9r8HhgIGzcm6lueO3eOqv7+nDx1itXLl1O6VKlEfX8REZGk4jilfuECrFlj3v7f/xJletgzZ85Q1d+fc//8w7pVq6hYocJTv6eIiIhVHKfUg4LM5YgR8PLLifKWFy5eJCo6mg1r1lD21VcT5T1FRESs4jilfuv66bVqPfVbXb16lfTp01OyRAn+/P13PD09n/o9RUScQUxsLGfOnSMyKurBrwFCjh5NulBOztvLi2ezZ8cjEY4Vc5xSd3EBLy944YWnepvDhw9TNSCA93v1ouc776jQRUTucObcOVKnScPzGTI8cGrsm5GRpNIsm4nCMAwuX7nCmXPnyP3cc0/9fo539PtT+CMkhEo1ahAbG0v1atWsjiMikuxERkWR8SGFLonLxcWFjBkyPHTLyONIMaW+/8ABKteogaurK1s2bKDoU474RUSclQo9aSXm+nacze9P4fr161QLCMDb25vgdevInz+/1ZFEROQRvvr6a2bPns2moCC8vLzoP2AAtWvXvutMpXIVKrDjxx8BCAoKYtacOWAYREZF0aF9+yeaSGzRokUsWLQIdzc3unXtSpUqVe56vtd773Hp0iUAzp49y0svvUTnTp0YOWpU/Gv27tvHlMmTKVG8OL169+ZmRAQeHh6MGzuWzJkzP8nqSJAUUepp06Zlwqef8uorr5AnTx6r44iISAKsWr2a2rVrs+aHH2jYoMFDX/vbnj3MnDWLL6dNw9fXl6tXr9K0WTPy5c1Lvnz5EvyZFy9eZM7cuSxdsoSoqChatGxJuXLl7jr+6vPPPgPMAWObdu0Y0L8/WbJkYc7s2QCsXbeOLFmyULFCBWbNnk2B/Pnp+/77LFq0iG+nT6d/v35PsDYSxqlLfcf//kd4eDg1a9SgRbNmVscREXEss2fDzJn3POxps4HrE+69bdcO2rR55Mt+/uUXcj73HM2aNeP9vn0fWeqLFy+mbZs2+Pr6ApA+fXoWL1pEmjRp7nrdBx9+yKlTp+Lvp02blsmTJsXf33/gACVKlsTT0xNPT09y5szJocOHebFYsXs+c9LkybRq2ZIsWbLEPxYREcGkyZOZO2cOAAUKFODYsWMAhIWH456Is6Hej9OW+patWwls0ID8+fJRvVo1XJ/0F1BERJLc4iVLaPzGG+TJnRtPT0/23Tqt+T9u7Y2+cOECz/3n6PG0adPe8/qPR4x46OeGhYWR2s8v/r6vry9hoaH3vO7y5cvs3LmTAf373/X4kqVLCfD3J0P69ACkT5eOHf/7H7UDA7l+/Trf/Vv29uKUpR60aRP1GjUi9/PPs3blShW6iMiTaNPmvqPqaDuf0nb9+nW2bdvGlcuXmfPdd4SFhjL3u+/w8fEhOjr6rtfGxsUB8Mwzz3Du3DkKFSoU/9zu334jU8aM5Lrjqp6PGqn7+fkRHh4efz88PJzU/xntA6xbv57AwEDc3NzuenzV6tVMHD8+/v7kKVPo2KEDzZo25dDhw7z97rus+v77x1wjCec4pT55MiTgkP+169bRoEkTCuTPT9DatXdtFhERkeRv5apVNGrUiH7vvw/AzZs3qVajBu3ffJONGzfGn5K8a9cu8uXNC0DDBg349LPPKFOmDD4+Ply+fJmBAwcyYcKEu977USP1F4sVY/z48URFRREdHc1fx45R4D4HV+/cuZNuXbve9VhoaCjR0dFkz549/rE0adLEj/wzZshAeFjYY66Nx+MQpe5x+jSEh5uTzzzCqjVreKFIETasWUPGjBmTIJ2IiCSmxUuWMHbMmPj7qVKlomaNGkRGRuLj48PrDRrg6+uLh4cHw4YNA6BEiRI0adKE9h064O7uTmRUFO+99x6FChZ8rM/OnDkzrVu1okWrVhg2G7169sTLy4ujR48y97vvGDpkCADHjx+/Z3P/8RMnyJEjx12Pvfvuu3z44YfMmz+f2NhYhv+b115cDMMw7PoJiSBkzhwKt2kDP/8MxYvf9zVRUVF4eXlhs9nMzSWpUydtSAcXEhJC4cKFrY7h9LSe7U/r+OmEHD1K4Ts2Yd+PZpRLfCGHDlH4zqP0bTZCjh2jcJEij/U+jrOzedy4Bxb6vAULKFqiBGfOnMHV1VWFLiIiKZLjlPoDNqXPmjOHVu3akSNHDtKlS5e0mURERJIRxyn1+/j62295s1MnqlWpwg/ff4/fHachiIiIpDQOW+qLliyhc/fuBNSsyarly/Hx8bE6koiIU3CAQ62cSmKub4ct9RrVqtG3d2+WL16Mtw7YEBFJFN5eXly+ckXFnkRuXXrVOwFndyWEQ5zSdqcFixZRv1490qdPz5iRI62OIyLiVJ7Nnp0z585x8eLFB74mJiYGDw+PJEzl3Ly9vHj2jnPbn4bjlHqZMgz7+GOGDBvGJ6NH07tXL6sTiYg4HQ93d3L/5/zr/woJCbn79CtJNuyy+d1mszF48GCaNm1K69atOXny5F3PBwcH06hRI5o2bcqiRYse+X6Gqysfzp7NkGHDaNu6NT3feccesUVERByaXUo9KCiI6OhoFi5cSO/evRk9enT8czExMYwaNYrp06czZ84cFi5c+NDNPABnDIOPx4yhU/v2TP/qq3vm2hURERE7bX7fvXs3Ff69iH3x4sU5ePBg/HN//fUXOXPmjL96zssvv8yuXbuoVavWA9/vsmHQo0sXJn7+Oa4uLqADOBKfYWi9JgWtZ/vTOrY/rWP7e8L1a5dSDwsLu+uccTc3N2JjY3F3dzcva3fHjG++vr6EPWKC+8LFilG8ZEkO/3tNWrEDDw9Cjh61OoXz03q2P61j+9M6ThJRMTGP/TV2KfX/XrrOZrPFXxj+vpe1e8S0rsUfMD2siIiI3GaXfeolS5Zk27ZtAOzdu5cCBQrEP5c3b15OnjzJtWvXiI6OZteuXZQoUcIeMURERFIUu1ylzWazMXToUI4cOYJhGIwcOZI//viDiIgImjZtSnBwMFOmTMEwDBo1akTLli0TO4KIiEiK4xCXXhUREZFHc9hpYkVERORuKnUREREnkaxKPbFnopN7PWodr169msaNG9OsWTMGDx6MzWazKKnjetQ6vmXQoEF88sknSZzOOTxqHe/fv58WLVrQvHlz3nnnHaKioixK6tgetZ5XrlxJgwYNaNSoEfPmzbMopXPYt28frVu3vufxx+49IxlZv3690a9fP8MwDGPPnj1G165d45+Ljo42qlevbly7ds2IiooyGjZsaFy4cMGqqA7rYev45s2bRrVq1YyIiAjDMAyjV69eRlBQkCU5HdnD1vEt8+fPN5o0aWKMGzcuqeM5hYetY5vNZtSrV884ceKEYRiGsWjRIuOvv/6yJKeje9Tvcrly5YyrV68aUVFR8X+f5fF99dVXRmBgoNG4ceO7Hn+S3ktWI/WEzkTn6ekZPxOdPJ6HrWNPT08WLFhAqlSpAIiNjcUrkS4HmJI8bB0D7Nmzh3379tG0aVMr4jmFh63j48ePky5dOmbNmkWrVq24du0aefLksSqqQ3vU73LBggUJDQ0lOjoawzBwcXGxIqbDy5kzJ5MmTbrn8SfpvWRV6g+aie7Wc487E53c62Hr2NXVlUyZMgEwZ84cIiIiKFeunCU5HdnD1vGFCxeYPHkygwcPtiqeU3jYOr569Sp79uyhRYsWzJgxg59++omdO3daFdWhPWw9A+TPn59GjRpRp04dKleuTJo0aayI6fD8/f3jJ2i705P0XrIq9cSeiU7u9bB1fOv+mDFj2LFjB5MmTdK/vJ/Aw9bxunXruHr1Kp07d+arr75i9erVLFu2zKqoDuth6zhdunTkypWLfPny4eHhQYUKFe4ZYUrCPGw9Hzp0iC1btrBp0yaCg4O5cuUKa9eutSqqU3qS3ktWpa6Z6OzvYesYYPDgwURFRTF16tT4zfDyeB62jtu0acOyZcuYM2cOnTt3JjAwkIYNG1oV1WE9bB0/99xzhIeHxx/UtWvXLvLnz29JTkf3sPWcOnVqvL298fLyws3NjQwZMnDjxg2rojqlJ+k9u8z9/qRq1KjBjh07aNasWfxMdKtWrYqfia5///506NAhfia6rFmzWh3Z4TxsHRctWpQlS5ZQqlQp2rZtC5glVKNGDYtTO5ZH/R7L03vUOv7444/p3bs3hmFQokQJKleubHVkh/So9dy0aVNatGiBh4cHOXPmpEGDBlZHdgpP03uaUU5ERMRJJKvN7yIiIvLkVOoiIiJOQqUuIiLiJFTqIiIiTkKlLiIi4iRU6iKJ7MyZM5QsWZLWrVvH/zd58uQHvr5///5s27aNZcuWPfUFXq5du8aqVavu+9y0adPumoRl48aN9O7d+7Hef//+/bRv354333yTtm3bMn369KfKe8u2bdtYuHAhAJ9//jkNGzZk5syZD11vb731FgCHDx/m119/feDrJkyYwNGjRxMlp0hyl6zOUxdxFvny5WPOnDlJ/rmHDx8mODiYunXr3vX4uXPnOHLkCF27dgVgxIgRbN++ncKFCz/W+w8bNowxY8aQN29eYmJiaNasGa+++ipFihR5qtwVK1aMv/3DDz+wfPnyu6YnvZ9bhb9hwwYyZcpE6dKl7/u6N998kz59+vDVV189VUYRR6CRukgSiYuL44MPPqBDhw40bNiQ8ePHJ+jr/vjjD5o3b06rVq3o0KEDf//9N2fOnKFJkybxr2nSpAlnzpxh2rRp/PTTT/Gj3lvmz5+Pv79//P2SJUsydOjQx/4ennnmGb777jsOHjyIq6sr8+fPp0iRIixbtowePXrQtm1b6tWrx/r16wH45Zdf4rMPGDCAmJgYIiMj6dWrF02bNqVhw4bs2bMnfivF5MmT+eeff+jSpQtbt26lV69eACxevJiGDRtSv379+AtflCtXjvPnz7N8+XJmzpzJ/v37eeONN+Kz9uzZk/3795MmTRq8vLw4dOjQY3+/Io5GpS5iB0ePHr1r8/v58+c5d+4cxYsX59tvv2X+/PnMnz8/Qe/14YcfMnjwYObOnUvz5s0ZPXr0A1/btWtXXn311Xtmrvvll18oWLBg/P3atWs/0bz+I0eOJGPGjAwdOpTXXnuNMWPGEB0dDUBERAQzZsxg+vTpjB49mpiYGAYNGsTkyZOZO3cuWbNmZfny5SxYsIAcOXKwcOFCRo8ezb59++Lf/6233iJz5sxMnz4db29vAC5fvszXX3/NvHnzWLZsGaGhofHzYWfNmpUGDRrQrl07XnzxRby9vTl69CjXrl3jzJkzvPjii4B5NbFffvnlsb9fEUejze8idnC/ze9hYWEcOHCAn376CT8/v/gy/K9169bx3XffAdCvXz8uXLgQv5m8dOnSfPrpp/d8zaMmhrx69Wr8Ffge5b+fX7RoUQCioqL4/fff6dGjBz169ODq1asMHDiQhQsX4uvrS+nSpeOv9JcmTRouXLjAhQsX6NmzJwCRkZGUK1eOK1euxG9uL1CgAAUKFHjoRW1Onz5N/vz540t+4MCBD3xt48aNWbZsGc888wz16tWLfzxz5sycP38+Qd+/iCNTqYskkWXLlpE6dWqGDRvGyZMnWbRo0X3LOCAggICAgPj7WbJk4dChQxQqVIhff/2V559/Hi8vLy5fvkxcXBzh4eGcOXMGMC+fa7PZ7nnPWxfbeNR+6vt9/i0uLi68//77fPPNNxQoUID06dOTI0cOPD09Afj9998BuHTpEmFhYWTLlo1s2bIxdepUUqdOzaZNm/Dx8eHIkSMcOHCA6tWrc/r0acaPH//QS/zmzJmTY8eOER0djaenJ++88w4ffPDBXblufc8BAQFMnz6ddOnSMWHChPjXXL9+nYwZMz7yexdxdCp1kSRStmxZ3nvvPXbv3k2qVKnIlSsXFy5ceOTXjRgxguHDh2MYBm5ubowcOZLMmTNTrlw53njjDXLmzEmuXLkAswCPHDnCzJkzadeuXfx7vPLKK+zbt49nnnnmifN7enoyfvx4Bg8eTFxcHC4uLhQrVoxGjRqxcuVKLl26RNu2bQkNDWXIkCG4ubnxwQcf0LlzZwzDwNfXl7Fjx1KyZEkGDhxIq1atiIuLY+DAgfz5558P/NwMGTLQqVMnWrVqhYuLC1WqVLnrohZFixZl7Nix5M2bl1dffZXSpUtz5coV0qVLF/+a/fv3x++fF3FmuqCLSApw9uxZxowZw8SJE+3y/suWLePYsWP06dPHLu//OIYOHYq/vz9ly5YFzNP8+vfvz7Rp0yxOJmJ/OlBOJAXIkSMHBQsW5MCBA1ZHsav27dsTGRkZX+gAM2fO1ChdUgyN1EVERJyERuoiIiJOQqUuIiLiJFTqIiIiTkKlLiIi4iRU6iIiIk5CpS4iIuIk/g/ibF48m5AkfAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# Model specification\n",
    "#\n",
    "\n",
    "# Inputs\n",
    "input_logs = Input(shape=(events_per_user, n_features))\n",
    "input_user = Input(shape=(x.shape[1],))\n",
    "\n",
    "# LSTM tower\n",
    "lstm_out = LSTM(8, input_shape=(events_per_user, n_features))(input_logs)\n",
    "lstm_tower = Model(inputs=input_logs, outputs=lstm_out)\n",
    "\n",
    "# User profile tower\n",
    "profile_out = Dense(16, activation='relu')(input_user)\n",
    "profile_tower = Model(inputs=input_user, outputs=profile_out)\n",
    "\n",
    "# Model head\n",
    "combined = Concatenate()([lstm_tower.output, profile_tower.output])\n",
    "dense_top_1 = Dense(32, activation='relu')(combined)\n",
    "dense_top_2 = Dense(16, activation='relu')(dense_top_1)\n",
    "dense_top_3 = Dense(8, activation='relu')(dense_top_2)\n",
    "prob_outcome = Dense(1, activation='sigmoid')(dense_top_3)\n",
    "model_lstm = Model(inputs=[lstm_tower.input, profile_tower.input], outputs=prob_outcome)\n",
    "\n",
    "#\n",
    "# Model training\n",
    "#\n",
    "model_lstm.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) \n",
    "history = model_lstm.fit([x3d_train, x_train], y_train, batch_size=16, epochs=10, verbose=1, validation_data=([x3d_train, x_train], y_train)) \n",
    "score = model_lstm.evaluate([x3d_test, x_test], y_test, verbose=0) \n",
    "print('Test score:', score[0]) \n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "#\n",
    "# Model evaluation\n",
    "#\n",
    "predictions_lstm_prob = model_lstm.predict([x3d_test, x_test])\n",
    "plot_roc(y_test, predictions_lstm_prob)\n",
    "plot_confusion_matrix(y_test, predictions_lstm_prob, ['Negative', 'Positive'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make the following conclusions :\n",
    "* LSTM easily outperforms the look-alike baseline. It is possible to improve the LightGBM baseline using more sophisticated feature engineering and tuning, but at the cost of extra effort.\n",
    "* Feature engineering is somewhat simpler becasue we use event-level attributes, not profile-level aggregates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step 4: LSTM with Attention\n",
    "\n",
    "Finally, we build and evaluate the LSTM with attention design."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "#\n",
    "# Train-test sets x3d_train, x3d_test, x_train, x_test, y_train, y_test are the same as for LSTM\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "421/421 [==============================] - 12s 24ms/step - loss: 0.6484 - accuracy: 0.6341 - val_loss: 0.6219 - val_accuracy: 0.6663\n",
      "Epoch 2/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.6182 - accuracy: 0.6699 - val_loss: 0.6113 - val_accuracy: 0.6718\n",
      "Epoch 3/10\n",
      "421/421 [==============================] - 11s 25ms/step - loss: 0.6126 - accuracy: 0.6743 - val_loss: 0.6134 - val_accuracy: 0.6732\n",
      "Epoch 4/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.6114 - accuracy: 0.6734 - val_loss: 0.6139 - val_accuracy: 0.6761\n",
      "Epoch 5/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.6098 - accuracy: 0.6720 - val_loss: 0.6053 - val_accuracy: 0.6754\n",
      "Epoch 6/10\n",
      "421/421 [==============================] - 10s 24ms/step - loss: 0.6074 - accuracy: 0.6775 - val_loss: 0.6069 - val_accuracy: 0.6781\n",
      "Epoch 7/10\n",
      "421/421 [==============================] - 9s 22ms/step - loss: 0.6063 - accuracy: 0.6782 - val_loss: 0.6016 - val_accuracy: 0.6830\n",
      "Epoch 8/10\n",
      "421/421 [==============================] - 11s 25ms/step - loss: 0.6043 - accuracy: 0.6831 - val_loss: 0.6004 - val_accuracy: 0.6841\n",
      "Epoch 9/10\n",
      "421/421 [==============================] - 11s 27ms/step - loss: 0.6035 - accuracy: 0.6804 - val_loss: 0.5996 - val_accuracy: 0.6852\n",
      "Epoch 10/10\n",
      "421/421 [==============================] - 10s 25ms/step - loss: 0.6025 - accuracy: 0.6856 - val_loss: 0.6000 - val_accuracy: 0.6867\n",
      "Test score: 0.6199774742126465\n",
      "Test accuracy: 0.6708240509033203\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#\n",
    "# Model parameters\n",
    "#\n",
    "hidden_units = 8\n",
    "\n",
    "#\n",
    "# Model specification\n",
    "#\n",
    "input_logs = Input(shape=(events_per_user, n_features))\n",
    "input_user = Input(shape=(x.shape[1],))\n",
    "\n",
    "# LSTM tower\n",
    "activations = LSTM(hidden_units, return_sequences=True)(input_logs)\n",
    "\n",
    "attention = Dense(1, activation='tanh')(activations)\n",
    "attention = Flatten()(attention)\n",
    "attention = Activation('softmax', name = 'attention_weigths')(attention)\n",
    "attention = RepeatVector(hidden_units * 1)(attention)\n",
    "attention = Permute([2, 1])(attention)\n",
    "\n",
    "weighted_activations = Multiply()([activations, attention])\n",
    "weighted_activations = Lambda(lambda xin: K.sum(xin, axis=-2), output_shape=(hidden_units,))(weighted_activations)\n",
    "\n",
    "lstm_tower = Model(inputs=input_logs, outputs=weighted_activations)\n",
    "\n",
    "# User profile tower\n",
    "profile_out = Dense(16, activation='relu')(input_user)\n",
    "profile_tower = Model(inputs=input_user, outputs=profile_out)\n",
    "\n",
    "# Model head\n",
    "combined = Concatenate()([lstm_tower.output, profile_tower.output])\n",
    "dense_top = Dense(32, activation='relu')(combined)\n",
    "prob_outcome = Dense(1, activation='sigmoid')(dense_top)\n",
    "model_lstm_attn = Model(inputs=[lstm_tower.input, profile_tower.input], outputs=prob_outcome)\n",
    "\n",
    "#\n",
    "# Model training\n",
    "#\n",
    "model_lstm_attn.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) \n",
    "history = model_lstm_attn.fit([x3d_train, x_train], y_train, batch_size=16, epochs=10, verbose=1, validation_data=([x3d_train, x_train], y_train)) \n",
    "score = model_lstm_attn.evaluate([x3d_test, x_test], y_test, verbose=0) \n",
    "print('Test score:', score[0]) \n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "#\n",
    "# Model evaluation\n",
    "#\n",
    "predictions_lstm_a_prob = model_lstm_attn.predict([x3d_test, x_test])\n",
    "plot_roc(y_test, predictions_lstm_a_prob)\n",
    "plot_confusion_matrix(y_test, predictions_lstm_a_prob, ['Negative', 'Positive'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention weights matrix: 2245 users x 113 weights\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "# Attention weights analysis\n",
    "#\n",
    "attention_model = Model(inputs=model_lstm_attn.input, outputs=model_lstm_attn.get_layer('attention_weigths').output)\n",
    "a = attention_model.predict([x3d_test, x_test])\n",
    "print(f'Attention weights matrix: {a.shape[0]} users x {a.shape[1]} weights')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "uid = 30\n",
    "fig, ax = plt.subplots(1, figsize=(15, 5))\n",
    "ax.plot(20 * a[uid, :], label='Attention weights', linewidth=5, alpha=0.5)\n",
    "for i, column in zip(range(n_features), ['Views', 'Items', 'Duration', 'Previews']):\n",
    "    ax.plot(x3d_test[uid][:, i], label=column)\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above plot illustrates how the model puts the emphasis on the beginning of the customer journey. We can use attention weights in several ways:\n",
    "* We can analyze the behavior drivers inspecting which event have high contribution.\n",
    "* We can cluster customers in the space of weight vectors to find typical patterns that result in a specific outcome."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py310",
   "language": "python",
   "name": "py310"
  },
  "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}