CatvsDogCNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.0.0'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "# Working with directory library\n",
    "from os import path, listdir\n",
    "from os.path import isdir\n",
    "\n",
    "# Image visualization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define function to load image from path, return all image paths and labels.\n",
    "\n",
    "def load_image_dataset(file_path):\n",
    "    all_image_dirs = [path.join(file_path, f) for f in listdir(file_path) if not isdir(path.join(file_path, f))]\n",
    "    all_image_labels = []\n",
    "    for f in all_image_dirs:\n",
    "        if f.split('.')[1][-3:] == 'cat':\n",
    "            all_image_labels.append(0)\n",
    "        else:\n",
    "            all_image_labels.append(1)\n",
    "    return all_image_dirs, all_image_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and save image paths and labels\n",
    "\n",
    "all_image_dirs, all_image_labels = load_image_dataset('./data/train')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function that take care of preprocessing image\n",
    "\n",
    "def preprocess_image(image):\n",
    "    image = tf.image.decode_jpeg(image, channels=3)\n",
    "    image = tf.image.resize(image, [192, 192])\n",
    "    image /= 255.0  # normalize to [0,1] range\n",
    "    image = 2*image-1  # normalize to [-1,1] range\n",
    "    return image\n",
    "\n",
    "def load_and_preprocess_image(path):\n",
    "    image = tf.io.read_file(path)\n",
    "    return preprocess_image(image)\n",
    "\n",
    "def load_and_preprocess_from_path_label(path, label):\n",
    "    return load_and_preprocess_image(path), label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data to train and test set.\n",
    "\n",
    "num_train_image = int(len(all_image_labels)*0.8//1)\n",
    "train_image_dirs, train_label = all_image_dirs[:num_train_image], all_image_labels[:num_train_image]\n",
    "test_image_dirs, test_label = all_image_dirs[num_train_image:], all_image_labels[num_train_image:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Put the image's paths and labels of train and test set to tensorflow dataset.\n",
    "\n",
    "train_path_label = tf.data.Dataset.from_tensor_slices((train_image_dirs, train_label))\n",
    "test_path_label = tf.data.Dataset.from_tensor_slices((test_image_dirs, test_label))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and preprocess all the images, put it in the same place with their labels.\n",
    "\n",
    "train_image_label_ds = train_path_label.map(load_and_preprocess_from_path_label)\n",
    "test_image_label_ds = test_path_label.map(load_and_preprocess_from_path_label).batch(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# implement batch for train set.\n",
    "\n",
    "BATCH_SIZE = 32\n",
    "AUTOTUNE = tf.data.experimental.AUTOTUNE\n",
    "\n",
    "train_ds = train_image_label_ds.shuffle(buffer_size = len(all_image_labels))\n",
    "train_ds = train_ds.repeat()\n",
    "train_ds = train_ds.batch(BATCH_SIZE)\n",
    "train_ds = train_ds.prefetch(buffer_size=AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://github.com/JonathanCMitchell/mobilenet_v2_keras/releases/download/v1.1/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_192_no_top.h5\n",
      "9412608/9406464 [==============================] - 28s 3us/step\n"
     ]
    }
   ],
   "source": [
    "# Create an instance of MobileNetV2 as pre-trained model.\n",
    "\n",
    "mobile_net = tf.keras.applications.MobileNetV2(input_shape=(192, 192, 3), include_top=False)\n",
    "mobile_net.trainable=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the CNN-model\n",
    "\n",
    "cnn_model = keras.models.Sequential([\n",
    "    mobile_net,\n",
    "    keras.layers.GlobalAveragePooling2D(),\n",
    "    keras.layers.Flatten(),\n",
    "    keras.layers.Dense(64, activation=\"relu\"),\n",
    "    keras.layers.Dense(2, activation=\"softmax\")\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "mobilenetv2_1.00_192 (Model) (None, 6, 6, 1280)        2257984   \n",
      "_________________________________________________________________\n",
      "global_average_pooling2d_1 ( (None, 1280)              0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 1280)              0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 64)                81984     \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 2)                 130       \n",
      "=================================================================\n",
      "Total params: 2,340,098\n",
      "Trainable params: 82,114\n",
      "Non-trainable params: 2,257,984\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "cnn_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile CNN-model\n",
    "\n",
    "cnn_model.compile(optimizer=tf.keras.optimizers.Adam(),\n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train for 782.0 steps, validate for 5000 steps\n",
      "Epoch 1/2\n",
      "782/782 [==============================] - 1730s 2s/step - loss: 0.1296 - accuracy: 0.9485 - val_loss: 0.0796 - val_accuracy: 0.9756\n",
      "Epoch 2/2\n",
      "782/782 [==============================] - 1918s 2s/step - loss: 0.0937 - accuracy: 0.9619 - val_loss: 0.1160 - val_accuracy: 0.9628\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x644919210>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the model with the train_ds above.\n",
    "\n",
    "steps_per_epoch=tf.math.ceil(len(all_image_dirs)/BATCH_SIZE).numpy()\n",
    "cnn_model.fit(train_ds, epochs=2, steps_per_epoch=steps_per_epoch, validation_data=test_image_label_ds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save model for flask usage.\n",
    "\n",
    "cnn_model.save('static/models/dog_cat_TK_2.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "checkpoint_path = \"static/models/training_1/cp.ckpt\"\n",
    "checkpoint_dir = os.path.dirname(checkpoint_path)\n",
    "\n",
    "# Create a callback that saves the model's weights\n",
    "# by default it saves the weights every epoch\n",
    "cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,\n",
    "                                                 save_weights_only=True,\n",
    "                                                 verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train for 782.0 steps, validate for 5000 steps\n",
      "Epoch 1/5\n",
      "781/782 [============================>.] - ETA: 1s - loss: 0.0814 - accuracy: 0.9683\n",
      "Epoch 00001: saving model to static/models/training_1/cp.ckpt\n",
      "782/782 [==============================] - 1701s 2s/step - loss: 0.0814 - accuracy: 0.9683 - val_loss: 0.1384 - val_accuracy: 0.9570\n",
      "Epoch 2/5\n",
      "781/782 [============================>.] - ETA: 1s - loss: 0.0745 - accuracy: 0.9713\n",
      "Epoch 00002: saving model to static/models/training_1/cp.ckpt\n",
      "782/782 [==============================] - 1647s 2s/step - loss: 0.0744 - accuracy: 0.9713 - val_loss: 0.0607 - val_accuracy: 0.9846\n",
      "Epoch 3/5\n",
      "781/782 [============================>.] - ETA: 2s - loss: 0.0647 - accuracy: 0.9744\n",
      "Epoch 00003: saving model to static/models/training_1/cp.ckpt\n",
      "782/782 [==============================] - 1868s 2s/step - loss: 0.0647 - accuracy: 0.9744 - val_loss: 0.0904 - val_accuracy: 0.9746\n",
      "Epoch 4/5\n",
      "781/782 [============================>.] - ETA: 2s - loss: 0.0603 - accuracy: 0.9770\n",
      "Epoch 00004: saving model to static/models/training_1/cp.ckpt\n",
      "782/782 [==============================] - 1880s 2s/step - loss: 0.0603 - accuracy: 0.9769 - val_loss: 0.1035 - val_accuracy: 0.9732\n",
      "Epoch 5/5\n",
      "781/782 [============================>.] - ETA: 2s - loss: 0.0489 - accuracy: 0.9804\n",
      "Epoch 00005: saving model to static/models/training_1/cp.ckpt\n",
      "782/782 [==============================] - 1904s 2s/step - loss: 0.0489 - accuracy: 0.9804 - val_loss: 0.0680 - val_accuracy: 0.9830\n"
     ]
    }
   ],
   "source": [
    "# Train the model with the new callback\n",
    "history = cnn_model.fit(train_ds,   \n",
    "                    epochs=5,\n",
    "                    steps_per_epoch=steps_per_epoch,\n",
    "                    validation_data=test_image_label_ds,\n",
    "                    callbacks=[cp_callback])  # Pass callback to training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuUAAAHgCAYAAAACHxPQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3xUZfb48c9N770QSIUEQklCCiUBlKaiskoAAUWaHeta9ru6yv5c3V1dV3cX164giAiKSixrp6h0QpMQAgRIDyQkpJE+8/z+mBBDlTKTO0nO+/Xa105m7tx7JsHkzDPnnEdTSiGEEEIIIYTQj43eAQghhBBCCNHVSVIuhBBCCCGEziQpF0IIIYQQQmeSlAshhBBCCKEzScqFEEIIIYTQmSTlQgghhBBC6MxO7wDag5+fnwoPD9c7DCGEEEII0Ylt27btmFLK/1Ke2yWS8vDwcNLT0/UOQwghhBBCdGKapuVe6nOlfEUIIYQQQgidSVIuhBBCCCGEziQpF0IIIYQQQmddoqZcCCGEEMJaNTU1UVBQQH19vd6hiAvk5OREcHAw9vb2ZjunJOVCCCGEEDoqKCjA3d2d8PBwNE3TOxzxG5RSlJWVUVBQQEREhNnOK+UrQgghhBA6qq+vx9fXVxLyDkLTNHx9fc3+yYYk5UIIIYQQOpOEvGOxxM9LknIhhBBCCMHKlSvRNI2srCy9Q7loI0eO5Ntvvz3lvv/85z/ce++9532em5ubJcO6KBZNyjVNG6dp2j5N07I1TXv8LI+HaZq2StO0XzRNW6tpWnCbx17QNG2Ppml7NU17WWt5S9Jy3D5N03a2/C/Akq9BCCGEEKIrWLZsGcOHD2f58uUWvY7BYDD7OW+++eYz4l6+fDk333yz2a9lKRZLyjVNswVeBa4F+gE3a5rW77TDXgTeU0rFAs8Az7U8NwUYBsQCA4BBwJVtnjddKTWw5X8llnoNQgghhBBdQU1NDevXr2fBggVnJLcvvPACMTExxMXF8fjjpjXW7Oxsxo4dS1xcHAkJCRw8eJC1a9cyfvz41ufdf//9LFq0CDDtrv7MM88wfPhwVqxYwdtvv82gQYOIi4tj0qRJ1NbWAnD06FFSU1OJi4sjLi6ODRs2MG/ePObPn9963ieffJKXX375lBgnT57Ml19+SUNDAwA5OTkUFRUxfPhwampqGDNmDAkJCcTExPDZZ5+Z/ftnDpacvjIYyFZKHQLQNG05cCOQ2eaYfsDDLbfXAGkttxXgBDgAGmAPHLVgrEIIIYQQVmHqmxvPuG98bBAzksOpazQw+90tZzw+OTGYm5JCKD/RyNz3t53y2Id3J//mNdPS0hg3bhy9e/fGx8eH7du3k5CQwNdff01aWhqbN2/GxcWF8vJyAKZPn87jjz9Oamoq9fX1GI1G8vPzz3sNJycn1q1bB0BZWRl33nknAE899RQLFizggQce4MEHH+TKK69k5cqVGAwGampq6N69OxMnTuShhx7CaDSyfPlytmw59Xvg6+vL4MGD+eabb7jxxhtZvnw5U6dORdM0nJycWLlyJR4eHhw7doyhQ4dyww03WF0dvyXLV3oAbX86BS33tbULmNRyOxVw1zTNVym1EVOSXtzyv2+VUnvbPO/dltKVeZq1fUeFEEIIITqYZcuWMW3aNACmTZvGsmXLAPjhhx+YM2cOLi4uAPj4+FBdXU1hYSGpqamAKdk++fj5TJ06tfV2RkYGI0aMICYmhqVLl7Jnzx4AVq9ezdy5cwGwtbXF09OT8PBwfH192bFjB9999x3x8fH4+vqecf62JSxtS1eUUvzpT38iNjaWsWPHUlhYyNGj1rfWa8mV8rMly+q0rx8DXtE0bTbwE1AINGuaFgn0BU7WmH+vadoVSqmfMJWuFGqa5g58AswA3jvj4pp2F3AXQGhoqBlejhBCCCGE5Z1vZdvZwfa8j/u4OlzQynhbZWVlrF69moyMDDRNw2AwoGkaL7zwAkqpM1aUlTo9nTOxs7PDaDS2fn36yEBXV9fW27NnzyYtLY24uDgWLVrE2rVrzxvjHXfcwaJFizhy5Ai33XbbWY+ZMGECjzzyCNu3b6euro6EhAQAli5dSmlpKdu2bcPe3p7w8HCr3KjJkivlBUBIm6+DgaK2ByilipRSE5VS8cCTLfdVYlo136SUqlFK1QBfA0NbHi9s+f9q4ANMZTJnUEq9pZRKUkol+fv7m/eVCSGEEEJ0Eh9//DEzZ84kNzeXnJwc8vPziYiIYN26dVx99dUsXLiwtea7vLwcDw8PgoODSUszVR03NDRQW1tLWFgYmZmZNDQ0UFlZyapVq855zerqaoKCgmhqamLp0qWt948ZM4bXX38dMDWEVlVVAZCamso333zD1q1bueaaa856Tjc3N0aOHMltt912SoNnZWUlAQEB2Nvbs2bNGnJzcy/vG2YhlkzKtwJRmqZFaJrmAEwDPm97gKZpfpqmnYzhCWBhy+084EpN0+w0TbPH1OS5t+Vrv5bn2gPjgQwLvgYhhBBCiE5t2bJlraUoJ02aNIkPPviAcePGccMNN5CUlMTAgQN58cUXAViyZAkvv/wysbGxpKSkcOTIEUJCQpgyZQqxsbFMnz6d+Pj4c17z2WefZciQIVx11VVER0e33j9//nzWrFlDTEwMiYmJrWUtDg4OjBo1iilTpmBra3vO8958883s2rWrtRQHTPXv6enpJCUlsXTp0lOuZ020c30EYZaTa9p1wH8AW2ChUupvmqY9A6QrpT7XNG0ypokrClP5yn1KqYaWyS2vAVe0PPaNUuoRTdNcW46zbznnD8AjSqnzztZJSkpS6enpFnqVQgghhBCXbu/evfTt21fvMKya0WgkISGBFStWEBUVpXc4wNl/bpqmbVNKJV3K+SxZU45S6ivgq9Pu+3Ob2x8DH5/leQbg7rPcfwJINH+kQujDaFTY2EivshBCCHEumZmZjB8/ntTUVKtJyC3Bokm5EOLcDpbW8OfPMnhoTG8GR/joHY4QQghhlfr168ehQ4f0DsPiLLqjpxDi3Lp7OtPQZOTWdzazckeB3uEIIYQQQkeSlAuhg0OlNRiVYsGsQSSEefHwh7v49/f7zzlmSgghhBCdmyTlQujgkY92ccs7m/F0see924YwOTGY+asO8OfP9ugdmhBCCCF0IDXlQrSzXfkV7Myv4C839AfAwc6Gf06OJcLPlfhQL52jE0IIIYQeZKVciHa2eGMOrg62TEzo0XqfpmncNyqSlF5+ACzbkseh0hqdIhRCCNEVrVy5Ek3TyMrK0juUi1JWVsbAgQMZOHAg3bp1o0ePHq1fNzY2XvB55syZw759+ywY6fnJSrkQ7aispoEvdxUzbXAI7k72Zz2msq6Jl77bR5NB8eaMRIb29G3nKIUQQnRFy5YtY/jw4Sxfvpynn37aYtcxGAzn3QDoYvn6+rJz504Ann76adzc3HjsscfOOE4phVIKG5uzr0m/++67ZovpUshKuRDtaFVWCY0GIzOTw895jKezPZ/OHYafmwMzFmzmk20ymUUIIYRl1dTUsH79ehYsWMDy5ctPeeyFF14gJiaGuLg4Hn/8cQCys7MZO3YscXFxJCQkcPDgQdauXcv48eNbn3f//fezaNEiAMLDw3nmmWcYPnw4K1as4O2332bQoEHExcUxadIkamtrATh69CipqanExcURFxfHhg0bmDdvHvPnz28975NPPsnLL798Qa8rOzubAQMGcM8995CQkEBxcTF33XUXSUlJ9O/fn2eeeab12OHDh7Nz506am5vx8vLi8ccfJy4ujuTkZEpKSi7p+3oxZKVciHY0JSmEpDBvevq7nfe4UF8XPr13GHPf38ajK3aRf7yW34/t3U5RCiGE0MtfvthDZlGVWc/Zr7sH/+93/c97TFpaGuPGjaN37974+Piwfft2EhIS+Prrr0lLS2Pz5s24uLhQXl4OmLauf/zxx0lNTaW+vh6j0Uh+fv55r+Hk5MS6desAU8nJnXfeCcBTTz3FggULeOCBB3jwwQe58sorWblyJQaDgZqaGrp3787EiRN56KGHMBqNLF++nC1btlzw68/MzOTdd9/ljTfeAOD555/Hx8eH5uZmRo0axeTJk+nXr98pz6msrOTKK6/k+eef55FHHmHhwoWtb0gsRVbKhWgnJ8cd/lZCfpKnsz2LbxvM1KQQfFwdLBmaEEKILm7ZsmVMmzYNgGnTprFs2TIAfvjhB+bMmYOLiwsAPj4+VFdXU1hYSGpqKmBKtk8+fj5Tp05tvZ2RkcGIESOIiYlh6dKl7Nljmj62evVq5s6dC4CtrS2enp6Eh4fj6+vLjh07+O6774iPj8fX98JLO3v16sWgQYNOea0JCQkkJCSwd+9eMjMzz3iOs7Mz1157LQCJiYnk5ORc8PUulayUC9FOZr+7lf7dPfi/cdEX/Bx7WxuenxSDpmkAbD5URmSAG75ujpYKUwghhI5+a0XbEsrKyli9ejUZGRlomobBYEDTNF544QWUUq1/g046154adnZ2GI3G1q/r6+tPedzV1bX19uzZs0lLSyMuLo5Fixaxdu3a88Z4xx13sGjRIo4cOcJtt912Ua+v7XUPHDjA/Pnz2bJlC15eXtx6661nxAng4PDrYpitrS3Nzc0Xdc1LISvlQrSDrCNV/Li/FA/nszd3ns/JX4a1jc3MXbqd1Nc2kF0ik1mEEEKYx8cff8zMmTPJzc0lJyeH/Px8IiIiWLduHVdffTULFy5srfkuLy/Hw8OD4OBg0tLSAGhoaKC2tpawsDAyMzNpaGigsrKSVatWnfOa1dXVBAUF0dTUxNKlS1vvHzNmDK+//jpgagitqjKV8qSmpvLNN9+wdetWrrnmmkt+rVVVVbi7u+Ph4UFxcTHffvvtJZ/L3CQpF6IdvLcxF0c7G6YmhVzyOVwc7HhnVhK1jc1MfG09Gw4eM2OEQgghuqply5a1lqKcNGnSJD744APGjRvHDTfcQFJSEgMHDuTFF18EYMmSJbz88svExsaSkpLCkSNHCAkJYcqUKcTGxjJ9+nTi4+PPec1nn32WIUOGcNVVVxEd/esnyPPnz2fNmjXExMSQmJjYWtbi4ODAqFGjmDJlymVNbklISKBfv34MGDCAO++8k2HDhl3yucxN6wrbeiclJan09HS9wxBdVGVtE0OfW8Xv4oJ4YXLcZZ8vv7yWOYu2knPsBM9NjOGmy0j0hRBC6G/v3r307dtX7zCsmtFoJCEhgRUrVhAVFaV3OMDZf26apm1TSiVdyvlkpVwIC1uxLZ+6JsN5xyBejBAfFz6Zm8KQnj5syz1ulnMKIYQQ1iozM5PIyEjGjBljNQm5JUijpxAWdlW/QDRNY0APT7Od09PZnkVzBrd+nV9ei7+7I0725tuMQQghhLAG/fr149ChQ3qHYXGyUi6EhYX5unL78Aizn9fe1gZ7Wxsamg1Mf2czN7+9iWM1DWa/jhBCCCEsT5JyISzov6sOsDWn3KLXcLSz5Ylro8ksqiL1tfVkl1Rb9HpCCCHMryv0+HUmlvh5SVIuhIXkHDvBS9/vZ3225aekXBsTxId3J1PXaCT1tQ3tck0hhBDm4eTkRFlZmSTmHYRSirKyMpycnMx6XqkpF8JClmzKxd5W45Yhoe1yvYEhXqTdl8Jti7by6ppsUnr5nrHhgxBCCOsTHBxMQUEBpaWleociLpCTkxPBwcFmPack5UJYwImGZj5Kz+faAUEEuJv3nfT5BHu78PHcFAwG0w5sJxqacba3xcZGknMhhLBW9vb2RESYv/dIdCxSviKEBaTtLKS6vplZKWHtfm0PJ3u8XR1oNhi5ffFW7l+2nfomQ7vHIYQQQogLJ0m5EBZgo2mMjg4gIdRbtxhsbTTGRAfydcYRpr61idJqmcwihBBCWCtJyoWwgJsHh7Jw9iBda7o1TePOK3ryxq2J7D9SzYRX17P/qExmEUIIIcytsdnIE5/uvqxzSFIuhJltyz1Os8GodxitrunfjY/uTqbRYOTBZTswGqW7XwghhDCXitpGZi7czLIteZd1HknKhTCjwoo6bnpjA6+uOah3KKeICfbks/uG8d+b47Gx0WTslhBCCGEmeeW17Cmq4l9T4i7rPDJ9RQgzWropF4CJCT10juRM3b2cAdN81XmfZeDqYMcfx0XLZBYhhBDiEuSWnSDM15XYYC/W/XE0ns72l3U+WSkXwkzqmwws35rPmL6BhPi46B3OOSkFGhpv/nSIe5dup65RJrMIIYQQF+P9TbmMeelHvtpdDHDZCTlIUi6E2fzvl2LKTzQyOyVc71DOy8ZG45kb+zNvfD++zTzC1Lc2UlJVr3dYQgghhNVrNhh5+vM9PJWWwRW9/RkR5We2c0tSLoSZrMo6SmSAGym9fPUO5TdpmsbtwyN4a0YSB47WcMs7m62qOVUIIYSwNlX1Tdy2OJ1FG3K4Y3gEb89Mwt3p8lfIT5KaciHM5JWbEzhaXd+htra/ql8gK+5JpqS6HjtbeY8uhBBCnMv6A8fYePAYz0+MYdrgULOfX5JyIczAYFTY2mgEeTrrHcpFG9DDE/AEYNmWPJqNihlD238nUiGEEMIaVdY24eliz7UxQazu4WmxvjFZGhPiMpVU15P83Cq+zzyqdyiXRSnF6qwS5qVl8NcvMzHIPHMhhBBd3Efp+Qz7x2p25VcAWHSQgyTlQlym5VvyKaluoKe/q96hXBZN03h9egKzU8J5Z91h7nl/G7WNzXqHJYQQQrQ7g1Hx3Fd7+b+Pf2FgiBfhvpb/Gy9JuRCXoclgZOnmXEZE+dHL303vcC6bna0NT9/Qn//3u36s2nuUaW9toqFZRiYKIYToOk40NHP3km28+dMhZgwN4905g/B0MV9D57lITbkQl+HbPUc4WtXA31Nj9A7FrOYMiyDUx4Xskhoc7Wz1DkcIIYRoN8u25LE66yh/uaE/s9pxzLEk5UJchvc25BLi48zIPgF6h2J2Y/oGMqZvIACbD5VR22RgVCd8nUIIIQRAY7MRBzsb5gyLYFC4D3EhXu16fSlfEeIy/PHaPvzlhv7YdvKt6v+7OpvbF21lycYcvUMRQgghzO6znYWM+ddaiivrsLXR2j0hB0nKhbgsiWE+jI4O1DsMi3tzRiKjowOY99kenvlCJrMIIYToHIxGxb++28dDy3cS5OGsa8mmJOVCXIKK2kaeSttNfnmt3qG0C1dHO96ckcScYeEsXH+Yu5dso75JGkCFEEJ0XHWNBu5ftp2XV2dzU2Iw798xBB9XB93ikZpyIS7BivQC3t+Ux/QhXWeTHVsbjf/3u/5E+LmyNec4DrIDqBBCiA7spe/28XXGEf50XTR3juip+47ckpQLcZEMRsWSTbkMjvChb5CH3uG0u5nJ4cwYGoamaeSX11JV30T/7p56hyWEEEJcEKUUmqbx4NgorujtzxW9/fUOCZDyFSEu2tp9JeSV1zIrOVzvUHRzcjXhqbQMbnpjI6uzOvZupkIIIbqGbzKKufntTdQ3GfBwsreahBwkKRfioi3emEs3Dyeu7t/5Gzx/ywuTY+np78odi9N5d/1hvcMRQgghzkopxatrsrnn/e00NBupbbS+vihJyoW4CAajIszHhTtGRGAvNdUEejjx0d3JjOkbyF++yOTpz/fIZBYhhBBWpaHZwKMf7eKf3+7jxoHdWXbnUF0bOs9FasqFuAi2NhrPThigdxhWxcXBjjduTeS5r/ay4WAZ9U0GXB3lV4sQQgjr8KdPM/h0RyGPXtWb+0dH6t7QeS6aUp1/VSspKUmlp6frHYbo4GoamskqriIxzNtq/4PWW21jMy4OdtQ2NlNZ10SQp7PeIQkhhOjiDh87QVZxFdfGBFn8WpqmbVNKJV3Kc+XzdyEu0MrtBUx+YyN7iqr0DsVquTiYVsj/9OlubnxlPRmFlTpHJIQQoitanXWUp9J2o5Qiws+1XRLyyyVJuRAXQCnF4o25xAZ70r971xuDeLHuGdkLe1sbbnpjI99nymQWIYQQ7UMpxTs/H+L2xenszK+guqFZ75AumCTlQlyADQfLyC6pYWZyuJSuXIDobh6svC+FqEA37lqSzoJ1h+kKpXJCCCH009hs5IlPd/PX/+3lmn7d+OjuZDyc7PUO64JJUi7EBVi8IQcfVwfGx1r/x1/WIsDdiQ/vSubqfoG8tiab47VNeockhBCiE7v/g+0s35rP/aMieW16QmtJZUfRsaIVQgcnGprZnnecaYNCcLK31TucDsXZwZbXpydSWFGHj6sDRqOivtnQ4X5RCiGEsH4zksO4NqYbqfHBeodySeQvoxC/wdXRjnV/HE2jwah3KB2SjY1GiI8LAP/+YT/fZx5l4exBdPeSySxCCCEuz88HSjlUeoJZKeGMiLKe3TkvhZSvCHEezQYjRqPCyd62Q9WlWavBET4UHq9jwqvr2V0gk1mEEEJcuiUbc5j97laWb82nsbnjL5xJUi7EeazcUcjIF9dytKpe71A6hRFR/nxybwr2tjZMeXMj3+05ondIQgghOphmg5E/f5bBvM/2MLK3PyvuScbBruOntB3/FQhhIaYxiDk42dsQ4O6odzidRu9Ad9LuG0bvbu7cv2yHvOERQghxwYxGxR3vpfPexlzuHBHBWzOTcOsku0h3jlchhAVsz6sgo7CKv04YIGMQzczf3ZEP7xrK9rzjBHo4AaY3QfJ9FkIIcT42Nhoje/szrn83pg0O1Tscs5KVciHOYfGGHNyd7EiN76F3KJ2Sk70tKb38APjylyLmLNpKdb2MTRRCCHGmTYfK+HF/KQCzh0V0uoQcJCkX4qxKquv5ancxNyWG4NpJPhazZrWNBtYdOMbk1zdScLxW73CEEEJYkY+25jNjwWb+9f3+Tr0RnSTlQpyFr6sjr05PYM6wcL1D6RKmJIWw+LbBFFXWMeHVDezKr9A7JCGEEDozGBV//2ov//fJLwzt6ct7tw3u1GWOkpQLcRa2NhrX9O/WOl9bWN6wSD8+nZuCk70NU9/aSH65rJgLIURX1dBs4O4l6bz10yFmJofx7uxBeDpb72ji8hONrNxRcFnnkM/lhTjND5lH+aWggntHRcoOnu0sqmUyy1e7i+UNkRBCdGEOtjb4uzvyzI39mZkcrnc4Z1BKsbe4mtVZR1mdVcKO/Aout7JG68y1OSclJSWp9PR0vcMQHcTk1zdQWtPAmkdHYmPTeT8m6wgyCiv5eFsBT17fF3tb+WBPCCE6u+15x/FwsicywE3vUM5Q29jMhuwyVmWVsHZfCcWVppG+scGejOoTwOjoAAaGem9TSiVdyvktulKuado4YD5gC7yjlHr+tMfDgIWAP1AO3KqUKmh57AXgekwlNt8DDymllKZpicAiwBn46uT9lnwdouvIKKwkPfc4T13fVxJyK7A++xiLNuRwsLSGV6cnyK6qQgjRiX22s5A/fPxr/bg1yC+vZXVWCauzSth4qIzGZiOuDraMiPLn4asCGNnHnwB3J7Ncy2JJuaZptsCrwFVAAbBV07TPlVKZbQ57EXhPKbVY07TRwHPADE3TUoBhQGzLceuAK4G1wOvAXcAmTEn5OOBrS70O0bW8tzEHZ3tbbkoK0TsUAdx9ZS+8XR3406e7mfTaBhbOHiRlLUII0ckYjYp//7Cf/67OZkiED/OnDtQtlmaDkW25x1sT8QMlNQBE+Lly65AwxvQNYFC4j0V2ELXkSvlgIFspdQhA07TlwI1A26S8H/Bwy+01QFrLbQU4AQ6ABtgDRzVNCwI8lFIbW875HjABScqFGRw/0chnO4uYlBhs1c0kXc2UpBCCvZ25Z8k2Ul9bz4p7Uojwc9U7LCGEEGZQ12jg0RU7+Wr3EaYmhfDshAEWSXjPp/xEI2v3mZLwn/aXUlXfjL2txuAIH6YNDmV0dEC7/N2xZFLeA8hv83UBMOS0Y3YBkzCVuKQC7pqm+SqlNmqatgYoxpSUv6KU2qtpWlLLedqeU3Z2EWZR09DMqD4BzEwO0zsUcZqUXn6svG8Y7/x8iGBvZ73DEUIIYSaaBqXVDTx5XV/uGBHRLiMPz9Wk6efmyDX9uzGmbwDDIv1wb+eSSUsm5Wf7rp5e+/0Y8IqmabOBn4BCoFnTtEigLxDcctz3mqZdAdRdwDlNF9e0uzCVuRAa2vl2fRLmF+LjwhszEvUOQ5xDL383nptoqmgrrW7gq93FzEwO69Qza4UQorPaU1RJsJcLni72LLtzKHYWbuavbWxmfXYZq8/SpPnQmChGRwcwoLunrv1klkzKC4C2hbnBQFHbA5RSRcBEAE3T3IBJSqnKloR6k1KqpuWxr4GhwBJ+TdTPes42534LeAtM01fM8YJE55VZVIWTvQ09/a2v21uc6YPNefz7h/1kFlXx19QBMplFCCE6kK93F/PwRzu5PqY7L02Js1hC3p5NmuZgyaR8KxClaVoEphXwacAtbQ/QNM0PKFdKGYEnME1iAcgD7tQ07TlMK+5XAv9RShVrmlatadpQYDMwE/ivBV+D6CKe+3ovB0tqWPfH0TJ1pQN4YHQkzUYj/12dTf7xWl6fnoini/QBCCGENVNK8eqabF78bj8JoV48fm20Wc/f1NKkueYsTZozhoYxOtpyTZrmYLGkXCnVrGna/cC3mEYiLlRK7dE07RkgXSn1OTASeE7TNIWpfOW+lqd/DIwGdmMqT/lGKfVFy2Nz+XUk4tdIk6e4TNklNfx84Bh/uKaPJOQdhI2NxqNX9yHM15UnPv2Fia+vZ/Ftgwn2lsksQghhjeqbDDzx6W5W7ihkwsDuPD8p1iwb9FlLk6Y5WHROuVLqK0xjC9ve9+c2tz/GlICf/jwDcPc5zpkODDBvpKIrW7IxBwdbG6YOkjGIHc3kxGB6eDnzj2+ycHWQDYqFEMJaVdU3sflQGY9d3Zv7RkVecj+QUorM4qrW1fC2TZrjBnRjdLQ+TZrmIH/FRJdWXd/Ex9sKGB8XhJ+bo97hiEuQ3MuXlfemoGkaDc0GNh8q54re/nqHJYQQAjh87AQh3s4EuDvx3SNX4uZ48annuZo046yoSdMcJCkXXdovBZU0GxWzksP1DkVchpMrLgvWHeaFb/bxh2v6cO/IXjKZRQghdPRD5lEeWr6D2+4zRO0AACAASURBVIdH8MjVfS4qIT9bk6abox0jovyssknTHCQpF13asEg/tjw5VjYL6iRuHx7B/iPV/PPbfRw+doK/p8ZYbUOPEEJ0Vkop3vn5MH//ei/9u3twy5Df3v/jXE2aPTtIk6Y5SFIuuqy6RgPODraSkHcijna2/HvqQMJ8XZm/6gCFx+t441aZzCKEEO2lsdnIvLQMPkzP57qYbrx000CcHc7e0Nm2SfPH/aVUtzRpDonw7XBNmuYgSbnosh5Yth2Ad2YN0jkSYU6apvHwVb0J83Xhb//bS0l1vSTlQgjRTg4fO8Fnuwp5YHQkD4/tfUqd97maNP3dHbm2pUlzeJT/JdWddwZd81WLLi+/vJZVWSXcNzJS71CEhUxMCOaa/t1wdbRDKUVeeS1hvl1nxUUIIdpTWU0Dvm6O9OnmzprHRhLk6Qyc2qS5JquEI1Wds0nTHCQpF13Skk252Gga04eG6h2KsCDXltWW5Vvz+X+f7+Gfk2O5cWAPnaMSQojO5af9pdz3wXae/l1/JiUG02xQLN6Qw6qsEjad1qQ5KrpzNmmagyTlosupazTw4dZ8rukf2PpOXnRu4/p3Y+WOQh5avpPcsloeGH3pM3KFEEL86r2NOTz9+R6CvZ3ZllvO6z8eJLsLNmmagyTlosv5YlcRlXVNzJQxiF2Gt6sDS24fzBOf7OZf3+8np+wEz02MwdHu8neTE0KIrqikqp6HP9rJ+uwy7Gw08srrWLGtgCERvtzcBZs0zUGSctHljI8LwtHehiERPnqHItqRo50tL02JI9zPlf/8sJ8pSSEM7emrd1hCCNEhtG3SXJVVws68ChTg4mDL9TFBjOnbtZs0zUFTSukdg8UlJSWp9PR0vcMQQliJQ6U19PR3A0xNSC4O8kdECCFO92uT5lHWZJWe0qQ5KjqAcF9XbojrLk2abWiatk0plXQpz5W/RKJL+cc3WfT0c+WmpBC9QxE6OpmQ/7i/lEc/2sVr0xMYLJ+cCCFE606aZ2vSDPN14eNtBcwb34+kcPmdaW6SlIsu42hVPW//dIjZKeF6hyKsRJiPCx5Odtz6zmb+MTmG1PhgvUMSQoh2dXInzZNb2p/epDkmOoCkcB9W7ijgqbQMQn1c8Hd31DnqzkmSctFlLN2ch0EpZiT/9na/omsI93Pl03tTuOf9bTz84S5yjtXy+7FRMplFCNGpldU08OP+UlZllfDTaTtpnt6kaTAqnv96L2//fJgRUX68ckuC7IRtIZKUiy6hsdnIB5vzGNUnQDaQEafwcnHgvduG8KeVu5m/6gD9untwTf9ueoclhBBmc7JJc/XeElbvK2HnGTtpBjI8yu+sTZordxTy9s+HmZUcxrzx/bCzlbGGliJJuegSvs4o5lhNA7OkdEWchYOdDf+cHMu4/t0Y0zcAMP0RkxVzIURHdb4mzYfGRDEmOpD+3T3O2aRpNCpsbDQmxvfAx9We0dGB7Rl+lyRJuegS/NwcuXFgd0ZE+ukdirBSmqYxtp/pj87B0hoe+WgX/54S19oUKoQQ1i6vrJbVWUdZva/0jCbN0dEBjOwTcEH14Ntyy3lyZQYLZw+iu5ezJOTtRJJy0SUMi/RjmCTk4gJV1zeTX17LxNc38OatiQyReeZCCCvUZDCSnnOcNfvO36R5MTtprtxRwB8/3k2QlxP1TQZLhS7OQuaUi07vh8yjDAz1ws9NusXFhcsrq2XOoi3kldfy/MRYJiXKZBYhhP7KahpYu6+U1fvObNIcHR3A6OgAwi9hJ02jUfHS9/t4dc1Bhvb04fXpiXi7OljgFXRuMqdciHMoq2ng3g+2MzUphGcnDNA7HNGBhPq68OncYcxduo1HV+zCyd6W62OD9A5LCNHFKKXYU2TaSfP0Js3rBgQxKjrgnE2aF+Ptnw/x6pqDTBsUwjM3Drio1XVhHpKUi07tw/R8GpuNMgZRXBJPF3sWzRnMO+sOtTaACiGEpdU2NrPuwDHW7Cs5o0nz92N6Mzo64LxNmpfiliGheLs4cFNSsDS560SSctFpNRuMLN2UR0ovX3oHuusdjuigHOxsuHdkJACVdU08+2UmT1wbja+UQwkhzOhcTZpX9PZjVJ8Lb9K8GL8UVPDyqgP89+YE3J3smTJIdrvWkyTlotP6YW8JhRV1zBvfT+9QRCexp6iSL3YVseVwOQtnDyIyQCazCCEuzTmbNP1dmTk0jNGX0KR5Mb7aXcwjH+3E19WRo1X1l1SHLsxLknLRae0pqiTY25mxUnYgzCSllx/L7hrKXe+lM/G19bw5I4nkXjKZRQhxYc7VpDm0py+3tOykaenkWCnFK6uzeen7/SSGefPmjEQZhGAlZPqK6NRqG5txcZD3nsK88strmbNoK7llJ3j1lgSulh1AhRBncb4mzdF9AszWpHkxXvx2H6+sySY1vgfPTYzByd623a7dFcj0FSFOU1XfhIeTvSTkwiJCfFz4ZG4Kf/l8D7HBXnqHI4SwIicamlmffay1LOVoVQMAcSFeFmvSvBg3JQXj6WzPHSMipKHTyshKueh0KuuaGPb8ah65qje3DY/QOxzRBRiMioXrDjMjOUxWnYTogk5p0jxYRqPBiLujHSMs2KR5MfYWV/HJtgKevL6vJOIWJivlQrTxybYCahqaGRTuo3cooovYdKiMv321l68yinl7ZpLUZwrRybVt0ly19ygHS08ALU2ayZZv0rwYP2Qe5cHlO/BwsueOET3p5umkd0jiHCQpF52K0ah4b2MOCaFexAR76h2O6CKGRfrx+vQEfv/hTlJfW8+7swcRGSBjOIXoTM7WpOlga8OQnj5MHxLWLk2aF0Mpxds/H+K5r7OI6eHJ2zOTCPSQhNyaSVIuOpWfDpSSU1bLw1f11jsU0cVcGxNEkJczdyxOJ/W1Dbw5I5GUXn56hyWEuERtmzRXZZWwq8DUpBlg5p00LeVv/9vLO+sOc31MEC/eFIezg5TWWTvr/JckxCV6f1Mefm6OXDtAtkMX7W9giBdp96Vw39LtOEttuRAdztmaNDUNYoNNTZpj+gbQL0i/Js2LMTo6ABdHO34/JqpDxCuk0VN0MiXV9RwsOSGzo4WulFKtzVQ/7i9lRKSf/FEUwkqdbNJclVXC5kPlVtekeTGyS6rZcvg4twwJ1TuULksaPYVoEeDuRIC71MwJfZ1MyNNzypm1cAvXxXTjX1MGymQWIazAbzZp9g0gKcw6mjQvxk/7S7nvg+042dsyPi4IDyd7vUMSF0mSctEp1DY288AHO7h3VCSJYd56hyMEAIlh3jx5XV/+/vVeCis28c7MpA6z4iZEZ9LapJlVwk8HrL9J82It3pDDM19mEhXgxoLZgyQh76AkKRedwmc7i1iVVcI9I3vpHYoQrTRN484rehLq68JDy3cw4dX1vDtnEL0DZTKLEJZ0sklzdZapNvz0Js3RfQMYHumHq5U2aV6Mpz/fw6INOYztG8B/psVbbeOp+G3ykxMdnlKKxRty6BvkQZKskgsrdE3/bnx0dzJ3LE4ns6hKknIhLOBkk+bqrBLW7OvYTZoXI8LPlbuv6Mn/jYvGtpO9tq5GknLR4W05XE7WkWqenxgjO5UJqxUb7MXqx0a2rmLll9cS4uOic1RCdGy5ZSdaV8NPb9IcHR3IyD7+nXIzr5xjJ8g/XsuIKH9mpYTrHY4wE0nKRYe3eGMOns723Diwh96hCHFeJxPyvcVV3PjqeuakhPPHcdGdbuVOCEuprGtiZ34F6w6Y6sPbNmnOSgljVHQAg8J9sLftWE2aF2PjwTLueX8b7k52rH50ZIdrSBXnJkm56PCSe/qSEOotGyOIDiMqwI2pSSG8+dMhcstq+ffUgfLvV4jTGIyK/Uer2ZFXwY684+zIryC7pAagtUnz1qGmJs0w347bpHkxlm/J46m0DML9XFkwK0kS8k5G5pQLIYQOlFIsXJ/DX/+XSWwPT96elSTjPEWXVlrdwM78lgQ8r4JdBRXUNhoA8HF1ICHUi/hQb+JDvIgL8eoUTZoXymhU/P0r0w6dV/T255Vb4mXCipWSOeWiS2poNvDZziJ+F9tdVhlFh6NpGrcPjyDUx4UHl+3gwy35PDAmSu+whGgXjc1GMourWhPwHfnHyS+vA8DORqN/dw+mJIUQH+pFfIg3IT7OXbpnSNPgRGMzs1PCeer6vth14vKcrkySctFhfbW7mP/7+Be6eThxRW9/vcMR4pJc1S+Q/z04vPXj97pGg7zJFJ2KUoqiyvpfE/C842QUVdHYbAQgyNOJ+FAvZg4NJyHMi/7dPWWjrRb55bU0NBuIDHDnbxNipP+kk5OkXHRYizbk0tPfleGRfnqHIsRl6envBkBxZR2TXtvAvaMiuXVomM5RCXFpahub2V1QyY42pSgl1Q0AONrZEBvsyeyUcOJDvBgY6kWQp7POEVun9Jxy7l6yjSAvJ764f7gk5F2AJOWiQ9qZX8Gu/Ar+ckN/+UUlOg13J3uigzx4Ki2D3LITPH5tX5k7LKyaUorDx060lqDsyKsg60g1BqOpXy3c14VhkX6tZSjRQe6dejKKuXy6vYDHP9lNdy8n5k+L79KlO12JJOWiQ3pvQw6uDrZMTJAxiKLzcHO0460Zifz1f3t5++fD5JbV8p9pA3FxkF/VwjpU1jWxK7+iNQnfmV9BRW0TYPr3OzDEi3tH9iI+1IuBId74uDroHHHHYjQqXvxuH6+tPUhyT19evzUBLxf5HnYV8ptedDgGoyKvvJZJicG4S/e56GTsbG14+ob+hPm68OyXmbz03X7mje+nd1iiCzrfSEJNg94B7ozr3820Ch7qTS9/N/lk5zI1GxVbc8q5eXAIz9w4QD5V6GJkJKLokJRSNBqMONpJM5DovNYdOEZciCfuTvYopeQjbGFRx2oafk3A8yr4paCCE21GEsaHeLUm4LHBnrIoYkZHKutxsrfBy8WBukYDTvY28t97ByUjEUWX0WwwcqLBgKeLvSTkotMbHmVqYq5rNHDHe1u5Y0RPRvUJ0Dkq0Rk0NhvZe3IkYUs5Sl55LWAaSdivuweTE4NNc8FDvQj1cZEk0UJ+KajgjsXpxAZ78c6sJJm+1IVJUi46lO8zj/LwRzv5dO4w+nX30DscIdpFTUMzx080cfuirfzlhv7MSA7XOyTRgSilKK6sP6UMZXdh5RkjCWcMDSM+1IsBPWQkYXv53y/FPLpiJ35ujvzhmj56hyN0Jkm56FAWb8zBz82RPt3c9Q5FiHbj7+7IinuSeXDZDuZ9tofDx2p58nqZzCLOrq7RwO7CylM25jlaJSMJrYlSiv+uzuZf3+8nKcybN2Yk4ufmqHdYQmeSlIsOI+tIFZsOlfPEtdGSjIgux9XRjrdmJvHsl5ksXH8Yo1I8fUN/vcMSOlNKkVNWe0oCvrf41JGEKb1kJKG1qapr5sOt+UyM78Fzk2KkHFMAkpSLDuS9jbk42tkwJSlE71CE0IWtjcbTN/QnKtCNYb1k06yuqKq+zUjCllKUtiMJ40I8mXvlyZGEXvjK6qtVKatpwMPZHk8Xe9LuG4afm4PU6otWkpSLDqG2sZm0HYVMGNgDb5l7K7q46UNMu30qpfj7V3uZEN+D/t09dY5KmJvBqDhQUn3KRJTs0hqUMo0kjApw45p+v44kjAyQkYTWLLOoijsWb+XamCDmje+Hv7u8YRKnkqRcdAguDnZ8fv8wHGzlIz4hTiqtbuDLX4pZujmPV26JZ3R0oN4hictwrKaBnW12xtyV/+tIQm8Xe+JDvbkhrrtpJGGIJx4ykrDD+D7zKA8t34GHkz2p8bLpnTg7mVMuhBAd2NGqem5fvJXMoir+PL4fs4dF6B2SuAC/NZKwb5BHywq4qRY8zFdGEnZESine/OkQ//gmi5genrw9M4lADye9wxIWJHPKRaf24/5SPtqaz19u7C/d6UKcJtDDiY/uTubBZTt5+otMSmsa+MM10XqHJU5TVFF3zpGEgR6OJIR6c+vQUOJDvRnQ3VNmVXcSBcfrmP/DAa6LCeLFyXHycxXnJUm5sHrvrj9MZlGVfFQrxDm4ONjx5oxE/vFNFsk9pQFUb3WNBjKK2owkzKvgSFU9AA52NsT28GRWcljrxjwykrDzqW1sxsXBjhAfFz67fxiR/m7YSL2/+A2SlAurdvjYCdbuK+X3Y6NwsJMxXkKci62Nxp+u69v69SfbCkiJ9JWEz8KUUuSW1bbWge/Iq2BvcRXNLSMJw3xdGNrTpzUBj+7mIb/LOrkDR6u5fXE6c0f24ubBofQOlH01xIWRpFxYtSUbc7Gz0bhlcKjeoQjRYZSfaOTpL/bg4mDLglmDGNBDJrOYS1V9E7/kV7apBT/O8ZaRhK4OtgwM9eIeGUnYZa3dV8IDH+zA0d6WaNnkTlwkScqF1TrR0MyK9HyuiwkiQBpjhLhgPq4OrLgnmdsXpXPTGxv5783xjO0nk1kulsGoyC6pOWVjngMlp44kvFpGEgpMn5gs3pDDM19m0qebBwtmJdHdSz6lEhdHknJhtZqNipkpYVzVr5veoQjR4UR382DlfSncsTidO5ek8+fx/Zgjk1nOq6ymgZ0nN+bJP86u/EpqGpoB8HKxJz7Ei/Gx3YkP9SIuxEv6XESrjMIqnv4ik6v6BfKfqQNxdZT0Slw8GYkohBCdWF2jgd9/uIOhPX0lKW+jsdlI1pGqUyai5JaZRhLa2mj0DXInPsS7dRU8XEYSirMwGFXrpyPrs4+R3NNXGjq7uMsZiWjRpFzTtHHAfMAWeEcp9fxpj4cBCwF/oBy4VSlVoGnaKODfbQ6NBqYppdI0TVsEXAlUtjw2Wym183xxSFLe8WQUVnKksp5R0QHycbAQl8loVK2Jwva840QFuOHexVZ5iyvrTtkZc3dhJQ0tIwkD3E0jCU8m4DE9ZCSh+G2Hj51g7vvb+MsN/RnS01fvcISVsMo55Zqm2QKvAlcBBcBWTdM+V0pltjnsReA9pdRiTdNGA88BM5RSa4CBLefxAbKB79o87w9KqY8tFbvQ3yurs9l8uIyNT4zB1kb+OApxOU4m5NX1Tcx5dytBnk4snD2o09a81jcZ2F147pGEMT08mTG07UhCJ1kFFxdlw8FjzH1/OzYasjIuzMaSRU+DgWyl1CEATdOWAzcCbZPyfsDDLbfXAGlnOc9k4GulVK0FYxVWpLCiju8yj3DXFb1wspeEXAhzcXey55Vb4rn3/e1MeHU9C2YNIia4Y09m+a2RhKE+Lgzp6UN8iGkVvG+QjCQUl2fZljzmpWUQ4efKglmDCPV10Tsk0UlYMinvAeS3+boAGHLaMbuASZhKXFIBd03TfJVSZW2OmQb867Tn/U3TtD8Dq4DHlVINZo1c6GrpplwAbh0qYxCFMLcRUf58cm8Kc97dypQ3NzJ/2kCu7t9xmqmr65v4paDNKnh+BeUnGgHTSMK4EC/uvrIn8SHeDAz1kl2AhVmt2VfCE5/u5sre/vz3lnhp9hVmZcmk/Gyf55xewP4Y8IqmabOBn4BCoLn1BJoWBMQA37Z5zhPAEcABeAv4I/DMGRfXtLuAuwBCQyW56yjqmwws35rP2L6BBHvL6oMQltA70J2V96Vw5+J0VmeVWG1SbjQqsktrTilD2V9SzclWqKgAN8b2DWgtQ4kKcJceFGFRV0b588LkWCbG98DOVj5xEeZlyaS8AAhp83UwUNT2AKVUETARQNM0N2CSUqqyzSFTgJVKqaY2zyluudmgadq7mBL7Myil3sKUtJOUlNT5R8x0Evnltbg42DIrJVzvUITo1ALcnVh+V3JrEnuksh4/NwddE43yE43sbFOGsiu/gurTRhJeHxtEfKgXscFeeDrLKqWwvPzyWh7/9Bf+MSmWYG8XpiSF/PaThLgElkzKtwJRmqZFYFoBnwbc0vYATdP8gHKllBHTCvjC085xc8v9bZ8TpJQq1kxdOROADAvFL3QQFejOj38YhSx2CWF5JyeM1DUamPLmRsL9XHn1lvh2mczSZDCSVVzdphb8ODmnjSScEN9DRhIKXaXnlHP3km00GYwUV9bLJ7jCoiyWlCulmjVNux9T6YktsFAptUfTtGeAdKXU58BI4DlN0xSm8pX7Tj5f07RwTCvtP5526qWapvljKo/ZCdxjqdcg2texmgbcnexwtJPmTiHak7ODLXNH9mJeWgaTX9/IgtlJZk8+jlTWn7I1/S8Fv44k9Hd3JCHUi2mDQ4kPMa2Cy0hCobdPthXwxKe76eHtzDuzkujl76Z3SKKTk82DhNX4/fId7MyvYPWjI2XElBA6WHfgGHOXbsPRzpYFs5KIC/G6pPPUNxnIKKxs3RlzR14FxZUtIwltbRjQw6O1Djw+1JvuMpJQWJm0HYX8/sOdJPf05fVbE/BycdA7JNFBWOWcciEuRml1A//bXcz0IWGSkAuhk+FRfnw6N4U5i7byz2/3seT2wdQ2Gli47jA9vJ3p7uVMDy9nunk6Yd9Se66UIq+89pSdMTOLfh1JGOLjzKBwn9YEvG+Qu3waJqzeVf0CefSq3twzslfrv3UhLE2ScmEVlm3Jo8mgmJEcpncoQnRpUYHupN03DA3QNI2iijpe+n7/KcdowNX9A2k2KLblHqeiztSL72hnQ3SQO3OGhTM4wpeBIV74u8tIQtExFFfW8c9v9/HXCQNwdbTjgTFReockuhhJyoXumgxGlm7OZUSUn9TsCWEFTs72NhoVCvjrhAFsOHiMXwoqKTxehwK+3XOUyAA34kK8+PlAKUYFDc1GduVXsiu/kpRefvi7O5JRWMnH2wro4eVMD2/TSnt3L2f83BykZEVYjZ35Fdz5Xjp1jQZmJocz8BJLt4S4HJKUC939tL+Uo1UN/D01Ru9QhOjSjEbFnqIq1mUfY8PBY+zM+3UkoaezPfGhXtyUGEJ8qBdxIb+OJDQYFaXVDRRW1FJYUU/h8Tr6dHMHIKfsBB9vK6CmofmUa335wHAG9PBkzb4Svtl9xFQa05K0n0zgZea4aA9f7CrisRW78Hd35P3bh7T+2xWivUmjp9CdUor03OMkhHrLH2Eh2lleWS3rso+xPvsY6w8eo6LWVIrSJ9CdQRHexIeYGjIj/FwveWVbKUVVfTOFx+sorKijqKKOSYnBuDna8f6mXOavOkBp9akbM2+fdxU+rg58uDWPddllLcm6U0vi7kLvQDdZaReX7YPNefxp5W4GhXvzxq2J+MoOsOIySaOn6NA0TWNQuI/eYQjRJRw/0ciGg2WtiXheuWk2eDcPJ8b2DWR4pB8pkb4EuDuZ7ZqapuHpbI+nsz39unuc8titQ8O4dWgY9U0GjlTWU1hhSty9XUyr8GUnGvmloIJvMoppMpgWkZzsbdj7zDgA/v39fvYUVbaurnf3cibUx4XYYCk/EL9tRJQfs1PCeeK6aGlAFrqTlXKhq79+mYmtrcYT1/bVOxQhOqX6JgPpOcdbk/CMokqUAndHO4b28mV4pB/Do/zoeRkr4e3BaFSU1jRQWFFHRW0jo6MDAXjx2338sPcohRV1VNebSmQi/FxZ89hIAB5bsYviyjq6e/5aHtMrwI2EUG+9XorQWUl1PUs35fHQmCiZ9iXMTlbKRYdUUdvI+5tzSY3voXcoQnQaRqMis7iKnw+YkvCtOeU0NBuxt9WID/Xm4bG9GRbpR1ywJ3YdaNSbjY1GoIcTgR6nruA/dk0fHrumDwBV9U0UVdRR22hofdzT2Z6DpTX8dKCUkuoGlIKUXr58cOdQAKa8uZEmg5HuXs4Et6y29+/uSWKYJO2d0Z6iSu5cnM7x2iaujw2id6DUjwvrIUm50M2K9ALqm4zMTA7XOxQhOrT88trWJHzDwWMcb6kLj+7mzq1Dwxge6cfgCB9cHTv3r3wPJ3s8utmfct+88f1abzc0m0pkTpbBgKl2/tCxGvYUVvL9nqM0GoxMSggmMcwbpRRD/r4KH1eH1qkxPbydGRzhQ0Ko6XGlkNXWDuK7PUf4/Yc78XS2Z8U9yZKQC6vTuX9DC6tlMCqWbMplcIQPfYM8fvsJQohW56sLH2OhuvDOwNHOljBf11Pue3bCgNbbRqPi2IkGjEbT140GI+MGdKOooo6C43VsySmnur6Z+0dFkhDqTUVtE4P//gNBns6n1LRf1TeQmGBPDEZFk8GIk73UKutt8YYcnv5iD7HBXrw9I5EAD/lvQ1gfScqFLtbuKyGvvJY/jovWOxQhrF59k4FtucdbV8NPrwu/fXgEwyL96OVv3XXh1s7GRjvljYyjnS3P3DjglGOq6ptQxl+/vm14BIXHTRNlfm4pkenm4URMsCf7jlRz3cs/4+/ueEp5zKSEYPp0c6e+yUBDkxEPZzv5uVlYn27uTBjYg+cmxsibJGG1pNFT6OJgaQ1LN+XxxHXRsoWxEKc5WRe+LvsY6w6cWRc+PNKvQ9aFdwWNzUaMSuFkb0tRRR0r0gsorKilqOLXyTJvzkhkVJ8Afsg8yh3vpePmaNdSHmMa+XjniJ6E+bpSWddEXaOBAHdHKZG5BGU1Dfy4v5SJCcF6hyK6kMtp9JSkXAghrEB+eW1rEn56XfiwSL8uUxfe2Z3cJdXWRiPn2Am+zzRNjiloWW0vrKjjo7uT6dPNnSUbc5j32R7sbTWCPFuSdi8XnrguGj83R45U1lPXZCDI00lWf0+z/2g1ty/eSml1Az/+YdQZDcJCWIpMXxEdStqOQiL8XImTbYxFF3b8RCMbD5W1lqRIXXjX0HbFO9zPlTuv6HnGMScXy5J7+fHshAGmZL1l46UNB4+1frr43sYcXlt7EAA/N8eWkY9O/HvqQBztbMkuqaGh2UCwl0uXKpFZu6+EBz7YgZODLcvvSpaEXHQYkpSLdlXT0MxTaRmM7RvAf6bF6x2OEO1G6sLFhTr5848McCMywO2cx6XG96CXv1vrLqmFFXXkltXi0JK0v7omm5U7CgFwdbClh7czUQHuvDo9+mPFfQAAIABJREFUAYDteccxGhU9vJ0JcHfqFDsqv7cxh6c/30N0Nw/emZVEdy9nvUMS4oJJUi7a1crtBdQ0NDMzJVzvUISwqHPVhdvZaCR04HnhwnpEBboTdZ6xfveNiuTqfoGtteyFx+swtilZff7rLLYcLgfAzkajm6cTgyN8+NeUgQCszjqKva2NaRSkl3OHKJGx0TTG9g3k31MHSqmX6HDkX6xoN0opFm/MJTbYk3gpXRGdUGtdePYxNmT/WhfeJ7BrzQsX1uG3Vtr/MSmW3LITrQl7UUUdPi4OrY8//Xlma1kVgJ+bA9fFBLVOpFmRno+Hs71pHKSXM14u9rp8ylNR20jWkWqG9vTl1qFhTB8SKp82iQ5J/jKIdrPhYBnZJTW8eFOc/MIUncLJuvCTq+FSFy46kgg/VyL8XM/5+LK7hlJQXktR5a817SfnvBuNiidXZtBo+HU+pIuDLXOGhfOHa6JRSvH6jwfp7vnr/PZAd0ezfyp0qLSG2xenU36ikXV/HIW7kz5vDIQwB0nKRbsprqynp58r42OD9A5FiEtysi78ZBIudeGiMzu5An42mgab/jSmJVmvpbCinsLjda2bwf3/9u49Ps66zPv498qp5+OkLW3TJE3aAuVQCukhAQSLBxQFBJWDQmF1UXdZdV110dVd10fXR91n3XXxcT0hLaCVRUDWZTlYUYGk0FBooYVCE5o2PdEkTXpIm9Nc+8dMyjSk6SSdyT2Hz/v1yqsz99z3zDU3N51vf7nm92s51KnvPLL5mGNyc0y3XXqa/vxtZWo73KWf/Kn+6Cqpva81qiD+FpnqLU361D3rlJtj+unyCo0bmX/ig4AUxpSIGFbhsDPfLtJGbF/401ua9Ozrx/aFXzCX+cKB42nv7H5zfvZoe8wFcwu1tCykTTv36/23P6We8LEZ5P99aIGuPq9IDc2HtKK64eiMMjMnjtbMSaM0Kdoic88zDfqH32zU7MIx+tnyRSoOjQ7oXQLHYkpEpLyG5kMqnjyaQI6UN1Bf+EeWlOjCufSFA/EYXZB33L72+TPGa/P/uVR7DnQcM+Xj2UUTJEnbWtq1au02tXf2HHPcij9brIvmTdGmnft1/pxC/fv1CzWeEXJkCEbKkXRHunq09FurdcWCGfrHPktWA0Frbe9UdV3z0dHwhuY3+8LPn1OoC+cWqqo8pKnMdQwMK3dXa3vXMbPHvG/BdE0dN1JdPWGZxG+okHIYKUdKe2j9TrW2d+nSM+klR/Bi+8Kf3tKkF3dE+sLHjsjT0rKQ/ux8+sKBVGBmmjSmQJPGFOjMmROOeSyfMI4MRChHUrm7VlRv1bxpY7W0bHLQ5SALnagv/LOXzNMFc+kLBwAEi1COpFq3rVUbd+7XN648k1FHDBv6wgEA6YZPJCTV/esaNW5knj6wcGbQpSCDHa8vfNr4EVp22jRdMDek88sL6QsHAKQsQjmS6muXn6HrlxQzIomEOlFf+M1Vpbpg7hT6wgEAaYOkhKTKz83RGTMmnHhHYADx9YWHtKBoIn3hAIC0RChHUnR2h/Wh/6jWxy8s0/sXzAi6HKShE/WFXzA3pCWzQ/wWBgCQEfg0Q1I8snG31je2aSyBCXGiLxwAkM1ITEiKldVbVRIarYvmTQm6FKSoI109WtewT08O2BdeqPIpY+kLBwBkPEI5Eu6lHW2qbdinr1x2unJyCFOIiLcv/OyiiSwMAgDIOoRyJNzKmq0alZ+rD503K+hSELDtLe16ekuTnhygL3zx7BBtTgCArMcnIRLuinNm6qyiiZowOj/oUjDMWts7VVPXfLQlhb5wAADiQyhHwp0/p1DnzykMugwMg96+8N5ZUugLBwBgaE4Yys3sVkn3uPu+YagHaawn7Lr991t09XkzVTRpdNDlIAl6+8KfjoZw+sIBAEiMeEbKT5G01szWSbpD0qPu7sktC+lo9ct79L3fvap508YSyjPI8frC500bS184AAAJcsJPUXf/ipl9VdK7JN0s6XYzu1fSz9y9LtkFIn2srGnQ9Akj9c7504IuBSehty+8tyWFvnAAAJIvrqEtd3cz2y1pt6RuSZMk3Wdmj7v7F5NZINLDljcO6KktTfrCu09lmfM0E9sX/vSWJm04pi98Mn3hAAAMg3h6yj8tabmkJkk/lfQFd+8ysxxJr0kilEMraxpUkJujaxYxDWKq69sXvnZri450RfrCFxZPpC8cAIAAxDNSXijpKndviN3o7mEze19yykK6CbvrqnNnqnDsiKBLQT96+8Kf2tKk6rpmtRzqlBTpC79+MX3hAAAELZ5P4IcltfTeMbNxkua7+zPu/nLSKkNa+caVZ4nv/6aOgfrC337qVPrCAQBIMfGE8h9KOjfm/qF+tiFLhcOuLXsPat60cfQbB4i+cAAA0ls8odxip0CMtq3wO25Ikp6ua9INP3tWP795kd5+6tSgy8kaJ+oL/8wlc3Xh3EL6wgEASBPxhOv66Jc9fxi9/xeS6pNXEtLJiuoGFY4tUFV5KOhSMt5AfeHXLS7WhXML6QsHACBNxfPp/UlJ35f0FUkuabWkW5JZFNLD9pZ2rX5lj259+xyNyMsNupyM09bepeq6pqMtKVtj+sIvPnWKLpxbSF84AAAZIp7Fg96QdO0w1II0c/eaBuWY6folxUGXkhFO1Be+vKpUF9IXDgBARopnnvKRkj4m6QxJR4fk3P3PklgXUlw47Prthl269IxTNH3CqKDLSUvhsOvl3fv11Gv0hQMAkO3iaV+5S9Irkt4t6euSPiKJqRCzXE6O6ZHPXqgDR7qDLiVtuLvq9h5UTV2zquuataa+WfvauyS92Rd+wZxCLSmjLxwAgGwTzyf/HHf/kJld4e4rzOwXkh5NdmFIXb2T8Ywbma9xI/MDriZ1ubu2txxWdV2TauojQXzvgQ5J0syJo3TJ6dNUVR7S+XMKNY2+cAAAslo8obwr+mermZ0pabek0qRVhJRX27BPX33wJd1+/bmaM3Vs0OWklF1th4+OhNfUNWtH62FJ0pRxI1RVHlJVeUiVZYWaNXkUfeEAAOCoeEL5j81skiKzrzwkaaykrya1KqS0O6u3amfrYc2YyOhu08EO1dQ1q6Y+EsJfbzokSZo0Ol9Ly0L65EVlqiwvVPmUMYRwAABwXAOGcjPLkbTf3fdJ+pOksmGpCilrd9sRPfrSbt1UVarRBdnX99zW3qU1r0cCeE1dszbvOSBJGjciT0vKJusjS4pVVV6o004Zp5wcQjgAAIjPgKkqunrnrZLuHaZ6kOJ+8UyDetx1Q2VJ0KUMi4Md3Vq7tSXaktKkjTv3y10amZ+jRaWTdeXCmaosD+nMGeOVxwwpAABgiOIZ6nzczD4v6VeSDvVudPeWpFWFlNTR3aNfPLtNbz91qkpCY4IuJymOdPXouYZ9R0P4+sY29YRdBbk5Wlg8UZ+9ZJ6q5oS0oGiiCvII4QAAIDHiCeW985H/Zcw2F60sWSfHTF9+7+kqCY0OupSE6ewOa31jq6q3REL489ta1dkTVm6OaUHRBH3yojJVlRfqvJJJGpnPqqUAACA54lnRc/ZwFILUl5+bo6vOLQq6jJPS3RPWSzv3Hx0Jr926T4e7emQmnTFjvG46v1SVZSEtmj2ZucIBAMCwiWdFzxv72+7uKxNfDlLVpp379eRre/XRpSUak0ZhNRx2vbL7gKrrmrSmvlnP1LfoQEdkwaN508bqmkWzVFke0pLZkzVxdEHA1QIAgGwVT7paFHN7pKRLJK2TRCjPInc8/boefnGXrltSHHQpA4qsmnlINXVNb1k1c3bhGL1vwQxVlYe0tCykKeNGBFwtAABARDztK38Ve9/MJki6K2kVIeW0HOrUQ+t36sMVRRqfYit49q6aWVMfCeH9rZpZWRZSZXlIMyaOCrhaAACA/g2lD6Fd0txEF4LUtWrtNnV2h7W8sjToUiS9uWpm78qZvatmFo6NWTWzPKTiyaNZsAcAAKSFeHrK/0uR2VYkKUfSfDFvedbo7gnrnjXbVFUe0txp4wKpoelgh9bURwL4mrpm1UdXzZw4Ol9LZ4f0iYvKVFUeUvmUsYRwAACQluIZKf/nmNvdkhrcvTFJ9SDF7GvvUtmUMfro0uFbLOh4q2aOHZGnJbMn6/olxaosD+n0U8azaiYAAMgI8YTybZJ2ufsRSTKzUWZW6u5bT3SgmV0q6d8k5Ur6qbv/3z6Pl0i6Q9IUSS2SPurujWb2dknfi9n1NEnXuvuDZjZb0ipJkxX5wukN7t4Zx/vAEEwZN0J3fWxJUl8jdtXMmrpmvbSz7ZhVM69YOENV5YWsmgkAADKWufvAO5jVSqrqDb5mViDpaXdfdILjciW9KumdkholrZV0nbtvitnnPyX91t1XmNkySTe7+w19nmeypC2Sity93czulXS/u68ys/+QtN7dfzhQLRUVFV5bWzvg+8Rb7W47Ipdr+oTEfkHySFeP1jXsi34xs0kbGtvUHbNqZmV5SFXlhVowa4JG5LFgDwAASA9m9py7Vwzl2HhGyvNiR6LdvTMazE9ksaQt7l4fLXKVpCskbYrZZ76kv47efkLSg/08zwcl/U80kJukZZKujz62QtLXJA0YyjE0tz/xmu5ft0O1X3mHRhcMfW7y3lUzexfsWbetVZ3dkVUzzy6aoE9cVKbKssiqmaMKCOEAACD7xJO09prZ5e7+kCSZ2RWSmuI4bqak7TH3GyX17YNYL+lqRVpcPiBpnJmF3L05Zp9rJf1L9HZIUqu7d8c858w4asEg7T/SpfvX7dB7z5o+6EDe3RPWxp37VV3XrJr6Zq19veXoqpnzp4/X8soSVZUXqqJ0ksal2BSLAAAAQYgnbX1S0j1mdnv0fqOkflf57KO/b+D17ZX5vKTbzewmSX+StEORL5NGnsBsuqSzJD06iOfsPfYWSbdIUnFxai94k4ruq21Ue2dPXNMg9q6aWVPfrJq6presmvnhiiJVlhdqaRmrZgIAAPQnnsWD6iQtNbOxivSgH4jzuRslzYq5XyRpZ5/n3inpKkmKPv/V7t4Ws8uHJT3g7l3R+02SJppZXnS0/C3PGfPcP5b0YynSUx5nzVAkZN+1pkHnFk/UWUUT3vJ47KqZkSD+5qqZpaHRet+CGaosD2lp2WRNHTdyuMsHAABIO/HMU/5Pkr7j7q3R+5Mk/Y27f+UEh66VNDc6W8oORdpQro/dwcwKJbW4e1jSlxSZiSXWddHtkiR3dzN7QpE+81WSlkv6zYneAwbn5d37ta2lXZ99x4Kj27a3tKs6unR9TV2z3oiumjljwkgtO23a0QV7WDUTAABg8OKZfeV5d1/YZ9s6dz/3hE9u9l5J/6rIlIh3uPs3zezrkmrd/SEz+6CkbynSgvInSX/p7h3RY0slPS1pVjS09z5nmd6cEvF5RaZR7BioDmZfGbz1ja16dfcBPft6S7+rZlZGV85k1UwAAICIk5l9JZ5QvkHSopiwPEqRUH3GUF4wCITyEzu6auaWZq2pf3PVzAmj8lVZFlLVnJAqy0KaM5VVMwEAAPqT7CkR75a02sx+Hr1/syJTESKNtR3u0jO9S9fXN+uV3ZGvCuTnmsaNzNeX33uazp9TyKqZAAAAwyCeL3p+Jzpa/g5FZj95RNLwrbmOhDgUs2pmdV2zNu5sUzhm1cz3L5ihc4sn6paVtaoqD+mWt5UHXTIAAEDWiHcC6t2SworMhvK6pF8nrSIkROyqmTX1zVq/vVXdYVd+rmlh8SR9+pK5qiwL6ZziiUdXzfzls9t0oKNHy6tKgy0eAAAgyxw3lJvZPEVmTLlOUrOkXynSg/72YaoNg9DZHdaGxtajS9fHrpp51swJuuVtZaoqP/6qme6uFdVbNX/6eFWUTArgHQAAAGSvgUbKX5H0pKT3u/sWSTKzvx6WqnBCPWHXSzvaVBPtC+9v1czK8pAWlU6Oa9XMZ19v0Su7D+jbV5/FFzkBAACG2UCh/GpFRsqfMLNHFJmGkLQWkHDYtXnPgaPzhD/zerMOHImsmjl36smvmnnaKeP1lctO1+ULZia6dAAAAJzAcUO5uz8g6QEzGyPpSkl/LWmamf1QkVU2HxumGrPS0VUzo0vXr6lvUcuhTknRVTPPnn40hCdi1cwJo/P18QvLTvp5AAAAMHjxzL5ySNI9ku4xs8mSPiTpNkmE8gTrXTWzd4aU3lUzp08YqYtPnaKq8kJVloc0M8GrZq56dptG5OfoAwuLEvq8AAAAiE+8s69Ikty9RdKPoj84SbvbjqimvknVWyIzpDTu6101s0CV5YWRRXvKQyoJJW/VzI7uHn330c1aWDyRUA4AABCQQYVynJzmgx1aU99ydDQ8dtXMpWWT9ecXlqmyPKS5w7hq5sMv7lLzoU6mQQQAAAgQoTyJelfNjPSFv7lq5piCXC0pC+m6xcWqLA/p9OnjlRvQqpl3VjeobMoYnV9eGMjrAwAAgFCeUMdbNXNEXmTVzC+8e4Yqy0M6a+YE5efmBF2uXtjeqvXbW/W1989XTkD/KAAAAACh/KT0rprZO1f4Matmzpqkv1o2V1Xlx66amUoOd/bovJJJuvo8eskBAACCZO4edA1JV1FR4bW1tSf9PLGrZtbUNeu5bfvU2R1WjklnF01UZXnki5kVJZP7XTUTAAAAmcvMnnP3iqEcy0j5AHrCro0726JL1zerdmuL2jt7JEVWzbxxaXTVzNmTNT6OVTNTyYbGVs0uHBPXap8AAABILkJ5jN5VM3t7wmNXzZwzdaw+eF6RqspDWjI7pEljBr9qZqro7gnrE3c9pzNmjNdPly8KuhwAAICsl9Wh3N1V33RI1XXNWlMXmSWld9XMktBoXXbWdFWWh1RZFtLU8Se/amaqeHzTHu1qO6KvX3Fm0KUAAABAWRjKt7e0R0fCm1RT36w9+49dNbOyLKTK8pCKJo0OuNLkWVGzVUWTRmnZaVODLgUAAADKklDe2t6lL963XtV1x66aubQspKrywqSvmplKNu8+oDX1LfrSe04LbG50AAAAHCsrQvn2fe16dOMeLS2brI9fMFtVcwqHddXMVPLHV9/QiLwcfbhiVtClAAAAICorpkQ8Y8FC3/D8OkaGo/bsP6JpGdQjDwAAkApOZkrE4JeVHAaj8nMJ5JK6esKSRCAHAABIMVkRyhGZ7vG9//akfvDElqBLAQAAQB+E8izxx1f36rU3DmrW5MydVQYAACBdEcqzxIqarZo6boQuPeOUoEsBAABAH4TyLPB60yH9YfNeXb+kWAV5/CcHAABINSS0LHBXTYPyckzXLy4OuhQAAAD0IyvmKc92N59fqrOLJmgqs64AAACkJEJ5Fpg1eTRf8AQAAEhhtK9kMHfXVx98Sc81tARdCgAAAAZAKM9gNfXNumtNg+r2Hgq6FAAAAAyAUJ7BVlY3aNLofF2+YEbQpQAAAGAAhPIMtaP1sB7btFvXLCrWyPzcoMsBAADAAAjlGeqeNQ2SpI8uZRpEAACAVEcoz1DTxo/U9UuKVTSJWVcAAABSHVMiZqjlVaVBlwAAAIA4MVKeYdxdT2x+Q1094aBLAQAAQJwI5Rnmhe2tuvnna3Xfc41BlwIAAIA4EcozzIrqrRo3Io9pEAEAANIIoTyD7D3Qof9+cZeuPq9IY0bwdQEAAIB0QSjPIL98dpu6elw3VpYEXQoAAAAGgVCeQZ55vVlvmzdFZVPGBl0KAAAABoEehwxy98eWqO1wV9BlAAAAYJAYKc8QR7p6ZGaaOLog6FIAAAAwSITyDLBp534t/ubvVFPXHHQpAAAAGAJCeQZYWbNVnT1hnT59XNClAAAAYAgI5Wmutb1TD76wQ1eeM5PWFQAAgDRFKE9z99Zu15GusG6sLA26FAAAAAwRoTyNhcOuu9Y0aHHpZM2fMT7ocgAAADBETImYxnJyTLdfd67C7kGXAgAAgJNAKE9zC2ZNDLoEAAAAnCTaV9JU/d6D+uJ967Wr7XDQpQAAAOAkEcrT1MqaBj34/E7l5fCfEAAAIN2R6NLQwY5u/fq5Rl129nRNGTci6HIAAABwkgjlaeiBdY060NGtGytLgi4FAAAACUAoTzPurhU1DVpQNEELiycFXQ4AAAASgNlX0syRrrAumFOoilICOQAAQKYglKeZUQW5+trlZwRdBgAAABKI9pU0srvtiGrqmuUsFgQAAJBRCOVp5M7qrfrIT9doz/6OoEsBAABAAhHK08SRrh6tWrtN75p/ik6ZMDLocgAAAJBAhPI08dD6nWpt79KNVUyDCAAAkGkI5WnA3bWieqvmTRuryrJQ0OUAAAAgwZIays3sUjPbbGZbzOy2fh4vMbPVZrbBzP5gZkUxjxWb2WNm9rKZbTKz0uj2O83sdTN7IfpzTjLfQyp440CH9uw/ohsrS2VmQZcDAACABEvalIhmlivpB5LeKalR0loze8jdN8Xs9s+SVrr7CjNbJulbkm6IPrZS0jfd/XEzGyspHHPcF9z9vmTVnmqmjR+pp29bFnQZAAAASJJkjpQvlrTF3evdvVPSKklX9NlnvqTV0dtP9D5uZvMl5bn745Lk7gfdvT2Jtaasw5096gm7RuTlakRebtDlAAAAIAmSGcpnStoec78xui3WeklXR29/QNI4MwtJmiep1czuN7Pnzey70ZH3Xt+Mtrx8z8xG9PfiZnaLmdWaWe3evXsT844C8KM/1emi7z6h9s7uoEsBAABAkiQzlPfX/Nx31ZvPS7rIzJ6XdJGkHZK6FWmruTD6+CJJZZJuih7zJUmnRbdPlvS3/b24u//Y3SvcvWLKlCkn904C0tkd1j3PbNOcqWM1uoDFVwEAADJVMkN5o6RZMfeLJO2M3cHdd7r7Ve6+UNLfRbe1RY99Ptr60i3pQUnnRh/f5REdkn6uSJtMRnp0427tPdCh5VWlQZcCAACAJEpmKF8raa6ZzTazAknXSnoodgczKzSz3hq+JOmOmGMnmVnvEPcySZuix0yP/mmSrpT0UhLfQ6BWVG9VaWi0LpqbniP9AAAAiE/SQnl0hPtWSY9KelnSve6+0cy+bmaXR3e7WNJmM3tV0jRJ34we26NI68pqM3tRkVaYn0SPuSe67UVJhZK+kaz3EKRNO/ertmGfbqgsVU4O0yACAABkMnPv2+adeSoqKry2tjboMgalJ+z646tv6LySyZowKj/ocgAAAHACZvacu1cM5Vi+PZiicnNMy06bFnQZAAAAGAZJXdETQ3PPMw36ziOvqCec+b/FAAAAACPlKacn7Pr/T9Rp1uRRyqWXHAAAICswUp5iVr+8RztaD2t5ZWnQpQAAAGCYEMpTzMqaBk2fMFLvnE8/OQAAQLYglKeQLW8c0FNbmvTRpSXKy+U/DQAAQLYg+aUQM9P7F8zQNYtmnXhnAAAAZAy+6JlCyqeM1b9ftzDoMgAAADDMGClPEWvqm/XangNBlwEAAIAAEMpTgLvryw+8qC/ctyHoUgAAABAAQnkKeGpLk+r3HtLyqpKgSwEAAEAACOUpYEV1gwrHFui9Z00PuhQAAAAEgFAesO0t7Vr9yh5dt7hYI/Jygy4HAAAAASCUB+ylHW0aW5Cn65cUB10KAAAAAsKUiAF7z1nT9fbTpmpkPqPkAAAA2YqR8gC1tnfK3QnkAAAAWY5QHhB313U/eUafu3d90KUAAAAgYITygNQ27NPLu/ZrUenkoEsBAABAwAjlAbmzeqvGj8zTlQtnBF0KAAAAAkYoD8DutiN69KXd+nDFLI0u4Lu2AAAA2Y5QHoB7a7erx103VLKCJwAAAJgSMRB/fmGZzi6aoJLQmKBLAQAAQApgpDwAowpydfGpU4MuAwAAACmCUD7MPrvqef3mhR1BlwEAAIAUQigfRhsaW/XgCzvVfLAz6FIAAACQQgjlw2hFdYNGF+TqgxVFQZcCAACAFEIoHybNBzv0Xxt26qpzZ2r8yPygywEAAEAKIZQPk1Vrt6uzO6zllaVBlwIAAIAUQygfJmfMGK9b3lamudPGBV0KAAAAUgzzlA+Ti0+dyjSIAAAA6Bcj5cPgP2u3640DR4IuAwAAACmKUJ5kr+45oC/ct0H/WdsYdCkAAABIUYTyJFtZs1UFeTm6bnFx0KUAAAAgRRHKk2j/kS7dv26HLl8wQ5PHFARdDgAAAFIUoTyJ7qttVHtnD9MgAgAAYECE8iTavq9dFSWTdFbRhKBLAQAAQApjSsQk+of3n6GunnDQZQAAACDFMVKeJL1TIObncooBAAAwMBJjEjQ0H1Llt36vXz/HNIgAAAA4MUJ5EtxV0yCTdMHcwqBLAQAAQBoglCdYe2e37q3drkvPPEXTxo8MuhwAAACkAUJ5gj34/E7tP9Kt5VWlQZcCAACANEEoT7BVa7dp/vTxqiiZFHQpAAAASBNMiZhgP79pkXbvPyIzC7oUAAAApAlCeYKFxo5QaOyIoMsAAABAGqF9JUF2tR3Wh39Uo5d2tAVdCgAAANIMoTxBfvHMNq3d2qIJo/KDLgUAAABphlCeAB3dPfrls9t0yWnTNGvy6KDLAQAAQJohlCfAwy/uUtPBTi2vKgm6FAAAAKQhQnkCrKhuUNmUMbpgDit4AgAAYPCYfeUkhcOuq8+dqYmjC5gGEQAAAENCKD9JOTmmGypLgy4DAAAAaYz2lZPQdLBDd69pUHtnd9ClAAAAII0Ryk/Cqme36SsPvqSdrUeCLgUAAABpjFA+RN09Yd29ZpsumFOoOVPHBl0OAAAA0hihfIge37RHu/cf0fKq0qBLAQAAQJojlA/RndVbVTRplJadNjXoUgAAAJDmCOVD0N7Zrc6esG5YWqLcHKZBBAAAwMlhSsQhGF2Qpwf+4nz1hD3oUgAAAJABGCkfpIMd3Wo51ClJjJIDAAAgIQjlg7Tq2W1a+q3V2tV2OOhSAAAAkCEI5YMQDrvuWtOgBUUTNH3CqKDLAQAAQIZIaig3s0vNbLOZbTGz2/p5vMRoC1N5AAANXklEQVTMVpvZBjP7g5kVxTxWbGaPmdnLZrbJzEqj22eb2TNm9pqZ/crMCpL5HmL98dW9amhu142VpcP1kgAAAMgCSQvlZpYr6QeS3iNpvqTrzGx+n93+WdJKdz9b0tclfSvmsZWSvuvup0taLOmN6PZvS/qeu8+VtE/Sx5L1HvpaUbNVU8eN0KVnnjJcLwkAAIAskMyR8sWStrh7vbt3Slol6Yo++8yXtDp6+4nex6PhPc/dH5ckdz/o7u1mZpKWSboveswKSVcm8T0ctWf/Ef3p1b36yJIS5efS9QMAAIDESWa6nClpe8z9xui2WOslXR29/QFJ48wsJGmepFYzu9/Mnjez70ZH3kOSWt29e4DnTIpp40fqd5+7SDdUlgzHywEAACCLJDOU9zdfYN+JvT8v6SIze17SRZJ2SOpWZP70C6OPL5JUJummOJ8z8uJmt5hZrZnV7t27d0hvoK+yKWM1ecywtbADAAAgSyQzlDdKmhVzv0jSztgd3H2nu1/l7gsl/V10W1v02OejrS/dkh6UdK6kJkkTzSzveM8Z89w/dvcKd6+YMmXKSb2RVc9u0yfuqtWhju4T7wwAAAAMUjJD+VpJc6OzpRRIulbSQ7E7mFmhmfXW8CVJd8QcO8nMetP0Mkmb3N0V6T3/YHT7ckm/SeJ7kLvrjqdf147WwxpdkJvMlwIAAECWSlooj45w3yrpUUkvS7rX3Tea2dfN7PLobhdL2mxmr0qaJumb0WN7FGldWW1mLyrStvKT6DF/K+lzZrZFkR7znyXrPUhSTX2zXt1zUDdWliryPVMAAAAgsfJOvMvQufvDkh7us+3vY27fpzdnUul77OOSzu5ne70iM7sMi5XVDZo0Ol+XL5gxXC8JAACALMPcfgPY0XpYj23arWsWFWtkPq0rAAAASI6kjpSnu1H5ubp12Vx96LyiE+8MAAAADBGhfACTxxToc++cF3QZAAAAyHC0rxzHk6/t1SMv7VY43O806AAAAEDCMFLeD3fXdx/drPbOHr37jGlBlwMAAIAMx0h5P17Y3qoNjW1aXlnCNIgAAABIOkJ5P1ZUb9W4EXm66ly+4AkAAIDkI5T3sfdAh/77xV26+rwijRlBdw8AAACSj1DeR+O+ds2cOEo3VpYEXQoAAACyBEPBfSwsnqQnPn8xveQAAAAYNoyUx9je0q4jXT0EcgAAAAwrQnmMv7l3va75UU3QZQAAACDLEMqjNu3cr2e3tuiys6cHXQoAAACyDKE8amXNVo3Mz9GHK2YFXQoAAACyDKFcUmt7px58YYeuPGemJo4uCLocAAAAZBlCuaTHNu7Rka6wbqwsDboUAAAAZCGmRJT0oYoinTlzgubPGB90KQAAAMhCWT9S7u4yMwI5AAAAApP1ofxTd6/T9x5/NegyAAAAkMWyOpTX7T2oRzbuVl4OiwUBAAAgOFkdyu+qaVBBbo6uXVwcdCkAAADIYlkbyg92dOu+5xp12dnTNWXciKDLAQAAQBbL2lD+wLpGHezo1o2VJUGXAgAAgCyXtaG8sjykz79rns6ZNTHoUgAAAJDlsnae8jlTx+nWZeOCLgMAAADIzpHynz5Zrxe2twZdBgAAACApC0N54752/dPDL+uxjbuDLgUAAACQlIWh/O412yRJH1nKFzwBAACQGrIqlB/p6tGqtdv0rvmnaObEUUGXAwAAAEjKslD+0Pqdam3v0o1VjJIDAAAgdWRVKO/oDmvJ7MmqLAsFXQoAAABwVFZNiXjD0hJ9dEmxzCzoUgAAAICjsmakfOPONoXDTiAHAABAysmKUN7d47ri9qf1/d+/FnQpAAAAwFtkRftK86EO5YZdV54zM+hSAAAAgLfIipHylkOduvjUKSotHBN0KQAAAMBbZEUo7w67lleWBl0GAAAA0K+sCOUFuTm6aN6UoMsAAAAA+pUVoXx24Rjl5DDrCgAAAFJTVoTygryseJsAAABIU6RVAAAAIGCEcgAAACBghHIAAAAgYIRyAAAAIGCEcgAAACBghHIAAAAgYIRyAAAAIGCEcgAAACBghHIAAAAgYIRyAAAAIGCEcgAAACBghHIAAAAgYIRyAAAAIGCEcgAAACBghHIAAAAgYIRyAAAAIGCEcgAAACBghHIAAAAgYObuQdeQdGZ2QNLmoOvIIIWSmoIuIkNwLhOL85lYnM/E4VwmFuczsTifiXOqu48byoF5ia4kRW1294qgi8gUZlbL+UwMzmVicT4Ti/OZOJzLxOJ8JhbnM3HMrHaox9K+AgAAAASMUA4AAAAELFtC+Y+DLiDDcD4Th3OZWJzPxOJ8Jg7nMrE4n4nF+UycIZ/LrPiiJwAAAJDKsmWkHAAAAEhZGRXKzexSM9tsZlvM7LZ+Hh9hZr+KPv6MmZUOf5XpIY5zeZOZ7TWzF6I/Hw+iznRgZneY2Rtm9tJxHjcz+370XG8ws3OHu8Z0Esf5vNjM2mKuzb8f7hrThZnNMrMnzOxlM9toZp/pZx+uzzjFeT65PuNkZiPN7FkzWx89n//Yzz58rscpzvPJZ/sgmFmumT1vZr/t57FBX5sZMyWimeVK+oGkd0pqlLTWzB5y900xu31M0j53n2Nm10r6tqRrhr/a1BbnuZSkX7n7rcNeYPq5U9LtklYe5/H3SJob/Vki6YfRP9G/OzXw+ZSkJ939fcNTTlrrlvQ37r7OzMZJes7MHu/z/zrXZ/ziOZ8S12e8OiQtc/eDZpYv6Skz+x93XxOzD5/r8YvnfEp8tg/GZyS9LGl8P48N+trMpJHyxZK2uHu9u3dKWiXpij77XCFpRfT2fZIuMTMbxhrTRTznEnFy9z9JahlglyskrfSINZImmtn04aku/cRxPhEnd9/l7uuitw8o8uEys89uXJ9xivN8Ik7Ra+5g9G5+9KfvF+H4XI9TnOcTcTKzIkmXSfrpcXYZ9LWZSaF8pqTtMfcb9da/DI/u4+7dktokhYaluvQSz7mUpKujv86+z8xmDU9pGSne8434VUZ/Rfs/ZnZG0MWkg+ivVhdKeqbPQ1yfQzDA+ZS4PuMWbQ94QdIbkh539+Nen3yun1gc51Pisz1e/yrpi5LCx3l80NdmJoXy/v710fdfgPHsg/jO039JKnX3syX9Tm/+axCDx3WZWOsklbj7Akn/LunBgOtJeWY2VtKvJX3W3ff3fbifQ7g+B3CC88n1OQju3uPu50gqkrTYzM7sswvX5yDEcT75bI+Dmb1P0hvu/txAu/WzbcBrM5NCeaOk2H/RFUnaebx9zCxP0gTxa/D+nPBcunuzu3dE7/5E0nnDVFsmiufaRZzcfX/vr2jd/WFJ+WZWGHBZKSvaW/prSfe4+/397ML1OQgnOp9cn0Pj7q2S/iDp0j4P8bk+BMc7n3y2x+18SZeb2VZFWnyXmdndffYZ9LWZSaF8raS5ZjbbzAokXSvpoT77PCRpefT2ByX93pmovT8nPJd9ekovV6R3EkPzkKQbo7NcLJXU5u67gi4qXZnZKb19e2a2WJG/55qDrSo1Rc/TzyS97O7/cpzduD7jFM/55PqMn5lNMbOJ0dujJL1D0it9duNzPU7xnE8+2+Pj7l9y9yJ3L1UkI/3e3T/aZ7dBX5sZM/uKu3eb2a2SHpWUK+kOd99oZl+XVOvuDynyl+VdZrZFkX+tXBtcxakrznP5aTO7XJHZBlok3RRYwSnOzH4p6WJJhWbWKOkfFPmCjdz9PyQ9LOm9krZIapd0czCVpoc4zucHJX3KzLolHZZ0LR/Sx3W+pBskvRjtM5WkL0sqlrg+hyCe88n1Gb/pklZEZwTLkXSvu/+Wz/Uhi+d88tl+Ek722mRFTwAAACBgmdS+AgAAAKQlQjkAAAAQMEI5AAAAEDBCOQAAABAwQjkAAAAQMEI5AGQgM+sxsxdifm5L4HOXmtlLiXo+AEAGzVMOADjG4ehy2gCANMBIOQBkETPbambfNrNnoz9zottLzGy1mW2I/lkc3T7NzB4ws/XRn6roU+Wa2U/MbKOZPRZdIVBm9mkz2xR9nlUBvU0ASDuEcgDITKP6tK9cE/PYfndfLOl2Sf8a3Xa7pJXufrakeyR9P7r9+5L+6O4LJJ0raWN0+1xJP3D3MyS1Sro6uv02SQujz/PJZL05AMg0rOgJABnIzA66+9h+tm+VtMzd680sX9Judw+ZWZOk6e7eFd2+y90LzWyvpCJ374h5jlJJj7v73Oj9v5WU7+7fMLNHJB2U9KCkB939YJLfKgBkBEbKASD7+HFuH2+f/nTE3O7Rm99RukzSDySdJ+k5M+O7SwAQB0I5AGSfa2L+rInerpZ0bfT2RyQ9Fb29WtKnJMnMcs1s/PGe1MxyJM1y9yckfVHSRElvGa0HALwVIxgAkJlGmdkLMfcfcffeaRFHmNkzigzMXBfd9mlJd5jZFyTtlXRzdPtnJP3YzD6myIj4pyTtOs5r5kq628wmSDJJ33P31oS9IwDIYPSUA0AWifaUV7h7U9C1AADeRPsKAAAAEDBGygEAAICAMVIOAAAABIxQDgAAAASMUA4AAAAEjFAOAAAABIxQDgAAAASMUA4AAAAE7H8Bx6na9Xj3IcoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Visualize model history\n",
    "def plot_history(history, key='loss'):\n",
    "    plt.figure(figsize=(12,8))\n",
    "\n",
    "    val = plt.plot(history.epoch, history.history['val_'+key],\n",
    "                    '--', label=key.title() +' Val')\n",
    "    plt.plot(history.epoch, history.history[key], color=val[0].get_color(),\n",
    "                label=key.title() + ' Train')\n",
    "\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel(key.replace('_',' ').title())\n",
    "    plt.legend()\n",
    "\n",
    "    plt.xlim([0,max(history.epoch)])\n",
    "\n",
    "plot_history(history, key='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Save 2nd model\n",
    "cnn_model.save('static/models/dog_cat_TK_7.h5')"
   ]
  }
 ],
 "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.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}