App_DC-Copy1-test-100.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem: Find defected iPhones\n",
    "* <b>Description:</b> Classify the iPhone pictures into defected and not defected\n",
    "* <b>Assumptions 1:</b> We assume that the background of the image is even (white) so we do not need to worry about finding the region of interest (ROI). If this assumption is violated, we can add an ROI layer on top of our model and introduce a boxing penalty so that the model automatically finds the ROI. Also, non-machine learning approaches like OpenCV countors can be used to find the ROI.\n",
    "* <b>Assumptions 2:</b> If the data is not labeled (as in the given file) we can use crowdsourcing or historical data to label them, but if that is not a feasible or effective way, we can use semi-supervised learning or unsupervised learning to label the data. In this problem, I assume the data is labeled and by looking at the images I divided them into \"defected\" and \"not defected\".\n",
    "* <b>Assumptions 3:</b> Since the pictures are all of the same objects, we conjecture that using a pre-trained model to perform a fine tunning or transfer learning cannot give us such a big advantage and we can train our model from scratch so it merely focuses on classifying defected and not-defected.\n",
    "* <b>Note 1:</b> The data set is highly unbalanced. We could use stratified k fold cross-validation or the like but is there any better solution? see observation 2.\n",
    "* <b>Note 2:</b> I leveraged open source tools (I also sent a file in which I just use Keras predefined models to just showcase my skills :) ) but finally  decided to build my model as it is here because it gives a real deep access to the losses and structure (like to add the ROI layer), so please excuse the long code in that part. I still keep the code under 300 lines.\n",
    "* <b>Observation 1:</b> We could use 3 channels but we observed that grayscale works better here by similar reason as in assumption 3 that we want to just focus on the defection. Also, this speeds the training up a lot (although the data is small this gave speed up of order 5x)\n",
    "* <b>Observation 2:</b> We tried data augmentation on the whole data set and it gave use ~ 90% accuracy on test set but if we do augmentation just on the defected samples then not only do we get up to 96% accuracy in test, but also we have alleviated the unbalancedness up to a natural degree (We all know perfect balance is not the best).\n",
    "* <b>Observation 3:</b> One of the challenges of this problem is to do hyperparameter tuning. This process can be done exhaustively or intelligently.  For example, the learning curve can help a lot for tunning the learning rate, model capacity and parameters (if learns so fast maybe decrease the capacity) and also data preprocessing steps. I keep the detail of this process in the background as it can be of less interest here.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:523: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:524: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "E:\\program\\Anaconda\\envs\\tf_2\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:532: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import cv2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# download the data \n",
    "import pathlib\n",
    "# emailed_link = 'https://urldefense.proofpoint.com/v2/url?u=https-3A__apple.box.com_shared_static_uqafgvmz8d1s2uexbg74fmqlyal6jzov.zip&d=DwMFaQ&c=clK7kQUTWtAVEOVIgvi0NU5BOUHhpN0H8p7CSfnc_gI&r=d4ucKxSoqaeRpi9SjIi_Xw&m=IHt8J6CHK1Tjq2MH1BtaRBmLfhvQSeK6Q2HMzE5fabI&s=JChTdl1eP1yofrrOOlOn7Q4BYl0gSNxMm6DUQxlP5l4&e='\n",
    "# data_dir = tf.keras.utils.get_file(fname= \"F:/Acad/lc/apple_DC/iphone/iphone\",\n",
    "#                                    origin=emailed_link,\n",
    "#                                    extract=True)\n",
    "# data_dir = pathlib.Path(data_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# manual labeling\n",
    "DATASET_PATH = \"F:/Acad/lc/apple_DC/splitted-all\" # the dataset file or root folder path.\n",
    "\n",
    "# Image Parameters\n",
    "N_CLASSES = 2 # total number of classes (11 defected , 89 undefected)\n",
    "IMG_HEIGHT = 64  # the image height to be resized to\n",
    "IMG_WIDTH = 64 # the image width to be resized to\n",
    "CHANNELS = 1 # The 3 color channels, can change to 1 if want grayscale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_prec = 0.8 # trian set percentage\n",
    "eval_prec = .1  # validation set percentage, rest is test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def augmentation(image, gammas, rotations):\n",
    "    '''\n",
    "    input: image tensor\n",
    "    return: a list of augmented images\n",
    "    \n",
    "    By a bried look at the data and also the assumption that we are in a semi-controlled environment,\n",
    "    we just did flips, shifts and add light. \n",
    "    '''\n",
    "    result = []\n",
    "    angels = np.random.random(rotations)*50-25  # random -25, 25 degree rotate\n",
    "    for angel in angels:\n",
    "        result.append(cv2.warpAffine(image, cv2.getRotationMatrix2D((IMG_WIDTH / 2, IMG_HEIGHT / 2), angel, 1.0),dsize=(IMG_WIDTH,IMG_HEIGHT)))\n",
    "    result.append(cv2.flip(image, flipCode=-1)) # vertical and horizontal flip\n",
    "    result.append(cv2.flip(image, flipCode=0)) # vertical flip\n",
    "    result.append(cv2.flip(image, flipCode=1)) # horizontal flip\n",
    "    for gamma in gammas:\n",
    "        invGamma = 1.0 / gamma\n",
    "        table = np.array([((i / 255.0) ** invGamma) * 255\n",
    "                          for i in np.arange(0, 256)]).astype(\"uint8\")\n",
    "        result.append(cv2.LUT(image, table))\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_images(dataset_path):\n",
    "    '''\n",
    "    input: str folder path \n",
    "    output: train, validation and test data sets\n",
    "    '''\n",
    "    images, labels = list(), list()\n",
    "    images_dir = list()\n",
    "\n",
    "    classes = sorted(os.walk(dataset_path).__next__()[1])  # List the directory\n",
    "\n",
    "    # grayscale or RGB\n",
    "    if CHANNELS==1:\n",
    "        read_img = lambda x: cv2.imread(x, cv2.IMREAD_GRAYSCALE)\n",
    "    elif CHANNELS==3:\n",
    "        read_img = lambda x: cv2.imread(x, cv2.IMREAD_UNCHANGED)\n",
    "\n",
    "    # List each sub-directory (the classes)\n",
    "    for c in classes:\n",
    "        if c ==\"defected\":\n",
    "            label = 1\n",
    "        elif c==\"undefected\":\n",
    "            label= 0\n",
    "            \n",
    "        c_dir = os.path.join(dataset_path, c)\n",
    "        walk = os.walk(c_dir).__next__()\n",
    "        # Add each image to the set\n",
    "        for sample in walk[2]:\n",
    "            img_path = os.path.join(c_dir, sample)\n",
    "            image = read_img(img_path)\n",
    "            image = cv2.resize(image, (IMG_HEIGHT, IMG_WIDTH), interpolation=cv2.INTER_AREA)\n",
    "            images.append(image * 1.0 / 127.5 - 1.0)  # normalize\n",
    "            images_dir.append(img_path)\n",
    "            labels.append(label)\n",
    "            \n",
    "            if label == 1:  # augmentation just on defected\n",
    "                res = augmentation(image, [.1, .4, .6, 1], 5)\n",
    "                images += res\n",
    "                images_dir += [img_path]*len(res)\n",
    "                labels += [label]*len(res)\n",
    "#             if label == 0:\n",
    "#                 res = augmentation(image, [.1, 1], 0)\n",
    "#                 images += res\n",
    "#                 images_dir += [img_path]*len(res)\n",
    "#                 labels += [label]*len(res)\n",
    "        \n",
    "\n",
    "    # shuffle and split train, validation and test\n",
    "    num_data = len(labels)\n",
    "    np.random.seed(110) # set the seed\n",
    "    idx = np.random.permutation(len(labels))\n",
    "    images, images_dir, labels = np.array(images)[idx,:], np.array(images_dir)[idx] , np.array(labels)[idx], \n",
    "    \n",
    "    num_training = int(num_data * .8)\n",
    "    num_eval = int(num_data * .1)\n",
    "\n",
    "    tr_X = images[:num_training]\n",
    "    eval_X = images[num_training : num_eval+num_training]\n",
    "    tes_X = images[num_eval+num_training:]\n",
    "    tes_X_dir = images_dir[num_eval+num_training:]\n",
    "\n",
    "    tr_y = labels[:num_training]\n",
    "    eval_y = labels[num_training : num_training+num_eval]\n",
    "    tes_y = labels[num_training+num_eval:]\n",
    "\n",
    "    return tr_X, eval_X, tes_X, tr_y, eval_y, tes_y, num_training, num_eval, tes_X_dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set has 185 samples and defection proportion = 0.622\n",
      "Validation set has 23 samples and defection proportion = 0.652\n",
      "Test set has 24 samples and defection proportion = 0.542\n"
     ]
    }
   ],
   "source": [
    "X_train, X_val, X_test, Y_train, Y_val, Y_test, num_training, num_eval, tes_X_dir = read_images(DATASET_PATH)\n",
    "defection_prec = lambda x: (len(x), sum(x)/len(x))\n",
    "\n",
    "print('Train set has %d samples and defection proportion = %.3f' % defection_prec(Y_train))\n",
    "print('Validation set has %d samples and defection proportion = %.3f' % defection_prec(Y_val))\n",
    "print('Test set has %d samples and defection proportion = %.3f' % defection_prec(Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "# an imaginary channel in the gray case\n",
    "if CHANNELS == 1:\n",
    "    X_train = np.expand_dims(X_train, axis=-1)\n",
    "    X_val = np.expand_dims(X_val, axis=-1)\n",
    "    X_test = np.expand_dims(X_test, axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # definec some wrappers with almost tunned parameters\n",
    "def conv2d(input, kernel_size, stride, num_filter):\n",
    "    stride_shape = [1, stride, stride, 1]\n",
    "    filter_shape = [kernel_size, kernel_size, input.get_shape()[3], num_filter]\n",
    "\n",
    "    W = tf.get_variable('w', filter_shape, tf.float32, tf.random_normal_initializer(0.0, 0.02))\n",
    "    b = tf.get_variable('b', [1, 1, 1, num_filter], initializer=tf.constant_initializer(0.0))\n",
    "    return tf.nn.conv2d(input, W, stride_shape, padding='SAME') + b\n",
    "\n",
    "def max_pool(input, kernel_size, stride):\n",
    "    ksize = [1, kernel_size, kernel_size, 1]\n",
    "    strides = [1, stride, stride, 1]\n",
    "    return tf.nn.max_pool(input, ksize=ksize, strides=strides, padding='SAME')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class BaseModel(object):\n",
    "    def __init__(self):\n",
    "        self.batch_size = 19\n",
    "        self.num_epoch = 10\n",
    "        self.log_step = 5\n",
    "        self._build_model()\n",
    "\n",
    "    def _model(self):\n",
    "        with tf.variable_scope('conv1'):\n",
    "            self.conv1 = conv2d(self.X, 7, 1, 32)\n",
    "            self.relu1 = tf.nn.relu(self.conv1)\n",
    "            self.pool1 = max_pool(self.relu1, 3, 2)\n",
    "        with tf.variable_scope('conv2'):\n",
    "            self.conv2 = conv2d(self.pool1, 5, 1, 64)\n",
    "            self.relu2 = tf.nn.relu(self.conv2)\n",
    "            self.pool2 = max_pool(self.relu2, 3, 2)\n",
    "        self.flat = tf.layers.flatten(self.pool2)\n",
    "        with tf.variable_scope('fc3'):\n",
    "            self.fc3 = tf.layers.dense(self.flat, 384)\n",
    "            self.relu3 = tf.nn.relu(self.fc3)\n",
    "        with tf.variable_scope('fc4'):\n",
    "            self.fc4 = tf.layers.dense(self.relu3, N_CLASSES)\n",
    "        return self.fc4\n",
    "\n",
    "    def _input_ops(self):\n",
    "        # Placeholders\n",
    "        self.X = tf.placeholder(tf.float32, [None, IMG_HEIGHT, IMG_WIDTH, CHANNELS])\n",
    "        self.Y = tf.placeholder(tf.int64, [None])\n",
    "        self.is_training = tf.placeholder(tf.bool, None)\n",
    "        self.lr = tf.placeholder(tf.float32, None)\n",
    "        \n",
    "\n",
    "    def _build_optimizer(self):\n",
    "        # Adam optimizer 'self.train_op' that minimizes 'self.loss_op'\n",
    "        gs = tf.Variable(0, trainable=False)\n",
    "        l_r = tf.train.exponential_decay(learning_rate=self.lr, global_step=gs,decay_steps=10, decay_rate=0.9, staircase=True)\n",
    "        optimer = tf.train.AdamOptimizer(l_r)\n",
    "        self.train_op = optimer.minimize(self.loss_op, global_step=gs)\n",
    "\n",
    "    def _loss(self, labels, logits):\n",
    "        # Softmax cross entropy loss\n",
    "        ls = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)\n",
    "        self.loss_op = tf.reduce_mean(ls)\n",
    "\n",
    "    def _build_model(self):\n",
    "        self._input_ops() # Define input variables\n",
    "        labels = tf.one_hot(self.Y, N_CLASSES) # Convert Y to one-hot vector\n",
    "        self.logits = self._model() # Build a model and get logits\n",
    "        self._loss(labels, self.logits) # Compute loss\n",
    "        self._build_optimizer()  # Build optimizer\n",
    "\n",
    "        # Compute accuracy and f1 score\n",
    "        self.predict = tf.argmax(self.logits, 1)\n",
    "        correct = tf.equal(self.predict, self.Y)\n",
    "        self.accuracy_op = tf.reduce_mean(tf.cast(correct, tf.float32))\n",
    "        TP = tf.count_nonzero(self.predict * self.Y)\n",
    "        TN = tf.count_nonzero((self.predict - 1) * (self.Y - 1))\n",
    "        FP = tf.count_nonzero(self.predict * (self.Y - 1))\n",
    "        FN = tf.count_nonzero((self.predict - 1) * self.Y)\n",
    "        precision = TP / (TP + FP)\n",
    "        recall = TP / (TP + FN)\n",
    "        self.f1_score = 2 * precision * recall / (precision + recall)\n",
    "\n",
    "    def train(self, sess, X_train, Y_train, X_val, Y_val, lr):\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        step = 0\n",
    "        losses = []\n",
    "        accuracies = []\n",
    "        val_accuracies = []\n",
    "        print('-' * 5 + '  Start training  ' + '-' * 5)\n",
    "        for epoch in range(self.num_epoch):\n",
    "            print('train for epoch %d' % epoch)\n",
    "            for i in range(num_training // self.batch_size):\n",
    "                X_ = X_train[i * self.batch_size:(i + 1) * self.batch_size][:]\n",
    "                Y_ = Y_train[i * self.batch_size:(i + 1) * self.batch_size]\n",
    "\n",
    "                feed_dict = {self.X: X_, self.Y: Y_, self.lr:lr}\n",
    "                fetches = [self.train_op, self.loss_op, self.accuracy_op]\n",
    "                # import IPython  # used for online debugging (we cannot do this using something like Pycharm, useful note for me) \n",
    "                # IPython.embed()\n",
    "\n",
    "                _, loss, accuracy = sess.run(fetches, feed_dict=feed_dict)\n",
    "                losses.append(loss)\n",
    "                accuracies.append(accuracy)\n",
    "\n",
    "                if step % self.log_step == 0:\n",
    "                    print('iteration (%d): loss = %.3f, accuracy = %.3f' %\n",
    "                          (step, loss, accuracy))\n",
    "                step += 1\n",
    "\n",
    "            # Print validation results\n",
    "            print('validation for epoch %d' % epoch)\n",
    "            val_accuracy, _, _ = self.evaluate(sess, X_val, Y_val)\n",
    "            val_accuracies.append(val_accuracy)\n",
    "            print('-  epoch %d: validation accuracy = %.3f' % (epoch, val_accuracy))\n",
    "\n",
    "#         ###################################\n",
    "#         # Plot training curve             #\n",
    "#         ###################################\n",
    "#         plt.title('Training loss')\n",
    "#         loss_hist_ = losses[1::len(losses)//20]  # sparse the curve a bit\n",
    "#         acc_hist_ = accuracies[1::len(accuracies)//20]\n",
    "#         plt.plot(loss_hist_, '-o')\n",
    "#         plt.plot(accuracies*100, '-s')\n",
    "    \n",
    "#         plt.xlabel('epoch')\n",
    "#         plt.gcf().set_size_inches(15, 12)\n",
    "#         plt.show()\n",
    "        return losses, accuracies, val_accuracies\n",
    "\n",
    "    def evaluate(self, sess, X_eval, Y_eval):\n",
    "        eval_accuracy = 0.0\n",
    "        eval_f1 = 0.0\n",
    "        eval_iter = 0\n",
    "        predicts = []\n",
    "        for i in range(X_eval.shape[0] // self.batch_size):\n",
    "            X_ = X_eval[i * self.batch_size:(i + 1) * self.batch_size][:]\n",
    "            Y_ = Y_eval[i * self.batch_size:(i + 1) * self.batch_size]\n",
    "            feed_dict = {self.X: X_, self.Y: Y_}\n",
    "            accuracy, f1, preds= sess.run([self.accuracy_op, self.f1_score, self.predict], feed_dict=feed_dict)\n",
    "            eval_accuracy += accuracy\n",
    "            eval_f1 += f1\n",
    "            eval_iter += 1\n",
    "            predicts += list(preds)\n",
    "        X_ = X_eval[(i) * self.batch_size:][:]\n",
    "        Y_ = Y_eval[(i) * self.batch_size:]\n",
    "        feed_dict = {self.X: X_, self.Y: Y_}\n",
    "        accuracy, f1, preds= sess.run([self.accuracy_op, self.f1_score, self.predict], feed_dict=feed_dict)\n",
    "        eval_accuracy += accuracy\n",
    "        eval_f1 += f1\n",
    "        eval_iter += 1\n",
    "        predicts += list(preds)\n",
    "            \n",
    "        return eval_accuracy / eval_iter, eval_f1/ eval_iter, preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----  Start training  -----\n",
      "train for epoch 0\n",
      "iteration (0): loss = 0.468, accuracy = 0.421\n",
      "iteration (5): loss = 0.181, accuracy = 0.789\n",
      "validation for epoch 0\n",
      "-  epoch 0: validation accuracy = 0.620\n",
      "train for epoch 1\n",
      "iteration (10): loss = 0.302, accuracy = 0.789\n",
      "iteration (15): loss = 0.095, accuracy = 0.947\n",
      "validation for epoch 1\n",
      "-  epoch 1: validation accuracy = 0.760\n",
      "train for epoch 2\n",
      "iteration (20): loss = 0.196, accuracy = 1.000\n",
      "iteration (25): loss = 0.326, accuracy = 0.842\n",
      "validation for epoch 2\n",
      "-  epoch 2: validation accuracy = 0.808\n",
      "train for epoch 3\n",
      "iteration (30): loss = 0.113, accuracy = 0.947\n",
      "iteration (35): loss = 0.399, accuracy = 0.895\n",
      "validation for epoch 3\n",
      "-  epoch 3: validation accuracy = 0.808\n",
      "train for epoch 4\n",
      "iteration (40): loss = 0.181, accuracy = 0.947\n",
      "validation for epoch 4\n",
      "-  epoch 4: validation accuracy = 0.808\n",
      "train for epoch 5\n",
      "iteration (45): loss = 0.191, accuracy = 0.947\n",
      "iteration (50): loss = 0.027, accuracy = 1.000\n",
      "validation for epoch 5\n",
      "-  epoch 5: validation accuracy = 0.808\n",
      "train for epoch 6\n",
      "iteration (55): loss = 0.054, accuracy = 1.000\n",
      "iteration (60): loss = 0.019, accuracy = 1.000\n",
      "validation for epoch 6\n",
      "-  epoch 6: validation accuracy = 0.808\n",
      "train for epoch 7\n",
      "iteration (65): loss = 0.059, accuracy = 1.000\n",
      "iteration (70): loss = 0.387, accuracy = 0.842\n",
      "validation for epoch 7\n",
      "-  epoch 7: validation accuracy = 0.808\n",
      "train for epoch 8\n",
      "iteration (75): loss = 0.032, accuracy = 1.000\n",
      "iteration (80): loss = 0.332, accuracy = 0.895\n",
      "validation for epoch 8\n",
      "-  epoch 8: validation accuracy = 0.808\n",
      "train for epoch 9\n",
      "iteration (85): loss = 0.164, accuracy = 0.947\n",
      "validation for epoch 9\n",
      "-  epoch 9: validation accuracy = 0.808\n",
      "***** test accuracy: 1.000, f1: 1.000\n",
      "preds [1 0 1 1 0 0 0 1 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 1]\n",
      "Y_test [1 0 1 1 0 0 0 1 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 1]\n"
     ]
    }
   ],
   "source": [
    "tf.reset_default_graph()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    with tf.device('/cpu:0'):\n",
    "        model = BaseModel()\n",
    "        lr = 1e-4\n",
    "        losses, accuracies, val_accuracies = model.train(sess, X_train, Y_train, X_val, Y_val, lr)\n",
    "        accuracy, f1, preds = model.evaluate(sess, X_test, Y_test)\n",
    "        print('***** test accuracy: %.3f, f1: %.3f' % (accuracy, f1))\n",
    "        print(\"preds\", preds)\n",
    "        print(\"Y_test\", Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, x in enumerate(preds):\n",
    "            if x!=Y_test[i]:\n",
    "#             if Y_test[i]==1:\n",
    "                print(\"Pred:\",x, \",label:\", Y_test[i])\n",
    "                plt.imshow(np.squeeze(X_test[i], axis=-1), cmap='gray')\n",
    "                image = cv2.imread(tes_X_dir[i], cv2.IMREAD_UNCHANGED)\n",
    "                plt.imshow(image)\n",
    "                plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_accuracies = [0.6201372742652893,\n",
    " 0.7597253918647766,\n",
    " 0.8077803254127502,\n",
    " 0.8077803254127502,\n",
    " 0.8077803254127502,\n",
    " 0.8077803254127502,\n",
    "0.8077803254127502,\n",
    " 0.8077803254127502,\n",
    " 0.8077803254127502,\n",
    " 0.8277803254127502,\n",
    "                  0.8277803254127502,\n",
    "                  0.8277803254127502,\n",
    "                  0.8277803254127502,\n",
    "                  0.8277803254127502,\n",
    " 0.9077803254127502,\n",
    " 0.9077803254127502]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA44AAALMCAYAAACrEOxHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZxWdfn/8fdhk00QBGbAUNx3FIS5tdTSUlNSFCorM1PBXdPM1BYtv1muaYq4Ydmifr8Wo1hhmr+sMbV7ZHFBQXFBvW+YYZd9mzm/P645zQCz3Ms59znnPq/n4zGPE/fc9znXjHA612e5Lsd1XQEAAAAA0JZOYQcAAAAAAIg2EkcAAAAAQLtIHAEAAAAA7SJxBAAAAAC0i8QRAAAAANCuLmEHEBUDBgxwhw0bFnYYAAAAABCKmTNnLnVdd2Br3yNxbDJs2DDNmDEj7DAAAAAAIBSO43zY1vdYqgoAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaBeJIwAAAACgXSSOAAAAAIB2kTgCAAAAANpF4ggAAAAAaFcsEkfHcX7tOM5ix3HmtHitv+M4f3ccZ37TsV/T647jOHc5jvOu4zivO44zMrzIgYSorJQcZ/uvysqwIwtPlH4nUYklKnFELRZEF39PWheV30tU4ohSLFGJA2XJcV037Bg65DjO0ZLWSPqd67oHNb12i6Tlruve5DjONZL6ua57teM4J0m6VNJJklKSfuW6bqqja4waNcqdMWNGcD8EUM4cp+3vxeAeE4go/U6iEktU4pCiFQuii78nrYvK7yUqcUjRiSUqcSC2HMeZ6bruqNa+16XUwRTCdd0ax3GGbfPyWEmfa/rfv5X0T0lXN73+O9cy4v84jrOT4ziDXdddVJpoAaAD55wTdgTNohJLVOIAUJyo/FuOShxStGIBihCLxLENFV4y6LruIsdxBjW9voukj1u8L9P02naJo+M450k6T5J23XXXYKMFAM9zz4UdQbOoxBKVOAAUJyr/lqMShxStWIAixDlxbEtrc/Stzs27rvuApAckW6oaZFAA8F8ffVTa67W3dKmUsUQlDqn9WAAUjnvK9qLyOwGKFIviOG2odxxnsCQ1HRc3vZ6RNLTF+z4laWGJYwMAAACAshHnxPEpSWc1/e+zJE1r8fq3mqqrHi7pE/Y3AgGrqMjv9SSI0u8kKrFEJY72rjlwYGnjQLRF6e9slETl9xKVONq7ZlR+JzvtVNo4UJZikTg6jvOYpJcl7es4TsZxnHMl3STpOMdx5ks6runPkjRd0vuS3pX0oKSLQggZSJa6OumNN5r/fNRRVr2tri68mMJWVyfdeKP97+XL7fcR1u+krq75+i2/Sh1LVOJoLZb586Xu3aXPfIbKg2i2aJG0117S8cdL119vywBXrUr2vU2Spk+342OPcU+JWizbxrF5szRihN3fVqwobSwoO7FIHF3X/brruoNd1+3quu6nXNd9yHXdZa7rft513b2bjsub3uu6rnux67p7uq57sOu69NgASiGbtePIkdLMmdKWLeHGEwW1tdI++0j9+oUdCTqy117ST38qPfmkVF0ddjSIijlzpHfflcaPl1IpexCfOTPsqMJXW2vHVIfdzhC2Ll2kKVOkJUuk738/7GgQc7FIHAHEgJc4jhsnrVsnvflmuPGEzXWldJoHqzj57ndtZP6SSxiZh6mutlnGsWOlqip7LZ0ON6YoSKdtWfewYWFHglyMHGn3tylTpOefDzsaxBiJIwB/ZDJ2PO00Oyb94erjj23JkPewiehjZB7bqq6WjjzS9o3tvLO0557c2yT7HVRVUcEzTn7yE/v7e9550vr1YUeDmCJxBOCPbNZGoPffX+rfn4cr7+dnxjFeRo6UrrySkXnYEtXXX7dVFJ5UinvbJ59I8+Zxb4ubnj2lBx6wv9c33BB2NIgpEkcA/shmpU99ykagq6qa98AkVW2ttMMO0iGHhB0J8nX99YzMo3mvq7eKQrJkaeHC5qX5STRjhi3FJ3GMn2OPlc45R7r1Vmn27LCjQQyROALwRyYj7bKL/e9UyvY4rl4dbkxhSqdtv1y3bmFHgny1HJn/6U/DjgZhqa6WDjtM2m235te8ZCnJs47ezz56dLhxoDC33ioNGCBNmEARO+SNxBGAP7wZR6m5+uCMhBY13rLFKi+yvzG+vJH5225jZD6JMhlLkFouU5VsBUHXriSOVIuOr/79pbvvlmbNku68M+xoEDMkjgCKt2GDtHRp84xj0qsPzpljlWVZyhVvt93GyHxSPfmkHbdNHLt3lw49NLn3NqpFl4cvf9kqBV93nfTee2FHgxghcQRQvIUL7egljl71waTuc6THWXno10+aNMlG5u+4I+xoUErV1dIBB0j77bf991IpW03R0FD6uML28cdSfT33trhzHOmee2z2/LzzbEAAyAGJI4DieYUivKWqUrKrD6bTljzvsUfYkaBY48c3j8y/+27Y0aAUli6V/vWv7WcbPamUtHat9NZbpY0rCqgWXT522UW6+WbpH/+QHn447GgQEySOAIrn9XD0Zhyl5uqD3veShB5n5cMbme/WTTr/fEbmk+Cpp6TGxrYTxyQvxU+nrVr08OFhRwI/nHeedNRR1oKori7saBADJI4AiufNOG6bOErJe7hatcpmIhiRLx+77CLdcgsj80kxdao0bJjtZWzN3nvbMuak3dskqkWXm06dpAcftBn073wn7GgQAySOAIqXzUq9e0t9+jS/5lUfTNo+x5kz6XFWjiZOZGQ+CT75RHruOZttbGvFQFJ71XrVorm3lZd997Wl+I8/brPtQDtIHAEUz+vh2PJBK6nVB72fl1Yc5aXlyPxll4UdDYIyfbq0aVPby1Q9qZRVT16zpjRxRcGcOdL69SSO5eiqq6SDD5YuusgGT4A2kDgCKF42u/UyVU8Sqw+m09Jee1mvLJQXb2T+j3+Upk0LOxoEobpaqqyUjjii/fdVVdk+yJkzSxNXFDAoVr66dZOmTJEWLZKuvTbsaBBhJI4AipfJbF1R1eNVH3zzzdLHFAZ6nJW/73+fkflytX69zTieeqrNMLcniQVy0mnra0q16PJUVWX7HO+9V/r3v8OOBhFF4gigOI2NNkrZ2oyj93CVlL1A2az9Lkgcy1fXrjYyX1fHyHy5efZZad06a8HSkYEDLYFKyr1Nsp+VatHl7X/+xwpDTZwobdgQdjSIIBJHAMVZvNiKJrQ245i06oP0OEuGliPzL7wQdjTwS3W13a8++9nc3l9VlZx7G9Wik6FXL+m++6R586Qbbww7GkQQiSOA4rTWw9HjVR9MysNVOm17RQ45JOxIEDRG5svL5s1WUfKUU2xWOReplN3/Fi4MNrYomDHDluKzv7H8nXCCdOaZ0k03SW+8EXY0iBgSRwDFaa2HY0uplO1xTEL1wXTaKsnusEPYkSBovXpJ998vvf02I/Pl4PnnpZUrO66m2lKSetVSGCdZ7rjDZt8nTEhWcTt0iMQRQHG8xLG1papScqoPbtlio/Is5UqO44+XvvUtRubLQXW1DQYcd1zunxkxQurSJRn7HGtrbesB1aKTYeedpV/9yv67T5oUdjSIEBJHAMXJZOzhadCg1r+flOqDb71lhTVIHJPll79kZD7uGhqkJ5+UTjpJ6tEj9891727L0sv93ka16GT62tfs38QPfiAtWBB2NIgIEkcAxclmpcGD2y5f71UfLPeHK5ZyJVPLkfm77w47GhTi5Zel+vr8lql6UinplVfKe9Agk7Fq0dzbksVxrABYp07SBRfYAAISj8QRQHHa6uHYUhIK5KTTtoxrr73CjgSl9rWvSWPGSD/8ISPzcVRdbUWtTjop/8+mUrZ/e+5c/+OKCqpFJ9euu0q/+IX0zDPSI4+EHQ0igMQRQHGy2bYL43hSKXuftx+yHNHjLLkcR5o8mZH5OHJdSxyPP17q0yf/z3vJVDnvc6ytpVp0kl14oXTEEdLll0tLloQdDUJG4gigcK6b24xjuT9crVljlWMZkU8uRubjafZs6cMPC1umKlnBmL59y3tFRTpthYCoFp1MnTtLDz5ovTyvuCLsaBAyEkcAhVu1Slq7tuMZR6/6YLk+XM2YYZVj2QOUbIzMx091tT0Yn3xyYZ/v1Km8l+J71aK5tyXbgQdakZxHHpGefjrsaBAiEkcAheuoh6On3KsPUhgHkiUgU6bYgMrll4cdDXIxdar02c9KAwYUfo5UytqxrF3rX1xR8eabVIuGufZa6YADpPPPl1avDjsahITEEUDhOurh2FIqZSPX5Vh9sLZW2nPP4h4+UR4OOMCK5Dz6qDR9etjRoD1z50rz5hW+TNWTStmKg1mz/IkrSrztBSSO2GEHGxjLZKQf/SjsaBASEkcAhctk7NjRjKNU3tUH6XGGlq65xhLICy5gZD7KqqvteOqpxZ2nnHvVetWi99wz7EgQBUccIV18sbUe+s9/wo4GISBxBFA4b8ZxyJCO3+slVuX2cOVVi2WZKjwtR+Z/+MOwo0Fbqqulww/PbeCrPYMGScOGld+9TbKfiWrRaOnnP7dVRhMmSJs2hR0NSozEEUDhMhlbntm9e8fv9aoPlltlVXqcoTVHHCFdcok0aZI1mEe0LFhgS0vHj/fnfKlU+d3bVq+mWjS2t+OO0r332t+Nm24KOxqUGIkjgMLl0sPRU67VB2trpa5dpUMPDTsSRM2NNzIyH1VPPGHH007z53yplPTRR1JdnT/ni4KZM63lEokjtjVmjPT1r0s/+5n01lthR4MSInEEULhsNrfCOJ5yrD6YTlvSmMusK5Jlxx2l++6zBytG5qOlutoqPfu1d68c9zlSLRrtufNOu8dNnGjFoZAIJI4ACpfJ5Lc/yKs+OHNmcDGVUkMDPc7QvpNOkr7xDUbmo6SuTnrxxeKrqbY0cmT59apNpy2x3nnnsCNBFA0aZMnjSy/ZABkSgcQRQGE2brQm5/kkjl6CVS57gd56yyrFspQL7bnzTqlPH0bmo+LJJ20Jpp+JY48e0vDh5XNvk6gWjY5985vS8cdLV18tffxx2NGgBEgcARRm0SI75rNUtdyqD9LjDLkYOFC64w4bmb/33rCjQXW1Fes68EB/z5tKSa+8Uh6DA9mstHAh9za0z3FstrGxUbroIhuQQVkjcQRQmHx6OLaUSpVP4phOSzvtZA+hQHu8kflrrmFkPkzLl0vPP2+zjX63mKiqklatkubN8/e8YaBaNHK1++62FP8vf5EefzzsaBAwEkcAhfF6OBaSOH78cfOMZZzR4wy5chzp/vsZmQ/bX/4ibdni7zJVTzn1qk2nrVr0IYeEHQni4LLLpNGjpUsvlZYtCzsaBIjEEUBhvBnHfJaqSuWzz3HNGmnOHEbkkbthw6xFx1/+Iv3f/4UdTTJVV9s9a/Ro/8+9777l06uWatHIR+fO0pQp0ooV0pVXhh0NAkTiCKAw2azUs6c9KOWjXKoPzppls0ckjsjHpZda0nLZZYzMl9qaNdIzzwSzTFWyXrWjR8f/3uZVi+behnwMH25Fcn77W+nvfw87GgSExBFAYbwejvk+gHnVB+P+cEWPMxSCkfnw/O1v0oYNwSxT9VRVSa+/Lq1bF9w1gvbWW9Zrl8QR+frRj2zm/fzzy6tfM/6LxBFAYfLt4diSV32wocHfmEopnbaiAAMHhh0J4mb4cCuSw8h8aVVX27/XI48M7hqplN3XZs0K7hpBY1AMhereXXrwQemDD6Trrw87GgSAxBFAYbLZwhPHqipp9Wrp7bf9jamU6HGGYvzwh4zMl9LGjba3dOxYm/UNindPiPM+x3Ra6tePatEozFFHSRdcYC2IZswIOxr4jMQRQP4aG63HV76FcTxxrz64cKHNuJI4olAtR+avuy7saMrfc8/ZYFWQy1QlqaJC2m23+N7bJEt6qRaNYtx0k1RZKZ17rrR5c9jRwEckjgDyt2SJ/Z9BoTOOXvXBuD5cebMJJI4ohjcyf+edtnQbwamulvr0kY49NvhrVVXF995GtWj4oW9fafJk2+97221hRwMfkTgCyF+hPRw9ca8+mE5bZdhDDw07EsTdTTfZ0ZvhaflVWVnaWCort48hjDj8tmWLNG2a9KUvSTvsEPz1Uinpww+l+vrgr+W3mTNtRQn7G1GssWPt39sPfhD+PaVc720hIHEEkL9Cezi2VFUlvfFGPKsPptPWGLtHj7AjQdz17WsP6q0pdeLR1vXimAC19MIL1vpk/PjSXC/O+xwpjAM/bdzY+uvc22KrS9gBAIihYmccpa2rDwZZ5dBvXo+zM88MOxIkwZgxYUcQf9XVNshzwgmlud7IkVaAJ52WTj65NNf0S22ttMceVItG8Li3xRKJI4D8ZbP2YFRRUfg5WhbIiVPiOG+eFdlgDxBKYfHisCOIt8ZG6YknpC9+UerVqzTX7NlTOvjgeC7FT6dt7y0QNO5tsUTiCCB/mYw0eHBxZe3jWn2QpVwopVIWzSnHKpqvvGIDXUFXU91WKiU99pglrp1isivIqxbNvQ2lwL0tlmJyNwMQKcX0cGypqip++4DSaduXts8+YUcCoCPV1VbI6ktfKu11Uylp1SrpnXdKe91ieINirKYA0AYSRwD5y2aLK4zjiWP1Qa/HWVxmERB9bS35LmYpuJ9x9OtX2jj84rrS1KnS5z8v7bRTaa/tzdrFaUVFba3Utas0YkTYkaBcRP3e1rNnaeMoAzz5AMhfJuPPjGPLfY5xsG6dVYJlRB5+qquzJGfbr7q6cONYv7655+rataWNxQ9vvCG9917pl6lK0n77STvuGJ97m9RcLbp797AjQbmI6r3NdaXzz5c2bKCHbp5IHAHkZ9UqKw7jR+LYsvpgHMycaVVV2QOEJOjeXXrwQWnBAunHPw47mvxVV9veprFjS3/tzp3j1au2ocEeoLm3ISluvtn6OE6YIG3eHHY0sUHiCCA/XisOP5aqetUH47LPkT1ASJqjjpIuuED61a/i8+/UU11t8Zd6WZwnlZJef91mbqNu7lxpzRrubUiOvn2lyZPt3+itt4YdTWyQOALIjx89HFtKpeyBtK0m6FFSWysNGyYNGhR2JEDp3HRT/Ebm58+3paphLFP1VFVJW7ZIs2eHF0OuvEEBEkckydix0pe/LN1wg/T222FHEwskjgDyE0TiuGpVPG7a6TQPVkgeb2T+jTfiMzL/xBN2PO208GKI0x7udNoKCO29d9iRAKV1991Sjx7SeefFYwA7ZCSOAPKTydjRz8RRiv7DVV2d9NFH7AFCMo0dK33lK/EZma+ulkaNknbdNbwYBg+Whg6N/r1NshhHj6ZaNJKnslK6/Xappsb2dKNd3CEA5Ceblfr3txE6P+y7r1UfjPr+KfY3Iunuusv+3U+cGO2R+UzG/r2GuUzV4y3Fj7K1a6kWjWQ7+2zp2GOl73+/eVUVWkXiCCA/fvVw9MSl+mBtrTUSHzky7EiAcHgj8y+8EO2ReW+ZahQSx6oq6YMPpCVLwo6kbbNm2UAAiSOSynGk+++XNm2SLr7Y2nWgVSSOAPLjVw/HluJQfTCdloYP92+mFYijOIzMV1dLBxxgqxnCFoel+F5sLMNHku21l/TTn0rTptk9BK0icQSQn2w2mMQxytUHGxvpcQZINjL/wAPRHZlfssT2KkVhtlGSDjvMVlVEeblqOk21aECSvvtdacQI6ZJLpBUrwo4mkkgcAeRu0yapvt7fpapSc0IW1VH5efOs8itLuQBpzz2tSM60adLUqWFHs7WnnrKBnvHjw47E9OolHXRQdO9tEtWiAU+XLtKUKTYAddVVYUcTSSSOAHK3aJEd/Z5xjHr1QXqcAVu74opojsxXV0u77y4dckjYkTSrqopur9pFi6SPP+beBnhGjpSuvFJ66CHpH/8IO5rIIXEEkDu/ezi2lEpFN3FMp6U+faKxZwqIgi5d7MFq6dLojMx/8on03HO2TNVxwo6mWSolrVwpzZ8fdiTbY1AM2N7119vKivPOi3bthRCQOALIndfD0e+lqpI9uCxYIC1e7P+5i0WPM2B7I0ZI3/tedEbmp0+35fRR2d/o8ZKyKO5zTKdtEGDEiLAjAaKjZ0+rHP3ee1YwB//FUxCA3AU54+jtc4zaw9W6dVbxlRF5YHstR+bXrQs3lupqaxly+OHhxrGt/feXeveO5ooKqkUDrTvmGOncc6XbbrOWNZBE4gggH9msPWD06+f/ub3qg1F7uJo9W2poIHEEWtOjRzRG5tetsxnH006L3sqAzp2lUaOid2/zqkVzbwNad+ut0oAB0oQJVvkdJI4A8uD1cAxi/1BUqw/S4wxonzcyf/vt4Y3MP/usJY9RW6bqSaWk116TNmwIO5Jm8+ZJq1eTOAJt6ddPmjTJBpDvuCPsaCKBxBFA7oLo4dhSKmUj4FGqPphOS7vuakvgALTu1lulgQPDG5mvrpb695c++9nSXzsXqZS0ebP06qthR9KMQTGgY+PHS6eeKl13nfTuu2FHEzoSRwC5y2SCKYzjqaqKXvVBepwBHWs5Mv/LX5b22ps2SX/+s3TKKVLXrqW9dq68e0iUVlSk01LfvlSLBtrjOHZv69ZNOv98yXXDjihUJI4AcuO60sKFwc84StF5uKqvlz78kMQRyMW4cTYyf/31pR2Z/+c/bcApqstUJWnIELt3RuXeJlkhMqpFAx3bZRfpllusevRvfhN2NKHibgEgN0uX2sh+kIlj1KoP0uMMyF3LkfnzzivdyHx1te2RPu640lyvUFHqVUu1aCA/EydKRx8tXXmlVFcXdjShIXEEkJsgezh6One2EfCotORIpy2mkSPDjgSIh112sf2Ozz9fmpH5hgbpySelMWOk7t2Dv14xUinp/fdtEC5ss2bZ7479jUBuOnWSHnhAWr9euuyysKMJDYkjgNwE2cOxpaqq6FQfTKelgw+2ZsAAcjNhQvPI/KJFwV7r5ZdtSXmUl6l6vNm9KAyMeTOfzDgCudt3XyuS88c/StOmhR1NKEgcAeTGSxyDnHGUmqsPzp4d7HU6Qo8zoDClHJmfOtWWxp50UrDX8cNhh9nvJgrLVWtrpd12kyoqwo4EiJerrrIB5Ysukj75JOxoSo7EEUBuMhl76An6QSMqBXLeecf+T4HEEcifNzL/pz/ZUtIguK7tbzz+eGnHHYO5hp9695YOPDD8e5tEtWigUF27Sg89ZPscr7km7GhKjsQRQG6yWetl2KVLsNcZMsRmNcNezkWPM6A4V10lDR8uXXxxMCPzs2ZJH31kfdbiIpWye1uYJf29atHc24DCjB4tXX65dN990gsvhB1NSZE4AshN0D0cW6qqCn9UPp22WYz99gs3DiCuunaVpkyxkfmrr/b//NXVVrzq5JP9P3dQUilpxYpwG4mzvxEo3g03SMOG2Z7uKNRkKBESRwC5yWaDL4zj8aoPLllSmuu1xutx1rlzeDEAceeNzN9/v1RT4++5q6ulz31O2nlnf88bJG+WL8yBsdpaqkUDxerVy+5r77wj/exnYUdTMiSOAHJT6sRRCm+56vr1VtmVEXmgeDfcIO2+u/VB82tkfu5cad68eFRTbenAA+2BM8zEMZ22JcRUiwaKc/zx0re+Jd18s/VFTQASRwAdW7PG9iiVaqmqV30wrMRx9mxpyxb2AAF+CGJkvrrajqee6s/5SqVzZ2nUqPDubY2Ndm3ubYA/fvlLqV8/W7La0BB2NIEjcQTQsVL1cPSEXX2QPUCAv447TjrrLP9G5qurpSOOsGJacVNVJb36qrRxY+mv/fbb0qpV3NsAv+y8s3TXXda+6+67w44mcCSOADpW6sRRCrf6YG2tNHSoNHhw6a8NlKvbb/dnZP6DD6yiatyWqXpSKWnTJkseS82b6SRxBPxz+unSmDHSD39o96cyRuIIoGOZjB1LtVRVaq4+OH9+6a7poccZ4L+WI/N33VX4eZ54wo5xThylcFZUUC0a8J/jSPfea1tsLrgg3HY7ASNxBNCxMGYcvT04pd4LtGSJjRiyBwjw3+mnS1/6kvSjHxU+Ml9dLR16qLTHHv7GViqf+pQtsQ1jn2M6bZVuO/H4B/hq6FDpppukZ5+V/vCHsKMJDHcOAB3LZm2JWSmr8IVVfZD9jUBwHEeaPLnwkflFi6SXXirZbGNlpYW87VdlZZEnLqBXbdGxrF9v+0u5twHBuPBC23t9+eXS4sVhRxOILmEHACAGMpnSzjZKzdUHS504ej3ODjustNcFksIbmb/kEun3v7dy9rmaNs2SzRIljvX1bb8+b14RJ979ROnJudJ/Vkg79Ss6lpx41aJJHIFgdOokTZkijRhhyeOjj4Ydke9IHAF0rJQ9HFtKpaQ77rDeb927l+aa6bR00EE22wkgGBdeaA9VV1whffGL0qBBuX2uulraZx/pgAOCjS8H++9fzKfPs68jfAomF94gHMvwgeAccIAVybn+eumMM6xoThkhcQTQsUxGOuSQ0l+3qkravFl67bXSjJJ7Pc6+8pXgrwUkWadO0oMP5jcyv3y59Pzz0ve+Z2s0Q/bYY0V8eP166ZxzpPHjpS9/OaePfP3rRVxPssSRatFA8K65Rnr8cRsge/NNK0hVJkgcAbRv82ZbCxXWjKNUuiqn8+dLK1eylAsohXxH5v/yF1tqGZFqql/7WjGf7iHd/oa07hPpayVMHLm3AcHr1s0Gxj7zGbvHFVNFOmIojgOgfXV1tqcojMTRqz5Yqn2O9DgDSuuaa6wQ1oUXSqtXt//eqVPtnjBqVGliC1ope9UuXiwtWMC9DSiVI46wfdyTJkkvvxx2NL4hcQTQvjB6OLaUSpUucUynpd69i928BCBX3bpZMYlMRvrBD9p+35o10jPP2GxjCZepDhjQ+usVFT6cPJWSli2T3nsvp7e3dc2cYmFQDCi9G2+05eHnnitt3Bh2NMNTrWMAACAASURBVL6IfeLoOM53HMeZ4zjOm47jXN70Wn/Hcf7uOM78pmNuJcsAbC+MHo4tVVXZg9WyZcFfK5222YzOnYO/FgBz+OHSpZdK99xjrTZa8/TT9uA1fnxJQ/vWt6QuXaSFC21i0Puqq/Ph5F4Sl2M/R2/xx7ZfOcWSTtt9beTIwuMFkJ8dd5Tuu0+aO9cqSZeBWCeOjuMcJGmipCpJh0j6kuM4e0u6RtL/c113b0n/r+nPAArhJY5hzjhKwTfL3rChdEV4AGztZz+zkfkJE1ofma+ulgYOtD1DJbJ2rfTrX1vtmkDqyRx4oPXGLcWKCqpFA+E48UTpG9+w2ce33go7mqLFOnGUtL+k/7iuu8513S2S/iXpNEljJf226T2/lXRqSPEB8ZfJSDvsIPXvH871R42ypWlBP1y9+qoVAiJxBEqv5cj8L36x9fc2bLDCOKeeWtLVAI8+arWyLrkkoAt06WL9YoO+tzU2Sq+8wr0NCMudd0p9+tjAWEND2NEUJe6J4xxJRzuOs7PjOD0lnSRpqKQK13UXSVLTMccGUQC24/VwDKv8/Y472sh80DOO3sMbD1dAOE480aqr/vznVsLe8//+n+1xLGE1VdeV7r5bOvRQ6dOfDvBCqZQ0e7a0aVNw16BaNBCugQMteXz5Zenee8OOpiixThxd150r6WZJf5f0N0mvSdqS6+cdxznPcZwZjuPMWLJkSUBRAjGXyYS3TNVTVRV89cF02hLkIUOCuwaA9t1xx/Yj89XV9tqxx5YsjBdekN54w2YbAx0zS6UsaXztteCu4Q2KVVUFdw0A7TvjDOmEE6Rrr5U++ijsaAoW68RRklzXfch13ZGu6x4tabmk+ZLqHccZLElNx8VtfPYB13VHua47auDAgaULGogTb8YxTHlWHywIPc6A8Hkj8//5j43Mb9kiTZsmnXyyVWAtkUmTpH79fOid2BEvmQtyuSrVooHwOY4tx29stPZDpWjDE4DYJ46O4wxqOu4qaZykxyQ9JemsprecJWlaONEBMee60UkcpeAerpYuld5/n8QRiIIzzrAk8dJLpa5dbdDokUfswauyMvDLZ7M2yXnuuVa7JlBDh9rPFGTiWFsrjR5NtWggbMOG2b/D6dOlTp3snuZ9leDe5ofYJ46SpjqO85akP0u62HXdFZJuknSc4zjzJR3X9GcA+Vq2zCochr1U1as+GNQ+R3qcAdHhOG3v+auvD/zy99/fPCkQOMex+05Q9zaqRQPRsnp166+X4N7mhy5hB1As13WPauW1ZZI+H0I4QHkJu4ejJ+jqg+m0jf4ddlgw5wcQCxs3WuI4Zoy0xx4lumgqZctxV6yw9bF+mj3bqkWzvxGAD8phxhFAUMLu4diSV32wtR5vxUqnbVazd2//zw0gNqZOlRYvDrAFR2u8pC6IWUeqRQPwEYkjgLZlMnYMe8ZRCq76oOvaAxsPVkDiTZok7b23dNxxJbzo6NHB9aqtrbWBP6pFA/ABiSOAtmWz0dm07SV2fo/Kv/uuLREjcQQSbeZMa7N28cW2cr1k+vSxiqdBzThybwPgExJHAG3LZCxp7No17Ehs1DyI6oP0OAOip6Iiv9d9cM89Uq9e0llndfxe36VSdi/ys0T/kiVWLZp7GxAdIdzb/ETiCKBtUWjF4fGqDwaROPbqZXscAURDXZ0lUdt+1dUFcrlly6RHH5XOPFPaaadALtG+qiprC/TBB/6dk2rRQPSU+N7mNxJHAG2LUuIo2QPQ/PnS8uX+nbO2Vho1ih5nQII99JDV3br44pACCKJXbW0t1aIB+IrEEUDbMploVFT1eA9Xr7ziz/k2bpRefZUReSDBGhqkyZOlz31OOuigkII4+GCpRw9/9zmm0/YDUS0agE9IHAG0bt06aeXKaM04jhrlb/XBV1+1Sq3sAQIS669/lT78sMQtOLbld69ar1o09zYAPiJxBNC6KPVw9HjVB/16uKLHGZB4kybZbW7s2JADqaqSZs2ywaxizZ9PtWgAviNxBNC6KPVwbMnP6oO1tdbfLErJMYCSmTdP+vvfpQsusEm/UKVStnz+9deLPxeFcQAEgMQRQOu8GccoJo7LlvlTfTCdZikXkGCTJ0vdukkTJ4YdifztVetViz7ggOLPBQBNSBwBtC6qM45eolfsctVly6R332VEHkio1aulhx+WvvpVadCgsKORtOuu1svNj6X46TTVogH4jsQRQOuyWalv3+hV5POqDxb7cMVSLiDRfvc7Sx5DLYrTkuPYwFix97YNG6gWDSAQJI4AWhe1Ho4ev6oP1tbag9qoUf7EBSA2XNeK4oweHbH8KpWS3n7bCtsU6rXXpM2bI/aDASgHJI4AWhe1Ho4tpVLS7NnFVR9Mp23/z447+hcXgFj4xz+sME5kZhs9XrI3Y0bh5/AG1di/DcBnJI4AWhfVGUfJHoiKqT7o9ThjRB5IpEmTpAEDbH9jpHgrIIpZUZFOUy0aQCBIHAFsb8sWqa4uuomjl/AV+nD13ntWHIfEEUicDz+UnnrKKql27x52NNvYaSdpv/2KTxy5twEIAIkjgO3V1UmNjdEdsS62+iCFcYDEuu8+O15wQbhxtKmYXrXLltnAGPc2AAEgcQSwvaj2cPQ4jj0YFdrvLJ2WevaUDjzQ37gARNqGDdKDD0pjx9r4UySlUtKSJTY1mi/vnsj+RgABIHEEsD2vh2NUZxwlezAqtPpgOm2VWbt08T8uAJH1f/9nk3KRK4rTUjG9atNpqkUDCAyJI4DtRX3GUWpeivXKK/l9buNGq8jKUi4gUVxXuvtuaf/9pWOOCTuadgwfbpsvC00cDzyQatEAAkHiCGB72azUrZuVHYyq0aNtZD3fh6vXX7c2HiSOQKLU1kozZ9pso+OEHU07unaVRo7M/95GtWgAASNxBLC9TMZmG6P8dNW3r1UfzHefIz3OgESaNMkm4s48M+xIcpBKSbNmSZs35/6Z996Tli/n3gYgMCSOALYX5R6OLVVV5V99MJ2WKiuloUODiwtApNTXS48/Ln372zFZxVlVZZV83ngj9894g2LMOAIICIkjgO3FJXH0qg8uWJD7Z7weZ1GeTQXgqylTbIX6RReFHUmOCulVS7VoAAEjcQSwNde1papRrqjq8R6ucl2uuny5NH8+I/JAgmzZIt17r3Tccba6PRaGDZMGDsxvKX5trVVTpVo0gICQOALY2ooVtkQqDjOOBx+cX/VBrwIre4CAxJg2zRZRRLoFx7a8XrW53tu8atHc2wAEiMQRwNbi0MPRk2/1Qa/H2ejRwcYFIDImTZJ2200aMybsSPJUVSXNmyd98knH733tNapFAwgciSOArcWhh2NL+VQfTKetiVufPsHHBSB0c+ZI//yn7W3s3DnsaPKUStnWgVx61VIYB0AJkDgC2FocE8dcqg/S4wxInEmTbDX7ueeGHUkBvGWnuexzrK2VBg+Ox0oRALFF4ghga5mMLeccPDjsSHKTa/XBDz6Qli5lDxCQECtXSr//vfT1r0s77xx2NAXYaSdp331zW4qfTtu9jWrRAAJE4ghga9msNGiQ1K1b2JHkZrfdrPpgRw9XLOUCEuXhh6V162JWFGdbufSqpVo0gBIhcQSwtbj0cPTkWn0wnZZ69LBKrADKWmOjdM890hFHWP2s2EqlpPp66aOP2n6Pt5SVxBFAwEgcAWwtLj0cW0qlOq4+WFsrHXYYPc6ABHj2Wendd2M+2yjl1qu2ttYG0EaNKk1MABKLxBHA1uI24yg1P1y1VX1w0yarvMr+RiARJk2SKiqkL3857EiKNHy4tMMO7a+ooFo0gBIhcQTQbP162y8TtxlHry9jWw9Xr79uDbJZygWUvffek6ZPl84/Pz5btdvUrZs0YkTb9zbXte9xbwNQAiSOAJrFrRWHp6PqgxTGARLj3nutZ+P554cdiU9SKWnmzNZ71b7/vrRsGfc2ACVB4gigWVwTR8kenGprW68+WFtr69Z23bX0cQEomXXrpIceksaNk4YMCTsan6RSthrkzTe3/x6FcQCUEIkjgGaZjB3jtlRVsv2LbVUfpMcZkAiPPmr9G2NfFKel9nrVetWiDzqotDEBSCQSRwDN4j7jKG3/cLVihfT224zIA2XOda0ozvDh0pFHhh2Nj3bfXRowoO3EkWrRAEqExBFAs2xW2nFH+4qbtqoPepVWSRyBsvbii9Jrr9lsY1ktLnAcWzGx7b1t0yZp9mzubQBKhsQRQLM49nD0dOtmnb637Xfm/dmrvAqgLE2aZHWyvvGNsCMJQColzZ0rrVrV/BrVogGUGIkjgGZx7OHYUlXV9tUH02lpv/2kvn3DiwtAoBYulKZOlc45R+rVK+xoApBK2VrcGTOaX/NmIOlPC6BESBwBNIvzjKPUXH1wzhz7Mz3OgER44AGpoUG68MKwIwlIa71q02mqRQMoKRJHAKahQaqri/eM47YFchYskJYsIXEEytimTdL990snnijttVfY0QSkf39p7723TxxTqTLb0AkgykgcAZj6ekse45w4etUHvX2N9DgDyl51tY15lVULjtakUpYsuq5Vi37nHe5tAEqKxBGAiXMPR8+21QfTaal7d+ngg8ONC0Bg7r5b2nNP6YQTwo4kYFVVliFnMs3VotnfCKCESBwBmDj3cGypZfXBdNoqrXbtGnZUAAIwa5b00kvSxRdLncr9iablUvx02gbKqBYNoITK/TYLIFfllDi6rj1NzprFUi6gjN1zj9Szp/Ttb4cdSQkccoi1HfISR6pFAygxEkcAJpOxmbmBA8OOpDjeCPxDD0kbNpA4AmVq2TLp0Uelb35T6tcv7GhKYIcdpBEjLGmsreXeBqDkSBwBmGxWGjIk/uu9vOqDTzxhf2YPEFCWfv1rGxu6+OKwIymhqipbTbFkCfc2ACUX8ydEAL7JZOK/TFWSKiul+fOtQqwk7bGH7QWqrAw3LgC+aWiQJk+Wjj5aGj487GhKpLLSKgF597aLLuLeBqCkSBwBmGw23hVVPfX1+b0OIHamT7c2rWXfgqMl7m0AQkbiCMCKyWSz5THjCKDsTZpkK+tPPTXsSAAgOUgcAUgrV0rr1pXHjCOAsvb229Kzz0oXXECnHQAoJRJHAOXTigNA2Zs82RLGiRPDjgQAkoXEEQCJI4BYWL1aevhh6StfoSYMAJQaiSMAq6gqlcdS1YqK/F4HEBt/+IO0apV06aVhRxIC7m0AQtYl7AAARIA34zhkSLhx+KGuLuwIAATAda0ozmGHSalU2NGEgHsbgJCROAKwGceBA6Vu3cKOBABa9c9/Sm+9Jf3mN9a+EABQWixVBVA+PRwBlK1Jk6Sdd5ZOPz3sSAAgmUgcAdDDEUCkffSR9OST0oQJUo8eYUcDAMlE4gjAlqoy4wggou6/344XXBBuHACQZCSOQNJt2CAtW8aMI4BI2rBBeuAB6eSTpWHDwo4GAJKLxBFIuoUL7UjiCCCCHn9cWrpUuuSSsCMBgGQjcQSSrpx6OAIoO5MmSfvuK33+82FHAgDJRuIIJJ3Xw5EZRwSsstLaKGz7VVlJLFGIJSpxbBvLK69Ib78tdeoUTiwAAEMfRyDpvBlHEkcErL6+7dfTaWIJO5aoxNFRLACAcJA4AkmXzUq9e0t9+oQdCRLs8MPDjqAZsWwvKnEAAMJD4ggkndfD0XHCjgRlrKOZounTSxOH56ST2v5eUmOJShxS+7EAAMJB4ggkHT0cEaDNm6XJk6Xrrmv/fSeeWJp4ckEs24tKHACA8FAcB0g6b8YR8Nnzz0sjRkiXXy59+tNhRwMAAIpB4ggkWUODtGgRiSN89fHH0umnS8ceK61bJ02bZksdKypaf39brweJWKIbR3vXDCMWAIBhqSqQZIsXS1u2sFQVvti4Ubr9dunGG6XGRumnP5Wuukrq0cO+X1cXbnwtEcv2ohKHFK1YAACGxBFIMno4wifTp0vf+Y707rvSuHGWQA4bFnZUAADALyxVBZKMHo4o0nvvSaecIo0ZI3XpIj37rDR1KkkjAADlhsQRSDJvxpGlqsjTunXSj38sHXigFcG59Vbptdek444LOzIAABAElqoCSZbN2jTRoEFhR4KYcF2bUfzud60Izje/Kd18szRkSNiRAQCAIDHjCCRZJmNP/J24FaBjb71lM4pf+YrUv79UUyP9/vckjQAAJAFPi0CS0cMROVi1SrrySumQQ6SZM6V77pFmzJCOOirsyAAAQKmQOAJJRuKIdjQ2Sr/7nbTPPtIdd0hnny2984500UW2whkAACQHiSOQVK5rS1UpjINWzJ5tM4pnnWUVUmtrpQcekAYODDsyAAAQBhJHIKlWrZLWrmXGEVtZtky68ELpsMOsJ+NvfiO99JI0alTYkQEAgDCROAJJ5bXiIHGEpIYG6b77bFnqgw9Kl10mvf229O1vUzsJAADQjgNIrkzGjixVTbyXXpIuucSWp37uc9Ldd0sHHRR2VAAAIEoYRwaSihnHxKursz2Mn/mMtHix9L//K/3jHySNAABgeySOiIXKSslxtv+qrExuLEXH4c04+tCELyq/kyjFEpU42otlyBDpsceka6+V5s2TTj/dXgcAANgWS1URC/X1+b0epKjEUnQc2aw0YIDUvXv4sfgoKrFEJY72rum60ptvSnvvXdp4AABA/JA4IvaOPz7sCJpFJZac4ph9vrThLCngmKPyO5GiE0tU4pBIGgEAQG5IHBF7a9aEHUGzqMSSUxzrOknddpICjjkqvxMpOrFEJQ4AAIBcOa7rhh1DJIwaNcqdMWNG2GGgDe3tuyr1X+GoxFJ0HIMGSaedJt1/f/ix+CgqsUQlDilasQAAgOhyHGem67qtdm+mOA6QRBs3SkuWUFEVAAAAOSFxROR98EHbMyYVFaWNpb1rljqWouJYuNCOPvVwjMrvpL1rxuq/j8+iFAsAAIgn9jgi0hoapDPPlHbcUXrtNWnYsLAjst53UVBUHD73cIzK70SKTixRiUOKViwAACCeYj/j6DjOFY7jvOk4zhzHcR5zHKe74zi7O46TdhxnvuM4/+c4Trew40Rhbr5ZevFF6Z57opE0lg2vhyNLVQEAAJCDWCeOjuPsIukySaNc1z1IUmdJX5N0s6Q7XNfdW9IKSeeGFyUKNWOGdP311pT8jDPCjqbMeDOOPi1VBQAAQHmLdeLYpIukHo7jdJHUU9IiScdK+lPT938r6dSQYkOB1q2TvvlN24N1773tV4VEAbJZqWdPqW/fsCMBAABADMQ6cXRdNyvpNkkfyRLGTyTNlLTSdd0tTW/LSGp1PZ7jOOc5jjPDcZwZS5YsKUXIyNFVV0lvvy399rdSv35hR1OGMhmbbSQjBwAAQA5inTg6jtNP0lhJu0saIqmXpBNbeWurncpc133Add1RruuOGjhwYHCBIi/Tp0uTJ0vf/a70+c+HHU2ZymbZ3wgAAICcxTpxlPQFSR+4rrvEdd3NkqolfVrSTk1LVyXpU5IWhhUg8rN4sXT22dLBB0s33hh2NGWMxBEAAAB5iHvi+JGkwx3H6ek4jiPp85LekvS8pC83vecsSdNCig95cF1p4kRp5UrpkUek7t3DjqhMNTZa4khhHAAAAOQo1omj67ppWRGcWZLekP08D0i6WtJ3Hcd5V9LOkh4KLUjkbMoU6amnpJtushlHBGTJEmnLFmYcAQAAkLMuHb8l2lzXvV7S9du8/L6kqhDCQYHmz5cuv9z2NH7nO2FHU+bo4QgAAIA8xXrGEeVh82ZrvbHDDtLDD0ud+FsZLHo4AgAAIE+xn3FE/N14o1RbKz3+OLlMSXiJIzOOAAAAyBFzO2hfZaX1+tv2q7LSl9O//LL0s59J3/qW9JWv+HLK4AX8OwlcJiN17ixVVIQdCQAAAGKCxBHtq6/P7/U8rF4tnXmmzTLedVfRpyudAH8nJZHNSoMHW/IIAAAA5IClqgjNFVdI778v/etfUt++YUeTIPRwBAAAQJ6YcUQonnhCeugh6ZprpKOOCjuahMlk2EwKAACAvJA4ouQWLZImTpRGjpR+8pOwo0kgZhwBAACQJxJHtG3VKt9P6brS2WdL69ZJjzwidevm+yXQnlWrbHMpiSMAAADyQOKItv3gB21/r8CKnPfcIz3zjHTbbdJ++xUYV9ja+tnjUKWUHo4AAAAoAIkjWvfii9LkydJll9k04Tnn2CyV69pXXV3ep5w7V7rqKunEE6ULLwwg5lKpq5OefNL+9wUX2PHVVwv6nZQcPRwBAABQABJHbG/jRmnCBGnoUOnGG+21igprN9HYWNApN22SzjhD6t1b+vWvre1hrHlJ4nnnSZ06SdXV4caTq0zGjiSOAAAAyAOJI7b3859L8+ZJ991nmZ5kieOWLdKKFQWd8vrrpdmzpSlTpMpKH2MNi9ez8cADrSxsXBJHZhwBAABQABJHbG3OHOkXv7DpwRNPbH7dy/YKWI5ZUyPdfLNNYo4d61OcYaurk/r3t+o+48bZ7+2dd8KOqmPZrMXdo0fYkQAAACBGSBzRrKHBsrs+faQ77tj6e17hF2+mLUeffCKdeaa0xx7bnzLW6uubfyennWbHJ54IL55c0cMRAAAABSBxRLN77pHSaelXv5IGDtz6ewXOOF5yiU1y/eEPzatey0JdXfPvZOhQafToeCxXpYcjAAAACkDiCPPhh9Z+44tflL7xje2/X8CM4//+ryWMP/6xdPjhPsUZFS1nHCVp/Hiptlb6+OPwYspFJkPiCAAAgLyROMLaa3j9Me67r/WSpzvtZPv5ckwcP/7YTplKST/8oY+xRkV9/dZVfrzlql6bjijatElavJilqgAAAMgbiSOkxx6Tnn7aWm/stlvr73Ecm2HLYalqY6P07W9LmzfbjGOXLv6GG7q1a6U1a7aecdxnH+mgg6SpU8OLqyOLFtmRGUcAAADkicQx6ZYulb7zHZsavOSS9t9bWZnTjOOdd0r/+IdtldxrL5/ijBLvd7BtX5Fx46QXXrBZvSiihyMAAAAKROKYdFdcIa1caQ0WO3du/705zDi+/rp07bXSqadK55zjY5xR4v0OWs44SpY4NjZKTz1V+phy4fVwZKkqAAAA8kTimGR/+5utJb32Wltm2ZEOZhw3bLD2j/37Sw8+2PpWybLQ1ozj8OHWdySq1VW9xJEZRwAAAOSJxDGp1qyRLrhA2m+/3KvXVFTYMszGxla//YMfSHPmSL/+tTRggI+xRk1bM46OY7OOzz1nDSyjJpORevSQ+vULOxIAAADEDIljUv34x9aC48EHpR12yO0zlZVSQ4O0bNl233ruOemOO6SLL5ZOPNHnWKOmvt6SxG17XUqWOG7eLP31r6WPqyNeD8eynQoGAABAUEgckyidtso1F10kHXlk7p/zZti22ee4fLl01lk2eXnLLT7GGVV1ddLOO0tdu27/vVRKGjIkmstV6eEIAACAApE4Js2mTdKECZbc/OIX+X3WSxxb7HN0XVvxunix9MgjUs+ePsYaVfX12y9T9XTqZD0dn35aWreutHF1JJulMA4AAAAKQuKYNLfcYhsRJ0+W+vTJ77NeMZgWM45/+IP0xz9K//M/0siRPsYZZXV12xfGaWncOEsan322dDF1pLFRWriQGUcAAAAUhMQxSebNswzvq1+VTjkl/89vM+O4YIHtaTzqKOmqq/wLM/Lam3GUpKOPttKyU6eWLqaOLF1qs80kjgAAACgAiWNSNDZKEydKvXpJd91V2Dn69JG6d5fq6tTQIJ15ptVZ+d3vOm4BWTZct+MZxy5dpLFjpT//2ZK1KKCHIwAAAIpA4pgU998v/fvf0i9/2f5sWXscxz5bX69bbrHT3XOPNGyYr5FG25o10vr1Hf8Ox42zlhzPP1+auDpCD0cAAAAUgcQxCTIZ6eqrpc9/3sqfFqOyUjPn76jrrpNOP1064wx/QowNrzBQezOOkvSFL0i9e0enumomY0dmHAEAAFAAEsdy57rWdmPLFpt1LLKH37qdh+qM2d9TRYV0770JbAnoFQbqaMaxe3dpzBjpySet92XYslmr+FrobDMAAAASjcSx3P3pT7bX7oYbpD33LPp0Vy24WG9v3F2//a3Ur58P8cVNrjOOki1XXbxYeumlYGPKRSZjMXfpEnYkAAAAiCESx3K2fLl0ySXSYYdJl19e0CkqK21W0fua/NbnJElnnOH6GGiM5DrjKEknnSTtsEM0lqvSwxEAAABFIHEsZ9/7nrRsmTRlSsEzTd4E2/avJ22NapP6elvyOXBgx+/t3Vs64QRLHN2QE+1slsI4AAAAKBiJY7l67jnpN7+xBouHHhp2NOWjrk4aMCD3/iPjxkkffSTNnBlsXB3JZEgcAQAAUDASx3K0bp10/vnS3ntL110XdjTlpb4+t/2NnpNPtiQzzOWqa9ZIq1axVBUAAAAFI3EsRz/5ifT++9KDD0o9eoQdTXmpq8uvMmn//tIxx0hTp4a3XJUejgAAACgSiWO5mTlTuv12aeJE6bOfDTua8pPvjKNky1XfeUeaOzeYmDpCD0cAAAAUicSxnGzeLE2YIA0aJN1yiy+nbGtyraLnKl/OHyuum/+MoySdeqqVpA1ruSozjgAAACgSiWM5+eUvpVdfle65R9ppJ19OOWuWHW+/3fIm15Xc3fdQ3WkX+XL+WFm1Stq4Mf/EcfBg6YgjwkscvRlHEkcAAAAUiMSxXMyfb3sbTzvNlkb65IUX7HjUUS1erKxs7meYJN7PnO9SVcn+m8yeLX3wgb8x5SKblfr1k3r2LP21AQAAUBZIHMuB60rnnWfN5idN8vXUNTVSr17SiBEtXqyoaLvBYznzfuZ8Zxyl5mT+iSf8iydX9HAEAABAkUgcy8FDD0n//Kd0663SkCG+nrqmRvrMZ6QuXVq8WFmZ7MSxkBnH3Xe37DuM5ar0cAQAAECRSBzjbtEi6Xvfswqq557r66mXLZPmzJGOPnqbb1RUVvRCBwAAIABJREFUSEuXSlu2+Hq9yPOWqhYy4yjZrONLL9l/s1LKZqmoCgAAgKKQOMbdpZdKGzZIDzwgdfL3P+eLL9pxu8SxstKWxy5Z4uv1Iq++XurcWdp558I+P26c/d6efNLfuNqzebPFzYwjAAAAikDiGGdPPGGN5X/yE2mffXw/fU2NbZscPXqbb3gzbkkrkFNXJw0caMljIfbfX9p339IuV120yJJVEkcAAAAUgcQxrlaulC6+WDrkEOnKKwO5RE2NlEpJ3btv8w1vj1/S9jnW1xe2v9HjODbr+Pzz0vLl/sXVHq+HI0tVAQAAUAQSx7i6+mpLZKZMkbp29f30q1dbD8ftlqlKyZ5xLHR/o2fcOKmhQfrzn/2JqSP0cAQAAIAPSBzj6F//sj2NV1whjRoVyCVeftnym3YTR2Yc83fYYdKuu5ZuuSozjgAAAPABiWPcbNggTZwo7bGHdMMNgV2mpsa28h1xRCvf7NVL6t07WTOOrmuJY7Ezjt5y1Weekdas8Se29mSztlG1f//grwUAAICyReIYNzfcIM2fL91/v9SzZ2CXqamxybHevdt4Q0VFsmYcV66UNm0qfsZRssRx40bp6aeLP1dHvB6OjhP8tQAAAFC2SBzj5LXXpFtukb79bekLXwjsMhs2SOl0G8tUPZWVyZpxLLaHY0uf/rQ0aJBVxA0aPRwBAADgAxLHuNiyRZowwXoI3nZboJeqrbXJtXYTx6TNOHo/qx+JY+fO0qmnSn/9q2XpQcpmKYwDAACAopE4xsVdd0kzZtix0Ab0OaqpsZWNRx7ZzpuSOuPox1JVyZarrlkjPfecP+drjeuSOAIAAMAXJI5x8P770o9+JJ18svTVrwZ+uZoa6aCDpH792nlTRYX1Ity0KfB4IsHPGUdJOuYYqW/fYKurLltmeylZqgoAAIAikThGnetK558vdekiTZ4ceJGTzZull17qYJmq1DzztnhxoPFERl2d/Tfwqzppt242EDBtmi1DDgI9HAEAAOATEscoqqy0BNFxpE6dbDnj6tWB9WxsafZsae3aHBLHpPVyrK+3gjadfPwnM26czdrW1Ph3zpbo4QgAAACfkDhGUVvJWAmStBdesONRR3XwRm/GMUmJo1/7Gz0nnGAtVYJaruoljsw4AgAAoEgkjthKTY20997S4MEdvNGbcUxKgZy6Ov/2N3p69pROPFF64gmpsdHfc0u2VNVx/E94AQAAkDgkjvivxkabcexwmaqUzKWqQSRg48ZJCxdaDxS/ZbMWc9eu/p8bAAAAiULiiP96801pxYocE8cePaQ+fZIx49jYaImj3zOOkjRmjCV2U6f6f25acQAAAMAnJI74L69GS06Jo2SzWUmYcVyxwiqfBjHj2Lev9IUv2D5H1/X33JkMiSMAAAB8QeIYRW3NbAUx49VCTY00dKi02245fqCiIhkzjt7PGNTvf9w469X5+uv+njebpaIqAAAAfJF34ug4zo6O4zzkOM6vHcfJaW7KcZyjm97/oOM4PfIPM2Hq6mz2aduvAJM017XE8eij82gVWVGRjBlH72cMqsjMKadYmw8/q6uuXSutXMmMIwAAAHxRyIzj1ySdLel0Sa/l+JnXJH1V0jmSvlLANRGwd9+1vDTnZaqSJVLMOBZv0CDrf+Jn4kgPRwAAAPiokMTxi03HZ1zX/SSXDzS972lJjqQxBVwTAct7f6NkidTKldLGjYHEFBlBzzhKtlx1zhzpnXf8OR89HAEAAOCjQhLHQyW5kl7K83MvNx1HFHBNBKymRho4UNp33zw+5CVS5b5cta5O6tZN2mmn4K5x2ml2fOIJf86XydiRxBEAAAA+KCRx9FrDf5zn55qmQDSkgGsiYDU1tloy5/2NUnJ6OdbX23LSvH45eRo6VKqq8m+5KjOOAAAA8FExVVXz/az31N2liGsiAB99JC1YkOcyVal5xrHc9znW1QW7TNUzbpxUWyt9nO+YTCuyWWv10bt38ecCAABA4hWSOC5tOu6Z5+f2ajouL+CaCNALL9gx78QxSTOOAbdCkeTvclV6OAIAAMBHhSSOr8lmD8fn+bkvy/ZGzingmghQTY3Up480fHieH0xS4liKGcd99pEOOsif5ar0cAQAAICPCkkcpzcdhzuOc0kuH3Ac51JJXlry1wKuiQC98IJ05JFS5855fnCHHaxgTDkvVW1slBYvLs2Mo2TLVV94wa5ZDGYcAQAA4KNCEseHJXlTTHc4jvM/juP0au2NjuP0chznZ5J+KZttXCppSiGBIhiLF0tz5xawTNVTWVneM47LlkkNDaWZcZQscWxslJ56qvBzbNli/02YcQQAAIBP8i5U47ruesdxzpb0Z1ni+QNJlzqO87ykuZLWSOotaX9Jx0jaUba0tUHS2a7rrvUpdvjg3/+2Y8GJY0VFec84ej9bqWYchw+X9tjDlqtOmFDYOerqLPlkxhEAAAA+KajCqeu6f3Mc5wxJD0nqJamPpFOavlryKqmukXSu67rThUipqZF69JAOO6zAE1RWSrNn+xpTpHizqaWacXQcm3X81a+kTz6xyqj5oocjAAAAfFZwOw7XdR+XdLBs6ekqWZK47dcqSfdLGu667h+Ljha+q6mRjjjC+tsXhBlH/40fL23eLP21wO3AXg9HlqoCAADAJ8X0cZTrugtc1z1PUn9JI2Uzjt9sOo6U1N913Qtd111QbKDw3yefSK++WsQyVckSqlWrpPXrfYsrUko94yhJVVXSkCGFV1f1EkdmHAEAAOCTgpaqbst13UZJrzZ9ISZefFFy3SITRy+hqq+Xhg3zI6xoqauz6rF9+pTump06WU/H3/xGWrdO6tkzv89nMjaFPGBAMPEBAAAgcYqacUS81dRIXbtKqVQRJyn3Xo5eD0fH6fi9fho3zpLGZ57J/7PZrM02ljpmAAAAlK2CEkfHcYY6jrOr4zg5TcM4jtOn6f1suoqQmhpp9Oj8J7S24s04lus+x7q60u5v9Bx9tNS/f2HLVenhCAAAAJ/lnTg6jlMl6UNJ78v2MebiUEkLJC1wHGd4vteE/9atk155pchlqlJyZhxLrUsXaexY6c9/ljZtyu+z3owjAAAA4JNCZhy/2nSc77ruP3P5gOu6NZLmySqtfr2Aa8Jn//mP9Yk/6qgiTzRokB2ZcfTfuHFWwej553P/jOta4khFVQAAAPiokMTxSEmupHx7Mv5VljgWm6rABzU1tgXuM58p8kTdutmSynKccWxokJYuDS9x/MIXpN6981uuuny5tGEDM44AAADwVSGJ495Nxzl5fu7NpuM+BVwTPqupkQ49tLD+8tuprCzPxHHpUqmxMZylqpLUvbs0Zoz05JOWxOaCHo4AAAAIQCGJ445Nx1V5fm5109GPVAVF2LTJlqoWvb/RU1FRnktVvZ8prBlHSRo/Xlq8WHrppdzeTw9HAAAABKCQxNFLGPvl+bn+Tccy7RQfHzNnSuvX+5g4luuMo/czhTXjKEknnmh9JHNdrprJ2JHEEQAAAD4qJHFsejJVvrvjPt10XFjANeGjmho7Fl0Yx8OMY3B695ZOOMESR9ft+P3ZrG1eHTw4+NgAAACQGIUkjv+SFbn5quM4OU1rOI4zVNLpsqI6/yrgmvBRTY20//7SwIE+nbCyUlqzRlq71qcTRkQUZhwlq6760Uc2VdyRbNYq3XbrFnxcAAAASIxCEsffNR27S3rKcZxB7b3ZcZwKSU82vV+SflvANeGThgbp3//2cZmqVL69HOvqpB49bNYvTCefLHXunNty1UyGZaoAAADwXd6Jo+u6MyU9Jpt1PFTSHMdxfuQ4ziGO43STJMdxujX9+ceS3mh6nyvpT67r/se/8JGv11+XVq0iccxJfb3NNjpOuHH07y8dc4w0dWrHy1Xp4QgAAIAAFDLjKEkTJc2QJY87S/qppFmS1juOs0lWAGeWpJ9IGtD0vlcknV1kvCiS7/sbpealnOW2z7GuLtz9jS2NGye98440d27772PGEQAAAAEoKHF03f/P3n3HOVWlfQD/nakMU4BpCUiVDgpK74g0RamKFIFZYbGhu77LKq7rrq5r19eyr3VVBkFpKkoRRZQyMPQOIkgfWjKFgen9vH+EC9y5yUySSXJvwu/7+eQz5uSee54JDOaZ5xRZAKAvgI8AlMOWGCqPkErPSwF8AKD/5X6ko5QUoFkzoFEjD9400CuORjBqlK3yWdV01cJCIDubFUciIiIi8jh3K46QUhZLKR8F0BzAUwCWwVZlPHr56zIATwJoLqV8TEpZ7IF4qQaktCWOHp2mCth22RGCFUdvql8f6NWr6sSRZzgSERERkZeE1PQGUsrTAN68/KiWEMIspfRIhiGEaA1g0TVNNwL4J2wb+CwC0BTASQD3SSmzPTGmPzt0CMjM9ELiGBoKxMUFVsWxtBTIyjJOxRGwTVedORM4ccJWNq6MZzgSERERkZe4XXF0hRAiRAgxRgixHMApT91XSnlYSnmLlPIWAJ0BFAD4FsDTAH6RUrYE8Mvl59c9r6xvVJjNgVVxzMiwlWiNUnEEgNGjbV8dVR2ViiOnqhIRERGRh3k1cby8s+o7AM4B+ArAXfBAldOBgQCOSSlPARiJq8d+fA5glJfG9CspKbb8rkULL9zcZAqsiqPyvRgpcWzWDLj11uoTR1YciYiIiMjDPJ44CiFihRCPCyF2wbbW8XFc3VkVAHI8PeZl42E7JgQATFLK8wBw+avdsyaFEA8KIXYIIXZkZGR4KSxjuHZ9o1dOlzCbAzNxNNJUVcA2XXXTJuD8ee1rZ84A0dG2BxERERGRB3kkcRQ2w4QQX8FWXXwHtrMblZ1VywCsBDABQH1PjFlp/DAAI2CrajpNSvlfKWUXKWWXhIQET4dlKKdO2fIKj69vVJhMgTVVVflejFRxBGyJIwB89532NZ7hSEREREReUqPEUQjRWgjxCoDTAJYDGAMgDLZkUQL4HcATAG6QUt4tpVwkpSyqYcz23Algl5RSKXlZhRD1L8dYH0C6F8b0K8r6Rq8ljmYzUFAA5OV5aQAfM+JUVQBo2xZo3dr+dFWe4UhEREREXuJy4iiEiBZC/FEIkQrgIGxHcdTH1eri2Wsuny+l/I+U0tvzQCfg6jRVwHYUSNLl/04CsNTL4xteSgpQrx7Qvr2XBlASrECpOlosQGQkEBWldyRqQtiqjmvXAhcuqF9jxZGIiIiIvMTpxFEIMUAIMRfAeQAfA+iBq8liAYAvAAwB0MQLcVYVV20AgwFcW4J5FcBgIcSRy6+96suYjCglxbabapC3tkNS1gIGyjpHq9V46xsVY8YA5eXA8uVX28rKbMkuK45ERERE5AVV7nAqhGgC4A+wVe2UhFDZWqUCwBrYzkz8RkpZcE0/jwfqyOVx4yq1ZcG2yyrBto/KkSPAQw95cZBArDgabZqqonNnoHFj23TVpMuFdavVlkwycSQiIiIiL6juaIzjl79emwn+CmAegC+klOe8EhV51IYNtq9eW98IXE2yAqni2KaN3lHYp0xX/fBD25rSqCie4UhEREREXlXdxEUlYZSwTUXtJKW8WUr5OpNG/5GSYluud+utXhwkIcE2D5YVR98YMwYoLgZWrrQ95xmORERERORFrqx4uw/A80KI0UKIUG8FRJ6XkgL07g2EVFdfrongYCA+PjAqjiUlto1njLrGEQB69QISE6/urnrmjO0rE0ciIiIi8oLqEsdkAHmwVR7DAAwH8DUAixDiQyFELy/HRzV04QKwf7+Xp6kqzObAqDimXz69xcgVx+BgYNQo4PvvgaIiW8UxNNRW+SUiIiIi8rAqE0cp5TTYjtp4AMD6y80CQD0ADwLYIIQ4KoR4TgjR3KuRkls2brR99UniaDIFRsVR+R6MXHEEbNNV8/KAn3+2VRwbNPDitrlEREREdD2r9lOmlLJASvm5lHIAgBYAXgSQhqtHcTQD8E8AvwshNgohHvZmwOSalBQgPBzo2tUHgwVKxVH5HoxccQSAAQOAOnVs01V5hiMREREReZFL5Qkp5Qkp5T+llE1hOx9xPoAiXE0iewJ4/5ouTYUQ4R6KldyQkgJ06wbUquWDwZSKo5Q+GMyL/KXiGBYGDB8OLF0KnDrF9Y1ERERE5DVuz2uTUv4ipZwE21TWRwFsw9UEUskckgBYhRCfCiFuq2Gs5KK8PGDXLh9NUwVsiVZREZCT46MBvcRfKo6AbbrqhQvAiRNMHImIiIjIa2q8IEpKmSOl/EhK2QNAewD/C8CKq0lkDGxrJH8RQqQJIV6p6ZjknM2bbWfC+yxxDJSzHK1WIDoaiIjQO5Kqmc22xFHx9tu2Mx6NXiklIiIiIr/j0Z00pJS/SSmfBNAIwAgA3wIoxdUksiGApzw5JjmWkmLbfLNnTx8NqCQsgZA4+kPy5eh99vf3n4iIiIgMxytbMEopy6WUK6SU9wBoAOAvAPZ5YyxyLCUF6NTJVjzzCaXi6O8b5Fgs/jFNlYiIiIjIR7y+d7+UMktK+Y6U8hYAXaDePIe8pKgI2LrVh9NUAVYciYiIiIgClE8PfZNS7pJS/smXY16vtm8Hiot9nDjGxdnmxrLiSEREREQUUHhaeIBKSbF97dPHh4MGBQEJCf5dcSwuBi5eZMWRiIiIiOgaTBwDVEoKcPPNQGysjwc2m/274qgkvf5QcXQUoz/ETkRERER+hYljACorA1JTfTxNVWEy+XfFUYndHyqOFgsgpfbhz4k7ERERERkSE8cAtHs3kJ+vU+Lo7xVHJXZW7YiIiIiIrmDiGICU9Y19++owuFJxlFKHwT3AnyqOREREREQ+wsQxAKWkAC1bAvXr6zC42QyUlNg2mPFHSsUxMVHfOIiIiIiIDISJY4CpqAA2bNCp2ghcneLpr+scrVagbl2gVi29IyEiIiIiMgwmjgHm11+B7Gyd1jcCV6d4+us6R57hSERERESkwcQxwCjrG3VLHAOh4sjEkYiIiIhIhYljgNmwAWjYEGjaVKcAlIqjPyeO3BiHiIiIiEiFiWMAkdJWcezXDxBCpyDq1QNCQjhVlYiIiIgogDBxDCDHjgHnz+s4TRUAgoKuHsnhbwoLgZwcVhyJiIiIiCph4hhAdF/fqDCZ/LPiqCS7rDgSEREREakwcQwgKSlAfDzQpo3OgfhrxVGJmRVHIiIiIiIVJo4BRPf1jQqz2T8rjkrMrDgSEREREakwcQwQp08DJ04YYJoqYEu80tOBigq9I3ENK45ERERERHYxcQwQGzbYvhoicTSbgdJSIDtb70hco1QcExP1jYOIiIiIyGCYOAaIlBQgJgbo0EHvSHB1qqe/rXO0WoHYWCAsTO9IiIiIiIgMhYljgEhJAfr0AYKD9Y4EV6d6+ts6R57hSERERERkFxPHAJCeDvz2m0GmqQL+XXHk+kYiIiIiIg0mjgFg40bb17599Y3jClYciYiIiIgCChPHAJCSAtSqBXTponckl9Wta1snyIojEREREVFAYOIYADZsAHr2NNCeLkLYKnf+lDjm5wN5eaw4EhERERHZwcTRz126BOzZY6D1jQqTyb+mqipJLhNHIiIiIiINJo5+btMmoKLCgImj2exfFUclVk5VJSIiIiLSYOLo51JSgJAQoEcPvSOpxN8qjkqsrDgSEREREWkwcfRzKSlA165A7dp6R1KJyWQ7J6SiQu9InMOKIxERERGRQ0wc/VhBAbB9uwGnqQK2BKy8HMjK0jsS5ygVx4QEfeMgIiIiIjIgJo5+bOtWoLTUoImjMuXTX9Y5Wq1AfDwQGqp3JEREREREhsPE0Y+lpNhOvujdW+9I7FCmfPrLOkeLhesbiYiIiIgcYOLox1JSgFtuAerU0TsSO/yx4sj1jUREREREdjFx9FMlJcDmzQadpgqw4khEREREFECYOPqpnTuBwkIDJ44xMUB4uH9UHKVkxZGIiIiIqApMHP1USorta58++sbhkBC2RMwfKo55ebYtallxJCIiIiKyi4mjn0pJAdq0ARIT9Y6kCiaTf1QceYYjEREREVGVmDj6ofJyIDXVwNNUFWazfyWOrDgSEREREdnFxNEP7d8PXLrkB4mjyeQfU1WVGJk4EhERERHZxcTRDynrGw2fOJrNQEaGrURqZJyqSkRERERUJSaOfiglBWjaFGjUSO9IqmEyARUVQGam3pFUzWKxbeYTH693JEREREREhsTE0c9IaUscDV9tBK5W8Iy+ztFqBRISgJAQvSMhIiIiIjIkJo5+5vBh2+xPv0gclTWDRl/naLFwfSMRERERURWYOPoZv1nfCFxNxvyh4sj1jUREREREDjFx9DMpKbYcp0ULvSNxgpKMseJIREREROTXmDj6ESmB9ett1UYh9I7GCVFRQESEsSuOUrLiSERERERUDSaOfuTUKeDMGT+ZpgrYsluz2dgVx5wcoKiIFUciIiIioiowcfQjfrW+UWEyGbviyDMciYiIiIiqxcTRj6SkAPXqAe3b6x2JC4xecVRiY8WRiIiIiMghJo5+JCUF6NMHCPKnPzVWHImIiIiI/J4/pSDXNYsFOHLEz6apAraELDMTKCvTOxL7lMSRFUciIiIiIoeYOPqJDRtsX/0ucTSZbDuXZmToHYl9FgsQHAzExekdCRERERGRYTFx9BMpKUBkJHDrrXpH4iJlCqhRp6tarUBCgi15JCIiIiIiu5g4+omUFKBXLyA0VO9IXKRMATXqBjkWC6epEhERERFVg4mjH7hwAdi/3w+nqQL+UXHkxjhERERERFVi4ugHUlNtywT9MnFkxZGIiIiIyO8xcfQDKSlAWBjQrZvekbghMtL2MGLFUUpWHImIiIiInMDE0Q+kpADduwO1aukdiZvMZmNWHC9eBEpKWHEkIiIiIqoGE0eDy8sDdu7002mqCpPJmBVHJSZWHImIiIiIqsTE0eA2bwbKy/08cTRqxVGJiRVHIiIiIqIqMXE0uJQU2xGDPXvqHUkNsOJIREREROTXmDgaXEoK0KkTEB2tdyQ1YDYDWVlAaanekaix4khERERE5JQQvQMgLbNZW6ATwpbfGHHGZ7WUxCw9HbjhBn1juZbVCoSEALGxekdCRERERGRorDgakKNZnUac7ekUZSqo0bJeiwVITASC+GNARERERFQVfmIm71MqjkbLfHmGIxERERGRU5g4kvcpyZkRE0eubyQiIiIiqhYTR/I+JTkz4lRVVhyJiIiIiKrFxJG8LyICiIkxVsWxosK2WQ8rjkRERERE1WLiaECOchm/znGMtiVsdrbteBC/flOJiIiIiHyDx3EYkJHyK48xmYxVcVRi4VRVIiIiIqJqseJIvmE2GysjVmJhxZGIiIiIqFpMHMk3WHEkIiIiIvJbTBzJN8xm27rC4mK9I7FhxZGIiIiIyGlMHMk3lAQtPV3fOBRWKxAaCtSrp3ckRERERESGx8SRfEOZEmqUdY4Wiy2ZFULvSIiIiIiIDI+JI/mGUnE0yjpHq5XrG4mIiIiInMTEkXzDqBVHIiIiIiKqFhNH8o3ERNtXVhyJiIiIiPwOE0fyjVq1gLp1jZE4VlTYNulhxZGIiIiIyClMHMl3TCZjTFXNygLKy1lxJCIiIiJyEhNH8h2z2RgVRyUGVhyJiIiIiJzCxJF8xygVRyUGJo5ERERERE5h4ki+YzIZq+LIqapERERERE7x+8RRCFFXCPG1EOKQEOI3IURPIUSsEGK1EOLI5a/19I6TYEvULl0Cior0jYMVRyIiIiIil/h94gjgXQA/SinbAOgI4DcATwP4RUrZEsAvl5+T3pRETe+qo9UKhIcDderoGwcRERERkZ/w68RRCBEDoB+AzwBASlkipbwIYCSAzy9f9jmAUfpESCrK1FC91zlaLLYkVgh94yAiIiIi8hN+nTgCuBFABoBkIcRuIcSnQohIACYp5XkAuPw10V5nIcSDQogdQogdGRkZvov6emWkiiPXNxIREREROc3fE8cQAJ0AfCilvBVAPlyYliql/K+UsouUsktCQoK3YiSF0SqORERERETkFH9PHM8AOCOl3Hr5+dewJZJWIUR9ALj8NV2n+OhaiZcLv6w4EhERERH5Fb9OHKWUFgCnhRCtLzcNBHAQwDIASZfbkgAs1SE8qiwsDIiN1bfiWF4OZGSw4khERERE5IIQvQPwgMcBfCmECANwHMADsCXEi4UQ0wCkARirY3x0Lb3PcszMBCoqWHEkIiIiInKB3yeOUso9ALrYeWmgr2MhJ5jN+iaOytisOBIREREROc2vp6qSHzKZ9J2qqozNiiMRERERkdOYOJJvseJIREREROR3mDiSb5lMQG4uUFCgz/isOBIRERERuYyJI/mWUunTq+potQIREUBUlD7jExERERH5ISaO5FtKpU+vdY4Wiy15FUKf8YmIiIiI/BATR/ItI1QcOU2ViIiIiMglTBzJt4xScSQiIiIiIqcxcSTfSkiwfWXFkYiIiIjIbzBxJN8KDQXi4/WpOJaVAZmZrDgSEREREbmIiSP5nsmkT8UxIwOQkhVHIiIiIiIXMXEk3zOb9ak4KmOy4khERERE5BImjuR7elUclTFZcSQiIiIicgkTR/I9s1nfxJEVRyIiIiIilzBxJN8zmYD8fCAvz7fjcqoqEREREZFbmDiS7ylTRX1ddbRagchIICrKt+MSEREREfk5Jo7ke0rFz9cb5FgsXN9IREREROQGJo7ke0riqEfFkdNUiYiIiIhcxsSRfE+p+ulRcWTiSERERETkMiaO5Hvx8YAQ+lQcOVWViIiIiMhlTBzJ90JCgIQE31YcS0uBrCxWHImIiIiI3MDEkfRhMvm24piebvvKiiMRERERkctC9A6ArlNms28rjjzDkXRWUVGBvLw85ObmorCwEOXl5aioqNA7LCIiIjKAoKAgBAcHIyIiAtHR0YiKikJQkLFqfEwcSR8mE3DkiO/GU6qbrDiSj5WVlcFqtSIvL+/K/wwL9/zpAAAgAElEQVQSEhIQHByMoKAgCCH0DpGIiIh0JKVERUUFysvLkZ+fj+zsbJw/fx5RUVEwmUwICTFGymaMKOj6o1QcpbRtlONtrDiSDsrKypCWlobIyEg0b97cMP/wExERkXEIIRAcHIzg4GCEhYWhXr16KCsrQ1ZWFtLS0tC4cWNDfIYwVv2Trh8mE1BUBOTm+mY8peLIxJF8REkao6KikJiYaIh/8ImIiMg/hISEIDExEVFRUUhLS0NZWZneITFxJJ34+ixHiwWIjgZq1/bNeHTds1qtiIyMREJCAqejEhERkcuEEEhISEBkZCSsvj7Gzg4mjqQPpfLnqx8CnuFIPqRshBMXF8ekkYiIiNwmhEBcXBzy8vJ031SPiSPpQ0nifJk4cpoq+YiyEQ6npxIREVFNhYSEoFatWsjPz9c1DiaOpA8lifPlVFVWHMlHcnNzER0drXcYREREFCBiYmKQk5OjawxMHEkfcXFAUBArjhSQCgsLERkZqXcYREREFCAiIyNRWFioawxMHEkfwcFAYqJvKo7FxUB2NiuO5DPl5eUIDg7WOwwiIiIKEMHBwSgvL9c1BiaOpB+TyTcVx/T0q+MR+UBFRQWCgvjPKxEREXlGUFAQN8eh65jZ7JuKozIGE0fyIe6mSkRERJ5ihM8VTBxJP76qOCpjcKoqEREREZFbmDiSfpSKo5TeHYcVRyIiIiKiGmHiSPoxmYCSEuDSJe+Oo1QcmTgSEREREbmFiSPpR5k66u11jhYLUKcOUKuWd8chIiIiIgpQTBxJP0oF0NvrHK1Wrm8kIiIiIqoBJo6kH19WHDlNlYiIiIjIbUwcST+sOBIRERER+QUmjqSf2FggJMQ3iSMrjkREREREbmPiSPoJCgISE707VbWoyLZrKyuORERERERuY+JI+jKZvFtx5FEcRETkAS+++CKEEKpHWVmZ3mEREfkME0fSl9ns3Yqjcm9WHImIiIiI3MbEkfTFiiMRkUedPHlSUxnz1eO2227T+9snHUydOtXu34cvvvhC79CIyIOYOJK+zGZbcield+6vVByZOBIREXlcXl4eFi9ebPe1zz77zMfREJE3MXEkfZlMQGkpkJ3tnfsrFcfERO/cn4iI6Dq2cOFC5Ofn231t/fr1OHbsmI8jIiJvCdE7ALrOKWsPLRbb8RyeZrEA9eoB4eGevzcRkQGFhYWhY8eOLvXJy8vTfMCPjIxEixYtXLqPq9eT/6uqqiilxOzZs/HSSy/5MCIi8hYmjqQvZQqp1Qq0a+f5+1ut3BiHiK4rDRo0wJ49e1zqs27dOgwYMEDV1qVLF6xbt86Dkfm3Z599Fs8++6zeYRjKwYMHsWXLFlWbEALymuUnc+bMwQsvvIDg4GBfh0dEHsapqqSvayuO3mCxcH0jERGRF1SuNgoh8NRTT6nazp07h1WrVvkyLCLyEiaOpK9rK47ewIojERGRx5WWlmLevHmqtn79+uHpp59GeKXlIdwkhygwMHEkfdWrB4SGsuJIRETkR5YtW4aMjAxV25QpU1C3bl2MGDFC1b58+XKkp6f7Mjwi8gKucSR9CeG9sxwLCoC8PFYciYgM7ujRo9i7dy9Onz6NvLw8hIWFwWw2Y/LkyRBCVNv/3Llz+O2333Dy5ElcunQJhYWFiImJQWxsLBo3bowuXbogIiLCB9+J+zIzM7FlyxYcO3YMeXl5qFOnDhISEtC9e3c0bdpU7/A0KlcRIyIiMHbsWABAUlISvvrqqyuvKdXJmTNnei2eo0eP4uDBg8jMzERWVhbKysoQExOD+vXro23btmjVqpXH1lkWFhZi27ZtOH/+PDIzM3Hp0iVERESgbt26aNGiBdq3b4+4uDiPjEVkKFJKPqRE586dJemkSxcp77zT8/c9flxKQMrZsz1/b6IqHDx4UO8QiFyydu1aCUD16N+/f43vGxwcrLrn3//+9yuv5efny9dee002b95cM7byKC0ttXvfzMxM+cknn8hx48ZJs9nssL/yCAsLk3369JELFy6UZWVlbn0v//73v52O71oDBw5U9endu7fq9fXr18uhQ4fKoKAgh/G3adNGzp07V1ZUVLgVu6edOXNG82c7ceLEK6+XlpZKk8mker1du3Yej2Pfvn1y2rRpsnHjxtX+HahTp44cPXq0nD9/viwqKnJ5rKKiIvn+++/L/v37y/Dw8CrHEkLIDh06yKeffloePnzY4983Xb988fkCwA7pIF/iVFXSn8nknamqyj1ZcSQiMpTt27ejXbt2mDVrlsvn/E2ZMgVmsxnTp0/HokWLYHHi/x8lJSXYuHEjxo8fj/bt22P//v3uhu4xJSUlePjhh9G/f3+sWrUKFRUVDq89dOgQpkyZgsGDByMvL8+HUdqXnJyM8vJyVduUKVOu/HdISAjuv/9+1ev2dmB116lTp3DvvfeiY8eO+Oyzz5CWllZtn0uXLuHbb7/FxIkTceutt7o03ieffIIbb7wRM2bMwPr161FcXFzl9VJK7Nu3D6+++ipat26NRYsWuTQekVExcST9eWuqqnJPrnEkIjKM1NRU3HbbbTh16pRb/Tdt2oSysjK3xz98+DB69uyp606fxcXFuOuuu/Dxxx+71O+XX37BHXfcoUnafElKieTkZFVb/fr1MWjQIFVbUlKSpq8nNslJSUlB165d8c0336iO/XBFTk6OU9cVFxcjKSkJDz74IM6dO+fWWACQm5vrdl8iI+EaR9Kf2WxL8ioqgCAP/i6DFUciIkNJT0/H6NGjUVBQcKWta9euGDJkCJo0aYKYmBhYLBYcPHhQtUbOkeDgYNx6661o37492rRpg/j4eERHRwOwJQdHjx7Fli1bsHHjRlVFLz8/HxMmTMCuXbt0WT84ffp0/Pzzz1eet2zZEsOGDUObNm0QFxeHS5cuYe/evfj66681FdXU1FS88cYbePrpp30dNgBg7dq1OH78uKpt0qRJmvWDHTp0QMeOHbF3794rbYsWLcI777yDyMhIt8ZetWoVhg8fjtLSUs1rcXFxGDRoELp06YKEhARERETg4sWLSEtLw86dO7Fp0yanE0YAKCsrw7Bhw7BmzRrNa0FBQejUqRMGDhyIJk2aIC4uDkVFRcjKysKBAwewbds2HDhwwK3vkcjQHM1hvd4eXOOoo3ffta1FzMjw7H2ff95235ISz96XqBpc40j+xldrHK99ftNNN8mNGzc67OtoHVqbNm3k6NGj5TfffCMvXrzoVBxpaWly0qRJmu9x6NChTn8vnlrjWKtWrSv/bTKZ5KJFixyuXczLy5MPPPCAZtyYmBiZl5fndOyeNHHiRE08+/fvt3vtW2+9pbl2tpv7Dhw/flzGxsZq7peQkCDff/99WVLN/+uLiork8uXL5d133y0bNWpU7Xh//vOf7a5fHDlypFP/xh89elS++OKL0mw2y08++cTp75OoKnqvcdQ9YTPKg4mjjhYtsv1VdPA/Hrc9/LCU8fGevSeRE5g4XsNksv18V36YTHpHRtfwVeKoPHr06OF00leZu/2klPLFF1/UxHLgwAGn+noqcVQeTZs2lSdOnKi2f0VFhRw2bJimf3JyslNxe1J2drYq8QUgO3Xq5PB6q9UqQ0JCVNf36dPHrbF79+6teQ/atm0rT5486fK9qnvfV69ebXfDm1dffdXlsYqKiuS5c+dc7kdkj96JI9c4kv6UNYieXudotXJ9I5HeHP1ce2NdM/mF6OhoLFq0CHXq1HGrv7v9AOCZZ55Bz549VW16HE4fEhKCRYsWOTVNVgiBt99+W9OuxxrNL7/8EkVFRaq2azfFqSwxMRF33HGHqm3jxo04fPiwS+OuWbMGqampqrbY2Fj89NNPaNKkiUv3AlDt+/7CCy9o2p588knMmjXL5bHCw8NRv359l/sRGRHXOJL+lDWInt5Z1WJh4kj+74kngD179I7CO267Te8I3HPLLcA77+gdhd964okn0LhxY13GFkJg8uTJ2Lx585W2jRs3+jyOcePGoVu3bk5f36pVK3Tr1g3btm270rZz505vhFalykl2SEgIJkyYUGWfpKQkrFixQtU2e/ZsvPbaa06Pa+/ad999Fw0bNnT6Hs7avHkzNmzYoGpr06YNXnzxRY+PReRvWHEk/Xmz4siNcYiIDGXatGm6jt+yZUvV8z179miqaN42ffp0l/tUTjSPHj1a5REenrZnzx7s3r1b1XbnnXciMTGxyn7Dhw9HvXr1VG1z5851emfc/Px8zQY1jRo1wvjx453q76ply5Zp2v7nf/4HoaGhXhmPyJ+w4kj6q1MHCA9nxZHIHn+vbAnh+LV163wWBhlDs2bN3JpaWJW8vDxs2LAB+/btw6+//oqsrCzk5uYiLy/PbmKVn5+vel5aWgqLxeKz3VXDw8PRo0cPl/s1b95c9VxKiZycHNStW9dToVXp008/1bRVNU1VER4ejnHjxuGjjz660maxWLBy5UqMGDGi2v4bN27UJJkTJkxASIh3PsKuq/TvUnBwcLVVVaLrBRNH0p8Qnj/LMS8PKChgxZGIyEA6derksXvt3r0bb7zxBpYuXao63sMdFy9e9FBU1WvUqBHCw8Nd7mdvbeelS5d8kjgWFRVh/vz5qrZ69eph+PDhTvVPSkpSJY6AbdqrM4njtdOKFb1793ZqXFeVlZVhx44dqrYOHTpcOeKF6HrHqapkDGazZyuOyr1YcSTSl6OfQf5sXpeqm9bojLKyMvz5z39G165dsWDBghonjYAtAfOV2NhYt/rZmypp7zxDb1iyZAmys7NVbePGjXM6Ae7Rowdat26talu5cqXmjEp7rHZ+qXzzzTc7Na6rsrKyNNVNb41F5I+YOJIxeLriqNyLFUcifVks9g7j8PzUdPILMTExNepfVlaGcePG4T//+Q/Ky8s9FJXvEjDAfgJodPZ2nnVmmmpV15eVleHzzz+vtt+FCxc0bZXXTHqKL8ci8kdMHMkYzGbvJI6sahARGUZN16W9+eabWLJkiaa9QYMGeOSRRzBv3jxs2rQJp0+fxsWLF1FUVKQ5h6zyjplUtRMnTmDt2rWqtpYtW2qONanO5MmTERSk/tg5e/bsavvl5ORo2qKiolwa21m+HIvIH3GNIxmDyQSkpwPl5UBwcM3vp1QzWHEkIgoIWVlZeOmll1RtISEhePXVV/GnP/3J6UpeYWGhN8ILWLNnz4btTPCrjhw5AlHVxldO+v3337Fx40b06dPH4TX2qtR5eXleWdvpaCwismHFkYzBZAIqKoCsLM/cz2q1bboTH++Z+xERka6WL1+u+RD/0ksvYebMmS5N/7Q3HZHsq6iowJw5c7w6hr1psNeKi4vTtFVeb+kpvhyLyB8xcSRjUCqDnlr3ZLEACQmAl7brJiIi31q9erXqeUxMDP785z+7fJ/jx497KqSAt2rVKpw5c8arY3z11VfIzc11+LrZzsyhffv2eSWW2NhYzS8hvDUWkT/ip2oyBmUtoqfWOVqtXN9IRBRATp8+rXrerVs3t461sHe8A9lnrxrYtm1bhIWFuX3P7OxspKWlXXmen5+PhQsXYvr06Xavt7eWMjU1FSNHjnQ7BkdCQkLQtWtXbNq06Urb/v37kZubyyM5iMDEkYzCGxVHrm8kIgoYmZmZqufuHGtx4cIF/Pzzz54KKaBlZmZi+fLlqjaTyYT9+/cjuAZ7ERw5cgStWrVStc2ePdth4ti7d2+Ehoaqdr5dsGABXn755RpvtmTPbbfdpkocy8vLMX/+fDz00EMeH4vI33CqKhkDK45ERFSFyMhI1fPKiaQzPvzwQ26O46S5c+eipKRE1TZ+/PgaJY2AbUfWbt26qdq2bNmCgwcP2r2+du3aGDJkiKrtzJkzWLBgQY3icGT06NGatnfeecenR7YQGRUTRzKG6GggIsIzFUfljDhWHImIAkb9+vVVzzdv3lzl2rjKDh06pNmVlRyzd1TG5MmTPXJve/epapOcWbNmadqeeOIJnD171iPxXKtLly64/fbbVW2HDh3Cs88+6/GxiPwNE0cyBiFsFUJPVBxzc4GiIlYciYgCSN++fVXPCwsL8dxzzznVNy0tDcOHD2e10UlbtmzBr7/+qmpr06YNOnfu7JH7jx8/XjPNdN68eQ6ren379sWAAQNUbRcuXMCQIUNU6yWddfLkySpf/+c//6lpe+ONN/DGG2+4PFZxcTHOnz/vcj8iI2LiSMZhNnum4qjcg4kjEVHAGDNmjGaa5Ntvv41nnnmmymmEixcvRs+ePXH06FEA9s/qIzV71b9JkyZ57P7x8fEYOnSoqi0jIwPLli1z2Ofzzz9HfKUjtg4ePIiuXbvio48+qnYqaUlJCVauXImRI0eiX79+VV7bv39/PPnkk6o2KSWeeuopjB49GocOHaqyP2BLTl9++WU0a9YM33//fbXXE/kDbo5DxmEyAZ7YJl2pWnKqKhFRwGjevDmSkpI0UyhfeeUVfP755xg7diw6duyI6OhoZGVl4ffff8eyZcuuJIwAEBERgddffx0PP/ywr8P3G/n5+Vi0aJGqTQiB+++/36PjTJ48WZNQzZ49G/fcc4/d6xs1aoT58+fj7rvvVq29TE9PxyOPPIJ//OMfGDx4MLp06YL4+HhERETg4sWLOHPmDHbt2oWNGzfi4sWLAIAbbrih2vheeeUV7N69W7OZ0nfffYdly5ahc+fOGDRoEBo3boy4uDgUFxcjKysLv/76K7Zv3449e/a4+pYQGR4TRzIOsxm4Ziczt7HiSEQUkN5++21s3bpVM43y3LlzePfdd6vsGxoaioULF7q1G+v1ZPHixZq1o3369EHTpk09Os6IESMQExODnJycK22rVq3C2bNnHSZ2gwcPxurVq3HPPfdoNkfKzMzEggULPLZpTnBwMFasWIHp06dj3rx5qtcqKiqwfft2bN++3SNjEfkLTlUl4zCZgMxMoKysZvdhxZGIKCDFxMRg9erV6NWrl0v96tevj1WrVmHEiBFeiixweHuaqiIiIgJjxoxRtZWXl2POnDlV9uvXrx+2bdtWoz9Lk5O/WA4PD8fcuXPxwQcfON2nsuDgYMTFxbnVl8homDiScZjNth1R3dhiXcVqBYKCAP5DTUQUcOrXr49169bhgw8+QPPmzau8tnHjxvjXv/6FQ4cOaTZXIa3Dhw8jNTVV1RYWFoaxY8d6ZTx7u6vOnj0bUsoq+zVr1gxLly7Ftm3bMGnSJCQmJlY7VkJCAiZOnIhly5a5XCl85JFHcPz4cbz55pvo3r17tUeSBAUFoVu3bnjhhRdw8uRJu0d8EPkjUd0P5/WiS5cucseOHXqHcX1bsgS45x5g927gllvcv8/06cCKFQB3MSOd/Pbbb2jbtq3eYRBdF44cOYJt27YhPT0d+fn5iIyMxA033IAOHTqgTZs2eodHPiClxP79+3HkyBFkZmYiKysLISEhiI6ORsOGDdGmTRu0aNECQgiPjHfx4kVs27YNVqsVGRkZKCgoQFRUFGJjY9GyZUu0a9cOderU8chYRNfyxecLIcROKWUXe69xjSMZhzINpKZHclitXN9IRHSdaNmyJVq2bKl3GKQjIQQ6dOiADh06+GS8unXrYsiQIT4Zi8hIOFWVjENZk1jTIzksFq5vJCIiIiLyICaOZBysOBIRERERGRITRzKOqCggMrJmFUcpWXEkIiIiIvIwJo5kLCZTzSqOly4BJSWsOBIREREReRATRzIWs7lmFUelLyuOREREREQew8SRjKWmFUelLyuOREREREQew8SRjMVTFUcmjkREREREHsPEkYzFZAKysoDSUvf6KxVHTlUlIiIiIvIYJo5kLErCl57uXn+LBQgOBmJjPRcTEREREdF1jokjGUtNz3JUznAM4l9tIiIiIiJP4adrMhal4ujuOkeLhesbiYiIiIg8LETvAGpKCHESQC6AcgBlUsouQohYAIsANAVwEsB9UspsvWIkF3ii4sj1jUREREREHhUoFccBUspbpJRdLj9/GsAvUsqWAH65/Jz8gaemqhIRERERkccESuJY2UgAn1/+788BjNIxFnJF7dpAdLR7U1WlZMWRiIiIiMgLAiFxlAB+EkLsFEI8eLnNJKU8DwCXvyba6yiEeFAIsUMIsSMjI8NH4VK1TCb3Ko7Z2bZjPFhxJCIiIiLyKL9f4wigt5TynBAiEcBqIcQhZztKKf8L4L8A0KVLF+mtAMlFZrN7FUelDyuOREREREQe5fcVRynluctf0wF8C6AbAKsQoj4AXP7q5qGApAt3K45KH1YciYiIiIg8yq8TRyFEpBAiWvlvAEMAHACwDEDS5cuSACzVJ0JyCyuORERERESG4u9TVU0AvhVCALbvZb6U8kchxHYAi4UQ0wCkARirY4zkKpPJtl6xuBgID3e+HyuORERERERe4deJo5TyOICOdtqzAAz0fUTkEUrFMD0daNTI+X4WCxAaCtSr5524iIiIiIiuU349VZUClLtnOSpnONoq0ERERERE5CFMHMl4lIqjq+scLRZOUyUiIiIi8gImjmQ8Nak4cmMcIiIiIiKPY+JIxqMkjqw4EhEREREZAhNHMp5atYA6dVyrOFZU2DbTYcWRiIiIiMjjmDiSMZlMriWOFy4A5eWsOBIREREReQETRzIms9m1qarKtaw4EhERERF5HBNHMiZXK47Ktaw4EhERERF5HBNHMiZWHImIiIiIDIOJIxmTyQRcugQUFTl3PSuORERERERew8SRjEmpHDo7XdViAcLDbbuxEhERERGRRzFxJGNSKofOJo5Wq62PEN6LiYiIiIjoOsXEkYxJqTg6u87RYuH6RiIiIiIiL2HiSMbkbsWRiIiokvfeew9CCNUjMzPTa/08Re/x9bZixQrN979jxw69wyK6bjFxJGNKTLR9daXiyMSRiIiIiMgrmDiSMYWHA/XqOVdxLC8HMjI4VZWICMD777+vqdIMGjTIa+PNmjVLM96DDz7otfGISF+dOnXS/MwLIXDgwAG9QyMvY+JIxuXsWY6ZmUBFBSuOREQA7r//ftSqVUvVtmbNGpw6dcrjY5WXl2PevHma9mnTpnl8LDK+AwcOaJKJr7/+Wu+wyIP27NmD3bt3233ts88+83E05GtMHMm4TCbnKo7KNaw4EhGhbt26GDNmjKpNSok5c+Z4fKwffvgB58+fV7W1b98e3bt39/hYRKS/Tz/91OFr8+bNQ0lJiQ+jIV9j4kjG5WriyIojEREA+xW/OXPmQErp0XFmz57t1NhE5P+Kioowf/58h69nZWVh6dKlPoyIfI2JIxmXs1NVlWtYcSQiAgAMGDAAN954o6rt5MmTWLt2rcfGyMjIwIoVK1RtoaGhmDRpksfG0Ntjjz0GKaXqER8fr3dY1427775b8/536dJF77CuW0uWLEF2draqTVQ6P5vTVQMbE0cyLpMJyM0FCgqqvo4VRyIiFSEEHnjgAU27vQqhu7744guUlpaq2kaMGIGEhASPjUFExlE5KUxISMDUqVNVbatXr8bp06d9GRb5EBNHMi6lgljddFWLBYiIAKKjvR8TEZGf+MMf/oCgIPX/5pcsWYJLly555P7JycmaNk5TJQpMJ06c0MxYmDhxouZnvqKiwivrqckYmDiScSkVxOoSR6vVdm2l6RJERNezhg0bYujQoaq2wsJCLFy4sMb33r59O/bv368Zb8iQITW+NxEZz+zZszVrpKdMmYKePXuiVatWqvbk5GSPr6cmYwjROwAih5SKY3XrHC0Wrm8kIrJj2rRp+OGHH1RtycnJeOihh2p0X3vVxj/84Q8IDg52+V4WiwWHDh3C8ePHcenSJRQUFCA6OhqxsbFo2LAhunbtisjIyBrFaxRlZWXYtGkTTp48ifPnz0MIgYSEBNx0003o1KmTW++fswoKCnD48GEcPnwYmZmZyMnJQWhoKGJjYxEfH49OnTqhUaNGXhvfKIqLi7F161acPXsW6enpKCgoQHx8PBITE3HzzTdr1gZ7y8mTJ7Fjxw6kpaWhqKgIsbGxMJvN6N27t+Gme9urIrZv3x6dOnUCYEsgn3322SuvnThxAmvWrMHAgQO9Eo+UEvv27cOxY8eQlZWFrKwsBAUFITo6Gk2aNEHbtm3RrFkzj42XnZ2N7du3IyMjA5mZmcjLy0NUVBRiY2PRunVrtGvXDlFRUR4bz9AqLzq+Xh+dO3eWZDBnzkgJSPnRR1Vfd/PNUo4c6ZuYiJxw8OBBvUMgklJKWVJSIhMSEiQA1ePXX391+56FhYWybt26qvsJIeSxY8ec6p+dnS3nzJkj77//ftmwYUNNbJUfISEhskePHnLOnDmypKTErZj/7//+T3PfjIwMr/Wr7Ny5c/Lhhx+WcXFxDr/PuLg4OWvWLJmVleWR8cvLy+W6devkzJkzZefOnWVwcHC173Xjxo3lX//6V3n27Fmnvzd7Mbr6uOuuu+zee/ny5Zprt2/f7nRs1/r+++/lsGHDZO3atauMpVWrVnLWrFlu/TlLKTV/xjNmzFC9vnDhQtm5c2eH4wshZO/eveXPP//s1vjesHLlSk2cr7/++pXXT506JYUQqtcnTpzo8ThWr14tx44dW+XPkfKoX7++TEpKkj/99JOsqKhweaysrCz5/PPPy86dO8ugoKBq/43q3bu3fPXVV+X58+c9/n1fyxefLwDskA7yJd0TNqM8mDgaUEmJ7a/o889XfV1CgpQPPeSbmIicwMSRjOQvf/mL5oPOX//6V7fv9+WXX2ruN2DAAKf6zpgxQ4aFhbmdYDRt2lRu3brV5Zj1TBxnz54t69Sp4/T3aDKZ5Nq1a2s0/o8//igbNGjg9vscFhYmX3zxRac+cBs9cTx06JDs37+/yzHFxMTIN954w6WxpHScOGZkZMjBgwe7FMPDDz8sy8vLXY7B0+655x5VXEFBQZpfLtx+++2qa2rVqiUvXLjgkfG3bt0qe/fu7fbfrwkTJjg9VoaO8t4AACAASURBVElJifzHP/4ho6Oj3RorJCREHjhwwCPftz16J45c40jGFRoKxMVVvcaxrAzIzOSOqkREDtjbsGbevHkoKytz63412RRny5YtNTog/OTJk+jXrx+++eYbt+/hS2+//TamTp3q0oZEVqsVQ4cOxZo1a9we98iRIzh37pzb/UtKSvDss89i/PjxqKiocPs+ektNTUWvXr2wfv16l/vm5OTgySefxJQpUzS7B7vKYrGgV69eWL16tUv9PvroIzz66KM1GrumMjMzsXz5clXboEGD0KBBA1XblClTVM+rO/PRWXPmzEG/fv2Qmprq9j1ycnKcui49PR233347/v3vfyM3N9etscrKylBYWOhWX3/ANY5kbNWd5ZiRAUjJNY5ERA60a9cOPXr0wJYtW660Wa1WrFy5EiNGjHDpXmlpaZqEpm7duhgzZozLcQUFBaFjx4646aab0KZNGyQkJCA6OhpBQUHIzc3FsWPHsG3bNqxbtw7l5eVX+hUXFyMpKQnt2rVD27ZtXR7XV+bOnYu//OUvmvaQkBAMGjQIAwcORIMGDVBcXIxTp05h+fLl2LVrFwBb4nbvvffikUce8UgsN9xwAzp16oS2bduiSZMmiI6ORu3atZGfnw+LxYJ9+/bhxx9/RFZWlqrf4sWL0b59e/zzn/90eO+EhAR07NgRgC1ZOHz4sOr1pk2bok6dOlXG5411hbt378agQYNQVFSkea1t27YYNWoUbrzxRkRHR8NisSA1NRXff/89CiodATZv3jyUlJS4valUSUkJhg8fjiNHjlxp69q1KwYPHoxmzZqhTp06yMrKwubNm7FkyRLk5eWp+n/88ccYOXIk7rzzTrfGr6m5c+dqftmTlJSkue7ee+/FjBkzkJ+ff6Xts88+w4wZM9we+6233sLMmTPtvtakSRMMGTIE7dq1Q0JCAoKDg5GdnY2jR49ix44dLv+SKjMzEz169MCJEyc0r4WFhaF3797o378/GjRogLp16yIvLw/p6enYs2cPNm/ejFOnTrn9ffoVR6XI6+3BqaoGdfvtUvbq5fj13btt01m/+cZ3MRFVg1NVyWg++eQTzZSqkW6sDX/++ec193nkkUec7t+tWzc5bNgwuXDhQtVavqqcP39ePvjgg5pxu3fv7vS4vp6qeubMGbvTU/v27SuPHDnisN9PP/0kGzdufOX6iIgIt+Nu1aqVfO2115xez1paWio/++wzGR8fr5mW6Ow99u/fr4n3q6++cqqvPe5OVc3Pz5etW7fW9E1MTJSLFy922C89PV2OHz/e7hTETz/91KmYK09VrVWr1pX/vummm+SGDRsc9j137pzdabV6fkZt3769Kpbo6GhZUFBg99opU6ZoYt+1a5db4/7888921+W2bt1aLlmypNr+Fy9elHPnzpXdunVzOBVaUVZWJgcOHKgZKygoSM6YMUNaLJZqx9uxY4d84oknZFRUlNvrcJ2h91RV3RM2ozyYOBrUxIlS3nij49d/+MH213jjRt/FRFQNJo5XmUy2H9HKD5NJ78iuL7m5uTIyMlKzFsdqtTp9j4qKCtmsWTPNh6sdO3Y4fY+LFy+6E76UUsr33ntPM3ZqaqpTfX2dOI4dO1bTb8iQIbK4uLjavmlpabJJkyYO11A5M/6lS5eqvcaRI0eOSLPZrBpz+vTpTvU1SuL4t7/9TdPPZDLJQ4cOOTXun/70J03/yMhImZmZWW1fRxu39O3b16k/l/z8fNmiRQtN/927dzsVuydt3rxZE8fUqVMdXv/LL79orn/sscdcHjcvL08mJiZq7jV06FCZk5Pj8v1OnDhR5etvvPGGZqzatWvL7777zuWxLly4UKN/56qjd+LINY5kbCZT1Wscldc4VZXIkBz9+FZ3PCt5VlRUFO677z5VW1lZGebNm+f0PdauXauZxtWxY0d07tzZ6XtUN2WxKjNmzMAdd9yhavv000/dvp+3nDlzBkuWLFG1mc1mLF68GGFhYdX2b9SoEb766isEBbn/ES0mJsbtvi1atMA777yjavviiy9QXFzs9j19qaCgAB9//LGmff78+WjdurVT93jnnXfQt29fVVt+fr7d+zojMTERixcvdurPpXbt2nj55Zc17atWrXJr7Jr47LPPNG2V1zJea8CAAWjcuLGq7csvv7Q7XbgqH3/8MdLT01VtHTp0wNKlSxEdHe3SvQDbdGlHCgsL8eabb2raP/30U4wcOdLlserVq1ejf+eMjmscydjMZiA/H8jLA+ydkaN8+uTmOBSgnngC2LNH7yi847bb9I7APbfcAlT6XO0Xpk2bptnYJjk52eEaospmz55t956+NGXKFPz4449Xnm/cuNGn4zvjk08+Ua3JBICXXnrJpQ+TXbt2RVJSkt2NiHxhzJgxiIqKurLerrCwEDt37kSvXr10iccV8+fPx4ULF1Rt9913H26//Xan7yGEwAcffIAOHTrYpudd9sEHH+Bvf/sbhBAuxfTkk0/C7MIvuEeMGIHo6GjVBi07d+50acyays/Px6JFi1RtTZo0Qb9+/Rz2EUJg8uTJeOmll660ZWdn49tvv8WECROcGre8vBz/+7//q7nvvHnzEB4e7sJ34Jw5c+bAWuk3mffcc4/T8V5vWHEkY1MSQkflCYsFiIy0n1QSEdEVvXv3Rps2bVRtv/76K7Zt21Zt35ycHE0VLTw8HPfff79HY6xOy5YtVc+PHDmi2dBFbz/88IPqeXR0NMaPH+/yfR566CFPheSy0NBQNGnSRNV27eZKRmZv51J3dia96aabNFXHs2fP4uDBgy7dJygoyOVfsISHh1/ZcEhRedMhb1u8eLFmZ9EpU6ZUmzTbq0jaq1w6smPHDs2OwHfccQc6dOjg9D1csWzZMk3bk08+6ZWxAgErjmRs1yaOzZtrX7daWW2kgOaPla1rVfUZY906n4VBl02dOhVPPfWUqi05ORndunWrst+CBQs0W8yPGjUKsbGxNYqnsLAQGzZswL59+3DgwAFkZmYiJycHeXl5do+BsDfl7fTp04iLi6tRHJ5SXFyMvXv3qtqGDh2K2rVru3yv7t2744YbbsDZs2c9EtvevXuxY8cO7Nu3D2lpacjNzUVOTo7DnSePHz+uep6WluaROLxt06ZNqucJCQlVVsmqct999yElJUXVlpqaivbt2zt9j5tvvhn16tVzeezmzZurKuquHOniCa5OU1W0atVKs4vzmjVrcPLkySqnjCrW2fkfw+TJk6vt546ysjLNMR+tWrVC9+7dvTJeIGDiSMamTO1wdCSHxcL1jURETpoyZQqeeeYZ1RmOCxYswFtvvYWIiAiH/WpydqM9Bw8exGuvvYZvv/3W7fPSFBcvXqxRf0/at2+fJhFzZQ1oZZ06dapR4lhQUIB3330Xc+bMwe+//+72fQBjvc+OpKen48yZM6q2zp07uzy1VNG1a1dNm3JkirMqV8mdVXlqsy8Tx8OHD2sSqp49e6JFixZO9U9KSlIljlJKJCcn41//+le1fTdv3qxp6927t1PjuurAgQOaf3+8NVag4FRVMrbqpqqy4khkaI5+PPljqw+TyYS7775b1Xbp0iV8++23DvscPHgQW7duVbU1adIEAwcOdHn8iooKPPPMM7jlllswd+7cGieNgO8rMVWpvKEHAKc3ZLGn8tRiV6xZswbt2rXDM888U+OkETDW++xIZmampq0mZ322a9fOqTGq4m5VPjQ0VPW8tLTUrfu4w1610d7ZjY6MGzdOsx4xOTnZ7iyCyiqvN4yJidFsuOMplccCbBVicoyJIxlbQoJtrhsrjkR+yWKxdxiH4x9p8j57lUJ7G99U9doDDzzg8q6fFRUVmDp1Kl555RWPfgj25Qfq6tirytVkh0V3+/7www8YNmyYRw8lN9L77Eh2dramrW7dum7fLyoqCiEh6sl5lTfeqU7lBNDoysrKMHfuXFVbeHg4xo0b5/Q96tWrhxEjRqjaTp8+bXf9aWWV3193pvk6y96fpTfHCwRMHMnYQkKA+Hj7FcfSUiAri6ULIiIX3HnnnWjQoIGqbc2aNXaTjLKyMnzxxReqNiEE/vCHP7g87n//+198/vnnmvaEhARMnz4dc+bMwcaNG3Hq1ClcvHgRRUVFmjPE9u/f7/K4vmSvghoZGen2/dzpm56ejgkTJmiOzwgODsawYcPw+uuv46effsLBgweRlZWF/Px8lJeX2zvf2u249eLp999ef09UyY1sxYoVmkrc8OHDXU7A7VUondkkJycnR/U8youbH1Yey9vjBQKucSTjM5vtlyeUKUGsOBIROS04OBhJSUl45ZVXrrRJKTFnzhw899xzqmu///57zYfIQYMGaXbcrE5BQQGeffZZVZsQAs899xyefvppp7fZr7xBj9HYO2MuPz/f7fu50/e5557TTCvt3bs3vvjiC6c2J1EY/b22x9Pvv73+7pwj6E/sJXdff/212+tEr7V06VJkZWVVuZlVTEwMLNd85lOOhPEGe+dqenO8QMCKIxmfyWS/4sgzHImI3DJ16lTNB8E5c+aozqwDPHd2408//aQ5NuPpp5/Gc88959LZbK5OE/Q1e1WZmqwNdLVveXk5vvrqK1VbixYtsGrVKpeSRsD477U99qYZ1mRTn/z8fNVGUoD7axb9wfnz5zXHyXhSSUmJZgZDZZWTSnvTjz3FXgLrzfECARNHMj5HFUeljRVHIiKXtGjRQnNEwcmTJ7F27dorz9PT07Fy5UrVNbGxsRg1apTL41Ve2xQWFoZZs2a5fJ/KR0QYTWJioqatJufvHTp0yKXrd+3apUnQZ86c6fJ0zby8PGRkZLjUxwgSEhI0bb/99pvb97N3ZmN8fLzb9zO6OXPmoLy83KtjVDdd1VzpM11OTo5H1+pWNRZg2xmZHONUVTI+peIopfpQOFYciYjcNm3aNKxfv17VlpycjNtvvx0AMHfuXE21ZdKkSS5VCBWnT59WPe/QoYNbG7/Y26rfSDp06ICwsDDVkRw7d+50+36uHv1Q+X0GoDnE3hnbtm3zegLhDQkJCWjYsKHqSI6dO3dCSunWVMvt27dr2vxx7aezKh+7ExQUVONdRs+dO6f6JcT+/fuxfft2u0edALZjPyrv8pyamury9HhntG/fHjExMaq1jpWPISE1VhzJ+MxmoLAQqLwgXak4MnEkInLZvffeq0nevvnmmyvTI+2d3Th16lS3xqp8hIE70/0KCgqwYsUKt8b3lfDwcHTs2FHVtmrVKrfWC27dutXlMxztHRXhznu9aNEil/sA0OxACsDnCWivXr1UzzMyMpCSkuLWvSpP+7V3/0Cxfv16HDlyRNU2YMAA7Nmzp0aP999/XzNWVbs433bbbZq2efPm1fj7syc4OBh9+vRRtR05ckRz/BBdxcSRjM/RWY5WKxAdDdSu7fuYiIj8XEREBCZMmKBqKywsxMKFC7F161bNNL3OnTtrkiJnVZ4q6epZeIAtkfWH9Ud33nmn6nlubi4WLlzo8n0++eQTl/vYm5Lq6nudnp5e7To0R+xtHOPrzUaGDh2qafvoo49cvs/Bgwc1FfmGDRvaPdsxENibQjpp0qQa33f48OGaX1AtWLDA4S9TOnXqpDm3cdWqVV6bQjp69GhN2+uvv+6VsQIBE0cyPmUOeuV1jhYLq41ERDVgb6Ob5ORkj22Ko6hfv77q+d69e+0evu1IWloannnmGbfH96Xp06cjODhY1fb3v//d7tb/juzcudNuxbc6ld9nwLYxkSseeughFBQUuDw2YH9zGl+vS50wYYKmyrpw4UJNElidGTNmaDaLmjFjhkd2FzWanJwcfPPNN6q2iIgI3HPPPTW+d61atXDvvfeq2i5duoSvv/7a7vXBwcH461//qmqTUmLy5MmaI2Y8YfLkyZrjiZYsWYIFCxZ4fKxAwMSRjK+qiiM3xiEicluXLl3QoUMHVdvWrVs1U8PsVSddUXmdXXl5Of72t7851ddqteLuu+92KfHSU8OGDTFmzBhV2/nz5zF+/HiUlpZW2//s2bMYO3YsKioqXB67e/fuCAsLU7W9+eabSFeOr6rGrFmz8N1337k8rqJ27dq48cYbVW3e3KXTnoiICDz88MOa9okTJ+LYsWNO3WPmzJlYt26dqi0qKgoPPvigJ0I0nPnz52t+WTBy5EiPHT1ir3JZ1SY5f/zjHzXJ3L59+zBy5Ei3KtgnT550+Fp4eLjdjbr++Mc/YtmyZS6PdfHixRrtpGx0TBzJ+KpKHFlxJCKqEXuVxMrTyMaMGePyAeDXGj58OGrVqqVqS05OxuOPP46ioiKH/ZYvX44ePXpg//79AOyfu2ZEb7/9tmZ63g8//IDBgwdXmbz88ssv6NOnD06cOAHAlgS5IjIyEsOGDVO1WSwWDBo0qModWtPS0jBmzJgrU/SEEG4nDZXXAO7evRuPPvqoy+s1a+Lvf/872rRpo2o7d+4c+vbtW2VinJmZiUmTJuGtt97SvPbuu+8G7FEc3pqmqujfvz8aNWqkalu/fj2OHj1q9/qIiAgsXLhQs2Z21apV6Nq1K5YuXVrtmLm5ufjyyy/Ro0cPPPbYY1Ve+9hjj+GOO+5QtRUUFGDMmDF4/PHHnZodsXfvXsycORONGzfWrBUNJNxVlYwvPh4ICrI/VfXy7n9EROSeSZMm4amnnqpyGlhNpqkCtm3vH330Uc0H8vfeew+LFy/G2LFjceutt6JOnTrIzs7G0aNHsXz5ctVRCqGhoXj77bdrHIsv3HDDDfjPf/6DpKQkVfv69evRtm1bDB48GLfffjsaNGiAkpISnDp1CsuXL8eOHTuuXFuvXj088sgjePnll10a+7nnnsOyZctUFcv9+/fjpptuwl133YXbbrvtyrjnz5/HmjVrsHbtWtVOsI8//jhSU1Pd2hF26tSpmjWSH374IT788EOYTCbExcUhNDRU9Xq/fv3wn//8x+WxHKlduzbmz5+PXr16qX4xcf78eYwePRrt27fHqFGjcOONNyIyMhJWqxWbNm3CihUrkJ+fr7nfuHHj3N4Yyuj279+v+nsH2HantbdW1F1CCNx///149dVXVe3Jycl46aWX7Pbp27cv3nzzTTzxxBOq9kOHDmHUqFFo0qQJhg4divbt2yM+Ph7BwcHIzs7GsWPHsGvXLmzatOnKn/1dd91VZXxBQUH44osv0L17d9UvdsrLy/Hee+/hv//9L/r27Yv+/fujfv36qFu3LvLz85Geno69e/di8+bNhj8qyGOklHxIic6dO0syMJNJyunTrz4vKpISkPKFF/SLiciBgwcP6h3C/7d3/1Fe1fedx5/vGUB+DVnAEUSC4A8iLs3ahJBlzSoRkiYaWzyua3KMwTWbmB4akxO2Vj2b1p7T2GNXm5zVtNmkVkhjkzRp/ZXGmEZDWnF1QTetUUyCgjYizIBmwSkozLz3j++d8nWYufMdGOb7/Q7Pxznf8733fj/33vfg5cu8/Hzu50pDcumllybQ7+uUU07Jnp6eIz7H3r17c/HixQOep+zV0tKSX/va1/LJJ5885LNvfetbg5771ltvPWS/zs7Oo7Zfr1tuueWwft5x48blD37wg8M+/80333xY5wXyggsuyP379+fb3/72Q7bX6pJLLhnyOftz3333HdJ2w4YNNdfx8MMP57Rp0w77zwLID3/4w/n666/XfM7p06e/Yf9Vq1bVvG+11atXv+E4kyZNOqzjDObqq68+5Gf+5Cc/Oezneeqppw45z6xZs/LAgQOl+91xxx05bty4I/pvWOu129HRkWefffYRnWuo1+hQjcTvF8DGHCAvOVRVzWHmzDf2OPber+E9jpJ0xMp68a688sphmRBk/PjxfPe732X58uVD2u/444/nnnvu4bLLLjviGkbaZz7zGW6//fYhPbOyvb2d+++/n2XLlh32eVevXs3NN9/c7+MxBhIRrFq1irvuumtI+/VnzZo1XHXVVXWfSObss89m/fr1nHPOOUPed8qUKdx000189atfPaSHdLR47bXXuPPOOw/ZPpzDVHudeeaZnHXWWW/Ytm3bNr73ve+V7nfFFVewbt06Fi9efNjnnlHjbU3t7e089NBDXHfddf3OUFyLiRMnMnny5MPatxkYHNUcZsx44z2Ovcve4yhJR2z58uXMnTv3kO0tLS2HDLc8EtOnT+eBBx7gjjvuYMGCBaVtTzzxRK6//nqeeeYZPvCBDwxbDSPtyiuvZNOmTVx11VWl98hNnTqV1atX8/TTT3PeMNyGsXr1ajZs2MDFF19cGgSPO+44LrroIh555BFuu+22YQlJEydO5Etf+hLPPfccN954IytWrGD+/PlMmzbtkMl7jrYzzjiDH/3oR9x3332cf/75g943etppp3HNNdewefNmrrnmmrqH36Pp7rvvZteuXW/YNn/+/CMKaWUuv/zyQ7aVTZLTa8mSJTz22GPce++9XHjhhTXdfzt37lw+8YlPsH79+prO0WvcuHHceOONPPvss1x77bU1PX7luOOOY9myZdx6661s27btkPtrR5PIPlMNH6sWLVqUfcd4q4GsXAnr1sHzz1fWv/MduPBCeOwxOEpfcNLh2rRp06C/FEuCLVu28Oijj9LR0cGePXuYOHEis2bNYuHChSxcuLDe5Q27/fv388gjj7B161a2b99OZtLe3s7ChQtZtGjRIY/xGC579uxh/fr1bN26lZdffpmWlhamT5/O/Pnzecc73sHEY+h5yPv27ePRRx/lxRdfpLOzk7179zJ9+nTa29t561vfyqmnnlrvEjWI/fv3s3HjRl544QV27tzJK6+8wvjx45kyZQrz5s1jwYIFzJ49e9jOt23bNp544gk6OzvZuXMn+/fvp62tjfb2dt7ylrewYMGCQyb/OlpG4veLiHg8Mxf195mT46g59PY4ZkKEPY6SNArMmzePefPm1buMETN27FjOPfdczj333BE9b1tb2yGzRh6rxo8fz9KlS+tdho7A2LFjWbJkCUuWLBmR882aNeuQx4McqxyqquYwcya89hr0Phun935Hg6MkSZJ01Bkc1Rz6Pstxxw5405tghIYGSJIkSccyg6OaQ+/sqb09jdu3O6OqJEmSNEIMjmoO/fU4OkxVkiRJGhEGRzWH/nocDY6SJEnSiDA4qjlMmwatrW/scXSoqiRJkjQiDI5qDi0tcMIJlcC4b19ldlV7HCVJkqQRYXBU85g5szJEtbfX0R5HSZIkaUQYHNU8ZsyohMbe4GiPoyRJkjQiDI5qHr09jr0T5NjjKEmSJI0Ig6OaR2+PY29wtMdRkiRJGhEGRzWPmTNh/3545pnK+gkn1LceSZIk6RhhcFTz6O1h/Md/hKlT4bjj6luPJEmSdIwwOKp59N7T+OMfe3+jJEmSNIIMjmoevT2OL7/s/Y2SJEnSCDI4qnlU9zLa4yhJkiSNGIOjmsfUqTB2bGXZHkdJkiRpxBgc1TwiDgZGexzV4DKz3iVIkqRRohF+rzA4qrn0Bkd7HNXAWlpa6OnpqXcZkiRplOjp6aGlpb7RzeCo5jBzZqXH8fHHK+tXXllZt+dRDai1tZXu7u56lyFJkkaJ7u5uWltb61qDwVHNYceOoW2X6mjChAl0dXXVuwxJkjRKdHV1MWHChLrWYHCUpGHW1tbGnj176l2GJEkaJXbv3s2UKVPqWoPBUZKG2eTJk9m7dy8HDhyodymSJKnJHThwgH379jFp0qS61mFwlKRh1tLSwuTJk9m1a1dDzIImSZKaU2aya9cuJk+e7OQ4kjQazZgxg66uLjo7Ow2PkiRpyDKTzs5Ourq6mNEATxQwOKo5DPSXpQH+Ekn9GTNmDHPmzOHVV1+lo6PDYauSJKlmBw4coKOjg1dffZU5c+YwZsyYepdE/SuQarF9e70rkIasNzzu2LGDZ599lvHjxzNlyhQmTZpEa2srLS0tRES9y5QkSXWUmfT09NDd3U1XVxe7d+9m3759TJ48uWFCIxgcJemoGjNmDCeddBI9PT3/+o/Brl276O7upqenp97lSZKkBtDS0kJraysTJkxg2rRpTJo0qe73NPZlcJSkEdDS0kJbWxttbW31LkWSJGnIGivGSpIkSZIajsFRkiRJklTK4ChJkiRJKmVwlCRJkiSVMjhKkiRJkkoZHCVJkiRJpQyOkiRJkqRSBkdJkiRJUimDoyRJkiSplMFRkiRJklTK4ChJkiRJKjUqgmNEtEbE/42I7xTr8yLisYj4eUR8MyLG1btGSZIkSWpWoyI4Ap8CNlWt3wR8PjNPB14BPlqXqiRJkiRpFGj64BgRs4ELgD8r1gM4D/h20WQtsKI+1UmSJElS82v64Ah8AbgG6CnWpwO/zMwDxfovgJPqUZgkSZIkjQZNHRwj4gNAR2Y+Xr25n6Y5wP4fj4iNEbGxs7PzqNQoSZIkSc2uqYMjcDbw6xGxFfgGlSGqXwD+TUSMKdrMBrb1t3NmfjkzF2Xmovb29pGoV5IkSZKaTlMHx8y8LjNnZ+Zc4IPAQ5l5GfBD4D8VzVYC99SpREmSJElqek0dHEv8DvCZiNhM5Z7H2+tcjyRJkiQ1rTGDN2kOmbkOWFcsPwcsrmc9kiRJkjRajNYeR0mSJEnSMDE4SpIkSZJKGRwlSZIkSaUis99HHB5zIqITeL7edfTjeGBnvYuQhsBrVs3Ga1bNxmtWzcZrtnmcnJn9PqfQ4NjgImJjZi6qdx1Srbxm1Wy8ZtVsvGbVbLxmRweHqkqSJEmSShkcJUmSJEmlDI6N78v1LkAaIq9ZNRuvWTUbr1k1G6/ZUcB7HCVJkiRJpexxlCRJkiSVMjhKkiRJkkoZHBtYRLwvIn4aEZsj4tp61yMNJiK2RsSTEfHjiNhY73qkviLizyOiIyJ+UrVtWkT8XUT8vHifWs8apWoDXLM3RMSLxXftjyPi/HrWKPWKiDdHxA8jYlNEPBURnyq2+z07ChgcG1REry0I5gAACbVJREFUtAJfBN4PnAl8KCLOrG9VUk3enZln+bwmNag1wPv6bLsWeDAzTwceLNalRrGGQ69ZgM8X37VnZeZ3R7gmaSAHgNWZuQD498Cq4vdXv2dHAYNj41oMbM7M5zLzdeAbwG/UuSZJamqZ+ffAy302/wawtlheC6wY0aKkEgNcs1JDysyXMvOJYnkPsAk4Cb9nRwWDY+M6CfjnqvVfFNukRpbA9yPi8Yj4eL2LkWo0IzNfgsovPcAJda5HqsVvRcQ/FUNZHfanhhMRc4FfBR7D79lRweDYuKKfbT47RY3u7Mx8G5Uh1qsi4px6FyRJo9CfAqcCZwEvAbfUtxzpjSJiMvDXwKczc3e969HwMDg2rl8Ab65anw1sq1MtUk0yc1vx3gHcRWXItdTodkTEiQDFe0ed65FKZeaOzOzOzB7gK/hdqwYSEWOphMY7M/Nvis1+z44CBsfGtQE4PSLmRcQ44IPAvXWuSRpQREyKiLbeZeC9wE/K95Iawr3AymJ5JXBPHWuRBtX7C3jhIvyuVYOIiABuBzZl5h9XfeT37CgQmY5+bFTF9NpfAFqBP8/Mz9W5JGlAEXEKlV5GgDHAX3rNqtFExNeBpcDxwA7g94C7gb8C5gAvAJdkppORqCEMcM0upTJMNYGtwFW9949J9RQR7wL+AXgS6Ck2X0/lPke/Z5ucwVGSJEmSVMqhqpIkSZKkUgZHSZIkSVIpg6MkSZIkqZTBUZIkSZJUyuAoSZIkSSplcJQkNaSImBsRWbzW1LueZhQR63r/DOtdiySpuY2pdwGSJB2OiLgCmAuQmTfUs5aREhErqDy/D+ALmfnLetYjSTp2GBwlSc3qCuDcYvmG+pUxolYAK4vlNYDBUZI0IgyOkqSGlJlbgah3Hc0sM5fWuwZJ0ujgPY6SJEmSpFIGR0mSJElSKYOjJKkhDTSrau9MoRy8v5GqdtWvGwY4bktE/OeI+GZEbImIf4mIPRHxTET8aUT8yiB13VB1jqXFtmUR8fXiePuKz+ZW7TMmIn4tIm6JiIcjoiMiXi/O+7OIWBMR55Scc03xM6+s2ryln595TZ/9ap5VNSLeGRFfjoifFnV1RcSzEbE2Is6rYf/eGtYV6xMj4r9FxMaIeKU43lMR8YcRMXWw40mSGov3OEqSjhkRcSrwbQ7OTFrtLcXr4xHxucz83doOGbcBqwZp93fA0n62jwVOL14rI2It8PHMfL2Gcw+LiBgD/AnwsX4+PqV4fSQivgWszMy9NRzzFOA+4Mw+H51ZvD4UEUuL+1glSU3A4ChJajb/HTge+APg3xbbLuqn3TPVK0VofLTYF+Ax4B5gC9AKvI3KTK3TgM9GRE8Nj/n4beD9wHYqs5z+hMq/rYuB16raTQBeBR4EHge2AvuAE4uf4TJgEpUexV8Cn+5znv8J3A1cDby72HYV0NGn3QuD1NufrwIfKpb3AWuBR4BuYBHwUaANuAR4U0S8LzPLejCnAH8LnAHcC9wPvEwlgP4mMAc4uTjvgL2skqTGEuXf/ZIk1Ucx1HNLsbo2M6/o8/k6iuGqmVk6+2pEtAAbqITDbuBjmXlHP+1OAB6g0iPZA7w1M5/q0+YG4PeqNj0MXJCZu0vOvwx4ZKDeuoiYTiUYvqs472mZuaWfdms4OFx13mA9doP9GUXEpcA3itUdwHmZ+XSfNicDPwTmFZt+KzO/2M+xqn+heB24ODO/08/PuaHqWO/MzP9T9jNIkhqD9zhKko4FK6iERoDf7y80AmRmB3AplXDZAnxqkON2AZeWhcbiuA+WDfHMzF0cDIQtVHogR8LvVC3/l76hESAznwc+CPQGw9+OiNZBjvsHfUNjcaxdwI1Vm35tiPVKkurE4ChJOhZcXry/Dtxa1jAzfwb09oK9d5Dj/nVmbjvC2nrP+xyVIa8A7xyOY5YpenR/tVh9MjPvH6ht0Sv4ULF6MvD2kkN3A7eVfP5Q1XLfeyAlSQ3KexwlSceC/1i8dwBLI0pHtkIl/ACcHBETSnoL/6HWAiJiCpWexPOBX6Fyr+WkAZrPrvW4R2Bx1fL3a2j/fWBZsfxODobrvn6Wma+UHOfFqmVnV5WkJmFwlCSNahExGZherM4G7hriIaYCAwXHFwfY3reGdwN/Ccys8ZxTamx3JE6sWv5ZDe2r25w4YCvYWXaQzHytKriPr+G8kqQGYHCUJI12bzrC/ceVfFbLoylOpzLL6IRi00+pzDT6cyqzje6rav5loJ3KLK9HW1vVclcN7V8dYN++eg6vHElSIzM4SpJGu+rAsy4z3z1gy6PjOg6Gxs8Bnx3ocRYR8ZURqwr2VC0PNGS22uQB9pUkHQOcHEeSNKpl5v/jYHg8M2q4wXGYLS/eO4DfLQmNbVSeITlSXqpaPr2G9tVthmVCIElS8zA4SpKa1b8OiawhDP598X4C8B+OWkX9m1G8b8nMsmGcyxn83+Xq/Y80AFdPbvOeGtpXzzDrsxcl6RhjcJQkNavqIaiDDbVcW7V8Yw3PIRxO/1K8nzJQwC3qub6GYw3lZy6VmVuBJ4rVfxcRAz56JCIWAecVq88Djx/JuSVJzcfgKElqVluqlt82SNtvAxuK5XOAO4uhof2KiPERsTIiPniENVJ13nbg0/2cayzwFWBRDccays9ci5uqltdExBl9G0TEHOAbHPyd4X9kZnffdpKk0c3JcSRJzepB4Opi+faI+DyV3rDeULM5MzcDZGZPRFwM/G/gJOBS4L0R8U0qvWe/BCYCb6bycPv3UJkM5rPDUOetHBwK+scRsRR4ANhF5b7BjxTvPyzey57h+GDV8h9FRDuVWVoPFNtezMwnay0sM/8qIlYAH6LyiI0nImINlT+nbiph9qMcfDzI94E/qfX4kqTRw+AoSWpWfws8DLwLOA34Yp/Pfx+4oXclM/85It4B/AWVB9lPBT5RcvxuYPuRFpmZ90XEH1KZXRXg14tXtfVUwuwGSmTmP0XE16kEvRnAzX2arAWuGGKJH6HyOI7/SmX2198sXn19G/jIQJP7SJJGN4eqSpKaUjFc8j3AtVR6yF7hYG/jQPu8lJnLgaXA/wKeotLb2A3sBp4GvkklOL05M/9smGq9Hng/lbC7E9hPZVbTh4CPAUszs7PGw11e1LeuONaB0taD13YgMz8GLAFuBzZTCZJ7qQyN/RqwLDMvycxBn1spSRqdwv9xKEmSJEkqY4+jJEmSJKmUwVGSJEmSVMrgKEmSJEkqZXCUJEmSJJUyOEqSJEmSShkcJUmSJEmlDI6SJEmSpFIGR0mSJElSKYOjJEmSJKmUwVGSJEmSVMrgKEmSJEkq9f8Bxg/Pu15F6koAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "###################################\n",
    "# Plot training curve             #\n",
    "###################################\n",
    "# plt.title('Training loss')\n",
    "# loss_hist_ = losses[1::len(losses)//20]  # sparse the curve a bit\n",
    "acc_hist_ = np.array(accuracies[1::len(accuracies)//20])*100\n",
    "val_his = np.array(val_accuracies)*100\n",
    "\n",
    "# loss_hist_ = losses\n",
    "# acc_hist_ = np.array(accuracies)*100\n",
    "\n",
    "# plt.plot(loss_hist_, '-o')\n",
    "# plt.xlabel('iteration', size=30)\n",
    "# plt.ylabel('loss',size=30)\n",
    "# plt.gcf().set_size_inches(15, 12)\n",
    "\n",
    "# plt.show()\n",
    "# plt.close()\n",
    "\n",
    "acc_hist_ = plt.plot(acc_hist_, '-s', color='red', label='Train Acc')\n",
    "val_his = plt.plot(val_his, '-s', color='blue', label='Validation Acc')\n",
    "plt.xlabel('iteration', size=30)\n",
    "plt.ylabel('Acc',size=30)\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "\n",
    "\n",
    "plt.legend(fontsize=50 )\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# conclusion\n",
    "We can get up to ~ 95% accuracy and 96 f1-score in the test set using this simple model and just 5 epochs. To locate or annotate the area, we can use a similar approach as Grad-CAM paper (read [here](https://arxiv.org/pdf/1610.02391.pdf)) which highlights the active regions, this works because the active region is just the countors of the defection which give hint to the model to classify it as a defected one.  A more systematic hyper-parameter tunning like Bayesian optimization or Reinforcement learning (on top of the model) can give us better accuracy too. We have a paper on this in which we used a response surface methodology to tune the hyper-parameters of a deep learning model using Baysian like optimization approaches. We are about to submit it and could observe promising results there."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_2",
   "language": "python",
   "name": "tf_2"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}