SIgn language accuracy using CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "42b35245-93b6-45ed-bcf8-d9ff22473269",
    "_kg_hide-input": true,
    "_kg_hide-output": true,
    "_uuid": "3d3bc91774b6b395666c22dc2cca97af6d5dcbe3"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\statsmodels\\tools\\_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
      "  import pandas.util.testing as tm\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "from keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D, Lambda, MaxPool2D, BatchNormalization\n",
    "from keras.utils import np_utils\n",
    "from keras.utils.np_utils import to_categorical\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras import models, layers, optimizers\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "from sklearn.utils import class_weight\n",
    "from keras.optimizers import SGD, RMSprop, Adam, Adagrad, Adadelta, RMSprop\n",
    "from keras.models import Sequential, model_from_json\n",
    "from keras.layers import Activation,Dense, Dropout, Flatten, Conv2D, MaxPool2D,MaxPooling2D,AveragePooling2D, BatchNormalization\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.callbacks import ReduceLROnPlateau, ModelCheckpoint\n",
    "from keras import backend as Kverb\n",
    "from keras.applications.vgg16 import VGG16\n",
    "from keras.models import Model\n",
    "from keras.applications.inception_v3 import InceptionV3\n",
    "import os\n",
    "from glob import glob\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import cv2\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.gridspec as gridspec\n",
    "import seaborn as sns\n",
    "import zlib\n",
    "import itertools\n",
    "import sklearn\n",
    "import itertools\n",
    "import scipy\n",
    "import skimage\n",
    "from skimage.transform import resize\n",
    "import csv\n",
    "from tqdm import tqdm\n",
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import train_test_split, learning_curve,KFold,cross_val_score,StratifiedKFold\n",
    "from sklearn.utils import class_weight\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "_cell_guid": "86a1fb25-c9b2-41fe-8bc3-01d91f7054bb",
    "_uuid": "22c127e3183a316ca314946688e21db95a7dc4ca"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1750/1750 [00:54<00:00, 32.30it/s]\n",
      "100%|██████████| 1750/1750 [00:31<00:00, 54.87it/s]\n",
      "100%|██████████| 1750/1750 [00:29<00:00, 60.13it/s]\n",
      "100%|██████████| 1750/1750 [00:23<00:00, 73.52it/s]\n",
      "100%|██████████| 1750/1750 [00:28<00:00, 61.83it/s]\n",
      "100%|██████████| 1750/1750 [00:32<00:00, 54.48it/s]\n",
      "100%|██████████| 1750/1750 [00:35<00:00, 49.14it/s]\n",
      "100%|██████████| 1750/1750 [00:56<00:00, 30.86it/s]\n",
      "100%|██████████| 1750/1750 [01:18<00:00, 22.43it/s]\n",
      "100%|██████████| 1750/1750 [00:28<00:00, 61.94it/s]\n",
      "100%|██████████| 1750/1750 [00:26<00:00, 65.72it/s]\n",
      "100%|██████████| 1750/1750 [00:38<00:00, 45.46it/s]\n",
      "100%|██████████| 1750/1750 [00:25<00:00, 69.22it/s] \n",
      "100%|██████████| 1750/1750 [00:28<00:00, 61.41it/s]\n",
      "100%|██████████| 1750/1750 [00:27<00:00, 63.37it/s]\n",
      "100%|██████████| 1750/1750 [00:33<00:00, 52.70it/s]\n",
      "100%|██████████| 1750/1750 [00:26<00:00, 65.60it/s]\n",
      " 78%|███████▊  | 1373/1750 [01:41<00:25, 14.55it/s]"
     ]
    }
   ],
   "source": [
    "imageSize=50\n",
    "train_dir = \"F:/dataset folders/mydata sam/training_set/\"\n",
    "test_dir =  \"F:/dataset folders/mydata sam/test_set/\"\n",
    "from tqdm import tqdm\n",
    "def get_data(folder):\n",
    "    \"\"\"\n",
    "    Load the data and labels from the given folder.\n",
    "    \"\"\"\n",
    "    X = []\n",
    "    y = []\n",
    "    for folderName in os.listdir(folder):\n",
    "        if not folderName.startswith('.'):\n",
    "            if folderName in ['A']:\n",
    "                label = 0\n",
    "            elif folderName in ['B']:\n",
    "                label = 1\n",
    "            elif folderName in ['C']:\n",
    "                label = 2\n",
    "            elif folderName in ['D']:\n",
    "                label = 3\n",
    "            elif folderName in ['E']:\n",
    "                label = 4\n",
    "            elif folderName in ['F']:\n",
    "                label = 5\n",
    "            elif folderName in ['G']:\n",
    "                label = 6\n",
    "            elif folderName in ['H']:\n",
    "                label = 7\n",
    "            elif folderName in ['I']:\n",
    "                label = 8\n",
    "            elif folderName in ['J']:\n",
    "                label = 9\n",
    "            elif folderName in ['K']:\n",
    "                label = 10\n",
    "            elif folderName in ['L']:\n",
    "                label = 11\n",
    "            elif folderName in ['M']:\n",
    "                label = 12\n",
    "            elif folderName in ['N']:\n",
    "                label = 13\n",
    "            elif folderName in ['O']:\n",
    "                label = 14\n",
    "            elif folderName in ['P']:\n",
    "                label = 15\n",
    "            elif folderName in ['Q']:\n",
    "                label = 16\n",
    "            elif folderName in ['R']:\n",
    "                label = 17\n",
    "            elif folderName in ['S']:\n",
    "                label = 18\n",
    "            elif folderName in ['T']:\n",
    "                label = 19\n",
    "            elif folderName in ['U']:\n",
    "                label = 20\n",
    "            elif folderName in ['V']:\n",
    "                label = 21\n",
    "            elif folderName in ['W']:\n",
    "                label = 22\n",
    "            elif folderName in ['X']:\n",
    "                label = 23\n",
    "            elif folderName in ['Y']:\n",
    "                label = 24\n",
    "            elif folderName in ['Z']:\n",
    "                label = 25\n",
    "            elif folderName in ['del']:\n",
    "                label = 26\n",
    "            elif folderName in ['nothing']:\n",
    "                label = 27\n",
    "            elif folderName in ['space']:\n",
    "                label = 28           \n",
    "            else:\n",
    "                label = 29\n",
    "            for image_filename in tqdm(os.listdir(folder + folderName)):\n",
    "                img_file = cv2.imread(folder + folderName + '/' + image_filename)\n",
    "                if img_file is not None:\n",
    "                    img_file = skimage.transform.resize(img_file, (imageSize, imageSize, 3))\n",
    "                    img_arr = np.asarray(img_file)\n",
    "                    X.append(img_arr)\n",
    "                    y.append(label)\n",
    "    X = np.asarray(X)\n",
    "    y = np.asarray(y)\n",
    "    return X,y\n",
    "X_train, y_train = get_data(train_dir) \n",
    "#X_test, y_test= get_data(test_dir) # Too few images\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import sklearn.cross_validation as cross_validation\n",
    "from sklearn.model_selection import train_test_split \n",
    "X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.20)\n",
    "\n",
    "# Encode labels to hot vectors (ex : 2 -> [0,0,1,0,0,0,0,0,0,0])\n",
    "from keras.utils.np_utils import to_categorical\n",
    "y_trainHot = to_categorical(y_train, num_classes = 30)\n",
    "y_testHot = to_categorical(y_test, num_classes = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "_cell_guid": "416ed5f0-5aa3-4d80-a91b-3f16b450a495",
    "_uuid": "676667e7c2b33f134ed685202b2f79bffa3b1734"
   },
   "outputs": [],
   "source": [
    "# Shuffle data to permit further subsampling\n",
    "from sklearn.utils import shuffle\n",
    "X_train, y_trainHot = shuffle(X_train, y_trainHot, random_state=13)\n",
    "X_test, y_testHot = shuffle(X_test, y_testHot, random_state=13)\n",
    "X_train = X_train[:30000]\n",
    "X_test = X_test[:30000]\n",
    "y_trainHot = y_trainHot[:30000]\n",
    "y_testHot = y_testHot[:30000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Step 3 Vizualize Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The min/max pixel values are already scaled between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "_cell_guid": "1abb596c-5c13-4d48-aaf2-d4683f822511",
    "_kg_hide-input": false,
    "_kg_hide-output": false,
    "_uuid": "eb614459b47542a02b0bf9241d778922d6800a88"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plotHistogram(a):\n",
    "    \"\"\"\n",
    "    Plot histogram of RGB Pixel Intensities\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10,5))\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(a)\n",
    "   \n",
    "   \n",
    "plotHistogram(X_train[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "_cell_guid": "ca9e3937-1a11-423a-9615-64e56220225a",
    "_uuid": "1d8945520f8763653c798ccfa7a7e270367cf09f"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "multipleImages = glob('F:/dataset folders/mydata sam/training_set/A/**')\n",
    "def plotThreeImages(images):\n",
    "    r = random.sample(images, 3)\n",
    "    plt.figure(figsize=(16,16))\n",
    "    plt.subplot(131)\n",
    "    plt.imshow(cv2.imread(r[0]))\n",
    "    plt.subplot(132)\n",
    "    plt.imshow(cv2.imread(r[1]))\n",
    "    plt.subplot(133)\n",
    "    plt.imshow(cv2.imread(r[2]))\n",
    "    #;\n",
    "plotThreeImages(multipleImages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "_cell_guid": "cd7271b9-db7e-4077-b7e0-82a7d182a223",
    "_uuid": "2be42c9523cd6e2434a43ac5515736101971aa9e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAIuCAYAAABdOBlOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzda3BT550/8K9ulmRZ0vH9InzBF7C5WUABk0litUl2Z4e0LG132e6GoZlNprOTF13a2W7TvmC6O9282kl3X/xn0r4gLpulNJswZNt0O7SNIdQQiINkE2wDNrZlYctGtu73y/8FPULGspFsSeei32cmMwlWpB98eY5+5znPeY4kkUiAEEIIIURspFwXQAghhBCSD9TkEEIIIUSUqMkhhBBCiChRk0MIIYQQUaImhxBCCCGiRE0OIYQQQkRJvtYPJRIJ3V8uMIlEQsL+O+UnPGx+lJ3w0NgTNspP2FLzS0UzOYQQQggRJWpyCCGEECJK1OQQQgghRJSoySGEEEKIKFGTQwghhBBRoiaHEEIIIaJETQ4hhBBCRImaHEIIIYSIEjU5hBBCCBElanIIIYQQIkrU5BBCCCFElKjJIYQQQogoUZNDCCGEEFGiJocQQgghokRNDiGEEEJEiZocQgghhIgSNTmEEEIIESV5oT+wtLQUlZWVKCsrg0wmg9/vx8TERKHLIOtgMBjAMAx0Oh2kUikCgQBcLhcmJiaQSCS4Lo88ATv2GIaBVquFRCLB3Nwc7HY7vF4v1+URQkjOFbzJqaysxFNPPYW2tjaUlpbCarXirbfeKnQZZB327dsHo9GIbdu2QaVSwWazwWKx4Gc/+xni8Tg1OjzHjj2j0YgtW7ZAoVDgww8/xIULF6jJIYSIkmStLyaJRJLTb60333wTTz311LKZnEAggKGhIczNzcFiseA3v/kN7t69m8uPLSqJRELC/nuu8/vlL38Jk8kEnU6XzM7pdOL999/H22+/DbPZnMuPK0psfrnODgAOHjyI7373uzCZTNBqtZBKpbh//z7sdjsuX76Mvr4+WCyWXH9s0cjn2CP5R/kJW2p+qQo6k2M0GrF///4Vv15eXg673Q4AuHLlSiFLIlmorq5GdXV18r+1Wi20Wi16e3sxOTkJAJicnITT6eSoQrIWpVKJyspKVFZWJn+tqakJjY2N8Hq9OH/+PIfVEUJI7vFi4bFKpUJtbS1qa2uhUqm4LodkqaWlBcePH8fx48fR0tLCdTkkSxKJJPkPIYSISUFncvx+P/x+P5RKJWQy2aMi5HKUlZVh06ZN+MIXvgCv10szAgLCMAyMRiMSiQTu3r2LSCQCq9UKt9vNdWkkQ2yG0WgUoVAIIyMjtE6HAwzDoKWlBQzDLPv1SCQCp9NJ44rn9Ho9mpubwTDMshMHyo87BW1yFhYWsLCwgOrqapSWlq74OTsj0NzcjL6+PlrjITCNjY04evQoamtrcfbsWXz++edcl0QyxI69559/HvPz83jjjTdw584drssqOmwORqNx2a97PB6YzWYaVzzX3NyMl156CUajETKZDFLpw4sllB93CtrkmM1mMAyDffv2pW1y2LPJeDyOsbExjI+Pw+PxFLJEsobVZuJYbH6xWAzT09OYnp6m/HgkFoshFAohFApBoVAkD8DAo+xaW1ths9mg1Wo5rLQ4qVQqdHV14eDBgzhw4MCyn3k8HkilUly8eBHj4+OIRCKIxWIcVUrSYfPr6enBgQMHIJfLlzU5er0ec3NzkMvlmJqaoisVBVLQJucnP/kJzGYzTp48iYaGhlVf19nZiddffx2fffYZrl27tqHPZP+SJRIJusV5g6ampjA1NQWDwQCdTrfi53K5HFqtFvv370drayuGhoZW5MdO3z4pC61Wi/r6etTU1MDr9WJqagoul4ty3IBIJAKXywWXywW9Xg+lUrniNXK5HBqNBnL5ykNDtmOJxl52Ghoa8OKLL6K+vn7Fz7RaLdra2vDcc8+hsrISLpcLdrs9Z7Pd7LhMty6L8stMQ0MDvvKVr6C5uRklJSXLfqbVavHMM8/gqaeegtlsxunTp3Hp0qWc5Pf4ejr2khkdMx8q+D45hcbOOLBnPcUc9kblYrCwX3xP2lenvr4ehw4dwvPPP4+7d+/i9OnTsFgsiMVilOE6KRQK6PV66PV6KBSKrP//1LGUSQbZvp6szWAw4MiRI/jiF7+ISCSCwcHBnH1JSqXStAvQE4kE5ZcjEokEMpkMbW1tePnll7F58+ac5SeTyZK5tbW14dixY3TM/BPeNjmpA00ikYBhmOSCLlYwGITL5YLT6cTc3BykUikYhkFTUxP0ej0AJM9I4/E44vE4gIeXzdipwnQL/VwuF6xWK1wuF2KxWPL/I5mRSqVQKpXJPFL/fNkvvng8ntwx2eVywefzobKyEnq9HqWlpdi2bRtMJhNMJhM2bdoEq9UKhmEQi8Vw48YNeDweKBQKMAwDg8Gw7PJKOByGz+eD0+nEwsIC/H4/J38OfCOTyaBUKtPO4KSSSCSQy+WoqqpCY2PjirEUi8WS2WUy9lIPsqljTyqVQiaTQS6Xo7y8HDqdDrFYDPPz8/B6vbTB5GO0Wi06OzuT/72Ry1VqtTq5+3V1dfWqTU48Hl81P5I9iUSC8vJylJeXr+vPkc2H/T7U6/XJJoc9gdy1axdMJtOyY2Yx58fLJid1oKV2v8eOHcOuXbuSr7Pb7RgaGoLZbMZvf/tblJSUYMuWLfjGN76BnTt3Akg/ZX7ixAmYzWZIJBJs3rwZx48fR3d3d/J9P//8c5w9exYWiwWBQICanCwpFApotVrI5fIVCylTD6Bzc3MYGhrC559/jnv37uHgwYPYvn07mpqasGnTJtTX10OpVKK5uRnHjh3Dl7/8ZSQSCfzjP/4jRkdHUV5eDqPRiMOHD2Pr1q3J93U6nbh37x7MZjMuXryIqampgv8ZCBU79kpLS9HV1YWjR49i+/btAJaPJTa79Y494GHTpVarodVqsWfPHuzYsQM+nw8fffQR7t69i3A4TOtOnkAikayrEaysrMSBAwdgNBrxzDPPJN8rndXyIxuXbX7sCUh7ezteeukl7Ny5c0VjyjZAqcfMYs6Pl02OVCqFSqXC3r17odFoIJPJYDQaYTKZVjQ5FRUVYBgGoVAIJSUlydexB9p0TCZT8hY/9vWpTU51dTXsdjsYhkEgEMCnn35adN1vOlKpNHnG96TXsflJJBKYTKYVd4sAj/Krrq5Gc3PzsiaHnQ0AHl5jTs3dZDKhrq4u2eSYTKYVTU5zczOkUinGxsYwMzMDAMsW28bjcQSDwQ39eYgRm92ePXugVCphMpmSTU6qjY494OFMj1qthk6nW9bkxONxlJWV4fbt23A4HHn7vfJNPB5HNBrN+EtPJpNBpVIhHA4DeHQ5kl0zF41GEQwG4fF44HA44Ha7odVq0dTUhG3btq1ocjLB7mUWiUSWfWZXV1fa14+MjMDlchXFQulAIIDZ2dmMjysymQwajWbZSbRWq101P7/fn1xv8+yzz6K3t3fZcfFx6X5mMpkAPNy0lZ0NXys/h8MBp9OZ/Hwh4mWTw84EvPLKK/B4PMum51KxX35NTU3Yv3//sinztRw/fhyHDx9e9X3ZW6H//M//HLFYDN/+9reLrvtNRyaTLbv2uxr259/85jcBYNUNAtn8WlpakperdDpd2jvvUh0/fhwejwclJSVgGGbFInaNRoPNmzdjbm4ODQ0NyfUnqYttQ6EQNTlpsGPv7/7u7yCTydDY2Jj2dRsde8DKy1V6vR7RaBQtLS3YsmULTp06VXRNTjAYzLgZKCkpQXl5OZaWlpBIJKDX69Hd3Y0jR46gs7MTPp8Pdrsdo6OjGBgYwK1bt5Kzbfv3709ersoGu6bL5XIl/7u7uxuvv/562te/8cYbsFgsyUv/Yra0tITBwUE8/fTTGb2+pKQE1dXVyy7LdnZ2rpqf1WpFV1cXvvrVr6Knp2fF91YmUrdoGR0dfWJ+V65cgcViwcDAgGCbnII+uwp42EmePHky2VEKwWrXMYeHh3HmzBmYzWbeTK3n8/krH374IUwmE0pKStLeQs43Ho8HNpsNCwsLAFbO5Ny6dQsXLlyAxWKBzWbjxSZd+Xp21T//8z+jt7cXu3fvRl1dXS7fOi+cTicmJyfxne98B7dv306u0zp06BAA4N/+7d+wsLAAn8/HcaWPbHTsKZVKfOUrX8GJEydw8ODBJ77e4/Hg1q1by2ZyUteosRs7ut3uFTM5qTOl2RgdHYXT6Vw2k8MwzLK1Qqu9fmhoCGfPnoXZbObl1hK5OHZm8/3m8XgwOjrKfjYAQKfTrZqf3+9f9vP1YsdW6rrG1fJLncm5fv26YPJLVdCZnM7OTnR2dqa9/ZjP0l1qAR5e156dnYVMJsPU1BQWFxd5ddDNNbVaDbVazXUZGWMXaq42gLVaLaanpzE3N4cHDx4UuLrC6u7uhtFozPrMnSvsvj29vb1oaGhYthgdAP74xz9iYWEB9+/fF83u6JFIBG63O9lAPIlWq12xn04quVye3BIg3W3p67HaWMrk9RUVFclnFH788cc5qYdPUm+4yIRWq8W+fftW/Xk+8gMeja1MsM+6a2trg0ajgd1uh1wux+DgIAKBQMZ/V7lU0CbnyJEjMJlMMBgMhfzYvGlqasI3vvENtLe343//939hNptF3eSITeoDK590x5HQsXd0rOfWcS791V/9FTweD+RyOXQ6XfJg/9prryEUCuHTTz8Vze7oCoUCOp1OcBllKnVHdDE2OcWSX3t7O+bm5mCz2ajJeZzRaITRaFz3VCnf6PV67Ny5EyqVCm63G4lEIvk0bsJ/Go0GbW1tyS/RsbExUXxZpqNSqQT58Ntt27al/XX2DLisrCx595zQs2PPsIUy25YtnU6H7du3IxKJoKenBy6XC36/H+FwGMFgEG63W9DbBhRLfmq1Gr29vbDZbMnLVi6XC0NDQ7zMr6BNzkY2IuMzduM6jUaD8+fPc10OyVB5eTl2796NzZs340tf+hKuXr0q+C/KYpP6vDuhZ8du9ieWme7VtLS04MSJExgeHsbk5CSWlpZgt9tx8+ZNQd+FVSz51dbW4tVXX112uWp4eBjf+973eJlfQZucTDYiE6KysjJ0dHTA4XCgtrYWLpdLVHfutLa24oUXXkBbWxvXpeSUSqVCfX198hKImDIrFuzZczAYFPzY0+l0q97KKyYMw+Dw4cMwmUzw+XwIh8MIhUJwuVyIx+OYmZnBJ598AqvVilgshoGBAUHcZVcs+Wk0GuzZs2fZr+3evTv53El2JsdqtWJgYADvvvsup/nx8hZyocp24ZlQlJWVobW1FRqNhutSCEmLYRh0d3fDYrEItskpJkqlEjU1NWl/NjMzA5VKlWxyHjx4gImJCUE3sGKn1+tX7LdktVpRUlICi8XCaX7U5BBCBI+9VPDgwYPkHTxEmNjdmHft2oVEIoHFxUVoNBoMDw9TkyMglZWVeOqppzA0NMRpftTk5JBOp0NnZycsFotgN05Kx+v1YmJiAj6fDxUVFVyXkzfslunF/kA7IWK3CxDa9hTAw8umer1+1ZmNYqNWq7Fp06bkfx88eBBqtRoVFRW4ffs277YMoPzSKy0tRWlpKef5ieu6CsfEuvDMbrfjwoULoj9DZrfJF8JGh0Q82Ls013ocRjHbu3cvvva1r+HEiRM4fvz4qjuoc4XyWxvX+dFMTg4J+WxyLT6fDxMTE/B6vVyXklfsU7rZHWQJKQR2a/1MN2grNo/fHMC3O1gpv7VxnR/N5BDyJ+xdchvZMp1wh73TSmh7lTQ0NODFF1/Eiy++yHUpZB0oP36jJoeQP6moqMC+fftQXl7OdSlkHdg9c/h4SYMQwg1qcgj5E61Wi66uLtFdbiwWQp3JIZmj9S/CljpGC4XW5BDyJ2q1GgaDQVAPISWkmLDPC6yvr8fw8DDX5ZAscbFDOTU5OcZ2quzj7Pl0q+N6aTQa1NbWoqysjOtS8krsD9grFhKJBBKJBFKpFIlEgvfbAQQCAczOzmJ2djanT5sWo9TjK19Qfplj8wuFQjAYDFhcXEQgEMjrZ9LlqhwT47qA2tpavPDCC6itreW6FEKeSCKRQCaTQSaTQSKRcF3OEy0tLWFwcBCDg4Ncl8J7UqkUJSUlKCkp4bqUJMove+z6x0Lsu0ZNTo6xneqePXtQVVUFuVwuiAPtWorpsQ5GoxFvvvkm3nzzTVHcEtra2opvfetbonvu2JNIpVLBjLupqSmcPn0ap0+f5roU3mMb2C1btuBb3/oWWltbuS6J8luH8vJy7NmzpyBr56jJySN22lwoB1sivsWrxdSgsnQ6HbZt24Zt27YJYhF5KBTC/Pw85ufnuS5FMDQaDVpbW3lxCZ3yyx77nMdCbLxKTU4eUYNDSOFt2rQJX//61/H1r3992eMBCCHFh5ocQtJIXbxKjaqwMAyDXbt2YdeuXdDr9VyXQwjhEDU5hKQhtMWr5BGZTAa1Wg21Wk3PISOkyFGTQ8gqxDCLQxscEkKKGTU5hIiYQqGAVquFXF48W2I5nU5YLBZYLBa4XC6uy8lYMBjE/Pw8QqEQ16WQdaD8+ImaHEKIqExPT+PMmTM4c+YMpqenuS4nYy6XC8PDw4JqzMgjlB8/FaTJ4dPtfiR7crmcdgImgsF+2QjtC8fpdMJsNvNqN1+SOcqPnwrS5NCOucJGz3QiJP/YnXOXlpa4LoWsA+XHTwVpcopxQzKZTIbS0lKUlpYK/g6PYlzXIRaJRAKxWIz3z28iD9d0zM7O5v1ZPiQ/KD9+KkiT4/V6MTExAZ/PV4iP4wWlUomqqipUVVVBqVRyXc6GRCIReDweRKNRrkshWVpcXMS1a9ewuLjIdSmEEFJwBWly7HY7Lly4ALvdXoiP44VQKIQHDx7gwYMHgl9tHwgEYLPZ6AxFgNhFuEJagEsIIblSkCbH5/NhYmICLpcL0Wi0KKbOtVot2tvb0d7eLvgF17SgTrjYRbi3b9+G3W5HMBjkuiRCCCmYgt5CHgqFEAqFEIvFCvmxnGhubsaxY8dw7NgxNDc3c13OhhTjTJzYCHHfGEII2aiCriQ1m83Q6XTo6OhAVVWVKHaUXY1er8euXbuwuLgo+KdZszNxly9fhlwuR0tLi+B/T8XGYrFAp9OhtrYWDMNAoVBAKqVtsvgmFArB4XDA4XBAq9WipKSE65JIFig//inoUe7MmTP47//+b4yPjyMcDiMejxfy48kG9fX1oa+vD5OTk1yXQrJ048YNXLt2DVNTU3C5XIhEIlyXRNLweDwYGxvD2NgYPB4P1+WQLFF+/FPQmZybN2/CarXi8uXLMJlMePnll7F79+5ClkA2wGw2Q6VS4eDBg2hoaIBerxf8nWPFYnZ2Fr/73e8wMjICk8mEV199FXv27OG6LPKYcDicvGGhpaWF63J4a2JiAm+99RbvLqFTfpkpZH4F3/iEXQhZWlqKAwcOoLq6Gps2bSp0GWSd2EXIer0eO3fuRF1dHV32EAiPx4PR0VGoVCps3boVUqkURqOR67IIyRq7LQkRpkLmx9nubg6HA5988glUKhU1OQJis9lw7ty55DXnyspKms0RmMnJSfT19WFqaoqaHEKIqHF2Cs7OCJjN5qK4pVws2NmAK1eu4OOPP8aNGzcoP4Fhx97AwACsViv8fj/XJZE/8fv9mJmZwczMDO1LJUCUH/9w1uR4PB6MjIzg1q1btO28AE1PT+Odd97BO++8g3g8TvkJkMPhwMDAABwOB9elkD9xOBy4cuUKrly5QrkIEOXHP5xdrmL3zLl79y7MZjPa2tpQXl7OVTkkS+zaKqlUCrPZjNbWVspPYJxOJwYGBqDRaJBIJFBVVYXS0lKuy9owhmGS2zeMj48L6oGJgUAAMzMzmJycxMLCAnw+H5RKJT037k9cLhesVitu3rzJdSlpUX5rczqdmJychNlsLthncv4nPzQ0hFdffRXHjx+HyWQSzR4sLpcLU1NTGBoaEvVOwRaLBa+88gq++c1vwmQyobm5WRT5CfmLMlMOhwOnT5/GwMAATCYTjh07hl27dnFd1oaxG3E2Njbi1KlTgsyO3YAzHA5j//79MBgMXJfEC8PDw3jjjTdw8eJFrktZE+WXntlsxo9+9CP09/cX7DM5b3KA5Qshjx8/LorFkFNTUzh9+jT6+/sxNTXFdTl59Xh+YmhyxPBFmQmfz4fx8XE0NjbC6/VyXU5OiGHszc7O4sMPP4Tf70djYyN9Sf5JLBZLXgXgM8qPP3jR5LALIQEkH4Eg9Bkdp9OJoaEhDA0Nif7p3Wx+MpkMXV1dKC0tRX19vaCf2SWTyVBaWorS0lJRTzWHw2GEw2Hcu3cP169fh0ajEfxsnNPpTD7GQqiPkPF6vbhz5w40Gg22bduG9vb2nGYSDofh8/kAQFCXmcvKytDe3g6bzYbR0VGuy1lVvvMTKq1Wi61bt2Jubq5g+fFqgxN2RoB21RWeRCKB2dlZ/PrXv8avf/1rzM7Ocl3ShszNzeE3v/kN/u///k/wv5dMsLMfP//5zwU7+8FKJBKIxWKiWBDPHhNzfTxkZ/DGx8dz+r75ZjAYcPjwYRw+fJjrUjKSr/yEiov8eHWKmjqj09LSIvjZnGLDnkHLZDJUVFSgrq4OWq2W67LWhZ2JK5aHWrJjTyqVYsuWLWhtbRVsdsDDRkcMTQ6bC7uGodiPiQzDwGg0CmadY2p+8XgcmzZtAsMwkMvlRbmJKhf58arJYVksFnz3u9+FRCLBs88+W/QDWyh8Ph98Ph/m5ubwxz/+EeFwGAcPHkRjYyN0Oh3X5WXF7/djcnISU1NTgr3kkQ129mN4eBgnT56EVqtFT08PamtrodFouC4vI+ydGzdu3MDS0pLgG5xUJ06cgNFozNkNGuXl5fjCF76QwwoLQ6VSob6+HvX19VyXkpUTJ06gq6sLX/va12AymbBz507U1NRwXVbBsfl1dHSgtbUVdrs9edk0X3jZSrJnYadOnaKpPgGKRCJwuVx45513cPbsWVitVq5Lyhr7pV9sezix2f3mN7/B7373O949G2gtYr/cLfbfn9jZbDa89957eO+99zAzM8N1OZyqra3FCy+8gNra2rx/Fi9ncoCHXzKpl64kEongFkSKYbp8Pdjm4LPPPoNUKkVHRwdKS0tRU1PD+1mBx2cD4vE41yUV1OPZVVZWQiKRCCY7dhd1MUp3g4YY7kQtFm63G263G0qlElu2bIFUKkV3dzckEgnXpXFCIpEU5PfO2yaHJdTbk4t1JiBVIBDA1NQULly4gFAohOeeew6bN2/muqw1sX/f+vv7i/pseWZmBlKpFFKpFEtLS4LIrljQs8eEjc3v3r17+Pd//3fIZLKia3Tm5+fxhz/8QZxPIc/W42cvfJ/NKfaZgFSRSAQLCwv47LPPoNVqsXv3bt5/Ubrdbty8eRM3b94sirU4q3G73ZienkYikYBGo8HevXu5LmlN7DPV3G4316XkXeox0Ww205pFgWHzi8fjRbvbv9frxfj4eEG+H3m5JudxiUQC9+7dw9tvv837s2u6br5cIBCA1WqF1WqFx+Ph/ayWTCaDWq2GWq2GTCbjuhxOpWbH94d42mw2nDt3DjabjetSCoZuTxY2dtsGoW/ZsB6FvPuR9zM5LLb7/X//7/+ht7cXzzzzDJqamrguawV2/4mJiQl6Ci0ezuZEIhFcunQJU1NTOHToEHbv3o2DBw9i06ZNXJe3TDQahcvlgsfjQSAQKOqZHGB5dtPT0zh16hRvL48sLCzg4sWLiEQiXJdSME6nE319fbh8+bKoHstRLFwuF37+85/j0qVLMJlMotntP1OFOuEVTJPDMpvN0Ol06OrqQkNDA6+uZ8bjcYRCoaK+RLUal8uFoaEhlJWVQSKRoKuri3dNjtvtxueff47FxUXR71KdDfYE4+bNm6iqqkJlZSXUajXXZS3DbvdfbNhsJBIJNm/eDKlUisbGRuj1eq5LIxlIza+trQ1yuVzU+RXlAzqzNT4+jrq6Ojx48ADBYBAqlYo32+7TTMCTjY2Nob6+Hh6Ph+tSVmB3bC6GHY7X48qVK1AqlbychStW7A0Ok5OTOHPmDO7fv4+/+Zu/Ee2XpFhZrVb84he/wNzcnKjzS72xo1D40R1kYXFxMfmcndLSUnR2dqKqqorrsgA8WrTqcDiKato8Gw6HA3a7HUtLS/D7/VAqlbxZ+8Lmx8cGjA/MZjMYhuHVLBwXZ4Z8k0gksLS0hBs3bkAikaCpqQlNTU2C24AzE2LNO3XHcbHnV+htHgSx8PhxbNfLt43m5ubm8Nvf/lZQG6hxIRQKYWFhAQsLC7y6xBCJRODxeOhS1SrGxsYwNjbGqyYwdaF/MWMv1929exdnz54V7WZzYs27WPLjguBmcoCH6ztcLheqqqp49Vwht9uNW7du5X2baqFju3mGYbBv3z6UlpZyXRKAh2uqwuEw12XwlsPhgMPh4EVj6vP5YLfb8dlnn+Hy5cuiO7PPViKRQDQahcPhwI0bN2C1WtHY2Ai1Ws2by/lkdY/nd/XqVUilUhgMBkE/Q44P6G9/DoXDYSwtLXFdBu/duXMHP/nJT2A2m3Hy5Ek0NDRwXRIRmPHxcbzzzjvo7+/HxMQE1+XwRjgcRjgcxrlz5zA9PY3NmzejsbERDQ0Noviy3LlzJ3784x+jv78fhw4d4rqcnGPz+8EPfoA9e/bg6NGj6OnpEU1+Wq0WHR0dsNlsuHPnTkE+U5CXqwghhKzuwoUL6Ovrw89+9jN88MEHuH//Ptcl5UTqpW4xc7lcGBkZwXvvvSeq/Orr63Ho0KGCNqg0k0MIyQh7+7hSqeS6FPIEExMTmJ2dxb179xCPx7F9+3Zs3rwZJSUlXJe2IWJ/PhkrGAzCbrcjHA5DqVQKPr94PI5IJIJgMFjwu45pJocQkpGtW7di69atopg2Lwbs5fOpqSkMDw/zasH4erHbPPz617/mupS8E1N+kUgELpcLo6OjOH/+fEHzE3STE41G4ff7eb/lPCFiEY1G4fV64fV66S40novFYggEApidncXg4CCuXbuGO3fuwOv1cl3aunk8Hty5c6dg6zm4JMbnLYgAACAASURBVMb8vF4vbt++XdD8BH25KvX6bHNzM9flECJqY2NjKCsrw44dO1BVVYW6ujqUlZVxXRZ5AofDgStXrkAmk+HAgQM4dOgQOjo6uC6LZEgM+SkUCuj1euj1eigUioJ+tqCbHJfLBYvFgvLycmpyCMmzBw8eYHZ2Fna7HU6nE5WVlVyXRDIQCAQwMzODDz74AJcuXcJ//dd/ob6+HnV1dTAajXjttde4LvGJotEogsFgUc4giiE/qVQKpVLJyeavgm5yUqfOifCwm+95PB5a5yEQ7H4e0WiUntEmMOyl/fv376OsrAx1dXVwOp3o6elBfX09GIbh1Q7kqZxOJ0ZHR2GxWOB0OrkuhxNCz4/dqbrQ+Ql6TQ4RtkAgAJvNBpvNxnUpJEPss5JisVjBniJMci8YDGJubg5Xr17FT3/6UwwODvJmo8d0rFYrzp49i1/84he82uWeK0LLL3Wn6snJyYJ+tqBncoiwhUIhzM/PY35+Hp2dnVyXQzLg8/kwMTGBxsZGbNq0iTfPjSPZSZ0F7+/vT66t2rt3L292IE/lcrlw8+ZN3Lx5k+tSeEFo+XF56z81OYQz4XA4+agAIgzz8/P46KOPEI/H0dXVRWvhRGB2dha/+tWv4PV60dDQQDuQCwzltzZBNzkOhwPXrl2DWq3G3/7t33JdDskSe4tkIBDguhSSIZ/Ph3v37qG5uZme0SYS7Lo4hmFw69Yt1NTUoLKykpczAmQlym9tgl6TEwwGcf/+fczOznJdCiGECFokEoHb7Ybb7S66O5jEgPJLT9BNTmqohBBC1i8ejyMUCiEUChV8632ycZRfeoJuclJDJYQQsn7spch79+7RpUgB8ng8uH37Nm7fvk3bqqQQ9JocQgghucHurFtSUoL29nZs2rSJ65JIFux2Oy5cuIBIJIL29nY0NjZyXRIvCHomhwgb+6Rdu93OdSlEYMrKytDa2orW1lZoNBquyxEFr9eL8fFxTExM0EyOALHbO0xMTNBMTgqayckhmUwGlUqFSCRC10Qz4HQ6MTQ0hIqKCq5LET2p9OH5TCKREMUmfq2trfjWt76FrVu3Ym5ujjaIy4FIJAKn0wmn04lwOMx1OcvodDp0dnZibm4ONptN0E/kLkZc5kczOTnEPoSs0A8gEyq9Xo8dO3Zgx44dXJciejKZDDKZDBKJhOtSCMmawWDAkSNHcOTIERgMBq7LIVniMj+ayckh9iFk7FkzWZtKpUJNTQ1qamq4LkX0qLkhQqbVapMzATqdjutySJa4zE+y1tS1RCIR/rx2kUkkEslvM8pPeNj8KDvhobEnbJSfsKXml4qmHAghhBAiStTkEEIIIUSUqMkhhBBCiChRk0MIIYQQUaImhxBCCCGiRE0OIYQQQkSJmhxCCCGEiBI1OYQQQggRJWpyCCGEECJK1OQQQgghRJSoySGEEEKIKFGTQwghhBBRoiaHEEIIIaJETQ4hhBBCRImaHEIIIYSIEjU5hBBCCBElanIIIYQQIkrU5BBCCCFElKjJIYQQQogoUZNDCCGEEFGSc10AISR3VCoVGIaBVquFRqNBNBqFw+HAwsICotEo1+URQkhBUZNDiIgwDAOj0YjOzk5s3rwZHo8HV65cQX9/PzU5hJCik5cmh2EYtLS0gGGYFT9zu92w2WxwOp2IRCKIx+P5KIFsgF6vR3NzMxiGgUQigUQiSf7M6XRicnISTqeTwwrJatgmp6enJ9nklJSUAABmZ2dp7PHcWmOPjp38R/nxT16anJaWFhw/fhxGo3HFz0ZGRvD+++/DbDbD4/EgFArlowSyAc3NzXjppZdgNBohk8kglT5aumU2m9HX1wez2cxhhWQ1DMOgu7sb+/btg0ajQSQSQVVVFQ4ePIjh4WEaezy31tijYyf/UX78k/MmR6VSoaurCwcPHsSBAwdW/LympgYPHjxAIpHA8PAw5ufnc10C2QA2v56eHhw4cAByuXzZQGUYBvfu3UMikcDU1BTN6PCISqXC5s2bsXnzZjQ0NCR/vaqqClu3bkVFRQWNPR570tirra3F4uIiAGB4eBh2u52rUskq2JnU3t7eFfnRdx83JIlEYvUfSiSr/3AVra2t+Nd//Vc8/fTTaGpqWvHzRCKBWCwGs9mM06dP49KlSzmZFWCnBlOnCwHAYrHA5XIhkUhgrd+rWCQSieT8qJDy+1O9KCsrQ01NDRiGgUqlgkKhKKpLZGx+QsputbEHFNflzXyPPRY7m9rf35/T/DQazbKxd+vWLTp2ZslkMuHkyZMwmUzp3p+++/IoNb9UBV94LJFIIJPJ0NbWhpdffhmbN2/OWdDs+x47dgy7du0CAPzTP/0TLBYLYrFYUQSdb/nMTyqVor6+Hs899xy6u7vR0NAArVYLi8WCt99+GxaLhTLcgEKPPQCUXR6wywGam5tzml9DQwOee+457Nq1Cw0NDfiXf/mX5LETAOW3QVx+9wHFmx8nd1dJJBKUl5ejvLwcLpcLUqk0q26T7VwZhkFzczP0en0yaKPRCJPJlAzaZDKBYZhlTY7ZbC6KM8v1SCQSiMfja2aRmt9G/hxTF6izTU5raytMJtOyJodhGExOTibPUCi/9AKBAGZnZxEMBld9TSHHHgDKLguZ5Ac8uiSynj/HtfJra2tDb29vcuxdunQJDMMgHo8nF8mulp9UKoVMJgMAxGIxWlS7io2OP9bjx861vvsyyU/MOL+FnA0om5kWiUQCuVyO9vZ2vPTSS9i5c+eKwcs6duwYvvzlLy/7i3TixAlaOLuKeDyOSCSS1aCTSCTrOktIXaDO3oWQerlKrVYve93hw4cBUH6rWVpawuDgIJ5++umMXp/vsQdQdtnINj8g+7G3Vn6pl6vUanVWx06ZTJYcr4FAgJqcDKxn/LEeP3bSd9/qct7kZHo2wpJKpclNyzQaDQwGA3Q63YrXsbffyWQyMAyDqqoq9PT0oLe3d9mZ4+PS/ay2thYqlQqRSAQAoFAooNfr0dXVlfY9RkZG4HK5EIlEklN/YhUMBjE7O4tAIJDR62UyGVQqFcLhMCQSCZRKJRiGQX19PcrKypKvY/PzeDzQarUwGAx49tlnYTKZ0t6Fl4o9c2Wx17snJyfh8XiemJ/D4YDT6YTD4YDf78/o9yVE2WaX7djzeDzJ6/7PPvvsE8cesPHsaOytjmEY7NmzBzMzMwCQ8/zS/Wy1/Hbu3LmsyWH3ZCqWsbceUqkUKpUKwWAQEokk+Wf5eI7rPXZmk5+Yj505b3KyPRtRKBSorKxELBbDli1bcOTIEXR2dq543ejoKM6dOwe1Wo2uri7s3r0bnZ2dK84cM6HX66HX6+FyuZL/3d3djddffz3t6994443kIi6xH2hdLheGhobwpS99KaPXl5SUoLy8HEtLS5DJZKipqYHRaMRf/MVfoL29Pfk6Nr/R0VF0dnbiyJEj6OnpQUtLS9Y1susR+vr6MDo6+sT8rly5AovFgoGBAcEO1HzIduyNjo6iq6sLX/3qV9HT07OusZdtdsU09rLV0tKCV155BefOnQMATvP74Q9/mPZyFY291bENBvvnxf5ZPp4jHTs3Jud3VwFrrzB/nMfjwejoKAAku1StVpv2dexMDrtOQ6VSrac8jI6OJjdkAh7+ZWMYJu0B4vHXDw0N4ezZs8m9Dvgm33cIPM7j8eDWrVvJmRyVSgW9Xr9iJofNz+12Q6fTrZpzpti7dtizkbXySz0buX79uiDy4+PY4yI7GntrY7MBwMv8hDj2gMIfO4FH30OP50P5ZaZgd1dJpVIolcpl+wOsRavVYt++fRm9brUgspXt+6S+XqPR4ObNm3A6nZiamkIgEEg2S2KwnvzS7YeU7nW5yg9YeRlkLZWVlaisrERbWxs0Gg3sdjvkcjkGBwdFlZ8Qxh6QXXapn1tRUSHa7NYrk2xo7PETHTsLI+dNjkKhgE6ng0KhyPVb84Jer8euXbsQjUYRjUZhs9kEEXSmxJ5fY2Mjjh49ivb2dszNzYkqP8qO8BnlJ2xCzS/nTQ7bJaZ7bpUY6PV67NixA2q1GrFYDLdu3cLc3BzC4TBisRgikQh8Pl9yClJoxJ6fTqfD9u3boVar0dvbC5vNhoWFBSwtLcHv98Pr9Qo2v2LMjp029/l8mJqaAgDBjsFizM/pdCIajcLn88FqtQoyN5ZKpUJ9fX1yAbbYPGn83b17l5f55bzJMRgMOHLkCAwGQ67fmhe0Wi26urrQ2NiI2tpaXLt2DXfv3sXS0hICgQCcTifu3bvHu6AzJfb8WLW1tXj11VcRCARgtVpx48YNTE5O4u7du4LNrxizY88kp6am8POf/xwABDsG2duC17OgVEhS8/N6vXC73ZiamsKZM2cEmRurvLwce/fuRXl5Odel5NVq4+8///M/eZlfzhcem0wmfPTRRxsqSihCoRBcLleye003k2O1WjEwMIB3330XDocj7zVtdPFcMeXHCgaDq87kcJUfZZcdv9+PyclJAMC9e/fwhz/8ARMTE4jFYhgYGKCxx1Psvlx+vx/T09O8GHvA+vLr6enB+fPnodfroVQqc1scz/n9fty5c4c3+aXK2UyOXC6HUqlEaWlprt6S95RKJWpqatZ8jdVqRUlJCRYWFjA+Pl40z/EREnaaOR3KTxhKS0uxbds2AA+n1YPBIBobGxGLxVBSUkLZ8RS7WF6pVK6YARHa2FOpVE/8PhCr0tJSdHd3L/u11PysVmvyTi2Px1PQ2Z6cNTlKpRLV1dWorq7O1VuKQmVlJZ566ik0NTXhk08+QV9fX9HtOClklJ/wVFZW4sCBA9i1axcSiQSeeuopyk6AaOwJW2p+d+/exZUrV2A2m3H79u2CzOywctrk1NTUoLa2NldvKQqlpaUoLS1FY2Mj1Gp1cnEk385K2P1tivVMZDVCyI+yW06tVmPTpk0rfo2P2QGU32qEMPYAym81qfkZDAbIZDJEo1HY7faCNjmZbaiRAZVKhbq6OtTV1eXqLUWHXVjIx8WF7NbsO3fu5LoU3uJrfpTdk/E1O4DyywTlJ2zl5eXYs2cPJwuzc9bklJWVoaOjAx0dHbl6S9FhbxHl422i7PbemW4SVYz4mh9l92R8zQ54dOzcsmUL16XwFp/zo6sYT6ZWq9HY2JiclSuknF2uamhowIsvvpjxduSEXyg/4aLshK2iogIHDhzIaPfbYpe6UDkUCnFdDoBHNy6sdvMCeXhjklwuR2lpKeTynO9cs6aczeQQQgjJHt20kTmFQgGtVpv2aetcYffH2bt3L9elkDRy1uSEw2EsLi5icXExV29JCC+VlZWhtbUVra2tXJdCspR62YMv4vE4gsEggsEg16XwHh/zI5njIr+cNTkejwd37tzBnTt3cvWWhPBSbW0tXnjhBbzwwgtcl0KylLqAlS/o2Jk5g8GAr371qzhy5AjXpSQtLS1hcHAQg4ODXJfCe1yMv5xdHAsGg5idncX9+/dz9ZaixXazoVAI09PTWFxcRCAQ4LSmQCCA2dlZzM7O0rXlJ2Dzi0QiuHDhAux2O3w+H2f1UHaZY7OLRqNobW3lPDuAjp3Z0Ol00Ol08Pl8vMrv/v37lF8GuBh/OZvJiUQicLlccLvduXpL0WK72RMnTmDfvn2oqKjguiQ6G8mCWq2GwWDAnj178MILL3B+VwVllz12No7r7AA6dq4Hn/Ij2StkfjlrcmZnZ/Hhhx/iww8/zNVbihbbzX7xi1/Enj17eHFL5NTUFE6fPo3Tp09zXQrvyeVyaLVatLe38+JAS9llT6PRoLW1FWVlZVyXQsfOdaipqeHF2AMAu92O3//+9/j973/PdSmCUcj8ctbkhEIhzM/PY35+PldvKXrs7ZAymYzrUig/AaPshI3yEzbKj9/oFnJC1ikUCsFut/Nmvw5CigWNPWErZH7U5BCyTtFoFF6vF9FolOtSCCkqNPaErZD5UZNDCCGEEFHKeZOTSCQQj8eRSCRy/dakANhFdHR9WXho7AkbjT1ho/z4KedNTjAYpGulAsZeK6XdV4WH3W+FshMmp9MJs9kMp9PJdSlkHSg/fsp5k+N2u/H555/D5XLl+q0JIWugg6ywsfsdLS0tcV0KWQfKj59y3uQ4nU5YLBZqcgSK3T2XZgOEhx171OQIEzsTx/Xu52R9KD9+ynmTQ92ssFF+wuVyuTA0NEQnGIQQ8id5WZND3axwUX7Cxa6Ho1k4Qgh5iG4hJ4QQQogoUZNDCCGEEFHKS5MTi8UQCoUQCoUQj8fz8REkjyg/4aLshC0UCsHhcMDhcCAcDnNdDskS5cc/eWlyotEoPB4PPB4PIpFIPj6C5BHlJ1yUnbB5PB6MjY1hbGwMHo+H63JIlig//slLkxMKhfDgwQM8ePCAulkBovyEi7ITtnA4nMyPNlQVHsqPf/LS5LB36NBdOsJE+QkXZUcIIY/I8/GmqVPm9JTY1U1MTOCtt96C3W7nupRlKL/M8DE/yi4zfMyOEJJ7eWlySGa8Xi8mJia4LoOsEx/zi0QicLlccLlcRbcmJ5FIJB9OKpFIIJFIVn0tH7MDiju/UCiUXMei1WqhVCpXfa3P58PExAS8Xm+hysuI3+/HzMwMZmZmsH37dq7L4a1C5ke3kBMiIn6/H9PT05ienobf7+e6nIJKJBKIRqOIRqOCfRJ7Mefn8XgwMjKCkZGRJy7atdvtuHDhAu9m4hwOB65cuYIrV67A4XBwXQ5vFTK/vDQ5qd0srQsQHspPuCg7YaP8MsPOxPl8Pq5LWSYQCCTzK7YmNRuFzC8vl6vYblapVOILX/gC2tra8vExJE8oP+EKBAKw2Wyw2WxF9yUpkUggl8uT/y5ExZyfVqtFV1dX8t8JyYW8NDlsNzs5OYmFhQX4fD4olcrkAajYuVwuWK1W3Lx5k+tS0qL81uZ0OjE5OQmz2cx1KSuwC4+XlpbgdDqLKrsnrcMB+J0d8Ci/+/fv49atW6ipqUF9fT3Kysq4Li3vlErlmutwAP7nx/J4PLhz5w4MBkPR5JcJv9+PhYUFTE1NFewz83rkY6+7hcNh7N+/HwaDIafvH4/Hk3eQlJSU5PS98+nWrVt488030d/fz3Upa8p3fkI1PDyMH//4x7h48SLXpayKzS4QCKC7uxutra2QyWRcl8U5IWQHAKOjo3jjjTfw8ccf4+///u/x9NNPU34AzGYzfvSjH/H+2En5pbewsICLFy8WdPzltcmZnZ3Fhx9+CL/fj8bGxpx/SbJnPQBQWVmZ0/fOJ4VCAZ1OB51Oh4WFBa7LWVW+8xMqhUIBvV4PvV7P2yd+s9k9ePAAMpkMBoMBpaWlXJfFOSFkBzy802h+fh4zMzOw2WwIhUKUn4BQfulVV1ejt7cXiUQCp06dKshn5vXuKq/Xizt37uD69eu4fPkynE5nPj9OMPR6PXbs2IEdO3ZwXcqaKL/0tFotOjs7sXXrVq5LWRVllx7DMDAajeju7ua6lDVFo1H4fD7YbDYMDg5SfgJD+aVXWlqK5uZmNDc3F+wzC3IL+eTkJPr6+jA5OZnT95XL5dBqtYJbpFZfX49Dhw7h0KFDXJeSkXzlJ1TV1dUwmUwwmUxcl/JEs7Oz+NWvfoXZ2VmuS+EFg8GAI0eO4MiRI1yXkhHKT9goP+4VZDWi0+mE2WxGf38/4vE4Nm3aBIZhIJfLIZWuv8+SSqWCWovDKisrQ0dHB2w2G9elZCRf+QmVTqdDZ2cn5ubmuC7lidjdjz/++GNIJJKiz46dhRNCdgDl9zh2Ji4cDsNqtcLhcPD6Vm3Kj3uStTbNkkgkOd9Rq6urC1/72tdgMpmwc+dO1NTU5PojBKO/vx9f/OIXc/qeiUQieXsJ5Zdf165dw1//9V9jYWEhZwdaNj/KLr8+/fRTHD16FHa7PWd7dRRq7PX29qKrqwu1tbVFcddcOna7Hf/xH/+Bc+fOYXR0NCfvSfkVTr7HX6qCt5I2mw3vvfce3nvvPczMzBT648kGUX6PVFdX49lnn0V1dTXXpWSEsnuktrYWL7zwAmpra7kuJWNsfr/85S8xPj7O64XT+SaTyaDRaATVJFB+jxRy/BX8b4jb7Ybb7YZSqcSWLVsglUphNBoLXQZZJ8pPuNJl193dndeN89jnSWWyh00haTQatLa2Cmr/EjY/mUyGpqYmSCQSPP3007z6cy0UqVQKhUIhqEs+lN8jhRx/nP0NYRez9vX1FeTzUh/eRzaO8nu458OlS5d4vQ1AOmx2p06dQiwWy9ufK5tZLBbL6+cUG6vVirNnz+IXv/gF/bkKEOVXWJzN9bGLWYGHGzy1tLSAYRiuyiFZovwe7t5ZyJ07c4XNLh6Pw2w2o62tDeXl5VyXVVB8fYp1JtinlEulUty4cQOtra2oqKgoqhkBseRH468InkJeqNuT+TZdLhaUn3BNTU3h9OnTeWvU2MxkMhlkMhmv8uPrU6yzweY3MTFRdDMCYspPiCdKG1XI/Ap+d1U6DMOgpaUFJpMJx48fL5o1HkK8uyodyi938nl3VTqUXe5wMfb0ej2am5thMpnw8ssvU34bQMfOwsl3fql4sTQ99dIHuxOimC9/COUhc5kqtvzEhLITNpfLhaGhIUilUmzevBkA5SckNP7yj/PLValSF7OKeXfdQi/aLZRiyU+MKDtho/yEjfLLH17M5LDYrlYqlaKjowOtra3Q6XRcl5Vz7O9TLDM5rGLKT0wzcQBlJ3SPzwiIdTbA4/HAZrNhbGyM61Jyqljyi8ViCIVCBd2lmlczOayZmRn8z//8T9FvWCZUYs9PrDNxAGUndGJ/zpzNZsP58+dx/vx5rkvJC7HnFwqFsLCwUNBtN3g1k8Niu9qrV69CKpXCYDAI7iGca2Gfv5LavYuJ2PMT60wcsPw5ZeFwWHRnlGLODlieHyC+9R2Un7B5vV6Mj49jfHy8YJ/Jy5mccDiMpaUl/OAHP8B3vvMdvP/++xgbG4PH4+G6tJzo7OzE97//fXz/+9/nupS8EHt+Wq0WHR0d6Ojo4LqUnGOze+211/DKK6/g7NmzlJ0AnThxQpT5KRQKaLVaQe1UvR5izc/pdMJiscBisRTsM3nZ5LBcLhdGRkbw3nvv4YMPPsD9+/e5LiknXC5XwYPmgljzq6+vx6FDh3Do0CGuS8mr+/fv44MPPqDsBIryEzYx5scwDLq7u9Hd3V2wz+Tl5SpWMBiE3W5HOByGRCJBXV0dGhoaBH/pg52SFHuTI7b84vE4IpEIgsEgYrEY1+XkXerlVJ1Oh9raWsFOnRdbdgDlJ3RsfnK5XDTHTq/XC6fTWdCZKV43OcCj6fPPP/8cUqkUBw4cEGzQrKWlJdy4cQM3btzgupS8E1N+kUgELpcLo6OjOH/+PK5cucJ1SXnFZnfjxg3Y7XYcOHBAsJuVFVt2AOUndHTszA3eNzmxWAyBQACzs7MIh8Po7++H3+8X9IKsYDCIubk5zM7Ocl1K3okxP6/Xi9u3b+POnTtcl5JXbHZsfv39/YhGo6irqwPDMFCpVJDLeX8IWaZYsgMoP6FLd+x0u92CzC8ejyMajcLpdGJsbKyg+fF6TU6qUCgEh8OBn/70p6K+xU6sxJCfQqGAXq+HXq+HQqHgupyC6+vrw1tvvYWrV69ibm4OwWCQ65IyVuzZAZSfUKUeO4Wan0wmg0qlgkqlgkwmK+hnC6MNxMOu1u/3Y3BwEOPj4+jv78emTZtQV1cHo9GI1157jesSyRrWyq+jowNHjx5FdXU1SktLuS51VVKpFEqlEkqlsuADlQ/MZjPu3r2L/v7+5JlkV1cXfvjDH1J2AkD5CVPqsXNsbEyQ+cViMQSDQU7WVAmmyUnFLsi6e/cu6urq4HQ60dPTg/r6ejAMw9uB4Pf7sbCwgKmpKfh8Pq7L4czj+d2/fx+tra3o6uqCwWCARqPh5dka5ffwcsHdu3eT/z0/P48/+7M/43127MLHUChUNAtX0xFqfolEArFYDNFoFPF4nOtyOCPU/AKBAGZmZjAzM4NAIFDQzxbM5ap02LUtV69exU9/+lMMDg7C4XAgFApxXVpaCwsLuHjxIi5evFjQHR/5is3vxo0b+OUvf4mBgQHcu3ePtw0E5bfS7OysILJjFz66XC5EIhGuy+ENoeSXur6omJvUxwklv9RNHJ1OZ0E/W5AzOaxoNAqv1wuv14v+/v7kBlF79+7l5dQdl0HzUWp+165dg1qthlwuR3l5OS8XJVN+K3k8HsFkZ7FYKLvHCCW/1MsdxTyT8zih5OfxeDA6OorR0VG43e6Cfragm5xUs7Oz+NWvfgWv14uGhgY0NDRwXdIKPp8P9+7d43XHzRV2lkQikWDHjh1oaWnhuqQVKL/0hJCdzWbDuXPn0N/fD5vNxnU5vCKE/OLxOMLhMMLhMDU5jxFCflweO0XT5Hg8Hng8HjQ0NPB2C+xwOAyn00lnkmn4/X5MTU1hZGQEo6OjqKurQ2VlJa9m5Ci/9ISQndvtTp5JkuXY/IaHhzE4OAitVsu7582NjIzgZz/7GTWpaQghv5KSElRUVKCiogKRSKSgl4wFvSYnnUgkkmx4otEo1+WQLEUiEbjdbrjdbspPYNgp6ZGREd6eaJDVeTwejIyMYGRkpOCXFJ4ktUmlv1vp0eX09EQzk8MKBAKw2Wyw2Wy862bJk8XjcYRCoaK/C0aIFhYW8PHHH0MqlaKhoQG1tbVcl0SysLi4iOvXr0Oj0aC9vR0Gg4HrkkgW7HY7Lly4gEgkgvb2djQ2NnJdUhL7iB+73V7wG4NE1+Sw3SzDMNBoNNTkCIzH48Ht27fR0NCA6upqlJeXc10SyRC7G219fT28Xi/X5ZAs+Xw+TExMoLGxkXdrznQ6HTo7OzE3NwebzUazOWmw+TU1NfFu/EWjUfh8Pk7+XomuyeFzN0uejPITLrpNW9j4nJ/BYMCRI0dQXl6Oc+fO0doqkjHRrclhu9mJiQnedbPs2UhnuKhRmQAAIABJREFUZyfNMK2C8hMu9jZfPl5qpOyejM/5abXaZH46nY7rckiWysrK0N7ejo6OjuRWL4UiuiaHzzo7O/H666/j9ddfR1dXF9flkCxRfsJF2RHCnS1btuA73/kOTpw4gS1bthT0s6nJIYQQQkjeyGSy5LPHpNLCth3U5BBCCCEkbyQSCeRyOeRyecGbHEkikVj9hxLJ6j8kvJRIJCTsv1N+wsPmR9kJD409YaP8hC01v1Q0k0MIIYQQUaImhxBCCCGiRE0OIYQQQkSJmhxCCCGEiBI1OYQQQggRJWpyCCGEECJK1OQQQgghRJSoySGEEEKIKFGTQwghhBBRoiaHEEIIIaJETQ4hhBBCRImaHEIIIYSIEjU5hBBCCBElanIIIYQQIkrU5BBCCCFElKjJIYQQQogoybkugBBCyJOVlpaisrISDMNAq9VCIpFgbm4OdrsdXq+X6/II4SVqcgghRAAqKyvx1FNPwWg0YsuWLVAoFPjwww9x4cIFanIIWYUkkUis/kOJZPUfEl5KJBIS9t8pP+Fh86PshCffY+/gwYP47ne/C5PJBK1WC6lUivv378Nut+Py5cvo6+uDxWLJ9ccWDTp2CltqfqloJocQQgRAqVSisrISlZWVyV9rampCY2MjvF4vzp8/z2F1hPATLTwmhBABk0gkyX8IIcvlZSZHr9ejubkZDMOsGHxOpxOTk5NwOp35+GiSA2vl53a7YbPZ4HQ6EYlEEI/HOayUPI6yK04Mw8BoNCIajSIUCmFkZITW6XBgtfEXiUTgdDphtVrhdrs5rrK45KXJaW5uxksvvQSj0QiZTAap9NGEkdlsRl9fH8xmcz4+muTAWvmNjIzg/fffh9lshsfjQSgU4rBS8jjKrji1tLTg+PHjeP755zE/P4833ngDd+7c4bqsorPa+PN4PDCbzTh79iw+//xzjqssLnlpctizit7eXsjl8mUHWoZhMDU1BQA0o8NTa+VXW1uLxcVFAMDw8DDsdjtXZZI0KLvixObe2toKm80GrVbLdUlFabXx5/F4wDAM7HY7FAoFffcVUF6aHKlUCoVCgZKSkhU/MxqNMBqNyRmd/v7+nM3qsFODEolk2bQhXSLLzlr5dXV14Yc//CEOHTqU8/wArLq2IJFIYK07AclDlF1xk8vl0Gg0kMtXHtrZL9xM88j29WT18afVavHMM8/gmWeeyct3X6rHx2Gx58fZ3VXs9Gpzc3NOgpZIJJBKpcmA29racOzYMezatQsWiwVvv/02LBZLUYedS7nOjyWRSCCTyVYM0lgslvx3sjFcZEe5cU8mkwFAxnmkvh6gsZcr+Rp/rNRxSOOPwyaHndZzuVyQSqXr6jbVanVyB9Dq6uplTU53dzdMJhN27doFhmEwOTkJhmEAPFwXRLM6G5Pr/KqqqgA8GqCpl1ni8XjyH4Dy26hCZ5d6kKXs8o9tMhmGQUtLS/K4x87uxGIxBAIBuFwuOJ1OzM3NQSqVgmEYNDU1Qa/XL3t9PB6H0+nE9PQ0FhcXk+NQKpWu2tTSovbV5WL8qVQqlJeXg2EY1NbWLvtZ6jhkxx+76Dk1v2LB+T45bCDr6TYrKytx4MABGI1GPPPMM8n3Ax7+RWpubgbwqHM+fPgwAODEiRO08DlHcpXf008/nXy/J13yoPxyg7ITn9QM2OOe0WgEsPzy09zcHIaGhmA2m/Hb3/4WJSUl2LJlC77xjW9g586dK15/8+ZNnD17FlevXk1+ScpkMqjV6mWXxqLRKAKBQNF9ka7HRsZfeXk59u7dC6PRiOeee27F+z7eeKbLr1hw3uQwDIM9e/ZgenoaLpcLwMPrlwaDATqdLvk69vZXj8eT/HlXV9eKJme1z2AHOgCYTCYADxc+ezweKBQK6PV6dHV1pf3/HQ4HnE4nHA4H/H5/Dn7X4vGk/KLRKILBIDweDxwOB5aWlqDVatHS0oLt27dnlN/jamtroVKpEIlEAIDyWyeGYdDd3Y3x8XG43W4oFArI5XLI5XK0t7ejrKwMwKOxx2bX1NSEbdu2rSs7Gnv5JZVKoVKpsHfvXiiVSphMpmXHPpbdbkdFRQUYhkEoFEJJSQmMRiNMJlOyyUlVVVUFu90OpVKJaDQK4OFMj1qthkKhSL4uEokgEAjA4XAkZ36K+VLJWtIdO6VS6arj78GDB8ljZ1dXV7LJYcfUWlLze/DgQXKNqkQiSR4H0hHD+OO8yWlubsbLL7+M999/HyMjI5BIJOjs7MSRI0fQ2dmZfN3o6CjOnTuH0dHR5M93796dnDLPBns9tK+vD6Ojo9Dr9eju7sbrr7+e9vVXrlyBxWLBwMCAYIPOlyfl5/P5YLfbMTo6ioGBAQwODibPMA8ePLiu/PR6PfR6ffLAQPmtT3NzM44dO4ZTp04lx4FWq4VWq8U//MM/oLW1FcCjsXf9+vXk2f7+/ftp7PGQQqGAVqvFK6+8AqlUipaWlrSv0+v12LVrF5qamrB///5ll6vSaWxsxNGjR/H8889ndLnKYrHgzJkzuHbtWnJND1ku3bGzpKRk1fF36dKlZcdO9nJVJlLz++yzz5KPAJFKpWhtbcXJkyfT/n9iGH95eXaVyWTCyZMnM+owgYe319lstuQmSTqdDgaDYdltkKmvSffzbLF3XLFnkwzDLGuqUqV2s9evX8fZs2eTe43wTS6ev5LL/NjNydxu94qZnGy/IFmjo6PJDe0AiDK/QmX3+DhgZ3I6Ojqg0WgAPMp3cXExOZPDrttYDxp72auvr0dvby++/e1vo6enJ5dvnRculwvT09N49913MTY2BqvVmjwpAQC/34+FhQX4fD4Oq1yOD8dOdiYn3fhbWFjY8LETeDT+2DwynckR0vhLxflMDvDw8sZqB7lsXpONxy9hrYV9XkxbWxs0Gg3sdjvkcjkGBwcRCASSX7bFaq1s2C9NjUaD+vr6nHxetn8PKL/VZTIOaOxxj916YyNfboWk1+uxc+dOzM/Po76+fkWT4/P5sLCwgPv37xf19h7ZfPflagwW2/jjRZMjJOy0X3t7O+bm5mCz2QQRNHmI8hOuYs7u8OHD6O3thcFg4LqUrOzcuRMtLS3w+/3LsorFYgiFQvj0009pB3yBEOr4y3mTo1KpUF9fD7Vaneu35gWdToft27dDrVajt7cXNpsNc3NzWFhYSA5kn8+HcDjMdanrwt4xwe6RITbp8mOnXl0uF4aGhhCPxwW5WLIYx55YsnuSrVu35nQ2rVBqampQU1Oz6s/LysqSO+ALvdEpxmMn+93ncrngdrt5Of5y3uSwt7aVl5fn+q15pba2Fq+++ioCgQDu3r2LixcvYmpqCk6nE/fu3RNsk1NSUoLy8vK0O+aKSWp+7NnI8PAwvve97yESiQhysWQxjj2xZFes8r0xXiEV47GT/e4bHh7GzZs3eTn+cr7wuKenB+fPn4der4dSqdxQcUKRuoju8Zkcq9WKgYEBvPvuu3A4HHmvZaOL5/bu3Yt33nkHDQ0NRff8m3SzAVzlR2MvO3zKDsj9wuOPPvoo48WsQnT16lX85V/+JVwuF4LBICc10LEze+x3n8vlgsvlQjwex8zMDD755BNYrVbEYjEMDAwUfPylysvlqrWmJ8WotLQ0ufHg46xWK0pKSrCwsIDx8XHeL7LTarXYunUr12VwQq/Xr9jzJTU/q9WavNvA4/HwbrauGMce60nZCWHsFTP2Dh+LxcJZk7NRxXjsTPfdN/P/2bv32LbO837gX95EUpREUrJEURdLlnxTfJOjXBw3rZUl6dAlQ+FmXZJhRtY/jCLIUCRbV2AFhnQo0KAb1qEYil/RZkudNF2y1vBqxGtaN4vsNLZjRxYl2ZF8kXWlKEqieBXv5Pn94R2atnWh5HP4vufw+QDCskrheaKv3sOH73nPe6amYDKZck1OWVkZ0/FHC49lVlNTg/3792Pjxo345JNPaJGdwuTnd/36dZw9exYulwtXr14tyqcTsn409pSjsbERBw8exPz8PLxeL+tyyD0Qd0PfvXs3BEHA/v37mY4/yZocvV4Pk8mU26WR3FReXo7y8nI0NzfDbDbnFtnRp0plyM+vqakpd719dnaWmhzO5WdnMpkwMjKCdDp91+3MhD3xNun8Xe6JMpnNZjQ1Nd31v7F679Ou/iOFMZlMqK+vR319vVQvqTriIrsXXnhh2Z1ICb/EmQFxp2aiHM3NzXjuuefw/PPPo7m5mXU5hJQUlu99kjU5RqNx1dsFS524CROPm3pRfqsTZwWam5tRXl7Oupwcym51PI89omw0/lbHcvxJ1uRYLBa0tLQsuwCX3FJRUYH29na0t7ezLiXH4XDg8ccfv+uJtuRuvOVH2a1O3HW7rq4O27Zt4yY7cov49GytVrvk0+x5ReOvcCz6BMmaHFI4h8OBJ598El/84hdZl0LWgfJTLsqOXxqNBjqd7q6HfhL1qK2txYEDB3DgwIGiHZPurmJAnLqjhcfKRPkpF2XHr/xsRkZG4Pf7WZdEJJaf8ZtvvlmUY9JMDgNmsxkNDQ1oaGhgXQpZB8pPuSg7frW0tODQoUM4dOgQLXtQKYvFgk2bNmHTpk1FO6ZkTU4ymYTf76fuuwB6vR6VlZVwOp1oa2uDxWJhXRJZA97yo7FXON6yI7dYrVbs3r0bu3fvVtTicBp/hTMYDLDZbGhqaira+JOsyYlEIhgZGcHIyIhUL6l64voAh8PBuhSyDrzkR2Nv7XjJjigfjb+1K+b4k6zJiUajGBsbw9jYmFQvqXp1dXXcnGi9Xi8++OADfPDBB6xLUQyn04mnnnoKTqeTaR009taOp7G3kubmZjz77LMltbePVquFXq+HwWCAVsv/igoaf2tXzM0fJVt4nM1mkc1mc08FJsqSSCQwOzuL2dlZ1qWQNaKxt3bi7cq838VjsVjQ1tZWcjvJK+k2chp/fOO/TVaxRCIBr9eLRCLBuhSyDrFYDG63G7FYjHUpZI0SiQTm5+e5H3vi/j46nY51KYRIRhAEpNNpZLNZ2Y9FTQ5D6XQakUgE6XSadSk58Xgcs7Oz3J/8CbkX4qZzvNNqtYq5bFPq6NxZOEEQitLgANTkkDuEQiFcvnyZHmBYALPZjMbGRpjNZtalkDUSn7VH2RGp0LmTT5I3OTMzM/jd734Hr9cr9UurTlVVFTo6OlBZWcm6lJxYLIbp6WnE43HWpXBPvB3ZYDCwLgUAjb210Ov1qKiogF7P936olZWV6OjooKdzK0A8HsfMzAydOwtUrDVXkjc5wWAQLpeLdhQtAI8n2ng8TutMFIrG3toIggBBEFiXsSKDwYDKykquzhFkafQBkU+SNzl+vx99fX20MVIBBEFAJpPh6kRL+SkXZVc4HsceUTa/34/e3l4afwUq1tiTvMmhKbvCpVIphMNh7hYeU37KRNkVLp1OY3FxEZlMhnUpRCXi8Tg8Hg/NghegmFcxaOExQ+KgoDclQopLKbeQE6JGRqMRDocDRqNR9mNRk8MQj7eQk8Kl02mEw2HaBEyBxOx4H3s8zvYSoiSyNDmJRAI+nw8+nw/JZFKOQxAZUX6FCYVCGBoaQjgcZl1KDmVXmGw2i2QyWbS9OtbL4/HgxIkT8Hg8rEshBRB3Pk6lUtz/bbG0uLiIkZERLC4uyn4sWZqccDiMK1eu4MqVK1y9AZDCUH7KRdmpi9frxcmTJ2lbAIUQ13rRei9+yNLkJJNJzM/P0zVvhaL8lIuyU5fFxUXcuHEDIyMj8Hq9tH6PczT++ENrcgghhHP9/f3o7++n3XQ5F41GMTU1hampKbrLihO0wxQhhHCuv78fVVVVcDgcsNls9DwrTqXTaYRCIYRCIbohgRPU5BBCCOf6+vpgNBpx3333wel0wmq1FuX2W0KUjpocQgjhnMfjwe9//3sMDQ2hu7sbhw8fxv3338+6LEK4J8t8p9zXJROJBGZnZxX/WPtkMomFhQXubvWl68rKRdmpVzgcxvDwMM6dO4fTp0/D5XKxLkkW4hPinU4nTCYT63LWhMYff2Rpcnw+H86ePYuzZ8/C5/NJ/vrBYBCDg4MYHBxU9EK8SCSC69evc3err9z5EflQduo3NjaGI0eO4MiRI6xLkYXdbsfevXuxd+9e2O121uWsCY0//shyuSoWi+W62Wg0KschVCESiRRtQ6S1oPwKI97eG4lEWJeSQ9kVhsfsChUIBOByuVBWVobJyUnU1NSgvLycdVmSsVqt2LNnD/x+P65evQq32826pILR+CtMMcefIpfnW61W7Nq1C7t27YLVamVdzrotLi5ibGyMuyaHFIY2alMuNWTn8/lw5swZ1c0YWK1W7NixAzt27EBVVRXrcogMijn+ZF14HA6Hce3aNTQ2NsLpdKKiokKS1zUajairq5PktVhIp9OIxWJYWFhAIBBgXc6y5MpPLSKRCG7cuMG6jCVRdivjObtCBQIBnDlzBhaLBYIgYMOGDaqY0RHP73V1dYpbkyOi8beyYo4/WWdyhoeH8dprr+G73/0uent7aZvr/xOLxTA9PY3p6WnWpayI8lMuyk79fD4f3nrrLfzjP/4j/u3f/g3Xr19nXZIkgsEgBgYGMDAwwPWHwJXQ+OOHrE2OeBfU1NQU3G63ou+EkpLZbEZDQwMaGhpYl7Iiyk+5KLvSID7ocGRkRJHri5YyPj6Ot956C2+99RbGx8dZl7MuNP74IWuTIz6szO12o7e3V7FdudT0ej0qKytRWVnJupQV3ZnfzMwM4vE4fSpRABp7pSGZTMLv92N0dBQXLlxAf3+/4rMWF1Yr+TEWNP74UZSFxx6PB++99x48Hk8xDkckJub32Wefwe/303blCkJjrzSIsx9vvvmmYmc/RIIgIJPJIJPJQBAE1uXcExp/7BVlx+NwOIxwOIyPPvoIGo0GTU1NsNls0Ov1Jf38lfLycjQ3N8Pn83F9u6GY3x/+8AdoNBrs3LkTTqeT8lNAfjT2llZRUYG2tjZ4vV5V3N0ozn5otVps3boVbW1t3M8UL0cQBAiCgGw2y7qUe0bjb2nFHH+alTpljUYjeRvd0dGBZ555Bt3d3di1a5fkd0mJnwIAQKfTQaPRSPr6UvJ6vfjhD3+IY8eOYXh4WJLXFAQh9x8sZ34HDhxAR0cHHA4H9PrSfDqInPkpcewpycLCAl5//XW8/fbbGBgYkOQ15R57hTCZTLBarfjBD36Affv2weFwwGKxsChlzQKBAMbGxtDT04MjR44UfUfnYp07afzJP/7yFf3dye124+jRo/D5fLDb7ZIHnclkcttpm81mrt+AdTodLBYL1zXeSczP6/XiL//yL2G1Wkv29kil5Sf32CPspVIpBINB/OY3v0EkEsETTzyBtrY21mUVRNzJuaenB2NjY6zLkRyNPzaKfnYWH0NvNBqxdetWaLVa7Nmzh+sZF7lotVoYDAZFTVuK+el0OmzcuBEajQaPPvoo5acANPbUT1zLcvHiRWi1WtTU1ECj0aCuro77GR3xkptan8lF448NZmdnsWt/4403JF1gptPpYDabYTabodPpJHlNcrfJyUm8++67eOedd1SxQLCUyDX2CD+mpqZw8eJFvPfee/jggw8wOzvLuiTyf2j8FRezeXaxa89ms3C5XGhvb5fkYWwajUYxlw+U/PycYDCIYDAIrVYraX5EfnKNPcKPUCiEiYkJCIIAi8WC+++/H5s2bWJd1rLEJ6yHQiHWpciOxl9xMZ9nF299VPptj+uhhufnlHJ+SkfZqVssFsPk5CQmJiYQiUS4njFwu904duyYoh7Gea9o/BWJeLveUl8AhGJ82Ww2obOzU3j55ZeFvr4+oVR8+OGHkv8uBcqvaC5cuCC0tbUJFotF8vwoO3nJmZ1QxPwKzXjPnj3C2bNnhVgsJqTTaba//CWcPn1aMBqNglarZfZ7EujcWTRyj7/8Ly6u64jTdwDQ0tICAGhtbYXNZmNZFilQqeanloc8UnbqFggEEAgEcOnSJWzYsAH19fXc3RGZyWRK8tEHNP7kx/xyVT5xQdaRI0dUeQuh2lF+ykXZqd+nn36KTz/9FH6/n3Up5A40/uTDxUyOKH/Xzi1btqCtrQ1VVVWsyyIFovyUi7JTv4mJCUxMTGDv3r2sS8mJRCLweDy4du0a61KYovEnH65mckRTU1P41a9+hampKdalkHWg/JSLslOveDzO3QN2PR4PTpw4gRMnTrAuhQs0/qTH1UyOSOxqe3p6kEwmVXeNUty+XK2bXlF+yiVmd+7cOWi1WjQ2Nir2GUhLUXN2q/H5fJifn+di7cvi4iK8Xi/6+/vR19dX8jM5Ihp/MlhuRbLAyR0CXV1dwo9//GNheHhYCIVCLBaCS+7TTz8VDh8+LGzZskUVdwiUWn4XL14U/vqv/1rYuXOnbPmxzs3hcAhf+tKXhJ/97Geqyu7MmTPCM888I2zYsEH1Y2+pr+7ubuHDDz9kmoEgCEJ/f7/wrW99S3jssceE+++/X2htbWX+uxE4yk+t4++jjz4Snn76aaGyslLW/PK/uLxclW96ehrHjx/H8ePHMT09zbocSTidTjz11FN46qmnWJciOzXm19zcjOeeew7PP/8861JkEwwGMTQ0hKNHj6oqu8rKSmzfvh3btm1jXQoBkEgkMDc3h7m5OdalcEWt489sNqOhoQFOp7Nox+TyclU+cfpOr9ejvr4eDQ0Nqpq+Uzs15ScIArLZbElsxR6Px+H1epFMJqHRaBSfHeFTOp3G4uIiFhcXWZfCFRp/0uG+yUkmk/D7/bh8+TK0Wi0efvhhxQctLrbr6elhXYrs1JRfNptFMpnEyMgIfvGLX+Cjjz5iXZKs1JSdSHx8wJUrV1iXQsiK1Dj+YrEYpqen4fF4inZM7pucTCaDWCwGj8eDZDKJnp4eRKNRRS9mDYfDuHbtWkkstlNTfoIgIJ1Ow+fzYWBgAJcuXWJdkqzUlJ0okUjkFuASwjM1jr90Oo1IJIJwOFy0Y3K/Jkcknpx+8pOf0IZJCqSG/MTLVdlslnUpRaWG7AhRKhp/94b7mRxRJpNBNBpFb28vRkZG0NPTg6amJtTX16OzsxMvvfQS6xJXlU6nkUgkEI1GkU6nWZdTVCvlt2XLFjz77LOora1FeXk561KXlb9+oJTyU8vYi8fjiEQiJZXdnaanp/Hee+8hEomgq6urqAtAyfqoYfyxpJgmJ5+4mPX69euor69HIBDAQw89hNraWthsNlgsFhgMBtZl3kVcTDYzM4N4PM66HGbuzG96ehptbW3o6OhAY2Mjt/mJl6vS6bTqFx4vZ6mx19nZCZPJBJvNBofDwd1zkYCb66kSiQQSiQRXm+EV2+LiIm7cuIGNGzfSHWYKpNTxx5IimxxRPB7HzMwMzp07hx/96Ec4cOAAOjs7sWnTJi6vWYqLHoeGhop6TZJXYn6Li4uwWCx48skn8cADD3CbH7klf+x9//vfh9PpRGdnJ774xS9yeZIVHwCZSCRK7nJjvmQyCZ/PB5/Ph2Qyybocsk5KG38sKbrJERcxRSIR9PT05D5d2+12Lt8k82cCSvlEK8rP7/z58zCbzdDr9dzmR27Jzy4YDOYuezz00EOMK1sazcLdFI/HMTs7i9nZWS52Pibro7Txl81mkUqlmMykKrrJyTc3N4dTp05Bo9Fg586daG1tZV3SXSwWCzZt2oTx8XFYLBbW5XBFCfmRpYl3gExPTyMWi7Euh6wgFovB7XbD7XZTViqhhPGXSqUQDAYRDAaRSqWKemzVNDnRaBTj4+MYHBxEb28vKisruXvux8jICH7605+ip6cHbrebdTlcUUJ+w8PDlN8S0uk0wuEwpqencenSJWzYsIG77MhNYlbhcLjobzZEHkoYf5lMJveA2GJfxVBNkyMSF2aJC5B5CjoUCmF4eBjDw8OsS+EWz/mJ+1awGKhKwHN2hKgdjb+lqa7J8Xq9OHnyJFKpFDZv3ozm5mbWJZE14Dm/2tpaHDhwAABw6tQp2or+DjxnR4ja0fhbmmI2AyyUeIvkjRs3EIlEWJdD1ojn/CorK9HR0YHt27fTp6Ql8JwdIWrH8/gTH4mTTCaLPguuuiaHELmUlZXBbrfDbrejrKyMdTmEEKII4rqhSCRS9LVg1OQUUUVFBTZv3owtW7bQXgYKpNPpYDabYTabodPpWJdDCCFkFdTkFNHWrVvxN3/zN3jllVewdetW1uUQQggTFRUVaGtrQ1tbG22nUQLKyspQU1OD6upqGI3Goh5bdQuPeabT6WA0GmE0GqHVUn9JCClNDocDTz75JAwGA65fv47JyUnWJRGVoianiDQaDfR6PfR6PTU5hJCSZbFY0NbWhomJCbp0T2SlWWmLc41GU7r7nyuUIAga8Z8pP+UR86PslIfGnrJRfsqWn18+mk4ghBBCiCpRk0MIIYQQVaImhxBCCCGqRE0OIYQQQlSJmhxCCCGEqBI1OYQQQghRJWpyCCGEEKJK1OQQQgghRJWoySGEEEKIKlGTQwghhBBVoiaHEEIIIapETQ4hhBBCVImaHEIIIYSoEjU5hBBCCFElanIIIYQQokrU5BBCCCFElajJIYQQQogqUZNDCCGEEFWiJocQQgghqkRNDiGEEEJUiZocQgghhKgSNTmEEEIIUSW9HC9qNptRU1MDm82GyspKGI3G3PcCgQDGxsYQCATkODSRAOWnXJSdslF+yrZcfqlUCoFAAJOTkwiFQoyrLC2yNDk1NTV45JFH0NnZiW3btqGmpib3PZfLhSNHjsDlcslxaCIByk+5KDtlo/yUbbn8wuEwXC4X3n33XVy+fJlxlaVFlibHZrOhs7MT3d3ddw1Um82G8fFxAKBPJZxaLb/R0VEIgoDx8XHKjzM09pSNxp6yLZdfOByGzWaD1+uFwWCg8VdMgiAs+wVAWM9Xd3e38OGHHwor6evrE15++WWhs7NzXcdY7Uuj0QharTb3pdFoZDkOb19y55fNZoWQHBzFAAAgAElEQVRUKiVcuHBB+MY3viF5fnfmVqr5yZFdscaemCPr3yWr7JQ69u7Mr1THnhrGXyl+Ccv0MbLM5BSitbUVL7zwAlpaWmSZftVoNNDpdNBoNBAEAZlMRvzjJfdA/L22t7fja1/7GjZt2iRpfvm5iSg/aRVj7Gm1WmSzWcpMQnKPvfzjaLVa6HQ6GnsykHv8kdsxa3LEab1gMAitVpvfQRcsf5HXhg0bbvueeEIQT7aZTCa38GthYQHZbFbK/5ySotFoYLfbYbfb7yk/k8kEu90Om80Gh8ORe20xN5GYn/j6LpeLpnrvgRRjb6nsRCs1OZTdvZFq7Gk0Gmg0GthsNuzevfuu72m12txr07lTWlKMv5XyW4p4jIGBgZIbf8yaHJH4praeTws1NTV4+OGH0dnZiUcfffSu171zNuDSpUt49913ce7cORqoErmX/Ox2O7q6utDZ2YnHH38893r5uYnyTwSvvPIKfQKSgNTZ5b+u6M7Xpeykcy/5aTQaGAwGbNmyBa+++upd38v/v3TulIdc+S1FbFa/+c1vUpNTbDabDXv27MHIyAhCoRAMBgP0ej30ej02b96MiooKAEAwGMTExAQWFhZgtVrR2tqKHTt25Jqcz3/+86sea8OGDfB6vTAajZifn8fY2BjC4TAMBgOsVis6OjqW/PeGhoYQDAaRSqWQyWQk/e9XuqXys1qtaGxsRFVVVe7nQqEQ3G435ufnUVlZidbWVnR0dOTeKLu7uws+pviz4uI98RPNnj17lvx5ym9pS2UnzqBt374d5eXliMfjCIfD8Pl88Pv995ydw+GAyWTKZaHRaFBWVgan04na2lpYLJbbfp6yW15+fn6/HwBgMBhgNpuxdevW3LlzqbFXXV0Ng8FQcH5LnTtp7N2bpfLT6XQwGAy47777cudPKfITm5wDBw5Ao9HctvDZYDCgsbFRteOPeZPT0tKCQ4cO4Y033sDw8DCsVisqKytRWVmJF198EW1tbQCAwcFB/OIXv8CFCxdy1zQfeeSR3OWqQjQ3N+PZZ5/FE088gYsXL+LIkSO5Y+7Zswd///d/v+S/99prr6G/vx/BYFCxQctlqfz27NmDgwcPYvv27bmfGx4exrFjx3D69Onb8hMveayFeD37yJEj6O/vh1arRVtb27KfaCi/pS2Vnbivx+HDh9Hc3Ayv14vh4WGcOXMGvb2995yd1WqF1WpFMBhENpuFVqtFZWUlHnvsMRw4cAAtLS23/Txlt7z8/MQ3SbPZjMbGxtvOnUuNvb1790Kr1d7TuZPG3r1ZKj/xQ+Lhw4dz508p8hNnjcS1XPlbEVgsFlWPP81K02T/t6p+zbq7u/Hqq68W/AlP3ORKnFURZ3K2bNmS6yyXmslZ6wl2pWPabLbb3pTzDQ8PIxAIIJVKYWBgAO+++y5cLhfC4fC6jy8XQRBy1wpY5Wez2dDY2IjKysrcz4TDYbjdbszNzeU+jUiRXzAYBIAVP00qMT9W2YkzOR0dHTCbzUgkEgiFQnfN5Kw3u/wsxMseZWVlaGhoQG1tLcrLy5f9eaVkBxQ/v/xP5WazGdu2bcudO2nsFYaH/MSZnB07duTOn3LlJx6zrKwsN5OjlvGXj/lMDnBrIdZKrFYrdu3aVdRjivKbn+rqani9Xuj1evT29iIWiyGVSklWlxIV8rusrKzE9u3bl20k5TimaKn8AOCjjz6SpBYlW+33qNfrYbFY4HQ6JTneWvOnsbcyGnvKpsT8NBoNzp49i0wmo4j1WVw0OUoiTttu3rwZMzMzcLvdJX+iVRIxP4fDQSdahaGxp2w09pRNzK+xsREulwuxWKw0mxyTyQSn0wmz2Sz1S3OhqqoKO3bsgNlsxoEDB+B2uzEzM4O5uTkEg0GEQiFF7w+i0+lgNpuh0+lYlyILMb9UKoV9+/YhGAwiGo0imUwiHo8rOr9SyY7GnjLljz3xcs7i4qJq8lM7MT8A2LdvH2ZmZhAMBpFMJpHJZJBKpbC4uIhkMsm40ttJ3uSIt5ba7XapX5orDocDhw8fRiwWw/Xr13Hq1CkMDg7i0qVLil6JXlZWBrvdjrKyMtalyKq1tRWvvPIKBgcHMTY2Br/fD6/Xq+j8SiU7GnvK1tramluoPD4+rpr8SkVzczO+/vWvw+VyYXR0FH6/H7FYDIFAAKOjo9w1OZIvPN63bx9+/etf33anhtpFo9HcpxHxrpGpqSl88sknmJycRCaTwZkzZ+Dz+WSv5V4Xz3V1deHtt99GQ0PDbQuH1SiRSCAYDOY+fYj/f35+LpcLQ0NDmJ+fL0pN97LweMuWLfjnf/5nPPjgg2hoaJC+OA4tNfbEc9rk5CTOnDmDX/7yl4oYe5QfH2MPWF9+TqcTf/u3f4s//dM/xdatW6UtjjN3njvzZ3JGR0eZ55dPlstVdXV1Ur8s18rLy++69W5qagomkynX5JSVlWFkZIT7B7NVVlZi27ZtrMsoCqPRuOzfqpifuKPv/Pz8XXcl8EbMTu3Nab6lxp5ocnISZWVlmJubU9TYK/X87hx7AwMDuSYoHo8zqnR14oLee7nzSSlWOndu3LiRq3MnLTyWibgb8+7duyEIAvbv349PPvnktv0JCL/E/LZv345QKIREIgGXy8V1fuIeKWpdD7dWNTU12L9/PzZu3KiIsUf53XTn2Dt69Cj6+/sxODjIdZMj3gFstVpZl8IUb+dOanJkYjab0dTUdNf/Nj4+DgDcf6osdWJ++RlarVaMjIwgnU5jcnIyt08ILwwGQ0nNAqymvLwc5eXlaG5uVsTYo/xuunPs+Xw+2Gw2VFdX4+rVq9zmV4pXMZbC27lTu/qPEKmIu1W+8MILaG1tZV0OWaPm5mY899xzeP7559Hc3My6HLIGNPaUq6urC8888wxeeeUVyk+hWJ47JWtyxGt01MkuT7xmy+N1W8pvdbzmR9mtjtfsAMpvNU6nEx0dHdi3bx+X+en1+tyjiMjSWI4/yZoch8OBxx9//K4nEpO75QfOC8pvdeLuvw0NDXjggQe4yY+yKxyNPWWrqKhAe3s72tvbWZeSY7fbsXfvXuzdu5d1Kdxiee6kNTkMiFPnLS0tXC+EJEuj/JSLslM2h8OBJ598EmVlZfh//+//sS4HwM39jaqrq1FdXc26FO6xGH/U5DAgfprkcfEcWR3lp1yUnbKJ+SUSCfz3f/83/H4/8zuuxJ2qS/2uuEKwGH+08JgQQogimM1mNDQ04L777sPevXtVv7M+uXeSNTnJZBJ+vx9+v1+ql1S9iooKtLW1wWKxsC4F8Xgcs7OzmJ2dZV2KYvCSH2WnbJRf4cRFvvX19Whvb2c+9gDKbz2KuSeUZE1OJBLByMgIRkZGpHpJ1ROvLzscDtalIBgMYnBwEIODg6xLUQxe8qPslI3yWzuj0YiamhouHh1E+a1ddXU1HnzwwaKsY5KsyYlGoxgbG8PY2JhUL6l6dXV1XLxJAjefRUKfRtbG6XTiqaeegtPpZFoHZbd2nZ2d+Nd//Vcu7rKi/NauqqoKO3fuRFVVFetSKL912LhxI/7iL/4CGzdulP1YkjU52WwWqVQKqVRKqpdUPXGHU4PBwLoUQkpKKT1nSI00Gk3uiyiPuFhbp9PJfixaeMyQRqOBXq+ngapQsVgMbrcbsViMdSmElJREIoH5+XkkEgnWpZB1iMfjmJmZKcq5k5ochjKZDBYXF5FOp1mXkiMuoqOTh/JQdspG+RVOo9FAq+Xr7Yvy4xNffyUlhseZgFAohMuXL3P38Eke8fbUaMpO2Si/wplMJtTX13Mz9gDKby2KmZ/kTc7MzAx+97vfwev1Sv3SqsPbmyRwaxqR9QZbSiDezsrLmqpYLIbp6WnKTqEov8Lp9XpUVFRAr+dnP9vR0VG8/vrrGB0dZV0K94qZn+RNTjAYhMvloh1FC8DbmyRAJ1oli8fj3M0MksJRfsomnjspP75I3uT4/X709fXRpoAK5ff70dvbS/kpEI09ZaP8CJGe5E0OXe4oXDqdRjgc5uq2+3g8Do/HQ59GFIjGnrJRfoRIjxYeM8TjwmNCCCFELajJYSiVSiEUCnF1CzkpHI8zcaQwlJ2yUX6kULI0OYlEAj6fDz6fD8lkUo5DEBlRfoUJhUIYGhpCOBxmXUoOZVcYHrMDKL9CUX7KVswmVZYmJxwO48qVK7hy5Qp3f4RkdZSfclF2ykb5KRvlV5hiLtWQpclJJpOYn5+nbbcVivJTLspO2Sg/ZaP8ClPMpRq0JocQQgghqkRNDiGEEEJUiZocQgghhKgSPw/+INwIhUIYHh5GfX09tm3bxrocsgaUnbJRfso2OTmJX/7yl5ibm0N9fT0aGhpYl1TyZJnJiUajmJqawtTUFG10p0CxWCyXXzQaZV0OWYNSzi4ej8Pr9cLr9Sp21+BSzk8NKD/+yNLk+Hw+nD17FmfPnoXP55PjEERG0WgUExMTmJiYoIGqMKWcXTAYxMDAAAYGBhAMBlmXsy6lnB8hcpClyaFutjCJRILLWw1TqRSCwSCCwSDtKLoCHvOj7AqzuLiIGzduIBKJsC7lNpRfYXjNjxSmmPnRmhyGwuEwhoaGEAqFWJdC1oHy44vVasXu3btz/7wSr9eLkydPwuv1FqM0IjHKT9mKmZ+sTU44HMa1a9fQ2NgIp9OJiooKOQ+nOJFIBDdu3MDi4iLrUpZE+a2M5/xKMTuTyQSTyVTQz4rZ8aoU81sLyk/ZipmfrLeQDw8P47XXXsN3v/td9Pb2IpPJyHk4xQmFQvjss8+4nQmg/FbGc36UnbKJ+X3ve9/D0NAQ63LIGtH444esTU4ikcDs7Cympqbgdru5WrtAVkf5KRdlp2xifnNzc5SdAtH444esTU46ncbi4iLcbjd6e3sRCATkPByRGOWnXJSdsuXn9+mnn1J+CkPjjx9F2fHY4/Hgvffeg8fjKcbhiMQoP+Wi7JRtbGwMR44cwdjYGOtSyDrQ+GOvKHdXhcNhhMNhfPTRR9BoNGhqaoLNZoNer4dWK22flc1mc7deGgwGyV9fShUVFWhra4PX6+Vy8aqomPkpiRLyK0Z20WgUc3NzAIDa2lqUl5dL8rpyKi8vR3NzM3w+H9fbXAQCAbhcLvT09CCbzdLY+z9KyY/OnUsr5rlTIwjC8t/UaJb/5jp1dHTgmWeeQXd3N3bt2oW6ujpJXz+RSOQ2ArNarTAajZK+vpQWFhbw+uuv4+2338bAwIAkrykIgkb8ZyXmpyRy5qek7MbHx3Hq1CkAwIEDB9DS0iLJ68rJ6/Xihz/8IY4dO4bh4WFJXpPGXvFQfsom93tfvqLvk+N2u3H06FH4fD7Y7XbJgzYYDLk9MgwGg6SvTeTPj8hHruxqa2tx4MCB3D8rgU6ng8VigV6vnK3CaOzdQvmRQhX9LyQUCiEUCsFoNGLr1q3QarXYs2cPNJolm7A102q1udmblWapyPrInR+Rj1zZlZeXK2L2Jp9Wq+X+cvadaOzdQvmRQjH7CxEX1L3xxhvIZDKSNySCICCbzVKjIxO58yPyoeyUjfJTNsqvuJjN9YkL6rLZLFwuF9rb22G321mVQ9aI8lMuyk7ZKD9lo/yKi/lc3/j4ON566y2Mj49L+roajQZarZamAmUmV35EfpSdslF+ykb5FYkgCMt+ARCK8WWz2YTOzk7h5ZdfFvr6+oRSceHCBaGtrU2wWCyS/S4Fyq9o5MyPspPX7Oys8J3vfEe47777aOwpEJ07lU3u/PK/uFiaLk7fAcgtYGxtbYXNZmNZlux4f8hcoSg/5Srl7EZGRrjd36hQpZyf0sceQPkVA/PLVfnEBVm0w6cyUX7KVWrZzc3N4fTp07lNDJWu1PJTG8pPPlzM5Iju7GpLoaNVEzE/rVaLLVu2oK2tDVVVVazLIgUoteyi0aiq1kKUWn5qUyr5RSIReDweXLt2rWjH5GomR0TPa1G2qakp/OpXv8LU1BTrUsgaUXbKRvkpm9rz83g8OHHiBE6cOFG0Y3I1kyMSu9pz587BZDKhsbERlZWVrMuSTCAQwNjYWG7WSm3y89NqtarLLxwOw+12S7adPE/Unh2NPWXLZDJIJBJcP6/qXqg9v3Q6jWg0WtT8iv7sqrVwOBy4//778eyzz2Lfvn1oaGhQReB9fX34j//4D/T09ODSpUuSvrYg8/NX1kKt+X322Wc4evQoTp06hQ8++EDS1xZkfHbVWqg1Oxp7yjY7O4vBwUGcOnUK3/3udyV9bcpPfnNzc/jss8/Q09OD73znO5K+trDMs6u4vFwlCgaDGBoawtGjR3H8+HFMT0+zLkkSzc3NeO655/D888+zLkVWas3P6XTiT/7kT/ClL32JdSmyUWt2NPaUze/3o6+vD319faxLkZVa8wuFQhgaGsLQ0FDRjsnl5SpRPB6H1+tFMpmERqNBfX29Kjpak8kEh8Oh+ge0qTW/TCaDeDyORCLBuhTZqDU7GnvKzi+VSiEYDCIQCLAuRVZqzS8SieDq1atFXXjMdZMDAMlkEn6/H5cvX4ZWq8XDDz+s+KCDwSAGBwclny7nkRrzm5ycxDvvvIOenh7WpchKjdnR2FN2fkajETU1NaipqWFdiuzUmN/i4iJGR0cxOjpatGNy3+RkMhnEYjF4PB4kk0mcP38eGo0GTqcTFRUVrMtbE0EQkMlksLCwgMHBQQwODrIuSXZ35tfT04NoNKrI7QHuzE/tb5Rqyi6bzSKVSmF2dhb9/f009hSWnyiVSiEcDiMcDrMuRXZqeu8TJZNJBAIB+P3+oh2T6zU5+RKJBHw+H44dO4YTJ07A4/GwLmnNxDsDxBOt2t8k84n5/eQnP1Hs9gBifolEAplMhnU5RaOG7MTLHBMTE+jr66Oxp1DBYBCXLl0qyfyU/N7HEvczOaJMJoNoNIr3338f586dw89//nM4nU7U19ejs7MTL730EusSVyWeaL1eL9xuN2ZnZ1mXVDRifr29vRgZGUFPTw+amppQX1+PLVu24Nlnn0VtbS3Ky8tZl7osQRCQSqWQSqWw0l2JarNSdkoZewaDAVarFSaTCX6/n8aewvITiR8SSzE/Jb/3saSYJkck3mM/PT2NiooK1NfXIxAIYN++fXA6nbDZbDAajdDpdKxLXZJw6wFwJUvcC+L69euor6/H9PQ02tra0NHRgcbGRlgsFhgMBtZl3kWj0UCv10On05Xs0+3vzC4QCOChhx5CbW0tbDYbt9mRmyg/5VruvU8J+QmCgGw2i0wmU/T3P8VcrlpKPB7HzMwMzp07h5/85Cfo7e2Fz+fj9q4XrVaLsrIylJWVQatV9K9eEmJ+fX19+K//+i+cOXMGo6Oj3D40UafTwWQywWQylXx++WPvRz/6ET788EOusxNnUYPBIFKpFOtymFNafuR2Sssvm80imUwimUwim80W9diKm8nJl06nEYlEEIlE0NPTk1uM1dXVxfVlD3JTfn7nz5+H2WyGRqOByWSC0WhEWVkZVzNy4sJjFp9GeHPn2BN/H3a7nctFreJt//F4vOgnWR4pLT9x4XiprYdbjhLzY7WeUdFNTj6Px4P33nsPkUgEDQ0NaGhoYF3SXVh2s7ybm5vDqVOnEI/HsWHDBlitVtjtdpjNZtal5dBswNLE7DQaDXbu3InW1lbWJZE1UEJ+NPaWp4T8xDvFYrEYNTnrJd5WWFFRgb1798JisXD33I+JiQkcP34cp06dwsTEBOtyuCI+FToej2NhYQGXL1/GV77yFXR0dLAuLYdmA5YmZnfy5EksLCygu7sbTz/9NLZu3cq6NFIAJeRHY295SshP3B9nbGys6JfUVNPkiMSFdeIiLJ6anHA4jOHhYQwNDSEUCrEuh0vhcBhXrlyB0+ksib0w1CR/7D366KOsyyFrxHN+4rlzeHiYzp3L4Dk/llTX5Hi9Xpw8eRKpVAqbN29Gc3Mz65JyxK26vV4vt4ujWRP3hJifn6ffkcJQdsrGc35utxvHjh1DT08P3G4363K4xHN+ZWVlqKmpQXV1NYxGY1GPrbpbRBYXF3Hjxg3cuHEDkUiEdTm3KS8vR3NzM5qbm7laa8ITcU8IFtduyb3hOTtaD7c6nvMjq+M5P51OB7PZDLPZXPSbSVTX5PCssbERBw8exMGDB9HY2Mi6HEJKRjqdRjgcRiQSoYWrCkTnTrJeqrtcxbPKykps374dMzMzqKqqYl0OIYQoAp07yXrRTA4hRPVMJhMaGhrgdDrpUrECabVaGI1GGI3Gkt+Ik6wN/bUQQlRPfHaV1Wrlctt7sjLKj6wXXa4ihKieTqfLzQbQTIDyUH5kvTQrbU+v0WhKe+96BRIEIffkSMpPecT8KDvlobGnbJSfsuXnl49aYkIIIYSoEjU5hBBCCFElanIIIYQQokrU5BBCCCFElajJIYQQQogqUZNDCCGEEFWiJocQQgghqkRNDiGEEEJUiZocQgghhKgSNTmEEEIIUSVqcgghhBCiStTkEEIIIUSVqMkhhBBCiCpRk0MIIYQQVaImhxBCCCGqRE0OIYQQQlSJmhxCCCGEqJKedQGEEEKI2pWXl6OmpgYVFRXQ6XSIxWK4ceMGBEFgXZqqUZNDCCGEyKympgb79+9He3s7ysvLMTU1hZ/+9KfIZrPU6MiImhxCCCFEZk1NTfjqV7+KRx99NDeT89xzzyGbzcLlcuHIkSPo7+9nXabqUJNDCCGEyMxoNKKmpgYOhyP3vzU3N+dmcX7961+zKk3VaOExIYQQwohGo8l9EenJMpNjNptRU1MDm82GyspKGI3G3PcCgQDGxsYQCATkODSRwHL5pVIpBAIBTE5OIhQKMa6SLMVsNsNut8Nms6Gqqgomkyn3PRp7/FsuPxp76maz2dDZ2Yl0Oo1EIoGhoSFEIhHWZamCLE1OTU0NHnnkEXR2dmLbtm2oqanJfU+89uhyueQ4NJHAcvmFw2G4XC68++67uHz5MuMqyVLsdju6urrQ2dmJnTt3oq6uLvc9Gnv8Wy4/Gnvq1traihdeeAFPPPEEZmdn8dprr+HatWusy1IFWZocsSvt7u6+q8mx2WwYHx8HAPpUyanl8guHw7DZbPB6vTAYDJQfh6xWay67O5scm82G0dFRCIKA8fFxyo5Dy+UXDoeh1Wpx6tQpjIyMIJVKIZPJMK6WSEU857a1tcHtdqOyspJ1SeohCMKyXwCE9Xx1d3cLH374obCSvr4+4eWXXxY6OzvXdQz6WvqL8lP2l5zZZbNZIZVKCRcuXBC+8Y1vUHYyZSdXfkNDQ8L3vvc94c///M+FP/7jP6b8OMxvpa/Pf/7zwvvvvy/E43Ehk8ksmfHi4qIwPj4uPPTQQ8x/H0r7EpbpY5jdXSVOz7W0tND0uQJRfsqj0Wig0+nQ3t6Or33ta9i0aRNlpyCNjY04ePAgHnvsMaRSKfT29lJ+CpJKpRAMBhEMBmG1Wm9bq0rkw6zJEafnQqEQysrKkE6nkc1m1/Qa4op0m82G3bt3F/zvuVwumqq/R2J+wWAQWq02/xNQwdaaXzAYxOTkJBYWFtb8t0Ju0mg0sNvtsNvtlJ3CVFZWYvv27bn/P5vNFj0/n89HG9fJSKfTwWQyoaysDGazGWazGVarFRs2bIDFYsn9XDweRzAYRCAQwMzMDLRaLWw2GzZu3Air1brs6+e/92m1Wuh0utvu6hIEAZlMRlVjlPk+OXq9HhaLBYuLi0gmk2v6dzUaDQwGA7Zs2YJXX3214H/vlVdeoU9AEhFnBzKZzLpOtGvJ7/Lly3j33Xdx7tw5VQ1CVig7ZWOR39mzZ5FOp9dbckkzGAywWq2wWq0wGAwr/kxFRQWqq6vR2NiInTt34gtf+AJaWlpyP+f1ejEwMACXy4Xf/va3KCsrw9atW/H8889j165dy9aQ/96n0+lgNpuh199qA9LpNGKxmKrGKPMmR5wRuHz5MmZnZwHc/OUbDAbcd999qKqqAgCEQiG43W7Mz8+jrKwMdrsdNTU1qKmpwcMPP4zu7u6Cjyn+bP7CWYPBgMbGRtTW1t7WMQPApUuXEAgE1nUyUTubzYY9e/ZgZGQEfr8fwK38tFpt7nkt2WwWs7OzCIVC0Gq1MBgMqK6uRmtrKz7/+c8XlF9tbS28Xi+MRiPm5+dvy0+n02HDhg1obGzM/c2IKL+lLZUdcPMN0Gg0oqKiIrfo3Ofz5X7mXrIbGxvD/Pw8kslkbuEsjb31WS0/rfbmNmjZbDa3UFm8RX2t504xv9HRUczPz9+28Hmp/MTztd/vRzabpfxw8xxlNBpXvEyl1WphNBpx//33o6amBg0NDdi1a9eSTU51dTVsNhsSiQTKyspyC9ZXanK6u7ths9kA3JxgMJvNtzVcqVQKsVjsrvOrkjFvcpqamvBnf/ZnCAaDuSZH7GYPHz6cm54dHh7GsWPHcPr0adjtdjz44IPYu3cvdu7cia1bt67pmOJakvzbaS0WCx577DEcOHDgtj8mAPiHf/gHuFwuxONx+hRzh5aWFhw6dAhvvPHGbW+C4jXn5uZm7N+/H6lUCr///e8xNDSU+/6uXbvwla98BY888khBx2pubsazzz6LJ554AhcvXrwtP4PBgD179uDgwYO3TekDlN9ylspOo9Hkpr7b29uxf/9+AMCZM2fQ29sLAPeU3cWLF9HX1we/349YLAaAxt56rZZfWVkZACCRSCAYDCKTyaz73Cnmd+HCBfT19eVeD1g6P/F83dvbi0QiQfmt0fPPP4/FxcXc5ara2trbvm+1WrF7925s3LgRDz300G2Xq1bywgsv4Mtf/jKAlS9X3Xl+VTLNSt21RqNZV+vd3d2NV199teDZlTs3KRNnAnbs2JG7lS4cDsPtdmNubg5lZWW5LraqqmpdC7juPGZZWVnu00h5efltPyt+msxmsxgcHMS7774Ll8uFcDi85uPKTRCE3F8s6/zyZ3IEQYDX671tJsdms6GxsXFdt0sudcza2tolXwAhQFIAABctSURBVE+J+bHKTjzhrTaTs97srly5gkAgcNtMDo29W6TMb7mZnHs5dw4PDyMQCNw2k7NUfuL52u/359Z48P7GKUV+K1lrtiyJf1dHjx7F1atXMTk5ibq6Ojz11FMAgO9973uYm5vD4uIi40pvyc8vH/OZHODWJauViIvu7vyULucxRTt37sz9c01NDbxeLwDgo48+kqQWpSv0d9nQ0FD0YwKU30oK/T06nU5Jjrdt27Y1/fxS2en1evT29iIWiyGVSklSl1KtZRxIodDz752LpAGgqqoK4+Pj0Gg0uHTpkuoWuK5EfO+681I6r8S/K5/Ph4aGhlyTIzZoH3/8Mebm5jA9Pc39ZS0umhwlEadtHQ4HvUkqEOWnXGJ2mzdvxszMDNxud8k3OUoibjuxefNmfPvb31bdAteVHDx4EN3d3WhsbGRdyprs2rULra2tiEajMJlMuQ87L730EhKJBD799FOuZ+cAanLWrKqqCjt27EAqlcK+ffsQDAYRjUaRTCYRj8cRCoWQzWZLfpEdr1bLL38BJ+GLmJ3ZbMa+ffvw2WefYWZmhsaeQoizAwaDAd3d3YhGowgGg5ibm0MwGFT12Ovs7ERnZ+eKt3fzqK6u7rZd00UPPvggAKCioiL3BANeGx1qctaptbUVr7zyCgYHBzE2Nga/3w+v14tLly7RlusKsFR+Ho9H1SdatXA4HPjqV7+K8+fP4/r16zT2FKa5uRnf+ta3kMlkMDo6ilOnTqG/v1/VY2+1W8eVSgmbwkre5DidTjz99NOSrr/gkc1mw5e//GV0d3fn9vgR72LIZrOYmprCJ598ApfLhaGhIczPz7MuuSClnF/+TI7b7VZcfqWSncViwR/90R+hq6trybE3OTmJs2fPor+/H1euXFFEdkDp5FdVVYXPfe5zAIAHHngA3d3dCAQCubE3NTWlyPxWstqt40olzs7F43E4HA4Eg0HE43HWZd1G8iZH/I8W78VXM6PRuORUHnBzoJpMJthsNjgcDszPz991JwSPKL+b7sxvYGAgtyU7b4NYRNndNDU1BaPRCJvNhvr6egwODnKfHVBa+YnKy8vR0tJy29YBSs2vlIn7+4h39PFE8iZH3ENDadcepSZutLV9+3aEQiEkEgm4XC7uF2lRfjfdmd/Ro0fR39+PwcFBbk+0lN1NNTU1eOSRR9DR0YFwOKyI7ADKT6TU/AifJG9yTCbTsp+wSonZbEZTUxOamppy/5vNZsst0uJ1Rofyu+nO/Hw+H2w2G6qrq3H16lUu86PsbloqO3FNxJUrVzA5OYlgMMi4yrtRfjcpceyVuqqqKmzfvh39/f2IRqOsy7kNLTwuovxFWrzP6JDbdXV1ob29HU888QTOnTtH+SlIV1cXWlpasH//fnzyySf4z//8Ty6bHLI0Gnv8a2xsxMGDBzE/P5/bh4wXkjU54nMw1rN7bakQr7knk0n09vZifn4eU1NTrMsiBXA6nbk9IuLxOH79618zrugWGnsrczqdqK2tRVtbGxKJBH7zm9+wLuk2RqMRVquVZnGWwfPYIzdVVlbivvvuQ3V1NQwGA1cbPUq2Sshut2Pv3r3Yu3evVC+pWu3t7XjxxRfx4osvsi4lR1zISSfa1YnNajF3ml0Jjb3V6fV6WCwWNDQ04IEHHuAmO+DmLfGPP/44Hn/8cdalcM9isdy1UJnwQXyqudlshk6nY11OjmQzOeLzpKqrq6V6SdWqrKzEtm3b4PF4WJeSIy56XOkJtuQm3vaGoLFXON6yI2tTW1uLAwcOQBAEvPnmm6zLIXkymQxisRhisRhXe1VJNpOT38WRlZWVlaGmpib38EMeiIseaSZndbzN5NDYKxxv2ZG1ofz4ZTKZ0NjYiIaGBphMJtbl5PB3UzshhBCyBIvFgk2bNmHTpk2sSyF3qK2txRe+8AV84QtfQG1tLetyciRrcuLxOGZnZzE7OyvVS6qe2WxGY2MjF5/AKb+1q6ioQFtbGywWC9M6KLu14yU7AEgmk/D7/ap+rIFUDAYDbDYbmpqauMmP3JQ/y8bThpaSNTnBYBCDg4MYHByU6iVVr7q6Gg8++CAXaykov7VzOBx48skn4XA4mNZB2a0dL9kBQCQSwcjICEZGRliXohg85Uduyp9l46n5lGzhcSKRoE+Ta9TU1IRvfOMbOHfuHD755BNcuHAB09PTTGqh/Naurq4OL7zwAjZt2oSzZ88yy4+yWzun04nDhw+jvb0dH3/8MdOxF41GMTY2hrGxMSbHV6K6ujo8+eSTGBgYwI0bN1iXQ3Bzram43rS8vJybW8klX5OTSCQwPz+PRCIh9UurjrhglKfb7UjhNBpN7osoi16vR1VVFRdPhc5ms0ilUkilUqxLUQwae3zTarXcZCN5kxMKhTA0NIRwOCz1S6tOIpHA1atX8Yc//AEXLlyga/IKQ/kp28LCAi5cuEDZKRB9mCaFkmUmZ3Z2lh6kVgCNRoNkMonp6WlMT08jFouxLim3iJVOHqvjLT/Kbm1isRg32QGU31poNBoun3h9J4vFgra2NlRUVLAupWRJ/lciTr0KgiD1S6uOyWRCfX09F3dXicRFrPRsn9Xxlh9lp2yhUAiXL1+m/ArA29hbDi2QZk/yJmd6ehrHjx9ntohPSfR6PSoqKqDX8/Oc1NHRUfz7v/87RkdHWZfCPd7yo+yUTZxZolnw1fE29pbD01YFpUryJicej8Pj8XAx/UvWjvJTLspO2eLxONxuN+WnMrwswC1V/F/UJISQEuD3+9HX10eLoFVEo9FAp9NRo8MQNTmEEMKBeDyOmZkZulxVAEEQkM1muV/7ydNWBcWi1WphNBphNBq5WBzOvgJCCCFkDQRBQDqd5r7JMZvNqK+v5+qBlXIzGAyoqqriprmTpclJJBLw+Xzw+XxIJpNyHILIiPJTLsquMOl0GuFwmDbgU6hUKqWI/ARB4L4RUztZmhyfz4ePP/4YH3/8Mebn5+U4hCrweqKl/ArDY36UXWF43bSUmtTCLC4uYmRkBIuLi6xLWZHH48GJEyfg8XhYl1I0iUQCc3NzmJub42LPJ7pcxVAsFqO7KRSM8iNSC4fDuHLlCq5cucJdA0bWzuv14uTJk/B6vaxLKVnU5DCUSqUQCoWQTqdZl0LWgfIjUksmk5ifn6dHFqjE4uIibty4gZGREXi9XlpUzgA1OYQQQoiM+vv70d/fT7tZM8D3dpGEEEKIwvX396OqqgoOhwM2mw0Gg4GL26tLATU5hBBCiIz6+vpgNBpx3333wel0wmq1wmg0si6rJMjS5ExOTuKXv/wl5ubmUF9fj4aGBjkOQ2RC+SkXZUcIfzweD37/+99jaGgI3d3dOHz4MO6//37WZZUEWZqcWCyGqakpTE1NIRqNynEIIiPKT7koO2WLRqO5/Hbs2MG6HCKhcDiM4eFhmEwmbNu2DVqtFp2dnazLUj26KEgIIZzw+Xw4e/Yszp49C5/Px7ocIoOxsTEcOXIER44cYV1KSaA1OYQQwgmaiVO/QCAAl8sFAHC5XGhtbYXNZmNclXRsNht2796NhYUFjIyMMH/gLM3kEEIIIUUmzuiMjY2xLkVSLS0tOHToEA4dOoSWlhbW5cjb5ITDYVy7dg3Xrl1DJBKR81CKJG4UxevvhvJbGc/5UXYr4zk7gPJbDe/5FSIQCODMmTMYGBjAxMSEambuDAYDbDYbbDYbysrKWJdz6wFiS30BEO7ly2KxCJs2bRIOHTok9PT0COl0WiC3fPjhh/f0+13qS6D8ikbO/KTK7q/+6q+E8+fPM/5N8UcpY4/yWxrv+RX6ZbfbhQceeED45je/KfT397P9pUqkv79f+Lu/+zvhoYceEqqrq4vye7wzv/wvWWdyEokEZmdnMTU1BbfbTduUKwzlp1xidrw8JI+sDeVXGsQHjY6MjCh6Virf4uIixsfHMTY2xsUDVGVtctLpNBYXF+F2u9Hb24tAICDn4YjEKD/lys/u008/pewUhvIrDclkEn6/H6Ojozh//jxcLpfis06lUlhYWIDf70cqlWJdTnEWHns8Hrz33nsl9bh5NaH8lEutixtLBeVXGvJvK1d61oIgIJPJIJPJiJf+mCrKLeThcBjhcBgfffQRNBoNmpqaYLPZoNfrS/r5HeXl5WhubobP5+N60Rnlt7SKigq0tbXB6/VyMS27FPF21Z6eHmSzWcru/yghO4DyW45Szp2FEnPWarXYtm0b2tvbUVlZybqsNRGbm1QqhUwmg2w2y7okAIBmpU5Lo9FI3oZ1dHTgmWeeQXd3N3bt2oW6ujqpDwHg1i9cp9NBo9HIcox75fV68cMf/hDHjh3D8PCwJK8pCELuP1bJ+SnBwsICXn/9dbz99tsYGBiQ5DXF/Cg7ecmZHUD5yU2J585CmEwmWK1W/OAHP8C+ffvgcDhgsVhYlLJm8/PzuHLlCnp6evDOO+/g0qVLRT1+fn75ir4ZoNvtxtGjR+Hz+WC322UbqJlMBrFYDGazGXo9n3se6nQ6WCwWbutbSrHyI9Kj7JSN8rtFiefOQqRSKQSDQfzmN79BJBLBE088gba2NtZlFWRychLvvPMOenp6MDk5ybqcnKL/hYRCIYRCIRiNRmzduhVarRZ79uzhdrZFTlqtFgaDQVHTzpSfci2VHT07Rzkov1uUeO4shLiW5eLFi9BqtaipqYFGo0FdXR33MzrBYBCXLl0q+gzOapi1weJCq9HRUfzLv/yL5JeVdDodzGYzdDqdZK9JbpE7PyIfMbvx8fGSfZNUMspP/aampqDVaqHVauH3+/H4449j06ZNrMtSJGZNjrjQKpvNoq+vD21tbaiurpbsjVKj0ahuKpMn+fm5XC60t7fDbrezLosUQO3PzlE7yk/9QqEQJiYmcncn1dTUcD2bIz5hPRQKsS7lLszn+sbHx/HWW2/hxo0b3NxyRgon5jc+Ps66FLJGdHuyslF+6haLxTA5OYmLFy/if/7nfzA3N8e6pGW53W4cO3YMbrebdSl3YT7VEQwG8eabb+LUqVPo7u7G1772tZKZghUXR6fTadalrJuY3+nTp9Hd3Y0XXnihZPJTukAggJ/97Gfo6ekpuezUMPYCgQCOHDmCP/zhD+ju7sahQ4ewe/du1mUVhRryW00qlUIqlcLQ0BAmJiZgsVjwuc99Do888giamppYl3ebubk5nD59movN/+7EvMkBbr5RDgwMQKvV5q47lsIUbCQSwcjICNf7dBQif/pcfOpsKeSnlocElmJ2ahx7zc3NyGazlJ/KpFIpBAIBXLt2DY2NjVw2splMBvF4nHUZS2J+uSqfmnZ9LITY/fI8DbkWpZaf1+vFyZMn4fV6WZdyz0otO7WMPXE/sJGREbzxxhuUn4olk0kkk0luNtlTCi5mckT5uz5u2bIFbW1tqKqqYl2WbKLRqKrWspRafpFIBDdu3GBdhiRKLTs1jT1BEOD3++H3+yk/FfP5fPD5fEgmk6xLyQkGgxgfH8fg4CDrUpbF1UyOaGpqCr/61a8wNTXFuhSyDpSfclF2ykb5qdfo6ChGR0e5ukQ3Pj6Ot99+G2+//TbrUpbF1UyOKP95LclksiSuMauJmN+5c+eg1WrR2NiouOewrCSTySCRSKjimTl3ouyUTe35hcNhuN1uyR7loCSBQACBQICLmZzFxUV4vV4MDAzA5XLh6tWrrEtaFpdNjnjt8aWXXkJXVxcOHz6M7u5uNDQ0qGLARqNRzM3NqXa6Vczv29/+Nu6//348++yz2Ldvn2ry83q9uHDhAnp6eliXIjm1Z7ewsIDPPvsMFy5cYF2KLPLz+9znPocXX3wR+/btg8lkUsW+YVeuXMGPf/xjVY69QsRiMXg8Hng8HtjtdphMJiZ1jIyM4O2338aFCxcQDAZhtVrh9/uZ1LIaLi9X5Zuensbx48dx/PhxTE9Psy5HEnNzczh16hROnTrFuhRZBYNBDA0N4ejRo6rKz+Px4MSJEzhx4gTrUmSj1uxCoRCGhoYwNDTEuhRZBYNBeL1eTE5Owuv1cnvny1rpdDqUl5dzuyme3Px+P3p7e9Hb28tFU5FIJDA3N8f1AnDuW3tx+lWv16O+vl4VnyhjsRimp6fh8XhYlyKreDwOr9eLZDIJjUajmvySySSCwSCCwSDrUmSj1uzE23HVnB1wK7+LFy/CaDRix44d6OjoQFlZGevS7kk2m0UikVBN06Z06XQai4uLXK0TuhP3TU4ymYTf78fly5eh1Wrx8MMPK/5Eq9frYbFYSuLTiBrzs1qt2LlzJ+bn5/G///u/rMuRjRqzK6WxNzMzg/fffx9TU1OYn59HU1MTampqWJd1T0rlA+Jy7HY7urq60NXVRY/RKRD3TY64s6XH40EymcT58+eh0WjgdDpRUVHBurx1SSaTCAQCXEw3yk1N+Yl7kqTT6ZJ4/IiashOV0tiLRCK4fv064vE4DAYDtmzZgs2bNys6v3Q6jUgkgnA4zLoUJjKZTG7mROkfOIqF+zU5okQiAZ/Ph2PHjuHEiROK7uR5fSS9nNSQn7ir5+zsLPr7+0smPzVkJyrFsefz+XD27Fm8+eabis+v1M3MzOC3v/0tfvvb32JmZoZ1OYrA/UyOKJPJIBqN4v3338e5c+fw85//HE6nE/X19ejs7MRLL73EusSCJRIJzM7OYnZ2lnUpRaOG/ARByH2SnJmZKZn8lsquvb0du3btQmdnJ55++mnWJRasFMdeLBbD1NQUjh8/jtOnTys6v1InXoKMx+PYs2cPNm/ezLok7immyRFFo1FEo1FMT0+joqIC9fX1CAQC6OzshMlkgs1mg8Ph4HI6NpvNIpVKIZFIIJPJsC6HCSXnJ16uymQyJXG56k752U1NTWFhYQGBQAAOhwO1tbWw2WywWCwwGAysS70Ljb3l83M6nXA6nbDZbDAajdDpdKxLJcsQP2RFIhFVP5xUSoprcvLF43HMzMzg3Llz+P73vw+n04nOzk588Ytf5PJNMpVK5e7K4fFprcWmtPzEjeQSiUTJPz8mGAxicHAQExMTmJ+fx4EDB9DZ2YlNmzZxuXEnjb3b5ecXDofx9NNPo7OzEzU1NSgvL2ddHiGSUXSTk9/VBoNBOJ1OAMBDDz3EuLKliWs64vF4yb9JAsrLT7xcVSoLj1ci/h17vV4kEonc78Nut3PZ5NDYu11+fgByHyq6urq4bHJoJo6sl6KbnHziXSDT09OIxWKsyyFrRPkpl7i5pUajwc6dO9Ha2sq6JLIGHo8H7733HiKRCBoaGtDQ0MC6pLvQTBxZL9U0Oel0GuFwGBcvXsQ//dM/4fz583j66aexdetW1qWRAlB+yiU+EfrkyZNYWFhAd3c3Zacg4XAY4XAYkUgEHo+Hy/xoJu4mp9OJrq6u3GOOyOoUcwt5ocQdkl0uFwKBAOtyyBpRfsrFc3ZiIzY+Ps717qws8ZwfIeuluiZH3NNjfn4eiUSCdTlkjSg/5eI5u/znxfH8nB2WeM6P3MTbs6uUQHVNjrinRywWowVqCkT5KRdlp2w85xcOhzE8PIzh4WGEQiHW5TATj8dzTyGntYuFUc2aHEIIWU5tbS0OHDgAQRBKaiNHtXC73Th27Bh6enrgdrtZl0MURHUzOYQQcqfy8nK0tLSgpaWlJB7OqTahUCg3k1Oqz63iSUVFBdra2tDW1sb9eKKZnCLSarUwGo0wGo3Qaqm/JISQQlRVVWH79u2YmZmB2+2mRoextrY2fP3rX8e2bdswMzODyclJ1iUti95pi8hgMMBqtcJqtXK59T0hhPCosbERBw8exMGDB9HY2Mi6HKIgNJNTRDqdLjebQzM5hBBSmMrKytxMTlVVFetyiIJoSn17ekIIIYSoE00nEEIIIUSVqMkhhBBCiCpRk0PI/2+3DmQAAAAABvlb3+MrigBYkhwAYElyAIAlyQEAlgKiVvv1MAQttAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 25 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"A\")\n",
    "multipleImages = glob('F:/dataset folders/mydata sam/training_set/A/**')\n",
    "i_ = 0\n",
    "plt.rcParams['figure.figsize'] = (10.0, 10.0)\n",
    "plt.subplots_adjust(wspace=0, hspace=0)\n",
    "for l in multipleImages[:25]:\n",
    "    im = cv2.imread(l)\n",
    "    im = cv2.resize(im, (128, 128)) \n",
    "    plt.subplot(5, 5, i_+1) #.set_title(l)\n",
    "    plt.imshow(cv2.cvtColor(im, cv2.COLOR_BGR2RGB)); plt.axis('off')\n",
    "    i_ += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "_cell_guid": "acafe27f-6c13-4091-9ce0-907c5784eb79",
    "_uuid": "6384bf60c740fc5cc97c90c6bb4a170e294210b2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z', 26: 'del', 27: 'nothing', 28: 'space', 29: 'other'}\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "map_characters = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z', 26: 'del', 27: 'nothing', 28: 'space', 29: 'other'}\n",
    "dict_characters=map_characters\n",
    "import seaborn as sns\n",
    "df = pd.DataFrame()\n",
    "df[\"labels\"]=y_train\n",
    "lab = df['labels']\n",
    "dist = lab.value_counts()\n",
    "sns.countplot(lab)\n",
    "print(dict_characters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Step 4 Define Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "_cell_guid": "5c2b5fc4-e1af-4dfe-a928-8a8076c73d59",
    "_uuid": "992129dbd3c7695bdd2e2497a6a56da0227c8c0d"
   },
   "outputs": [],
   "source": [
    "# Helper Functions  Learning Curves and Confusion Matrix\n",
    "\n",
    "from keras.callbacks import Callback, EarlyStopping, ReduceLROnPlateau, ModelCheckpoint\n",
    "\n",
    "class MetricsCheckpoint(Callback):\n",
    "    \"\"\"Callback that saves metrics after each epoch\"\"\"\n",
    "    def __init__(self, savepath):\n",
    "        super(MetricsCheckpoint, self).__init__()\n",
    "        self.savepath = savepath\n",
    "        self.history = {}\n",
    "    def on_epoch_end(self, epoch, logs=None):\n",
    "        for k, v in logs.items():\n",
    "            self.history.setdefault(k, []).append(v)\n",
    "        np.save(self.savepath, self.history)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Step 5 Evaluate Classification Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Transfer learning w/ VGG16 Convolutional Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\sklearn\\utils\\validation.py:72: FutureWarning: Pass classes=[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
      " 24 25], y=[ 7 23 20 ...  9 20 25] as keyword args. From version 1.0 (renaming of 0.25) passing these as positional arguments will result in an error\n",
      "  \"will result in an error\", FutureWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3976: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:174: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:181: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:186: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:190: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:199: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:206: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3295: The name tf.log is deprecated. Please use tf.math.log instead.\n",
      "\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 50, 50, 3)         0         \n",
      "_________________________________________________________________\n",
      "block1_conv1 (Conv2D)        (None, 50, 50, 64)        1792      \n",
      "_________________________________________________________________\n",
      "block1_conv2 (Conv2D)        (None, 50, 50, 64)        36928     \n",
      "_________________________________________________________________\n",
      "block1_pool (MaxPooling2D)   (None, 25, 25, 64)        0         \n",
      "_________________________________________________________________\n",
      "block2_conv1 (Conv2D)        (None, 25, 25, 128)       73856     \n",
      "_________________________________________________________________\n",
      "block2_conv2 (Conv2D)        (None, 25, 25, 128)       147584    \n",
      "_________________________________________________________________\n",
      "block2_pool (MaxPooling2D)   (None, 12, 12, 128)       0         \n",
      "_________________________________________________________________\n",
      "block3_conv1 (Conv2D)        (None, 12, 12, 256)       295168    \n",
      "_________________________________________________________________\n",
      "block3_conv2 (Conv2D)        (None, 12, 12, 256)       590080    \n",
      "_________________________________________________________________\n",
      "block3_conv3 (Conv2D)        (None, 12, 12, 256)       590080    \n",
      "_________________________________________________________________\n",
      "block3_pool (MaxPooling2D)   (None, 6, 6, 256)         0         \n",
      "_________________________________________________________________\n",
      "block4_conv1 (Conv2D)        (None, 6, 6, 512)         1180160   \n",
      "_________________________________________________________________\n",
      "block4_conv2 (Conv2D)        (None, 6, 6, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block4_conv3 (Conv2D)        (None, 6, 6, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block4_pool (MaxPooling2D)   (None, 3, 3, 512)         0         \n",
      "_________________________________________________________________\n",
      "block5_conv1 (Conv2D)        (None, 3, 3, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_conv2 (Conv2D)        (None, 3, 3, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_conv3 (Conv2D)        (None, 3, 3, 512)         2359808   \n",
      "_________________________________________________________________\n",
      "block5_pool (MaxPooling2D)   (None, 1, 1, 512)         0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 512)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 30)                15390     \n",
      "=================================================================\n",
      "Total params: 14,730,078\n",
      "Trainable params: 15,390\n",
      "Non-trainable params: 14,714,688\n",
      "_________________________________________________________________\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\tensorflow_core\\python\\ops\\math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:986: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:973: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n",
      "\n",
      "Train on 30000 samples, validate on 9100 samples\n",
      "Epoch 1/2\n",
      "30000/30000 [==============================] - 1055s 35ms/step - loss: 0.9487 - acc: 0.8681 - val_loss: 0.3527 - val_acc: 0.9671\n",
      "Epoch 2/2\n",
      "30000/30000 [==============================] - 1619s 54ms/step - loss: 0.2496 - acc: 0.9748 - val_loss: 0.1808 - val_acc: 0.9816\n",
      "\n",
      "Keras CNN - accuracy: 0.9816483516745514 \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.engine.training.Model at 0x1c323415208>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map_characters1 = map_characters\n",
    "class_weight1 = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train)\n",
    "weight_path1 = 'C:/Users/User/Desktop/my project 2021/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
    "#weight_path2 = 'C:/Users/User/Desktop/my project 2021/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
    "pretrained_model_1 = VGG16(weights = weight_path1, include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "#pretrained_model_2 = InceptionV3(weights = weight_path2, include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "optimizer1 = keras.optimizers.Adam()\n",
    "optimizer2 = keras.optimizers.RMSprop(lr=0.0001)\n",
    "def pretrainedNetwork(xtrain,ytrain,xtest,ytest,pretrainedmodel,pretrainedweights,classweight,numclasses,numepochs,optimizer,labels):\n",
    "    base_model = pretrained_model_1 # Topless\n",
    "    # Add top layer\n",
    "    x = base_model.output\n",
    "    x = Flatten()(x)\n",
    "    predictions = Dense(numclasses, activation='softmax')(x)\n",
    "    model = Model(inputs=base_model.input, outputs=predictions)\n",
    "    # Train top layer\n",
    "    for layer in base_model.layers:\n",
    "        layer.trainable = False\n",
    "    model.compile(loss='categorical_crossentropy', \n",
    "                  optimizer=optimizer, \n",
    "                  metrics=['accuracy'])\n",
    "    callbacks_list = [keras.callbacks.EarlyStopping(monitor='val_acc', patience=3, verbose=1)]\n",
    "    model.summary()\n",
    "    # Fit model\n",
    "    history = model.fit(xtrain,ytrain, epochs=2, class_weight=classweight, validation_data=(xtest,ytest), verbose=1,callbacks = [MetricsCheckpoint('logs')])\n",
    "    # Evaluate model\n",
    "    score = model.evaluate(xtest,ytest, verbose=0)\n",
    "    print('\\nKeras CNN - accuracy:', score[1], '\\n')\n",
    "    y_pred = model.predict(xtest)\n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    \n",
    "    return model\n",
    "pretrainedNetwork(X_train, y_trainHot, X_test, y_testHot,pretrained_model_1,weight_path1,class_weight1,30,10,optimizer1,map_characters1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight_path1 = 'C:/Users/User/Desktop/my project 2021/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
    "#weight_path2 = 'C:/Users/User/Desktop/my project 2021/inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5'\n",
    "\n",
    "#pretrained_model_2 = InceptionV3(weights = weight_path2, include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "pretrained_model_1 = VGG16(weights = weight_path1, include_top=False, input_shape=(imageSize, imageSize, 3))\n",
    "def pretrainedNetwork(xtrain,ytrain,xtest,ytest,pretrainedmodel,pretrainedweights,classweight,numclasses,numepochs,optimizer,labels):\n",
    "    base_model = pretrained_model_2 # Topless\n",
    "    # Add top layer\n",
    "    x = base_model.output\n",
    "    x = Flatten()(x)\n",
    "    predictions = Dense(numclasses, activation='softmax')(x)\n",
    "    model = Model(inputs=base_model.input, outputs=predictions)\n",
    "    # Train top layer\n",
    "    for layer in base_model.layers:\n",
    "        layer.trainable = False\n",
    "    model.compile(loss='categorical_crossentropy', \n",
    "                  optimizer=optimizer, \n",
    "                  metrics=['accuracy'])\n",
    "    callbacks_list = [keras.callbacks.EarlyStopping(monitor='val_acc', patience=3, verbose=1)]\n",
    "    model.summary()\n",
    "    # Fit model\n",
    "    history = model.fit(xtrain,ytrain, epochs=4, class_weight=classweight, validation_data=(xtest,ytest), verbose=1,callbacks = [MetricsCheckpoint('logs')])\n",
    "    # Evaluate model\n",
    "    score = model.evaluate(xtest,ytest, verbose=0)\n",
    "    print('\\nKeras CNN - accuracy:', score[1], '\\n')\n",
    "pretrainedNetwork(X_train, y_trainHot, X_test, y_testHot,pretrained_model_1,weight_path,class_weight1,30,10,optimizer2,map_characters1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-98d091539d2e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     17\u001b[0m \u001b[0mtest_image\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg_to_array\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[0mtest_image\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 19\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_image\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     21\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "image_x, image_y = 64,64\n",
    "\n",
    "from keras.models import load_model\n",
    "classifier = load_model('F:/may 2021 all folders/will/Simple-Sign-Language-Detector-master/Trained_model.h5')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "from keras.preprocessing import image\n",
    "\n",
    "test_image = image.load_img('F:/dataset folders/mydata sam/test_set/T/7.png',target_size=(50,50))\n",
    "plt.imshow(test_image)\n",
    "test_image = image.img_to_array(test_image)\n",
    "test_image = np.expand_dims(test_image, axis=0)\n",
    "result = model.predict(test_image)\n",
    "\n",
    "\n",
    "if result[0][0] == 1:\n",
    "    prediction = '1'\n",
    "elif result[0][1] == 1:\n",
    "    prediction = '10'\n",
    "elif result[0][2] == 1:\n",
    "    prediction = '2'\n",
    "elif result[0][3] == 1:\n",
    "    prediction = '3'\n",
    "elif result[0][4] == 1:\n",
    "    prediction = '4'\n",
    "elif result[0][5] == 1:\n",
    "    prediction = '5'\n",
    "elif result[0][6] == 1:\n",
    "    prediction = '6'\n",
    "elif result[0][7] == 1:\n",
    "    prediction = '7'\n",
    "elif result[0][8] == 1:\n",
    "    prediction = '8'\n",
    "elif result[0][9] == 1:\n",
    "    prediction = '9'\n",
    "elif result[0][10] == 1:\n",
    "    prediction = 'A'\n",
    "elif result[0][11] == 1:\n",
    "    prediction = 'B'\n",
    "elif result[0][12] == 1:\n",
    "    prediction = 'C'\n",
    "elif result[0][13] == 1:\n",
    "    prediction = 'D'\n",
    "elif result[0][14] == 1:\n",
    "    prediction = 'E'\n",
    "elif result[0][15] == 1:\n",
    "    prediction = 'F'\n",
    "elif result[0][16] == 1:\n",
    "    prediction = 'G'\n",
    "elif result[0][17] == 1:\n",
    "    prediction = 'H'\n",
    "elif result[0][18] == 1:\n",
    "    prediction = 'I'\n",
    "elif result[0][19] == 1:\n",
    "    prediction = 'J'\n",
    "elif result[0][20] == 1:\n",
    "    prediction = 'K'\n",
    "elif result[0][21] == 1:\n",
    "    prediction = 'L'\n",
    "elif result[0][22] == 1:\n",
    "    prediction = 'M'\n",
    "elif result[0][23] == 1:\n",
    "    prediction = 'N'\n",
    "elif result[0][24] == 1:\n",
    "    prediction = 'O'\n",
    "elif result[0][25] == 1:\n",
    "    prediction = 'P'\n",
    "elif result[0][26] == 1:\n",
    "    prediction = 'Q'\n",
    "elif result[0][27] == 1:\n",
    "    prediction = 'R'\n",
    "elif result[0][28] == 1:\n",
    "    prediction = 'S'\n",
    "elif result[0][29] == 1:\n",
    "    prediction = 'T'\n",
    "elif result[0][30] == 1:\n",
    "    prediction = 'U'\n",
    "elif result[0][31] == 1:\n",
    "    prediction = 'V'\n",
    "elif result[0][32] == 1:\n",
    "    prediction = 'W'\n",
    "elif result[0][33] == 1:\n",
    "    prediction = 'X'\n",
    "elif result[0][34] == 1:\n",
    "    prediction = 'Y'\n",
    "elif result[0][35] == 1:\n",
    "    prediction = 'Z'\n",
    "else:\n",
    "    prediction = '  '\n",
    "    \n",
    "print(prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\ipykernel_launcher.py:14: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(32, (3, 3), input_shape=(64, 64, 3..., activation=\"relu\")`\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3976: The name tf.nn.max_pool is deprecated. Please use tf.nn.max_pool2d instead.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\ipykernel_launcher.py:20: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(32, (3, 3), activation=\"relu\")`\n",
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\ipykernel_launcher.py:24: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(64, (3, 3), activation=\"relu\")`\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:133: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3295: The name tf.log is deprecated. Please use tf.math.log instead.\n",
      "\n",
      "Found 45500 images belonging to 26 classes.\n",
      "Found 6500 images belonging to 26 classes.\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\tensorflow_core\\python\\ops\\math_grad.py:1424: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:986: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:973: The name tf.assign is deprecated. Please use tf.compat.v1.assign instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:2741: The name tf.Session is deprecated. Please use tf.compat.v1.Session instead.\n",
      "\n",
      "Epoch 1/15\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:174: The name tf.get_default_session is deprecated. Please use tf.compat.v1.get_default_session instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:181: The name tf.ConfigProto is deprecated. Please use tf.compat.v1.ConfigProto instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:190: The name tf.global_variables is deprecated. Please use tf.compat.v1.global_variables instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:199: The name tf.is_variable_initialized is deprecated. Please use tf.compat.v1.is_variable_initialized instead.\n",
      "\n",
      "WARNING:tensorflow:From C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:206: The name tf.variables_initializer is deprecated. Please use tf.compat.v1.variables_initializer instead.\n",
      "\n",
      "15/15 [==============================] - 376s 25s/step - loss: 3.2824 - acc: 0.0396 - val_loss: 3.2724 - val_acc: 0.0419\n",
      "Epoch 2/15\n",
      "15/15 [==============================] - 210s 14s/step - loss: 3.2676 - acc: 0.0500 - val_loss: 3.2579 - val_acc: 0.0725\n",
      "Epoch 3/15\n",
      "15/15 [==============================] - 205s 14s/step - loss: 3.2586 - acc: 0.0500 - val_loss: 3.2497 - val_acc: 0.0728\n",
      "Epoch 4/15\n",
      "15/15 [==============================] - 206s 14s/step - loss: 3.2542 - acc: 0.0500 - val_loss: 3.2383 - val_acc: 0.0868\n",
      "Epoch 5/15\n",
      "15/15 [==============================] - 205s 14s/step - loss: 3.2394 - acc: 0.0604 - val_loss: 3.2315 - val_acc: 0.0613\n",
      "Epoch 6/15\n",
      "14/15 [===========================>..] - ETA: 0s - loss: 3.2353 - acc: 0.0714"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\dask\\dataframe\\utils.py:14: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
      "  import pandas.util.testing as tm\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-682dcd3b27c0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     67\u001b[0m         \u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m15\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     68\u001b[0m         \u001b[0mvalidation_data\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtest_set\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 69\u001b[1;33m         \u001b[0mvalidation_steps\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m6500\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     70\u001b[0m       )\n\u001b[0;32m     71\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\legacy\\interfaces.py\u001b[0m in \u001b[0;36mwrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     89\u001b[0m                 warnings.warn('Update your `' + object_name + '` call to the ' +\n\u001b[0;32m     90\u001b[0m                               'Keras 2 API: ' + signature, stacklevel=2)\n\u001b[1;32m---> 91\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     92\u001b[0m         \u001b[0mwrapper\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_original_function\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     93\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mfit_generator\u001b[1;34m(self, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[0;32m   1416\u001b[0m             \u001b[0muse_multiprocessing\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1417\u001b[0m             \u001b[0mshuffle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mshuffle\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1418\u001b[1;33m             initial_epoch=initial_epoch)\n\u001b[0m\u001b[0;32m   1419\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1420\u001b[0m     \u001b[1;33m@\u001b[0m\u001b[0minterfaces\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlegacy_generator_methods_support\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\engine\\training_generator.py\u001b[0m in \u001b[0;36mfit_generator\u001b[1;34m(model, generator, steps_per_epoch, epochs, verbose, callbacks, validation_data, validation_steps, class_weight, max_queue_size, workers, use_multiprocessing, shuffle, initial_epoch)\u001b[0m\n\u001b[0;32m    232\u001b[0m                             \u001b[0mval_enqueuer_gen\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    233\u001b[0m                             \u001b[0mvalidation_steps\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 234\u001b[1;33m                             workers=0)\n\u001b[0m\u001b[0;32m    235\u001b[0m                     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    236\u001b[0m                         \u001b[1;31m# No need for try/except because\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\legacy\\interfaces.py\u001b[0m in \u001b[0;36mwrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     89\u001b[0m                 warnings.warn('Update your `' + object_name + '` call to the ' +\n\u001b[0;32m     90\u001b[0m                               'Keras 2 API: ' + signature, stacklevel=2)\n\u001b[1;32m---> 91\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     92\u001b[0m         \u001b[0mwrapper\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_original_function\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     93\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mevaluate_generator\u001b[1;34m(self, generator, steps, max_queue_size, workers, use_multiprocessing, verbose)\u001b[0m\n\u001b[0;32m   1470\u001b[0m             \u001b[0mworkers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mworkers\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1471\u001b[0m             \u001b[0muse_multiprocessing\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0muse_multiprocessing\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1472\u001b[1;33m             verbose=verbose)\n\u001b[0m\u001b[0;32m   1473\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1474\u001b[0m     \u001b[1;33m@\u001b[0m\u001b[0minterfaces\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlegacy_generator_methods_support\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\engine\\training_generator.py\u001b[0m in \u001b[0;36mevaluate_generator\u001b[1;34m(model, generator, steps, max_queue_size, workers, use_multiprocessing, verbose)\u001b[0m\n\u001b[0;32m    344\u001b[0m                                  \u001b[1;34m'or (x, y). Found: '\u001b[0m \u001b[1;33m+\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    345\u001b[0m                                  str(generator_output))\n\u001b[1;32m--> 346\u001b[1;33m             \u001b[0mouts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtest_on_batch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    347\u001b[0m             \u001b[0mouts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mto_list\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mouts\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    348\u001b[0m             \u001b[0mouts_per_batch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mouts\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\engine\\training.py\u001b[0m in \u001b[0;36mtest_on_batch\u001b[1;34m(self, x, y, sample_weight)\u001b[0m\n\u001b[0;32m   1254\u001b[0m             \u001b[0mins\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0my\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0msample_weights\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1255\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_make_test_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1256\u001b[1;33m         \u001b[0moutputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtest_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mins\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1257\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0munpack_singleton\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1258\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m   2713\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_legacy_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2714\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2715\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2716\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2717\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mpy_any\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mis_tensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py\u001b[0m in \u001b[0;36m_call\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m   2673\u001b[0m             \u001b[0mfetched\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_callable_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0marray_vals\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_metadata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2674\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2675\u001b[1;33m             \u001b[0mfetched\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_callable_fn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0marray_vals\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2676\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mfetched\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2677\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\Anaconda3\\envs\\anacondaenv\\lib\\site-packages\\tensorflow_core\\python\\client\\session.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1470\u001b[0m         ret = tf_session.TF_SessionRunCallable(self._session._session,\n\u001b[0;32m   1471\u001b[0m                                                \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_handle\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1472\u001b[1;33m                                                run_metadata_ptr)\n\u001b[0m\u001b[0;32m   1473\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1474\u001b[0m           \u001b[0mproto_data\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Part 1 - Building the CNN\n",
    "#importing the Keras libraries and packages\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Convolution2D\n",
    "from keras.layers import MaxPooling2D\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras import optimizers\n",
    "\n",
    "# Initialing the CNN\n",
    "classifier = Sequential()\n",
    "\n",
    "# Step 1 - Convolutio Layer \n",
    "classifier.add(Convolution2D(32, 3,  3, input_shape = (64, 64, 3), activation = 'relu'))\n",
    "\n",
    "#step 2 - Pooling\n",
    "classifier.add(MaxPooling2D(pool_size =(2,2)))\n",
    "\n",
    "# Adding second convolution layer\n",
    "classifier.add(Convolution2D(32, 3,  3, activation = 'relu'))\n",
    "classifier.add(MaxPooling2D(pool_size =(2,2)))\n",
    "\n",
    "#Adding 3rd Concolution Layer\n",
    "classifier.add(Convolution2D(64, 3,  3, activation = 'relu'))\n",
    "classifier.add(MaxPooling2D(pool_size =(2,2)))\n",
    "\n",
    "\n",
    "#Step 3 - Flattening\n",
    "classifier.add(Flatten())\n",
    "\n",
    "#Step 4 - Full Connection\n",
    "classifier.add(Dense(256, activation = 'relu'))\n",
    "classifier.add(Dropout(0.5))\n",
    "classifier.add(Dense(26, activation = 'softmax'))\n",
    "\n",
    "#Compiling The CNN\n",
    "classifier.compile(\n",
    "              optimizer = optimizers.SGD(lr = 0.01),\n",
    "              loss = 'categorical_crossentropy',\n",
    "              metrics = ['accuracy'])\n",
    "\n",
    "#Part 2 Fittting the CNN to the image\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "train_datagen = ImageDataGenerator(\n",
    "        rescale=1./255,\n",
    "        shear_range=0.2,\n",
    "        zoom_range=0.2,\n",
    "        horizontal_flip=True)\n",
    "\n",
    "test_datagen = ImageDataGenerator(rescale=1./255)\n",
    "\n",
    "training_set = train_datagen.flow_from_directory(\n",
    "        'F:/dataset folders/mydata sam/training_set',\n",
    "        target_size=(64, 64),\n",
    "        batch_size=32,\n",
    "        class_mode='categorical')\n",
    "\n",
    "test_set = test_datagen.flow_from_directory(\n",
    "        'F:/dataset folders/mydata sam/test_set',\n",
    "        target_size=(64, 64),\n",
    "        batch_size=32,\n",
    "        class_mode='categorical')\n",
    "\n",
    "model = classifier.fit_generator(\n",
    "        training_set,\n",
    "        steps_per_epoch=15,\n",
    "        epochs=15,\n",
    "        validation_data = test_set,\n",
    "        validation_steps = 6500\n",
    "      )\n",
    "\n",
    "'''#Saving the model\n",
    "import h5py\n",
    "classifier.save('Trained_model.h5')'''\n",
    "\n",
    "print(model.history.keys())\n",
    "import matplotlib.pyplot as plt\n",
    "# summarize history for accuracy\n",
    "plt.plot(model.history['acc'])\n",
    "plt.plot(model.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()\n",
    "# summarize history for loss\n",
    "\n",
    "plt.plot(model.history['loss'])\n",
    "plt.plot(model.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}