Image Classification and object detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6f9332a6",
   "metadata": {},
   "source": [
    "# Image Classification and Object Localization\n",
    "\n",
    "In this Code:\n",
    "- classify the main subject in an image\n",
    "- localize it by drawing bounding boxes around it.\n",
    "\n",
    "Dataset:\n",
    "- [MNIST](http://yann.lecun.com/exdb/mnist/):\n",
    "- Place each \"digit\" image on a black canvas of width 75 x 75 at random locations.\n",
    "- Calculate the corresponding bounding boxes for those \"digits\".\n",
    "\n",
    "The bounding box prediction can be modelled as a \"regression\" task, which means that the model will predict a numeric value (as opposed to a category)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f82b95b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Platform: macOS-12.4-arm64-arm-64bit\n",
      "Tensor Flow Version: 2.10.0\n",
      "Numpy Version: 1.23.2\n",
      "Keras Version: 2.10.0\n",
      "GPU is available\n"
     ]
    }
   ],
   "source": [
    "import os, re, time, json\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "import numpy as np\n",
    "\n",
    "import tensorflow as tf\n",
    "from matplotlib import pyplot as plt\n",
    "import tensorflow_datasets as tfds\n",
    "import platform\n",
    "\n",
    "print(f\"Python Platform: {platform.platform()}\")\n",
    "print(f\"Tensor Flow Version: {tf.__version__}\")\n",
    "print(f\"Numpy Version: {np.__version__}\")\n",
    "print(f\"Keras Version: {tf.keras.__version__}\")\n",
    "gpu = len(tf.config.list_physical_devices('GPU'))>0\n",
    "print(\"GPU is\", \"available\" if gpu else \"NOT AVAILABLE\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39514b9d",
   "metadata": {},
   "source": [
    "## Detecting the devices for distributed strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9ae4f79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 17:09:25.522074: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:306] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2022-10-05 17:09:25.522846: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:272] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n"
     ]
    }
   ],
   "source": [
    "# Detect hardware\n",
    "try:\n",
    "    tpu = tf.distribute.cluster_resolver.TPUClusterResolver() # TPU detection\n",
    "except ValueError:\n",
    "    tpu = None\n",
    "    gpus = tf.config.experimental.list_logical_devices('GPU')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f8473064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on single GPU /device:GPU:0\n",
      "Number of accelerators 1\n"
     ]
    }
   ],
   "source": [
    "if tpu:\n",
    "    tf.config.experimental_connect_to_cluster(tpu)\n",
    "    tf.tpu.experimental.initialize_tpu_system(tpu)\n",
    "    strategy = tf.distribute.experimental.TPUStrategy(tpu)\n",
    "    print('Running on TPU', tpu.cluster_spec().as_dict()['worker'])\n",
    "elif len(gpus) > 1:\n",
    "    strategy = tf.distribute.MirroredStrategy([gpu.name for gpu in gpus])\n",
    "    print('Running on multi GPUs', [gpu.name for gpu in gpus])\n",
    "elif len(gpus) == 1:\n",
    "    strategy = tf.distribute.get_strategy()\n",
    "    print('Running on single GPU', gpus[0].name)\n",
    "else:\n",
    "    strategy = tf.distribute.get_strategy()\n",
    "    print('Running on CPU')\n",
    "    \n",
    "print('Number of accelerators', strategy.num_replicas_in_sync)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2b68e877",
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 64 * strategy.num_replicas_in_sync # Global batch size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2b568935",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_image_tfds(image, label):\n",
    "    '''\n",
    "    Transforms each image in dataset by pasting it on a 75x75 canvas at random locations.\n",
    "    Args:\n",
    "        image: original image in dataset, 28x28\n",
    "        label: label\n",
    "        \n",
    "    '''\n",
    "    xmin = tf.random.uniform((), 0 , 48, dtype=tf.int32)\n",
    "    ymin = tf.random.uniform((), 0 , 48, dtype=tf.int32)\n",
    "    image = tf.reshape(image, (28,28,1,))\n",
    "    image = tf.image.pad_to_bounding_box(image, ymin, xmin, 75, 75)\n",
    "    image = tf.cast(image, tf.float32)/255.0\n",
    "    xmin = tf.cast(xmin, tf.float32)\n",
    "    ymin = tf.cast(ymin, tf.float32)\n",
    "   \n",
    "    xmax = (xmin + 28) / 75\n",
    "    ymax = (ymin + 28) / 75\n",
    "    xmin = xmin / 75\n",
    "    ymin = ymin / 75\n",
    "    return image, (tf.one_hot(label, 10), [xmin, ymin, xmax, ymax])\n",
    "\n",
    "def get_dataset():\n",
    "    '''\n",
    "    Loads and maps the training split of the dataset using the map function. \n",
    "    Note that we need to load the gcs version if using TPU in Google colab.\n",
    "\n",
    "    '''\n",
    "    with strategy.scope():\n",
    "        splits, info = tfds.load('mnist', split=['train', 'test'], as_supervised=True, \n",
    "                                 with_info=True, data_dir='./mnist', download=False)\n",
    "        train_data, test_data = splits\n",
    "        train_batches = train_data.map(read_image_tfds, num_parallel_calls = 16)\n",
    "        train_batches = train_batches.shuffle(5000, reshuffle_each_iteration=True)\n",
    "        train_batches = train_batches.repeat().batch(BATCH_SIZE, drop_remainder=True).prefetch(-1)\n",
    "        \n",
    "        test_batches = test_data.map(read_image_tfds, num_parallel_calls=16)\n",
    "        test_batches = test_batches.batch(10000, drop_remainder=True)\n",
    "        test_batches = test_batches.repeat()\n",
    "    \n",
    "    return train_batches, test_batches, info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "0227f5a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_pil = Image.fromarray(x[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "7e616409",
   "metadata": {},
   "outputs": [],
   "source": [
    "rgbimg = Image.new(\"RGBA\", image_pil.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "bd62938c",
   "metadata": {},
   "outputs": [],
   "source": [
    "rgbimg.paste(image_pil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "f784b252",
   "metadata": {},
   "outputs": [],
   "source": [
    "draw = ImageDraw.Draw(rgbimg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "1cfd67d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "im_width, im_height = rgbimg.size\n",
    "xmin, ymin, xmax, ymax = [0.        , 0.14666666, 0.37333333, 0.52      ]\n",
    "if use_normalized_coordinates:\n",
    "    (left, right, top, bottom) = (xmin * im_width, xmax * im_width,\n",
    "                              ymin * im_height, ymax * im_height)\n",
    "else:\n",
    "    (left, right, top, bottom) = (xmin, xmax, ymin, ymax)\n",
    "draw.line([(left, top), (left, bottom), (right, bottom),\n",
    "         (right, top), (left, top)], width=1, fill='red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "cfe7436a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2c5c69190>"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(rgbimg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "389a4237",
   "metadata": {},
   "outputs": [],
   "source": [
    "im_width = 75\n",
    "im_height = 75\n",
    "use_normalized_coordinates = True\n",
    "\n",
    "def draw_bounding_boxes_on_image_array(image,\n",
    "                                       boxes,\n",
    "                                       color=[],\n",
    "                                       thickness=1,\n",
    "                                       display_str_list=()):\n",
    "    \"\"\"Draws bounding boxes on image (numpy array).\n",
    "    Args:\n",
    "      image: a numpy array object.\n",
    "      boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).\n",
    "             The coordinates are in normalized format between [0, 1].\n",
    "      color: color to draw bounding box. Default is red.\n",
    "      thickness: line thickness. Default value is 4.\n",
    "      display_str_list_list: a list of strings for each bounding box.\n",
    "    Raises:\n",
    "      ValueError: if boxes is not a [N, 4] array\n",
    "    \"\"\"\n",
    "#     print('image', image.shape)\n",
    "    image_pil = Image.fromarray(image)\n",
    "    rgbimg = Image.new(\"RGBA\", image_pil.size)\n",
    "    rgbimg.paste(image_pil)\n",
    "    draw_bounding_boxes_on_image(rgbimg, boxes, color, thickness,\n",
    "                                 display_str_list)\n",
    "    return np.array(rgbimg)\n",
    "\n",
    "\n",
    "def draw_bounding_boxes_on_image(image,\n",
    "                                 boxes,\n",
    "                                 color=[],\n",
    "                                 thickness=1,\n",
    "                                 display_str_list=()):\n",
    "    \n",
    "    \"\"\"Draws bounding boxes on image.\n",
    "      Args:\n",
    "        image: a PIL.Image object.\n",
    "        boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax).\n",
    "               The coordinates are in normalized format between [0, 1].\n",
    "        color: color to draw bounding box. Default is red.\n",
    "        thickness: line thickness. Default value is 4.\n",
    "        display_str_list: a list of strings for each bounding box.\n",
    "\n",
    "      Raises:\n",
    "        ValueError: if boxes is not a [N, 4] array\n",
    "    \"\"\"\n",
    "    boxes_shape = boxes.shape\n",
    "    if not boxes_shape:\n",
    "        return\n",
    "    if len(boxes_shape) != 2 or boxes_shape[1] != 4:\n",
    "        raise ValueError('Input must be of size [N, 4]')\n",
    "    for i in range(boxes_shape[0]):\n",
    "        draw_bounding_box_on_image(image, boxes[i, 1], boxes[i, 0], boxes[i, 3],\n",
    "                               boxes[i, 2], color[i], thickness, display_str_list[i])\n",
    "        \n",
    "def draw_bounding_box_on_image(image,\n",
    "                               ymin,\n",
    "                               xmin,\n",
    "                               ymax,\n",
    "                               xmax,\n",
    "                               color='red',\n",
    "                               thickness=1,\n",
    "                               display_str=None,\n",
    "                               use_normalized_coordinates=True):\n",
    "    \"\"\"Adds a bounding box to an image.\n",
    "      Bounding box coordinates can be specified in either absolute (pixel) or\n",
    "      normalized coordinates by setting the use_normalized_coordinates argument.\n",
    "      Args:\n",
    "        image: a PIL.Image object.\n",
    "        ymin: ymin of bounding box.\n",
    "        xmin: xmin of bounding box.\n",
    "        ymax: ymax of bounding box.\n",
    "        xmax: xmax of bounding box.\n",
    "        color: color to draw bounding box. Default is red.\n",
    "        thickness: line thickness. Default value is 4.\n",
    "        display_str_list: string to display in box\n",
    "        use_normalized_coordinates: If True (default), treat coordinates\n",
    "          ymin, xmin, ymax, xmax as relative to the image.  Otherwise treat\n",
    "          coordinates as absolute.\n",
    "    \"\"\"\n",
    "    draw = ImageDraw.Draw(image)\n",
    "    im_width, im_height = image.size\n",
    "    if use_normalized_coordinates:\n",
    "        (left, right, top, bottom) = (xmin * im_width, xmax * im_width,\n",
    "                                  ymin * im_height, ymax * im_height)\n",
    "    else:\n",
    "        (left, right, top, bottom) = (xmin, xmax, ymin, ymax)\n",
    "    draw.line([(left, top), (left, bottom), (right, bottom),\n",
    "             (right, top), (left, top)], width=thickness, fill=color)\n",
    "\n",
    "\n",
    "def display_digits_with_boxes(digits, predictions, labels, pred_bboxes, bboxes, iou, title):\n",
    "\n",
    "    n = 10\n",
    "    indexes = np.random.choice(len(predictions), size=n)\n",
    "\n",
    "    n_digits = digits[indexes]\n",
    "    n_predictions = predictions[indexes]\n",
    "    n_labels = labels[indexes]\n",
    "\n",
    "    n_iou = []\n",
    "    if len(iou) > 0:\n",
    "        n_iou = iou[indexes]\n",
    "\n",
    "    if (len(pred_bboxes) > 0):\n",
    "        n_pred_bboxes = pred_bboxes[indexes,:]\n",
    "\n",
    "    if (len(bboxes) > 0):\n",
    "        n_bboxes = bboxes[indexes,:]\n",
    "\n",
    "\n",
    "    n_digits = n_digits * 255.0\n",
    "#     print(digits.shape, n_digits.shape)\n",
    "    \n",
    "    n_digits = n_digits.reshape(n, 75, 75)\n",
    "    fig = plt.figure(figsize=(20, 4))\n",
    "    plt.title(title)\n",
    "    plt.yticks([])\n",
    "    plt.xticks([])\n",
    "  \n",
    "    for i in range(10):\n",
    "        ax = fig.add_subplot(1, 10, i+1)\n",
    "        bboxes_to_plot = []\n",
    "        if (len(pred_bboxes) > i):\n",
    "            bboxes_to_plot.append(n_pred_bboxes[i])\n",
    "    \n",
    "        if (len(bboxes) > i):\n",
    "            bboxes_to_plot.append(n_bboxes[i])\n",
    "\n",
    "        img_to_draw = draw_bounding_boxes_on_image_array(image=n_digits[i], boxes=np.asarray(bboxes_to_plot), \n",
    "                                                         color=['red', 'green'], display_str_list=[\"true\", \"pred\"])\n",
    "        plt.xlabel(n_predictions[i])\n",
    "        plt.xticks([])\n",
    "        plt.yticks([])\n",
    "    \n",
    "        if n_predictions[i] != n_labels[i]:\n",
    "            ax.xaxis.label.set_color('red')\n",
    "\n",
    "        plt.imshow(img_to_draw)\n",
    "\n",
    "        if len(iou) > i :\n",
    "            color = \"black\"\n",
    "            if (n_iou[i][0] < iou_threshold):\n",
    "                color = \"red\"\n",
    "            ax.text(0.2, -0.3, \"iou: %s\" %(n_iou[i][0]), color=color, transform=ax.transAxes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0a5cd7aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Matplotlib config\n",
    "plt.rc('image', cmap='gray')\n",
    "plt.rc('grid', linewidth=0)\n",
    "plt.rc('xtick', top=False, bottom=False, labelsize='large')\n",
    "plt.rc('ytick', left=False, right=False, labelsize='large')\n",
    "plt.rc('axes', facecolor='F8F8F8', titlesize=\"large\", edgecolor='white')\n",
    "plt.rc('text', color='a8151a')\n",
    "plt.rc('figure', facecolor='F0F0F0')# Matplotlib fonts\n",
    "MATPLOTLIB_FONT_DIR = os.path.join(os.path.dirname(plt.__file__), \"mpl-data/fonts/ttf\")\n",
    "\n",
    "def dataset_to_numpy_util(training_dataset, validation_dataset, N):\n",
    "\n",
    "    \"\"\"\n",
    "    This cell contains helper functions used for visualization\n",
    "    and downloads only. \n",
    "\n",
    "    You can skip reading it, as there is very\n",
    "    little Keras or Tensorflow related code here.\n",
    "    \"\"\"\n",
    "\n",
    "  # get one batch from each: 10000 validation digits, N training digits\n",
    "    batch_train_ds = training_dataset.unbatch().batch(N)\n",
    "  \n",
    "  # eager execution: loop through datasets normally\n",
    "    if tf.executing_eagerly():\n",
    "        for validation_digits, (validation_labels, validation_bboxes) in validation_dataset:\n",
    "            validation_digits = validation_digits.numpy()\n",
    "            validation_labels = validation_labels.numpy()\n",
    "            validation_bboxes = validation_bboxes.numpy()\n",
    "            break\n",
    "            \n",
    "        for training_digits, (training_labels, training_bboxes) in batch_train_ds:\n",
    "            training_digits = training_digits.numpy()\n",
    "            training_labels = training_labels.numpy()\n",
    "            training_bboxes = training_bboxes.numpy()\n",
    "            break \n",
    "  \n",
    "  # these were one-hot encoded in the dataset\n",
    "    validation_labels = np.argmax(validation_labels, axis=1)\n",
    "    training_labels = np.argmax(training_labels, axis=1)\n",
    "  \n",
    "    return (training_digits, training_labels, training_bboxes,\n",
    "            validation_digits, validation_labels, validation_bboxes)\n",
    "\n",
    "# create digits from local fonts for testing\n",
    "def create_digits_from_local_fonts(n):\n",
    "    font_labels = []\n",
    "    img = Image.new('LA', (75*n, 75), color = (0,255)) # format 'LA': black in channel 0, alpha in channel 1\n",
    "    font1 = ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'DejaVuSansMono-Oblique.ttf'), 25)\n",
    "    font2 = ImageFont.truetype(os.path.join(MATPLOTLIB_FONT_DIR, 'STIXGeneral.ttf'), 25)\n",
    "    d = ImageDraw.Draw(img)\n",
    "    for i in range(n):\n",
    "        font_labels.append(i%10)\n",
    "        d.text((7+i*75,0 if i<10 else -4), str(i%10), fill=(255,255), font=font1 if i<10 else font2)\n",
    "    font_digits = np.array(img.getdata(), np.float32)[:,0] / 255.0 # black in channel 0, alpha in channel 1 (discarded)\n",
    "    font_digits = np.reshape(np.stack(np.split(np.reshape(font_digits, [75, 75*n]), n, axis=1), axis=0), [n, 75*75])\n",
    "    return font_digits, font_labels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b6880cc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "with strategy.scope():\n",
    "    train_batches, test_batches, info = get_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2ddd7280",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tfds.core.DatasetInfo(\n",
       "    name='mnist',\n",
       "    full_name='mnist/3.0.1',\n",
       "    description=\"\"\"\n",
       "    The MNIST database of handwritten digits.\n",
       "    \"\"\",\n",
       "    homepage='http://yann.lecun.com/exdb/mnist/',\n",
       "    data_path='./mnist/mnist/3.0.1',\n",
       "    file_format=tfrecord,\n",
       "    download_size=11.06 MiB,\n",
       "    dataset_size=21.00 MiB,\n",
       "    features=FeaturesDict({\n",
       "        'image': Image(shape=(28, 28, 1), dtype=tf.uint8),\n",
       "        'label': ClassLabel(shape=(), dtype=tf.int64, num_classes=10),\n",
       "    }),\n",
       "    supervised_keys=('image', 'label'),\n",
       "    disable_shuffling=False,\n",
       "    splits={\n",
       "        'test': <SplitInfo num_examples=10000, num_shards=1>,\n",
       "        'train': <SplitInfo num_examples=60000, num_shards=1>,\n",
       "    },\n",
       "    citation=\"\"\"@article{lecun2010mnist,\n",
       "      title={MNIST handwritten digit database},\n",
       "      author={LeCun, Yann and Cortes, Corinna and Burges, CJ},\n",
       "      journal={ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist},\n",
       "      volume={2},\n",
       "      year={2010}\n",
       "    }\"\"\",\n",
       ")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f7eb420f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 17:10:16.682601: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n",
      "2022-10-05 17:10:17.046666: W tensorflow/core/kernels/data/cache_dataset_ops.cc:856] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.\n"
     ]
    }
   ],
   "source": [
    "(training_digits, training_labels, training_bboxes,\n",
    " validation_digits, validation_labels, validation_bboxes) = dataset_to_numpy_util(train_batches, test_batches, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4f9e4155",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x400 with 11 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x400 with 11 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_digits_with_boxes(training_digits, training_labels, training_labels, np.array([]), training_bboxes, np.array([]), \"training digits and their labels\")\n",
    "display_digits_with_boxes(validation_digits, validation_labels, validation_labels, np.array([]), validation_bboxes, np.array([]), \"validation digits and their labels\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d805664",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d178dabf",
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extractor(inputs):\n",
    "    x = tf.keras.layers.Conv2D(16, activation='relu', kernel_size=3, input_shape=(75, 75, 1))(inputs)\n",
    "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
    "    x = tf.keras.layers.Conv2D(32, activation='relu', kernel_size=3)(x)\n",
    "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
    "    x = tf.keras.layers.Conv2D(64, activation='relu', kernel_size=3)(x)\n",
    "    x = tf.keras.layers.AveragePooling2D((2, 2))(x)\n",
    "    \n",
    "    return x\n",
    "\n",
    "def dense_layers(inputs):\n",
    "    x = tf.keras.layers.Flatten()(inputs)\n",
    "    x = tf.keras.layers.Dense(128, 'relu')(x)\n",
    "    \n",
    "    return x\n",
    "\n",
    "def classifier(inputs):\n",
    "    \n",
    "    classifier_output = tf.keras.layers.Dense(10, activation='softmax', name='classifier')(inputs)\n",
    "    return classifier_output\n",
    "\n",
    "def bounding_box_regression(inputs):\n",
    "    \n",
    "    bounding_box_regression_output = tf.keras.layers.Dense(4, name = 'bounding_box')(inputs)\n",
    "    return bounding_box_regression_output\n",
    "\n",
    "def final_model(inputs):\n",
    "    feature_cnn = feature_extractor(inputs)\n",
    "    dense_output = dense_layers(feature_cnn)\n",
    "    \n",
    "    classifier_output = classifier(dense_output)\n",
    "    bounding_box_regression_output = bounding_box_regression(dense_output)\n",
    "    \n",
    "    model = tf.keras.Model(inputs=inputs, outputs=[classifier_output, bounding_box_regression_output])\n",
    "    \n",
    "    return model\n",
    "\n",
    "def define_and_compile_model(inputs):\n",
    "    model = final_model(inputs)\n",
    "    \n",
    "    model.compile(optimizer='adam',\n",
    "                  loss = {'classifier': 'categorical_crossentropy',\n",
    "                        'bounding_box': 'mse'\n",
    "                         },\n",
    "                  metrics = {'classifier' : 'accuracy',\n",
    "                         'bounding_box' : 'mse'\n",
    "                        }\n",
    "                 )    \n",
    "    return model\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0c8465db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 75, 75, 1)]  0           []                               \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)                (None, 73, 73, 16)   160         ['input_1[0][0]']                \n",
      "                                                                                                  \n",
      " average_pooling2d (AveragePool  (None, 36, 36, 16)  0           ['conv2d[0][0]']                 \n",
      " ing2D)                                                                                           \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)              (None, 34, 34, 32)   4640        ['average_pooling2d[0][0]']      \n",
      "                                                                                                  \n",
      " average_pooling2d_1 (AveragePo  (None, 17, 17, 32)  0           ['conv2d_1[0][0]']               \n",
      " oling2D)                                                                                         \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)              (None, 15, 15, 64)   18496       ['average_pooling2d_1[0][0]']    \n",
      "                                                                                                  \n",
      " average_pooling2d_2 (AveragePo  (None, 7, 7, 64)    0           ['conv2d_2[0][0]']               \n",
      " oling2D)                                                                                         \n",
      "                                                                                                  \n",
      " flatten (Flatten)              (None, 3136)         0           ['average_pooling2d_2[0][0]']    \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 128)          401536      ['flatten[0][0]']                \n",
      "                                                                                                  \n",
      " classifier (Dense)             (None, 10)           1290        ['dense[0][0]']                  \n",
      "                                                                                                  \n",
      " bounding_box (Dense)           (None, 4)            516         ['dense[0][0]']                  \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 426,638\n",
      "Trainable params: 426,638\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "with strategy.scope():\n",
    "    inputs = tf.keras.layers.Input(shape=(75, 75, 1))\n",
    "    model = define_and_compile_model(inputs)\n",
    "\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d792dccb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 17:10:28.437924: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "936/937 [============================>.] - ETA: 0s - loss: 0.9155 - classifier_loss: 0.8992 - bounding_box_loss: 0.0163 - classifier_accuracy: 0.6878 - bounding_box_mse: 0.0163"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 17:10:41.372991: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "937/937 [==============================] - 16s 16ms/step - loss: 0.9149 - classifier_loss: 0.8986 - bounding_box_loss: 0.0163 - classifier_accuracy: 0.6880 - bounding_box_mse: 0.0163 - val_loss: 9.9822 - val_classifier_loss: 9.8938 - val_bounding_box_loss: 0.0884 - val_classifier_accuracy: 0.2330 - val_bounding_box_mse: 0.0884\n",
      "Epoch 2/10\n",
      "937/937 [==============================] - 14s 15ms/step - loss: 0.2802 - classifier_loss: 0.2736 - bounding_box_loss: 0.0067 - classifier_accuracy: 0.9163 - bounding_box_mse: 0.0067 - val_loss: 12.3164 - val_classifier_loss: 12.2223 - val_bounding_box_loss: 0.0941 - val_classifier_accuracy: 0.2073 - val_bounding_box_mse: 0.0941\n",
      "Epoch 3/10\n",
      "937/937 [==============================] - 14s 15ms/step - loss: 0.1962 - classifier_loss: 0.1923 - bounding_box_loss: 0.0039 - classifier_accuracy: 0.9407 - bounding_box_mse: 0.0039 - val_loss: 15.8472 - val_classifier_loss: 15.7674 - val_bounding_box_loss: 0.0798 - val_classifier_accuracy: 0.1880 - val_bounding_box_mse: 0.0798\n",
      "Epoch 4/10\n",
      "937/937 [==============================] - 13s 14ms/step - loss: 0.1579 - classifier_loss: 0.1553 - bounding_box_loss: 0.0027 - classifier_accuracy: 0.9533 - bounding_box_mse: 0.0027 - val_loss: 14.9802 - val_classifier_loss: 14.9313 - val_bounding_box_loss: 0.0489 - val_classifier_accuracy: 0.1873 - val_bounding_box_mse: 0.0489\n",
      "Epoch 5/10\n",
      "937/937 [==============================] - 13s 14ms/step - loss: 0.1320 - classifier_loss: 0.1300 - bounding_box_loss: 0.0019 - classifier_accuracy: 0.9601 - bounding_box_mse: 0.0019 - val_loss: 18.4807 - val_classifier_loss: 18.4425 - val_bounding_box_loss: 0.0383 - val_classifier_accuracy: 0.1958 - val_bounding_box_mse: 0.0383\n",
      "Epoch 6/10\n",
      "937/937 [==============================] - 14s 15ms/step - loss: 0.1173 - classifier_loss: 0.1158 - bounding_box_loss: 0.0015 - classifier_accuracy: 0.9638 - bounding_box_mse: 0.0015 - val_loss: 17.6370 - val_classifier_loss: 17.6063 - val_bounding_box_loss: 0.0307 - val_classifier_accuracy: 0.2296 - val_bounding_box_mse: 0.0307\n",
      "Epoch 7/10\n",
      "937/937 [==============================] - 14s 14ms/step - loss: 0.1051 - classifier_loss: 0.1037 - bounding_box_loss: 0.0013 - classifier_accuracy: 0.9680 - bounding_box_mse: 0.0013 - val_loss: 21.5586 - val_classifier_loss: 21.5256 - val_bounding_box_loss: 0.0330 - val_classifier_accuracy: 0.1732 - val_bounding_box_mse: 0.0330\n",
      "Epoch 8/10\n",
      "937/937 [==============================] - 13s 14ms/step - loss: 0.0947 - classifier_loss: 0.0934 - bounding_box_loss: 0.0012 - classifier_accuracy: 0.9717 - bounding_box_mse: 0.0012 - val_loss: 18.2529 - val_classifier_loss: 18.2241 - val_bounding_box_loss: 0.0288 - val_classifier_accuracy: 0.2043 - val_bounding_box_mse: 0.0288\n",
      "Epoch 9/10\n",
      "937/937 [==============================] - 13s 14ms/step - loss: 0.0865 - classifier_loss: 0.0854 - bounding_box_loss: 0.0011 - classifier_accuracy: 0.9735 - bounding_box_mse: 0.0011 - val_loss: 17.6335 - val_classifier_loss: 17.6053 - val_bounding_box_loss: 0.0283 - val_classifier_accuracy: 0.2081 - val_bounding_box_mse: 0.0283\n",
      "Epoch 10/10\n",
      "937/937 [==============================] - 13s 14ms/step - loss: 0.0791 - classifier_loss: 0.0782 - bounding_box_loss: 9.7408e-04 - classifier_accuracy: 0.9763 - bounding_box_mse: 9.7408e-04 - val_loss: 20.1139 - val_classifier_loss: 20.0905 - val_bounding_box_loss: 0.0234 - val_classifier_accuracy: 0.1608 - val_bounding_box_mse: 0.0234\n",
      "1/1 [==============================] - 1s 953ms/step - loss: 20.0773 - classifier_loss: 20.0540 - bounding_box_loss: 0.0234 - classifier_accuracy: 0.1591 - bounding_box_mse: 0.0234\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 10\n",
    "steps_per_epoch = 60000//BATCH_SIZE\n",
    "validation_steps = 1\n",
    "\n",
    "history = model.fit(train_batches, epochs=EPOCHS, validation_data=test_batches,\n",
    "                    steps_per_epoch=steps_per_epoch,validation_steps=validation_steps)\n",
    "loss, classification_loss, bounding_box_loss, classification_accuracy, bounding_box_mse = model.evaluate(test_batches, steps=1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fbf3698",
   "metadata": {},
   "source": [
    "## Define the Network\n",
    "\n",
    "<img src='./CNN.jpeg'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "77ee6e51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_metrics(metric_name, title, ylim=5):\n",
    "    plt.title(title)\n",
    "    plt.ylim(0,ylim)\n",
    "    plt.plot(history.history[metric_name],color='blue',label=metric_name)\n",
    "    plt.plot(history.history['val_' + metric_name],color='green',label='val_' + metric_name)\n",
    "    \n",
    "plot_metrics(\"classifier_loss\", \"Classification Loss\")\n",
    "plot_metrics(\"bounding_box_loss\", \"Bounding Box Loss\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ffebec",
   "metadata": {},
   "source": [
    "## Intersection over union\n",
    "\n",
    "Calculate the I-O-U metric to evaluate the model's performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b51c01ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "def intersection_over_union(pred_box, true_box):\n",
    "    xmin_pred, ymin_pred, xmax_pred, ymax_pred =  np.split(pred_box, 4, axis = 1)\n",
    "    xmin_true, ymin_true, xmax_true, ymax_true = np.split(true_box, 4, axis = 1)\n",
    "\n",
    "    smoothing_factor = 1e-10\n",
    "\n",
    "    xmin_overlap = np.maximum(xmin_pred, xmin_true)\n",
    "    xmax_overlap = np.minimum(xmax_pred, xmax_true)\n",
    "    ymin_overlap = np.maximum(ymin_pred, ymin_true)\n",
    "    ymax_overlap = np.minimum(ymax_pred, ymax_true)\n",
    "\n",
    "    pred_box_area = (xmax_pred - xmin_pred) * (ymax_pred - ymin_pred)\n",
    "    true_box_area = (xmax_true - xmin_true) * (ymax_true - ymin_true)\n",
    "\n",
    "    overlap_area = np.maximum((xmax_overlap - xmin_overlap), 0)  * np.maximum((ymax_overlap - ymin_overlap), 0)\n",
    "    union_area = (pred_box_area + true_box_area) - overlap_area\n",
    "    \n",
    "    iou = (overlap_area + smoothing_factor) / (union_area + smoothing_factor)\n",
    "\n",
    "    return iou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "04915909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 17/157 [==>...........................] - ETA: 0s"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 17:16:18.576794: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:114] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "157/157 [==============================] - 1s 4ms/step\n",
      "Number of predictions where iou > threshold(0.6): 9474\n",
      "Number of predictions where iou < threshold(0.6): 526\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjAAAAFhCAYAAADeEuMiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAACUXUlEQVR4nOzdd3gc5b33/89s16r3LlmyJVvuDWxMx6aHkAChBWJIgyeNnJPySzlPSAiB5OSkJ5CQ5IEQcgJplFDjQ682xrjKstxk9Wr1svX+/SG0B7kXybuS36/r2gs0mpn9zur27Mx8Zu7bMsYYAQAAAAAAAAAAxBBbtAsAAAAAAAAAAADYFwEGAAAAAAAAAACIOQQYAAAAAAAAAAAg5hBgAAAAAAAAAACAmEOAAQAAAAAAAAAAYg4BBgAAAAAAAAAAiDkEGAAAAAAAAAAAIOYQYAAAAAAAAAAAgJhDgAEAAAAAAAAAAGIOAQYAAABikmVZR/R66aWXol3qCVFTUyPLsvTAAw8ccr6XXnpp1Odjt9uVnZ2tj3zkI9q6desJqfWcc87ROeecE/n5SGvfV2Vlpb797W+rpqZmTOuTpG9/+9uyLGvM1xur7wsAAABMRI5oFwAAAAAcyJtvvjnq5+9+97t68cUX9cILL4yaPnPmzBNZ1oRx11136dxzz5Xf79fatWt1xx136Pnnn9emTZuUn59/QmvJzc3Vm2++qalTpx7VcpWVlfrOd76jc845R1OmTBmf4gAAAADELAIMAAAAxKSlS5eO+jkzM1M2m22/6fsaGBiQ1+sdz9ImhLKysshnddZZZyklJUWf+MQn9MADD+ib3/zmAZcZr8/O7XYf9u8GAAAAAPuiCykAAABMWOecc45mz56tV155RcuWLZPX69XHP/5xScNdUH3729/eb5kpU6bopptuGjWtublZt9xyiwoKCuRyuVRSUqLvfOc7CgaDh63hkUce0QUXXKDc3FzFxcWpoqJCX/va19Tf3z9qvptuukkJCQnasWOHLrnkEiUkJKiwsFBf+tKX5PP5Rs3b2Nioq6++WomJiUpOTtY111yj5ubmo/tw9jESIOzZs0fS/3ZltG7dOl111VVKTU2NPCFhjNE999yj+fPnKy4uTqmpqbrqqqu0a9euUes0xug///M/VVxcLI/Ho4ULF+qZZ57Z770P1oVUVVWVrrvuOmVnZ8vtdquoqEgf+9jH5PP59MADD+gjH/mIJOncc8+NdIn1/nX8z//8j5YvX66kpCR5vV6dfvrpev755/d7/6eeekrz58+X2+1WSUmJ/uu//uuIPrMvfvGLio+PV09Pz36/u+aaa5Sdna1AICDpyNvBgYxHW7333ns1b948JSQkKDExUTNmzNA3vvGNI9puAAAAIFbwBAYAAAAmtKamJt1www366le/qrvuuks229Hdo9Pc3KxTTz1VNptN3/rWtzR16lS9+eabuvPOO1VTU6P777//kMtv375dl1xySeRid1VVlX7wgx9ozZo1+3V3FQgE9MEPflCf+MQn9KUvfUmvvPKKvvvd7yo5OVnf+ta3JEmDg4NasWKFGhsbdffdd6u8vFxPPfWUrrnmmqP7YPaxY8cOScNPsrzfFVdcoWuvvVa33npr5GL7LbfcogceeEBf+MIX9IMf/EB79+7VHXfcoWXLlmnDhg3Kzs6WJH3nO9/Rd77zHX3iE5/QVVddpbq6On3qU59SKBTS9OnTD1nPhg0bdMYZZygjI0N33HGHysrK1NTUpCeeeEJ+v1+XXnqp7rrrLn3jG9/Qr371Ky1cuFCSIiHLQw89pI997GO6/PLL9Yc//EFOp1O/+c1vdOGFF+q5557T8uXLJUnPP/+8Lr/8cp122ml6+OGHFQqF9J//+Z9qaWk57Gf28Y9/XD/72c/0l7/8RZ/85Ccj07u6uvT444/rs5/9rJxOp6SjawfH6kjb6sMPP6zPfOYz+vznP6//+q//ks1m044dO1RZWTkmdQAAAAAnjAEAAAAmgJUrV5r4+PhR084++2wjyTz//PP7zS/J3H777ftNLy4uNitXroz8fMstt5iEhASzZ8+eUfP913/9l5FktmzZcsQ1hsNhEwgEzMsvv2wkmQ0bNoyqX5L5y1/+MmqZSy65xEyfPj3y87333mskmccff3zUfJ/61KeMJHP//fcfsoYXX3zRSDKPPPKICQQCZmBgwLzyyitm2rRpxm63R2q6/fbbjSTzrW99a9Tyb775ppFkfvSjH42aXldXZ+Li4sxXv/pVY4wxnZ2dxuPxmA9/+MOj5nv99deNJHP22WdHpu3evXu/2s877zyTkpJiWltbD7otf/3rX40k8+KLL46a3t/fb9LS0sxll102anooFDLz5s0zp556amTakiVLTF5enhkcHIxM6+npMWlpaeZITocWLlxoli1bNmraPffcYySZTZs2HXCZQ7WDkc/9/ca6rX7uc58zKSkph902AAAAINbRhRQAAAAmtNTUVJ133nnHvPyTTz6pc889V3l5eQoGg5HXxRdfLEl6+eWXD7n8rl27dP311ysnJ0d2u11Op1Nnn322JGnr1q2j5rUsS5dddtmoaXPnzo106yRJL774ohITE/XBD35w1HzXX3/9UW3XNddcI6fTKa/Xq7POOkuhUEh/+9vfNHfu3FHzXXnllaN+fvLJJ2VZlm644YZRn0dOTo7mzZunl156SdLwIOtDQ0P66Ec/Omr5ZcuWqbi4+JC1DQwM6OWXX9bVV1+93xMhR+KNN97Q3r17tXLlylE1hsNhXXTRRXr77bfV39+v/v5+vf3227riiivk8XgiyycmJu73dziYm2++WW+88Ya2bdsWmXb//ffrlFNO0ezZsyPTjqYdHKsjbaunnnqqurq6dN111+nxxx9Xe3v7mLw/AAAAcKLRhRQAAAAmtNzc3ONavqWlRf/85z8jXQHt61AXf/v6+nTmmWfK4/HozjvvVHl5ubxer+rq6nTFFVdocHBw1Pxer3fUhXRpeIDroaGhyM8dHR2RLpreLycn52g2Sz/4wQ903nnnyW63KyMjQ4WFhQecb9/Pr6WlRcaYA9YgSaWlpZE6D1bX4Wrt7OxUKBRSQUHBYbfjQEa6f7rqqqsOOs/evXtlWZbC4fAx1Tjiox/9qL785S/rgQce0N13363Kykq9/fbbuueeeyLzHG07OFZH2lZvvPFGBYNB/fa3v9WVV16pcDisU045RXfeeafOP//8MakFAAAAOBEIMAAAADChWZZ1wOlut3u/wbGl/73wPiIjI0Nz587V9773vQOuJy8v76Dv/cILL6ixsVEvvfRS5G57aXiMhGOVnp6uNWvW7Df9aAfxLi0t1eLFiw87376fX0ZGhizL0quvviq3273f/CPT0tPTD1pXc3OzpkyZctD3TEtLk91uV319/WHrO5CMjAxJ0i9+8YvI4OT7Ghlg27Ksg9Z4JFJTU3X55ZfrwQcf1J133qn7779fHo9H1113XWSe420H49FWb775Zt18883q7+/XK6+8ottvv10f+MAHVF1dfdgnZAAAAIBYQYABAACASWnKlCnauHHjqGkvvPCC+vr6Rk37wAc+oKefflpTp05VamrqUb3HyMX/fS/0/+Y3vzmGioede+65+stf/qInnnhiVDdS//3f/33M6zwaH/jAB/T9739fDQ0Nuvrqqw8639KlS+XxePSnP/1pVDdUb7zxhvbs2XPIACMuLk5nn322/vrXv+p73/teJJDY18jnuu8TDKeffrpSUlJUWVmpz33ucwd9H5fLpVNPPVX/+Mc/9MMf/jDy9Etvb6/++c9/HnS5fd188836y1/+oqeffloPPfSQPvzhDyslJSXy++NtB+PZVuPj43XxxRfL7/frQx/6kLZs2UKAAQAAgAmDAAMAAACT0o033qj/+3//r771rW/p7LPPVmVlpX75y18qOTl51Hx33HGHVq1apWXLlukLX/iCpk+frqGhIdXU1Ojpp5/Wr3/964N2dbRs2TKlpqbq1ltv1e233y6n06k//elP2rBhwzHX/bGPfUw/+clP9LGPfUzf+973VFZWpqefflrPPffcMa/zaJx++un69Kc/rZtvvllr167VWWedpfj4eDU1Nem1117TnDlz9H/+z/9RamqqvvzlL+vOO+/UJz/5SX3kIx9RXV2dvv3tbx9R90w//vGPdcYZZ2jJkiX62te+pmnTpqmlpUVPPPGEfvOb3ygxMTEyxsR9992nxMREeTwelZSUKD09Xb/4xS+0cuVK7d27V1dddZWysrLU1tamDRs2qK2tTffee68k6bvf/a4uuuginX/++frSl76kUCikH/zgB4qPj9fevXuP6DO54IILVFBQoM985jNqbm7WzTffPOr3x9sOxrqtfupTn1JcXJxOP/105ebmqrm5WXfffbeSk5N1yimnHFFNAAAAQCxgEG8AAABMSl/5ylf0la98RQ888IAuu+wy/f3vf9df/vKXUXfOS8NjQKxdu1YXXHCBfvjDH+qiiy7SjTfeqP/3//6f5s+ff8g73dPT0/XUU0/J6/Xqhhtu0Mc//nElJCTokUceOea6vV6vXnjhBa1YsUJf+9rXdNVVV6m+vl4PP/zwMa/zaP3mN7/RL3/5S73yyiu69tprdemll+pb3/qW+vv7deqpp0bmu+OOO3T33XfrX//6lz74wQ/qF7/4hX79619r+vTph32PefPmac2aNVq0aJG+/vWv66KLLtL/9//9f3K73XK5XJKkkpIS/fSnP9WGDRt0zjnn6JRTTok8OXHDDTfoxRdfVF9fn2655RatWLFCt912m9atW6fly5dH3uf888/XY489pp6eHl1zzTX693//d1155ZX6+Mc/fsSfh81m08c+9jHV19ersLBw1Pql428HY91WzzzzTG3evFm33Xabzj//fP3bv/2bysvL9eqrrx7ToOkAAABAtFjGGBPtIgAAAAAAAAAAAN6PJzAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMcdxrAuGw2E1NjYqMTFRlmWNZU0AAAAAAAAAAGCCMcaot7dXeXl5stmO//mJYw4wGhsbVVhYeNwFAAAAAAAAAACAyaOurk4FBQXHvZ5jDjASExMjhSQlJR13IQAAAAAAAAAAYOLq6elRYWFhJD84XsccYIx0G5WUlESAAQAAAAAAAAAAJGnMhp1gEG8AAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcAgwAAAAAAAAAABBzCDAAAAAAAAAAAEDMIcAAAAAAAAAAAAAxhwADAAAAAAAAAADEHAIMAAAAAAAAAAAQcwgwAAAAAAAAAABAzCHAAAAAAAAAAAAAMYcAAwAAAAAAAAAAxBwCDAAAAAAAAAAAEHMIMAAAAAAAAAAAQMwhwAAAAAAAAAAAADGHAAMAAAAAAAAAAMQcx7EuGA6HJUnd3d1jVgwmJmOMent7lZeXJ5tt/DKxcDisxsZGJSYmyrKscXsfTAy0O5xoJ6rNSbQ7/C/2dYgG2h1ONL5jEQ3s6xANtDucaHzHIhpG8oKR/OB4HXOA0dTUJEkqKioak0Iw8dXV1amgoGDc1t/Y2KjCwsJxWz8mJtodTrTxbnMS7Q77Y1+HaKDd4UTjOxbRwL4O0UC7w4nGdyyioampSSkpKce9nmMOMBISEo77zTG5JCYmTuj1j5IuuZKk70qaeuLedUzl9Emz26SvSfp1tIsZR5Oq3WFCOBFtgnaHfbGvQzTQ7nCi8R2LaGBfh2ig3eFE4zsW0TBW+cExBxg8CoR9jXebOKFtbqnkXyR9XdJEbenXbpb++A/JHe1CxtmkaneYEE5Em6DdYV/s6xANtDucaHzHIhrY1yEaaHc40fiORTSMVZs45gADmNQsyWmkGzdIzl7pD5KGol3TkfJKmi+F+N4AAAAAAAAAMIERYAAH4QxJt66V4hulRzSBAoxMSbOjXQQAAAAAAAAAHJ/xHX4eAAAAAAAAAADgGBBgAAAAAAAAAACAmEOAAQAAAAAAAAAAYg4BBgAAAAAAAAAAiDkEGAAAAAAAAAAAIOY4ol0AcLJxu92y2WwaGhqSMWbU75xOp5xOp9LT05WQkKCCggJlZGQoLy9PxhiFQiFVVVWptbVVGzduVCgUitJWAAAAAAAAAMD4IsAATrC4uDg5nU75/f79Agi32634+HiVlZUpLy9PZ555pmbPnq3TTjtNkuTz+fTnP/9Z69ev15YtWwgwAAAAAAAAAExaBBjAOLMsS06nU1OnTlVZWZkqKirkdDr1q1/9St3d3XK5XAqFQgqFQsrPz1dhYaFuueUW5efnKzMzU8nJyZIUeVojJSVFKSkpsiwrmpsFINYslVQQ7SLGyNuS9kS7CAAAAAAAEG0EGMA4stlscrvdSk5OVmlpqRYuXKj58+fL4XDoz3/+s8LhsBITE+Xz+eTz+ZSdna0pU6Zo6dKlysvLi6zn/V1NWZYlm81GgAFgtALJmiUlD0k2c/jZY9GQQxpwSvHVkktSjySeMwMAAAAA4ORFgAGME7vdrvz8fM2ZM0ef/vSnVVBQoLy8PPl8PvX19ekzn/mM7Ha75syZo/r6eu3cuVPTpk1Tdna2kpKS9ltfKBTS4OCgnn32WW3cuFGBQCAKWwUgliUPSX/6u1TaGe1Kjs2f5kp3niX9X0nLJd0gaVuUawIAAAAAANFDgAGMg/j4eCUkJGjevHmaM2eOKioqlJaWppSUFPX09Mhms0W6kiotLZXb7ZY0PAbG4OCgdu7cqeTkZBUVFclms0mSWlpa1NTUpNraWjU3N+83ADgA2MxweJHfIVVKCke7oKM00Df831xJZZLc0SwGAAAAAABEHQEGMMYsy9K0adNUVlamO+64I/JExUiXT0lJSUpMTFR2drYCgYC6u7uVmZkpt9utp59+WlVVVerv71dZWZm++93vRsKNZ555Ri+//LLWrFmjvXv3EmAAOKhKSRdLGop2IUcpGO0CAAAAAABATCHAAMZQdna2srKydN5556msrEzp6enyer2yLEuWZckYo2AwKJ/Pp+rqarW3t2vbtm3q7+9Xb2+vGhoa5Pf7NWfOHE2dOlU2m01DQ0Pq7+9XTU2NqqurNTg4SHgB4JDCGg4vBqNdCAAAAAAAwHEgwADG0JQpU3TKKafo+uuvV1lZmRISEiLBxUjo4PP51NXVpX/961+qqqrS//zP/6i3t1d9fX2aM2eOSktLddFFF6m4uFh2u109PT1qaGjQ1q1btWnTJvl8vihvJQAAAAAAAACMPwIMYAy4XC4lJibq1FNP1ZVXXqmioiLFxcXJsiwFAgF1dnZq+/bt2rZtm7Zs2aLm5mZVV1erq6tLXV1dSktLU3l5ua677jotWLBAZWVl8ng86uvr08svv6wHH3xQGzZsUCAQ4OkLAAAAAAAAACcFAgxgDNjtdnm9XhUWFmru3Lnyer2y2+0yxmhoaEitra2qrKzUq6++qjfeeCPSVdTIsgkJCSopKdFpp52m0047TeFwWD6fT83Nzdq8ebP++c9/RnkLAQAAAAAAAODEIsAAxsDQ0JCam5u1Y8cOrV+/XqWlpfJ6verp6dGWLVt0zz33qKGhQQ0NDerv71cgEJAkJSQkRAb8njVrlpKTkxUKhdTY2Kiqqir98Ic/VE1NTXQ3DgAAAAAAAACigAADGAPGGAUCATU0NGjjxo3q6emJBBiVlZXaunWrurq61NPTM2o5p9OpjIwM5ebmqqioSC6XSz6fT7t27dLWrVtVWVm53zIAAAAAAAAAcDIgwADG0HPPPacXXnhBNptN0nCwMdId1IHGrvB6vZo2bZpOPfVUXXjhhQoGg2poaNDPfvYzbdu2Ta2trQqFQid6MwAAAAAAAAAg6ggwgDEUDAYVDAYPOU9iYqISEhI0a9YsFRYWasmSJSopKZHL5dK6detUXV2t3bt3q729nfACAAAAAAAAwEmLAAM4wbKzs1VYWKjPf/7zKi4u1rRp0yRJoVBITz31lJ577jnt3r07Msg3AAAAAAAAAJyMCDCAceJwOFRQUKC0tDSVlpYqJSVFKSkpkWkjg3a7XC6Fw2FZlqUFCxbIGKNVq1apvb1d7e3t0d4MACcxt9stl8slj8ej9PR0ffSjH5XX6z1gl3iS1N7ernfeeUfNzc1qbm5Wd3c3YSwAAACOjU3SUklp0S5kDBhJqyVxig8AR40AAxgHNptNbrdbhYWFkW6i8vLylJeXp4yMDMXHxystLU12uz2yjGVZkacxqqqqJEkdHR0HvVAIAOPJsizFxcUpMTFRSUlJKi4u1vXXX6+UlBSFw+EDLlNTUyPLslRdXS1jjPx+v4LB4EHnBwAAAN7PLsk98oMlDU2XTJHkCUrWBDs1DknyScMbJUlbRYABAMeAAAMYY5Zl6dRTT1VZWZk+85nPKD09XQkJCXI6nXK5XJGLeq+++qqGhoZkWZaysrKUn5+vsrIyTZ06Vfn5+Vq/fr3+4z/+g7uXAZxwHo9HKSkpOv/887V06VLNnj1bGRkZys3NlcPhOGiwWl5erk9/+tPq7e1VT0+Pfv/73+vdd99VZWUl+zIAAAAc1nJJd7z3/wFJn5PU3iv97nEpdSh6dR2LlyV9TZI5RdKcKBcDABMYAQYwDrxer5KTk1VUVKS0tDQ5nU75fD75/X61t7ers7NTmzdv1sDAgCzLUkFBgYLBoEpLS5WcnKyysjL19PREumoJBALR3iQAk9xI0OrxeBQfH6+MjAzNmDFDc+fOjXR5dyTrSEhIUCAQkM/nU0VFhQYGBtTT0xN5hUIhhUKhE7BFAAAAmGjSJJ0qqUVSs4YfXrAFpYQmKXEgqqUdMaekEkmNIxNmRK8WAJgMCDCAcdDY2CiXy6WtW7cqPz9fBQUF2rlzp7Zt26bHHntMVVVVowbqLiws1NSpU3XTTTdp0aJFSk9PV1FRkWbNmqW6ujrV1tZGeYsATGZ2u11nnHGGCgoKVFFRoaSkJGVkZKiiokJTpkwZ1d3dkXA4HLLb7br66qu1YsUKrV27Vtu3b9ejjz6qvXv3au/eveO0JQAAAJgMfi7pXkl9ksKSPqDhITEmghJJz0a7CACYRAgwgDFmjFF3d7caGxv1yiuvKDMzU7m5uaqpqdGuXbu0bds2NTY2qre3N3IXcltbm2w2m1paWtTV1aWMjAwlJCSorKxMPp+PAAPAmHO5XIqPj1dpaany8vJ06qmnKisrS6WlpZGxL1JTU+V0Oo963ZZlSZKSk5PldDpVUVEhSUpJSdHAwAS5dQ4AAABRMyCp630/d0epjmORpuExuwEAY4MAAxgHTU1NamlpUW1treLi4pSamqq2tja1tbUdcP6RO5L37NmjkpISTZ06VampqTrrrLPk8/m0du3aE7wFACa7hIQEFRUV6aabbtKKFSuUmpoa6T5qJIA4HpZlKTExUYmJicrOzlZCQoL++c9/qq+vT42NjYdfAQAAAAAAOOkRYADjJBwOa3BwUH6/Xz6fT4ODg4dd5v0D47pcLhUWFiotLW08ywRwknE6ncrJydHChQt12WWXaf78+crMzJTH45HdbpdlWUcdYITDYfX09CgcDsuyLHk8HsXFxY1aT25urj7+8Y9HutEDAAAAAAA4HAIMYAyNXPgbCSJ8Pp8kHVOXKU6nU5mZmUpMTBzTGgGcvCzLktvtVn5+vhYsWKCrrrpKbrdbLpfrqNcVDodljJExRsFgUF1dXQqFQpHxMuLi4kbNn5mZqQ9+8IPavn37mGwLAAAAMF4sy5LNZpPdbpcxRqFQSOFwONplAcBJiQADGANut1spKSnKz89XTk6O2tra1Nvbqx07digYDB7TOgOBgFpbW9XT0zPG1QI4GdlsNpWVlam0tFSf+MQnImNd2GzHNhzi9u3btXPnTrW0tKi3t1c1NTVKSkrS3LlzNWPGDKWmpo7xFgAAAADjz263a/HixSorK9PKlSu1efNmPf7449q2bZuampqiXR4AnHQIMIAxEBcXp/z8fE2bNk1TpkxRQ0ODOjo6VFNTc0QBhsPhkNvtVnx8vLxeryzLkt/vV3NzMwEGgOPmcDjkcrk0ZcoUTZ8+XbNmzVJ6enqky6gjEQwG1d7erlAoJGOMdu7cqcrKSjU0NKi7u1u1tbXKyspSYWGhhoaGxnmLAAAAgPFhs9mUk5OjqVOnatmyZXI4HHrnnXfU0NAQ7dIA4KREgAGMgalTp+q2227TzJkzNW3aNDU0NGjXrl165513juhCXmFhoWbMmKGzzjpLp512msLhsOrq6vS73/1OtbW1J2ALAExmWVlZys3N1Wc/+1mVl5eruLhYDofjqMa6aGtr01e+8hV1d3fLGKOWlha1tbWpp6dHfr9foVBIM2fO1HnnnTeOWwIAAACML7vdrunTp6u8vFw2m01paWmaN2+eduzYQXeoABAFBBjAGHA4HEpISFBCQoISExOVmZmpvr6+SF/wh2JZlrxer7KyspSQkCCn06nOzk51d3erublZ3d3dJ2ALAExmTqdTcXFxysjIUEZGhpxO5yHDi3A4rGAwKJ/PJ5/Pp507d2rPnj3avn27ent7JUk9PT3q7e3V4OCgJCknJ0d5eXmaMmWKUlJS9ltnMBjUwMBAZGwgAAAAINbYbDY5nU7l5eUpLy9PNpstMh7G0dz8AwAYOwQYwBgZGcxWktLS0jQwMHDYvuUty5LdbldqaqpKSkrk9XoVCoXU2tqqhoYG7dmzh4t9AI6by+WS1+tVRkbGEY1NEQwG1d/fH3nK4uc//7kqKysPOq5PfHy8zjjjDC1ZskTLly+XzWaL7A9H+Hw+1dXVqbOzc8y2CwAAABhLDodDXq9X8+fP15w5c2S32xUOhyNPHAMATjwCDGAMBAIBdXd3R8IGy7Lkdru1ZMkSNTY2HnQci/j4eBUXF2vhwoU644wzZLfbtXv3bj322GPasmULB0gAxkRRUZHmzJkjj8dzyPmMMQoGg6qtrdVbb72l6upq1dTUaPPmzZHxL/bldruVmJioqVOnKj8/P7KeEaFQSI2NjdqzZ4+eeuopvfPOO2O7cQAAAMAYyczMVH5+vpKTkxUXFyfLstTb26vdu3dHnkQGAJxYBBjAGAgEAurq6tLQ0FDkwp3L5dLixYvV1NSkxsbG/e5GlqT09HQtWbJEs2fP1uLFi7V9+3bt3r1bzzzzjHbv3k2AAWBMFBYWaubMmQcNMEaeIAuHwxoaGlJdXZ1WrVqltWvXqqqq6oDLWJYly7IUFxenpKQklZSUKDc3V8YYWZYV2ecFAgHV1tZqw4YN+tvf/qa9e/eO23YCAAAA+3r/senhZGRkqKioSElJSXK73TLGqK+vT3v27CHAAIAoIcAAxkBTU5OeeOIJxcfHq7S0VImJiYqPj9c111wT6UP+/UKhkDo7O2VZluLj4+Xz+fTCCy/o0Ucf1caNG7V161YNDAwc8UEWABzKvHnzdMEFFygpKemAvw+FQnrttdfU2NioLVu2aOfOnXrttdcO+vSYJM2dO1ezZ89WWVmZcnJydN555yk5OXlU38ANDQ1qbGzU7373O+3cuVNNTU0KBAJjvn0AAADAvhwOh6ZPny6HwyG/36+Ojg61trYecpmysjItWbJEXq9XwWBQe/fu1a5du7R27Vr19fWdoMoBAO9HgAGMgYGBAe3evVu1tbVqaGhQQUGBEhISVFJSErmjORwOKxQKKRAIyO/3yxgjv9+vwcFBtbW1qbGxUe+++642bdqkwcFBwouJzpIUL+nQw6BMKM6QlNUvDUhiFIOJJTU1VXl5eQf83ci+qba2Vjt37tTbb7+thoYGNTU1HXB+u92uuLg4FRcXa968eaqoqFBWVpZyc3Pldrsj6zTGqLGxUTt27NCmTZvU2NgYGfAbAAAAGE+WZcnlcqm0tFQejydyHHqwAGPk6eLMzEwVFRXJ5XJFbjzs6OhQR0fHiSwfAPA+BBjAGBgcHFR9fb0eeeQRrV69WitXrtTMmTM1a9YsdXV16e2331Z7e7va2tq0detWtbS0aPfu3RocHNTAwIDC4bCCwaAGBgYUCAQILyYDt6SrJKVFu5CxU94q/f0R6cmA9OVoF4Mx4/P51NfXp6qqKm3evFmrV6/W0NDQQefPz8/X8uXLddFFF+ncc8+Vx+ORw+GQy+Uatc6BgQHde++9evHFF9Xa2sqTFwAAADhhEhISlJeXp+985zvKyMhQW1ub/vjHP2rr1q0HnN/lcik+Pl7z5s3TmWeeqYSEBHV1denVV189aJeqAIATgwADOIx4ScslHfJhUWOkUEhpHR1KM0bpb78tb3u7rIYGOXt7lVxZKdPZKVtXlwZ27VLi3r2Kb26W3+fT0D7dSx2vPkmrx3SNOCaWpARJLkkNkt7LpOZIypK0RtKE6UHVJilfcsVLeZaUEu16cNR6e3vV3t6ulJQUORyjv/q7u7vV2tqq+vr6yFMSBxt/x+l0KikpSYWFhcrMzFRSUpLsdrtstuFHjQKBgPr6+tTT06Ouri41NTWpra0t8tQZAAAAcCIUFxervLxc2dnZSktLk81mU3JyspxOp4LB4H7Hpg6HQ16vV/Hx8UpMTJTNZlMwGFRHRwddRwFAlBFgAIdRJOnhI525s1NWZ6esX/5SliRZllIlnT5ycGTM8HXskf+Og62SzhqndeMYtEl6RNJ7N5//u6QPSjpH0qZo1XS03JJuinYROB67du3SunXrtHTp0v3Gwdi5c6c2btyoN954Q7t37z7oOux2u5KTk5WTk6OZM2cqOzt7vzCkr69PW7ZsUVNTU2T8i0M9zQEAAACMNcuydNlll+mMM85QcnKyHA6HkpOTI6+enh75/f5Ry3g8HqWlpSkpKUler1fS8M05DQ0N6uykA10AiCYCDOAgApJ+L+nZY1k4HB7bYo5Cm6QhSVsk3anhO/0RZWFFnsCwSbJr+AGNCYMb5ye86upqJSUlac6cOfsFGMYYGWMUPsx+y+v16sILL9SsWbNUUVGh9PT0yIDdwWAw0jXek08+qdbWVrW0tKitrW3ctgkAAADYl8PhkMfjUW5urgoLC+VwONTd3a21a9dq+/btGhgYOODTxomJiSouLlZ8fLyMMfL5fOrq6lJVVdVBx4YDAJwYBBjAQQQk/cbSBLvSrEi9mzSB7vDHcRkZcG7E4S5E4+RTXV0tv9+v66+/fr/H5UcCjAN5f7tKTEzUJZdcovLycs2aNSuyrDQcYNTX12vTpk16/PHH1d7err17947T1gAAAAAH5nK5IuNfFBYWym63q7OzUy+//LKqqqo0MDAgafRxriQlJyerpKRECQkJMsZocHBQnZ2dqq6uVmdnp2w22yGPmwEA44cAAzgYh6QLNPw4w0Tieu+FSS8lJUVTp07VOeeco2XLlikQCGjv3r360Y9+pLa2NvX09ES7RMSIcDisUCikvr4+9fYOj74yNDSk3t5ePf/883rxxRfV0dERmT8pKUkFBQU65ZRTVFFRIUmKj4/X3LlzlZiYqJ6enlEnfQMDA9q9e7dqamrU1NREt1EAAACIinnz5umss85SWVmZXC6Xdu/erc2bN+v1119XV1eXpkyZosLCQiUnJ0cG7i4uLlZxcbEqKio0ZcoU2Ww2JSQkaNasWfrd734XGd/tH//4h9566y319PQcdMw4AMDYI8AADsQnaUBSerQLOUaDmnjBC45afHy8pk6dqqVLl+qSSy5Rf3+/GhoadN9996mrqyva5SGGBINB+Xw+tbS0yOUaTjgHBgbU2dmpbdu2qaqqalTo4HQ6lZiYqMLCQs2cOTMyzRgzKgQZMTg4qPr6ejU3N6uvr4870wAAABAVWVlZmj17tlJTU2W32zUwMKD+/n75fD4lJCQoIyNDZWVlSk9Pl8fjUVJSkioqKpSVlaWCggIlJCRIGj72TU9P14oVKzQwMKC9e/dqw4YN2rhxo/r6+ggwAOAEIsAADuQ1SW9Hu4jj5D/8LJjYSktL9fnPf165ubkaGhrShg0bVF1draamJnV3d0e7PMSQhoYGtbS06BOf+IScTqek4acywuGwenp6NDAwMKrrsc7OTq1fv17V1dX6/e9/L2n4Mft9B+0eEQ6HNTg4KL/fT3gBAACAqPF4PEpJSZHD4ZDD4dDUqVNVUFCg0047TXa7PTLdbrfLZrPJZrPJ6XTKbrfL6XTu17XUyDpzcnKUk5Oj7OxsdXZ2KhAIRGHrAODkRIABHMjgey8gBtlsNiUnJ0fuErLb7err61NVVZW2bNmiwcFB7gjCKMFgUMFg8IgHIAyHw/L5fPL5fONcGXB46ZJmafSQVD67tC5X8tujVNRYaRXHGwAAHIeRcyPLshQMBuV2u0f93u12y+12KzExMRJYHIlQKCRjjAKBgIaGhtTX16fu7m75fD5u2AGAE4wAAwAmGI/Ho0WLFmn+/PkqKChQfX29amtr9eCDD2rt2rWEFwAmldMlPSLp/Zcb6uKls66UGpOiVNRYCEv6i6Tt0S4EAICJy+VyadGiRbLb7erq6lJaWpp8Pp/C4bAsy5LdfuR3O1iWFQknhoaG5PP51NnZqT179mjdunVavXq1ampquMkHAE4wAgwAmGCcTqfKysqUn58vm82mgYEBtbW1aWhoiPACwKRjk+SS9Lqk1e9N65bUZ5fUI6lKUozeCGmT9GFJaZL+LKlv5BcF773276UCAAAcBZvNpqSkJLndbsXFxam9vV0vvPCCUlNTJQ2PiWGMUU9PjwYHByPjWfT19amxsVFJSUk666yzFBcXJ4/Ho76+PvX19enZZ59VW1uburq61NHRoYaGBtXV1dFlKgBEAQEGAEwwbrdbM2fO1JQpUyRJvb29am5u5k4gAJPaM5Lu3ndih6R/KaYDjFskzZD0lN4XYJyl4QADAAAcl5EupEYG3966datefPFFlZaWyu12KyUlReFwWM3Nzero6FBra6u2bt2qxsZGvfXWWyoqKlJFRYUyMjLk8XjU3d2txsZG3Xfffdq2bZu6u7sJLAAgyggwAGACyc7OVklJiRYsWKD8/HwFg0HV1NRo9erVDNwNAAAwQXxM0iXRLuI4vS3px4rZDBknkfcPvD00NKS9e/fqj3/8o55++mmlpKRIkvr7++X3+zU0NKSenh4NDQ2pq6tLycnJo9bV19en9vZ2dXd3q7+/n/ACAGIAAQYATBCWZSk5OVkZGRnKz89Xamqq/H6/2tratGvXLg0OMhIsAADARLBA0tUa7gkvGOVajpZNUrKGu/f7cZRrAfYVCAQ0ODioDRs2HHI+y7IUHx8vY8yowb37+/vV3d2twcFBBQKBE1EyAOAwCDAAYIKwLEvFxcUqKytTUlKSfD6fqqqqtG7dOr377rsaGhqKdokAAAA4QgFJn5H0TrQLOUpFGh7XB4gVx/KUhMvl0iWXXKL58+crLy9PbrdbklRVVaXXX39d/f39Y10mAOAYEWCMAa+kWZLs0S5kDAxK2iyJYYCB2BQfH6+EhAQ5HA75/X4NDAxEXgAAAJg4jKTaTGmbO9qVHJ0+SaslbRuZ0C2pN2rl4CQXDofV39+vYDAov99/xMGDzWZTfn6+8vLy5HQ6ZbPZFAqF1N7ervr6evn9/nGuHLGoWFLue/8/ZJc2Z0tBWzQrGgNhSY3RLgI4PgQYY6BM0pOSEqJdyBioknSeho9BAcQWy7KUkpKi9PT0yCPOAAAAmKDski6WVBjtQo5Oo6QrNXxNzEjSi5LeiGZFOJkFg0Ft375dfr9f9fX1R/xUusPhUHl5uaZNmya73a5AIKChoSFt3bpVa9as4Qaxk9RnJH3uvf/flSSde43U7o1mRWPAJ+m/ol0EcHwIMMZAh1d6aIbkmQSPYDQNSv6t4hEMIAZZlqWMjAxlZWXJZrPJ5/OppaVFfX190S4NMcLnkP48Rxron3j9aUsavuUJiIKUlBQlJCQoIyNDXq9X6enpkcE9D6W2tlYtLS0npkgAk5Ndw+deWzXcp9QEkCjpCknNqdKz0zQ8KAYQJaFQSK2trQqFQhocHFQodOQXM2w2W2QA8GAwGHmyvb+/X+FweLxKRgxzSXJLekLSRklDDg0/drZD7yW2sa9E0kUaflJunTRhvluAQyHAGAP1SdKXLtTwnm6ia9PwjpkAA4g5lmUpPz9fxcXFstvtGhgY0O7du9XdzTNTGNbvlO44O9pVABNPTk6O8vPztWDBAuXk5GjevHlqa2tTdXX1IZd79tlnCTAAHL8BSave++8EkCnpB5JenyE9N23CXNPDJBUKhdTQ0HBMy46MnWGMkd/vV29vr3p7exn/4iQXlPRjSa+NTGiW9FTUyjlq8yT9UtJ/6L0AA5gECDDGUq0m7t7BLunMaBcB4GDy8vKUm5urGTNmqKSkRHa7XT6fT+3t7TzejGFvS9oe7SLGxm/rpGcl1UW7EEx6JSUlmjdvns4991zNmDFDaWlpiouLU2pqqnw+nyoqKg65/OLFi9XW1iZJGhgY0CuvvKKamhqtXr36RJQPAACOkd1u1/Tp0zV16tTIkxgjT2MAAGILAcZY6pC0IdpFHCOnpEXv/RdAzElLS1NJSYny8vKUkZEhm82mcDisoaEhBYOH7yzI4XDIsiyFw2EZY3gkejLa895rEnjt8LMAx8xut8tms8npdKqoqEhLlizReeedp9mzZ4+aLxQKKRA49DP3M2bMiPx/V1dX5I5NAgwAAGKXzWaTy+VSTk6OMjMzJQ0/hREKhSJPZQAAYgcBBgBMALNmzdJFF12kzMxM2e3DA+6kpaXp9NNPV3NzszZu3HjQZS3L0tKlS5WZmandu3ers7NTe/ZMkivdAHAU7Ha7KioqVFxcrMsuu0xTp07V7NmzlZycvN+827dv10svvXTE6x7pexsAAMS2KVOmaMqUKXK73ZFpbW1tWr9+vTo7O6NYGQDgQAgwAGACcDgccrlcstlskT5aBwcH1dvbK7/ff8D54+Li5HQ65Xa7NWPGDOXn52toaEiSVFdXx1MYAE46drtdRUVFKi8v17x585SXl6fs7Gz5fD719PSoo6NDPp9Pg4ODqqqq0vr164/6PbjwAQBAbEtKSlJGRkbkxjBpuCvIpqYmuudFzEpISJDL5VJKSor6+/sZh+39HJLSJU2mXuCGJHVFu4jYQYABABNAY2OjNm7cqKVLlyolJUUNDQ1as2aNfv3rX6u1tXXUvHa7XampqZo9e7by8vJUUFCga6+9Vnl5eXI4HNq0aZO2bNkiYwyPSAM4qbjdbn34wx/W7NmztXDhQjkcw4fCe/bsUV1dnR566CHt2rVLGzduVCAQOKIu+vZFOAwAQGzLy8vTtGnTRj2B0dLSojVr1qijoyOKlQEHZrfbNX/+fE2ZMkWXXXaZVq9erR//+MfRLit2JEu6XpIn2oWMoWpJf492EbGDAAMAJoBwOBzpkzUUCqm9vV1tbW2jBvHOyspSUlKSpk+frqysLM2cOVOpqalKS0tTVlaWEhMTtXDhQoXDYT377LMaHBw8bP/uADCZ2O125efnKzc3Vw6HQx0dHaqvr9dbb72l7du3q7KyUq2trerp6SHgBTCpJCcnKzMzU0VFRUpJSVFra6u6urpUWVlJ8IqTTlNTkxITE9Xe3i632y2Xy6WOjg7t2LFDPT090S4PGMWyLDkcDi1ZskRTpkxRb2+v+vr6ol1WbLFJckml/dLZNRPzQYyQpGcltbgllYsr9vvg4wCACSYYDKqurk719fVqb2+XMUaWZWnatGmaNm2abrrpJhUUFGjq1KmjlrMsSxdddJGSkpJ03333KRwOE2AAOKnYbDaVlJSoqKhIlmVp9+7devrpp/Xoo48eciwhAJjocnJytGTJEl1++eWqqKjQG2+8ocrKSm3fvl0+ny/a5QEnVGVlpZqbm1VTUyOHw6Hk5GTV1tbqnXfeiXZpwH4sy5Lb7dZVV12lgoIC/epXv1JtbW20y4pJpzZIv38i2lUcG7+kFZJaUiVNiW4tsYgAAwAmGJ/Pp02bNmnXrl0yxignJ0c5OTn6yEc+opkzZ6q8vFxxcXHy+/1qbm5WU1OTcnNzlZiYqOTkZHm9XpWXl6umpoY7NwCclCxr+L6srq4uVVdXc7clgEkrJSVFS5cu1aJFi3TeeecpOztbTqdTvb29PG2Gk1YgEFB3d7d++ctfKjk5WS6XS9u2bYt2WcAoNptNdrtdZ5xxhubMmaPk5GR1dXXp9ddfV11dXbTLi0lvS7o12kUcg6slnRHtImIcAQYATDDBYFB79uxRa2urbDabMjIyVF5ertNPP12zZ8+WzWZTMBhUb2+v6urqVFVVJWNMpBspl8ulvLw8BpoFcFIa6ZLPZrNpcHBQ7e3t3H2MqHBp8pyM+SUd/YgxGG82m03Jyck69dRTtXTpUp1zzjnq6upSd3e3ent71dvbS4CBk1I4HNbAwICeffbZaJcCHJTNZpPT6dTs2bO1fPlyud1uNTU1qaqqinP5g9j53muiqRABxuFMlmNmADjpxMfHa9q0afrIRz6iq666ShkZGerq6tJzzz2n7du3a9WqVRoYGNDg4KBOOeUUlZWV6bbbbpPT6VR6erq8Xm+0NwEATqhQKKStW7fKZrOpvLxcM2bM0Mc+9jH95je/UVNTU7TLw0nm65IujnYRY+T7kh6LdhEYxeFwqKKiQvPmzdONN96otLQ0SVJvb6+ampr0zDPPqLq6WsEg0RMAxCKXy6WUlBTNmjVLS5Ys0apVq7Rlyxb19/ez78ZJhwADACaYkT4w09LS5PV6VVZWppKSErW2tqq1tVUbN25UVVWV1q5dG7mrrqCgQGlpaZGBwIPBIAM2AjjphEIh1dXVKSUlRdOmTVNKSkokyGhvb1dXV5eGhobU3d3NXckYd6WSFkuqkTRRnwFKkZQnKSvKdWB/lmUpMTFRaWlpysvLk8fjkTTcdV5jY6Oam5vV0dER5SqBI2SXlCFpMNqFHBm/pGpJ9SMTuG8MxyA+Pl6FhYXKzMxUYmKiampqtH37dsILnJQIMABggnE6nSopKdG8efO0ZMkSpaena3BwUH/961+1fv16PfPMM6O6BLAsS0VFRSovL5fL5VJ/f7+2bt2qlpaWKG8JAJxYPp9P//jHP1RbW6szzjhDmZmZSktL049//GP19/frT3/6kzZv3qz//u//lt/vj3a5OAn0S7pJ0pYo13GsPirp59EuAgdlt9tls9lks9ki015//XW9+OKLdD+CiSVR0vWSJsi9BQ2SPqDhrvWMxJU3HDWbzaZ58+bp1ltvVUVFhfr6+vTUU09p3bp1HKPipMRudIKxLEsOh0P5+flKSEhQTk6OvF5vpCuYcDisjo4O9fT0aOfOnRocHNTg4AS5TQHAEXG5XJo9e7bi4+OVm5srv9+vlpYWbd++XdXV1err61MgEIjMb7PZIgGGZVkaGhrS3r17NTAwEMWtAIATLxwOq7GxUdu2bdOLL76okpISTZ8+XU6nUx6PR/PmzVNKSopCoVBkgNve3l719/dr9+7dHFNhzBlJPZIm6qVkjiRin2VZkoafQAsGg+rq6lJ7ezt38CLmLZR0rZG0S8M7ygmoQdKrIz+EJfVFrxZMHDabTfHx8crIyNDUqVO1d+9e7d69W52dnYQXOGkRYEwwdrtd8fHxOuOMMzRt2jQtX75cBQUFKi4uljFGgUBAb731lrZu3arf//73ampqUkNDQ7TLBjCG4uPjdemll0Z+rqqqUlVVlVavXq0NGzaMmtdms8nhcGjRokU699xz5ff7I30f9/b2nujSASCqQqGQdu7cqba2NvX19emKK67Q9OnTJQ33F798+XJJ0sc//nE1NTVp27Ztqq6uVm1trR544AECDAAT1sgxYHt7u1paWggwEPNulHRjWNLL0a7k2D0m6TVNmAdHECMcDocyMjJUXFysuXPn6oEHHtCqVavU3t4e7dKAqCHAmAAsy5LX61V8fLxWrFihadOm6ZRTTlF6erqKioqUkJAQCS8CgYBKS0vldDp19tln65133iHAACaZkTvpwuGwAoGANmzYoKeeekqtra2ShkOLhIQEFRYWqrS0VFOnTlVxcbH6+vr02GOPacOGDfs9pQEAJ5OhoSHt3LlTjz76qHbv3q0VK1Zo5syZys/Pl9vtliQlJydr2rRpysjI0Jw5czRlyhS1tLRo9erVqq2t1caNG6O8FQBw5IaGhtTe3q7m5ma1tLRwHIiY9a6kf4t2EWNkpwgvcHSSkpKUl5ena6+9VgsWLNDg4KB27typdevWqb+/P9rlAVFDgBHjbDabnE6nkpKSlJGRofPPP19LlixRSUmJnE6nwuGwjDHy+/0aGhpSKBRSbm6u3G63Fi5cqLa2tmhvAoAxYIyJ/HsfGdtiJMDYsWOHXn75ZXV3d8tut8vpdColJUXTp0/X0qVLtWzZMmVkZKinp0f/+te/VF1drcHBQQaoBXDS8vv9amhoUENDg15++WW5XC55vV4lJydLGn7i1ePxKD8/XwUFBbIsS8uWLVNbW5s8Ho/Wrl2rrVu3KhQKKRwOR3lrAODwBgcH1d7ero6ODu3duzfa5QAHte29F3CysSxLiYmJKigo0Ac+8AGlpqaqr69PdXV1qq6ujnZ5QFQRYMQoy7KUkJCg4uJiXXrppaqoqNCsWbMiY18MDg6qoaFB77zzjvbs2aMdO3YoMzNTGRkZuuGGG2Sz2eR2u+Vw8CcGJoOdO3dqaGhIl1xyiZKTk5WWlia/36/29nbl5uZq+fLlCgQCstvtKiwsVEFBgc4880x5vV7FxcXpkUce0YYNG/TGG2+ou7ub8AIA3ufPf/6znnvuOcXHxysrK0uXXHKJsrOzVVRUpMLCQmVkZEiSUlJSdM0112jZsmVatmyZ/vGPf+jllydw3xYAThq7du3SY489ptra2miXAgA4AIfDoWXLlmnOnDnKz8/X1q1b9eSTT2r9+vXRLg2IOq5uxyC32y232x0ZdHfhwoWaMWOGKioqNDAwoIGBATU1NampqUkbN27Uzp07VVVVpbKyMg0NDSkQCMjhcHBXIDCJ9Pb2qrm5Wa2trero6FBKSkrkaYzMzEzNmDFDkuR0OjVlyhTl5eVpxowZ6unpUVdXl6qrq7VhwwZ1dHTI5/NFeWsAILbU19ervr5ekpSZmanc3Fzl5+err69PwWBQfr9fGRkZcrlcKiwsVFxcnGw2m7Zs2aLq6mp1dHQwqCKOj11SoiQr2oUcnR4Nd5EyanzdkKRe0W9KlI3cyRsfHy/LsiJ38Q4MMPQ6AMQah8Mhr9er0tJSlZSUyOFwaO/evXr33XfV0dER7fJOSpZlKS4uTna7XXa7XW63Wx6PRzabTTabTdJwrxg+n08DAwPq6enhGuw4IsCIMZZladasWZo6dao+//nPKzc3V3l5efL7/ero6NCqVau0bds2Pf3005HHf4PBoEKhkIqKihQfHy+bzaahoSHt3r2bQX6ASaK3t1eDg4N6/vnn1d7eroKCAsXFxamwsFC5ubk677zzIvM6HA4ZYzQ0NKTXXntN//rXv7Rq1SrV1NQwYCMAHEZHR4cefPBB2Ww2ORwOlZeXq6SkRN/97ndVVlYmSUpLS9PChQvl8Xi0YsUK3X777dq6dWuUK8eEli7pOkmuaBdydJ7U8Pi6ve+f2C7pvyVxv0RUuVwuXXDBBZozZ47sdrv8fr+6uroIWwEgBuXn56uoqEjXXHONCgoK1NDQoC1btuj111/nHD4KLMuSx+PRsmXLlJaWppycHM2ZM0dLlixRcnJyZMy83t5ebdmyRf/617/00EMPaXBwkDGmxgkBRgywLEt2u10FBQXKz8/X4sWLNWXKFBUWFsrtdqu5uVl1dXWqra3V6tWrtWfPHjU0NEQuaLrd7kh3U+Xl5XK5XAqFQvJ6vXK5JthZEIADMsYoFAqprq5O8fHxqq+vV2pqqpKSktTf36/BwUFJw3cADAwMqL+/Xy0tLXr77bdVWVmpzs5ODnwA4AiM7EdH1NfXKxAIaPXq1ers7FRxcbHi4uKUmJio7OxsGWM0ffp0+Xw+7dmzR6FQKIrVY8KySfJKGpTUFOVajkKWpIWS1kuqsUkqkhSnCfckyWRkWZaSkpKUmJgoafR4agCA2OB0OuVyuTR16lTNmDFDCQkJGhoa0po1a1RdXU3ofILFxcUpLi5ORUVFysjI0BlnnKGUlBSlpaWptLRU+fn5io+Pj1xrHfl7zZo1S4sWLdLWrVvV3Nwc5a2YnAgwYoDdbpfX69UFF1ygD3/4w1q4cKHS0tJkjFFdXZ3+9a9/6YUXXtDzzz+vvr6+/XZgKSkpKioq0gUXXKBzzz1XHo9HoVBIhYWFSktLi9JWARhr4XBYGzZsUFtbm+bOnauioiLNnDlTu3fvjvRnHAgEVFNTo4aGBq1evVotLS1qaWmJcuUAMHE1NjaqpaVFP/3pTzV16lTdfPPNKioqUkVFhXJycpSZmanLLrtMhYWF+v3vf0/3LDg+uyU9Hu0ijtxySb+TdKuk37okrZTkjGpJeI/NZlNiYqISEhJkWSRKABCLvF6vsrKydP755+v000+X0+nU7t279bOf/Yzz+ChIT09XcXGxrr32Ws2ZM0eLFy+Wx+OJfI/u+30aFxenmTNnyuPxKDs7W7/4xS8IMMYJAUYU2e12ZWVlqbS0VMuXL9fChQsj41jU1NTozTff1J49e/Taa69pz549GhgYGHUHtd1ul8fj0Zw5c3T++edrypQpcrlcsixLwWBQHR0d6uvri+IWAhhrvb29amxs1N///nclJycrIyNDXV1d6ukZ7n06HA6rq6tLvb29ampqUn9/f5QrBoCJLxwOq6GhQf39/br//vsj3Uelp6crMTFRixYtktfr1R//+EcCDByfCXZzvPW+10SrfTIbGcsnOztbKSkpBBgAEKO8Xq9ycnJUVFSkgoICbdu2TVVVVWpvb+dc/gQa6Rln9uzZuvjii7Vo0SLl5eXJ5/Ops7NT27dvj4wz3NjYqL6+PqWkpCg+Pl4FBQXq7+/nu3acEWBEkcPhUG5urhYtWqRPfepTSkxMlNfr1c6dO1VXV6fHHntMu3bt0vr16w+4vN1uV0JCgioqKvSBD3xA+fn5stvtMsbI7/ervb2dAAOYZAYGBjQwMKBnnnkm2qUAwEnDGKPm5mY1NzdHTipPOeUUOZ1OJScna968eUpISJDb7ZZlWXTRAiCqMjIyVFRUpMzMTCUnJ0e7HADAQYwEGHl5ecrJydFTTz2lTZs2qbOzk+6jTiDLsuR0OlVRUaHLLrtMmZmZcrlcam1tVX19vV5//XX5/X4FAgGtX79era2tKiwsVFZWlk455ZRI11MYPwQYUZSSkqJPf/rTKi0tld1u1xtvvKGNGzfqrbfeUmNjo2pqaiL92u/LsiylpKRo2bJlmjt3rgoLC+XxeBQMBlVZWanKyko9+uijamhoOMFbBQAAMLl1dXVp06ZNSk1NVWFhoaThPnCvuuoqbdmyRS+99FJ0CwRwUluyZIlOO+00paenKxwOa9euXdq5c6d27typ3t7ew68AADCuRu74Ly8v1xVXXKGMjAy1tbXphRde0ObNmxm/8gTLyMjQ0qVLNW/ePGVlZamqqkr19fX629/+pqamJu3ZsycyjlRPT48CgYDa2tqUnZ2tjIwMBQIB9ff3q6lpAg1kNsEQYETJyLgXs2bNUlpamvbu3avt27drzZo1Wr16tVpbW0cNAmlZlmw2m9xut+x2u+Li4pSfn6/p06crLy9P8fHxkqShoSHt2bNHO3bs0O7duzlABQAAOAiXyyWPxyNp+CmL/v5+hcPhwy7n9/vV2dkpn88XmWa325WWlhYZMBeIJqfTKbvdrsTERNntdjkc/3vaFwwGFQ6H5fP5FAwGNTQ0FBngGZNDdna2SkpK5PF4Ihdburu7IxddAADRZbfblZycrJycHJWXl8vhcKi7u1v19fVqamriO/kEi4uLU2lpqbKysuTxeCJPXY9cn+3u7h41v2VZcrlcCgQCstvt6uvrU1tbm4aGhqK0BZMfAUaUZGVlqbCwUFOnTtXOnTv1ox/9SNXV1dq9e7f8fv9+4UVCQoKSkpK0ePFiFRYWatmyZcrLy9Ps2bMjjymN9M324IMPauvWrero6GCnBwAAcBAzZ87UeeedJ2k4lHj44YfV3t5+TOvq6enRQw89xMB9iDrLsjRt2jQVFhbqE5/4hHJzc1VcXBzp3qy2tlbt7e1au3at9uzZo5deekn9/f3q7++PhBuY2FJTU5WTkyOHwyGfz6fe3l719vaqp6eHLu4AIMosy1JmZqYuv/xynXXWWZo1a5beeecdbdu2TW1tbYx9EQUpKSk65ZRTlJ+fL0l65ZVX9NJLL6m+vv6AoYTb7dbFF1+suXPnauXKldqwYYOeffZZVVZWnujSTxoEGFESCoUUCoUUDAbldDqVm5urgYEBhUIh+f1+GWOUkJAgp9Mpt9uttLQ0paenq6KiQjk5OZo+fbrS0tKUmpoaWWdTU5Nqa2tVX1+v9vb2USEIAAAAhtntdiUlJam4uFgLFixQa2ur2traZLfbD7mczWZTUlKScnJyNG3aNCUnJ8sYo97eXnV2dqqnp+eg3X8CJ5LX61VycrIyMjKUnZ0dOSGXhttxSkqKAoGAsrKyZFmWWltb1dTUpKamJvX29srn83GhewKz2+2y2+2yLEt+v1+NjY3q7OzkbwoAUWaz2ZSVlaUpU6ZowYIFKiwslDFGe/bs0caNG9Xf38++Ogre3+NNKBRSX1+furu7FQwG9/t7OBwOeTweTZs2TVOnTlVKSopSU1OVkZEht9sdpS2Y/AgwoqS7u1vt7e1qaWlRenq6vvCFL6iqqkrbt29Xa2urwuGwZs2apeTkZGVmZqqgoECFhYWyLCvyej9jjF599VW99dZb2r59uzo7O6O0ZQAAALEtPj5es2bN0jnnnKPrr79ejz32mNra2g67nMfj0axZs3TmmWfquuuuk81mkzFGO3fu1LZt27h5BDEjMTFRycnJkacujDGR84ecnBzl5ORoxowZkd9t3LhRb775pp588klt3bpVTU1N9L89SfT09OiVV17R9u3bo10KAJz0nE6nli1bpoULF+rGG29UKBRSd3e3nn32WT366KM8fRFlIzeVDw4OanBw8IBhktfrVUZGhs4++2yVl5dHbgyZPn26kpKSolD1yYEAI0qCwaC6urr0zDPPKDc3V0VFRZGT4pKSEoXDYaWmpsrtdis+Pl79/f3auXOn2tvb5fP5FBcXF/kHMrK+bdu2ae3atdz5BwAAcAhut1vFxcVKT0+PPMZfXFys4uJi2Ww2NTc3Kzs7W+Xl5aOWS05O1iWXXKIZM2bIZrPJsiyFQiFt2LBB69evl9/vj9IWAf/LGKOamhr19fVJGg4sZs2apaysLGVlZUkavtMwLS1NHo9HCQkJys3N1eLFi9Xf36/c3Fw99thj+/X3jNg3Mt6Jw+GQZVlqb29XQ0ODqqur1dLSEu3yAOCkZ1mW4uPj5fV6ZbPZ1NfXp6amJvX09ETGpMKJFw6HFQgEZIyRw+HQlClTVFFRIZ/PF+lCyuPxyOv16qyzztKMGTNUWFiohISE/W4wx/ggwIiSkZT1n//8p0pLS3XWWWdp+vTpKi0tjdzN9/6BJPfu3av29nZt27ZN3d3dkRPt8vJyGWNGBRgAYp/tvddEQW/YACaT9wcYkpSRkaGSkhKVlpbKGKP29nbl5+dr+fLlo5bLyMjQypUrI+OPGWMUCoX0zjvvaM2aNQyOi5hRU1Ojmpoabdy4UZmZmVq8eLFmzZql2bNnSxru/qC8vFzJycmKj49Xdna2srOz5XA4VFhYqOeff57xEiYgu90uj8cjp9Mpm82m9vZ21dfXq6qqikAKAGLA+wMMy7LU398fCTA4joweY0ykO3+n06nS0lL19PSosbEx8lTMSNecV199tZYtW6aEhIRR3c9yzDS+CDCiyO/3a/v27WpoaFBlZaVSU1OVlJQUedR7YGAgEmD4/X75/X719fXJ4/Hoc5/7nHJycmRZllpaWrRnzx51dXVFd4MAHBGvpJ9I6ol2IUdoQNLXo10EAIyhgYEBVVZWqqSkRJJUUFCg9PR0ZWRkqL+/X93d3ZGxLt7P5XLJ5XJFfn733Xe1ZcsWrVmzRtXV1XS5g5gTCATU0dGh1atXq7KyUs8++6yk4QAjLy9PM2bM0Kc//WklJycrKSlJpaWlSktL00033aQtW7boiSeeoGu0CSQrK0vTpk1TaWmpsrKytHXrVnV1dUXu7AUARI/b7VZKSoqWL1+uiooK2e12tbe3a/369XQDH2Wtra168sknZbfbVV5erjPOOEPz58/XpZdeGjm+dzqdcrlcKi0tjTxBgxOHACOKwuGwurq61NXVpcbGRjmdzsjdMiMBxr4Jns1mU0ZGRqRfW2m4X9M9e/ZoYGAgGpsB4FDskuIlvXdNq1tSh6QZ0avoqPW6Ja9NCoSkVk2c4AUADsbv96u5uVmtra3q7OyMnFBmZGQc8mTEGKNAIKBAIKBgMKjdu3fr3XffVUNDAzeSICYZYzQ0NKTm5mY1NzdHpo+cU/T396uurk7GGCUkJCg5OVlxcXGaP3++wuGwnnzySQKMCcTr9SorK0vJycnyer0KBoPy+Xzy+/38HQEgymw2m5xOp/Ly8pSdnS3LstTb26s9e/Yw9kWU9ff3q7q6WvX19ers7FR6erry8vI0c+bMUV1EjTx9HQ6HNTQ0JJvNNurmJowfAowYMnIyPOJAjx/l5eVpypQpmjdvXmRQ7x07duixxx5TQ0PDiSwXwJHIknSzpPf+Od+h4acvJpKwJTUlSGqTlkvi0ArARNff3693331XPT092rRpky644ALNnj1bM2fOVHx8/EGXGxwc1JYtW9Ta2qodO3bo2Wef1VtvvaXe3t4TWD1w/MLhsDo6OrRmzRp98Ytf1Ic+9CHdfPPNSktLk8vl0oIFCxQMBrm7EACAMTI0NKSenh7t3r1bXq9XKSkp2rFjh/76179Gxq1CdPT19Wnr1q164okn1NraqnPPPVelpaWaOnXqfgFFbW2t2tvb1djYqKSkJJ111llRqvrkQoARYw7XZ1paWppycnIUHx8vh8Oh/v5+tbW1kdgCsSYsqUHSPsch7e+9JpwuSR3SHgbDADAJGGPk8/nU2tqqqqoqZWRkqK+vT+3t7ZHxLQ5kaGhI27dvV0dHh/bs2aPa2lqevMCEFQqF1N/fr9raWrW1tWlgYEBJSUlyuVzyeDxyu90MTDnBhcPhSJfEAIDoGrl7f6SLeJ/Pp4GBAXV3d7OvjrKRMTCam5u1ZcsWJSYmqqWlRc3NzXI6naPmHTn+tyyLv9sJRIAxgViWpYqKCi1atEher1c+n0+7du1SZWWl1q5dyz8cIJb4JD0e7SLGAbsZAJNIe3u7Ojo6tGnTJlmWdUQXa40xo17ARBYMBtXR0RF5paamyuv1RrssjIGRoNbv90e7FADAPgKBgNra2niKN8bs3r1bNTU1euGFF2S32xUfH7/f06iDg4NyOp268cYb5Xa7OR84QQgwJgi73S6n06mpU6dq5syZcrlcGhoaivS5HA6H+UcDxBou9gNAzBu5Gw44GY303ezxeOTxeGS32yPnFJxbTGzBYFCbNm1SZWUlN7oBQIyx2+1KSEhQRkaGCgoK1N7eTq8qMeD9NymFQiEZY/a7wSkYDMoYs993K0+tji8CjAnC4XAoLi5OM2bM0IIFC+R2u9XV1aU9e/Zo7969nGAAAAAAOCojdxd6vV55vV7Z7fZol4QxEggE9NZbb2nLli2EtAAQY+x2u1JSUpSTk6OpU6fK5/MRYMSQkRDD5/Md8Pf7dis1ghBj/BBgTBAej0epqalKS0tTSkqKjDFqa2vTc889p+rq6miXBwAAACDKioqKVFRUpGXLliknJ0culytyMl1XV6fa2lrt2rVLnZ2d6ujoUElJiW655RZNnz5dOTk58ng8Ud4CjAW6ugOA2BQKhbRr1y55PB4VFhaqtrZWlZWV6u7ujnZpOA4jg7MzGPv4IcCYINxutxITE+X1euXxeDQ0NKTu7m5t27ZNbW1t0S4PAABgXHklpb33/2FJPZLskhKjVtHhOd97AePNsizZ7Xbl5uZq1qxZWr58uaZMmaK4uLhIgFFVVaUtW7bI7XarublZHo9H5eXluuiii5SYmKj4+PhIlwn9/f0aGBjg4vcE8/4BYoeGhhQIBBQMBqNdFgDgPeFwWI2NjUpISFBDQ4Oam5vV2trK9+0E9P6nLQKBgHp7exUIBKJY0eRGgDFBZGdna968eUpOTlYgEFBVVZUqKytVW1t70EeaAAAAJotbJF313v83SbpWUrmkX2s4yIhFlqQCSXujXQgmvaSkJE2ZMkXXXHONPvKRjygpKUkulysy8KQxRklJSZo3b56uuOIKhUIhBYNBud1uZWRkRLqOCgQC6urq0o9+9CNt2bKFE/EJpru7W7t27dIrr7yiXbt2adOmTWpsbOTCGADECJ/Pp3/84x9yuVy677771NPTwzhFE5BlWYqLi1NcXJwkKSUlReXl5UpKSopyZZMXAcYEYFmWEhMTlZubK7fbrXA4rI6ODnV2dsrv99OnKQAAmLT2SnpLw2HAiG4NP4UR8EidBZI9hq/N7ZXUIsn//onJ0akFk9vIyXRqamokvBi5O9AYI4fDofj4+FHzj/wuGAzK7/ervr5ejY2N2rZtm2pra7nwPcEMDQ2ps7NT27Zt0969e9XT0yO/33/4BQEAJ4QxRl1dXZKk1tbW6BaDY2ZZlrxeb+RJ1/cP+o3xQYAR40YeB8/Ly9OCBQuUnJysYDCoXbt2cVIBAAAmvdckrdhnmpE0JGlvnnT+x0aHG7FopN4IW5QKwaQ1ODio+vp61dfXq6GhQbm5ufJ6vYc8V3j/77q6utTS0qI//OEPWrNmjd599126kJqAenp61Nvbq/r6elmWxRM0AACMA5vNpoKCAuXl5cmyrMgYGL29vdEubdIiwIhxdrtdXq9X2dnZKisrk8fj0eDgoDZv3qzt27dzUgEAACa1sKTBfSf6JW2Qwu59goGJpivaBWCyCIVCGhwc1JYtW/Tss89q/vz5Sk9Pl9O5/ygsmZmZ8nq9cjj+91Swrq5Or7/+urZs2aK6ujr5/X7OM06gJElXSIobi5UZI43zuBeZGqNaAQCYoMLhcKT7L5/Pp66uLm4cGEcEGDHO4XAoKSlJxcXFmj9/voaGhtTc3Kw33nhDu3btoq88AABw8hmS9Hy0iwBix8jA22+++aZ27dqlyy+/fL9BvKXhp7sXL14sp9Mpu90+aoDvP//5z9q+fbv27mXUlhNlJCLKlPSD9/4LAABiXyAQUPC9GwaGhobU3t6uoaEJfWtVTCPAiHEjAYbb7ZYk7d27V01NTeru7tbAwECUqwMAAAAQK7q7u+X3+/X4448rISFh1FMW0nCAcfHFF2vGjBk677zz5PV6JUkFBQU6++yz1d3dTYBxgvy3pHckVUsajJc+f4kUN74PToy52uT/DWEAYNLKk/ShaBdx5N6RdLOkd0cmBCQ9FbVyJp24uDglJydr2rRpKioqkmVZGhoa0t69exl3ahwRYIwhp8b+UdpEy1K60ylvMCj19GiopUUDTU2y9/fL4/fLM0bvYyT1a7ibBgAAAAATz9DQUGQg5wOxLEvp6eny+/1aunSpPB6PLMtSRkaGZs6cqZdfflk2m42nvE+At997KSDJSH+ZFt16jplPUijaRQDAODAa3sd5Jc2Ici1HoUnSY3pfN6s+EWCMIafTKa/Xq8zMTKWnp8uyLPn9fvX29tKF1DgiwBhDl0r69hiv097fL1d1tdJ+/GNZf/iDCn0+Zfn9erS9XWP5z2JQ0iclbRnDdQIAAACIHcYYPf/889qyZYsWLFigadOmadq0aSopKVF2drZef/11NTU1qampiZPwEyGk4YtKrmgXcpz6ol0AAIyDXkl/lmSLdiFH50xJP5b0S0m/l7hTeYw5nU55PB7Fx8crLm74Nvauri5VV1erp6cnytVNXgQYY8ho7G8+CYXD8g8Oqq+hQbUNDWO89v8VFo//AgAAAJNdd3e3LMtSU1OTUlNTNW3aNHk8Hnk8HmVnZysnJ0dtbW0EGCfKgR+WAQBEiSWpXFJ/SFJblIs5BvMlzZWUFeU6JiubzRZ5GWM0NDSkgYEB9fX1cew0jggwxtBTmtjjSTKiBgAAADD5BQIBrVu3TsYYLV68WA6HQ8YYLViwQJK0a9cuDQ4ORrlKAABOPKekX2ji9o7n0HAIg/E3NDSk7du3q6GhQQMDA3TBOY4IMMZQMF3qWxDtKo6RXcP9+hEWAgAAADHNsixNnTpVcXFx6u7u1sDAgNrb2494+WAwqN27dyszM3PUdIfDIYfDIcvi0gcA4OSzWtL/i3YRY2RDtAs4CYTDYfl8PgUCAYXDYRlD3zbjhQBjLBW995qoLEmt0S4CAAAAwKHYbDadccYZys7O1rZt21RfX39UAUYgENDGjRuVlJTE3YIAALzn4fdewJF4f4BBeDG+CDDGQrekZzT8FMNENySewgAAAABinDFGiYmJWrlypbq7u7V161atXr1a69at08DAgILB4EGXdblcWrRokWbPni2bbYKNTgoAABADQqGQuru76XbzBCDAGAuDktZHuwgAAAAAJwtjjOLi4nTOOecoGAxq5syZCgQC2rNnj8LhsAYHBxUK7d+Dt81mk9vt1owZM1RaWjqqu6hwOMwTGQAAYGKyaXgQk3FkHEZhe1iDwUE5fU519XdpIDBwXO/r1/C4xGFp3OufqAgwAAAAAGACMcaop6dH3d3dstlsSk5O1vTp0/W5z31O1157rR5++GFt3bpVb731lgYGBuTz+SLLTp8+XaWlpbruuutUUFAgu334MXLLslRbW6vKyspR8wMAAEwIJZJWju9bdDm7NOAa0A3/c4Psdvvw8Vhu93G9768k/VVSlTR8pd4zJqVOKgQYAAAAADDBdHV1qa2tTV1dXbIsS/Hx8YqPj1dBQYG2bt0qh8Oh9vZ29fb2qre3V9JwSDF9+nSVlZWpsLBQ6enpMsYoFAopEAios7NTbW1th+x+CgAAIJa4glJJh2RzSXKN97sFpUBQga0bFXjv7TIlZR7n+/ZJijw32yGp5/jWN9kQYAAAAADABBIOh/X6669r+/btmjlzpioqKnT22WfLsixZlqUrr7xSl156qT70oQ+pu7tbTU1NMsbIsiwtWrRIOTk5SklJiQw42dXVpZaWFlVVVamqqkp+vz/KWwgAAHBkSrqkZx6SkqNdyHHwS/qwpLdGJuzfC+hJjQADAAAAACaYQCCg3t5erVmzRp2dnbLb7SosLFRubq5cLpccDocKCgqUlpam5OTkSICRlZWlxMRE2Ww2GWPk9/tVU1OjNWvWqK6uTgMDA4yDAQAAJow+Iz0/JMVHu5DjEJDUGe0iYhgBBgAAAABMQL29vXrkkUeUk5OjdevW6cMf/rAuvvhiJSYmyul0Ki8vT5IiT1qMGBm4OxgMqq+vT2+++aZ+9atfqampSX19fSd8OwAAAI5Vg6RPRbsIjCsCDAAAAACYgIwxCgaD6uzs1KZNm+TxeNTU1KTy8nJlZmZq0aJFcrlckcDCGKOOjg719fWppqZGLS0tevfdd7Vx40a1tbUxeDcAAABiDgEGAAAAAESBpeHBH50a7jrApmM4QQuH5evtVV1vr2yBgFpqa9W9dKlKSko0d/p0ueLf16GCMeppa1Nra6vWr16tnTt36qmnnlJfX58G+vsj9RwpTiYBAAAw3jjmBAAAAIAo8Er6jaR3JX1e0rmSvnYc63O3tMjd1aWkPXvkiYuT97//Wza7XXpfF1IFQ0PKCgRU3NOjwaEhrdy7V6FQ6JjGiszWcAgDAAAAjBcCDAAAAAA4wVol1UhKkpSp4acvvJJyj2elPp/k8ynU06N+Sf07dhxydktS+vG8n6QdknqOcx0AAADAwRBgAAAAAMAJdoek/3zv/4OSBiQ9KenlqFV07HqjXQAAAAAmLQIMAAAAADjBerX/hf+h914AAAAAhtmiXQAAAAAAAAAAAMC+CDAAAAAAAAAAAEDMoQspAAAAAIgFlibuLWYTtW4AAADENAIMAAAAAIgFUyV9NNpFHCNLUrqknmgXAgAAgMnkmAMMY8xY1oFJYLzbBG0OB0K7w4l2ItoE7Q77Yl+HaKDdnUBhST5JLkn5Ua7lePklHeOflu9YRAP7OkQD7Q4nGt+xiIaxahPHHGD09fWNSQGYPHp7e5WcnDyu6wf2RbvDiTbebW7kPYD3Y1+HaKDdnUCtkn4c7SKij+9YRAP7OkQD7Q4nGt+xiIaxyg8sc4xRSFdXl1JTU1VbWzvu/wAQ24wx6u3tVV5enmy28ev8NhwOq7GxUYmJibIsa9zeBxMD7Q4n2olqcxLtDv+LfR2igXaHE43vWEQD+zpEA+0OJxrfsYiG7u5uFRUVqbOzUykpKce9vmMOMHp6epScnKzu7m4lJSUddyEAAAAAAAAAAGDiGuvcYHyjNwAAAAAAAAAAgGNAgAEAAAAAAAAAAGIOAQYAAAAAAAAAAIg5BBgAAAAAAAAAACDmEGAAAAAAAAAAAICYQ4ABAAAAAAAAAABiDgEGAAAAAAAAAACIOQQYAAAAAAAAAAAg5hBgHKPe3l598YtfVHFxseLi4rRs2TK9/fbb0S4Lk9i9996ruXPnKikpSUlJSTrttNP0zDPPRLssTHINDQ264YYblJ6eLq/Xq/nz5+udd96Jdlk4Cdxzzz0qKSmRx+PRokWL9Oqrr0a7JExi3/72t2VZ1qhXTk5OtMvCJMZxHaLhlVde0WWXXaa8vDxZlqXHHnss2iXhJHP33XfLsix98YtfjHYpmOTY3yEauFY8fggwjtEnP/lJrVq1Sn/84x+1adMmXXDBBVqxYoUaGhqiXRomqYKCAn3/+9/X2rVrtXbtWp133nm6/PLLtWXLlmiXhkmqs7NTp59+upxOp5555hlVVlbqRz/6kVJSUqJdGia5Rx55RF/84hf1zW9+U++++67OPPNMXXzxxaqtrY12aZjEZs2apaampshr06ZN0S4JkxjHdYiG/v5+zZs3T7/85S+jXQpOQm+//bbuu+8+zZ07N9ql4CTA/g7RwLXi8WMZY8yxLNjT06Pk5GR1d3crKSlprOuKaYODg0pMTNTjjz+uSy+9NDJ9/vz5+sAHPqA777wzitXhZJKWlqYf/vCH+sQnPhHtUjAJfe1rX9Prr7/One844ZYsWaKFCxfq3nvvjUyrqKjQhz70Id19991RrAyT1be//W099thjWr9+fbRLwUmM4zqcSJZl6dFHH9WHPvShaJeCk0BfX58WLlyoe+65R3feeafmz5+vn/70p9EuCycJ9nc4EbhWPNpY5wY8gXEMgsGgQqGQPB7PqOlxcXF67bXXolQVTiahUEgPP/yw+vv7ddppp0W7HExSTzzxhBYvXqyPfOQjysrK0oIFC/Tb3/422mVhkvP7/XrnnXd0wQUXjJp+wQUX6I033ohSVTgZbN++XXl5eSopKdG1116rXbt2RbsknCQ4rgMw2X32s5/VpZdeqhUrVkS7FAAYF1wrHl8EGMcgMTFRp512mr773e+qsbFRoVBIDz30kFavXq2mpqZol4dJbNOmTUpISJDb7datt96qRx99VDNnzox2WZikdu3apXvvvVdlZWV67rnndOutt+oLX/iCHnzwwWiXhkmsvb1doVBI2dnZo6ZnZ2erubk5SlVhsluyZIkefPBBPffcc/rtb3+r5uZmLVu2TB0dHdEuDZMYx3UATgYPP/yw1q1bx1O0ACY1rhWPLwKMY/THP/5Rxhjl5+fL7Xbr5z//ua6//nrZ7fZol4ZJbPr06Vq/fr3eeust/Z//83+0cuVKVVZWRrssTFLhcFgLFy7UXXfdpQULFuiWW27Rpz71qVHd+gDjxbKsUT8bY/abBoyViy++WFdeeaXmzJmjFStW6KmnnpIk/eEPf4hyZZjMOK4DMNnV1dXptttu00MPPbTfXckAMNlwrXj8EGAco6lTp+rll19WX1+f6urqtGbNGgUCAZWUlES7NExiLpdL06ZN0+LFi3X33Xdr3rx5+tnPfhbtsjBJ5ebm7ncnaEVFBQMpY1xlZGTIbrfv97RFa2vrfk9lAOMlPj5ec+bM0fbt26NdCiYxjusATHbvvPOOWltbtWjRIjkcDjkcDr388sv6+c9/LofDoVAoFO0SAWDMcK14/BBgHKf4+Hjl5uaqs7NTzz33nC6//PJol4STiDFGPp8v2mVgkjr99NO1bdu2UdOqq6tVXFwcpYpwMnC5XFq0aJFWrVo1avqqVau0bNmyKFWFk43P59PWrVuVm5sb7VJwEuG4DsBks3z5cm3atEnr16+PvBYvXqyPfvSjWr9+PXclA5iUuFY89hzRLmCieu6552SM0fTp07Vjxw595Stf0fTp03XzzTdHuzRMUt/4xjd08cUXq7CwUL29vXr44Yf10ksv6dlnn412aZik/u3f/k3Lli3TXXfdpauvvlpr1qzRfffdp/vuuy/apWGS+/d//3fdeOONWrx4sU477TTdd999qq2t1a233hrt0jBJffnLX9Zll12moqIitba26s4771RPT49WrlwZ7dIwSXFch2jo6+vTjh07Ij/v3r1b69evV1pamoqKiqJYGSarxMREzZ49e9S0+Ph4paen7zcdGEvs7xANXCsePwQYx6i7u1tf//rXVV9fr7S0NF155ZX63ve+J6fTGe3SMEm1tLToxhtvVFNTk5KTkzV37lw9++yzOv/886NdGiapU045RY8++qi+/vWv64477lBJSYl++tOf6qMf/Wi0S8Mkd80116ijo0N33HGHmpqaNHv2bD399NM8/YNxU19fr+uuu07t7e3KzMzU0qVL9dZbb9HmMG44rkM0rF27Vueee27k53//93+XJK1cuVIPPPBAlKoCgLHH/g7RwLXi8WMZY8yxLNjT06Pk5GR1d3crKSlprOsCAAAAAAAAAAATyFjnBoyBAQAAAAAAAAAAYg4BBgAAAAAAAAAAiDkEGAAAAAAAAAAAIOYQYAAAAAAAAAAAgJhDgAEAAAAAAAAAAGIOAQYAAAAAAAAAAIg5EybAOOecc/TFL34x2mXgJEO7w4lGm0M00O4QDbQ7nGi0OUQD7Q7RQLvDiUabQzTQ7k4i5hh1d3cbSaa7u/tYV3FUOjo6TE9Pzwl5r3397W9/MxUVFcblcpmKigrzj3/847DLPPvss2bJkiUmISHBZGRkmCuuuMLs2rUr8vuVK1caSfu9Zs6ceVTv/fLLL5sPfOADJjc310gyjz766H613H777Wb69OnG6/WalJQUs3z5cvPWW2+NmmfHjh3mQx/6kMnIyDCJiYnmIx/5iGlubo78fvfu3ebjH/+4mTJlivF4PKa0tNR861vfMj6f74Db397ebvLz840k09nZedjPK1ZNtnb397//3axYsSLyd166dKl59tlnR63jvvvuM2eccYZJSUmJtJfVq1cf9D3vuusuI8ncdttto6b//e9/NxdccIFJT083ksy7776737JNTU3mhhtuMNnZ2cbr9ZoFCxaYv/71r4fdzslssrW5F1988YD7uq1bt0bm+fvf/24WLVpkkpOTjdfrNfPmzTMPPvjgQd/zQG3O7/ebr371q2b27NnG6/Wa3Nxcc+ONN5qGhoZRyw4NDZnPfe5zJj093Xi9XnPZZZeZurq6/d7jySefNKeeeqrxeDwmPT3dfPjDHz7sZzGRTbZ2Z4wxL730klm4cKFxu92mpKTE3HvvvaN+f/bZZx+wbV5yySUHfM+D7euMMaaystJcdtllJikpySQkJJglS5aYPXv27DdfOBw2F1100UG/r4+k3d1///1mzpw5xu12m+zsbPPZz372EJ9UbJtI7e72228/YHvxer2ReY5kf3ck7e6ee+4xc+bMMYmJiZHv6qeffnq/eg51bNfR0WE+97nPmfLychMXF2cKCwvN5z//edPV1TVqPe+8845ZsWKFSU5ONmlpaeZTn/qU6e3tPabPdCKYSG3OmOF9xg9/+ENTVlZmXC6XKSgoMN/73vcivz+SNrd582ZzxRVXmOLiYiPJ/OQnPznge/3qV78yU6ZMMW632yxcuNC88soro37f3NxsVq5caXJzc01cXJy58MILTXV19ah5fvOb35izzz7bJCYmHvYcYGhoyMybN++gx4js68ZGtL5j77///gO2zcHBwcg8B9qvZmdnH7SuT3/60/u14d27dx/wfSSZv/zlL5H5jmRfd6B17LtdE8lka3eNjY3muuuuM+Xl5cayrAMejx3Jd+xdd91lFi9ebBISEkxmZqa5/PLLTVVV1aj1hMNhc/vtt5vc3Fzj8XjM2WefbTZv3jxqniM5p7jssstMYWGhcbvdJicnx9xwww37nZtMJhOpzR3JcZ0xxvzyl780M2bMMB6Px5SXl5s//OEPo35/JOexPT095rbbbjNFRUXG4/GY0047zaxZs2bUPAe6PrhkyZID1n6484mTzURqd8Yc2XfsQw89ZObOnWvi4uJMTk6Ouemmm0x7e/uoeTo7O81nPvMZk5OTY9xut5kxY4Z56qmnDvieBzuPPdz5xJF+xxpz4PPY9+cGY/EdO2ECjGh54403jN1uN3fddZfZunWrueuuu4zD4dgvAHi/nTt3Grfbbb7+9a+bHTt2mHfeececddZZZv78+ZF5urq6TFNTU+RVV1dn0tLSzO23335U7/3000+bb37zm+bvf//7QXdgf/rTn8yqVavMzp07zebNm80nPvEJk5SUZFpbW40xxvT19ZnS0lLz4Q9/2GzcuNFs3LjRXH755eaUU04xoVDIGGPMM888Y2666Sbz3HPPmZ07d5rHH3/cZGVlmS996UsH/Awuv/xyc/HFF0/4ACNaxqvd3XbbbeYHP/iBWbNmjamurjZf//rXjdPpNOvWrYvMc/3115tf/epX5t133zVbt241N998s0lOTjb19fX7veeaNWvMlClTzNy5c/fbGT744IPmO9/5jvntb3970JPTFStWmFNOOcWsXr3a7Ny503z3u981NpttVD04McarzY1cXNm2bduofV4wGBw1zz/+8Q9TWVlpduzYYX76058au92+X7hmzMHbXFdXl1mxYoV55JFHTFVVlXnzzTfNkiVLzKJFi0Ytf+utt5r8/HyzatUqs27dOnPuueeaefPmjarnb3/7m0lNTTX33nuv2bZtm6mqqjrpg7XxMl7tbteuXcbr9ZrbbrvNVFZWmt/+9rfG6XSav/3tb5F5Ojo6RrXJzZs3G7vdbu6///793vNQ+7odO3aYtLQ085WvfMWsW7fO7Ny50zz55JOmpaVlv/X8+Mc/jnw37vt9fSTt7kc/+pHJy8szf/rTn8yOHTvM5s2bzRNPPHGITxgHciztrre3d1R7aWpqMjNnzjQrV66MzHMk+7sjaXdPPPGEeeqpp8y2bdvMtm3bzDe+8Q3jdDpHXTw53LHdpk2bzBVXXGGeeOIJs2PHDvP888+bsrIyc+WVV0bW0dDQYFJTU82tt95qqqqqzJo1a8yyZctGzYOxcSxtzhhjPv/5z5vp06ebxx9/3Ozatcu8++67ZtWqVZHfH0mbW7Nmjfnyl79s/vznP5ucnJwDBhgPP/ywcTqd5re//a2prKw0t912m4mPj48EseFw2CxdutSceeaZZs2aNaaqqsp8+tOfNkVFRaavry+ynp/85Cfm7rvvNnffffdhzwG+8IUvRPaH+x4jsq8bG9H8jr3//vtNUlLSfvvN97v99tvNrFmzRv1+ZB+2r0cffdTMmzfP5OXljWrDwWBwv/f4zne+Y+Lj4yMBxZHu6ySZ+++/f9S6BgYGjvjzxrDxane7d+82X/jCF8wf/vAHM3/+/AMGGEfyHXvhhRea+++/32zevNmsX7/eXHrppfvty77//e+bxMRE8/e//91s2rTJXHPNNSY3N3fURdIjOaf48Y9/bN58801TU1NjXn/9dXPaaaeZ00477Rg/WRzMeB3X3XPPPSYxMdE8/PDDZufOnebPf/6zSUhIGPV9dCTnsVdffbWZOXOmefnll8327dvN7bffbpKSkkZdX1m5cqW56KKLRtXT0dFxwNoPdT6BE2e89nWvvvqqsdls5mc/+5nZtWuXefXVV82sWbPMhz70ocg8Pp/PLF682FxyySXmtddeMzU1NebVV18169ev3+89D3Uee7jziSP5jjXm4Oex+wYYx/sdO2ECjLPPPnvUh713715z4403mpSUFBMXF2cuuuiiUXcB3X777WbevHmj1vGTn/zEFBcXH9X7Xn311eaiiy4aNe3CCy8011577UGX+etf/2ocDkfk4r8xwyejlmUZv99/wGUeffRRY1mWqampOeb3PtId2Mjf7n/+53+MMcY899xzxmazjfpb7t2710gadZK0r//8z/80JSUl+02/5557zNlnn22ef/75CR9gTPZ2Z4wxM2fONN/5zncO+vtgMGgSExP3u9ugt7fXlJWVmVWrVu33Ob3fSGp7oAAjPj5+vzsU0tLSzO9+97uD1jPZTbY2N3Jx5Wj3AwsWLDD/8R//MWrakba5EWvWrDGSIhdgurq6jNPpNA8//HBknoaGBmOz2SIHmYFAwOTn5590bXCytbuvfvWrZsaMGaOWu+WWW8zSpUsPut6f/OQnJjExcdQJrDGHb3fXXHONueGGGw65ncYYs379elNQUGCampr2+74+kna3d+9eExcXF/nungwmUrvb1/r1642kUXepH8v+7mDtbl+pqamHbB/7HtsdyF/+8hfjcrlMIBAwxgzfLZ+VlTXq39K7775rJJnt27cf8TZMJBOpzVVWVhqHw7HfncHvd7Rtrri4+IABxqmnnmpuvfXWUdNmzJhhvva1rxljjNm2bZuRNCpECwaDJi0tzfz2t7896rqefvppM2PGDLNly5b9jhHZ102O79j777/fJCcnH7K+A23ngdTX15v8/HyzefPmg7bh95s/f775+Mc/Hvn5SPd1k+1i4GRrd4fatoM5ku/Y1tZWI8m8/PLLxpjhwDYnJ8d8//vfj8wzNDRkkpOTza9//WtjzJGdUxzI448/fthz84lsIrW5fR3ouO60004zX/7yl0fNd9ttt5nTTz/9kOt6/3nswMCAsdvt5sknnxw1z7x588w3v/nNyM8rV640l19++RHVebDziZPVRGp3R7Kv++EPf2hKS0tHLffzn//cFBQURH6+9957TWlp6WH3JUd7/eRIzif2/Y491HnsvgHG8bbXCTMGxr5uuukmrV27Vk888YTefPNNGWN0ySWXKBAIHPE6XnrpJVmWpZqamoPO8+abb+qCCy4YNe3CCy/UG2+8cdBlFi9eLLvdrvvvv1+hUEjd3d364x//qAsuuEBOp/OAy/z+97/XihUrVFxcfFzvfTh+v1/33XefkpOTNW/ePEmSz+eTZVlyu92R+Twej2w2m1577bWDrqu7u1tpaWmjplVWVuqOO+7Qgw8+KJttwjavg5ps7S4cDqu3t3e/v+P7DQwMKBAI7DfPZz/7WV166aVasWLFQZc9nDPOOEOPPPKI9u7dq3A4rIcfflg+n0/nnHPOMa9zspksbW7BggXKzc3V8uXL9eKLLx50ncYYPf/889q2bZvOOuusUb872jbX3d0ty7KUkpIiSXrnnXcUCARGbWdeXp5mz54d2c5169apoaFBNpstUvPFF1+sLVu2HNF7ThYTvd0dbL1r16496Db8/ve/17XXXqv4+PhR0w/V7sLhsJ566imVl5frwgsvVFZWlpYsWaLHHnts1HwDAwO67rrr9Mtf/lI5OTn7redI2t2qVasUDofV0NCgiooKFRQU6Oqrr1ZdXd1BP6uJJpbb3b5+97vfqby8XGeeeeZ+vzvS/Z108HY3IhQK6eGHH1Z/f79OO+20A85zoGO7A+nu7lZSUpIcDoek4eM/l8s16ngtLi5Okg55/DeZxHKb++c//6nS0lI9+eSTKikp0ZQpU/TJT35Se/fu3W/eo2lz+/L7/f9/e/ceXdOd/3/8pTk5QeKeIKQoGUq1VBRxqZa6LYapXqhWmWpXddX0wlhFzTBfQ7VqlJR2IShVce+Y1iU0aKdKKz0ZDJWIqLqkRmgTTRsk798fVs43R3KSE/r7/U7OPB9r5Y/s8zmfvT8773wu+73P2UpOTi52fL1793YfX15enqRr64NCQUFBcjqd5Y6V77//Xs8884xWrFihqlWrFnudvs43FWGMvXTpkho3bqyoqCgNGDBALper2P7S0tLUoEED3XbbbRo6dKiOHz/u8XpBQYGGDx+u8ePH64477vB63IWSk5OVkpKiUaNGubeVp68bM2aMwsPDdc899+jdd99VQUFBmfusKCp63N2IssZY6drYKMm91s3IyFBmZqZHG0JCQtS9e3d3G3xZU1zvwoULWrlypTp37nxTbapI/DnmrlfSvC4vL89j3JOu9R1ffvlliW0oaR179epV5efnl1jP9f3Prl27VLduXTVv3lzPPPOMzp075/F6WesJXOPPcedLX9e5c2edOnVKmzdvlpnp+++/17p169S/f393PZs2bVJsbKyef/551atXT61bt9aMGTOUn5/vsb/yXD/xZT1R0hhbnusnNzvGVsgrzGlpadq0aZMWL16sbt26qU2bNlq5cqVOnz5d7KJBaapWraoWLVqUOoBkZmaqXr16Htvq1aunzMxMr+9p0qSJEhMTNWnSJIWEhKhmzZo6deqUEhISSix/9uxZbdmyRU8//fRN79ubjz76SGFhYapcubLmzJmj7du3Kzw8XJLUqVMnhYaG6pVXXlFubq5++uknjR8/XgUFBTp79myJ9aWnpysuLk6jR492b8vLy9Njjz2mWbNmqVGjRuU+Rn8XaHEnSbNnz9ZPP/2kRx991GuZCRMmqGHDhh6dXkJCgr7++mu99tprXt/ni9WrV+vq1auqU6eOQkJC9Oyzz2rjxo1q1qzZTdUbKAIh5iIjI7Vw4UKtX79eGzZsUIsWLdSzZ099+umnHnX9+OOPCgsLk9PpVP/+/RUXF6devXq5Xy9vzP3yyy+aMGGChg0bpurVq7vb6HQ6VatWLa/tLFw4T506VZMnT9ZHH32kWrVqqXv37iVeNApEgRB33uq9evWqzp8/X6zOL7/8UocOHSo2DpcVd+fOndOlS5c0c+ZM9e3bV4mJiXrwwQc1ePBg7d69213u5ZdfVufOnTVo0KAS6/El7o4fP66CggLNmDFDb731ltatW6cLFy6oV69eunz5stfzVVH4e9wVlZeXp5UrV3pM3iXf+7tC3uJOkg4ePKiwsDCFhIRo9OjR2rhxo1q1auVRprS53fWysrI0bdo0Pfvss+5tPXr0UGZmpmbNmqXLly/r4sWLmjRpkiR5nf8FEn+PuePHj+vbb7/V2rVrtXz5ci1btkzJycl6+OGH3WXKG3MlOX/+vPLz80s9vttvv12NGzfWxIkTdfHiRV2+fFkzZ85UZmZmuWLFzDRy5EiNHj1a7du399pu+rqy+fsYe/vtt2vZsmXatGmTVq1apcqVK6tLly5KS0tzv6djx45avny5tm3bpkWLFikzM1OdO3dWVlaWu8zrr78uh8OhF154wafzEh8fr5YtW6pz587ubb72ddOmTdPatWu1Y8cODR06VOPGjdOMGTN82q+/C4S4K6/SxthCZqaxY8eqa9euat26tfv4C4/ZWxt8WVMUeuWVVxQaGqo6dero5MmT+vvf/37DbapI/D3mivI2r+vTp48WL16s5ORkmZn279+vJUuW6MqVKx7ridLWsdWqVVNsbKymTZumM2fOKD8/X++//7727dvn0f/069dPK1euVFJSkmbPnq2vvvpKPXr0cN9AIJW9noD/x50vfV3nzp21cuVKDRkyRE6nU/Xr11fNmjUVFxfnLnP8+HGtW7dO+fn52rx5syZPnqzZs2dr+vTp7jK+Xj8pz3qipDHW1+snv8YYWyETGEeOHJHD4VDHjh3d2+rUqaMWLVroyJEjPtfToUMHffPNN2rYsGGp5SpVquTxu5kV21ZUZmamnn76aY0YMUJfffWVdu/eLafTqYcfflhmVqz8smXLVLNmTf3ud7+76X17c//99yslJUV79uxR37599eijj7ozuhEREVq7dq3+8Y9/KCwsTDVq1NCPP/6odu3aKSgoqFhdZ86cUd++ffXII494TAgmTpyoli1b6oknnij38VUEgRZ3q1at0tSpU7V69WrVrVu3xDrfeOMNrVq1Shs2bHDfNfDdd9/pxRdf1Pvvv1/sToLymjx5si5evKgdO3Zo//79Gjt2rB555BEdPHjwpuoNFIEQcy1atNAzzzyjdu3aKTY2VgsWLFD//v315ptvetRVrVo1paSk6KuvvtL06dM1duxY7dq1S1L5Y+7KlSsaOnSoCgoKtGDBgjLLF21n4V0Ar776qh566CHFxMRo6dKlqlSpktauXVtmXYEgEOLOW70lbZeuTcZat26tDh06uLf5EneF8TJo0CC9/PLLatu2rSZMmKABAwbo3XfflXTtDpmkpCS99dZbXtvkS9wVFBToypUrmjdvnvr06aNOnTpp1apVSktLK/cd1/7I3+OuqA0bNignJ0dPPvmkx3Zf+7tCJcVd0bpSUlK0d+9ePffccxoxYoQOHz7sUaa0uV1R2dnZ6t+/v1q1aqUpU6a4t99xxx167733NHv2bFWtWlX169dX06ZNVa9evRLnf4HG32OuoKBAeXl5Wr58ubp166b77rtP8fHx2rlzp44ePSqp/DF3o8cXHBys9evXKzU1VbVr11bVqlW1a9cu9evXr1yxEhcXp+zsbE2cOLHUdtPXlc3fx9hOnTrpiSeeUJs2bdStWzetWbNGzZs397gA069fPz300EO688479cADD+jjjz+WJL333nuSrt3pOXfuXC1btsyn/vnnn3/WBx98UOwipK993eTJkxUbG6u2bdtq3Lhx+p//+R/NmjWrzP1WBIESd+VR2hhbaMyYMTpw4IBWrVp1023wVmb8+PFyuVxKTExUUFCQnnzyyRtuU0Xi7zFXlLd53Z/+9Cf169dPnTp1UnBwsAYNGqSRI0dKkkffUdo6VpJWrFghM1PDhg0VEhKiefPmadiwYR51DBkyRP3791fr1q3129/+Vlu2bFFqaqq7X/RlPQH/jztf+rrDhw/rhRde0J///GclJydr69atysjI8Lh5vKCgQHXr1tXChQsVExOjoUOH6tVXX9U777wjqXzXT3xdT3gbY0tbxxZNGv0aY2yFTGB46/CLBsstt9xSrFx5PjJUqH79+sUyaOfOnSuWaStq/vz5ql69ut544w3dfffduvfee/X+++/rk08+0b59+4od85IlSzR8+HA5nc6b3rc3oaGhio6OVqdOnRQfHy+Hw6H4+Hj3671791Z6errOnTun8+fPa8WKFTp9+rRuu+02j3rOnDmj+++/X7GxsVq4cKHHa0lJSVq7dq0cDoccDod69uwpSQoPD/dYMFdUgRR3q1ev1qhRo7RmzRqvHyd78803NWPGDCUmJuquu+5yb09OTta5c+cUExPj/lvv3r1b8+bNk8PhKPaxNW/S09P19ttva8mSJerZs6fatGmjKVOmqH379po/f75PdQS6QIq5ojp16uRxB15hO6Kjo90D2sMPP+y+W6A8MXflyhU9+uijysjI0Pbt292fvihsY+Gdd97aGRkZKUkedzqHhISoadOmOnnypNc2BZJAiDtv9TocDtWpU8dje25urhISEordoedL3IWHh8vhcBS7M75ly5bueElKSlJ6erpq1qzprkeSHnroIffX5fkSdyWViYiIUHh4eEDEpr/HXVGLFy/WgAEDfPr4fkn9neQ97go5nU5FR0erffv2eu2119SmTRvNnTvXo0xZcztJysnJUd++fRUWFqaNGzcWu5Ns2LBhyszM1OnTp5WVlaWpU6fqP//5T7H5XyDy95iLjIyUw+FQ8+bN3dtatmwpSaX+z3uLOW/Cw8MVFBRU5vHFxMQoJSVFP/zwg86ePautW7cqKyurXLGSlJSkvXv3KiQkRA6HQ9HR0ZKufaXCiBEjJNHXSYE1xha65ZZbdM8995Qam6GhobrzzjvdZT777DOdO3dOjRo1co+f3377rcaNG6cmTZoUe/+6deuUm5tb7CKkdGN9XadOnZSdna3vv//ea5mKIhDirjzKGmMl6Q9/+IM2bdqknTt3KioqyuP4JZXaBl/WFIXCw8PVvHlz9erVSwkJCdq8ebP27t1b7jZVNP4ec0V5m9dVqVJFS5YsUW5urk6cOKGTJ0+qSZMmqlatmscd6qWtYyWpWbNm2r17ty5duqTvvvvO/RVUpfU/kZGRaty4sbs/9GU9Af+PO1/6utdee01dunTR+PHjddddd6lPnz5asGCBlixZ4v7UTmRkpJo3b+6RBGvZsqUyMzPdXw3q6/UTX9YTkvcxtrR17KlTp7yeixsZYytkAqNVq1a6evWqx2CWlZWl1NRU98Q+IiJCmZmZHoGZkpJS7n3FxsZq+/btHtsSExM9PjJzvdzc3GJ3IxX+fv13fO3evVvHjh0rlsW60X37ysw8Po5WKDw8XDVr1lRSUpLOnTungQMHul87ffq07rvvPrVr105Lly4t9oyL9evX61//+pdSUlKUkpKixYsXS7o2+Xz++edv+pj/fwuUuFu1apVGjhypDz74wON79IqaNWuWpk2bpq1btxb7iH/Pnj118OBB9985JSVF7du31+OPP66UlBSf78TLzc2VpGJxFBQUFFDfN3szAiXmrudyudwDnTdF+yhfY64weZGWlqYdO3YUW0THxMQoODjYo51nz57VoUOH3O2MiYlRSEiI++7WwnpPnDjh8YyiQBYIceet3vbt2xe7gLtmzRrl5eUV+/SgL3HndDp1zz33eMSLJKWmprrjZcKECTpw4IBHPZI0Z84cLV26VJJvcdelSxdJ8ihz4cIFnT9/PiBi09/jrlBGRoZ27txZ4rytJN76O29x5423eVtpZbKzs9W7d285nU5t2rSp1Duw6tWrp7CwMK1evVqVK1f2+Aq/QOXvMdelSxddvXpV6enp7m2pqamSVOr/vC9jbFFOp1MxMTHFjm/79u0lHl+NGjUUERGhtLQ07d+/v1xfZTFv3jyPtcLmzZslXbuxpvBrD+jrAmuMLWRmSklJKTU28/LydOTIEXeZ4cOHFxs/GzRooPHjx2vbtm3F3h8fH6+BAwcqIiLC6z7K09e5XC5VrlzZ/Sy1iiwQ4q48ShtjzUxjxozRhg0blJSUVOwi8m233ab69et7tOHy5cvavXu3x3qhrDVFSQrPbVnjeSDw95gr5Mu8Ljg4WFFRUQoKClJCQoIGDBhQ6vNevc3ZQkNDFRkZqYsXL2rbtm2ljp9ZWVn67rvv3P2hL+sJ+H/c+dLX5ebmlniNTPrfPqRLly46duyYR/+YmpqqyMhIOZ3Om7pm5y1+vY2xpa1jb731Vq/7uaEx1qdHfZeg6NPE/1+4/onpgwYNslatWtlnn31mKSkp1rdvX4uOjnY/hf3w4cNWqVIlmzlzph07dszefvttq1WrlseT5fft22ctWrSwU6dOed3v559/bkFBQTZz5kw7cuSIzZw50xwOh+3du9ddJi4uznr06OH+/ZNPPrFKlSrZX/7yF0tNTbXk5GTr06ePNW7c2HJzcz3qf+KJJ6xjx443vO+cnBxzuVzmcrlMkv3tb38zl8tl3377rZmZXbp0ySZOnGhffPGFnThxwpKTk23UqFEWEhJihw4dctezZMkS++KLL+zYsWO2YsUKq127to0dO9b9+unTpy06Otp69Ohhp06dsrNnz7p/vNm5c6dJsosXL3ot4+8CLe4++OADczgcNn/+fI+/4Q8//OCu5/XXXzen02nr1q3zKJOTk+PzeTIzy8rKMpfLZR9//LFJsoSEBHO5XO6YuXz5skVHR1u3bt1s3759duzYMXvzzTetUqVK9vHHH3v/owS4QIu5OXPm2MaNGy01NdUOHTpkEyZMMEm2fv16dz0zZsywxMRES09PtyNHjtjs2bPN4XDYokWLfD5PV65csYEDB1pUVJSlpKR4xG5eXp673OjRoy0qKsp27NhhX3/9tfXo0cPatGljV69edZd58cUXrWHDhrZt2zb75ptvbNSoUVa3bl27cOGC1+Op6AIt7o4fP25Vq1a1l19+2Q4fPmzx8fEWHBxs69atK3YMXbt2tSFDhtzQeTIz27BhgwUHB9vChQstLS3N4uLiLCgoyD777DOv9UiyjRs3emzzJe4GDRpkd9xxh33++ed28OBBGzBggLVq1cr9d6loKlLcFZo8ebI1aNDAo88o5Et/V6i0uJs4caJ9+umnlpGRYQcOHLBJkybZLbfcYomJiWbm29wuOzvbOnbsaHfeeacdO3bMo08seuxxcXGWnJxsR48etbffftuqVKlic+fO9XruKrqKFHP5+fnWrl07u/fee+3rr7+2/fv3W8eOHa1Xr17uMr7EXF5ennutEBkZaX/84x/N5XJZWlqau0xCQoIFBwdbfHy8HT582F566SULDQ21EydOuMusWbPGdu7caenp6fbhhx9a48aNbfDgwR7tPHv2rLlcLlu0aJFJsk8//dRcLpdlZWWVeF4yMjJMkrlcLo/t9HUVf4ydOnWqbd261dLT083lctnvf/97czgctm/fPneZcePG2a5du+z48eO2d+9eGzBggFWrVs0j7q7XuHFjmzNnTrHtaWlpVqlSJduyZUuJ7yurr9u0aZMtXLjQDh48aMeOHbNFixZZ9erV7YUXXvB6LP4u0OLOzNx9WUxMjA0bNsxcLpf9+9//LnYMpY2xzz33nNWoUcN27drlMTYW3c/MmTOtRo0atmHDBjt48KA99thjFhkZadnZ2e4yZa0p9u3bZ3FxceZyuezEiROWlJRkXbt2tWbNmtkvv/zi9fxVZBUp5gqVNq87evSorVixwlJTU23fvn02ZMgQq127tmVkZLjL+LKO3bp1q23ZssWOHz9uiYmJ1qZNG+vQoYP7POTk5Ni4ceNsz549lpGRYTt37rTY2Fhr2LChR8xdr6T1xH+jihR3vvR1S5cuNYfDYQsWLLD09HT75z//ae3bt7cOHTq46zl58qSFhYXZmDFj7OjRo/bRRx9Z3bp17a9//avP58nXa8VmZY+x3taxJ06ccF8L/DXG2AqbwLhw4YINHz7catSoYVWqVLE+ffpYamqqx3veeecdu/XWWy00NNSefPJJmz59ukdQFl5gL9oBlWTt2rXWokULCw4Otttvv73YQnTKlCke9ZqZrVq1yu6++24LDQ21iIgIGzhwoB05csSjzA8//GBVqlSxhQsX3vC+C9tw/c+IESPMzOznn3+2Bx980Bo0aGBOp9MiIyNt4MCB9uWXX3rU88orr1i9evUsODjYfvOb39js2bOtoKDA/frSpUtL3E9pObBATGBU9Ljr3r17qfFidm1hUFKZKVOm+HyezLzHTNF6UlNTbfDgwVa3bl2rWrWq3XXXXbZ8+fJSz0ugC7SYe/31161Zs2ZWuXJlq1WrlnXt2rVYgurVV1+16Ohod5nY2FhLSEgo13kqvAhS0s/OnTvd5X7++WcbM2aM1a5d26pUqWIDBgywkydPetR9+fJlGzdunNWtW9eqVatmDzzwQLFBPNAEWtyZme3atcvuvvtuczqd1qRJE3vnnXeK7fvo0aMmyX1huCwl9XVmZvHx8e4YbtOmjX344Yel1lPSgsOXuPvxxx/tqaeespo1a1rt2rXtwQcfLBa/FUlFi7v8/HyLioqySZMmlVinL/2dWdlx99RTT1njxo3N6XRaRESE9ezZ06OsL3M7b/PD68/N8OHDrXbt2uZ0Ov8rxuCKFnOnT5+2wYMHW1hYmNWrV89GjhzpkQzwJea8jY/du3f3KDd//nx33LVr1852797t8frcuXMtKirKgoODrVGjRjZ58mSPGwQK21DSvpYuXVriOfGWwKCvq/hj7EsvvWSNGjVy92O9e/e2PXv2eJQZMmSIRUZGWnBwsDVo0MAGDx5c4sXoorwlMCZOnGhRUVGWn59f4vvK6uu2bNlibdu2tbCwMKtataq1bt3a3nrrLbty5Uqpx+PPAjHuSupfrq+nrDHW29hYtJ8qKCiwKVOmWP369S0kJMTuvfdeO3jwoEc9Za0pDhw4YPfff7/Vrl3bQkJCrEmTJjZ69OhSL4hWdBUt5sqa1x0+fNjatm1rVapUserVq9ugQYPsm2++8Sjjyzp29erV1rRpU3M6nVa/fn17/vnnPW4gzc3Ntd69e1tERIR7jB0xYkSZ4x4JjGsqWtz50tfNmzfPWrVqZVWqVLHIyEh7/PHHi/Ude/bssY4dO1pISIg1bdrUpk+fXmIiztt58vVasVnZY6y3dWxh3mD9+vW/yhhbyezGniCUnZ3tfthz0e8YBwAAAAAAAAAA/31+7bxBhXwGBgAAAAAAAAAACGwkMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA7zhu9I1mJknKzs7+1Q4GAAAAAAAAAABUTIX5gsL8wc264QRGTk6OJOnWW2/9VQ4EAAAAAAAAAABUfDk5OapRo8ZN11PJbjAVUlBQoDNnzqhatWqqVKnSTR8IAAAAAAAAAACouMxMOTk5atCggW655eafYHHDCQwAAAAAAAAAAID/W3iINwAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3SGAAAAAAAAAAAAC/QwIDAAAAAAAAAAD4HRIYAAAAAAAAAADA75DAAAAAAAAAAAAAfocEBgAAAAAAAAAA8DskMAAAAAAAAAAAgN8hgQEAAAAAAAAAAPwOCQwAAAAAAAAAAOB3/g9Ut+GszTHxaAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 2000x400 with 11 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "predictions = model.predict(validation_digits, batch_size=64)\n",
    "predicted_labels = np.argmax(predictions[0], axis=1)\n",
    "\n",
    "predicted_bboxes = predictions[1]\n",
    "\n",
    "iou = intersection_over_union(predicted_bboxes, validation_bboxes)\n",
    "\n",
    "iou_threshold = 0.6\n",
    "\n",
    "print(\"Number of predictions where iou > threshold(%s): %s\" % (iou_threshold, (iou >= iou_threshold).sum()))\n",
    "print(\"Number of predictions where iou < threshold(%s): %s\" % (iou_threshold, (iou < iou_threshold).sum()))\n",
    "\n",
    "\n",
    "display_digits_with_boxes(validation_digits, predicted_labels, validation_labels, predicted_bboxes, validation_bboxes, iou, \"True and Predicted values\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78df236d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9 (tensorflow)",
   "language": "python",
   "name": "tf"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}