t81_558_class_06_3_resnet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "kernelspec": {
      "display_name": "Python 3.9 (tensorflow)",
      "language": "python",
      "name": "tensorflow"
    },
    "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.7"
    },
    "colab": {
      "name": "Copy of t81_558_class_06_3_resnet.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LSIM-PITWYFa"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_3_resnet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YDTXd8-Lmp8Q"
      },
      "source": [
        "# T81-558: Applications of Deep Neural Networks\n",
        "**Module 6: Convolutional Neural Networks (CNN) for Computer Vision**\n",
        "* Instructor: [Jeff Heaton](https://sites.wustl.edu/jeffheaton/), McKelvey School of Engineering, [Washington University in St. Louis](https://engineering.wustl.edu/Programs/Pages/default.aspx)\n",
        "* For more information visit the [class website](https://sites.wustl.edu/jeffheaton/t81-558/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ncNrAEpzmp8S"
      },
      "source": [
        "# Module 6 Material\n",
        "\n",
        "* Part 6.1: Image Processing in Python [[Video]](https://www.youtube.com/watch?v=4Bh3gqHkIgc&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_1_python_images.ipynb)\n",
        "* Part 6.2: Keras Neural Networks for Digits and Fashion MNIST [[Video]](https://www.youtube.com/watch?v=-SA8BmGvWYE&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_2_cnn.ipynb)\n",
        "* **Part 6.3: Implementing a ResNet in Keras** [[Video]](https://www.youtube.com/watch?v=qMFKsMeE6fM&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_3_resnet.ipynb)\n",
        "* Part 6.4: Using Your Own Images with Keras [[Video]](https://www.youtube.com/watch?v=VcFja1fUNSk&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_4_keras_images.ipynb)\n",
        "* Part 6.5: Recognizing Multiple Images with YOLO Darknet [[Video]](https://www.youtube.com/watch?v=oQcAKvBFli8&list=PLjy4p-07OYzulelvJ5KVaT2pDlxivl_BN) [[Notebook]](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class_06_5_yolo.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lux_6KOXMU94"
      },
      "source": [
        "# Google CoLab Instructions\n",
        "\n",
        "The following code ensures that Google CoLab is running the correct version of TensorFlow."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fU9UhAxTmp8S",
        "outputId": "a7dc7035-f775-4c3e-cded-e9cce17207e9"
      },
      "source": [
        "# Detect Colab if present\n",
        "try:\n",
        "    from google.colab import drive\n",
        "    COLAB = True\n",
        "    print(\"Note: using Google CoLab\")\n",
        "    %tensorflow_version 2.x\n",
        "except:\n",
        "    print(\"Note: not using Google CoLab\")\n",
        "    COLAB = False\n",
        "\n",
        "# Nicely formatted time string\n",
        "def hms_string(sec_elapsed):\n",
        "    h = int(sec_elapsed / (60 * 60))\n",
        "    m = int((sec_elapsed % (60 * 60)) / 60)\n",
        "    s = sec_elapsed % 60\n",
        "    return f\"{h}:{m:>02}:{s:>05.2f}\""
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Note: using Google CoLab\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q09yMGGcmp9N"
      },
      "source": [
        "# Part 6.3: Transfer Learning for Computer Vision\n",
        "\n",
        "Many advanced prebuilt neural networks are available for computer vision, and Keras provides direct access to many of these networks. Transfer learning is the technique where you make use of these prebuilt neural networks.  Module 9 takes a deeper look at transfer learning.\n",
        "\n",
        "There are several different levels of transfer learning.\n",
        "\n",
        "* Use a prebuilt neural network in its entirety\n",
        "* Use a prebuilt neural network's structure\n",
        "* Use a prebuilt neural network's weights\n",
        "\n",
        "We will begin by using the MobileNet prebuilt neural network in its entirety. MobileNet will be loaded and allowed to classify simple images. Through this technique, we can already classify 1,000 images without ever having trained the network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jpN-M-BScz5K"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import os\n",
        "import tensorflow.keras\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.layers import Dense,GlobalAveragePooling2D\n",
        "from tensorflow.keras.applications import MobileNet\n",
        "from tensorflow.keras.preprocessing import image\n",
        "from tensorflow.keras.applications.mobilenet import preprocess_input\n",
        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.optimizers import Adam"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vB4Im0gKfF0J"
      },
      "source": [
        "We begin by downloading weights for a MobileNet trained for the imagenet dataset, which will take some time to download the first time you train the network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DUDtlNDxfMBA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c9597ac-9385-4fda-f7cb-de18f82de4a9"
      },
      "source": [
        "model = MobileNet(weights='imagenet',include_top=True)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf.h5\n",
            "17227776/17225924 [==============================] - 0s 0us/step\n",
            "17235968/17225924 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cwuvm2W_fRZy"
      },
      "source": [
        "The loaded network is a Keras neural network.  However, this is a neural network that a third party engineered on advanced hardware. Merely looking at the structure of an advanced state-of-the-art neural network can be educational."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YF5ZFnrqfXA5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7747c94b-0dc2-4dc0-a1bc-60313059a6de"
      },
      "source": [
        "model.summary()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"mobilenet_1.00_224\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " input_1 (InputLayer)        [(None, 224, 224, 3)]     0         \n",
            "                                                                 \n",
            " conv1 (Conv2D)              (None, 112, 112, 32)      864       \n",
            "                                                                 \n",
            " conv1_bn (BatchNormalizatio  (None, 112, 112, 32)     128       \n",
            " n)                                                              \n",
            "                                                                 \n",
            " conv1_relu (ReLU)           (None, 112, 112, 32)      0         \n",
            "                                                                 \n",
            " conv_dw_1 (DepthwiseConv2D)  (None, 112, 112, 32)     288       \n",
            "                                                                 \n",
            " conv_dw_1_bn (BatchNormaliz  (None, 112, 112, 32)     128       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_1_relu (ReLU)       (None, 112, 112, 32)      0         \n",
            "                                                                 \n",
            " conv_pw_1 (Conv2D)          (None, 112, 112, 64)      2048      \n",
            "                                                                 \n",
            " conv_pw_1_bn (BatchNormaliz  (None, 112, 112, 64)     256       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_1_relu (ReLU)       (None, 112, 112, 64)      0         \n",
            "                                                                 \n",
            " conv_pad_2 (ZeroPadding2D)  (None, 113, 113, 64)      0         \n",
            "                                                                 \n",
            " conv_dw_2 (DepthwiseConv2D)  (None, 56, 56, 64)       576       \n",
            "                                                                 \n",
            " conv_dw_2_bn (BatchNormaliz  (None, 56, 56, 64)       256       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_2_relu (ReLU)       (None, 56, 56, 64)        0         \n",
            "                                                                 \n",
            " conv_pw_2 (Conv2D)          (None, 56, 56, 128)       8192      \n",
            "                                                                 \n",
            " conv_pw_2_bn (BatchNormaliz  (None, 56, 56, 128)      512       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_2_relu (ReLU)       (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " conv_dw_3 (DepthwiseConv2D)  (None, 56, 56, 128)      1152      \n",
            "                                                                 \n",
            " conv_dw_3_bn (BatchNormaliz  (None, 56, 56, 128)      512       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_3_relu (ReLU)       (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " conv_pw_3 (Conv2D)          (None, 56, 56, 128)       16384     \n",
            "                                                                 \n",
            " conv_pw_3_bn (BatchNormaliz  (None, 56, 56, 128)      512       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_3_relu (ReLU)       (None, 56, 56, 128)       0         \n",
            "                                                                 \n",
            " conv_pad_4 (ZeroPadding2D)  (None, 57, 57, 128)       0         \n",
            "                                                                 \n",
            " conv_dw_4 (DepthwiseConv2D)  (None, 28, 28, 128)      1152      \n",
            "                                                                 \n",
            " conv_dw_4_bn (BatchNormaliz  (None, 28, 28, 128)      512       \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_4_relu (ReLU)       (None, 28, 28, 128)       0         \n",
            "                                                                 \n",
            " conv_pw_4 (Conv2D)          (None, 28, 28, 256)       32768     \n",
            "                                                                 \n",
            " conv_pw_4_bn (BatchNormaliz  (None, 28, 28, 256)      1024      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_4_relu (ReLU)       (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " conv_dw_5 (DepthwiseConv2D)  (None, 28, 28, 256)      2304      \n",
            "                                                                 \n",
            " conv_dw_5_bn (BatchNormaliz  (None, 28, 28, 256)      1024      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_5_relu (ReLU)       (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " conv_pw_5 (Conv2D)          (None, 28, 28, 256)       65536     \n",
            "                                                                 \n",
            " conv_pw_5_bn (BatchNormaliz  (None, 28, 28, 256)      1024      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_5_relu (ReLU)       (None, 28, 28, 256)       0         \n",
            "                                                                 \n",
            " conv_pad_6 (ZeroPadding2D)  (None, 29, 29, 256)       0         \n",
            "                                                                 \n",
            " conv_dw_6 (DepthwiseConv2D)  (None, 14, 14, 256)      2304      \n",
            "                                                                 \n",
            " conv_dw_6_bn (BatchNormaliz  (None, 14, 14, 256)      1024      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_6_relu (ReLU)       (None, 14, 14, 256)       0         \n",
            "                                                                 \n",
            " conv_pw_6 (Conv2D)          (None, 14, 14, 512)       131072    \n",
            "                                                                 \n",
            " conv_pw_6_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_6_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_dw_7 (DepthwiseConv2D)  (None, 14, 14, 512)      4608      \n",
            "                                                                 \n",
            " conv_dw_7_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_7_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pw_7 (Conv2D)          (None, 14, 14, 512)       262144    \n",
            "                                                                 \n",
            " conv_pw_7_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_7_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_dw_8 (DepthwiseConv2D)  (None, 14, 14, 512)      4608      \n",
            "                                                                 \n",
            " conv_dw_8_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_8_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pw_8 (Conv2D)          (None, 14, 14, 512)       262144    \n",
            "                                                                 \n",
            " conv_pw_8_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_8_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_dw_9 (DepthwiseConv2D)  (None, 14, 14, 512)      4608      \n",
            "                                                                 \n",
            " conv_dw_9_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_dw_9_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pw_9 (Conv2D)          (None, 14, 14, 512)       262144    \n",
            "                                                                 \n",
            " conv_pw_9_bn (BatchNormaliz  (None, 14, 14, 512)      2048      \n",
            " ation)                                                          \n",
            "                                                                 \n",
            " conv_pw_9_relu (ReLU)       (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_dw_10 (DepthwiseConv2D  (None, 14, 14, 512)      4608      \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv_dw_10_bn (BatchNormali  (None, 14, 14, 512)      2048      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_dw_10_relu (ReLU)      (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pw_10 (Conv2D)         (None, 14, 14, 512)       262144    \n",
            "                                                                 \n",
            " conv_pw_10_bn (BatchNormali  (None, 14, 14, 512)      2048      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_pw_10_relu (ReLU)      (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_dw_11 (DepthwiseConv2D  (None, 14, 14, 512)      4608      \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv_dw_11_bn (BatchNormali  (None, 14, 14, 512)      2048      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_dw_11_relu (ReLU)      (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pw_11 (Conv2D)         (None, 14, 14, 512)       262144    \n",
            "                                                                 \n",
            " conv_pw_11_bn (BatchNormali  (None, 14, 14, 512)      2048      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_pw_11_relu (ReLU)      (None, 14, 14, 512)       0         \n",
            "                                                                 \n",
            " conv_pad_12 (ZeroPadding2D)  (None, 15, 15, 512)      0         \n",
            "                                                                 \n",
            " conv_dw_12 (DepthwiseConv2D  (None, 7, 7, 512)        4608      \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv_dw_12_bn (BatchNormali  (None, 7, 7, 512)        2048      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_dw_12_relu (ReLU)      (None, 7, 7, 512)         0         \n",
            "                                                                 \n",
            " conv_pw_12 (Conv2D)         (None, 7, 7, 1024)        524288    \n",
            "                                                                 \n",
            " conv_pw_12_bn (BatchNormali  (None, 7, 7, 1024)       4096      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_pw_12_relu (ReLU)      (None, 7, 7, 1024)        0         \n",
            "                                                                 \n",
            " conv_dw_13 (DepthwiseConv2D  (None, 7, 7, 1024)       9216      \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv_dw_13_bn (BatchNormali  (None, 7, 7, 1024)       4096      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_dw_13_relu (ReLU)      (None, 7, 7, 1024)        0         \n",
            "                                                                 \n",
            " conv_pw_13 (Conv2D)         (None, 7, 7, 1024)        1048576   \n",
            "                                                                 \n",
            " conv_pw_13_bn (BatchNormali  (None, 7, 7, 1024)       4096      \n",
            " zation)                                                         \n",
            "                                                                 \n",
            " conv_pw_13_relu (ReLU)      (None, 7, 7, 1024)        0         \n",
            "                                                                 \n",
            " global_average_pooling2d (G  (None, 1, 1, 1024)       0         \n",
            " lobalAveragePooling2D)                                          \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 1, 1, 1024)        0         \n",
            "                                                                 \n",
            " conv_preds (Conv2D)         (None, 1, 1, 1000)        1025000   \n",
            "                                                                 \n",
            " reshape_2 (Reshape)         (None, 1000)              0         \n",
            "                                                                 \n",
            " predictions (Activation)    (None, 1000)              0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4,253,864\n",
            "Trainable params: 4,231,976\n",
            "Non-trainable params: 21,888\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zcdKUTOAfbw0"
      },
      "source": [
        "Just examining the above structure, several clues to neural network architecture become evident.\n",
        "\n",
        "We will now use the MobileNet to classify several image URL's below.  You can add additional URL's of your own to see how well the MobileNet can classify."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDX_FwNDfvlX"
      },
      "source": [
        "%matplotlib inline\n",
        "from PIL import Image, ImageFile\n",
        "from matplotlib.pyplot import imshow\n",
        "import requests\n",
        "import numpy as np\n",
        "from io import BytesIO\n",
        "from IPython.display import display, HTML\n",
        "from tensorflow.keras.applications.mobilenet import decode_predictions\n",
        "\n",
        "IMAGE_WIDTH = 224\n",
        "IMAGE_HEIGHT = 224\n",
        "IMAGE_CHANNELS = 3\n",
        "\n",
        "ROOT = \"https://data.heatonresearch.com/data/t81-558/images/\"\n",
        "\n",
        "def make_square(img):\n",
        "    cols,rows = img.size\n",
        "    \n",
        "    if rows>cols:\n",
        "        pad = (rows-cols)/2\n",
        "        img = img.crop((pad,0,cols,cols))\n",
        "    else:\n",
        "        pad = (cols-rows)/2\n",
        "        img = img.crop((0,pad,rows,rows))\n",
        "    \n",
        "    return img\n",
        "        \n",
        "\n",
        "def classify_image(url):\n",
        "  x = []\n",
        "  ImageFile.LOAD_TRUNCATED_IMAGES = False\n",
        "  response = requests.get(url)\n",
        "  img = Image.open(BytesIO(response.content))\n",
        "  img.load()\n",
        "  img = img.resize((IMAGE_WIDTH,IMAGE_HEIGHT),Image.ANTIALIAS)\n",
        "\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "  x = preprocess_input(x)\n",
        "  x = x[:,:,:,:3] # maybe an alpha channel\n",
        "  pred = model.predict(x)\n",
        "\n",
        "  display(img)\n",
        "  print(np.argmax(pred,axis=1))\n",
        "\n",
        "  lst = decode_predictions(pred, top=5)\n",
        "  for itm in lst[0]:\n",
        "      print(itm)\n"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GP6UnmqcjAAo"
      },
      "source": [
        "We can now classify an example image.  You can specify the URL of any image you wish to classify."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 406
        },
        "id": "FwfnWNXSo7Vk",
        "outputId": "f286ab26-7c13-489f-ccf4-c9c0c60b19c1"
      },
      "source": [
        "classify_image(ROOT+\"soccer_ball.jpg\")"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=224x224 at 0x7F1FAA09A450>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[805]\n",
            "Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/imagenet_class_index.json\n",
            "40960/35363 [==================================] - 0s 0us/step\n",
            "49152/35363 [=========================================] - 0s 0us/step\n",
            "('n04254680', 'soccer_ball', 0.9999938)\n",
            "('n03530642', 'honeycomb', 3.862412e-06)\n",
            "('n03255030', 'dumbbell', 4.442458e-07)\n",
            "('n02782093', 'balloon', 3.7038987e-07)\n",
            "('n04548280', 'wall_clock', 3.143911e-07)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 241
        },
        "id": "70FicXOvo0l0",
        "outputId": "dd9fa1a5-5b7f-4997-c9a6-7bdedf28b6a7"
      },
      "source": [
        "classify_image(ROOT+\"race_truck.jpg\")"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOAAAADgCAIAAACVT/22AAAAIGVYSWZNTQAqAAAACAABh2kABAAAAAEAAAAaAAAAAAAAAAAAAHNQMpcAAQAASURBVHicbP1prG1Zch6IfRGx1t7nnDu8KV/my7FyqMysKavIYpGsiaNEqdUyPEhNWe52Q4IhGA0JbgMCDLjdMOAfBmw07IbdaMsNy1NbpqVutUhKolTNQRTJojiIVSSrWHNW5Ty8+d3pnLP3XmtF+Eestc95Rd0ikvfed+45e68dK+KLL76IRf/ZP/oDMwNARP4NADYQUSGACADMmMjM5hcAYBAAEKvV71QVMCLafyv/MjNmLqoAiGAGIiKCqhHgn66qzKyq9e1BRJg/lJmLGgxCDC0AjMzYAIYCVK9fVYmZAdNCIEW9OL8GgAGISCnlT1+emZkazIgITGr1e782tOucL4moXjtA/ib+e7OHFkFVReThu/M/h6oRAcZm6u+mavVtFSBSGMyIuZiZGZOR3wiRqhGLAaQKAwhGVFT9G1MVAzHPD8IvT0Rs91XviIqCCEzmS+FrZlwMCiOGWqn3Dm0rCYD8c6FEILOCaixKRKZGADEX1bpo82K1Z+3PC83KVNXXbe95Icy/8mVl5lKKMVmzDiZiZitKRNUS6/uZv037rRGBiKv5+vNuj8rfP9Q7APm9GRjQelfmt+EvJoKZAmAmf2ZmykQsYqpgMjNwuxXeGY1/br1Emm0I7Rpob1F2Fzb/l5nhP7rR7b2AmefvRcQXdN9S58/6vu/9kvas2V/gywUALOwXBoC4eQoBwbjtIKnGwG6gBkN76gRiJm2Pz01AATaAyJ/6/v3O35tVq/Vb03m7EmBQgsGIDAATqQEwYYbBdpsRBFIoMcN2VlT/gZmI3JERs8H8oft1zqvqD3f37HYbAADC/j/40jCz+RoRCREZ4NuaYCDMj6RaqbYLYIUxEchmA6h33nZGoWqvRdU/iIih1RCJ3MHUZZ89YrMMd89sZEpWvVb1Xjsz2j0MdxUw369m5ptn33Tq89h3eG2f7G+t+TXud/169p+0v+T7rHO3TZqVEBGzb3yq1sj4vg0wbx7szJlgRgR3/+33BKn7jZnYCGRG4PpyCOoD2r9aPOyl5ntkoPiFAMzkYdF2KwwzE18aNbhn8Hdo7nwOF0QEuKN5aIlUDWbMrHvx5/vC7PwU9n1BePit2/r65wBkgDs5IpgxgO+35gCGNV9iMFPbD3m7tWAiAaAgIgJ7pIexzPvR4BZcPQtUYR6jzdw1qyXzqyeCgRRE7B/M/NCNVH+M3fe7hwvjvdi3f+O7V1l1UfW5oT4G3/FuqdQ+yfb/rF4DE+1/BO+Z+vzfZr5oPwBGO1cKGBkIZP4CM8O8NnD/t2eyII8PZgyy+a8qSEP9URhAUWVmapBDye/XV9gYKM1NGIxg7qYIMKb2nOF2qg1B+EtmtwoiI/Vn5w/TXfP3WaQHg+/7ZXtHwD3o/pfjJDdRMlMYgYi5mBJA7iHbmxIR6pUTCI603LbJeP+TSdhUIzGsbmIoqntzvMM8ux5/NzOz6nEr0gBBtYUbq2imefT9WyDTtrE99gHu42eDYyaz2bGxapkRjsdQX+KKWwlq9RGqGe1FMQCmu03IzHsAwdrVYQYO7QXY953Nhsx3gGoB6gIYiB5+gG6XRMQefcltQNu7uGG7SbF7C3i4U6svRtvMNdqS+TowoQYaUtU9MOLrDEIxMAi+97QY2LceaSnETKiwAUZGIDaYwzgjItk9aIBgnrv4arTgYO3Lr9pAgfmhKOYho5o8c7srC0TwFXHc0EzCzKDtvnZ3BIYBtneragRVY2E2UVO/McD9pszPya+v1GgsMEAhRFArZExsilANAACMHRHRPmgEq5k4imdiNZ29aotL1kLKDvj6wqkZCAyYaouTEAKAQlzMBLugozBmFiM1nZeEyC9OAWKeAYMvXnCzd5P1qxVwM3drrsgI7C/QvTDtFqBKAKQaPcwMPKN24xZPCVK3iBnY4Sugxr4nTQ1K1N4FYKsQztot+DJzc+YG4XZzWU3cGZuyiOfGbc+CxYpZNpIKqkEVokFN60Nn3zZ1k8/RYOdHALM9D7rDYdU1MgGe9FUg2LaPmRI3X2cEGOmcP9W3UtiMld0ZMMEEBUpMZu4+Pch7llDxs99ksN2mcXSl5K4LBlMCs6iZwhpKpgZbldiXcwZz5lkKM9xr+lvP4NWz0Gq/1ZTdFzUH2IzY4RqDQQYPI+50tUIAzEuOXb748I8PZfGYN/m84eqFMNVcpPrS/XfyKDdj3Ic/peKQompUmLmmmFCPy8TS1pX3E1kAustQH/pxvi5mJqspGjW/xkRQY/fSDuINBDDA7gVgBHICwgDWBhFBBDI2h39+GS1bIDNjmHvGlhjtZQZmO7hALddh8tCpJOzby90WtQ+YF0jVPP0GIM4muDkyq6rfeX0gBBaPUJXFcAsVd2HuIRzdkKcCYIfF0OpyCAQQzxGAmE13G4aaY4ZZARkLwQhW/8Tmre8v0+bWrLIkZobGshFBCAR1XKOwQDBTMzBXB9SM3t+jrudDO3/vn9sK+2c+BIsJEGa1nSnUkO976+G33X83qymXYzgVcZ9oVCER+9bdz5X9+ZZSHoLmVmHE/pVbBRzE8x3tXY2ZwblAIgDB3009qDYH2UJJ+5MdbJ8fFtWU0AwU9m51t6ebnem8HL6RlHZwnm0mIzyQab2r+or65AnQBhjF06yGuOsi8S659oTAzNT2KDFfcUBh3B5XZWrdHdb38pXz6zdiatmIUQVRDSzCAYazP/MOVphxaGhRZwDiFAmqI51pNY99hIofqJEo7VNmS20oov7RjFAfdoDWIgCYnX/Q+XHN8c+ROmaHUv+MzSrX0Z4aKchmGNvgJgHuSnd5yF5e6NzZ7qs+kBYVUXeSmXrqRuTAjbOpMhFBtSE3IjNVgoBJqql4xNk9hZYtVutpVAY11llJjCxQtXdjhmqLx34pDdTRHLWF3ZPPSalvsYceA83IDQC5TVtl8Jr1z0klkQEiztk2VFDdq2dLuwtwGp3bXqIK0MkYWtw1elz2PIhMZyiiBGJfKPeRNi8/6uXAzBe24vaaCLdo9H25Sn1maiazmTKbKYFmJ1HTV4MnICAyJao2OtsvAOdAfJNTdb3WcufqTup6mRpMq38xc6bRHxwRlaKoVug3UcHxjGYwVy7mEOgQaUeXzsGEm/swYlJtpLUvMsizHCdNubqk5uOIyIhMPRkyYq7MFeZoPidD9pBrROOWKwYIVLe+fykRE1E2GIxFvLbALXTNVjk7bfbYW1fT6gpQ3fdazZG4ubFqx40NcLufs7Y58ldg7ugepKrWalT+ygobuHI0zMAOaVilVWeG3L0VwdSIa6WJtKUETGq7BAoVABE7ydZwGNHej4CZak04dmmWx/qaGrpTMQMxMaOoV2Go5t1GROYvaDDDKjJSj691za15W88cGAzWmsCZiPPxFZhUckCdfCDAAtcXu9dmQGcqyMBmTJQr/Tl/tZzBDFAlrRDaDbI+GTNSh8qOONUsCJs66CUCCRFAygDICGSkqqa7jT4/IzeJaj6mUh8cwxDmQFN5GSIA4gnFbos77OXdNrSa4pDvpl0CO4OYamtutrus/6Fa6A5w7H/jrwNAzKjUx/eFS5oJfFYjAxErGTGXUqr16y4OzlcoUt2871HH+wwOzPPKefrtjOxu55oRg5Rq1umwl60Q2Dcwk6mJiKoZzEs7vkvUFFrjdWFS33RqXs01MzYIsZqFEKxSSExe9mSevbjfp5c1ScRdYK6/fmh9qsfei6R1YztF126rIhIYbL9O1p4LYPM6N3RN8yvM/NH7w+W2l4yYW65eOHjwh4FhRMZkeY/v27fU2dJmpOE3HhQgAru9ekg0Ypg28gZtezVwDQCNMoPzmO3TDKTVcAEjo7pXd45zB72IHOhVr+s+wuYoX60cO9OntotABBEmopZvmZk5FVDJqx2jTV6HqZGHSdXqjVT2nGuJXI2F1UUA7VFREwNUZ+zMiztgAARx9+y5NhsAYQ9JyuxsYPMejhbJCSAnDUlVnbEzqGpxKxGu27jCE6uhiAUKcMXADYL+aeDRoLv+qZIYNWNy7hkt4zLM3EWtKhOBjIQozTGDwIAjiEbm1CoCNSQGYE5l/Bp3UA81iPEcb/euzUzRKN+dDwRACMTkyIYqjq6YyHc/rBFX2JW+dzt1Nv+GcLUUtHjll9kuwq24whQ3/WpBtg/YrFUKdkBp3mFE80dVtkyYCkHRcCc8rgIEdtfVsnRyNPZvuHjzyqxX+ZnIscgMCWaFR/0NGVc86FQDWvJuXiDwW/AbLdCKTUu9dDZiIvJqhRATzQWWEKNq2eWkro8phVr5ysx4Rhw1BDub2OysPvIK+6zF0IacapVSd9ENIGJm0YdW1W/WC3Sex4PAnn8yzRQANdjQPHFd0PqxpijZKUUQ+fX4jm2Rs31TWZVmGDVvs8CihsDwzV1rD+S1f3Lb0uqIdn+GFp+t6m2I1R2MM1geelpw2Scjdi6w2kXLgRqh5wndXOel9ihqyMZuy83foZJfao6V601Xw294HQ+93inyRuk1CyNimhkdVROqGQ/5ahsIKLWaV8F3e06NJfXnZBVU+qL6JbE0iIlmK/5RVSTmyS8I7PIlZpix2zwITGRknjK7s62Fe9P9AMRzxgqCqdS9MINmAIYqYzBrJYSiShBqvkO9WEq11tI8C0BWrMYJbXo0+J5p2aR6sICaKZmJu2uD1vXnlqD4h8MMjo+ZgqnWIA4igqISoiE01EJVxGBEbFyaKVVWq7muerfMBAjMimqLFDtHZw8/ubo8TWLXkiR4PVF9l8/Rfc9fWnOKzcNSQ0doi+6ZtztJrxi1gLSje3bY2mbqve13AJA5dLctUSsJnuHBDG6vrsDwu9OWAtfbbDnfXrUTQM103H9T/Ws0QVblyJzKbvem2Cthtvu2CryKMdEsmZvvay8136deQP6kDDvD9ZzGnPtry6LVj4GIpD0NMyFWd8e1ulXLdkTEwl7jJYODdnZoYkaAUOUttBY5qRRlUhDlWX03Z8YATFmICMXqs2FQgYIsON4EzKmMBtwYzSHMHkm4PdbKRDmsgnB9zPOncq3f7liSqhvzbcetCL5nx7Ml7a/7bN87sLKH8cnRHcjYiDwp2RVv5pxv/02a10Ate7R4ow1hU/WYzA0Y1oIK1XTQ3weOIM2KFzzaBbf/OgU0F41nDdHDkbTtH2aZkxMmIW6R2p/WLk0kMKjx+Q/vhBYlWrpQjbsVEebfePbr6+KB3Wolr5EpBuagqgIzVTZw2w8MMiJjf3Y1Qvme36F8Ip6jpdsfkRk8/3O1boX4bVHNDE3P0C7fQHDXGfY8V0sFZmp0R67UD5+/2/dMM56Zd6RjG4WLUp1pcUNo1fz6h2Smxg8Z6P433ydsg++s9pgbeNNKHmGGrO0SaxxqO6fFeswupj1hboyE6/2YGQoCzRewCwXwENHwrhdQm7xm/2W712MOQf7RbbPu/pV3Cehujd3jsu1dNlfMpE5wUrtud21cSw/VNTRw2HyxVWuvzCxBZoqlBTiA1NRUhdg0i4gBWUt9uNy8gMHUxKmPvbwHtezhIcaw27Hs+i8JAZXO3mMSG7vSPEjb4YBR1YNKywp9+faSLxdbuOxjhiPuBz2bwS6+eJ2xfqqp+3gAxLMvbn9MVSzuRNL+Vys013A538NeAN0lTg5IiBQAU9VPzbuz6WN3KWR9mn9qP7jFiBCRVM51LzP1Ny9aFJVso5ZWStUVfP/Wam9Zk3ARMWuPr71wftUuCXMIt5ObgAjEVMouzhCDbS5VuAerFPOexRMqYTnfrNXw2LCjoWE3djLWoy03/TgZk5ILiam4lBNeazCmKtKo7svARqrKQeZPmh3D7Gu8cuvBxEUCzamTaan54o4UMwVbVdTDmvjBGd2GRM1Ian28qHJNIpqdqjIMVLe4X4U1+2iuS1ExWE1crJJTXKxgZo24sdBwYQAVa+IGx9QAKqRp3pcqwWtmQlyTwxZZzGwmYHZlIKsAfw7HZEagCrOqKB2RiYopm1FpSYKZGgsEollr4jHb+r5zbSjFFRPimKSmGwYiKza/pmIc1GoHABIH9LvyI1oOWT9rT8JPmAHMjF7r8qsXXNR5DGrRzVdDaS5ie28GjEigCjJDJgZBVC1KUFVSBddH3Hwtu8s0EJGQFshqNd40WV1wlGkEJ4YUqjomdy9E9eq5FqLMIWltV6FQTDkQGaxoxcKUzTQMwxAk9F0nRE7MogEpR2yVDxf3yL696gYqRQEnTvbCVov3ngW1fK2iqPr8TF2sNe9vakpYX8cwy5grcU2zP2rWYOTpgtZuidlKeM9H1svduW1jegi2+CXx/Prqpfxidybe3CYwKw0rWJppwBnjENzPVn0ZwSlJAC0m0O4b9k1J7b2oFXLnhKMxMGSocuO51QSolUZUL+p6IVDTZVK7OK2bf9f+sXO0viVcQl59jbkGhkEQ0f1lr+R2hdAEjSGeXrz/+Y+v3rtD3zkZlrEvAJsYDFbc/czAg8jYyEv4JKwuCSUhUscGXFN91KSIJSyWi5LyOA7CEmJ0jYXXu6WGfpiZtD1bC/mqbh+qSjPcN2ukFqwCUHMdgxlUa8cHt5TFahGVas5d38MzHo8t1eu2Aq4XJMh8zWZBndMTcxCsrqk9wn3LcxHlXnlgRqJ+f0auWnXqffeGzRgB2b0l4H/QgFxdLBCq/KxgH1O2UKFWUZjBqoatqd/3A/+eV5436vwbL+WaM2tq893uuVWjQDWSWIMNO7ahQuE9tDNbtjmu2N/B1koVWrN/zCIpZqbpYrj7wLZXdegmjirKlosYK6sp4SE+R9WYCao5Kwl7msYEUoVqqW6IQKzKBgvC0i2CFtOSx3Ekpth1TExcbZFm52RtAfbw1kMtL831NsBnswN2HOYE9XzPqLLCXR7a7LSipZ3pmLoCQ+GFITDJjE0BdVpw3uRAy/UNLERzAdovU+vVWk0eMHtMIzL2VlHsXefugrmVr/yK57JqA8S+FSrX4wqsumzwi6jUsr8PZuGKYi7r75tmjQYk7k0boTgHIiNyGc6MUPfSh8qocMuWKtahPUq7rbwztQZU5sEqVVn16sSGJnqtJK9BiLSUcVyfPzh9bfPewY0fzIUECZxJ1Qil+KY2a8+dmaGWrBBDoUhk4GIaKZipWXEhjJdxApMWDf7gmZk5skgqZRxHIe773h2kd83i4X6una+imo3sim4GUCXPPI4DEGH/99lea4yrAaoxPnM+2BCoOwmrtaUWyOqfUPXoLQGZHQ4akV4/gOqPpfnXRhuZVSQGNjLyXHAXCvccDItwk5XVe9daoNvlJzWHM3i7Axgo1TWytfRnj9/10qunw/WDmnl6XG7eoWblTISHKm07Rbk/CWoUHpouwmOWbxlr/YmuUpxN3KAerGY6zO2Va9NGdbdwponBRFo055ymycA3rl/9zIev/+KvfzU+84njoy5ZkIxC1BT7e+TKnLGRadOgGzkwBkyNoHDek4IVAKFm+76oIr1Ijy6nPA2DiIQQuhDcOr9PakqtlMwgNZ0drVWisCFCm0P3DuxrQ13eQ2gzKKTKZTsNa3Phntl737kxDAbjlo85Apipcmrpa2kMpaIW2aRlPERkKDWwNoIelS20GWdaTXbh1WrmnTFaa69pBA0IpM2n1ruqbIIBZjv1Yl1BVPuAg8sWDpwJsWL+7Folt3rjuUTsYZqIYLXuZWYGNWlNpDNfAAOjAfW9ksjOHOdeZ1TkUB2Hk/zOOpmBODCVotM4egVVpO+Xx7ffvPVz/+UXrDtMuPrYxx/ZDERUPAen0mDOnvty+VitA2lxPR+aqoKrNVYfGFoqsJc2AF0XqAs5l2EYmCnGLgRpgbH+qcI8emI2o2a+7gpmX+gwfO663HXYtLjZYEHbXTRHyDlN2ScgdpsEZkJUrOaWgE9AgBmcVq42v4fhiNhql66aQarpm4f82X7ax9UW2/rj/g3a972SqBV/57Ssuv92C/P/m++hvk/tmPF3NM8YPDHag6eupjI19eZd2nOBLVGvl8RVYY29UREtJWo+Yi++25y67ZBABT8VJNTfqG43Y4jSvkKiDJS79+4egJ5+7qWzo6emAmFikAICsgYYHP7CWkibszQDWe303V9M+PYghF2VvBpfvWpijjGIkKqllHKeREIIgVnmogN7y1VT/dueK29aSsc7+wDfGkivkLm2PLqwo7X8teSlUpfzzsDDX0RVSLRDrnjoG7QsT6gF+1pAaQ2JZkykZXdJ3B4OEbxU6YGihd/dDnloEQD41JNdEloXdZ/N3bddNE1+tTM3KaoggaonMS+8ACABK5iDX3Px9BSuXa7TCSrm220DY95/Ls0s2vXMMpTv2/91Heq+sWka/dpiF6OLWurEFALp0dHykXDjyuNP2+LxosmX2oy8c6GZUw25pDMl49NH/H8V+9TnCQOcEEQQblbkH+mXy4ZarUfXhRhFVXPOw7CNMYoIM/sAGVVlVy8SbFcKr+YOqkFcq8ynxl9Hb75AhUBEAU00BKKWiDQAtLP6OV9uDmzWZ+5C55wumClVObk1aFix6zy/wGBiKoGLmTO+DiSMoA1O1MKtQ4+ZfJovxGr1HHWTzIG96rmqW4KBSJUf3q5+ey2JaXSGwVwUqkUblTHj9brRxBPDogRDyxirq3o4plVzqJ+F6snIZd7fF5pqRkeAmmopdcQGKEhgYXhuV6/FmGFMh6v47/z5f/tb9+jmAyyJGF7PDA4ii5bdDvElJ7gYBkVr+0ENFFRRr9UdQqAw7/Vmwl6Va+6kCZ6ZebFYdF0ppUzTAIME/5L97biD/40N9lUXl/No8yF7Fyw0Gw5aOjA/5nZP1u5x139b34qIxHYSw9rwPhMCFcy6rzI1k7kBEJWg8DjINFtmtTxu1FFtlp93RXuQVtetqhOBKi8nOI0Er4O2vUqoGqaH3JipipDpLuC2Z9OsFwQG+y5gqBmLb3jfjxUn0j7Sq1Be2Yu3VPlUJiJQUVfCY04V9vLLWg3POQOmOYOoix0TcinmUwEqaPcxVmCi5aqHjWYHQkREAmRTIp3z7+pRiQgV4RpqUx5qVcfUlEkc/LbVNgBhfh7U0Aa1GDmDlYa6jIlJOK6imaWUhu3Q9R0zBxFrr69LbKjqir3Qzy1vdvtzKFuRH7lImxBmV2nYE38ws6IWEeZNb1U7wyCoKs/RHrPBezKrniCIfZ/edAfj9un9+TfVYZlVj7zHrfrSmtVdv4dwrELPvdufl1toZ4Vwx0Y1z2p/tQNtO9keETx/trKTksBN0J9v2EGItrW1dtY3+2jKN2rt/KZeSwcze2e6mamWNCUAfRdCH1scM3dl7gFhIK8ZmLIxoqhwKl0gJUYopCxMmTS2MjBRlQsaMWqx3XvHc3F9BSuoeRNzJwuFlzrnDV0Tj+Y8tLkTmnG75zowMuoWfb9YpJRSzuM4skiMUZhn4mN+h+YrgblIiwrybO9p7SjVCn0afKmOvQHbOUPyN9V6Q1RFygYzESrViBmYW/yq3GmHufe91N4X1Qiwi32+Lsa7XLI66ep9ebZ7b/2jGgpbplivkDyNmikOnSWzXiSgCki5dXo49moDgXz+QH3VQ86vtmZVDOSQlL3mUHsB2sZzQQmIAAELEwGlFMBKKSnn2HX9aglnd7W2wRBIiGsvntf8FL6ynuM4iAeKX6dwKKgCGq5N5w5JWQmq7kBhnmeb15dmhg0G4zo3R0OLddjFh/a9tIa1Gp/2LAOulmXpuhhDMLOcc54mZTZYFztH32js6fyMZ6gzDwCbSxr74H1nMm7WTsWAZvePPWfmz2x28/5bUqubqcEVVWtigIdM8vvg2p6Z7pvxv+GlFYztdWIRzarcGu4N8Ll81WvwDIdBRMKkWlAFQa0heJaVNAbCy58Vo6Ht7ib58CDZoO38jH1V9vBf9aNmpoGd2M5ajICUEjF1XYx9qCiTYGosDFCVortvw670T2DyFFOz41EQiNUHO6ECjdqGa62hhUAiXLTykv5HpYaj9uxqzYQAnj2ot64+lOd7rJhnWzLVQCDUpOtWK/vMtFgsAKSUcs65FE2pUhEhWPuq2pcaQNttVB+9S1wwu+0qHffSs4Hk+7Lg9iz22ZOKNUJw9AypiM0CE4hL0e+zyIffbWeERLOKoIJIbnY7w3YzYxHa22BzWJdWO3U/NP8VEZhlHj82b4a9RMKZDvgSu5kqmaJ6lbo+Hnod0rV1awtVbYjloVsLwmRkzMM0MnPJhQxdjF1c7PacF+3UUOW/Oq8te+D1G4R5xVlYStHtdlAtPrWEWfzxtelLRkQk4i0MoY5KsrkFU5sExhdEoT7gyGNOIKGiYBKiQlaIvFlKYQqqyaN3eHVWusBGlDVPpZCEFvCLIwsDYpBFJynnYlJynsaUE0uQIKHxlLODpBZJm4U2BRd2l8vN4ELDaqh7uWZQc+JSBd7Nxcx1rxrmiKgUJZina3sjQq1ZOZobbhtnP7779bREaeY22x/XsG6NA/eIXhGYuCNXnr1rU8UX3eXbDzU/oU7/M7hcjATkT2RG4Q1jew9cQ3DejawAVdUnMbumB0BOKU8mgU1VgsRFRzUpbZJ6m/eKcZ1es1dFqTNg/AJAABjEJESqWYnY659C8OlM5DigLawZg0gJquJtq2aoOmhUrGAQYgJZ7aZGYJuIAygQICDAkqkiRIHlYRGk67vNdkhKl2N+8alHQZzJbp9s3rp7nnkFAVuCcdO/aTHlwKTUxYWqllJyzkNOBIgEEeFW9qwPfybqPKjVC2s72mbfQAylWgbbc3feh0owozpZiWiGm2hvZjWPqRKWVmfdfy/sW6r/yX6D7OzU9oNM1aLufbXfN19fNyNgVJshmz+GgjyVbWqvfWGD01G22x4WvAw7I2dqq6hVRlqhjtVmeccYWrTknHN2fiPEGKIsJHqLetWrNJ4RtSHQ30za/If5fm3voRFVX2GBCEULGRkLyWQGMgFlqm85cy71LRoIl6YK8gsXEu/otxbmAYSVYChWYAwhJi1FCGyIOT16tHjy+hFpuXOSS1geSD46kCiUxzEcSRcu3zxNZ2P2TmbVzCAQFzBALpEWFmaOIRpMixYtaZrgfS8s3jq8FzBbdLN5OeyhBarex59P7ZqwXYHeZpMye8iGZ3Pb6Tywi4nzFaA9AaJ57CV2L/tTyNVakuwvnl/pEG7nneEelUFUhzfUO7MWqmkf3O9sdA/21AZrs72LrSkRsQBsWsjA4h0GWc1KQc5ZWJio7/sqhyADtNVCvftUgAxUfX79EHhfpkNMtzP2f1R1RUMzOoCAnBJ5WxIVX+6WT6OhyWbbdfVqePChMrW8XHey1WECrASEx65evnn/fJuLEVPOq467GHkanr5x9dGjruMM4qtHV5LxyZjvbMegU6AiIteP40GU90+mbWbS1PVdVpyPiaRXQKAAqZY6LAcIQQxMfaelpJS1JM2mZhwiM8+Kazc1jzO8N3QYqKVwbxPee5g7K2BuLmt2CQ3LUsXsNNuW2cN2Ybto2579LlGbv9l9YHXDUNieJWKmlZx59c6HZoM7gSYqxbHnZusem5PFh3ZIQ/2NKK0EiG+8RgCXUnIBYZpGkRhIQowiod2f37MZjISYmAjel98U5jb7AKvjAW126/Pni3ApdUiWoZKiXAVlZnVMOJPm2UIr6ILrIs3jRmObjNp4AZfAG5ORazwYQDi0zeVYljGwWW/26JV+1Uk2PjoMSiVLCF0E9P6du2k99rGHCLrVmPM4bsXwyILUIBRiCBPi+6ebB2MiDgoASlIxUx0p69fD1C86t7xSSjakNAFgEZgFCSLS9MtupjsNL1rqh5Y/u9ulnQXNHO7Ohmt/GVWA0J467QWvfVxR/eV+YaxRXvZ9v3EMOPvrJpPlolbIJ6NofUhO91gbyle9rL/H7Fv2/Do9tH3axmiNzBXScSl5nAYQiaHk0oVOJMiyc/RNLf+rZi1cKntbp0FVDWOlsXRO5JjFrFClhPZ2n3e3CqNxVQCEedX3nJnYp1oQGZjI2zjmhW454p7YbwZL9Ql4gwNUjYQVrEAoJR336HuKzFDqe845GdPF9nzZ90aFlM7Xw53bD1YxRgpkdrbeeNVSwQUAFSEiTQF61CFrybAIgiGwbMYpg7MEY7DmmkKYgQQkLLIiS6ueJuuTrZHWlsM4klrXdy13kjr8jLj44Bh/VLVmZ9x6v7QtQlN4mdN57nKg6uq/duBGac9Pdl50p8YkFxlS02hTpf/aZHlVQhXpWbMqbn2cQmi+Ho38cZNkm5WRZlK3iD+kWix4eI5XHezoz1jU51eqmTn3XFWSIkzEC2/O9IzHBzyhnq/QyvT+xkzB52gDalUAQPNIOAbDvAN4nlLglmoOSbz2q6xqEBipdqs+nJoCYjYxGEZC0rC1ms2B3qiFFG6jfwAxVi0EV8R4q7F3wllYj7mPwTQXIxCtx1ENMGU21QItIXZqEmNcj3nMmxjZtKxWyxjCNKU0jAwqi15iyGOC5iVbF+SJa5dXy0XRfL4Zz8Z862Q9Kk8cPTQFaEA6EGUrxRbrkpmJhRehY9ZYNGUtajknqgVMFhEiFam82K4aVAVutb6gqtTyxtph5Wp837H18BJ/8A/5zZm6g7dxVfe5d0oGhKE7drM28LLHNTez3WjtOeza/ObmyinfdY3V10Zmu46ulmF9KrSqCUspGaCiWkoWkZQmAscYD5YrIzCJ8/ilqO3NrKz1mMaVNjqZZpAzv5JaOlhKMbUgAqsGVP2uFyMqiWmA16PY06sI1pzHNDlmEAIYKDAogYnRhitW8/djgvyJYFcMImH2ZpY6FsxgAhCFNClKJrNpGrq+Pzw8nPJ0dnbBhOWyj1GGNK6348Vm0AJDChPFQJICMU/jqONIEomxTdN2Ggh0wNSLdayMgaVcvcSXw+U+dm++d5fZlEgNIsJaBMxWUi4RKExTMINIIaIYgnZMtFg4X5hz9jrHPF5LRFxl7a6nxj+nnwi+Si1cOcyvOeQetpM6fm8mTfbQJng3maFV3sghrrfz1VEge9FrxydUbPaQ1M2jaZU8t8l5wrUF0KpEosBMtSiQpjyOU4wRgIgQUeAQgnRdMDMrPit1tkXD7KL2SLq25XZgRtpu5P2sjgyEIGSKKh9QDVyb5am1VAGWPd2TulpsAMpyuQghqClzMCs8d5VjTkP3wH31EdqSJte8ag39c0tB2/oBlhaLg0vHh+tzHB6sukU/ngylYD1tVfXw6MCAi/X2Yj0QB8AIykxF6WIz5ZS0QMo0nmlOOcawXC76EIPIkPP98wuXPUHGPiyuH/eBiIUlRIXcPdusx6y8WvTlSuxHKyfTxMYwGgjCMG+2par2B0VTI+Kcs3eNlTQ5vmIWIjIiEZnFx1JpNw/bFf/6Q5qrXJ4XSU1Pdn4UgJEodkLFihqpCgkYLU+HzUlSc1fYl4DuSS1JtYi4Ty3MLsiAqnoqoqolZwNERJgXi26x7BtB0VKc1t/DgUsddIo5yMw00GwMLeva2yQN/+1PJyZ/HyYwvFfOiP90klrzwsaLOclghFJKv+j5ot0vuUDEZ+B7BmKNMoaAVI1nYWF1C6RaiJQFVM/oQTAzWLh25WjRdYJydLA002G9iczL1XLM01TKMKYx5e0wKghZYer4OmVVhWtDgXJYlofLRRRBUeppmwbkAUpCggLSnNO944UU6a4dLY4W3ZRzJ/zuA12XdLDQy8QhxqClj1E1vDOuQbENrgfgalHfjyVGNmNyfQOqPD7nknI2s1JKKQVqZBa7ru+6oqVKxkG+dvspCFETXu7IlNnz1oF1rQCmDhFcCMJmZGBDIZobALh6Hb8yfzcFKOesVXVmpZRmT9U4XJnaxQ6xq/roylDabJo1bXcsCwAITEULKADqbGyl3R4y0IcyP7QX+acQUS3+tpZD/4OGnbyD0+Ysh0UIfoYDgaie9gZMKVkxZhEJZHn2liyO/HWG126MLumEtdzQUGWZDaRWtgkgUEhJrWyjkBIPxQLRItLBklOO5+txc7q5WG9zUXZZnNWqccoZaiEiBILpspNlz3naZqNxpKkUZhKjVAYhRkYpGaVYwP2TfALtul6IblxaXKy3aVse4OLq8dGVZSiWi+DaVEZCMpqUIb0ZxFKEZYaaD4yDFRUOMCYos/U9L/qoprDOQKbG0JxSGjYOCY2kFPO0R01FxI/oIxEp6oXlvcrQvHAQHyTRnrBZHRRUTOf8CUQ5Z6J2YoHzOah/5wlMYA/61AX/tmkV3Pp8j6gVc1WXpzPUGN1md0Y7Nk1ViAgKplzPtwCI1IrCCEyleadaTVAAHLyC5UiDXFBi+yODULVkM5PrXtbbR4UILGoGU1IIwGQspAJVJSib9yyhzslRI+LWVuwUca3mmzVOhaC1hluRgzfteqt3uHW6QR46odj3fgDBKMiMYczbYVxv8zRlVbAIgBAEBdSEKlkzlRBYximBwEzM4XS9TaUwSEDLLgpTKaXvO2IRQh+CluL/F0UeuXx07+R83I7bYctC01QQNBL1KIjdqepoqRBnkUJFCxOJj95kGCwLVCVkT41rCzDqEBTuhKVbLmZ35oPUfO+aWTBX+ZK6gMOBamOeDVbMmGb1jbP3td+Zaa8qSCSBYvDurnpwYwgCaocr1LDqPWEyR8xduVWLNZbWyODnRNTx1P6XVURntAO8IPGDcgxEFgD4UgsH0gKSmalsI5vJaWTMRATcXrAPDmYlX+PxGsdh9X/tSomIqN0sow4mBIFdvUrk3TU2FwNFYFpFlb7GLnFtlJM1mq0K19XILGw1aJHNOGFbctFAuHzQx2V3sR23Yylq3hCrBWCkXLyGykxBqCF6WQ95TIWDFJumnAgcCSEGYvI40BPlNFGmPkiMQVUDM1SF0pVLB0PPw2bTh76LAoL04aBTjrwYMBmGKatSELZgYx4KSVYosYKyU8fkR9LW7oU2AqeoKUN8uqQQCFAimbeqVeCZRSpVba2KAhSatXC6Q5PtRE0YrKajKKZeON45APWgzA0CkpnNo6+J6jEJqqWxWjXmCfHeeDeQM4I12PlXMZiZEKBmXRdySXlKy34Bs3EYY+x8y6BNQ68LUpNBH23vE3u88xYsD7elWR2iIZBKaFXuqSnw98pLVNs+fWCTMbGQNgZQG3ldPz0YQGxNMOQf5FtBWtvQDpo4Dw0KylF6Ng5FrUBzmk435VBKiIusU9GKNpDrpxHB9QCBKQiLCLFoyUNSpCwsMDLLFigXrIccQohM23GKLES2HUekHGMkM/IjB1CE0ffdYtHBiInNEDrLJbGlFYejgwC1yGykF6MqhSHZxTSKRIndNE0+i8qKsvopK1pl4WSOfwAydSECoR0ogaarF0Or91Tdkec8XOlNzy1Mc4GPxK9RF66QoHpqkj8xNtVGJ+2+qvcibs2xBTTrc7XKBhgw40rvWjsRs22nmqmxc2VabNXHr371D+/dv/Phl1549Y03Ll+5enBwdO/+yeXrNx678fiUi+Nk4CH1FsnuvCFfDXeKMwNc/TOTqRHXVKYFjXpKqjUlDHOdUTqNYyOHlOu5LVaJ1LLXJVNLtXX2DVpiaq17oQEkZRZ/u8AxciGLxCTBeEjj+WY9PFjnkrNBDUJiZuZzbQlarBNxbsvnK5EVVagRAywkgDFbPQWFzKBGORXpgodKzXmz3a6WC4YpNBdLOXddt92OmvNyuQzEJcf1ehjGFDoEg1q5mDY5WyklBIsklwXE40LyRdCMBVkZUdSnPFpZBO5YxmJDzgapkcNMUYxYWXJRIlIyMxVFdTJopDS7nHTX+uJOQmdapg44rZHQlfB1cRtXT8xW6hg6pnbAyGxqLVHztW20OjVxdq3a10MRWsLkh3CCiKAixMCN69dfeOaZ89vvPfvkjf7g6vHlqxI7LYW4jS4yrh1gTg3XpL4m1zC09vlWQZi79mBEVHxsbo3AzW36MJ82/aARa065EBOcA3AYIO3oHIdD6lMUzDkBr6nO0qXK2RGI1EzYgJAoRXAKQYgioIeLbhUu3r89KSCByLQoqfpsi5yM2vQSZg1d6LQgY7JoQMcKK/XQDBNVEhYoTDUuQhdoKJpTKqpmerFdp1JCCGJxGifmiZmZMEyTqnII6+0mEInZuF4roFrOk6YxHyx01XUhxlTsfDsai9gmWCIK54WVQyBFSayyDBLY1CYz65hgysxDCZsclIKiCJUoykqjoUAIEBSzOpzAbHdAmc9A5VkbRg5Jbc6qCH50YnV54rpGhnsKVH7KXaYfAFddCrkzaflZpccZNcWpzm/XT0KAj3G7GIeP/MAPlpJundvLP/Apy+NJ6u2QQxmNJZN2pSiMDIIKG8xgO3K0Eqd1ii5qlcs5SPMiWXWC7YOtzlxxRJPNDAhg4sSxz2TKgHdA8WjlAPUE+Xp3ao31JG/eqVfCzIpcAx3MWh9sMJAhdCwshGjD+vQQ+u2v/glv7cUXXk7cXWxH4uDhrgCqpVhhgDN57iywLKwFGSUwE4qALl+6vN5uh3Ey9+VGJC7lMdJpOyUiDrEbx5JyGaBUtqWUEGPf90woYymlKOUxZagdShyzFge7mYU7ZlIu2UwhWcM4pJKHPnaxk0AEIVVOVs94zUVzyQyjIEFYWUopBETyboWyYAJDc4Ea7Xwm7YovjRxpuXALhfNUPbVWSq6sjdvVLB71XErakSPOrjc93r4VopqKg+M2j23nsIF6DBcCKfddd/f2u//8n/38v/Uzf/HNP/rOj/7Ah99+/Y3l5cXLH/rQ27fXFiP5AWQ0fwiZoexOiNxlhDTXtIQb2gFczlFp9roVS03WwH5IF4GK5ZR8FpWQEJfqSecjgZrXbR1H/oNhJk2q9rRKtbjBIStKZAGZcmbu44M734VNer4+vzs9+5NP3bx/J+U0pUJgD8RmaigKAYzMvAHDjBSkRqqFxI4vHXkLr6egRV04LkPOEoVEgBRiVLNhmEoxsEBzjEFCBIcx52G7JeFBCdyHwJpDcbEZGwWObMuVLHoWCdOktrXFUZ+mkHKBYRWJAg2Zi08+VlNVhuQ0oOhgOcYIDgIIjEHTNEwZIQZSL+los7Y5/qIN7oO1aqQ/1/npYt+8dibmkL3lv65vrO+wmzAzf1krIphVsc9+EWrHB9dOUnepZbHof/hTn3zsyScPVqF04aVXXjmfzm6dnJTuOAv3uZ5h4IbiliVzdYequhF77eZoxume1VHMfiOtYiakzf2diAA2jSMB7OfXVlqgTm3w9/d6H9WjxhrkmlcaPg3PiNHGQRdjUqLAPHFYEjFtt9evHE5PPj08enRxcbFcLqcHpymbQIpaMTPLDAOZEgkxmLJpTgWuCiALXTTC7QcPhpRNXeFhIqxEmpLWZyw9hzSMAusXgUi2UwEHkjBlzdk2Y1YzUOBIAKU0ppwCh6PVAUXVMo6jddIvgywWoeMx5aFbxM3EgannlPKmUBe6ICWHQGmS7TAIMbEIScfgELJhyDkbKUsCAFGWYkFg3iyrIAa4HnPYMn5PqSsE3HdCMyvjvrEZw57tMageTOPRkrHXn+XmUr+t9uEvmHOLlj2gHgutEMtqh5cuf/wHPzNs7fjoiiFdjKHwKljuQaaF2qATNDuEWR03vttNjmSqKbWpzTAgtsypJfd1D7HHZU+toFALIn3X07YCXSEGMbTN3jETn/9dClrLckugHDHW+3b1SL0QsqBMRgES2HKZpo++9OIV2W4PL5d4bSrnh6vVE49cIQpnJ+elqLEauhj7s7OzGGNRnUou2QgIXKIIgJTt/bsnQykKFk2eiLDwkIrlLEKH/UqCjNNgmpnYO5ayqQFqhTiA2YhysU6yTWUc1RkyZcook5W+65PlTERdl/MILaTZyPrIeRo3Q3Kd4aTTsgt5SuMwwRBiVDISjsLmh8WwGHz6OoyIwVKPjxHAfJxrIWojk5SUBFLYedYatvb6NaqvU5/HustqakbkI5FqcrQ3uGrf6Ta2lACYqpennJ3yAhURAUJkIFVSbz0rhUiQckbsiqlRKGqwJLXa1eDmLttrJ7e0j2TXhdbTDlxBo0CbFeGkmykIPmibedYJurKE0rDNqsQkhUwYbKxcoMFtnVCPvqvHldTOeGpeuvZ9tq1YN6QhBwAWuMSAopoLQnd5FUs3FY1d0DJdO16UVJZXDpgpBOv7g7PzTcy4du3SkMv9883ZesyqZnWw4/mmhBhAEojUTEtR9XPfAoxKIfSUs623W9+627H0fQwiXR9zzlPaGvGw3RJHZQBIOYUQhHi57KNw3uaeuY8cI7bDOqkmBxCiTMRB1LgYUHQVAohNAi/EDMpk0GTlQlWNisKItTm9bGCmUKlBMNAxvKhnjDFnJTaRYrULg6rhzNIhcqrQTHdnADhW9X91DdQ8znJvTLW1/kHdqXdb/KzG0YQ/7s1mGFxn+RigQtmIFSFgUiWFkNTxUw6mrfb91cL+/liA2cs3U6Q2LV91xjbOrFXRwm5cMBGZZgECQyFKhVULk2IKJplV0Ioi2gh/QvaZCdiDFFYJqnmft3GTDCD0tmGwcdhmjAWkiKUM05QjJYVm7wilGEMfITTdePRqv1zo+frSol9ymFIx4klzgTFBQNFAzIMpE7FIpXhFYDqMA4gUtQrSxU6NWLpSNKVcUpEQF10UicO4JablYjmlqaiGEISZxZIOkfuLKRVViV1SIyPOUJuEaLnouijM1IVumvLJkJKETExGoiZkE5kRmThUMVIV8fnKamqRebmMqz4uQliUFLtQgtxfb+5ebCcrCcbmJ7E0DQmM6rAN16JJU97ajsWp49rguTrtOcyKVa0WA6sFzpRks4MZFcyg1/MLIrJ65JNkl3OyeKm0FqWa83Nlu3fHNIqptTG5056H46ENLkWjjzxJknkaq3pFy6MLESP7GGVjAguxFWai4gIaq0OGa0ulI9pd/GCiYg+HoV04qoeYBLOsSso9hw6UfDpRkcAhDGVKSYf1drnoTzYXZw/Onnn62Q3sfFOGwhmg0DFK0UQUpnGwUiJTBjGJMosEdxel5koYSpEQQcQwEZFABKwWHEL3IA1hEUF8sFoQhVQmZgkhKFSzDttt8mdVeLOezIxYOmIFyjgFwmLZHS77vg9s5ejoAAZdLjSOm/PRBZfMyrNPI5hpZBNBxzhehhBDmhLDlhHLzhgjH8RUUpm2V5ZxFQ7OLsaUtARKpmPSUnlTD98k1YgwV+mAyho6o1hP/SLD7pUtnM95dvVle41qmL+dkXBDutaAr4M49cm6EG5lUoeeatIm3aExsdzI8GoKjYNsfKVRm1uMOjPBaoNJ7bl1slYBCFBgiy56b4cL8xjGjDYtyDFandm91+Iyl+jMfISgtpqT61dQh/mEdULnxC9lUJ6MJhKG5EKEYF0QWlHs7t559+tfe/XZ5z52sb4okdEdWFCpj8AkFwm9aeYQamW3WKlTgUQM0zgarD9YiUgpeRG5D1j0crToe7KuF9NeIcV4M5xvx4G89yXnGCIHkOlisViEEAOP42iw5WohLCDSyB0zCVZ9DGIhxj4yCENK0HHJlgxAISrCFsEEKpqEadUHWEJOV1aXieQijRJZLYWuExGKi5M7dzTn1ZJ6wtEC2km3iEq4c7o92yaVrjk6tXbs3L4P8MDqiYA278ez8TXrtDqXAU2h0d6nno2C5ves9s3MSHaH1ry/wYceViLACVfyfGVm3ms113FF9fDkVBKKVVLN94OLZdsA10biNv1srXswmWqJQYJIzol5idZyxAzLhdvs9maXzfd7BRhGqIO0POxUGtmjjwJA6GIf2FR62JTGIhxZGCUG4rXoonAIlI+73/+Xf3Tnq1+79/kfkytXecwKP2Sa4Flbh+7gwNQY3vNkTGQl9zEWVYVN5VABCrHk1BdeddyzHvaxExqKplFT5q7rzFRLCRK5CxI7CQFEUYLmiZlKmSKFxSIycLjoic0sJ6IQe2gyzd1y0S/60HU551SGnnFtEbSYkY05EXtey2YIga1M0ATViymPw6bkvKD+YLUIfR8jbbZpSoVbf0wAD1PKScnouO/YaD3lCQwWI4MWqwxUjd2tWYLMK2mNWSGGT4uuh81RHc/XWuj9+bSOv5k3bNCAm3m77txfSUZa59JWHqod+MHwD2pNdu7vtckDmjeG0Xz6G4S9xFv96Fx8MmuybRiotAkSbGbDuDGdrh0d3x+sGBmxz09ud7PPlLnv3GVE3r48Yxuznfm6pwsxBKKUFbGPh6sF1huOns3ZIocp4Lggbde/8cu/8PjtXDYbvnql9iUUYiNjEmipISEvmFYhBGGjotmWC56STsUolUKcTLvAIUTNkxJnpeFinGCqRcBaSk7TtUuHEpfrUjIMBiYEAgkHEYkIkVG0j2HKoxGyZisaohCVnEeiDtBp2J6t10lLFyOEhu0gHBTe85hi7JRUcyEGsYD45GyT0tTHMI3T0cGSYFZsnCaDFVU1Qyk5Zy1pKqIKQxFQgBXT4iq9WezYHgn26UbM4wt8zDLX5Bl1dArVWE0NkpIPXmwwYAcEqKX7FSk2BSczSWAtNZtBJbekwlm0LJkAPCSw8vd0taxqHRbwsFGSx2oW1qI1CFTxO4OImFar5TQO79566/CR57NVxCDusHft2g3fQBvA9oBBBJQmkPXVa4sJEEIhI9XlMr7z+rfGoKvHXzzJJhEyFDpYcraRp2scfuyVj7z9W199dHlwkpMRK0iIBMJshhINARZIF4KDiBB4ymmiPA4lZS1K4qyCTR4mctaUynqbmCiXcdmv+k5yGsjy0eGRFox5ghormGi1FDNsL86T4KKkLsYLYEpTzhr7RR+ZaPShCNuk59szVfPD3zkSMY9qZDmrSmBGSWlgFgNBLbIYYRjGUooHlc12iJEZtl6v1+t1YOniIuW8Gbbkcn3jIY1JfWgGWNXc5ezZaMtRDK3Zv8ZyTzia5t+r1tTS/Nk5AtRUIngIizpe+zekFKaa2SIBc+sKt7ykvQPNb+/Mz2ym1JgHbi7fdofeVov18Y5Vz6WFm/iAmdQKEffLwymdbIchxoVSJiJ4wKKZjXCpvH3fpXug56oc8uhhsuNCEEAsnnzl4Z133nz++lNlm77zrW9+4JOvvPrl33/xAy/RIo5d7K9dPT27uH92Eh+5ZKoFxfdByqPmkYwKWYalUaeJu75LSYcxgyMgpZQuRDbtxHJWIoos05Rc88vgzXbUrIsOzDylKU1GpaxiiCwA8rj1g8rGrERBi9MFAhZNuEj5fMgEVtVbJ2POqe+6w2UPHUtZk4RhmLoYojCIspqqBngLHtSslJy0EKBKBh6naRyDWR6mtB5TIDUZhnHaTlOMPTE4oICzD9VjYhD5iZ3MLTTbQ6vfrNYb6LxHjGucNYJpPbLMmqsyH+/aKlgPeeK9N6cZFApTmgqgxOK95E68tJOw0aTr5Dm4A15/kQPE1ls8ZzDWDBOevRhg6tPm62EQ7toJgKkRq/GYpsMY6oFScHqh0e6tklRHKqPRbHM5o8X5+e4qNDcLZpiGYUHdT37+c8v0sVfvrL/z9jvpvZv6yZfuvvfa4Vt3PvDTnx271WJ1/eOf+/zBE49dAMFgWlxZ5WxuUVVDAgO8VotqAKn0JMGdS7KpFzFV0hJjMJAK9aEDrLTCqBEXWMlalKwYizFbKnkzDRL6QQtzOVotDpZdDH7QDjbr7cVog2LK02Y7kiEGtqysGoW3YwIXVct56qIsiYtCTbbbKUo+PloRYzNstKBoKTnHuCLiUlQ1X2zHMVlmHU43qSiJuBQEBcTBmNSIwE5gMnT2kmgO0OaSJnbu0dE/VfpInYTS+idO9dfMSK2gKe7+TTxMzTwYlYQWEfODsZqXbRMgZ8BZUTJVNtQdfFUdMLkArVaMqMrpQACpErOBSinWhC3eH+wIQ804dE899fTgFTAv6hP5NMZ99Dm7eI/4fqGmfg5H04a1NN/T/9At9Y//5e997od/pLuYSi83x6m79+7p+L3/z//mjxarTbn8xAfjT7/93v033r4Vw8Vv/MNf/Mz/+K+N6ebdb37t0R/+pJbQWRh7IgqxcMg29SpkQU0D99n8KFllLknPhk2GCkthRAkGS2MCoRDDLKWySRAmZ8IZmoeJRIZpLGYdSp6ywqYynKxHbmfBmxGIo1Bk7oWo9uySmW4TjMTjmRINSbdp60deTdPIRJspi9B22I5JM0yIzsd0PKSDZSTT9baoBfM+5RAgItJBBP4h1jgZ9jkwUq2AAbBLptmFni7yV2Of++ydGabEPvWOCBzczJWMiYSzZonSubrHTPP8mBW0Kw45sZrUjnsOXbfJWRGMjNhIq9+rM/PNV8raw7cWS2fD0Was5sBfaynezbRySyR+jLdXUCMxsf94dgGghJXmXrksSmJiCLu8spjO7UaeVT8cE+ANdtIK97ZzqSCi8NKy+8hf/0sPXnv/nXffjx98aiipdP2zH3nxtS/96u+++fo/u/WHN577xPbpp9999c0/96GnX37xxRVthcbjsFjaKnHpNutJELpF6HpK03aclrlwiJowphxclucn0ro+umDSQpGZRKkwswSpxRJYmlLKE4FAkrQosg9m205JwATiTElLKclzj+LFmRBaPLJF3xOolGyWoFZUvQxbFyVICLziRYyBgGGzWcV+EQuHQBzGlHLW9ZAZ6EJY9qJ+5jCo1IhVc0y1AvMWVCfnyUUVQkZaCBqFi1lRNZKsBqJsxsTBZ/lBWoneQzrVcg2zltJL2G63t2+9TyyXL189Oj4uPuyHpKX3u0yIgK6Lj16+9Nrb9yRUnQXN2dOc6NgcRhuLtSt4gvz8PIMBLtEyQH3CYXubZjxcmVEzBpaRuwO59swzQ9FufLCQ4zOKKj2ZkmVfK59otOdCvRzQaFn/Fc0pFGjn+dnMQre+f3j1mYvnr/1n/6e/f/e3v/4f/Yd/+wtnF9/4jX/9/BOXu4MPf/n8ax9YDu8tp+MlH165/Od/9r+zps2DWxcvf+5zr56l3G2/982vPfnyR7W3N9587enHnmQOnHG62fYWRpQxZ80lsLg+oiMv0GmecohC5Mc01ZMoGNT3se+iqhKFJQFMxWgcBi2FwQYLTDF0asG9QMplTKnAACtFiWkzbOsdErlemJmYiI26LnJHRESqi64rOQnx8cHhokOBJWWvbDmDFvycSedEmGKIuQCqzAqwCGd1RVwV7kDVzAIssh0uutVykbVcbMbNNBFJMRJmFzyW6sHaiD+r7KgpwSwQReZ3b91exWDAIgSqw+vMG4Ol/lHLr81MdRhGEYHVgRFuUwXO2DfI6chWS8uQ9lJpitVU/Z2NyGWscFOvbo/a9ECgoOTjo8O/83/+Pzx34+q/+5f/u//5f/F3fvxzn33isef7S48NGUFIoFaojmd3699F+MYuNH6iNkK1XzREDjMLv/BPf+mDP/Ij/+SXv/CF3/+TH7of8//rn5x+4vCUT4To6MbVxMrbg5TWdx7c+fZXvj7Z5uTm7dO7t8piOD5+7Nd+9w9+8+/+f/8X//H/evnYpTf/6Osv/uwHv/KbX/zkj/zwV/7wDz7y+LPPfvKV9+/eOV4djeebbZoyDDlxDABbKbl6I43GBuSU6ozcosQkVCo6MXTiHa8MYTUlAhtyVgUVQeRwKMIheBtlTiWEAObJzIoK+wg98iF7BQWAlrJOExlktdqopqw5q1EoQGkDbQoRaaNwQDllEAlcD5JRvEWJYURmIuAQfbz7YtkfHXTT9rxfdnIY6UJTtmJl0S1Uy6hA0UxQtDMHYWxWp4CSJ/V2dLAatuvjS5dNlUBsPtHEGG3kg5P6VI/BXSwWVjZt9k92BxR83C+xGrSSW0rtVAzbc8bsroxrV7NRK49Xs2kIW8B+Ig8RQGnKP/mTf7asH/wn/7v//dUbV17+wc9MWzqdpg4mSomZUageMN28NdfbBXadMzCwtWOcQQaT5k2ZKfzcF35t+Vu/892vfyNdehrLw03YrMrB55+9cmnFf/CvX3/l2Wd/8Yv/1d/89Gee/Gv9xavh7vvv3Hzr9LkPPHZ2cXu4p+vT9Xdfe/0Pf/PXX3n833rpyuGdd189e+O7d568cnb7rdvjdH977xOf//R/8//+ez/zU3/u+iPXcqQAmrYjE5V6zC2YBUVhJrHTnM2MRXwokk8E8FGCmgsho3AuJUThivMoxE7IiApYvHrbdWQgJjqYD6IDiCildPfkzmKxkhBi15EFr6hNWrKKEtflCuwEtyJatRYzoI7M9mzUrOSJ2aFnYGiEmOkwTefnZ9DFoqPN+mKJhSqRasdCZJ1Naho4brOywYSkRc9UoFwbpFQVQeKij123OjwahpFggSEwNSUIETEj5zq1ebnoH9x//+Tue0eXnthss6cvdTJsTetaobUp+tGOlKDqykBW6qe7/MjxRmNeqVHrfp6VbyOhMKb8iU9+6v777y7z+U/9uZ/65t0CLIh1UZIhEgf2s6/Im1HnEK8739mssm0Bx+fVnEutxW/lgx96/P1bJ2dDd5HvjT/0KV72P/dzv3hpdVU2fMBv/s/+xmeffuHtj/3YR7/zR9Mv/NzfeeHln6FwkyIfXn352vU3P/3ZT33kxY/dfeO7X//Kbx3cfPSLv/nFi+9+++mXn9fTuzcefyLn6WOHvMrnXXzij7/xu5dk9cIzz6YiEqJpFlg9/dsTSwoOJGtjGhEzkUFisN6gqmRCsc5VIWoMCpMf/uwTD2v5pQpk3NuwSElTnobV8ZEqgsIQzIpRISFRZmot2lxPCqHG+NSeeBAsKKWiSooyFg5mKBmwlDu2TLTeDiVnBeVyZlO5WE/KBjFiCBCmEEj8vFRiswyDsZqA4uLQFbfZcYXh6qVLRlpUr1xaiaajZZcyzicjtT6UVS8521TIjFjHGzeuv3/7pqUpaymldJ10RApK5KO42c9KVO+618mIuTZJ+4FVNhPyfjqxKzkZs16l9mV7WlaEE0qfFUTn08WwXR9dWkI0WhxFmbQgZEKwgVm0LiNsJjYxc151dImqeimrYp925Lg/gnCyvvPW6ZXvvXHzWrwhTy3HlejZ+3/hz/zMze+81b+ywL3y3slzv/p3v/P05a//xmvpi19852f+5PUf/NQHn3nxlffGb33vN774qR/+HD/9xLB51zReXRwfUzi6dPnzn/nRj3/yB04PLn/1m1/5y3/lp947W79tp4vzdLC5lW88cRooQBe8YBZBSZ5LtN0KItKWxJn7eTYyEiZoYGZXZVMF7XOhojEv1Sm4uXIVc3HXL3Iq23HowgJMpqVqjlBPC6792lbDJFeQ99BAPCYxsigC4S6SqY0jJS0i1oe4WvbExKpBmBddLtOU7PRiBEgid6J9FCsIMQJg0kgchXoWwiidGHPOyiJkmvMIVKqZoXncZgMRT2k6Wh0QmWohkJr2HfcRh6tojMPDw82wmYb1Qb9adCH08XyTTrcjcQhUlj2VaVwnsDDVqSReH7IMSC02akWwRsaqpkTBvZxBDByplqWocqhisClNMDUr2HW5774a4zmn5w+VNLUdDNTApwGlNTkTQOEv/ujHT7H9kY9d+dzHXnnpQ8+dHi+/9/W7rzz/LD93+O/8lZ/9f/78P/3tP3zjI5/+9K/90q8s5PKnPxQWB9YtUOTe23//N69/C9+S+y9/Eo9efXzxoY8vj7vVwWq4dvRf/7Nfuop86cd+stP8jS9/iY+u3l3ym1/56jrYCz/5U/ffe/tf/Oqv/Ht//W+9fecO0cUjVx4bNXsUotoX4DRHK4t4OymBlOGMwMyR7GPtPdIXbVHcdlU1CD/5xJOO/Ivm/UlG1lJLAMTearPjp5lZ1aTKpgvYcpqWXeg7KlkB62NPbMQkQaZpImZTlSih78u6BNGkVIoNlrMVZIia+VnAXQcmKFQhRSEkEkopVnIXglgx8KTYbMcYuDCfnF+UUoRULOdcIGG5WIAp5XHYbo4vHYZgJnp40EeRnmkZLCzDMAyGEokWrHHVUaIx5XqeGxE0MyF65m5qUGYHrQoyFsklmw+TgJgBqmCX19ZkvPoF0xrwTIE6+I9QyfyH6sDNm3raRU0DBeyLbZTIyS8KH/3kkwcIP/25j5Vpuwibd+7cK6f3vvBrrz957ZHhdKmL61//2u9/8TtfjuXSX/zMi5/6/Ce+/Ju/8fjlJ167c/Jrv/pbzx6/+Gee/InLh/1pHp5+9rl4xP/B3/qbtw4XP/d//C+GfLT95mvvvHfzq//4t5+69sGP/dVPXv/8p77467/2ja9867Of+aEnDmRx3L/+O9+6/+Vf/8t/82+TWC6JQhdiP40jKQhGfnIX/D4IfjJW66ScS2j/5i8yoNT+t+pWjeq4T8cAyl7KAaX5EKhWedFiWoqZlZyFgwelnDMzVDUlnSJvAoRRMggkDG+KkSCMME75wnTKKScNsQ9EpWiZNLtsJOWUC4AzHgVMVKfBKTSGAMuBJQgzypSh3JEZWyLh9WYqhpLWfSARsaRqUyf9OK1P7p8eHT5ycXYGlLjo1DSDELoI9AHbYRwm2qz1cLk4PIhUrFhR02KkpdYwCaxksEJqyxCFETioaYJK5GIASspaiJUYrJaVwYCfEOcjwDsCM9VGyVnuWgn3udrQDsWciweYQ389x9MdalV4hXvnt8ehyyEqFc4PYtf/xGdfundxsnnz7Of/q//LVIZHD/sHt/nug++up48ePP708vFHn3v2Q/e+/M3vbe30+L2ffWRhl5fTphxfOeQDevTqY6xFV5d/7bU3P3rlcHvl8tfOxxzKJy5d+sa33rh/cufa0aWjw+WNz/z4P/ylf/Lb/+jv/3s//iNpuDjsj89CPC8Xf/S7v/n5T/14cYbRXZt3gsNnqBOxwOCzZys2IlJPcudTE6pDrEkB4BTOvG2rCq7G8ia/beexggDzc1qJKURiKSV70mtgb21IGeOUmCHMITKYTanNCdCsAEQkdB0BVnISkEKKSQamXBSBiKbsTUIQZCMUtZEzQYWJtIQubpPlUmAGTULEEorZ5NuzKMhSKTlNyw5hsdiMeb0d+mWXpwylkoazMRF4mvIwpilbBk/IpQwAG4EVTABLybmk5M1OpZSuTvwqRqJaBCVK6IRjXEzjOKmQWSrmOhsiykVj1wUJgKFyczCYE8M+Dcf/a7ZHbe3lXs1Gbc7h2sMtMAu9LfRQdEwxRg1iwGYzXOmPbnzsCql6SfUnfuzDtx+c3Ll98+/93/6TG0fHr/eLdDw+8+de0DfPvvvg5IkhHR0sL95//7lnni+HHd06v37j2r1b73H85BVcOj07K5fGLqVLy+Wnf+qHHrl6OE3r8SL9q1/8he7s3j/+k2984vDo3ttnf+lv/E289fYz79866JZrSWW7BUIEFysITKqiUKYEJQMLkcEsE6gWygh1fGtlFQlAOwKYnD30kkZlnX1YAgyKQGSm7lEBgjILgwl+xI4aSwAgCEYqaqSwojkJCXGgpDaOxUxVteQCH8JBTECkAFMthVkg6Fg6oBP2/BSRTDOhdBKLYSxlLEUkBGEh+dY3/uTxJ56R7ii57N9UVL0RZcoKgZCklDdrvXo5Jk33zs9TobNx7VOhInfbbSbhoigGCVyyjuPmzqgxhMAlhsAg1ankPMHyZADnlKcYL8akVg67jmExck6lA0/TumRlKQs1zmWrVKTrIYJSAD98isknjTJQKlfrnqJ1tAJUPLHYzRCAzVWuZrncTl0DLBQkMvMDjKPElLOqbks6O99KoK7rMCUqePzoyuVFf1EGyfmNm6/icPnTn3ll/Ojm5vZrX/vn3/3QK5995ckfMFzOU4lSPvyBx5974lkqZbVYWiHh0HFYGj37wWeVdHV4eD+vv/Tt73zw2qOvfufN3/29L11+7Maf+emflH/6Kz/4jbc3P3Pnzffeef65l7XryzQZSdFMAKNoG5lQ6nmDDkPJzBvP6yw1rZUTsxomqIURJUhFR+YCe+/dzLnkvuv9ZN+Khmu2CWYqdaBdXUsOQiwhdrBStBx0fL49Xa831x97fJpyKXUIWSmacvbRL6SuJNae1Ke/chAYoixgOimVMROVTijnPIxZc35w/96TTzy1iLLkyGRmRUhcpZlyIiOGsnDoF70o91G6bkyQ6P2UJhS6rp/SNI5Tv4hquupiMZ1KjlGgpjqpgZliL+tNSdmIrJiN20FEmLHBRFo67ZhsyEpmJatIYrKUYRCziTjYuOWchElLhkSg5vto5tm+qucMTnrOv5if0+5lRGTMyEYgBBJLaSSVUlREzdSsHIpYHwYdx2nLQTabTQ6bZPE858jCi+4wLo8L6GgJTXR6evL6l0+Pu7ff3T7+sY+fXGyff+7DV288kogp9nK0WF4/sLhJ070yLfWY/tkv/7fh+PDaE0/9xm/9q4PVpYPFYv3OzVff/d5TtA5//NX3fuVfvhaHDzx69Hu/97XrVx978gPPd6sjoUCqQIpBCCF7t76p12WYwWTD5sIMq4MDhezKynt5EMOgGZhPgkFWZaaz+3fX2+2NJ57MpTZs1EnY8CN+2wgZoHiiauyzfrwc3y/j/VvvnJxvLl++PAwJ8IO7YIZSTET8UGvHwSPgS+wJmpiLTlG0gEgNuZQoMaVk0BA4p7Fk7RcSQ/BnTwSC5VyYEGMIIeSyHYdpFec4Sb7ZSAiZWDhGBoSIU0pUQqh1dWKiTkRNE2deBRFRi2maAKh6T1k0Q8pGOTNTjJIKXPuejcGB46JQCDGmNAVZJCsVTUF9qE0rGu3GVBgBZK3tZC5lwdqhTLsaPWCGMKStWLBsArJsRiaBMogMK1nEjHGaDg+WQ5kenN+BUgmLU0W+uH8cFzcOLk2mxwfHVrZ//Lv/eCnhT978omL1oy98+s7p9OiVx0PfK9FydUgZV/pV7PrbSd+4ee/lS5cfe+IJo/zhF56buoJ743MffcW++Q26cnD7vXf++OKN03tv2VD6D3740UeuPTi5Z4ZlCIbpYtxYCU/eeCZlNSKzQsyACXS7Pm8dOoGETbO1XkmXt6uZoE6+Mz9lFYgiNg3Hi55SZqvWo+ojVKrOPRc0laQ6OmJVMgihk3BltXpfeNnFZYziWYKWYmU0r5zA6sw69xsSmLXA5/8LWaBgKgbNJQFG3IUYT05yv1yGvg+8sGgpDdO0DTEu+0UpOXTBclHTpCVdbA4WViicb1NSFrUoKCUXtdPNuTuosVgMgVBSyn7KiwhnU2gGU5qmLoQQmNhyTotVN02ZwElLiF2M3TROUDWUAGXpplwU1sWY1FRTKYnbpEcWRimNU0bzA/tftn9uSMvqWy5QDdqLVWBjAIFSyZqFg6KEsCDQmNJYiABoCqCceMyJOF7l5SSbISQymtbjeZrO0kXocSn0K7n8yJUn87CJmzuLfv29737hfqTbR491ixuPHPX9YnHn7ftn50ey0m1593kuC5TXvvc6y/LaI9eGA3n/wau9Yjy4+u4ifPrDH30Kz/w3v/Urf+M//I9/+Te+8Mz5vd/54m8fXF688sGP8Cq++qUvbwd7/q//T/KDIbBo8BmH4sLpftHFGErttvV5Ko3r9N6dKl4j1+eiTg0XM8QYSSuvqlpmissr+/Xw5pIDEQwlENQ6BSxvp2lMGjhoSlpK7CMTl+w8s1ptJAd8+otxcWmwsJGJcMeixiknkVgzBqCPktO0XCyEOzXrD2JK0zCk7bANQZiJpWqUlLNPepqsTKUgKROFENqIHVegljHVDVk0CVRK5X0zMhFFQiqlqKasrFmzBWHFCFCeijBzYJjFGIhMYKqcbJsLRA90GmhRhESLN6EVs2AwswKVmVOiPaM0oJ195qfOe2mA2vDTehyOc0+BtOfWVLPVqeu6nPM0jiEGYitEWUlkaZlz1r5b9lnHnA8PV6OOiokM904e5FW2sB10IMkiR2MmmzYn6ZugP/7hHzpcLd+8e4f61dXQ3ViwxcQ5nd14YvHU4Wfv3dnceOL5t06/LEV/p5+2n3ryv/yFv7d97/ZjLz33d/6v/4+DPt155Xkdh0cXq4t8f5Wu/PSnP7c4uHQybEJYwAg0zUcRzpOIHKqDxKgNIvKxhVolupUB9I2rVqBd7JXMT+mtirAdQmpqYjOLUYsF0EjKgSzpoCVPab0d+9VKCTknB1SqdZS7y2HJW8BcFWDmkn+DTSlnUmaUklGbs42ZixZSg5ZURmOGFQm8Wi1KyjDNOccYvL4KliiFmWTR6ehZoxaYmoqfUkxUZ0n77HOGJs1gmAVmU5PApaRiyGRJTadRSKKhi11WmEK1OLSQjC6WlDSXUGTKhTQzlAJz9YqlwJRMhSirAWXuILU2rt/MT4JvNLYn8bvlrnQfgd1Qg4W8XBwPG7VCWmzc5BCiBpAZQ4WFOwoSmWMaJevURREqpnYcO8OYqBweHoqpjlvwMOmoUxZbhhyGJMQdOju7eHPQt2MXB32pHDz17AsvyJWrTz327Gq1efGHnvud8/uqEMTTbOmRa5uzafve2fPPP/b/+/lf/Ft//a+9/cb3HjzYfuQvfPrNkwePHF1bHPbdcnnM4XycRCIXv0uFWcnZgngsNhC3wS9ms/jBaNf4AjOXs+uUU9cv1LTJb9V9bMPssDpT0SXaRGaBoEVTKtJ1akhWDrrIIXAMjrkkyOyAzWxu/UUd4M1gnxtFjomtdT/6Zyn0+PiICAw2mgcio+siwXLRnAsRhSAh9mk4K1pi4B6dEBnqjBmyOg8/xuhaoppfGgisRQtQSmEtBi6ObVDIYKQK5OzCL/MzKwAl1QlsFtQ4JzPiUrJpiSFoKVCUVILPjq14Wf2AZFc0qBUAZvXkKj/rbp5eTepw1QgQtIqeUYjLC6W0OFxu18oaoiwMJArVZGZG2sVIrKojL3KwDNbFYpEmYpKc4yqokOWhQK0P/SKklMs0jcbGIC3LcRtyGfN4EVd0cv8P1t0f3IrXr9x88dFLh5vz9ed+7Af/xX/9D/vDBS27cj6sBvqxH/3c3/nXX/r8Vn7qx//CiaX47sk3/uTr/+n//dbf+vf//fH2nQ1fLmbj5ixefiSZdUZGDug5p0m7WMlTePmjTQ+oUKf29BI1BO/TG1I2q+J2U3NCtJ7BDMecKLkwU0fo2ahkp/FRCtTAMeWMmVflpjupzleBNmsZzTF7469rYmBiJhyIoKpFjWDCtL4472LIBWCfxUg+PbaYxcB9F6aU0jCYqmjhKtkywNiUgmsSELtO986bq7pQkKpPo2nFYXCoikyD1jEkhOJCk2ii3sPOplDijolJWYtp0TKlRbdQzSllDWRsqtkURoX8CDJuTSd1WbQ6jEa/AGBjm3v5zVwlYCAzhEiHpSTjoV+BiZht2KY+LnIRDplFjYrBjFWMqahpScUkrIjVLI04j0JxeVwyq5VAzDyIBEg/2CnHxNRfbDBs+wfn6ZGu06Welnt4cKccHl5/9pE37377jT/+2isvPBcOuve2945t89Frh08/fu0PX7/JMS46S0f9RJTXF994/avP5ONnX3w6Lhbf+c53L19+RJHbgRAKQkojbDWLLAltPsIe+vEJRHgIvJvmSQykBj89FQZVhnhJ3x9tECHY+7fvPnntuk2aQokii9XqQpVgJWcBk1ZepYYssiYNmDPYfTZlhze4qnz8LKYqgjcfCmwwNSM1M+YImN+EFmWh5WphRpo154SSiBpb7t0kilKyVY1DXYtOwBKzjxZHGwrZ9E0AWaD94SRsDCYu6sPqCiajAlAXQiEsF0smubhYxxBiAHUkpJpRmCDC6uFrFi1VXp5rpXX3fLzj31q4A6ihM4TtAOKgmiQg0BQDMw9A6UOPEDNvRjvvAy+5K+l4IiHdWNqYGncLKxhBhTGlQUoUI6gWTQAsTwvy08u2x4tFkC4OgJWyYR370wikbc5v/O433/zcZ+0j1548uXj/3ru3bzxx/Y23v7Oy+IkPPfL2WboYy3RYPvTxV445n5xtTzb3ju6/dNBdyp0lbENaFkqZjErQYiiFTWEFPozU1Ar5mdLEqGKcGujdjLhoMbNhKkaspXgjG8PhlpIfj4yUi92+f3H5+tVf/92vfPzjn/7oBy4dybChbpMmJcKEkqYsPJLCVAjJQCSspGzm82i99qfAPOvFh+V5AKyiKy80GBFQyvHl40I2mQVxfReyFRfKOwnuWDaGLnZR02bcbpOiDzFKPbrALSBQPU64mMGQChsm36hEZGrM5F3jpWQv4RCB/dx5PznTiplCVVWNyWyCbY0CEFK6kKippM12q7zyOWAEMFT9rEgzMgT37a1uZHUARRUwlaJAITC1A8PmA8rVEO7qeWAWdnH7tE1DtxQsbJomLhIDRelUBxCkv4CyUgdBkvOxXIhcp7Fsh/tdR0XMD3gwOjKAg5YMy2NchIwpxvzIsjs/Uya7GIfzrS4XcbXqpjxdffTaRXnt9778d156Dp/96Ke/cf9WWZRrjyzfB1nWcH5x7fEXnvrgDdveee3s9H/5H/1vnzx67K/8D//7l7lX6QJJxsBiaolYJQBUcskswUpmCaUUIvbph15vUzUoPBHxkDtshimlbqEsoqZFVTjkzRg7HkshCauDo+G9O//il3/1sctX33j9m89cfvb2/XdObXn58PDo8IgPr5Lxkeaog2ZNoTNRGbaQgKIuSilGRAHtHE7bneMIUBUNmBnDYCpm47idLta9hFw059wJOuOi1fIUlW7wYLDZbJf9wharzZitlHFMHLoQI7HVkoyZuIzQQAgwDTK7VKBKQ9GOqfVOKCNi89GIVrWnzFRctuq+VRE6GcfNwbXD2Pd6YaUU0kzGZlasaLF6QINnSt51RKr1tFJSRSlFVYNrZhSqAGlhZvKIgXB/OF/2CxqUYctFDIJtGS3YweKgm/oyyZSVJZjk1Sp1CzrdrCdkUs1TOezOAkvO3Shj5k3oAynpSEGki05wL8aUFLZcBVApC9pO6erRckiasq3Pp5zSZnxwrVsN24sbj5Z37v386X1+5pkn3jy50635OMq1Z544P5f4vfO8PUHRy7GE8cG4Pr176+2BjDfDjetPbTIJdBpsu87EHEJPBO5F1WIIaqpFyacmspfepdRDZ4iAksZOmAjr7aaLUURyng77Ltv2opQ7d7fTdOel5568++77P/qZT3/z9e997Y+/9PxTj33xi7/VMf+P/uq/e3pycefs/McuHy626T0O2Wh5vo1H8TxbZEExNQPTZAnE4geAMFdLBdAwr0uBVDVpziV7Z9WYM4mQWiqFqaNcrM4sRD0+WVAtxqzrOivFcipmwzh2whQCMTkH65/LUD/lqKYmbf6MaT2xXRtYLjYzltaE9WRV219tLudcinZdb8VQihEUmYoY72UBqkpavHTRNGuAO04QUQiBfRcJafQaHwwoqjCES4uFJVvIsgzJMrAUE15vznPIR3IQZNkvjqdpa0zrdTHostdQKOV+sYiTPlh0lw/p6tpODVvTkYWNS8pmg7BFpiASuVAZlKArkcWqS6p5HGO3KJ0MI5WxrNX6g8gxn6dbj9949Mblo9MpX1DRswf01gYHL77XyVtvvf7cM1f+53/pZ147uff2/e+98ztv6RKs8l2LSQoVHB0cvfmmLg+OVKTrVh0vrl9/hFlEZLk8iLE3s7OL9Wq1nKYUQtSaLpScNyKFUFTz8fHl+7dujuv18tFnlquDd9+5+w/+wS//5E99hl/GT/z0j9++8+Dtd97d3j995PJxiMsHd25999VvS1i98fbr33zrg1dpSR94hKfNkeD26Uk4uLpeXwQJrBaDHBJyHjIFZhbnHVRdZhoCG5xd19h1HKISb3XK0KODFYxME8c4pNx3SzJLJTFzSglmhFr0MtVcNIiwiIOTPI0pJQp+FnKTtUJdJ1sBoYOGdmQUzOf3zmfQw70oM6nLdbSCdMcGBAohVPvmQFwE5JmRt9Q6TaU+JIKoQt8KyCvMUK0a+jpwo1WXXKkXDjoNXeSMeHy0TQN3nDlfX1zvgl1sHvCSsFyc3jw5inzQL/LY89ixpUU3UjdaEiigQ1QKtNRk201aLC7lkjEqBT/ZW40yK6IEViKyEIQPFmPJkxmiHnSHJ8P5Zm09LyUuKWsID44ZVx493NxYbO5NG90c31v/D558uT8Kj/eLO1enmw/Sk+F4nU+3U8mGiTf3b530zzyfit6/92AzpXEau2hHR0ceQRb9ctEfXHvk+quvfefg8HCzXofQqaHru7OT05V0777/1iOPPTmlfH5ydtTFst3eGb/0sU996BvffKukxcn9ze/+699763vvTOv05ltvf+4HP/LNr3z15jt3P/WJD984XpxaeuXZF/7BP/rNH/jpn/jzT/UxrDXyV3/+i5cefeTe/QdPP/vMC888Nd18sLl758bjT55ffwJmaRxN7eDgoJQiwvfP7rGE40uXzzfDzVt3um5x5+4JiDSlr3/5a5dCd+VgcaZp9eSTX3/1za5bdd0iMq5eWqw6GbdbKppgGVkRhu2w7HuO0dQWzKnklPN2GLoYl32P1hTvKtra12HFyFhCDeyAlaJQFjE1q20NLmuofEjTdLr4MHWxg7Fq9vwNMC1mXOrYXgY8f/QubG1zUvekoqVSbMW5PhiRsXE2WDjqljBWoqITSzadlstAG9usOeNgfXER7FSWgF5Zb2GWOkYfmahL27E3LjYOmQP3KEKwDqQ6clQxmTZj4J5V+oVMeatWRkBEkEEmkXS5pEnGNGyPlrGYWSppTGMMDndyOIeOR08uH+WzfEzvjv1HXv7o4sknb9y6WeItHabPfOiHxzQqFzW9OMvr9bA8WAzTYIAwidnpydnVK5cff/zaMF5A+fDo+JkrH83Z50wkzRPMzo/78w0/9cyjWobtRkc6Wi4OiPOjebl9/8Fqe/+/9/kbx8cXedxQXw6uH3782Q8drg5/742T55+49Gf/7I+//fYbr71z89a97fElOX37u7+9vvnYtcX5yc2bw/3Nff7YE8+9dvfW4aNHzy26tYp14da914+PLx0fXsJkaXtmgTYlf+Wb37q8Cp/8xMcZdPvBuuft+fvvHixFWH7hV7/wQ8++9G//+E/881/75z/xUz9980+++Z3vvUtyuNmuf/Zn/8JHPnTj9oP3xAoxbt+/eOLJD/3SP/mNk7PR+u7KavnIk5c//2M/9MyIkysdbVI5P8kHh1bi6ebbgkuRFxamaepWh9HIzk7pGLjXy5IODzSh60nVV4oqPUSkrf/SWIyUiiEVJI6i3kFkyF7GZSgsFGuVeBIQSp2dyzsVZB2rppXQqMyewVkoYlCwrcUoOVvJadUHE4jp1FmgSCPlTWKSrHmDMaATptGGNBpDjw8OUhrGjbKtUIglwHTR9dnGKWULnCMmDKYmI3cclnyQtFjhLgSGsU7TxbZbHC4PB4UlxZAyh27KBqPYURBaxRWVUqaTxdGlLZ2/+tY3Rh5HpNOLd8dh+pNXx21Shh73/XarKZVL6TDlQbOyhLHg9q27b7976/b96xLQ9Yv89u1FgMQFCSMqdyQxjjqN5+PpxYMQp9Wlw9WlMGwfDNMZ4XARWdN7WspTT35k1R9d+sxLw5D7uLh0fO2N737r/Hz7G1/4wltvv7fNG1r0N65+YHNx8/ffuF3KGJgXhx0tzv/o1W987e23zm26/tGPLZ98tL92fP9Lrx492x1evgouWeg7r3/vpY9/5Ed/6JVgebnsX33n7Vv37l6/fuPMZBnKd977zqc+/InD5WO/drK+Fw+t0Gc+8fzLl9cHy7TlS6uDs271Qjnfjnn7zAsvLsPh6fjgAz/41I/deOb9L33l8slwvjmxOL35+rtnOS371cnp3SdeeCZQujq9eRCvpX4z3A8Ri6NHPjS9hwdvvrU6IMF5kdUZ9PDlT1hKfk5GTTR91CIZuPgxMjmjEyZT4gLOPrFCTIiIkZlLO7vDZvpXpJ7m0XjZmXXbcXHazqR02UQYRk7JW0niZjt1B0GzDmY2lZjiMh/a2sZ0blEtajbEQCxCxtthCoiHS2SMflpUoH4YYSleWhwo541utjpIEMrgLCmpHISiNqYchYpax0sdplIoLqJZ6fz4OkpZC1mctmnZx0W/UC6wzeGliOnizXf+yKJeutZb4Xv33rnzYHN6sRYO771754UPvqD3Jy2ThKhJGRJkMUz5wet3pzROKR0eHFtJItFcv0ElFTu/GD707Me+/QdfWx3Kej3AumW/iKxdDMM4rpYHb7/73qvffSNwDNLxgi4/cvlwcYxFeOToRin05AeeHcdt3/fL1ZXzi+Ha4QJamGOhvFjgkUdvHF9/9PT8wXffeOMg8qGeSxjun747lBMGd2H54PzsN7/4e3laXj06jP29lMvz1y7l6ULGdWfx7dfeCk8+dnWxWo031+H0a9/+w6//0Z1pWOVJ+/7khz/91pM3HlVLXegCTaent05P1vLe6ea9s+uQoxjtYn12/+TuvfNv/uG3lPnpDz/9FPqJwyPLLPbextIf/cH245988fXbr27lsZPjBYfFmUU9PT3qpmtxONlOfYxq2q86Iip1tB0zAgFmHCP3kbq4ZBMYBenYn3XhkgtgRgVtJAXmkqbNBzXNaqaKIahhU7dfd9ZBcKhZs5aUJ3BYbycKen8sS6Ynji5rziXb5bCYpjVpkBB0yomMJIypjJn7pWocEToS2Y4XxCEGYYioXVlcPihTTtkYXexyLuOQSJiFx5TJUKxE6YpG3RhQOlao9rGfbJpy6mKcNpNlkAgFECXuBgTLpiWNC1k99dS1R25cfbC+yEZXHjua8vTg/i0jKyOxBQwZ6A8PLl2sT46OV5j0bHsbiy4P5eBgJeS9zgsog3Vx0EnPPcLmXNPESXPqC7g7uxiffPLGhx979OCgPzxY9AcL5tCFEKQTjsSyHdNYTDkIgkhYLAQgK1I0rhOjyJhG4nJwsMh5nIb09PHjmdIwbU/PTgUDd8evffM7F+cny16265OPf+SF61cOlfKV/var35lOJty2bw/3p8MiV5+79NEr48987tpoth4j0fFS+HvfeevKYzem6eJ83N66c/P2G+89d/3Zp5+4cfPi/l0720zj/a99+YUPvLxYfDSth0eefez917/x1Tf/5KdeXj16ffmrv/nNL3319sd/5rnf+8I/Ob30I3eXzyZjfvzay9cvfzjf7m7em4rKpUMCvv3tb9+8efPBgweLRX94eHx8fCzEi+WRsZRxc/fBrS4+v7l3+vpbJ/21xaqnBR/3iyM/vKA265hpa0Fux8TbXLhoyrs6kAy1hKFOH4cOfdEsshzzdrU6SGUsqlsbOw6EOJVkyh3ClX6pQhfDloBuEdOYIi9itxiHIQ2krJOt+z4ijz3HXIw5WkLEIrBCIL3YOHU5KkxTYYrMYOOSS8YkRFRYiULoyliixK5LXReTLNfDkEynnLZlWB0tC0wVPfcn5+fp7v2w6BdBlobLjx0b6Mnrh9txOD1bl0LnZ5thW7bjBZEN45pggcq03sQQNucPtuOGWPr+6N7Zxfu3bt0/vdmvuO8X3WpFNkSBTsMiysd/4OXnPvDowUE+PJ66WMTWXaSU8+FBHIbEnWjhIDZsEnGcUjb0YyJ0vWYcL3TKNq3l5G55/VvTyZ0rJeH6c4urj129dvXa5cPVopPFcvkjP/phTWGzGYZhXcaL7cXJ6dk5+stX+lvr9YPHJ7rx2BW5trhz78767sHhswddXB8sBu7CJPr1N9/Z/MHwAz/0ydXqxoc/+OLLzz938Ngj2cqD3/v6hk8On7k83Xv/vXfPS+geu3J5e36a1nevSr51+9J770yvfUNe+MgHKSxvyGMH5fwg34nLo5xOV2cnk539iz/4ruUVc1Ar5xcX2+12msbFYjmWKfQhjYk45Gyw8oFnHrt0+fjXf/fXfuX3/7C7ErvIi3D5xZde+eAHX+5omUoiQtf3QXofY2Q6ed2ZdqRVE59rHURAoECSDUUL/ef/q7/qeoIYO8BKLgZEjlMqRXUYJxiYrQuxW8QpJbPSd+7zEYKY2Wa99gOMiU1EnHQOHGIXpnGSwESIMU4pucyfiVNOZsg5TWniGISopAwQGIXyRCXkMQqFGIyskBa2DN2WtM0paSlQCbLqeksapSs5E5iZF8s+59QtpJfAWYaUtuNYVEueSkllKnkroZeMnP24jwQrWE+ZGVpSCKSmRc0gHXcvP/f0Y5cPzu+/89nPv/Do45d/+199m8HPfOD6yx968Ytf/O0PvvzsuMnHl46n4eLG4zc263F1YEyyPKRxGMmONYvyqSnbtLx/+/Zv/dKtD37osWdeuVxKMES1RVLJpc4xZu6EF0RRWLxLJJfx/N7du+/d/tYffWNzMdBitS5MEpjr6bXM1PWx5CTdYpj0yqVLMVAp0+nZSb9axMCRaRgGT7SPjo7MdbGSu/747Dytz7d9Hx579PJ2e5LMUi5ZNVCMFGiyi/v36SBaoDEn6buiSFPRYmNBUitaylRCQc7l+Pojf/s/+J/+6j/+hd/96ldVIlFg5jGnS1euXjo+Vk25lKPjS5evPnr1+hMhLpfhgEWYmYm0mAQGUHRU1RijqRE4p5xS6hcrFg7jpCLChUvJIGjRXHJgnaYp18o1lVTGYZBxEUJXio3jRISUMrPEGM3CtC0GChLNzOthoAGAltL1vakaBiIex1S0xBgJVLQQiFjGzSQkTH58EZRQmFNaXeRSSiYmlqBk2bJpx9QjjYAW2BQQOE4dFQkxiFI+G85EFEbgLpaV5hQUnUh3dNx3opoZOqaJeLneDK4W02xHaTRiyCrlTIag0DG99LFX0qTnF3c//qknHn/6kV/95S89/viL77z/7vLwqb/7d39xGund9wqjs/Du9owuH9278aT9xJ/5hPC1f/qP/9tXfuDlPN2MC8CWiwNcPTp87rFLz//IM8gYHxSDboet6hboVIOpkKVcSlYJXc8sfRBmCtJ1Lz8WVk9/9qde+rv/6T+4efO0LIhBgqBmLIFYprHjEG3YRJEHN28TEGKIode15YAMKxqncWRenD9I4zTFEBhc9D6IWTGN09unt0w15TGZGSSXNRlxKQGgUYc8Fk3KSNmEA5Oo5YKSS4khMkTT1AmEyirQUsC9n3VtQrY9vT2ub7GRCG9Pbr3zvW/FuMzKRF3s+67vQ4xEoqAbN25cu3rp+OjoO9967ez0goWHccw5Lw8Pl6tVEO5hUJVxHAnwAmDhBLBBi5IIg5QkirBZDpFTmmAQoZwng/Z9VxRayqjF1JhkLNmgIpJz2U4bAKomIlCUYsN2iDF6DYVAU/bhCJymHPvgdRcyNmWjoGo5FwZbASgq0PEBM4pmSgaCjhlWCnOMB5p7ZUwCjXyRi/AixDDmaYvCnJRUOordMnZh1a+6Po7jaGagBTgmxXY7kloZLj7/E595/Z072/XFhz/0yLPPX3lwcr8UXazk0pUQ+eyll566cvn49MF04/Fr3/z6N1/82At//Iev/cxf+EGl8g9/7p994ytvEj/2vVe/8ZFPvPLWd7/7wsuXv/Pqv/7Acx+4/vgybfsPf+Tx07MHz37gceo4b7almBUTirkEZekWByh2du+BWLzY/v+p+vNgy7LsvA9bw977nHOnN7+Xc1ZWVmXNVV3V8wB0o7sBCSMJSKYokVSIYZMMiqIVouiwGZZt0TJlhxkOKhCkTTJIUKDCIhgECEAAQRANNLqBRneju+a5soacp5dvvMMZ9t5rLf9xbjbp+isjoyrrRr599/Ct7/t9e2ubZ2pXbzyy/iP/4Rf/2c//VqWuy5JNyXFMHSB3XQ5FkXPvCEHvPeRMRM55xOSWXks0A2ZXBlIzRfbBqyUAQ3SmjEjBQm/WyFlV1fpwZgTiImLXxRgQLQMYojo0ZOW0kKjapCQnQ+VG7XFztHsUBkNJBgbZBJjEgJFMlIgJudZkoIhz6TF6PgBxivnqW8RK3ofFYp5NnXN9MWA2VQPnfNG2bdPVZubYGVDPddYe808oPZkjMAA458SSoTGxiCKzqeUsuGRoETKK5OCRuFgG2QxUpLdMu8KLiAGYao8kVhFPbLq0fC2jFSlnXUoSPQHHVB0xcs9MNZW+882QEJUZHCrn1sy8mgpo5H68LWgKiKIkoOy9aP+Ronco2iJZNkFmj+YgoLqD492nP/bYnfsHIM0Tj53wrB++uyCnTz37KAc4Ua0dzqdPPPNQU9tDF/1qUT3zzKdT8E98cvvE1hbo0Wd+6OwnP3f2vTfvnT9/cmUVTp+z+XFM82p20P7R7189dbp85/Wrx9P9T376E9evv/sjX/2hra3gBl5zIkPnC0JmPx4N1+Z1y3V1/d184pGzKdx79KHN9Y3JnWmt5pyxCi19FgiSk4oYooK1OTqmftztnDcFIswizrFjR0RIBIzWiSPyzgGKqAAhM5iZiTKgcyRgasYBSlekWcMeuHegiBlg/z7v6szI6N1o7FPqwGg8XiHnhdRMibGTKBbRCIkQNeXUD47Ihn0pUR8M8eglqVjSlEvnVMVUGVljNBOH6OqmRoSUIjPHFEMI3hd1U/cOU2QCMwJLyQBQtTdcsADlbIhkYtiHUcBJ7ufLZAY5dz24hZiQnSeWnJMkMCAi6Y09OfezhT4pxERqfWkiASARq6mkzM4tgZyi/dyZEVSNnVMFtR7+n2E5nRbn0MxEFIH1QccJgmnKqvAAtO4QnIgQEWDXZYjakcLptc1Hzu+89Ob7uXW3r11t5yk1JSJzyClLUzf7u7unTj/67a99YzwMvArb5WSyQuX2eGtzcubc5OKlh6sN/+ynHj25cyK10+LTl77/h29PJuXRQipU9qDCp3YuXrl7//C2fff3Xzpu8+md9a/+zLOJDFGR3f0rt1/5xX89u3J/9vZHh089+1/+k3/YLebrm/rIU9u3vvtWl+BwkVfXVtiF2MV/70s/9v677924eduFktHAsqYMgIX30ifqk1m2TpMCEDE7CgU4dIacMXsfer9mAnLMZCApIWKWnFWLsug0KRK5YGboHHvsPaBgVlaeBJM0sQN0vk7Nom3KIZFDMBCAEAappZhSGYIBVGURUzZTsYykfXNEPzN1gQE4xdzb0OhBG2gPdnVm5pwryyLnhEgp5py0f2cF583UhSCSevwLmErOgJiyeu+LopgeTwHAMRqBCGi/QZo6RDUQExNBJMMMZtSvGwRRRRI1RSK3jAlblMzMiCyKS0g/EDOoyGQynk5nMYtzTAhJhYlz70viJVihx/mAgCqy873L7IGFyKCPtSAkESQUyaLinRfNKJKBBTNZ85kf+sr3v//t23dQgRFc4KKowDH3+K1hqIL6q3furvuVobqrdw5PP7w2rk7fv3Hv4Prs93/r1uHhtzd2ymx4Yn1z69x449zkqYsbF585twr0yad2Foa/99t/PFoLt683YeSf/fRD/+C//+2P/dWfxMJDis5MILz/934rvLR7brJxe/LwB+1emxbsHz7Yf3N8/szaR7dHrpin1pgFcGCD16+8uLa9uqrF8fGRAaysrMxmCwPX5Jisqwoe+MHiaOE5kA9JxRBztGzZLDJxni288wgAyMyECOzIIVsGMjbJBkpmIuaYu6Y1U++cd6QIyFCgw1CxlyRtWQ6IXBczmBJAVmKygoP3BSGKiOTMAGa9fENJsioogGNnZiCpIFYVNWVyKkvRCRGdaq7rGII3I0TseccAQo56d5+IqCJTX2YpLgQDIwMzqJumGlRgulS5yJBQJfdm4bKsQggxtgCgIAhERg9un6YqiNQb2HPOosIIjCQ5q6hoypJ7M4OZimbnluEzImbrr0pKSJpUTbzz2kdweg+nZjMhIiLuI3UiCqCEav1WrWYKIEoAylVgnE8Xn/nco3V9dONDG68NknWSe1gImkHOmZgbAF+Egw8+PFFOZl2skAYn1+hMdWZrczCu9M0bEOBLX/nst771nWltt16+c/ZA33/xXv7l10cjfOjM+vlHL3zyk4+fenij3r++fsrIrz70/M4Ln3tsLrtDDRaqoxsHbxxPjx7bmCeVE2cP3nn59vsvnb30I9eujLqDE34vdgUqiCcjFQGJvLh7dEAe19adGiC3fpAVJTadxlRN1tr6OPquCKaY67ouykHpR/PFwjnXdk1RlW3ORESmMauZ+swgvSGTNOeiKvoutijG7E1FFSRG58CUEjsOASFbXhROTmyuGvvUdSIpJhHDnqarCEbQdYmYicEQiKgIRYrRFNQEDcSIHIMZ9xguQlUAFUDsSw4eaKh9LFT7UlTrnVSqaiqioojMrjcDdqkFxLIsYZnxRkTqGQg+BBVRkZgiITrny7JgR5Jzb8ldUjYRQ/C6DG1JNmFHjEREINpl6dpuPp+nlIiK2EXvfUZBIGLsMwkiPUgZHbEtcY0kIv2e2rtmcu4roHuHcs8bWlbDlUXIOSE5QWeyeOj0+mOPXPz13/idweiE5NpUCZ2YqBkSsPcmioxn53bx7ONXmvmrxweI1cZ43MyTQSkzmR51KcFs3qyurk+ncTQaBSxPPH5Ju3R0uH/ldn3/3rWXfzekjZd/9omHnzrz7Bs35j/605+CnFwsmsIRlmF9w/n10d22Ksv1oh4+eml+/aB4ajTZKj/9ydV7lzfevt4EClEEe0McmDKiGgOgQ/ZYMPmSx8NqBrNm3hahCCsFs1vUbVGGejHFSVSXLfik3XDitItdjKUvm7opC4/et02rAk3TghTakSOfojh2jh2iEQfP1NTzIozqOtXd/OLGikkyi8xA3gXHoCJmWZZkTVUVEe85dl2MEciHUDKxpGVFJCJijj0u54EREZBMs6qq846LUBiw476dTjHgcgqFAAD95o8IPSKv3y2RiIhEsmYjYkASUSZC5N7kT2wxZ8lC5NomEiAyJROzPnyuiEDLk4UNLKsiGYo57m/k2OsJAGSGIZQpJjAiXvYypJQBcJlSEEPCEEJ/WBkAAzhmVX1QNKFIiGCiBmgKxkzEHJj6bnpr2y985vnXX36vaydUHJsAQ1AVIlIE8qxJyLHr4vMt0+rkd++/JcmvbGz5QaldjYzEyh57zPeJnZN3b7372Jmzx/u7dnYVZtFnqVZXnWXw8rHb7sL3Dt945Z2fv//i/+G/+lF4whywJTUm7NKP+a26mnYF+liHMycvv79/6cfnFy89vHvt1UfXV+TNva7yDWgsXAsghKLZiA29RJFGiACniUCRKjaIs6yYzCUCCsA+rJTqu9wNy+GwSGmeA2DBZe66yiFo9I7K1XKxqF1wvgg5a+qSpg6VRqOVvXv3rk1nWyc3T6xU7374/tHC3b23u31+vanniJBSKvyAmQ0NkRSzkwzARgjkqhCsrMwsi7VNkyWXVZFUNcfYRTT0zKoCCEyMhJKzL7yZOnSFiPQbp6kyQ7/g+qvk0sZCy/mpqiIaoyGxGSKwc2BqIirWk2O039nRkID6PzfmjArOc0xx2abX6x+klgyAVVWWRzaCGTOLCZgxO7V+eqCmZioI7gHgz/eTNEPtaZcSMyKyc6BmZjllM1NV55yqQs9rJiHzAJQlZetMETBonD/56PmU2nfevUujKpuxDpxZQ70CBNYaOBayCwfdeij/9d0PY1jFo7g6LiNDp8iEExoX4DxoMOcnfrxWQTvzXb55/fjhh7fWcjXrkN38s7tw+rZPq/6tg5v+cPF7v/DGt1774C/+1S+PuDLQ+9/8o5vXr9WVndkLZsXB/Vs3r7zU/oWfq+yCDM6d2+523n9xUIxqsjlqV0LjMBImHxZBjtga5mgggQ9ZEyKAj+zZLNSpLhQ0DzC0rRmEOme17L1bpuHEQvA5xy5DUTLlUIaCyeYyH48HHMDMMKSVk8PtgF1sFpk+80OfeeP1azc+vBqnBzeuf9SkOkvMdc1cMKhBZkYg33fWSMqiGRCdZx+gKAYGqGpZNCXCQaUp5awkllUXTSeiqsjeA5ojdn0ckEgBgNFEBJfdjrwclxKZqveMiCIJwPqRI5MjACBBWd52+3pdEaFlgguQSFIiIuxzVLI0AhgsCyaTiIEx49I7ayCgjpxmVenDVWCg7FzKKWpHzEv0HWKfMA4h5LoeDEc5pRQTEhJQVuntwDn3/0sUES4IlipWdg4kK6GRLZ55+nO//dtfEytzjAagMapZ6zOLOWMQmGEeH7fPFmt73eyDepFiZayucG3XmqpFqFE61gXE6C1Jfebclu3OV8+cfO3qvcfObjaL40VnT6wVz5eYP7Hy4sHt33j1/T2SteFx8zvvyF/8YVspEkiXBMJ4//6NVdqqwv4GPFTeu7F77c31R54pmi9sPv3IldXfLReJYlgTgGkyFVMmnJu16gtjlwSSx3lJia0N0A0Gbw50GnCgPDVN2dSymUVVIpQYEYkYsmBupHceoYGBa2JiJIJyOm+NAQn3Do+d47EbjQnnB0cH5f75nZ3iM883R0e///vfapvmeN74EtRayVIVwTMhIqgRcyBmz0lym7JnT0QiSkSeyfVwdRf62EmXOl8UqpCy9mVYjohE1f6dcCohMTMTL11PDwTLBxYTWkqMPSKgR6CbgZpjVhMyIO6DCLBMGvS6ESI5EpR+seYkfQLd2RJE3eP8lvEXQORlRhYRs4imNBlPsuamaZxjydK/ogipaztEapu2v4GYmH8ACk8pMfPSjENkWZG1KL0ImUrhCBU++dmnbt29fnAEvpIcS3CtK0WzI8SQTRyiKahcauj0ZPDrt96/vYjJ+cxpbWsHyau3zgQ5D8y20GHTpdie9MN3bn+08vjFiZf27v6FH37u1PbqMzRs999evUBHv9LemltVDd/44NonPr0zGq6ooWX1w0m1uQl712cDozHoPPq5u375rUcuzr7/Oy997GPnu5LjzeNcuaw9Nj8HF6OR4ShEwSSGQqJhlleoPPbWHt6np09956lV3W+HAkjomLJISorkVJVIUhQz750zEBGpm7YPMGU1RAo8UDM0HC3n2wpqg9HWYvfYbDYZlGDNrZsHg8EKopjlppk7DsPhuqnGrlnMF0UoFjEVg7IaVPNFbczes/RdmmiIKDkDeQPruoaZRlXZtl3BblAUItnFlBwtf5xMhGjsaYlhAVBTx05Vs6pIWrqxse/pzcDm2KOiMYKBmTEzGiIhEqacl9lCRDDrj1oz855TSsTI6FStLMsfWABzzv33AVSJeLl7mjnVLKJozvuiJyN453sIly0DV7ZEH3H/SYioz7uICCICQq9KAJpIJPKqphLHo/DQ6RO/9pvfKEfrQC0BijoXGMsCWyMRQLKSTx40FyWkdrqXZN+KCpxyvLs3820qnRKrwzDWMBxv63jdDU+dPnN68tCZ77730d/47/6P//zv/OOPffyHmrXAHx7t5XeHN2p/Lw6bhN6NsTp9YtUVIUbAZGB0MJ+PyMHQVRceoiyb5fD6i5fdzyxe+Pwalzd2fuqh+ltTSOoXINOMXWgbMsmYm4SEDAqKQINicNDq77VHz53cWvVVPlgkXxSWss+IvvSeiHCZlUtZVBXEpJ/fIBGzU5XUIxRVgveiuWd1IxkD5U5KFwChaxokK8M4toLk4iJ5IEI4uL9npuzAe/aeELiLrS88ETRt3bTgPcdo3vuyLIE5Z0uxAzAidM6hgYhkBehJGDlnWO5wy2EOAohoz2PRrM4xE2MPxzWQrMg0GAxSjjmLigGhqoJBzyxlJVHrR3BEREs8nCEiM8bYmQki9ywY7RcQgJkF70XUloFcXBJiEHxRBMS26wBgMBx2Xacmjj3AMkrQiwP9md4f6PQAqBxj7JcvIRORQJctMxcOqJnv//APfezGlRu5G7mJJ2BfSI6TZNEslxh4xRWZjgu7dLfbBjqU2aJpI4QyaygHe/t1uz8dMCs7mSQ5nBZmW8PB/O79K7tTW9n86L3dty5/1GX8tV/6lZ/8K3+qYTh18flulRZv8clXbuJD4+aubp2b9LMfzHjr5q0Y04RcLa10i4XP42pFL99Pebp5bgdhbv/+o3amCUJcR4kynSvw2sqgLPP84L079sHxyrS6e5Rens9fyoePb269kPzv0rTh4LTy4LuUisoYicgkq0omUiIUUDVFXU6kDRQZTYmBQbMDB/lB/wdDlAxIbUyEOhwNuybN6sZV3hRFiMlB1lCimeYs5agoyxKCtCl1Xeu9Hw2rpml6AXExn2kWAGDksvBEoa5rNRuOxrFLIhnAnGbpdz5VNct9yD9rYkIFyDkTgghYb1ZlB4RIGrwDBo8sKTKCihEAIqsoMGbVPpS+BCiIIBExaz9NNc09iYgKU0spMlNP4V5+OYgZ0bPLKAjcJ2BSTn0/fU6Z+yRxVgIUU7XkvO/fXikvX4KAD8AvwZla700hVWBjnqBVZNPz51bXxoNvfWt/sDICNkLPTETqJCBCuVIcT6+1vLZ5r32k5mtrjub21t3ju0ot4GCtGvswsSqEYAgJ4dihP+wwdVvNFHebr++9ut1M3/wHvzTbWH39j169fv3O2dW1g1F15sLOMAwG47XxidPt4v7WzgkAh1TPVRdX6zC/7widiTQuzWWmQzi4d7R/dX3rMUMDqWZv359Ug3mJw9Xx+OSwPLmTZZ5irs6e5B/a9EpyZfqdX73u9/jz3rePVXhmrdyvK6LWtYylCXWSRNV5B4aaMgOigpEhPyChmjL5yheaxQByl63HfKBaBo+eve+sM7PpoiFk55lUiVwoHQBW5RDQkAY9WnzRJlNlJmYWgbaxnAlBQ/BFUBEl5qwRxCwrojEAgXoHwBhjckTYb1iiYtoXOCCZpuWWjqY5iTnniLivHCXArmuTZCBgJEJm7un5ZsS9yY9hqdOaap+P6tp22WUJS83SQMCMHPUcAQXNokjEhEUIqtIjDdRAcrY+I2x9TzAiIgefRQjYBET1QZ4LDVFErNcUVEMIXepUFZEFSURAOybq0vT5z3zprfeuNJ0bDDnmOqYGCUpfhrJqsNOieuyJZ4c7O6tfe5V2qo/OrD360jvDsTtlpYtN7Gb7+3cKZQ0+qzKitFE7ffHNd74ymqhIsT7YPrZPDE790+bu/QpXr+/R7fkbdfeN3/7GQ65oFd597c3TSqcf3hHILpR77300v7a/hZwWqRoUGot78/nDn3z+vTtX2ru7vPNUZ4rnThSPXgrkEufYtTTr9o8u+5i1AcIqAR7R8WDL/uxfeqGsq3OnH1n5yU98deZu/41/etTlbjQcNQxOxPWEDSUiLHx/SKHDmGJ/S0AlQjIyDk4zMjMzpZTREQKqaBaZjIai2sUuq5ahMJWmrn3wbdtqTmbWxRRCcN6pWhGcZOvvFUoEgGLQxcTOp5QNoCyL/gfE5JhdSklEM2Tn2YXA/ZjQu9BfOhEw94h96qVNh6gAlnIyS7qc4kgPhycgAvOBAUAkhxD605bZ2/Lf7GUAcs4lMQDgpaqaVcXQUImYiAmXuieoSdc2YP1/vKxBQCIGYEBdslGQnVMz6qFItuw9R9T+0mlm/S/quu63a0ICZe+qtonH8zsPX9ryZfXKq+8EXkkpVaNiY7iyMtkYVhvj4err1w6FNnV7h9/63viDxe0vX5pMttfx+ifWNx6KTqDAssKtszHmrqundV23cY8tlkD7R4915WS3edT5DsLw+OBPCtzxMB5Wh83iftBFjmvDwSt39/3QD0fVqfPrBglgxEcxtCCjcb0QRL6xv0+q77z4Ggpee/v9s899GZKU69vDxz+92N2fgxA0nDowVT4otqRNMFjb2tm85NYGk+2tsLmZvbcct8abJ57dvvnH7ztYdSyCfYMHmllKCQnVjMCxIjtvKszkvNeUlcQXLEygkFJEdqlLqhrKot9L0KwqCunbOBUHw6H3vqoGfTJutOypQVDoaxqJMaekmtixQ6cqTdsxk4jUTU4pIRAtS5IekIMQnYn2dZ/ec6/qm5mnPtmkZsYAfcOTCQAwPKgw7DVSJkcGQGBqzNhvW/CgiaT3GDC7/p2uKIikWQi5CFXKHaio8vIR413fv+p9YBSmwgx0GW/ts1SGiD/wPGmOy1UHaH1dHTMRY09a7C+jBmVZZslZsoGCSJtjGKye3dn5+Kcuvv3Kyy888Wy1sjYaT9hXIq7tsJ7le3e7oYyvHx7f3b3z4++9EUr3+vGN9WtvtkPjZngy0IwgVGsXPvHZWRc1LdqU0v7R/r17DLJV4uZ+3WK9k1zyqE4/LzR1lGMsrfhSWTRD34CfjVIDWjqwkFlRieH+or1zQE+fqkuOFMW5jRjiwSElObhyA0CcjD03cfdatzvVqipdgKriAkarJ4v1yYkxlRNXjCugQQZok4TWszKyPPX0w2/+8QcZMfpkeTkLdMRiAIDsyFNRLxa+dGqgJkktOF8UpfTQG0JgAoOqKJUAEEiNCMEsmxKCqhCSK4oecNnLJtBTbUTZMRLlmAwI2SFkUdH+yAPuJWozQHJZRLrU3zb7MaGIun4gBUA5L83dS26VGRAu1yP2vy8KuWcTE/XhYAJTA9Vsqn2ImhAJAZlZRM00Z42xJSQFBRJTUDFBjSkygSRxjns9yECQmAglZ7F+euZUDIhEDAEzZEAjWBamOiZHlFT6jdr1fyuIPVgS0HzhU0pZs5lZ1jY2xdCff/jRkw89sba1UoSj0xfOwgJjCiocOzw8WoxGK4MyFEWxFurC2d779/3t2wdnH8fdim06AyoG63n/PrpchdA0KQERDhewaAqeMjYHs0eLzZC7aXKQyEJZdLKo5y3iIFNGFzp1ZY4ISbIjXFmtiiFHFSa+c/XWUDk23WRY7HWzEZQ+G5Q00aHenHZNjW6MnNbO7qjo6tbGYFi6VY8rOJmsAIjzDsA3c7l748ZgMto8sY6WFAmw3jw93hxNFlbWlro+BaSgWfu8LyLmlBgR1ABBDVRFDQqiGFOX4ub2Vs55djTlgDnnNnYDXwBgF7ssQp67mHoN1TmnZkUIRSja2PYtQqZ9gEG5h5VSlmyS+xVl/R2ytzUxOzAU6SlQRmghoENmWyJQllUMSByIzCxnMTABAMDe28u81EqZBYBEQXqmpohj9q5/EeWcchZnZl3X9dfNJUOi1yPRiMwhipiBiRhg30scYowOCQEVGAnR2NAICftiDFVAYOcsKSJKVsOYRftYoIBZb3dlZyYOnUIOhUs5GeP69tap8+fGZ3YGNEkS9+ZHxGFn42wxekdlcNTmtdUzxTyz1rFRxoFM3HY4efrcapP2ZFid3drBfXd/ei3X8zuLOXeWpfbtnEdbOcUB+DyZHL537du3bn2+mWHXDFMlQTm2oCrBFRGBfAJpLZVdvklJkgL5tVPDSTiR84KdvXnt7phkONW4TtZx7MhUBl1epHhz/zge3S5PIiQaPTIqzj4cygFXATER2O7N2db22vvX7u3frds9Sd3iqU8PkDMIqHm2PBgVKLOFMUSHmLIsn8Upi4iWBSfMSTNmYnJZMnvXiWhcEFIIfnp0nFICgCY1g2pgZm2XmJ2iMwYk8t4TOzFl53LOoioqnlyMMRRBVFNOAMBV0TaNae66pEAhFDElcmRm3CP8RdEMGZ3nbBK4AAPX25B5ObmGpmlUtX/NPhh2GyKUZci5twBpv+CIWEDJ1DEqLsV4NVBgZOzv4N4XvdYD0PNalRlDKAEADHLKgGwIhj0eSAmRHeeUVZWAsmYASH0RMiFT6LoI6cH7xzIT5ZwAob/7mlnbz/IKzw6bo8YU1nZO7Tz6OG9sHEW5eReg7QKTgEdJ9QDW3BZCY+XW7aOR+vVQSfLT0aigRocWx9vj4//iJ1YtXZgeNAuig3S4b6cOfHMQ7x1IgsPSrQFgaatF57qgm889uiHD1tKdm7fWmppdxUIAJmQaRK0rU4HD0dWj+80w+On8xObAlZjaClTPU4FDbReL5N2ZzYf85vr+3SuNtKcunf30F54sh3ela5k3iwEPBiVAEEOiwcHu/Re/997G9sm9mwf1LA4mk5WdQRgSaDLypAkNh2FjUA1j05GD0pddjCKSUgyhDIEWi4X3hWYbFkXXtQ5Rc2I0FWtjW1XD/gkrIpolctc3HGWJxEwGOadellTVnHPvJstNQwAEGGPsE0giUtc1IpLzDhgBibkkVFEgYEdokLOI9I56YkABMbDeVGdd18EDXE4IwbJK6svwlnArJiqKsHweWf/o8SqgEhE1hLDsBlMQAGbqUbDee9Wls847ZjLnvPehadoUs0juuoiezAwBRQQAIiIxGaB2qceqE2LP+kLEHCMX6IMPIeQcu64pSu/9MvbQUzT7J2RMUu1snX/ssfWTZ1Pmw6O2UjeaKE5MVJB5PCpYpk3tBnXsFgfz1HI1jowHBweOQjkc3prn1RxXN+JuvUhMoxX3/LMnJ62dxxn45vj4WGU36zzLAHORVPyJ1bWzz2w2u/N7t+N76/tXunw8dzMLwmRmGcjBQH1n2CQrPfjShifWATSGjmo91w2LnZNX9m5eOb62+sz2ylP+1NrTW2fWV8+uwbDIwgHXFJxhkwWInRgz+abRC6cuHhweqdQnzkwee/qCK2hccGqBKhSuUZ0rh+S5OzgaFpOcc86Zmb0PIgKgzjlmKqnMKZchICGS5ZSS6erqWgjFbDYj4t56ZmY5R+8dIppqTErkEFCyiOSYly99UGOiHm1nEJ1ziAiqTdtyCN752EZnEtgnVWaOOYOBZ5ezpJSaqGq5dIWZuZQTCgIs77aDwUBF9AH5ve8BVhUwVLUeIdmf46om2VSEGCgngCXYhAlNdTkQtUwIoXQ55+C9KWWxLrdN0wAiEboyKAgjoQKZKhh7FrAlkpC5f+33910CLMsSiUW0bRoFERRJmpIyE3IfohJQWd08c/aR5zdPr2fuYl4wyc4K5FaSWsYWXFH4gcV9w4xhPBxXQ4xr2KEdMMCFjfW6Hfuwe2HNzRd1lHuNwYcv3zQ9fJ26EdETT+zMaP/MmZXtKghmwYNR4Wdts7q9UQ2l6XZPol784vlZPNHem3c3F/lOWtzu2n2Li+5+llmYPrQ62mjzd48Px49sAzBj2SyO79e33EPFk3/ik4+d/dTw5M5wtQjjkfiyE0FlxpF2Y6BEvgZwCqAkYt365uj177/59Keee37rlNyN+EFsj7X7WDF4eJLqtju6PDhx1g0mrqJyUBQwUszknOTsvU8pO+dVtemid4zkUhYyhWwA6JzPWXKuicB7l7OkKCEUTD1TSZl9ySFF8Z59AG9amIjosrxLwUSAMIkggPc+EPmicOgBoXQeQUU1FF7E+tE8IBMze+fR2tgaIQK54L2ZEbGBqeqirlUEsY/fmuutJD1wlKyPUz3AnxoREzMiZMlEuHzBAZBz5JCI+xtJSpKydrHRbEREzP1DUslUsvOuV5LQY2CXNQfnlJd9ML0KtxTtFEEgJ2XHyUSRHA+Q1BHmLDlKUiiGo8eefGLn3Mnjrq7bWyiKhk3U2aJhDo5IaZFjO4t1WTQxN4bjowJNtCJyAhL3uTgYrK6WLKVPg0kqurmcaB8+Tywn3r92H2t3/cq9BbpXvnN1Z1hsn5oMtsJwFLdWB9X4iHPMmXZFVysFrkePhI0nV1Jnlrxk7qZd3PeH82O5elhk9NP86JObkBtvQyJ7+Oeed89eHG1NqmFFUhq4mB002Tw7ZUquFeOE7Dgbgjh2nOyoGgx+5Mc+076/d/jtrlgZ6DZMPraBDdz51Tfe/cN/84W/9sOWu9tvv+pENJo47WKrYEVRqKoBsHO5azmgDw4AzRSRVZWZVcV7T4RNUxORSOzNPc75vr2kbTtVK4rKlpBbqMph6jpCNBXJAt4TYoHU19d3XSQiIDMwZFSFvp4ia/bBgVFWgd5LTjoYDAA0xuhSGwEQWGXp2AByztS6uPDedyn5fgGRAYBznpbQaPtBMhMAfaCUkqoCYcpmWayTHkspBt57MQSzMixPYQAyFUQkIMm9SQ8BUFQRyBRNjYkRuff+J9WUEiNlzeickTqjHqWWNHPB7BmdO3/+kZMXzlshu0cH2OFk1StEgVwELYN4lwAYDJi6lKZqwy5VocqSw3w6F5RiSIOVE5qlPqzv3Z6XZbFSBed8WdRVScby3OOnVaVNoyKEDz9y+4dtTPmDF2+dOXfmmx/cMMif+dzjZUlFSdfu3Dt//kQX5007dS4gxcGKL1fETuuZcrPLq67yn1j55KAqc7PAUgRk7YsfH07WRA06ULbEc1dsUTdVV5J4mQdOhSabWTdcKyEdQ1o1r0p67ZvvnKRT21840RQH8eqdG//iA/6g3vvaNx7+D09XZy/80f/+n53/qY+FalBwwa6lzpCJiFJWQ2hTErNQhBgTIwJYjG2vHKokaQQRVaGuWzNgJrXUF5ciYiiCiLTdoiwLQpCe4qwgaCkJEqgIk2OinLOZMrJjJ32NtKIZIgdmUsTCewBUNVUVyWrokDRJ5QL+P//rP2tLfA4+AJJY3+3DzH0LReGc9x6AVEFVmHl5X4zRHjCf+nlDjImZRUzNlm4jImbuYZaDoog5Z1UxAQNHpCKAJCreh/6J03+5AcBUCx/MTE36+2U2XYJ91MZFhQZJuh4lMNkYPfb049VoaJoIO1QJ5IEi9hkCNcCMCGBMrkNkhIFK//dc+LDwHlQl5w4Rm0Ujoou5jgajFNvgXOxmWQ6rUUKbeW9VWYjkoigJXIqGPrYR7t07vvzOwWiwQ6wffnB7da2KUb785cc3t8msIXCgzByQvQ+DwXhSToZ+OABfGBTBBjOpNadRNYGMygLQOsTZMYT10d61d8pBAfXDhZ33zl8//nB0Iu9sHFLGDBVmXUzryfZjt//w3bt/9/fO5lPtaKO++V67/8ZD//I/uft3v11fbj72P//U3/9r/+aV2WA4iJVVRVU2bRtjAsReGAKEnDM+AEAjU9vFXswUsRCCKbRtW5aVquacmLmuG5FcFAUASu6KwgOxGpJjNXPOpdgF5v6ylkXMlB2bKbEXEe5r7x641ajP94ZC1XJORREQMVlsY+vIcd99wUyIFLwHxJQTEcYuMnO/e6eUU5aempOyEKGpEVMP4GRiMZCuQ8TU/w67XmDqX3B9zrjuOnKut8YgYJ9GBgRV631x3vsUU1GWiCAi8sBHAojBeYFcmRsIZYLkKYJYnZn82omtR584x4WZHXtSzxpYVI8BjYhMXVGWWUA0usCaymwAlssQyqozvl/iEMmpqZqLKZfFMKc8HiISxmhtN9vcWJ8eFZKsnh9ubk7u7x137fHqSuk9jEYlmI3dYPuJtReev9B1MJvPfuQrT965e//y+wcbO5vVIJkOCEvnhj6UYVBWwwmFAhxlQsOAGhJ1DqUi63BRuLGSdDIFLF/8h7+KN+V4eu+L/48/vd/d12xnzwzffm2vuR6ePOeeebw1nQO4yXZ5+7t/0P38B6Pbxb+2tz++fsLev+x/6uLR777b/U69/X/5nA6K9WJtcHC3zRPt6nlTE1PTdP2DuDe9hRBi04YiiGjsovRFfiqq6p3vEzVd1yISs8s595FJVfUhdDl5JQRqugacV7NEuRdZmZDQPDvJGQk1U9t0qtrn0fuERr9ARUTUui51Xesch+CLwZiAekQ0kEHOGcw0pxBCzimlzMQiyRQUGWwZOX6gUARi7okAhCZqDGRGqkoMSNDFzjlWUYceDQtfmllG84UDWjrrJIojh4RFEfp7rXOMCCIpixCSQxLRGBsfvCIMgOepW3hHtc5uHBYFXnzqsWq72D5ZlX7KFHtbgEFGNAZWU0TKCnfu76u2zjmWcSe7YhRceaj1zvbg5IntlGYpzc2IyBWeEIGKou0UbW0yWG/SfeR75XBqcSjG5Thg2OjaUcppOJxUoxGRIJnpqZTUhbi5QUR46dLZZz8BzXxuWb0rOZR+4F1JFBxikaHviGcQ76FMFM0aUzMc/MF//4/Xd9Yf+wtfXUCzfdTIb95d//wja6dOv/vdW9G80vTD4+Qno1feuf/Yw2NXNEoQGzv8f/0v5ZvD/yHt/6v57s/d2vtLK6UsZvVvpuozz0+eP+fchC+uxzt7o6S1ZTA0sLIsETHnDGrJVERAZLFIuU+VmTJiCJ6Yc46q4BzFGIlITUNwKSfnSNVybl3wmVk1c+mIyBvlJEBUNx0AiKaiCGgonayvre8fHaABkVvCaZgNMEtWABUjdkU5EE0x5zybMjonD0jSMaUihJyl6zrvPaqqGiD2TUuqhiiIRgiDqogxqSTvAzMlyP34B8G8o9XVlS7Gumsdec0CaszsHIuaieYumqmpjKuKR3x8NCUj6BEUZstwXMomlqSLlkNZki/35/Xh9P6ibu8fzg9r8N38z53euXDm9OShE7w+K8tDQvT0gJWGvak6IRCzv3d8cLB7uDI5eeXq/fFQNrbKCw9PylKufbT36qsf4sc+VlZYlAWTmmZCQmA0KKuuXuzmti0KJl+MhydNaF2GCnllfUi0wo4AVDWJsJIytASG4MgK4EaxrWfgQ1VOKgoFB0Zn6Cj3PkIICIhmxCoyJQEvq1bOd7/3Nv/mh93mndmf+ETYXl00flocP/STDxukOwf+emPbx82gXC+5hVAIMncjrODGv3kF3s2/2e5+p9nfqAbfnu19efXU+atarp7ULQnb6wph+/zYfdNr0slk2CU5mh4DMgOZQgjeO59y6sEk7FwfqTfEJrZ9qtaHAGjA1HbROZ9Fq6psmqY3kzI5E13qOQQpd9751DWxTT54Yp8z9hCOw4MD5xDZGZqIOEdmppqVlv4e7z2TQ0FE8OgliytDYaaIVhTeObdYtMxLJ+WyAB2RA5jmvl4JAJDRO3LOEWKU7J3f2Fi/e/sOMxNgW7fEXPgSRIui9N7nnEWzWD90FOcQiIJ3zvkQ2BR7gSClzlRVNISQUlLPAtSae+v92+98cGMRsxlFC4Ho//rlzz91eAU/vX44uHmGIVMyI9Gl95SAEBQBUJ1Kvb3lT5062SYdrhRFGYLHG1c+qOeL7a1Tjz3y6N07B9euXT17dutjzz8KvjFIBBmB1dz6BpnNwUiNzBRZh+wBgln/bBVE9BSYAMCRGfXBPEzIhfeFC8GXHj2CwyVMUBmQEZgeNF9kS0hZsGIdEjR733nrcN6OEdN7eytb4yOehz/33Nn/4AW0w04zj2noXLL9nOVIVgRqprppq71f/N7qcHvx9DB+7TvUplnwt1L9qeqhozgKp4ZhWEj03GiBnVbjxWJhSGVVgZEZppRFFAhijPgDB8nSaoMpGyKmJF1XIzEiOvYx5bIskEh6fglA6pIjR8BmgMCOIMXonXMVigEAiKqAUY8okCVmkZnNMiEG59H7lGLTNF1Xex8QMIsCUs7i+heJiCKiSO5rctqcENExV2VpIipasO9B/4DYdRnMctaUExmZds2s7el2YgpNNxoOU9sBgKo458ixInZdlC6F4EVJNR8cHAIgs4s5OfYG1gOmM2RVQYcxJUF349a9V15/t86MLiiTzbrPfvX8hUfqQk/o06OdsvPgGQoiRIQHLnoGQAAGS2ZZwURC5bcfvbA2WptXhe/aHULNkg4OjjajffyTn2ZHahEMEQowNnOAGcD6wuy+1RCNDHscNhEt2cDLzRoAkXr0KXvngnc+mGcwk744tM9PQWZDQDFEVTUlRsdQAkDr67JuD96/fv6v/8T1f/F1f7vpuvbcjz/1xI9+sW32Uteen4TUDHPnjhudAAXbtzjAycrRN19ffevwziMPz05Wp7Y3Prh1dV6MA58mXpnv3ji9dQm4uPfrL85//1pXUkqLOO9cUXjv2y6S84jQd3gSYc9Z8d73oh4oDIuBGVS+yFn6QHCbkg8eAPbu7znPOQk7RoS2XRCz8z72XfLM5BygMWDPS4Rl+ttxxpRiUVZmmlIy4q7LkIQYR4MhAXrnmrohAGLLObsHYQnsQ0jo2MD8A85tzrnvGumXfM7LACYAMANaH1LRpaE9575z8vDwCAAdIaLG3BJ7MazKgSVt27YHMvaeasnJAJIlhL5RGFVUsqLSqBp1KnE+fe7x84PRaLY4nKVWDvLnP/noxhe3UbqIzToTIPjeDctETITADs3A1Ag8gAMyMXSc1jZ9SgOJyrCaUwJot7crZMkpZ0kFh34UBWZmuWdT4IOmOQC37DkF+MHSBADovxVMHDx775xjv0yq9OJDL1r30AlTBe2ymfVdH4SOQCVy7IoR3vnow63Hzz/zn/307N037s8OT2SV8cQAMebs19bY1c3RcWUbo/gjF7DayH7QChT3f+M9lzZfcs3du+1obcPt3dm0cJrHR++/Pz0/+8Sf/Nmbr79661985y4UVLfRSg6VZFHNkiV2iRyZ8yIJAESSqhYhZBHEPgDC5LhtGiJm5zTFEAoD69LyIWuqhGSWq6oiojZ2MScwQKQ4m5VlYQZMzM61XYuMRISZEHGxWBRF4Zzvi2yIyNS6nKqilJwGVRXb2FlGJic5GWBOIi70TQvsyBkYgJillPpuXQDMIqoGhv2XDBGZnGBWQDVFhtIXKWdTNeIMmCUxLMtKNGvXRNMsks16DDMDoog5th+UBJoZGoloAknNnNltrK+2i/TU4xdVFo5xKuS7tainY371VDnGEEQaJHLM7MgxIqOZESsisAUARhaxVA67rDfRBXICmgKCqcuZRYNbyseGaM73zmsxC4ComntStRki0APbwIO9k8ixY+/MMzkGAkMQEzABAzIAZEBCZM1ZUwIVInOuQg6GHkBEG80tg2NIsenWP/5U0nvDzaHV6IGv/92v6bX2mf/o0fndGYyrF1YXq4VeeqTcuzs/ui0n1qn+cJq/sV+v+8u6aA55UqxQolmQ24v7Z47mp/5PX73/5rVb/7dv7j36+Du7H7JJqStq0Tu1nmvUHzEivREJEFOMWYSZzSxJaroakZ13ues4x95DpmpmGR2jKQIAY1UVOSd2WHFVWCkiABhC8OxyykwuxezQR0lt13hg51zK2Ux6YVNUnCskZVMxgxyjI+f77AaSa5P0JTU5t6bmfEhRwZQIGZAUHLIpZJP+gsiIoFl6uAUxEzgkAMqiscvkHZKKGgEQOs0ZgHMWNYu5ZTDnXe9syqZMTA6T2FKKMnBLdBSXDhSRXAl4fDQ/nNaz1LWFg0W9KNr1N76DgtvTE7unzg0mY1KJwhltYMiERACMhNDD3MisKMuyqZvBuGQPpoTsRJQ8+mCskQBNaTntVzNjM8eAhuAg9D1ry/QeSpGhdY6AqPDowDPlQGgAIpYMFbKogjIxMkWyIMJNEjPzzM5npw5LsI3EBwT3Q0sEKXkqYKTs/Kb3ZMnKySamWTt8/ejo/rfaLz/iN8Jmng8X67denv6T/+Xy4y+cH9DdC3Bq9w/fr24tbj9ztofELbTZHK906XDPFsVk9e4vvfXm1d9Yu/Ts24e73JYZV5BrSsrkDUhVwVA1Ft5V46prOyIqva+bZjwczecLFQ2h8M7llPuC55QzETIysM8qJuaY4qK1iuZ12xstl/YJJkTMkjn41EV2DCoFuEFROOYY43BYiohzIWdNMasog3OhSLED4qTS5QTsu5wdwANWggp7pyIA1KeHkVx/nJlazgkRkYC5d10CEaHjHDtGAjAVMDPpopj04jyYmVpWQV66mfqjmIjUTCSnlJz3xA4RTQTA2C+bmDkUknIbe+VVVLrg1IXN9liO09Hj64PD+emrVzeuv//6l36mxTCaDLZNxKRJIs4VaCWTAzZiNgtJ8Hg6X9taz9aiQzJZekoBkMmMDI15uYWDau9xeHDcK+GSHNQRi0cgKHxhCBooZ+2ShAQmglnR+sEEGSh0ucrYIWQHJTtxIAErmmQgbG9Xizp7zbY83gBQCIABAOG4C48X3WJaEmiL7WyROvfuSytrpy4dtt9//c33v/LTnzl1dlLP5nd+58WNAd6KrY6qiffJ23Offv4FmZ27MdWb9ejlxcrnnr+8Stdu3WxWNt1Ual+vFMO6mYVQApCoEELOMUVddhcheeeaeuGdYzdUVcfMSKYqqoPRsJ41zIjIpvbgRIV53Wi/ryAzcxfbPvTQiXjVLDlb7qmGqYsJEUwjQoxxNPIA0HWtKwpE6LpYFF772A87MXHEPajDRAAAU0qEjKiSczbj0rFzmhKYlS4YWNYHhijEpm37FKioAGBZDGKMphacizk75wwA+EGtqRkzO+96rIOaoUHwHhF7NPloWC0Wi5QjE6vZYj41oGKwEqrhvLPD2hbz+f37Vz2vDwftZ4t2oH7oyfmyqAa/8PNf+/jzjzzzsZXtE9sYBi2YCKGYSo2uca408eWohD7fBP2yXBZ1I5HZssO050ngcrCm/UcnBRNLORJihZWVgSrumerStLzQQi2DEdhyJAImKUrKDAAwDCGkyhqNVRh0C9y7fBh8Wnlau5yqbpSKKWvBFnJO49GwGo86TYtbeyvnvvje7ZvXtwYT6YZh+N23Lt+9H84+HT73M+Vnf+KnvT+g0s3euudePM6ji/7UWhXacYcH9fGN/ZvnEU8kawYWTp4ojjXGrK6glKZet6VqukiMallUmZjM2tjlmIiYiMy0h7iLZiYXuwQK7J0vKnYuSkTv+nuNqp7Y2Tk+Pm6bBv+d2ricZFAMTVVVnEMwCCE498AcTNSjIXpMQV03qgpIKafeTpRzNrXADlRUlNg56vtVzRDJo+9Fyn55ZZWmaxiZzMpQRokMgMRd2yEh9noOwPra2uHBUV3XhISEquqINPe5NU0pMbFjJsCUszJ77yv3b/dmNY0xxq5DRHaemdGUgGdN/ODytY9u7e4eL96/91rMQtPmv/2bj39w+eav/YtfPnHq4pOPvHBiaxWHxf/0G7u/+q+OLzzUPPXY1sefPff0E5unzp8Oa67goUqlVnVmVdHFPCdgwr62E5cPHexDLYh9emr54obeCMv93dR6ZUmiZiyL5r1bN7723QuPPYGPnZRRcKJIaAjKvQ6nGDC4AlzIXLEh6MKH1fr99rV/9I2192R65a2tv/7pc3/m0zLdRzUEBSZJ3c7mmq5M5h/emjdtcXr00Mn1i//0r770N/9+avjRF557/pN3x2sHrZVlDgtr0PzeNy+PW3fb718zmKxsj4RWrVsZVhspjXaPh8VA7zbvDuN3TmN2AZpuULgZKRgyYhYJ3vdZmsJX5Hzd1KgKAFmzY0o5FwGjStcka8A5l0XIERiqJlIx1f39fUT0IQAhayZAFUDGrImR+oO09w/FGPt7rQEwBxFQU0ACxOCLnLMouIJjjL1PoEsJVJKRmjhTWbYr9D8xROe8mPbrjx17dg4wdbFPejASAgoognUpEeHxdEreEUGKCY1K57L0IUz0LhRlyf0nVRPoXS1dU9e9yZ4IrTfypY69R7KyKA4OD969MX3/6u29o2MBJufRlCiMq3jxPI2L09Xni3l98N5rv3rh0VMbqxcefXz1rZe7m6/Vf/TS3sqvHp062T1yfuvJR1effPr0ufOTk2c3xzs7wzCAYpCzZZVlypuop6v1jebL+kp8UNH3gwpvUwBEIgNkMQCcvvbB+rtHu69/K332kYf/1BcAoxIBAThERiIkxEyoQmXGjgXCoL1Vv/q3/tXFe1vN7MZY6fAXXj/7pSfqU+2oHokvhI2yIIphee8br2ydPc2b42Ebm4DDk5tcwPbaPMNA6zXgTixbGMT9nL52rdCJq1ZPPP7YvKkH1WByPD04nmrlucPUxlfPjv/gdIDOuaxNBS5nBoroRBXU2rYDw8JXddO4CkMoetIQAopmAIiSyTvvXeqSinhmMgTHxG4+narqxsbGbDY3hJTa8WhASFGycy4mISLnfdu2zvveEd93JMSY+sJmAFAR7z31ZbJizOzZMUEW6QWpXDejsnRELpQhpQRgYGIAotnMVLIBOOaUsxABAQGJqCs9SGYjjxiCExAjcMym6IIzVYKeckemikRVKNq27bpWRAWYeOmcBwDsj1RmBC2qyvnq7uHsO6++ee3O7t40E7FzJVhGy4Qkor7Uw0P58MPrP/kTn9/cKr/0WcVi1h12v/D//lOvvHr3j1/66OVXb3z44eE7V+WNy/d+6xuH4/FHG+u4sQJf+qEnv/KlC+PNwZkzO4OVMQyGgAxAAlkMIbNKRgIARQBDRkOhaOYJFA0JQ85qKMxjF2U2vbeBXVhd3f74s1z6BC3G5Afc+CrkgQG3kKrEial1VljILb79t/71zu3xrL35fjiMo+aRW930yl1/dh0FrEikJSWtKw6xvfvdD5/4iz/bgZCyP5hL4WUImJRxQ/2sDDk244rTzd9//d3Lc9sYXzjFZ04/euOj9yahvBIKEhh1LeX0hxdX3twalb1tdOArM0Hx3hVoMaOxS6o5J8WMLqu6lHIvzzvPiMzMyMxEZlb6AM5QzURTzj74waDqumhm3nkzDIVjZDUjJMliqoJiZqEMzvuu65zzjr20XSA21F4ZdsGz55SSqYn2pI1lOlcBM8CTT1y6+dF11/fmLpkc//9NtPTvsI16bY8YU+oAzHvvnSMkMTFUIpdThv6xb+aQcsoGoFka0SxZwJTMuUTEoODJ574tCZCgxqK8d9C8/eEHH1zfmzYJfUnsCPpcrAGiWM5Zy8nA8SjG7q13XnxER5Ph2kjWOsLhwP3ojzz04z9+cV7HG9dm77x56413r7z57tHNj9qDvXjjowSw+9Kr9y6/cfeJZ8Znz6yeOTe6cGHt4rmd7dM7g7XVan0CvgAgABKAbKaCqMrYeV8CBIDE5s0GCil7eOTn/uTxyddmx3rmiS9kG0HYddWxAJgoaWnkjvauhnHlYNKSggvv/o+/v/796e0sf+/gtenqaDI7+vOysXnleOOHz4olNWekBjIsJje+/ZadWdv55JOp20W/0t35cLC+Wk22E1wHnEM+851viYJ89uPNd/7glY2f/5vPPPTs//jn/qO7f/ydz335s3L9DifISGlz9N1n6HtSh7bB4DJbcC6LFlVJAE3s1DRmIe4bWrQsqy4ZEXrvARQAvA8GSFEYMIkKGiAIWaeZAaytAZEZDw8PvPPEziQDOhdCbBoACEXBjlNKKWYVU1XFDIDI5IijJETw3qlZ10bHHhCzRcgRez6DaFJFdoNqkHJaCvVVVfWFOv3AoDcWIWJVVQDQu4qWw0+RonCOHZillMQUQNlh7DqEpUJuZgQ9NAl6HwA67mfuINC1jXA2M/YWQrHX8uX3rr51+dasMWbvQ8n9a8yMCBF7jxYB5YLWXv6Dqa+eqMLw6OhGETpqr5fVvG7WmqZj56uqunRh++mnz/yv6NNt7W/fPb5y5XJd55Wt8Te+9vbefvH9N+5+6/s3CKAqaTzG1VV/Ymfy6Mlw6uz25pmNcxe2Tp6abKyXfhSg3ACzN1++qWlnc6fkIKGSspij26TV8dZPfnJTzip93OECbB3lISIp7V3FN8y1i91OV7eNtOBwuH9Pf+Xt0frJ97cOX/v6gu7zxPm7uXnu/lyBtGgteAeozpH6g3euXfjpzwsKR7VRe7B7j7aNfNccnVtdeW4+16G/69bzR1//xsNP/+ynfvI/vfGtP/jy5756/COfTa4pd07iW1fE+8MY90pDG5IBOqcxLto5o+vqpvfBq1nKGUWcYzRISYH4wRTSADAuau8DE3UpAiERExOqOl8aCPSY1gJDCF0Xi8KlzkQkLhZ9uC1L7mLX+4ZFxDmH1r+kIeWkpkQoktkxALZtqqqKHUrKhQ+aNQRXIPhQvPrKq0VRuH583W+TveuJnGNmZu66TvtUsvW4pCXOLufY1HPqDdZIQNR0C0SUlJz3/cfCHv2l9oNaRlVNSRCkKoumaYYrK53olRu3X7m8d3//CNE7RiYCUNNEzD2hQVT7PmgkIEslDV0YnT372Sh33nrtnc985uSifm9lVYMvAFyXuigVzLPnovR5Z8VtP/vJpnGbW499/Omjv/Hf3v83v/ZHL33vyocf7N+5XR/sdVc/WFz7sPkD8UWxV1Y4GuL6iltb5fX1ldNn/P/6v/y5t75/eG7nhx8999jxdHq4G4M75MJZKH2ZHLWOXya36kvE/AEMTrG2EROo1917+tgJBA5oB79/ZbSfP/x4OPVTP/bnVyb/5P/76+3O+uy4bu/NFAqG1rfFYpZqghXNncnZZx6dHe16xKDa3K63n7303of3KF/YP7z80Z1Xx3HtRF45/Pqb9LH/ZB+O9P2Xu6vXytUfW3x02w9Dtpy7buGkzDCh0LHElLMZuaBiGQwAuja54LDXKVVQ0JNzRUDEGNs+3eB9kCziQQlyigUEi5EBc0rMTs18QBcCqlShICAKoZ+2d13bdx6yYxVgdo6pHziJiJgQE0EPWdKYpJ/VdV3Tdg2CeReIWMXMRLUJg6GZuR47m3JeZuXNiqKIKeUskkVEenkopRiX/DFGgCzSZ4+AneOCvWNiYlYRIESgfsQnKsu3BgCCDSv4zOc+/8Ybby2i3NqrX3/no5t3dkWrwhdq1qNvspqx8z3em4CBkAw5WBfLMD6ey9Ya3rxx56g++t637v3Ij34htfJ3/4df+uynHn3isdUTJytXVFnHCeIC8Oa7NNsdjNbEsp+ltWpx98d/6od/6k99sWvj/u50dnj00fv7167uX7lxcO3qvaOj9mBvceVm+8FHWM+mH39m/Bf+yrB0KydPnynHfvdAzIqtEy84HtTt3ECsXrT13K8NnPPH9/YO8dqJjfvFKDf1oLt77JENXLI2/+GtFKorodl/8Z1Pf+r5Dy5f+ebb75Q8oHspCnp2wnS4uzc+e/rgxr7bPsHBv/+NV5/63GdiDe3B4caFT+R5e+P2m6EQcjwnt57l/r2DdZPDX/51/1vfe/mttxd//Efnh8Xdg3lb12tVubCZ80EUc5Kma0JRMrpF13gfwAw1EqEBmhraUgyezWahCMPhMMaoaohqiE7VAXpfGFgGM0TzDplzFy2l+Xxhtqy87x9AqjoejkUkpujYxZxUJJtKis4575xDKgeD3AgQiIhDE1UENEPvhiqauhiKIqXsPItp03UG4ACx7wUX1d4qP6/rrMqA3EeBmbu2jSk6xwZ9CQwyERA4B2KacyLAsgyMlJGyihlYFgQIxGJqPYdboODRoKii5FcuX3/7ymGXrSrGlCibGFpWQURHiGps1LIipkKqRItFdI9srf/nf/3fzz59+PK1+V4pQw1hFYFiufbP/8393/367MLW4IlL/rmPrz/61LnT51ZKNz64kfY+un1itVpd1LX56tzTH92+e+rx3bIanzp1As6Vjz33EEAF0EGKd3fre3emu3eObt04eOPV9774uUsGx6PJzs6FJ+7ce89sMFmhNt5ZWT/jGSWJVW442ikGa+D8eHtjVWBv/7ViuKvzfTt25saG7eLGcXf5VvHoU9f1nt3bvRqGP/4TX33rxvU0czhPBlOCkWRev7g14HL3cLp9+szi8F6hYTBavfPGm7o2DpNVO7ydQnFxbfXs+Gj9DN77g3f9VZj/nX+Qjg5HU/38T3zlXy0ODtpyXudZ28S4WBkPVRHJqvFwdX18eHDQLTKbt2wCGgJJzsGXKpI1lYWLXTtbNC7G8WCoks2sGoyOp9PgGRG8LyWrIwcgWVPddQaoZhy8iSJiTjHlDEgxxpyF2aEhGRWhaJrWcxiP1mLsUoqECFklZ2LqZXly3LM6AQJi8h7MBMmiSIyJyWWJ7gfOOkR0D+RJZOp1azL0ZeGgoOgBTURBgdh54pRFzYisJ0F0XfTeh+CduaZrgTwA5JxMoZ9eU3Dztv6Vf/lrxWgCopq6wWAtpcxLri8gEJNTVVEhx2ROBToDZ+UAZ3/1L/+Jpx+36NunHn484NlvvvLB4dH9e3evnXsaPv7k2ptv5ZdvtS/dnP/K7+fzp64/cpZeuPTQI8+vX/zkicvfv9PmRqKkebf2qXExCF2ck2TjiJhQWzaH7E6cWDtxehuAAADgK5A6Mz9Pr/3Pv/i/e+ThS/OjvLF+slvMz547dn7IhV/ZWR1sb9bzqTOb7951mTU3OQEdRZseOWg7KKdv7Lkje2W8twgmne7tHu98bOvLn/vk6Df+uG4WVOdm4MpG0RH4weHetce+8MIHX39psr1t0N1/++qJp58RM2Y7F8qVVeeKkR3Srd96e30/Qg7JVbDC12aHxwdMLt3fP0Yk58PxbFaGUgRmd6af+PizTz7xxO997ZvELNmMzHtmTwjqC1+Q7zmhm+XAMVeFPz48QsIcu8L7vmAqxSgio9GQiGMSRARyaChZfPDeOe8pLxZGtLK22nXd0fGxYxYwEQGw6XwGhCLLDEXKGRjFxLHrL6w9+t05JMIlBLG/cFZVzBHAOVry53svYO8xg34g2XWtc75LKYswEhgQklGPRrGclYljEnbI7HrPckyKjnqrM5hBr4obAhI4Yk+rftO54tknH7uzNz9YNMyFSe7vAwSsoqICiFETq0d05rWr5YufOPeFT69A3qvbI5T9yU75zHNbj5/96fGgLnn483//v3rttVe++6333nh1/6MP5+9f9W9fxd958ebmr914/sl3/vO/8mOzeX3+4uNFlcdrU3DsvAMhkGHOnUEQ7gxSzt4k9d1SiADYIeHP/McfOz46bpuj1Oa9e3fao/k7d/5YU4U25vcmp04/vrZ+drS2crxoQsI79253K25yX/xhBjCEGF+5WQ6Ge+Pu7q3bw2oyDXhnb+WFp5/ib72tbeTo4ig4tkhl1+4u7ty8/It2+8Xv/8Q/+YtQ14vF4tKlHW0OTp/Yvv3RPKowFK/+7V8ZvtzkyXAx78JCSi5vtbNFGtO8rtuO2anFoiw8eyIcDEavv/7GjRvXvffEXk2AFFXAGBFi15gZUt/jR6LZAjGZY19Wgyya0gNvl1cmCMEjKKIg+hhTyqnv9UWwlCXmum2btm0HgwHhElFTlGVZlqqiqojkfZFSaprWOXbM3tNgMOxiMjXQjMydKAAyU4wxpQhGpuYQ6UHTgPXQUeecppgBHTlJmRDZEKVvDeyhS5kJXKDee99nMlXN1BQhNtE5RwRmxkgGBs4TkeScQUZFkJg3V8sf/cqnfvNr3+5iziCqQshMZIjEKCA5S6FkLK1vwcozG4PRYJGh3PCnuJ3N9l9b3zldTNYqWpf23Mb45I999Ud/7KsfTA9eeeudW9/73q3vf//yB+8e3zmobn9tfv2DX/tP/+zzR+380rOPfP/XX7n24f2dc5NzF86fPrs13hE/HAOMQRFUBTiDGmUkNHRgIXY8GA9W1whgfPbhDJAEiMC6Os5mnaSPiPa67Od6tOKrsHq/HO7M7++6qSi6ND/Ol4+PSi4G+MIjl9784MpihNeu31t9+JFwflvu3E1HqdpYTXDk2LoFHf3rN+2ND8/8xKNNbL/5t3/z2Z/6VMkJXcjor33/+k7i/W/98eLFvfFiHCvHkINIQZQKaruYp9LmXNfT4YAcEYpp1Koa+lGlloio7Vp2GLwjsZSi8wUahOAVeh8LOmaPsL4yIea67kQkJS2LUkHMoK4X02MBYBecaAsAjhwxhaIwk3FZmGGKsZhMgvcG0LYtO9fGxjnvvU+S67ruUjJTQ0BHSJZS7rqmLAam6jmkJDHJdF6nrGLSxu7E+hoDuCxCCG3bjIbDlG1ZwQaACNJzdgDYEESAnWcvmsBMcnbOe8eGho4lZc+uL5krQyWSsW/9Zibi2HX9lVRFMqrkmGdxfTT5oc8894d//FqcW88MVVVg6A2nbKhkaOSVEogP8fjwVhhP2K2W5c6oOLWwRSfvx+T99LodrQ6KR8pBMZq88NkvfuyzX5nF+s6HH9195eWP3n39/ne+c/mXfu/GB2++1zZ2FLmkQeWa9fGrJ7fDw49MHjp36vwjdubC9uaJrdGkLMqBG54Ak5SOiEQsE0hdm3M+gjpLpN6YimpQDEYGA4AVBD15dgWAz+aVBbTTO8c69wBhfuOouzU9Wh1e35+eH43OTNbeO97fmOxokU9+6tn2n92p78/XL643lgp2u9+58ejdlU46f3L17T98c/3S+fOffjKDHd+YHv3KN9xvXbn7/t3VU5vtxYvp+oJTcnVuPFw97Q8H1MzqNIuj8VDUptO6KnzBQdRyK1g6M3OEVeWd9zlFAucD5yzVoMo5hVA0TZNFuphmi8WgKgfVoG4aUWhj9sGLJKJ+ztQiUFmELqYsioyi0jSN84RKms15n3PqctcXhoMBoqvrZjJh791mtVovGjBmx4SM6Jqm2d8/rsqSiYqi6I/Zoqi6NCurcrK6MvZBuuhEVcFMZDY9YnbMnESXMXXEUBRgllMC62sQc8qJCUV1MllldLv790tXKmLffwyKKOKZMoh3XkT6sXdP9Cxdkc3MuQI5zhen14ZPP3ri2y9eC8VIFQGyaDYkBk/IrbfQuSKycKzTcVu3iL6inIphgrWAOBhtCBSguWs+mM3fOZp5t7dWVidH4zPV8OITT+Ynnr4FcLw4lnoBl9/54MpHt9977+6NK/euXZvu3pldf6t+8b3oaH+jGq6uXi0KePzp8ty5DY3lpWfy53/saYJLLqQuXh9MJgA1YkegoAHRZeEsBREjlsmmTiIWg90bN3Fg7qDLTUap2xv318B+Z/dDePKxW0cHD2+OP7px+LkvfOriE6dm33kXtJArh/SZMwQUbWX/n//R3u697ksXP/EzT1184sTQr19/7eXul1/d/9plO8Byc6taWSs3V8qLG83bt8ZQvb9W3j01OX741OG9GRsV49I0ompwhXPeHFXBF8zT2dx7j+zMrG26nLKp9pEeSpkIUxs1a04GTICu7nTRTAvnc+4AsW47VQ3eeUdFURCBqpaFV7N50yn0qGxnktEAUXtIHBE6wrSMoxGoOmYHOCxLyUrMXUyLrjN0w9EqE6rmRZtF1TvKOZfBlY6b+WzPO1F1oErMSuYcM/mYkmPu1z8TOe9jjM456212AGVZIpHkPJ3NQKEoCmJy1semVESZHBjElHqLYU8BBwDHLjhWT9PFvNNYsPeaPv3kY1FHr7z2rnNlWnZ0goAhKKoCUDZVdbt36/u7eTBuh7Y/Gp8fVxPFa5Jd1EggA3/SKIl1Kc0X0zfmx6+GMBwOz/iiMm/D1cFwpdo69fznv/I0AIHUN27sX796563X7r7z5q3rV+/f3Tu+W+v0Rlg7c5rL9V/6hd/783/5uU99+anLL9n+4dE/+YV/+B/87L/3uc9/iTi5SesKYVe7gQ5GlUGjdoewMlwhgNnNWxuXzs/2pnzcdvMsl3cXe9N4aeXoxu2Tz17Y3b23JfzSa2/fOrhbXL/3LPLiezfa//jTZdHdvHr/6np68h/9uce++ikPmBfx/V/63Tv/nz9cuTJf3dhoN6qwvkrDtnv/9oLk++no6rBuzpzxjGcXimCDtbJo0vHRbHN1WPjQdrULLjCD6rAsFLDrYuyyERqY5DgZrJhqX1pZhqL0IUWJkhTA0BSgi03wrlk0oSh6mT0nDUWYz2ZZ88pkknIuiiKl1MTofSWU+8y6dy7lBIT9rKgI3LZoYovF3PomYkRi6GKsBkME62IHZkUomLHnMPRAkNzr6JK846Uoj94BWm/aAwVyjP0tchlhRjVVsT5Rn3M2JABFh6KiUXs2XQ9sAgNNSozWD6X+bcOBiKAiIDEaFL6IXdMtFtmiaALhPkCoZgDOTI0USNUUyO/tTT/84P6zzz1/tDefHe/n9dXxSutcURTDJPc7OEYIRCVjNa5WTC217fzwQ3WwsfVQnBWG+5KOuED0zMxnHxqffWjj81/6OIDU7eLW9cMPP/rg7vXpzasHNz66/akvXfgTf+b5g/21c48/8cpv/sLl99M/+PnvQXt6OAmjwfaJk6dXVvPB/Y+mx3fW1iYbmyuAe1gfRaBwrdFRI0cRYp7N5tXVfKUYvHHn3tmTDzGEBmmlnFx5/d1y45Pn0U/HfvCta93dhCeqrXH62b/zX3twu+++dfzdq7N//lZ4c74RBvXORh4P8PT6cDI6+v6d/QK+vji699Cpa4t69SgZNZDaT1+89NKVDzJ5hxoYQTMBgmqUziOhQXDM7IYDbrpYFIWhNE3rmUUFAbJkRFSVsqySSo/Pdt4H55soAH04XlQkpTgYDruucY7ndV0NQ9d14/HYOz+bdarEBDmnrouIfSmyjEZVjLEsy+Fo3HSp5KBmyMrOtbFlYlMtfCFZs6ac89hPADHG2LQtAo4Ho/l07gr2Rmj0g0YNZMK+rAUNcpf6xmZAEk1dp2bLPg1ERDLvPRHHNoIoPpj5OM/GpqLMTAamPeZOW01kzqMj5NjlUA1rzddu3UX2xIWlbCaESGCIfV1tNhRVt336VDFZGa2W49Vzx9P709k7TZucL85dunD9rf3Z/uEjl86Ji66gLtbsSj8aVG5nNDmZ0qxpbnrMTsQa6YjYQ4dKPiCVzq8Mwuqjl1YevfR4L6+lfDyvp2uTp1/++qI8XbWNrWwMIbanzp84deqM9+PTp3fq2Y0xXPrw3gd+X3Mz9Tyzo1YgTI7T/suXq5lp5+KV3eZgNnzqUrp9PBxUIabRxoqU3Fy+X2GVcebZ0bXju//oDx/9b37UNov7L723/4vfrC/PYBHKqx1urkeJ44s7ftF29/evt/Urp6vdam0x4O3IK+P1aHozHQ6cf++ja7tdPeHgPIGCWEbi6WwxGg7KYdW2nZoyEUAmjc28QXaE2OOGTXMTuxCCaGIBUXWOfQild13dTlYGPfSfS8dIdd2YpuFwsFjUVVXNFwvoY/UAq6urXddJzmZQFD6mJJLVYNYmALScMSdHLkvKWRAhSwreA5h3XBXl/HgRhiFUoekat2zpYEQ6qusM5qjoAxsi2UIo0JlKRpO+cL4YFrPZHIyydEVRSO6H8ksADi3NZb0Rz3nnTFVEe1AvPIga2QOiDrMDAVwucYEMZeGfe+Lh3//2K9GygTpEVUuEbEbqxChIzqEdHKzEd8uj03c2To83t89AV9sxHE0P7u/e/NVffuu1773z9HNnvvrVTzX1nYcfXl/d7FxRj8uTCC2UcTR+BOFYNZNiSFFERDXHDqyRbpFRgDzTGLAwLlzJo9GamT/92PrunQ+fePrjo8nvnd0+mTptZyq8f/neldJGh7ff7+KtJ57/0cNbb5WTbnbYjIqORwM5upv3ak+j9veutfemO3/6c3/tzGff+toftc3CjdY8pfWV9QEsdESRXVWOm//plct7t+zYDl+6WixgXE3iyIsnXhmWNMwvXtXVlZdW7U2tDweeEshRNxdBQAWccFHHFNGv+hGqpCwNxqIoGXF1vGIqdRfZc07ROZaUh1XRtG0SBYAuxRAKBCyc9+yUg5omSYaYcsxtapqOAjnmYVUNitLMFou6zbkTC6EsyyKlzIQ5q0VJGMXEFx5VCGBUDGKR2pRbBQISVRXNIETUr4VqUPb1V2AWU+M9nDtx4trNm8OiSCJHR8ebm9v1oh4Ph13TupSTGRShKosqxk4kA1rpi6ZpkCiLuhCIeHNl6/jwOFQ9ItSccyKZiFWBwNj5nJO2HRE672JMOWXvfe9XzQ8avSxnxw4QBA0ZJWU0ffzMxtETF7772kch9CMQMDNF6b1FCFBBezFV8Nrum9/YvX22WPnquXNf2Nw5sz3antzeb19/59ZRvf7iy8cfvv/tenrwyCObTz29vn3CPf3CuQvPPepwgdgS5SwsviDPSOAQnAGJofSes4VItiSYj7tWAIPQ/mq1Vp3lc2eHf+tv/6UzZx9hv9Z03B3O9bjbPziUjUlb44czG194eG/+st/eOuhye2U++Ni5Y7y60fnZH9zynd195Z1vvfruqa2xEIyHm7HdQ8HJWolH6F1ATj4H+f69fLMbFpMB0UJaf2LLZjVcvt+W/vJG9eJGvOVspVyrBNtFnQGpLECFkYKIMWBB3HQp5RCCOVKT2MVxOSTnFbNmRTPNlqMIA6ADkqIoQhEIab6YV2WVU47ZnCNGil0sy8oUvS/a2IGzRhYe8P7e/WIwLMpCsuYk026acyxHY5UUU2xT9GWBZgToHC8WTQiFMwxZck7eO2SOKYbCI0BP9TI1yZmdQ0Qq8N69XUYEg5zFhRBzTJJmnRVV4UxB1WLsEGMfxmCiNoqBUwWTnj0bHDoRYSbVZZi2b4LrqzOyROvZNd73nFw1EUVVzYK9HyrnTAzOUx8G7L30YIbp+LNPXaoX6b1r94ACqBVoljWiKWgDsk3FKNsWZmps+MpR9737b5xxrz536sxXLmx+4qICKWA0vHF/6qB66/369bdvff6Hnrj4VHr75T8elraxulpOoKgIA4MfqGZNyYiUSAHQk8MRmRCCaYIcQQ0Nu8XCYhbd3VyZxundwk9GNBqurtG298EDrIA9IZyIOcKzg2pj//07N//OP760+eVmMKoX2QSGNrz/u+99Y371z/xv/7My+LViuO+PFm3z0c27a9Gfb82pLlAmJzePT3h69z4Vni/tLN74aOgG17bx/e3RuxOcgUxmyrN0WEIxLl0bNUciQlR0pKJt3SBCWYW+z8CHUJahmS888+pk3DStEOeUybmUJaXUSlbAEEJMab6o1WAwGFSBiKlrO+eWaOyy8kZmKou2iSmFsjo8OlpZWy9DOT06brt6dWOtS7HNiZ1zpstzl2ixaFPSw/mRZK3KcnVtpWkbQgy+ZOe6NhZUHE9nzrkeqWdgSOSJjX0XEzGPx+NFU4cqdF3Oqg6RidRAU8p9k02/vphZRVQ1BA8m9+/fK4qi9zf92+ETGCIW7FWiL7yiAaHn4ItgklU1xtibCQCxKAqzLKI9OiJlrULRxU6jIk6/8MKlpq2v3j0mLFCN0HlDM0ioIw6hKLtmviKRx1zQpl9E/9t7e3/4rv9vfgpC6HKygjrALqNxabDy7e989KWffMHR/ntXFjc/uHbm5MonP//MR9dfocrOPXT63PkT4hQq5z0DWG4HwKQsmYKGipAMhAduiAyQV20950YymDCmXc2py0Pi4P3COzQ6GiNllmKt3T69du+V6wWMncuVxEBFN2/PP/zwaGM9xa7QioP34/Li2YdZXF65KgfHnBHDsIjZPbS1aBu6P2WBa5vu6yO9mxo+4kFZwjDklNeMIwiVAcWq4WA+mzNz7BmbYLl3lzsnORuAIUwX81B4I+y6CECggIhFUTIqIamIqa6vr9V1nWIMRZFiGgwGIjKfL8qySKlBYEMqB0MwizkPhuOmaWfTeVmWZL5t2zZ2zoWc86AsU4wxx8PjKTteWVlFImKom6asipxTXTcbGxt1Hbs2mrbMzM71MbWUsnNcdy0YeOdEJObY1t3CmkFReDNXliUCJIllVYABGBFx1iwiXp2ZANjKZIiWFaHvZLcHNddZsnMsmgbDYmVlVHdNjMkUTcEVhQF473u/TH/Cq6qpIZCAkKPBsDSQSIGgq6h74amHbu+9rIiaWF1Cg1JhYXmdqp3JuGqmXgGSEM4jdoNhNRyv3tyTm7vdpBhHq8FRlIy5c2iL+Wxzgrd2p7/+G2/Vh2hy9Mu/8aEahyCj4ctf/NInDg+ub2+PTp3a3N7ZPvHUpXLsVIXQGAE0GnQAZMCqTpCNy57/i1ySDQO+YDAUuIl5Q/KNjHsImxpnC5vAm9d8OxfajkXVYTN44tyf/t/83M27H509eSodtmU1OHX+RHcwXXv00uRjl/ZffW/oJ268lm/eg5du4KTSyr+zUvwR1UlXPFlOXdNGVRmFMue8MVm7u3vHOVIpyqIoyqpLMcbYQ0FEemo7KgIoVsPxrEspxqIsckzOcQih7TpCCoHFoCgCAJSTFWauuzam3NezEGHOEVFTVlXoK2X6sNtgMDDAw+Mj5xgIq2qQumRmdd0AEqDLgmqaUxqPBybWJT04OvTeIdP+wTR2FkIASqZGSiLGzCbZgQdQdg4BU5fZubWV9Xldl4NQ1wtHTN753IhJD3BKSGI/eNigxS7evnvfMQPkHrOovV/JjAljW5uaQajrbj6v25RMzTuHauzYftD/BgAIioiMCpJzIuKj6YyQB2FgoBmak1vrpyZrN/caCoVlKwSo5KpyK+DuX758PiaoQspCogUXFnPOZTXZ0HykNtaCeYZDbiLPj+f07KWT5y6dnHX7WbUcrNZ1exRjEh7FlaZNv/hP/wjJF4GwvfLZL2z8F//3s2KsmgWFgBiJEQ20z+kbCCgQoohDjQirQFtmBLiGbAV/PDe77K9EaGFxf2UGtRSkNWsXI2/9yA9d+tmf/Hv/5/9u51OfvZE/aG/Oy0A10KBeaJfl7Bo0+fCjG9J1xdAnw7cL+O7EpbX1oH5Qchfb2bRmVWbkELrYVGVlhPN5XRRFXdcxRwAzZB8cZY0xF6HMOfnSIUGMXSiLogij9Y179+6KZRADTzlLlozsF/O5974aFMSGWbt2wc55z31ifexIRBSwSwkMY0ygECVVVekREMAxD8a+bRvikI2aul4ZV2LaxW7e1OPhyDIMqmHwHIpisagR4mhYMPk2do4pdsmxB6J5Xdexa+rDhx+6UNfNfDZdWV1FTYuFAQdq5vXseApiKaamaRRBTGOMOaemads62tI4bKlL0ttG1Xq3qKlmyexcSnk2mwNg4UPPhBGVummS5KZt66aOKbYP/unR6DkLkSPHizitm5xqz1m/+LnnttdDjo1jaErIXU617pKISS61c0iJxLkFo6H5pj01Kj//48/HcTtwHJqikEHpitXgHr+wtrLKDKXqCLgwSgTAEGbt3BiL0TCjS1RMO8lkbjAwBY7mO+UcJS3aPJOElkXtGOgA8NigQ8DYNUAJSAgHbGtg86ivmLuuuJB6X+tjFSEKzqiTiG1bHjXf+Ze/XmyNu+NjBr1x+/bqyraQXb/3/vAnnyj+8pd//ay+99T50caJ93bKr1+qvr0J97rOZtEWHcRUeX/u5M7aZNTMjkBTm1sXaG1ltLo6QjIk847H47Fj13RdlIyODC1pIkddTGrUxbyo29v37nVZomRDSKnLkvqmvlCW/z+e/uTX1nXLz4TGGG/5FbNYxV67ONWt4kYdjrADhwucETbKtCWqhFSCUkAioURYgCCTHg1SAjqIpAMNaNCiAzToJWAlaSSD03aESYcddhQ3bnHOPfcUe++191prFl/xVmMMGvOE/4M5teb6vvcd4/d7HgVY1gJAXTeQsUgXE5pdllpztmQQMedsvdtsN5dBqSUTQtdES2NWTE2nNU3n0zB0MYbtOEQXbnfXUtg7Z8kgwDxPzhvnTGvJXtaVRD44ltZ1MZd8fXW1217d379PufjQffX6jfXxeDzOp8nWUhCRicgaY79Ju3ljVJWsscZe7uDBWUYAIm+tiOacL+j47XabczFgVLXVqgDKXP5MlcmNLzckVY0xriWP41BrXZcVkapUbLDI6lq39TtoafTlN3/927/3z356ejiZ0AE4WeUHvPzjcfho7nat5CAEuC1g0aHCl//Bf/iv/8a3f+df/XPn59u/83f/IM18OvJ8L8vTrLB8+bOvSkPX0e5mmCZal2HVdprXLjjnvA+Wtvri4+fGDcZ1mZNKI26GmQoDiKJwI6QOhIiaNQ/BgcK7xH8PCAkmo40giFoB9PcnTQJAwFXFkWIzMvzg899LP/2t/86/+fUf/8gSHubjszS5habD4X/9H/9ffvzui+e7u+PD+y9N/XIjBywNzbPbF9NpijdbQnaK+83mow9fvXn75jxNtbWXL29PxydjoIt2mtcQOxHpus44J6LMzFydc85ZAHo4nDabTVqXEIIPsXFBRKsGQJk159SaEBEqTku2lktpXRdYkVWMda1WgKbGWONLKa1y13XWUEnp6XAQBUDUVNdcbm+uy7Iwy0X1O3Y9qGIMqRaWSgix6wDAOWeJdrvRLOZ4PHVdb62wSAg+p+qcraVYco0FjZuXPA4jElolJGNKqdHZ6H3OGS/YAqIudrlWUfX/sjyqKiKlVCJqrTlrlnUFIObmnbPOcWNnrQLky4+VkMgYBBYprbLwPC+1NiIDALUWAEA0SLLWQ2tlWufb7f5v/dVf++kPv/rHP/vigPkaOpDwf5/OP47dfw7sX+D4AZsM68kzMcW33P7DH8bd5+7743/7l7+rv3L1J8ub3/9P/vQ3f/sX0N1OS333xaNuvY96SlMDcNYZEE/WxV4xs9ZPvvvR/WefCoXhetdtBnAWQBCqBQGorRDCDsWU+n6pXzkyxGrCIkAkBtUpCHJuYvJnjzZbJgBgNcaxqKH3r1//uf/qv1bOUzvNXzy9H/a7j37te3/4D//wxz98M2Vze/dzDvjp7f0X2IbQ7buhCgjBi5fXrgqQmfP67kc//Bt/43dSTqWUruu++61v3Vz/xj/63d97/3SIMZyn8zhulmkVBR/cMAyqknPh0kot11e71trV1T6tS9d1ZPrz+cws38gERS5kzMsokIi6LtaaRfRC+zbGpMvu3tm0JlEV5tZaSdlZp4SKYIwxhGVdaqsKWmt11k7LHLu+CovyZrNpXEFV+JvA8dPTyccQwgXhBMuydl3//jg550PXW0MxhvJ1qnlC67u+t0AkCNbZ1hqXeulkOmsU0Tm35HwBGog0kQsGmS5VfAUxioYMEqlSrTWGqEa5XuywF+HiRSYBiJhyAZCLb5FZRNg5qyrEFmxpWJkodnvNMnbl537p5fDtqy/++Msv3j4dcr1a6EuW/yNOf1fxXwndXzL2losipwjUUaDGf/QG/9MnvsPf+Esv/+J/5tc//OVfFvzot/76L6hxbz9/0/nbH/1EfvCDB15NLQvk0vVoA6oWk9Yv/6d/f353jvuue74xn+zp5Xb84Cp+vIl3PQWHUSIMMe5bLdSqAok2kkgXQw82NM7R8PjHX1Al8KQETAwimMV9/8VHn3z0//wH//BXrj7+o88+/cWf//4/+I/+wRA6E4u3WTWvzRgIm+1wtd1hEbOuFkhanTlzNYasIv7408+m8yml1Rr/B3/whzfXV4bcX/j1v7C7uvr//P3/ZM5rDP35OBvEDOCD24xDKdUYctGxmGWec0rBO+/6F89eHM/L4+NjF4N11lqDALnk87wMY5/WfElODn3HIrkyWcONFdo4jt46ae0CCE61iEjsLvPANoybGkItJcbYmIuw1IwKw9Cragyh1RJ8bCKVKxee07rZbNOSSm3O+fM059bWUq82wzAMOS0fffjyeHgsam0I+B/8e/9N46yolFaFxSBZY8S01oTA1IsHmxBRLtdzJGQRZvbeX4Db0thaW2q5WDOJqDZWNX+G6SAivHjIgkEWEYKU06XeSgA2eha5QBARqbVGaFTqBaGQhX74069/8rP7x3OOGsRIxfox0G+q+63YfZcoej204iQYMKXMpjXpwvW/+pfMi34DRX9+Q9fwwc9/dDTpMB3+9E++aLz58Q+++OKH7+vJa337t/+d37b/h5/hka0ANmzaMjZxiKPU602/C/VDs/3Fb9399b+c/am3qdu8UIyWfmMyf9K3Q14yT/X0o/c/+9/+P159FbS4FVnyighc2/Cb3//hb31oMv1H//SfdeN4c3Pzhz/6ydCFkuaW1ypirEdEqzD2AyHW2p6eHo21L16+mOczKyvCmvOFc+LIoLcsHIA63+Va1lrmWl7dvZgenrIoI7Hw1W6nLRsyuZVlTf0w5Jz7GC0gGtusm6cpWAMsOeftZteY3x+OAkCGgvd97KTWZZ7m2oyzYzfknMdhkNpqrUDEyp33yq22KorG+SVnReyNA9Wl5Cps0MRoQzBlLaQmxm5alsyVnDEXoauIiDYVUZmWpVR7Pp/3u23fx+ht38e0zEuuwQf8X/1P/hv8jY9VDBpzWU0S5FK88xcnLIACKFzCTbXUUlXVmW8EikgXXSKmlBARFJjl8hJXVe99KXma5uC9NygXfzwRAiEgAXlvS8nGWlYupTRuomABtLXLoEqACuCbt+/++Zdv3709mVmkj83CNi2/CvF3Xrz8hSVvtBwouwV66k2H481NOvL2nPOg4lU6go/3u09e0Mfb/tv7/IyfMM2TXG1cp9P7/97v7eyuCHvrv2m8IFQCYWdb88tp/bXv3v67/9Zn/5v//RYajLvhb/72s9/5L372f/rfuYeneqq6zvA4+0w4S8sMLLax77opLeGXvlX+nX/t//x//b/95PW73/7t3/7Zp58ec9ZW13kGgM04sIIxBDWrCBl7aTGEEJxzOaVaW4hhzck6N/a9s05BKteU8ryu3gdrvXeh5lzLCtad53Ve0rOb67ykvu/I0TTNArDdbEDVAi5rUrIxOBVeltU6t6bkXOiiX9alsuScvY/eWGeNGLOkFH04n88IsN1ug/PTdFZU5wwZW2szxp2mObcSot2GIXjHAOu6OmO9IdG2pgTkamvWWoNUc+m7XkRSSsa7lHOphbzLBWopiICgfResISJaliX4YJVAVNEZapd6sdRSQ+y9CSAqytyaqBhCdG6aZ1UxFykciiFzMYzEGEsuZAwoKKpBarUCqLV2ns+t1RAcETRh45yK1FrHfnMpcZ6P5+CdopyPRwHd7LY5Z0VrYgSRx8f34zgET69u+m+9+tXHc/6DH3725dsjr20F//vA/+SLTz+09q+78TfDuNk6XqbWKnLYuWG42RQrUHiciP/5vP7un7Ch9y7jdQe3V92rK//d63fngy0GhAE1cbLWGTTaxBsBtCU4LPHq139Nb+66r/Gq285P7fruVw+Pb8d/+maEeMoWS28nf84nLjUSiUixuLZkWWgp96/v//DzT//aX/kbh+k0r/PQ9e+Px0t/gVmtMVxaDD7nzNwuzhdmzjkbos1mLK1uNptaa2N2zkfrCUE7UudzLlaRS0NVcl5UYwzO+Vq5NKHSluNcufXDsKRMAKjQWDhnEA3BIdDxdO7HTWUph6cQozWkPlhnfYgtV5a2zst0Ol/oX85aVol9VJXj6Tyva/DeWOedBxJptWC6ID9j9NgYWQDROCeE3nlvrJTmQmy1ppwZVBqKyG6/r61Zrjj0tWTrbCmZfAjWig9V2Epja4zxvlHl2lRRANZSAECBrUUwyI1FUdfmrGfRbujWdWXR0uoFsrVMs6pekqMxhJzL5agaYzTGTdPsnK+1LstqXOv7rutirhlYpbGLURCOp2PXdZYwL/N2uxVCJPv4/knAoAkKylLO0yF691f/4vfXpj/+7Ks/+pPPciLs3Q/B/HTl/1COf/G6+y/cbr6V+qtPPn768nN3WhujqSpCEsl0G4+xx0lno48FfvTT49/5J9EOJsbKqioIqtLEEqABkuKxSRPKZh+n/9fv3VyPj8tp//Hz7hd/af7s/6e1ZZCW17wcdYWISGpYoCEKiCUiZ+ntsT+lX/31Pz+q++O3X6GlkuYQXc6t63oEKLmAcDNQW4sxIqCCxq4fhv7h/eOaW1PNUhozlnY4TpthSOvqo/chotWUkncm5caCLHWz2bTWRGHfX03n2Xf9tutO51PKy+UhylKX1opwZa61NtHTNKecow/Hx9O4HQHJOr+uaTqe99d7772KGGs34zgtC3zjTW0AFGyIIRKCRXbe+rh1QIXbklMTHazPtWTVLngRJgKtPC+rdwEQhu2mtnZx2WhjSeWSB6VvrEspaRVBNlbBWASIzpfaRIRbJUO2d9CQma011pIiOGeMsS03EbGGhL/xJAnCZcdPQNZZg0aEnXVEJuX8zV1K1XunokSmHzfOWiDiVqVVA9R1Qa0TkdB1tbVx3M7rLKLCFbEZkL6PwlVFuxBzabUJn6ctmb/8rY8+GLZ//PXXP/7iMKxg4Pi56qc/W/5xX/58P//lr8qf3z9jD0NrQVBzK1bTWtoymSEXUh2cwer9xvLYdDaiXhEQhUGkoHWc1HjbgW3k5fd/Qj99l9JE1rpnL+iDG/ndczJdWZvMmdY1GCuFGysEq0g2i2ElY3haryW82F9/+emXxmFWPj88xn6IMeZcLlpfsobIlrZaQVEtOQ9gnRMRs5bsgnPGszCo5Fbq6VxKvnY+ALZa+z4yNxuCVgVBZmGRxozGCQioLvM0DuOyLPO8XK7tzoe0rktO1lpy1lrrYuhjf39/v6y577p39++2mw0RXq4ffdcfDk+WyFh7PB69Dxccx2a7MYQWoeWUUuOWmiFF7UIAQECqotaH4GNaZmUha12M5JzUhoYuGIkYe2VWgZWbiF5I2cN+3xqjNWnKImBjjCLiiIjZe1+1Wm+MM4aic7bWb7DzzKwGgFCa5LQG75kbNK3CNnhWUW5kyFpTWvPeB5ALfvwSz7sslAbnW2td7Ew33L+7B4LD6WSt7fqeEMGY4/kch+E4TSA29jGMm/XwmGu72u+DsTZ0h+N5yVINFMjX1/1f3n30y5+8/Prh/HSaNueUczum5T9O09/5+s21+fyFM9+J7ltj/NZu87Lrbp91o3h5XG4SQlXGrhlNmht4rmwvH9Gg1DwAFLS4JO2juj7/kz9hhzj2++cf1FcfUpj4p+/dCrgusqRmfJZy9a0PHr76GtfiwAF49raZRoP30zxNx6Mpfq6n42Pox5yrKiGCj76qvHn3Lohe394oQc2tCqda2rHWJERoLzx/VhbZb4dUio++Edyfjo7MYKPkFVUExTqnSIBmzfm8PN3d3Q6df7h/39JCCr6LT8fj+8PTy/01ARgXwBgBNoasIW3r7X5kAWuMxKCq5Ozrh3fPbm/P83m/vwKEWisampeVEDe78XQ+OGNFdb+/LvkYCQVFuHiL3nfed6w0zedzraUUFnbBN5XgvnG1qYgKXBwj5IMtjI5Eal6yssbYcSuIDUBs5YpIBkmJrEEDBlFDN3Dji6gO9BuEGAiCAAD2XUdkaqkIKCC1ZiKDqBdFEQCUki+YEpFvBHbMzK2xAjNP5zMa47zPpaRatyGkdRXVEIL3rrXS9b3Hb8Dhw9DXUtdU7OhzraJ8CQ80FQNQha7G8HLXZbmbchW0CpBTnufl6Tg9nee/t+TlNOu7+63qlXe3Xf+K7bey+Vj9R0N/5e0Q7PU4Sq5pXo01FbVYOpbqFS24shTmFmOwqoFJufbS1n/+w/XLL01eNCW8fBSi6fG4v7p5SveqgpY6QijV3O0Xqz/7/GcNg0e3768mqYUbNdqMowpLrS9ubi7HMuc9KHRdjxf6eDSAAiAsNddknTXWeggplVqLNSYt+QQLIdbWFKQ0vmjglGW/3QXj8pLHcXs+n6/24/E83+6vgFmRQVsMXUrr+XSOz56xqrGWtVlrADHGmFJyzu13WyJ00f/Jj37w7NmzYRh9F32A6P3h8NQPvUFalmVdZudM5SyClqhUTmk2ttXWwECuRUFCiIgUvLfG5pxVUQREpNa1lNx1PV7w4UDW2WmaAABQx2idsxfxtzZtpbZpSs6a73z7k/v3h9P57JwVUWUWke1m04gERAVFNKVFVInoYiVj5uA9INZaAaDVZi+cHVFjDAKpQs1ZrSEiJNNEL5GW66srFQFj9vv94XCotV5uCbVUIkprQgPWOVRsjbmyMhhHgGjI57Qy18SmIiGCVdwMwZK6fWjcIT1HNsvKT8u6cGmcX7+9f72Yrxr/v+sTtmYf6g3aZzZ+J4SX5F80+61u82q/7dFYG9ChEqbagjGomhrXOe2crqfH9rv/DN69L+sUmFfhDsg3xVqr8POXz6Z5meY0kU47p1fmn/3R76+1oXHvlmM/dsrYdV30/nA8WkfG2lxajD02rrUyy+F4vLm9ZRFjrTATkjRutQ1DX1olNM+fPzufpmmarDHG2HVNXR+ttpQrIE7zEryP1kzHI6Dx3pOxX71+/fHHn8zz9P3vfXfNyzonZTBdv85LcH5epmWaxnEcx/F8Pl88ScaQq/Lx3d3D0+EXvvf90+mILIHs9bOb0/m0GUfvQ6k1xA6JgrdEyLUZNCq6pFmkxBiss+AxpdRYVHlds7AoAhKty3IZDW23OyRqzNIaEcYYL3cy6wwJAIC9Gsen46k0FhUwpor89PMvKgsgllJV9GIJWteEiCAqTYpUY623nkUay8ULsab6TSJExFl3iYCqamO4rOadt7kW5xwioAIzk8IF86QKDw8PF5dMqQUUAE1uzYVIBi6WPgJGFk+WwKa8AkAfY2heSdWaVgoqgUJjJaLDYXEhDM4RlJsNhYwxXH2w3XqLBtyy8uOS58qPh8PjnH688DpP1GpcX9884icUXlD8ELtn/XBl7YsYeytx62EbrC3m4SEi3VQ+e23SYB+nIgdta+AnU4+6lL1/E4sd+mrpZ48/Zmc7GrG2ly/vHo7vh7jJaa2leWcLVyZFwsPpREjS2n63s9Ys86KE83xkLn/+N371808/V9a8ltDZJS3WEnPdbvp1LefpFPuh1CTSYrcplZ1TSyS1lnUtQKYUQTXOrXkpdWXudturlh/mdX7+/C56V2qyVq3puq7/8suvui56H4wh7+zu7ubx4X3KJfb9zuwvjfZSUinZ+5BzuZQmjLEiuq75Uj1HQjJknVEQTthUUsqCyRAZY5Gg1Kqq1rvLOFKBDk8nRNpsxlKztdFYXNd1sP2ca0rZvnt6yrmEEFnYW4uArVYFIiRRvsAlEDHldLnmsjRjTcs1awEgFRFQacLKImqNJTCNWbQgqjFWqgISgVpvCmoVSUvyzl9a8kSRUMnQBQjdmFEQkRqz87FyVUESNWRU1Rin2lC08xFQHZmsLXhfSiaFpazO2xjjUiqDxQLJIPqoCFQhmD6ty1SSM2wcXG/lRXDfeXErTRhdLa3WNuW6NPnJu4c/bhwwt/npOvbPgt8b/GC7f/7iek/14Ysfnj/7F4ON69CeYAq39pjyY81oqCiTMWgg7rdlKcf798Pt7mbcTU/nEELs+vpeVBcffUqpMnsfc8nf/7nvfvHV67SsLsTzvDrvDqfT9bMbb41g+PrLN8ZY3xlypolwk+fPX37xxRfOBxFY80qkiqZyqS0551WJAHNjNdYai4bSsvgQ3r17/52Pv/X08P4nn3354tnd7e3t4+MjIGx3+1wLKYroZhjRYAh2XpfSTK0VANHaXFtraoytjWFJhHg8nvt+qKUyN+dsyU0YmFW0tVYMUT+65Txv4qYUBrKqIgBXu3FdZ0WIoRfGzWZ3f/9wf/8oANvRz9NBVA1CPwxs7NP7J2OsAbSMaL1X0JySd4EUUJHIcBMFFdHGBQGNIYNWBIiMNEZrUEBEVCR2gbkiEjcWYWMJGKSKj8YaInTLkoyBBlxydS5YMkM/1FZKUQAJzjYWQFWEWrim3MfBENaaWLU1JlYTwpxXAXLGCnCtNYRQhNHZdamWgnBxPtbW2vkUve/7UJmtd50LtZYKGYjjNngJrDV2drcZnx4P0qCISKkGwPdht+kI6Bde3CCgjfY4TcZ7IHM+nr5Guj9Mh+lt6KMJIFpFDLut1ByCddYaoo1z9+/fWatA2ahc3d2Mw7iUkrDVtuSvvuxDh/hnRCBAQya62Apbg33fAVIutbQ2bEYEjSHUXNcld53nlpGxC2F9TD/59KcAIDIT0W67FRZAdNYTQlonUeAGZCwDGoB5mmIXhbmP4zKvlaUf+yWv1pp5XaxzoXLKhVSc7Tbj5jyfFJpzVtUQ2ZxSZSbS4MMFdwhkg/XZsCL66IVpTYmAgKXVutlvcoYQPAJ2XVdaCV0oS16m9Wa/TfMag0eAmguieXd/D2gUYU1pu/Gx72prKWdVCCFsN9v742HNGf+X/+P/GhEZMsxCF5NXk1LbxW1gDF6wTYhIaBCQhY01rdWU0sWSHfvYagVC772wrEty5IjQWCDC82kBJedN7BwCzdOCZJQRSLlVYw0aw98sSAuCMouqWuNYhQEMIlYOPqw1u+AvovnL47qWhoSdDzWXBrzf75dlVpXtuElpRWOsMRYpdjHnbJBabUCY8mKIFAQUrHWn06xkEbRxsWQuk7lWWS2CsJQ1WOeMOy3leE6h911nuuBrKUQBFDMXZbHG5lL6vj+dpxCiAAJA7x1ampYFCb0PBMilgRgFKNpiF0orF4Nq8A6RamHrXBM2hI2rMl2C7iklIqTLdsVSLYUbe+8Q4LLMA6R1Tamku+fPHp+eEMiHuCwrpyqose+ss4BwPp1C9IDAFz8nQAwBCEXEm5Bz886HaIfRn48nQtMYSq2I0FoDUO99qVkbWHLkbamtcrXWtlYtEik2FQAkY1LK1hhEAITK3FhzKtvNWNZ1HLrTvDjvhbWUqgjG2lLKeb6M/U3w7vLVck411824IwQEgUu4M+e8plJaE5Wck6pcFFtERIiXryUKpTRVuODJLjukSyJZRNZlFdFSiiGy1uScnbPGmuvrq1evXjUVJSy1Fq6ioEhNpLRaaiklC7O1btxsamMWRbIsyizGuEsdujZGJBY9nk4s4oMnY5XABtt3Xcrp4teZ11X04tPE1lotlRvPy1JKOU+nWhmRhnGnaNE6Y20qtTADknEOAJx3ZI0h0/cDkQ+xn2ubc1lVSlNvewDsu6E1VqU+9CFGVhjGLQtY62tjMmY+T+fzbNCOw8ZaV3JRYcVvyEQCuubcWGpr47hBQG5CRCJ60QWqcFPJteZaxnEMIVqyBq0lF2MfYodkU25LrtOaTtOy1obG5tyEpYsxr6tFHLebzXbb9/3Q9yo6brah66Rq34+bzXbYbBVJmiorERHhZ599GkK4vr5Z1lUUgBAJAdA5KyLWmpcvX6Sc11LWdQXkq/0WpP25X/nl6MOaEoteImzGOgUDYLx3hBi9AxUAjP0gaEQRgJqI74L1DkFVeL/bWWesuVhDyVjrnNuOG5WG/4v/4b95sa9c5kr6jelC53n23hFdMh9krUUyqthaExZDKNpEq0Fz8TVWbswSfOCqBshaNQ5brQBGlRBVoaVWAXActsuSTqez916kgdWx7/OS+m6Y5nXYbOZ14cyKQN5qaUYwxKCGWqvWGFVmbpcySb2cuK1tjYUAAKLz3PgC7VNRaXwJlV12wWix1qYKolqZY+wA4eH9+804GGOWZRHR03m+vbkDTtvd9od/+tlxmj/+5BNVXtPEmW6ur3I+GGNCGHLmfjMcj0dh9t5La3ldDJn91X6ZluNxil2nqJdnAyGUVhvi8XwaxvGiqVTWktI49KpgrWcW520TZi4iF14GRxe4tRCisF46t601QLTRHw4HIhIwhqzzaBCis8F6i5hKK0QtZ2PIG5tbdcGJMq9C1rDqRcuJiJ6MaqlNAbC0kuty9/zl8TA1aarifXBkUkreOW/tec1rrTFY4WoIh9iVeS2sU66IKASllOADApJqMKiIuRQgU6owKLP2zqSSTfAKkJe032yFuSGLMF78koqq0Foj7xTBKqiysAihISQWBoEwOIBBVVsTRLLWNhZS/WaHhMLfAEGNWvDRiTBzM9ZZNMZoba0p1iLGOBQgIuGWSxN0zpnj8VRK6fqIgMyIqC0zkWVR56yotNZEmnWOAMUSItiAKi1G1xrnUgG1cQVEG6yIchNjyCMgojPUbbrD06khOWtZubd2M25OxwMbJTJX+918PqfaQAWUuXIMYU1FWBq3se++862PWk5z9eelMSI5j9ZEGzYuPuD53fFp23Xemd1mOOp0Pp6QzDydU65jP8R+A9JE+PbmisS8eX/oN6OAGOFNH6/Hm+N06lyAhiJi0OQyb/ueBXMp5/MybMZ1nmsr2+3gEFkUwa9rAgCp2Tuz5IVFgvMtlVILABjnvCVvLIpepKO18gWTzLWwNCCz1FobV76UdsWBK5UvnTUVboboYtZCVFBrwuPDU/BRpI79AAKNubamcPHcY+yHwhWNY27TkrVyU/XeiGhZi3P+4py+YJpzrqlW76nUBIjCLHbo4nBhyjrjSqmtNSBstfpgEZQBibyoIisRWFFtzMxsLZRalaXv+5JWBGBWZrbGKYhoQ0FVEcHL2t05F0IkwpQziDgXVFWErTW5NVV7wYz4Lry7v+9CKI19CABIiDE67x2zIkBtVZFaYyJW1fl8JkuBYnC+qao1F8Y5ouaahYEvHShr6JKlQgLSy0OducXonbUiTYGaqjOmMrd14YvTjuV8mlBBuPkQpmlyxl6QUjF2ThqLTKdjK+XdaV2X9Pzm9tUHw8PT4eunwwe3z6+vrt+8e3c8nJ9956N1mRH4/f37u+fPPnnxjBlqacx6PJ9byfvt2I+mX4wif/LtT1TrZz/5FJFudltpXFgu0cljrohUG19d38QYv/76691uWysaIEtggFgkeo9EAOCDD40vpxd2UGrxzgcfVNgQSpM15a7rrLNvnt51sXM2lJyMYmtNFTI3FTFepCkieedSWnPOsQsGyVrrQ8g518p9F601AnFNFViaSG1S6qrcptO574cQgqo4sjlnsiY4O80zkW3cnPXSGAmdJbyYQ9AsSxa5rIPM6TSFEGKMzjhhUQXnfOHGqrVK33UqyCLrvNy9uFqWs2UQsOStaa11QwwuHI+nzmPfx8enc9dFJGythW9elK6UQkTOeUQqpVwUOGCACNa0dCGqVGOJEVOt5Xz23o+bTa01dpEIEBUdGeOZBbRZg0g+pRS8r7WCat/3tVWsaskAqzDkmkz0tZUmsixL3w+OSEEtmVIKWZdYHKKSUeZ5mk+nExnrDeWcTYix7x8en5xz3GQ9r70L3jpWA4KItu9GNElSuuh8UioYPZB7dhPyUCxgmpd1TVVkKjUdn5wl9G5e0rJM3dB/7+e/v8zz8bSoQmPuYu/iIEBzbv2m32R+PJyeng4qzfmhNVCVq/3mPC8KbJ2xIczfLOUxxtAFbxCcDxdFuih761IrqAiAy2mRqmTtktaqfLl7BbJAromsJZdcDud5u9s6FxozUkGiS/TRWgMKwmLMJaFLqiqI3ntjLAKUVpGMqKrqvCZMKERpydE6JFQkY9DHGJrOqRIFA5aMGfrw7ulx2BpygRsP40BINde0JL8djaHSSl4Lkc2p+uCQaL+Pl5l6rsVaW0rp+5hbizEMw+bpcBhi13chL1PL2rKzBFhrMdYhIgGqsEj7tV/6tRDD3/+Hv+uDn5fFWX9JfH4DH2vf4BkBdE1r8F5F0FlQaLUZIuFmvZ/Xc9/3zjlu7cJ1ZqkEhGhTas5aBUKieZ4vmruu61TFeY+AYiRxQQYFuJhMa2tk7G57dfEiC0uWSmCZFZHWlKJ3CLDbbh+fnixRE93f3JzO53fv35VSAWC32/VxOD0djLGpNRQpKWltzz94oU+Hdc2X7P/l5d9qCdYbRQDYDMM4btZpdj72XcDOrbUuqYIpp/M7ZjDWAqqLQZ3ZdldPT4fj+dy86/rRntO6rNc318NwtS7r0/Gc8rrbbZEMGluGPt7eKgsRPj682+1HQ6bkQkCtltvbG+vdu3fvRHFdcm3cxR5QraAje/mdTVNi4bXm2loIfthviBCaAGhtGY1Zl6Xv+8vfCCwBWBG+ONi7viu5gCIaIKDa6iW2hoDCCl5itNA0rVkQTLBpTs6Eiduf/vhzNNY6N4790EdSJ6UYQymnrovOORZIqQAYEWVRstD3XWvNIBpLzrla2+Hp0Fq7vr7a7jbOQmny9v5dKZVZvvPsQ0PtcHz8/i98D//n/4N/I+XcxVhrNUjCYq3deEvW3D89+WHc73fv3r5zF5w44KWcdZkE1dpYW4zWoGnMzEJAyqKITdql5iJ8AYkAIjZkbpKzXMQ3Fxs7GCREArx4zS5WMXSkqi03Q8Y5J9JyTc7E1kSYL672y5KWUQs3Ahz76Kxd15mQ0JgLIEpVvDO3t7dfffklkpmW3FKx1rCB0AVi1VJ2N9dv79/nXGO/QQBvXauVSXofTw9PgEDR11r7EI1DVLwUH0pNRGSNBwVjyDlqLXXR/8ov/tLv//7vN+au77wbyJjKKdeSczUmOmej9xaVDKVaRPF4mjdhAFI0eDodkMBYb623hmIf53nKtZbcRPB0nPfXmy46a7CuaVkKK53nklvpt72zJgTvjFnPcx9CiPHd06E2NsaWUnebgVAJIbquaUs5GWNqa4assS6VpYvxfJ6Y1VpbcuPGfqSx65fzCkBIJufiAZd1tl0sSMd1nacpOvPtV69qqg9Phw8+ePl0eHTOex/fvHm332+7SMuaY+hDiMfj6c9+mgnUqOI8Jx+scB2GQMxo/JuHw1rK7e219/DsZpfmvCwrBR9j7GtpimiC/84v/JxYPNb2MC3Wec5pCKGLPrck3FoqKNwFr8qiVal1XVSgKszKQCqoRaQKI6m3NtrQhw4ES5OH47Hmwq05C8aoNRBciD5GSw4BRVuuXLU2FWNUiBp21iHwUpbUmlRclsT8Z8Jrg6pNsVqEbRg8mnXO85wUXIhjTi0Yt8xLcGFdy9PjiRlykaT+aa1fvHm/TtU0e3t9t1Y+TEXAC5jWWvBOtCkxQVNstgvGB2t933e+t7VlYwmAnYWxH8Z+jCH44Esp87wG381z+f/+o/90bsQUc4XCDRARXXD9OGzGoYuWvDXcZJnL08M5JV5SnvPZRgvWuK5nMNZFZWiZjw+nN18/pFWIfGt8e3tlEefzzBX6cR+HTRFZyjpux03X4QV9hTSMw2laHg5HVQbVGLo+jmsqj0/np8P0+PBQsqo4i9YhtJqWZSLFVto4jN6aVpoKe2+ciWnl1tR6t5SUWvXjkBXQ+V0fvv1s/1u/8gsvr66Wea1Nx2F7OByfXd8aRFX++KOXwbuSoI+DcC11jdE750URlMi5JI2itTHY4GqtFUxlic588sHz3tPPPv382e3L737wrfy04L//3/+vEJLz3lpbS4mhm6ZzbYIIKHJBgpA1QCCiIIqX0HgpMQRLVJpcNqBd103TJKzGeGuNSjNkai655FKasW67207nMxEZZ1TEOXuR1xIpkeGmtTKrqEFRKaWiqEOsyuQdAKZltWi72KW0eudU+eJfQqJaWUSMtaUW53yMcZpOrea7u7uas3HOWZtSWlP+F3/609242QzD1W5jDTrnKpfGVlWfnp6IYBh7ABBtpWZluLt7mZec1tU5NAZUlUW/EQ6hTSl7H6yz3Kpw67p4wU0tuXjnHZlci/feOTdNEyi0Vi2Rt+5y5rM+COppmm53W1YVgRBCKTnn0oWuSUXEL79+K6Avnr94fHh/tdsBORatNa/LvN1sFfH1m3tF3Gw3BmGeTpvNOPRD3/XHw4lZrHWH4+n+/v76+uru7nYc+7dfv3n78PTi5StrVDkLIiuWkr3ztRRAc+kxM8vj4WG/2ZaUWdXGvpSKrHAJTEkZhy6E8Prre+tiq+nmZpNLIcImAgCV9Xp/8/T+iSz+S5XhsqYlJXLeEDqDrRRDphv62po31lqzLGvXdSktiHg8nfrYK4I13iFgzqlkMkjvzw+GqPGl2gTRx9pqY66lppz7vuNcEMj7KAIpNde5UhI3EV5LZkS0FmupRLCus6h675+9eGGNORyOCNQaD+PwZyuAagwBYK0t58oqRKRNckmtyKYfQdQTXcj5xGCCOZxO0hoO6JxtVS4HYXQ2Wquq87r4EJo052OpsKwynVNanxDRWTOM47c/+cggySX812RaF7LUcprmeb/fi7LzFhFbQxHd7HettWmeNsOIILUURWnCiLTb7U7nuaqgCIGgAQJzOek2Zm+NCOemRGZd0qLrBeHbdYOKllbJoOuiKnch9P2tNm4511xRlRC5tvfn92HwLsTd9f716zfTNN/e3hHA2uA0LyUtXLK1eTOO3/7WJ+/eP6zz2nXBOR+CV9VlntGaw+mcc/72t7/FxPM8TXUx1VhrSqvHZdptOlUBJQECMi7GVCq3tiyLAIro7e2NIxq6eJpTKqXvx/PjsRvsze328eGBtaUsu/0AgLWEklkEjHWtJLKBRb746t4SOHSGDIKua6o5lZScdaiwzKnzzjmfckEyl2RS18XWmnOh1Dr0Y1K23lutXJmQ5NK1AABXI0lEQVSv9vtlXXPOIfpaKxpkbj6E0kprTZQRcbfdgqqwWuNZLuUje5omVQYwIk0EvXeXyByI+hBFhQzlUpZW5nnajLsQfSn5z2gOVKuAaq6NRUII0buSl3/lr/21n/z0y89+8tP9ZjevqXJjrYOPqVQyBhG7fig5L2uOIbSanTcXn5gn8oYMofpw/246n99Za2vhu9vb4ANz63ynqqfzkwFUwlSKFd9q3WzGvo+GsIuhlpKFxbhaG4r2XSfK3Ng5X8ryC9/7uc8++3yZZxG2SIh46fi2wt46ZsYLAT0n65z3UZSNNSICQEhQS3XepZKVKAZfSkVV450QKEKtdRzHwJJyATSlNmPc7e0LBXzz/qnmAkiVm0W4vr1GxPMymezubm+51U8/+8mrDz8IIb65v5/n1Br3Y397d81a91c7H9wyJ2/Cbru5WdPD6bjb9gCUc97vb9ecLyrrZV7GYWyVibCWpkSk0GpFosPh8Wq7z2U6n54A5Kuvv3r+/Pm3P/nWfD7dv3tKRZwzrYHzfcolLflwOPpgdrudc+F8PhHh2PfGEgMsazlNpR+8KXm76WqaSLtWmzG0rin4QGgEIFja70f8n/13/3UWefXBq8fD07qugErGCAOAoqo0HjfjRR9fc+5C9CE+Ph1UdVmLMVahRudKYTL2ogU3BglR+fIOlsYVRK1BADXGOusOxxMABB+dCzklBrl0KZ21pGpUgjPHxm/e3l+N++O8bK92tRVvqJZmjGNhQlzm6e72WWMRaWQw56QiIYaSqzP2OC+ntex3OwRorXprvLP39/ehG4PzeV27rpvTar1z3iOAswZULCKpPLu9Gbruy7ePpTISWGcen56E1fqw69xuM7x5+x6JFM2lC2udrbUSGlRwfzY3acoCTETjOHrvj8djLuX66vrx/sFYur69vr69+dM//lPvgyXL2L6howM0bsa5XFqrbV1XRbOkmmsJIToyV1dbkdp3XauVmd/evwvd0Hn3/GZ/XpY3b982EedDN2zHrrfCtVVRrrUEH98/PAXnr3a97cc55Ricd+azn3zOis9f3D09PVpjmVUuDl8AY0hVvHW51qoKAA7NJaEW++7N2zfGmLEbUeTN/f3u5tpbm2uptXaxm8+zcd7HLqV8OhwB5OpqF7wzBqfj9PW78/u5ZgHQ/J0Pb3/9V3/u/vOvAZGMUcB1Td45ItPqut2OFo0xxrx5e3/B0BmkYH0DUYCLeDOl4n1Iay7rOnQ9EdaWichQG4IHjIBGtQKos8AMzK3U5qxXEWsMkUUDoJpLXteCCMOwyakwy7qenfN6cYiVfKkyOmenJa9NNrsdq27GXkrpuy7XcjhNt7c3qJxyCj6M43A8HNKSyPpam7F0Ok/G+WUtxsWXmw2RKznPKYuzCrLZbQBdrTV0frPtlZRZD09Pdze3yFBrBUMq7f79u7HvS6mlNhaxzgHgZjciEmv76v7e2lhZc86x77hVLtUhEYEoM6rxUDg755DJGkeAD+8erLUWaZ0Wi45refns9jSduVW1fW1IFsraRLDUZLyta6oVDCAzqlEfbYim884bC9JaaW+P75x33ofNZjcvayn5vJ76bvCxH6ztY9e4vHv7uu+2T4eHZ8+ujfdF6v56x9IqiZEWANuaalYXvRGDJEMXz8fJxn5J6/F4eH5zC1K9901l3O4a8zJPPtiLXnuazqK86TelVQsudCOAFTA5t3le9lc33dBP5+XwcLQOb2533tt1TedpUWZAvbrd25HfPj6tc/nZz37689/+8G6/e3P/DmNghUtp3lk7K76bVvz3//a/cWHTX2LPzpB3PtUqTRDgX1oX1pSsQWsNfMP7tsYYrrUWJrQhBGZe1xUR5EKmRbTWXlIzqsAsOWfnjKpa66fzJKK1VOf97nqf0tq4jkNnrSlp9cEZ259O0zJP2832eDiStYBoY3h8euxCdN61UnLO2+1GCgfrFBgRWBoa16p4Z0N0y5JrZW5ts9kQEWub1hScE27eWrI217asqzM2OF9rdc6WWowhADXW1FKD98aYLnbMDRELt5TKpYtiEG9ubqbpnFM2aFnYe3eZDv8ZgVoQcV3XrusMEQvnXJAIFHNuhggMMldjEMmU3ERpmmcXDLNKg6Hr1mV20VtvnDPcGqm+OyzWRW6NCHe7rXArpQVP++2giofjWRWPx2PlMg6jsGw2AyDE6JjFOcfcDNLpuPT9oNCQpJS6rEWpvrp78fD+8Pbd03h1dT5PvQ+vnu1LTbUJAO2u9q2UktP5PIcQyVKu1TrXdf2br9+E2LkQ1nUlxFJqzfnDVy+eTqf3j09dFz7+6KOvv/r6xd3dPM/TPINDbq2V9lf+6n/2d3/v9xo3BEDFsesI8Wp/dTgeUq02huu4fXp4sBeDUWntgg2vrZVcMrN33iLhnzXmXPDj0HOrQBS7TphLKcYaa/26lNP5jIh4+e0HDwACegHZ1dKIzDQtm82oCiL6/v3Dbrtzzp1OpxA8qvQxAPg1rWzJOccshIyg3BoSXV3fnM+nLnYC+snLV8LNOffw8Dhst4jIFtGYUloIDhWE1TvPXOc5G7LeuwZQSrn4xK21aAxKyzlHa4mo7/t1Xp0HtKa0Zn3MOXV9l9Icgru0/pdVpLEhyixojLVgDd1cX6c1DSEaJERzuXY550opoMrcKrMBJDAoSJYqt8othm46r952pTTk5jyxVhQ6z+u8ttP5eHN7dXV1leZVhXdX23meHblvIi8lP7vatQalagjOaOOWWl7HuEspn07T+TwDUj/0HkLf99bgsizO+ZxrrZWZS6ljNzLD8TwNo4/WlVKUJXZXj+8XYfP8+d1SlufPt0Pw1ljAjiW/efPGObfbjrUkrhVDV0olglrK0Pe3N7v3j08+BmsQkawB4908L87ajz7+4PVXX79//3632ynA0Pellqfzst+MRO31p58NJsxsnqbl5nY/l9Q5V0suJRnrnPPnlrNFG2Nc1oUMAQCRvcSfottY66TW1hoCjttNEwHmYC0aA8ytlM57blxra1IVxPmgIk005zXnklLx3llrbXQAQJu43Xag2lrru2tmZskvXt6kdSWtaUnjMIIPrbWaGqDm5RD7DrZ9aclZPwxBWjUIKGhQ5/MavQXQyxq9ATQRbMJNVBXQsGiIcV0yoqIhMKTQaqvCNjivQLHzOaXGwgq1Maypi7FJJeA+WJTqyKLaZZ1DF5c1e+dyY0NIoMbhOAy15FJqTsUYK1pbaxfsz8UVkXJSNNzKbhiltQrSpAGisDiLsSdVURZg04fh4XB+eDgq+Zvbu2Fwy3zcdEPwjhDsdnAuPD4+GqQu9jU3JM2tqqM5pYenw263Py3rOs/juLHObjYbIhVpXOdWkC4pcsbzeRrHvuviWtK8LqzqAjFXZ72z6ggqtN1mjH23pKDKWOohldJERMbddWNY1tzHga/0/eOTtdYY6509Hw5X2/Gjly/nNYvKeZqur28Kt/O0Bm97jM44bcAMf/ynP9rttnd3z6xxoEg2/MlPfqZg51x8iNPD2XnS4E9pHrabmorM6+uHdx9//DGVWln0an/lnbPGWwpDtzOIrWYkCN7FLlhrLZG1XhRL5XlaS6nztJyejmlZLGJwxltyzqgyoHpnXt7dPru5HocuBj8O/bObXRedQjMOhyEiqndmHDpEEFYfQhN21hhjyThnu64bCCiGSKgqFQEQsHJbcsq1kiEyVFol59pFfG4QDboYjLWAAESpClpjLBmDSGC8Q2udN6mspVVRvaSkg/fB+7EfnKXoLSpfJqzeu1zyOA4qF40LhOCNMYhgrJ/meVrmWmsppbU8jp015L2z1qlCzvV4nA7H06sPPp5TPq9raXVZVzKIKvvdRpgBtLIomS9fv1XUFy+fx+Du37zx1n706kUfDBqc80qGrIE++nXJJcFa+NMvvno8zkuSzHB1e5dFRHUYB0B9+fIuenIWyQIQdiFG79M8OWOC96W0NVVQ3e5643BZUymcE4/DOHZmMzjh8vXXrx+fpnXVadan0+S74GMQ4cr1PM2HaQo+vHp+t+mHvGYR7WIERYPYh1Aa5Aos4qxxltKac2m77bZKm9d1s92ta3p8OhBCrllQP/72J13v13zOstjYvXs6Oh8AEAR2mzE6s99v7x/u7Zqr9/58Pis3VANArGoMICEhXoyd6zR75xStKORaSivReeNMP/bCevHlcGMgvMQ0fXTOoKpYY0QEUAmQawFEIpNyBSQy7u39o3W2avPeAQiDKF0iWExIoHIZm4MqC5AhZ/2aMgMbBENGgVKu1lpjUNAQQqtVRA3RuqwKEIIPwbVamZt1wZqAVEXABV+ZiciQLaU6a5b57L2zFlNp1vlSW8C2GbvWNFrfuCEotILOq0Cp7G1A0CUvm81Qa1mWSRGWeRWZjbWIFsiI8o8/+3TsBwoxlRz7brsd3n39xvt4PqXPv/x6HDfdRisCSt1u+isaz+enq83OG1JnRWmIgzVoDKG1P/7sRzd3r7yzVzc3XRdSWjd9tI4AIBpryTbhlBZz8f6QRQuEVLne3OxzLszNuO6r1+9e3l65QNf7YUmFmVrNJS99uHv//kHQpNqsc8vx6fb6ajQRiXvvyto6PzTVOa15Xjb9MAxjyqnV2t/etNaW6TzPaVplc3WDBnpv3DDMpp7XBQHkgqTUdvfsWS3ts6/exs7HWm4QXt1eeW/uT8cvnh4t4Tytg6PK6WGZ9zc3Lzabh8dHCwDMjUCsJQABEUExZA3atGYARaIQAgCANGeIjBttzLUys3MODbAogMm1trU654L3hqiU5oITYbKWuVVAg9ZZW2u11qoqEcToVaHv3YU9dAmjMIAqV1YAPJ0bGULAy62rtYp4afGRDZ6Ya2sWLK/Fh0BIVSoANmZrjQKKyPvHpy6GzWbDosJl1w9EppRackZjLv/91odUSmmCxhsLy5qMc61J4hpiBwTIF8OEelJDdMngqCoZs5aioK1qyYWVY4yiosCK7Xq3X9fUuDpyLLLMi7cuxs3rN+9Lle997+dev3lTS91vdw8P74PrYuw+/OiDd4/vvDN99F7RCSIiK56XtduNcRMjGUeIBIx6Pj7udvvOhpLbaTnZGLw1zhgibKUqCHTOOTfN09CPUcA6v98Mw9gbBylnUOk6G0O/LKcv7t/2m800T9ab3WYoyczzsYshOgsKwzCISHB+5eWUsukGV8pmtyfQh4f3OecuxK7rTE8s0ipXoimXys0beng6isLN3e3Yj12MD+sDOdrsdtaYtbZ5Sc45A/jh8xdv33xhPF7dXaU1tYZ/+pMvd2P3wasXlhANoHUGERHJeKq5qWBt7ULFRaQLt9YaukSLylqqiDMWkWopikRIPkRrrIqKKAIoYM5VUQFQFVsVIWrSRJS5Alw4P0qEtVZEMgZFxZABUES4mLmJbK211gYACLDWbKz1xikrsxprBRRUnbUAmnJ2zp2nxRjy3jvnG9c1pVSqTlMXQ9/FtK7WWEWDiJfMLBKtaeliNJaC9yklHyKzEJKCtta4NhEZh35epuPxFGNHWJnZWKOIXBkMEVLXxUv92oApJb98+ZybIOLj4+PLV6+Op6Moo07O+H7YHN++Py+Lca7mJMENXe+sUxVCIEJnba081ZpKsYR933U+fnL3AhVZlVkckrG0DdtWG5HZ765rfZzmhQxeb7beOVYJoefWamtI9vHpcH1zk9PaBVtyMaKtZgLkVhpBF0Ku6LyLLbRS1mVyzpNYVUK1Pvinx1OM8Xh8QCQXou86lDqdjir87O7FvK7zlFJa5zY754Pxx6ezj95Y452/vroSJWV8/XDvnfn2J58Mm/7t+3d9P1hAb61x5sXz21LgejMMsUfyj4eHx+PZ2DjX9u5wtPZiaiestaowolFF4YaIINiqNE4s6r0vooBQGtfWgvMOfVuaNrbeCAsiEJCiskJOBURZWYB98N76vBbQaoPL+ZvGPmLo+7imtdYGQCKASGgJUZkrQ7VWESnXBorMbRgGdKa2qohIBEg+BEERlqqg3IDQ2IusAwyh97bMxTlvnSWE1ppwRSJQEVHjHLdKxgDCAOaCmmolSWsqYo2zFowx3Ng5A0qiLXjD4KtqWeeS8wcvXokIIDUEMSBNuhhba6AwdqNUNpbQaOzjw9PTZru1RMJNldZlbcJPh8P1zb7zoyW42lwdzyfjDKmgkjWWc17nFLoupVU1gcpus13OJ+tCYVlTCp03RIZoXUqmiohgDDnTgEtLMYZSCoiKQG2y2e2FBUC7LpbM1poY+tpEWVtttnNdcFzSGD07MwzD/bsnRToe0uPj7IIPIQrZ0A8o0tJa0jw4u+kiol2X8nicfvbVg42RfI0IY9y2BFVkHKMTs6aSKxvr5vPibrZrXj3UV3c3rKiVHZlc02Y3aGsf3H77/s3T/Xx4fFgO0/y9X3gxGv/1l19b55wI51Scc02YmUOICFBbE8KUEyBE72ttF/dmqdUY05gbrwhIRJZMYa7CCoCgIGAQmrIqG0NceWmptqai2hICAgC31iqrYK3N2qiqKs0aqqV476yxwFYYHx+PgNh1HaI9r6slIDIXmCkyamva2qVEH0JsjadljX2fUq4srnEt5fp6BwAGseSFkIicKFtDAkqEpVQiM7VqUL2xIEwE0Tkia4lAQbQ9HJ62m61Bo2hD8LW2uN0rNONRciPrSRmkAYgwM7NzvrGUUkwFIgsC8zTdXN2ots8+//zFy4+WnIc+eG83XQjezfNU+dj1DhDJxgspiHy4velKKRpsbUxkHk+ntM4xYq0tRJ+T1Jorc98NagWQX93dEmFZF1XJ69KPfcrFIm632+PpVEH7GD3ZlIv14fB02G626Eyt9TytXRdAsdSaUnn/eAZjK+vFnsXYiiqCNikoYskdHs6y67ylWqbPv3rbfPzo4w+1lLUlRT2tp+1ucArT0/m4pLvbZ6fluE6nMPjbmytLNGclI86Z2HciXBsGE5al3J/fPCzl4Wm+ud380oef8Fof1+N221lEEBFVKKX2fa8ql2G7sVRLNo6sdSpirWVq37zaRH7x53/569evT+dJVGurlRkMMbMyG8DGDPQNc6JxK41j6BhaRKzcFA1azyJTSizqlWLnGxdREZT3xydnfU1irEUiF2wIzlmLYJb5HLwnIhYhMrVhrcIswvA4H7ouXjK8IXhmfnx6itFPpxMRdSHEEFNKCEhI3rnaKisapNqaRWMQn90+Mwjv378XwVpqBTTGAJEx7nie+n7wwROBdSStGQtAzXcmL1UEz/NqjHEOS2mtCRKKKoFZptXaYE397Kefhy5sr67nZTVIPpjdbtNyWUouub54dReif/fufW01VwXJMURErsIsKqzMrCzO9KDcdUZFiLCCvri7RlJnHUrnDaAiOhdimOfzMq2sOoSu5QwEgBR8bLn46Fpru+0OEVNaAbHvR2svbkIppSFSLtWGEJ33weVSVfR8mjrvrbGn2l4/Pja3++DZDRE9v719f0yc1/V8qkK7q42PxC151xnjcz5N03x3c/14OnZjFOaaMpIL3jl7gR6beck5PxJhA7662Y6bqy4IamoJWdn6YGupCsDMiDjPi4IqgLPErRlDzlhEFVTVBgYIMZcaXXj75m2aE1ZlaU0FCKWWi0ZWkUSV0KmCiCBY/03p3hQpKWdjnXdOCYShC6GWMp0zSx364dUHL3/yk8+cdbZTF5yxfa1ZSmGWS35RW20AQHZaF1FtlVkFAa21wzCkdZ3Px67rhNtlHpnzfJGPpZREtJQEKildEOtRAQBFAVJaX7+959ZEtVYx1gJwXaoxREh3t7fn07m02oCNddzUseGWG1dhErHnpXkHEYwwEiA0sc48nWZrLLEKUT+OXd8hKJcGzmzGzhijVomQjDsdTqmkLnbGGGLNrYJX66wI5yyb7ZDWsra1D6FyKrmF0Clg9KGPfa1pOpx8iPM07/c7Fiy1KpAq7oaxlqJgEF0TeTgcx64nIu9cXvO6rj6EEAILl1W4tWEYQYgVHo6HZToN19c1ZW8tSwvkUICMiR1857sfojYESKmoYFrTaZ2326G3fW+j1hziMNcqCB+9fE5AaZ69NQ/v3v/ct7/dUgIpznhQAaA1ZwYwBm3w+2GYj3k5TL/06z/39f3PHtp0vd87BDudZ2usD760hqRoqLWGoAhgyCJAKSWEWGtttYiCszbn/PX5a2sdKCqwsYZrE9FXL18eDoclrbHrcq3f3L4VyZB3odQySwtDh4K1NlIlBotSuUVnb5/fffXVV1/MP+1scMYz6brMTUWFgw8EsNZsgwWElLNIzaVZ55x3DsAaoyrrsnBr3+AMiJwnRHz27Jm19vj0ZA12Mc4pd92Ycg3Wns7zj3/8k91u++zF9WmZHLcQo7D2m6GUJCzWma7rCPDu7pkwH58ORVoqS/RjQQVswftWmJFd9DUXXcUaY4wZNts3b9/4GA3Z1tp+s7HOsRQE7fpOlUWFa0Oid+/eP3/+4nw8AaAKgqL+mRGwrqtzth8Cc3EefRjzmp3zy5odhB/88CfzMn/4wavNEGNwYKGynOYp+CDMIXhmEYAmknJSg6y67XtjbC2FiRAxxmiMufS3nLHWumVNQJjXVYRvbq/7IRweH7s4boaxlJJzccHI0rCJ9Y5L7fr+nI4Q7dD10dvOhafDo3PQ1PXjbl4TqzC32MWH08FZG6wTSAx8Op28j6iooH3XESEB5DUtazLGfPX6Sxtp3PS5Ft93+O/9W39zGAYBqK0ikSKwCKkaIkMGGrMKEF2oYHCxbYr4GEIXz6ezAiCrMDvjiKgJk6EmDIQiTGgMYCmVkAAg5/X7P/fzr1+/mddl2IzLmpdlicERwYV2i0itCSjWlJ+/eHGaz7XWEDthKalWLkjorL2wWAlRRYlgHPvT+Vxr88GH0LOwAkhjIqy1xBjympwzJScX7JpF1T4ez2/fPYauu7re7zwYY5yPNWdhHrpQ19lvdsuaESGldEnBOeuEqnE2L/r4+DgMIcYgTUtlsiatWUQv4DRCk9K6v9p+k1Z1rpRc62qsNWAAxfvA2k7Hs3Oh63oudVlTiKG2WkrpYldTAkLrPStwa7VeeCpApoYhHqf26c9ei8Lt7Y20Gpx59uzm7ZuvDcm3v/WxRailsGguxZElIrBUa43Wd87PNYGIIXvp7bCIkjFgWmuEWFpR0MxNCQ1i8B4ZLs9OZjlP87AZGJgM9M5r1XlOU61MEmJY55zSer0fnSEoUIQLiUeLQGspV1d7LI2EE2jfDSjKpYoyWTQGaxKhmgooBBtyDFpWG+MwzWfbQAuIVEYEYVFFg9YarFxrK5dZjHeWQCvzBV3mrVUGUgNAwgwCqsgipWTrvRJoa16wqWGAVKvzlrVxrV0cPv/8i1xqbS23o3HGBnO5wudSESmXTMYIy7jZ3L97Z50l6+Z1BoV5Wfq+B1ByJq/ZW4+IrTbj/OE8A5L1ThRyWi+BDVZe16ZkNLfHw4mIhLnvu+PxeHPzzDv67rc/aCytNmOjIVPWdJGcLEtqDJwykhLCOEYWH2Ocp/TidviF73/v7/2D3wNs/Xj79u3bsR+5sUMCoVzKaVrUQJbmCbf7Do1RhLUWQgohdLE7nifvfcoFQL3zSMhcGTn23gdfz82H7v7hqesHT5BSPs2lCgKotPV6P85LNWFjJP/Kdz8EoMfTeQX9+u3DksrHH+yNlI4Mojuu827fc1kaq3OxVjZkmVsmbd+0IZzxvuZsnVERQ67k4rzbDp1xbl7WJgCCwJxKBnXnx2Xo/O/89b/y5vXXX375tbWxip5OJyRKXD3gbT/Y3e3PfvaFBS9NjAGtJVInapZ16YN10mywmeF6jMFbrjyfS1m5j13VjNb1oSfKzNrFTU7zEJ1I8iSWBVXJegJVYRYBUZ7m3HUdEFZuzrtLD84gOR+4SamcUprWhaxh1lbr0PcgQtYCwrKs1tiq6IODUh0ZFWSwS21zqq9fv+66Tpj7PnrvvKOqGRGdd4gYY68qFMzD06N33jub1lWkEdHtzS64UHI2RP12n3MSUAcXEIUMw9Aat8bztHQxCguSM8Y15rf3j6A6jtEE9IFeffBBTtlbE7xv02yRgrW1NgGp2tg5dPYwrfS4di6igaurfS3p+DQba998ffj6y9/14+bu2dVxWqa5reu5C76UdnP3/PFnn8/p9As//31CgSaeXK0tl9x1naqmlAnNfjuWWhEMEWVEFZ3XdTP0hswyr4iYUi6tbYIPFp+WY641Vckp7ff9zbPb/OVbaLIbNykvgGINxhju7q4BWgz25e3duzfvvYtd57RJHzcPh+NpStvtznkrXFNKIXZ9jI9PJ2Gx1qVaxmFY1vmjjz88H0/n6czrAmjP50nEh+CXVGJnd/ue63J920d88fmffhZCbFVaLlc3z3I7ttaeniYy837XA4CKFcXGrWib1olQduNmu+l8iOdpIVZkrSk7G6gPx+nogglOyYAKG6KWS0rFOcdVguvw3/23/8tdDLXmYeyF+Xw8IhKiudjiQBUJiFBZLpBlBZznJXTROVdbttZedEe1FFVNKTGotU4RLUA0hgUejqfDXOaUvaEQw2YzRO+dpVJSKeXiWjgcDsMwpJSMtaVWBNjtdqqCqq0WbjWGMG62b96+tcb6ENY1eedbYyIIwQtAvVjE0awpBe9QtVROJVtrrvZXl74OK5dSmVVFW5Npmne7vbWwruvFpqcqf/13/poL9vd+75++u3+/2W4uJkhV5dYQjXcBDR7O07ykw/Gw2++vt1dpXdRCKss4Ds92O9MKqj0k/cEP/uTu+d3+6qpxZW6EsA3Odz0iTstqnT/P67KuwWAfgvcxl5Jyumx1y7r0w+bNuycB21rhmm9v9lYVFYyl0IVPP/9c0YzbvaiMfaxp3Q7D8enp+uqaiJjFO9dY53VR0BjdbruZ53MXuw8/+viP/ugHothqddaCQpHU9T0AfPHFlwr05379Nz797NN5TX3f5zWNw9DHWMua0hLIIRITABpQyLk+nA7e90OIIaC1qgoE4f79OZeaIadcX9xdv7rd3WyHUiozLucl9mFdk7Hx/eOTj84HY40CkCp6G3LOOZfaijNBWPFv/9f/prMEIN77xq0VdtaVxqVWZfbWXEadZImEgGGttbZqjHHeeUdIRGTSul4iGanW0/m8v94ZvCzQ3Weffp5y7of++d2zzdiJNG5VlZdlFYGu60HRWgsKa0pIKCree2/tNE2bzWZZllqrd85ZP+yG0/nUGpdch2FTSiEkY+0yL0taQ4ytlrSu+91V8Ea0KBhV7LpuXRYSAQIle2GRE+AlILfb7QrLdJ5BlUR677Z9+PO/+iuvl/kHP/5JWhMAinCMvtbmrTfGNOGUsgthXhIZ25o0blf77Tqfx6HPKbVcl9rOVRxRF9xmM5acWMUHFxW990hGVRtLa3xJPJRc+q4nAERJOTvnhXktecm8ZhaV8/HpWx9/ZEFEmvH+6XhkUWvMptuwFDL49DRvN9sQTAy2VUBAkWqsyzmNm2Ga5hC8iJSU15ydjzkXAOhiVBBrsbYmgE9PJxF48fz5uqzkqyHnTZeWxVqqtbVGXeeaZN+PudblNLfaTAzOWmoMKiLsfHz97uE4p6ur/W7bzWt6drsLwHdXewTzeJiNse8f73dXV/NaWuVx7I3l4H1a8/k0OxfahfzFrbAY66xzZAzVKq2xCgAaUUp5iSE2rUTEwlLVIK3z6qwVlWVNsYtaFNVY59Y1WTKq+P7paVmXFy9f5mUODsH1f/Kjz6rIdz75eDc4iwqlGFJjMGfxxrsu9t1Q8rKuyQdPqMoCqs646fTY970lsIaM6YRVEKVIQDudzl0/ruf5dD4DoAtREIz1ooqId8+eEWgIfl5aZTbGnY+zs85a8/b+3bAdQgy1tDmttzfXjdtyPj4eknGu62Icwvl8XDn93X/8j3JRHzpQw01jHPOaRcR+k45VSw7F9HH84ouvyZtnz69bzoF8nvJaOWz2Os83G2PRWCRP5L2vXAmoqRrA48PD3fPnXWcvdPqV2Xi7rAsKX+32NhKANDJke6RCWIZhswneGxO8X/Pighfgm9tnDundm/vvfvvlfjf8kF8Pmx4M5zwzozQNzvRd9+z27v37R+dMzplZYuwZzHa3W1Kal7mpGIMqPHR9Zb259su6Pj4+9qFbz2U79mmtiGCthOBSFktI4OuaSypaGAVaquBaIAQhEIfoGmu37cZ9v/UepEVL2JqKTtOcS6OgfujWmquw9e50Pt5cjRb96fAEaFQxpxyCzyWbzik2W1K7MOJCiDFGRK21xmAJoDRec0HiEJwWscFZZ6XkoXPPn92UvCozEal1pTRt4q0drq+CEQpBwP70059+9OLu5vaqlQzCqdQu7iq3teRcWFq76YdWk0jd7QcFBjBItlRhVusHVjrPqzXWEuWatMpTbkuWf/HHP/vo4w/3N+Pb0/Hly5fX+6tynhjURa8iKjwvs/LQGIXMvEz7rm85P+bcgo3fPPMtGX+c1tjHP/jhj37+536RW4sxcKm1tM3t9TTPz2+v1rx4ssqmrs2iTdrO80xorPPG+nNaVfj6bjt0Xc11rcU6i5bGYQTm69E6Z0p2x9PinG4Ga8gZ9Fkv1gGHAKIKiM5achaV3j696bu+qQIIoQD6sq4W4e56l5a02/TvHw7W4osXt59/8SUiHR6PXT8kMJ9+cf9y2Xlral4AScXnlIe+F87SpKyrI9Aq1lrvSbGh5u3gc55BOIYOmxzXvKyzijgfSqpg7CJgvUMHY+9Px4Q4lNQc2mlZydp5Xta1pCZVFIwjIzfbvvPeI+R8/rlvf/BwPJZpfqfzOMSW8m47zrmd11SrEDoR6rpuOj2MV4MlWpN2lO5ur14/HEDquI1IZirz430dhz0Zg0Sw2Y5/FgtpIVqWxsDeu5vrqxfPn41jF7sYgiMEi3B7vUeo19fb2pIxYIkMQmlFEKqooGWgn37++W63e/nBy5TSeZqmZc612mAEmDlvNv1uv3HeAgGQnZdcCiuZJWdRqTWz1MYFkZZ1nVNealtyPbf1YXl4+fHzu7v9zXb4pW99/OF+pymRM0hASGTs6zf389pEjdQarQNuw9gzNrSy2QQCqTUF7/roo3co/J//W38rBNd1fp5PxuLNs2tRcc4eTtO01ndP56L8tByTpJnL43kqrGuptbWH+7dD559fXy3LtObknGNmQuBSDeDQjcHHGJz3WGt2LoBqSvPh6YRkjXXn83lZZkBFAhSspb54/mIcx2k+k7NLaS0vf/W3flNqsagxulpL3/f9MLx/PORSN5sxeNPKcnc17PfbpUoFWFJRpNqaD24tKTF98fbd6/eHLKDWOO9E2Cp3zv7gj/4orUtrrdR6mqanZTms6f7xsObsgt3vhs7j2HWWaJom6ywZYtDjMh/X+bieXfRM4oJRba2uYxdFREGMJWdtay2E4IwlcoDWukDkiCh2YRi76GwfvHAbhuF8nhpzZZlqeVqntRYFcGSe7faOCUx7XO4plawI1tK8nFvLAE25dH1fapvns3ew2w4lJZFvOGcIYI0R0ZwLGtMEgOzXr1+fzmcgVITjNE/Lcvfi7vnLF1998UVekncuxn6z2615AZLdbjt0HQIs61qZRVGAznPOhWsRY23lqsrOWbIWyP70Z180ViYDrd303YurncH28PCmQV1yZgRyZklrqfX+7VtrPZA/zyu3Vpf08u7ltKyplc0Q27pUFkPUWsl5zXk1RMpyOp/WZXHelpIANOd0Pk0tt/mweuocuf12dJaGOFrrkaiUcv/mzdX+ajuOreSh613wxpjo/EVMWHLJa7ZkEZszssxnIuO8E2Uf+rQWJFOZn54OOeeU87Smw/G4LGvwTlWFpYkE737wJ3889DF4S4aGoffB2OCndX356pX3fjsO1/sdQkPEVBnI2BCQyAePqNFHh26/vQY1aa3IMPo4xHham5ouq304p0r+8zfv3x2XpVRyfnN1/fB08D60VoWTJcprrrn0XVTUyg2su7q+7vphyYlVuj7eXO9e3l2R8HbceOcaNxdcrcUSbjajdc4aN835/uGwrDnnuqbUWhPhUsuyrsaYXCqofufVR1dx82x/vczrUsqPvvhZC+7Z9XgzOhqG7XazW9bc9xtnnTPm+bNnx2l5//QUQ5fW8nD/3honDMuyCiIa+/7d4XzMb96epgRffP3wox9/Tj4+f/nSeUsGx3HYbMZxGLjkTT90PvSh99a32i637JZrTZXUWBMaQ2kpl9QPYy78dJze3j+yEqApReZ5fXf/cLW73m02nTfb2Fs13trD0+H29pl1XonmtXz1xZsYO2Mo5Txst1Xh89df9/thv9+dHo/LmtE4h/57H3z7eJ7ROEXwMcTYt6Z/8Ad/6H3XmK+urnLOhGRNUKbjPMXN5suv7k/n2VqspZwe5pZa8Obl87vNZtPFrpQ2TQsqamNLZICiDyHEKq3WVtZyfb0JEe/ubnOuzpp+8D66fhzWdSUywzjWyqfTfFzW1+8eiEhENsNgjO1Cn6scTnNTXWt1zok2IlXml89eSG3zvIBgLa0k5lqDJS7FEM7TXKsweFEgyUTCwgq4rOnh6ek4TZnh6TQ5Hw6ns6qMQ//s2fUHz286b4xqWnIpLGjOa86Fh80YurCWlVVSTt46YkzHpQ99H3sVGfouON93AYQBVFSI0FkK1hlQkfp4eDLOseCaai3iTJxzLYK18jgMIbht30Vvy7xI5bQsMcRam3EODGkDLw7/W/+lvxpD2G62hghE5nkGgNcPTy9fvugvoAiUtbRU2XnfaqmleWNTKqd5FSJrrXcuBorBqzaDBArDMLbWnKG8JoMXeOBleWpaa866ZV69j6kWZu46S2RZ8NNPP3PWf/zxR621NU0IRGiOx9Pds2dpXZhzEW0KQ+y5VRUxxtYsh/M8bobT4en6Zr/Mp48+/ujd42mel9urgZSmaXnx8Uf/4l/80Yv91Yu723fTYTNsmLmUbIw5nyZV2u23ztla87qklHM/bp8ejoflKfY7NA44fe9brz7/7Ium/Uev7lqZpymllLe7bamptQKXAIq1CDQMfeNWlQ2Y9XT8xV/9/vF8mpe6zIm1IilRVFUE4MaqQMYsy1JRb/ZXgdAinA/HbhhC10+pECABG4JSS0qZnA2hUwFVaY0BYFlS5bYd+1aSc6E0Xte03e1Lrd6SM5JyJeuXlJFgOwzRu3lNUvmiHwMkAkjLsrvZT9N6OMz9uJvX5bycX716kefzdhisM8wVgJYliZJBak1qa3Nadle7WmrO68vnL0D1fD5utiMCLstsjUcAY4lZS2uq2MXu8HjcbDZVGyAqt6GPXXBcW0oZQKc15ybBu2BNLQWNVWEixP/Rv/03QJELR9+J4JKLCDy729Vajoej914YnI9rLobM8XhU5Vpy6Lp+HJUoOudQay3BWWtMTtkZL4CVNS1T8P7Vq5cPTw8C2lqx1l4Udax4PJ1rbZvNptVGxpzOJyLabjeeLNdGwbJcqMDS9f3D4yMaW7l654L165KWJYfYneeVAlQRSfrhqxd9JzlNtVJZmESG6+G8zi4MtXB0tCwn700rsNtcibbWMhqDZEfnGPDdw9Pj6Wysi9Gr6JyTIOy227qmbeiA8Gk+DSE6MKU1URAQIPD//5rerNf2Zb3Pqrf6+nejme2aa63dnn22OSfHxE7kJFJQLAcIOKQDKVwQySJCQtwg8QXId0Hi0ggJcQXiAiGBBXGCsX2S3a9m9nPMMca/qb7eysU0X6Eu631+zyNZLYQiKK1Irev1ap4nqH9h6WaMO2uH9Xp3eCZcEAJGiP3+sFoNtVZgPIQohHB2MVqPh+PQ9zknZTQiMiFqxWh93w3WucM4D+utj6PRnDPhfSy5khexBCmKMazkJQOTU1RSUMEIBfSZMhEqxpIFomHcYhKMl5hjTG3XH6ep6VoXfMpofVqsl0r0nUnJv704W6a5MW1MOaektI5YrHO1UinV/nDoug4xV0qkEDWl9XoVQ6iINkTGJYPaKUj5xYIPsWBKRWutCNgQkeDpuqMVKdeHyUnFQwiH8diYRghBMpJaOWOlIAdUSgikhdQqFQ8ltEZjdHbxz6MtJHkXAJEhEkEpZ31jLs7PY/BSyqbtMCclOLCuVpymCSTfj+NqtVFS5JKEUBmhVn6cpkpqr0QGjIk87XaU0QoQAgKUUrIxahiGeV5CCdEHERQBIrjwPu339/2qr5WkmIbN6rDfA5D1uidAhDRcMAoEKkhelqMlhB4nh6muemNMs7hlGY9t28W4SMmgcM0lKfSF9q9YAMiTizFlLrRS2fvANJ/ncVgNlbHj/jA0bcFKCmLCQJNopFumruulEDF6RoAqDpQu8yyFwIqN1hSAUHp995jScro98S4a1VRCCCXBWUZJCN6YpuSkJF+WZZwcE6ZSwYTMFZ3zpjG8+piy6Yen0TrnXzSAnVlTRsbD2GqdWKaMZcS+6+28lFw45y83OcpYxkKBe0yNltF6LvmqH/a7PaMi5aKbNoPfL0sh9OkwSSVs8D5Eo8X56UnJfmU6LDmlMGMxxmAlqQTGuRGKUz7NswauCI0FOWXJe2UaZ50SIqbCKlAkjMvD6IFSyqj3jgnaGmmMTEsI3p9fXlBGGFTrbds3NbpmaGqJldRGSZ9sKZiAllo5AJtmtyxz27Q+HqXWLsRxKodxrlJLLSnFV2drRasvtR1WNUVG6tC23ocUxpLJ7nF5/eZqWexxnjmX3bCuQIKdBCWC1qe72xBjI8Xi/bv7+8UulDLTtkPf++C5FjWjMXqx7vn5sCzLZr09TLuLM/Nw/3B2cTFOS9M2dvGllO12E30suQAQLkrf9cfjnhGWYtyebOy0UMqxMsqS90suOueilK4lbIbVYqGUCFzdXz8tzn/y9so6u96e7HbPKSNQzpE4FwTnhJChHwhQ5wMANUa5cT4/O1NGMcn2+/16vUKsjTGNUXYeSynBB6UUBfYSjnx6fGBcHudJMgGUSilCjLVWDow37bBapRhjilzIWmst5e2rMwqAAaFGhunf+vmXQ9f/8//nXxKmHOan5+dh1f72b/3i5sM3ObOYQSlVcqZAKBAK6L3lnAnBY8xCMCF0wYShQMVGGQ6wNoYABBspk5yrOSx2HK3zjNLVZmMXxzk0Rrdtsx6GHDwBZAQE58MwHI6HXg4VIOccva9UjHbywWutl+zW6xWSEsYZCEkpM8qR0GVxwHLKCxcSSPZuUVq0bcco1JK0lhu+GcdpM3RCApDq7NIKpiXXioeQKBCpVXAegSij4T/99/9K1/VdNyyzjQV9TLO1fomtkWfn66GTq65JIXLGYyrW+dPtZlkWH2KpkAraxSkhsRYpBYEqhEIk82z3h5ECwZzPzs8I1JQTodWXwhlTXA59/3h/P/S9dy4TkELM0zJPSynYrdeU89O+ORz32jSH8di07WG3N0ozxpQSsUQuZNs1jdYl+u9+uEUqNmtpF9s3mw/Xd/3QSCVoge1Jv9vtsJCuW0/TQbcqAD7d7berLWMoFRWCE4R58ZSJ65v79XbTNLqWgpihoDDKxaillACKC+sdY1QZk3PGQjin8zJ3rWFMLIvnnBltlsUtzvkQz862nJecihLauQCU+ZCM0QxyCKGUygUXUozTwoVojYoxccHHw7Fv202/yj58f3MntKacCk6V5F3TRO+41MvilJQ5JcpYJaSQmoIf+i6lUgoqpXOOlBLvfQpZtOZwHAfdNLr7/uP1FMLpsJrsLATfbNYEs+JsmZdMSmOaYb2axjGn2CqjtX5+2rVdl7EWQg6Hw3a9Di6M3lIhhRDBByVl17WUVu/8ql9bu9zfP2rTRCQPj/sQ3CdvLq5evZrHMXi37vvV0F9ff2zWbUbufVy3pm/kPE2E8dbolJL1ARhPCTnj3jrCKFDgw2qTc3l4eCyVUGCkklXXX12K1dAqTnMIpZQYy36xjVaY8jwtMeeYESgDoH3fM05DtJUQwZsQkw9TiLEdhnma+tWGK+VjONhgTEMDmk4KRufjnlNqjy5nArL4nADw9etLqdTzYYwxPu1s05qU8mq10o1x3t/cP3/9s08pqYo2+8OzdbMQkhB19/D0b//qly4sn376+bv31zHFn3/9i4f7u3Fv7x7ivAQKvFK73W4ISUp13tXb3f3r8xMpBAFKGG2Mvr3ZrdfNJ2+vbj7eb7Z6OoaYUDcMMpaaWdP4EJFSUrl3hTJaSfHet037wnoLyW0k33zzE6bw9VdfvB7akqOfZ601ISSXVEtuuybGFDBTRgkgodQuvpbc9h1mUNJMdtKNGdab/fMRCGl7YzqDKb9MEYNLKQHlwDlHAJDSxxdjN2maBjjN3lOgPjpCKq+MAkskH5/3XApf8u7+ul+3aSzbTd91xgVXMVNSY/SMVVZBMlZC4MAICACOlaqmz5Xkkiilm9UAQDNiZ7ppnjVhp+1gGhNSdNbnVJLCm8fd/nj82XrbUw6kMnXeChaDN1piDj46+zibvtm0wxxS9IESSirTukmlxBhKKT4EJIkCo4TmXDlUrRRPIaeSgVLFmNZKC1UrClGLd8dcCSGpAFYCkhYgQjdPx9E0bTesXfAPN3er9QpdahpJqXy43zPO2l6tN12OtGavNcvZYolto54eHj85O92u+smNQrOQk8vBmL41XAigjHpvK2GkplYLpiRiFZTbeYp+1oydDKtcsneub7eMMgoolXw++C+//irShIz/+b/61i/L7/7Nv1GjDwdvzJrLKjXninMqP9w+Tsdls95+8+N3n33+drNaQ46IcJyWph9SZpqx7779tmb+9s2w7DHmHFNkAByg5MS1sMvMgVACkvKm0SGQGAOlLHiPwK4fj4SyLz77dGgkL9FNSyk0L9EF3/StXRY7z5WAS2UYjJSUAR+Prm1aRFSymcYjI7VtTfBWaOZckEJQpCmTlCJjDChSQXIOtWIpBTirtDABndZAIYQomKi1plKY4EBYDI5xthI9IZULIbUsOZ2vWyUJUHiJSmGtQkil1H5/4LIUhFprJWxePI+ZABqjOFMlVynN4/Px5vaoe2GMQIDJLi9pDpeSYiL4kCm8+uRNbxS62CkqOxWOcXZTo7iUAig0w4ZUEmYXY2y0LqXEkBMWYETJxoeQ4iS1WRYXWTJS14rJB06gSEH71eolvMkYDT5KxoFQwYhQYl5eLOUixAQV2rZ3IT7urmMqQprFxVqyDfnp4b1S5vz8NIQ8jjNWIEicdYyVftUdDvbt1dmvfvHFN9/+UCu1NmJ5ufCWSmiM1TlPOYvJPz3tTk/PGtX99OO7s9PzWmtO5fTsBGC5vb67en3V9yalebVeI5b10N1+uP/lV7/tU/jf33/42VdfvLv9uNgFRb0675/u7pdxFlIdp53q+4N/gFn81l/9q8syPj7tXp+f7XcHIPzdzT2RjHLjw3x5vmVU6abRK2ndIpRotEYspJRV25AKJZe2UfvjgVQghEqlnp6mjLlieXW5anXNfmFcF6SFEABSCQim7LJrm1ZJZRT3bqZSxpqOx7HpWt31y7SkWoyWIaWSMhJCAFLEmOOLvaKUhAQphVRSRSRAeSFQCgVacyYAJaCUilBSsOaCiEgoDI3JOb80icfDdHX1GiteX7/rV5uKpBLs2q7khJiF7hICVCwlSykRa6U1BRyPh8XFkJINkVDuU5Igu6FPMVWsuRYp5YtK1sbpbNNDJdN8GJquAz1bi0AF51IZrfXN7W2ItW87JSXBLDTLPviYuNQhxuR9CCHnCrEYZZx3c55RcCoY/Nf/5Ped94QQoFCxSs45ZS89gwo1YyGElQoUREozBcy55FJzQcaYMSYhpoLXH+9eX716+/bq/v6mZKwZGQW3uKHvpKTt0DztjlIYTvI0e6BC6YZAPez3UgmtpfOhFOSMxxiP0/jJp293j8/epe3J6d3DbbduU63f/fjxi8uLz64ux/nQD6vjcaRAUlysD7Xyk82KUoq1vAinuWq///DwfH/7+Wef5pSFNNf3T23fC0HHZbl6fXlxMnzzZ3+6Xm1nV2YXjGaSyeCWq1cbqAIoHmfHmOSUEkQg9aWSUwgQYNbOSklKGFY4Ho4x56vP3j7tHpWsby9PKVbni7WplBxjFFpTIKQSLSVncpltwQAMCOGUccqgYI4xcQpC8IuzM+/D0/M+FiypMEq7ri0lF8xS8hgjFxIIlYIv89KYDkn1PuSSWmPWTeu9G+0iGh2CB8S27ZxzQsgXfE1rs91uvvv+m2G9cS5UQmutFEgOsUpBSmUvPXRKlZTeuadDqESM88gkbzqlG8YkXPTr48NeKWm0ft49VYLr9TpjaYcuen9+dv7h/buX4isStnjUUkDFvmsPx6MPcXNykrzbT/vVut8Ow/PTs1SNDYkgFUJ453LJXPAQQshRMimYoHbxShmlG0aFEIpTyalAYISxgkVKWXL2szvuRlLF09MYQtZSt0obISAXWUuxy+evrj69uPjy9dnVptlq2QkxtPpkM6z7ruT08cM1pfx4nKCKrm0ZRy4RoBBKAQQBAAKCy8WGaXbb7em333x3sJNaNTcPN42WHMvA+RfnF1+9flOTk5zsn3dPjyOlTUW23p5PoVQQ1gbIsOwtzez+46OzoVuff7g/zIncPT1Imn7xxRuOuH94+I2vvvxn/+y//Y/+3t/9zd/6ywFLI/nJShkuri5OKMSU63GcgGQGiBjHec8kUAlMEFvizo5f/+YvL968ypB9mEwr37w+i/OeF9yYlaEm+TzNSwZEUoSRhFYkWGuZp+O8HLliXDKluBC0IubgBQWllZTSSGWnJbjwkk9hghEGwGl6mXrk6kIuOQtac/A5huBnAoUrVgCFFqUWIJVTYgRfdS2j1IdMuUBSqWBUQCLpaf/4ySdvtVKlIBAQXHAmNpstg9r1DSG1bdqSyvF5lEwbUfqWnKyaTvCByxXwE0JwshizoMy6RWjBtZyj1UZma0Ul1+9+oowVCqXWF6kEFuSczfNRSdb3qiQvhMoptkb93t/6m52SJQROGeEwzsdSktEKACqAadvMyJgC/Bf/8PeEZBWTlFxyVRLmVAPmjNi27f44jeNECJFCacWFZG1rECNUzKnkjDEmqWWIuW0MltwozQhlAKmGBHQ/Tt5ZoxvORdd1NNVKSarFx1QSppCNMpV4Svk824zVtM3T8xMAvH37ep4nzLkW0jV9CMEu0/bsdH9/98Vnn9wdxxiqBjll97R7WOlet62PuQIcj4ez81MX/GTDfnf4xW981mg97cPl6ep+/yP2J3/33/v9V6vt//G//K/G6Ou7j0ypJebD/lEyOfRdLjEmAAoCECuxMQOlbdtyVlP0lPJX5+d/8E/+sz/8w//h//7j/7cfNpXU6G0umXMxdL1WMjifcpoWa7pGSO69r5XlVJBUwanmknEgpC6L45wPfT8vNmbkjAnOD8ejUuZlyPazLz798acfldGxZMaYMY11fmhkSWHxUQhdkSglgNZpXrqux5SAkJwy40IIQUi11nIuhVLLMiNWJWWtSBmkFL1Pgv9FwA5LoaxSTrHSWuF5f5wXRylvekkqDXMK0V2+2mgp4hy10hWqUHK2s5BMS6mUDCGMx3k19IiVAMUKzodSa8HKKZWcAlaj9TiNWivnI+M8+NC2umIZF8eFbgwtlNVY7dGOObBWqlpZBcQK/9V/8nulkqZtM5IfP1xLZQrWTpK2bayLjIsQwmY1CM4Ri9bKuin4RSotuJom+5JwVFq/GBkkE0Aqq6i1OIT0p7/+5tX5KyOZMZxALZlhxcM0p5wZZZLyrm3HZa+0xko3683Nze3j7vHr3/i5neZpHjnnw7BxLt/d3nzx5VsXYpn9p2+udsHf3T4TX57s2K3Mq5PNj+9vKqHzYjer4eLidPd8yAibtekafdgvz4/PJyfd26vz3//d/zBC/cP/+X/601//2dc/+3IlpGLsx+dDymndt43WQCCXErw32gAj0cfVajXPszGaMV4CCgBS4/X9XXdyVrnY758uTjeNlouzDJjSep4XZ51UOqXStdrHEBwyJitBKWn5/8lGzhlQGryfxplQ6Lo+xiikRKwhhLbtGq32h2ehZMxZSlkr1lI5o85ZAoJQpqSCWlKyWpvDcez7nhCCBTmTtdZakXGWcg4pkUpSTIIJQgjj9KXrp7QOPs7LDARMazISa51zMSOhjC+La9b88vwCXSG0MFVJyRxVjpkAcsEBCKGVA1BCMkJIhRLUWscYQswFqJQyxsAIwVJLLkxwLgTWirV4FyuhygjrJiUNIpye9vlgx9HuUhz6gcSAvAph9rs9/Df/+T/wPt/dPs2LOz076QaNkFvBa60UxDTNKaX1MGCKyjTOB85pzhkrIJK7u0cteaOEVAoACCFa65QSAaKb5l9//36awsXJ6dBK3cLsRkbal9knY9wuC6YMhIiufflUW+YlpzwM/dD3H65vTs9PGIX9fnx8eH779vVq3T7vdittpFIfDsc/+qN/+e/8lb/+/v7DJ19+evv+g5Sy6/plWS4vL2MM79+9//yzNzZMH97NpJrPvuxNSw73M1/Q1Vg1PXl1tlmtqg/zYZpyZYxpQVujnV1ehL1LAkLQcJqcFVKVSnPl729uteR/+Zdf5RxTxlKRA9FKAKXOWheCMe3heGyalkvlY+CMBOcqUgYSa+asAmdS6pKLc855v1oNjEHfdsfj0fuojP6LhDMSShnjjFBKSMWcckyN0rGUTGiJCRG1Um1nYvApJ6V1rTXnzBkXXIUYCCHW2l/95m9+9/13uZQXb1TFWmIhhAAA4yKXUhCDD01naq0p1ZzKS32dUNKvdW/0fBiFFIt3tVZeIeRMALquYwQIEIKFUUoISwUBCEDFmnPCkDJQ6NvG6Ga/P9gQuZRHaynApjUpFso4llRqkkIr1cS4EF8o5Zmzx+fn6P1mswqFTPPCf7q+SyG12vzizadD38SwlBhD8IWAS5ZzoVWToucUUnBKyoJIKZdS3t0+WLecnb1tlCSEpJQoY4v307Isy5Jr3U/z1eXr7brfrvpUHHCKqcZYKWNSqvFw5FxKKe8fn1b9UGsRkg7DSgr58HAvheCM3dxeR59OTjaMwd3djVQCCWm6lgVnBrNad+d5FYMbrd0KJjg52w6khBLjxenm/HT9+AhtU3TTCMFuP9wK0R4M/ezq0zQeN0yUaULGAiMk1ZJSpaJWjDGlnHVjOKGkwhI8IqeiuXt4HCe3PlufnQ4gmaRimg6Kq5dd/9HHFFPTmBgIYyZGzDkoIylF1jTeF784oLXvVxlLDDHG4lxarzaEIACtFRAr5yJ4z5gwuo0xxpiEkAAkl4KlnGy3ry7O/69//senr149TqNkTIjmZQXet53S+nA8csY4FyknSql3nlJ2/eEjyVgRJec2eFJro9paa8yZAAkpUMa5Elg8Vsgpb7bb/XgEQMqIAGIE687W9w87LDAMKw4oY8QKgrKXqVZMSWm1GrrbjzfKqFQi45xLSULKKU9grfVKqgYoAWCIJydbWkqpmF3QRgohvYspOyDV0to3Kj0eZrtkydcIUHPbafin/+hvc0FzSVor71OMBUC2LP6Nv/47v/72+6fdMwAAIZSCkuqlZFUJpJye9/tXV1cpppJyzjnlvBr6WErllBTCkHDNFaO04Ph8kKoRSuQaCWEx5bvHp+NoqVSc81WjN+uV9csw9IjleBgXu5yfv9ofdi8vjgiMwdn56v31I838p/fvnmK4unytfCEQMgfK2JefviElVsSnp10p7OJ8DQStNw+7W6EzrRIyOzs/+Xi3GzrdtZySDADKtCmhc6GUpJSK0XMhYymV0LVmFeHxOIdSgbF5ni7PzoZWC8DkXQWYfMqFbtfD025HgFFChlUXnKOUSMmBvJwco3UuZfQumlZTilCBAieV1UoIQQLYdc3hMHIuCEDBEkPinIcQCVbOmW405zznAEC0lEdnsdbXl686bX788SdtGkSUUnlvCSEFSy5IgVFGKWUYC2OMUii15FxSzSEGzXXOpQKJKceUdNuEEDoplTIPj8+pZKlV02llRAti1SrBYVr87hg325NlfOScHcdZSVlKQUIKIT7Hq9PzZBcqhQ8h5QzASyyVVBBcC+msNVLmnOd5poyB4SkUJTUAGiNTyNbGDOW0G47jtI9OK1NCDjk3uik58xxDScA4s4unQNdDWwnURP7Fn/yaEADgiKUSHPq+lIqIlQIldDzuLs7ONKc1k8N86LtWCs4YMiwpZCXNvFiJEZX48d2Nc+nk/Cw8PSebpW6eD+PD7uni1YWdprOzbUA82mWz2dzc3qWcQ/a6aUcXHnfTp6/fVsT764/r9erI5ePdTphmplCpJExP9bDR9PzsTDJFxmPbdT88Hx9tNpLeHUcmoOT47vbuzZtXn765eri9ubm78yWzWEPErmk4I/O8256eklhC8FRQ0xvEynzsGyNqpYIPnXnYHbTueNdpwW/uHruuE4wKBgRxs+pqzULIWkFpWbAAp0IIIaRdHIVkfciEVkp0qwAzVMqE5IzGGBinjAmorKTKhY4pYUXTNCGjz4kwoqWmQFL0WnZCqZIRKm1lC1BJzLE6xWiJAYA7t8QStWxLIjHk8/NtLvFweFZSpYIMWfCpEoIENdcpLuvN6ePz9N2Pt23ffX1xKWHPkBNCQw6ma5SQspIVGC0pITXVwgRfDQwxMqWmZbExVcbaxji3rLt2s736/of3gpm0LEarmgsBJKRirdbZkmuMhdACgt8uHgj8wd/5d//PP/oXh8l2fS+k4JSXmA7HSQquGt0iRpso4cnGQ5yMUTzkWkqCWruuNUbnkFIKuYKPJeVcKzIKTaNzCkLwVAsF7qzfnpwB0LuHw7xMm82WMsYohFDm2UptHp8eu7ZjHOZ51lK8ff2J9+6w3z3YuFXybnz87POr9dBsulPJIcRqGnNzfc2ADutNzlk25sNP74fV2iHe3N9nIMthz9rGproetKL080/fhpCAi1AKFc27dx95dD//ap0DdkKvmkZxkEanSN6cXXzy6nXN5fHu6dWrV63pACslUCtUKiuHu8fniEVKBYTVCICVFTHt7cM+TdZVkqVmp2eN6FBAvrxYE2DJe874qmtf/ES0IuOs1SLnqLkEAiWlEt0UvDQmxUQonaZxu15Jxo/HaRi6F2mwkhoLzvNcKgopCWE5RpKRAuVcKKWic5VAiFErFVPKBU3TxRTvHnf90AVCS61KiRyLFNI5b23QWh2PRwIlhERAEywAiIAhuFSiaTSTZprssjghRN/1ycdgXYGoAS/PT3NMQEgMKajc963gxMaFEGq02h+n4/HQD6tmY1LJNVcGIkaMHjkTDGrCjMgphZRyTJEKthpUTZUSGuN0tr14fbltTbf76R6P4aRd+ZjmZIHQQnjLV2EsjuRhtbqzu/30XClrGJyfXsI/+t3f0UYjZs6oEkIqWbH4VAgQKQQhCKRqJYUQIdimaR7un73PSptxnBkXm83QdZqQGr1z3nEhpNLOec64czOlDJFSEMsyASOqM5LLw+Hw+vLK2YUSMk1HJjljYprmpumvr2+NaXNBxXjbdb/+4XuuTdM2ybnO6G61ziUmP6/64d1PH07PLrqh+/6nH4GKq9OLtmmmZWKMtkpiSrPzMRTr3avX57OdrQ3b7YkiBChwzn0Myhjnw83tbQXeaBNmd9gfvvjqq/vD8/vb20bJy4tzLQVn5XTVt1IoCpliygUqMHhBOaXzPuYkBe+7LsXAuSAEjscZCRJKrQupIOMCgDSNySlCBaNlSikEu1mfAIF5toRVxnjOZVn8Mi/r9UbrppJil9kYbRoVY3TOt20XXdBSl1prxVByyokypiSnhMRYhBC1kmWZpeRf/Ozz69sba23O+OIsp8BiyiG6zhgAdhxtLLgdGkHLVPzQdSvTTYdpnpd2vQ4lnXUtwSC0WKzj3FRCn5+fXr96jQjX19ekklIr4zykPPQtkJxzEUICpT7GnErBLJWQXM3j2DQaGDhfQkg1Oy4M5TKVZIxKPh+Pds7h8vwsevf0eP+rX/0lUsnzfn97t5NSwn/5j/8D52wIgXFWK0GCWpvOGG8dE4xSQiqpFYBAyqkgzvNycX55d3dPgKzWQ4rOaKGkcIt9++ZtqfDh4w0XYprnvmspY9/9cL3M7uzylNP8at3mhKZprUuqaV2KIWU7jkIIHxNQHmNmlHHKd/OhlEIKrvoeABqjCCXACBCUQlDCxoPlnAGvn7zZ/rW/9jv/3X//P0rVIiasCXNtTLd73g/Dqmk0geS9TYUSIjB4YCQhSikE5yVGwfn94/7y8mpabCo1pAgcumH4+rOz+9uPUoih7UoqtDJSwRePFaNPjDAfglCqYKFAKVDMWXCuTfvNDz8isAqkMfpwOA7DSmulpcglGqOXyRqtCKm1FqOb4ALjcjeNWAqpNRc0SiMiFrTWbrYbxlnXtYfjIcRICJUANZdMiJQq5pRSWvVtKsWF2HedD2G9WlnnEOury/OU7MfrmwqUM3myPTvsxlyw6Xiw02pY+Ygf754oqeu+rQI3q9UyzRVRcKGMtt5xwmvNUlJrPYBYbNBGMsrGcRqG3jrHKI8hbDbbWguDSim/e3gQSimlx2nKBbu+xVyB1GFoj/s9Z5IyNZe5VkoJ8942Rs1j8L7Qlp2erN5cnH/z5392dXF+cXb23TfffvM8EaX54XC/Xm/bVtdK7x8fVusNAEQXjRIxBipUTNkF632ZlsXohjH+8PTcDR2jRFBSCAkuQ+FarXLmu93+6X6MOX76xVsf4tPdfa318y8+kYpLJYBwoNElLFBdWCpASo4z2Xb9+2+/3Wy2w2b18cOHZV7Eur168+b55pEC0IrOTt22m/fj68tPfv3dj/MSAWhnZN/Jy9VQj48bxX0JUMvQqFggxESwKk41xZOTze1dSMCcT0ir0ap6+4uffyGF+P7bbzmlV683wNKJaaZp2lB9tl6HZc6H6bLbHqdjYfGFI0oZU8mNaQqD6CMXSjfNYb9HAgShpMx5/dc/fONKqVySikjqsF4bpRlAyUlyaucJgM/LQkjVSi7WlYz7px3hnBBCgbZtl1I+jpNSQkiRUkJSd/u9s9Y0RkhdcsyAKRdCsVl1XdN6O7s5tV03zbP3vuu6nLMU7PrDzXE/tX1jWhOCncanUoJWihKCJVo7JmSCA1DhYlpJXRKmXIZVL7hgUP2SkfCYMJecEF4WyVxIAqTpugogpMRSgJIQneA8lbrYQyUEKJ9mByARrWmUXbxdlmEwlAMFmMYDYgbKdNswJcd5calkAG5DVvK9fXeyPRnn+TDPZli/TsQoxUXT+phT9EqIV2fnOaVGiVKZ9XtSiRtBGtlvVvZxOdnIrtHXd8/SGB8TpihBIsAS3Xw3EcJv7v54s+7PLy7ynB8O47v3D1rKz1+fGJ47Y46Te17SdBw3m1XXcWvn84urp4dx6Do7z9v1sDlZPe520ojzV58Omj/ulpgqWXNv3ao/2T8/dKa7fRz3c55n+8tffE5rFEr8b3/0/3HCdT8cx33fKcpNTvlxv2+04YoBJ5xJAHU4PA3rFUMia25F/Vu//cv7x6dv/5WnzaCRblar6TgypU5OTzPibow8K+sDUj7Z2LRdcC7lrKXxUwAOCMiZKAmtTUQwYEwIeZwcqKYG32hjlGgUK6UwUpUUWCqn3PTNcZmYEhRorUAQlhRpqzXjOZeaYTraVHEKUfTD6/PT54dHo7QxepFSCGGt5QQqYVzzvmsbISXnNpXVqnchVFLX6xUF0rdKChoE9VHa4HTTMKpSSlwrKnj0QagmlYqErFf9zd3DMAzH2bqHp2Hoc6o5egBChXrxyVEiSU2EEMYg+ghQOaXeOsbZ0PXjOMYYCcBil4wouybljFABsW0MIcVoaSfy/LR0q+39w+Pj8/707MQ0RHXMHSLnbbSHbtMUX7nRJYZcy/pk8/jwfDz6WinlEv7g7/8d5+dhMDkHzjhjapkdsCB4G3yWikxTCB4IK33Lok8hE6ZEjO7i9Cz7fFzswS5Xl+f7/aFr27ZpYgklhVZ172/vh2ET7GKUuLl/YEp+dnXuXYbKKOC07E/PTxbrCspxGqWUOUXBuRSCUboUa23hnHcDfbw/NGLT9bJmR5i4fXo83awk4OvzC1LZn/zpn1++fi1MG4J30+F0e3KY7Djaq8tLCl4pnmJumt4Gz6VwzgvATWdy8MAYMoGEJh8YUMmFlCKmRABc8EJLIQVinaeZM55SphQ4V86GCui9M027P4ycS9FIzIkhhQo2pYS46vpackzhhSxerfoY/MuV2bnQDF0MqaSSQgDOM6m8Muf9YZ64VG3XcAYcoNU6l5xT6vrWe6+UmuZJAC+Ipjc5xmyDVLoQUgl452OMUsq2awip1h6x8sVDjGHoh5IjkGqUBCBYMyLYGLRp9sdpWpbT0zNnj6thqBWlYASrEIwCTNNEAbRsnnY7LnXXdtNsGdSuayshuZQUg+Si5JwRgfHFLmcX5znl42Evhdysh5BtyXScnLWRScklDzEMRnEBUDFF7Lr17cM9MKA5MeBtY/rOzHZCQrHwH24fIyL80//4bwNUGxapVEr0/buHp8fjyfnGWQjBf/HFdtyP0eH5hZGKSdW33eqHn354+/ZqPB4f7/em6buh9fOzVqrrVs6Fbt0cdo+bblVodc4b1TqbEqlUULfMTw/j6eacMUI5Ck2tdZVB27SYi2BMCLF7fHzz5s3N03Owcd2qi9ebP/mzH8fn8vWXrwgmG8puOlycnyzzoW+7SvU47q8uL54O07Isq0YLToVulsW/Ot0C5JRjCKlWZoMvWKSQnJHWaCyZc5ELArAckpIyxSClAACsmCtWznLOmLLRJviIUCuA9wmxphS1lpRyxIpICiYleU2VEIqUYK2SQkmZUMooMM6UlpgLF9Rbz0ByLX98/44ROD85l1o97J6Ph5ky2g5N0zWCMaNkzQUxNo3JuQAhjPFSMMRYcuZK+uCGptVcHg8TcrbYdHgep+n45u1rpaTzDhEpZ6NdGq1bY6ydBWN918YYYyq1QiolpBxzAcq4kJtO1VJeun1KqhgD5xwpVkKii4Ir07SzdS4lxTkH6qN33ikpG6NJRibF0VtGQAqOpTRaMQq5pMM8GbM6HP1sXUyhX3cnm6FlkDK6EEtBUisWBEJVy5XQh/0xRs8k41Jz2aQQp+OBe2cpZ0D47nmqlMmO/6VPf+Pdx8cxH7Ynm9vnhZP62c8uJK2+4N4uj/sxpZhiPDzvT7Yn+/2sjbi82pJK9jv7fLCP8yxo5eBdWdquSSkRrJgDY9IttRbou26ad9o0D/e79Wq7WnOjtF2s9/Fh90yZ/O6nD0ipriLN/uluHxObg12dmOu78fbgjuNCmNZcpEKA4sl2PR/3DMTl2ZmgWGvOJLat6FtVgbmAlPFUyMVmZd1sF4uEFoBKmYsRKsQYgIt5mighreCMkpATZRRDlEyA4FpoIBQpvb6/U1JpJYEWxl6MLPKFpMmhLJNtVx2TMkUfCkrOsGAFVrC88HLRYWNM8vVx9ySNASRMiMN4jDma9UBJ1YKLUhRjyfnKqGQcM1KgtRIAVkouufiUCGKK8WxzTrA+Pu/b9fbpeFxiuPjkte7b+4f7itj3K611zsgphOC0VgAwLQsAMMGFUH5/6NtGazMvrmu7WuLsbQgxlyxkAkoxxM12a5clZ0KhloyPT0+6a2mFw3xo+q4CmK6lhDBCfUmLX05Xm80wuHkZ+s7ZpWSkIJYlWBuCT6t1d3G+VpJsdPPh4xOlksgSk9uuN3YObaucDVKqtm0ph5TyYX/sO32y6f4Nfsmmicbi37kAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=224x224 at 0x7F1F947B34D0>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZP7lQFZ6f3VM"
      },
      "source": [
        "Overall, the neural network is doing quite well. \n",
        "\n",
        "For many applications, MobileNet might be entirely acceptable as an image classifier.  However, if you need to classify very specialized images not in the 1,000 image types supported by imagenet, it is necessary to use transfer learning.\n",
        "\n",
        "### Using the Structure of ResNet\n",
        "\n",
        "We will train a neural network to count the number of paper clips in images. We will make use of the structure of the ResNet neural network.  There are several significant changes that we will make to ResNet to apply to this task.  First, ResNet is a classifier; we wish to perform a regression to count. Secondly, we want to change the image resolution that ResNet uses. We will not use the weights from ResNet; changing this resolution invalidates the current weights. Thus, it will be necessary to retrain the network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c8ixjIi5p8Uy",
        "outputId": "f5d16e4c-a74b-4d05-d572-337bb6dae27a"
      },
      "source": [
        "import os\n",
        "\n",
        "DOWNLOAD_SOURCE = \"https://github.com/jeffheaton/data-mirror/releases/download/v1/paperclips.zip\"\n",
        "DOWNLOAD_NAME = DOWNLOAD_SOURCE[DOWNLOAD_SOURCE.rfind('/')+1:]\n",
        "\n",
        "if COLAB:\n",
        "  PATH = \"/content\"\n",
        "else:\n",
        "  # I used this locally on my machine, you may need different\n",
        "  PATH = \"/Users/jeff/temp\"\n",
        "\n",
        "EXTRACT_TARGET = os.path.join(PATH,\"clips\")\n",
        "SOURCE = os.path.join(EXTRACT_TARGET, \"paperclips\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[751]\n",
            "('n04037443', 'racer', 0.7131951)\n",
            "('n03100240', 'convertible', 0.100896776)\n",
            "('n04285008', 'sports_car', 0.0770768)\n",
            "('n03930630', 'pickup', 0.02635305)\n",
            "('n02704792', 'amphibian', 0.011636169)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sj-mDxHekmio"
      },
      "source": [
        "Next, we download the images. This part depends on the origin of your images. The following code downloads images from a URL, where a ZIP file contains the images. The code unzips the ZIP file."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LqJXCf76qbR-",
        "outputId": "c24c5210-4184-43df-9307-34b933a7ed8d"
      },
      "source": [
        "!wget -O {os.path.join(PATH,DOWNLOAD_NAME)} {DOWNLOAD_SOURCE}\n",
        "!mkdir -p {SOURCE}\n",
        "!mkdir -p {TARGET}\n",
        "!mkdir -p {EXTRACT_TARGET}\n",
        "!unzip -o -j -d {SOURCE} {os.path.join(PATH, DOWNLOAD_NAME)} >/dev/null"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2021-11-28 08:45:31--  https://github.com/jeffheaton/data-mirror/releases/download/v1/paperclips.zip\n",
            "Resolving github.com (github.com)... 140.82.114.4\n",
            "Connecting to github.com (github.com)|140.82.114.4|:443... connected.\n",
            "HTTP request sent, awaiting response... 302 Found\n",
            "Location: https://objects.githubusercontent.com/github-production-release-asset-2e65be/408419764/25830812-b9e6-4ddf-93b6-7932d9ef5982?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211128%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211128T084531Z&X-Amz-Expires=300&X-Amz-Signature=6db9f72de68b167bd44bfec7661073997b48ed04708a827f50189f622b0395cd&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=408419764&response-content-disposition=attachment%3B%20filename%3Dpaperclips.zip&response-content-type=application%2Foctet-stream [following]\n",
            "--2021-11-28 08:45:31--  https://objects.githubusercontent.com/github-production-release-asset-2e65be/408419764/25830812-b9e6-4ddf-93b6-7932d9ef5982?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAIWNJYAX4CSVEH53A%2F20211128%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20211128T084531Z&X-Amz-Expires=300&X-Amz-Signature=6db9f72de68b167bd44bfec7661073997b48ed04708a827f50189f622b0395cd&X-Amz-SignedHeaders=host&actor_id=0&key_id=0&repo_id=408419764&response-content-disposition=attachment%3B%20filename%3Dpaperclips.zip&response-content-type=application%2Foctet-stream\n",
            "Resolving objects.githubusercontent.com (objects.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to objects.githubusercontent.com (objects.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 163590691 (156M) [application/octet-stream]\n",
            "Saving to: ‘/content/paperclips.zip’\n",
            "\n",
            "/content/paperclips 100%[===================>] 156.01M  25.5MB/s    in 5.9s    \n",
            "\n",
            "2021-11-28 08:45:37 (26.6 MB/s) - ‘/content/paperclips.zip’ saved [163590691/163590691]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PX4uUN5DkuYH"
      },
      "source": [
        "For the regression, the labels are contained in a CSV file named **train.csv**.  This file has just two labels, **id** and **clip_count**.  The ID specifies the filename; for example, row id 1 corresponds to the file **clips-1.jpg**. The following code loads the labels for the training set and creates a new column, named **filename**, that contains the filename of each image, based on the **id** column."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOHDapz2sW_V"
      },
      "source": [
        "df_train = pd.read_csv(os.path.join(SOURCE, \"train.csv\"))\n",
        "df_train['filename'] = \"clips-\" + df_train.id.astype(str) + \".jpg\""
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5NrCLEp8gQD9"
      },
      "source": [
        "We want to use early stopping. To do this, we need a validation set. We will break the data into 80 percent test data and 20 validation. Do not confuse this validation data with the test set provided by Kaggle. This validation set is unique to your program and is just used for early stopping."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KOVV842BshWp",
        "outputId": "30876803-ce16-4aa9-f8bc-68e8a8c2b862"
      },
      "source": [
        "TRAIN_PCT = 0.9\n",
        "TRAIN_CUT = int(len(df_train) * TRAIN_PCT)\n",
        "\n",
        "df_train_cut = df_train[0:TRAIN_CUT]\n",
        "df_validate_cut = df_train[TRAIN_CUT:]\n",
        "\n",
        "print(f\"Training size: {len(df_train_cut)}\")\n",
        "print(f\"Validate size: {len(df_validate_cut)}\")"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training size: 18000\n",
            "Validate size: 2000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aj_umT9VgRzI"
      },
      "source": [
        "Next, we create the generators that will provide the images to the neural network as it is trained. We normalize the images so that the RGB colors between 0-255 become ratios between 0 and 1. We also use the **flow_from_dataframe** generator to connect the Pandas dataframe to the actual image files. We see here a straightforward implementation; you might also wish to use some of the image transformations provided by the data generator.\n",
        "\n",
        "The **HEIGHT** and **WIDTH** constants specify the dimensions to which the image will be scaled (or expanded). It is probably not a good idea to expand the images."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GYiMObEJsoof",
        "outputId": "d2043497-d895-441e-9fd4-19374f01135b"
      },
      "source": [
        "import tensorflow as tf\n",
        "import keras_preprocessing\n",
        "from keras_preprocessing import image\n",
        "from keras_preprocessing.image import ImageDataGenerator\n",
        "\n",
        "WIDTH = 256\n",
        "HEIGHT = 256\n",
        "\n",
        "training_datagen = ImageDataGenerator(\n",
        "  rescale = 1./255,\n",
        "  horizontal_flip=True,\n",
        "  #vertical_flip=True,\n",
        "  fill_mode='nearest')\n",
        "\n",
        "train_generator = training_datagen.flow_from_dataframe(\n",
        "        dataframe=df_train_cut,\n",
        "        directory=SOURCE,\n",
        "        x_col=\"filename\",\n",
        "        y_col=\"clip_count\",\n",
        "        target_size=(HEIGHT, WIDTH),\n",
        "        batch_size=32, # Keeping the training batch size small USUALLY increases performance\n",
        "        class_mode='raw')\n",
        "\n",
        "validation_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "\n",
        "val_generator = validation_datagen.flow_from_dataframe(\n",
        "        dataframe=df_validate_cut,\n",
        "        directory=SOURCE,\n",
        "        x_col=\"filename\",\n",
        "        y_col=\"clip_count\",\n",
        "        target_size=(HEIGHT, WIDTH),\n",
        "        batch_size=256, # Make the validation batch size as large as you have memory for\n",
        "        class_mode='raw')"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 18000 validated image filenames.\n",
            "Found 2000 validated image filenames.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8rVZJBMIgqJq"
      },
      "source": [
        "We will now use a ResNet neural network as a basis for our neural network. We will redefine both the input shape and output of the ResNet model, so we will not transfer the weights. Since we redefine the input, the weights are of minimal value. We begin by loading, from Keras, the ResNet50 network. We specify **include_top** as False because we will change the input resolution. We also specify **weights** as false because we must retrain the network after changing the top input layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6MJpmLyhtahJ"
      },
      "source": [
        "from tensorflow.keras.applications.resnet50 import ResNet50\n",
        "from tensorflow.keras.layers import Input\n",
        "\n",
        "input_tensor = Input(shape=(HEIGHT, WIDTH, 3))\n",
        "\n",
        "base_model = ResNet50(\n",
        "    include_top=False, weights=None, input_tensor=input_tensor,\n",
        "    input_shape=None)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xF9EKVFhAGl"
      },
      "source": [
        "Now we must add a few layers to the end of the neural network so that it becomes a regression model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gXO3lTFIs_U1"
      },
      "source": [
        "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n",
        "from tensorflow.keras.models import Model\n",
        "\n",
        "x=base_model.output\n",
        "x=GlobalAveragePooling2D()(x)\n",
        "x=Dense(1024,activation='relu')(x) \n",
        "x=Dense(1024,activation='relu')(x) \n",
        "model=Model(inputs=base_model.input,outputs=Dense(1)(x))"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ErCUZTv1hJDx"
      },
      "source": [
        "Now we train just like before, the only difference is that we do not define the entire neural network here."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nonHOozTtpD3",
        "outputId": "2a54ad35-0394-4730-85dc-d6fcf7778a4a"
      },
      "source": [
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from tensorflow.keras.metrics import RootMeanSquaredError\n",
        "\n",
        "# Important, calculate a valid step size for the validation dataset\n",
        "STEP_SIZE_VALID=val_generator.n//val_generator.batch_size\n",
        "\n",
        "model.compile(loss = 'mean_squared_error', optimizer='adam', metrics=[RootMeanSquaredError(name=\"rmse\")])\n",
        "monitor = EarlyStopping(monitor='val_loss', min_delta=1e-3, patience=50, verbose=1, mode='auto',\n",
        "        restore_best_weights=True)\n",
        "\n",
        "history = model.fit(train_generator, epochs=100, steps_per_epoch=250, \n",
        "                    validation_data = val_generator, callbacks=[monitor],\n",
        "                    verbose = 1, validation_steps=STEP_SIZE_VALID)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "250/250 [==============================] - 70s 256ms/step - loss: 73.1411 - rmse: 8.5523 - val_loss: 701.4966 - val_rmse: 26.4858\n",
            "Epoch 2/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 27.7530 - rmse: 5.2681 - val_loss: 365.0618 - val_rmse: 19.1066\n",
            "Epoch 3/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 28.6821 - rmse: 5.3556 - val_loss: 130.9240 - val_rmse: 11.4422\n",
            "Epoch 4/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 18.8626 - rmse: 4.3431 - val_loss: 55.8694 - val_rmse: 7.4746\n",
            "Epoch 5/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 14.1957 - rmse: 3.7677 - val_loss: 554.3814 - val_rmse: 23.5453\n",
            "Epoch 6/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 12.8428 - rmse: 3.5837 - val_loss: 79.6855 - val_rmse: 8.9267\n",
            "Epoch 7/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 13.2751 - rmse: 3.6435 - val_loss: 316.9753 - val_rmse: 17.8038\n",
            "Epoch 8/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 11.9826 - rmse: 3.4616 - val_loss: 466.4104 - val_rmse: 21.5965\n",
            "Epoch 9/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 12.0956 - rmse: 3.4779 - val_loss: 4.5767 - val_rmse: 2.1393\n",
            "Epoch 10/100\n",
            "250/250 [==============================] - 60s 242ms/step - loss: 9.6629 - rmse: 3.1085 - val_loss: 82.4498 - val_rmse: 9.0802\n",
            "Epoch 11/100\n",
            "250/250 [==============================] - 60s 242ms/step - loss: 6.0348 - rmse: 2.4566 - val_loss: 134.9830 - val_rmse: 11.6182\n",
            "Epoch 12/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 9.1004 - rmse: 3.0167 - val_loss: 13.1667 - val_rmse: 3.6286\n",
            "Epoch 13/100\n",
            "250/250 [==============================] - 60s 242ms/step - loss: 9.2808 - rmse: 3.0464 - val_loss: 372.9783 - val_rmse: 19.3126\n",
            "Epoch 14/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.7128 - rmse: 2.3901 - val_loss: 26.7188 - val_rmse: 5.1690\n",
            "Epoch 15/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.8171 - rmse: 2.4119 - val_loss: 15.2567 - val_rmse: 3.9060\n",
            "Epoch 16/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.2777 - rmse: 2.2973 - val_loss: 61.7677 - val_rmse: 7.8592\n",
            "Epoch 17/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 8.9798 - rmse: 2.9966 - val_loss: 116.6043 - val_rmse: 10.7983\n",
            "Epoch 18/100\n",
            "250/250 [==============================] - 60s 242ms/step - loss: 6.0367 - rmse: 2.4570 - val_loss: 11.1855 - val_rmse: 3.3445\n",
            "Epoch 19/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 7.0206 - rmse: 2.6496 - val_loss: 157.4581 - val_rmse: 12.5482\n",
            "Epoch 20/100\n",
            "250/250 [==============================] - 60s 240ms/step - loss: 7.4522 - rmse: 2.7299 - val_loss: 210.9105 - val_rmse: 14.5228\n",
            "Epoch 21/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 10.0948 - rmse: 3.1772 - val_loss: 18.0399 - val_rmse: 4.2473\n",
            "Epoch 22/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.0645 - rmse: 2.2505 - val_loss: 21.2375 - val_rmse: 4.6084\n",
            "Epoch 23/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 5.7177 - rmse: 2.3912 - val_loss: 28.5047 - val_rmse: 5.3390\n",
            "Epoch 24/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 5.1064 - rmse: 2.2597 - val_loss: 47.6090 - val_rmse: 6.8999\n",
            "Epoch 25/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 4.4656 - rmse: 2.1132 - val_loss: 51.3690 - val_rmse: 7.1672\n",
            "Epoch 26/100\n",
            "250/250 [==============================] - 60s 240ms/step - loss: 3.6463 - rmse: 1.9095 - val_loss: 93.4837 - val_rmse: 9.6687\n",
            "Epoch 27/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 3.6216 - rmse: 1.9031 - val_loss: 49.9860 - val_rmse: 7.0701\n",
            "Epoch 28/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 3.9304 - rmse: 1.9825 - val_loss: 4.8757 - val_rmse: 2.2081\n",
            "Epoch 29/100\n",
            "250/250 [==============================] - 60s 240ms/step - loss: 4.6160 - rmse: 2.1485 - val_loss: 159.4939 - val_rmse: 12.6291\n",
            "Epoch 30/100\n",
            "250/250 [==============================] - 60s 240ms/step - loss: 5.9745 - rmse: 2.4443 - val_loss: 31.3900 - val_rmse: 5.6027\n",
            "Epoch 31/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 4.9073 - rmse: 2.2152 - val_loss: 44.5920 - val_rmse: 6.6777\n",
            "Epoch 32/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 4.4296 - rmse: 2.1047 - val_loss: 6.8120 - val_rmse: 2.6100\n",
            "Epoch 33/100\n",
            "250/250 [==============================] - 60s 241ms/step - loss: 6.6059 - rmse: 2.5702 - val_loss: 103.0320 - val_rmse: 10.1505\n",
            "Epoch 34/100\n",
            "250/250 [==============================] - 60s 242ms/step - loss: 3.9264 - rmse: 1.9815 - val_loss: 318.6042 - val_rmse: 17.8495\n",
            "Epoch 35/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.7293 - rmse: 1.9311 - val_loss: 245.8616 - val_rmse: 15.6800\n",
            "Epoch 36/100\n",
            "250/250 [==============================] - 61s 244ms/step - loss: 3.5809 - rmse: 1.8923 - val_loss: 3.9251 - val_rmse: 1.9812\n",
            "Epoch 37/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.6419 - rmse: 1.9084 - val_loss: 23.3965 - val_rmse: 4.8370\n",
            "Epoch 38/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.6437 - rmse: 1.9089 - val_loss: 22.4549 - val_rmse: 4.7387\n",
            "Epoch 39/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.5197 - rmse: 1.8761 - val_loss: 103.7435 - val_rmse: 10.1855\n",
            "Epoch 40/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.8539 - rmse: 2.4195 - val_loss: 272.6473 - val_rmse: 16.5120\n",
            "Epoch 41/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.8808 - rmse: 1.6973 - val_loss: 97.9878 - val_rmse: 9.8989\n",
            "Epoch 42/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.9501 - rmse: 1.9875 - val_loss: 237.1111 - val_rmse: 15.3984\n",
            "Epoch 43/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 5.9793 - rmse: 2.4453 - val_loss: 102.9308 - val_rmse: 10.1455\n",
            "Epoch 44/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.2876 - rmse: 1.8132 - val_loss: 13.3443 - val_rmse: 3.6530\n",
            "Epoch 45/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.8473 - rmse: 1.6874 - val_loss: 4.4881 - val_rmse: 2.1185\n",
            "Epoch 46/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.9382 - rmse: 1.7141 - val_loss: 13.9019 - val_rmse: 3.7285\n",
            "Epoch 47/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.5568 - rmse: 1.8860 - val_loss: 59.7056 - val_rmse: 7.7269\n",
            "Epoch 48/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.0542 - rmse: 1.7476 - val_loss: 48.3846 - val_rmse: 6.9559\n",
            "Epoch 49/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 4.0696 - rmse: 2.0173 - val_loss: 21.7313 - val_rmse: 4.6617\n",
            "Epoch 50/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 3.7122 - rmse: 1.9267 - val_loss: 118.0979 - val_rmse: 10.8673\n",
            "Epoch 51/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.6829 - rmse: 1.6379 - val_loss: 10.7841 - val_rmse: 3.2839\n",
            "Epoch 52/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.8031 - rmse: 1.6742 - val_loss: 13.8609 - val_rmse: 3.7230\n",
            "Epoch 53/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.7726 - rmse: 1.6651 - val_loss: 21.6723 - val_rmse: 4.6553\n",
            "Epoch 54/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.4007 - rmse: 1.8441 - val_loss: 77.9120 - val_rmse: 8.8268\n",
            "Epoch 55/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.0227 - rmse: 1.7386 - val_loss: 17.7745 - val_rmse: 4.2160\n",
            "Epoch 56/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 4.1116 - rmse: 2.0277 - val_loss: 20.5534 - val_rmse: 4.5336\n",
            "Epoch 57/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.5196 - rmse: 1.5873 - val_loss: 1.6131 - val_rmse: 1.2701\n",
            "Epoch 58/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 3.0357 - rmse: 1.7423 - val_loss: 72.6971 - val_rmse: 8.5263\n",
            "Epoch 59/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.4410 - rmse: 1.5624 - val_loss: 300.2112 - val_rmse: 17.3266\n",
            "Epoch 60/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.2377 - rmse: 1.4959 - val_loss: 4.8804 - val_rmse: 2.2092\n",
            "Epoch 61/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.5355 - rmse: 1.5923 - val_loss: 3.1464 - val_rmse: 1.7738\n",
            "Epoch 62/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.4223 - rmse: 1.5564 - val_loss: 149.8977 - val_rmse: 12.2433\n",
            "Epoch 63/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.3303 - rmse: 1.5265 - val_loss: 97.8213 - val_rmse: 9.8905\n",
            "Epoch 64/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.6361 - rmse: 1.6236 - val_loss: 7.0856 - val_rmse: 2.6619\n",
            "Epoch 65/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.2068 - rmse: 1.4855 - val_loss: 42.9824 - val_rmse: 6.5561\n",
            "Epoch 66/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.2291 - rmse: 1.4930 - val_loss: 27.3345 - val_rmse: 5.2282\n",
            "Epoch 67/100\n",
            "250/250 [==============================] - 61s 242ms/step - loss: 2.2970 - rmse: 1.5156 - val_loss: 5.9973 - val_rmse: 2.4489\n",
            "Epoch 68/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.8215 - rmse: 1.6797 - val_loss: 12.4237 - val_rmse: 3.5247\n",
            "Epoch 69/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.4158 - rmse: 1.5543 - val_loss: 12.4950 - val_rmse: 3.5348\n",
            "Epoch 70/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.4888 - rmse: 1.5776 - val_loss: 27.5749 - val_rmse: 5.2512\n",
            "Epoch 71/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 1.9211 - rmse: 1.3860 - val_loss: 17.0489 - val_rmse: 4.1290\n",
            "Epoch 72/100\n",
            "250/250 [==============================] - 61s 243ms/step - loss: 2.3726 - rmse: 1.5403 - val_loss: 167.8536 - val_rmse: 12.9558\n"
          ]
        }
      ]
    }
  ]
}