Sigmoid Activation NN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy as sci \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 891 entries, 0 to 890\n",
      "Data columns (total 12 columns):\n",
      "PassengerId    891 non-null int64\n",
      "Survived       891 non-null int64\n",
      "Pclass         891 non-null int64\n",
      "Name           891 non-null object\n",
      "Sex            891 non-null object\n",
      "Age            714 non-null float64\n",
      "SibSp          891 non-null int64\n",
      "Parch          891 non-null int64\n",
      "Ticket         891 non-null object\n",
      "Fare           891 non-null float64\n",
      "Cabin          204 non-null object\n",
      "Embarked       889 non-null object\n",
      "dtypes: float64(2), int64(5), object(5)\n",
      "memory usage: 83.6+ KB\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv('titanic_train_kaggle.csv')\n",
    "data.head()\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 714 entries, 0 to 890\n",
      "Data columns (total 4 columns):\n",
      "Survived    714 non-null int64\n",
      "Sex         714 non-null int32\n",
      "Age         714 non-null float64\n",
      "Fare        714 non-null float64\n",
      "dtypes: float64(2), int32(1), int64(1)\n",
      "memory usage: 25.1 KB\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "pd.set_option('display.max_rows', 714)\n",
    "data = pd.DataFrame(data[[\n",
    "    'Survived',\n",
    "    'Sex',\n",
    "    'Age',\n",
    "    'Fare'\n",
    "]])\n",
    "data = data.dropna()\n",
    "\n",
    "scaler = StandardScaler()\n",
    "age = data['Age'].values.reshape(-1,1)\n",
    "data['Age'] = scaler.fit_transform(age)\n",
    "\n",
    "fare = data['Fare'].values.reshape(-1,1)\n",
    "data['Fare'] = scaler.fit_transform(fare)\n",
    "\n",
    "data['Sex'] = data['Sex'].map({'female':0,'male':1}).astype(int)\n",
    "\n",
    "data.info()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return (1/(1 + np.exp(-x)))\n",
    "\n",
    "              \n",
    "def sig_der(x):\n",
    "    return (sigmoid(x) * (1 - sigmoid(x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weights Before Train\n",
      "[[ 0.3021492 ]\n",
      " [-0.62845312]\n",
      " [ 1.22719663]]\n",
      "Weights After Train\n",
      "[[-2.3169637 ]\n",
      " [-0.1717068 ]\n",
      " [ 0.69788022]]\n",
      "[1.04547753]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "learning_rate = .01\n",
    "\n",
    "inputs = data.loc[:,['Sex','Age','Fare']].values\n",
    "train_outputs = data.loc[:,'Survived'].values\n",
    "weights = np.random.randn(3,1)*np.sqrt(2/(3))\n",
    "print('Weights Before Train')\n",
    "print(weights)\n",
    "\n",
    "B = .05\n",
    "\n",
    "for i in range(100):\n",
    "\n",
    "    input_layer = inputs\n",
    "    X = np.dot(input_layer,weights) + B\n",
    "    outputs = sigmoid(X)\n",
    "\n",
    "    train_outputs = train_outputs.reshape(-1,1)\n",
    "\n",
    "    error = outputs - train_outputs\n",
    "    \n",
    "    der = sig_der(outputs)\n",
    "    z_delta = error * der\n",
    "    \n",
    "#     adjust = np.dot(input_layer.T, sig_der(input_layer, weights, B) * error)\n",
    "    \n",
    "    weights -= learning_rate * np.dot(input_layer.T,z_delta)\n",
    "    for num in z_delta:\n",
    "        B -= learning_rate * num\n",
    "\n",
    "print('Weights After Train')\n",
    "print(weights)\n",
    "print(B)\n",
    "out_r = []\n",
    "for i in outputs:\n",
    "    if i >= 0.5:\n",
    "        out_r.append(1)\n",
    "    else:\n",
    "        out_r.append(0)\n",
    "# print(list(zip(out_r,train_outputs)))\n",
    "\n",
    "# print(outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.          0.          0.         ...  0.          1.\n",
      "   1.        ]\n",
      " [-0.53037664  0.57183099 -0.25482473 ... -0.73704057 -0.25482473\n",
      "   0.15850313]\n",
      " [-0.51897787  0.69189675 -0.50621356 ... -0.08877362 -0.08877362\n",
      "  -0.50952283]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Weights After Train\n",
    "# [[-2.33628522]\n",
    "#  [-0.17116952]\n",
    "#  [ 0.69766165]]\n",
    "# [1.05987224]\n",
    "\n",
    "\n",
    "print(input_layer.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1= Survived 0= Did Not Survive\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.80      0.83      0.82       424\n",
      "           1       0.74      0.69      0.72       290\n",
      "\n",
      "    accuracy                           0.78       714\n",
      "   macro avg       0.77      0.76      0.77       714\n",
      "weighted avg       0.78      0.78      0.78       714\n",
      "\n"
     ]
    },
    {
     "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": [
    "from sklearn.metrics import roc_auc_score, roc_curve, classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def ModelScore(y_true, y_pred,output):\n",
    "    print('1= Survived', '0= Did Not Survive')\n",
    "    print(classification_report(y_true, y_pred))\n",
    "    roc_auc = roc_auc_score(y_true, y_pred)\n",
    "    fpr, tpr, thresholds = roc_curve(y_true,output)\n",
    "    plt.figure()\n",
    "    plt.plot(fpr, tpr, label='Model (area = %.2f)'% roc_auc)\n",
    "    plt.plot([0,1],[0,1], 'r--')\n",
    "    plt.xlim([0.0,1.0])\n",
    "    plt.ylim([0.0,1.05])\n",
    "    plt.xlabel('False Positive Rate')\n",
    "    plt.ylabel('True Positive Rate')\n",
    "    plt.title('Reciever Operating Characteristic')\n",
    "    plt.legend(loc='lower right')\n",
    "    plt.show()\n",
    "    \n",
    "ModelScore(train_outputs,out_r,outputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c046d3ee46094ed38bd532cbf70b4448",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=135.0, description='ix', max=360.0, step=15.0), FloatSlider(value=20.0…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interactive\n",
    "import ipywidgets as widgets\n",
    "\n",
    "x = data['Sex'].values\n",
    "y = data['Fare'].values\n",
    "graph_weight = []\n",
    "B = 0.5\n",
    "for i in range(100):\n",
    "    graph_weight.append(np.random.randint(-5,5,size=3)/np.random.randint(1,5,size=3))\n",
    "\n",
    "\n",
    "errors = []\n",
    "for i in range(100):\n",
    "    pred = np.array(sigmoid(np.dot(input_layer,graph_weight[i]))).ravel()\n",
    "\n",
    "    error = np.mean((pred - train_outputs)**2)\n",
    "    errors.append(error)\n",
    "    \n",
    "    \n",
    "errors = np.array(errors) \n",
    "\n",
    "x = [graph_weight[i][0] for i in range(100)]\n",
    "y = [graph_weight[i][1] for i in range(100)]\n",
    "\n",
    "from mpl_toolkits.mplot3d import Axes3D \n",
    "import matplotlib.cm as cm\n",
    "def plot(ix,iy):\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    ax = fig.add_subplot(projection='3d')\n",
    "    ax.plot_trisurf(x,y,errors,cmap=cm.magma)\n",
    "\n",
    "    ax.view_init(iy,ix)\n",
    "    ax.set_title('Loss Function for Single Layer Perceptron NN')\n",
    "    ax.set_xlabel('Weight1 (multiplied by Sex)')\n",
    "    ax.set_ylabel('Weight2 (multiplied by Age)')\n",
    "    ax.set_zlabel('Loss')\n",
    "\n",
    "inter_plot = interactive(plot,ix=widgets.FloatSlider(min=0,max=360,step=15,value=135),iy=widgets.FloatSlider(min=-180,max=180,step=15,value=20))\n",
    "inter_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now Building NN Class with hidden relu activation layer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Relu:\n",
    "    @staticmethod\n",
    "    def activation(z):\n",
    "        z[z<0] = 0\n",
    "        return z\n",
    "    @staticmethod\n",
    "    def prime(z):\n",
    "        z[z<0] = 0\n",
    "        z[z>0] = 1\n",
    "        return z\n",
    "    \n",
    "    \n",
    "class Sigmoid:\n",
    "    @staticmethod\n",
    "    def activation(z):\n",
    "        return 1 / (1+ np.exp(-z))\n",
    "    @staticmethod\n",
    "    def prime(z):\n",
    "        return Sigmoid.activation(z) * (1 - Sigmoid.activation(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork():\n",
    "    def __init__(self, dimensions, activations):\n",
    "        #dimensions param: tuple of dimensions for NN, (input, hidden layer, output)\n",
    "        #activations param: tuple of activation fuctions\n",
    "        self.n_layers = len(dimensions)\n",
    "        self.loss = None\n",
    "        self.learning_rate = None\n",
    "        \n",
    "        self.w = {}\n",
    "        self.b = {}\n",
    "        self.activations = {}\n",
    "        self.train_history = {'epochs':[], \n",
    "                              'loss': [], \n",
    "                              'accuracy': []}\n",
    "        self.val_history = {'epochs':[], \n",
    "                            'loss': [], \n",
    "                            'accuracy': []}\n",
    "        self.test_history = {'epochs':[], \n",
    "                            'loss': [], \n",
    "                            'accuracy': []}\n",
    "        for i in range(len(dimensions) - 1):\n",
    "            #if dimensions = (3,4,1):\n",
    "            #weight[1] = random array with size (3,4)(row, col)s\n",
    "            #weight[2] = random array with size(4,1)\n",
    "            self.w[i+1] = np.random.randn(dimensions[i],dimensions[i+1]) / np.sqrt(dimensions[i])\n",
    "            self.b[i+1] = 2 * np.random.random_sample(dimensions[i+1]) + 1\n",
    "            self.activations[i+2] = activations[i]\n",
    "            \n",
    "\n",
    "    def _feed_forward(self, x):\n",
    "        #param x: array of input data vectors( array of arrays )\n",
    "        \n",
    "        #pass data forward through NN\n",
    "        #z has keys 2 and 3 for the weightged sums at each neuron\n",
    "        ### so z[2] is (n_rows_training, n_neurons in layer2) shape\n",
    "        ### each row in z[2] has four columns, each row represents a row of training data being passed\n",
    "        ### through NN and each column is the sum of that training row at a given nueron (x1w1 +x2w2... +xnwn +b)\n",
    "        ### the weights will be differnet for each x going into each neuron\n",
    "        \n",
    "        # z = W1X1 + W2X2 ... + WnXn + Bias \n",
    "        z = {}\n",
    "        \n",
    "        #outputs or activations of each layer\n",
    "        #input layer 1 just outputs the inputs\n",
    "        # input layer 2 (for RElU then Sigmoid network) outputs used in next iteration of z\n",
    "        \n",
    "        # a = f(z)\n",
    "        a = {1 : x}\n",
    "        \n",
    "        for i in range(1, self.n_layers):\n",
    "            #fill z[i+1] with dot product of weights[i'th layer] and outputs (a) of i'th layer\n",
    "            z[i+1] = np.dot(a[i], self.w[i]) + self.b[i]\n",
    "            #fill outputs (a[i+1]) by applying activation fuction[i+1] (only layer 2 and 3 have activation)  to \n",
    "            #to the just calculated z[i+1] dot prod of weght * x\n",
    "            a[i+1] = self.activations[i+1].activation(z[i+1])\n",
    "         \n",
    "        #dictionaries with keys for corresponding layer\n",
    "        return z, a\n",
    "        \n",
    "        \n",
    "    def predict(self, x):\n",
    "        #x param: array containing x input array\n",
    "        \n",
    "        _ , a = self._feed_forward(x)\n",
    "        \n",
    "        #returns last layer's output\n",
    "        #this is the models prediction \n",
    "        #here is is through sigmoid function so between 0-1 for proba survive\n",
    "        return a[self.n_layers]\n",
    "        \n",
    "    def _update_w_b(self, index, dw, delta):\n",
    "        #index param: index of layer \n",
    "        #dw param: array of partial derivatives for weights \n",
    "        #delta param: delta error (combined partial dervatives for chain rule for partial der with respect to weights)\n",
    "        \n",
    "        #subtract learning rate times derivative of cost fuction with respect to each weight at each layer \n",
    "        #from each corresponding weight to move weights towards more accurate (less loss) values\n",
    "        # Bias partial derivative is slightly differnt than weights and needs one less chain-rule to calculate\n",
    "\n",
    "        self.w[index] -= self.learning_rate * dw\n",
    "\n",
    "        self.b[index] -= self.learning_rate * np.mean(delta, 0)\n",
    "        \n",
    "    def _back_prop(self, z, a ,y_true):\n",
    "        #z param: dictionary w(x) +b\n",
    "        # a param: dict f(z)\n",
    "        #loss will be called in the 'fit' method, using MSE here\n",
    "        #delta method returns partial derivative of loss func w respect to predicted value\n",
    "        #times the derivative of optimization function at last layer of NN\n",
    "       \n",
    "        \n",
    "        delta = self.loss.delta(y_true, a[self.n_layers])\n",
    "        \n",
    "        #matrix multiply delta by the given layers transposed inputs and thats the three chains for partial \n",
    "        #derivative of loss function at last layer of network\n",
    "        #doing all in matrix multiplication is much faster than using for/while loops \n",
    "        \n",
    "        dw = np.dot(a[self.n_layers - 1].T, delta)\n",
    "        \n",
    "        \n",
    "        #update params = dictionary with key for each layer of NN\n",
    "        #layer 1 has (input dim, num nuerons in second layer) shaped derivative of weights as dw, \n",
    "        #and (batch_size,num nuerons in second layer) shaped delta for num nuerons in second layer z funcs at 2nd\n",
    "        \n",
    "        #layer 2 has (4,1) shaped derivative of 4 weights in second layer (from relu to sigmoid)\n",
    "        #and (batch_size,1) delta because just on z func (or neuron) at sigmoid layer\n",
    "     \n",
    "        \n",
    "        update_params = {\n",
    "            self.n_layers - 1 : (dw, delta)\n",
    "        }\n",
    "        \n",
    "        for i in reversed(range(2,self.n_layers)):\n",
    "            \n",
    "            # mult previous layer's delta by it's weights (while iterating) by given layers activation functions derivative\n",
    "            # to get current layers delta. (biases adjust by: minus 1*(delta), weights adjusted by: minus delta * previous layers activations)\n",
    "            # we do this in batches with dot products and transposed activation matrixes to get a sum of partial derivatives for each row in batch \n",
    "            # ran through NN.  Too large of batch size (or strange distributions in training data) can make this combination too\n",
    "            #extreme in either direction (+/-)\n",
    "            delta = np.dot(delta, self.w[i].T) * self.activations[i].prime(z[i])\n",
    "            \n",
    "            # now dot prod the delta matrix and previous layers activation matrix transposed\n",
    "            dw = np.dot(a[i - 1].T, delta)\n",
    "\n",
    "            update_params[i-1] = (dw,delta)\n",
    "\n",
    "        for k,v in update_params.items():\n",
    "            #use calc partial derivative to update the weights and biases at each layer\n",
    "            self._update_w_b(k, v[0], v[1])\n",
    "            \n",
    "        \n",
    "    def fit(self, x, y_true, loss, epochs, batch_size, learning_rate,xtest, ytest,validation_split=0.4,plot=True):\n",
    "        if x.shape[0] != y_true.shape[0]:\n",
    "            raise ValueError('Lengh of x and y arrays dont match')\n",
    "        #passing in activation function for loss class\n",
    "        self.loss = loss(self.activations[self.n_layers])\n",
    "        self.learning_rate = learning_rate\n",
    "        \n",
    "        #shuffle data for creating random validation sample\n",
    "        seed = np.arange(x.shape[0])\n",
    "        np.random.shuffle(seed)\n",
    "        x = x[seed]\n",
    "        y = y_true[seed]\n",
    "        \n",
    "        val_index = int(round(len(y_true)*validation_split,0))\n",
    "\n",
    "        x_train = x[val_index:]\n",
    "        y_train = y[val_index:]\n",
    "        x_val = x[:val_index]\n",
    "        y_val = y[:val_index]\n",
    "        \n",
    "        for i in range(epochs):\n",
    "            # Shuffle the data\n",
    "            #stochastic gradient decent for faster processing\n",
    "            #uses sample of points rather than full training set to calculate partial derivatives\n",
    "            seedt = np.arange(x_train.shape[0])\n",
    "            np.random.shuffle(seedt)\n",
    "            x_ = x_train[seedt]\n",
    "            y_ = y_train[seedt]\n",
    "            \n",
    "            \n",
    "            for j in range(x_.shape[0] // batch_size):\n",
    "                #k = lower bound of sample\n",
    "                k = j * batch_size\n",
    "                #upper bound of sample\n",
    "                l = (j + 1) * batch_size\n",
    "                z, a = self._feed_forward(x_[k:l])\n",
    "                self._back_prop(z, a, y_[k:l])\n",
    "                \n",
    "         \n",
    "            if i % 15 == 0:\n",
    "                test_pred = self.predict(x_train)\n",
    "\n",
    "                print(\"Epoch {}, Loss: {}\".format(i,self.loss.loss(y_train, test_pred)))\n",
    "                losst = self.loss.loss(y_train, test_pred)\n",
    "                accuracyt = self.accuracy(y_train, test_pred)\n",
    "    \n",
    "                self.train_history['epochs'].append(i)\n",
    "                self.train_history['loss'].append(losst)\n",
    "                self.train_history['accuracy'].append(accuracyt)\n",
    "\n",
    "                \n",
    "                val_pred = self.predict(x_val)\n",
    "\n",
    "                lossv = self.loss.loss(y_val, val_pred)\n",
    "                accuracyv = self.accuracy(y_val, val_pred)\n",
    "                self.val_history['accuracy'].append(accuracyv)\n",
    "                self.val_history['epochs'].append(i)\n",
    "                self.val_history['loss'].append(lossv)\n",
    "                \n",
    "                val_test = self.predict(xtest)\n",
    "\n",
    "                losste = self.loss.loss(ytest, val_test)\n",
    "                accuracyte = self.accuracy(ytest, val_test)\n",
    "                \n",
    "                self.test_history['accuracy'].append(accuracyte)\n",
    "                self.test_history['epochs'].append(i)\n",
    "                self.test_history['loss'].append(losste)\n",
    "                \n",
    "\n",
    "\n",
    "                \n",
    "        if plot == True:\n",
    "            self.plot_loss()\n",
    "            \n",
    "            \n",
    "        \n",
    "        \n",
    "        \n",
    "    def plot_loss(self):\n",
    "        f = plt.figure(figsize=(10,5))\n",
    "        f.suptitle(\"SGD Optimization with {} learning rate\".format(self.learning_rate))\n",
    "        ax = f.add_subplot(1,2,1)\n",
    "        x = self.train_history['epochs']\n",
    "        y = self.train_history['loss']\n",
    "\n",
    "        x2 = self.val_history['epochs']\n",
    "        y2 = self.val_history['loss']\n",
    "        ax.plot(x,y,label=\"Train\")\n",
    "        ax.plot(x2,y2,label='Validate')\n",
    "        ax.set_title(\"Loss\")\n",
    "        \n",
    "        x3 = self.test_history['epochs']\n",
    "        y3 = self.test_history['loss']\n",
    "       \n",
    "        ax.plot(x3,y3,label='Test')\n",
    "        ax.set_title(\"Loss\")\n",
    "\n",
    "        ax.set_ylabel(\"loss\")\n",
    "        ax.set_xlabel('Epochs')\n",
    "        plt.legend()\n",
    "\n",
    "        \n",
    "        ax = f.add_subplot(1,2,2)\n",
    "        xt = self.train_history['epochs']\n",
    "        yt = self.train_history['accuracy']\n",
    "        xv = self.val_history['epochs']\n",
    "        yv = self.val_history['accuracy']\n",
    "        x3 = self.test_history['epochs']\n",
    "        y3 = self.test_history['accuracy']\n",
    "        ax.plot(xt,yt, label='Train')\n",
    "        ax.plot(xv,yv, label='Validate')\n",
    "        ax.plot(x3,y3,label=\"Test\")\n",
    "        ax.set_ylabel(\"Accuracy\")\n",
    "        ax.set_xlabel('Epochs')\n",
    "        ax.set_title(\"Accuracy\")\n",
    "# #         plt.legend()\n",
    "        plt.show()\n",
    "        \n",
    "    def accuracy(self, y_true, y_pred):\n",
    "\n",
    "        if y_pred.shape[1] > 1:\n",
    "            y_pred_round = []\n",
    "            y_true_round = []\n",
    "            for j,k in zip(y_pred,y_true):\n",
    "                y_pred_round.append(np.argmax(j))\n",
    "                y_true_round.append(np.argmax(k))\n",
    "        else:\n",
    "            y_true_round = y_true\n",
    "            y_pred_round = []\n",
    "            for i in y_pred:\n",
    "                if i >= .5:\n",
    "                    y_pred_round.append(1)\n",
    "                else:\n",
    "                    y_pred_round.append(0)\n",
    "\n",
    "        C = 0\n",
    "        I = 0\n",
    "\n",
    "        for true, pred in zip(y_true_round, y_pred_round):\n",
    "            if true == pred:\n",
    "                C += 1\n",
    "            else:\n",
    "                I += 1\n",
    "        return round(C/(I+C),3)\n",
    "        \n",
    "        \n",
    "class MSE:\n",
    "    def __init__(self, activation_fn):\n",
    "        #param activation_fn: Class object of activation function\n",
    "        self.activation_fn = activation_fn\n",
    "    def activation(self, z):\n",
    "        return self.activation_fn.activation(z)\n",
    "\n",
    "\n",
    "    def loss(self, y_true, y_pred):\n",
    "        return np.mean((y_pred - y_true)**2)\n",
    "    \n",
    "\n",
    "    def prime(self, y_true, y_pred):\n",
    "        #partial derrivative for chain rule\n",
    "        return (y_pred - y_true)\n",
    "        \n",
    "    def delta(self, y_true, y_pred):\n",
    "        #combining partial activation derivative and derivative of MSE with respect to y_pred\n",
    "         return self.prime(y_true, y_pred) * self.activation_fn.prime(y_pred)\n",
    "\n",
    "    \n",
    "        \n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I added X_test and y_test into the fit method because I had a bug in the plotting that was showing validation getting worse over time.  Added in test to check, was just a typo.  Need to remove the use of the testing data from the fit meothd "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, Loss: 0.26534833386097206\n",
      "Epoch 15, Loss: 0.23158866803620615\n",
      "Epoch 30, Loss: 0.21699401525175968\n",
      "Epoch 45, Loss: 0.20706398666770692\n",
      "Epoch 60, Loss: 0.19978970643981883\n",
      "Epoch 75, Loss: 0.1941595430970602\n",
      "Epoch 90, Loss: 0.18960251742296105\n",
      "Epoch 105, Loss: 0.18573562474005684\n",
      "Epoch 120, Loss: 0.1824835161746997\n",
      "Epoch 135, Loss: 0.17963254935109588\n",
      "Epoch 150, Loss: 0.1772048341232848\n",
      "Epoch 165, Loss: 0.1751297325336686\n",
      "Epoch 180, Loss: 0.17335107643590544\n",
      "Epoch 195, Loss: 0.1718289411668469\n",
      "Epoch 210, Loss: 0.1705103698328927\n",
      "Epoch 225, Loss: 0.16941533530817016\n",
      "Epoch 240, Loss: 0.16849569896553232\n",
      "Epoch 255, Loss: 0.16771941341301486\n",
      "Epoch 270, Loss: 0.16702177520618838\n",
      "Epoch 285, Loss: 0.16646201893682663\n",
      "Epoch 300, Loss: 0.16601280560520593\n",
      "Epoch 315, Loss: 0.16561106881309334\n",
      "Epoch 330, Loss: 0.16528313942133255\n",
      "Epoch 345, Loss: 0.1650222350831808\n",
      "Epoch 360, Loss: 0.164779713980922\n",
      "Epoch 375, Loss: 0.1645929019765397\n",
      "Epoch 390, Loss: 0.16442403866237848\n",
      "Epoch 405, Loss: 0.16429389454233737\n",
      "Epoch 420, Loss: 0.16418099151795754\n",
      "Epoch 435, Loss: 0.16409095971708207\n",
      "Epoch 450, Loss: 0.16400667708786118\n",
      "Epoch 465, Loss: 0.16393603779004196\n",
      "Epoch 480, Loss: 0.16387527870026086\n",
      "Epoch 495, Loss: 0.16382313391985107\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAAFhCAYAAAA1Aw2RAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3hUZfbA8e/JJCGNJKTQQTrSW0QRFRAUu/5sFFm7rG3VVSyrrmJd2VUXFRsqdsW2uKyKYkGxgRCkht5DKEmANBLSzu+Pe4NDSCNMMgk5n+fJQ+be9773zCRMzrxVVBVjjDHGGFM3BPg7AGOMMcYY8wdLzowxxhhj6hBLzowxxhhj6hBLzowxxhhj6hBLzowxxhhj6hBLzowxxhhj6hBLzoyp50TkZBFZXc1r24pItoh46kpMtXF/EWknIioigbUZV20SkStF5Cc/3fteEXnVH/c25mhgyZlpkETkJBH5RUQyRGS3iPwsIsd5nW8hIq+ISIqbvGwQkTdE5Fj3fMkf92z3a6eIfCYip1VyXxGRO0VkrYjkisgWEXlCRBodRuwqIp1KHqvqj6ratTqvg6puUdUIVS2qzvU1EZMvlL6/iGwSkRHVrc/9uU0SkXT3658iIhWUHysim0UkR0Q+FZEYr3MxIjLDPbdZRMZW9Vr3/GgRWemeXy8iJ1f3edUUVX1cVa/1dxwAIjJRRN7xdxzGHA5LzkyDIyKRwGfAc0AM0Ap4CNjvno8FfgHCgJOBxkB/4AegdPIVraoRQB/ga2CGiFxZwe2fBcYDl7v1ngmcCnzog6dmas544AKcn3Nv4Bzgz2UVFJEewMvAn4BmwD7gBa8izwP57rnLgBfdayq91k3+JwFX4fz+nAJs8NFzrJK61NpYl2IxxqdU1b7sq0F9AQnA3grOPwosAQIqKNMOUCCw1PEJwM6yrgU6A0XAwFLH2+Akhqe6j98AXsJJ9rJwksJj3HNz3fvmANnAKGAokOxV3ybgTmCpW+41nD/0s9z6vgGalH4ewCC3zpKvPGCTW24g8CuwF9gOTAGCDyOmbsD37vUrgPO8zr2Bk7B87sY3H+hYzuv+JnCH+30r9743uo87AbsB8b4/8DZQDOS68d3l9byvALYAacB9Ffy8fwHGez2+BphXTtnHgfe8HnfEScYaA+Hu9128zr8NPFHZtV5xXFPF3/MrgZ+8Hh+L8zu1G1gNXOp17mzgdyAT2ApMLON3/Rr3tZpb2esHTATeKXV9eWVD3Z/rHmCl+/NJruB5KXATsBbY6B57xo07E0gETnaPn+G+fgXuz36JezwK5//FdmAbzv95j7/fm+zLvkq+rOXMNERrgCIReVNEzhSRJqXOjwBmqGpxNer+D9AUKKtLbzjOH53fvA+q6lZgHge3yl0GPALEAYuBd92yp7jn+6jTHflBOXFc5NbXBTgXJzG7160vALil9AWq+qtbZwTQxI3pffd0EfBX9/pB7nO5sSoxiUgQ8D9gtvva/AV4V0S8X6MxOK2XTYB1wGPlPK8fcBIvgCE4rUZD3MenAD+q6kF70qnqn3CSgnPd+P7pdfoknJ/VcOABEelWzn174CTsJZa4xyotq6rrcRMy96tIVdeUU1e517rjAhOAeBFZJyLJIjJFRELLieMAEQnHSczew/kZjAFeKGmxw0msLweicRK1G0TkglLVDMFJskd6Havq61dR2QdxErgOOL+z4yp7PjitmMcD3d3HC4C+OC3h7wEfiUiIqn6Jk/B+4P7s+7jl3wQKcRL6fsDpQJ3ohjUGrFvTNECqmonzh0KBV4BUEZkpIs3cInHAjpLyInKeiOwVkSwRmV1J9SnuvzFlnIvD+aRelu3u+RKfq+pcVd0P3AcMEpE2ldzb23OqulNVtwE/AvNV9Xe3vhk4f5Aq8izOH+z7AFQ1UVXnqWqhqm7C6XobUsH13k4AInBah/JV9TucbuUxXmX+o6q/qWohTiLat5y6fgBOFpEAnGTsn8Bg99wQ9/zheEhVc1V1CU5S1KecchFAhtfjDCCinHFnpcuWlG9cybnKrm0GBAEX43S398X5Od5fTszezsFpBX3d/RkuAj5x60JVv1fVZaparKpLcZLy0j/fiaqao6q5Xseq+vpVVPZS4HFV3aOqyTi/e5X5h6ruLolFVd9R1XT3uT0FNKLsD0i4/8/PBG5zn88u4N/A6Crc15haYcmZaZBUdaWqXqmqrYGeQEtgsns6HWjhVXamqkbjtBwFV1J1K/ff3WWcS/Out5QW7vkSW73un+3W17KSe3vb6fV9bhmPI8q7UET+jNM6Nbak9VBEurgTHnaISCZOa0RceXWU0hLYWqolcjN/vFbglQzjjLMqMz63JSkbJzE5GSfJS3Fb4aqTnFXpvu49I70eRwLZpVvpyilbUj6rknOVXVuSFD2nqttVNQ14GjirnJi9HQMc737I2Csie3FaZ5sDiMjxIjJHRFJFJAO4nkN/vls5VFVfv4rKtixVd1n3Ke2gMiJyhztJIsN9blGU//t5DE6Su93rtXgZp0XRmDrBkjPT4KnqKpxxTz3dQ98CF7itM4fr/4BdOGN6SvsOaCMiA70Pui1iJ7j3LdHG63wETktcCjXMnfn3CHC+qnq34LwIrAI6q2okThdpubMVS0nBed7er2dbnLE+1fEDTotPsNsy+ANOl1wTnC7gspSVRB2OFRzcKtTHPVZpWRHpgNOSs8b9ChSRzuXUVe61qroHSKZ6z2Ur8IOqRnt9RajqDe7594CZQBtVjcIZ81j653ukr2F5tgOtvR5XpYX4QCzu7+zdOC1wTdwPUhn8EX/puLfijPGM83otIlW1vG5qY2qdJWemwRGRY91P2q3dx21wutjmuUWexvlD/7aIdHSXUWhM+V1tiEgzEbkZZ/zM38oar+aOM3oJZ7zVCSLiccf8fAJ8o6rfeBU/S5zlPoJxkqX57tg0cFrBOhzBS1Dec2gDfABcXmpMFDjdaplAtjjLidxQ6nxFMc3H6SK9S0SCRGQozji46dUM9QfgZpyB6eBMNPgLzuD38pYEOdLX7C3gdhFpJSItgTtwEvqyvAucK85aa+HAwzjdtlmqmoMzLvFhEQkXkcHA+TiTAiq81j3/OvAXEWnqjpW8Daf1sDKf4Yxb+5P7MwgSkeO8xn01Bnarap774WFs+VX53IfA30SkiYi0wvnZHo7GOOPHUnES3wc4uPVxJ9Cu5MOBqm7HGf/4lIhEikiA+/+8qt30xtQ4S85MQ5SFM5h4vojk4CRly3H+4OJ2F52AM1vxJ7f8Ypw/AqWTkr1uHctwupcuUdVpFdz7ZuBV4B2cLqwvcZKLi0qVew8n0dsNDMDpgioxEXjT7ZK5tKpPugqG43RzfSx/rN9W0qIzAecPdhbOOL3SExHKjUlV84HzcMb5pOEsDXG522JZHT/g/CxKkrOfcJY9mVvuFfAP4H43vgnVuOfLOJMaluH8rnzuHgPAfa1OBlDVFTjdgu/itKI2xp084boRZ4biLpyxXTe411Tl2kdwBr+vwZnZ+DvlT544wE3uTscZV5WC08U4CadVriSmh0UkC3iA2l3a5WGcFsGNODOJP8Zd1qaKvsKZ8LIGp7s8j4O7PT9y/00XkUXu95fjDFFIwpkl+jHlDzkwptZJ2UMmjDH+IiJv4MzqrMpAb2OOKiJyAzBaVa0lyzRY1nJmjDHGb8TZjWOw273YFacFe4a/4zLGn2x1ZWOMMf4UjNNF3B5nkeLpHLyjgjENjnVrGmOMMcbUIdataYwxxhhTh1hyZowxxhhTh1hyZowxxhhTh1hyZowxxhhTh1hyZowxxhhTh1hyZowxxhhTh1hyZowxxhhTh1hyZuocEdkkIiP8HYcxxojI9yKyR0QaVV7aGN+w5MwYY4wpg4i0A04GFDivFu9ru/c0cJacmXpDRK4TkXUisltEZopIS/e4iMi/RWSXiGSIyFIR6emeO0tEkkQkS0S2icgE/z4LY0w9cjkwD3gDuKLkoIiEishTIrLZfc/5SURC3XMnicgvIrJXRLaKyJXu8e9F5FqvOq4UkZ+8HquI3CQia4G17rFn3DoyRSRRRE72Ku8RkXtFZL37/pYoIm1E5HkRecr7SYjI/0Tktpp4gUzNsOTM1AsicirwD+BSoAWwGWcPPoDTgVOALkA0MApId8+9BvxZVRsDPYHvajFsY0z9djnwrvs1UkSaucefBAYAJwIxwF1AsYi0BWYBzwHxQF9g8WHc7wLgeKC7+3iBW0cM8B7wkYiEuOduB8YAZwGRwNXAPuBNYIyIBACISBwwHHj/cJ648S9Lzkx9cRkwTVUXqep+4G/AILfboQBoDByLs1/sSlXd7l5XAHQXkUhV3aOqi/wQuzGmnhGRk4BjgA9VNRFYD4x1k56rgVtVdZuqFqnqL+770mXAN6r6vqoWqGq6qh5OcvYPVd2tqrkAqvqOW0ehqj4FNAK6umWvBe5X1dXqWOKW/Q3IwEnIAEYD36vqziN8SUwtsuTM1BctcVrLAFDVbJzWsVaq+h0wBXge2CkiU0Uk0i16Ec4ny80i8oOIDKrluI0x9dMVwGxVTXMfv+ceiwNCcJK10tqUc7yqtno/EJE7RGSl23W6F4hy71/Zvd4ExrnfjwPePoKYjB9YcmbqixScT7EAiEg4EAtsA1DVZ1V1ANADp3vzTvf4AlU9H2gKfAp8WMtxG2PqGXf82KXAEBHZISI7gL8CfXCGVeQBHcu4dGs5xwFygDCvx83LKKNeMZwM3O3G0URVo3FaxKQK93oHOF9E+gDdcN77TD1iyZmpq4JEJKTkCyepukpE+rpT2h8H5qvqJhE5TkSOF5EgnDfAPKBIRIJF5DIRiVLVAiATKPLbMzLG1BcX4LxXdMcZ89UXJ8n5EWcc2jTgaRFp6Q7MH+S+L70LjBCRS0UkUERiRaSvW+di4EIRCRORTsA1lcTQGCgEUoFAEXkAZ2xZiVeBR0SkszspqreIxAKoajLOeLW3gU9KuklN/WHJmamrvgByvb5OBv4OfAJsx/nEONotGwm8AuzB6fpMxxmwC/AnYJOIZALX80dTvzHGlOcK4HVV3aKqO0q+cIZPXAbcAyzDSYB2A5OAAFXdgjOM4g73+GKc1jaAfwP5wE6cbsd3K4nhK5zJBWtw3tfyOLjb82mcD62zcT54vgaEep1/E+iFdWnWS6KqlZcyxhhjTL0hIqfgdG+2U9Vif8djDo+1nBljjDFHEXeIx63Aq5aY1U+WnBljjDFHCRHpBuzFmbgw2c/hmGqybk1jjDHGmDrEWs6MMcYYY+oQS86MMcYYY+qQQH8H4CtxcXHarl07f4dhjKlFiYmJaaoa7+84fMHew4xpWCp6/zpqkrN27dqxcOFCf4dhjKlFIrK58lL1g72HGdOwVPT+Zd2axhhjjDF1iCVnxhhjjDF1iCVnxhhjjDF1yFEz5syY+qSgoIDk5GTy8vL8HUq9EBISQuvWrQkKCqq1e4rIGcAzgAdnpfUnSp1vi7N/YbRb5h5V/cI99zecja2LgFtU9ataC9wYU+9ZcmaMHyQnJ9O4cWPatWuHiPg7nDpNVUlPTyc5OZn27dvXyj1FxAM8D5wGJAMLRGSmqiZ5Fbsf+FBVXxSR7sAXQDv3+9FAD6Al8I2IdFHVoloJ3hhT71m3pjF+kJeXR2xsrCVmVSAixMbG1nYr40BgnapuUNV8YDpwfqkyCkS630cBKe735wPTVXW/qm4E1rn1GWNMlVhyZoyfWGJWdX54rVoBW70eJ7vHvE0ExolIMk6r2V8O41pjjCmXJWfGNEDp6en07duXvn370rx5c1q1anXgcX5+fpXquOqqq1i9enUNR+o3ZWWDpTciHgO8oaqtgbOAt0UkoIrXOjcRGS8iC0VkYWpq6hEFbIw5etiYM2MaoNjYWBYvXgzAxIkTiYiIYMKECQeVUVVUlYCAsj/Dvf766zUepx8lA228Hrfmj27LEtcAZwCo6q8iEgLEVfFa3OumAlMBEhISykzgjDENT4NMzr5J2okIDO/WzN+hGFOnrFu3jgsuuICTTjqJ+fPn89lnn/HQQw+xaNEicnNzGTVqFA888AAAJ510ElOmTKFnz57ExcVx/fXXM2vWLMLCwvjvf/9L06ZN/fxsjsgCoLOItAe24QzwH1uqzBZgOPCGiHQDQoBUYCbwnog8jTMhoDPwW20FbmpHSnYKv6b8ipbdKFqhDlEd6N+sfw1EZY4WDTI5e+mH9QR6xJIzY8qQlJTE66+/zksvvQTAE088QUxMDIWFhQwbNoyLL76Y7t27H3RNRkYGQ4YM4YknnuD2229n2rRp3HPPPf4I3ydUtVBEbga+wlkmY5qqrhCRh4GFqjoTuAN4RUT+itNteaWqKrBCRD4EkoBC4CabqXl0mZs8l3vm3kNWQVa167iu13Xc1PcmPAEeH0ZmjhYNMjmLi2jEutRsf4dhDAAP/W8FSSmZPq2ze8tIHjy3R7Wu7dixI8cdd9yBx++//z6vvfYahYWFpKSkkJSUdEhyFhoayplnngnAgAED+PHHH6sffB3hrln2RaljD3h9nwQMLufax4DHajRAU+uKtZipS6fywuIX6BrTlUcHP0p0o+jDqkNRXlryEq8se4Wk3UlMOnkSUY2iaihiU181zOSscTDzNu73dxjG1Enh4eEHvl+7di3PPPMMv/32G9HR0YwbN67MJS2Cg4MPfO/xeCgsLKyVWI2pLdn52dz7073M2TqHszuczYODHiQ0MLRadU08cSI94nrw+PzHGf3ZaJ459Rm6NOni44hNfdYwk7OIRuzdV0BBUTFBHpuwavyrui1ctSEzM5PGjRsTGRnJ9u3b+eqrrzjjjDP8HZYxtWpDxgZum3MbWzK3cPdxd3NZt8uOeHmXS7pcQufoztz+/e2M+2IcDw9+mDPa2f8t42iQmUlsRCMAdudUbckAYxqq/v370717d3r27Ml1113H4MFl9uIZc9T6bst3jP18LBn7M3jl9FcY132cz9bd69u0Lx+c8wFdm3Tlzh/u5OmFT1NYbK3OBsQZv1r/JSQk6MKFC6tUdtM7t/D5qj0MuWEKPVtZX7+pfStXrqRbt27+DqNeKes1E5FEVU3wU0g+dTjvYcZ3Zm2cxdSlUynrb6GibMjYQPfY7kweOpkWES1qJIaCogImLZjEB6s/oHl4c8IDwyu/qJQuMV247/j7bPxaPVLR+1eD7NaMyVnLCQGppGXbuDNjjGmoduTs4MFfHqRFeAs6Rncss8ypbU/lz73/TEhgSI3FEeQJ4v4T7qdPfB/mbJ1z2NcXazFfb/6a5WnLeWbYM3Ru0rkGojS1qUEmZwERTYllPRuzrVvTGGMaIlXlsfnOhNoXRrxAqwj/77B1bsdzObfjudW6dvGuxdz+/e1c9sVlNn7tKNAgx5wFRzUjTjKs5cwYYxqob7d8y/dbv+fGPjfWicTsSB0yfi3xaYqKbXm9+qpGkzMROUNEVovIOhE5ZEVKEbldRJJEZKmIfCsix3idaysis0VkpVumna/iCopsRoTksXdvhq+qNMYYU09k52fzj/n/oGuTrlzW/TJ/h+Mz8WHxTBs5jVFdR/H68te54Zsb2Ju3199hmWqosW5NEfEAzwOn4ew1t0BEZroLN5b4HUhQ1X0icgPwT2CUe+4t4DFV/VpEIoBin8UW4Wwrk5+xw1dVGmOMqSee/f1ZUnNTmTxsMkEBQf4Ox6dKxq91j+3Oo/MeZfTno7kz4U7CgsIOu672Ue1pHt68BqI0lanJMWcDgXWqugFARKYD5+NsaQKAqnqPfJwHjHPLdgcCVfVrt5xvl/MPjwegKGuXT6s1xhhTty1NXcr0VdMZc+wYesX38nc4NebCzhfSObozt31/G7d9f1u16ggNDOWRwY8wst1IH0dnKlOTyVkrYKvX42Tg+ArKXwPMcr/vAuwVkf8A7YFvgHt8tj9dhJOcsS/NJ9UZU98MHTqUv/3tb4wc+ceb7uTJk1mzZg0vvPBCmddERESQnZ1NSkoKt9xyCx9//HGZ9T755JMkJJS/usXkyZMZP348YWGH/0nemCNRUFzAQ78+RHxYPH/p9xd/h1PjesX34tPzP2XtnrWHfW2RFvHsomeZ8MMEktKTuKXfLbYPaC2qyeSsrFX6ylxUTUTGAQnAEPdQIHAy0A/YAnwAXAm8Vuq68cB4gLZt21Y9MrflLDDXkjPTMI0ZM4bp06cflJxNnz6df/3rX5Ve27JlyzITs6qaPHky48aNs+TM1Lp3kt5hzZ41TB46mYjgCH+HUysaBzemf7P+1bp22shpTFowiWnLp7Fq9yomnTyJ6JDD20vUVE9NTghIBtp4PW4NpJQuJCIjgPuA81R1v9e1v6vqBlUtBD4FDvntUtWpqpqgqgnx8fFVjyzcGXMWmp9OUfHRsQivMYfj4osv5rPPPmP/fue/3KZNm0hJSaFv374MHz6c/v3706tXL/773/8ecu2mTZvo2bMnALm5uYwePZrevXszatQocnNzD5S74YYbSEhIoEePHjz44IMAPPvss6SkpDBs2DCGDRsGwOzZsxk0aBD9+/fnkksuITvbt6MYjAFIzkrmhcUvMKzNMIYfM9zf4dQLJePXHjrxIRbsWMDoz0ezevdqf4fVINRky9kCoLOItAe2AaOBsd4FRKQf8DJwhqruKnVtExGJV9VU4FTAd0tnB4WQHxhBbGEGe/blE+du52RMQxEbG8vAgQP58ssvOf/885k+fTqjRo0iNDSUGTNmEBkZSVpaGieccALnnXdeudvVvPjii4SFhbF06VKWLl1K//5/fIZ67LHHiImJoaioiOHDh7N06VJuueUWnn76aebMmUNcXBxpaWk8+uijfPPNN4SHhzNp0iSefvppHnjggdp6KUwDoKo8Ov9RAiSAe4+/19/h1DsXdr6QTtGd+Ov3f2XcF+OYeOJEzu5wdtmFf5kCS6bXboB1SYchMPKxI66mxpIzVS0UkZuBrwAPME1VV4jIw8BCVZ0J/AuIAD5y3/y3qOp5qlokIhOAb8U5kQi84qvY0nPT2RsaQ9x+Z60zS86MX826B3Ys822dzXvBmU9UWKSka7MkOZs2bRqqyr333svcuXMJCAhg27Zt7Ny5k+bNy56xNXfuXG655RYAevfuTe/evQ+c+/DDD5k6dSqFhYVs376dpKSkg84DzJs3j6SkpAN7dubn5zNo0KAjeebGHOKbLd/w87afufu4u232YTX1ju/NB+d8wB3f38E9P97DjLUzDt01IW8vbJkHjSKhBndUqMv65m/jWh/UU6M7BKjqF8AXpY494PX9iAqu/RroXd75I3HztzcTHh3E1XszScvKB/u/ahqgCy64gNtvv51FixaRm5tL//79eeONN0hNTSUxMZGgoCDatWtHXl5ehfWU1aq2ceNGnnzySRYsWECTJk248sory6xHVTnttNN4//33ffa8jClt9qbZNA1ryphjx/g7lFqlqny+bDvzNqSXW6ZLs8aMHdiWQE/lo5ziQuN4deSrPPf7c8xLmUdmfqb33SBtDQSHQFwHkEPr27uvgH359X9j9/BGgUSFlr0ES2YL36QtDXL7priwOJID1xEnGSTZLgHG3ypp4aopERERDB06lKuvvpoxY5w/WhkZGTRt2pSgoCDmzJnD5s2bK6zjlFNO4d1332XYsGEsX76cpUuXApCZmUl4eDhRUVHs3LmTWbNmMXToUAAaN25MVlYWcXFxnHDCCdx0002sW7eOTp06sW/fPpKTk+nSpUuNPnfTsCSlJ9Envk+Dmm24dfc+7vt0OXPXpNI4JJDgMpKvYlXe2beFDxZsZdJFvenZqvJN04MCgrh9wO0woNSJnyZD4mwY9S50O+egU+tTs/nbf5axZuNuokKDCAwoe5hEfVBQVExyXiEnd47jsQt60Ta2ZiY2NczkLDSOpVJkWziZBm/MmDFceOGFTJ/ujBG57LLLOPfcc0lISKBv374ce+yxFV5/ww03cNVVV9G7d2/69u3LwIEDAejTpw/9+vWjR48edOjQ4UC3JcD48eM588wzadGiBXPmzOGNN95gzJgxByYnPProo5acGZ/J2J/Blqwt/F/n//N3KLWisKiYN37ZxFOz1xAgMPHc7vxpUDs8ZSREqsqXy3fwwMwVnDflJ645qT1/Pa0LYcGHmRrs2QTfPwHHnnNQYpZfWMxLP6xnynfrCAkKYNJFvbg0oU25Y1jrg+Ji5d35m5n05WpOn/wDt5/WhasHt69Sy+PhENWjY7ZiQkKCLlxYtTkDLyx+gZeWvMiijVt4auDP3H1WzxqOzpiDrVy5km7duvk7jHqlrNdMRBJVtfxF1eqRw3kPM1U3b/s8rpt9HVNPm8qglkf3eMYVKRnc88kylm3LYPixTXnkgp60jA6t9LqM3AKemLWK93/bQpuYUB67oBendKniCgiq8M5FsPU3uGk+RDn7lCZu3sPf/rOUNTuzObt3Cx48tztNGx8949C2Z+TywH9X8HXSTnq2iuSJC6vW8uitovevBttypkC6x0Pe3p2AJWfGGHM0WpG2AoDusd39HImjoKiYlL255Z6PCQ+mccjhbSmVm1/E5G/X8OqPG2kSFsyUsf04u1eLKrdQRYUG8Y8Le3FB35b87T/LuHzab/xfv1bcOLQjwYEVtwiFrfmU+PXfsvuUR8gqjKYoNZs3f9nEW/M20zwyhNeuSGB4t2aH9XzqgxZRoUz904ADLY/nP/+z0/I4oguhwUfefd5gkzOANE8AhbaFkzHGHLVWpK+gdURrohodXqtGTbnr46XM+H1buedDggIYM7At40/pQIuoilu9svcX8u68zbzy40bSsvczKqEN957Vjaiw6u0XenyHWL649WRemLOOF39YX2GcAJFk822je1isHbhwdnuKZ38PgAhcMagdE0Z2JaLR0ZtmiAhn9mrBiZ3ieGLWSqbO3cDK7Zm8fU1FmyFVzdH7qlUgPtRprk3zeCDbkjNjjDlaJaUn0TOubvSOJKVkMuP3bfxfv1ac3DnukPOq8OuGdN7+dTPvzNvMRf1bc/2QjrSLCz+o3J6cfN74ZRNv/LKJjNwCTuoUxy3D+zOwfcwRxxgS5OH207tyQb9WLN66t8Ky/d4xGpIAACAASURBVJY8SOyWHJaeMo0no/4YcnBs80i6t4w84ljqC6flsTfn923ls8kODTI5K2k5Sw304LH9NY0x5qi0N28v27K3MarrKH+HAsBTs1cTGRLIxHN7lNu6ddGA1tw2ojNT525g+oKtfLhwK2f3bsmNQzsSGx7MKz9u4N35W9iXX8Rp3Ztx49CO9GvbxOexdoiPoEN8BVtcbf4FNn8MJ/6F4cNO8/n966MTOsT6rK4GnZyleTw0yk9HVev17BFjjDGHSkpPAqBHbA8/RwKJm3fz7apd3Dmya6Xdjq2bhPHw+T25+dROvPbTRt75dTP/W5JCkEcoKlbO69OSG4Z2omvzxrUUfSmF++F/t0FUWxj6N//EcJRrkMlZkCeI6EbR7PLk0FQzyMgtIDos2N9hGWOM8aEV6c5kgG6x/p0Zrar866vVxEUEc9XgdlW+rmnjEP52ZjduHNKJt+dtYs++Ai4fdAzHxIZXfnHlQUHi67Du28O/NicV0lbD2I8g2AexmEM0yOQMnNaz1ODddJdM0rLzLTkzDUp6ejrDhzubP+/YsQOPx0N8vDMW87fffiM4uGr/H6ZNm8ZZZ51V7vZOxvjTivQVtItsR+NgP7UwuX5el868Dbt58Nzuh7+GGBAVFsTNp3b2XUD5++B/t8Cyj6BJ++olWCdPgC6n+y4mc5CGnZwFbiQOZyHaTk0r6Fs35igTGxvL4sWLAZg4cSIRERFMmDDhsOuZNm0a/fv3t+TM1Ekr0lfQr2k/v8bgtJqtomVUCGOPb+vXWABnwdgPxsGO5XDq/XDSHRDg2wVUzZFr0MnZJo8QJxlssl0CjDngzTff5Pnnnyc/P58TTzyRKVOmUFxczFVXXcXixYtRVcaPH0+zZs1YvHgxo0aNIjQ09LBa3IypaWm5aezI2eH38Wazk3ayJDmDf17Um0aBft4+av0c+PgqKC6GsR9ay1cd1mCTs/jQeHZLETGSxcIsS86MAVi+fDkzZszgl19+ITAwkPHjxzN9+nQ6duxIWloay5YtA2Dv3r1ER0fz3HPPMWXKFPr27evnyI05WF2YDFBUrDw1ezUd4sK5sH8rv8WBKvzyLHwzEeKPhVHvQGxH/8VjKtVgk7O40DjyUYIDMkmz5Mz40aTfJrFq9yqf1nlszLHcPfDuw77um2++YcGCBSQkODuK5Obm0qZNG0aOHMnq1au59dZbOeusszj9dPvEbeq2pPQkBKmxyQBFxUpBUTEhQeW3hs1cso01O7OZMrZf1fZeVIXMbc6/vlJcCN8+DCv+A90vgPOfh0Y2jKeua9DJGUBGIORkpvs5GmPqBlXl6quv5pFHHjnk3NKlS5k1axbPPvssn3zyCVOnTvVDhMZUzYr0FbSPak94UM3MJrzr46V8viyl3NX88wuL+ffXa+neIpKzeraoWqWfXAvLP/Z9sBIAIx6Cwbc6y/ebOq/BJmfxYX/sElCQscPP0ZiGrDotXDVlxIgRXHzxxdx6663ExcWRnp5OTk4OoaGhhISEcMkll9C+fXuuv/56ABo3bkxWVpafozbmUElpSRzf4si30SnL3DWpfLIomZ6tInmrnNX8P1y4lS279/H6lccRUJVV41d+5iRmA66EVmXuhV19zbpDqwG+rdPUqAabnB3YJcDjoTg71c/RGFM39OrViwcffJARI0ZQXFxMUFAQL730Eh6Ph2uuuebAgs2TJk0C4KqrruLaa6+1CQGmTtm1bxe7cnfRI873481y84u4/9PldIgL5+PrTyQ1az+v/PjHav7n9G7J1Se157nv1pJwTBOGdo2vvNL9WTDrLmjaA856EjzV2xvTHD0afHKW7vHgybXkzDRcEydOPOjx2LFjGTt27CHlfv/990OOXXrppVx66aU1FZox1VIyGaB7bHef1/3sd2vZsnsf7113PCFBHtrEHLqa/8wlKU7Z0f2qtvvMd49CZgpc8qYlZgZowMlZRFAEIZ5GpAZ6CM5Lsy2cjDHmKLEifQUBEkDXJl19Wu+qHZm8MncDFw9ozYkdD9643Hs1/7d+3URBsXJ8VfZa3JYI81+G466BNsf5NF5TfzXY5ExEiA2NI9Wzh5bFGeTkFxHRqMG+HMYYc9RYkbaCDlEdCAsK81mdxcXKvf9ZRuOQQO49q/wZoFFhQfxleBVX8y8qhP/dChHNYPgDPorUHA0a9LLA8aHx7ApsRDwZtpyGMcYcBVSVpPQkn69v9u5vW1i0ZS/3n92dmHAfja2c/yLsWAZn/RNConxTpzkqNOimoviweNYGBRInzhZOJbNsjKkN1pVederLdZ/MUSlnfyE/rk1j9/5dpOelQ34bvli2/cD5po0bMeCYJtX6P7crM49/zlrF4E6xvltMdu8WmPM4dDkDup3nmzrNUaNBJ2exIbHMC4BYySTVtnAytSgkJIT09HRiY2MtQauEqpKenk5ISIi/QzF1VHGxcs2bC5i3YTeBESsIbQPvzS3mnbxFB5Xr0zqKG4d14rRuzaq2vIXrof8lsb+omEcv6OWb/6+q8PkEQJzZmfYeYEpp0MlZfFg8WaJESgZJ2fn+Dsc0IK1btyY5OZnUVJspXBUhISG0bt3a32GYOuq1nzYyb8Nu/n5Od7bqSmZs9PDpdZfQyNPoQJnEzXt46Yf1/PntRLo0i+DGoZ04p3eLSlfu/27VTj5ftp07TutCe1/1riR9Cmu/gpGPQ3Qb39RpjioNOjkrWU6DwGwbc2ZqVVBQEO3bt/d3GMbUeyu3Z/Kvr1Yzskczrh7cjhu+WUfn6E70bnXwbMquzRtzaUJrPl+2nefnrOO2Dxbz1NeruX5IRy4e0LrMTclz9hfy909X0LlpBH8e4qO9KHP3wqy7oUUfGPhn39RpjjqWnAH7AgvJzMrwczTGGGMOR15BEX/9YDGRoUH848LegLOMxqltTy2zfKAngPP7tuLc3i35dtUupsxZx30zlnPfjOWU1cupOD2QH10/iODAKs6f27MZvpgA674p+7yq04059gPwNOg/waYCDfo3Iz70jy2c8vfu9HM0xhhjDsfTX69h1Y4sXr/yOGLCg0nJTmHv/r2VztQMCBBO696MEd2a8sv6dOZvSKe8KSc9W0VxXLuYyoMpKoT5L8GcxwCB46+H4HK6QVsfBy37VV6nabAadHJ28BZOu/wcjTHGmKr6dX06r/y4gXEntGXYsU0Bp9UMqPIyGiLC4E5xDO4UV3nhiuxYBjP/Aim/Q+eRcPZTNpbMHJEGnZzFhMQQgJDm8SA5NjDbGGPqg4zcAu74cDHtY8MPWhB2RdoKAgMC6dykiovAHqmCXPj+CfjlOQiLgYunQY8LbfalOWINOjnzBHiIaRRNWmAWQXnp/g7HGGNMFUycuYKdWfv55IYTCQv+48/YivQVdGnShWDPYSwSuzMJln4A5XZslkMVVv4P9myEfuPgtEecBM0YH2jQyRlAXFg8qZ4U2hXuIa+giJCgQ2fsGGOMqRs+W5rCjN+38dcRXejbJvrAcVVlRfoKRrYbeXgVzroLNv0EgY0qL1tak3Zw+UzoMOTwrzWmApachTUlNTCIBMkgNWs/bWJ8txebMab+EpEzgGcAD/Cqqj5R6vy/gWHuwzCgqapGu+eKgGXuuS2qakvA+8COjDzum7Gcvm2iuWnYwUtbJGclk5WfdXjbNu1Mgk0/woiJcNJffRqrMUfCkrPQOFZ7/tjCyZIzY4yIeIDngdOAZGCBiMxU1aSSMqr6V6/yfwG8p9/lqmrf2oq3IVBV7puxjPzCYv49qu8hi8ce7mQAABa8Cp5G0O9yX4ZqzBFr0Bufg7Ocxu4AiCGDdNslwBjjGAisU9UNqpoPTAfOr6D8GOD9WomsgZq1fAffrtrFHacfulL/tuxtvLrsVUIDQ+kU3alqFeZlOmPNel4E4bE1ELEx1dfgk7O40DiKBIIDM0mz/TWNMY5WwFavx8nusUOIyDFAe+A7r8MhIrJQROaJyAU1F2bDkJlXwMSZK+jRMpIrT2x30Ll52+cx+rPRpGSn8OSQJwnyBFWt0iXTIT8bBl7r+4CNOULWremudaaB2ZacGWNKlLUWQnnT+UYDH6tqkdextqqaIiIdgO9EZJmqrj/kJiLjgfEAbdu2PdKYj1r/+nI1adn7efWKhAPdmarKW0lv8XTi07SPbM8zpz7DMZHHVK1CVadLs2V/aDWgBiM3pnoafMtZfJizS0BB4H52Z+3zczTGmDoiGfBeRbQ1kFJO2dGU6tJU1RT33w3A9xw8Hs273FRVTVDVhPj4+CON+aiUuHkP78zfzBUntqN3a2d25r6Cfdw9926eXPgkw9sO592z3616YgawcS6krYaB19VQ1MYcmRpNzkTkDBFZLSLrROSeMs7fLiJJIrJURL51uwe8z0eKyDYRmVJTMXrvEpCbYbsEGGMAWAB0FpH2IhKMk4DNLF1IRLoCTYBfvY41EZFG7vdxwGAgqfS1pnIFRcXcN2MZzSNDuOP0rgBszdrKuFnj+HLTl9za/1aeGvIU4UHlbJNUngWvQGiMs2CsMXVQjXVrVmW2E/A7kKCq+0TkBuCfwCiv848AP9RUjPBHcpbm8VCUaftrGmNAVQtF5GbgK5ylNKap6goReRhYqKolidoYYLqqend5dgNeFpFinA/AT5R63zNV9OqPG1m1I4upfxpARKNAft72M3fNvQuAF0e8yOBWgw+/0oxtsOoLOPFmCArxccTG+EZNjjk7MNsJQERKZjt5T0Wf41V+HjCu5IGIDACaAV8CCTUVZGhgKBGeEHcLJ2s5M8Y4VPUL4ItSxx4o9XhiGdf9AvSq0eDque0ZuXy3ahfn9G5JVGjZA/i3pO/jmW/XMLJHM07r3oxXl73Ks4uepXOTzkweNpk2jau5d2Xi66DFkHD1ETwDY2pWTXZrVnm2k+saYBaAiAQATwF31lh0XuJCYkj1BBBoWzgZY0yNe/3nTdw3YzmDn/iOSV+uIjXr4MlYqsr9/11OYEAA95zVgTt+uINnFj3DGe3O4O0z365+Yla4HxLfgC4jndX9jamjarLlrMqznURkHE7rWMkeGDcCX6jqVqlgA1lfzXSKC2tGWuAGuuTvpqComCBPg58nYYwxNWZDajatokPp2zaal35Yz7SfNjL6uDaMH9KRVtGhzFySwtw1qdw6Mprbf7qGDRkbmJAwgcu7X05FfxMqlTQTclJtIoCp82oyOavSbCcRGQHcBwxR1ZKPT4OAk0XkRiACCBaRbFU9aFKBqk4FpgIkJCQc5q61f4gPb8ZyTyCDJJP07HyaR9k4BGOMqSkbUnPo3TqK58f2Z31qNi//sJ5352/h3flbuKBfK75fvYvO7bby4fbHCAzw8PJpL3NCixOO/MYLXoGYDtDh1COvy5gaVJPJ2YHZTsA2nNlOY70LiEg/4GXgDFU9MOBLVS/zKnMlzqSBQ2Z7+kpsaBxpHg/x7hZOlpwZY0zNKCgqZsvufZzZqzkAHeMj+OfFfbh1RBdembuB93/bBNHfkR/6NV0bd2XysMm0iqhoREwVbV8KW+fDyMchwHpHTN1WY7+hqloIlMx2Wgl8WDLbSURKNgH+F07L2EcislhEDpmqXhviw+LJDRAay15SbSFaY4ypMcl7ciksVtrHRRx0vFV0KBPP68FV56wmOH42Z3U4i7fOfMs3iRk4rWaBodB3bOVljfGzGt0hoLLZTqo6ogp1vAG84evYvMWHOos/SlAmaVmWnBljTE3ZmJYNcMj+mACrd69m+pq3OK/jeTw6+NEjG1/mLXcPLP0Iel8CoU18U6cxNcjadoHYUGfTWw3MIc02PzfGmBqzITUHgA6lkrOi4iIe/vVhohpFcddxd/kuMQNIfBMKc+E4mwhg6gdLzvij5azAk0daVp6fozHGmKPXhrQcmoQF0SQ8+KDjH675kKVpS5mQMIGoRlG+u2FGMsz9F3Q6DVr09l29xtQgS874Y5eAPYFCbmaan6Mxxpij18bUnEO6NHft28Uzi55hUItBnNPhHN/ecNbdUFwEZz/p23qNqUGWnAHRjaIJlADSPAEUZtouAcYYU1M2puUcMhngid+eoLC4kL+f8Hffdmeu/AxWfQZD77FFZ029YskZICLEBUeR6vGgtoWTMcbUiJz9hezIzKND/B8tZ99v/Z6vN3/N9X2up01kNVf+L0teJnxxJzTrCYNu8l29xtQCS85ccSExpHk8ePZZt6YxxtSEjWkHTwbYV7CPx+Y/RqfoTlzR4wrf3mzOY5C1Hc59Bjxl799pTF1lyZkrLqwZaR4PjfanU1Rc7c0GjDHGlKMkOWvvtpxNWTyFHTk7eHDQgwQF+DCB2pYI81+G466F1gm+q9eYWmLJmSs+oiWpgR5iJYPdObachjHG+NrGtBxEoF1sOCvSV/Duyne5tMul9G3a13c3KSqE/90KjZvD8AcqL29MHWTJmSsuLJ49Hg9N2Eua7RJgjDE+tyE1m5ZRoQR6lId+eYiYkBhuHXCrb28y7wXYsQzO/CeERPq2bmNqiSVnrpLlNEICLTkzxpiasDEthw7x4by38j1W7l7JPQPvITLYhwnUns3w/T+gy5nQ7Vzf1WtMLbPkzFWSnAUEZZJuuwQYY4xPqSob0nJoFpPLlMVTOLnVyZx+zOm+vAF8MQEQOOtf4MslOYypZTW6t2Z9UrJLQLFnH3us5cwYY3wqPSefrLwC1hZ+CMB9J9znuzXNioth3vOwdjaM/AdE+3BJDmP8wJIzV3yYk5zlB+aRasmZMcb41IbUHAIbL2fDvt+YkDCBVhGtfFNx2lpnAsDmn50tmgaO9029xviRJWeu2BBn8/PMwGIyMzL8HI0xxhxdVu7cSaNmM+kQ2YXLul125BUW5sPPk519M4PC4Lwp0G+cdWeao4IlZ64gTxDRnlDSPVnk7t3h73CMMeao8t8tryGB2Tw8eCKBAUf4p2frbzDzFkhdCT0uhDMnQURT3wRqTB1gyZkXZwundHbvTEZVfbvHmzHGNFBLUpewNnc24XlD6NO0V/Urys+BbybCb69AZCsY+yF0GemzOI2pK2y2ppe40Fh3l4DdbN2d6+9wjDGm3isoLuDhXx8moCiKnmGXHlllcx53ErPj/ww3zbPEzBy1LDnzEh/enDSPhzjJYEnyXn+HY4wx9d7bSW+zZs8a8nacR+f4+OpXpApJ/4UuZzjdmI0a+y5IY+oYS868xLlbODUNyGCpJWfGGHNEkrOSeXHxi5zQ7BT2Z3Y/sOF5texYChlbods5vgvQmDrKkjMvceHNKRChdeMcliTbjE1jjKkuVeXR+Y8SIAGc2fIG4I8Nz6tl1ecgAU7LmTFHOZsQ4KVkrbPGIZks35ZBUbHiCbBJAcYYU5YFOxbw1MKnKNbiQ84VFBewbu867hl4D3vTnaTsiFrOVn4GbQdBeFz16zCmnrCWMy8lWzgFsZ19+UVsSM32c0TGGFN3fbruUzZkbKBZWLNDvlpHtObKHlcyuutoNqblEBkSSEx4cPVutHsD7FoBx1qXpmkYrOXMS0lylrd/B43Zx5LkDDo3s0GnxhhTlsSdiQxuOZh/D/t3heU2puXQPj6i+ssTrfrC+ffYs6p3vTH1jLWceSlJztI8AZwYvN4mBRhjTDl25OxgW/Y2BjQbUGnZDanZR9alueozaNYLmrSrfh3G1COWnHmJCIogxNOI1MBARkZutEkBxhhTjsSdiQCVJme5+UWkZORVPznLToUt82yWpmlQLDnzIiLEhcaTFhFLf1nDypRM8gsPHehqjDENXeLORCKCIujSpEuF5Tal5wBHMFNzzSxA4dizq3e9MfWQJWelNAtvRkpIOG32JaFF+azekeXvkIwxps5J3JlIv6b98AR4Kiy3Mc1NzqrbcrbyM4huC816Vu96Y+ohS85K6RjVkfXFuQQU5dFDNtlOAcYYU0p6bjobMjbQv1n/SsuWzHqvVnK2Pws2fA/Hngu217FpQCw5K6VTk05kFeWxy+PhlJB1NinAGGNK+X3X7wAkNEuotOyGtBxaRIUQFlyNxQHWfQtF+61L0zQ4lpyV0im6EwDrY9pwSsh6ltqkAGOMOUjizkQaeRrRI7ZHpWU3puVUv0tz1WcQFgttT6je9cbUU5acldIxuiMAa2Pb0r0gibW7ssjNL/JzVMYYU3ck7kykT3wfgjxBlZatdnJWmA9rZkPXM6GScW3GHG0sOSslJiSGmJAY1odGEFa4h7a6nRUp1npmjDEAWflZrN6zukrrm+3OyWfvvoLqJWebf4L9GbYrgGmQLDkrQ+fozqzTPAASAlbbemfGGONavGsxxVpcpeRsY5ozGaBjfMTh32jlZxAUBh2GHv61xtRzlpyVoWN0R9bnpFAcGsPJjWynAGOMKZG4M5FACaR3fO9Ky25IreYyGsXFsPoL6DQcgkKrE6Yx9ZolZ2Xo1KQT+wr3sb11PwZ6VtukAGOMcSXuTKR7XHdCAytPmjam5RDkEVo3OcwEK+V3yNruLKFhTANkyVkZDszYjGtH84JkMtNSyMgt8HNUxhjjX3mFeSxPX16lLk1wWs7axoQR6DnMPzWr/gfigS6nVyNKY+o/S87KcGDGZlgkAAMC1rDMWs+MMQ3csrRlFBYXVml9MyiZqVmN8WarPod2J0Fok8O/1pijgCVnZYgMjqRpWFPWay7qaURCwBrbKcAY0+At3LkQQejbtG+lZYuLlY3pOXQ43D01U9dA2hroZl2apuGqxpLNVSciZwDPAB7gVVV9otT524FrgUIgFbhaVTeLSF/gRSASKAIeU9UPajLW0jpFd2JdxkakVX8GJ6/lOWs5M8Y0cIk7E+ka05XI4MhKy6Zk5JJfWHzoZICCPJh1F/z+Nmhx+RV0PfMIozWm/qqx5ExEPMDzwGlAMrBARGaqapJXsd+BBFXdJyI3AP8ERgH7gMtVda2ItAQSReQrVa215qtO0Z34YPUHFLU5m65bprB6687aurUxxodE5GbgXVXd4+9Y6rOCogKW7FrChZ0vrFL5kpmaHbyTs4xk+OBPkLII+v0JIluWfXFMR4hqfaQhG1Nv1WTL2UBgnapuABCR6cD5wIHkTFXneJWfB4xzj6/xKpMiIruAeKBWk7P9RfvZ1rQLbSmkaVYSqVnDiW/cqLZCMMb4RnOcD4eLgGnAV6qqfo6p3knanUReUd5BkwG+WrGD137cSFEZL2d69n4A2pd0a276GT66AgpyYdQ71m1pTAVqcsxZK2Cr1+Nk91h5rgFmlT4oIgOBYGB9GefGi8hCEVmYmpp6hOEerGTG5towZzBrQsBqW+/MmHpIVe8HOgOvAVcCa0XkcRHpWNF1InKGiKwWkXUick8Z5/8tIovdrzUistfr3BUistb9usLHT8kvFu1cBED/Zv0B+CQxmRveSSQ1ez+hQZ5Dvlo3CWPcCW2JDw+G+S/DW+dBSBRc950lZsZUoiZbzqSMY2V+WhWRcUACMKTU8RbA28AVqocOTlDVqcBUgISEBJ9+Ei6Zsbk+dyfD4o7luJ2rWZScwfBuzXx5G2NMLVBVFZEdwA6cMa5NgI9F5GtVvat0+aoMy1DVv3qV/wvQz/0+BngQ5z1NcYZlzKzL3aqp+1KZs3UOF3a+kMCAsv8sJO5MpF1kO+JC43h73mb+/ulyTuoUx9TLBxAWXM6fkoJc+O+NsOR96HImXPiyk6AZYypUky1nyUAbr8etgZTShURkBHAfcJ6q7vc6Hgl8DtyvqvNqMM4yhQWF0SqiFev2rCPgmEEkeNaxbGt6bYdhjDlCInKLiCTijGn9GeilqjcAA4CLyrnswLAMVc0HSoZllGcM8L77/Ujga1Xd7SZkXwNn+OCp1JhnFj3DI/Me4c4f7qSg6NA1HYuKi1i0cxEDmg3glbkb+Punyxl+bFNevSKh/MQscztMG+kkZkPvhdHvWWJmTBXVZHK2AOgsIu1FJBgYDcz0LiAi/YCXcRKzXV7Hg4EZwFuq+lENxlihjtEdWZexDtqeQAQ57Etejg1VMabeiQMuVNWRqvqRqhYAuK3x5e2qXeVhGSJyDNAe+K4a19bY0IyqysrPYvbm2bSPas83W77hljm3kFeYd1CZdXvXkVWQRVpaKx77YiVn927BS38aQEiQp/yKv34A0tbCmA9g6N0QYCs3GVNVNfa/RVULgZuBr4CVwIequkJEHhaR89xi/wIigI/ccRslydulwCnAlV5jOipfWMfHOkV3YmPGRgpaOwsudt6/guQ9ubUdhjHmyHwB7C55ICKNReR4AFVdWc41VR6WgfPB82NVLTrca1V1qqomqGpCfHx8OdXXrFkbZ5FbmMvjJz3Og4Me5OdtP3PjtzeSU5BzoMzCHQsB+Py3MC4e0JpnR/cjqKJV/zO2wYr/wICroGudbjQ0pk6q0XXOVPULnDdG72MPeH0/opzr3gHeqcnYqqJTdCcKiwvZGiC0CWtGQtZqlm3LoE1MmL9DM8ZU3YtAf6/HOWUcK61KwzJco4GbSl07tNS131ct1Nr3ydpP6NKkCz1ie9AzrichgSHc/9P9jP96PC+OeJGIwMa89fsciguiGZfQh4fO60FAQFn5p5ffXnbWMDv+z7XzJIw5ylg7cwUObOOUsY6AdoM4znYKMKY+Eu+lM9zuzMo+mFY6LANARLriTC741evwV8DpItJERJoAp7vH6pyV6StJSk/ios4XIeIkXOd0OIenhjxFUnoS1351LS/8uIT/Z+++46sq7weOf753ZO9BCAkJBAKyV4AgIC7cC8VN1VaLttU6WlutrXW1v2pr3VrcWgdaFcUtOAEB2XvPJIywsufNfX5/nJsQICQh5Obem3zffZ3Xufc5zzn3e2M4/eY5z8itWEVGxAAeuLAZiVllMSx8FfpeCLHp3v8SSrVDmpw1IiM6A0HYVLAJe9ooUmQvmzau83VYSqljs9kzKMDp2W4FNjd2QjO7ZYA1EGDqYcnffuBBrARvAfCAp8zvghUqpwAAIABJREFUvL/hfYLtwZybce4h5aeln8ZTpz7F5sLNvLDpVmyOEq4ZckpdAteoJW9AZSGMusVLUSvV/mly1ogQRwhdI7uyscAaFAAQumsBe0sqmzhTKeVHbgJOBPKwHjmOBCY3dZIx5jNjTC9jTA9jzN88ZfcaY6bXq3OfMeaIOdCMMS8bY3p6tlda7Zu0onJXOZ9t/ozx6eOJDj5yFOWYlDH8tt/D1EgJAFmdm7HYeY0L5j0LaaMgdVjT9ZVSDfJqn7P2oGdMTys5S+pPjTOc4a51fLM2n8uyujZ9slLK5zwjwa/wdRz+Zsa2GRRXFze6HNPS9fHIjl9z2/l2ukV1a/qiaz+Ggu1w5t9bL1ClOiBtOWtCj5gebC/aThVubN3HcKZjMV+vOlq/YKWUvxGREBH5jYg8KyIv126+jsvX3l//PulR6WQlNdwiVlhezacrdnJB3xFcP/C65j3SnPsMxHaH3ue0crRKdSyanDUhMzaTGlPDlsItyMArSGIf1Ru/p6K6pumTlVL+4L9Y62ueCXyPNXqy2KcR+djmws0szl/MxZkXHzXp+mhpHpUuN1eOSGveRbfPh9wFMOo3YGtk/jOlVJOalZyJyK0iEiWWl0RksYic4e3g/EHdMk4Fm6D3ObickZzL98zdpKsFKBUgehpj/gKUGmNeA84FBvg4Jp+atmEaDnFwQY8LGjxujOHtn3Lo1yWK/inNnNV/7lMQEgODr2rFSJXqmJrbcvYLY0wR1pDwRODnwD+8FpUf6R7VHYc4rH5nzhCk/8WcbVvA9yu3+Do0pVTz1K5HVCAi/YFooJvvwvGt6ppqpm+azsldTyYhNKHBOivyClmzs4grmttqtn8zrPkEsn4BQeGtGK1SHVNzk7Padu9zgFeMMctoeBbsdsdpd5IWlWYlZ4B9yNWESSW2NR/hdutSTkoFgOc98439GWuustXAw74NyXe+zfmW/RX7Gx0IMHVBDiFOGxcO7tK8i877D9gcMKLJQbBKqWZo7mjNRSLyFdb6cXeLSCTg9l5Y/qVnTE/W7Pes8tJ1BCXhaZxe9C0rdxQyMDXGt8EppY5KRGxAkWcB8h+ADB+H5HPvb3ifzuGdObHLiQ0eL610MX3pDs4d0IWoEGfTFyw/YM1tNuBSiEpu5WiV6pia23J2PXAXMNwYUwY4sR5tdgg9Y3qSW5xLuascRLANvooT7auZv3ipr0NTSjXCsxrAzb6Ow1/kleQxd8dcJvScgP0onfY/XbGTkkoXV4xo5nRBC1+B6lJrIIBSqlU0NzkbBawzxhSIyCSsxwOF3gvLv/SM7YnBsLnQmlQ8LMvq8Bq8+n++DEsp1TwzROT3ItJVROJqN18H5QvTNkwDYELPCUetM/Wn7fRIDCcrPbbpC7qq4KfnIeNk6Ny/dYJUSjU7OXsOKBORQcAfgG3A616Lys8cMmITIDadvJgsxpTNJO9AmQ8jU0o1wy+wFib/AVjk2Rb6NCIfqHHXMG3jNE5MOZHkiIYfP67fXczi7QVcMTytefOaLX8HinfqUk1KtbLmJmcuz9pxFwJPGGOeACK9F5Z/SYtMw2lzsvHAxroy59CryLDtYtm8GT6MTCnVFGNM9wa2Dtf37IfcH8gvy+eSzEuOWuedBTk47cLFQ1OavmDZfph5H6RkQc/TWi9QpVSzBwQUi8jdwM+AsSJix+p31iE4bA66R3evG7EJ0GnkZZR/czfBK9+Bsy/0YXRKqcaIyDUNlRtjOkzrf2VNJY8uepTUiFROTj254TquGj5YnMsZfTsTHxHc9EVn/AUqCuD8J6A5rWxKqWZrbnJ2OXAV1nxnu0QkDfin98LyPz1ierA0v94AgOBINsafQtbe7yguKSYyosM0JCoVaIbXex0CnAYspgN1zXhxxYtsK9rGlPFTcNob/rv6q1W7OVBWzeXDmzEQYOtsa4Tm6Nu0r5lSXtCsx5rGmF3Am0C0iJwHVHSkvzoBMmMy2Vm6k5Kqkroyx5AriZZSNsx6z4eRKaUaY4y5pd72S2AIEOTruNrK5oLNvLjiRc7NOPeo02cATF2wnZSYUMb0bHhi2jquSvj4NohJh3F/bOVolVLQ/OWbLgN+Ai4FLgPmi8hEbwbmb+oGBRRuqivLHHkuu4kjeNU7vgpLKXXsyoBMXwfRFtzGzf1z7yfMEcadWXcetd72fWXM2biPy4d3xWZr4hHl7Mdg3wY4798QFNbKESuloPmPNe/BmuMsH0BEEoGZQIdpMsqMse7lmwo2MShxEAAOp5OV8Wczbt/buAp34Yju7MsQlVINEJGPgdrlPGxAX+Bd30XUdj7c+CGL8xdz/4n3Ex8af9R605flIQKXZqU2fsE962HWo9B/IvQ8vZWjVUrVam5yZqtNzDz20fyRnu1CSmQKIfaQQwYFADiGXoVjxptsm/U66ef9wUfRKaUa8a96r13ANmNMrq+CaSv7yvfx6MJHGZY0rNF5zQB+WL+X/l2iSY4OPXolY+CT28EZCmf9XytHq5Sqr7kJ1hci8qWIXCci1wGfAp95Lyz/YxMbPWN6snrf6kPKhw4byTJ3D0JWd4g/xJUKRNuB+caY740xc4B9ItLNtyF53yMLHqHMVca9o+5tdM6ykkoXi7cfYGxmE33NlrwB22bD+AcgolMrR6uUqq+5AwLuBJ4HBgKDgOeNMR2uJ2hW5yyW71luLePkERniZGnc2SSVbYBdK3wYnVLqKP7HoWsB13jK2q0f837ksy2fccOAG8iIbnxKt3mb9uFyG8ZmJh69Uske+OrPkDYKhjQ4M4lSqhU1+9GkMeZ9Y8wdxpjbjTHTvBmUvxqZPJJqdzVLdi85pDxkyKVUGTsFc1/1TWBKqcY4jDFVtW88r9vtaM1yVzkPznuQblHduGHADU3Wn7VhD2FBdoamxxy90lf3QFUpnPc42DpUjxalfKLRf2UiUiwiRQ1sxSJS1FZB+ouhnYbisDmYt2veIeVjBvXmU3c24SvegOJdPopOKXUUe0Tkgto3InIhsNeH8XjVlGVTyC3J5d5R9xJsb3oy2Vkb9pKdEU+wo+GF0Nn4tbVM05jboNMJrRytUqohjSZnxphIY0xUA1ukMSaqrYL0F2HOMAYmDGT+zvmHlKfEhPJJ3HWIuxrz3cM+ik4pdRQ3AX8Ske0ish34I3Cjj2Pyio0HNvLaqte4qOdFDO88vMn6OfvL2Ly39Oj9zcoPwEc3Q3wmjP19K0erlDoabZ8+RtnJ2azZt4bCysJDyk/OHsGbrlNh8Wuwb9NRzlZKtTVjzCZjTDbWFBr9jDEnGmM2NnVeIPom5xtcxsXtw25vVv3ZG60GxKMmZ5/+Dkrz4eLnwRnSWmEqpZqgydkxGpk8EoNhwa4Fh5RfNCSFl2wTqSIIvnnQR9EppQ4nIn8XkRhjTIkxplhEYkXkIV/H5Q05xTkkhCYQFxLXrPqzNuwhOTqEHokRRx5c8R6sfB/G3QUpQ1s5UqVUYzQ5O0YDEgYQ6ghl3s5D+51FhjgZN7Q/L9acBaumwY4lR7mCUqqNnW2MKah9Y4w5AJzjw3i8Jqc4h66RzVgbE6hxG2Zv2MvYzIQjp9oozIVP7oDUETCmea1wSqnWo8nZMXLanWQlZR3R7wxgUnY6z1WdS7kzBmbe1/bBKaUaYheRup7xIhIKNN1TPgAdS3K2PLeAogrXkVNouN3w4a/A7YKLp4C9uXOVK6VaiyZnLTAyeSRbi7ayq/TQkZm9O0fSt3sqLzIBNn8Hm771TYBKqfreAL4WketF5HpgBvCaj2NqdRWuCvLL8kmNbGIJJo/ZG/YiAqMPX+h8/nOw5QdrFYC4xudIU0p5hyZnLZCdnA3QYOvZz7LTebp4HBVhXazWM7f7iDpKqbZjjHkEeAjogzUo4Asg3adBeUFeSR5As1vOZm3Yy4CUaOLC6035tns1zLwfep8DQ3WyWaV8RZOzFsiMzSQ2OLbB5OzMfp2JjIjkjbBJsHMprP7QBxEqpQ6zC2uVgEuA04A1vg2n9eUU5wDNS86KK6qPXLLJVQkfTIaQKDj/SWhkySellHdpctYCNrExInkE83fOxxhzyLEgh40rR3Tl//IGUhV/gjVys6baR5Eq1XGJSC8RuVdE1gBPAzmAGGNOMcY87ePwWt2xJGfzNu8/csmmb/8Gu1fABU9DRCNLOSmlvE6TsxYamTyS/PJ8thRtOeLYVSPTQOxMj78B9m+Gxa/7IEKlOry1WK1k5xtjxhhjnsJaV7Ndyi3OJdwZTmxwbJN165ZsSvPU3fYjzHkShl0Hvc/ybqBKqSZpctZC2Z2P3u8sOTqU0/t04u8b03GnjoTvH7bWpVNKtaVLsB5nfisiL4jIaUC7fVZXO1LziGkxGlC7ZFOQw2Y9zpz+W4hJgzP+1gaRKqWaoslZC6VGptIlvAvzdsxr8PjPsruxv6yaWd1uhpLdMPfZNo5QqY7NGDPNGHM5cALwHXA7kCQiz4nIGT4NzguaO41Gzv4yttRfsmn2Y7BvA5z3bwhuYDJapVSb0+SshUSEkckjWbB7ATXuI5+UnNgjnoyEcJ5YHw99LoAfHrFGQiml2pQxptQY86Yx5jwgFVgK3OXjsFpVjbuGvJK8Zk2jMWtD7ZJNibBnPcx6FPpPhJ6neztMpVQzeTU5E5GzRGSdiGwUkSNuhiJyh4isFpHlIvK1iKTXO3atiGzwbNd6M86Wyk7OpriqmDX7jxz4ZbMJV2ens3h7AWuG3Qch0TBtMriq2j5QpRQAxpj9xpgpxphTfR1La8ovy6faXd2slrNZG/bQJTqEHglh8Mnt4Ay15jRTSvkNryVnImIHngHOxppb6EoR6XtYtSVAljFmIPAe8Ijn3Djgr8BIYATwVxFpupdrGxuRPALgiKWcak0cmkqI08bry0vh/Cdg1wr4/h9tGaJSqgOoHamZGtF4y1mN2zBn417GZiYiy96CbbNh/AMQ0aktwlRKNZM3W85GABuNMZuNMVXAVODC+hWMMd8aY8o8b+dhPXIAOBOY4fkr9wDWjN5+N4QoITSBnjE9GxwUABAd5uSiwSl8uGQHhelnwOBJVv+O7Q3XV0qplmjuNBq1Szadlm6Dr/4MaaNgiE42q5S/8WZyloI1r1CtXE/Z0VwPfN7Cc30mOzmbJflLqKypbPD4pOx0yqtreG9RrvXoIDoVpt0IlSVtHKlSqr3KKc7BIQ46h3dutN4sz5JN47Y8Yd2DznscbNr1WCl/481/lQ2N5zYNlCEik4As4J/Hcq6ITBaRhSKycM+ePS0O9HiMTB5JZU0ly/KXNXi8f0o0WemxvDhrMxX2cLjoOTiwFWb8pW0DVUq1WznFOXSJ6ILD1vgi5bM27GFS4maCV78LY26DTie0UYRKqWPhzeQsF6jfxp4K7Di8koicDtwDXGCMqTyWc40xzxtjsowxWYmJvpnROispC7vYj9rvDOB3Z/RmZ2EFr8/dCt3GwKjfwMKXYcOMNotTKdV+NWcajeKKalZtz+eOyv9AXA8Y+/s2ik4pday8mZwtADJFpLuIBAFXANPrVxCRIcAUrMQsv96hL4EzRCTWMxDgDE+Z34kIiqBfQj/m7zp6P7JRPeIZ1yuRZ77dRGF5NZz6F0jsAx/dDGX72zBapVR7Y4whtzi3yWk05m7ax69tHxBbmQvnPQbOkDaKUCl1rLyWnBljXMDNWEnVGuBdY8wqEXlARC7wVPsnEAH8T0SWish0z7n7gQexErwFwAOeMr80svNIVu5dSXFV8VHr/OGs3hSWV/Of7zdZN8WLp0DZPvj0DjANPu1VSqkmFVYWUlxd3GTL2doVC7jR/gk1A66AjHFtFJ1SqiW82hPUGPOZMaaXMaaHMeZvnrJ7jTG1SdjpxpgkY8xgz3ZBvXNfNsb09GyveDPO4zWqyyjcxs3CXQuPWqdfl2guHNyFV+ZsYXdRBSQPgpPvglXTYMX/2jBapVR70tyRmv02TKHaFoz9rL+3RVhKqeOgw3RawaDEQYTYQxrtdwbwu/G9qXEbHp+5wSoYfRt0zYaPb4Wdy9sgUqVUe9Oc5GzHtvWMc81hc9pECI9vq9CUUi2kyVkrCLIHkZ2czcxtM3G5XUetlxYfxtUj03l3YQ6b9pSA3QGXvQ6hsfD2lVCSf9RzlVKqIXUT0DbS56zw26cAiBx3c5vEpJQ6PpqctZKLel5Efnk+P+74sdF6N5/akxCHjUe/WmcVRCbBFW9Z/c/emQSuhudLU0qphuQU55AYmkioI7ThChWFdNv2Ht/YR5PWvVfbBqeUahFNzlrJSaknERcSx7QN0xqtlxARzA1jM/hsxS6W5RRYhV0Gw4TnIGe+tdadDhBQyueaWhvYU+cyz/rAq0TkrXrlNZ5BTnUDnbylqWk0aha9TqgpY233axBpaApJpZS/0eSslTjtTs7POJ/vcr5jX/m+Ruv+8qQM4sOD+MfnazG1iVi/CTDuj7D0TZj7TBtErJQ6muasDSwimcDdwGhjTD/gtnqHyxsa6OQNjU6jUePC9eNzzHefQMagMd4MQynVijQ5a0UTMifgMi4+2fxJo/Uigh3cfGpP5m7exw8b9h48MO4u6HOBtXqATlCrlC81uTYw8EvgGc/6vxw2V2ObqHBVkF+ef/SWs9UfElyax4s15zK6R0LbBqeUajFNzlpRj5geDEwcyLQN0w62iB3FVSPT6BoXysOfr8Xt9tS12WDCfyCpH7z3C9izrg2iVko1oDnr+/YCeonIHBGZJyJn1TsW4llabp6IXOStIPNK8oCjjNQ0BuY+TZ49hT2dTyY2PMhbYSilWpkmZ61sQs8JbCrcxIq9KxqtF+yw87vxvVm9s4iPl9dbmSooHK54GxzB8PYVuoKAUr7RnPV9HUAmcDJwJfCiiMR4jqUZY7KAq4DHRaRHgx9ynOsDNzpSc9uPsGMJz1WeyZheScd8baWU72hy1srO6nYWoY5QPtjwQZN1LxjUhX5dovj7Z2soLKs+eCCmK1z+JhTmWiM4q8u9GLFSqgHNWd83F/jIGFNtjNkCrMNK1jDG7PDsNwPfAUMa+pDjXR+40TnO5j5DVVAM77nGMjZTH2kqFUg0OWtlEUERjE8fzxdbv6CsuqzRujab8I+LB7K3pIoHP1196MG0kdYjzm0/wrvXgKvKi1ErpQ7T5NrAwIfAKQAikoD1mHOzZ03g4Hrlo4HD/oG3jpziHMKd4cQGxx56YN8mWPcZP8ZeiC0ojCFpsQ1fQCnllzQ584IJPSdQWl3KzO0zm6w7IDWam8Zl8N6iXL5dd1h/4v6XWAsUb/gKpt0I7hovRayUqq+ZawN/CewTkdXAt8Cdxph9QB9goYgs85T/wxjjteSsa2TXI6fImPsM2J08WXQyozLiCXLorV6pQKL/Yr1gWNIw0iLTmvVoE+C3p2WS2SmCu99fQVFF9aEHs34O4x+EVR/oHGhKtaFmrA1sjDF3GGP6GmMGGGOmesp/9Lwf5Nm/5K0Yc4tzj3ykWbYflr5FSe9LWHwgWB9pKhWANDnzAhFhQuYEFu1exLaibU3WD3bY+delg8gvruDvn645ssLo38LY38Pi16xpNjRBU6rDq3HXkFvSwBxnC14CVznfxV0KwNhex96XTSnlW5qcecn5GedjExsfbvywWfUHdY1h8kk9mLoghx/WNzBq69Q/w4jJ8ONTMOtfrRytUirQ7C7bjcvtOrTlzFUJPz0PPU7jk50xpMSEkpEQ7rsglVItosmZlySFJzEmZQzTN05vdDH0+m47PZMeieHc/cEKig9/vCkCZz0Mg66Ebx6C+c97IWqlVKBocKTmmo+hNJ+a7N8wZ9NexmYm6JJNSgUgTc68aELPCc1aDL1WiNPOPy8dxM7Ccv7v87VHVrDZ4IKn4YTz4PM7YckbrRyxUipQNJic7dsIwFLHAIorXIzN1EeaSgUiTc68aFzquGYthl7f0LRYrh/Tnbfmb2fOxr1HVrA7YOLL0ONU+Og38NMLrRixUipQ5BTn4LA56BzW+WBhST6ExjFrUwEicGKPeN8FqJRqMU3OvMhpd3JexnnNWgy9vt+d0ZuMhHD++P5ySisbeCTqCLZWEeh9Dnz2e5j9eCtGrZQKBDnFOaREpGC32Q8WluyGiCRmb9jLwJRoXbJJqQClyZmXTejZvMXQ6wtx2nlk4kDyCsp56PDJaWs5Q+Cy16H/RJj5V/j6QR3FqVQHklvcwEjNknxcYQksySnQR5pKBTBNzrysZ2xPhnQawhtr3qCyprLZ52V1i+OmcT14+6cc3luU23AluxMufh6GXmON4PziLnC7WylypZS/MsZYE9BGHDbHWWk++SaaGrfR+c2UCmCanLWBXw/+NbtKd/HuuneP6bzfje/FqIx47pm2glU7ChuuZLPD+U9C9m9g/n/g41t0JQGl2rmCygJKqksOHQxgDJTks6U8nPAguy7ZpFQA0+SsDWQnZzMyeSQvLH+B0urSZp/nsNt46qohxIYFcdMbiw5dHL0+ETjzbzDuj9YIzvdvgJqj1FVKBbwGR2pWlUB1GSsKghnVQ5dsUiqQ6b/eNnLrkFs5UHmA/67+7zGdlxARzLOThrKrsILb3lmC232UfmUicMqfYPwD1lJPb10OFUWtELlSyt80mJyVWGvzri8N0/5mSgU4Tc7ayIDEAZza9VReW/UaBRUFx3Tu0LRY7j2vL9+u28PT325svPLoW63HnJu/g5fPhILtLQ9aKeWXcoutfqgpkSkHCz3J2V6iGaP9zZQKaJqctaFbhtxCaXUpL6089nWQJ2Wnc/GQFB6buZ7v1uU3XnnYtTDpfSjMgxdOg9xFLYxYKeWPcopzSAxNJNQRerCw1LovVIUk6pJNSgU4Tc7aUM/Ynpzf43zeXvs2u0t3H9O5IsLfJgygd1Ikt05dSs7+ssZP6HEK3DADnKHw6jmwqnlrfCql/F9Occ6hjzShruUsOSVdl2xSKsBpctbGfjXoV9SYGqYsn3LM54YG2fnPpGG4jeFXby6iorqJUZmJveGGr6HzQPjftTDr3zoXmlLtQENznFUc2EmNEXqkp/koKqVUa9HkrI2lRqYyMXMi0zZMY3vRsfcH65YQzmOXDWZlXhF3vb/86AMEakUkwrUfQ/9L4Ov7YfrN4KpqYfRKKV+rcFWQX55/RMvZgT257CeKwena30ypQKfJmQ/cOOhGnHYnTy99ukXnn943iTvP7M2HS3fwwCerMU21hjlD4JKXDk618foFULSjRZ+tlPKt2sEAhydn5ft3sMfEMLBrtC/CUkq1Ik3OfCAhNIGr+1zN51s+Z93+dS26xq9P7sH1Y7rz6o9befLrJkZwwsGpNi55CXYuh/+MtUZ0KqUCSoPTaACU5FPmjCMqxOmDqJRSrUmTMx+5rt91RAZF8tSSp1p0vohwzzl9uGRoKo/NXM+rc7Y078QBE2HytxCeAK9fBN8/oks+KRVAGkrOjDGEVu2DiE6+Cksp1Yo0OfOR6OBoftH/F3yf+z1L8pe06Bo2m/DwJQMY3zeJ+z5ezYdL8pp3YmJv+OU3MPAy+PZv8OZEKN3XohiUUm3r6j5X8+UlXxITHFNXtn1fKXGmgNC4Lj6MTCnVWjQ586GrTriKhNAE/vHTP6h2t2y5JYfdxlNXDmFURjy/+98yvl7TzCk6gsJhwhQ473HYOhumjIWcBS2KQSnVduw2O10iuhwyXcbKzTkEi4v4pNRGzlRKBQpNznwozBnG3SPuZvW+1by04tgnpq0V4rTz/DXD6Jscxa/fXMz8zc1sBROBrJ/D9V+BzQGvnAVzntCF05UKMFu2bgYgsXPXJmoqpQKBJmc+dka3Mzin+zlMWTaF1ftWt/g6kSFOXv35cFJiQ7nhtYWszCts/sldBsONP0Dvs2HGvfDqubB/c4tjUUq1rZ151rQ89qgkH0eilGoNmpz5gT+N/BNxIXHcM/seqmpaPgdZfEQwb1w/kqhQJ1e9MI/F2w80/+TQGLjsvzDhedi9Gp4bDQte1ElrlfJzFdU1lOzzTI0TocmZUu2BJmd+IDo4mvtOvI+NBRt5Zukzx3WtLjGhvHNjNrHhQUx6cT4/btzb/JNFYNDl8Ou5kJYNn/4O/jsBCnOPKyallPes3llEnPH8IabJmVLtgleTMxE5S0TWichGEbmrgeMnichiEXGJyMTDjj0iIqtEZI2IPCntfLG4saljuSTzEl5d9SpL85ce17VSY8P4342jSI0N5bpXFzBz9bGt40l0Ckz6AM79N+T8BM+eCEvf1lY0pfzQku0FJEohxuaAkJimT1BK+T2vJWciYgeeAc4G+gJXikjfw6ptB64D3jrs3BOB0cBAoD8wHBjnrVj9xZ3D7yQ5PJl7Zt9DWXUTC5s3oVNUCO9MHsUJnSO56Y1FTF92jCsCiMDw6+FXsyGpL3x4E7x1Gexv5nxqSqk2sTSngLSgEiS8E9j0YYhS7YE3/yWPADYaYzYbY6qAqcCF9SsYY7YaY5YDh8+CaoAQIAgIBpzAMTb/BJ5wZzgPjn6Q7cXbeWLxE8d9vdjwIN68YSRD02O5deoSpv507Gt5EpcB130KZ/4fbPsRnhkJ3/0DqiuOOz6l1PFbsv0A3UJKdAJapdoRbyZnKUBOvfe5nrImGWPmAt8COz3bl8aYNa0eoR8a3nk4k/pM4q21bzFv57zjvl5kiJPXfj6CkzITueuDFbw4qwWjMG12GPVruHkh9DkPvvs/eHYkrP/quONTSrXc3pJKcg+U09lWpMmZUu2IN5OzhvqINavTkoj0BPoAqVgJ3akiclID9SaLyEIRWbhnz57jCtaf/Hbob+kW1Y1759xLcVXxcV8vNMjOC9dkcc6Azjz06Roe/mItNe4W9B+LSoaJL8M1H4E9CN66FKZeDQUtaJFTSh23pdsLAIhyH9DkTKl2xJvJWS5Qf0bEVKC5HZ8mAPOMMSXGmBLgcyD78ErGmOeNMVnGmKzExMTjDthfhDpCeWgEeJaLAAAgAElEQVTMQ+wu282D8x7EtEJH/CCHjSevGMKVI9J47rtN/PL1hRSWt2xVAjJOhpvmwOn3waZv4OkR1qPOyuNPJJVSzbck5wAOm8FZvldHairVjngzOVsAZIpIdxEJAq4Apjfz3O3AOBFxiIgTazBAh3isWWtQ4iBuGXILn2/5nCnLp7TKNR12G3+f0J+HLurPD+v3MOGZOWzMb2FC5QiCMbfDb36CXmdajzqfGAzzp4CrslXiVUo1bmlOAcM7gZgaCNeWM6XaC68lZ8YYF3Az8CVWYvWuMWaViDwgIhcAiMhwEckFLgWmiMgqz+nvAZuAFcAyYJkx5mNvxeqvru9/PRf0uIBnlj7DF1u+aJVrigiTstN565fZFFVUc9EzPzLjWKfaqC+mK1z2GtzwDXTqA5//AZ7OgmXvgPvwcR5KqdZS4zYsyylkVJJnuTV9rKlUu+HVcdfGmM+MMb2MMT2MMX/zlN1rjJnueb3AGJNqjAk3xsQbY/p5ymuMMTcaY/oYY/oaY+7wZpz+SkT466i/MrTTUO6ZfQ/L9ixrtWuP6B7H9JvHkJEYzi9fX8gTMzfgbkk/tFqpw+Daj6350UJiYNpkazH19V/p/GhKecGmPSWUVLoYHOtZVUSTM6XaDZ0Ux88F2YN4/JTHSQpP4rff/Ja8krxWu3aXmFDevXEUFw9N4bGZ67npjUWUVLpafkER6HkaTP4eLnkJqkqtQQMvng5rPtaWNKVa0RLP8my9I8qtAu1zplS7oclZAIgNieXp056m2l3NzV/fTElVSatdO8Rp59FLB3HveX35em0+5zwxi4Vb9x/fRW02GDDR6o927r+hdA+8MwmeGQGLX9c+aUq1gqU5BUSFOEgUa8Smtpwp1X5ochYgMqIz+PfJ/2Zr4VZ+/8PvcbmPo4XrMCLCL8Z0Z+rkbAyGy6bM5eEv1lLpqjm+CzuCrFUGbllstaQ5Q2H6LfDEIJjzBFQUtc4XUKoDWrK9gEFdY7CV5oM9GIKjfB2SUqqVaHIWQLKTs7kn+x7m5M3hkQWPtPr1h3eL4/NbT+Ly4V157rtNXPj0HNbsbIUEyu6wWtJu/AF+Ng0SesGMe+GxfvDlPbBv0/F/hlIdSGmli/W7ixmSFgsle6xHmu17+WGlOhRNzgLMxF4Tubbvtby99m1eX/V6q18/ItjB/108kJeuzWJvSRUXPD2b577b1LJJaw8nAj1OhWunw+TvoOfpMP8/8NRQ+O8EWPMJ1LRei6BS7dXy3ELcBoZ0jYGS3fpIU6l2RpOzAHT7sNsZnz6efy78p1cSNIDT+iTx1e0ncXqfJB7+Yi2XT5nLlr2lrfcBXYbApa/A7avglD/DnnXwztXwxED4/hEo3tV6n6VUO7MkxxoMMLhrjNWnU5MzpdoVTc4CkN1m5+GTHq5L0F5e+bJXPicuPIhnrx7K45cPZt3uYs587Ace/mItpcczovNwkZ1h3J1w63K44i1I7A3f/s165Pn2VbD6I11kXanDLN1eQLf4MGLDg7TlTKl2SJOzAOW0OXnkpEc4u9vZPLboMaYsa51VBA4nIlw0JIWv7xjHeYOSee67TZz26Pd8tDSvVZaVqmN3wAnnWn3SblkM2b+CvEXw7jXwaC+Y/lvYOken41AdnjGGJTkFVn+zGheU6tJNSrU3mpwFMIfNwd/H/p3zM87n6aVP8+zSZ1s3YaqnU1QI/75sMO//ahQJkUHcOnUplz8/r3UGDBwuvgec8RDcsdqa1LbX2bDiPXj1HGuk59cPwq6VOrmt6pB2FFawp7jSeqRZtg8wEN5+1hZWSoHD1wGo4+OwOXhw9IPYbXaeW/YcLreLW4bcgnhp5Naw9Dg++s0Y3lmQwz+/XMu5T85iUnY6t5/ey3rE0ppsdmtS256nQeWjsPZTWP4OzP43zPoXxHaDE86zWty6jrTqK9XOLd1uzWs2uGsMlGy3CrXlTKl2RZOzdsBus3P/iffjsDl4YcULVLuruWPYHV5L0Ow24aqRaZwzoDP/nrGeN+Zt44PFefx8dDduGJNBdJiz9T80OAIGXW5tJfmw7jNrdOdPz8PcpyEsAXqfbSVr3U+CoLDWj0EpPxAWZGdsZgJ9kqNgS75VqMmZUu2KJmfthE1s/CX7L9jFzqurXqW0upS7R9yN0+6FRMkjJiyIBy7sz6TsdB6fuZ6nvtnIq3O28osx3fnFmO5Eh3rpsyM6wbDrrK2iCDbOhLWfwKoPYcl/weaE1CzoNha6j4XUEeAM8U4sSrWxU07oxCkneAYAlNYmZ/pYU6n2RJOzdsQmNu4ZeQ8RzgheWvkSmws38+i4R4kPjffq5/ZKiuTZq4exZmcRT8zcwBNfb+CVOVu4fkwGPx/TjagQ7yWIhERB/4utzVUJW2fDlu9hyyzr0ecPj1izp6cOtxK19BOhy1CrJU6pQFey29qH62hNpdoT8VYH8raWlZVlFi5c6Osw/Manmz/lrz/+ldiQWJ445Qn6xvdts89etaOQx2duYMbq3USHOrl2VDqTRqXTKbKNW68qCmHbXNg6y9p2LgcMiB2S+ln91LqOhK4jICZNZ1gPQCKyyBiT5aVrnwU8AdiBF40x/2igzmXAfYABlhljrvKUXwv82VPtIWPMa019XovuYV/8CRa9CvfsOLbzlFI+19j9S5OzdmzVvlXc9u1tFFQUcP+J93NOxjlt+vkr8wp54usNzFyzG4dNOH9gF34xpjv9U6LbNI465QWQuxBy5ltb7kKo9kysG9EZUoZByhCrZa3LEAiL802cqtm8lZyJiB1YD4wHcoEFwJXGmNX16mQC7wKnGmMOiEgnY0y+iMQBC4EsrKRtETDMGHOgsc9s0T3sveutKWduXXps5ymlfK6x+5c+1mzH+sX3Y+q5U7njuzv446w/svbAWm4dciv2NhrV2D8lmheuyWLr3lJe/XEr/1uYwwdL8hjRLY5fjOnG+L6dsdvasLUqNAYyT7c2sOaIyl/tSdZ+gh2LYd2nB+vHdreStJSh0KmvNUFuVIq2sHUMI4CNxpjNACIyFbgQWF2vzi+BZ2qTLmOMpwMYZwIzjDH7PefOAM4C3m71KEt262AApdohTc7aufjQeF4840UeXvAwr6x8hfUH1vPw2IeJDm671qtuCeHcd0E/7jijF+8uyOHVH7dy0xuLSY0N5YrhXbloSAqpsT4YXWl3QPJAaxvxS6usvAB2LoUdSyBvMeQugFUfHDwnKMJauD2x98F9fE9rWg9HcNt/B+UtKUBOvfe5wMjD6vQCEJE5WI8+7zPGfHGUc1O8EmXpHkjI9MqllVK+o8lZB+C0O/lz9p/pHdebv8//OxM/nsiDox8kOzm7TeOICnFyw9gMfj66OzNW7+aVOVv411fr+ddX6xnRPY5LhqZw9oBk7w4gaEpoDGScbG21SvfCnrWebT3sXQebv4dl9RtCBKK7QnwGxPWAuAxrMt3YbhCTrlN7BJ6GmkcP7wPiADKBk4FUYJaI9G/mudaHiEwGJgOkpaUde5Qlu6HbmGM/Tynl1zQ560Au7XUpJ8SewJ9m/4lffvVLrjzhSm4fdjuhjtA2jcNuE87q35mz+ncmZ38ZHy7JY9qSPP74/gru/WgVp/dNYsLgFE7qlUiQww8WsQhPgPAxR/6fYEUh7N0A+zbB/s2wf5P1euV71rFDrtEJYtMPJmux6RCZbM3sHtHJ2ntx2hN1zHKBrvXepwKH97rPBeYZY6qBLSKyDitZy8VK2Oqf+11DH2KMeR54Hqw+Z8cUoasKyg/oY02l2iEdENABlbvKeXLxk7yx5g3So9J5aPRDDO402KcxGWNYllvItMW5fLx8J/tLq4gMdjCudyLj+yZxcq9O3pnc1lvK9luJWsE2OLD14P7ANijMBVNz5DmhsVYSF1G7JXmSt6SDZeGdrNY9R4j2fcOrAwIcWAMCTgPysAYEXGWMWVWvzllYgwSuFZEEYAkwmIODAIZ6qi7GGhCwv7HPPOZ7WGEePNYXznscsn7e/POUUn5BBwSoQ4Q6QvnjiD9yStdT+Mucv3DtF9fy834/59eDf02QvZWXYGomEWFw1xgGd43hz+f1ZdaGPXy1ajcz1+TzyfKd2G3CiG5xnN43ifF9kkiL9/PHhGFx1tZ1+JHHalxQlGc9kirJtyYSLdnj2Xu2HUussqrihq9vc0BwpGeLOvg6JMb63NBYCPXEEBpjva6rFwHOME3uGmGMcYnIzcCXWP3JXjbGrBKRB4CFxpjpnmNniMhqoAa40xizD0BEHsRK6AAeaCoxa5HaOc605Uypdkdbzjq4kqoS/rnwn3yw4QN6xfbigdEP0C++n6/DquN2G5blFjBzzW5mrs5n3W4rWemeEM6oHvGMyohnVI94EiLaaWf8qlJPArfnYDJXWQSVxYdtRdZqCeUHrK2yiQXpxQZBkQeTteAoa0Lf2n1ItOd1tNVK5wy1Bjw4Qhre24M97z1lbTQi2JvznLW1Y76Hrf8S3roMbvgGUod5LzCllFfoPGeqSd/nfM99c+9jX/k+Ls68mJuH3ExCaIKvwzrC9n1lzFyzmx837WX+5v0UV7oA6J0UaSVrPeIZ0S2u9RdhDzQ11dbI0/L91iPW8gNWEldVm8yVQFXJkcld7b6iEGoqW/75YrcSNLFbiWDdJla5I9RK+ILCrFY8Z5jnfThk/8qawqQ5H9ORk7PFr8P0W+C2FdYkykqpgKKPNVWTxnUdx/Sk6UxZNoU3177JF1u/4KaBN3F1n6u9uj7nsUqLD6tbu9NV42bljiJ+3LSXuZv2MXXBdl79cSsAPTtFkJUey7D0WIZ3iyM9PsxrC8H7JbvTWm/xeNZcdFVaiZqrot5Wae2rK8BVbr2vqfIcqzpYp6YS3DVg3J7NHHztdnmuUQZVZda+ogCKd1othYOvar2fQ3umSzcp1W5py5k6wtbCrfxr4b/4Pvd70qPSuTPrTk5KPcnvk5tKVw3LcgpZsHU/C7fuZ9G2AxRVWC1rCRFBDEuPZWBqDH2To+iTHEVSVLDffyfVuA7dcvbZH2DZVLh7u/eCUkp5jbacqWPSLbobT5/2NLPzZvPIgke4+ZubObHLidwx7A56x/X2dXhHFeywM6J7HCO6W8suud2GjXtKWLB1P4u2HmDhtgN8uWp3Xf248CD6JEfWJWuZnSLplhBGpC/nWVOquUp2WyN4lVLtjiZn6qjGpIxhZPJI3ln7Ds8ue5aJH0/klK6nMHngZPon9Pd1eE2y2YReSZH0Sork6pHpABRVVLN2ZzGrdxSyZmcxa3YV8drcbVS53HXnJUYG0z0hnB6J4XRPCKd7QgTp8WF0jQ0jNKhtOror1aSSfB2pqVQ7pcmZapTT5mRS30mc3+N83lr7Fm+sfoMrP72S0V1GM3ngZIYmDW36In4kKsR5SOsagKvGzZa9pWzaU8rmvSVs2VPKlr2lfLVqN/tKqw45v1NkMGlxYaTFhdHVs+8SE0pydAido0MIcWryptpIaT50HuDrKJRSXqDJmWqW6OBofjXoV/ysz894Z907vL76da794lqykrKYPHAy2cnZAdt/y2G3kZkUSWZS5BHHCsuq2by3hO37y8jZX8Z2zzZ/y36mLc3j8C6bMWFOOkeFeJK1UBIjg0mICCI+PJj4iKC619GhTmxtuei7an+05UypdkuTM3VMIoIiuH7A9VzV5yreX/8+r6x8hckzJnNC3Alc2utSzs04l3BnuK/DbDXRYU6GpMUyJC32iGOVrhryDpSzq7CCnYUV7CqqYGdhObsKK9lVVM6KvEL2lVYdkcCBtYRVbFgQceFO4sKthC023ElceDDx4UFEhzqJDHEQFeokKsRJVKiDyBAn4UH2gE2CVSuqLremPdE+Z0q1S5qcqRYJdYQyqe8kLut9GR9t+oh31r7Dg/Me5NGFj3Jexnlc1vsyvx480BqCHXYyEiPISIw4ap0at+FAWRX7SqrYV1LJnpJK63VpJftLq+q2NbuKOFBaRUF5dYPJXC27TYgIdhAR7CAyxNoigh1EhFjJXJjTTliQnbBgB2FBdkKddsKCrNchTjuhQXZCnDZCHJ7XDjshQTaC7DZN+gJJSb6112k0lGqXNDlTxyXIHsSlvS5lYuZElu9dzrvr3uWjTR/x7vp3GZQ4iMt6X8b49PFtvri6v7DbhISIYM8KBkc+Nj2cq8ZNQXk1ReXVFFe4KKqopqi8dl9NUUU1JRUuiitcFFe6KKlwsbekii17SymucFFWVUN5dQPrdjZDsMNGkMNGsMNOsMNGsNNK2uqXBzmssiBHvc1uw2kXnHYbTs8xp11w2Dx7uw2HzTru8NRz2A6WW68Fu816nxYfRpSOmG1cbXKmjzWVapc0OVOtQkQYlDiIQYmD+MPwPzB903TeXfcu98y+h4fmPcRJqSdxZrczGZMypsMmas3hsNvqJXMt43YbKlw1VqJWZe3LqlxUVLupqK6hotpK4Mqra+rKKqtrqKxxU1ntptLlptJVQ5XLel3leV9W5aKg3Hpft9UYqmvc9bbjnzfx+Z8N44x+nY/7Ou1aaW1ypi1nSrVHmpypVhcdHM3P+v6MSX0msXD3Qr7Y8gUzt8/ky61fEuoI1UTNy2w28TzKbPt/3sYYqmsMVTVuXJ5kzeV24/IkcS63ocrlpsZtcLkNrpp6rz31BneNafO4A07doueanCnVHmlyprxGRBjeeTjDOw/n7pF3s2j3Ir7a+tUhidqo5FGMThnNmJQxdIno4uuQ1XESEYIcQpDD5utQ2re6PmfHsTyXUspvaXKm2oTD5mBk8khGJo+sS9RmbJvBD7k/8E3ONwBkRGfUJWrDkoYRbG/5oz2l2rWSfAiLt9ZQVUq1O5qcqTZXP1EzxrClcAuz82YzO282U9dO5b+r/0uIPYTBnQYztNNQhiQNYWDCQMKcYb4OXSn/ULJbR2oq1Y5pcqZ8SkTIiMkgIyaDa/pdQ1l1GQt3L2RO3hwW7V7Ec8uew2Cwi50+cX0YkjSEoZ2G0j+hP0lhSTr9g+qYSvK1v5lS7ZhXkzMROQt4ArADLxpj/nHY8ZOAx4GBwBXGmPfqHUsDXgS6AgY4xxiz1ZvxKt8Lc4ZxUupJnJR6EgDFVcUszV/KkvwlLM5fzDtr3+G/q/8LQFxIHCfEncAJcSfQJ74PfeL60DWyKzbR/k6qnSvNh9Thvo5CKeUlXkvORMQOPAOMB3KBBSIy3Rizul617cB1wO8buMTrwN+MMTNEJAJwN1BHtXORQZGMTR3L2NSxAFTVVLF632pW71vNmv1rWLt/La+vfh2X2wVAuDOc7lHd6RrVlbTINNKi0ur2scGx2tKm2gddukmpds2bLWcjgI3GmM0AIjIVuBCoS85qW8JE5JDES0T6Ag5jzAxPvRIvxqkCSJA9iMGdBjO40+C6sqqaKjYWbGTt/rWs2beGbUXbWL5nOV9u/RK3OfirFeGMoEtEF7qEd7H2EV1IDk+u28eFxGnypvxfZQlUl+ljTaXaMW8mZylATr33ucDIZp7bCygQkQ+A7sBM4C5jzCFTn4vIZGAyQFpa2nEHrAJTkD2IvvF96RvfFzIPllfXVJNXksf24u1sL9rO9uLt7CjZQV5pHgt3L6Sk+tCcP8gWRKewTnQK60RSeBJJYdbWKawTsSGxxATHEB0cTXRwtI4kVb5TO8eZDghQqt3yZnLWUBNEc6cPdwBjgSFYjz7fwXr8+dIhFzPmeeB5gKysrOOfmly1K067k27R3egW3a3B40VVRews2cmOkh3sKN3B7rLd7C7dTX5ZPiv3ruSbsm+orKls8NxQRyhRQVHEBMcQERRBpDOSyKBIIoIiiHBG1L2OdEYS7gwnMsjaRzgjCA8KJ9wRjt1m9+K3V+1Wia4OoFR7583kLBerM3+tVGDHMZy7pN4j0Q+BbA5LzpQ6HlFBUUTFRR11gXZjDIWVhewu201BZQEFlQUUVhYe3KoKKagsoLiqmJ2lO9lQsIHiqmJKqksOeZx6NA6bgyBbEE67E6fNechrp81JsD2YYHswTrv1uva4XaykTkSQen8DiQgOceCwOXDanIfsHTYHNrEhiLX3nFtbZrfZsYv94N7zum5whQFT+z9T96rumLWzjtW+rjE11LhrcBmXtXe7qDHW3ia2Q+Kpv41OGU1KREoL/6t2AKW6rqZS7Z03k7MFQKaIdAfygCuAq47h3FgRSTTG7AFOBRZ6J0ylGiYixITEEBNybMsJGWMod5VTVFVEaXUpJdUllFZ59p73JVUlVLmrqK6ptvbuaqprqq29u5qqmioqayqpqqmitLqUSndlXVltclSbMMHBxKjG1FDtrsbldtUlQ4HmyVOe1OSsMdpyplS757XkzBjjEpGbgS+xptJ42RizSkQeABYaY6aLyHBgGhALnC8i9xtj+hljakTk98DXYvXQXgS84K1YlWpNIkKYM8wvJs11G3ddouY2bty4reTOk+C5jdtq5XLXWC1dntau2hau2hbA+q10ta8FqRtAUdeCJwdf17bi1bbG1W/Bq//5h29RwVFt/4MKJP0vgS5DrBUClFLtklfnOTPGfAZ8dljZvfVeL8B63NnQuTOw5j9TSrWQTWwE2YMIsgf5OhTVWsLirE0p1W7pbJ1KKaWUUn5EkzOllFJKKT+iyZlSSimllB/R5EwppZRSyo9ocqaUUkop5Uc0OVNKKaWU8iOanCmllFJK+RFNzpRSSiml/IgmZ0oppZRSfkSTM6WUUkopPyLGGF/H0CpEZA+w7RhOSQD2eikcbwvU2AM1bgjc2AM1bmhe7OnGmMS2CMbbjvEe1t7/u/qrQI09UOOGwI39uO5f7SY5O1YistAYk+XrOFoiUGMP1LghcGMP1LghsGP3tkD+2WjsbS9Q44bAjf1449bHmkoppZRSfkSTM6WUUkopP9KRk7PnfR3AcQjU2AM1bgjc2AM1bgjs2L0tkH82GnvbC9S4IXBjP664O2yfM6WUUkopf9SRW86UUkoppfxOh0vOROQsEVknIhtF5C5fx3M4EXlZRPJFZGW9sjgRmSEiGzz7WE+5iMiTnu+yXESG+jDuriLyrYisEZFVInJrAMUeIiI/icgyT+z3e8q7i8h8T+zviEiQpzzY836j53g3X8XuiccuIktE5JMAi3uriKwQkaUistBT5ve/L76m9zCvxR2Q97BAv395YtJ72GE6VHImInbgGeBsoC9wpYj09W1UR3gVOOuwsruAr40xmcDXnvdgfY9MzzYZeK6NYmyIC/idMaYPkA38xvOzDYTYK4FTjTGDgMHAWSKSDTwMPOaJ/QBwvaf+9cABY0xP4DFPPV+6FVhT732gxA1wijFmcL0h54Hw++Izeg/zqkC9hwX6/Qv0HnYkY0yH2YBRwJf13t8N3O3ruBqIsxuwst77dUCy53UysM7zegpwZUP1fL0BHwHjAy12IAxYDIzEmkDQcfjvDvAlMMrz2uGpJz6KN9VzAzgV+ASQQIjbE8NWIOGwsoD6ffHBz0zvYW33HQLuHhZo9y9PDHoPa2DrUC1nQAqQU+99rqfM3yUZY3YCePadPOV++X08Tc1DgPkESOyeZvWlQD4wA9gEFBhjXA3EVxe753ghEN+2Edd5HPgD4Pa8jycw4gYwwFciskhEJnvKAuL3xYcC9ecQUP9dA+0eFsD3L9B7WIMcXgjWn0kDZYE8XNXvvo+IRADvA7cZY4pEGgrRqtpAmc9iN8bUAINFJAaYBvRpqJpn7xexi8h5QL4xZpGInFxb3EBVv4q7ntHGmB0i0gmYISJrG6nrb7H7Snv7Ofjd9wnEe1gg3r9A72E0EntHaznLBbrWe58K7PBRLMdit4gkA3j2+Z5yv/o+IuLEuqm9aYz5wFMcELHXMsYUAN9h9TmJEZHaP2Dqx1cXu+d4NLC/bSMFYDRwgYhsBaZiPRZ4HP+PGwBjzA7PPh/r/1BGEGC/Lz4QqD+HgPjvGuj3sAC7f4Hew476+9LRkrMFQKZnJEgQcAUw3ccxNcd04FrP62ux+kLUll/jGQWSDRTWNqe2NbH+vHwJWGOM+Xe9Q4EQe6LnL05EJBQ4Hatz6rfARE+1w2Ov/U4TgW+MpxNBWzLG3G2MSTXGdMP6Xf7GGHM1fh43gIiEi0hk7WvgDGAlAfD74mN6D/OSQL2HBer9C/Qe1ujvi6860vlqA84B1mM9k7/H1/E0EN/bwE6gGivTvh7rmfrXwAbPPs5TV7BGbm0CVgBZPox7DFYT7XJgqWc7J0BiHwgs8cS+ErjXU54B/ARsBP4HBHvKQzzvN3qOZ/jB783JwCeBErcnxmWebVXtv8VA+H3x9ab3MK/FHZD3sPZw//LEpfewepuuEKCUUkop5Uc62mNNpZRSSim/psmZUkoppZQf0eRMKaWUUsqPaHKmlFJKKeVHNDlTSimllPIjmpwpnxKRGhFZWm+7q+mzmn3tbiKysrWup5RSh9N7mPKGjrZ8k/I/5caYwb4OQimlWkjvYarVacuZ8ksislVEHhaRnzxbT095uoh8LSLLPfs0T3mSiEwTkWWe7UTPpewi8oKIrBKRrzwzaCMivxWR1Z7rTPXR11RKtVN6D1PHQ5Mz5Wuhhz0SuLzesSJjzAjgaaz11vC8ft0YMxB4E3jSU/4k8L0xZhAwFGvGZoBM4BljTD+gALjEU34XMMRznZu89eWUUu2e3sNUq9MVApRPiUiJMSaigfKtwKnGmM1iLUa8yxgTLyJ7gWRjTLWnfKcxJkFE9gCpxpjKetfoBswwxmR63v8RcBpjHhKRL4AS/r+9O9aFIIriMP79bSEavICn4C08AKIS1TZUvIZeofIASo1ohCgk3kJBodAo5Ch2xCZsYe1mb/h+zZyZTGbmNifn3jmTgTPgrKpepjxUSX+QOUzT4MqZWlYj4lHnfOd1KH7js89yncF/zlaBuyT2X0qaNHOYxmJxppZtDG1vuvga2OzibeCqiy+APkCSXpLFUWtnLIkAAAClSURBVBdNMgesVNUlcAgsA19mvpL0S+YwjcVKW7O2kOR+aP+8qj4+RZ9PcstgErHVHdsDTpIcAI/ATnd8HzhOsstgdtkHHkbcswecJlkCAhxV1fPERiTpPzGHaeLsOVOTun6Ntap6mvWzSNJPmcP0G77WlCRJaogrZ5IkSQ1x5UySJKkhFmeSJEkNsTiTJElqiMWZJElSQyzOJEmSGmJxJkmS1JB3nVKVoarXeooAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===============\n",
      "Testing Data\n",
      "Corrects:  154\n",
      "Incorrects:  43\n",
      "Percent Correct:  0.7817258883248731\n",
      "===============\n",
      "1= Survived 0= Did Not Survive\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.81      0.84      0.83       122\n",
      "           1       0.73      0.68      0.70        75\n",
      "\n",
      "    accuracy                           0.78       197\n",
      "   macro avg       0.77      0.76      0.77       197\n",
      "weighted avg       0.78      0.78      0.78       197\n",
      "\n"
     ]
    },
    {
     "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": [
    "from sklearn.model_selection import train_test_split\n",
    "data = pd.read_csv('titanic_train_kaggle.csv')\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "pd.set_option('display.max_rows', 714)\n",
    "data = pd.DataFrame(data[[\n",
    "    'Survived',\n",
    "    'Sex',\n",
    "    'Age',\n",
    "    'Fare'\n",
    "]])\n",
    "data = data.dropna()\n",
    "\n",
    "scaler = StandardScaler()\n",
    "age = data['Age'].values.reshape(-1,1)\n",
    "data['Age'] = scaler.fit_transform(age)\n",
    "\n",
    "fare = data['Fare'].values.reshape(-1,1)\n",
    "data['Fare'] = scaler.fit_transform(fare)\n",
    "\n",
    "data['Sex'] = data['Sex'].map({'female':0,'male':1}).astype(int)\n",
    "inputs = data.loc[:,['Sex','Age','Fare']].values\n",
    "\n",
    "train_outputs = data.loc[:,'Survived'].values\n",
    "train_outputs = train_outputs.reshape(-1,1)\n",
    "\n",
    "x = inputs\n",
    "y = train_outputs\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(x,y, test_size=.275, random_state=1)\n",
    "\n",
    "\n",
    "\n",
    "np.random.seed(41)\n",
    "\n",
    "\n",
    "\n",
    "nn = NeuralNetwork((3, 5, 1), (Relu, Sigmoid))\n",
    "nn.fit(X_train,y_train,loss=MSE,epochs=500,xtest=X_test,ytest=y_test,batch_size=1,learning_rate=.0006)\n",
    "predictions = nn.predict(X_test)\n",
    "y_pred = []\n",
    "for i in predictions:\n",
    "    if i >= 0.5:\n",
    "        y_pred.append(1)\n",
    "    else:\n",
    "        y_pred.append(0)\n",
    "\n",
    "\n",
    "C = 0\n",
    "I = 0\n",
    "for i,j in zip(y_pred,y_test):\n",
    "    if i == j:\n",
    "        C += 1\n",
    "    else:\n",
    "        I += 1\n",
    "        \n",
    "\n",
    "print('='*15)\n",
    "print('Testing Data')        \n",
    "print('Corrects: ',C)\n",
    "print('Incorrects: ', I)\n",
    "print('Percent Correct: ', C/(I+C))\n",
    "print('='*15)\n",
    "ModelScore(y_test,y_pred,predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: array([[-0.86890054,  0.5873444 ,  0.46917403, -0.04737266,  0.74246974],\n",
       "        [-0.5744467 , -0.03754819,  0.51264447, -0.56153863, -0.51353837],\n",
       "        [-0.20275298, -0.69843722, -0.38939475, -0.08090371, -0.57234724]]),\n",
       " 2: array([[ 1.20844567],\n",
       "        [-0.74678353],\n",
       "        [-0.43751232],\n",
       "        [-0.38233873],\n",
       "        [-0.66237921]])}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#weights after training\n",
    "#keys represent layers \n",
    "\n",
    "\n",
    "\n",
    "nn.w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: array([2.60156535, 1.70216253, 2.19846506, 2.40842524, 1.8101811 ]),\n",
       " 2: array([2.24215177])}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# {1: array([2.49102832, 1.79611397, 2.21635583, 2.45668798, 1.84335846]),\n",
    "#  2: array([2.16758199])}\n",
    "#bias terms \n",
    "nn.b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2: __main__.Relu, 3: __main__.Sigmoid}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn.activations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.  5. 13.  9.  1.  0.  0.  0.  0. 13. 15. 10. 15.  5.  0.  0.  3.\n",
      " 15.  2.  0. 11.  8.  0.  0.  4. 12.  0.  0.  8.  8.  0.  0.  5.  8.  0.\n",
      "  0.  9.  8.  0.  0.  4. 11.  0.  1. 12.  7.  0.  0.  2. 14.  5. 10. 12.\n",
      "  0.  0.  0.  0.  6. 13. 10.  0.  0.  0.]\n",
      "Epoch 0, Loss: 0.07680830000796082\n",
      "Epoch 15, Loss: 0.014492658126531959\n",
      "Epoch 30, Loss: 0.009539910414275111\n",
      "Epoch 45, Loss: 0.007569164223895262\n",
      "Epoch 60, Loss: 0.006141949598397549\n",
      "Epoch 75, Loss: 0.005248052688284784\n",
      "Epoch 90, Loss: 0.004310945356515484\n",
      "Epoch 105, Loss: 0.0036947440650582156\n",
      "Epoch 120, Loss: 0.0032027115824294606\n",
      "Epoch 135, Loss: 0.002693188449694637\n",
      "Epoch 150, Loss: 0.002423831899370251\n",
      "Epoch 165, Loss: 0.0022734575986216644\n",
      "Epoch 180, Loss: 0.0019383845271054752\n",
      "Epoch 195, Loss: 0.0016691803969711503\n",
      "Epoch 210, Loss: 0.0015801638451730091\n",
      "Epoch 225, Loss: 0.0012910795374301422\n",
      "Epoch 240, Loss: 0.0011384577272415444\n",
      "Epoch 255, Loss: 0.001067066216800478\n",
      "Epoch 270, Loss: 0.0009307844392832137\n",
      "Epoch 285, Loss: 0.0008512363000621362\n",
      "Epoch 300, Loss: 0.0007525789460740854\n",
      "Epoch 315, Loss: 0.0006541695235964208\n",
      "Epoch 330, Loss: 0.0006748830370995977\n",
      "Epoch 345, Loss: 0.0005962261223620883\n",
      "Epoch 360, Loss: 0.0005035899268272649\n",
      "Epoch 375, Loss: 0.00046773077517929\n",
      "Epoch 390, Loss: 0.00048803195727405705\n",
      "Epoch 405, Loss: 0.00039838710860624806\n",
      "Epoch 420, Loss: 0.00038954925468890955\n",
      "Epoch 435, Loss: 0.0003345485778394406\n",
      "Epoch 450, Loss: 0.00031213456401539774\n",
      "Epoch 465, Loss: 0.00027371371417341705\n",
      "Epoch 480, Loss: 0.0002551274931855525\n",
      "Epoch 495, Loss: 0.0002485001149282302\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.98      0.97        54\n",
      "           1       0.96      0.96      0.96        55\n",
      "           2       0.96      0.98      0.97        53\n",
      "           3       0.95      0.98      0.96        55\n",
      "           4       0.96      0.98      0.97        54\n",
      "           5       0.96      0.93      0.94        55\n",
      "           6       1.00      0.98      0.99        54\n",
      "           7       1.00      0.94      0.97        54\n",
      "           8       0.91      0.92      0.91        52\n",
      "           9       0.96      0.96      0.96        54\n",
      "\n",
      "    accuracy                           0.96       540\n",
      "   macro avg       0.96      0.96      0.96       540\n",
      "weighted avg       0.96      0.96      0.96       540\n",
      "\n",
      "===============\n",
      "Testing Data\n",
      "Corrects:  520\n",
      "Incorrects:  20\n",
      "Percent Correct:  0.9629629629629629\n",
      "===============\n"
     ]
    }
   ],
   "source": [
    "## Now testing NN on sklearn digit reconition data set \n",
    "\n",
    "from sklearn import datasets\n",
    "import sklearn.metrics\n",
    "np.random.seed(1)\n",
    "data = datasets.load_digits()\n",
    "\n",
    "x = data[\"data\"]\n",
    "y = data[\"target\"]\n",
    "print(x[0])\n",
    "y = np.eye(10)[y]\n",
    "\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(x,y, test_size=.3, random_state=1,stratify=y)\n",
    "\n",
    "nn = NeuralNetwork((64, 25, 10), (Relu, Sigmoid))\n",
    "nn.fit(X_train, y_train,xtest=X_test, ytest=y_test, loss=MSE, epochs=500, batch_size=25, learning_rate=.0005,validation_split=0.25)\n",
    "\n",
    "prediction = nn.predict(X_test)\n",
    "\n",
    "y_true = []\n",
    "y_pred = []\n",
    "for i in range(len(y_test)):\n",
    "    y_pred.append(np.argmax(prediction[i]))\n",
    "    y_true.append(np.argmax(y_test[i]))\n",
    "\n",
    "print(sklearn.metrics.classification_report(y_true, y_pred))\n",
    "C = 0\n",
    "I = 0\n",
    "for i,j in zip(y_pred,y_true):\n",
    "    if i == j:\n",
    "        C += 1\n",
    "    else:\n",
    "        I += 1\n",
    "print('='*15)\n",
    "print('Testing Data')        \n",
    "print('Corrects: ',C)\n",
    "print('Incorrects: ', I)\n",
    "print('Percent Correct: ', C/(I+C))\n",
    "print('='*15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x9000 with 25 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "class PlotImgPred():\n",
    "    def __init__(self, predictions, X, y, n_plots=10):\n",
    "        self.predictions = predictions\n",
    "        self.X = np.array(X).reshape(len(X),8,8)\n",
    "        self.y = y\n",
    "        self.plots = n_plots\n",
    "    def show_pred(self):\n",
    "        fig = plt.figure(figsize=(15,self.plots*5))\n",
    "        axes = []\n",
    "        for i in range(self.plots):\n",
    "            axes.append(fig.add_subplot(self.plots,2,i+1))\n",
    "        for i in range(self.plots):\n",
    "            ax = axes[i]\n",
    "            if i % 2 == 0:\n",
    "                ax.imshow(self.X[i], interpolation=None, cmap='binary')\n",
    "                ax.set_title('Labeled: {}'.format(np.argmax(self.y[i])))\n",
    "            else:\n",
    "                ax.bar(range(10),self.predictions[i-1])\n",
    "                ax.set_title('Predicted: {}'.format(np.argmax(self.predictions[i-1])))\n",
    "        plt.show()\n",
    "        \n",
    "\n",
    "PlotImgPred(prediction, X_test,y_test,25).show_pred()\n",
    "    \n",
    "    \n",
    "# fig, ax = plt.figure() \n",
    "# plt.imshow(X[0], interpolation=None, cmap='binary')\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print('{}'.format('hello'))"
   ]
  },
  {
   "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
}