Lab09/FFNN-MNIST-Full.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ee4ffdd0",
   "metadata": {},
   "source": [
    "# Multi-layer Feed Forward Network Program on MNIST (Image) Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3f376417",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inputs = (n_inputs, pixel_width, pixel_height) = (1797, 8, 8)\n",
      "labels = (n_inputs) = (1797,)\n",
      "X = (n_inputs, n_features) = (1797, 64)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import datasets\n",
    "\n",
    "\n",
    "# ensure the same random numbers appear every time\n",
    "np.random.seed(0)\n",
    "plt.rcParams['figure.figsize'] = (12,12)\n",
    "\n",
    "\n",
    "# download MNIST dataset\n",
    "digits = datasets.load_digits()\n",
    "\n",
    "# define inputs and labels\n",
    "inputs = digits.images\n",
    "labels = digits.target\n",
    "\n",
    "print(\"inputs = (n_inputs, pixel_width, pixel_height) = \" + str(inputs.shape))\n",
    "print(\"labels = (n_inputs) = \" + str(labels.shape))\n",
    "\n",
    "\n",
    "# flatten the image\n",
    "# the value -1 means dimension is inferred from the remaining dimensions: 8x8 = 64\n",
    "n_inputs = len(inputs)\n",
    "inputs = inputs.reshape(n_inputs, -1)\n",
    "print(\"X = (n_inputs, n_features) = \" + str(inputs.shape))\n",
    "\n",
    "\n",
    "# choose some random images to display\n",
    "indices = np.arange(n_inputs)\n",
    "random_indices = np.random.choice(indices, size=5)\n",
    "\n",
    "for i, image in enumerate(digits.images[random_indices]):\n",
    "    plt.subplot(1, 5, i+1)\n",
    "    plt.axis('off')\n",
    "    plt.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')\n",
    "    plt.title(\"Label: %d\" % digits.target[random_indices[i]])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c0171ea3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training images: 1437\n",
      "Number of test images: 360\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# one-liner from scikit-learn library\n",
    "train_size = 0.8\n",
    "test_size = 1 - train_size\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(inputs, labels, train_size=train_size,\n",
    "                                                    test_size=test_size)\n",
    "\n",
    "# equivalently in numpy\n",
    "def train_test_split_numpy(inputs, labels, train_size, test_size):\n",
    "    n_inputs = len(inputs)\n",
    "    inputs_shuffled = inputs.copy()\n",
    "    labels_shuffled = labels.copy()\n",
    "    \n",
    "    np.random.shuffle(inputs_shuffled)\n",
    "    np.random.shuffle(labels_shuffled)\n",
    "    \n",
    "    train_end = int(n_inputs*train_size)\n",
    "    X_train, X_test = inputs_shuffled[:train_end], inputs_shuffled[train_end:]\n",
    "    Y_train, Y_test = labels_shuffled[:train_end], labels_shuffled[train_end:]\n",
    "    \n",
    "    return X_train, X_test, Y_train, Y_test\n",
    "\n",
    "#X_train, X_test, Y_train, Y_test = train_test_split_numpy(inputs, labels, train_size, test_size)\n",
    "\n",
    "print(\"Number of training images: \" + str(len(X_train)))\n",
    "print(\"Number of test images: \" + str(len(X_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "05cc15c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# building our neural network\n",
    "\n",
    "n_inputs, n_features = X_train.shape\n",
    "n_hidden_neurons = 50\n",
    "n_categories = 10\n",
    "\n",
    "# we make the weights normally distributed using numpy.random.randn\n",
    "\n",
    "# weights and bias in the hidden layer\n",
    "hidden_weights = np.random.randn(n_features, n_hidden_neurons)\n",
    "hidden_bias = np.zeros(n_hidden_neurons) + 0.01\n",
    "\n",
    "# weights and bias in the output layer\n",
    "output_weights = np.random.randn(n_hidden_neurons, n_categories)\n",
    "output_bias = np.zeros(n_categories) + 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac80954d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "probabilities = (n_inputs, n_categories) = (1437, 10)\n",
      "probability that image 0 is in category 0,1,2,...,9 = \n",
      "[5.41511965e-04 2.17174962e-03 8.84355903e-03 1.44970586e-03\n",
      " 1.10378326e-04 5.08318298e-09 2.03256632e-04 1.92507116e-03\n",
      " 9.84443254e-01 3.11507992e-04]\n",
      "probabilities sum up to: 1.0\n",
      "\n",
      "predictions = (n_inputs) = (1437,)\n",
      "prediction for image 0: 8\n",
      "correct label for image 0: 6\n"
     ]
    }
   ],
   "source": [
    "# setup the feed-forward pass, subscript h = hidden layer\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1/(1 + np.exp(-x))\n",
    "\n",
    "def feed_forward(X):\n",
    "    # weighted sum of inputs to the hidden layer\n",
    "    z_h = np.matmul(X, hidden_weights) + hidden_bias\n",
    "    # activation in the hidden layer\n",
    "    a_h = sigmoid(z_h)\n",
    "    \n",
    "    # weighted sum of inputs to the output layer\n",
    "    z_o = np.matmul(a_h, output_weights) + output_bias\n",
    "    # softmax output\n",
    "    # axis 0 holds each input and axis 1 the probabilities of each category\n",
    "    exp_term = np.exp(z_o)\n",
    "    probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n",
    "    \n",
    "    return probabilities\n",
    "\n",
    "probabilities = feed_forward(X_train)\n",
    "print(\"probabilities = (n_inputs, n_categories) = \" + str(probabilities.shape))\n",
    "print(\"probability that image 0 is in category 0,1,2,...,9 = \\n\" + str(probabilities[0]))\n",
    "print(\"probabilities sum up to: \" + str(probabilities[0].sum()))\n",
    "print()\n",
    "\n",
    "# we obtain a prediction by taking the class with the highest likelihood\n",
    "def predict(X):\n",
    "    probabilities = feed_forward(X)\n",
    "    return np.argmax(probabilities, axis=1)\n",
    "\n",
    "predictions = predict(X_train)\n",
    "print(\"predictions = (n_inputs) = \" + str(predictions.shape))\n",
    "print(\"prediction for image 0: \" + str(predictions[0]))\n",
    "print(\"correct label for image 0: \" + str(Y_train[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b234c73d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Old accuracy on training data: 0.1440501043841336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New accuracy on training data: 0.09951287404314545\n"
     ]
    }
   ],
   "source": [
    "# to categorical turns our integer vector into a onehot representation\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# one-hot in numpy\n",
    "def to_categorical_numpy(integer_vector):\n",
    "    n_inputs = len(integer_vector)\n",
    "    n_categories = np.max(integer_vector) + 1\n",
    "    onehot_vector = np.zeros((n_inputs, n_categories))\n",
    "    onehot_vector[range(n_inputs), integer_vector] = 1\n",
    "    \n",
    "    return onehot_vector\n",
    "\n",
    "#Y_train_onehot, Y_test_onehot = to_categorical(Y_train), to_categorical(Y_test)\n",
    "Y_train_onehot, Y_test_onehot = to_categorical_numpy(Y_train), to_categorical_numpy(Y_test)\n",
    "\n",
    "def feed_forward_train(X):\n",
    "    # weighted sum of inputs to the hidden layer\n",
    "    z_h = np.matmul(X, hidden_weights) + hidden_bias\n",
    "    # activation in the hidden layer\n",
    "    a_h = sigmoid(z_h)\n",
    "    \n",
    "    # weighted sum of inputs to the output layer\n",
    "    z_o = np.matmul(a_h, output_weights) + output_bias\n",
    "    # softmax output\n",
    "    # axis 0 holds each input and axis 1 the probabilities of each category\n",
    "    exp_term = np.exp(z_o)\n",
    "    probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n",
    "    \n",
    "    # for backpropagation need activations in hidden and output layers\n",
    "    return a_h, probabilities\n",
    "\n",
    "def backpropagation(X, Y):\n",
    "    a_h, probabilities = feed_forward_train(X)\n",
    "    \n",
    "    # error in the output layer\n",
    "    error_output = probabilities - Y\n",
    "    # error in the hidden layer\n",
    "    error_hidden = np.matmul(error_output, output_weights.T) * a_h * (1 - a_h)\n",
    "    \n",
    "    # gradients for the output layer\n",
    "    output_weights_gradient = np.matmul(a_h.T, error_output)\n",
    "    output_bias_gradient = np.sum(error_output, axis=0)\n",
    "    \n",
    "    # gradient for the hidden layer\n",
    "    hidden_weights_gradient = np.matmul(X.T, error_hidden)\n",
    "    hidden_bias_gradient = np.sum(error_hidden, axis=0)\n",
    "\n",
    "    return output_weights_gradient, output_bias_gradient, hidden_weights_gradient, hidden_bias_gradient\n",
    "\n",
    "print(\"Old accuracy on training data: \" + str(accuracy_score(predict(X_train), Y_train)))\n",
    "\n",
    "eta = 0.01\n",
    "lmbd = 0.01\n",
    "for i in range(1000):\n",
    "    # calculate gradients\n",
    "    dWo, dBo, dWh, dBh = backpropagation(X_train, Y_train_onehot)\n",
    "    \n",
    "    # regularization term gradients\n",
    "    dWo += lmbd * output_weights\n",
    "    dWh += lmbd * hidden_weights\n",
    "    \n",
    "    # update weights and biases\n",
    "    output_weights -= eta * dWo\n",
    "    output_bias -= eta * dBo\n",
    "    hidden_weights -= eta * dWh\n",
    "    hidden_bias -= eta * dBh\n",
    "\n",
    "print(\"New accuracy on training data: \" + str(accuracy_score(predict(X_train), Y_train)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e326f978",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNetwork:\n",
    "    def __init__(\n",
    "            self,\n",
    "            X_data,\n",
    "            Y_data,\n",
    "            n_hidden_neurons=50,\n",
    "            n_categories=10,\n",
    "            epochs=10,\n",
    "            batch_size=100,\n",
    "            eta=0.1,\n",
    "            lmbd=0.0):\n",
    "\n",
    "        self.X_data_full = X_data\n",
    "        self.Y_data_full = Y_data\n",
    "\n",
    "        self.n_inputs = X_data.shape[0]\n",
    "        self.n_features = X_data.shape[1]\n",
    "        self.n_hidden_neurons = n_hidden_neurons\n",
    "        self.n_categories = n_categories\n",
    "\n",
    "        self.epochs = epochs\n",
    "        self.batch_size = batch_size\n",
    "        self.iterations = self.n_inputs // self.batch_size\n",
    "        self.eta = eta\n",
    "        self.lmbd = lmbd\n",
    "\n",
    "        self.create_biases_and_weights()\n",
    "\n",
    "    def create_biases_and_weights(self):\n",
    "        self.hidden_weights = np.random.randn(self.n_features, self.n_hidden_neurons)\n",
    "        self.hidden_bias = np.zeros(self.n_hidden_neurons) + 0.01\n",
    "\n",
    "        self.output_weights = np.random.randn(self.n_hidden_neurons, self.n_categories)\n",
    "        self.output_bias = np.zeros(self.n_categories) + 0.01\n",
    "\n",
    "    def feed_forward(self):\n",
    "        # feed-forward for training\n",
    "        self.z_h = np.matmul(self.X_data, self.hidden_weights) + self.hidden_bias\n",
    "        self.a_h = sigmoid(self.z_h)\n",
    "\n",
    "        self.z_o = np.matmul(self.a_h, self.output_weights) + self.output_bias\n",
    "\n",
    "        exp_term = np.exp(self.z_o)\n",
    "        self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n",
    "\n",
    "    def feed_forward_out(self, X):\n",
    "        # feed-forward for output\n",
    "        z_h = np.matmul(X, self.hidden_weights) + self.hidden_bias\n",
    "        a_h = sigmoid(z_h)\n",
    "\n",
    "        z_o = np.matmul(a_h, self.output_weights) + self.output_bias\n",
    "        \n",
    "        exp_term = np.exp(z_o)\n",
    "        probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n",
    "        return probabilities\n",
    "\n",
    "    def backpropagation(self):\n",
    "        error_output = self.probabilities - self.Y_data\n",
    "        error_hidden = np.matmul(error_output, self.output_weights.T) * self.a_h * (1 - self.a_h)\n",
    "\n",
    "        self.output_weights_gradient = np.matmul(self.a_h.T, error_output)\n",
    "        self.output_bias_gradient = np.sum(error_output, axis=0)\n",
    "\n",
    "        self.hidden_weights_gradient = np.matmul(self.X_data.T, error_hidden)\n",
    "        self.hidden_bias_gradient = np.sum(error_hidden, axis=0)\n",
    "\n",
    "        if self.lmbd > 0.0:\n",
    "            self.output_weights_gradient += self.lmbd * self.output_weights\n",
    "            self.hidden_weights_gradient += self.lmbd * self.hidden_weights\n",
    "\n",
    "        self.output_weights -= self.eta * self.output_weights_gradient\n",
    "        self.output_bias -= self.eta * self.output_bias_gradient\n",
    "        self.hidden_weights -= self.eta * self.hidden_weights_gradient\n",
    "        self.hidden_bias -= self.eta * self.hidden_bias_gradient\n",
    "\n",
    "    def predict(self, X):\n",
    "        probabilities = self.feed_forward_out(X)\n",
    "        return np.argmax(probabilities, axis=1)\n",
    "\n",
    "    def predict_probabilities(self, X):\n",
    "        probabilities = self.feed_forward_out(X)\n",
    "        return probabilities\n",
    "\n",
    "    def train(self):\n",
    "        data_indices = np.arange(self.n_inputs)\n",
    "\n",
    "        for i in range(self.epochs):\n",
    "            for j in range(self.iterations):\n",
    "                # pick datapoints with replacement\n",
    "                chosen_datapoints = np.random.choice(\n",
    "                    data_indices, size=self.batch_size, replace=False\n",
    "                )\n",
    "\n",
    "                # minibatch training data\n",
    "                self.X_data = self.X_data_full[chosen_datapoints]\n",
    "                self.Y_data = self.Y_data_full[chosen_datapoints]\n",
    "\n",
    "                self.feed_forward()\n",
    "                self.backpropagation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "873394df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy score on test set:  0.9555555555555556\n"
     ]
    }
   ],
   "source": [
    "epochs = 100\n",
    "batch_size = 100\n",
    "\n",
    "dnn = NeuralNetwork(X_train, Y_train_onehot, eta=eta, lmbd=lmbd, epochs=epochs, batch_size=batch_size,\n",
    "                    n_hidden_neurons=n_hidden_neurons, n_categories=n_categories)\n",
    "dnn.train()\n",
    "test_predict = dnn.predict(X_test)\n",
    "\n",
    "# accuracy score from scikit library\n",
    "print(\"Accuracy score on test set: \", accuracy_score(Y_test, test_predict))\n",
    "\n",
    "# equivalent in numpy\n",
    "def accuracy_score_numpy(Y_test, Y_pred):\n",
    "    return np.sum(Y_test == Y_pred) / len(Y_test)\n",
    "\n",
    "#print(\"Accuracy score on test set: \", accuracy_score_numpy(Y_test, test_predict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b94fc088",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.11666666666666667\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.20833333333333334\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.12222222222222222\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.14722222222222223\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.17777777777777778\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.16111111111111112\n",
      "\n",
      "Learning rate  =  1e-05\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.20277777777777778\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.5305555555555556\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.5944444444444444\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.5888888888888889\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.6111111111111112\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.5222222222222223\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.5555555555555556\n",
      "\n",
      "Learning rate  =  0.0001\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.8055555555555556\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.85\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.85\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.875\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.8666666666666667\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.8638888888888889\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.9555555555555556\n",
      "\n",
      "Learning rate  =  0.001\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.925\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.9222222222222223\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.9277777777777778\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.9305555555555556\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.9388888888888889\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.6277777777777778\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.9416666666666667\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.25555555555555554\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.08888888888888889\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.11388888888888889\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.08888888888888889\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.09166666666666666\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.10555555555555556\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.1\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.09166666666666666\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.10555555555555556\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1.0\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/1630775253.py:43: RuntimeWarning: overflow encountered in exp\n",
      "  exp_term = np.exp(self.z_o)\n",
      "/tmp/ipykernel_17160/1630775253.py:44: RuntimeWarning: invalid value encountered in divide\n",
      "  self.probabilities = exp_term / np.sum(exp_term, axis=1, keepdims=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  10.0\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n"
     ]
    }
   ],
   "source": [
    "eta_vals = np.logspace(-5, 1, 7)\n",
    "lmbd_vals = np.logspace(-5, 1, 7)\n",
    "# store the models for later use\n",
    "DNN_numpy = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object)\n",
    "\n",
    "# grid search\n",
    "for i, eta in enumerate(eta_vals):\n",
    "    for j, lmbd in enumerate(lmbd_vals):\n",
    "        dnn = NeuralNetwork(X_train, Y_train_onehot, eta=eta, lmbd=lmbd, epochs=epochs, batch_size=batch_size,\n",
    "                            n_hidden_neurons=n_hidden_neurons, n_categories=n_categories)\n",
    "        dnn.train()\n",
    "        \n",
    "        DNN_numpy[i][j] = dnn\n",
    "        \n",
    "        test_predict = dnn.predict(X_test)\n",
    "        \n",
    "        print(\"Learning rate  = \", eta)\n",
    "        print(\"Lambda = \", lmbd)\n",
    "        print(\"Accuracy score on test set: \", accuracy_score(Y_test, test_predict))\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "92f63a9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n",
      "/tmp/ipykernel_17160/953065564.py:4: RuntimeWarning: overflow encountered in exp\n",
      "  return 1/(1 + np.exp(-x))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visual representation of grid search\n",
    "# uses seaborn heatmap, you can also do this with matplotlib imshow\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set()\n",
    "\n",
    "train_accuracy = np.zeros((len(eta_vals), len(lmbd_vals)))\n",
    "test_accuracy = np.zeros((len(eta_vals), len(lmbd_vals)))\n",
    "\n",
    "for i in range(len(eta_vals)):\n",
    "    for j in range(len(lmbd_vals)):\n",
    "        dnn = DNN_numpy[i][j]\n",
    "        \n",
    "        train_pred = dnn.predict(X_train) \n",
    "        test_pred = dnn.predict(X_test)\n",
    "\n",
    "        train_accuracy[i][j] = accuracy_score(Y_train, train_pred)\n",
    "        test_accuracy[i][j] = accuracy_score(Y_test, test_pred)\n",
    "\n",
    "        \n",
    "fig, ax = plt.subplots(figsize = (10, 10))\n",
    "sns.heatmap(train_accuracy, annot=True, ax=ax, cmap=\"viridis\")\n",
    "ax.set_title(\"Training Accuracy\")\n",
    "ax.set_ylabel(\"$\\eta$\")\n",
    "ax.set_xlabel(\"$\\lambda$\")\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (10, 10))\n",
    "sns.heatmap(test_accuracy, annot=True, ax=ax, cmap=\"viridis\")\n",
    "ax.set_title(\"Test Accuracy\")\n",
    "ax.set_ylabel(\"$\\eta$\")\n",
    "ax.set_xlabel(\"$\\lambda$\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ccadca7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.18333333333333332\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.18611111111111112\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.13055555555555556\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.24444444444444444\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.23333333333333334\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.12777777777777777\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  1e-05\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.1527777777777778\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.9111111111111111\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.8888888888888888\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.8722222222222222\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.8305555555555556\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.8888888888888888\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.8805555555555555\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.0001\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.8944444444444445\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.975\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.9777777777777777\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.9805555555555555\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.9861111111111112\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.9805555555555555\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.9777777777777777\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.001\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.9444444444444444\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:691: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (100) reached and the optimization hasn't converged yet.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Learning rate  =  0.01\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.9861111111111112\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.9888888888888889\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.9888888888888889\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.9861111111111112\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.9888888888888889\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.9722222222222222\n",
      "\n",
      "Learning rate  =  0.01\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.9527777777777777\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.9138888888888889\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.8861111111111111\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.8694444444444445\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.9166666666666666\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.8805555555555555\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.9055555555555556\n",
      "\n",
      "Learning rate  =  0.1\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.7222222222222222\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.10555555555555556\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.18888888888888888\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.175\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.29444444444444445\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.10833333333333334\n",
      "\n",
      "Learning rate  =  1.0\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.07777777777777778\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  1e-05\n",
      "Accuracy score on test set:  0.11944444444444445\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  0.0001\n",
      "Accuracy score on test set:  0.125\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  0.001\n",
      "Accuracy score on test set:  0.10555555555555556\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  0.01\n",
      "Accuracy score on test set:  0.12777777777777777\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  0.1\n",
      "Accuracy score on test set:  0.09444444444444444\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  1.0\n",
      "Accuracy score on test set:  0.11666666666666667\n",
      "\n",
      "Learning rate  =  10.0\n",
      "Lambda =  10.0\n",
      "Accuracy score on test set:  0.11388888888888889\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "# store models for later use\n",
    "DNN_scikit = np.zeros((len(eta_vals), len(lmbd_vals)), dtype=object)\n",
    "\n",
    "for i, eta in enumerate(eta_vals):\n",
    "    for j, lmbd in enumerate(lmbd_vals):\n",
    "        dnn = MLPClassifier(hidden_layer_sizes=(n_hidden_neurons), activation='logistic',\n",
    "                            alpha=lmbd, learning_rate_init=eta, max_iter=epochs)\n",
    "        dnn.fit(X_train, Y_train)\n",
    "        \n",
    "        DNN_scikit[i][j] = dnn\n",
    "        \n",
    "        print(\"Learning rate  = \", eta)\n",
    "        print(\"Lambda = \", lmbd)\n",
    "        print(\"Accuracy score on test set: \", dnn.score(X_test, Y_test))\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8bc41f14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyYAAANgCAYAAADZNnxDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACzpElEQVR4nOzdd3gUVdvH8d/sZtNJIJTQS1Cq9CIdBEQBlVdAwYoVVGwgKvb62HvhQUEU9REsoIIKSEeqiDTpEDoSIIGQAEk2u/P+sSEhZlMWN0zYfD/XlQsyO2f27GE4O/ec+5wxTNM0BQAAAAAWslldAQAAAAAgMAEAAABgOQITAAAAAJYjMAEAAABgOQITAAAAAJYjMAEAAABgOQITAAAAAJYjMAEAAABgOQITAAAAAJYjMAGALKNHj1b37t3Pquz777+v+vXr+7lGAACUHkFWVwAAClPUC/7PP/9cF198cTHXpmR74IEHNHPmTN1xxx16+OGHra4OAABFZpimaVpdCQAoyI8//pjn9yVLlui1117Ltb1jx46qUKHCWb+P0+mUaZoKDg72uWxmZqZcLpdCQkLO+v3/rdTUVHXo0EEVKlSQ2+3W/PnzZRiGZfUBAMAXjJgAKPH69euX6/e1a9dqyZIlebb/06lTpxQWFlbk93E4HGdVP0kKCgpSUJC1XeqsWbPkdrv10ksvaciQIVq5cqXatm1raZ28MU1T6enpCg0NtboqAIAShDkmAALCTTfdpCuuuEJ//fWXbrjhBjVr1kxvvfWWJGnOnDkaOnSoOnXqpIsuukg9e/bUhx9+KJfLlesY/5xjsm/fPtWvX1+ffPKJvv76a/Xs2VMXXXSRBgwYoHXr1uUq622OSf369fX8889rzpw5uuKKK3TRRRepb9++WrRoUZ76r1ixQv3791eTJk3Us2dPTZ482ed5K9OnT1eHDh3Url071a1bV9OnT/e6344dO/TAAw+oXbt2atq0qS677DK9/fbbufZJSEjQ448/nt1m3bt31zPPPKOMjIx8P68kTZ06VfXr19e+ffuyt3Xv3l3Dhg3Tb7/9pv79+6tp06aaPHmyJGnKlCm6+eab1b59e1100UXq06ePvvrqK6/1XrhwoW688Ua1aNFCLVu21IABA7I/43vvvafGjRsrKSkpT7mnnnpKrVu3Vnp6ehFaEQBgFUZMAASMY8eO6c4771Tfvn111VVXqXz58pKk77//XuHh4br11lsVHh6u5cuX67333lNqaqoeffTRQo/7008/6cSJExo0aJAMw9D48eN13333ac6cOYWOsqxatUq//vqrrr/+ekVEROiLL77Q/fffr/nz56tcuXKSpI0bN+qOO+5QxYoVdd9998ntduvDDz9UTExMkT97QkKCVqxYoVdeeUWS1LdvX02cOFFPPfVUrtS0zZs364YbblBQUJAGDRqkatWqac+ePZo3b55GjBiRfayBAwcqJSVF1157reLi4pSQkKBZs2YpLS3trFLddu7cqYceekiDBg3Stddeqzp16kiSJk2apAsvvFDdu3dXUFCQ5s+fr+eee06maeqGG27ILj916lQ9/vjjuvDCCzVs2DCVKVNGmzZt0m+//aYrr7xS/fr104cffqhffvlFN954Y3a5jIwMzZo1S7169bI0zQ4AUDgCEwAB4/Dhw3ruuec0ePDgXNvffPPNXGlD1113nZ5++mlNmjRJI0aMKPRC+8CBA/r1118VHR0tSapTp47uueceLV68WJdcckmBZXfs2KFffvlFNWvWlCRdfPHF6tevn37++efsC+j33ntPdrtdkyZNUmxsrCSpd+/e6tOnT5E/+88//6zg4GD16NFDkicwee+997Ro0SL17Nkze78XX3xRpmnq+++/V9WqVbO3jxo1Kvvvb731lo4cOaJvvvlGTZo0yd7+wAMP6GynJe7evVvjx49X586dc23/8ssvc/3b3Hjjjbr99tv16aefZgcmKSkpevHFF9W0aVN98cUXuQKM0/WpVauWWrRooWnTpuUKTBYuXKjk5ORC0/4AANYjlQtAwAgODlb//v3zbD/zwjc1NVVJSUlq3bq1Tp06pfj4+EKP26dPn+ygRJJat24tSdq7d2+hZTt06JAdlEhSgwYNFBkZmV3W5XJp2bJl6tGjR3ZQInkutP95EV+Q6dOnq2vXroqMjJQk1a5dW40bN9a0adOy90lKStLKlSs1YMCAXEGJpOxJ8m63W3PmzNEll1ySKyj5536+ql69utfPc+a/TUpKipKSktS2bVvt3btXKSkpkqQlS5boxIkTGjp0aJ5RjzPr069fP61du1Z79uzJ3jZ9+nRVqVKlRM61AQDkxogJgIARGxvrdfRj27Zteuedd7R8+XKlpqbmeu30xW9BqlSpkuv300HK8ePHfS57uvzpsomJiUpLS1OtWrXy7Odtmzc7duzQxo0b1a9fP+3evTt7+8UXX6z//e9/Sk1NzRUM1atXL99jJSUlKTU1VRdeeGGR3ruoqlev7nX7qlWr9P7772vNmjU6depUrtdSUlJUpkyZ7ECjsDr16dNHL730kqZNm6Z7771XKSkpmj9/vm655RZWJwOA8wCBCYCA4W2Vp+PHj+vGG29UZGSk7r//ftWsWVMhISHasGGD3njjDbnd7kKPa7fbvW4vSlrTvylbVKdHRV5++WW9/PLLeV6fNWuWBgwY4Lf3k/IfOfnnggKnefu32bNnj2655RbFxcVp9OjRqlKlihwOhxYuXKjPPvusSP82Z4qOjtYll1yi6dOn695779XMmTOVkZGhq666yqfjAACsQWACIKD9/vvvOnbsmD744AO1adMme/uZq0ZZqXz58goJCck10nGat23/ZJqmpk+frosvvljXX399ntfHjBmj6dOna8CAAapRo4YkaevWrfkeLyYmRpGRkdq2bVuB7xsVFSXJE/id/rvkmY9TVPPmzVNGRob++9//5kotW7FiRa79TqfCbdu2rdBRpH79+umee+7RunXrNH36dDVq1Mjvoz8AgOLBHBMAAc1m83RzZ45QZGRk5Lsk7blmt9vVoUMHzZ07VwkJCdnbd+/erd9++63Q8qtWrdL+/fvVv39/XX755Xl++vTpoxUrVighIUExMTFq06aNpkyZkieAON0+NptNPXv21Pz587V+/fo873d6v9PBwsqVK7NfO3nypH744QefPvuZx5Q86VtTpkzJtV+nTp0UERGhjz76KM+Sv/8ceerSpYvKlSun8ePHa+XKlYyWAMB5hBETAAGtRYsWio6O1ujRo3XTTTfJMAz9+OOPfk2l+rfuvfdeLV68WNddd52uu+46ud1uffnll7rwwgu1adOmAstOnz5ddrtd3bp18/p69+7d9fbbb+uXX37RrbfeqieffFLXXXedrr76ag0aNEjVq1fX/v37tWDBAv3444+SpJEjR2rJkiW66aabdO2116pu3bo6fPiwZs6cqa+++kpRUVHq2LGjqlatqieeeELx8fGy2+2aMmWKypUrV+RRk44dO8rhcOiuu+7S4MGDdeLECX377bcqX768Dh8+nL1fZGSkHnvsMT355JMaOHCgrrjiCkVFRWnz5s1KS0vTq6++mr2vw+FQ37599eWXX8put6tv375FqgsAwHqMmAAIaOXKldPYsWNVsWJFvfPOO/rkk0/UoUMHPfzww1ZXLdtFF12kcePGKTo6Wu+++66+++473X///Wrfvn2Bz95wOp2aOXOmWrRoobJly3rdp169eqpevXr2PJQGDRrom2++UZs2bTRp0iS9+OKLmjVrVq4HS8bGxuqbb77RZZddpunTp+vFF1/UDz/8oLZt22bPFXE4HPrggw9Us2ZNvfvuu/riiy90zTXX5FqqtzBxcXF67733ZBiGXn31VU2ePFnXXnutbr755jz7XnPNNfrvf/+riIgIjRkzRm+88YY2btyoLl265Nn39NLA7du3V6VKlYpcHwCAtQyzJN02BABku+eee7R9+3b9+uuvVlflvLJ582b169dPr776qv7v//7P6uoAAIqIERMAKAHS0tJy/b5r1y4tWrSI52+chW+++Ubh4eHq1auX1VUBAPiAOSYAUAL07NlTV199tWrUqKH9+/dr8uTJcjgcuuOOO6yu2nlj3rx52r59u7755hvdcMMNCg8Pt7pKAHBe2b17tz755BOtXbtW27ZtU1xcnH766adCy5mmqXHjxumrr75SUlKSGjZsqMcee0zNmzf36f0JTACgBOjcubN+/vlnHT58WMHBwWrevLlGjhyp2rVrW12188aLL76oI0eOqEuXLrrvvvusrg4AnHe2bdumhQsXqlmzZnK73UVeKGbcuHF67733NGrUKNWvX1//+9//dNttt+nHH3/MXqq+KJhjAgAAAEButzt7mf3Ro0frr7/+KnTEJD09XR06dNANN9ygkSNHSvIsy3/55ZerS5cuevbZZ4v8/swxAQAAAJAdlPjizz//VGpqqnr37p29LTg4WJdeeqkWLVrk2/v7/O4AAAAAICk+Pl6SZwn4M9WtW1cHDhzIs7hLQZhjAgAAAASIHj16FPj63Llz/fp+x48fV3BwcJ7nbkVFRck0TSUnJ2c/A6swpTYwubz501ZXIaAZJ4oeHeMspZ6wugYBLaN+NaurEPAciZzDxc21YavVVQhoQbWKPqkXZ2fGzresrkK+3AfrWV2FfJy/52WpDUwAAACAQOPvEZHCREVFKSMjQ+np6blGTY4fPy7DMBQdHV3kYzHHBAAAAMBZOT23ZOfOnbm2x8fHq2rVqkVO45IYMQEAAAB85pbb6ip4da5HHVq2bKnIyEjNmDFDDRo0kCQ5nU79+uuv6tKli0/HIjABAAAAoFOnTmnhwoWSpP379ys1NVUzZ86UJLVt21YxMTEaMmSIDhw4oNmzZ0uSQkJCNGzYML3//vuKiYlRvXr1NGnSJB07dky33367T+9PYAIAAABAiYmJeuCBB3JtO/37559/rosvvlhut1sulyvXPnfeeadM09SECROUlJSkhg0b6pNPPvHpqe9SKX7yO6tyFS9W5ToHWJWrWLEqV/FjVa7ix6pcxYtVuYpfSV6VK/3vuMJ3skBIlXirq3DWmPwOAAAAwHIEJgAAAAAsxxwTAAAAwEdulcrZEMWKERMAAAAAliMwAQAAAGA5UrkAAAAAH5XUByyezxgxAQAAAGA5AhMAAAAAliOVCwAAAPCRq3Q+o7xYMWICAAAAwHIEJgAAAAAsRyoXAAAA4CMesOh/jJgAAAAAsByBCQAAAADLkcoFAAAA+MhFKpffMWICAAAAwHIEJgAAAAAsRyoXAAAA4CNW5fI/RkwAAAAAWI7ABAAAAIDlSOUCAAAAfOQySeXyN0ZMAAAAAFiOwAQAAACA5UjlAgAAAHzktroCAYgREwAAAACWIzABAAAAYDlSuQAAAAAfuXjAot8xYgIAAADAcgQmAAAAACxHKhcAAADgIxeZXH7HiAkAAAAAyxGYAAAAALAcqVwAAACAj3jAov8xYgIAAADAcgQmAAAAACxHKhcAAADgI5cMq6sQcBgxAQAAAGA5AhMAAAAAliOVCwAAAPCRmwcs+h0jJgAAAAAsx4jJOeJw2HXTPd3Vo28zRUaFaee2BE38cK5WL99RYLmO3Ruqy2UXqV7jaipXPlJHEo5rxaIt+mrcQp1IScu1b5deF6ld1/qq36S6qtUsr3V/7NQjd3xanB+rxHAE23XTA73UvV8rRUaHaeeWv/X527O0esm2AstVq1NRfa9rp/rNauiCxtUUHOLQkG4v69D+o7n2a9I2Tq/97658jzPxrZma/N95fvksJZUjOEg3PdxX3Qe2VWR0uHZuOqDPX52u1Ys2F1iuWt1K6ntzZ9VvUVsXNKmh4FCHhrR5Sof2JRVYrkqtChq74EkFhzp0/+WvatvaPf78OCWOw2HXLbd2Uc9eF6lMmVDF7zikTz9ZqFWrdhVYrlPn+up2SUPVb1BFMTGROnzouJYv264vvlisE6npefYPCwvWTTd3VJduDVW+fKSOJ5/Sxo379cpL05SenllMn67kcjjsuunenupxRXNP37z1oCZ+MFurlxXSN/dopC6XN1G9i6p7+uaDyZ6++aP5efrmQOQIDtKQ5wep541dFFkuUvHrduuzpybrzznrCi1bvmqM7n5riFr1aibDZmjt/A3678jPdHDnoVz7hUeF6/on+qvT/7VVherldexQsv6cu15fPPetDu89kr3fTc9co5ufuTbP+2SkZahv+A3//sOWII5gu24a0Vvdr27l6Yc3H9Dnb87Q6sVbCyxXLa6i+l7fQfWb19QFF1X3fNd1eiHPd91pYREhuu6+S9W5TzOVrxSt5KMntHn1Lr0x8iulpzmL46MBkghMzpmHnr9anXo21g9fLdP+PYm69KoWeuH9G/XonZ9qw5r8L7juf+oqJR1O0byf1+nwwWOqfWGsrhx8sdp0qqd7r/uvMs64kLji2ja6oGFVbd2wX1HRYefiY5UYI18dpE6XNdEPExfrwK4j6tm/lZ4fd5tG3/SRNhRwYdewRU1ddXNH7dmeoL07Dqluo2pe99u745Bee2hSnu09/q+lWnWurz8L+VIIBCPfuUmdrmihH8bN14Gdh9Tz2nZ6/st7NHrgu9rwe/4XcQ1bxemq27tpz9a/tXfbQdVtUqNI7zf0uQFyuUrP46seGX2FunRtoCnfrdT+fUm67PKmeunVQXpoxP/01/p9+ZYbOaq3Eo+kau7sDTp0KFl16lRSv6tbqW27urrrzgnKyMjpIyIiQvTWuzeqYsUy+nn6au3ff1Rly4arSdMacjiCSmVg8tCLA9Tp0ov0w5dLPX1zvxZ64cMhevT2T7Rh9e58y93/zP95+uaf1ujw38mevvm6dmrTuZ7uvfbDXH1zIHr40+HqPLCdpr77i/Zv+1u9hnTTf35+TKO6P6cNS/K/WREaEao35j2jiOhwTXp5qjKdLg148Aq9ueA53dXiYaUkpUqSDMPQq78+pVqNqmvaf2dp/9YDqnpBFV15dy+17tVMtzd6UKdScweA7979ca5t7gDsP0a+fp069W6mHz5dpAO7DqvngDZ6fsKdGn39GG34Y2e+5Rq2qK2rbumsPdsStHd7guo2rp7vvuFlQvXa5OGqUDlaMyYt19+7jyg6JlKN29SRIziIwOQMrMrlfwQm50C9i6qpW++mGvfWLE35fIkkac70tfrou+G6fUQvjRwyPt+y/3n4a637Y1eubds2HtDDLw5Q9z5NNfP7P7O3v/bEFCUeSpFpmhr73fBi+SwlUb2mNdTtiuYa/8pPmvLJIknSnO9XaewvI3XbI3300KAx+ZZdPnejrmn1jE6dSNeA27vkG5gcS0zV/Gmr82y/4b5LtW/nYW0t4MIxENRrXkvdrm6t8c9N1ZSxcyVJc75dobHzn9RtT/6fHrrqzXzLLv91na6pv9rTxnf1KFJg0rJbQ7Xq1lDfjpmj60f09tvnKKnqN6ii7j0aa+x/5+rbr1dIkn79db0++fRODR3WXfff+3m+ZZ97ZqrW/uPmxtatf2v041ep56WN9cvPa7O3335nN8XGRumuOyfo4MHk7O2TJy338yc6P9S7qLq69WmmcW/M0JSJiyVJc6at1kff36/bR16mkTd9nG/Z/4ycpHX/uBDctnG/Hn7pGnXv21wzp/5RrHW3Uv02F+iS6zrpo4c/13dvTpckzf58ocatf0t3vnqjHuz0ZL5lr7qnl6rXq6rhbUdr6x+eGxorZ6zWuPVv6ZqHrtSEJzw3gBq2u1AN2l6g9+8dr2ljZmWX37dlv0ZNGK6WPZtqyQ+/5zr2ou+W63hiir8/bolRr1lNdbuqpca/NE1Txi2QJM2Z8ofGznpEt42+Qg8NfD/fssvnbNA1zZ7w9MN3diswMLn14b6qVK2c7rviLSWcMbL97Ud++yhAvphjcg507tlYrkyXZkzJ+aJyZmRq1g9/qlGzmqoQG5Vv2X8GJZK0dN4mSVKNOhVzbT+ScFymWfpmYnW6vImnfbMu6KSs9v12pRq1rK0KlaPzLZuafEqnTuRNdymKek1rqFrtCl4DlkDT6YoWnjb+ckn2Nmd6pmZNWqpGbeJUoWrZfMumHjvpUxvbg2y664WB+mH8Av2960jhBQJA164N5HK59fP0nHPJmeHSjJ/XqvFF1VWxYpl8y/4zKJGkxb95RvBq1qyQvS0iMkSX926qn6ev0cGDyQoKssnhsPvxU5x/Ol+a1Td/tzJ7mzMjU7Om/qFGzWupQmz+fcc/gxJJWjp3oySpRlzFPK8Fks4D28mV6dIvH8/J3uZMd2rmhLlq3KG+KlYvn3/ZAe21+fft2UGJJO3dckCr565Xl2s6ZG8LjwqXJB1NSM5VPvHvY5Kk9FMZeY5tGIbCywRutkCn3k095+ukZdnbnBmZmvXNCjVqVUcVqpTNt2xqctH64Ygyobr0mraaOWm5EvYlKchhlyO4dPcTOLcYMTkH6jaoon27E3XyH53Clr/2e16vX0VHEo4X+XjlKkRKko4fO+m/Sp7H6jaqqv27jujkP/Lpt67bm/36kYPJ3or+K5dc1UKSSkVgUvei6toff0gn/5E6sTUr1aVu4+o6cuCYX97r/+7srsjocE1+Z6Y69Gnul2OWdBdcWFn79ibp5MncF1ubN//tef2CWB0+XPQ7wTExEZKk5OScPqJJkxoKCXFo//6jeua5/urYqZ4Mw9DGDfv03ruztGP7ofwOF7DqNqyaT9/sGQGt26CKjiQUve8oV8ETQB4/esJ/lSyBLmheR/u2/q2TKadybd/y+3ZJUt3mtXV4X2KecoZhKK5pTc38dH6e1zav3K7WlzVXWGSoTqWmaesfO3QqNU23PD9IKUmp2rvlgKpdUFl3vnqjNv++3etcls93fKDwMmE6lZqmJT/8ro9Gfa5jh/zf91ulbuNq2r/zcN7vuqz5d3UbVdWRrMDtbDVuE6eQUIcO7D6iJ8YMUftLL5JhM7Tpz90a8/QUxW868K+OH2hI5fI/RkzOgZgKkUo6kppne9IRz4VG+QLuhnpz7S2d5cp06bc5G/xSv/NdTMUoJR3KG9glHfZsi6mU/4jU2bLZDHXp00yb1+7R33vyfgEHmpjYaCV5CZ6Tsr70YyqX9cv7lKsYpetHXK4vXvspTxAUyGLKRyox0UsfkbWtfAXf+ojB17eXy+XWooU5uf7VqpWTJN0xtJsqViyjV16apvfemaWq1crpjbduyA5mSpOYCmWU5CXgO72tfCUf++bbunj65tmB3TfHVCmrpL/zTpo+PZpRvmo5r+XKxEQqODTYa9nT28pXjZEkHU9M0YuD31ZEdLhen/uMJu/7SG8ueE6JB47q4R7P5Zo/knr0hH74YIbeuetjPTfwDc34ZK66Deqgtxc9H1AjKPl+1x06/V2X/whfUVWt7RllveXhPqpQpazeeGiSxjw9VVVqldcrX92jcj5erwC+KnEjJocPH9aSJUsUHx+vY8eOSZLKli2ruLg4dezYURUrnn9D5MEhDjmdeSdCnp4cGRzqKPKxuvVuosv7t9I3n/6mA3sKXtWotAgJdciZ4cqz/XT7hvjQvkXVvMMFiqlYRl+PDeyVuE7ztLGXczhrEqS/2vi2J/vp792Jmvm/pX453vkiJDjIex+R1ebBIUXvqrv3aKQ+fZtr8lfLtP+MFXfCwoIlSaYpjXroK6Wd8vzbbd9+UB+MuUX9rm6tTz9Z+G8+xnknOLSwdvehb+7TVJcPaK1vJizSgQC/WRESFixnet4J0BlpnhG/4KxzzVs5SfmUdebaR5KSDx/X9tW79OOHM7Vrw17VbV5b1z7cTw9PuEcvDHore7/v3/sl17EWT12hzb9v1+P/e0BX3nOZvn71B98+YAmV/3ed//rhsIgQz19M6bEb/qu0rFHcHRv26+3vH9CVN3fS52/O+NfvA+SnxAQmTqdTr776qiZPniyXy6WKFSsqOtoT/ScnJ+vw4cOy2+0aPHiwRo8eraCgElP1QmWkO+Vw5K3v6YuNjCKucNG4RS2NeOb/9MeSbfrsg7l+reP5LD3N6TUH9nT7FscKIpdc6ZlzseiMicWBzNPGXs7hrC9Cf7Rxg5a11X1gWz12zXulbq5Uekam9z4iq82LusJTkyY1NOqRvvr99x365JMFed5DkpYt3ZYdlEjSpo0HdODAUTVu7H3hh0CWkVZYuxexb25ZSyOe668/Fm/VZ+/N9msdS6L0UxlyeAnagkM9QUWGl/kfp8tJyqesI9c+letU0uvzntFrQz7Q4qme+YPLpv2hhF2H9chn96rNp821cuaafOs4f9JiDXvjZrXs0SRgApP8v+v81w+fvh5ZMXdDdlAiSZvX7NbfexLVsGXtf/0egcRtksrlbyXm6v6dd97Rjz/+qKefflq9e/dWmTK5hwtTU1M1Y8YMvf766woNDdWoUaMsqqnvko6kek3XislKz0gsQu54nXqxevbd67V7xyG9OOrrgFwG8WwlHT7udZJqTEVPCpe3oe9/IzgkSB16XaTVS7frmJf0m0CUlJDsdWLl6dSBpIPH/vV73PbU1dqwYocO7klUpeqedI7orPSimEpRqlitnA7ns+b++S4pMVUVvKRrxZT3zCdLPFJ4HxFXt5JeeGmgdu48rOeemSq3K3dwd/oYR73Mfzh27KQiy4SeTdXPa0lHUlTeS6pnTFZ/nXioKH1zZT37/k3avT1BL46cVCr65qS/j6lCtZg828tn9RGJB7z/P01JSlVGWoZiquRN9Tq9LfGAJxPgslsuUXBosFb8tCrXfsumeRaRadyxQYGBiSQd3puoMjGRBe5zPsn3u67S6e+6fz+fJjErZfeol/Tz5MRUlSlljyLAuVdiApMff/xRjz32mPr37+/19cjISF1zzTWy2Wx6++23z6vAJH7L32rWurbCI0JyTbKs38SzXN+OLX8XWL5K9XL6z4c3KznphJ669wul5XM3qrSK3/S3ml1cV+GRIbkmBdZv5lmWdsdG/07Wa9ejscIjQ0vFpPfT4jfsV7OO9RQeGZpr7kf9rLtnOzb8++WSK1Urp9ga5TVx5Qt5Xnv287uVmnxS1zR4+F+/T0m0fXuCmreopfDw4FwT4Bs2rJr9ekGqVC2rV14brGNHT+rxR7/JNSJy2tatByXJawBUvnyk9gZ4+pE38Zv/VrM2dbz0zVl9x+bC+uYY/WfsLUpOTNVT90wsNX3zjrW71PySxgovE5ZrAnyDiy/0vL5ml9dypmlq5/o9qteqbp7XGra9UAd2HMx+DknZ2GgZhmSz554KG5S1kpw9qPCVomJrV9SO1fk/2+N8E7/xgJq1uyDvd13zmpL881237S/PojHlK3sJ2CtFaV986VskA+dWiZn8fuLECVWuXLnQ/SpXrqwTJ86vFU9+m71R9iC7eg9onb3N4bCrV78W2rRub/aKXBUrR6t67Qq5ypYrH6n//HeI3KapJ+75XMlHWYnrnxbPXOdp30EXZ29zBNt16YA22rxmd/aKXBWrlFV1Pyzj2e3K5ko7maGls//618c6Xyz+abWnjW/smL3NERykSwe10+ZVO7NX5KpYrZyqXxB7Vu/x3sNf6flbP8r18+P4BZKkcc9O1WvDP/uXn6LkWrRws+x2m/pe2SJ7m8Nh12W9m2rjxv3ZK3JVqhSlGjVzL8VaLiZCr71+nUy3qUcfmZxrJa4z7dubpO3bE9Sh44W5HsDaqnUdxcZGa1UBD2cLVL/N/stzXg9sk73N4bCr1/+11Ka1e7JX5KpYOVrV63jpmz++RW63qSfu+qxU9c2/fbdM9iC7+gztmb3NERyky265RJuWb81ekatijQqqUb9q7rJTlqtB2wtUr1Vc9rbq9aqqefeLtOi7nOfp7N96QDabTV2v7ZCr/CXXdZIkbT8j4IiukPci+sq7e6lcpWitnLXm7D9oCbN4xlrP+Xpd++xtjmC7Lh3YVptX785ekati1bKqHlfprN5jf/xh7di4X+17XqSocjkLYrTsXE+VqpUrFQ8T9oVLRon8OZ+VmBGT5s2ba+zYsWrSpEmeNK7TUlNTNXbsWLVo0cLr6yXVlr/2adGvf+nW+3qqbEyEDuxNVM8rWyi2Slm9/ewP2fs9/GJ/NW1dR5c3fzp724tjblLVGjH65tPf1Lh5TTXOujMiSUeTTmj18py14C9qWUtNsu5gR5eLUGhYsK67o6skaf2fu/TXn/k/xfh8tmXtXi36Za1ueai3ostH6u/diepxdSvFViundx7/Nnu/Ua8PUtOL66r3hY9kbwuPDNVVN3u++Bpltd1VN3ZQasopnTiepulf5p6EHRkdptZd6mvJr3/lyr8NdFtW79KiaX/qlsf7KbpCGf2967B6XHOxYmuU1zsP/S97v1Hv3aymHeqpd5WcB3yGlwnVVbd3kyQ1auO5GLnqtq5KPX5KJ5JPafqnngnXfy7M+7ToiKxnGaxfvk3b1uZ9Xkeg2LzpgBbM36Q77uymcmXDtX//UfW6rIkqV47WG6/9nL3fo49fqebNa6lHt5eyt73y2mBVrVZOk79apiZNqqtJk5wHpx1NOqFVq3Zl//7fD+botTev07vv36yfpv2piMhQDbymrfbuSdS0aTkPay0ttqzfp0Wz1uvWB3pl9c1J6nlVC8VWLae3n/k+e7+HXxqopm3idHmTJ7K3vTj2FlWtUV7fTFikxi1rqXHLWtmvHU1M1eplOxSoNv++XQu/WarbX7peZStF68D2g+p1c1fF1q6oN+/4b/Z+j068V826Ndaltmuyt00bM0u97+ipF396TN++OV2ZzkwNHHGljiYkZz+sUZJmfbZAAx+6Sg+MHaoLWtTRrg17dWHLOup9ew/t/GuPlnyf83DFL3eN0cKvl2rnX3uUkZahizo2VLfBHbR99U79/FHgzPnZsmaPFv28Rrc83Dfru+6IevRvo9jqMXpn9NfZ+41683o1bXeBetcZmb0tvEyorhriCeoataojSbpqSCdPP3w8TdM/X5y978cv/KiXvhimN769V798tUwRZcLU//au2hd/SD+f8SwroDiUmMDkqaee0pAhQ9S1a1d16NBBcXFx2QFKamqq4uPjtXTpUkVEROizzz6ztrJn4fUnp2rI8O7q0beZIqNCtXNbgp65/3+FBgt161eRJF17a+c8r637Y2euwKR52zjdeNclufYZcm8PSdKXY+cHbGAiSW88/LVuHnFMPfq1VGR0mHZu/lvPDP1Uf60s+C5wZHSYhoy4PNe2AVnBXMK+pDyBSefeTeUIDtKC6aUnjeu0N+6fqJsfuVI9BrZVZHS4dm7ar2du/q/+Wr69wHKR0eEa8uiVubYNuNtzpzVhb2J2YFLavfLyNN2a0FU9ezVRmTKhit9xSE889o3WZz2PJz8XZI1QDb6+fZ7X1qzZnSswWbNmt0Y/Mlm33tZFt9/ZTelpTi1ZvFUffzTPa/pXafD6499pyL091ePKFp6+eWuCnrn3c/11Rrt5U7dBVt98W5c8r61bGR/QgYkkvTrkA92yZ7B63thFZcpFKH7dHj115Sta/9umAsudSk3TqEue0d1v3aIbnhggw2Zo7YINGjtyopKP5MwHTElK1fA2ozXk+UFqd0Ur9R12qVISUzTz0/ma8PhXyjxjNbV5X/2mRu3rq9OAixUcGqxDuw/rm9en6av/TPH6IMbz2Rsjv9LND/VWj6tb53zX3TFef/0eX2C5yKgwDXmoT65tA+70XC8k7EvKFZisW75dT97ysW4e2Vu3PNxX6acytHT2ek14+adSdUMO1jDMErT8zfHjxzVp0iT99ttvio+P1/Hjnk4qKipKcXFx6tKliwYPHqyoqH//XIozRyXgf8aJ0vMMCsuknl8pjeebjPqlb5Wqc82RyDlc3FwbSL0pTkG1alhdhYA3Y+dbhe9kkZV7altdBa/a1NxldRXOWokZMZE8AciwYcM0bNgwq6sCAAAA4BwqMZPfAQAAAJReJWrEBAAAADgf8IBF/2PEBAAAAIDlCEwAAAAAWI5ULgAAAMBH5/vDDEsiRkwAAAAAWI7ABAAAAIDlSOUCAAAAfOQyub/vb7QoAAAAAMsRmAAAAACwHKlcAAAAgI/c3N/3O1oUAAAAgOUITAAAAABYjlQuAAAAwEc8YNH/GDEBAAAAYDkCEwAAAACWI5ULAAAA8BEPWPQ/WhQAAACA5QhMAAAAAFiOVC4AAADAR25W5fI7RkwAAAAAWI7ABAAAAIDlSOUCAAAAfOTi/r7f0aIAAAAALEdgAgAAAMBypHIBAAAAPuIBi/5HiwIAAACwHIEJAAAAAMuRygUAAAD4yM39fb+jRQEAAABYjsAEAAAAgOVI5QIAAAB85DINq6sQcBgxAQAAAGA5AhMAAAAAliMwAQAAAGA55pgAAAAAPnJxf9/vaFEAAAAAliMwAQAAAGA5UrkAAAAAH7lN7u/7Gy0KAAAAwHIEJgAAAAAsRyoXAAAA4CNW5fI/WhQAAACA5QhMAAAAAFiOVC4AAADARy7TsLoKAYcREwAAAACWIzABAAAAYDlSuQAAAAAfubm/73elNjB57IfJVlchoKWZpfbUOmfSzGCrqxDQ0twOq6sQ8Go4Eq2uQsBLcYdaXYWA5tImq6sABBRCPQAAAACW47Y2AAAA4COXyf19f6NFAQAAAFiOwAQAAACA5UjlAgAAAHzkFg9Y9DdGTAAAAABYjsAEAAAAgOVI5QIAAAB8xKpc/keLAgAAALAcgQkAAAAAy5HKBQAAAPjIxf19v6NFAQAAAFiOwAQAAACA5UjlAgAAAHzkNnnAor8xYgIAAADAcgQmAAAAACxHKhcAAADgI1bl8j9aFAAAAIDlCEwAAAAAWI5ULgAAAMBHbpP7+/5GiwIAAACwHIEJAAAAAMuRygUAAAD4yCUesOhvjJgAAAAAsByBCQAAAADLkcoFAAAA+IhVufyPFgUAAABgOQITAAAAAJYjlQsAAADwEaty+R8jJgAAAAAsR2ACAAAAwHKkcgEAAAA+YlUu/6NFAQAAAFiOwAQAAACA5UjlAgAAAHzkIpXL72hRAAAAAJYjMAEAAABgOVK5AAAAAB+5ecCi3zFiAgAAAMByBCYAAAAALEcqFwAAAOAjVuXyP1oUAAAAgOUITAAAAABYjlQuAAAAwEduk1W5/I0REwAAAACWIzABAAAAYDlSuc4RZ4Y07XNp+VzpZKpUrY70f0OkRq0KL/v7AmnWt9Lfu6XQcKlZO6n/7VKZ6Nz7LZgubV4r7dwsHT1sqP2lpm4dVSwf57zhzDD1yxemVs41dSpVqlpH6jvEpgYtCx9+XbXArbnfmjq4RwoJl5pcbOiq2w1FRpfOodvMDFO/fpGpVfMydSpVqlLH0GU3O1Svpb3QsttWuzR3cqYO7nLL7ZIqVjPU4aogteqRuwtKOWpqxqdObfrdpfRTUqUahroPcqhp58LfIxBkOk3N+yJda+c7dSrVVGxtm3rcHKoLWhTeVe9YnamFX6fr0G633C5T5avZdPGVwWrePTjXfmknTC38Ol2blmXq+BG3IqIN1W0epG7Xh6hspcC+V+XMkL7/3KZlc2w6kSrVqGOq/y1uNW5lFlp2xXxDv3xr14GsfrhFO1PX3OHK1Q8nHpJ+m2XTut8NJew3ZLNJ1WqbuvJ6txq3LPw9AhX9cPHKzDA14wu3/pjrzu6b+wyxqX7Lwv8//7nArXnfupSQ1b4XXWzoitvttG8Rubi/73e06Dny2ZvS7KnSxd2lQXdLNpv03lPStr8KLrdgujT+ZUMRkdK1w6TOl0srF0hvP+r5kj3TrG+lLWukqrUkm730fgme6X9vmpo/1VTrSwz1v8uQYZPGPuXWjr8Kbp/ffnJr4iumwstIVw811OFyQ38uNPXBaLecGaWzbb9+y6lF32eqxSVBumqYQzaboQlPZ2jnX64Cy21Y7tL4JzLkypQuvcGhy4c4FBRs6Os3PMc7Le2EqTGj0rV+sUvt+gTpijscCgkz9OVLGVo9P7OAdwgc3791Skt/yFDTbg71GRoqm83Ql8+c1O4NBX/+zcud+vypk3JlSpdcH6IeN4cqKNjQ1DfTtPT79Oz93G5TE588oZU/Z6hh+yD1vStUTbo6tGGxU+NHnVD6ycA+tz95w65fp9jUrrtb19/tkmGX3n7Srq1/FXwRNm+6TWNfDlJkGVPXDXOra2+3Viww9PqjQbn64dXLbJrxjU2Vqkr9b3HryhvcSjtp6I3RQfptVum90KMfLl5fvenSgqlutbrEpv+7yy6bTfr4KZfi/3IXWG7JTy598YpL4WUM9RtqU/vLbVq90NR/R2fSvrAMIybnwM7N0soFhgbeYarXNZ5t7XtKzw6VpoyXRr/jvVymU/rhM+nCJqZGvCIZWd9rdRtJHzxj6LcZprr3y9l/1OtSTCXPfvf183rIUmX3FlN/LjTV7w5DPQZ6YvC2PU29PMytHz9xa+Tb3u/CZzpN/fSZqbpNpOEv22RkNXydRqY+fsatpTNMde1Xui4y9mxxa+1Cl/reHqSuAx2SpFY97XrrrnT9MiFTw9/Kf0Rj6bRMlYmRhr0crKBgT7td3MeuN+5M16rZmepytacbWj4jU4kHTA19OVgXNPccr11fuz4cka6fxjnVpJNdQY7Abfd9W1xavyhTvW4LUacBIZKkZj0c+vCeVP06IV13vpl/d73ipwxFxhi69eXw7DZq3duh94elavVcpzpc7Tnevs0u7d/qVt+7Q3XxFTkjKRWq2/TDO2nasSZTjTo4ivFTWid+s6EVC2y69k6Xel/juWDreKlLTw4N0jfjbXryHe8BdqZTmvKpTfWbuDXqFVd2P3xBI1PvPh2khb/Y1PP/PMdr2MytN7505xpFuaSvW8/cHaTvJ9rV+bLSEWCfiX64eO3e4tbqhaauusOmSwZ62rJNT0OvDcvU9E/ceuBt7/efM52mfv7MrbpNDN39sj27fWs3MjT+GZeWzXCrS7/SMVKNkoURk3Ng1WLJZjPVuU/ONkew1OlyKX6ToaRD3svt3yWdTDXUpmtOUCJJTdtJIWGmVi7IvX/52Nz7lXZrfjNls0kdeuc0iiPYULvLDO3aJB097P2O0N+7pFOpUssuRnZnLXmGuEPCpD8Xlr47SesXu2SzSRf3zrk4dgQbanOZXbs3uXXscP535tJPmgqLNLKDEkmy2w1FRHn+H5y28y+3IqKVHZRIks1mqGlnu1KOSvHrC777d77bsMQpm01q3TunURzBhlr2CtbezS4lF9jG8rSxI3cbh0fZ5Dij3dNPev6MLJu7oyhTzpb9foHqj98M2WymuvXJaUdHsNT5Mrd2bLQpMZ9+eN8uTz/ctquZq39t3s5UaJipFQtyNlarnTfF1hEsNW3r1tEjhk6d9N/nOV/QDxevtVnt2753zuWcI9jQxZfZtGuTWWj7Nv9H+za+2KaQMGk17VskbtMokT/nMwKTc2Dvdim2uhQWkXt77fpZr8d7L5fp9PzpCM77WnCwtGeH5A7sa7V/Zd8OUxWrS2ERuf+T1qpvZL3uvVx2u4fkfc0R7CnndpeuTvvADrcqVDMU+o+2rFHPlvV6/u0R19SuhN2mZn3u1JEDbiUecGvOV07t22aq6zU5d+ddTskRkrdDdYR6tu3fHtgn+987XCpfzabQ8NxtUK2eJ1D7Oz7/lLnaTew6tNutuV+kKfGAW0l/u7VgUroObHOp04CcDqTqhTYFh0pzv0hX/FrPHJOd6zP166dpqlbPprgWgXuHdPd2Q5W99MNxDTzn7t4d3r/MM52e7Y6QvOe4I1jas8MotB9OTjIUHGIqxEufEujoh4vX/qz2/WffXDOrfffn0ze7nJ7tXvvcYE852hdWIJXrHEhOkqJj8m4/ve1YovdylapJhmFqx0ap42U52w/ulVKSPZ3JyVRTkVF+rnCAOJ5Pu0dlbTueaErK2ylXrOYZeYrfILXrlbM9Ya+p1GTP30+lShGlqN2PJ5mKisnbVqe3HU/K/wus5/VBSkowNW9ypuZO8qSyOEKkm54MVuP2ORfCFasb2rbGraMJbpWLzblnsjMrTzr5SGB/SaYeNRXppY3LZG1LKaCNu10XomMJbi36OkMLJ3smPThCpEGPh6lh+5zgLyLapmseDdO099P02eM5t+8vaGnXoMfDZbef33faCpKcZCg6Jm8bnt52NNGQlPf12GqmDMPUtg02db4sJzj8O1c/rHz74YT90qolhtp0MWUL3LgvX/TDxavQvjnRe79RoZohw5B2bnDr4l45/e0h2hcWO+8Ck6NHj2r79u1q06aN1VUpsowMKchL2vbpkRBnet7XJE9KQKsu0tLZUuUaUouO0rEj0qQxkj3IlCvTyLcsCm/3jIy8r0lSZLShFl0M/T7HVOWabjXtYCg5UfpujFv2IMmVKWWkSxHeiwckZ7pk99KWQYWcw5KnXMVqhpp0suuiDja53dKKGS5Nej1Dd/4nRLUaZuWdXx6k5b+49OXLGbpyqENlyhpa+5tLG5Z6Lgb/udhDoHGmmwpy5B3EPp2e5UzPPzCxO6Ty1Wxq1DFIjTo45HZLf8zM0JQ3T2nIi4ZqNMjp6iOibaocZ1fbK+yqVNOmgzvdWvxdun54+5QGPR7u/w9WQhTaD+dzfpWJltp0MbV0tqGqNW1q2dGtY0cMffmhPbsfzsjn/E9Pk8a8GKTgEGng7QUvEhGo6IeLlzOf9g0q5LyOjDbUvIuhlXNMxdZ0qUkHm5ITTU0d48puX64vCucOwMSjHTt26MUXX9Tq1asVERGhfv366cEHH1RwsJf0nTMcPXpUb7/9thYtWqRjx46pevXquuGGG3Tdddf59P7nXWDy+++/68EHH9SmTZusrkqRBQfnDEuf6XSH4W2o+rQbH/B0Dt+NM/TdOM+2i3uYqlhFWr1ECgnzf30DRWHtXtD/sUH3G8pIN/XDOM+PJLXubqhCFVNrS2G7O0I8qVb/lFmEc/iHMU7t2ezWA++HyGbzXGQ362LXm3ela9pHGbrvnVBJUpU6Nl33SLCmfpChMQ95DlymnHTlMIe+/8CpkFC/fqQSxxFiKNOZN/jILCDl4rSf/5umfZtduuu9iOw2vqhzkD64+4R++ShNw96OlCQl/e3Wp4+dUP+HwtS4o+dqpmF7qWwlQ9+/naatfzhVr3VgTn4vtB8uoD8Y8qBLGRl2ff2x50eS2vdwq1JVadViQ6Fe+gO3Sxr7kl0H9kgjXnSpXHk/fIjzEP1w8XLk076ZRTivr7nfLme6S9PGuTVtnGdkulV3QxWqSOuWmLRvKZScnKwhQ4aodu3aev/995WQkKBXXnlFaWlpevrppwss+8ADDyg+Pl4jR45UlSpVtGjRIj377LOy2+269tpri1yH8y4wOR9Fx3hP10pO8vxZtoAvrPAIafhzUuIhU4kJUvlKnknurzwolYk2FR5ZLFUOCFH5tPvxrHaPKp//hV5YhKGhz9qVdMhUUoJntbOYWENvjXApMloKjwzclBdvomIMr6lUp1O4vKUSSJ6L6pWzXOo2MCj7glmS7EGG6re2ael0lzKdZvaoQNPOdjVqF6q/40253VK1CwzFr/N8YVaoHnh3ps4UWc5Qipe0i9MpXGUKaOM/f3Wq04DgPG18YesgrfgpI7uNV8/JUKZTqt82d9ff4GKHpDTt2egK2MAkOsbUscS8bZic5NlWrnz+I1LhEdIDz7mUeMilIwcNlY81VSFWevFBe7798Kfv2LV2haGho11q1CKw0xALQj9cvKJiDCV76Tey++ZC2vf2Z4N09JCppART5SoZiok19O6ITEVGexbUQOkyefJknThxQh988IHKli0rSXK5XHruuec0bNgwxcbGei13+PBhrVixQi+//LL69+8vSWrfvr3Wr1+vn3/++fwMTK688soi7XfixIliron/1agrbVkrnTqRe+Llzs1Zr8cVfozylTw/kiefec92qWVH/9c1kFSLM7RtralTJ8xcEy93b/F02NXrFn6MmEqGYrLb3dTe7VLzjqWvs64SZ9OOtZlKO2HmmmS5d4snaKha13ubnEzx3Dn2NjnYnSmZbs/PmYIchmrUzznetjWeHS5sHtiBSZU4u3aty1DaSTPXBPh9W1zZr3tzKsXMt41dmWauNj5xzJRMz7+Jzog/XC7P/wl3AGcb1axravNaI08/HL/Z09Y16hYePHj6Yc9+J1Ol3dsMteqUt9zXH9u0eJZN193tUrtLSm9QItEPF7dqcYa2rzXz9M2n27daPn3zmcpVMlSukme/U6mm9m431Yz2LRLXeb4C1j8tWrRI7du3zw5KJKl379565plntGTJkuyg458yMz3zR8uUKZNre2RkpE6e9G05whLzTR8fHy+bzaaLLrqowJ/q1atbXVWftewsud2GfvslZ5szQ1r6q1SngZnd4SYekv7eU/jxvp8guVxST+/nB7I07+xZLWfpjJwLA2eGqRW/mqrVQCpX0dOhJB0ylbC38IuH6Z96LgC7XR1YHVFRNO1kz5obkvMchswMUytnu1SzvqGyFT1dydFDbh3am3OF7LnrJv211JUrTSn9lKmNK9yqVMMoMEXp8H63lv+cqYZtbaoY4CMmjToGeeaGzMhJCs90mlo9x6nq9e2KzmrjY4fcOrw3J4KIiDYUGiFtWpaZp423/J6pCtVt2W1cvppNpilt+C137sf6hZ7fq9QN3NnZrTubcrsNLfgl5zxyZnie1B7XwJ1946eo/fB3E2xyuaRe/XNHhDO+sWnmd3ZdcZ1Lva4O7JXkioJ+uHg1y2rfZTNyzrXMDFO//+pWrQZGdvseLWL7/vSpW26X1PXqwO5v4V18fLzi4nLfLY+KilLFihUVH5/PErKSqlSpok6dOmns2LHavn27UlNT9csvv2jJkiW64YYbfKpDiRkxufDCC1WrVi29/PLLBe43a9YsrVy58hzVyj/iGkitOpua+ql0PFmqVFVaNls6kiDdPDJnv09fl7auM/TxrJzOY8bX0oFdUp0GnqfFr1kmbVxlqN8QM3u54dPWLpf2ZZ03Lpe0b6f081ee35u1k6oXYWQmkNRuYKh5Z0PTPzWVesytClWl3+d4UuKuG5HT6X75ulvb10vvzcy5KJv9tVt/75JqNZBsdmn9UlOb/5T6DjGyl7ksTWo2sKlpZ7tmfJap1GSpfBVDq+a6dDTB1DUP5iQxf/2GU/Hr3Xpthic52WY31KV/kGZ9nqkPRqSrVY8gud2e9K7kI6YGP5w7beiNoWlq2tmuspUMJR00tfznTIWXMdT/voIn3QWCGg2C1LhTkOZMTNeJZFPlq9i0eq5TxxLc+r8HcialT33rlHatd+n5nz3L5djshjr2D9HcL9I17qETatbdIdMt/fmrU8ePmBowKmdyToueDi2ZmqFpH6Tp73i3KtW06cAOl/6c5VSlWjY1bF9ivhL8rm5DU226uDVlgk0px6RKVU0tmW1TYoJ028ici7pxr9m1ZZ1Nn/6aE7z9PNmmfbsM1W3gWVnrz6WGNqyyqf8tLsXVz+mvVy029M14u2KrmapSw9TSObn7isatTEWXK/aPWqLQDxevWg1satbZrZ8+dSvlmFShqqGVc9xKSpAGn9G+/3vdpR3rTb09M6fPnfO1Swd3marZwJA9q323/GmqzxCbatYnMDmf9ejRo8DX586d63X78ePHFRWVdym26OhoJScnF3jM999/XyNGjFDfvn0lSXa7XU8++aQuu+yyAsv9U4n5FmratKl+++23Iu1rmuff0Phtj0g/TpSWz/Wkt1SvI933vFSvScHlqtX2THJfu9yTZlE9Thr6hKnWXfLu++diadnsM9Jstnt+JKlcBbPUBSaSdNPDhn6eKK2ca+pkqlS1jjTsOZsuaFLwl1rV2obWLXVr/QrJdHnK3fq4TS26lN4vw0GjHCr7uaE/52bqVKpUpY6hW58LVlyTgu+y97jOoZjKhhb/mKk5XzmV6ZSq1DZ00xPBatIpd9kqcTb9MdullKOmIqI9c0563eTI80DAQNX/oTDN+yJda+c5lZZqKraOTTc8E67aFxXcVXcdHKJylW1a9mO6FnyVLlemFFvbrkGP50xyl6TwKJvueidC875M15YVTq38xVR4lKEWlzrUc0hIrgc0BqI7H3Fp6mc2LZ1r04kUqUacqQdecKl+04K/U6rXMfXnEkNrltvkdnnK3fNkptp0yV1ub7yn/RL2Gxr3Wt5/s0dfz1R0ufPv++vfoh8uXjc8bNeMiW79MdetU6lS1TqG7nzOrrpNCg4uqtQ2tH6pqb9WuGW6PH36kMftat6FoKSozveHGfqLaZp67LHHtGvXLr355puqWLGili5dqpdeeknR0dHZwUpRGGYJucrfs2ePtm3bVmiUl5aWpsTERFWrVu1fvd/CXfX+VXkULM0sMTFvwEozA38UwUpp7sCcBF6S1HDk8xAn+E2KO8CXs7OYq+RkxAesPnX+sroK+XpgtW9L4Z4r77aYdFbl2rdvr4EDB+qhhx7Ktb1z587q16+fRo0a5bXc/Pnzddddd2natGmqXz8nnefJJ5/UwoULizzwIJWgOSY1a9YsNCiRpNDQ0H8dlAAAAADIERcXl2cuSUpKig4fPpxn7smZtm/fLrvdrnr1ct/0b9iwoQ4dOqRTp04VuQ4lJjABAAAAzhdu01Yif85Wly5dtHTpUh0/fjx728yZM2Wz2dSxY/5LwVarVk0ul0tbtmzJtX3Dhg0qX768wsKK/lAcAhMAAACglBs8eLAiIiI0fPhwLV68WFOmTNFrr72mwYMH53qGyZAhQ3TppZdm/96lSxdVrVpV999/v3788UctW7ZMr7/+ur7//nvdeOONPtWBiQAAAABAKRcdHa2JEyfqhRde0PDhwxUREaGBAwdqxIgRufZzu91yuXKWrY+MjNRnn32mt99+W2+88YZSUlJUvXp1jR492ufApMRMfj/XmPxevJj8XvyY/F68mPxe/Jj8XvyY/F68mPxe/Ery5Pd7/vTtovtcGdPyS6urcNb4HwUAAADAcgQmAAAAACxHvg0AAADgIx6w6H+MmAAAAACwHIEJAAAAAMuRygUAAAD46N88zBDe0aIAAAAALEdgAgAAAMBypHIBAAAAPnKLVbn8jRETAAAAAJYjMAEAAABgOVK5AAAAAB+5eMCi3zFiAgAAAMByBCYAAAAALEcqFwAAAOAjHrDof7QoAAAAAMsRmAAAAACwHKlcAAAAgI/crMrld4yYAAAAALAcgQkAAAAAy5HKBQAAAPjILVK5/I0REwAAAACWIzABAAAAYDlSuQAAAAAfsSqX/zFiAgAAAMByBCYAAAAALEcqFwAAAOAjt8n9fX+jRQEAAABYjsAEAAAAgOVI5QIAAAB8xKpc/seICQAAAADLEZgAAAAAsBypXAAAAICP3CKVy98YMQEAAABgOQITAAAAAJYjlQsAAADwEaty+R8jJgAAAAAsR2ACAAAAwHKkcgEAAAA+IpXL/xgxAQAAAGA5AhMAAAAAliOVCwAAAPARqVz+x4gJAAAAAMsRmAAAAACwXKlN5eoY6ra6CgEuw+oKBDybMq2uAvAvldqvoHPGaaZZXYWAdtRN+5ZmpHL5HyMmAAAAACxHYAIAAADAcoyjAwAAAD5yi1Quf2PEBAAAAIDlCEwAAAAAWI5ULgAAAMBHrMrlf4yYAAAAALAcgQkAAAAAy5HKBQAAAPiIVC7/Y8QEAAAAgOUITAAAAABYjlQuAAAAwEekcvkfIyYAAAAALEdgAgAAAMBypHIBAAAAPiKVy/8YMQEAAABgOQITAAAAAJYjlQsAAADwkUkql98xYgIAAADAcgQmAAAAACxHKhcAAADgI7dI5fI3RkwAAAAAWI7ABAAAAIDlSOUCAAAAfMQDFv2PERMAAAAAliMwAQAAAGA5UrkAAAAAH/GARf9jxAQAAACA5QhMAAAAAFiOVC4AAADAR6zK5X+MmAAAAACwHIEJAAAAAMuRygUAAAD4iFW5/I8REwAAAACWIzABAAAAYDlSuQAAAAAfsSqX/zFiAgAAAMByBCYAAAAALEcqFwAAAOAj07S6BoGHERMAAAAAliMwAQAAAGA5UrkAAAAAH7nFqlz+xogJAAAAAMsRmAAAAACwHKlcAAAAgI9MHrDod4yYAAAAALAcIyYl2ImT0qeTDa3bZGj9Jul4iqEXR7t1dW8WzvYH2rf4nTgpTZgsrdskrd8kJacYemm0qat7W12zwED7Fj/a2DcZGdKHn9r00682HU+RLqxr6r7b3WrfuvB+dcZcQ59Otit+lxQRLnXraOrBoS6VK5t7v8Qk6Z2P7Vq03NDJk1KdWtIdN7jUq1vg990ZGdKEz4L162yHUlIM1Y1z6/bb0tWmtavQsnPnBWnS5GDt3m1TWLipjh0yNWxohspG5223pCRDEz4L1rJlQTp+3FBMjKmWLTP16MPpxfGxgGyMmJRgx5Kl/060KX63VL+u1bUJPLRv8TuWLI2ZaGgHbVwsaN/iRxv75slX7PriG5v69HTr0ftcstuk4Y/a9ee6glNevv7RpkdfCFJ0GVOjhrvV/wq3ZswzdOdDQUo/41o49YQ05L4gzVlk6Jor3Xrobrciwk2NejZIP88J/LSal18N1TffBuvSHpm679502WzSo4+Fad16e4HlfvjRoedfDFNUlKl77knXFX2dmjffoZEPhSk9I/e+hw4ZGnZPuFb8HqSrrnLqwQfT1LePU8eOccn4T27TKJE/5zNGTEqwiuWlBVNdqlhe+muzNGhYwR0PfEP7Fr+K5aVFU83sNr5mmNU1Ciy0b/GjjYtu/SZDM+fZNPIul24Z7JYkXdnLpf63Buntj2z64kPvd/WdTum9cTa1aubWx2+6ZGRdVzVvbOq+x4M05Webru/vOd63023as9/QuLcydXFLz53+a/tJN94jvTnGrl5dM+VwFP9ntcKmTTbNm+/Q3cPSNHiQU5J0WS+nbr0tQmM/CtGYD056Led0SuM+CVGzppl68/VT2e17UWOXHnsiXD/95NCA/s7s/d94K1R2u/TRmBOKji72jwXkQvhbggUHe74UUTxo3+JHGxcv2rf40cZFN3uhIbvN1MAr3dnbQkKkq/u6tXaDTQcPeS+3baeUkmroskvM7ItmSerawVR4mKmZ83I2/rnOULmyZnZQIkk2m9Srm6kjSYb+WHt+3y0uyIJFDtltpq68IieICAmW+vRxasNGuw4d8v7Zd+60KTXV0CWXZOZq3w7tXQoLMzVvfk4kt3uPTSt+D9LgazMUHS2lZ0iZmcX2kYA8CEwAAMC/tnmboVo1pMiI3NsvauAJIjZv937h7HR6toeG5J3rEBLiOa7bfXpfKTQk7zFCQz1/btwSuIHJtu02Va/hVsQ/2rdhA1f2695kZMUxIcHe2tfUtu227PZdtcqTORBTztSIh8LU6/Iy6nV5pB4eHaa/DwZu254t0yyZP+czAhMAAPCvHU40VKF83quiilnbDh/xfmFbs5opwzC1en3uS5Kde6SjxwylpRs6nuLZVruGqYTD0oGDuY9xeg7LoSP/8kOUYEmJhsrH5G3f09sSE71f0lWv7mnfvzbkTlfes8fQsWM2pacbSslq3337Pcd4460QBTmkZ54+paF3pmv9erseGhWutDQ/fiDAixI5x+TkyZMKDw/3+prT6dThw4dVtWrVc1wrAACQn/QMKdjL/I6QYM+fafks6FSurHRZN1PTZxmKq2VTj85uJRwx9Mq7dgUFmcrMNLLL9u/r1jfTbBr1nF2PDHerfDlTsxbYNO83I+s9Aveufnq6IYcjb2ASnDUSkp5P+5aNNnVJt0zNnOVQrZpude6UqcNHbHrv/ZDs9k3PMCSZOnXKUyYmxtSrL52SLSvWqVjR1PMvhmnOXIeu6Ov0/kaAH5SoEZMPP/xQbdq0UatWrdStWzd98cUXefbZuHGjevToYUHtAABAfkKCc9KGznR61SdvKVinPfWQS53amXrzv3b1ud6hW+8P0oVxprp28Fx0h4d59qtXV3rlSZf27Td0871B6nuDQ19NsemRe91Z+53neSwFCAkx5fTSvhkZRtbr+Zd9aESa2l2cqTFjQ3XdjZG6/8Fw1anjVof2ngkkYVntdjqI7NYtMzsokaRuXTNlt+cddSntTNMokT/nsxIzYjJlyhR9+OGHGjhwoBo2bKg//vhDL7/8shYsWKB3331XkZGRVlcRAADko2J5U4e8pGsdTvRsq1gh/6ChTKT03n9c+jvBpf0HDVWNNVW1snTTcLvKlTUVVSZn317dTF3SMVNbdhhyuaRG9UytXON5j1o1/PuZSpKY8qaOeGnfxCTPtvLl3XleOy0yUnrpxTQlJKTr4EGbYmPdqlzZ1D33hqtsWbfKZF1ilc/6N4opl/vfym6XoqPM7JQvoLiUmBGTL774Qnfeeaeef/55XXfddXrzzTf1+eefa9u2bbrxxht1+PBhq6sIAADyUf8CU7v3ep41cqb1mzwXzg0uKHw0o0qs1LqZJyg5niJt3GqoXau85RwOz6T6Zo1NORzS8lWe92jXKv+L8/PdhXXd2rfXphP/aN+NmzyjGBdeUPhnj4011ayZS5Urm0pJlbZus6lVy5xlnOvX8/z9n/OBnE4pOdlQ2bKBOyKFkqHEBCa7d+9Whw4dcm1r3bq1vvnmG7lcLg0aNEjx8fEW1Q4AABTk0q6mXG5D303PubTIyJB+nGFTk4ZuVa7k2fZ3grRzd+HHe3ecTS6XdNM1BV9w794nfTvNpi7t3aodwCMmXbs65XIbmv5TzkSejAxpxkyHGjV0qVIlT9CQkGBo957CL+8+Hhcil0u6ZmDOExabN3OpXDm35sxx5Hrw4oxZDrnchlq3KvwJ86WJ1SlbpHIVo6ioKCUlJeXZXrlyZX311VcaOnSorr/+et11110W1M46/5tqKCU1Z6WRBUsNJWQNHt3Q38wefsXZoX2L3/+mSsfPaOP5S6WDWW18Y3/Rxv8S7Vv8aOOiadrIVK9ubr03zqakY57VtqbNsunAQenZR3KCiydesuuPtTatW5AzYeKT/9m0faehJo1M2e3S/MWGlq606d7bXdnLDZ/2f0OCdGk3t6pUMrX/b0PfTLMpuoz01MjAvmhu1NCtbl2d+nh8iI4es6laNbdmzXLo4EFDj47KWS7rpVdCtWZtkBbOy8m7+t9Xwdq5y6aGDVyy26XFS4K08o8g3XFbuho2yPm3CQ6W7hqWrpdfCdP9D4Sr16VOHTpk03dTHWraJFNdOvNQExQvwzRLxorH99xzj8LCwvTmm296fT09PV0PPPCAFixYIMMwtGnTpn/1fpkHL/hX5c+VSwfZdCCftcN/nexStSrnuEIB5nxuX1vJGfAsUI9ByreN50w2S3Qbnw9o3+J3Prex0zy3F5Lp6dIHE2z6ebZNx1OkenVNDb/NrY5tcy41bnsgb2CyaJmhsZ/btHO3IZdbqhdn6uZr3erVLe8lyiPP27XmL0OJR6Vy0VLXDm7dc6tb5cudk4+Yy1H3uV0/Nz1DmjAhRL/OCVJqiqG4OLduvy1dbdvkBGUPjAjLE5gsW27XxM9DtHuP55klcXFuXTswQ5d0835+zJ0XpK8mBWvPHpsiI0117ZqpoXekK58FU4tV5WoHzv2bFlGTac9YXQWv1l/1nNVVOGslJjCZMWOGJk6cqLFjx6ps2bJe93G5XHr22We1ZMkSzZs371+93/kSmAD5OV8CEwDWOdeBSWlzrgOT0qgkByaNf3zW6ip4taHfs1ZX4ayVmMDkXCMwwfmOwARAYQhMiheBSfEjMPHd+RyYcGUDAAAAwHIlZvI7AAAAcL4onTlHxYsREwAAAACWIzABAAAAYDlSuQAAAAAfne8PMyyJGDEBAAAAYDkCEwAAAACWI5ULAAAA8BGpXP7HiAkAAAAAyxGYAAAAALAcqVwAAACAj3i+ov8xYgIAAADAcgQmAAAAACxHKhcAAADgI1bl8j9GTAAAAABYjsAEAAAAgOVI5QIAAAB8xbJcfseICQAAAADLEZgAAAAAsBypXAAAAICPWJXL/xgxAQAAAGA5AhMAAAAAliOVCwAAAPCRyapcfseICQAAAADLEZgAAAAAsBypXAAAAICPWJXL/xgxAQAAAGA5AhMAAAAAliOVCwAAAPAVqVx+x4gJAAAAAMsRmAAAAACwHKlcAAAAgI94wKL/MWICAAAAwHIEJgAAAAAsRyoXAAAA4CtSufyOERMAAAAAliMwAQAAAGA5UrkAAAAAH5k8YNHvGDEBAAAAYDkCEwAAAACWI5ULAAAA8BWrcvkdIyYAAAAALEdgAgAAAMBypHIBAAAAPmJVLv9jxAQAAACA5QhMAAAAAFiOVC4AAADAV6zK5XeMmAAAAACwXKkdMbERkwEAApzd4LuuODm5ZQ74FT0WAAAA4DOjhP6cvR07dujWW29V8+bN1bFjR7322mvKyMgoUtmEhAQ9+uijateunZo2barevXtr2rRpPr1/qR0xAQAAAOCRnJysIUOGqHbt2nr//feVkJCgV155RWlpaXr66acLLHvo0CENGjRIderU0QsvvKDIyEht27atyEHNaQQmAAAAQCk3efJknThxQh988IHKli0rSXK5XHruuec0bNgwxcbG5lv29ddfV+XKlTV+/HjZ7XZJUvv27X2uA6lcAAAAgK/MEvpzlhYtWqT27dtnByWS1Lt3b7ndbi1ZsiTfcqmpqZoxY4auv/767KDkbBGYAAAAAKVcfHy84uLicm2LiopSxYoVFR8fn2+5DRs2yOl0KigoSDfeeKMaN26sjh076vXXX5fT6fSpDqRyAQAAAAGiR48eBb4+d+5cr9uPHz+uqKioPNujo6OVnJyc7/GOHDkiSXryySd17bXX6t5779W6dev03nvvyWaz6aGHHipy3QlMAAAAAF+xWrQkye12S5I6dOig0aNHS5LatWunEydOaMKECRo+fLhCQ0OLdCwCEwAAACBA5DciUpioqCilpKTk2Z6cnKzo6OgCy0meYORM7du319ixY7V7927Vr1+/SHVgjgkAAABQysXFxeWZS5KSkqLDhw/nmXtypgsuuKDA46anpxe5DgQmAAAAgK9Mo2T+nKUuXbpo6dKlOn78ePa2mTNnymazqWPHjvmWq1atmurVq6elS5fm2r506VKFhoYWGricicAEAAAAKOUGDx6siIgIDR8+XIsXL9aUKVP02muvafDgwbmeYTJkyBBdeumlucqOGDFC8+bN03/+8x8tWbJEY8eO1YQJE3TLLbcoPDy8yHVgjgkAAABQykVHR2vixIl64YUXNHz4cEVERGjgwIEaMWJErv3cbrdcLleubd27d9dbb72lMWPGaNKkSapUqZLuu+8+DR061Kc6GKZplso1BdwH61ldBQAAipVbbqurEND+dp2wugoBr0a1v62uQr5qTXjN6ip4tfu2R6yuwlkjlQsAAACA5QhMAAAAAFiOOSYAAACAr0rlZIjixYgJAAAAAMsRmAAAAACwHKlcAAAAgK/+xcMM4R0jJgAAAAAsR2ACAAAAwHKkcgEAAAA+MliVy+8YMQEAAABgOQITAAAAAJYjlQsAAADwFalcfseICQAAAADLEZgAAAAAsBypXAAAAICveMCi3zFiAgAAAMByBCYAAAAALEcqFwAAAOArVuXyO0ZMAAAAAFiOwAQAAACA5UjlAgAAAHxFKpffMWICAAAAwHIEJgAAAAAsRyoXAAAA4CtSufyOERMAAAAAliMwAQAAAGA5UrkAAAAAX5mG1TUIOIyYAAAAALAcgQkAAAAAy5HKBQAAAPjIYFUuv2PEBAAAAIDlCEwAAAAAWI5ULgAAAMBXpHL5HYFJCXbipDRhsrRuk7R+k5ScYuil0aau7m11zQID7Vv8aOPiRfsWP9rYNxkZ0vsTDE3/1dDxFKleXen+293q0Kbwsr/MNTRhkqEdu6WIMOmSjqZGDjNVrmzu/Y4kSW9/ZGjRckMnTkpxtaQ7b3DrskuK5SOVKBkZ0sTPQjRntkMpKYbi4ty69bY0tWrtKrTs/HlB+npyiHbvtik83FT7Dpm6c2i6oqPzXl0fTTL02WchWr4sSMePG4qJMdWiZaZGPZxWHB8LyEYqVwl2LFkaM9HTSdeva3VtAg/tW/xo4+JF+xY/2tg3j79s6PNvDF1xqanR95my26S7H7Vp1bqCy03+wdDDz9sUHSU9co+pgVeYmjHP0G0jbUpPz9kv9YR00702zV5k6JqrTI26x1REuDTyWbt+mh34z5R4/dUwffdtsLr3cOqee9Nks5l6/LFwrV9vL7DctB8d+s+L4SoTZeque9LUp69TC+Y79PBD4crIyL3voUOG7rknQr//HqQrr8rQ/Q+mqXefDCUfC/z2hfUYMSnBKpaXFk01VbG89Ndm6ZphVtcosNC+xY82Ll60b/GjjYtu3SZpxjybRt3t1q2DPXfh+11mqt+tNr011qb/jXF7LZfhlN4dZ6h1M1Pj33TLyLr+bX6RqeGP2fXdT4ZuGOA53jfTDO3Zb+iTt11q19Kz3+B+pq6726bXxxjq1c1UsKPYP6olNm+yaf58h4YOS9O1gzzRRK9eTt1xW6TGfRSi9z446bWc0ylN+CRUTZtm6rXXT2a3b+PGLj35RLh+/smhq/s7s/d/561Q2e3Sh2NOeB1NAYoTIyYlWHCw50sRxYP2LX60cfGifYsfbVx0vy4wZLebuubKnIvZkBBpQB9TazYY+vuQ93Lbd0rHUw1dfomZfdEsSd06SOFhpn6Zl7Nx1TpDMWXN7KBEkmw26fJLTB1JMvTHGj9/qBJk0SKHbDZTfa/IGeIIDpYu75OhjRuDdOiQ9xGNXTttSk011PUSZ672bdc+U2FhphbMz4nk9uyx6fffHbr2Wk+KV0aGlJlZbB8JyMOnEZOUlBR9/vnnWr9+vUJDQ1WpUiXVq1dP9evX14UXXqjQ0NDiqicAACjBNm8zVKu6FBmRe3uThmbW61KVSnnLnU4lCg3J+1poiKec2+0JQDKcnmDH236StGGroQ5tAvMu//btdlWv4VbEP9q3QQPP/JId2+2qVClvFOF0eqKRkOC8xwwJMbV9uz27ff9c5UkJK1fO1MMPhWv16iDZbKZatXbpgQdPqXLlwGxblBw+BSYPP/ywFi5cqAoVKqhs2bJatmyZkpOTZRiGDMNQjRo1sgOVevXqqV69eqpVq5YMg7xEAAAC2eEk76NLFbK2HU405G0Zo1rVJcMwtfov6eo+Odt37pGSsuY1HE+RykZLdWqYWr7K0IGDUtXKOfuensNy6LCfPkwJlJRoqHxM3vY7vS0x0fu1VrXqbhmGqQ0b7Lq8d07K1t49Nh075kmcSUkxFB1tav9+z+9vvxWq+g3cevLpkzqUYNMXn4fokVER+nh8qrgHnYMHLPqfT4HJsmXL1KdPH7355pvZ2xISErR161Zt2bJFW7du1datW7VgwQI5nU4ZhqHQ0FCtXr26yO9x+PBhOZ1OVa1aVZJkmqZmz56t3bt3q2bNmurRo4eCgpgaAwBASZKeLq/zO07fqU9Lz/uaJJUr60nF+nGmobhaUo/Opg4dlv7znk1BQaYyM43ssgOuMPX1NEMjn7Xp0XvdKl9OmjXf0NzFnovy9Azv7xEI0tMNORx55+k4gs3s172JjjbVtVumfp3lUM2abnXs5FTiEZs+eD80u31Pj1qdOuU5RkyMqf+8dFK2rIT/ihXd+s+L4Zo316E+fZ1e3wfwB5+u8MuUKaO2bdvm2hYbG6vY2Fh17tw5e5vL5dLOnTuzg5WiSE1N1QMPPKClS5dKknr06KE33nhDw4YN04oVKxQUFKTMzEw1bNhQX375pSL+OZYJAAAsExLiSbX6p/QCUrVOe+YhU2nphl4fY9PrYzzbrrzUrRpVDc1ZJIWHebbVryu99pRbz79l043DPWlHFWJMjb7X1PNvGQoL8+MHKmFCQszstKwzOTOM7Nfz8+CIU0pPD9NHY0P10VjPkEfPnhmqUtWtxb85FBbmKXs6iOzazZkdlEhSl66ZeuVlz6gLgQmKk0+ByeWXX661a9dq0KBBBe5nt9t1wQUX6IILLlDfvn2LdOwPPvhAGzZs0PPPP6/o6GiNGTNG999/v/bu3asffvhBDRo00Jo1a3Tvvffq008/1b333utL1QEAQDGqGCMlHMm7/Uhi1uvl879wLhMpffCSWwcS5EnTivWkat1wj2eye1SZnH0v6yZd0tGtLds9c08a1pNWrvG8Vru63z5OiRNT3tSRI3kDk8Qkz7byBbRvZKT0wounlJCQpoSDNsXGuhVb2dT994arbFm3IiM9+5Wv4BmRKVcu97HsdikqylRqCqn5uZi0h7/5tCrXgAEDtHXrVs2aNcvvFZkzZ47uu+8+XXPNNerVq5f+85//aNGiRbrnnnvUoEEDSVLz5s11++23F8v7AwCAs9fgQlO793meNXKmdRuNrNcLP0bVWKl1M09QcjxF2rBVatcq7wV3sENq0lBq1tjz92V/eN6jfevATfqvW9elfXttOvGP9t28yTNyVPeCwh+yGBtrqmkzl2Irm0pNlbZts6tFy5xyF9bz/P3IkdyXh06nlJxsKLps4LYvSgafApOrr75aGzdu1IMPPqhbbrlFEydO1B9//KGUlJR/XZGEhATVq1cv+/cLL7ww15+nNWjQQPv37//X7wcAAPynV1dTLpehb6fn3EXOyJC+n2GoaSMze0WuAwlS/O7Cj/fOx4ZcLunmawq+GN69z/N8k67tTdWu8W8+QcnWpWum3G5DP/+Us7xWRoY0a6ZDDRpmqlIlTzslJBjas6fwy7vx40LlckkDBuZM/mnWzKWy5dyaO8eR68GLs2Y55HYbatWKtYNRvHxK5Xr55ZezJ7hv2bJFy5cvz15xq3Llyqpfv77q16+vESNG+FyRyMhIHTt2LKdiQUGKjY1V2D8SRtPT02WzlZ7Hr/xvqnQ8VTqUNTw+f6l0MGvVkRv7e4a/cfZo3+JHGxcv2rf40cZF07SRdFk3t9752FDiUalmNenHWZ4VtF54NGfS9uMv2bRyjaENC3Pu1I/7n6HtO6WmDT1pQ3MXG1q60tD9d7jVpGHu97nyZpsu62aqSqy072/p6x8NRUdJzzzk/QGOgaJhQ5e6dHXqk/EhOnbMUNVqbs2e5dDBgzY9NCrn4YqvvhKmdWuDNGfe8extk74K1q5dNjVo4JLdLi1Z4tCqP4J0621patAgp92Cg6Whw9L12ithGvFAhHpemqFDh2z6fmqwmjTJVKfOBCa5MIDkd4ZpmmfdrElJSdqyZUv2JPctW7YoPj7ep1W4TrvpppvUrFkzjRo1qsD9PvroI82aNUtTp04922pLktwH6xW+UwnQY5B04KD3HMY5k01Vq3KOKxRgaN/iRxsXL9q3+J3PbezWub1YT0+X3p9gaPqvho6nSvXipPtud6vTGevm3PJA3sBk4TLpvxNtit/tmTdSL04acq1bl12S9z1GPWdo9V+e4KdctHRJB1PDbzNVvtw5+ID/8LfrROE7+VFGhvTphBDNneNQSoqhuDi3brktTW3a5LTlyBHheQKT5cuD9OXnIdqzxya3W6oT59LAgRnq2s17oDF/XpAmT/LsHxlpqkvXTN1+R5rCw4v9I+ZRo9rf5/5NiyjunbesroJX8Q+OtLoKZ+1fBSbemKZ5Vs8tWbhwoZKTk3XVVVcVuN99992npk2b6s477zzbKko6fwITAADO1rkOTEqbcx2YlEYEJr47nwMTvz8Q5Gwfpti1a9ci7ff++++f1fEBAAAAvyGVy+9Kz2QNAAAAACUWgQkAAAAAy/k9lQsAAAAIdAapXH7HiAkAAAAAyxGYAAAAALAcqVwAAACAr0jl8jtGTAAAAABYjsAEAAAAgOVI5QIAAAB8RSqX3zFiAgAAAMByBCYAAAAALEcqFwAAAOAjHrDof4yYAAAAALAcgQkAAAAAy5HKBQAAAPjKNKyuQcBhxAQAAACA5QhMAAAAAFiOVC4AAADAV6zK5XeMmAAAAACwHIEJAAAAAMuRygUAAAD4iAcs+h8jJgAAAAAsR2ACAAAAwHKkcgEAAAC+IpXL7xgxAQAAAGA5AhMAAAAAliOVCwAAAPARq3L5HyMmAAAAACxHYAIAAADAcqRyAQAAAL4ilcvvGDEBAAAAYDkCEwAAAACWI5ULAAAA8BWpXH7HiAkAAAAAyxGYAAAAALAcqVwAAACAj3jAov8xYgIAAADAcgQmAAAAACxHYAIAAADAcgQmAAAAACxHYAIAAADAcqzKBQAAAPiKVbn8jhETAAAAAJYjMAEAAABgOVK5AAAAAB/xgEX/Y8QEAAAAgOUITAAAAABYjlQuAAAAwFekcvldqQ1M9mSmWF2FgHbSZDCuuB1zh1hdhYDmNEtt93jOhBpOq6sQ8A65ylhdhYD2zeFuVlch4H1Rzeoa4Fzi6hEAAACA5bglCAAAAPiKVC6/Y8QEAAAAgOUITAAAAABYjlQuAAAAwEc8YNH/GDEBAAAAYDkCEwAAAACWI5ULAAAA8BWpXH7HiAkAAAAAyxGYAAAAALAcqVwAAACAj1iVy/8YMQEAAABgOQITAAAAAJYjlQsAAADwFalcfseICQAAAADLEZgAAAAAsBypXAAAAICvSOXyO0ZMAAAAAFiOwAQAAACA5UjlAgAAAHzEAxb9jxETAAAAAJYjMAEAAABgOVK5AAAAAF+RyuV3jJgAAAAAsByBCQAAAADLkcoFAAAA+IpULr9jxAQAAACA5QhMAAAAAFiOVC4AAADARzxg0f8YMQEAAABgOQITAAAAAJYjlQsAAADwFalcfseICQAAAADLEZgAAAAAsBypXAAAAICPWJXL/xgxAQAAAGA5AhMAAAAAliOVCwAAAPAVqVx+x4gJAAAAAMsRmAAAAACwHIEJAAAAAMsxxwQAAADwFXNM/I4REwAAAACWIzABAAAAYDlSuQAAAAAfGVZXIAAxYgIAAADAcoyYnCMZGdLnn4Vo7hyHUlMM1Ylza8itaWrV2lVo2QXzgvTt1yHavdum8HBT7dpn6vah6YqOzjvr6miSoc8/C9GK5UE6ftxQTIyp5i0yNfLhtOL4WCWGM0OaNDFYC+YE6USKoVpxbl1/a4aatyq8fX+bH6QfvnZo726bwsKlNu0zdfOd6YqKzr/MxvU2PTEiXJI0cUpqgfsGCmeG9P3nNi2bY9OJVKlGHVP9b3GrcavCZ/+tmG/ol2/tOrBbCg2XWrQzdc0dLpU5o90SD0m/zbJp3e+GEvYbstmkarVNXXm9W41bBv4MQ2eGNO1zaflc6WSqVK2O9H9DpEatCi/7+wJp1rfS31nt26yd1P925WpfSVowXdq8Vtq5WTp62FD7S03dOqpYPk6J5MyQpn5u15IzzuGBt7h0URHO4eXzbfr5W5sO7DayzmG3Bnk5hxfNsmnt7zYdzDqHq9c2ddX1Ll1UCs7h/GRmmJr5hUt/znPpZKpUpY6h3jcHqV7Lwu+Nrl7g0oLvXErYYyokTGrczqa+twUpIrp03qt2O93aP3W3jiw5pMwTmQqvEaHqA2sp+qJyBZZbM/J3ZRxJ9/paSGyomr3eRpJ0+LcE7Ry3Nd/jxN1VXxU6VDr7DwAUghGTc+TN18I09btgde/h1N3D02SzmXrq8XD9td5eYLnp0xx6+T/hiowyNezuNF3ex6kFCxx6dFS4MjJy73vokKH7hkdo5cog9b0yQ/c9kKbL+2QoOTnwO/D3Xg/RtO8c6tI9U7ffky6bTXrx8VBtXF/wKT5zWpDe+k+oIsuYuvWudF3ax6nFC4L0zMNhedr3NLdbGv9BiEJDS9eFxidv2PXrFJvadXfr+rtdMuzS20/atfWvgs+vedNtGvtykCLLmLpumFtde7u1YoGh1x8NkvOMNl69zKYZ39hUqarU/xa3rrzBrbSTht4YHaTfZgX+OfzZm9LsqdLF3aVBd0s2m/TeU9K2vwout2C6NP5lQxGR0rXDpM6XSysXSG8/qlztK3mCly1rpKq1JJu9dJ2/kjTuDbtmTrGpfXe3brzbJZtdevPJIG0p5ByeO92mMS8HKaKMdN0wl7r1dmv5ApteeTQoVz/x5zKbfv7GrkpVPQFPvxtcSjspvTbaoUWzSu/X7eS3MrXoe5daXGLX/w0Lks0mjX/aqZ1/uQsst/Qnl/73aqbCy0hXDg3Sxb3tWr3QrbGPOeXMKH3nryTFj9uqgzP3q3z7iqp1Y5wMm7T1zQ1K2ZJcYLlaN8Qpblj9XD/VB9aSpFxBTZn6UXn2ixtWX+G1IyWbFNWobHF+vPOPWUJ/zmOMmJwDmzfbtGC+Q3cMS9M113q+xXr2cmro7ZEa/3GI3nn/pNdyTqf02SehatI0U6+8dlJG1ndno8YuPfNkuGb87FC/q53Z+7/3dqjsdun9D08oystoSqDautmmxfMdGjI0Xf93rac9uvXK1AN3hOvzcSF65b1TXss5ndKXE0LUqKlLz76Wlt2+9Ru79NKTYZr9s0N9z2jf0379OUhHDtvUs49TP00NLrbPVZLEbza0YoFN197pUu9rPBcTHS916cmhQfpmvE1PvuN9ZCrTKU351Kb6Tdwa9Yoru40vaGTq3aeDtPAXm3r+n+d4DZu59caX7lx3oC/p69Yzdwfp+4l2db4ss1g/o5V2bpZWLjA08A5Tva7xbGvfU3p2qDRlvDT6He/lMp3SD59JFzYxNeIVZbdv3UbSB88Y+m2Gqe79cvYf9boUU8mz3339vB4yYO3YbGj5ArsG35mpPtnnsFuPD3Xo6/F2Pf2O9/Mr0yl9+6ld9Zu49egrmWecw269/bRDC36xqVf2OWzq7S+duc7h7n3devJuh6ZOtKvLZQVfiAeiPVvcWrPQrStut6vbQM8lR6ueNr1xV4Z+mpCp+97y3odmOk3NmJipuIsMDX3JISOr4Ws3NDTh2UytmOFWp34F39gLNKk7UpS0/LBqDK6jKn2qS5IqdIzV+sdXae/XO9Xo6eb5li3XqkKebft/3CNJKn/GCEhopTCFVgrLtZ87w6VdE7crqlFZBZctHd95sE7pvYVzDi1e6JDNZqpP35xba8HB0uW9M7RpY5AOHfJ+t27XTptSUw117ebM/jKUpHbtMxUWZmrBfEf2tj17bFr5u0MDr01XVLSpjAwpM3Cv43JZtihINpupXn1zgojgYKnn5U5t2WjXkXzad88um06kGurUNXf7tmnnUmiYqcUL8sbtKcelrz4N0XVD0hUR4fePUmL98Zshm81Utz45F1aOYKnzZW7t2GhT4iHv5fbtkk6mGmrb1czVxs3bmQoNM7ViQc7GarXzph45gqWmbd06esTQKe/xe0BYtViy2Ux17pOzzREsdbpcit9kKCmf9t2/y9O+bboqV/s2bSeFhJlauSD3/uVjc+9Xmqz8zSabzdQlZ5zDwcFS18tc2l7gOWzoZKqhi7u6c7Vdi+xzOOdrtHpt0+s53KytW0kBfg7nZ91it2w2qV3vnCDCEWyo7WV27d5k6thh7zfRDu42dSpVatbVnh2USFKji+0KCZPWLCo8TTfQJK08ItmkSpdUzt5mC7apYtfKSt2eovRE76la+UlcdkghFUNV5sKoAvc7ujpJ7jSXyrcnhQvFj8DkHNi+3a7q1d15LmTrN/B0rPHbvd/1cTo9nXFwSN7XgkNM7dhulzvrO3b1n55jlCtn6tFR4bqyd5Su7F1GT4wO18GDgX0lsnO7TVWrmwr/R/te2MDTODt3eD/NnVlxTH7tG7/dlt2+p331WbDKxrjV64pSEvVl2b3dUOXqUtg/2jiugeeiYu8O7+dYZtY57AjJe/HhCJb27DDytPE/JScZCg4xFeLl3ylQ7N0uxXpp39r1s16P914uM+scdni5iRkcLO3ZoULbt7Qo7Bzek885XFA/4QiWdhfpHFbAn8P52b/DrQrVDIVG5G7fmvVs2a97U9C5HRQs7d9hyu0uPZkBknRyd6pCK4fJHpb7pllEXKTn9T2pRT7WiV2pSjtwSuXbVyx038Slh2QLtimmdXnfKlwKGGbJ/DmflfjA5OTJkxo8eLA2bdpkdVXOWlKSoZjyec+UmBjPtsRE71+I1aq7ZRimNv6VO3DZu9em5GM2pacbSk3xlD2wz/NP+e5boQoKkh5/6qRuuzNdG/6ya/TDEUoL4LnvSUmGypXP++V2eltSPu1btZqnfTdvyN2++/caOn7Mpox0Q6kpOdt3xdv0608O3XZXhuylK4NAyUmGomPynsOntx3Np41jq5kyDFPbNuTuav7eK6UkG8pIN3SygO/ShP3SqiWGWnc2ZQvgNk9OkqJj8m4/ve1YovdylapJhmFqx8bc2w9mta+zkPYtTY4lSWW9nMNlCzmHK2efw7lfP/McPlHIOfzHEpvadHYH9Dmcn+NJUpSXc7tMTM7r3lSsasgwpF0bc/fth/a5dSJZcqZLp0rZue08luE1ler0NufRfCZGepG4zDNEWNgoSGaqU8nrj6ps85g8ARFQHErEWbZhw4Z8Xzt58qTWrFmjv/76S+6s21KNGzc+V1Xzi4x0Qw5H3gvn4GDPF2J6hvcvxOhoU126Zmr2rw7VqOlWx05OHTli05gPQhUUZCoz01B6Vj906pTnGOViTL3w0knZsq4DK1Zw6+X/hGv+XId69807XyIQeNrXyx15R87r3kRFSx27Zmr+r0GqXtOtiztmKinR0LgPQrLbNyPD0OmZZOM/CFHLti41L8JKaoEmI0MKcuTdfvpu5j8nWZ9WJlpq08XU0tmGqta0qWVHt44dMfTlh3bZg0y5Mg1l5JN9kJ4mjXkxSMEh0sDbA7vNC23ffNqoTLTUqou0dLZUuYbUoqN07Ig0aYyy2ze/sqWNM8NQkLd+IquN81vsoky01LaLW4tn21S1pqlWHT2phV+ccQ7n18bpadL7WefwtQF+DucnM91UkCPvPVBHsKdfdqZ7v70bEW2oWWeb/pjjVqUamWrSwa7kRFM//DdT9iDJlZn//4tA5Xa6ZQTlbUsjq33dGUUbHjXdphKXH1Z4rQiFVQsvcN+klUdkZpq55qEAxalEBCYDBgzIziE1TTNXPulpTz/9dPZr59voSXCImZ2WdaaMrIAkJDj/cbcHRpxSekaYxn0UqnEfhUqSevTMUJWqbi35zaGwMDPrPTz7d+nqzA5KJKlz10y99oqpjRvtARuYeNo37/acFIz82/euB9OVnm7os49C9NlHnkbs2tOpylVMLV8clN2+i+cHactGm94ZXwqTxOVJC8r01sZZF3Pe0i1OG/KgSxkZdn39sedHktr3cKtSVWnVYkOhYXnLuF3S2JfsOrBHGvGiS+UCPIOg0PYtIAXoxgc8F2jfjTP03TjPtot7mKpYRVq9RArx0r6lkSPYLLCNgws4h2990KWMDEOTPg7SpI892zr0cKlSVemPxYbXNna7pDEvBenAHkOjXswM+HM4P0EhhjKdefvg06tqOULyTzUecH+QnBmZ+mm8Sz+N9wR2LbvbVL6KofVL3KXu3LY5bDIz8wYfptOzzRZctCSYlM3Jch7NUOXLqxW6b+LSQ7JHBCm6acHLEZda53naVElUIgKTSpUqye126/7771ft2rVzvXbixAndfffdGj16tBo2bGhNBf+lmBhTiUfydr5JSZ5t5b2keZ0WESk998IpHUpIU0KCTZVi3YqNNfXgfeGKLutWpCe1VOWz0pbKlct9LLtdiooys1O+ApGnffN2yEcTPdu8pdGdFhEpPf5Cmg4nGDqUYKhirKlKsaZG3x+mqLJuRWS178SPg9WhS6YcQdKhrDk7J054XjtyyKZMp6mYCoHbQ0XHmDrmJdUlOescLldAG4dHSA8851LiIZeOHDRUPtZUhVjpxQftKhNtKjwyb5lP37Fr7QpDQ0e71KhF4LbradEx3tO1krPSXMoWcFEbHiENf05KPGQqMUEqX8kzyf2VB5Vv+5ZGZWO8p2sdK+I5POK5TB05JB05aKhC1jn8/INBKhNtZvcTZ/rkHbvWrDB0Vyk5h/MTFSMlH8m7PSUp5/X8hEUYuvUZh44eMpWUYKpcJUMxsYbeH5mhiGgpLDJwv9e8cZQNVsbRvMNEGcc80bWjXNFWzEpcdkgypPLtCp5fkn4kTSlbj6tit8qyeRmpAYpDiQhMZs6cqQ8//FAvv/yyrr/+et1zzz2KyJopnpLiSfJv1KiR2rRpY2U1z1rdC1xauyZYJ04o1wT4zZs8d4/jLih8iL9SrKlKsZ79UlOl7dvs6tg5ZwL2hfU8rx35xwW60yklJxuKLhu4X4y167q1fo1dJ08o1wT4rZs9bVGnbuHD2xVjTVWM9bTRiVRpxzab2nfKad8jh21aNM+mRfPy5ts8dHe4atd16e2PvC9LHAhq1jW1ea2hUydyTx6O3+y5MKhRt/Dzq3wlqXwlz34nU6Xd2wy16pS33Ncf27R4lk3X3e1Su0sC97w9U4260pa1ytO+OzdnvR5X+DE87ev5+8lUac92qWVH/9f1fFWzrqlNXs7hHVnncM0inMMVKkkVKuX0E7u2GWrdKW//Mulju36bZdcNd2eq/SWle/WBqnE27VjrUtoJM9cE+D1bPO1SrW7hF7zlKhkqV8lT9lSqqX3bTDXtVPoulMNrRuj4pmNyncrMNd/jxI6UrNcLvwvhdrqVtDJRUQ2jFVyu4NUYEpcflkzxQEWcUyXif3Z4eLgefvhhfffdd9q0aZMuu+wyff/991ZXy286d8mU223ol59z7mZkZEi/znKoQcNMVcr6ojuUYGjPnsL/SSaMD5XLJfUfkHPnpGkzl8qWdWv+XEeuXOnZsxxyuw21bBW4q0h1yGrfX3/OCRqcGdK8WQ7Va+DKvpA4nGBo357C77B9MT5Ebpd05YCcvI/Rz53K89Opm+f1Bx5N0213F33S4fmodWdTbrehBb/knJ/ODM+T2uMauLMviBMPSX/vKfx4302wyeWSevXPfdE24xubZn5n1xXXudTr6tJzQdeys+R2G/rtl5xtzgxp6a9SnQamYnxs3+8nSC6X1LN/8dT3fNS2s1tut6H5ec5hu+qecQ4fOSQdKEIbfzvBLpdLuvwf5/DP39g04zu7rrzOpctK0Tmcn6adPKsbLp+RcwMuM8PUytlu1axvqGxFT5989JCpQ3sLb69fPs2U2y11/r/St5JATNsKkls6NP9g9ja3063DvyUoom4ZhZT3BBrpR9J06oD3tONja5PkOplZpKV/E5cdVnD5EEXWK3g54VLN6gcp5vdzHisRIyan1a1bVxMmTNDMmTP16quv6quvvtJ9993ndc7J+aRBQ5c6d3Xq0/EhSj5qqGo1t2b/6lDCQZtGjsrpPF5/NUzr1gZp1tzj2du+nhSsXTttatDQ85TiZUscWvVHkIbclqb6DXKvx3/HsHS98WqYHnowQj0vzdChQzb9MDVYFzXJVMdOgRuY1GvoVocuTn35SbCSjxmqUtWt+bMdOnTQ0PCHcpYje/fVUG1YZ9f3c3KWcpkyyaE9u2yq18Atu93UiiVBWrMqSNffmp693LAkXdwx76jWzqxlnlu2zVRUdJ6XA0rdhqbadHFrygSbUo5JlaqaWjLbpsQE6baROe007jW7tqyz6dNfc4K6nyfbtG+XoboNPCtr/bnU0IZVNvW/xaW4+jk96KrFhr4Zb1dsNVNVaphaOif3//vGrUxFB2iac1wDqVVnU1M/lY4nS5WqSstmS0cSpJtH5uz36evS1nWGPp6V024zvpYO7JLqNPA8LX7NMmnjKkP9hpjZyw2ftna5tC9r6WGXS9q3U/r5K8/vzdpJ1YswMnO+qtvQVNsuLn07wa7jxwzFVjW1eLZNRxKk20fm/P/++LUgbV5n0+e/5txsmD7Zpv27DMU1MGW3S6uW2vTXKpsG3pKZ6xz+Y7Ghr8cHKbaaqao1TC2Zk/tG00Wt3AF7DuenVgObmna26ZfPXEpNlipUMfTHXJeSEkxd82DOzaRJbzgVv97UGzNy7uLP+yZTB3eZqlnfJptd+muZS1v/NHX5zXbVrF8i7queU5F1oxTTtoL2fbtLzuNOhcaG6sjiQ8o4kq46t9fL3i/+461K2Zystp93znOMxGWHZDgMlWuT94GLZzq574RO7T2hKldUP++vwXB+KVGByWmXX365unXrpjFjxmj48OFWV8cvHhl9ShM/DdHcOQ6lpBiqE+fW8/85qSZNC07jql3HrSWLHVq+zCGXW4qr49ITT59Ul655A41LeznlCDL19eQQjfsoVJGRpvpc4dStt6cF/PK2D4xO11efmlo4J0ipKYZqxbn1xItpaty04Dtwteq4tWJJkFYuC5Lb7fl91FOn1LFr6VxBpyB3PuLS1M9sWjrXphMpUo04Uw+84FL9pgXfnqlex9SfSwytWW6T2+Upd8+TmWrTJXe5vfGeL7+E/YbGvZa3a3r09UxFlzvPbwUV4LZHpB8nSsvnSidTpOp1pPuel+o1KbhctdqeSe5rl3smXFePk4Y+Yap1l7z7/rlYWjY75yJj73bPjySVq2AGdGAiSUMfcWnKZ9KSuTadzDqHR7yQqQaFnMM16phatcSmP884h+990qm2/ziH98R7LpYT9hv6yMs5/NjrzoA+h/Nz3aggzfzcpVVzXTqVKlWpY+j25xyq26Tg4KJybUPrl7q1YblnlKRqHUM3PR6kZp0D/AutAHFD62vflF1KXJKgzJOZCq8RoQtHNFZUg8LvjrlOZerYmqMq2yxGQeEFX/4lLi3acsIIPDt27NCLL76o1atXKyIiQv369dODDz6o4IJWCPmHzz77TC+//LK6deumjz76yKf3N0zTLNG95IEDB7Rv3z41atRIkZH+m8W5a18Vvx0LeZ00S9/drHPtmLsUPq3tHHKaJfK+TUAJNQJzpcCS5JCrjNVVCGjfHG5rdRUC3hcXj7e6Cvlqft/bVlfBqzXvjzircsnJyerbt69q166tYcOGKSEhQa+88oquuuoqPf3000U6xuHDh9WnTx85HA41adLE58CkxH/zVq1aVVWrVrW6GgAAAEDAmjx5sk6cOKEPPvhAZcuWlSS5XC4999xzGjZsmGJjYws9xuuvv67u3bvrwIEDZ1UHbmsDAAAApdyiRYvUvn377KBEknr37i23260lS5YUWv6PP/7QnDlz9NBDD511HQhMAAAAAF9ZvfqWn1flio+PV1xc7smGUVFRqlixouLj4wss63K59MILL+iuu+5SpUpnPzepxKdyAQAAACiaHj16FPj63LlzvW4/fvy4oqLyLg8dHR2t5OTkAo/51Vdf6dSpU7rllluKXE9vCEwAAAAAnJXExES99957evXVV31avcsbAhMAAADAR0YJXdc2vxGRwkRFRSklJSXP9uTkZEVH578k9bvvvqv69eurdevWOn7c8yy+zMxMZWZm6vjx4woPD1dQUNFCDgITAAAAoJSLi4vLM5ckJSVFhw8fzjP35Ew7d+7UypUr1aZNmzyvtWnTRuPGjVOXLl4eruUFgQkAAABQynXp0kVjx47NNddk5syZstls6tixY77lHn/88eyRktNeeuklhYaGauTIkapfv36R60BgAgAAAPiqhKZyna3Bgwfriy++0PDhw7MfsPjaa69p8ODBuZ5hMmTIEB04cECzZ8+WJDVs2DDPsaKiohQeHq6LL77YpzqwXDAAAABQykVHR2vixImy2+0aPny43nzzTQ0cOFCjR4/OtZ/b7ZbL5SqWOjBiAgAAAEB169bVZ599VuA+X3zxRaHHKco+3hCYAAAAAD4qqatync9I5QIAAABgOQITAAAAAJYjlQsAAADwFalcfseICQAAAADLEZgAAAAAsBypXAAAAICvSOXyO0ZMAAAAAFiOwAQAAACA5UjlAgAAAHzEAxb9jxETAAAAAJYjMAEAAABgOVK5AAAAAF+RyuV3jJgAAAAAsByBCQAAAADLkcoFAAAA+MgwyeXyN0ZMAAAAAFiOwAQAAACA5UjlAgAAAHxFJpffMWICAAAAwHIEJgAAAAAsRyoXAAAA4CODVC6/Y8QEAAAAgOUITAAAAABYjlQuAAAAwFekcvkdIyYAAAAALEdgAgAAAMBypHIBAAAAPmJVLv9jxAQAAACA5QhMAAAAAFiOVC4AAADAV6Ry+R0jJgAAAAAsR2ACAAAAwHKkcgEAAAA+YlUu/2PEBAAAAIDlCEwAAAAAWI5ULgAAAMBXpHL5HSMmAAAAACxXakdMhl3Q3eoqBDSjfpzVVQh4htNldRUCmnvnXqurEPCOXdPC6ioEvLLfrLK6CoHNSLe6BoHvlNUVwLlUagMTAAAA4GyxKpf/kcoFAAAAwHIEJgAAAAAsRyoXAAAA4CuTXC5/Y8QEAAAAgOUITAAAAABYjlQuAAAAwEesyuV/jJgAAAAAsByBCQAAAADLkcoFAAAA+IpULr9jxAQAAADA/7d352FRlf0fxz+IIIisiismIYqKW6UZifooLpk+kVupJVaaUvazLFufR9O0NLPtsdzNrcXMpdUsU1OzNC33XMHEDVwARWQT5vfH4NgIqKODZxjer+viuuSec2a+5+Z4z3zP/T33GI7EBAAAAIDhKOUCAAAAbOSSZ3QEzocZEwAAAACGIzEBAAAAYDhKuQAAAABbsSqX3TFjAgAAAMBwJCYAAAAADEcpFwAAAGAjF0q57I4ZEwAAAACGIzEBAAAAYDhKuQAAAABbmajlsjdmTAAAAAAYjsQEAAAAgOEo5QIAAABsxKpc9seMCQAAAADDkZgAAAAAMBylXAAAAICtKOWyO2ZMAAAAABiOxAQAAACA4SjlAgAAAGzEqlz2x4wJAAAAAMORmAAAAAAwHKVcAAAAgK1M1HLZGzMmAAAAAAxHYgIAAADAcJRyAQAAADZiVS77Y8YEAAAAgOFITAAAAAAYjlIuAAAAwFaUctkdMyYAAAAADEdiAgAAAMBwlHIBAAAANmJVLvtjxgQAAACA4UhMAAAAABiOUi4AAADAVnnUctkbiYmB3NzLKmZkT0X1jVQFfy8d3JGguaO/0J8rd15xv6A61dTl8SjVa15bobcFy93DXTFhTyvp0KmbFHnJ4ebmqn5DohTVpYkq+Hjq4P5Ezf1gpbZsiLvifi2jGqh1p4aqG15D/hUr6FTSWW1cu1efTv9Z6WmZNyl6x+Lm5qp+/9de7e67zdyX+xI17/0V2vLbgSvuVyO4kro8eKfCGtdUaIPqci/npv7tJ+jEsdQC23qUd1f/oR0U2bGhfAO8dPxwsr7++Dd99/nGYjoqx2ceJ3ooqm9LVfDz0sGdhzV31CL9uepq40TVS+NE01r548QwJSWU3nHCrayrBnW/W51b1pe3l4cOHD6paYvW6/ddCVfcr80doererrFqB1WSbwUPpaZlaOeB45qx9DfFHz1tte3StweoeqBvgedYsmqb3pyz0q7HU1LwXle8GCPgTCjlMtBzMwer+9OdtWrBek0ZPk95uXka8+XzCr+77hX3q39XHUUP6SRPb08l7Dl2k6ItmZ4b013dH75bq5dt19QJy5SXa9KYD/op/LZbrrjf0BH36ZZbA7Xqu22a+uYybV6/X//u3ULvzhsk93KlM59/9o2e6tY/Uqu/3app475VXm6eXpvaX+G317rifvWb3qL7Hr5bnl7ldDj+ZJHblSnjorHTH1WX3i20dvkOTRv3nY78fUpPvRqtBwe1sffhlBjPzRik7kPv0aoFv2rK8I/zx4nnrj5OtKij6Cc7yrOCB+NEvpGPd1Lfe27XD7/t0bsfr1ZenknvPtdNTepWv+J+oUGVlJaeqc9/3KIJc1dp8cptqlursmaP6qs6NSsV2H7voRN6der3Vj/frN1VXIfl8HivK16MEXAmLiaTqVTOQ3XyeMjQ1w9rFqL//TJGM176RIveWyZJcivnpul/jlfqibMa1nZ0kft6+3vpQk6uMs5lqucz9+rx8Q853FUkl7AQo0NQ3YY19L9PYjXj7eVaPG+9JPOVpWmLn1Jqcrqe7T+jyH0bNwvW9s1/W7VFdW2q51/vofdGfanlS/8oztCviUtO7k17rbqNgvT+509q5lvLtHj2L5LMfTn166eVevqcnntoWpH7VvD1VG5OrjLOZ6vHo5Ea+Py9hc6YRHZqqP+821fv/nexflxyqX//825fNW8Tpv7tJ+hMcnqxHF9h8g4evmmvVZSwZiH637rRmvHyZ9bjxB/jlHryrIa1fa3IfQuME+P6ONzV0NRet92012oQUlWzR/XV/z5bo0++N59f7m6u+vSN/ko5e16Pj1lg0/MF+JTXN+89rq/X7rSaCVn69gDFHz2t59750p7hXze/hcaOVc7+XicXY6/vOvsYIUk/ZMw3OoQitbl3gtEhFGrNsheMDuG6MWNikMhuLZR7IVfLZq22tOVk5Wj5nDVqEFFXgUEBRe6blpKujHOls5zIFq3ahyv3Qq6+X7zZ0paTfUE/LP1TDZreokpVfIrc9/KkRJJ+XfWXJKlmSKDdY3V0kR0bmvty4SZLW072Bf2weLMa3FZLlaoWLF256NyZDGWcz77qazS8I1iStGbZdqv2Nd9vVzkPN0W0q399wZdgkd3uzB8nVlnaLOPEXXUYJ2zQrnkdXcjN05erd1jasnNy9c2aHWpcp7oqB1Sw6fmSz55XZvYFeZcvV+jjZV3LyMO9dM6u/hPvdcWLMQLOhsTEIKFNa+nI/kSdT8uwat+72XzvQ0jjK5fH4Opq16umI4dO63x6llX73p1HLI/bwr+S+YPL2ZTz9gmwBKldv5qOFtKX+3ZcX18Wxs29rHIv5CrnspmgrExzUhMaXuOGX6OkCW1ycZyw/vDAOGG7urUq63BiitIzrZPkXfGJ5sdvqXzV56hQvpz8vD1VO6iS/jOgoyqUL6dNfxWcWWtWv6bWzByqNTOHaunbA/Rgx5s3M+RoeK8rXowRcDZczjFIQFU/JSemFGhPPp4qSapY3f8mR+R8AgK9lXwqrUD7xbaKgd42Pd8Dj7ZS7oVcrfvpyjcUOqOAQB8lnyykL/PbAioXPft0rY4cPCnXsq6q36Smdv15yNIenj+TUskOr1HSmMeJ1ALtF9sqVvO7qfGUZJX8vHQqtWAp4On8tkB/r6s+x6yRfRRc3XwFOj0jWx99tUFfr9lhtc2Bw6e0bd9RJSSmyLeCh7pEhuvZh9uqkl8FfbhwnR2OpGThva54MUYYiy9YtD+HT0xOnTql3bt3S5IaNGigihUrGhyRfbh7uisn60KB9uws89W8ch7uNzskp+Nezk052QXvw8jO73f3cm7X/Fz/6txY93RvpoWz1+lYQrLdYiwpypUrq5zsws7XHMvjN+rn77ap7xPt9MzYHpo85msdPXRKd7Sso66975IkuXtc+9/LWbh7uhU+TmTm97sn48S1KudWVjkXCo4HWfkzdOWuoexqzMwf5OXprhqBvuraqqHKuZVVmTJllJubZ9nm+fe+strnm7W79N7w7up7z+36YsUWnUg5d4NHUrLwXle8GCPgbBwmMXnnnXf00EMPqUqVKpKkvLw8vfHGG1qwYIFyc3NlMplUtmxZ9evXTy+++KLB0d647IxsuRXyYc69nHkQycq8ek0+riw7K0du7q4F2i+uqnXxQ/XVhN9WS8NG3a/N6/drzqSf7BpjSZGVdUFuhXxwu5jcZRXyxmirlFPnNHrIfA1/s5femPWYJCk9LVNTXv9Gw8f3uqb7VJxNdkZO4eNEfpKWlVH6+uR6ZeVckFvZguNBOTdzW1Yhiffldh44bvn3ig179fn4RyRJ/1uw9or7ffbDH4poHKzb69fU8l932xB1ycd7XfFijICzcZjEZMaMGWrfvr0lMZk5c6Y+/fRTPfLII+rcubMk6bvvvtPcuXMVFBSkhx4ydlWtG5WcmKqK1QvelBaQP+16+ljBqW/YJvlkmioWUv4TUMlcwnW6kNKky91at6pG/e8hHTqQpLHPLVDeP66MlibJJ8+qUpWCN7gH5JfDJZ84a5fX2fnH33qs40QF160qD083xe9NtJTcHf3bsVaKuRnM40TBUpeAqn6SpNP55TC4ulOp6arsX/AG94p+5hKukym2rfiWdj5Lm3cfVqe76101MTlx2jzW+Hh52PQazoD3uuLFGGGw0rmwbbFymJvfL1+1eOHCherbt69eeOEFNWrUSI0aNdJLL72knj17auHChQZFaT9x2w4pqE5Vlff2tGqv17y2JCl++6HCdoMN4vcmKqhWRZX3sl41J6xRkCQpbs/xwnazqBbkr9cnx+hMcrpGPDVfmaX4ylP8nuOqUVhfNr62vrRFXp5J8XuO668tCco8n62mEaGSpK1X+SJHZxS3/eI4Yf2BlnHCdvsTTqpmVX95XVY6FF7bvHDDvoQTNj9nObeyquBZ+Kpc/1S9sjmpT00rfQtn8F5XvBgj4GwcJjG53LFjx9SuXbsC7VFRUfr7779vfkB2tm7p73It66p7B7S1tLm5l1XHmDbavfGATh4x38cQWLOiata98RWPSqN1P+2Sa1lXde7RzNLm5uaqjtG3a/f2wzqVZL7KH1jVV0HB1l+S5l+xgl6f+ojyTCb954m5OlMKV+L6p19+3GnuyweaW9rc3FzVodsd2rMtQacSz0iSAqv5KuhW+y2n7OvvpV4DWyt+z3Ft+S3Obs9bUqxbuil/nLg0FprHidba/TvjhC1W/b5PZV3L6P62jSxtbmVd9e9W4dp54LhOJJvv/ahS0Vu1qllfgfa/7EO1JFWr5KPm4TW1+2CSpc3Hy0NlXFystnN1LaP+Xe9Uds4Fbd5t/Hfj3Gy81xUvxgg4G4cp5ZKkc+fOKTU1VZLk7+9fYBblojJlHDafumZ7N8Vp7aINenTMg/IN9NWx+ER1eLi1qtSqpHdiL33x3/OzYtWkdQOrL4Qs7+Op6Cc7SZLCI8zf7HpfbEedO3Ne6anp+nrqipt7MA5q744jWvvDTj06tIP8Arx07HCy2v+7qapU99O7o5Zatnt+bA81bn6r7mkywtI2dnKMqtcM0MLZ6xR+Wy2F33ZpycWU0+e0ZUPp+pC8d/sRrV2+Q48800m+ARV0POG0oqJvV5Xq/nrvv0ss2w0f10uN7wxR5wavWNrKVyin+x66W5LU4PZbJEn3PRShc2czlZ6WoW8+3WDZdsLcx7V7a4KOJZyWfyVvdX6guTzLu2vUE/OKHA+c2d5NcVq7eKMefa2XfAN9dCwuSR0ejswfJ2Zatnt+5mA1aV1fnTz7WdrK+3gq+omOkqTwiDqSpPue6KBzqeeVfiZdX08tXfdL7YpP1E8b9+rJXpHy9ymvI0mpujeygapV8tHYWT9atnt10D26o35NtYh5x9L26Rsx2vTXYe07dEJp57NUs4qf7mvTUK6urlYrbbW6LUSPRt+lVZv26fjJM/Lx8lDHiPoKrVlJkxeuU/KZ0neBg/e64sUYYSxW5bI/h0pMBgwYYPm3yWTStm3b1LJlS6tt9u3bZ7kPpaSbMGCq+if0VFTflvL299LBHYc1sttE7fxlzxX38/b30iOjelm19RzWRZKUeOgkg/U/vPXfxeo/JEpRXZuqgo+HDu5P0qtDP9bOP688vX3xezkeeLRVgce2bzpY6hITSZr40heKGdpeUfc1VQUfTx3cm6hXn5ynnX/8fcX9Kvh4qv/THazaeuT3a9LRFKvEZP+uo2rVqaEqVvHR+XNZ2vLbAc373wolHim9degTBkxT/1d7KKpPS3n7l9fBnYc1svs72rl+7xX38/bz0iOjelq19XzmXkkXx4nS96Fj9PTlSuzRUp1b1pd3eQ8dOHxKz777pbbuPXrF/Rav2q6WTW7VXY2C5eXhpuSzGdq445DmfPO74o5cuvcp7sgpHTx6Wp3vri8/b0/lXMjT/oQTennSN1q1aX9xH57D4r2ueDFGwJm4mBzkMuTSpUsLtAUGBioyMtKqbcCAAapdu7ZeeeWVAtvb4p9XZWB/LmEhRofg9FxyCi59CvvJO1j6ym5uttRepfeLB28Wv4V/GB2Cc3Mp+RUcju6HjPlGh1Cktp3eNDqEQq3+oeSuXuswMybdunW7pu1mzZpVzJEAAAAAV+EQl/adC6k+AAAAAMORmAAAAAAwnMOUcgEAAAAlhYtj3KbtVJgxAQAAAGA4EhMAAAAAhqOUCwAAALBVntEBOB9mTAAAAAAYjsQEAAAAgOEo5QIAAABsxKpc9seMCQAAAADDkZgAAAAAMBylXAAAAICtqOSyO2ZMAAAAABiOxAQAAACA4SjlAgAAAGzFqlx2x4wJAAAAAMORmAAAAAAwHKVcAAAAgI1cqOSyO2ZMAAAAABiOxAQAAACA4SjlAgAAAGzFqlx2x4wJAAAAAMORmAAAAAAwHKVcAAAAgI1c8oyOwPkwYwIAAADAcCQmAAAAAAxHKRcAAABgK1blsjtmTAAAAAAYjsQEAAAAgOEo5QIAAABsRSWX3TFjAgAAAMBwJCYAAAAADEcpFwAAAGAjF1blsjtmTAAAAAAYjsQEAAAAgOEo5QIAAABsRSmX3TFjAgAAAMBwJCYAAAAADEcpFwAAAGCrPKMDcD7MmAAAAAAwHIkJAAAAAMNRygUAAADYiC9YtD9mTAAAAAAYjsQEAAAAgOEo5QIAAABsRSmX3TFjAgAAAMBwJCYAAAAADEcpFwAAAGArSrnsrvQmJi5MFhWnvL/2Gx2C03NxdTU6BOfGGFHs/BZvNToEp2fKzTU6BOfmwgdTwJ545wUAAABguNI7YwIAAABcrzyjA3A+zJgAAAAAMByJCQAAAADDUcoFAAAA2MiFVbnsjhkTAAAAAIZjxgQAAACA4uLiNHbsWG3ZskVeXl6Kjo7WM888I3d39yL3OXHihObMmaP169crISFB3t7eat68uZ599lnVqFHDptcnMQEAAABs5WSlXGfOnFH//v0VHBysSZMmKSkpSePHj1dmZqZGjhxZ5H67du3SihUr1KNHDzVp0kQpKSmaMmWKevXqpW+//VYBAQHXHAOJCQAAAFDKLViwQOnp6frggw/k5+cnScrNzdXo0aM1ePBgValSpdD97rjjDn3//fcqW/ZSWnH77bfrX//6l7788ks99thj1xwD95gAAAAApdzatWsVERFhSUokqXPnzsrLy9P69euL3M/Hx8cqKZGkqlWrKiAgQCdOnLApBhITAAAAwFYmk2P+XKf4+HiFhIRYtfn4+CgwMFDx8fE2PdfBgwd1+vRp1a5d26b9KOUCAAAAnERUVNQVH1+5cmWh7WfPnpWPj0+Bdl9fX505c+aaX99kMmns2LGqXLmyunTpcs37SSQmAAAAAOxk0qRJ2rBhg2bOnKny5cvbtC+JCQAAAGArB12Vq6gZkavx8fFRWlpagfYzZ87I19f3mp5j4cKF+vDDD/X6668rIiLC5hi4xwQAAAAo5UJCQgrcS5KWlqaTJ08WuPekMCtWrNCoUaM0dOhQ9ezZ87piIDEBAAAASrnWrVvr119/1dmzZy1ty5cvV5kyZdSyZcsr7rtx40Y9++yz6tWrl4YMGXLdMVDKBQAAANgqz+gA7Kt3796aP3++hgwZosGDByspKUkTJkxQ7969rb7DpH///jp27JhWrFghyfxt8UOGDFFwcLCio6O1detWy7YBAQG65ZZbrjkGEhMAAACglPP19dXcuXM1ZswYDRkyRF5eXurZs6eGDRtmtV1eXp5yc3Mtv2/btk1paWlKS0tTnz59rLbt1q2bxo8ff80xuJhMDnrnTjHr5NnP6BCcmulCjtEhOD0XV1ejQ3BuLlS6FrsyLkZH4PRM2dlGh+DcGCeK3Y/ZnxodQpHuCf+P0SEUavmu140O4boxYwIAAADYyKV0XtsvVqT6AAAAAAxHYgIAAADAcJRyAQAAALailMvumDEBAAAAYDgSEwAAAACGo5QLAAAAsFUepVz2xowJAAAAAMORmAAAAAAwHKVcAAAAgK1YlcvumDEBAAAAYDgSEwAAAACGo5QLAAAAsBWlXHbHjAkAAAAAw5GYAAAAADAcpVwAAACArSjlsjtmTAAAAAAYjsQEAAAAgOEo5QIAAABslUcpl70xYwIAAADAcCQmAAAAAAxHKRcAAABgK1Oe0RE4HWZMAAAAABiOxAQAAACA4SjlAgAAAGzFFyzaHTMmAAAAAAxHYgIAAADAcJRyGcjNvaxiRvZQVN+WquDnpYM7D2vuqEX6c9XOK+4XVKequjwepXrNayu0aS25e7grJmyYkhJO3aTIjeXmXlYxox5Q+4ciVcG/gg7uSNCckZ/rz5U7rrpvxer+ip0Yozs6NJZLGRdt+/kvTR0+T4kHT1ht51fZVwPe6KMWnW+Tp7enEvYc1YI3v9S6xRuttus3oqf6jexZ4HWyM7PV1Tvmxg60BDCfwz0V1TdSFfy9dHBHguaO/kJ/rrzaOVzt0jl8W3D+Ofy0kg6VjnPYFowT9uPmXlYxI7orqs8/+vK1Rfpz1a4r7hdUp6q6DGynes3+0Zf1ny20L9v0aKEW9zZVvWa1VSO0qrat3a0XOo8rrkMyjCONw5cb//0rur19Y301+Qd9+PTsGzpOI5n7uKfa921lGV/nvLrwquOrdLGP++mO9o3MfbzmL00d/nEhfeyjAa/3UYvOTS/18YSvC/TxvH3vq2pwYKGvdXR/oh4Nf/b6D7Qk4wsW7Y4ZEwM9N2OQug+9R6sW/Kopwz9WXm6exnz5nMLvrnvF/eq3qKPoJzvKs4KHEvYcu0nROo7hs55Qj2fu1arP1mvKs3OVm5unsd+8qPCWYVfcz8OrnN5aMVKNW9fXZ+O/1PzXFim0abDeXvmqvAMqWLYr7+2pd38epchud+q7GSs1/cWPlZGWoRELhqlt75aFPvf7Q2bqzf4fWH4mDpxq12N2VM/NHKzuT3fWqgXrNWX4vPxz+Pmrn8N31VH0kE75b4Sl7xy2BeOE/Tw3/XF1/797tOrz3zTl+fy+XPKcwiOu1pehin6iozy9PZSw9/gVt+0ysJ0iutyuk0eTlZZ8zp7hOxRHHIclqeX9zVX/riv/PUuK4bNi1ePpi308z9zHX7+g8LuvpY//q8at6uuzN7/S/NcWK7RJsN7+aUTBPl49SpHdmuu7mas0/cVPlJGWqRGfPa22ve+2es6pw+frzUc+tPqZPfJzSdIfP223/8Gj1GLGxCBhzULU9oEIzXj5My16b5kk6adPftH0P8Zp4Ou9Nazta0Xuu+G7P9Wj6mBlnMtUz2fuVWjT4JsUtfHCmtdW294tNf2Fj7Xo3W8lSSvmr9X0rW9p4LiHNKz1yCL3/XdsRwXVraanIl7Rvs3xkqRNy7dq+ta31HNYV80esUCS1OXxKNWoU00vdBijrT+br6R+O3WF3l8/RoMmPKx1izfoQk6u1XOvW7xRZ0+nFcchOyzzOXy3Zrz0yaVz+ONfNP3P8Rr4eh8Nazu6yH03fPuHelT5vVSew7ZgnLCfsDtC1LZXhGa88pkWvf+9JOmnT9dr+qY3NHDsgxoWNabIfTd8t0U9qsea+/LpzgptUqvIbd8aOE2njqXIZDJp2qY37H4cjsBRx2G3cm4aPKGfFr71tfqPfqA4Dv2mCWtWW20fvFvTX/xEi979TpK04uN1mr7lTQ0c10fD2owqct9/x3ZQUJ1qeiriv9r3R34f/7BN07e8qZ7Dumj2CHNCYe7jqnqh41ht/fkvSdK3037S+7+8pkFvPqR1izda+vjXrzcXeJ2+L98vSVr12Xp7HTbAjIlRIrvdqdwLuVo2a5WlLScrR8vnrFGDu+ooMCigyH3TUtKVcS7zZoTpcFp1b2Hut5krLW05WTn6YfZqhUfUVWBQxaL37dFCezYdsLwZStLhvce0ZdVOte55l6WtYWQ9pZ44Y3kzlCSTyaS1X2xQxWr+aty6QYHndnExX30qTSK75f8tZq22tFnO4Yi6nMN2wDhhP5Hdmpv78qPLztd5+X1Zwz59efJoskxOvlKPo47DDwz/t1zKuOiLd7650UM0XKse+f/3Z1r/3/9hzs/5fVz0+dqqewvt2RRnSUqki328S617tLC0NYwMy+/jvyxtJpNJaxdd7OP6V4yxbe+7dTz+hP7asP96DtE5mEyO+VOCkZgYJLRJLR3Zn6jzadZvdns3x0mSQhoXfUWuNAttGqwj+47rfFqGVfueTeZ+q13ElUwXFxeFNLpF+/8xUF+0d1OcaoRWlWcFD0nmq25ZGdkFtsvKyJIk1bn91gKPzd33P32ZPFtfpczRi3OHyK+yr20HVgKFNr14Dlv/LTiH7Ydxwn6K7kvzmBDS+BYjwiqRHHEcDqxZUQ++EK1Zr3yq7Mwc2w/KwYQ2CdaR/Vfq4+BC9zP3cc3C+3jzZX3sXkQfny/6ve6i2k1rqVb9IK3+nNkS2BeJiUECqvopOTG1QPvFtorV/G5qPCVFQFX/IvotRZL5hr/CeAdUkLuHu5KPX33fI/uOqVJQRVW+pZLVdg1b1jNv948rq2mp6fryw+V6/8mZeu2Bd/T9R6vUpleE3lk9yulnUMzncEqB9ot9XNTfAteOccJ+Aqr6KTkptUD7pb7kfL1WjjYOS9LgCf0Ut/Vv/bzwN5uOxVEFVPMrop/MbUX937f0cWF/n+PX2MeR+X1cvehZmXb59/mspIwLduYw95hkZ2crNzdXnp6XPswlJyfrk08+0f79+5Wdna2GDRuqT58+qlix6GniksLd0005WRcKtF+80lPO0/1mh1QiuHu6Kyer4NWwi/3mXkS/XezP7GvY9/uPVqvLoA7672fPaOrweUpJOqM2Pe9Sy/ubWz2XJH056Xur5/pl6e/auylOL8//P/07toM+f+trWw+xxDD/LQo5h7PMV+DKeXAO3yjGCftx96Av7cXRxuEmbRoosvudGtryvzdwVI7F3aOI8fWqfexm3u5a+nj2anUZ1F7//XSopg6fr5QT+X0c3Sz/uQp/DRcXF/3rgQjt33JQh0v7wholvGzKETnMjMlTTz2lt956y/L79u3b1alTJ82ZM0cpKSlKT0/XRx99pK5duyouLs7ASO0jOyNHbuUK5oXuHuZBpbDpVUjZGdlyK+dWoP1iv2UX0W8X+9P9GvY9uCNB4/tNUrWQynpv7Wuau/d9RT91j6Y8N0+SrlprvnrBep0+nqLbohpd41GVTOa/RSHncDnzm1lWJufwjWKcsJ/sTPrSXhxpHC7jWkZPvveIVn6yzuq+lZIuO7OI8fWqfZyffFxTHx/W+JgPVC2kit5bO1pz97yn6CGdNOW5+ZKKfq9r3Lq+AoMqctM7ioXDzJhs375dvXr1svw+btw41alTR1OmTJGvr7lePyUlRbGxsRo/frxmzJhhVKh2kZyYWuh0d0BVP0nS6UKmcGGe7i9sejmgqrkvTx8rWFokSWnJ55Sdma2AQqa/C9t33ZKN+u2bzQppUktlXMvowJ8H1aRNuCTp6P4rLxcqSSePnLZaltEZmc/hQv4W+X1c1N8C145xwn6SE1MLLde61Jecr9fKkcbhDv1aK6hudb3/5ExVqWX9PRvlvT1UpVagUk+cKXGJZ/LxVFWsYfv/fUsf529ntW+1wvr4d/32zR8KaZzfx1sOqkkb88ICRb3XtevTUrm5eVr9+a82HBFwbRxmxuT8+fPy97/0n3DHjh2KjY21JCWS5O/vr0GDBmnz5oLL1pU0cdsPKahOVZX39rBqr9e8tiQpfvshI8JyeHHbDimobrUC92/UuzPU8nhhTCaTDu48rDp3hBR4rN6doToWl1Tg6tCFnFzt2xyvPRsP6EJOrm6LaihJ1/TlVlVrBerMybPXdEwlVdy2i+fwZX8LzmG7YZywn7jtCYX3ZbOLfZlgRFglkiONw5VrVpKbe1m9t/Y1zT8wyfIjSR36tdH8A5N0R4fGN3bABjCPr1fq478L3e+Kfdy8dtF9/Ee89vx+WR8X8iWubu5lFdntTm1f81eh98CUOkavvsWqXMWndu3a2rp1q+V3Hx8fZWVlFdguKytLbm4FpyhLmnVLN8m1rKvuHdDO0ubmXlYdY1pr9+8HdPJIsiTzSiM161YzKkyHs27JRnO/DYyytLm5l1Wn/m20e+N+nTxyWlJ+v4VVt9538UbVax5qNWAH1a2mpm3DtXbxhiu+bvXQquoyqL02fPuH1VUk30reBbb9d2wH+VX21eYft13XMZYU65b+nn8Ot7W0mc/hNtq9kXPYHhgn7Mdyvj522fnar5W5L4/m92UQfXk1jjQO/7zwV43qMbHAjyRtXPanRvWYqD2/H7DLcd9Ml/rY+v9+p5iLffyP//uX9/GS31WveW2rVbUsfbzE+hvdL1c9tKq6PB6lDd/9qaP7Ews8fmfnpvL296KMC8XGYUq5YmJi9Prrr6tevXqKjIxUv3799Pbbbys4OFh16tSRJO3Zs0fvv/++2rZte5Vnc3x7N8Vp7eKNevS1XvIN9NGxuCR1eDhSVWpV0juxMy3bPT9zsJq0rq9Onv0sbeV9PBX9REdJUniEuW/ue6KDzqWeV/qZdH099aebezA30Z7fD2jNF7/psdd7y69yfr/1a60qwYF6Z9A0y3YvzB6iJm0aqKNbb0vbN1N/VOcB7TT2qxe06J1vdeFCrno83UUpSWe0OP9Lwi6asW2i1i7eoJOHT6tqcKC6Du6gtOR0vT9kptV28+M+0JovftPfOxOUnZmj8Lvr6V8PRujA1oP6brrz/h2k/HN40QY9OuZB+Qb66lh8ojo83Dr/HL5Uavn8rFg1ad1AnTwesrSV9/FU9JOdJMnyrdv3xXbUuTPnlZ6arq+nrri5B+OgGCfsZ+/meHNfjv5HXz6U35dPzrJs9/yMQea+9IqxtJX38VR0bAdJ/+jL2Pb5fXleX0+71JcNW4apUf63n/tW8pZH+XLq88J9kqQd6/dq5/q9xX6sxc2RxuHDe4/p8N7Cb8BO/PtkoV8MWBLs2RSnNYs26LGxD5r7+ECSOvRrpSrBlfTO4OmW7V746AlzH7v3tbR9M3WFOj/W1tzH736nCzkX1OPpe/P7+Dur15mxbYLWLt6okwmnVfXWQHUd1D6/j2epMO36tFR2ZrbWLf29eA4cpZ7DJCbdunVTYmKiYmNjFRQUpLp16+rEiRO677775OfnJ0lKTU1Vw4YN9fLLLxsbrJ1MGDBN/V/toag+LeXtX14Hdx7WyO7vXPWNy9vPS4+M6mnV1vOZeyVJiYdOOv0HjgmPTtYjCQ8o6qFW8vb3UvyOBI2InqAdv+y54n4Z5zL1fPvXFDsxRn1f6S6XMi7avuYvTR0+T2dOWX9re/z2Q+rU/1/yq+Krs6fStGbRBs0f/YVSLyvPWvXZL2pwV11FdrtT7h7uOnHopBZO/EafjVta4mqar8eEAVPVP6Gnovq2lLe/lw7uOKyR3SZq51X+Ft7+XnpkVC+rtp7Duki6eA6TmFzEOGE/Ex6frv6H8/vSL78ve757bX356mV9+fQ/+vIfiUnTNg3U7z/drLa9uO/815c6RWIiOdY47KwmPDpFj4zqpai+kfl9fFgj7p94bX3cYaxiJ/ZT35fvN/fx2t2aOnx+IX2coE4xbf7Rxxs1/7VFhfZxeW9P3dn5Nm38fqvOn80o8HiplJdndAROx8XkYF9RGx8fryVLlmjbtm06deqU8vLy5Ovrq9DQULVt21bt27eXi4vLDb/OP68swv5MF0r+F1w5OhdXV6NDcG4uDlPp6rzK3PhYjiszZTv/BRJDMU4Uux+zPzU6hCJ1rjbE6BAK9f3xD40O4bo5zIzJRSEhIRo+fLjRYQAAAAC4iRwuMQEAAAAcnmMVHTkF5iABAAAAGI7EBAAAAIDhKOUCAAAAbEUpl90xYwIAAADAcCQmAAAAAAxHKRcAAABgqzxKueyNGRMAAAAAhiMxAQAAAGA4SrkAAAAAG5lMeUaH4HSYMQEAAABgOBITAAAAAIajlAsAAACwFaty2R0zJgAAAAAMR2ICAAAAwHCUcgEAAAC2MlHKZW/MmAAAAAAwHIkJAAAAAMNRygUAAADYKo8vWLQ3ZkwAAAAAGI7EBAAAAIDhKOUCAAAAbMWqXHbHjAkAAAAAw5GYAAAAADAcpVwAAACAjUysymV3zJgAAAAAMByJCQAAAADDUcoFAAAA2IpVueyOGRMAAAAAhiMxAQAAAGA4SrkAAAAAW+VRymVvzJgAAAAAMByJCQAAAADDUcoFAAAA2MrEFyzaGzMmAAAAAAxHYgIAAADAcJRyAQAAADYysSqX3TFjAgAAAMBwJCYAAAAADEcpFwAAAGArVuWyO2ZMAAAAABiOxAQAAACA4SjlAgAAAGzEqlz2x4wJAAAAAMORmAAAAAAwHKVcAAAAgK1YlcvumDEBAAAAYDgSEwAAAACGczGZTCwpAAAAAMBQzJgAAAAAMByJCQAAAADDkZgAAAAAMByJCQAAAADDkZgAAAAAMByJCQAAAADDkZgAAAAAMByJCQAAAADDkZgAAAAAMByJCQAAAADDkZgAAAAAMByJCQAAAADDkZgAAAAAMByJiQOLi4vTo48+qqZNm6ply5aaMGGCsrOzjQ7LaRw6dEgjR45UdHS0GjRooK5duxodklP5/vvv9cQTT6h169Zq2rSpoqOjtWjRIplMJqNDcxpr1qzRww8/rLvuuksNGzZUVFSUxo0bp7S0NKNDc0rp6elq3bq1wsLCtGPHDqPDcQpLlixRWFhYgZ+JEycaHZrTWbp0qe6//341atRILVq00MCBA5WZmWl0WICVskYHgMKdOXNG/fv3V3BwsCZNmqSkpCSNHz9emZmZGjlypNHhOYX9+/drzZo1atKkifLy8vjAbGdz5sxRjRo19NJLL8nf31+//vqrRowYocTERD311FNGh+cUUlNT1bhxY/Xr109+fn7av3+/Jk2apP379+ujjz4yOjynM3nyZOXm5hodhlOaOXOmvL29Lb9XqVLFwGicz5QpUzRjxgzFxsaqadOmSklJ0W+//cb5DIdDYuKgFixYoPT0dH3wwQfy8/OTJOXm5mr06NEaPHgwg7YdtGvXTu3bt5ckvfTSS9q5c6fBETmXKVOmKCAgwPJ7RESEUlNTNXv2bD355JMqU4YJ2xsVHR1t9XuLFi3k7u6uESNGKCkpiXHCjuLi4vTpp5/qxRdf1Kuvvmp0OE4nPDzcaryA/cTHx+uDDz7Q5MmT1aZNG0t7p06dDIwKKByfDBzU2rVrFRERYUlKJKlz587Ky8vT+vXrjQvMifDBuHgV9iGjfv36OnfunM6fP29ARKXDxTEjJyfH2ECczNixY9W7d2/deuutRocC2GTJkiUKCgqySkoAR8UnMwcVHx+vkJAQqzYfHx8FBgYqPj7eoKiAG/PHH3+oSpUqqlChgtGhOJXc3FxlZWVp165d+vDDD9WuXTsFBQUZHZbTWL58ufbt26chQ4YYHYrT6tq1q+rXr6+oqChNmzaNEiM72rZtm+rWravJkycrIiJCDRs2VO/evbVt2zajQwMKoJTLQZ09e1Y+Pj4F2n19fXXmzBkDIgJuzObNm7Vs2TK9+OKLRofidNq2baukpCRJUqtWrfT2228bHJHzyMjI0Pjx4zVs2DAS6mIQGBio//u//1OTJk3k4uKiVatW6b333lNSUhL3U9rJyZMntXPnTu3bt0+vvvqqPD09NXXqVD322GP68ccfVbFiRaNDBCxITAAUu8TERA0bNkwtWrRQTEyM0eE4nenTpysjI0MHDhzQlClTFBsbq9mzZ8vV1dXo0Eq8KVOmqGLFiurRo4fRoTilVq1aqVWrVpbfIyMjVa5cOc2dO1exsbGqXLmygdE5B5PJpPPnz+v9999XvXr1JElNmjRRu3bt9PHHH+vpp582OELgEkq5HJSPj0+hS36eOXNGvr6+BkQEXJ+zZ8/q8ccfl5+fnyZNmsS9PcWgXr16uu2229SrVy9NnjxZGzdu1IoVK4wOq8Q7evSoPvroIw0dOlRpaWk6e/as5f6o8+fPKz093eAInVPnzp2Vm5ur3bt3Gx2KU/Dx8ZGfn58lKZHM96I1aNBABw4cMDAyoCBmTBxUSEhIgXtJ0tLSdPLkyQL3ngCOKjMzU4MHD1ZaWpo+//xzq+VAUTzCwsLk5uamhIQEo0Mp8Y4cOaKcnBwNGjSowGMxMTFq0qSJFi5caEBkwLULDQ0tcjzIysq6ydEAV0Zi4qBat26tqVOnWt1rsnz5cpUpU0YtW7Y0ODrg6i5cuKBnnnlG8fHx+uSTT1i69ibZtm2bcnJyuPndDurXr6958+ZZte3evVvjxo3T6NGj1ahRI4Mic27Lli2Tq6urGjRoYHQoTqFt27ZasmSJdu/erfr160uSUlJStGvXLj3yyCPGBgdchsTEQfXu3Vvz58/XkCFDNHjwYCUlJWnChAnq3bs3H/DsJCMjQ2vWrJFkLtk4d+6cli9fLkm68847WVP/Bo0ePVqrV6/WSy+9pHPnzmnr1q2Wxxo0aCB3d3fjgnMSTz31lBo2bKiwsDB5eHhoz549mjVrlsLCwizf0YPr5+PjoxYtWhT6WHh4uMLDw29yRM5nwIABatGihcLCwiRJK1eu1MKFCxUTE6PAwECDo3MO7du3V6NGjTR06FANGzZM5cqV0/Tp0+Xu7q6+ffsaHR5gxcXE1107rLi4OI0ZM0ZbtmyRl5eXoqOjNWzYMD7Q2cmRI0cUFRVV6GPz5s0r8gMJrk27du109OjRQh9buXIlV/TtYPr06Vq2bJkSEhJkMplUo0YNdejQQQMGDGAFqWKyceNGxcTEaNGiRcyY2MHYsWO1bt06JSYmKi8vT8HBwerVq5f69esnFxcXo8NzGsnJyRo3bpxWr16tnJwcNWvWTC+//LJCQ0ONDg2wQmICAAAAwHAsjwMAAADAcCQmAAAAAAxHYgIAAADAcCQmAAAAAAxHYgIAAADAcCQmAAAAAAxHYgIAAADAcCQmAFCCZWVlKTw8XM2aNdOkSZOMDgcAgOtGYgIAJdiFCxc0duxYVa9eXR9++KFOnz5tdEgAAFwXEhMAKMG8vLzUrVs3DRw4UCaTSXv37jU6JAAArguJCQA4gTp16kiS4uLiDI4EAIDrQ2ICAE4gKytLknTgwAGDIwEA4PqQmACAExg/frwkKT4+3uBIAAC4PiQmAFDCffXVV9qyZYsqVqxIKRcAoMQiMQGAEiw9PV0TJ05U69atFR0drdOnTys1NdXosAAAsBmJCQCUYNOmTVNKSor+85//KDQ0VBL3mQAASiYSEwAooRISEjR79mw99thjCg4OtqzMxX0mAICSiMQEAEqocePGKSAgQLGxsZKkkJAQScyYAABKprJGBwAAsN26deu0atUqvfvuuypfvrwkqUKFCqpWrRo3wAMASiRmTACghMnJydEbb7yhFi1a6N5777V6rHbt2pRyAQBKJBITAChhPvnkEyUkJGjEiBEFHqtTp46OHz+u9PR0AyIDAOD6uZhMJpPRQQAAAAAo3ZgxAQAAAGA4EhMAAAAAhiMxAQAAAGA4EhMAAAAAhiMxAQAAAGA4EhMAAAAAhiMxAQAAAGA4EhMAAAAAhiMxAQAAAGA4EhMAAAAAhiMxAQAAAGA4EhMAAAAAhiMxAQAAAGC4/wepV50pbMANUAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# optional\n",
    "# visual representation of grid search\n",
    "# uses seaborn heatmap, could probably do this in matplotlib\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set()\n",
    "\n",
    "train_accuracy = np.zeros((len(eta_vals), len(lmbd_vals)))\n",
    "test_accuracy = np.zeros((len(eta_vals), len(lmbd_vals)))\n",
    "\n",
    "for i in range(len(eta_vals)):\n",
    "    for j in range(len(lmbd_vals)):\n",
    "        dnn = DNN_scikit[i][j]\n",
    "        \n",
    "        train_pred = dnn.predict(X_train) \n",
    "        test_pred = dnn.predict(X_test)\n",
    "\n",
    "        train_accuracy[i][j] = accuracy_score(Y_train, train_pred)\n",
    "        test_accuracy[i][j] = accuracy_score(Y_test, test_pred)\n",
    "\n",
    "        \n",
    "fig, ax = plt.subplots(figsize = (10, 10))\n",
    "sns.heatmap(train_accuracy, annot=True, ax=ax, cmap=\"viridis\")\n",
    "ax.set_title(\"Training Accuracy\")\n",
    "ax.set_ylabel(\"$\\eta$\")\n",
    "ax.set_xlabel(\"$\\lambda$\")\n",
    "plt.show()\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (10, 10))\n",
    "sns.heatmap(test_accuracy, annot=True, ax=ax, cmap=\"viridis\")\n",
    "ax.set_title(\"Test Accuracy\")\n",
    "ax.set_ylabel(\"$\\eta$\")\n",
    "ax.set_xlabel(\"$\\lambda$\")\n",
    "plt.show()"
   ]
  }
 ],
 "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}