cnn_origin.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Using pure CNN's to classify cats vs dogs\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import shutil\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from shutil import copyfile\n",
    "import matplotlib.pyplot as plt"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Extract the file (manually or using zipfile module)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import zipfile\n",
    "# Extract the archive\n",
    "zip_ref = zipfile.ZipFile(\"./data/cats_and_dogs.zip\", 'r')\n",
    "zip_ref.extractall(\"./data\")\n",
    "zip_ref.close()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## informtion about the dataset"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 12500 images of dogs.\n",
      "There are 12500 images of cats.\n"
     ]
    }
   ],
   "source": [
    "source_path = './data/cats-and-dogs/PetImages/'\n",
    "\n",
    "source_path_dogs = os.path.join(source_path, 'Dog')\n",
    "source_path_cats = os.path.join(source_path, 'Cat')\n",
    "print(f\"There are {len(os.listdir(source_path_dogs))} images of dogs.\")\n",
    "print(f\"There are {len(os.listdir(source_path_cats))} images of cats.\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## create training and test subdirectory"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "root_dir = './data'\n",
    "training_path = os.path.join(root_dir, \"training\")\n",
    "test_path = os.path.join(root_dir, \"validation\")\n",
    "training_path_cats = os.path.join(training_path, \"cats\")\n",
    "training_path_dogs = os.path.join(training_path, \"dogs\")\n",
    "test_path_cats = os.path.join(test_path, \"cats\")\n",
    "test_path_dogs = os.path.join(test_path, \"dogs\")\n",
    "\n",
    "if not os.path.exists(training_path):\n",
    "    os.makedirs(training_path)\n",
    "if not os.path.exists(test_path):\n",
    "    os.makedirs(test_path)\n",
    "if not os.path.exists(training_path_cats):\n",
    "    os.makedirs(training_path_cats)\n",
    "if not os.path.exists(training_path_dogs):\n",
    "    os.makedirs(training_path_dogs)\n",
    "if not os.path.exists(test_path_cats):\n",
    "    os.makedirs(test_path_cats)\n",
    "if not os.path.exists(test_path_dogs):\n",
    "    os.makedirs(test_path_dogs)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## split the data"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "def split_data(source_dir, training_dir, testing_dir, split_size):\n",
    "    files = []\n",
    "    for filename in os.listdir(source_dir):\n",
    "        file = os.path.join(source_dir, filename)\n",
    "        if os.path.getsize(file) > 0:\n",
    "            files.append(filename)\n",
    "        else:\n",
    "            print(filename + ' is zero length, so ignoring.')\n",
    "\n",
    "    training_length = int(len(files) * split_size)\n",
    "    testing_length = int(len(files) - training_length)\n",
    "    shuffled_set = random.sample(files, len(files))\n",
    "    training_set = shuffled_set[0:training_length]\n",
    "    testing_set = shuffled_set[-testing_length:]\n",
    "\n",
    "    for filename in training_set:\n",
    "        src_file = os.path.join(source_dir, filename)\n",
    "        dest_file = os.path.join(training_dir, filename)\n",
    "        copyfile(src_file, dest_file)\n",
    "\n",
    "    for filename in testing_set:\n",
    "        src_file = os.path.join(source_dir, filename)\n",
    "        dest_file = os.path.join(testing_dir, filename)\n",
    "        copyfile(src_file, dest_file)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Copy the image from the dataset (it can be removed after copy)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "666.jpg is zero length, so ignoring.\n",
      "11702.jpg is zero length, so ignoring.\n"
     ]
    }
   ],
   "source": [
    "split_size = 0.9\n",
    "split_data(source_path_cats, training_path_cats, test_path_cats, split_size)\n",
    "split_data(source_path_dogs, training_path_dogs, test_path_dogs, split_size)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Check the information of the image"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 11249 images of cats for training\n",
      "There are 11249 images of dogs for training\n",
      "There are 1250 images of cats for validation\n",
      "There are 1250 images of dogs for validation\n"
     ]
    }
   ],
   "source": [
    "# Training and validation splits\n",
    "print(f\"There are {len(os.listdir(training_path_cats))} images of cats for training\")\n",
    "print(f\"There are {len(os.listdir(training_path_dogs))} images of dogs for training\")\n",
    "print(f\"There are {len(os.listdir(test_path_cats))} images of cats for validation\")\n",
    "print(f\"There are {len(os.listdir(test_path_dogs))} images of dogs for validation\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Standarize the size of the image"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 22498 images belonging to 2 classes.\n",
      "Found 2500 images belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "train_datagen = ImageDataGenerator(rescale=1.0 / 255.)\n",
    "train_generator = train_datagen.flow_from_directory(directory=training_path, batch_size=100, class_mode='binary',\n",
    "                                                    target_size=(150, 150))\n",
    "\n",
    "validation_datagen = ImageDataGenerator(rescale=1.0 / 255.)\n",
    "validation_generator = validation_datagen.flow_from_directory(directory=test_path, batch_size=100, class_mode='binary',\n",
    "                                                              target_size=(150, 150))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Create CNN model"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "model = tf.keras.models.Sequential([\n",
    "    tf.keras.layers.Conv2D(16,(3,3), activation = 'relu', input_shape=(150,150,3)),\n",
    "    tf.keras.layers.MaxPooling2D(2,2),\n",
    "    tf.keras.layers.Conv2D(32,(3,3), activation = 'relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2,2),\n",
    "    tf.keras.layers.Conv2D(64,(3,3), activation = 'relu'),\n",
    "    tf.keras.layers.MaxPooling2D(2,2),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(512, activation = 'relu'),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "  ])\n",
    "model.compile(optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.001),\n",
    "            loss='binary_crossentropy',\n",
    "            metrics=['accuracy'])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Train the model"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      " 55/225 [======>.......................] - ETA: 2:10 - loss: 0.7931 - accuracy: 0.5362"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 32 bytes but only got 0. Skipping tag 270\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 5 bytes but only got 0. Skipping tag 271\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 272\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 282\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 8 bytes but only got 0. Skipping tag 283\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 20 bytes but only got 0. Skipping tag 306\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:771: UserWarning: Possibly corrupt EXIF data.  Expecting to read 48 bytes but only got 0. Skipping tag 532\n",
      "  warnings.warn(\n",
      "D:\\ApplicationApps\\Python3.8\\lib\\site-packages\\PIL\\TiffImagePlugin.py:793: UserWarning: Corrupt EXIF data.  Expecting to read 2 bytes but only got 0. \n",
      "  warnings.warn(str(msg))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225/225 [==============================] - 173s 768ms/step - loss: 0.6912 - accuracy: 0.6136 - val_loss: 0.5753 - val_accuracy: 0.7308\n",
      "Epoch 2/15\n",
      "225/225 [==============================] - 81s 361ms/step - loss: 0.5308 - accuracy: 0.7378 - val_loss: 0.4676 - val_accuracy: 0.7804\n",
      "Epoch 3/15\n",
      "225/225 [==============================] - 86s 384ms/step - loss: 0.4459 - accuracy: 0.7906 - val_loss: 0.5200 - val_accuracy: 0.7644\n",
      "Epoch 4/15\n",
      "225/225 [==============================] - 91s 406ms/step - loss: 0.3854 - accuracy: 0.8234 - val_loss: 0.4068 - val_accuracy: 0.8152\n",
      "Epoch 5/15\n",
      "225/225 [==============================] - 89s 396ms/step - loss: 0.3174 - accuracy: 0.8589 - val_loss: 0.4177 - val_accuracy: 0.8184\n",
      "Epoch 6/15\n",
      "225/225 [==============================] - 98s 435ms/step - loss: 0.2482 - accuracy: 0.8965 - val_loss: 0.4175 - val_accuracy: 0.8252\n",
      "Epoch 7/15\n",
      "225/225 [==============================] - 94s 416ms/step - loss: 0.1727 - accuracy: 0.9300 - val_loss: 0.4390 - val_accuracy: 0.8256\n",
      "Epoch 8/15\n",
      "225/225 [==============================] - 90s 401ms/step - loss: 0.1153 - accuracy: 0.9557 - val_loss: 0.5793 - val_accuracy: 0.8004\n",
      "Epoch 9/15\n",
      "225/225 [==============================] - 91s 405ms/step - loss: 0.0749 - accuracy: 0.9741 - val_loss: 1.1009 - val_accuracy: 0.7516\n",
      "Epoch 10/15\n",
      "225/225 [==============================] - 92s 407ms/step - loss: 0.0615 - accuracy: 0.9804 - val_loss: 0.7410 - val_accuracy: 0.8312\n",
      "Epoch 11/15\n",
      "225/225 [==============================] - 86s 384ms/step - loss: 0.0661 - accuracy: 0.9824 - val_loss: 0.8404 - val_accuracy: 0.8296\n",
      "Epoch 12/15\n",
      "225/225 [==============================] - 88s 389ms/step - loss: 0.0521 - accuracy: 0.9847 - val_loss: 0.8339 - val_accuracy: 0.8212\n",
      "Epoch 13/15\n",
      "225/225 [==============================] - 88s 392ms/step - loss: 0.0466 - accuracy: 0.9885 - val_loss: 0.8591 - val_accuracy: 0.8284\n",
      "Epoch 14/15\n",
      "225/225 [==============================] - 86s 382ms/step - loss: 0.0481 - accuracy: 0.9885 - val_loss: 1.1947 - val_accuracy: 0.8296\n",
      "Epoch 15/15\n",
      "225/225 [==============================] - 84s 372ms/step - loss: 0.0540 - accuracy: 0.9856 - val_loss: 1.1399 - val_accuracy: 0.8232\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(train_generator,\n",
    "                    epochs=15,\n",
    "                    verbose=1,\n",
    "                    validation_data=validation_generator)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Show the information about training"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAGdCAYAAAB0CIUmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeZyNdf/H8feZscyMWUwiZM++jgxCtihLRCpLKJW0aFF+txZZ2u62W3VXd3W30SIkUmlBoWQXQoQQylZhBoOZMef3x+c+s5jBLGfONeec1/PxOI9zne26PjPRefuuLrfb7RYAAAD8WojTBQAAAKDgCHUAAAABgFAHAAAQAAh1AAAAAYBQBwAAEAAIdQAAAAGAUAcAABAACHUAAAABoJjTBcA30tLStGfPHkVFRcnlcjldDgAAyAW3260jR46oYsWKCgk5e1scoS5I7NmzR5UrV3a6DAAAkA+7d+9WpUqVzvoeQl2QiIqKkmR/KKKjox2uBgAA5EZiYqIqV66c/j1+NoS6IOHpco2OjibUAQDgZ3IzdIqJEgAAAAGAUAcAABAACHUAAAABgFAHAAAQAAh1AAAAAYBQBwAAEAAIdQAAAAGAUAcAABAACHUAAAABgFAHAAAQAAh1AAAAAYBQBwAAEAAIdQAAwK/9+af09NPS2rVOV+IsQh0AAPBr998vPfSQ1LSpdOWV0pIlTlfkDEIdAADwW8ePS7NmZTz+8kupTRupQwdp7lzJ7XasNJ8j1AEAAL/15ZfS0aNS1arSli3SrbdKxYtL330ndekitWghffKJlJbmdKWFj1AHAAD81rRpdt+3r1SrlvTGG9L27dKIEVJ4uLRqldSnj9SokfTBB1JqqrP1FiZCHQAA8EtHj0qzZ9txv34Zz1eqJL3wgrRzp/TII1JMjLRxozR4sFS7tvT669KJE87UXJgIdQAAwC99/rmNqatZU7r44uyvly0rPf64hbunnrLHO3ZId9wh1aghTZhgwTBQEOoAAIBf8nS99usnuVxnfl9MjPTgg9Jvv0kvvWQteXv3Sv/3fzYW77HHpIMHfVJyoSLUAQAAv3P4sPTVV3bcv3/uPhMRId19t7Rtm/T22zYG7+BBadw4C3ejRkn79hVezYWNUAcAAPzOp59KyclS/fpSw4Z5+2yJEtLNN0ubNklTp0qNG1s37HPPSdWqScOHW5etvyHUAQAAv5O56zW/QkPt82vX2vi8Sy6RTp6UXn3VxukNGSL98otXyvUJQh0AAPArf/8tzZtnxwUJdR4ul9Sjh+1EsWCB1LmzLX3y7rvWEnjdddLq1QW/TmEj1AEAAL8yc6aFrrg4qU4d753X5bKdKObNk5Yvl3r1sh0pPv5YatZM6tZN+uEH713P2wh1AADAr0ydavfeaKU7kxYtbPux9eulgQOlkBDp66+ltm2ldu3suKhtQUaoAwAAfmP/fmnhQjsuzFDn0bCh7USxZYs0bJhNsli0yFrt4uOlGTOKzhZkhDoAAOA3Pv7YQlSLFlL16r677kUXSf/9r21Bdt99tjzK6tXStddKDRpI770npaT4rp6cEOoAAIDf8EXX69lceKH0/PO2kLFnC7JffpFuvNFa7pxstSPUAQAAv/D77xkTFfr2dbYWzxZku3ZlbEHWrZuNvXNKMecuDQAAkHvTp9v9pZfaVl9FQXS0bUF2zz02I9dJhDoAAOAXnO56PZuICKcroPsVAAD4gR07pBUrrHvz2mudrqZoItQBAIAi76OP7L5DB6l8eUdLKbIIdQAAoMjzdL327+9sHUUZoQ4AABRpW7ZIa9dKxYpJffo4XU3RRagDAABF2rRpdt+5s1SmjLO1FGWEOgAAUKTR9Zo7hDoAQIGkpUn79jldBQLVhg3Sxo2252rv3k5XU7QR6gAABTJhglShQsbCsIA3eVrpuna1LblwZoQ6AECBzJhh92+84WwdCDxud8Z4Orpez41QBwDIt5MnpTVr7HjhQungQUfLQYBZs0b69VcpPFzq2dPpaoo+Qh0AIN/WrJGSk+04NVWaPdvZehBYPF2vV14pRUY6W4s/INQBAPJt6dKsjz/5xJk6EHjc7oxdJOh6zR1CHQAg35Yts3vPButffy0dO+ZcPQgcy5dLO3daC1337k5X4x8IdQCAfPOEuttuk6pXl06ckObMcbYmBAZP12uvXjamDudGqAMA5MuePdKuXVJIiNS8uXT11fb8zJnO1gX/l5aWsUSOpxUY50aoAwDky/Lldt+okXWRefbknD07Y/IEkB8//GD/aIiJka64wulq/AehDgCQL55JEpdcYvetWkkXXCAlJEgLFjhXF/yfp+u1Tx+pZElna/EnhDoAQL54xtN5Ql1ISMY2TsyCRX6lpkoff2zHdL3mDaEOAJBnKSnSqlV23KpVxvOecXWzZkmnTvm+Lvi/hQulP/+UypSRLrvM6Wr8C6EOAJBn69dLx49LsbFSrVoZz3fsaOOg9u/PaMkD8sLT9XrttVLx4s7W4m8IdQCAPPMEtpYtrdvVo0QJqUcPO6YLFnmVnJwxe5qu17wj1AEA8uz0SRKZZV7axO32XU3wf/PmSYcOSeXLS+3aOV2N/yHUAQDy7PRJEpl17SqFhUk7dkjr1vm2Lvi3adPs/rrrpNBQZ2vxR4Q6AECe/PWX9OuvdtyyZfbXS5WSunSxYxYiRm6dOGETbCS6XvOLUAcAyBPPosP16kmlS+f8Hs9CxIyrQ2599ZV05IhUuXLWGdXIPUIdACBPztb16tGjh3WfrV+f0aoHnI2n67Vv36yTb5B7/NoAAHlytkkSHuedZ8ubSLTW4dyOHZM+/9yO6XrNP0IdACDXTp2SVqyw47OFOiljFiyhDucye7aUlCTVqCHFxztdjf8i1AEAcm3TJhv3FBkpNWhw9vd6tgxbutQ2ZwfOxNP12q+f5HI5W4s/I9QBAHLNM56uRYtzLzlRsWJGa96nnxZuXfBfiYnSl1/aMV2vBUOoAwDkWm4mSWSWeSFiICeffiqdPCnVrSs1bux0Nf7N56GuQ4cOGjFiRPrjatWq6cUXXzzrZ1wul2Z5Fq8pAG+dBwCCVW4mSWTmCXULF0oHDxZKSfBzdL16T65DXc+ePdW5c+ccX1u6dKlcLpdWr16d5wJWrlypYcOG5flzZzN+/HjFxcVle37v3r3q1q2bV691ukmTJqn0mRZuAgA/dviwtHGjHee06HBOatWSGjaUUlNtMDyQ2cGD0ty5dkzXa8HlOtTdcsstmj9/vnbu3JnttXfeeUdxcXG6+OKL81xA2bJlFRERkefP5Uf58uVVsmRJn1wLAALNypV2f9FFUrlyuf8cCxHjTD75REpJsW7XevWcrsb/5TrU9ejRQ+XKldOkSZOyPJ+UlKRp06bplltu0d9//60BAwaoUqVKioiIUKNGjTRlypSznvf07tetW7eqXbt2CgsLU/369TVv3rxsn3nggQdUu3ZtRUREqEaNGhozZoxSUlIkWUvZo48+qp9++kkul0sulyu95tO7X9evX6/LLrtM4eHhKlOmjIYNG6ajR4+mvz5kyBD17t1b//rXv1ShQgWVKVNGw4cPT79WfuzatUu9evVSZGSkoqOj1bdvX+3fvz/99Z9++kkdO3ZUVFSUoqOj1axZM61atUqStHPnTvXs2VOxsbEqVaqUGjRooC89o0sBoJDldTydh6cLds4cW48M8Mjc9YqCK5brNxYrphtuuEGTJk3S2LFj5fpfx/f06dOVnJysgQMHKikpSc2aNdMDDzyg6OhoffHFFxo8eLBq1Kihlrloq09LS1OfPn10/vnna9myZUpMTMwy/s4jKipKkyZNUsWKFbV+/XrdeuutioqK0qhRo9SvXz9t2LBBX3/9tb755htJUkxMTLZzJCUlqWvXrrrkkku0cuVKHThwQEOHDtVdd92VJbguWLBAFSpU0IIFC/Trr7+qX79+iouL06233prbX106t9ut3r17q1SpUvruu++UmpqqO++8U/369dPChQslSQMHDlTTpk312muvKTQ0VGvXrlXx4sUlScOHD1dycrK+//57lSpVShs3blRkZGSO1zp58qROnjyZ/jgxMTHP9QJAZvkNdU2aSNWrSzt2WLDztNwhuB04IH37rR0T6rzEnQebNm1yS3LPnz8//bl27dq5BwwYcMbPdO/e3T1y5Mj0x+3bt3ffe++96Y+rVq3qfuGFF9xut9s9Z84cd2hoqHv37t3pr3/11VduSe5PPvnkjNd49tln3c2aNUt/PG7cOHeTJk2yvS/zed544w13bGys++jRo+mvf/HFF+6QkBD3vn373G63233jjTe6q1at6k5NTU1/z3XXXefu16/fGWuZOHGiOyYmJsfX5s6d6w4NDXXv2rUr/bmff/7ZLcm9YsUKt9vtdkdFRbknTZqU4+cbNWrkHj9+/Bmvndm4cePckrLdEhIScvV5AMgsLc3tPu88t1tyu1euzPvn77/fPjtokPdrg3969VX7MxEf73QlRVtCQkKuv7/zNPu1bt26at26td555x1J0rZt27Ro0SLdfPPNkqRTp07pySefVOPGjVWmTBlFRkZq7ty52rVrV67Ov2nTJlWpUkWVKlVKf65VDrv6fvzxx7r00ktVvnx5RUZGasyYMbm+RuZrNWnSRKVKlUp/rk2bNkpLS9PmzZvTn2vQoIFCMy3GVKFCBR04cCBP18p8zcqVK6ty5crpz9WvX1+lS5fWpk2bJEn333+/hg4dqs6dO+vpp5/Wtm3b0t97zz336IknnlCbNm00btw4rVu37ozXeuihh5SQkJB+2717d75qBgBJ2rrVBrWHheVv2QlP69znn0vJyd6tDf6Jrlfvy/OSJrfccotmzJihxMRETZw4UVWrVlWnTp0kSRMmTNALL7ygUaNGaf78+Vq7dq26dOmi5Fz+DXa73dmec502v3nZsmXq37+/unXrptmzZ2vNmjUaPXp0rq+R+Vqnnzuna3q6PjO/lpaWlqdrneuamZ8fP368fv75Z1155ZWaP3++6tevr0/+N7p46NCh2r59uwYPHqz169crPj5eL7/8co7XKlmypKKjo7PcACC/PF2v8fFSiRJ5/3yrVtIFF0gJCba8CYLbnj3S99/bcd++ztYSSPIc6vr27avQ0FB9+OGHevfdd3XTTTelB5JFixapV69eGjRokJo0aaIaNWpo69atuT53/fr1tWvXLu3JtJ/MUs+iSP+zePFiVa1aVaNHj1Z8fLxq1aqVbUZuiRIldOrUqXNea+3atTqWadTu4sWLFRISotq1a+e65rzw/HyZW802btyohIQE1cs07ad27dq67777NHfuXPXp00cTJ05Mf61y5cq6/fbbNXPmTI0cOVJvvvlmodQKAJnldzydR0iI1KuXHbMQMaZPl9xuqXVrqUoVp6sJHHkOdZGRkerXr58efvhh7dmzR0OGDEl/rWbNmpo3b56WLFmiTZs26bbbbtO+fftyfe7OnTurTp06uuGGG/TTTz9p0aJFGj16dJb31KxZU7t27dLUqVO1bds2vfTSS+ktWR7VqlXTjh07tHbtWv31119ZJgx4DBw4UGFhYbrxxhu1YcMGLViwQHfffbcGDx6sCy64IG+/lNOcOnVKa9euzXLbuHGjOnfurMaNG2vgwIFavXq1VqxYoRtuuEHt27dXfHy8jh8/rrvuuksLFy7Uzp07tXjxYq1cuTI98I0YMUJz5szRjh07tHr1as2fPz9LGASAwlLQUCdldMF++qmUzw4PBAi6XgtHvnaUuOWWW3To0CF17txZVTJF7DFjxujiiy9Wly5d1KFDB5UvX169PTs656aYkBB98sknOnnypFq0aKGhQ4fqySefzPKeXr166b777tNdd92luLg4LVmyRGPGjMnynmuuuUZdu3ZVx44dVbZs2RyXVYmIiNCcOXN08OBBNW/eXNdee606deqkV155JY+/jeyOHj2qpk2bZrl17949fUmV2NhYtWvXTp07d1aNGjU07X9/ukNDQ/X333/rhhtuUO3atdW3b19169ZNjz76qCQLi8OHD1e9evXUtWtX1alTR6+++mqB6wWAszl2TPIM4S1IqOvYUYqJkfbtywiJCD47d9rOJC6XdN11TlcTWFzunAayIeAkJiYqJiZGCQkJjK8DkCfffSd16CBVqiQVdM7VoEHS5MnSyJHSv/7llfLgZ557Tho1yv5MLVjgdDVFX16+v32+9ysAwL94WtVyWIwgzzwLEX/yiY2pQvCh67XwEOoAAGfljfF0Hl272rIo27dndOkiePz6q/Tjj1JoqHTNNU5XE3gIdQCAM3K7bfyT5J1QV6qU1KWLHbMXbPDxtNJ16iSVLetsLYGIUAcAOKOdO6X9+6XixaWmTb1zTs8sWJY2CT5Tp9p9//7O1hGoCHUAgDPydL3GxUnh4d45Z48e1v22fr11xyE4bNwobdhg/0DIw8IYyANCHQDgjLw5ScLjvPNs5qNEF2ww8XS9dukixcY6W0ugItQBAM7Im5MkMvN0wRLqgoPbTderLxDqAAA5OnFCWr3ajr0d6jxbhi1dKu3d691zo+j56Sdpyxab+XzVVU5XE7gIdQCAHK1ZI6WkSOXKSdWqeffcF16YERRnzfLuuVH0eLpeu3eXoqKcrSWQEeoAADnK3PXqcnn//JkXIkbgouvVdwh1AIAcFcYkicw8oW7BAunQocK5Bpy3cqX022+2RuGVVzpdTWAj1AEAclRYkyQ8atWSGjaUUlOl2bML5xpwnqfrtWdPKSLC2VoCHaEOAJDNnj3Srl1SSIgUH19412Eh4sCWlpYR6uh6LXyEOgBANp5WukaNpMjIwruOpwt2zhzp2LHCuw6csWSJ9McfUnS07fuLwkWoAwBkU9hdrx5NmtjM2uPHLdghsHha6a6+WipZ0tlaggGhDgCQTWFPkvBwuViIOFCdOiVNn27H/fo5W0uwINQBALJISZFWrbLjwm6pkzK6YGfPlpKTC/968I3vvpP277dt4Tp3drqa4ECoAwBksW6ddYfGxtoM1cLWqpV0wQXS4cPSwoWFfz34hmdtumuukYoXd7aWYEGoAwBk4el6bdnSZr8WttDQjG3D6IINDCkp0owZdkzXq+8Q6gAAWfhqkkRmnnF1s2bZMhjwb99+Kx08aFvMtW/vdDXBg1AHAMjCV5MkMuvYUYqJkfbty7g+/Jen6/W666RixZytJZgQ6gAA6f76S/r1Vztu0cJ31y1RQurRw45ZiNi/nTxpLa4SXa++RqgDAKTztJLVqyeVLu3ba3tmwX7yiW0CD/80Z46UkCBdeKHUpo3T1QQXQh0AIJ0T4+k8unaVwsKk7dul9et9f314h6frtW9f30y0QQZ+3QCAdE6GulKlpC5d7JguWP+UlCR99pkd0/Xqe4Q6AIAk2wFgxQo79uUkicwyd8HC/3z5pe3hW62ab8dkwhDqAACSpE2bpCNHpMhIqX59Z2ro2dPWrVu3Ttq2zZkakH+ertd+/WwLOPgWoQ4AIElautTuW7SwYOWE886TOnSwY1rr/MuRI9IXX9gxXa/OINQBACQ5O54uM89CxIyr8y+ffy6dOCHVri3FxTldTXAi1AEAJBWdUOfZMmzpUmnvXmdrQe7R9eo8Qh0AQIcPSxs32rHToe7CC23fWSljEVsUbYcOSV9/bcd0vTqHUAcA0MqVdn/RRVLZss7WImV0wTKuzj/MmiWlpEgNG0oNGjhdTfBiRzYAQPokCadb6Tyuvlp64AFpwQJrBYqNdboieKSlSZs3W3e957Zhg71GK52zCHUAgCIzns6jVi1r9dmwQZo9Wxo82OmKgtehQ9Ly5RkBbvly664/Xd260k03+b4+ZCDUAUCQc7uLXqiTrLVuwwbrgiXU+UZqqvTzz1lb4X75Jfv7wsOl5s3tz8sll9gYyIoVfV8vsiLUAUCQ27rVWmPCwqQmTZyuJkOfPtLjj9sA/KQkKSLC6YoCz4EDWQPcihW2I8Tpata0XUY8Ia5RI6l4cd/Xi7Mj1AFAkPO00sXHF60v6iZNbLup336T5szJ2EIM+ZOcLP30U9YQt3179vdFRdkC1J4Q17KldP75vq8XeUeoA4AgV9QmSXi4XNZa9/zzthBxUQ11P/8s3XyztHu3FB0txcRk3Gc+Ptd9qVLeXd/tjz/sv60nwP34oy0OfLr69e2/vSfE1avn3I4iKBhCHQAEuaI4ns7j6qst1M2ebS1NJUo4XVFW8+db8ExIsMcFWSw5JMQCXn4CYXS0daVmDnG//579GrGxWQNc8+ZS6dL5rxlFC6EOAILYsWPSunV2XBRDXatWUrlyFlgWLpSuuMLpijK8+640dKhNLmjTRpowwVrCEhKkxMTc3XuOT52ypUIOH855Zml+hIRIjRtnDXG1arHbQyAj1AFAEFu1ysJEpUq2k0NRExoq9e4tvfGGzYItCqHO7ZYee0waP94e9+snTZpkE03ye76kpNwHwTPdR0ba+DdPiGvWzJ5D8CDUAUAQ83S9tmrlbB1nc/XVFupmzZL+8x9rgXJKcrJ0663Se+/Z4wcflJ58smA1uVw2nq5UKalCBe/UieDENmEAEMSK6iSJzC67zMaM7duXEUKdcPiw1LWrBbrQUOm//5WeesrZkAlkxh9FAAhSRXXR4dOVKCH16GHHTu0F+9tvNm5uwQLr0pw9Wxo2zJlagDMh1AFAkNq5U9q/39ama9rU6WrOrk8fu58508KoL61aZaF340bbNWHRImuxA4oaQh0ABClPK11cnG37VJR17WoTEbZvl9av9911P/9cat/ewm/jxrbvaVyc764P5AWhDgCClD9MkvAoVUrq0sWOZ870zTX/8x+beZuUZLNuFy2yWcJAUUWoA4Ag5Q+TJDLz7ChR2OPq0tKkkSOlu+6y46FDbQxddHThXhcoKEIdAAShEyekNWvs2F9CXc+eNut03Tpp27bCuUZSknTddbaLhWTLlbzxRtHaExc4E0IdAAShNWuklBTbraFaNaeryZ3zzpM6dLDjwmitO3DAlk+ZOdNm3E6eLD38MDswwH8Q6gAgCGVeysSfQkthdcFu3mxjC5cvt/1R582Trr/eu9cAChuhDgCCkD9Nksisd2+7X7JE2rvXO+dctMh+D9u3S9Wr21jDdu28c27Alwh1ABCE/G2ShMeFF9r+ppL06acFP9+UKVLnztKhQ3beZcukOnUKfl7ACYQ6AAgyf/wh7d5t21vFxztdTd5lXog4v9xu2+Lr+uttP9err5bmz7cxhoC/ItQBQJBZvtzuGzWyLa/8jWdc3YIF1sKWVykptsXXww/b4/vuk6ZPlyIivFcj4ARCHQAEGX/Y7/VsatWSGjaUUlNt/bi8SEy0pVHeestaKl96yZYvCQ0tnFoBXyLUAUCQ8ddJEpnlZxbs779LbdtKc+ZYq9wnn0h331049QFOINQBQBBJSbEN6iX/bamTMkLd11/bgsHnsnatTYRYt0664ALpu++kq64q3BoBXyPUAUAQWbdOOn7c1mKrVcvpavIvLs4WTT5+3Frezubrr62Fbs8eqV49a6n0xwkiwLkQ6gAgiHi6Xlu2tDFl/srlyl0X7JtvSj16SEeP2m4Uixf7zw4aQF758V9pAEBe+fskicw8S5t8/rl1K2eWlmazW4cNk06dkgYPtha92Fjf1wn4CqEOAIJIIEyS8GjVytaVO3xYWrgw4/kTJ6SBA20dOkkaN056913bzxUIZIQ6AAgSf/4p/fqrHbdo4Wwt3hAamrFtmGch4r//li6/XJo6VSpWTJo4URo/3r/2twXyi1AHAEHCs+hwvXpS6dLO1uItnnF1s2ZJW7dKrVtLP/wgRUfbBIkhQxwtD/CpYk4XAADwjUAaT+dx2WUW4Pbtk5o2lY4dk6pUkb74whYoBoIJLXUAECQCMdSVKGGzWyULdBdfbD8ngQ7BiFAHAEHg1KmM7tdAmCSR2dChNmbuqqtsUeEKFZyuCHAG3a8AEAQ2brS12iIjpfr1na7Guzp2tD1dIyOdrgRwFi11ABAEPF2vLVoE5ub1BDqAUAcAQSEQx9MByIpQBwBBgFAHBD5CHQAEuMOHbUydRKgDAhmhDgAC3IoVdn/RRVLZss7WAqDwEOoAIMDR9QoEB0IdAAQ4Qh0QHAh1ABDA3G5CHRAsCHUAEMC2bJEOHZLCwqQmTZyuBkBhItQBQADztNLFx0vFiztbC4DCRahDwe3da3v0AChy6HoFggehDgUzd67UuLE0fLjTlQDIAaEOCB6EOhRMqVLSwYPSBx9IH37odDUAMjl2TFq3zo4JdUDgI9ShYNq0kcaMseM77pB++83RcgBkWLlSSkuTKleWLrzQ6WoAFDZCHQrukUek1q1tXN2gQVJqqtMVARBdr0CwIdSh4IoVs+7XqChp8WLpn/90uiIAItQBwYZQB++oXl169VU7fuwxaelSZ+sBghyLDgPBh1AH7xk0SLr+eunUKWngQJY5ARy0c6e0f7+tTXfxxU5XA8AXCHXwrldflapWlXbskO66y+lqgKDlaSxv2tR2kwAQ+Ah18K6YGGnyZCkkRHr/fWnKFKcrAoISXa9A8CHUwfvatLEZsZItc7Jzp7P1AEGIUAcEH0IdCseYMVKrVlJCAsucAD524oS0Zo0dE+qA4EGoQ+HIvMzJDz9ITz/tdEVA0FizRkpJkcqVk6pVc7oaAL5CqEPhqVFD+s9/7Hj8+Iz+IACFyjNJolUryeVythYAvkOoQ+EaNEgaMIBlTgAfYjwdEJwIdShcLpf02mu2zMn27dLddztdERDwCHVAcCLUofDFxNj4upAQ6b33pKlTna4ICFh//CHt3m1/3eLjna4GgC8R6uAbl14qjR5tx7ffzjInQCFZvtzuGzWSIiOdrQWAbxHq4Dtjx1p/UEKCNHiwjbMD4FWZJ0kACC6EOvhOsWK220RkpLRoEcucAIWA8XRA8CLUwbcyL3MyblxGXxGAAktJkVatsmNCHRB8CHXwvcGDpf79rfv1+uulI0ecrggICOvW2W4SsbFSrVpOVwPA1wh18L3Tlzm55x6nKwICgqfrtWVLm/0KILjw1x7OKF1aev99++aZNEn66COnKwL8HpMkgOBGqINz2raVHn7YjocNk7MqgTAAACAASURBVHbtcrYewM8xSQIIboQ6OGvsWOsrSkiwLcVY5gTIlz//lLZts+MWLZytBYAzCHVwVvHiWZc5eeYZpysC/JJnInm9eja6AUDwIdTBeRddJL3yih2PGyetWOFsPYAfousVAKEORcMNN0j9+kmpqSxzAuQDkyQAEOpQNLhc0uuvS1Wq2MCge+91uiLAb5w6ldHATUsdELwIdSg6SpeWPvjAljmZOFGaPt3pigC/sHGjdPSoDU2tX9/pagA4hVCHoqVtW+mhh+yYZU6AXPGMp2vRQgoNdbYWAM4h1KHoGTfOljk5fNjG2rHMCXBWTJIAIBHqUEBut/TEE9LmzV48aeZlTr77Tnr2WS+eHAgsW7ZIM2bYcevWztYCwFmEOhTIf/4jjRljvaZr1njxxBddJL38sh2PHSutXOnFkwOBISFBuuoqu2/dWrriCqcrAuAkQh0KpH9/qVkzW82+Y0dp8WIvnvzGG6W+fTOWOTl61IsnB/zbqVP212LzZqlSJWnmTGvkBhC8CHUokPPPl7791lrqEhKspWDuXC+d3LPMSeXK0q+/sswJkMno0dKXX0phYdKsWdIFFzhdEQCnEepQYDEx0tdfS127SklJUs+e1mrgFbGxtsyJyyW984708cdeOjHgvz78MGNHvXfesdZyACDUwSsiIqRPP5Wuu05KTrb7d9/10snbtctY5uTWW6Xdu710YsD/rFol3XKLHT/4oDRggLP1ACg6CHXwmhIlpClT7AsnLU0aMiRjS9cCGz/eFuE6fFgaPJhlThCU9u2TeveWTpyQrrzSZp4DgAehDl4VGiq9+aZ03332+O67pSeftKVPCsSzzEmpUrbMyXPPFbhWwJ+cPCn16SP98YdUt679dWChYQCZEergdS6XNGGCNa5J0iOPSKNGeSHY1ayZsczJmDEsc4Kg4XZLd94pLV1qu+l99pmNZQWAzAh1KBQul20M8cIL9vhf/5Juv90LvaZDhtiAvdRUaeBAljlBUHj5ZZsQERIiTZsm1arldEUAiiJCHQrViBHS22/bl9Ebb0iDBkkpKQU4ocsl/fe/tszJ1q12ASCAffutdP/9dvzccywwDODMCHUodDffLE2dasPipk6Vrr5aOn68ACeMjZXef98C3ttvZ+yRBASYbdusYfrUKdsG2TNWFQByQqiDT1x3nS15EhYmffGF1L27dORIAU7Yvr2t5yCxzAkC0pEjUq9e0qFDUsuW1kDtcjldFYCijFAHn+nWTZozR4qKkhYulDp1kv7+uwAnfPRRqXlz+9br37+AJwOKjrQ0W7nn55+lChVsMe+wMKerAlDUEergU+3aSQsWSGXK2OTV9u2lvXvzebLixW1p/chIackSKS5OWrTIq/UCThg3zlq2S5a0LcAqVnS6IgD+gFAHn2vWTPr+e/ui+vln6dJLpR078nmymjWlxYulOnWk33+XOnSwhfFYnBh+avr0jEWF33zT1twGgNwg1MER9etLP/wg1aghbd8utW0rbdqUz5M1bmx7J91wg/VbPfKIbUS7b59Xa87JL79It91mkz98cDkEuLVrbdUeSRo50rpgASC3CHVwTPXq1ltav76tkt+unbR6dT5PFhlpm81OmmQb0X7zjdSkid17mdttgfSqq6R69WypllmzpI4dC9CVjKB34IBNjEhKkrp0kZ55xumKAPgbQh0cVbGi7foVHy/99ZcFowINi7vxRmu1a9TIviWvuMJa7lJTC1zrqVM2YL11a2tZ/Pxzm43Yq5ctm/fLL9b7+8cfBb4UgkxysnTttdKuXbaw8JQpbAEGIO8IdXDc+efbAqvt2kmJidZK8fXXBThhvXrS8uXWL+p22xi7jh1tzF0+HD8uvf66nfaaa6Rly2wA+623WpfxrFk2m7dKFWnLFgt2+bwUgtQ999g/ZqKjbQuw2FinKwLgjwh1KBKioy3Ide9uIeqqq6SPPy7ACcPDLYlNnWprqPzwg3XHzp6d61P8/bf0+ONS1arSHXfYBhaxsdLo0dLOndbtWqeOvbdGDWtxrFZN+vVXC3YsnYfceO21jDXopkyR6tZ1uiIA/opQhyIjPFz65BOpb1/bSqxfP2nixAKetF8/ac0am3J78KDUs6eNQE9OPuNHduyQ7r7bWt7GjpX+/NOC3YsvWvfYE09IF1yQ/XPVqlmLXfXqthNA+/YW/oAz+e47a6WTpKeesn/UAEB+EepQpJQoYUvPDR1qE1lvvln6978LeNKLLrJlTzz7xD7/vK2jsn17lretWmUZsGZN6ZVXbMB606ZWz6+/Svfea/MxzqZqVfuivugiC4cdOki//VbA+hGQfvvNxtGlpkrXXy+NGuV0RQD8HaEORU5oqHVtjhxpj0eMkB57zIbH5VvJktILL9iKrrGxtvJx06ZyT/9YX30lXXaZbU7x0UcWJq+4Qpo3T/rxR2nAAKlYsdxfqnJla7GrVcu+uNu3z5YfEeSOHrUJNn/9ZY3Ib73FFmAACo5QhyLJ5ZKee87CnGQr7I8cWcBgJ9lgvbVrlXxJO72b2FuN+9ZR9+62y0WxYtKgQbZW2Jw5UufO+f+irVTJgl3t2tZl26GDdckCaWm2Ft26ddaNP2uWDT0AgIIi1KHIcrmkMWNsLJtkDW233lqwzSISEqTnplVRjd0LNUTvaoMaKVJHdP/572n7vG16/32bT+ENFStasKtb1yZNtG9vky0Q3J54Qpoxw4YazJxp/wAAAG8g1KHIu/de6Z13pJAQ6e23bfzRWeY55OiPP2zMUpUqdv/HHy6VLy89ddMW7S7TVBP+ulGVezSR3n/fq7VXqGDBzrPAcocO0ubNXr0E/Mgnn1irs2SzXlu3drYeAIGFUAe/cNNN0rRpUvHiNu6td2+byHAuGzZYV1f16tadm5ho6829/baNd3vwndoqvX6RrWN37JhtNXbTTXbsJRdcYN27DRtKe/ZYsMv3lmjwW+vXZ2z7dc89NgkIALyJUAe/ce21tjBreLj01VdSt24W0k7ndluI6t7dNpZ4911bIsWzC8SGDfaFWrLk/z5QoYLNinj0UWsOnDTJtrhYv95rtZcrJ82fb9vU7ttnGXLjRq+dHkXcX3/ZxIhjx6ROnaQJE5yuCEAgItTBr3TtapMYoqOl77+3Wat//WWvpaZaK16LFvb8V1/ZuDzPLhDffy/16GG5LZvQUFuUbv58Gwz3yy92ojfe8MLsDFO2rO2cERcn7d9vLXYbNnjl1CjCUlJs7cUdO2yR6mnT8jabGgByi1AHv9O2rbXEnX++LTnSrp1Noqhd29aZW7VKCguzXSC2bLGdKVq2zOXJ27e36a/dukknTthWYwMG5NwkmA+eLdGaNrVFjTt2tFmQCFz3329/XiMjraW5TBmnKwIQqFxut5eaIVCkJSYmKiYmRgkJCYqOjna6HK/YtEm6/HKbgOBRpow0fLh0113WMpZvaWnWR/bww9YEeNFF1sTSrFmB65akQ4es9h9/tJq/+cZa8BBY3nrLZmxLtnRJr17O1gPA/+Tl+5uWOvitevVsS9eGDW2h31desTXhHn20gIFOsj7af/zDdlmvWtUWmWvVyra38MK/g2JjLcg1b257zHbqJK1eXeDTogj54Qfpzjvt+PHHCXQACh8tdUEiEFvqfObQIemWW2w9CskWMJ44UTrvvAKfOiFB6tJFWr5cKl3agp6XGgPhoF27LLAfOCBdd5018rJjBID8oKUO8KbYWFst9uWXbcXYzz6zvtIlSwp86pgYae5cawQ8fNha7Fau9ELNcExSki25c+CA/TGZOJFAB8A3CHVAbrhcNlBv2TKpZk3bIqJdO+npp238XQFER9uM3jZtrOWuc2druYP/cbttuZw1a2wIwKxZUqlSTlcFIFgQ6oC8aNrUBr8NGGD7lT30kM2UPXCgQKeNirIlWNq2tYm2l18uLV3qpZrhM08/nbFkyYwZNhwTAHyFUAfkVVSUNHmyTW0MD7f+00aNbN+nlJQCnfbLL21VlSNHpCuukBYv9mLdKFSffy6NHm3Hr7xiAR0AfIlQB+SHy2WTJ1autI1dDxywqY5161rgy2eXbGSk9MUXtn7d0aM2iWLRIi/XDq/buFEaONC6X++4w5Y3BABfI9QBBdGggXXHvvyybfK6fbs0aJCNkJ89O1/Ln5QqZR/t3Nm2lerWTfruu0KoHfmSlCStWGGbjdx5p9S6te0qd+SItbL++99OVwggWLGkSZBgSRMfOHbMvtGffdZmPEj2jf/UUzapIo+OH7dZlHPnShERFvQ6dvRyzTirAwdsg5HMt82bc26IbdDAdo4o8BqJAJBJXr6/CXVBglDnQwcPWrB76SVLZpJtWvvPf9pEizw4cULq08cmUYSH27itTp0KoeYgl5Zm60ufHuD27Mn5/WXLWmNsXJz9J42Ls23qQkN9WzeAwEeoQzaEOgfs2SM98YT05pu21ZhkO7s//rglgFw6eVK65hobaxcWJn36qU2iQP4cPy5t2JA1vP30kzW0ns7lshVsPAHOc6tQgbXnAPgGoQ7ZEOoctG2bNHasNGWKjbELDZVuukkaN06qVClXpzh50nYm+PxzqWRJW/+sa9dCrjsA/Pln9ta3X37Jufs0LMwmMWcOb40a2axkAHAKoQ7ZEOqKgHXrbM2L2bPtccmS0vDhttbd+eef8+PJyVK/fhboSpSwXcu6dy/kmnMpJSV7UMrcknV6q1ZuXzvXez3y2n16/vkZ3aaeW+3atr4cABQlhDpkQ6grQhYvlh5+WPr+e3scFSWNHCndf/85m4VSUqT+/aWZMy3YzZgh9ehROGWmpUl//y3t25f1tndv9ucOHSqcGryhVi26TwH4L0IdsiHUFTFut+0N9vDDtqeUZM1Ho0dLt99ufYFnkJJia6JNny4VL273vXrl/tJJSTmHs9Mf79+fMRTQH9B9CiAQEeqQDaGuiEpLs1Q2Zoy0das9V7myNH68dMMNZ+wPTE215fA8W1JNmSJdeumZW9IyP3fkSN5KPP98qXz5jFuFCtkflytnAdMj8/9VTv8/TG5fy+t5ypSh+xRA4CHUIRtCXRGXkiJNmiQ9+qj0xx/2XN26NlP2mmty7CtMTZVuvFH68MO8Xy48POdwlvlx+fK2nnLmsAYA8C1CHbIh1PmJ48elV1+1BYv//tuea9bM1ri7/PJs4e7UKduS6p137HG5cmduTcv8OCqKMWUA4A8IdciGUOdnEhOlCROk55+3TWAlqUMHC3uXXJLt7UeOWOsb3Y8AEFjy8v3N3q9AURQdbV2x27ZJ995rU10XLpRatbJZERs2ZHl7VBSBDgCCHaEOKMrKlZNefFHassUWLA4JkT77TGrc2CZS7NjhdIUAgCKCUAf4g6pVbeDchg02ccLtlt5/X6pTR7rrLpvWCgAIaoQ6wJ/Uqyd9/LG0cqVNnEhJkf7zH+mii2yf2RMnnK4QAOAQQh3gj+LjpblzpfnzpZYtbUXhMWOkhg2lL75wujoAgAMIdYA/69hRWrpUmjzZ1i3Zts32DevZ044BAEGDUAf4O5dLuv56afNm6R//sGmws2dLDRpY611SktMVAgB8gFAHBIqoKOnZZ6X166XOnaWTJ22cXb160syZ2ffZAgAEFEIdEGjq1rXxdjNmSFWqSLt22YzZLl2kX35xujoAQCEh1AGByOWS+vSRNm2yLtiSJaV586RGjaRRo2wLCgBAQCHUAYEsIkJ67DHp559t8kRqqvTcc7a+3Ycf0iULAAGEUAcEg4susp0oZs+24717pYEDpfbtpXXrnK4OAOAFhDogmFx5pe1K8eSTUni4tGiR1LSpdM890uHDTlcHACgAQh0QbMLCpIcftkkT114rpaVJL78s1a5tW5GlpTldIQAgHwh1QLCqUkWaPt0mUNStK/35p3TLLVKrVtKqVU5XBwDII0IdEOw6d5Z++kn617+kyEhpxQqpRQtp2DDpr7+crg4AkEuEOgBSiRLSyJHSli3SoEE2K/bNN61L9rXXpFOnnK4QAHAOhDoAGSpUkN5/X/r+e6lxY+nQIenOO6X4eGnJEqerAwCcBaEOQHZt20o//ii98opUurS0dq3Upo10443Svn1OVwcAyAGhDkDOihWThg+3LtmhQ22Xivfesy7ZF16QUlKcrhAAkAmhDsDZlS1r4+uWLZOaN7ctxu6/X4qLkxYscLo6AMD/EOoA5E6LFhbs3npLOv98aeNG6bLLpH79pN27na4OAIIeoQ5A7oWE2Fp2W7ZId91ljz/6yNa5e/ppKTnZ6QoBIGgR6gDkXWys7UKxerV06aVSUpL00ENSkybS/PlOVwcAQYlQByD/mjSx5U/ee08qV862HuvUSRowQNqzx+nqACCoEOoAFIzLJQ0eLG3enNElO3WqVKeO9PzzzJIFAB8h1AHwjtKlrUt21Srpkkuko0dtl4qLL5YWLXK6OgAIeIQ6AN7VtKm0eLHNki1TRtqwQWrXzhYu3r/f6eoAIGAR6gB4n2eW7ObN0rBhGQsX16lju1SwlywAeB2hDkDhKVNG+u9/bX27Zs2khATp7rttEeNly5yuDgACCqEOQOFr0UJavlx69VUbe7dmjdSqlXTrrdJffzldHQAEBEIdAN8IDZXuuMO6ZIcMsefeesu6ZN94Q0pLc7Q8APB3hDoAvlWunDRxovTDD1LjxtLBg9Jtt1nL3Y8/Ol0dAPgtQh0AZ7RpYyHuxRelqChpxQobazd8uHTokNPVAYDfIdQBcE6xYtK991qX7PXXS263jburU0eaNIkuWQDIA0IdAOdVqCBNnmz7xtarJ/35p3TTTba+3bp1TlcHAH6BUAeg6OjYUVq7Vnr2WalUKVvE+OKLpREjpMREp6sDgCKNUAegaClRQvrHP6RNm6Rrr7WFiv/9b+uS/fBD66IFAGRDqANQNFWuLE2fLs2ZI9WqJe3bJw0cKHXqJG3c6HR1AFDkEOoAFG1XXCGtXy898YQUFiYtWCA1aSKNGiUdPep0dQBQZBDqABR9JUtKo0dbl+xVV0mpqdJzz9mkio8/pksWAESoA+BPqlWTPv1U+vxzqXp16fffpeuuk7p2lbZudbo6AHAUoQ6A/+nRQ/r5Z2nsWJtYMXeu7U7xr3/ZxAoACEKEOgD+KTxcevRRC3edO0snTtis2TZtmEgBICgR6gD4t5o1raXurbek6Ghp+XKpaVPpn/+0sXcAECQIdQD8n8sl3XKLtdp17y4lJ9vEipYt2ZECQNAg1AEIHJUqSbNnS++9J8XGSqtXS/Hx1k2bnOx0dQBQqAh1AAKLyyUNHmytdr17Sykp0vjxUvPmFvIAIEAR6gAEpgoVpJkzpSlTpDJlrBu2RQvrlj150unqAMDrCHUAApfLJfXvb7Nh+/a15U7++U/p4ottQgUABBBCHYDAV66cNG2aNGOGHW/cKLVubUugHD/udHUA4BWEOgDBo08fC3QDB0ppabZYcVyctHix05UBQIER6gAElzJlpA8+kD77TKpYUdqyRWrbVhoxQjp2zOnqACDfCHUAglPPnjZD9qabJLdb+ve/bauxhQudrgwA8oVQByB4lS4tvfOO9PXXUuXK0vbtUseO0p13SkeOOF0dAOQJoQ4AunSRNmyQbrvNHr/2mtSwoW0/BgB+glAHAJLtG/v669K330rVqkm7dlnYGzpUSkhwujoAOCdCHQBkdtll0vr10t132+O335YaNJC++MLZugDgHAh1AHC6yEjppZek77+XataU/vhD6tFDuuEG6eBBp6sDgBwR6gDgTNq2lX76SRo5UgoJkd5/31rtZs1yujIAyIZQBwBnExFhixQvXizVrSvt2yddfbU0YID0559OVwcA6Qh1AJAbl1wirVkjPfigFBoqTZ1qrXYffWTr3AGAwwh1AJBbYWHSU09Jy5ZJjRpZS12/ftK110r79ztdHYAgR6gDgLyKj5dWrZLGjpWKFZNmzpRq1ZLGjGEiBQDHEOoAID9KlJAefdTCXbNmtgPFE09I1atb2Dt0yOkKAQQZQh0AFESTJtKKFdKMGdYlm5goPf64LWBMuAPgQ4Q6ACiokBCpTx9p7Vrp44+zh7tx4wh3AAodoQ4AvCUkRLrmmuzh7rHHCHcACh2hDgC87fRw17BhRrirXl0aP146fNjpKgEEGEIdABQWT7j76Sdp+nQLdwkJNsGiWjXCHQCvItQBQGELCbG17M4U7h59lHAHoMAIdQDgK5nD3Ucf2Y4UCQnWYke4A1BAhDoA8LWQEOm666R167KHu+rVbexdQoLTVQLwM4Q6AHBK5nA3bZpUv7611I0bZy13hDsAeUCoAwCnhYRIfftK69fnHO4ef5xwB+CcCHUAUFR4wt26ddLUqVK9ehbuxo4l3AE4J0IdABQ1oaFSv37Wcnd6uKte3faYTUx0ukoARQyhDgCKqszhbsoUC3eHDkljxljLHeEOQCaEOgAo6kJDpf79M8Jd3bpZw92TTxLuABDqAMBveMLdhg3Shx9mhLtHHpGqVJGGDpXmz5dOnXK6UgAOINQBgL8JDZUGDMga7hISpLffljp1soA3cqT044+S2+10tQB8xOV28zc+GCQmJiomJkYJCQmKjo52uhwA3pSWJi1aJE2ebNuQZd6Vok4d6frr7VazpnM1AsiXvHx/E+qCBKEOCBInT0pz5ljA++wz6cSJjNdatLBw16+fVL68czUCyDVCHbIh1AFB6MgRadYsC3jffJMx1i4kxLppr79euvpqKSbG2ToBnBGhDtkQ6oAgt3+/dc1OniwtW5bxfMmSUo8e0sCBUrduUliYczUCyIZQh2wIdQDSbd9uS6NMnixt2pTxfEyMdM011oLXoYNNyADgKEIdsiHUAcjG7ZZ++slm0E6ZIv3+e8ZrFSrY8inXXy81aya5XM7VCQQxQh2yIdQBOCvPDNoPP7Ru2kOHMl6rXTtjBm2tWs7VCAQhQh2yIdQByLXkZOnrry3gffaZdPx4xmvNm2fMoK1QwbkagSBBqEM2hDoA+eKZQfvhh9K8eVln0HbsaBMs+vRhBi1QSAh1yIZQB6DADhyQPvrIAt7SpRnPlywpde0qNWggVa1qO1pUqSJVrixFRTlXLxAACHXIhlAHwKvONIP2dLGxGSEvp1uFCsyyBc6CUIdsCHUACoXbLa1bZ7tY7Nwp7dqVccu8XdmZFCsmXXhh1qCXubWvSpWi2drndkspKdKxY1JSkt1iYqSyZZkpDK/Ky/d3MR/VBAAIRC6X1KSJ3U6XmCjt3p097Hluv/8upaba6zt3nvkapUufu7Wv2GlfZ6mpGWErKSkjfGUOYec6PtfrnvGFmYWHW03Vqlk4rVo16zEtkyhEtNQFCVrqABQ5p05Je/fmHPg8t8xLq5xJaKiFJbc7I3AlJxd+/ZmvHxEhHT1qNZxN8eI21jCnwFetmlSpkr0H+B+6X5ENoQ6AXzpyxFr7zhT6du+2VrkzcbkscEVESKVKZT/O6bm8vB4RIZUoYddKTs5omfztt4wWSM/x7t05t+5lFhIiVayYNexlDn9VqlhrIIIGoQ7ZEOoABKRTp2xf299/ty7Y0wNXWFjRGeN26pS0Z0/Ogc9zO3ny3Oe54IKcW/rKl7fxh5GRdl+qFF29+ZGSYv+YyHxLTDz3c4mJto7jM894tRzG1AEAgkNoqLVsVazodCXnFhpqXa+VK0tt22Z/PS3Nlo3JKex5Hh89aiF2/35pxYpzXzM8PCPoecJeQY4jIpwPyWlp1jp76lTGLTXVwtjRo3kPYqe/58SJ/NfmcIgm1AEAUBSEhFhrW/nyUsuW2V93u22MYU4tfb/9Jv31l4WSo0czunmPH7fbgQPeqdHlshbAnAJfWFj2oHWu4/y8z1dKlrSfy3OLjs76OKfnqlTxXX05INQBAOAPXC7pvPPsdvHFZ36f223duJ6A52m9Kuix59ye5/ft883PnRelSuUufOXmPZ6xkn6EUAcAQCBxuazVLCzM1s3zhrQ0a/E7W/A7ccK6H4sVs3vPLfPjwn7N6a5hhxHqAADA2YWEWCtYqVJOV4KzCHG6AAAAABQcoQ4AACAAEOoAAAACAKEOAAAgABDqAAAAAoDfhroOHTpoxIgRuX7/b7/9JpfLpbVr1xZiVQAAAM4o9FDncrnOehsyZEi+zjtz5kw9/vjjuX5/5cqVtXfvXjVs2DBf18stwiMAAHBCoa9Tt3fv3vTjadOmaezYsdq8eXP6c+Hh4Vnen5KSouLFi5/zvOedd16e6ggNDVX58uXz9BkAAAB/UegtdeXLl0+/xcTEyOVypT8+ceKESpcurY8++kgdOnRQWFiYPvjgA/39998aMGCAKlWqpIiICDVq1EhTpkzJct7Tu1+rVaumf/7zn7r55psVFRWlKlWq6I033kh//fQWtIULF8rlcunbb79VfHy8IiIi1Lp16yyBU5KeeOIJlStXTlFRURo6dKgefPBBxcXF5fv3cfLkSd1zzz0qV66cwsLCdOmll2rlypXprx86dEgDBw5U2bJlFR4erlq1amnixImSpOTkZN11112qUKGCwsLCVK1aNT311FP5rgUAAASOIjGm7oEHHtA999yjTZs2qUuXLjpx4oSaNWum2bNna8OGDRo2bJgGDx6s5cuXn/U8EyZMUHx8vNasWaM777xTd9xxh3755Zezfmb06NGaMGGCVq1apWLFiunmm29Of23y5Ml68skn9cwzz+jHH39UlSpV9NprrxXoZx01apRmzJihd999V6tXr1bNmjXVpUsXHTx4UJI0ZswYbdy4UV999ZU2bdqk1157Teeff74k6aWXXtJnn32mjz76SJs3b9YHH3ygatWq5XidkydPKjExMcsNAAAEMLcPTZw40R0TE5P+eMeOHW5J7hdffPGcn+3evbt75MiR6Y/bt2/vvvfee9MfV61a1T1o0KD0x2lpae5y5cq5X3vttSzXWrNmjdvtdrsXLFjgluT+5ptvjE8orgAADItJREFU0j/zxRdfuCW5jx8/7na73e6WLVu6hw8fnqWONm3auJs0aXLGOk+/TmZHjx51Fy9e3D158uT055KTk90VK1Z0P/vss2632+3u2bOn+6abbsrx3Hfffbf7sssuc6elpZ3x+h7jxo1zS8p2S0hIOOdnAQBA0ZCQkJDr7+8i0VIXHx+f5fGpU6f05JNPqnHjxipTpowiIyM1d+5c7dq166znady4cfqxp5v3wIEDuf5MhQoVJCn9M5s3b1aLFi2yvP/0x3mxbds2paSkqE2bNunPFS9eXC1atNCmTZskSXfccYemTp2quLg4jRo1SkuWLEl/75AhQ7R27VrVqVNH99xzj+bOnXvGaz300ENKSEhIv+3evTvfdQMAgKKvSIS6UqdtEDxhwgS98MILGjVqlObPn6+1a9eqS5cuSk5OPut5Tp9g4XK5lJaWluvPuFwuScryGc9zHm63+6znOxvPZ3M6p+e5bt26aefOnRoxYoT27NmjTp066f/+7/8kSRdffLF27Nihxx9/XMePH1ffvn117bXX5nitkiVLKjo6OssNAAAEriIR6k63aNEi9erVS4MGDVKTJk1Uo0YNbd261ed11KlTRytWrMjy3KpVq/J9vpo1a6pEiRL64Ycf0p9LSUnRqlWrVK9evfTnypYtqyFDhuiDDz7Qiy++mGXCR3R0tPr166c333xT06ZN04wZM9LH4wEAgOBV6Eua5EfNmjU1Y8YMLVmyRLGxsXr++ee1b9++LMHHF+6++27deuutio+PV+vWrTVt2jStW7dONWrUOOdnT59FK0n169fXHXfcoX/84x8677zzVKVKFT377LNKSkrSLbfcIkkaO3asmjVrpgYNGujkyZOaPXt2+s/9wgsvqEKFCoqLi1NISIimT5+u8uXLq3Tp0t79wQEAgN8pkqFuzJgx2rFjh7p06aKIiAgNGzZMvXv3VkJCgk/rGDhwoLZv367/+7//04kTJ9S3b18NGTIkW+tdTvr375/tuR07dujpp59WWlqaBg8erCNHjig+Pl5z5sxRbGysJKlEiRJ66KGH9Ntvvyk8PFxt27bV1KlTJUmRkZF65plntHXrVoWGhqp58+b68ssvFRJSJBtcAQCAD7ncBRkkFoQuv/xylS9fXu+//77TpeRJYmKiYmJilJCQwPg6AAD8RF6+v4tkS11RkZSUpNdff11dunRRaGiopkyZom+++Ubz5s1zujQAAIAsCHVn4XK59OWXX+qJJ57QyZMnVadOHc2YMUOdO3d2ujQAAIAsCHVnER4erm+++cbpMgAAAM6JEfYAAAABgFAHAAAQAAh1AAAAAYBQBwAAEAAIdQAAAAGAUAcAABAAWNIkSHg2DklMTHS4EgAAkFue7+3cbABGqAsSR44ckSRVrlzZ4UoAAEBeHTlyRDExMWd9D3u/Bom0tDTt2bNHUVFRcrlcXj13YmKiKleurN27dwflvrLB/vNL/A74+YP755f4HQT7zy8V3u/A7XbryJEjqlixokJCzj5qjpa6IBESEqJKlSoV6jWio6OD9i+zxM8v8Tvg5w/un1/idxDsP79UOL+Dc7XQeTBRAgAAIAAQ6gAAAAJA6Pjx48c7XQT8X2hoqDp06KBixYKzRz/Yf36J3wE/f3D//BK/g2D/+SXnfwdMlAAAAAgAdL8CAAAEAEIdAABAACDUAQAABABCHQAAQAAg1KFAXn31VVWvXl1hYWFq1qyZFi1a5HRJPvPUU0+pefPmioqKUrly5dS7d29t3rzZ6bIc89RTT8nlcmnEiBFOl+JTf/zxhwYNGqQyZcooIiJCcXFx+vHHH50uyydSU1P1yCOPqHr16goPD1eNGjX02GOPKS0tzenSCs3333+vnj17qmLFinK5XJo1a1aW191ut8aPH6+KFSsqPDxcHTp00M8//+xQtd53tp8/JSVFDzzwgBo1aqRSpUqpYsWKuuGGG7Rnzx4HK/auc/33z+y2226Ty+XSiy++6LP6CHXIt2nTpmnEiBEaPXq01qxZo7Zt26pbt27atWuX06X5xHfffafhw4dr2bJlmjdvnlJTU3XFFVfo2LFjTpfmcytXrtQbb7yhxo0bO12KTx06dEht2rRR8eLF9dVXX2njxo2aMGGCSpcu7XRpPvHMM8/o9ddf1yuvvKJNmzbp2Wef1XPPPaeXX37Z6dIKzbFjx9SkSRO98sorOb7+7LPP6vnnn9crr7yilStXqnz58rr88svT99/2d2f7+ZOSkrR69WqNGTNGq1ev1syZM7VlyxZdddVVDlRaOM71399j1qxZWr58uSpWrOijyv7HDeRTixYt3LfffnuW5+rWret+8MEHHarIWQcOHHBLcn/33XdOl+JTR44ccf9/e3cQ0uQbxwH8uzY3K0SYkW8rtgxG1uxg7pKNPBQeki5RYtYSPAWa08VQ6tDJVZeioIx16BJSlyLrUrOGJB1Gs6V2sWisOsjoYkSYsf3+h2iwtAJz7/Pn3fcD7+F9Lu/35WW//d5n7/vM7XZLNBqVpqYmCQQCqiPppr+/X3w+n+oYyrS0tEhnZ2fB2MGDB+XYsWOKEukLgNy7dy+/n8vlRNM0OX/+fH5sfn5eKisr5fr16yoiFtWv57+UeDwuACSdTuuUSj+/O/+PHz/Kxo0bZXp6Wlwul1y6dEm3TJypo2VZWFhAIpFAc3NzwXhzczOeP3+uKJVac3NzAAC73a44ib66urrQ0tKCffv2qY6iu5GREXi9Xhw+fBjr169HfX09bty4oTqWbnw+H548eYKZmRkAwKtXrzA+Po79+/crTqZGKpXC7OxsQV202Wxoamoq6bpoMplKZvY6l8vB7/cjFArB4/HofvzSXfaZ/smnT5+QzWZRXV1dMF5dXY3Z2VlFqdQREQSDQfh8PtTV1amOo5vbt28jkUjgxYsXqqMo8e7dOwwNDSEYDOL06dOIx+Po6emBzWbD8ePHVccruv7+fszNzaG2thZmsxnZbBaDg4M4cuSI6mhK/Kx9S9XFdDqtIpJS8/PzGBgYQHt7+4r/wf3/1YULF2CxWNDT06Pk+Gzq6J+YTKaCfRFZNFYKuru7MTk5ifHxcdVRdPPhwwcEAgE8fvwY5eXlquMokcvl4PV6EQ6HAQD19fV4/fo1hoaGSqKpu3PnDm7duoXh4WF4PB4kk0n09vbC4XCgo6NDdTxlWBd/vDTR1taGXC6Ha9euqY6ji0QigcuXL2NiYkLZ9ebPr7Qs69atg9lsXjQrl8lkFt2lGt3JkycxMjKCWCyGTZs2qY6jm0QigUwmg4aGBlgsFlgsFoyNjeHKlSuwWCzIZrOqIxbdhg0bsH379oKxbdu2lczLQqFQCAMDA2hra8OOHTvg9/vR19eHc+fOqY6mhKZpAFDydfH79+9obW1FKpVCNBotmVm6Z8+eIZPJwOl05mtiOp3GqVOnsHnzZl0ysKmjZbFarWhoaEA0Gi0Yj0ajaGxsVJRKXyKC7u5u3L17F0+fPkVNTY3qSLrau3cvpqamkEwm85vX68XRo0eRTCZhNptVRyy63bt3L1rGZmZmBi6XS1EifX39+hWrVhV+jZjNZkMvafInNTU10DStoC4uLCxgbGysZOriz4buzZs3GB0dRVVVlepIuvH7/ZicnCyoiQ6HA6FQCI8ePdIlA39+pWULBoPw+/3wer3YtWsXIpEI3r9/jxMnTqiOpouuri4MDw/j/v37qKioyN+dV1ZWYvXq1YrTFV9FRcWi5wfXrl2LqqqqknmusK+vD42NjQiHw2htbUU8HkckEkEkElEdTRcHDhzA4OAgnE4nPB4PXr58iYsXL6Kzs1N1tKL58uUL3r59m99PpVJIJpOw2+1wOp3o7e1FOByG2+2G2+1GOBzGmjVr0N7erjD1yvnT+TscDhw6dAgTExN4+PAhstlsvi7a7XZYrVZVsVfM367/r01sWVkZNE3D1q1b9Qmo23u2ZEhXr14Vl8slVqtVdu7cWVLLeQBYcrt586bqaMqU2pImIiIPHjyQuro6sdlsUltbK5FIRHUk3Xz+/FkCgYA4nU4pLy+XLVu2yJkzZ+Tbt2+qoxVNLBZb8nPf0dEhIj+WNTl79qxomiY2m0327NkjU1NTakOvoD+dfyqV+m1djMViqqOviL9d/1/pvaSJSUREn/aRiIiIiIqFz9QRERERGQCbOiIiIiIDYFNHREREZABs6oiIiIgMgE0dERERkQGwqSMiIiIyADZ1RERERAbApo6IiIjIANjUERERERkAmzoiIiIiA2BTR0RERGQAbOqIiIiIDOA/P997u/n2xqMAAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc=history.history['accuracy']\n",
    "val_acc=history.history['val_accuracy']\n",
    "loss=history.history['loss']\n",
    "val_loss=history.history['val_loss']\n",
    "\n",
    "epochs=range(len(acc))\n",
    "plt.plot(epochs, acc, 'r', \"Training Accuracy\")\n",
    "plt.plot(epochs, val_acc, 'b', \"Validation Accuracy\")\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.show()\n",
    "print(\"\")\n",
    "\n",
    "plt.plot(epochs, loss, 'r', \"Training Loss\")\n",
    "plt.plot(epochs, val_loss, 'b', \"Validation Loss\")\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}