{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img width=\"800px\" src=\"../fidle/img/00-Fidle-header-01.svg\"></img>\n",
    "\n",
    "# <!-- TITLE --> [GTS4] - CNN with GTSRB dataset - Data augmentation \n",
    "<!-- DESC --> Episode 4 : Improving the results with data augmentation\n",
    "<!-- AUTHOR : Jean-Luc Parouty (CNRS/SIMaP) -->\n",
    "\n",
    "## Objectives :\n",
    "  - Trying to improve training by **enhancing the data**\n",
    "  - Using Keras' **data augmentation utilities**, finding their limits...\n",
    "  \n",
    "The German Traffic Sign Recognition Benchmark (GTSRB) is a dataset with more than 50,000 photos of road signs from about 40 classes.  \n",
    "The final aim is to recognise them !  \n",
    "Description is available there : http://benchmark.ini.rub.de/?section=gtsrb&subsection=dataset\n",
    "\n",
    "\n",
    "## What we're going to do :\n",
    " - Increase and improve the training dataset\n",
    " - Identify the limits of these tools\n",
    "\n",
    "## Step 1 - Import and init\n",
    "### 1.1 - Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "\n",
       "div.warn {    \n",
       "    background-color: #fcf2f2;\n",
       "    border-color: #dFb5b4;\n",
       "    border-left: 5px solid #dfb5b4;\n",
       "    padding: 0.5em;\n",
       "    font-weight: bold;\n",
       "    font-size: 1.1em;;\n",
       "    }\n",
       "\n",
       "\n",
       "\n",
       "div.nota {    \n",
       "    background-color: #DAFFDE;\n",
       "    border-left: 5px solid #92CC99;\n",
       "    padding: 0.5em;\n",
       "    }\n",
       "\n",
       "div.todo:before { content:url(data:image/svg+xml;base64,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);\n",
       "    float:left;\n",
       "    margin-right:20px;\n",
       "    margin-top:-20px;\n",
       "    margin-bottom:20px;\n",
       "}\n",
       "div.todo{\n",
       "    font-weight: bold;\n",
       "    font-size: 1.1em;\n",
       "    margin-top:40px;\n",
       "}\n",
       "div.todo ul{\n",
       "    margin: 0.2em;\n",
       "}\n",
       "div.todo li{\n",
       "    margin-left:60px;\n",
       "    margin-top:0;\n",
       "    margin-bottom:0;\n",
       "}\n",
       "\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "FIDLE 2020 - Practical Work Module\n",
      "Version              : 0.4.3\n",
      "Run time             : Friday 28 February 2020, 14:23:29\n",
      "TensorFlow version   : 2.0.0\n",
      "Keras version        : 2.2.4-tf\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.callbacks import TensorBoard\n",
    "\n",
    "import numpy as np\n",
    "import h5py\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sn\n",
    "import os, sys, time, random\n",
    "\n",
    "from importlib import reload\n",
    "\n",
    "sys.path.append('..')\n",
    "import fidle.pwk as ooo\n",
    "\n",
    "ooo.init()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 - Where are we ? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Well, we should be at GRICAD !\n",
      "We are going to use: /bettik/PROJECTS/pr-fidle/datasets/GTSRB\n"
     ]
    }
   ],
   "source": [
    "place, dataset_dir = ooo.good_place( { 'GRICAD' : f'{os.getenv(\"SCRATCH_DIR\",\"\")}/PROJECTS/pr-fidle/datasets/GTSRB',\n",
    "                                       'IDRIS'  : f'{os.getenv(\"WORK\",\"\")}/datasets/GTSRB',\n",
    "                                       'HOME'   : f'{os.getenv(\"HOME\",\"\")}/datasets/GTSRB'} )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2 - Dataset loader\n",
    "Dataset is one of the saved dataset: RGB25, RGB35, L25, L35, etc.  \n",
    "First of all, we're going to use a smart dataset : **set-24x24-L**  \n",
    "(with a GPU, it only takes 35'' compared to more than 5' with a CPU !)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 0 ns, total: 0 ns\n",
      "Wall time: 5.48 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "def read_dataset(dataset_dir, name):\n",
    "    '''Reads h5 dataset from dataset_dir\n",
    "    Args:\n",
    "        dataset_dir : datasets dir\n",
    "        name        : dataset name, without .h5\n",
    "    Returns:    x_train,y_train,x_test,y_test data'''\n",
    "    # ---- Read dataset\n",
    "    filename=f'{dataset_dir}/{name}.h5'\n",
    "    with  h5py.File(filename,'r') as f:\n",
    "        x_train = f['x_train'][:]\n",
    "        y_train = f['y_train'][:]\n",
    "        x_test  = f['x_test'][:]\n",
    "        y_test  = f['y_test'][:]\n",
    "\n",
    "    # ---- done\n",
    "    print('Dataset \"{}\" is loaded. ({:.1f} Mo)\\n'.format(name,os.path.getsize(filename)/(1024*1024)))\n",
    "    return x_train,y_train,x_test,y_test\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3 - Models\n",
    "We will now build a model and train it...\n",
    "\n",
    "This is my model ;-) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A basic model\n",
    "#\n",
    "def get_model_v1(lx,ly,lz):\n",
    "    \n",
    "    model = keras.models.Sequential()\n",
    "    \n",
    "    model.add( keras.layers.Conv2D(96, (3,3), activation='relu', input_shape=(lx,ly,lz)))\n",
    "    model.add( keras.layers.MaxPooling2D((2, 2)))\n",
    "    model.add( keras.layers.Dropout(0.2))\n",
    "\n",
    "    model.add( keras.layers.Conv2D(192, (3, 3), activation='relu'))\n",
    "    model.add( keras.layers.MaxPooling2D((2, 2)))\n",
    "    model.add( keras.layers.Dropout(0.2))\n",
    "\n",
    "    model.add( keras.layers.Flatten()) \n",
    "    model.add( keras.layers.Dense(1500, activation='relu'))\n",
    "    model.add( keras.layers.Dropout(0.5))\n",
    "\n",
    "    model.add( keras.layers.Dense(43, activation='softmax'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4 - Callbacks  \n",
    "We prepare 2 kind callbacks :  TensorBoard and Model backup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ooo.mkdir('./run/models')\n",
    "ooo.mkdir('./run/logs')\n",
    "\n",
    "# ---- Callback tensorboard\n",
    "log_dir = \"./run/logs/tb_\" + ooo.tag_now()\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)\n",
    "\n",
    "# ---- Callback ModelCheckpoint - Save best model\n",
    "save_dir = \"./run/models/best-model.h5\"\n",
    "bestmodel_callback = tf.keras.callbacks.ModelCheckpoint(filepath=save_dir, verbose=0, monitor='accuracy', save_best_only=True)\n",
    "\n",
    "# ---- Callback ModelCheckpoint - Save model each epochs\n",
    "save_dir = \"./run/models/model-{epoch:04d}.h5\"\n",
    "savemodel_callback = tf.keras.callbacks.ModelCheckpoint(filepath=save_dir, verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5 - Load and prepare dataset\n",
    "### 5.1 - Load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset \"set-24x24-L\" is loaded. (228.8 Mo)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x_train,y_train,x_test,y_test = read_dataset(dataset_dir,'set-24x24-L')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 - Data augmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "datagen = keras.preprocessing.image.ImageDataGenerator(featurewise_center=False,\n",
    "                             featurewise_std_normalization=False,\n",
    "                             width_shift_range=0.1,\n",
    "                             height_shift_range=0.1,\n",
    "                             zoom_range=0.2,\n",
    "                             shear_range=0.1,\n",
    "                             rotation_range=10.)\n",
    "datagen.fit(x_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6 - Train the model\n",
    "**Get the shape of my data :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images of the dataset have this folowing shape :  (24, 24, 1)\n"
     ]
    }
   ],
   "source": [
    "(n,lx,ly,lz) = x_train.shape\n",
    "print(\"Images of the dataset have this folowing shape : \",(lx,ly,lz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get and compile a model, with the data shape :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = get_model_v1(lx,ly,lz)\n",
    "\n",
    "# model.summary()\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Train it :**  \n",
    "Note : La courbe d'apprentissage est visible en temps réel avec Tensorboard :    \n",
    "`#tensorboard --logdir ./run/logs`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train for 612 steps, validate on 12630 samples\n",
      "Epoch 1/10\n",
      "  1/612 [..............................] - ETA: 1:57:56 - loss: 3.7702 - accuracy: 0.0156WARNING:tensorflow:Method (on_train_batch_end) is slow compared to the batch update (0.238514). Check your callbacks.\n",
      "612/612 [==============================] - 15s 24ms/step - loss: 2.1205 - accuracy: 0.4047 - val_loss: 0.8360 - val_accuracy: 0.7512\n",
      "Epoch 2/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.9110 - accuracy: 0.7209 - val_loss: 0.4255 - val_accuracy: 0.8871\n",
      "Epoch 3/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.6064 - accuracy: 0.8142 - val_loss: 0.3533 - val_accuracy: 0.9116\n",
      "Epoch 4/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.4648 - accuracy: 0.8560 - val_loss: 0.2755 - val_accuracy: 0.9246\n",
      "Epoch 5/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.3765 - accuracy: 0.8824 - val_loss: 0.2727 - val_accuracy: 0.9295\n",
      "Epoch 6/10\n",
      "612/612 [==============================] - 13s 20ms/step - loss: 0.3227 - accuracy: 0.8989 - val_loss: 0.2075 - val_accuracy: 0.9487\n",
      "Epoch 7/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.2795 - accuracy: 0.9126 - val_loss: 0.2256 - val_accuracy: 0.9431\n",
      "Epoch 8/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.2508 - accuracy: 0.9205 - val_loss: 0.2228 - val_accuracy: 0.9453\n",
      "Epoch 9/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.2268 - accuracy: 0.9282 - val_loss: 0.2177 - val_accuracy: 0.9459\n",
      "Epoch 10/10\n",
      "612/612 [==============================] - 12s 20ms/step - loss: 0.2088 - accuracy: 0.9358 - val_loss: 0.1811 - val_accuracy: 0.9509\n",
      "CPU times: user 2min 16s, sys: 4.9 s, total: 2min 20s\n",
      "Wall time: 2min 14s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "batch_size = 64\n",
    "epochs     = 10\n",
    "\n",
    "# ---- Shuffle train data\n",
    "#x_train,y_train=ooo.shuffle_np_dataset(x_train,y_train)\n",
    "\n",
    "# ---- Train\n",
    "#\n",
    "history = model.fit(  datagen.flow(x_train, y_train, batch_size=batch_size),\n",
    "                      steps_per_epoch = int(x_train.shape[0]/batch_size),\n",
    "                      epochs=epochs,\n",
    "                      verbose=1,\n",
    "                      validation_data=(x_test, y_test),\n",
    "                      callbacks=[tensorboard_callback, bestmodel_callback, savemodel_callback] )\n",
    "\n",
    "model.save('./run/models/last-model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Evaluate it :**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max validation accuracy is : 0.9509\n"
     ]
    }
   ],
   "source": [
    "max_val_accuracy = max(history.history[\"val_accuracy\"])\n",
    "print(\"Max validation accuracy is : {:.4f}\".format(max_val_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss      : 0.1811\n",
      "Test accuracy  : 0.9509\n"
     ]
    }
   ],
   "source": [
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "\n",
    "print('Test loss      : {:5.4f}'.format(score[0]))\n",
    "print('Test accuracy  : {:5.4f}'.format(score[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 7 - History\n",
    "The return of model.fit() returns us the learning history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhIAAAGdCAYAAABHM5ovAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3gc1b3/8fdXXbIs23IRtty7wXJMMYYUY8oNpAE3QOihk7AJEH4kIaQQknAhBAJcCEsgEDqhBhIuCSR0COCCccXgXiQX2ZYty5JltfP7Y1bSSqiuV5otn9fz6Nmd2TMz38UGfTjnzBlzziEiIiISiRS/CxAREZH4pSAhIiIiEVOQEBERkYgpSIiIiEjEFCREREQkYgoSIiIiEjEFCREREYmYgoSIRI2ZPWRmzsze9LsWEekdChIiIiISMQUJERERiZiChIiIiERMQUJEfGdm48zsXjNbY2bVZrbTzN42s4vNLLWdY1LM7Hwze8PMdphZrZltM7NlZvZnMzuhjWPGmNk9ZrbCzPaaWZWZrTezN83sWjMb1PPfViSxpPldgIgkNzP7OvAMkBXaVQ70Ab4U+jndzE52zlW2OvRR4Kyw7XIgDxgEHBj6eTnsOocAbwJ9Q7tqgUpgZOjnKOCj8GNEpHPqkRAR35jZOOBJvBDxFjDZOdcf75f9d4B9wHHA/7Y6bhZeiGgArgLyQsdlAcOA84F3W13u1tB55wCHOOcynHMD8ELLDOAOvDAiIt1geoy4iESLmT0EnAe85Zyb3YX2DwAXAquBac65qlafXwrcCzhgonNuVWj/j4GbgZedc1/pYm1VQDZwhHNuTle/k4h0TD0SIuILMzPglNDm7a1DRMj9QAlgwKlh+3eHXoeYWVf/O9Z4zNDu1ioi7VOQEBG/jAX6hd6/0VYD51wD3rwGgEPCPnoVqAnte9PMzjGzYZ1c7x+h10fM7LdmdoSZpUdUuYg0UZAQEb8MDntf0kG74tbtQ0MclwF78SZkPgqUmNna0F0ZB7dxnh8B7+HNk7gGeB/YbWavm9llZpYd+VcRSV4KEiISCzK7e4Bz7s/AGOAHwN+AHcBo4LvAh2b201btdwBfBP4LuBPvDo0M4GggCCw1s+GRfwWR5KQgISJ+2Rb2flQH7Rp/uW9r/YFzbqtz7n+dcyfj9VgcDjyPN6fiN2Y2rVV755x71Tl3pXPuELxbRb8DlOENtdwe8bcRSVIKEiLilzXArtD7o9tqEJpIOTu0uaCjk4VCwjzgNLzhkBS8HoiOjtnpnLsPaOy9OKpLlYtIEwUJEfGF8+49/2to80ozy2mj2cVAId7tn8827jSzjA7OW4+32BSEhkxCq2B2tADf3vD2ItJ1ChIi0hPSzWxQJz/pwI14q0sOA14ys0kAZpZpZpfgzWUAeKBxDYmQG83sWTM72czyG3eaWYGZ3Yk3d8IB/w59lAesMrOfmVlR47LboYBxLPA/oXav9Mw/DpHEpQWpRCRqwhak6oqjnXNvmtk3gKdpXiJ7F95qk423Zr4GnBS+RLaZ3QFcGXau3XjzIvqG7fuZc+7GUPv+wM6wz2qBCrzbTxuf5bEGOMo5V4yIdJmetSEivnLOvWhmRcCP8e6oGAZUAUuAR4A/h4Yrwt2OtxrmscAUvEWmMoGNeLd43u2ceyes/W7g63jLbX8ebwLnYLzekE+BF4C7nHMVPfEdRRKZeiREREQkYpojISIiIhFTkBAREZGIKUiIiIhIxBQkREREJGIKEt0UCARcIBDQDFURERF0++f+UJgQEZFkYm3tVI+EiIiIRExBQkRERCKmICEiIiIRU5AQERGRiGmyZZTU1tZSXFxMdXW136XEvKysLIYPH056enrnjUVEJKYpSERJcXExffv2ZfTo0Zi1ObFVAOccO3bsoLi4mDFjxvhdjoiI7CcNbURJdXU1AwcOVIjohJkxcOBA9dyIiCQIBYkoUojoGv1zEhFJHAoSCSQ3N9fvEkREJMkoSIiIiEjEFCQSkHOOH/3oR0ydOpWioiKeeuopADZv3sysWbOYPn06U6dO5Z133qG+vp7zzz+/qe3tt9/uc/UiIhJPdNdGDzj+Ny/12Llf+cXXOm3z17/+lYULF7Jo0SK2b9/OjBkzmDVrFk888QTHH388P/vZz6ivr6eqqoqFCxdSUlLC0qVLAdi1a1eP1S4iIolHPRIJ6N133+XMM88kNTWVgoICjjrqKObNm8eMGTN48MEHuf7661myZAl9+/Zl7NixrFmzhssvv5yXX36ZvLw8v8sXEZE4oiCRgJxr+8Gks2bN4u2336awsJBzzz2XRx55hAEDBrBo0SJmz57N3XffzcUXX9zL1YqISDzT0EYP6MrwQ6NNZZXsqa4FYEi/bPr3ydzv68+aNYt7772X8847j7KyMt5++21uueUW1q9fT2FhIZdccgmVlZUsWLCAr371q2RkZHDKKacwbtw4zj///P2+voiIJA8FCZ9lZ6Q1BYm9NXVRCRL//d//zfvvv8/nPvc5zIzf/e53HHDAATz88MPccsstpKenk5ubyyOPPEJJSQkXXHABDQ0NANx00037fX0REUke1l43uLQtEAg4gGAw2GL/8uXLmTJlSrfPV11Tx4btewBIS01hzJC+SbFgU6T/vERExDdt/nLSHAmfZaankpLi/dnU1TdQW9/gc0UiIiJdpyDhMzMjO6N5hGlvTZ2P1YiIiHSPgkQMyM5IbXq/d1+9j5WIiIh0j4JEDFCPhIiIxCsFiRiQlZ5KSmiCZW19A7V16pUQEZH4oCARA8yMrPDhjRoFCRERiQ8KEjFCwxsiIhKPFCRiRMsg0Ts9Erm5ue1+tm7dOqZOndordYiISPxSkIgRWRmpTQtR1dTVU6f1JEREJA5oieyecPEJ3T4kBZjQlYb3v9zuR9dccw2jRo0iEAgAcP3112NmvP322+zcuZPa2lpuuOEGTjrppG7VVl1dzWWXXcb8+fNJS0vjtttu4+ijj2bZsmVccMEF1NTU0NDQwHPPPcewYcP41re+RXFxMfX19fziF7/g9NNP79b1REQkfvjeI2FmE83s12b2gZltM7MKM1toZj8zsz7dOM9Xzew9M6s0szIze8bMxrTTdpKZvWBmO0Pt3zGzY6L3rfxxxhln8NRTTzVtP/3001xwwQU8//zzLFiwgDfeeIOrr7663aeDtufuu+8GYMmSJfzlL3/hvPPOo7q6mj/+8Y9ceeWVLFy4kPnz5zN8+HBefvllhg0bxqJFi1i6dCknnND9UCUiIvHD9yABXAhcBawGfg38CPgUuAF4z8yyOzuBmX0T+D8gO3T8LcAs4D9mNqxV23HAe8CRwO9C7XOBV8zsuCh9J18cfPDBlJaWsmnTJhYtWsSAAQMYOnQoP/3pT5k2bRrHHXccJSUlbN26tVvnfffddzn33HMBmDx5MqNGjWLFihUceeSR3Hjjjdx8882sX7+e7OxsioqKePXVV7nmmmt455136NevX098VRERiRGxMLTxLHCTc648bN8fzWwl8DPgIuAP7R1sZunAXcBG4EvOuT2h/f8EPgSuBy4NO+QmoD9wqHNuYajtI8Ay4G4zm+z290lmHQw/dKShwbF66+6mHoOxBXmkpXYv65166qk8++yzbNmyhTPOOIPHH3+cbdu28eGHH5Kens7o0aOprq7u1jnb+8dx1llnMXPmTF566SWOP/547r//fo455hg+/PBD/vGPf3Dttdfy5S9/meuuu65b1xMRkfjhe4+Ec25+qxDRqLGPvrNbB44ChgH3N4aI0HkXAm8Cp4fCBqGhkhOBNxtDRKjtHuB+YCIwI8Kvst9SUozM9Ob1JKojuHvjjDPO4Mknn+TZZ5/l1FNPpby8nCFDhpCens4bb7zB+vXru33OWbNm8fjjjwOwYsUKNmzYwKRJk1izZg1jx47liiuu4MQTT2Tx4sVs2rSJnJwczjnnHH74wx+yYMGCbl9PRETiRyz0SLRneOi1s374xl/877fx2QfAMXgBYRkwDcjsoG3j+eZ2q9Ioys5IpTq0jsTemjpys9O7dfxBBx1ERUUFhYWFDB06lLPPPptvfOMbHHbYYUyfPp3Jkyd3u6ZAIMB3v/tdioqKSEtL46GHHiIzM5OnnnqKxx57jPT0dA444ACuu+465s2bx49+9CNSUlJIT0/nnnvu6fb1REQkftj+9uL3BDNLBd4FDgOmOuc+7aDtXcD3gQOdc8tbfRYA7gaOd879y8xOwRtKCTjn7mnV9kC8sHGTc+6nbVznUuDSyy677FCAYDDY4vPly5czZcqUbn/X1iqraykpqwS8R4yPGtx3v88Zi6L1z0tERHqNtbXT96GNdtwBHAFc11GICMkJve5r47PqVm2607YF59x9zrnDOqllv4Uvlb2vtp76Bq0nISIisSvmhjbM7Dd4PQz3Oedu6sIhVaHXzDY+y2rVpjttfZGakkJmeir7ar35EdU19fTJ6rm8t2TJkqY7MhplZmYyZ86cHrumiIgkjpgKEmZ2PfBz4EHgu108bFPotRBY3uqzwtBrSRttW2vd1jfZGWlNQaKqpo4+Wd2bJ9EdRUVFLFy4sPOGIiIibYiZoQ0z+yXwS+AR4OJu3II5L/R6ZBufHQHsBlaEtpfgDWu01xZgfhev+xnRmm+S48NzN3pTLM7LERGRyMREkDCz6/DWe3gUuMA51+bEADMbamaTzSx8HsNbwGbgYjPLDWv7OWA28IxzrhaabvN8EZgd+ryxbS5wMbCSCO/YyMrKYseOHVH5Jdl6nkRDQ+L84nXOsWPHDrKysjpvLCIiMc/3oQ0z+x7wK2AD8CpwVuPDq0K2Ouf+HXp/E3AecDTeGhE452rN7Eq8dSfeMbM/AXl4q2Vuw+vlCHctcCzwLzO7Ha/H4hK8oY2vRboY1fDhwykuLmbbtm2RHP4ZOyqqqav3SqnankFGWmonR8SPrKwshg8f3nlDERGJeb4HCZrXgRgJPNzG528B/25jfxPn3DNmthdvfsWteMMXrwHXOOdKWrVdZWZfAH4L/ATIABYAJzjnXo30S6SnpzNmTJuP9ojIH/65lBfne4tHnfWl8Zw3e1LUzi0iIhItvgcJ59z5wPn729Y59394z9voynmWA917BGYvmzoyvylILN1Q5nM1IiIibYuJORLyWUUj85veLy/eRU1d4k26FBGR+KcgEaMG9s2iMN97inptfQOfbmrrcSQiIiL+UpCIYUWjmnsllqzf4WMlIiIibVOQiGHhwxtLNE9CRERikIJEDJs2amDT+4837qSuXs/dEBGR2KIgEcOG9MumoF82ANW19azaonkSIiISWxQkYtzU8OGN9RreEBGR2KIgEeOmhU24XKx5EiIiEmMUJGJc0cjmeRLLNpRRn0DP3RARkfinIBHjhuXnkJ+bCUDlvjrWle72uSIREZFmChIxzsxa3Aa6WPMkREQkhihIxIEWC1NpnoSIiMQQBYk4ED5PYumGMiJ80rmIiEjUKUjEgZGDc8nLTgegvKqGDdv3+FyRiIiIR0EiDqS0mieh4Q0REYkVChJxYmrYctlamEpERGKFgkScmNaiR2KH5kmIiEhMUJCIE2MK8sjJTANgR8U+Nu2s8rkiERERBYm4kZpiTB0xoGl7qeZJiIhIDFCQiCNFmichIiIxRkEijrRY4XLDDh8rERER8ShIxJEJQ/uRmZ4KwNZdeykt3+tzRSIikuwUJOJIWmoKBw5vniexZL16JURExF8KEnFGC1OJiEgs8T1ImNm1ZvaMma0xM2dm67p5/Pmh4zr6Kexi+z9E/QtG2bTwB3hpwqWIiPgsze8CgBuBMmAB0D+C498Gzm1j/1Dgd8BC51xJO9dd3mrfpxFcv1dNKuxPemoKtfUNFJdVUranmvzcLL/LEhGRJBULQWKcc24NgJktBXK7c3Do2DWt95vZtaG397dz6L+dc29251qxICMtlcmF/ZuGNZZu2MmsA4f6XJWIiCQr34c2GkNENJmZARcCe4HHO2jX18wyon39ntbiNlBNuBQRER/5HiR6yFHAeOA559yudtr8HdgNVJvZIjM7p9eq20/hC1NphUsREfFTogaJi0KvbQ1rVAFPAFcBJwI/ALKAR83sl+2d0MwuNbP50S40EgcO709qigGwtrSC3VU1PlckIiLJKuGChJn1B04BVuFNxGzBOfe0c+5s59wDzrkXnXN3AtOApcDPzWx0W+d1zt3nnDus5yrvuqyMNCYM7de0vXSjeiVERMQfCRckgLOAbOAB18VnbTvn9gG34k0+/XIP1hY1Wk9CRERiQSIGiYuAOuChbh63LvQ6KJrF9JQirSchIiIxIKGChJlNBw4BXnLObenm4RNCr1ujW1XPmDoiHwu9X72lnMp9tb7WIyIiySmugoSZjTSzyWaW3k6Ti0OvD3RwjoFt7OsHXAPUAK/sd6G9oE9WOuMOyAOgwcHHG3f6XJGIiCQj3xekMrNzgVGhzcFAhpn9PLS93jn3aFjzR/Bu7RxD81BE43my8OZHbAL+0cEll5jZW8ASoBQYjbfmxFDgaudc8f58n940dWQ+q7bsBrzhjRnjh/hckYiIJBvfgwTenIajWu37Tej1LeBRuuabwADgHudcfQft/gLMxptUmQeUA3OBC5xzcdEb0WjaqIG8MHcdAIs3aGEqERHpfb4HCefc7Gi0dc49gbc+RGfnuLqr14t1U8Pu3FixqZzq2nqy0lN9rEhERJJNXM2RkJb65WQwarD3aJL6BscnxZonISIivUtBIs61fO6GbgMVEZHepSAR58Kfu7FE8yRERKSXKUjEufAeiU9KdlFT19E8UxERkehSkIhzA/tmMSw/B4CaugZWbCr3uSIREUkmChIJYNrI8OENzZMQEZHeoyCRAMJvA12yXvMkRESk9yhIJIBpYQ/wWrZxJ/UNDT5WIyIiyURBIgEU9M9hSL9sAKpr61m5ebfPFYmISLJQkEgQ4Xdv6DZQERHpLQoSCaIobHhjqRamEhGRXqIgkSDCeySWbiyjvsH5WI2IiCQLBYkEUZjfh/zcTAD2VNexrrTC54pERCQZKEgkCDNreRuo5kmIiEgvUJBIIOG3gS7RPAkREekFChIJpKjVCpfOaZ6EiIj0LAWJBDJycC59s9MBKK+qYeP2PT5XJCIiiU5BIoGkmLVaT0LDGyIi0rMUJBJMeJBYrHkSIiLSwxQkEkzRqOZ5Eks1T0JERHqYgkSCGVuQR05GGgDbK6rZvLPK54pERCSRKUgkmNQU46CRA5q2NU9CRER6koJEAmp9G6iIiEhPUZBIQEUtFqbSCpciItJzfA8SZnatmT1jZmvMzJnZugjOsS50bFs/g9poP8zMHjGzbWa218zmm9lpUflCMWDC0H5kpqcCsGXXXkrL9/pckYiIJKo0vwsAbgTKgAVA//04zyfA/7Sxv8XTq8wsH3gXGALcBhQDZwFPm9mFzrkH96OGmJCemsKU4f1ZuNbrjVi6oYxjigp9rkpERBJRLASJcc65NQBmthTIjfA8W51zj3Wh3U+AMcCJzrkXQ9d9AHgfuNXMnnHOxf2SkNNGDmwKEksUJEREpIf4PrTRGCKiwczSzCyvk2ZnAasbQ0SohnrgLiAf+Gq06vFT+DyJxZonISIiPcT3IBFFM4EqoNzMdpnZw2Y2LLyBmQ0FCoEP2ji+cd+Mni2zd0wa1p/0VO+Pt3hHJTv37PO5IhERSUSJEiSW4c2POAs4E3gSOBuY2ypMNL4vaeMcjfvaHAMws0vNbH50yu15mempTCpsnnKyVLeBiohID0iIIOGc+5pz7gbn3LPOuSedc98Fvo0XCn4V1jQn9NrW/55Xt2rT+hr3OecOi1rRvaDFczc2aHhDRESiLyGCRFucc08A64Cvhe1uXC86s41Dslq1iXst15NQj4SIiERfwgaJkHVA+DoSm0KvbQ1fNO5ra9gjLh04fAApZgCsK61g994anysSEZFEk+hBYjywtXHDObcZLygc0Ubbxn1xMw+iM9kZaUwY2g8AByzbsNPfgkREJOHEVZAws5FmNtnM0sP25bfT9nvAcODFVh/9BRhnZt8Ia5sKXA7sAv4R9cJ9NC18eEPzJEREJMp8X5DKzM4FRoU2BwMZZvbz0PZ659yjYc0fAY7CW1BqXWjft83sIuDl0L40YDZwMrAa+GWrS/4WOA14wsxuw+uhOBPvts+LnXMVJJCpI/N55n1vqQ7NkxARkWjzPUgAF+GFg3C/Cb2+BTxKx+YBxwCn4wURA9YCNwO/dc7tCm/snNthZl/ACxTfw1tJ82PgDOfcU/vxPWLS1JH5GN7Qxqot5VTtqyMnMxb+2EVEJBH4/hvFOTd7f9o65/4DnNjNa5YA53bnmHiVm5XO2II8Vm/dTYODZRvLmDF+iN9liYhIgoirORISmRa3gWphKhERiSIFiSQQvjCVVrgUEZFoUpBIAlPDgsSnJbuorq33sRoREUkkChJJoH+fTEYO8p7OXtfg+KRE60mIiEh0KEgkCS2XLSIiPUFBIklMGzmw6b0mXIqISLQoSCSJ8HkSy4t3UlOneRIiIrL/FCSSxKC8LIYO8J6QXlPXwMrN5T5XJCIiiUBBIolM0zwJERGJMgWJJFIUNk9iseZJiIhIFChIJJHwOzc+3lhGfUODj9WIiEgiUJBIIgX9shmclwXA3pp6Vm3Z7XNFIiIS7xQkkoiZtVguW/MkRERkfylIJJmiUVpPQkREokdBIsm0foBXg3M+ViMiIvFOQSLJDB/YhwF9MgHYU13LutIKnysSEZF4piCRZMysxSqXS9bv8LEaERGJdwoSSajFwlSaJyEiIvtBQSIJtbhzY0MZTvMkREQkQgoSSWjUkL70zU4HYFdlDRt3VPpckYiIxCsFiSSUYsbUES3v3hAREYmEgkSSCl8ue7EmXIqISIQUJJLUtPCFqdZrnoSIiERGQSJJjS3oS05GGgDbK6rZsmuvzxWJiEg88j1ImNm1ZvaMma0xM2dm67p5fGHoHG+Z2WYzqzSzZWZ2i5kNbKP9+aHrtPXzh6h9sRiXmpLCgSMGNG0v2aDhDRER6b40vwsAbgTKgAVA/wiO/wZwPfAScAtQARwO/AA43cwOd85taee6y1vt+zSC68etaaPymb96G+ANb3z5cyN8rkhEROJNVINEIBAYANQEg8Hu3E84zjm3BsDMlgK53bzsO8CoVmHhT2Y2B/gT8MPQT2v/ds692c1rJZSpI7UwlYiI7J9uD20EAoFjA4HA70KhoXHfkEAg8BawHSgLBAK3dfV8jSEiUs65Ze30ODwVep3a3rFm1tfMMvbn+vFs4rD+ZKZ5fwU276xi227NkxARke6JZI7E5cA3g8HgzrB9twJfAlYBO4ArA4HAt6JQ3/4YHnrd2s7nfwd2A9VmtsjMzumdsmJHemoKU4aHzZNYr14JERHpnkiCxOeAdxs3AoFANnAq8O9gMDgJmARsBL4blQoj96vQ68Ot9lcBTwBXASfizaXIAh41s1/2XnmxoSj8NlANb4iISDdFEiSGAJvCtmfi/SJ+CCAYDFYA/4cXKHxhZlcDpwH3OedeD//MOfe0c+5s59wDzrkXnXN3AtOApcDPzWx0O+e81Mzm93DpvS78uRta4VJERLorkiCxD8gO2/4S4IC3w/btBvLxgZldjHf3xkvA97tyjHNuH97wTBrw5Xba3OecOyxadcaKyYX9SU/1/hps2L6HXZX7fK5IRETiSSRBYi1wTNj2KcDKYDBYErZvBN7Ey15lZhcC9wH/Ak5xztV24/B1oddB0a4rlmWmpzJxWL+mbQ1viIhId0Ry++fDwB2BQGAOUAMU0TwfodEh9PKaDGZ2Ad7tnq8CJ4d6GbpjQui1vcmZCatoZD7LNnpzZ5esL+NLU4b6XJGIiMSLSHok7gGeBA4DvoA3H+Lmxg8DgcDhwBTgzSjU14KZjTSzyWaW3mr/+cD9wBvASc656g7O0dZql/2Aa/CC0StRLToOTNOESxERiVC3eySCwWAtcFYgEPgu4EKTK8OtAQ6meaigQ2Z2LjAqtDkYyDCzn4e21zvnHg1r/ghwFDCm8fxmdiLwAN68jKeAU8ws/BJ7nHMvhG0vMbO3gCVAKTAauBAYClztnCvuSt2JZMrwAaSY0eAca7fupmJvLX2z0zs/UEREkl7EK1sGg8Hd7ezfTvfmR1yEFw7C/Sb0+hbwKB07BK9npT/e/IjW1gPhQeIvwGy8SZV5QDkwF7jAOZd0vREAOZlpjB+ax4pN5Thg2cYyjphY4HdZIiISB7odJEIrWg4FVgeDwX1h+y8ATgYqgTuCweDcrpzPOTe7q9duq61z7nq8Z2109RxXd7VtMpk2aiArNpUD3vCGgoSIiHRFJHMkbgTmhB8bCAQux5uj8A3gDODNQCBwYFQqlF4Rvp7E4vV6EqiIiHRNJEHiC8BrwWAw/MEMPwRKgFlA49LY/28/a5NedNCIfBpnlqzavJuqfXW+1iMiIvEhkiBRiLeWBAChnocRwF3BYPDdYDD4LPAiXqiQONE3O50xBXkANDjHx8U7OzlCREQksiCRDYTfXvkFvJUtXw3btxovcEgcmTYq7LHiGt4QEZEuiCRIlACTw7aPx7v1clHYvgGAnkkdZ6aGzZPQehIiItIVkdz++QZwXiAQ+D5ez8SJwHPBYLAhrM14vCeAShwJn3C5YlM5+2rryUxP9bEiERGJdZH0SNwE7AH+F2/dhmrCbr8MBAJD8NaFeC8K9Ukv6t8nk5GDcgGorW/gk5JdPlckIiKxrttBIhgMrgUOAq4ErgCmBoPB8OdqjALuJvRYcYkvLYY3NE9CREQ6EdHKlsFgcAvwh3Y+mwfM25+ixD/TRuXzjwUbAM2TEBGRzkW8RDZAIBBIx5t42R9vqenloWdxSJwK75FYXryT2voG0lMjGQETEZFkEFGQCAQCecDvgHOBrLCPqgOBwKPAT4LBoAbY49DgvGyGDshh884q9tU1sGLTLg4akd/5gSIikpS6/b+aoRDxH+BSoA54B3g69Fob2v9uqJ3EofC7N5ZqeENERDoQSZ/1tXiTLe8BRgWDwdnBYPDMYDA4m+aJlgeG2kkcKhoV/twNBQkREWlfJEMb3wQ+CAaD3z5SlA4AACAASURBVGv9QTAYLAcuDwQChwCnoDARl6aNHNj0/uONO6lvaCA1RfMkRETksyL57TASeLOTNm/hPX9D4lBB/2wG5XlTX6pq6li9ZbfPFYmISKyKJEhUAUM6aTM41E7ikJkxTctli4hIF0QSJOYBpwUCgQltfRgIBMbhPUpca0nEsaJRzcMbSzRPQkRE2hHJHIlbgH8B8wKBwF14z97YDBwAzAYuB3KBW6NUo/ggfD2JpRvLaHCOFDMfKxIRkVgUyRLZrwEBvPUjfgr8G1iK9xjxXwB9gO8Hg8FX2z2JxLwRA/vQv08GABV7a1lfWuFzRSIiEosimoofDAbvBSYC1wHPA6+HXn8BTAwGg/dErULxhZm1WE9iseZJiIhIGyJeIjsYDG4A/qetzwKBQBaQEQwGNd0/jhWNGsg7y7cA3jyJk2aM9rcgERGJOT21OMA9gP4XNs4VtbhzYwfOOR+rERGRWNSTqwxpZl6cGz2kL7lZ6QDsqqyheEelzxWJiEis0XKF0q4UsxZ3b2g9CRERaS0mgoSZXWtmz5jZGjNzZrYuwvN828w+MrO9ZrbVzO43s8HttJ1pZq+aWYWZ7Tazl81s+n59kQTUYnhj/Q4fKxERkVgUE0ECuBE4BlgN7IzkBGZ2FfAwUA5cCdwLnAG8aWZ9WrU9Am8Z7zF4d578EpgAvGNmRRF+h4Q0bVTLOzc0T0JERMJFfNdGlI1zzq0BMLOleAtadZmZDQJuwFtN81jnXH1o/zzg73jB4sawQ+4EaoBZzrmSUNungeXA74Ev79e3SSDjDsgjJyONqpo6tu+uZuuuvRwwIMfvskREJEbERI9EY4jYDycDOcBdjSEidN4XgTXAOY37zGw8MAN4pjFEhNqWAM8Ax5nZAftZT8JITUnhwBEDmrY1T0JERMJ1qUciEAjUd97KVzNCr++38dkHwJlmluuc29OFthcChwIvRb3KOFU0Mp/5q7cB3m2g//W54T5XJCIisaKrPRIWwU9vGhZ6LWnjsxK8eoZ1sS1AYfRKi39F4fMk9AAvEREJ06UeiWAwGBNDIB1oHLTf18Zn1a3adKdtEzO7FLj0sssui7TGuDVxWH8y0lKoqWtg884qtu+uZlBelt9liYhIDIj1gNBVVaHXzDY+y2rVpjttmzjn7nPOHRZxhXEsPTWFKcPD50noNlAREfEkSpDYFHpta0iiEHBhbTprC20PeyS1aVqYSkRE2pAoQWJe6PXINj6bCXwammjZWdsj8ELHh9EtL/5NHRW+MJWChIiIeOIuSJjZSDObbGbpYbv/BuwFvm9mqWFtvwGMAx5v3OecWwXMB04zs2FhbYcBpwGvO+e29PDXiDuTCweQluLNod2wfQ+7KtuaYiIiIskmJhakMrNzgVGhzcFAhpn9PLS93jn3aFjzR4Cj8FalXAfgnNtmZr8AbgVeNbO/4A1TXA18AtzR6pJXAm/grWR5V2jf5XjB6uoofrWEkZWeyqTC/izb6C08unRDGV+cMtTnqkRExG8xESSAi/DCQbjfhF7fAh6lE86535vZDuAqvJUrdwNPAz8JG9ZobPuemc3GWw3zBrzhjPeA05xzi/bjeyS0qSPzm4LEEgUJEREhRoKEc252NNo65x4CHuried4Hju3qdQWmjRrIU/9ZDWiehIiIeOJujoT458DhA0gxb57Emq27qdhb63NFIiLiNwUJ6bKczDTGD80DvLGgZRvVKyEikuwUJKRbisLWk1iq9SRERJKegoR0S9HIgU3v9dwNERFRkJBumToyv+mJbCs3l1O2p7rD9iIiktgUJKRb+manM7bAmyfR4Bw/fXwuu/fW+FyViIj4RUFCuu28oycSWuSStaUV/PTxuVRW6w4OEZFkpCAh3TZzQgE/PPFzLYY4fvaXuVTtq/O1LhER6X0KEhKRY6cN58qvFzVtLy/exXVPzqO6tt7HqkREpLcpSEjEvnLwSAInHNS0vWRDGdc/NZ+aOoUJEZFkoSAh++WkGaO55LgpTdsfrd3Ob55dQG19g49ViYhIb1GQkP126pFjOW/2xKbtuStLuem5BdQpTIiIJDwFCYmKs740gbO+OL5p+z+fbuWWvy2ivsH5WJWIiPQ0BQmJmm/PnsgpR4xp2n5z2SZuf3ExDU5hQkQkUSlIxILqvdAQ/xMUzYxLjpvCNw4b1bTv34uLuesfS3EKEyIiCUlBwm9rP4Vffw/++YzflUSFmRE44SBOOHhE075/LNjAH//1scKEiEgCUpDw08pl8Nv/B6Wb4G+PwJpP/K4oKlLMuOKrRRxbVNi074W563jgtU8UJkREEoyChJ/GToYxk7z3DQ3wp5thb6W/NUVJaopx9YnTmHXg0KZ9z7y/hsfeXuljVSIiEm0KEn5KTYVLroHsPt72ts3wRNDfmqIoNSWFa06ezpETC5r2Pfb2Sp58d5WPVYmISDQpSPhtYAGce3nz9vuvwQev+1dPlKWlpvDTUw7msHGDm/Y9+Man/HXOWh+rEhGRaFGQiAWHz4bP/1fz9mN/8HonEkRGWirXnXYo00cPbNp3778+5sX5632sSkREokFBIlacdRkMGea9r67y5kvUx/8toY0y01P51emHcdCIAU37/vDPpbyycKOPVYmIyP5SkIgVWTnefInUVG97zSfw4uP+1hRlWRlp/ObMGUwu7N+07/YXF/P6khIfqxIRkf2hIBFLxkyCk89r3n7pSVixxL96ekCfzHRuOPNwxh+QB4ADbvnbIt5ZnjhDOSIiyURBItYcfypMnu69dw1w/++gssLfmqKsb3Y6N549k9GD+wLQ4Bw3/fUjPlix1efKRESku3wPEmaWYmZXmdknZlZtZhvN7Pdm1qcLx15vZq6Dn9putP9hz33LbkhJgYt+CH28X7KUbYNH/hcSbCGnfjkZ/PacmQwf6P0x1zc4bnh2AR+u3uZzZSIi0h2+BwngduA24GPgcuAZ4ArgRTPrrL6/Aue28XNL6PMX2znuqjaOeSnyrxBlAwbB+Vc1b3/4LvznX/7V00MG5GZy8zlHMHRADgC19Q1c//R8Fq3b4XNlIiLSVWl+XtzMDsILD391zp0Stn8tcCdwBvBEe8c75xYDi9s4772htw+0c+gLzrl1EZbdOw7+PBz1NXgrlG+eCML4A+GAER0fF2cG5WVx8zkz+eEjH1Bavpeaugaue3IeN559OAeNyPe7PBER6YTfPRJnAgbc0Wr/n4Aq4JzuntDMcvACSAnwcgft8szM1yDVqW9dAkNHeu9r9sF9N0NdbcfHxKGC/jncfM5MBvbNBKC6tp6fPzGPTzft8rkyERHpjN9BYgbQAMwN3+mcqwYWhj7vrm8BecCDzrn2FmJYDJQD1Wb2npl9JYLr9LzMLLj0J5CW7m1vWAXPP+xvTT1kWH4fbj7nCAb08cJEVU0dP318Lqu3lPtcmYiIdMTvIDEM2O6c29fGZyXAIDPL6OY5L8K7q/DPbXy2C7gPbzjlJOBaYBTwkpmd39FJzexSM5vfzVr234ixcMqFzduvPAsfL+j1MnrDiEG5/PacmeRle8FpT3Ut1z4+l3WliXXXiohIIvE7SOQAbYUIgOqwNl1iZpOALwKvO+c+8zAH59wdzrnvOOceds793Tl3CzAN2Arcbma57Z3bOXefc+6wrtYSVceeBFPDLv3ArVCRmP+nPnpIX246eya5Wd6oU3lVDT95bA7FO/b4XJmIiLTF7yBRBWS281lWWJuuuij0en9XD3DO7QD+CPQHPt+Na/WelBS44GroG1oRsrwMHr494W4JbTR+aD/+56zDycnwwsTOyn1c8+gcNu/szl8FERHpDX4HiU14wxdthYlCvGGPmq6cKDRx8ttAGfB8N+tYF3od1M3jek+/AXDB/2veXvgBvBk7d6xG2+TCAfzmzBlkpntLhm+vqOaax7w7O0REJHb4HSTmhWo4PHynmWUB04HuzEn4BlAAPNrOnIuOTAi9xvbSitMOh+NObt5++j4oWedbOT1t6sh8fn36YWSkeX9Nt+7ayzWPfcCOiupOjhQRkd7id5B4Cm9i5A9a7b8Eb25E01OrzGycmU3u4FyNwxptrh1hZmlm1q+N/SOAy4AdwHtdL90np1wIw8d472tr4L7feq8JavqYQVx32qGkp3p/VTeVVXHNox+wq7K7WVFERHqCr0HCObcEuBv4ppn91cwuNrPf4610+RYtF6N6DVje1nnMbBhwAjA3dM625ALrzOxBM/uxmV1iZrcCS4B+wGXOudjvN0/P8G4JTQ/dzFKyDp5tb92txDBj/BB+dsohpKYYABt3VPKTx+awuypxA5SISLzwu0cCvN6IHwIH4YWKM4C7gK875xq6eI7zgVQ6nmS5F3gOOAzvts8gcDbwKvB559wzkRTvi2Gj4PTvNG+/9jdYPMe/enrBkZMK+Ml/H0woS7C2tIJrH5/DnurEW6BLRCSemEvQmf89JRAIOIBgMOhvIc7B3b+Ghe972337wfX3QL/EXlb6tcXF3PK3RTT+rZ1S2J8bz55JTmZsL1IqIpIArK2dsdAjIZEwg/N+AP0HetsV5fDnW6Ghq5048enYacP5wdeLmraXl+ziF0/Oo7qmzseqRESSl4JEPOvbz3vkuIVC4rIF8OoL/tbUC044eCTfO+Ggpu2lG8r45dPz2Vfb3oroIiLSUxQk4t2Ug+H405q3n/uz90yOBHfijNFc+l9TmrYXrt3BDc9+SG19YvfIiIjEGgWJRHDyuTA6tBRGfZ33lNB9ib/WwilHjOX8oyc1bc9dtY2bnltAncKEiEivUZBIBGnpcMlPvKeFAmzZCE/d629NveTML47nrC+Nb9r+z6db+d0LC6lv0CRiEZHeoCCRKAoK4axA8/bb/4QP3/Wvnl707aMmctqRY5u23/p4M7e9uIgG3ZEkItLjFCQSyef/C2Yc1bz98B1Qts2/enqJmXHRsZM5acbopn2vLi7hzpeWoNubRUR6loJEIjGDcy+H/CHedtUeeOAWaEj8uxnMjO8efyBfOXhE075/frSRe175WGFCRKQHKUgkmpxcuOTHYKE/2k8Xw8vxs2jn/kgx44qvFXFsUWHTvr/NW8cDr32iMCEi0kMUJBLRhKnw9TObt194BNZ84l89vSjFjKtPnMZRBw5t2vfM+2t49K2VPlYlIpK4FCQS1dfPgnEHeu8bGuBPN0N1lb819ZLUlBR+fPJ0Pj+poGnf4++s5C/vJv76GiIivU1BIlGlpsLFP4bsHG9722Z43Ofng/SitNQUrv3mwcwYP7hp30NvfMpT/1mlW0NFRKJIQSKRDT4Azrm8efv9V2HOG/7V08sy0lL5xamHMn3MwKZ9f379Uy695y1eWbhRC1eJiESBgkSim3k0HHlc8/Zjd8G2Lf7V08sy01P51bcOY+rI5qeiFpdVctuLi7ng7jf5+7x1ekaHiMh+UJBIBmcHYHBo8uHeKrj/ZqhPnl+eWRlp/M9Zh3PWl8aTm9X8uPHS8r3c/fIyzrvrDZ55bzVV+/QEURGR7lKQSAZZOd4S2qmp3vbq5fB/T/hbUy/LSk/lvNmTeOSKY7jwmEn0y8lo+mxn5T7uf+0Tzr3zdR59awW799b4WKmISHxRkEgWYyfBSec2b//fX2DFUv/q8UmfzHRO/8J4HrniGC47/kAG5WU1fbanupbH3l7Jt+98nftfXU7ZnsR/8JmIyP5SkEgmJ5wGk6Z5710D3P87b/XLJJSVnsrJh4/hoe8fzQ++XsTQATlNn+2tqeeZ99dw3l1v8Id/LmXrruS4bVZEJBIKEskkJRUu+pG3+iVAWSk8cick8aqP6akpfOXgkTwQOIprTp7OqMG5TZ/V1DXw4vz1XHD3m9z690UU70jO0CUi0hEFiWSTPxjO+0Hz9vy34b1/+1dPjEhNSeGYokL++J1Z/PJbhzJxWL+mz+obHP9eVMzFwbf4n+cWsHrLbh8rFRGJLWmdN5GEc+gXYdZXvEeNAzwRhPEHeY8iT3IpZnx+0gEcObGABWu38+S7q1i8vgwAB7z98Wbe/ngzMycM4cwvjmfK8AH+Fiwi4jP1SCSr078DB4SelLmvGv70W6ir9bemGGJmHDp2MLd8+0huO//IFitkAsxZWcoPHnyPax79gIVrt+uhYCKStBQkklVmFlx6DaSle9vrVsILj/pbU4w6aEQ+N5x5OHdf/EW+NOUALOyzhet2cM1jc7jqwff4YMVWBQoRSToKEsls5Hj45gXN2688A8s/8q+eGDd+aD9+fuqh3PfdWRw3rZAUa44Uy0t28cun5nPZfe/w5rJNep6HiCSNmAgSZpZiZleZ2SdmVm1mG83s92bWp4vHu3Z+2pxmb2aTzOwFM9tpZpVm9o6ZHRPdbxUnjjsZDjrUe+8cPHArVJT7W1OMGzm4Lz86aToPfm82Xzt0JOmpzf8arS2t4Ka/fqTneYhI0rBY6Io1s/8FrgCeB/4JTAEuB94BjnPOdfhfYzNzobb3tfqo1jn3VKu244C5QB1wB1AOXAJMBb7inHu1o2sFAgEHEAwm0JM0y8vg+suaA8T0I+F714FZx8cJADsqqnn2gzW89OGGzzy3Y0i/bE47cizHTx9BZnqqTxWKiERFm78UfA8SZnYQsAR43jl3Stj+y4E7gbOdcx2u5xwKEg87587vwvWeBk4BDnXOLQztywWWAdXAZNfBP5SEDBIAi+fCndc1b59zOcz+mn/1xKHyqhpemLOWv81bR2Wr53YM6JPJKUeM4WuHjiInUzdLiUhcajNIxMLQxpl4xd3Rav+fgCrgnK6eyMwyQqGgvc/7ACcCbzaGCADn3B7gfmAiMKPrpSeQaYfDsSc1bz91L2xa7189cahfTgbnHT2JR684hguO1vM8RCQ5xEKQmAE04A03NHHOVQML6fov9lPxgkeFmZWa2V1m1q9Vm2lAJvB+G8d/EFZPcjr1Iigc7b2vrYH7fuu9Srf0yUrnjC/qeR4ikhxiIUgMA7Y75/a18VkJMMjMMtr4LNxc4Hq8MHEe8DrwfeCdVj0Uw8LO29a1ANpclcnMLjWz+Z3UEd/SM+DSn3ivAMVr4bk/+1tTHNPzPEQkGcRCkMgB2goR4M1ZaGzTLufcTOfcrc65F5xzjzjnzgB+BhQBV7a6Fu1cr8NrOefuc84d1lEdCaFwNHzrkubtV1/w5k9IxPQ8DxFJZLEQJKrwhhvakhXWprtuAWqA8BmDjedp63r7c63EMvvr8LmZzdsP3gblO/2rJ0HoeR4ikohiIUhswhu+aOuXeyHesEe3B+qdc7WN5251rcbztnUtaHvYI7mYwfn/D/rle9sVu+DB30OD1kSIhsbnedx54Re48ezDmTYqv+mzxud5BP70Dtc9OY/lxQpwIhLbYiFIzMOr4/DwnWaWBUwHIpqXEDp+OLA1bPcSvGGNI9s45IjQa2LPg+iqvv3goh82by+dD6/9zb96ElBXn+dx1YPv8cz7q9m4XcMeIhJ7YiFIPIX3P2I/aLX/Erz5Co837jCzcWY2ObyRmQ1s57y/wXu66YuNO0K3eb4IzDazz4WdIxe4GFhJq7tHktqBh8DxpzZvP/dn2LDav3oSWOPzPP7QxvM8Pi7eyf2vfsLF97zFhXe/yb3/+piFa7dr1UwRiQm+L0gFYGZ34d1l8TzwD7yVLa8A/gMc07iypZmtA0Y55yzs2NvxehPeADYAucBXgaOBOcDRzrm9Ye3H44WFWuB2YDdeaCkCvuace6WjWhN2Qar21NXCjVfBhlXe9gEj4Bd3eQ/9kh6zYVsFT723mteXbKKhnX9HczLTOGzcYI6YMIQZ44eQl9PZzU0iIvslNle2BDCzVLweiUuB0cB2vJ6K60K9CI3t1vHZIHESEMBb4nogUI/Xs/A0cFtoPYrW15sC/BY4CsgAFgDXd7Y8NiRhkADYUgy//h7UhG52OeqrcO4V/taUJHbu2cfcVaXMWbGVD9dsp7rVEtyNUgymDB/AERMLmDlhCCMH5WJa4lxEoit2g0Q8ScogAfDuK/DQ7c3bgV/AIV/wr54kVFNXz+L1ZXywYitzVpZSWr633bZDB+Qwc8IQZk4ooGhUfosHi4mIREhBIhqSNkg4B/feCPPf8bb79IVfBiF/cMfHSY9wzrGutII5K0v5YOVWPineRXv/JudkpHHouEHMnFDAjPGD6d+nvbutRUQ6pCARDUkbJAAqK+BXASjb5m0PHQmHHwUTi2Ds5OYVMaXX7arcx7xV25izcisfrt5OVU1dm+0MmDy8P0dM8IZARg/pqyEQEekqBYloSOogAbBiKdzyY2j9ZPe0dC9MTJzqBYtxB2pCpk9q6xtYsr6MOSu38sGKrWzZ1f4QSEG/bA6fMIQjJhYwbVQ+GWl61LmItEtBIhqSPkiAt2z2M3+C+rYn/gGQmgqjJsDEaV64mHAQZPfpvRoF8IZANmzfwwcrSpmzcivLi3fS0M6/8lnpqRw6dhAzJxZw+PghDMjVEIiItKAgEQ0KEiE7t8Oni2HFEu9nS3HH7S0FRo4L9VhM84JFbl7v1CpNyqtqmL+qlA9WljJ/9Taq9rU/BDKpsH/ThM2xBRoCEREFiahQkGhHeRmsXAqfhoJFybrOjykcDZMaeyyKoN+Anq5SwtTVN7B0Q1nThM1NZe0/ZmZwXlZTqJg+ZqCGQESSk4JENChIdNGe3S2DxcY1n51X0doBI7xQMWkaTJiqO0J6kXOO4h2VfLByK3NXlrJ0w852F8LKTE/l4DGDOGLiEA4fP4SBfTUXRiRJKEhEg4JEhKoqYdVSb7LmiiWwbkXnDwEbPNSbuNk4HDKowHugmPS43XtrmL9qG3NWljJ/dSl7qtseAgGYOLQfM0MLYY0/IE9DICKJS0EiGhQkoqR6L6xeDitC8yzWrvCW4+5I/mCvp6JxOKRguIJFL6irb+Dj4p1NC2EV76hst+3AvpnMnFDAIWMHMa4gjwMG5JCiPyORRKEgEQ0KEj2kZh+s+aR5OGTN8uYludvTb4A3t6JxOGToSEjRCo49rWRHpXdr6cpSlm4oo76920CA7IxURg/py9iCPMYW5DFmSF/GDMkjJzOtFysWkShRkIgGBYleUlcL61Z6PRafLoFVH8O+9tdDALy7QCZMbR4OGTEWUjQpsCftqa5l/uptzF1ZytxVpVTs7aRXKWTogBwvXISFjIL+2RoWEYltChLRoCDhk/p67wmkjbebrlwGVXs6Pia7j3eb6YQimFQEI8dDmv5PuKfUNzSwvHgXc1eW8unmXazdWkF5VU2Xj8/JSGNMQevei75kZejPTCRGKEhEg4JEjGioh+J1zcFixVLYU97xMZlZMP4gmDIdDjwYho/VUEgPcs5Rtmcfa7buZs3WCtaW7mbN1t1s3F7Z7h0hrRkwLL8PY8KHRwr6UtBPvRciPlCQiAYFiRjlHGze4A2DrFzivZaXdXxMbh5M/pwXLKYc7N0lol9OPa6mrp4N2/awpjQUMLZ6AWN3F4dFAPpkpjGmII+xBd6ci7EFeYwe0pesdA1lifQgBYloUJCIE85B6abmHotPl0BZacfHDBziBYop02HydC2Q1Yucc+yo2NfUa7FmawVrtu6meEf3ei8K8/s0BYzGHozBeVnqvRCJDgWJaFCQiGPbtsAnC2H5R7B8IVR0MhRSONobApky3ZvAmZXTK2VKs5q6etZv2xMKF80hY09113svcrPSw3ouvIAxanBfMtV7IdJdChLRoCCRIBoavGW8l4eCxYolsK+6/fapqTBmUqjH4mAYO8l74qn0Oucc2yuqWbN1N2tDPRdrtu6mpKyy3QeStZZiXu9F+LyLMUPyGJSXpXUvRNqnIBENChIJqq4W1n4aChYLvXUsOnq6aWaWdzfIgaH5FYWjNXHTZ/tq61m/reIzkzs7WpWztYy0FIYN6EPhwD4U5vdh+MA+DMvvQ2F+DgP6ZGqIRJKdgkQ0KEgkieq93uJYH3/kDYdsXNNx+779vHkVTRM3D+idOqVDzjm27a5uMSyytnQ3JTsq6e5/+XIy0hiWn8Pwgbnea74XOIbl9yEvO6NH6heJMQoS0aAgkaR274JPFoXmV3wE27d23H7w0OZQMXka9O3fO3VKl1TX1rOutKLF5M6N2/d0a92LcHnZ6RTmN/dkNP0M7EO21sGQxKEgEQ0KEgLAts3eEMjHH3kBo7M1LEaMa16/YsJUb2hEYs6e6lpKyiop2VHpvYbeF5dVUrWv60Mk4fJzM1uEjOH5Xi/GsPwcPY5d4o2CRDQoSMhnNDRA8dqWEzc7ek5IahqMm9LcYzF6olbcjHHOOcqraigpq6R4R2WLsLGprJJ9dZ08ybYNBgzpl90UMIaFQkZhfh8K+meTlqo5NxJzFCSiQUFCOlVX6z2ArLHHYu0nHT8yPTPbW8K7cQ2LwtFaGCuONDjHjorqpmBRXFbJplAvxpadVdR19VaSMKkpxgH9c8KGSnIozM+lMD+Hwf2ydWeJ+EVBIhoUJKTb9lZ6S3g39liUrOu4fd4Ab8XNxjUsBhb0SpkSffUNDZSWV1O8Yw+bQiGjpKyKkh17KC3f2+XbVcNlpKUwdIA32XNofh/yczNDP1nea99McjLSdIeJ9ITYDBJmlgJcCXwHGA1sA54GrnPOVXZy7ETgHODLwDggC1gNPAPc0fp4M7se+GU7p/uRc+7WzupVkJD9Vl7WPHHz44Wdr7iZkQmW4i1+YCnebaaf2TbvSadmYZ+H9rdok9LJMW216eh87Vwzb4C31saoCV798hk1dfVs2VlFSVkVxWV72FRWFQocVWyv6GBNky7ITE9tETAG9s1kQB8vZDQFjtxM8nIy1Lsh3dHmX5ZYGJi9HbgCeB74PTAltH2wmR3nnOto8PFC4HvA34HHgVrgaOAG4FtmdoRzrq1nT18FbG+178P9+hYiXdUvH2Ye7f04B6Wb4ZOPmiduVla0bN/RfItYl5rqPc597BRvXsjYqajLKgAAEwRJREFUKTCoQEM3QEZaKiMH92Xk4L5Ay16n6po6r+eirOWkz5Kyyi7dWbKvtp7NO6vYvLOqw3ZpKUb/Vj0aA3Mzye+b1SKIDMjNIFXrpEg7fO2RMLODgCXA8865U8L2Xw7cCZztnHuig+MPA1Y658pb7b8B+BlwuXPuD2H7r8frkRjjnFsXSc3qkZAe1dAAG1c3D4OsXBbfQaIteQNg7GQvWIyb4vVa6C6WLgu/s2Rr+V7K9lRTVrGPsj37vPd79lETweTPjhjQr09Gi96MFkMqYT0dWno8ocVkj8SZ/P/27j5Isqo+4/j3190zPdMzO7OwCywLyyJqVhQtlBdfQjRGY0yM0ZQhBgVfCQUXTUFZmhQqrGJFY/lCiV4NlFFBMJCKGDVqiVFQQYWNWQVlQYHlbdmX2d0Zdt5nun/549yeudPTMzvTO9t3tvf5VF3O9Lm3757uGqafPvecc0PDrqqpvxb4GOGyxZxBwt03zbHrJkKQOGWu55pZDzDs7o3N6RI5GHK58MG6/pnw6rPD7dInJkLpHoKGV6DiSVnvsc8+fsZzax+nnlv7/Hrnqh5Te67q/nIZdjwBD94H2x+b/Rqf2gubfxa26ms+/qSkxyIJGLoT65y6O9rYsHYlG9bWX5vE3Rkam2TPvtEkXMwMGXsGx6b2DS1wSqsD/UPj9A+N89B+llDpKhaSsRoddcdvHNlVpLeryIrONl1WaRFZB4kzgApwV7rS3UfNbHOyvxHHJ+Vcv/K/BlYAZTO7C7jS3b/b4L8lcvDk8lA8hL/hDe0LS48/eF9YdvyhLTBS091eqcCjvw/bj74V6lb0ToeKk04OU2Q7Opvf/kOQmdHd0UZ3R1ty2WRuoxNl9lZDxr5Q7k6HjyRwLGahrqGxSYbGJnls97xD3MgZrOhsp7fUzsquUPaUkseldnpLRXqT+uq+Nk2JXZayvrRxD3C0u88alm5mNwNnA0V3X/BvsZnlgZ8CpwOnuPv9qX2XEMZg3AnsBTYAlwDHAu9w9y/Pc94LgAsuuuii00CXNkQaUqnAk4+GQFENF9se3f/zLAfHP23mJZGj16rXokkmyxX2Do0loWM6ZOyu6e3YOzhGuZGpKAvUVSykwkWR3lJbUs4OJCtL7XRoVdGltvxmbZjZg0Cbu59QZ991wHnAEe7ev4hzXg28C7jM3T+6gONXAfcSZnysc/fB+Y7XGAmRJTY8mOq12BK24Xn/Nwy6e0KwOOlkePqzwt1Zdav3TFXceWp4fObllJrxG3uHxhgYGl/wZZUDUSzk6O2aDhoztq7auiLdHZo2ux/LcozEMHD0HPs6UscsiJldSQgR1ywkRAC4+24z+wKwEXgJ8P2F/nsisgRK3fCc08IGoddi++NJqLgvBIxtj4SxGGmDT8Gv7wobhF6L49bPvCRyzHGtcVdWdxgbgeGhsC7J8GD4eWJscVOC604BTj83P/8U4PmmEJuRM2NlV5GVXUVO2s/yJxPlCk8NjzNQ3YbGGRgeo394fEZ9/1Ao942ML3rdjbHJCjsHRtg5UG/y3mz5nM0IFz2pn7s72ujqKNBdbKOro42uYiGpa6NULJDPHb4BJOsgsQ14tpkV3b12aPpxQN9CL2skMzI+AHwJuHCR7dialKsX+TwRWWq5HKw9IWxnvSrUjQzN7rWonSbryVLljz8MP06GPJW6p3ssTjo59FqUupr7eiAMWB0ZnhkEpsrh6WBQrU+HhZGhUM47E36ZWNB6JznIF2jL5VmVDxu5fFg6Pp8PWy5dl4POAt6VZ9KNMTfGHcYqxljZGa0YI2VnZBJGys7whDM0CUMTFSbcmLQcZXJMWo4KRtlyTJKjnNTPfGyUR3KUd+fotxy7k2PGrcCefImKzR1KS+0FSlNBo0BXRxvdxcKs0DH9c4GuYtvUz4fyfVeyDhJ3ExaTOhP4SbXSzDqAU4EfL+QkZnYFYVrndcD5vvjrNc9Myv2MRxaRTHR2wbNfEDYI39B3PA4PbpkexPn41tkftsODcO/dYYPwQXbsCTNniKxZt/9ei8mJ5AN9GEYGZ3/IjwzO7i2ohoSRwdkDTFuVV6AMyX+WlAFtyZaFMsau/Ap2FFawo9DD9sIKdhZ6ph7v8m6Gxyfpo7HFxNryuRAqquFjKmjUhJGp/amg0lHIdDXTrMdIPBf4FXOvI3Geu381qXs6YTzFlppzXA58CLgeeNtcC1iZWQHoqrPmxDpgM2GG07o5FrCaojESIsvU6DA8/MDMgZyDT+3/eZ1dYRXO1WtSvQY1wWA5rOXRXgw9LKUu6OwO7S4W60znrdSZ+jvHFN6FTCeuO923zvkOcyFodLMzCRbVgLEjnwSNQjdlO3i9DjmDUjF9+SUEjw+efdpSTrNdfmMk3P0eM/sc8C4z+zrwHaZXtrydmWtI/A+wntQLMbOLCSHiUeAHwJtqEtkOd781+bkbeNjMvgHcx/SsjfOTfefsL0SIyDLWUUruqHpqeFxdNfSh3073XDz+8OwPvZEh+M0vD377OkshAJS6QggodYVgUP25uq+UOiZ9/HK/Q2y9tUWmwkg6mJRDWZ4MP5eTrVIOdeX0vuTx1M/pY8uzzzH1uOb8lTJMJo/3e3xtG8owOgL75h/zn8dZU97HmvI+GNs2a3/FjMGOXvZ2rGR3ew87Cz08mV/BY3TxSKXE9lw3kwcQNCoeFisbHJ1gB+GjrKMt35S1OpbDb+YlhDEKFwCvISxdfTXhXhv7i7nVdSZOAL5SZ//tQDVIjAD/CbwQeD0hPPQRAsjH3f2uOs8XkUOVGRyzNmwvfmWoGx2BrQ/MHMi5b2D+80C4xj/1wV9KBYDuOqEgdUy1vqMzXPNvZVYdrNmir3NsFPbsgt07wtaXlLt3hp8H9sz79Jw7PSP99Iz0s77Ofjej0nMkEytXM9azmqEVq9hXOoL+jpX0ta9kV9sK9k04g6OTDI9NMDg6ydDYBEOjkwyOTjA6MftyUndHcy4EZX7TrkONLm2ItBB36Ns+PXizs2tmAKiGhGKn1qyQ+U2Mh1CRDhfpwDGwZ/bMo8VauQpWHR3uCLz6mFCuOhpWH8Nk72qGPc/g6ERYFGx0grI7p5101NK8vmD5XdoQEcmUWViO+6hjs26JHOra2mHN8WGrZ2Ic9vTB7u0hXOypCRv9u/cfNPp3h+3B+2btKgA9vUfQs6oaMJKwse5PQ9sOIgUJERGRg62tffpSWz2TE7C3b3ZPRrV3Y2/f/qcAD+wN20PJnATLwVl/trSvow4FCRERkawV2ubvHZucDGGidoxGtXdjz67ZA4mPWN2UQboKEiIiIstdoQBHrQlbPeUy9Fd7NJKxGvnmDHxVkBARETnU5fPTYyOarAUWoRcREZGsKEiIiIhIwxQkREREpGEKEiIiItIwBQkRERFpmIKEiIiINExBQkRERBqmICEiIiINU5AQERGRhilIiIiISMMUJERERKRhutdGg6IoyroJIiIizeRxHFttpXokREREpGHm7lm3QQAz2+Tup2fdjlan97k59D43h97n5tD7PD/1SIiIiEjDFCRERESkYQoSy8c1WTfgMKH3uTn0PjeH3ufm0Ps8D42REBERkYapR0JEREQapiAhIiIiDVOQyIiZ5czsUjPbYmajZvaYmX3SzLqyblurMLM/MLMPm9nPzWyXme0zs81m9n69zweXmZXM7GEzczP7bNbtaTVmdqSZfcLMfp/8/dhlZj8ysz/Kum2twsy6zewyM7sn+dvRZ2Z3mtnbzGzWokyHM61smZ1PA/8A3AJ8Ejg5efx8M3ulu1eybFyLeAdwMfBN4AZgAng58BHgb83sRe4+kmH7WtmHgdVZN6IVmdl64DagG/gi8ADQCzwPOC67lrUOM8sB3wVeAnwFuBooAecAXyL8vf7HzBq4zGiwZQbM7DnAPcAt7v6GVP27gc8Ab3b3G7NqX6sws9OB37n7QE39R4D3A+92d31bXmJm9gLgLuB9hJD8OXd/V7atah1m9hPgROBMd38y4+a0JDN7MXAncJW7X5qqbwe2AEe6+8qs2rfc6NJGNs4BDLiqpv5aYBg4t+ktakHuvqk2RCRuSspTmtmew4GZ5Qm/x98Dvp5xc1qOmb0UOAv4uLs/aWZtZlbKul0tqCcpt6Ur3X0c6AOGmt6iZUxBIhtnABXCt7Yp7j4KbE72y8FzfFLuyLQVrelS4FmAeiAOjr9IykfN7FvACDBkZg+Ymb6ALJ27gH7gfWZ2tpmdYGYbzOyjwGnAxkxbt8woSGRjLdDn7mN19j0BrE660GSJJd+YLwcmAV0+WkJm9jTgQ8CH3X1rxs1pVRuS8lrgSOCtwDuBceB6M3t7Vg1rJe6+F/grYA9wM/AI4ZLGxcAb3P3aDJu37GiwZTZKQL0QATCaOma8Oc05rFwFvAi4zN3vz7oxLebzwMPAp7JuSAtbkZT7gJcnXe2Y2S3AQ8A/m9lXNFh7SQwC9xIGa99JCG4XAzea2evc/dYsG7ecqEciG8NAcY59HaljZAmZ2ZWELvdr3P2jWbenlSTd6q8CLnT3iazb08Kqs4y+Vg0RMPUN+pvAGqZ7LaRBZvZcQni41d3f6+63uPsXCeNTtgPXJr2bgoJEVrYRLl/UCxPHES57qDdiCZnZRuADhKlbF2bbmtaS/B5/CvgOsN3MnmFmzwDWJ4f0JnUa5X7gHk/K7XX2VWdwHNGktrSySwlf6v4jXenuw8B/E363T2x+s5YnBYls3E14789MV5pZB3AqsCmLRrUqM7sCuAK4DjjfNed5qXUCRwGvAX6X2m5L9p+bPD4/i8a1mOoA7ePr7KvW7WxSW1pZdT2Oer0OhZrysKcgkY2bAAcuqan/e8LYiBua3qIWZWaXE0ZYXw+8XdeOD4oh4Ow6W5Ts/17y+JuZtK61fIMwPuJcM+uuVprZscDrCeum/D6rxrWQ3ybl29KVSa/a64C9wINNbtOypQWpMmJmVxOu199C6BKurmx5B/An+sA7cGZ2MfBZ4FHgg4Qpt2k7NGDq4DGzEwmDL7Ug1RIyswuAfwV+A/wb0A5cBBwL/KW7fz/D5rWEZPXQXxIuE91A+Lt8JOHL3onAxe4eZ9bAZUZdM9m5BNgKXEDoEu4jLMN6uULEkqmux3ECYZnbWrcDChJySHH3a8ysj7By6JWEgPwz4E3ufkemjWsR7v6ImZ1JmCr+CuDvCANdNwPvcXcttpaiHgkRERFpmMZIiIiISMMUJERERKRhChIiIiLSMAUJERERaZiChIiIiDRMQUJEREQapiAhIiIiDdOCVCJy2IqiaCPhPiwvj+P4tmxbI3JoUpAQkYZFUbSQFe30IS3SwhQkRGQpfGiefVub1QgRaT4FCRE5YHEcb8y6DSKSDQUJEWma9JgEYD3h5nXPItwa+9vAZXEcb6/zvGcS7uD6CuAowk3ufgBcGcfx7+ocnyfcqfE84BTCHTKfAG4D/mWO5/wN4UZYpwCjwPeB98Rx/MSBvGaRVqdZGyKShUuBLwC/Aq4C7gfeDtwZRdFR6QOjKDoD2AScC9wNfAL4OfBmYFMURafXHN8OfA/4PLAOuBH4DPC/wF8Df1inPRHwVcJlmM8B9wJvBH4QRVHxgF+tSAtTj4SIHLCkp6Ge0TiOP1an/s+BF8Zx/H+pc3ya0EPxMeCdSZ0B1wE9wLlxHN+QOv6NwL8DX42i6NlxHFeSXRuBVwLfAs6O43gs9Zxicq5arwbOiOP4ntSxNwLnAK8Dbp7zxYsc5tQjISJL4Yo5tn+a4/jr0yEisREYAN6U6gV4CeHSx8/SIQIgjuObgJ8CG4CzYOqSRgSMABemQ0TynLE4jnfVac9n0iEicW1SnjnHaxAR1CMhIksgjmNb5FNur3OOgSiKNgMvA04GNgMvSHb/cI7z/JAQIp4P/JgQOnqBX8RxvG0R7dlUp+6xpDxiEecROeyoR0JEsrBjjvrqQMvemvLJOY6v1q+sKRc7QLK/Tt1kUuYXeS6Rw4qChIhk4Zg56tck5UBNuabOsQDH1hxXDQTHNd40EVkMBQkRycLLaiuiKOoFTiVMvbwvqa6Oo/jjOc5Trf9lUm4hhInnRVG0dikaKiLzU5AQkSycF0XR82vqNhIuZXwtNUjyDsLU0LOSdR6mJI9fCjxAGHRJHMdlIAY6gS/UTt2Moqi9dnqpiBwYDbYUkQM2z/RPgG/Ecby5pu67wB1RFN1MGOdwVrJtJTXTI45jj6LorcCtwE1RFP0XoddhA/B6wkJWb0lN/YSwXPcLgdcCD0RR9O3kuHXAq4D3Al9u6IWKyCwKEiKyFK6YZ99WwgyMtE8DtxDWjXgjMEj4cL8sjuOd6QPjOP5FsijVBwjrQ7yWsLLl1wgrW95fc/x4FEWvBi4E3gK8FTBgW/Jv/nTxL09E5mLuC7l5n4jIgdNtu0Vaj8ZIiIiISMMUJERERKRhChIiIiLSMI2REBERkYapR0JEREQapiAhIiIiDVOQEBERkYYpSIiIiEjDFCRERESkYQoSIiIi0rD/ByZUXMQ7teIvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ooo.plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 8 - Evaluate best model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.1 - Restore best model :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded.\n"
     ]
    }
   ],
   "source": [
    "loaded_model = tf.keras.models.load_model('./run/models/best-model.h5')\n",
    "# best_model.summary()\n",
    "print(\"Loaded.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.2 - Evaluate it :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss      : 0.1811\n",
      "Test accuracy  : 0.9509\n"
     ]
    }
   ],
   "source": [
    "score = loaded_model.evaluate(x_test, y_test, verbose=0)\n",
    "\n",
    "print('Test loss      : {:5.4f}'.format(score[0]))\n",
    "print('Test accuracy  : {:5.4f}'.format(score[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Plot confusion matrix**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred   = model.predict_classes(x_test)\n",
    "conf_mat = confusion_matrix(y_test,y_pred, normalize=\"true\", labels=range(43))\n",
    "\n",
    "ooo.plot_confusion_matrix(conf_mat,annot=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"todo\">\n",
    "     What you can do:\n",
    "    <ul>\n",
    "        <li>Try different datasets / models</li>\n",
    "        <li>Test different hyperparameters (epochs, batch size, optimization, etc.)</li>\n",
    "        <li>What's the best strategy?  How to compare?</li>\n",
    "    </ul>\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<img width=\"80px\" src=\"../fidle/img/00-Fidle-logo-01.svg\"></img>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}