FullyConnectedNets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures.\n",
    "\n",
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> <class 'numpy.ndarray'> x: (2, 4, 5, 6) w: (120, 3) b: (3,)\n",
      "Testing affine_forward function:\n",
      "difference:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "#q = np.reshape(x,[input,-1])\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print(type(out), type(correct_out),\"x:\",x.shape,\"w:\",w.shape, \"b:\",b.shape)\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "dying of ReLU\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  6.750562121603446e-11\n",
      "dw error:  8.162015570444288e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.52e-08\n",
      "W2 relative error: 3.48e-10\n",
      "b1 relative error: 6.55e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 8.18e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.09e-09\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "loss, grads = 0, {}\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "#print(X.shape)\n",
    "scores = model.loss(X)\n",
    "#print(type(scores), \"scores:\",scores)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 4900) loss: 2.324142\n",
      "(Epoch 0 / 10) train acc: 0.139000; val_acc: 0.129000\n",
      "(Epoch 1 / 10) train acc: 0.440000; val_acc: 0.448000\n",
      "(Epoch 2 / 10) train acc: 0.512000; val_acc: 0.486000\n",
      "(Iteration 1001 / 4900) loss: 1.585834\n",
      "(Epoch 3 / 10) train acc: 0.445000; val_acc: 0.423000\n",
      "(Epoch 4 / 10) train acc: 0.531000; val_acc: 0.470000\n",
      "(Iteration 2001 / 4900) loss: 1.362002\n",
      "(Epoch 5 / 10) train acc: 0.486000; val_acc: 0.432000\n",
      "(Epoch 6 / 10) train acc: 0.569000; val_acc: 0.488000\n",
      "(Iteration 3001 / 4900) loss: 1.433523\n",
      "(Epoch 7 / 10) train acc: 0.567000; val_acc: 0.487000\n",
      "(Epoch 8 / 10) train acc: 0.533000; val_acc: 0.474000\n",
      "(Iteration 4001 / 4900) loss: 1.266005\n",
      "(Epoch 9 / 10) train acc: 0.606000; val_acc: 0.522000\n",
      "(Epoch 10 / 10) train acc: 0.583000; val_acc: 0.498000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "model = TwoLayerNet(hidden_dim=125, reg=0.1)\n",
    "\n",
    "solver = Solver(model, data, \n",
    "               update_rule='sgd',\n",
    "               optim_config={\n",
    "                   'learning_rate': 1.5e-3,\n",
    "               },\n",
    "               lr_decay=0.95,\n",
    "               num_epochs=10, batch_size=100,\n",
    "               print_every=1000)\n",
    "solver.train()\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 7.36e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 3.48e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the learning rate and initialization scale to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 18.276745\n",
      "(Epoch 0 / 20) train acc: 0.240000; val_acc: 0.122000\n",
      "(Epoch 1 / 20) train acc: 0.200000; val_acc: 0.103000\n",
      "(Epoch 2 / 20) train acc: 0.440000; val_acc: 0.106000\n",
      "(Epoch 3 / 20) train acc: 0.740000; val_acc: 0.127000\n",
      "(Epoch 4 / 20) train acc: 0.860000; val_acc: 0.122000\n",
      "(Epoch 5 / 20) train acc: 0.940000; val_acc: 0.134000\n",
      "(Iteration 11 / 40) loss: 0.081475\n",
      "(Epoch 6 / 20) train acc: 0.960000; val_acc: 0.138000\n",
      "(Epoch 7 / 20) train acc: 1.000000; val_acc: 0.135000\n",
      "(Epoch 8 / 20) train acc: 1.000000; val_acc: 0.136000\n",
      "(Epoch 9 / 20) train acc: 1.000000; val_acc: 0.135000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.135000\n",
      "(Iteration 21 / 40) loss: 0.013271\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.133000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.136000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.137000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.136000\n",
      "(Iteration 31 / 40) loss: 0.007523\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.139000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.139000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.141000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.140000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.140000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 3.9e-2\n",
    "learning_rate = 2e-3\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again you will have to adjust the learning rate and weight initialization, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 139.034283\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.104000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.128000\n",
      "(Epoch 2 / 20) train acc: 0.460000; val_acc: 0.104000\n",
      "(Epoch 3 / 20) train acc: 0.600000; val_acc: 0.108000\n",
      "(Epoch 4 / 20) train acc: 0.580000; val_acc: 0.102000\n",
      "(Epoch 5 / 20) train acc: 0.460000; val_acc: 0.098000\n",
      "(Iteration 11 / 40) loss: 19.332391\n",
      "(Epoch 6 / 20) train acc: 0.720000; val_acc: 0.121000\n",
      "(Epoch 7 / 20) train acc: 0.900000; val_acc: 0.122000\n",
      "(Epoch 8 / 20) train acc: 0.960000; val_acc: 0.122000\n",
      "(Epoch 9 / 20) train acc: 0.960000; val_acc: 0.122000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Iteration 21 / 40) loss: 0.000142\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Iteration 31 / 40) loss: 0.000126\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.119000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.119000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 4e-04\n",
    "weight_scale = 1e-01\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n",
    "Layers 5 had to be tuned more to reduce loss. more weight scale,smaller learning rate.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.876739\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.089000\n",
      "(Iteration 11 / 200) loss: 2.232312\n",
      "(Iteration 21 / 200) loss: 2.081927\n",
      "(Iteration 31 / 200) loss: 2.093803\n",
      "(Epoch 1 / 5) train acc: 0.269000; val_acc: 0.229000\n",
      "(Iteration 41 / 200) loss: 2.006196\n",
      "(Iteration 51 / 200) loss: 1.988315\n",
      "(Iteration 61 / 200) loss: 1.831371\n",
      "(Iteration 71 / 200) loss: 1.864060\n",
      "(Epoch 2 / 5) train acc: 0.311000; val_acc: 0.273000\n",
      "(Iteration 81 / 200) loss: 1.901096\n",
      "(Iteration 91 / 200) loss: 1.808923\n",
      "(Iteration 101 / 200) loss: 1.997017\n",
      "(Iteration 111 / 200) loss: 1.772677\n",
      "(Epoch 3 / 5) train acc: 0.377000; val_acc: 0.299000\n",
      "(Iteration 121 / 200) loss: 1.867554\n",
      "(Iteration 131 / 200) loss: 1.823545\n",
      "(Iteration 141 / 200) loss: 1.657043\n",
      "(Iteration 151 / 200) loss: 1.823717\n",
      "(Epoch 4 / 5) train acc: 0.412000; val_acc: 0.324000\n",
      "(Iteration 161 / 200) loss: 1.531858\n",
      "(Iteration 171 / 200) loss: 1.749999\n",
      "(Iteration 181 / 200) loss: 1.556198\n",
      "(Iteration 191 / 200) loss: 1.619454\n",
      "(Epoch 5 / 5) train acc: 0.434000; val_acc: 0.343000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.419751\n",
      "(Epoch 0 / 5) train acc: 0.131000; val_acc: 0.141000\n",
      "(Iteration 11 / 200) loss: 2.248758\n",
      "(Iteration 21 / 200) loss: 1.999520\n",
      "(Iteration 31 / 200) loss: 1.940763\n",
      "(Epoch 1 / 5) train acc: 0.329000; val_acc: 0.283000\n",
      "(Iteration 41 / 200) loss: 2.007849\n",
      "(Iteration 51 / 200) loss: 1.784180\n",
      "(Iteration 61 / 200) loss: 1.968313\n",
      "(Iteration 71 / 200) loss: 1.908982\n",
      "(Epoch 2 / 5) train acc: 0.403000; val_acc: 0.313000\n",
      "(Iteration 81 / 200) loss: 1.727771\n",
      "(Iteration 91 / 200) loss: 1.787988\n",
      "(Iteration 101 / 200) loss: 1.641296\n",
      "(Iteration 111 / 200) loss: 1.556636\n",
      "(Epoch 3 / 5) train acc: 0.435000; val_acc: 0.322000\n",
      "(Iteration 121 / 200) loss: 1.679992\n",
      "(Iteration 131 / 200) loss: 1.733355\n",
      "(Iteration 141 / 200) loss: 1.611364\n",
      "(Iteration 151 / 200) loss: 1.541176\n",
      "(Epoch 4 / 5) train acc: 0.452000; val_acc: 0.349000\n",
      "(Iteration 161 / 200) loss: 1.445940\n",
      "(Iteration 171 / 200) loss: 1.585091\n",
      "(Iteration 181 / 200) loss: 1.427675\n",
      "(Iteration 191 / 200) loss: 1.457885\n",
      "(Epoch 5 / 5) train acc: 0.529000; val_acc: 0.360000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sanat\\Anaconda3\\lib\\site-packages\\matplotlib\\figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3QAAANsCAYAAAATFepNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3X94VOWZP/73PckEJv5IlNBSCC7UpbYKCBJZu2RrKx+ESktZrbG17truWu3aitoWBNdiyrfVCO2itt+2WrrX2o+2S1SKWHSValuNtVUiCFhlW8WWJFIBDRQymEnyfP6YHzlz5vx65pyZMzN5v66LCzI5c+aZM2eGc89zP/ctSikQERERERFR+YmEPQAiIiIiIiLKDwM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIKoaIVInIERE5Jcht8xjHN0Tkv4LeLxERkVl12AMgIqKRS0SOGH6sBfAOgMHUz1cppe7T2Z9SahDA8UFvS0REVKoY0BERUWiUUpmASkReB3CFUuoXdtuLSLVSaqAYYyMiIioHTLkkIqKSlUpdXC8iPxWRvwK4TEQ+KCK/FZFeEXlDRO4UkWhq+2oRUSIyKfXzvanfPyoifxWRZ0Vksu62qd9/VET+V0QOich3ROQZEfmsx+exWEReSo35SRE5zfC7G0WkR0QOi8grIvLh1O3niMgLqdv/IiJrAjikRERUYRjQERFRqftHAD8BUAdgPYABANcCaAAwB8ACAFc53P9SAF8DcDKAPwP4/3S3FZF3AWgHsDT1uHsAzPYyeBH5AIB7AVwDYCyAXwB4WESiInJGauxnKaVOBPDR1OMCwHcArEnd/rcAHvDyeERENLIwoCMiolLXoZR6WCk1pJSKK6WeV0r9Tik1oJR6DcDdAM51uP8DSqmtSqkEgPsAzMhj248B2K6Ueij1u7UADngc/6cAbFJKPZm6bxuAEwH8HZLB6WgAZ6TSSfeknhMAJABMEZExSqm/KqV+5/HxiIhoBGFAR0REpW6v8QcReb+IbBaRfSJyGMAqJGfN7Owz/LsPzoVQ7LYdbxyHUkoB6PIw9vR9/2S471DqvhOUUrsBfAXJ5/BmKrV0XGrTzwE4HcBuEXlORC7w+HhERDSCMKAjIqJSp0w/3wVgF4C/TaUjrgQgBR7DGwAa0z+IiACY4PG+PQD+xnDfSGpf3QCglLpXKTUHwGQAVQBuTd2+Wyn1KQDvAvBtAA+KyGj/T4WIiCoJAzoiIio3JwA4BOBoan2a0/q5oPwcwFki8nERqUZyDd9Yj/dtB7BIRD6cKt6yFMBfAfxORD4gIh8RkVEA4qk/gwAgIv8kIg2pGb1DSAa2Q8E+LSIiKncM6IiIqNx8BcDlSAZFdyFZKKWglFJ/AXAJgP8AcBDAqQC2Idk3z+2+LyE53u8D2I9kEZdFqfV0owCsRnI93j4AJwG4KXXXCwC8nKru+S0Alyil+gN8WkREVAEkuQyAiIiIvBKRKiRTKT+plHo67PEQEdHIxRk6IiIiD0RkgYjUpdIjv4ZkhcrnQh4WERGNcAzoiIiIvGkG8BqS6ZELACxWSrmmXBIRERUSUy6JiIiIiIjKFGfoiIiIiIiIylR1vndM9cJ5CskKXdUAHlBK3Wza5rMA1iDVawfAd5VS65z229DQoCZNmpTvsIiIiIiIiMpaZ2fnAaWUp/Y4eQd0SJZqPk8pdSTVV6dDRB5VSv3WtN16pdSXvO500qRJ2Lp1q49hERERERERlS8R+ZPXbfMO6FRy8d2R1I/R1B8uyCMiIiIiIioSX2voRKRKRLYDeBPAFqXU7yw2u0hEdojIAyIy0c/jERERERER0TBfAZ1SalApNQNAI4DZIjLVtMnDACYppaYD+AWAe6z2IyJXishWEdm6f/9+P0MiIiIiIiIaMQJrWyAiNwM4qpT6ls3vqwC8pZSqc9pPU1OT4ho6IqJciUQCXV1dOHbsWNhDIQrE6NGj0djYiGg0GvZQiIhKioh0KqWavGzrp8rlWAAJpVSviMQA/B8At5m2eY9S6o3Uj4sAvJzv4xERjXRdXV044YQTMGnSJIhI2MMh8kUphYMHD6KrqwuTJ08OezhERGXLT5XL9wC4JzXzFgHQrpT6uYisArBVKbUJwBIRWQRgAMBbAD7rd8BERCPVsWPHGMxRxRARjBkzBlxqQUTkj58qlzsAzLS4faXh3ysArMj3MUrCjnbgiVXAoS6grhGYuxKY3hL2qIhohGIwR5WE5zMRkX9+Zugq34524OElQCKe/PnQ3uTPAIM6IiIiIiIKna8qlxXviVXDwVxaIp68nYiIPJs0aRIOHDgQ9jCIiIgqDgM6J4e69G4nIiohG7d1Y07bk5i8fDPmtD2Jjdu6wx5SOHa0A2unAq31yb93tIc2lHIMbLdv345HHnkk7GEQEZENplw6qWtMplla3U5EVMI2buvGig07EU8MAgC6e+NYsWEnAGDxzAl57fPo0aNoaWlBV1cXBgcH8bWvfQ0nnHACvvzlL6OhoQFnnXUWXnvtNfz85z/HwYMH8elPfxr79+/H7NmzEVSLHG1Mnfdt+/bt2Lp1Ky644IKwh0JERBY4Q+dk7kogGsu+LRpL3k5EVMLWPLY7E8ylxRODWPPY7rz3+T//8z8YP348XnzxRezatQsLFizAVVddhUcffRQdHR1Z1Qq//vWvo7m5Gdu2bcOiRYvw5z//Oe/H9aUAqfNHjx7FwoULceaZZ2Lq1KlYv349HnnkEbz//e9Hc3MzlixZgo997GMAgIMHD+L888/HzJkzcdVVVzkGtq+//jre//7344orrsDUqVPxmc98Br/4xS8wZ84cTJkyBc899xwA4K233sLixYsxffp0nHPOOdixYwcAoLW1FZdffjnOP/98TJo0CRs2bMCyZcswbdo0LFiwAIlEAgDQ2dmJc889F7NmzcL8+fPxxhvJ7kIf/vCHccMNN2D27Nl43/veh6effhr9/f1YuXIl1q9fjxkzZmD9+vVobW3Ft7413HJ26tSpeP311z2Pn4iIgsWAzsn0FuDjdwJ1EwFI8u+P38lvdYmo5PX0xrVu92LatGn4xS9+gRtuuAFPP/009uzZg/e+972ZHmKf/vSnM9s+9dRTuOyyywAACxcuxEknnZT34/pSgNT5Qga2f/zjH3Httddix44deOWVV/CTn/wEHR0d+Na3voVbbrkFAHDzzTdj5syZ2LFjB2655Rb88z//c+b+r776KjZv3oyHHnoIl112GT7ykY9g586diMVi2Lx5MxKJBK655ho88MAD6OzsxL/8y7/g3//93zP3HxgYwHPPPYfbb78dX//611FTU4NVq1bhkksuwfbt23HJJZf4Hj8REQWLKZduprcwgCOisjO+PoZui+BtfH3MYmtv3ve+96GzsxOPPPIIVqxYgXnz5jluXxIl6QuQOj9t2jR89atfxQ033ICPfexjOOGEE3IC27vvvhtAMrDdsGEDAG+B7eTJkzFt2jQAwBlnnIG5c+dCRDBt2jS8/vrrAICOjg48+OCDAIDzzjsPBw8exKFDhwAAH/3oRxGNRjFt2jQMDg5iwYIFmTG//vrr2L17N3bt2pV57QYHB/Ge97wn8/gXXnghAGDWrFmZx9PhZfxERBQsztAREVWgpfNPQyxalXVbLFqFpfNPy3ufPT09qK2txWWXXYavfvWr+M1vfoPXXnstc6G+fv36zLYf+tCHcN999wEAHn30Ubz99tt5P64vBUidTwe206ZNw4oVK/DQQw85bq8T2I4aNSrz70gkkvk5EolgYGAAACzTNtOPYdw+Go1mbk/fXymFM844A9u3b8f27duxc+dOPP744zmPX1VVlXk8s+rqagwNDWV+PnbsmNb4iYgoWAzoiIgq0OKZE3DrhdMwoT4GATChPoZbL5yWd0EUANi5cydmz56NGTNm4Jvf/Ca++c1v4nvf+x4WLFiA5uZmvPvd70ZdXR2AZFrgU089hbPOOguPP/44TjnllICemaYCpM6HHdga9/mrX/0KDQ0NOPHEEz3d97TTTsP+/fvx7LPPAgASiQReeuklx/uccMIJ+Otf/5r5edKkSXjhhRcAAC+88AL27NmTz9MgIqKAMOWSiKhCLZ45wVcAZzZ//nzMnz8/67YjR47glVdegVIKX/ziF9HU1AQAGDNmTNbMz9q1awMbh7aAU+d37tyJpUuXZmbBvv/97+ONN97AggUL0NDQgNmzZ2e2vfnmm/HpT38aZ511Fs4999xAAtvW1lZ87nOfw/Tp01FbW4t77rnH831ramrwwAMPYMmSJTh06BAGBgZw3XXX4YwzzrC9z0c+8hG0tbVhxowZWLFiBS666CL8+Mc/xowZM3D22Wfjfe97n+/nRERE+ZPQSknbaGpqUlu3bg17GEREJefll1/GBz7wgbCHkWXt2rW455570N/fj5kzZ+KHP/whamtrwx5W0R05cgTHH398JrCdMmUKrr/++rCHVRZK8bwmIgqbiHQqpZq8bMsZOiIiytv111/PwAXAD3/4w6zA9qqrrgp7SERENEIwoCMiIvJJJ7A9ePAg5s6dm3P7E088gTFjxgQ9NCIiqnAM6IiIyohSqjTaAVDexowZg+3bt4c9jJJQass+iIjKEatcEhGVidGjR+PgwYO8CKaKoJTCwYMHMXr06LCHQkRU1jhDR0RUJhobG9HV1YX9+/eHPRSiQIwePRqNjfk3eSciIgZ0RERlIxqNYvLkyWEPg4iIiEoIUy6JiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEzlHdCJyGgReU5EXhSRl0Tk6xbbjBKR9SLyRxH5nYhM8jNYIiIiIiIiGuZnhu4dAOcppc4EMAPAAhE5x7TNvwJ4Wyn1twDWArjNx+MRERERERGRQd4BnUo6kvoxmvqjTJt9AsA9qX8/AGCuiEi+j0lERERERETDfK2hE5EqEdkO4E0AW5RSvzNtMgHAXgBQSg0AOARgjMV+rhSRrSKydf/+/X6GRERERERENGL4CuiUUoNKqRkAGgHMFpGppk2sZuPMs3hQSt2tlGpSSjWNHTvWz5CIiIiIiIhGjECqXCqlegH8CsAC06+6AEwEABGpBlAH4K0gHpOIiIiIiGik81PlcqyI1Kf+HQPwfwC8YtpsE4DLU//+JIAnlVI5M3RERERERESkr9rHfd8D4B4RqUIyMGxXSv1cRFYB2KqU2gTgRwD+r4j8EcmZuU/5HjEREREREREB8BHQKaV2AJhpcftKw7+PAbg438cgIiIiIiIie4GsoSMiIiIiIqLiY0BHRERERERUphjQERERERERlSk/RVFGhI3burHmsd3o6Y1jfH0MS+efhsUzJ4Q9LCIiIiIiIgZ0TjZu68aKDTsRTwwCALp741ixYScAMKgjIiIiIqLQMeXSwZrHdmeCubR4YhBrHtsd0oiIiIiIiIiGMaBz0NMb17qdiIiIiIiomBjQORhfH9O6nYiIiIiIqJgY0DlYOv80xKJVWbfFolVYOv+0kEZEREREREQ0jEVRHKQLn7DKJRERERERlSIGdC4Wz5zAAI6IiIiIiEoSUy6JiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMlUd9gDKzcZt3Vjz2G709MYxvj6GpfNPw+KZE8IeFhERERERjUAM6DRs3NaNFRt2Ip4YBAB098axYsNOAGBQR0RERERERceUSw1rHtudCebS4olBrHlsd0gjIiIiIiKikYwBnYae3rjW7URERERERIXEgE7D+PqY1u1ERERERESFxIBOw9L5pyEWrcq6LRatwtL5p4U0IiIiIiIiGslYFEVDuvAJq1wSEREREVEpYECnafHMCQzgiIiIiIioJDDlkoiIiIiIqEwxoCMiIiIiIipTDOh07WgH1k4FWuuTf+9oD3tEREREREQ0QnENnY4d7cDDS4BEqu/cob3JnwFgesvwNk+sAg51AXWNwNyVw78jIiIiIiIKEGfodDyxajiYS0vEk7cDwwHfob0A1HDAx1k8IiIiIiIqAAZ0Og51Od/uFvAREREREREFKO+ATkQmisgvReRlEXlJRK612ObDInJIRLan/qz0N9yQ1TU6324b8O3lmjsiIiIiIgqcnxm6AQBfUUp9AMA5AL4oIqdbbPe0UmpG6k95T1XNXQlEY9m3RWPJ2wH7gA8AUzCJiIiIiChoeQd0Sqk3lFIvpP79VwAvA6jsjtvTW4CP3wnUTQQgyb8/fudw0ROrgM+MKZhERERERBSQQKpcisgkADMB/M7i1x8UkRcB9AD4qlLqpSAeMzTTW+yrVqZvT1e5hLLezi41k4iIiIiISIMoZRN0eN2ByPEAfg3gm0qpDabfnQhgSCl1REQuAHCHUmqKxT6uBHAlAJxyyimz/vSnP/kaU8lYOzVV8dJEqgA1xLYGRERERESUQ0Q6lVJNXrb1VeVSRKIAHgRwnzmYAwCl1GGl1JHUvx8BEBWRBovt7lZKNSmlmsaOHetnSKXFLgVTDYJr6oiIiIiIyC8/VS4FwI8AvKyU+g+bbcaltoOIzE493sF8H7PsmNfcSVXuNlxTR0REREREefKzhm4OgH8CsFNEtqduuxHAKQCglPoBgE8C+DcRGQAQB/Ap5TfHs9wY19y11ltvwzV1RERERESUh7wDOqVUBwBx2ea7AL6b72NUnLpG6zV1ju0OiIiIiIiIrPlaQ0ea3PrYERERERERaWBA59eO9mQ1y9b65N9OBU7c+tgRERERERFpCKQP3Yi1oz1ZpTIRT/6crloJOPeqYwBHREREREQB4AydH0+sGg7m0li1koiIiIiIioQBnR921SlZtZKIiIiIiIqAKZd+eKhauXFbN9Y8ths9vXGMr49h6fzTsHjmhCIOkoiIiIiIKhVn6PxwqVq5cVs3VmzYie7eOBSA7t44VmzYiY3buos/ViIiIiIiqjhSan2+m5qa1NatW8MehmfPb7oLE19Yg3epA3hTGvDUKf+GO96ciZ7eOCIiGLQ4vlUiGFKKM3ZERERERJRDRDqVUk1etmXKpQ8bt3VjxfN/g3jijuEb/xcAkoVSrII54+3pGTsADOqIiIiIiEgbUy59WPPYbsQTg772EU8MYs1juwMaERERERERjSScofOhpzfuvlER96ODxVqIiIiIiMofAzofxtfH0O0hGEuvmbNbUze+PllYxRxk3X76H3D2q99JtkGoa0wWW3FoSu41SEsXa0nPLjL1k4iIiIioPDHl0oel809DLFrluE0sWoVvt5yJPW0L8e2WM3O2FyQDqhlffxxLH3gxUxFz1uEtmNp5U6otgkr+/fASYEe75ePoVNS0ShVl6icRERERUflhQOfD4pkTcOuF0zChPgYBMKE+hsvOOSXr51svnJaZ9TJuDySDufR8XW88gcTg8Ozdsup2xKQ/+wETcezbcCMmL9+MOW1PZgVrOkGaXYpnGKmfRERERESUP6Zc+rR45gStNMX09nPannRM1xwvByxvf5c6kDUDl96nTpBmlyqaTv0kIiIiIqLywBm6kPT0xrEo0oGOmiV4bdSl6KhZgkWRjuHfqwbr+6kxmX8bZ+DsgjGr261SRWPRKiydf5r28yAiIiIiovAwoAvJ5cc/h7boOjRGDiAiQGPkANqi6zJB3eqBFsRVTdZ9+lQNVg8MF0VZFOnA+r7PA6312CJX45M1v8na3i5Is0oVNaaGEhERERFReRBl0/w6LE1NTWrr1q1hD6Pg+m57P2rjb+Tc3oMGzDl2Z06Vy31owC39F2PTUDOAZDDXFl2HWsM6u4Gq0fiGfAH3HJld0FYEbHlARERERFQ4ItKplGrytC0DupC01mO4JIqZ5LQpMLca6KhZgsaIxTq7uonA9buS1TCfWJVpefD8qdfgut9P8RyE2QVt5nEAyZlAzvAREREREQVDJ6BjymVY6hodfpnbpsCcJjk+ctD6noe6kvd5eElWy4OpnTdh1uEtri0NAOcWCGx5QERERERUOjhDF5Z00JVwaRWQnnEz2df6txiH/bm3YyzG1Y1OBXPZBlQEEQyhRzVg9UALOk+ch2eWn5eznVsFTisCYE/bQk/bMmWTiIiIiMiezgwd2xaEJZVKmUmLtEm/HDrUhVOXb85ZUxcdOg79Uo0aGchs26dqcGviYtxx6PuW+6qWIQBAoyQLsKw4DAC5AV0+/ei8tjwwp2ya2y8QEREREZF3TLkM0/SW5Oxba29yJs5Cz9AYKACzDm/B1M6bMmmUYyJHoKDwljoeQ0rQNdSA5YkrsPXEeeiLjXN96Frpx4qa+4dv2NEOrJ0KtNbj2dHXZrVQcBONCPr6BywbnpsxZZOIiIiIKDgM6ErF3JVANHuWy9imYFl1O2KGipYAMEoG0adG473v3Ifm/jtRUx3BFrkao+NvYMhDJu27kSqqYlpzNw77cZuhhYIdAVAfiwICvN2X8LQ+T6cBOhEREREROWNAVyqmtwAfvzM1Uzc845ZuUzBeLCpaIlkcRQB8NtXXrjb+BiIAIgIMKUCp5No5K5IuzPLEqpy1fDHpx43GGTyTCfUx7GlbiONGVSMxmB09Os246TRAryQbt3VjTtuTnmYxiYiIiIi8YkBXSgwpmJfU/jATzAFAj2qwvEukrhF72hai9bgHUT14LPt3AnSrBnw58QX0mZqUIxIF+o8m2ydYFFABgHE4gNsvmYFYtCrrdmPDct0Zt6XzT3Pcn2+G1FGsnZqpEhomp6qhRERERER+MKArUebAZ/VAC+LmoCwaS6ZqAqnCKrnGy0FsGmrGSnUl+mLvASBA7GRABIi/BfteeEBfbFxOu4QJ9TH8+Ow/YfGv5juutzPOuBlnp9Y8thsXzZqQtT8/PeyM+279xs0YeOiarHYNxtYPYeG6QSIiIiIqFFa5LFHpACdd3r/zxHnYdfqkTJVLc+Nx1DVazrT1qDGYUB9D8/yrUTvzm8kb105NBXP2+lQNVicuQWtqLJmAa0c78PDNmRTN9Ho7JJCZUTTOuFlVtXywszuQRuTmfV/Rfy+qI9mzlEjEkyml6eMUAq4bJCIiIqJCYUBXwrICKQDJFgNXWW88d2VuX7toDI0fvxXPTDe1JrCZzVMKUBD0qDFYPdCCh9+ZjVbzRg7r7R4+1pzTV85pdspLQOfUs868b7t1hnbPt1jG18cs+/pV+rpBIiIiIio8BnSVwtzXzjyDZ2Qzm9etGtDcf2fm5wlWAYdNcDQOBywbi7vNTjkFbG4968z77lENaLQK6tLFXwrI6XksnX9a1vMAAl43SEREREQjFgO6SjK9xVtqocVsXtzQIgEAPlnzG6ySB4HWfUDspNRGbwMSAdSgeY+2QZPT7JRbwGY3u/eV9hdx/frtiIhgUA2vAVw90JKs9Gls72BcZ1ggbs/DnD5rDviIiIiIiPLFgG4kspjN23XqNej8/RRIbxyXH/8cblLrUB1PrUczrrezCuYcgian2Sm3dEy72b10EGcM5oDkGr4aFcGq2gdRG9+Hvtg4rE5cgnt+chzGP/IkPvL+sfjlK/ttgyqnWTYnXtJKc9NniYiIiIj8Y0A3Uplm884G8Myi1A9rbwAOHbO8W4ZUAWrIMrXTHBhdNGuCZSB1/frtlrtOB3J2s3tmVSIYUgrjDcVfrGbN7v3tnzP3Mc+iuc2yOWHRE8pXvl8iEBEREaUxoKNcXoqIqCGgtTfnZqvA6NgL/40txz2I2tH7gFGNQNVKAC2uxUKsZvesDCmVs37PatbMzDiLtuax3Zg3+Gssq2nHeDmAHtWA1QMtWPNYjesFdrGLnpRqEFCq4ypVfr5EICIiIkpjHzrK5aWIiM025kBqUaQDq+Ru1MbfgLk3nFuTcXMPvCoRy8e06nnnZWYPGJ5Fazq8BW3RdWiMHEBEgMbIAbRF16Hp8BbL+xn73x19ZwDRquyxFaroSak2KS/VcZUy9ickIiKiIDCgo1xzVybXxdkxr5nb0Z7sbddaj/V9n89qNL6suj27SAmQLMbysy9g8UNnoPP46/DZ45+zbTK+eOYEPLP8POxpW4hvt5zpGAAagwogGUx21CzBa6MuRUfNEscG6Ctq7s8ZZ630Y0XN/Tn3MQcvvfEEoICTaqOBNEt3UqpBQKmOq5QxVZeIiIiCwJRLymUummKscmleM7ejPatiZnpmK91o3LY3XKq4Sm38DbRG70LrpWcA0xdmZr6s0vbcqkUag4pFkY6sipeNkj0uAIhGBH39A5i8fDNeHW09zncj93ar4CUxpFBbU41tK893PLR+6QYBxUqDLKfgxO8xCeqYsj8hERERBYEBHVnz2gLBotF4rfRjWXU7NvU32/eGM0rEgSdWYePgHNc1RU7VIo3Bg9XMYK2hAXpdLIqj/QN4uy+RvO/QGDRGcsf5FzTgg8s3Z124hxm8eAkC0gFHd28cAiBdC7S7N46l97+Irz/8Enr7EoEGePkEJ2GsufO7bi3IdW/sT0hERERBYMol+WNTQGV85CAEwLqayzBQNdrTfvym7RmDB7uZwXQD9ONGVSMxmN3Drk/VZD+2qsEt/RfnrAmzC1KKMbPitu7QnHaqTPdPDCm83ZcIfJ2b27jMwlpz5/ccCzK11LxGtJCpukRERFS5OENH/tQ1JgudmETqGrGndSGAhcCOM4bTNx0ak/f8JXeGZ1GkA8v62oHWg5YtEoyMMx62M4OpYi7m2bRFGWHzAAAgAElEQVRNQ81AIjmz1xg5iH1owGODZ2JZdTtul+9lql5+pX0Ig0plzXwBucGL1uzTjvasnoBOz1En7TRz/KqzK3emU06B3H55+dJtnu6ld18h+J1dDXp2lv0JiYiIyK+8AzoRmQjgxwDGARgCcLdS6g7TNgLgDgAXAOgD8Fml1Av5D5dKztyVWWvoAACRKNB/FGitHw5Qrt+V/J1pzR2ATJGV8Y9kp+2Z18FlKmQC2Wv4UsHQ4rpGTDj7Glz3+ylYc7gFbTU/Qgzv5DwOYJ0iuGmoGZ218/DM8vNw640rcKvdGjzVDAVkgroJpuBFKy1vRzsGHroG1YPHMs9x4KFrkm9Mh6DOS9qpl3WE5vv4oROchJW26nfdGte9jRxsw0FEROXCT8rlAICvKKU+AOAcAF8UkdNN23wUwJTUnysBfN/H41Epmt4CfPxOoG4iAAFiJwMiQPwtmNsUWG5fNzH58/SWnLQ92wqZT6xK/jsdHB7am3mss3fejGcuOIA7brkVsQu/a/k4gHuKoF3Vy2XV7Zmf08HcM8vPy7rQ85KWly7+0vXAiuFgLqV68Bh6NqzA5OWbMaftSa00RGNgYbeO0PgcFkU68Ozoa5PB99qpw6+TaZz5jMXMuK+IhxYUhaCbGhr0/ak8sA0HERGVE1HKvMomzx2JPATgu0qpLYbb7gLwK6XUT1M/7wbwYaXUG3b7aWpqUlu3bg1kTBSCtVMtUzBRN3F4ls6B8VvxV0d/BpGcVWAAIMmm5gE+lvkbeNVaD7F47CEleO879xlHktPUfPLyzXajxp62hVkzeK+NuhQRi9jG+DixaJXntVU6+14U6cBt0XWIGYK+garR+IZ8AfccmZ0pHGNca6g7lvTxtdqXmd2MZ9DMr/tH3j8Wv3xlv+eZGM7cVD67XpbpL3CIiIgKTUQ6lVJNXrYNZA2diEwCMBPA70y/mgDAeMXdlbotK6ATkSuRnMHDKaecEsSQKCw2RVJsbzetH1s8dyUWL0+lGq61Xp+XaWqu+1gmTimCYrM2sEeNyfrZakbJLS3POINnt9bP+Dg6a8uy1rL1We/7TWmAALix5n7EkD2DVz14DFcM3Yv/wuxkfz2TeGIQX2l/Edev3+4YzJjTTq32BSSbxZvXJHqqxqmx7tAqAEtflOdTtXIkrHsb6UFrqbYHISIisuK7yqWIHA/gQQDXKaUOm39tcZecr+iVUncrpZqUUk1jx471OyQKUzrY8nK7RcpkVnqmVYNzY1NzncfSZfHYcVWD1QPDQYNdqp1bWl5PbzzT9Hy8HMCQ6R3RZ3qc9H28Sjdjb/zkrZbHb9yFt2BP20LLHnsAMEEOODZjH1TKNQ3NKu3UypBSmFAf06vG6XbeGLilzumkxwaRdlpIQY2T6Yb2qb9Wt/N4ERFR2HwFdCISRTKYu08ptcFiky4AEw0/NwLo8fOYVOLcgjAjix52WWvkHNbbaT+WLovH3jXrG+g8cZ5riXm3cvSXH/8c2qLr0Bg5gIgAEQGGFKAU0DXUgPsHP4Rl1e1ZQZXW2rId7cl01A1XAtWx5LrG9PE789Lk8W2tx6Dl9y3JJZARGW4SbxXUpdmV7PcagI6vj3naNutx3M4bA7eAzW0mxu1i3S2IKlYwGGRQEWRrhnKls1aSx4uIiMLmp8qlAPgRgJeVUv9hs9kmAF8Skf8G8HcADjmtn6MKkA62vKTD2aZM7rWukOnnsQCtNL3M/g2/PxvAM4vsNzdySstbFl2P2oHsVMeIJIO5/z9yKb4mP8iqTHlbdB12nT4JwHmWz+P5U5OVPXt647j8+Odwk/rBcKGV+FvJIPfCu5M/GyqMVkNBqWQAZ8fYJN6OVVBkl3ZqlL5ATjdBN7Jqt/Bwb2oMNufN0KEunKrZBF4nPTbNeLHulK4ZZBNyN0G2gQirAmkp0WnDweNFRERh87OGbg6AfwKwU0S2p267EcApAKCU+gGAR5BsWfBHJNsWfM7H41G5MAVCtmzWqSUp6zYF+T6WuV3Cob3AxquBR28A4m97C/ACUhvfZ3l7Y+Qgbq37GXAoO9iLST/OfvU7AK6yfB5TO2/CrMQV6EYzrui/F9WR7KqZWbNXppktEWBARRCBgkBZBnfpJvGR1Hq3nN9bzB4aewKmRSOC40dXW66LM25r127h5GgNgIW2503P0Jis2an02JwCNqtxmtNjrfT0xl2DKN0gy886rCCDijBbM5TSWjSvayXZyoLIu1J6jxNVkrxTLpVSHUopUUpNV0rNSP15RCn1g1QwB5X0RaXUqUqpaUoplq+kYVYpk2Y2qXTarNL0hhL27RXcpNMabcr9O3Ja++dW6MXiecQMrQjGWzVTT9/fZt8RKLz3nfvQrRqsf1/XiD1tC/HtljNz0tAEyQDKnE5olXa65uIzsW3l+djTtjCr1YN52+U1Nu0WouuTP1icN+Z1h+niLd298ZzEUmPA5pYe67SWyi2I8hRkpc4j1VqPszd+CLMOb8krZVJnzZebsFozlOtaNKvjFY0I+voH8kq1LZc1m0S6yvU9TlQOAmtbEBS2LRhhjOmDlsX+gUybAj9a6x32b+DU8iAz1r1AVl1GJAMM4/o+p/ROu+bqH7/TsH+bcdk8j3Qrgo6aJWiMWAR1damlrBb73oex+OCxO3LTNS2eV/rb1XSgZByJTksDAPbHyPa1MpwHhvt2DY3B6oGWrGbpFvf03BLBrd1C+nnapYreWHM/xuEA9qEBt/RfnDOuKhEMKWV5vPtUDZYnrsjcJ72t2zfZ5vRO4zjz+fbb7Vv0QnzLbtcqwOsxCJPXc8Zt7EG/jkSlhO1AiPTotC1gQEelw2dfubz2ncMmeLQKwszS43QK2NwCPov7GnvDPTv6WozD/pyH7hpqQHP/nTnpilmPDeQ/LhOr/5iNwYyn9Yz5BrUexmLFy0WD1QW1XaqoeVurvn5xVYMbDAGakV3wbXwtjesIb8en0PyPVzsGdXZBlt/ee27HKIigw65/o5H5cfwEloVK/fJz0coLXqpkbj1aiShb0fvQEQVi7krri3xj1UrdwiZO+7Zilw5plbJp5pAWmUkdTY/Vbu2fqdBLX2wcVh69CA/0zwYA3NJ/sWXQkE433DTUjBoVwaraB5Nr9ayOkdPx87gm0ZxOmAkk033t3NY/Oh0jL+eBgdU6OC9jtmK17i0xpFBbU41tK8/Put1cOMOqr19M+nFjzf14+FhzzhpEu/TY8XLQch3hKnU3Vm+uxuKZX7e8n92aL6viLPf+9s+Z33vp+2cMfqzWUuZbgCXreVusRbMqjrPmsRrfRWcKWbDGz3pGFlgpPK7hCg/XmxIVDgM6Kh1uVSutCpu4FU2x23fsJKD/CDBomsmya3ngpVm5RJxTOz02PDcGVfPankR3//B/gJuGmoEEsmbCdp16DTp/PwWSukBpnn81amd+03Xffpj/Y15WnbvuLSeINXJaK6hZvdQcWOkUbzHTvaDOCqJaP2O5zTgcwJ62hZi8fHP2Ph2aylsdz1rpxxX992Ly8tlas2xeegKm+/4B7tU6rY4tkN3qwXjBfPvpf0gW9XF5Lc2BuV1xnBWHAeA8X5U9g6wKaublotUuqOAFb2EVs/Is5XIrQkVE+WNAR6XFKeDwMvOls2+d2T7HipwpyqWRdh4Nz60CiU1DzXj4WHMmRUWnnUJQzP8xOxZjsWJ3PNPHSDPwNAZWVqmQN0TbMf7YQWCt8+vs64La5TmZ9716oCUnPTaOUVgz0IK10e9Zj08OZooJmGfZ7C5M85ndmTf4a5zz0JeAhw7gHDRg3uDF2AT7NYpA8vmZj/2sw1swtXMdIO4zt+bA/IaodVC7ouZ+ALeW7EyY20WrVVCRniF9uy9huTY1qAveQs5O+d13MWbOChnIkzuddiBEpIcBHZUPtwqQunSCBsuUzdSll1S5B3N5Njwv1W/szf8xvyljLdf22QaxmmmV+Y6t6fAWtNX8CDG8k/yly6yun2+Qnz/1GkztvCknHXbXqdfgbIt9W6XHxuauxB3TW9B3289QG89t2dmjxtg+vt2FqZeegEbm9Nlx2I+26DogAdvCM+lqp19pfzFrBm9ZdXvW8QDg+CWMMTBXNjOe78YBx+fl5b1RyPeV20WrXVpveoZUQa+Ij1dOgaRdqq2ffevMfBVr5owpreHz2g6EiPTk3baAqOicyv0X2vSWZMGOuokAJPn3hXcDrYcANeRwx9S2Z16avIjVbHMQVgl5LxbPnIBnlp+HPW0LMe7CW3JbUDgFaObjGTsZqI4BG660PD66pdzTY7tj7MPDwVyaQysMtzYGTq77/RTckLgCXUMNGFKCrqEGtA9+CBNfWAO01mPxr+bjx2f/KWvfzf94NWpveCVZiOf6XZkgp/ajqzBQNTpr/+bWDFasLkytziEndume6dYYaVWppoXGGSVzOqb2zK2B2LyvJZXavEWuxidrfpP1O6/vjUK/r4zvDWOLDsBb8JAO5sz39cMpkPRbQt5p5qsY9/cqyPYeRJWGLVPKG2foqHwUcFbHE7sZPdtUO5uqlxpr/zylqORbKCZImuveMvexquxpOj6+ZhbymNXN9xvknt44utGMTf3JWSyrQjFn77wZzxiritqZ3pL8cE4dz31owC2J3BYIRukqo2j9DFDXiOdPvQbX/X5KppT+6Ggkc7yM6+/MZfadirWkObVuyDomNusEPX0JY1fIKDUbXht/A23RdTi+phr3HJmtNcMUZuqX1xnToGeNvOwv3/RDLzNfTimVVkWWllW3Y3z8APa1jsXes5bi7EVXedqXE67honxVYjEdp3YrXF9afhjQUfnIJ2goBrdA0+faP8cAw0+hmKDlW3DF5fi4pag5/sfjtlYvQL4LxZgZjudvt3Vjy4adwJB1am+mZYIheJzaeRNmJa5AN5rRG08gFq3C2ktm2FbCdEuffVMaIKnnmb6YuX79dsenYLVOcKBqNKq9fAljfr9LJCe1uXrwGFrrHkTrTdaVP53oBu5BXdB5rcoa9KxRIQNJtxRWt5RK4/3NxXDGYT/qOm/C8wDOXnRVXumZ5gtX45cbOn0pw7yQL+Y4SuU5F5Nb25dKK6Zjfk698UTONlxfWl6YcknlZXpLqsF2dopa6GMyp2MaZ2H8rv3b0Z5MQ7RK13QKhsqFy/HRmVnIMXelXiqoD+Y0Pj/phmZWqaCXnXNK5ucba+7PWasWM6VJOqWweUmfHXfhLTkphHZBR5UIBMBToz6Cfx/8fFYa6tJ3/hUzN9Z7S+sxvN+VTWqzcjqeTu8dDemLn+7eeCY9cen9L2Lmqse105PMr2V9LIpolWRtU4hZI6+pt/kEkm4prG4plcb7W30REpP+ZOqyh32ZmV+73ngCxxJDWHvJDNeUVqvXPd+0VD82butGx8++h/V9n8eroy7F+r7Po+Nn3yvIOErlOReT23MuVkpwMXmpfgxwfWk54QwdURCcZqf8zBK5zcAFXSgmDB6qQ846vCWnH5k5/dDyP54gZnU9prT6LhTjwnFGyaaAiDFNEvD4n7PGMbNLYUuvO5zT9iR+Fp+Dn2FO9h0HhmdXvabP/gUNlsczeXuS8Vv2y49/DjepH6B68Fjylz5mr33NElswv5bFmBExn5/mFCsg/0DSLYXVLSXTeP/xcesvQt6lDnjal1mptrfQsX3z3Vgld2v1pcxXqTznYnJ7zpVYTMfr2Lm+tHwwoCMqND9r/9zSNYuYUpgjqLV7Lsfn9tP/gKmdw83U0/3IzFUXs/7j0Rmb07aaKa1ZF+o7jhZvzafNeWCuimn7n7PVMbh+l+vD5nshb+Q1MLq1/2Lcakrf7FM1uDVxMe5AbgrRFf33ojpyzPRgGimvBoVcfwYUr/JfIQNJp+fgpapo+v77Wu1Tfsd53JdRqba30HFF/72ojVj3pQSCDehK5TkXk9tztjvnIiKYvHxzWaaleknBLub60pGY5hs0BnREheZnlshtBq7QhWLsgp0g1+65HJ+zX/3OcB+zlHTVxXQBkqz/eHTG5ratn/WPxVzzaXEexE1VMW3/c/b5WuZzIW+UKYBhmH1d81hNzj63njgPyw8jte1B9KgxWD3Qgs4T5wHI/ZY9yJTXsAqZFJrfQNJt3ZFxNjBaJZ5mA/eetRR1Fu0/9s5ainGwnhWORgR9/QOWF9de1vfZPYcw28YYx/XqKJtCRZGDlrf7UaqtcrzINyhwe852617TVX3LcU2d3fvo+NHVvtuY6KrENYphYEBHVAz5Fgzx0oAbKEzQ4HSh77fJu5nT8bG5AB8fOZhTpEN7bG7b+k1pzfd112VxHuw69Rp0/n4KxO3iJujX0sCtAIi5AEZ69nXFYQA4z2Jf/ZkgHkild6aCAnMwZVdhsy82DrUBP4+0Yl/oh12kw+4iDEBOwYVoRHBSbdT1YvHsRVfheQATX1iDd6kDeFMasHfWcJVLu9RRu1lep8qWbheSYVXFNI/L7lw+lse57KZcK4H6qYbs9pzN51xEJKdFS7mlpZZSk/eRmOZbCKJMJ2XYmpqa1NatW8MeBlFpMAdVQHIGzkvpe7/WTrVvx3CoC8Pdx4wkWbCmWONIpwUaZxItx2UzttZ6m+1T23p57HLndgx8ciqN3VGzBI2R3AvVfRiLca1/dNyX+QJkTtuTWd+ym4NFINXLL3q1ZVXM5zfdlQoi9uNNcS6Vb7f+zGvPwnyZL1qL9bhWzMc7bUIqqLX73TPLz8u5vVDjSD+W3XmTz31vP/0PyayBAs66ezmXB6pGo/oT3/H82DpfBJTKlwY67F5LI6f3is5znrx8s90nJva0LXQdazke30LSPZ4j6fiJSKdSqsnLtpyhIyplYbZqcJqdKubaPbe0Uqug14rV2Nyeh9VjR6JA/9FkIFQqrTOseF1HWODX0nHdlk3K2LthnWLmlCJo/pZ901AzkMhN0dz0zmxsaXsy6yLg+U13YWo6zU9yS+W7Po8iXVQU+ptsneeUz1qrQqSkehmH3Xljd9/u3nhW+mYmCN3RDjx8c8HbxJjHZTyXGyMHgbrGZOsPjWBOJ6WtWGs6g6S7ztXqXPf6ZYOfNXVeXotSCViKNQ6dNF+mZ9pjQEdU6oqVtmfmdKGfz9q9fIuouAW1VimDZuYAML2v2ElAVQ0w2G+9rfmxYycB/UeA+FvJ28Ps++dEZ11coddhmmRdLK61Psckj2DSKi1q01BzVopmmvkiYOILayzbPkx8YQ1gmKWzfR5FUsiCFboXmlZpZ8DwRViQ67AKtc7NaW2ksXw9kDoGBUxPdhvXpqFmdNbOy2uGcySktOmsc/UbFPhZU+f2WuiOTTfo8rp9MQMnnTTfkXAu54t96IjImlMPN7fee2bpAOPQXgBqOMDw2hfMqf+g43o209jM44i/BSgFxE62fx7Gx645Ljv4A4rX90+np5pOf0Ld1zJIAfcJNPbT+3bLmY5914x9pN6lLNpLYLhUvraA+t+Z2QUp6ZkBnX54Zm69tsy9uqyCufRFmFtfOh1uPcI8PZbN6+GlN5/xGNj1PHTshZiHfI7fxm3dmNP2pOV5MBIqV+r0WfTbV87cS7JKJGcbu/25vRY6Y9PtGaizfTF771n1WbVLjR0J53K+OENHRNasZsamnJ/8ecOVerNshfxm23Ym0WKdm9U4hhLJQO2GPe6PFVbfP91KlLbj3Ju8oDW/bmHNAhcwpdg4Y2f3zX36IsCuZ2C6VL4Wq9dq49XAozcA8bd9PcdCVtvL50ITSF7MDill+W1/EOlabt/IuxZ3cHjvLJ7ZknVfu9W36WPgpReiH+Z1mqOjEU8VB91mUwpdubIUUgR1+ixev3675T50ggLjuTd5+WbP+3N7LXQCFt3ZKp3tix04ec14KOcqrIXGgI6I7Bkv9P2Uty9kIKSTMuh3HGH1/dMNiO3GCZRemmgBg8n0RcKctictm9OnWx64lcrXYvelQQBpuoWstpfvheaQUpaFC4JKSc1njVx6tqqnN45nR9+IcbB/7xjva1dYI30M3Hoh+mEOynrjCcSiVVh7yQzfDdALWbnSb2peIXsh2u3b7kuefIMCnSDD7bXQ2Zdu0KVze6kGTl7O5VL4giEMTLkkIm900vjM7AKeIAIhnZRBv+OwShGEDM98BZRal0M3ELUcp0Gx0kRLxO2n/wG3RdehMXIAEQEaIwdwW3Qdbj/9DwCShU92zfoG9mEshpRgH8Zi16xvZFW59MzLlwM+jr8xrXTIIu1xUaQD6/s+n0kvfH7TXbapeEZuaX52F3J+1sV5GZfu45rTyuzSaa3es27HYOuJ87A8cQW6hhowpARdQw1YnrgCP1f/4Cnl1ek5+0lxcyvusuax3bho1gRPKW26/IxbN2VQl/G9kl57mA7azUmSfgJcnRRZt/RCnX3pvjd0bg8ybTpIbsev0OdUKeMMHRF542d2q9CFN7zO8vgdR1aK4F4kCyunLqoLOfOlOzOYM04Lh/aWfqXOgFg1p49Jf/J2JIO2sxddlSmAMi71Jy9Os6MG6lBXzkWlLvO36Dnl7Q/txdTOmzArcQW60ew4e+KWuhjkLI/OrI7u45oDDLsebgBy3rPejkG/RaEd95RXt+fsJ8XNS3GXBzu7Mxe+6RmM69dv9z2D4WfcxSxwYT7+CsOf3hMCmBkEvKcYO81e6+xL972hs30p9akzczp+I7loCvvQEZE3fnuy5VvlMmhBjSOf45HvY/vpR2g3TqNi9TYMSyF67dm9lh7baNj12jNzSh8yX6Ta9fXrGmpAc/+dmZ/z7QfnmMqkcW576f/m+XFNzD2trHq45dDoK+ml0qfV83B7zrrHxDwmL43v04FLkL0M/Yzbrv8YkAy2ggwi/IyzlBWqymW58tsjsNSwDx0RBS+I2a1SCBiCGofujKWfNYh+iodYvW5mBSi9XhRh9drz8lqmxnVw6DicIMdQIwOZuzuuuzI8p77YOHQcvQjd/X8PIHdWJ+dbdJu+fuMl+3avhQ089+rSPLd1Z3V01uOZZ6vSPdxurLnfsqBJcrze1/LmWwzD7Tn7mQE1nwdOxV2CmMEwF2+JVklW8RFB8lydY+r3aKbdNsKHSq2OqLtWtRx7DLrRaadSybiGjoi8CbO8fTF5LTmvux7PzxpEwLl1g9v9jK+bnUJX6gyaTiuMgNsjuL6WhtdqUe3/xVcTV+asu9qaKsji9Jxq429gldyNRZGOzCbm9UnGdUIRm3OvR43J+tnLxY3WWhTNczvo9XhGVmt/tlSdi99+4tep94AFp8De4fNA53mMr49hUaQDHTVL8NqoS9FRswSLIh2ZlhN+17kZz4MJDuPyG9iYz4veeAJQwEm1UQBZSeiu65d020b4Efg5V6DWJKRHp51KpWNAR0Te6QQV5fgfXiGDhLBaHgDZr1s+F7XFUi699jRey6XzT8OWqnPR3H8n3vvOfWjuvxNbqs61vsCweE610o9l1dnHwfbi2+KcjKsarB4Yfp5eL26sZnLmDf4a5zx0bu7ro3luaxdc0DgvHIsm6L5nXT4P3J6HsQjKh479Em2mwjxt0XVYKE9nrXNbOv+0TBGPfGdSnMblN7CxOi8SQwq1NdWYUB/LmR10CsjMr5WdIGbRzMdkUaQDz4xago5jF1qeU45FezT7qnotAET6nNqpBF0AqNQx5ZKIgucnvTBMOu0BdNMgw2p5YFboAjX5CrLXnlWxF91UW6d0To3XUqu4gM1zMqdMZl18m8d55qXAHx7P/Lzr1GvQ+fspEM01M+aL6MxaNAwXXMm8PprnttYxyeOzxDatTPc96/J5YH4elx//HJZF16P2oX3oezw7XfaLQz9BbSR7HV86WE8XWQmqeIPb8TWndkYjgr7+AUxevtn1HMlnhs/pdzptI/wwHpOmw1vQVvMjxPBO8pemc8q1aI/G/xNeCgCV67q2Qo7b675126lUMhZFIaLg+S2gEpZCFM9I81PYJGiFLFDjtm+73+ueM4Us9uL2WhXqtbR5TsaiJlkFLPyOw+G1Ml9c2xVcQd1E+y8Jgji3w/ws0fk8sHgt+lQNlieuwKahZrw26lJELKahhpTgve/cZ9xzwS9EzWvgrBpw281qOBUXAWD5O6fm8+ZxBVmwxZbLOeVaQEXjvHDbV9DPuVjBYSFfK6t921UkrdRiN2k6RVGYcklEwQszvdCPUumXV2j5rsezYkyHu20y8NAX7VORnFKVgu61B+Tf783LGjnjaxk7GaiOARuu9JZebJdCaPGcBqpGY13NZdbpQ37WZWqmE463Lf3fVdhzO8zPEp3PA5d02R7VYLmrfNY3+mVcb3fcqOqsYA5wTpN0Sue0WxM3qJSnnmBuPcbM8k5ldDmnXGchNc4Lt3356eNnVswebH7HrduT0W5dZj798io1BZYpl0QUvFJJL9QVZr+8UmnroMM8KxF/K3cbYyqSUwDiq9deF6y/MUd+F/5egoj0a6mbEqhRIRN1jaieuxKt01vQmu847WimE74pY62rRKZfn0JVsQ3zs0Tj88Cur2A6XXb1QEtO+4R+VYVaOYbXRl2KHtWA2/EpNM+/Ouhn4SifiqOAc7qsseLgQnkay6rbMV4OoEc1YPVAC9Y8VuOpR5tTvzydXoY5XM4pu+qbmWBb47xw25fu8XeagStmDzY/xXXy7cmYZnxOuv3yfJ03JY4BHREFr1TXabnx0x7Aj0pac2glHWA4BSAX3q1/zhiDCNs0KpsL/4DWyGmtu/SyvU5g5CfY8RAMZq1F23E0nPe01WdJJAr0Hx1eKznl/Kx1g4G9ZzU+D/6CBsuANz0Dt2moGTUqglW1D6I2vg+InYSqY3/FyeoIAKBRDqCtah2qq84EUITPm9RzenZ0A27pvzjZ3sHAaabQrTF2+nfX3rgCtxqC2EY5gDXRu3A0/mOg9ajj8XS78PYVvLj8/+TaQkLjvHDbl2vwqHFMitmaQWfcZm6vnVM7izTjc9JpxVDJjceZcklEwSul9EJdQZ7B/LkAACAASURBVKYjeuW3pUGxpVMG3dawpaUDDKdUJb/njE4FQ7cqdTr70p0lcyvmolMR1k87Bt304rDe01bprSKp2eDUa7f1R54rDub1+B4+D27tvxh9qibrtr5UhdF0+mDzP16N2hteSe6r5jhUqUTW9tWDxzy/513TxuzSek3n/jjsx23RdVmtMYIq876i5v6chu6jZBAnyxG4vVZuKX2+gheXc9lT6qf5vAAsj7fbvnRSBt2OSSHbgZjppjoaz1e7YM3Yk9GtnUW+z6lS+xECnKEjokIplUbi5aCc1hxaFeJwYgww3GZu/ZwzOrOrXmbJvO5Ld5bMbnsAWRe5xudkJ+iG8+Zg0GoWM4yiRuaZWKvUXqNEHPjZF5JrGos0y771xHlYfhip9MKD6FFjsHqgBZ0nzsMeq+IMPt7zrmljTjP+Fud+TPpxY839ePhYc6CFNN4Nm3WXRjaz2W4X3uPrY5h1eEtOOmenVX/HNI20dq0G3C4ZFm4zmoC3lMFCNqfXpTNuqyInVtJBmnHf3b3xrN6GgIfn5PA6+5lZLHWscklEFLZyqgrqNjMXiQKjTgDib+tVuSymfKqZ2o1bt9Kk14C4GK+902tR6Kqs+Z4Htq+dg0JWk009D3WoCz1qDG5LtGTSFx2r/vl4z7tW9nPat+16Ux+VfHUr13p4bLfn+PymuzC18ybETGsSVc0JGJU4VNzzOejPb5vj6aWiYym2QLAbt5HTe0XrObm8zjoVNEuBTpVLBnRERGErpZYGbpwuqNMl7EttzGa6F2Be2hjoBCfG7W2DE5sL7GIFxIX8ksHP+a6T6mvkddw6x9fiecQxCsv7/xVbT5zn68LTyeTlm3POmkWRDiyrbkdj5CAczynbGWWN19V4jGInAf1HgEFDamX6eQB5f3nhWhZft21JIc/nINvdOJwXGwfnaLcKKIUAz+p8TRMg2HF5eJ3Tx8Ru9q+UGpGzbQERUTkppzWHtqmEE4u35tAv3bVnXtoY6Ky7NG5fN9F6G6vj7Lb2zy/juiu7i2WvacB2a7gAf2tGvbSrsOJl3LrH1yp9Ee/gjrEP45nl5zlfFPp4z5vTw9JN35N9Ah2+pE8HqJrrLo3rn1q/cTMGHrpm+BjF38oO5oDsNErz+seq7HWGWQVuNNaeeXo9jedUIdPabT4Tu4bG6JfFd3hv5NPWoVhtDJzYpTNOqI9hT9tC9/eKDo/Fnp5Zfh4m1Mdy3i35towoBVxDR0RUCnTXj4WVuliuFUyNdNeeFfJiUOd4eqiomfc38p5TQT1U0HSr2urneFq9dsYqlxIBlMVaHS/j1q1Y6ve8yHPNqHmt1LLq9pziIznS55SXc9/w2dIXG4eOoxehu//vAQBX9N+L6sgx90Gmj4H5OVrN7qXXRGqsPXNei2oxjkK2v7B4D6cL4miXxXc5p8qxomMx1/bZvc770IAPLt+c9ZlYaQVSGNAREZWbMNschNXaIWjFag/gZRyA81o2j732fPVY8tKCwmvgbhcYpQuV+Am6APd+jvl+4aAboIXUIy+nIEXkoMPWkntOaRy/2vgbWCV3oz8yhE1DzfYN5s2cqqU6FbhxCKCNX1ZcfvxFuKnqB8nKoF7GUcgvogzv4aFDXegZShbESa+l1AqiAjynSiVg0e0V54vF6xxXNbglcXHWLCVQeQVSGNAREZUb3ZkEv0ql2mFYwmo4rzlr5usbecdZJYugIJ99pYM4q2CuABfX2l846F5MhzhbnTVTs9bnujjj+9si2K6Vfiyrbsem/mb0qAY0ugZ1khzP2qmBzXybv6z4ryOzcaRmAKuOG+7rZ7mWz1hBFyjcF1Gp9/CpNuvFPAdRAZ5TpRSwaFUN9cP0Ou9DA25JZPdZTH8mFnXmsAh8BXQi8p8APgbgTaXUVIvffxjAQwD2pG7aoJQq0cZKRERlophtDsq16XmQwpqV1Jw18/WNfBDFMtz2ZSZVgBoq2MW1Nt2L6VKZrc63BYVVlVarYBvAeEnOAq4eaEGboVk4AENl27cAY5kJt88KjQDa6suKB/r/Hs/WzsUzrec5P8e0IrTS8R1Emc6pvtg4rE5cgnt+chzGP/Kk1sxWsQMW4wxqXSwKEaC3L1H8YiyG1/mDDgF2UWcOi8DvDN1/AfgugB87bPO0UupjPh+HiIjSipnqVezZwFIVRl9FzVkzXxeTQc42We3LihrKv1R+IeQToJVCv00vabsafems9KgxAIBNQ82oURGsqk3NjLm1KXD6rNA45zx9WVECr0UgQVTqefhKoYaHVMcA12Gbx9obT2R+p72OMEBun4lFmzksAl8BnVLqKRGZFMxQiIjIk2KmepVT0/NKozlr5utiMsjZJvO+/K6ZK6YSCAry4jRupy9lPLyPB6pGY131ZZD+5IVw8/yrUTvzm7kb6n5WaJxzpZQ+6CTIWZ8giprYBix5ZF44FVyyGqufcQel0tIqnRRjDd0HReRFAD0AvqqUeqkIj0lEVLmKmeoVUuEHgnbg7vtiMshgxrgvP4VKyD+nQMvu/W1Ih62euxKt01vQ6vY4+XxWWFXBXDs153OtnC7Mg5r1KWhRE83MC7fZQi9jCqN6ZKWlVTopdED3AoC/UUodEZELAGwEMMW8kYhcCeBKADjllFMKPCQiogpQrJmESmhTUK7yCNyLmkLkNWWrVNaajVROgZbd+zufPph+PyscZo0Wz0yOJbQL8yDbxHjcV0FnJTVnU91mC+3GahTWbGolpVU6EaUcmlB62UEy5fLnVkVRLLZ9HUCTUsq2RFJTU5PaunWrrzEREVGAwup5R6XLbtYtn0CA9Om8J91eqxCCFUtWa/CA/ArzBCnIc91qX5miMm9nHTPzrBiQnJXMaiZuPt7GnoxOx1/zWE+2KS4iAPa0LbQcq5HruPl/iiUR6VRKNXnatpABnYiMA/AXpZQSkdkAHkByxs72QRnQERERFUCQF1FBX3zzAi+b0/HIJ8Aoh+PbWg/rXouSLJ4T1nMI8ly325eR4bV8ftNdmPjCGrxL7cebMhZ7z1qKsxddldzOS1sTu/NC8xya0/ZkzgzcokgHbqy5H+NwAKhrxPOnXoPrfj/Fvcplsb8MKodz30bRAjoR+SmADwNoAPAXADcDiAKAUuoHIvIlAP8GYABAHMCXlVK/cdonAzoiIqKABX0R5XbxHebYyp3b8SjVmSy/nJ5XkKmhuoI81233ZeLlOXsJDtP7sjovNAId8wzcokgHbouuQ0xMff+8vB5+z98gZ6dLXFFn6ILGgI6IiChgQQcBxZi1KPcAJV9uxyPIAKOUOF18P7GqsOeIU+qibZXWPAIlr0FYui1JXueBw/58tiZIr2F8dvS1GIf99mMzMx4T2zF7OH91A7Qy/2zRCegihR4MERERhSRTNdDmIjLf9hNzVyYvpIzyLZbD1hjZ3I6HXdXIcq88O70leWFeNxHJAGTi8IV6Ic+RdJBwaC8Alfx764+Gf7YK5uzOdat9PbwkeTtg/b6xUteY/3lgyWIsmhbPnIBnlp+HPW0Lk2mWTmMzMh8TO16ej1N1Tq/jcbq9jDGgIyIiqkRZF1I28g0CnC6+dVVqgKIrHXzbXfSmj0eQwXSpmd6Smn3qTf6dPp8KeY54bK4OqYLrue4WcJjfN7GTgaqa7O3Tr6Xbc/YaHNqNxQ+3saXP5dZ64GdfcD++Xs9f3QBtBH22FKMPHRERERWb24Wq3yAgqNYZldoaw+9aHyPj8RgpbSCMxy92UjLwGTSt2QriHPE6W6OG3FMCvQQcVr337F5Lp/eF1XlgTBW1+2IgiNkpp/es+Vy2muHM0EwF1e11WKmfLRYY0BEREVUipwu3dNGFUggCKjFAceip5nlmJ83qtSpWH8qwmI9f/K1kef/YyTnl/X2zCxKstst3XzrN1Y23A87vC6fzwHb9mM1YdL6AcBrb2qneZjzzWcemG6BV4meLDRZFISIiqkRlXhCgKApV0lz32FdqoZN8BXHuen1t/ZT/97KvsKoq6owlyHF7Kdbip81GGbch0MWiKERERCNdJa+1CoJbAQs/uNbHH7/FLHReW6v1oE3/mt/60CDXlvqlMxbdYiNO7M5ZL2sQAffXzrzOEhher7d2qt7717jWT/e+JYYzdERERJVqBH2bra2QM5i6+y6lmZ1S4Pe14ey0Hi8zxH5mPHXOZZ3Xzs9jlcF7jjN0REREZF81kApb0lx3drSUZnZKgd/Z5RFUrj4QXqpW+pnx1DmXdV47PzOLQc5KlgAWRSEiIqKRJ58CFl7lU4yh0gud6PBbzKKQr20lcis24hT82BV0yfdc1nnt8gncMzONAffmDBkDOiIiIhp5Cl3SnAGaP36O3wgqVx8ItwC6mDOeVq8dJBmArZ2aPS7dwN1LAZwyDfoZ0BEREdHIM4JKmo84fG31OQXQxZzxzHrt9gIQZNb3mdt/6Abuhe7NGSIWRSEiIiIiayysQ2EVEPFSIEXn/HRqqVBKvTlTdIqicIaOiIiIiHLpNkinXJUQEIc14+kl1VMnNdd2prH8q58yoCMiIiKiXLrFMChbJQXEhVwTahf0Bp3qWcFrK9m2gIiIiIhysfy/P6VWGr8UG2k7tUTw277CrILbg3CGjoiIiIhysfy/P6UUEJfqbKFT0JtOgwwy1bNCq88yoCMiIiKiXBWcolYUpRQQ66bPFmvtn1vQW6EBWNCYcklEREREuSo4Ra0ogk4Z9ENnttApDTJodsEtZ4G1cIaOiIiIiKxxhiR/pdQPT2e2sJjFcDgLHAgGdEREREREhVAqAbFO4FTMtX+lFPSWMQZ0RERERESVTCdwKvbav1IJessYAzoiIiIiokrnNXBiGmTZYVEUIiIiIiJKyqcYTin2uBtBOENHRERERFTqitVKANBLgyzVHncjCGfoiIiIiIhKWTFbCehyqopJRcGAjoiIiIiolJVy0FTMqphkiQEdEREREVEpK+Wgic3BQ8eAjoiIiIiolJVy0DR3ZbIKphGrYhYVAzoiIiIiolJWykFTPlUxKVCscklEREREVMp0GoOHgc3BQ8WAjoiIiIio1DFoIhtMuSQiIiIiIipTDOiIiIiIiIjKFAM6IiIiIiKiMsWAjoiIiIiIqEwxoCMiIiIiIipTDOiIiIiIiIjKlCilwh5DFhHZD+BPYY/DQgOAA2EPYgTj8Q8Xj394eOzDxeMfHh77cPH4h4vHPzylcuz/Rik11suGJRfQlSoR2aqUagp7HCMVj3+4ePzDw2MfLh7/8PDYh4vHP1w8/uEpx2PPlEsiIiIiIqIyxYCOiIiIiIioTDGg8+7usAcwwvH4h4vHPzw89uHi8Q8Pj324ePzDxeMfnrI79lxDR0REREREVKY4Q0dERERERFSmGNARERERERGVKQZ0HojIAhHZLSJ/FJHlYY+nkonIRBH5pYi8LCIvici1qdtbRaRbRLan/lwQ9lgrlYi8LiI7U8d5a+q2k0Vki4j8IfX3SWGPsxKJyGmGc3y7iBwWket4/heOiPyniLwpIrsMt1me75J0Z+r/gh0iclZ4Iy9/Nsd+jYi8kjq+PxOR+tTtk0QkbngP/CC8kVcGm+Nv+1kjIitS5/5uEZkfzqgrg82xX2847q+LyPbU7Tz3A+ZwrVm2n/1cQ+dCRKoA/C+AeQC6ADwP4NNKqd+HOrAKJSLvAfAepdQLInICgE4AiwG0ADiilPpWqAMcAUTkdQBNSqkDhttWA3hLKdWW+lLjJKXUDWGNcSRIffZ0A/g7AJ8Dz/+CEJEPATgC4MdKqamp2yzP99TF7TUALkDydblDKfV3YY293Nkc+/MBPKmUGhCR2wAgdewnAfh5ejvyz+b4t8Lis0ZETgfwUwCzAYwH8AsA71NKDRZ10BXC6tibfv9tAIeUUqt47gfP4VrzsyjTz37O0LmbDeCPSqnXlFL9AP4bwCdCHlPFUkq9oZR6IfXvvwJ4GcCEcEdFSJ7z96T+fQ+SH3xUWHMBvKqU+lPYA6lkSqmnALxlutnufP8EkhdgSin1WwD1qQsDyoPVsVdKPa6UGkj9+FsAjUUf2Ahhc+7b+QSA/1ZKvaOU2gPgj0heH1EenI69iAiSX2L/tKiDGkEcrjXL9rOfAZ27CQD2Gn7uAgOMokh9KzUTwO9SN30pNdX9n0z5KygF4HER6RSRK1O3vVsp9QaQ/CAE8K7QRjdyfArZ/6Hz/C8eu/Od/x8U178AeNTw82QR2SYivxaRfwhrUCOA1WcNz/3i+QcAf1FK/T/27jw+zrLe///rSjJJZrJNmnTJnrZ0owtN6QK07GLLIiL4BUFc4Kh4BFE4VE9VQFE5KB5wPR5x+R304ILIgUIFFESgSIWWlrbQUqBNmq1bmn2fmev3xz2ZTLY2zXZneT8fjz6Sue97Mp8JQzLvXNf1ud6JOqbX/jDp9l5zzP7sV6A7PtPLMc1THWbGmGTgT8AXrbV1wE+BmcBioBL4TxfLG+9WWmuXABcCN4anhsgIMsbEA5cCfwwf0ut/dNDvgxFijPkqEAAeCh+qBPKttUXArcBvjTGpbtU3jvX1s0av/ZFzNV3/mKfX/jDp5b1mn5f2cmxUvf4V6I6vDMiLup0LVLhUy4RgjPHg/A/2kLX2UQBr7UFrbdBaGwJ+jqZ6DBtrbUX44yHg/3C+1wc7pheEPx5yr8IJ4ULgdWvtQdDr3wV9vd71+2AEGGM+AVwCfNSGF/qHp/pVhT/fArwHzHavyvHpGD9r9NofAcaYOOBy4A8dx/TaHx69vddkDP/sV6A7vteAWcaY6eG/mn8EWO9yTeNWeO74L4Fd1tr7oo5Hz1X+ELCz+31l8IwxSeEFwhhjkoD343yv1wOfCF/2CeBxdyqcMLr8hVav/xHX1+t9PfDxcMez03CaFlS6UeB4ZYxZA3wZuNRa2xR1fHK4URDGmBnALGCvO1WOX8f4WbMe+IgxJsEYMx3n+//qSNc3AbwP2G2tLes4oNf+0OvrvSZj+Gd/nNsFjHbhTls3Ac8AscCvrLVvulzWeLYS+Biwo6NlL/AV4GpjzGKcIe5i4AZ3yhv3pgL/5/ysIw74rbX2aWPMa8DDxph/AfYD/8/FGsc1Y4wPp6tu9Gv8u3r9Dw9jzO+Ac4BMY0wZcCdwD72/3v+M0+XsXaAJp/uoDFAf3/t1QALw1/DPoU3W2s8CZwF3GWMCQBD4rLW2vw09pBd9fP/P6e1njbX2TWPMw8BbOFNhb1SHy4Hr7Xtvrf0lPddOg177w6Gv95pj9me/ti0QEREREREZozTlUkREREREZIxSoBMRERERERmjFOhERERERETGKAU6ERERERGRMUqBTkREREREZIxSoBMRkTHPGNMQ/lhojLlmiL/2V7rd/sdQfn0REZHBUKATEZHxpBA4oUDXsWnvMXQJdNbaM06wJhERkWGjQCciIuPJPcCZxphtxphbjDGxxph7jTGvGWO2G2NuADDGnGOMed4Y81tgR/jYY8aYLcaYN40xnwkfuwfwhr/eQ+FjHaOBJvy1dxpjdhhjror62n83xjxijNltjHnIhHfJFhERGWpxbhcgIiIyhP4duM1aewlAOJjVWmuXGWMSgJeNMX8JX7scWGCt3Re+fb219qgxxgu8Zoz5k7X2340xN1lrF/fyWJcDi4FTgMzwfV4MnysC5gMVwMvASmDj0D9dERGZ6DRCJyIi49n7gY8bY7YB/wQygFnhc69GhTmAm40xbwCbgLyo6/qyCvidtTZorT0IvAAsi/raZdbaELANZyqoiIjIkNMInYiIjGcG+Ly19pkuB405B2jsdvt9wOnW2iZjzN+BxH587b60Rn0eRL9vRURkmGiETkRExpN6ICXq9jPAvxpjPADGmNnGmKRe7pcGVIfD3FzgtKhz7R337+ZF4KrwOr3JwFnAq0PyLERERPpJfzEUEZHxZDsQCE+d/B/gBzjTHV8PNyY5DFzWy/2eBj5rjNkOvI0z7bLDA8B2Y8zr1tqPRh3/P+B04A3AAl+y1h4IB0IREZERYay1btcgIiIiIiIiA6AplyIiIiIiImOUAp2IiIiIiMgYpUAnIiKjRrjBSIMxJn8orxURERmvtIZOREQGzBjTEHXTh9OuPxi+fYO19qGRr0pERGTiUKATEZEhYYwpBj5lrX32GNfEWWsDI1fV2KTvk4iI9JemXIqIyLAxxnzLGPMHY8zvjDH1wLXGmNONMZuMMTXGmEpjzA+j9omLM8ZYY0xh+Pb/hs8/ZYypN8a8YoyZfqLXhs9faIzZY4ypNcb8yBjzsjHmk33U3WeN4fMLjTHPGmOOGmMOGGO+FFXT7caY94wxdcaYzcaYbGPMScYY2+0xNnY8vjHmU8aYF8OPcxT4mjFmljHmeWNMlTHmiDHmN8aYtKj7FxhjHjPGHA6f/4ExJjFc87yo67KMMU3GmIyB/5cUEZHRSoFORESG24eA3+Js3v0HIAB8AcgEVgJrgBuOcf9rgNuBScB+4Jsneq0xZgrwMLA2/Lj7gOXH+Dp91hgOVc8CTwBZwGzg7+H7rQU+HL7eD3wKaDnG40Q7A9gFTAa+AxjgW+HHOBmYEX5uGGPigA3Auzj77OUBD1trW8LP89pu35NnrLVV/axDRETGEAU6EREZbhuttU9Ya0PW2mZr7WvW2n9aawPW2r04G3effYz7P2Kt3WytbQceAhYP4NpLgG3W2sfD5+4HjvT1RY5T46VAqbX2B9baVmttnbX21fC5TwFfsda+E36+26y1R4/97YnYb639qbU2GP4+7bHWPmetbbPWHgrX3FHD6Thh88vW2sbw9S+Hzz0IXBPeSB3gY8Bv+lmDiIiMMXFuFyAiIuNeafQNY8xc4D+BU3EaqcQB/zzG/Q9Efd4EJA/g2uzoOqy11hhT1tcXOU6NeTgjY73JA947Rn3H0v37NA34Ic4IYQrOH2EPRz1OsbU2SDfW2peNMQFglTGmGsjHGc0TEZFxSCN0IiIy3Lp33/oZsBM4yVqbCtyBM71wOFUCuR03wqNXOce4/lg1lgIz+7hfX+caw4/rizo2rds13b9P38HpGrowXMMnu9VQYIyJ7aOOX+NMu/wYzlTM1j6uExGRMU6BTkRERloKUAs0hpt3HGv93FB5ElhijPlAeP3ZF3DWqg2kxvVAvjHmJmNMvDEm1RjTsR7vF8C3jDEzjWOxMWYSzsjhAZymMLHGmM8ABcepOQUnCNYaY/KA26LOvQJUAXcbY3zGGK8xZmXU+d/grOW7BifciYjIOKVAJyIiI+3fgE8A9TgjYX8Y7ge01h4ErgLuwwlCM4GtOCNgJ1SjtbYWuAC4AjgE7KFzbdu9wGPAc0Adztq7ROvsEfRp4Cs4a/dO4tjTTAHuxGncUosTIv8UVUMAZ13gPJzRuv04Aa7jfDGwA2iz1v7jOI8jIiJjmPahExGRCSc8VbEC+LC19iW36xkOxphfA3uttV93uxYRERk+aooiIiITgjFmDc5UxRZgHc7WBK8e805jlDFmBvBBYKHbtYiIyPDSlEsREZkoVgF7caY8rgEuG4/NQowx/wG8Adxtrd3vdj0iIjK8NOVSRERERERkjNIInYiIiIiIyBg16tbQZWZm2sLCQrfLEBERERERccWWLVuOWGuPtb1OxKgLdIWFhWzevNntMkRERERERFxhjCnp77WacikiIiIiIjJGKdCJiIiIiIiMUQp0IiIiIiIiY9SoW0MnIiK9a29vp6ysjJaWFrdLERkSiYmJ5Obm4vF43C5FRGTMUqATERkjysrKSElJobCwEGOM2+WIDIq1lqqqKsrKypg+fbrb5YiIjFmacikiMka0tLSQkZGhMCfjgjGGjIwMjTiLiAySAp2IyBiiMCfjiV7PIuKa7Q/D/Qvg637n4/aH3a5owDTlUkREREREJo7tD8MTN0N7s3O7ttS5DbDoSvfqGiCN0ImIyLArLCzkyJEjbpchIiICz32jM8x1aG+G5+5yp55B0gidiMg49djWcu595m0qaprJ9ntZu3oOlxXluF3WyNv+sPNLurYM0nLh/Dtc+wtsYWEhmzdvJjMz05XHH4ht27ZRUVHBRRdd5HYpIiIDEwrB4V2w7yXY96Lz+6A3fR0f5RToRETGoce2lrPu0R00twcBKK9pZt2jOwAGHOoaGxu58sorKSsrIxgMcvvtt5OSksKtt95KZmYmS5YsYe/evTz55JNUVVVx9dVXc/jwYZYvX461dsie2wkZZ9Nq3LBt2zY2b96sQCciY4e1UPUe7HsBil9yglxTeJZIeiF4kqC9sef90nJHtMyhokAnIjIGfeOJN3mroq7P81v319AWDHU51twe5EuPbOd3r+7v9T4nZ6dy5wfm9/k1n376abKzs9mwYQMAtbW1LFiwgBdffJHp06dz9dVXd9b3jW+watUq7rjjDjZs2MADDzxwIk+v/576dziwo+/zZa9BsLXrsfZmePwm2PJg7/eZthAuvKfPLzlcwba4uJg1a9awatUqNm3axCmnnMJ1113HnXfeyaFDh3jooYdYvnw5R48e5frrr2fv3r34fD4eeOABFi1axNe//nX27dtHZWUle/bs4b777mPTpk089dRT5OTk8MQTT+DxeNiyZQu33norDQ0NZGZm8j//8z9kZWVxzjnnsGLFCp5//nlqamr45S9/yYoVK7jjjjtobm5m48aNrFu3jl27dpGcnMxtt90GwIIFC3jyyScB+lW/iMiwqNnvjL7te9EJcPUVzvGUbDjpfTD9LJh+Jvjze/6xD8DjdWZwjEFaQyciMg51D3PHO94fCxcu5Nlnn+XLX/4yL730Evv27WPGjBmRPcSiA92LL77ItddeC8DFF19Menr6gB93ULqHueMd74eOYPvGG2+wc+dO1qxZww033MBTTz3Fxo0bOXz4cOTajmC7detWLr30Uvbv7z1Md3j33Xf5whe+wPbt29m9eze//e1v2bhxI9/73ve4++67AbjzzjspKipikaKqDAAAIABJREFU+/bt3H333Xz84x+P3P+9995jw4YNPP7441x77bWce+657NixA6/Xy4YNG2hvb+fzn/88jzzyCFu2bOH666/nq1/9auT+gUCAV199le9///t84xvfID4+nrvuuourrrqKbdu2cdVVVw26fhGRIVF/ALb/0fkD3Q9Oge8vhMdvhHefg/wVcMn98PnX4da34PKfQdFHnTAHzgyND/wQ0vIA43z8wA/H7MwNjdCJiIxBxxpJA1h5z98or2nucTzH7+UPN5w+oMecPXs2W7Zs4c9//jPr1q3jggsuOOb1I9KS/hgjaYDTirq2tOfxtDy4bsOAHnLhwoXcdtttfPnLX+aSSy4hJSWlR7DtGJF88cUXefTRR4H+Bdvp06ezcOFCAObPn8/555+PMYaFCxdSXFwMwMaNG/nTn/4EwHnnnUdVVRW1tbUAXHjhhXg8HhYuXEgwGGTNmjWRmouLi3n77bfZuXNn5L9dMBgkKysr8viXX345AKeeemrk8U5Ef+oXERmQpqPh6ZPhUbgje5zjiWlQeCas+FdnFG7KPOjP759FV47ZANedAp2IyDi0dvWcLmvoALyeWNaunjPgr1lRUcGkSZO49tprSU5O5qc//Sl79+6luLiYwsJC/vCHP0SuPeuss3jooYf42te+xlNPPUV1dfWgns+AnX/HkE+rGc5gm5CQEPk8JiYmcjsmJoZAIADQ67TNjseIvt7j8USOd9zfWsv8+fN55ZVXjvn4sbGxkcfrLi4ujlCoc6Q3emPw/tQvItIvLbVQ8o/ORiYHw9PrPUlQcAYUfcyZQjltEcTEuluryxToRETGoY7GJ0PZ5XLHjh2sXbs2EhZ++tOfUllZyZo1a8jMzOyyPurOO+/k6quvZsmSJZx99tnk5+cP+jkNSMdfX4ewy6Xbwbbja95+++38/e9/JzMzk9TU1H7dd86cORw+fJhXXnmF008/nfb2dvbs2cP8+X2P+KakpFBfXx+5XVhYGFkz9/rrr7Nv377BPSEREYC2Rti/yQlvxS9BxVawIYhLhLzlcN7XYPrZkF0EsR63qx1VFOhERMapy4pyhnSbgtWrV7N69eouxxoaGti9ezfWWm688UaWLl0KQEZGBn/5y18i191///1DVscJG+JpNW4H269//etcd911LFq0CJ/Px4MP9tHcpRfx8fE88sgj3HzzzdTW1hIIBPjiF794zEB37rnncs8997B48WLWrVvHFVdcwa9//WsWL17MsmXLmD179qCfk4hMQIFWp3FVxxTKss0QaoeYOMhdBmfe5kyhzF0GnkS3qx3VjGutpPuwdOlSu3nzZrfLEBEZdXbt2sW8efPcLqOL+++/nwcffJC2tjaKior4+c9/js/nc7usEdfQ0EBycnIk2M6aNYtbbrnF7bLGhNH4uhaRYRBsd0bdOgJc6T8h0AImBrIWd3ahzDsNEpLdrtZ1xpgt1tql/blWI3QiIjJgt9xyi4IL8POf/7xLsL3hhhvcLklExF2hoLOtTMcUypJ/QFuDc27qAlh6vRPi8k8Hr9/dWsc4BToREZFBOpFgW1VVxfnnn9/j+HPPPUdGRsZQlyYiMjKshcO7O0fgijdCS41zLnM2LLrKCXCFqyAp091axxkFOhGRMcRaOzLbAciwycjIYNu2bW6XMSqMtmUfInICrIWje6MC3EvQGN6H018A8z4QDnBnQmrWsb+WDMqgAp0xZg3wAyAW+IW19p5u5z8J3AuUhw/92Fr7i8E8pojIRJWYmEhVVRUZGRkKdTLmWWupqqoiMVHNDkTGjJrSrnvB1YXf4qdkwczzOgNceoG7dU4wAw50xphY4CfABUAZ8JoxZr219q1ul/7BWnvTIGoUEREgNzeXsrIyDh8+7HYpIkMiMTGR3Nxct8sQkb7UH+wa4KrD25T4MpzgNv3fnK0EMmb2bzNvGRaDGaFbDrxrrd0LYIz5PfBBoHugExGRIeDxeJg+fbrbZYiIyHjVdNRZ+9YxhfLwbud4QhoUroQVNzijcJPnQUyMu7VKxGACXQ5QGnW7DFjRy3VXGGPOAvYAt1hrS7tfYIz5DPAZwL3NZ0VEREREJpKWOtj/SngE7gU4sBOw4EmCgtPhlKudAJd1CsTEul2t9GEwga63cdXuq5ufAH5nrW01xnwWeBA4r8edrH0AeACcfegGUZOIiIiIiPSmrQlKN8G+8DTKiq1ggxCbAHnL4dyvOnvBZS+BuHi3q5V+GkygKwPyom7nAhXRF1hrq6Ju/hz4ziAeT0RERERE+ivQCmWbO9fBlb4KoXaIiYOcU+HMW50RuNzl4FGDorFqMIHuNWCWMWY6ThfLjwDXRF9gjMmy1laGb14K7BrE44mIiIiISF+CAajc5kyf3PcS7N8EgWbAQPZiOO1fnSYm+adBQrLb1coQGXCgs9YGjDE3Ac/gbFvwK2vtm8aYu4DN1tr1wM3GmEuBAHAU+OQQ1CwiIiIiIqEQHNzZ2YWy5B/QVu+cmzIfTv2kM4Wy4AzwprtaqgwfM9o29Vy6dKndvHmz22WIiIiIiIwu1sLht8NTKF9wOlI2VzvnMk5ypk927AWXlOlurTIoxpgt1tql/bl2UBuLi4iIiIjIMLHW2ftt34udjUwaDznn0vJhzsXhEHcmpGa7W6u4RoFORERERGS0qC3rDG/FL0FteMev5Gkw4xwnvE0/C9ILXSxSRhMFOhERERERtzQc6uxCue9FOLrXOe6d5IS3VV+EwrMgcxaY3nYNk4lOgU5EREREZKQ0V0Pxy50B7nC4CXxCKhSshGWfdoLclPkQE+NurTImKNCJiIiIiAyX1nooeQWKwwGucjtgweNztg845SpnCuW0UyBWb83lxOlVIyIiIiIyVNqbofSfnY1MyreADUJsPOStgHPWOQEu51SIi3e7WhkHFOhERERERAYq0OaEto4plGWvQrANTKwT2lbd4kyhzFsBHq/b1co4pEAnIiIiItJfwQBUvtE5hXL/JmhvAgxkLYIVN8D0s53plAkpblcrE4ACnYiIiIhIX0IhOPRm5xTKkpehtc45N+VkKPpYeDPvleBNd7dWmZAU6EREREREOlgLR96BfS+E94LbCM1HnXOTZsKCK5wplIVnQvIUd2sVQYFORERERCa66uLONXD7XoSGg87xtDyYc2F4BO5MSMtxtUyR3ijQiYiIiMjEUlfhTJ/sCHC1+53jyVOd4Db9LOdfeqE285ZRT4FORERERMa3hsNQ/JLzb9+LUPWuc9ybDoWrYOXNToDLnK0AJ2OOAp2IiIiIjC/NNU7zko5GJofedI7HpzjNS069zglwUxdATIy7tYoMkgKdiIiIiIxtrQ3O9gEdjUwObAcbgjivs33Awg87AS5rMcTq7a+ML3pFi4iIiMjos/1heO4uqC2DtFw4/w5YdKVzrr0ZSl/tnEJZvgVCAYiNh9xlcPaXnQCXcyrEJbj7PESGmQKdiIiIiIwu2x+GJ252ghtAbSk8fhPsetLZQqD0VQi2gomFnCVwRngNXN4KiPe5W7vICFOgExEREZGRFQw4m3O31kFrPbSEP3Yce+6uzjAXuU8r7Hocpi2C5Z92Alz+6ZCY6s5zEBklFOhEREREpH9CIWhv7BnAutyODmi1vQS2emhvGmABBj770pA+JZGxToFOREREZLyzFgKtUYGr9sQCWPRt7HEezEBCCiSkOh8TU8E3ydnTreN2QmrX85HrU53bD5wLdWU9v3Ra7jB8c0TGNgU6ERERkdEsMj3xRANYtymNofbjP1act1vASoHkKccPYNHXxycPfiuA993ZdQ0dgMfrNEYRkS4U6ERERESGg7XQ1jDwANZxvj/TE2PiugWuVEjNgYS5PQNXYlrPEbSOz2M9w/996Y+ObpZ9dbkUkQgFOhEREZHu2lv6sUasr6YeUef7PT0xKmB508Gff5wAlgIJaZ234xLBmJH4zoycRVcqwIn0gwKdiIiIjB/BALSd4AhYb2vKgm3Hf6w4b88piEkz+hfAOs4PxfREEZnQFOhERERkYI618fOJshbaGvsZwI7RVbG98fiPZWK7NuZITIXU7P6vEUtMc4JYXPzAnquIuO6xreXc+8zbVNQ0k+33snb1HC4rynG7rAFRoBMREZET19vGz+s/D9XFkH/aCbS1jwptNnT8x43vFrgS/eHpiccKYN26Knq84296ooj022Nby1n36A6a24MAlNc0s+7RHQBjMtQp0ImIiEjvQiFoPAx15VBfCXUVzr/6Stj5qLPRc7RACzz/7d6/Vq/TEzN7Tk88Vlv7+BRNTxSRExYKWepbAlQ3tVHd1MY3n3wrEuY6NLcHufeZtxXoREREZIxob4H6CqirDIe18vDn4dBWVwkNByAU6Hq/mDhIyeoZ5iIMfPJJTU8UkSFnraWlPRQJZjVN7dQ0tYc/b6M6/Hlt5Fj4dnM7oeP1JwIqapqPf9EopEAnIiIynlgLzdXhkFbZ++haXQU0H+153/gUSM1yAtv0szo/T80Jf54NSZOdUbL7FzjTLLtLy4XCVcP/PEVkTGsPhqhtbu8MYo3hgNbs3K5paqO60bndEcyqm9ppC/Q9NdsXH0u6L540r4f0JA9Zfi/pPk/nMV886UkevvzIDg439PyjVLbfO5xPedgo0ImIiIwVwQA0HAwHs4qeI2odxwLd/8psnCCWmu2sN8tb4QS01JxwYMt2Piam9r+W8+/Qxs8igrWWupYANVEjYtEfu4ycNYePN7ZT3xro82vGxRj8vnjSfR78Pg95k3wsyk0j3ReP3xeP3+cJn4sPH3OuS4iL7VfNX7040GUNHYDXE8va1XMG/f1wgwKdiIjIaNDa0Dl61tuIWl0FNB7q2TgkNj4cyLIhuwjmXNR1RC01G1KmDf2G0dr4WWTcaWkPOiNh3UbGooNZ9EdnRK2d4DHmM6YmxpGeFB8JXzMyk3oEsfRut5MT4jDD2LioY53ceOlyaaztx4TSEbR06VK7efNmt8sQEREZGqEQNFV1jp5FpkB2G11rre1530R/5+hZanYvn2eDb5I6NopIF4HwdMbo4NVl5Ky5c0pj9MhZS3vf0xkTPTGREbKOkbOOzyMjZ+Gpjh2BLTUxjrhYNTIaCGPMFmvt0v5cqxE6ERGRgQq0OeGsS1OR6NG1Cqg/0HOTahMDydOcUbTMWTD97K4jah3BLd7nzvMSkVHBWktDa6DLGrL+TG2sb+l7OmNsjMHv7RwZy033sSCn6xTGdJ+HtG4jZ4me/k1nlJGnQCciItKdtc7eaN1H1KIbjNRXOi39u/P4OkfR8k/vOaKWmgVJUyBWv4JFJpKW9mBkJKy6MWrqYsfUxkbndm1z1+AWOMZ0xpTEuEgw8/viKcxMCoe18MhZUtTImS8ef5KHlGGezigjT79NRERkYgkFO/dWO1bL/vbGnvf1ZXQGs5wlUU1FokbXEtM0BVJkHAuGbJfujN3XlPU1ctZ937NoCXExXdaQzZqS3Gvzj+ipjmleDx5NZxQU6EREZDxpb45qJNJHy/76A2C7vbGKiescPZu6AGatjmrZHzUFMi7BneclMgE9trV8WJtWWGtpbAv2u11+bfhjXUs7fbWgiDFEgpjf6yErLZF5Wand1pzFR0Jax+iaN17TGWXgFOhERGT069hbLRLWehlRq69wrukuIbVzFG3yOZ2fR7fs92U6e6uJyKjw2NbyLm3ly2uaWffoDoBeQ11bINRlDVn3rozdR846pja2B/uezpicED2d0UP+JF9nEOvW/CPd58HvjSclMY6YGI3Qy8hSoBMREXcF2zv3VuurZX99JQRaut3RQPIUJ5SlF0LB6T03wU7NgoQUN56ViAzCd5/e3WOKYnN7kK/+3w6e3XWwR0Braut7OmN8bEyXYDZjclKXbo3pvvioBiCd0xnj4/RHHhkbFOhERGT4tDZ03QS7t5b9DYeAbn8lj03oHEXLObXniFpqNiRPHfq91URk2IVCliMNrVTUtlBR00xFTTPl4Y8VNc6xqsa2Xu/b2BbkzYo6/D4PU1MTmTM1pbONflLnSJk/3BAk3efB64lVExAZ1xToRETkxIVC0HSklymQ3UbXWut63jfR3zmKNnVBz02wU7PBm67GIiJjVGNrIBLSKsOhLTqwVdY295jq6IuPJcfvJcvvZUFOKk9ur+y19X6O38vzt50zQs9EZGxQoBMRGc+2PwzP3QW1ZZCWC+ffAYuuPPZ9Aq29NBXpPrpWCaH2rvczsZAyzRlFmzwbZp7bs6mI9lYTGdMCwRCH6lujQpoT0JzbTnirbe76syHGwLTURLL9Xhbn+blw4TRy/F6y07xk+73k+L2keru20l8xPaPLGjoAryeWtavnjNhzFRkrBhXojDFrgB8AscAvrLX39HHdh4E/AsustZsH85giItJP2x+GJ252Oj8C1JbC+pudYDZtYR8t+yudkbfuPEmdXR8Lzug2ohb+PHkKxKhTm8hYZa2lriUQmQYZHdKc0NbCgboWgt32RUtNjIsEs6UF6WT7vWT7E8MfvUxNSSDuBNvrdzQ+Gc4ulyLjhbF99V093h2NiQX2ABcAZcBrwNXW2re6XZcCbADigZuOF+iWLl1qN29W5hMRGZRgO9x3MjQeOv61vsyuo2i9fZ6QqimQImNcWyDEwbqWqOmPnYGtIjw9sqG16zRHT6xhWloi2WlOYMuO/EuMTJFMTtCEL5GhZozZYq1d2p9rB/N/4HLgXWvt3vCD/h74IPBWt+u+CXwXuG0QjyUiIscSaIXy16FkIxS/DKWv9r4xdofrng6HtmnaW01kHLDWcrSxjYqalvDatc41ax0B7nBDa4/90zKS4sn2e5kxOYmVJ2VGhTYnsGUmJ6gNv8goN5hAlwOURt0uA1ZEX2CMKQLyrLVPGmP6DHTGmM8AnwHIz88fREkiIhNEewuUvQYlL0PxRufzjrb+U+ZD0Udh55+gqarnfdPynBb/IjJmtLQHu3SBLI+aBtlxuzUQ6nKfhLiYSEA7Z85kJ6ilebtMiUz0aJq0yFg3mEDX259rIn/3McbEAPcDnzzeF7LWPgA8AM6Uy0HUJCIyPrU1QdmrzuhbyctQthmCrYCBaQtg6fVQsNJZ3+ab5Nwnd1nXNXQAHq/TGEVERo2ONv7l3QJbRVSXyO5t/I2ByckJZPu9zMtK5fx5UzqnQ6Y5gW1SUrza9YtMAIMJdGVAXtTtXKAi6nYKsAD4e/iHyTRgvTHmUjVGERE5jtYGKN3UGeDKX3e6SpoYyDoFln8aCldB/mlOi//edHSzPNEulyIypBpaA1RGdYXssvdabTMHalt6tPFPio8lJ91LVpqXBTlp5EQ1Gcnxe5mamqiNr0UEGFxTlDicpijnA+U4TVGusda+2cf1fwduU1MUEZFetNTB/k2da+AqtoINOlsB5CxxRt8KV0HeCkhMdbtaEQkLBEMcDLfxr+gtsNU0U9dtP7XYGBNu4++EtKw0b5fAlu33kpoYp9E1kQlsRJqiWGsDxpibgGdwti34lbX2TWPMXcBma+36gX5tEZFxr7kaSl7pXAN3YDvYEMR4IOdUWPVFJ8TlrYCEZLerFZmQrLXUNQc6u0LWdg1sFTXNHKhroVsXf9K8HrL9XnLTvSyfPilqKqQT2qYMoI2/iEhfBjxCN1w0Qici41LT0XB4Cwe4gzsBC7EJzlq3wpVOgMtdpo23RUZIWyDEgdqubfy7h7bGtmCX+8THxpDlTyQrHM6iW/nn+BPJSvOSpDb+IjJII7VtgYiI9KXhcOf0yZKX4VB4R5c4L+Qtg3PWOSEuZyl4Et2tVWQc6t7GPzqwlde0UNlHG//MZKeN/8zJyayaldlj77XMJLXxF5HRRYFORGQo1B9wRt6KNzoB7sge57gnCfJXwIIrnDVw2UsgLt7dWkXGgea2IBW1zVR26woZPcLWvY1/oicmMqo2d47TFTIrvN+as5YtUW38RWTMUaATERmI2rLw6Ft4FO7oe87x+BSn8+Tia6BgFWQvhliPu7WKjDGhkOVwpI2/E9q6B7ajvbTxn5LitPE/OTuVC06eGlmz1vEv3edRoxERGXcU6ERE+qO6pLOBSfFGqClxjiemQf4ZsPQ6Zw3ctEUQqx+tMjE8trWce595m4qaZrL9XtaunsNlRTnHvV9Da6DrqFp0aOujjX9yQhw54RG1Rbn+8KhaYmSjbLXxF5GJSu86RES6sxaO7u1sYlLyMtSWOue86U5wW/FZZw3c1AUQoylaMvE8trWcdY/uoLndaRpSXtPMukd3EAqFWDEzs0fr/uhGI3218c/xezk1P52sqCYjnW38NdItItIbBToREWuh6l0ofqkzwNVXOud8mU5wO+Nm5+PkeRCjUQCR7zy9OxLmOjS3B7n1j9t7XOv3echO85Kb7mNFdBt/f0cb/0Ri1WhERGRAFOhEZOKxFg7v7mxgUvwyNB5yziVPDW/ivRIKz4TM2c7iHJEJLBiyvHOonq37a9i6v5rX99dQWdvS5/X3XL6wS2jzxevthojIcNFPWBEZ/0IhOPRmZxOTkn9AU5VzLjUHZpwT3gduFWTMVICTCe9oYxvbSqt5vaSGraXVvFFaS0OrM00y3eehKD+dQ3UtPaZOAuT4vXxkef5IlywiMmEp0InI+BMKwoEdnaNv+/8BzdXOubR8mLW6cyPv9EIFOJnQ2oMh3j5QHxl527q/muKqJsBZ2zYvK4UPFeVQlO9nSX46BRk+jDE91tABeD2xrF09x62nIiIyISnQicjYFwxA5RudWwjs3wSttc659Okw92Jn9K1wJfg1ciAT26G6Fie4lVaztaSG7eU1tLQ7+7VNTklgSb6fjyzPpyjPz8LctD6nS3Z0sxxIl0sRERk6CnQiMvYE26Fia+cauP2boK3BOZdxEiz4kBPgCs6ANL25lImrNRDkrYq6yMjb1v01lNc0A+CJNczPTuPq5fksyU+nKN/ZCuBE9mm7rChHAU5ExGUKdCIy+gVaoXxL5xq40leh3ZkSxuS5sOiqzimUKdPcrVXEJdZaKmpbnKmT4bVvb5bX0RZ0Rt9y/F4W5/u5bmUhSwrSOTkrlUSPttwQERnrFOhEZPRpb4ayzZ0beZe9BoFwR70p86HoY50BLinT3VpFXNLcFmRHeW1k5O31/dUcqm8FICEuhkW5aVy3spCifD9F+elMTU10uWIRERkOCnQi4r62RmfUraOJSflmCLYBBqYthKXXO+Gt4AzwTXK7WpERZ61l/9EmXg+Ht637a9hVWUcgZAEoyPBxxswMlhSkU5SXztysFDyx2i9RRGQiUKATkZHX2gClmzo38S7fAqEAmBjIWgwrbnDWwOWfBl6/29WKjLiG1gDbS2vYWlrD6yXVbC2t4WhjGwBJ8bGckufnhrNnUJTnrH3LSE5wuWIREXGLAp2IDL+WWqdxSUcTk4ptYIMQEwfZRXD6TVC4CvJWQGKq29WKjKhQyLL3SEO4cYnTvGTPwXrCg2/MnJzE+XOnUBRuXDJ7agqxMdpqQ0REHAp0IjL0mquh5JVwgNvo7AlnQxDjgdylsOoWZw1c7nJISHa7WpERVdvUzrayzpG3bfurIxt0pybGsTg/nTULplGUn87iXD9pPo/LFYuIyGimQCcig9dY5Yy8dayBO7gTsBCbALnL4Ky1zhq43GUQ73O7WpEREwxZ9hysjzQt2bq/mvcONwIQY2D21BQuXpQd2bR7RmYSMRp9ExGRE6BAJyInruFQZwfK4pfh8C7neJwX8pbDuV9xAlzOqeBRZz2ZOKoaWp1pk6XO1gHby2pobAsCMCkpniX5fi5fkktRnp9FeX6SE/RrWEREBke/SUTk+OoqOwNcyctwZI9z3JME+Stg4YedNXDZSyAu3t1aRUZIezDE7sr6yMjb1tIaSqqc/RHjYgzzslK54tTcyKbd+ZN8J7Rpt4iISH8o0IlITzWlXQPc0b3O8YRUp/Pk4o86AS7rFIjV+h6ZGA7WhTftDjcu2V5WS2vA2bR7SkoCS/LTuWZ5PksK0lmQnYY3Xpt2i4jI8FOgE5norIWaks4tBIo3OrcBEtMg/wxnH7jCVTB1IcTqx4aMf62BIDvL6yIjb1tLqqmodTa3j4+NYUFOKteeVhDZtDs7LVGjbyIi4gq9MxOZaKx1Rtw6Rt+KX4a6Muecd5Kzefdp/+qsgZs6H2I0yiDjm7WW8prmyMjb1v01vFVRR1vQGX3L8XtZUpDOp8JTJ0/OTiUhTv9fiIjI6KBAJzLeWQtH3nG2D+gYhauvdM75Mp3tAwq/6AS4yXMhJsbdekWGWVNbgB1ltZ0BrrSGw/WtACR6YliU6+e6VYXO2rc8P1NS1dhHRERGLwU6kfEmFILDu6PWwP0DGg8555KnOQGuYKUzhTJzNmiamIxj1lqKq5oiI2+v769m94F6guFdu6dnJnHmSZmRqZNzpqXgidUfNUREZOxQoBMZ60IhOPRmePQtHOCaqpxzqTkw89zOADdphgKcjGv1Le28UVrbufZtfzXVTe0AJCfEcUpeGp87ZyZF+X4W56UzKUldWUVEZGxToBMZa0JBOLC9c/pkyT+gpcY558+HWas7R+HSCxXgZNwKhSzvHW6I2rS7hj2H6rHO4BuzpiRzwclTKcpPZ0l+OidNSSZWm3aLiMg4o0An4rbtD8Nzd0FtGaTlwvl3wKIrO88HA1D5RucauP2vQGudc27SDJj3AWf0rWAl+PPceQ4iI6CmqS086uaMvG0rraG+JQBAmtdDUb6fixZmUZTv55Q8P2lebakhIiLjnwKdiJu2PwxP3Aztzc7t2lLndtW7EJfgBLjSf0Jbg3M+YxYsuBwKVjmjcKnZ7tUuMowCwRB7DjZERt62llaz93AjADEG5kxL5dJTsikKd56cnpFEjEbfRERkAlKgE3HTc3d1hrkO7c3wwneczyfPhVM+4oy+FayElKkjX6PICDjS0Bo1ddLZtLupLQhARlL94oK9AAAgAElEQVQ8RfnpXLEklyX56SzKTSMpQb++REREQIFOxF21ZX2fW/seJGWOXC0iI6QtEGJXZeem3a/vr6b0qPOHjbgYw/zsVK5cmud0nsxLJ2+SV5t2i4iI9EGBTsQtu550GpZ0dHCIlpanMCfjxoHalsjI29b9Newor6U14GzaPTU1gSX56Xz8tEKK8v0syEkj0aNNu0VERPpLgU5kpDVWwVNrYeefIDUXmg5DoLXzvMfrNEYRGYNa2oO8WVHbpfNkZW0LAPFxMSzMSeNjpxWwpMBZ+5aV5nW5YhERkbFNgU5kJL35f7DhNmiphXO/CqtucY4dq8ulyChlraWsurmzccn+at6qrKM96Iw6503ysqxwUmTT7pOzUomP06bdIiIiQ0mBTmQkNByCDf8Gu9ZDdhF8cD1Mne+cW3SlApyMCU1tAWfT7tKOAFfDkQZndNnriWVRbhqfOnMGRXl+Fuf7mZKS6HLFIiIi458CnchwshZ2/BGe+hK0NcH7vg6nfx5i9b+ejG7WWvYdaewydfLtg/UEQ87o24zMJM6anRnetNvPnKkpxMVq9E1ERGSk6V2lyHCpq4Qnb4E9T0HuMvjgf8Hk2W5XJdKrupZ23ojatHtraQ01Te0ApCTEsTjfz43zZlKUn87iPD/pSfEuVywiIiKgQCcy9KyFbQ/B01+BYBusvhtWfBZi1LlPRt5jW8u595m3qahpJtvvZe3qOVx6SjbvHGqIdJ3cWlrNO4casNZpvDprSjJr5k+LrH2bOTmZWG3aLSIiMioZ21vLdBctXbrUbt682e0yRAamtgye+AK8+yzknwEf/DFkzHS7KpmgHttazrpHt9PcHoocizHgiTG0hhuX+H0eivL84amT6SzKSyM10eNWySIiIgIYY7ZYa5f251qN0IkMBWthy//AX24HG4IL74Vln4IYrSmS4RcKWQ7Wt1B8pIn9RxsprmqipKqRv7x5kECo6x/tQhbiYmO4+/IFLClIpzDDp027RURExjAFOpHBqi6B9Z+HfS/A9LPg0h9BeqHbVck4EwiGqKxtobgqHNiONFJy1AluJVVNkY26ATyxhrx0X48w16GpLcgVp+aOVOkiIiIyjBToRAYqFILNv4S/3gkmBi65H069zlmEJDIAbYEQZdVNlFQ1URwOasVVjeyvaqK0uimyvxtAQlwMhRlJFGQkcfbsyRRkJIVv+8j2e4mNMay852+U1zT3eJxsvzbzFhERGS8GFeiMMWuAHwCxwC+stfd0O/9Z4EYgCDQAn7HWvjWYxxQZFareg/U3Q8lGmHkefOCH4M9zuyoZA5rbguyPGlmLDm4VNc1ED6olJ8RRkOFjXlYqqxdMozDDFwluU1ISiDlOo5K1q+ew7tEdNLcHI8e8nljWrp4zXE9PRERERtiAA50xJhb4CXABUAa8ZoxZ3y2w/dZa+9/h6y8F7gPWDKJeEXeFgvDPn8Fzd0FsPFz6Yyi6VqNy0kV9SzslVc5IW8nRRkqOdAa3A3UtXa71+zwUZCRxakE6ly/JpWCSj8JMJ7hlJMUPan3bZUU5AD26XHYcFxERkbFvMCN0y4F3rbV7AYwxvwc+CEQCnbW2Lur6JGB0tdQUORFH3oHHb4TSf8Ks1fCB70NqtttViUtqmtoizUeKj4RH3MIjb0ca2rpcm5mcQGGGj5UnZTqjbJlJzsdJSaT5hrej5GVFOQpwIiIi49hgAl0OUBp1uwxY0f0iY8yNwK1APHBeb1/IGPMZ4DMA+fn5gyhJZBgEA/DKj+H5u8HjhQ89AIuu1KjcOGet5XBDK/urmjqDWyTANVLXEuhyfXZaIgUZSbxv3tTwtEhnlC0/w0dygpYri4iIyPAYzLuM3t7N9hiBs9b+BPiJMeYa4GvAJ3q55gHgAXD2oRtETSJD69AueOxzUPE6zL0ELr4PUqa6XZUMkVDIcqCuJdJ4pHtwa2rrXHsWYyA33UdBho8PLs6hILKezUfeJB+JHm0cLyIiIiNvMIGuDIjuApELVBzj+t8DPx3E44mMnGA7vPx9eOG7kJACH/4VzL9co3JjUCAYoqKmJbyGrSOsdU6RbOve7n+Sj8KMJE6bMYnC8AhbYUYSOX4v8XHaV1BERERGl8EEuteAWcaY6UA58BHgmugLjDGzrLXvhG9eDLyDyGh3YIczKndgO8z/EFz0PUjKdLsqOYbWQJCy6uYu69k6RtnKqpu77MeW6ImhYFIS0zOTOHfuFArCga0gw0dWmtPuX0RERGSsGHCgs9YGjDE3Ac/gbFvwK2vtm8aYu4DN1tr1wE3GmPcB7UA1vUy3FBk1Am3w0n/CS98Dbzpc+Rs4+VK3q5Kw5rag0zGyx3q2Jipqm7Hd2v0XZvqYn53GRQuzIoGtMNNp9z+YzpEiIiIio4mxdnQtWVu6dKndvHmz22XIRFOxFR6/CQ7uhIVXwoXfAd8kt6uacDra/Xe0+I8ObgfrWrtcmx5u91+Y4SM/qglJYYaPSYNs9y8iIiLiJmPMFmvt0v5cq9ZrMrG1t8AL34GXfwDJU+Dq38OcC92uatyy1lLT1N5lM+3IeraqJqoau7b7n5zitPs/c9bkrsFtBNr9i4iIiIwFCnQycZVtdtbKHXkbFl8Lq78NXr/bVY151loO17dScrSJ4iNdg1txVSP1Ue3+jYGsVKfd//vnd2v3P8lHktr9i4iIiByT3i3JxNPeDH/7Fmz6L0jJho/+CWa9z+2qxpRQyFJZ10LJkfCUyKONlBxxAtv+o01d2v3Hxhhy073kT/JxWV5OpAlJYaaP3HS1+xcREREZDAU6mVhKXoHHb4Sj78Gp18EFd0FiqttVjUqBYIjymuYuzUf2H3UC3P5u7f7jY2PIm+SlMCOJ02dmdDYhyUgiJ92LJ1bt/kVERESGgwKdTAxtjfDcXfDPn4E/Dz7+OMw4x+2qXNcaCFJ6tLlr18jwx/Je2v0XZiQxc3IS58+dQkE4tKndv4iIiIh7FOhk/Nv3Eqy/CaqLYfln4Pw7ISHZ7apGTFNbINx4pGtgK6nq2e4/JSGOgkwfC3LSuGRRVnhNmxPc1O5fREREZPRRoJPxq7Ue/nonbP4lpE+HT/4ZCle6XdWwqGtpj6xhK4l0jnRuH6rv2u5/UlI8BRk+lhWmU5CRS2GmLxLc0n0ehTYRERGRMUSBTsan9/4G678AtaVw2o1w3tcg3ud2Vb16bGs59z7zNhU1zWT7vaxdPYfLinK6XGOtpTrS7t9Zz1ZS1UjJUSe4He3W7n9KSgKFGUmcPXtyeFqkE9jyM3ykedXuX0RERGS8UKCT8aWlFv7yNXj915AxC65/BvJXuF1Vnx7bWs66R3fQ3O50hSyvaeZLf9rOpn1VZCTFd06PPNJEfWvXdv/ZaV4KMnysnj8t3Opf7f5FREREJhq965PxY89f4IkvQMMBWPkFOGcdeLxuV3VM9z7zdiTMdWgLhPj9q6WRdv8FGUksyU+P2qNN7f5FRERExKFAJ2NfczU8vQ7e+B1Mngcf+V/IOdXtqo5rz8F6ymuaez1ngN3fXKN2/yIiIiJyTAp0Mrbt3gBP3gKNR+Cstc6/uAS3qzqmqoZW7n92D797tRQD2F6uyfZr7zYREREROT4FOhmbGqvgqS/Bzkdg6kL46B8h6xS3qzqm1kCQB/9RzI/+9i5NbUE+uiKf2VNT+PaGXV2mXXo9saxdPcfFSkVERERkrFCgk7Hnzcfgz7dBcw2c8xVYdQvExbtdVZ+stTzz5gH+46ndlFQ1cc6cyXz1onnMmpoCQHJC3HG7XIqIiIiI9EaBTsaOhsPw53+Dtx6HrMXw8cdh6ny3qzqmneW1fPPJt/jnvqPMmpLMg9cv5+zZk7tcc1lRjgKciIiIiAyIAp2MftbCjkecKZZtDXD+HXDGFyB29L58D9a1cO8zb/On18tI98XzzcsWcPWyPOK0Lk5EREREhtDofUcsAlB/wGl68vafIWcpfPAnMGWu21X1qbktyM9f2st/v/Ae7cEQnz5zBjeee5I28xYRERGRYaFAJ6OTtc42BE//OwRa4f3fgtM+BzGjc++1UMiy/o0KvvP0biprW1gzfxrrLppLQUaS26WJiIiIyDimQCejT225s0H4u3+F/NPh0h9D5kluV9WnLSVHuevJXbxRWsOCnFTuv2oxp83IcLssEREREZkAFOhk9LAWXn8Q/nI7hAJw4Xdh2achZnSuOyurbuKep3bz5PZKpqQkcO+HF3HFklxiYozbpYmIiIjIBKFAJ6NDdQk8cTPs/TsUngmX/ggmTXe7ql41tAb4r+ff5Rcb9xFj4ObzTuKGs2eSlKD/nURERERkZOkdqLgrFILNv4Rnv+7cvvg+OPW6UTkqFwxZ/ri5lO/9ZQ9HGlq5bHE2X1ozl2y/1+3SRERERGSCUqAT9xzdC+tvhuKXYMa5cOkPwZ/vdlW9+se7R/jmhl3sqqzj1IJ0fvGJpSzO87tdloiIiIhMcAp0MvJCIXj1Z/DcXRAT50yvLPoYmNG39mzv4Qbu/vNunt11kBy/lx9dXcQli7Iwo7BWEREREZl4FOhkZB15Fx6/EUo3waz3wyXfh7Qct6vqobapnR889w6/fqWYhLgY1q6ew7+smk6iZ3RumyAiIiIiE5MCnYyMUBBe+Qk8/22IS4DL/htO+cioG5VrD4Z4aFMJ33/uHWqb27lqaR63vn82U1IS3S5NRERERKQHBToZfod2w+Ofg/ItMOdiuOQ+SJnmdlVdWGt5/u1DfHvDLt473MgZMzP42sUnc3J2qtuliYiIiIj0SYFOhk8wAC9/H174DsQnwxW/hAVXjLpRubcP1POtDW/x0jtHmJ6ZxM8/vpT3zZuidXIiIiIiMuop0MnwOLDTGZWrfANOvgwu+h4kT3a7qi6ONLRy31/38PtX95OcEMftl5zMx04rID5u9G2ZICIiIiLSGwU6GVqBNth4H7z4PfD64cpfw8kfdLuqLloDQf6/l4v5yd/epak9yMdPL+QL588iPSne7dJERERERE6IAp0MnYptTgfLgzth4f+DNd+BpAy3q4qw1vLUzgP8x1O7KD3azHlzp/CVi+Zx0pRkt0sTERERERkQBToZvECrs05u4/chaTJ85Hcw9yK3q+pie1kN33pyF68WH2XO1BR+8y/LOXPW6JoCKiIiIiJyohToZHDKtjhr5Q7vhlOugTV3gzfd7aoiDtS28N1ndvPo6+VkJMXz7Q8t4KqlecTFap2ciIiIiIx9CnQyMO3N8Pzd8MqPISULPvoIzLrA7aoimtoCPPDiXn72wl6CIctnz57J586dSWqix+3SRERERESGjAKdnLj9/3RG5arehSWfgPd/ExLT3K4KgFDI8ti2cr779NscqGvh4oVZ/PuFc8mb5HO7NBERERGRIadAJ/3X1gh/+xZs+imk5cHHHoOZ57pdVcRrxUf55pNvsb2slkW5afzomiKWFU5yuywRERERkWGjQCf9U7wRHr8JqvfBsk/D++6EhBS3qwKg9GgT9zy1mw07KpmWmsh9V57CZYtziInRxuAiIiIiMr4p0MmxtTbAs3fCa7+A9OnwyQ1QuMrtqgCob2nnJ8+/x6827iM2xvDF983iM2fNwBevl7WIiIiITAx65yt9e+95WH8z1JbCaZ+D874G8UluV0UwZPnDa6Xc99e3OdLQxuVLcvjS6rlMS0t0uzQRERERkRGlQCc9tdTCX26H1x+EjJPg+qch/zS3qwJg4ztH+NaGt9h9oJ5lhen86pPLWJTrd7ssERERERFXKNBJV+88C0/cDPWVcMbNcO5XwON1uyreO9zA3Rt28dzuQ+RN8vJfH13ChQumYYzWyYmIiIjIxKVAJ47manjmq7DtIZg8F678NeQudbsqapra+P6z7/C/m0pI9MTy7xfO5ZNnFJLoiXW7NBERERER1w0q0Blj1gA/AGKBX1hr7+l2/lbgU0AAOAxcb60tGcxjyjB4+yl44ovQeBjO/Dc4+8sQl+BqSe3BEL95pYQfPPcO9S3tfGR5PrdeMJvMZHfrEhEREREZTQYc6IwxscBPgAuAMuA1Y8x6a+1bUZdtBZZaa5uMMf8KfBe4ajAFyxBqOgpPfQl2/BGmLoBr/gDZi10tyVrLc7sOcfefd7H3SCNnzsrkqxfPY+60VFfrEhEREREZjQYzQrcceNdauxfAGPP7/5+9O4+vqyr3P/55Ms9zOmVsS1ugAx1CK4KATC2DgKIoCiiiOICoXLjKVZlE5YoXUHEqXq7wuyAiYC0UKLNcBIRUaqEtLW1J27SlTTM283DW74+9k5ykSZNmOjnJ9/169ZWz99k5+zlwoPlmrfUs4DygI9A5514Muv514OJB3E+G0oa/wqp/86Zannw9nHANRMWEtKSNe2q4ddUG/r6lnGnZidz7hSI+OmuC1smJiIiIiPRiMIEuB9gZdFwKLDnE9ZcDT/X0hJldAVwBkJ+fP4iSpE+1ZfDktbBhBUw+Bi5ZAZPmhLSksgNN3PHsJv705k5S4qO56WNH87kPFRAdGRHSukRERERERrvBBLqehk1cjxeaXQwUASf19LxzbjmwHKCoqKjH15BBcg7eeRSevA6aa+GUH8Dx34TI6JCV1NjSxr1/f59fv7iVxpY2vvDhqVx96hGkJYR2pFBEREREJFwMJtCVAnlBx7nA7u4XmdlpwPeAk5xzTYO4nwzUgQ/giWtg0yrIWQTn/QomHBWycpxzrHp7D7c99S6llQ2cdtRE/uOsI5mWnRSymkREREREwtFgAt2bwAwzmwrsAj4DfDb4AjNbAPwOWOac2zeIe8lAOAf/egie/i60NMDpt8CHroTI0O1W8a+dVfzwiQ0Ub6/kyEnJPPClJRx/RFbI6hERERERCWcD/sneOddqZlcBq/G2LbjXObfezG4Bip1zK4HbgSTgz35jix3OuXOHoG7pS/UueOJb8N4zkLfEG5XLmhGycvZUN/DTpzfxl7d2kZUUy22fmMunivKIjFDDExERERGRgRrUUI1z7kngyW7nbgh6fNpgXl8GwDl46/95m4S3tcCy22DxFRARmo2465tb+e3ftrH85a0EHHz95Ol8/aNHkBSrPe1FRERERAZLP1WPJVU74PFvwtYXoOAEOO+XkDEtJKUEAo7H3trF7avfZW9NE+fMm8x3lh1JXkZCSOoRERERERmLFOjGgkAA1twLz97ojdCd9TMouhwiQtP2/433K/jhExt4e1c1x+Sl8evPLWRRQUZIahERERERGcsU6MJdxfuw8htQ8n8w7WT42C8gvSAkpewor+cnT23kqXc+YHJqHHd9ej7nHjOFCK2TExEREREZFgp04SoQgDeWw/M3Q0SUF+QWXgo28uGpprGFX72whf/5ewmREcY1p8/kyx+ZRnxMaNbtiYiIiIiMFwp04ah8K/z1StjxGhxxOnzsLkjNHfEyWtsCPPTmTu58djMV9c1csDCX65bOYmJK3IjXIiIiIiIyHinQhZNAG7z+a3jhVoiKhfN/A8dcFJJRuZc3l3Hrqg1s3lvL4qkZ3HfO0czJSR3xOkRERERExjMFunBRtskblSt9E2adBWffASmTR7yMLfsO8KNVG3lxUxn5GQn89uKFLJ09CQtBqBQRERERGe8U6Ea7tlZ49Rfw0m0QkwCf+D3M/eSIj8pV1jVz13Ob+d9/7CAhOpL/OOtIPv/hQmKjtE5ORERERCRUFOhGs73rYcXXYc9aOOpcOPu/IGnCiJbQ3Brg/tdK+MXz71Hb1Mpnl+Tz7dNmkpkUO6J1iIiIiIjIwRToRqO2Fvi/O+Dl2yEuFT51H8w+f0RLcM7x7Ia9/OSpd3l/fx0nzszm+2cfxcyJySNah4iIiIiI9E6BbrTZ8y9YcSXsfRvmfBLO/CkkZo5oCet3V3PrExt5bVs5R0xI4n8uO5aPzhrZkUEREREREembAt1o0doEf/spvHInJGbBZx6EI88e0RL2HWjkv1Zv5uE1O0mLj+aW82Zz0eJ8oiMjRrQOERERERHpHwW60WDXGm9Urmyjtw3B0h9DQsaI3b6xpY3/fuV9fv3iFprbAlx+/FS+ccoMUhOiR6wGERERERE5fAp0odTSCC/9GF79JSRNgs8+DDOXjtjtnXM8vm4P//nUu+yqauCMoydy/VlHMTUrccRqEBERERGRgVOgC5Ud//D2lSt/DxZcAkt/5DVAGSFv7ajkh09s4J87qjh6cgq3f2oeH56eNWL3FxERERGRwVOgG2nN9fDCrfD6ryE1Fy5+DI44dcRuv6uqgZ8+/S5/Xbub7ORYfnrBPC5YlEtkhDYGFxEREREJNwp0I6nk77DyKqjYBkWXw+k3Q+zIbANQ19TKb/+2leUvbwPgqo8ewVdPnk5SrD4CIiIiIiLhSj/Nj4SmWnj+ZnhjOaQXwucfh6knjsitAwHHI/8s5WerN7HvQBPnHjOF75x5JDlp8SNyfxERERERGT4KdMNt20uw8htQtROWfA1O/QHEjEzTkde3lfPDJzawfncNC/LT+O0li1iYnz4i9xYRERERkeGnQDdcGmvg2R/Amj9AxnS47CkoOG5Ebl2yv46fPLWR1ev3MiU1jp9/Zj7nHjMFM62TExEREREZSxTohsOW52DlN+HAbvjwN+Cj34Po4Z/iWN3Qwt0vvMcfXi0hOjKCa8+YyZc+Mo246Mhhv7eIiIiIiIw8Bbqh1FAFq78Ha/8XsmbB5c9CbtGw37a1LcAf39jBnc+9R2V9M59alMu1Z8xiQkrcsN9bRERERERCR4FuqGx6Gp74FtTugxOugZO+A9HDH6he2rSPH63ayHv7avnQtAy+f/bRzMkZuf3sREREREQkdBToBqu+Ap7+Lqz7E0yYDRf9EaYsGPbbvrf3ALeu2sjfNpdRmJnA7y5ZxBlHT9Q6ORERERGRcUSBbjA2rIRV/wYNFd6I3EeuhaiYYb1lRV0zdz67mQff2EFCTCTfP/soLj2ukJioiGG9r4iIiIiIjD4KdANRtx+evBbW/wUmzYOLH4XJ84b1lk2tbdz/6nZ+8cJ71De38bkl+XzrtJlkJA5vgBQRERERkdFLga4v6x6G52+B6lJIzYVZy+Cdx7xtCU75Phz/LYiMHrbbO+dYvX4vP3lqI9vL6zl5VjbfO+soZkxMHrZ7ioiIiIhIeFCgO5R1D8PjV0NLg3dcvRPeuAfSCuALq2DCUcN6+3d2VfPDJzbwj/crmDEhifu+uJiTZmYP6z1FRERERCR8KNAdyvO3dIa5YK5tWMPcvppGbl+9iUf+WUp6Qgw/PH8OFx2bR1Sk1smJiIiIiEgnBbpDqS7t5fyuYbldY0sb97y8jd/8bSstbQG+/JFpXPnRI0iNH74pnSIiIiIiEr4U6A4lNdebZtnT+SHknGPlv3bzn0+9y+7qRpbNnsT1Zx1JQWbikN5HRERERETGFgW6Qzn1hq5r6ACi473zQ2TN9kp++MQG1u6sYk5OCnd8ej4fmpY5ZK8vIiIiIiJjlwLdocy70Psa3OXy1Bs6zw9CaWU9//n0Jh7/124mJMdy+yfnccHCXCIitDG4iIiIiIj0jwJdX+ZdOCQBrl1tUyu/eWkLv/+/9zGDq085gq+cNJ3EWP2rEBERERGRw6MUMULaAo5H1uzkZ89spuxAE+fPn8K/LzuSKWnxoS5NRERERETClALdCHh1635ufWIjG/bUsKggnXsuLWJ+XlqoyxIRERERkTCnQDeM3t9fx4+f3MizG/aSkxbPLy9awDnzJmOmdXIiIiIiIjJ4CnTDoLq+hV+88B73v1ZCTGQE1y2dxeUnTCUuOjLUpYmIiIiIyBiiQDeEWtoCPPiPHdz13GaqGlr4dFEe15wxkwnJcaEuTURERERExiAFuiHgnOOlTWXcumoDW8vq+PD0TL5/9tEcPSUl1KWJiIiIiMgYpkA3SJs+OMCtqzbwf+/tZ2pWIvdcWsRpR03QOjkRERERERl2gwp0ZrYM+DkQCfzeOXdbt+dPBO4C5gGfcc49Mpj7jSbltU3c8exm/vjGDpJio/jBOUdzyYcKiImKCHVpIiIiIiIyTgw40JlZJPAr4HSgFHjTzFY65zYEXbYD+AJw7WCKDKUVb+3i9tWb2F3VwJS0eL592gzK65q5+4Ut1Le0celxhXzz1BmkJ8aEulQRERERERlnBjNCtxjY4pzbBmBmDwHnAR2BzjlX4j8XGMR9QmbFW7u4/rG3aWhpA2BXVQPXPbIOB5xy5AT+46yjOGJCUmiLFBERERGRcWswgS4H2Bl0XAosGVw5o8vtqzd1hLl2DshMjOHeLxwbmqJERERERER8g1nw1VPXDzegFzK7wsyKzay4rKxsECUNrd1VDT2er6hrHuFKREREREREDjaYQFcK5AUd5wK7B/JCzrnlzrki51xRdnb2IEoaWlPS4g/rvIiIiIiIyEgaTKB7E5hhZlPNLAb4DLByaMoaHa5bOov46Mgu5+KjI7lu6awQVSQiIiIiItJpwIHOOdcKXAWsBjYCDzvn1pvZLWZ2LoCZHWtmpcCngN+Z2fqhKHqknL8gh598Yi45afEYkJMWz08+MZfzF+SEujQRERERERHMuQEtexs2RUVFrri4ONRliIiIiIiIhISZrXHOFfXnWu2CLSIiIiIiEqYU6ERERERERMKUAp2IiIiIiEiYUqATEREREREJUwp0IiIiIiIiYUqBTkREREREJEyNum0LzKwM2B7qOnqQBewPdREypukzJsNJny8ZTvp8yXDS50uG02j9fBU457L7c+GoC3SjlZkV93cvCJGB0GdMhpM+XzKc9PmS4aTPlwynsfD50pRLERERERGRMKVAJyIiIiIiEqYU6PpveagLkDFPnzEZTvp8yXDS50uGkz5fMpzC/vOlNXQiIiIiIiJhSiN0IiIiIiIiYUqBTkREREREJEwp0PWDmS0zs01mtsXMvhvqemRsMbN7zWyfmb0T6lpkbDGzPDN70UwloG4AACAASURBVMw2mtl6M/tmqGuSscXM4szsDTP7l/8ZuznUNcnYY2aRZvaWmT0R6lpkbDGzEjN728zWmllxqOsZKK2h64OZRQKbgdOBUuBN4CLn3IaQFiZjhpmdCNQC9zvn5oS6Hhk7zGwyMNk5908zSwbWAOfr/18yVMzMgETnXK2ZRQOvAN90zr0e4tJkDDGza4AiIMU5d06o65Gxw8xKgCLn3GjcWLzfNELXt8XAFufcNudcM/AQcF6Ia5IxxDn3MlAR6jpk7HHO7XHO/dN/fADYCOSEtioZS5yn1j+M9v/oN8UyZMwsFzgb+H2oaxEZrRTo+pYD7Aw6LkU/EIlImDGzQmAB8I/QViJjjT8dbi2wD3jWOafPmAylu4B/BwKhLkTGJAc8Y2ZrzOyKUBczUAp0fbMezum3jyISNswsCXgU+JZzribU9cjY4pxrc87NB3KBxWamqeMyJMzsHGCfc25NqGuRMet459xC4EzgSn8ZTNhRoOtbKZAXdJwL7A5RLSIih8Vf1/Qo8IBz7rFQ1yNjl3OuCngJWBbiUmTsOB4411/n9BBwipn9b2hLkrHEObfb/7oP+AveUquwo0DXtzeBGWY21cxigM8AK0Nck4hIn/yGFf8NbHTO3RHqemTsMbNsM0vzH8cDpwHvhrYqGSucc9c753Kdc4V4P3+94Jy7OMRlyRhhZol+wzDMLBE4AwjLjuMKdH1wzrUCVwGr8RoKPOycWx/aqmQsMbM/Aq8Bs8ys1MwuD3VNMmYcD1yC91vttf6fs0JdlIwpk4EXzWwd3i9An3XOqbW8iISDicArZvYv4A1glXPu6RDXNCDatkBERERERCRMaYROREREREQkTCnQiYiIiIiIhCkFOhERERERkTClQCciIiIiIhKmFOhERERERETClAKdiIiMWWbWFrRlw1oz++4QvnahmYXlnkUiIjJ2RIW6ABERkWHU4JybH+oiREREhotG6EREZNwxsxIz+08ze8P/c4R/vsDMnjezdf7XfP/8RDP7i5n9y//zYf+lIs3sHjNbb2bPmFl8yN6UiIiMSwp0IiIylsV3m3L56aDnapxzi4G7gbv8c3cD9zvn5gEPAL/wz/8C+Jtz7hhgIbDePz8D+JVzbjZQBVwwzO9HRESkC3POhboGERGRYWFmtc65pB7OlwCnOOe2mVk08IFzLtPM9gOTnXMt/vk9zrksMysDcp1zTUGvUQg865yb4R9/B4h2zt06/O9MRETEoxE6EREZr1wvj3u7pidNQY/b0Np0EREZYQp0IiIyXn066Otr/uNXgc/4jz8HvOI/fh74GoCZRZpZykgVKSIicij6TaKIiIxl8Wa2Nuj4aedc+9YFsWb2D7xfbl7kn7sauNfMrgPKgMv8898ElpvZ5XgjcV8D9gx79SIiIn3QGjoRERl3/DV0Rc65/aGuRUREZDA05VJERERERCRMaYROREREREQkTGmETkRERoSZFZqZM7Mo//gpM/t8f64dwL3+w8x+P5h6RUREwoECnYiI9IuZrTazW3o4f56ZfXC44cs5d6Zz7r4hqOtkMyvt9to/ds59abCvLSIiMtop0ImISH/9AbjEzKzb+UuAB5xzrSNf0vgy0BFLEREZuxToRESkv1YAGcBH2k+YWTpwDnC/f3y2mb1lZjVmttPMburtxczsJTP7kv840sx+Zmb7zWwbcHa3ay8zs41mdsDMtpnZV/zzicBTwBQzq/X/TDGzm8zsf4O+/1wzW29mVf59jwp6rsTMrjWzdWZWbWZ/MrO4XmqebmYvmFm5X+sDZpYW9HyemT1mZmX+NXcHPffloPewwcwW+uedmR0RdN0fzOxW//HJZlZqZt8xsw+A/zGzdDN7wr9Hpf84N+j7M8zsf8xst//8Cv/8O2b2saDrov33ML+3f0ciIjL6KdCJiEi/OOcagIeBS4NOXwi865z7l39c5z+fhhfKvmZm5/fj5b+MFwwXAEXAJ7s9v89/PgVvb7g7zWyhc64OOBPY7ZxL8v/sDv5GM5sJ/BH4FpANPAk8bmYx3d7HMmAqMA/4Qi91GvATYApwFJAH3OTfJxJ4AtgOFAI5wEP+c5/yr7vUfw/nAuX9+OcCMAkvSBcAV+D93f0//nE+0ADcHXT9/wMSgNnABOBO//z9wMVB150F7HHOBe/TJyIiYUaBTkREDsd9wKfMLN4/vtQ/B4Bz7iXn3NvOuYBzbh1ekDqpH697IXCXc26nc64CLzR1cM6tcs5tdZ6/Ac8QNFLYh08Dq5xzzzrnWoCfAfHAh4Ou+YVzbrd/78eBHketnHNb/Ndpcs6VAXcEvb/FeEHvOudcnXOu0Tn3iv/cl4CfOufe9N/DFufc9n7WHwBu9O/Z4Jwrd8496pyrd84dAH7UXoOZTcYLuF91zlU651r8f14A/wucZWYp/vEleOFPRETCmAKdiIj0mx9QyoDzzGwacCzwYPvzZrbEzF70pwNWA18Fsvrx0lOAnUHHXcKOmZ1pZq+bWYWZVeGNLvXnddtfu+P1nHMB/145Qdd8EPS4Hkjq6YXMbIKZPWRmu8ysBi8ktdeRB2zvZS1hHrC1n/V2V+acawyqIcHMfmdm2/0aXgbS/BHCPKDCOVfZ/UX8kcu/Axf400TPBB4YYE0iIjJKKNCJiMjhuh9vZO4S4Bnn3N6g5x4EVgJ5zrlU4Ld40xT7sgcvjLTLb39gZrHAo3gjaxOdc2l40ybbX7evDVV3401PbH898++1qx91dfcT/37znHMpeFMY2+vYCeT30rhkJzC9l9esx5si2W5St+e7v79/A2YBS/waTvTPm3+fjOB1fd3c59f8KeA159xA/hmIiMgookAnIiKH637gNLx1b923HUjGGyFqNLPFwGf7+ZoPA1ebWa7faOW7Qc/FALF4I4OtZnYmcEbQ83uBTDNLPcRrn21mp5pZNF4gagJe7WdtwZKBWqDKzHKA64KeewMvmN5mZolmFmdmx/vP/R641swWmecIM2sPmWuBz/qNYZbR9xTVZLx1c1VmlgHc2P6Ec24PXpOYX/vNU6LN7MSg710BLAS+id/IRkREwpsCnYiIHBbnXAleGErEG40L9nXgFjM7ANyAF6b64x5gNfAv4J/AY0H3OwBc7b9WJV5IXBn0/Lt4a/W2+V0sp3SrdxPeqNQvgf3Ax4CPOeea+1lbsJvxAlE1sKpbnW3+ax8B7ABK8dbv4Zz7M95atweBA3R2DAUvXH0MqAI+5z93KHfhrQHcD7wOPN3t+UuAFuBdvGYy3wqqsQFvtHNqcO0iIhK+zLm+ZqqIiIjIWGFmNwAznXMX93mxiIiMetqgVEREZJzwp2hejjeKJyIiY4CmXIqIiIwDZvZlvKYpTznnXg51PSIiMjQ05VJERERERCRMaYROREREREQkTI26NXRZWVmusLAw1GWIiIiIiIiExJo1a/Y757L7c+2oC3SFhYUUFxeHugwREREREZGQMLPt/b1WUy5FRERERETClAKdiIiIiIhImFKgExERERERCVOjbg2diIj0rKWlhdLSUhobG0NdisiQiIuLIzc3l+jo6FCXIiISthToRETCRGlpKcnJyRQWFmJmoS5HZFCcc5SXl1NaWsrUqVNDXY6ISNjSlEsRkTDR2NhIZmamwpyMCWZGZmamRpxFRAZJgU5EJIwozMlYos+ziITMuofhzjlwU5r3dd3Doa5owDTlUkRERERExo91D8PjV0NLg3dcvdM7Bph3YejqGiAFOhGRMWrFW7u4ffUmdlc1MCUtnuuWzuL8BTkhqaWwsJDi4mKysrJG/ubrHobnb4HqUkjNhVNvCMu/sEVEpBdtrdBUA00HvK+NNd2+Vnc+31gD7z4Brd2me7c0eH9XhOHfDwp0IiJj0Iq3dnH9Y2/T0NIGwK6qBq5/7G2AkIW6kBhlv4UNabAdoLVr17J7927OOuusUJciImNRa7MfxKp7CGLBgay3sFYDLXV93ycyBmJTIC7l4DDXrrp0aN/bCFGgExEJQzc/vp4Nu2t6ff6tHVU0twW6nGtoaePfH1nHH9/Y0eP3HD0lhRs/NrvX16yrq+PCCy+ktLSUtrY2fvCDH5CcnMw111xDVlYWCxcuZNu2bTzxxBOUl5dz0UUXUVZWxuLFi3HODeyN9uWp78IHb/f+fOmb0NbU9VxLA/z1KlhzX8/fM2kunHnb0NUY5tauXUtxcbECnYh05ZwXjNpHvXoNZH2Etd7CVbCoeC+ItQey2BRImeIfp0JsctfnOr6mdh5HxXa+3p1zvF/wdZeaO3T/fEaQAp2IyBjUPcz1db4/nn76aaZMmcKqVasAqK6uZs6cObz88stMnTqViy66qOPam2++mRNOOIEbbriBVatWsXz58gHfd1C6h7m+zvfDcAXbkpISli1bxgknnMDrr7/OMcccw2WXXcaNN97Ivn37eOCBB1i8eDEVFRV88YtfZNu2bSQkJLB8+XLmzZvHTTfdxPvvv8+ePXvYvHkzd9xxB6+//jpPPfUUOTk5PP7440RHR7NmzRquueYaamtrycrK4g9/+AOTJ0/m5JNPZsmSJbz44otUVVXx3//93yxZsoQbbriBhoYGXnnlFa6//no2btxIUlIS1157LQBz5szhiSeeAOhX/SIyCjgHLfXdwlUPoasjrAVNWwy+JtDS971ikrqGrIQMSC/sPO4xiKV0DWuRQ7xX5ak3dJ29ARAd750PQwp0IiJh6FAjaQDH3/YCu6oaDjqfkxbPn75y3IDuOXfuXK699lq+853vcM4555CcnMy0adM69hC76KKLOoLbyy+/zGOPPQbA2WefTXp6+oDu2ae+RtJ6/S1sHly2akC3HM5gu2XLFv785z+zfPlyjj32WB588EFeeeUVVq5cyY9//GNWrFjBjTfeyIIFC1ixYgUvvPACl156KWvXrgVg69atvPjii2zYsIHjjjuORx99lJ/+9Kd8/OMfZ9WqVZx99tl84xvf4K9//SvZ2dn86U9/4nvf+x733nsvAK2trbzxxhs8+eST3HzzzTz33HPccsstFBcXc/fddwNw0003Dap+ERmkQACaa/u3Vuyga6o7R81cWx83soNDVtIkyJrpB7HknkfCgr/GJkNE5Ij8Yzks7VPux8j6agU6EZEx6Lqls7qsoQOIj47kuqWzBvyaM2fOZM2aNTz55JNcf/31nH766Ye8flS0pB+G38IOZ7CdOnUqc+fOBWD27NmceuqpmBlz586lpKQEgFdeeYVHH30UgFNOOYXy8nKqq6sBOPPMM4mOjmbu3Lm0tbWxbNmyjppLSkrYtGkT77zzTse/u7a2NiZPntxx/0984hMALFq0qON+h6M/9YuMa4G23teBNfW2fqyHUTP6mMZukd3CVSqk5UHsbP+4+xTFHgJZdCJEjOEdzuZdGLYBrrt+BTozWwb8HIgEfu+cu63b818FrgTagFrgCufcBjMrBDYCm/xLX3fOfXVoShcRkd60Nz4Zyi6Xu3fvJiMjg4svvpikpCR+85vfsG3bNkpKSigsLORPf/pTx7UnnngiDzzwAN///vd56qmnqKysHPR7GpBh+C3scAbb2NjONR4REREdxxEREbS2tgL0OG2z/R7B10dHR3ecb/9+5xyzZ8/mtddeO+T9IyMjO+7XXVRUFIFA59Td4I3B+1O/SNhqaxncWrGBNO9o/5o4rf9rxWKTIToBRsMv1WRE9BnozCwS+BVwOlAKvGlmK51zG4Iue9A591v/+nOBO4Bl/nNbnXPzh7ZsERHpy/kLcoa0o+Xbb7/Ndddd1xEWfvOb37Bnzx6WLVtGVlZWl/VRN954IxdddBELFy7kpJNOIj8/f8jqOGxD/FvYUAfb9tf8wQ9+wEsvvURWVhYpKSn9+t5Zs2ZRVlbGa6+9xnHHHUdLSwubN29m9uzep/AmJydz4MCBjuPCwsKONXP//Oc/ef/99wf3hkR6M5RbjrQ0HmKt2IFDPBd0TevB09gPcqjmHf1ZKxabAtFxA3uPMm71Z4RuMbDFObcNwMweAs4DOgKdcy641VoifY4Di4hIuFm6dClLly7tcq62tpZ3330X5xxXXnklRUVFAGRmZvLMM890XHfnnXeOaK3DKdTB9qabbuKyyy5j3rx5JCQkcN99vXTr7EFMTAyPPPIIV199NdXV1bS2tvKtb33rkIHuox/9KLfddhvz58/n+uuv54ILLuD+++9n/vz5HHvsscycOXPQ70nkID1tObLyG1C+DfKKemna0VPzDj+stTX3fc/emnd0rBVL7T2QtT8e6uYdIv1gfbWSNrNPAsucc1/yjy8Bljjnrup23ZXANUAMcIpz7j1/yuV6YDNQA3zfOfd/PdzjCuAKgPz8/EXbt28f5NsSERl7Nm7cyFFHHRXqMrq48847ue+++2hubmbBggXcc889JCQkhLqsEVdbW0tSUlJHsJ0xYwbf/va3Q11WWBiNn2sJgfoKqNgG5VuhYiu8+kuvC2O/9NC8I3j64aHWigU39hiNzTtk3DKzNc65ov5c258Rup4m4B6UAp1zvwJ+ZWafBb4PfB7YA+Q758rNbBGwwsxmdxvRwzm3HFgOUFRUpNE9EZEw8e1vf1vBBbjnnnu6BNuvfOUroS5JZPSpr/AD2zYvtHUEuG3QWBV0odH7ZC+DL67uGtZiksZ28w6RPvQn0JUCeUHHucDuQ1z/EPAbAOdcE9DkP15jZluBmUDxgKoVEREZhQ4n2JaXl3PqqacedP75558nMzNzqEsTGTnOQUNl/0KbRXjr4jKmw5wLIHM6ZEzzjtML4JeLet/4OX/JyL0nkTDQn0D3JjDDzKYCu4DPAJ8NvsDMZjjn3vMPzwbe889nAxXOuTYzmwbMALYNVfEiIuONc250bAcgA5aZmdmxb9x419eyDxmFuoS2boGtYqu3fq1dcGib+8nOwJYxzQttUbG932eMbfwso8+Kt3YNaSfoUOoz0DnnWs3sKmA13rYF9zrn1pvZLUCxc24lcJWZnQa0AJV40y0BTgRuMbNWvC0NvuqcqxiONyIiMtbFxcVRXl5OZmamQp2EPecc5eXlxMWpo9+o41znmrZ+hbY8L6TN/dThhbZDGWMbP8vosuKtXXz3sXU0tnhbsOyqauD6x94GCMtQ12dTlJFWVFTkios1I1NEpLuWlhZKS0u77PslEs7i4uLIzc0lOlqdAUdc99DWfZpkb6Etc3pnYMucDmn5Aw9tIsOgtS3A/tpm9tY0sremkX0HmthX08jemib2HfC+vvtBDYEeIlBOWjx//+4pI190D4a6KYqIiIwC0dHRTJ06NdRliEi46AhtPYyy9RbaMqf7I20KbTK6tLYFKK/zgtq+mib2+uFsnx/a9vqhrbyuie7jVREGmUmxTEyJZXJqHBv21PR4j91V/dhrcBRSoBMREREJVz2GtvbH27yNstsdMrQVQFRM6N6HjFttAUd5bVOXETRvZK1rcCuvbTpoVM0MMhO9oDYxJY65OalMSInzjpPjmOCfz0yMISqysxPq8be9wK4ewtuUtPjhfrvDQoFOREREZDQLDm0HdZA8RGibd2HQNMlpCm0yotoCjvK6JvYdFNQ6p0DurWlkfw9BDSArKYYJyV44mz05lYkpsUxIiWNCshfSJqbEkZXUNaj113VLZ3H9Y2/T0NLWcS4+OpLrls4azFsOGQU6ERERkVBzDurLe54a2VNoS8v3QppCm4ywQMBRXtfcOYLWbX1a+/my2ibaekhqmYkxHcHsqMnJTEyJ6xbUYslKiiV6AEGtv9obn4ybLpciIiIiMgQOCm3B0yTfP3RoC96nLS1foU2GXCDgqKhv7pjmuK+XtWplB5po7SGoZSTGMCHZG0WbNbE9qMV2jLJ5I2qxxESNjk3gz1+QE7YBrjsFOhEREZGh0h7aetxcu7fQNh1yj1Vok2ERCDgq65s7God0nwK590ATZX5Y6ymopSdEM8FfjzZjYrI39dEPaRP8qY/ZoyiojUcKdCIiIiKHo6fQ1vFYoU1GhnOOqvqWjhG0vTWNlHV0e2xfq+aFt5a2g4NaWkJ0xzTHI7KzvAYi/nH7FMjs5FjioiND8O7kcCjQiYiIiHTnHNTt72Vz7W3QFNT2PDi05S3uurm2QpscJucc1Q0tXZqIeCNrXdeqlR1oorktcND3p8Z3BrUl0xK7THlsH11TUBtbFOhERERkfOo1tLVPjwwObZGda9oU2mQAnHPUNLT6I2qNQWvVDu4C2dx6cFBLjovqCGVLpmaQ7bfmb1+r1t6mX0Ft/FGgExERkbGre2jrsrbtUKFtSdd92lLzFNqkR845ahpbDxpB6zIF0j/XY1CLjerYL62oIL1jymOXtWrJccTHKKhJzxToREREJLx1hLbuUyMPEdoypx8c2tLyITI6dO9DRhXnHAeaWg/q9th9L7V9BxppbDk4qCW1B7XkOBbm+0HN7wLZuVYtloQY/Tgug6NPkIiIiIx+PYa24EYkCm3SP845aptau+yZ1nWtWudUyOCNp9slxEQyKcVbhzY/L61jfVp20IbXE5JjSYzVj9kyMvRJExERkdHBOagr63lz7UOGtg9121xboW0sWPHWrsPe+NkLasHr0toDWtcpkPXNBwe1+OhIJqV6wWxebhoTk2M7pkIGt+lPUlCTUUafSBERERmYdQ/D87dAdSmk5sKpN3ibYB9Kb6GtfZ+25gOd11okpBf4a9oU2saTFW/t4vrH3u4YIdtV1cB3Hl3Hln0HmDEx+aBGIu1Bra6HoBYXHeGNnCXHMXtKCqccOaGjC2TwxtdJsVGY2Ui/VZFBU6ATERGRw7fuYXj8amhp8I6rd3rHAHM/1S20ddtcu7fQln+cQts41dDcRmllPTsqvD8/e2bTQdMdm1oD3P3i1o7j2KiIjq6PR01J4aRZ2R3H7R0fJ6TEkaygJmOcAp2IiIj0zTkvvDXXQXMtPPP9zjDXrqUBVnwdnriml9A23QttHZtrK7SNF4GAY9+Bpo7AtqOinp3+nx0V9ew70NTv13r22ycyISWOlDgFNRFQoBMRERl7uoSvA/5XP4g110FTbdfjjsfdj+uCrq8FXN/3DrTA/C8qtI1DtU2tHQFtZ/fgVtnQpWW/GUxJjScvI56TZmaTn5FAfmYCeRkJ5GckcN7dr7CrqvGge+SkxTNjYvJIvi2RUU+BTkREJJQ6wlcPgaqpl4DVJaT1cm1/wheARUBMMsQkBv1JguTJXY+7PE6CZ74H9eUHv15qHpz10yH9RySjQ2tbgD3VjeysDA5sDR2hraKuucv1ybFR5GcmMHNiMqcdNZFcP6zlZyQwJS2O2Kje91W7bumRXdbQgde05Lqls4bt/YmEKwU6ERGR/nIOWup7H8HqcbSrtmv4auohjA0mfMUme+Ers1vg6imMxSYffD4qzhsuOVwRkV3X0AFEx3uNUSRsVde3dI6sVXYdbdtV2UBroPOzGhlh5KTFk5+RwNLZkzrCWl6Gdy41PnrAUyLbu1kebpdLkfHInOvnXyIjpKioyBUXF4e6DBERCXc9ha8epxr2MCWxx5A2iPAVm9TDSFdizyNjHdf3MCoWFTuw8DVcBtLlUkKquTXA7qqGbtMh/dG28npqGlu7XJ+RGENeenzHVMjO0JbA5NQ4oiIjQvRORMY2M1vjnCvqz7UaoRMRkdALDl89jWD1tsar1ymJ/uN+h69ILzDFdgtRKVN6GfXqZbQrOKSNtvA1HOZdqAA3yjjnqKhr7hLYOh83sKe6gaBBNmIiI8j1R9QW5KV3hLX2kbbkOK19FBntFOhERMay4RhBaQ9fPY5g9Xe0q4eRssMJXz2NYKXk9DLNsLcpiEHnx0P4kjGjsaWN0sqGLmEtuGtk973YspNjyc9IYPHUDPIyEshLj+9oQjIxOY6ICH32RcKZAp2IyFjV0z5hK6+C/e9B3uKeA1afUxKHMXz1OC2xpzVfCl8ytgUCjrLaph67Re6oqGdvTdcW/3HRER1TIY+bntllWmRuejwJMfpxT2Qs03/hIiJjRUMV7N8MZZu8r28sh9Zubb9bm+DlXjoQHhS+/K8pub1MM+xltKv9ODYJImMUvkR6UNfU6q1dK/dCWmll13VtTd1a/E9OiSM3I4GPzMjuEtjyMxLISorRfmwi45gCnYhIOHEOanb5wW0z7N/kjbiVbYK6fZ3XRcZAW3MvL2Jw+bMHhzSFL5Eh0xZwfFDTyI7ybqNsfsv//bVd//tMio0iPyOBI7KT+Ois7C6BLSc9/pAt/kVkfFOgExEZjVqbofJ9f7QtKLTtfw9a6jqvi0uFrFkw4wzInuk9zpoB6YXw82O8aZbdpeZC3rEj9lZExqrqhpaOdWvd17Ltqmqgpa1ri/8paXHkZyRw+tET/bVsnV0j0xIG3uJfRMY3BToRkVBqrPFC2n5/tK1ss/e48n0IBLUPT8n1gtrCS7yvWbMgexYkZvc+qnbqDdonTGQQWto6W/zvDNpAuz24VTe0dLk+LSGa/IwEZuekcubcyZ1TI9MTmJwWR7Ra/IvIMFCgExEZbs7BgQ/80La56zq3A3s6r4uIgozpMOFIOPrcztG2rBnetMjD1d7NUvuEifTIOUdl8Eba3QLb7qquLf6jI4289ARyMxI4Ji+1y1q2vIwEUtTiX0RCQIFORGSotLVCZYk/RXJz52jb/vegqbrzuphkL6RNOxmyZnp/smd50yQjh/gHQu0TJuNcY0sbu6qCRtfK2zfS9tr+1zZ13Ug7KymW/Ix4igrSyV+QQ27QZtoTU+KIVIt/ERllFOhERA5Xc13nNMn2kbb9m6F8KwSCpmAlTfLWtc37lD9F0g9vyZPVfERkiDjntfjvGFkr7wxvOyvr+aCmERc0yhYb1dnif8nUjG6jbGrxLyLhR//XEhHpiXNQt7/baJvflCS40YhFQsZUL6jNXNY52pY1w2tYIiKDVt/cys6Khh73ZNtZWU9jS6DL9ZNT48hLrXyKeAAAIABJREFUT+DD07P8DbTjO0JbdlKsmo+IyJjSr0BnZsuAnwORwO+dc7d1e/6rwJVAG1ALXOGc2+A/dz1wuf/c1c651UNXvojIIAXaoGp7UBfJoDVujVWd10UneCEt/zjI+nznaFvGNG+jaxEZsEB7i/8e1rHtqGhgf23XjbQTYyLJz0xkWnYiJ83MJj8zqMV/Wjxx0WrxLyLjR5+BzswigV8BpwOlwJtmtrI9sPkedM791r/+XOAOYJmZHQ18BpgNTAGeM7OZzrm2IX4fIiKH1tIA5Vs6W/+3d5Qs3wJtQT8sJmZ7QW32xztH2rJmQUoORKhDnUiwFW/t4vbVm9hd1cCUtHiuWzqL8xfk9HjtgcaWriNrQV0jSysbaG7rHGWLMJiS5o2qnXbUhI6mI+3TI9PV4l9EpEN/RugWA1ucc9sAzOwh4DygI9A552qCrk8E2mernwc85JxrAt43sy3+6702BLWLiBysvuLgtW1lm6BqB53/azJIL/CC2vSP+sHND28JGaGsXiRsrHhrF9c/9jYNLd7vaHdVNfCdR9exee8B8jISOkbYSv2vlfVdW/ynxnst/o+anMIZsycFrWWLZ0pavFr8i4j0U38CXQ4QvDNtKbCk+0VmdiVwDRADnBL0va93+96DfnVnZlcAVwDk5+f3p24RGc8CAagpDVrXFtRRsn5/53VRcZA5A3IWwfzPdnaUzDwCouNCV79ImKpramV7eT07Kuq44a/vdIS5dk2tAX790lbAa/Gfm55Abno8ZwXvyeb/SY1Xi38RkaHQn0DX05wGd9AJ534F/MrMPgt8H/j8YXzvcmA5QFFR0UHPi8g41drkdY7svndb+RZoqe+8Lj7dG2E78iw/tPkdJVPzIEJraUT6yzlHRV0z2yvq2V5e54W38nr/uP6gtWw9MeCV757CJLX4FxEZEf0JdKVAXtBxLrD7ENc/BPxmgN8rIuNRQ1XnurbgjpKVJeCCutel5ntBrfCErvu3JWaFrHSRcNMWcOypbugIaiXldd7jcm9qZPC+bGYwOSWO/MwETj1yAgVZCRRkJFKQmcCX7y9mT3XjQa8/JS2enLT4kXxLIiLjWn8C3ZvADDObCuzCa3Ly2eALzGyGc+49//BsoP3xSuBBM7sDrynKDOCNoShcRMKMc1Czu7P1f/Aat9q9nddFxkDGdJg0F+Z80g9t/jTJmMTQ1S8SRhpb2iit9EJae1BrH3Hr3oAkJjKC3Ix4CjISWOzvy1aYlUB+RiK56b13jPzOsiO7rKEDiI+O5Lqls4b9/YmISKc+A51zrtXMrgJW421bcK9zbr2Z3QIUO+dWAleZ2WlAC1CJN90S/7qH8RqotAJXqsOlyBjX1gIV7/tdJIM6Su5/D5prO6+LTfWC2hGnBe3dNhPSCiBSW2SK9KW6ocUfZQueGumNtu3ptpl2UmwU+RkJHDk5mTNmT6IgM4GCjATyMxOYnBo/oKmR7d0s+9vlUkREhoc5N7qWrBUVFbni4uJQlyEifWk60LUZSfufim0Q6JyyRUpOZ+v/rBmdHSWTJnjzuUSkR845yg40daxfax9h215Rz47yuoO6RmYlxXYJaoWZieT7xxmJMWrzLyISRsxsjXOuqD/X6tfgItI757zpkAdtA7AZDgQth42I8jbYzpoJR54TtH/bTIhNDl39IqNca1uAXVUNXYJa8DTJ4OmMEQY56fEUZCRy5tzJFGQkeAEuM5H8jAQSY/VXuojIeKT/+4sItLVC1faD927b/x40VXdeF5PkBbWpJ3rTJds7SmZMhUi1IBfpSUNzGzuCm4+0T5H0N9RuC3TOlImNiiDfD2onzMiiIDPBP04kJy2emCjtzSYiIl0p0ImMJ811/pq2bh0lK7ZCW3PndUkTvbA295Oda9uyZkLKFE2TFOnGOUdVfUuXVv/te7VtL69n34Gurf5T46MpyExgbk4q58yb3NE1siAzkQnJsUSo1b+IiBwGBTqRscY5qC/3R9iCO0q+B9U7Oq+zCEif6gW1mWd0jrZlzYD4tNDVLzIKBQKOD2oauwS17UGjbQcaW7tcPzElloLMRE6ame2NsmUmdkyRTEuICdG7EBGRsUiBTiRcBdqgakfnaFtwR8mGys7rouK9kJa/BLIu6Rxty5wOUbGhq19klGluDbCz0u8WWV7nr2nz17ZV1NPc2tnqPyrCyE2PJz8zkQV56R0jbAWZCeSlJxAfow3tRURkZCjQiYTauofh+VuguhRSc+HUG2DehZ3PtzRA+daD928r3wKtQZv6JmR50yOPPs8fafP3b0vJhQituxEBqG1qZbu/lq2k22jbnuoGgpazkRATSX5GAtOzEznlyAkda9sKMxOZnBpHVKT+uxIRkdBToBMJpXUPw+NXe6ENoHon/PXr3nkzL7hVbgfaf8o0SMv3gtu0k7vu35aQEZr3IDKKOOfYX9vcJagFNyQpr2vucn1GYgz5GQkcW5hOfmZux7TI/MwEspNi1epfRERGPQU6kVB6/pbOMNeurQW2PAsT58CUBTDvM50dJTOPgOj40NQqMkq0BRy7O1r9+50jg9r+1zV3tvo3gymp8eRnJHD60RM792fzg1tynLqziohIeFOgEwmVQMAbkeuRwdf+PqLliIwmjS1t7PQ31C4pr2NHRX1Qq/96Wto650bGREaQlxFPQWYiS6Zm+OvZvDVtuenxxEZpPZuIiIxdCnQioVBbBn+5ovfnU3NHrhaREKmub+myJ1vJ/s5GJB/UNHa5Njk2ivzMBI6anMyyOZMoyPCmRRZkJjIpJY5ItfoXEZFxSoFOZKSV/B0evRzqK2DBJfDOI12nXUbHe41RRMKcc459B5q6BLX2aZEl5fVUN7R0uT47OZaCjAQ+fERm0N5sXmhLT4jWejYREZEeKNCJjJRAAF65A178EWRMg8/9GSbNhaknHrrLpcgo1tIWYFdlQ4+bau+oqKexpbPVf2SEMSUtjsLMRG9D7cwE8v3glp+RQGKs/koSERE5XPrbU2Qk1O2Hx74MW1+AOZ+Ej90Fscnec/MuVICTUa2+ubVLUCspbx9tq2N3VSNtQb3+46IjyM/wgtpHZmRTGLSpdk56PNFq9S8iIjKkFOhEhlvwFMtz7oJFX/Ba74mMgBVv7eL21ZvYXdXAlLR4rls6i/MX5HS5xjlHRV1z57TIoO6RJeX17K9t6nJ9WkI0BRkJzM9L57xjEjo6RxZkJjAhWa3+RURERpICnchwCQTg73fCC7dC+lT4sj/FUmSErHhrF9c/9jYNLV4b/11VDfz7o+t4det+MhJjO/Zq21Fez4Gm1i7fOykljvzMBE45MpuCoDb/BRmJpCao1b+IiMhooUAnMhzq9sNjV8DW52HOBfCxn3dOsRQZZs45dlU1cPPj6zvCXLvm1gAPF5cSHWnkpntr1xYVpJOf0TnKlpeRQFy0Wv2LiIiEAwU6kaGmKZYywtoCjo17alizvZI3SypYs72SPdWNvV5vwLs/PFOt/kVERMYABTqRodJ9iuWXHobJ80JdlYxBdU2trN1ZRXFJJcXbK3hrRxW1/pTJyalxFBVmUFSQzt0vbqHsQNNB3z8lLV5hTkREZIxQoBMZCsFTLGd/wptiGZcS6qpkjNhX00hx0Ojb+t01tAUcZjBrYjIfX5BDUWE6RYUZ5KTFd3xfanx0lzV0APHRkVy3dFYo3oaIiIgMAwU6kcHa/io88kV/iuWdsOgyTbGUAQsEHFvKar3Rt5IKirdXsqOiHvC2BJifl8bXTppOUWE6C/LTSY3vvUFJezfLvrpcioiISPhSoBMZqI4plj+C9AL40nOaYimHrbGljXWl1RRvr6C4pJI12yupbmgBICsphqKCDC49roCiwgyOnpxCTNTh7eN2/oIcBTgREZExTIFOZCDq9sNfvgJbntMUSzksFXXNrNneOfr2dmk1zW0BAKZnJ7Js9iSKCtM5tjCDgswE7ekmIiIih6RAJ3K4tr/mT7Esh7PvgKIvaoql9Mg5R0l5vRfe/AYmW8vqAIiONOblpnHZ8YUUFWawqCCdjMSYEFcsIiIi4UaBTqS/AgH4+11+F8sC+NKzMPmYUFclo0hLW4D1u2u6BLj9tc2A16BkUUE6FyzK5djCDObmpGqvNxERERk0BTqR/qgrh79c4U+x/Dh87BeaYinUNLbwz+2VHeFt7c4qGlu86ZP5GQmcOCPb20KgMJ0jspOI0FYBIiIiMsQU6ET60jHFcj+c/V9QdLmmWI5Tu6oaKC6p4E1/BG7T3gM4B5ERxtGTU7hocT7H+nvATUiJC3W5IiIiMg4o0In0JhCAV38Oz/8Q0vL9LpaaYjletAUc735Q44++eU1M9lQ3ApAYE8nCgnTOnDOZosJ05uelkRir/52KiIjIyNNPICI9qSv3u1g+C0efD+f+UlMsx7j65lbW7qjiTX/65Fs7qqhtagVgUkpcR+fJRQXpHDkpmajIw9s+QERERGQ4KNCJdLfjdfjzZZpiOcbtq2mkeHslb5ZUsGZ7Jet319AWcJjBrInJnL9gSkeAy0mL1/YBIiIiMiop0Im0CwTg1V/A87doiuUYEwg4tpbVdoy+FZdUsqOiHoC46AiOyU3jaydNZ1FhOgvz00mNjw5xxSIiIiL9o0AnAt4UyxVfhfee0RTLMaCxpY23d1V7o2/+GrjqhhYAMhNjKCpM59LjClhUkM7sKanERGn6pIiIiISnfgU6M1sG/ByIBH7vnLut2/PXAF8CWoEy4IvOue3+c23A2/6lO5xz5w5R7SJDY8frXhfLujJNsQxTFXXNrNneOfr2dmk1zW3e9gHTshNZNnsSi/w1cIWZCZo+KSIiImNGn4HOzCKBXwGnA6XAm2a20jm3Ieiyt4Ai51y9mX0N+Cnwaf+5Bufc/CGuW2Twuk+xvPxZmKKP6mjnnGN7eX3H2rc3SyrYWlYHQHSkMTcnlcuOL2RRQTqLCtLJTIoNccUiIiIiw6c/I3SLgS3OuW0AZvYQcB7QEeiccy8GXf86cPFQFiky5Oor4C9fhfdW+1MsfwFxqaGuSnrQ0hZg/e4aiv2934q3V7K/tgmAlLgoigoz+MTCXI4tzGBebipx0ZEhrlhERERk5PQn0OUAO4OOS4Elh7j+cuCpoOM4MyvGm455m3NuRfdvMLMrgCsA8vPz+1GSyCDs+Ac8cpk3xfKsn8GxX9IUy1GkprGFf26v7Bh9W7uzisYWb/pkXkY8J87I6pg+eUR2EhER+ncnIiIi41d/Al1PPy25Hi80uxgoAk4KOp3vnNttZtOAF8zsbefc1i4v5txyYDlAUVFRj68tMmiBALz2S3juZkjL0xTLUWJXVUPH6NubJRVs2nsA5yAywjh6cgoXLc6nqCCDosJ0JqbEhbpcERERkVGlP4GuFMgLOs4Fdne/yMxOA74HnOSca2o/75zb7X/dZmYvAQuArd2/X2RYdZlieZ7fxVJTLEdaW8Dx7gc1/uhbJWtKKthd3QhAYkwkCwvSWTZnEscWZjA/L43EWDXiFRERETmU/vy09CYww8ymAruAzwCfDb7AzBYAvwOWOef2BZ1PB+qdc01mlgUcj9cwRWTk7HzD2yi8bp+mWI6w+uZW1u6o6tjA+60dVdQ2tQIwMSWWYwszuKIgnaLCDI6clExUpLYPEBERETkcfQY651yrmV0FrMbbtuBe59x6M7sFKHbOrQRuB5KAP/vtwNu3JzgK+J2ZBYAIvDV0G3q8kchQCwTgtbvh+ZshNRcufwamLAh1VWPavgONrCnxR9+2V/DO7hraAg4zmDUxmfPmT+HYwgwWFaSTmx6v7QNEREREBsmcG11L1oqKilxxcXGoy5BwV18BK74Gm5+Go86F8+7WFMshFgg4tpbVdoy+rdleyfbyegBioyKYn5dGUaE3+rYwP53U+OgQVywiIiISHsxsjXOuqD/XaoGKjD3BUyzPvB0Wf1lTLIdAY0sb7+yq5s2SSopLKlizo5Kq+hYAMhNjWFSQzsVLClhUmM6cKanERGn6pIiIiMhwU6CTscM5b4rlczdBSg58cTXkLAx1VWGrsq7Za16yvYI1JZWsK62muc3bPmBadiJnHD2RosIMigrSmZqVqOmTIiIiIiGgQCdjQ30FrPg6bH7Km2J57i8hPi3UVYUN5xw7Kuo7Rt+Kt1eyZV8tANH/v707j6+ivvc//voQVlkERJEdVMRd0Ij7UlesrUutVu2C1l6tLaK1WrW2Wu3iVXv9tS63LW3tvbYFBVfctXa519aFJYCAoIgoISAiuxAg5Pv7I6c0cBGiJkzO5PV8PPLIOXNmTt55OPg478xnZkqCfXtsz/mH96W0TycO7NOJHdq1yjixJEmSwEKnPJg7ruZG4SsWOGJZR+vWVzO9YvmGc9/GzVnCopU1dxvp0Lo5B/bpxBmDelDapxP79+pI6xYlGSeWJEnS5ljoVLw2HbG88FlHLD/Eisp1THxn6YYbeE+au5TV69YD0KtzG47s36XmAiZ9OtN/p3Y0a2YhliRJKgYWOhWnjUYsPwun3uWIZS0VS1dvdPRt5oLlVCdoFrBX9w584aBeGwrcztu3zjquJEmSPiYLnYrPRiOWt8Lgi5r0iOX66sTMBSsY/3bN0bfxcxZTsawSgLYtSxjUuxPDj+tPaZ/ODOzdkXat/GcvSZKUF36yU/FICV68G/50Q2HE8hnocWDWqba5VWurmDR3aU15e3sJZW8vYcWaKgC6dmhFad/OXNSn5v5ve+zcnuYl3j5AkiQpryx0Kg61Ryz3+AycdnduRiwfKZvHbc/MpGLparp3bMNVJw3g9EE9Nry+cEUlEwrlbfycxUyrWE5VdSICdt+pPacO7L5hfLJnpzbePkCSJKkJsdCp8as9YjnkFjj44tyMWD5SNo9rH3p1wwVK5i1dzdUPTuEfby5ifTWMf3sxb7+/CoBWzZuxf6+OXHz0LpT26cwBvTux/XYtsowvSZKkjFno1HhtNGLZPZcjlrc9M3NDmfunNVXVjB5fTue2LSnt04kvHtyb0r6d2af79rRs7vikJEmS/sVCp8Zp1WJ49Jsw88ncjVjWVrF09WaXBzDhe8c7PilJkqQtstCp8SkfD2MugBXzYci/w8Ffz82IZW1PT53/oa917+i5cJIkSdo6C50aj5Tgpf+E566vGbH86jPQM18jlgCV69bzkydf494X36ZXpzYsXLGGNVXVG15v06KEq04akGFCSZIkFQsLnRqH1UtqrmK5YcTyLmjTKetU9W72eysZNrKM6fOXc+ER/bh6yB48+er8LV7lUpIkSfowFjplr4mMWD5cVs51D0+lZfNm/OYrpRy/V1cATh/UwwInSZKkj8VCp+ykBC/9ombEsn233I5YrlpbxQ2PTmPMhHIO6tuJn58ziO4d22QdS5IkSTlgoVM2Vi+BR74JM5+AAafA6XfncsRyxoLlDBtZxpvvreTSY3fjsuP607zEWw9IkiSpfljotO2VT4Ax58OKCjjpZjjkktyNWKaUGPXKXG58bBrtW7fg9189mCP6d8k6liRJknLGQqdtZ7MjlqVZp6p3yyvXce1Dr/LElPkc2b8Lt589kB3bt8o6liRJknLIQqdtY/USeHQYzHgcBny65kbh23XOOlW9m1K+lGEjy5i3dDVXnTSAS47elWbN8nX0UZIkSY2HhU4Nr3wCPHA+LK+Ak34Ch3wjlyOWv33hLW55egY7tmvF/RcdQmnf/BVWSZIkNS4WOjWclODlX8Kz34f2O+d2xHLJB2u56oHJ/Om1hRy/Z1d+etZ+dNyuZdaxJEmS1ARY6NQwmsiI5bg5ixk+qoxFK9dw/Wf24oLD+xI5O/ooSZKkxstCp/o3r3AVy+UVcOKP4dBv5m7Esro68Yu/vcntz71Oj45tePCSw9ivZ8esY0mSJKmJsdCp/qQEL/8Knv1ezYjlBU9Dr4OyTlXvFq6o5Ir7J/PCrEV8Zr9u/ORz+9KhdYusY0mSJKkJstCpfqxeCo9+s2bEcveT4fT/zOWI5QtvLOLy+yexonIdN39uX845qJcjlpIkScqMhU6f3LwJMOYCWD4vtyOWVeur+dmf3uDuv85i1x3b8YevDWaPnTtkHUuSJElNnIVOH19K8MoIeOa6XI9YVixdzWX3lTFuzhLOLu3JD07dm+1a+k9HkiRJ2fNTqT6e1Uth7DB47bFcj1j+afq7XPnAZNZVVfOzLwzk9EE9so4kSZIkbWCh00c3b2LhKpb5HbFcW1XNvz81g3v+/hZ7devAXecNYpcd22UdS5IkSdpIs7qsFBFDImJmRMyKiGs28/oVETE9IqZExPMR0afWa0Mj4o3C19D6DK9t7J9XsfztiVC9Hi54Cg4blrsy9/b7H/D5X/6De/7+FkMP7cND3zjMMidJkqRGaatH6CKiBLgbOAEoB8ZFxNiU0vRaq5UBpSmlVRFxCXAr8IWI6AzcAJQCCZhQ2HZJff8iamCVy2puFP7aWNh9CJz+i1yOWD4+pYJrH3yVCPjllw5gyD7dso4kSZIkfai6jFwOBmallGYDRMR9wGnAhkKXUvpLrfVfAr5UeHwS8FxKaXFh2+eAIcCoTx5d20xFWc2I5bJyOPFHcGj+jspVrlvPTY9PZ+TL7zCwV0fuPHcQvTpvl3UsSZIkaYvqUuh6AHNrPS8HDt7C+hcCT21hW68qUSxSgld+Dc9eB213qhmx7DU461T1btbCFQwbWcaMBSu4+OhduPLEAbQoqdM0siRJkpSpuhS6zR2KSZtdMeJL1IxXHv1Rto2Ii4CLAHr37l2HSGpwtUcs+58EZ/wydyOWKSUemFDO9Y9Oo03LEn53wUF8asBOWceSJEmS6qwuha4c6FXreU+gYtOVIuJ44Drg6JTSmlrbHrPJtn/ddNuU0ghgBEBpaelmy6K2oX+OWC6dCyf8sGbEslm+jlitXFPF9x+ZysNl8zhkl878/JxBdO3QOutYkiRJ0kdSl0I3DugfEf2AecA5wHm1V4iIQcCvgCEppYW1XnoG+ElEdCo8PxG49hOnVsNICcb9Bp757r9GLHtvabq2OE2rWMalI8uY8/4HXH58fy49tj8lzfJ1TqAkSZKahq0WupRSVUQMo6aclQD3pJSmRcRNwPiU0ljgNqAdMCZqLpbxTkrp1JTS4oj4ITWlEOCmf14gRY1M5TIYeylMfzTXI5a/f+ltfvTEa3Rs04I/fu0QDt11h6xjSZIkSR9bpNS4JhxLS0vT+PHjs47RtNQesTz+Bjj00tyNWC5bvY6rH5jC09MWcMyAHfmPs/Znh3atso4lSZIk/R8RMSGlVFqXdesycqm82mjEcsfcjlhOfGcJl44s493llVx78h7825G70MwRS0mSJOWAha6p2mjE8kQ441e5G7Gsrk785oXZ3Pr0TLp2aM3orx/KAb07bX1DSZIkqUhY6JqiikkwZmjhKpY35XLE8v2Va/j2mMn8deZ7DNl7Z245cz+2365F1rEkSZKkemWha0r+z4jlk9D7kKxT1buXZr/PZfeVseSDddx02t58+ZA+FC7WI0mSJOWKha6pqFwGY4fD9EdqRixP/yW0zdcVHtdXJ+788xvc8fwb9NmhLb8dehD79Ng+61iSJElSg7HQNQUVkwpXsXwHjr8RDhueuxHLd5dXcvl9k3hx9vucPrA7PzpjX9q1cveWJElSvvmJN89qj1hu1yW3I5Z/nbmQb4+ezKq167n18/tx1oE9HbGUJElSk2Chy6vK5fDYcJj2MOx2Qs1VLHM2YrlufTU/fXYmv/rbbAZ0bc9d5w2if9f2WceSJEmSthkLXR7NnwyjhxZGLH8Ah12WuxHLuYtXMfy+MsreWcq5g3tzw2f3onWLkqxjSZIkSduUhS5PUoLxv4Wnr60ZsTz/CehzaNap6t3TUxfwnQcmU53gznMH8dn9u2cdSZIkScqEhS4vNhqxPB7OGJG7EcvKdeu5+cnX+O8X32bfHttz13mD6LND26xjSZIkSZmx0OXB/Mk1V7Fc8jYcdwMcfnnuRizfWvQBw0ZOZFrFcr56eD+uPnkArZo7YilJkqSmzUJXzFKC8fcURix3gPMfhz6HZZ2q3j06aR7ffehVmpc049dfKeWEvbpmHUmSJElqFCx0xapyOTx2GUx7qDBi+Sto2yXrVPVq1doqfjB2GqPHl1PapxM/P3cQPTq2yTqWJEmS1GhY6IrR/CkwZmiuRyxnLljBsJETmfXeSr75qV351vG707wkX7+jJEmS9ElZ6IpJSjDhd/DUNbBd51yOWKaUuG/cXH4wdhrtWzfn3q8O5sj+O2YdS5IkSWqULHTFonI5PH45TH0Qdj0OPjcidyOWKyrX8d2Hp/LY5AoO320H/t8XBrJT+9ZZx5IkSZIaLQtdMZg/pXAVy7fguOvh8G/lbsTy1fJlDBs1kbmLV3HlibtzyTG7UdIsso4lSZIkNWoWusZs0xHLoY9D38OzTlWvUkr87u9zuPmp1+jSrhX3X3woB/XtnHUsSZIkqShY6BqrNSvgscth6gOw67E1Nwpvl69zyZauWsuVY6bwp9fe5bg9duKnZ+1Pp7Yts44lSZIkFQ0LXWO04FUYPbRmxPLY78MRV+RuxHLC24u5dGQZ761cw/c/sxdfPbwvEY5YSpIkSR+Fha4xSQkm/Bc8dTW06ZTLEcvq6sQv/vYmtz/3Oj06tuHBSw5jv54ds44lSZIkFSULXWPRBEYs31uxhitGT+J/31jEKft14+bP7UuH1i2yjiVJkiQVLQtdY7Bgas2NwhfPhmO/B0d8O3cjln+ftYjL75/E8tXr+PEZ+3De4N6OWEqSJEmfkIUuSynBxP+uGbFs3RGGPgZ9j8g6Vb2qWl/Nz59/g7v+MotdurTl9xcOZo+dO2QdS5IkScoFC11W1qyAx78Fr46BXT4Fn/t17kYs5y9bzWWjJvHKnMV8/sCe3HTa3mzX0l1OkiRJqi9+us5CExixfP75hoLSAAAQjklEQVS1d7lyzGTWVFVz+9n787kDemYdSZIkScodC922lBJMvBee+g603h6+Mhb6HZl1qnq1tqqaW5+ewW9eeIs9u3XgrvMGseuO7bKOJUmSJOWShW5bWbOyMGI5ujBiOQLa7ZR1qnr1zvuruHTURCaXL+PLh/ThulP2pHWLkqxjSZIkSbllodsWFkyFMefD4jdzO2L5xJT5XPPgFAj4xRcP4OR9u2UdSZIkSco9C11DagIjlpXr1vPDx6fzx5ffYWCvjtx57iB6dd4u61iSJElSk2ChayhrVsITV8CU+2GXYwpXsczXiOWshSsZNnIiMxas4OKjduHKkwbQoiRfRx4lSZKkxqxOn74jYkhEzIyIWRFxzWZePyoiJkZEVUR8fpPX1kfEpMLX2PoK3qi9Ow1GHFNzS4JPfQ++9FDuytwDE8r57J0vsHDFGn53wUFc++k9LXOSJEnSNrbVI3QRUQLcDZwAlAPjImJsSml6rdXeAc4HrtzMW6xOKQ2sh6yNXxMYsfxgTRXff3QqD02cx+B+nbnjnEHsvH3rrGNJkiRJTVJdRi4HA7NSSrMBIuI+4DRgQ6FLKc0pvFbdABmLQxMYsZxesZxhoyby1qIPGH5cf4YfuxvNPSonSZIkZaYuha4HMLfW83Lg4I/wM1pHxHigCvj3lNIjm64QERcBFwH07t37I7x1I/HuNBg9tOYqlp+6Do78NjTLz+X6U0r84eV3+OHj0+nYpgV//NrBHLZrl6xjSZIkSU1eXQpdbGZZ+gg/o3dKqSIidgH+HBGvppTe3OjNUhoBjAAoLS39KO+drZSg7Pfw5FWFEctHod9RWaeqV8tWr+OaB6fw1NQFHLX7jtx+9v50adcq61iSJEmSqFuhKwd61XreE6io6w9IKVUUvs+OiL8Cg4A3t7hRMag9YtnvaDjzN7kbsZw0dynDRk5k/rJKrjl5Dy46cheaNdtcv5ckSZKUhboUunFA/4joB8wDzgHOq8ubR0QnYFVKaU1EdAEOB279uGEbjXenw5ihsOgNOOa7cNSVuRqxrK5O/PaFt7jl6Rl07dCa0RcfyoF9OmUdS5IkSdImtlroUkpVETEMeAYoAe5JKU2LiJuA8SmlsRFxEPAw0An4bETcmFLaG9gT+FXhYinNqDmHbvqH/KjGacpoeP4mWFYO2/eEXY+tWdaqfc2I5S5HZ52wXi3+YC1XjpnMn2cs5KS9u3Lrmfuz/XYtso4lSZIkaTMipcZ1ylppaWkaP3581jFqTBkNjw2Hdas3Xt5lDxg6Ftp3zSZXA3l59vtcdt8kFn+wlutO2ZOvHNqHCEcsJUmSpG0pIiaklErrsm5dRi6brudv+r9lDmDdylyVufXVibv/Mouf/el1enfejoe+cRj79Ng+61iSJEmStsJCtyXLyj9k+bxtm6MBLVxeyeX3T+Ifb77PaQO78+Mz9qVdK3cLSZIkqRj4yX1Ltu8Jy+ZufnkO/O3197ji/kl8sLaKW8/cj7NKezpiKUmSJBWRZlkHaNSOux5atNl4WYs2NcuL2Lr11dzy9AyG3vMKO7RrydhhR3D2Qb0sc5IkSVKR8Qjdlux3ds332le5PO76fy0vQuVLVjF8VBkT31nKuYN7cf1n9qZNy/zcckGSJElqSix0W7Pf2UVd4Gp7ZtoCrhozmeoEd5w7iFP37551JEmSJEmfgIWuCVhTtZ6bn5zBf/1jDvv06MBd5x5A3y5ts44lSZIk6ROy0OXcnEUfMGzURKbOW84Fh/flmpP3oFVzRywlSZKkPLDQ5dijk+Zx3cNTKWkWjPjygZy4985ZR5IkSZJUjyx0ObR67XpufGwa942by4F9OnHHuYPo0bHN1jeUJEmSVFQsdDnz+rsrGDZyIq+/u5JvHLMr3zphd1qUeHcKSZIkKY8sdDmRUmL0+LncMHYa7Vo1596vDuao3XfMOpYkSZKkBmShy4EVleu47uGpjJ1cwWG77sDPvjCQnTq0zjqWJEmSpAZmoStyU+ctY9jIibyzeBXfPmF3vvGp3ShpFlnHkiRJkrQNWOiKVEqJ//rHHG5+cgad27Zk1L8dwsG77JB1LEmSJEnbkIWuCC1dtZbvPDCFZ6e/y7F77MRPz9qfzm1bZh1LkiRJ0jZmoSsyE95ewvBRZSxcUcn3TtmTC4/oR4QjlpIkSVJTZKErEtXViV/9z2x++uxMundszZivH8bAXh2zjiVJkiQpQxa6IrBo5RquGD2Z/3n9PU7Ztxs3n7kvHVq3yDqWJEmSpIxZ6Bq5f8xaxGX3T2LZ6nX8+Ix9OG9wb0csJUmSJAEWukaran01dzz/Bnf+ZRb9urTl3q8OZs9uHbKOJUmSJKkRsdA1QguWVTL8vjJeeWsxZx7Qk5tO25u2rfxPJUmSJGljtoRG5s8z3uXboyezpqqa/zhrf848sGfWkSRJkiQ1Uha6RmJtVTW3PTODX//vW+yxc3vuOu8AdtupXdaxJEmSJDViFrpGYO7iVQwbVcbkuUv50iG9+d4pe9G6RUnWsSRJkiQ1cha6jD356nyufnAKJPjPLx7Ap/ftlnUkSZIkSUXCQpeRynXr+dET0/nDS++wf6+O3HXuIHp13i7rWJIkSZKKiIUuA2++t5JhI8t4bf5y/u3Iflx10h60bN4s61iSJEmSioyFbht7aGI533tkKq2aN+Oe80s5do+uWUeSJEmSVKQsdNvIB2uquP7RaTw4sZzB/Trz83MG0m37NlnHkiRJklTELHTbwGvzlzNs5ERmL/qA4cf1Z/ixu9G8xBFLSZIkSZ9MnVpFRAyJiJkRMSsirtnM60dFxMSIqIqIz2/y2tCIeKPwNbS+gheDlBJ/eOltTrv77yyvrOIPFx7MFSfsbpmTJEmSVC+2eoQuIkqAu4ETgHJgXESMTSlNr7XaO8D5wJWbbNsZuAEoBRIwobDtkvqJ33gtr1zHtQ++yhOvzufI/l24/eyB7Ni+VdaxJEmSJOVIXUYuBwOzUkqzASLiPuA0YEOhSynNKbxWvcm2JwHPpZQWF15/DhgCjPrEyRuxyXOXMmzURCqWVvKdIQP4+lG70qxZZB1LkiRJUs7UpdD1AObWel4OHFzH99/ctj02XSkiLgIuAujdu3cd37rxSSnx2xfe4panZ7BT+9aMvvgQDuzTOetYkiRJknKqLoVuc4eWUh3fv07bppRGACMASktL6/rejcqSD9Zy5ZjJPD9jISfs1ZXbPr8fHbdrmXUsSZIkSTlWl0JXDvSq9bwnUFHH9y8Hjtlk27/Wcdui8cpbi7nsvjLeX7mWH3x2L4Ye1pcIRywlSZIkNay6XG5xHNA/IvpFREvgHGBsHd//GeDEiOgUEZ2AEwvLcmF9deLO59/gnBEv0qp5Mx76xmGcf3g/y5wkSZKkbWKrR+hSSlURMYyaIlYC3JNSmhYRNwHjU0pjI+Ig4GGgE/DZiLgxpbR3SmlxRPyQmlIIcNM/L5BS7BauqORb90/i77Pe59T9u/PjM/ahfesWWceSJEmS1IRESo3rlLXS0tI0fvz4rGNs0f++8R7fun8SK9dUceOpe3N2aS+PykmSJEmqFxExIaVUWpd163IOXZP2SNk8bntmJhVLV9OtY2v26taB52csZLcd2/HHrx3CgJ3bZx1RkiRJUhNloduCR8rmce1Dr7J63XoAKpZWUrG0kkP6deZ3FwymTcuSjBNKkiRJasrqclGUJuu2Z2ZuKHO1zV2y2jInSZIkKXMWui2oWLr6Iy2XJEmSpG3JQrcF3Tu2+UjLJUmSJGlbstBtwVUnDaBNi41HK9u0KOGqkwZklEiSJEmS/sWLomzB6YN6AGy4ymX3jm246qQBG5ZLkiRJUpYsdFtx+qAeFjhJkiRJjZIjl5IkSZJUpCx0kiRJklSkLHSSJEmSVKQsdJIkSZJUpCx0kiRJklSkLHSSJEmSVKQipZR1ho1ExHvA21nn2IwuwKKsQyjX3MfUkNy/1JDcv9SQ3L/UkBrr/tUnpbRjXVZsdIWusYqI8Sml0qxzKL/cx9SQ3L/UkNy/1JDcv9SQ8rB/OXIpSZIkSUXKQidJkiRJRcpCV3cjsg6g3HMfU0Ny/1JDcv9SQ3L/UkMq+v3Lc+gkSZIkqUh5hE6SJEmSipSFTpIkSZKKlIWuDiJiSETMjIhZEXFN1nmULxFxT0QsjIipWWdRvkREr4j4S0S8FhHTIuKyrDMpXyKidUS8EhGTC/vYjVlnUv5ERElElEXE41lnUb5ExJyIeDUiJkXE+KzzfFyeQ7cVEVECvA6cAJQD44BzU0rTMw2m3IiIo4CVwL0ppX2yzqP8iIhuQLeU0sSIaA9MAE73/1+qLxERQNuU0sqIaAG8AFyWUnop42jKkYi4AigFOqSUPpN1HuVHRMwBSlNKjfHG4nXmEbqtGwzMSinNTimtBe4DTss4k3IkpfQ/wOKscyh/UkrzU0oTC49XAK8BPbJNpTxJNVYWnrYofPmXYtWbiOgJnAL8JussUmNlodu6HsDcWs/L8QORpCITEX2BQcDL2SZR3hTG4SYBC4HnUkruY6pPPwO+A1RnHUS5lIBnI2JCRFyUdZiPy0K3dbGZZf71UVLRiIh2wIPA5Sml5VnnUb6klNanlAYCPYHBEeHouOpFRHwGWJhSmpB1FuXW4SmlA4CTgW8WToMpOha6rSsHetV63hOoyCiLJH0khfOaHgT+mFJ6KOs8yq+U0lLgr8CQjKMoPw4HTi2c53QfcGxE/CHbSMqTlFJF4ftC4GFqTrUqOha6rRsH9I+IfhHREjgHGJtxJknaqsIFK34LvJZSuj3rPMqfiNgxIjoWHrcBjgdmZJtKeZFSujal1DOl1Jeaz19/Til9KeNYyomIaFu4YBgR0RY4ESjKK45b6LYipVQFDAOeoeaCAqNTStOyTaU8iYhRwIvAgIgoj4gLs86k3Dgc+DI1f9WeVPj6dNahlCvdgL9ExBRq/gD6XErJS8tLKgZdgRciYjLwCvBESunpjDN9LN62QJIkSZKKlEfoJEmSJKlIWegkSZIkqUhZ6CRJkiSpSFnoJEmSJKlIWegkSZIkqUhZ6CRJuRUR62vdsmFSRFxTj+/dNyKK8p5FkqT8aJ51AEmSGtDqlNLArENIktRQPEInSWpyImJORNwSEa8UvnYrLO8TEc9HxJTC996F5V0j4uGImFz4OqzwViUR8euImBYRz0ZEm8x+KUlSk2ShkyTlWZtNRi6/UOu15SmlwcBdwM8Ky+4C7k0p7Qf8EbijsPwO4G8ppf2BA4BpheX9gbtTSnsDS4EzG/j3kSRpI5FSyjqDJEkNIiJWppTabWb5HODYlNLsiGgBLEgp7RARi4BuKaV1heXzU0pdIuI9oGdKaU2t9+gLPJdS6l94fjXQIqX0o4b/zSRJquEROklSU5U+5PGHrbM5a2o9Xo/npkuStjELnSSpqfpCre8vFh7/Azin8PiLwAuFx88DlwBERElEdNhWISVJ2hL/kihJyrM2ETGp1vOnU0r/vHVBq4h4mZo/bp5bWDYcuCcirgLeAy4oLL8MGBERF1JzJO4SYH6Dp5ckaSs8h06S1OQUzqErTSktyjqLJEmfhCOXkiRJklSkPEInSZIkSUXKI3SSJEmSVKQsdJIkSZJUpCx0kiRJklSkLHSSJEmSVKQsdJIkSZJUpP4/6xPDZNXevYsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-2,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.801494\n",
      "(Epoch 0 / 5) train acc: 0.096000; val_acc: 0.102000\n",
      "(Iteration 11 / 200) loss: 1.958607\n",
      "(Iteration 21 / 200) loss: 1.897851\n",
      "(Iteration 31 / 200) loss: 2.201840\n",
      "(Epoch 1 / 5) train acc: 0.330000; val_acc: 0.296000\n",
      "(Iteration 41 / 200) loss: 1.686953\n",
      "(Iteration 51 / 200) loss: 1.723705\n",
      "(Iteration 61 / 200) loss: 1.719750\n",
      "(Iteration 71 / 200) loss: 1.655069\n",
      "(Epoch 2 / 5) train acc: 0.417000; val_acc: 0.321000\n",
      "(Iteration 81 / 200) loss: 1.573274\n",
      "(Iteration 91 / 200) loss: 1.722084\n",
      "(Iteration 101 / 200) loss: 1.616181\n",
      "(Iteration 111 / 200) loss: 1.588450\n",
      "(Epoch 3 / 5) train acc: 0.473000; val_acc: 0.359000\n",
      "(Iteration 121 / 200) loss: 1.527258\n",
      "(Iteration 131 / 200) loss: 1.357665\n",
      "(Iteration 141 / 200) loss: 1.452988\n",
      "(Iteration 151 / 200) loss: 1.489836\n",
      "(Epoch 4 / 5) train acc: 0.541000; val_acc: 0.378000\n",
      "(Iteration 161 / 200) loss: 1.331934\n",
      "(Iteration 171 / 200) loss: 1.277615\n",
      "(Iteration 181 / 200) loss: 1.445772\n",
      "(Iteration 191 / 200) loss: 1.153970\n",
      "(Epoch 5 / 5) train acc: 0.547000; val_acc: 0.367000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.798048\n",
      "(Epoch 0 / 5) train acc: 0.141000; val_acc: 0.137000\n",
      "(Iteration 11 / 200) loss: 2.011229\n",
      "(Iteration 21 / 200) loss: 2.009316\n",
      "(Iteration 31 / 200) loss: 1.867575\n",
      "(Epoch 1 / 5) train acc: 0.405000; val_acc: 0.290000\n",
      "(Iteration 41 / 200) loss: 1.749068\n",
      "(Iteration 51 / 200) loss: 1.837775\n",
      "(Iteration 61 / 200) loss: 1.720556\n",
      "(Iteration 71 / 200) loss: 1.744303\n",
      "(Epoch 2 / 5) train acc: 0.421000; val_acc: 0.344000\n",
      "(Iteration 81 / 200) loss: 1.536022\n",
      "(Iteration 91 / 200) loss: 1.586846\n",
      "(Iteration 101 / 200) loss: 1.493323\n",
      "(Iteration 111 / 200) loss: 1.613336\n",
      "(Epoch 3 / 5) train acc: 0.470000; val_acc: 0.353000\n",
      "(Iteration 121 / 200) loss: 1.592629\n",
      "(Iteration 131 / 200) loss: 1.562840\n",
      "(Iteration 141 / 200) loss: 1.416284\n",
      "(Iteration 151 / 200) loss: 1.272144\n",
      "(Epoch 4 / 5) train acc: 0.529000; val_acc: 0.371000\n",
      "(Iteration 161 / 200) loss: 1.365094\n",
      "(Iteration 171 / 200) loss: 1.297836\n",
      "(Iteration 181 / 200) loss: 1.441300\n",
      "(Iteration 191 / 200) loss: 1.437434\n",
      "(Epoch 5 / 5) train acc: 0.543000; val_acc: 0.367000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer: \n",
    "if gradient is large then learning rate reduces drastically as cache size increases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "pass\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}