Meetup9-Lab-Cifar-10-Tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Image Classification\n",
    "In this Lab, you'll classify images from the [CIFAR-10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html).  The dataset consists of airplanes, dogs, cats, and other objects. You'll preprocess the images, then train a convolutional neural network on all the samples. The images need to be normalized and the labels need to be one-hot encoded.  You'll get to apply what you learned on the last two Notebooks, and build a convolutional, max pooling, dropout, and fully connected layers.  At the end, you'll get to see your neural network's predictions on the sample images.\n",
    "## Get the Data\n",
    "Run the following cell to download the [CIFAR-10 dataset for python](https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\n",
    "\"\"\"\n",
    "from urllib.request import urlretrieve\n",
    "from os.path import isfile, isdir\n",
    "from tqdm import tqdm\n",
    "import tarfile\n",
    "\n",
    "cifar10_dataset_folder_path = 'cifar-10-batches-py'\n",
    "tar_gz_path = 'cifar-10-python.tar.gz'\n",
    "\n",
    "class DLProgress(tqdm):\n",
    "    last_block = 0\n",
    "\n",
    "    def hook(self, block_num=1, block_size=1, total_size=None):\n",
    "        self.total = total_size\n",
    "        self.update((block_num - self.last_block) * block_size)\n",
    "        self.last_block = block_num\n",
    "\n",
    "if not isfile(tar_gz_path):\n",
    "    with DLProgress(unit='B', unit_scale=True, miniters=1, desc='CIFAR-10 Dataset') as pbar:\n",
    "        urlretrieve(\n",
    "            'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz',\n",
    "            tar_gz_path,\n",
    "            pbar.hook)\n",
    "\n",
    "if not isdir(cifar10_dataset_folder_path):\n",
    "    with tarfile.open(tar_gz_path) as tar:\n",
    "        tar.extractall()\n",
    "        tar.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Explore the Data\n",
    "The dataset is broken into batches to prevent your machine from running out of memory.  The CIFAR-10 dataset consists of 5 batches, named `data_batch_1`, `data_batch_2`, etc.. Each batch contains the labels and images that are one of the following:\n",
    "* airplane\n",
    "* automobile\n",
    "* bird\n",
    "* cat\n",
    "* deer\n",
    "* dog\n",
    "* frog\n",
    "* horse\n",
    "* ship\n",
    "* truck\n",
    "\n",
    "Understanding a dataset is part of making predictions on the data.  Play around with the code cell below by changing the `batch_id` and `sample_id`. The `batch_id` is the id for a batch (1-5). The `sample_id` is the id for a image and label pair in the batch.\n",
    "\n",
    "Ask yourself \"What are all possible labels?\", \"What is the range of values for the image data?\", \"Are the labels in order or random?\".  Answers to questions like these will help you preprocess the data and end up with better predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Stats of batch 4:\n",
      "Samples: 10000\n",
      "Label Counts: {0: 1003, 1: 963, 2: 1041, 3: 976, 4: 1004, 5: 1021, 6: 1004, 7: 981, 8: 1024, 9: 983}\n",
      "First 20 Labels: [0, 6, 0, 2, 7, 2, 1, 2, 4, 1, 5, 6, 6, 3, 1, 3, 5, 5, 8, 1]\n",
      "\n",
      "Example of Image 802:\n",
      "Image - Min Value: 2 Max Value: 221\n",
      "Image - Shape: (32, 32, 3)\n",
      "Label - Label Id: 4 Name: deer\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8940f73828>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 250,
       "width": 253
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import helper\n",
    "import numpy as np\n",
    "\n",
    "# Explore the dataset\n",
    "batch_id = 4\n",
    "sample_id = 802\n",
    "helper.display_stats(cifar10_dataset_folder_path, batch_id, sample_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Implement Preprocess Functions\n",
    "### Normalize\n",
    "In the cell below, we implement the `normalize` function to take in image data, `x`, and return it as a normalized Numpy array. The values are in the range of 0 to 1, inclusive.  The return object is the same shape as `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize(x):\n",
    "    \"\"\"\n",
    "    Normalize a list of sample image data in the range of 0 to 1\n",
    "    : x: List of image data.  The image shape is (32, 32, 3)\n",
    "    : return: Numpy array of normalize data\n",
    "    \"\"\"\n",
    "    return x/255\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One-hot encode\n",
    "Just like the previous code cell, we are implementing a function for preprocessing.  This time, we are implementing the `one_hot_encode` function. The input, `x`, are a list of labels.  It returns the list of labels as One-Hot encoded Numpy array.  The possible values for labels are 0 to 9. The one-hot encoding function returns the same encoding for each value between each call to `one_hot_encode`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_hot_encode(x):\n",
    "    \"\"\"\n",
    "    One hot encode a list of sample labels. Return a one-hot encoded vector for each label.\n",
    "    : x: List of sample Labels\n",
    "    : return: Numpy array of one-hot encoded labels\n",
    "    \"\"\"\n",
    "    \n",
    "    num_labels = 10\n",
    "    return np.eye(num_labels)[x]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Randomize Data\n",
    "As you saw from exploring the data above, the order of the samples are randomized.  It doesn't hurt to randomize it again, but you don't need to for this dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess all the data and save it\n",
    "Running the code cell below will preprocess all the CIFAR-10 data and save it to file. The code below also uses 10% of the training data for validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL\n",
    "\"\"\"\n",
    "# Preprocess Training, Validation, and Testing Data\n",
    "helper.preprocess_and_save_data(cifar10_dataset_folder_path, normalize, one_hot_encode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Check Point\n",
    "This is your first checkpoint.  If you ever decide to come back to this notebook or have to restart the notebook, you can start from here.  The preprocessed data has been saved to disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL\n",
    "\"\"\"\n",
    "import pickle\n",
    "import helper\n",
    "\n",
    "# Load the Preprocessed Validation data\n",
    "valid_features, valid_labels = pickle.load(open('preprocess_validation.p', mode='rb'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build the network\n",
    "For the neural network, you'll build each layer into a function.  Most of the code you've seen has been outside of functions. To test your code more thoroughly, its better if you put each layer in a function.  \n",
    "\n",
    "Let's begin!\n",
    "\n",
    "### Input\n",
    "The neural network needs to read the image data, one-hot encoded labels, and dropout keep probability. These are the needed functions\n",
    "* Implement `neural_net_image_input`\n",
    " * Return a [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder)\n",
    " * Set the shape using `image_shape` with batch size set to `None`.\n",
    " * Name the TensorFlow placeholder \"x\" using the TensorFlow `name` parameter in the [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder).\n",
    "* Implement `neural_net_label_input`\n",
    " * Return a [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder)\n",
    " * Set the shape using `n_classes` with batch size set to `None`.\n",
    " * Name the TensorFlow placeholder \"y\" using the TensorFlow `name` parameter in the [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder).\n",
    "* Implement `neural_net_keep_prob_input`\n",
    " * Return a [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder) for dropout keep probability.\n",
    " * Name the TensorFlow placeholder \"keep_prob\" using the TensorFlow `name` parameter in the [TF Placeholder](https://www.tensorflow.org/api_docs/python/tf/placeholder).\n",
    "\n",
    "These names will be used at the end of the project to load your saved model.\n",
    "\n",
    "Note: `None` for shapes in TensorFlow allow for a dynamic size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda/envs/py35/lib/python3.5/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "def neural_net_image_input(image_shape):\n",
    "    \"\"\"\n",
    "    Return a Tensor for a batch of image input\n",
    "    : image_shape: Shape of the images\n",
    "    : return: Tensor for image input.\n",
    "    \"\"\"\n",
    "    return tf.placeholder(tf.float32, [None]+list(image_shape), \"x\")\n",
    "\n",
    "\n",
    "def neural_net_label_input(n_classes):\n",
    "    \"\"\"\n",
    "    Return a Tensor for a batch of label input\n",
    "    : n_classes: Number of classes\n",
    "    : return: Tensor for label input.\n",
    "    \"\"\"\n",
    "    return tf.placeholder(tf.float32, [None, n_classes], \"y\")\n",
    "\n",
    "\n",
    "def neural_net_keep_prob_input():\n",
    "    \"\"\"\n",
    "    Return a Tensor for keep probability\n",
    "    : return: Tensor for keep probability.\n",
    "    \"\"\"\n",
    "    return tf.placeholder(tf.float32, None, \"keep_prob\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OS:  linux\n",
      "Python:  3.5.4 |Anaconda custom (64-bit)| (default, Nov 20 2017, 18:44:38) \n",
      "[GCC 7.2.0]\n",
      "Numpy:  1.14.1\n",
      "TensorFlow:  1.6.0\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print(\"OS: \", sys.platform)\n",
    "print(\"Python: \", sys.version)\n",
    "print(\"Numpy: \", np.__version__)\n",
    "print(\"TensorFlow: \", tf.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convolution and Max Pooling Layer\n",
    "Convolution layers have a lot of success with images. For this code cell, you are implementing the function `conv2d_maxpool` to apply convolution then max pooling:\n",
    "* Create the weight and bias using `conv_ksize`, `conv_num_outputs` and the shape of `x_tensor`.\n",
    "* Apply a convolution to `x_tensor` using weight and `conv_strides`.\n",
    " * We recommend you use same padding, but you're welcome to use any padding.\n",
    "* Add bias\n",
    "* Add a nonlinear activation to the convolution.\n",
    "* Apply Max Pooling using `pool_ksize` and `pool_strides`.\n",
    " * We recommend you use same padding, but you're welcome to use any padding.\n",
    "\n",
    "**Note:** You **can't** use [TensorFlow Layers](https://www.tensorflow.org/api_docs/python/tf/layers) or [TensorFlow Layers (contrib)](https://www.tensorflow.org/api_guides/python/contrib.layers) for **this** layer, but you can still use TensorFlow's [Neural Network](https://www.tensorflow.org/api_docs/python/tf/nn) package. You may still use the shortcut option for all the **other** layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides):\n",
    "    \"\"\"\n",
    "    Apply convolution then max pooling to x_tensor\n",
    "    :param x_tensor: TensorFlow Tensor\n",
    "    :param conv_num_outputs: Number of outputs for the convolutional layer\n",
    "    :param conv_ksize: kernal size 2-D Tuple for the convolutional layer\n",
    "    :param conv_strides: Stride 2-D Tuple for convolution\n",
    "    :param pool_ksize: kernal size 2-D Tuple for pool\n",
    "    :param pool_strides: Stride 2-D Tuple for pool\n",
    "    : return: A tensor that represents convolution and max pooling of x_tensor\n",
    "    \"\"\"\n",
    "    # Variables.\n",
    "    weights = tf.Variable(tf.truncated_normal(\n",
    "      list(conv_ksize + (x_tensor.get_shape().as_list()[-1],) + (conv_num_outputs,)),0, stddev=0.1))\n",
    "    \n",
    "    bias = tf.Variable(tf.zeros(conv_num_outputs))\n",
    "    conv = tf.nn.conv2d(x_tensor, weights, list((1,)+conv_strides+(1,)), 'SAME')\n",
    "    conv = tf.nn.bias_add(conv, bias) \n",
    "    conv = tf.nn.relu(conv)\n",
    "    conv = tf.nn.max_pool(conv, ksize=list((1,)+pool_ksize+(1,)), strides=list((1,)+pool_strides+(1,)), padding='SAME')\n",
    "    \n",
    "    return conv\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flatten Layer\n",
    "Implement the `flatten` function to change the dimension of `x_tensor` from a 4-D tensor to a 2-D tensor.  The output should be the shape (*Batch Size*, *Flattened Image Size*). Shortcut option: you can use classes from the [TensorFlow Layers](https://www.tensorflow.org/api_docs/python/tf/layers) or [TensorFlow Layers (contrib)](https://www.tensorflow.org/api_guides/python/contrib.layers) packages for this layer. For more of a challenge, only use other TensorFlow packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(x_tensor):\n",
    "    \"\"\"\n",
    "    Flatten x_tensor to (Batch Size, Flattened Image Size)\n",
    "    : x_tensor: A tensor of size (Batch Size, ...), where ... are the image dimensions.\n",
    "    : return: A tensor of size (Batch Size, Flattened Image Size).\n",
    "    \"\"\"\n",
    "    shape = x_tensor.get_shape().as_list()\n",
    "    print(shape)\n",
    "    return tf.reshape(x_tensor, [-1, shape[1] * shape[2] * shape[3]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fully-Connected Layer\n",
    "Implement the `fully_conn` function to apply a fully connected layer to `x_tensor` with the shape (*Batch Size*, *num_outputs*). Shortcut option: you can use classes from the [TensorFlow Layers](https://www.tensorflow.org/api_docs/python/tf/layers) or [TensorFlow Layers (contrib)](https://www.tensorflow.org/api_guides/python/contrib.layers) packages for this layer. For more of a challenge, only use other TensorFlow packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fully_conn(x_tensor, num_outputs):\n",
    "    \"\"\"\n",
    "    Apply a fully connected layer to x_tensor using weight and bias\n",
    "    : x_tensor: A 2-D tensor where the first dimension is batch size.\n",
    "    : num_outputs: The number of output that the new tensor should be.\n",
    "    : return: A 2-D tensor where the second dimension is num_outputs.\n",
    "    \"\"\"\n",
    "    shape = list((x_tensor.get_shape().as_list()[-1],) + (num_outputs,))\n",
    "    print(shape)\n",
    "    weights = tf.Variable(tf.truncated_normal(shape,0,0.1))\n",
    "    bias = tf.Variable(tf.zeros(num_outputs))\n",
    "    return tf.nn.relu(tf.add(tf.matmul(x_tensor,weights), bias))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output Layer\n",
    "Implement the `output` function to apply a fully connected layer to `x_tensor` with the shape (*Batch Size*, *num_outputs*). Shortcut option: you can use classes from the [TensorFlow Layers](https://www.tensorflow.org/api_docs/python/tf/layers) or [TensorFlow Layers (contrib)](https://www.tensorflow.org/api_guides/python/contrib.layers) packages for this layer. For more of a challenge, only use other TensorFlow packages.\n",
    "\n",
    "**Note:** Activation, softmax, or cross entropy should **not** be applied to this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def output(x_tensor, num_outputs):\n",
    "    \"\"\"\n",
    "    Apply a output layer to x_tensor using weight and bias\n",
    "    : x_tensor: A 2-D tensor where the first dimension is batch size.\n",
    "    : num_outputs: The number of output that the new tensor should be.\n",
    "    : return: A 2-D tensor where the second dimension is num_outputs.\n",
    "    \"\"\"\n",
    "    shape = list((x_tensor.get_shape().as_list()[-1],) + (num_outputs,))\n",
    "    print(shape)\n",
    "    weights = tf.Variable(tf.truncated_normal(shape,0,0.1))\n",
    "    bias = tf.Variable(tf.zeros(num_outputs))\n",
    "    return tf.add(tf.matmul(x_tensor,weights), bias)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Convolutional Model\n",
    "Implement the function `conv_net` to create a convolutional neural network model. The function takes in a batch of images, `x`, and outputs logits.  Use the layers you created above to create this model:\n",
    "\n",
    "* Apply 1, 2, or 3 Convolution and Max Pool layers\n",
    "* Apply a Flatten Layer\n",
    "* Apply 1, 2, or 3 Fully Connected Layers\n",
    "* Apply an Output Layer\n",
    "* Return the output\n",
    "* Apply [TensorFlow's Dropout](https://www.tensorflow.org/api_docs/python/tf/nn/dropout) to one or more layers in the model using `keep_prob`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, 8, 8, 50]\n",
      "[3200, 400]\n",
      "[400, 200]\n",
      "[200, 100]\n",
      "[100, 10]\n",
      "WARNING:tensorflow:From <ipython-input-16-b3a294ab95d5>:61: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See tf.nn.softmax_cross_entropy_with_logits_v2.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def conv_net(x, keep_prob):\n",
    "    \"\"\"\n",
    "    Create a convolutional neural network model\n",
    "    : x: Placeholder tensor that holds image data.\n",
    "    : keep_prob: Placeholder tensor that hold dropout keep probability.\n",
    "    : return: Tensor that represents logits\n",
    "    \"\"\"\n",
    "    # Apply 1, 2, or 3 Convolution and Max Pool layers\n",
    "    #    Play around with different number of outputs, kernel size and stride\n",
    "    # Function Definition from Above:\n",
    "    #    conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides)\n",
    "    net = conv2d_maxpool(x, conv_num_outputs=50, conv_ksize=(3,3), conv_strides=(2,2), pool_ksize=(2,2), pool_strides=(2,2))\n",
    "    net = tf.nn.dropout(net, keep_prob)\n",
    "\n",
    "    # Apply a Flatten Layer\n",
    "    # Function Definition from Above:\n",
    "    #   flatten(x_tensor)\n",
    "    net = flatten(net)\n",
    "\n",
    "    # Apply 1, 2, or 3 Fully Connected Layers\n",
    "    #    Play around with different number of outputs\n",
    "    # Function Definition from Above:\n",
    "    #   fully_conn(x_tensor, num_outputs)\n",
    "    net = fully_conn(net,400)\n",
    "    net = fully_conn(net,200)\n",
    "    net = fully_conn(net,100)\n",
    "    net = tf.nn.dropout(net, keep_prob)\n",
    "    \n",
    "    # Apply an Output Layer\n",
    "    #    Set this to the number of classes\n",
    "    # Function Definition from Above:\n",
    "    #   output(x_tensor, num_outputs)\n",
    "    net = output(net,10)\n",
    "    \n",
    "    return net\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\n",
    "\"\"\"\n",
    "\n",
    "##############################\n",
    "## Build the Neural Network ##\n",
    "##############################\n",
    "\n",
    "# Remove previous weights, bias, inputs, etc..\n",
    "tf.reset_default_graph()\n",
    "\n",
    "# Inputs\n",
    "x = neural_net_image_input((32, 32, 3))\n",
    "y = neural_net_label_input(10)\n",
    "keep_prob = neural_net_keep_prob_input()\n",
    "\n",
    "# Model\n",
    "logits = conv_net(x, keep_prob)\n",
    "\n",
    "# Name logits Tensor, so that is can be loaded from disk after training\n",
    "logits = tf.identity(logits, name='logits')\n",
    "\n",
    "# Loss and Optimizer\n",
    "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "optimizer = tf.train.AdamOptimizer().minimize(cost)\n",
    "\n",
    "# Accuracy\n",
    "correct_pred = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the Neural Network\n",
    "### Single Optimization\n",
    "Implement the function `train_neural_network` to do a single optimization.  The optimization should use `optimizer` to optimize in `session` with a `feed_dict` of the following:\n",
    "* `x` for image input\n",
    "* `y` for labels\n",
    "* `keep_prob` for keep probability for dropout\n",
    "\n",
    "This function will be called for each batch, so `tf.global_variables_initializer()` has already been called.\n",
    "\n",
    "Note: Nothing needs to be returned. This function is only optimizing the neural network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_neural_network(session, optimizer, keep_probability, feature_batch, label_batch):\n",
    "    \"\"\"\n",
    "    Optimize the session on a batch of images and labels\n",
    "    : session: Current TensorFlow session\n",
    "    : optimizer: TensorFlow optimizer function\n",
    "    : keep_probability: keep probability\n",
    "    : feature_batch: Batch of Numpy image data\n",
    "    : label_batch: Batch of Numpy label data\n",
    "    \"\"\"\n",
    "    session.run(optimizer, feed_dict={x:feature_batch, y:label_batch, keep_prob:keep_probability})\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Show Stats\n",
    "Implement the function `print_stats` to print loss and validation accuracy.  Use the global variables `valid_features` and `valid_labels` to calculate validation accuracy.  Use a keep probability of `1.0` to calculate the loss and validation accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_stats(session, feature_batch, label_batch, cost, accuracy):\n",
    "    \"\"\"\n",
    "    Print information about loss and validation accuracy\n",
    "    : session: Current TensorFlow session\n",
    "    : feature_batch: Batch of Numpy image data\n",
    "    : label_batch: Batch of Numpy label data\n",
    "    : cost: TensorFlow cost function\n",
    "    : accuracy: TensorFlow accuracy function\n",
    "    \"\"\"\n",
    "\n",
    "    loss = session.run(cost, feed_dict={x:feature_batch, y:label_batch, keep_prob:1.0})\n",
    "    v_accuracy = sess.run(accuracy, feed_dict={x: valid_features, y: valid_labels, keep_prob: 1.0})\n",
    "    \n",
    "    print('Loss: {:>10.5f} Validation Accuracy: {:.5f}'.format(loss, v_accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameters\n",
    "Tune the following parameters:\n",
    "* Set `epochs` to the number of iterations until the network stops learning or start overfitting\n",
    "* Set `batch_size` to the highest number that your machine has memory for.  Most people set them to common sizes of memory:\n",
    " * 64\n",
    " * 128\n",
    " * 256\n",
    " * ...\n",
    "* Set `keep_probability` to the probability of keeping a node using dropout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Tune Parameters\n",
    "epochs = 10\n",
    "batch_size = 256\n",
    "keep_probability = 0.75"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on a Single CIFAR-10 Batch\n",
    "Instead of training the neural network on all the CIFAR-10 batches of data, let's use a single batch. This should save time while you iterate on the model to get a better accuracy.  Once the final validation accuracy is 50% or greater, run the model on all the data in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checking the Training on a Single Batch...\n",
      "Epoch  1, CIFAR-10 Batch 1:  Loss:    2.01299 Validation Accuracy: 0.31260\n",
      "Epoch  2, CIFAR-10 Batch 1:  Loss:    1.74139 Validation Accuracy: 0.40140\n",
      "Epoch  3, CIFAR-10 Batch 1:  Loss:    1.50584 Validation Accuracy: 0.43840\n",
      "Epoch  4, CIFAR-10 Batch 1:  Loss:    1.23934 Validation Accuracy: 0.46540\n",
      "Epoch  5, CIFAR-10 Batch 1:  Loss:    1.01642 Validation Accuracy: 0.48100\n",
      "Epoch  6, CIFAR-10 Batch 1:  Loss:    0.90419 Validation Accuracy: 0.51460\n",
      "Epoch  7, CIFAR-10 Batch 1:  Loss:    0.73793 Validation Accuracy: 0.52980\n",
      "Epoch  8, CIFAR-10 Batch 1:  Loss:    0.61731 Validation Accuracy: 0.54260\n",
      "Epoch  9, CIFAR-10 Batch 1:  Loss:    0.53141 Validation Accuracy: 0.54700\n",
      "Epoch 10, CIFAR-10 Batch 1:  Loss:    0.48428 Validation Accuracy: 0.54300\n",
      "CPU times: user 4.68 s, sys: 7.37 s, total: 12 s\n",
      "Wall time: 14.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL\n",
    "\"\"\"\n",
    "print('Checking the Training on a Single Batch...')\n",
    "with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:\n",
    "    # Initializing the variables\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    # Training cycle\n",
    "    for epoch in range(epochs):\n",
    "        batch_i = 1\n",
    "        for batch_features, batch_labels in helper.load_preprocess_training_batch(batch_i, batch_size):\n",
    "            train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels)\n",
    "        print('Epoch {:>2}, CIFAR-10 Batch {}:  '.format(epoch + 1, batch_i), end='')\n",
    "        print_stats(sess, batch_features, batch_labels, cost, accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fully Train the Model\n",
    "Now that you got a good accuracy with a single CIFAR-10 batch, try it with all five batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training...\n",
      "Epoch  1, CIFAR-10 Batch 1:  Loss:    2.03511 Validation Accuracy: 0.28700\n",
      "Epoch  1, CIFAR-10 Batch 2:  Loss:    1.61979 Validation Accuracy: 0.37460\n",
      "Epoch  1, CIFAR-10 Batch 3:  Loss:    1.38557 Validation Accuracy: 0.41680\n",
      "Epoch  1, CIFAR-10 Batch 4:  Loss:    1.45913 Validation Accuracy: 0.47340\n",
      "Epoch  1, CIFAR-10 Batch 5:  Loss:    1.39303 Validation Accuracy: 0.48680\n",
      "Epoch  2, CIFAR-10 Batch 1:  Loss:    1.47753 Validation Accuracy: 0.52320\n",
      "Epoch  2, CIFAR-10 Batch 2:  Loss:    1.12261 Validation Accuracy: 0.52220\n",
      "Epoch  2, CIFAR-10 Batch 3:  Loss:    0.96090 Validation Accuracy: 0.53260\n",
      "Epoch  2, CIFAR-10 Batch 4:  Loss:    1.16172 Validation Accuracy: 0.55400\n",
      "Epoch  2, CIFAR-10 Batch 5:  Loss:    1.11457 Validation Accuracy: 0.55820\n",
      "Epoch  3, CIFAR-10 Batch 1:  Loss:    1.18292 Validation Accuracy: 0.56760\n",
      "Epoch  3, CIFAR-10 Batch 2:  Loss:    0.90112 Validation Accuracy: 0.55200\n",
      "Epoch  3, CIFAR-10 Batch 3:  Loss:    0.75271 Validation Accuracy: 0.57480\n",
      "Epoch  3, CIFAR-10 Batch 4:  Loss:    0.89189 Validation Accuracy: 0.58800\n",
      "Epoch  3, CIFAR-10 Batch 5:  Loss:    0.86862 Validation Accuracy: 0.57740\n",
      "Epoch  4, CIFAR-10 Batch 1:  Loss:    1.03368 Validation Accuracy: 0.58880\n",
      "Epoch  4, CIFAR-10 Batch 2:  Loss:    0.75546 Validation Accuracy: 0.59380\n",
      "Epoch  4, CIFAR-10 Batch 3:  Loss:    0.58915 Validation Accuracy: 0.59440\n",
      "Epoch  4, CIFAR-10 Batch 4:  Loss:    0.73338 Validation Accuracy: 0.60260\n",
      "Epoch  4, CIFAR-10 Batch 5:  Loss:    0.66127 Validation Accuracy: 0.60440\n",
      "Epoch  5, CIFAR-10 Batch 1:  Loss:    0.82312 Validation Accuracy: 0.61040\n",
      "Epoch  5, CIFAR-10 Batch 2:  Loss:    0.54887 Validation Accuracy: 0.61460\n",
      "Epoch  5, CIFAR-10 Batch 3:  Loss:    0.44699 Validation Accuracy: 0.61620\n",
      "Epoch  5, CIFAR-10 Batch 4:  Loss:    0.55632 Validation Accuracy: 0.62400\n",
      "Epoch  5, CIFAR-10 Batch 5:  Loss:    0.48931 Validation Accuracy: 0.63340\n",
      "Epoch  6, CIFAR-10 Batch 1:  Loss:    0.65913 Validation Accuracy: 0.62400\n",
      "Epoch  6, CIFAR-10 Batch 2:  Loss:    0.41725 Validation Accuracy: 0.62000\n",
      "Epoch  6, CIFAR-10 Batch 3:  Loss:    0.34151 Validation Accuracy: 0.63360\n",
      "Epoch  6, CIFAR-10 Batch 4:  Loss:    0.47450 Validation Accuracy: 0.60900\n",
      "Epoch  6, CIFAR-10 Batch 5:  Loss:    0.32915 Validation Accuracy: 0.64680\n",
      "Epoch  7, CIFAR-10 Batch 1:  Loss:    0.55641 Validation Accuracy: 0.63560\n",
      "Epoch  7, CIFAR-10 Batch 2:  Loss:    0.27376 Validation Accuracy: 0.64380\n",
      "Epoch  7, CIFAR-10 Batch 3:  Loss:    0.28164 Validation Accuracy: 0.64200\n",
      "Epoch  7, CIFAR-10 Batch 4:  Loss:    0.33167 Validation Accuracy: 0.63940\n",
      "Epoch  7, CIFAR-10 Batch 5:  Loss:    0.28028 Validation Accuracy: 0.65100\n",
      "Epoch  8, CIFAR-10 Batch 1:  Loss:    0.44362 Validation Accuracy: 0.63000\n",
      "Epoch  8, CIFAR-10 Batch 2:  Loss:    0.21785 Validation Accuracy: 0.64700\n",
      "Epoch  8, CIFAR-10 Batch 3:  Loss:    0.22281 Validation Accuracy: 0.64380\n",
      "Epoch  8, CIFAR-10 Batch 4:  Loss:    0.26205 Validation Accuracy: 0.65040\n",
      "Epoch  8, CIFAR-10 Batch 5:  Loss:    0.20879 Validation Accuracy: 0.65680\n",
      "Epoch  9, CIFAR-10 Batch 1:  Loss:    0.34758 Validation Accuracy: 0.63040\n",
      "Epoch  9, CIFAR-10 Batch 2:  Loss:    0.15457 Validation Accuracy: 0.65720\n",
      "Epoch  9, CIFAR-10 Batch 3:  Loss:    0.20737 Validation Accuracy: 0.65280\n",
      "Epoch  9, CIFAR-10 Batch 4:  Loss:    0.20718 Validation Accuracy: 0.64820\n",
      "Epoch  9, CIFAR-10 Batch 5:  Loss:    0.12783 Validation Accuracy: 0.66220\n",
      "Epoch 10, CIFAR-10 Batch 1:  Loss:    0.23683 Validation Accuracy: 0.65560\n",
      "Epoch 10, CIFAR-10 Batch 2:  Loss:    0.10452 Validation Accuracy: 0.65300\n",
      "Epoch 10, CIFAR-10 Batch 3:  Loss:    0.17459 Validation Accuracy: 0.64160\n",
      "Epoch 10, CIFAR-10 Batch 4:  Loss:    0.15815 Validation Accuracy: 0.65620\n",
      "Epoch 10, CIFAR-10 Batch 5:  Loss:    0.10289 Validation Accuracy: 0.66020\n",
      "CPU times: user 19.2 s, sys: 12.5 s, total: 31.6 s\n",
      "Wall time: 35.5 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL\n",
    "\"\"\"\n",
    "save_model_path = './Cifar10model/image_classification'\n",
    "\n",
    "print('Training...')\n",
    "with tf.Session() as sess:\n",
    "    # Initializing the variables\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    # Training cycle\n",
    "    for epoch in range(epochs):\n",
    "        # Loop over all batches\n",
    "        n_batches = 5\n",
    "        for batch_i in range(1, n_batches + 1):\n",
    "            for batch_features, batch_labels in helper.load_preprocess_training_batch(batch_i, batch_size):\n",
    "                train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels)\n",
    "            print('Epoch {:>2}, CIFAR-10 Batch {}:  '.format(epoch + 1, batch_i), end='')\n",
    "            print_stats(sess, batch_features, batch_labels, cost, accuracy)\n",
    "            \n",
    "    # Save Model\n",
    "    saver = tf.train.Saver()\n",
    "    save_path = saver.save(sess, save_model_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Checkpoint\n",
    "The model has been saved to disk.\n",
    "## Test Model\n",
    "Test your model against the test dataset.  This will be your final accuracy. You should have an accuracy greater than 50%. If you don't, keep tweaking the model architecture and parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./Cifar10model/image_classification\n",
      "Testing Accuracy: 0.6580078125\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAscAAAJ/CAYAAACUb342AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3XecZGWV//HPqeo8eYYchyAyiKKOgKgLwyq7ZsyssiqyukYU08qqu4J5zQruuq4irglc42/Nq4IiiCQVgQEkjMAAA5ND56rz++M8Vff2neru6uk43d/361Wv6rr3uc99KvapU08wd0dERERERKA03Q0QEREREZkpFByLiIiIiCQKjkVEREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouBYRERERCRRcCwiIiIikig4FhERERFJFByLiIiIiCQKjkVEREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouB4mpnZwWb2PDN7rZn9s5mdY2ZnmdkLzexxZjZ/uts4HDMrmdmpZnaxmd1uZlvNzHOX7013G0VmGjNbXnifnDsRZWcqM1tVuA9nTHebRERG0jLdDZiLzGwp8FrgVcDBoxSvmtnNwOXAD4FfuHvvJDdxVOk+fAs4ebrbIlPPzC4CXj5KsUFgM7AeuJ54DX/D3bdMbutERER2nTLHU8zMngncDLyf0QNjiOfoaCKY/gHwgslr3Zj8N2MIjJU9mpNagD2AI4GXAP8BrDWzc81MX8x3I4X37kXT3R4Rkcmkf1BTyMxeBHwdKBd2bQX+BDwA9AFLgIOAFczALzBm9njgGblNfwHOA64FtuW2d09lu2S3MA94D3CimT3N3fumu0EiIiJ5Co6niJkdRmRb84HxjcC7gB+5+2CDY+YDJwEvBJ4LLJyCpjbjeYXbp7r7H6elJTJTvJ3oZpPXAuwNPAl4HfGFr+ZkIpN85pS0TkREpEkKjqfOB4D23O2fA892957hDnD37UQ/4x+a2VnAK4ns8nRbmft7jQJjAda7+5oG228HrjCzzwBfI77k1ZxhZp9x9z9MRQN3R+kxtelux3i4+2Xs5vdBROaWGfeT/WxkZp3As3ObBoCXjxQYF7n7Nnf/pLv/fMIbOHZ75f6+b9paIbuN9Fo/Hbgtt9mA10xPi0RERBpTcDw1Hgt05m5f6e67c1CZn15uYNpaIbuVFCB/srD5ydPRFhERkeGoW8XU2Kdwe+1UntzMFgJ/BewPLCMGza0Dfufud+9KlRPYvAlhZocS3T0OANqANcCl7v7gKMcdQPSJPZC4X/en4+4dR1v2Bx4BHAosTps3AncDv53jU5n9onD7MDMru3tlLJWY2dHAUcC+xCC/Ne7+9SaOaweeQMwUsxdQId4LN7j7DWNpwzD1Pww4DtgP6AXuBa529yl9zzdo1xHAo4E9iddkN/FavxG42d2r09i8UZnZgcDjiT7sC4j3033A5e6+eYLPdSiR0DiQGCOyDrjC3e8cR50PJx7/fYjkwiCwHbgH+DNwi7v7OJsuIhPF3XWZ5Avwd4DnLj+eovM+Dvgx0F84f/5yAzHNlo1Qz6oRjh/uclk6ds2uHltow0X5MrntJwGXAtUG9fQD/w7Mb1DfUcCPhjmuCnwb2L/Jx7mU2vEfwB2j3LcK0d/85Cbr/nLh+M+P4fn/UOHYH4z0PI/xtXVRoe4zmjyus8FjsleDcvnXzWW57a8gArpiHZtHOe/RwP8AO0Z4bu4BzgZad+HxeCLwu2HqHSTGDqxMZZcX9p87Qr1Nl21w7GLgvcSXspFekw8BFwLHjvIcN3Vp4vOjqddKOvZFwB9GON8A8H/A48dQ52W549fkth9PfHlr9JngwFXACWM4TyvwVqLf/WiP22biM+eUiXh/6qKLLuO7THsD5sIF+OvCB+E2YPEkns+Aj4zwId/ochmwZJj6iv/cmqovHbtmV48ttGHIP+q07Y1N3sdryAXIxGwb3U0ctwY4qInH+8xduI8OfBwoj1L3PGB14bi/a6JNpxQem3uBZRP4Gruo0KYzmjyuo8HjsGeDcvnXzWXEYNZvjvBYNgyOiS8uHyW+lDT7vPyRJr8YpXO8s8nXYT/R73p5Yfu5I9TddNnCcc8FNo3x9fiHUZ7jpi5NfH6M+lohZub5+RjP/Smg1ETdl+WOWZO2ncXISYT8c/iiJs6xJ7HwzVgfv+9N1HtUF1102fWLulVMjeuIf861adzmA/9tZi/xmJFiov0X8A+Fbf1E5uM+IqP0OGKBhpqTgF+b2YnuvmkS2jSh0pzRn043ncgu3UF8MXg0cFiu+OOA84FXmNnJwCVkXYpuSZd+Yl7pR+aOO5jI3I622Emx734PcBPxs/VWIlt6EPAoostHzVuIzNc5w1Xs7jvM7DQiK9mRNn/ezK5199sbHWNm+wBfIev+UgFe4u4bRrkfU+GAwm0ngrjRfIqY0rB2zO/JAuhDgUOKB5hZmXiun1/Y1U28J+8n3pOHAceQPV6PAq40s+Pcfd1IjTKzs4mZaPIqxPN1D9EF4DFE949WIuAsvjcnVGrTJ9i5+9MDxC9F64Eu4rl4JENn0Zl2ZrYA+BXxPs7bBFydrvclulnk2/4m4jPt78d4vtOBz+Q23Uhke/uI18ZKsseyFbjIzH7v7n8epj4DvkM873nriPns1xNfphal+g9HXRxFZpbpjs7nyoX4SbuYJbiPWBDhkUzcz90vL5yjSgQWiwvlWoh/0lsK5b/RoM4OIoNVu9ybK39VYV/tsk869oB0u9i15G3DHFc/ttCGiwrH17JiPwQOa1D+RUSQmn8cTkiPuQNXAo9ucNwqYEPhXE8f5TGvTbH3oXSOhtkr4kvJOxj6034VOL6J5/U1hTZdC7Q1KFcifmbOl/2XSXg9F5+PM5o87h8Lx90+TLk1uTLbcn9/BTigQfnlDbZ9oHCudUS3jEaP22Hs/B790Sj35ZHsnG38evH1m56TFwEPpjIbC8ecO8I5ljdbNpX/W3bOkv+K6Ge902cMEVw+i/hJ/7rCvj3I3pP5+r7F8O/dRs/DqrG8VoAvFcpvBV5NobsLEVx+nJ2z9q8epf7LcmW3k31OfBc4vEH5FcSvCflzXDJC/c8olP0zMfC04Wc88evQqcDFwP9M9HtVF110Gftl2hswVy5EZqq38KGZv2wgAr1/IX4Sn7cL55jPzj+lvnmUY45n536YI/Z7Y5j+oKMcM6Z/kA2Ov6jBY/Y1RvgZlVhyu1FA/XOgfYTjntnsP8JUfp+R6mtQ/oTCa2HE+nPHXVJo16cblHlXocwvR3qMxvF6Lj4foz6fxJesYheRhn2oadwd58NjaN/xDA0Sb6XBl67CMSV27uP9tBHKX1oo+9lR6n8EOwfGExYcE9ngdYXyFzT7/AN7j7AvX+dFY3ytNP3eJwbH5st2A08cpf43FI7ZzjBdxFL5yxo8Bxcw8riLvRn62do33DmIsQe1cgPAIWN4rDrG8tjqoosuk3PRVG5TxGOhjJcSQVEjS4GnEwNofgZsMrPLzezVabaJZrycbHYEgJ+4e3HqrGK7fgf8a2Hzm5o833S6j8gQjTTK/otEZrymNkr/pT7CssXu/gMimKpZNVJD3P2BkeprUP63wGdzm56TZlEYzauIriM1bzSzU2s3zOxJxDLeNQ8Bp4/yGE0JM+sgsr5HFnb9Z5NV/IEI/Jt1Dll3l0HgOe4+4gI66XF6NUNnkzm7UVkzO4qhr4vbgDePUv9NwD+N2OrxeRVD5yC/FDir2effR+lCMkWKnz3nufsVIx3g7hcQWf+aeYyt68qNRBLBRzjHOiLorWkjunU0kl8J8g/uflezDXH34f4/iMgUUnA8hdz9f4ifN3/TRPFWIovyOeBOM3td6ss2ktMLt9/TZNM+QwRSNU83s6VNHjtdPu+j9Nd2936g+I/1Yne/v4n6f5n7e6/Uj3cifT/3dxs796/cibtvJbqn9Oc2f8nMDkrP1zfI+rU78LIm7+tE2MPMlhcuh5vZE8zsn4CbgRcUjvmau1/XZP2f9Cane0tT6eUX3fm6u69u5tgUnHw+t+lkM+tqULTYr/Uj6fU2mguJbkmT4VWF2yMGfDONmc0DnpPbtInoEtaMdxduj6Xf8SfdvZn52n9UuH1ME8fsOYZ2iMgMoeB4irn77939r4ATiczmiPPwJsuITOPFZtbWqEDKPD42t+lOd7+6yTYNENNc1atj+KzITPGzJsvdUbj9f00eVxzsNuZ/chYWmNl+xcCRnQdLFTOqDbn7tUS/5ZolRFD8ZYYOdvuou/9krG0eh48CdxUufya+nPwbOw+Yu4Kdg7mR/GD0InWrGPrZ9u0xHAvw69zfrcCxDcqckPu7NvXfqFIW91tjbM+ozGxPottGzTW++y3rfixDB6Z9t9lfZNJ9vTm36ZFpYF8zmn2f3FK4PdxnQv5Xp4PN7PVN1i8iM4RGyE4Td78cuBzqP9E+gZhV4Vgii9joi8uLiJHOjT5sj2boyO3fjbFJVwGvy91eyc6Zkpmk+I9qOFsLt29tWGr040bt2pJmR3gKMavCsUTA2/DLTANLmiyHu3/KzFYRg3ggXjt5VzG2LghTqYeYZeRfm8zWAdzt7hvHcI4nFm5vSl9ImlUu3D6UGNSWl/8i+mcf20IU14yhbLOOL9y+fBLOMdlWFm7vymfYUenvEvE5OtrjsNWbX620uHjPcJ8JFzO0i80FZvYcYqDhj303mA1IZK5TcDwDuPvNRNbjCwBmtpj4efHNxLRSea8zswsb/BxdzGI0nGZoBMWgcab/HNjsKnODE3Rc60iFzewEov/sI0cqN4Jm+5XXvILoh3tQYftm4MXuXmz/dKgQj/cGYuq1y4kuDmMJdGFol59mFKeL+3XDUs0b0sUo/UqTf76Kv06MpuEUfONU7PbTVDeSGWY6PsOaXq3S3QcKPdsafia4+9Vm9u8MTTY8JV2qZvYnomvdr4kBzc38eigiU0jdKmYgd9/s7hcRmY/3NihyVoNtiwu3i5nP0RT/STSdyZwO4xhkNuGD08zsqcTgp10NjGGM78WUffpgg11vdfc142jHrnqFu1vh0uLuy9z9CHc/zd0v2IXAGGL2gbGY6P7y8wu3i++N8b7XJsKywu0JXVJ5ikzHZ9hkDVZ9A/HrTXdhe4noq/x6YvaZ+83sUjN7QRNjSkRkiig4nsE8vIf4EM17SjOHj/F0+mDeBWkg3FcZ2qVlDfA+4GnAw4l/+h35wJEGi1aM8bzLiGn/iv7ezOb6+3rELP8uGO29MRPfa7vNQLwRzMTHtSnps/uDRJecdwC/ZedfoyD+B68ixnz8ysz2nbJGisiw1K1i93A+cFru9v5m1unuPbltxUzRojGeo/izvvrFNed1DM3aXQy8vImZC5odLLSTlGH6MrB/g90nEyP3G/3iMFfks9ODQOcEdzMpvjfG+16bCMWMfDELuzuYdZ9haQq4jwAfMbP5wHHAXxHv0ycy9H/wXwE/SSszNj01pIhMvLmeYdpdNBp1XvzJsNgv8/AxnuOIUeqTxp6R+3sL8Momp/Qaz9Rwby6c92qGznryr2b2V+Oof3eXn6+3hXFm6YtS4JL/yf+w4coOY6zvzWYU53BeMQnnmGyz+jPM3be7+y/d/Tx3X0Usgf1uYpBqzaOAM6ejfSKSUXC8e2jUL67YH+9Ghs5/Wxy9Ppri1G3Nzj/brNnwM28j+X/gv3H3HU0et0tT5ZnZ44AP5zZtImbHeBnZY1wGvp66XsxFVxVuP3kSznF97u+HpUG0zWo0Ndx4XcXQ99ju+OWo+Jkzns+wKjFgdcZy9/Xu/gF2ntLwWdPRHhHJKDjePTy8cHt7cQGMlM3K/3M5zMyKUyM1ZGYtRIBVr46xT6M0muLPhM1OcTbT5X/6bWoAUeoW8eKxniitlHgJQ/vUnunud7v7T4m5hmsOIKaOmot+Xrh9xiSc47e5v0vA85s5KPUHf+GoBcfI3R8CbsptOs7MxjNAtCj//p2s9+41DO2X+9zh5nUvSvc1P8/zje6+bSIbN4kuYejKqcunqR0ikig4ngJmtreZ7T2OKoo/s102TLmvF24Xl4UezhsYuuzsj919Q5PHNqs4knyiV5ybLvl+ksWfdYfzUnbtZ+/PEwN8as539+/lbr+LoVnTZ5nZ7rAU+IRy99uBX+Q2HW9mxdUjx+trhdv/ZGbNDAQ8k8Z9xSfC5wu3PzGBMyDk37+T8t5Nv7rkV45cSuM53Rt5X+H2VyekUVMg9YfPz2rRTLcsEZlECo6nxgpiCegPm9leo5bOMbPnA68tbC7OXlHzZYb+E3u2mb1umLK1+o9l538snxlLG5t0J5Bf9OGvJ+Ec0+FPub9XmtlJIxU2s+OIAZZjYmb/yNBBmb8H3p4vk/7JvpihAftHzCy/YMVccW7h9n+Z2SljqcDM9jWzpzfa5+43MXRhkCOAT45S31HE4KzJ8kWG9rd+CvCpZgPkUb7A5+cQPjYNLpsMxc+e96XPqGGZ2WvJFsQB2EE8FtPCzF6bVixstvzTGDr9YLMLFYnIJFFwPHW6iCl97jWz75rZ80f6ADWzFWb2eeCbDF2x63p2zhADkH5GfEth8/lm9lEzGzLy28xazOwVxHLK+X9030w/0U+o1O0jv5z1SWb2BTN7spk9rLC88u6UVS4uBfxtM3t2sZCZdZrZm4mM5kJipcOmmNnRwKdym7YDpzUa0Z7mOM73YWwDLhnDUrqzgrv/hqHzQHcSMwH8u5k9bLjjzGyxmb3IzC4hpuR72QinOYuhX/heb2ZfK75+zaxkZi8kfvFZwiTNQezu3UR782MU3gj8Ii1SsxMzazezZ5rZtxh5Rcz8QirzgR+a2XPT51RxafTx3IdfA1/JbZoH/J+Z/UMxM29mC83sI8AFhWrevovzaU+UdwB3p9fCc4Z776XP4JcRy7/n7TZZb5HZSlO5Tb1WYvW75wCY2e3A3USwVCX+eR4FHNjg2HuBF460AIa7X2hmJwIvT5tKwNuAs8zst8D9xDRPxwJ7FA5fzc5Z6ol0PkOX9v2HdCn6FTH35+7gQmL2iFrAtQz4vpn9hfgi00v8DH088QUJYnT6a4m5TUdkZl3ELwWduc2vcfdhVw9z92+Z2eeA16RNhwP/Afx9k/dptvgXYgXB2v0uEY/7a9PzczMxoLGVeE88jDH093T3P5nZO4BP5Da/BDjNzK4C7iECyZXEzAQQfWrfzCT1B3f3n5nZ24CPk837ezJwpZndD9xArFjYSfRLfxTZHN2NZsWp+QLwVqAj3T4xXRoZb1eONxALZdRWB12Uzv9vZnY18eViH+CEXHtqLnb3/xjn+SdCB/FaeAngZnYbcBfZ9HL7Ao9h5+nqvufu/ztlrRSRhhQcT42NRPBbDEYhApdmpiz6OfCqJlc/e0U659lk/6jaGTng/A1w6mRmXNz9EjM7nggOZgV370uZ4l+SBUAAB6dL0XZiQNYtTZ7ifOLLUs2X3L3Y37WRNxNfRGqDsk43s1+4+5wZpJe+RL7UzP4IvJ+hC7UM9/wUjThXrrt/Mn2BeR/Ze63M0C+BNYPEl8HxLmc9otSmtURAmc9a7svQ1+hY6lxjZmcQQX3nKMXHxd23pu5J3yEC+5plxMI6w/kskSmfaYwYVF0cWF10CVlSQ0SmkbpVTAF3v4HIdPw1kWW6Fqg0cWgv8Q/iWe5+SrPLAqfVmd5CTG30MxqvzFRzE/GBfOJU/BSZ2nU88Y/sGiKLtVsPQHH3W4DHEj+HDvdYbwf+G3iUu/+kmXrN7MUMHYx5C42XDm/Upl6ij3J+oM/5ZnZkM8fPJu7+MWIg46fYeT7gRm4lvpSc4O6j/pKSpuM6kaHdhvKqxPvwie7+3001epzc/ZvE/M4fY2g/5EbWEYP5RgzM3P0SYvzEeUQXkfsZOkfvhHH3zcQUfC8hst3DqRBdlZ7o7m8Yx7LyE+lU4jG6itE/26pE+5/h7n+nxT9EZgZzn63Tz85sKdt0RLrsRZbh2UpkfW8Cbp6Ilb1Sf+MTiVHyS4lAbR3wu2YDbmlOmlv4ROLn+Q7icV4LXJ76hMo0SwPjHkX8krOY+BK6GbgDuMndHxzh8NHqfhjxpXTfVO9a4Gp3v2e87R5Hm4zopvAIYE+iq8f21LabgNU+w/8RmNlBxOO6N/FZuRG4j3hfTftKeMMxsw7gaOLXwX2Ix36AGDh9O3D9NPePFpEGFByLiIiIiCTqViEiIiIikig4FhERERFJFByLiIiIiCQKjkVEREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouBYRERERCRRcCwiIiIikig4FhERERFJFByLiIiIiCQKjkVEREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouBYRERERCRRcCwiIiIikig4FhERERFJFByLiIiIiCQKjkVEREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouB4DMzM02X5dLdFRERERCaegmMRERERkUTBsYiIiIhIouBYRERERCRRcCwiIiIikig4zjGzkpmdZWZ/NLMeM3vIzP7XzE5o4tg9zexDZvYnM9tuZjvM7EYz+4CZLR3l2KPN7EIzu8vMes1ss5ldYWavMbPWBuWX1wYHptuPN7Nvmdn9ZlYxs0/t+qMgIiIiMne1THcDZgozawG+BZyaNg0Sj88zgaea2WkjHPsk4PtALQjuByrAI9LlpWZ2irvf2uDYNwCfJvuisgOYDzwhXU4zs2e4e/cw534R8LXU1i3pvCIiIiKyC5Q5zryDCIyrwNuBRe6+BDgU+DlwYaODzOxg4H+JwPgLwJFAJzAPOBr4CXAg8B0zKxeOPRU4H+gB3gns7e7z0/F/A9wKrAI+OUK7v0gE5oe4+2KgC1DmWERERGQXmLtPdxumnZnNA+4DFgLnufu5hf3twPXAUWnTIe6+Ju37KnA68Bl3f1ODutuAq4FjgBe6+7fS9jJwB3Aw8Dx3/26DYw8B/gS0Awe5+/1p+3LgrlTsCuBEd6/u2r0XERERkRpljsPfEIFxHw2ytO7eB3ysuN3MOoEXppufaFSxu/cT3TUATsntWkUExmsaBcbp2LuAq4guE6uGafvHFRiLiIiITAz1OQ6PTdd/cPctw5T5VYNtjwPa0t+/M7Ph6u9M1wfmtj0hXe9nZg+M0LZFDY7N++0Ix4qIiIjIGCg4Dnum6/tGKLO2wbZ9c3/v3cR5uhoc27YLx+Y91MSxIiIiItIEBcfjU+uWssndR5yubYRjv+vuz9vVBri7ZqcQERERmSDqcxxq2df9RijTaN+6dL3EzPYZ4zlrxx41YikRERERmTIKjsP16frRZrZwmDInNdh2LTEfMsBYs7+1vsIPN7NHjPFYEREREZkECo7DT4GtxJRpw03H9tbidnffBnw73Xy3mQ3bd9jMWsxsfm7TL4C709+fLM6BXDh2yaj3QERERETGTcExkFaf+0i6+R4ze0uapq02p/B3GX62iHOAjcQAuyvN7LlpXmTS8Yeb2dnAamJ2i9o5B4CzACemePuZmR1vacqLFEyvNLMPA3dO2J0VERERkWFpEZBkmOWjtwOL09+nkWWJ64uApGOPBb5H1i95kFjKeT6Rja5Z5e5DpoQzs1cAnyObEq6XWEJ6MVDPJru75Y5ZTloEJL9dRERERMZHmePE3QeB5wNvBG4gAtwK8EPgJHf/zgjHXkMsG/0O4EpgGxHc9hD9kv8NOLYYGKdjvwQ8nFjy+aZ03kXABuBS4G3A8om4jyIiIiIyMmWORUREREQSZY5FRERERBIFxyIiIiIiiYJjEREREZFEwbGIiIiISKLgWEREREQkUXAsIiIiIpIoOBYRERERSRQci4iIiIgkCo5FRERERJKW6W6AiMhsZGZ3AQuBNdPcFBGR3dVyYKu7HzKVJ521wfEeRx7jAIOVbFsVA6ClnK5z975iVQCsNZLprW3ZzsrAIAAli20trZbtq/QDUG5pA6Cjsy07XzWOK5dbAdj64Pb6vsHBWLa71NaalR+IxvpgNZ13oL7PqnHOUinaMGi5Zb9tMJWppOvcvvR3unuUsqZTWzl847235baKyARZ2NnZuXTFihVLp7shIiK7o9WrV9PT0zPl5521wXE1BYqVarW+rVSOu+spQiy3t9f3WYoe+6sRkNYCVADzMgBtHfXa6/vKFhvbU107tu+o7xtMQbWTgtzBrH1WjSB8oD/b2NaRAuWOiFq9JwtyK71RrrU92lL1XBvaUkBeifMM9vTl2p6CY4vzeS5uFpmJzGwNgLsvn96WjNuaFStWLL3uuuumux0iIrullStXcv3116+Z6vOqz7GIiIiISDJrM8ciItPtxrVbWH7OD6e7GSIik2LNh58x3U2YFLM2OC6XU/eDfG/a1HViMHW5mLco6wo4f8F8ALp7o2/L5k3b6vtqXR8qg6mbRK5LQ39f2lYdehugZNFNopL6ElvuuKxNWfI+Fact9Vvu7Oys79u2fnOqNPVVtuyOtaTjarW3d2X9ni11DxnsiXZVB7N+FWbqaiwiIiKSp24VIjLlLLzBzG4ys14zW2tmF5jZohGOebGZXWpmm9Ixq83s3WbWPkz5I83sIjO7x8z6zGydmX3dzB7eoOxFZuZmdqiZnWVmN5hZj5ldNoF3W0REdgOzNnPsHtnaUik3Ai19FRisxL6q52aDSLM/9O7ojjJ9/dm+lG2tZV9bW7MZJizV1bMjBuK1lHNZ23TC1nLa0JpNnVFNI+Nac1NmlFtiW5r4gnKpXN/X2h7lKv0pC51L+tba1d4e7Vq2R5YRr01q8cA99wHglew+o8SxTJ9PAW8E7gc+DwwApwLHA21Af76wmX0ROBO4F/gOsBl4PPA+4Mlmdoq7D+bKPzWVawX+F7gdOAB4HvAMMzvZ3a9v0K5PA38F/BD4EVBpUEZERGaxWRsci8jMZGZPIALjO4Dj3H1j2v4u4FJgX+AvufJnEIHxd4HT3b0nt+9c4D3A64nAFjNbAnwD6AZOdPebc+UfAfwO+ALw2AbNeyzwGHe/awz3Z7jpKI5stg4REZk5Zm1w3NJS63Oc9fOtpl65XW3xK+yCefPq+9avexCAbVsjA1zO9zippMxxymVVS1n2tbXd0rY4X7k6/vvoAAAgAElEQVSUZZX7+2NKtVI5jm+bl2WxW1JH4YGe3JRxKZNbTdnd7Ztz08L19qV2xXny0xzX5kMeGIiN6/s3ZO1L07xV63MfZwdqVjeZJq9I1x+oBcYA7t5rZv9MBMh5byImQjwzHxgn7wPeAJxOCo6BlwGLgTfkA+N0jpvM7L+As83sqOJ+4CNjCYxFRGT2mbXBsYjMWLWM7a8a7Luc3IzgZtYFHAOsJwLaRvX1AStyt09I18ekzHLREel6BVAMjq8eqeGNuPvKRttTRrlRdlpERGYwBcciMtVqg+7WFXe4e8XMNuQ2LSF6x+9JdJ9oxrJ0/apRys1vsO2BJs8hIiKz1KwNjgct+kC0zqsva0dLGhnX3x/7egazMT99aalnT5mpam60WrkcXSxKFsfnxv3gtc4JHuVrS00DeCUtSZ16aJRyM7nV/q70ZV005rV3xXEDafno3myfp5X+vFyrLOsUUUpTxFVqg+0q2UA+T0m4Uke6X/m57QY0Ik+mxZZ0vTdwZ36HmZWJ4HZtoezv3b3ZLGztmGPc/YYxtk29jURE5rhZGxyLyIx1PdHd4CQKwTExU0T9c8ndt5vZTcAjzGxpvo/yCK4Cnp/qGmtwPKGO3n8R183SSfJFRGarWRsct82LQXdde2a/nO518L4AlEtxtx+496H6vsXtewLQuz2yrzs2ZYPhPC3ikQ7DPRusVxvkV07b8rnYvfbeG4AHH4hfaqtZlXQP1MYVZU/B4I44d2UwrktZEppSuWXI/bLW7EydbbFYyNYNMQ2dlbL2ldqiXNe8VKY/q7QyoGmuZVpcBLwSeJeZfT83W0UH8KEG5T8BfBG40MzOcPfN+Z1pdopDclOzfQl4F/AeM7vG3a8ulC8Rs1hcNoH3SUREZolZGxyLyMzk7leY2fnAWcCNZvYtsnmONxFzH+fLX2hmK4HXAXeY2U+Bu4GlwCHAiURA/JpUfoOZvYCY+u0qM/sFcBOxiORBxIC9ZUAHIiIiBQqORWQ6vAm4jZif+NXABiKYfSfwx2Jhd3+9mf2YCICfQkzVtpEIkj8KfLVQ/hdm9ijgbcDfEl0s+oH7gF8C356UeyUiIru9WRsct3csBKBzQZYcOuCwPQCYP38JAOseWl/f178tujK0tMZD0tGZrUi7Y8em2NcWcxPnV67r7Y75h6tpgNy8rmzu5PldMcBuW3vUtfe+e9b3PZDmVe7vy7o5bN8S/S7qA+tycy17KbpHtFncn9Zy9tR1dMS27eU4rq8vW9TLLK3qV5t/OT8VlmvskUwPd3fggnQpWj7MMT8AfjCGc6wh5kBupuwZwBnN1i0iIrOXOp2KiIiIiCSzNnO8YWtMlbrgoAPr27ZtjwFr6zZEJrjcln03qE3vNpgywV7Jsq9tCyLzW6lUh1wDeMrgVgZr07ZldQ4MRF3z50dmt5aVTgWjTCXLHFs5rbKXpmtzz62elzLHPek+DPRl2evutKof1bR6Xm5YYCVlpr09VsrLr6xHrn4RERERUeZYRERERKRu1maOD3r4fgD09mcLafzlzpi6bbCatmVrgFBKWddqJTaW27PM7Py9ov9y347eKFvJvlNs3bQNACtHFraaS83WpnmbNz/6Htf6IAO0p/7LPb1ZeWuJp6Oa+gLXMs9RPmV+U7K3ryfbV0kLhHSk/s75/tLd2/uGtL2ay3qbqc+xiIiISJ4yxyIiIiIiiYJjEREREZFk1narOPQRhwOw4aFsMa2NG7cCUO2L7gTl/uy7QaU7uhu0tkR3h/nLspX1vByD81qqsa/DOuv7tm2JAXLljuj2MJDrqtAzGF0a9txvHwCOWH5Yfd+ihVH/veuz9Q7ufmAdAN29cVzZsqenNmCwLU3JZtVs0F3JogvIwGCUqVSz/iKeBvz196QBhtk4Q0qoW4WIiIhInjLHIiIiIiLJrM0c3/9QTOU2vz3L8i5dFNna21ffCUDrQLavf0dkWz0SwLT2Zt8baoP0BnekLGylt76vnDK41lpK+7Ks7aZtkakuPRDp2uMe9Zj6viee8HgALv3d5fVtW/ojY9zzYFqcpJqbai0t3jFQG2CYS/rWB+C1RpnBgax9He2Rae5PC4P4kOnblDkWERERyVPmWEREREQkmbWZ4x3rY2GMzX0b69vmLV4AQKkUi3Js3bq9vq8jTZVW+7pQ2ZZlWKu9kXUtpfU6BqvZwh2kpaStGlnY/K7eVMW6+6MNv//DDfV9beVoQ/fmbKo5BtL0cYORAa7mdmHRvnJryvZabmfaNliKE7ak/s8ANlgZ0j7PZaM9129ZRERERJQ5FhERERGpU3AsIiIiIpLM2m4VW9bHaniWi/8HUxeDtpYYwNbXkq0yV7XoD1H2eEh6tmeD2kql6H7Q0R7dFaoD2aC7ark2N1rqolDKdVVI3SO62mIgYF81q/PmNTfG8d5a39bdE6vtVSrRLh/MrZ5XX7Cv9kfWrcJrA+vSucvtWbeK/h096bB4HKq5QXhaIU9ERERkKGWORWTGMLPlZuZmdlGT5c9I5c+YwDasSnWeO1F1iojI7mPWZo5rUX/Zs/i/e0NkZgfqCeMsy1tNi2XUssRWyQau7btoKQBPenxMv7Zxw7r6vjvuug2A9Vuj7t7B3AIcaRDcXkvi+O2VrfV9gz2R+V08b4/6tv0P3juOWxvn3rxuW1ZXak/Fo8580tdTRry9a17UuWxpfd9mYjBg70BarKSUe8orudGDIiIiIjJ7g2MRmRO+C1wF3D9awelw49otLD/nh8PuX/PhZ0xha0REpBkKjkVkt+XuW4At090OERGZPWZtcNzbHd0QWnPbyoMxEG8gdX1o68jufr3bQuqisGzhovq+fzztJQA8YeWxUaY3mx/5wftitb3Vt8YAu7v+8pf6vrXro0uDLYz5ldfZjux8aeW+hzZnXSe2b4/+HuVytLprwbxs3+boFlEqp3mVc90jBgeji0Z3GnzXMT/XtSN1MKmkLh5trW2549StQmYuMzsS+DBwItAO/B54r7v/LFfmDOBLwCvc/aLc9jXpz0cB5wLPA/YHPuDu56YyewMfBJ4JLARuBT4JZG9iERGZc2ZtcCwiu7VDgN8CNwL/CewLnAb82Mxe4u6XNFFHG/BLYCnwM2ArcBeAmS0DrgQOBX6TLvsCn0tlm2Zm1w2z68ix1CMiIjPDrA2OB/rSinClbGDdvLYuAKopi7pwXld9X3fKNPd1R3Z3wQGL6/t8z/j7+1deDkBnJcvMHrA4MsBHHXwAAA8/YJ/6vt/8KbLJl992KwB7HLWivu+Ou+4BYP09D9W31bLWThocaNmAwdrf5mmbZQMNW1KmeaASx296cEN932B/ZJUtrYZXzQ1CdLRCnsxYJwIfc/e31zaY2QVEwPw5M/uxu28d9uiwL3AzcJK77yjs+xARGH/K3d/c4BwiIjJHaSo3EZmJtgDvzW9w92uBrwGLgec2Wc9bi4GxmbUCpwPbiC4Xjc7RNHdf2egC3DKWekREZGaYtZnjvfZaAsDWHVn/YFoii9qSsq/9ucU82loj+9qS+vR257LD3/vtrwBY3BEZ5APmZX2B770luieWByOJtaCzo77vrofWA+Dz4rhKJesBveXB6GtslSx7O68j+kTv6ItzVz3bV/urWo0Mt7Vk+9rb4rja4iTVgUp9XzktJOKpropnmfQhC5aIzCzXu/u2BtsvA14OPAb48ih19AI3NNh+JNAFXJ4G9A13DhERmYOUORaRmWjdMNsfSNeLhtmf96C7N1oGsnbsaOcQEZE5SMGxiMxEew+zvdapv5np24ZbH7127GjnEBGROWjWdqtYflB0q9i4I5u6rLcnuh0saIup1Sp9WReDgTQdWiVN6TZv3vysstT9YPnhywHYrz3b179kIQDVchzf3zdQ39c5EIP1DiS6atx0y831feWU0GrtyE021xLb2i26SfR3Z107rBTfY8rpuurZeUqpS0g5dZ2wgew7T21MXyUNyPNqdp/Vq0JmsMea2YIGXStWpevfj6PuW4Bu4NFmtqhB14pVOx+ya47efxHXaaEPEZHdijLHIjITLQL+Nb/BzB5HDKTbQqyMt0vcfYAYdLeAwoC83DlERGSOmrWZ4+Mf/TAA1j60ub6ttzdSpUvmxxRumzdnCaPeNHBt6dIYPOe5qdKWLYpM7vyuOL6zLdvX1bkMgNa2yBL3DWa/5G6txMO75o7b4vaGbIXb9rbYVxsICOCtUW9XKQb1bezZWN9XaYtzL5ofgwG90lPf11+Oc87riPs1sCPLKvdXI/tsKSOOZ4P1zJQ6lhnr18Arzex44AqyeY5LwKubmMZtNO8EngycnQLi2jzHpwE/Ap49zvpFRGQ3pcyxiMxEdwFPADYBrwFeBFwPPL3JBUBG5O7rgScSq+sdCZwNPBp4LbFKnoiIzFGzNnN86EExIH3b5mxBjP0X7wVAZ2dkTPfZJ5t2rWrxUFQr8X1h/UNZ1rZ1QWSFe7bEtu2dffV9XQviOItuxfTm+hy3taesrUWGeu+9s/OV0wFLF2WLjey51x4A3H1fDKLfmG9DS2SYF+8T5a2aTSfXnaZ+27E9ssmDlawNLa1xnnI5Msb9PVnmeHAwN62byAzg7mtgyOo0p45S/iLgogbblzdxrgeAM4fZrZ9VRETmKGWORUREREQSBcciIiIiIsms7VZRaXkQgEMelq0V0JWmYOvsjO8EfdVc94PaYLb+6Gqwx9LsoenuiengevpiW2trNujOW3oB2J6qau3Iuk709cdgwAMOiK4Qj3zkifV91bQy3rzWrqwN6ZfcvdOgwK7Ozvq+jVuja8bhhx6Q7mBuSraWaN8996wF4IG1uTUMUrGSRbeMvt72+q6BPn03EhEREclTdCQiIiIikszazHF3W2Rtlx50UH1bbYTN/LTwhm8brO/rJw1mSwPXluyVW512fTpucSz4UcoNeOsrR+a4rz+OWzQ/WyBk+fJYgKu/J863995L6/tKFtnerRu669s6W+Lp2G+/KLffAcvq+265488ALF4c2WSrZt9rSmkauc6UhPbq9vq+lpYYkFdJbR4czMYZPbRuvLNhiYiIiMwuyhyLiIiIiCQKjkVEREREklnbrWJbf8z9u717XX1bbeDaPnvsCUCfZ4PaNm/fAYCnsXalcjawzrriuJbO6HphA73ZidKgvvbWeCgHq+vruw5aHl0zBlJXhoH+HfV97WmVvfyKeksWxDlbLbWroy07TXvMgWxpPuatm7LuGG4x7/KBaW7n/oE96vvmp24eg2mlvLX3ra3vK3Xpu5GIiIhInqIjEREREZFk1maOqwMxOm39umxwWtv8GLhWJQai9XZnA/IsZX6r1cjatvRn2eGqR5a20hfXC9qzjG5fb1p5biAyyKXB1vq+AWJFvkV7xnm3buuv72tvi2zvPosX1LeVUtq62hf72tuz7y4LWmIKtta2uF6wRzYF3IYHYvBhZ8oEH33M8vq++Quj/rb2GJj30MZsZb22rux+iIiIiIgyxyIiIiIidbM2c3zfA9E/uK8vm3ZtcEdkefu6I7vbUi7X91VLUa6a+iGXy7nscE9kn3f0xkIcfcuyKdnaO9JCHX1pSrdqlh2+f3P0P17fF+dpac32tQ5Edri1lG2r9SfetHkjAB1dWXZ4oCX6LVdSFnveoixDvSQ9jd290ad5wdIsG71wfuxr64hrm5cd19mRLTIiIiIiIsoci4iIiIjUKTgWkQlhZsvNzM3soului4iIyK6axd0qoiuEeTbobmAguib0bY+uE3vstaS+ry9Nz9bdF90xtm7fUt/X0RrHWTmut2zryU60Pbo5DPTENq9mK9ANbtgGQM9A7Nt/3+x8S+bFanv93Rvq22pTzW3vjbb7xk31fYvnx0C6MtENo5RfIa8zukf09cZ97Shn08NVLLZt2Bpt6e7PBiju6OlDRERERDKzNjgWEZluN67dwvJzfthw35oPP2OKWyMiIs2YtcFxb18Mvls0v72+bWHKsG7eGlOfdfdlg+4G0lRs23dEZrVtIHtoqh0xiK1rXmRvu7uzBTi6uyMjW61GttY9G+Q3kBK4A9Voiz2YZZU3ldNUcYPZtnJbGrjXFttaqNT3PfDA/QDsv+fi2JA7z30bIsvdk6aV83KW2a61a+26+1NbtmXns+zcIiIiIqI+xyIyCVL/44vNbL2Z9ZrZtWb2zAbl2s3sHDO7wcy6zWyrmV1uZi8apk43s4vM7Agzu8TMHjSzqpmtSmUONbPPm9ntZtZjZhvN7E9m9jkzW9agzheb2aVmtim1c7WZvdvM2otlRURkbpi1mePW9uhru2hxtujFws6YGq3UHlnigWqWYS21RiZ24cIoPziYTbFWbo3vELWMc2trlnHt6kqLh6TM82AlO66rPf6/tndG/+JtPVnGuXcg2tfVlk2ntqMvMsAdaRq5zq6s7YMpA9zbn9ps2dLXD26KdpXLUVe5J2tDT1pQZN3mqHtbri91tZJNcycygQ4GrgbuBL4CLAVOA75vZk9x90sBzKwN+ClwEnAL8FmgC3gBcImZPdrd39mg/sOA3wG3AV8DOoGtZrYvcA2wEPgR8G2gAzgEeClwAVDv5G9mXwTOBO4FvgNsBh4PvA94spmd4p4btCAiInPCrA2ORWTarALOdffzahvM7OvAT4C3A5emzW8lAuMfA8+uBaJmdh4RXP+zmf3A3a8s1P8k4EPFwNnMziIC8bPd/dOFffOAau72GURg/F3gdHfvye07F3gP8HpgSD2NmNl1w+w6crRjRURk5lG3ChGZaH8B3p/f4O4/Be4GjsttPhNw4C35DK27P0hkbwFe2aD+dcB5DbbX9BQ3uPuOfAAMvAkYBM4sbCedewNw+gjnEBGRWWrWZo4XL4luElXLBqD1VmLAWktHdFEYGMi6HwwMRlKpsz26JpTKWdeJCtH9wD0dn1tZb/68+Ls2tK+SjaGjrxKD7jwNyOtqz7pCtLdGl4slC7KujQMe59y6I7o+9FeyX3TnL4p2bdm6FYBNO7LvNX3pfngahLhta27AYFq5r1qKunp7coPwfNY+/TK9/uC1N8tQ9wAnAJjZAuBwYK2739Kg7C/T9WMa7Pujuzeah/D/AR8EPmtmf0t02bgCuNnd6/MbmlkXcAywHjjbGg9M7QNWNNpR5O4rG21PGeXHNlOHiIjMHIqORGSibR5m+yDZr1WL0vX9w5StbV/cYN8DjQ5w97+Y2XHAucBTgeelXfeY2cfc/TPp9hLAgD2J7hMiIiJ1szY4bmmJTKnlOo7s6N0BQDVlilras529lUhEpQQy5ZYsO+ylKN/RFVO6LVqYDaIrleM4S90ZFyzI9rWmjO627rie35493J1pUN/8zqwNVaL+vr7UiFKW2a6Wo9xAOfZZSzYN3cK22LdlY2SJt23LBtptTwP/+qtx39uqXfV9bS0akC/TpjYydJ9h9u9bKJfnDbbFDvfVwGlm1kJkh58CnAV82sx2uPsXc3X+3t2V2RURkSFmbXAsIjOXu28zszuAQ83sYe7+50KRk9P19btY/yBwHXCdmV0J/Bp4DvBFd99uZjcBjzCzpe6+cRfvxqiO3n8R12mxDxGR3YoG5InIdLmQ6N7wUTOr/1RjZnsA/5Ir0xQzO87M9m6wq7atO7ftE8RQgQvNbKeuG2a2xMyUVRYRmYNmbeZ4oC8Nuitlg22qaUxONXWBqPZkY3pqg3IGLMYRlcq5Lhe9aWBdJY6rLMj2WZoPuTZ+rzLYWt/X3hHdKvsGY9W99nI2RqmrIx76ntTVI/6OLhCl1BekpS17etrSmgTVtGpeX39vfd/CrtjX2hrlBway+zWY5l+uDkbsUVutL3ZqCleZVh8DngacCvzRzH5EzHP8QmAv4CPu/psx1PcS4PVm9ivgdmATMSfys4gBdp+qFXT3C81sJfA64A4zq82msZSYF/lE4EvAa8Z1D0VEZLcza4NjEZnZ3L3fzE4B3kIEtmcRg/b+SMxV/I0xVvkNoB14AjFLRCewFrgY+Li731g4/+vN7MdEAPwUYvDfRiJI/ijw1V28azXLV69ezcqVDSezEBGRUaxevRpg+VSf13IzHImIyAQxsz6gTAT7IjNRbaGaRtMpiswExwAVd5/SGQSUORYRmRw3wvDzIItMt9rqjnqNykw1wgqkk0oD8kREREREEgXHIiIiIiKJgmMRERERkUTBsYiIiIhIouBYRERERCTRVG4iIiIiIokyxyIiIiIiiYJjEREREZFEwbGIiIiISKLgWEREREQkUXAsIiIiIpIoOBYRERERSRQci4iIiIgkCo5FRERERBIFxyIiTTCzA8zsQjO7z8z6zGyNmX3KzJaMsZ6l6bg1qZ77Ur0HTFbbZW6YiNeomV1mZj7CpWMy74PMXmb2AjM738wuN7Ot6fX01V2sa0I+j4fTMhGViIjMZmZ2GHAlsBfwfeAW4DjgTcBTzeyJ7r6hiXqWpXqOAH4JXAwcCbwCeIaZneDud07OvZDZbKJeoznnDbN9cFwNlbns3cAxwHbgXuKzb8wm4bW+EwXHIiKj+3fig/iN7n5+baOZfQJ4M/AB4DVN1PNBIjD+pLu/JVfPG4FPp/M8dQLbLXPHRL1GAXD3cye6gTLnvZkIim8HTgIu3cV6JvS13oi5+3iOFxGZ1czsUOAOYA1wmLtXc/sWAPcDBuzl7jtGqGce8BBQBfZ19225faV0juXpHMoeS9Mm6jWayl8GnOTuNmkNljnPzFYRwfHX3P3vx3DchL3WR6I+xyIiI/vrdP2z/AcxQApwrwC6gMePUs8JQCdwRT4wTvVUgZ+lmyePu8Uy10zUa7TOzE4zs3PM7C1m9jQza5+45orssgl/rTei4FhEZGQPT9e3DbP/z+n6iCmqR6RoMl5bFwMfAj4O/Ai428xesGvNE5kwU/I5quBYRGRki9L1lmH217YvnqJ6RIom8rX1feBZwAHELx1HEkHyYuASM3vaONopMl5T8jmqAXkiIuNT65s53gEcE1WPSFHTry13/2Rh063AO83sPuB8YlDpjye2eSITZkI+R5U5FhEZWS0TsWiY/QsL5Sa7HpGiqXhtfYGYxu3RaeCTyHSYks9RBcciIiO7NV0P14ftYel6uD5wE12PSNGkv7bcvReoDSSdt6v1iIzTlHyOKjgWERlZbS7Ov0lTrtWlDNoTgR7gqlHquSqVe2Ix85bq/ZvC+USaNVGv0WGZ2cOBJUSAvH5X6xEZp0l/rYOCYxGREbn7HcQ0a8uB1xd2n0dk0f47P6emmR1pZkNWf3L37cBXUvlzC/W8IdX/U81xLGM1Ua9RMzvUzPYv1m9mewBfSjcvdnetkieTysxa02v0sPz2XXmt79L5tQiIiMjIGixXuho4npiT+DbgCfnlSs3MAYoLKTRYPvpqYAVwKvBgqueOyb4/MvtMxGvUzM4g+hb/ilhoYSNwEPB0oo/ntcAp7r558u+RzDZm9hzgOenmPsDfAncCl6dt6939banscuAu4C/uvrxQz5he67vUVgXHIiKjM7MDgfcSyzsvI1Zi+h5wnrtvLJRtGBynfUuB9xD/JPYFNhCj///V3e+dzPsgs9t4X6Nm9kjgrcBKYD9icNM24Cbgm8B/unv/5N8TmY3M7Fzis2849UB4pOA47W/6tb5LbVVwLCIiIiIS1OdYRERERCRRcCwiIiIiksy54NjM1piZm9mq6W6LiIiIiMwscy44FhEREREZjoJjEREREZFEwbGIiIiISKLgWEREREQkmdPBsZktNbNPmNldZtZnZmvN7L/MbN8RjjnZzL5jZg+YWX+6/q6Z/fUIx3i6LDezFWb2ZTO7x8wGzOx7uXJ7mdlHzexGM9thZr2p3JVm9l4zO3iY+vc0sw+Z2Z/MbHs69kYz+0BacEBEREREmjDnFgExszXAwcBLgfenv7uBMtCeiq0BHuvumwrHvh94V7rpwBZiSc3aCkMfdvd/bnDO2oP8MuBzQBex6lAr8FN3f04KfH9LrJgFUAG2Aotz9b/W3T9XqPtJxPKJtSC4Px3bmW7fQyz3eesID4uIiIiIMLczx+cDm4g1uOcB84FTgc3AcmBIkGtmf0cWGF8A7OXuS4A9U10A55jZ349wzn8HrgEe6e4LiSD5rWnfe4jA+HbgRKDN3ZcSQe4jiUD+gUKbDgb+lwiMvwAcmcrPA44GfgIcCHzHzMrNPCgiIiIic9lczhyvAx7h7hsK+98KfAy4y90PTdsMuA04HLjY3V/coN6vAy8G/gIc6u7V3L7ag3wncLS79zQ4/mZgBfB37n5Jk/flq8DpwGfc/U0N9rcBVwPHAC909281U6+IiIjIXDWXM8efLwbGSa0P8CFmNi/9/WgiMIbI4DZyXro+GDhumDIXNAqMk63petj+znlm1gm8MN38RKMy7t4P1ALiU5qpV0RERGQua5nuBkyja4bZvjb392JgB/DYdPshd7+p0UHufquZrQX2T+WvalDstyO050fA8cC/mdnDiKD2qhGC6ccBbenv30Vyu6Fa3+MDRzi3iIiIiDC3M8fbGm10997czdZ0vWe6XsvI7i2UL3pohGP/Dfh/RMD7OuCXwNY0U8XbzWxxoXw+w7z3CJeFqUzXKG0XERERmfPmcnC8K9pHLzKiynA73L3P3U8FTgA+QmSePXf7NjM7JndI7bnb5O7WxGXVONsuIiIiMuspOG5OLeN70CjlDiiUHzN3v8rd3+HuJwBLiEF+dxPZ6C/kiq5L10vMbJ9dPZ+IiIiIZBQcN+f6dD3PzBoOtjOzI4j+xvny4+LuO9z9YuAf06aVuUGC1wKD6e/nTcT5REREROY6BcfN+QMx/zDAO4cpc266XkNMnzYmadq14dQG5RlpEJ67bwO+nba/28z2HqHuFjObP9Y2iYiIiMw1Co6b4DEZ9LvTzVPN7HwzWwZgZsvM7DNE9weAd+fnOB6DG83sg2Z2bC1QtnAc2SIj1xRW7TsH2LaJyIkAACAASURBVEgMzrvSzJ5rZvV+0WZ2uJmdDawmZrcQERERkRHM5UVATnb3y4YpU3tQDnH3Nbnt+eWjq2TLR9e+ZIy2fPSQ+gplNqe6IAbubQEWkM2YsR54srvfUDjuWGJu5v3SpsF07HyGDiBc5e6/anRuEREREQnKHI+Bu78beDLwfSJYnQ9sIKZge0qjwHgMTgU+BFwB3Jfq7gduAD5MrOZ3Q/Egd7+GWDb6HcCVxBR1i4muGNcSU8Qdq8BYREREZHRzLnMsIiIiIjIcZY5FRERERBIFxyIiIiIiiYJjEREREZFEwbGIiIiISKLgWEREREQkUXAsIiIiIpIoOBYRERERSRQci4iIiIgkCo5FRERERJKW6W6AiMhsZGZ3AQuBNdPcFBGR3dVyYKu7HzKVJ521wfEND+AAQ5bHNovrtK2KZftSsZJXAGgrZ/s621KC3atRTa7OtpYyALXiLblHtKUcdXW2xs5SKUvU9/ZHXYPV7DyDg7GtVI3rSroGGPQ4diCV7+7rz5peqaY2R1uslLtf1M4d1+vXr6/v2bplMwAnP+Go/AEiMjEWdnZ2Ll2xYsXS6W6IiMjuaPXq1fT09Ez5eWdtcFwzJDjO/009Hm64r5QLMKtp3+BgJd3OBbkDEZiWLcp0dmb7Omt11GLyanaOavrbs/iXagqGvb4xa0OtqpKlQDjXIcbKLUNKV3NBdb2Ml9PxuTb4wE7lRGTCrFmxYsXS6667brrbISKyW1q5ciXXX3/9mqk+r/oci8iEMLPlZuZmdtF0t0VERGRXKTgWEREREUlmbbeKWvdis+G70xo776t1p8gfV6lEdwr32Oa548zi+4Wn7gqDlaxLQ5VCX+Ncz43aeXLFsVSutVTrx5xrQyrXkrp4tLeWd2rD4GDsGxjIukvU2m6pfR1t2XEdLfpuJDKZbly7heXn/HC6myEiMi3WfPgZ092EXaLoSEREREQkmbXBsVMYcDfG8tWq1y+1na0t5biUrX5pKUFLKQbklc2hWq1fSjglHK/GpX4Sz5+nWr+4O+6OmWFmlErZpaUcl462Eh1tJeZ3lOuXjlajo9WgOgjVQUru9Yt5FfMqLSWjpWSsuf32+uWbX/kK3/zKVybg0RYZKvU/vtjM1ptZr5lda2bPbFCu3czOMbMbzKzbzLaa2eVm9qJh6nQzu8jMjjCzS8zsQTOrmtmqVOZQM/u8md1uZj1mttHM/mRmnzOzZQ3qfLGZXWpmm1I7V5vZu82sfVIeGBERmfFmbbcKEZk2BwNXA3cCXwGWAqcB3zezp7j7pQBm1gb8FDgJuAX4LNAFvAC4xMwe7e7vbFD/YcDvgNuArwGdwFYz2xe4hphb+EfAt4EO4BDgpcAFwIZaJWb2ReBM4F7gO8Bm4PHA+4Anm9kp7j442p01s+GmozhytGNFRGTmmbXBcS0lXmm4N1K3pSGp5dSfOPXpreTSu1k/5LjdOnQOuCHna8lNAVebD3mg4un4/PRwNuQasundBirx/7hayRL7nuY3ttqmXOMrldiXpkkekgHP/k59nPuz/sh33XorIpNgFXCuu59X22BmXwd+ArwduDRtfisRGP8YeHYtEDWz84jg+p/N7AfufmWh/icBHyoGzmZ2FhGIn+3uny7smwdUc7fPIALj7wKnu3tPbt+5wHuA1wND6hERkdlv1narEJFp8xfg/fkN7v5T4G7guNzmM4nvb2/JZ2jd/UEiewvwygb1rwPOa7C9ZqcZ4919Rz4ABt4EDP5/9u47ztKyvv//63PKtO2FZZfmAtIEaUsQMQp2DV/Lz+jPWBLRJPZuvoklRtBYHomxhGisSLCh0RiNJRqVoiAq1QALyMJSlmXZws7O7MycOeXz/eO67rJnzrTdqWfeTx7ncc/c13Vf93XOHGav85nPdV3Aq5rOE++9E3jZGPfIt72h1YMQDRcRkXmmbSPHIjJrbnL3Vn+0uR94PICZLQEeDWxx91aDyJ/H42ktym5290qL898DPgR8ysyeSUjZuBq4zXO7AZlZD3AKsAN46ygr2lSAE1oViIhIe2vbwXGpELdgzqUtJEuwJekO+V2Wm/95zO9mVyPZBS8usZYLuCdtJMuudea2nS7F5dOy5dpyqRDxXCO3M1+SVtFXDUG0fYYXSVwtNl8vZGvAJRvqFYjbR+e23UuWn0vOHHNs9u/9KSefjMg02D3K+RrZX6uWxePWUeom55e3KHuo1QXufq+ZnQlcADwLeEEsut/MPuru/xy/X0H4P+kgQvqEiIhISmkVIjIbeuNx7Sjl65rq5Y26EI27b3T3FwOrgDOAdxJ+z33SzP68qc0b3d3GekzqGYmISFto28hxd0cY9w8P5SKzyRdxVls+MBuDvOk8t/wGHOYhIpsEbz0XtS16/HxhyT1y/57GtryWRJCzvgzH0PFQdTg7F+sNVcuxL9nkOR/eE9qvhV6XOxZnfYjh68FKfzxRzvoQv7amjUwAli4fsbKVyIxw9z4z2wQcZWbHuPvvm6o8OR5v2M/2a8D1wPVmdg1wFfB84Ivu3m9mtwInmtlKd9+1n09jXCcduozr5+ki+CIiC5UixyIyWy4mfKz8RzNLt240s9XAe3N1JsTMzjSzg1sUJecGcuc+BnQAF5vZiNQNM1thZqdP9N4iItI+2jZyLCJz3keBZwPPA242sx8S1jl+EbAG+Ad3/+Uk2nsp8AYzuxK4C3iEsCbycwgT7D6RVHT3i81sA/B6YJOZJatprCSsi/wk4EvAaw/oGYqIyLzTtoPjQsxpSCbFAdlCxcl6wvmMwpia0JGkHeTSD6oxi8IaMaXB8gkZ4SVMJulVa1lZLf061KnnUi4qsaxSz/qXzM3rivfZu/P+tGzT7b8J9feG4NfSJevSsoFqqL8nrmF85pOempZ1dsaNvmLbw7nJeusOPQSR2eLuw2b2dODthIHtmwjZSzcT1ir++iSb/DrQCZwNnE7YHGQLcBnwT+5+S9P932BmPyIMgJ9GmPy3izBI/kfgK/v51EREZB5r28GxiMwsd9/MyIVf8uXntjg3RFh+7UNT0P6vCTvnTZi7fx/4/mSuERGR9ta2g+NCjJB25rKqOy2cK8RjfvJcNU6Mqw/0AeCkKZB09CwFsh3uOvI3ilFoj9P9qtm0v3SZt3o17DEwOJClPHrsX3452L7eRwB4+K6NANx506/Sskd2bAHguGMeDcA1v8r+2vyL60JA7LQnhojxsY95bFrWe8/dAOyNbe/cel9adsctNwPw8lf9/4iIiIiIJuSJiIiIiKTaNnLcWYobdlgWyS3Fr/u2PwjAfbf9b1o2uHt7qE/I2+0fTnezZajYA8CKgw8HYPWqLFd36bKwHFpHVzcA9dz9tj90LwB33XA1APduylarqlfCBl/dHVkc+v77Nod6998FQGVgKC2rDIT6v/99iAT37t2Tlj340MPhi+tCXvKiZdkSbTt37ABg6z1hE7KDVy5Ny7Y9vA0RERERyShyLCIiIiISaXAsIiIiIhK1bVpFKU6G6yhl4//t94e0hiu/+QUA6jseSMu6lywBoDeu73bj7XenZXfeFybDHRGXPnvCGRvSsnIppEUUCiGNo1DM3W9buG5g90MA7H5kd1p2372hbO9wNiFvZ1+YDLgrLslWrWVt1fr2ArAn1ulYmu2QZ53hx7hrT0ihOOSQbB+EE48/FoA7loSd8jpL2dJxmzbdiYiIiIhkFDkWEREREYnaNnJcTObFNbKJdb+68n8A2HHvHQA8alU2Oe3WTfcAcO3GMInu/p3ZhLfh4bDM26IQfKV3+5q0rBaXgNueTIqrZxPyko8e3UvChL5iKZt8t+aQQ8N9tu9Kz+3d3RuOQ2HyXdWz+h2lcPNyd2hroJ4tNddfrcXnHCLOmzbdlZYtWxye46Z7wvMql7JI9VC1ioiIiIhkFDkWEREREYnaNnK8ZFE47trWl567/rfXAuAPhRzg+zffm5Zdd1fIAd6yO2zY0ShmL025EPJ0Byoh0nrVb3+Xlh20enVosxFylR/a+nBatncotOXlEAGuDmZLsy2LOc75jahrtRABtnq4j1vWh6FiiBzvqoX7eFdXWtbRE85VhsJ1v7zqyhH32XJfyKH2WiUtW3NQtuSbiIiIiChyLCIiIiKS0uBYRERERCRq27SKr37lWwDs2JqlTvzvLbcA0N0fdsNbsWxZWrZ4RUgx6PGQhtHbvzcts0ZIfnh4x04gS6EA2L471BuuhYl5/f39adlwnJxXi59BypZ9FukfCikUTjaBb6ga7lMohZSJ8uLVadneOAFvS5ys19OR/ejWrgjPY8f9mwHY+sD9adnKE44Px1UrAajn0iq6e3oQERERkYwixyIyp5jZZjPbPNv9EBGRhaltI8dDcXmzzfdnUdQH4nJrRy7rBuCwRx2RlvXd+yAAnf2D8Uy2WUbDYwQ4RoKLhc607JE9IVJcqVVj3awPDUKE2WKguVDIIs7VRmir7tkFVUJ0uNQTll877MQz07IdlRBV3nJvWKZtsFDOrvNw3WGHhudz4rHHpmUHrVoRXocHQgR9uJJNCrR6fjqgiIiIiChyLCIyTW7Z0jvbXRARkUnS4FhEREREJGrbtIrHnnwqAIN7dmYniyH9YG+cULdsxcqs6N4HAKjF9Ag8S4GwuMbwcExD8OFssl4xtplmTFiWJpGcSso8t6pxPcm/KGXpEXFOH0tWHwLAQYcflZbt2RYmES5atTZcP5SlRxx8aKh/1IqwuPPynu60bHg4TMDr7Az3ue++e9Ky3Ttzr43IDDIzA94AvA44GtgJfAd4zxjXvAR4NXAq0A3cA3wV+Ed3r7SofzzwTuCpwBpgN/Az4EJ3v6Op7iXAK2JfzgP+EjgG+LW7n7v/z1REROabth0ci8ic9gngzcBW4HNAFXge8DigAxjOVzazLwKvAh4A/oMw0D0L+ADwVDN7urvXcvWfFeuVgf8C7gIOA14AnGdmT3b3G1r065PAE4EfAD9k3316RERkAWjbwfFX/u1SAAb2ZDvWGeHfzoF6eNq7+7Ng087ePQD0DYd/C5etODgtW33QQaF+3/bYZhZxHR4K/4bXhuOEvPwktzgTr7MrRHSL5WJaVI1LqhXqWYS6VAg76Z1yapiI1zuQLQu3/e7fA9DRHdoaqOTuEyf3DcWo989+/qu0aGggPK+exWF5uKFq9pyto21//DKHmdnZhIHxJuBMd98Vz78HuBxYB9ybq38+YWD8HeBl7j6YK7sAeB8hCv3JeG4F8HVgAHiSu9+Wq38i8GvgC8DpLbp3OnCau9/Tomy053P9KEXHT7QNERGZO5RzLCIz7ZXx+MFkYAzg7kPAu1rUfwtQA16VHxhHHyCkZLwsd+7PgOXA+/ID43iPW4HPA6eZ2WNa3OsfJjMwFhGR9tO2ocPbbr0VgBVLs5zeZOOMzviRoJjblKPYEfJ0jzzuaABOOumstGzd4WGJtDXrwqYcg32PpGWb7w7/jj4SNwjZsX1HWta/ZzcAu7ZvBaC3N4s4lzvDBhylYta/w9ccBsCqrtCXu274XVpWeTC00YhR6O5SR1rWF9v/9W33ATDQl+VEd5bjjzhGtvv6B9KyUqFtf/wytyUR2ytblP0CyKdH9ACnADuAt5pZi0uoACfkvn98PJ4SI8vNkrUOTwBuayr7zVgdb8XdN7Q6HyPKraLTIiIyh2l0JCIzLdmacltzgbvXzSw/U3QFYW7rQYT0iYlYFY9/OU69xS3OPTTBe4iISJtSWoWIzLRk8d+DmwvMrEg2uM3XvdHdbaxHi2tOGeeaf2vRN29xTkREFpC2jRwf95jwV9aD4vJmAEN9Ybe8xt4wSW3btixw1VcJk9pe9crXAPCUpz0/LasXw8tUiBPqCnGnPIB6LUyMq1bCRLfBgSwl0ivh62995bMAfP1rl6RlJ554UuxDloZx7Anh3Nq1awBYsSzre3cpfI5JJuSXy9kufR7XgEs+6fQPZGkVQ+WQttER+zw0kC0C0FVu+Sdqkel2AyHd4Bzg7qayJ5L7veTu/WZ2K3Cima3M5yiP4Vrgj2Nbvxun7rQ66dBl41cSEZE5RZFjEZlpl8Tje8wsXWzczLqAD7eo/zHC8m4Xm9ny5kIzW2Fm+dzeLxGWenufmZ3Zon7BzM7d/+6LiEg7a9vI8Z+/7k0AVPZmk+d2brsTgM03XwfAtu1ZEKpzafg3+oTHngZAubsrLatVQ9R1OAaMC43sM4UVCrF+mCBX7lqSli2Kc+bK3eHcmkOOSMv+5OXnA3Dpv30lPbdyTdjM48jHhBWgHtqTbT1biZMHb7kjPIdaKYv6FjuTpeLCJL+havaX4aVdIcLciCu/NWq5TUoUOZZZ4O5Xm9lFwJuAW8zsW2TrHD9CWPs4X/9iM9sAvB7YZGY/Bu4DVgJHAk8iDIhfG+vvNLMXEpZ+u9bMfgbcCjSAIwgT9lYBXYiIiDRp28GxiMxpbwHuJKxP/BqyHfLeDdzcXNnd32BmPyIMgJ9GWKptF2GQ/I/AV5rq/8zMTgb+CngmIcViGHgQ+Dnw7Wl5ViIiMu+17eD4oMMPBWDPrmwr5aqHp9vfH3KBC8UscPToxz4WgLWHhOXUPEsrphyXjyrEraEt28uDbNdoj9dlF1ZjBHf7jhChXn/0sWnZhj8IS8X96L9/np7b+UiIFO/aFY6H5iLNRz3quFj2NQB2D2ZLsp31hKeG6x8KW2D/4VOelZZtidtF33BN2BhkaU9PWtYwbf4ls8PdHfiX+Gi2fpRrvg98fxL32Ay8cYJ1zwfOn2jbIiLSvpRzLCIiIiISaXAsIiIiIhK1bVpFLWY3eG7V0rqHZc36hsJyaL0D2V4DJ69aC8CSnjC5bXAouy75BFFIGxv5mSKd2lbIci68Vo2nwst8ZC6t4qC1IX3jqKOOSs/9/s7fA7B2zToABpZny651dIT9CtYdEuoP3HNnWrbusJB+seEP/gCAJ/1hNkH/C5/6BAC333gDAEuXZ2kVHV36bCQiIiKSp9GRiIiIiEjUtpHjYjFEeculWnru4DVhubbFy0MUth6XXwOo1UOo2OphklqpmP/cEM5ZnKXXcgutdGZetjza8HCI/HYvCtHaE058bFpW7gz3fvSxx6Xndm5/GICTTzk5NNWV9e+Ou+4DoFINz+ekx2TXnXlGaPdXv7wKgP94IIsq79oedsM983EbANjdmy1ft7evr9UzEREREVmwFDkWEREREYk0OBYRERERido2raIQ0yO6OzrTc+vXHw3AvUeE4zFLl6ZllTgDb0/vbgAWL1uVltWTHeeSlIncIsgWz3mcrFcsZhPy9vTuCWUWXub1R2WpEMNhrh6HHn50em7JsjsAqMYd+ZYtz9Zo9no4NzSwN5yIEwcBLvvCZwH47a9+CcBAUgdYFOu5h9djcCDbMfCwtcsQERERkYwixyIiIiIiUdtGjotxSbWO7iw6fPqZTwJg24NbAejrz3aZ2/ZIPwD33Xs/ACedmkWOa/FlihvkUShkk+4SjUYoLBSzst49IYI7VK8AsHjFkrSsHj+WLFu5Mj03HKPDO3aFJeZ29GVLzf3m19eEOkNhEt11v74hLStXQ7S7I11zLvux9vSEyPmyFeE+tcritGz1iiyqLiIiIiKKHIuIiIiIpNo2cnztTd+NX2WR3O5y+Cyw/FHhaQ9vzSLHK3pCEvBV1387lHXtyBrzUL+/L0SXO3JLrHV1huhrrRaWWKsMZxt33HP3XQBs33MLAL+5+ftp2cO9jwZg7+496bltj2wE4KdXfgOAnqVdadmNv7sWgFJ5OwCHHZ59runqCLnDxbjZiFlWFrtHqRTuU21k/dv0QBaZFhERERFFjkVEREREUhoci4iIiIhEbZtWceVvvwjAwGAlPVcgTHjriukVi3qyCWnFzlD2UF/YXe7Hv/hdWuaNMLlvcO9gqFvKPlMU4k56Q0NhKbihSna/SiWc857Q9rU3fyMtu2ljWGKtUa1nbS0KaRubH3wAgO49Wf+WrgwpIKtXh+XdVizOJta5hTaG07ayPfyq1ZBG0Vkux2Nu+brKakTmGzPbDODu62e3JyIi0o4UORYRERERido2clythGXUkmgxZBthDAyFY7WeRXmHh8OEOo/1+3uzyXqNRiNeHyKy9Xr2maIYI7L1ONGt3JWVlbvDZMBKNUz2K5T6sus6wrliMetfqRy+LpeK8b5Z/a6e0G5HrFMgizgnm5KU4lJwxVL2YzULkeZy3AzFLNukZInps5GIiIhInkZHIiIiIiJR20aOC43w1Mr5/OD4ZTVGcqvVLDe3UgmR487OJMKaRXSHhkMU2uOqcNVGNS3rJkRihwbD9aVc1LYjft1RDcdCPtgbo9iNenafWtzyuh4j1cPDlVz90Neenp74XPLPq7DPdaWsyXR764GB0Fb+01BXqYzIXGThjfsG4HXA0cBO4DvAe0ap3wm8DXgp8GigBtwMXOTu3xyl/TcDrwGOamr/ZlBOs4jIQtW2g2MRmdc+QRi8bgU+B1SB5wGPAzqAdMFuM+sAfgycA9wOfAroAV4IfMPMTnX3dze1/ynCwPvB2P4w8FzgTKAc7yciIguQBsciMqeY2dmEgfEm4Ex33xXPvwe4HFgH3Ju75B2EgfGPgOe6ey3WvxD4DfAuM/u+u18Tzz+RMDC+E3icu++O598N/BQ4pKn98fp7/ShFx0+0DRERmTvad3AcUybq1Vp2qhHSFpKUBitkO90VCV/XKnFSWzGbuFb0UNYRJ7V5LhWC4XCfMiHdwYazVI0uD/W7O5eH+9ezvtQboZ51ZIkOdQvnBipxMmC2uR8d5fCjKpXDrnlJugRATznu0jdcjZdlbVojfF0uhhSKSmUwLUtSNUTmmFfG4weTgTGAuw+Z2bsIA+S8VxHWL3x7MjCO9R82sw8AXwD+ArgmFr0i1/7uXP3h2P4vp/TZiIjIvNK+g2MRma9Oj8crW5T9gpBPDICZLSHkGG9x99tb1P95PJ6WO5d83WoQfG2+/Ylw9w2tzseI8umtykREZO5q28FxMS63lizDBlCIM+qKxRAJHqrkJsMNhqjr3r1h+bTFi7vTsp5FISrcGV+uQm6TjWQCXrEc2rZGvixGo+M/tf392fJw3hHqey6zsVGIy7TFJdaWdGcbfRAjxaW4FJvn7tMYCjewOKnQa1lZRylElVcuDc+hv5hFnPfEiYYic8yyeNzWXODudTPb2aLu1lHaSs4v38/2RURkgdFSbiIy1/TG48HNBRYW6l7Vou7aUdpa11QPYM8k2hcRkQVGg2MRmWtuiMdzWpQ9kdxfvNy9jzBx71AzO6ZF/Sc3tQlwYzz+YYv6Z9HGf1ETEZHxte0/Av27+wFoNLLFhdccfBAApWL4TDDYl871YUnc6W7F6lDHLEtNKBZCKkMhzpBrFHIpDfHrwWpYRzi/zvFA3yOhbE9cYziX0pCkX/QsydI3knWRS52hLx0d2YTBSiW0UUx2tct9rGnEiX7FeF3dspTJWix7eMfDse3OrKySW3hZZO64hDCB7j1m9t3cahVdwIdb1L8Y+CDwj2b2xx5n3JrZauC9uTqJSwmT+JL2e2P9DuBD0/B8RERkHmnbwbGIzE/ufrWZXQS8CbjFzL5Fts7xI4zML/4o8OxYfrOZ/ZCwzvGLgDXAP7j7L3PtX2lmnwNeDdxqZt+O7T+HkH7xIOT2nd9/6zdu3MiGDS3n64mIyDg2btwIsH6m72tazktE5prcDnlvYN8d7N5Nix3sYlT57YQd8o4m2yHvU+7+9RbtF4C3EHbIO7Kp/QeATe5+6gE+hwpQTPorMkuS9bZbreYiMlP29324Htjj7kdObXfGpsGxiEgU85bvBC5z95ccYFvXw+hLvYnMBL0PZS6Yb+9DTcgTkQXHzNbG6HH+XA9h22oIUWQREVmAlHMsIgvRW4GXmNkVhBzmtcBTgcMI21D/++x1TUREZpMGxyKyEP0PcArwDGAlIUf5TuCfgU+48s1ERBYsDY5FZMFx958BP5vtfoiIyNyjnGMRERERkUirVYiIiIiIRIoci4iIiIhEGhyLiIiIiEQaHIuIiIiIRBoci4iIiIhEGhyLiIiIiEQaHIuIiIiIRBoci4iIiIhEGhyLiIiIiEQaHIuITICZHWZmF5vZg2ZWMbPNZvYJM1sxyXZWxus2x3YejO0eNl19l/YxFe9DM7vCzHyMR9d0PgeZ38zshWZ2kZn9wsz2xPfMV/azrSn5vTrVSrN5cxGR+cDMjgauAdYA3wVuB84E3gI8y8ye4O47J9DOqtjOscDPgcuA44FXAueZ2ePd/e7peRYy303V+zDnwlHO1w6oo9Lu/hY4BegHHiD8Dpu0aXg/TxkNjkVExvdpwi/wN7v7RclJM/sY8Dbgg8BrJ9DOhwgD44+7+9tz7bwZ+GS8z7OmsN/SXqbqfQiAu18w1R2UBeFthEHxXcA5wOX72c6Uvp+nkrn7bNxXRGReMLOjgE3AZuBod2/kypYAWwED1rj73jHaWQRsBxrAOnfvy5UV4j3Wx3soeiz7mKr3Yax/BXCOu9u0dVgWBDM7lzA4/qq7v3wS103Z+3k6KOdYRGRsT4nHn+R/gQPEAe7VQA9w1jjtPB7oBq7OD4xjOw3gJ/HbJx9wj6UdTdX7MGVmLzazd5rZ283s2WbWOXXdFRnTlL+fp5IGxyIiYzsuHu8cpfz38XjsDLUjC9N0vH8uAz4M/BPwQ+A+M3vh/nVPZFLm9O9DDY5FRMa2LB57RylPzi+foXZkYZrK9893gecAhxH+mnE8YZC8HPiGmT37APopMhFz+vehJuSJiByYJG/zQCdwTFU7sjBN+P3j7h9vOnUH8G4zexC4iDBx9EdT2z2RSZnV34eKHIuIjC2JYCwbpXxpU73pbkcWppl4/3yBsIzbqXFSlMh0mdO/DzU4FhEZ2x3xOFru2zHxOFru3FS3IwvTtL9/3H0ISCaLLtrfdkQmYE7/MpINaQAAIABJREFUPtTgWERkbMkans+IS66lYnTtCcAgcO047Vwb6z2hOSoX231G0/1E8qbqfTgqMzsOWEEYIO/Y33ZEJmDa388HQoNjEZExuPsmwjJr64E3NBVfSIiwXZpfi9PMjjezfXaNcvd+4Mux/gVN7bwxtv9jrXEsrUzV+9DMjjKzQ5vbN7PVwJfit5e5u3bJkwNmZuX4Pjw6f35/3s8zSZuAiIiMo8U2pxuBxxHWJL4TODu/zamZOUDzJgstto/+DXAC8Dzg4djOpul+PjI/TcX70MzOJ+QWX0nYhGEXcATwR4T8z+uAp7v77ul/RjIfmdnzgefHb9cCzwTuBn4Rz+1w97+KddcD9wD3uvv6pnYm9X6eSRoci4hMgJkdDryfsL3zKsIOTv8JXOjuu5rqthwcx7KVwPsI/7isA3YSVgb4O3d/YDqfg8x/B/o+NLPHAu8ANgCHECY+9QG3At8EPuvuw9P/TGS+MrMLCL/DRpMOhMcaHMfyCb+fZ5IGxyIiIiIikXKORUREREQiDY5FRERERCINjkVEREREogU1ODYzj4/1s3Dvc+O9N8/0vUVERERkYhbU4FhEREREZCyl2e7ADEu2K6zOai9EREREZE5aUINjdz9+/FoiIiIislAprUJEREREJJqXg2MzW2lmrzCzb5vZ7WbWZ2Z7zew2M/uYmR0yynUtJ+SZ2QXx/CVmVjCzN5rZb8xsdzx/aqx3Sfz+AjPrMrML4/0HzexhM/u6mR27H89nsZm9yMy+ama3xPsOmtldZvY5MztmjGvT52RmR5jZ583sATOrmNk9ZvZRM1s6zv1PMrOLY/2heP+rzey1Zlae7PMRERERma/ma1rFuwnbXyb2AN3ACfHxcjN7mrv/bpLtGvAfwPOAOmFLzVY6gcuBs4BhYAg4CPgT4Llm9mx3v2oS9z0fuCj3fR/hg8vR8fFSM3u+u/90jDZOAS4GVuauX094nc4xs7PdfUSutZm9Efgk2QelvcBi4Oz4eLGZnefuA5N4PiIiIiLz0ryMHANbgI8ApwNL3H0ZYcB6BvBjwkD1a2ZmozfR0gsI+3u/Hljq7iuAg4G7m+q9DjgZeAWwON7/NOAGoAf4ppmtmMR9dxIGx2cDy919KdBFGOh/FVgUn8+iMdq4BLgJeGy8fjHw50CF8Lr8ZfMFZva8eN9BwgeOg919MeGDxjMIExjPBT4+ieciIiIiMm+Zu892H6aUmXUSBqmPAc519ytzZcmTPdLdN+fOXwC8L377Gnf/3ChtX0IYEAO83N2/2lS+GrgdWAW8193/Pld2LiHafK+7r5/E8zHgJ8DTgPPd/d+aypPndCuwwd0rTeUXAW8ELnf3p+TOF4FNwKOAF7j7d1rc+0jgfwkfPI5w960T7beIiIjIfDRfI8ejioPD/4nfPmGSl+8kpCaM517gay3uvQP4bPz2hZO8d0sePr38IH471vP5WPPAOPrPeDyp6fy5hIHx5lYD43jve4BrCek3506wyyIiIiLz1nzNOcbMjidERJ9EyK1dTMgZzms5MW8M17l7bQL1rvTRQ+5XElIUTjKzDncfnsiNzeww4E2ECPHRwBJGfngZ6/n8dpTzW+KxOc3j7KRNM3tojHaXxePhY9QRERERaQvzcnBsZn8CXAokKyk0gF5Cfi2EgfKi+JiM7ROst2UCZUXCgHTbeI2Z2TnA9wn9TvQSJvpByAFeytjPZ7TJg0kbzT/rdfHYQcirHk/PBOqIiIiIzGvzLq3CzA4CPk8YGH+DMNmsy91XuPtad19LNoFsshPy6lPRxUlVDkulfYUwMP4pIRLe7e7Lc8/n7fvT9jiSn/133N0m8LhgCu8tIiIiMifNx8jxswkDyduAl7p7o0WdiURCD8RY6Q1JRLYOPDKBth4PHAbsAp43ypJp0/F8koj2Y6ahbREREZF5ad5FjgkDSYDftRoYx9UdntJ8foqdM4GyWyaYb5w8nzvHWEv4aRPu2cT9Kh6PM7MTp6F9ERERkXlnPg6Oe+PxpFHWMf5LwoS26bTezF7SfNLMVgKvjt/++wTbSp7PMWbW1aLNZwBP3q9eju1nwH3x64/Hpd1amuSazSIiIiLz1nwcHP8UcMLSZP9sZssBzGypmf1f4FOEJdmmUy/weTN7uZmV4v1PJtuA5GHg0xNs62pggLA28qVmti62121mrwK+zTQ8n7hb3psIr+XTgZ+Y2eOSDxxmVjKzDWb2EUZugiIiIiLSlubd4Njd7wA+Eb99I/CIme0i5Oz+AyEi+plp7sa/EjbH+DLQb2a9wM2EyYEDwIvcfSL5xrj7buBd8dsXAQ+a2W7ClthfBO4CLpza7qf3/h5hF71hQirKtcCAme0grHJxHfA3wPLpuL+IiIjIXDPvBscA7v52QvrCjYTl20qErZPfCpwHTGSt4gNRIaQ6vJ+wIUgHYRm4y4DT3f2qyTTm7v9M2Lo6iSKXCDvtvY+wHvFoy7QdMHf/EnAc4QPHrYTXbhkhWn058FeEdaRFRERE2l7bbR89nXLbR1+opc1ERERE2s+8jByLiIiIiEwHDY5FRERERCINjkVEREREIg2ORUREREQiTcgTEREREYkUORYRERERiTQ4FhERERGJNDgWEREREYk0OBYRERERiUqz3QERkXZkZvcAS4HNs9wVEZH5aj2wx92PnMmbtu3g+DM/vKvFMhxNp2xkjSSUbpYVlktlAIYb4fqCZe0cuqIDgNWLOwHoKpfTsnq9DkB3ZxGAnu7s5S4UQ/sdpWJ6rqNksQ+h/WIx60NHbNZjHwaHamlZb38FgEd69wJQqWb929M/BMDeoVCnszP7Y0GjOgjAs885o8UrISIHaGl3d/fKE044YeVsd0REZD7auHEjg4ODM37fth0ci0h7MbMrgHPcfcIf5szMgSvd/dzp6tcYNp9wwgkrr7/++lm4tYjI/LdhwwZuuOGGzTN93wUwOPYRX2dR4ZHBZYvh5IJlEdZ6jNaW4nWrlmYv22GregBYsbgLgEYja3NwOLlLaGtvpZqWlWLEeCh3blFXaLerHMrKuagyNEL/Yrdy3UsjzB0dIYpd80bWdwudGK6Fcz09nWlZrZrdW0REREQWxOBYRBawE4CB2br5LVt6Wf/OH8zW7UVEptTmj5w3212YERoci0jbcvfbZ7sPIiIyv7Tt4LhQSPIORqZVtBZTLpI6lqUmNGI6RVcptJmfRNfwcK5vME6Qy23HPTQcJuQNDIVk8p7ubLJed9LPkV2go1yIbWeT7qpxkl2SalEsZn1InmtHR/hxDtdHpmoUCekfi7s60rKOolbyk7nBzJ4LvAV4DLAS2An8HviGu3+6qW4J+GvglcARwMPA14D3uvtwU90ROcdmdgHwPuDJwKOAtwLHA33A94F3u/tDU/4kRURkXtDoSERmlZm9GvguYWD8X8A/AT8kfIZ8ZYtLvga8CfgF8K/AIGGw/NlJ3vptwGeAm4FPAHfE+11jZgdN+omIiEhbaNvIsccZa5aPFnu9qU426T2ZiEecCO+5dd4snksm8vUPZW1u2toPQLkYznV3ZBHdai0uuzYcIsA9lez+y7pCWyuXdKXnSnFiXSku6Zafku+NGE2OE/7Kuahvd2eMGFfrsb9Z1HtRd2c8l7aUlnV2ZJFskVn0GmAYOMXdH84XmNnqFvWPBk50912xznsIA9w/M7N3TSLq+2zgce5+Y+5+HydEkj8C/PlEGjGz0ZajOH6C/RARkTlEkWMRmQtqwIjlU9x9R4u6f5MMjGOdvcBXCb/PzpjEPb+cHxhHFwC9wEvNrHPkJSIi0u7aNnKc38QjPUeM6nqLJdzS6klZI1cYzlXq4ZhbrS2NTFvMUa7tE6kOjQ7HphpDuVzgcsj97ezMcoDT4HXsX7GQi17HaHItRqMrw1k+ciW5QWygkfvMs2cgbAIyHKPWldzybcPVrA2RWfRVQirFrWb2DeBK4Gp33z5K/etanLs/HldM4r5XNp9w914zuwk4h7DSxU3jNeLuG1qdjxHl0yfRHxERmQMUORaRWeXuHwNeAdwHvBn4DrDNzC43sxGRYHff3aKZ5JNesUXZaLaNcj5Jy1g2ibZERKRNaHAsIrPO3S9197OAVcB5wBeBJwE/NrM103Tbg0c5vzYee6fpviIiMoctsLSKtDB+4bmypt3zbOTnhkJ8uXIJF2mbZmFyW6Oe3bcW0zBq9fwVwVDcsa5/MFt5KqxQRZr20d2Z9aGjKa1iMJeisXcotFVvJLvoZcGzWkzt2NYblpPLZWMwUNEOeTK3xKjwD4EfmlkBeBXwRODb03C7c4BL8yfMbBlwKjAEbDzQG5x06DKuXyCL5ouItAtFjkVkVpnZsyz9ZLiPJGI8XTvc/amZndZ07gJCOsXX3b0yTfcVEZE5rP0jxz7GudxGH0m01uKGGvnIc1dc8SzZBKQnF9Etxvp7KyEC3FnKyvqHwiS4RozeNnITAfdUwr1LuwfTc0OV8OPYG5dmW7Y4W2ptaU/4OokY13NtlZJ7xuXe6nuzsUQpTibsiW125fpeLuuzkcwJlwFDZvZLYDPhDzJPBP4AuB746TTd90fA1Wb2TWAr8IfxsRl45zTdU0RE5jiNjkRktr0T+BVhZYfXEzbiKAN/AzzZ3acr/+fj8X6nku2SdwlwdvN6yyIisnC0beQ43cSjxfC/EEPH+WntHeXwUiyJ2y135jbZ6InnvBESdhflll8rxXrD1Rhxzl23tCf8m95VDht9PNI/lJb1DoS/2NZy68INDoX2S4VwbveebNOQWjXJJw7fl0tZZLueLO9Wq+/Tp3DvEHFeuih8n98gZGn3ZCb2i0wPd/8MYae68eqdO0bZJYSBbfP5kZMPJnCdiIgsXIoci4iIiIhEGhyLiIiIiERtnFYRWG5GXiOddBe+L+aWPCvGVIRC3JWuoyO3JFtMV7D4WcILWWpCR5yt19mdpF5k9yvGJhbHslKpK+ufhxSKztykuOpwSMPoGwjHfGrHUFx2beni7tDPXFJIMjlvME4AzC/XNhh3xuuOE/K6O7NJfsnzEhEREZFAkWMRWVDc/QJ3N3e/Yrb7IiIic0/bRo6TpdlyK7lhcZKeJ5tz5MrqlfCdeXhJqtUscmwWIqwrl4SJeCXLorZdcSm3OCeOwXrWaiVGezviUmud5ezlXrtycbiumtXvjRuDVOOmIV0dWf0kxltLgtaFfOQ4nOwbDG3tzW0sUo7VkqXgOoq558WYc5VEREREFhxFjkVEREREovaNHLfSFE3OL6NWiInIlWo4N1TLIrod5aQsRGh3VXPLrsaVopJl1PJtenx5B4fDdR2etVmOEWfP5RUXYlS3Wku2ss6iw0mqcDEu89bILcmWRIr7BoZiH7Jc4tXLl4R7d4S2irnIcbG8sH78IiIiIuNR5FhEREREJNLgWEREREQkav+/q3uLUz6yMFnmrUqypFtWVouT8/qHwrmCZSkNxMl6g8NxElxujluyE18jTvLLp0J4qTiifnfcea/atOMdQFdHsgRbuKBvIJt0NxCXa4vZG5QK2Y+1VgspIAMx1aJUyD4PtXhpRERERBY0RY5FRERERKL2jxzvIwnT+j7f5Xl6zD43JFHlgTgRryO3jFpvjOAmy6nVc9HhZO5bPd4pvzlHTzlO0ivlIrkxupsEd/dWsgsacXm3jjgzL7+Bx95KKGvEPldrWR+GhpNJiLV97gFku6GIiIiICKDIsYiIiIhIqn0jx7ZvlDj/pbUIGVvTSfdcPnKy0UcMyDb2WQKuse91ua8bcSvqWtzWuZrt3Ey1Gs515SLHSVqxx0hz/2C2ZNxg7EMhnivkcoeHa3E5udhmMdeLvUNJG6FOPu95aDjLWxYRERERRY5FpImZXWFm0z5f08zWm5mb2SXTfS8REZGJ0uBYRERERCRq27SKFkkVI+vkUima0ypapWMk6Q4Na1Gtafe90Ic48S+WVRpZSkM97oxXrWcT5Drr4dxwXMqt6tlnl2SSXbkYJgN6btJdzKagnqR95IJ+Q7GtUnx+Q8O5VI3hfVNCRKI/A3pmuxPt4JYtvax/5w+mpe3NHzlvWtoVEVno2nZwLCL7x93vm+0+iIiIzJYFkFZh6aNgJQpWCmulFQo4lj6SOmbhgXvuwT4Pyz2SkwWDgkGp6OnD6/XwcMfdqdWzx1C1wVC1wcBw9his1hms1hmuhQdWSB+FQpFCoRhmE5rR8OyRKBWLlIpFioXsUa2HyPJgpcZgpcZwnfRRazi1xrSnlsocYGbnm9m3zexuMxs0sz1mdrWZvbxF3RE5x2Z2bswPvsDMzjSzH5jZrnhufayzOT6Wmdm/mNkWMxsys9vM7M028s8zo/X1WDP7iJldZ2bbzaxiZvea2efM7LAW9fN9OzX2bbeZDZjZlWZ29ij3KZnZ683s2vh6DJjZjWb2RjOtcygislApciyyMPwrcBtwFbAVWAX8EfBlMzvO3d87wXYeD7wL+CVwMbAayC970gH8FFgOXBa//2Pgk8BxwBsmcI8XAK8FLgeuie2fCPwF8BwzO8Pdt7S47gzgr4FfAV8Ajoj3/pmZnerudyQVzawM/BfwTOAO4GvAEPBk4CLgccCfTqCvmNn1oxQdP5HrRURkbmnfwXEMUlkuC7hS2RO+iPm6nYsXp2XZ8mcxp9eyl8ab4l2ea7MYA0zFYnK/LIfYYl5xvZ5sEJJdlywVV8gFqJLiYnIqF7tL8pCT2Ns+ga24nFwj5i/nl6HzGBmu1eMxt3lIvp60vZPcfVP+hJl1AD8C3mlmnxllwNnsGcBr3f2zo5SvA+6O96vE+7wP+C3wejP7hrtfNc49vgx8PLk+199nxP7+LfC6FtedB7zS3S/JXfMa4DPAW4DX5+q+hzAw/hfgre5ej/WLwOeAV5nZt9z9u+P0VURE2oz+dCiyADQPjOO5YeBThA/JT51gUzeNMTBOvCs/sHX3XcAH4revnEBftzQPjOP5nwC3Ega1rVydHxhHFwM14MzkREyZeCPwEPC2ZGAc71EH3kH4aPqy8foar9nQ6gHcPpHrRURkbmnfyLGIpMzsCOBvCIPgI4DupiqHTrCp34xTXiOkQjS7Ih5PG+8GMTf5ZcD5wCnACpI/6QSj7V5zXfMJd6+a2bbYRuJYQlrJ74G/HSUVehA4Yby+iohI+2nbwXH6z10xe4rb7g3Bs9uv/h4AT3nZ29OyQtfScF0SRNpnPs7oW+sliQlJ6sRE905I/kHOpzbU4hpx5bj7XaNeS8uSVeCS5d3cs7J6MqkuHhr7pG/ElIvkmE8JKSitYiEws6MIg9oVwC+AnwC9QB1YD7wC6Jxgcw+NU74jH4ltcd2yCdzjY8BbCbnRPwa2EAarEAbMjxrlut2jnK+x7+B6VTweA7xvjH4sHqNMRETaVNsOjkUk9XbCgPCVzWkHZvYSwuB4osb7RLXazIotBshr47F3rIvNbA3wZuAW4Gx372vR3wOV9OE77v6CKWhPRETaSNsOji1GX/MT3lasORyA/kd2AvDwXb9Nyw49JaYxNkZOaiskk/uSaG8Wl6aRhHRj9UIxK0uitklb+0yUixcM54YatUq4tlhIor3k6jdNMMzt31H3JArd2Kft0Ibvc32e4sYLxqPj8dstys6Z4nuVgLMJEeq8c+PxxnGuP4owF+InLQbGh8XyA3U7Icp8lpmV3b063gX766RDl3G9NusQEZlXNCFPpP1tjsdz8yfN7JmE5dGm2ofNLE3TMLOVhBUmAL40zrWb4/EP48oRSRuLgc8zBR/oPeQkXURYWeOfzaw5/xozW2dmjznQe4mIyPzTtpFjEUl9mrBKxL+b2bcJObwnAc8Cvgm8eArvtZWQv3yLmX0PKAMvJAxEPz3eMm7u/pCZXQb8CXCTmf2EkKf8dMI6xDcBp05BPz9AmOz3WsLayT8nvC5rCLnITyAs93bbFNxLRETmkbYdHHtMd9i9I9sJt7tnCQBLVx8CwD23XJuWrX306QB0dIW5Om659YqTBARP0iuy+yTZDcm5Ri7dIVljuNFIUhvyE+WSC3PB+9h+vd4iFSJdFzm5MLc+ctOxkcvHSO+dpH3kbtdRzM9Rknbl7r8zsycDf0/Y+KME3EzYbGM3Uzs4HgaeBnyIMMBdTVj3+COEaO1E/Hm85sWETUO2A98D/o7WqSGTFlexeD7wcsIkv/9DmIC3HbgHeC/w1am4l4iIzC9tOzgWkYy7XwM8ZZRia6p7bovrr2iuN8a9egmD2jF3w3P3za3adPcBQtT2PS0um3Tf3H39KOedsOHIl8fqp4iILCxtOzguxhBpdzlbjalUCSs9LVu6CID77872Rdh4/eUAnHzuC8P1jY5ca8kyaMnyaVnEtVBIJukRj1lo1goh+myNuCxrbqs9i/+Wey7S3Egn+I+cKpdM5mukY4DchYxcFq65zOKNSrlocXeHIsciIiIieZqQJyIiIiIStW3kOBn3l1cfnJ6xQljK7VGn9gPQ//D9aVnlwVsAeOTWsEdB9/Lsus6V6wEoFUI0uV7PlmqtV8LeBLWhAQAawwNp2fDw3nAc2gNAtZpFezu7VwOw4vDj0nONUvhxWCP5zJKPBI8VHd63Tv4zT5ILXSgkOctZ2eBwPvosIiIiIm08OBaRmTRabq+IiMh8orQKEREREZGobSPHhcGtAJR3bU3PWecKAB512BoAtq5dkZbdsymkWOzc/t8APOaxx6dltWLY1CvsHZAt0QbgtXCuHnfWq3stLavGlIsiXQCUcq92d89d4fp6f3pu5aPPCOcKcaJcbl245nQKm9C6AdmufskEwFquzVqteYdfERERkYVNkWMRERERkahtI8fVnrDRR71jWXquvDtsdnXPjVcD0JULv/b0lAF4cPtOABY/9EBa9qjDDgptxaBrIxdwrTZq8VyMINeyyKzFKPLi7kr4vr43LeushOhwtff2rLFa2IjES+Ezy1jB4X0jyc01R15Zi/X3iXqbPhuJiIiI5Gl0JCIiIiIStW3kuOhVAOrFrvTc4KoNACw+MmwCctRRD6ZlS++4GYBtD1wDwP233paWrSwcAUD3op7QjmVtDlQ6AejqCMu8rV6avaSNWojSVuLmI4uXr0vLystC3vOKtaek57wc+mWx75bb6MOTr73F1tI24ouRLC4TRxb2dtdSbiIiIiJ5ihyLiIiIiEQaHIuIiIiIRG2bVpGkGBRzS6sV445zK454DACVxolp2ZqVZwFw3pFPA2DLpv/NmiqEJdkaIXOCzqxJKoMhZeLRRywGYMmS5WnZ7353KwB7w3w8Vhx3Zlq28pizAajVh7Lb1OPEPS+2eD4xncIa8dlZrmSsqXu27zG/BtxE14MTERERWSAUORaROcPM1puZm9klE6x/fqx//hT24dzY5gVT1aaIiMwfbRw5DrzF+N+rIVprhWxZs47uEBZed8xpABxywqlpWcNjhLWeHLPQcaMW2qr07wJgqDvbWKRr96pwnweuAqCzkC3lZtW4QUgja8sa4cdRLwzH/uUiu434dTIvj9xSbpZ8PdZnHYvXTTTiLCIiIrLwtP3gWETa2neAa4Gt41UUERGZiLYdHCexVM8FR5OlyyzZ/CK3klkSmK0MDwBQGMpdF7dzTlJ0C8VchLYzLOvW3RWWe8uvjnbMhqcAUD3xcfG6zrSsFm9esOxH4KWwzJolyc3kt3eODcdO5DfzSFiLHOIkwpy+HvsWisxr7t4L9M52P0Zzy5Ze1r/zB2z+yHmz3RUREZkg5RyLyJxkZseb2X+a2S4z22tmvzSzZzTVaZlzbGab42OpmX0sfl3N5xGb2cFm9kUz22Zmg2Z2k5m9YmaenYiIzFVtGzkWkXntSOBXwC3AZ4F1wIuBH5nZS939GxNoowP4ObAS+AmwB7gHwMxWAdcARwG/jI91wGdiXRERWaDad3CcZBjkUgcKzRPQWsxHKxCXUStmhYUkXaHVTnRxx7q6x5SIXB5HskNesdwdvm9kaRJpyN6yDjZPkNt3/7pCWqv5ulxnWvQvOcZ0DM/+WOCajydz15OAj7r7/01OmNm/EAbMnzGzH7n7nnHaWAfcBpzj7nubyj5MGBh/wt3f1uIeE2Zm149SdPxk2hERkblBaRUiMhf1Au/Pn3D364CvAsuB/2+C7byjeWBsZmXgZUAfcMEo9xARkQWqbQfHRmHEI0RUx3kkB7P0kbUZ/sOyR1KnQHgx89el13sDvEHBLPcoULBCUz3AwyQ634/Zcu7Jw9PHROqLzEE3uHtfi/NXxONpE2hjCPhdi/PHAz3ATXFC32j3mBB339DqAdw+mXZERGRuaNvBsYjMa9tGOf9QPC6bQBsPe+tPiMm1491DREQWoLbNOU6Xa8tFYJMocPbv5cSWQ2t1LleaVBqtyZZ9GS+qO558n5K2kmPLJd2a6ojMcQePcn5tPE5k+bbR3uzJtePdQ0REFiBFjkVkLjrdzJa0OH9uPN54AG3fDgwAp5pZqwj0uS3OiYjIAqHBsYjMRcuAv8ufMLMzCBPpegk74+0Xd68SJt0toWlCXu4eU+KkQ5dpAxARkXlmYaVVkKQdxJL8dnZNy6Dtm5nQfM5GlLXuQ3qjCfa5Oe1j/+y7C95YbSnFQuasq4C/MLPHAVeTrXNcAF4zgWXcxvNu4KnAW+OAOFnn+MXAD4HnHmD7IiIyT7Xt4FhE5rV7gNcCH4nHTuAG4P3u/uMDbdzdd5jZE4APAc8BzgDuAF4HbGZqBsfrN27cyIYNG6agKRGRhWfjxo0A62f6vqYJWiIiU8/MKkARuHm2+yIyimSjGi07KHPVKUDd3Ttn8qaKHIuITI9bIKyDPNsdEWkl2d1R71GZq8bYgXRaaUKeiIiIiEikwbGIiIiISKTBsYiIiIhIpMGxiIiIiEikwbGIiIiISKSl3EREREREIkWORUREREQiDY5FRERERCINjkVEREREIg2ORUREREQiDY5FRERERCINjkVEREQpq5IaAAAgAElEQVREIg2ORUREREQiDY5FRERERCINjkVEJsDMDjOzi83sQTOrmNlmM/uEma2YZDsr43WbYzsPxnYPm66+y8IwFe9RM7vCzHyMR9d0PgdpX2b2QjO7yMx+YWZ74vvpK/vZ1pT8Ph5NaSoaERFpZ2Z2NHANsAb4LnA7cCbwFuBZZvYEd985gXZWxXaOBX4OXAYcD7wSOM/MHu/ud0/Ps5B2NlXv0ZwLRzlfO6COykL2t8ApQD/wAOF336RNw3t9BA2ORUTG92nCL+I3u/tFyUkz+xjwNuCDwGsn0M6HCAPjj7v723PtvBn4ZLzPs6aw37JwTNV7FAB3v2CqOygL3tsIg+K7gHOAy/eznSl9r7di7n4g14uItDUzOwrYBGwGjnb3Rq5sCbAVMGCNu+8do51FwHagAaxz975cWSHeY328h6LHMmFT9R6N9a8AznF3m7YOy4JnZucSBsdfdfeXT+K6KXuvj0U5xyIiY3tKPP4k/4sYIA5wrwZ6gLPGaefxQDdwdX5gHNtpAD+J3z75gHssC81UvUdTZvZiM3unmb3dzJ5tZp1T112R/Tbl7/VWNDgWERnbcfF45yjlv4/HY2eoHZFm0/Heugz4MPBPwA+B+8zshfvXPZEpMyO/RzU4FhEZ27J47B2lPDm/fIbaEWk2le+t7wLPAQ4j/KXjeMIgeTnwDTN79gH0U+RAzcjvUU3IExE5MElu5oFO4JiqdkSaTfi95e4fbzp1B/BuM3sQuIgwqfRHU9s9kSkzJb9HFTkWERlbEolYNkr50qZ6092OSLOZeG99gbCM26lx4pPIbJiR36MaHIuIjO2OeBwth+2YeBwtB26q2xFpNu3vLXcfApKJpIv2tx2RAzQjv0c1OBYRGVuyFucz4pJrqRhBewIwCFw7TjvXxnpPaI68xXaf0XQ/kYmaqvfoqMzsOGAFYYC8Y3/bETlA0/5eBw2ORUTG5O6bCMusrQfe0FR8ISGKdml+TU0zO97M9tn9yd37gS/H+hc0tfPG2P6PtcaxTNZUvUfN7CgzO7S5fTNbDXwpfnuZu2uXPJlWZlaO79Gj8+f3572+X/fXJiAiImNrsV3pRuBxhDWJ7wTOzm9XamYO0LyRQovto38DnAA8D3g4trNpup+PtJ+peI+a2fmE3OIrCRst7AKOAP6IkON5HfB0d989/c9I2o2ZPR94fvx2LfBM4G7gF/HcDnf/q1h3PXAPcK+7r29qZ1Lv9f3qqwbHIiLjM7PDgfcTtndeRdiJ6T+BC919V1PdloPjWLYSeB/hH4l1wE7C7P+/c/cHpvM5SHs70PeomT0WeAewATiEMLmpD7gV+CbwWXcfnv5nIu3IzC4g/O4bTToQHmtwHMsn/F7fr75qcCwiIiIiEijnWEREREQk0uBYRERERCTS4PgAmdn5ZuZmdsV+XLs+XqvcFhEREZE5QINjEREREZGoNNsdWOCqZLu9iIiIiMgs0+B4Frn7FuD4cSuKiIiIyIxQWoWIiIiISKTBcQtm1mFmbzGza8xst5lVzWybmd1sZp8ys8ePce1zzOzyeF2/mV1rZi8Zpe6oE/LM7JJYdoGZdZnZhWZ2u5kNmtnDZvZ1Mzt2Kp+3iIiIyEKntIomZlYi7Nt9TjzlQC9hB5Y1wMnx61+1uPa9hB1bGoRdhRYRtjT8mpkd7O6f2I8udQKXA2cBw8AQcBDwJ8BzzezZ7n7VfrQrIiIiIk0UOR7ppYSB8QDwp0CPu68gDFIfBbwRuLnFdacQtkV8L7DK3ZcT9g7/Viz/cNw2drJeRxiQvwJY7O7LgNOAG4Ae4JtmtmI/2hURERGRJhocj3RWPF7q7l9x9yEAd6+7+33u/il3/3CL65YD73P3v3f33fGabYQB9nagC/g/+9GfZcCr3f1Sd6/Gdm8CngnsBA4G3rAf7YqIiIhIEw2OR9oTj+smed0QMCJtIg6ufxy/PWk/+nMv8LUW7e4APhu/feF+tCsiIiIiTTQ4HulH8fg8M/uemb3AzFZN4Lrb3H3vKGVb4nF/0h+udPfRdtC7Mh5PMrOO/WhbRERERHI0OG7i7lcCfwfUgOcA3wZ2mNlGM/uomR0zyqV9YzQ7FI/l/ejSlgmUFdm/gbeIiIiI5Ghw3IK7fwA4FngXISViD2GzjncAt5nZn81i9/JstjsgIiIi0k40OB6Fu9/j7h9x92cBK4EnA1cRlr/7tJmtmaGuHDJGWZIXXQcemYG+iIiIiLQ1DY4nIK5UcQVhtYkqYf3iM2bo9udMoOwWdx+eic6IiIiItDMNjpuMM7FtmBClhbDu8UxY32qHvbhm8qvjt/8+Q30RERERaWsaHI90qZl9ycyeaWZLkpNmth74N8J6xYPAL2aoP73A583s5XH3PszsZEIu9EHAw8CnZ6gvIiIiIm1N20eP1AW8GDgfcDPrBToIu9FBiBy/Jq4zPBP+FTgX+DLwBTOrAEtj2QDwIndXvrGIiIjIFFDkeKR3An8N/DdwN2FgXAQ2AV8CTnf3L89gfyqEyYDvJ2wI0kHYce+y2JerZrAvIiIiIm3NRt9fQmaTmV0CvAK40N0vmN3eiIiIiCwMihyLiIiIiEQaHIuIiIiIRBoci4iIiIhEGhyLiIiIiESakCciIiIiEilyLCIiIiISaXAsIiIiIhJpcCwiIiIiEmlwLCIiIiISaXAsIiIiIhKVZrsDIiLtyMzuAZYCm2e5KyIi89V6YI+7HzmTN23bwfG/X/w5B6jXaum5YqkIwK7e3QAMVippWUdHBwBmBsBwZSgtq3oIsPfXw8s1VMuWv2tUqwB0WijzYiF3XSPUIdSv1eoj+pncL/913cJ1w9WsfqPRdMytwJd8ndy50MjdoBHbqMWThWJaVI/P64ufer8hIlNtaXd398oTTjhh5Wx3RERkPtq4cSODg4Mzft+2HRzv6tsLQKGYDQZ9KAxkH9kbBr4DuRe8XA5lhUIYMFpu/WcrhpfJLAygy8Vs9FmP1Sql8shOxDaSQWu5kA12PY5y8+tMJ4Pj5Ewp6zoe++XJ4DiXEVP3cJ3FUXKhkLXp9UY8l9wku66krBqZR/5fe3ceJWd13nn8+1RVd6sXqbULIQFtcFjGJGCLgA1mEDhhseOESXzGycQLJJMJIT7YODkxjjc5nrHJOTMmCQ7GiWMTHHKwZzwJ9ngjYAtjAyZsxqwGhBBIQvuu7q7tzh/3eeu9XapudUvdaqn0+5zDKem973vvraZO6/bTz32uma0ELgghjPuHOTMLwD0hhOVTNa8xrD7ttNPmPvzww9MwtIjIkW/ZsmU88sgjqw/1uFodiYiIiIi4to0ci4gApwF7p2vwJ9buYOC6b03X8CJylFt9/dumewpHpLZdHK966RUACkkOsOE5vZ64UE9SGmrEHIZGSkKS09tVMO8r3tOZ5O3i/Q91FP2xJIc4SwbOUiiqyW+Di7EtTavI/ly0onedtnnqhAf707SKij8XajFto5AmJGe5GaHoz+cKplRjaW8hhGemew4iInJkUVqFiEw7M/t1M7vbzNab2bCZrTOze8zs6hb3lszsz83sOb/3ZTP7S8s2BYy8N3iucnpthV9fbmbvNbNHzWzQzDaa2ZfM7JgpfKsiInKYa9vIcbZzrWj5W8wjpd6WRIC7u/zfVb+nUEg2rnV2xac8cmwh31hX8lhsp0d7qyHZrGdhxGsgHy/rP40cZ+peYaJYTyPHBX8PxRF9xrfqFTmKcS7FdL9SyDb5xa9DId0ASFrWQmR6mNl/A74AvAp8E9gMLAR+CbgSuKnpkX8Gzge+A+wE3gr8mT9z5QSGvha4GPgq8F3gzf78cjM7J4SwaZzzH23H3akTmIuIiBwm2ndxLCJHij8EysAZIYSNaYOZzW9x/0nA60IIW/2ejwA/Bd5jZh8OIbw6znEvA84JITyajHcD8AHgeuD3J/xORETkiNe2i+PerlharbMr/01rFqXNorvFjvzt9/V1A1DzvF2SyHHdc47x+sOlJDDb49Hkgkd2B5PaxIMeYa56RNeScm9ZADetfbxnz26fS1+cXxLZzsoVZ5HgrBYyQD3EMnT4PaUklziLONeyMm9JMrXV8hrQItOsClSaL4YQNre490PZwtjv2WNmtwEfB84C/t84x/xKujB2K4jR4/9iZleHEIb3fWyfOS5rdd0jym8Y51xEROQwoZxjEZlutwE9wJNmdoOZXW5mC8a4/6EW11721zkTGPee5gshhB3AY8AMYqULERE5ymhxLCLTKoTwWeC9wBrgGuBfgA1m9gMzO6vF/dtbdJP9GqTYom00G0a5nqVl9E+gLxERaRNtm1axoH8mMLJcW9V/FKj4UcodnXmaQ2cpS33wTXfJyXrFzhnxuXL8re+ObdsabcOl+CXs7oxpGR3JCXQ1T81onLqXlGYzvzaUbIrbsGEtAD19Az7RPD1iRiHOITsCu5Y811HzMbMNeekR0f5eB+t7R7wHyE/PE5luIYRbgVvNbDZwLvCfgN8DvmdmpzXnIk+SRaNcz6pV7JiCMUVE5DDXtotjETnyeFT428C3zaxAXCCfD3x9Coa7ALg1vWBm/cCZwBDw9MEOcPqSfh5WEX4RkSNK2y6OzSPGw4ODjWvF3hh97entAUaWa8vKoXXNiNHkQhI57uuNpdz6FswFYEtH/tyeXXETHYW4G25GV7Lprpod6hEjuqXO/Mtd9LFL5Bvy5s6K8xraHQNWtaE8yjtUi/NZdMziOM/OJDqcHW5S23fTXcUjzMEPHSkW04NI8rmKTBczuxS4K4TQvEN0ob9O1Ql37zazzzVtyltBTKf48ng244mISPtp28WxiBwxbgeGzOxHwGriQY7nA78MPAzcNUXjfgf4sZl9DVhPrHP8Zp/DdVM0poiIHOa0IU9Eptt1wP3EsmdXE0updQAfAi4MIexT4m2S3ODjnUmsbXwqcAtw7hTlOIuIyBGgbSPHa9asAUamR/T65vNeTyfo6upqtJV9o1qlMgRAPakBvHtbLKm6cH6sLtWdpFVYT6yjvLtcBqBaHWq0lXzsDq9vXKvnfRazk+6G9zSuzew0HydWo3r5xZcabRvXx3+ru7vic7Pnzm60dVhMzaiV/bfAhTxdwuq++bAY59zVk9d9tglt7BeZGiGEm4Gbx3Hf8jHabiEubJuv2z43j+M5ERE5eilyLCIiIiLi2jZyPDgY9/DMnJWXKi17dLfspdi6u7uTJ/w0u2q8JyRR3rpHZCtDcXNfR1Iqzbx0216P0JaS8nClbHNeJd6zcUPjUC9m9cVSc8XkpLsFfXHDYKfPYXjHpryv4KXY9sYSr9vr+V6hrq7Yf9035IV6HiwrdcboeEcp9k1ITtar5xv3RERERESRYxERERGRhraNHOPlzdJybaUOz/31NMTh4Tz6OsNLuHV2xZzcjlJP3pMHWHu6YvS1XklKrA3HKG+XHxRS7Mijyls2xTzhXbt3ArB0yUCjrb+vD4Deznx+J52wNPbVFdvOOf2URlulHHOTH3/mRQA2bs9zlRcsirnQa156BYDycB717qzVRrymecZmyjmWo08IYQWxZJuIiMg+FDkWEREREXFaHIuIiIiIuLZNqxgaiiXVeqtJioG/bt0SN8bNmtnXaOvtiRvXCn6CXHdP3palaFTKsa9yJd/UNlT2tIWC31PNUy42ro8b6rq64pd5l28EBHjq0UcAuOSi8xvXjvUSbnf920oANmxY12j7tbdfDMCMjjjO00892Wg77jUnAPnmu8Hh/NS9csXn7OkfhSSVoqQT8kRERERGUORYRERERMS1beS4Uo2b7Sw5AqA2FKOnW9bEwzXCnDmNtoWz46EaRS95ViSPqnYU/cs0I0aMK5Vyo62YbeTz19178kNAss16xy46BoA+39AHcOy8+QAsmju3ca27o+T97wZg3YZXGm27BmO/5Vrs84Xnn260/ezR2P+ChYvjHMhLtJl/AUodMW6eFm+rUkdEREREcooci4iIiIi4to0cv/bkmIfb358fszzbo8Nz+mOUt6OU59/OXRTbdg7FiPMrr6xqtA3tiYd/zF+4EIDOnrzMG5WY31ssxpjsXi/bBjBUjs9V/UCRej3PRz755JMAGBzKS7Lt8Gcvu/QSAC668MJG24zeXgBeWLUagGPm5jnRg7u2xHuWHAtAV/K+CgUvTRfiz0G15BCQKjoERERERCSlyLGIiIiIiNPiWERERETEtW1axckDcZNaSNIIsJjCcMzCmKJQrycpBuVY3m1GR/x5YWBJf6Nt1+6YhtHdF0uldXblaRW7dsbUhIHFMeXiuAX5Jr/XLFkEQM3TF7Zu2NBoW79pLwAvrx9sXNu4dT0A82bFTXoz+2Y12vpnxzSKM37pVAAWLv6DRlvHjPh+avU4v7vvfqDRVvPT/Kqe/lGu5aXtKrW85JtIxsxWAheEEGx/9x7kOAPAi8A/hhCumMqxRERExkuRYxERERER17aR47NeGze81UMeKR2ueDm04WH/e9rm1/wQjzJ5W293/Bli+/Z4qMfWbXmJtQX9sSTbzGossbZk6dJGW9/rYpR3e3mvzyU5PGQwXhsaziPHfX0xIl0oxU10paT0W3dX3GQ3b36MJp/y+lOTdxv/N+7cGt/Dfff+e6Pl8Z89C8Du8sj31/xnkcR7gJ793iUiItKG2nZxLCIHJoSwZrrn0C6eWLuDgeu+Nd3TmJDV179tuqcgIjKtlFYhchQwsyvM7OtmtsrMBs1sp5n92Mze1eLelWYWmq4tN7NgZivM7Gwz+5aZbfVrA37Pav+v38w+Z2ZrzWzIzJ4ys2vMbFw5zGZ2spldb2YPmdkmMxs2s5fM7O/MbGmL+9O5nelz225me83sHjM7d5RxSmZ2tZk94F+PvWb2qJm9z8z0vVFE5CjVtpHjUiFuTit1djWuzfS0hSy7wSyvBxxC3Jw27GkOw5U83aFeiP9Olsvxwfu/vbLR9uR9PwHgmZ44Tk93d6Ot3zfpLfVNdP3HLGi09fTFTXR9s/JNd4uPjZsIu2fOjHNKlhKWbR70DXWDO/P6yIV6XMd0d8Y+L7tkeaNt06aNADzw2E8BKHbkJ//NWTAfOWp8HngK+CGwHpgHvBX4ipmdEkL42Dj7eRPwYeBHwJeA+UA5ae8E7gJmA7f7338L+GvgFOCPxzHGbwJXAT8A7vP+Xwf8V+DtZnZWCGFti+fOAv4MuB/4InC8j323mZ0ZQng2u9HMOoBvApcAzwL/DAwBFwI3AucA7x7HXEVEpM207eJYREY4PYTwQnrBzDqB7wDXmdnNoyw4m10MXBVC+MIo7YuBVT7esI/zCeDfgavN7KshhB/uZ4yvADdkzyfzvdjn+1Hgj1o89zbgyhDCLckzfwjcDLwfuDq59yPEhfHngA8E/+nY4k/Mfwf8npn9nxDCHfuZK2b28ChNp45yXUREDmNtuzjesDduvpvtZc4ABgfjCXQvrXoZgK5SHlWu1WPwq683boLr6u1stHX0xvv6Z8a+Bo7PI64v3x/77KzFqHRtx+5G26bt2wCYtziWZps1O5mLn5a3JzlRb9uWuOGvc0aM7s7qye/v6Yz9d1psKxTzsHINL9dWj+PN6c838l18UfyN8ut/8XUA9PbNbLQVu/L3KO2teWHs18pm9rfARcBbgFvH0dVjYyyMMx9OF7YhhK1m9ingy8CVxOj1WHNtuUgPIdxpZk8SF7Wt/DhdGLsvERfAZ2cXPGXifcCrwLXZwtjHqJnZn/g8fxfY7+JYRETaS9sujkUkZ2bHAx8iLoKPB7qbblkyzq4e3E97lZgK0Wylv75+fwN4bvLvAlcAZwBzgGJyS7nFYwAPNV8IIVTMbIP3kTmZmFbyHPDRUVKhB4HT9jdXH2NZq+seUX7DePoQEZHDR9sujnftjlHUJcfkkdJtO2I0efXaWIqtt7uv0bZp22YgL+nWMzOvZDVzVlxHnHdm/Hd97ry5jbaifwU7/YCQOccd22jbvi4e+lEoxX985y9Z3Gib3R/7qIV831O1HgNYe3bvAmDH1h15X7X45+6uOJfu3nx+23fEA0x6euN7XbQon8PZvxz/bd68fTsADz36eKPt4ftiybdff0+r31BLuzCzE4mL2jnAvcCdwA6gBgwA7wW6Rnu+yav7ad+cRmJbPNffoq3ZZ4EPEHOjvwesJS5WIS6YTxjlue2jXK8ycnE9z19/AfjEGPPoG6NNRETaVNsujkWk4YPEBeGVzWkHZvY7xMXxeIX9tM83s2KLBfIx/rqj+YGm+SwErgGeAM4NIexqMd+Dlc3hX0IIvzkJ/YmISBtRuSKR9vdaf/16i7YLJnmsEtCqdNpyf310P8+fSPy+dGeLhfFSbz9YzxCjzG/0qhUiIiINbRs5XrduHQDLTntN49rSBTGVYf5lvwJAeSjfDL97MP7Wdo+/DpfzUm745rleL4PWMz9PXyz1xc1vs49bBMCJZ+Qb1B9dE/cVVbfHf+PLyea7Smf8Le+MGfnmuf7emDLRUYsb5YZ2bsvn4GVne70EXDXkaZevbIgb+awQ77/3/jz1slKNpd8eeuoxAFavyX8rvntvfmKftLXV/rqcWL4MADO7hFgebbJ9xszeklSrmEusMAFxU95YVvvrm9MItJn1AX/PJHzPCiFUzexG4GPA35jZB0MIg+k9ZrYYmBNCeOpgxjp9ST8P61ANEZEjStsujkWk4SZi9YX/bWZfJ+bwng5cCnwNeOckjrWemL/8hJl9A+gA3kEs8XbT/sq4hRBeNbPbgd8GHjOzO4l5yr9KrEP8GHDmJMzzU8TNflcRayd/n/h1WUjMRT6PWO7toBbHIiJy5GnbxfEjTz0HwFv+45sa17q7Y0S2w6Ow5VKeFtnfN8vbZgNQKedR5eFy3MhX8pJpxVl5tLd3Xnxu66a4oa/66M8abXt2xoixDcUobylJw6x5ZLpCfm1wd0yF3LbNNxMem2+swzfurXnpJQAefDz/N/v+x+PZBoODcZzBvfncyx45LoeKd5PvSyqVVMrtaBBCeNzMLgT+O/HgjxLwU+JhG9uZ3MVxGfgV4NPEBe58Yt3j64mHa4zH7/sz7yQeGrIJ+AbwcVqnhkyYV7G4HHgXcZPfrxE34G0CXiRGlW+bjLFEROTI0raLYxHJhRDuI9YzbsWa7l3e4vmVzfeNMdYO4qJ2zNPwQgirW/UZQthLjNp+pMVjE55bCGFglOuBeODIV8aap4iIHF3adnH8yFM/B+ClDZsb15adEffy7B2Kub+1Wv7vqVViBNf8bOkSeT5uvWAjXotJGbV5S5cC8PhdMc9366Z8M37ZI9SrPCJc9sNHAHbt2QvA0NBQ49qWrVtiH1tiabaBgbxi1eYtse3FVS/Ge3blx0cPeZWq7ITpQiH/31r3o6WHq/H91TySDGD7LTwgIiIicnRRtQoREREREafFsYiIiIiIa9u0ig2emnDXj37SuHbCSfGE3IKnJ5Zm5AdglYNvYivEnxesI9909+q6eKLes8+vAuD4Jcc12rbW45dwc4jPFUOeqrHZN+A9+fzzAFRX52kVQ0Nxg5wV8vsbKQ9+nO2TazblbX56Xt1zJ6yQH2hWrdX8NaZJWC1Pl/CsCsq+76+eVG8rjSuDVGR8RsvtFREROZIociwiIiIi4to2ctzRGQ/suO/hxxrXKvXdAFSH4ma2zlIefR2qxjJowSO5HaX8S7Nh00YA1q6PrwtmzW+0bdkYI9RbvKsuPzAEoFKMG+VqlRi+rSbl4Wq+8a8Qkp9PPGJc8Oh1ul2uHrK/+ebANDpcy1o8el3ID/3KgsPFokfEq3npuBFji4iIiIgixyIiIiIiGS2ORURERERcG6dVxLe2ZfvWxrXvfv9eAGqVrLZwkriQ1TL2PISi5T83dPpJcub1gzdvXNVoK5ZiCsNQZ0yhqCYb3mq+Ua7gwxSKeZ9ZCkR2D0Dw1InQmERSa9nvy+43y0+6s1Dy533cpJZxlo5R8NuLhcI+bSIiIiISKXIsIiIiIuLaNnIcvIxauZJHZvET66wYI8GFYl7LrOih1eLIWwGoV+N9WTm19GeKrFRasRKjvMOV8j5zKXl0uVjMo72hVh8xz7TfbOhasukukM0hiy4nz3n5uCzynEajfY8fhew0wCR6XUn7EBERERFFjkVEREREMm0bOc4OxKin0VHzaK1HX7NoMUCx6BHZLEc3yTnODg0pWPxypbm6VU8yLpQKjbszWV+VStXnsm+Ob3otK7eW5QVXq/vmI9cbEec0f3lkxLhSqezzXHbYyIgZFPWzkYiIiEhKqyMREREREafFsYgcdcxswMyCmd0y3XMREZHDS9umVWR72eph30132Ql0JG01r35WKHrqRFKSLUtFqPofLEm5sOw0uyx9ISmxVvNOGykR9XSj3MhNdPHP2aBZn8nci6WR15K2bMyOjg5/f3nb0FA8lS9LJaGQpn0gMmXMbAB4EfjHEMIV0zoZERGRcVLkWERkijyxdgcD131ruqchIiIT0LaR4zrZBrR8/V/zUGkpK2+WRFizzWz1Rvm0vC2rh5ZtkCuYNTdRKsXobRrtLXhEN9i+GwDrHpoOyRa5LCLdCCCnffkBJKVSFnFO3mttZAi4o6Mz+Vs292y8vM+6ISIiIiIJRY5FZNKZ2QpiSgXAez2/N/vvCjNb7n9eYWZnm9m3zGyrXxvwPoKZrRyl/1vSe5vazjazr5rZWjMbNrP1Znanmf3nccy7YGZ/433/XzObcWBfAREROVK1b+Q4OywjuZaVZyv64R8W8sRi8+hutRoP8bAkypsd9VytxxJp6RHM1Bsd+L15ODaEkVHeUNg3Epz+dJLlHGdjpweE1Dzy2yj9lkR9h8vlEWMXkxJtWX51lo9MEvWuoaRjmTIrgdnA+4GfAv+atD3mbQBvAj4M/Aj4EjAf2PcknXEysz8APg/UgG8AzwELgbOAq4GvjfHsDOCfgN8C/ha4JoTkm4SIiBwV2nZxLCMgXqoAAAhdSURBVCLTJ4Sw0sxWExfHj4UQVqTtZrbc/3gxcFUI4QsHO6aZ/QfgJmAncH4I4cmm9qVjPDsXuAM4D7guhPCXExj34VGaTh1vHyIicvjQ4lhEptNjk7Ewdn9E/J72qeaFMUAI4ZVWD5nZCcB3gZOAd4cQbpuk+YiIyBGobRfH1khzSE+S82ueXmFJVkGWKZHfn+QtFLLn9mlpjFP3sm2FYrrpLqZFNMq11fZNYyiV8v8F2X21WkzfSO/OxqlZll6RtDWVqEvnUPNNhJbf3GhLNwiKTJMHJ7GvN/rrdybwzCnA/UAvcFkI4e6JDhpCWNbqukeU3zDR/kREZHppQ56ITKdXJ7GvLI957QSeORlYDKwCHpnEuYiIyBGqbSPH2aa0xgY2aIRis7Jmafi1EWnOoqmWlnKL10rFuKktVPONctUsYuyl3Cwtv+ZzqFarIydAHuXN2/Iha7U4r1q6YbDu8/LNhNUkCl30/41ZqTmrpe8re37fg0iKndqIL9NurF2hgdG/R81ucW27vy4Bnhnn+N8EngU+DdxtZheHEDaP81kREWlDihyLyFTJfhI70PydbcBxzRctHgl5Zov7H/DXyyYySAjhM8C1wOuBH5jZognOc1SnL+ln9fVvm6zuRETkENDiWESmyjZi9Pf4A3z+QeB4M7u46fpHgRNa3P95oAp8zCtXjDBWtYoQwl8RN/S9DrjHzI49wDmLiMgRrm3TKkKLX9YWfaNavRo3vNWSlIZsy1qWFJFkRxDqnjrhfy8V0i9bdqOfbpc8mGVFmAfOLA2g+fzqtX1TO7I+0pPvzAsqh1DwuefpEfXGRj5Pq0g23XV2xLnmmw/z+VUqFUSmSghht5n9BDjfzG4Dfk5ef3g8/idwCXCHmX0V2AqcC7yGWEd5edN4T5nZ1cDNwKNmdgexzvE8Yp3jXcCFY8z3ZjMbAv4B+KGZXRRCWDPOuYqISJto28WxiBwW3g3cAFwK/A7xp7NXgNX7ezCEcLeZXQ58HPhtYA/wb8A7gU+O8szfm9kTwJ8SF8+XA5uBx4EvjmPMW8xsGLiVfIG8an/PjWLg6aefZtmylsUsRERkP55++mmAgUM9roVWIVYRETkovsguEk8IFDkcZQfVjHcDq8ihdgZQCyF0HcpBFTkWEZkaT8DodZBFplt2uqM+o3K4GuME0imlDXkiIiIiIk6LYxERERERp8WxiIiIiIjT4lhERERExGlxLCIiIiLiVMpNRERERMQpciwiIiIi4rQ4FhERERFxWhyLiIiIiDgtjkVEREREnBbHIiIiIiJOi2MREREREafFsYiIiIiI0+JYRGQczGypmX3JzNaZ2bCZrTazvzKzORPsZ64/t9r7Wef9Lp2qucvRYTI+o2a20szCGP/NmMr3IO3LzN5hZjea2b1mttM/T/90gH1Nyvfj0ZQmoxMRkXZmZicB9wELgTuAZ4CzgfcDl5rZeSGELePoZ573czLwfeB24FTgSuBtZvamEMKqqXkX0s4m6zOa+OQo16sHNVE5mn0UOAPYDbxC/N43YVPwWd+HFsciIvt3E/Eb8TUhhBuzi2b2WeBa4H8AV42jn08TF8Y3hBA+mPRzDfDXPs6lkzhvOXpM1mcUgBDCismeoBz1riUuip8HLgB+cID9TOpnvRUdHy0iMgYzOxF4AVgNnBRCqCdtM4H1gAELQwh7xuinF9gE1IHFIYRdSVvBxxjwMRQ9lnGbrM+o378SuCCEYFM2YTnqmdly4uL4thDCuybw3KR91seinGMRkbFd5K93pt+IAXyB+2OgB3jjfvp5E9AN/DhdGHs/deBO/+uFBz1jOdpM1me0wczeaWbXmdkHzewyM+uavOmKHLBJ/6y3osWxiMjYTvHXn4/S/py/nnyI+hFpNhWfrduBzwD/C/g2sMbM3nFg0xOZNIfk+6gWxyIiY+v31x2jtGfXZx+ifkSaTeZn6w7g7cBS4m86TiUukmcDXzWzyw5iniIH65B8H9WGPBGRg5PlZh7sBo7J6kek2bg/WyGEG5ouPQv8uZmtA24kbir9zuROT2TSTMr3UUWORUTGlkUi+kdpn9V031T3I9LsUHy2vkgs43amb3wSmQ6H5PuoFsciImN71l9Hy2H7BX8dLQdusvsRaTbln60QwhCQbSTtPdB+RA7SIfk+qsWxiMjYslqcF3vJtQaPoJ0HDAIP7KefB/y+85ojb97vxU3jiYzXZH1GR2VmpwBziAvkzQfaj8hBmvLPOmhxLCIyphDCC8QyawPAHzc1f5IYRbs1ralpZqea2YjTn0IIu4Gv+P0rmvp5n/f/PdU4lomarM+omZ1oZkua+zez+cCX/a+3hxB0Sp5MKTPr8M/oSen1A/msH9D4OgRERGRsLY4rfRo4h1iT+OfAuelxpWYWAJoPUmhxfPSDwGnAbwAbvZ8Xpvr9SPuZjM+omV1BzC2+h3jQwlbgeOCtxBzPh4BfDSFsn/p3JO3GzC4HLve/HgNcAqwC7vVrm0MIf+r3DgAvAi+FEAaa+pnQZ/2A5qrFsYjI/pnZccBfEI93nkc8ielfgU+GELY23dtycextc4FPEP+RWAxsIe7+/3gI4ZWpfA/S3g72M2pmvwj8CbAMOJa4uWkX8CTwNeALIYTy1L8TaUdmtoL4vW80jYXwWItjbx/3Z/2A5qrFsYiIiIhIpJxjERERERGnxbGIiIiIiNPiWERERETEaXEsIiIiIuK0OBYRERERcVoci4iIiIg4LY5FRERERJwWxyIiIiIiTotjERERERGnxbGIiIiIiNPiWERERETEaXEsIiIiIuK0OBYRERERcVoci4iIiIg4LY5FRERERJwWxyIiIiIiTotjERERERH3/wH6nAOFGdIySAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f88e08634a8>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 319,
       "width": 355
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "DON'T MODIFY ANYTHING IN THIS CELL\n",
    "\"\"\"\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "import tensorflow as tf\n",
    "import pickle\n",
    "import helper\n",
    "import random\n",
    "\n",
    "# Set batch size if not already set\n",
    "try:\n",
    "    if batch_size:\n",
    "        pass\n",
    "except NameError:\n",
    "    batch_size = 64\n",
    "\n",
    "save_model_path = './Cifar10model/image_classification'\n",
    "n_samples = 4\n",
    "top_n_predictions = 3\n",
    "\n",
    "def test_model():\n",
    "    \"\"\"\n",
    "    Test the saved model against the test dataset\n",
    "    \"\"\"\n",
    "\n",
    "    test_features, test_labels = pickle.load(open('preprocess_test.p', mode='rb'))\n",
    "    loaded_graph = tf.Graph()\n",
    "\n",
    "    with tf.Session(graph=loaded_graph) as sess:\n",
    "        # Load model\n",
    "        loader = tf.train.import_meta_graph(save_model_path + '.meta')\n",
    "        loader.restore(sess, save_model_path)\n",
    "\n",
    "        # Get Tensors from loaded model\n",
    "        loaded_x = loaded_graph.get_tensor_by_name('x:0')\n",
    "        loaded_y = loaded_graph.get_tensor_by_name('y:0')\n",
    "        loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob:0')\n",
    "        loaded_logits = loaded_graph.get_tensor_by_name('logits:0')\n",
    "        loaded_acc = loaded_graph.get_tensor_by_name('accuracy:0')\n",
    "        \n",
    "        # Get accuracy in batches for memory limitations\n",
    "        test_batch_acc_total = 0\n",
    "        test_batch_count = 0\n",
    "        \n",
    "        for test_feature_batch, test_label_batch in helper.batch_features_labels(test_features, test_labels, batch_size):\n",
    "            test_batch_acc_total += sess.run(\n",
    "                loaded_acc,\n",
    "                feed_dict={loaded_x: test_feature_batch, loaded_y: test_label_batch, loaded_keep_prob: 1.0})\n",
    "            test_batch_count += 1\n",
    "\n",
    "        print('Testing Accuracy: {}\\n'.format(test_batch_acc_total/test_batch_count))\n",
    "\n",
    "        # Print Random Samples\n",
    "        random_test_features, random_test_labels = tuple(zip(*random.sample(list(zip(test_features, test_labels)), n_samples)))\n",
    "        random_test_predictions = sess.run(\n",
    "            tf.nn.top_k(tf.nn.softmax(loaded_logits), top_n_predictions),\n",
    "            feed_dict={loaded_x: random_test_features, loaded_y: random_test_labels, loaded_keep_prob: 1.0})\n",
    "        helper.display_image_predictions(random_test_features, random_test_labels, random_test_predictions)\n",
    "\n",
    "\n",
    "test_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Why 50-80% Accuracy?\n",
    "You might be wondering why you can't get an accuracy any higher. First things first, ~60% isn't bad for a simple CNN.  Pure guessing would get you 10% accuracy. However, you might notice people are getting scores [well above 80%](http://rodrigob.github.io/are_we_there_yet/build/classification_datasets_results.html#43494641522d3130).  That's because you still don't know all there is to know about neural networks. There are a few more techniques and tricks that needs to be learn.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}