linear_regression_and_FFNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h7f83S3UV2DH"
   },
   "source": [
    "## Import Packages and Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "xqhLIiDoVxHO"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-10 22:11:57.184438: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: SSE4.1 SSE4.2, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# Standard\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import os\n",
    "import math\n",
    "\n",
    "# TF and Keras\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img\n",
    "from keras import models\n",
    "from keras import layers\n",
    "from keras import metrics\n",
    "from keras import losses\n",
    "from keras import regularizers\n",
    "from tqdm.keras import TqdmCallback \n",
    "\n",
    "# Plots and images\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import Image\n",
    "%matplotlib inline\n",
    "\n",
    "# Silence TF\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "# Setting random seeds\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading in the CSVs\n",
    "X_train = pd.read_csv('data/X_train.csv')\n",
    "Y_train = pd.read_csv('data/Y_train.csv')\n",
    "X_val = pd.read_csv('data/X_val.csv')\n",
    "Y_val = pd.read_csv('data/Y_val.csv')\n",
    "X_test = pd.read_csv('data/X_test.csv')\n",
    "Y_test = pd.read_csv('data/Y_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "Qqk2h0YKlybU"
   },
   "outputs": [],
   "source": [
    "# Drop unecessary columns added to the beginning of each DF\n",
    "for df in [X_train, Y_train, X_val, Y_val, X_test, Y_test]:\n",
    "    df.drop(columns=['Unnamed: 0', 'name_normalized'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making One-Hot Encodings and Tensors for Categorical Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Merging train, val, and test sets into one DF to perform the encodings in one batch\n",
    "X = pd.concat([X_train, X_val, X_test])\n",
    "\n",
    "# Making the numerical categorical variables into strings - necessary to make the one-hot encodings\n",
    "X[['opp_diff_ind', 'GW','was_home']] = X[['opp_diff_ind', 'GW','was_home']].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making categorical variables into sparse one-hot encodings\n",
    "season_tf = tf.keras.layers.StringLookup(vocabulary=X.season.unique(), output_mode='one_hot')(X.season)\n",
    "\n",
    "player_team_name_tf = tf.keras.layers.StringLookup(vocabulary=X.player_team_name.unique(), \n",
    "                                                         output_mode='one_hot')(X.player_team_name)\n",
    "\n",
    "opp_team_name_tf = tf.keras.layers.StringLookup(vocabulary=X.opp_team_name.unique(), \n",
    "                                                      output_mode='one_hot')(X.opp_team_name)\n",
    "\n",
    "opp_diff_ind_tf = tf.keras.layers.StringLookup(vocabulary=X.opp_diff_ind.unique(), \n",
    "                                                      output_mode='one_hot')(X.opp_diff_ind)\n",
    "\n",
    "position_tf = tf.keras.layers.StringLookup(vocabulary=X.position.unique(), output_mode='one_hot')(X.position)\n",
    "\n",
    "gw_tf = tf.keras.layers.StringLookup(vocabulary=X.GW.unique(), output_mode='one_hot')(X.GW)\n",
    "\n",
    "was_home_tf = tf.keras.layers.StringLookup(vocabulary=X.was_home.unique(), output_mode='one_hot')(X.was_home)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Getting the correct split sizes to split the tensors into train, val, and test again\n",
    "split_one = X_train.shape[0]\n",
    "split_two = X_val.shape[0]\n",
    "split_three = X_test.shape[0]\n",
    "\n",
    "# Splitting the encoded tensors into train, val, and test tensors\n",
    "season_train, season_val, season_test = tf.split(season_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "player_team_name_train, player_team_name_val, player_team_name_test = tf.split(player_team_name_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "opp_team_name_train, opp_team_name_val, opp_team_name_test = tf.split(opp_team_name_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "opp_diff_ind_train, opp_diff_ind_val, opp_diff_ind_test = tf.split(opp_diff_ind_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "position_train, position_val, position_test = tf.split(position_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "gw_train, gw_val, gw_test = tf.split(gw_tf, [split_one, split_two, split_three], 0)\n",
    "\n",
    "was_home_train, was_home_val, was_home_test = tf.split(was_home_tf, [split_one, split_two, split_three], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Turning Continuous Variables into Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grabbing only the continuous columns we want\n",
    "# Note: hyperparameter tuning found that lag_3 was the optimal choice between 1, 3, and 5, so we use it here\n",
    "cols = ['assists_lag_5', 'bonus_lag_5', 'bps_lag_5', 'clean_sheets_lag_5',\n",
    "        'creativity_lag_5', 'goals_conceded_lag_5', 'goals_scored_lag_5',\n",
    "        'ict_index_lag_5', 'influence_lag_5', 'minutes_lag_5',\n",
    "        'own_goals_lag_5', 'penalties_missed_lag_5', 'penalties_saved_lag_5',\n",
    "        'red_cards_lag_5', 'saves_lag_5', 'selected_lag_5',\n",
    "        'player_team_score_lag_5', 'opp_team_score_lag_5', 'threat_lag_5',\n",
    "        'total_points_lag_5', 'value_lag_5', 'yellow_cards_lag_5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making continuous variable tensors\n",
    "# Naming convention: \"contin\" stands for \"continuous\" and tf signifies that these are tensors\n",
    "X_train_contin_tf = tf.convert_to_tensor(X_train[cols])\n",
    "X_val_contin_tf = tf.convert_to_tensor(X_val[cols])\n",
    "X_test_contin_tf = tf.convert_to_tensor(X_test[cols])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making Final X and Y input Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making lists of train, val, and test tensors to combine\n",
    "# Note: using this method (rather than pytorch) because pytorch kept crashing my kernel\n",
    "X_train_tensor_list = [season_train, player_team_name_train, opp_team_name_train, opp_diff_ind_train, \n",
    "                       position_train, gw_train, was_home_train, X_train_contin_tf]\n",
    "\n",
    "X_val_tensor_list = [season_val, player_team_name_val, opp_team_name_val, opp_diff_ind_val, \n",
    "                     position_val, gw_val, was_home_val, X_val_contin_tf]\n",
    "\n",
    "X_test_tensor_list = [season_test, player_team_name_test, opp_team_name_test, opp_diff_ind_test, \n",
    "                      position_test, gw_test, was_home_test, X_test_contin_tf]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concatenating input tensors\n",
    "X_train_tf = tf.keras.layers.Concatenate(axis=1)(X_train_tensor_list)\n",
    "X_val_tf = tf.keras.layers.Concatenate(axis=1)(X_val_tensor_list)\n",
    "X_test_tf = tf.keras.layers.Concatenate(axis=1)(X_test_tensor_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making target tensors\n",
    "Y_train_tf = tf.convert_to_tensor(Y_train)\n",
    "Y_val_tf = tf.convert_to_tensor(Y_val)\n",
    "Y_test_tf = tf.convert_to_tensor(Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Plotting Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mse_mae_plots(history):\n",
    "    '''\n",
    "    Takes in history from model fitting and plots loss and MAE by epoch for both train and val\n",
    "    '''\n",
    "    hist = history.history\n",
    "    x_arr = np.arange(len(hist['loss'])) + 1\n",
    "    \n",
    "    fig = plt.figure(figsize=(12, 4))\n",
    "    ax = fig.add_subplot(1, 2, 1)\n",
    "    ax.plot(x_arr, hist['loss'], '-o', color='darkturquoise', label='Train loss')\n",
    "    ax.plot(x_arr, hist['val_loss'], '-s', color='mediumvioletred', label='Validation loss')\n",
    "    plt.axhline(y = MSE(true, pred), color = 'limegreen', linestyle = '-') # Adding a horizontal line for baseline MSE\n",
    "    ax.legend(fontsize=12)\n",
    "    ax.set_xlabel('Epoch', size=12)\n",
    "    ax.set_ylabel('Mean Squared Error (MSE)', size=12)\n",
    "    ax.set_title('MSE by Epoch')\n",
    "\n",
    "    ax = fig.add_subplot(1, 2, 2)\n",
    "    ax.plot(x_arr, hist['mean_absolute_error'], '-o', color='darkturquoise', label='Train MAE')\n",
    "    ax.plot(x_arr, hist['val_mean_absolute_error'], '-s', color='mediumvioletred', label='Validation MAE')\n",
    "    plt.axhline(y = MAE(true, pred), color = 'limegreen', linestyle = '-') # Adding a horizontal line for baseline MAE\n",
    "    ax.legend(fontsize=12)\n",
    "    ax.set_xlabel('Epoch', size=12)\n",
    "    ax.set_ylabel('Mean Absolute Error (MAE)', size=12)\n",
    "    ax.set_title('MAE by Epoch')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making a Baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting up necessary functions\n",
    "\n",
    "# Making a vector of predictions as long as the actuals\n",
    "def pred_vect(true_values, prediction=2):\n",
    "    predictions = []\n",
    "    count = 0\n",
    "    pred = prediction # Can pass baseline or 2\n",
    "    while count < len(true_values):\n",
    "        predictions.append(pred)\n",
    "        count += 1\n",
    "        \n",
    "    return predictions\n",
    "\n",
    "# Defining loss functions\n",
    "def MSE(true_values, predicted_values):\n",
    "    \"\"\"Return the MSE between true_values and predicted values.\"\"\"\n",
    "    tot = 0\n",
    "    count = 0\n",
    "    \n",
    "    # Calculating the SE for each data point\n",
    "    while count < len(true_values):\n",
    "        tot += (true_values[count] - predicted_values[count])**2\n",
    "        count += 1\n",
    "    \n",
    "    # Returning the MSE\n",
    "    return tot / len(true_values)\n",
    "\n",
    "def RMSE(true_values, predicted_values):\n",
    "    \"\"\"Return the RMSE between true_values and predicted values.\"\"\"\n",
    "    tot = 0\n",
    "    count = 0\n",
    "    \n",
    "    # Calculating the SE for each data point\n",
    "    while count < len(true_values):\n",
    "        tot += (true_values[count] - predicted_values[count])**2\n",
    "        count += 1\n",
    "    \n",
    "    # Returning the RMSE\n",
    "    return math.sqrt(tot / len(true_values))\n",
    "\n",
    "def MAE(true_values, predicted_values):\n",
    "    \"\"\"Return the MAE between true_values and predicted values.\"\"\"\n",
    "    tot = 0\n",
    "    count = 0\n",
    "    \n",
    "    # Calculating the SE for each data point\n",
    "    while count < len(true_values):\n",
    "        tot += abs(true_values[count] - predicted_values[count])\n",
    "        count += 1\n",
    "    \n",
    "    # Returning the MAE\n",
    "    return tot / len(true_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a baseline with the average value\n",
    "baseline = Y_train['total_points'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE is 5.573\n",
      "RMSE is 2.361\n",
      "MAE is 1.595\n"
     ]
    }
   ],
   "source": [
    "true = np.array(Y_test['total_points'])\n",
    "pred = np.array(pred_vect(Y_test['total_points'],baseline))\n",
    "\n",
    "print(f'MSE is {round(MSE(true, pred),3)}')\n",
    "print(f'RMSE is {round(RMSE(true, pred),3)}')\n",
    "print(f'MAE is {round(MAE(true, pred),3)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fVyClQxWXtX-"
   },
   "source": [
    "# Making a linear regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "Lg-I4TfLViAA"
   },
   "outputs": [],
   "source": [
    "# Defining a function to create linear regression models\n",
    "def make_lin_reg_model(epoch_count=20, learning_rate=0.0005, optimizer='Adam', decay_steps=10000, decay_rate=0.95, lr_sched='yes'):\n",
    "\n",
    "    ############################################################################################## 1\n",
    "    # Preparing the data\n",
    "    num_features = X_train_tf.shape[1]\n",
    "\n",
    "    ############################################################################################## 2\n",
    "    # Building the model\n",
    "    tf.keras.backend.clear_session()\n",
    "    model = tf.keras.Sequential()\n",
    "    \n",
    "    # Create input layer\n",
    "    model.add(tf.keras.Input(shape=(num_features,), name='Input'\n",
    "              ))\n",
    "    \n",
    "    # Create output layer\n",
    "    model.add(tf.keras.layers.Dense(\n",
    "              activation = None,    # linear activation\n",
    "              units = 1,            \n",
    "              use_bias = True             \n",
    "              ))\n",
    "    \n",
    "    # Set a learning rate schedule\n",
    "    if lr_sched == 'yes':\n",
    "        lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "            initial_learning_rate=learning_rate,\n",
    "            decay_steps=decay_steps,\n",
    "            decay_rate=decay_rate)\n",
    "    else:\n",
    "        lr_schedule = learning_rate\n",
    "    \n",
    "    # Set optimizer\n",
    "    if optimizer == 'SGD':\n",
    "      opt = tf.keras.optimizers.SGD(learning_rate=lr_schedule)\n",
    "    elif optimizer == 'Adam':\n",
    "      opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)\n",
    "    else:\n",
    "      raise 'Unsupported optimizer: %s' %optimizer\n",
    "\n",
    "    ############################################################################################## 3\n",
    "    # Compiling the model\n",
    "    model.compile(\n",
    "        optimizer=opt,\n",
    "        loss=losses.MeanSquaredError(),\n",
    "        metrics=[metrics.mse,\n",
    "                 metrics.RootMeanSquaredError(),\n",
    "                 metrics.mae]\n",
    "        )\n",
    "\n",
    "    ############################################################################################## 4\n",
    "    # Fitting the model\n",
    "    history = model.fit(\n",
    "        x = X_train_tf,\n",
    "        y = Y_train_tf,\n",
    "        epochs = epoch_count,\n",
    "        validation_data = (X_val_tf, Y_val_tf),\n",
    "        verbose=False,\n",
    "        callbacks=[TqdmCallback()]\n",
    "        )\n",
    "\n",
    "    ############################################################################################## 5\n",
    "    # Plotting the results\n",
    "    mse_mae_plots(history)\n",
    "\n",
    "    ############################################################################################## 6\n",
    "    # Evaluating the model\n",
    "    \n",
    "    results = model.evaluate(X_test_tf, Y_test_tf)\n",
    "    print(f'MSE is {round(results[1],3)}')\n",
    "    print(f'RMSE is {round(results[2],3)}')\n",
    "    print(f'MAE is {round(results[3],3)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "559431d485e343f3839f357e93b0f89d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "829/829 [==============================] - 0s 492us/step - loss: 4.1350 - mean_squared_error: 4.1350 - root_mean_squared_error: 2.0335 - mean_absolute_error: 1.0890\n",
      "MSE is 4.135\n",
      "RMSE is 2.033\n",
      "MAE is 1.089\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+oAAAGICAYAAADWPRqqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACmx0lEQVR4nOzdd3hT1f8H8PfNaJKuFDpoS6Etq6yyvjgAGaUgoiCCiAzZKvxQRBEHIFCGLAeggDhaagER2SgKKlMQlCl7CQUKpdBCm8404/7+KI2ErqRNmrR9v54nT5N7zz33k7Rw8rnn3HMEURRFEBEREREREZFTkDg6ACIiIiIiIiL6DxN1IiIiIiIiIifCRJ2IiIiIiIjIiTBRJyIiIiIiInIiTNSJiIiIiIiInAgTdSIiIiIiIiInwkSdiIiIiIiIyIkwUSciIiIiIiJyIkzUiYiIiIiIiJwIE3UiO4qNjYUgCBAEAbt37y6wXxRF1KtXD4IgoFOnTmb7UlJSMHHiRDRu3Bhubm5Qq9Vo2LAhBg8ejBMnThR6jsIehZ33QZ06dULTpk1t8G6LFxISUmSMD793Rxg2bBjc3d0dHQYREVUwZWnr8yUnJ0OhUEAQBBw+fLjQMsOGDSu2vS+JIAh4/fXXrXlrVouPjy82xqioKLue3xIhISHo0aOHo8MgKpHM0QEQVQUeHh6Ijo4u0EDv2bMH//77Lzw8PMy2Z2Rk4PHHH0dGRgbeeecdNG/eHNnZ2bhw4QI2bNiA48ePo1mzZmbHLF++HA0bNixw7saNG9v8/ZRWu3bt8PHHHxfY7unp6YBoiIiIbMfatv5BK1asQG5uLgAgOjoarVu3LrScSqXCzp07bRazvYwdOxYDBw4ssD0oKMgB0RBVTEzUicrBiy++iFWrVmHJkiVmSWl0dDTatGkDjUZjVn7t2rW4dOkSdu7ciYiICLN948ePh9FoLHCOpk2bFtmwOwsvLy88/vjjjg6DiIjI5qxt6x8UExMDPz8/BAcHY/Xq1fj000+hUqkKlJNIJBWiHa1du3aFiJPImXHoO1E5GDBgAABg9erVpm1paWlYv349RowYUaB8SkoKACAgIKDQ+iQS2//T/eOPP/D4449DpVKhZs2amDJlCgwGA4C8YXv169dHt27dChyXkZEBtVqN1157zSZxREVFQRAEHDt2DH369IGnpyfUajVeeukl3Llzx6ys0WjE/Pnz0bBhQygUCvj5+WHIkCFISEgoUO+2bdsQGRkJtVoNV1dXNGrUCHPmzClQ7tKlS3j66afh7u6OWrVq4e2334ZWq7XJeyMiosrL2rY+319//YVTp05h8ODBeOWVV0zH2MuXX36JBg0aQKFQoHHjxvj+++9N++Lj4yGTyQptH/fu3QtBELB27VqbxJF/611x3z/y3b17F2PGjEHNmjXh4uKCOnXqYPLkyQXaZ6PRiM8//xwtWrSASqUydRBs2bKlwPm3bduGVq1aQaVSoWHDhoiJibHJ+yKyFSbqROXA09MTffv2NWsEVq9eDYlEghdffLFA+TZt2gAAhgwZgk2bNpkS9+IYDAbo9Xqzx8MNXVFu3bqF/v37Y9CgQdi8eTP69u2LWbNmYdy4cQDy7msbO3YsfvvtN1y8eNHs2Li4OGg0GosSdVEUC8So1+shimKBsr1790a9evWwbt06REVFYdOmTejWrRt0Op2pzP/93//hvffeQ9euXbFlyxbMnDkT27ZtQ9u2bZGcnGwqFx0djaeffhpGoxHLli3Djz/+iDfeeKNAQq/T6fDss88iMjISmzdvxogRI7BgwQLMmzfPos+RiIiqLmvb+nzR0dEAgBEjRqB///5wdXU1bStMYe1oYSPtCrNlyxZ89tlnmDFjBtatW4fg4GAMGDAA69atA5B3//azzz6LZcuWFfgOsXjxYgQGBqJ3794lnsdoNBYa58NK+v4BADk5OYiIiEBcXBzGjx+PrVu34qWXXsL8+fPRp08fs/qGDRuGcePG4ZFHHsGaNWvw/fff49lnn0V8fLxZuX/++Qdvv/023nrrLWzevBnNmjXDyJEjsXfvXos+R6JyIRKR3SxfvlwEIB46dEjctWuXCEA8deqUKIqi+Mgjj4jDhg0TRVEUmzRpInbs2NHs2BkzZoguLi4iABGAGBoaKo4ePVr8559/Cj1HYQ+pVFpijB07dhQBiJs3bzbb/sorr4gSiUS8evWqKIqiqNFoRA8PD3HcuHFm5Ro3bixGRESUeJ7g4OAi45w5c6ap3LRp00QA4ltvvWV2/KpVq0QA4sqVK0VRFMWzZ8+KAMQxY8aYlfvrr79EAOKkSZNEURTF9PR00dPTU3ziiSdEo9FYZHxDhw4VAYg//PCD2fann35aDAsLK/H9ERFR1VSWtj4zM1P09PQUH3/8cdO2oUOHioIgiJcuXTIrm99OFfaIjIwsMU4AokqlEm/dumXaptfrxYYNG4r16tUzbct/Dxs3bjRtu3HjhiiTycTp06cXe44rV64UGSMA8Y8//jCVtfT7x7Jlywptn+fNmycCEH/99VdRFEVx7969IgBx8uTJxcYYHBwsKpVKU/2iKIrZ2dli9erVxVGjRhV7LFF5Yo86UTnp2LEj6tati5iYGJw8eRKHDh0qdijclClTcO3aNcTExGDUqFFwd3fHsmXL8L///c9sWF2+uLg4HDp0yOzx119/WRSbh4cHnn32WbNtAwcOhNFoNF1d9vDwwPDhwxEbG4vMzEwAwM6dO3HmzBmLZ5F94oknCsR46NAhjBw5skDZQYMGmb3u168fZDIZdu3aBQCmn8OGDTMr9+ijj6JRo0bYsWMHAODPP/+ERqPBmDFjSpwVVxAE9OzZ02xbs2bNcPXqVYveHxERVW3WtvU//PADNBqNWZkRI0ZAFEUsX768QHmVSlVoO7p06VKL4ouMjESNGjVMr6VSKV588UVcunTJNMqsU6dOaN68OZYsWWIqt2zZMgiCgFdffdWi84wbN67QOFu0aGFWzpLvHzt37oSbmxv69u1rVi6//c9v73/55RcAsGiEX4sWLVC7dm3Ta6VSiQYNGrC9J6fCyeSIyokgCBg+fDg+++wz5OTkoEGDBmjfvn2xx9SoUQPDhw/H8OHDAeTdH9a9e3eMGzfOdC9cvkaNGpV6MrkHG+18/v7+AGA27H7s2LFYvHgxVq1ahVdffRWLFy9GUFAQevXqZdF51Gq1xTHmnz+fTCaDt7e3KZ7i7uMPDAw0Nbb597VbMtOsq6srlEql2TaFQoGcnByLYiYioqrN2rY+OjoaSqUSTz31FFJTUwHkXSAOCQlBbGwspk+fDqlUaiovkUjKNHHsw23rg9tSUlJMbeUbb7yBl19+GefPn0edOnXw9ddfo2/fvoUeX5igoCCL4rTk+0dKSgr8/f0LXGz38/ODTCYzlbtz5w6kUqlFMXp7exfYplAokJ2dXeKxROWFPepE5WjYsGFITk7GsmXLTMm3NTp06IAnn3wSd+7cwe3bt20WV1JSUoFtt27dAmDemNWrVw/du3fHkiVLcP36dWzZsgWjR482+xJhK/nnz6fX65GSkmKKJ/9nYmJigWNv3rwJHx8fAICvry8AFDrBHBERka1Z2tZfuHAB+/btQ05ODmrXro1q1aqZHvHx8bhx4wa2b99u09geblsf3PZgez9w4EB4e3tjyZIlWLt2LW7dumWzSWMfZMn3D29vbyQlJRWYz+b27dvQ6/Vm7b3BYCj0PRJVREzUicpRzZo18c4776Bnz54YOnRokeWSkpIKnRjGYDDg4sWLcHV1hZeXl83iSk9PLzAj6nfffQeJRIIOHTqYbR83bhxOnDiBoUOHQiqV4pVXXrFZHA9atWqV2esffvgBer3etD5t586dAQArV640K3fo0CGcPXsWkZGRAIC2bdtCrVZj2bJlhU5aR0REZEuWtvX5E8Z9/fXX2LVrl9nj559/hlwut/lM5Dt27DBLjg0GA9asWYO6deuajTxTKpV49dVX8e233+LTTz9FixYt0K5dO5vGAlj2/SMyMhIZGRnYtGmTWbm4uDjTfgDo3r07AOCLL76weZxEjsCh70TlbO7cuSWWWbFiBb788ksMHDgQjzzyCNRqNRISEvDNN9/g9OnTmDp1KlxcXMyOOXXqVKEzqtatW9fUq1wUb29v/N///R+uXbuGBg0a4Oeff8bXX3+N//u//zO7hwsAunbtisaNG2PXrl146aWX4OfnZ8G7zpOamoqDBw8W2K5QKNCyZUuzbRs2bIBMJkPXrl1x+vRpTJkyBc2bN0e/fv0AAGFhYXj11Vfx+eefQyKRoHv37oiPj8eUKVNQq1YtvPXWWwAAd3d3fPLJJ3j55ZfRpUsXvPLKK6hRowYuXbqEf/75B4sXL7Y4fiIiIkuU1Nbr9XrExcWhUaNGePnllwst07NnT2zZsgV37twxteNGo7HQdhQAWrZsCYVCUex5fXx80LlzZ0yZMgVubm5YunQpzp07Z7ZEW74xY8Zg/vz5OHLkCL755pti633YtWvXCo3T19cXdevWNb225PvHkCFDsGTJEgwdOhTx8fEIDw/Hvn37MHv2bDz99NPo0qULAKB9+/YYPHgwZs2ahaSkJPTo0QMKhQLHjh2Dq6srxo4da9V7IHI4B09mR1SpPTgTbHEengn2zJkz4ttvvy22bt1a9PX1FWUymVitWjWxY8eO4ooVKwo9R1GPr7/+uthzd+zYUWzSpIm4e/dusXXr1qJCoRADAgLESZMmiTqdrtBjoqKiRADiwYMHLfsgxOJnfa9Zs6apXP6s70eOHBF79uwpuru7ix4eHuKAAQPEpKQkszoNBoM4b948sUGDBqJcLhd9fHzEl156Sbx+/XqB8//8889ix44dRTc3N9HV1VVs3LixOG/ePNP+oUOHim5ubgWOy4+HiIioMKVp6zdt2iQCEBcuXFhk+W3btokAxE8++UQUxeJnfQcgXrx4sdjzAxBfe+01cenSpWLdunVFuVwuNmzYUFy1alWRx3Tq1EmsXr26mJWVVWzd+Uqa9X3QoEGmstZ8/0hJSRFHjx4tBgQEiDKZTAwODhYnTpwo5uTkmJUzGAziggULxKZNm4ouLi6iWq0W27RpI/7444+mMsHBweIzzzxTIPaOHTsWmJWfyJEEUeRYUCKyTuvWrSEIAg4dOmTzuqOiojB9+nTcuXPHdN8ZERERla/bt28jODgYY8eOxfz5821ef6dOnZCcnIxTp07ZvG6iyoBD34nIIhqNBqdOncJPP/2EI0eOYOPGjY4OiYiIiGwsISEBly9fxkcffQSJRIJx48Y5OiSiKomJOhFZ5OjRo4iIiIC3tzemTZuG5557ztEhERERkY198803mDFjBkJCQrBq1SrUrFnT0SERVUkc+k5ERERERETkRLg8GxEREREREZETYaJORERERERE5ESYqBMRERERERE5kSo5mZzRaMTNmzfh4eEBQRAcHQ4RERFEUUR6ejoCAwMhkfA6ui2wvSciImdiTVtfJRP1mzdvolatWo4Og4iIqIDr168jKCjI0WFUCmzviYjIGVnS1lfJRN3DwwNA3gfk6enp4GiIiIgAjUaDWrVqmdooKju290RE5EysaeurZKKeP/zN09OTDTcRETkVDtG2Hbb3RETkjCxp6x1+E1xUVBQEQTB7+Pv7F3uMVqvF5MmTERwcDIVCgbp16yImJqacIiYiIiIiIiKyH6foUW/SpAl+//1302upVFps+X79+iEpKQnR0dGoV68ebt++Db1eb+8wiYiIiIiIiOzOKRJ1mUxWYi96vm3btmHPnj24fPkyqlevDgAICQmxY3RERERERERE5cfhQ98B4OLFiwgMDERoaCj69++Py5cvF1l2y5YtaN26NebPn4+aNWuiQYMGmDBhArKzs4s8RqvVQqPRmD2IiIiIiIiInJHDE/XHHnsMcXFx2L59O77++mvcunULbdu2RUpKSqHlL1++jH379uHUqVPYuHEjFi5ciHXr1uG1114r8hxz5syBWq02PbhUCxERUfnZu3cvevbsicDAQAiCgE2bNpV4DOejISKiqszhQ9+7d+9ueh4eHo42bdqgbt26+PbbbzF+/PgC5Y1GIwRBwKpVq6BWqwEAn376Kfr27YslS5ZApVIVOGbixIlmdeVPi09ERET2l5mZiebNm2P48OF4/vnnLTqG89EQEVFV5vBE/WFubm4IDw/HxYsXC90fEBCAmjVrmpJ0AGjUqBFEUURCQgLq169f4BiFQgGFQmG3mImIiKho3bt3N7swX5LSzkej1Wqh1WpNr3mrGxERVVQOH/r+MK1Wi7NnzyIgIKDQ/e3atcPNmzeRkZFh2nbhwgVIJBIEBQWVV5hERERkJ6WZjwbgrW5ERFR5ODxRnzBhAvbs2YMrV67gr7/+Qt++faHRaDB06FAAecPWhwwZYio/cOBAeHt7Y/jw4Thz5gz27t2Ld955ByNGjCh02DsRERFVLKWZjwbI+86QlpZmely/fr2cIiYiIrIthw99T0hIwIABA5CcnAxfX188/vjjOHjwIIKDgwEAiYmJuHbtmqm8u7s7fvvtN4wdOxatW7eGt7c3+vXrh1mzZll97mxDNuQGuc3eCxERUWllG4rvLa5KSjMfDVD0rW5s74mIyBlY09Y7PFH//vvvi90fGxtbYFvDhg3x22+/lfnc3U52g9RdWuZ6iIiIysqQYXB0CE6jNPPRFIftPREROQNr2nqHD30nIiIiehDnoyEioqrO4T3qjrQ9fDs8PT0dHQYRERE0Gg384e/oMOwiIyMDly5dMr2+cuUKjh8/jurVq6N27dqYOHEibty4gbi4OAB589HMnDkTw4cPx/Tp05GcnFym+WjY3hMRkTOwpq2v0om6SqqCSsoJ6IiIyPF0Up2jQ7Cbw4cPIyIiwvR6/PjxAIChQ4ciNjbWrvPRAGzviYjIOVjT1guiKIp2jMUpaTQaqNVqpKWl8Qo7ERE5BbZNtsfPlIiInIk17RLvUSciIiIiIiJyIkzUiYiIiIiIiJwIE3UiIiIiIiIiJ8JEnYiIiIiIiMiJMFEnIiIiIiIiciJM1ImIiIiIiIicCBN1IiIiIiIiIifCRJ2IiIiIiIjIiTBRJyIiIiIiInIiTNSJiIiIiIiInAgTdSIiIiIiIiInwkSdiIiIiIiIyIkwUSciIiIiIiJyIkzUiYiIiIiIiJwIE3UiIiIiIiIiJ8JEnYiIiIiIiMiJMFEnIiIiIiIiciJM1ImIiIiIiIicCBN1IiIiIiIiIifCRJ2IiIiIiIjIiTBRJyIiIiIiInIiTNSJiIiIiIiInAgTdSIiIiIiIiInwkSdiIiIiIiIyIkwUSciIiIiIiJyIkzUiYiIiIiIiJyIzNEBEBERkXPSaDQ4ePAgbty4gezsbPj4+KBx48Zo2rSpo0MjIiKq1JioExERkYler8e6deuwbNky7N+/H0ajEaIomvYLggBvb28MGjQIY8aMQf369R0YLRERUeXEoe9EREQEANiyZQsaN26MIUOGwM3NDbNnz8avv/6Kf/75B+fPn8eBAwewcuVK9O/fH5s2bULjxo0xevRoJCcnOzp0IiKiSkUQH7xMboErV67g559/xv79+wsMhevcuTO6du0KuVxur3htQqPRQK1WIy0tDZ6eno4Oh4iIyCnapmrVquGtt97C6NGj4efnV2L5HTt24MMPP0SnTp0wderUcojQOs7wmRIREeWzpl2yOFHfvXs35s6di99//x1GoxE1a9aEn58flEol7t69i+vXryMrKwu+vr4YNWoUJkyY4LSNIhtuIiJyNs7QNqWmpsLLy6vcjrM3Z/hMiYiI8lnTLlk09L1379548skn4eLigtWrVyMpKQnXr1/HkSNHsH//fpw9exZpaWk4cuQIRo0ahZUrV6J+/fr4/fffbfKGiIiIyP5Km2w7Y5JORERUkVk0mZyHhwfOnTuHOnXqFFlGKpWiZcuWaNmyJaKiorBixQrcuHHDZoESERGRfV27dg0BAQEl3sKWnp6OQ4cOoXPnzuUUGRERUdViUY96XFxcsUl6gUolEgwdOhRDhw4tdWBERERUvkJDQ3Hs2DHTa6PRiAYNGuDMmTNm5c6cOYOuXbuWd3hERERVBmd9JyIiIgDAw9PWiKKIS5cuIScnx0ERERERVU0WJeozZszAzZs3zbb9+eefyMrKMtt2+fJlDBkyxHbREREREREREVUxFiXq06dPR0JCgum1wWBA+/btce7cObNyd+7cwapVq2wbIREREREREVEVYlGiXtgKblYuv05EREREREREFnD4PepRUVEQBMHs4e/vb9Gx+/fvh0wmQ4sWLewbJBERURWh0Whw9+5d3L17FykpKQW23b17F2lpaQ6OkoiIqHKzaHk2e2vSpInZmutSqbTEY9LS0jBkyBBERkYiKSnJnuERERFVGd26dSuwLTIy0gGREBERVV1OkajLZDKLe9HzjRo1CgMHDoRUKsWmTZuKLavVaqHVak2vNRpNacIkIiKq1KZNm+boEIiIiAhWJOqrV6/Gvn37AOStqyoIAlatWoXdu3ebyly7dq1UQVy8eBGBgYFQKBR47LHHMHv27GLXbV++fDn+/fdfrFy5ErNmzSqx/jlz5mD69Omlio2IiKiqYKJORETkHATRglnhJBLLb2UXBAEGg8Hi8r/88guysrLQoEEDJCUlYdasWTh37hxOnz4Nb2/vAuUvXryIJ554An/88QcaNGiAqKgobNq0CcePHy/yHIX1qNeqVQtpaWnw9PS0OFYiIiJ70Wg0UKvVFaJtOnnyJKKjo7Fw4UJHh1KsivSZEhFR5WdNu2RRj/qVK1dsElhhunfvbnoeHh6ONm3aoG7duvj2228xfvx4s7IGgwEDBw7E9OnT0aBBA4vPoVAooFAobBYzERFRVaPRaPDdd98hJiYGR44cAQCnT9SJiIgqKosS9eDgYHvHYeLm5obw8HBcvHixwL709HQcPnwYx44dw+uvvw4gbxi+KIqQyWT49ddf0blz53KLlYiIqLLbvXs3YmJisH79euTk5MDb2xtvvfUWXn31VUeHRkREVGmVeTK5s2fP4vTp0wgMDETbtm3LHJBWq8XZs2fRvn37Avs8PT1x8uRJs21Lly7Fzp07sW7dOoSGhpb5/ERERFXdzZs3ERsbi5iYGNOouieeeAL79u3DunXr0KFDBwdHSEREVLlZlKhv2rQJv/76K5YuXWq2/Y033sCSJUtMryMiIrB161arhplPmDABPXv2RO3atXH79m3MmjULGo0GQ4cOBQBMnDgRN27cQFxcHCQSCZo2bWp2vJ+fH5RKZYHtREREZJ0NGzYgOjoav/76KwwGA4KDgzF16lQMHz4cnp6eqF69uqNDJCIiqhIsStRjY2Mhl8vNtv30009YvHgxGjdujFdffRVnzpzBV199hQULFuD999+3OICEhAQMGDAAycnJ8PX1xeOPP46DBw+ahtsnJiaWejZ5IiIislzfvn0hCAK6du2Kd955x2z99LS0NAdGRkREVLVYlKgfP34cU6ZMMdu2YsUKuLi4YNu2bQgKCgIAiKKItWvXWpWof//998Xuj42NLXZ/VFQUoqKiLD4fERERFc7Pzw+3b9/Gnj17oFarodfr8eSTT0IQBEeHRkREVKVYtO7anTt3CqxrvnPnTrRp08aUpANAjx49Cp0EjoiIiJxfQkICNmzYgMjISGzYsAFPP/20afj7v//+W+p69+7di549eyIwMBCCIGDTpk3Flt+9ezcEQSjwOHfuXKljICIiqkgsStSVSqXZOuRXr15FSkoKHn30UbNy1apVg06ns22EREREVC5kMhmee+45/PTTT7h27RpmzpwJpVKJWbNm4ZFHHoEgCNi/fz9yc3OtqjczMxPNmzfH4sWLrTru/PnzSExMND3q169v1fFEREQVlUWJet26dbFnzx7T619//RWCIKBdu3Zm5RITE+Hr62vbCImIiKjcBQQEYNKkSbhw4QJ27tyJgQMHQqlUYvLkyQgMDMSECRMsrqt79+6YNWsW+vTpY1UMfn5+8Pf3Nz2kUqm1b4OIiKhCsihRHzlyJBYsWIAZM2bgq6++wrRp0+Dj44Nu3bqZlduzZw/CwsLsEigRERE5RqdOnbBixQokJiZiyZIlCAkJwYIFC+x+3pYtWyIgIACRkZHYtWtXieW1Wi00Go3Zg4iIqCKyOFF/7rnnEBUVhdGjRyMnJwfffvut2TJsmZmZ+P7779G5c2e7BUtERESO4+npif/7v//D4cOHcfz4cbudJyAgAF999RXWr1+PDRs2ICwsDJGRkdi7d2+xx82ZMwdqtdr0qFWrlt1iJCIisidBFEXR0sLx8fFISUlBo0aN4OrqarYvIyMD58+fR7169aBWq20eqC1pNBqo1WqkpaXB09PT0eEQERFVmbZJEARs3LgRzz33nFXH9ezZE4IgYMuWLUWW0Wq1ZnPqaDQa1KpVq9J/pkREVDFY09ZbtDxbvpCQEISEhBS6z93dHf/73/+sqY6IiIicyMMrvBRHEIQyzQRvrccffxwrV64stoxCoTAb7UdERFRRWZWoExERUeUVHx8PtVqNdu3aOd3a6ceOHUNAQICjwyAiIioXFiXq1syyKggC9Hp9qQMiIiIix+jUqRP27NmDkydPYujQoRg+fDhCQ0PLXG9GRgYuXbpken3lyhUcP34c1atXR+3atTFx4kTcuHEDcXFxAICFCxciJCQETZo0QW5uLlauXIn169dj/fr1ZY6FiIioIrAoURdFEWq1Gs8++yzv8SIiIqqkdu7cifj4eERHR+Pbb7/F7Nmz0bFjR4wcORLPP/98qYeVHz58GBEREabX48ePBwAMHToUsbGxSExMxLVr10z7c3NzMWHCBNy4cQMqlQpNmjTB1q1b8fTTT5ftDRIREVUQFk0mN2LECKxbtw5GoxF9+vTByJEj0bFjx/KIzy6qyoQ9RERUcThb2ySKIrZv346YmBhs2bIFrq6uGDBgAEaPHo3w8HBHh2cRZ/tMiYioarOmXbJoebaYmBgkJiZi0aJFuHz5MiIiIlCvXj3Mnj0bN2/etEnQRERE5DwEQcBTTz2FH374ATdv3sSYMWPw1VdfYdq0aY4OjYiIqNKzKFEHADc3N4wcORL79u3D2bNn0adPH3z++ecIDg7GM888gx07dtgzTiIiIipnoijil19+wahRo/DRRx/B3d0dHTp0cHRYRERElZ7FifqDwsLCMH/+fCQkJGDKlCnYvn07lixZYuvYiIiIyAH+/fdfTJ48GbVr10aPHj1w9+5dLF++HImJiXjzzTcdHR4REVGlV6rl2dLS0vDdd98hJiYGR44cQVhYGPr27Wvr2IiIiKgcxcXFITo6Gvv27UNQUBBGjBiB4cOHIyQkxNGhERERVSlWJeo7duxATEwMNm3aBKlUihdeeAGLFi1C27Zt7RUfERERlZNhw4bB09MTL7/8Mrp27QqJRIKjR4/i6NGjhZbv06dPOUdIRERUNViUqM+YMQOxsbG4evUq2rZti8WLF6Nfv35wc3Ozd3xERERUjjQaDb7++mt88803APLuUy+MIAgwGAzlGRoREVGVYVGiHhUVZbrCHhYWhnv37uHLL78stKwgCHjrrbdsGiQRERHZ365duxwdAhEREcHCddQlEsvnnKsIV9i5rioRETkbtk22x8+UiIiciTXtkkU96leuXLFJYERERERERERUPIsS9eDgYHvHQURERA42ZswYTJ06Ff7+/hYfs2HDBmRnZ2PQoEF2jIyIiKhqKdU66kRERFT5nD9/HnXq1MFLL72E7du3Iysrq9Byly5dwieffIKmTZti5MiRqFatWjlHSkREVLlZ1KP+9NNP48MPP0TLli0tqlSr1WLJkiVQKBR47bXXyhQgERERlY8dO3Zg8+bNmDNnDrp37w6ZTIb69evDz88PSqUSd+/exeXLl3H37l24ublh2LBh+OCDD+Dn5+fo0ImIiCoVixJ1f39/PPLII3jssccwZMgQdOrUCWFhYWZl0tPT8ddff2Hz5s1YvXo11Go1VqxYYZegiYiIyD569eqFXr164dixY/jpp59w8OBB3Lx5E9nZ2fDx8UGvXr3QqVMn9OrVCx4eHo4Ol4iIqFKyaNZ3ADh27Bjmzp2LTZs2Qa/XQ6VSwdfX13SFPSUlBaIoIjg4GK+//jpee+01KBQKe8dfKpwFloiInA3bJtvjZ0pERM7E5rO+A0DLli2xZs0a3L59G9u3bze7wv6///0PDRs2RKdOndCuXTsIglDmN0FERERERERUFVmcqOfz8/PD4MGDMXjwYHvEQ0RERERERFSlcdZ3IiIiIiIiIifCRJ2IiIiIiIjIiTBRJyIiIiIiInIiTNSJiIjITE5ODiZNmoQjR444OhQiIqIqiYk6ERERmVEqlViwYAEyMzMdHQoREVGVZFWinp2djYEDB2Lfvn32ioeIiIicQKNGjXDlyhVHh0FERFQlWZWoq1QqbN68GUaj0V7xEBERkROYMmUKZs2ahX///dfRoRAREVU5Vq+j3qJFC5w6dQodOnSwRzxERETkBJYvX46srCw0atQIzZo1Q0BAAARBMO0XBAGbN292YIRERESVl9WJ+ty5czF48GA0adIEHTt2tEdMRERE5GAnTpyAi4sLatasiZSUFKSkpJjtfzBpJyIiItuyOlEfM2YMMjIy0LlzZ1SrVq3QK+z//POPTYMkIiKi8hUfH+/oEIiIiKosqxN1b29v+Pj42CMWIiIiIiIioirP6kR99+7ddgiDiIiInI1Op0NcXBx27NiBlJQU+Pj4oEuXLnjppZcgl8sdHR4REVGlZXWiTkRERJVfWloaIiMjcfToUbi5ucHf3x9//vknVq9ejaVLl2LHjh3w9PR0dJhERESVklXLs+W7e/cupkyZgrZt2yIsLAzt2rXDtGnTcO/ePVvHR0RERA4wefJknD9/HmvWrEF6ejouXryI9PR0/PDDDzh//jwmT57s6BCJiIgqLasT9Rs3bqBVq1b48MMPkZaWhtq1ayM1NRUzZ85Eq1atcPPmTavqi4qKgiAIZg9/f/8iy2/YsAFdu3aFr68vPD090aZNG2zfvt3at2EzBlHE7vQMrL57D7vTM2AQRYfFQkREZCubNm3CjBkz8MILL5ht79u3L6KiorBx40YHRUZERFT5WZ2oT5o0CdnZ2fjrr79w+vRp/Pbbbzh9+jT++usvZGdnY9KkSVYH0aRJEyQmJpoeJ0+eLLLs3r170bVrV/z88884cuQIIiIi0LNnTxw7dszq85bVhtQ0hJw+h4hLlzHw6nVEXLqMkNPnsCE1rdxjISIisqU7d+6gWbNmhe5r3rw5kpOTyzkiIiKiqsPqe9S3bduGWbNm4ZFHHjHb/sgjj2DGjBmYMmWK9UHIZMX2oj9o4cKFZq9nz56NzZs348cff0TLli2tPndpbUhNQ98rV/Fw//kNnQ59r1zFutBg9PFSl1s8REREtlSzZk3s27cPkZGRBfbt378fgYGBDoiKiIioarC6Rz0tLQ0hISGF7gsNDUVamvW9yRcvXkRgYCBCQ0PRv39/XL582eJjjUYj0tPTUb169SLLaLVaaDQas0dZGEQR4xJuFkjSAZi2vZlwk8PgiYiownrxxRcxe/ZsfPrpp0hJSQEApKSkYNGiRZg9ezb69+/v4AiJiIgqL6sT9dDQUGzdurXQfb/88gtCQ0Otqu+xxx5DXFwctm/fjq+//hq3bt1C27ZtTV8KSvLJJ58gMzMT/fr1K7LMnDlzoFarTY9atWpZFePD/sjIRIJOV+R+EcB1nQ5/ZGSW6TxERESOEhUVhYiICEyYMAF+fn5QKBTw8/PDW2+9hYiICERFRTk6RCIiokrL6qHvw4cPx/vvvw+j0YihQ4ciICAAiYmJWLlyJT7//HPMnTvXqvq6d+9ueh4eHo42bdqgbt26+PbbbzF+/Phij129ejWioqKwefNm+Pn5FVlu4sSJZnVpNJoyJeuJxSTppSlHRETkbBQKBbZt24bt27dj165dSElJgbe3NyIjI9G1a1dHh0dERFSpWZ2ov/POO/j333+xePFiLFmyxLRdFEW8+uqrmDBhQpkCcnNzQ3h4OC5evFhsuTVr1mDkyJFYu3YtunTpUmxZhUIBhUJRprgeFCCX27QcERGRM8nOzka9evWwbNky9OzZE926dXN0SERERFWK1Ym6TqfDF198gfHjx5tdYe/cuTMaNGhQ5oC0Wi3Onj2L9u3bF1lm9erVGDFiBFavXo1nnnmmzOe0Vnt3NwTJ5bih0xV6n7oAIEguR3t3t/IOjYiIqMxUKhWys7Ph5sZ2jIiIyBGsStRzcnLg5uaGdevWoXfv3ggLCytzABMmTEDPnj1Ru3Zt3L59G7NmzYJGo8HQoUMB5A1bv3HjBuLi4gDkJelDhgzBokWL8Pjjj+PWrVsA8r5UqNXlM8u6VBCwKCgQfa9chQCYJevC/Z8LgwIhFYRCjiYiInJ+kZGR+P3339G5c2dHh0JERFTlWDWZnFKphLe3t02vsCckJGDAgAEICwtDnz594OLigoMHDyI4OBgAkJiYiGvXrpnKf/nll9Dr9XjttdcQEBBgeowbN85mMVmij5ca60KDUfOh4e1BcjmXZiMiogpv0qRJ+P777zFjxgycOnUKKSkpuHv3rtmDiIiI7EMQRevWEBs5ciRcXFzwxRdf2Csmu9NoNFCr1UhLS4Onp2eZ6spfqm1JcgraubliT/267EknIiKr2bJtsgWJ5L9r+UIR7ZrBYCivcErF2T5TIiKq2qxpl6y+R71///4YOXIkRowYgT59+iAgIKBAA96qVStrq62wpIKAPl5qLElOwS2dnkk6ERFVCtOmTXN0CERERFWW1Yl6/syvsbGx+Pbbb832iaIIQRCc/gq7rYUrlQCAy7m5yDQY4Sa1enl6IiIip5Gbm4s2bdqgYcOGqF27tqPDISIiqnKsTtSXL19ujzgqNF+5DDVkMiTp9Tidk4NH3VwdHRIREVGpyWQy9OjRA7/88gsTdSIiIgewetZ3rVaL9u3bo1GjRvaKqUIKVymRlJ6Bk0zUiYiogpNIJAgKCoJGo3F0KERERFWS1bO+v/HGG7h9+7a94qmw8oe/n8zOcXAkREREZTdy5EgsWbKkyt3ORkRE5AysHvpep04d09rl9J9wVV6ifiI728GREBERlZ2LiwvOnz+PRo0a4dlnny0weawgCHjrrbccGCEREVHlZfXybF9++SWWLVuGPXv2VNilTuyxXMvhrCw8cv4SfGRS3G7auMilbIiIiArjbEuJPbg8W2EqwuSxzvaZEhFR1WbX5dlOnz6N5ORkhISEoHPnzoVeYV+0aJH1UVdwjZVKSAAk6w1I0uvhL5c7OiQiIqJSu3LliqNDICIiqrKs7lHnFfaihZ05hwvaXPxaNxRdPT1sVi8RAQaDATqdztFhEFlNJpNBKpWWONKKvb+2x8+UyLmxbafKRC6XQyqVFlvGrj3qRqPR2kOqjHCVChe0uTiZk8NEnchGRFHErVu3kJqa6uhQiEpNKpXCz88ParXaqW+NunbtGgICAiAvYVRYeno6Dh06hM6dO1tU7969e/HRRx/hyJEjSExMxMaNG/Hcc89ZdOz+/fvRsWNHNG3aFMePH7foGCJybmzbqbLy8vKCv7+/Tdp6qxN1Klq4Uon1SOPM70Q2lN+Q+/n5wdXV1amTHKKHiaIIvV4PjUaDxMREZGdnIyAgwNFhFSk0NBQHDhzAo48+CiDv4nzDhg2xadMmNG7c2FTuzJkz6Nq1q8Uj6DIzM9G8eXMMHz4czz//vMXxpKWlYciQIYiMjERSUpJ1b4aInBbbdqpsRFFEVlaWaXU0W7T1FiXqe/fuRatWreDu7l5sueTkZGzZsgUjRowoc2AVUf7M70zUiWzDYDCYGnJvb29Hh0NUah4eHlAoFEhOToafn1+JQ+Mc5eG74URRxKVLl5CTU7Z2rXv37ujevbvVx40aNQoDBw6EVCrFpk2byhQDETkHtu1UWalUKgDA7du3bdLWW7SOekREBM6cOWN6bTQa4eLigmPHjpmV+/fff/HKK6+UKaCKLH8t9dM5OTBYd+s/ERUi/741V1dXB0dCVHZubm4QRZH3Y1po+fLl+PfffzFt2jSLj9FqtdBoNGYPInIubNupMsv/u7ZFW29Rol7YFXa9Xl9ge1VXR+EClSAgRxTxrzbX0eEQVRocEkeVAf+OLXfx4kW8//77WLVqFWQyy+/SmzNnDtRqtelRq1YtO0ZJRGXB/xOpMrLl37VFiTpZRioIaJI//L2MwwSJiIiqIoPBgIEDB2L69Olo0KCBVcdOnDgRaWlppsf169ftFCUREZF9cTI5GwtXKnE4KxsnsrPxvJfa0eEQERFZRaPR4O7duwAAvV5fYBuQN8mbvaSnp+Pw4cM4duwYXn/9dQB5t9yJogiZTIZff/21yNnmFQoFFAqF3WIjIiIqL+xRtzFOKEdEJREEwaLH7t27y3SeqKgomw8tFAQBUVFRNq2TnEu3bt3g6+sLX19f06y1kZGRpm2+vr6lmhjOUp6enjh58iSOHz9ueowePRphYWE4fvw4HnvsMbudm4iotCp62y4IAoYNG1bo/hkzZpjKxMfHF1qmT58+EATBdIH1Ybt37y72c4mNjbXNm6lELO5RP3/+vOk+sfzlWM6dO2dW5uHXVVH+hHIc+k7kvAyiiD8yMpGo0yFALkd7dzdIy/FeuQMHDpi9njlzJnbt2oWdO3eabX9wOazSePnll/HUU0+VqQ6qWqyZuM0aGRkZuHTpkun1lStXcPz4cVSvXh21a9fGxIkTcePGDcTFxUEikaBp06Zmx/v5+UGpVBbYTkSUj2172Xh4eGDt2rX4/PPP4eHhYdouiiJiY2Ph6elZ5ASdt2/fxk8//QQAWLVqFT7++GMo7+dED5s9ezYiIiIKbK9bt64N3kXlYnGiXtgVlsGDB5u9FkWxyk8M0ez+tPz/anORaTDCTcpBC0TOZENqGsYl3ETCA7NxBsnlWBQUiD7ldLvK448/bvba19cXEomkwPaHZWVlWTVLblBQEIKCgkoVI1VN9krUDx8+bPbFbPz48QCAoUOHIjY2FomJibh27Zpdzk1ElR/b9rLr1asX1q9fj++//95sFa+dO3fiypUreOWVV/D1118XemxcXBx0Oh2eeeYZbN26FRs2bMDAgQMLLVu/fv0SPxPKY1EWuXz5csTExJg9ittWlfnJZfCTySACOMNedSKnsiE1DX2vXDVryAHghk6HvleuYkOq/e67tVanTp3QtGlT7N27F23btoWrqytGjBgBAFizZg2efPJJBAQEQKVSoVGjRnj//feRmZlpVkdhw+NCQkLQo0cPbNu2Da1atYJKpULDhg3L9H/3qVOn0KtXL1SrVg1KpRItWrTAt99+a1bGaDRi1qxZCAsLg0qlgpeXF5o1a4ZFixaZyty5cwevvvoqatWqBYVCAV9fX7Rr1w6///57qWMj59CpUyeIoljgkT/UMTY2ttjhoFFRUTh+/Hi5xEpEFQvbdtu07Wq1Gr179y5wTExMDNq1a1fs5J4xMTGoUaMGvv32W6hUqiqfD9qKRT3qQ4cOtXcclUq4UokdGRk4mZODR9y4RiSRLYmiiCyj9UtDGkQRbyTcQGFHigAEAOMSbqKLu7vVQ+VcJYJdRhMlJibipZdewrvvvovZs2dDIsm7tnrx4kU8/fTTePPNN+Hm5oZz585h3rx5+PvvvwsMsSvMP//8g7fffhvvv/8+atSogW+++QYjR45EvXr10KFDB6tiPH/+PNq2bQs/Pz989tln8Pb2xsqVKzFs2DAkJSXh3XffBQDMnz8fUVFR+OCDD9ChQwfodDqcO3cOqampproGDx6Mo0eP4sMPP0SDBg2QmpqKo0ePIiUlxaqYiIio4ilN+862/T+2aNtHjhyJyMhInD17Fo0aNUJqaio2bNiApUuXFtkW//nnnzh79izeeecdeHt74/nnn8eqVatw5coVhIaGFihvNBpNE5U+yJqlOKsKfiJ2EK66n6hzQjkim8syinA/ccrm9YoAEnQ6qE+etvrYjGZN4Sa1fWN+9+5drF27tsAM1x988IHpuSiKaNeuHRo1aoSOHTvixIkTaNasWbH1JicnY//+/ahduzYAoEOHDtixYwe+++47qxP1qKgo5ObmYteuXaY1q59++mmkpqZi+vTpGDVqFNRqNfbv34/w8HCziei6detmVtf+/fvx8ssvmw2569Wrl1XxEBFRxWSP9p1tu3Vte0REBEJDQxETE4OPPvoI3333HWQyGV544QUsW7as0GOio6MBwDQyYOTIkVi5ciWWL1+OGTNmFCj/4osvFlrP9evXebveQ3gDtR1w5ncisoVq1aoVugzV5cuXMXDgQPj7+0MqlUIul6Njx44AgLNnz5ZYb4sWLUwNOQAolUo0aNAAV69etTrGnTt3IjIy0pSk5xs2bBiysrJMk+s8+uij+OeffzBmzBhs37690AlpHn30UcTGxmLWrFk4ePAgdA8NYyQiIqronLltz5/5fcWKFdDr9YiOjka/fv3g7u5eaPmMjAz88MMPaNu2LRo2bAgA6NixI+rWrYvY2FgYjcYCx8ybNw+HDh0q8KhRo4bFcVYV7FG3A878TmQ/rhIBGc2sn/l5b0YGnr4cX2K5n+uEoEMRDVJxMdlD/tJYD8rIyED79u2hVCoxa9YsNGjQAK6urrh+/Tr69OmD7OzsEuv19vYusE2hUFh07MNSUlIKjTMwMNC0HwAmTpwINzc3rFy5EsuWLYNUKkWHDh0wb948tG7dGkDe/XmzZs3CN998gylTpsDd3R29e/fG/Pnz4e/vb3VsRERUcZSmfWfb/h9bte3Dhw/H9OnTMXv2bBw9ehSff/55kWXXrFmDjIwM9OvXz+xWtn79+mHOnDn47bffCoyeq1Onjqndp+IxUbeDJiolBAC39Xrc1unhJ+fHTGQrgiCUaijak54eCJLLcUOnK/ReNgF5M8Q+6elRrsu5FKewe+N27tyJmzdvYvfu3aYr7QDMGsjy5O3tjcTExALbb968CQDw8fEBkHfv2fjx4zF+/Hikpqbi999/x6RJk9CtWzdcv34drq6u8PHxwcKFC7Fw4UJcu3YNW7Zswfvvv4/bt29j27Zt5fq+iIiofJWmfWfbbnu1atVCly5dMH36dISFhaFt27ZFls0f9v7mm2/izTffLHT/w4k6WY5D3+3AVSJBXYULAOBkjvU9VERke1JBwKKgvF7eh5vI/NcLgwKdpiEvSn4Dr1AozLZ/+eWXjggHkZGRpi8YD4qLi4Orq2uhS7B4eXmhb9++eO2113D37l3Ex8cXKFO7dm28/vrr6Nq1K44ePWqv8KkEWq0WX375JQYMGICuXbvi4sWLAIDNmzfj8uXLDo6OiKo6tu328fbbb6Nnz56YMmVKkWXOnj2LAwcO4Pnnn8euXbsKPCIjI7F582ZOCFsG7Oq1k3ClEpe0uTiRnYNIDw9Hh0NEAPp4qbEuNLjQtVYXluNaq2XRtm1bVKtWDaNHj8a0adMgl8uxatUq/PPPPw6JZ9q0afjpp58QERGBqVOnonr16li1ahW2bt2K+fPnQ63O+0x79uyJpk2bonXr1vD19cXVq1excOFCBAcHo379+khLS0NERAQGDhyIhg0bwsPDA4cOHcK2bdvQp08fh7y3qi45ORkRERE4ffo0/P39kZSUhPT0dADApk2bsH37dixdutTBURJRVce23faefPJJPPnkk8WWye9Nf/fdd/Hoo48W2J+eno4dO3Zg5cqVGDdunGn7xYsXcfDgwQLl7bU+fEVmUaK+d+9eqyq1dtbgyihcpcTGNA0nlCNyMn281Oil9sQfGZlI1OkQIJejvbub019tz+ft7Y2tW7fi7bffxksvvQQ3Nzf06tULa9asQatWrco9nrCwMPz555+YNGkSXnvtNWRnZ6NRo0ZYvnw5hg0bZioXERGB9evX45tvvoFGo4G/vz+6du2KKVOmQC6XQ6lU4rHHHsOKFSsQHx8PnU6H2rVr47333jMt8Ubl691330VqaioOHz6MZs2awcXFxbQvIiIC8+bNc2B0RET/YdtevnQ6HVasWIEWLVoUmqQDeSvABAUFITo62ixRnzRpUqHlJ0+ejFmzZtkl3opKEEWxxAULJRKJaUiGKIolriloMBhsE52daDQaqNVqpKWlwdPT0y7nWHcvFS/EX0NrVxUOhdW3yzmIKrucnBzTOpzK+5M0ElVUJf09l0fbZA0/Pz/MmzcPw4cPh8FggFwux+HDh9GqVSvs3LkTvXv3RlpamqPDLJazfaZExLadKjdbtvUW9ajv2rXL9Dw9PR2vv/46wsLCTEsI3Lp1C6tWrcL58+exZMkSK99O5dRMpQIAnM7OgUEUK8wVPSIiIiDvy0RwcHCh+3Q6HfR6fTlHREREVHVYlKg/OPvgmDFj0KFDB8TFxZmVGTp0KAYPHowff/wRPXr0sG2UFVBdhQtUgoBsUcRlbS7qKxUlH0REROQkQkNDceDAgULX+/37778RFhbmgKiIiIiqBqtnfV+7di0GDRpU6L5BgwZhw4YNZQ6qMpAKAhpzPXUiIqqgBg0ahHnz5mHz5s3Iv0tOEAQcOnQIixYtwuDBgx0cIRERUeVldaKelZWF27dvF7ovKSkJWVlZZQ6qsghX3U/UOaEcERFVMO+99x7atWuH3r17o0aNGgCAbt264fHHH8djjz1mNjkQERER2ZbVy7O1b98ekydPRsuWLdG0aVPT9pMnT+KDDz5A+/btbRpgRWZK1NmjTkREFYxcLsfPP/+MNWvWYOvWrUhKSoKPjw969OiB/v37QyKx+lo/ERERWcjqRH3RokXo0KEDWrRogSZNmpgmkzt9+jS8vb2xaNEie8RZIYXnD33PznZwJERERNYTBAH9+/dH//79HR0KERFRlWL15fCwsDCcPHkSEyZMgEqlwuXLl6FSqfDOO+/gxIkTnFzmAfk96pe0ucgyGh0cDRERkeWkUin+/vvvQvcdOXIEUqm0nCMiIiKqOqzuUQfy1ladO3eurWOpdGrIZPCRSZGsN+BMTg5au7o6OiQiIiKL5E8gVxij0QiBy44SERHZTalvMEtLS8P27duxatUq3Lt3z5YxVRqCIDww/J33qRMRUcVSVDJ+5MgRqNXqco6GiIio6ihVj/rMmTMxd+5cZGdnm5ZqqVatGiIjI9G1a1e8//77to6zwgpXKbErI5OJOhEROb1FixaZ5poRBAHPPfccFAqFWZns7Gzcvn0bffv2dUSIREREVYLVPepLly7F9OnTMXLkSGzdutVsaFyPHj2wdetWmwZY0YVzLXUiekjv3r2hUqmQmppaZJlBgwZBLpcjKSnJ4noFQUBUVJTp9e7duyEIAnbv3l3iscOGDUNISIjF53rQ0qVLERsbW2B7fHw8BEEodJ+9RUVFcWh2Kfj5+aFJkyZo0qQJRFFEnTp1TK/zH+3atcPUqVPx5ZdfOjpcIiKnwbbd/vLbdolEgsuXLxfYn5mZCU9PTwiCgGHDhhVax8mTJyEIAuRyORITEwst06lTJwiCUOijtJ9naVjdo7548WKMHz8e8+fPh8FgMNtXv359XLx40WbBVQbNVCoAHPpO5Ay0CWnQ3y16FQZZdRUUQfYfzjty5Ehs2rQJ3333HcaMGVNgf1paGjZu3IgePXqY1q8ujVatWuHAgQNo3LhxWcIt0dKlS+Hj41OgUQwICMCBAwdQt25du56fbGfAgAEYMGAAACAiIgJffPEFGjZs6OCoiIiKxrbdPpy5bXd3d8fy5csxc+ZMs+1r166FTqeDXC4v8thvvvkGAKDX6xEXF4f33nuv0HJ16tTBqlWrCmx/eJSZPVmdqF++fBndunUrdJ+Hh0exV5GqoiZKJQQASXo97uj08JWX6m4DIiojbUIajrdZBlFrKLKMoJCixYHRdm/Qu3fvjsDAQMTExBTamK9evRrZ2dkYOXJkmc7j6emJxx9/vEx1lIVCoXDo+alsdu3a5egQiIiKxba9/DlD2/7iiy/i22+/xfTp0yGR/DdAPDo6Gr1798aWLVsKPU6r1WLVqlVo3rw5kpOTERMTU2SirlKpHP4+rR76rlarixyuER8fDz8/P6vqyx/C8ODD39+/2GP27NmD//3vf1AqlahTpw6WLVtm1TnLk5tUgjouLgA4/J3IkfR3s4ttyAFA1BqKvSpvK1KpFEOHDsWRI0dw8uTJAvuXL1+OgIAAdO/eHXfu3MGYMWPQuHFjuLu7w8/PD507d8Yff/xR4nmKGh4XGxuLsLAwKBQKNGrUCHFxcYUeP336dDz22GOoXr06PD090apVK0RHR5vd8hQSEoLTp09jz549BYaFFTU8bt++fYiMjISHhwdcXV3Rtm3bArdNxcbGQhAE7Nq1C//3f/8HHx8feHt7o0+fPrh582aJ770wRqMR8+fPR8OGDaFQKODn54chQ4YgISHBrNyxY8fQo0cP+Pn5QaFQIDAwEM8884xZubVr1+Kxxx6DWq2Gq6sr6tSpgxEjRpQqLme1d+/eEh9ERI7Etv0/ValtHzFiBK5fv47ffvvNtO3ChQvYt29fsW3xpk2bkJKSgpdffhlDhw41HeOsrO7ejYyMxPz589GrVy8o799/LQgC9Ho9vvjiiyJ724vTpEkT/P7776bXxa3NeuXKFTz99NN45ZVXsHLlSuzfvx9jxoyBr68vnn/+eavPXR7CVUr8m5uLk9k56Ozh7uhwiCo0URRhzNJZfZwh27JjDNk6GDJzrapb4iq3+n7oESNGYO7cuYiJicGCBQtM28+cOYO///4b77//PqRSKe7evQsAmDZtGvz9/ZGRkYGNGzeiU6dO2LFjBzp16mTVeWNjYzF8+HD06tULn3zyCdLS0hAVFQWtVmt2VRrIa4xHjRqF2rVrAwAOHjyIsWPH4saNG5g6dSoAYOPGjejbty/UajWWLl0KoPhhYXv27EHXrl3RrFkzREdHQ6FQYOnSpejZsydWr16NF1980az8yy+/jGeeeQbfffcdrl+/jnfeeQcvvfQSdu7cadX7BoD/+7//w1dffYXXX38dPXr0QHx8PKZMmYLdu3fj6NGj8PHxQWZmJrp27YrQ0FAsWbIENWrUwK1bt7Br1y6kp6cDAA4cOIAXX3wRL774IqKioqBUKnH16tVSxeTM8u/RK87Dt8AREZVWadp3tu15qlrbXr9+fbRv3x4xMTGm3DMmJgYhISGIjIws8rj82AYNGoS7d+9izpw5iI6OxhNPPFFoeb1eX2CbRCIp8Jnai9WJ+vTp0/Hoo4+icePG6N27NwRBwOLFi3Hs2DFcu3YNP/zwg/VByGQl9qLnW7ZsGWrXro2FCxcCABo1aoTDhw/j448/dupEfVOaBidz7H81j6iyM2bpcCj0Y7vVf6bnCquPeeTKBEjdXKw6pl69eujQoQNWrlyJ+fPnm+6niomJAQDTFeGwsDBTIwnkJUbdunVDfHw8PvvsM6sac6PRiMmTJ6NVq1bYuHGj6QvIE088gfr16yMwMNCs/PLly82O7dSpE0RRxKJFizBlyhQIgoCWLVtCpVJZPBTv/fffR7Vq1bB79264u+dduOzRowdatGiBCRMmoF+/fmZfjJ566il89tlnptd3797Fu+++i1u3blncbgDAuXPn8NVXX2HMmDH4/PPPTdtbtmyJxx57DAsWLMCHH36Ic+fOISUlBdHR0ejVq5epXL9+/UzP//zzT4iiiGXLlpktUVbUxDUVVWFD35OTk7F582bs378fS5YscUBURFRZ2bN9Z9v+n8rSto8YMQKjR4/G3bt3oVarERcXh1GjRhV5ceXq1avYsWMH+vXrh2rVqqFatWro0KED1q5di88++wweHh5m5U+fPl3ove4jR4403edub1ZfDqhfvz7+/PNPNGrUCEuXLoUoioiLi4OPjw/++OMP09UZa1y8eBGBgYEIDQ1F//79C53FL9+BAwfw5JNPmm3r1q0bDh8+DJ2u8KtqWq0WGo3G7FGeuJY6ERVm5MiRSE5ONt1LpdfrsXLlSrRv3x7169c3lVu2bBlatWoFpVIJmUwGuVyOHTt24OzZs1ad7/z587h58yYGDhxo1pAFBwejbdu2Bcrv3LkTXbp0gVqthlQqhVwux9SpU5GSkoLbt29b/X4zMzPx119/oW/fvqaGHMgbRTV48GAkJCTg/PnzZsc8++yzZq+bNWsGIK/BtUZ+0vlwMv3oo4+iUaNG2LFjB4C8L1nVqlXDe++9h2XLluHMmTMF6nrkkUcA5CXvP/zwA27cuGFVLBVFx44dCzyef/55xMXFoWvXrti2bZujQyQicjps2/PYu21/4YUX4OLiglWrVuHnn3/GrVu3ir1gvnz5chiNRrOh8SNGjEBmZibWrFlToHzdunVx6NChAo8pU6ZYHGNZWdWjnpOTg7i4OLRv3x7btm2DVqtFSkoKqlWrBtX92c2t9dhjjyEuLg4NGjRAUlISZs2ahbZt2+L06dPw9vYuUP7WrVsFZkqsUaMG9Ho9kpOTERAQUOCYOXPmYPr06aWKzxbCVXmJ+qmcHBhFERIuGURUahJXOR65MsHq4zJPJVl0Rb3xj4Ph1tS62VglrkXPLlqcvn37YuzYsVi+fDmef/55/Pzzz0hKSsK8efNMZT799FO8/fbbGD16NGbOnAkfHx9IpVJMmTLF6sY8JSUFAAq9Wu3v74/4+HjT67///htPPvkkOnXqhK+//hpBQUFwcXHBpk2b8OGHHyI72/oRQvfu3YMoioX+P51/xT8/xnwPtwP5Q++sPX9+vUWdO//LgVqtxp49e/Dhhx9i0qRJuHfvHgICAvDKK6/ggw8+gFwuR4cOHbBp0yZ89tlnGDJkCLRaLZo0aYLJkyebZkyv7Hr37o2hQ4eaRrcREZVVadp3tu1Vt213c3PDiy++iJiYGAQHB6NLly4IDg4utKzRaERsbCwCAwPxv//9zzT5eZcuXeDm5obo6Gi8/PLLZscolUq0bt3a4njswapEXalU4o033sD27dvRqFEj0yQ7ZdG9e3fT8/DwcLRp0wZ169bFt99+i/Hjxxd6zMNDGvInPyhqqMPEiRPN6tJoNKhVq1aZ4rZGPYUCCkFAllHE5dxc1CvHaf2JKhtBEKweigYAUpVlDa5UJS9V/aWhUqkwYMAAfP3110hMTERMTAw8PDzwwgsvmMqsXLkSnTp1whdffGF2bP790tbIbxhv3bpVYN/D277//nvI5XL89NNPpvlIgLyJWEqrWrVqkEgkha5bmj+JjI+PT6nrL07+e09MTERQUFCBcz943vDwcHz//fcQRREnTpxAbGwsZsyYAZVKhffffx8A0KtXL/Tq1QtarRYHDx7EnDlzMHDgQISEhKBNmzZ2eQ/O5N69e9BqtY4Og4gqkdK072zbq3bbPmLECHzzzTc4ceJEoUup5fv9999NF+QL6wg+ePAgzpw5Y/cl76xl9dD3OnXqFPqHYCtubm4IDw8vcj12f3//Aue/ffs2ZDJZoR88kHeVxtPT0+xRnmSCgMbKvOScw9+J6EEjR46EwWDARx99hJ9//hn9+/eHq6urab8gCAUmcDlx4gQOHDhg9bnCwsIQEBCA1atXm83uevXqVfz5559mZQVBgEwmM5vcMzs7GytWFOy5UCgUFl0Fd3Nzw2OPPYYNGzaYlTcajVi5ciWCgoLQoEEDq9+XJTp37gwg78vRgw4dOoSzZ88WOvmMIAho3rw5FixYAC8vLxw9erRAGYVCgY4dO5p6So4dO2aH6B3j2rVrBR4XL17E+vXrMXHiRIcvW0NE5KzYtpdP296mTRuMGDECvXv3Ru/evYssFx0dDYlEgk2bNmHXrl1mj/z3nj+PgDOxejK5cePGYe7cuejevbtdEl6tVouzZ8+iffv2he5v06YNfvzxR7Ntv/76K1q3bl3s4vaOFq5S4Vh2Dk5m56C3l33XcSSigmTVVRAU0hLXWpVVL91tPKXVunVrNGvWDAsXLoQoigXWV+3RowdmzpyJadOmoWPHjjh//jxmzJiB0NDQQmcjLY5EIsHMmTPx8ssvo3fv3njllVeQmpqKqKioAkPmnnnmGXz66acYOHAgXn31VaSkpODjjz8udNbX/B7oNWvWoE6dOlAqlQgPDy80hjlz5qBr166IiIjAhAkT4OLigqVLl+LUqVNYvXq11TPsWiosLAyvvvoqPv/8c0gkEnTv3t0063utWrXw1ltvAQB++uknLF26FM899xzq1KkDURSxYcMGpKamomvXrgCAqVOnIiEhAZGRkQgKCkJqaioWLVoEuVyOjh072iV+RwgJCSn09yGKIsLCwrB48WIHREVE9B+27VW7bQfykvDipKSkYPPmzejWrZvZJLEPWrBgAeLi4jBnzhxTPpmdnY2DBw8WWr68LlRbnaifPn0aycnJCAkJQefOnREQEGD24QuCgEWLFllc34QJE9CzZ0/Url0bt2/fxqxZs6DRaDB06FAAecPWb9y4YVoLcPTo0Vi8eDHGjx+PV155BQcOHEB0dDRWr15t7VspV6YJ5biWOpFDKILUaHFgdLFrqcqqq6AIKv8LaSNHjsS4cePQuHFjPPbYY2b7Jk+ejKysLERHR2P+/Plo3Lgxli1bho0bNxZYQ9XScwHAvHnz0KdPH4SEhGDSpEnYs2ePWX2dO3dGTEwM5s2bh549e6JmzZp45ZVX4OfnV+ALx/Tp05GYmIhXXnkF6enpCA4ONrsn7kEdO3bEzp07MW3aNAwbNgxGoxHNmzfHli1b0KNHD6vfjzW++OIL1K1bF9HR0ViyZAnUajWeeuopzJkzxzQiq379+vDy8sL8+fNx8+ZNuLi4ICwsDLGxsaZ26bHHHsPhw4fx3nvv4c6dO/Dy8kLr1q2xc+dONGnSxK7voTzFxMQU+HKlVCoREhKCRx55pNyWpyEiKgrb9v/OBVTNtr0kK1euhFarxahRo4os8+qrr2L06NH48ccf0adPHwDA5cuXi7yVTafTQSazOo22miA+OEbCAiU1zIIgWLWuav/+/bF3714kJyfD19cXjz/+OGbOnGm6R2DYsGGIj483+yPbs2cP3nrrLZw+fRqBgYF47733MHr0aIvPqdFooFarkZaWVm7D4H/VpKPbv1cQplDgXOOwcjknUUWXk5ODK1euIDQ01OxeKqKKqKS/Z0e0TZUdP1Mi58O2nSozW7b1Vl8KMBqN1h5SrO+//77Y/bGxsQW2dezYsdB7BZ1Z/szvF7VaZBuNULEngoiIiIiIiAph/z57AgD4y2TwlkqRYjDgbE4OWj0woQQREZEzeHB92ZIIglDivYFERERUOkzUy4kgCAhXKbE7IxMns5moExGR89m5c6fFk/7Yc3IgIiKiqq5UifrKlSuxcOFCnD17FjmFTI5mzT3qVYkpUeeEckRE5ISKmiiIiIiIypfVN0pv2bIFw4cPR8uWLZGdnY3hw4djwIABcHNzQ/369TF16lR7xFkpmGZ+51rqREREREREVASre9Tnzp2L8ePHY/bs2YiOjsaYMWPQqlUr3Lp1C+3bt0etWrXsEWelkD+h3Akm6kRWsXJxCiKnVFH/jnfs2IEdO3YgJSUFPj4+iIyMROfOnR0dFhFVcBX1/0Si4tjy79rqRP38+fOYPn266d40vV4PAPD398cHH3yAjz76yKrJaKqSJvd71G/p9UjW6+FTDuvvEVVk+WtU5v8/Q1SR6XQ6AIBUKnVwJJbJzc3F888/j59//hmiKEImk0Gv12Pu3Ll45plnsH79esjlckeHSUQVDNt2qszy/65tsc661UPfDQYDXFxcIJFI4Obmhlu3bpn21a5dG5cvXy5zUJWVh1SKUBcXABz+TmQJqVQKqVQKjUbj6FCIykQURaSlpUGhUFSY5HbGjBnYvn075s6di6SkJOTm5iIpKQnz5s3D9u3bMWPGDEeHSEQVENt2qsw0Go3pb7ysrE71Q0NDcfPmTQBA8+bNsXr1ajz77LMAgHXr1iEgIKDMQVVm4SolruTm4mR2DiI83B0dDpFTEwQBfn5+SExMhEKhgJubG2eapgpFFEXodDqkpaUhIyMDNWvWdHRIFlu9ejUmTZqEd955x7TN19cXEyZMQEZGBuLi4jBz5kwHRkhEFRHbdqqMRFFEZmYmNBoNAgICbPI3bXWiHhkZid9//x0DBgzAuHHj8OKLL+LQoUNwcXHB+fPnMXfu3DIHVZmFK5XYkqbhzO9EFlKr1cjOzkZycjLu3Lnj6HCISkWhUKBmzZrw9PR0dCgWS0hIQPv27Qvd1759e8yZM6ecIyKiyoJtO1VGgiDAy8sLarXaJvVZnah/+OGH0Gq1AIAXXngBUqkUq1atgiAIePfddzFs2DCbBFZZNVNx5nciawiCgICAAPj5+Znu8SWqSKRSaYUZ7v4gX19fnDx5EpGRkQX2nTx5Er6+vg6IiogqA7btVBnJ5XKbzkNjdaKuUCigUChMr/v06YM+ffrYLKDKLn/m91M5OTCKIiQc6kNkEVvd70NElnn22WcxdepU1K5d26yd37x5M6KiojBo0CAHRkdElQHbdqKicdrxclZfoYBCEJBpNCI+Nxd1HrjoQURE5Cw+/PBD7N+/Hy+88ALc3Nzg7++PpKQkZGRkIDw8HB9++KGjQyQiIqq0rE7US1o7VRAE7Nixo9QBVXYyQUAjpQLHs3NwMjuHiToRETmlatWq4e+//0ZsbCx27dqFlJQUtGrVCpGRkRgyZIjZ6DoiIiKyLasTdaPRWGAWu+TkZJw/fx5+fn5o0KCBzYKrrMKVyrxEPScHvWCbyQaIiIhsTaFQYNSoURg1apSjQyEiIqpSrE7Ud+/eXej2CxcuoFevXpg2bVpZY6r0wlVK4B4nlCMiIueVk5OD3Nxcs5nqf/jhBxw9ehRdunRBly5dHBgdERFR5SaxVUUNGjTAO++8g3fffddWVVZa4SoVAOAEE3UiInJSgwcPxhtvvGF6/dlnn6F///6YP38+unXrhp9//tmB0REREVVuNkvUASAkJASnTp2yZZWVUrgyb+b3i1otcoxGB0dDRERU0N9//42nnnrK9Pqzzz7DSy+9hNTUVPTp0wcff/yxA6MjIiKq3GyaqK9fvx6BgYG2rLJSCpTLUE0qhQHA2Ryto8MhIiIq4M6dO6hZsyYA4MqVK7h8+TLGjh0LT09PjBw50qoL83v37kXPnj0RGBgIQRCwadOmYsvv27cP7dq1g7e3N1QqFRo2bIgFCxaU5e0QERFVKFbfoz5ixIgC27RaLU6cOIEzZ85g/vz5NgmsMhMEAeEqJfZmZOJkdg5auqocHRIREZEZV1dXpKWlAQD++OMPuLu7o3Xr1gAApVKJjIwMi+vKzMxE8+bNMXz4cDz//PMllndzc8Prr7+OZs2awc3NDfv27cOoUaPg5uaGV199tXRviIiIqAKxOlHfuXNngVnflUolQkJCMHHiRAwcONBmwVVm4cr7iXpONoBqjg6HiIjITHh4OJYsWYLg4GAsXboUERERpvb/2rVr8Pf3t7iu7t27o3v37haXb9myJVq2bGl6HRISgg0bNuCPP/5gok5ERFWC1Yl6fHy8HcKoepqp8u5T58zvRETkjKZMmYIePXqgRYsWcHFxwe+//27at3XrVrRq1arcYjl27Bj+/PNPzJo1q9hyWq0WWu1/t5RpNBp7h0ZERGQXVifqZBvh+Yl6DhN1IiJyPp07d8bZs2dx5MgRtGjRAnXq1DHb16JFC7vHEBQUhDt37kCv1yMqKgovv/xyseXnzJmD6dOn2z0uIiIie7M6Ud+7d69V5Tt06GDtKaqEpvdnfr+p0+OuXo/qMl4zISIi5xIcHIzg4OAC20eNGlUu5//jjz+QkZGBgwcP4v3330e9evUwYMCAIstPnDgR48ePN73WaDSoVatWeYRKRERkU1Znh506dSpwj/qDRFGEIAimnwaDoUwBVlYeUilCXOSIz9XhZHYOOnq4OzokIiIiMwaDAT/88AN27dqFlJQUeHt7IyIiAi+88AJk5XCBOTQ0FEDe/fJJSUmIiooqNlFXKBRQKBQ2j8MgivgjIxOJOh0C5HK0d3eDtJjvQkRERGVldSu7ZcsWvP766wgLC8PAgQPh7++PW7duYdWqVbhw4QI+//xzeHp62iPWSidcqcxL1HOYqBMRkXNJTk7GU089haNHj0Imk8Hb2xspKSn45ptv8PHHH2P79u3w8fEpt3hEUTS7/7y8bEhNw7iEm0jQ6UzbguRyLAoKRB8vdbnHQ0REVYPVifrPP/+MDh06IC4uzmz70KFDMXjwYPz000/48ssvbRZgZRauUuFHTTpOcEI5IiJyMm+99RbOnz+PVatWoV+/fpBKpTAYDFizZg1Gjx6Nt956CytWrLCoroyMDFy6dMn0+sqVKzh+/DiqV6+O2rVrY+LEibhx44bpu8WSJUtQu3ZtNGzYEEDeuuoff/wxxo4da/s3WowNqWnoe+UqxIe239Dp0PfKVawLDS5Vss4eeiIiKonVifratWuxcuXKQvcNGjQIgwcPZqJuoXDO/E5ERE7qxx9/xKxZs8yGmkulUgwcOBC3b99GVFSUxXUdPnwYERERptf595EPHToUsbGxSExMxLVr10z7jUYjJk6ciCtXrkAmk6Fu3bqYO3duud0bD+Ql0+MSbhZI0gFABCAAeDPhJnqpPa1KstlDT0RElrA6Uc/KysLt27cL3ZeUlISsrKwyB1VVhN+fUO5UTg6MoggJr6YTEZGTEEURTZo0KXRf06ZNIYqFpbCF69SpU7HlY2NjzV6PHTu23HvPH/ZHRqZZMv0wEcB1nQ6TbyYi0sMDgXI5asrlUEslRc7lY68eeiIiqnysTtTbt2+PyZMno2XLlmjatKlp+8mTJ/HBBx+gffv2Ng2wMmugVEAuCMgwGnE1V4dQhYujQyIiIgIAdOnSBb///ju6dOlSYN9vv/2GTp06lX9Q5SixmCT9QfNuJ2Pe7WTTa5Ug5CXtLnIEymSm5/4yGd68YfseeiIiqpysTtQXLVqEDh06oEWLFmjSpIlpMrnTp0/D29sbixYtskeclZJcENBIocCJnByczMlmok5ERA519+5d0/MpU6agT58+MBgMBSaP3bBhAzZs2ODASO0vQC63qFxrlRI5InBTp8NdgwHZooh/c3Pxb26uVefL76H/IyMTnaycYJb3vBMRVT6CaM3Ytftu376NTz/9FLt37zZbruXNN99EjRo17BGnTWk0GqjVaqSlpTl8hvqX4q9h1b1UzAqogcn+zv/ZERGRfThD2ySRmA/bzv+KUNQ2Z1+CtSyfqUEUEXL6HG7odIX2ggvIu7f8SpOGpqQ422hEok6HGzo9bup0uKnT4YZOh5s6PY5nZeOsBbPW11e4oLunBx51dcUjrq6op3Ap9tY43vNORFRxWNMulWoRVD8/P8ydO7dUwZG5ZiolVt3jhHJEROR4U6dOLfL+6qpGKghYFBSIvleuQgDMkvX8T2hhUKBZz7VKIkEdhQJ1ClnLfXd6BiIuXS7xvBe1ubh4JwVACgBALZWgtcoVj7ip8IirKx5xVSFILocgCHa955299EREjlWqRP1BZ8+exenTpxEYGIi2bdvaIqYqJX9CuZM5TNSJiMixrJnJvSro46XGutDgQnusF1rZY93e3Q1BcnmxPfQ1ZDLMC/THkexsHMrKxrGsbKQZjNiRkYEdGRmmsjVkMrRWKfFHZpZd7nlnLz0RkeNZlKhv2rQJv/76K5YuXWq2fezYsWbbIiIisHXrVigKuZJMhctfou18jhZaoxEKicTBERERERXNaDRi69atiImJwcaNGx0djt318VKjl9qzzL3LlvTQL6lVE3281Bhy/7VOFHE6OweHsrJwKCsbh7KycDI7B0l6PbamZ6A4+fe8z0pMwhMebqgulaGaVIpqMik8JeU/Mz176J0PfydEzs2iRD02NhbyhyZV+emnn7BkyRI0btwYr776Ks6cOYOvvvoKCxYswPvvv2+XYCujmnI5vKRSpBoMOJejRXNXlaNDIiIiKuDChQuIiYlBXFwcbt26BVdXV0eHVG6kgmD1BG+FsbaHXi4IaOGqQgtXFV65vy3baMTx7Gwsu5OCuHupJZ4zKuk2kGS+TQKYkvZqUimqS/N+qqVSfHcvtUKsHW/rJLOqJa0cNUHk/CxK1I8fP44pU6aYbVuxYgVcXFywbds2BAUFAcibYGbt2rVM1K0gCALClUr8kZmJkzk5TNSJiMhpZGVl4YcffkBMTAz2798PAGjcuDEmTZqEwYMHOzi6iqmsPfQqiQRt3NygNYoWJepNlQoYAdzTG3DXYIBWFGEEkGIwIMXKyQDze+nbX7iEZipV3hJ099ePrynPW4quulRq1ltvjx56WyeZFeFCgi3rtOfcBrZUES6eVMULRs4eY2X6nViUqN+5cwd16tQx27Zz5060adPGlKQDQI8ePbB69WrbRlgFhKvyEvUTnFCOiIicwMGDBxETE4M1a9YgPT0dHh4eGDhwIL777jssWbIEHTp0cHSIFZoteugtuec9SC7H8YYNzL5UZhuNuGcwmBL3ewa96fkfGZnYmKYp8dwHsrJxICu70H2K/HXk5TIEyGT4JT3Dpj30tk4yK8KFBFvWaRBFjEu4aZe5DWyZ0Nirx9+ZY6wIF4ycPcaK8DuxhkWJulKphPaBJUWuXr2KlJQUPProo2blqlWrBt0Db4Qsk3+fOmd+JyIiR/r0008RHR2Nc+fOQRRFPPHEExg5ciReeOEF5ObmYtWqVY4Oke4rzaz0QF6PvEoiQWAh68S3VKksStTf8vWBh1RiWnruRq4ON/U6JOvzeuyv5ObiigXryOf30Dc9ex6hCgW8pVJ4y2Twlkn/e/7ANi+J1KZJpj2SVnsl/qWpM9doRIrBgGS9Hin6vJ9/ZmaZJR0Py/+dbExNQx8vdbFLAz4co60SGnv1+DtzjBXhgpGzx1gRfifWsihRr1u3Lvbs2YOnnnoKAPDrr79CEAS0a9fOrFxiYiJ8fX1tH2Ulx5nfiYjIGUyYMAGCIOCZZ57BggULULduXdM+Xoh3PraclR6wvJf+o5oBhSauWqMRN++vIX9Dp8NPaRqssGB4/jltLs5pS07sS5KfZDY5ex6uEgl0IqAXRegh5v184LVOFKE1isgRC3un5vX5nTgNT5kULoIAhSDJ+ykR7r/O++kikUAOYEuapsjEHwBGXr2OeK0WLhIJZIIAGQCZIEAuCHmvH9gmEwQIEDH6WkKxdQ69eh3r7qXinsGIZIPelJinG42l/ixfiL8GuSCgplyG2i4uqC2Xo5aLvMBztVRa5oRGL4rIMBiRbjQgVW/A/10v/v2+dv0GWqtUqC6Twq2YiREfZMuky9YXeCrCBSNnj9GW8RlFEVqjEW8k3LDLyBNrWJSojxw5EuPGjYNKpYK/vz+ioqLg4+ODbt26mZXbs2cPwsLC7BJoZdb0fo/6DZ0O9/R6VJOVedU8IiIiq7Vo0QLHjx/H1q1bkZSUhBEjRmDAgAHw9PR0dGhUBFvNSg+Uvpc+n0IiQajCBaEKFwCAn0xmUaI+078GAl3kSLmfYKYYDHnP83/e36YrJql+0HkbJP0Pums04m5u6ZPeB6UajXj75i2b1JUvw2jE6tS0QvdJAFSXSeEjlcFHJoUIYH9mVol1SpC36kB8rg7xuUVfpHMXBOSIYrGJ9ZD4a1jt6YEMo4h0owHpBiMyjEbT8+IulhTmll6P4DPnAABSAOr7EyGqpZL/nkv+e+4hETDv9p1iY3zlWgJu5uYiF3m3h2QbReSIeT+zjXkx5m034pZOb9GohHqnz8FTKoVUyPu3JYNgei7Ffz/TDAaL6nv/ZiJau7rCXSKBh1QCd4kE7hKp6bmbRAKJIFictPb09EC2KCLVYECawYBUg/H+T8MDP41INRhwMUdrUYzhZy/ARyaDXBAgFwCX+xehHny43H/fccVMXAnkXYD6XZMOI3D/4tr9C235D/z3+o6FvxP/k2cgEwQYkHfhziCKMNyvx3C/Tkvk1/dHRqZNJhotiiCKJf/r0Ov1eOmll/DDDz8AALy8vPDdd9+ZetgBIDMzE8HBwXj77bcxceJEuwVsCxqNBmq1GmlpaU7z5SP41Flc0+mwp34ddHC33y+ciIick7O0Tf/88w++/vprrF69Gvfu3YNKpcLzzz+P559/Hr1798bu3bsrzD3qzvKZVjSFDUetVYpeeoMoIuT0uRJ76K80aVjihQVRFPGLJh3PXI4v8byzA2qgpasrZIB5T7UAyCCYerAPZ2Vh0NXrJdb3Va2aaKZSIfd+T1uuKEIrivdfi8gV87YdyMzCSgsuTLR1c0WQXA69mNez/2DCoRfxwAgAEcl6A65bMJploJcXunq6w1uWl5D7SO/fLiCVmg1ft/R3crFxGG7r9biWq8N1nQ7XcnPNnl/P1Vk9GWFJ5IIAFwCZFiTuD19IojyuEgEKCLhXhtEUZLnvgmthQPVqVh1jTbtkUaKeLz4+HikpKWjUqFGBZVkyMjJw/vx51KtXD2q142eKLI4zNtw9/r2CrZp0LA4KxGu+Po4Oh4iIypmztU1arRbr169HdHQ0du/ebdr++uuvY+LEifD393dccBZyts+0IrH1DONA4T301g5vtVXib4/6dqdnIOLS5RLL7apXx+JeOHvUaavfSabBiGXJyZhgwQiBodW90MndHR5SKTwe6BH2uN8j7CGRwEUisfj97qwbikfd3JBmNO/9TbvfG5z2wOvj2dnYZ8EogkdUKjRQKqCSSKAUhPvzOQhQCnk/VRIJVIIE/2q1mJF0u8T6PgkMQLhKCQPy/tb093tvDQ/+FIFTOdn46HZyifU97qqCUiLJG41wf1RCxv1RCWVJy+WCAC+pBF73RyD891MCtSTv+R29HouTU0qsa6Z/DTRUKpB7/yJU3gMPvRZxLCsbmzQlz4fRW+2Jlq6q+xfY8MDtIXmv8y/EXcjRYqYFv5NltQLxuGve/2UyAZDev3AnvV+3FHk/D2RkoeeV+BLrs+bfXT67Jer2NmfOHEyaNAnjxo3DwoULiyy3atUqzJ8/HxcvXoRarcZTTz2Fjz/+GN7e3hadxxkb7kk3EzEn6Q5GeVfHstpBJR9ARESVijO2Tfni4+MRHR2Nb7/9FgkJCZDL5ejZsyfWrVvn6NCK5cyfaVViqx76/Lpslfjbuj5bJ/72qhOw3e/E1hcS7PF+nT3GstYninlzLWTcT953pqfj5es3Sjzv+pDa6K72hFIQSrzP39kvajnb76Q41rRLEqtqtqNDhw7hq6++QrNmzYott2/fPgwZMgQjR47E6dOnsXbtWhw6dAgvv/xyOUVqH5xQjoiInFVISAhmzpyJq1evYuvWrejZsye2bt3q6LCogujjpUZ8k4bYVa8OvguuhV316uBKk4almjE5fwK9mg/NWh8kl5dqFmZb1pd/jz/wX6Kfz5J7/MurTsB2v5P8CQiLOruAvAsA7d3dLKrPHu/X2WMsa33C/d5/X7kMoQoXDPOubtH77eWlhsrCyfhs/Z4r++/EVpwiUc/IyMCgQYPw9ddfo1q14sf5Hzx4ECEhIXjjjTcQGhqKJ554AqNGjcLhw4fLKVr7CFepAACnsnPgRIMciIiITARBQPfu3bFu3TokJCQ4OhyqQPLXjh9QvRo6ebiX6QuuLRN/W9dn6wsJ9qoTsM3vxB4Jja3fb0WI0dkvGFWEGJ35d1JaTjH0fejQoahevToWLFiATp06oUWLFkUOff/zzz8RERGBjRs3onv37rh9+zb69euHRo0aYdmyZYUeo9VqzdaB12g0qFWrllMNhdOJItz+OZU3w2aThgh2cXF0SEREVI44TNv2+JmSo9jqHn9712krtry9IZ+t329FiNGW9dnj/VaEGJ35dwJUsHvUv//+e3z44Yc4dOgQlEpliYk6AKxbtw7Dhw9HTk4O9Ho9nn32Waxbtw7yh6545IuKisL06dMLbHe2hrvZ2Qs4mZODLXVC0FPtPHEREZH9Mam0PX6mROXHmS8k5KsIMdpSRXi/FSFGW7KmXXLogt3Xr1/HuHHj8Ouvv0J5/x7tkpw5cwZvvPEGpk6dim7duiExMRHvvPMORo8ejejo6EKPmThxIsaPH296nd+j7mzCVUqczMnByewcJupEREREVGHkD6V3ZhUhRluqCO+3IsToKA5N1I8cOYLbt2/jf//7n2mbwWDA3r17sXjxYmi1WkilUrNj5syZg3bt2uGdd94BADRr1gxubm5o3749Zs2ahYCAgALnUSgUUCgU9n0zNmCaUC4728GREBERERERkaNYnajrdDrMmzcP3333Ha5evYqch2YpFwQBer3eoroiIyNx8uRJs23Dhw9Hw4YN8d577xVI0gEgKysLMpl52PnlnOB2+zIJV3HmdyIiIiIioqrO6kR94sSJWLBgAbp3747nnnuuTD3VHh4eaNq0qdk2Nzc3eHt7m7ZPnDgRN27cQFxcHACgZ8+eeOWVV/DFF1+Yhr6/+eabePTRRxEYGFjqWJxBfqJ+PkeLXKMRLhKnmJSfiIiIiIiIypHVifoPP/yAqVOnYtq0afaIp4DExERcu3bN9HrYsGFIT0/H4sWL8fbbb8PLywudO3fGvHnzyiUee6oll8NTIkBjFLHgTjIec3Wt9BMqEBGRc7LlCDoiIiKyjtWJ+r1799ChQwd7xAIA2L17t9nr2NjYAmXGjh2LsWPH2i0GR9mYpkHO/dH779+8BSBvrb5FZVxGgYiIyFq2HEFHRERE1rE6Ue/QoQOOHz+OiIgIe8RTZW1ITUPfK1fx8F32N3Q69L1yFetCg5msExFRuSnvEXRERET0H6tvgv7ss88QHR2NDRs2IDc31x4xVTkGUcS4hJsFknQApm1vJtyEoYJPlkdERBWHvUfQERERUdGsTtRbtGiBS5cu4YUXXoCrqys8PT3NHmo1e32t9UdGJhJ0uiL3iwCu63T4IyOz/IIiIqIqLX8EHREREZU/q4e+P//88xA4uZlNJRaTpJemHBERUVl99tln6NWrF4KDg9GjRw+4uLg4OiQiIqIqw+pEvbDJ3ahsAuRyi8qtT01DV08P+Mis/rURERFZpUWLFtDpdHjhhRcgCAJcXV3N9guCgLS0NAdFR0REVLkx43MC7d3dECSX44ZOV+h96vnWp2nw6+lzeKeGL97y9YG7VFpuMRIRUdXCEXRERESOU+pE/dSpUzh79iyys7ML7BsyZEiZgqpqpIKARUGB6HvlKgTALFnP/4r0QQ0//KTR4Fh2DqYmJmHJnRRM9ffDKz7ekPOLFBER2RhH0BERETmOIIrWTSWelZWFZ599Fjt37oQgCMg//MGr7gaDwbZR2phGo4FarUZaWho8PT0dHY7JhtQ0jEu4aTaxXC25HAvvr6NuFEX8kJqGD27ewr/3Z9yv6+KCWYH+6OelhoQJOxFRheWsbVNFxs+UiIiciTXtktU96jNnzkR8fDz27NmDjh07YsOGDfDw8MCyZctw8uRJrFmzptSBV3V9vNTopfbEHxmZSNTpECCXo727G6T3E3CJIKB/NS/0UXvi65S7mHHrNv7NzcWA+Gv4SKXC3EB/dPX0MKvTIIpF1kdERFQSjqAjIiIqf1b3qDdu3BhvvfUWRowYAblcjsOHD6NVq1YAgIEDB8LT0xPLli2zS7C2UlmusGcYDFhwJxkfJd1ButEIAIh0d8fcmv5o7epaaA99kFyORfd76ImIyHk4W9vEEXRERES2ZU27ZPU66vHx8WjYsCGkUikEQUBWVpZp36BBg7Bp0yarA6bScZdKMcW/Bv5t3BDjfH0gFwTsyMjAI+cvoe35S+h75WqB9dlv6HToe+UqNqRypl4iIiragyPoRFHEhg0b8Ntvv6FPnz6oX78+jh496ugQiYiIKi2rE3UvLy9kZmYCAPz8/HDx4kXTPp1OZ9pH5cdXLsPCoEBcaBSGwdW8AAAHsrIKnUE+f9ubCTdhsG4wBRERVSGbN2/Ge++9h7Zt2wIAateujcjISKxduxatWrXCF1984eAIiYiIKi+rE/Xw8HBcuHABABAREYHZs2dj3759+PvvvzFjxgw0b97c5kGSZUIULogLqY1vatUstpwI4LpOhz8yeFGFiIgKxxF0REREjmN1oj5y5Eikp6cDAD788ENkZWWhY8eOaNOmDa5evYpPPvnE5kGSdVwllv1aV99LxYUcLayZpsAgitidnoHVd+9hd3oGe+WJiCopjqAjIiJyHKtnfe/Xr5/peWhoKC5cuGCaaKZt27aoXr26TQMk6wXI5RaV+yrlLr5KuQtfmRRt3dzQzs0VT7i7oZVKBUUhyT4npyMiqjryR9A99dRTphF09evXh4uLC0fQERER2ZnVifrD3Nzc0LNnT1vEQjbS3t0NQXI5buh0hd6nDgAeEgmaKRU4nJ2DO3oDNqdpsDlNAwBQCAIecVWhnZsb2rm7oa2bK/ZkZKLvlasF6sufnG5daDCTdSKiSmTkyJGmXvQPP/wQTzzxBDp27Aggr7f9559/dmR4RERElZrVy7MBgFarRWxsLHbv3o3k5GQsXboU9evXx+bNmxEeHo46derYI1abqQrLtWxITUPfK1cBwCy5zl9UJz+x1hqNOJqdjX0ZmdifmYX9mZlI1hdcbkcGQF/EuQTk9axfadKwVGu0c613IiLnb5syMzMr3Ag6Z/9MiYioarGmXbK6Rz05ORkRERE4ffo0/P39kZSUZLpnfdOmTdi+fTuWLl1ausjJZvp4qbEuNLjQoeoLHxiqrpBI0MbNDW3c3PAOAFEUcVGbi32Zmdh/P3k/r9UWmaQD/01OF5dyDwOqe0Fp4T3yAIfTExFVFBxBR0REVH6sTtTfffddpKam4vDhw2jWrBlcXFxM+yIiIjBv3jybBkil18dLjV5qT6t6qwVBQAOlAg2UCozwzust+fJOCkYn3CjxfCOuJ2Dk9QQEu8jRQKHIeygVqK9QoIHCBcEuLmbnzu/1t/VwevbQExHZRkUfQUdERFRRWZ2o//TTT5g3bx5atWoFg8F8iHRQUBASEhJsFhyVnVQQ0MnDvUx1hCkVFpVzFQRkiSLic3WIz9Xh1/QMs/0ugoC6Chc0UChQz8UFMXfvFrnWu4C8td57qT2tSrLt0UPPxJ+IqiKOoCMiInIcqxN1jUaD4ODgQvfpdDro9cUNkqaKqKTJ6fLvUb/cOAwpBgMuaHNxQavFhRxt3k+tFpe0ucgVRZzN0eJsjrbEc+YPpx+XcBNt3VzhK5PBTyaDr1wGH6kULkXMSm/rHnom/kRUVXEEHRERkeNYnaiHhobiwIED6Ny5c4F9f//9N8LCwmwSGDkPqSBgUVAg+l65CgGFT063MCgQMokENSQS1LiffD7IIIq4nqszJe4/pWmw/aEe98IsSU7BkuSUAtu9pFL4yqR5ybssL3lfk5pm0x56Jv5EVJVxBB0REZHjWJ2oDxo0CPPmzUPTpk3xzDPPAMi7r/nQoUNYtGgRJk+ebPMgyfEsnZyuKFJBQIjCBSEKFzwJDzRVKi1K1Du5uQECcEevxx29Acl6PYwAUg0GpBoMuKjNtSj+/B76uqfPobaLC6rLpKgulaK6TApvqcz02lsmQ3WpFGqpBG8k3KiSiT9g++Tf2esjooI4go6IiMhxrE7U33vvPezfvx+9e/dGtWrVAADdunVDSkoKnnrqKYwbN87mQZJzKM3kdEWxdDj97/XrmNVvEEXcMxhwR6/HbZ3elMDvSE/H+vvrwBfnqk6Hqw8ktaWVn/gPu3od4SolPKVSeEgk8JBK4CGRwvP+z7zXEigFAeMSbjp94p9fry2Tf2evD7BP4s+LE1TRcQQdERGR45RqHXVRFLFmzRps3boVSUlJ8PHxQY8ePdC/f39IrFiay1G4rqpzsHStd0vsTs9AxKXLJZb7JDAAtVzkuGsw4K7egLsGPVL0BtPrFIMed/V5FwIKriZvf33VnghTKuEqkUAlEfJ+ChK4SgSoJBLTdoUg4Ol/43GriB6t0q5tX1TyX5rfSUWoL79OWyf+VfHihLPXVxFidLa2adasWZg/fz5WrFiBZ555Bi4uLjhy5Aj0ej26d++OyZMn46233nJ0mMVyts+UiIiqNmvapVIl6hUdG27nUVgCUsvC4fQPMogiQk6fK7GH3tLEdZcmHZ3/vVJiuec8PeEpkyLdYEC60Yh0gxEaowHpBiPS7/80WvwubK+WXA5vmRRKQQKlRIBSkEAhEaAUBCjv9/Tn/3QRgEV3UqAxFh2xr1SKlSG1oJRIIBeEvAeE/54/8JBARIvzF3FDZ5uLCfm/44QiRkSU5uKEvRL/qnZxwtnrqygxOlvbpNPp8Oyzz2L79u2oVq0a7t27Bx8fH9MIuh9//NHii/N79+7FRx99hCNHjiAxMREbN27Ec889V2T5DRs24IsvvsDx48eh1WrRpEkTREVFoVu3bla9B2f7TImIqGpjol4CNtzOxVa9UrbsobdV4i+KIrJFEdvSNHg+/lqJ5x3gpYaPXIZso4gsoxHZRmPeTzHvdd42ESl6fbEJdUUSIJPBUyqFywNJ/n/PYXp+T2/ArszMEusb6+ONpiolXO7Xo5BI/nt+/6eLRIAMQPcSRiXUlMtxsXHY/QsPefNxFMfWFxMqwsUJZ6+vosQIOGfbZKsRdL/88gv279+PVq1a4fnnny8xUX/zzTcRGBiIiIgIeHl5Yfny5fj444/x119/oWXLlhaf1xk/UyIiqrpsnqgXdn9akRUKAnbs2GFxeUdgw1152aqHPr8uZ0v881k61H9BYAAaqZTQikbkGMW8R/7z+z+1oogcoxEnc3LwmwUT/AXJ5XCTSKATxSIflXmKKcn9h3A/eZcAkNx/boSITGPJ1z5D5XJ4yaSQCQKkECATAJkg5D0gQHr/9T29AXstuDjR30uNUIWLqT6pAFM90gfqFAB8kHgL9wxFX+TxlkqxJCjQ9HcoCILpb14AzJ4bIeKVazeQYij6RhFfqRTfBteCXBAgCIAAwVSPAJhtM4oi+sZfxR194fUJAPxlMuxrUBdKiQQy5F3Mkd2/mJP3/s0vqFSEiyf5qkrbJAhCiYl6YZo0aYIXX3wRU6dOLbKMVquFVvvfEqAajQa1atWq9J8pERFVDNa09RZNJrd79254enqiVq1aNgmQyF5sOeFdWWe6f5ClS9xZGqelk/GN9fOxuM7d6RkWJeorgmuhk4d7sWVEUcSO9Ax0teD2gcVBgWiqVJqS/NyHfuY/P5OjLXSpvod1dHODl0yKXFFErlGEVjTmPRfzLkrkGvOepxkMpRqVYLz/wIPXOK0cmHRFpwNsMKlhvu9T02xWV4rBgP5Xr9usvjsGA56+HG+TukQAiXo96p45X2w5GWAanSECSC/m95w/MWTNU2egECQQ72/Le4gQRZht0xqNSLOgvj8yMkv8d0KWMxqNSE9PR/Xq1YstN2fOHEyfPr2coiIiIrIfixL1OnXq4PLly1Cr1RgxYgRefPFFuLm5lXwgkQNIBcFmX5CrSuIPWJ78t3cv+d++IAiI8HC3qL7RPt4W92RuTtOUWN+Oh1YKKIqloxJ+DA1BW3fXvARdzOtFznsuQgTMth/IyMLgayUnuR8H+qOpSgW9KEIvijAApud6EdAj7/nZbC0WJieXWN8Lak8EurjcryuvDsMD9eY/j9fm4nB2don1NVQo4CuTQbz/SecnqXjwp5i3bOK/uSUvkVhLLoeXVPpf8ptfpwizbWl6A24X0zufT3b/+KJK6pH3vrOtuICSpDcUU6P1Em14IaY8OesIuk8++QSZmZno169fseUmTpyI8ePHm17n96gTERFVNBYl6pcuXcKePXsQHR2NsWPH4s0330S/fv0wYsQItG3b1t4xEjlUVUj8Adsn/85en6UXJrqrPSyuM8TFBRMTb5VY55t+vhZfnFiXllZifatDg216ceKLWjUt+pu3tL44C0ZhWFPfb/XqoJOHO4z3L0Do7l/kMN16IYrQiXnJ+v6MTAy/nlBinUuCAtHa1RUCAImQPzRfeGiIPnA4MxsjLKgvQC4vsYwzcsYRdKtXr0ZUVBQ2b94MPz+/YssqFAooFIpyioyIiMh+rJ5MTqPR4LvvvsPy5ctx6NAhhIWFYcSIERgyZAhq1KhhrzhtqqrcB0hVg62XiLLlff7OXp8t5yGwV53OPFeCs9dXUWLM5wxtU7169XD58mW0bdvWbiPorLlHfc2aNRg+fDjWrl2LZ555xupzOcNnSkRElK/cZn0/deoUli1bhi+//BLPPvss1q9fX9qqypUtGm5tQhr0d4seQiqrroIiqHRL9BA5mrOvN23L+mx9IcEedTrzxQlnr6+ixAg4T1KZP4Ju/fr1kEqlNh9BZ2mivnr1aowYMQKrV6+2euK5fM7ymRIREQHllKifPXsWMTExWLFiBZKTk/Huu+9i9uzZpQq4vJW14dYmpOF4m2UQtUXfzygopGhxYDSTdaIKwNYXEuxRpzNfnHD2+ipKjM6WVNpyBF1GRgYuXboEAGjZsiU+/fRTREREoHr16qhduzYmTpyIGzduIC4uDkBekj5kyBAsWrQIffr0MdWjUqmgVlv++TrbZ0pERFWb3RL1jIwMrF69GjExMfjrr79Qt25dDB8+HMOGDUNgYGCZAy8vZW24M0/cwskuMSWWC/99BNya+ZcmRCIiu3LmCwn2qK8ixOjMSWVZR9Dt3r0bERERBbYPHToUsbGxGDZsGOLj47F7924AQKdOnbBnz54iy1vKmT9TIiKqemy+PNvevXtNw+BEUUTfvn0xd+5cdOzY0SYBExFR+bLlJIkVoT571GmPGJ3R2bNn8e2332LdunUQRRFhYWFW19GpUycU1y/wcPKdn7ATERFVVRYl6p06dYKnpycGDRqEAQMGmLL/o0ePFlq+VatWtouQiIiIylVhI+jeeOONCjeCjoiIqKKyKFEH8rrpv/nmG3zzzTdFlhFFEYIgwGDBOrhERETkXDiCjoiIyDlYlKgvX77c3nEQERGRg3EEHRERkXOwKFEfOnSoveOolFL3XoFreA0IZZwAiYiIqLxwBB0REZHjWTz0nax3fcYupB+8jtA53aCoxWXaiIjIuXEEHRERkXNgol4KsuoqCAppseuoQyoAApD66yX8s+8qgt7tgIBXH4Egk5RfoERERFbgCDoiIiLn4FSJ+pw5czBp0iSMGzcOCxcuLLKcVqvFjBkzsHLlSty6dQtBQUGYPHkyRowYUS5xKoLUaHFgNPR3s4ssI6uugjFLh8sTfkH6weu4FrUDyetOoc4n3eHekjPmEhERERERUeGcJlE/dOgQvvrqKzRr1qzEsv369UNSUhKio6NRr1493L59G3q9vhyi/I8iSA1FUMnD2Rtvegl3Vv+Dq9N3IutUEk49FQv/ka0RNLEjZB6KcoiUiIiIiIiIKhKnSNQzMjIwaNAgfP3115g1a1axZbdt24Y9e/bg8uXLqF69OgAgJCSkHKIsHUEiwG9QC1R7sj6uTsvrVb/1zWHc3XoeIbOfRLWnG3CyOSIiIiIiIjJxihumX3vtNTzzzDPo0qVLiWW3bNmC1q1bY/78+ahZsyYaNGiACRMmIDu76GHoWq0WGo3G7FHe5L5uqLf0WTRaOwCKkGrITUzHheHrcWHoOmgT0qBNSEPmiVtFPrQJaeUeMxEREREREZU/h/eof//99zh69CgOHTpkUfnLly9j3759UCqV2LhxI5KTkzFmzBjcvXsXMTExhR4zZ84cTJ8+3ZZhl5q6Yyia73kZNxbux83FB3Fv20Wk7r4CUW8E9MYijxMUUrQ4MNqi4fZERERERERUcTm0R/369esYN24cVq5cCaVSadExRqMRgiBg1apVePTRR/H000/j008/RWxsbJG96hMnTkRaWprpcf36dVu+DatJVHLUmtgJ4TtGwuPRIIg5+mKTdAAQtYZiJ68jIiIiIiKiysGhifqRI0dw+/Zt/O9//4NMJoNMJsOePXvw2WefQSaTwWAouPxZQEAAatasCbX6v57lRo0aQRRFJCQkFHoehUIBT09Ps4czcG3oi8ZbBqPm+HaODoWIiIiIiIichEMT9cjISJw8eRLHjx83PVq3bo1Bgwbh+PHjkEqlBY5p164dbt68iYyMDNO2CxcuQCKRICgoqDzDtwlBIqD602GODoOIiIiIiIichEMTdQ8PDzRt2tTs4ebmBm9vbzRt2hRA3rD1IUOGmI4ZOHAgvL29MXz4cJw5cwZ79+7FO++8gxEjRkClUjnqrZSLxC/+Qtof8TDmFhxpQERERERERJWDwyeTK0liYiKuXbtmeu3u7o7ffvsNY8eORevWreHt7Y1+/fqVuKxbZZC8/jSS15+G1N0F6k6h8OpaD16RdeHi516grDYhrdh72mXVVZyYjoiIiIiIKrzKmPsIoiiKjg6ivGk0GqjVaqSlpTnF/eqZJ27hZJfCZ6x/kFfXesg4dhP65Cyz7W4tAuDVpS6qda0Ht+YByL2pwfE2yyBqi+55t3YW+cr4x09E5EycrW2qDPiZEhFVftqENJvnPvZiTbvk9D3q9J9a73WAa9MayDyeiHu/XULq75eQ+c8tZB5PRObxRNz4eB/kvm5waxVQ7B8q8N8s8pb8sdrrj5/JPxERERERlYX+brZNcx9nwUTdCciqqyAopCUmwrLqKggSAe6tAuHeKhC13uuA3KQMpO74F6m/XULq7ivQ3clE6vZLFp3XqNVDFEUIglBsOXv88VekK19ERERERETliYm6E1AEqdHiwOhS9S671HCH38Dm8BvYHMZcA9IPXsPt704gZcPpEs97+pk4QMhb112ikuX9VOb9lOY/d5XDmKOz6H0YdZZPcldZr3wRERER2RJHIBJVTUzUnYQiSF3m/2QlLlKoO4RC5qWyKFEHAIiAMUsHY5YOQNGNgCVOd/8WUi8l5L5ukPu45v30dYPcx+2B53nbDVmWJf/WYENGRERE1nD27w4cgUiVlS3+7emSM6E5cB0pW85adM7sy3fhGl6jxNHEzoKJehXWaPNLUNWtDmO2HsZsXd4j5/7zrLznhmwdsv9Nwa2lf1tUpyE1B4bUHORcTLFz9ObYkBERka05exJHZVMRvjtwBCJVRqX9t6e7kwnNwWvQ7L8GzZ9XkX0u2arzXnp1E65O+R3qjqHw6hQKzw4hha6elR+jo///Z6JehcncXIr843xQ5olbFiXqjdYNhNzPDbrkTOjuZEKXnJX3804m9MlZyL2TCf39fcZsvUUxnh+6Dq6NfKEMrQZlaDUoQqvn/aylhkQuNZVjQ2YbzvCfEhGRM6gISVxVZMt2it8dqg5n/37j7PEBjvm3l30pBRlHb0Kz/yo0f15D9vmCiblrI18oG/jg7uaSe9UFhRS6pAwk/3ASyT+czDu+aQ1T4u7xWC1IlDKn+f+fiTrZjMxLCdeGvgB8iy0niiLS/7qOM8+uLLHO3Bsa5N7QFNwhFaCo5WVK4AWFtGAZsoqz/KdUnIrQkBFR5cAkzvlUtXZKNBiRfeWerUKrMGzd1tvj78aWMTp7fPaK0RLn+n1fYJtrYz94tqsNzza14dGmNuTersg8ccuiRL3xxkEwZuuRtvsKUndfRtbJJGSdynskLjkIQSmDZ5vaUDXwdor//5moV0LWzCLvCIIgQOrqYlHZkI+egiARkHPlHnIu34X2yj3kxN+DMVsPbfw9aOPvIW2XfeK0x39yzpxkOvuX0orwBY2IiOzHFu2UUauH/l429HezkX480abxlaWdMuoMyD6fjMyTt5B54hYy/7mFrNNJFo9ArCzs0dbb+vuNrWN09vjKEqNoFGHIzIUhLQf6NC0M6TkwpGmReeqWRecFANcmfvBsF3w/Ma8FeXXXAmUszX1c/D2gCFJD3T4EtadEQHcnE2l/xJsSd92tDKTtuoy0XZctjs+emKhXQmWZRb6oso5K/D1aBsKtmb/ZNlEUoUvKyEve7yfwGccSofkjvsT6zr30A9xbBEAV5gvXhr5QhflAVd8bEoX5PwVb/ydXEa6W2kNVHKJY1S7wEJHj8P+Hwt2KOQyJiwy6+wm5/t5/D2MpJrM903sVlHWqQVHb6/5DDWXw/edBakiUed8hLG2ncpMyoL+bjcwTt5DxTyIyTyYh63RSoccKShnEnJKT9RuL/kTQu+3hGlb8qEZ7cNa23pijhz4tB9nxlo1KEEWx3GO0B1vGJ+qN0GtyoL1ZyOjWQvw7/mfAKMKguZ+Ya3IAyz7WQjXaMBDqJ0JKLFfa3Efu6wafPk3g06cJRFFE9vlkpO2+gpQfzyLj0I3SB24jTNQrKVvMIv9gXbZM/PPLlzb5FwQBLv4ecPH3gGeb2gDy7qM/2SWmxPPqbmXg3raLuLft4n8bpQKUodXyEveGeQk8BMGm/wk749VSY44eWefvIOvMbWSdvo30v6+XeF4AuP3dP/C6lQ5VQ18oaqmLnDmzIvSAO/vQsKr4GdoDL56QPSVvOgNIJXBt5AtBUvxMws4+XNbZiXqjReXufHei+AISAbJqSkhUcuQmlJyAGNK1yPwnr5e7MHJ/dyhre0HqobAovtM94wB9wexF6qGAW7MacAv3h1vzALg1qwFDRi5OdYstsc67P57D3R/PQd0hBP6vPAKvLnUhSCUWxVMWjvo7vLP+FO7+ciGvpzY1B/r7Pw1p2abXJX3vetipZ+Lg4usGWXUV5N6ukHu7Qvbgz+oqyHxcobuTZVF9+sxc5CZlwJiZC8P9FZYMmbl5P7N0MGblPc++fNei+hK/OgRFkCcEFykkLjIICikkLlIIChkkLv891yakWVTfnTUnkfLTORjScmDQaKHXaPM+T83912laGDNzLaorX9aJwv+NCC5SyDwVkKqVkHoqIAgCMo7+f3v3Hh5Fee8B/Dt7yW422WwuEJIQEiAI4SZeQO4i0KIggscqoC0FW9seH7BaORWOLQX9p9Ra2mOp9XIgwJFjfSrgoWJVKAmoXEQNAhLCLTckFwgk2WSTzV7e88cmS5ZksxOym52dfD/Ps0/2MjP7vvtm5je/d96ZuRRwebo4o+zv7m7uI0kSTC15QNykDFl5RagxUSdZgpn4ty4v2Mm/HANfng04XLAVXEZj4WXYTl+Bq7YJTeeuouncVeD9wi4tr/H8VWhjo6AxXb8HvRSlDfltH7qS+Ef1j4Ojoh4N31R6k3LbqSo0nqsGXF3v5qzc9CUqN30JANDGRnk6N4Z7HtHDk2Ea3hf6RFNQOieEW8BV2wRHtQ31J+QPk5JDSUPDemp5wRYJiUJv7DyhnlW+4TDKNxyGLiEa5vEDEDcpA3GTMmAameyTKCl9uGzbciqlY0sIgaaz1ag9UITaAyWoPVAk6zsTH8hG9C1J0CVGQ5dg8iReCdHQJURDl2CENs4ISSPJ7uQf8vqDngtMlda0PGrRVFoDe0kN3DYHHBX1cFTUyyobAMApoI03tiTkKYi5NQWxt6bAMDChXWdPg5/E50bmSRmwHi5D7YFi1B4ohiEjHik/vhN9HxsDnUV+stNV3fk/dNXb0VxuRfMlq+dvhRUNJyplfW/FX+XdjQgaCdqYKLis9sDTNrv8XxvpJhTMD3wtpq5ovfhZsFS8eVT2tHJHdqT/6h7Ejk6B1mLwJOZxRugsRu+ok1Zy173ejok6hU2wk385zLel+gylbx1Gbyu4jMbTl2ErvALbac9RZjkbpHM/e6/9mxrJk7S3Sd7lDvu5sqsAtlNV0MTooYnWQ2vy/NVE66Ex6aFteS7c8hZ44T8+gL2kFs5rHe8k6RKiYRqZDNPIZGjNBnz78qcBl2mZPhiOCisaz1XDVd+M+i++Rf0XvsOD9P1iYegfJ6uMV3YV4NrHZ+GotsFZbfPcLaDaBucVGxxXbV3uTCh49B2YhibBMDABxoEJMGTGwzgwAcaB8dDFXx+hofQkOFSUOkQxFOULRRl76/8N+Rd7Rxpspy/Dea0R1z48g2sfngHgOTpqHp/uOa9yUgYgQfH/O0ro2LJfqkPdgWLPeaOfFHctAW7R/+lJ7U6b647orMQOlyeEgLPa5k3crUfKULnxy4DLG/o/jyBh1hBZnfpyRyAO2fAAhFugMucrVG07BntpDUrW/AtlvzuAPo+MQsoTY73D4sMxKqh80xeAU3gTcke5Fa76rh2tbctyz0AYMhOgi4+GzmKELt4Ibcvfts+1sQbYTlbKSgqHvvUIovrGtOyPNHr+XrVd3z+pboSz2obmqnq45ZZdI3n25Ux6aExRnucxUd73tCY9XI0OXPvgTMBF9Xl4FLQWA0SzC267C6LZ2fLXBXezE8LugrvZBVdNI5qKawIuL/67Q2DMjIc2zgCdpeU3izNA23LkWxdnhNZigNZsQGPBZVm/YcL0wUFd93o7JuqkCjc7lL7tMPr46YO979cfK8fJWTmBvzfeCLfDDXejA2hNnt3Ccx/6mzgPrvyVQ12epzMNx1p64rUSoockeZLyEckwjeyHmBHJ0KfEencUGo5XyErUM351D2JuTYHb4ULT+auwFVRd7+g4dRn20ho4KuvhqJS3cyWnzlqzAZrYKDjKrQGndV5uQN3lBuCz0vbLiTd6k3eNSS+rfK4mJxzVNribnHA3OeBudF5/3uT0ed14Xt7wtaLnP4bWqIPb4YJodkM4XJ7nN7x2N8r7H7IevQhNbJTnXMko/3dAUPrR4HCWz1lvh9NqhyQBkCRAkjxHtiQAGsmznmgk2ecwUu8x6KX7ED28Lxq+roD1UCnqDpXCeuQiXFY7avaeR83e8wA8R6TkcNY2wV5WC1e9Ha76ZrgaHHB7n7c86pthL5F33u3ld0/CdqrKc3Q53nNEWZfgeS7pfIdGh6tjq/r/CmAvq0XtgSLP6LY2JIMW5rsGwHL3QESlmnF++T8Cfq9c3b0GjyRJ0PeJgb5PDGLvSEP04ERZiboh1Sx75F1XRyBmrpmB9F9OxZXtJ1H531/AVnAZVVvyUbUlH3FTByLp30ag+D8/6tZ2VggBR1UD7KU1qP20RFY9rvg5HUFrNiAqNRZRKWboU82AVvI7bVsZv54R9ITQkGKWtUy5R4NH7v4hYsf2D9jWDccrZCXqqf9+V1DLN2Dl3WFLqpV+4WulYKJOqhDsofSBzjNsNfzdxxBzawqEEBAO9/VEzuZok9Q50HCqCiXP7wm4vLgpmZD0WrgbHXA3tpzD1PLcbXN0+eqv/X85FYn33oLooX3aDTvqLo1e6z2XB/92/X1XvR2201dQs/ccvl3/WcDlmCdlIDor0XP+Vx8T9Ekx3nPC9H08QxY1Bp3swDP4v+6HpNPCXuy5Q4C9pAZNxdfgqGqAq6YJDcfK0dCFK/2emrtV9rRy1X9+MajLK/7Pjz1PNBKi+sfB2DKKwJAZf31EQWb8Te2Eux2e144rNjirG1qOMHheN55pfz/Tjlz802cw3ZIEXXw0tAktQ1DjjW0SB0/C0NVTOlx1ds9RjquNbY56NMJx1VNG51UbmkrlnatX8OA2WdNR79GVHUmNXgvz2P4wj+2PtKcmQrjcaDhZCetBT+Jed7gMrpomWd9b8L3/DVYVAAAVr/kfIqw1G3wSd0jyOqIaz17xnB9r0EFjaD1XVgeNUdcu+Zej9IV9119oJMSMSYHl7kGwTM2EeVy6Z2Qa5A8Dlytcp+F1VVdHIGpNevRbfDuSf3Ab6g6WouLNo7j24VnUfVIs68K7wu5CU1ktnDVNsJd4hvs3tQz5t5dcg72stsv7I4nzhiNmdD/PwZHUWESlxSEqxQxtrO9dgBqOV8hK1COBxqAL+amQkUrp655SOhKYqJNqhGMofStJklou7qEFOhjxrY2Vd4GZzLUzO+3dFG4Bd6MD9V9+i4KH3w64vMR7b5HdWxqsjZI21gDz2P7QRGllJeoDX/xOUHt0Y0b263B5roZmb9LeVFyD+i+/xdV/nJa9XEmvgcbYejqDZ4dUY9S3PPf8dTc5UJtXHHBZ/X85FdGDEyFFaSDpWy4Ao9N4rm/Q+lqvReOFqzi7dHvA5RkGxsNR1QC3zYHmslo0l9WiroOjHJpYebdFPPfUPyCanHBcbYSrVl5y0Zlr7xci0LE/rdkATYy8UQ4FD/8vXPXNsi8sRXQzurMjKWk1iB2TitgxqUh9cjyEW6D6vVM49+//J+u7JaMO2hg9tDEGz3VQYqKgjW15tDx32pplJTSW6YMASNevfF7T5F2vXVY7XFY77DI7tFqde3KX/w81EjQGz0Wt5OYoUelxSJh1CyxTByJucobPaUpthWLnOZz7DqEmSRIskzNhmZwJe1ktKnK+RNWWfFnnawc8v1oCovrHQZdo8nsBsbb6/3wij976ofTyAb1v3VNKRwITdaIIIrVcFMXfTkx3KGWj1Nl3dydIaGOiPMP+RyQD8PTay0nUR+xaDPO4/rKunttwvAIn8gIf9ZfbgSKa5V2xduh/PwTT6H6eoYgtnRH2kho0ldR4RhaUeE5HkHtOXWPBZd83NJLnYkyJ0T5XwBVONy5v+zrg8vr+4DZoDFo4rzW1JAott0zqIGGQw9nmyKQ2Ngq6RBN0SdHQJ3pGYOgSTdAnef66rE0ofSE34DJHfrgEMSP7AcLTIQbheQgBz2ktbgEhBGwnK2V1kpE6BGtHUtJ4Tj+SY+SHS2C+o3/A6eQeecz41fT2tzl1uluukt14fb281oiGU5WoeDXwRbp0SdGA23NPctHs8u00cwvP0dYuHHEdtvlhWdtEtcepUDIMsCDzNzOQcN9Q2SPFdEnR3lvSeW9HlxEPY4YFUS2nWgX7omChSgiVfNtipZcvFGWMBEroSGCiTtSBYG/klBy821LCRsmfcAUJrUnfI7e46S5JkhDVLxZR/WJhviu93ecumwPX9pzDuZ/sDLisjDXTEXtHf29Cros3dvgbNByvkJWopyy9w+9OeNuEwfr5RVx4enfA5Q15bT7iJmZAlxAd8JQOz1DZwIm6RucZxhtIKDrJiNrS6PxfZyJYJJ3Ge/uptkzH+8pK1Ie/86jvhVldbs9FrexOuJtdngTe7kTDiUrZowjkYpzqHq3M0+BG7PoB4iZkhLg07YXqN1T6bYuVXr7W5Sp13VMrJupEHQj2Ri4SekuDrbcNkwKU3cGjNekRPShB1vdapg7qsSGKbRMGd4O8i+dFD0lCVKo5xCUjUjYlxQFJq4HWpAFuuEhnV89jVgOlxym5tCZ5p0r1xlgPKL+MSi8fycNEnciPUNw7Xum9pcGk9DJGwtCw3vgbBpuSO0+od1H6cFmim8H/Q6LQYaJOFKEiobdUyWWMlKFhvfE3DKbe1nlCyqX04bKt38+OLeoqJccpokjGRJ2Ieq3etnOh9CGKodqp702dJ6RsSv/fYceW+rHzhChySEIIeTfNVJG6ujpYLBbU1tYiLq6De2kREamU/WKtonealV6+UGJsCj7+pkTt9ebtLFG4dSUu8Yg6EVEvEglH9JRcPiKiSMftLFFkUP49h4iIiIiIiIh6ESbqRERERERERArCRJ2IiIiIiIhIQZioExERERERESkIE3UiIiIiIiIiBWGiTkRERERERKQgvfL2bK23jq+rqwtzSYiIiDxaY1JrjKLuY7wnIiIl6Uqs75WJutVqBQAMGDAgzCUhIiLyZbVaYbHwHsfBwHhPRERKJCfWS6IXdt273W5cunQJZrMZkiSFuzg3ra6uDgMGDEBZWRni4uLCXZxuUUtd1FIPQD11UUs9APXURS31AIJbFyEErFYr0tLSoNHwzLRgUEO85/qiPGqpB6CeuqilHgDrokThivW98oi6RqNBenp6uIsRNHFxcRH9z9+WWuqilnoA6qmLWuoBqKcuaqkHELy68Eh6cKkp3nN9UR611ANQT13UUg+AdVGino717LInIiIiIiIiUhAm6kREREREREQKwkQ9ghkMBqxZswYGgyHcRek2tdRFLfUA1FMXtdQDUE9d1FIPQF11IWVS0/+YWuqilnoA6qmLWuoBsC5KFK569MqLyREREREREREpFY+oExERERERESkIE3UiIiIiIiIiBWGiTkRERERERKQgTNSJiIiIiIiIFISJukL99re/xbhx42A2m5GcnIwHH3wQhYWFnc6Tl5cHSZLaPU6fPt1Dpe7Y2rVr25UpJSWl03n279+PO++8E0ajEYMHD8Zrr73WQ6X1b+DAgR3+vsuWLetweiW1x4EDB/DAAw8gLS0NkiThvffe8/lcCIG1a9ciLS0N0dHRuOeee/DNN98EXO727dsxYsQIGAwGjBgxAjt37gxRDTw6q4fD4cDKlSsxevRoxMTEIC0tDT/84Q9x6dKlTpe5efPmDtupqakpbHUBgKVLl7Yr04QJEwIuV0ltAqDD31aSJPz+97/3u8xwtImcbW6krCcUORjrGeuDSS2xHlBPvFdLrAcY78OxrjBRV6j9+/dj2bJlOHz4MPbs2QOn04lZs2ahoaEh4LyFhYUoLy/3Pm655ZYeKHHnRo4c6VOmEydO+J22qKgIc+bMwdSpU5Gfn4/nn38eP//5z7F9+/YeLHF7R48e9anDnj17AACPPPJIp/MpoT0aGhowZswYbNiwocPPX3rpJaxfvx4bNmzA0aNHkZKSgu9+97uwWq1+l3no0CEsXLgQixcvxtdff43FixdjwYIFOHLkSKiq0Wk9bDYbvvrqK6xevRpfffUVduzYgTNnzmDevHkBlxsXF+fTRuXl5TAajaGoglegNgGA++67z6dMH3zwQafLVFqbAGj3u27atAmSJOF73/tep8vt6TaRs82NlPWEIgdjPWN9MKkl1gPqifdqifUA431Y1hVBEaGqqkoAEPv37/c7TW5urgAgrl271nMFk2HNmjVizJgxsqd/7rnnRHZ2ts97P/vZz8SECROCXLLuefrpp0VWVpZwu90dfq7U9gAgdu7c6X3tdrtFSkqKWLdunfe9pqYmYbFYxGuvveZ3OQsWLBD33Xefz3v33nuvWLRoUdDL3JEb69GRzz//XAAQJSUlfqfJyckRFosluIXroo7qsmTJEjF//vwuLScS2mT+/PlixowZnU6jhDa5cZsbqesJRRbGesb6YFFLrBdCPfFeLbFeCMb7joSiXXhEPULU1tYCABITEwNOe/vttyM1NRUzZ85Ebm5uqIsmy9mzZ5GWloZBgwZh0aJFuHDhgt9pDx06hFmzZvm8d++99+KLL76Aw+EIdVFlaW5uxltvvYUf/ehHkCSp02mV2B5tFRUVoaKiwuc3NxgMmDZtGg4ePOh3Pn/t1Nk8Pa22thaSJCE+Pr7T6err65GZmYn09HTMnTsX+fn5PVPAAPLy8pCcnIyhQ4fiJz/5CaqqqjqdXultUllZid27d+PHP/5xwGnD3SY3bnPVvJ6QcjDWM9aHitq3YZEc79UW6wHG+1bdbRcm6hFACIFnn30WU6ZMwahRo/xOl5qaijfeeAPbt2/Hjh07MGzYMMycORMHDhzowdK2N378eGzduhUfffQR3nzzTVRUVGDSpEmorq7ucPqKigr069fP571+/frB6XTiypUrPVHkgN577z3U1NRg6dKlfqdRanvcqKKiAgA6/M1bP/M3X1fn6UlNTU1YtWoVHnvsMcTFxfmdLjs7G5s3b8auXbvw9ttvw2g0YvLkyTh79mwPlra92bNnY9u2bdi3bx/+8Ic/4OjRo5gxYwbsdrvfeZTeJlu2bIHZbMZDDz3U6XThbpOOtrlqXU9IORjrGetDSc3bsEiO92qM9QDjvdx5AtHd9JzUY5YvX47jx4/j008/7XS6YcOGYdiwYd7XEydORFlZGV5++WXcfffdoS6mX7Nnz/Y+Hz16NCZOnIisrCxs2bIFzz77bIfz3NhzLYTo8P1w2bhxI2bPno20tDS/0yi1Pfzp6DcP9HvfzDw9weFwYNGiRXC73Xj11Vc7nXbChAk+F26ZPHky7rjjDvz5z3/GK6+8Euqi+rVw4ULv81GjRmHs2LHIzMzE7t27Ow18Sm0TANi0aRO+//3vBzz3LNxt0tk2V03rCSkLYz1jfU9Q2zYs0uO9GmM9wHjflXk6wyPqCvfUU09h165dyM3NRXp6epfnnzBhQtiPDN4oJiYGo0eP9luulJSUdr1PVVVV0Ol0SEpK6okidqqkpAR79+7FE0880eV5ldgerVfl7eg3v7Fn8Mb5ujpPT3A4HFiwYAGKioqwZ8+eTnvXO6LRaDBu3DjFtVNqaioyMzM7LZdS2wQAPvnkExQWFt7UetOTbeJvm6u29YSUhbHeg7E+dNS4DVNjvI/0WA8w3ndlnkCYqCuUEALLly/Hjh07sG/fPgwaNOimlpOfn4/U1NQgl6577HY7CgoK/JZr4sSJ3qustvr4448xduxY6PX6nihip3JycpCcnIz777+/y/MqsT0GDRqElJQUn9+8ubkZ+/fvx6RJk/zO56+dOpsn1FqD9tmzZ7F3796b2tkTQuDYsWOKa6fq6mqUlZV1Wi4ltkmrjRs34s4778SYMWO6PG9PtEmgba6a1hNSDsZ6xvqeorZtmFrjfaTHeoDxvq1ut8tNX4aOQurJJ58UFotF5OXlifLycu/DZrN5p1m1apVYvHix9/Uf//hHsXPnTnHmzBlx8uRJsWrVKgFAbN++PRxV8FqxYoXIy8sTFy5cEIcPHxZz584VZrNZFBcXCyHa1+PChQvCZDKJX/ziF+LUqVNi48aNQq/Xi3fffTdcVfByuVwiIyNDrFy5st1nSm4Pq9Uq8vPzRX5+vgAg1q9fL/Lz871XR123bp2wWCxix44d4sSJE+LRRx8Vqampoq6uzruMxYsXi1WrVnlff/bZZ0Kr1Yp169aJgoICsW7dOqHT6cThw4fDUg+HwyHmzZsn0tPTxbFjx3zWG7vd7rcea9euFR9++KE4f/68yM/PF48//rjQ6XTiyJEjIatHoLpYrVaxYsUKcfDgQVFUVCRyc3PFxIkTRf/+/SOqTVrV1tYKk8kk/vrXv3a4DCW0iZxtbqSsJxQ5GOsZ64NJLbE+UF0iKd6rJdYHqksrxvvgtgsTdYUC0OEjJyfHO82SJUvEtGnTvK9/97vfiaysLGE0GkVCQoKYMmWK2L17d88X/gYLFy4UqampQq/Xi7S0NPHQQw+Jb775xvv5jfUQQoi8vDxx++23i6ioKDFw4EC/K3xP++ijjwQAUVhY2O4zJbdH6+1jbnwsWbJECOG5FcWaNWtESkqKMBgM4u677xYnTpzwWca0adO807f6+9//LoYNGyb0er3Izs4O+Y5JZ/UoKiryu97k5ub6rcczzzwjMjIyRFRUlOjbt6+YNWuWOHjwYEjrEaguNptNzJo1S/Tt21fo9XqRkZEhlixZIkpLS32WofQ2afX666+L6OhoUVNT0+EylNAmcra5kbKeUORgrGesDya1xPpAdYmkeK+WWB+oLq0Y74PbLlJLgYmIiIiIiIhIAXiOOhEREREREZGCMFEnIiIiIiIiUhAm6kREREREREQKwkSdiIiIiIiISEGYqBMREREREREpCBN1IiIiIiIiIgVhok5ERERERESkIEzUiYiIiIiIiBSEiTpRL7B582ZIkuT3kZeXF7ayFRcXQ5IkvPzyy2ErAxERUaRjrCdSF124C0BEPScnJwfZ2dnt3h8xYkQYSkNERETBxlhPpA5M1Il6kVGjRmHs2LHhLgYRERGFCGM9kTpw6DsReUmShOXLl+P111/H0KFDYTAYMGLECPztb39rN+3Jkycxf/58JCQkwGg04rbbbsOWLVvaTVdTU4MVK1Zg8ODBMBgMSE5Oxpw5c3D69Ol2065fvx6DBg1CbGwsJk6ciMOHD4eknkRERL0VYz1RZOARdaJexOVywel0+rwnSRK0Wq339a5du5Cbm4sXX3wRMTExePXVV/Hoo49Cp9Ph4YcfBgAUFhZi0qRJSE5OxiuvvIKkpCS89dZbWLp0KSorK/Hcc88BAKxWK6ZMmYLi4mKsXLkS48ePR319PQ4cOIDy8nKfoXl/+ctfkJ2djT/96U8AgNWrV2POnDkoKiqCxWIJ8S9DRESkDoz1RCohiEj1cnJyBIAOH1qt1jsdABEdHS0qKiq87zmdTpGdnS2GDBnifW/RokXCYDCI0tJSn++ZPXu2MJlMoqamRgghxIsvvigAiD179vgtW1FRkQAgRo8eLZxOp/f9zz//XAAQb7/9drfrT0REpHaM9UTqwqHvRL3I1q1bcfToUZ/HkSNHfKaZOXMm+vXr532t1WqxcOFCnDt3DhcvXgQA7Nu3DzNnzsSAAQN85l26dClsNhsOHToEAPjnP/+JoUOH4jvf+U7Ast1///0+vf233norAKCkpOTmKktERNQLMdYTqQOHvhP1IsOHDw94gZmUlBS/71VXVyM9PR3V1dVITU1tN11aWpp3OgC4fPkyMjIyZJUtKSnJ57XBYAAANDY2ypqfiIiIGOuJ1IJH1InIR0VFhd/3WgNsUlISysvL20136dIlAECfPn0AAH379vX2zBMREZEyMNYTKR8TdSLy8a9//QuVlZXe1y6XC++88w6ysrKQnp4OwDNkbt++fd5g3Wrr1q0wmUyYMGECAGD27Nk4c+YM9u3b13MVICIiok4x1hMpH4e+E/UiJ0+ebHclWADIyspC3759AXh6yGfMmIHVq1d7rwR7+vRpn9u2rFmzBu+//z6mT5+O3/zmN0hMTMS2bduwe/duvPTSS94rtz7zzDN45513MH/+fKxatQp33XUXGhsbsX//fsydOxfTp0/vmYoTERH1Eoz1ROrARJ2oF3n88cc7fP/NN9/EE088AQCYN28eRo4ciV//+tcoLS1FVlYWtm3bhoULF3qnHzZsGA4ePIjnn38ey5YtQ2NjI4YPH46cnBwsXbrUO53ZbMann36KtWvX4o033sALL7yAhIQEjBs3Dj/96U9DWlciIqLeiLGeSB0kIYQIdyGISBkkScKyZcuwYcOGcBeFiIiIQoCxnigy8Bx1IiIiIiIiIgVhok5ERERERESkIBz6TkRERERERKQgPKJOREREREREpCBM1ImIiIiIiIgUhIk6ERERERERkYIwUSciIiIiIiJSECbqRERERERERArCRJ2IiIiIiIhIQZioExERERERESkIE3UiIiIiIiIiBfl/6eY8Xr1XJP0AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "make_lin_reg_model(learning_rate=0.0005, optimizer='Adam', epoch_count=20, lr_sched='yes', decay_steps=10000, decay_rate=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making a FFNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup for testing different configurations\n",
    "\n",
    "def create_nn(learning_rate=0.00001, epoch_count=175, hidden_layer_sizes=[150, 75], \n",
    "              hl_act_func='relu', dropout_rate=0.1, oput_act_func='relu', optimizer='Adam', plot_flag=True,\n",
    "              verbosity_flag=False, lr_sched='yes', decay_steps=10000, decay_rate=0.95):\n",
    "    \n",
    "    ############################################################################################## 1\n",
    "    # Getting number of features\n",
    "    num_features = X_train_tf.shape[1]\n",
    "\n",
    "    ############################################################################################## 2\n",
    "    # Building the model\n",
    "    tf.keras.backend.clear_session()\n",
    "    model = tf.keras.Sequential()\n",
    "\n",
    "    # Create input layer\n",
    "    model.add(tf.keras.Input(shape=(num_features,), name='Input'\n",
    "              ))\n",
    "\n",
    "    # Create hidden layers\n",
    "    for i, hidden_layer_size in enumerate(hidden_layer_sizes):\n",
    "      model.add(tf.keras.layers.Dense(units=hidden_layer_size,\n",
    "                                     activation=hl_act_func,\n",
    "                                     name = f'Hidden_{i+1}'))\n",
    "    \n",
    "      # Create dropout after each hidden layer\n",
    "      model.add(tf.keras.layers.Dropout(rate=dropout_rate, name=f'Dropout_{i+1}') # Need to make dropout rate variable\n",
    "              )\n",
    "    \n",
    "    \n",
    "    # Create output layer\n",
    "    model.add(tf.keras.layers.Dense(\n",
    "              activation = oput_act_func, \n",
    "              units = 1,                \n",
    "              use_bias = True\n",
    "              ))\n",
    "\n",
    "    # Set a learning rate schedule\n",
    "    if lr_sched == 'yes':\n",
    "        lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "            initial_learning_rate=learning_rate,\n",
    "            decay_steps=decay_steps,\n",
    "            decay_rate=decay_rate)\n",
    "    else:\n",
    "        lr_schedule = learning_rate\n",
    "    \n",
    "    # Set optimizer\n",
    "    if optimizer == 'SGD':\n",
    "      opt = tf.keras.optimizers.SGD(learning_rate=lr_schedule)\n",
    "    elif optimizer == 'Adam':\n",
    "      opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)\n",
    "    else:\n",
    "      raise 'Unsupported optimizer: %s' %optimizer\n",
    "\n",
    "    ############################################################################################## 3\n",
    "    # Compiling the model\n",
    "    model.compile(\n",
    "        optimizer=opt,\n",
    "        loss='mse',\n",
    "        metrics=[metrics.mse,\n",
    "                 metrics.RootMeanSquaredError(),\n",
    "                 metrics.mae]\n",
    "        )\n",
    "\n",
    "    ############################################################################################## 4\n",
    "    # Fitting the model\n",
    "    history = model.fit(\n",
    "        x = X_train_tf,\n",
    "        y = Y_train_tf,\n",
    "        epochs = epoch_count,\n",
    "        validation_data = (X_val_tf, Y_val_tf),\n",
    "        verbose=verbosity_flag,\n",
    "        callbacks=[TqdmCallback()]\n",
    "    )\n",
    "\n",
    "    ############################################################################################## 5\n",
    "    # Displaying learning rates\n",
    "    if plot_flag == True:\n",
    "        mse_mae_plots(history)\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1573f1a273f14ecd88d81c40406ea5dc",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0epoch [00:00, ?epoch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0batch [00:00, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "829/829 [==============================] - 1s 594us/step - loss: 3.9839 - mean_squared_error: 3.9839 - root_mean_squared_error: 1.9960 - mean_absolute_error: 1.0453\n",
      "MSE is 3.984\n",
      "RMSE is 1.996\n",
      "MAE is 1.045\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating the model\n",
    "final_model = create_nn(epoch_count=175)\n",
    "ffnn_results = final_model.evaluate(X_test_tf, Y_test_tf)\n",
    "print(f'MSE is {round(ffnn_results[1],3)}')\n",
    "print(f'RMSE is {round(ffnn_results[2],3)}')\n",
    "print(f'MAE is {round(ffnn_results[3],3)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}