4-Regularization_and_Keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Neural network memorize - Overfit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the striking aspects about fully connected networks is that they tend to memorize the training data given enough time. As a result, traininga FCN to convergence isn't really a meaningful metric. \n",
    "For large enough networks, it is quite common for training loss to trend all the way to zero. This empirical observation is one of the most pratical demonstrations of the universal approximation capabilities of FCN. \n",
    "Note that training loss trending to zero does not mean that the network has learned a more powerful model It is rather likely that the model has started to memorize peculiarities of the training set that are not applicable to any other datapoints.\n",
    "\n",
    "Controlling networks and preventing them from misbehaving in this fashion is critical for modeling success.\n",
    "\n",
    "Regularization is the general statistical term for a mathematical operation that limits memorization while promoting a generalizable learning. There are many different types of regularization available.\n",
    "\n",
    "## Dropout\n",
    "\n",
    "Dropout is a form of regularization that randomly drops some proportion of the nodes that feed into a fully connected layer. That means that the contribution of the dropped node to the corresponding activation function is set to 0. In this way the gradients for dropped nodes drop to zero as well. \n",
    "The nodes to be dropped are chosen at random during each step of gradient descent. The principle is that the network will be forced to avoid co-adaption. Briefly: suppose that one neuron in a deep network has learned a useful representation, then other deeper neurons will rapidly learn to depend on that particular neuron for information. This process will render the network brittle since the network will depend ecxcessively on the features learned by that neurons, which might represent a small part of the dataset, insted of learning a general rule.\n",
    "Dropout prevents this type of co-adaption because it will no longer be possible to depend on the presence of single powerful neurons, in this way the other neurons will be forced to learn useful representations as well.\n",
    "\n",
    "Dropout prevents the network from memorizing the training dta, the loss will no longer tend rapidly toward 0. And then they tends to slightly boost the predictive power of the model on new data.\n",
    "\n",
    "#### REMEMBER TO TURN OFF THE DROPOUT WHEN MAKING PREDICTIONS!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Just for plotting the confusion matrix in a fancy way ##\n",
    "from sklearn.utils.multiclass import unique_labels\n",
    "from sklearn.metrics import confusion_matrix\n",
    "def plot_confusion_matrix(y_true, y_pred, classes,\n",
    "                          normalize=False,\n",
    "                          title=None,\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if not title:\n",
    "        if normalize:\n",
    "            title = 'Normalized confusion matrix'\n",
    "        else:\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "    # Only use the labels that appear in the data\n",
    "    #classes = classes[unique_labels(y_true, y_pred)]\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "\n",
    "    fig, ax = plt.subplots(figsize = (15,10))\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    # We want to show all ticks...\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "           title=title,\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "             rotation_mode=\"anchor\")\n",
    "\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    fig.tight_layout()\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding dropout to a hidden layer\n",
    "\n",
    "TF takes care of implementing dropout in the built-in <code> tf.nn.dropout(x,keep_prob) </code> where <i>keep_prob</i> is the probability that any given node is kept. We need a new placeholders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate a dataset and plot it\n",
    "import sklearn.datasets\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn\n",
    "from sklearn.metrics import accuracy_score\n",
    "from scipy.special import logit\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "#np.random.seed(0)\n",
    "X_d, y = sklearn.datasets.make_moons(10000, noise=0.1)\n",
    "\n",
    "sc = StandardScaler()\n",
    "\n",
    "X = sc.fit_transform(X_d)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fa9fc56cfd0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X[:,0], X[:,1], s=40, c=y.reshape(-1,), cmap=plt.cm.Spectral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (7000, 2) \n",
      "Y_train shape: (7000,) \n"
     ]
    }
   ],
   "source": [
    "print(\"X_train shape: {} \\nY_train shape: {} \".format(X_train.shape, Y_train.shape))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W1213 18:28:38.104143 140370048280384 deprecation.py:506] From <ipython-input-5-c48ad49dc6d2>:39: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow version: 1.15.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1213 18:28:38.373646 140370048280384 deprecation.py:323] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/tensorflow_core/python/ops/nn_impl.py:183: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    }
   ],
   "source": [
    "print(\"Tensorflow version:\",(tf.__version__))\n",
    "#np.random.seed(0)\n",
    "X_d, y = sklearn.datasets.make_moons(10000, noise=0.1)\n",
    "\n",
    "sc = StandardScaler()\n",
    "\n",
    "X = sc.fit_transform(X_d)\n",
    "\n",
    "\n",
    "n_hidden = [70,70,70,70,70]\n",
    "n_lay = len(n_hidden)\n",
    "\n",
    "tf.reset_default_graph() #In order to permit us to instantiate new variables\n",
    "    #d = len(X_train)\n",
    "\n",
    "\n",
    "with tf.name_scope(\"placeholders\"):\n",
    "\n",
    "    x = tf.placeholder(tf.float32, (None,2))\n",
    "\n",
    "    y = tf.placeholder(tf.float32, (None,))\n",
    "\n",
    "    keep_prob = tf.placeholder(tf.float32) #Keep prob!\n",
    "\n",
    "with tf.name_scope(\"hidden-layer\"):\n",
    "\n",
    "\n",
    "    \n",
    "    for lay in range(0,n_lay):\n",
    "        \n",
    "        if(lay == 0):\n",
    "            \n",
    "            W = tf.Variable(tf.random_normal((2,n_hidden[0])))\n",
    "\n",
    "            b = tf.Variable(tf.random_normal((n_hidden[0],)))\n",
    "\n",
    "            out_hidd = tf.nn.relu(tf.matmul(x,W) + b) #(600)\n",
    "            \n",
    "            out_hidd = tf.nn.dropout(out_hidd, keep_prob)\n",
    "        \n",
    "        else:\n",
    "\n",
    "            W = tf.Variable(tf.random_normal((n_hidden[lay-1],n_hidden[lay])))\n",
    "\n",
    "            b = tf.Variable(tf.random_normal((n_hidden[lay],)))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "            out_hidd = tf.nn.relu(tf.matmul(out_hidd,W) + b)\n",
    "            #out_hidd = tf.nn.dropout(out_hidd, keep_prob)\n",
    "        \n",
    "\n",
    "\n",
    "with tf.name_scope(\"output\"):\n",
    "\n",
    "    W = tf.Variable(tf.random_normal((n_hidden[-1],1)))\n",
    "\n",
    "    b = tf.Variable(tf.random_normal((1,)))\n",
    "\n",
    "    y_logit = tf.matmul(out_hidd,W)+b\n",
    "\n",
    "    y_one_prob = tf.sigmoid(y_logit)\n",
    "\n",
    "    y_pred = tf.round(y_one_prob)\n",
    "\n",
    "with tf.name_scope(\"loss\"):\n",
    "\n",
    "    y_expand = tf.expand_dims(y,1)\n",
    "\n",
    "    entropy = tf.nn.sigmoid_cross_entropy_with_logits(logits = y_logit, labels = y_expand)\n",
    "\n",
    "    l = tf.reduce_sum(entropy)\n",
    "\n",
    "with tf.name_scope(\"optim\"):\n",
    "\n",
    "    train_op = tf.train.AdamOptimizer(0.001).minimize(l)\n",
    "\n",
    "with tf.name_scope(\"summaries\"):\n",
    "\n",
    "    tf.summary.scalar(\"loss\",l)\n",
    "\n",
    "    merged = tf.summary.merge_all()\n",
    "    train_writer = tf.summary.FileWriter('./Output/nn-train', tf.get_default_graph())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "330e4b52354446349e733b31058a50e4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, description='Epochs', max=500, style=ProgressStyle(description_width='init…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Accuracy: 0.999000\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm_notebook\n",
    "\n",
    "    \n",
    "import imageio\n",
    "images = []\n",
    "\n",
    "\n",
    "loss_train = []\n",
    "loss_test = []\n",
    "\n",
    "acc_train = []\n",
    "acc_test = [] \n",
    "\n",
    "n_steps = 500\n",
    "\n",
    "pbar = tqdm_notebook(range(n_steps), desc = \"Epochs\")\n",
    "\n",
    "\n",
    "with tf.Session() as fcnn:\n",
    "    \n",
    "    fcnn.run(tf.global_variables_initializer())\n",
    "    \n",
    "    for i in range(0,n_steps):          \n",
    "\n",
    "        dicti_train = {x: X_train, y:Y_train, keep_prob : 0.9} #Train dict\n",
    "\n",
    "        _,summary,loss = fcnn.run([train_op,merged,l], feed_dict = dicti_train) #Running the train\n",
    "        \n",
    "        dicti_test = {x: X_test, y: Y_test, keep_prob : 1} #Test dict\n",
    "        summary_t, loss_t = fcnn.run([merged,l], feed_dict=dicti_test) #Running the test     \n",
    "        \n",
    "        #Loss functions\n",
    "        loss_train.append(loss)\n",
    "        loss_test.append(loss_t)\n",
    "        train_writer.add_summary(summary,i)       \n",
    "        \n",
    "        #Making predictions    \n",
    "        y_pred_train = fcnn.run(y_pred, feed_dict={x: X_train, keep_prob : 0.9})\n",
    "        score_train = accuracy_score(Y_train, y_pred_train) #Computing the accuracy   \n",
    "\n",
    "        pbar.update()\n",
    "\n",
    "\n",
    "        #if(i % 10 == 0): #One can decide not to test every epoch but after a few ones. (Rembember to indent)\n",
    "        \n",
    "        #Making predictions on the test dataset in order to compute the accuracy every step.\n",
    "        y_pred_test = fcnn.run(y_pred, feed_dict={x: X_test, keep_prob : 1}) \n",
    "        score_test = accuracy_score(Y_test, y_pred_test) #Computing the accuracy on the test dataset\n",
    "\n",
    "        acc_train.append(score_train) \n",
    "        acc_test.append(score_test)\n",
    "\n",
    "    w_final, b_final = fcnn.run([W, b]) #Saving the final results\n",
    "    \n",
    "    # Make Predictions on test\n",
    "    y_pred_test = fcnn.run(y_pred, feed_dict={x: X_test, keep_prob: 1}) #Final predictions\n",
    "    \n",
    "    y_proba = fcnn.run(y_one_prob, feed_dict = {x:X_test, keep_prob: 1}) #Final predictions (probability)\n",
    "    \n",
    "\n",
    "    \n",
    "    score = accuracy_score(Y_test, y_pred_test)\n",
    "    print(\"Classification Accuracy: %f\" % score)\n",
    "fcnn.close() #Closing the session.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (15,10))\n",
    "\n",
    "plt.subplot(211)\n",
    "\n",
    "plt.plot(loss_test, label = 'Test')\n",
    "plt.plot(loss_train, color = 'red', label = 'Train' )\n",
    "\n",
    "plt.subplot(212)\n",
    "\n",
    "plt.plot(acc_test, label = 'Test')\n",
    "plt.plot(acc_train, color = 'red', label = 'Train')\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!tensorboard --logdir=./Output/nn-train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='Keras'></a>\n",
    "# KERAS "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensorflow and PyThorch permit to develop customised models following step by step the train chain. For a more simple use one can use keras, that has a more simple sintax. Keras is also very customizable and permit to add regularization in a very fast way. Let's see how to use Keras on a physical problem. \n",
    "This problem is a classification problem. We have two different dataset, one for the signal process and one for the background process. The purpose of the analysis is to train a model for the discrimination of signal and background events. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns #useful for statistical data visualization\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt \n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from scipy.special import logit\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "signal_file = './Data/Signal.npy' #Signal dataset\n",
    "bkg_file = './Data/Background.npy' #Background dataset\n",
    "s_header_file = './Data/Signal_var.npy' #Signal variables names\n",
    "b_header_file = './Data/Background_var.npy' #Background variables names.\n",
    "\n",
    "#Simple function that returns the features dataset and the target one (label = signal, background (1,0))\n",
    "def to_xy(df,target):\n",
    "    y = df[:,target]\n",
    "    x = np.delete(df, target, 1)\n",
    "    return x,y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = np.load(signal_file)\n",
    "B = np.load(bkg_file)\n",
    "S_header = np.load(s_header_file)[0,:-1]\n",
    "B_header = np.load(b_header_file)[0,:-1]\n",
    "dataset = np.vstack([S,B])\n",
    "np.random.shuffle(dataset)\n",
    "train,target = to_xy(dataset,dataset.shape[1]-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(0,7):\n",
    "    plt.hist(S[:,i],bins = 100, density = True,histtype = 'step', fill = False,linewidth = 1.5,label = 'Signal')\n",
    "   # plt.hist(my_data[:,feature_index], 50, density=True, histtype='step', fill=False, linewidth=1.5)\n",
    "    plt.hist(B[:,i],bins = 100, density = True,histtype = 'step', fill = False,linewidth = 1.5,label = 'Bakground')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Correlation matrix\n",
    "\n",
    "Seaborn permits to visualize the heatmap of a matrix exploiting the method <code>sns.heatmap()</code>. We will compute the correlation matrix through the pandas library.\n",
    "\n",
    "### Signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa987930278>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAJDCAYAAAAcrI56AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4VMX+x/H3JICBJEASIEsUJXQF6SIqSqJ0Ba+gYgOsgO1nAQvgVVSwNxQbF+UCFryKBQQLckEFRYQg9YqQUE2hhEACSYBkfn/sEtKAXbIlq5/X8+yT7Dlzzn4ne/Zk9jsz5xhrLSIiIiLBLCTQAYiIiIhUlBo0IiIiEvTUoBEREZGgpwaNiIiIBD01aERERCToqUEjIiIiQU8NGhEREQl6atCIiIhI0FODRkRERIJeFX+8yKFdKX/byxFf2+HeQIcQUB2pGegQAur+xQ8FOoSAeu38ZwMdQsA8lL4g0CEE1FP1EwMdQsA9uOU946/X8vf/2ap1Gvmtbu5ShkZERESCnho0IiIiEvT80uUkIiIiPlRYEOgIAk4ZGhEREQl6ytCIiIgEO1sY6AgCThkaERERCXrK0IiIiAS7QmVolKERERGRoKcMjYiISJCzGkOjDI2IiIgEP2VoREREgp3G0ChDIyIiIsFPDRoREREJeupyEhERCXYaFKwMjYiIiAQ/ZWhERESCnW5OqQyNiIiIBD9laERERIKdxtAoQyMiIiLBTxkaERGRYKcL6ylDIyIiIsFPGRoREZEgp5tTKkMjIiIifwHK0IiIiAQ7jaFRhkZERESCnzI0IiIiwU5jaJShERERkeCnDI2IiEiw072clKERERGR4KcGjYiIiAQ9dTmJiIgEOw0KVoZGREREvMsY08sYs94Ys9EY83A5688wxsw3xqwyxiw0xpxW0ddUg0ZERCTYFRb693EcxphQ4HWgN3AWcK0x5qxSxV4ApllrWwNPAE9X9E+gBo2IiIh4Uydgo7U2xVp7EJgBXF6qzFnAfNfvC8pZ77G/9BiaR556iR8WLyU6qjafv/dWoMPxiZvH3ka7xI4czM1n4shX2LQmpcT6amHVGPHmQzhOr09hYSHLvlvK+89OA+DMTi256bFbOaNFQ16++3mWzP0pEFXwWLexg2ic2JZDufnMGTmJjDWby5SJbdWQS18cRtWwaiQv+I3vxk4HoHmfTnS5rz91msQxtd9jpK/eVLRN3RYN6PX0zVSLqI4ttEzt9ygF+Yf8VS2PLVq6gmdfn0JBYSH9+1zCrddeUWJ9asZOHn3+dTKz9lGrZgRPj7oHR90YANIydvLYi2+SvnM3BsMbT4/mVEe9QFTjuBp2bU3i2EGY0BDWzFjI0jdml1gfWq0KvV8eTr2z48nbk82Xd05k3/ZdAHS6sy+tBiZgCwr572PT2PLDagB6Pn8bjS5py4Hd+5jafVTRvi57/S6iGtUH4JSaNcjfd4Dpvcf4qaaee/mlJ+jd62IO5OZyyy33seK3NWXKzJ/3MY76seTm5gHQu8+17Ny5u2h9//6X8p8Zkzi3c2+WJ63yW+zecMnYQTRynQe+Os55oM+Lw6gSVo2UBb8xv9h54IL7+hPTJI7ppc4DQcvPY2iMMUOBocUWTbLWTnL9fiqwrdi67cC5pXaxEhgATACuACKNMTHW2t2cpL90huYffbrz1kvjAh2Gz7RL7ED9+Dju7jqMt0a9ztBxt5dbbtakz7nnkjt4oM+9tOh4Ju0S2gOwK3Unr4+YwKIvvvdn2BXSKLENUfEO3u46gq9HvUPPcTeWW67n+Jv4etQ7vN11BFHxDholtAZg1x/b+WzYBLb9sr5EeRMaQt9Xbueb0VN4p/vDfDBwPIWHDvu6OietoKCA8a9O5o2nx/DFuy/z1X8Xkbx5W4kyL7w1lb7dE/h08ksMH3QVEya/X7Ru9LOvcePVlzNrygQ+fONpomvX8ncVTsiEGC4ZN4RPhzzHvy95kOb9OhPdNK5EmVYDE8jbu593LxrB8slfc9GoawCIbhpH876dmdrtIWYOfo5u42/EhBgA1nz8AzMHP1/m9b68cyLTe49heu8xbPjqVzZ8/avvK3mSeve6mKZN4mlxVhduv/0hXp947Gz94MF30fGcHnQ8p0eJxkxERDh333kzv/yS5I+QverIeeBfXUfwzah36H6M80CP8Tfxzah3+JfrPBDvOg/s/GM7n5dzHhD3WWsnWWs7FntMKrbalLdJqecjga7GmBVAV+BPoEInXbcaNMaYeHeWVTYd255NrZqRgQ7DZ87pfi4LZy4AYMOK9dSoGU7telElyhzMO8jan53fTA8fOkzKmmRiHHUA2Ll9B1t+30xhYenjrPJq2r0Da2YuAiB1RTKn1AwnvF7tEmXC69XmlIjqpCZtBGDNzEU07dERgN0bU8lMSSuz3/iLzmbH79vY8b+tAORl5WAr8d9l9e8bOf1UBw3iYqlatSq9Ey9gwU8l/wGnbNnOue3PBqBT21ZF65M3b6OgoJDzO7YBoEb16lQPO8W/FXCDo21jsjZnsHfrTgoPFbB+9hKa9OhQokyTHu1Z+8mPAPwxdymnX9DStbwD62cvoeDgYfZt20nW5gwcbRsD8OfS9eRl5Rz3tZtfdi6/f/GzD2rlHX379mT6+58A8MvSJGrVroXDwwzb42Mf5IUX3yQvL88XIfpUk+4dWOs6D6StSCbsGOeBasXOA2uLnQcyj3EeCGqVaAwNzoxMg2LPTwNSixew1qZaa/tba9sBY1zL9lbkT+BuhmZmOcs+qcgLS8XFOGLYnbqz6Hlm+m5iYmOOWb5GzXA6duvEqsUr/RGeT0Q6oshOPfotMzs9k8jYko24yNgostMzj5ZJyyTSUbJMadHxDrCWq6c9yI1zxnHusEu9G7iX7diViaNunaLnsXVjyNiVWaJMs8YN+e6HJQDMX/QL+w/kkrU3m83b04gMr8G9jz3HVcNG8uLb0ygoqHxXGY1wRJGdWvJ9jCj1XhcvYwsKyc8+QPWoCCJiy9n2BMfAEad2as7+XXvJ2pzhhVr4xqlxDrZvO/r/4c/taZwa5yi37OTJL7Hs128ZM/reomVt27akQYP6zJn7nc9j9YVIRxT7fHAeEK/5FWhqjIk3xlQDrgFmFS9gjKljjDnSBhkFvFvRFz1ug8YY08IYMwCoZYzpX+xxIxB2gm2HGmOWGWOWTZ72YUXjlPKUk9SztvysQkhoCPe9NpK5U75kx7bKe6I+IVO20mXqXE4ZjvF3OSKkSiinndOM2fe8wXsDnqBZr46c4fq2XxnZMtlbMKXqPXLYYJatWstVw0aybOU66tWJJjQ0hIKCApLW/M6IYUP48I1n2Z6WwRffLPRT5O4rXR+gbNK63OPBzW2PocXl51Xq7AyUX7/yPvuDhtxNu/bdSEi8gi4XdOKGG67EGMOLz4/lgQef8EeovnGS54FjnR//Cqwt8Ovj+LHYw8BdwDfA/4D/WGvXGmOeMMb0cxVLANYbY/4AYoHxFf0bnGhQcHPgMqA20LfY8mzgtuNt6OpPmwRwaFfKX/co8rNeg/twyTU9AEhetYGYuLo4jxeIdsSQuSOz3O2GP3MXaZtSmfPurHLXV2btB3ejzTWJAKStSiEy7mgWKtIRTc6OrBLls9MziXREHy1TP5rsjJJlSstOy2Tbkt/J3ePsikhesJLYVg3Zsnitt6rhVbF1YkjfuavoecbO3dSLKfnts16daF55/EEADuTmMu/HJURGhBNbN4YWTRrSIC4WgIsv6MTKdX/Qn0v8VwE3ZKdlEhlX8n3M2bGnRJkcV5mc9ExMaAinRNYgLyvHeQyU3jaj5LblMaEhNO11Du9d+k/vVcRLbh8+hFtuuR6AZct+47QGR8cTnXpafVLTyn5RSU1NByAnZz8fzvicczq2Zdasb2jZsgXz5zmT7A5HXT77dApX9L+pUg8Mbje4G61d54H0VSnUjIvhT9c6d88DOSc4D4j3WGvnAnNLLXu02O+f4OWenuNmaKy1X1hrbwIus9beVOzxf9ba4JgS8xfz9bS5PNDnXh7ocy9Lv/2FhAHOD3jTds05kH2ArB1lT9rXjLyeGpE1mPL4ZH+H6xVJ075jSp8xTOkzhg3fLqfVgC4AxLVrTH72AfaXOpHt35HFwf15xLVzjploNaALG+YtP+5rpHy/irpnnk6VsGqY0BBOP7cFuzf8edxtAqlViyZs+TON7WkZHDp0iK8WLCbh/HNKlNmzdx+Frr7uyR98xhW9LnZu27wx+7L3k5nl7K7+ZcUaGp9R4WtaeV36yhRqxzuo2aAuIVVDad63M8nzSg5gTZ6XRMsrLwSgWZ9ObP1pXdHy5n07E1qtCjUb1KV2vIP035JP+JpndGlFZnIqOenlfzEIpDffmlo0uHfWrG8YdP2VAJzbqT379u4jPX1HifKhoaHEuBq5VapU4dJLu7F27Xr27cvGEXc2TZp1pkmzzvzyS1Klb8wArJj2HVP7jGGq6zzQ0nUeqH+C80B913mg5YAubDzBeSCo2UL/Piohd6dtZxhjZgOdcSZufwbus9amHH+zwHrgsWf4dcUqsrL2cck/buCOWwYxoG/PQIflNUn/XUb7xA5M/OFt8nPzeWPkq0Xrnp/7Cg/0uZdoRwxX3j2Q7Ru38dyclwH4etoc5s+YR+PWTXhw0mjCa0XQsds5DLzvOu7rflegquOW5P/+RqPENgz74UUO5R5k7sijA+tvmjueKX2c02y/GTOFS18c6pyuuXAlKQuc44aa9exIt8cHUyM6kqumjCRj3Rb+M/g58vcd4NfJXzFk9hNgLckLVpL8398CUkd3VAkNZfTdtzL8oXEUFBZyRe+LadKwAROnzKBl88Yknn8Ov/62lgnvvI/B0KH1WYz5v1sB5z+6EcMGc+vIx7HAWU0bceWl3QJboXLYgkL++8+pDJj+ICGhIaz56Ht2//En598/gIzVm0iel8Tqj76n9yvDufmHF8nLymHOXRMB2P3Hn/zx5S/cOP9ZCg8XMv+RfxcN8r70tTs57bwzqR4VwdBfXuWnl2ay5iPnTL/m/Trz+6zK3d0EMPer+fTqdTHr/7eYA7m53Hrr/UXrlv36LR3P6cEpp1Rj7pwPqFq1CqGhocyf/yOT33n/OHsNHimu88BtP7zI4dyDfFXsPDBk7nimus4D88ZMobfrPLCp2Hmgqes8UD06kgFTRrJj3RY+HvxcQOoi3mPc6VM0xizBedW/I4NhrgHuttaWnlderr9zl9O1He49caG/sI7UDHQIAXX/4ocCHUJAvXb+s4EOIWAeSl8Q6BAC6qn6iYEOIeAe3PJeedOXfSIvaZZf/8+Gte/nt7q5y91ZTsZaO91ae9j1eA+3h9iJiIiI+Ja7XU4LXDeXmoGzITMQmGOMiQaw1la+DmcREZG/i0o6rsWf3G3QDHT9HFZq+c04GziNvBaRiIiIiIfcatBYa497VWBjTHdr7TzvhCQiIiLiGW/dnPJZQA0aERGRQCisfFf79jdv3Zyy0o12FhERkb8Pb2VoNONJREQkUDQo2GsZGhEREZGA8VaGZrOX9iMiIiKeKlSGxq0GjTHmR+AH4EdgsbU2u/h6a21/H8QmIiIi4hZ3u5yGAOuBAcBPxphlxpiXfReWiIiIuE03p3T7OjQpxphc4KDrkQic6cvARERERNzlbpdTMrAL+AB4B+eNKStnE01EROTvRmNo3O5yehXYClwL/B8wxBjT2GdRiYiIiHjA3S6nCcAEY0wEcBMwFjgNCPVdaCIiIuIWZWjc7nJ6AbgQiACWAI/inPEkIiIiEnDuXofmduAZ4GNr7e8+jEdEREQ8ZK3u5eTuGJp+OO/X9JoxJtkYM9MYc48P4xIRERFxm7tjaOYbYxYC5+Ccsj0caAlM8F1oIiIi4haNoXF7DM18IBz4GefYmXOstTt8GZiIiIiIu9wdQ7MK6AC0AvYCWcaYn621uT6LTERERNyjS8O53eV0H0CxadtTAAdwiu9CExEREXGPu11Od+Gctt0B2AK8i6Zti4iISCXhbpdTdeAlYLm19rAP4xERERFPaVCw211Oz/s6EBEREZGT5W6GRkRERCorDQp2+8J6IiIiIpWWMjQiIiLBTmNolKERERGR4KcMjYiISLDTGBplaERERCT4KUMjIiIS7DSGRhkaERERCX5+ydBc2+Fef7xMpfTh8lcCHUJAvdXu0UCHEFADzx8d6BAC6jxTK9AhBMxT9RPpH74z0GEEzG97bKBD+HtRhkYZGhERX/g7N2ZEAkFjaERERIKdZjkpQyMiIiLBTxkaERGRYKcxNMrQiIiISPBTg0ZERESCnrqcREREgp0GBStDIyIiIsFPGRoREZFgp0HBytCIiIhI8FOGRkREJNhpDI0yNCIiIhL8lKEREREJdhpDowyNiIiIBD9laERERIKdMjTK0IiIiEjwU4ZGREQk2Fkb6AgCThkaERERCXrK0IiIiAQ7jaFRhkZERESCnzI0IiIiwU4ZGmVoREREJPipQSMiIiJBT11OIiIiwU43p1SGRkRERIKfMjQiIiLBToOClaERERGR4KcMjYiISLDTrQ+UoREREZHgpwyNiIhIsNMYGmVoREREJPgpQyMiIhLslKFRhkZERESCnzI0IiIiwU5XCv5rNGhuHnsb7RI7cjA3n4kjX2HTmpQS66uFVWPEmw/hOL0+hYWFLPtuKe8/Ow2AMzu15KbHbuWMFg15+e7nWTL3p0BUwSceeeolfli8lOio2nz+3luBDscrTk9ozUVjB2FCQ1j34UKWvzG7xPqQalXo8cpw6p4dT96ebL6+YyLZ23cRVjuC3m//H/XaNOL3j3/g+3863/+q4WEMmPnPou0j6kez/tPF/Pj4e36t18m65fGhdEjsQH5uPq+NmEDKmuQS66uFncIDbz6E44yjx/70Z6YC0O/Wy+l2bQ8KDhewL3MfE0dOYOefOwNRjZN2ydhBNEpsy6HcfL4aOYmMNZvLlIlt1ZA+Lw6jSlg1Uhb8xvyx0wFo3qcTF9zXn5gmcUzv9xjpqzf5OfqTV6NLR+qMGg6hoez75CuyJv+nxPqaAy+l1rV9obCQwv257Bg7gUPJWwmpFYnjlX8SdnYz9n02j13jXw9QDSomNrE1bZ9wngc2fbCQ9RNLngfqdG5BmyduoNaZp/PL8In8OWdp0bouHzxIdPsm7F76B4sHv+DnyMWXgr7LqV1iB+rHx3F312G8Nep1ho67vdxysyZ9zj2X3MEDfe6lRcczaZfQHoBdqTt5fcQEFn3xvT/D9ot/9OnOWy+NC3QYXmNCDAnjhjBr8HO8f/GDNLu8M1FN40qUaXlNAnlZ+5l+4Qh+m/w1F4y+BoDD+YdY8sInLB73QYnyh/bnMaPXmKJH9vZdJH/9q9/qVBHtEzsQ1zCOOy4axpsPv86w8eUf+19M+oy7L76dEb3voUXHM2mf0AGAlLUpjLz0fu7r+X/8NGcxg0ff5M/wK6xRYhui4h38q+sIvhn1Dt3H3VhuuR7jb+KbUe/wr64jiIp3EJ/QGoCdf2zn82ET2PbLej9G7QUhIdR95E5Shz3C1r63EdknkaqNTy9RJPvLBWz7x3C29b+DPe9+TJ0HhwFgDx4k87Wp7Hr+X4GI3DtCDO2eupFF1z/HN10fpME/ziOy2aklihzYvotl97zNts/KfkH94405/Hr3m/6K1m9sofXrozIK+gbNOd3PZeHMBQBsWLGeGjXDqV0vqkSZg3kHWfvzagAOHzpMyppkYhx1ANi5fQdbft9MYSV9gyqiY9uzqVUzMtBheE1s28Zkbc5g39adFB4q4I9ZS2jUo0OJMvE92vP7Jz8CsHHOUk67oCUAh3PzSfv1Dw7nHzrm/ms1jKV6nZqkBsk/uE49OrNg5n8B+GPFesJrhhNV5tjPZ03pY79+DABrfl7Nwbz8ou2PLA8WTbp3YO3MRQCkrUgmrGY44fVqlygTXq821SKqk5q0EYC1MxfRtEdHADI3ppKZkubfoL0g7OzmHNqayuHt6XDoMDlfLSTi4vNKlLH7DxT9HlI9DHCe32xuPnlJa7H5B/0ZsldFt2tMzuYM9m/diT1UwLYvlhDXs+R54MD2Xez937Zy//HuWLSWwzl5/gpX/CjoGzQxjhh2px5Nk2em7yYm9tgn5ho1w+nYrROrFq/0R3jiReGOKHJSM4ue56RlEuEo+Q88whFFtquMLSjkYPYBwqIi3Np/s8vPY8PsJd4L2MdiHDHsTttV9Hx3+m6iHSd37Hcb2J2kBct9EqevRDqi2Je6u+h5dnomkbElj4fI2Ciy048eM9lpmUSWOmaCTWhsDIfSj57zDqfvIrRenTLlal3blzO+nkLMiFvZ9dQb/gzRp6o7osn98+j7npuWSfUgf0+9orDQv49K6IQNGmPMK66fs40xs0o9vjDGTDHGdPZ9qMcKsOwie4xLQIeEhnDfayOZO+VLdmzL8HFg4m3GlH2zy77V5R0Q7u2/Wb/z+OOLnz2OqzI53rE/4rUHmDNlNhlbSx77Xa9IoHHrJnz+9qf+CNF7yj0erOdlgk05dSrvIN/74Wy29LqJ3S+9Q9Sw63wfl7+UW/0gf0/FK9wZFDzd9fNYo6fqAO8CZxVfaIwZCgwFaBfdmkYRZ5xsjGX0GtyHS67pAUDyqg3ExNUF/gdAtCOGzB2Z5W43/Jm7SNuUypx3Z3ktFvGfnLRMIuKii55H1I9mf8aekmXSM4mMi2Z/eiYmNIRqkTXIy8o54b7rnHk6pkoIO1dv9nbYXtV7cB+6X9sTgI2rNhBT/+g38xhHDHsyyj/273jmLlI3p/LlOyWP/dZd2nDlXVfzyNWjOHzwsO8C95J2g7vR+ppEANJXpVAzLoY/XesiHdHk7MgqUT47PZNIx9FjJrJ+NDkZJcsEm4L0XVR11C16XsVRh4Idu49ZPmfuQuo+erc/QvOL3LRMqp96NBNZvX40uUH+nop3nLBBY61d7vp5zFGzxpgyHbLW2knAJIArz+jn1ebz19Pm8vW0uQC0v7gjvYdcyuJZP9C0XXMOZB8ga8eeMttcM/J6akTW4M0HX/NmKOJHGStTqN3QQc0GdclJz6RZv858c3fJVPqmeUm0uPJC0pM20uTSTmxfvM6tfTe7/Dw2BEF25qtpc/nKdex3uLgjfYZcxqJZP9DMdezvKefYv27kDdSIDOf1Usd+fMtG3P70nTwx6DH27t7rl/grasW071gx7TsAGl3clvZDuvO/WT9Tv11j8rMPsL9Ug2b/jiwO7s+jfrvGpK1IpuWALiT9+9tAhO41eWvWU/WMU6lyaiyHd+wmoncCGQ8+U6JM1TPiOLQlFYAaXTtxaMuf5e0qKO35LYWIeAc1GtQlNz2TBpd3ZukdwTlby6s0bRtzovSrMeY/1tqrjTGrKZvXtEAmMMFa+/mx9uHtBk1ptz45jLZd25Ofm88bI18lebVzAODzc1/hgT73Eu2IYdIvU9i+cRuHXINCv542h/kz5tG4dRMenDSa8FoRHMo/SNbOLO7rfpfXYvtw+Ste25enHnjsGX5dsYqsrH3ERNfmjlsGMaBvT7/G8Fa7R726vzMS23Dh2BsICQ1h3Uffs+y1WZw7YgA7Vm1i07wkQk+pSvdXhlO3VUPys3L4+s6J7NvqHG8w5KeXqRZZnZCqVTi47wCfX/8MezY4T/qDF73E7CHPsyfZu4NE/2t821AY+uRw2iU4j/3XRk4geZXz2H/pqwnc3/seYhwxTF76b7Zv2Mahg85jf+7UOXw341vGfvAkZzQ/o6gRtDN1J0/f4t1ZceeZWl7dX2ndnhxCfNfWHM49yFcjJxVNvR4ydzxT+4wBwHF2PL1fHEqVsGpsWriS7x51Ttlv2rMj3R4fTPXoSPL3HWDHui18PPg5r8XWP9x3U+BrXHQOdR4ejgkJYd9n37Ln7Q+JvmsweWv/4MCCJdQZNZzq57WHw4cp2JvDrvGvc3DjFgDOmDeVkIhwTNUqFO7L4c/bRnMoeavXY/xtT9lxPd7iuLgNbVzTtjfP+J7fJ3zBWQ8MYM/KTaR9m0RUm0ac9+59VKtdg4K8Q+Tt3Mu8hIcASPj8n0Q2iaNKjTDy9+SwfMQkMhau9kmcV6a9X14HmU8cePNuv/a71bj9Nb/VzV3uNGjqW2vTjDHH6jOqA7xvrW1xrH34ukFTmQWyQVMZeLtBE2x83aCp7HzdoKnMfNmgCQa+bNAEC782aF6/y78NmjsnVroGjTtdTmmun1uOUWSLMeZ6r0YlIiIi4oETNmiMMdmU7GoyrucGsNbamkfG2YiIiEgAVNKp1P7kTobmr3NlNhEREflL8uheTsaY9kAXnBmaRdbaFT6JSkRERNynDI37Vwo2xjwKTAVicA4E/rcx5hFfBSYiIiLiLk8yNNcC7ay1eQDGmGeAJOCvc/dDERGRYKSrJXt0L6fNQFix56cAyV6NRkREROQkuDPL6TWcY2bygbXGmHmu592BRb4NT0RERE5IY2jc6nJa5vq5HPis2PKFXo9GRERE5CS4M2176pHfjTHVgBY4MzTrrbVl7uEkIiIiflaoMTRuDwo2xvQB3sY5bsYA8caYYdbar3wVnIiIiIg7PJnl9BKQaK3dCGCMaQzMAdSgERERCSTdbdujWU47jjRmXFKAHV6OR0RERMRj7sxy6u/6da0xZi7wH5xjaK4CfvVhbCIiIiJucafLqW+x3zOArq7fdwJRXo9IREREPKNBwW7NcrrJnR0ZY0ZZa5+ueEgiIiIinvFkDM2JXOXFfYmIiIibbGGhXx8nYozpZYxZb4zZaIx5+BhlrjbGrDPGrDXGfFDRv4FHd9s+AePFfYmIiEgQMsaEAq/jvKPAduBXY8wsa+26YmWaAqOAC6y1e4wx9Sr6ut5s0KgDT0REJBAq1xiaTsBGa20KgDFmBnA5sK5YmduA1621ewCstRWeNe3NLidlaERERORUYFux59tdy4prBjQzxiw2xiwxxvSq6Iu61aAxxoQaY+47QbGPKxqMiIiInARb6NeHMWaoMWZZscfQYtGUl+AonUKqAjQFEoBrgcnGmNoV+RO41eVkrS0wxlwOvHycMk9VJBAREREJDtbaScCkY6zeDjQo9vw0ILWcMkustYevkFh0AAAgAElEQVSATcaY9TgbOCd9fTtPxtAsNsZMBD4C9h9ZaK1NOtkXFxERES+oXGNofgWaGmPigT+Ba4DrSpX5HGdm5t/GmDo4u6BSKvKinjRoznf9fKLYMgtcXJEARERE5K/DWnvYGHMX8A0QCrxrrV1rjHkCWGatneVa18MYsw4oAB6w1u6uyOu63aCx1iZW5IVERETER9y4Now/WWvnAnNLLXu02O8WuN/18AqPpm0bYy4FWgJhxYJ64thbiIiIiPie2w0aY8xbQA0gEZgMXAks9VFcIiIi4q7KNYYmIDy5Ds351trBwB5r7ePAeZQcxSwiIiISEJ50OeW6fh4wxsQBu4F474ckIiIiHrGVawxNIHjSoPnSddGb54EknDOcJvskKhEREREPeNKgec5amw/MNMZ8iXNgcJ5vwhIRERFxnydjaH4+8ou1Nt9au7f4MhEREQmQQuvfRyV0wgyNMcaB86ZS1Y0x7Th6j4aaOGc9iYiIiASUO11OPYEbcd6L4aViy7OB0T6ISURERDxgK9mF9QLhhA0aa+1UYKoxZoC1dubJvEhHap7MZn8Jb7V79MSF/sKGr/h7X3dxf4e/9/sfWjkz034xO6duoEMIqMKqgY5A/m7c6XK6v7zfj7DWvlR6mYiIiPhRJR3X4k/udDlF+jwKERERkQpwp8vpcX8EIiIiIidJGRr3p20bY5oZY+YbY9a4nrc2xjziu9BERERE3OPJdWj+BYwCDgFYa1cB1/giKBEREfGALfTvoxLypEFTw1pb+u7ah70ZjIiIiMjJ8OTWB7uMMY1x3sMJY8yVQJpPohIRERH3aQyNRw2aO4FJQAtjzJ/AJuB6n0QlIiIi4gGPrkMDzAUW4Oyq2g8MoOTVg0VERMTPrDI0Hl2HpjlwDvAFzvs5DQJ+8FFcIiIiIm5z+zo0xphvgfbW2mzX87HAxz6NTkRERE5MGRqPZjmdDhws9vwg0NCr0YiIiIicBE8GBU8HlhpjPsM50+kKYKpPohIRERHxgNsNGmvteGPMV8CFrkU3WWtX+CYsERERcVth5bzYnT95kqHBWpsEJPkoFhEREZGT4lGDRkRERCohDQr2aFCwiIiISKWkDI2IiEiwU4ZGGRoREREJfsrQiIiIBDlrlaFRhkZERESCnjI0IiIiwU5jaJShERERkeCnDI2IiEiwU4ZGGRoREREJfsrQiIiIBDmrDI0yNCIiIhL8lKEREREJdsrQKEMjIiIiwU8NGhEREQl66nISEREJdoWBDiDwlKERERGRoKcMjYiISJDTtG1laEREROQvICgzNN3GDqJxYlsO5eYzZ+QkMtZsLlMmtlVDLn1xGFXDqpG84De+GzsdgOZ9OtHlvv7UaRLH1H6Pkb56U9E2dVs0oNfTN1Mtojq20DK136MU5B/yV7XccnpCay4aOwgTGsK6Dxey/I3ZJdaHVKtCj1eGU/fsePL2ZPP1HRPJ3r6LsNoR9H77/6jXphG/f/wD3/9zGgBVw8MYMPOfRdtH1I9m/aeL+fHx9/xaL2975KmX+GHxUqKjavP5e28FOhyv8sXxX+u0Otw6/zkyk9MASF2xkW/GTPFbnUpLfHwQ8YltOZybz9cjJrGjnDrWO7shvV4cRpWwamxa8BsLHnPWMaxWOJe9cRc1T6vLvu07mX3Ha+TvPXDc/V44aiCNLm4LwJJXP2f97F8AGPjJP6kWHgZAjTo1Sf8tmS9ue8XHtT/qjK6tSRg7iJDQENbMWMivpT7vodWq0PPl4cSeHU/unmzm3jmRfdt3AXDOnX1pNTCBwoJCFj42jS0/rAag3c09aXVtAsYYVn+4gBXvfANA5/v6c/a1CRzYnQ3A4uf+w+YFK/1W1yMadm1Nousct2bGQpaWU+feLw+nnusc92WxOndy1dkWFPLfYnU+1j57vjiUBue2ID87F4CvR7zNznVbafGP8+l0+2UAHNqfx3dj/s3O/23115/g5ChDE3wNmkaJbYiKd/B21xHEtWtMz3E3Mu0fY8uU6zn+Jr4e9Q6pSRu5auoDNEpoTcrCVez6YzufDZtAr6duLlHehIbQ95Xb+fK+t9jxv62E1Y6g8NBhP9XKPSbEkDBuCJ9f9ww5aZkM/PIJUuYtZ8+G1KIyLa9JIC9rP9MvHEHTfp25YPQ1fH3HRA7nH2LJC58Q0/w0YpqfVlT+0P48ZvQaU/R84JwnSf76V7/Wyxf+0ac71w3ox+gnXwh0KF7lq+MfIGtLBlP6jCmz3N/iE9sQ1dDBuxeNoH67xnQbfyMfXD62TLlu429i3sPvkJa0kf5TH6BhQms2L1xFpzv7snXxOpa+MZtOd/Sl0x19+fHpj4653/iL2xLbqiHTeo0htFpVBn48hk0LVnEwJ5ePrnyy6PX6vvV/JM9L8tvfwYQYLh43hE+vf4bstEyum/0EyfOWk1n88z4wgfy9+5ly0Qia9e1Ml1HXMPfOiUQ3jaN5385M6/YQ4bFRDPjgYf7ddSTRTU6l1bUJfNj3MQoOHab/9AfZNP83sjZnAJA0+WuWT5rrtzqWZkIMl4wbwieuOl8/+wk2lqpzq4EJ5O3dz7sXjaB5385cNOoavixW56muOl/1wcO823UkwHH3+f1TH7Jhbslz3r5tO/no6nHk7z1Aw4TWdH/m5nKPQalcgq7LqWn3DqyZuQiA1BXJnFIznPB6tUuUCa9Xm1MiqpOatBGANTMX0bRHRwB2b0wlMyWtzH7jLzqbHb9vY4erFZ6XlVPp+iRj2zYma3MG+7bupPBQAX/MWkKjHh1KlInv0Z7fP/kRgI1zlnLaBS0BOJybT9qvf3D4OBmnWg1jqV6nJqm/rPddJfykY9uzqVUzMtBheJ2vjv/KpHGPDqxz1THtBHVMc9Vx3cxFNOnprGPj7h1Y6/oMrP3kR5q46n6s/cY0PZVtS37HFhRyODefneu20jChdYnXqxoexukXtGTjN8t9V/FSHK7P+17X53397CU0LvV5b9yjPetcdd0wdymnuz7vjXt0YP3sJRQcPMy+bTvJ2pyBo21jopvGkZaUzOG8g9iCQrYv+Z0mvTr6rU4nUl6dm5Sqc5Me7Yve3z+K1bnJMerszj5LS12+oSirl7ZiIxH1o31QWy8r9POjEjphg8YYU9P1M7qcR5QxJtT3YR4V6YgiO3V30fPs9EwiY6NKlomNIjs982iZtEwiHSXLlBYd7wBruXrag9w4ZxznDrvUu4F7QbgjipzUo/XKScskolS9IhxRZLvK2IJCDmYfICwqwq39N7v8PDbMXuK9gMXrfHX8A9RqUJeb5o7juo/GcNo5zb0XtIciHFFkp5WsY7nHefE6FitTo05N9u/IAmD/jixq1Kl53P3uXLeF+MQ2VAmrRvWoCBqcfxaRpf6BNe3Vka2L13IwJ9e7lT2O4p9lcH3eY4//ec93fd4jYsvZ1hHF7vXbOe3c5oTVjqBKWDUaJrYhon5MUbk2Q7pzwzdP0f352zilVg0f17Cs0nXOdrPO1cupc7arzifaZ5cHrmbwN0+R8Oj1hFYr22lx9sAENi9Y5bU6iu+40+X0AXAZsBywgCm1PsIY8y9r7ejiC40xQ4GhAFdEd6JTRFMvhAuY0i8P1toTlqF0mVJCqoRy2jnNmNr3UQ7lHuTaD0eRvmYzWxavrUi0XmXKrXuZUmU3dDPR1KzfeXx775sexyV+5KPjP2dHFm+cdy95WTnEtmrIgH/dx+TuD/v1H/gRppxjuEwdyz3Oj1/HY+13y49rcLRpxLWfPUZu5j7Slm+gsKDkV9AW/c5j9YyFJwrdu9z4vJd3TnCepcvfNnNjKr+++SX933+YQwfy2PW/rdiCAgBWTf+OXyZ8hrVw/sgrueiR65n3wL+8URO3HbM+JQuVLWKPva0JOfY+Fz37H/bvyCK0WhW6P3ML59x+GUsmfF5UrMF5Z9JqYFdmDHiy7D4qmcrWoxAIJ2zQWGsvc/2ML2+9K0OzBhhdartJwCSAZ864oUJ/6faDu9HmmkQA0lalEBl39BtFpCOaHNe3sSOy0zOJdBz9hhVZP5rsjJJlSstOy2Tbkt/J3ZMDQPKClcS2alipGjQ5aZlExB2tV0T9aPZn7ClZJj2TyLho9qdnYkJDqBZZg7ysnBPuu86Zp2OqhLBz9WZvhy0V5I/jv+DgYQoOOo+TjDWbydqyg+h4R4lB877UdnA3zr7WWcf0VSlE1i9Zx/2l4s8pXUdHNDmuMgd27SO8Xm3278givF5tDuzaB7j+LsfY7y8TZ/HLxFkA9Hn1DrI2pReVC6sdgaNtI74Y6r/BwOD8vEeW/rzvKPl5z3aVyXF93k9xfd6PnAdKbOs6V6z96HvWfvQ9ABc8eDXZac7sxZG/E8CaDxdw+ZQRPqvbsWSXqnNk/WhyStU55xh1zk4vZ1tXnY+1zyOZvIKDh1nznx/oOKxPUbk6LRrQ47lb+XTw826dQyXw3OlyauH62b6cRzvgNGvtmb4MMmnad0zpM4Ypfcaw4dvltBrQBYC4do3Jzz5QdFAesX9HFgf35xHXrjEArQZ0YcO84/d9p3y/irpnnk6VsGqY0BBOP7cFuzf86ZsKnaSMlSnUbuigZoO6hFQNpVm/zmwqNUhx07wkWlx5IQBNLu3E9sXr3Np3s8vPY8MXP3s9Zqk4fxz/1aMji77J1mpQl6j4WLK27vBBbcr327TvmN57DNN7j2HjN8s5y1XH+ieoY31XHc8a0IXkb511TJ6XREvXZ6DllReSPO/o8vL2a0IMYbWd3bJ1WjSg7pkN2OyaHQPQ7LJOpMz/ze8zHtNXphAVf/Tz3rxvZ1JKfd5T5iVxlquuTft0YttP64qWN+/bmdBqVajZoC5R8Q7Sf0sGoHqMswsuMi6GJr06sn7WTwAlxik17tmR3eu3+7yOpaWvTKF2qTqXHohd/P1t1qcTW111Ti5V59quOh9vn8Xr3KRnh6I6R8bF0G/SvXx171vsKda4rdQ0hgZTNpVbqoCzO+k2Y8yCYxSJAVZaawcdax8VzdCU1v3JITTq2ppDuQeZO3JS0bfIm+aOL5ql4Tg7nktfHEqVsGqkLFzJvEed05Sb9exIt8cHUyM6kvx9B8hYt4X/DH4OgJZXXEDnO/qCtSQvWMnCp2dUONZwL7/xZyS24cKxNxASGsK6j75n2WuzOHfEAHas2sSmeUmEnlKV7q8Mp26rhuRn5fD1nRPZt3UnAEN+eplqkdUJqVqFg/sO8Pn1zxTNkBq86CVmD3mePcneHTA6fMUTXt2fux547Bl+XbGKrKx9xETX5o5bBjGgb0+/x/Fih0e9vk9fHP/Ne59Dl/sHYA8XUFhoWfTSTDbOX1HhWKue5Cf/kieH0DDBWcdvRk4iY5WzjoO+Gs/03s46xraOp5erjpsWrOS/rjqG1Y7gsjfvpmZcDPtSd/Pl8FfJ27v/mPsNPaUqg+aOAyA/O5fvRr/LznVHp+he/dEYlr4xm83fezaOwhszLhomtiHhsRswoSGs/eh7lk6cxXn3DyBj9SZSXJ/3Xq8Mp17LhuRl5TD3ronsdX3eO93Vj5YDu1J4uJDvH5/O5oXO+K/+5J+ERTlncX7/5Adsc2Whe70ynLpnnYG1ln3bdzF/1LtlGpKeONlTX7yrziGhIaz56Ht+mTiL8111TnbVuXexOs8pVudz7+pHK1edFxSrc3n7BLjqw1FUj6mJMbBj7Va+G/0uhw7k0+PZW2na55yi6eCFBQW8f5nnn+URW98rp7/LN/YMSPBrn1PUzIV+q5u7TtigcWsnxnxrre1xrPXebtAEE283aIJNoBo0lYUvGjTB5GQbNH8FQTeF1Mv+5qc+wL8Nmswruvr10xb92feVrkFzwjE0xpj+x1tvrf30eI0ZEREREV9zZ5ZT3+Oss8CnXopFREREToZSYm7NcrrJH4GIiIiInCy3u3mNMTHGmFeNMUnGmOXGmAnGmJgTbykiIiLiW56MW5sB7AQGAFe6fv/IF0GJiIiI+2yhfx+VkSc3p4y21ha/XOI4Y8w/vB2QiIiIiKc8ydAsMMZcY4wJcT2uBub4KjARERFxky6s59a07WyO3sPpfuA916oQIAd4zGfRiYiIiLjBnVlOkf4IRERERE5OZR3X4k+ejKE5cpG9LjgzNj9aaz8/wSYiIiIiPud2g8YY8wbQBPjQtWi4Maa7tfZOn0QmIiIi7lGGxqMMTVeglXXd/MkYMxVYffxNRERERHzPkwbNeuB0YIvreQPAs9vPioiIiNdpDI17s5xm4xwzUwv4nzFmqev5ucBPvg1PRERE5MTcydC84PMoRERE5KQpQ+PetO3v3dmRMeZna+15FQ9JRERExDMeTds+gTAv7ktERETcpAyNZ7c+OBHrxX2JiIiIuM2bGRoREREJBGsCHUHAeTNDo7+miIiIBIQ3GzSDvLgvEREREbe5cx2aRdbaLsXuul20CrDW2po4f1njoxhFRETkODQo2L1p211cP3XXbREREamUPL3bdigQW3w7a+1WbwclIiIi7rOFGsbqyd227wYeAzI4el9PC7T2QVwiIiIibvMkQ3MP0Nxau9tXwYiIiIjnNIbGs1lO24C9vgpERERE5GS5M8vpftevKcBCY8wcIP/IemvtSz6KTURERNxgdWE9t7qcjsxu2up6VHM9RERERCoFd6ZtP178uTGmpnOxzfZZVCIiIuI2jaHxYAyNMaajMWY1sApYbYxZaYzp4LvQRERERNzjySynd4E7rLU/AhhjugBT0LRtERGRgNJ1aDyb5ZR9pDEDYK1dBKjbSURERALOkwzNUmPM28CHOC+oNxDnrKf2ANbaJB/EJyIiIidg7YnL/NV50qBp6/r5WKnl5+Ns4Fx8rA3vX/yQh2H9dQw8f3SgQwio/R0eDXQIATVi+ROBDiGgXm3/933/H0hfEOgQAur+uIsCHYL8zbjdoLHWJvoyEBERETk5GkPj+c0pLwVaAmFHlllr/95fQUVERCTgPLk55VtADSARmAxcCSz1UVwiIiLiJmVoPJvldL61djCwx3WxvfOABr4JS0RERMR9njRocl0/Dxhj4oBDQLz3QxIRERHxjCdjaL40xtQGngeScM5smuyTqERERMRtmrbtWYPmOWttPjDTGPMlzoHBeb4JS0RERMR9njRofgaOXEQvH8g3xiQdWSYiIiKBoUHBbjRojDEO4FSgujGmHXDkr1YT56wnERERkYByJ0PTE7gROA14qdjybODvfRlcERGRSsDaypWhMcb0AiYAocBka+0zpdYPB+4ECoAcYKi1dl1FXvOEDRpr7VRgqjFmgLV2ZkVeTERERP7ajDGhwOtAd2A78KsxZlapBssH1tq3XOX74UyY9KrI67rT5XR/eb8fYa19qfQyERER8R9bGOgISugEbLTWpgAYY2YAlwNFDRpr7b5i5cNxzpyuEHe6nCIr+iIiIiLyt3EqsK3Y8+3AuaULGWPuBO4HqnGcG1y7y50up8cr+iIiIiLiO4V+HkNjjBkKDC22aJK1dtKR1eVsUiYDY619HXjdGHMd8AgwpCIxeXIvp2bAm0CstbaVMaY10M9aO64iAYiIiEhwcTVeJh1j9XZK3hrpNCD1OLubgbN9USGe3PrgX8AonLc8wFq7CrimogGIiIhIxVhr/Po4gV+BpsaYeGNMNZxthVnFCxhjmhZ7eimwoaJ/A08urFfDWrvUmBIVOVzRAEREROSvw1p72BhzF/ANzmnb71pr1xpjngCWWWtnAXcZY7rhTJLsoYLdTeBZg2aXMaYxrn4wY8yVQFpFAxAREZGKqWxXCrbWzgXmllr2aLHf7/H2a3rSoLkTZ39ZC2PMn8Am4HpvByQiIiLiKY+uQ4OztbUA59ib/cAASl49WERERPxMd9v27Do0zYFzgC9wTskaBPzgo7hERERE3Ob2dWiMMd8C7a212a7nY4GPfRqdiIiIiBs8GUNzOnCw2PODQEOvRiMiIiIeq2yDggPBkwbNdGCpMeYznDOdrgCm+iQqEREREQ+43aCx1o43xnwFXOhadJO1doVvwhIRERF3+fvWB5WRJxkarLVJQJKPYhERERE5KR41aERERKTyceN2BH95ntzLSURERKRSUoZGREQkyOnCesrQiIiIyF+AMjQiIiJBTrOclKERERGRvwBlaERERIKcZjkFeYNm0dIVPPv6FAoKC+nf5xJuvfaKEutTM3by6POvk5m1j1o1I3h61D046sYAkJaxk8defJP0nbsxGN54ejSnOuoFohoVcsvjQ+mQ2IH83HxeGzGBlDXJJdZXCzuFB958CMcZ9SksLGTZd0uZ/ozzAs/9br2cbtf2oOBwAfsy9zFx5AR2/rkzENXwSLexg2ic2JZDufnMGTmJjDWby5SJbdWQS18cRtWwaiQv+I3vxk4HoHmfTnS5rz91msQxtd9jpK/eBECt0+pw6/znyExOAyB1xUa+GTPFb3XytkeeeokfFi8lOqo2n7/3VqDD8ZqGXVuTOHYQJjSENTMWsvSN2SXWh1arQu+Xh1Pv7Hjy9mTz5Z0T2bd9FwCd7uxLq4EJ2IJC/vvYNLb8sJrI+tH0enk44XVrYa1l1QcLWPHuN4GomsdefukJeve6mAO5udxyy32s+G1NmTLz532Mo34subl5APTucy07d+4uWt+//6X8Z8Ykzu3cm+VJq/wW+8nq99gQWiS25VDuQf4z8k3+XLu5TJlTW8Vz9QvDqRpWjd8X/Masx53nu/pnnUH/8bdQ9ZSqFB4u5LN/vsu2lc7zZaPOZ9Lv0cGEVKnCgT3ZvDXwCX9WS7wkaBs0BQUFjH91MpOeexRH3WiuueNhEs/rSOOGDYrKvPDWVPp2T+Dyngn8smI1Eya/z9Oj/g+A0c++xm3XDeD8jm04kJuLMcHX+9Y+sQNxDeO446JhNGvXnGHjb+ehy0eWKffFpM9Y8/NqqlStwuMfjqN9QgeSFi4nZW0KIy+9n4N5+fS8oTeDR9/Ei3c+F4CauK9RYhui4h283XUEce0a03PcjUz7x9gy5XqOv4mvR71DatJGrpr6AI0SWpOycBW7/tjOZ8Mm0Oupm8tsk7Ulgyl9xvihFr73jz7duW5AP0Y/+UKgQ/EaE2K4ZNwQPrn+GbLTMrl+9hNsnLeczA2pRWVaDUwgb+9+3r1oBM37duaiUdfw5Z0TiW4aR/O+nZna7SHCY6O46oOHebfrSAoLCvl+3AfsWLOZquFh3DDnSbb8uLrEPiuj3r0upmmTeFqc1YVzO7Xn9YlPc36XvuWWHTz4rnIbKxER4dx958388ktwXCu1RUJb6sQ7eC7hPk5v14Qrxt/CxH/8s0y5K8bdzMzRk9matIGb//0QzRPasH7hSi59+Dq+mzCT9QtX0iKhLX1GXcfb1zxJWM0aXPHkzbwz5BmyUncTHlMzALWrOM1yCuIxNKt/38jppzpoEBdL1apV6Z14AQt++rVEmZQt2zm3/dkAdGrbqmh98uZtFBQUcn7HNgDUqF6d6mGn+LcCXtCpR2cWzPwvAH+sWE94zXCi6kWVKHMwL581P68G4PChw6SsSSamvjNLtebn1RzMyy/a/sjyyqxp9w6smbkIgNQVyZxSM5zwerVLlAmvV5tTIqqTmrQRgDUzF9G0R0cAdm9MJTMlzb9BB0DHtmdTq2ZkoMPwKkfbxmRtzmDv1p0UHipg/ewlNOnRoUSZJj3as/aTHwH4Y+5STr+gpWt5B9bPXkLBwcPs27aTrM0ZONo2Zv+OLHa4MnyH9ueRuTGVSEe0X+t1Mvr27cn09z8B4JelSdSqXQuHhxnmx8c+yAsvvkleXp4vQvS6s3p0IOlT53u7dcVGqkfWILJuyc9+ZN3ahEVWZ2vSBgCSPv2Rlq7PvsUSFlEdgLCaNdiXsQeAdv0uYM3Xv5KV6sxc7d+9zy/1Ee9zu0FjjLnKnWX+smNXJo66dYqex9aNIWNXZokyzRo35LsflgAwf9Ev7D+QS9bebDZvTyMyvAb3PvYcVw0byYtvT6OgoMCv8XtDjCOG3Wm7ip7vTt9NtOPYjZIaNcPp2K0TqxavLLOu28DuJC1Y7pM4vSnSEUV26tGUeXZ6JpGxJRtxkbFRZKcfPRay0zKJdJQsU55aDepy09xxXPfRGE47p7n3ghaviHBEkZ1a8n2NKPXeFy9jCwrJzz5A9agIImLL2bbUMVHztDrUa3kGaStKdttWRqfGOdi+7WgW6c/taZwa5yi37OTJL7Hs128ZM/reomVt27akQYP6zJn7nc9j9ZZasdFFjQ6ArPRMapVqfNZyRLM37ej7nJW2m1qxzjKzH59Gn1HXM/qniVw6+nq+em4GAHUa1ad6rXCGzfgn/zd7PO37X0gwKrTGr4/KyJMMzSg3l/mFpWx+zZiSf+SRwwazbNVarho2kmUr11GvTjShoSEUFBSQtOZ3RgwbwodvPMv2tAy++GahnyL3LXuMvGNIaAgjXnuAOVNmk7E1o8S6rlck0Lh1Ez5/+1N/hFgxpuwHqUydyylzonxszo4s3jjvXqb0eYT5T75Pv1fvoJrr25xUDqU/3wBlTgPlHh8n3rZqjVPo9/Y9LHj8PQ7m5FYsUD8orz7lffYHDbmbdu27kZB4BV0u6MQNN1yJMYYXnx/LAw8G2TgRtz77ZTc7UqbzDd2Z/eR0njr/LmY/OZ2rnh0KOM+Np54dz7s3Pcfkwc/Q7e4rqBNffuNQKrcTjqExxvQG+gCnGmNeLbaqJnD4ONsNBYYCvP7Mo9x6/ZUVDLWk2DoxpO88mp3I2LmbejElv3HVqxPNK48/CMCB3Fzm/biEyIhwYuvG0KJJQxrExQJw8QWdWLnuD/pziVdj9IXeg/vQ/dqeAGxctYGY+kezVDGOGPZkZJa73R3P3EXq5lS+fGdWieWtu7Thyruu5pGrR3H44DHfzoBqP7gbba5JBCBtVQqRcUezUJGOaHJ2ZJUon52eWaLbILJ+NNkZJcuUVnDwMMmKqnkAACAASURBVAUHcwDIWLOZrC07iI53FA0alsDLTsskMq7k+5qzY0+JMjmuMjnpmZjQEE6JrEFeVo7zmCi9ravLIaRKKP3evof/ffYTG79e5p/KnITbhw/hlluuB2DZst84rUFc0bpTT6tPalpGmW1SU9MByMnZz4czPuecjm2ZNesbWrZswfx5zi4rh6Mun306hSv631TpBgafN6g75157MQDbVqZQu9hnv7Yjuqjb6Ii9aZnUqn/0fa5dP4Z9rmOkw4CLigYIr5qzhCufuc25TXomB/Zkcyg3n0O5+aQs/Z36Z57Brk3pPq2beJ87GZpUYBmQBywv9pgF9DzWRtba/2fvvuOjqtI/jn+eFHoChBZAkCqsIEWK6KKAAgouWNDFBtgWXXXXtaAiKlhQV3+2XWxYEUVR0VUUFESaDaQ3RXpNaCEkJBBSzu+PmYQEEpgJmZlM+L55zYuZe8+985yZO5Mzzznn3rHOuY7OuY4l3ZgBaN2yGZu2JbA1YQeZmZlMnfkj3c/pVKDM3n0p5OTkAPDmhM+57CLPB6N1i6akpKaRlLwPgHmLV9D01FNKPMZAmPreFO7ucyd397mTed/+Qo8Bnjqd1r4F6anp7D3iCx7gmnuvo1JMZd4e9UaB5Y1bNeHvT93Okzc9zr49+4ISf3Eseu873uk7gnf6jmDNtIW0HtAVgHrtm5KRmk7aEQ2atJ3JHEo7SL32TQFoPaAra6YfuzutYlwMFuH5eVe1QS2qN65D8uadAaiNFFfi0vVUaxxPbINaRERH0qJfF9ZNLzigdd30RbS6wtNlcFrfzmz+aVXe8hb9uhBZLorYBrWo1jiexCWerqXez97MnrXbWfjm1OBWyE+vvjaOjp1607FTb7788lsGeb9Xz+p8Jin7UkhMLHi8RkZGUsP7Iy8qKoqLL+7JypWrSUlJJb7eGTQ7rQvNTuvCvHmLSmVjBuDn8dN5se9wXuw7nJXTFuR1BzVs34wDqemk7jrix8yuZDL2H6Rh+2YAnHn5uaya5vnsp+zcS5MufwKg2Tmt2L3R02BZNW0BjTq1JCIygugK5WjYrhk7124LVhVLjHMW1FtpdNwMjXNuKbDUzCbgSei1xJOsXe2cOxTg+IoUFRnJg/+4mVvvf4LsnBwu63M+zRo1YMw7H9GqRVN6nNOJX5es5KW3PsAwOrQ5nRH/vBnwfNDvuWUwN9/7KA44vXkTrri4Z6iqUmwLv19Ahx4deXXuWM+07Xtfylv3/NSXuLvPndSIr8GV/xzI1jVbeG7KiwBMGfc13300jSEjbqBCpQoMe/UBAHZt38VTNz0Rkrr4at33S2jSoy23zHmOzAOHmHLv2Lx1N0wZnTdL6dsR73Dxc0OJqlCO9bOWsn6mZ9zQaRd2pOejg6kUF8OV79zLjlWb+HjwMzQ8qyVd7x6Ay8omJ8fx7YPvcHBfWkjqWBKGjXyaXxcvIzk5hQsuvY7bbhrEgH5F/v4ICy47h+8fHseA8fcRERnBiomz2fPHNs65ewA7lm9g3fRFLJ84mz4v3sqNc57jYPJ+vr5jDAB7/tjGH1/N4/oZ/yYnK4cZD72Ly3HU73QarQacy67fNjNo6mgAfnjmYzbMPHqcWWkyZeoMLrrofFb/9iPpBw5w8813561b8Os0OnbqTfny5Zjy9QSio6OIjIxkxoy5vPnWByGM+sT8PnMxLXu04/7ZL3LoQAafDHs9b92/pjzFi309IyA+f+jtw9O2Zy3h91lLAJj0wBv0HzmYiKhIsjIymTT8TQB2rtvOH7OXctc3/8blOOZPnMmOP7YGv4JywqyoMRdHFTTrC7wOrMPTsGkM3OKcO+7PmkNbl5+0E8oGnvNgqEMIqbOsaqhDCKl7FobZOIUS9p8zHwl1CCFzf+LMUIcQUnfXOy/UIYTcMxs/DFoqY169y4P6d/as7Z+VujSNP+eheR7o4ZxbC2BmTYGvgdKdpxUREZEyz58Gzc7cxozXekCDDERERELspO0GycefBs1KM5sCfIzntbsS+NXMLgdwzoXBnF8REREpi/xp0FQAdgDdvI93AXFAPzwNHDVoREREQqC0nuwumHxu0DjnbjjWejMb7px76sRDEhEREfFPSV7LKWSXQRARETmZ6Tw0JdugKZ01FBERkTLPnzE0x6NB1iIiIiGQE+oASgFlaERERCTslWSG5pMS3JeIiIj4yCmn4HuGxsyamNlkM9ttZjvN7Asza5K73jn3ZGBCFBERETk2f7qcJuA5qV48UA9PRubDQAQlIiIivstxwb2VRv40aMw5N945l+W9vY8GAouIiEgpcNwxNGYW570708yG48nKOGAgnotTioiIiISUL4OCF+JpwOSOOPqb93/zLn88AHGJiIiIj3I0KPj4DRrnXGMAM6sI3AZ0xdOQmQu8GtDoRERERHzgz7TtcUAK8B/v46uB94C/lnRQIiIi4jtN2/avQdPCOdc23+OZZra0pAMSERER8Zc/s5wWm1mX3AdmdhbwY8mHJCIiIv7ICfKtNPJlltNyPGNmooHBZrbZ+/hUYFVgwxMRERE5Pl+6nP4S8ChERESk2DSGxrdZTpuCEYiIiIhIcZXkxSlFREQkBErruJZg8mdQsIiIiEippAyNiIhImFOGRhkaERERKQOUoREREQlzmuWkDI2IiIiUAcrQiIiIhLkcJWiUoREREZHwpwaNiIiIhD11OYmIiIS5HA0KVoZGREREwp8yNCIiImHOhTqAUiAoDZr/nvPvYDxNqXS2VQ11CCEVeZJ/yv5z5iOhDiGk/rnosVCHEDL/BF7ocPK+/5E6da0EmTI0IiIBcDI3ZiT41H7UGBoREREpA5ShERERCXM5pllOytCIiIhI2FOGRkREJMyd5PMvAGVoREREpAxQhkZERCTMaZaTMjQiIiJSBihDIyIiEuZyNMlJGRoREREJf8rQiIiIhDldbVsZGhERESkD1KARERGRsKcuJxERkTCnE+spQyMiIiJlgDI0IiIiYU7TtpWhERERkTJAGRoREZEwp0sfKEMjIiIiZYAyNCIiImFOs5yUoREREZEyQBkaERGRMKdZTsrQiIiISBmgDI2IiEiY0ywnZWhERESkDFCGRkREJMwpQ6MMjYiIiJQBytCIiIiEOadZTsrQiIiISPhTg0ZERETCnrqcREREwpwGBStDIyIiImWAMjQiIiJhThkaZWhERESkDAiLDE2jbm3oMWoQFhnBio9mMf+VyQXWR5aLos8Lt1L7jMYc3JvKV7ePIWXrbgA6396P1gO747Jz+H7ke2yasxyAC5/9G00uaEf6nhTG9Rqet6+/vHwH1ZvUBaB8bCUyUtIZ32dEkGrqvwtGDaJJj3ZkHshg6r1j2bFi41Fl6rRuRN/nbiGqQjnWz1zCjFHjAWjRtzN/vutyajSrx/j+I0lcviHI0R9bj0cH0bhHO7IOZPDNPWPZWUjdap/RiIu8ddswcwkzR3rqVqFqZf7yyh3EnlKLlK27mHzbf8nYl37M/Z47fCBNzm8HwC//+R+rJ88DYOCnD1OucgUAKtWMJXHJOr7424sBrn3hSvqzEFM3joteuJXKtarinGPZhJksfvvbUFStRD305PPM+XE+cdWr8b/3Xwt1OCfkRD7jFapWpv/Ld1D1lFrs27qLL277Lxkp6ZSPrUSfZ4dS7dTaZGdkMnXYG+z+YysxdeO4OPd4yHEsnTCThe+E7ngI9vHe/vpetBvSm5zsbDZ8v4Q5T34U1PqeCBfqAEqBUp+hsQjjgieG8NmQZ3j3gvto0b8Lcc3rFSjTemB3Du5L4+3z7mHhm99w3vCrAIhrXo8W/bowruf9TBr8DD1HX49FeCbrr/hkDpMGP3vU8311+xjG9xnB+D4jWDP1V9Z882vgK1lMTXq0pXrjeN7odg/fDn+LXk9cX2i53qNv4Nvhb/FGt3uo3jiext3bALDrj63875aX2DJvdRCj9k3jHm2p3iiet8+7h+kPvEXP0dcXWq7n6BuY/sBbvH3ePVRvFE8jb906396PzT+u4u1u97L5x1V0vq3fMffb+Px21GndiPcuGsEH/UfR8ZaLKVelIgATr3g875jYvnANa75ZEPD6FyYQn4Wc7BxmPzGBdy+4nwmXjKLd4J5H7TMcXdq3F689/0SowzhhJ/oZP+u2fmz6cRVvdL+XTT+uoov3c3D2HZewc9Um3r3oQb6++zUuGDUIgJzsHGY+MYG3Lrif9y8dRfvBPakRouMh2Md7g7P/RNPeHXjvwuGM6/kAv74+Jeh1lhNT6hs08e2akrxxB/s27yInM5vVk3+hWe8OBco0630mKz+dC8AfU+bT8M+tvMs7sHryL2QfyiJlyy6SN+4gvl1TALbNX83B5P3HfO4WfzmL37/4OQC1KhnNenVg5aQfAEhYvI4KsZWpXLtagTKVa1ejXJWKbF+0FoCVk36gee+OACSt3U7S+oTgBu2jpr07sCpf3coXUbfyVSqS4K3bqkk/0OxCT92a9uqQd0ys/HQuzbx1Lmq/NZrXZ8svv+Oyc8g6kMGuVZvzGke5oitXoOGfW7H224WBq/gxBOKzkLYzOS9DlZl2kKS124mJjwtqvQKhY7szqBobE+owTtiJfsab9+rAikme42HFpLl5y2s0r8+mH1cCkLQugdhTalKpZixpO5PzMkCH0g6yZ+12qtQJzfEQ7OO97aCezH9lMtmHsgA4sCclSDUtGTkW3FtpVOobNFXiq5O6PSnvcWpCElXqVC+yjMvOISM1nYrVq1ClTiHbxhfctij1O7cgbfc+kjfuKIFaBEZMfHVStu/Je5yamETMEa9NTJ3qpCYWfA1ifHwNQqlKfHVSEwrW7cj3rkr8EXXLVyb3yxkgbWcylWrGHnO/u1ZtonGPtkRVKEfF6lVocM7pxNQt+EXe/KKObP5xJYf2HyjZyvoo0J+F2FNqUrvVqSQsXhfAWog/TvQzXtTnYOeqzZzWpxMA8W2bULV+zaMasrGn1KROq1NJWBKa4yHYx3v1xvGc0rkF13wxir9+PII6bZoEqmoSIMcdQ2Nm9znnnjGz/3J0N50DkoD3nXMBOerNCmkKHhlFIWWc83HbIrS85OxSnZ0Biqi3879MKWT4Endh7++x61bUfjfNXUF82yZc/flIDiSlkLBwDTnZBecNtOx/Nss/mnW80AMmkJ+F6Erl6f/6ncx89P2QNdikEAH6jM97dTIXjBzEkCmj2b16CztWbipwvEdXKs+lr93JjMdCdzwE+3iPiIqgfNXKTLhkFPFtm9DvlTt4s+vdJ1CD4Cpts5zM7CLgJSASeNM59/QR68sD7wEdgD3AQOfcxhN5Tl8GBf/m/b+ogQM1gM+AtvkXmtlQYCjAFdU706VK82IFmJqQREy9w78cYurGsX/n3gJl9nvL7E9MwiIjKB9TiYPJ+z2/Zo7cdkfBbQtjkRE0v6gT71/8cLFiDqT2g3vS5qoeACQuW09svRps866LiY9jv/fXWK7UxKQCv7w8r0HBMqVFu8E9OePqw3WLqVsjb11MfBxpR8S9/8i6xR+uW/ruFCrXrkbazmQq165G+m5P+jg1ManI/c4b8yXzxnwJQN//3EbyhsS8chWqVSG+XRO+GBqawcAQuM9CRFQk/V+/k98+/4m1IRofJIeV5Ge8qM/Bof0HmDpsbN42t/zwAvu27AI8x8Olr93Jqv/9FLLxYhD84z01YS9rpnoeJy5dj3OOinExHEhKDWQ1yyQziwReBnoBW4FfzexL59yqfMVuAvY655qZ2VXAv4GBJ/K8x+1ycs5N9v4/rojb88ArhWw31jnX0TnXsbiNGfAcWNUaxxPboBYR0ZG06NeFddMXFSizbvoiWl1xLgCn9e3M5p9W5S1v0a8LkeWiiG1Qi2qN40n0IX16atfWJK3bzv58adzSYvF73zGu7wjG9R3BmmkLaTWgKwB12zclIzU9L72cK21nMofSDlK3vWfsUKsBXVk7PTRjQI5nyXvf5Q2+XfvtQk73s26nD+jKummeuuU/JlpdcS7rph9eXth+LcKoUK0KADVbNqDWnxqw0TsjDuC0v3Rm/YwlZGdkBvAVOLZAfRZ6P3sze9ZuZ+GbU4NbISlUSX7G1363iNYDPMdD6wHnssa7vHxsJSKiIwFoc1V3tsz/PS9TcdEznuNhQYiPh2Af72unLaDhOacDnu6nyOiosGrM5AT5dhydgbXOufXOuUPAR8AlR5S5BBjnvf8pcIEVmlrznR0vNWlmLzrn/mVmkym6y+l159wvRe3juYbXnVAfR+Mebek+8joiIiNYMXE288Z8yTl3D2DH8g2sm76IyPLR9HnxVmq3asTB5P18fccY9m32/No4647+tB7YjZysHGY+Op6Ns5YBcPF/b+eUs/9ExepVSN+dwk/PT2LFxNkAXPjcUBIWr2XZ+9+fSNgAZAd48FTPx4fQuFsbsg4cYuq9Y/OmXg+ZMppxfT3TzePPaEyf54Z6pjbPWsp3j7wHQPMLO9Lz0cFUjIshIyWdnas28cngZ0o0vsgTeOcveHwIjbq3IfPAIb69dyw7lnnqNmjq6Lyp9HXaNOai3LrNXMr33rpVqFaFv7z6D2Lr1SBl+x6+uvU/HNyXVuR+I8tHM2iKZ1ZMRuoBvnvwbXat2pwXy18njmD+K5PZOHtZ8StUAkr6s1C/02lcNekRdv22GZfjebN+eOZjNsxcWiLx/nPRYyWyH38NG/k0vy5eRnJyCjXiqnHbTYMY0O/CoMbwQodHSmQ/J/IZr1CtCpe8cvhz8MXfPZ+Demc24+LnbyUnO4c9a7cxddgbZKSkU7/jaVw76RF25jse5j77MeuLcTycyGc/VzCP94joSC58dii1WzUk+1A2s0dPYMtPq44V3nHds/n9oA2fPdG/s/66d8sHt+DthfEa65wbC2BmVwAXOedu9j4eBJzlnLsjt7CZrfCW2ep9vM5bZndxY/KlQdPBObfQzLoVUaQm8Lhz7vSi9hHsF7o0CXSDprQriS81CV+hatCUBiXVoAlX+uwHt0Hzf8Fu0ByjbmZ2JXDhEQ2azs65f+Qrs9JbJn+DprNzbk9h+/TFccfQOOcWev+ffYzgDxU3ABERESlTtgIN8j0+BdheRJmtZhYFVMXT41NsvsxyWs4x5gY559rkjrMRERGR4Ctl54b5FWhuZo2BbcBVwDVHlPkSGAL8DFwBfO9OcAquL7Oc/nIiTyAiIiInD+dclpndAXyLZ9r22865lWb2GLDAOfcl8BYw3szW4snMXHWiz+tLl9MmX3ZkZj87584+0YBEREQkvDnnpgBTjlj2SL77B4ErS/I5S/LilBVKcF8iIiLio9J2Yr1QKMlLH2hMu4iIiIRESWZoREREJASUUSjZDE3pGmMtIiIiJ42SzNAMKsF9iYiIiI9ylKPx6Tw0PzjnuppZKgWzWgY451wsnjsrAhSjiIiIyDH5Mm27q/f/mMCHIyIiIv7SLCc/u5y8lwSvk38759zmorcQERERCTyfGzRm9g9gJLCDw41BB7QJQFwiIiLiI42g8S9DcyfQ4kSuhCkiIiISCP40aLYA+wIViIiIiBSPxtD4Nsvpbu/d9cAsM/sayMhd75x7PkCxiYiIiPjElwxN7uymzd5bOe9NRERESoEcndrWp2nbj+Z/bGaxnsUuNWBRiYiIiPjBn1lOHYF38GZszGwfcKNzbmGAYhMREREf6EzB/g0Kfhu4zTk3F8DMuuJp4GjatoiIiISUPxenTM1tzAA4534A1O0kIiIiIedPhma+mb0OfIjnHD4D8cx6OhPAObcoAPGJiIjIcajDyb8GTTvv/yOPWH4Ontfy/BKJSERERMRPPjdonHM9AhmIiIiIFI9OrOf/xSkvBloBFXKXOeceK+mgRERERPzhz7Tt14BKQA/gTeAKYH6A4hIREREfadq2f7OcznHODQb2ek+2dzbQIDBhiYiIiPjOny6nA97/082sHrAHaFzyIYmIiIg/lJ/xr0HzlZlVA54FFuF5/d4MSFQiIiIifvCnQfOMcy4DmGRmX+EZGHwwMGGJiIiIrzTLyb8xND/n3nHOZTjn9uVfJiIiIhIqx83QmFk8UB+oaGbtgdyLlMfimfUkIiIiIaRZTr51OV0IXA+cAjyfb3kq8GAAYhIRERHxy3EbNM65ccA4MxvgnJsUhJhERETED8rP+NbldHdh93M5554/ctmR7k+c6X9kZcTvzVqHOoSQmry/VqhDCKlhJ/GxD5Dd4ZFQhxAydy08uU+ivqXHraEOQU4yvnQ5xQQ8ChERESk2zXLyrcvp0WAEIiIiIlJcPk/bNrPTzGyGma3wPm5jZg8FLjQRERER3/hzHpo3gOFAJoBzbhlwVSCCEhEREd+5IP8rjfxp0FRyzh15de2skgxGREREpDj8ufTBbjNrind2mJldASQEJCoRERHxmQYF+9eguR0YC7Q0s23ABuDagEQlIiIi4ge/zkMDTAFm4umqSgMGUPDswSIiIhJkuvSBf+ehaQF0Ar7Acz2nQcCcAMUlIiIi4jOfz0NjZtOAM51zqd7Ho4BPAhqdiIiIHJfyM/7NcmoIHMr3+BDQqESjERERESkGfwYFjwfmm9nneBqDlwHjAhKViIiI+ExjaPxo0DjnRpvZVOBc76IbnHOLAxOWiIiIiO/8ydDgnFsELApQLCIiIlIMOg+Nf2NoREREREolvzI0IiIiUvqU1usrBZMyNCIiIhL2lKEREREJcxpDowyNiIiIlAHK0IiIiIQ5jaFRhkZERETKADVoREREJOypy0lERCTMaVCwMjQiIiJSBihDIyIiEuZynAYFK0MjIiIiYU8ZGhERkTCn/IwyNCIiIlIGKEMjIiIS5nKUo1GGRkRERMKfMjQiIiJhTpc+UIZGREREygBlaERERMKczhSsDI2IiIiUAWUiQ/PC84/R56LzST9wgJtuuovFS1YcVWbG9E+Ir1uHAwcOAtCn79Xs2rUnb/3ll1/Mxx+N5awufVi4aFnQYj8Rlbp2pObwWyEykpRPp5L85scF1scOvJiqV/eDnBxy0g6wc9RLZK7bTETVGOJffJgKZ5xGyufT2T365RDVwDendmtD91GDiIiMYMVHs/j1lckF1keWi+LCF26lzhmNObA3lSm3jyFl624AOt3ej9YDu5OTncOske+xac5yANrfeCGtr+6OmbH8w5ksfutbALrcdTlnXN2d9D2pAPz4zMdsnLk0iLX1z8lw7F8wahBNerQj80AGU+8dy44VG48qU6d1I/o+dwtRFcqxfuYSZowaD0CFqpXp//IdVD2lFvu27uKL2/5LRko65WMr0efZoVQ7tTbZGZlMHfYGu//YSkzdOC5+4VYq16qKy3EsnTCThe98G+Qan7iHnnyeOT/OJ656Nf73/muhDqfEVfxzR2rc/3csMoKUz75h31sTC6yPufJiql7dH5edg0s/wK5HXyRz/WYqnn0mcf+6CYuOwmVmsee5Nzg4f0mIalGyNMupDDRo+lx0Ps2bNabl6V05q/OZvDzmKc7p2q/QsoMH31HoF3aVKpX5x+03Mm/eokCHW3IiIqj10O1su3k4WTt202Dif0mb+QuZ6zbnFUn9aiYpE78GoFKPLtS87xYSbhmBO3SIpP+Oo1zzRpRr1ihEFfCNRRjnPzGEz659mtSEJK6Z/Bjrpi8kac32vDKtBnYnY18a75x3D6f160LX4Vcx5fYxxDWvR4t+XXiv5/1UrlOdARMe4N1u9xLXrD6tr+7Oh/1Gkp2ZxeXj72PDjCUkb9wBwKI3v2Hh2CmhqrLPToZjv0mPtlRvHM8b3e6hbvum9Hriet6/dNRR5XqPvoFvh7/F9kVruWLcMBp3b8OGWcs467Z+bPpxFfNencxZf+9Hl9v6MfvpiZx9xyXsXLWJ/93yInFN69Lr8euZeM1T5GTnMPOJCexYsZFylSsw+KvH2fjDcvbkO97CwaV9e3HNgP48+Pj/hTqUkhcRQc0Rd5Aw9AGyEndT/6P/kj7zZzLXH/7u2z9lJqmfeL/7unehxrBbSPz7CLL37iPxjofJ3pVEdLNG1H3tSTb3vCZUNZESFvZdTv36Xcj4Dz4FYN78RVStVpX4+Np+7ePRUffxf8+9ysGDBwMRYkBUOKMFmZu3k7U1ETKz2D91FlXOP7tAGZeWnnc/omIFcs8l6Q5kcHDRSlzGoWCGXCzx7ZqSvHEH+zbvIiczm9WTf6Fp7w4FyjTtfSarPp0LwJop82n451be5R1YPfkXsg9lkbJlF8kbdxDfrilxzeuRsGgdWQcP4bJz2PrL7zS7qGPQ63aiToZjv1mvDqyc9AMACYvXUSG2MpVrVytQpnLtapSrUpHti9YCsHLSDzTv7Xk/m/fqwIpJnmNjxaS5ectrNK/Pph9XApC0LoHYU2pSqWYsaTuT8zJAh9IOsmftdqrUiQt4PUtax3ZnUDU2JtRhBET5/N99WVmkTZ1N5R7nFCiT/7vPKlbIu3/o93Vk70oCIHPtRqx8OYiODk7gAeaC/K80Om6Dxsxaev8/s5BbezM7NfBhFq1+vXi2bjn862nb1gTq14svtOybbz7Pgl+nMeLBf+Uta9euFQ0a1OXrKd8FPNaSFFmnBpmJu/IeZyXuJrJ2zaPKVb26H6d+8w417rmZ3U++EswQS0SV+Oqkbk/Ke7w/IYkqdaoXWcZl55CRmk6F6lWoUqeQbeOrs2f1Vk45qwUVqlUhqkI5GvVoS5W6NfLKtR3Si+u+fZJez/6N8lUrBbiGxXcyHPsx8dVJ2X64eyw1MYmYI97/mDrVSU08/D6nJiQRE+8pk9tIAUjbmUylmrEA7Fy1mdP6dAIgvm0TqtavSUx8wYZL7Ck1qdPqVBKWrCv5ikmxRdWuSVb+774du4isU+OocrFX9aPBlHepcfff2P3U0d3qlXudS8bvayEzM6DxSvD40uV0NzAUeK6I9TXMbKlzblD+hWY21Lsd1j9LkwAAIABJREFUFlmViIjKJxRoUczsqGWukKuODhryD7ZvT6RKlcp8MvENrrvuCj74YBLPPTuKG2++KyCxBVQh9S7sah77PpzMvg8nU+XiHlS/5Rp2PhhmKehC398jixTyWriit01au51fX/2Kyz94gMz0g+z+bTMuOxuAZeO/Y95Ln+McnHPvFZz30LVMH/ZGSdSkxJ0Ux74vdfTxdchv3quTuWDkIIZMGc3u1VvYsXITOdmH54lEVyrPpa/dyYzH3ufQ/gPFi10Co9CvvqPf75SPJpPy0WQq9+1B9aHXsuuhZ/PWRTc9lbi7biJh6PAABirBdtwGjXNuqPf/HkWVMbNphWw3FhgLEFWufonmp/5+6xBuuulaABYsWMIpDerlrat/Sl22J+w4apvt2xMB2L8/jQ8/+h+dOrbjyy+/pVWrlsyY7knbx8fX4vPP3uGyy28olYMj88tO3E10fK28x1HxNcneuafI8vunzKLWI/8IRmglan9CEjH1Dv9yrlI3jrSdewuUSfWW2Z+YhEVGUD6mEgeT97M/sZBtd3i2XTlxNisnzgbgz/f9ldQEzy/89N0peeVXfDiTS965J2B1K46T4dhvP7gnba7yfN0kLltPbL0abPOui4mPY78345IrNTGpQHYlpm4c+3d4yqTvTqFy7Wqk7Uymcu1qee/vof0HmDpsbN42t/zwAvu2eH71R0RFculrd7Lqfz+x5psFgaqmFFPWjt1E5f/uq1OL7J1JRZZPmzqLWg/9k9ycTmSdmtR5cSQ7H3yGrK0JAY42eDRt27cup/O9/19eyO0yM+sG9Al4pPm8+to4OnbqTcdOvfnyy28ZdO0VAJzV+UxS9qWQmLizQPnIyEhq1PCkoKOiorj44p6sXLmalJRU4uudQbPTutDstC7Mm7eoVHyh++LgitVEn1qfqPp1IDqKKn26kzbzlwJlok89/MeuUrfOZG7aduRuSr3Epeup3jie2Aa1iIiOpEW/LqyfXnAA6/rpizj9inMBaN63M1t+WpW3vEW/LkSWiyK2QS2qN44n0dt9ULGGp+shpl4Nml3UkdVf/gRQYHxG0ws7smf11oDX0R8nw7G/+L3vGNd3BOP6jmDNtIW0GtAVgLrtm5KRmp7XhZQrbWcyh9IOUrd9UwBaDejK2ukLAVj73SJaD/AcG60HnMsa7/LysZWIiI4EoM1V3dky//e8TMxFz9zMnrXbWfDm1MBXVvyWkffdFw9RUVTu0420WT8XKBPVMN9333lnkbnZ890XEVOZ+JcfZ+9Lb5OxZFVQ45bA86XLqRvwPVD49AmoAYwAepdUUP6YMnUGF110Pqt/+5H0Awe4+ea789Yt+HUaHTv1pnz5ckz5egLR0VFERkYyY8Zc3nzrg1CEW3Kyc9g1+mXqvfEkFhFByufTOLR2E3F3DObgyj9In/kLVa/pT8Wzz4SsLLL37S/Q3XTq9HFEVKmMRUdR5YKz2fa3BwvMkCotXHYO3z88jsvH34dFRrBy4mz2/LGNs+8ewI7lG1g/fRErJs7mohdv5YY5z3EweT9T7hgDwJ4/tvHHV/MYPOPf5GTl8P1D7+JyPMnCfq/fSYXqVcjJzOL7h8eRsc8ziPDcB6+i1umn4pwjZetuZgx/O2R1P56T4dhf//0SmvRoy9/mPEfWgUNMvfdwVmXIlNGM6zsCgOkj3qHPc0OJqlCODbOWst471f6XVyZzySv/oM3AbqRs38MXf/8PADWa1ePi528lJzuHPWu3MdXbrVi/42m0HnAuO3/bzJApowGY++zHefsLF8NGPs2vi5eRnJzCBZdex203DWJAvwtDHVbJyM5h95NjiH/tSSwygtTPvyVz3Saq3z6YjJV/kD7rF6pefQkVu7THZWWTk5LKzhGe7qbYqy8hukF9qt1yLdVu8WQ6E24ZTk5S8rGeMSwcr5v1ZGAl8SKY2VvOuZuKWl/SXU7h5PdmrUMdQkhN3l/r+IXKsGGJM0MdQkg9WbfInuoy766Fj4U6hJDa0uPWUIcQck2WTytsxE9AXNawX1D/zn6+eXLQ6uar42ZozOzuY613zj1/rMaMiIiIBJZOrOdbl1PZPJmBiIiIlBm+zHJ61Jcdmdlw59xTJx6SiIiI+EOznEr2TMFXluC+RERERHxWktdyKnUDhERERE4GpfVyBMFUkhkavZoiIiISEsrQiIiIhDnNcvIxQ2NmkWZ2vIu+fFIC8YiIiIj4zacGjXMuG7jkOGWeLJGIRERExC/OuaDeSiN/upx+NLMxwEQgLXehc25R0ZuIiIiIBJ4/DZpzvP/nP5+3A84vuXBERETEXzoPjR8NGufcyXtRFhERESnV/JrlZGYXA62ACrnLnHMn9xXYREREJOR8btCY2WtAJaAH8CZwBTA/QHGJiIiIj3RiPf9OrHeOc24wsNd7faezgQaBCUtERETEd/50OR3w/p9uZvWAPUDjkg9JRERE/KET6/nXoPnKzKoBzwKL8MxwejMgUYmIiIj4wZ8GzTPOuQxgkpl9hWdg8MHAhCUiIiK+Kq0nuwsmf8bQ/Jx7xzmX4Zzbl3+ZiIiISKgcN0NjZvFAfaCimbXn8EUoY/HMehIREZEQ0hga37qcLgSuB04Bns+3PBV4MAAxiYiIiPjluA0a59w4YJyZDXDOTQpCTCIiIuIHnYfGty6nuwu7n8s59/yRy0REREQKY2ZxeC503QjYCPzVObf3iDKnAp8BkUA08F/n3GvH2q8vXU4xxYhXREREgiQnvGY5PQDMcM49bWYPeB/ff0SZBDwn9M0wsyrACjP70jm3vaid+tLl9OiJRC0iIiKSzyVAd+/9ccAsjmjQOOcO5XtYHh9mZfs8bdvMTjOzGWa2wvu4jZk95Ov2IiIiEhguyLcTVMc5lwDg/b92YYXMrIGZLQO2AP8+VnYG/DsPzRvAcCDTG8Qy4Co/thcREZEywMyGmtmCfLehR6z/zsxWFHK7xNfncM5tcc61AZoBQ8yszrHK+3Om4ErOuflmln9Zlh/bi4iISAAE+zw0zrmxwNhjrO9Z1Doz22FmdZ1zCWZWF9h5nOfabmYrgXOBT4sq50+GZreZNcWbbTKzK/AM2hERERHx1ZfAEO/9IcAXRxYws1PMrKL3fnXgz8DqY+3UnwzN7XhaYy3NbBuwAbjWj+1FREREngY+NrObgM3AlQBm1hG41Tl3M/An4Dkzc3iuUPB/zrnlx9qpX+ehAaYAM/FkdtKAARQ8e7CIiIgEWThd+sA5twe4oJDlC4CbvfenA2382a8/56FpAXTCkxoyYBAwx58nExEREQkEn89DY2bTgDOdc6nex6OATwIanYiIiByXC68T6wWEP4OCGwL5T3RzCM9pi0VERERCyp9BweOB+Wb2OZ6ZTpfhOcPfcT1Zt0cxQisbluw9uVvNOdGhjiC07q53XqhDCKnInFBHEDpbetwa6hBCqsHMY152R0pYOI2hCRSfGzTOudFmNhXPPHCAG5xziwMTloiIiIjv/MnQ4JxbBCwKUCwiIiJSDE4ZGr/G0IiIiIiUSn5laERERKT00SwnZWhERESkDFCGRkREJMxplpMyNCIiIlIGKEMjIiIS5jSGRhkaERERKQOUoREREQlzGkOjDI2IiIiUAWrQiIiISNhTl5OIiEiY06UPlKERERGRMkAZGhERkTCXo2nbytCIiIhI+FOGRkREJMxpDI0yNCIiIlIGKEMjIiIS5jSGRhkaERERKQOUoREREQlzGkOjDI2IiIiUAcrQiIiIhDmNoVGGRkRERMoAZWhERETCnMbQKEMjIiIiZYAyNCIiImFOY2iUoREREZEyQA0aERERCXvqchIREQlzGhSsDI2IiIiUAcrQiIiIhDnnckIdQsgpQyMiIiJhr0xkaC4YNYgmPdqReSCDqfeOZceKjUeVqdO6EX2fu4WoCuVYP3MJM0aNB6BF3878+a7LqdGsHuP7jyRx+YYgR198dXq0od1jg7DICDZMmMXqMZMLrK/ZpSVtH7uOqn9qyLxbx7Dt6/l567pOuI+4M5uxZ/4f/Dj4/4Ic+fE16taGHqM8dVvx0Szmv1KwbpHloujzwq3UPqMxB/em8tXtY0jZuhuAzrf3o/XA7rjsHL4f+R6b5iw/5j4vfG4oDc5qSUbqAQC+ued1dq3aTMtLz6Hz3/8CQGbaQb4b8S67ftscrJegSP1HDqFlj3ZkHjjEx/e+yraVG48qU791Y/76f7cSXaEcv89cwpePjgOg7umncvnom4guH01OVg6fP/w2W5auA6BJlz/R/5HBRERFkb43ldcGPhbMahWqpI+DmLpxXPTCrVSuVRXnHMsmzGTx29/m7a/99b1oN6Q3OdnZbPh+CXOe/Cio9fVVxT93pMb9f8ciI0j57Bv2vTWxwPqYKy+m6tX9cdk5uPQD7Hr0RTLXb6bi2WcS96+bsOgoXGYWe557g4Pzl4SoFoHz0JPPM+fH+cRVr8b/3n8t1OEERY7G0IR/g6ZJj7ZUbxzPG93uoW77pvR64nrev3TUUeV6j76Bb4e/xfZFa7li3DAad2/DhlnL2PXHVv53y0v0fvLG4Ad/IiKM9k9ez9yBT5GekMQFUx9n+7RFpP6xLa9I+tbdLLjzdU77+8VHbf7HK18TWbEcTQZdEMyofWIRxgVPDOHTa58mNSGJayc/xtrpC0lasz2vTOuB3Tm4L423z7uHFv26cN7wq/jq9jHENa9Hi35dGNfzfirXqc6VEx7g7W73Ahxzn7Of/JA1U34tEEfKll1M/OsTZOxLp1H3NvR6+kYmXDIqaK9DYVp2b0fNxvE80/0uGrZvxmWjb2LMpQ8fVe6yJ25k0oNvsnnRGm58935adG/L6llLufiBa/jupUmsnrWUlt3b0Xf4Nbx+1eNUiK3EZY/fyFtDniZ5+x4q14gNQe0KCsRxkJOdw+wnJrBzxUaiK1fguq8fZ9Pc5SSt2U6Ds/9E094deO/C4WQfyqJiKXgNChURQc0Rd5Aw9AGyEndT/6P/kj7zZzLXH25s758yk9RPvgagUvcu1Bh2C4l/H0H23n0k3vEw2buSiG7WiLqvPcnmnteEqiYBc2nfXlwzoD8PPl76fqxJ4IR9l1OzXh1YOekHABIWr6NCbGUq165WoEzl2tUoV6Ui2xetBWDlpB9o3rsjAElrt5O0PiG4QZeAuPZN2b9xB2mbd+Eys9nyxS/Uu7BDgTLpW3ez77ctuJyjW+47f1hJ1v6DwQrXL/HtmpK8cQf7Nu8iJzOb1ZN/oVnvgnVr1vtMVn46F4A/psyn4Z9beZd3YPXkX8g+lEXKll0kb9xBfLumPu3zSNsXriFjXzoACYvXUqVuXABq65/Te3dg0Weeem9evJaKMZWIqVXweI+pVY0KMRXZvGgNAIs+m0sr7/HucFSoUhGACrGVSNmxF4D2/f/Mim9+JXn7HgDS9qQEpT7HEojjIG1nMju9GdzMtIMkrd1OTLznfW07qCfzX5lM9qEsAA6UgtegMOXPaEHm5u1kbU2ErCzSps6mco9zCpRxael5961ihbz7h35fR/auJAAy127EypeD6OjgBB5EHdudQdXYmFCHEVTOuaDeSiOfMzRmdiMw1zm3JoDx+C0mvjop3i9hgNTEJGLqVCdtZ/LhMnWqk5qYdLhMQhIx8dWDGmdJqxgfx4Fth+t9ICGJuPZNQxhRyakSX53U7QXfr7rtmhZZxmXnkJGaTsXqVahSpzoJi9cV2LaK970+1j67DvsrZ995GZt/XMncpyfm/VHLdcbA7mycuazkKllMVevE5TU6AJITk6gaH0fqrsPHe9X4OPYlHK5rcsIeqtbx/NGe/Oh73PTecC5+8Doswnh5wEgAajapS2RUJLd89DDlK1fgh3e+yWs4hUqgjoNcsafUpHarU/PKVW8czymdW9B12JVkZWQy+4kP2bFsfaCqV2xRtWuSlbgr73HWjl2Ub9PyqHKxV/Wj6uABWHQ0228adtT6yr3OJeP3tZCZGdB4RYLFnwxNI+B1M1tnZh+b2T/MrF2A4vKd2VGLjmo9+lIm3BxdJQj3OnlZIe/XUd3Dhb6nRW97rH3+8O+PeafHMD7o9wgVqlWhk3fcTK4GZ/+J1gO7MeepUjCewqfj/ejNcst0ua4Xkx8fz5Pn3MHkx8dz5b+HAhARGUH9Mxrz9g3P8Obgp+n5j8uo2Ti+xMP3RyCOg1zRlcrT//U7mfno+xza7xk7FREVQfmqlZlwySjmjP6Qfq/ccQLRB5CPn/2Ujyazpe/17HnhTaoPvbbAuuimpxJ3103sfvSlAAUpwZaDC+qtNPK5QeOce8Q5dz7QGvgBGAYsLKq8mQ01swVmtmDe/pJN6rQf3JMhU0YzZMpo9u/YS2y9GnnrYuLj2J8vOwPerE384e6CmLpx7N9RsEy4OZCQRMX6h+tdsW4cB8K8TrlSE5KIqXfE+7Vzb4Ey+/OVscgIysdU4mDyfs97feS2O/Yec5+52bzsQ1ms+HgO8fmyADVbNqD3Mzfzxc0vcDB5f8lX1gdnD+rFv6Y8xb+mPEXKjr1Uy3e8V4uPy+s2yrUvIYmq+brHqtWtQYq3rh0GnMeKbzyDw5d9/QsN2nrqui8xiT9mLyXzQAbpe1NZP/936v7p1EBX7ZgCcRwARERF0v/1O/nt859Y+82CfM+3lzVTPY8Tl67HOUfFuNLXbZG1YzdR8bXyHkfVqUX2zqQiy6dNnUXl8w93SUXWqUmdF0ey88FnyNoaft3tIkXxuUFjZg+Z2VRgGtAMuBc4pajyzrmxzrmOzrmOZ1VpfuKR5rP4ve8Y13cE4/qOYM20hbQa0BWAuu2bkpGaXqC7CTx/sA6lHaSut0um1YCurJ1eZFssLOxdsp4qjeOp1KAWFh1Jg0u6kPBteNcpV+LS9VRrHE9sg1pEREfSol8X1k1fVKDMuumLaHXFuQCc1rczm39albe8Rb8uRJaLIrZBLao1jidxybpj7jP/mKtmF3Zgz+qtAMTUq0H/sf9i6r9eY++GxGBUvVA/j5/Oi32H82Lf4ayctoAzL/fUu2H7ZhxITS/Q3QSQuiuZjP0Hadi+GQBnXn4uq6Z5jo2UnXtp0uVPADQ7pxW7N3rqtWraAhp1aklEZATRFcrRsF0zdq7dRigF4jgA6P3szexZu52Fb04tsK+10xbQ8JzTAU/3U2R0FAeSUgNdTb9lrFhN9Kn1iaofD1FRVO7TjbRZPxcoE9WwXt79SuedReZmz3sZEVOZ+JcfZ+9Lb5OxZFVQ45bA0hgaMF8DM7NFQBbwNTAb+MU559Oo0mdOvS6gte/5+BAad2tD1oFDTL13bN7U6yFTRjOu7wgA4s9oTJ/nhhJVoRwbZi3lu0feA6D5hR3p+ehgKsbFkJGSzs5Vm/hk8DMlFluTQ4Grevz5bWnrnba98aPZ/P7SF5w+bAB7l24gYdoiqrdtwtlv30W5apXIPpjJwV37mN79fgC6/+9hYprVI6pSBTL27mfhPWPZMWt5ice4Kbqw/PjxNe7Rlu4jryMiMoIVE2czb8yXnHP3AHYs38C66YuILB9NnxdvpXarRhxM3s/Xd4xh32bPuIKz7uhP64HdyMnKYeaj49k4a1mR+wS48sPhVKwRixnsXLmZ7x58m8z0DHr/+2aa9+2UNw04JzubD/7yiF/12BGRXaz6H8ulj91Ai25tOXQgg0+Gvc7W5Z5xHv+a8hQv9h0OwClnNDk8bXvWEr4Y+S4AjTq2oP/IwURERZKVkcnnD73NthWez0u3oX+h45XdcDmO+RNn8sPbUwt9fn/UyYk8oe1L+jio3+k0rpr0CLt+25w3WP6HZz5mw8ylRERHcuGzQ6ndqiHZh7KZPXoCW34q/h/9y6ruPKG6H0vFcztR4z7PtO3Uz78l+Y0PqX77YDJW/kH6rF+ocf/fqdilPS4rm5yUVHY/+TKZ6zZRbeg1VLvpqrwGDkDCLcPJSSr57G6DmaGbLj1s5NP8ungZyckp1Iirxm03DWJAvwuDHkd0zSbF+wIshvrVWwW1lbFt78qg1c1XPjdoAMwsBujqvf0V2OGc63q87QLdoCnNAtmgCQfFbdCUFYFo0ISTE23QhLNANmjCQSgbNKVFMBs0daudHtQ/NgnJq0rdl7s/s5xaA+cC3YCOwBYgtNMgRERERPDvxHr/BuYA/wF+dc5prp+IiEgpoKtt+9egeR742TmXftySIiIiIkHkz3lohgBLzOxnM3vGzPqZWXifnU5ERETKBJ8zNM65wQBmVg+4AngZqOfPPkRERKTkldap1MHkz6Dg6/AMCj4D2A2MQYOCRUREpBTwJ7vyIrAOeA2Y6ZzbGJCIRERExC+l9XIEweTPpQ9qAjcCFYDRZjbfzMYHLDIRERERH/nT5RQLNAROxXOhyqocfak4ERERCTKNofGvy+kH720u8F/nXGgv9CIiIiLi5U+D5ibgQeA+YLiZ56zHzrk2AYhLREREfJSjDI1fDZr38VxhewWQE5hwRERERPznT4Nml3NucsAiERERkWLRGBr/GjQjzexNYAaQkbvQOfdZiUclIiIi4gd/GjQ3AC2BaA53OTlADRoREZEQ0nlo/GvQtHXOnRGwSERERESKyZ8GzS9mdrpzblXAohERERG/aQyNfw2arsAQM9uAZwyNAU7TtkVERCTU/GnQXBSwKERERKTYdB4aPxo0zrlNgQxEREREpLh8vjiliIiISGnlT5eTiIiIlEJO07aVoREREZHwpwyNiIhImNOgYGVoREREpAxQhkZERCTM6cR6ytCIiIhIGaAMjYiISJjTLCdlaERERKQMUIZGREQkzGkMjTI0IiIiUgYoQyMiIhLmlKFRhkZERETKAGVoREREwpzyM8rQiIiISBlgJ0O/m5kNdc6NDXUcoaL6n7z1P5nrDqq/6n9y1/9kc7JkaIaGOoAQU/1PXidz3UH1V/3lpHGyNGhERESkDFODRkRERMLeydKgOdn7UFX/k9fJXHdQ/VV/OWmcFIOCRUREpGw7WTI0IiIiUoapQVMIM7vUzE4PdRwiIiLiGzVoCncpELQGjZmNMrN7fVlvZtebWb0Set53zeyKQpZfb2Zjithmv/f/emb2qfd+RzP7j4/PGbS6Huu5zOynY2zX3cy+KmLd/iKW572WZvZmboPYzKaYWTX/oy/0ORqZ2YpClm80s5onuO92Ztb3RPZxAs8dDsdE3muf/3g3s/5m9kBx4ylurEeuL+Hvhfz7fczMenrv5x3XIqVR2DRozOw+M/un9/4LZva99/4FZpZuZs97H99pZuu995ua2Q/H2OdGM/u3mc333pqZ2TlAf+BZM1tiZk0DXzu/XA/49cVlZiV+iQvn3Hbn3BXe+wucc/8s6eegGHX1lXPunEDs17vvm51zq7z3+zrnkgP1XCWoHRCSBo2frifEx0T+490596Vz7ulAxOOn6wnA94Jz7hHn3Hfe+3nHdah4G5a/extXK8zsAzPraWY/mtkaM+tsZsvNrJp57DGzwd5tx3vLTjGzNt5li83sEe/9x83s5lDWT05M2DRogDnAud77HYEqZhYNdAX+nW/ducAeM6vvXTf3OPtNcc51BsYALzrnfgK+BIY559o559aVcD0AMLMRZrbazL4DWniXNTWzb8xsoZnNNbOWR2xzBZ66f+BtbFU0s0fM7Ffvh3usmZm37Cwze9LMZgN3HiOUnt7n+sPM/pJveQNvLKvNbGQh8ef/xVpkRiOIdX3RzH7yruucb1ene9evz20Qe7cpNNOST6yZfW5mq8zsNTPL+6yY2XNmtsjMZphZrULqO8vMOnrvn3D25AhRZjbOzJaZ2admVsm7fFj+hnlRG5snk/Ra/vfczMoBjwEDva/1wBKMt6g4wvGYyC2Xd7zbMbKZxVGKvhdy950/85h3XIdYM+AloA3QErgGz3f9vcCDwI/An4FWwHoO/23oAvyC92+JmcUCWd6y4NvfCynFwqlBsxDoYGYxQAbwM54P8bnAJ3gaODFAA2ACcJ533fEO0A/z/X92AOI+ipl1AK4C2gOXA528q8YC/3DOdcDz4Xwl/3bOuU+BBcC13sbWAWCMc66Tc641UBHI3yip5pzr5px77hjhNAK6ARcDr5lZBe/yzsC1eH65X1ncL7Ig1rWy9xf2bcDb+Za3BC701mekeRrBvugM3AOcATT1xg5QGVjknDsTmA0c1dgLsBbAWOdcGyAFT33hiIb5cfbRiHzvOZ7vgUeAid7XemIgAs8VxsdEQJWy74XSbINzbrlzLgdYCcxwnum6y/Ec23PxfP+fB7wKnGGeH7hJzrn9+dZ3Bb7G87ejEtDIObc66LWREhM2V9t2zmWa2UbgBuAnYBnQA88fm9/wNHBuAFbjOWBvxNNAued4uy7ifiCdC3zunEsHMLMvgQrAOcAn3h9TAOV92FcPM7sPqATE4fmAT/au8+UP08feL4Y15umqy/31N905t8cb32d4PvwLfNjfkYJV1w8BnHNzzCzWDo9b+do5lwFkmNlOoA6w1Yfnmu+cy+26/BBP/T8Fcjj8ur4PfObDvkrSFufcj/mePzfDkL9h/sJx9lHUex4s4XpMBFpp+l4ozTLy3c/J9zgHz9+0OcDtQENgBHAZcAWHf9z+iufH8HpgOlAT+BueH80SxsKmQeM1B88vlBvxtMafBxY655yZzcGTNn8MWIynsXPAObfvOPscCDzt/f9n77JUIKbkwy/gyMZTBJDsnGvn6w682ZRXgI7OuS1mNgrPF2CutGLE4Y6zvDiCUdei4s3/5ZeN78e8r/UP9omcfHm/jhdTSb63xRWOx0QwlJbvhbDlrXNNoJxzbr15xlHeC9zhXX/IzLYAfwUeB2oB/+e9SRgLpy4n8LSw6wI/O+d2AAc53Oqei6e7aY5zLhvYAhQ5IDif8mY2D09/8l3eZR/hGZOw2AIzKHgOcJm3rzsG6AekAxvM7EoA82hbyLb5G1u5X1K7zazApUHnAAACqUlEQVQKnl8h/rrSzCK89WyCJ8MF0MvM4sysIp5ZXz8WuYdjC1ZdB3r31RXY50ND9ng6m1lj84ydGcjhYyki33Nfg2/HWElqaGa5XaNX53v+gfn+//morQoq7D0PRiM+V7geE4FWmr4Xwt084A/v/blAfQp+VucCO7zZsLnAKWj8TNgrTb9Mjss5NwOIzvf4tHz31wGW73FvH3f7snPu0SOe50cCOG3bObfIzCYCS4BNHP4gXQu8amYP4annR8DSIzZ/F89YlwN4utTewJOt2ognleqv1XjGgtQBbnXOHfSmtn8AxuMZgDfBOVdYd9NxswJBrOte80y7jcWTwTtRP+PJ3J2B5w/N597laUArM1sI7ONwQ+JIgerK/A0YYmavA2vwjBH4B4cb5hF4GjrHUth7PhN4wMyWAE8FchxNGB8TBapRxP3i77B0fS8UCK2I+0HnnNsItM73+PrC1jnnBuVb/hNH/Hh3zj0MPOy9v518fzskfJ3Ulz7wjsnp6JzbHepYwo13AOPzzrluZjYA6O+cGxKiWGYB9xbR6Ao6M1uOZ+r/ZmAnEO+cywxtVB5m9i7wlXcgaZkVyGMi//FuZvcAsc65YA8ODwozm4zncz4z97h2zm0IdVwihQmrDE1xmdnnQOMjFt/vnGsUgnDCnnlmPE3A84u+PzD6/9u5dxuEgSAIwzMFEdMHEj3Qg2O6QDRACaR0QEJGHY6W4JKTLROApfPa/xeeZGml22DuZc2/Ak7J9l3SMyLetl+SLksJM/hf3e+2Tyr/fzl8/Sgp21eVS8WPuq8blwVM2vQOzVbY7iQdB8O3iDi3qGcpbO9UjtVqfUTsW9QzJ+b8N2vuiSF6BGtDoAEAAOlle+UEAAAwQqABAADpEWgAAEB6BBoAAJAegQYAAKT3AakAw4OnYA7SAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (10,10))\n",
    "sns.heatmap(pd.DataFrame(S[:,0:-1],columns = S_header).corr(), annot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa987a357f0>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAJDCAYAAADtp9X3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd8VFX6x/HPmQm9htCbdFkBpYPKUgUEF1TAtirqonRCVbD8AFEsqCAWUGTZtayKwqqguIiADaQjRaQpIJGEkAYhhJLk/P6YISQkDDMwJYnf9+s1r2TuPffmeTI3kzPPPedeY61FREREpKByhDoAERERkUBSZ0dEREQKNHV2REREpEBTZ0dEREQKNHV2REREpEBTZ0dEREQKNHV2RERExK+MMfOMMbHGmO0XWG+MMa8YY/YaY7YaY5pnWXefMWaP+3GfP+JRZ0dERET87d/AjR7W9wDqux8DgdkAxphywCSgDdAamGSMCb/cYNTZEREREb+y1n4HJHhocjPwjnVZA5Q1xlQBugPLrLUJ1tpEYBmeO01eCbvcHXjjTNxvf9rLNA9tOT7UIYRUbEZqqEMIqVnVToQ6hJAa/keJUIcQMotjNoU6hJB6okrHUIcQcpMP/McE62cF+/9s4Qp1B+GqyJw1x1o7x4ddVAMOZnke5V52oeWXJSidHRERESk43B0bXzo358utI2g9LL8sOo0lIiIiwRYF1MjyvDpwyMPyy6LOjoiISH6XkR7cx+VbBPR3z8pqCxy11kYDS4Fuxphw98Dkbu5ll0WnsURERMSvjDEfAB2B8saYKFwzrAoBWGvfAJYAPYG9wAngAfe6BGPMU8B6966mWGs9DXT2ijo7IiIi+Z3NCHUE2Vhr77rIegsMu8C6ecA8f8aj01giIiJSoKmyIyIikt9l5K3KTl6jyo6IiIgUaKrsiIiI5HM2j43ZyWtU2REREZECTZUdERGR/E5jdjxSZUdEREQKNHV2REREpEDTaSwREZH8TgOUPVJlR0RERAo0VXZERETyO//cnLPAUmVHRERECjRVdkRERPI7jdnxSJUdERERKdBU2REREcnvdFFBj1TZERERkQJNlR0REZF8TjcC9UyVHRERESnQVNkRERHJ7zRmxyNVdkRERKRAU2VHREQkv9OYHY9U2REREZECTZUdERGR/E73xvJIlR0REREp0NTZERERkQJNp7FERETyOw1Q9kiVHRERESnQVNkRERHJ73RRQY9U2REREZECrUBXdp54ZjrfrVpHufCyfPreG6EOxy8adWjKnRMfwOF08P385fxv9qfZ1ocVDuMf00dwReM6HE9KZs7wGcRHHQGgWsOa3PvMIIqVLEZGhmXqzRNIO3WGcR9OpkyFcM6cOg3AjHufIjn+WNBz8+ShJwfSolNLTqWeYubYl/lt+6852tRtUpfIl0ZTpGhhNq7cwFuT5gBQskxJHp41norVKxEbdZhpQ58j5WgKHW7pSJ8hfQE4mXKS2Y/PYv8v+yhUpBDPfPw8hQoXwhnmYPWSVXww/f2g5uuNIm1bUWbUcIzTQcqiJRx/94Nc2xXt1J6IZyYT+8BgzuzcDU4n4Y+No9CV9cHp5MSXX3H8ndy3DZUBTw6kRacWnEo9xatjZ+b6etdpUpfIl0ZRuGhhNq7cyD+zvN5jZz2S+Xq/OPR5Uo6mXHC/ta6qzeCpQylWqjgZ6ekseO0jVi3+AYAe991ErwG9qVKrKv2vuZvkxLzzdzFj+hR63NiZE6mpDBgwms0/bc+2vlixosz/YA516l5Beno6X3yxjMcefzZzfb9+vZj4f2Ow1rJ16w7u7T882ClcsnodrubGSfficDrY9OE3/DB7cbb1V7RuyI2T7qFSw5osGPEaO5asy1w38bd3id15EICjh+L44MHpQY09YDRmx6MC3dm5pWdX/t63N4899WKoQ/EL43Dw9ykDmHHPUyTGJPD4omfZsmwD0XujMtu0u70zJ44e5/GOI2jV6zr6TriHOcNn4HA6eHBGJP8c8ypRvxygRNmSpJ85d12GuaNmcmDbb6FI66JadGpJlVpVGdx+IA2aXcmQqUN5+OaxOdoNnjqMWRNeY9emnUx8ezLNO7Zg0zcb6TvsNrau2sLCWQvoO7QffYfexjvP/pvDB2N47PYJpBxNoXnHFgx7bjgP3zyWM6fO8H93PsbJEydxhjl5buE0Nq7cyO7Nu0KQ/QU4HJQdO5K4kQ+THnuEivNmc/L71aTtP5CtmSlejJK39eH09h2Zy4p16QCFChF7z4OYIkWo+MG/SP1qBekxh4OdRa6ad2pB1VpVGdp+EA2aXcmgqUMYf/O4HO0GTx3K7AmvsWvTLv4vy+vdZ1g/tq3ayn9nLaDP0H70GdqPd599+4L7PZ16ipmjpxO9P5rwSuV48YsZbP52MyeOpbBzwy9sWL6ep+c/E4LfxIX1uLEz9evVpuFV7WjTujmvv/Ys17XrlaPd9Blv8M23qylUqBDLls7nxu6d+N/SldSrV5vxjwynfYdbSEo6SoUKESHI4tIYh6HnU/fz7t3PciwmgYcWPcWurzdxZM8fmW2OHorj07Fvct3Am3Jsn3byNG/0fCyIEUteUKBPY7Vs2oQypUuFOgy/qd20HkcOxBB3MJb0M2msX7yKpt1aZmvTtFsrVi/8FoCNS9bQ8LrGAFz112uI2nmAqF9c/wxTko5j88k53tbd2rBy4QoAdm/eRYnSJQivGJ6tTXjFcIqXLMauTTsBWLlwBW26twWgTdc2rFiwHIAVC5bTtptr+c6NOzM/8e/avJOIKuUz93fyxEkAnGFhOMOcYG0AM/Rd4asakhb1B+mHoiEtjRNfr6Bo++tytCs98B8c/8+H2NOnzy20YIoVA6cDU6QInDlDxokTQYzes9bd2nr1ehcrWZxdm1wd0JULV9Da/Xq37tqGle7Xe+WC5bRxv94X2u+hfYeI3h8NQOLhBI7GHaVMudIA7Pv5N45ExQY4Y9/16tWdd/+zAIC16zZRpmwZKleumK1NaupJvvl2NQBnzpxh0+ZtVKtWBYAHB/yd2bP/TVLSUQCOHIkPYvSXp1rTuiTsP0ziwSOkn0ln++I1XNm1RbY2SVFxHN55EJuRt/5uAyojI7iPfMarzo4xprY3yySwylYqR8Khc29KidEJlK0UkaNN4qE4ADLSM0hNPkHJ8FJUqlMFa2HUO4/zxOfP031Q72zb3f/CMCYueYGbRvQNfCI+iqgcQVx0XObzuJh4IipH5GgTH3PudxOfpU2Z8mVJjE0EIDE2kTLly+b4GV3v6MamlRsynzscDmZ8+QrvbH6Pn374id0/7fZrTpfLUaE86bHn/gmnx8bhrFAhW5tCDerhrFiBk6vWZFueuuJbbGoqlRcvoNKnH5D8/kfYY8lBidsbEZUjiM/yesfHxFPuvNe7XOUI4mOytonLfL3LXuD19ma/9a+pT6FCYcQciPFvUn5WrWplog4eynz+R1Q01apWvmD7MmVK87eburJipev0XP36dWjQoA7fffMpq75fTPduHQMdst+UrlyOY9Hn/taPRSdQunK4hy2yCytSiIGLn+LBT56kYbcWF99ACgRvT2MtBJqft2wBcMEjxRgzEBgIMOulp3mw/12XFKCcY0wuC8+rOJhcGllrcTqd1G/VkKm9J3A69RRj3p/EgW2/sXP1duaOfIWkwwkUKVGUIbPHcW2f9vz43+8ClIXvDLnndH6rnG2823+Ta5twwx3deLTvI5nLMjIyGN0jkhKlS/DonMep2eAKft99wMNegiy3gyFrwsZQZuRQEp96Pkezwo0aQkYGMb1uw1G6FOVnz+TU+k2uKlEedf7r7d0x4dt+wyuGM/LlMbwy5uVL2lcwXejvPDdOp5P/vPs6r70+j337fgcgzBlGvXq16XxDP6pXr8I3Kz7hmmadOXo074xJ8oUvr9eMayNJjk0ivEYF7vvgcQ7vPEji73mveucra3W7CE88dnaMMQ2BRkAZY0yfLKtKA0U9bWutnQPMATgT91vefufIJxJjEihX9dwn0fAq5UiKTTivTTzhVcuTGJOAw+mgWKnipCQdJzEmnt1rd3A80fUJftvKTdRsXIedq7eTdNi1j1MpJ1m36AdqXVM/5J2dnv1voutd3QHYu3UP5bOcYipfOYKEw9nzzvrJHlyf4hMOuz79HY1LIrxiOImxiYRXDOdoXFJmuysa1mLYtEim9J9EclLO6kbKsRS2rdlG847N81RnJyP2CM6K505bOCuWJz3uXNXCFC9OWJ3alJ81w7W+XDkipj1N/CNPUKxbF06uWQ/p6WQkJnF623YK/6UBqSHs7PTo3zPb6531lGJE5QgSc329s7Ypn3lMJF3g9Y6Pib/gfouVLMbj/5rE+y++l7fGZmUxZPB9DBhwNwAbNvxE9RpVM9dVq16FQ9G5j7l6Y/Y09uzdxyuvzs1cFvVHNGvXbiItLY39+w+ye/ev1K9Xmw0btwQ2CT84FpNA6Srn/tZLVylH8uEkD1tklxzrapt48Aj71/xClca1CkRnRzy72GmsK4G/AWWBXlkezYGHAhuanG//lr1UrFWF8tUr4iwURqte17Nl2YZsbX5atoHr+nYAoEXPtuxa7Zqh8fO3W6jWsCaFixbG4XTQoM1VRO+JwuF0UDLcNa7JGebk6s4tOLT79+Amlosl73zB6B6RjO4RyZqlP9Kpb2cAGjS7kpTkE5mnKc5KjE0kNSWVBs2uBKBT386s+2otAOuWraVzvy4AdO7XhbXLXMvLV63Ao3Me4+VRL3Fo37lTAqXLlaZE6RIAFC5SmGvaNSXq1yjyktO/7CSsRjWcVSpDWBjFb+jMye9/zFxvU1KI6XErh/v8ncN9/s7pn3cQ/8gTnNm5m/SYWIq0aAaAKVqUwo3+wpn9B0OVCgBfvrOEMT1GMqbHSNYuXZPt9T7h9evtOl23ftk6Orlf7079urDO/XqvX7Y21/2GFQpjwluP881/V7D6i1VByfdSzH7jbVq26kbLVt1YtGgp997dD4A2rZtz7OgxYmJy/sOe8uQjlClTijFjJ2VbvmjR/+jY0TXGKyIinPr16/DbvtD/3Xvj0JbfiKhdmbI1KuAs5KRxr7bsWrbRq22Lli6Os7DrM37x8JLUaNkg28DmfM1mBPeRz3is7FhrPwM+M8Zca6390VPbvOjhSc+xfvNWkpKO0eWWexg64F769uoe6rAuWUZ6Bu9P/Cej3nkc43Sw6qOVHNoTRe/Rd3Bg269s+XoDP3y0ggHTRzD1m1dJSTrOnBGuT/YnjqWwbO7nPL7oOay1bFu5mW0rN1G4WBFGvfMEzjAnDqeDHau28d0Hy0OcaXYbV2ygZaeWvPH9W64pw+Nezlw348tXGN0jEoA3Hp9F5EujKVy0MJtWbmSjewzOwlkLeHj2BG64oxtHDh1h2mDX9Ns7R95JqfDSDHp6KAAZ6emM/dtowiuWY9T00TicDozDwarPv2fD8vVBzvoi0jNIeulVyr/8PDicpHz+JWn79lPqofs588tuTv6w+oKbpiz8lPAnxlPxP/PAwIkvlpL2a96ZibdxxQZadGrJ7O/nuF/vmZnrpn85kzE9RgLw5uOzMqeeb1q5kU0rXf/w/jtrAeNmj6fLHV2JO3SEFwY/53G/1/+tHVe1bkSpsqUyO8WvjH2Z/Tv2cdMDvbhlcB/CK4Tz8levsHHFRmaNfzWYv45cLflyOTfe2Jldv6ziRGoqDz44JnPdhvVf0bJVN6pVq8Jjj47kl517WL9uKQCzZv2Lef/6gKVffUPXGzqwdctK0tPTGf/oUyQkJF7ox+UpGekZLJn4b+59ZzzG6WDzR99yZM8fdBrTl0Nb97Hr601UvboOd84ZTdEyxWlwQzM6ju7LrK7jqVC/Gn97ZgA2IwPjcPDD7EUFp7MjHhlvznUaY+oAM4G2gAV+BEZba716h/wzn8Ya2nJ8qEMIqdiM1FCHEFKzquWdWU6hMPyPEqEOIWQWx2wKdQgh9USVjqEOIeQmH/hPbiMtA+LkpkVB/T9btHnvoOXmD95OPX8f+AioAlQFPgby1lXIRERERHLhbWfHWGvftdamuR/v4arwiIiISKhpzI5H3k49X2mMmQB8iKuTcwfwhTGmHIC1NsHTxiIiIiKh4m1n5w7310HnLf8Hrs5PHb9FJCIiIuJHXnV2rLUer5ZsjOlqrV3mn5BERETEJxm6qKAn/ro3Vs7LtIqIiIjkAf6663m+moImIiJSoOTDQcPB5K/KjmZmiYiISJ7kr8qOiIiIhEqGKjue+Kuys99P+xERERHxK68qO8aY74HvgO+BVdbabLeHttb2yXVDERERCTyN2fHI28rOfcAuoC+w2hizwRgzI3BhiYiIiPiHt9fZ+c0Ykwqcdj86AX8JZGAiIiLiJY3Z8ciryo4x5lfgU6AS8E+gsbX2xkAGJiIiIuIP3s7GegVoB9wFNAO+NcZ8Z639NWCRiYiIiHdU2fHIq8qOtXamtfY24AZgIzAZ2B3AuERERET8wtvZWC8CfwVKAmuAibhmZomIiEiIWat7Y3ni7WmsIcBzwMfW2p0BjEdERETEr7zt7PQGrgdeNcbUAX4CvrPWzgxYZCIiIuIdjdnxyNup58uNMd8ArXBNOx8MNALU2REREZE8zdsxO8uBEsCPuMbqtLLWxgYyMBEREfGSrqDskbdXUN6K62KCjYGrgcbGmGIBi0pERETET7w9jTUawBhTEngA+BdQGSgSuNBERERELp+3p7GG45p63gI4AMxDU89FRETyBg1Q9sjb2VjFgOnARmttWgDjEREREfErb09jvRDoQEREROQSaYCyR94OUBYRERHJl7w9jSUiIiJ5lcbseKTKjoiIiBRoquyIiIjkdxqz45EqOyIiIlKgqbIjIiKS32nMjkeq7IiIiEiBFpTKztCW44PxY/KkWRueD3UIIXV785GhDiGkZkRXCnUIIZVBcqhDCJmbKjfDaf68nyejzelQh/DnosqOR3/ev0QRkQD6M3d0RPIajdkRERHJ7zQbyyN99BAREZECTZUdERGR/E5jdjxSZUdEREQKNHV2REREpEDTaSwREZH8TgOUPVJlR0RERAo0VXZERETyOw1Q9kiVHRERESnQVNkRERHJ7zRmxyNVdkRERKRAU2VHREQkv9OYHY9U2REREZECTZUdERGR/E6VHY9U2REREZECTZUdERGR/M7aUEeQp6myIyIiIgWaKjsiIiL5ncbseKTKjoiIiBRoquyIiIjkd6rseKTKjoiIiBRo6uyIiIhIgabTWCIiIvmdbgTqkSo7IiIiUqCpsiMiIpLfaYCyR6rsiIiISIGmzo6IiEh+Z21wHxdhjLnRGLPLGLPXGDMhl/UzjDE/uR+7jTFJWdalZ1m3yB+/Hp3GEhEREb8xxjiB14GuQBSw3hizyFq742wba+3oLO1HAM2y7CLVWtvUnzGpsyMiIpLf5a0xO62Bvdba3wCMMR8CNwM7LtD+LmBSIAPSaSwRERHxiTFmoDFmQ5bHwCyrqwEHszyPci/LbT9XALWBFVkWF3Xvc40x5hZ/xKvKjoiISH4X5MqOtXYOMOcCq01um1yg7Z3AAmttepZlNa21h4wxdYAVxpht1tpfLyNcVXZERETEr6KAGlmeVwcOXaDtncAHWRdYaw+5v/4GfEP28TyXRJ0dERGR/M5mBPfh2XqgvjGmtjGmMK4OTY5ZVcaYK4Fw4Mcsy8KNMUXc35cHrufCY328ptNYIiIi4jfW2jRjzHBgKeAE5llrfzbGTAE2WGvPdnzuAj60Nttc9r8AbxpjMnAVZJ7LOovrUuW7zk6jDk25c+IDOJwOvp+/nP/N/jTb+rDCYfxj+giuaFyH40nJzBk+g/ioIwBUa1iTe58ZRLGSxcjIsEy9eQJpp84w7sPJlKkQzplTpwGYce9TJMcfC3pu/vbEM9P5btU6yoWX5dP33gh1OJesWYfmDJj8EA6ng68/XMZ/Zy3Itj6scBgjZ4yhbpO6JCcm8+KwaRyJigWgz7B+3HBHVzLSM5g7aQ4/fbcZgOEvRNKySyuOxh9lZNfhmfu67qbruWP036lerzqP9B7Lr1v3Bi9RH13Z4Rpuntgfh9PB2vkrWTk7+wenOq0b0ntif6o0rMl/RrzC1i/XZa578O0JXNGsHvvW72LegBeCHbpPHnpyIC06teRU6ilmjn2Z37bnPHVft0ldIl8aTZGihdm4cgNvTXINJShZpiQPzxpPxeqViI06zLShz5FyNIXWXdtw97h7yMiwZKSnM/fJt/hl/bn302Ili/H6ijdY878fmTMxdH87zTo05x+THsThdPL1h1/xyeyF2daHFQ5j5PTR1GlSj+TEY7w0/IVzx/7QfnS5oysZ6en8c/Jbmcf+Gz+8RWpKKhnpGaSnp/NIr7GZ++t5/0306H8T6ekZbFyxgXef/XfQcr2YRh2acrv7vf+H+ctZmst7/wPTR1CzcR1SkpJ5y/3e3/rmdnQbdHNmu2oNazL1b+OJ2rGfm8fdRds+7SlepiQjG90b7JT8ymZc/No3wWStXQIsOW/ZxPOeT85lu9VAE3/Hk69OYxmHg79PGcDM+6cysetoWve+nir1qmdr0+72zpw4epzHO47g639+Tt8J9wDgcDp4cEYk7z0+h0ndxvDinZNIP3NuPNTcUTOZ0vNhpvR8uEB0dABu6dmVN6Y/HeowLovD4WDg04N56r7JRHYZRrve7alev0a2Njfc0Y2Uo8cZ2n4Qi+d+Rv9H7wegev0atOvVnsgbhjGl/2QGTR2Cw+E65Fd8vJwp/Sfn+Hm/7zrA8wOfYcfanwOd2mUxDsOtUx5g7v3P80LXcTTrfR2V6mWf7JB4KI75495g82ercmz/zZuL+WD0rGCFe8ladGpJlVpVGdx+IK9PeI0hU4fm2m7w1GHMmvAag9sPpEqtqjTv2AKAvsNuY+uqLQzpMJCtq7bQd+htAGxdtYWR3Ucwukckr4ybyfDnR2Tb393j7mX7mm2BTe4iHA4HDz01iKfve5KRNwzjr7ke+105fvQ4wzoMYvE/F9F/wn3A2WP/r4zsOoyn7nuSgU8Pzjz2ASbe+Thje47K1tFpfG0TWnVtw+gbIxnVdTiL5nwSnES9YBwO7poygFfvn8rkrqNplct7//W3dybl6HH+z/3e38f93r/usx94uufDPN3zYeaNfpX4qCNE7dgPwNblG3j25keDnY6EQL7q7NRuWo8jB2KIOxhL+pk01i9eRdNuLbO1adqtFasXfgvAxiVraHhdYwCu+us1RO08QNQvBwBISTqOzVvXJfC7lk2bUKZ0qVCHcVnqN61P9P5oDv9+mLQzafyw+Dtad2uTrU3rbm1YuWA5AKuXrOLq66/JXP7D4u9IO51G7MHDRO+Ppn7T+gDsWPczyUnJOX5e1N4oDv32R4Czunw1m9Yj/kAMCQdjST+Tzk+Lf6TReX8LiVFxRO/8HZvL1U73rv6ZUympwQr3krXu1oaVC10zUndv3kWJ0iUIrxierU14xXCKlyzGrk07AVi5cAVturcFoE3XNqxwHxsrFiynbTfX8pMnTmZuX7R40WwXhK3bpC5ly5fNrISESr2zx/7Bs8f+97Tumv3Yb9X13O/nxyWraHL22O/ahh8Wf5/t2K/nPvYvpPs9Pfhk1kLSTqcBcDT+aACyujS1m9YjNst7/4bFq7jmvOP9mm6tWON+79+U5b0/q9a9r2f9onOd/32b93DsSFKOdvlSRkZwH/nMRU9jGWNettaOMsYsJufUMQskAG9aa9cEIsCsylYqR8Kh+MznidEJ1D7vD7hspXIkHooDICM9g9TkE5QML0WlOlWwFka98zgly5Vm/eJVLH3zXNn//heGYTMy2PjlGr54NXupWEKnXOUI4tyvJ0B8dDwNmjbI1iYiS5uM9AxOJKdQKrw0EZUi2L15V5Zt4yhXOSI4gQdYmUrhJGX5W0iKjueKpvVCGFFgRFSOIC763OsfFxNPROUIEmMTs7WJjzn3u4h3twEoU75sZtvE2ETKlC+b2a5t92u5d3x/ypQvy1P3PwmAMYYHnniQl0e9lNlpDpWIyhHER2c99uOo3+zKnG1yHPulKFf5vGM/y+/EApPem4K1lq/+s5RlHywFoGrtqvyl9VX8/eF7OHPqDG9PncfePHIa1/W+fvH3/oTz3vtLhJciJfHch5qWf7uOWQ9NC07Qkqd4M2bnXffXFy+wvjwwD7gq60L3BYYGArQr15yGpepcaoxZ9pnLwvM+tZpcGllrcTqd1G/VkKm9J3A69RRj3p/EgW2/sXP1duaOfIWkwwkUKVGUIbPHcW2f9vz43+8uO165fBd6Pc9rlHNDay+wrb8iC7GCnFsWJpfLdeSsVF3a72LN0h9Zs/RHrmrdiLvH3cPEvz9Bj/43sXHlhmwdrNDJ/bjO3iT33HP/k3Bt+1if8STGJlAmogyT3pvCH79GsWPdzzjDnJQsU5IJtzxMvWvqM3bWeIa0e8gfiVy+S3zvz9qmVtN6nE49zaHdB3O2kwLvop0da+1G99dvL9TGGHM6l+0yLzj0UK3b/PI2nBiTQLmq5z6Zh1cpR1Jswnlt4gmvWp7EmAQcTgfFShUnJek4iTHx7F67g+PuXv62lZuo2bgOO1dvJ+mwax+nUk6ybtEP1Lqmvjo7eUR8dBzlq5bPfB5RJYKE817zs23iY+JxOB0UL1WC5KRk4mLiiMi2bXkSD8dTEByNSaBslr+FslUiOJal2pGf9ex/E13v6g7A3q17KF/l3GtYvnIECYfPe/1j4jKrFuCqdiS4X+ejcUmEVwwnMTaR8IrhHI3Lecpix7qfqVyzMqXCS9OweUOuan0VPe7tSbESRQkrVIiTJ1J557m3A5GqR/ExcURUyX785sg92nWMZz32jyclEx8dn+33FpHl95bo/vs5Gn+UtUvXUL9pfXas+5n46HjW/M81A3jvlj3YjAxKlyvNsYTQj2FMikkg3Iv3/nJVy5N03nv/Wa16Xc/6RT8ELeagu/h08D+1i47ZMcZ85P66zRiz9bzHFmPMSlxTywJu/5a9VKxVhfLVK+IsFEarXtezZdmGbG1+WraB6/p2AKBFz7bsWr0dgJ+/3UK1hjUpXLTDUlFvAAAgAElEQVQwDqeDBm2uInpPFA6ng5LhrnEtzjAnV3duwaHdvwcjHfHCni17qFK7KhVrVCKsUBjterVn/bJ12dqsX7aWTv26AHBdz+vZtnqre/k62vVqT1jhMCrWqESV2lXZ89OeoOcQCAe3/Er5WpUpV70CzkJOmva6lp+XbQx1WH6x5J0vGN0jktE9Ilmz9Ec69e0MQINmV5KSfCLbKSxwnZ5KTUmlgfsUT6e+nVn31VoA1i1bS2f3sdG5XxfWLnMtr3xFlczt6zSuS1jhQiQnHmP6yBd58Np/MPD6Afzr6XmsXLgiJB0dcHU4sh/7f2W9O/6z1n+9LvP3c222Y38t7Xr9Nduxv/enPRQpVoSiJYoBUKRYEa5p35Tfd7ne79Z+tYYm110NQJXaVQkrFJYnOjpw7r0/wv3e3zKX9/6tyzbQ1v3e37xnW3a63/vBVfVp0fNa1i/OOVhf/hxMboMXszUwpoq1Ntp9/4rclAf+Y61teKF9+KuyA9C4YzPunHg/xulg1UcrWfL6f+k9+g4ObPuVLV9vIKxIIQZMH0HNRrVJSTrOnBEziDvomorZ5pa/0nPorVhr2bZyMwufe4/CxYrwyEdTcIY5cTgd7Fi1jY+eettvg5dnbXjeL/u5FA9Peo71m7eSlHSMiHJlGTrgXvr26h7UGG5vPvKy99G8UwsGTHJNPV8+/2sWvPYRd425m73b9rB+2ToKFSnEqJfHULtRHY4nHeel4dM4/PthAPoNv50ud9xAelo6856cy6ZvXB2CMa+Oo9G1TSgdXpqkuCQ+nP4+y+cvo033tjw4ZRBlypUh5dhx9u3Yx5R7L/3+dHUdJS87/wtp2LEpN0/sj3E6WP/RNyx//VO6j+7HwW372PH1RmpcXYf73hxD8TIlOHPqDMlHjvJit4cBGPrRJCrWrUqREkVJSUzmo/Fz2P3dVr/HuCcj5yBwXw16ajDNOrbgVOopXh33cuY4khlfvsLoHpEA1Lu6HpEvjaZw0cJsWrkxc7p4qbKleHj2BCpUrcCRQ0eYNvhZjh89Tp8hfenUtzNpZ9I5ffI0/35mXrap5+DqHNW7uv4lTz13msuf/9G8Uwv+MfFB17H/0dcsfO1j7hzzd37dupf1X7uO/ZEzzh77yUwf/gKHD7qO/b7Db6PL7e5jf8pcNn+ziUo1KjF+zmMAOMKcfP/Ztyx87WMAwgqFMeyFSGpfVZu0M2n8e+q/2L760o+JCq7rwvlN447NuH3i/Tjc7/1fvv5fernf+7e63/v/MX0ENdzv/XOzvPc3aHsVt46/m+dvfTzbPvtMuIfWN7ejTKVwjh5O5If5y/n85Y/9FvOb+z/O7QRcQJx4fXhQT2QXH/Za0HLzh4t2drzaiTEtzp7uyo0/Ozv5TSg7O3mBPzo7+VkgOzv5gT86O/mVPzo7+Zm/Ozv5kTo7eYc3s7GSyT4Ly7ifG8Baa0t76uiIiIhIgOXD6eDB5M0A5fx9oRYRERH5U/PpdhHGmOZAO1yVnR+staG96paIiIiosnMRXp9UNsZMBN4GInANSv63MeaJQAUmIiIi4g++VHbuAppZa08CGGOeAzYB+fvmSyIiIvldQbyqqB/5Ml1gP1A0y/MiQM7bD4uIiIjkId7MxnoV1xidU8DPxphl7uddgQJ8OUoREZF8QmN2PPLmNNbZy1RuBD7Jsvwbv0cjIiIi4mfeTD3PvFa6MaYw0BBXZWeXtTbHPbFEREQkyDI0ZscTrwcoG2N6Am/iGqdjgNrGmEHW2i8DFZyIiIjI5fJlNtZ0oJO1di+AMaYu8AWgzo6IiEgo6a7nHvkyGyv2bEfH7Tcg1s/xiIiIiPiVN7Ox+ri//dkYswT4CNeYnduA9QGMTUREROSyeXMaq1eW7w8DHdzfHwHC/R6RiIiI+EYDlD3yZjbWA97syBjzqLX22csPSURERMR/fLoR6EXcBqizIyIiEmRWFxX0yJcByhdj/LgvEREREb/wZ2VHJwxFRERCQWN2PFJlR0RERAo0rzo7xhinMWb0RZp97Id4RERExFc2I7iPfMarzo61Nh24+SJtnvFLRCIiIiJ+5MuYnVXGmNeA+UDK2YXW2k1+j0pERES8pzE7HvnS2bnO/XVKlmUW6Oy/cERERET8y+vOjrW2UyADERERkUuk6+x45NPUc2PMTUAjoOjZZdbaKRfeQkRERCS0vO7sGGPeAIoDnYC5QD9gXYDiEhEREW9pzI5Hvlxn5zprbX8g0Vr7JHAtUCMwYYmIiIj4hy+nsVLdX08YY6oC8UBt/4ckIiIiPsmH174JJl86O58bY8oCLwCbcM3EmhuQqERERET8xJfOzjRr7SlgoTHmc1yDlE8GJiwRERER//BlzM6PZ7+x1p6y1h7NukxERERCJMMG95HPXLSyY4ypDFQDihljmnHuhp+lcc3OEhEREcmzvDmN1R24H6gOTM+yPBl4LAAxiYiIiA+sLiro0UU7O9bat4G3jTF9rbULL+WHxGakXrxRAXV785GhDiGkPto0M9QhhFS/5pGhDkFC5MyffHbMIfvnfd+XvMeb01hjcvv+LGvt9POXiYiISBDlw3E0weTNaaxSAY9CREREJEC8OY31ZDACERERkUukyo5HXk89N8Y0MMYsN8Zsdz+/2hjzROBCExEREbl8vlxn5y3gUeAMgLV2K3BnIIISERERH9iM4D7yGV86O8Wtteff5TzNn8GIiIiI+Jsvt4uIM8bUxXVPLIwx/YDogEQlIiIi3tOYHY986ewMA+YADY0xfwD7gLsDEpWIiIiIn/h0nR1gCbAS1+mvFKAv2a+qLCIiIkFmVdnxyJfr7FwJtAI+w3V/rHuB7wIUl4iIiIhfeH2dHWPMV0Bza22y+/lk4OOARiciIiIXp8qOR77MxqoJnM7y/DRQy6/RiIiIiPiZLwOU3wXWGWM+wTUj61bg7YBEJSIiIuInXnd2rLVTjTFfAn91L3rAWrs5MGGJiIiI1zLy34X+gsmXyg7W2k3ApgDFIiIiIuJ3PnV2REREJA/SAGWPfBmgLCIiIpLvqLIjIiKS36my45EqOyIiIlKgqbIjIiKSz1mryo4nquyIiIhIgabKjoiISH6nMTseqbIjIiIiBZoqOyIiIvmdKjseqbIjIiIiBZoqOyIiIvmcVWXHI1V2REREpEBTZUdERCS/U2XHI1V2REREpEBTZ0dEREQKNJ3GEhERye8yQh1A3qbKjoiIiBRoquyIiIjkc5p67pkqOyIiIlKg5ZvKzkNPDqRFp5acSj3FzLEv89v2X3O0qdukLpEvjaZI0cJsXLmBtybNAaBkmZI8PGs8FatXIjbqMNOGPkfK0RQ63NKRPkP6AnAy5SSzH5/F/l/2UahIIZ75+HkKFS6EM8zB6iWr+GD6+0HNN6tmHZozYPJDOJwOvv5wGf+dtSDb+rDCYYycMYa6TeqSnJjMi8OmcSQqFoA+w/pxwx1dyUjPYO6kOfz03WYAhr8QScsurTgaf5SRXYdn7uu6m67njtF/p3q96jzSeyy/bt0bvET96IlnpvPdqnWUCy/Lp++9EepwLlsgjv/GbZvw2NwnOHzwMABr/rea+TM/pHyV8oyaMYayFcKxNoOl7y/l83mLgppvVoHIvVrd6kS+OIq6jevy3gvv8OmcTzL3VaJ0CYZPi6Rmg5pYC68+PJNdm3YGLd/zDTwv/18vkP+ol0ZT2J3/nCz5PzJrPJWqV+Jw1GGed+dfvFRxxs4cR4WqFXCGOfjvm5+w/OOvqVCtAo/NeRyHw0FYISeL//05/3vvy2CnnE0g8gdo3LYJD016iLBCTo4lHOPR2x/N3J/D4WD65zNIOBzPlAemBCfRy6XKjkf5orLTolNLqtSqyuD2A3l9wmsMmTo013aDpw5j1oTXGNx+IFVqVaV5xxYA9B12G1tXbWFIh4FsXbWFvkNvA+DwwRgeu30CI7uPYP4rHzLsOdc//TOnzvB/dz7GqBtHMOrGSJp3aEGDZlcGJ9nzOBwOBj49mKfum0xkl2G0692e6vVrZGtzwx3dSDl6nKHtB7F47mf0f/R+AKrXr0G7Xu2JvGEYU/pPZtDUITgcrpd8xcfLmdJ/co6f9/uuAzw/8Bl2rP050KkF1C09u/LG9KdDHYZfBOr4B9ix/mdG94hkdI9I5s/8EID09HTmPf1PhncZwiM3j6Nn/5uocd4xFyyByv14UjJvTXqTT+f8N8e+Hpw8kE3fbGRY5yGMunEEUXsPBi7Bi2jRqSVVa1Vl0EXyHzp1GK9NeI1B7QdStVZVWrjz7+fOf5A7/37u/G/qfxO/7/mdyBtH8OjtjzLg/wYQViiMxNhEHr51HCN7RDK291j6DelHuUrlgpbv+QKVf4nSJRgydQhPD3iKYTcM47khz2XbX69/9A7p6y7+ly86O627tWHlwhUA7N68ixKlSxBeMTxbm/CK4RQvWSzzE9jKhSto070tAG26tmHFguUArFiwnLbdXMt3btyZ2cvftXknEVXKZ+7v5ImTADjDwnCGOcGGptdcv2l9ovdHc/j3w6SdSeOHxd/RulubbG1ad2vDSnd+q5es4urrr8lc/sPi70g7nUbswcNE74+mftP6AOxY9zPJSck5fl7U3igO/fZHgLMKvJZNm1CmdKlQh+EXgTr+LyQxNjGzepKakkrU3oOUqxzh15y8Fajcj8YfZe/WPaSlpWfbV7GSxWjUuhHLPvwKgLQzaaQcSwlcghfRtlsbVrjz3+Vl/isWrqBtlvyXu/NfniV/CxQvUQyAYiWKkZyUTHpaOmln0kg7nQZAocKFcDhMwHP0JFD5d7i5Az9+uZojh44AruPhrIjKEbTq0oqv3MdAvpER5Ec+c9HOjjGmtPtruVwe4cYYZ6CDjKgcQVx0XObzuJh4Is57842oHEF8THzm8/gsbcqUL0tibCLgeiMvU75sjp/R9Y5ubFq5IfO5w+Fgxpev8M7m9/jph5/Y/dNuv+bkrXKVI4g7dC73+Oh4IirlzP1sm4z0DE4kp1AqvDQRlSKIz7ZtXMj+acmlC+Txf2Xzhrz8v1eZ+PZkajSomeNnV6xekTqN6rB78y6/5uStYPztZ1W5ZmWOJhwj8qVRzFgyk+HPj6BIsSL+Ssdn5+cff4H847Lkn/V3VPa8/Mu68//i359TvV4N3t7wDq9+9RpvTZ6DdX+gK1+lPK8sfZV/rf0XC2YvJOFwQkBz9CRQ+VetU42SZUryzPxnmfHFy3Tq2zlz+4cmD+Rfz8wjQ6eFChRvKjtnB6tsBDa4v559bAJijDHPnL+RMWagMWaDMWbD/uO/X1aQhpyfLmyOSktubbzbf5Nrm3DDHd14+9l/Zy7LyMhgdI9IBrS5nwbXNKBmgyt8iNh/jPEi91zaYO0FtvVXZBIsgTr+f92+l4eu/QejbhzBF//+nMfeeiLb+qLFizL+zceY++RbpB5P9TVsvwj03/75nGFO6jauy//eXcLoniM5mXoq22m/4Lt4/rn/jjzvtVmH5uzb8Rv3tezPyBsjGTxlMMVKuio9cdFxRHYfwcD2A+nSr0tmByE0ApO/0+mkbpN6PHn/ZCbdM5E7I++kau2qtOrSiqNxSfy6Lee4oLzOZtigPvKbiw5Qttb+zf21dm7r3ZWd7cBj5203B5gDcHPNv/n8m+nZ/ya63tUdgL1b91A+yymm8pUjcnzaiI+Jy9bjj6gcQcJhV2//aFwS4RXDSYxNJLxiOEfjkjLbXdGwFsOmRTKl/6RcT+ukHEth25ptNO/YnN93H/A1jcsWHx1H+arnco+oEkFCbEKubeJj4nE4HRQvVYLkpGTiYuKIyLZteRIPxyN5XzCO/6wdmI0rNzDo6SGUCi9NcuIxnGFOJrz5GN9+8g1r/vdjwPLMTbD+9nMTFx1HXHRcZiV39ZJV9B3Szy95eatn/5vo7s5/z3n5R+SSf1xMHOWz5F8+S/5J5+Wf5M7/httuYMFs10SH6APRxBw8TPW6Ndiz5VwFO+FwAr/vPsBVrRuxesmqwCSbi2DkHx8Tx7HEY5xKPcWp1FNsX7ud2lfVpm7jerTu2oYWnVpSuEhhipcqxpiXxzJ91EuBTlsCzJvTWA3dX5vn8mgGVLfW/sXfgS1554vMgZNrlv6YWWZs0OxKUpJPZJYmz0qMTSQ1JTVzIHGnvp1Z99VaANYtW0vnfl0A6NyvC2uXuZaXr1qBR+c8xsujXuLQvkOZ+ypdrjQlSpcAoHCRwlzTrilRv0b5O0Wv7Nmyhyq1q1KxRiXCCoXRrld71i9bl63N+mVr6eTO77qe17Nt9Vb38nW069WesMJhVKxRiSq1q7Lnpz1Bz0F8F4zjv2yFc5/Y61/TAIfDkJx4DIARL4zk4N6DLJr7aWATzUUwcr+QpCNJxEXHUa1ONQCuvv4aDu65vMq0r5a88wUje0Qy0p1/Z3f+Vza7khMe8r/SnX/nvp1ZkyX/Lu78u2TJ/8ihI1zjHttXtnxZqtetzuHfY4ioHEHhIoUBKFGmBH9peRV/BPm9Lxj5r/lqDY1aN8LhdFCkaBGubHYlB/dE8c7zb/NAm/t58PoBTBs+ja2rt+afjo7G7HhkcpaEz2tgzFvW2oeMMSsv0CQC2GKtvfdC+7iUys75Bj01mGYdW3Aq9RSvjnuZve4p0TO+fIXRPSIBqHd1PSLd0w83rdzInImuKcelypbi4dkTqFC1AkcOHWHa4Gc5fvQ4w58fwbU9ryfWPU07Iz2dsX8bzRUNazFq+mgcTgfG4WDV599nzlTxlSOXEquvmndqwYBJrqnny+d/zYLXPuKuMXezd9se1i9bR6EihRj18hhqN6rD8aTjvDR8God/d00n7jf8drrccQPpaenMe3Ium77ZCMCYV8fR6NomlA4vTVJcEh9Of5/l85fRpntbHpwyiDLlypBy7Dj7duxjyr2TLjn2jzbNvOz8L8XDk55j/eatJCUdI6JcWYYOuJe+vboHPY5+zSP9sp9AHP897/sbPe7tQXpaBqdPnmLeU3PZuXEnf2l1Fc8tnMb+X/Zljlt4b9o7bMwypi2YApF72QpleenzlylesjgZGRmcPHGS4V2GkHo8ldpX1Wb4tEjCCoUR83sMr4x7OXMigy/89f9g8FODae7Of2aW/Gd++Qojs+R/bur1Rt7Mkv/4LPk/586/XKVyjHppFOEVy2GMYcGsj/nmk29o+tem/OOJAa4RzAa+ePtzlr6/1E+ZXJpA5A9w66A+3HD7DdgMy1cfLmXRP7NfXqFx2yb0GXTrZU09X/z750Eb4Z3Yt2NQzy2FL/wmtKPXfXTRzo5XOzHmK2tttwut90dnJ7/yR2cnPwtVZyev8FdnR/KffPjhV/wsmJ2dhFs7BPX/bLlPvs1X/9wuOmbHGNPH03pr7X89dXREREREQsmbKyj38rDOAjmvyiUiIiLBo1KiR97MxnogGIGIiIiIBILXV1A2xkQYY14xxmwyxmw0xsw0xugKdSIiIpKn+XK7iA+BI0BfoJ/7+/mBCEpERES8ZzOC+8hvfLnreTlr7VNZnj9tjLnF3wGJiIiI+JMvlZ2Vxpg7jTEO9+N24ItABSYiIiJe0kUFPfJm6nkymZeYYgzwnnuVAzgOXPoV50REREQCzJvZWKWCEYiIiIhcmvw4jiaYfBmzc/YCg+1wVXq+t9YG/8Y5IiIiIj7wurNjjJkF1AM+cC8abIzpaq0dFpDIRERExDuq7HjkS2WnA9DYum+mZYx5G9gWkKhERERE/MSXzs4uoCZwwP28BrDV7xGJiIiITzRmxzNvZmMtxjVGpwzwizFmnft5G2B1YMMTERERuTzeVHZeDHgUIiIicsnyWmXHGHMjMBNwAnOttc+dt/5+4AXgD/ei16y1c93r7gOecC9/2lr79uXG483U82+92ZEx5kdr7bWXG5CIiIjkX8YYJ/A60BWIAtYbYxZZa3ec13S+tXb4eduWw3X9vpa4ziJtdG+beDkx+XIF5Ysp6sd9iYiIiJfy2L2xWgN7rbW/WWtP47q35s1eptIdWGatTXB3cJYBN17q7+Usf3Z2rB/3JSIiInmUMWagMWZDlsfALKurAQezPI9yLztfX2PMVmPMAmNMDR+39YlPFxUUERGRPMia4P44a+cAcy6wOrdgzi+ILAY+sNaeMsYMBt4GOnu5rc/8WdkJ7m9aRERE8qIoXJenOas6cChrA2ttvLX2lPvpW0ALb7e9FP7s7Nzrx32JiIhI/rQeqG+MqW2MKQzcCSzK2sAYUyXL097AL+7vlwLdjDHhxphwoJt72WXx5jo7P1hr22W5+3nmKsBaa0vj+mb75QYjIiIivstLU8+ttWnGmOG4OilOYJ619mdjzBRgg7V2ERBpjOkNpAEJwP3ubROMMU/h6jABTLHWJlxuTN5MPW/n/qq7n4uIiMhFWWuXAEvOWzYxy/ePAo9eYNt5wDx/xuPrXc+dQKWs21lrf/dnQCIiIuIbm6Fhs574ctfzEbgu9HOYc/dXtcDVAYhLRERExC98qeyMBK601sYHKhgRERHxXV4as5MX+TIb6yBwNFCBiIiIiASCN7Oxxri//Q34xhjzBXB2bjzW2ukBik1ERES8YIN8UcH8xpvTWGdnYf3ufhR2P0RERETyPG+mnj+Z9bkxprRrsU0OWFQiIiLiNY3Z8czrMTvGmJbGmG3AVmCbMWaLMabFxbYTERERCSVfZmPNA4Zaa78HMMa0A/6Fpp6LiIiElK6z45kvs7GSz3Z0AKy1PwA6lSUiIiJ5mi+VnXXGmDeBD3BdTPAOXLOzmgNYazcFID4RERG5CGsv3ubPzJfOTlP310nnLb8OV+en84U2nFXthI9hFRwzoiuFOoSQ6tc8MtQhhNSCTa+EOoSQur35yFCHEDK7TsaEOoSQ6lC8VqhDEMnkdWfHWtspkIGIiIjIpdGYHc98vRHoTUAjoOjZZdbaKf4OSkRERMRffLkR6BtAcaATMBfoB6wLUFwiIiLiJVV2PPNlNtZ11tr+QKL7QoPXAjUCE5aIiIiIf/jS2Ul1fz1hjKkKnAFq+z8kEREREf/xZczO58aYssALwCZcM7DmBiQqERER8ZqmnnvmS2dnmrX2FLDQGPM5rkHKJwMTloiIiIh/+NLZ+RE4ewHBU8ApY8yms8tEREQkNDRA2bOLdnaMMZWBakAxY0wz4OxvtDSu2VkiIiIieZY3lZ3uwP1AdWB6luXJwGMBiElERER8YK0qO55ctLNjrX0beNsY09dauzAIMYmIiIj4jTenscbk9v1Z1trp5y8TERGR4LEZoY4gb/PmNFapgEchIiIiEiDenMZ6MhiBiIiIyKXJ0Jgdj7y+grIxpoExZrkxZrv7+dXGmCcCF5qIiIjI5fPldhFvAY/iuk0E1tqtwJ2BCEpERES8Z60J6iO/8aWzU9xae/5dztP8GYyIiIiIv/lyBeU4Y0xdXPfEwhjTD4gOSFQiIiLiNV1B2TNfOjvDgDlAQ2PMH8A+4O6ARCUiIiLiJz5dZwdYAqzEdforBehL9qsqi4iISJDpruee+XKdnSuBVsBnuO6PdS/wXYDiEhEREfELr6+zY4z5CmhurU12P58MfBzQ6EREREQuky9jdmoCp7M8Pw3U8ms0IiIi4jMNUPbMl87Ou8A6Y8wnuGZk3Qq8HZCoRERERPzE686OtXaqMeZL4K/uRQ9YazcHJiwRERHxlm4X4ZkvlR2stZuATQGKRURERMTvfOrsiIiISN6TH2/hEEy+3C5CREREJN9RZUdERCSf00UFPVNlR0RERAo0VXZERETyOc3G8kyVHRERESnQVNkRERHJ5zQbyzNVdkRERKRAy/eVnSJtW1Fm1HCM00HKoiUcf/eDXNsV7dSeiGcmE/vAYM7s3A1OJ+GPjaPQlfXB6eTEl19x/J3ct82rruxwDTdP7I/D6WDt/JWsnL0o2/o6rRvSe2J/qjSsyX9GvMLWL9dlrnvw7Qlc0awe+9bvYt6AF4Idus8eenIgLTq15FTqKWaOfZnftv+ao03dJnWJfGk0RYoWZuPKDbw1aQ4AJcuU5OFZ46lYvRKxUYeZNvQ5Uo6m0LhtEx6b+wSHDx4GYM3/VjN/5oeUr1KeUTPGULZCONZmsPT9pXw+b1GOn5eXPfHMdL5btY5y4WX59L03Qh3OJalWtzojXhxJncZ1+c8L7/LZnE88tn/wyYF0vv0G/v6X2336ORVrVGLsaw9Tsmwpftv+KzNHTSftTBqd+nXhvscfICEmHoAlb3/B1x9+dcn5+NvjU8fS/obrOZl6kkdHPMmObbtytBn16BBuvv0mSpctRYvaHTKX33FfH+5+4DbSMzI4kXKCiWOf4dfd+4IZ/mVp1KEpt098AIfTwQ/zl7N09qfZ1ocVDuOB6SOo2bgOKUnJvDV8BvFRR2h9czu6Dbo5s121hjWZ+rfxRO3YH+QM/E+zsTzL35Udh4OyY0cSP2YCh+96gOJdOxNW64oczUzxYpS8rQ+nt+/IXFasSwcoVIjYex7kyP2DKXFLL5yVKwUz+stiHIZbpzzA3Puf54Wu42jW+zoq1auWrU3ioTjmj3uDzZ+tyrH9N28u5oPRs4IV7mVp0aklVWpVZXD7gbw+4TWGTB2aa7vBU4cxa8JrDG4/kCq1qtK8YwsA+g67ja2rtjCkw0C2rtpC36G3ZW6zY/3PjO4Ryegekcyf+SEA6enpzHv6nwzvMoRHbh5Hz/43UaN+jcAn6ke39OzKG9OfDnUYl+V4UjJzJ825aCcHoO7V9ShRpuQl/Zz+j97P4rmfMazDIFKOHqfLHV0z161a/D1jeoxkTI+Reaqj077LdVxRpybd2/Rh4thnmDRtQq7tVn71Pbd3vy/H8s8XLqV3x7u4tfPdzH3tXSZMGR3okP3GOBzcNWUAr94/lcldR9Oq9/VUqVc9W5vrb+9MytHj/F/HEXz9z8/pM+EeANZ99gNP93yYp3s+zLzRrxIfdaRAdFPX5XQAACAASURBVHTk4vJ1Z6fwVQ1Ji/qD9EPRkJbGia9XULT9dTnalR74D47/50Ps6Sw3bbdgihUDpwNTpAicOUPGiRNBjP7y1Gxaj/gDMSQcjCX9TDo/Lf6RRt1aZmuTGBVH9M7fsbl0+feu/plTKanBCveytO7WhpULVwCwe/MuSpQuQXjF8GxtwiuGU7xkMXZt2gnAyoUraNO9LQBturZhxYLlAKxYsJy23dp6/HmJsYmZlaPUlFSi9h6kXOUIv+YUaC3/n717j5Ox/P84/rpm12HXadcudpfKMaVEzuFLCCGdqL6ddFCORaRQ/YjOKocI0fmc9FUpQg6JchZJCanIrrVrl7XWYXeu3x8zxq5dszvM7Kn302MeO3Pf1337XPd9z8w1n/u67rthfSqUL1fQYZyTg4kH2bF5O+np6V7LORwO7nrsHt599q0s08tXLM+j00cybu54xs0dz0VNLs5x+fotL+OHea4fBEtnL/YcN4VZhy5t+WLW1wBsWr+F8hXKUaly9mN00/ot7I9PzDY99XCq53loaOkcPyMKqxoNaxP/VxwJu+PJOJHOurkraXDaZ1+DTk1Z9dl3AGyYt4qLWl6abT3Nrm3F2i+z/xAsqpzW5OujqMlzY8cYc1NepuUnR6VIMuLjPa8z4hMIqlQpS5kSF9YmqHIljq5clWV62pLvsGlpRM2dTZXPPyLlw1nYQyn5Erc/VKgSTvLeUx9iybGJVKgS7mWJoisiKoKE2ATP64S4RCJOa3xEREWQGHdqeyRmKlMhMoyk+CTA1ZCpEBnmKVe30UVM/GYyo955kvMuPD/b/125WmVqXlKT3zdmP0UghUPXu7uxdtEazz4+qfeTfZj7xhc82n0o4/o+x8AXHsy2bLnw8qQeOowzwwlAQmzWY6tF15ZMWPAKj0wfQUR0ZGAr4oMqUZWI3bvP8zpubzxVoiv7tI7b7r2JhWvmMGzUIJ557CV/hxgwYVUqkpTpsy8p9gBhVSKylTmw1/WZ4cxwkpZyhDLhWRv/Ta5pydovVwQ+YCkUfOmzMxL4NA/TADDG9AH6ADxfoy53VIk5qwC9Mjm0LjP/QjGGCoMHkPTUC9mKlbzkInA6iet+E47y5YicNoljaze4skRFQQ51L0I/znxiyKmup1fW9+2xc8sO7r/iXo4eOUrjdk14bOYT9G/bxzO/dGhphr/2GK+PmUna4aKRBfu3Ca9SkZbdWvPEzSOzzWvQukGW048h5UIpXSaEo5kymjl/hLgOnHXfruH7L78j/Xg6ne+4msHjH2LUrU/4vxJnI8f3v28fAB+++Skfvvkp19zYmf5D72XEg2P8FV1g5ZRUOK3uJpfvhuoNa3M87Th7f9/t5+CksMq1sWOM6QJ0BaoaY17JNKs8cMb8srV2BjAD4J8r2gfka9gZv5+gyqd+zQRVjiQj4VQGwISGElyzBpFTJ7jmV6xIxLinSXz0CUI6deDoqrWQkYEzKZnjP2+h5MUXklZEGjsH4w4QFnPq10xYdASHTvtlW5R17dWNjrd2BmDH5u1EZvpVHRkVwYF9B7KUT4xLyPKLPCIqggP7XL/+DiYkE145nKT4JMIrh3MwIRkgSwNm/dJ19H26P+XCy5OSdIig4CBGvPYY381ZxqpvfgxYPSWrLr26evb7U3ePIem0/Xy6mpfUJOqCaKYtd3VGLxVSiqnLX2NAm74Yh4MR1z/C8WPHsywz6r0xhEWGsWPzDqYOn0yZ8mVxBDlwZjiJjD51bKUkn8r0LvpwIXeOuNuPNfXdbffexE13XA/Azxu3Eh1zqo9hVExl4uP2n9V6v56z0N3np2g0dpLjDhCe6bMvPLoiyfFZj5OkuEQqxkSSHHcAR5CDkHKhpCYf9sxv2r1VscvqaOi5d3k5jbUXWAccBdZnenwJdA5caLk7/utvBJ9XlaDoKAgOJvSq9hz9/tQXk01NJa7LDey78Tb23Xgbx3/ZSuKjT3Dit9/JiIunVOPLATClS1Pykos58WfRaeXv3rSTyOpRVKxWiaASQTTsfgW/LFpf0GH5zbx3v/Z0HF614Efa9WgPwIWX1yU15Ui2UxZJ8UmkpaZx4eV1AWjXoz1rFq4GYM2i1bTv2QGA9j07sHqRa3pYpVOns+o0uBCHw5CSdAiAB18czO4du/ny9ayjPCSw5r87z9MhOLeGDsD6Jeu4t0kv+ra6j76t7uNY2jEGtOkLwE/LN9L17m6estXr1QBg7J2jGdplMFOHTwZgy4+badm1FQDtenbwHDeZ+4U17diMPTsK9vPhwzc/5Yb2t3ND+9tZPH8Z193sqluDxpeScuhwjn1zzuSCGqcyXld2bM1ff/zt93gD5c9NO6hcPZqIapUJKhFMk+6t2LRoXZYymxeto0UP1+izRl1b8NsPWzzzjDE07noFa+cWn/46krtcMzvW2k3AJmPMh7gSiBcBFthmrT3udeFAy3CS/PJkIie+AI4gUr+aT/quPyl3/92c+PV3jq744YyLpn72OeFPDKfyB2+CgSNfLyB95x/5GPy5cWY4mTPqbe5/dyQmyMHaWcvYt30PnYf0ZPfPu9j67XrOu6wmd702lNAKZajXoRGdhtzES50eAWDArNFUrhVDqTKleeLHKcwaPoPfl28u4FrlbP2SdTRp14Tp38/kWNoxJg+b6Jk3Yf4rDOkyCIDpj09l0MtDKFm6JBuWrmf9UtcH4GdTZ/PItBFcdUsn9u/dz7h+zwHQsmtrutzZhYx0J8ePHuOlB8YBcHHTerTr0Z4/f93FhPmuZOb74971rK8oeGT086zduJnk5EN0uP4OBvS+kx7dC/S3ic/CKoXx4lcTCC0binU6uab3tQzqMIC0w2k88fZoXh0+2WuD6PXRM+jzdD8mLHiFoOAgtq7+hemPZR+B+O5zb/PwlEe57ZE72PXLH3z7iWvUVbd7utO0Y3My0jM4nJzC5IcnBayuvvru25W0uaoVC9fM4eiRozw2eKxn3pwlH3BD+9sBGDbqQa65sTMhIaVZ9tNXzP7gC6a8OJPbe9/MFW2akZ6ezqHkQ0XnFBauz76PR73B4HcfxxHkYOWspcRu30P3Ibfw18872fztOlbMWsK94x/kqWWTSU0+zOsPTvAsX6f5xSTFJZKwO97L/1L0FMVOw/nJ5PU8rzGmK/AasBNXo6cG0NdaOz+3ZQN1GqsomBBbdIazB8J2Z9Hp9B0Isze8knuhYuzmRoMLOoQC8+vRuIIOoUC1Da1e0CEUuNf+/DTfWiCrY27M1+/Z5nv/V6RaV750UB4PtLPW7gAwxtQCvgZybeyIiIhI4PxrMwp55Mt1duJPNnTc/gCKVx5QREREih1fMju/GGPmAbNwNSJvAtYaY24EsNb+LwDxiYiISC7UZ8c7Xxo7pYF9wMkbrOwHKgLdcTV+1NgRERGRQifPjR1r7T3e5htjRlprnzv3kERERMQXus6Od/68N1aB3jpCREREJCe+nMbKjZqVIiIiBcBZ0AEUcv7M7Gjkm4iIiBQ6yuyIiIgUcVZfwV75M7OT493PRURERApSnhs7xpiaxpi5xpgEY0y8MeYLY0zNk/Ottc8GJkQRERHxxmnz91HU+JLZ+RDXBQWjgBhcmZyPAhGUiIiIiL/40tgx1tr3rLXp7sf7qFOyiIiIFHK5dlA2xlR0P11qjBmJK5tjgVtw3QhURERECpBTHZS9ystorPW4Gjcnt+T97r/GPf2pAMQlIiIi4he5NnastTUAjDEhwACgNa5GzvfAtIBGJyIiIrnS0HPvfLnOzjvAIeAV9+tbgXeBm/0dlIiIiIi/+NLYqWutbZDp9VJjzCZ/ByQiIiK+0e0ivPNlNNZGY0yLky+MMc2Blf4PSURERMR/8jIa62dcfXRKAL2MMX+7X18AbA1seCIiIpIb9dnxLi+nsa4JeBQiIiIiAZKX0Vh/5UcgIiIicnbUZ8c7f94IVERERKTQ8WU0loiIiBRCyux4p8yOiIiIFGvK7IiIiBRxGo3lnTI7IiIiUqwpsyMiIlLEOZXY8UqZHRERESnW1NgRERGRYk2nsURERIo4pzooe6XMjoiIiBRryuyIiIgUcbagAyjk8qWx88A/ZfLjvymUnKQUdAhSgG5uNLigQyhQszZMKugQCtS/ef/HO48WdAgiHsrsiIgEwL+5oSP5T7eL8E59dkRERKRYU2ZHRESkiHMajcbyRpkdERERKdaU2RERESniNBrLO2V2REREpFhTZkdERKSI02gs75TZERERkWJNmR0REZEizqnBWF4psyMiIiJ+ZYy52hizzRizwxgzIof5Q40xW40xm40xi40xF2Sal2GM+cn9+NIf8SizIyIiUsQVprueG2OCgFeBjsAeYK0x5ktr7dZMxTYCTay1R4wx/YFxwC3ueWnW2ob+jEmZHREREfGnZsAOa+0f1trjwMfAdZkLWGuXWmuPuF+uAqoFMiA1dkRERMQnxpg+xph1mR59Ms2uCuzO9HqPe9qZ9AbmZ3pd2r3OVcaY6/0Rr05jiYiIFHH5fVFBa+0MYMYZZud0Ti3HEI0xdwBNgLaZJp9vrd1rjKkJLDHG/Gyt3Xku8SqzIyIiIv60Bzgv0+tqwN7TCxljrgIeB6611h47Od1au9f99w9gGXD5uQakxo6IiEgR5zT5+8jFWqCOMaaGMaYk8F8gy6gqY8zlwGu4GjrxmaaHG2NKuZ9HAq2AzB2bz4pOY4mIiIjfWGvTjTEPAAuAIOBNa+0vxpixwDpr7ZfAi0BZ4FPjumP739baa4GLgdeMMU5cCZnnTxvFdVbU2BERESniCtvtIqy184B5p00blen5VWdY7gegvr/j0WksERERKdaU2RERESni8ns0VlGjzI6IiIgUa8rsiIiIFHG6Eah3yuyIiIhIsabMjoiISBFX2EZjFTbK7IiIiEixpsyOiIhIEafMjnfK7IiIiEixpsyOiIhIEWc1GssrZXZERESkWFNjR0RERIo1ncYSEREp4tRB2TtldkRERKRYU2ZHRESkiFNmxztldkRERKRYU2ZHRESkiLMFHUAhV6gbO73H9KFxu8YcSzvG5Icn8ceWndnK1Kxfi0EvP0TJ0iVZv3Q9b4yeAUDZCmV5eOqjVK5Whfg9+3hpwAukHkw943qr16tBv2cGEFIuFGdGBrOnzGLl3BUAdLmrG917X0t09Rh6NbidlKRD+bcR3O4f04fG7ZpwLO0Ykx6emOO2qFW/FoNeHkKp0iVZv3QdMzNti0emDvdsi3EDnif1YCrNOjbn9mF34HRanBkZvD5mJr+u3epZX0jZEF5dMp1V3/zIjFHT862uOQlE/avWqsaglx6i1qW1eP/Fd/l8xhzPusqUL8MD4wZx/oXnYy1MfmQS2zb8lm/1BahaqxoPvjSYmpfW4oMX3+OLTPHl5L4xfWh/81XcdvHNPv0/lc+rwsNTHqFsWDn+2LKTSQ+NJ/1EOu16duCux+/hQFwiAPPe+ZpvP1541vXJT088O57lK9dQMTyMz98v2GP3XFzethG9n7wfR5CDbz9exP+mzs4yP7hkMIMnDKVW/VqkJKXw0sBx7N8TD8CNA3ty1S0dcWY4eX30DH5avpGI6EgGTxhCeKVwnNay6MNv+OrNuQDcMuRWOt7amUOJBwF4f9y7bFi6Pn8r7KbPfvG3Qnsaq1G7xsRUj2FAm75MG/EqfZ/pn2O5fs8MYNqIKQxo05eY6jE0urIx4Hqj/7xyMwPb9uXnlZu5cUBPr+s9nnaMSUPGM/iqgYzt9ST3jr6f0PJlAPht3a+Mvu3/iN+9Lx9qnl3jdk2Irh5DvzZ9eHXEFPo/MyDHcv2eGcjUEVPo16YP0Zm2RY+BN7F55Sb6t+3D5pWb6DHgJgA2r9zE4M4PMqTLIF4ZNokHXngwy/puH3YnW1b9HNjK5UGg6n84OYWZo1/j8xn/y7au+57sw4Zl6xnYvj8PXf0ge3bsDlwFz+Bwcgqvj56RayMHoNZltSlToexZ/T+9Rt7N3Ne/YGDbvqQePEyHWzp65q2c+z1DuwxmaJfBRaahA3B9145MH/90QYdxThwOB32e7sdTdz3JoA4DaX1tG6rVOS9Lmatu6UTqwcMMaNOXua9/Qa+RdwNQrc55tO7ehkHuz7O+z/TH4XDgzMjg7aff5MEOAxh+3TC69OqWZZ1zX//Cs78LqqGjz/6z4zT5+yhqCm1jp1mnFiz9bAkAv2/cRpnyZQivHJ6lTHjlcELKhrJtwzYAln62hGadW7iW79icpbMXu6bPXkzzTi28rnfvrr3E/hkLQNK+AxxMOEiFiuUB2PXLH55fSwWhWafmedoWoWVDPNmHpZ8tobl7WzTv2Jwl7m2xZPZiWri3xdEjRz3Llw4tjc2UB61VvxZhkWH8tHxjwOqVV4Gq/8HEg+zYvJ309Iws6wopG8IlzS5hkfvLPf1EOqmHUgNXwTM4FV+613IOh4O7HruHd599K8v08hXL8+j0kYybO55xc8dzUZOLc1y+fsvL+GHeSsD9XnFvt6KsScP6VChfrqDDOCd1GtYh9s9Y9v29j/QT6ayYu5xmnZpnKdOs06nPuR/mreSyVg0801fMXU768XTid+8j9s9Y6jSsQ1J8kidLcjQ1jT07dhMRFZG/FcuFPvslEHI9jWWMedRaO84YM5nspwUtcAB431qbPc94DiKiIkiMTfC8ToxLpGJUBEnxSZ5pFaMiSIzLXCbB88YNiwzzlE2KT6JCZFie11unQR1KlAgm7q84f1bprEVERZCQKeaEuEQiTos5IiqCRPfpBnDV6+S2qHCGbQHQovMV3Dm8FxUiw3jq7jEAGGO454n7mPjQy54Pz4IUyPrnJOr8KA4eOMSglx+ixsU12PnzDmY+OYNjacf8WS2/6Xp3N9YuWpNlewD0frIPc9/4gl/XbiUyphKj3xvDgx2yZsXKhZcn9dBhnBmusRwJsYlZvvxadG1JveaXsHfXXt4c83qW944EVsWoCBL2Zvqsik3kwoYXZikTkamMM8PJkZRUyoWXJ6JKBL9v3JZp2QQqntaoqVStMjUuqZWlXNe7unFlj3bs3LyDt55+w3P6Jz/ps//saDSWd3nJ7Pzq/rsOWH/aYwOQAmQ7D2CM6WOMWWeMWffn4b/8Eqy1Wdtahuy5tNPL+Lre8MrhDJ44lMnDJp3VugIhb/XMqUzu61614EcGtu/Ps/c9ze3D7gCgS69urF+6LksDoyAFsv45CQoOotaltfjmvXkM6TqYo2nHPKe+CpvwKhVp2a01X789N9u8Bq0bcP/YvoyfP4nH3niCkHKhlC4TkqWMySEdfXLbrvt2DX1b9mZI50FsXvETg8c/FJA6SM5MDjsn23Gf8w48w7KnnpcOLc3w10by5piZpB1OA+Cb9+bT/z99GHr1YJLik7jnid7nFL8//Vs/+8V/cs3sWGvnuv++c6YyxphszX9r7QxgBsAN53fP05HTpVdXOt7aGYAdm7cTER3pmRcRFUHSvgNZyrta85nLRHLAXSY5IZnwyuEkxScRXjmcgwnJ7mUSz7jekLIhPP7WaD586f0sv3YKQtde3bJsi8hMMUdGRXjqeVLmXzbgqteBfa5Mx8EzbIvMtq75hajzoygXXp6LGl1EvWb16HJnV0LKlCa4RAmOHknj3efPeAj4XX7XP7OE2AQSYhP4/affAdfpgR79e/qlXrnJ/B546u4x2Y7509W8pCZRF0Qzbbmrc2apkFJMXf4aA9r0xTgcjLj+EY4fO55lmVHvjSEsMowdm3cwdfhkypQviyPIgTPDSWT0qW2bkpziWWbRhwu5c8Tdfqyp5CYxNoHImEyfVdERHIg/kGOZxLhEHEEOQsuVISU5hYS4BCKyLBtJkvv9EBQcxKOvjWT5nGWs+uZHT5nM74uFHy3gibdGBapq2eiz/9wps+NdrpkdY8xE99+5xpgvT3t8YYx5C9jkj2DmvzvP0zlu9YJVtOvRHoALL6/LkZQj2dL0SfFJpKWmceHldQFo16M9axauAmDtojW069nBNb1nB9YsWu2evjrH9QaXCGbEzMdZ9r8l/PD1Sn9U55zMe/drhnQZxJAug1i14McsMafmeVu46rxm0Wrau7dF+54dWO3eFlEXRHuWr3lpLYJLliAl6RDjB7/EfVfcS59WvXnr6TdZ+tmSfG3oQP7U/0yS9yeTEJtA1ZpVAbisVQN2b//br/U7k8zvgdwaOgDrl6zj3ia96NvqPvq2uo9jaccY0KYvAD8t30jXu7t5ylavVwOAsXeOZmiXwUwdPhmALT9upmXXVoD7veLebpn7STTt2KxAOmn/m23ftJ3oGjFUPq8KwSWCad29DWsXrclSZu2i1Z7PuZZdW/HzD5vd09fQunsbgksGU/m8KkTXiGH7T9sBGPjiIPbs2M2Xr3+RZV2Z93eLzlfw1zb/ZOTzQp/9Emgmt3SdMaaxtXa9MabtGYpEAk9Za+udaR15zeycrs9T/bj8ykauYYLDJrFz8w4Axs+fxNAugwHXKJSTww83LF3PzFGvAVAurBzDpg0nMqYSCXv382K/5zl88PAZ19v2hit54KXB7P791JfaKw9P5M+tu+h2T3eu73cj4ZXCOZiYzPol6z1fFLlx+unqB32f6sflV7qHTA6byA73tpgw/xWGdBkEQO3LajPo5SGebXFyuHi5sHI8Mm0ElWIqsX/vfsb1e47DBw9zY/8etOvRnvQTGRw/epy3n30zy9BzcDUOal9Wp8CHngei/mGVwnj5q4mElg3F6XRy9MhRHujQn7TDadSoV4MHxg0iuEQwcX/H8cqwiWfVf8GRQ7o9r8IqhfHiVxMILRuKdTpJO3KUQR0GkHY4jSfeHs2rwydnaxB9+Ossz9DzcuHl6fN0P6rVrkZQcBBbV//C9MemZvt/qpxfhYenPErZsLLs+uUPJgx+mfTj6dwxvBdNOzYnIz2Dw8kpvPb4NP7ZucenOszaMOms638uHhn9PGs3biY5+RARFcMY0PtOenTvnK8x3Nxo8Dmvo1G7xvQe7Rp6vviTb5k9ZRa3Dr2dHT9vZ+2iNZQoVYKHJg6lxiU1OZx8mJcfGMe+v10jh3o+cDMdbrmKjPQM3hzzOhuWrefipvV49rMX+PPXXVin67Pp5BDzwROHUqNeDay1xO+JZ/rIV7M1MvJLcfjsB5jz99x8G7f00vl35Ou5t2F/v1+kxmTl2tjJ00qM6X7ydFdOzraxUxz4q7EjRdO5NHaKg4Jq7BQG/mjsSNGmxk7hkZfRWD/j5eKM1trLvDV0REREJLCK4rVv8lNerqB8TcCjEBEREQmQvIzGylMvNWPMj9baK849JBERERH/8ee9sUr7cV0iIiKSRxp67p0/bxehnrgiIiJS6BTqu56LiIhI7pRt8M6fmR31BRcREZFCx5+ZnTv9uC4RERHJI13Tzbu8XGdnhbW2tTEmhayZMgNYa215XE+2BChGERERkbOWl6Hnrd1/ywU+HBEREfGVRmN559NpLGNMEFAl83LW2vy5Q6KIiIjIWchzY8cY8yAwGtjHqUakBS4LQFwiIiKSR+qx450vmZ3BQF1rbWKgghERERHxN18aO7uBg4EKRERERM6O+ux4l5fRWEPdT/8AlhljvgaOnZxvrR0foNhEREREzlleMjsnR2H97X6UdD9ERESkEHDqsr5e5WXo+ZjMr40x5V2TbUrAohIRERHxE19GYzUB3sKd6THGHATutdauD1BsIiIikge6grJ3vnRQfhMYYK39HsAY0xpX40dDz0VERKTQ8uVGoCknGzoA1toVgE5liYiISKHmS2ZnjTHmNeAjXNcvugXX6KxGANbaDQGIT0RERHKhk1je+dLYaej+O/q06S1xbef2folIRERExI/y3Nix1rYLZCAiIiJydnRRQe98vRFoN+ASoPTJadbasf4OSkRERMRffBl6Ph0IBdoBrwM9gTUBiktERETySEPPvfNlNFZLa20vIMl9ocErgPMCE5aIiIiIf/hyGivN/feIMSYGSARq+D8kERER8YXyOt750tj5yhgTBrwIbMC1bV8PSFQiIiIifuJLY2ectfYY8Jkx5itcnZSPBiYsERERySuNxvLOlz47P558Yq09Zq09mHmaiIiISGGUa2bHGBMFVAVCjDGXAydvJF8e1+gsERERKUAajeVdXk5jdQbuBqoB4zNNTwEeC0BMIiIiIn6Ta2PHWvsO8I4xpoe19rN8iElERER8oLyOd3k5jTU0p+cnWWvHnz7tdHPj/r33CL02unFBh1CgTth/d7e5bUfjCjqEAnVzo8EFHUKBmbVhUkGHUKDSRvYr6BBEPPJyGqtcwKMQERGRs/bv/lmZu7ycxhqTH4GIiIiIBEKeh54bYy40xiw2xmxxv77MGPNE4EITEREROXe+XGdnJjASOAFgrd0M/DcQQYmIiEje2Xz+V9T40tgJtdaefpfzdH8GIyIiIuJvvtwuIsEYUwv3CDdjTE8gNiBRiYiISJ6pg7J3vjR2BgIzgIuMMf8Au4DbAxKViIiIiJ/4dJ0dYB6wFNfpr1SgB1mvqiwiIiL5TLeL8M6X6+zUBZoCX+C6P9adwPIAxSUiIiLiF3m+zo4xZiHQyFqb4n79JPBpQKMTERGRXCmv450vo7HOB45nen0cqO7XaERERET8zJcOyu8Ba4wxc3A1Im8A3glIVCIiIpJn6rPjXZ4bO9baZ4wx84H/uCfdY63dGJiwRERERPzDl8wO1toNwL/3FuYiIiKFkK6z450vfXZEREREihyfMjsiIiJS+BTF+1XlJ2V2REREpFhTZkdERKSIU58d75TZERERkWJNmR0REZEiTn12vFNmR0RERIo1NXZERESkWNNpLBERkSJOHZS9U2ZHREREijVldkRERIo4p1UHZW+U2REREZFiTZkdERGRIk55He+U2REREZFiTZkdERGRIs6p3I5XyuyIiIhIsabMjoiISBGn20V4p8yOiIiIYfOrUwAAIABJREFUFGvK7IiIiBRxuoKyd8rsiIiISLFWLDI7E8aPpcvV7TmSlkbv3kPY+NOWLPNDQkrzyUczqFnrAjIyMvj660U89vhznvk9e3Zn1P8NxVrL5s1bubPXA/ldBa8ub9uIe0ffhyMoiG8/XsicaZ9lmR9cMpjB44dQs35tUpIO8fIDL7J/TzwANw7oSYdbOuLMyOCNJ2fy0/KNAExfMZO01DScGU4yMjJ4tPvDnvV1vbsbXXp1IyPDyfol63jvubfzra5n0mdMHxq3a8KxtGNMengiO7fszFamVv1aPPTyEEqWLsn6peuYMXoGAGUrlOXRqcOpUq0K+/bs44UBz5N6MJXQcqE8PGkYlWIqERTs4H+vzWHxp99SqWolHpvxOA6Hg+ASQcx9+yu+eX9+flc5Tx5/5mHaXNWKo2lHGfngGLb+vC1bmYdG9ue6m7tRPqwcjWu09Uy/5a4buf2em8hwOjmSeoRRDz/Lzt935Wf4ubq8bSN6P3k/jiAH3368iP9NnZ1lfnDJYAZPGEqt+rVISUrhpYHjTh37A3ty1S0dcWY4eX30DH5avpGI6EgGTxhCeKVwnNay6MNv+OrNuQDcMuRWOt7amUOJBwF4f9y7bFi6Pn8r7CdPPDue5SvXUDE8jM/fn17Q4fhd0CVNKP3f/hiHg+Pff8Pxbz7JMr9Ey46U6nk/NjkRgONLvuDEim8AKNWjN8H1mwNw7KsPSF/3Xf4GHyAajeVdkW/sdLm6PXVq1+Cieq1p3qwRr055jpatu2crN37CdJZ99wMlSpRg0YJPuLpzO75ZsJTatWsw/NEHaNP2epKTD1KpUkQB1OLMHA4H9z/VlzG3jyIxLpFxX77M2m/XsGf7bk+Zq27pyOGDhxnYti+tuv+HXiPu4uUHXqRanfNo3f0/DO44kIpVInjyg7E8cGV/nE5XwnPUfx8nJSkly/936RX1adqxOUOuHkT68XQqRFTI1/rmpHG7JsRUj6Fvmz7Uvbwu/Z8ZwLDrHs5WbsAzA5kyYgrbNvzGk+88SeMrG7N+2Xp6DryJzSs3MXvqbHoO6EnPATfxznNv061XN/7e/jdP3TuW8hXLM33Za3z3+TKS4pN45IZhpB9Pp3RoaaYsepU1i1ZzYN+BAqj9mbXp0JILap5P5+Y30qDxpYweN4JbutyTrdzShd/zwRuz+Gb1/7JM/+qzBXzyjmtau85tGDF2CPf/d1C+xJ4XDoeDPk/348nb/4/E2ETGzR3PmkWrTzv2O5F68DAD2vSldff/0Gvk3bw8cJz72G/DoKtcx/6YD59iYNt+ODMyePvpN/ljy05Klwnh5a8n8NP3P3nWOff1L/hixpyCqrLfXN+1I7f1uJbHnnqpoEPxP+Mg5LYHSJ0wApuUQJnHJ5O+6UecsX9nKZa+9juOfvRqlmnB9ZsRdH4dUsf2g+CSlHnkJdK3rIWjR/KzBlIAivxprO7dO/PeB65fe6vXbKBCWAWioipnKZOWdpRl3/0AwIkTJ9iw8WeqVo0G4L7etzFt2tskJ7t+ze3fn5iP0eeudsM6xP4Zy77d+0g/kc6Kud/TrGPzLGWadmzO0s+WAPDjvJXUb9UAgGYdm7Ni7vekH08nfvc+Yv+MpXbDOl7/v853dGHO1M9IP54OwEH3r9yC1KJTc5a467dt4zbKlC9DeOXwLGXCK4cTWjaEbRt+A2DJZ0to0bkFAM07Nmfx7MUALJ69mBadXNMtEFomBICQMiGkJKeQkZ5B+ol0T/1LlCyBw2ECXsez0aFLW76Y9TUAm9ZvoXyFclSqnL2xvmn9FvbHZz+uUw+nep6HhpbGFrJ769Q5eez/ffLYX06zTlmP/WadmrPUvW9/mLeSy04e+52as2Lu8izHfp2GdUiKT+IPd1bwaGoae3bsJiKqcP3A8YcmDetToXy5gg4jIIJq1MW5fy82IQ4y0jmx9juCG7bM07KO6AtI/30zOJ1w/CgZe/4g+NImAY44f9h8/lfU5NrYMcZc5P7bKIfH5caYCwIf5plVjYliz+69ntf/7ImlakzUGctXqFCea7p1ZMnSFQDUqVOTCy+syfJln7Py+7l07nRloEP2SURUBImxCZ7XibEJVDztwzkiKoLEva4yzgwnR1JSKRdejopRESRkXjYu0fPBboHR74/lxa/G0/HWzp4yMTViuLhZPZ7//EWe+uRZal9WO4C1y5sIL/XIUibu1Bd6QqYyYZFhJMUnAZAUn0RYZBgAX7/9FdVqn8c7695l8sIpzHxyhucLPzI6klcWTOat1W8xe9pnhS6rA1AlqhKxe/d5XsftjadKdGUvS2R32703sXDNHIaNGsQzjxWuLEDFqAgS9mY+9hOJqJLDfs927Jcnosqp94Rr2ezvm0rVKlPjklr8vvHUqb+ud3VjwoJXeODFQZSpUCYQ1ZJzZMIicR7Y73ltk/bjCMveYA1u1Joyo6cT0u//MOGVANyNm6ZQshSmbHmC6zbA4Z4nxVteTmMNBfoAL59hfoQxZpO19s7ME40xfdzLYYIq4HAE5oPDmOy/us/0CzUoKIgP3nuVKa++ya5drpRncFAwtWvXoP1VPalWLZplS+bQ4PL2HDx4KCDx+i6HrMLp9ctxG+Q42bNtHrtxOEnxB6gQUYHR74/ln5172LrmF4KCgyhboSwjrn+E2g3q8PDU4fRvfb8/KnIOct/HJscy3td6edtG7Nr6B4//9zGiL4jmqQ+e4sE1D5J2OI2E2AQGdX6QilUq8vjMJ/hh3kqSE5LPqRZ+58OxfyYfvvkpH775Kdfc2Jn+Q+9lxINj/BXdOcvTezvng/wMy556Xjq0NMNfG8mbY2aSdjgNgG/em8+nkz7BWsttw+7gnid6M+WRV86pDhIAOSZasx4X6ZtWcWLNMkg/QYm23Qi59xGOvPwoGVvXk179QsqMmIhNOUjGH7+CMyM/opYClmtmx1rbx/233RkelwFVclhuhrW2ibW2ib8bOv373cW6tQtZt3Yhe2PjqHZejGde1WrR7I3dl+Ny06eNY/uOXbwy+XXPtD3/xPLllwtJT0/nzz938/vvO6lTu4Zf4z0XiXEJRERHel5HREdmyzIkxiYQEeMq4whyEFquDIeTU0iMTSQy87JREZ5lk+Jdfw8mHmT1glXUcZ/eSoxNZNU3PwKwY9N2rNNJ+YrlA1fBM+jaqxuT5r/CpPmvcCD+wBnrcVJCXAKRmX65R0ZFcGCfK9OTnJDsOe0VXjnc02i56qar+MFd19i/YonbvY9qtc7Lst4D+w7w9+9/Ua/ZJf6v5Fm47d6bmLPkA+Ys+YD4uASiY0699aJiKhMft9/L0mf29ZyFdOhypZ+i9I/E2AQiYzIf+xEciM9+7EeeduynJKeQEHfqPeFaNpIk9/EQFBzEo6+NZPmcZZ5jHeBgQjJOpxNrLQs/WkCdhhcGsnpylmxSAo6Kp7IxJrwSzuSsx4VNTYH0EwCcWD6foPNPnb4/Pu8jUsf258iEEQA49/2TD1EHnjOfH7kxxlxtjNlmjNlhjBmRw/xSxphP3PNXG2OqZ5o30j19mzGm8+nLno28nMZq7/57Yw6PG4wxbYEu/ggmr6ZNf4cmTTvRpGknvvxyAXfe3hOA5s0acejgIeLi4rMtM3bMo1SoUI6hD4/OMv3LL7/hyitd53sjIsKpU6cmf+z6O9vyBWXHpu1E14ih8nlVCC4RTOvu/2HtotVZyqz9dg3terQH4Iqurfj5h82u6YtW07r7fwguGUzl86oQXSOGHT9tp1RIKUq7+6qUCilFgzYN+Xubq86rF66ifsvLAIiuEUNwiWAOHcj/LNe8d79mcJdBDO4yiFULfqS9u351L6/LkZQjntNSJyXFJ5GWmkbdy+sC0L5He1YtdG2nNYtW06FnBwA69OzAavf22793Pw3cfTzCIsOoVqsa+/6OIyIqgpKlSgJQpkIZLm5Sj3927gl8pfPgwzc/5Yb2t3ND+9tZPH8Z193cDYAGjS8l5dDhHPvmnMkFNU417K7s2Jq//ig8xz3A9mzHfhvWLlqTpczaRatp5963LbMc+2to3b1NlmN/+0/bARj44iD27NjNl69/kWVdmfuBteh8BX9t+yuQ1ZOzlPHnNhyVq2IioyAomBJN25K+6ccsZUyFip7nwQ2vICPOfWwbB6aMqy+To2oNHNVqkr61aI64K8yMMUHAq7jaBvWAW40x9U4r1htIstbWBiYAL7iXrQf8F7gEuBqY6l7fOcnLaay2wBIg+xAnlwjgcaDTuQZzNubNX8zVV7dn268rOZKWxn33DfXMW7d2IU2adqJq1WgeGzmYX3/bzto1CwCYOvUt3nzrIxYsXEbHq9qyedNSMjIyGD7yKQ4cSDrTf5fvnBlOXh/1GqPefRJHkIPFs75l9/bd/HfobezcvIO1365h8SeLGDxhKK9+9xqHk1MY/8CLAOzevpuVX6/glW9fJSM9g5n/Nx2n00lYZBjDZzwGgCM4iO+/+I6N320AYMmsbxn44iAmLpxM+ol0Xnl4UoHV/aR1S9bRpF0TZnw/0zX0fNhEz7xJ819hcBfXCKKpj0/NNPR8PeuXrgNg9tTZDJ82go63dGL/3v0838912YFPXvmYh15+iMkLp2CM4e3n3uJQ0iEa/qch9z7R25UZNzBnxv8K5Rffd9+upM1VrVi4Zg5HjxzlscFjPfPmLPmAG9rfDsCwUQ9yzY2dCQkpzbKfvmL2B18w5cWZ3N77Zq5o04z09HQOJR8qVKewwHXsz/y/6Yx+b4zr2P/kW3b//je3Dr2dHT9vZ+2iNXz7ySIemjiUqctf43DyYV5+YBwAu3//mx++WsHkxVNdx/4TrmP/4qb1aNejPX/+uovx813H9skh5r0eu4ca9WpgrSV+TzzTR77qLbxC7ZHRz7N242aSkw/R4fo7GND7Tnp098sP5ILndHL0wymEPvQsxjg4vnIBzr1/UeraXmT89Tvpm1ZRsv31BDdsARkZ2NQUjr7l7o8WFEToo+MBsEePkPbG867OysVAIRtg0AzYYa39A8AY8zFwHbA1U5nrgCfdz2cDU4zr/PN1wMfW2mPALmPMDvf6srZofWT8sYGMMW9Ya3ufaX5wyaqFai/kp2ujGxd0CAXqhC0eHyRna/vRnE+p/ltcXPrMgwWKu1kbCv6HQkFKG9mvoEMocOVnLsy3oZw3nN89X79nP9/9VV/c/XLdZlhrZwAYY3oCV1tr73O/vhNobq31XMTOGLPFXWaP+/VOoDmuBtAqa+377ulvAPOttVkvsuWjXDM7xpih3uZba8d7a+iIiIhIYOX3RQXdDZsZZ5idUyPv9ADPVCYvy/osL6exiufFGkRERCQQ9gCZR3tUA/aeocweY0wwUAE4kMdlfZZrY8dam6cT+caYkdba53IvKSIiIv5UyDoMrAXqGGNqAP/g6nB822llvgTuwtUXpyewxFprjTFfAh8aY8YDMUAdYA3nyJ9XUL7Jj+sSERGRIshamw48ACwAfgVmWWt/McaMNcZc6y72Bq7r9O3AdT2/Ee5lfwFm4erM/A0w0Fp7zhdD8ue9sQrnNfVFRESKucJ2Cwdr7Txg3mnTRmV6fpQzJEmstc8Az/gzHn9mdgrXlhYRERFBmR0REZEiL79HYxU1ecrsGGOCjDFDcin2qR/iEREREfGrPDV23J2DrsulzLN+iUhERER8Yq3N10dR48tprJXGmCnAJ0DqyYnW2g1+j0pERETET3xp7LR0/x2baZoF2vsvHBEREfFVIbvOTqGT58aOtbZdIAMRERERCQSfRmMZY7rhuu166ZPTrLVjz7yEiIiISMHKc2PHGDMdCAXaAa/jurzzOV/CWURERM5NYbuoYGHjy0UFW1prewFJ7vtlXUHWm3WJiIiIFDq+nMZKc/89YoyJARKBGv4PSURERHyhiwp650tj5ytjTBjwIrAB10is1wMSlYiIiIif+NLYGWetPQZ8Zoz5Clcn5aOBCUtERETyqihe6C8/+dJn58eTT6y1x6y1BzNPExERESmMcs3sGGOigKpAiDHmck7d8LM8rtFZIiIiUoDUZ8e7vJzG6gzcDVQDxmeangI8FoCYRERERPwm18aOtfYd4B1jTA9r7Wf5EJOIiIj4QNfZ8S4vp7GG5vT8JGvt+NOniYiIiBQWeTmNVS7gUYiIiMhZc2o0lld5OY01Jj8CEREREQmEPA89N8ZcaIxZbIzZ4n59mTHmicCFJiIiInlh8/lR1PhynZ2ZwEjgBIC1djPw30AEJSIiIuIvvlxBOdRau8YYk3laup/jERERER/pOjve+ZLZSTDG1MKdwTLG9ARiAxKViIiIiJ/4ktkZCMwALjLG/APsAm4PSFQiIiIifuLTdXaAecBSXBmhVKAHWa+qLCIiIvlMp7G88+U6O3WBpsAXuO6PdSewPEBxiYiIiPhFnq+zY4xZCDSy1qa4Xz8JfBrQ6ERERCRXVhcV9MqXDsrnA8czvT4OVPdrNCIiIiJ+5ksH5feANcaYObhGZN0AvJOXBZ+IvtL3yIqJWHM890LF2F6bVtAhFKi2odULOoQCFe88WtAhFJi0kf0KOoQCFfLc9IIO4V9FfXa8y3Njx1r7jDFmPvAf96R7rLUbAxOWiIiIiH/4ktnBWrsB2BCgWEREROQsWGV2vPKlz46IiIhIkeNTZkdEREQKH43G8k6ZHRERESnWlNkREREp4jQayztldkRERKRYU2ZHRESkiFOfHe+U2REREZFiTZkdERGRIk59drxTZkdERESKNTV2REREpFjTaSwREZEiTreL8E6ZHRERESnWlNkREREp4pwaeu6VMjsiIiJSrCmzIyIiUsSpz453yuyIiIhIsabMjoiISBGnPjveKbMjIiIixZoyOyIiIkWc+ux4p8yOiIiIFGvK7IiIiBRx6rPjnTI7IiIiUqwpsyMiIlLEqc+Od8rsiIiISLGmzI6IiEgRpz473imzIyIiIsWaGjsiIiJSrOk0loiISBGnDsreKbMjIiIixZoyOyIiIkWctc6CDqFQU2ZHREREijVldkRERIo4p/rseFWkGzu1217G1aPvxBHkYMPHy1gxbW6W+Rc0u4irR99BlYvOZ/aDU9g6b41n3qg/3iP+t90AHNybwEf3jc/X2M/WJW0bcvOoe3AEOVjxyWIWTPs8y/zgksHcM/5Bzr+0JqnJKcx8YAKJe/bT7LrWdOp7nadc1YvO55lrhrNn659cN+xWWtzYhtAKZRl8yZ35XaU86TOmD43bNeFY2jEmPTyRnVt2ZitTq34tHnp5CCVLl2T90nXMGD0DgLIVyvLo1OFUqVaFfXv28cKA50k9mArApS3qc//o+wkuEcShA4cYefNIz/ocDgfjv5rAgX2JjL1nbP5U1AeBOBYKi95j+tC4XWOOpR1j8sOT+COH/V2zfi0GvfyQe3+v541M+/vhqY9SuVoV4vfs46UBL3j2d07rrV6vBv2eGUBIuVCcGRnMnjKLlXNXANDlrm50730t0dVj6NXgdlKSDuXfRvAi6JImlP5vf4zDwfHvv+H4N59kmV+iZUdK9bwfm5wIwPElX3BixTcAlOrRm+D6zQE49tUHpK/7Ln+DzwdPPDue5SvXUDE8jM/fn17Q4UghUGRPYxmHoetTd/PBXeN49apHufTaK6hUp2qWMgf3JvD5w6/x8xc/ZFs+/ehxpnd9jOldHysyDR3jcHDr2N5MvvsZnuw4hKbXtiK6drUsZVrd3J7Ug4f5vysf5Ns3vuLGEXcAsOaLFTzd9RGe7voIbw6ZTOKe/Z4vt82L1/HcdSNP/+8KjcbtmhBTPYa+bfrw6ogp9H9mQI7lBjwzkCkjptC3TR9iqsfQ+MrGAPQceBObV26ib9s+bF65iZ4DbgKgTPky9H+mP0/3foqBVw3k+f7PZ1lf93uvZc+O3YGt3FkK1LFQGDRq15iY6jEMaNOXaSNepe8z/XMs1++ZAUwbMYUBbfoSUz2GRu79fePAnvy8cjMD2/bl55WbuXFAT6/rPZ52jElDxjP4qoGM7fUk946+n9DyZQD4bd2vjL7t/4jfvS8fap5HxkHIbQ9wZNLjHB51PyWaXYkj+vxsxdLXfkfq2P6kju3vaegE129G0Pl1SB3bj9RnB1Gq801QOjS/axBw13ftyPTxTxd0GPnKWpuvj6KmyDZ2qjasxYE/95G0ez8ZJzLYMncVdTs2zlImeU8C+37bjXUWvR2TkxoNaxP/VxwJu+PJOJHOurkradCpSZYyDTo1ZdVnrl9qG+at4qKWl2ZbT7NrW7H2y5We17s2bufQ/uTABn8OWnRqzpLPlgCwbeM2ypQvQ3jl8CxlwiuHE1o2hG0bfgNgyWdLaNG5BQDNOzZn8ezFACyevZgWnVzT217Xlh/n/8D+vfsBOJh40LO+iKgImnZoysKPFwa2cmcpUMdCYdCsUwuWuvf37172d0jZULZt2AbA0s+W0My9v5t1bM5S9/5eOnsxzd37+0zr3btrL7F/xgKQtO8ABxMOUqFieQB2/fIH+/fEB7jGvgmqURfn/r3YhDjISOfE2u8IbtgyT8s6oi8g/ffN4HTC8aNk7PmD4Eub5L5gEdOkYX0qlC9X0GFIIZLnxo4x5l5jTJ1ABuOL8lEVORSb6Hl9KPYA5aPCvSyRVXCpEvSZ+xT3zRnDRZ0a575AIRBWpSJJe0/VOSn2AGFVIrKVObA3AQBnhpO0lCOUCc/6pm9yTUvWfrki8AH7SURUBAmxCZ7XiXGJRERFZC8Td2rbJGQqExYZRlJ8EgBJ8UmERYYBEFOzKmUrlOXZT55jwtcTadejvWf5+5/sw1vPvomzkDaUi/OxEBEVQeJp+7viafu7YlQEiXGZyySccX9XcO/vvKy3ToM6lCgRTNxfcf6tlB+ZsEicB/Z7Xtuk/TjCIrKVC27UmjKjpxPS7/8w4ZUA3I2bplCyFKZseYLrNsDhnidFmxObr4+ixpc+O9WBO4wxFwDrge+B7621P+VU2BjTB+gDcE3FZjQuW/scQ82dL6m1CVcMIiU+mfDzKnHXR4+z77fdJP1duH7BZWNymHZanY3JoVCmMtUb1uZ42nH2/l44T8/kLHudTt/XJscy3tcaFBRErfq1eeLWxylVuhQvfv4S2zb8RtWaVTmYkMzOn3dyaYv65xR5wPzLjoW87W/fP4AzLxNeOZzBE4fyytCJhTtNn9O+P+3LJ33TKk6sWQbpJyjRthsh9z7CkZcfJWPretKrX0iZEROxKQfJ+ONXcGbkR9QiBSrPjR1r7SgAY0wIcD/wCDARCDpD+RnADIAnL7jd758ch+IOUD761K+Z8tEVSdmX91MxKfGuskm79/Pnql+JvrR6oW/sJMcdIDzmVJ3DoyuSHH8gS5mkuEQqxkSSHHcAR5CDkHKhpCYf9sxv2r1Vofsln5OuvbrR+dbOAGzfvJ3I6EjPvIioCA7sy1rvhLgEIjP9So+MiuDAPlfmIzkhmfDK4STFJxFeOZzkBNe+T4xL4FDSIY6lHeNY2jG2rN5CjXo1qHVpbZp1bE7jdk0oWaokoeVCGDrxYcY/9HKgq51nxe1Y6NKrKx3d+3vH5u1EnLa/k07b365MTuYykZ5j4vT9fdCzvxPPuN6QsiE8/tZoPnzpfX7fuC0wlfQTm5SAo+KpbIwJr4QzOev2sakpnucnls+n9I33eV4fn/cRx+d9BEDIfSNw7vsnwBFLfijUDfRCwJfTWE8YY+YDC4HawDCgmvelAmfvpj+IqBFF2HmVCCoRxKXdW7Bt0fo8LVu6fChBJV3tvNDwspzX5EL2by/8b/g/N+2gcvVoIqpVJqhEME26t2LTonVZymxetI4WPdoC0KhrC377YYtnnjGGxl2vYO3cwtVHIyfz3v2awV0GMbjLIFYt+JH27lNMdS+vy5GUI57TFCclxSeRlppG3cvrAtC+R3tWLVwNwJpFq+nQswMAHXp2YPUi1/RVC1dxSbNLcAQ5KFW6FHUvr8vu7Xt494V3uKf53dzXqjfjHhjH5h82F6qGDhS/Y2H+u/MY2mUwQ7sMZvWCVZ5Tihfmsr8vdO/vdj3as2bhKgDWLlpDO/f+btezA2vc+3vtotU5rje4RDAjZj7Osv8t4YevC8f28Cbjz204KlfFREZBUDAlmrYlfdOPWcqYChU9z4MbXkFG3N/uGQ5MGdepTEfVGjiq1SR9a94+N0WKMl9OY90IpANfA98Bq6y1RwMSVR44M5zMG/U2d747HBPkYOOs79i//R/aDe3B3s272PbtBmIuq8l/ZwyhdIVQLrzqcq4c0oOpHYdTqU5Vrnm2N9bpxDgcrJj2ZZFo7DgznHw86g0Gv/s4jiAHK2ctJXb7HroPuYW/ft7J5m/XsWLWEu4d/yBPLZtMavJhXn9wgmf5Os0vJikukYTdWTNYN464g2bXtaZkSEme/3E6Kz5ZzFcTP83v6p3RuiXraNKuCTO+n+kaej5somfepPmvMLjLIACmPj4109Dz9axf6vrynz11NsOnjaDjLZ3Yv3c/z/d7DoA9O/awftl6Ji+cgnVaFn68gL9//yv/K3gWAnUsFAbrl6yjcbsmTPt+hmuI+LBJnnnj509iaJfBALz2+FTP0PMNS9ezYanrS/t/U2czbNpwOtzSkYS9+3mx3/Ne19vqmtbUa3YJ5cLK0d7dSHrl4Yn8uXUX3e7pzvX9biS8UjgTF77C+iXrmTp8cn5ujuycTo5+OIXQh57FGAfHVy7AufcvSl3bi4y/fid90ypKtr+e4IYtICMDm5rC0bdeci0bFEToo67Rp/boEdLeeN7VWbmYeWT086zduJnk5EN0uP4OBvS+kx7dOxd0WAHlVGbHK+NL6ssYUw5o7X7cDOyz1rbObblAnMYqKmLN8YIOoUDtdaYVdAgFKsYRUtAhFKh4Z4H9Hipw73Q+VtAhFKiQ53R9mxKRNXPsYRUI0WH18vV7NjZ5a77VzR+EkYKzAAAL/ElEQVTynNkxxlwK/AdoCzQBduPqpCwiIiIFSHc9986X01gvAMuBV4C11toTgQlJRERExH98aeyMB3601h4JVDAiIiIi/uZLY+cuYJoxJhH3NXaAFdbaJO+LiYiISCBp6Ll3vlxnpxeAMSYG6Am8CsT4sg4RERGR/OZLB+U7cHVQrg8kAFNQB2UREZECVxRv4ZCffMnKTAR2AtOBpdbaPwMSkYiIiIgf+XIaK9IYcwnQBnjGfVPQbdbaOwMWnYiIiORKfXa88+V2EeWB84ELcN0UtAKn331OREREpJDx5TTWCvfje2Cytbbw319BRETkX0C3i/Auz5kdoDcQDTwKzDfGbDbGbA5MWCIiIiL+4Utm531cdzrfAhS/O8eJiIgUUeqz450vjZ391tq5AYtEREREJAB8aeyMNsa8DiwGPLfztdb+z+9RiYiISJ7pOjve+dLYuQe4CCjBqdNYFlBjR0RERAotXxo7Day19QMWiYiIiJwV9dnxzpfRWKuMMfUCFomIiIhIAPiS2WkN3GWM2YWrz44BrLX2soBEJiIiInmi6+x450tj5+qARSEiIiISIL7cG+uvQAYiIiIiEgi+ZHZERESkELIaeu6VLx2URURERIocZXZERESKOHVQ9u7/27v7GLmqOozj34fwLm0qAaEgplgUwpuLlKJIedGiCWoFbKlApMUgIUbgD4qghUJAFKIgGuSlECwiIJbYiEA0UCld2vJSoFLe2kpbJQFBUEBaqEof/zhndm+XmZ3d2Z3ZnZnfZzOZM/fce885M2funvu7Z2YishNCCCGElhaRnRBCCKHJxZcK9i4iOyGEEEJoaTHYCSGEEJqcG/w3EJK2l3SfpFX5/oNl1umQtETSM5KekjS1kDdH0hpJy/Kto1qZMdgJIYQQQiOdB8y3/TFgfn7c03rgZNv7kL7U+CpJowr559juyLdl1QqMOTshhBBCk2uyOTtfAY7I6ZuBBcC5xRVsryykX5L0KrAj8EYtBUZkJ4QQQgj9Iuk0SUsLt9P6sflOtl8GyPcfqlLWeGBL4IXC4kvz5a2fSNqqWoER2QkhhBCaXKMjO7ZnA7Mr5Uu6H9i5TNbM/pQjaTRwCzDN9sa8+LvA30kDoNmkqNDFve0nBjshhBBCGFS2J1bKk/SKpNG2X86DmVcrrDcSuAc43/bDhX2/nJMbJP0CmFGtPnEZK4QQQmhybvBtgO4CpuX0NOB3PVeQtCUwD/il7bk98kbnewHHAE9XKzAGOyGEEEJopMuAoyStAo7Kj5E0TtKNeZ3jgcOA6WU+Yn6rpOXAcmAH4PvVClSTzeCuiaTT8vXFthTtb9/2t3PbIdof7W/v9odu7RLZ6c8s8VYU7W9f7dx2iPZH+0OgfQY7IYQQQmhTMdgJIYQQQktrl8FOu1+zjfa3r3ZuO0T7o/0h0CYTlEMIIYTQvtolshNCCCGENhWDnTIkHSNp76GuRwghhBAGLgY75R0DxGAnhBBCaAFNM9iR9B1JZ+b0TyT9Kac/J2m9pCvz47Mkrc7psZIe6mWfayVdLunRfNtD0iHAJOBH+RsbxzagbRdJqvjbHsV8SdMl7TJI5c6RNLnM8umSrq6wzdv5fhdJd+b0OEk/62OZDWtrb2VJWtzLdkdIurtC3tsVlnc9l5JuLEUGJd0raVT/a1+2jDGS3ve16Lkf7zDAfXdIOnog+xhA2c3QJ7qe+2J/lzRJ0nm11qfWuvbMH+TjQnG/F0uamNNd/TqEZtM0gx1gITAhp8cB20naAjgUuLyQNwF4XdKuOa+zyn7fsj0euBq4yvZi0u92nGO7w/YLvW/ecNOBfh3UJA36D77afsn25JxeavvMwS6DGtraV7YPqcd+875Ptf1sTh9t+416lTWIOoAhGez003SGuE8U+7vtu2xfVo/69NN06nBcsD3L9v053dWvh0oedD6fB15PS7pV0kRJiyStkjRe0nJJo5S8LunkvO0ted17Je2flz0paVZOXyLp1KFsX6ifZhrsPA4cKGkEsAFYQhr0TADmkgY/I4DdgNtIv6kxgeqDndsL95+uQ73LkjRT0gpJ9wN75mVjJf1B0uOSOiXt1WObyaQ235qjTttImiXpsfzGny1Jed0Fkn4g6UHgrF6qMjGXtVLSlwrLd8t1WSHpwjL1L57pVoyENLCtV0lanPPGF3a1d85frRwZzNuUjdAUjJQ0T9Kzkq6T1PVekXSFpCckzZe0Y5n2LpA0LqcHHHXpYXNJN0t6StKdkrbNy89RIUJZaWOlCNR1xddc6Qf3Lgam5ud66iDWt1I9mrFPlNbr6u/qJQpai2F0XCjtuxix7OrXQ2wP4KfA/sBewImkE9sZwPeARcBngH2A1XSfCH8KeJh84qz0i9r/y+tC306OQ5NqmsGO7f8Ca4FTgMWkTnkkMBZ4jjT4OQVYkfMmkAYvi6rtukK6biQdCHwNOAA4DjgoZ80GzrB9IOmNe01xO9t3AkuBk3LU6R3gatsH2d4X2AYoDlhG2T7c9hW9VGcMcDjwReA6SVvn5eOBk0hn/FNqPcg1sK0fyGfm3wJuKizfC/hCbs+FStHAvhgPnA3sR+pjx5XKAZ6w/UngQeB9A8E62xOYbXt/4C1Se6FHhLLKPsZQeM1Jx4FZwB35ub6jHhUvaeI+UVfD7LgwnK2xvdz2RuAZYL7Td6gsJ/XtTtLJ7mHAtcB+SpH+f9p+u5B/KHAP6UR5W2CM7RUNb01oiKYZ7GQLSW/2haQOezqwLHf0Yt6TpIHQBttvVtnn1ML9kpz+NzBicKu+iQnAPNvrbb9Fumy2NXAIMFfSMuB6YHQf9nWkpEeUfgH2s6SzmZK+/NP6je2NtleRzoJKZ4332X49Hzh/Szow1KJRbb0dwPZCUlSmNE/mHtsbbL8GvArs1Md6P2p7te338r5L7d9I9/P6K2p/Xmr1ou3SAL5Yfn8ilJVe80Zp1j5Rb8PpuDCcbSikNxYebwQ2p3vKwwRgAfAPYDLdUZvH6L4qUPp/8U3S1YPQogZ9LkeddQIzgSW210l6l+4O3Em6hLXQ9nuSXgSe78M+t5L0CGngd0Je9mvghhzinlyneTs9o0ibAW/Y7ii3cjk5CnMNMM72i5IuIh0cS9bVUA9XWV6LRrS1Un2LB8b36Huf72v7G/2tnH15varVaTBf21o1Y59ohOFyXGhauc07AFvaXq30IZUZwLdz/n/y/4fjgUuAHYEf51toUU0V2bE93/YWttflxx+3fWVOv2Bbtlfmx5/v46TZn9s+OId8/5K3XWR7b9sH1GmgsxA4Nl9bHwF8GVgPrJE0BUDJJ8psW4w6lQ5gr0najnT20l9TJG2m9Kmzj5IuAwIcJWl7SduQPopf7XJgJY1q69S8r0OBN/sQ0atmvKTdlebqTAVKn+rbrFD2iYXljfIRSaXIzQmF8stFKCsp95rXO5pZ1Kx9ot6G03Gh2T0CrMzpTmBXNn2vdgKv2F6f0x8m5uu0tOF0RtM2bD8h6Q5gGfBXut9kJwHXSjof2IIUYfpzj83nkObWvEO6XHED6Vr1WlJ4tr9WkOae7AScbvvdPJfxIeAW0mTA22wvLdeUCunuhY1r67+UPjo8EvhG703ukyXAZaQ5OwuBeXn5OmAfSY8Db9I9yOipXnPBngOmSboeWEWak3AG5SOUlZR7zR8AzsuXSn5Yz3k7TdwnNmlGhXTtOxxex4VNqlYh3XC21wL7Fh5PL5dn++uF5YvpcWJv+wLggpx+CVD9ah2Gg7b4bSxJ84Ddeyw+1/Yfh6I+rSBPprzS9uGSvgpMsj1tiOqyAJhRYUDWcHmexCTgb6Q5ITvnCfZDTtIc4O48qbVl1bNPFPu7pLOBkbYbPVG9IST9nvQ+f6DUr22vGep6hdBfbRHZsX3sUNehleRPZt1GigRMAi5l8M+cm5Kk+4DlttdIeh64cbgMdMLAFfu7pNNJ329zXK8bNSlJNwHbAg8V+/UQVyuEmrRFZKfdSZoJTOmxeK7tS4eiPsOFpP1Il+qKNtg+eCjqM5jiNa9NK/eJnqKPhHYSg50QQgghtLSm+jRWCCGEEEJ/xWAnhBBCCC0tBjshhBBCaGkx2AkhhBBCS/s/fOaknwDr/JoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (10,10))\n",
    "sns.heatmap(pd.DataFrame(B[:,0:-1],columns = B_header).corr(), annot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split the dataset in train and validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best thing to do is to create three different dataset. The train one, the validation one and the test one. The validation dataset is need for the correct tuning of the hyperparameters, while the test one is for the last step, the prediction. Indeed,  the test dataset is a dataset used to provide an unbiased evaluation of a final model fit on the training dataset. If the data in the test dataset has never been used in training (for example in cross-validation), the test dataset is also called a holdout dataset. \n",
    "Sklearn doesn't provide a method for the split in three different dataset, but we can write a small function for this purpose."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn\n",
    "\n",
    "def data_split(examples, labels, train_frac, random_state=None):\n",
    "    ''' https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html\n",
    "    param data:       Data to be split\n",
    "    param train_frac: Ratio of train set to whole dataset\n",
    "\n",
    "    Randomly split dataset, based on these ratios:\n",
    "        'train': train_frac\n",
    "        'valid': (1-train_frac) / 2\n",
    "        'test':  (1-train_frac) / 2\n",
    "\n",
    "    Eg: passing train_frac=0.8 gives a 80% / 10% / 10% split\n",
    "    '''\n",
    "\n",
    "    assert train_frac >= 0 and train_frac <= 1, \"Invalid training set fraction\"\n",
    "\n",
    "    X_train, X_tmp, Y_train, Y_tmp = sklearn.model_selection.train_test_split(\n",
    "                                        examples, labels, train_size=train_frac, random_state=random_state)\n",
    "\n",
    "    X_val, X_test, Y_val, Y_test   = sklearn.model_selection.train_test_split(\n",
    "                                        X_tmp, Y_tmp, train_size=0.5, random_state=random_state)\n",
    "\n",
    "    return X_train, X_val, X_test,  Y_train, Y_val, Y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wahid/Programs/anaconda3/lib/python3.7/site-packages/sklearn/model_selection/_split.py:2179: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "x_train, x_val, x_test, y_train, y_val, y_test = data_split(train, target, 0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocessing\n",
    "\n",
    "Let's start with the standardization of the train dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler(copy = False, with_mean = True, with_std = True)\n",
    "x_train = scaler.fit_transform(x_train)\n",
    "x_val = scaler.transform(x_val)\n",
    "x_test = scaler.transform(x_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# keras imports\n",
    "from keras.models import Model, Sequential\n",
    "from keras.layers import Dense, Input, Dropout, Flatten\n",
    "from keras.utils import plot_model\n",
    "from keras import backend as K\n",
    "from keras import metrics\n",
    "from keras.callbacks import EarlyStopping, ReduceLROnPlateau, TerminateOnNaN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input_shape:  7\n"
     ]
    }
   ],
   "source": [
    "input_shape = x_train.shape[1]\n",
    "dropoutRate = 0.1\n",
    "print(\"Input_shape: \",(input_shape))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1213 18:33:16.470138 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "W1213 18:33:16.518566 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:133: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#### Using the API ####\n",
    "inputArray = Input(shape=(input_shape,))\n",
    "#\n",
    "x = Dense(100, activation='relu')(inputArray) #Input layer\n",
    "x = Dropout(dropoutRate)(x)\n",
    "#\n",
    "x = Dense(100, activation='relu')(x) #1st hidden layer\n",
    "x = Dropout(dropoutRate)(x)\n",
    "#\n",
    "x = Dense(100, activation='relu')(x)# 2nd hidden layer\n",
    "x = Dropout(dropoutRate)(x)\n",
    "#\n",
    "x = Dense(100, activation='relu')(x)#3rd hidden layer\n",
    "#\n",
    "output = Dense(1, activation='sigmoid')(x) #output layer, Note: binary-classification -> 1 output neuron, sigmoid.\n",
    "####\n",
    "model = Model(inputs=inputArray, outputs=output) #Creating the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1213 18:33:18.508265 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "W1213 18:33:18.617382 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:3376: The name tf.log is deprecated. Please use tf.math.log instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 7)                 0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 100)               800       \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 100)               10100     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 100)               10100     \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 100)               10100     \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 1)                 101       \n",
      "=================================================================\n",
      "Total params: 31,201\n",
      "Trainable params: 31,201\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])#Compiling the model.\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "n_epochs = 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can set some regularization. In this case we will use the <code>EarlyStopping</code> which stops the training when the validation loss function doesn't decrease within a threshold fixed by the user for a fixed number of epochs (patience). The <code>EarlyStopping</code> is important in order to avoid the overtraining. \n",
    "A second type of Regularization is the <code>ReduceLROnPlateu</code> and works as follow: when the validation loss stop decreasing within a threshold the model try to improve the level of training reducing the learning rate. The purpose of that is to get as close as possible to the real minima in order to tune the hyperparameters properly.\n",
    "Then we have the last callback, <code>TerminateOnNaN()</code> that terminates the training when a NaN loss is encountered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1213 18:33:24.660532 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:986: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
      "\n",
      "W1213 18:33:24.911024 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:973: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n",
      "\n",
      "W1213 18:33:25.208192 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:174: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "W1213 18:33:25.209177 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:190: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "W1213 18:33:25.210290 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:199: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 182449 samples, validate on 60816 samples\n",
      "Epoch 1/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1213 18:33:25.780918 140370048280384 module_wrapper.py:139] From /home/wahid/Programs/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:206: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "182449/182449 [==============================] - 12s 66us/step - loss: 0.0677 - acc: 0.9734 - val_loss: 0.0358 - val_acc: 0.9873\n",
      "Epoch 2/50\n",
      "182449/182449 [==============================] - 11s 62us/step - loss: 0.0389 - acc: 0.9855 - val_loss: 0.0340 - val_acc: 0.9876\n",
      "Epoch 3/50\n",
      "182449/182449 [==============================] - 12s 68us/step - loss: 0.0361 - acc: 0.9870 - val_loss: 0.0433 - val_acc: 0.9834\n",
      "Epoch 4/50\n",
      "182449/182449 [==============================] - 11s 60us/step - loss: 0.0351 - acc: 0.9871 - val_loss: 0.0336 - val_acc: 0.9879\n",
      "Epoch 5/50\n",
      "182449/182449 [==============================] - 12s 63us/step - loss: 0.0341 - acc: 0.9878 - val_loss: 0.0314 - val_acc: 0.9891\n",
      "Epoch 6/50\n",
      "182449/182449 [==============================] - 11s 60us/step - loss: 0.0334 - acc: 0.9880 - val_loss: 0.0306 - val_acc: 0.9895\n",
      "Epoch 7/50\n",
      "182449/182449 [==============================] - 10s 55us/step - loss: 0.0329 - acc: 0.9882 - val_loss: 0.0292 - val_acc: 0.9905\n",
      "Epoch 8/50\n",
      "182449/182449 [==============================] - 10s 53us/step - loss: 0.0326 - acc: 0.9884 - val_loss: 0.0307 - val_acc: 0.9890\n",
      "Epoch 9/50\n",
      "182449/182449 [==============================] - 11s 58us/step - loss: 0.0324 - acc: 0.9885 - val_loss: 0.0311 - val_acc: 0.9889\n",
      "\n",
      "Epoch 00009: ReduceLROnPlateau reducing learning rate to 0.00010000000474974513.\n",
      "Epoch 10/50\n",
      "182449/182449 [==============================] - 12s 67us/step - loss: 0.0296 - acc: 0.9898 - val_loss: 0.0273 - val_acc: 0.9909\n",
      "Epoch 11/50\n",
      "182449/182449 [==============================] - 11s 59us/step - loss: 0.0289 - acc: 0.9900 - val_loss: 0.0269 - val_acc: 0.9911\n",
      "Epoch 12/50\n",
      "182449/182449 [==============================] - 13s 72us/step - loss: 0.0284 - acc: 0.9902 - val_loss: 0.0267 - val_acc: 0.9911\n",
      "Epoch 13/50\n",
      "182449/182449 [==============================] - 10s 55us/step - loss: 0.0281 - acc: 0.9903 - val_loss: 0.0267 - val_acc: 0.9909\n",
      "Epoch 14/50\n",
      "182449/182449 [==============================] - 10s 54us/step - loss: 0.0280 - acc: 0.9904 - val_loss: 0.0272 - val_acc: 0.9908\n",
      "\n",
      "Epoch 00014: ReduceLROnPlateau reducing learning rate to 1.0000000474974514e-05.\n",
      "Epoch 15/50\n",
      "182449/182449 [==============================] - 13s 69us/step - loss: 0.0278 - acc: 0.9904 - val_loss: 0.0266 - val_acc: 0.9910\n",
      "Epoch 16/50\n",
      "182449/182449 [==============================] - 12s 65us/step - loss: 0.0275 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 17/50\n",
      "182449/182449 [==============================] - 11s 61us/step - loss: 0.0277 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 18/50\n",
      "182449/182449 [==============================] - 12s 64us/step - loss: 0.0273 - acc: 0.9906 - val_loss: 0.0263 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00018: ReduceLROnPlateau reducing learning rate to 1.0000000656873453e-06.\n",
      "Epoch 19/50\n",
      "182449/182449 [==============================] - 11s 61us/step - loss: 0.0275 - acc: 0.9905 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 20/50\n",
      "182449/182449 [==============================] - 11s 59us/step - loss: 0.0276 - acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00020: ReduceLROnPlateau reducing learning rate to 1.0000001111620805e-07.\n",
      "Epoch 21/50\n",
      "182449/182449 [==============================] - 14s 76us/step - loss: 0.0276 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 22/50\n",
      "182449/182449 [==============================] - 14s 75us/step - loss: 0.0277 - acc: 0.9905 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00022: ReduceLROnPlateau reducing learning rate to 1.000000082740371e-08.\n",
      "Epoch 23/50\n",
      "182449/182449 [==============================] - 14s 79us/step - loss: 0.0274 - acc: 0.9905 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 24/50\n",
      "182449/182449 [==============================] - 13s 73us/step - loss: 0.0275 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00024: ReduceLROnPlateau reducing learning rate to 1.000000082740371e-09.\n",
      "Epoch 25/50\n",
      "182449/182449 [==============================] - 13s 69us/step - loss: 0.0273 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 26/50\n",
      "182449/182449 [==============================] - 11s 62us/step - loss: 0.0275 - acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00026: ReduceLROnPlateau reducing learning rate to 1.000000082740371e-10.\n",
      "Epoch 27/50\n",
      "182449/182449 [==============================] - 11s 61us/step - loss: 0.0275 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "Epoch 28/50\n",
      "182449/182449 [==============================] - 14s 79us/step - loss: 0.0276 - acc: 0.9906 - val_loss: 0.0264 - val_acc: 0.9912\n",
      "\n",
      "Epoch 00028: ReduceLROnPlateau reducing learning rate to 1.000000082740371e-11.\n",
      "Epoch 00028: early stopping\n"
     ]
    }
   ],
   "source": [
    "# train \n",
    "#tf.reset_default_graph()\n",
    "with tf.Session() as ker: #Session only because there are different graphs instantiate before.\n",
    "                      #If they don't exist you don't have to start a new session.\n",
    "    \n",
    "    \n",
    "    history = model.fit(x_train, y_train, epochs=n_epochs, batch_size=batch_size, verbose = 1,\n",
    "                    validation_data=(x_val, y_val),\n",
    "                    callbacks = [\n",
    "                    EarlyStopping(monitor='val_loss', patience=10, verbose=1), #Early stopping on validation loss\n",
    "                    ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=2, verbose=1),\n",
    "                    TerminateOnNaN()]) #Reduce learning rate when the metric has stop improving\n",
    "\n",
    "    pred = model.predict(x_test) #the inference step, note: the test dataset is passed.\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot training history\n",
    "fig = plt.figure(figsize = (15,7))\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "#plt.yscale('log')\n",
    "plt.title('Training History')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['training', 'validation'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot training history\n",
    "fig = plt.figure(figsize = (15,7))\n",
    "plt.plot(history.history['acc'])\n",
    "plt.plot(history.history['val_acc'])\n",
    "#plt.yscale('log')\n",
    "plt.title('Training History')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['training', 'validation'], loc='upper right')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n",
      "[[0.98857247 0.01142753]\n",
      " [0.00299168 0.99700832]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa9869dc6a0>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = pred.reshape(-1)\n",
    "y_pred = np.around(y_pred,0)\n",
    "plot_confusion_matrix(y_test,y_pred,classes = [0,1],normalize=True) #NOTE: using the test dataset!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "response_S = []\n",
    "response_B = []\n",
    "\n",
    "\n",
    "\n",
    "for i in range(len(pred)):\n",
    "    if(y_test[i] == 1):\n",
    "        response_S.append(pred[i][0])\n",
    "    else:\n",
    "        response_B.append(pred[i][0])\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very important plot when studying a binary classification problem is the response of the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA34AAAHwCAYAAAD5DL2VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3XucXWV9L/7P1yQCR3AUgj0qYsIJiCAY6YDgFYvww0vwhhekUiwlXoq21NaDt19tPbw8PdVS/RVPDV7QHqtSrEpoTim/ykUtKIRyvCAgLxSI8OOqo1hRkef3x+zgGJOZTTJ79uw17/frlVdmPWutZ3/3npVJPnme9axqrQUAAIDuetCwCwAAAGCwBD8AAICOE/wAAAA6TvADAADoOMEPAACg4wQ/AACAjhP8AGATVXVhVf3esOsAgNki+AEwJ6rqu1V1a1U9ZErb71XVhX2ef2ZV/beBFQgAHSb4ATCXFif5g2EXsSU1aav/bqyqxbNZDwDMFsEPgLn0l0n+uKoetrmdVbV3VZ1fVXdV1TVV9bJe++okxyZ5c1XdXVVrq+rVVbV2yrnXVdVZU7ZvqqqVva+fUlWXVdVE7/enTDnuwqo6taq+nOQ/kuyxSU2PrKqvVdUfb6Hm71bVf62qryX5cVUtrqpHVdVnqur2qvpOVb1xyvEHVdXlVfXD3gjoX/Xal1VVq6rVVXVzVd1SVW+act52VfXXvX03977errfv0KraUFVvqqrbeue+esq5z62qq6rqR1X1vanvpaqeX1VXVtUPqurfqmr/6b6BAIwmwQ+AuXR5kguT/FqI6k0BPT/J3yd5RJJjknygqvZtra1J8okk/6O1tmNrbVWSi5I8vaoeVFWPTLIkyVN7fe2RZMckX6uqnZP8U5L3J9klyV8l+aeq2mXKy78qyeokOyW5YUpNy3qv8zettfdM876OSfK8JA9Lcl+StUn+T5JHJzksyR9W1f/VO/Z9Sd7XWntokv+S5KxN+npWkj2THJHklKp6dq/9bUkOTrIyyROTHJTk7VPO+89JxnqveUKS06vq4b19H07ymtbaTkmekOQLvfd3QJKPJHlN77P5YJJzNgZKALpD8ANgrv3fSd5QVbtu0v78JN9trX20tXZva+2KJJ9JcvTmOmmtXZ/kR5kMQs9Mcl6S71XV3r3tL7bW7stkIPt2a+3vev1+MsnVSVZN6e7M1to3e/t/3mvbJ5Mh9U97wXM672+t3dRa+0mSA5Ps2lr789baz3p1npHkFb1jf55kRVUtba3d3Vq7dJO+/qy19uPW2teTfDSToTKZHPH889baba2125P8WSYD60Y/7+3/eWttXZK7kzxuyr59quqhrbXv9z7bJDkxyQdba19prf2itfaxJD/NZMAEoEMEPwDmVGvtG0nOTXLKJrsem+TJvSmHP6iqH2Qy7Pznabq7KMmhSZ7R+/rCTIa+Z/a2k+RRmTKK13NDJkfGNrppM30fm+R7Sc6e/h392vmPTfKoTd7HW5P8Rm//CUn2SnJ1b9rp86fp64Ze/Zt7H1P3JcmdrbV7p2z/RyZHPZPkJUmem+SGqrqoqg6ZUuubNqn1MZv0C0AHCH4ADMOfZnK0adPwdVFr7WFTfu3YWntdb3/bTD8bg9/Te19flF8PfjdnMuBMtXsmQ91Gm+v7nUnuSPL3VbVohvcz9fybknxnk/exU2vtuUnSWvt2a+2YTE5n/YskZ09d6TSTwWtqnTdv4X1M3Td9ca1d1lp7Qe81P5dfTi+9Kcmpm9T6n3qjogB0iOAHwJxrrV2X5NNJ3jil+dwke1XVq6pqSe/XgVX1+N7+W7PJwiuZDHfPSrJDa21Dki8mOTKT96v9e++Ydb1+X9lbeOXlmZzGee4MZf48yUuTPCTJ3z2A1T6/muSHvQVfdqiqRVX1hKo6MEmq6reratfeNNQf9M75xZTz31FV/6mq9k3y6kx+TknyySRvr6pdq2ppJqfM/q+ZiqmqB1fVsVU11pvG+sMpr3dGktdW1ZNr0kOq6nlVtVOf7xWAESH4ATAsf57JUJUkaa39KJMLmrwikyNZ/18mR8Q2LjTy4Uzep/aDqvpc75xrM3kv2xd72z9Mcn2SL7fWftFruzOT9w++KcmdSd6c5PmttTtmKrC19rMkL87kSNlH+gl/vdddlcl7D7+TyVHDD2Vy4ZVkMph+s6ruzuRCL69ord0zpYuLklyX5F+TvKe19i+99v+WycVxvpbk60mu6LX141VJvltVP0zy2iS/3av18kyOvP5Nku/3Xvf4PvsEYIRUa5ub3QIAzKXeCqLfSbJkk3v1AGCbGfEDAADoOMEPAACg40z1BAAA6DgjfgAAAB0n+AEAAHTc4mEXsC2WLl3ali1bNuwyAAAAhmL9+vV3tNZ2nem4kQ5+y5Yty+WXXz7sMgAAAIaiqm7o57iRnOpZVauqas3ExMSwSwEAAJj3RjL4tdbWttZWj42NDbsUAACAeW8kgx8AAAD9G+l7/AAAgLnz85//PBs2bMg999wz7FIWnO233z677bZblixZslXnC34AAEBfNmzYkJ122inLli1LVQ27nAWjtZY777wzGzZsyPLly7eqD1M9AQCAvtxzzz3ZZZddhL45VlXZZZddtmmkdSSDn1U9AQBgOIS+4djWz30kg59VPQEAYOE69dRTs++++2b//ffPypUr85WvfCW/93u/l6uuumrWX2vHHXec9T6HwT1+AADAVjnt/Gtntb+TD99rxmMuueSSnHvuubniiiuy3Xbb5Y477sjPfvazfOhDH5rVWrpmJEf8AACAhemWW27J0qVLs9122yVJli5dmkc96lE59NBDc/nllydJPvzhD2evvfbKoYcemhNPPDEnnXRSkuT444/PG9/4xjzlKU/JHnvskbPPPjtJcvfdd+ewww7LAQcckP322y+f//znh/PmBkjwAwAARsYRRxyRm266KXvttVde//rX56KLLvqV/TfffHPe9a535dJLL83555+fq6+++lf233LLLfnSl76Uc889N6ecckqSyUclfPazn80VV1yRCy64IG9605vSWpuz9zQXBD8AAGBk7Ljjjlm/fn3WrFmTXXfdNS9/+ctz5pln3r//q1/9ap75zGdm5513zpIlS/LSl770V85/4QtfmAc96EHZZ599cuuttyaZfFzCW9/61uy///559rOfne9973v37+uKkbzHr6pWJVm1YsWKYZcCAADMsUWLFuXQQw/NoYcemv322y8f+9jH7t8300jdximiU4/9xCc+kdtvvz3r16/PkiVLsmzZss49pH4kR/ys6gkAAAvTNddck29/+9v3b1955ZV57GMfe//2QQcdlIsuuijf//73c++99+Yzn/nMjH1OTEzkEY94RJYsWZILLrggN9xww0BqH6aRHPEDAAAWprvvvjtveMMb8oMf/CCLFy/OihUrsmbNmhx99NFJkkc/+tF561vfmic/+cl51KMelX322SczDRgde+yxWbVqVcbHx7Ny5crsvffec/FW5lSN8k2L4+PjbePKPQAAwGB961vfyuMf//hhlzGju+++OzvuuGPuvffevOhFL8rv/u7v5kUvetGwy9pmm/v8q2p9a218pnNHcqonAADAlrzzne/MypUr84QnPCHLly/PC1/4wmGXNHSmegIAAJ3ynve8Z9glzDuC3yBc8O7p9z/rLXNTBwAAQEz1BAAA6DzBDwAAoONGMvhV1aqqWjMxMTHsUgAAAOa9kQx+HuAOAAAL06JFi7Jy5co88YlPzAEHHJB/+7d/26p+jj/++Jx99tmzXN3s2HHHHWe9T4u7AAAAW2emRQ0fqD4WQdxhhx1y5ZVXJknOO++8vOUtb8lFF100u3XM4N57783ixaMVpUZyxA8AAOCHP/xhHv7whyeZfGj7YYcdlgMOOCD77bdfPv/5z99/3Mc//vHsv//+eeITn5hXvepVv9bPO97xjhx//PG57777sm7duuy999552tOelje+8Y15/vOfn2Ty2YCrV6/OEUcckeOOOy733HNPXv3qV2e//fbLk570pFxwwQVJkjPPPDMnnXTS/X0///nPz4UXXphkciTvbW97W574xCfm4IMPzq233pok+c53vpNDDjkkBx54YN7xjncM5LMarZgKAAAsaD/5yU+ycuXK3HPPPbnlllvyhS98IUmy/fbb57Of/Wwe+tCH5o477sjBBx+co446KldddVVOPfXUfPnLX87SpUtz1113/Up/b37zmzMxMZGPfvSj+elPf5rXvOY1ufjii7N8+fIcc8wxv3Ls+vXr86UvfSk77LBD3vve9yZJvv71r+fqq6/OEUcckWuvvXba2n/84x/n4IMPzqmnnpo3v/nNOeOMM/L2t789f/AHf5DXve51Oe6443L66afP4qf1S0b8AACAkbFxqufVV1+df/7nf85xxx2X1lpaa3nrW9+a/fffP89+9rPzve99L7feemu+8IUv5Oijj87SpUuTJDvvvPP9fb3rXe/KD37wg3zwgx9MVeXqq6/OHnvskeXLlyfJrwW/o446KjvssEOS5Etf+tL9o4d77713HvvYx84Y/B784AffP4L4m7/5m/nud7+bJPnyl798/2ttbkRyNhjxAwAARtIhhxySO+64I7fffnvWrVuX22+/PevXr8+SJUuybNmy3HPPPWmtpao2e/6BBx6Y9evX56677srOO++c1tq0r/eQhzzk/q+3dOzixYtz33333b99zz333P/1kiVL7q9l0aJFuffee+/ft6UaZ4sRPwAAYCRdffXV+cUvfpFddtklExMTecQjHpElS5bkggsuyA033JAkOeyww3LWWWflzjvvTJJfmep55JFH5pRTTsnznve8/OhHP8ree++d66+//v6RuE9/+tNbfO1nPOMZ+cQnPpEkufbaa3PjjTfmcY97XJYtW5Yrr7wy9913X2666aZ89atfnfF9PPWpT82nPvWpJLm/z9lmxA8AABgZG+/xSyZH3T72sY9l0aJFOfbYY7Nq1aqMj49n5cqV2XvvvZMk++67b972trflmc98ZhYtWpQnPelJOfPMM+/v76UvfWl+9KMf5aijjsq6devygQ98IEceeWSWLl2agw46aIt1vP71r89rX/va7Lffflm8eHHOPPPMbLfddnnqU5+a5cuXZ7/99ssTnvCEHHDAATO+p/e973155Stfmfe97315yUtesm0f0BbUTMOZ89n4+Hi7/PLLh13Gr5tpWds+lqkFAID55lvf+lYe//jHD7uMgbr77ruz4447prWW3//938+ee+6Zk08+edhlJdn8519V61tr4zOdO5JTPatqVVWtmZiYGHYpAABAh5xxxhlZuXJl9t1330xMTOQ1r3nNsEuaFSM51bO1tjbJ2vHx8ROHXQsAANAdJ5988rwZ4ZtNIzniBwAAQP8EPwAAoG+jvEbIKNvWz13wAwAA+rL99tvnzjvvFP7mWGstd955Z7bffvut7mMk7/EDAADm3m677ZYNGzbk9ttvH3YpC87222+f3XbbbavPF/wAAIC+LFmyJMuXLx92GWwFUz0BAAA6TvADAADoOMEPAACg4wQ/AACAjhP8AAAAOk7wAwAA6DjBDwAAoOMEPwAAgI4byeBXVauqas3ExMSwSwEAAJj3RjL4tdbWttZWj42NDbsUAACAeW8kgx8AAAD9E/wAAAA6TvADAADoOMEPAACg4wQ/AACAjhP8AAAAOk7wAwAA6DjBDwAAoOMEPwAAgI4T/AAAADpO8AMAAOg4wQ8AAKDjBD8AAICOE/wAAAA6TvADAADoOMEPAACg4wQ/AACAjhP8AAAAOm7xsAsAAACYD047/9ot7jv58L3msJLZZ8QPAACg4+ZV8Kuqh1TV+qp6/rBrAQAA6IqBBr+q+khV3VZV39ik/ciquqaqrquqU6bs+q9JzhpkTQAAAAvNoEf8zkxy5NSGqlqU5PQkz0myT5Jjqmqfqnp2kquS3DrgmgAAABaUgS7u0lq7uKqWbdJ8UJLrWmvXJ0lVfSrJC5LsmOQhmQyDP6mqda21+wZZHwAAwEIwjFU9H53kpinbG5I8ubV2UpJU1fFJ7thS6Kuq1UlWJ8nuu+8+2EoBAAA6YBiLu9Rm2tr9X7R2Zmvt3C2d3Fpb01obb62N77rrrgMpEAAAoEuGEfw2JHnMlO3dktw8hDoAAAAWhGEEv8uS7FlVy6vqwUlekeScIdQBAACwIAz6cQ6fTHJJksdV1YaqOqG1dm+Sk5Kcl+RbSc5qrX3zAfa7qqrWTExMzH7RAAAAHTPoVT2P2UL7uiTrtqHftUnWjo+Pn7i1fQAAACwUw5jqCQAAwBwS/AAAADpuJIOfe/wAAAD6N5LBr7W2trW2emxsbNilAAAAzHsjGfwAAADon+AHAADQcYIfAABAx41k8LO4CwAAQP9GMvhZ3AUAAKB/Ixn8AAAA6J/gBwAA0HGCHwAAQMcJfgAAAB03ksHPqp4AAAD9G8ngZ1VPAACA/o1k8AMAAKB/gh8AAEDHCX4AAAAdJ/gBAAB0nOAHAADQcSMZ/DzOAQAAoH8jGfw8zgEAAKB/Ixn8AAAA6J/gBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHSc4AcAANBxIxn8PMcPAACgfyMZ/DzHDwAAoH8jGfwAAADon+AHAADQcYIfAABAxwl+AAAAHSf4AQAAdJzgBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHTcSAa/qlpVVWsmJiaGXQoAAMC8N5LBr7W2trW2emxsbNilAAAAzHsjGfwAAADon+AHAADQcYIfAABAxwl+AAAAHSf4AQAAdJzgBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHSc4AcAANBxgh8AAEDHCX4AAAAdJ/gBAAB03EgGv6paVVVrJiYmhl0KAADAvDeSwa+1tra1tnpsbGzYpQAAAMx7Ixn8AAAA6J/gBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHSc4AcAANBxgh8AAEDHCX4AAAAdJ/gBAAB0nOAHAADQcYIfAABAxwl+AAAAHSf4AQAAdJzgBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHSc4AcAANBxgh8AAEDHzZvgV1WPr6q/raqzq+p1w64HAACgKwYa/KrqI1V1W1V9Y5P2I6vqmqq6rqpOSZLW2rdaa69N8rIk44OsCwAAYCEZ9IjfmUmOnNpQVYuSnJ7kOUn2SXJMVe3T23dUki8l+dcB1wUAALBgDDT4tdYuTnLXJs0HJbmutXZ9a+1nST6V5AW9489prT0lybGDrAsAAGAhWTyE13x0kpumbG9I8uSqOjTJi5Nsl2Tdlk6uqtVJVifJ7rvvPrgqAQAAOmIYwa8209ZaaxcmuXCmk1tra5KsSZLx8fE2q5UBAAB00DBW9dyQ5DFTtndLcvMQ6gAAAFgQhhH8LkuyZ1Utr6oHJ3lFknOGUAcAAMCCMOjHOXwyySVJHldVG6rqhNbavUlOSnJekm8lOau19s0H2O+qqlozMTEx+0UDAAB0zEDv8WutHbOF9nWZZgGXPvpdm2Tt+Pj4iVvbBwAAwEIxjKmeAAAAzCHBDwAAoOMEPwAAgI4byeBncRcAAID+jWTwa62tba2tHhsbG3YpAAAA895IBj8AAAD6J/gBAAB03EgGP/f4AQAA9G8kg597/AAAAPo3ksEPAACA/gl+AAAAHSf4AQAAdJzgBwAA0HEjGfys6gkAANC/kQx+VvUEAADo30gGPwAAAPon+AEAAHSc4AcAANBxgh8AAEDHCX4AAAAdN5LBz+McAAAA+jeSwc/jHAAAAPo3ksEPAACA/gl+AAAAHbd42AUAAADMhdPOv3bYJQyNET8AAICOM+IHAADMuZlG304+fK85qmRhMOIHAADQcSMZ/DzHDwAAoH8jGfw8xw8AAKB/Ixn8AAAA6J/FXQAAgIFYyI9PmG8EPwAAYN6ZLjRa8fOBE/wAAICtZlRvNLjHDwAAoOOM+AEAACPFKOMDZ8QPAACg4x5w8Kuqh1fV/oMoBgAAgNnXV/Crqgur6qFVtXOS/5Pko1X1V4MtDQAAgNnQ74jfWGvth0lenOSjrbXfTPLswZU1vapaVVVrJiYmhlUCAADAyOg3+C2uqkcmeVmScwdYT19aa2tba6vHxsaGXQoAAMC812/w+7Mk5yW5rrV2WVXtkeTbgysLAACA2dLv4xxuaa3dv6BLa+169/gBAACMhn6D3/+T5IA+2gAAgI7x3LzRN23wq6pDkjwlya5V9UdTdj00yaJBFgYAAMDsmGnE78FJduwdt9OU9h8mOXpQRQEAADB7pg1+rbWLklxUVWe21m6Yo5oAAACYRf3e47ddVa1JsmzqOa213xpEUQAAAMyefoPfPyT52yQfSvKLwZUDAADMNYu3dF+/we/e1tr/HGglAAAADES/wW9tVb0+yWeT/HRjY2vtroFUBQAAzCqjegtbv8Hvd3q//8mUtpZkj9ktBwAAgNnWV/BrrS0fdCEAAAAMRl/Br6qO21x7a+3js1sOAACwtUznZEv6nep54JSvt09yWJIrkgwl+FXVqiSrVqxYMYyXBwAAGCn9TvV8w9TtqhpL8ncDqagPrbW1SdaOj4+fOKwaAAAARsWDtvK8/0iy52wWAgAAwGD0e4/f2kyu4pkki5I8PslZgyoKAAAWqunu0zv58L3msBK6pN97/N4z5et7k9zQWtswgHoAAACYZf3e43dRVf1GfrnIy7cHVxIAALA5Vu1ka/V1j19VvSzJV5O8NMnLknylqo4eZGEAAADMjn6ner4tyYGttduSpKp2TfL/Jjl7UIUBAAAwO/pd1fNBG0Nfz50P4FwAAACGqN8Rv3+uqvOSfLK3/fIk6wZTEgAAALNp2uBXVSuS/EZr7U+q6sVJnpakklyS5BNzUB8AAADbaKbpmn+d5EdJ0lr7x9baH7XWTs7kaN9fD7o4AAAAtt1MwW9Za+1rmza21i5PsmwgFQEAADCrZgp+20+zb4fZLAQAAIDBmGlxl8uq6sTW2hlTG6vqhCTrB1cWAAB0lwexM9dmCn5/mOSzVXVsfhn0xpM8OMmLBlkYAACMMuGO+WTa4NdauzXJU6rqWUme0Gv+p9baFwZeGQAAALOir+f4tdYuSHLBgGsBAABgAGZa3AUAAIARJ/gBAAB0nOAHAADQcYIfAABAx82r4FdVL6yqM6rq81V1xLDrAQAA6IKBB7+q+khV3VZV39ik/ciquqaqrquqU5Kktfa51tqJSY5P8vJB1wYAALAQzMWI35lJjpzaUFWLkpye5DlJ9klyTFXtM+WQt/f2AwAAsI36eo7ftmitXVxVyzZpPijJda2165Okqj6V5AVV9a0k/z3J/26tXTHo2gAAYGuddv61wy4B+jbw4LcFj05y05TtDUmenOQNSZ6dZKyqVrTW/nbTE6tqdZLVSbL77rvPQakAACxUwh1dMazgV5tpa6219yd5/3QnttbWJFmTJOPj420AtQEAAHTKsFb13JDkMVO2d0ty85BqAQAA6LRhBb/LkuxZVcur6sFJXpHknH5PrqpVVbVmYmJiYAUCAAB0xVw8zuGTSS5J8riq2lBVJ7TW7k1yUpLzknwryVmttW/222drbW1rbfXY2NhgigYAAOiQuVjV85gttK9Lsm7Qrw8AALDQDWuqJwAAAHNE8AMAAOi4kQx+FncBAADo30gGP4u7AAAA9G8kgx8AAAD9E/wAAAA6TvADAADouJEMfhZ3AQAA6N/AH+A+CK21tUnWjo+PnzjsWgAAGG2nnX/tsEuAgRvJET8AAAD6J/gBAAB0nOAHAADQcSMZ/CzuAgAA0L+RDH6ttbWttdVjY2PDLgUAAGDeG8ngBwAAQP8EPwAAgI4T/AAAADpO8AMAAOg4wQ8AAKDjRjL4eZwDAABA/xYPu4Ct0Vpbm2Tt+Pj4icOuBQCA+e+0868ddgkwVCM54gcAAED/BD8AAICOE/wAAAA6biTv8QMAgKncwwfTM+IHAADQcYIfAABAx41k8PMcPwAAgP6NZPBrra1tra0eGxsbdikAAADz3kgGPwAAAPon+AEAAHSc4AcAANBxnuMHAMBI8Kw+2HqCHwAA84ZwB4NhqicAAEDHCX4AAAAdJ/gBAAB0nOAHAADQcSO5uEtVrUqyasWKFcMuBQAARs7BN67Z4r5Ld189lHP7OZ+tN5LBr7W2Nsna8fHxE4ddCwDAQjTd6psnH77XHFYC9MNUTwAAgI4byRG/kXfBu7e871lvmbs6AAAYmkFOe5ypbxYeI34AAAAdZ8QPAAC2ksVKGBVG/AAAADrOiB8AAMxD7tNjNgl+AADA/QTObjLVEwAAoOOM+M030z3qIfG4BwBgpE334HdgcIz4AQAAdJwRPwAAYF6Y7v5Cj8bYNoIfAACzynTOX7JQCvOFqZ4AAAAdN5LBr6pWVdWaiYmJYZcCAAAw741k8GutrW2trR4bGxt2KQAAAPOee/wAANgs9+pBd4zkiB8AAAD9M+IHAADMCquYzl9G/AAAADpO8AMAAOg4wQ8AAKDj3OMHANBh063MefLhe81hJcAwGfEDAADoOMEPAACg40z1BABYoDygHRYOI34AAAAdZ8RvIbng3dPvf9Zb5qYOAABgThnxAwAA6DjBDwAAoONM9QQAGHEWaWEhOPjGNdPuv3T31XNUyWgy4gcAANBxgh8AAEDHmeoJADAPzDRd8+TD95qjSuanmab5DYrpg3SFET8AAICOE/wAAAA6bt5M9ayqPZK8LclYa+3oYdczkmZ6QDsAMLKs3Dkcw5piCrNtoCN+VfWRqrqtqr6xSfuRVXVNVV1XVackSWvt+tbaCYOsBwAAYCEa9FTPM5McObWhqhYlOT3Jc5Lsk+SYqtpnwHUAAAAsWAMNfq21i5PctUnzQUmu643w/SzJp5K8YJB1AAAALGTDuMfv0UlumrK9IcmTq2qXJKcmeVJVvaW1ttkb1qpqdZLVSbL77rsPulYAAGAETHc/psdyDCf41WbaWmvtziSvnenk1tqaJGuSZHx8vM1ybQAAAJ0zjMc5bEjymCnbuyW5eQh1AAAALAjDCH6XJdmzqpZX1YOTvCLJOUOoAwAAYEEY6FTPqvpkkkOTLK2qDUlr0h+AAAAPrElEQVT+tLX24ao6Kcl5SRYl+Uhr7ZsPsN9VSVatWLFitksGABiYhf4sPvdgwfAMNPi11o7ZQvu6JOu2od+1SdaOj4+fuLV9AAAALBTDmOoJAADAHBL8AAAAOm4Yj3PYZgv6Hr8LNvt4w8H3/ay3DO5c5s5M14/vFTCD6e5RO/nwveawkv4Mqt6Ffq8edM10958m3bgHdSRH/Fpra1trq8fGxoZdCgAAwLw3ksEPAACA/gl+AAAAHSf4AQAAdJzFXRg+C44AwMjwEHYYTSM54mdxFwAAgP6NZPADAACgf4IfAABAxwl+AAAAHSf4AQAAdJxVPWFLRnW10ZnqZvZM91nP1+sDBviz7bTzr512/8mH77XV58612apnW1bAtHomMJtGcsTPqp4AAAD9G8ngBwAAQP8EPwAAgI4T/AAAADpO8AMAAOg4q3oyeNu6yuS2nG9lxW6weuZo6OJKuPO15j5saVXKg2+8M0lyyB67zGU5zLLpVvxMtm3F0G2xLf0OqiZIXF/JiI74WdUTAACgfyMZ/AAAAOif4AcAANBxgh8AAEDHCX4AAAAdJ/gBAAB0nOAHAADQcYIfAABAx3mAOwvXtj5Ynl/l4d2z97ozvfaAPustPfA7SU4+fK+t6nNYpr6XTR/auy0PLp/Vz2i+/pmZ8WfjS+akjAdquoczb+lh5tN9PwG6ZiRH/DzAHQAAoH8jGfwAAADon+AHAADQcYIfAABAxwl+AAAAHSf4AQAAdJzgBwAA0HGCHwAAQMcJfgAAAB23eNgFbI2qWpVk1YoVK4ZdysJxwbuHXQEbDfJ7MYrf53lc82nnX7vFfQffeGcO2WOXOaxm0nQ1Dcol19+ZJLn03l9/7ZMP32vbX2Az18DBN9657f324eAb10ypY5Pv57Pe0lcfGz+fTW3u89rUrHx+m7GlmpIku29Dx9P+eX3JtKf+ymf9AG3LuTO5dPfVA+sbYDaN5Ihfa21ta2312NjYsEsBAACY90Yy+AEAANA/wQ8AAKDjBD8AAICOE/wAAAA6TvADAADoOMEPAACg4wQ/AACAjhP8AAAAOk7wAwAA6DjBDwAAoOMEPwAAgI4T/AAAADpO8AMAAOi4xcMuYGtU1aokq1asWDHsUua1S66/c4v7DtljlzmshF9zwbu3vO9Zb5m7OmYw3TWUPMDraLr3PGRbfJ/X/3GSrfzzcsG7c/CN039+0znt/Gu3uG+6fmeq9eAb10y7/9LdV09f2Cyb7n3O5OTD95rFSrZgk+v2AX1Pp5w705+lrbWlz+/gG9fk4IG84vRmur4umW7n7rNaykiY6fOar30Do2kkR/xaa2tba6vHxsaGXQoAAMC8N5LBDwAAgP4JfgAAAB0n+AEAAHSc4AcAANBxgh8AAEDHCX4AAAAdJ/gBAAB0nOAHAADQcYIfAABAxwl+AAAAHSf4AQAAdJzgBwAA0HGCHwAAQMcJfgAAAB0n+AEAAHSc4AcAANBxgh8AAEDHCX4AAAAdJ/gBAAB0nOAHAADQcYuHXcBGVfWQJB9I8rMkF7bWPjHkkgAAADphoCN+VfWRqrqtqr6xSfuRVXVNVV1XVaf0ml+c5OzW2olJjhpkXQAAAAvJoKd6npnkyKkNVbUoyelJnpNknyTHVNU+SXZLclPvsF8MuC4AAIAFY6DBr7V2cZK7Nmk+KMl1rbXrW2s/S/KpJC9IsiGT4W/gdQEAACwkw7jH79H55cheMhn4npzk/Un+pqqel2Ttlk6uqtVJVifJ7rvvPsAyu+2S6+/c4r5D9thlpPqd1vV/PO3u6Wqa8b1c8O4HfN5Mr5lki/1ui63+/OahrX0v23L9Dcp07+XgrNn6Pme47qdz8I2bf91LPrzVXc7Ydz8u3X31r7Wddv61vX4f2DUxqJ9Tc2lbPsuN5tvPhdl4T8MwqnUDC88wgl9tpq211n6c5NUzndxaW5NM/otofHy8zXJtAAAAnTOMKZUbkjxmyvZuSW4eQh0AAAALwjCC32VJ9qyq5VX14CSvSHLOEOoAAABYEAb9OIdPJrkkyeOqakNVndBauzfJSUnOS/KtJGe11r75APtdVVVrJiYmZr9oAACAjhnoPX6ttWO20L4uybpt6HdtkrXj4+Mnbm0fAAAAC4XHJgAAAHSc4AcAANBxIxn83OMHAADQv5EMfq21ta211WNjY8MuBQAAYN4byeAHAABA/wQ/AACAjhP8AAAAOm4kg5/FXQAAAPo3ksHP4i4AAAD9G8ngBwAAQP8EPwAAgI4T/AAAADpO8AMAAOi4kQx+VvUEAADoX7XWhl3DVquq25PcMOw6NmNpkjuGXQSd5fpikFxfDJprjEFyfTFI8/X6emxrbdeZDhrp4DdfVdXlrbXxYddBN7m+GCTXF4PmGmOQXF8M0qhfXyM51RMAAID+CX4AAAAdJ/gNxpphF0Cnub4YJNcXg+YaY5BcXwzSSF9f7vEDAADoOCN+AAAAHSf4bYOqOrKqrqmq66rqlM3s366qPt3b/5WqWjb3VTKq+ri+/qiqrqqqr1XVv1bVY4dRJ6NpputrynFHV1WrqpFdxYy518/1VVUv6/0M+2ZV/f1c18ho6+PvyN2r6oKq+vfe35PPHUadjJ6q+khV3VZV39jC/qqq9/euva9V1QFzXePWEvy2UlUtSnJ6kuck2SfJMVW1zyaHnZDk+621FUlOS/IXc1slo6rP6+vfk4y31vZPcnaS/zG3VTKq+ry+UlU7JXljkq/MbYWMsn6ur6raM8lbkjy1tbZvkj+c80IZWX3+DHt7krNaa09K8ookH5jbKhlhZyY5cpr9z0myZ+/X6iT/cw5qmhWC39Y7KMl1rbXrW2s/S/KpJC/Y5JgXJPlY7+uzkxxWVTWHNTK6Zry+WmsXtNb+o7d5aZLd5rhGRlc/P7+S5F2Z/A+Fe+ayOEZeP9fXiUlOb619P0laa7fNcY2Mtn6usZbkob2vx5LcPIf1McJaaxcnuWuaQ16Q5ONt0qVJHlZVj5yb6raN4Lf1Hp3kpinbG3ptmz2mtXZvkokku8xJdYy6fq6vqU5I8r8HWhFdMuP1VVVPSvKY1tq5c1kYndDPz6+9kuxVVV+uqkurarr/XYdN9XONvTPJb1fVhiTrkrxhbkpjAXig/0abNxYPu4ARtrmRu02XSO3nGNicvq+dqvrtJONJnjnQiuiSaa+vqnpQJqenHz9XBdEp/fz8WpzJaVKHZnK2wher6gmttR8MuDa6oZ9r7JgkZ7bW3ltVhyT5u941dt/gy6PjRvbf90b8tt6GJI+Zsr1bfn0awf3HVNXiTE41mG7oGDbq5/pKVT07yduSHNVa++kc1cbom+n62inJE5JcWFXfTXJwknMs8EKf+v378fOttZ+31r6T5JpMBkHoRz/X2AlJzkqS1tolSbZPsnROqqPr+vo32nwk+G29y5LsWVXLq+rBmbxx+JxNjjknye/0vj46yReaByfSnxmvr95UvA9mMvS5P4YHYtrrq7U20Vpb2lpb1lpblsl7SI9qrV0+nHIZMf38/fi5JM9Kkqpamsmpn9fPaZWMsn6usRuTHJYkVfX4TAa/2+e0SrrqnCTH9Vb3PDjJRGvtlmEX1Q9TPbdSa+3eqjopyXlJFiX5SGvtm1X150kub62dk+TDmZxacF0mR/peMbyKGSV9Xl9/mWTHJP/QWzPoxtbaUUMrmpHR5/UFW6XP6+u8JEdU1VVJfpHkT1prdw6vakZJn9fYm5KcUVUnZ3Ia3vH+851+VNUnMzkNfWnvHtE/TbIkSVprf5vJe0afm+S6JP+R5NXDqfSBK38GAAAAus1UTwAAgI4T/AAAADpO8AMAAOg4wQ8AAKDjBD8AAICOE/wAmDeqqlXVe6ds/3FVvXOGcw6tqqcMoJbjq+pvZrtfABgGwQ+A+eSnSV7ce6h3vw5NMqvBr6oe8HNut+YcAJgrgh8A88m9SdYkOXnTHVW1a1V9pqou6/16alUtS/LaJCdX1ZVV9cyqur4mPayq7quqZ/TO/2JVraiqnavqc1X1taq6tKr27+1/Z1Wtqap/SfLxTV77eVV1yaaBdNNzqmpRVf1lr76vVdVresc9sqou7tX4jap6eq/97qp6b1VdUVX/WlW79tpX9mr7WlV9tqoe3mu/sKr+oqq+WlXXTuln317blb1z9uy1//aU9g9W1aLZ+kYBMFoEPwDmm9OTHFtVY5u0vy/Jaa21A5O8JMmHWmvfTfK3vfaVrbWLklybZJ8kT0uyPsnTq2q7JLu11q5L8mdJ/r21tn+St+ZXQ95vJnlBa+2VGxuq6kVJTkny3NbaHZupd+o5JySZ6NV4YJITq2p5klcmOa+1tjLJE5Nc2Tv3IUmuaK0dkOSiJH/aa/94kv/aq/HrU9qTZHFr7aAkfzil/bVJ3tfrfzzJhqp6fJKXJ3lqr/0XSY7dTP0ALACmpQAwr7TWflhVH0/yxiQ/mbLr2Un2qaqN2w+tqp0208UXkzwjyfIk705yYiZD1WW9/U/LZHBMa+0LVbXLlJB5Tmtt6ms+K5NB6ojW2g+3UPLUc45Isn9VHd3bHkuyZ++1P1JVS5J8rrW2Mfjdl+TTva//V5J/7NXysF6ITZKPJfmHKa/3j73f1ydZ1vv6kiRvq6rdkvxja+3bVXVYJkPpZb3PbIckt23hPQDQcUb8AJiP/jqTo2cPmdL2oCSH9Eb2VrbWHt1a+9Fmzv1ikqcnOSjJuiQPy+R9gBf39tdmzmm933+8Sfv1SXZKstc0tU49p5K8YUqNy1tr/9JauziTYfR7Sf6uqo7bQl9tC+1T/bT3+y/S+w/c1trfJzkqk0H5vKr6rV4tH5tSy+Naa+/so38AOkjwA2Deaa3dleSsTIa/jf4lyUkbN6pqZe/LH2UynG30lUwu9nJfa+2eTE6rfE0mA2EyGQCP7fVxaJI7phnNuyHJizN5/96+fZR+XpLX9Ub2UlV7VdVDquqxSW5rrZ2R5MNJDugd/6AkG0cHX5nkS621iSTf33j/XpJXZXLEcouqao8k17fW3p/knCT7J/nXJEdX1SN6x+zcqwOABUjwA2C+em+SqYupvDHJeG/xkqsyeV9bkqxN8qLeAiZPb639NMlNSS7t7f9iJoPh13vb79zYT5L/nuR3piuitXZNJoPiP1TVf5mh5g8luSrJFVX1jSQfzOSo3KFJrqyqf8/kNNP39Y7/cZJ9q2p9kt9K8ue99t9J8pe9GldOad+Slyf5RlVdmWTvJB9vrV2V5O1J/qXXz/lJHjlDPwB0VLXWz6wSAGC2VdXdrbUdh10HAN1nxA8AAKDjjPgBAAB0nBE/AACAjhP8AAAAOk7wAwAA6DjBDwAAoOMEPwAAgI4T/AAAADru/webpK+eevrTZgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure( figsize = (15,8))\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.set_yscale('log')\n",
    "plt.hist(response_S,bins = 100, label = 'Signal', alpha = 0.5)\n",
    "plt.hist(response_B,bins = 100, label = 'Background', alpha = 0.5)\n",
    "plt.title(\"Network response\")\n",
    "plt.xlabel(\"Network response\")\n",
    "plt.ylabel(\"Counts\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC Curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "AUC (area under the curve) - ROC (Receiver operating characteristic) curve is a performance measurement for classification problem at various thresholds settings. ROC is a probability curve and AUC represents degree or measure of separability. It tells how much model is capable of distinguishing between classes. Higher the AUC, better the model is at predicting 0s as 0s and 1s as 1s. By analogy, Higher the AUC, better the model is at distinguishing between patients with disease and no disease.\n",
    "\n",
    "The ROC curve is plotted with TPR (true positive rate) against the FPR (false positive rate) where TPR is on y-axis and FPR is on the x-axis.\n",
    "\n",
    "$$TPR = \\frac{TP}{TP + FN}$$\n",
    "\n",
    "\n",
    "$$FPR =\\frac{FP}{TN + FP} $$\n",
    "\n",
    "A simple explanation of the ROC curve and its interpretation can be found here: <a href=\"https://towardsdatascience.com/understanding-auc-roc-curve-68b2303cc9c5/\"> ROC-AUC </a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve, roc_auc_score\n",
    "\n",
    "fpr, tpr, _ = roc_curve(y_test,pred)\n",
    "score = roc_auc_score(y_test,pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (10,10))\n",
    "lw = 2\n",
    "plt.plot(fpr, tpr, color='darkorange',\n",
    "         lw=lw, label='ROC curve (area = %0.4f)' % score)\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n",
    "plt.xlim([-0.1, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver operating characteristic')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grid search\n",
    "\n",
    "The choice of the model parameter can be very important. In order to try different combinations of parameters in a simple way, scikit learn provides the GridSearchCV methods. Note: computationally speaking is very expansive! It can take a lot of hours!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import multiprocessing\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "\n",
    "#Defining a function that returns a built model. The sintax adopted is a little bit different -> is just for example.\n",
    "def create_model(n_layer ,neurons, activation, optimizer = \"adam\"):\n",
    "    \n",
    "    model = Sequential()\n",
    "    \n",
    "    model.add(Dense(neurons, input_dim = input_shape, activation = activation))\n",
    "    \n",
    "    for i in range(0,n_layer):         \n",
    "        \n",
    "         model.add(Dense(neurons, activation = activation))            \n",
    "        \n",
    "    model.add(Dense(1, activation = 'sigmoid'))\n",
    "\n",
    "    model.compile(loss = 'binary_crossentropy', optimizer = optimizer, metrics=['acc'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "model = KerasClassifier(build_fn = create_model, verbose = 1)\n",
    "\n",
    "\n",
    "early_stop = EarlyStopping(monitor = \"val_loss\" ,min_delta=1e-8, patience=3, verbose=1, mode='auto')\n",
    "\n",
    "#The following ranges are small! Is just for example!\n",
    "\n",
    "# epochs = [i for i in range(100,140,20)]\n",
    "neurons = [i for i in range(3,4)]\n",
    "n_layers = [i for i in range(1,2)]\n",
    "\n",
    "\n",
    "#The gridsearch method needs a dictionary!\n",
    "#The activatin functions and the optimizers available can be found on the keras website!\n",
    "activation = [\"relu\",\"tanh\"] \n",
    "optimizer = [\"adam\"]\n",
    "param_grid = {'n_layer':n_layers,\n",
    "              'neurons':neurons,\n",
    "              'activation':activation,\n",
    "               'optimizer': optimizer}\n",
    "\n",
    "#n_jobs stands for the number of cores that will be used, cv stands for cross-validation!\n",
    "grid = GridSearchCV(estimator = model, param_grid = param_grid, n_jobs = 4, verbose = 1, cv = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 2 folds for each of 2 candidates, totalling 4 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=4)]: Using backend LokyBackend with 4 concurrent workers.\n",
      "[Parallel(n_jobs=4)]: Done   2 out of   4 | elapsed:   33.1s remaining:   33.1s\n",
      "[Parallel(n_jobs=4)]: Done   4 out of   4 | elapsed:   33.9s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 182449 samples, validate on 60816 samples\n",
      "Epoch 1/1\n",
      "182449/182449 [==============================] - 18s 97us/step - loss: 0.1384 - acc: 0.9512 - val_loss: 0.0879 - val_acc: 0.9661\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as ker2:\n",
    "    grid_result = grid.fit(x_train,y_train, verbose = 1,validation_data=(x_val,y_val), callbacks = [\n",
    "                    early_stop, #Early stopping on validation loss\n",
    "                    ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=2, verbose=1),\n",
    "                    TerminateOnNaN()] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: if the notebook was opened from a shell, sometimes the output of the training is printed in the shell instead of in the notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's have a look on the best parameters found by the grid search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.960175 using {'activation': 'tanh', 'n_layer': 1, 'neurons': 3, 'optimizer': 'adam'}\n"
     ]
    }
   ],
   "source": [
    "print(\"Best: %f using %s\" % (grid_result.best_score_, grid_result.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 182449 samples, validate on 60816 samples\n",
      "Epoch 1/10\n",
      "182449/182449 [==============================] - 20s 109us/step - loss: 0.1584 - acc: 0.9339 - val_loss: 0.0896 - val_acc: 0.9642\n",
      "Epoch 2/10\n",
      "182449/182449 [==============================] - 22s 120us/step - loss: 0.0794 - acc: 0.9671 - val_loss: 0.0739 - val_acc: 0.9687\n",
      "Epoch 3/10\n",
      "182449/182449 [==============================] - 22s 119us/step - loss: 0.0677 - acc: 0.9714 - val_loss: 0.0641 - val_acc: 0.9737\n",
      "Epoch 4/10\n",
      "182449/182449 [==============================] - 22s 120us/step - loss: 0.0598 - acc: 0.9752 - val_loss: 0.0567 - val_acc: 0.9770\n",
      "Epoch 5/10\n",
      "182449/182449 [==============================] - 23s 126us/step - loss: 0.0548 - acc: 0.9777 - val_loss: 0.0526 - val_acc: 0.9793\n",
      "Epoch 6/10\n",
      "182449/182449 [==============================] - 23s 127us/step - loss: 0.0522 - acc: 0.9792 - val_loss: 0.0511 - val_acc: 0.9794\n",
      "Epoch 7/10\n",
      "182449/182449 [==============================] - 24s 131us/step - loss: 0.0509 - acc: 0.9797 - val_loss: 0.0493 - val_acc: 0.9813\n",
      "Epoch 8/10\n",
      "182449/182449 [==============================] - 26s 140us/step - loss: 0.0501 - acc: 0.9802 - val_loss: 0.0489 - val_acc: 0.9811\n",
      "Epoch 9/10\n",
      "182449/182449 [==============================] - 22s 119us/step - loss: 0.0496 - acc: 0.9804 - val_loss: 0.0481 - val_acc: 0.9817\n",
      "Epoch 10/10\n",
      "182449/182449 [==============================] - 21s 116us/step - loss: 0.0493 - acc: 0.9804 - val_loss: 0.0483 - val_acc: 0.9805\n"
     ]
    }
   ],
   "source": [
    "# ep_best = grid_result.best_params_[\"epochs\"]\n",
    "nrn_best = grid_result.best_params_[\"neurons\"]\n",
    "activ = grid_result.best_params_[\"activation\"]\n",
    "lay = grid_result.best_params_[\"n_layer\"]\n",
    "optim = grid_result.best_params_[\"optimizer\"]\n",
    "\n",
    "model = create_model(lay,nrn_best,activ)\n",
    "\n",
    "model.compile(loss = 'binary_crossentropy', optimizer = optim, metrics=['acc'])\n",
    "\n",
    "with tf.Session() as ker_fin:\n",
    "    history_cv = model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val))\n",
    "\n",
    "#And then as before..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}