From eec8c4ada9db13267696c616808a23e5594e0952 Mon Sep 17 00:00:00 2001 From: JZ-LIANG Date: Sun, 25 Nov 2018 22:14:48 +0100 Subject: [PATCH] lab --- .gitignore | 16 + LAB1_FCNN/LAB1_FCNN.ipynb | 1136 +++++++++++++++++ LAB1_FCNN/NeuralNetwork.py | 113 ++ .../__pycache__/NeuralNetwork.cpython-36.pyc | Bin 0 -> 3187 bytes .../transfer_functions.cpython-36.pyc | Bin 0 -> 1414 bytes LAB1_FCNN/__pycache__/utils.cpython-36.pyc | Bin 0 -> 2300 bytes LAB1_FCNN/images/NN.png | Bin 0 -> 24261 bytes LAB1_FCNN/images/mnist.png | Bin 0 -> 43617 bytes LAB1_FCNN/transfer_functions.py | 45 + LAB1_FCNN/utils.py | 42 + LAB2_CNN/LAB2_CNN.ipynb | 1058 +++++++++++++++ LAB2_CNN/images/LeNet.png | Bin 0 -> 39641 bytes LAB2_CNN/images/cnn_board.png | Bin 0 -> 40685 bytes LAB2_CNN/images/softmax_board.png | Bin 0 -> 50740 bytes LAB3_RNN/LAB3_RNN.ipynb | 693 ++++++++++ LAB3_RNN/images/GRU.png | Bin 0 -> 33002 bytes LAB3_RNN/images/RNN.png | Bin 0 -> 55614 bytes LAB3_RNN/utils.py | 171 +++ README.md | 41 + 19 files changed, 3315 insertions(+) create mode 100644 .gitignore create mode 100644 LAB1_FCNN/LAB1_FCNN.ipynb create mode 100644 LAB1_FCNN/NeuralNetwork.py create mode 100644 LAB1_FCNN/__pycache__/NeuralNetwork.cpython-36.pyc create mode 100644 LAB1_FCNN/__pycache__/transfer_functions.cpython-36.pyc create mode 100644 LAB1_FCNN/__pycache__/utils.cpython-36.pyc create mode 100644 LAB1_FCNN/images/NN.png create mode 100644 LAB1_FCNN/images/mnist.png create mode 100644 LAB1_FCNN/transfer_functions.py create mode 100644 LAB1_FCNN/utils.py create mode 100644 LAB2_CNN/LAB2_CNN.ipynb create mode 100644 LAB2_CNN/images/LeNet.png create mode 100644 LAB2_CNN/images/cnn_board.png create mode 100644 LAB2_CNN/images/softmax_board.png create mode 100644 LAB3_RNN/LAB3_RNN.ipynb create mode 100644 LAB3_RNN/images/GRU.png create mode 100644 LAB3_RNN/images/RNN.png create mode 100644 LAB3_RNN/utils.py create mode 100644 README.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ea143da --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +# MAC +.DS_Store +.AppleDouble +.LSOverride + +.ipynb_checkpoints + +# +LAB1_FCNN/.ipynb_checkpoints +LAB2_CNN/.ipynb_checkpoints +LAB1_LSTM/.ipynb_checkpoints +LAB1_FCNN/Data/* +LAB2_CNN/MNIST_data/* +LAB2_CNN/log_files/ +LAB3_RNN/log_files/ +LAB3_RNN/data/* diff --git a/LAB1_FCNN/LAB1_FCNN.ipynb b/LAB1_FCNN/LAB1_FCNN.ipynb new file mode 100644 index 0000000..257f526 --- /dev/null +++ b/LAB1_FCNN/LAB1_FCNN.ipynb @@ -0,0 +1,1136 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

Deep Learning Lab Session

\n", + "

Artificial Neural Networks for Handwritten Digits Recognition

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \n", + "The aim of this session is to practice with Artificial Neural Networks. Answers and experiments should be made by groups of two students. Each group should fill and run appropriate notebook cells. \n", + "\n", + "To generate your final report and upload it on the submission website http://bigfoot-m1.eurecom.fr/teachingsub/login (using your deeplearnXX/password). Do not forget to run all your cells before generating your final report and do not forget to include the names of all participants in the group. The lab session should be completed ans submitted by April 13th 2018 (23:59:59 CET). " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "During this lab session, you will implement, train and test a Neural Network\n", + "for the Handwritten Digits Recognition problem [1] with different settings of hyperparameters. You will use the MNIST dataset which was constructed from scanned documents available from the National Institute of Standards and Technology (NIST). Images of digits were taken from a variety of scanned documents, normalized in size and centered. \n", + "\n", + "\n", + "\n", + "
Figure 1: MNIST digits examples
\n", + "\n", + "\n", + "This assignment includes a written part of programms to help you understand how to build and train\n", + "your neural net and then to test your code and get results. \n", + "\n", + "1. NeuralNetwork.py \n", + "2. transfer_functions.py \n", + "3. utils.py \n", + "\n", + "\n", + "Functions defined inside the python files mentionned above can be imported using the python command \"from filename import function\".\n", + "\n", + "You will use the following libraries:\n", + "\n", + "1. numpy : for creating arrays and using methods to manipulate arrays;\n", + "\n", + "2. matplotlib : for making plots.\n", + "\n", + "Before starting the lab, please launch the cell below. After that, you may not need to do any imports during the lab." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# All imports\n", + "from NeuralNetwork import NeuralNetwork\n", + "from transfer_functions import *\n", + "from utils import *\n", + "import numpy as np\n", + "import matplotlib\n", + "import time, random" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Section 1 : Your First Neural Network\n", + "\n", + "Part 1: Before designing and writing your code, you will first work on a neural network by hand. \n", + "Consider the following neural network with two inputs $x=(x_1,x_2)$, one hidden layer and a single output unit $y$.\n", + "The initial weights are set to random values. Neurons 6 and 7 represent biases. Bias values are equal to 1. You will consider a training sample whose feature vector is $x = (0.8, 0.2)$ and whose label is $y = 0.4$.\n", + "\n", + "Assume that neurons have a sigmoid activation function $f(x)=\\frac{1}{(1+e^{-x})}$. The loss function $L$ is a Mean Squared Error (MSE): if $o$ denotes the output of the neural network, then the loss for a given sample $(o, y)$ is $L(o, y) = \\left|\\left| o - y \\right|\\right|^2$. In the following, you will assume that if you want to backpropagate the error on a whole batch, you will backpropagate the average error on that batch. More formally, let $((x^{(1)}, y^{(1)}), ..., (x^{(N)}, y^{(N)}))$ be a batch and $o^{(k)}$ the output associated to $x^{(k)}$. Then the total error $\\bar{L}$ will be as follows:\n", + "\n", + "
$\\bar{L} = \\frac{1}{N} \\sum_{k=1}^{N} L(o^{(k)}, y^{(k)})$.
\n", + "\n", + "\n", + "\n", + "\n", + " \n", + "
Figure 2: Neural network
\n", + "\n", + "\n", + "Question 1.1.1: Compute the new values of weights $w_{i,j}$ after a forward pass and a backward pass, and the outputs of the neural network before and after the backward path, when the learning rate is $\\lambda$=5.\n", + "$w_{i,j}$ is the weight of the connexion between neuron $i$ and neuron $j$. Please detail your computations in the cell below and print your answers." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== FORWARD PASS 1 ===\n", + "Output = 0.5597295991095776\n", + "=== BACKWARD PASS ===\n", + "w13 = 0.3432265432215471\n", + "w14 = -0.5273473101875394\n", + "w23 = 0.8108066358053868\n", + "w24 = 0.19316317245311515\n", + "w63 = 0.2540331790269339\n", + "w64 = -0.4341841377344243\n", + "w35 = -0.8541467506279605\n", + "w45 = 0.2745727217772572\n", + "w75 = 0.10637455535192797\n", + "=== FORWARD PASS 2 ===\n", + "Output = 0.40648823589210115\n" + ] + } + ], + "source": [ + "# Initial values\n", + "\n", + "lr = 5.0\n", + "# input\n", + "x1, x2 = 0.8, 0.2\n", + "\n", + "# initial the parameters\n", + "x6, x7 = 1.0, 1.0\n", + "w13, w14, w23, w24, w63, w64 = 0.3, -0.5, 0.8, 0.2, 0.2, -0.4\n", + "w35, w45, w75 = -0.6, 0.4, 0.5\n", + "\n", + "# ture label\n", + "y = 0.4\n", + "\n", + "# forward pass on hidden layer\n", + "x3 = sigmoid(x1 * w13 + x2 * w23 + x6 * w63)\n", + "x4 = sigmoid(x1 * w14 + x2 * w24 + x6 * w64)\n", + "x5 = sigmoid(x3 * w35 + x4 * w45 + x7 * w75)\n", + "\n", + "print(\"=== FORWARD PASS 1 ===\")\n", + "print(\"Output =\", x5)\n", + "\n", + "# backpropagate \n", + "d_w35 = 2 * (x5 - y) * x5 * (1 - x5) * x3\n", + "d_w45 = 2 * (x5 - y) * x5 * (1 - x5) * x4\n", + "d_w75 = 2 * (x5 - y) * x5 * (1 - x5) * x7\n", + "\n", + "d_w13 = d_w35 * w35 * (1 - x3) * x1\n", + "d_w14 = d_w45 * w45 * (1 - x4) * x1\n", + "d_w23 = d_w35 * w35 * (1 - x3) * x2\n", + "d_w24 = d_w45 * w45 * (1 - x4) * x2\n", + "d_w63 = d_w35 * w35 * (1 - x3) * x6\n", + "d_w64 = d_w45 * w45 * (1 - x4) * x6\n", + "\n", + "# upgrade the weights\n", + "w13 -= lr * d_w13\n", + "w14 -= lr * d_w14\n", + "w23 -= lr * d_w23\n", + "w24 -= lr * d_w24\n", + "w63 -= lr * d_w63\n", + "w64 -= lr * d_w64\n", + "w35 -= lr * d_w35\n", + "w45 -= lr * d_w45\n", + "w75 -= lr * d_w75\n", + "\n", + "print(\"=== BACKWARD PASS ===\")\n", + "print(\"w13 =\", w13)\n", + "print(\"w14 =\", w14)\n", + "print(\"w23 =\", w23)\n", + "print(\"w24 =\", w24)\n", + "print(\"w63 =\", w63)\n", + "print(\"w64 =\", w64)\n", + "print(\"w35 =\", w35)\n", + "print(\"w45 =\", w45)\n", + "print(\"w75 =\", w75)\n", + "\n", + "# forward pass\n", + "x3 = sigmoid(x1 * w13 + x2 * w23 + x6 * w63)\n", + "x4 = sigmoid(x1 * w14 + x2 * w24 + x6 * w64)\n", + "x5 = sigmoid(x3 * w35 + x4 * w45 + x7 * w75)\n", + "\n", + "print(\"=== FORWARD PASS 2 ===\")\n", + "print(\"Output =\", x5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Part 2: Neural Network Implementation\n", + "\n", + "Please read all source files carefully and understand the data structures and all functions.\n", + "You are to complete the missing code. \n", + "First you should define the neural network (using the NeuralNetwork class, see in the NeuralNetwork.py file) and reinitialise weights. \n", + "Then you will need to complete the feedforward() and the backpropagate() functions. \n", + "\n", + "Question 1.2.1: Implement the feedforward() function." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class NeuralNetwork(NeuralNetwork):\n", + " def feedforward(self, inputs, softmax_output=False):\n", + " # assign the input\n", + " self.o_input = np.array(inputs)\n", + " # add input bias\n", + " self.o_input = np.append(self.o_input, np.ones((len(inputs), 1)), axis=1)\n", + " \n", + " # compute hidden layer activation and output\n", + " self.u_hidden = self.o_input.dot(self.W_input_to_hidden)\n", + " self.o_hidden = self.transfer_f(self.u_hidden)\n", + " self.o_hidden = np.append(self.o_hidden, np.ones((len(inputs), 1)), axis=1)\n", + " \n", + " # compute output layer activation and output\n", + " self.u_output = self.o_hidden.dot(self.W_hidden_to_output)\n", + " \n", + " if softmax_output:\n", + " self.o_output = softmax(self.u_output)\n", + " else:\n", + " self.o_output = self.transfer_f(self.u_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 1.2.2: Test your implementation: create the Neural Network defined in Part 1 and see if the feedforward() function you implemented gives the same results as the ones you found by hand." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output = 0.5597295991095776\n" + ] + } + ], + "source": [ + "# First define your neural network\n", + "model = NeuralNetwork(input_layer_size=2,\n", + " hidden_layer_size=2,\n", + " output_layer_size=1,\n", + " transfer_f=sigmoid, \n", + " transfer_df=dsigmoid)\n", + "\n", + "# Then initialize the weights according to Figure 2\n", + "W_input_to_hidden = np.array([[.3, -.5],[.8, .2],[.2, -.4]])\n", + "W_hidden_to_output = np.array([-.6, .4, .5]).reshape(3, -1)\n", + "model.initialize_weights(W_input_to_hidden, W_hidden_to_output)\n", + "\n", + "# Feed test values\n", + "test = np.array([0.8, 0.2]).reshape(1, -1)\n", + "model.feedforward(test)\n", + "\n", + "# Print the output\n", + "print(\"Output =\", model.o_output[0][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 1.2.3: Implement the backpropagate() function." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class NeuralNetwork(NeuralNetwork): \n", + " def backpropagate(self, targets, learning_rate=5.0, softmax_output=False):\n", + " # backpropagate on output layer\n", + " if softmax_output:\n", + " self.dE_du_output = self.o_output - targets\n", + " else:\n", + " self.dE_du_output = 2 * np.multiply((self.o_output - targets), self.transfer_df(self.u_output))\n", + " dE_dw_output = np.dot(self.dE_du_output.T, self.o_hidden).T / len(targets)\n", + " \n", + " # backpropagate on hidden layer\n", + " self.dE_du_hidden = np.dot(self.dE_du_output, self.W_hidden_to_output.T[:,:-1])\n", + " self.dE_du_hidden = np.multiply(self.dE_du_hidden, self.transfer_df(self.u_hidden)) \n", + " dE_dw_hidden = np.dot(self.dE_du_hidden.T, self.o_input).T / len(targets)\n", + " \n", + " #update the weights\n", + " self.W_input_to_hidden -= learning_rate * dE_dw_hidden\n", + " self.W_hidden_to_output -= learning_rate * dE_dw_output\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 1.2.4: Test your implementation: create the Neural Network defined in Part 1 and see if the backpropagate() function you implemented gives the same weight updates as the ones you found by hand. Do another forward pass and see if the new output is the same as the one you obtained in Question 1.1.1." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def printWeights(weightsMatrix):\n", + " for i in range(weightsMatrix.shape[0]):\n", + " for j in range(weightsMatrix.shape[1]):\n", + " print(\"w_\" + str(i+1) + str(j+1) + \": \" + str(weightsMatrix[i][j]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== FORWARD PASS 1 ===\n", + "Output = [[0.5597296]]\n", + "=== BACKWARD PASS ===\n", + "W_input_to_hidden:\n", + "w_11: 0.3432265432215471\n", + "w_12: -0.5273473101875394\n", + "w_21: 0.8108066358053868\n", + "w_22: 0.19316317245311515\n", + "w_31: 0.2540331790269339\n", + "w_32: -0.4341841377344243\n", + "W_hidden_to_output:\n", + "w_11: -0.8541467506279605\n", + "w_21: 0.2745727217772572\n", + "w_31: 0.10637455535192786\n", + "=== FORWARD PASS 2 ===\n", + "Output = [[0.40648824]]\n" + ] + } + ], + "source": [ + "# First define your neural network\n", + "model = NeuralNetwork(input_layer_size=2,\n", + " hidden_layer_size=2,\n", + " output_layer_size=1,\n", + " transfer_f=sigmoid, \n", + " transfer_df=dsigmoid)\n", + "\n", + "# Then initialize the weights according to Figure 2\n", + "W_input_to_hidden = np.array([[.3, -.5],\n", + " [.8, .2],\n", + " [.2, -.4]])\n", + "\n", + "W_hidden_to_output = np.array([-.6, .4, .5]).reshape(3, -1)\n", + "\n", + "model.initialize_weights(W_input_to_hidden, W_hidden_to_output)\n", + "\n", + "print(\"=== FORWARD PASS 1 ===\")\n", + "\n", + "# Feed test values\n", + "test = np.array([0.8, 0.2]).reshape(1, -1)\n", + "model.feedforward(test)\n", + "\n", + "# Print the output\n", + "print(\"Output =\", model.o_output)\n", + "\n", + "print(\"=== BACKWARD PASS ===\")\n", + "\n", + "# Backpropagate\n", + "targets = [0.4]\n", + "model.backpropagate(targets)\n", + "\n", + "# Print weights\n", + "print(\"W_input_to_hidden:\")\n", + "printWeights(model.W_input_to_hidden)\n", + "print(\"W_hidden_to_output:\")\n", + "printWeights(model.W_hidden_to_output)\n", + "\n", + "print(\"=== FORWARD PASS 2 ===\")\n", + "# Feed test values again\n", + "model.feedforward(test)\n", + "\n", + "# Print the output\n", + "print(\"Output =\", model.o_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Checked your implementations and found that everything was fine? Congratulations! You can move to the next section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Section 2: Handwritten Digits Recognition" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The MNIST dataset consists of handwritten digit images. It is split into a training set containing 60,000 samples and a test set containing 10,000 samples. In this Lab Session, the official training set of 60,000 images is divided into an actual training set of 50,000 samples a validation set of 10,000 samples. All digit images have been size-normalized and centered in a fixed size image of 28 x 28 pixels. Images are stored in byte form: you will use the NumPy python library to convert data files into NumPy arrays that you will use to train your Neural Networks.\n", + "\n", + "You will first work with a small subset of MNIST (1000 samples), then on a very small subset of MNIST (10 samples), and eventually run a model on the whole one.\n", + "\n", + "The MNIST dataset is available in the Data folder.\n", + "To get the training, testing and validation data, run the load_data() function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading MNIST data .....\n", + "Done.\n" + ] + } + ], + "source": [ + "# load data into numpy array\n", + "training_data, validation_data, test_data = load_data()\n", + "small_training_data = (training_data[0][:1000], training_data[1][:1000])\n", + "small_validation_data = (validation_data[0][:200], validation_data[1][:200])\n", + "indices = [1, 3, 5, 7, 2, 0, 13, 15, 17, 4]\n", + "vsmall_training_data = ([training_data[0][i] for i in indices], [training_data[1][i] for i in indices])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# And you can run that cell if you want to see what the MNIST dataset looks like\n", + "ROW = 2\n", + "COLUMN = 5\n", + "for i in range(ROW * COLUMN):\n", + " # train[i][0] is i-th image data with size 28x28\n", + " image = np.array(training_data[0][i]).reshape(28, 28) \n", + " plt.subplot(ROW, COLUMN, i+1) \n", + " plt.imshow(image, cmap='gray') # cmap='gray' is for black and white picture.\n", + "plt.axis('off') # do not show axis value\n", + "plt.tight_layout() # automatic padding between subplots\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Part 1: Build a bigger Neural Network\n", + "\n", + "The input layer of the neural network that you will build contains neurons encoding the values of the input pixels. The training data for the network will consist of many 28 by 28 pixel images of scanned handwritten digits. Thus, the input layer contains 784=28×28 units. The second layer of the network is a hidden layer. We set the number of neurons in the hidden layer to 30. The output layer contains 10 neurons.\n", + "\n", + "Question 2.1.1: Create the network described above using the NeuralNetwork class.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class NeuralNetwork(NeuralNetwork):\n", + " def train(self, \n", + " train_data, \n", + " validation_data, \n", + " epochs=50, \n", + " learning_rate=5.0, \n", + " plot=True, \n", + " init=True,\n", + " batch_size=1,\n", + " softmax_output=False):\n", + " \n", + " def next_batch(data):\n", + " # shuffle the data at the beginning of each epoch\n", + " data = np.array(list(zip(*data)))\n", + " np.random.shuffle(data)\n", + " data = list(zip(*data))\n", + " \n", + " # generate mini batches\n", + " for i in np.arange(0, len(data[0]), batch_size):\n", + " offset = min(i+batch_size, len(data[0]))\n", + " yield (data[0][i:offset], data[1][i:offset])\n", + " \n", + " # initialize weights\n", + " if init:\n", + " self.initialize_weights()\n", + " best_W_hidden_to_output = None\n", + " best_W_input_to_hidden = None\n", + " \n", + " # get starting time to return execution time\n", + " start_time = time.time()\n", + " \n", + " best_acc_it = 0\n", + " train_accuracies = []\n", + " val_accuracies = []\n", + " errors = []\n", + " \n", + " for it in range(epochs):\n", + " errorsi = 0\n", + " count = 0\n", + " \n", + " for (inputs_batch, targets_batch) in next_batch(train_data):\n", + "\n", + " # compute the outputs\n", + " self.feedforward(inputs_batch, softmax_output)\n", + " \n", + " # compute the derivatives\n", + " self.backpropagate(targets_batch, learning_rate, softmax_output)\n", + " \n", + " # compute the squared error\n", + " error = targets_batch - self.o_output\n", + " error *= error\n", + " errorsi += np.sum(error) * len(targets_batch)\n", + " \n", + " # compute training data accuracy\n", + " target = np.argmax(targets_batch, axis=1)\n", + " prediction = np.argmax(self.o_output, axis=1)\n", + " count += np.sum(target == prediction)\n", + " \n", + " # keep track of learning values\n", + " errors.append(errorsi/len(train_data[0])) \n", + " train_accuracies.append(count * 100 / len(train_data[0]))\n", + " new_accuracy = self.accuracy(validation_data,softmax_output)\n", + " val_accuracies.append(new_accuracy)\n", + " \n", + " # update best accuracy\n", + " if new_accuracy > val_accuracies[best_acc_it]:\n", + " best_acc_it = it\n", + " best_W_hidden_to_output = self.W_hidden_to_output\n", + " best_W_input_to_hidden = self.W_input_to_hidden\n", + " \n", + " # set the best weights as current weights\n", + " self.initialize_weights(best_W_input_to_hidden, best_W_hidden_to_output)\n", + " \n", + " # plot learning curves and best accuracy\n", + " if plot:\n", + " self.plot_curves(train_accuracies, \n", + " val_accuracies, \n", + " errors, \n", + " learning_rate, \n", + " best_acc_it)\n", + " \n", + " return val_accuracies[best_acc_it], time.time() - start_time" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Define your neural network\n", + "mnist_model = NeuralNetwork(input_layer_size = 784, \n", + " hidden_layer_size = 30,\n", + " output_layer_size = 10,\n", + " transfer_f = sigmoid, \n", + " transfer_df = dsigmoid)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.1.2: Train your Neural Network on the small subset of MNIST (300 iterations) and print the new accuracy on test data. You will use small_validation_data for validation. Try different learning rates (0.1, 1.0, 10.0). You should use the train() function of the NeuralNetwork class to train your network, and the weights_init() function to reinitialize weights between tests. Print the accuracy of each model on test data using the predict() function.\n", + "\n", + "### Stochastic Gradient Descent" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwYAAAEgCAYAAAAOrGTWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XeYVNX5wPHvlN1lC7CUXUEQAcFXxa6AigVb7ESNFWyxGzEa9acmxtiiib232A0WDIq9RYOVaFTs4itFVIqAwrIs22fn98c5A8Oys312Znfez/Pw7Mxt55yZ4d773tMC0WgUY4wxxhhjTGYLpjoDxhhjjDHGmNSzwMAYY4wxxhhjgYExxhhjjDHGAgNjjDHGGGMMFhgYY4wxxhhjsMDAGGOMMcYYA4RTnQFjTGIiEgU2UNX5cctOAI5R1b1EZCKwnqpe0sC+s4GTVfXNest3Biap6uB2yuNDwGxV/Wt7HK8N+dgbuBzojTu3zQN+r6pfN/Y5tUO6lwNH4h60fAKcpqolIpIN3AnsCkSAu1T11hYeezDus+3wc3V7f2YiMg8IABV+URj4FJioqj81sa/4vLzdxjwcC9wFnK6qk9pwnM2Bd4HrVPWqtuQp3YjIhcDxQAEwBThPVaPN/T2LyGXARODnuMV/VNWp9bYbBTzk3/5WVT/wywuB/wC7qerKdiyaMaYZLDAwphNT1dtTnYd04G8m/gXsoaoz/LI/AE+JyGbJ+pxE5Ghgb2AboAp4EvgTcAFwLi5I2QR3k/WpiExX1Y+SkZf2lqTPbIKqvgsgIiHgZuAGYEIT+x2Cu161OjAQkYuAnQBt7THinABcApwOdJnAQET2A04GRgGrgH8DxwD/pGW/59tV9bImkrsUONG//gtwgH/9V+AaCwqMSQ0LDIzpxPzTuYGqerKIbAc8AmQBL9bb7s/AabineM/FLc8BrgP2BbKBf6jq1X7dPOBvwEnABsBjqnpeC/N3MnAe7lyzCDgWKAUWAENUdbHf7nq/zR9wN1wTgG7AM8C5qhoRkTeB94BDgZNUdXpcUsOBKPBZ3LJbgSf8087LgIHAFcBrcdsUA9NU9TciMhD3NFn8urNV9WWfvzeA/4sFHXG+Bs5Q1Qq/3Zu4QAHgcOBiVa0DSkVkil/WLoGBD4ZuA0bjPrsrVfVBv24c7oY1GyjDfV6fishY4GpgPlADXAz8F/c9n4K78TtXVSfX+229ifvdHAoMwd2gj/ef7QnA34HFwE3Ag6oaaCr//jt9AbjR5znoy7OXz/e7uBvHfYE/AtUi0ktVzxORU3E3qt18/k9U1QoROQQ4SFVPXDdFpgHX+L+t5gOag4GtgQNFZHTc0+5c4B5gF6ASuEpVJzWy/CHiatvi3/v/fw/g/i/sDeQC9wN9cP/HL1HVx/1+++ICrCzgW+A4n94Hqnq932ZzX/b+/rj/UtXn6xVvb2Cqqi73+9wBjMcFBu39ex6Oq2GLvUZEtgGGq+rEVh7TGNNG1sfAmK7jLuAWVd0YmI67gUNENsPdRG3v/20Zt88FwGbAFsAI4DAROTBu/a7AjsB2wFn+5rlZRKQYuB3YW1WHA7NxNzPLgddxzW9iDgGewD2dPAL3xHIj/++MuO22A0bUCwoAvsIFHG+KyHgR6a+qEVVdFL+Rqv6gqpuo6ibAzsBK4Fq/+mHgU//57Q9MEpE+fr89GwgKUNXPVPUzX96euBulWOC1MTAnbvM5uKet7eUGoM4fczRwuYhsLiJhX5ZTVFWAZ4Hr4/bbBrhbVWNP6fsCdaq6BXAO7oltQw7C3ThuDOwB7CQivXHNS/byx92nuZn3N8sn4n6r4H4DuwCbA5vivusj/c3rVNxv+zwR2QW4Elc7NBhY4d+jqlMTBAWo6geqGm1u/hqxL/C+qpYBk3A34THnAdmqOgT3Wd0uIus3srwpA1VVVPUH3Hf4gqpuivvc7heRLBHJBx7FfVYb4/6fXQk8jrupjzkEeEpVa1X1uAaCAnDBdSjufRkwzL9uye95LxGZLiIqIjf4BxD11eGaloWAiIgEcDVIfxWRx0XkeRHZNsHxjTFJYoGBMenvTRH5JvYP93R3LSLSDRgJTPaLpuCaAoC7uX9LVReragR3MxNzEHCnqlap6ipcjcOhcesf8zfYC3FPhDdobqZVdQnQI65/xDvAUP/6ceBon/ctgZCqvu/z84CqrlDVWuC+evl5yT+xrJ9WOS6A+R+un8FCEflARHZrJIsP4tpJf+BvrnbHPfFGVWf7/B7QyP6richjuBqR2bjPECAP93Q4pgLIb87xmukg3M1ynaouBZ4GDvWfW7H/PGHtzx2gQlX/E/c+jPssAGYAgxKkN0VVK/zv5Fu/3WjgW1X90n8vdzWR50f973gWsAxYiAtGUNWngO1VtUZVK4EP6+U7vtyT/W8S4G7W/o0k2/Gs+T80FTjIt78HF1A+AeB/9wN9PhMtb8oLca9/javdA1eb0g339H8M8KOqfunXXYCreXsJ2Mj3zwAXGEymcf8GjhSRgSKSh6tF6ubXNff3PAP3ueyO+z85Criwge0+wQWCuwEf42ompwP7Ac/jmmnd2ER+jTHtzJoSGZP+xmoDnY/rbdPb/y0F8E08SuLWrYjbdnnc60LgJhG52r/Pwd1cx8TvF2Htp4mN8k0urvDNWkJAd9wNJbin6veKyBBcs4wn4/Jzvm8qAu4ctTTusMsSpedvtM4DzvOdds8EXhKRdYIZETkb1zQjVlvQE/f0cvqa+ygKcJ0gm6Sq431wdi3upvFIXGDWLW6zPNwT2Pp5eQMY4I/TkhqFQuBJEan173Nx/SwAfi8ix+O+z264J8Ex9T/DiL/Zh8a/44Z+C73qHW9BE3meoKrv+hvpb4HnY2mLSBFwm39KXAf0wz1Brq8QOEREfuXfB3FNj9pMRAYAb/i3/1PV4+qt7wUcCPwq7neS55c9jat9if2/w9cq0MjypsR/tvsAf/afU+xpe7CBY1fH5XcqMF5E7scFEW81lpiqviIit+Jq9Jb7MsX+/zTr96yqz8W9rRKRm4CLcM344l3KmiD6HFzN084+zYdVdYGIbNhYfo0x7c8CA2O6htjNfg9ghW+v3TtuXc+4bYviXi8ErlfV+CeT7eVIYBywq6r+LCKn4DuZquoqEXke1/TmMOC3cfl5rqUdX0VkY6Ag1txHVecB/yciJ1LvqbOIbA2cD4yKq31YgrvZ3b4FN22IyB7AYlX9SlUrReRe3BN6gG9wzTBm+ffDcX0S1qKqezY3vXoWAgfHPSmO5Wkn3BPaUao6T9xoTfe2Mo2mlOICqJj+zdlJVat9H4brRWR7/z1chev3sIWqVonIowl2X4i7cTy/DflOlK8FNN7c6yjgEVU9PbbA92s4HndD+zPuRj22biDu5j7R8vqBWK+GEhWRLFzQd4SqvuSb5sRGd6p/7Dygt3+Y8DiuFmwFrsZnndq2+lT1WnzALCLHAV/4Vc36PYvIMGCJqpb6RWHc91o/nW+BHfw+9wB/VdVyf+4ibl9jTAeypkTGdAHqOr9+hmsuAO4GJvZ077/AziJS5J/ix9c2PAucLCIhEQmIyJ99R8b2UAzM80FBH1zfgfibyMeA3wF5qvpxXH6O9Tc3iMhp/sl3U7YBpojI6iBARA4AaoGZccvycTdLp8f3P/DNb17ENV9ARPJE5IGGahvq2Rm4Ma4N9UHA5/71k7h+GSER6Y/7TppqytESz8blNywiN/mn7cW4QOcH/zkeD+T7Ntzt7WNgSxEZ5m/oTm7Bvv/E/UaP9e+LgS98ULAVrolM7PdSg6spAN8J2j85R0R+LW6IzY5wAq5DfLxXgbH+N/4ccJz/v9QP11ymbyPLFwFbAfjf7s4J0s33/2Idfc8GqnGfz7tAPxEZ6dddghvlB9yT/z7A72nGb09ExorINBHJFpHuuCZJD/vVzf09XwFc7cvaDTfowYsNbBdLcxSuadXTftHXwEhfm9joMLbGmPZngYExXccZwIUi8i2uXe/XAKr6Ka4d9gzcjdy7cfvcAXyP67z7Da7TZ/z65jo7vh+EiNyAuwHvI24+hceBPwMb+HXgbqh6sPbNxTO49sUzfH+KcX67RqnqZNzIOFPFdXicg7sZ2jeumQy4tugbATfE5TX2hP8MYDef7gxgrqr+CK65jzTcEfJaYC7wuf/c92TNzfEtuKfbihsN5opYR+UWCtX7bL/xN02XAD1FRHHfXwgXlLzi052DG4HpZvwT41ak3SgfXP0JV74PWFNb0px9I7gy/FVcR+QbgNNFZCauGdh5uKD1cHybcxGZ4muFrsb1vZmJ61j/LLin9yLyQEPpicir/rsdBVzrP8dDGto2wf6b4GoT1mpe5vu3vInrM3MTLij73i8733ccTrT8XmCwuD4XfyPBd6SqJbjf2ici8gnuu30G1wchAPwG11n+W9zgAn/y+0VwNQ0h3IhesbI8IiIHNZDUO7gmXrNwv6UHdc08KAl/zyLyNxGJ1aKcgxsB7FvcPBWf4b7bdfhg8kZcoBNzM+67fw03apYxpgMFotH2GKTBGGNaTkS+Ag5X1XWaJJjOQUQCsdF+RGQE8K6qNtgkxnQ8EbkA6KuqF6Q6L8aY9Gc1BsaYlBCRo4BFFhR0XuKGRl0gIqP9oiNxTddMGvDNrU7F1RgaY0yTrGOPMabDici/cW2sD0t1XkzrqWqtiJwJPOybhSzCDTtpUkxETsM1Kfqrqs5NdX6MMZ2DNSUyxhhjjDHGWFMiY4wxxhhjjDUlMu1ARN7DjSG/Varz0hbiJw5T1b06IK2JwHqqekmy0zLGmBgRiQJPqeph9ZbfB5ykqskY1rZ+HoK4GcoPw42qlIUb0vX//NDBacHPN/FjQ5+JiMzD5b2i3qo/qurUJObpTeA+VZ3U1LbtkNYbuO9kRrLTMunDAgPTJiKyOW4oxGUisqOqWsfDZmjpBF7GGNOOthSRHrFJyMTNRD2yiX3a06m4ORtGqmqZnzPhZdzEg3/vwHy01QRVbc3wzp1CGyZfNJ2YBQamrY7HjZNdCRxH3IgkftbMP/u3HwAn+8mL1lkO7Ih7CjLM7zs29l7cDKkDcBMBPQbcCtwG7AVk48bdP1FVa0SkL/AgMAIow11osoBrVHXzuLx9hOuUV3+yotj6Qp/GaNz/kytV9UG/bhxultZsn8ZJqvqpz/PVwHzchEwX+8/jb8ApuJmIz1XVyb5MA1X1ZP8E6DncGPtDgLeB8aoa9bUYfwcW48ZCfzDB06t9cWOFZ+HGDz8ON0fAbFUN+20Gx977447DzYj8MW6SqQNjE42JyDnADqp6lIicihsrvpsvz4l+QjVjTOc0DTcZYmzysn2AD3FzIABu4jjgr7iJ1Wbjzkk/+0nzHgS2xp0Dn4rNQt3Yuaxe+lsAX8ZmGVfVlT69cn+ckT5vYdwcFvvi5raAxNeJpvL1ns/XSbg5XhKd308ELsXN6p1o9u0m+ZqZP+EmxdsMN/fEA7jZ3/f2m90LDMZdL65V1Uf8eXo6bn6XbVV1t0bSGIOb96EXbgbs8ao619fIJLpGPoSbdXsv4ErctbIva66xPwO/VtVFvlbkGNw1LdG1rBvwCG5Cwq9wc8D0U9UT6uU1gLtGHeLLe6+qXhd/LfTbrX5f73v7J3C0qm4Rd8xPgYuA90nwfZqWsz4GptXEzaJ7KPAUboKh/f2Tp9hN6PXAWEBwF5ffJ1rejOT2B/ZX1ZtxJ5ZdgM1xE3JthxsmEdxN9NeqOhQXtDyOm/2zv4hs6fM2CBiGe0KVyA1AHW5Co9HA5SKyuR+e8WHgFFUVX+7r4/bbBrhbVSf4932BOn8yOwd3oW3IQbiLxcbAHsBOItIbuBN3At8Gd/Feh7jZfB8FjlTVjXEX8SsbKVvMr3AzAF8ATMUFCjGHAE+KyC7+WHuo6mBc7VBzjm2MSV9PAuPj3h+Ne8ADrJ6FOXYjNhQXSMSGPD0D6I47N24LnCAi8TM2r3MuayD9l4HTROQWEdldRLqp6i9xDxzuAm7x57MPcdeKpjSVr+2AEao6ncTn9164B0/7+nP2+s1ItzEBVRU/0Ry4G17xk9v9A3jTX0cOAG7110dw141PmwgKuuOCpj/5QOkW3PcKjV8jwU3EOEpVY9/54bjr00a4ifhObCDJRNeyk3Gf04a4oOG3CbI8ATe54MbA9rhZtEclKl+c7XDBy/XAQD+5I/7vQNz1vcHvsxnHNg2wwMC0xT7Ah6paGjf7Z2w2zV8B01V1oX9aNB73xDvR8qZ8oKo/A6jqU8D2qlqjqpW4C8dQv93+uGAAVf0EGKyqVbgZRY/22xwMPOuXJ3IQ7sJUp6pLgaeBQ33712JVfd9v905c2gAVqho/M2oY9xQL3JOUQQnSm6KqFX6W3m/9dqOBb1X1S1Wtw10sGzIG1w72S//+AuAPjZQt5ltVnRVLHx8Y+FqXrYCXcJ/DZFVd6Le7GxcMGmM6rzeBESJS7J+07wS8Ebd+X9xNa+yccjcwTkRCqnoD7olyVFWX454Sx58DGzqXrUVVX8CdqwfiZnBeJiIPiUgv/wR6O9bMiD4ZVyPdqGbk6yV/HoUE53fcOXeWqs702z1M4x5tYFby7Lj1L9Tb/gUAEcnCBU93+rx/jwu+9vDbZeEe1jRmF2C+qv7bH+NxYJiIDGriGgnwhl8e87aqfu+vyZ/Q8HUq0bVsF9x3XuvL8WKC/O7vt6vxTdg29flqykv+e6rGBUKxB1iHAM/4a3Ki79O0gjUlMm1xAq6WoMS/D+OqNJ/CPV2ILSd2EvI3nQ0tbyqtZbEXftKe20RkW9xTgn646lQaSHelf/k48BDwR1xgEP+UvyGFuCfmsY5wuax5ovZ7ETkeyME1r4mvJl/G2iL+AgkQAUIJ0lsRv4/frle94y1IsG/9MldDyz5T4C1ggK9N2Qt4UVUrfZOqQ0TkV367IK5q2hjTSalqRESeBo7APSF+Vd2cFLFNCoFdReSbuN1WAH1EpCdwo4hsgjtXbcCaG8bYdjEJz3mq+jrwuq95HoM7J98JnBd/HN+k8uemyiQiw5vIV/z5LtH5vXe9/C9vItmm+hjUvx7E3vfB1SbUT6vYv474m+fGFAIb1fuOqoAiEakg8TWyoXw15ztLdC1r6Dq1QQP7179OrYIWX6emAGfjakcOZk3tdWPXa9NCFhiYVvFVrmOB3nE3omFgvr9x/5m4KmQR6YH7z5poef2TUa9Gkr8K10ZxC3V9FuLbgf6MOwHN88cfjDtRvQ2EReRAXPXqv5so4kLg4LgnZrH87gRciKuGnScie+PaiSZDKVAQ975/gu1iZY7lMQ93gYsAQREJ+CdBCT9Tf6PwDO7Jyz7A/X7VQuDhWFtdY0yX8QSuT9RS/JPrOAuB17XeyEUAIjIJ1y/pYH/eeK+lCYvIfria4xW+mc3bInIlrg177OaxB7DCt5fv7Zc1dp24owX5SnR+3w/X7yqmqIVFa66fgToR6eVrN8AFC4tbcIyFwExV3b7+ChH5B4mvke2ttdep9XAjOrXk2v8q8KAPAjcGYrXzDX6fpnWsKZFpraOA/8SCAnCzoOL+4x6Na4YyRkQG+05Hd+M6fSVavgjXD6DYP0GaQGLFwBf+hLcV7mlT7MT0HK4mAxHZDFflGfZVyJOB24HnVLWmifI9C5zujxMWkZv805di3BO2H/wN+PFAvi9Le/sYN3rIMH9xPDnBdu8C/XyHPYBLgL/gTsQRXEc/cB2SGzMFFxiMAl7xy54DDvXBHiLyaxG5sDWFMcaklf/ibuI2x9UYxnsV2MX3NUBERonILX5dMfCJv/neGxjO2jeGzfF74BrfbAj/9zDgLd8s9XPWNAWZgHt4BI1fJ1qSr0Tn94/cIhnutzu+heVqlrhr5Wk+DxsBu+LayzfXB7jPYrQ/xlAR+ae/FjV2jWxv/wN+IyJBEdkA2C/Bds8BR4tIju8X9y7ut7cI2Nzv3xfX5KhBvvnvq8C1uObAsb4bib5P0woWGJjWOh7XNrS+qcBxqjofNyTdf3DtTKPAjY0sn40bseET3AnjjQaOHXMDcLqIzMSNVHEecLKIHI57mj9Q3GgKk3GjNMQ6tD2O6yA1eZ0jrusSoKeIKK6tagh3sXoF93RiDvAarnp2Be6mul2p6iLcqBbTcBeBdxJsVw78BpgkIt/iRhb5ky/3pcAr4kZh+rSJJP+D6xT271j/C3XjV18NvOk/73NxJ2FjTCfmaxGn4moG6uqtW4TrSDrV/7+/nTXnzb8CN4jIl8BuuPkILhc3Qk5zjcedU7+IO8f+gusfBe68fmHc+ex7n6/GrhMtyVeD53ffPv08XBOnLwFtohwN9TH4WzM/g9OBsb4p0FTcqH0/NnNf/Pn9MFyToZn+GP/y32tj18j2djeuD8gcXK3NE6zdvDZmMu6mfhbu+7tfXUfwfwGr/P7/pOkmQFNwzYiejFuW6HptWiEQjTb0/RnT9fiqyxnAoLgnDWktrhkQIjICeFdVG6tqNcaYLkVEZuNunN9MdV7Muupdp67D1dI3ZwAMk4asxsBkksuBuzpRUBAGFsSqinHDzdkEcsYYY9KCuHl9PvRNhApwQ6/adaoTs87HpsvzNQX/xVUtdpqnGH6UkDOBh30fg0W4/hjGGGNMOngR1y9gJm4EpBdIQtNa03GsKZExxhhjjDHGagyMMcakDxG5CdgB14HxbFX9MG7dBrhBBLKBGap6empyaYwxXZP1MTDGGJMWRGQ3YLiq7ohrNndrvU1uAG5Q1VFARNyEfMYYY9pJp2lKtHTpylZntKAgh7KyqvbMTkpYOdKLlSO9ZHo5ioq6J2MujQ4lIlcAP6jqff79N7jJBEt9P5sFwMDGBhCwa4WVIx11lbJYOdJLMq4XGdGUKBxucEb2TsfKkV6sHOnFytEl9MNN7Bez1C8rxc1CuxKITV70jqr+sf4BCgpyWv0ZhkLBLvH5WznST1cpi5UjvSSjHBkRGBhjjOmUAvVeDwBuAeYBL4rIAar6YvwObXkKWFiYR0lJeav3TxdWjvTTVcpi5UgvrS1HUVH3hOusj4Exxph0sRBXQxCzPm6YXoCfge9VdY5vSvQGMKKD82eMMV1aUgMDEdlcROaIyET/fgMReVNE3hGRJ0Ukxy+fICIfisgHImLjtBtjTGZ6DTgMwDcXWqiqK8HN6wHMFZHhftvtAE1JLo0xpotKWmAgIvnAbbinOjFXAHeo6i7AbOBEv91fgL2AscAfRKR3svJljDEmPanqdOBjEZmOG5HoTBE5QUQO8ZucAzzo168Ank9RVo0xpktKZh+DKtxseBfGLRsLxMadfh44H/fE50NVXQEgIu8BY7ATvjHGZBxVvajeos/i1s0Gdu7YHBljTOZIWmDgq31rRSR+cb6qxnqGLQH649qTLo3bJrbcGGOMMcYY00FSOSpRojFUG1ze1iHoCgvzWrVvOrFyrC0adf9SJRAI0qNH5/8+rBzpIxDoOv/PjTHGdD4dHRiUiUiuqlbghp1byLqjUAwA3l9nxxQOQRd/AxoMrrsMoLoa5s4NUtVANmtq4LvvgvTvH6Vbtyhz5waprGz5XER5edmsXFnDnDlBKivXXR8MwvjxNfTtG2XAgCihRuKo118PMW1amLKyAHPmBCgv77i5kUIhiCScnqh56urghx+ClJWlek6nzj8OsmPlSAdDh9bxzTd17T78nGnaqzOX8NQXP/GPI7ZMdVaM6ZIWLVrI4YeP4+67H2TzzbdYvfzkk49jyJChXHzxZe2e5r333sWHH35AdnY2kUgt5557IcOHS9M7trO5c2dz443Xcvvt/1hr+W67jWaLLbZaa9l5513EkCFDOzJ7a+nowOB14DfAJP/3FeAD4D4RKQRqcf0LzungfK1DNch//hPimWey+PLLIDU1AbKyopxxRjXdusGdd2an6Ka0G/n5Ubp3X/dR+cqVASZNyqKuLsDBB9dw++2VnHZaN4JBOPfcakaMqAPg3XdDjB+fR15elJ49owwaVMfAgXUdVoJwOEhtbdvTGz06QlFR6qoMunXLorKyJmXptxcrR/oYPLgOyE51NjLS3GXlfDq/JNXZMKZLW3/9Abz++qurA4P5839k5crSpKT1yScfM2uWcs89DxIIBJgx4yMeffQRLrvsqqSk1xoFBQXrBAuplrTAQES2A24ABgM1InIYMAF4SEROA74HHlbVGhG5CHgViAKXxzoip8rXXwfZa688amsDbL11hFNPrSE/P8o33wS59dYcAPbZp5attlrz2DsYhCFD6igoWPdGNRiEDTaI8tNPAWpq3MW/oKDl+erZM5fS0gr69o2urrmIt3w53HxzDosXB3j66SyWLAkwfXqY/Pwo//tfiEceqeCbb4Jcd10OG25Yx1tvrSIvBS0WXA1OA1UenUxhYZiSkupUZ6PNrBzpxgKDVAgFYjXBUQKBVNdEGtM1jRixBR999AGRSIRQKMTrr7/KyJE7UFXl7gk+++wT7rnnDsLhMMXF63HhhX8mEAhw1VWXsXTpEioqKjjxxFMZM2YXJk48lZEjRzNjxkeUlJRwzTU30a/fmgYoZWUrqaioIBKJEA6H2Xbb7dl22+0BeO6557jvvnspLl6P3Nw8dtxxDABz585h4sRzKC8v57jjjmTKlOd57bWXmTJlMqFQkMGDN+LCCy/mpZee5/33p/Pzz0u5/PKrefvtN3n99VcIBILssstYjj76GJYsWcwll1xEVlYWw4Zt3KLP6f7772HhwgUsWrSQE088lSeffIzy8nImTvwDCxbMZ/LkRwmFQmy55RacccY5a21/2233EGqsyUgTktn5+GPcKET17d3AtlOAKcnKS0tNnpxFIADvvbeK4cPXPNmORuGss6rp1SvKoEEtf1K9cct+F+soLIRu3RKn26sXXH55FdEo1NbCc89lIRLhnnsqGTcuj332yQdg+PAIN99cmZKgwBhj0lHQBwORKIQtLjBd3ItfLea5L39q8X6N1fiP27wfB4xYr4n9w2y22ebMmPERI0eO5t133+a3vz2FN990I9vffPN13HLLXfTo0ZM777yFadNeZ+TI0YwatQP77XcgCxbM55JLLmLMmF0AyM/P55Zb7uKuu27j7bf/wxFHjF+d1ujRO/HUU0+HkyS3AAAgAElEQVRyxBG/Zscdx7Dzzruxww47AXDrrTdz332TKCgo4MQTJ6wODBpSUVHBDTfcRvfu3TnzzFOYM2c2AIsX/8Tddz/AokULefPNN7jzzvsBOOOMk9h99714+unJ7LnnrzjiiKOZNOkhZs/+tpmfslNbW8Odd97HjBkfMWfObB5//Glqa2u59NI/8uCDj5GXl8fFF5/PjBkfrbV9W6Wy83FaWbo0QN++USIRmDo1zJ571q4VFIDrGLjVVh3X5Ka1AgG44YZKVq4McOqp1Wy2WR3vv7+Kl18OM3x4HaNHR7AHYsYYs0Yo6E6KdXVRCNoJ0phk2X33PXn99Vfp06cPRUVF5ObmArBs2S/Mn/8jf/rT/wFQWVlJz56FdO/eg5kzv+K5554mEAhSWrqmUclWW20DQHFxMStWrN3YJDs7m5tvvpNvvvmaDz/8gNtuu5E33niNiRP/QEFBAYWFhQDrtPGvr0ePHvzxj+cB8P3337FihWtyuOmmmxEIBJg58yvmz/+Rs846DYDy8lX89NNC5s37jt133wuAbbbZnvffn77OscvKypg48dTV7wsKCvj732/0x18zsfuwYcPJzs7mu+/mMnDgIPL8k92RI0fy7bffrLN9W1hgAHz8cZADD8zjmGNcx96ffgoyfnznburSsydMnlyx+n3fvlGOPbZzt782xphkidUY1KVyqDNjOsgBI9Zr8ul+Q9o6mAvA9tuP5sYbr6NPn76MHbvn6uXhcBZ9+xat0+b+5ZdfoLS0lDvuuI/S0lJOPvnY1evim8xE6/3fjUQiRKNRNtlkMzbZZDMOO+woDjlkP373u9+v1Vwwdoz4ZbW1tQDU1NRw443X8tBDj9GnT18uuGBNF9hwOGv13x13HMMFF1y8VvqPPvowgUDQ563hh8qN9THIyspa53UgsHY5a2pqCPq25fHbt0XSZj7uTG67LZtIJMDDD2czY0aIW2+tYN992zhsjjHGmE4jVkkQscDAmKTKyspi66234cUXn2XMmF1XL+/RowcA3303F4ApU55g9uxZlJSU0L//+gSDQd566z/U1DTvIef999/DAw+suekuKVlO79596NWrN6WlKyktXUFtbS2ffjoDgLy8fH755WcAPv/8U8A9/Q+FQvTp05fFi3/im29mrg4aYkQ2ZcaMj6msrCQajXLzzddTVVXJoEEb8s03XwOsbu7TVhtssCHz5/9AefkqAD766CNENmuXY8dkfI3Bk0+GefnlMGedVcXQoVHGjq1lwAC7MBhjTCZZ05QoxRkxJgPsvvtelJQsp6DeSCwXXfQXrr76crKyXO3BuHGHkp+fz0UXncvXX3/JAQeMo7i4mAcfvLfJNI477kRuvPEaTj31BHJzc6mrq+Piiy8nEAhw5plnMnHiqRQVrccGGwwCYPvtR/LIIw8wceKp7LTTzgQCQXr2LGTkyNGcfPJxDBs2nPHjj+XWW2/kiCOOXp1Ov379OOKIoznzzFMIBoPsuutYcnK6cfjhR3PJJRfx9tvT2Gij4Q3msX5TIoCjjpqQsEy5ubmceebZnHfeWQQCQUaO3J6tttqajz76oMnPo7kC9ate0tXSpStbndFEVV9ffBFkzz3zGTOmlocfrsAHq2mrParw0oGVI71YOdJLa8tRVNTdGsbT+mvFEzMWcMO0Ofz7dztSmNs+VfKpkun/F9JRVylLVyzH7bffzNChG7H//gelOFctl4zrRUY3JZo6NUw4HOWBB9I/KDDGGJM81sfAGGMyuClRNOqG89xttwi9eqU6N8YYY1Ip5B+T1dVZYGBMJpk4MeVz6qaVjK0x+OyzID/8EGTcOBupxxhjMl38PAbGGJOpMjYwePbZLLKyouy3X23TGxtjjOnSQtaUyBhjMjMwcM2Iwuy2WwQ/v4UxxpgM5ocCJ2JNiYwxGSzjAoNoFN5/P8SPP1ozImOMMc6azscpzogxxqRQRnU+XrQowK675pOdHaVPnzrGjbNmRMYYY+KaEllkYIzJYBkVGHzySYgVKwJAgPPPryIvL9U5SmPRCNRVxy0IQKhbyrJjjDHJFAzGOh9bYGCMyVwZERjc9MGNVFTU8O6cEOwY5sCDath+jy2BXaiOVHPfF/ess8/2641iVP/RlNWU8chXD66zfqf1x7B18baUVC7nsW8mrbN+t4G7M6Lv5iwpX8KUbye7hdEIRN20mnsN2pONe2/CglVLeXbO1HX232/IAQzpOZTvVszl5e9eBCA3N4uKCtf86dcbHcKA7gP5dpny+g+vrbP/YRsfSXFeMV/9/CVvzZ+2zvrxmxxDYbdefLpkBtMXvufzVwfRCMHqpfy+Ygo9axevtU/FwJMo2/gqoLnzKCUxmIjWQV3Vmveh3OSkY4zJCCF/WrPOx8aYTJYRgUHM0p8DdO8eZfvt68jJSWJC0QjUVUKkHCIVUFdNqPJHui18jEBdJQC9F11G3+wgy/qfDnVFfscABLNcR4gOFqxaRLcFDxOsXekWFPWjbNhlxIKAUPlscuffT+78+1t03Ir1j6Fss9sgEGqfjEbrCJXPpcenRxAun716cVXxwawccTvRsM1UZ4xpudV9DOpSnBFjjEmhQLSTPB1p7TT3sGbK6P32yyMvL8pTT1W0Z9bcjXwgAHU1ZC1/hx6fH0+wdsU6m9XmC5X9x69+n1U6g5wlz645DAEq159AztJXqBh4AuVDzl+7HD3zKFnR0NTXwdY/ma+rJVz2BT1nHEI0mEvFBqdAIMw7DKYuZz1G9R+9uozZS54lVP5dsw8dqphH7oIHqex3OCs3vQUCwSbK0cTxKhfS49PDCZfPoS5cSMWGZxENhAlW/0TeD3cBUFU8jpWb3UE0mNXi47dUa8vR4YK57veZQFec4r4zS8YU95mktdeKt+f8wnnPfMXDE7Zhs37d2ztbHSrT/y+ko65SFitHeknG9SJjagyiUZg1K8hhh7XDSESxQADI+mUaPb44gaqig8hZ8gzB2lJq8zelfMh5a+8TyKKy/1FEs/usXlQRrSNn0RMEq5cAEC79hNyFk6gLFZD/3fXkf3f9OkkXrbPEBRQVG57FquFX+rQa+L5XBy+19Jq+PeVD/4/qogPpNX0koeqfiOQMoGT7F6nLGwrA/z69Dfh+TWAQCFC93sEt+pgAIrmDKJh9Od1++leT5WiOunAhZcMupbr4ICL5G69eXt1nb7J/eZ28H+4kZ8lzrTx6y7W2HB2ppvs2lG79GHVZCcbmrY262q1kCuauDgyNSUe+iwGd5WGZMcYkQ8YEBkuWBCgtDTB8eNvqiYPlcyn8cB8qBv2O2u6b0/OzCUQDYXIXPkJtwWaUDziOyn5HrhUAJBQIUrX+mhoEonVUF4+jutfOZC+bRrDqp7U2z+2WRUXluoFNeOUX5H1/K9FQHt3mP8Sq4ZdStf4Et7KulvDKT+jx2TGUD/k/qvv+inDFXHIWTyVU8QOh6p9YNfRPVA44hrpuA9vy0TSoYsh5RPI3IVQ+q8lyNC1AddH+RPKHr7Ompu9e1PTdi+o+exEu+7INOW6+1pej4wQi5eTNu5k+72za6HbJDnBq84azYpsnqcvpl8REOiDASbZAMts4msbYzMfGGJNBgcGsWe5p5bBhbQsM8udeS6h6MQWzLwWgtmALSradSvayt6jus0fzAoJEAkGq+v0GgKr+R62zOqcwj4qGqoyiUYJVi8mf+3cAcuc/5AKDyCp6v7s1oWrXiTh/zlWrb/6zlk8nq+QDqooOpHyji1qf52aoLj6geeVoB7EAoSMksxztqbpof7KWvZVwfXyn9mQIRGvInXcLfd7bJmlpxHSGGpzGRLptSN1Bc1KdjYxkw5UaY0wGBgZtqTEIVv1Ezk+TKd/gdGq7b0kwspLK/kcSzepNVf/D2yurLRcIUL7Rn8j+6G2ioXyyVnxAsHIBWSUfEKpeTPngc6jpOZKen00gb+7fXFkiZQCsSnJQYFKvtsfW1PbYOuH6jghwqorHkb305aSmkewApyNEcodgoyinxuqZj60pkTEmg2VMYDB7dpD8/Cj9+7f+pB9e8RGBaISqfodRWziqHXPXdjW9dmLFlpOoyymm14e/ImfxM2SVvE9ddjGrhl0KgRCRbhuQVfrJ6n2qig8i0n3LFObaZIpI/sZUxPUJSYbOUoPTlEwPDETkJmAHIAqcraofxq2bB/wIRPyiCaq6oD3SXTPzsQUGxpjMlTGBwaxZQYYPr2tscBY3Ln60LuGY+OHSGUQDIWq7b5GcTLZR9XrjANe8qdvCSYTK51K5/oTVQ4XW9tiGUOWPRHIGULbpjdT02C7hsU7e4rQOybMxxsSIyG7AcFXdUUQ2BR4Adqy32X6qWtbeaYdsuFJjjCFjhgmZNSvYaP+CYMX39J02iL7T1id33i1u/gFYa06BrNJPieRvmvaTaVX1O4Rw2VdQV+mGH/VizUnqcgdRXbQf0ZzihMfIDmWTHcpOel6NMSbOnsAzAKo6E+glIh0yOYnNfGyMMRlSY1BWBgsWBBk+vIH2x34Yz5yfphCoq6C6z54UzLqE/Fl/YeWIuyjQi1g54i6qi/YnXPoJVUX7dXwBWqiq+GDyZ19B1XqHEClYMxpNTQ/X+TOSO6jJY7y34B0AxgzYJTmZNMaYdfUDPo57v9QvK41bdreIDAbeBf6oqmvdyRcU5BAOt3xCxZ5l1QDk5mVTWNi5G3SFQsFOXwboOuWArlMWK0d6SUY5MiIwmDvX/R06dO0ag2DlAnq/M4LSLR8kZ/Ez1PQcyYqt/0XOT5PpPvM8Cmb9hWBtCfmzLyOSN4RgzS+NduJMF5H8YazY6glq6vWDqO2+NVECRHKHNHmMz5Z+ClhgYIxJqfqNP/8CvAIsw9Us/AaYEr9BWVlVqxIqX+X2K11Z1eknPsr0yZvSUVcpi5UjvbRhgrOE6zIiMPj5Z/e3qGjtKuKs5e8SoI6enx8PQNnGV0MwTNX6E+i26Emyl00jSoDwKqXnJ4cTDeZSVdzySb5Sobp4/3WWRbP7sGLbp6ntnv7BjTEmIy3E1RDErA8sir1R1Udir0XkJWAL6gUGrWWdj40xJkP6GCxb5v4WFvoTfqQSIqsIr/x89TY1PbajcsDxa973dk/Kq4sPpLLfEYQqf6Rig1MabZffGdT02bNtcy0YY0zyvAYcBiAi2wILVXWlf99TRF4VkVjnp92AdpvNMGSBgTHGZEaNwfLl7oTfu3eUYOUier+3NYE617m4pse2lA85n5reuxINr6laqe61C/lAde/dqBx4ElXF46juoImzjDEmE6nqdBH5WESmA3XAmSJyArBCVaf6WoL3RaQC+IR2qi2AuHkMbIIzY0wGy4jA4Jdf3N+ePaMEK+atDgrADeFZXXzgOvvU9hzFii0nUd33VxAIrR4K1BhjTPKoav1ZFz+LW3cLcEsy0l3TlCgZRzfGmM4hIwKD5cshNzdKbi4Ey0oAqFj/GHIXTiKSN6zhnQKBjA4Gfrf1WanOgjHGdBhrSmSMMRkSGCxbBr16uZN9oGY5ABWDz6W67z5U990nlVkzxhiTBqwpkTHGdHBgICIFwCNALyAHuBz4CbgLiAKfq+oZ7Z3uL78EKCx0Q5UGa12NQV12byLr/bq9k+oypv3wBgC7D9ozxTkxxpjksxoDY4zp+FGJTgBUVXfHjTxxC3AzcLaqjgF6iki7zyC2fHl8jYELDKLhnu2dTJcyc9nXzFz2daqzYYwxHSLWxyBicYExJoN1dGDwMxAbK7MXbpKaIar6oV/2PNDuQ/+s3ZSohLpwTwi0fGZMY4wxXVMw6GsMrCmRMSaDdWhgoKpPAINEZDbwNnA+sDxukyVA//ZONz4wCNYuJxoubO8kjDHGdGIhP8eyNSUyxmSyju5jcAzwg6ruKyJbAVOBFXGbBBLtW1CQQzjc8qf80agLDNZbL0xhzyAhVhLo1pvCwrwWHyvVQqFgh+U7NzcLICnpdWQ5ksnKkV6sHKYtrCmRMcZ0/KhEY4BXAVT1MxHJBbLi1g8AFja0Y1lZVasSLCuDmprurN9TyZqyKeAmLVtRUt6q46VSYWEeJR2U79oqd3VMRnodWY5ksnKkl0wvR1FR96Y3MgmFrCmRMcZ0eB+D2cBoABHZEFgJzBSRnf36Q4FX2jPBkhJ3sh/ce9bqZdFwr/ZMoks6ZcszOGXLdh8gyhhj0lLQRiUyxpgOrzG4B3hARN7yaZ+OG670HhEJAh+o6uvtmWAsMMjNWxMD1WVZHwNjjDFr+AoDm8fAGJPROjQwUNUy4IgGVu2SrDSrq93fvOyy1cuiFhg06d/zXMXN3oP3TXFOjDEm+VY3JbK4wBiTwTq6KVGHq652J/ucUFxgEO6Rqux0GrNKZjGrZFbTGxpjTBewpvOxRQbGmMzV5QODmhr3Nye0pjNfoLY0RbkxxhiTjmJNiazzsTEmk2VOYBBcU2NQl9U7RbkxxhiTjgKBAIEA1KU6I8YYk0Id3fm4w8X6GOSEVgGwYuvJVPdp98mVjTHGdHKhQMBqDIwxGa3LBwbhmkWsemALqmtHEg12o7pov1RnqVPIC9sES8aYzBIMBmy4UmNMRuvygUFu5Dvy8ivIqf6QaDg/1dnpNE7Y/KRUZ8EYYzpUKBAgYm2JjDEZrMv3MQhFVri/0QqioYIU58YYY0y6CgZtgjNjTGbr+oFB3ZoRiKzGoPlenPs8L859PtXZMMaYDhMKWFMiY0xm6/JNicJ1K1a/joas3XxzfV86L9VZMMaYDhUKBmzmY2NMRuvyNQbhaFyNgTUlMsYYk0AwELCZj40xGa3LBwZZawUG1pTIGGNMw0LBgM18bIzJaF0/MMCaEhljjGla0OYxMMZkuC7fxyA7EB8YWFOi5irMKUx1FowxpkOFbFQiY0yG6/KBQU7QmhK1xvhNj011FowxpkMFAwEiFhcYYzJYl29K1C1oTYmMMcY0LRS0pkTGmMzW5WsMuoXiAoOwNSVqrmdnPw3Ar4cdmuKcGGMyiYjcBOwARIGzVfXDBrb5G7Cjqo5tz7SDNo+BMSbDdfkag9xQKeXVrqbAmhI134KyBSwoW5DqbBhjMoiI7AYMV9UdgZOAWxvYZjNg12Sk70YlSsaRjTGmc+j6gUF4BT8uGwpYYGCMMWluT+AZAFWdCfQSkR71trkBuDgZiYdsVCJjTIbr2k2JohFys8r47pdNkH5fEs3qleocGWOMSawf8HHc+6V+WSmAiJwAvAXMS3SAgoIcwuFQqxIPhQIEw0EKCzt3f7RQqPOXAbpOOaDrlMXKkV6SUY4uHRgEat2IRJ8v2pEdjj2Omt67pDhHxhhjWiAQeyEivYHfAnsBAxLtUFZW1erEggGoqq6lpKS81cdIB4WFeZ2+DNB1ygFdpyxWjvTS2nIUFXVPuK5LNyWKBQYVkZ7U9BkLgdY9RcpERblFFOUWpTobxpjMshBXQxCzPrDIv94DKALeAaYC2/qOyu3GTXDWnkc0xpjOpUvXGBCtBaC0er0UZ6TzOVyOSnUWjDGZ5zXgcuAeEdkWWKiqKwFUdQowBUBEBgMPqeof2jNx1/nY+hgYYzJXl64xqMvbiLOeeY2PF+6X6qwYY4xpgqpOBz4Wkem4EYnOFJETROSQjkjfhis1xmS6rl1jALz/3R4UFnbp+Ccp/qVPAFZzYIzpWKp6Ub1FnzWwzTxgbHunHQoGqK61wMAYk7m6fGBQUwPZ2anOReeztGJpqrNgjDEdKhSweQyMMZmtyz9Kr66GrKxU58IYY0y6CwaxpkTGmIzW5QMDV2NgJ3pjjDGNCwYCRGyCM2NMBuvygUF1dcCaEhljjGlSMBDAKgyMMZksYR8DEXmyGftHVfXIdsxPu7M+Bq0zoCDh/EHGGNMl2XClxphM11jn4+HAOY2sDwDtOrlMMlhg0Dq/HnZoqrNgjDEdyoYrNcZkusYCg4tV9a3YGxEJ42adXKqqtX7ZxUnOX5u5pkR2ojfGGNO4UBCb+dgYk9ESBgaq+lLstYhMACYAy4B+IvKeql4av01z+WNdANQCfwE+B/4JhIBFwLGqWtXS4yZSU2OjErXGYzP/CcD4TY9NcU6MMaZjuOFK7UGSMSZzJex8XG+mybGqur+qHqOqewF7tCYxEekDXArsDBwI/Bq4ArhDVXcBZgMntubYiVRXW1Oi1iipKqGkqiTV2TDGmA4TDFpTImNMZmusKdGmInIi7kb+TRF5AfgFGAC808r09gJeV9WVwErgVBH5Djjdr38eOB+4q5XHX0skApGINSUyxhjTtFAgQJ0NV2qMyWCNNSW6WkSKcc19coCJQDXwSxua+gwG8kTkOaAXcBmQH3e8JUD/Vh57HTU17q/VGBhjjGlKMGgzHxtjMltjNQao6hJgoogI8DdgJnBdG9ILAH2AQ4ANgWl+Wfz6BhUU5BAOh1qUWGmp+9utW4DCwrwWZjX9hELBDitHbq7rmJGM9DqyHMlk5UgvVg7TViFrSmSMyXCNzWMwETgaqPSLbgeWA0+IyFOq+kgr0lsMTPejGs0RkZVArYjkqmoFrpnSwoZ2LCtreSXFL78EgALC4SglJeWtyG56KSzM67ByFGe5eQySkV5HliOZrBzpJdPLUVTUPQm5ySzBADbzsTEmozVWY3CUqo6B1UOVvqGqu+H6GxzTyvReAx4SkWtwTYkKgFeB3wCT/N9XWnnsdVhTotY7YOhBqc6CMcZ0KFdjkOpcGGNM6jQWGEwXkZeApbgn+VNjK1R1UmsSU9UFIjIFeN8vOgv4EHhERE4Dvgcebs2xG1Jd7f5aYGCMMaYpIZvgzBiT4RoLDN7HDSXaAzepWU39DUTkUFV9uiUJquo9wD31Fu/dkmM0V6zGwOYxaLmHvrwfgBM2PynFOTHGmI4RDAasKZExJqM1Fhhcypr+Bbj+x2sJ+G1aFBh0pOpq15fZhittufLazt9W2xhjWsJqDIwxma6xwGAGcHgT+89ox7y0u3796th00wibb57qnBhjjEl3QetjYIzJcI3NY/DbjsxIMvTqBW+9Ve5H+Uh1bowxxqSzkI1KZIzJcMFUZ8AYY4xJB6Fg0AIDY0xGa3SCM5O5hhcOT3UWjDGmQ2WFAkSB2roo4WDC+TaNMabLajIwEJGngEeBF1S1OvlZMulg78H7pjoLxhjTobLDrhK9JlJHOBhKcW6MMabjNacp0Q3AaOAdEblfRPZIcp6MMcaYDhcLDKpr61KcE2OMSY0mAwNVna6qF6rqaOAu4G8iMl9ELhWR/ORn0aTCvZ/fxb2f35XqbBhjOiER2aSRdQd2ZF5aIicWGEQsMDDGZKYmAwMRyRORo0RkKnAbMBlXg/A98EyS82dSpKaulpq62lRnwxjTOd0Z/8ZfP2LO7eC8NFt2yAIDY0xma07n489xk5j9RVW/iFv+kIjslJxsGWOM6cTq99wtbGTdWkTkJmAHIAqcraofxq07BTgJiACfAWeqarsNI7S6j0GtjUxkjMlMzeljsC3wbiwoEJFjY02IVPXUZGbOGGNMp9TYnXXCdSKyGzBcVXfEBQC3xq3LA44CdlHVMcAmwI7tk10nJ+w6HFuNgTEmUzUnMJgEDIl7nws8lpzsGGOM6YKa+wh+T3wTVVWdCfQSkR7+fbmq7qmqNT5I6An81J6ZzLY+BsaYDNecpkSFqnpL7I2q/kNEjk5inkwa2LT3ZqnOgjGm89pFRJb41wGgp38fAHo0sl8/4OO490v9stLYAhG5CDgbuFlV57Znpq2PgTEm0zUnMCgVkYnAe7gahj2AFUnNlUm53QftmeosGGM6KVXNaqdDrdMfQVX/LiK3AC+JyLuq+l78+oKCHMLh1s1B0G2lm6onu1s2hYV5rTpGOgiFgp06/zFdpRzQdcpi5UgvyShHcwKDCcD5wF9xHb7+BxzbrrkwxhjTZYhIGNhXVV/w7/cCjgbmAjeqakWCXRfiaghi1gcW+WP0BjZX1bdVtUJEXgbG4B5arVZWVtXqfGf52Y6XraigpKS81cdJtcLCvE6d/5iuUg7oOmWxcqSX1pajqKh7wnXNmcdgBXANcAYwETdc6VMtzoXpVO789Dbu/PS2VGfDGNM53QPsDyAiG+GuG2/h+hrc0ch+rwGH+f22BRaq6kq/Lgs3Gl6Bfz8K0PbMdKwpUY01JTLGZKgmawxE5C/ACUAf3NwFG+JO+sYYY0xDRqjqDv71eOBJVX0EQESmJdpJVaeLyMciMh2oA84UkROAFao6VUSuAKaJSC1uuNLn2jPT1vnYGJPpmtOUaD9VHSoi01R1d/8U5/BkZ8wYY0ynFd9UaG/guubuqKoX1Vv0Wdy6h4CH2pKxxuTYPAbGmAzXnMAgKiIBICwiuao6w3f8MsYYYxpSLiK/wU1stjHwbwAR2ZQmJjhLpViNQZXVGBhjMlRzAoMpwDnAo8BnIrIYWJXUXBljjOnMTgWuxM01ME5VK0WkG/AsrmlRWrI+BsaYTNecwGCaqn4CICIvAX2BT5OaK5NyWxVtneosGGM6ryv931LgdBE53b//L/A74MSU5KoJsaZE1bUWGBhjMlNzAoMbRORXqlqrqj8APyQ7Uyb1xgzYJdVZMMZ0XlvgmhG9CrxEJ6llzrIJzowxGa45gUE5MEtEPgOqYwtV9Yik5cqkXHXET/QTyk5xTowxnY2qjvTDlB4FXAbMxzVLfT5u+NG0EwwGCAcDVEes87ExJjM1JzBo9mgSpuu47ws3Iu3vtj4rxTkxxnRGqjoHuAq4SkRG4IKE60RkhqoelNrcJZYdClofA2NMxmpOYDAWNylNfW+1b1aMMcZ0JX5Eu91xHY53x01g9q+UZqoJ2eGg9TEwxmSs5gQGP8e9zsJNQb8gOdkxxhjT2YnIKOBo3BwGH+CCgTNUtSalGWuG7FDA+hgYYzJWk4GBqtafvv5mEXk+SfkxxhjT+b0PzMEFBUHgSOAIEQFAVdNyVCJwHZCtj4ExJlM1GRiIyGb1FvXHTUWolrgAACAASURBVFhjjDHGNGRIqjPQWtlh62NgjMlczWlKFF9jEAVWAH9ITnZMuth+vVGpzoIxppNS1e9TnYfWyg5ZHwNjTOZqTlOi3UVkkJ/DABHZRFW/SX7WTCqN6j861VkwxpgOZ30MjDGZLNjUBiJyDXBF3KLzReTa5GXJpIOymjLKaspSnQ1jjOlQ1sfAGJPJmtOUaCdVXT0NrqqeLCJvtyVREckFvgSuBN4A/gmEgEXAsapa1Zbjm7Z75KsHAZvHwBiTWbLDQcqqalOdDWOMSYkmawyAkJ+cBgARGQkE2pjun4Fl/vUVwB0++JgNpO1oFcYYY7q27FCQKutjYIzJUM2pMTgTuEtENgbqgK+BM1qboIhsAmwGvOgXjQVO96+fB84H7mrt8Y0xxpjWyg4FbFQiY0zGarLGQFU/AY5R1X6quj4wUVW/bEOaNwDnxr3Pj2s6tAQ3HKoxxhjT4bLD1sfAGJO5mjOPwTXAesAJftH5IrJMVS9oaWIichzwX1X9LjbRTT0JmygVFOQQDodamiQAoVCQwsK8Vu2bTjqyHLm5WQBJSc++j/Ri5UgvXaUcnVVWyOYxMMZkro7ufHwAMFREDgQGAlVAmYjkqmoFMABY2NCOZWWt749cWJhHSUl5q/dPFx1Zjm16uXkMkpGefR/pxcqRXlpbjqKi7knITeaxeQyMMZmsOYFBSERGqOpX0LbOx6p6ZOy1iFwGzAN2An4DTPJ/X2nNsU372rp421RnwRhjOlyWzWNgjMlgzQkMfofrfCy4zsdfsaazcHu4FHhERE4Dvgcebsdjm1YqqVwOQGG3XinOiTHGdJycsKsxiEajBAJtHYDPmP9v787jo6rOP45/ZskkmewhCZuggnDYrEjdqD8LLlistu6K4lawIIpSqi22hbrvoggogiCCItIqdaloUVRcsMpqVeAgLiA7BLOShCzz+2MGyDJhSUjuTPJ9v168mLnn3jvPkzuZk2fOufeKRJeDufPxCuCXe54bYzoAlxMsEOrMWntnpaf96rMvOfxeXP0CoPsYiEjzkhofQ3kA8orLSAmdayUi0lwczIgBxpjWBIuBAUA6+lZfRESaoJZJsQBsKyhRYSAizU6thYExJh24BLgSOAZ4BUi11nZupNhEREQaVVZiqDDI302nTIeDERFpZPu7j8EW4A/AQ0B7a+0IoKhRohIREXFAVmjEYGs9roQnIhKt9lcYXAusBZ4FnjbGnNE4IYmIiDijRYIPtwu25aswEJHmp9apRNba2cBsY0wacCnwd6CLMeYRYLq1dmUjxSgO6HPE6U6HICLNkDHmceAUIACMsNYurtR2OvAAUA5Y4Hpr7WG9tqjX7SIjwafCQESapf2NGABgrf3JWjvFWtuX4LkGW4GZDR2YOKt7Rg+6Z/RwOgwRaUaMMX2ATtba3sBgYHy1VaYAl1hrTwWSgP4NEUdWUizbNJVIRJqhAxYGlVlrN1prH7XWntBQAUlk2LZrG9t2bXM6DBFpXs4EXgWw1q4C0owxyZXaf26t3RB6vB1o0RBBZCXGsi1/d0PsWkQkoh1SYSDNx8tr5vDymjlOhyEizUsrgn/w77E9tAwAa20e7L2E9tnAvIYIIisplq2aSiQizdBB3cdARETEATVuPWyMyQLeAG601mZXb09MjMXr9dTpxTweN6mpflqn+dlVWk58Yhyx3uj7/mxPHtGuqeQBTScX5RFZGiIPFQYiIhIpNlFphABoA2ze8yQ0regt4G/W2vnhdlBQj3MDUlP95OTswlMRPJ9587Z8Uv3Rd5OzPXlEu6aSBzSdXJRHZKlrHpmZSbW2Rd9XISIi0lTNJ3hjTYwxvYBN1tr8Su1jgcettW83ZBAJscERh4LdZQ35MiIiEUcjBiIiEhGstYuMMUuNMYuACuAmY8x1QC7wH+AaoJMx5vrQJi9aa6cc7jgSfMGusXB3+eHetYhIRFNhIGGd1f5sp0MQkWbIWnt7tUVfVHoc2xgxJPiCIwaFGjEQkWZGhYGE1TndOB2CiIgjEmJDIwYlGjEQkeZF5xhIWBvzN7Axf8OBVxQRaWL2jRioMBCR5kWFgYT12rf/4rVv/+V0GCIijS4xVBjs0lQiEWlmVBiIiIhUsncqkUYMRKSZUWEgIiJSSZzXjdsFBSoMRKSZUWEgIiJSicvlwu/zUFiiqUQi0ryoMBAREakmwefVVCIRaXZ0uVIJ65yjz3U6BBERxyT4PCoMRKTZUWEgYR2d0sHpEEREHJPg82oqkYg0O5pKJGF9n/sd3+d+53QYIiKOSIjViIGIND8qDCSst75/k7e+f9PpMEREHJHo81Co+xiISDOjwkBERKQanXwsIs2RCgMREZFqEmI95BeXkV242+lQREQajQoDERGRatqmxFFcVsGl05dQVhFwOhwRkUahwkBERKSaS3u24ZZfHk1+SRlb8oqdDkdEpFHocqUS1vkdL3Q6BBERx7hcLn7WJhmAdT8VcURqvMMRiYg0PI0YSFhtk46gbdIRTochIuKY9mnBYmD9T0UORyIi0jhUGEhYa3Za1uy0TochIuKY1PgYkmK9rN+5y+lQREQaRaNPJTLGPAycFnrtB4DFwPOAB9gMXG2tLWnsuKSqd9fPB6BzunE4EhERZ7hcLtqnxbNOIwYi0kw06oiBMeZ0oIe1tjfQHxgH3A08aa09DVgLDGrMmERERGpzZHq8phKJSLPR2FOJPgQuDT3OARKAvsDroWVvAGc1ckwiIiJhHZXuZ2t+CQUluguyiDR9jTqVyFpbDhSGng4G5gG/qjR1aBvQOty2iYmxeL2eOr2ux+MmNdVfp20jSWPmER8fA9Agr6fjEVmUR2RpKnk0FZ2zEgFYs72AXkekOhyNiEjDcuRypcaY8wkWBmcD31RqctW2TUFB3U87SE31k5MT/SePNWYeRUWlAA3yejoekSWS85gw4XGsXcXOndkUFxfTpk1bkpNTuP/+R2qsWz2PefPeICEhkT59Tg+77yeeGMullw6gTZu29Y7zlVfmkJOTw+DBQ8O2r137DT6fj/btjzzgvup6PDIzkw55GzmwLqHCYPVWFQYi0vQ5cfLxr4C/Af2ttbnGmAJjTLy1tghoC2xq7Jikpks6X+50CCLcfPNIIPhH/nfffcvw4X846G1//evf7Ld9xIhb6xXboVi48D26dOl2UIWBRJYWCT6yEn2s3lrgdCgiIg2uUQsDY0wK8AhwlrV2Z2jxu8DFwAuh/99uzJgkvCx/ltMhiNRq2bIlvPTSC+zatYvhw0eyfPlSPv74fXbvLqN371MZNGgI06ZNJjU1laOP7sjcuf/A5XKzbt339O17JoMGDWH48CH88Y9/5v33F1BYWMD69evYuHEDt9xyK717n8oLLzzHu+/Op02btpSVlTFgwEB69TphbwxLlnzO+PFjSU9vQYsWGXvXu+++O9m+fRtFRUUMGjSEVq1a89prc1m48D3S0tLYsOFHXn55Dh6Pm6OO6sioUX9z8CcpB8NkJaowEJFmobFHDC4HMoB/GLP3MpjXAlONMUOBdcCMRo5Jwvh6x1cAdM/o4XAkIuF9++1aZs+ei8/nY/nypcyc+QJ5ecVcdtn5XH75lVXWXbnya1588RUqKiq49NLfMGjQkCrt27Zt5dFHx/Pf/y7itddeoXv3Hsyd+09mz36FwsJCBgy4iAEDBlbZZvLkiYwZcw+dOnXmtttuoU2btuTn53HSSadwzjnnsXHjBsaMuZ1nn32Bk0/uTd++Z9KtWw+++WYNY8dOICkpiZtu+j3ffruWjh2PafCfl9SdyUrk4+92srusAp9Xt/8RkaarsU8+ngJMCdPUrzHjkANbuOF9QIWB7DNnjpfZs2MO6z6vuKKUyy+v29VejjmmEz6fD4C4uDiuu+5aAgHIyckhLy+vyrrGdCEuLq7Wff3sZz0ByMrKoqCggA0bfqRDh47ExsYRGxtH167da2yzefNmOnXqDEDPnr0oKSkhKSmZVau+5vXX5+JyucnLy62xXXJyMn/5S3Aa07p135Obm1On/JsqY8zjwClAABhhrV1cqS0OmAx0t9aeUMsuDrsjUuMJAFvyS/beDVlEpCly5ORjEZH6iokJFilbtmxmzpxZzJ07l927XVx99WU11vV49n9Fs8rtgUCAQADc7n3fDLvCXBahcnsgEADgnXfeJi8vjyefnEpeXh7XX391lW1KS0t57LGHee65F2nRIoM///ngz5loDowxfYBO1trexpiuwLNA70qrPAKsAGpWag2odUosAJtyi1QYiEiTpsJARA7K5ZeX1fnb/YaUk5NDWloafn8CX365jC1btlBaWlqvfbZu3ZrvvvuWsrIy8vPzWb16VY11MjIyWb/+B9q1O5Lly5fSvfux5OTk0Lp1G9xuNwsXvrc3DpfLRXl5Obt2FeLxeGjRIoOtW7ewevUqysoi72fqoDOBVwGstauMMWnGmGRr7Z4hoL8CLYCBte2gIbRJDo42bcqr+9XxRESigSZLikhU69SpM/Hxfq66aiALFszn/PMvYuzYh+q1z/T0FvTr15/f//4annjiUbp1615j1GHIkBsZPXoUo0aNJCurJQB9+57BokUfMWLEMOLj48nKymL69Gc47rjjGTfuEb75Zg0nnngy119/DdOnP8OVV17N+PGPqTjYpxWwvdLz7aFlAFhr8xs9IiAzMRav28Wm3GInXl5EpNG49gyBR7rt2/PrHGgkX6f9UDRmHk+tmADAjT1vPuz71vGILMojvHnz3qBfv/54PB6uuWYAjz02YW8B0JDqcR+DWu8DEy2MMVOAN621r4WefwwMstauqbTOUcDLtZ1jUFS0O1Cfm2GWl1eEbTvz8Q85tk0y4y7vWad9N6b95RFNmkoe0HRyUR6Rpa55xMR4au0vNJVIwrqyy1VOhyDiqOzsbIYMuZaYGB9nn92/UYoCYROVRgiANsDmQ9lBQ90Ms1Wij3XZhVFRRKvYjzxNJRflEVka4oaYKgwkrNS4NKdDEHHU1Vdfx9VXX+d0GM3NfOAuYLIxphewyanpQ9W1Tonjo2+znQ5DRKRB6RwDCWvFtmWs2LbM6TBEpBmx1i4ClhpjFgHjgZuMMdcZYy4EMMb8E3gp+NB8YIy5cj+7O6zapsSxc1cphbt1PoiINF0aMZCwFm36BICeWb0cjkREmhNr7e3VFn1Rqe3SRg5nr6PT/QD8sLOI7q1qH4YXEYlmGjEQERE5gKNaBAuD77MLHY5ERKThqDAQERE5gCNS4/G6XXyfXeR0KCIiDUaFgYhErKFDf1fj5mJPPz2R2bNfCLv+smVLGD36zwDcfvsfa7S/8socpk2bXOvrrV37DevXrwPgjjv+QknJ4blu/cSJ45g3741a21esWMZPP+08LK8lDcPrdtEuLZ4fdkb/lUxERGqjwkBEIla/fr/ivffeqbLsgw/e46yzzj7gtg8++Nghv97Che/x44/rAbjrrgeIjY075H3UxZtvvq7CIAp0aOHXVCIRadJ08rGEdU333zkdgghnnnk2w4YN5sYbbwFg9epVZGZmkpmZxeLFnzF16tPExMSQlJTE+PFPVNn23HPP5M03F7BkyeeMHz+W9PQWtGiRQZs2bSkrK+O+++5k+/ZtFBUVMWjQEFq1as1rr81l4cL3SEtL4+9//wszZ86hoCCfBx64m9LSUtxuN7ffPgaXy8V9991JmzZtWbv2Gzp3Ntx++5gqr/+f/8xj1qwZZGa2JDY2lg4dOlJYWMBdd42mqKiI4uJiRo78E4WFBXz00Qd8//133Hvvw7z66kLeeuttKioq6N37VAYNGtJoP2/Zv44tEnj/mx3kFJWSGh/jdDgiIoedRgwkrMSYRBJjEp0OQ5q5tLR02rRpy8qVXwHw3nvv0K9ffwDy8/O54457mThxCn5/Ap988knYfUyePJExY+5h3LinyM3NCW2bx0knncLEiVO4++4HmDZtMh07HsPJJ/dm6NDhdOvWY+/2U6c+zXnnnc/EiVO48MJLePbZKQBYu4qhQ29i6tSZfPrpJ+Tn77vcfiAQYPLkJ3niiUk89NBjbNz4IxC8adp5513AhAmTueGG4cyaNYMTTzyFY47pzF//+ndatQre2+upp6YyZcpzvPXWvyksLDjMP1Wpq9M6plMRgH9/vZU123RcRKTp0YiBhPX55s8AOKn1yQ5HIpEidtOLxG0KP7e/rorbXEVJm/1fir5fv/4sWPAO3br14JNPPmTSpGcBSE1N5aGH7qW8vJxNmzZy2mmnkpzcosb2mzdvplOnzgD07NmLkpISkpKSWbXqa15/fS4ul5u8vNxaX9/aVdxww3AAevU6geeemwpA27btaNEiA4CMjEwKCwtISgpexjI3Nxe/P4G0tHQAjj32OADS01swY8ZUZs9+ntLSUuLiak5ViouLZ/jwIXg8HnJycsjLyyMhQUV6JDBZibRPi+eJhd8BMH/YKaT5fQ5HJSJy+GjEQMJasvVzlmz93OkwROjT53QWLfqI1atX0q5de5KTkwF44IF7GDnyz0ycOIX/+79f1rq9273vYy4QCADwzjtvk5eXx5NPTuX++x89QASuvduVlpbhcgX35/F4qqy1Z509j91u197nFRUVAPzjHy+SkZHFpEnTuO226pfrhy1bNjNz5nOMHTuBiROn7B1BkMjgcrk4v8e+Y/LZuhwHoxEROfw0YiAiB6WkzZUH/Ha/Ifj9CXTs2ImZM6fvnUYEUFhYQMuWrcjPz2fZsqUce2z3sNtnZGSyfv0PtGt3JMuXL6V792PJycmhdes2uN1uFi58j9LSUiD4h195eXmV7bt27cayZUvo168/K1YspUuXrgeMOSUlhYKCAvLz84mPj+fLL7+gR4+fkZubQ8eOnQBYuPB9ysqCd9F1u92Ul5eTk5NDenoL/H4/1q5my5Yte2OTyHD1iUdw0XGtuXDaYj79YSf9u2Y5HZKIyGGjEQMRiXj9+vVn8eLPqowMXHTRpQwbNpiHH76PgQOvYerUZ8jO3lFj2yFDbmT06FGMGjWSrKyWAPTtewaLFn3EiBHDiI+PJysri+nTn+G4445n3LhHWLJk32jZ9dffwNtvz+OWW25g3rx/M3jw0APG63a7GTRoCMOHD2H06D/ToUNHAPr3P5c5c2YxcuRNdO/eg+zsbN5883V69uzF6NGj8Pl8+P1+hg0bxIIF8zn//IsYO/ah+v745DByuVwkxno5+chU/vvDT1RUGikSEYl2rkCUfKht355f50BTU/3k5ET/tacbM4+nVkwA4MaeNx/2fet4RBblEVnqmkdmZpLrwGs1fY3VV8xbuZU73rK8cFUvTMvIOgekuf8uRKKmkovyiCwN0V9oxEBEROQQnXxkGgCLftD9J0Sk6VBhIGFdf+xQrj/2wFMmRESaoxYJPrpkJfLpDz85HUq9lZZX8Nm66M9DROpPhYGE5fP48Hl0GT4RkdqcclQa/9uYS+HuMqdDqZc3vtrC8Je/5Ied0T+1QkTqR4WBhPXJxo/4ZONHTochIhKxTmiXSnkA/rcpz+lQ6mXZhuB9PDbkFBEIBHhhyQaunLmUHQUlDkcmIo1NhYGE9cX2FXyxfYXTYYiIRKyftU3G43ax9Mfab5AXDfYUNptyi1m4NpsnFn7HN9sLee2rLQ5HJiKNTYWBiIhIHcTHeOjWMollUVwYbM0vYXNecGRgY24xKzbm4fO46HVECq99uYXS8gqHIxSRxqTCQEQi1ubNm+jX75cMHz6Em28eytChv+OLLw59JOvjjxfqRmHSIH7eLoWVW/PJLYrO99dXm4OjBV63i025xdjtBRyTmcgVvdqyOa+Ea2ctp6i0/AB7EZGmQoWBiES09u2PZOLEKUyYMJlhw25mxoyph7yPl16apcJAGsSZnTMorwjwjt3udCh18n128ITj49omBwuDrQWYrAT6dsrgL/068c32wr3Fg4g0fV6nAxAROVg7d+4kIyMTgB07tvPAA/dQVlaK2+3m/vvvIz4+lXHjHmH16lWUl5dz4YWX4Ha7WbnyK2677RaeeGISMTExABQWFnDXXaMpKiqiuLiYkSP/RLduPVi8+L9MnvwUbrebs846m8suuzLssksu+Q0zZ87B7/czceK4vXc3/u9/F7Fjx3buuut+XnrpBVau/Jrdu3dzwQUX85vfXMCWLZu59947qKiooFWr1owYcStDhw5i9uxXcLlc/Pvfb7B8+RfcfPMfHfs5y8EzWYl0zPDz0IK1zP3fZp69oidxMR6nwzpoP+YUkZXo4+h0Py9/sRmALlnBG7b9skM6DwDf7djFie3THIxSRBqLRgwkrBt73twgdz0WOVTr169j+PAhDBlyHRMnPs4VV1wNwDPPTGLAgIE88cQkLrvsCp5++mny8nJZtOhjnn76WSZNmkZZWRn9+59LenoLHn10/N6iACA7O5vzzruACRMmc8MNw5k1awaBQICxYx/ikUeeYNKkaSxZ8jklJcVhl9Vm69YtPPnkMyQnp9CqVRsmTZrGU089w9SpTwMwZcpTDBgwkKeemkpGRgYbNmzgmGOO4auv/gfA+++/R79+/RvwJyqHk8vl4opebUnwefhmeyFvrdoGwKc/7OS6Wct5/INvqQjU+WbMDW79T0W0T/fTJiVu7zLTMgkI3qshJc7Lt9mFToUnIo1MIwYictCeWjGhxrLjMntyatvT2F2+m6lfTq7RfkLLkzip9ckUlBYw8+vpVdoOpvjcM5UIYN26HxgzZhTPPjuLr776H+vXr2PGjGlUVFSQmZlBcnIK7dodye23/5HTTz+L/v3PrXW/6ektmDFjKrNnP09paSlxcXHk5PyEz+cjLS347ejDD4/jp5921li2P127dsPlchEbG0teXi433DAIr9dLTk7wBlJr1qxmxIhbg/nfOAKA/v3PZcGC+XTp0o0NGzbSpUu3A/5cJHKcf2xrftujFQOfX8bsZRs5q3MmEz78nvU/FfH1lnx6tk3h9E4ZTocZ1o8/FXFm50xOaJ9Ku9Q4zunakm4tgyMGLpeLDi38fLdD9zcQaS5UGEhY769fAMDp7c90OBKRfY488ihiY2PZtm0rXm8M99zzEBkZwT+4UlP95OTsYuzY8Vi7mnfeeZu3336Txx9/Muy+/vGPF8nIyGLMmHtYvXolEyeOw+12U1FR9dvdcMsg+EfTHmVl+25w5fUGRyWWL1/KsmVLmDhxCl6vl379Tqt1f6eccirPPPM0S5cupk+fPnX4yYjTXC4X1/c+kr++sZLfPPMZhbvL+Wu/Tsz4/EemfrqOtilxZCT6SI714vVExmB9TlEpucVltEuLp2vLJOYOPqnGOh0yEpi/ejuBQKDKe15EmqaIKQyMMY8DpwABYIS1drHDITVrq3auBFQYSFX7+4bf5/Httz0xJrHe09Py8nLJzs4mMzOLbt168NFHH3DhhZewdOliiovz6dChCx9//CGXXjoAY7owaNBVALhcbsrLq15ZJTc3h44dOwGwcOH7lJWVkZKSSkVFOdu3byMjI5NRo0YyZsw9YZf5/QlkZ+8gNrYtX3/9JZ07mxr7z8pqidfr5eOPF1JeXkFpaSldunRj2bLFnHnm2Uyd+jTHHXc8J554Mj17Hs+0aU8zduzYev2MxDlndMpg+sDjmbVkAwUl5ZzbrSUJPg9j5q1m4PPL9q4XH+MmKdZLclwMKfFeUuNjSDnA48RYL+7D+If5e9/sYNTrwc/59mnxta7XoYWf/JIyVm4twOt2YULnH4hI0xQRhYExpg/QyVrb2xjTFXgW6O1wWCISAfacYwCwe/duRo78EzExMQwePIT777+Ld9/9Dy6XiwcffJDY2CS++uoLFiyYT0xMDOee+1sAjj++FzfeOJgJE6aQmpoKBKfv3HvvHbz//rtcfPFlvPvufN5883VuvfV2Ro8eBcAZZ5xFUlJS2GUXX3wZo0aNpH37Izn66A414j7hhJOZNWsGw4cP4bTT+vCLX/wfjz76AIMHD+X+++/mX/96mZYtW/K73/0+tN+zWbnya9q3P5KcHE3diFZdWyZx77ld9z4/u0sWPdumsHxDLrnFZeSXlJJXXEZ+cRl5xWXkFpfy3Y5d5BSVkldcSnktpyN4XJAQ6yXG4yYr0UeMx43H7cLjAo/bhdvlCj13ERfrpaK8AnflNpcLV+i51+3i7dC5EBD84782fY7JYOqn67lu1nIABp3cjn5dskKFjZc4r1sjCSJNiCsQASdFGWPuBtZba6eGnq8GTrLW7r1G2vbt+XUOdM8Ug2jXmHnsmUveECcg63hEFuURGaZNm0yrVq0ZOHBAnfLIzEzSX2dEd19REQhQWFIemuJTSm5RWaXHpRSUlFNSVsG2ghLKKwKUBwJUVAQoqwhuu2cZLhe7S8v3tpcHIBAI/l9REWB3eQUJPg/jLuqB1+3m6P0UBgB2WwEzP/+R3eUVfLA2u0qb1+0iOS44ouECXC5wESxCKj8GQu2uvesBuEMFiyu0xp7HLhd4vR7Kyysq7Tf4wMW+dSrvb3+v5XW76Zjhx+/z4HK5cO+NIbiNu9r+3aH9sTe2utkTj98fy65dJYe2bT1euaFqtQR/LIUHyKM+r12vnA9hXX+Cj12Fu/dt69CnZ32K6uOPSOGYtqmHvb+IiBEDoBWwtNLz7aFlewuDxMRYvN66XQLO43GTmrr/D75o0Jh5/LXvqAbbt45HZFEezhs27Abi4uL4wx9uieo8Dof9TSs1xpwF3A+UA/Ostfc4E2XDcLtcJMV5SYrz0o7ap/ccyOEucExWIved15WKQIAvNuaRXbibvJJ9ox75JaUUlpQTPHUmQAAIBNh7NaZAgNCyYNu+ZYHg/5UfE/xHIIDH7aKiPLSsIlBlH4HQa1VU2vf+Xqu4rJx310TnvSZEwrng2FY8clnPw77fSCkMqqtRyRQUHFqlXZnT3wIdLsojsiiPyBLNeTzwwGMA5OeXkJrqnalxtwAACuFJREFUqes3QIc7rEZ3ENNKxwO/AjYCC40xr1hrVzoQarPkdrk4/oiURnu9w/07XVRaTml5RdVihGrFRLXCoj6TKvaVJpCcHE9eXtHBb+vgZI79vXZychx5ebVfrrk+YddnBsuhbpmcFEdefnHdNq7H61bdth75BvZ/blB9REphsIngCMEebYDNDsUiIiLOOBN4FcBau8oYk2aMSbbW5hljOgA7rbU/Ahhj5oXWV2EgByU+xkO8QzefS031k9MEJvulpvrJ8UR/IqmpfnJiIuPqYJEmUgqD+cBdwGRjTC9gk7U23+GYRESkce1vWmmr0PM9tgEdq+8g5YJf19hpyW8vpHjQ72HXLlKuvKRGe/GAgZQMGAg7dpBySZj26wZTcsHFuDduIOmmITXai4bdzO5fnYNn7Tck3jaiRvuukX+itM/peL78H4ljbq/RXvjXOyg76WS8n39Gwv131WgvuOdByo/9GTEL38f/+CM12x99gvJjOuH7z1vET5qAx+smpaxib3v+k1OoaHsEsa++Qtxz02psnzfteQItWhD70iziXppVoz33xZfB7yfu2WeIff1fNdtfnQdA/JPj8b3zdtXGuDhyX5oLgH/sQ8R8tLBKcyAtnbzpLwCQcO+deJd8vrfN43WTlNmK/ElTg+2jR+H96ssq25d3PIaCseMBSLz1Fjzfrq3SXtbjWArvfQiApGHX4968qWr7CSdROPpOAJJ/dxWun3ZWaS89rQ+7bg1OrU0ZcBEUV/22fHe//hTddEuw/UDvvTDte957ruxskgdfXbM9wt571d9b1d971UXqe8/jdZOclFrrew+gonWbiH/v8bfgMT3kz71PPqqx/h4RURhYaxcZY5YaYxYBFcBNTsckIiKO299Xk2HbPB53jRMJPX4fcal+8AX/IKjO7/cRn+rH81MxhG2PJT7VD/nxYbdPSPDhT/VDUlzY9sTEWAL7aU9KCra7kmJxh22Pg1Q/rsQDtCf4cIeuEuSttF5ycnyw3R9++5SUPe2+sO2pqX7w+3H7fbhqawfc8TE122M8+9rjDtAe663S7nK58Pm8ldprbu/1efGG2j0+b43j54mNIWa/7d597TGemu1xMfgqt5dVa4+PIXZPe5ifzZ73nqektvdW8L1H2a5a3puR9d6r/t6q/t6rLlLfey6Xi5j9vPcAiIL3nit0Ttr+3nu1fe7VJiKuSnQwovlKE4eL8ogsyiOyNPc8msJViYwxdwKbrbWTQ8+/A46z1uYbY44CZltre4fa7gCyrbUTK+9DfYXyiERNJRflEVkaor/QBCsREYkU84FLAKpPK7XW/gAkG2OOMsZ4gfNC64uIyGESEVOJREREwk0rNcZcB+Raa/8FDANmh1afY61d41CoIiJNkgoDERGJGNba6mdIflGp7UOqXr5UREQOI00lEhERERGR6Dn5WEREREREGo5GDERERERERIWBiIiIiIioMBAREREREZr4VYmMMY8DpwABYIS1drHDIR00Y0xf4J/A16FFXwIPA88DHmAzcLW1tsSRAA/AGNMDeA143Fo70RjTjjCxG2MGAn8geGnCKdbamvdMd1CYPJ4Dfg5kh1Z5xFr7ZhTk8TBwGsHf+QeAxUTn8aiex2+JsuNhjPEDzwEtgTjgHoJX3om649GURGt/Ee19Bai/iMA81F9ECCf6iyY7YmCM6QN0Ct0lczAw3uGQ6mKhtbZv6N/NwN3Ak9ba04C1wCBnwwvPGJMATAAWVFpcI/bQen8HzgL6AiONMemNHG6taskD4C+VjsubUZDH6UCP0O9Cf2Ac0Xk8wuUBUXY8gN8AS6y1fYDLgMeIwuPRlDSB/iIq+wpQf0Hk5aH+IoLywIH+oskWBsCZwKsA1tpVQJoxJtnZkOqtL/B66PEbBN8AkagE+DWwqdKyvtSM/WRgsbU211pbBHwCnNqIcR5IuDzCifQ8PgQuDT3OARKIzuMRLg9PmPUiOg9r7Rxr7cOhp+2ADUTn8WhKmlp/0Zfo6CtA/UWk5aH+IoLycKK/aMpTiVoBSys93x5aludMOHXSzRjzOpAO3AUkVBoO3ga0diyy/bDWlgFlxpjKi8PF3orgcaHa8ohQSx4Aw40xfyQY73AiP49yoDD0dDAwD/hVFB6PcHmUE2XHY4/Q3X2PAM4D3o2249HERHt/EZV9Bai/IPLyUH8RQXns0Zj9RVMeMajO5XQAh+gbgh/w5wPXAtOoWshFWz6V1RZ7NOT0PHC7tfYMYAVwZ5h1IjIPY8z5BD8gh1driqrjUS2PqD0e1tpfEJzz+gJVY4yq49FERdPPuin3FRDdvw9R+/mk/iKyNGZ/0ZQLg00EK6g92hA8SSMqWGs3hoaQAtbab4EtBIe340OrtOXAQ5aRpCBM7NWPUcTnZK1dYK1dEXr6OnAsUZCHMeZXwN+Ac6y1uUTp8aieRzQeD2PMz0MnVxKK3QvkR+PxaEKitr9ogn0FROnnU3XR+PkE6i+IoDyc6C+acmEwH7gEwBjTC9hkrc13NqSDZ4wZaIy5LfS4FcEz0qcDF4dWuRh426Hw6uJdasb+GXCiMSbVGJNIcD7cRw7Fd1CMMa8YYzqEnvYFviLC8zDGpACPAOdZa3eGFkfd8QiXRzQeD+CXwK0AxpiWQCJReDyamKjtL5pgXwFN5PchGj+f1F9EVh440F+4AoFAfYOOWMaYBwn+UCuAm6y1Xzgc0kEzxiQBLwKpgI/gUPFyYCbBS1atA35nrS11LMhaGGN+DowFjgJKgY3AQIKX3KoSuzHmEuBPBC8ROMFaO8uJmMOpJY8JwO3ALqCAYB7bIjyPIQSHTNdUWnwtMJXoOh7h8phOcIg4mo5HPMHpHu2AeIK/20sI87sdyXk0NdHaX0RzXwHqL4i8PNRfRFYejd5fNOnCQEREREREDk5TnkokIiIiIiIHSYWBiIiIiIioMBARERERERUGIiIiIiKCCgMREREREaHq3RFFmhVjzFHAl8DSak0XVbp+c132eyeww1o7se7RiYhIJFBfIc2JCgNp7qy1tq/TQYiISERTXyHNggoDkWqMMc8RvPlJFyCD4M1DlhtjRgADQqu9aq19yBhzJDAD8BC80ci1ofYexph/A52AEdbat40x44ETQutOstY+11g5iYjI4aW+QpoinWMgEp7XWnsWMAb4uzHmaOA64LTQv8uNMR2B+4DHrLWnAZsIfpgDZFhrzwNuAW4wxqQD51prfwH8HxDTqNmIiEhDUF8hTYpGDKS5M8aYDyo9t6H/3w39/ynwEHA88F9rbVloo0+A44BewAgAa+2fQ23nAB+Htt8IpFhrdxpj1hhjXgP+SfB25iIiEh3UV0izoMJAmrsa80ZDw8N7RtNcQCD0z1VpNR9QAZQTfuStrNJjV+iFzjHG9AKuBK4Bzq5/+CIi0gjUV0izoMJAJLzTgH8AvYGVwHLgTmPMnt+Zk4H7gcXAGcAcY8zdwIfhdha6qsVvrbXjgWXGmOpXtxARkeijvkKaFBUG0txVHx4G2AWUhk4IawdcZa39wRgzBVhI8FufqdbadcaYO4DpxpgbgfXAXQTnhVa3CfiFMWYAUAI82zDpiIhIA1BfIc2CKxAIOB2DSEQJDQ+/bK39t9OxiIhIZFJfIU2RrkokIiIiIiIaMRAREREREY0YiIiIiIgIKgxERERERAQVBiIiIiIiggoDERERERFBhYGIiIiIiKDCQEREREREgP8Hm6gVlMnLcjAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# train the neural network with different learning rates and show accuracy on test data\n", + "learning_rates = [0.1, 1, 10]\n", + "for lr in learning_rates:\n", + " mnist_model.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=lr,\n", + " batch_size = 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Batch Gradient Descent" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAEgCAYAAAADshSRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XeYVNX5wPHvnZntCywdFBRQfBFRsQCJ2EVjb7GCsaCxRCzBGv0ZwZbYUNSIxooiiiIodgVFRYKC2BB8ERGUIk122V5m5vfHuQOzfYFddpd5P8/Dw86t59w7c+/px4tGoxhjjDHGGGMSQ6CxA2CMMcYYY4zZdiwDYIwxxhhjTAKxDIAxxhhjjDEJxDIAxhhjjDHGJBDLABhjjDHGGJNALANgjDHGGGNMAgk1dgCMMY6IRIGuqrosbtn5wDmqOkhEhgEdVfWWKvZdBFykqtMrLD8QGKeq3eopjM8Ci1T1jvo43laE40hgJNAG9xxbAlypqvNruk71cN6RwJm4wpOvgEtUNVtEkoFHgYOBMDBGVR/azGN3w13bbf5cru9rJiJLAA8o9BeFgK+BYar6Wy37ih+WT7YyDH8BxgCXquq4rThOH2AGcK+q3rk1YWpqROQfwHlAFFgA/E1VfxORVsDjQF/cd31CNc+dEcAwYG3c4n+o6uQK2/UHnvU/XqCqn/vLs4APgUNUNbceo2aMqYVlAIxpJlT1kcYOQ1PgJxpeAQ5X1bn+sr8Dr4pI74a6TiJyNnAksA9QDLwM3ARcDwzHZUZ6AZnA1yIyU1XnNERY6lsDXbMhqjoDQESCwIPA/cCQWvY7Bfdu2uIMgIjcCBwA6JYeI875wC3ApcB2kwHwM9FDgf1VNUdE/g3cB5wD3AOsVNWz/N/bXBH5n6q+XcWhHlHVEbWc7lb/XAD/BI7z/74DuNsS/8Zse5YBMKaZ8EvbuqjqRSKyH/AckAS8VWG7/wMuwZXKTYlbngLcCxwNJAP/VdW7/HVLgH8BFwJdgfGqes1mhu8i4Brcc2Ul8BdgA7Ac6K6qq/zt7vO3+TsuYTUESAVeA4aralhEpgOfAacCF6rqzLhT9cSVWH4Tt+wh4CVVjcauE3Ab8H7cNh2Aj1T1zyLSBVc6LP66q1T1HT9804DrYpmLOPOBy1S10N9uOi5DAHA6cLOqRoANIjLRX1YvGQA/EfYwMAB37W5X1Wf8dSfiEqbJQB7uen0tIocCdwHLgFLgZuB/uPv8V1yGZbiqTqjw3ZqO+96cCnTHJcQH+9f2fODfwCrgAeAZVfVqC79/T98ERvlhDvjxGeSHewYugXg08A+gRERaq+o1InIxLoOV6od/qKoWisgpwAmqOrTyGfkIuNv/f4v5GZeTcSXhx4vIgLjS6zRcKflBQBFwp6qOq2H5s8TVnsV/9n9/T+N+C0cCacBTQFvcb/wWVX3R3+9oXEYqCVgInOuf73NVvc/fpo8f987+cV9R1TcqRG9PYI6q5vifP8Ql/AFeBb4F8Gu45uJ+K1VlAOqiJ67GLPY3IrIP0FNVh23hMY0xW8H6ABjTPI0BRqvqbsBMXEINEemNSyzt7//bK26f64HeuBf/HsBpInJ83PqDgT8C+wFX+InkOhGRDsAjwJGq2hNYhEu0rAem4prNxJwCvIQraTwD6A/s4v+7LG67/YA9KiT+Ab7HZSymi8hgEemsqmFVXRm/kar+oqq9VLUXcCCQy6YEzljga//6HQuME5G2/n5HVJH4R1W/UdVv/Pi2wiXwYxms3YCf4jb/CVcbUF/uByL+MQcAI0Wkj4iE/Lj8VVUFeB1XihuzD/CYqsZK3dsBEVXdE7gaVwJblRNwCdHdgMOBA0SkDa6Z0yD/uH+qa+D9RPFQ3HcV3HfgIKAPsDvuXp/pJ1In477b14jIQcDtuNqebkCO/xlVnVxN4h9V/VxV62Oa+6OBWaqaB4zDJbZjrgGSVbU77lo9IiI71LC8Nl1UVVT1F9w9fFNVd8ddt6dEJElEMoAXcNdqN9zv7HbgRWBw3LFOAV5V1TJVPbeKxD/AdNx97eJ/j04BPgBQ1fdjTbVEZDegH+Uz0/EGichMEVERud8vaKgogmsSFgTCIuLhaoTuEJEXReQNEdm3DtfIGFNPLANgTNMyXUR+iP3DldaWIyKpuBfyBH/RRCDf//tg4GNVXaWqYVyiJeYE4FFVLVbVfFwNwqlx68f7CekVuBLernUNtKquBlrG9V/4FOjh//0icLYf9r2AoKrO8sPztKrmqGoZ8GSF8Lztl6hXPFcBLqPyBa4fwAoR+VxEDqkhiM/g2uV/7ieiDsOVYKOqi/zwHlfD/huJyHhcDcci3DUESMeV9sYUAhl1OV4dnYBLFEdUdQ0wCTjVv24d/OsJ5a87QKGqfhj3OYS7FgBzgZ2qOd9EVS30vycL/e0GAAtVdZ5/X8bUEuYX/O/xj8DvwApcpgNVfRXX9KRUVYuA2RXCHR/vCf53EuAxyn9HGtp5bPoNTQZO8Pt7gMs4vgTgf++7+OGsbnlt3oz7+yRcbR242pFUXGn+QOBXVZ3nr7seV5P2NrCL338CXGJ+AjXwM7ljcf1n1uGeHRufNyIS9PsWfQXco6rfV3GYubjrchjuN9kfuKGK7b7CZfgOAb7E1TTOBI4B3sA1rxpVU3iNMfXLmgAZ07QcqlV0Aq6wTRv//w0AftOM7Lh1OXHbro/7Owt4QETu8j+n4BLRMfH7hXGldXXiN5W4zW+OEgRa4BKO4ErJnxCR7rjmFC/Hhedav4kHuOfRmrjD/l7d+fwE1TXANX7n2cuBt0WkUqZFRK7CNamIlf63wpVGztyUXiIT1wSiVqo62M+E3YNLHJ6Jy4Clxm2WjmuOUzEs04Ad/eNsTg1BFvCyiJT5n9Nw/SAArhSR83D3MxXXPCqm4jUM+4l6qPkeV/VdaF3heMtrCfMQVZ3hJ5gXAm/Ezi0i7YGH/VLfCNAJVyJcURZwiogc5X8O4JoMbTUR2RGY5n/8QlXPrbC+NXA8cFTc9yTdXzYJV5sS+93h1xJQw/LaxF/bPwH/51+nWOl5oIpjl8SFdzIwWESewmUWPq7pZP5v9Tigo3/um3Df52P9Y4eBXf0wvCYiYVV9LP4Yqjol7mOxiDwA3IhrfhfvVjZllq/G1SQdiLuOY1V1uYjsXFN4jTH1yzIAxjQ/sUR9SyDHb0/dJm5dq7ht28f9vQK4T1XjSxrry5nAicDBqrpWRP6K39lTVfNF5A1ck5nTgAviwjNFN7MDqt8kITPWTEdVlwDXichQKpQii0hf4Fqgf1xtwmpconb/zUicISKHA6tU9XtVLRKRJ3Al7gA/ALsCP/qfe+L6DJSjqkfU9XwVrABOjiv5jYXpAFyJa39VXeJ37HxiC89Rmw24jFJM57rspKolfh+D+0Rkf/8+3Inrl7CnqhaLyAvV7L4Cl0C8divCXV24llNzM62zgOdU9dLYAr/fwXm4hOtaXII8tq4LLiFd3fKKGa7WVZ1URJJwmbszVPVtv0lNbDSlisdOB9r4hQYv4mq1cnA1OJVqzyo4CnhXVdf5x5qAywTERlB6Q1WzVXWNiLyEaw5VLgMgIrsCq1V1g78ohLuv5ajqQuAP/j6PA3eoaoH/7CJuX2PMNmJNgIxpZtR1Qv0GV80PLqESK33+H3CgiLT3S+Xjaw9eBy7yq/Y9Efk/v0NhfegALPET/21xbfvjE4vjgb8B6ar6ZVx4/uInYhCRS/yS7NrsA0wUkY2JfRE5DijDDWUYW5aBSxRdGt8/wG828xau2QEiki4iT1dVe1DBgcCouDbOJ+B3lMTValzhX9vOuHtSYxOMzfR6XHhDIvKAX3reAZeh+cW/jucBGX4b6/r2JbCXiOzqJ9wu2ox9n8d9R//if+4AfOcn/vfGNW2JfV9KcSX/4HdG9kuhEZGTRKSqJiYN4Xxcx/R47wGH+t/xKcC5/m+pE66ZS7salq8E9gbwv7sHVnPeDP9frAP5VUAJ7vrMADqJSD9/3S24UXXA9bVpC1xJ3b57ChwR+/3hagNiGcwL8Jtr+RmSP7Hpux7vNuAuP66puMEH3qpiO/xj9cc1iZrkL5oP9PNrB2scHtYYU78sA2BM83QZcIOILMS1u50PoKpf40rp5uISbDPi9vkPsBTXifYHXOfL+PV1dVV8PwURuR+X0G7rtxl+Efg/oKu/DlzCqSXlEyav4dr/zvX7O5zob1cjVZ2AG4lmsriOhz/hEj1HxzVvAddWfBfg/riwxkrsLwMO8c87F1isqr+Ca6YjVXdIvAdYDHzrX/cj2JQIHo0rrVbc6Cu3xToMb6ZghWv7g584ugVoJSKKu39BXILsXf+8P+E6aT6IXwK8BeeukZ+JugkXv8/ZVPtRl33DuDjcIa5D8P3ApSKyANd86xpc5vR0/DbhIjLRr+W5C9c3ZgGug/vr4ErjReTpqs4nIu/597Y/cI9/HU+pattq9u+Fqx0o1yzM738yHden5QFc5mupv+xavwNvdcufALqJ6xPxL6q5R6qajfuufSUiX+Hu7Wu4PgIe8Gdcp/WFuE7+N/n7hXE1B0HcCFqxuDwnIidUcarHcJmMb/3v1alsqp27AOjvX8MFuD4Cd/vH+5eIxGpFrsaNuLUQN8/DN7h7W4mfaRyFy9DEPIi79+/jRqkyxmwjXjRaHwMlGGNMzUTke+B0Va3UNMY0DyLixUbXEZE9gBmqWmVTFrPticj1QDtVvb6xw2KMadqsBsAY0+BE5CzcxEKW+G+mxA0VuVxEBviLzsQ1OTNNgN9M6mIqtNM3xpiqWKcbY0yDEpEPcG2gT2vssJgtp6plInI5MNZvzrESN5yjaWQicgmuKdAdqrq4scNjjGn6rAmQMcYYY4wxCcSaABljjDHGGJNArAmQ2Swi8hluDPa9GzssW0P8CbZUddA2ONcwoKOq3tLQ5zLGGAARiQKvquppFZY/CVyoqg0xVGzFMARws3WfhhvBKAk3TOp1/nC8TYI/V8OvVV0TEVmCC3thhVX/UNXJDRim6cCTqjqutm3r4VzTcPdkbkOfyzQdlgEwdSYifXBDDP4uIn9UVesAWAebO9GVMcbUk71EpGVsoi5xszL3q2Wf+nQxbr6DfqqaJyItgHdwk/P9exuGY2sNUdUtGTK5WdiKCQpNM2YZALM5zsONM10EnEvcCCAici5u7HdwY4Rf5E/yU2k58Edcycau/r6Hxj6LmzF0R9yEOeOBh4CHgUFAMm7c+qGqWioi7YBngD2APNxLJQm4W1X7xIVtDq5zXMVJfWLrs/xzDMD9Jm5X1Wf8dSfiZi1N9s9xoap+7Yf5LmAZbuKim/3r8S/gr7iZeYer6gQ/Tl1U9SK/VGcKbszt7sAnwGBVjfq1Ev8GVuHGEn+mmhKpo3FjbSfhxt8+FzfG/iJVDfnbdIt99o97Im6G4C9xkzEdH5uQS0SuBv6gqmeJyMW4sdZT/fgM9SceM8Y0Px/hJgwc63/+EzAbN38A4CZXA+7ATT62CPc8WutPEPYM0Bf3/Hs1NiNzTc+xCuffE5gXm3FbVXP98xX4x+nnhy2Em//haNy8EFD9O6K2cH3mh+tC3Pwo1T3bhwK34ma4rm4m6lr5NS034SaO642bt+Fp3EzoR/qbPQF0w70r7lHV5/xn9Ezc3Cj7quohNZxjIG7OhNa42aAHq+piv4aluvfjs7gZqAcBt+Pek+3Y9H5dC5ykqiv9Wo5zcO+z6t5jqcBzuEn7vsfNn9JJVc+vEFYP9346xY/vE6p6b/x70N9u4+cK9+154GxV3TPumF8DNwKzqOZ+ms1nfQBMnYibVfZU4FXcRDzH+qVJscTmfcChgOBeJFdWt7wOpzsWOFZVH8Q9RA4C+uAmrtoPN/wguMTyfFXtgcucvIibDbOziOzlh20nYFdcqVN17gciuIl/BgAjRaSPP+zhWOCvqip+vO+L228f4DFVHeJ/bgdE/AfX1biXalVOwL0YdgMOBw4QkTbAo7iH9T64F3Ul4ma3fQE4U1V3w72wb68hbjFH4WbEvR6YjMsQxJwCvCwiB/nHOlxVu+Fqe+pybGNM0/QyMDju89m4Qhxg44zEsQRXD1yGITaM6GVAC9xzcV/gfBGJn7240nOsivO/A1wiIqNF5DARSVXVdXGFCmOA0f6zbDbuPVGb2sK1H7CHqs6k+md7a1zh0tH+83qHOpy3Jp6qij8ZG7iErfgTwP0XmO6/Q44DHvLfjeDeGV/Xkvhvgcsc3eRniEbj7ivU/H4EN1lhf1WN3fPTce+mXXCT1Q2t4pTVvccuwl2nnXGZgwuq2Bdcxqc/7nuxP26G9P7VxS/OfrhMyn1AF38CRPz/u+De7VXezzoc21TBMgCmrv4EzFbVDXGzYcZmlzwKmKmqK/wSoMG4Euzqltfmc1VdC6CqrwL7q2qpqhbhXhI9/O2OxSX6UdWvgG6qWoybYfNsf5uTgdf95dU5AfcSiqjqGmAScKrfRrWDqs7yt/s07twAhaoaP1NoCFcyBa50ZKdqzjdRVQv9WWsX+tsNABaq6jxVjeBejFUZiGurOs//fD3w9xriFrNQVX+MnR8/A+DXouwNvI27DhNUdYW/3WO4TJ8xpnmaDuwhIh38kvMDgGlx64/GJU5jz5PHgBNFJKiq9+NKiKOquh5X6hv//KvqOVaOqr6Je053wc1m/LuIPCsirf0S5f3YNDv4BFztco3qEK63/WcoVPNsxz1vf1TVBf52Y6nZC1XM0J0ct/7NCtu/CSAiSbhM0qN+2JfiMlmH+9sl4QpkanIQsExVP/CP8SKwq4jsVMv7EWCavzzmE1Vd6r+Pv6Lqd1R177GDcPe8zI/HW9WE91h/u1K/6dnufrhq87Z/n0pwGZ5YIdUpwGv++7i6+2m2gDUBMnV1Pq7UP9v/HMJVR76KKzGILSf2wPETl1Utr+1cv8f+8Ce3eVhE9sXl/DvhqkKp4ry5/p8vAs8C/8BlAOJL7auShSsBj3VKS2NTKdmVInIekIJrFhNfxf075YX9lyFAGAhWc76c+H387VpXON7yavatGOcS2LxrCnwM7OjXjgwC3lLVIr8p1CkicpS/XQBXrWyMaYZUNSwik4AzcCW+76mbzyG2SRZwsIj8ELdbDtBWRFoBo0SkF+451ZVNCcPYdjHVPu9UdSow1a9FHoh7Hj8KXBN/HL8Z5Nra4iQiPWsJV/yzrrpne5sK4V9fy2lr6wNQ8V0Q+9wWVztQ8Vwd/L/DfiK5JlnALhXuUTHQXkQKqf79WFW46nLPqnuPVfWO6lrF/hXfUfmw2e+oicBVuNqOk9lUE13Tu9psJssAmFr51aWHAm3iEpwhYJmfQF9LXPWviLTE/TCrW17xwdO6htPfiWtHuKe6PgXxbTXX4h42S/zjd8M9lD4BQiJyPK5q9INaorgCODmuFCwW3gOAG3BVqEtE5EhcW86GsAHIjPvcuZrtYnGOhTEd9zILAwER8fzSnWqvqZ8oeA1XmvIn4Cl/1QpgbKw9rTFmu/ASrr/SGvyS6DgrgKlaYaQgABEZh+szdLL/zPhsc08sIsfgaoFz/OYxn4jI7bg25rFEYksgx2/P3sZfVtM74j+bEa7qnu3H4PpExbTfzKjV1VogIiKt/doKcJmCVZtxjBXAAlXdv+IKEfkv1b8f69uWvqM64kZQ2pz3/nvAM35mbzcgVtNe5f00W8aaAJm6OAv4MJb4BzcrKO5Hejau+chAEenmdwB6DNcBq7rlK3Ht9Dv4pUJDqF4H4Dv/4bY3rgQp9hCagquZQER646orQ3717wTgEWCKqpbWEr/XgUv944RE5AG/RKUDrtTsFz+hfR6Q4celvn2JG7FjV/9FeFE1280AOvmd5wBuAf6Je+iGcZ3uwHUMrslEXAagP/Cuv2wKcKqfqUNEThKRG7YkMsaYJuN/uMRaH1ztX7z3gIP8vgCISH8RGe2v6wB85SeyjwR6Uj4BWBdXAnf7zX3w/z8N+NhvSvotm5pwDMEVEEHN74jNCVd1z/Y5bpH09Lc7bzPjVSdx78lL/DDsAhyMa89eV5/jrsUA/xg9ROR5/z1U0/uxvn0B/FlEAiLSFTimmu2mAGeLSIrfZ20G7ru3Eujj798O11SoSn6T3feAe3BNeGN9K6q7n2YLWAbA1MV5uPabFU0GzlXVZbjh3j7EtQWNAqNqWL4IN0rCV7iHw7Qqjh1zP3CpiCzAjQ5xDXCRiJyOK53vIm4Egwm4kRFinctexHVWmlDpiJXdArQSEcW1Jw3iXkzv4kocfgLex1Wt5uASz/VKVVfiRpL4CPfA/7Sa7QqAPwPjRGQhbjSPm/x43wq8K27Uo69rOeWHuA5aH8T6R6gbA/ouYLp/vYfjHrjGmGbKrxGcjCvpj1RYtxLXoXOy/5t/hE3PzDuA+0VkHnAIbjz/keJGpKmrwbjn6Xdxz9d1uL5L4J7pN8Q9y5b64arpHbE54ary2e63H78G1zRpHqC1xKOqPgD/quM1uBQ41G/CMxk3Qt6vddwX/9l+Gq6pzwL/GK/497Wm92N9ewzXR+MnXC3MS5RvEhszAZd4/xF3/55S1yH7FSDf3/95am+6MxHX/OfluGXVvavNFvCi0arunzHNm1/tOBfYKa70oEmLa76DiOwBzFDVmqpJjTFmuyEii3AJ5OmNHRZTWYV31L24Gve6DEJhmiCrATDbq5HAmGaU+A8By2PVvLih3GyiNWOMMY1O3Jw4s/2mPZm4IU3tHdWMWSdgs13xS/7/h6sWbDYlE/7IHJcDY/0+ACtx/SWMMcaYxvYWrt3+AtyIQ2/SAM1hzbZjTYCMMcYYY4xJINYEyBhjjDHGmARiGQBjjDHGGGMSSJPrA7BmTe4Wt0nKzEwhL6+4PoPTKCweTYvFo+nZXuKypfFo375FQ8xF0ezY+8Li0dRYPJqWRI9HTe+K7aoGIBSqcibyZsfi0bRYPJqe7SUu20s8mqPt5dpbPJoWi0fTYvGo3naVATDGGGOMMcbUzDIAxhhjjDHGJBDLABhjjDHGGJNALANgjDHGGGNMAmlyowAZY4xp/kRkCHA9UAb8Ezc79/NAEDfT9V9Utdjf7mrc7KL/VdWnRCQJeBbYGQgDF6jq4m0fC2OM2T5ZDYAxxph6JSJtgVuBA4HjgZOA24D/qOpBwCJgqIhk4DIHg4BDgb+LSBtgMJCtqgcCdwL/2uaRMMaY7ZjVABhjjKlvg4CpqpoL5AIXi8jPwKX++jeAawEFZqtqDoCIfAYMBI4AnvO3nQo8vQ3Dbowx2z3LABhjTAObNSvIL794zJ8fZM6cAD/+GOSJJwo58cTGDlmD6Qaki8gUoDUwAshQ1dhMNquBzkAnYE3cfpWWq2pERKIikqyqJVsbsLziMv4ybi6jz9yHnTKTtvZwxpgKVq5cwemnn8hjjz1Dnz57blx+0UXn0r17D26+eUS9n/OJJ8Ywe/bnJCcnEw6XMXz4DfTsKfV+ntosXryIUaPu4ZFH/ltu+SGHDGDPPfcut+yaa26ke/ce2zJ45VgGwBhj6lk4DJEIlJbCs88mMWJEKgApKVH22ivCWWeVstde4UYOZYPygLbAKbh2/B/5y+LXV7dfnZdnZqZs9gQ5Ob8XsCy7iCW/F7BXl86btW9TFAwGyMpKb+xgbDWLR9OyNfHIz0+jS5eufPrpNA48cAAAv/yylPz8XJKTQ/V+fWbPns3PPy9iwoQJeJ7HF198ziuvjOeee+7d5vejRYs0QqFgpXO2aNGCcePGbfFxGyIelgEwxpgtFI3CqlUehYWQl+cxaVISs2YF+e67ACUlm9KsRx9dyj//WUzXrlFSUhoxwNvOKmCmqpYBP4lILlAmImmqWgjsCKzw/3WK229HYFbc8m/8DsFeVaX/eXnFFRfVKi+3EICycITs7ILN3r+pycpKt3g0IRYP2LChkN1334PPPvuMdetyCQaDTJr0OvvtN4Di4iKyswv45puvePzx/xAKhejQoSM33PB/eJ7HnXeOYM2a1RQWFjJ06MUMHHgQw4ZdTL9+A5g7dw7Z2dncffcDdOq06bHx229ryM3NY926XEKhELvttic33bQn2dkFfPLJVJ588gk6dOhIWlo6f/zjQAAWL/6JYcOupqCggHPPPZOJE9/g/fffYeLECQSDAbp124UbbriZt99+g1mzZrJ27RpGjryLTz6ZztSp7+J5AQ466FDOPvscVq9exS233EhSUhK77robZWXhStcuGo1WeT2feupxVqxYzsqVKxg69GJefnk8BQUFDBv2d5YvX8aECS8QDAbZa689ueyyq8tt//DDjxMM1lwA0r59i2rXWQbAGGMqyM+HBQsCFBdvSsSXlMDChQGKijxKSuD77wPMmRNk9epNYykkJUXZb78wF11USqtWUTwPdtstwpFHlpGUWK1N3geeFZG7cU2AMoH3gD8D4/z/3wU+B54UkSzcaEEDcSMCtQRO9/c5AVeDUC8CnrunkWi0vg5pTJP11vermDLvt83eLxQKUFYWqXLdiX06cdweHWvZP0Tv3n2YO3cO/foNYMaMT7jggr8yffo0AB588F5Gjx5Dy5atePTR0Xz00VT69RtA//5/4Jhjjmf58mXccsuNDBx4EAAZGRmMHj2GMWMe5pNPPuSMMwZvPNeAAQfw6qsvc8YZJ/HHPw7kwAMP4Q9/OACAhx56kCefHEdmZiZDhw7ZmAGoSmFhIfff/zAtWrTg8sv/yk8/LQJg1arfeOyxp1m5cgXTp0/j0UefAuCyyy7ksMMGMWnSBI444ijOOONsxo17lkWLFtbxKjtlZaU8+uiTzJ07h59+WsSLL06irKyMW2/9B888M5709HRuvvla5s6dU277rWUZAGNMQioshGnTQuTnu88lJR7z5rlE/fz5AcLh6lqjON26RTj44DD77ltCy5ZRgkE48MAwHTtawlJVl4vIRFxpPsAVwGzgORG5BFgKjFXVUhG5EZfQjwIjVTVHRCYAR4rIDKAYOL++wha7q5b+N6ZhHXbYEUyd+h5t27alffv2pKWlAfD77+tYtuxXbrrpOgCKiopo1SqLFi1asmDB90yZMgnPC7BhQ87GY+299z4AdOjQgZycnHLnSU5O5sEHH+WHH+Yze/bnPPzwKKYury9cAAAgAElEQVRNe59hw/5OZmYmWVlZAJXa4FfUsmVL/vGPawBYuvRncnKyAdh99954nseCBd+zbNmvXHHFJQAUFOTz228rWLLkZw47bBAA++yzP7Nmzax07Ly8PIYNu3jj58zMTP7971H+8ffYuHzXXXuSnJzMzz8vpkuXnUhPd81++vXrx8KFP1TafmtYBsAYs10rKXEl+t9+65rm5OV5fPddkC++CJKTUz6Rn5kZZZ99wlx5ZQl9+0Zo2XJTKjEQgF13dcs8D5KTt3VMmhdVfRx4vMLiI6vYbiIwscKyMHBBQ4TLsxoAk0CO26NjraX1VamPpkz77z+AUaPupW3bdhx66BEbl4dCSbRr175SR9l33nmTDRs28J//PMmGDRu46KK/bFwX39QlWuG3Gw6HiUaj9OrVm169enPaaWdxyinH8Le/Xbnx9x5/jPhlZWVlAJSWljJq1D08++x42rZtx/XXX10uvLH///jHgVx//c3lzv/CC2PxvIAftqprTTIzMyvFNyYprno49rfnlY9naWkpgUCg0vZbwzIAxpjtTn4+vPlmiI8+CvHGGyFKS8sn9HfbLcxxx5Vyyill7Lyze2AHArDjjq4k32y/Av5XwdL/xjSspKQk+vbdh7feep0XXnh1Ywl2y5YtAfj558V0796DiRNfom/f/cjOzqZz5x0IBAJ8/PGHlJaW1uk8Tz3lyhkuvvhvAGRnr6dNm7a0bt2GDRty2bAhh/T0DL7+ei69evUmPT2DdevWAvDtt18DrjQ/GAzStm07Vq36jR9+WLAxcxAjsjtjxjxMUVERKSkpjB59P5ddNoyddtqZH36YT69eu29sprO1unbdmWXLfqGgIJ/09AzmzJnD4MHnM2fO5/VyfLAMgDFmOxCNwoQJIe6+O4XcXI/iYigu9sjKijJkSCndu0fo1StC375hWrbEEvkJzGoAjNl2DjtsENnZ68nMzCy3/MYb/8ldd40kKcnVBpx44qlkZGRw443DmT9/HscddyIdOnTgmWeeqPUc5547lFGj7ubii88nLS2NSCTCzTePxPM8Lr/8coYNu5j27TvStetOAOy/fz+ee+5phg27mAMOOBDPC9CqVRb9+g3goovOZdddezJ48F946KFRnHHG2RvP06lTJ84442wuv/yvBAIBDj74UFJSUjn99LO55ZYb+eSTj9hll55VhrFiEyCAs84aUm2c0tLSuPzyq7jmmivwvAD9+u3P3nv3rdcMgFexKqWxrVmTu8UBst73TYvFo2nZXuIBm+ISDsPSpR6TJydx990p7L9/mH33DRMKwdFHl9G/f5hAE57vfEvvSfv2LWruoJAgtuR98XtBCX8aM4sRx/fmOGnXEMHapraX37XFo2nZHuPxyCMP0qPHLhx77AmNHKrN1xDvCqsBMMY0Cfn5buz8tDTXfOfVV5ModCM2Egy60XRCIVANUFgYYP78TPLz2Tjc5sknlzJmTJGV7psaBbAaAGOMsQyAMabBrF8Pzz+fzFtvhejWLcLee4dJT4dQyLXDz8/3ePvtEL/+GuCjj4JEox7p6VEKCjy6do3QqZNLpBUXuwm1wmGXEWjTBo4/vpSWLd1x2rePcsghYUv8m1rF+v9ZBsCYxDJs2NW1b5RALANgjKk3xcVuaM3Zs4PMmRPg66+DFBd77LtvmM8/DzJ5cuXRCzIzo3ToEOWyy0pp0ybK0qUeRx1VxpFHVt98x1WHbv4kUMZsmgegkQNijDGNyDIAxpgtFo3CV18FmDYtxJQpIVatCpCd7ZGcHGXPPSNccEEpZ51VSu/ebqSd33+H0lKPoiI3qRbAwIGuVsCYbcHbOAqQ5QCMMYlru8oAPPD5KAoLyw8btXf7vgzc8SBKwiU8+V3FIalh/4796d95AHmleTz3/TOV1h+ww0D6dtiX7KL1jP9hXKX1h3Q5jD3a9WF1wWomLpxQaf2gnY5itzbC8txlvP7T5Errj+l+HN1b9eDnnMW88/NbAKSlJW2Mx0m7nMKOLbqw8Hdl6i/vV9r/tN3OpEN6B75fO4+Pl1WeLHNwr3PISm3N16vnMnPFZ5XWn7vHBWQmZfLFys+Zs+qLSusv2vMSkoPJfLb8U75Z83Wl9X/rewUAH/0yjQW/zy+3rmVGOuf0vBCAD5a8y4/ZP5Zbnx5K5/w+bv1bi99g6YYl5dZnpWQxeHc3DvDriyaxPG95ufXt09pzupwFwCv6EmsK15Rbv2Pmjpy066kAjF/wPNnF2eXW79yyG8f1cJ2Bnp33FAVl5TvY9MzqyZHdjgbgiW/HUBopPyTY7m16c9hObmzjR79+mIqa2ncv/nsFVX/34tX03fv5Z49Fr57LykWdWZw/D3p8QPf9I3TPirBH7wjdukc5t8+m796jX1fx3Ts07ru3cPO+e2lpSVwglwJVf/eSAiH+utdlQON+97zS9bw6/VR6Bos5sEWrTRsEksmTuyFr30rxNg3LagCMMWY7ywAYY+pXJAI/LvJYvsajtASWr/BYtCjIz4sDdFoToHe3CKcdV0SkWzGZLRo7tFvHixSRtHYqXqSYQMfjqt4oUkzy2qmkBUtpUeIyRWmrl5JSUr45UmpKGi0K3ySUN58vV/9AdsudOLBl67iTBdg0J63ZlgLWB8AYY2wY0KbI4tG0JFI8li71mD07yJdfBlmwIMCyZQF++aV8Q/zu3SMMGVLKRReVNFrTnXq/J5FiWn11OknrPyUaSCMaaklxpz9X2iwp+wtCObMJp3ev23G9JP4d3pdwiz021pbFs2FAt86WvC+KSsMc9NBnXHvkbpy5V6eGCNY2lUjPp+bA4tG0JHo8bBhQY0y18vLgmWeS+eCDILNmuUdCenqUPfZwk2cNH15M+/ZRQiHo0ydC+/ZNoNAgUkbKihcIlK4nGkijuPMZREN+FUQ0TMrKCQRKf6/z4ZJ+/4Tk36ezYY8xlLXYm1bfDCZt2dOVtosGksnt/QjFO55T52OHq2geZhpPwCYCM8YYywAYk4hKSmDKlBDz5gWZPj3I/PlBdtstzC23FHPYYWX06uXG3G9Q0QhJv39EoDTHfQymU9J2EARC/rrpBEqzq9w1qO/R8pcXN35OWTWZoi5DAUhe+y6pK1/avKAQIK/nnRTv4GZm/P3Ab7ckRqYZCGzsBNy44TDGmMbUYK94EckEngNaAynASOA3YAwQBb5V1csa6vzGmMqiUZg5M8ioUcl8+mmIlJQobdtGGT++gEGDwtssEMG8+aQte4q0ZU+WW1XU+UwKdxxKyqpJpP9aueN0vPweN1C40zCS17xJi+//RvL6Tzat634thTtfVfcgBUIQzNi8eNTRzi27NchxzZbxrAbAGGMatAbgfEBV9R8isgPwIbASuEpVZ4vIeBE5RlXfacAwGJPwolFYudJj/Xq4//4U/vvfZJKTozz4YCFnnVVW7Vj79cErWYsXziu3LHXlBDJ+uhOAgq6XUNTFjcaT8ttEMn6+h9SVbkSjwi4XUtj1kiqP26J1GwpKOwBQvMMQStscjlcWq0lIJZLWrSGis0ViI02ZpsFqAIwxpmEzAGuBvfy/WwO/A91Vdba/7A1gEGAZAGMaQG4u/Pe/ybz3Xoivv45NkRtk6NASbrqpmJYtG/DkkTJSVzxP5oKr8aic0irq+GcKd7qMslb9Ng7MXrDLzZS0PxavLIdoMN1fV03uJCMd4jpERVI7A50bIiZmO2M1AMYY04AZAFV9SUTOF5FFuAzACcB/4jZZjb2xjal3+fkwdWqIp59OYtasIH36RLj11iK6dk0mObmIo46qfobd+pC8+k1afncRXqSAkraHU9Tp9HLro8FMStofC4EKswJ7HmWttr9x8Z+d9xTAxnkHTOMLeDYPgDEmsTVkH4BzgF9U9WgR2RuYDOTEbVLl0ESZmSmEQsGqVtUqGAyQldX8pxS1eDQtzSUe69bBww97vPSSx+LFHoFAlLFjo5x1FkASwaBHOJzScAHYsIDQJ8dC0QqiWfsQ2fkcvO4XkBaq3LZ+a69mc7knANEkN/laVeFtTvHYnnieZzMBG2MSWkM2ARoIvAegqt+ISBoQX+S3I7Ci4k55ecUVF9VZoo/32tRYPLadH34IMHRoKosXe/TtG+Gll4rZa68I7dpFyfYH0mmIeARzvyNj0Ujydx1B+tJHCBWvo3DnqyjY+QqiyW0hD6D+r11zuCcxsdmXqwrvVoztvNXhSmSuBsAyAMaYxNWQGYBFwADgVRHZGcgFlojIgao6AzgVsAGyjdlKL74Y4rrrUmnRIsprrxXyhz9sm9F8AgU/02ruqQRLVpGUMxevLIfCLheS33PENjm/MVsq4HnWBMgYk9AaMgPwOPC0iHzsn+dS3DCgj4tIAPhcVac24PmN2a59/32A225L4aOPQhx8cBmPPVZEu3YNn6rxStaQ/vMoUta8hRctIWev59ykWdEyCrtd2eDnN6Y+WA2AMSaRNWQn4DzgjCpWHdRQ5zQmEZSUwIMPJvPgg8m0ahXlppuKufzyEpKSat93S3lluaQuexovnEfK6rcI5ivh9O5s6PsyZVkDKOl4csOdvJnrmdWzsYNgKgh4NgyoMSax2UzAxjQTkQhMnRrkrrtSmD8/yKmnlnLnncW0bVuPKZlIMcnrplPS9gggTMqq1/HC+aT89grJ62e4TUKt2LD3eEra/6n+zrsdO7Lb0Y0dBFNBwPOIVjE8rTHGJArLABjTDHzwQZBbb01h0aIgO+wQYezYQo45pqx+TxIN0/K7C0lZPYWizmfhhQtIWT3FrfKCbNjjcYp3OLt+z2lMI/BsGFBjTIKzDIAxTVQ4DO+/H+Lxx5OYOTOESJjHHivkhBPK6qW5TzD/R7zwphFoUpc9RcrqKZS0PpjUlS8BkNfzNoo7nUk0mEY0KWvrT5qAnvh2DAB/3euyRg6JiXGdgC0HYIxJXJYBMKYJmjkzyNVXp7JkSYAuXSKMHFnEhReWkpxcP8dPX3QHGT/fU2l5Qbfh5PccQTBPwQsQzrD261urNFLPNTVmq3lYHwBjTGKzDIAxTcwHHwS54II0unaN8uSThRx7bBmhevylJq3/jIyf76Go81kUdzhp4/JoqBWlrQcCEM6U+juhSTgicijwCvC9v+g74B7geSAIrAT+oqrFIjIEuBqIAP9V1adEJAl4FtgZCAMXqOri+gqf1QAYYxKdZQCMaSLWrfOYMSPIlVemsvvuEV5+uYDWrev/PEnrPiTqBcntNQpCmfV/AmOcj1X1tNgHEXkG+I+qviIidwFDReQ54J9Af6AEmC0ik4ETgGxVHSIiRwH/As6sr4BZHwBjTKKzDIAxjSQcdk19VAPMnBnkzTddw/699w4zfnxhgyT+AZJyvqAsc09L/Jtt7VDcfDAAbwDXAgrMVtUcABH5DDeL/BHAc/62U4Gn6zMgAc8jajUAxpgEZhkAY7axwkJ4/fUQY8cm8+WXQQBSUqJcdVUxe+wR4fjj67fJTzmRMpJy5lC4wzkNdAJT0e5tejd2EBpLbxGZArQBRgIZqlrsr1sNdAY6AWvi9qm0XFUjIhIVkWRVLamPgAWsBsAYk+AsA2DMNrRqlcf556fx5ZdB2reP8NBDhRx+eJgWLaKkpTX8+UMb5uKF8ynLGtDwJzMAHLbTEY0dhMbwIy7R/zLQA/iI8u8br5r9Nmt5ZmYKoVBwswMXCASIAllZ6Zu9b1MTDAYsHk2IxaNpsXhUzzIAxmwD0Si8/HKIW25JpbgYnnqqkOOOKyMQqL9zeMWrSP9lDEQKq1wfSEmi5bIpRJJaU9Lm0Po7sTEVqOpyYIL/8ScR+Q3oJyJpqloI7Ais8P91itt1R2BW3PJv/A7BXlWl/3l5xRUX1U00SjgSITu7oPZtm7isrHSLRxNi8WhaEj0e7du3qHadZQCMaWClpXDddSmMH59M//5ljB5dxC67lG9/4JWud2PvR1yCJpLUjpL2x5D628tEgi3cBFxesMI+OaSsfBEvUgRA6soJBPN/IBqsum2/50EkmEVO31eIJrdrgJiaqjz69cMA/K3vFY0ckm3HH9mns6reJyKdgI7AM8CfgXH+/+8CnwNPikgWUIZr/3810BI4HXgP1yH4o/oMX8ADmwjYGJPILANgTAPZsAE+/DDE+PFJTJ8eYvjwYq67roRgLB0fLiR57Xt4kWLSfnmMpA1flts/EsoiUJYNQNHv0ylpd6RbntSW0tYH0OrrM0jK/t+m7YOZ5OzzKqVtD68yPNtLSYhpFqYA40XkJCAZuAz4CnhORC4BlgJjVbVURG7EJfSjwEhVzRGRCcCRIjIDKAbOr8/AeZ5nfQCMMQnNMgDG1LMFCwJMmhTilVeSWLEiQDAY5YEHihgypNRtEA0TyplDxuJ/k7xumlvkhcjZaxwl7QYBkLH4XtKWjiZnr7GEcr8j4+f7SP3t5Y3nCKd1I1C4lA17Pk1x+2PdQi8JAvUwRbAxW0lVc3El9xUdWcW2E4GJFZaFgQsaJnSxTsCWAzDGJC7LABhTjx5+OJnbb08hFIqy335hHn64iN13j9CunZ/YiEZoMe9iUn97BYDcXvdR2uZwIklZ5Zrl5Pe8lYLuw4mGWlDS8RSKugzFC7umPmlLHiRtxXPkyr0UdzqtUhiMMTXzbCIwY0yCswyAMfXg3XeDPPpoMrNmhTjppFLuvruINq0j4MX18g0XkbFoBKm/vUJ+92sp7nQG4cxe1R4zGtrUeSeS2mXj33m9H6Kg+3Ai6T0aJC7GbO8CnuuYb4wxicoyAMZsgdxcGD06mWnTQqxf77FiRYBddokwfHgxw4eX0Gr5A6R/+xA5fSdQltWftCUPkfHjP/GIULDTZRTscovrlbslvIAl/puRvdv3bewgmAqsBsAYk+gsA2DMFrj22lRefz3EwIFhevWKMGBACYMHl9Ji7QtkzryFQOlaol4yWXOOJhrMIFCWQ3G7oynueDLFnc/a8sS/aXYG7nhQYwfBVGATgRljEp1lAIypo/Xr4cUXk/j88yDvvJPEDTcUc801bmjy5DXvkD73TkK58yhrtT8F7YdR3PEk0paPhUgxkeQOFO58BQSSGzkWZlsrCfvfkaDd+6Yi4HlErQbAGJPALANgTB38+GOAc89N46efAuy8c4Tzzy/hiitcwi5p/We0/PZcwqk7Udj1r+T3HAHBDADye97WiKE2TcGT3z0OJNY8AM2B1QAYYxKZZQCMqUE4DPff7zFiRDrp6TBlSgF/+EN44/pg7jxafn0W4bSdyd7/PaLJbRsxtMaYughYHwBjTIKzDIAx1fj5Z4/LLktj7twAxxxTyj33FNOx46ZEQ6BwCa3mnko0mEHOPpMt8W9MM2GjABljEp1lAIypIByGyZND3HJLCpGIx/PPRzjqqKJy/Xa9knW0mnsKXqSI7H7vEUnr2ngBNsZsFs/6ABhjElyg9k2MSSw33pjC3/6WRvv2Ud55J58zz4xWGrQnffG/CRb+Qs4+LxPO3L1xAmqM2SI2CpAxJtFZDYAxcV58McTYsclcemkJI0YUE4hlkSNlhPLmQTQMkRLSlj9PceczKMv6Q6OG1zR9+3fs39hBMBV4WB8AY0xiswyAMcDatR5vvx3ihhtSOPjgMv75z7jEP5C+9EEyFm0a0SeKR8FOwxohpKa56d95QGMHwVRgfQCMMYnOMgAm4Y0encydd6YAcNBBZTz7bCGh+F9GuIi0pY9S0vpACne+EoBIcnvCLfZohNCa5iavNA+AzKTMRg6JiXFNgCwHYIxJXJYBMAkrNxdefjmJu+9OZtCgMs45p5Sjjy4rV/IP4C0dR6B0LQU9bqS0zcGNE1jTbD33/TOAzQPQlHg2DKgxJsFZBsAkpGXLPAYPTuOHH4LsumuYhx8uom3bKhIE0QjBhQ9Q2qIvpa0P2vYBNcbUO+sEbIxJdJYBMAlHNcDpp6eRn+8xYUIBhx4arjTKT0zKbxPxcpXCPZ+m2o2MMc2LDQNqjElwlgEwCSUvD847L41wGN58s4Ddd49UuV0w9zsyFt9N8tr3ibTen+IOJ2/jkBpjGkoAKLX0vzEmgdk8ACZhLF/uccYZ6SxZ4vHEE0XVJv4BMn+8leR10yhpcwjhg96AgOWVjdleBDyPKJYDMMYkLkvVmO1eNOpG+rnnnmSCQXjiiSIOOCBc7fbB3Hkkr5tK/i63UNDjOrJS0qGwYBuG2GxPDthhYGMHwVTgWR8AY0yCswyA2a6VlrqZfZ9/PplTTinl5puL2Wmn6t/8Xsk6Wn57HpFQFoVdhm7DkJrtVd8O+zZ2EEwFAesDYIxJcJYBMNulaBQmTQpx110p/PprgOHDi7nh2g0k58yCddU1/YmSsegOgkW/kLPva0ST227TMJvtU3bRegCyUls3ckhMjNUAGGMSnWUAzHZn9WqPa69N4d13k+jbN8y//lXAUUeFyVh4O+lLH65x3ygBNuw9jtLW1mzD1I/xP4wDbB6ApiTgeUQsB2CMSWANmgEQkSHA9UAZ8E/gW+B5IAisBP6iqsUNGQaTWObPD3DuuWmsXu0xcmQRF19cSjAIXmk2qcueobj9cRR0u6ra/SPJHYmkd9+GITbGbGsBz9USGmNMomqwDICItAVuBfYDMoGRwGnAf1T1FRG5CxgKjGmoMJjEMmlSiCuuSCUrK8qUKQX07bupqU/qyvEEwnkU9LiRspZ7N2IojTGNzWYCNsYkuoYcBnQQMFVVc1V1papeDBwKTPHXv+FvY8xWiUbho4+C/P3vqey7b5iPPy6f+AdIXv0mZZl9LPFvjLGZgI0xCa8hmwB1A9JFZArQGhgBZMQ1+VkNdG7A85sEUFwMV12VyqRJSXTpEuHJJ4to1678m90rWUdS9v8o6Pb3RgqlMaYp8cBqAIwxCa0hMwAe0BY4BdgZ+MhfFr++kszMFEKh4BadMBgMkJWVvkX7NiUWj7pZsACGDAkwb57HrbdGGD48SlpaWrltvDWfEvzmGrxomJQep5K8BeGx+9H0NKe4HN/7GIAqw9uc4rElRCQNmAfcDkyjij5gfl+xq4EI8F9VfUpEkoBnce+OMHCBqi6ur3B5NgyoMSbBNWQGYBUwU1XLgJ9EJBcoE5E0VS0EdgRWVNwpL2/L+wRnZaWTnd38J2yyeNRu8WKPk09Op6wsygsvFHLkkWGKi12NwEbRKFlfXUc0fzHFnc8m1+sNWxAeux9NT3OKy07JuwJUGd4tjUf79i22OlzbyP8Bv/t/30aFPmAi8hxugIj+QAkwW0QmAycA2ao6RESOAv4FnFlfgQp42DzAxpiE1pAZgPeBZ0XkblwToEzgPeDPwDj//3cb8PxmO7RhA4wZk8yYMckkJ8Prrxew++7l2/sH8xeRumIcXlkOSTlzyO11H0VdL26kEJtEt7pgNQAd0js0cki2LRHpBfQG3vIXHQpc6v/9BnAtoMBsVc3x9/kMGAgcATznbzsVeLo+w+Y6AdfnEY0xpnlpsE7AqrocmAjMAt4BrsCNCnSeiHwKtAHGNtT5zfYnHIbzz09j1KhkDjmkjA8/zK+U+A8U/kKrL48jbeloUleMpyxjN4p2OKeRQmwMTFw4gYkLJzR2MBrD/cDwuM9V9QHrBKyJ26bSclWNAFERSa6vgLlOwJYDMMYkrgadB0BVHwcer7D4yIY8p9k+lZXBDTekMGNGiNGjCzn77LJy672yDSSt+5CMRbfjhQtZ/4fPCGf2bqTQGpPYRORc4H+q+rOIVLVJlX3ANnf5lvYZS0kJEY1W3S+judle+pFYPJoWi0fT0hDxsJmATZOXnw+XXJLG+++HuPrq4kqJf4CMhf9H2vJniQZSydn3NUv8G9O4jgN6iMjxQBegGMirog/YClxpf8yOuFrj2PJv/A7BnqqWVDzJlvYZKysJE4lGm00/kpo0p/4wNbF4NC0Wj6alIfqLVZsBEJGX63DsqKrWW8csY6oyYkQKU6cGufvuIi64oLTSeq94NakrX6So89nk7XYX0eS2jRBKY0xM/HtBREYAS4ADqNwH7HPgSRHJws0YPxA3IlBL4HRcv7ETcKPI1ZuATQRmjElwNdUA9MQ9iKvjAQ/Ub3CMKe+XXzxeeCGJ884rrTLxTzRK2q+PQ6SEgu7XWuLfmKbrVuA5EbkEWAqMVdVSEbkRl9CPAiNVNUdEJgBHisgMXO3B+fUZEM9zEwgaY0yiqikDcLOqfhz7ICIhoD2wxh/aExG5uYHDZxLcHXekEAjAVVdVqP2PRslYNJKUVZPwSrMpaX8c4YyejRNIY2owaKejGjsIjUpVR8R9rNQHTFUn4gaMiF8WBi5oqDBZDYAxJtFVmwFQ1bdjf/sTtQzBjefcSUQ+U9Vb47cxpr69/XaI115L4oYbitlhh/Iv67Slo0lfMoqoF8KLllHQ7cpGCqUxNdutTZWdYE0j8jxsGFBjTEKrqQ/AKao62f94qKoeG7fuU1x1rjEN4tdfPa6+OpU99wxzxRUlpKx8hbSljwBhvGiEUN48ijr+mYLu15CU8wVlrQY0dpCNqdLy3GUA7NiiSyOHxMR4YDMBG2MSWk1NgHYXkaG4hP50EXkTWIcbpeHTbRE4k5iiUbjqqlTKyuCJJwrJyP2IFt9fTDhDCKd1A6CkzSHk9xwJgWTCLfo0boCNqcHrP7lylL/1vaKRQ2JiAp5nfQCMMQmtpiZAd4lIB9w07SnAMNxU7eviJnMxpt698EISM2aEuO++Inp0j5Dx+QjCqTuzvt9UCGU2dvCMMc2cZxOBGWMSXI3zAKjqamCYuJlc/gUsAO7dFgEziWnlSo9bb01h4MAyzjmnlKT1M0jK/Yrc3Udb4t8YUy9cJ+DGDoUxxjSemvoADAPOBor8RY8A64GXRORVVX1uG4TPJJBwGK64IpXSUrj//iICAUhd8QKRUBZFnc9q7OAZY7YTbhhQywEYYxJXTTUAZ6nqQNg4BOg0VT0E1x/gnG0SOpNQHnkkmU8+CfHAA0X06BGFaJYLgkwAACAASURBVJjkte9R0u4oCKY1dvCMMdsJqwEwxiS6mjIAM0XkbWANruNvbEQgVHVcQwfMJJaFCwPce28yJ55YyuDBbsKvUM5sAqXrKGl/bC17G9N0HdP9uMYOgqkgYH0AjDEJrqYMwCzgNtyU7GtUtdI0rCJyqqpOaqjAmcTw/+zdd3hUVfrA8e+dPpNOCr0IygHE3guKsiiuYC8oi6uAKIoFXdeyIrJ2XaxYQERQwbLqKi6uIoj8LGsDdS1wBAtIEwikT6b//riTkJBJISSZmcz7eZ48mbnn3jvvyUzm3veee87ZutVg9Gg36ekR7r7bh2GYyx3bFhExbPhzh8Q3QCH2wF5ZveMdgtiFIROBCSFSXEMJwBR23v+P2Q+4FiO6jiQAotkiEbj6ahebNxu8+moFBQU7D8r2ok8JZhxAxJ4VxwiF2DO/FP8MSCKQSCwGMgyoECKlNZQArADObWT7FS0Yi0hB8+fbWbLExl13VXLYYeGdBeEA9uLleLtdEr/ghGgB//llISDzACQSA7kFSAiR2hqaB0DOvESrev99Kzfc4GTQoCBjxtS+w8xW+i1G2EsgW2b4FUK0LEM6AQshUpwl3gGI1PT11xbGjHHTr1+YOXO8WK21yx2FSwAIZh0eh+iEEO2ZJdrPSIYCFUKkKkkARJsLhWDSJBfZ2RFefNFLRkbtcvu2xXh+vgd/hxMIu7rGJ0ghRLtlREcakNN/IUSqanAmYACl1GvAPODfWmt/64ck2rvZs+18/72Vp5/20rFj7UOwrfhLsv43mlBaf0r2l7nmhBAtr6oFIBzZ+VgIIVJJowkAMA04HbhRKfUdME9r/X7rhiXaq3fesTJ5spMhQ4KcdlqwernF+xvO3/+F59eHCDvyKTr4dRn9R7QLp/c5M94hiF1YqloAIhHMLsFCCJFaGk0AtNafAJ8AKKUOBR5XSnUFngb+obUub90QRXvx6adWxo93c+CBYZ5+2othgOEvxFG4hLQ1U7FW/kbI2ZWig/9FxNkx3uEK0SK6ZnSLdwjNopTqp7VeVU/ZcK31v9s6ppZSdcovHYGFEKmq0T4ASimPUmqkUupfwGPAy8ARwFrgjVaOT7QTq1ZZGD3aTbduYebN85Kebi5PX3U9md+NwwgWs+PwJWw/9lvCnj7xDVaIFvTjds2P23W8w2iOJ2o+iR4DqlzXxrG0qNotAEIIkXqacgvQ/zAn+7pNa/1tjeVzlFJHt05Yoj0Jh+Haa104HBFeftlLbq550LV41+L8/Q283cZRvvdtROzZcY5UiJa3eN0iAPp2qDOZYqLb9d6Y7AbKkopRow+AEEKkoqaMAnQw8FHVyb9SarRSKg1Aaz2+NYMT7cM//2ljxQorkyf76N595xHXve4JMCxU7HW9nPwLkXgaOj1O6lPnqhYAmQxMCJGqmpIAvADsVeO5G5jfOuGI9ubnnw1uvtnFYYeFOO+8nZ1+jcAO3Buew9fpHBnqU4jk0G7Olo3qeQDiG4cQQsRLU24BytZaP1L1RGs9Uyl1QSvGJNoJrxfGjXNjt8OMGV4sNdJN1/rZGKFyKnpeHb8AhRANGaSU2hJ9bABZ0ecGkBm/sPacIS0AQogU15QEoEQpNRH4GLPF4ESguFWjEu3C3XcbfPedhfnzK+jWrcaBNuzDve4p/LknEsoYGL8AhRD10lrb4x1Da6m6FiGn/0KIVNWUBGAU8BfgTiAEfA6Mbs2gRPKrrIRZswxOPTXAH/4QqlXm3PRPrP7fKe05I07RCdF2zul7frxDaBallA0YVjXcp1LqD8AFwM/Ag1prbzzj2xOGjAIkhEhxjfYB0FoXA/cBE4CJmMOAvtbKcYkkN2eOncJCg0suCdQuiETwrH2UYPp+BDqcEJ/ghGhDBZ4CCjwF8Q6jOWYAfwRQSvXB/O5fhnnh/PE4xrXHLDIKkBAixTXaAqCUug24GMjFHPu/J+aBQYg6tm0zuOUWJ2+8YefYYyMMGlT76r9j27vYyldRMnDmzp54QrRj32/7DoB985Ludrd9tdZHRh9fCLyitX4OQCm1tKENlVIeYA7QEXABdwDfAM8DVmATMFpr7VNKjQKuBcLATK31M0ope3T7npgtz5dorX9uqYpZqjsBSwYghEhNTRkF6BStdW9ghdZ6f+AEzC9kIWpZsMDGccd5WLjQxk03+Xj33TCGAZbKjbh+ewbXuhlk/HAlIfde+DqeHe9whWgTy9YvZdn6Bs+XE1XNW3yGAm/vxrYjgC+11scD5wEPAn8HHtdaDwLWAGOiQ0rfBvwBGAxMUkp1wEw4irTWxwJ3AffsYV1q2dkJuCX3KoQQyaMpfQAiSikDsCml3FrrFUqpRxrdSqSMQABuuMHJ/PkODjwwxGuveenfP4zdbn680ldei3PbOwCEHB0pPuhVsLTb/oVCtBcVSqmzMScA6wu8B6CU6k8jE4FprV+u8bQ7sB7zBP/y6LK3MPuWaeCL6K2mKKU+Bo4BhgDPRdddDMze8+rstPMWIMkAhBCpqSkJwKuYzbPzgG+UUr8D5a0alUgaoRBceqmLt9+2M2mSjxtu8GOr8amylq3Cue0dKnpdT0WPCUTsWWBxxi9gIURTjce8dScLOE1rXamUcgFvYl6hb5RS6hOgGzAcWKy19kWLtgCdgU7A1hqb1FmutQ4rpSJKKYfW2r/n1arRCbgldiaEEEmoKQnAUq31VwBKqbeBPODrVo1KJI3bb3fy9tt27rijkssu26XDb6iS9JWTiFjcVPS8kogjLz5BCiGa447o7xLgcqVU1dX7/wJXAGMa24HW+mil1IGYE0rWbDWorwVht5anpzux2ayNhVF3uzTzIkR6hovsbM9ub59IrFZL0tcBpB6JRuqRWFqjHk1JAKYppU7SWge11uuAdS0agUhKkQg895ydGTMcXHqpv+7JP2BZdS/Woo8pGThLTv6FSD77Yd7+8y7m/f9NbvlVSh0CbNFa/6a1/jo6pGhp9DZSL9AV2Bj96VRj067ApzWWfxPtEGzEuvpfVubbdVGTeCvMXRUXe8lI8rEIsrM9FBVVxDuMPSb1SCxSj8TS3Hrk52fUW9aUBKACWK2U+gao/gLWWp/X2IZKKTfwHeaVpCXEGAGiCa8vEsymTQZ/+YuL996zMWhQkClTYr+Nxu9LCGQdga9zox8VIdqtC/v9Kd4hNIvW+rDo8J8jgdsx7+N/FXhLa13ayObHYY7gc61SqiOQDrwDnI3ZGnB29PlnwCylVDYQxLz//1rMmYbPxUw+RgAt2ovakGFAhRAprimjAD2AOQzoQ5hjP1f9NMWtwPbo4zojQOxWpCIh/Oc/NgYNSuOjj6zccUclr7zixeGIsWLYh7FjOYHsI2MUCpE6sl05ZLty4h1Gs2itf9Ja36W1PhyYDPQHViml3mpk06eAAqXUh8BC4EpgCvDn6LIOwNxoa8BNmCf6i4Gp0Q7BLwNWpdRH0W1vbsl6WWQiMCFEimtKC8BgYveVWtbQRkqpfsAAzC//qv3sOgLEk00JUsRfYaHB/Pl27rvPwb77hnnySS+9e9d/8LSVfI0R9hPIPqINoxQi8Xy9ZQUABxYcHOdImic6CtwJmB1/TwAWAf9saJvoiX2sjsJDY6z7KmbLQs1lIeCSZobcqJ3zALTWKwghRGJrSgKwrcZjO2YT7YYmbDcNc+bgP0efp8UYAUIkgVAIRo1ys2KFlUMOCfHiixVkZze8jb3oMwACWYe3QYRCJK5PNn4MJF8CoJQ6HLgA86T9M8yT/gla67odfpJM9TwAMg6QECJFNZoAaK13vd3n4caaf5VSFwH/1Vr/opSKtUq93a6aO6oDSG/v1nLPPQYrVliYMyfMhRcCNB6bteQDIpn9yOrYq7XDa3WJ9n40V3upByRXXdxuc86LWPEmeD0+BX7CPPm3AOcD51V9p2utk/Y2Tov0ARBCpLhGEwCl1IBdFnXGnBSmIacCvZVSwzHHgPYBZTFGgKijuaM6gPT2bmn/+peNf/7TzuLFVs48M8App1RSVNT4dkawhNwtywj3vToh6rGnEuX92FPtpR6QXHXxes0L5rHibY2RHVrQXm3xIvFgSB8AIUSKa8otQDVbACJAMTCpoQ201udXPVZK3Q78ChxN3REgRIJ6+mk7f/ubix49wpx/foB//KOyeuSMxtgLl2BEAkQ6D2/dIIUQrUZrvTbeMbSWqtEvpAVACJGqmnIL0AlKqR7ROQBQSvXTWq9qxmtNAZ5TSl0GrAXmNmMfopVFIrBwoY3bbnMybFiAWbMqY4/y0wDXppcJ2/OI5B4FJS0ycacQQrQYaQEQQqS6ptwCdB/QEXMoUIC/KKW2a63/2pQX0FrfXuNpnREgROIIheCyy1wsWGCnb98Q06fv5sl/JIx9x8c4t75Nee8bcVhs1Jg6QoiUdNG+rTaYjWgm6QMghEh1TZkH4Git9cVVT7TW4wAZ3L2d2brVYMwY8+T/xht9LFlSQWbmbuwg7Cfrq7PIXn4qEYsLb/fxrRarEMkk3Z5Ouj093mGIGozqYUAlAxBCpKamJABWpdS+VU+UUofRwCg+IvksWWJl0CAPS5bYmDq1kuuv9+N07t4+0tbcgaPwfcp730LRoe8QceS3TrBCJJnPN33G55s+i3cYoobqYUDl/F8IkaKa0gn4SuBJpVRfIAz8AExo1ahEm/noIysXX+xm773DPPWUF6XCu70PI7AD9/pZVHY6j4o+N7VClEIkry9//xyAwzvLpHiJonoisPiGIYQQcdNoC4DW+ivgT1rrTlrrLsBErfV3rR+aaG0LFti44AI3vXqFee21imad/LvWPUXOp8dghMqp6HVNK0QphBAty4J0AhZCpLZW7wQsEtNTT9mZMsXJYYeFeO45Lx06NH1bx5aFuH+bAeEAjqKPCWQdhrfbWEIZ+7VewEII0UIM6QQshEhxTbkF6Git9aCqJ1rrcUqp/2vFmEQrCoVgyhQnM2c6GD48wOOPV+J278YOwkHS9U0YYS8hTx+83cZSpu4Dy26OFSqEEHFiqe4DIBmAECI1NSUBsCql9tVafw/SCTiZeb1w5ZUu/v1vO+PH+5k61YfVunv7cG5ZgLVyLcUHzMdfIBN9CSGSz85RgOIbhxBCxEtTEoArMDsBK8xOwN8Dl7dqVKJFrV5t4d57HSxebMPrNfj73yu5/PLA7u8oEsG99lGCnj74809p+UCFaIfG7XdZvEMQu5AWACFEqmvKTMBfA8dVPVdK9QbOx0wERIIrLDQ491w3ZWUGF1wQYPjwIMceG9rt/RiB7bg2vYS9ZAWl/R8GYzebDoRIUQ6r3B6XaCzSAiCESHFNaQFAKdUZ86R/JNABmNuaQYmW8cMPFi6/3MW2bQZvv13B/vvv5ig/YR+20v9hhAOk/zARW8UaQo6OVHa+oHUCFqId+njDhwAc03VQI2uKtlI9D4AMBCqESFH1JgBKqQ7AOcCFwN7Aa0C21rpvG8Um9sDWrQYjR7oJh+G557y7f/IfLCN7+XDsJSsAiFhcFB/wIoHsI8G6O72GhUht32z9GpAEIJFUdWKTUYCEEKmqoRaAzcAa4HrgXa11WCn1VduEJZpr2zaDKVOcvPmmDcOAt9+uYL/9dn98//Qfb8ZW+g2l/R4k5O5JyLM3Yc9erRCxEEK0rZ23AEkGIIRITQ0lAH8GLgBmA28ppV5qm5BEc8yda2f+fDsrV1oIheCiiwKce25gt07+PT/djWPrO5Tu+ziujfOp7HoJld3HtWLUQgjR9qpuAZLzfyFEqqo3AdBavwi8qJTKAc4FbgP6KaUeAJ7VWv/QRjGKBkQi8OabNv76Vyf9+4cZOTLApZcG2Gef3bvqb/gL8fz6CEbYS85ngyESpKLnxNYJWggh4sgiE4EJIVJcU0YB2gHMBGYqpbpitgo8BxzayrGJBqxda/DQQw4WLbKxbZuFAQNCLFxYQVpa8/bnWWue/Jf2fwRb6f8IZuxP2NO7ZYMWQogEsLMFQDIAIURqatIoQFW01huAf0R/RJwUFcFZZ3nYts3g1FODnHiijxEjgjidzdufa8PzeH59mMouo6jsdknLBitEirviwKviHYLYRXULQHzDEEKIuNmtBEDEXyAAl13mZvNmgwULKjjkkD07hDm2LSL9h6vw555Iaf9HWihKIYRIXNICIIRIdZIAJJFwGK65xsXSpTYeeqhyj0/+iYRJ0zcTSutL8f4vgEUmLBKipS1dtwSAE3oMiXMkoor0ARBCpDpJAJJEaSnccouLV1+1c8stPkaNCjR7X5bKDTgK38fi/QVbxWpKBj4DtvQWjFYIUWXldnO8BEkAEocFaQEQQqQ2SQCSwLPP2rn7bielpXDddT6uucbfrP0Yge3Yd3xK+qpJWH2bAAi6e+PreGZLhiuEEAnNkBYAIUSKkwQggZWVwcyZDu6918lxxwWZPNnHAQc0/7afzG/H4ShcTNiWzY5D3yXs6kbYkQsW+RgIIVqWUup+YBDmceYe4AvgecAKbAJGa619SqlRwLWYfXJnaq2fUUrZgTlATyAEXKK1/rmlYqvqAxCWFgAhRIqyxDsAEZvPB2ef7eHee52cckqAefO8e3Tyby39DkfhYip6XMn2Y1YQzDmKsLs7WD0tGLUQQoBS6gRgoNb6KGAY8DDwd+BxrfUgzFnmxyil0jDnmPkDMBiYpJTqAFwIFGmtjwXuwkwgWozDaiYA/qCMAySESE2SACSgYBCuv97FV19ZmTnTy9y5lc0e4hOAcID0H/9GxOKhovcNRBx5LRarEKJhdosNe+q1sv0f5gSSAEVAGuYJ/oLosrcwT/qPAL7QWhdrrb3Ax8AxwBDgX9F1F0eXtZg0h/l+VARCLblbIYRIGil3VEoGV15p8Mordm680ccZZwSbv6NImPSVk3BtnIcR8VM6YDoRe4eWC1QI0ahL958Q7xDanNY6BJRHn44F3gZO1lr7osu2AJ2BTsDWGpvWWa61DiulIkoph9a6Vgeo9HQnNpt1t+NLD5lX/kMWC9nZyd0KarUmfx1A6pFopB6JpTXqkRIJwIIFNtzuCEOHJv7VnuXLLTz7rIUrr/Rz/fXN6+wLQCRC2o9/w73hWSo7nYuvYDh+6ewrhGhDSqnTMROAk4DVNYqMejbZreVlZb5Yi5vEZbdQWFxJUVFFs/eRCLKzPUlfB5B6JBqpR2Jpbj3y8zPqLUuJW4DGjXMzapSHUIKf/3u98Je/uOjYMcL11+/BgW39HLI/PxHPusep6H45pQNnycm/EHHy3q/v8N6v78Q7jDanlDoZ+Btwita6GChTSrmjxV2BjdGfTjU2q7M82iHY2PXq/55Kd9qoCOxBC6sQQiSxlEgAqnzwwe43FbeVwkKD8ePdfP+9lRkzwqQ3c1h+58Z5ZKy8GiNUQUWvSZSre3eOeSeEaHOri1azumh14yu2I0qpLOABYLjWent08WLg7Ojjs4F3gM+Aw5RS2UqpdMx7/T8EFrGzD8EIYGlLx5jmsFHhT/CrQkII0UpS4hagvLww27ZZeOUVO0OGJN4XfjAII0e6+eEHC3fdVckf/2inqCj2uvYdn+DY8u+YZUa4EteGZ/F3OIHig/4pM/sKIeLlfCAPeEUpVbXsz8AspdRlwFpgrtY6oJS6CXgXiABTtdbFSqmXgaFKqY8AH3BxSweY5rRRLgmAECJFpUQCEAyaV8A/+MBGOAyWBGv3eOIJB998Y2XWLC+nnRYE7DHXs+34L1krTodIhEg9J/eBnEGUHPCCnPwLIeJGaz0TmBmjaGiMdV8FXt1lWQi4pHWiM6U7rZIACCFSVkokAF4vdOkSZuNGC999Z2H//RNn7OfPPrNy770Ohg8PMGJEA/ejRsJkrLyGsLMLOw5/n4gjt+2CFEKIdibNaWNjhTfeYQghRFwk2LXwlhcKgc9ncPLJ5sn1Bx8kRs4TDMKjjzo45xw3XbtGeOihynpv1TeCpbjWz8JWvoryPjfLyb8QScRj8+CxJf8wdO2N2QdAOgELIVJTYpwNtyJv9AJPz55h+vcPsWSJlauvjm9M4TBcfLGbRYtsnHpqgPvu85GVFXtdw7+N7C+GYqv4iZCrG76OZ8deUQiRkC4eODbeIYgY0l3SB0AIkbrafQtARYV5Wd3thhEjgnz6qZWNG+MzKo7XC1df7eLww9NYtMjG1KmVzJ5dSUFBpO7KYR9GYAdZX52NtXIDJQOfpuiwRWCJ3T9ACCFE06U5pA+AECJ1tfsEoKoFwO2OcNZZASIRgzfeaPuGj4ULbRx/fBovv2yjR48wl1/u5/LLA3Vv+wn7sX50BvlL8sn7oCe20v9Rsv9cfJ3PJ+zq1uZxCyH2zMKf32Lhz2/FOwyxizSnDV8wTDAc4wKMEEK0cylwC5B5hu3xQO/eEQ45JMQjjzg54YQQmZkRrFbo1CnCL78YzJ7tYOlSKxYLdOsWoWPHMCeeGOKUU4LY9uAv9e67VsaNc9GvX5gXX6zkxBPrv+qUtvp2LJv+TUWPCYQdBQSzDiPQ4bjmv7gQIq7Wlvwa7xBEDOlO80u9wh8k0yUtq0KI1NKqCYBS6n5gUPR17gG+AJ4HrMAmYLTWuvlT3jZBzRYAgCee8DJ8uIcTT/RUDwm6995hfvzRgtUKgwebJ+dbthgsX25n3jwHGRkRDjooxKGHhujRI0xBQYSDDw7RoUPjr//BB1YuvdTNfvuFef31ikYn+HJuXUi4ywjK1X17Um0hhBAN2JkAhCQBEEKknFZLAJRSJwADtdZHKaVyga+AJcDjWut/KqXuBsYAT7ZWDLCzBcAdnYB+r70iLF5cwbPP2rHZwOeDn36ycOqpQS6+OECnTjubg0MheO89K0uW2Fi+3MrDDzsIh3fes5OREaFv3zCDBwf58EMr27cbHHxwmEMOCdG9e5gZMxwsW2ajT58w8+d7Gz35N3xbsHp/IbTPhBb/OwghhNgpzWHODC/9AIQQqag1WwD+D/g8+rgISAMGA5dHl70F/IVWTwDM31UtAACdO0e45RZ/o9tarTBsWIhhw8wDRFkZbN9u8NtvFpYvt7J5s8GyZVamTXPSu3eYvn1DvP++lVdeMa8mpadHmDq1ktGjA42e/APYi80/VyTvqN2spRBCiN2R7jIPf5IACCFSUaslANGZHMujT8cCbwMn17jlZwvQubVev0rNUYD2VHq6eVLfo0eIY44xDxqRiPljGOZPJAJr1xps2WLQu3eEvLymdzCzF31KxHAQyT4YSuWgJER7kO3MjncIIoY0x84+AEIIkWpavROwUup0zATgJGB1jaKYY3Gmpzux2azNei2r1UJ29q4T7pgv07Gji+w2Og7n5OzmBqUay6a3sax/mkjHE7E63GRnJ85sxc0V+/1IPlKPxJNMdbniqMvqLUumerQ3aTX6AAghRKpp7U7AJwN/A4ZprYuVUmVKKbfW2gt0BTbuuk1ZWfP7BGdneygqqqi1rLDQDrgIBr0UFSXgcG+RMDn/PQtruSaYpihST5AVCtepRzKK9X4kI6lH4mkvdWluPfLzM1ohmtSSEb0FqMwnCYAQIvW02jwASqks4AFguNZ6e3TxYqBqKtuzgXda6/WrxOoDkEgc2xZhK9eU9n+EHUd+QsSRF++QhBAt6M01r/PmmtfjHYbYRbbb7KtVXBmIcyRCCNH2WrMF4HwgD3hFKVW17M/ALKXUZcBaYG4rvj5QdxSgOiIhDH+heeJtWOosr7O6IxeM5t2itHMnYQz/NoxQGWk//o2QqxuVXf4ks/wK0Q5tKNsQ7xBEDB6HFYfVoMgrCYAQIvW0ZifgmcDMGEVDW+s1Y/F6wW6PYI9xbm0EtpP95QhsZd8SyDqU4oPfJGLLwAgUkbV8BPbSb+psE8g4iOJDFhCxZzUvoFA52SvOxF70KQARi5Pig9+Qk38hhGhDhmGQ5bZLAiCESEkpMRNwnav/oQqyvrkQe+FSMOxU9JqEe+2j5C7tZrYCRMJg2Cjb+3YitszqzYxgMWk/3UXuBz2qWwv8uUMo2f8FsLpqv0bYT+a3Y3BsXVh7eSQMGJT3voWwI49g1qEEMw9s8XqnusceewitV7J9eyGVlZV06dKVzMws7r77gUa3ffvtt0hLS+f440+IWf7II9M499yRdOnSdY/jfO21lykqKmLs2NgdRdesWY3D4aBHj557/FpCiNqy3XaKvTIKkBAi9aRAAlD7/v/0Vdfj3Pw6RmA73u6X4e94BoGco/F3GIx9x4fV6wVyhxDIOabO/oJZh2PfvhQAS7AE928zyf1wABFr7SzDCFdi8W/F220sYXvtYYECOccQyB3SktUUu7jqqkmAeTL/888/MXHitU3e9o9/HNFg+TXXXL9Hse2OZcvep1+/AZIACNEKslw2aQEQQqSkdp8AlJfvbAGwlmncvz2NP/tovD2uwN/xtOr1ArknEMiNfcW3pkCHQQQ6DKp+7s85Bue2RTHX9Xc4Hl/nkXtWAdGiVqz4kpdeeoGKigomTpzEV18t54MPlhAOhznqqGMYM2Y8zzwzg+zsbPbaqw+vv/4KTqed1avXMHjwEMaMGc/EieO57rq/snTpEsrLy1i3bi0bNqzn6quv56ijjuGFF+awePEiunTpSjAYZOTIURx88KHVMXz55ec8+ug0OnTIJTc3r3q9u+66na1bt+D1ehkzZjydOnXmzTdfZ9my98nJyWH9+t949dWXsVot9OrVhxtv/Fsc/5KiqfLd+fEOQdQj221nzbbyxlcUQoh2pt0nAF4vXHDEHJwbgzi2LyVicVFywAstNtqOv+OZ+Due2SL7Em3jp5/W8OKLr+NwOPjqq+U88cQsLBYL5513Oueff2GtdX/44XsWLnybHTvKOffcEYwZM75W+ZYtv/OPfzzKp59+wptvvsa++w7k9df/yYsvvkZ5eTkjR57FyJGjam0zY8Z0Jk++g3326ctf/nI1Xbp0pbS0hMMPP5JTThnOhg3rmTz5JmbP0Ga8nAAAIABJREFUfoEjjjiKwYOHMGDAQFav/pFp0x4jIyODK6+8lJ9+WkOfPnu3+t9L7JlzlVwESFRmHwC5BUgIkXpSIAEwuPtPY+F783lFr2tlqM029vLLNl58sWU7OV9wQYDzz2/egXvvvffB4XAA4HK5mDhxPFarlaKiIkpKSmqtq1Q/3G43Pl/sYWT339/sv1FQUEBZWRnr1/9G7959cDpdOJ0u+vfft842mzZtYp99+gJw4IEH4/P5yMjIZOXK71mw4HUMw0JJSXGd7TIzM7n5ZvP2o7Vrf6G4uKhZ9RdCmLLcdkoqA4QjESxGzLkphRCiXWr3CYCvcuckL94uoynfe0ocoxGJwB4dEmrz5k28/PI8Zs+eh8fjYfTo8+qsa7U2PORrzfJIJEIkAhbLzuFkY51T1CyPRMzE4r333qGkpITHH59FSUkJ48aNrrVNIBDgwQfvZ86c+eTm5vHXvza9T4OIr3/qlwBpCUhE2W474QiUVgbJcstIbEKI1NHuEwBPdLLh0v6PUNntkjhHk5rOPz/Y7Kv1ramoqIicnBw8Hg9ar2Lz5s0EAnvWIbBz5878/PNPBINBSktLWbVqZZ118vLyWbfuV7p378lXXy1n3333o6ioiM6du2CxWFi27P3qOAzDIBQKUVFRjtVqJTc3j99/38yqVSsJBhPvbyrq2urdGu8QRD2yorMBF3kDkgAIIVJKq80EnCicgV8BCLllFBVR2z779MXt9jBhwhiWLFnE6aefxbRp9+3RPjt0yGXo0GFceulFPPLIPxgwYN86rQjjx1/BrbfeyI03TqKgoCMAgwefyCeffMg110zA7XZTUFDAs88+zQEHHMTDDz/A6tU/cthhRzBu3EU8++zTXHjhaB599EFJAoTYAztnA5b/IyFEamnXLQBFRVCQ9isAIXevuMYi4mPXIT0PPvjQ6hF5rFYrDz44vcHta47es3DhEgCmTzfnt+vde2cH3N69965e3r17D8aMMfsVXHTRSDp37lJrn0ceeTRHHnl0ndeaO/el6scnnXRK9eNTTzVHqzr00MNrrT9y5J8ajF0I0bCqq/4yFKgQItW06wRg3ToLe+X/QjhiIezqHu9wRIooLCxk/Pg/Y7c7OOmkYdVX+YUQiSXXYyYA28p8cY5ECCHaVrtOANautbBXwS/4rV3BIvd3irYxevTFjB59cbzDEAmia/qezxidjJRSA4E3gYe01tOVUt2B5wErsAkYrbX2KaVGAdcCYWCm1voZpZQdmAP0BELAJVrrn1s6xoIMJ2kOK2u2VbT0roUQIqG16z4Aa9ca7JX/C5E0uf9fCBEfp+99FqfvfVa8w2hTSqk04DFgSY3Ffwce11oPAtYAY6Lr3Qb8ARgMTFJKdQAuBIq01scCdwH3tEacFsOgT14aa7aWtcbuhRAiYbXrBGDdOgu9O/6CkSEJgBBCtCEf8EeIDsNmGgwsiD5+C/Ok/wjgC611sdbaC3wMHAMMAf4VXXdxdFmr2Cc/jdXbyquH5BVCiFTQrhOAzRt8dMneKB2AhRBxM3/l88xf+Xy8w2hTWutg9IS+pjStddXN9luAzkAnoOY4qXWWa63DQEQp5WiNWPfJT6PMF2JzqfQDEEKkjnbbByAQgB3rfwNkCFAhRPwU+WTG5hjqm3Z3t5anpzux2RqerK8+VquF7GwPB+2VC6zhl2If/Xt0aNa+4qmqHslO6pFYpB6JpTXq0W4TgGXLrOQ41gIyBGgquuyyS5g06a/069e/etlTT00nKyubCy6oO3zmihVf8vrrr3Dnnfdz003Xce+9D9Yqf+21lykqKmLs2Mtivt6aNatxOBz06NGTKVNu5pZbpuB0uva4HtOnP0zv3n3qDGda5euvV9CzZy9ycpLvxEWknDKllDvaMtAV8/agjZhX+6t0BT6tsfybaIdgQ2vtr7PDPRi9JzvbQ1FRBd08drpmuXhgkWb/gjTSncl1WKyqR7KTeiQWqUdiaW498vMz6i1Lrm+6BpSVwc8/Q2mphVAInnrKwWE9zEEjwi5pAUg1Q4eezPvvv1crAfjgg/d57LGnGt1215P/pli27H369RtAjx49mTq1VforxrRw4QIuuOBPkgCIZLAYOBt4Ifr7HeAzYJZSKhsIYt7rfy2QCZwLvAuMAJa2VlAOm4XbhvVlwiv/4/RZn3Ng1yx6dXCT6bLjtFmqf+xWCzaLgdViYIv+VD+2WrAZBlargc0wsFl3KbdYaqxrYDHqa+gQQoi20W4SgCuvdPGf/1iBNAAMI8Jdj/xExOIk7JRx2FPNkCEnMWHCWK644moAVq1aSX5+Pvn5BXzxxWfMmvUUdrudjIwM/v73e2tte+qpQ1i4cAlffvk5jz46jYKCArKycujSpSvBYJC77rqdrVu34PV6GTNmPJ06debNN19n2bL3ycnJ4bbbbua5516mrKyUe+75O4FAAIvFwk03TcYwDO6663a6dOnKmjWr6dtXcdNNk2u9/rvvvs28eXPJz++I0+mkd+8+lJeXMXXqrXi9XiorK5k06QbKy8v48MMP+OWXn7nzzvtZunQxH3ywhHA4zFFHHcOYMePb7O8tRE1KqUOAaUAvIKCUOgcYBcxRSl0GrAXmaq0DSqmbME/0I8BUrXWxUuplYKhS6iPMDsUXt2a8B3fLZs6og5i/fAM/binjk1+2Ewy3XqdgA7BZDazVyYIldmJR/diCzWLeBmCrUea0WcjJcGENR/A4LLjtVtIcVtwOKx67tfp5hstOtttGutMmyYcQAmhHCcD99/u49FIL5eVmk7BSYfYv/plQeU8w2nVfZxFDTk4HunTpyg8/fMeAAQN5//33GDp0GAClpaVMmXInXbp05Y47buOzz/6Lx1P33roZM6YzefIdHHbYgYwbN44uXbpSWlrC4YcfySmnDGfDhvVMnnwTs2e/wBFHHMXgwUMYMGBg9fazZj3F8OGnM2TISSxdupjZs2cyduxlaL2SqVPvJienA2ee+UdKS0vJyDCb6SKRCDNmPM4zzzxPRkYmY8eatysVFhYyfPgZHHfcYJYv/4J58+Zy110PsPfefbnuur/SqZN5F8UTT8zCYrFw3nmnc/75F5KWlt7af2rRiJ6ZveIdQpvTWi/HHPVnV0NjrPsq8Oouy0LAJa0SXD36d8zgjj/2AyAcieAPhqkMhqkMhPAFwwTDEYLhCKFav8M7H4dqlwfD4RqPI7UeB6Pr19nHLutVl4cihCIRAsEw3ujyQDiMLximcn0xZZVBKoPhRutoMSDLZSfbbSfLbYv+tpOb5qAg3UFButP8yXCQ7bZjSLIgRLvVbhKAjh0jKAVFRaHqZZZP1xJ29YhjVALAuXE+ro0vtOg+K7v8CV+XCxtcZ+jQYSxZ8h4DBgzk44//jyefnA1AdnY29913J6FQiI0bN3DIIYfFTAA2bdrEPvv0BeDAAw/G5/ORkZHJypXfs2DB6xiGhZKS4npfX+uVXH75RAAOPvhQ5syZBUDXrt3Jzc0DIC8vn/LysuoEoLi4GI8nrfqWnv32OwCADh1ymTt3Fi+++DyBQACXq27/ApfLxcSJ47FarRQVFVFSUiIJQAI4tXfs/hsicVkMA5fdistuBXdiTyJZdW9wKByhMhjC6w9REQhT4Q9SEQhR4Q9RUhmkyBug2BugOPq4yBvgtyIv324qZUeFn10bPOxWg/w0BwUZTjpmOOma5aJzposuWeZPpwwnNqtcXBMiWbWbBCAWa+Vv+DIPincYIk6OP/4EnntuNkOHnkz37j3IzMwE4J577uCBBx6mV6+9ePDB++rd3mLZeXCrGiP8vffeoaSkhMcfn0VJSQnjxo1uIAKjertAIIgRbYmyWmuPWlJz/PFIJILFsvOqWzhsXtV75ZX55OUVMHnyHaxa9QPTpz9cax+bN2/i5ZfnMXv2PDweD6NHn9dAXEKI9sZqMUhz2Ehz7P5hPRiOUFjuZ2uZjy2lPraUmY9/jz7+dmMJi/VWQjWSBIsB+elOMyHINH/XTBAK0p1YLdKCIESiar8JQMiLJVBI2NUt3pGkPF+XCxu9Wt8aPJ40+vTZh+eee7b69h+A8vIyOnbsRGlpKStWLKdPn31ibp+Xl8+6db+SldWfr75azr777kdRURGdO3fBYrGwbNn7BAIBAAzDIBQK1dq+f/8BrFjxJUOHDuPrr5fX6pBcn6ysLMrKyigtLcXtdvPtt98wcOD+FBcXVce5bNlSgsEgYCYpoVCIoqIicnJy8Hg8aL2KzZs3V8cm4mvOd88AcPHAsXGORIjYbBaDjtEr/XSOvU4wFGZLmZ+NxZVsLKlkY3Elm6K/v1hXxNYyPzUbEazRfe6aIFS1JOSlO6Q/ghBx1G4TAGvlBgBCrq5xjkTE09Chw7jzzilMmXJH9bKzzjqXCRPG0r17D0aNuojZs2cyfvwVdbYdP/4Kbr31Rrp160ZBgdmRfPDgE7nppuv44YfvOPXU0ygoKODZZ5/mgAMO4uGHH6h1K9G4cZdzzz138NZbb2Cz2bn55snVJ+71sVgsjBkznokTx9O5c2d69+4DwLBhp3LnnVNYunQxZ599HosXL2LhwgUceODB3HrrjdxzzzTcbg8TJoxhv/0O5PTTz2LatPt45JEnWuLPKPZARTD5h6ATwma1VF/dj8UfDPN7qa86QahKDjYW+/j4lx0UltcexdVuNeic6aJzNDnoXZBBB6fVXJblItcjfRCEaE1Gok1/vnVrabMDqjlOqn37MrKXj6DokH8T6HBci8XXFlJ93NpEI/VIPMlUlye+fgyAKw68qk7ZHoztLGdGtNzxIpklSz0qAyE2l/jqJAcbSyrZVFzJDm/tFkunzVKdHHTOdNElentR5ywXXTNdZLltCZkgJMv70RipR2JpjWNFu20BsFSuB6QFQAghhIg3l91Kr1wPvXJjz2bq8DhYuW5HzOTg+02lFFfWbj112y31Jgeds5xkuhK787YQ8dZuE4CqW4DCTkkAhBBCiETmcdjok5dGn7y0mOVlvuDO5KDEx6biyurbjb5aX0y5v3YfrPTo7UQ1kwPzsZPOma6km/FZiJbWbv8DLJUbCNvzwBr7fkUhhGgL+2TH7mQuhGi6dKeNffLT2Se/7tDGkUiEUl8wZnLwW5GXz9ftwBuoPU9ClstWPWpRVV+EjhnO6mFPO0gfBNHOtZsEwFq+GqPoa5wVZkcjW8kKQjICkBAizob2Gtb4SkKIZjMMg0yXnUyXnX4dM+qURyIRir1BNkRvKao5ktHPheV8/Mt2fLtMpGa3GhSkO6tHR4r1k+lKzH4IQjRFu0kAPD/dhe3318mssayyc9sPPSmEEEKIxGEYBtkeO9keO/t2ip0g7PAG+L3Ux+8l5vwHNX++Wl/M1jJfrXkQAFw2S52koFfHDNIskJ/mJD86o7IMdyoSUbtJAEoHzsR6yP2UlHirl8n9/0KIeHv6f08CcOn+E+IciRAiFsMw6OBx0MHjoH+MFgSAUHSyNHNytLpJwqdrd7Btl7kQwJwPIS/NQX66g/x0J/lpDvLSazxPd5Cf5iTdaZXWBNGm2k0CgMUBab0IB5J/uCex5zZt2shFF41EqX4YhoHf7+eKK67hgAMO3K39fPTRMk4+eUgrRSlSQSDc8NwPQojEZ7UYFET7CNQnGAoTsFn5aWMxW8r8bCvzsbXMz9ZyP1tLffy6vYIv1xVR6qv7neCyWchPd5BXI0koiCYIeekO8tKc5KbZ8dglURAto/0kAELsokePnkyfPhOAr79ewdy5s3jwwem7tY+XXprHiSceB8gXrhBCiPrZrBbysty4G5lfqTIQiiYGPraV+dla5mdLWfRxuZ+Vv5ey5Sd/nX4JYM6PkJvmINdjJzfNbLXITbNHfzvoEF2em+bAbbe2VlVFOyAJgEgJ27dvJy8vH4Bt27Zyzz13EAwGsFgs3HjjZDp16sTDDz/AqlUrCYVCnHnmOVgsFn744Tsuv/wypk17HLvdHFe6vLyMqVNvxev1UllZyaRJNzBgwEC++OJTZsx4AovFwh/+cBLnnXdhzGXnnDOC5557GY/Hw/TpD1fP9vvpp5+wbdtWpk69m5deeoEffvgev9/PGWeczYgRZ7B58ybuvHMK4XCYTp06c80113PZZWN48cXXMAyDRYv+g9Yrueqq6+L2dxZCCNEwl91K9xw33XPc9a4TiUQo84XYWu5ja6mfwgo/heV+CssDFFb42V7u57ciL99sKKHIG6hz6xGAx26lQ5qdXI+DDtGkoUM0OejgtpPjsZPltpPttpPpsklfhRQjCYBot9atW8vEiePx+/1s27aVadPMGVmffvpJRo4cxWGHHcF///sRc+fOYsKEq/jkk4945ZU3CQaDvP32W5x22pnMmvUUTz01A79/5xdjYWEhw4efwXHHDWb58i+YN28ud955P9Om3ceTT84mMzOTm2++ntNPPyvmsvr8/vtmnnpqNn6/n06dunDVVdfh81Vy3nlnMGLEGcyc+QQjR47i2GOP54knHmH9+vXsvffefPfd/9hvvwP48MNljBp1Uav/XYUQQrQuwzDIcNnIcNnonRt7boQqwXCEooqdyUFhuZ/tFQG2VyUNFQF+3V7Bit/8dSZUq2IxIMtlJgPZHjv5mS7SbAY57p1JQo4nWu62k+O245IWhqQmCYBoE098/VidZQfkH8gxXQfhD/mZ9e2MOuWHdjycwzsfQVmgjOe+f7ZW2RUHXtXoa9a8BWjt2l+ZPPlGZs+ex3ff/Y9169Yyd+4zhMNhsrNzyMzMonv3ntx003WccMIfGDbs1Hr326FDLnPnzuLFF58nEAjgcrkoKtqBw+EgJycHgPvvf5gdO7bXWdaQ/v0HYBgGTqeTkpJiLr98DDabjaKiHQD8+OMqrrnmerP+V1wDwLBhp7JkySL69RvApk0b6ddvQKN/F9G2+neQ90QI0XpsFoO8dCd56fX3T6gSCIXZEU0OirwBirxBirwBdngDFHsD5uOKAL9sK6ewzEexN1Bn9KMqTpuFbLedLJeNTLedTKeZsGQ6bWS6zJ8MV43l0Z90p7Q2JAJJAERK6NmzF06nky1bfsdms3PHHfeRl5dXa51p0x5F61W89947vPPOQh566PGY+3rllfnk5RUwefIdrFr1A9OnP4zFYiEcrv0tGWsZUKsDVzC482qMzWbeYvTVV8tZseJLpk+fic1mY+jQQfXu78gjj+Hpp59i+fIvOProY3fjLyLaygk9pBO5ECIx2K2WRjszA2RneygqqiAciVDmC7KjIlAjYfDXSRxKK4P8UlZBiS9IaWUAf31ZA2aPuvSaSYKzKlmwkeG0k+60kuaw1fqd7rCRFv2d7rRis1pa+C+Teto8AVBKPQQcCUSAa7TWX7R1DKLtNXTF3mF1NFiebk9v0hX/hpSUFFNYWEh+fgEDBgzkww8/4Mwzz2H58i8oLCxkv/3256OP/o9zzzVHDhoz5k8AGIaFYDBEzX+V4uIi+vQxZ3ddtmwpwWCQrKxswuEQW7duIS8vnxtvnMTkyXfEXObxpFFYuA2nsyvff/8tffuqWrEWFxdRUNARm83GRx8tIxQKEwgE6NdvACtWfMGQIScxa9ZTHHDAQRx22BEceOBBPPPMU0yZctce/Y2EEEKImiw1JlnruRvbVQZClFQGowlB0HxcGaDUZz4urQxSHH1eWhlkc6nPXM8XJBTjwtmunDYLaQ4r6U4baQ4raU4b6TF+52d7IBjCbbficVjw2K24HVbzt92Kx2HFnqLJRJsmAEqp44F9tNZHKaX6A7OBo9oyBpE6qvoAAPj9fiZNugG73c7YseO5++6pLF78LoZhcMstU8jLy+e7775hyZJF2O12Tj31NAAOOuhgLrroTzz88FNkZ2cD5m03d945haVLF3P22eexePEiFi5cwPXX38Stt94IwIkn/oGMjIyYy84++zxuvHESPXr0ZK+9eteJ+9BDj2DevLlMnDieQYOO5+ijj+Uf/7iHsWMv4+67/86//vUqHTt25JJLLo3u9yR++OF7unXr3up/U7H7qm5/29MkVgghkoXLbsVltzba0rCrSCSCP2S2OpT7Q9HfQcp8oZi/y30hyqK/f6vw13reeBphslkM3HYrbrsFj2NnYuC2W2snDLUSBwtuuxWXzYrLbsFls+Cs8dhlt+KyWRK6pcKINDJcVUtSSv0dWKe1nhV9vgo4XGtdUrXO1q2lzQ6oqskq2Uk9Ekui1+OZZ2bQqVPn6qSlPolej92RTHVpKAFobj3y8zPkBlrkeAFSj0Qj9UgMkUiEikAIq8vB79vK8AZCVARCeP3h6O/o80CICv8uv6vLw7WWewMhmtA4UYvVYkSTg51JgctuNZ/XWmbBZYsujz6u+t09x81xAzq1+LGirW8B6gQsr/F8a3RZdQKQnu7EZmtez3Kr1UJ2tmePAkwEUo/Eksj1mDDhclwuF9deezVWa8P/N4lcj92VTHW5ZfCN9ZYlUz2EECJZGIZBmsNGdqYLV7jufArNEYlE8AXD1UlChT+ELxjGFwxTGQhTGQxV/27KspLKIFvKfNFlYSoD5jrBXbIMh9Xgf7d1bJE61BTvTsB1MpOyMl+zd5bsGWsVqUdiSeR63HPPgwCUljb+f5PI9dhd7aUue9AC0ArRCCGEqI9hGNW3NuW04usEQ9GEIBjGFwyRZrdhtbR8o29bJwAbMa/4V+kCbGrjGIQQQgghhEg4NquFdKuFJozqukfaunfCIuAcAKXUwcBGrXVpG8cghBBCCCFEymrTBEBr/QmwXCn1CfAocGVbvr4QQgghhBCprs37AGitb2rr1xRCCJF8ZN4YIYRoHYk7QKkQQoiUVXPeGGAsZquxEEKIFiAJgBBCiEQ0BHgDQGu9EshRSmXGNyQhhGgf4j0MqBBCCBFLo/PGZJ3xxzob+U47k8oxl0JFBVkXnlOnvHLkKHwjR8G2bWSdE6P84rH4zjgby4b1ZFw5vk65d8JV+E8+Beua1aT/5Zo65RWTbiBw/AlYv/0f6ZPr3vFafssUgocfge3zz0i7e2qd8rI77iW03/7Yly3F89ADdcv/8QihvffB8e5/cD/5GFabhazgznHOSx+fSbhrN5xvvIZrzjN1ti955nkiubk4X5qH66V5dcqL578KHg+u2U/jXPCvuuVvvA2A+/FHcbz3Tu1Cl4vil14HwDPtPuwfLqtVHMnpQMmzLwCQduft2L78vLrMarOQkd+J0idnmeW33ojtu29rbR/qszdl08yGoPTrr8b605pa5cGB+1F+530AZEwYh2XTxtrlhx5O+a23A5B5yZ8wdmyvVR4YdDwV15vzdmSNPAsqK2uV+4cOw3vl1WZ5PZ89rrum0c+eUVhI5tjRdcsT6LNnfWxarc8V1P3s7SoRP3tV/x8NffYAwp27JPRnz3LaCBgzwSzfne+9jz+ss24VSQCEEEIkgzoDYVutFoxdllo9DlzZHnCYB/9deTwO3NkerDsqIWa5E3e2B0rdMbdPS3PgyfZAhitmeXq6k0gD5RkZZrmR4cQSs9wF2R6M9EbK0xxYbBYMw8BWY73MTLdZ7om9fVZWVbkjZnl2tgc8HiweB0Z95YDFba9bbrfuLHc1Uu601So3DAOHw1ajvO72NocNW7Tc6rDVef+sTjv2BsttO8vt1rrlLjuOmuXBXcrddpxV5TH+NlaPAyM6uV9Dnz2CFfWUJ85nb9fPVa3ytNifnUT87FXXo4HPHgAJ/tnDYlTHV99nr6HvvViMSKTZM6kLIYQQrUIpdTuwSWs9I/r8Z+AAGTpaCCH2nPQBEEIIkYhk3hghhGgl0gIghBAiISml7gWOA8LAlVrrb+IckhBCtAuSAAghhBBCCJFC2k0n4GSdMEYpNRj4J/B9dNG3wP3A84AV2ASM1lr74hJgI5RSA4E3gYe01tOVUt2JEbtSahRwLeaVvJla67pDBMRZjLrMAQ4BCqOrPKC1XpjodVFK3Q8Mwvz/vgf4giR8T2LU4zSS7P1QSnmAOUBHwAXcAXxDEr4f7UWyHitAjheJQo4VCV8POVY0QbvoA9AOJoxZprUeHP25Cvg78LjWehCwBhgT3/BiU0qlAY8BS2osrhN7dL3bgD8Ag4FJSqkObRxug+qpC8DNNd6bhYleF6XUCcDA6P/CMOBhkvA9qacekGTvBzAC+FJrfTxwHvAgSfh+tBft4FgBcryIKzlWJEU9IMneD+JwrGgXCQDtb8KYwcCC6OO3MN/oROQD/gjUHPB2MHVjPwL4QmtdrLX2Ah8Dx7RhnE0Rqy6xJHpd/g84N/q4CEgjOd+TWPWwxlgvoeuhtX5Za31/9Gl3YD3J+X60F+3tWAFyvGhrcqxI/HrIsaIJ2sstQI1OGJPgBiilFgAdgKlAWo0m3C1A57hF1gCtdRAIKqVqLo4VeyfM94RdlieMeuoCMFEpdR1mzBNJ8LporUNAefTpWOBt4ORke0/qqUeIJHs/qiilPgG6AcOBxcn2frQjyX6sADlexJUcK5KiHnKsaIL20gKwqzoTxiSw1Zhf4qcDfwaeoXZilkx12VV9sSdLnZ4HbtJanwh8DdweY52ErItS6nTML8OJuxQl1XuySz2S9v3QWh+NeV/qC9SOManej3Yo2f7OcrxITEn73STHisTSlseK9pIAbMTMiqp0wewwkfC01huiTT8RrfVPwGbMZml3dJWuNN7UmEjKYsS+6/uTFHXSWi/RWn8dfboA2I8kqItS6mTgb8ApWutikvQ92bUeyfh+KKUOiXZ0JBq7DShNxvejnUjaYwXI8SJRJeN3E8ixggSqRzyOFe0lAUjaCWOUUqOUUn+JPu6E2QP8WeDs6CpnA+/EKbzmWEzd2D8DDlNKZSul0jHvV/swTvE1mVLqNaVU7+jTwcB3JHhdlFJZwAPAcK319ujipHtPYtUjGd8PzDHsrwdQSnUE0knC96MdSdpjBcjxIlEl43eTHCsSqx565pncAAADOklEQVTE4VjRbuYBUEk6YYxSKgOYD2QDDszm3a+A5zCHgloLXKK1DsQtyHoopQ4BpgG9gACwARiFOZRVrdiVUucAN2AOvfeY1npePGKuTz11eQy4CagAyjDrsiWR66KUGo/Z3PljjcV/BmaRRO9JPfV4FrN5N5neDzfmbRrdATfm//eXxPj/TuR6tCfJeqwAOV4kAjlWJEU95FjRBO0mARBCCCGEEEI0rr3cAiSEEEIIIYRoAkkAhBBCCCGESCGSAAghhBBCCJFCJAEQQgghhBAihUgCIIQQQgghRAqxNb6KEMlNKdUL+BZYvkvRWTXGP27Ofm8Htmmtpzc/OiGEEIlCjhciVUgCIFKF1loPjncQQgghEp4cL0S7JwmASFlKqTmYk4T0A/IwJ9n4Sil1DTAyutobWuv7lFI9gbmAFXNCjj9Hywcqpf4N7ANco7V+Ryn1KHBodN3/b+/uQZwKojAMvwG1FcTWQiy+UtxGXEwjIiyKrSIilmKhnZ2/oGBjYSOIqK0/jWBpoaIoCNoJx0oFt7QUxNVY5C6EuJ3urnvnfWCYhGRuZorkcO65d3Kjqu6u1JokSf+e8UJ94z0Aat26qtoLnAXOJdkKHAeGXTuUZBtwGbhWVUNgnvEPNsDmqjoAnAJOJNkE7K+qWWA3sH5FVyNJWi7GC/WGFQC1IkmeTjyvrn/S9a+Aq8AO4HVVLXSDXgLbgRngNEBVnelemwNedOO/ABur6muSD0keAQ8Y/423JGntMF6o90wA1Io/runsSrqLVbABMOraYOJtG4BfwE+WrpgtTDwedB80l2QGOAIcA/b9/fQlSSvEeKHeMwFQ64bAfWAX8B54B1xIsvjd2AlcAd4Ae4B7SS4Bz5c6WLeDxMGqug68TTK9k4QkaW0yXqg3TADUiumSLsA34Ed3U9YW4GhVfUxyE3jG+AzOrar6lOQ8cCfJSeAzcJHxNZvT5oHZJIeB78Dt5VmOJGmZGC/Ue4PRaLTac5BWRVfSfVhVj1d7LpKk/5fxQn3jLkCSJElSQ6wASJIkSQ2xAiBJkiQ1xARAkiRJaogJgCRJktQQEwBJkiSpISYAkiRJUkNMACRJkqSG/AbDfH+MfYfc0QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "learning_rates = [0.1, 1, 10]\n", + "for lr in learning_rates:\n", + " mnist_model.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=lr,\n", + " batch_size=len(small_training_data[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mini-Batch Gradient Descent" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "learning_rates = [0.1, 1, 10]\n", + "for lr in learning_rates:\n", + " mnist_model.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=lr,\n", + " batch_size=64)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + "From the above table and plots, we can see the differences between the implementations of the gradient descent algorithm. The reasons for our choice to implement the mini-batch gradient descent are clear from the results: the general batch gradient descent is too slow in converging compared to the others and it does not tolerate great learning rates, the stochastic gradient descent is very fast but the mini batch is more stable: it oscillates less around the optimal solution.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.1.3: Do the same with 15 and 75 hidden neurons." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define a neural network with 15 hidden neurons\n", + "mnist_model = NeuralNetwork(input_layer_size = 784, \n", + " hidden_layer_size = 15,\n", + " output_layer_size = 10, \n", + " transfer_f = sigmoid, \n", + " transfer_df = dsigmoid)\n", + "\n", + "# train the neural network with different learning rates and show accuracy on test data\n", + "for lr in learning_rates:\n", + " mnist_model.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=lr, \n", + " batch_size=64)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define a neural network with 75 hidden neurons\n", + "mnist_model = NeuralNetwork(input_layer_size = 784, \n", + " hidden_layer_size = 75,\n", + " output_layer_size = 10, \n", + " transfer_f = sigmoid, \n", + " transfer_df = dsigmoid)\n", + "\n", + "# train the neural network with different learning rates and show accuracy on test data\n", + "for lr in learning_rates:\n", + " mnist_model.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=lr, \n", + " batch_size=64)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.1.5: Explain the results you obtained at Questions 2.1.2, 2.1.3 and 2.1.4." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "The table above shows the different performances in terms of accuracy of the implemented neural networks. It is clear that the network with 75 hidden neurons performs better than the others because a larger number of hidden neurons makes the model more elastic, therefore it can adapt better to the problem (even if we could risk some overfitting).

\n", + "\n", + "The plots give us more insights about the situation: the 75-hidden-neurons neural network converges faster to a low error and high accuracy. Moreover, the other models generally oscillate in a pretty wide neighbourhood of the optimum when using a too high learning rate (10) while it is able to handle it and get a good accuracy anyway.

\n", + "\n", + "In the last plots, regarding the very small dataset, we can see how the learning rate plays a key role in the training of the model: the accuracy on validation data is generally small because of the size of the training set, but the accuracy on the training data is able to reach the top percentages only when the learning rate is sufficently high. An analogous comment can be made regarding the loss of the model.
\n", + "Finally, this last plots, prove again that an higher number of hidden neurons is able to converge with higher learning rates.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.1.6: Among all the numbers of hidden neurons and learning rates you tried in previous questions, which ones would you expect to achieve best performances on the whole dataset? Justify your answer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "According to the previous results and comments we decided to take 75 hidden neurons to have higher accuracy and robustness, and (after some testing) a learning rate of 1.2, that is neither too low, risking not to converge, nor too high, risking to diverge.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Part 2 (optional): Another loss function\n", + "\n", + "In classification problems, we usually replace the sigmoids in the output layer by a \"softmax\" function and the MSE loss by a \"cross-entropy\" loss. More formally, let $u = (u_1, ..., u_n)$ be the vector representing the activation of the output layer of a Neural Network. The output of that neural network is $o = (o_1, ..., o_n) = \\textrm{softmax}(u)$, and\n", + "\n", + "
$\\textrm{softmax}(u) = (\\frac{e^{u_1}}{\\sum_{k=1}^n e^{u_k}}, ..., \\frac{e^{u_n}}{\\sum_{k=1}^n e^{u_k}})$.
\n", + "\n", + "If $t = (t_1, ..., t_n)$ is a vector of non-negative targets such that $\\sum_{k=1}^n t_k = 1$ (which is the case in classification problems, where one target is equal to 1 and all others are equal to 0), then the cross-entropy loss is defined as follows:\n", + "\n", + "
$L_{xe}(o, t) = - \\sum_{k=1}^n t_k\\log(o_k)$.
\n", + "\n", + "Question 2.2.1: Let $L_{xe}$ be the cross-entropy loss function and $u_i$, $i \\in \\lbrace 1, ..., n \\rbrace$, be the activations of the output neurons. Let us assume that the transfer function of the output neurons is the softmax function. Targets are $t_1, ..., t_n$. Derive a formula for $\\frac{\\partial L_{xe}}{\\partial u_i}$ (details of your calculations are not required)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Answer:
\n", + "The derivative of the softmax function is:

\n", + "$$ \\dfrac{\\partial{f(u_i)}}{\\partial{u_i}} = f(u_i) (\\delta_{ij} - f(u_i)),\\qquad where\\ Kronecker\\ delta\\ \n", + "\\delta_{ij} = \\begin{cases}\n", + " 1,\\quad i = j\\\\\n", + " 0,\\quad i \\ne j\n", + "\\end{cases}$$
\n", + "Therefore, the derivative of the cross-entropy loss function can be computed as follows:

\n", + "$$\\frac{\\partial L_{xe}}{\\partial u_i} = -\\underset{k}{\\sum}t_k\\dfrac{\\partial log(f(u_k))}{\\partial u_i} =$$\n", + "$$ = -\\underset{k}{\\sum}t_k\\dfrac{\\partial log(f(u_k))}{\\partial f(u_k)}\\times\\dfrac{\\partial f(u_k)}{\\partial u_i} =$$\n", + "$$ = -\\underset{k}{\\sum}t_k\\dfrac{1}{f(u_k)}\\times\\dfrac{\\partial f(u_k)}{\\partial u_i} $$
\n", + "The result above can be splitted knowing the derivative of the softmax function:

\n", + "$$ \\frac{\\partial L_{xe}}{\\partial u_i} = -t_i(1 - f(u_i)) - \\underset{k\\ne i}{\\sum}t_k\\dfrac{1}{f(u_k)}(-f(u_k)\\cdot f(u_i)) =$$\n", + "$$ =-t_i + t_i\\cdot f(u_i)) + \\underset{k\\ne i}{\\sum}t_k\\cdot f(u_i)) =$$\n", + "$$ = f(u_i)\\left( t_i + \\underset{k\\ne i}{\\sum}t_k\\right) - t_i $$
\n", + "Since $\\sum_k t_k = 1$, we can finally write:

\n", + "$$\\frac{\\partial L_{xe}}{\\partial u_i} = f(u_i) -t_i $$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.2.2: Implement a new feedforward() function and a new backpropagate() function adapted to the cross-entropy loss instead of the MSE loss." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.2.3: Create a new Neural Network with the same architecture as in Question 2.1.1 and train it using the softmax cross-entropy loss." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(89.0, 14.52992844581604)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define a neural network with 30 hidden neurons\n", + "mnist_model_xe = NeuralNetwork(input_layer_size = 784, \n", + " hidden_layer_size = 30,\n", + " output_layer_size = 10, \n", + " transfer_f = sigmoid, \n", + " transfer_df = dsigmoid)\n", + "\n", + "# train the neural network with different learning rates and show accuracy on validation data\n", + "mnist_model_xe.train(small_training_data, \n", + " small_validation_data, \n", + " epochs=300, \n", + " learning_rate=1, \n", + " batch_size=64,\n", + " softmax_output=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "87.63\n" + ] + } + ], + "source": [ + "print(mnist_model_xe.accuracy(test_data, True))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Question 2.2.4: Compare your results with the MSE loss and with the cross-entropy loss." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " Answer: It's possible to notice how the last implementation, the one using the cross entropy and soft-max is faster in reaching a neighbourhood of the optimum. But it looses a couple of percentage point on the validation data accuracy. This maybe due to the fact that this new model may need different parameters settings to work at this best. Furthermore also the error goes down faster and more smoothly with respect to the previous implementation.

\n", + "\n", + "A final remark has to be made regarding the accuracy of our model which is confirmed on the test data, in fact the difference in accuracy between test data and validation data is just 0.08.\n", + "\n", + "
\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
THE END!" + ] + } + ], + "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.6.3" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LAB1_FCNN/NeuralNetwork.py b/LAB1_FCNN/NeuralNetwork.py new file mode 100644 index 0000000..96602a5 --- /dev/null +++ b/LAB1_FCNN/NeuralNetwork.py @@ -0,0 +1,113 @@ +import time +import random +import numpy as np +from utils import * +from transfer_functions import * +import matplotlib.pyplot as plt +plt.style.use('seaborn-darkgrid') + +class NeuralNetwork(object): + + def __init__(self, + input_layer_size, + hidden_layer_size, + output_layer_size, + transfer_f=sigmoid, + transfer_df=dsigmoid): + """ + input_layer_size: number of input neurons + hidden_layer_size: number of hidden neurons + output_layer_size: number of output neurons + iterations: number of iterations + learning_rate: initial learning rate + """ + + # initialize transfer functions + self.transfer_f = transfer_f + self.transfer_df = transfer_df + + # initialize layer sizes + self.input_layer_size = input_layer_size+1 # +1 for the bias node in the input Layer + self.hidden_layer_size = hidden_layer_size+1 # +1 for the bias node in the hidden layer + self.output_layer_size = output_layer_size + + # initialize arrays for activations + self.u_hidden = np.zeros(self.hidden_layer_size-1) + self.u_output = np.zeros(self.output_layer_size) + + # initialize arrays for outputs + self.o_input = np.ones(self.input_layer_size) + self.o_hidden = np.ones(self.hidden_layer_size) + self.o_output = np.ones(self.output_layer_size) + + # initialize arrays for partial derivatives according to activations + self.dE_du_hidden = np.zeros(self.hidden_layer_size-1) + self.dE_du_output = np.zeros(self.output_layer_size) + + # create randomized weights Yann LeCun method in 1988's paper (Default values) + self.initialize_weights() + + def initialize_weights(self, wi=None, wo=None): + input_range = 1.0 / self.input_layer_size ** (1/2) + + # initialize weights between input and hidden layer + if wi is not None: + self.W_input_to_hidden = wi + else: + self.W_input_to_hidden = np.random.normal(loc = 0, + scale = input_range, + size = (self.input_layer_size, + self.hidden_layer_size-1)) + + # initialize weights between hidden and output layer + if wo is not None: + self.W_hidden_to_output = wo + else: + self.W_hidden_to_output = np.random.uniform(size = (self.hidden_layer_size, + self.output_layer_size) + ) / np.sqrt(self.hidden_layer_size) + + def accuracy(self, test_data,sm_xe): + """ Returns percentage of well classified samples """ + + # compute the predictions + self.feedforward(test_data[0],sm_xe) + + # count correct predictions + target = np.argmax(test_data[1], axis=1) + prediction = np.argmax(self.o_output, axis=1) + count = np.sum(target == prediction) + + return count * 100 / len(test_data[0]) + + def plot_curves(self, train_accuracies, val_accuracies, errors, learning_rate, best_acc_it): + + # get x axis + iterations = np.arange(len(train_accuracies)) + + _, ax = plt.subplots(1, 2, figsize=(13, 4)) + + # plot accuracies curve + ax[0].plot(iterations, train_accuracies, label="Training data", color="blue") + ax[0].plot(iterations, val_accuracies, label="Validation data", color="orange") + best_accuracy = val_accuracies[best_acc_it] + ax[0].plot([0, best_acc_it, best_acc_it], [best_accuracy, best_accuracy, 0], color="green", ls="--", alpha=0.6, label="Best accuracy") + ax[0].legend() + # ax[0].grid() + ax[0].set_title("Accuracy learning curve") + ax[0].set_xlabel("Epochs") + ax[0].set_ylabel("Accuracy [%]") + + # plot MSE curve + ax[1].plot(iterations, errors, label="Mean Squared Error") + ax[1].legend() + # ax[1].grid() + ax[1].axhline(y=0, color="red", ls="--") + ax[1].set_title("Mean Squared Error learning curve") + ax[1].set_xlabel("Epochs") + ax[1].set_ylabel("MSE") + + plt.suptitle('Hidden Layer Size: {} - Learning Rate: {} - Accuracy: {} %'.format(self.hidden_layer_size-1, learning_rate, best_accuracy)) + plt.show() + + diff --git a/LAB1_FCNN/__pycache__/NeuralNetwork.cpython-36.pyc b/LAB1_FCNN/__pycache__/NeuralNetwork.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..516c1047ffbf4c0499889905bb32d4de5254c1bb GIT binary patch literal 3187 zcmZ`5+ioMbm7JSKk|kf(^{#h|V3Ov73E&8Af)-d5-CVk9A2vd<-Xy>z!C)j(qmf55 z3Q4VPRetim`Vaa8{UyG%KpqOe*o*(Sg1TkJY_8%wIp-pl*@8a~iurWFMNp0c zGZz$a^-8(nZRx#7=f{Ri{ z{yeUhAXaf|r!2UP8f9$6M}AqeXuv8K@aU&8TQ9Atdih>`Eih4h%CmH=Waw!}@_Zy3 za3$d*Xd-YCphy0jh#lyD9{0YKT*zLYB}F;`uo#y`+WRY)C#szFhUHvH-b*tzo)6-g zC?|ZVdjF{Uqi4wgIQi`8S*_;Yvrj(#ef;@n{eJI8FnlmO*M1Dw%Tye;@XH4P2pGYqzU5PkI&{zAXrx7O(V=L9m`g}Zc_vrm*;$v_K$?%hQ% zc+S;a6f&4`G313xQjXc_l;?Rc%o8cIQN~#ylj$tyGBAcQb_!|aBxjktW^lUDi`pa3 z8EEh{5vJh?Zz*;_QIm@6fJw+w)hf>vDqZ7|%wve*{NUWCE_aq?hnr zcnaMd6w4l=YkzB9G%oz5&%8r)We?P6s@9c5$;PM!wXMyXX4G1`hvcHUnq?joDmS&4 z&1I8$sm-=nhjrOD+qv@AGCV9F^@;}D#e!T@KHJ-%n(SUpfg_mn*leHu=E^qwIJT06 zcnj+60qk~vW4^&2Y)E)59r>H=5a&PxZT4`o1uoaY;tA!pd1)RAFw-@K4xQ(>ed7n> z9_aEKZG4Rm3vY$SC`&O`jjt>^FGK>4UZerqT04V$&O=MPc{1QR+BYx7V*9Hk&tM)* zUa@(l2{Y}cg7acw9UY|~n)bt!MdwrSoM2^Fh|>39Uv1@5yGcG9C*ob87xzD@edKkm z0-t%wBk$>~9FFB;Yt8V@JKrt#zTim_9DhGg!1;owLX-k>4NB5Bj6g1;=Vl}EK1zS{ zF8l3$>@SX=E*}5g6!hR3z5#+`^9K0mMQ{|X5`OU9)KxRKI?&?)$ag|Zyaii{-vJ1> z*CA!H&l~1kvs^{KoDXJssbu6}r@fq~ykNR1xr$Y$avrr1Ju~{Q@be09BxmD1D>%xS z8CLCK3QUwqlaK_*48KU+8;~dt- z8HD!hcZa62wvw}`vzj*neLK?Ic&XSJP9DRh<=X&=-L>}Z1A0Jx`YzqFs=;B$J3I{bHume7fgc5ZztdiIX(+E6^4W9JmmnVj(UZ5MM>TP+3U8r5q|ZvrQZl+uF6Iq;gN? z$`9c$`O2v`Zb)2UW*wWfB93Nf*PflX@9j*UcDwDtpI@KP1!F(h(t~UE3Qd2+0T}QJ zJLVw3`pS+4*x;bIpaD(vHn`A2??4+m=o_#GUGz=31?%Wt*nmy+E!cu>^ljiDSig6L znVCP}9uB~Pr)VfI*};`2!5DYBYNM}FNg+Zu zsPv_j@seccKIWz)6?Pg#Bg7-18z_pBZ=hAAXkDjYNs1`tyvKG+Qi=i*fHp4(sTR&} zfE5nVNp9npe|*+(RRacceD)^P(&ig{}Z}fDj*IKqV;kX-$#NO`TvU9^!-q zMH6TinoXsTT`j(eoQ)l@_V7$YaVfBFXwCN+tuAPfiOow%?DCY@=yos*wK9JIjjD*l zi7c8*n(HYnolO;0h+4;??xJ@$ORlNovveBF9%0m?=$>&!rPA*dPLxfPxyf(3*)*4_ tVnt=5sEQO_t|Gw|X<)W4fshQU?APbh7_y0cL8sCrt}9%p{@FOQ{sLF!>p}nk literal 0 HcmV?d00001 diff --git a/LAB1_FCNN/__pycache__/utils.cpython-36.pyc b/LAB1_FCNN/__pycache__/utils.cpython-36.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d1088ea77f45a074af2e694eed7b32994c8cd0c0 GIT binary patch literal 2300 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 literal 0 HcmV?d00001 diff --git a/LAB1_FCNN/images/mnist.png b/LAB1_FCNN/images/mnist.png new file mode 100644 index 0000000000000000000000000000000000000000..5ba7da5a5c5e1162589f0ddc5a4f49dadf98c7af GIT binary patch literal 43617 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 Learning \n", + "

Convolutional Neural Network (CNN) for Handwritten Digits Recognition

" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The aim of this session is to practice with Convolutional Neural Networks. Each group should fill and run appropriate notebook cells. \n", + "\n", + "\n", + "Generate your final report (export as HTML) and upload it on the submission website http://bigfoot-m1.eurecom.fr/teachingsub/login (using your deeplearnXX/password). Do not forget to run all your cells before generating your final report and do not forget to include the names of all participants in the group. The lab session should be completed and submitted by May 30th 2018 (23:59:59 CET)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the previous Lab Session, you built a Multilayer Perceptron for recognizing hand-written digits from the MNIST data-set. The best achieved accuracy on testing data was about 97%. Can you do better than these results using a deep CNN ?\n", + "In this Lab Session, you will build, train and optimize in TensorFlow one of the early Convolutional Neural Networks, **LeNet-5**, to go to more than 99% of accuracy. \n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/liangjianzhong/Desktop/course/github_project/Project-Lab/Deep-Learning/LAB2_CNN\r\n" + ] + } + ], + "source": [ + "!pwd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load MNIST Data in TensorFlow\n", + "Run the cell below to load the MNIST data that comes with TensorFlow. You will use this data in **Section 1** and **Section 2**." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting MNIST_data/train-images-idx3-ubyte.gz\n", + "Extracting MNIST_data/train-labels-idx1-ubyte.gz\n", + "Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n", + "Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n", + "Images Shape: (28, 28, 1)\n", + "Training Set: 55000 samples\n", + "Validation Set: 5000 samples\n", + "Test Set: 10000 samples\n" + ] + } + ], + "source": [ + "# SUPPRESS WARNINGS\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# IMPORT LIBRARIES\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "from time import time\n", + "from tensorflow.examples.tutorials.mnist import input_data\n", + "\n", + "\n", + "# LOAD DATA (RESHAPING THE IMAGES)\n", + "mnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\n", + "X_train, y_train = mnist.train.images.reshape((-1,28,28,1)), mnist.train.labels\n", + "X_val, y_val = mnist.validation.images.reshape((-1,28,28,1)), mnist.validation.labels\n", + "X_test, y_test = mnist.test.images.reshape((-1,28,28,1)), mnist.test.labels\n", + "\n", + "\n", + "# PRINT SHAPES\n", + "print(\"Images Shape: {}\".format(X_train[0].shape))\n", + "print(\"Training Set: {} samples\".format(len(X_train)))\n", + "print(\"Validation Set: {} samples\".format(len(X_val)))\n", + "print(\"Test Set: {} samples\".format(len(X_test)))\n", + "\n", + "\n", + "# DECLARE NOISE\n", + "epsilon = 1e-10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Section 1 : Neural Network in TensorFlow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before starting with CNN, let's train and test in TensorFlow the example\n", + "**y=softmax(Wx+b)** seen in the first lab. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 01 =====> Loss= 1.288826695\n", + "Epoch: 02 =====> Loss= 0.732409473\n", + "Epoch: 03 =====> Loss= 0.600389052\n", + "Epoch: 04 =====> Loss= 0.536720089\n", + "Epoch: 05 =====> Loss= 0.497859464\n", + "Epoch: 06 =====> Loss= 0.471154518\n", + "Epoch: 07 =====> Loss= 0.451148307\n", + "Epoch: 08 =====> Loss= 0.436046376\n", + "Epoch: 09 =====> Loss= 0.423529351\n", + "Epoch: 10 =====> Loss= 0.413163693\n", + "Epoch: 11 =====> Loss= 0.404344185\n", + "Epoch: 12 =====> Loss= 0.396952076\n", + "Epoch: 13 =====> Loss= 0.390443056\n", + "Epoch: 14 =====> Loss= 0.384207741\n", + "Epoch: 15 =====> Loss= 0.379257517\n", + "Epoch: 16 =====> Loss= 0.374483205\n", + "Epoch: 17 =====> Loss= 0.370433719\n", + "Epoch: 18 =====> Loss= 0.366613644\n", + "Epoch: 19 =====> Loss= 0.362859343\n", + "Epoch: 20 =====> Loss= 0.359751099\n", + "Epoch: 21 =====> Loss= 0.356533978\n", + "Epoch: 22 =====> Loss= 0.353698811\n", + "Epoch: 23 =====> Loss= 0.351298389\n", + "Epoch: 24 =====> Loss= 0.348955568\n", + "Epoch: 25 =====> Loss= 0.346460257\n", + "Epoch: 26 =====> Loss= 0.344384526\n", + "Epoch: 27 =====> Loss= 0.342060804\n", + "Epoch: 28 =====> Loss= 0.340382500\n", + "Epoch: 29 =====> Loss= 0.338404959\n", + "Epoch: 30 =====> Loss= 0.336811813\n", + "Epoch: 31 =====> Loss= 0.335328057\n", + "Epoch: 32 =====> Loss= 0.333329280\n", + "Epoch: 33 =====> Loss= 0.332088111\n", + "Epoch: 34 =====> Loss= 0.330364238\n", + "Epoch: 35 =====> Loss= 0.329204523\n", + "Epoch: 36 =====> Loss= 0.327845818\n", + "Epoch: 37 =====> Loss= 0.326596685\n", + "Epoch: 38 =====> Loss= 0.325374669\n", + "Epoch: 39 =====> Loss= 0.324305523\n", + "Epoch: 40 =====> Loss= 0.322998705\n", + "Optimization Finished!\n", + "Accuracy: 0.9152\n" + ] + } + ], + "source": [ + "# PARAMETERS\n", + "learning_rate = 0.01\n", + "training_epochs = 40\n", + "batch_size = 128\n", + "display_step = 1\n", + "logs_path = 'log_files/softmax' # useful for tensorboard\n", + "\n", + "\n", + "# PLACEHOLDERS\n", + "# Images with 784 pixels\n", + "x = tf.placeholder(tf.float32, [None, 784], name='InputData')\n", + "# 0-9 digits recognition, 10 classes\n", + "y = tf.placeholder(tf.float32, [None, 10], name='LabelData')\n", + "\n", + "\n", + "# WEIGHTS AND BIAS\n", + "W = tf.Variable(tf.zeros([784, 10]), name='Weights')\n", + "b = tf.Variable(tf.zeros([10]), name='Bias')\n", + "\n", + "\n", + "# MODEL ARCHITECTURE\n", + "# Model (softmax activation)\n", + "with tf.name_scope('Model'):\n", + " pred = tf.nn.softmax(tf.matmul(x, W) + b)\n", + "\n", + "# Loss function (cross-entropy)\n", + "with tf.name_scope('Loss'):\n", + " cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(tf.clip_by_value(pred, epsilon, 1.0)), reduction_indices=1))\n", + " \n", + "# Optimizer (SGD)\n", + "with tf.name_scope('SGD'):\n", + " optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)\n", + " \n", + "# Accuracy\n", + "with tf.name_scope('Accuracy'):\n", + " acc = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n", + " acc = tf.reduce_mean(tf.cast(acc, tf.float32))\n", + "\n", + "\n", + "# INIT SUMMARY\n", + "init = tf.global_variables_initializer()\n", + "tf.summary.scalar(\"Loss\", cost)\n", + "tf.summary.scalar(\"Accuracy\", acc)\n", + "merged_summary_op = tf.summary.merge_all()\n", + "\n", + "\n", + "# LAUNCH THE SESSION\n", + "with tf.Session() as sess:\n", + " \n", + " sess.run(init)\n", + " summary_writer = tf.summary.FileWriter(logs_path, graph=tf.get_default_graph())\n", + " \n", + " for epoch in range(training_epochs):\n", + " \n", + " avg_cost = 0.\n", + " total_batch = int(mnist.train.num_examples/batch_size)\n", + " \n", + " for i in range(total_batch):\n", + " \n", + " batch_xs, batch_ys = mnist.train.next_batch(batch_size, shuffle=(i==0))\n", + "\n", + " _, c, summary = sess.run([optimizer, cost, merged_summary_op],\n", + " feed_dict={x: batch_xs, y: batch_ys})\n", + " \n", + " summary_writer.add_summary(summary, epoch * total_batch + i)\n", + " \n", + " avg_cost += c / total_batch\n", + " \n", + " if (epoch+1) % display_step == 0:\n", + " print(\"Epoch:\", '%02d' % (epoch+1), \" =====> Loss=\", \"{:.9f}\".format(avg_cost))\n", + "\n", + " print(\"Optimization Finished!\")\n", + " summary_writer.flush()\n", + "\n", + " print(\"Accuracy:\", acc.eval({x: mnist.test.images, y: mnist.test.labels}))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "
Figure 1: accuracy and loss
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Section 2 : The 99% MNIST Challenge!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Part 1 : LeNet5 implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The LeNet architecture takes a 28x28xC image as input, where C is the number of color channels. Since MNIST images are grayscale, C is 1 in this case.\n", + "\n", + "--------------------------\n", + "**Layer 1 - Convolution (5x5):** The output shape should be 28x28x6. **Activation:** ReLU. **MaxPooling:** The output shape should be 14x14x6.\n", + "\n", + "**Layer 2 - Convolution (5x5):** The output shape should be 10x10x16. **Activation:** ReLU. **MaxPooling:** The output shape should be 5x5x16.\n", + "\n", + "**Flatten:** Flatten the output shape of the final pooling layer such that it's 1D instead of 3D. You may need to use tf.reshape.\n", + "\n", + "**Layer 3 - Fully Connected:** This should have 120 outputs. **Activation:** ReLU.\n", + "\n", + "**Layer 4 - Fully Connected:** This should have 84 outputs. **Activation:** ReLU.\n", + "\n", + "**Layer 5 - Fully Connected:** This should have 10 outputs. **Activation:** softmax.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def Conv_layer(inputs, size_in, size_out, padding1, padding2):\n", + " w = tf.Variable(tf.truncated_normal([5, 5, size_in, size_out], stddev=0.1), name=\"W\")\n", + " b = tf.Variable(tf.constant(0.1, shape=[size_out]), name=\"b\")\n", + " conv = tf.nn.conv2d(inputs, w, strides=[1, 1, 1, 1], padding= padding1)\n", + " act = tf.nn.relu(conv + b)\n", + " tf.summary.histogram(\"weights\", w)\n", + " tf.summary.histogram(\"biases\", b)\n", + " tf.summary.histogram(\"activations\", act)\n", + " return tf.nn.max_pool(act, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding= padding2)\n", + "\n", + "def FC_layer(inputs, size_in, size_out, act = 'relu'):\n", + " w = tf.Variable(tf.truncated_normal([size_in, size_out], stddev=0.1), name=\"W\")\n", + " b = tf.Variable(tf.constant(0.1, shape=[size_out]), name=\"b\")\n", + " if act == 'softmax':\n", + " act = tf.nn.softmax(tf.matmul(inputs, w) + b)\n", + " else:\n", + " act = tf.nn.relu(tf.matmul(inputs, w) + b)\n", + " tf.summary.histogram(\"weights\", w)\n", + " tf.summary.histogram(\"biases\", b)\n", + " tf.summary.histogram(\"activations\", act)\n", + " return act" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def LeNet5_Model(images, dropout_rate = 1): \n", + " \n", + " # --- INTERNAL MODEL DEFINITION --- #\n", + " with tf.name_scope(\"LeNet5\"):\n", + " # CONVOLUTIONAL 1 LAYER\n", + " with tf.name_scope(\"Conv1\"):\n", + " # Convolution (28x28x1 -> CONV1 -> 28x28x6 -> MAXPOOL1 -> 14x14x6)\n", + " pool1 = Conv_layer(inputs=images, size_in = 1, size_out = 6, padding1 = 'SAME', padding2 = 'VALID')\n", + "\n", + " # CONVOLUTIONAL 2 LAYER\n", + " with tf.name_scope('Conv2'):\n", + " # Convolution (14x14x6 -> CONV2 -> 10x10x16 -> MAXPOOL2 -> 5x5x16)\n", + " pool2 = Conv_layer(inputs=pool1, size_in = 6, size_out = 16, padding1 = 'VALID', padding2 = 'VALID')\n", + " \n", + " # FLATTEN LAYER\n", + " with tf.name_scope('Flatten'):\n", + " # Flatten (5x5x16 -> 400)\n", + " flat = tf.contrib.layers.flatten(pool2)\n", + " if dropout_rate < 1:\n", + " flat = tf.nn.dropout(x=flat,keep_prob = dropout_rate)\n", + " \n", + " # FULLY CONNECTED LAYER 3\n", + " with tf.name_scope('FC1'):\n", + " # Activation (400 -> FC3 -> 120)\n", + " hidden3 = FC_layer(flat, 400, 120, act = 'relu')\n", + " if dropout_rate < 1:\n", + " hidden3 = tf.nn.dropout(x=hidden3,keep_prob = dropout_rate) \n", + " \n", + " # FULLY CONNECTED LAYER 4\n", + " with tf.name_scope('FC2'):\n", + " # Activation (120 -> FC4 -> 84)\n", + " hidden4 = FC_layer(hidden3, 120, 84, act = 'relu')\n", + " if dropout_rate < 1:\n", + " hidden4 = tf.nn.dropout(x=hidden4,keep_prob = dropout_rate)\n", + " \n", + " # FULLY CONNECTED LAYER 5\n", + " with tf.name_scope('Output'):\n", + " # Activation (84 -> FC5 -> 10)\n", + " predictions = hidden4 = FC_layer(hidden4, 84, 10, act = 'softmax')\n", + " \n", + " return predictions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "The LeNet architecture now has been declared. The filter sizes and strides have been chosen in order to respect requested sizes between the various layers, remembering the formula:\n", + "$$ I_{i+1} = \\frac{I_i - F + 2P}{S} + 1 $$\n", + "\n", + "
    \n", + "
  • Convolutional Layer 1: 28x28x1 ----- [5x5] -----> 28x28x6
  • \n", + " we've chosen $S = 1$. The padding will be $P = 2$ (chosen by the TensorFlow option 'SAME').

    \n", + "
  • MaxPooling Layer 1: 28x28x6 -----> 14x14x6
  • \n", + " To avoid \"intersections\" between the various pools, the kernel size value has been chosen also for the stride, so:\n", + " $ 14 = \\frac{28 - K}{K} + 1 $. We've chosen $ K = 2 $ as feasible value.

    \n", + "
  • Convolutional Layer 2: 14x14x6 ----- [5x5] ----->10x10x16
  • \n", + " $I_{i+1} = \\frac{I_i - F}{S} + 1 = \\frac{14 - 5}{S} + 1 $, so $ S = 1 $ is a feasible value.

    \n", + "
  • MaxPooling Layer 2: 10x10x16 -----> 5x5x16
  • \n", + " Also in this case, to avoid \"intersections\" between the various pools, the kernel size value has been chosen also for the stride, so:\n", + " $ 5 = \\frac{10 - K}{K} + 1 $. We've chosen $ K = 2 $ as feasible value.\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.1.2. Calculate the number of parameters of this model " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of parameters: 61706\n" + ] + } + ], + "source": [ + "# COMPUTE THE NUMBER OF PARAMETERS\n", + "count = np.sum([np.prod(v.shape.as_list()) for v in tf.trainable_variables()])\n", + "\n", + "# PRINT THE RESULT\n", + "print(\"Total number of parameters:\", count)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "The number of trainable parameters is 61706. This number has been computed thanks to the tf.trainable_variables() function available in TensorFlow:
\n", + "
\n", + "- For each variable, the shape is computed.
\n", + "- The components of the shape are multiplied, so the number of parameters regarding that shape is obtained.
\n", + "- All the parameters regarding each shape are then summed together.
\n", + "
\n", + "The total number so, can be calculated also by hand:\n", + "\n", + "5 x 5 x 1 x 6 +\n", + "6 +\n", + "5 x 5 x 6 x 16 +\n", + "16 +\n", + "400 x 120 +\n", + "120 +\n", + "120 x 84 +\n", + "84 +\n", + "84 x 10 +\n", + "10 =\n", + "61706\n", + "\n", + "\n", + "\n", + "
\n", + "*note: this cell, even if it's located before, has been executed after the following cell, to be run with the right instance of the model (the CNN), and not with the one of the classic neural network.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.1.3. Define your model, its accuracy and the loss function according to the following parameters (you can look at Section 1 to see what is expected):\n", + "\n", + " Learning rate: 0.001\n", + " Loss Function: Cross-entropy\n", + " Optimizer: tf.train.GradientDescentOptimizer\n", + " Number of epochs: 40\n", + " Batch size: 128" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# RESET THE GRAPH AND CLEAR LOGS\n", + "! rm -rf ./log_files\n", + "tf.reset_default_graph()\n", + "\n", + "\n", + "# PARAMETERS\n", + "learning_rate = 0.001\n", + "training_epochs = 40\n", + "batch_size = 128\n", + "loss_display_step = 1\n", + "acc_display_step = 10\n", + "logs_path = 'log_files/CNN'\n", + "\n", + "\n", + "# PLACEHOLDERS\n", + "x = tf.placeholder(tf.float32, [None,28,28,1], name='input')\n", + "y = tf.placeholder(tf.float32, [None,10], name='output')\n", + "\n", + "\n", + "# MODEL DEFINITION\n", + "# Model structure\n", + "with tf.name_scope('model'):\n", + " pred = LeNet5_Model(images=x)\n", + " \n", + "# Loss\n", + "with tf.name_scope('loss'):\n", + " cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(tf.clip_by_value(pred, epsilon, 1.0)), reduction_indices=1))\n", + "\n", + "# Optimizer\n", + "with tf.name_scope('optimizer'):\n", + " optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.1.4. Implement the evaluation function for accuracy computation " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# EVALUATION FUNCTION\n", + "def evaluate(logits, labels):\n", + " \n", + " correct = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))\n", + " return tf.reduce_mean(tf.cast(correct, tf.float32))\n", + "\n", + "# Accuracy\n", + "with tf.name_scope('accuracy'):\n", + " acc = evaluate(pred, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.1.5. Implement training pipeline and run the training data through it to train the model.\n", + "\n", + "- Before each epoch, shuffle the training set. \n", + "- Print the loss per mini batch and the training/validation accuracy per epoch. (Display results every 100 epochs)\n", + "- Save the model after training\n", + "- Print after training the final testing accuracy " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# TRAIN FUNCTION\n", + "def train(init, sess, logs_path, n_epochs, batch_size, optimizer, cost, merged_summary_op):\n", + " \n", + " # Start\n", + " print(\"[OPTIMIZATION STARTED]\\n\")\n", + " startTime = time()\n", + " sess.run(init)\n", + " summary_writer = tf.summary.FileWriter(logs_path, graph=tf.get_default_graph())\n", + " \n", + " # Training\n", + " for epoch in range(n_epochs):\n", + " \n", + " # Init\n", + " avg_cost = 0.\n", + " total_batch = int(mnist.train.num_examples/batch_size)\n", + " \n", + " # Loop over all batches\n", + " for i in range(total_batch):\n", + " \n", + " # Next batch\n", + " batch_xs, batch_ys = mnist.train.next_batch(batch_size, shuffle=(i==0))\n", + " batch_xs = batch_xs.reshape(batch_size,28,28,1)\n", + " \n", + " # Run optimization\n", + " _, c, summary = sess.run([optimizer, cost, merged_summary_op],\n", + " feed_dict={x: batch_xs, y: batch_ys})\n", + " \n", + " # Write logs\n", + " summary_writer.add_summary(summary, epoch * total_batch + i)\n", + " \n", + " # Compute average loss\n", + " avg_cost += c / total_batch\n", + " \n", + " # Display logs\n", + " if (epoch+1) % loss_display_step == 0:\n", + " print(\"Epoch:\", '%02d' % (epoch+1), \" =====> Loss =\", \"{:.4f}\".format(avg_cost))\n", + " \n", + " if (epoch+1) % acc_display_step == 0:\n", + " acc_train = acc.eval({x: X_train, y: y_train})\n", + " acc_val = acc.eval({x: X_val, y: y_val})\n", + " \n", + " print(\"Train accuracy =\", \"{:.2f}%\".format(acc_train*100),\n", + " \" | \",\n", + " \"Validation accuracy =\", \"{:.2f}%\\n\".format(acc_val*100))\n", + " \n", + " \n", + " endTime = time()\n", + " print(\"[OPTIMIZATION FINISHED]\")\n", + " print(\"Training time =\", \"{:.3f} seconds\".format(endTime-startTime))\n", + " summary_writer.flush()\n", + " \n", + " \n", + " # --- ACCURACY ------------------------------------------------------ #\n", + " acc_test = acc.eval({x: X_test, y: y_test})\n", + " print(\"Test accuracy =\", \"{:.2f}%\".format(acc_test*100))\n", + " \n", + " return endTime-startTime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
LeNet architecture (SGD optimizer)
" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[OPTIMIZATION STARTED]\n", + "\n", + "Epoch: 01 =====> Loss = 2.2634\n", + "Epoch: 02 =====> Loss = 2.1361\n", + "Epoch: 03 =====> Loss = 1.8475\n", + "Epoch: 04 =====> Loss = 1.2495\n", + "Epoch: 05 =====> Loss = 0.7923\n", + "Epoch: 06 =====> Loss = 0.6004\n", + "Epoch: 07 =====> Loss = 0.5038\n", + "Epoch: 08 =====> Loss = 0.4459\n", + "Epoch: 09 =====> Loss = 0.4069\n", + "Epoch: 10 =====> Loss = 0.3778\n", + "Train accuracy = 89.34% | Validation accuracy = 89.98%\n", + "\n", + "Epoch: 11 =====> Loss = 0.3554\n", + "Epoch: 12 =====> Loss = 0.3368\n", + "Epoch: 13 =====> Loss = 0.3211\n", + "Epoch: 14 =====> Loss = 0.3067\n", + "Epoch: 15 =====> Loss = 0.2949\n", + "Epoch: 16 =====> Loss = 0.2832\n", + "Epoch: 17 =====> Loss = 0.2737\n", + "Epoch: 18 =====> Loss = 0.2649\n", + "Epoch: 19 =====> Loss = 0.2561\n", + "Epoch: 20 =====> Loss = 0.2486\n", + "Train accuracy = 92.66% | Validation accuracy = 93.32%\n", + "\n", + "Epoch: 21 =====> Loss = 0.2412\n", + "Epoch: 22 =====> Loss = 0.2341\n", + "Epoch: 23 =====> Loss = 0.2275\n", + "Epoch: 24 =====> Loss = 0.2219\n", + "Epoch: 25 =====> Loss = 0.2158\n", + "Epoch: 26 =====> Loss = 0.2105\n", + "Epoch: 27 =====> Loss = 0.2055\n", + "Epoch: 28 =====> Loss = 0.2005\n", + "Epoch: 29 =====> Loss = 0.1961\n", + "Epoch: 30 =====> Loss = 0.1915\n", + "Train accuracy = 94.31% | Validation accuracy = 94.84%\n", + "\n", + "Epoch: 31 =====> Loss = 0.1877\n", + "Epoch: 32 =====> Loss = 0.1835\n", + "Epoch: 33 =====> Loss = 0.1797\n", + "Epoch: 34 =====> Loss = 0.1761\n", + "Epoch: 35 =====> Loss = 0.1723\n", + "Epoch: 36 =====> Loss = 0.1692\n", + "Epoch: 37 =====> Loss = 0.1660\n", + "Epoch: 38 =====> Loss = 0.1631\n", + "Epoch: 39 =====> Loss = 0.1601\n", + "Epoch: 40 =====> Loss = 0.1573\n", + "Train accuracy = 95.28% | Validation accuracy = 95.80%\n", + "\n", + "[OPTIMIZATION FINISHED]\n", + "Training time = 1027.803 seconds\n", + "Test accuracy = 95.51%\n" + ] + } + ], + "source": [ + "# MAKE SUMMARIES\n", + "init = tf.global_variables_initializer()\n", + "tf.summary.scalar(\"loss-LeNet\", cost)\n", + "tf.summary.scalar(\"accuracy-LeNet\", acc)\n", + "merged_summary_op = tf.summary.merge_all()\n", + "\n", + "\n", + "# LAUNCH SESSION\n", + "with tf.Session() as sess:\n", + " train(init, sess, logs_path, training_epochs, batch_size, optimizer, cost, merged_summary_op)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.1.6 : Use TensorBoard to visualise and save loss and accuracy curves. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "This is the graph showing the general architecture of the network:
\n", + "
\n", + "
\n", + "Learning progress:
\n", + "
\n", + "
\n", + "\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Part 2 : LeNET 5 Optimization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
LeNet architecture (Adam optimizer)
" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[OPTIMIZATION STARTED]\n", + "\n", + "Epoch: 01 =====> Loss = 0.3601\n", + "Epoch: 02 =====> Loss = 0.0956\n", + "Epoch: 03 =====> Loss = 0.0645\n", + "Epoch: 04 =====> Loss = 0.0490\n", + "Epoch: 05 =====> Loss = 0.0401\n", + "Epoch: 06 =====> Loss = 0.0331\n", + "Epoch: 07 =====> Loss = 0.0277\n", + "Epoch: 08 =====> Loss = 0.0233\n", + "Epoch: 09 =====> Loss = 0.0204\n", + "Epoch: 10 =====> Loss = 0.0194\n", + "Train accuracy = 99.44% | Validation accuracy = 98.78%\n", + "\n", + "Epoch: 11 =====> Loss = 0.0165\n", + "Epoch: 12 =====> Loss = 0.0133\n", + "Epoch: 13 =====> Loss = 0.0131\n", + "Epoch: 14 =====> Loss = 0.0120\n", + "Epoch: 15 =====> Loss = 0.0096\n", + "Epoch: 16 =====> Loss = 0.0091\n", + "Epoch: 17 =====> Loss = 0.0095\n", + "Epoch: 18 =====> Loss = 0.0076\n", + "Epoch: 19 =====> Loss = 0.0074\n", + "Epoch: 20 =====> Loss = 0.0068\n", + "Train accuracy = 99.87% | Validation accuracy = 99.04%\n", + "\n", + "Epoch: 21 =====> Loss = 0.0055\n", + "Epoch: 22 =====> Loss = 0.0092\n", + "Epoch: 23 =====> Loss = 0.0038\n", + "Epoch: 24 =====> Loss = 0.0063\n", + "Epoch: 25 =====> Loss = 0.0069\n", + "Epoch: 26 =====> Loss = 0.0044\n", + "Epoch: 27 =====> Loss = 0.0048\n", + "Epoch: 28 =====> Loss = 0.0066\n", + "Epoch: 29 =====> Loss = 0.0039\n", + "Epoch: 30 =====> Loss = 0.0058\n", + "Train accuracy = 99.82% | Validation accuracy = 99.08%\n", + "\n", + "Epoch: 31 =====> Loss = 0.0029\n", + "Epoch: 32 =====> Loss = 0.0028\n", + "Epoch: 33 =====> Loss = 0.0068\n", + "Epoch: 34 =====> Loss = 0.0035\n", + "Epoch: 35 =====> Loss = 0.0036\n", + "Epoch: 36 =====> Loss = 0.0055\n", + "Epoch: 37 =====> Loss = 0.0016\n", + "Epoch: 38 =====> Loss = 0.0024\n", + "Epoch: 39 =====> Loss = 0.0053\n", + "Epoch: 40 =====> Loss = 0.0045\n", + "Train accuracy = 99.80% | Validation accuracy = 98.80%\n", + "\n", + "[OPTIMIZATION FINISHED]\n", + "Training time = 877.757 seconds\n", + "Test accuracy = 98.98%\n" + ] + } + ], + "source": [ + "# RESET THE GRAPH AND CLEAR LOGS\n", + "! rm -rf ./log_files\n", + "tf.reset_default_graph()\n", + "\n", + "\n", + "# PARAMETERS\n", + "learning_rate = 0.001\n", + "training_epochs = 40\n", + "batch_size = 128\n", + "loss_display_step = 1\n", + "acc_display_step = 10\n", + "logs_path = 'log_files/'\n", + "\n", + "\n", + "# PLACEHOLDERS\n", + "x = tf.placeholder(tf.float32, [None,28,28,1], name='input')\n", + "y = tf.placeholder(tf.float32, [None,10], name='output')\n", + "\n", + "\n", + "# MODEL DEFINITION\n", + "# Model structure\n", + "with tf.name_scope('model'):\n", + " pred = LeNet5_Model(images=x)\n", + " \n", + "# Loss\n", + "with tf.name_scope('loss'):\n", + " cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(tf.clip_by_value(pred, epsilon, 1.0)), reduction_indices=1))\n", + "\n", + "# Optimizer\n", + "with tf.name_scope('optimizer'):\n", + " optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n", + "\n", + "# Accuracy\n", + "with tf.name_scope('accuracy'):\n", + " acc = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n", + " acc = tf.reduce_mean(tf.cast(acc, tf.float32))\n", + " \n", + "\n", + "# MAKE SUMMARIES\n", + "init = tf.global_variables_initializer()\n", + "tf.summary.scalar(\"loss-LeNet\", cost)\n", + "tf.summary.scalar(\"accuracy-LeNet\", acc)\n", + "merged_summary_op = tf.summary.merge_all()\n", + "\n", + "\n", + "# LAUNCH SESSION\n", + "with tf.Session() as sess:\n", + " train(init, sess, logs_path, training_epochs, batch_size, optimizer, cost, merged_summary_op)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.2.1 \n", + "\n", + "- Retrain your network with AdamOptimizer and then fill the table above:\n", + "\n", + "\n", + "| Optimizer | Gradient Descent | AdamOptimizer |\n", + "|----------------------|--------------------|---------------------|\n", + "| Testing Accuracy | 95.51% | 98.98% | \n", + "| Training Time | 909 sec | 877 sec | \n", + "\n", + "- Which optimizer gives the best accuracy on test data?\n", + "\n", + "
\n", + "The adam optimizer gives a better accuracy. It takes a little bit of time more than the model with the standard SGD, but is able to classify in a better way the MNIST dataset.
\n", + "\n", + "
\n", + "The Adam optimizer, indeed, is a combination of the improvements brought by other optimizers: it adds momentum to the RMSProp optimizer. It adapts not only the learning rates basing it on the first moments (the mean) as in RMSProp, but it also makes use of the average of the second moments of the gradients (the variance).\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Question 2.2.2 Try to add dropout (keep_prob = 0.75) before the first fully connected layer. You will use tf.nn.dropout for that purpose. What accuracy do you achieve on testing data?\n", + "\n", + "**Accuracy achieved on testing data:** 98.99% (with 0.75-dropout)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "The accuracy obtained with the dropout layer is almost the same, just slightly better than the LeNet CNN without it. Dropout is, in general, useful to generalize the network avoid overfitting: the performances will be a bit worse on the training data but, in general, on validation and test data will be less overfitted, so the performances could be better. In this case, the obtained accuracy on test set is almost the same, just slightly better (98.98% without dropout vs 98.99% with dropout), while on the train data the accuracy of the model with dropout is of course a bit worse.
\n", + "The computational time is slightly smaller: maybe this is due to a TensorFlow code optimization, which can avoid to compute the hidden outputs of dropped neurons.
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
LeNet architecture with Dropout (Adam optimizer)
" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[OPTIMIZATION STARTED]\n", + "\n", + "Epoch: 01 =====> Loss = 0.5821\n", + "Epoch: 02 =====> Loss = 0.1632\n", + "Epoch: 03 =====> Loss = 0.1159\n", + "Epoch: 04 =====> Loss = 0.0986\n", + "Epoch: 05 =====> Loss = 0.0811\n", + "Epoch: 06 =====> Loss = 0.0733\n", + "Epoch: 07 =====> Loss = 0.0660\n", + "Epoch: 08 =====> Loss = 0.0626\n", + "Epoch: 09 =====> Loss = 0.0579\n", + "Epoch: 10 =====> Loss = 0.0514\n", + "Train accuracy = 98.62% | Validation accuracy = 98.44%\n", + "\n", + "Epoch: 11 =====> Loss = 0.0490\n", + "Epoch: 12 =====> Loss = 0.0476\n", + "Epoch: 13 =====> Loss = 0.0460\n", + "Epoch: 14 =====> Loss = 0.0416\n", + "Epoch: 15 =====> Loss = 0.0394\n", + "Epoch: 16 =====> Loss = 0.0392\n", + "Epoch: 17 =====> Loss = 0.0379\n", + "Epoch: 18 =====> Loss = 0.0353\n", + "Epoch: 19 =====> Loss = 0.0338\n", + "Epoch: 20 =====> Loss = 0.0327\n", + "Train accuracy = 99.05% | Validation accuracy = 98.44%\n", + "\n", + "Epoch: 21 =====> Loss = 0.0319\n", + "Epoch: 22 =====> Loss = 0.0300\n", + "Epoch: 23 =====> Loss = 0.0286\n", + "Epoch: 24 =====> Loss = 0.0272\n", + "Epoch: 25 =====> Loss = 0.0298\n", + "Epoch: 26 =====> Loss = 0.0287\n", + "Epoch: 27 =====> Loss = 0.0271\n", + "Epoch: 28 =====> Loss = 0.0270\n", + "Epoch: 29 =====> Loss = 0.0269\n", + "Epoch: 30 =====> Loss = 0.0256\n", + "Train accuracy = 99.22% | Validation accuracy = 98.70%\n", + "\n", + "Epoch: 31 =====> Loss = 0.0248\n", + "Epoch: 32 =====> Loss = 0.0241\n", + "Epoch: 33 =====> Loss = 0.0233\n", + "Epoch: 34 =====> Loss = 0.0225\n", + "Epoch: 35 =====> Loss = 0.0231\n", + "Epoch: 36 =====> Loss = 0.0226\n", + "Epoch: 37 =====> Loss = 0.0228\n", + "Epoch: 38 =====> Loss = 0.0214\n", + "Epoch: 39 =====> Loss = 0.0221\n", + "Epoch: 40 =====> Loss = 0.0203\n", + "Train accuracy = 99.35% | Validation accuracy = 98.76%\n", + "\n", + "[OPTIMIZATION FINISHED]\n", + "Training time = 1070.386 seconds\n", + "Test accuracy = 98.85%\n" + ] + } + ], + "source": [ + "# RESET THE GRAPH AND CLEAR LOGS\n", + "! rm -rf ./log_files\n", + "tf.reset_default_graph()\n", + "\n", + "\n", + "# PARAMETERS\n", + "learning_rate = 0.001\n", + "training_epochs = 40\n", + "batch_size = 128\n", + "loss_display_step = 1\n", + "acc_display_step = 10\n", + "logs_path = 'log_files/'\n", + "\n", + "\n", + "# PLACEHOLDERS\n", + "x = tf.placeholder(tf.float32, [None,28,28,1], name='input')\n", + "y = tf.placeholder(tf.float32, [None,10], name='output')\n", + "\n", + "\n", + "# MODEL DEFINITION\n", + "# Model structure (with dropout)\n", + "with tf.name_scope('model'):\n", + " pred = LeNet5_Model(images=x, dropout_rate = 0.75)\n", + " \n", + "# Loss\n", + "with tf.name_scope('loss'):\n", + " cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(tf.clip_by_value(pred, epsilon, 1.0)), reduction_indices=1))\n", + "\n", + "# Optimizer\n", + "with tf.name_scope('optimizer'):\n", + " optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n", + "\n", + "# Accuracy\n", + "with tf.name_scope('accuracy'):\n", + " acc = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))\n", + " acc = tf.reduce_mean(tf.cast(acc, tf.float32))\n", + " \n", + "\n", + "# MAKE SUMMARIES\n", + "init = tf.global_variables_initializer()\n", + "tf.summary.scalar(\"loss-LeNet\", cost)\n", + "tf.summary.scalar(\"accuracy-LeNet\", acc)\n", + "merged_summary_op = tf.summary.merge_all()\n", + "\n", + "\n", + "# LAUNCH SESSION\n", + "with tf.Session() as sess:\n", + " train(init, sess, logs_path, training_epochs, batch_size, optimizer, cost, merged_summary_op)" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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.6.3" + }, + "widgets": { + "state": {}, + "version": "1.1.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LAB2_CNN/images/LeNet.png b/LAB2_CNN/images/LeNet.png new file mode 100644 index 0000000000000000000000000000000000000000..86745fef548ac17ccc71b7da9627d951deab690e GIT binary patch literal 39641 zcmcG0cRbeL|2LP*F0-P9%Pxed>@7PolPw{8XLA`Dk(s@-$tGlv>=_~BviIJb`&{bt z`TldpIa4C^w}f#S~FcP)|`%AZ}O~ z;FC$oqB8J-tFfr)ODR!N*h?ErLt`@o6qE;H`ntM|Qp^w9_4IUg+k2QE;@CJS`uhhd z>ee?m^fWZXT6BNFl43M9r%4H>o8iQ+)vXO!Us%_?x~2Edodz?@T`%uED~z>KrQ@kQ z@I-ZxHnC<$L!-eAO-xWsNWgu&gz}rG1N}Lj(BTc3Mnz3JN{ayM+rV3>Tnt z*70HQiDG(MAgaVf^Eckgp!|kN5q!h&PsG#HfRA?E4R|Q@4YQrapR55s*!;Y4qCs&a z3|=jTQN^9X#w(QiBO;FE-VGZ}f-W{kwo0}KY%v_9Y-;Sw>|9als-NMvc$P?%?-*nn zeSW|N5q+l8$SqirQbt=YDbdKm`dVJ1vAv-mB^~dU5kZ?z9=7B*@D92gA7XYFTeTwBp)ks1OH`1f24K&DG-+c4j=2kq8Gq1{hcg` zf+B<>B_^!wh`OGL?Wppr>SziY9?DGxWf#K8WW!;9pj&)H-MIWw`E%CWevAl#FXe}) zEBU|VpKBzajrj(N z^B2>leFAHby8?(Aq(wwTLXNh-)MBlV7K^^o*EazFALf#p&XGc9f^!}+neal6+Zd>+ zMNCXh&0le<`a``u8*-Gg(latXB$n#F>qel9dhG)A6+= zV1wK`g{R^Ndp-Ulk(-l)9ZWK-5ek2S)qsgX{_f)HalCTiFDn=-PAwW)kDLkxn=YK4 zNmWJVcaHj3Tx_l+_@Nt^%I>^+8yzA87ok+U6jnH$ZuHJ5FIS0+i}RXwJ0_yl#e@(z z$E$WuZ@J53Ae>FI$;@WpK;4w)S0GkrkR zna{<C{VJ>J88hU)va;gV1$PKT!L}oS_v7DtBFQB<<>`ZY0V5cmYImH; zFkqiW4OLT7|~kXCePpy^J6_~DZ;SaX8{FQmQ-}*iC3zE$CPbETuUZv zrLlK^3K#~_ZRtubH-{vL3SS+Rh+Q1;-?f@fp}TEBbx7O)#4dYX$NAGOR?X>hFP-`| z3n?zwmbIrzw5UYOvM5)AV<&^WJjv&6g@mSpQ8`yTK_jMoE3%L!&8`S}9qX#H^TBeP zMbqe*Lm~lOx9%$^kvB=_4ugy>L5Wf*UOF{ab@#tJ7nfBpuG^m;Ius21ozsJfKL}~q zm6^F83+GTIkF3ajbY-|Ne3EuB{z_`D6LVqRpU~Z-UZ8Kl?^j~@v4#h87-iv}3tdd= z9(IeevgCe;G~I4-!Ae5w{u8Mao5DSvAWI?09fIr{-IC8eb!yT^J>gNG_wv;2ijS`d zC3fS)x7{Ub&t3&gR4S}`9BFXZ>L%&vlv!#Y8TCpw;YTaXUwjm(Wao{Hc;sSnW^}jC zqPF{V3SY*@^o84(E(h-bsAL1Lr*F3`_px`LL36~FguvN?bdL3gT=X7d>h0x6US0}G zE*oXT%hf3!_dQr8wvWn)WK+2e-E727ceeq7Ps?*2r>sQ92Bv-Jen!#g67Yq1 z)O`H-5h`r`U{|<5#r1GBW;twWQU1=KQ5C;6O53KeA$IKk$-d{gF<8#g9y~-@kwN z=5U!xL+A+_9-J=^q?On%$#Gjv!-cjbg6}_6%92x=x?x}n*@tzOEVQmIbSM1QLOj@= z3#m@vu=%n?c#*_fJ@0f{^5JJv{NMtgyw4p}|MM!_rOzD#%-y$}0t28TLGUbNip;~* z0!Jd!#x%5UF-RT3JNqB7fYJTeSrQnV2$}+I{rbemF1JptUUl2_4GCC#Ej_%%dkkS4 zX*LraSO~g%*GWLk$e(I@&G!MSN6ez=EpnY|5{P+$8je=DDckK$^&Y!#$u7S85B6u- z`jeo+5!`|QH+9~^Rl3$KCAO;#_E5vRfJLMWKSs5f)^lS>8ENX zL>^q(^!r)W7yB1Ue6g9*g5O38w5p-CmzQdip_rKpHnz6aLuOZ(7Z9V4%lEx(r$XFG z*k>6b6#Qd*WpnP$OVG@d++4;~V}x~&(KwEN?%3z!u|O4SA>q| zJ8cUkT`Uol7t0d99M36811?WT>Z68+hU89ab~~A*mtPfV{$6pF7aacjI*o_I$w_A; z#rN=Pfz{*pLNTzDE;M|;{)HN1Iidc88s5d}nTPU)P7G!D*Or+;gez+Ut4RdO|sWfe>S-_--t=M?vOFStyZM#S&7RJC0sdKN+t=KwQo`mjv&fR zDXUy_@OqBEh114EPlP27;;OEhieN3VctA{a8_{=Nw!TyBz=hvJ3H`rC&TakIpOa|O z?(FO&uA&ZJ1(Wl>-54vEPUqFyKlap>&~ZP>xX|5SOY!@O1QRt1(T5u1Vb0amZEZO|oa%mFNWLBRU>hx*z={*PfVCUq!PqKR{T_OD^d*7%63zSmo`CsfUXHSzCG51a~5-vNJxDv6&qkKS^ zHR1J8+Ln<15QaLB!JAVHmtsun_j-9ttmni%M?sjy&Q#p2TB7iDy3n~g(BZ9Z%dbE% z3Z8Vx&sQxat=YVoI^G|Y&-3?XtvmiQ_5}Sg;db}xue^m$rb6Xm$T6;_O$VLL#lgs0 z+von~S97gomdc3&j>OH4TbE~B6^ZY@D0$Uuxi&L?ki%~wPje`6+Ipu*;X{CG^rGm) z%Vy}V%Hvh<=nIg>4G9K&ewE3NuKiISNhfCf`Yb-vL}uB?y#$qf~e8YI*!wH?sYBXYSV&`*VSp`OP+HFW@w%LKX0y&Ng<&?k>@n zx;Tb7_fh#d@jdGf$4q${y%ZS7a*B(KMT-ue+d%{__LUZ%V20Vs$2hb}o`-mxr=73J zd#qOa)YwUUnM-eL{QOV}N}0$~e{S=;#;Me7{M(DFHtw(|Qw?*85_I92#lA_0n%D?f1DKmdd?O;TTS&xxe_u^7{(? z$%dszo|x58w!-S`AiJF#vJ+D$y$(FPqS~8==JEr+26`vE3nf-FA}2HW9-}+=`HqS$ zruHs_$<7^7);`>ElzlYA&t}qAO})uSj2$X;1l~Vcik-ux=5Dt>`dG?gBfQ0fE8pB1 zix||(>kz;WE#o>6T+15(X(j}kl8rzJ%RFYf~3M}LZ;UbSs z3pq$J<67*A=PYbCf%l@XDk&(WZhB|;Ch=?VM<*uc4<~r+b}*O(B%OWsVrkQvT86*N z;vv_Ql|b=nCo2{?&a>$DgC>ZehxF>j}d#|Z7Mqjki#|wi|M8A`Z82JFezreXhDsjwj2&tX)$%$L&EbG<2{`Zt%rBJS;3#d^>3e z?OcU^j|xN!f<<+Cmx5{%S@q+a3S?8&ll}X9E*UGEy@p~HU3_*h&+~KFry@S3w&xBmI~o6dvkQZ269iAqA#8(pdo>k2 zhta6X45++>q|-KDa!I`PGLg9zmSLp@({dM5_XmInBj5|PAKF%HeGo=%xrMR8f)yO5 zZc4SW`C69T@gv{nhr5&mJLh5j#{D!7t~7crczHz7I$k4DkIy}PlCaNMFPBAg%J~tu z_jawiy&GY5J%G%GfUL1=aHKm_5|G*4!#$$cyzm|>T2Rpw^P z{msjH9xqHHg|c>$d^XrzFIEx`?Pd^4CqziMAqNz%eC>y#Cd)Q6-vf_xqKGX z`I|E;Dk_)jP?L3Q{r!!%8&s=feE7v}80;|+ugd0*U}Scl1Z?ThjHG@TC#;pAjlwjt zN*hu5&Rc+^&%m0eAFqXc(Wzh*>r@c6PL}{gCQMYs4req;81L3JpAcU(eAjgG zaa(73Pp>hj$B43D`VTA$iharZwP*3{do-v) z-v|1>RHhR0^v7`Ns4n!Zs~J1w;W2gtz9??ZVZzdc%XS6tR4CLH#Dt^Bn44RERo_6V z{h>0$Hu5G}Hl>OPrp0uFC%f5bQLtv2KDk)Z8iKcI8xECBAp^3qXy96Sl2E|L8qz>- z)u3-9;CXoXz8r00AWb3zll05fXmxLUTIJ!q;a((YP~HUBtY3FFjL_rD~q2oS(T4={O`)1c72) zq#Es%ZWp!Q-vk+LBsR(3o~E>sHO+AjSIpFmn%{uSn>SzBe|T)UOhvS}OFlgce$!v9 zPmM|h^SmSid0=$P^Sc*1p8eA2KlnkS!>r#Lq>ySsu6PkzKrcc}V?qw4xO10F z4&*eN=GeG1Z4VGi^P=}ib&`NfC>`f}s)>#eu}qWEP{-yUJnwn|Y@(ZqgXrILGfmIN~WD zbqERwX_SxO_^hVP!~kyvheDnM-0H!u8#77L0Z30pKg0pB$31G>EC7c1hVJ~gSrKNueq3+yEC8OM40Fe6-aE8_TW?SshOiE zgohK=u=a4$fD`5ci;I7@k}B%Q^Nn^PdtgkwsVv}*W08aeE~VP57^DU^7=x31X7^BrqPC7oCKtuaKGUqNg7o z`B-7ivDFr|K_dh~ScqbZC@m?0u2<>3+&Xu}#14gDfG}e|EFKdrVP7ew2{F8V9z0!)lPV%ryqAJ`=fmlNjKsvj=Ep+hi~4;3_u=j(2x$j4dowAt6}r zmz9xVN2m}RaZ3Mqy8R4_?_{s8Kqgv}2O0WoFn&~*9#qg~UJ|FqgOGz0s2dq_T#7Z@ zm>9DQmsdtc#_tsIMg{bil(q*Ha_?^)Prp;DLkAn%0&lM4*gGR8HE*Ia1L^IJpgGL% zYDrk0ZO)E3HI#66Trisim<_Y?q^Kqj_|*;PC~%_FV_emaK@&34(ohk3Plxv!C5J$h zE@^-Zrj!xo)|(I5&W(vTVi!j_FB+s2qZp)2@aAj{lLxziG60=H8NZ$8gmp`Nm(-K} zL=I(bnreGHU0z;3y1QEz6jIe}G^y~)&1eiSH`{Q@u zP#&-_hef^Ltd3*)v~iz5w+z(a4^8&$tNF%&eD=`ihzb`W4FL1zj`}pkxCI88#^*-^ z8vuH`y@^eE<58Cb(xSb9MdNf*7{DMDvt#;X>X}K{4ZEme5(%hKVlP3!UmbP_y#hKR z*^mfECi*^a8?D56^Ym>yL7=pq_T!jgF8A|F99Oh1Oo^RdQ_*3hDo}s}xl@4#y@9G# zbStPj!^sa{fb>W6D&UpaJ}x1)5wCZcu|rX?_d!-QMMfp4mRtE`&B+#F25VMWI0IbdAYBT=IRHtae}u zqvW)>|GaLz{+>2C2M|Gk8XP6-CEN7x?cH(?yEr?N(brGYm7~zuXGfY13U&-wkR`>q z9JlCbQ&W?OyF10&d|qy@GM5Gq!v2(a1|R97**<_{y7g6y<43S*YTe+y_sODc_ruPrj3+j zfyiy4BB#KI8J@TNFhchFB2YpgwK&5MoPTXD2S|h z9#KRDW}=dYQ&~NF=h!{q_w(IlgD0BThGTKEtF-h-bf4GIYc&ya0BSNBwljBJN(Z}!Yf-usE@l^8l z>(}A2vBvCDhVn?6(dznuwP8J_Olst@@o~QyrL3bj<0!mK<0l@%U}+Wpi_LB4$IEn3Ww*Ckn$;5Rl>|LtaN*A0;S%J|HM>Rd=AJ>Ck53 z@7hf_)YFN=-u#bS75WN;d7P;HbTtp(%#da)IRKl&F$l4w_ z&|lWFnOxO}1&^wo@@B4S2$kNFV6smq88XYt`d#sb;`|J7KM7rRc1Hvc%ub+F*lzio z_#JHDawNVah@nI3)hHZ{@DUeUccAUIAE&Fr<$E^T(c7yE5wwC`LDzqZe+5Ap7_l(? zsxw~b_KaR}dM{peB^dXu^M@jL(DVjRhOUS$n+$S;SjNcnilf}y+g6h(N)V#^I@6|D z_3|z<{2j^?wbirlMBA6HjwDtG!k+g(1%jC z%lRb}a_}N&g`rY{LfsAiD_TSEn?#9?`z7Enr6;Jik@*nF?90+KGY>O5Yy6PXlZ5$W zkBTqPH2A(V+g5Y15m{DSSHm1Ar}iW}tns^z+BF{@5fRznT=G&`dA=McCRxG=j%r;q zJ0o?y0Y(VwZD*{ZnP$I*mH=X##qQV?NFM)IzI#q?Zms}Hz=Hi~0G>uKwHhA4h=7QN zwh6If`YCzrBo8+y^Zc90?wj_`WXM@s?OnC&TEj~zsAp5jgYR=wM=;2%%4~MCCek4v zL%~*)g26=aJ^dPV#kk$i9dDQY=!`aetwRWJUs_t~0(f~k;7ePB$F|=V7KesQwY*1+@P51H%Cs?eQ>{Hd<`Fq;`kj2*Ynl)yAn4Cs=U2Z z-V+VAsojR>KrYA(R`i((TUK!|$VQ5&(=sy9{r*lOKv1N-96~9`VpWr7JnDC+WLp(F z;>kg)DtsJHkkF<9KzpUE5OUs3>irqaD9YIiIWCrm4;2K9X$SV=w5k17Zk!!%D9QPp zzD}D0E|d`=WZ7pq{w=>k!!Z$gq-OFBCEU*EqBkuqnU~&_FrfOhJ-@~8|5&_#`SSst z+u?5`Mk1Kk{_^ob_*{#oQ{NPos){8NLri znlqOywH*r&N)n|TMR24fY2+N5=}jo5J1L-(-9KB3rVGID+jKpuc#w>4 zhqaxA&%giD@0VWZ=Z7|J{au2;ml_R*r%^7zFFQixCF7gm$6F6dq3B-EhGm7OpZ)_jQ~ ze3OBiAVTRhPk3AyE+Ed71ZoXKaJbVa34KAh>#ah zcr&}@xJw}ASf>N)-)-sFUlVBB0f)!Bg=iuRZVLN4# zXgdnCmBZO7+>iAREF2I{S*v_zQ*~OCbpR81f1kf`hZC541GZ04fBnf~JVa^J?PxOV za>vige5_2${bEfg&uPWdZB4_?;)a>#-uYf1?qc%AqkStbQAD)X``1DrDAJsQIuEew zdAY`{<+tqd8(T`*JkQ2uD6G#XCHAt3We+4mC{(C}*q3_ZvvPC0#3i6|zLjn7#)|d* zR$+Cgt9gupxGa@IFBBTQQrzz9O6ekNcvM~@EbLT2wmHh#c+I^cs{#=(QY}DoNTcYM z)SmBlMRHTpm|(RweZb`%!|kfs4!Ho{Gjhcd@NcX4di7#Q6S!@mOgKf%8(#uhh`LXj zyzf7rw|8}~2c%QamA3OrhRKtUDNiM1SbLG-AyaO2Uy$^d=&^VZ=|GOJ zqeIZD9!nc1QPehQ%&_O)?0Q;8mGtAVo{*4`5&s->alehyL-Vzf)y)#&j}xxg zDhii|2L$RetGDVj7Ocn3D{@XQT{f#EHfxWxs{opgKAf19?C;YF~woDJ`|83 z!WxQ=s=*7u^RZlAOkL$i**6B5E%heuwh3MqNAx#8T;r@i`9!3JRs0OSnMnipB8lH+ z9^d2Gn+Ot97^dxUVIPUV=o*G_+2ViNX-{(6CwQePaJo$6*>Cx~)Mf`j^qM62wO0cz7P%Xz& zv)vRd0ed!eb$PU4s&f{{gXzb@<=%K>ilnhslF$on08SHIZDoIJwg@e#WM`nmP3%)f z)MnSC$wEDK!1m};EkCR(^`e6&LLTj&azE-kb?~UaNYwFIYhJoe5y?U%g3i*-~Eo970*yE@4IeFnicN1N2VA2;+T+O zXiV5OzJ(0v1W*x?WvW@V%Y*3p^9)>lsFE<0i~md8G9``2kwWE?g~j&bCX4Wdy%#Yo zN@s=JWL^ufE3A2zI=h?uDb4N;yyS#OMVk0Q1Z7xxWNh|cdsb#c-8256Tfy&U9(heh zQh`%-^3rwkaO-+eVxJaXZYQbky2*P3WOKDP&NFJ3@d=so7{b4VNqaHCz^$O(#ZW&Lxf@( z<|wl{QZ(O_T)pkY6mq@R25hKE(;CH1RMa--cR|xs>sAfT-@b0!IfNiE6q?4?feVu; zs=+CqDrUx)DYf(RJ5qV2mB9=pduFygL?)=sO99qlYnV6fUy)pOIuNy6HqC@gT=?f9*~ynMn>U&-(+!ijTf`uTm!ZOdgdYv^(BoHyau zC3@sYrdpKjLFUhk=}5%!{MnWuKAuLAFz8!2e}hvSw^dDu}bP2sy; zI+rDL_jq1bAe>Dr%-2ob9IrhPSEP_+%qBk>rs2`17~(?v(eCEbL=9~Il~<4F-2DEo=sfD-EJ#l7aF2Ej6w7ho)Pe2)t5K8Xhiu>KU=;p^!Y4e`?4MF zU^}V-iyQ~5_DtXqvAMu~orJ1DqCPECSxEXHw!YPYe0O8(fx|>e%k}3d6WMxZ1b(5W ze)vs+eMDV!Q-E}a<|lc=c4%~%kDNH@yYW-`5zXgp6SGf8iI727C~^$CvHkiA9y z+EDs*Bkp&1(OjZ1GqyKNdaYdQjoiX&x|>#towMz2d)_*0eM%4e>YgB&> zO^J-aqtD0Gs!a4}@$zGj5I1P(ez|F3t?C_C?TM_1_YPoJ*9ECC@`ad!=gq+bl;UQ! zKUnY;5#QV&mEndL&gj<$)SLy1_!D|iV9U9W7E+L7+d+$b2=XY|$_K~BauYTu^e3v9 z=GLrr&e>dhB94#+BzzD{&BVyJa*omgDzUTJvhc*QQCWxCsM&^#i!^Q$yE&U&iF?ch z#kPJhi_dGt(sN4$Xs#xd`L=UV5xsoUSJ@Jc3X2UQGy2MYo+Wc#aS0cg-qm}o$N$O1 zm6ttlEV?-AH4Ec58cxT4I`}C&ObowEK75-wy7@jg+ z>so!+Dg?CXJpeB``>8k6oG!Q|4&tEo$oKl`GUe%n#NMfO@aj`+_df;yC=%Xi z8*X?<;gX+~nVE}E(Z()(?t7ACdmsQ=*Z}i^uS}w%Pb0NCmMd-DRJ;B#zuOSCs}P?I z6RcxzITXl%uHVytSB(a0_>lb2q$I=!v79FL=tkEzg`scWNDec^0y0D!a2r2UALn3xYO z14EZVw3Z=^L;$Gv^+Fekr~MJIxvyWDv2k%Do|+Dmc6)~Wjok2)>lrFjQ-u*uOXR<+ zY_py`d)68CNaMzQlLRu1B2U^CYy>R`7Z-P7P3P*nuH`AH#yUX9+)$g4s;kf6?a2b( zkQ43zilN<|HcA=5Q@H|tXT*%z`6v1}SU|ZXEK{Bn5fQz;JU>xXRiy`u~l{IP}lU|=9KrcWevSlc1!ZyYYQrOJQ%+HAlGd20q7LIPIl_qLA&o(RF4G4w)AaWMuCm0lVB;=XRFq`QGm-(h z&y5S%q5nURf5Z0F&{kp0x@Ve^U)y7YC5|f=bhheig3Zd$r1EJ&ytMed${&?5oHUs^ zr=yvfH6HyB4y7goOA*o0(0NpiQz11|?8@!dTE*Kyp3hkJ?bo@odUpzGM^`MZ(w?ET z*%Q&zQ*5SED&!V4kl@PJgHdWS2lubKV$UU{oKM*T0s^B@(J)4FUb3lX*5+&7TZ>OW zefuee{P6xLi*1$`J+Z_K?ADP5UZlDTNfKlE_j`QT&tGSrU?dD94CiH$`RR*)b446$ zzAKqaon8VbxT8(uisi+lPwcj{2|}uV27h72Sb(>L5YmbX2t1Z+l_z8J)=YECY#?m! zmWoLK4DGo3^77f%Z8BC#~6LNgMR@#+<`G#>x9M?Q$yoU=zNR}lwl*Wz+lp7hW=Ld1dW zAuRy~1xrVcl;UgEjgQ7J8L*23+;W#QU&PaLa43m?x$7!nh`io-(+`j8dBU`@V&;(>A zP-vR162wN?{g&U84LicN;OZdi&1}EGFPpE&{^=QSaat%T{SyU-r??!J`>7%qz8?N zEq|6A_2q)0MwOM3Ub>|9t=)IkS1McTajMJ;3Sr^gj4z17t1%KEGVwgjXk&ca(16PR z#_qdm%S45OO_mq)IqD$4qOhLlt(*J3U$RykZiV2_Qh`RV>?{qpI^Ty7J7!oD5C7?M zT6lCc1C#34(0I$b*Q)vIbZk{~NdW870j`{WtNyA^)8pd6YYAXT4+?8`KL(NWs(!PW zWCZBrX9)@?F}Hf)>T>l_s65v4E8b3iw`UBAWO|i5+m8zGFVwD82Z$(>yueAi(2&BN z&Th~^TD|#Q=GCV^96l~`yN?jxqNRrtzDB&dyf6<4`bf}+C#9~Md%j#p$LN=NYIst} zaK*g9LP*KSEM>yDO56Q(wbrbIj{WT8p5dx(LF3*yt1FC`b5Z7vbWMT<_uOehlqGYm zvZ0o{9_!PcqlLZ9rMlo%1)dfrrbn+puif~HZSTRG%_YD+GcPRYe7GX#vPwx$Pk(@m zve-oR4`>AQ#<&>{B30+gu3ezs| zFH1Cz7)f%M!2Vs&SFSl5F`J%|qcU7y`dYxzt@Z|)fS9;kcepv_mMXQ!hI~Qz&S0CQ zi$;9S#jME)e{y?Etp1R#HtzPE6jrs-&n0J$x#qW@6r3!>aP$f!n$DeqO~nH7lRjYA zWMup(J$Ap4lat$g5+`BE_6s29$^mSh37nQmjH1zQ^X-Ipxoy(FOK7oeCzJEOe^7b} zAjaIJx@j+5S|%o$*91lPP`2=7AlK>aXc*jWWBGmhLhc|UA9Mb=k>~`G|H{t)02ck) z<8t;l5%&YdZyviDxhJWtAswOnjqG}@q|w^}H-bnXkUUDDHX84fHVANFwfCrJZ_&KM zcUseTJ!8_d!=Gu!;sF#v0N<{!K4QKj;+H=O&0Buy!}k->rXXNK@XvwT+2!(dudt=+ zy9hQ&qM`SxaZTbDPy$stbtsQO0Y}N zhf^KLzHISJSZ8;UA8B#A&p^a=qt&!Y*Hq+CeEZH&I*Wk@^Le|ypa!#%T=JCL7A8v` ze97_qfWdCtXCY^~ZJ+ZGaAz5-QPC!6C&wz$<1lc{S#_Y%_zm6Vm?!?C?U5p=tFxZ01Zp4WHT`$q#p!k@Q4|DHHkJqfCTt^XPTl7vQPV zX)fV&wfjkqelfl`t~Eb%5+dh$$H}emj=@EB{nTY|Vg11jvImZK`V&Yoa3kyMztwg9 z#?(FzV6xj1dP+%|ynIH~_^Y7m&9L{A^2)&PuSi(><=_Yn~?s zG{zkLOpx(7O=RhHoS9j=xl@ciPylDI>nZj)Y<$0v;4oM3uJdO06T0h;;)|resh6iV zcK_WzTx$RCOA=Gh9N&d2-!J^!s`TPix$P+GY4zK=DW0}~sXeFEukQNZu24yJ|CS+#d`F}K`$^nCsjTEG?VDNd@NZAPfRqOD0xUd#(|d7M*_;pD*g-uvuf8^zq@(bg0zCO*Yy&|6ZT zeiQX=Xc)@$`u zW=W?BHcmgA8+&cJC%;g-Yi(Pbc%9t;^6_AM^aGwu2dsvzQQzDZ)CKBwnLX=lZTiqp z_|Hl`QACeFS(rt{#pN=ijKVR}Tx&nyOnYx8;vKVVS%2}Z2K2x)GExkeU+qTMuUGn7 zeFI1i({n_Q2mC8Q@!?Zg{dQCGpGVtUmFCZ4GagY)l^TT*+52BCC3~=-qoe0)W4U`z z@x&z}j1aXyRa8`RZTl0sr!Ejl!Bm^(1^tc7nvOEdW+|ecr2AL}f6jrnKN4<0bL#K8 zL=#tDQSOkB-Z$ziG%h%1^s`0EWXl1XSOqSm@UHs3Fqz=Y_3Upl3-NIw9L1nCbNB8= z6>|o)0eRn<4O|W*6P4}D(NjHX&p&CsP)iA+o8tLNZA*!*4{J z2$Rg`l(WH!)39@b*D>dW@9(5p#GF!{I$KO?BrTJ|sAxBRZ;}m7@ZCQS^$UXzUNqwi zG6SkwoMMUNI_r1>WhNWQqQ{Sj5iV9#nb9bUO`+O=lW@GV>2t6^L8=QkKI9| z?ks?YE?3)$o7gQk89-`%C?Y|}dy-a&X7>X%L3||-H@8~$4gKF*rlxr|-#JzrmbB@E zi@%0kOH3pYZjk8$PvWu26uS}hxf#7JJvEqKh4*6Tm-6>-p8Sp?L~n=}nrdP*Rc~gx zF;{ty(&)_>I#hF%>l(@-OF}A1BrCdd`Ew=uVZ=IOb7bwhIj}S3B&tlG6uG+2L zHwZuhs!P>8kPLE#`QAWU$H`SOVj!5$Q zriW-j$z%OPq@rdkHSae2lzD-H>2^V(ee7Bo(OmeDqyU4yT|3)!AhOgF$|eBy4%+7E zIyU>yr_K}Q9`Wm}V+<+yvdL^3ZgJ|GU4{2dkY!$jDReOmMBnVtLN#8zLhCGAD64dkOq8&KR&)#Z0=b&} zb+rjD+G1t*SHB_*c0T5MNJXtFD^}xEA<@1aL@1Zbvv%DJMoT~q<)X4EN-bU_BP)Ob zzBVUj9iwzs|Bnc0b?*TvM!0Nr;yHs^4Y*B|>#-YuUHJkQ7}@!h^6>wN1qqo}hAbY; z-T!4uguK3rEKi89F&)nVS9|+%&>xT+v*GBv+@HG2*?mOd`Y-Z>i#qN&IgT!Ac>r&h zk7a*u9)s)|wrERQ8TCg`L|O0mB_ICVS0&kihwRh(CL+(9r&sZ0GiH(ICE{9LXmuG; z<2GOX=<5Cl^(g`)Js0|Z{sYb^gR)&|hu!vCPM}SK8Fb<4o|M}C{h2Ki1QO+%?u5Tv z{d;ek`I`L(W^#>^+-Buq_*2$MiHG5GstCMEcYeyGU(~)Vc5+53q?=>*`a=$ zYYT}+5>>0Kt3&Su7#RGhE#Wkj*L67&TQXQN${Z-eC2ed<#%l4>9AkF>g=~VM%Rxpd zD#-jFbpHUbg&CBPCT%=uzqbkh*)kFbLwU3QT<7IW7_x8JWnk`4^DWr#x+FZ)1uY-6 z4drwn-oAai)5l|@eB|DL!&4sYV~}z_dzPDFPvFd492gw@EEMp2Y-j#eSQezh)`|MwP>@;s7#N8DgU5{Xpwp6_RY7=|6*`4U>QX0G)7Mqtt&4^(NT&(}dSJ ze-Sn)=;{)HjlO>H_vh>N-!zK)2Tw!=%|7^8@9+Ha0z!~sf}$5#6CYO%-8$i-iUW34N&hRww>`V~YMP zWI<+aB?>OQY}qK0hjSMHTqr5z?ky$|It)w@vH_ohaV5#s{wxb#1%=S>^Ws)?X7LW^ zRs?+ z-c@v(Y9EOt#YfW_)A(ZCRb8s-4M@wdNl%d!K%6=ln;3tNC0^pn+Wq?Q&r^j^W)kNh z7}c(IKry?XdeRM>Pm8e-2^a^1RyYQO^yQ(*?;0cTmLDx$#}gf%c?2?leAqS$geutZGUR^hR&4KKbXo|{WUb? zSX*CHqnQYrp#7KUkX?TOQE~( z(6BRGA&pi*K$~AlMTPG82H7*&O!;I)SYNtS1W&N_v^(gyv7Xc>6L76;X=!Os5%%Vp z92}uE9sa5?Tj#j*<{=A<>cNox1`EC&^GiWl<7-+Pu7s^dzmMhXeT$58PFXd$z#+z` zgL~x4S?00zyJQn?Radc}itOmKg@OcpZeQ#1$$8RCTC(r|0hGeR!V2WHoGpKx*tu;_ zH)?JAom>SlB)v4eB(ta#&Xh}JL|#cH+67=&=g$lo6^8khtYp>9tH=7S?ci^P{3`RT z+X8#y8je>01% zxwpx@OFg?uOT5z_y6Sg7n80z>?G z^cMl^OfASolw;JY0fdsyRymHA)`9YW(e~9*Rj%LGlmZ5zBB*qU3X&qZNhwJwL0U?r zySqe?E~QkuyE|l4f^>IxvuVEP1w8kj`}@B8-#3P1oN)&G?I+fnYtFe;vnxwwLS*hy zew5Zu;mSNT8{ZurcmrF0(V&x092`LdSRtVWdY#sXi#tBpBJN+CILmdGyWt zoAemTc+yQ!7;Rg^xlt)=MO+ukAaP=4DLNd=nbXf26?5%j(KPy)ql_;-XBR zK;GE19TXA%jHlehx4a^)TIp=1g-6V;OZ4GiXiI0h`V!jGCt{zj9*f6s?znv@W1q?I zyluiNDpzjBkFALiKTNaOb%=f?=frZM=JWBDV>sv}1*KQVIUe zB+6{_E|>rW=|0%9yW2TrGV^s$-DyvLZ}%F$3Mts3TispzkZf%f?_LTz0?_QwBS!;@ zUY1FUDL9HXNfIp;g%vX!Z4dWsq~2NiU(l-b{6~ks>CeQbRTEA$DP+R`IQ;(87`py` zz3szz?s1q_pegmlTqk(J|&gw3>veU!foqt+droz$9dHXz`x=^W1NSa{AU7f zR1b;Ei5UxP9MGJ`EHD7lP09 z!WRwDxj$7Lv-pQG4q$IJ6#;;I09RCwI#^gJ%D_i<3<$V5R3Sc4xD}rb)1)T?AXDiM z8rOL3fm*GX^=t=t2v`!j0PJvC(WODOlNq+t&YW(6jLwy)7w^=+gLihZ7bt_>`grgb zm2fK+3x%M!ZnC94lex5~3Zmeb`TXvok+s%L0+sdXrX->?xk7+W6K#Fn3EOP|Q*3^- ztK}5<7JQpb2wi`&I1x9op5Q1>@?G}3pxQ)+pwjvJMoG=iiiy(!7qnN|LLw6Wr1VM! z(#7?sFukZp!I6YnL5*aX>yaD*1v^Zf0c+Ni#!V&4V<)Qd$LkfH6G}`xP)uhEV%n<6 z(VJ^k?D;8hcfsa}KDW#o4Zf=~zj=p>#~NqoJ^&CQ*As}LI0 zY&I@XZQt@a1%!XlKTyc-a1g&%cw?W2@aOtrR}mrC3(;o*Z(q-(J$6c;acKLdn!jbD zZh10a_ZDqZ8>tUx_dbPLOD zc4m6Imjf|6sxs#o85Wl4-c@SiI1@*|?TTMhGV6R>Y#gWE=PDCLl0a~uUGtBNd9IZ_ z+j>mzlG(2x_#l>!8Y{BprDBH8kZW#<-uG9*FFh)gu*+P;l@?~kwsw@)g0?{n)PJtO7yXn_+(MhlU5J~DH*Z$01>(7tmQ z525vS1ds~leVPX%LG~fvsfqf?zt^gs@#PObdoUe!h70wdjaRA-1Q=i#_?Z@Cd_*<4 zgp)m)00ukujzrV=?b(u^v0fz!)&n-)>I+;bT|el-z_&xUY>P1}MWmw;6Pr%-=@SqU zQ!=xNed*viKe1p*Z@SJfIDJ3C27`^fLlfJs(=z}myDYE~wz1S^k|`_fgVME7nWf|- zk3?brsb;*Sn*MN`7#fHeRG|Lg)L6TtDaN>cJGr+<=%u7%XR%9RXQFRtShJQSL~C7R z$kGaZg!uB2v=GOca@21E=-R}1L5cnD($)-|fFIcpWxAQ7sVWCk_Qn+#nmpp`dgyfL z2G#m+<=ESrB*0*2;q5*D=5~ePInt;ongKE+m_a&(*_2sfz~bsoF*yC+*jQK;nCJFb zti;((vT|G(!SJonY`D(CstyFI+tT=sC)nbMK^?4qq>H>2LkFS<$%gufwtrVlOP_pX zS#egU*%0^f?QtSy(rXn<$M_6icC$6tg|i?mv73R%-rm>UOeu_Ejf9U~JZl7Lk3j^I zuDEA0-~J{R&2~J&;>WKEn3OnXZ5Ng({HKr7c@<(@cHtlLO*^~2pw~Ib`=ASB!blh9 z#KVZLDbF?r%e1shVC$?GJ0fPXt@&Ep;ud93D}5^+uH(FCnckh$Pajk37=TGDClQ zz^S-jzDW*<*8kYIYl-AON6NR!SaX$NO}d~&+<=KAA|)$SzG@?k>BEkOubBJ35DKoF_nojg zajV+-2c(&;h{!8yt9&>SG}_MSmW6wjY(p{m!lKphl)!kZEk?|IP52}B@*2eeA~w1f zfxD_JU0N!SRoae;%iodhd)jyaY>7t)^TF%edMeoZKG7vl3xy3L@~+3njhoJEVhenl@u-r-uz*_wVuS4Q&Fs1 z^@e*;o>A`o?(JaT&JX$6Kg5I0*EH4htVcyVv{6+@@6CizaV$HE+f(Q25?$gD{+Ia7 z!+-D@Pnsxk2hUrb52g~+3$iaWJ2HOPd(+nm9vM{UP2G?I!2$d+{q=&GfAU>Od&`&k z7of4{9`xsiUvO3-&;=sWxG9*D{9b{xrw>p<6hA1kha|43SySBK1_CYQazr;TA)Q*u z3p~Y}_;*Tj`AcVCKUpa)pO=8fL+t)vIW(CDL5@QO(oz;NpcOL#Bbp+bNBhdc_47{$ zlkdm60)l;-gtC2`&%j@(1rT!VNuDAK3m&1xb0!~Rgq2)Y^P^q^OyU141|z-rze7N` zqO_1qfRlhD@C^AFJq)BRi`= zW^WDzqjLO#2m3%Oh--&RczF2}h@~TJ;%Wv8&BIw(fmjb1cmZ|g-wYi>071mW$J6WU z>q7_!0J;JEMF|#$snl^Ku`A$61A;h^s|V|hL5X)+)KJXt4)?;sZP&j@Lh?Ppo*(;MEvMUzO71jlu37*o>go11h z<7Mg8r*WiLf8P%#^nThM_E+EhFxi5cPV%xl?9JRNNEhWE5fIFQ z=v9Vbm=u@pk{}2)Sit}c$e|i{||sFx-;rZI0Q5Z5LDwGckOau z2Z0a$WOtrf7xQugQ(hT3>eXHSKY*HUR2}*&T~gY>n(Ggs8jVFIhQA{Th_X$%wIVJ+ zXmAWNhyk%5*yD*`OkQ4;`FjAWQCVFHxcweSc>L)SV1+#Ehb^nAsH}#4%-E~~1tR~h zjVL@VL1+%vvbnk5fYmn>b2};q08J2JMKPY?Av@na?gj}Xd2P{VmF=rtC@uFVWDn^& zb%evIp-)(Q2f}8696Y4T0r5-(sQsVmIyyR5J~HBPkMW=x>hFJ?D-;$P*;eO)J_nK+ zCSaokbZXX{%6ZF|4?2#4_G*!A6Xytc9DHTabl29=vCAOnRN_U#3kNndLq!IWg~i3K zgLzudpM(ou;$Dh^wdOy3YG*u%CP11^#>mL1P({ zRV9J`t82c6;uWwMJbI2r#L+vzvF+@K;pyXZa~Qpi_)d@OWvQt45RKNNsi)qJ%2I)v z?VK$2OUVoS-4AoF`!gixiq5+UBrQpiYRhZILF_*JPoF=R=kHt!57M`;2KX2+&OM-c zvTEdv^3IYpsXk1GOrS8!^@gA%Yx^OuFj8CF(Km+WQy}LFyQlo|<43p_gr@L)08B)V z4)!J9l0aj6>b_X3OK#&L#Ln4xS6HM6{NCnTsN;9vrP8D1F!RDEK`+kQ85k@=Wp?DKUuzlD$@-9Mhg| z^j+pULv7=glnl5<$R<7JF=t$$`&$Oti^Dj7sSfZ0tjg78MlqA{F9!&v5WfL!U1dh|lmdoG=*#yGCBzMZuJa=T`l5b`e2N zf>Obe@w@d-m$L$>iV3le*lpHhfYjq=zTps48BhWBHQx)K4I;gcWB+Lv5Uj!)$Q1A= z75!KuGR9oaPhTeja^$syvkhlN1*9xX<8nSfp2!G5@w`KGcT#q9)S|Nmn2`|({7hyl z+T_u2wP_SlxycM^OKFSQakXzHVKfdpylO{WmDb+ z+RMFZ+tYsZ&+bf=nkCSxmdhz2$2lMA_hAY+{4DTV*ma6`+W-2|ugGAa)eRMWHbU9> z4TYVd99pmoU_}AC&8z!2SL%suM#<=FPVx+VtcCrv=u1W=;Zr;xItP;x`M> zK1HUwZ01y~bCiL%)(68^wG1|2Y$#gEsZopdSUP%Ja}?eVjJJ$yPOXa^*TD7}21z`a zOvbrbLf~I;;`QR}gw~$;Y)?J-^ua1p-MOq4zI<-EP`RjteejHQ3PyII!DTqeK-G;S z@ABA`FXb5pMFPc$Fo~0#MCgCV&9>pLEkv<2mL20R=T3dZi;lG+?g4noShY4lR|@R% z0#i34)$B#BZjsKKRP9A%Dwjyk<(bdDmM7*w!a3^8cuOOOo$OA!{N$$Y8DXUSe0Ih9 zaw-A##d3)SDJSv-#$kxj9^XSmH3G(RW7V>I5B2dF&*_rX@(ZCIhKdGGl4+md4En7} zM*hYR_a1AlEne?*{&XW5i4;qO%?GHtp11(Nw0ynJI9E*AvQeYT@OAV>wG^ zVtf4#r+6MHRosL%9=V|tOZT8ZF*!ZjOAkBTS;)Xb7vC5@n$EKIZ_+g5<*Y^VcvzxNe%RpKg<;CV9LY)RKhP+O25D&W@{j%52f{gblI!h9kh5OvwEImuX<6D_ z(pr4v0FPYCOSG2=67vc4GU|;+$|)&5Wx#B}#b%~!ytXqR_kJw0(z1+!LhIZHq1~9) zerm@Y_+}%HgTLI+3HxQeTde^)t8KqSb&hk>A}iq*!`O73hNKIyqm)muJ$gDJ)k3^ytnOP)X8vM~ka@bt6?;;IlvRju1{e6evdp^#DRR^xaH z!-PDe{07>}c2x>Hgm1>2W!1nswE__U$b2m?A6^@ic`xF#K8+jqLa&K9=LffejqleU z#y(zkz+OSJZfU^#B@#sgw|uRt8oM1@%Or>}$i43Ruzh*)RV|bI%i4TF1QuHIn@J4x zo0yrT95A3qL)rhvcyeu0%MHS%+#3=k0TaoM8}~q(bjiej9(M2KDTBn1xAI)as|9f- zn}9z7A{KYv3GdS4)O4%x+Hb}us92p2w0R!r&}4NNcyPDBL%@`wGr;a$>?BKI07`_r zrrgapZV#%?j#f|@-9!n-hd(vq--?E77*(b;8{i!&`*AzZD4u(J36eOd_0$xpqYCwI zhMMBrjV6RvGz(1T5lZ=0R-+p&58de*@OLx_X5FTZzt~?hKrB=hB-VWBBA@$ooeWOM5n8L&rXf z6Kmh|4VU=xflxgo_d5K+?~3y##*VUyn}7sRO}|uqye`{?d2CL<0bSBfgBoZ4Zh~=D zTL_-B0I+rK@#X93+z3yuaOq!CQFkVF=HN=q6MQbDD=GTGt%0DrBKUj2)CMs=v94Xz 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 literal 0 HcmV?d00001 diff --git a/LAB2_CNN/images/cnn_board.png b/LAB2_CNN/images/cnn_board.png new file mode 100644 index 0000000000000000000000000000000000000000..439c20e15d1d7079f22af33a35eee403a5cd64f0 GIT binary patch literal 40685 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%0ATv(g#&Gn~pQJvI=aVW8(;V#g0+!hBZIf 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 MlTnd|OFj?y4;_W)(EtDd literal 0 HcmV?d00001 diff --git a/LAB2_CNN/images/softmax_board.png b/LAB2_CNN/images/softmax_board.png new file mode 100644 index 0000000000000000000000000000000000000000..1a265e014a1e7eac95e11d396fd2fa4f74059150 GIT binary patch literal 50740 zcmc$`V|Zmvw>BDQ#VfXL+fF*}*tXHJ?WAL~!|vF&opkJUY#S&2Jp0@4{`UEMuIsE{ za~6iGYK&2L)m#yZ@{$O!IItifAPCY@VqZZ(z*<2-K+ynDpC$d^$vB@c-j<@GiqfK@ zM2b%KW|lUlARtuVjSUQFr0J-J4Gj$ph9_vLVV&H*hKEOgHR$T=p6Ko)>Ngl5%1P7F z*}?*D_4%WEw+(g!3K&lU$G_aXddw9!c)w$CRHZwqk@Ga)1%SGJv2tVq2PcJ&&(8Xq zl?7*V0J6+80x3=|bPrFY-PHaAq+bBkBnk}_A7HWxS~Ev{ibUj!k~Yx~riO~L3vVI= zvJ55-Y=jEWMl{s+UmC%VpcZO`9%cx~?e?GR6Yp8;{<`?xzfBsdg}aD}S15lVF#{6^ z-U%8w#^lb_%tXbM#)`$H!E(sLmGVO^$sdj908<6SwAeg}iVIAXL$!xnuqm&etU*e$ zhm}!NL9%DKdm7{iBAPj{P!Kvm&K!+54mhSi+-*=c-rcNi1Ak9C#QR-Q3(5+*ldxoy-}Txw*L+nOGQESm-}n&^vqBxfr_B z+c}f|OXUC15i@l*cCvJEv9z}%`b*c)$o`uPKMBcSM*sc$S58xR%l~k)bN(;2J{4sA zTf@lAz{L39v_HG@{VnBDv~)MM(Gat=HMMj8nb+o|^yZ$->F; zKYRXWVlpbqs0a~^ z7%)5wu^A$D?!2or{b)UBIcIr!eYvfp@Wic&bxt??v#_kPvJz1|T`EyRh%^s*8ejpz z28II~<1b<0PYfh5IGdT6`A^xuO|SqK!s>#6e_H*g6F3Se{UPG;YB_Gv|0MI-08;l2 z{=doo+W}q*qCSt8$o{8Y(*NR%;d00Nf5{<4%0z@b9eD2FUeT)bzj$g*&rkXP-vqk- z#f0Em!LJ*SB`p7sD*q+qr_kX4i@^UMLI=RM%B0Zc*VeLl9+#EebD3;`M@fiu znil{;bGYI2u#OfZaa7rMew@8>AVl5fc2R6OS3L7{kZbP^l97?&l&97T`>DQ=pLkwF zLoyF9uXFKp*V~!B<>^w*?J#NFbb)x3Q?Xtv$v-ygMgj|fX+2CMbl(CMDS7OLV^oxr zlM{L3bv-X`pX*pl6 z>J)#*$H*Ax`_Q&IvpiQ7M7OG zz4l#it}CtIe$pep{lT?wH@vNrNo8mlXwemliV^_6wNm_Ru}vUAb~@xzQ$!xk>jf2T4!H5FGhNBPef5a9w`zJ0@f zn+UPMEGZg%{$R`9L)pT#n439&}rjP?_uE<}d0<2MkNvFp_-kV2*S zq_QnmUhvK3`SDL2LdCgl)4IfTccAZ8l)j>|F{!YZ*Fm=1Y^HsuwBO6>W|Ed6w}PXd zhK3X{Uf=slJTMe}MHSFpP3?6zuWtFfREfEwT3u8Bc{bHzxz@DaXaJV-g zD1+x)In@_J_P?%1D3{pbq@oGOCp+z^*T8oogMCmIhbF`q^=%$ifzOZ%cY3Pxb9G4g zFpq`wypAz;$xh#kX!>_nwzRZNtrWs7{NtaNC5V8+m~+NJ7GkPEhUP6WttLDCd}ByM zE8Fef5SKx0bF9V3mebm?=%WTHGNa3E_nnAP2`tCMQsQPK!%V`!V)x;AVklY&-87!l zhDAMzcVMw-zM`zVc=p=pig~V&#mCzNr_D?}HpaZJ(+Ih5d7j5Vo>FK5x%<~V3}u#3 z5Hu3UX!);SY;5gV(?N(_TOiN3a|%a-?|%g0^D$U$fWE?slnNZrBeYfRvp^^F$t>xr zuJ_gp--ThZkAECwfN!V}Q6R%O8dJwdAL08n6Sn_DKte)7ni}SP^V!)M#{^aJb4@th zQKQYWQ51M6Dy6(^8+a(t=P*AEMF18Z9X%8zM%*dS#FUs`mWIQ2#l#|)vGtIIH2eKu zFYXfq!q$uxKgMP`OIBW0#Th8ib3|q=0q@%WsbS+xoJbH{d1YnsKosVj@5`Cw=G(cO zWq&v_1VYWfONS{Q86Y+tlHQBi^(Zc?3~NjMPJAkGJ1rU6Y(H_!+w2Fbte$B=m>hEfBqXE~M+;Ee8~<;Fkc<<2ch_&v_*b-2pn(ERb={Xo zb0jvXm)wun1FF@193QkPMe&Q4gB%SG1Ox;n4o#+KC4x)IYbZ`kixY3ylp9?Rg z#*3JgloSc`i41hp3OhR6T2zc*F+4R+q}V@W7yntv+(AMB_9HoJ0y9AMVhBZ#^t6yr zkdmtEUNp;EXwRB39gmEG14N$YlB~yE-Wk5yAanGqP`fMdg_dS z*QPy*|2u*;p^6XralkU;ZA03+6UuC@kgRAJVvKmrb-INkni3Maa3WeaU%GkUf)>oX@IK&WCdQnpHtp;BuN4GD?lu$rSG;Z^F(GRg=pEg8 z+u8p+$;ylFV6cGy$36bf{H7(`AH&7@s`8NMf8{nN(VrEpp^E1JD|L#G`pnfhF)t!3 z|5tt|H2Al|81N11pGfncH17XX7Khn0Xh5T}O?vIdej}0mc*jaN$td9hh0nnWKm%g& zd%D1`c~P7U#^9pjbAMgTy~f%{cx$CQi-sE)Lz61mw?Cf^ ze*1Jk^9u{J!`#qH^+cU}rBbW>Ms(sgaK@IZl*}9DGida5YBgAf>+9>mUK~EpF6ucN zVr*X^R~H5t9B0`*YtML=2Wm~nEcVCKp)yMgv!I?LE~PBF?^F;|3#t3L_O!XgWuTPU z(25nleOd zytY+RuD}}x4*s#cyqt>966!m6Nlv688ny~DEy>!vum|rS@P3WpZ##60fLO88JhKkR z)<)jkPg8f%~DUmA_d7S`5e z@9yr{eEGU=G=I3{gt+`f?XTM^IaSGp6!a)}@2`vh;)iq5p~`)pZ#cciLwM`bEr;2; zvtv{k^kq+?SX<4xj{`QWPldlWqqLo6-KIILDY#Yy!$4Ac<>!JK1`3Hp=h>NUFsAos zP9jztPcuuRgW{i@jNCpyuB}pFB5a_po=V*P(hDT)u&XSQrMB9#va+I5ODQd66+{*Y zhelJ?@k=MmDoujq$8aeVN7*fU{yjg>96GN8JZ5qh$|67fiaaI2CUYc)osc(%j-J0? z6F!Dw>3~E=r=_K(F^w-VAoZu;65!_oB@?J8iF>eUIi=m{loG|2!=Imn5%e>HXntCp1!D@fT0h?#kP6)2^2Mekp;~WT{Hp@ z9HZ&l#oY-)#fJfkzvh9)1H;mBi(81Wl#X)6P9Vx@(w!r{mrtsXXj;NuO^2#TV1yj0 ztH+FxIT99j9JG4VrR@4Mlf=fty09sanA=j{C}g{KlmRP3>ik${kQ9Wob0gy2ehr!X zfqZBRL1r6SvD=(5fbokF4bW^@YJfmDtXXV1lc;$wy!%}f!Nn>@$O>RE9TY&t){!!u zsRfmx{pnB-gZAVVqznX&t@>@3$znUy@NF58au zxnW1KfueUOaj$6x;0gq;5(hZILsmO;{IzYnZpm^MRo32q6U`h~O-{vZxx`7Jh?m>0 zkEjmOvGOrp2LpqXqk4V+9Ex?rgVA6R7{)6qc>wi$&uL`A9J*2BkdR zi;m-w=UTlMeh3oJaUMxdFL{#-OII{#@65Se?hqHO;m?yS*w}&AEUp_g8^pFR$aJwG zHep#)6e23r=_k#5klw0Ei9rae;@>n@0Nwqiu`d#hV+}J))cbW&Zgz)K+DV;%_uo!% zpcOL{6))f08hTW88NLHqJY}5CJvPFHiALiff4C)_O~xmFNR zIAG=P7UxP=YP}M=f5TUN-QSpHZZC(ZPM6AaAFgbmVxjMeI$B@j*x1)L>$CR7Yp=fB zdPr0sfeu0?@O;bgO5DPT`Iq`n4`y?VKQuJUH9b)>Lw`f3rqHJxnjqhV%&6g5(=!-` zJ&F)gfbav%XVGBthjjwwapth>Fux@@L!7)~*h|PfQq>;9cv@9-p-cSzwf*LMax{bn zC8+nyPO9#kPGDnVrvWCopZJFv?sh<$Um!*UBaWpswjE)9XK8{`F_JK+C~=cQMv61n z0}SlF2s?!JW~O+~3K+`H7dTcXmO)RY9d&x$I%I`G}bi zI5OOf9*_uN#`;2o3hZttWz41aI=4Rb(&|n>{(vYpTL26Ln)#xw1=!Q~1!-7s)Rt2w zD$kx4j{SJ0p1+Vzdwm+N>7n|3lYAuGb;Y$*(_iQ}?MYzHA5rpAIg5lb$(fPVU!Ac# zRM=gtem)g{;fElhT6NDCvjXv(Kc?h=;+&6JKc`h5CU82?j?q7hRlFJ2T)>J7PEW*m zn^e=2&dJb@`}S(Fzalc-;B-MnyjlAScHtDdNH<-eGc28CPUeAU&g%FUn?!NPICb#g z!w>^3F=XOu{as3s6g#jg(Heq9Qpg_kS9f(uNto+-y}jGY?5xOod&MtSo$q{q@;-Bb zuk*xn(S7YP_RT$Ou8nQKZS)T+b?dzz?5wJL#j(Fj5s0s}4UmT{A<|FnL?{Y~Yn^Eu z?Q1(Kx&GKtW}-@ASX)4$tqW48Ed15Fq7`W{L|hCMH-3r~<9{kbqu)K#M5X#tkVQcA z!@|<*G^5w>m|(2C1SX^xMeBKbP4C0 z^&MjtO?7nh-$Yh%j%`gxEFHQcqoPXl@{)Ru#*CtfQDB_;z1-XODu39f+@Kva>tFK= zX=Z=>7JMMM&L_Sx68nkpu#AqFC=ss2K9FJ0->`DK98R0q@Cc|QcUQ)fua!9Jn-yNX zrXQy2$3XW`xV`FKS!WsE)5hf@^OG76iR)WJcp`t!*;fDc6|0KUh8<#eR~HvWFRwP4 z$gMzPMakwM_*ObVtH&CYqB^bH3Z2cjIz`YPFxy1xUJ*+LUnM#~pk3zxs-<;dPIUuo z{D6|dfcUaR!)hes>Uva6$-e7>f{>3UcUzZL%%SsRcVO$LRx`cg2A4sP2844ddmdT3f^V(~z)) zs5|R}cqQ=gbax+sbhaciLor$C96|d9@3j^Gx1OQ_pmoRNCRsC5)g*maFsu==t3>(-}>?D?YY6oJXCiwW!apbqn1?T9u;s7vJ2_e8EH50PGuB+6}n z5flBx?S5&1!)ccV7+tBUuTLVffYwvvg}ZoK5Q&&63~w&9+vo^t_y(z>t7~hIbniw; zXPK`dRm>-o)l(^iek%F3IGmkH=s<9#*J8-5prHAiEH9kPbY2WLYX&=+shJh2Zb+8$ zPD?i)VT@EJw*J5!AzND2892&!te}v_MzwMRo?tAg#HxZdS?~#)^ui93e6C0qM+7-D zy}0li!kLW%tH6}`ZU?faPvaiAbm2@`inXmZlZ`7aq}3QZyzD^GY3*d(x(AP?uXTPs zhsv0@WM0DIc7i}xcgB~Q!-P$4z~W8m`dD}~fm*8@6%J7eZSBEVPWz~n8Wb?jO{ZgbkB(Ykr!;W602^WBgfTw-$2 zXn!;&=y#nCfIe3+HC=d_z>A4#v)Jw(U~`coKjSplADto;%FQ-hL)ykJ{mEQYx-6z* zd*=rjDY}CMUP^PAkZ2rngIJ zyjZzzU>bxNM6b%s5YFfYoOCbqO%;mL-p{PEb_0q{OhO!7e$?Vg8L~H~_A$ zSxb}r#9Lel78JT4RXnR*tzS9VF|p@28wS(GxmGjf@#mxyH7i~O*c}oH$~vp2b2Nh# zQoO%7YfdLy4n}ua-W{_$0Xsh4!(952!*D17aRS$5KG!2(d7ckR-D6b4d6sSR>woL$ zM2c1W3<{3xjcU55e1cXqllq#B``Sbj&7L`6h1srFGAPPS_!**i~=-}GH=VZlngQZFQ=sB1FM-RkysI*3F-)O>H}kjRN!( zwo(|-K>>s&=|sDYHDQ=bAm)i%nh?9H@}P`12!_m6aC@n0ip*_9W5!bqPbVogl(lA& z*F*(v)#(Q5Nkiw<9wClZ_0X!pyt4I_tAPv{a-xsH)tPcAdhzY&O29pE&ZOisr%SzX zFEp`^j%(l^{10E}N-(`A zk|Y{MRlbWtS8&H{0C9bN1K;FcTWoW-a>r&qX`?OO7m84%RCq=}@d-Qh`IcKFqy})9 zbz0b4o7>uJPZO(RIRG2sw6IsGR2LZ0y8C)H*=|&D84e_yC?JI%WRjVz)5HiI)v4f z`J}nt$P(0XUHq?gCvVp!NaWKuPy{Q0iePDKE75U?6REX1`sAaq5??GSf;L2 zNQAJOic_xmV(Fu>(gBl58jWnNU%&5{!AppkoI{gsrM#%hml`(a_5_0kA^DdCC!dNw z^gt8-SzisEZvBRP_<2eejqb9T{V)^f`>G$h7;JT4^4blKglpHoP-&{)dg_chmtT_W z%d+nG5p+8vDFctN(`d`?GJu|nTcriLj%Qmpzq*H_u=adCXD&PZ?nI( zG(ETgb(#ldWzuHEN5~Yl)Dj}qGFLcq{IZykKL48Y{g|u+d8NmicZ~LZIx@(LskB=4=#W z=P3R!pBf0f^u9P!y!3~cBmI^c-^n@TUX>>^nzSM-P8h3z4U#hKXm z$B8=50BD95Poy*Sb<)Z$kNko__7rJ=clF{oPb;C?-d?cGcv^GFfTj<)mbC(twzU{M zO#AzD&w@Qd_tpEsmb>)78$5Cdr!UhXijnxP)eU5gk>0!8lmIx=tl!<0dhf3#yp|Lf zz0R*NL$g2W&=~bzBYL20`#K)p=Ny8ZFMDpdy1Yso7hDv;wd;#yQs-ud@J2$nY=bSi zEP4%L$6evRXV(5l47xt!W&`VUxmRo}^#bqhK{BF-d5i1s5fzNP*$uZX1uRV3?in zsF^pYRX}fTj2*^Aj)nGA#xjbOz_Vg|R%42=)>K&sxwjuexaCy0->Rl5mS>d4f3vT9 ze`2Hal)ZDb+lk#zLGg)Ld%^xy)V1CXOQaOum-*$;`PnGg609*lX+-0&8#GNVv1E9Q z!Gx<#P_zD!l;<(e!wH4wb{ae;+t(%l{H#~`B}2qmSxM@VdJZX0{f_7`QhqfG$q`sS zO95ad0EDkF3+g z)JEZaA}aO~AneV7h9Yml*UCcqvvUCej|Smn#jM4}sB}&s;Ei>0IXk?vT8_29XLHf; z&02085)oqa^U$~-82+&CmWxGL->krQ1%J`uOWtw$I>r{n-pnFQB%cOm2F1l2h9sH3 z)vSZga0BrTF_kYMdBAqWnx$lrRJ@IfZgLq?F-do?zE1fH!_{uXBqWMM>^hPPCt@=W zcmYc`8(0GUCHbPkm=6ZajW<4K$;=h# z5jj)I=R58tiy*-^$}7zN!i>)3EXvzAPUuu-pL89~#Yad5mlmS+dce52JjHz+BzDn5)yAZ~1NuIE$Z^7XSaacCyt5c;qIRY2P5E61E&kGk31Rrp#hYVy|Js(5a zgjHw|T9iet=bt#=F&Janl&czXyfyq_eorVa$94jJe6%wW>iD&x0gG>jS8hD`{BKn$ zF`^O(-FYx*Z-eZ%+brjE?Az4Uivnt8N@WiZ?us3J&-=|ymv5vQfYlB2_ct(I-vRP= zXPNx(ValxVdaCJws)`1Mc@e1~rXXANI=LleK(80jG=wWxM26@T7E?KZi_s=e$`|yG z?TiECl-rH`ICfu2!JKU2H&a^#vL*78rq&csWOGK-@F-?4>+EPd2`U{?Fw@*H$HEhV zNcq+S&;4z%dlRu+n+kv#Xf|C*WvwEz5JuM9E4?)FLqy3yQi*@B;k?*8wU$VbR4*yn z>OGQ#KZxh?$$E!_{cg7f)-nfM~t+~ksxD7HASUW_mv?(&c={fJxv^*O;~-6R0!+iwkW*I z>;mqu<3!hH9u+bm#{xm)nTcLHUKhD`aa=}qL+bJ#2NG)&H+g0qA1 zf^`FkhOyduey_?Y;Qbn5q;0k{N+p8igksO;d$XyJY6z~G#3alu-qmW>NHK2Co*2JS z!@$U8W5?1`EBwXct5#>3$Z5#ZP#fxToA(;c*4qEnUz#IWx(0>5o!!4Py|aU&>XK(T zy{o3ChN5=ZHmgv{T-fQ=Mh)N0;wia>ANGVgs+`c!T;)AOt0LeEHuDKc*%Z8H+LM;! zhzGmTz;I9eN~k_L3<&JLZ4tZZvT5A^!x>?Qe_UlMLM1P*eWLD*Af}8*ZFfyH&>X*aPbSll9$!`>7L784g;yL!tu zgUb;tlWM&9^HxmYdFP3*R;LZQVb%RaX5)0jqORekush^bNiIViyT$Qu>d=LUBxQLf zwyr;v(SCG*7Qxyx)Rp!^9BQ>2h>?F=e@fV)&__Qj9dVPMrZ*Y3W~glXK<_&8LoJT=8jAUvDBjnx+e^X-GrY78 zq;j1Ufhl~5rPoMIrN^IB>V6WpuWu>Y4AwX@e~O*oS*n|PR^{Z1v`M-ys`Uk$oSgW* z^O_hJucl_6_mYkRyFcN|iVM00Q11!$uOEZzbG&v{?O3m+c86kiUWUum3egY0TR&tzu%(wN?X$>!&c z4etvPB{o4d8((3*uWGZ7jPTN*`ef^|AL|yUXLB2ZPJZ~%&rnQ{lvF_@f*BVBi)s~r z4eJbJm#?opV40lg4p9h$r+>niKiyn9>eek*=tA4p}tN8;7_33(F% zvFtqd`kaSI5w_LnJ1B@FXo`|*$h1vTBJVg0ZN(xl2?{O4=+x!-( zhD*_!{st-mO({$y-IYo9ZGYydvK8r>bQ+TjVmQ8*Db}K|)lONm zO1}L>WG{zp@4WUk$dV*KEu;pCV#Mp;81clmzKD$3+Duk%`x++T( zLR4*Dq}Ba$nd83sUS+ziiMV(W@b~DWoA|5`-mSV31b;eqVuUtea_nRe9Y^_ewveQ% zzA~_ph7>=A2F$}2)P`B7ZNgh^OS=0+uUM;v=&6P`DUt3>gD%aDiZ#5cG**dpbusdQ z6T?Cf`?crh9%Ol}_dsTxD}R1qz7$4mAn4SxA3Zn>`=&ox;G7zOHq-&;!O>z>&;MMR zn})megXPc_RdGOQLQkYx{f<}X8KC?X&Z9x}T>CYR&{XHfMmnzNfL1iovF;mG4q!LS zi+O70c=$K+w7v3i+6Z;R_5nthe?!QUuKZ~!`9ay#8!=HPX*im^Au1S+&74}zQvi|0 zi@sOVA;f+7mdLtkauTEU50f4ZcE!HH0@g}0&&UZZlWj2C%c<5Bi#3(h1ea=kh-%eZ zSqIh#e8kKQFs#q}>AaIQ=xnZgGA&uNUtky0qcB9rRt9AGc%Wl`}=ldfZRh!4(# z7zL%y3MrK0<^=1KIY=6K$9er}Fiq^1g^&TW?Y50QeU_x{&PLYOwD#4%v#Py}nnR$2 zEB2%HljbC3#yrA$z$9(YQc3i^sKz=y#3i`#m-6e`9D(7_2af#y6+|s^B;!-aym^5M z>xIB3Zj-A~(+Cc+s7#MdOt*aWG*I3o)ZTIIi%RSP|4=t%bPud2imP^HqX%cD^Gp#e ze`6Wv4Mgq?^GNMs=+&&I#%~n1aj2O<`@~8s!pG=mO;ML2wXOi7{RUpoPjtb*RY?r541(uzFa2GBMG zOD2v#8}x$`#wcuZ>e4^y)=UznLwvQIIe%t;sjY~vW6-xa_unNxr0_oe#0o7gz{mMk z=*})dhX!x@u^V09aNz2zheBG0;*rIi;}$X{mXyA{Sl#STG}Z$-F0X!-DJ@y8anWTwLHp~=Qu10BzzjQTXM9$ zMnpre{B(z|NCXs-N(AD#+27akkynsn=XjO#>YPO%(y{wB%OBOardMb4r1`)OKs{?jB5S`giK~%7H z6iBt(kZ5d{#L9|%pf0V=ddkD2KjcxGS?nR&N`ha5=ziSdPjhc4SjU(N*%RY`IN4rPSF*&r}9baS!E-MqP+GkQJAX6PL{$ z&>$fSWd|8VH<$B$JZL#yi$O+D66D43@j2uPl%vO=zEzo&a)l~2$~mVd^4uox`&o>N znpvkh2gdKsbTzxgnB^A{07s!D@3>IbNVP#_&MHj87|I=%+F45voEbV1mV7!3x!wZ_ zlxsg1iKF$9V_OzhI{BcVn-jiCrb#E|U^kWz`XXeYowal7lTDu(>4W?GHNFH_>!eI(Wp<%4#Dz7YQE??JtFtJ9Jo1b*30CZ4LVUv~gKf ze|#0uel>G5*#hC3X%hggqtDb}xUPc`y5crg!Xr#_^i2ZWDV+j7Uw!2N`JN+Q0KY?@9)o^DBEnMupA=Sxz|9yzUaf4fG&6Iw%pe$&e^%2- zjaoezyc%*=3K=S1B`7T~Tz=5EI5JzIm?XJ-M&M2xRRg9(I8*7Z>3;hqNm%FV`r-5V z_DA&d6QACiYW3k=u>G%YxcM=CzTCk{zvz_*f%p~qw%$@l#|bD>IZ3KG66hR@#@=4~ z+>ouuIdchazwd%4J+sA)RGZ>eFa42eOJ4g*usIL2UmI`c*e-$HMDQPhdCX`cg#c%Q z>?pd$ig4#{vi(BNh*)mQ%9bGD4-|{l{hfX;Xn^Y#v z!O^b}8tA>J2$`-}yNmTB3irZSKh`9mr*{On17nUOn)8lv+yw-1HWy@>?uOy6e8y`f zIJ5UHg%=^&Wz9$a9`cI{Ij?*l;S?bnaO4AnNd@#>O4h|F~2PImCku$h`A(`f>kmb&3EVXYen zPNP-4g@Zx6LPMce4CiUr`FPtzQ~>m0aCc}|fp9qt31c`sp0LTh?W*K5k%ySFovxQWd9XseO+Jg~ zJZ7>EyRNHoCq!!DP|>jseLZcQt1OY1O#fQ%xY9Q_ANfO`BT#O6cOU*b3#eH!4q!Z>c# zKa(Sxt8Xc+?g&RDbo%)rLL=6%aeNLNEV*2Pb&Q;tD0EsiES%n?F&fhz$!2MkLZj18 zmf_ZkYT}=J)XWjpqiBN<#zVCTsejjp!@RVsM)mS{^^-_V-e8#3FOt5~`xqD)vtr)2 zA=%%9C`)COX*WbsDP)J~#=gJyEHmJg48w9by*e2?pwL=dl6-7|bwXG7)E56XZjYqn z4|>$wwbhgRGZd$wp>&qckUgw^QF#B#$6$@eI2rF!NG~VWxpN*e(Eio?aq1t>DZ{JCrCuu z?5q2{WCSa)L|?jaAMf=0Y-C_cg{Svd0Xo>(`YxHUS z&7A#*QJLw1z(qHA5Ez8({QYjG6wrr?0Y0gsj)z#tA|H}dwz)|n>0T9xE;3E*85-hE z1s+BMfM?ml+z8>%)Gt`yf_o-0zzX^NkvE;IJbC^oLJNwNvu5A$sJWR3yWop)e{~hk zwG!sE5Oby%9O6xKy~|>(w3hINy}j9Q#+YtH9$Be~REK$%*=$(ECH+=Xk(1rm-i!F9 z4$*W2K7_n^)AK^Spkp71@03vf!+q%*DT1JDy_sQaK$}k`5|vHi<5})CV*)N*myCKO zZqTD2%NbZS>OTcYn+ z(7oQQMiV_g##+w;egycx#;+#4xVP!dt+0&7M43!D`f}xksKB&NF08rMv5NV`Al`TC zm-|?hD=&!#uj{h|ynp-f+k&I8$RLP1t8Sy%xG!7PdvcXrrf~N8$vXyWXq=|2q0SxoA zVMvVL6@Y2K%psj^D@uM5;3R0el${;*fC{a+Lk>;=2Z!{){L;dA&_dY8V4gvzYc0$v z(|umE40V^V59>d|1NXBdH2WY!AtI%{kAh$|@aJ2xs+n)ohS+VKwj8EV*)C#5{I3cz ztueB0cHCb}$q|^egBI-8$tGW6TA4_@>rYYrVw`tG5jdqV{SrB6xX1`%TlpS&k1|00 z!mHH%j8@P{2IICokpDOzn~H6+v(H??Kf!|yr0Wn0OXkY4FTN*v_Q$GDpL=h6BcJ%) zdGmz`%mIFc`On?%h0pz|gf{$1E48PLJwhnA}`#TBjay?oWiZDsD2tiW|qE0krE;r!#&__Nr8t5z*dUnQr z*FG#>8dg0M3{fBO5~^zo9yFUVXe-%@w2Ry82Xfo<)ctkf zHxMWSwz%%MjDRR>i0pwqLeE-{qFJd5z24sQiwSo@5eBZ3iR}s8SmqMX13bgx0mj)r z&QhB{P;PQ86I|W(-_Q(4*!lw%KEI1fCt>nsBq4Ag08H&4O7HK5Cf67ka|+D2!RuE5 zW#`BNCNy)9sgOBG7=Lmm_q6>%+3LgW-WZ>WEmUh1vAk=iv>tj3xa%7O zyk14y;>j?J*F*S@lVPg+3a+tllcv3FX_2qDFqgdPV`QsSqc3%$rNOJ&o8EoD-V94> zDK7c`wAbhG>MhFwMQR>xs@@{h7$U7HCz9U%n2Q+Tf*N!tr(u#lqHuRSbevdck~FWZ zpJds6cK0t(U4PMdX>45`7dlm5In&Yf4;>~p$r0CSp;*+=Q#E$??_-sCQ|AnF)e$6_ z5L!Mi%O)F?6It9FUZIb1z6V+yd7YX?oGg)IJpy{vIBbCg6htmu4Xa;Se9Dml5TI$3 zfL=tu!={>P_{=c_&Yr6GEJ$Vy&pm9Eo;U&gVlmVQ4B|5Ut9Oi4iee?0`3Rj2V&IR2 z@2i~BX=n!V8CBCmFp&Q3rOQtpGHQ+Cl7x^V`YL>B*V-CN#C{6NB3bGEcZ(IeoxhtZ zTUJQnKPFz=n-jwFA|MBP*`ToCP|gT=RfB){sUYOdPSF=8eL^|_fov{N&_ztX09HB0*MF0UjaZ^zu&Uu%YhWO9H0Eio)VZZ)(U^klUg` zN4@6f%;1yXAsmRwMhTt1CqBA+*9!%g#vMJvraTzP&3*a1VGXP zP;C_#<-@E#uV@6iztmW#sk~JSafKum|kxks%1|wmywaMGYyX%v|vFwa?<_4De$I zM#wIh&G-#{Q3lM9T!$A;yhj+7CcTM#g8|11NYYyYaqL!se`h7Opty4ExqWkfNLS`1 z5iE(P?Ol&;Z{nK}$O5d2=lH5-$uz^Sv~mzoD9DUx%i!Qw4p0=&ZF)t}2$&<($QrFm za?55(q6ISS7}%31ez~C?;+?9AVYawAxT1G;q-Rv=V+XWJa$9cG-p3zbS+y~0DmIij zbS1E(9RWs%mlvIX9j>ig7a6mGSwU3uGd7mIFA$Eqfv^f!&&vTRe(X}}e0q1r!@fn? zIg%TiJN@~(N>~~GgI#Jd?piYrkMdJThfPBH>M%J`Bh)h#_HTMo4tO0qCY>r%9oKS& z(q$OAGOwSrqp0nBOshNp=`vMS)pc-+^Y+j5m5!K7zGiBFnq$|E#Y4s6|Xk=9t^%S%xy4jFxidCQjH&?@l-Oq>8F5g-8|*6cCB#8Euv5 zGArULxPeS&lv|zBK-s7TdQA0m$r4O-2c8%H;JXwevS%Qtw$f?Jr@57?x?vEKaemgy zVSF3^VWSj$?L~L@H0quj7*v{?)nHSc`ir1|-{~1oU@_1RaWkv?=fV`hWYP*!Te+Ki zj|vSK?l|NnqxTw5h`1#xxT)@zI0)HmM~3=7<7;2Jl%5Xc*@5+IKwzA<@H9YOO115m-5Zs`Ix42cZFxxPKZETs0Vv0_aG>0jhoARw zXJ0Ppe=O?xsPJ|a{h$8=2y(qJ3$n!Qb*;V8*A`OXf17uN`nmhoXuJf8g(l)U&|`3)#Xzg2GwWLfgqIJoI7%f1_^IL8DMZuvk8>V- zu4&RB+~Of-^kn-i2!vQ3EEi#MtRM__g-H?2vL5-fO}G+W$m#86sXVNJOeJ;KsP9;w!_b_Q%siK(qRB6I9xGg~^mA(i;XPtU} z&CM-z$KU==)zu?uzd8HTBM(18YuBz%$f%*Ak^cOrJ89;u8Fc&!$I`1T6fa)-v~=lmI{KI+jj+4!yw3>NKm8m5m=3)7 zfZ2#wA4z=SRm~HcOvDMBPTr!}Ms6=JTv>sHS->t{kOjh)u!4q+5NGBQ3!U&Uw7~Y* z_|>2P%k-D~0o$;O-Mqxqe-W>aW^LuhQ?HBj%V*B%Kh>1v;2~xTXaS(j#;R@*gzHpE zUKBTp7tpv7Z~L4;vNm}CqZm7B<+p67oRH8*K$Jh`f_OljHA?z1$Xdxd<2?ZZxXF_T zZD{k+XW9KckDp3(yMi}5Qreyz4DORPi9MijMqqg<|X_~ zGE^*a5MCf+nR%S3%2tJWWMM?P^$n`LWL__UI9Zv_cvV?Wo*=GqZ=6DQ5cvj}M@|X4 zPd@n!U3K+kG-2X+8a8YwU32Z_^zzH|6Po+fQ_s>@zIqLf7%`j%4JxHCed!|l$P#p+ z3BKy8FVT=8l{9J61iIqNOIhpt3_(*|Q?s2;KKXbf&D^>B(cUwr)3Rl0eBcvm)K3C} ze2H?Y$q>@y#SE)HN?to*BMZ*QZZ|ceoo)7X!i)f+LIZit{}7#cvB@Vo-;JM{*AVt@ z{3X$8SC}iO%~1QV(9YUJ)mI{ahjzGg@Gv#MSgQUYjxS$}_)F!|D@o~$cw>~6p zo?f=(7(R>?gun~{+ra?%)*pJjg7mEetgk~A5pi; z3y8!!AWty>7TR4j(CqYZq-NmO3VGDv);Hzup!27X*P1? z1Q(6qQ!VFgZQF&7tGi+wESmX=l)W;>{?yi86`g9n!z+S^5oKB9vUnrDkU^w0xo;ljnXumN}B zeAowC1F?hFLw~ThiZ^TsamOV4na)iLr@fU zpQ6(eE~wylwX%u`8cOE}NtERjMn$;SQRSXX#qYe=D(x{$1FrjlJ+&}5z(O#%2NQy# zyvf7dW9(_1S7MQ!GaT2+giYrM9d5k@%{fw>`9I3;#j@GiI`Q^j!<^#0Bo)^Ej%RdoC9cgJ`j*kUGb%$U(Mi)Yy$c;FGkL<|ft5qtWn=V;!% z{i&j|g8p**T?yu7v5fYVlWaUUj=^HZT62cefK&)i&)h>)zdepJ79YW#q9E9Lf}rtr z$Z2Lo0Kd+6-EWqn4PN~6Vk$2_k2t02g4?ci$VaS!K)b*PVHW>x_gED!VZw}z ztm0FJ?cn>1zTUa%kBZkT41-nYOhBgnECv$-ORuuijB_k;PBWK)l7;gU;kt%c7{fm($}gfg7p!Qf`ET-waQTRQRQbz1 ze$HVpovbWB`N%wZ^B*JUQxjn=Wn|@I%Ci_F>am2#&{elk{@;IUr0m|h z-r$RloM5y^WC#DhyLauPLDgd^kEf>ccsIB3M{gL>CJqu{d6rK7c6*(uD||D zBOJ4A7hZIpu|@*rXbKR4%fCZ}t+yo#W2Z*AOH4)(c452!%ELsXCKADJ|Hw0mj^ck1 z%pK(Q2WF`Hcl}B>z4{f=J_quk`TE2GzYyf`Yzd)HwT-wV_YkKuzFp8rW;)~J$UCD; zdCFdXUF37Q0MTY!7z@dQWbLj9laIn&P7Vv=+|NKlE=Sx)Im~&EZ=Cqf$uk;GK45}f z>F`Xz!%!ATe4Db6b?RBFI#ztt3kvMjJm=gq49&olsgtR^yqs2jwwm_ee?LRZ>(u_D z7RVQQxW%bzx_tR^TW~`|gE1wC^0H0Pkl;i7`RAYeE~-SaXs4|sOksWz#lnQn##SnH zY}wk{+Dc7LO-g}Z6pnmU`HOhJM|>pf>+1;v3`|8u)6s5nVfico746(eE#vp0ac!*$ zf^PGUZR|v#gT&CNxwwql-hGXRzx!|6HGLipQB=5xU)=n+xx<$z#HI|J*RN+uvx_Ei zcn`min>KBx5Mzq#C@(_8^>DT=$5Vl}HS@J6g$Gg5;pfqq7vmZ+PkxTvPQ}zN<-2p| zPRbuuP2uA%rz!vXc`SL9+kpBAD&4Vz%%LC)qrBtN=1FrYYQ=}RV?!H2&FfZCB_G?^ zwONgn9&uZ%rqNIqj*B^bL_-~k`4W^!P(J$U& z25jAG9-Y4xtX<|=SE^+V5;gEZbvw1Rw6MTb${)#ZnB1&9AV;0dh|GTL>S|f|Eb?6N zn(Voc@blZzf(m*Q?$=&>Wv2u8E;)JZCrdu1E7`nDrWrH#CaiVXYpG-j3X2l_4T;lngT@tvluWry6xszwqZX) zF1W$B6J_7qon# zx#Jqr$)xh@-OT1w$%y-_yxpvgq!blR(5|LHENZ1j5WH2S5@=O?2$Ol`bq`K{Y0;cB zN_h=)KAzbu*|C9W@4e$JEDt4+mw844bN>s-&!s9uxN}l%Z5>tel$T5pTyMPT2Ew8= zd>D^l?E@B;4I4JZu)~#kagKb)jUPvA*Q~Q?d?8R4iS0h6L=eR0&YdfT5G`7?h|>y#=V&kFE_#;nu!x9u}0E<&+%T!^`ov`X34yOt$?+z zli-+ML6v#@kzy)kU$(aN90q{}i$jZx`5Bt@O>>0K&(vg?a8&VoS#&s68jIw(^PF#F z!#j$WCgfwrc>hA{Sy@?0Wjte(ZGtcj^Cy(&O39vkn6QkA-xs%hwz>)WZV7rZJj{X% zo*S8}t4DA@x+6i*ednF`S)nkS2M9u!Z>B7)|Y?rz( z7oheWekz674uk z2y2DIZ#-%8ieIE*`~1i;=ZX-Dw6$@kQou7nT@(`9OT~9TmcTmchFJg$yIoyH&Zt1I z@!dsxRI-S=pt#I}*`1Kp7Ratph&V~`baR~XEHHnR2ZSOWHA0wIQmuB)pzgwitB5MVlN?AXyXZQ2xL(b>+O zwT5jjI#6_4ZTvEol$gRDY{bU1kPF+fKmOsbbnqcOrDD-@&%H#)9-D>@pva)V9ThKL zZ#SWG>6=8)t}xx?_$_?nDs!7l2)bBAfyHOAHCpt#J%>tZk(O+)1%J5kvn$B)VHd%% zBc{f%QW>;~%bq^RJkKvQkMb|}pI`o=8KRgXmsx$EpLw&wd@|1iW82 zCRTaOd^u;)poN9G*kOkq9OLskK|fqvoVdQiE6t~$TG~X5skXM(m_^I>zy||;2)a-( zWRs$;9kivfnW7EN2{UU!mOFIJbgE!YV+Zff*fwf14duao?Oq4*^>FHFVxemMz7*ZO z#VB%$qTn8wSMk6HB&_JiK6V>@cEZ&(#3|%jX}Z=fr!AA`#Y*XF zXrk_taw^`*Gh;%~jm5g3;2we6y#}W4$$iJv7Yw4VZQFQPWY%7%N*gyOO%V;5?e1Zr z9Wz)3yndmF6$N=d+#p7H!C@*Ugxx%oncv=Ql+(3rDV4UchF3vt{Ha6vg}Z8Fu^lZu z6P%(gFWLjenK2_5%gH?Hs@qKkEsfM&I@p+9v`0r->ud__s7o?JzmVz-SxyPMr=5Nh zFJyR_KKW!RVG-J<&0Fd6%P%(Cycja;-wcDd7N^}35Mo({Dg5-%fj))t-{w9KH5ETn?u?QP8v_g@IQ5GGH#j7W5-4T{y_*#8|n1o4hRA!C}$%5v#@ z@w_2~$(Y1r%(L^q%0hHK(aR5-*U*3qj}EHNZ@1Y28_cR*!JPTKT_1fm+r^y`k6pcl z2!3#}pbXv|Bq6$^Vnm$puv57`+$lrQ<<8S^8Fs=&tSx7)b*#SJW)+R$0VM?8AV^*? zC$9h(c|#CRXH_)Zw8{4xgB?5%y+!bq>^7|@y;{9houJD>{|Rl6JhKItj&tVBwiWfr zBTpJLYmYw4Q`$^RmnK)w8& zYp4XXK1ZHR!-tJh4O_YIOM%dbxX#FNTPb2G zqMY`+_&4RJ@JB)n7(vxOKR^4Qz@*v>he=vO!K3RSMB5N5|sjjHuZ|8|T&ihI{CzxqKyK9+gL}Y)x1{Z5uWqSD`7S#D)P}mVK z!e!sJ2*U>`U6Sjh+IBaY7Tv8}bdbpio+QMI@npQI#*1C8;65lea7ZZv?XV%oTIGtY>PHTqN|!1{sa=KS-|GOnsejU>1mgCYWi{x5c;Ua6xEXwnQbQ$2FEFgnGw`VbfEPFdCgxHlU zKBEU8e2j(;9YX8YZJ=|{Ju_AftbO>=kN+!ntvWgV^polS`yXV_H%p9u8#`5AamA$u z>m`?*Pxs#YFGE;1Owky#^Dj7Cm5mNlA%MZRAg|d4!Gj~46h(^auFs_Dut{%GI>~h!jet)CAWX_rRp{j4QbcIX{A43+j8)TpijP1S zcR~f&;?a$;@dLb7Jor14!>K()CnjqzCI6U!BDW{xcKJldESk{Od9w<&c@e8*4xe2*WPYst{ zcCq0f7gMsb2L{;Jnlo(8#<~f&g=n@y2l_=S&yqa&L|+N>A9?*j5LjU|7??*v(~2D# zg=P(9V{2}hRUr&JDGGuBj@c-gZf0czrq_=Kssc{s7CNGvC_SG7r zNi)n-S^L2uJy?Z&;f*o2gcEe$=$HjLJCX_(bY(i^r1%xg2_(V-j_i_$Fq^ES-S;qc z)mE{FTqbAx<+xPN#egK0G;X}&qw5xra6dd=>C=w$xF>1n**6Jc4pvc-+0-$-F~~x$ z+!6@9TFA8!flVZYO4za{BVmpu_>#Trf-jXLgj^8p-{Fx)Civ17?-#Z($D&qffUjij zrd$`;<%^AGsz#fORu4K}&dEH7i2|nJ(bunB#KJ9Wa^;ym?A|651g@7Jltb8NzQw#2 zM|*5WS7EnJ3qEDxRz;8eSruvzLp#NSUwe#s<)uYd@%P6tS#XBJE68tz4?MJ>>jR{I z%_2WwebEqX$BX^fo%Ti0lnT!VqF!uoZ6jW}Z6j=>2tqpE$tgyce#<;{cttS$^r92L z?At_F-@;Q)hsKf^)9Vm&$4-fd!7;i_$FgQZCQPjfI`BAgW*ob-Dd^%u!#-|3>EILG zqs52H$#KM~ahGj~OHzb0x$Cvce$A~8u9=7kZhKM+s^Uot(hM4b%n`tV64SMQroEju zx_(}VOlk;EEHcR&WrV|pa1d*w6wbjyQ(^EoR@`7LS522}Rw^-o)Z$XZmE@&2!!9vA?)4 zXm#f2b&bWzy+zsVQlTBUQMMmywxqF@r!O=DK_lQ4R^|Lf=Ox1AsdS92Wm5<6)NC|4 zvE}Xw7n%;qv5-q9>BC?w+Jg23D>+9`W(~@SIOlagG;MIvk&6Xr@mTXrHmevl(H;w7 z4z_F-bvaBKM0jw=Bt4IxkEXLSV_3+?j!J?Y8gUWq`v{E>{$=kGvBYV1X3k`33(T>K z1b5QcgUH}oqI1dx1XPQ$oPuW7jVF@;G4~kLu2y2}+V3c}Z7upo^v|%nJ^Old*EOVr zAiC^>cn;sVHGU4W46z9Vc6Nh1Nv7guZ&UeOPqKS6UT?7QRnx>`;cId2?gEa3unXU^ zx87vV5Mq|lsbGnhq&y3;UF+bF=bIjHp8toL&vWbP4?DZ%nT^5ZK+w`JGeo zK_k5JGgVA5VPcRF%PqQ-h$=B1p}}ZeTWoAUA3PYj+*fZqVvtdPzm6Uug=+Dz_)n z)L9gZDzZt*I)Q2X**z_Yx}3|4L;RAw7|(ASzkJet@teft^O3MOgx_TNr`9OVtr1Wo z0Mmf&o8xiPz}*P!jb}Yxy1z3wWdUZ)Fw-PvnhFQ=p z`}lP(pZ^8%#uqVy%`)mY_h|McVTGe?EKqaID8|y@#II{OTO#WMTI|;zV}I`Zt6~$w zge^5@F`?i|hq7r-;Z$&mnc8&f=`)QMbbSJ)+0sP7+I__}wQLh5kG{o+7X@6rSl&8&CF>xtinMR<~RRL__Xkw33@uM3IX&{ z!rKet{k%7+`j*BbGBG=*szbKI;9l&|Q`j!|`FIIp7LRvsq`&@;8SW5rUb9){c|D%Ob*b0V`lNGI}_ufG&$sCqMu&NK81g3w--+2HWekfN7$%G2)fVSi)|%Y z5S?pJVeDKc1*Pjk?fLsn*OEfhEoGT-Dk)#s|7t?C?*J^)4ubHU;d%D5NB5fb4WbU5 zM>wE-bT%3RH3HH`2ViKL=I9LMR3E<;zY>~Y)hOAgJ#3e}a~E>n?{K^Mf+!6gFx=vx z6LylDkPAL^(pa&4)qhbWo7zyLPJX1hP`vioFv2fEmSE^e|`TI!cM;J({ zOrOksRj$wKX|{fffO7$w+ziz-rwWtPsLoY(^eVof!;WN)s7$<5mOm}glt)3hQIXB zcs$Nz0pA|Ow#ZAJA?AWDgn#n38RupGAX3Yl76~o5i0iE*lvF}X`@zes&0g7CCA*fR z1zlHY21LRnjyXqNpco+|R%n9ZPg$(y6{#lA5@(*rjtVw=kjXg> zD95F9e(L4s;*50CrjiD?Fj;4g{ARF57X-~NGz@;}?CVV1S|RZIO_vH^Iv-=???cW_ zr5b_q`ne~87N|2D& z=RAuxDb98DS@CmmhCWvCBMjF;)7?L@rEfZnV4+^RI~hm^3mC7 z1k?yDc-j_@y{>8hqlqx(pE!!QbhoQsY*CSK2B4fWO>8P3;(KVZ>&4$3n8R> z0?~I_Aj51~B`YJK3~AoQF4wr-7k!=RAxo=z@i&O3&Nf=ubnJx`VkJo#Y-8cBQl9-& zVSsIn_u=n`(_8_*ez8^qyIv}&`Rl)-#@$UccIoRxi{=x3>03nqxYgu@P!3J5Abg8X zW5N5``^*rmE5UA=Fi}{=0x4+L!E73F649MMHm{MVMH8RaO(5Nxq21>CaX93C5h zi%bu(04)eRi%py%u1u{pwu~2>F(Bsk$7%BCTqh8OPoZhW0&Hw|p98gDh%(SF{JRq8lNRxGQCM10+H&*nct_nGRLvw5qbA>~c;{r^?58K2pR&w8;&_C^TMDKOom3 zR(~Go822U?pguua+J~$f8y%V=0zr)XXmwHF8jRO@?W26+6YB7_T*F!(Bm z7X~5FVNoq?jv=U8LM}?|;PWV(hZ*x!$DXeibcN6fyIX8nfq}nM(1qdzTIDbP2N66X z$aKj!c_5KzhQO;2gi;8S@EUlG-1(22F4LUYLZBQu-kHk#8k=_bp=}%N zToA~`zy)sNu(PNTa=|HtT%2RDkSYmJ8K~c3rxN}CKh0;uT2QV)Ctd=cp>&lU@m$hA z(}J!GbRT{wX%(5LwzihAzq_BUiCwbv9lU$@Znh)upruQfdZsDlZD{jb9V0%^6p4|o zt!+lT+I{Ye9pPy;tW5Po#q~8Lzv64xuA_#A28yyDy(xY&V4k|c)l~oaYVMr4^PPSe z`+}HyQ#QwyDco)MO|GzZy#R7hM!*jOX-c}7a^Jyy6e#JS zFwHW&773drtACvW5d89vpJwBQkQ*ax7IfwJ*atcbbFh1boh>x45YUm=oFh$JS|q?` zLdRXirf~et8pr&C;Q9XP^Vp32amm#kRj)$tx)|$oxw5bHaY2wJLcsS0`Y2EX4dzf`qb=1jJB`=(iwGGM? zW?*6EFd8>*98H~S?=U@*WE2(Q4ITD|Fe5Y}8Rh0kJZhpjm1QmL>)72%dzFS+(9PiW z#nh;3I@3{fA!{wGt4C7t(BY=$!V&NL5(;FW9!mLz+unzylG9~!kl_RZlXy)N6 z4|P)w0u)KI6_ml3GFw&B`Q|hNvChdyEj!yxroHwz9fu38vAnApIM6Y{mg&>?ePrs7 zB_#GG_s5>wT);e)4^CEEM2F$kjN$#73rMyBaK^Y2A$vf2*MM(W6ciU721 z6~oN`WNnmW&}6J>$M@DVE;PrOC3Fglek%{(wX#6z$Mb_K?{v#YUJ#gp*`X|8!h~S< zq4qj~r<%Vm z0lC`g^sCJ4sk6)@>h>reCbYp~OJl47f-N;XO!#r3X3x>r zmDcF`f=M%_g#aFE5IS+0Fv5fpzpyXDb<-}HBYvLD)+o+tp7F>P6v4(3>(`lK1K~G1 z5E_xCHuTnqIZM^o+3w*8p#Q_aFOno(>@=2**$nx8f{B2bcE+YUZZv$1Ta0^nOrz`0 z(rYok@mJIciW&&q$FVjUyKxG$3I(fY5bT1l{vSKbUUN+Rg;@wZ9PpxSL(2=3w!OJr z*d${?90p8vtQj6QDxL=q0_tWRL9wSxU=GdgdoRWL;0M?b!Pha&wOm|LcI`Enie?`| z^zXl$g1yQv_pje4x`x{c&r4{F>{b-sG_a`?%t`_zt)MUXR3*j#~Ng9>{{nf6$Lub(&Ed5`6L+Mmt`N;~=!=DMzN1mx#0TU~-&2DGl| zuZ5Qc)Fddkjo7G1kX)t+>rY2)A_1Dm-!30^`zEu`Um@gz9ola!q61-Z-GRrM8f6H% zpyMtykJ5(e!!-@YZjs$Zl*xF9_IaQ^K^ z^2%8^o;@kNzYDs)KbUFURMqp9MmGME$U=a>6q-vTkaYwg{0bkcsT2k`UK>}Zl0wa! zY5$aloUE=$4uu+K0$J=Y()~tGDWfKJu%rLOw zh1&)uCYSp!Hi*KGa)Vh;@adM+$Sj>_*}WE|1zitt_JpXSxBpFJ7rsIS--US4{nGva zXL8CbSLL)@*Tk=!rVH^HedY%N2y&TzNc@zOO`dEDqXY3Hnaz8Vqj|sk?z=X>*Y)-F z)YR0(O0n!(*zMf8)7X4v@#4i&WNk4t5fo18Yt=lpW(D&o#9(P(>#0F=X{7~HpAUr30Ywi znVOnyybloHq%0Gjg^rF+`=&KjQz?AdIErEe4W^0%PNK$t z)Ei|e>z%1)B8$>!Z(`D$Whw8&zzsa~P}VL zhf_sGg_(=s5qWwY<-D<-ZBv7qd*}$-S;RAdOv6Wvh!6VVK_Ejv^05M~y6j^2V!KN6 zX#8;2KxRVFfMOw5Z4H|)m{`f#VbD`lRM;zi-i>Er;w01Wx^(a4`p}FSRBa1L{Q^R6 zf**8MHU}SJdUsI8Sz*QdAL;r&rsJ1f3%VX)5BR9(?z1*tY6LU_eh^>{q)9$HGV}+j z%raGtVxe!Fdo9vYh9ukg!o4)ln64r0Re+@LnkTnQr0_J93Pvtj1sYsZ9vh?tnr|wZ z;n~50I&4Xdjd$d&iIER>tvl!XRB}wpn{$FLRO}yr^a*b}+Dh{doJ)fT^Nmr^u3fw7 z?YG}Erh(?pox{6e#oe21*szH{{&)!$78cUshaY0gW6PGU^vTCdY4VgwG=2Isc7LZo zz%h7#|84V>cQKg`pjG~xzIJJM*nPO^t1Fk-B!?S-aN_^w?enW%ZeW4Q0~5OjG5MpqJLIT^Af=sJt( zH`kSHW`NyNJt@O}+%s=SBzBP$o|ha^R6U+ORD6MG$vZ@=J|>#B9}zaNIOsUjRa?OQ zY)%Qf&CM-z&)@$+XPj{gm6ey#BM(18$9~}`nml=;4W_MIw$by?zf2cja=xMdf9b_n z+4gCZA=EBd@HVxzwbN;*okZ>J?ex!oK1yeubt;VfWZrM{dwlzH+SB99?$sA=J)RX?71`JvB&HK7_c$eYzDCi3}z9l z43ZE?fOhF^#pmpE z&ZO~(*U1aUO{8}wE9IG| zVWysR%$OJ3I4`h0P~G4~l39j$B`k-s|1;|i>SNpEuIclMCiCYix6g07H6Oe*spZ%F z%-6ETQsjAp7;2}!hQ|ThKn^;1E-)KfZxN}PV-Pj3J1k(X&w*LpE=`&EWQTPfb;5)O z(_@1{%F^8VRDZJfx<7Rtw~1A_&oE{>B{w;pXbYK#%^vbi7`NdC&t*~;zNltP ze)=LC55MJxIgn8W%do)-wt@{@ERm+=vX8SF6@z6&8|9y)Oiw)VG~Im54YY940-8E? z3VriiH`4m`FK2Ms@a8-8)$6`QwY4=W?&K0SYCrun@etd&b2nXh;TKgtVn)95m87S?|PRrww`zqb2I3_0a9;n^2#R$zR*3Wyd6!9f|Dt0#B#BF^RJ%EePa^z~t%F zJ!2tH0^*nNqDi*#BSWri<;e=>IN`^z%V;N$46o;+g{@CrEOl%rrk=JU_fzL~`^IrB zvrcBHq0Woy*Zzz!+tItk!GYpMXV%H%xTp->-kx4%gqr$PRaWxMM61_n?bD}8{el>PCij*tKZX3JBi+XH`Kiqici74;`-pGT`BqH0lvE|ipJ+TGK6_G431 z3mdZhSvZ-NFJDR@ZQVvc`SDLx{4L^ozxU_gQKgq$asmDH-)^HC_V%_kx9~C)t7!4! zg|vCohdi;6ZzLm?atuj)tUh2n5=+S#aHJ2{J;2jj(=pHK0^8C5@vn(pS+?nyh2)K< zmkz=H-XkgLL8;iT2`yKluyhX>7#U#k}{9hfL)4`K6=Wq_A~8=Ao0 z(cFwYAej4?RLR+;AN|@XLqk z+uylKt>=cqZQDMfmtJ~B@vwV_QSQ_x*0{scHfF-wZ5&FHfjr zuc|Fobhc1ga@|8)QBJ2*4<91F-QAO3UWO??`DA;F&Wt|#M0w5+(lUON#4F0)_uu8X z*l|?J`)$Ka?iv`P{YG89kTf?pQ=blPNOARl&{N+^Rn5F)OP17AQA=1quq3%QWEOH& zJXlsqy@y+;7?|yhr-1xrf70W2voMYGlk{E9-Bi_hfUwS?J@xa<-16>rm5p#8tYtdb z6{nhpeJRqunu%1=m3Ud|VfkXLQ)PSN;W1EAO=bFJhij-cD*0Jg)39IFkMqhLSYOgi zgS=>YW8DFD-`3QmWAY%UJ=N6jwPf`)b|_senaPuWUa-8swvJ+~XEp1qQ)6Qj$M;uq zdzrDpPHpOXL4GlItXj1yNL8sL2#j0=u!;l5x+>hyK8;0=}kD;AAcG2|dY0oeWS3K;T(upTp!yI6A4)Ldw$ksqKgxIxfms(B2u`QmA z7R%u+%V29cEZMi&a_)7qbm2mZ;f>Zh)1pUtuybY6+WhpB;JD^?vRztj9Tie7b*?oC&U}|6_Zt_iTLb5{j`dj)^Cu#SsU_ zlhI6?+S-F^O;fD{v z-cQmsV89yVcDf*hqtw!CA@H)Zz^X(YZT8&Y=fJ@=d6l_V%3grJ^1A{@c5b0l6qTVn zXZCEyY8Nf#rN5A{#26AD?4}2%k3EBZef_+ASb9c(J9~AJ^shSM|KJ&g0lj9;(e(45 z-9e|EdXg@pb?aWBbI(09b*>K((%_V^LyudT6MfLUl+o@a2lC7r>_HoGnr-jGt8{=r zMIip`;GP5p8#b})|3~`$)(kl@44fFt8Z%@CcEB*NosKZL89ZG?R&Ai|oZ14m_`^V9 z4i;ru+GJXFZ6J;-n{42pjmEB&mMfXBG4!RITYH+P(}TgNqx9nQQac6)jl#@4x8r~^ zjIUa6r?_qQ^6IuMdZDg8X+ApNY+L8)U(hNZ?8z|dd0vZ7ZEAi2ehV>X1Q1KA2m(cj z00xT8G%$5GmB2xO33kRye*cev{##c*;mcN7zQ0uHt(?c>;krcb52smjXFaFlDDsNR(7p7s3snfhrcGN2lhF3|lQlAYT`I~c%6_WRQi;}1NLb-NRx6|S|I4r>SdT~ZBv+`Q1PZP*GR8+KLG zY5JT*C<30peiL5Q;SfqWvyAcFY3%jOcLdWFm7xn9ufP6U<$;CA7R!g}boJGj>q8aF z@ZIlzOT`X?&h*M2d+ch$U%~@iK`?H0TDE*C;jg8oH6t8C(~Oy4huBP4-LZBrVt+6& zAkA5%e$xN(&FPd-XC$SdgFsI8j6r9(vB^npyRbRxVYX!+Yqt3qqE7rYU;XQHiRxnc z6$Au<5sZM>7+~M_Ru5g-#su)p#mEf+XhUtbkppw=PRdKn>7D3?c+Lev&8V8~ zDRWoTY%DcS+30dE&jx(X46{~XM2at!bKtjWy(gh#_F0h_LyI@Y|I=d zFZkYzZpf~(Hi{2?mY~%!QeHLjhJEsRUKGK~>;pkCF1gjpcEd+4Q$GBI)b&%x4~>bk z1w+e8f+`0#JM&z}6|+8`IWXw(Yo=KX6P{M> z4dxwFRm!I=lfU-BVs1m;DSRVv2;N;44gs%l`22HLIV{|BXt?M+x;e-$r1>C_+@d#* z-AS?~OcLyDPyB(_&*lJbJKbb!D_gnGn?%PsXJcn6_sQE*M@|AD;4s+cW9a&kAZq@8 zWDpubV5}nmW7G5VevWUX`V&2V5xc96S$H&?>#b<>MB_*j;&)+4=96^Xs-NevpLYB_ z%dlyK&z(m7G?_u;Dnqi5F=xV@l#Dp!h>{q(5dj+=TL&W{NMp%W1crDiD93a@$40Mz zI8lUHpX72=YJFXN8Znc@tp3!1W736k9FqQ_$dY8DZ|EWvElf2nytK|b(|)e={r=`t z-%njJbp7^(&BXc=Tj# ze>urEAoD zF}B5%bNT|9WRFqCr19 z^4T9UUb5&HGvE&0+&n;b8OP8$)(79Z^<#SW+4a26^$}0aj~uC|-~awuwGod=h|OT$ zeDfW8`Q_Kt#yVyhCjYKq|1xdl^~{|%?J;TPc#I>!>uD3lA^R8+1uRq9*n-jOXUx&< zLq5dh<~l)4*AMd-&uE8dtY;JESgAJh@T7JxRN)#f&ryuC_%rA7l(MWkrM?Io#%(H3 z6NURLhHkichR@Bo7D8j*c#x>ANwLF@Tm2LH?aZFA)+rX+M}k*b?{tNkn|{)8#ORtg zv6qZ)blU6ZRoAI3iav5`CrDl{9+EI#LLj3XzFK|{yaL5m8@t%)Cgj&Y0(aeYKMf8J z(V1s{p5EN>4!!=`n~s$qd+aHKp^KGl>W?(gZ-4uwqQk~Jcinj}&7C_(tyligLyz*V zgmtP6J5xUO#N%lqZ~SxnZTF}(&>b6)OhEuIq?k-*f0>N}8EgWfjMnr9Q&BV% z9Z!$J-E9mu4NmQy#tv|^7deRO!QX+}F$?`TYhhv)2s?r4#T7%>j?Nf658+zNK*fqy%wcl^ zKXT;UkRPT7O_Z1!&E$0GC6m*jWzu`#((m) zUVU`~-FVa2X!7Jqyi4K|y7sGIqIJ(a?@u_P5(I)GkV|+|&^C&?p7s7siHaCw?Qw-; z2Znwqt3{+*upYoOj}^VViwtU-ll+0zIa-=PWOk>c> zCQj&h<{MA(lb+Oyo$c_~)6+xa*?2b7j2Y9Ysfo9Nl_Us6i2w|&LWDm=se>DD z7^*sTwCW@4Z$4uzVrauowijo`-jvbF;TEC{61or~n31qDFNQE0NUpY^S;f8He3MI% zXB&Ww%7s12`7?OXn=R}<3KJ$T*)qyPGOo?HcR#wAa)cy;pJs)I9WCsA zx8EnTX3gLbg$4^e@W{@Y%by{W>5qSWU3qA6>a@jiH5kiZO8JS^GPV}0u{0agi z4gqug%0c*e2|Jmv^IAU1?HwPJaJA>w4}WuFncnU=pk9v6IoTN|f2Xg2j*Nn3ibppX zZX>tW|Nd_l+2e@I?BW<)r*!(Iyv`kadtZGjUFsCNpi8f0kM1KsOPsmgy>(NZU9&x$ z5P}2=F2R!k2{u@8hd^)-7Tn$4-7UDgySrO(cLtZi-R-@|eLv@%r|S0!UjCV?sTr<4 zTY7h|Ufru%T*#;|o;fVG|8(|yP&%P%A5#$NNOlC_4YYOV>Wn{JT z@~1eMnnorjn_C?IkgoUKA?27u&jjh5&R06kiUQ-1kreh@esKCbhCr{j?FRQ}H$LtL z(~<1mvqw{dAI%QmzL9RnZVrx?aIFukC@beTv9sPT_@Z3tPDcu`sN1tk&W!vnjH*sF ziHJK`8eb4^VYk~Y<^e=lQ40!hQIIM~=J!APuNd%J`P`Gd6 zNTSfdTr5Vv35(HP?o}IF>ZaPf4XwO7!OhM4+0GzLLiAPw2bOR>WS`&P#NZHj`0-6g zm9*rSjB5*UXFTMw@nwc8BhudRswv^Po&E4!p*T0071pU*c{5iiLB()(wq`t_ub(`e zWo$kh9G6m;>>tEqsPy&n>Pkjem!2@K;drSb2~g0Q3$feV$AfsPbBWEm9u5M^JjHU3 z+)U9GIjKj4SKAUnvu0p#E-o)C`do3_%5kc|T`*y{9qinu3yg`hp8Rh=iY-K>aI}KwqvljLONDT7JtIl!S!6GgG2cP+b>Hp^R=`1tvH!+%?#)E4B+ZX-J+k zUjaAS7YUOZjDC$ljG6qHrQvQ(d0A1{{xzn&PwQc4B=2lSaN*iet4ZUW8kx@7f06yx zwzR9Dv5Z5*L+5N76V~x@c0#BAyX1GIL+ET=`OB%Jr)< zV(IO6AqD*PgyN<>73yBE6#v}eUeU?5(7Hx05^a0D>rhROqlKDah1I~*_TP_JhdbC& zR{r~MS=LQIm`}5L+G+gabXNASKYXNUDlH9bY;63(C1uu;QZUXbl%+E9%fEz1XTiEKmgE{+6vCCKuu?YA4#P~s#E zh5@5_6mp-$CGX7=4&SO?5Wzc<{?PSMt#YNC?LaDEI78>JYma_Uv8-nUNdu*Llrq z_Nh;?WgunqRd1-I;aW$FwLTSXq7XLQFp~CC+nUB*e=mKnbM8t_RqZHj+;>`;*{@%7 z`Z0OJ-a|d?G8iLHzXhwE-@T`cu1yC$mW5x@8~s_1f98!VwW4*)XeIa8mi_RB3HhR* zN;X{{oQ6P0JW$o9kY%Ooz1^0sw5hGFl(6>tBzWvWH?XdAQ{`u?Y2R$}fGE_ke45er zaMFG-xR`YC>k+1V6N{z@NLwjVgaX~XoaIOlBq?l-H=Ncrm;f!-{^~10^>dqY7={ia z<*vDy6_ZOl+8*r>LB(IkBoVneoJjTCCO5N@)f?;X6VJqP@3j<#dp5{7sQ!g#N7#6T z;@l|8rb>ol@bQUYJ%&o85RJZfherEN^Jn>YU7Bj9U-4dZNa+Zlp32^oaG2T{S=mw( zQ0y?@sHJ@8k9Q3w-I^Pt7Ivcs0KK6EhJxQ^&a!zoQ>+-qo4i4jW5wSOG9g*NVF;To zxE#r@t(|ZiGaL_)H2C>uiL_j`hSI9gE?kiL3H{m`Q|Gx0IM+y}ntwm0q>DWeZEPKB z`J<=463=o>vS}Pjg;hp;nx2+tj6^bao|uj2y%#K5Dp+yLkV6^Tz4025D+$LE=5vO_CfgGEj7{+;~tK4Do~|%)MS& zDYoErI6(p1OkM^Z86P|X>U8Rq+6`4v%qeTI;J7xc7+?QnI4Er-PZnoS|KAcxnbQP# z_bjGIS#M{G=o6x5Y!fESTumKVjFx`tTNS1W5!QX~4|}zIa;i_p*~PNQEK(f^>o(9u z`-hO369LVfv%dbK;j2bzUo(U7L7{n-e?32E@__3ZRZ?#nRaBZfN79tJ0gO71I40)S zlG^&=QdO%;#+wz4ugiD$=*`+Df7;_MO%OPebu2cJS|u(THEBjqpz6oH71a3zRl%pT z(WrfX8Nsy!gQD~t#v?BEC4~N0?XpO6ejVW)4;2|jmv8+b47T7Twu(N9$$Yjsc*!`0 zs@F@J)$pn1Mz*Y4H1h2IwU$G7hT$GLqf)Vv6K4e<#|)P3l=JSy5LyQ2qBIOeXKf3! z2B98cPI;gW$Sh(IXdW_^C5lT*QfTT|5wN&uts+O*kMS?{zcNag)vvMDaM7$w4P)Y* zB%IEunE$M(opw>3>y!8P#eWB-4f`5E`(V-4+Xag!Xf1{@iGvg)tCR8reDNnU4eJ!< zfR>L3DMn{ODl+~$y=%GF2=1Fc!QdVhhk~H8?_FWT7$YTP?<4F!Fsm6%tLbr%MvGa! z3x1_mOfE458bJdIjlqs#BygToF2H4R=H!NL!< z%ftuuORU?iCR0(u(jEy%cL|jeH}Wqq*KCq0G^^mEn&sT8AyM_=8QZXcAW^=Hvo8OS z6W(7qZmQRo*ZJn`vD~a2ds7cz3DZo-174=JHE=G z@%o<49qHYd`{Pr6^fl0r^%xW=Qn8Ru!lfUI6GNI?9s(KX&nMn0E^DiOgE^bg9xY4} zbPRIj_}4k)mb)gS>Z=~uFq7=a%fq!S)Hv}pqE$*a{6s^FC1q7QJ2vZfriLxDD&Ou_ zl~a>jU}U;2y3)6%nW_5wZ{B)-g$>hOZT!%H71kkvv(a&C$|&dkRNjvhk~M_}4PX!L zc%DI;d*N3TMaifdk7+G0-r`L4G5P5WCH-_sp*2W>oxH6+oc(z?VP zbYe6p!EQ8Sdb2=g9`@necT`>;6cp%Ao>wrXsm(n_EW#A{P-u-(EXCe67`~|Az&D6# zMRJaKfv<5`eA!vHa2wMxgDddJ!Zgq5b?i6+(O5kbHad%veV$~|S%=f%31(z!(OBYt zClm!97?&WFaU{bq`F5?MoHc!Q@>$UL<%-X+vE)@SVIic4-xdB20NV2-9}gn<;~t`r zbSCYx-{jbEk8%F%(|r;~2bJcApm6E@TffUBQKH*vQmT25+c}QT2FTiXJd&x@y&oC> zd7cJ;Iz-E+VtNzy*!<%`ruDio`3d0y2Wme_4G*hQZUr#m>#qk=a7| znyFe;Ymfx%mbHhB2bOZB4IP2)l-2%@sW{_;8=eVztl#)pO~TKoh%00K z553s6^r1BKHRWmdCi4-q`bd;Yt(PTBd>mDp>eW_$`IY5=7l;StiwJbkK-S{;xbWYY zGx1y0452+D=iQ%;YU`aN#MM1y{OlF3JLnYGD_k2ugJmLin1~_^+lSV}{Jw{?TBl!& zEzD5^VG!s;-t)$}(R}_4HN|x#0Z2pHs;>v~|` z?zW0qx^FPn*i?ZmBx$8Fa;D6kmA?bYyp>i5 z6~17&8L?!MIvkZ?=88zdiOz6Eb=TC@c`+gf+((SXtm&almrW_UMwmet2V9d)DPWHR zJDvyS52j}(y^XW8Qw*vRg>=vTi1xD$Ly2mW-?FQ|Hihx=@*|_Rpq94R)6?q@`1sl6 zX%2p=Zg;F(Yn=PVlZG3;*SpbCl48>x9WR;q|UyS@5j05F_*P3OeJ>29`_+c+E96z#}2ecOez0+n&oIOih@93Ev{2_7I&p|XT z2OkT$CwPRaU}weVoH-->$8}_e`i>tx4foYzjsxPhg4{P9&p$3H_^^+*S-_6g`uYxjyqi;G9Gyh2 z7t%qn$RF_VSWD}IyGVMK&azl|#Vol&Us?bMEa>uDMt72AT1?VDd4MgkU}%R%6Cus{ z3#r=sn26=@oQ$ksw(A3F-LZnKELF!2*=|Bu?*k;7!`-v=9~hUP3HnJ7q)QFBis_x5 zoeNqUd_@kD6j&_qiVZWL?)2nk#>>-0>Lnu>R|Y;gf7N5~fHhLdFRuE=s{j^&MaECx zYxOD4SFmNtsB$b0h;jSv;)e}v>rYFx4`IIqIFhptiwM+r~voo57z z>=_^Cp3T7YmdWbAXRMP|Qi&pyZp&Rx6p~~H&FVHMAAp