deep_q_learner.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "deep-q-learner.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.9"
    },
    "papermill": {
      "default_parameters": {},
      "duration": 571.103242,
      "end_time": "2021-02-19T00:41:23.588495",
      "environment_variables": {},
      "exception": null,
      "input_path": "__notebook__.ipynb",
      "output_path": "__notebook__.ipynb",
      "parameters": {},
      "start_time": "2021-02-19T00:31:52.485253",
      "version": "2.2.2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pste22/CoinPayments/blob/master/deep_q_learner.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "38eiVUYNxYrr"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wAbDESGvrkG3",
        "outputId": "2d8755b2-efc6-4b4a-d24b-63855d57314a"
      },
      "source": [
        "# info about current GPU\n",
        "#from tensorflow.python.client import device_lib\n",
        "#device_lib.list_local_devices()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[name: \"/device:CPU:0\"\n",
              " device_type: \"CPU\"\n",
              " memory_limit: 268435456\n",
              " locality {\n",
              " }\n",
              " incarnation: 15155385682615513370, name: \"/device:GPU:0\"\n",
              " device_type: \"GPU\"\n",
              " memory_limit: 14674281152\n",
              " locality {\n",
              "   bus_id: 1\n",
              "   links {\n",
              "   }\n",
              " }\n",
              " incarnation: 3123617642910169614\n",
              " physical_device_desc: \"device: 0, name: Tesla T4, pci bus id: 0000:00:04.0, compute capability: 7.5\"]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RPTPrCICrs1O",
        "outputId": "7c6ee1f6-edd3-490d-8c0a-d4c8c8555b9e"
      },
      "source": [
        "# Ram Info\n",
        "#!cat /proc/meminfo"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "MemTotal:       13333564 kB\n",
            "MemFree:         2528524 kB\n",
            "MemAvailable:   12001652 kB\n",
            "Buffers:          231484 kB\n",
            "Cached:          8929032 kB\n",
            "SwapCached:            0 kB\n",
            "Active:          1732924 kB\n",
            "Inactive:        8335644 kB\n",
            "Active(anon):     702924 kB\n",
            "Inactive(anon):    10604 kB\n",
            "Active(file):    1030000 kB\n",
            "Inactive(file):  8325040 kB\n",
            "Unevictable:           0 kB\n",
            "Mlocked:               0 kB\n",
            "SwapTotal:             0 kB\n",
            "SwapFree:              0 kB\n",
            "Dirty:               628 kB\n",
            "Writeback:             0 kB\n",
            "AnonPages:        908100 kB\n",
            "Mapped:           560152 kB\n",
            "Shmem:             11272 kB\n",
            "Slab:             496100 kB\n",
            "SReclaimable:     442760 kB\n",
            "SUnreclaim:        53340 kB\n",
            "KernelStack:        4432 kB\n",
            "PageTables:         8944 kB\n",
            "NFS_Unstable:          0 kB\n",
            "Bounce:                0 kB\n",
            "WritebackTmp:          0 kB\n",
            "CommitLimit:     6666780 kB\n",
            "Committed_AS:    3679800 kB\n",
            "VmallocTotal:   34359738367 kB\n",
            "VmallocUsed:           0 kB\n",
            "VmallocChunk:          0 kB\n",
            "Percpu:             1048 kB\n",
            "AnonHugePages:         0 kB\n",
            "ShmemHugePages:        0 kB\n",
            "ShmemPmdMapped:        0 kB\n",
            "HugePages_Total:       0\n",
            "HugePages_Free:        0\n",
            "HugePages_Rsvd:        0\n",
            "HugePages_Surp:        0\n",
            "Hugepagesize:       2048 kB\n",
            "Hugetlb:               0 kB\n",
            "DirectMap4k:      199880 kB\n",
            "DirectMap2M:     6090752 kB\n",
            "DirectMap1G:     9437184 kB\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hQ6Yc7SOxYru",
        "outputId": "2e7a895e-bbdd-4111-caab-6e319eb84874"
      },
      "source": [
        "#GFootball environment.\n",
        "!pip install kaggle_environments\n",
        "!apt-get update -y\n",
        "!apt-get install -y libsdl2-gfx-dev libsdl2-ttf-dev\n",
        "!git clone -b v2.3 https://github.com/google-research/football.git\n",
        "!mkdir -p football/third_party/gfootball_engine/lib\n",
        "!wget https://storage.googleapis.com/gfootball/prebuilt_gameplayfootball_v2.3.so -O football/third_party/gfootball_engine/lib/prebuilt_gameplayfootball.so\n",
        "!cd football && GFOOTBALL_USE_PREBUILT_SO=1 pip3 install .\n",
        "\n",
        "# Some helper code\n",
        "!git clone https://github.com/garethjns/kaggle-football.git\n",
        "!pip install reinforcement_learning_keras==0.6.0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: kaggle_environments in /usr/local/lib/python3.7/dist-packages (1.7.11)\n",
            "Requirement already satisfied: jsonschema>=3.0.1 in /usr/local/lib/python3.7/dist-packages (from kaggle_environments) (3.2.0)\n",
            "Requirement already satisfied: six>=1.11.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.0.1->kaggle_environments) (1.15.0)\n",
            "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.0.1->kaggle_environments) (20.3.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.0.1->kaggle_environments) (56.0.0)\n",
            "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.0.1->kaggle_environments) (3.10.1)\n",
            "Requirement already satisfied: pyrsistent>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema>=3.0.1->kaggle_environments) (0.17.3)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->jsonschema>=3.0.1->kaggle_environments) (3.4.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->jsonschema>=3.0.1->kaggle_environments) (3.7.4.3)\n",
            "Hit:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n",
            "Ign:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
            "Hit:3 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n",
            "Get:4 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n",
            "Hit:5 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Ign:6 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Hit:7 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release\n",
            "Hit:8 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Get:9 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n",
            "Hit:10 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n",
            "Hit:11 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n",
            "Get:12 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n",
            "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Fetched 252 kB in 2s (151 kB/s)\n",
            "Reading package lists... Done\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "libsdl2-gfx-dev is already the newest version (1.0.4+dfsg-1).\n",
            "libsdl2-ttf-dev is already the newest version (2.0.14+dfsg1-2).\n",
            "The following package was automatically installed and is no longer required:\n",
            "  libnvidia-common-460\n",
            "Use 'apt autoremove' to remove it.\n",
            "0 upgraded, 0 newly installed, 0 to remove and 45 not upgraded.\n",
            "fatal: destination path 'football' already exists and is not an empty directory.\n",
            "--2021-04-30 06:11:59--  https://storage.googleapis.com/gfootball/prebuilt_gameplayfootball_v2.3.so\n",
            "Resolving storage.googleapis.com (storage.googleapis.com)... 172.217.9.208, 172.217.12.240, 172.217.164.144, ...\n",
            "Connecting to storage.googleapis.com (storage.googleapis.com)|172.217.9.208|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 45163384 (43M) [application/octet-stream]\n",
            "Saving to: ‘football/third_party/gfootball_engine/lib/prebuilt_gameplayfootball.so’\n",
            "\n",
            "football/third_part 100%[===================>]  43.07M   205MB/s    in 0.2s    \n",
            "\n",
            "2021-04-30 06:11:59 (205 MB/s) - ‘football/third_party/gfootball_engine/lib/prebuilt_gameplayfootball.so’ saved [45163384/45163384]\n",
            "\n",
            "Processing /content/football\n",
            "Requirement already satisfied: pygame==1.9.6 in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (1.9.6)\n",
            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (4.1.2.30)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (1.4.1)\n",
            "Requirement already satisfied: gym>=0.11.0 in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (0.17.1)\n",
            "Requirement already satisfied: absl-py in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (0.12.0)\n",
            "Requirement already satisfied: wheel in /usr/local/lib/python3.7/dist-packages (from gfootball==2.3) (0.36.2)\n",
            "Requirement already satisfied: numpy>=1.14.5 in /usr/local/lib/python3.7/dist-packages (from opencv-python->gfootball==2.3) (1.19.5)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from gym>=0.11.0->gfootball==2.3) (1.15.0)\n",
            "Requirement already satisfied: cloudpickle<1.4.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym>=0.11.0->gfootball==2.3) (1.3.0)\n",
            "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym>=0.11.0->gfootball==2.3) (1.5.0)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym>=0.11.0->gfootball==2.3) (0.16.0)\n",
            "Building wheels for collected packages: gfootball\n",
            "  Building wheel for gfootball (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for gfootball: filename=gfootball-2.3-cp37-cp37m-linux_x86_64.whl size=38649863 sha256=84f3fc018f96d8d86110737b579ed6bd2dffeaf0fe8c71780d0f85c1b9640db4\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-6v3apo9b/wheels/41/ad/ae/8cf1d92b8694b10187e5daf33e8d5c248ffa5437e234ccbbee\n",
            "Successfully built gfootball\n",
            "Installing collected packages: gfootball\n",
            "  Found existing installation: gfootball 2.3\n",
            "    Uninstalling gfootball-2.3:\n",
            "      Successfully uninstalled gfootball-2.3\n",
            "Successfully installed gfootball-2.3\n",
            "Cloning into 'kaggle-football'...\n",
            "remote: Enumerating objects: 116, done.\u001b[K\n",
            "remote: Counting objects: 100% (116/116), done.\u001b[K\n",
            "remote: Compressing objects: 100% (96/96), done.\u001b[K\n",
            "remote: Total 116 (delta 39), reused 91 (delta 18), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (116/116), 3.14 MiB | 31.81 MiB/s, done.\n",
            "Resolving deltas: 100% (39/39), done.\n",
            "Requirement already satisfied: reinforcement_learning_keras==0.6.0 in /usr/local/lib/python3.7/dist-packages (0.6.0)\n",
            "Requirement already satisfied: tensorflow==2.3.1 in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (2.3.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (4.41.1)\n",
            "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (4.1.2.30)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (3.2.2)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (1.0.1)\n",
            "Requirement already satisfied: coverage in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (3.7.1)\n",
            "Requirement already satisfied: gym[atari]==0.17.1 in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (0.17.1)\n",
            "Requirement already satisfied: scikit-learn==0.23.0 in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (0.23.0)\n",
            "Requirement already satisfied: seaborn in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (0.11.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (1.19.5)\n",
            "Requirement already satisfied: dataclasses in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (0.6)\n",
            "Requirement already satisfied: mock in /usr/local/lib/python3.7/dist-packages (from reinforcement_learning_keras==0.6.0) (4.0.3)\n",
            "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.36.2)\n",
            "Requirement already satisfied: keras-preprocessing<1.2,>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.1.2)\n",
            "Requirement already satisfied: h5py<2.11.0,>=2.10.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2.10.0)\n",
            "Requirement already satisfied: gast==0.3.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.3.3)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.15.0)\n",
            "Requirement already satisfied: protobuf>=3.9.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.12.4)\n",
            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.1.0)\n",
            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.3.0)\n",
            "Requirement already satisfied: google-pasta>=0.1.8 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.2.0)\n",
            "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.32.0)\n",
            "Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.12.0)\n",
            "Requirement already satisfied: tensorboard<3,>=2.3.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2.4.1)\n",
            "Requirement already satisfied: astunparse==1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.6.3)\n",
            "Requirement already satisfied: tensorflow-estimator<2.4.0,>=2.3.0 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2.3.0)\n",
            "Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.7/dist-packages (from tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.12.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->reinforcement_learning_keras==0.6.0) (0.10.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->reinforcement_learning_keras==0.6.0) (1.3.1)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->reinforcement_learning_keras==0.6.0) (2.8.1)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->reinforcement_learning_keras==0.6.0) (2.4.7)\n",
            "Requirement already satisfied: cloudpickle<1.4.0,>=1.2.0 in /usr/local/lib/python3.7/dist-packages (from gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (1.3.0)\n",
            "Requirement already satisfied: pyglet<=1.5.0,>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (1.5.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (1.4.1)\n",
            "Requirement already satisfied: atari-py~=0.2.0; extra == \"atari\" in /usr/local/lib/python3.7/dist-packages (from gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (0.2.6)\n",
            "Requirement already satisfied: Pillow; extra == \"atari\" in /usr/local/lib/python3.7/dist-packages (from gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (7.1.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn==0.23.0->reinforcement_learning_keras==0.6.0) (2.1.0)\n",
            "Requirement already satisfied: pandas>=0.23 in /usr/local/lib/python3.7/dist-packages (from seaborn->reinforcement_learning_keras==0.6.0) (1.1.5)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from protobuf>=3.9.2->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (56.0.0)\n",
            "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.8.0)\n",
            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2.23.0)\n",
            "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.0.1)\n",
            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.3.4)\n",
            "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.4.4)\n",
            "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.7/dist-packages (from tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.28.1)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from pyglet<=1.5.0,>=1.4.0->gym[atari]==0.17.1->reinforcement_learning_keras==0.6.0) (0.16.0)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.23->seaborn->reinforcement_learning_keras==0.6.0) (2018.9)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.24.3)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (2020.12.5)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3,>=2.21.0->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.0.4)\n",
            "Requirement already satisfied: importlib-metadata; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from markdown>=2.6.8->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.10.1)\n",
            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.7/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (1.3.0)\n",
            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.2.8)\n",
            "Requirement already satisfied: rsa<5,>=3.1.4; python_version >= \"3.6\" in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (4.7.2)\n",
            "Requirement already satisfied: cachetools<5.0,>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (4.2.1)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4; python_version < \"3.8\" in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.7.4.3)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata; python_version < \"3.8\"->markdown>=2.6.8->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.4.1)\n",
            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.7/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (3.1.0)\n",
            "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.7/dist-packages (from pyasn1-modules>=0.2.1->google-auth<2,>=1.6.3->tensorboard<3,>=2.3.0->tensorflow==2.3.1->reinforcement_learning_keras==0.6.0) (0.4.8)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M_1_MvNdxYrw"
      },
      "source": [
        "import collections\n",
        "from typing import Union, Callable, List, Tuple, Iterable, Any\n",
        "from dataclasses import dataclass\n",
        "\n",
        "from IPython.display import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from tensorflow import keras\n",
        "import tensorflow as tf\n",
        "import seaborn as sns\n",
        "import gym\n",
        "import gfootball\n",
        "import sys\n",
        "from statistics import mean\n",
        "\n",
        "sns.set()\n",
        "\n",
        "# Tensorflow 2.0 preview release which has eager execution enabled by default. \n",
        "# Training keras models in a loop with eager execution on causes memory leaks and terrible performance.\n",
        "#ref : https://stackoverflow.com/questions/53429896/how-do-i-disable-tensorflows-eager-execution\n",
        "\n",
        "tf.compat.v1.disable_eager_execution()\n",
        "\n",
        "sys.path.append(\"/kaggle/working/kaggle-football/\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_2QfErvZxYrw"
      },
      "source": [
        "# Q-Learning\n",
        "\n",
        "Q-learners are off-policy temporal difference leaners \n",
        "\n",
        "Ref : (https://lilianweng.github.io/lil-log/2018/02/19/a-long-peek-into-reinforcement-learning.html#model-transition-and-reward) \n",
        "\n",
        "## Components\n",
        "\n",
        " - Agent\n",
        "   - Model, usually a neural network \n",
        "   - Replay buffer (the agent's memory)\n",
        "   - Exploration method, such as episilon greedy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUCqn32AxYrx"
      },
      "source": [
        "## Model\n",
        "\n",
        "Using the GFootball enviroment with the Simple115StateWrapper which returns observations (state) as a (115,) array. \n",
        "\n",
        "Simple115StateWrapper is a simplified representation of a game state encoded with 115 floats, which include the numerical coordinates of all the players, ball positions, ball ownership, game modes, etc.\n",
        "\n",
        "This array will be used as the input to a very simple neural network with 3 layers, which will output an estimated value for every possible action. The agent will either select the action with the highest value as estimated from this model, or randomly (chance depending on epsilon) select a random action.\n",
        "\n",
        "To make learning more stable with deep-q learners, two copies of this model are used by the agent. \n",
        "  - \"Action\" model This copy is updated every training step and is used to estimate the value of actions for the current state. \n",
        "  - \"Target\" model\" The copy is updated by copying the weights of the value model, this is done less frequently in order to keep the training target more stable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LgdQqEO0xYry"
      },
      "source": [
        "class DenseNN:\n",
        "    \n",
        "    \"\"\"\n",
        "    :param observation_shape: Tuple specifying input shape.\n",
        "    :param n_actions: Int specifying number of outputs\n",
        "    :param output_activation: Activation function for output. Eg. \n",
        "                              None for value estimation (off-policy methods).\n",
        "    :param unit_scale: Multiplier for all units in FC layers in network \n",
        "                       (not used here at the moment).\n",
        "    :param opt: Keras optimiser to use. Should be string. \n",
        "                This is to avoid storing TF/Keras objects here.\n",
        "    :param learning_rate: Learning rate for optimiser.\n",
        "\n",
        "    \"\"\"\n",
        "    def __init__(self, observation_shape: List[int], n_actions: int, \n",
        "                 output_activation: Union[None, str] = None,\n",
        "                 unit_scale: int = 1, learning_rate: float = 0.0001, \n",
        "                 opt: str = 'Adam') -> None:\n",
        "        self.opt = opt\n",
        "        self.learning_rate = learning_rate\n",
        "        self.output_activation = output_activation\n",
        "        self.unit_scale = unit_scale\n",
        "        self.n_actions = n_actions\n",
        "        self.observation_shape = observation_shape\n",
        "        \n",
        "\n",
        "    def _model_architecture(self) -> Tuple[keras.layers.Layer, keras.layers.Layer]:\n",
        "        \n",
        "        obs_shape = self.observation_shape[0]\n",
        "        frame_input = keras.layers.Input(name='input', shape=obs_shape)\n",
        "        fc1 = keras.layers.Dense(int( obs_shape/ 1.5 * self.unit_scale), \n",
        "                                 name='fc1', activation='relu')(frame_input)\n",
        "        fc2 = keras.layers.Dense(int(obs_shape / 3 * self.unit_scale), \n",
        "                                 name='fc2', activation='relu')(fc1)\n",
        "        fc3 = keras.layers.Dense(self.n_actions * 2, \n",
        "                                 name='fc3', activation='relu')(fc2)\n",
        "        action_output = keras.layers.Dense(units=self.n_actions, name='output',\n",
        "                                           activation=self.output_activation)(fc3)\n",
        "\n",
        "        return frame_input, action_output\n",
        "    \n",
        "    \"\"\"\n",
        "    Compile a copy of the model using the provided loss.\n",
        "\n",
        "    :param model_name: Name of model\n",
        "    :param loss: Model loss. Default 'mse'. Can be custom callable.\n",
        "    \"\"\"\n",
        "\n",
        "    def compile(self, model_name: str = 'model', \n",
        "                loss: Union[str, Callable] = 'mse') -> keras.Model:\n",
        "        # Get optimiser\n",
        "        # we can add as many optimizers as we want under elif\n",
        "        if self.opt.lower() == 'adam':\n",
        "            opt = keras.optimizers.Adam\n",
        "        else:\n",
        "            raise ValueError(f\"Invalid optimiser {self.opt}\")\n",
        "\n",
        "        state_input, action_output = self._model_architecture()\n",
        "        model = keras.Model(inputs=[state_input], outputs=[action_output], \n",
        "                            name=model_name)\n",
        "        model.compile(optimizer=opt(learning_rate=self.learning_rate), \n",
        "                      loss=loss)\n",
        "\n",
        "        return model\n",
        "    \n",
        "    def plot(self, model_name: str = 'model') -> None:\n",
        "        keras.utils.plot_model(self.compile(model_name), \n",
        "                               to_file=f\"{model_name}.png\", show_shapes=True)\n",
        "        plt.show()\n",
        "\n",
        "\n",
        "DenseNN(observation_shape=(115,), unit_scale=0.25, n_actions=19).plot()\n",
        "Image(filename='model.png')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9s1BJxJ7xYry"
      },
      "source": [
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABGMAAAFeCAYAAAAhcdLQAAAgAElEQVR4Aey9eZxURbbv63/3fT73nXPuGfr9ce879/NudzMUQ6lAqYAD4NAtcGSwBQUaHBBpxUIBEVRkcGCQWRAVBAQZRBBksARpQIupQEtBwQkVKcFuBJWpLaWo9T5rR66M2LFjZ+6szKyqrPrx+RR7587YESu+K8aVESsuIvwDARAAARAAARAAARAAARAAARAAARAAARCoNgIXVVtKSAgEQAAEQAAEQAAEQAAEQAAEQAAEQAAEQIBgjEEhAAEQAAEQAAEQAAEQAAEQAAEQAAEQAIFqJABjTDXCRlIgAAIgAAIgAAIgAAIgAAIgAAIgAAIgAGMMygAIgAAIgAAIgAAIgAAIgAAIgAAIgAAIVCOBOmmMKS9ZTP/07xO8v8Z3bKbvPaDf0YI/j48/n7m3GikjqawQOP9tEXX9F6Xnf/3NcvowK6kgUiZwZOUAatx0Kh2sRhxHd82h269pRQ3y8mnYupMppnycFvVvTNdO2W+8V0qjGzSnYWtSjcuIArfVRoDLXMMm99OGvyVLEnpNRgjfg0DVCJTTwVVPUvfWzalBXgHN3UdU/t6EiPWyainm2ltR26mKk5to6BWtqO+c/fRLrmUyo/KivY6KM91xV2XFAZrVpQW1f7CI6sKo5/jGR6lly560cN+vUREiXA0QOH/sNerbKD+nxtrBuuaaQ2QPZkRjjN+QIYaORNcoxo7Dr86OG0dccbV+xpxIRYdQk8aYE4e20wujXqTrr1dGAs7XvzWeTH/oNpee3/tT9EwgZFICVTXGnD9cRLc2nED//B/Taebef3jpmGXGVRa1UU+LVXn+Oype8SoN6jeNmjfW+m52/XTqPfRdKqOfadczU70y/r9vWEkHyvW7NX0njSUbOhL9zS5VkgYbquzm4JeDz9F1jfOp+6Ov0rYd62nDzhMpJuhqSDEITBFijQaPOskhqht6PV/2GvVr0Y1mlaqBJk96w+rmZQPXBAfXFeX09fYlNGrQLXRFS12vG7W8lm4dvcULf/q9CXR9y0H0dlIDV42qHonXEgLH3xxGTfMK6I5n36QdW5bS1i9gjLFVE7WdOn9sLd3dGsaYutJe2+UgG5/THXdVlpfS1DpkjClbez+MMdkoaBmOU+YXufTDZ7CuueYQGQZlRJfUGHPh7I/040+f0HO99KoS12TVflb/jDHfU9GTU+l/x1bk2Dz488BVxw30df/2wtky2rt2Aw27dxo9tCbzea+aMeYgPd1BleU2o/eQ2EdSNcac+XQd3X6pNsDY+tYrdXR6XZ7ZH0+vprVfWV5G7+8ooZ2xv+J1k6hj43wa9vLe+DP+7usflKTBhiq7Odg5vSnlFUylAxeqmo6rIa0bk/aqEsn8e2W0dvQDNHpDdn5zizrJqQuD+8qKMm8lV6+5n8XVJMYYu05yvdz94VHfr+sXTpXS1NtaeKsX2vUZSRNnLqcNO96l5S/NpCkTHqY+D8kvo+W0a3onunKQfI4nVy9uzh/eRI/fPwLGqEjaPk4rBjYm2/CX7sqYE+8toMG95zlWWZ6i3QuGU/8Xq/YjXKQsZSFQ9HYqC4lnMMrqqxvoh6OqrbrHXVHlyly47I4hMidnXYspu21tKsaY6mt3EuswWNdcc4jEcaTzbVJjzLsLltAb775HWyP8bXl3DfX7JzVBTdUYU9VVMK7MmxNrvaLBv7oninyuuN3PymjBAG2s+s8bFtCSvUep/LwKfeHsd7R/43Kauj7zBgm3PLXj6bbxT8VXPmXDEFUVY4ysxvqX/3iB3jimObnLjP7evDtVspha/6s2xPSauos+OyFmnZ/p5Dcf0Asj19EnsZd++usCz0jHK3Fe/MiMqfbcS+MpK2FsyYINlR0ik59P0RtDGgYmAaml4GpIMQhMjWGy0NnlGX2Sk105klHIxPe8AiG/1QQqNfYviDEmrE5KuhfOldKYG5tSXtuhtPLTM/I49Hrh7FYaeUkrmrqz/i31TteQEAq1Tn5xgKa0b2Zt9Ux/ZUx4X+Jqs2s/2OjtVO3OS/XVjdxvr6tLk+F1pbokyHY6KAvZJuyOP7ttrcwnoqyMqb52x01CngbrWnYZSbpyTWqMKX5tY8zniryS6FpKo/5b/TPGHH59VnxFzH/esJxKzyViVH++q33GmP30dBtVPlsZq2JYI1GNMZU/76fR12pDzP2rDItOqGp1upcNe5dOhYaruS+k8Qyb+AUbqmzKqhpB+xfZ1FJ0NaTo+FNjmCx0dnlGn+RkV45kFNL/vozm9mhC97zqb0uiGWPKaefE66hxq/tp/dHokrw/qwO1HlJEyU030ePMhZC1ZeCXC6xkxZnf7xaMMbbuordT9pu163P11Y1cb6+rT2/VO+6qvnzplFAWNIvqvHONjzOXvswnYIyJzjQHjDHhK1rCJtDu58F4fnpHrVjgLSa/ybMdwH5Ns29Sq13+5T/m0cbQlfh6os3xPLlV+SBJroLzVFbyFo27V/sbYd8yne9bRhs+8fuWsVeAvP/TR/T8gzPjfkouu3Uxrf7ctAD58zpj1ynas3gedWqtjAi/b/MsjV75VWDLzIWfPqEVE16g62LhftNyMvV5vIg+duS94rsPaNFEHZbz3vz6Z2lG8SmfYcPevmOugEotvb008S/PUIN/U3ngPL+66Y2UHPhyuZBtZE9uNX6CTsEY87c35sRX+/y+x1tUllzRXojdsyZ67yUuSxEjy0IwaTyTGWMOXDhNH7JDx5hj3cs7D6H5JUF/LpUVx+mdecPj4S5u35dGzt9LJysSC8+DD9tPhjhxTSRjcNDi6mz8Hf+p4nHUNC+fRm866xBKTZCjTFgrju2mOcPvouvbsJPLfGrcthsNfXG/b6LrCnPniEX0XgCdlpHfmT7oJro0L5/Y70ffcUX0ncVP8u3Sy5J9wal2Knq5cPogrZo0mDq3U06UWYY+I4roOyLaOfG3oXoSmGc/W0dPxORvkHcl3VQ4hTZ+4a93HNaW6ZL2g2jG1mN0KE0HvicPcvraf4pdVlPV/4VzhzweomeOb9qGr33bhWQCO2z1MRIH1FJ+hYt9/fXQK9SxcU9a9ZX/myjGmIqTa6l/o3wasORr/8tJPrFPpqvzojhHVhFVqfwe30VzhveO+a+Jrn93WxGrFyFc7bLq1cE5Znuj3rfbFtvge3TXAirs1d5rF1R5D9ZRKa+9O7Xx6oBZL5Jgj5d1eZfrRef+I+mVQBuq2y/O25IxmmOXwsX0cbBqO5NOzsX5mrN+iwP3sEl7svom7betAzb2uNp9Dmf2RynVvzUnKUr7ybmvyXbKZHl0+/M0oKMqU1wHJm3wG2fjbQvnLULdkr4h6HRfly2l/Wh1Q5cUtXL10p6v0jf6oXe3c2IzatTkESq2yueWp39HOnyiPm4NHTaHsrH4o+hIWK4/eoK2zR7otTtm/Y5WfqwMGR+jvp9KnbPD2m2J6NDVv7vGXYa4sVtb1/w4Ef/wMcZBKqdP1k3yldHgmE7Hbcsi+hGH/FHGEMni4O/Ta49P04frJtE9XVWbz07KeZvvpiM65cqKYJiru7v6fn3QhUtf9njM5JG87it5ovRPiklQZslX5tramEzb/X3moMnb6cg3KyM48I3W7tj9ysXtetIDk4uc7YTWmr5zlY++44LtjNQ13V666o6ON9N39doYQ6QNKf/875N9W0hMA8jFCVYz/HpoHbWPbVn5H795hXbLbpWEmjpL2yYn9i/z5znc9Kl/piy81eVqwzmwGDt+k2em7TfGXH399LgBQcLzdVKxnhidP/x2qA+Uf897gdYYjdOpkmXUoZFeHWLGyduRTGOY+R3fizEmU+lJ/NpHSzh4bRB5gd76uz+cKbPe2uYPQ/QzFT36dJxl70UGFDuo9dk0BD32Vu1bGyMDZXPwa2aBG6pGTcbS+GdupltHL6dtO0o8h47DOjajhk36+iaS7P9i8cBLqFGrvjR1dbHng2bz0lHUqUU+XTN8i89IYabB9+fKPqCdO9bT2Jub0iU9ptIGz6fNh3SsnCiRjNEaUv9AgU8a4GX4bR0y8WT1qryCpFs52CEqOxpu2X0kLdywx8tr8bqFNGyc9slx+r3pXt7NMJtXTaLbWjd3rGhQMt49cTLdfs3d9GIsztdn9PImiNc9vdc3+U+ml9eNIpqKXjxnspc2p7y2d8d1uGPLKnry3rmer4cfPttNO3Ys8AwBvSYWxfwMKT2xHoULTxyVDtfTtDuuoAZNutHLn2qta5l60sj5b8b53d+1Df2x040RT23x65VjV2WlgHo8pNOfwD5VmnSjF2MnMaSif9kK1LzzkLieX599h2coM/28yED3jmEj6O6ntic1PrKsZasHUPMb5tEhjcW748GaPSG1gtCpbeOoYZOgIccOZ3+urCil0Zc0DzFE+kNXpfwOfnk1je3aw6fTAR2bBcq71n+ytkLp2M1VDZrM+iX15dZZcnLNKfpsRwm9s6DQ4zUtVq9M3zts/GNntf0mrtbtW9eW1LjVI/Tuj8KEJ6IXe/VC6ibX5TvazXb4QJF31JXL0PguLalRK13WuU6Nu/MKz9cPG/D0P5Wnto9O8TiOXa7bUW5vWvR61TOK6vCuuyhcXO8RmfW79YOLY/X7K6/tNicR8nak+hbzU7Zq/M3UqMlQWrxT+Swr+eKMr93X6WmfZanWv6jtZ023U4rlABr/zL3Uof+8eFvptVWB/kfVgah1K9gnirbsSUbyuiFvyvXvawc52mbVn3KbNaXY3AKpnt8ZNxgn7uOufWK7r4+LqiNh+eCwu2jyVv8viNHLj+TQf43+fvQ6l6yPZQmS9e+2Ad8vNX+ydc3PEvN3jTHYELvi9XuoQ/8ptGoLj3PepSXj1Zik5xRpY3XcrhURdrthtjGuMUQwL65VeVVvj6XvYYP4gMmqzed8LZ30F1q4T6XOYVYUXkb+MOtpztA/eeMxf96T68scj0l5jVb3yftxKnn/xMYpNf72y6zzZY6x02trtUzmOIvZXNapK13FPigTnlyavN05tPp+b4x1VbzcldDqecO98XR+56n0cYS1D2z0M8exPBfhPtT2mxdsL111x1UqM/Os1hhjZFItV+3Tw29YMH29hE2g3c/d8cgEndM1J9fmCgjTaGFjN9P6bfdoKyXEhwin+Z83LKYtf1c/d5/9tpgejm2BMf2LmMYYfqf//M+9rS4V3++k4W21UUSv9vDntdEd6+jzU0SV53+koicnxY0JeqvO1/Rcd7UKiNPl1S3878whdeoQp3nlE8rZ7flv3/ZOIuJnHHbkys/plOcb5zx9v+8tmve29osTvk0penpE2gEup3nvyyrvvKpmjuGnJ7kx5ntaerfK42/yVsb9uYg+TT1yOvafKnd+rpq3xBJ+rfjubeoZO4a73TRtew1/o3q/SWToYEm4oeJBlt358K/6XRvnUw/D8SiH5dUA9raJU7sm0NV5HX2TcXcuVSNo/qrF4RLJGK0hVYMQs4P4YklPb2KwOT7ZUhLxNg6eIH+RwIEwH1V636XNqe19awIrViRffJrBmA7NnGFkgOdffaNkDG47Kaei0c0DvzpmQy+ekeLGppS8swvy5HxLnrtN8huOeJDAx42bxi9P/ib6BKE4NzaU3djUMeCXEOY1KMf5Y5toebE1ID+7lYY0bE4dJu2NvxxN/2orULPrp1Kp1fkfWn6PpRMlS7KyExcgtsrIZCLf8WCN65zrT4ymzK9R0wlUou3q8nqSq6pjf5yV2Fmq6NJVxhOVX1f9V75qmgf07wobbCsScT1ORcuKLcNXORWNaEA8ifjAqMP2hEAgSdsy9DXTIEJ04dwur/5K+1ZxfK33i1/hSn84slasSbz6mmg7GX/XyWqHlH7YeCina0lcB16+lRpEbEejcpG4/VfFPMo2paj1jeMPttWSatjgN/X6F6X9lLJdk+2U1HG7frnqikyiXfXFFT5VzmF1Q7RjXqW+mKtK+QeMa1o9Qg88kEc3TNHtilr5Z/b7qlxlWkfC8pbntRN0JXMq5cfMpdyn8n60tihqH+v1jxHHXSKt/+qqU9H5c1wig11P+LtgW6TiNsdYIo+7fIWHl/fMqx1H1dtjovfndPR+nLHbVzM9L++ONpjDKON9R1r4sX5DWEUZJ0t5jVL3pb4l659Ykij5chvp+O3oZV1ksvPqyTCrozducZUDTUvd2TqV7xPFL4bMYF2Xt/V1z5qlgVU0H8/vSg2bDPDNUVh3svpTve2qOzreTN/Ve2MMr2z54/9Qk2+9IuIHWv2AWgHhX3ESxG9O4qMZY3TcPOG3J/TiYJa/uyZ2tLdpjLGNDruecTnJ9RsNntmt5f7l/WXxrTqS31/2vUYtYtt/tIGG39GySroH50+JGyo6P5vYqBBmjEklPTOszddclSTy6Zzad2U0/zZljJF8myFMPdqGGP6crjGGB1LiT+ny8bHzok0BavheGj6Z5NnicENlN14qzCGa272J4eRRfb7G+nWLw1ZW7KLRDZonsZZzSNUIVocxRvL9yJt6q5KsGrB9eLiY8C+8tiHHDMcrF3jiZHbY5veK6/20Ob5dSQ1OTIOBhGcnr7YOwvWifo3U8UTXC3eOTRPILPLI5MDucBOt1ji0vJ/R4ZXRor55ob5LOCxPPGRZs07Xvos6oAuWqyj6ryzfSiMaNCf9y65OnwcFtzYyt1OE60+/Zd6pJf/2hJdDyGDNdZpSJk4541+MXOn6pKti+XXVf473/TkdDANJ9DIpZU2XZ1NK973ULbP8hA38DrzcNdSoxVsspC2qLN9FIy9JbIB1SSNlKGzwKOVw2DoxIKqyWnDnmsAKGG/VXuN8mlXiSin5MxcX91uqLNtlJIxhMI5gfeMwnL5/0CtvqvB2esIu3fpnt5+1oZ2SOh7UpWoX/PpX+ohWt1LnHF2vrC+1jdeUhesQfz646h7fSj/Wt984Hd5GKp3oNj+6jnR7abNMrfxIWdTXdN/nmOw6x6yj9LHqPf+kUUlmj7u0vP47V50K52/XES27e/XlhVMb6d6GzUkbp1Xc9piA43GXr/Dw/nyoT3YcVW6PYytDw9pjlZpi7P+xTEsl40TzB41wfdnjsfDyShSs+5H7p0j54jy4ygX/kBZ9rMPjs7Dxr4yLXOVAE1R3tk7ley/PCcbXvCWySUHyFakSn3nlNPlHLnO+w7rz90tuRmY8mbyvNcYY2b4SzJzfsJDplTFE39OygX7fMBd+3kmF/10ZaJIZHMxJfHKDAOduP436nYpbr/7RuTbjE6NBImOMabzRJxaFMzPjkvjZAbHLAGE+U7KejK8u0QYKLbt9F2aMiZ4ekRnWLiNmXpKz18YQybcpr4u7+b2693NNNln3v584fQl7/sgi6nzRRXRRhv5+23NZJAfcMhkwGyeRia/SUJm/MqvvVYMlkxWZNLl+zZdn9mDbTMcdp3qaSEaRT5sHXQ2pq+M/RSsKG8UnW5wS+xJpFsEIwJNZvQ8+mAt+wnIlWrmgOoUCmhtbFiv8XJ1YtA5E5Ki6XpLJLCmEycrvi65dV21gUfpwTbKEnQ6rUw3eufRKdOGHQ1S8aqE62vmWHnHfN7qsckzJ9S/lzpUXeab1pWTRg9OgtP4nrnKqQrj07X9XbXGyDXR2mLDPUYwxycpCWPkNyz/Hp3WqWAlD11W3FYm58r7+z7avorkzJ9Pgu26hm7opHwA6Lc3UfsbfMAtX+vLMHKR9WfSYt0ya/TvcN3k17T+afFmSlCH/9g1TMyp/emAfXi4kLl3mzHj891G5+N+ST0omrQP1nHXuYhitvum+RLfVkp47z5Jf0YXrqlkomfVniVtPfqSPqw3tVBhLlprLpFnupL2NVrdS55xIFk1R3/FkKa9gKh3wVp6piSuXb78PLDWxNFfKJMqHak/0JCm6jmSyHzRcpFZ+dP7kLtX3o9S5ZO2qpM3huAwkH3fJG/bVVaei1xGOLVwG/tZuIxLHHWw3wsPbOeHPrjKanfZY5y1sfCIGjSsG6S3pwiqsbTPHHq68SJ7tuh+1f5KyGt7PSAqucqFXn7vaWHkmbSvLFDb+FTkkrKTquoZxSBQ/x8OsuTzpHzJdsRNRRTl9s389vTzzWRo16BbqcktXb+sT50f6AonP3966GYWkkvZjGGOIyNySxP48eGLOjl5tPzIu2hd+3EL3/N96W0uiLU3qfT0przXGmFdnRzTG/I0W/FkZrtIyxkROj8g0NqVnjNEOmatujCEyt7Wl4sCXOy1ZGeNffWSXqp/pxx9/zODfz3YCzs/SeJqNkxkweiejOtc/PSV+RJRfgJ2e7xftI8CMO3ivGkGz4+IwiWQMyudqSN0dvzK+9CW1n5e3A/0+dLWGKSt3Fv5fLs1v1T3LVZuMMVH0IiyDA0A7f26eXp6bDKVFxUHdq3IgvmXU+1EnF3bq+nNQDtlrzE52n5j5LC1dz/vcN9OEfk18hjeOI5n+pdwNm6/8dphlWe71hDwoi5bTdXecVgxs7FyhYk9MXG/LKglzZZcrnOsZl197om2Hy2T55bhV2RAHn4pVlDIpg37X4O582Tq6m/0vte1GhWNn0czlyvfQ+hl3BIwGiQZ++V0mxHx2uMqt8pcifCrLy+jdpU/S7Z4j8wL687Om3wQJpa9ShsIHyYpFJo0xqXDRkpp3Sia7jLgYplLfpH0Jm7DY6Qm7dOufXZ9qQzvlYika4Prpnxwkblv8dUtPoqNyTiSLyGReue2Rbceso36NpV6rVQBcV2U1rL/ch+ej6jpyT9RZ3tTKj5lDdZ/K+1HrnNSBZH2shAvToT1GCkoffRzE79r8+Vm4DPyt0qVs45TPrnbaXb7Cy0IwL+E6rmp7bK+i8qepZKstxpgo/ZOU1cT54ly6ykVqdSXR+FfkcJUDP+NwnXL8YcYejoPLZTJjDG+l9vy0tbyWeo+YQtNfUr6BSpaOwsoYUxGJJto6nH81gm9lzPbFcSOCOcF2r3IIj4dXwjz0e2VQ4YnyO7GTb+xtMVom8+77+JYmNlD8rsd6OpRw/7j2XcLhbeONyeSmOZ97CSVaAWKGr+rKGHPrUmJDAZG5LSrZqqGwlTGppFceomMGI0Yz5ph8ZYzWfzKfMWZZMjXN97xtqnXMYTOn+8Tb0Zzx1gWfMf6BoZCxDSdqIGYuX5aQ0a92nOrNeAMfX8qvY+Qli375XJ2Nu+MXR6680kmdTpPccS+nzFsuXCdHaKnIc7CabJuSPw63jBxnagMlm2F0vfBS5Wg+KdyyqqXO7mXNJhuixDLxL6/BX9L8MahPfjlk+XBwj7vaFmUPYJPpX5Zihw/KTJn8spjfhN3zoMNVX1z6Dsahtgsk9+9jv6mMQHryb3+vPvM2gaqUX/8v4RK3MnRqZ8WJ9S9vqWs4V677bn8+wW1u7glBrC5XwfcO/wpeOn+g54A3zJDN8svy77Bl8dK2aR8crvZLkZCwyQa6qXDxs5ZPirltHLEZplrfwid37jxnqv7Z9amm2ymmbLMU8nwNM8ZEq1vhkxXRVzK9mrK471X95XaRdWr6veK+kT+fPDiHrmli+7QKr8tV11E4y9TKTzCnqbwftc5F7WOT1RW7LwtK76pT0flzfDLpNbd7SjpqFZR5IqWK29WvuOMJl0XSMK+J6guHi9oei061EclMRe6jbVMy40hFX4nyYtd9b6wZoX+Kli/On6tcEMn7UcY6iWSScpGsj2JJwjhE2aakxxKiM/9Vypztv7J8J7Yp+UiZhgR71YMZcOsT+gSbP47f4zmMrfz5a1pgOHA1J9CpGmM4rd3T1NHD//PqudS/t1r9ccdS4ygSUyDr/vxh7eiWJ+jNb3uNNn9+Mn4a0oWzZbR37XKaul45t/3b+jlxvy3/ecNy2hk77/fMobdp4JXKKPTP/zGLXo0ddZptY0zlz6X0eMwRMDvlnfD2MSr3nPISsezvLp5HCz9QmTaNEf6wP1NZyRqaFcujxzRm1GImbUbv8pwO8/NU0rvwYzHd0yDG5N8n0yNrjnhcK77fQ6Njzo6jGWO0IYmPl95m2VDcZcZStPfxLG2bMDVuBGQGI5bsp2/OxoDRz3Ti0730wsh1PifBpgEqV09T8hs7hI1q1M1BATu/5Um03QDKG8mvwTj5HZnQ2KctiPNCv3yuzia842eZ2Qq/ObbfPZHjXpGfOxx2XuxyYCZhEu1pFgeo/hOmwmW0B6qcRiqdf1S9CE/bsZzkSV/dAy85bjloDNFvyh0PXl1l5cKpbZ5vjqoYY8Kc+om+zLIqciTWv9rK5Jrwy/v6Gq4/HcZ/l85pShzT6Q+meacDXN5nXuQjj/kXzKcvTn6aUlXLb16rCbTLOt5W+JunT0Utk+G/uCqjkr1CrbLiEM3t0SRgzFN1yNwWqHTxy/453ukPtoNEv6Z4yXPsz/hC9sdrQ4rxZfy2nLaMc52exgHYaWIn69QmV/ulIotmjEmNS1xM340qy8km7anWNxkgB5eXqzyby/6VOJmpf3b7WdPtFOctbCLC39kTMqkDUeuWMqQWWCcbqR8ImublB1bFhdUNX5GwPnD7ffl9i2nO0EZkrs7juJo3nUrzFnbzGWnU6+FtZDo6CmeZSvmxMuh9jPp+9DoXtY9NpX93Se6edEfnz3GyDLylY8Cir60k1KEC/tPmlAGDT3v7xnCcHtYeS5l2GW+sxLyPAR2n0R7zgQhBJ9L+VNnBv8uJOodSDnz9p0Omoq9AXoyk7bofuX8i0Umy8Xf6bS3Lz+2I3WeyQYzZcpmJaozhI8X1Vn0F4vzh8PG1OPA1xxIGvvjtzulNHdv8FKM6v01p6cLP6ceffoxP5uNUHDdRjTGn3l/mW43Ak2/++/8aqyvfp2uMMR3FcnymMcQheuDRmU/XhR4NLfLqlSv+Cb18b16HrdGnNWTbGMOZOVWy2MlYZDJXJH26YnbcmCTfy1XnMbiKhMOI0S0T6f1b4wlxOZKvjCHiU6xETttxcnRjDNP6noqeTHw0uS2POD52bQ9pAf8AACAASURBVE0LFKYaeCAD/LBfd1PpZMTIYB7hyts51ix7hgbfOi/pEbAygAhOmstp1/RO3q/Qcrw2HyM9oOOfaczYu6q8MoZxc8PfrXE3+kOnZpSKLyDVIeeTefTe5lUzraOtg8dfy9HWwRUNqQ+U/EYoKTyqszUZpqIXOU7UPC64eP1Sejx2tLVKRaXBA5p5W/dQ8apl9M7f1DcuLnyM7/Nj7qXH14qTUl4Wu5b6Xdrcfwz6qknUq90gGj/hzsBkWnLnv9rM1GoR+2j1Lt1GUqFjmxLHlUz/0vmbRyTyMZjLX3qKBj6k94zL4DLKIETywEaKTnmyTU6eqomaPWDQ3/rvvn1noufHhI+z5OW4C17nLVUs30yaPPYB6uGTkTy/Dq40/bGqT66ykKz83nzvfXRDG300uxxtb5f36GXS1rGW1BswB46k7kF8xK1tzJN2ru1987zjq1cs+yup0qgMIjwo1Md0lhCX+aeG96EFMZ/r/P7t7QbFj3vfuUMd2c4T5N3WSVtaQnXnymv8aOvAiR2qbtmGEI5J8pCsjKXCxZZVfVbMbRmCk4jU6psM4v/01BqvjL64Nu4wi3hyz5OfCav30I4tz1NR7KtM1D9O165PNdtOVc0YE7Vu8WlR429s6h2lLkejr543mDrdNp4e62c63VfalnIVrBvu0sFPRZd2PVM/nNxI7a5zOewPr8vp6IjfteUQyaOXH3nDf436fip1ztWu2n1sKuMuv8TyydWOpMafZWCu/e+9gmTcJe0et5fDVuu5CqfKPy7wJP2q2FHtXhvXqzWNGTvaoZ/wMYTkwLzaOs50e8z5WjDmXt/R1osHXhJytHUw76noy86LmU/bGCMG+2T9E8fh6mfsfHG49NtaNj4ymwLqN1Ft/1H9WTu6b/Jk72CDZH0Uy5Go3XG1z3K0dfIfC9UWdC6LXQoXx7Ygr6dpd7ajB4c9GOgLgrpz1R1TS5m9T+oz5p1Zz9GYmSto6owofy/RmJX6aONkokY1xnA8x3csozuvU8aX/6fls/TQC6X09x2Z2aak5NTHLfOEvdmg4vhKjmT5kO8rz39HxStepUH9nqEGsdOJvLiun069hr5Gf/2qXIJyEaQj76ynYfdOo+Yxo9JvWk6mXkPX0eavfjLCEVWHMYYTrPhuL814cCa1baGNXC3/i1nvom/0YTOebN8f2ErjDNn/rfFk6nj7Alr6kd+Zoak30xiTWnrManlc/5xWj8ffpoMH36KuseOibeOHD2Dsg7kdTY7qlnCpGWPUWycObacXRr1I17XWvFi2P3SbS48v2W+Un89pahe12qoq5UpkzOZVGsRMGGNYzgunD9KqSYPp+jbKQs7OLrvfNZIWbT1K/hLiypVqBE1DgoSqrDhO22breNvcNoHWfvGLY4WIqyENH4SII9eGTYKTYkk77Hp0+wIafFeXmFOwArq6+xCavvErXz7PHd5G0wfdQle0VEcVX9y+L42cX0zHztmxhsvoGqgGOxCJz80wFb2cPLiOnjBkvrzz3TRy/n4yFzycL9tEj/Zs7XVsl7T3r4ZgLoW9lCNVngRd3qkHPTB5NX0UPzlKyVpxfBfNGd47xuZKuqlwCm2M6TRscC25VNcgM45z+qCbYjq5kvqMeJU+Ov2td7S2q1xF0X/Fsd2GnPmej5I/FU6hNfvMDAVl8cvq+qQms7YR0KVv19vyjHX7+oyHqXenNp4+mDkPlK7q1oOGvujXG69I4V8vv5OXk1xTLr+rj9GJD5ZQYaxssD+XByYXBY6Y5GSjlclwrsE2YSS9tu+M98ulq/x8WfQEdW/N7VIBdRq3PV6e+Re9D9dNogEdhR+z4zKv62ll+QGaP/yueLvG+eo/bnmgTIfhvHCujDbNHhx3Js3tYp8Ri2jHEbtVdLVfKlZpq5MNdFPlEpRZMU9ujCFKrb6VU+ncgfH6PmCJ/sX9wrmD9NxfrvEmc3lt+9KqL7RU6da/sPpUk+1UahOyWB1IoW7Zeuk7bg0dPve91w7aemXSYXVDa8F/J6tVg22qctzrqn+JDNbp6CgRS5Y6Wvnx58/8FOX9VOtcsj421f7dlFfdu9qR8LbUxV9kOHChjDZO+kus3hZQuz4j6ZUSs++T1Mvp4KonqbvnTyufLmk/iOaXnAhdBZZoDCExytXWcdrtcWyc2rldK6/P5Pb8zhGL6KMfJUXe+nScSpY+afSraozi7/dVeGEVxcePnRedomtVnNqClax/kjikT02Ur/TbWsXmnXnD47pmH33TNnxN5469Rn0bRVsZwzInaneOfbCEHrtTxtf5xGlMXb2PYhtKJMsh12BZnLH1mFcWbcN8UHeuuhOSTAYeJzXGZCCNnInik0XT4ysnhm/4IWfkhqDRCRycr3TMW5U26h/oo0dQhZA/vbMg7hB65l570F2FCPFKFgiopchhxxhmIUFEWasI1Kz+2YfApddPpQPV0DyoJfKtAtsXMqOO8IF+ZuJHLCBQXwmgbtVXzddkvoOT1JqUBmmDQN0kAGNMXK96Zcxv8l6h3eYilngY3OQ6gcqf98d9zdw4vjTu1yd7+TpIT3dQq2LajN5TDellLyd1OWa1PzWa4966zKG+5q2m9V9ZUeb9Wp1sD3T6+lFb/a40juNMP04zBkwYTRq4B4HMEUDdyhxLxBSVAIwxUUkhHAhUnQCMMR678/TJUu0H5fZF0Rz3Vh073qxJAuJwmZ3vztybZKN/moLunjXFW23FjppLA1tS0owcr2eMAG/bYM/sURz3ZixRRFRrCNQG/Xt+CVp0o1mlv2aNC/spuL7lIHo75tsn8wlhwph5pogRBJgA6hbKQfUTgDGm+pkjxfpHoJ4bY0pp1H/T/j7Yp0mLv7xNZfWvHCDHIFDvCJw/tomWvL6HXp99B12a15GeLcneJLjewc2BDEP/2VASJozZoIo4QQDGGJSBmiAAY0xNUEea9Y0AjDExYww7zy2cWUrH5YTi+lYSkF8QqGcE5EhWdhT5zEb/iQD1DEW9zC70nw21wxiTDaqIEwRgjEEZqAkCMMbUBHWkWd8I1HNjTH1TN/ILAiAAAiAAAiAAAiAAAiAAAiAAAiBQ0wRgjKlpDSB9EAABEAABEAABEAABEAABEAABEACBekUAxph6pW5kFgRAAARAAARAAARAAARAAARAAARAoKYJwBhT0xpA+iAAAiAAAiAAAiAAAiAAAiAAAiAAAvWKAIwx9UrdyCwIgAAIgAAIgAAIgAAIgAAIgAAIgEBNE4AxpqY1gPRBAARAAARAAARAAARAAARAAARAAATqFQEYY+qVupFZEAABEAABEAABEAABEAABEAABEACBmiYAY0xNawDpgwAIgAAIgAAIgAAIgAAIgAAIgAAI1CsCMMbUK3UjsyAAAiAAAiAAAiAAAiAAAiAAAiAAAjVNAMaYmtYA0gcBEAABEAABEAABEAABEAABEAABEKhXBGCMqWF1VxzfRdP/cg01zcunKwYV0ckalgfJV4XAcVrUvzFdO2V/VV7GO3WIQPl7E6hhk/tpw990plzP9LdVvzu6aw7dfk0rapCXT8PW5UrLUUqjGzRHXYmpfefE31LjplPpYNWLQYQ3FfNha3KljETIki9IdssU+mgf7Ax8iF4eKysO0KwuLaj9gxgbZQB8tUVRPe1aNrITvWxmI/XaEOf5Y69R30b5VHf7i+SUS+d2o4vbDqW3jXFc8reSh8hWvMlTTiVEavOZipObaOgVrajvnP30SyrJZCBsXeofYIzJQIFIFkVY48YFacqNTal557G0bOseWvvGHhhjksGM+L0w54mq/Rc2+TlXtpsWjHmAOrdTE1z1XgFd3X0MvXMiUcKpNV6JYsJ3uU3AZXhxPUs3l78cfI6ua5xP3R99lbbtWE8bdiYsoOkml8H3sztxzqCg1RJV9Uxa6voEI3tlqqp9dMUPB+n1GQ9T705tfP3P5Z160JJ9umix/rmfuTLhDzHu/KXzrpagJu6il8fK8lKaCmNMTSgprTSrp11LS8SQl6OXzZAIcv6xjJ3rrzGmnHbNyoYxJlvxZrrIpTafOX9sLd3duoaMMXWof4AxJtPl2BFfWOP2ywfTqGleAc0udbxUzx+dP7yJHr9/RJUt08K818Qi2rmjxPr7is4YfCsrTtOuObd5q5Mubt+XHprwLC1dv4f++vpCmjZzMg3uPTKJHKk1XkbSuK1jBFyGF9ezdLO9c3pTyiuYSgcupBtTdb/vnli6pSijtaMfoNEb6uqKDqJMTlrC28y6PsFIpUy5S1rY06r00V+ue8wzlDZu240Kx86iBa8XU/H6pTRt5rM0atBNtMDo78Wg0iCvgEZvOhsihjt/6bwbklA1PU6/PIaX9Uxn4RTtXjCc+r+IVa+pkM1ku5ZKuumHTb9spi9DzcYgY+coxpjqq4fZYIK67aZaG+czdX8sCGOMuzRm9GlY43b8zWGBLQ0ZTTiHI0t3AhvGPIiknHZO7EQN8q6k4cs/ozMVwRDJn9TGxiu51AiReQKucut6ll7Kp+iNIQ3psoFrcnAlnXti6eZR9wfGmZy0hJezus4xlTLlLmlhT1Ptow+tHOD9wNJ74nY6GaEvYf03ajKUHhx2KeW1mkC7/+GSxJ2/dN51pVJ9z9Ivj+FlPdO5QN9eFaKZbNeqkn7V30m/bFY97drxZvSxM1H11cNssEHddlOtjVzqfr2EMcZdGjP6NKxxO7JyAIwxIaTTbeTDmNvJnX5vAl2VV0DDVh+zv0rhc21svFIQH0EzRsBVbl3P0ktQlTcYY9KjWBvezuSkJbyc1fWBjMpfNnx2pdJHS5/Tc0r0vfOi/33fraN+lzana5/Y7th3785fOu/WbNlPvzyGl/VM5wx9e1WIStnMri+sqkiW7J30y2ayFGr799KORVkZU331MBvUULfdVGsjl7pfL5MYY7RSLpw+SEvG9KYrWrIPjiupS+Fi+tjc6xHT6oVzh2jVpMF0fZvm3l7oyzsPoWkbvvYNMKSyu7bn8ODH79NDy3D2s5X0aM/WXrzmuxXHdtOc4XfF0+TlwXeOWETvBdwoaIXyO9MH3USX5uVTo5bXUt9xRfSd9UsWO+4z4+UtLI9vSH3SLvmVxk0+275M5HtXBTEbvaO7FlBhr/bethrO6wOTi+jwOf9bwvHjc4c8vXE+zcFqFD0RldMn6ybRPV1VWkrv8wJ6P/vZOnoixpLD3FQ4hTZ+4Xfl5JN/+/M0oKPaS89MJ/mYKh3ZbFKdeArjREyJTtGKwkbUoter9E1a2z10GTW1UFlxnN6ZNzzuN0CVszVxXZ0//Ap1bZxPPeZ+Zr4Wuy+nLeOaU/Mb5tEXhmym7jm+Po5ynkj3Lpn6jCii7xwS2I+Obl9Ag+/q4tUZXlbfrs94WmvpOVHaHF+0cmenrD7zAM9dDnS91m8mK7uud9TbZlnV8RFFyb/rXf+zMprbo4mn10Nm5LH7U8XjqGleR1r4seNLImK+dt2wHQafPMj18ZZYW51PF7fr6WwjUuOpeUVpO1l6JYdqY7ld6DPiVfro9K5IDnxZtmT5jNLus2+dqxrn05TiX31ApX2w6975stfo1kb+8Knoff3RE7Rt9kCPvVlWuf80+8U2t42k1/adoa0Tf2f1d0Sp9zvJ2sxEutPtkQkonXrK8WS2T9CSpVOmJBa7DeSy2bn/SHqlRA8YpHzYZTBRf/L+rA4JVrdI6v6rOWlVq2o60rMl/rJKpPRn9t8cSzrv+qXQn+y2g8dv8w0uHFLas7CyzmH8dSafOJ4FpTJgTKU82n1rsrKu8hKln+SQvEX5Q98Yh/u1kbTpiLut5fIgY89U2s9kzKRMdo85ZOdx0cj5ewOrq1JvGxQPaX/EHx6PG4fOsePXrCOP91No15Qk7v8TlxeibMkflMYom974X895XONafj+q7oJpqTLmn+9IKK0LecJX1a7qvt1fr1TIVNpu5i5zCR5PDpq8nY58szKCA99o9dBuT8LGImYe7fso/bx6J7ruXOMos27LOFYbE7U+PIfusflOXls9fzGfM8vCQP0K6pvbBbuP0Z8L6OnNeutqKnq1GfJnKafaj1mw31Pv6bz601Rto9lP2tzNdCW9ZG0av2PXbzW3UfOSxGNBLSvHo8bPBTR1p92HElWW76KRlzSnW57X862oMkapd2beq3IfyRjT9tEpNLZrDxq7vNjzvbF56ShvTzRPYs1J3IVzpTTGc0g7hBZu2OOFfX32Hd7krZcx4ZSBjnRqpuBhleDyB0fSyAdepc+lP4+9dPq96dSpRT617D4ynubmVZPottbNqXGr+2n9UTN2VVnvnjiZbr/mbnpRZJzRyzNsXPf03rjRiD1E33dpc7qq/zza4PkceZeWTvoLdZ2V+t5hya8M5CrLy+j9HSW0avzN1LBJT5oWk2P/Ub8Bw5RcOvP5rz9DXbrpvK6eN9jTRdv71viMScyRlz8PeeRBWvmpH1pUPb0/pyM1atUzrvfidQup8NYhvpNieGUJOxJl45zitJ6m3XEFNWjSjV7+VOdAyT+Axj9zL3WIM11PE25rQTyx15XnFH22o4TeWVDoY7P7w6Nx3ehYw+9s5q6QleVbaUSD5nTnkq9dX6fwzN8gyIvciOS1vZumrvbXG+2sURmD2OBiT8wvnNpI9zZsTve8qo1/sgS+38TVtG1HCe3YspSGdW1JjVs9Qu/+KKmqBt+te97ecrEnk5R9rit3tJud9DQX1WlcSQMmG2l3bObVMdPjfCbKnc6J/y6VwW/ysqs7bn8qerJhn4jEk7Zk+Zd6ar9rGkz+vnYQNcjr6KsfSga1/chuV035zpV9QDt3rKexNzelS3pMjdW5D+lYuQp1aPX9Xnt7Vf8ptGqLaoNXzxvutZH5nafSx8Y2iFR4yoQwStvJkki7oOXg9vNOuqxTV6+9sCeWZh75/ofPdtOOHQuof6N80n6fdD6jtvueA9b2zegG66Qz3n7Cg55Le75K3xiJ8/NGTSdQSawpjlrupX17cNhdNHmr38eNtLe+tsDro7rSHzo18xljqtbvJGszE/d79moMkbd558T9uIHNdyu6z1yfoKKXeKtapjgWztv4Li29fm3k/De9McqOLato3J1XeP2QrJBMvY8+RHO7N6FrnCtbfHh8H7gOymSssqLMO5Wv2fVTqdSop1L37DqTzrs+IWIfVJ9ZQD0e0n251z836UYv7tOD20RlnX/AUdt+zXhKiNugSXHfT6mUR7tvTVbWiaL2k8x78cBLvB8XpV3fuUON8xbuIzLb2tYPLo77nfv6BwUslfYzETORo1Grvr6xAo9rrxm+Je7frmptA8uqGJpj5NdjY95bZ5mruFS4VMf7Udo1V3lTz6KUl+zI75ZJlc3BL6/25jzSRvDYd0BsvGPOKaLqzp1WcHKuw9nlnkg57S+gW0cv98Z/PA6YM7w3jVit+5tU2m6pJ2Z9nzP0T14fzT9gyHxFy2TeRaiHKYxFzJjN+6j9vHonuu6S1e2weSjXjXE9+8fmjrG5Tl5HmrH1XRp7Y9f4XEnqlznvZRnteC/8cCjerohvy+1FM7wfac0Vlqno1eQn91H7PRVelb12E1fT4oHXGGPeVTSuVwtvbjerVPcH0j+Z5SWVesE/gPGqULMd4T75yXvnevOSxGNBfz2R8Z6rHz61bRw1bNKXXj+ichlVxij1Tjinc41kjOGJtR8+0YGXb7UmFNyoXkfBgQTRoeX3UKMmj1BxzCYgE+VUjDE8udxsTDg50+xpf0yHZmQbIvg7KbythxTFOzMpNEEjTTkVjW7uk7FsNW8hGmAZc4jIWj0TBb7k1yys/B5XTHOSliguNSnI91YG2Ct4uJDx0dimA0COmycbj7ypLasq/qh6KqWnL25OHSbt9YvF+Y8xEP7dJmkjFgfmQs5HPbc1BhIiv62rC2e3etZKMyzHoQYv/iOC/YIk/iTMtZVZn6okepAw9q/miWN2fetvECTEnjVL46tg5NnH87v6ylXYSgiesJtlXmQd+po2znCcF87t8uqA+Qt/mO4rjq/1fvEoXOmPQ/QpMrquv3ywjlZZq2B+/Ww+dWycT2Z8YWmrQXq09sGVPj+LPvhNXnalLZCyYKbpKntR8+96137mstBz+hUn13rGh2CdNaXje1XezJUX/FTKiNmJy5vS4Zm/CkTnybGogU6UtlPaBbuucyxla4d5bZU9sRQ5/VeVpq2jRPG72v2dE5tZK5GU0WvAsBF0dZ7ZxnA/8Htfu5WK3rmtMfmqvKj2NsiNV8Cs9Qz+Mhn3+KTR79jlTLOMrrt066noJtN9gsSbXpkK14UYEcw2l/lF76MV41QN+6ZBhdPjesrHyvonySpuu86k864uG/ru/LFNtLxYT+z4G+6fhzT0jwO4nLnLOhEbM/lQAjFq6djNu1TKo7tvDSvr0gZG6SfZYO8a25qSSltrs+cwqbSfiZhJGTMn+Rz/qV0T6GrDaF/1MelxKlpWbK2yKaeiEQ08Q+AH8ZW3irWLSdh4P2q75meqP0UrL9mQX8vgv1Nlk8fltj5krNruMW0gi6o7fxr6E79vtv/6m2C5Z6f9HFbrKxY6PieJOrZPPFZ4f1ZHr37b/a6WTd8lq4dRxyI6Rn2XqM139fMyRkmkO/88I8hYUg/qRYXlyfyqrySUnoPyD8r+Ns/9Q2swXh2XulNzUf8PZ9H1ascmcfLc3FVX3f1erB3IC67SrKw45K3svvi/Fhs/Yqk6Y5aXqPVCTiv059eVi2AaKlRQh+/P6eCby6twQT+LUWVMXu9c8qb+LJIxpuDONb4VMJyMLP+eVaISTbTKQJZ+i/FFOkz5bIodLKwKtksGNkLwL8yJlvRzxdwcX32sFBowMPD0xnOmq40vstzJ7tRNWaPeS37NwsrvSmEwf0UPi1M6c7fh4ABNad/MZzhRcev8SLzR9aS2U3Aled+/sEaiImVp7OlrnOTLQ8v7+ToZkV/Ki4TjrULsjNTWb1gjr99LfCfM9a/q+kQlWYEkYVzlMHHs9rfBBsEOIZ+Fg6RZWVFKo62lczIANFdqHXi5q+8Xe4mPr1ue/p1v+0647tUyPdeExowv+r2qT+ZANTzt8FVIdvsQln70wW/ysisdt10nOe3oZS+Yf9e7rmdiIDC3oDE7duJZGr5ALoZGlTfbGOOVEYfRWnhymk0K9Cqo6Dw5huhtZ/lOnqy52+XKimjblJTMKk1bR6m2+6ot1+2U1wY27Ekrv/jQq3tixJa6mNwY5tY7T1Dt9k3yGzTSqBxy3TUH4+n0O65yZnJ09XuqDdcGqej9g4rZ/j9bfUImypTkLUwX0h8MW6cNEqo903zs/OrP7rKqv3ff2QYVDsU/XvGEWK9GCZY3DpfOu25pXE+DbQ2XM1dZl37L/wOYK06VnyjlUeI0+xiOMaysR+0npa6HlQUtdXjfnkr7Gc4sfEWVtB3S/qXTNuj86Ltg2VZ5tcdi/EZgvB9rx8P42e2aTtW8U+klLy/mO/o+Hfl1LPadKpuuX9Y5JE/0tEEkuu7sVOQz58Fs/+W5q9x/saSn1y48W2L/wKrekvbNZRC2x1g8PrcNz5K2hJVyJ89d14T1MIWxiCvuVPt5GaNE0x2nGF63g3oJqxvqBxxzNa3kRTHWixD4eTBeCa2uvFqpWcDgk97YWcpFWF0N9nsqr/aqYZHUnisLd11eotcLLj+JtuVLmsE05JugDsX9gzmOC/7QGV3GZPVOJEn3GskYY3eEnGhcgWvUwEU+cycd9ifKkrAyITUzESysCrar4+awrkog8akOsIDm7pMn4QMm6SxFJl7dsfaxm71fcS9pP4imrt4X3wogsUW9Sn4l//Iey5/KyhjnSh0vMsXInJwJR9uKLrKE6Yifi5xn9s/3tnspfw+LaPtXfqsMp5EoHjNvYY02i+8aVCYKL/wSXSWfkhdX2NCVIq7ACZ8FGwQveEU5fbN/Pb3sHWl6C3W5pWvM34red87hPF8DxjHFqjHxH3nOjBKxNjv0MN1zWl8WPeZtWeE9mfdNXk1imEqYvdiX58oO0pplM2ny2Aeoyy094j6azPYhLG3RR6I8JNIVi5DK4DdZ2Q1v3MMH+lHy7yq3rme/7J/jOY6W9oZIGZDs7TRuvQTru/AJ60D5e9aNaZxOhWcyXqxXyQunE94uuyeW7ny62+vE8Sv98S9V0u7LYETKFw/yFCc1kJLBG084/CtllFTR9R40fku5dxvRg21fOv2Oq5ypHCiO5go24c3vmLoTeataT1k3id6tap+QWOfRypTkLUwXUsb/aGxF5nRNmYVb8BqyGi8Y0PfE1ffFf33sLP7C3PlL512fEMYHXjZfvGohTZnwMPW5pQeJjxFzbKHKWbCsCz/XZNBIIm7YjVIewyZMYWWdmSQqf9JPJi8LInFI355if5SMWSKZpX9Np21g3zifbV9Fc2dOpsF33UI3dVN+AP1lOzyvwkvaUPkcVpdcZVOI6qsq18nLi/Ltk0n5tQz2XXhbySH97YEKG0V3dirymeOTMinP1DWoiwvnDtJsdgGQl0/sc2zR1q98p3+KThLJI/pj/YSNFSQeCeuXy/8pUT0Mi59jEI76h3J/vBImfBwR7Oel/XG1KxJf1PIe1EtQHyJxWFmXPJo/tgfjlVjUqsh+LewVNnquHUWvOjZ9J/oMq6vCTfd7Kq+uOTfHyjpnWWS8J+/r8hK9XjCPRDrWuVBx6jTkG5de1DPTyMvp+H/ojC5jsnonkqR7zbgxZth85R9D9r+ZV5n4SeHQytTZCBZWF2wVPpkiVaHRg/JgodHpBguY+u5c2W5aMOZezyEj+0950bdXTr+f6E7yaxcklt/fOITHEtboqTcUI3MJXpCjChmXJYKe+A3l4G4GFcYcJ7d/UDs69vg3GUqLivWqE1PfO3doHw+J5Hc1ZonCh1PS38TzGTMW6m/MO7WiyKy05rfR74NlNL5Hs+W11HvEFJr+kvK1UrJ0lNWQyQppTQAAIABJREFUEYnxRfzm8K97tuNeZpTfZULMR4iL91fx7Xhhupf8sD+Ed5c+Sbd7zgIL6M/PmvvGJZR5Ladd07t7y8/ZueHEmYs8fyS73l/iLWGXwSK/EZZ2XB8Ry52ZutwzA3NSIM/D6nWishv2DscZLHvR8x981xUfp6KML7L66ddDr1DHxu7VJDqfcqfKm82C+aQyAEqNZ1hnGOycpQzYhmAlvYrHLDOSq+DVnabX7hh+Xez3WAemMUZW30n7yCuEZFsf/8qTFzOE8i9Zfn7p6Z3lknJvr5gRmVkHrsF4VfodV9lT6bg58neKlR5YibxR+nHJg3n1dJOFPiETZUryFn1QqicN5oDazK++Vys87XZbf+++C9M/twfs3F35HHDXmXTedUkj/qbYKegTM5+lpevZ59RmmtCvia/dTVbOwiZDOs3o5bEqxpgo/aSUhbB6qWUN9u3yXSrtZzJmf3qqKOA7QsZSJV/4fwRLtW04X7aO7mYfim27UeHYWTRzufKVtH7GHdb4MzyvwkvGsPI5jF9Y2RR26qrKQbLykg35/XKYn8LLJodS7ZusdlBhU9GdmZLE52r/w8o9v3Ny/zp6Zngf74e9vLZD6e2YX0zRSZS2m/XjWgHF8cfjSTh2VjkJK9ccv78vVeHlf+bIc59sGGOkjEpacvXrjp+Gl3fpb1wOfCU+uYaVdcmj2XcE41WxyHYd7U9SYjf0UcWxs+gzer8XzoWlUmMG0+ehXWei1wvh4R4ragbh43W3rH43D2qs7V8ZFF1GkSKs3sn36V4zZowRh6NRrNxSOMzlwJIRHij7Gyc3bA4fZRmb6asmXKFSwPSgVOSRK3t7fq5/XnzgLs+jXOP5tRo3V2UNi09VAP9qCQkrv/zKBIOfSyHXjYkKnYqeJH65frvpCe9kEmns1HI1vfxfwrmuYY02h3U1ZonCu+K3n4Uxt8PJEjTbJ5IdLvHnYBkV3dr7jtVye7ucqf2lPDEvr1AGItNxL6ft7YNMMAE15QvTvRmG79lYUTp/oDdxdRlGJbywtLfsyTJqc2IdlnY65U7k4HJibrOR5yKflEt5bl7tsittgf41QIcW3UknKvFHyb+r3LqecWrcYYi1nldHJXLcq6XjO1XebGNMlG1KprPo1HjaHa6WiPNn/lKSqF2QtsosMzom+86dZurtvtqGyr/A7PrHBzT6khvjzpNVueTPZ7ztkmb/la7eOTeJy71amePv7/wMUul3wsqZlHVX/bB1l1hev2yuT4l0b4cPlzfYJySKN2qZknD+QZmWSvQt29b4G7st0KGDd7KNxO87IBjOfOLq++R79mmifBTsdp5Als67koZcZduO7euHjcaL+uZFNMaovkuMnhJ38Oqu1xzOLo/S1tntRVjZidpPSjk3x0xBOflJsG+XcKm0n2HyEilmsjpP4o5yjdo28Jja7cuxX5WNMcLPbC+1zMnbNRU2WnnJhvxaVvtOlU33ClWVL92HVl13kqq0L7ZRQuqjXe7lPb6yj6dHOjSL183EOjHfTDyeVD8M6RXy/jf9n8LKdapjEX+s6lPq/XwquuM0wut2cBwbHjasHRbdyjiSUwzGy0/ZJ0wnZx3lb1PRK4e3/6Xe77nHlxKv0q0YJPmp3Z5Hrxfcr7sPs5DU5GqnIc/depE885iHy3OnPO24V70ZXUZJSa52vZPn6V4zZoyRY4Jdjb4tpIAKnOIQc+bqH5y6YXOc4gjT5QNDHDyZ3uiDhUZLFhgExJ1i6TCuPYD62/A7GeTZg2FXZQ2LReRjZmcs2TznatbpRe5Kz7GriX8UPdmOXWXyLQMY2YcXHMAFcxHWaHNIV2Om8muuagrGmehJGHP7HXYSNv7GpsQnGSzc5/8Fyg4b/jlYRt1On7gzV0e+28YPz5LbdAJtfXciNXPstfW2tTTOJ9sg4JIpVPdcbqyyI/uDzQmIHecvH0zztuvZv4JxZ8mOo80BQ2jaqZQ7W4DYZ+4EbAdq/JVyLmgNHqx82mWXSO0ZtY81ly0C5oq1VPLvKueuZyy31J9ntr7r+S4x97iGIIg9dneWslc2kdM807t/SjwDHa6WUNVVbWCUuudqFz6ez47f/WVGx2TfqQ7YNpil3u7Lr0sFNP2lF6nD9bL9g9NTLO99+WUa0UAbafibdPWucqPid7W37ACbVz/4+jur3HIcUfud8DYzbCDjmvym0D+oDPr+lzLt0r0vYGzibdYz83u7T8hMmSqnLeNcpyxyympA7DqZLkxGU151f5xW8Ok8TbrRkxssJ+nBwN4TO59mMPm1tOCeKTSuXxNfO8vh0nnXTIfvw7bsygod0/Ab1p5xPDIWSfzjRirlMdi3cjphZT16P6n6YrdTS5OOSv+KQUWkPQmp71NpPxMxY0M8lzH7hxtTCu++Sm0Dl8nGgVUQrn5O2kKzPxcZpP7pMWyK7ZpEZF2Tl5dsyW8JEv+oyib/SLLLGg5KXTD70Mi6i8fvv1EGhwKyVy24xlb22I1jYt882jgUve3m8shjN3s8yT/QyRhV69ovs/kprB6mOhYx45T71Pv51HQn5d1Vt4PjWHc7xLKGtcMch913BOMVR93BQ3KEQ0pzNv2ScZdqv6fyymPtZV8Y0cQcuvPx0Mnm1VHrhTjFds3h/Skr3dpjQdFhsM1SeeZ+a/3z18YNlmacUWVMXu/MWKt+n0FjTGzPm3VEFR8VuPylp2jgQ2Znxsu/O3m/yMsxberouD/TmLF3+QenCayXnG057tI8tk+Otg56aI4+COBKc+19+njY4nUveP5TtAFJ5cFbJvi3xAoIdmQqvKuyhsWkOvOedPe9XXzHbc8fpfza2BMwV6WXuHkCbh8lFtRTKY25oi/J0X78PadlO5dSx+Plkz5ulI9cXkXPj7mXHl+rhy+JBiOuxkyYtb1vnneM34plf/UGQ8qvQ/LVOPJ+lA6l4vg2GtulpTdJ5L24z8xXW4r++vpCmjrzabqn20gyj28WjvoabKjVr6TWkd93tqMHhz3oW0UgcaiOpxX9sdONJFtX5Dt1VZMF3n6hjyIsoeL1S+mp4X1oQakOHaZ7ZnJ7O/Z/JFsJ1dF8PPDY7TtKVcfFd9Ip2kfdXv/QCO/0H7MhDEub44lW7vxpm5/OH1sbL7fqaO53acn4XnTduKe97VJa19HKLp9OwQMSOb7eO+K2V2saM3a0rxNNJf+ucu56pvKlOoxLO3WldpEc9woNVd7MCZJ846qPcrS13eFF58mxR287eWKr2nd/+edjM3tNnhzY2iayB68qnzxhmrd1DxWvWkbvxNra1Np9jlnFxYYg+1dPnlQ1ue5GatdqKh2InyySWrkP1zHR6Q+mecd5m/WHddKl+1R6amQjX3/H9SdxvxOkJE+kzbPbzNR0l349dZXB9PuEzJQp+ZGGtxxL3+bVez7a2nFqJOvDHlALb9f1wrlD9FLh5V4bz77mnpi53Ntayu30NM9fRxdfW+3q+8x4pey4DJjpvGumoe7VUm77eOUu3UZSYeRtSuokRddx0ctmPBw42lq311oarkfmKjupt2Yfw6HDy3r0ftJVFvi4YN6Wzkdbyz9emcFlY8LqPbRjy/NUFPsulfYzUfvglqOE1ix7hgbfOs873pVlqWrb4K3+zSugfhPVuGbHlqU0rGsPenDYXVbZDo5jhIHwNnUmZTNKuybx2Ff2g5OsvGRLflsW9Vn1czffex/d0Obu2BHGJbR56SjP1549p4iqO3da6jQe9WNgz/ixyKvnDaZOt42nxywD7M6JLanPiEXxreoi04AlX8ejjz7GihmOfeViFY27sx3dN3ky3drI+nErnoL/RspFsM+RI+b9c4OwsYg/Vv0ptX4+Nd1xKmF1OziODa8bYe2wq++w45U25IrCxbHjyv0uCL7+QbGIrlfNzrxzldPwfk/ltdU999HtrXW5lDlw0IAdHBu60uNtl3abxjK6dMz95eOxo61VPpRMwbFguF7YMH91Xjf6Q6dmjlOF9YnL5ljAJWOUemeyrup9Ro0xLETFsd00Z3hvz8cKd6q8T/VPhVNozb74kUaerJUVx2nb7MFxJ6BtbptAa7/4xbGMKxy2ZPrc4W00fdAt8TQvbs9GhGI6dk5CyDVYaOQbexBw5uArNPiuLnGHq5d3vpvGL99vHA9YE8YY/vXkDJUsfYi6t1YrLHh/97QNX5N9AItd6SWfck2up+O0cdLguAM/dvj6p8J5tOOInRLR0e0LqLCXcgjHOr+8Uw96YPJq+shQeaLBSFhj9mXRE7F8FlCncds9nyicL/1LgOQmeJVOwhw8BEPpJ+JfxNQ55+Xidj29fH9s/Uqi3+Q7Vxktp4OrnqTunl+WfOKB+YytxxzLsHVMbKllY4v4jtHfqDsl4yQa0LGNN2DlsFd1uztQ1sN0X1l+gOYPvyte57hu9h+33KcnO035fPazlfRor3ae8YLLwqDJ2+kYnwTVoLnvF9uwtCWe5OVOQrqvthyFc/bSiZgcWtdRy25QR/NLTng6sidgdrph+XeVc9czyZ38kus2wEko+6rKm8sYwyGPfbCEHrvTbLuGeA7ITzp+WbXz5ebJsUZvO5W05fTJOl1WVZusdWVPruwcyufzZZvo0Zi/qkva+3+tjN7uq9jY6MJ1xl6VJieF2EYafsvmk4reJQ8qnnX0xKCbvP6E6w8Pqt87EfxVLXm/Y8YavHe1manrLno/HpRAPclOn5CZMnXhXBltmu3v21gfrr6N2zO7LQjLs/n86PYlNMoYk8hYqPtdI2nTER0yrO/TIbQRyq4z6byr49d3Fcd30fRYGVVO+1+lj05/S4v6N/b9spioPePYeGz3zrzh1LuT6qfU2GEKbf1Kxg6ptCWuvlXJ7C7r4udOtz1h/STHwlt9VhnjHO4T7xyxiD76UXNhB47P/eUar+/La9uXVhm/FtvtQ1j7mYyZyHF9GzWuY2ZcVhZtPRof21W1bQiOtUfSa/vOEBtN/WU7nHXYeOrsZ9HaNU0zeJesvGRT/qA0sbK5+hid+GBJ3Fcil4sHJhfR4cCcQpehRLoLpqOf2PWu77g1dPjc9169M+v8t+9MpHu6yji7gK7uPoTmGeVDYow6xhLuMkaVucS5Y69R34jGGE4zrB7yd6mMRUR++xq9n6+C7kLqdnAcG143wtphV9/hj/cUvTEi/MAb7jPMsUpUvdr85HP0fk/n9fzhbfRErO0zxy0Sp7q62/MobZrEc/IgtyN6Ds/z7ZHz98f9YHI491hQyypxydVbWdq+WdwVgDw3r1FkjFrvzHircp/EGFOVKPFONggk68yzkWbti1Pt2ZVtUrVPvvQkYmMMG5rM447TixFv13YCynof1XFvbc8N5AMBEAABEAABEACB6ibgNgpUtxT1Lz1wz4TOYYzJBMVqiAPGGIbMTpda+qzF1YC+WpKQrTC2495qSRyJ1BABtU0puuPeGhITyYIACIAACIAACIBArSUAo0BNqEZWzSXyO1kTcuVamjDG5IjGYIxRvgx6tfT7dcgR9SUV038UW9LgCFAHCIiz0+iOe+tAppEFEAABEAABEAABEMgoARhjMoozYmQ8d/Fvd4z4IoL5CMAY48NRez/AGFN7dVN1yUpp9QvFcedwtmf7qseLN2szgT1rXqCtnhPFlp4vhu8cvlxqs/yQDQRAAARAAARAAARqDwEYY6pLF7sXjKJlW/fE5y63ztof921VXTLUtXRgjMkRjcIYkyOKSknMUnr64ubEjrEemP8ZGrOU2OVuYD72nJ1KXnffYvo8wSlWuZtDSA4CIAACIAACIAAC1UUAxpjqIs1H0l8aO6Bn6Jy9xsE21SVB3UsHxpi6p1PkCARAAARAAARAAARAAARAAARAAARAoBYTgDGmFisHooEACIAACIAACIAACIAACIAACIAACNQ9AjDG1D2dIkcgAAIgAAIgAAIgAAIgAAIgAAIgAAK1mACMMbVYORANBEAABEAABEAABEAABEAABEAABECg7hGAMabu6RQ5AgEQAAEQAAEQAAEQAAEQAAEQAAEQqMUEYIypxcqBaCAAAiAAAiAAAiAAAiAAAiAAAiAAAnWPAIwxdU+nyBEIgAAIgAAIgAAIgAAIgAAIgAAIgEAtJgBjTC1WDkQDARAAARAAARAAARAAARAAARAAARCoewRgjKl7OkWOQAAEQAAEQAAEQAAEQAAEQAAEQAAEajEBGGNqsXIgGgiAAAiAAAiAAAiAAAiAAAiAAAiAQN0jUAuNMcdpUf/GdO2U/TlP+8jKAdS46VQ6mPM5QQZAAARAAARAAARAAARAAARAAARAAAQyRQDGmEyRdMQDY4wDCh6BAAiAAAiAAAiAAAiAAAiAAAiAQD0nAGNMFgsAjDFZhIuoQQAEQAAEQAAEQAAEQAAEQAAEQCBHCcAYk0XFwRiTRbiIGgRAAARAAARAAARAAARAAARAAARylACMMVlUHIwxWYSLqEEABEAABEAABEAABEAABEAABEAgRwkkNcZUHN9Fc4bfRde3aU4N8vLp4vZ96fENx+LZDTc4hDvirTi22xdn47bdaOiL++mMF6t+78Lpg7RkTG+6omU+Nci7kroUzqP3TsSTTnjD766aNJg6t2vlye2lMWcvnazwv5Ysf/7Q/k92Go1aXkt9RhTRd7FgLjaVFcfpnXnDqXenNp5c/E7fcWvo8Dl/3K5wZtwc+uxn6+iJQbfE+OTT5Z2H0IJSRdEfm/9TlPcqK07Th+sm0T1d21PTPOZfQO36jKRNR3RcrjBXdx9C0zZ8Tb/oYN6dsPj43CFPp5fm5fucNCuZbiJ+zrq+qXAKbfzCjqWcPvHJpMrEx8mzbEmDjyAAAiAAAiAAAiAAAiAAAiAAAiBQcwQSGmMqTm6i+y5tTlf1n0cbdpTQzh3v0tJJf6Gus/RJRzLJDp4YpI0qZvZOvzeBrmucTy27j6SFG/bQzh0lVLxuIQ0bV0QnvYDqvbaPTqGxXXvQ2OXFXpjNS0d577Xo9Sp9c8GM0XWv4jDTeH1GL8+ocOus/XFDQZT8uWLnZ+fLXqN+lzanvLZ309TVSsYdW1bRk/fOjZ+e5GKzc+Jvfe9Ivq4cJPnn2E/RG0Mu9sK9GGO0edUkuqPd7Hjcvxx8jq5rXEC3jl5O2zzdrKc5w3vTiNWKYpjcUd6rrCijxQMv8YwiAyavjsWvdL9wn4qZw6wovMwKs57mDP2Tx7nnFM2Z32AWjZoMpSGPPEgrP/VbT6RMdClcHCtn62naHVdQgybd6OVPdU7en9ORGrXqGS8TXG4Kbx1CG/6mw+AOBEAABEAABEAABEAABEAABEAABGo7gYTGmLLVA6hhkwG0/qiVDWN1icvgoEIHjTFi/Gh73xr6zojDH7t6jyfis0p/9X114OVbqUFeR98E3Rcg/uE4FS0rtlbBlFPRiAbeUdMfxIw5UfIXj9K4qaw4QFNubEr5nafSx/8wvrBuXWz2rFkaWAXz8fyuPs4Vx9dS30b5VLhSr0DyojaY7Zze1JeXeNJGmPgz4ybKe2z0cPE3ovGMK2FhDq0cQE3zOtLCj/UbzIJXVj3y5ln9kIgqy0tpTIdm1G3S3riRjAOwsYePOG87fEtsxVQpPX1xc+owaa/vfeL8Jsmz/wV8AgEQAAEQAAEQAAEQAAEQAAEQAIGaJZDQGHOqeBw1zSugoa9ZRgFDZpfBQX0dNMZwWF4dsflHI4LArXqv4M418e0+EuTXQ69Qx8b5NLtUnqR25fQbNrk/vpIiSv5cKZS/NyFgbHCFC2fjD83xsaFC8lVZvotGXtKcEhmtvljS0zOYPFviN274Yw5+SvZeZUUpjb6kOd3y/GfBl+NPDtHc7k2o9ZCimKEk/oV3I3H80VpB5TLsndo2jho26UmrvvLHwZ8OLe/nGZzUqqsymtujiWcAe9+/sCb4Ip6AAAiAAAiAAAiAAAiAAAiAAAiAQC0mkNAYw6sT1j52s7ft5JL2g2jq6n10rNyfm3CDQ9AYw1t0Lu35Kn3jj8L6pN4LrIDgrUHHXvNWjAxbk3grDkfI/kw+276K5s6cTIPvuoVu6qZ8n5jGmCj5s4TzPnpGpaYTqMR2aWIFdrKpKKdv9q+nl2c+S6MG3UJdbuka85OijTEczZdFj1GnFvnEPmXum7ya9h/1J3bh3EGazVt58vKpzW0jadHWr+hMhBUiyd4TxlOK/auS/FkrpdENmtOdS772P45/Ujq8wth6JSxkVZIE5eech7A/U19n9s+n21qz76Irqc+IRbT9K1hlhCOuIAACIAACIAACIAACIAACIAACuUMgoTFGsnGubDctGHOv5yiWfXa8aGwfkkl2FJ8xbIxxrXiRdNQ1aMSR78VQkMwYc75sHd3dujmx097CsbNo5vI3Pb8z62fc4VsZI/Emyp+EMa+SZ9uwYIbhewknbC6cK6XxXVp6BpbeI6bQ9JeUP5aSpaN8K2MknsryMnp36ZN0+zXshLiA/vys3w8Lhzu5fx09M7yPZ9DJazuU3ra3lElk1jXsPWE8q8R6wfex6sYYYSHRMSNeLbWomH0Suf4+9BkAldPgGVTYs7XHrP2DRQm2vEkquIIACIAACIAACIAACIAACIAACIBA7SEQyRgj4vLpQc/1z6O8gql0IOZ3hSfTvHphs3XKkWxVuXaKdvb7/pwO1KjJI1SccEFD+saYnRObUbPrp1Kp5c+Ft72YKy0kX3J15U++M6/H3xwWyXeNbYwRVrYPnvKd/m1KZlp8zwaI0vkDPYOMbGWyw5w/toke6dCMLhu4JuYI2Q7h/my/d+HURrq3YXPqMTf9bUpmHDYLkYZZhm1TkjBh1283PUFXNc6nZMa5sPfxHARAAARAAARAAARAAARAAARAAARqgkBiY4xj2wsbNEyDCvv84FUb9rYWfs5HIpvGGPb50rVxPtkn7fgznq4x5jitGNg4sAKnsuKQ53PEZ4yJkD+/bOrThbNbk/p04ZC2AcLtPLecikarY8PjhhaWy5KNT2+6tVE+jd4U8xFjfc/pbXn6d9T8hnl0yCW0PEv6npKncav7g46bJQ4iEt8ztpNlDqIc+PpPQrJZSFQVJ9dS/0b5AQe+8r3vasleWbHL2y5lGn184fEBBEAABEAABEAABEAABEAABEAABGohgYTGGJ5AX3vfFFq1RY6gfsHz2XHtE9vjJ9/waTjjb2zqO3J49bzB1Om28fRYvyY+YwznX03U8+mq/jrezatmBo62No04wk220CRbCeEZCvIKqN9EtQ1ox5alNKxrD3pw2F2+lTFR8idp21c5jtk8Prt4/VJ6PMHR1sphcD75jnC+sx09OOxB3zYlzuft7dhHjzoye+cOddRzXqsJtDu22mfnxJae3xR15HgJ8RHZ7GNmQKgfF5WDKO/xdqoxMZ2OnK+2eLEMvFXNPNo6ePy1HG1dQMNW+50+hxljWCpXmeBjwp8fcy89vlb8A5XSmCv6kpbnXZo/6mZq1qRv3Pnv+WNrqV+LAuo7J7idy9YfPoMACIAACIAACIAACIAACIAACIBATRFIaIw5c/AVGnxXl7iD2cs7303jl++3jowmqji+i6YPuikW7krqO24NHT73vXc0scuocnT7AiPeArq6+xCavvGrmIEn3ZUxvK3nOG2bPZiub6NWnLCD29f2nfEm/ebKmKj5C1POyYPr6IlBt3i+dNgBLfMZOX9//IShoAGinA6uepK6ez5g8omdIs/YeoyCpykdoPnD74rLz75v+o9bTh8ZW8G+fWci3dNVOSXmlUnMcN7Wo3EjWZjMUd/jLVurJg2mzu3YX02+53/nzhGL6CPjJCzmXLL0SerdqY0Xhh3r3lQ4hdbsMwSNCRJk4ZeQy0RhL8lPPl3eqQc9MHm1kefjtNGQhx0b/6lwHu04oh0bwxjjZ4pPIAACIAACIAACIAACIAACIAACtZNAQmNM7RQZUoEACIAACIAACIAACIAACIAACIAACIBA7hKAMSZ3dQfJQQAEQAAEQAAEQAAEQAAEQAAEQAAEcpAAjDE5qDSIDAIgAAIgAAIgAAIgAAIgAAIgAAIgkLsEYIzJXd1BchAAARAAARAAARAAARAAARAAARAAgRwkAGNMDioNIoMACIAACIAACIAACIAACIAACIAACOQuARhjcld3kBwEQAAEQAAEQAAEQAAEQAAEQAAEQCAHCcAYk4NKg8ggAAIgAAIgAAIgAAIgAAIgAAIgAAK5SwDGmNzVHSQHARAAARAAARAAARAAARAAARAAARDIQQIwxuSg0iAyCIAACIAACIAACIAACIAACIAACIBA7hKAMSZ3dQfJQQAEQAAEQAAEQAAEQAAEQAAEQAAEcpAAjDE5qDSIDAIgAAIgAAIgAAIgAAIgAAIgAAIgkLsEYIzJXd1BchAAARAAARAAARAAARAAARAAARAAgRwkAGNMDioNIoMACIAACIAACIAACIAACIAACIAACOQuARhjcld3kBwEQAAEQAAEQAAEQAAEQAAEQAAEQCAHCcAYk4NKg8ggAAIgAAIgAAIgAAIgAAIgAAIgAAK5SwDGmNzVHSQHARAAARAAARAAARAAARAAARAAARDIQQIwxuSg0iAyCIAACIAACIAACIAACIAACIAACIBA7hKAMSZ3dQfJQQAEQAAEQAAEQAAEQAAEQAAEQAAEcpAAjDE5qDSIDAIgAAIgAAIgAAIgAAIgAAIgAAIgkLsEYIzJXd1BchAAARAAARAAARAAARAAARAAARAAgRwkAGNMDioNIoMACIAACIAACIAACIAACIAACIAACOQuARhjcld3kBwEQAAEQAAEQAAEQAAEQAAEQAAEQCAHCcAYk4NKg8ggAAIgAAIgAAIgAAIgAAIgAAIgAAK5SwDGmNzVHSQHARAAARAAARAAARAAARAAARAAARDIQQIwxuSg0iAyCIAACIAACIAACIAACIAACIAACIBA7hKAMSZ3dQfJQQAEQAAEQAAEQACc4QDgAAAgAElEQVQEQAAEQAAEQAAEcpAAjDE5qDSIDAIgAAIgAAIgAAIgAAIgAAIgAAIgkLsEYIzJXd1BchAAARAAARAAARAAARAAARAAARAAgRwkAGNMDioNIoMACIAACIAACIAACIAACIAACIAACOQuARhjcld3kBwEQAAEQAAEQAAEQAAEQAAEQAAEQCAHCcAYk4NKg8ggAAIgUJcJ/Prrr3Ty5Ek6fPhwVv6OHDlCJ06cqMsIkTcQAAEQAAEQAAEQAIFaTgDGmFquIIgHAiAAAvWNwLFjx2jqlCk07IEH6KHCwfRQYSENHzzY+/PuCwfTw4P5u0L1XeFgGs5/g42wsWcShsNzGP786MMP04oVK+obVuQXBEAABEAABEAABECgFhGAMaYWKQOigAAIgAAIEO3bt49uaN+BOv22MfX65/9Fvf/5f0b/+6fEYW/51/9Ff2zcjMaOHQvUIAACIAACIAACIAACIFBjBGCMqTH0SBgEQAAEQMBF4MMPP6TO7TrQrObX0F8v+h1tu+j/ZOzv9Yt+R4PzWtCYMWNcSeMZCIAACIAACIAACIAACFQLARhjqgUzEgEBEAABEIhKgI0x/9WuAz1/cQcqvuj3tPOi32bsb91Fv6MhMMZEVQXCgQAIgAAIgAAIgAAIZIkAjDFZAotoQQAEQAAEqkYAxpiqccNbIAACIAACIAACIAACuUMAxpjc0RUkBQEQAIF6QQDGmHqhZmQSBEAABEAABEAABOo1ARhj6rX6kXkQAAEQqH0EYIypfTqBRCAAAiAAAiAAAiAAApklAGNMZnkiNhAAARAAgTQJwBiTJkC8DgIgAAIgAAIgAAIgUOsJwBhT61UEAUEABECgfhGAMaZ+6Ru5BQEQAAEQAAEQAIH6SADGmPqodeQZBEAABGoxARhjarFyIBoIgAAIgAAIgAAIgEBGCMAYkxGMiAQEQAAEQCBTBGCMyRRJxAMCIAACIAACIAACIFBbCcAYU1s1A7lAAARAoJ4SyLoxpnELevzxx+nXX3+tp4SRbRAAARAAARAAARAAgZomAGNMTWsA6YMACIAACPgIZNsY82CjS2nw4MF04MABOn/+PF24cIEqKyt9MuADCIAACIAACIAACIAACGSTAIwx2aSLuEEABEAABFImkG1jzD3/byNq1rQptWjRgsaMGUM7duygEydOUEVFRcqy4gUQAAEQAAEQAAEQAAEQqAoBGGOqQg3vgAAIgAAIZI1Ato0x9/2fplRQUEANGzakZs2a0W233UZPPvkkrVixgvbt20c//PCDt1omaxlExCAAAiAAAiAAAiAAAvWeAIwx9b4IAAAIgAAI1C4C2TbGPNDwErrjjjvo0Ucf9VbHsGHm5ptvpgceeICeeeYZmj9/PhUVFdHnn39Op0+frl1wIA0IgAAIgAAIgAAIgECdIABjTJ1QIzIBAiAAAnWHQLaNMUPyWtAjjzxCn3zyCY0cOZLatWtHf/jDHzwDzbBhw7xVMlOnTqXnn3+eXnvtNdq+fTt9/fXXdPbsWayYqTvFDDkBARAAARAAARAAgRolAGNMjeJH4iAAAiAAAjaB6jDGsK+YX375hT744ANiA0yXLl2od+/enmNf/m7mzJk0d+5cevHFF2nWrFneapmNGzd625iOHTtG586dg9NfW3H4DAIgAAIgAAIgAAIgEJkAjDGRUSEgCIAACIBAdRCoLmMM54VPU3r33Xc9g0yfPn1o4MCBNHz4cJo4cSItWrSItmzZQhs2bKCXX37ZM8rMnj2blixZEl8tc/LkSSovL4dhpjoKBtIAARAAARAAARAAgTpEAMaYOqRMZAUEQAAE6gKB6jTGMK9ff/3VM7iwEYaNMbx16YknnqCnn37aWyGzc+dOOnLkiHcU9tq1a+m5554j3sbEK2Z4G9P+/fu905h4GxMbd3BMdl0ohcgDCIAACIAACIAACGSXAIwx2eWL2EEABEAABFIkUN3GGBaPDSl8mtLDDz9MhYWFnt8Y9hnz7LPPeoaZxYsX05dffkk///wz/fjjj8Qycnh2+PvUU0954davX0+HDh3y4mIDz4ULF1LMOYKDAAiAAAiAAAiAAAjUFwIwxtQXTSOfIAACIJAjBGrCGMNojh8/7m1B4pUxvEpm/Pjx3sqXt956iyZNmuRtXXr77be9VTC8+oVXwbBhZteuXbRgwQLPKMMratiIw9ubvv32WxhkcqTMQUwQAAEQAAEQAAEQqG4CMMZUN3GkBwIgAAIgkJBATRljKioqvNUvL730Eo0ePdpbHTNhwgRavny5txXplVde8bYn8ff79u3zHADz6hf2GXPmzBlvK9PmzZtp3rx5NHnyZC/swoULaffu3fT9998Tx49/IAACIAACIAACIAACIMAEYIxBOQABEAABEKhVBNgY07nDtfRsmz/Spv9+KW3+vy7J2N+Kf7uYCi+5wjO2uDLNhpWPPvrI8wvD24/YLww78122bBl9+umn9M4773gnLPFpS2vWrKGjR4/Go2FjC2934hU2Bw8eJPYv88ILL3hGGfYzs3LlSs+ow05/YZiJY8MNCIAACIAACIAACNRLAjDG1Eu1I9MgAAIgUHsJsDGm0/U30Ng/30HP9+hLL9zy5xT+Eoef3PVW6nftDfToo4+GAmCDyp49e2j69OneH6+ImTJliucjhg0ybGhZvXq1Z6jhlS8lJSXeyhjTRwz7jPnhhx/oq6++8lbGsH+ZOXPmEJ/GxP5neLvTZ599Rj/99BMc/oZqAl+AAAiAAAiAAAiAQN0lAGNM3dUtcgYCIAACOUnAWxlz3fX0zH/1pBWtO9HKyzrSyitiV/Oen8nziPcvFdxA97RpR6NGjUrI5tSpU57fF3bQy0dcszFlxowZ3vWLL76gY8eOecdbz58/33vOznvZ8MIOfs1/7FuGDTO8WoZX3GzatMmLj1fKzJ071zPq8Damb775JmDQMePBPQiAAAiAAAiAAAiAQN0iAGNM3dIncgMCIAACOU/A8xnT/lp6ocX1tPOiJlRyUV7G/t68qAkNa3IZjRkzJiEnNqKwc15eAcN+Y9atW0evv/66txpm6dKlnm+Z06dPe1c+3ppX0fAqmffee89z8MvOfV3/2FjDW5vYAMPvvfjii95JTGzUYX8zvOrmb3/7G507dw7Of10A8QwEQAAEQAAEQAAE6ggBGGPqiCKRDRAAARCoKwRqgzGGWfK2I95qxIaSadOm0Y4dO6ioqMgznvDpSbwShn3M/OMf//BOVOJTlHj1DPuS4ZUu/DzsHxt7+HsOxycv8SoZNujwUdq8LYpPaGKjDW9j4jTwDwRAAARAAARAAARAoG4RgDGmbukTuQEBEACBnCdQW4wxDJINMrwliX298F9paam3PYmNLuwDhv2+yCoYPsp61apVnn8ZNszs3LnT23qUzFkvG2bY4MJxsdNfNsiw02B2EixOf3nbFK+q4bg4PP6BAAiAAAiAAAiAAAjkNgEYY3Jbf5AeBEAABOocgdpkjBG4n3zyibfqhY+1Zie+fLQ1r5Zhx74HDhyIG2TYPwzLz6co8WlM7KyXjTSmc1+JM+zK2584fj5Se/z48TRu3DgvHfFLw4YbGGTC6OE5CIAACIAACIAACOQGARhjckNPkBIEQAAE6g2B2miM4dUv7OeFV62wkeTw4cP0+eefe0dg8yqWvXv3xp33clh22MvOeidPnuz98VYkNrJEMaJwGI6DV8J8//333gqbl19+2Vstw/5r2M8Mx1dWVhY3AtWbwoGMggAIgAAIgAAIgEAdIQBjTB1RJLIBAiAAAnWFQG00xjBbdqrLR1KzQYad+f7973+nr7/+2jOOTJ06lYqLiz2DC4fl7URnzpwhPnmJV8fwqUzse4ZX2HA8Uf/xihr2LcPOhNkAxAYeXp3D/mV4qxTHzcdwsyyprL6Jmj7CgQAIgAAIgAAIgAAIZIcAjDHZ4YpYQQAEQAAEqkigthpjODsnT570TlZig8xbb73lGV/YCS+vXOFnbKzhMPKPty3x6UhsqGGfM+xnht9j57zJfMlIHHLl8Ly6ht/lbUzsX4ZXybBvGXYAzI6D9+/f76UvfmzkXVxBAARAAARAAARAAARqFwEYY2qXPiANCIAACNR7ArXZGMOrT9gYwsdSsxGETz1igwuvWlm2bJlncHnzzTe9lSqyJYmvvBqGfcusWLHC29q0ZMkSzxkwO+atyj9Ok0964q1SbOh59dVXvXjZ2MPbqLZt2+Z9xytqsGKmKoTxDgiAAAiAAAiAAAhklwCMMdnli9hBAARAAARSJFCbjTGcFV51wsdaL1y40DPIHDx40HvGjnr59KPnnnvOW7Xy3Xff+XzEsFGGV8ls3bqV5s2b562S2bhxo3e8NRtXxHiTIi7PGMQ+ani1zIYNG4iP3WYZOA1ePcMnQB05csTbNgXDTKp0ER4EQAAEQAAEQAAEskMAxpjscEWsIAACIAACVSRQ240xnC0+0YhXpfDWIzZ8iDNdNra88cYbNGvWLG8VDBtkbAMIO+blY6x5JQ2vrmFfMh9//LHnFybVrUs24l9++cU7iptX7HD8LJukwU5/v/zyS88pMPuhseWy48JnEAABEAABEAABEACB7BGAMSZ7bBEzCIAACIBAFQhk2xgzNK+ARo0a5a0oqepqFM4WG1V41QmfpvTKK694JyixMeXEiROeXxg++vr/Z+++g+2ozrTR43HAJCNAEsrxHOWIQBHlhAKSEBlEEiCCwCJnBIgMTjgCAzZgsE0Gm2DAGWMbbGN7fD04zVRd35mpmTu3pubWN1/dP99bvzVeTLPZJ2rvI4FWV3Xt1L16rWe93ec8Tz/v2w899FBKWaoVWRz3P//zP+O1115LtWYU+PXoauJNox5drX/q2Xz3u99Nj9r2ZCd90tfXX389HUuRYQLO9uDQjSkuuxQECgIFgYJAQaAgUBDY5REoYswuHwIFgIJAQaAgsHMh0Gwx5uOtU2LTpk3pyUZqqhA/pAlJPyKacIx0VpywL8fJLbfcklKCFO+1r1owP/zhD5NQc88996T0pFpBBuq+46bhYrn11luT0+YXv/hF/Nd//VdDnSsEF04erh2CzE033ZRepVX99re/TTVtjL+4ZXauc6H0piBQECgIFAQKAgWB9y8CRYx5/85tGVlBoCBQEHhPItBsMeasIWNizJgxMXPmzDjrrLPijjvuSA6WF198MT0m2uOoiSqdeSIR4YWQQ9TQjsK53Ca+J6hwoBBZPGnJY7DrtWlb33PZSHu67bbbUoqTosB+a9RCaHEcT2SCsaK/3DKEGY/K5syRxkS4KUtBoCBQECgIFAQKAgWBgkBzEShiTHPxLa0XBAoCBYGCQBcRaLYYc+6w8TFhwoQYNWpUTJkyJdatWxebN2+O6667LgkhBIpPfepTqe6Lpx55FPUbb7yRnCX/9m//FuqtVEUS7zlspCTddddd8bOf/eztVCNPUfrVr34Vn/zkJ5PQ8tZbb6Xf6kFCBNE+UUSdF3VnuGuIJ41c9NexiEb/8i//Ej/5yU9S341bPz0mm6ikDg7nT1kKAgWBgkBBoCBQECgIFAQaj0ARYxqPaWmxIFAQKAgUBLYDgWaLMReOPihOPPHEuOCCC2LOnDmxYMGCOOmkk+Kyyy5L7hZPSfJ4aLVVPJFIEVzOEQKJR0cruOt3Is3Pf/7z4KQhaniqEiHDNsYgBYnwoXaLAr1cL37jgCHS1Fu4V9SS+bu/+7v46le/mo6rH7///e+TA6fePtvzneMRlzyN6c9//nO8/PLLcf/996exGrdx5voy9dKstufYO3pfziVuJfNBkLISztTZIVZVBbcd3dcdcXwuKil0YpfAqL6ReFd8Oqfj7Yh+lWMWBBqJgDh3/ZauWY1zaZ2uxbv6daCRWJe2CgIFgXcjUMSYd2NSvikIFAQKAgWBHYhAs8WYS8ZNj8svvzwR7+uvvz6OOOKIOP744+Pcc8+NrVu3JncIwUXakvotv/vd7xJh5xbxqGhuGSKNWjAEC6vHSRNNuEsuvPDCuPHGG+NHP/pR/PM//3P8x3/8R3K3+GefWGM/Tztqz/FCwOFM+c53vpPaJ+J4TzRBHpqxEGbUuiFG/PKXv4xnnnkm7r333iQiEag8NptIpEBxs/rQjHHlNolJ+q6gsdSx0047LVavXh3z589PKWvS1rxfs2ZNnHHGGammjnnalYQHApV4N9/EyiOPPDIWL14cs2fPjhkzZsShhx4ay5cvT+fLVVddFU8//XRIp3svxkOOi/K66yFADP/Nb36Trm/nnXdeivNFixbFrFmz3o7zww47LMW5vwmu+3/5y1+aIojveuiXERcECgJVBIoYU0WjvC8IFAQKAgWBHY5AT4gxRBjuBwKJGi1nnnlmnH322UmkUYxXmhKR5fHHH08pSkQVd0mlI3niEReJfr766qvJIfPkk08mJwv3C5J6yimnpPZ8fuqpp5LjRMqROi1qtHgC00svvVT3SUt5AogjBBtuja997WspBcr++kw0aeYdW+SaiMSRo0CxAsPZ2fPYY4/Fj3/844QBTHZ2Ig4n6V8vvPBCXHTRRUlYGN46JoaOmRzjZy6KQ5atj5krj0/rtMXrYtyMhTGodXy0jhkXCxctSgKduSPKvF8X6WjIqTS79evXx7iJk2JI67honTo7pi5cHTNXHhezVp0Q05cfHRPnLIsREw+Joa1jY8rUg+LUU09NaW5EGedUWQoCOysCUjNdT4nmhNhRY8enOB910JyYsuDwmLHi2Ji1+n/ifNj4g2Joy5iYdvAhqei76y+x2rW5LAWBgkBBoBEIFDGmESiWNgoCBYGCQEGgYQj0lBijw/6ploYhDYkT4JJLLombb745OVi4XzhS/Mb1om4Mt4p/6Kv/jHNcEE2kdCiAK92FkEPc4bYh7BAyFPFVB+aGG25Izgu/cclIA5Lq5M4r0YDg486twsCEBO1zxEiL0q59CCSs9T1R00U//v3f/z2RGMISd49xwCe7ZYhVtbg0LCC2oyHiAEHJo8MPmTEz+g4aHmNnLIjDTrsoNt32QFx6/0tx3WM/i23P/CpuePrNuOYbr8XF970YG2+6LxafcE4SIwYOa4n5CxYm3KU1NVME246hdntXops6RUSYEUSqsVOT8HLiVZ+OLV98Jq7+2qux7alfxo3P/Cquf/yNuPzB78W5n3k01m/ZFlMWrIr+w0dHy6gxsWXLluT4IhSWpSCwsyFARFdofe26dTFwyPAYOu6gmLPm5Nhw7WdjyxeffTvOXQuuf+KNuEKcf+rrsfbca2PSvBUxYPjomDB5Slx66aXJMcm9WJaCQEGgILC9CBQxZnsRLPsXBAoCBYGCQEMR6EkxJndcvRdCx9VXXx1XXHFFcq6o2aKGgHQdYopHQhMgpCsRHwgwbblCuCi+9a1vJdeNuisEH6k/r7zySqrD4slLUmGkgXjlxrn77ruTu8bxOE/0yXEIIQQapFl9E30g8OifgsBEkJ4SCAhD1aK/nBTEKmldBCJilb4iKlXBKuPck69EJC4i6UjI17Dx0+KYi29P4svtL/8x7njlz+2vL/8pCQ+rN10ZA1vGxfCWUXH++eentJyewruZeJkfc2Xuxo4bHwcOHh6HrjslPv75p+LWF/6+fWwSdn+KG7/5mzjjli/HxDlLY/++A2LJ0mXJgVQEmWbOXGm7qwgQYrhhJkyaHH0GDY956zfGhXc/F3e8/KdOxPmf44an3ozTbrw3Oen6Dx4WS5YsTTWUekIM7+pYy/YFgYLAewuBIsa8t+ar9LYgUBAoCLzvEdgRYgxQiR9qpEgjIo5YOUAIKUQGAonfpRgp5ktsYVknPBBlagk6NwtHjfokhJjqnVSODQUiOW8QfKlNHC/cM1wcUqfs51iEIMKLugWKqBKIpE/53XbPPvtsEmwQg54UQIzB+NWyMQ590V81dbh9iEhtYdPsIIYDR4z6L70P7B8zVxybXDAdCjB1BJrbX/pjbL7r8Zg8b0X0ObB/Kv6s9kxPYt1ovMQqIYYA2LtP3xg0cmycct0Xk7jSHYxufObXseL0S+KA/kNi5qxZKTWvENVGz1pprzsIEM2vvPLKGDp8REqvO/WGu+O2b/++UyJM7bnAJbZi48VxwIEDY8qUqela3JYg352+ln0KAgWBXQ+BIsbsenNeRlwQKAgUBHZqBHaUGAMUBJ7gQljwVCFumG3btqW7/cir9CFFbIksivQSbrwn5NTWy0B4pR0RdLRHfOHWyIvfOQgUQVXDRl0YAgbyoP4GAUddGd9rw7Fsl1cOHrVuNmzYkNKrbOsOcE+TA+MwdqlWXD3uQEvF4v4hGhGzPLGpJxdztWrVquh1QO9YcuLmuO7xN7pFvqpk7PIHvhtzVp8Y++yzT0pBM0/v1YWbSu2fPffcMwa3jI8tX3im2wQ1Y3Tbt/8QR190Sxw4ZGQqiKyeUlkKAjsaAeL2wIEDUy2o8+56fLuvA9ue+XUce+kdse/+vWPcuHHpiWwcg2UpCBQECgLdQaCIMd1BrexTECgIFAQKAk1DYEeKMYQMj+4lxBATuE6IIRwf0oOINQSZ/Fhkv0sZ8jsRx9N3uCYIFBbtcY/kujFqjlT/ceeuQOo9ucnxHnroobS9/Qg33AWEDMdTLNf+nvBEeFFUl5NGUVoOkMMPPzyl5BCP9D87aQhFUou0k/vV6MnTrj5zwuinIpnIvjQmQpR+KqBLsDGmZvXDuODraVkH9usXC4/ZFFc+/MPgbsmiQXdf3U2/9Csvx9QFq5Mg8+CDDyYxrdFYNrs986T+0bjx46N3/8EpLemW53+33fjAVdrSEeddH/2HjIgVK1akOkrNHk9pvyBQDwHXge9///vR0tISo6bOirPvfDhuffGt7Y5zKY7XPfHzOOqCm2KvvfeJY445Jong9fpQvisIFAQKAh0hUMSYjhAqvxcECgIFgYJAjyJAjFm5fHlce/rZ8emN58RnNp4bd2085+3V5+p31fe12+XPeZ+bNmyME1asSrb1tgZFLPC0JI+r5vJQOFc9FOlCHCqerKN+C1JLSFHXRaqONCP1U7yqDSO1iaBi9aQavyHwvq+KEd5rRy0a4oXjOn5VtMl9zYIHZwP3ByeN9ogf+nbOOeekp9tcdtllSSDi7CEEEUOkEjm+9CqiEWFJ37lztNuoxXhgqH85vctxjd9KKIKh36qpW404vuMa29ChQ2PCzIVxwZe+ud2Oj6p4o5aKNhUCnnbwwckR9V5LV/rHf/zHVKdov94HxglXfCpu+tZvt5ugVjG65uuvxZITzo0hQ4clgbER81raKAh0BQHXINc1gmC/wcPi5O1IwavGdn5P3JWyNHPFcbHf/gek1EwidFkKAgWBgkBXEShiTFcRK9sXBAoCBYGCQFMRIMasXrI07lx3dDw297B4/NDlDVvvm704zpo9Lz2uuL1BVAUZAgJxhSNF7Raih0dZZ5dLFlM4YNR0kbZEuPHUIe4URXa5ZQgQ9pWWJH2pdiHIeBIT0YQgw9FSTWuq3b76mZiiTfVkHEOaEHu+YxF5OG8UElaslVikf7mP3DhcLLYhZOgvoUQRYmKJ8XV3IVRwEkmfMh7CFoeRPsIHjlwafq9N8+rOMfV548aNsX+ffqE2BKdGJlCNetXmus1bY59e+yWxQW2g98oinqSStY4ZG5PnrkhPkOpUMeM6tXTawlO60rmfeSxap8yIKVOmpKeE1RMW3yuYlX6+9xDgJPTkt169esW89acl4aSteO3u97e+8FZcdM9zcUC/wbFs+fJ0fXvvIVV6XBAoCOxoBIoYs6NnoBy/IFAQKAgUBN6BQEpTWrQ47pm9OH78oTHx0w+0Nmx9bq9RcdHEaanuyjsOWudDroPCyUG4+NGPfhS/+93v0uOcCSaEDXVd/OOfBQupQP/0T/+URBEChyc0KZJKlCHGED4U/5VmxDlSu3C8KH5LqHBc9Wm6IlLYlkgkJchxpU4RkqQHEWvUoiGK/PznP08Wfi4Z6U6ORaSxj5UY9Oijj6ZHHrP6E6KySENYMuauumlySpb+EX0IMfoHSyKXfsJX+50Voar4ZQdSv379YvKhy+PKh3/UcCEGcXNX3COwB44cG/PmL0hPuKr2Y2d+LzYvvvji6DNoWJy27Z6m4AMjaRxrz7kmevfpk2K50Q6onRnj0rcdjwBx97jjjosD+vYPdWI693SwDp6uVkeQlN7nyUz9Bg5O17Oero2145EuPSgIFAS2F4EixmwvgmX/gkBBoCBQEGgoAv9dM2ZR3DNjUfxkt5Z4fbeRDVuf/0hLXDzhoE6JMQbljr7Cu8QKogERgQPGK4eH9J/vfve7qTZGVZwgDBAViDVPPPFEEmWyMKOmiychcazU++edk8R+BBnCCDw4dbLg0xmwWeYJKMQffdQHtXC0ndNq9Jf4k0Uawg/B6fnnn09OGfsSSwhR+qE/DzzwQCIdhBOikeK8//AP/5DSnbhStEcQ6qiv+iDVi8Dz8ssvJzHGcWCsr9om2hhHPWEmC0J5LDAhbsH4bz74wTjhik82xRWT76ITZBYcfWYMGDw0uY/q9bEz89TobeBhXqu4VI+hqC4BacSk6XH9k79omhgDny1ffCYGDGtJtYx2phSO9vCpYlXe77wIuL60dU10zXZdGjhoUEw6dHlc++hPmxrnmz/9jejVp39ceOGFyVG486JWelYQKAjsjAgUMWZnnJXSp4JAQaAgsAsjsDOJMXkaOEuIL1mQIQYQCzg6pANJAVKLo7ZILtLgO/VZOEEIDlu3bk01O66++uqUliQ9qVa84CTgEuFW4aR58803kxulLZKd+1l9RTrdIX7uueeSIEOU8XhuaTXtuW1yn42Rk4ZIQzhi++eYIcxIM1LfRpv6qCYMEUVtHfMHG0WDHYtIwkmDPNXrv34Scuzn6UsEFalhxB/CEMFGO9pAtPSPGERYIOjkNv/yl7/ESSedFB/da5+48qs/aPy3juoAACAASURBVEjR3iy+1L5K7Tn95vuiV98B6SlXavfsDItYI47BQlxlbHLfzN+osRNiwVFnNI2gZqyu+OoPYsq8FdG3b98k1tXGeO5TT786T+HT6FpJPT2OXfl4xE+Ci5pXBOBqGpzrhGvRhz6ye6z/+A2x7dlfNzXWuWMGtY6PRYsXp5TLXXleytgLAgWBriNQxJiuY1b2KAgUBAoCBYEmIrAzijGGq6iu1CSCClGDywShU2vlk5/8ZBIRpP/4rkoOMlS+46qRQqSmi6dwnHLKKemJTdwp2stig30QDsSa+OFpTerBIB61BDu339YrEURqEpeLJzZ5OhS3D+Le1bb0jwBSFWkQH4KMQsEKHjuGVzhx0hBxpDoRdZAn4gyhwHiJTsaZx60/BCS1cwgHcNUu3LVhf8KH77iLfJfFLKLNnEPnxpDRk1ItlCwKNOv16q/9KPoOHpEEIHjuDIu5kXqmcLP6PLDMcQVbj0fvP6w1TrzqM00lqDC/7ok3YvkpF8QHP/jBFLvtCYA9iZ2UQaKq81BtJOeB+CvLewcBgovrA1FY8XRxnufRtfS6666LD+++R2z5/FOhtkuzrgG53YOXHBETJk9N4vF7B8XS04JAQWBnQKCIMTvDLJQ+FAQKAgWBgsDbCOysYowOEkeQAM4NKT1ZROBi4ejwGGePu/7Xf/3XdoUOTg8ukGOPPTY9lpo4gyS6Y191kGifwwR5vOWWW9Ixs/jwNmCdeMOVgJRzlBBKrNKDqs6STjTT5ia5feTWk6OIJMaXhaQbb7wxpGdZHZvLiEjDcfPb3/42jZEwwyVjzIQD5J3oo8+w1UZu57TTTgtPjIK3Wjz2FTeto8fEQQvXNP1uOBJ224u/T3Vjli5dmu6IE5X0f0eu4krRZmT0+uuvT4IVdxGySgSTSjFg5Ng4+85Hmk5QORKkixFj1CVy/B2JTT62AsY333xzwoirzXnnHMvncptBvov/4JzcGWLcPEp7I9C6noh14qw6XOKc88n1Yfc994rrHn8jGl2gOgsw1dflp14Qw1pGJ6F7Fw+TMvyCQEGgiwgUMaaLgJXNCwIFgYJAQaC5COzMYgxC4p999VS4NggBhAhEjmMDESY2SLHhBPF9vUU7RBWCzpYtW+Kss85K5Jm4wLlCoHD316INogkRiOskiyj12m3vO/1EpqQQPfLII8lto5/Ek7b62V57tb9p37i0hTA5FmGJm0fhWMeRxiRdSw0e+CHFVkKTsXHv+J1IAz9OIiSe24j7BL7nnntuLFu2LNUiOf/881OaGKeSOjMDhwyN2YdvaGq9mCoJGz7h4BjZ0hIbNmxIxJBoRoDaUSs3EhcVgpoFGQIW0UFK3ZFHHhmDR0+K8z/7ZNPFGI/MPv3Gv40PfOAD6RHD5te8i+MduTo/iZ9VfPRNbBFDxW1Z3o2A8+/aa69N5+mOiu98XOKsawbBsTqPHGF+W758eey9735x4zf/rulx7nqw5pxro/+Q4Smu341c+aYgUBAoCLSNQBFj2sam/FIQKAgUBAoCOwCBnVmMAUcWNJBbggLhgIuDCEFgkU4kbYd7RqoIIYFQUbv4zh1eaU5IDiLvsdis9zk1R6FgtVuIHF7VptEu9w07fncWQgmBw2O49ROBQUQ7cvN051j2MU7YwEgqAXHGuI0H+SXSKILMSSOtCZmCK9Ksb2rmEI2M3Xr00UfHokWL0rpixYr0KGsCBKJGjJmz+sQeE2OGjZ8WH9t33xgyZEjMnz8/LrnkkoSp2NgRK7FD7GQxJr+KGfieeOKJSYzxhJmqqNSM98SYjdvuid122y3VjZk1a1YSHs0nV8OOWqtiTCbyUt44tbJDprux/n7dzznLzTZhwoQU51deeWX6TJTeEXFOzCNcZzHGPBLY1LASV2vWrIk99+nVY2LM2nOvjYHDRqbr1/s1Bsq4CgIFgeYgUMSY5uBaWi0IFAQKAgWBbiKws4sxhpVTaIgnyB2HDCcL4UE6kLvIHg1NTOBC4aapd8edSKF4LaKsHXUsOEKIE8gP4opgS9XhEuEwkWZBsFGrRQ2V7iz6qb/SrggxyDpXCncJ4uX3nliITNk9w/1DECLQKJjsiVLqQWSRhuuD2DFjxoyYPXt2LF68ODku1q9fH+ecc05cdNFFMaKlNSbPW9kjaUoelyvlZ+TIkak/xIZTTz01zQ0cpUwQzHpyhRvBKpNTRZaJfeZZfy644IIYMGJMbLrjoaaLMdue+XUce+kdyRlz0EEHxdSpU1N9HUKb4sviWZ96eoWP2jmIvHPOeVp9pHpPxX5PnF+NOoZrF5HZuTZt2rTk5COa/upXv0rXpJ6McceSvkhIJsBYXRs4Bl1nFfY9/fTT4yN77BlbH/tZUwt5ZxFz6YbzY3jrmJSO1yjMSzsFgYLAroFAEWN2jXkuoywIFAQKAu8ZBN4LYgwwsyDjzjDSS5DhgrEgL0gmMYGgQlhRlJYjhABRXXx2R94dXe4YT05S+0M6EdKq/SzKEGt899hjjyXSrxYHYtLdhUuGQwXR0kd3lrlukBp1WHbUghDDlzAk/UstGoTZeOfMmRMzZ84MtVqOO+64JMRcc801SYA4aNrBMahlXFz/1C+bLjZc+dAPUgFfqT+O7/Woo44KT8kioHE11ZvvZmJK0BIjxDoijKd46QPRzyq1Y+CIUXH85Z9oOj5bH389kFQ1Ywgfa9euTfio9YNISy0jRPb0osAxIYGYSUxwrjkPytI+AnAi2EoBct6JedcsRcvFWE+KWIRkrhz9IcIQv117XUv1U2reh3f/aJz/2SeCaJpFk2a9Tl24JiZOmZrOvfZRLL8WBAoCBYF3IlDEmHfiUT4VBAoCBYGCwA5GoNlizIXjpsQVV1yRUnWk63RnRXqt/vHXX2KJuhyIAeHAbzkNx3fcALkuBYJsP0TUdl6txBrbuMv7i1/8IjkqiDTSeBQZ9T0yzW2DzNo2pzdx02jTMTu7EjnyymGTBRmuAcdS34Uoo928ndf8ufY1/+b7zqzucFe3q36ud6edK0hKmDvzkydPToKMNKWzzz47iUjINZLo0daXfeWVuO3bf2gaCVMU9LRt98Z+Bw5Mc8LJZC6OP/74uPjii1MscBspnkss6ylhiyvLk7MIV1Lm8kKI4UASNy2jx8a89Rub7hjwaOuJc5ZF//79E2H3SPcTTjghPv7xj6c6QYQ/cZ1dYz1F5p1PzlnxWhVhvM9Pnsq4ldf/QYDALLa4qzwJjqgmPZCwJR2To42A2hOL4xCBiDCEmSxwZ6chN+JHPrpHrNu8NTi0miXCaHfbM79KAvCSpUvTdbsnxl+OURAoCLx/EChizPtnLstICgIFgYLA+wKBZosxm1vGpbv06pAolovEc4O4Y/7cc8+lV++rK9JY+9l3VvsiJOedd15s3rw5pT5wrkgn8ptaFIinQr1nnHFGqLfg2LaRIpRXhWuJLWeeeWYiOuoi+M7+XjlXPD3EMdjwTzrppFQ/hRtDmg6irU3jsb3V++oq5Sd/9r662tedbqKCfm7atCnd/Xb3GbmRztHRmuu6VF+5Wdpa4Z9X2+T31VfHtqonIyVh+PDhMXTo0Bg1alRIf+GQ0VfEEDYf/NCH4thLbm9qqhKhh6AxYPDQNMeIPbzFADFG/Rrzp37Lgw8+mMh/T7hkEGYijP4Q8qQCeSS71A1im37NmDkz1LrZ+tjrTSOp8Dn/c0/GwGEtsW7duiQ6Ohc8zQmZhwv3kPNCfHGoEEWR6WYv8CFYEvwIfBxoSL3rTn40fU8JQ80ea6PbF8NSM6XjEbRdc1zLzCMHHxEwuwMbfexqe8SXLIZX41zhc440fRw4aFBMnL0krvnGa02N87PvfDj27d0vnfeE+LIUBAoCBYGuIFDEmK6gVbYtCBQECgIFgaYj0GwxZtPQUYnIjxkzJpYsWZLcDJ7Kw3ZP7FDMUy0JzgaOl86uHCUeqequsSf+aMe+iIpVm4i6IqocHIQD+1SP471t/I7weNJQtQ3tILLSPhzDdp4sNH369DQWgg9BRzv5uFJW8nuvHX22jTYIC5wejpHdDNKxchva6e7KeZP3rX2fPxs3FxDHESyNmVA1aNCg5LY48MADo0+fPtG7d+844IADUhHdlStXpmKxSBhnRjMea3v7S3+Ma7/x0+g7aHgsXLQokXjknWtAUVHzYl65eKSpGQ/MpA8RAJrpHuDsILoQr4gc4kAMwc6r1A6x3nfQsDjlui82jaRe98TPY83ZV6W5IfBxBnEImVO1ffSFKChViZDp3CCEItYcPM0SQ7RL+CGA5mLRji2tBUZERKJQWeojQOx76623Ukqga4J45wrj/nM+m1/1rTj9OI2aNY/OIeeXOCcIuU64ZplDjkHfe8LZx3rtH5vverxpqUqKVM9Zc1L06TcgCfNitywFgYJAQaArCBQxpitolW0LAgWBgkBBoOkINFuM4YxRbFURWEVFpbpwVnCsSCfyj7xHTnMUqPuCQLuT7k5sNaXJXeL8Ob9HyDlYiAcIn3395m6x1fZqwnAoIIC2VXRV2353194xuWq0gRw6ttopVpb8vGrXvo5z6aWXBiGCEIT8utOvTe0h6J5i1NVVX6VLIcvIMycDTPQTuUY8rIhRWyvyVrsiadXV7/bXlj4an7HmFC1Ej2sG0UMA+/XrF/vss0/ssccesfvuH42PfGT39Dp27NgkfBBsPrbvfnHqDXcHstToFAVpD4efdWXsuc/HkthhfiwIKPcHZ5GUHE4deOWiukgiDLkHjLcZRBWWUtaQ5Pwkpfwq1qQEET2Gj2yJsYfMbwo+xKpzPv2NGD5+anr6Dlw4GbheOMm4mwifhCJOFEWbxbk+c1lIIxIHOfWk0RccLiECWcbFKxKPzHPJiM2ytI2Ac5/rS4zDzrWMI0Wcc8e4bplHRaNt24w4d/6IHceqzqPYEuccKmomfexjH4s5azbEVY/8qOHXgdu+/fu4+N4XYp/9esdhh61IIlXbqJVfCgIFgYJAfQSKGFMfl/JtQaAgUBAoCOwgBJotxlw84aCUKiGt5OSTT05ijJQfrhL/2BNJ/FNPgEAqiAHuBhMIOiKIiAciIM0G+X7ppZfelXphG2kk6iwgE+7qIqAIhiX/TmThCvn+97/f5kzYFsklkCC6XDerVq1K7gPjQ763J/VD+0QdGCCrCLNaMo7XqIWAoHYMksxJQgyDCXeJeeBWImzAIj0NaMCAJL58+MMfeVuI6dWrV3IGEbqIHeqUjJw4PbZ88dmGkjAE7IIvfTM+tn+fOOigaUn0gpFFbCCk5p17Sfxwp6jHQ2CSPsFZBENzJZ7yvo3CUjvmi5hXJalimmNGjEldgqNH/x55wY1xy/O/ayhG13z9tVhw1JkxcODANI/VsRGnYCLuOVIIbFKFxMAbb7yRPmd8CJnNWIgtzj3xlTGCDyGNCJQXc9OM+cntv1df4edcdU46T82l6x3xVExzO5lD3zuficbNWPSD8Gzu8jw671577bU0b0To1atXx/59DoyTt36+4XF+7aM/jakLVsdH99gznW/O8bIUBAoCBYGuIlDEmK4iVrYvCBQECgIFgaYi0BNijLu6BAX/uHt/yimnpLQcrgZOECkUarUQY5BrK+Lhzi97POcJklGPrCEJBBl3+wkIBJkstGTgEHfEhYvBE5QQGwSdSOM3Aoo21D7g1pFaod22Fv1AJIlGRIA8Hu0SNxynu3ep9QexcafbHXFjQoKIHtrs7KKPtidOuJNO1OF4kd6AmMNYf+GP3EnrkfKQH+XNvSCFy6Ot9957n7eFmL333jvVkFHnhhABa8JR/4GDYvbhG1Ix30a4Yzg+Lv3yyzHm4Lnp+GLEHFYXxyeCIYjix3i8EhY4fwgh6vQgqxwFnFS+b9Ti+MQ7x4VXJqnSk5Blcwl/zpADeveOXn36x+ZPP9oworrt2f92DfUbNDTWrFmTRLbq2My/eUWa9ck5xS2U3Vb6Bi+/51oy7cV9te3OvBcb3F5iDj55dTyCIHycR56MZp7MV1neiYDzGI7mjbuJE4XI6DzlxDPHivm6VjqvpYO5LtVeA9/Zauc/mSOuPXGUU5PEOeE2p5nZxrWUA6tPn74xuHVCnHnbA3H7S40p6u2R2avOvDz22mff5Kp0btX7W9D5UZUtCwIFgV0VgSLG7KozX8ZdECgIFAR2UgR6QoxBwrKAgRAjFVdddVVcfvnliUgTQAgCnBZSFzzpCDkjziAeVrUKFLT1m20QyuxCcaffHX+/Z0Gm9s6p4yPittM2Ykrk8LQlhEYb2nUcx/Ped+0tfueG0U9pV1Yih/FpmzsDSekqwdVX+9hXChcBSR0UTwuqR0TggJgZm7voBAJYINiIsLFyRfhMLJJS8Mtf/jLVFVFbBGFWUNgx8pOokC3zoxbEiBEjkiCy1157pboknrDkTnzGX6qXJ/cMHj4y5h5xWlz6lVe2y/1BiLnw7udi8twV0bffgCTgSU9C+qoL/Lk/9AUxtBqn8cMDhvbjUvG9NdeSqW2r2m5H7xHdP/zhDwlLbRLNxKV+WIlfxD0OJzGhDpBHcffvPyCGjpkc53zikbjxm7/ZLoxuePrNWHfe1hgwYlQsWrw4OV1qxySO9NO8iyFjJ0xxpRC24ENQev31198+1/wm7vLcdoRFvd8dV5xymzmXCAnaJfw5PtGPuCru4MUpJ+7EUVnqI+DaCEviY04jFOfm0FxJTyNqmWfiH4zN4/YshDLxk0Vh1xQ1a/L1ROoSQc/1RLHoww8/PNW9GjRkaLRMnhmbbnswbnvx99sV5woCrz33mug3eFjMnTs39aej6/L2jLnsWxAoCLy/EShizPt7fsvoCgIFgYLAew6BnhJjMjD+keb64EJxp5WzxD/3hACkjdUewUbMCAVcJkgHop3FBS4HooJ6HAiB7RAPd9YRBsQOGXFHFzGsLgiru/KvvvpqIi7aRGKQdqIMIu3OvafyIJTITnuL8Tg+gmQshBhij3aNSTtcKfpWTctor83qb0gzQsQZgmQhRgQaKTr66r275PBw19w2CBmBCMYIODGCs4bApGZIxkqqinbhiSjrs/0QZq4lNWM4YObNm5fcMAr4erKSdAT7VRepXwoQDx81Ng5ZemRs/sxjcesLb3WZiHl07em33B8TZi+NYSNbU4qPO//1xAFzS5QTG+YMuYe38YgLoolt4M5dRXAiTsEFdrWCXXU8bb0XJ+KRaOc44hUhJf4Qy2CPMItpT+E67LDD0tPE9M/2I0aOjBETpsXRF90aUoy64yK67IHvxpITN8fAkaNj0eIl6TxoK7b0i1tMXIrznI5HPMrj9yqe/GY7GHKH+b72/GkLF9/b1j7mQZwSqogwznfnHGec9uHkXFfcWCwtXrw4CQ3msiz1EYANTJ2f4i+73Fwf82Kuid3OB9cB2/jcVfHCNdJ1QmyLc225zviOeMdNJUacT661ip8rzr5gwYLkwJLqOGHylGiZPCOOu+zOuO6JN7oc51IUL7r3hVh4zKYY0jo25s+fn1ySHV2PMxbltSBQECgI1EOgiDH1UCnfFQQKAgWBgsAOQ6CnxRgD9c8+F4fHV7vbi6BJo0A2vGe55yrxzz+BRNqO1BOiBBJJhLE9ooD8cqEgksgD4on4Sh3hTHDHuB6h1CYig5hrg6DB5YLQII1IBlLtuLWOg9rJQhA4IfQBCUeCCCD6g7QQOqQPEIiMoTN1HbKIoP9EFARM2wSSs88+OzkuuAqIC3AwDsTXdsgw8YGghcQhY/rouL7PT0ZBsuxLPMoEyzHU9/AoXU944lpQF4fQ4r3CxR7tzVlTXWDkO083GjN+YrROnR3rNm+NC+95LhWu7ehJS9uefjM9nnnFxotj5MRDYvzEyWmMRIL2FmPjboIF4YmDQDxYjTXPHTzFE3yy6EQkg1Hepq3j2Jewoz0xAXPiF8EiCwjEIoKbWFIjxiOmiQwIqsehiw3bwnv69BkxbMzE5CIiPBFluIHaE2bUmrn8oe/Fhqs/GwctWhdDRrTG2rXrkrAhZttajE3MEYLEohgn2vlcTdsSH4QmpNtvxiFeCU2dSXmxjXPa+QcfooF6JtqEDQy1RYSRznL00Ue/TeDh5PtCtNuaxf/+noPJOZvjHMZWuOcYhiGcs5BiLgnPnXU7EdPEBaElpzBy2xH7zKHFZ/Gh7pf0uIULF6Y4F+sEXjFGiJ4xc1YMaR0XC489K86646vp8e4dxfmtL/x9ctYde+mdMXneihg5enw6f4ynniDbPmLl14JAQaAg8E4EihjzTjzKp4JAQaAGAf/wuGuonkVeEdbaFRn1e/X7/Nlr9ffq97Xb+y3/Xv3N+2ob+be8rdfq79Xv87ZefZ/X6vf5fbWN/F21rerv+fuXX3qpPEmhJm625+OOEGNyfxE1hNg/9v7xR+TEAYKB0HG56B8iUSVqhBQkmrsBYbQdgmkf7UgVQoil2SAVWWSptqEP/rknoogt+yHwBBrHcx4SJgg67gZ3tCBDhBukmxhE3EHOuWYQXAITIkUIYOtHkI0/CyXG5DiIFGcQp0l2MhBykHjCFaHE44o9xYhYoj0ECCHjoqklLMQsIgQChcRlbAlfzi/ilv4Zu37DTg0W2J111llJhOGOkUZG5OGIITZxDdUuyBrxhBA2e86cJBhMmL0k1p13XXK7fPwLT8elX3k5iQqEhUvufykJMBtvui9WnnFZjD5oTowcNSaJGGICFh0tjmmMWfQimCCtSCjBxJxUF9dYceM388FFYJ8q2axuL2YIYjDWpjiBm7ipOg70A5ElKhx77LFvCzEIqs/SOyz6KsY9iWvUmHHRMuGgWHDUGbHh2s/FuZ95NC7+2xeD8wU+lz3wnZSuhcgee9mdMWPF0TFwxKiYOGlyEuS4f7TX0UKEM/fmF9EWC8gyAU985pgxBqKKbcw3Zwt8fCb4+L128R2RKWNKTM2Y1tbngaPzQupblcB7XLzjlaV9BFwvzJlzl9PN/LsmuMa5dmRBRiuuBa4huVYQsdV1xXWm3jzal3vJ9cA1Qqy7HrvO1m7v3HfdEcPiO6/cMerViCd9JVyuXbs2WkaNieHjD0purpO2fiHO/cxjcfF9L8blD34vxbm0xgvu/lZsuuOhOOqiW+LgJetiaOvYmHrQtFS3iuhZ24f2kSq/FgQKAgWB+ggUMaY+LuXbgkBB4K8I+Cdn3NixMX9oSywe0ph1yV/b8bpw5JiYPWVqLGgdG4uHjoolQ1vTunhoa1g7+9l21e2X/vXzwpFjY+6ESTFv7IRYPLwlrUuGt4S1q5/zPnn/pcNbYt6I1lgyY2ZyT5SgaQwCO1KMMQIE1j/byDcixxGDaBBIkGWkkQCASCB9VcJhf/+kI9LOHWPJYo4UqNNOOy0RP0WDEWhEIVvtkRJE2/7IKieLPiA33BNSKxAZhNSdZf3saMlt6QNBAkkiKCCliCgxg+jhN04OAg2Sb/yEF4QJ0UL4EWd4wMA+XC/6SOwgLnG3EJ8IRo4nlScLCsaFPBsrwuY4xmHNriNuG2KRYzqO4xESvEpRkkLiEeRSEAhd2SGEaBlPe24JRJAgwiUzceLEGDx4cAxrHRutU2YEcebgJWvjoEVrY/ysxdE66ZAYPKwlhg4bFmrRXH311Wke22u/dh7EBBFNAVN30MWCORQ7yL+5ri7myXiQTdvAEbbmKAt2Oa7gqg1tE8TEWL1YsL3jIKCbN29OTw1btGhRIqrq6SC51cUcmmfbtLS0xsAhw2Lk+KnpEdhTF66OaUvWxaS5h8WYaYfG8NETY/DQYeFx4pwI+qOvjtmZBT6OZ/4JaeJETJt3bSHOtW0h94RO2CDm8LRdxsdxiVEIPKHJuSNWiavO09r2bO88I0QqDM0NYyXKcF7BrSztIwBTrj04i13zQWRzrYO7866Ku7kyP+bYdUL8uh6Y2zyPtifoiXOitutfFqXFSb3FuWNbDjkCTJ5HNWMIm1nccwzXUcc+9NBDY/jw4TFk+MgkQI6dPj/EOeFl0tzlSYgdPnp8DBo8JMaNG5dqUBHExXlZCgIFgYJAoxAoYkyjkCztFATepwggbqNGtsTjuw2L7+w2LL7b4PXZfabEnSefHk+2HBrf221M/GC30Q1dn+t1cHz+8OPiqzOXxA92G97w9Rt7jYwt0+ckAvU+DYEeH9aOFmMMGKkjDrgjS6TwKFz/8PtHnghBIPAPPVKBaCMJtaJMFThiAecCgqJQsJQIwoyitJmQcoM4JoKIRCPYjseFgtxwThAU3AFGSJGYqhOierza98gNkmQs2iOgOA5iwUHgO+lGUn+ks3BOcLkodEwcIJAQpexXFQiqxzF+1wukiFCgn/bJuBGftEX4QbAQG4IWkQaJI/4g45wwXAlwho0npSg6qyCnmiewd5xMsKp96Og9vIyBmMNdM2vWrFQMeNCgQUmgQc6QNOIFvIlDncW49tjEGyQS4XRMOIgX/YdLJp/V/cwTgQ525gqW4kY8EBSIZ9pTFJpYALf2cEBsxRDxz5yKOzVRCFq1aV25H8iyeCdCrVixIkaPHh3wsarPM2XKlNSOPhB0uouP+DPHYlvci3efxQABqx7xhhl8uI6k7RHyOGngZnvxRLAUf35DxNs7L/3GaWF7opLCxoQYaVwExbJ0jACB1flKOHVemlfz4zwmSNa6kbRoHrlkCGaw597L4q39CcLiwG+uW86dqqhT2yvtSQcU50ccccTb82g+nXu154h5dx0Tb9IfOaHEOZHWI9lznNtfP5wr9QTP2n6UzwWBgkBBoKsIFDGmq4iV7QsCuxgCWYx5drfh8ePdRsRPGry+tPe0uOv0s+LFUfPjp7uNj9d3G9vQ9ZX9ZsS9R2yIx+YcFq/vNrLh6zN7tcZF0w8tYkwDz4u3xZiZi+O13VrjZ7u1NGx9fo/WuHjCtCSCdNRl//wjBki5VByviDGSjTxymfgemUQYOlsDAXmRNoEEKCyJPBIovCfO+Odf2wi7XLhQbwAAIABJREFUVB99kJqkGC8iz0lAzOAOUJukrUX/84qMIPNIEqGBy0Tqj74TXBzXWLTvOIQPqUcIb3YgtEeGqn1AzglF9nUs9WQuvfTSdDyEzW/umCNEiBoxiOilP8YkZYVwg8wRJPRRipJ2fEaw6wkZ1T505b35hI21ke3qA/GEaMepQSwwn8ZqbESEeseDM4GKWGXscISH+DN+LgTOpfZEBsfWDpwJO4S2Sy65JM2/OYCnNjqzOA4iqvg00aOzcdBR22ISATcmTjN9JS7ldCSEvK1jcVLA1HljJd7AyHt4EfZg2NGiHY43eEizMzfOLbFPkCpLxwiYI6Ic3LhjzKtroesY8ZUY2FasZkHEvNnWXJh/10JCLOGtM44012UOPqmgrjXacC0hKBPoasWYeqOyjRh0vRXnZSkIFAQKAj2BQBFjegLlcoyCwHsYgSLGtC/gFDGm8cFNjFm5bFlsO+nUuPfYE+O+Y05o2PqpI46Jk5csT+6UzvQc0fCPufQIJI8rgXhAROBWcNdVzQRP+yFkIIUd3cVFTNyNR0CR7VxfAWmQ6oNIIDZ+0y5SwiHhe8SVaGIloHB4OEerC4KP5KgBI4WAqwUx0RaSQ9TwWOOTTz45CQW2QZiQV4KBcXFH+B5xd0xj4+ogQrXnhPCb4xqbY3FgOJZj6j9CbxsYaEuhXsIEpw8CTazgaNBXKTMIHYcGcUg/kL56AkZ1/N15b57bIv7daS/vg9xxHSH55lffYQ1PogrSWo+o6gsSSphSXDbPl/kQO53BQNzCV6wQYmBMvDPH5sHa2SXj02iM4MPhY76zC8k5lR1FsKq36IfxGY/44WRRL8R5Q6yDXUd9FefiiQgoTYkDS+zqE4wJQ2XpHAKuQa6DnC6uHWJaaqfzl4jovK632M48mgdxztVyyimnJIGaKCLOO5pHIqrrI1cMIcZ1I7sVCd/muaM2ct9sl9f8XXktCBQECgLNRKCIMc1Et7RdEHgfIFDEmCLG9HQYJ2fMypXx+SuvjZdv/1S8csen4zudXNvb1m+PXndTnHfihlSDpCvj4gxggyfGILWeyuI7wgJSS6DhOkE+CB+EBUS7rQXJQBQIJcgku7y79NpEQgg67gq708w5464xMQLhyHVTiClqJBBrYIbQsPsj/r5D+DPpJwj4zTYIrP4hrtIAjAUhqi6ZJCGkxsaNoy3jI6r4DglCXGCgv9omFnCCOD4S5jupVUQjd7/1g+VfnQ445rvhhBlFWW0HD/sSKwhOUpQIU9JGCAnvpQWOar8YC3cTEc8YuIOMCYk077WLu/Q5/YNIQIzi3jBf5o5g0N6CgEp7y4IeHAmFeT/zpm87enEemHux7RwQ+4QUMQIz8VIPH/0Xm84Poh+nl5WrSyogMbK9xXGlyYg/+8CHCEiQzNjsDPi0N4ad6Tdxzcnk3Oeks/jOXLgWcHnVm0cYm3/Yi3NPQxLnUuCcN84V89HWYh45mByX6Oga47PvLdpvb/+22i3fFwQKAgWBnkKgiDE9hXQ5TkHgPYpAEWOKGNPToUtYWLdqdTx18+3xL/c/Ev/3l7/esPW3d90d12/clFJzujouBJeQ4Q4wIUFaRBZcEEjkGSEhyiB5XqUaISH1CAHCYB8klABBbMjb2p7IgRwSOjgEkGtiBbLCBTBnzpyYNGlSTJ8+PdUDkfaEjEhLIbwQWdydRnbc6ScaGQOi75XrgrXfWIgmjle76AdS5W43cSg/5ck+hBcOGClXWQDyiiBzGMCGyGN1Z1wqV37qkkK67qITuKQYSOfRb6QKrsbJLYEkI8uOkbGu7WN3PxO+uDGQcoKRuVPjQuoMLOrNWXeORRggYHF7SE3SLlEEHgQuhJWwZfGbOdcXGMAD5ubRd7mAM8eLArj1BAPzRdgithEGEVvCBmdOve3rjSnPOyzMkVgiAokTcSNuO5P6Ua/t6neOIz6Ifc4Zca5dGIh343d+GJNtLbYXizC1j/OROCjtKsczt1l2yFSP5712HMe23G6cFGINZvXOgdr9y+d3IwBT5zjxTKy51vjOK+eT78SPubP4zTkgnlwzzIHz3hwQKp0rhF/75tTQ2qNqw7a2s79YcU0Ss11Z9Ml1QPyIc3Hnuu2cyy6frrRXti0IFAQKAl1BoIgxXUGrbFsQ2AURKGJMEWN6OuyJMUesXh3fuvXO+H8feDT+90OPN2z98+fui1vOPLtbYgwciC7EDY4WRJAY4R/5TEzdyUUGpBshe7bhfkBoEZO8XcbUZ2KL9pAKBJ3F3rZeiRpIOFeFdtxlJlAQZDgBiDIzZsyIMWPGxMqVK1NKDwKO2MARac4EKB8zv+orUovgI+5ICIECyam3IPL6JGULefWYaY8EVoiYEIRQI1PcDdVxOo7UE4KKNAJ1HNQwgY26H+5kcxzpt8/aISAQljg79C+LGPX61dnv9IkwYpzGqx8K2ireOX/+/LQuX748CVucKPqE7GVi2dnj1G7nuEgnwmisCD8siUscAb4XH3ATO1wEyCuSmp+opA3zCAcx4nfEE2m0XxZZCHy2QYqzkMF1In6y4FPbv+pnIghxSuwSzsSXJ9ModCzOFDdW1JcryxOuxD9hY3tEDH0nchKmOKaMRwzCR2ocNxD8jB85RuoJVTle/I3ShrEj7jD2G3yQ61qXjPONmAV3MemcgldHLowqTuX9uxEg8BI1nbtwz4KmmOZ0cz6JLfPoGkpkgz3R2jWOEG0eCW9iigjpPPU7sbZ6HpprbZhDsUCQsy0h2P7tLVkI4r4iADvXXQeqcT537tx0PZUyxbEjDp1XHbXd3nHLbwWBgkBBoB4CRYyph0r5riBQEHgbgSLGFDHm7WDooTc7sxgDAsSYyIEUExSQBaJGlcx5z7lgm5zahFxUxYpMPJAQjgxklKihTSQRwUDIEUukA7kkyBBakB04ISm+R5oRCE8IImBwrtjX9pwXSBDyIrUDGXJsC3Khn46VU2CQnvy7bZAqfeQ0IDIZL6LPzWNF9okzjidFwXaIPww4ctSecacb8XKnG2HjArIfUUZqgmNrG0FD5hCr3KY71MhXd5dM7Ak90rwILyNGjY3BreNj9LRDY/K8lXHQ4nUxddHhMeHQ5dE6dXYMGDE6Ro0dH8uWL0/9IAbApbsLHDg5YOSamhduFfNrhQlxxvzDCY61Iod5IVYQYWAKJzGGKMJbXHJFmR9pSTnFrSoY5mNXX+0rnhx73bojYsz4iTFwxOhomTIrJs9bEQcvWx/TVxwbhyw9Mj0KfPiEg2PwyDExacrUVBdIv7eHrIpDMehcIcwYpzkn/mUHi/kTz84F23IyEI9qF/gQ0YydaOW8E+OEVG4MYo02CElINqyIYW2JkLXtl8/1EYCf+COOwDeLK+aRm0rsiy/CIPFL7IpV1yXXpOqiLfPoOmc/54d5I7aJVaKcGNCG6wZRxflAxGlvES/m2rV25cpV0TJ6bAwaOTad864DBy87Kg457Kj0GPcJs5fGsPHTYtCIUTF12sFJfBZ/+utvQFkKAgWBgkAjEChiTCNQLG0UBN7HCBQxpogxPR3eO7sYAw9kwT/2XBZEBik3mRxWhQwkE6kmrhAcED8ExLY59YQTApn1u3owhBW1YBAG6RbIBjIjDYDIUSUC+oFgIjgcKuvXr09pPYg/spIJkD4iSUg+twXSQiBAeOyvbeRV2gYSj+wYH3Kln0irMSI/xB/HQ3AJFNrhVkCajc92RBXCTHZo2MdxOW9gwilDdNFnT7FRRFX/PNkJ8eISQtyQauSruwsxw1iR8pmzZkfv/oNjxKTpsfj4c+P0m++Pi+99IbY++pPY9vSbse2pX8bVX/txXHTPc3HK9V+KuUecmsjYgCHDY/GSpQkfZBDmXV30w/iNibMozyEsiClcThs3bkzCD9w6En4QXI4D8QErOBNospuA00rqjnoq3pvnthakGdFdu3ZdDB3RGoNHT4pZq06Ik7d+IWGx9dGfxk3f+m3c8vzv4sZnfhVXPfyjOP9zT8RRF94cU+avjAOHtMSwES2xefN5aYydceDU6wtBUpxyN4hJi7mHG8GOS0GciC1/lzKG9dqCN3yca9ok8iDh4tQcINWIPhIv3vLx6rVVvus8AtwxcDVP3C5ZZBFjxEaFvBX1dq179dVX0zWmvfPJHDt/zZd5c43SrhggOjuXzKlrpbhx/HqLY7iWuf6tWr06+g0aEkPGTolD150SJ1/3pbj43ufjusd+luL81hf+PralOP9hnHfX47H+49tiwpxl0W9oS4ybOCk5xsRSHlu945XvCgIFgYJAZxEoYkxnkSrbFQR2UQSKGFPEmJ4O/feCGJMxQfoIJe4EEyIIJ9wnSCRigJhKk0AoWPVZ4k888cQ44YQTEjHxBBEOEU4WhIPrBXlEZqRSIOXtkZXcD6QFueGM0Tbigow7fzkNuAry3WgiCAJPIEFqCEMcCMQVxBSBJ+YQiQgsiI6xZTeCPtUSYQKUsXLB2P70009PT7ghtmhTuhXyYiVOIcH6wJ0gLYn4tGbNmkS6iTlcMUhWPedDHnNHrwQLY5dONXDIsBjUOiHWn78tiAu3v/zHuOOVP7e/vvynuOzLr8TyUy6M/sNHx4iWUempRDDtzJzU9s9+RDfCkBQc8QELIpRHgCOp3ndFzIAnzIlkYgvZ1b5xE2o8JYgzighWu5gzcykORo8ZG30GDo0FR50RW774TNz27d+3j81fsbv5uf8jzrrjoZg4Z1n06n1gEq3EcHfEDX3MAiKnmbHBTIzARyqJc4PI0ln8tck95nxQCJrYyc0l5gmKzjMEX6yUZfsRMC+ElyzaEnXFgmuR64BzkajmWuga2dl5FKeEb2KxODeP2nPdci2RMufaW28eHUNqmnkfN2Fi9B44LBYff05cev9LnYpx14kbn/1NbLzpb2PCrMXRt/+gWLx4SUqdI6aWpSBQECgIbA8CRYzZHvTKvgWBXQAB/wyPGtkSz+42PH6824j4SYPXl/aeFnedfla8OGp+/HS38fH6bmMbur6y34y494gN8dicw+L13doXVrrze3m0deNPgveKGOOffISWMCENBClA7tjliR/Z8UJ08L2nfXi96qqrErlEKBBEzgUEHJHQJjEn18rwWz0i3RbqiHd2EbhzzGWB9GfSgyhxunBCcM0QPfRJkVzuAUSeKKB2ynHHHZe+V8ejIwIMB+QK8UXE1IZBmoyP2AQTqT6EA6SIYGNbrhrtwyTfNT/88MMT6Ua0tNudxXiJS5xC+/XuG9MWr0sumA4FmDoCze0v/THO+dTXY/ysxXFA7z4JHyJRxrSz/ZMmY8zEMIIFMcB7BJNrgCggVohqXRm3fiCqiiITLOANU7UuiGKEPq6Aan+955bx2377759SNU694e7kDOgORjd/67ex6ozLY/9+g+OQ6dOTkFiPGHeEVRZOOBg4ffTPeHwmDIodY23LAVGvff0QC4TK1atXp3h3XhEY1Q3SJmdYWRqDAIGCMOJ6Z664k5zvhDTXNfPo2kTEdk50dsntqlfkvDZ/xGRxLt2R2Ox6UruIFemfgwYPiZGTpidRxTndnTi/5uuvxYqNl8T+ffrFxIkTU4x2J85r+1g+FwQKArsuAkWM2XXnvoy8INApBIoY076AU8SYToVRlzZ6L4gxyCzxgUiBQCLXiCMniAKnRx55ZBIkiBscCkQR9WK4ZNzxR4TtRwDhREFU2O8JL9omyCDoithyyCAiVTLdFqDIDRGICIJoKvbrLnQmKdrIAhJXjzvG0pIQmmOPPTYVs1XIUl0VggyRhIjSnlvDMTl/kCzCDpcQG78xIrnSB4gORB5kmFikeKa75vrqN0IEjDggiEAcQwi4/bsiTGRcHNscHND3wFh4zFlx7Td+Et0lYEibfd1Jn7ni2OjVq1cif91xf0hzMt48Rk4ZQh4M1aJQj0cscLZ0dhFTxC6iDmcNcUFh5XXr1qWUCnOLFFdFPWKS1Lm99947ho2dktww0jO6Q1DzPvY/5pLbUr0dBX8R8q4u4oxIKHWNoCeWuCoQXu4IMUawcu50Ni7ME3eNcwFOUmSIVOKDU4MQ6ffOttfVMe1q27vGmEcCCBfM1Vdfna6B4tw1h8gqxgk0zodal11beKlJZP4JyNx0RLqjjjoqrYpN++waUjuPth80aFBMnL00zv/sk3Hbt//Q7TjnqLvh6Tfj2EvviP37HBjjx49PTykrgkxbs1a+LwgUBDpCoIgxHSFUfi8I7OIIFDGmiDE9fQrsbGIMcoHcI8tEBDU+csoPYkcwcZcWiZRmQYBRKBbJ45BBTAgwiEgmCtpEwBFpNTGk5iDpyDQhA/GUykLkyYJMZ90Y+urOP/KpH/YnFOl7ttVry51pQhHyTkThaHHnmnhCJECGkR3EXlvGJnVIvRf7G4/rA0HF+K2EHUKSseUxSsWBCaHFmlOz9M2qXUV9ETRtcO7oP9JtP24aY+rsAmPt9u8/IOatPy0uf+h720XA3hYbXnwrLrnvxZg897AkyEjlgkNnF/MpdjiGpGSZc4JUJnLwJNgZM5EOjjle2joGnIlWcCO4iCevUtXUHpK+QYyRpkMwMyeOJ+bGjR8ffQYMSQRVPZg8zu153fbMr2P9+TekoqeHHXZYio+2+l77PXGTG4YAKO7UDxJfxmiBBULuHHGuiauOFgKU+EHIuSjMgTpEhEr4XHbZZek4zj345LnoqN3ye30EzJEYhDWhi+DlPCH6ZmzNpzQ01x3X0VrXVr2WnQscNuJYfHP4udZwyHDKEJ/Fi5Q7oo/F8WzT2toaY6YdGmd/4pFU92h74tu+BJnrnngjjrrgpthn315pjASmshQECgIFge4gUMSY7qBW9ikI7EIIFDGmiDE9He47UoxBFJCJLLxI58l1LAgaBAtk2R12NV6kBblzjwAgFfZFsNWkQAxsr8hkdrzUYom8IKH+mSd0IOEIBwKjDeST2IFMIt3a74ig+1177h5LB0Betcs5QWRR5NUdZsfhPCDIKJ7KPUNc0FdiEAxsS5ThJCBwuJttP8IJMuU7Qo2xEmm4EHL/YElcgJXtjQPhVeAzCz3a5QwiBhGNbG8/x9cnZM2+xqL9TOjgaBtCV/U7+3IYjRw5MsYeMi8+/vmn4tYX32qI0ICIES3cXe8zYGjMnDUrkco83tq5zZ8JYMYFe/EgjswnLJFKAklepFTov7kSX/Cs/p6382rcYianOSGs4oMTipihKDAhxgpfqUswMwdSdvbrfWCceOWnu52a1Baplcqx+MTNMXjosDTOap/rvYcfhwR3CnzMN3yIcdKLqov5JaaoFyImkPy2loy7eHUOEGIIXoQ+cWfNYpUYdJ53x+3U1vF3te/FLiHVtYVI7Zog9pzDVbFCPJsboopzgANQ3La1uD66hjpvXI+c865Trl1HHHFEcn/leRQ32svXEC7F/kNGxCnXfTG2Pfvrhl0HOOWu/tqrMXv1CbHf/gckZ59zqywFgYJAQaCrCBQxpquIle0LArsYAkWMKWJMT4d8T4gxRATkgXCCnHKNcLEgakiz+i9EF6QPkSNYuMuKCLqrKz0JuUPeqmJAxgqBcOdeKgiy7E4xsabetnkfbekLAcjxOScQVOKFVwSHcwUB7UgAcByPTUaM1G5ASFn5FQ/21B7kHLExFuNAXmoXpIkjxfE5B2BGWEGSOVy4L9yVvuSSS1L7XDxwJEy5bnAkcDAYCycG4YHQ47j6BF/kW0qKFKlchBNOSDM3kbY4dcwDQYn4RXTwOzJHYLB9XhzDHXkpBCdf+/ng1GhLNOju90jd6k1Xxj699kuOFPi1tYgvfdZ3OHhPYMhPnOEIEit5yZgbl7QL28OsdjFfiC9HDBFBOhdMnDvSQ8wzB1IWY7wSOcwPUa91zLj0JCRPjelUMeM6tXTawg9RPfczj0XLpOkxZcqUNIf1UlHEMFINA3ElRhFpopu6OeJDTNXuax/nKnJu+3oCin3gTAiwnTYdjyjAQSFuFTfO+PiOk80j4LN7rBbz8rk+ArCGqxpIzlMiifj2nXMd/q6b1WufOCequK753fb14tycSUnTJnFSmzn2XTekhXJSVefRtuZRnEsp5I4jnLQVr939/tYX3ooL7/5WHNBvcCxbvjwJrvURKt8WBAoCBYG2EShiTNvYlF8KAgWBiESqSgHftgWZUjOm8adJs8WYa048OdXTcOcW4ePw4CAhUCDAyAGCiwgSFAgWSADSV0sM2xs9ckyUIMS4A0zQIbYQGdpaMhlHtAkvBJlMRAgX3CMIDhdLW4KMNvTVE4zUYuGCQD6RdCKI1AzjJXIQC2zf3oIkSR/hHiC8WO1P6NFHApZaJ/qpvzAlHDmOfQgL8COUINHEKXVwOIqIVUQY7dkPIecKQs4IMcbhjjOXEMcHDOyrjg1xAa7mCIFG9rQ5cODAmDhrSVz58A8bTsAQNzUnkLt+w0bFwkWLkwBSxQ+e5ljdF2TTuIwJQSQkmDeCkrHCsHYOxJjvspPGflXBxjg5ScSvWCX6IajIrViDOdcIcuwzEkuUyGl0nlzVZ9CwOG3bvU3BB0bXPfHzWHvONdGn74FJhKqNefNF0BQb5tFYzKkYMX7xLTaMT+zULgTJ/Nhq+9WelwQ6cWl/QqDfzYv4I7wQxwg52jA3xCDxC6+upMTV9mtX++z8dK0SY+LcnEl/NL/wNsdESNc+MV27iGPngNjkhHPNrC6ul+bKNuLcPLoeOJ7rkOuPGDJvji3ObetaIQ1t/74D4rzPPh7bWw+pLcFGu3OPOC0OHDAoiT/V87Q6jvK+IFAQKAi0hUARY9pCpnxfECgIJASKM6ZtIcbTl4oY0/gTpdlizJY166Nv375x8MEHx5IlS9ITaAgWUmfY3JEHhJ9DRUFIZM+dXaQY8SByuNPuzrs0Iq4EhBFB5JJAKBE6xNuKGCJ+hANEAelAYtpbEHZtECGQRW4UAgd3CjLprm+tIIOQI/n6xlHhWJwTxI5cqJRYYSxZPEFiECb71lsQfykE9pGOdPzxx6einPrk2oAccRh5r9YNMuTJJpwZMCVwIbpIE4GLIESEgKM+Em8QNSlR8FRThRMJQdd/aTh+My44S3WCIww4GxQHtZ0xIGnm7m8++MFUYLORaQm1ZIz7Y8FRp6dHZhtbJpHwEgMEAOTeakziw295sb3YIgTCrVassK1xI7iECqTUPuJC+4QG+xLJ7Iv4SoVCXJFS8WVb5FA8Or42CDzTDj4kRkyangST2nE16jN8tnzx2RgwrCU8HSsLHDmunQNZbEKs9a0ag8g8XMQ9Ucl+1cVnYp14I9CJ+SzIOOfsQ4ghqBIT4SOO4Sn2iQAwhhM8fXZe65f9y9I+AvB3veNgEnPOY5hXXWpaELPmwO8cUHmOcuvmhXijDfFgTn2nffNFTDZnroPi3JyZa9c112jf5WuQ7V2HzCORrf+AAam+07WP/rRpoiNhdvOnH41effrHBRdckK5DeWzltSBQECgIdAaBIsZ0BqWyTUFgF0agiDFFjOnp8G+2GHPx+mNixMiWmDt3bnjqi6fOeNIPco/kc8cQPhBBq3/8CQC+4+rwHUEB0Ub+kWWkEJkgUnBDcK8gJ8QExJyY4XfCCHcLVwri4W4xoQGRICYgrRwOSCISabUN0uN4BBGPgJZyRNxwftpWG4QWwoa+6aN+IfzIibvH3CfEDMdCPokIiCzxA5HPpNV8I0NEFoIAYgMD7XJcwMJ7IhXiatvsdIADkcArsSXvK61p7dq1ScixL0IMa+2ab6IBoqUthM6TeNwt97vUB4IGvPyGhHmMs+KdCrFy+xiXO+ee3rL7HnvFlQ/9YLuentSRKCG1Z+ON90avvv0Trgi9MegjoUxal9gwJ/XulmeySXRCOOu5P5BScQMDYya+iQ/YiEUxlgUMx/BZe34nwJiT2oVwNWrshFhw1BlNI6gZuyu++oOYMm9F9OnTJ41Pf8Sy8wLBtko1q8Zdtb/IPmyM37kBs+pi7Ii5MSPz2oYD0u9cIfJow4KwO5bzV/0RWOoPjMvSeQTMAYyJn1kkJrYSVGoFxdwqoc25TCQ0j7WLeeSEc10wZ2JXTDjnxbnriGuixbXLNcX5pbaS6579q/NoX9fgD31k91j/8RsaWismx3b1VR2pQa3jY+GiRalPteMrnwsCBYGCQHsIFDGmPXTKbwWBgkAieyVNqW1BpjhjGn+SNFuMuen0sxKJRw64OLg9uDg8kSMLCQgbgiHVhIsDqXanHtEjsBBTuF2QZCIL4QMBJFQgCtohuli5bQg8xBCCz9FHH52EiU2bNqVtiQ1IMnEFGeF6cDdZH4gwjgkTtROIIWoksOAr0iolxfaIjLoJhAn9URskExV3p5EZ1n19QEqJKFZtE2SQHikctkNSESKkHmE2HuSG8IP0EGiMl+CDKDkOjDgRjNd+BCLberUNEUr/iDBeCSmKb3L6mIecloRIIXX6jLgZs33gqY9wso9HZC9cuDC14Y60Y3P5HDp3XgxunZAeP1slTM14f9XDP4y+g0fESSed9HZsiAF4IYwwrBUQas8WcSRmzBcxqnYhIhDSiAgEJ3MHd2KX+csklChBkIAPHMyPeIUnLG1nFR/9h7Wmwr3NwKTapifOLDt5S3zoQx9K/XYO6R98EHkkPfe/dtw+i0Nx79whKtYj+4QBYqd6L84D2zufjF/NJItjiEOiDVHAOSTmYC7eMz71+lC++x8ExCK8uLHydU78EiI7mkcx7BwlLtbbVixri/BGJCa0mNMszuiFc0nKqHkUR4RnceQ6rV/OH20TbF0jPrz7HrFFAe8XGlfAuxrf1feHLFsfEyZPTdft/0GsvCsIFAQKAh0jUMSYjjEqWxQEdmkEijOmbSGmpCk159Rothhzy5lnJ1eGf96lGbmzK93FI4eJBgSO7JDxzz5BoN6d+bZGr10kmEjh/EE6OU+QY0SGiOMY6rio34GkcKd4RboJJhwwuShl7StXzKpVq9IIBOi/AAAgAElEQVQTg7gORowYEZ4aov+IKOGEmKPgMDEHAZJixepPGNJeFmQQUek/HAjGjMRyLkgrQNxhQ2hBxKoLJwdxxzbaRJz03Ti1aUGmCTOEFO0gbdw2RIOcXuS4yLljG7M29B8ZQ6q05c43DJFoeHlk8oQJE2LGjBkxf/78JEwR0tSoaRk1Og5auLrpd8MRsdte/H0MGDEmpk+fnsgfDIgxRId6hLOKX35vjOZdnHFr1FsICcQD4yM8OQZnU16Q1CzIwdv8mWN42lb8Ei20I3YGtoyLcz7xSNOdMdLEjr/sE/E3f/M36bj6ZH7FpPOjMwtBi4BiP+dgPVyNjfjl3FVHRLy5hmQhTBwSHaXMEW44iIiGzkHni1irJ/R0pn+7yjZwdy0Tp3Aj0hIA87neEQ7cec5757v5qrc4F8T55Zdfnq5lRJeq0GP+XdeIx+aXUGNOxbnri++0zZ2msO/ue+4V1z/5i6bHuWsB0XHoyFEJn3pjK98VBAoCBYG2EChiTFvIlO8LAgWBhEARY4oY09OnQk+JMcZFZCAQIGtIsX/ukQD/6CMG/vHPaUuIiO2QhnouhipOyAsyqH2r7bOwgPhJn3AnWNuIJrFECgrCbHWnFxFBut3hR/A5HpBIKT/ScazcMVOnTo1p06bFcccdlwipu9batC1hxzHySrQ48sgj035q5HCbuBtNEFFXhtvk0EMPTQKHfZEfApL+uStNFNEnwoE0JcRJTRAOI6KNcRo7AszNoG2OH5gZF6FFX7iLEG3kCclC7DhobGsfAg9STRQyboISHJA6T4OSXibNjMtIv/XVmPv2HxCzD98QN37zNz1CwoZPODhaWltTqhshQP+RfSkWnVnhS6SQdiXuuF9q9/Od2JTmtWjRojTHBL28HYLrMdYcU94TGLSZBRl4I8JqIG3YsCGGjJkS53/uyabjc9O3fhsbt90bH/jAB2LevHmxZcuW5HLikiAUcmJ1tNqW6wu5Jiz5XLuPtogx0g3nzJmT8BEzeTtYmRspbUQrwicRET6EBbEmzsS58y6LONXzubyP5BJ0zXDOuz52Jc6l7rm2inPpezl2q6/myVwvXbo0XYNcm8xj3sZ+4txcas+1OYvWeR6JydyKa9asib0+1qvHrgNrN2+NAUNHJMdaiZWCQEGgINAVBIoY0xW0yrYFgV0QgSLGFDGmp8O+J8WYPDYCCYGBQIL4IgLEF33hKCEiIGy5XgxXCPKWHymc2+nsK8LHmi9VAglHLLRXdQwQbwgy7tzn9A4CC1JCuCCM5MdnI9lSf7gnMrGUTqS2A6GDmMMhwZVAZOKQ4DIheCC5XDWEDcLKsmXLkvOGc4fdHxaEDiKP8esrYnX66acn0qMIsv0QJf1EhggqyLf9kSyOhOzuIAwQdtT4IEAZM0GMWEOYIVQRdogHxAXzoT0r0sWJ0traGuPHj0+CjGLBiDVsBgweEnNWn9hjJGzY+GnRu0+fGDduXHLsKFBsPnNNlM68wtL8wZMwULsP7KXRLV++PIkx0uq4cGwHG2KUR4MT2mAEhyzG5FdiFZGGoDN49KQ4767He0SMOe2Gu5MYM3z48FiwYEFK0yP8wagzq1iDidj0KHXj9l11X/iINSSeGENs5JKxnd8ICOLTNj5rL5P4jI85cF453zmxyvJOBAjK3HTEQHHovO5KnBNZ7GMOicjmRuxWY928OAdcTxzHeS2W7WveXK/Evke2O7aY5qjLc+jV9czqGrbnPvvGjd/8u6bHOWfMus1bY+CwkUWMeWfYlE8FgYJAJxAoYkwnQCqbFAR2ZQSKGFPEmJ6O/x0hxhgjgYQ4QAggvviHn/2d8OFJP8QPDg134aVOIBMInLvEHq/MHk9Y6OyddQ4SIgRhwh1dpMOdf6lTXCDu+KuX4vvsEPG0FylC+ThIkqKWHBZIJ0EEsUS8tUWQ4T5BMAlOjmd76SzIDPGAwIHUEGU4VohCxp1JDreH8RFUYAEXLoNcPNdnBAl54lrJ4gABQdvEHGlJiJT6KtmpQbgxPu1LQVIDArbGwg1CxOFkgK9tETNtDBo0KPr16xeDBw+O0aNHJwKu/o5jjGhpjcnzVvZImpLH2kr5mTJlShJDCB36AXsOKiKYeexoVZdIDRhzYKzV/fJvxAWxRgQ0L8gpkdB8wT6nIxHd4JjnTiyILfNHuDNnUqs23fFQ00nqtmd+HcdccntKU+JUQOLFBCKu3+Ke00m/rN7XW6W+iQNCI4HUuPN2zgfuCbFPLCT4GTvBR4wbNxcMIcB+8ISx2Led35zHRFjnN4HUOVWWdyLgWmWOXC+kCXK4uAYSis1FRzHud+464qo2nOPay/uZG+eAeXL+iGEOGNc+grXrgWsJ8cb12Squs6hGyLG/a5dzj5AsTWnroz9paiHvXDdm2ckfjxGjxqb4eydy5VNBoCBQEGgfgSLGtI9P+bUgsMsjkMSYlpa4f8yceHrsgnh63MLGrH9t6xuzVsadm7fEw0vWxzOTl8azExY3dH10zuq467Sz48vrjo1vTlvQ8PX+gw6NcxcuSQR1lw+WBgGwo8SY3H2OFO4MRI4ogTwSCZBHqTVqwSDM0nSQRCQZGbYtYki0IIIQdjojzEjtQUwILtwNSAdiiSQiLwSQfOx66VFZREIokUsEhUMCkSFiIKVSi/K+xBnkh8tAahNipWgml09OMzJG40d4jE3b+qioMHFF36QhEY44ivyGCBNLVq5cmQgXAsWJQ0BQuFh6A9eMtAMpDlloIcYgUtJHYJlXDhorcuZ4xubOujo5BxxwQHo8+YABA1LtnNmzZydBxFOyerqArz4h+IQPYkMWVYgIsEZkO1qQUlgTG8SYxX7EFfMIQ2IfpxT8xIfaMObNXNuO4EZMMEfIqbknepgj/TC3RIiBI0bFcZd9oulizNbHX4+lG85LBXzFBqJNrPJqPPpcdYK1hREcOKacH8YkTi3Gw/nlO+eoGIQdXMSsc1bsw4qwmUUW+MBMewRLYoL0pLK0j4AYIoxIh+Ngcf0gWsOdyNvRAn+Cl3PZ/BOHza241a5z3bXA/xyunVKROPFc/5wXrgOuW/ZxPOeca5FrpALgYkEfOe6cix/e/aOx+TOPBtE0iybNep22eF1MmjotxVNHOJTfCwIFgYJAFYEixlTRKO8LAgWBdyGQxJjW1vjs2efHwxdfGY9celU8cslV//Oa3+fv8+f8mr/Pr76vrPdfdnXcfs218bdXb42Hr7o2Hrn6r2t+7zW/91v1c+331d//ut2Xr742Pn35lfHJTZvjS0ed1PD1ljXHxGmHrU7/3L8LvPJFtxDY0WJM7jSSwBFDOEAg3AlG7pBBNVGQi1zvxPfIAUKBCCKIxAjkARm2XRY6cvv2RwL9TsBxDPVgkHuvSAaS7lgdLQgKIo5cIjD57rJ+IPPacscY8URcCEeIDFcFcmy/WuEA4SEoeDoT4mXlPiGauDOdCZhjSzGCgcduuyuN7HItOB7XS77DDVPH0VeYEBeIOTAlYBGdpFNJidAn4o0xwAbBgs2+++4b++yzT1q9t+6///7JKTNyZEvssfe+ccWD34vbvv2HppGw9Gjrm+6L/Q4cmEQicwhXGEkB4/4xBwQ7Y+yo0ClRguDlzj9iKlY4oAhTYoqjA3aEN3ghrZwdHCHm1jEs5sT5Q3wg3uSYc3y/6VPL6LEx94jTmu4Y8GjrSXOWRf/+/dP8ij+4cDyYS30xz+oJZaGkvTgn/hFdnCtiiGBK0OMS4ojIGCPjiLxjwcg+jiFOLfAlyMBUHFrgCl/zALOy1EdADJkHojGHC3GPiGhOCLgdic9EFo43YqFrG8wJNM5x7bhemKcc574TK65TrgVZqHRNFDvERv+jaMd+YsD8u2Z95KN7xNpzrwkOrWaJMNrVPgF46bJl6dpVH7nybUGgIFAQqI9AEWPq41K+LQgUBP6KgH90Ro8aFa/ecVf84Z4H4k/3PtTQ9RdfvC++dOtt8drDD8Wfnn4y/uHppxq6/uobX4/7tt0c9yw9Nh4fMr/h65eGz4lNhxZnTCNPmJ1FjDEm/+D7x1+fuDek5PhHn+WemFAlkQQJ4g2ygiAj1oggEYctn4CBYCPOiCR3jbv4fideIKcIB6Ltbr7vCRra7eyCXHJO6CcRRL/VXiG8cKZkhwoCy7VC/HCX2vGQVGPNpNUxkV5jRb48ivrUU09NfTYGY7ctAmtfYyAccGsQhAgoXrVNqEGYEF13xI0JMUPgEOUsxnhMLUcOIYa4JY0JDsQcjiGP9N5rr73iox/dI3bf/aPpdY899kyCzMSJE1P/PvihD6Wn+DSziC+hZ8HRm6L/oCFpvEggogh7IoD+Gr+xEwzEBSJbxbZ2ThFR4guhDB5iwTxJBbFvXhyLG4Fgp2itQrU5RsyffsDUyhFF5OJCgauYnD5jRgwdNzWue/yNppFU+CgSPHBYS4obc23eCU5i0SpGxQfXjD4aY3tk3jmT3RPi1nkm5pD7LMRkjOAjXtTSgWe1XbELG6Td+ZjrKolhooK+tjdP+Ri74ms+38UmIcZ8mEexzokk3sxzW4vzn3ApjYyrxry7nopLcV47j65fasXk604WyryaO3NInHRcoo5rFVHUdWPAwIExYfbSuObrrzU1zs/55CPRq0//JDLqR1kKAgWBgkBXEChiTFfQKtsWBHZBBLIY88e77on/9eBj8b8feryh6/9538PxlTs/EX986on4r++8FP/fd15u6Pp/feuZ+PpNt8WDBx8eL+02seHrV3ebFOdPm5/I1y4YHk0ZchJjVq2OZ265I/79K1+P/3jg0Yatb3323th2+qaUStLVziO5CGAWGZBs50e221fbI2IgHUQId3cVlczpR4gHEintxl1fThpEGbFAMrL4I42CmOPuL8GjswSRIIP0OgZRiAhEcJFCk58+pE/ZGaCfSBWCTCDKd5n1w2dkyZ1sAkMm0gQehJazB4nVT+PgxiAMEAi4ZBQVJkg4RhagOF/8Dj/CE7EFoUPQ1IXxSoSw+p5AYRt9kOay3377JSGGGLPHHnskIaalpSXVQ9E2l8zkuYfFlQ//KG5/+U8NJ2K3v/THJGQcOGRkzJ03L7mfzL35MUaY66s790ir8RsDom9uqgJeNWb8Rpwj5hiv+CDiZaElb0tYQETVUDGfjue4vretWDJn5iPHHYcI145tPfmqz8ChcfLWzzccm+xA8Ejhw8+6Knr37p3EkEzQ1Ssy7+YVeec6E1PiBz7ZQZbHWvsKHwKOc0gbxmOf2gU+fpc2p33HNT9WMUIIcA7YBt5Sy6xqldRrr7b9XfmzOHMtFNOuha41Oc5dR7gBXa+qAlgVLzEKf/GtDeeHVKTaOLcPsYb7y9O0XMMc1+La5Bpi/sVCNc69l9akhtU+vfaPzXc9Hre+8FZTYt0Tw+asPSn69BuQREHXzrIUBAoCBYGuIFDEmK6gVbYtCOyCCBQxpn0Bp4gxjT8piDFrVq6Ke7Zui1c/d3e89vl7GrY+e+snYstJJ6d0m+70HJnjWkAkkTiCAcEFkaglH7b1HeIgRQP5QA4VwFy1alUSR5DBTF4IMbbP+xEwuHHcgUZe3LGvPUZbY0DspUkh3p7Uw+avLf2QwoGgEj0QY3eUOQkIIYiN8SHPihUjW0QdLhr9I8AQUPSJYMB9k8k09wUxhpvHb1wsHmnMUaMfatkQpAhQ1uwgQaiQcqITYYcA5LqjT9JtpEUREqRTeSLOhAkTYu+994k999wzevXqlQr6qlNjTpBud9H32bdXbLzpvrjl+d81nIRx3Bxx3tb46F57p/nPKULmgtCi7wQDuMHDmJBU+CL7hIK25pFAJhWMowNRNY/iobogurCCp+OIKzgRxswRdxExiABTXTlEkFsCz7ARI2P0tLlNqachheucT30jho2ZnOaKuFEdg7jmXBBb+soRRDgyx9xQMMuuq+q4vRebyDZybuzaql0cS5wj+XCAuzjNoqnUO8erYkOIcfx87No2y+d3I+A8JdC6rsBUnJvTfL1yLtYTHsUop5haVVIaCSeE6NrFPHLZme8s0BJ+uGeIHm+++WY6Vu08ul44B2279957x+yVxydhNguFjXq97du/j0vu+3bsve/+sWLFyuQyrB1D+VwQKAgUBDpCoIgxHSFUfi8I7OIIFDGmiDE9fQoQYw5ftSo+cd318fjnPh9PfuELDVu/fOttcfaGDSntprvjQqSlVEiVUOuAsCDFiBjBEWOxDRLKeo+sIHq2czdeCg6iQIRAFv2GbBBcjN1+9rdK45GGYV8kQ0oFMtPeggAh9bbnJOFOQVgIKZnIIOVEGcclpji2OhrZlUFwITQRVRBmghKyz4afnTCK/yqcu2LFinT3mihgLAQTjxImKBBhOHI8zhZJU0NF3/SFqKBdxMrqM4IHG6KQvmTBBnmGleKhxJ2hQ4emIr7qkUyePDnVaUHwjA+GnrbUOmVWXHjPcw0VYxAwbe7Xd0BMmTo1xUBVaDAvxsKNpO/mWBoF5wpxDLHMLpDaedQOrOHn8czSLWrTNrTvmsw1BRNOAS4YwgMBwrGz+6RKUsVP/l0MXXDBBbHXx/aLo7bc2HDB6uqvvRrzjzwjBg8ZkpwntfiIa+QdcXfewIbQCB8xBx9jFw+1i7gxLrFl3NqqXYxf6pPYFQtSx8Qm0dT5CVPnoO8yRvBxnuXzt7bN8vndCMCeC8t8uZaYG3OpiDlsCc3wr8VU3KsXQyQm2Lqe1Io22taWuDaXzidCnWO5plrMI4HR3OV5JICqH2R/ArknnPU+sH9suPqu4GJplBCjnWsf/WlMmb8q9thzryQa1YvXd6NWvikIFAQKAu9EoIgx78SjfCoIFARqEChiTBFjakKi6R/9A7/u8MPj6c/eFf/6/Dfj/3nxubfXf3/xubBWv/O+9rvaz3mb333tkbhh83ndSlOqDhzBRAYQPwIDYok4uAMvPSUX/UUuCQvcCMQCQgshx0rcQNSlZ9gPebG9u80cFO78+t0xkB6/IeBV0afaJ+9tj1QiLfrELeLYhBDEBcFBfBAirguuBGSHewCpufDCCxOBIeCoL4P0E3WMQZvGSFCQgrRs2bLkfPHYYp9to99q0xAiOGscD5EiQiFoiJpx6wMM9YEDRtoTYq594pC+IucEoryvxzt7dDdxZ+7cuSE1acyYMUkM4iJB+rRJ4OEa6T9wcCpUe8VD32sICZOedOlXXonxMxfFXnvvne7o63/tog9cGFIvzBnizz1jW64h4zFGuLu+ZlGG64MIZpyKo3KP5PSefAyEj1ChXeKKfTlttGmuxJ5UHnPE7ZFJKuFCbOibeJJWMnzEiOjVZ0CcfefDcfNzjSGqNzz9Zqw68/IYMHREiiPzX28xV+LDODgjnA/GJlaMO59Lzhl9ttiHk8uYFEkWI8TK2gUuYp8IYx/Ya5PwiPjDyLmW8fGKxHNnIPHih1jg/HO+lqVtBMyb64trg3OYAOL8VrvFtco8OufFOWytcOYUU4dKqp1rZS3OREXnvzkj3DkPCLW5mLdUM9c51xluO3PonCfYZAehV9euQYMGx5DWCXHmrV8JYmojBBlCzMqNl8Te+/ZK1z7nYI7TttEqvxQECgIFgXcjUMSYd2NSvikIFAQqCBQxpogxlXDokbfEmCPWHB7Pf+Hz8b9e+XZDawj94+OPxa1btmy3GJOB8A84AoIAEjw2btyYrPfcDQifu7TcJIhBJt15X6/ICcKIVEq5IMwQNBBrogyRwWdpKcgO0kP08DkTGG0g+gQb5MN+nC6EFttwT6ivgKxoFwlGlohICA0RhOPkqKOOiunTp6dHRUsFcucaGUJ6kXnCDqKPSBELEGmf85NrtK8dOCC9iJoFseLGQJSIBPqGTBEpuIaMR58RLeILQg5PApXvCRdcMVKtzjvvvDjzzDMTIXd8jhtYcz1UyZDjues+ZERrLDxmU1z+4PYJMoSYi+59IQ5esi769h+YBKdM3qvzmd/rC1JqzMYgDogNSKV4yC4Q82us0mN8BwupGUQHOCKgVXeM7cyHOTPnjiOuCAfELqkf3EnmyzFzmg4Bz7Wcq8BvSDLRDFEdNm5qbLrtgdjegsfqxKw999oY3DI2Fi9ZkmK5OicZG6++F5tiWh+lWTkPCCH66XtYiDXik7Gq1yQ1CTZiCK7Ol+riPFNbxHlA5LPAhxMMYc/pcsQreDsfCJGO7xhij1Dl2FlcqLZf3r8TAfNIcIMZAUwsE1rNo1g1V+YJ3s5537lemHPz6nuiDbdcjhX7a9N5T6hzbfSbc8d8uw4Qf8W744oLYprjOIZ9XdtcW8wtwWdES2u0Tp0dZ9z65e1Ozbv66z+Ow8+6MgYMa4kFCxYkd1z1HH0nQuVTQaAgUBBoH4EixrSPT/m1ILDLI1DEmF1XjEFo69VCafZJ8V4QYxAGZJvgQZBw590//gQJd3ythBMCSSbNncEN4UDytYusIBsIKaLjlQBB8EC4iSPIOgLJZYHgEE+yeIOMcwEgnQg48q2oJcLujnImu0QjhEU9m5NOOimlNq3+/9m782C9ivPe9zg4jsEGBJpnaWvYmgckoRnNAoGEJIwIo5iMmMxgMGBGm3mw8QSeh8TG2BiCg8EGA47jxMeO7SSOE18njp1KVU5y7rl/3qpzb6VOnVv13Po0PJzF63dP0t4bwe5VtbTevd61enU//XTr/X376V7bt5epRqJlpKMfIHJAD0IeEDBiDbiAPc57u48oGSJJZEEKFDBGVAYgBOJY00WECzBDMLEfOCQKwtSvjIaRP9CByDL67ZXIIiLcB/aAGtayIZpFlbRuhJnpPlNnzomVJ59V3u6zPwt53vmtv4uLH/hyLFq/I6ZMm1nsR9zzgZ42eWQrU2YAEWDAfUAEKAYasL96A1/UHTsDc/yJcOU/NrBCedmDb6R4db06ttCpV3/zQdOdtF3Ay7NFiRC2RKs69Tx2Zt/pM2bEtPlL47T33hOmGAFPfY0eeN8XX4jNZ18RE6bNjs1btpZoCfntbmMHvp75yikt4CL7qGPTvOSZ74uI0c70S9oHIQ/gATC5gVLaiqlu2Xdpp8S5tXj4Az8i6j2bb7sejAEO+Jy2xd/4azuAms+qx5ctoB61d3XDnxKC8U9RSWyvroA0gIVtRcOoH5Fi7M9P1ZNNn8L2+hFtBtjxDNEnQKXoPeBYOtqh/sd5EE47EF2mjwLf7OpYW5q/cHFMX7Qizrjhwbj9iZ/02cf1HaYogruTZ86JjRs3ln6v+khtCdUC1QIHYoEKYw7EevXeaoEhYIEKY4YmjCGIjFgSvoQKMe0H8WBsBzOMITCJAqJPVInIBmKCACAgwARCkdAltIk7AsEiuUBLCuje2BHEIBgJEml4FqFIjBDdwAoAIjLkoosuKtOKiA715loCljiyywvh6nswBhQhgoEQQISAJ5aIfXAHFBCFYqFU5TPiDSwBB4SVciqPLaMWpEnwgkLgD8ELsgBCoJIoBP4ECl1yySXlOukqI5u63n0glrwCTPItz0bDQSggwoLHBJoN8CHe8u9y8pV/+LA02Wbm7Hkxa+na2HPdfXHdF56Pe779f4SFZruDDnc9/XdxzaefiZ2X3RozFq2IWXPmFdsbxe/tJg/qT30om8iA9AHtiXAlHIEwo/18CohQJtEfvuM7yglCgBPsD8Aos7y4Th2lv7lHtIBIHL7ID9SJOs5pS2wM5BHEvl++fHlM6ZwXa3efX6IHQJnup3T8tqzBccMffy/OvfXhOHbjzhKFtHPnrgJ+pNubLaNWtBPlyrK6V/n87bw1YoBCZdUXATCmgSkH6GZTXvZha+Xmn+wN1vFb5eQ/fNA5Ih70cr10CPe0D5/LtUl6U46hfg1b67e1cVBGm+b7Nn2mfgAAVI/avv9T+AgAox8CDPlyQhd9mHr3fUYsiTJLP/e9vhBokb66Uo/qtlmPoDMg5HeMul++YmVMnjk3Np15Wex78NGy7kv3fv4vxc+v/9KLceb7H4oFa0+MaZ1zylvM9PdZxqFe/7X81QLVAvtvgQpj9t929c5qgSFhgQpjhiaM8aOY0B89enQsWbKkCDmimmgeaChzsMEY5SX+CDujvEZgiUeCADAgBIjj5ggpgUDsEhCEHrEBPLgOZMmNMJc+4UmcEOKEjHZHKEqDkBEJYdqO6AmL8p5wwgkxf/786OjoiM7OzrJ+i6gR4oPoJFqJBXkDTuTds+2iBuSJeFEWEAaQIWCzbuVffYsiAAr4AohjPRMRHYSvzXXqi9BhE2X0fAvEuj7Xj3FOlId7PcdnEQ+EG1FNkBHM8gRImIbFZsSVSA6j5IQeW/RFALGv5wERS5YujQlTpsXC47fFnuvuj0sf+loZ6b7xK9+Pmx/7i/LGlRv++M/KuUs+/FjsvuL2mL3s+BINs2bNmpLfdhE4WZddHdUtyMVf1Is6zi1FIpBlpJ/YVD/AC3FKwIoiUG+ij9gY6OMjbO1vO1iXPqNO2ZKt3GfNDuk0Raq8gBE2/uh+USMzOmdFx5xFcfypF8V5H/x0vOcTTxZ4xS7sBL6IDmC7M278cBy39dQYN3lazJ03r/ilaBbl7cvG5wAVfggC6mPUsZ2Q5hsiqQA5PiOKgj+LzOJXwB14BXpJw/fsJ+oCAHNOOwV2gByf+ZK2rD6VXcRZghhH9aDd1K33FgBNtFsw0Doy/laH6lc/xuesQ6UP0//wZ/UBmPpO9Ba/lgZ4qK9QP/o+9azOwGN+7j59hX4H0FS3Ipv4edYjf3dfRk5pdyJoRP2ZtjRl9qLYcs574rw7PlOi5kDa/+3nL/cDl37k6/GH1z9YYOPk6bPKot3KoG3VrVqgWqBaoD8sUGFMf1ixplEt8Ca2gB8+nTNnxm8+/tn4H19+Iv7frzzZr/u/feGr8Ucf+nD85pt/Ev/P917o1/VB/vN7L8a/P/t0fP3u++PLS3fEC4d0D1b25/v+eLW1UW8/XP1YJJAcm3tfz7k+789dM9sAACAASURBVMljX9MzT99CqUceeWQccsgh8ba3va28plbkA/HtR3MTPvRnEzgYYAwRYbSX/fzQBwgIBmJQpAnhYFpNd8ITCABYiA3imAgBPfyQJybY0BtIhPgTsaCEqUfEp6kt+Tyh/cQigQKGqBdRAo4gicV2wRlrqbiOECJQLNQKmuR0oawjvkCQinqxLgwx3w4yKD+I4BnemuR13KJT2ML0G+koC0EEJEgTMCK0cjqSqBRAhTAGbmzEmX4FbDFlSR7AEmIKgMgIHPdJy5GoErGTUSVZlt4e1QNRZ02fmTNnxrhx44K46lyyOhatPzmWn3h62Res3Radi1fGhMkdMX7ChJg7d26ZGkUYNiFab5+b17EVSMAPwBS2VTdspozKbGoR+/ExUQFgAxv5Xt5BB3YAYcAswtPfIETTtvyVcAUU+Bk/ELkFaLGznX8leMs8AhwE7qZNm2Lq1KllAeSO2QsLkFpw/Illmtb8NVtj1pLVMXn67Bg7bnzMmDEjdu3a1XYR1ky3N0d5AaGU3ZGA1icS7KJUAClwhL1cox2xCXHte5Fq7OM77U3ki/LzbeKerdN3QE7Xsi1/Yx/ppG2Ieem3axO9KctQvoafA476OvUAkunnQDb9BMCbU5r4L3AIGKdvq28+CKDpw3yvTn2v/Ws3Nv/3+N53gK7+iP/yDxAm61I7SXDsPv26+ucb+rRJkya97OdzFsWc5etD+zcdcd7qLdF57KqYNK0zxo4bV/xcP5W+OZTruJa9WqBaoH8tUGFM/9qzplYt8KazQIUx3QOc/oAxRnGN4BpRtPuB2fq53bnWa/OePLqneV+eb70vr8ljXrd69eo47LDDCowBZOxvfetbY8qUKWVNFBEHfmz7gduf2+sJY4hCgMWIvBB4oky0SU69MYJPcORG4OXoL4EAfLjfTiALs1e/hKN0ABQQRBQLcZxRH8SL74EHgp3AIBABGuKb2CRofE98gjbS9RyCUlrAB3AigkB6hDoAYFSaIAET8npAybWmxvhMtLfWo7J4rugWa8FYk4S4lWfQBzDwLNOlTJXyTOCIGFOHYIJ8JjQAG/gLkeu8cshDAhvPIp6k4zkEmOeYfqOM/bEpk7SIMVO9vBbba7CHDx9edp9FgqkjwAJwa4VZ+5sPfSnQpn3xI5FLbAAcpE/xF77iGv6gbgjLFJjOyzs/4B9gYWu9EawgmbT5EbHLp4hhR/eKlulqk6a8eaZXlM+ZM6dEyI0YMaJArGOPPbZESxHMytEKdbpKt6fzgBkYJV3TrABK5eUH/EZb06aAKzbgG4Q7EMhWQKXyJcAj5IGphDDN5/NPaahjMAv45Kfu1ZbYhx3q1jcL8EUgHwzUFwAo2rr/W4AMvpn1aKqSOlTfvtevAGH8Xd2oD7toGGm2btIBdzxHW5A+H+czjqYx+T4BTvN+92proLo+7KSTTioRhiJBR44cGRMmTIhly5aVvk1e+Ei7dJpp1s/VAtUC1QL7Y4EKY/bHavWeaoEhZIEKYwYexhA+S5cujUMPPfSg2t/ylre8BsQkkHFeXv1oJcj7W7S8XjAGrDDaSjz4gU8cEAnEMoDg+6awS1EhugWYInpFPYAR7EJoSCPFNKEhxH3v3r1lSoioECLSaLBRf0CE6CRuiRo7AQBigBPSASZADlAl8+I6o/uEN2FK3BD9hGoCH+UQXWDtFiKd6CRUPJs4B24AKGnZpE2AeC4QRVx5vnSJE2UgykWOWEzTWh2uz/y7P+0jqsTziR4Cich3BF7YDXyw4LG3H4FUImSIK0KMEDeSnmXtj65XWsoJntmBKmUn+Ih957IO+vu5FhwFDIAt0UPs1io0PZ+/AYFsDhpt3ry5rFNhoWV1wdZZV+1sokz6Fc8wXYw/g1CmADkP8HW3KTcbyAsYlSDPcaDsIz/+v1FuviIKi68516wH5RYJwZdvv/32Eu20ZcuWEiHGrsS4iC5wp3lfs7zKwe/Y19pI2om1iPgB/9OWq/huWqz3n/kNUKz9muYompJN9VHNTT2CnVnfTT8H1gAyIFlddbXxRWnrPwBhbUN/YXoesKc/7w6mykOrn6t390jb7pqu/KirfNXz1QLVAtUCvbVAhTG9tVS9rlpgiFqgwpiBhzHgA0Gwbdu2/d5PPPHE/b633XOlJ4T793//938HyLz97W8vC34K828K+P5qIoMJY/zI9sOdMAM6CAgwww/5XLOAgAYNiDUAwzQd0z6ACsCF0AU4QAv3E5BG3IXMmzLkHmUSHs9ewvaJYQAErBH9QFw3AQsRIOwe2Mk8iQgAvgiFVnFAMBjptf6F/BAyBKVnijIAZkSgiHARbk+0iGogakUAuUc+iHXPlh9/AwfSBEdMg3K/NWvAGBBGmsQWO5gO0iqACR3lEKVgapURaPeDQMrCHka0iTbpWRvEM0XHuIft5WcgN7Zkv8EQXWCVspvac8YZZxS/aicW2Y0tgRN2mTx5clkXCJziP+3uadpIWfj1ZZddVqJbRFWxt3SJzYMVNMif9iLfopNETzjXujlnKlNeO3bs2Fi8eHFpezl9sLWNNNPwHWDAb3fu3FnarvbHbkAWKNfd/c206ufftYA2C5IArBYc13eybevmOlFhADg/93+OaXJArfO+76keABdrVHkWWJz1qK0BOT3d35qn+ne1QLVAtcBgWqDCmMG0dn1WtcAb0AIVxgw8jPGj0Ui4ET1h9Y7N/fU45wcu8XzEEUe8CmOGDRsW69atK9BCJAcx1O4H9oG6+UDDmHuvuqpEJogwAUzADiPsRuNBFZDEDmiAFuCKSBIj7o7OiXwxtYxoIBiBG8AG3BApAzIQE9a9UL8EAgFJGNiJYZEwQIn0ASCChB9oc6YneT4wYcqE8wRid/aWLiBjrYbMP0ACrABHphsBRkL4Pc8OuABL4BEbAGwigcAQAodN2EfZARujz0awiWVggA09jz1cA2iBPHyDHYAHeREZw24gl7SVC+ARzeOz+zwXqNm9e3eJVOhpVPtA/Wyw71c/6lxZTQ8DntS5Omvd+Io6ZzOw1GLNRCp4pz57gjGAAnuKGLjqqquK/UXGELeep3/x+WDb5E2b4numsPEPUKp10w7AJpBpz549ZYqJ6EJg0PQm5e9u0x75rQgtdSEyJu3qO1CyXb10l2b97mULqBvRXvoZtuWDgKu+sHVzLV/UF1mTat68eSUKTD8sKqYnP9ePgj6i7UTV6Uvdp63pL3uKrGnNT/27WqBaoFpgsC1QYcxgW7w+r1rgDWaBCmMGHsYcjC5BDBJDAIzpSCJl/LgmtHN9i4HK90DDmBvPO6+sC5LRHd4WBC4krABBCGawgdgTGQJqEHnWQCAeRHuADULviQyiIGFLb+1CiBCaIA4BCnoAFYShz2APW3gGcdHbjRAlLAESU6MAFelae0G+tWnCXJly2hGRbz0bwp/ot1YIcQMGiO4xsg0KglfEr4gY9xM8dukCL+COaU/y7wjQ5LolBC7fAa6An/POO6+INSBI+mxgGg6/kx+gCtQZqA0kA89MA1O3dnCJfYjAvti8N3lUj9bwAaZEV7E9EQoKJDzwTBDAOT4ISrA1aACEsQ14BQACfu3yqD6svyNtzxBRpe2CbmzPn53vaXohf/YM/skP2cdaNCJP1GO7Z/fGDl1dI4qBTwGHfF9UmDKY+tcER+pNO1Qe/g0aazNAHh8W7UL8t1sHybO1OzCZfUWMmdLEz+3qXzSSKVDaed36ZoH0X20ZvAUE9UNsKxowpxzldSISwVq+bTqdaZaOII579AHaDV9s3dSjuuMjnqd/0/+Y+qdNg9h8pB0EaqYlbWAvox/5uQXHReW5t7/9vPns+rlaoFqgWqDCmOoD1QLVAt1aoMKYoQlj/NA12mgqBWFtystACuOmEw40jLnmjDNixMiRJdpg+fLlZZpCjuBaw4UI8EpqIjAjXrQDP8z7W6T7oQ/kECqACWEp8sR6GQRl63oiTTt195m4IGYJVPDE2hgEaI40E0UiL4gZYsg0Ia98NTI9bdq08qYR69sYdXYf4Q64EDsZRUQwm+rBV6QrPXZzH8ClLMQykWRqjesIKyCB6AIaPBe0IYr5GfjFFkAYKCZCyD39sRFdIIJpWSKAjNgDQsCTNUfspqyYHmPNCqKOL/L7AxVkYAsookyEvnrlU4AA+4MAIIxpZWAJeAK6sKUjWMXeIj9EDTjHVuoGfMn8qQfRANJVV+rMs9ncPeCY+0V4gWutG9DhfhE72oJ24ZXXYKx1a0wz0ycQz9KQrnI0YUlrmr35W/4JaG3P9DTAR7rgnzyDQCJWMtpK/fEb9aSfYgf3WSNHvpXVvdJM0JX54KeuZXfQChAFmQEv56QLJDhXt75ZgC0BNRF4IK72JsJNewZlAA/9Hd8DS9QTeKa/0weoD9cBwfwLaNEHSYNv5sbPAWXXaKf6IX0Uf1R3ImTUp3y0g5baDJ/RFl13ySWXFD/3Vrr0c/2wKVbaIigE7h2on2f+67FaoFqgWiAtUGFMWqIeqwWqBdpawA/i+mrrroFMf7xNqa3hX+eTxBHx6Edwq5gZ6KwNNIy5+cIL4/j1G8oPbcJbhIw1ewgCERnEH1FI8InaINxMqfFDn5A3akoIGDnVPvzYJ9iJBZADdOjNRlCAJuCDZxEmjoS0z4ShZxIa0k3B3V3ariH0iQdlUBbChOAhWohagghkIoY8LxfX9VYk4luEEJtYYBg0scCmxX+JEuIXJPK3CAYj0oQVYeMcceR5BFWWSTmMkAN6AJHnGbFmS4KZ7a33IG3imeBhW9Eb4IXntRNU3dmh+R2bADr8mVAX+dMxY1aM7+iMjvnLYvZx62Luqi0xd9XmmHXcupgyd0mMmTw9OufMi5O3by9lMlq+vzBSPSuXeiVK1WduIpjSXmwkioidTeciQglFEUdAjTpLH+GP7gNcfvzjHxf7gBX8ERBzHYCj7CCitVX4AjhmJ1jVR278S1vn6+p94eIlMX7qjJjYuSA6l6yJeas2x7xVW2LO8g0xbeHymDB9bkye3hnLV6ws7QhAEvmkrH3d5FG++QtBLupFOnZwShmVRxQFu/A7diKk+TU/cS2IRLyzM1DF79wLOGpnYJw6ZDtpaCPgAWEOhhHuwA778Hvft4vI6Gv5hsr1IAs/57/6DP0Q+/EtYEtbVh8Aq35VX6H/ABnVGz/nq/xWO+WL+gt+7nrRYtLMaWT6GN8l4AF+1BmonX6uPptT8vTR+m7+AxjPmbcgxk2ZEZNmLSx+Pnflppi3euurfj52amdMnjYzVq1eU0Cfvoif97aPHyp1X8tZLVAtsP8WqDBm/21X76wWGBIWqDCmaxDzwiHz480KY15P5x5oGHPf1VcX8GKEPNc0IcREjzgSzAQtMeAzUUdIEIRAgp0IIByJDkDBK1KJxQxv94NdNAgIQAASfcRKikyig3j0HIKSSCE2iG7wiyAlUggWIhVEMfLb3cgs4UN0imogiDJcn6BVFpEo1ikR2SI6wjVEDjFLwIhMIfjlWTQLOGJajKlDF154YYkaMVJMkBBMRK8pUIQrmxBURDA4o6wprNgP4CHyTQdjN7CFjYgx+RFpATywh6lDBJej9OSTgCbECPe+bOwFfhBuq9esjWNGjYuJnfPj+FMvjPPv+Ey89zPPxq1f/1Hc+c2/jTue+pu45Ws/jGs+/Uyce9vDseKkM2L89LkxduLkOOHEbUX8Gx3vy5agQV2CY/yjWQYgAHRhFwskqwPgRNnVjbKLBiH++BN7SAc4kRbfAFnY0d/spB5yao/71Ck/4t8pUoldkQs29cT3RDJ1zOiM0ZOmxfzVW+O0994T7/n4k3HTo38edzz118VGH3jiJ3H9F1+ISx78Spz07utj+qIVcfToCTFz1uxXYVozgqEnW8kfn1fv8i2vzfu1BW3U1BXglI/INwEOACmXtmJT12AN+wBNQBcbSpePE+WmILkHOORPQIF2yEcTxKSNwErttm49W4DtRTOlz/rcBFlgKrDCx02747NgrMgtPqwfTUipn5OOetIO+IS+RlvQVtS3tPgwwKoN2fW/+uisvzyClXxKv6b+zzr77Bg3cXKMnjQ9Fh5/Upz+vvvjiuLnP4gP/snPXuPnF9/3R7F179UF2o4YNykWLj721fWs+E7dqgWqBaoFDtQCFcYcqAXr/dUCb3ILVBhTYcxgu/hgwBjCK7ccGfcDnwAgiIkzQIIYIA6IcACBECBcAQnCmJAg9kQauA/MATrACWmIACGUpUUgGoEXRULouY64NMIPTAAYBAyBSrCDOIQEESJd1xEv8uua3FwL8oBL4JFriVLinC09X7nAGBEo+TYlo9jyQ/gQR/InHRsY4tmmbAA41uIAVIAj0UPsRyCbtrJ169YCbIx+EygJG5TFaLWym44k7F8UjKgEokhe2QxAABeIa88DusAnQphdfC9/BLu6aJY9bdDu6PnAkAVsx02YFEa5d1xyS4EvD7z4m3jwpX/pfn/xtwU8bD77ihg5YWpMmzGzTBPqS5QO0CHf7C9CIwUcG6lvo/RAHJEKNoBm6h1IALlAlYQTymMah7QACX8TmMACXwLK7Eb92Z2d2IuveQZbZ905AlRszD8WLFwYx4waG8u27I7LHnos7v3Or7q3zUv/Emx459N/F3tveySmLVwRRx49PHbt3v3qWkLt6qR5jg2UDWwBAwFNZbf5jg/m1DcC3nQpedYW+a32BXK5Ljdti/9Yk0dagIuII/YxxYsv8D9t2TN8ry0T+3wv7UPIa7tAWN26twA7gsD8SL8n0i83PqiO9UPqhY/b+ST/1yb4M5CS9eioL+H/zrvf7xD9AD8xhUlfpq3oCz1ffVqPSX+srtVjwhhwWr8JAh+7ZGkMGzk2jtt6Wlz5iafiwRd/26Of6ydAmrPe/5GYtuC4GDlmXOzatbv0UdlfZnnrsVqgWqBaoK8WqDCmrxar11cLDDELVBhTYcxgu/xgw5gsnx/1hDYBQJz5QW9hUIKPCCasiQvXNbeEDiJQQASRDcSg+wg/I7iiEkSaWMPFGiXW4LBeCQFImBCkok2ICgKaaPcsI87yRIgAN4QGgd6MEnEtUQ+UECBEj/wDRJ7r+YQlkcS2RAlgI4LASLL7AKbWjQgCgLzOWl6BKM81it0sh7VW/vAP/7A8g+ghUORd3+F+zyeiCWWAx7O9xtYOEhDXbKocABFBl+Jc2QEHglo6AE6CBvl1X2t9ZDmANPDpqKOPiYXHb4v3fubbvRJerZDmgRd+E5d+6Ksxa+naOOaY4QWcEJI9bfJF6KsHQlEEiI1t+BL4oEzszwfYSH2Ymqa+2En5XZ8bOCDKAwD0nWfwPxEDIlus56J+QSyi1jNESIEabMsn+RGYxreBmxEjRsTIcZPijBs+XOBKa/l78/ed3/x5bDh9Xxx5zMg4/vjjS7m7qpcsi/rmU+o669V37hMRw1/5gvwS1HxFe7EmifYAUmpvzU2a4JdINkDLxg6iK/iCN/ZoH9qZOtSupcte/JN95Id9nBc1U7fuLaCfSD9PSOgO9ZgwUL+lvtSbfodvA2rO6av0nc1N/WsLrgV6bMAhP/e2NetgaSP6BkDG+YQuILQ+CsxRj9IHcCZPnlIi3UCV+7/76/3qC2569Aexfs++OGLYMXHccceVMjTbZ7MM9XO1QLVAtUBvLFBhTG+sVK+pFhjCFqgwpsKYwXb/1wvGKKcf1mCCH/6iKkQdEIREsxFcopqQI/qaG+HhXvDE/b4nAgk+aQnJl4bIEIuMEhrEN1hDrBOcRKBrCBUCnRg0BUrEiLUQCHZilMAgNkWyABkiT0zzIcZFRvhenkXuGGEmWORF3uyAiqgCayaYfkQgOd+6EafE0vXXX1/yLLqFgCdyjEDn+jlEEVgD2lgUNwVWwiP5J8rYhbDyvWk5bCGvhDgBxWbyATIQ1CI52IhgVwbAin3knXgGIUAG67m4p7kBHyJxRo0ZF8efekHc9NW/2G8BBkbc9/w/xbWf/XYs3bwrhg8fXmyiXrva+AK4ph7VofzyEfWQ0TBs6TvTM/iJ88rGhqI4gBTXNzc2BBnYhi+yFxvwFeeABkf1z3fVgfpSVwAQ4Wy6DqCj7pVlfMesuOzDj8Vdz/xDiXbpDXxpveblKJlfxCmX3hxjp0yPjRs3Fv9s5r35mX0IcPkFlvix+mQj5/kuXweWiHZ2AKL8zTZ2tiPam5v7+RIRz68JdREygJTpcNobMKAt87GEpdoW23oO+4iS8yxtrG5dW0A9miqkDtkzI5uc14/rp9SjqBlwVH3oV/mofkU95lSj5lPUBXCrroBi94meU6/6ANF82o++RF1lZKJIG/fyCyCNjwDFo0aNis4lq2PfA1/uVdRXq3/n38Ds7U/8NHZdfnscM2J0rFy5spSL79atWqBaoFpgfyxQYcz+WK3eUy0whCxQYUyFMYPt7q8njMmyEnWELgFrrQ6CgKAj4ggPn422Z3RC3tc8uh98ECVjmg2BTGCLHgEnRHiADNInVEAHAoTIJkZFLRCEwA2xAdKIdLGOiykbRvlNEVq3bl1ZlNa0IeJf5AxgJH3ikjBqbkQKEWzKRr61RISBMucmP6IEiCZ5AAi8aQjgMAqtXwAQABTPIVoJKxEzppSceuqpRQQBT6JjRGUQU+CKNEV/yAeQRGCxjWkHAJA8E3WEFchAcCkTaAEqpEgHmtwDYPCZ3JQXhBg/fkKs3nF2XP+llw4IxKQQu++5f4xrP/tszF+1uUSTEIH8o3VLQKLe5M36GQSiehZBwId8x6f4gettyi2qyjQOYI19WkWeOpIOAKau+ZJ6kh7b8EcwQjQAuJdTNdgY5HC/emPbzlmz4uiRY8r6L3c98/f7FSmQtsnjB/7kZ3HSRTfEhCnTi4/Ka7sNnFIG9Q4usQEBzf/lVZ2DeO5P8MkW/BR45GN8p9W3PUudZCSNNuo6At5Re9TORE5oTzktKW3pGepKGtoA0FW3ri2gvaov/WFGxfFBIEyfx//VgT4i/RxYEX2oj/AWIxCytR75KdgJlukzpJERTz7rN/mCfkzd6hft+kx9U/q59tbR0RFT5iyOC+/+Qtz97C8P2M8BmVsf/1GcfPGNccSRRxVfzOidri1Vv6kWqBaoFmhvgQpj2tulnq0WqBZ4xQIJY/76ww/Hf/38o/HvX/xq3/YvvHJ96/GVdH756S/FZx94MP72a4/Fvz/7dPy3b3+rX/dfPflE/PFd98YX1p8WTw9f1e/758ctj8tXbypiqDpN/1jgYIAxrSUhIPzgNkpPJIoMIYAJhVxQlHggKggBIpvY9j3BCa5YdFTERqvA9iz3EZ0iF1xDbIgEIAiN1LMJgQPKiCrxCta5c+eW11B7HTUoA66AEAQMsUm8yCuB737iHsDwPSBAqBiVVhaiRuQJQUxMgRxAinViwA/fE/0iWdyvLOCBTXmJLdAFJDKNwIg2sa387GQU29ozRLS8gUVsSvQqH0hlFN1zwB7n5INQs/6NNERzEO7Aj/yzhTya/iWygf3sImVmzpwZs5asLgvQgigJCw70eM+3fxmXf+TrMWLspFh7/PHFDk0h6bO6Yyv5A0b4gnw7p3xG65VP+dkuN2JV2dJO6ps/NK9xLburTxEv7EyMglXqwLX8hu0TxDiyPwDGt4hmQOOYkaPjXVffFf0FYtK2N37lz2Pt7vNjytSO4itZvjyyh/oGXLxZRxn5A7ilnglqUUXK07St+7U/YNAaRuwprdbNPewjfcAlQZ9rfccGooaa64r4rL00I2200wQIrc+of0eJ9hLVBtaydwIS7RvcAsSAyFYfBgP1Oxb0BpZNQVQnrRtf1nfpf/i4Ng+oqaOsR7BWO0hfd61+Tb3pW0xNGztxSpmCd8ef/rzf+oH7v/vP8f5HfxDHbtwZo0aPKZE/nle3aoFqgWqBvlqgwpi+WqxeXy0wxCwAxhA2X7rr3nj64U/Ftx75TDzzyGd+59junGu7u949j3/s4fjIvffGY598JJ750hfimS99sezPtjm2O9fT9d/47Kfj4bvvjofefXl8evc58Znd55Rj83Oec2x+bl7T/Ny85t7te+LCE7eXUcAh5hoDVlw/7HefsiO+88lH4n+89N34z++92G/7vz75RHibEqiwP5sf+UQisCG6ACAgsI0AgwjOGfXNUVwwwmg/kNMXYUcI+nEvmgHUIcwJD+LS4pWmBZnmQ/ATIM5dd911RbR4JkEkOoJQch/QQbgTPyIvlF8eiWKj2kaVQQ0QhiC2oCzoQ8gSS8pLzIIFRK70jYoTVvIJgHhGvhUIDDAdAXRgF9On9u7dWxb6lSa7gQOiFERJAAiiZwg46QNERBXoI6LGZ+krk/uMuosEsu6Mo/PSUTfscvSIUXH2TR/d7zVQEiy0O1q0dtuF74sjhx1T8mraV24iekQ2sbVFipVffvmHMgFeytoKGdwPPpnOQXi6XhrWTQFtmhuRyp8IUNEFWXZpAjUiBojhFKh5BNHAIZFaXuk757j1IZLFSH+7cu7vOetxXPLhx2LavCWxfPnyUi9ZXsJc+xBNwf9AGP5t2ol2BB46x69aNxErIIqy8Xt+wsbtrmVjvu917QBlRgVJkz/5ThtI2/jM7mBPRuK0Pn+g/1av+ght32ebo7+b55z3t2vTrgOdt2b68gQ8a9fqwBRK0BQo0dfY1bGoptY+z73aKIij39LXaNcgcbt6FJkEvuk73JORVupIX6SNNOtRP+b5+ibt0DS8lSedUcDJ/vpzV/dZ5NrbxiwIvHPXrtJXNe1UP1cLVAtUC/TGAhXG9MZK9ZpqgSFsgYyM+fZXHouffOeF+Onz33tlfyl++vxL8dPnWnbnyv7Kdb5/9e/fvef73/xWPPzQR+K7Tz0ZP3nphfjZn73Ur/v3n/1WfObBB+PTp58Tj6/e2u/7Iys3xiWbTyhTV4awm/Rr0Q9mGNMsKEFgrYsMoRd9ADoIvQdHCBWQop3IaKaTUsJZvAAAIABJREFUnwkXYl7kgoVFgRIilVghMIh5IhQ0IWKMLgMBhDlBRMD7Hlwh+glvERkAkXMghbzJZ6aZU0KIUmBj/fr1sWjRojL1SaSN6APTX8AY04SII2AEDAEBiC5RGSnCiGOgRtnlQfk9G4AhtMEFMMA1ni3PRLkRcGAGfGlCLtdZsNV30nOPfFnvxMLBGzZsKGvfmJKTaUycOLGABiPXXQmpAzlvVPzmx/6yvBp385atry4ia8Re+UxjE91BLIrqARkcwaZm5EXWuyNxLRpE+URRARLqWz2BBxmF5FpQwjkiVRQSUZxrdfA1de6cZ7KfuuEvIgvUp6iYkeMnxzm3fHxA7MO21tUArEaOGlWeKV/8W96UCwxRz3xcvgBEftYuGibtxP8AJfbRPtK2+osmlCD4wRc+ar0QvtcELNoFqAM8ZvvKSCvRXaCjNAZzU//KBzRpV6JMbPoC4FI+1Xlu6lG52KFZ9vx+oI7soi61SXmVN5/VhbrRlgEtPtrOhvyY/YEvkJI/8AWgRdtnh9zcr92bSmnaHiCd7SBhjHOe7f70c/lgH8B62PBRcdlDXzugdWK66ysAmZUnn1lelc2netvXZxnrsVqgWqBaoMKY6gPVAtUC3VqgwJjOzvjXH/51/M9//q/xv377H/26/59/88v48mc/H//687+O//nv/xb/33/7937d//uvfhlPfOwT8fhxm+NHh0zo9/2pQ6bENUtXFfHZrSHrl722QIExO3bEs488HP/3C8+V6BgRMv2x/8sTX497r7pqvyNjWgtBPBBvRDggAHiIPrn11luLyPQDnTgxUi8qoCmciA2iRYi+dua6BDBgBlEBZBhxlr6pOIQ+YUbYN3/4y4cpAaZ6uJfgJXbBE8KeaLJWi7QSqhA/gA4xY3FTa9CY+rRw4cLyymqi3cgzIJCCSTqEPqGbUTbAk4gdYAYcUg7iP6MOCF1COwWxMoNYQI205FWePUdeXGukXHnZIOGG82CPSJhNmzbF/PnzyxtNtm3bVuyeafzeoYfGnmvvizuf/sWAwQbRJKbiTJg8tQh7dUs4KgNbiHBhA/kXWdRVNEz6EwiR65wAX2zEjspOWJqupo7tbMdO/M06PYAW/+FPvhdJA85I07X8ggBW12zk9b6T5xxbgEl3QvNAvmOfqx75ZoyZOKVAPvnhi3yXH4qcIqCVD1zJ9UbSHq1H7UbbYFP9gzKyE79kc2ln21JuUwfVg3YIGrBfwgFAzDUikdwnHVADzAMaRV/kta35GKi/tWVTtn7v934vJkyYUCI7PMs50UXTpk0r0wDz+drooYceWoAMXxmsTRvml/oFfYC6Y38QEVxh0+423+tD1Ak7yzuYrZ2YvqedsL26BJn1DZ6lL9EOfG/zvYg8u/5XVJxIPH6uHsG9iZMmxdzlG+LWx388YP0AMHvpg4/GUSNGlymd2mHdqgWqBaoF+mKBCmP6Yq16bbXAELRAhTHdA5wKY/q/URBbO7dvj69+6EPxj994PP75ySde3X/9xDei7K+c+/WTT0TZnW+ee+Xv1nP/5XOfi5sv3leiSw4k58QAQah9GJ0lLghd0RtGsMEEgtPotWgVEQqmKxHHhKmdMBHeL2Iko1pcT7ASYUQ0UEOUgCwpYlOYt8s/Ucd+0vBc6cmbdRWAGHkmdowwAyeiNwiem2++ubwW2Si0kXnXi8CRL1BExIA0iWGj2kCN13MvWbIkNm/eXKI0lNF1ykOoWfDXGjLsQEQpCyEsD54vUoK4Ywd5ToChnJ4jcsGzHQlr8EHe5EMEz+zZs2Px4sUlOuacc84pYgiYedvbD4/3f/n7/T79pgknvD3ogjs/U6YoyJf8Kz/xb1oMAQkUEK5NaNauztRHRsUAMnm98/xJ/YkmUl+EJ7jDRqZhiErw2VQfdrWDQkAX4MDO0skN3Js1d36s2XXegAnUtJPIpAWrt8bYsWOLUCam+ZXILL5JgAN48tzdpq3xEb7MF7QHGzuZksXXlEt5nRMlJhqJLwJ4vme/hBbsA2aKPmm1T3f5GMjvtAN9hvWfRHsBqDbnvK7cGlHab27a1YIFC0oEVutUoLymv4+eA16xrags/YCpRqLATAtK2NrVc9mf3fmzPiLzrc6AHG1eX2oKFMiiz3OtftN5/gIwA46e5bz2pU34O/0cGNVvvPVtb4udl906IFMV08cd73n2lzGuozO2bNla2l1X5a/nqwWqBaoF2lmgwph2VqnnqgWqBV61QIUxFca86gyD9IGwPenEE+P9l78n7r3y2rivuV91bdyXu/PNz83rWr975bpb910ep+84pSz8ur/FIQYIAMKAQCS+CT9tJQWGtIkP4CSn9VjPgIAxigwquNc5Yh4QIbxdn8LC/USZawlYghLE6c1GuIMbQvW3b99ewAogQnwSK8S/yATPljYYY+0FEQLEcU4fIGTlH0RRbs8nkoAa4MG91omxGKfoGrYwjchrrr3lCTTxBqYESUQV0AQW5CK98iNfdgLZd+xJiEkf2GAri6xK+9hjj41JkybFlClTCowxVcdrco2ez5k7LyZMnxv9uVhnU3g1P9/06J/HqIkdBTipVwvvitoBjrKu2IxI7G5XftM7RBgQq81r2YS9wQvTwYAGn0UXELEAF3EMUIkuUT/qi62ANLZUd/wS1FDfY6fMiDNvfGjAYcztT/40Np9zZYn2kGdT+ERTqSeRPbmOS7O87T6zARDBriIf/J3XEe2EPMgDUokgYw9whj0yEoMPicRQH9KSH20OjCT+m+22N+1rqF3D3iAYoOaNaSIA+RLba7NZH90d3c/PtWWRLM22ob8CIn2nHkFGfaPIQj6tHxTtAvx4Hp8WSaN/0I+BcnxBmvo5/vD7f/D2uPLjT0Z/LuDdbP/Nz4s37Iz5i44t0VtDzTdqeasFqgUOzAIVxhyY/erd1QJvegtUGFNhzGA7ORizfcOm+NjSbfHtQxbHc4cs6nZ//pCFbb9vd/6xQxbFFfNWlB/6+1MuoASoIAwSoohuSYDSmiYBTDATfUaRrX0gekNUic9EISEBvLiWmLERnMCIaRwZ+ZAitPUZ7f42gi2KADQBWYhzgpSIJ/rlnWgFR4gafxOpnmGTF9OZfEcEi24xrYnwAVyknW9KyQVjXUdQgTKeByJ4ljffWKsGXHENoWR3TcIW18mb6SWEGFjEziInpGPUHPwBfawJM2LEiBg5cmT5vHTp0nKe2J82Y2YsXndy3PmtgZuilCLs/ud/HeM6ZpU8gE4iGNgYpCMIgQAis7vdNUb4+QabAgiuz3sdRVqpKwLYzidEIvjOLgpAnRCxAJe/AQ/1zs5sC1KIynrf+94X4zpmxyUPPjrgMMY0sTNv+FC85S1viZUrV8auXbtKvkAledEuCOjudtfwQ+WzJgiA07ze94Q9sOLNX3xAHZj64jvC3WftgK8DAqIy+CH78D8RFyJoQMhsf+3a1FA+x+batogcbyjSJ7Gr3wfpq+nnrX+nP2vX+hmgDBhrXuezNq+dA652/QV/di1/8XzQE2wErTPSKusRtBZJpG3oc9522OFx+xM/GdAIuewLtpx7ZUydMatAxqHsJ7Xs1QLVAn23QIUxfbdZvaNaYEhZoMKYCmMG2+ETxnz82BPj+UMWxAuHzO+3/euHzIv3zD6uCLG+lItIIwSBAdEiolusTWBqBJDS3IzOEiDKITrFmikEIvACZoiacJ4IJAadN2IMPhA9om6MOBslNtUF7OkLiNFmQRTChkAnXDzTa6UJYpEqoiZAFGuwED2eL0KjKUZFCxBJ7s1FNEXQgDbK53vXi9BQVm9z8nYfAMD0AREHrjOdRjmJJ2JY/ggmU2sIKzYl0OQJaGArcMLuM+HMRoScSB8Q5uijjy7H8ePHl+lKomPkcfS48bFq+9n9/rrmFF2txylzl8TwESPKG+cANq/all82be58prn7zt9ErTLt2bOngBLlbL3ONSJKVq1aFStWrChgy7lMnxglkME9IIydwJjc1Yc88ScgcGLngvIWmNay9Pffdz/7y7jwzs8VGDNu3Lgy/UYdpX2a5Wx+ls/c+QBhftJJJ5X65Q/Na31mM2vnsI3FpwlxNvAdG/E9Pp++CeyIumi1D2ilDfLnur3WAmCzdrxmzZqythQ/Uxfpg81j1o9z+VkdWHTbIuH6kOb1eZ30+Lmpj3a+ov7zWlOjLMisLkEZaWYdOiZw5u/g6OFHDBu0fmDHpbfEuMkdZariay1X/6oWqBaoFujeAhXGdG+f+m21wJC3QIUxFcYMdiM4mGCMCBFwxNQaI/MiFEQeADNC5RNeABOiIUSzWJQWWABDAJdclDajHgAXo/ZGe4k/MEK6oA0YQWQQFkLy3UMI9XaTpggT6YEo8mPKD1FEhHqG9IkZ4sc5I8ry3ropu/TkjyAGDEwHMsKtDLn57JzviCXCyHQSolYaRraNahPNptk4r0wiEQCbXEzVs4AjC3HyAbDLNAUQB/yS7x07dsQRRxwR73jHO8px2LBhJUqms7OzCMURo8fE6kGGMZ2zZhWRSWyKPBGlQbgCYT3tfOrSSy8t8IDftLseWJMu24IuFkwWRZPXWtg2gQ2/ARVaRao6BtEAm8GFMZ8tMIY4ln9Tufgmn9KO7OrYnn/nUSSLdXi8Zt0aRdpRftc8AokgmKgN/iEKS/vLa9iV/yg7cEXcN4U88a6tAqDaOphat9daQD8nMg4QAQ+1df2TPib9sKtjvjFLVBcIJjKp9VrtBZAV2QTY8BWf9V3udz0f0Y+pX32XOmtCNX0a2K2+QeeXYcw/DHgEGIi58/LbKox5rcvUv6oFqgV6aYEKY3ppqHpZtcBQtUCFMRXGDLbvHwwwBkQACoTOE74ghiO4YeqDaBhQQfuwLgehQDgSwoQggWi6CgEjGqTdFAgCRzqiR0SKEMyEJ8Ft7RFRMcLuwQz56W6TFqBCuBObplGBMtIgfglb0SqAhyNIZNFb037k21SP5gaWeMuMcliYGBAxvUT57CJq5BtIUU7peRZBSyQBEiJvQCewhh2AByIYuLEGBNBkGoKyu9a0B1N2rJ1DsBFiBJ/7REoYjbdY8OGHvyMOO+zwV3dg5phjjikLxY4cPSYWrR+caUr3PfdPMX76nDIKDy6IdgKcADURP3yDfdig3c6PrPWivtQzENB6Hd9hBxECYITPhKjP6tt6Gu4xlQlwIFb5EeggOkTdsqmpPqKcRBuMmzY79j34lQEXqaaKnXnjh8uaMWyi/YBG8mg6GujGPspt9zn/djTVjh8AS3xGO8hr8shv+aJr2DLtQ9izSaanLvix+tE+CXcgks1AKn7IT3tqZ802MtQ+i5wTpecNSmzHnuAqgJp+2Oq//gau1Yd+IfuE1utck36uzwFUtHcQV9253jPAa+loD/o4MEZ7kL5IOz6jrxEF+AeHvyM+8Cc/C4tt93fUV2t6W/deHVOmd5Z2OdT8opa3WqBa4MAsUGHMgdmv3l0t8Ka3gB9CRp3rq63bQ5n6NqX+bwKvN4wBTqyHYrQWeAADQAaCloD2gx+kIbhBirwGCCEMLcJKRPdmugOI4nnSI24ICyAjIQSxSJx4LbE8EYytI/f+9jwiiYAhUAhegMS9hL58e5ZNOZTJ1A6iFGhyXQolAtY9xI7vCCIChxgm7J0j9IlfYt/z7AQUQQQGGNW2xkuOnvvOfRdccEFZ8BeAIIqVFcSx+7u5y6NdOcAYgtt0FTDm7W8/rBzf+c53lilLM2bMKK+7XrT42JjUuWBQFvC95bEflgV8RVwQqWzMPuyirEb0Aadch6fZUtQZIMUOQJl7WzdgAOiTlrrVF4NpoA97sHVOkQPP+Kj01L08gFr5fHXvmWDY+I7OOOumjw64QCWETzjvmnjrW99a7AIeWTuJT2gzACafzjI0yy+/2hkf5APtQIkyAzp8R3oEPeAkIsbfQIHoNZuyg33sA8i4R/vm19KuW+8swI581VpObKhucg0X9dG6qUd9m+vUd9ZH8zr9pHajr+Pn+jKgV98KvPj/QB9pU1f6WBFg6hGEAYP5Sva37tdX/P4fHBZXf/JPAzRthSf9/feyLbtj3sLFBTI2y1Y/VwtUC1QL9GSBCmN6slD9vlpgiFugwpj2EOZHh7x8vsKY/m8grxeMIQoBByJXuDshILqEgCScRZQQAglgQAJigKjzulwCop2w7MpChA3wYfFQkQPEDQhiBFikAKhDwIAbBDlhKjpFJIl8Eh+eJzrAArumcpgGApS4hxgFXggYu3T9DaAY2VY206881wKndt+517oOpiIARPJgmoApCQkCjDx73a7pJyJ5iB+Ciwh2D9ADUoi+MbXBOeAFbAJkTDVIyCBKQnSC/IJOhBmB5W9Cj0Aj1EwnkZ4oGFOVTFEaNWpUADGmNaizc845Nw4/4qi46dEfDOjCnQ+8+Nt4971fiqNHjy/5Uh824IWvGOUHRfgHyMX26js3dQdygSoikFr9xrQ3IEVUk/oALZyThjoEW/iMiI68F4xgYyLVNDHX2xw9T6SX9KbNnB0bz7gkHnzxtwMqUr3aeuHx28raPsQyuCSv8glAaT/Kpr2zTzMqhfjO11IT/gkS036u9X+TCCE2JPizvJ7Ft4E9aXum+7UB9gGkpMkeNt+5RuSHc816yufV42stwEZAFojLp0Q96a9EsDQ39gSp9TH6z9ZNOhkVqO/RdmzO+6zd6/eyjah39avvAGQS5qnD9HPAUvt429sPi9OuvmvAF/O2NtKkzvmxYeOmslB2axnr39UC1QLVAt1ZoMKY7qxTv6sWqBYoP3hrZEzXQKbCmP5vJIMNY/yQJxqMshMXRs8JPFMkhMUDIIQCAUAAE3SiHogRInJ/NsKBgAcbiGdpej7RTIgQh0aaCUiCw3UpQAAN4AGwEDlBDFkjwVoLwIfIA9+ZUgUkWXtFGQhgEAYMMV0FbCJ03A+eSGPZsmXlddFAC7hjsVXPda3rCGjPt0iqKJUtW7aUNSR8D9YQuZ5JHLMRMGQHsYgoo+rAi+kqomVESwAYRswBKH+zOduzuXRNSZBv0Tdg0/z58wuEsXjvzJkzCxQCgYg31x/61rfG2Td9bEAX77z/u/8cm868LEaPm1DKob5y40+Evak1bAZEqT9lU6fqly1EJYE2gFxzIziBPSAH0CFy+UVu0uB7vuMHIgGk6Rp25k+iZJwH6kzXAfnALXk5bvmK6Jh/XNzxzZ8PGIx54IXfxNWfejomdMwsiwa3thOinZ8Q29oboElE50LVgFNGh/GL5sa+bAYQsgHfboIc3xP4YAwIYBqNczb+yfc8j23Uie/BVBBQ9Iy6q1vvLKBu+JV+wc7v+K7+jc1zSqT23ApqPIH9+bD2C1o269H3/Fb/A8jyD9/rE/Ut+qx8oxMwp03wKYCZ74waPToWrTspbvvGXw2on7/n40/GsJFjS98EoNatWqBaoFqgLxaoMKYv1qrXVgsMQQvUyJiuQYzomApj+r9RDBaMIRaIaIDAj3siLRdAFf0CVAAPdkKDgCNsc0S9teTSIxYIYztBIv0EK4QmwQw8AC9Gk0V7ADF+xBM2BDQhaiQYlCBGRIsQ2bkILiAhEgQwOfbYY6Ojo6MAlLPPPru83lcZCH0gxS7/YIYFNE855ZSyToxzohIIfsKFIN63b19IY+/eveWtJiAKEWUKjn6AyCKecm0U0TiiWgh8kEokg/Kl8GUDZSC0QAnCjE1EPQAx8iYt4IaIY3PiWt7lzz3gGGAhDRENFrIFgebMmVN2kTmiePiMtIGLYcOOjsXrT46bH/vLARFhQMMd3/zbGDtlZqxavaYAsVZfyL8BolwrhZ0zgordlCdH/PN6tgMu+JrvCct2cICdgQV1BILxHfcStCKa1CEb8i9RS3aQxhQekG3khClx0T1fHBD7mAJyx5/+PN519V0xfPjw0nZymkmW01F9ASKiWNS5dqD+lB9MJMIJ/dZNO/I9n+Mf7aa+aHNApWvYPdus55k+Z9Fk9gX6QD72cZRuO3u35qH+/b8toB75sf5AHyoqhd+zuXP6znZRMXxY/QHfQJi/Wzd9CJDpGm0CiPE8/afIOxF26lGfpw6tlQTIajcWdD7qmBEFCt7/3V8PiK/f+51fxfrTLo6jR4wqfVm7MrSWqf5dLVAtUC3QtECFMU1r1M/VAtUCv2OBCmMqjPkdpxjgE4MFY4g6gg2IsMYJkWq01Q96P+6JCEKAsCDuutsIBOIDsNBmRLMQIKJTQAqi0ki+6BSQgYgQyeIISoAlnpvCufWY38mXN8d4s5EIkcmTJ5fX+RIeYAvR4jkgDmFrGotpIUaQpeHZ8pfARISByALPJ9bBAhE70vA3sWqaEmBFaAAjAACYkhEZykpIE0XEPjtk+sSUKAXCWnrgjDwRVqDS9u3bCxySN3mXrrzLI0gDFkmXPdQN0EA0myblVdLeYOSZKaDZH1A64qhhse+BL8d9z/1jv4uwu575hzjtmrvKAqHqLqcodeUfQASRr3wACbHKhsrWChLYWPl9D+K0gxj5HD6pPuQBsHOt+gQf2AZca/oRO7EPqDd+4uSYv3rLgE3luvLhp2La/KVlCpl1XFojHrIMjtrOT3/60wLilJt9CGqw0L2tm/6BH4uc4oNdbfzQujnsw4c9xyZ9bc9bgayxxEZ8Sprtoje6Sr+ef60F2E4UHntrs/xQvwI8tkZ/6RcAZtfqC1q/b6asjfBzoFb6GR2jb+Ln3vRmiqV61D9aTFte+Plhhx0W6/dcHLc+/qN+7wdA2Zu+8oM48phRsWHDxtLfNvNdP1cLVAtUC/TGAhXG9MZK9ZpqgSFsgQpjKowZbPcfaBhz+cylZaqOH/dEfUKRG2+8sYhlIk+kBoBh/RhC15QT0EIUgh/7hLLIGREbRLYRYeKA2LYTGUb7icvmDkAAKSIXCEDPEoJPOIhC8VzC3bOt+yH0XtSMiBSgxHNBCcCBmDQNw3WENqhEjMiL9ES0GEk2DQNYct6IMhFP0Pico9nSJWzzO6DK9/KW5VEO0ISwbQpswgqQAFJcAzKYhuM8QAC+GAE3PerUU0+N6667ruSTjQAwIEya8goWsLcpJp4rsiHzrmzKK1/KxPauY6OEP6bwsN2YMWOic8nauPZzz/WrCDPCft3nn48R4ybH/AULSp10Bxq0HXmTL9CKbUzx4nOisZqwJcGVSCPr72S0S1ftT7qiSPgh2KXdeI7oGL4hCkoUCJHKR9kp691bu444ekR525HR/f5c0NS0kC3nXBkTJk4q/tCTfZSP34la4SfaCP9WLn7Y3HK9HH6gPXSXNvvwU+1VWwS5pKceQL3du3eX6Xrsw2/BP/ar2/5ZgL3BRPD65fWbzokzzzyzALFmxAgbA9Xat/5H39ZTPWrvuVYXyAys6d9MrbRm1Q033FD8XH+gf8i24e1ro8ZNjAvv/nz0t5/f/uRPY8W2M+Lthx1e+mX9V92qBaoFqgX6aoEKY/pqsXp9tcAQs0CFMRXGDLbLDzSMOWvEtJgwYWKZ4nPccceV6Azi1HQXgIQwAy7AGoBDRAcxSyQnADBqD6QQCPnKYaBGJA1wA+Ioh6gQ4sDRiDzhJw0ROUSIEWGC2g95I/lGgQl04oVo8VkbzOlAgISRYHk1WgxeELLuBVOsmUDgiCwAMhzdA6J4pnRFkbiO4BcNADIR/q2CSLrSF/LPPsT9NddcU6IYPK+5AQnSUH7PynIqq3wAVc4DEV7brTxEG3BAQAEzhLjP7C1v4A7bulca0pYfQiwBEFCVUTHyQ4SxGWA1dsLE2HD6vrKYb3/ABq/IvfHL348Fa0+Id7zznUVw9iWSQn3yCTDKQsTEKCCjTMojgomIBZ9Mh2utj6a987PysiN7sZ0ILBEJ7Lx169YyHUfUANtlXgEJ0VoLFi6KEeOnxNWffLrfhOpdz/x9nHrVnTF+6oyynhAR3duNDQAjU6vAJG0RpMvII/k3pYnPdjWtpfVZfMVaI+ANHwJk+JUospNPPrlAUe1DW+Y37Fm3/bcA++ljRARedtllBXZrv/qQbLv6Mz6uP9V+9TM9ba4RVace9SkiqbQV0G7btm2lPvXb1qNKgMefPHfa9OnRMW9pXPaRr/dbJJg3he1+zwfjyKOHlzyAhL1prz2Vs35fLVAtMPQsUGHM0KvzWuJqgT5ZoMKYCmP65DD9cPFAw5gzRk4r0zSsN2L9kTPOOKPABtN/QBjQxHQiIfFGy43iGoW1LoJRdaKZyMwFQI2+m8aTUCWBClFAmPih7o0igA4h6P4UDF2Zi/gAa0yzECHgXoudCvvP6UBEaqt4JChBGXn2TFEGojBAFPAGJBIpQAgRoGydIr01L8SMvANOpnPIA2FFSIniIaTAJHYQnWNqEyBglNqaNoQSKOK5nsN+RJoojhRU7jPFSaSQHaAgoExhILZcCy4RYuzb3IgfeWy1gWvUk8iHSdM6Y/PZV4Q3+xwIkDEl4X1ffKGMhI8aO77Yk509v7cb4CbySRnZD2gCCJTP+i/+ZhegoSf/aD4T5GEz/ksAA1tsZ5FmkUjqjb8286reXDNq1OjoXLImLELqrTAHYqM7v/WLOP19D8SUWQtizdq1JU99EajqUZtjExFEorLUP7jEb4AZ3xHc3U1radrGZ/bhP9YbAmG0IXZmL20fjBFl086PWtOqf/dsAX1QRskBveoPQOPf/Jy/62f1CX3xcwBY+xFNd8UVV5S+SFqmeuo79I/6q9zUJ1DLZ2Z0zo65KzfF5R95PA50/Zjbn/xJ7Ln23pgwbVaA+XyzL+XI/NVjtUC1QLUAC1QYU/2gWqBaoFsLVBhTYUy3DjIAXw40jHn31IVx1jl7i7gTjSHKhejLKBifCVWCgsgFZES3EN8EQa490VPRiRIRMWAGQQxWACzd3U8wew5oYuoQ8AGaiKAALUSNiMDpKbSfWHWPaBTi3IgyMELEiJogQEXwiGZpt8kHaEQQE1IiK0w9MiInKGoVAAAgAElEQVRNyJr+IoIhp9QQQnZ2sygvAENwGa32t36EOJKuCB1AybQwx4yaAYwIZeUDdaRnPQnQh6Du6yb6QzTP1M65sXb3BXHNp761X0JMtMelD30tlm55V0yeNqOsU2PqVRNu9CZv7smIKmBJxIZIFv4GFJiuRVx2VSftnsGXRMYQuiKmLGoqogtcAC/ABtEkrfACJAER+cakyVNi9rLj49zbHo7bn/jJfgGZm776F3HKpTfH5M75sXrt2pKf1vVw2uW/eU7kBP/h78CddgDO8AO+CzTxi75EIbCPdPgvEW+KIL/lg4AYm/FRbbVuB24B9tZetWl9AEit3wBl+Lk2rh70u2zeWwAGams/+lJ+cNZZZ5WoP2mD54CMfqYZJZel0feAybPmzo+5yzfEeR/4VFlguq/g0RvUrv+jl2LbRe8rwHHFihWljfUmsifzUo/VAtUC1QKtFqgwptUi9e9qgWqB11igwpgKY17jEIPwx0DDmPfMPq5ACoLUj3cRJiIpCDQjryAMUQxggCGmgBDRIk2IOkCC2AUr3CuyBCxIYeHonPTcB1gAH851FSngPOEiUoSIATxExHiec6b1ADHWgiEuu0pH9RilNVor/xn9AgRZJwOMIfyJJSPWIm9MifHshESOykbgA1TKDUiZUiRiBZwx1eb8888v021EG5gOJS1CTDnlgU3BHDYklDyHoAK4QCJTdawj43sj5mzlb2+6cQ6QAhHSrn11PTay/o4Inemdc2Luio1x9s0fK4KqN+tH3PWtX5Q1Z057790xa+mamDFrdhF91qzo68bP+BbbWdMmN9Ey7GztIosRgw3s1E5U5j2OysbO6gXA4C/q2lFdWHeH/YlQUSZAR+smDfYFZBYsWBjT5y2OE857b1z+sSfi9id+2uOUjvue+6e45Ws/jHff90exZud5MbFjZmzctKkI7Vb40/rsdn+DZ+lHWX720QZEPgBL7McPne/OL3wHBoloEwkGhhLt2mIuBCtaBugBDfsCwNrlvZ572QLqBeQCuEw5S1ABHutTwUJ+ru/RF4AsPdWjvkmb4efqnz/rH/Rh+kb/X/BhfU1r9FzWi/4MhFuwaHFMnb0oTr74xrjqkT+NDz71N73yc5F11p1ZfuLpMXXmnLJwsHW6ss/M59RjtUC1QLVAXy1QYUxfLVavrxYYYhaoMKbCmMF2+cGCMV2VC1ghzvyABzWIQVEqIlOIACO8RAF4IOrA90Sx67UXxxwJJvZ819WPdtEVBITIm3zTEkGda6oAL6ZlpNggqrsDMdIjwglPeQWBQABiFFQCOExhkmf5J37lEeQBmExncVQ+0S85bQvYEe5PzLKDkW15BAAAG88S5UF0ATEElt3INZgDCtx0002vrscjDRCCMJY3glleCDXwhC3UQXdCrav6a553v/KakjJv/vwYP7kjlmzaFefc+om46pFvFjDjFdjetnLr138UN331L8t0JG8DOv3a+2Leio0lGmbJkiWlDprTIJrP6elz1omR/RT+8sZX2J8d2ITd/a2eiNDW6Bv3sK+pYfwi69XUJunyIxBPOuqRHdUPKJHCuDWvIhTUxZYtW2LKtBkxY8Fxse3C95VooOu+8HyZ4nXL1/5LsRH4csMf/1lc8+lnCoRZf9q7Y0LHrJg2fUaJOgG/EqS0Pqe7v4ET5beL9LEpO//X9kRQAVXK6yhiRmRPuzJpa9oJm/BbPgsQOKd9AgHSAKz4rDRde6C+1l35hsJ36guM1Y4Bk4w2UkfaoLrQn/BPfaj+CLDmt639o7rQD6sv0IM/8w0gXLvwHPWqHvm2flh6AFtX9Qicq/u1a9fGpKkdMWPhijjl0lviso8+Htd+/rni5/oAfUHTzy+46/Ox+pRzY/KMOdE5a3aB0NpnV88ZCnVdy1gtUC3QfxaoMKb/bFlTqhZ4U1qgwpgKYwbbsV9vGNOuvH54G/UlAsAVMMNIL+FB7Bqltfts+o1QeovYivgAW0xvIk4IDKLF7m/ti1Akxt0LShDuRoxFF4A60iVIpdMdiJFHgiMBibTcRwARRwS859pcS5wSN8SRxVLBEtNBRKx4S4npTCJYCCcQAdgxfYQdMh/KQGiBP55DMBFE8p72EmkkksYaLtaSkZa8sAn7mLbg1dwid0xRAiMIZBEQ7NAfm7yIyPF2l4kTJ8aIESNi0vRZMWf5+li29dRYs3NvEVxAzeyla2P8pI4YOWpUTJs2rdQlsa7u9mcjRvkLQSkdG/uLbFFX7Mun1C/bEZiioAAv/pFwi81BC/YWJWDtGfULECWUSOHLL4lTkQPS4gvqu7uNqBXRADyNGTM2Ro2dEDMXLo9F63fEyu1nx9rd58fybX8YC1ZviamzF8aoMeNiwoQJRdwqB99Trr5ufBL05P98jF9Ihw+J6AIiAcVm2bUXkE97bPqIz86JLkvAxabp9/Jm6iAbyzMgw058ji/vT/77Wt436/X8GSDUDwCBbM6e2jo/BWz17eqIv/vbtWALCNz0cz4gAk098QuRdc3padqiNNyvnWTUGfioHrvaQB/1r2+eO3dujBo1KsZOmBwzF6142c93pJ/viQWrt8aUznkxYuSo4ucWCuZz/Lxu1QLVAtUC/WWBCmP6y5I1nWqBN6kFKoypMGawXftghDHtbEBoEAXEBjEJMli7YOfOnSUcH9wwog8sADfWP3Ed4UEwEujEhPVbMmxfetIlbAgMgtu9hGhPQpHIEeHgNb4EPjFKiHtOCk2Cnkgi2o1IE6rWFvEcr4hdsGBBzJkzp7yhBBwRMWNtkxRW7ezgnPwBK8pjOgCBC8wASQS+KByghbCSPxEJwITRcqBGRAzwY6RctIhRb2KNcErw09Wz+3KefYk8drG47cyZM2PYsGFx+OGHxzve8Y446qijSvlBGwLdVIoEHX15TvNaIhLwMnovmsOmrohQthDlQXza1LF6AejSd7z5CkwiAsEJNlW37K08rZvIFCP37A7CgA58kEDujS3Vt/u89coCpcAV2xx22GHxzne+s8CsTZs2FXDHR9vloTVP3f3NFkS3+hZJZXNOuRNENutAZES2HdFaonFcbwdXgCh+yIaubd3YgH3cy0ddx1ba5oGWpfVZQ+VvfqutqENgNuEXX+RL/M80xoyAcb26AVn0PdqaN125HjTUV6T/O69/ad2koU/lI/opfah09Bk9bfKnPelb9dlLly6NkSNHln5AX3DEEUfEpEmTSrSYqD5tLdtoT2nX76sFqgWqBfpigQpj+mKtem21wBC0QIUxFcYMttu/UWBM2oW4M0pLcBAGBCqgAHRYY8XIragIgk/kyb59+0okCPhhAVGCQMSJH/vScjTCDBgQ8CImCI/uNiLHgr0iXEzJMfJLaIouIWQzXUJFtA04QAQRPHb3Wa/FIrKADmGjLECRvIsqIdK7yofzgA8xbJHO7du3l8VzTXUCXYx6E7qmnZiGBb5Yc0YeCB35IqREQRBf7AnIiAARKdSfGyEmP4QfWwMkgAlIRiA65zv5ZbcD2VIwAgTs4G/QwBoYbEuMgi9Nu+Y1IlXYhN+AL+qDvdQPaJGCtzV/7gfzQDbPAAnZFfxpByda71dmPqM+2YL/+X8AQFR/0iaOlSPFdWsavf2bjUXv8EFtxfM8X9tR/2Bda0SP8qk/9uEf7nWt3QLQYADglpEW7fKifrVTbUxbAGYAIdCrbn23AH9Qf/pA/bdNPelrAFjAi980N9+rfxCM7dWd+uDjfF50E3/jY65tt/FRUTeeAQCrR/f1xi+l2fRzkVhNP+cLysWPtLWu8tAuX/VctUC1QLVAby1QYUxvLVWvqxYYohaoMKbCmMF2/TcSjCEGjPgSy8QA+OEHPDFAaPjej3pwxujtzTffXBaoNTVHBAnRQYS4n2AnPp2zyK7oluYimF3VA7FguhEIc/HFF5f1WSxmSZCKhhB5QZBLj9jxLKBGSH+umyFCwy7/xLc8E/ymjRC37iO0gIC8hmgmUFzrnAgMEQmggfQJI2UBX8AH6RLergFi7NJ1jp3YiA0JK/ki5Iy0g1lA0EBtyqAsWZ7+fI6oKUITVFMG4s+6LmyjrMRmO6iSQhFwuO2228rryb1Bhn90B2Iy78oCvIhIYm8+5plsvT/bQNmHQAf++GS+IYwf8CX24f+e3W7Tvqwvwy9NgRPpxJ+ATd91t7GvyAhT6MAcAAC40vdoT3XrmwXYnG+CY/o/9mVLPmdqj98RXdUjqCcijp+rR2tG6XP4b7u20cyZ52hjrgcc7eCx/PR1k9ZA+Xlf81KvrxaoFhg6FqgwZujUdS1ptcB+WcCPqBkzZsS+vefHNfsujWsuuaxf98svuCj2nHpq7Lvg/Ljmskvjva375ZfFe+15vvXv5vn8nMfLL4vL331RnLlrV5y+dHnsnTE3zpsxtxx9zt255vnWv5vX5ec87pkxN05asbIIgv0ycL3pdyzwRoAxRAIxJ9oAPAA7iGzCwo96mx/2xKbpFkQK0QhSgCOuFYlBTIoCMG2HABWZYl0VUSqiVQhSaVssF3AxFcBzwQvpE46gC3hj3ZUrr7yy5AcAcC9hAvJ4LkADckgDGCBipAmWuA64kV7mXxkJK9fKI+EKjkhPNIGyG/H2WVSCdEyjEcki2kT6okE8G+gRraNMrhVp417pEXGiYUAd9pB3+THS7pk+A0dgzhttA5TYi535BpCSvkAwdjWCrx7YnMhkO74DcoENRv4Bi6ynrmyi/tiTvU21sLOjenGezV/PDTDhcwQ0vxGtwm9EC/ElvtoVGEkQk9Py2Aj4kxbwpX31BGTYnh3Z2BQ50/K0QZE4fF79vBF9brDrVF8kkk9bBl3ZlZ+rQ22fHUHIdpt7RcGBhunf+lNwTNvnq13dm+l5nj5QfycST13yIfUPZlpjiW/VrVqgWqBa4GC0QIUxB2Ot1DxVCxxEFiAm/cAlBuxGuuwf/chH4mONv/O8c+W7V6579ZpuzpdRd+m5p5Fmfz3DqOtDH/pQfORDH4qPigx45Zifm3871+58XuOYn10n3U8+8kiZanEQVdsbOisHO4zxIx9wADf4LIHbXEQVJCHiRIu4hhgmSkTQEH+EQQppR2JDhIQRZMCCiLEmBiFvvQWwg9Bw3tFivAQ5GCJEXzTMihUrYseOHXHttdcWwQ5oEKqmYhA7CUgS4oAsxLh8uZbw7070+I5IJZ6lKwrHAr/nnXdeWVtE32C6kdFs5c9NuYAkU5f27NlTpieZekMsE96mKIATygZImbJDvGWZTbVRRjZUFkCjPzZ293xijYC07oj8s4lXS6u/Zjn6+sxMX7nANOIUROMrfAakYtP0g0yfsGSzjApS3+Ad/2IXtpQmgGDdEwCru3wCMsqnjwXqCFVwyHpGxHNXm3zxFdCG/8gvG3kmXwHpe4IdXaWd5/kTn5c3oltZUtSbcmfaSLuNj8gHv1EGUI9/260hkvaR556mZfEnPu3/CK9oF53BtqJkAAL1VrfuLaAta6/aqTalfgAxfYL2zY9aNz7Lh7K+3A++pZ9r9+pE1JSoGb9DWttKM019Kv8EcUz9VI8gr/Wo9MHy1NVmahw/l9emn/MLUE6brFu1QLVAtcBAWaDCmIGybE23WuBNYgE/mvyg9WNmIHZpD2T68jzQzyDc2v3gfJO4wKAX42CGMSCGUVgCW8QG8ci/tBNigS9Y/4RoJqTtxCKBz0daBYX7iIF8xa4pOSJmCF3XE6wADkEsHQLRtArC2pozy5cvj46Ojli2bFkJ7wdJ5MsCmOxI5DajdVSmMojWAWKIIOXpDsTIszTki1iRB9NeRLmIRsjIDcKaoCLOtDtCFoAiiggz4tlnMALQIX4IMqKHeAMJiDN5ZkPXsx8xJa++z5H3/XFKZTQVRp4AIUININq4cWOsWrUqVq9eHZs3b44zzjijvBFLOf/qr/6qCExQoy+b63P6mjwDLOpY3RCa6rx1c44tlNeUMjZSNwnv+Aq7yhPbuAa0sJZLVxEknsGHXC/aylQe6/mcdNJJBcy05oHoBVvUJSDhHtd6HTAbrVu3rixQ7W1hIAo/600USutz1IWIBb4AKvIvohtc0Qb4ReumTWgL2pb6UyZQpglttD/2JuJBGbYmtLvzb/eIpDBtTlSaBbi9OYd/s23durYAv0ugom9QF0CiARzHVj/nw/ofPpaQFVgGRTN6Rdvh5+CKdq+u9bPZL7bLjT4KyHH93r17y7S+k08+OSw07Zw2kJs8AH/6VOt1AeCg8oknnhhr1qwpfr5+/foyZeqKK64oUEg743v8tG7VAtUC1QL9aYEKY/rTmjWtaoFqgWqBaoEDtkCBMZu2xAObTo3Hp2+Kb3RsjCc6Npajz/m3c809z+ex+V3e//npx8e+JWvLD/C+ZpRoS4hBIAAPKSAIDMKNaBBpQlQSGaBCVz/gUxSIyBCiTxgAEUZi7dI00kwEWOtD2uAJkXjuuecWEOMtIIQEKCK8H/Qg+AkQ6QE4pshYe4NYsYu0EGkCNhDEXY38pnAigoheUziIZ/eJ3CFywQ1pEOWe6Xu2ARI8A6hxXv7ZSnQIkQayEMuENVBlZy9lACNEORBsnqk8YA34AMh0N+2hXZ0qh+da/8ZUnZWrVsW4SR0xrmNWdMxfFrOOWxdzV20ue+ey42PK3CUxetL0mDxtRqzfsKGMtrMhgdibzfOIUvkWZcEvgAZ+oU7YrLmxv/wRn2CV+0zbUffSat0IYD7BXuobeGBf/tkOGpmWJmLA68qJTPsJJ5xQgFOmDfypR/l912mnReeceTFqYkdMmr0oZi5ZE3NWbIo5KzfF7OUbYvqilTFhxrwYO3laLFi0uERmqX9+0h0Uymc5KptpKPwlo1q0Gb6lfpvlSMipjPLnOvfyv3a+6xz7WKOJLaWpT1Enrfb0N1AmXZFlGzZsKPZxtNi2Z9Stawuoc/YF79gcYOWT2iuw17Q3mMb3tUN9g/Yv2g0oadZ3Ps05/UL2JeANONkuSsZz9Bf6QSAt/dzRs7QvGzjkOn3Sjh2nRMeMWTF60rSYNOtlP+ff+oJZx62PaQuWx/jpc2LMxKmxeMnSAsD1V8rcLr+Z73qsFqgWqBboiwUqjOmLteq11QLVAtUC1QIDbgHC6eRt2+KD198Qn/rg3fHpD97zyt78nOeax56+vycevOGm2HvanrKQbm8LkmIQgEiIQRQQF0ALYQlwAAyEiKgZwhFM6WqTptFZo8kiDIhwYobglx5BKrKCqCFaXGMnNnLKjygHz3O9Z2WUiftEF8gPgFGm6T30UPksqsarXEXQEELEEZFKpCgLIUtoACdC9JWL2AJJ5MNaL+5pFcH+BpKMIEtbxMlpp51W1uFwjuD1jEyfAJdHYlzZgQjCVySDcoJO4EAKcGUwPQtUAHuUtTUP7WwtIoJd2WHJ0mVx1IjRRXideMG1ccmDX4mbHv1B3PPsL+OBF35T9rue+fu48Y+/F+++70ux8YxLCnQYPnpsrFl7fInEYBN1190GSIheET0E2CXkIABBseYGgoA1aQvRHnyrp7LJg3vVD+AAUvFPdcMvba7xGewTyWLkP2HDli1byrQc1xG3BPKuXbtjwuSpRZwu2/KuOPfWT8R1n/tO3PHU38T93/11PPjib+O+5/4xbnv8x3HlJ56Kd733npi7YmMcPXp8TJoyNa6++poCPbrze8/jX+pVvgElkWXKzRecT3iZ+Sek+RBfB2KAQeCpp025RMlk+wEm0z5Zh2xInFtzCaBK+xDx1pABA+rW3gLqUVSMetR++TngqH1qJwli2Fp/kmBF+wa/9HHpq+2f8PJZ/VNGlal/MBfAabYRfYvzl156aWzduvU1MEafIT/8jA/sOOWUGDF6bAGuK08+K877wKfius89Fx9s+Pk93/5V3Pr1H8V7Pv5knHrVHdG5ZE0cM2ZCzJozL2644YYSydNb8Nhd2ep31QLVAtUCFcZUH6gWqBaoFqgWOKgsAMbs3rkznvrSo/EfP/uH+O9/+6vX7P9Xy9+t33f1t/v+/sW/iA9c//Krn3tTaIKDGDDy6600RmmJeyKfIBQxQSCIAAEVhL4TBt1txAnBSiQL5wcKlNnfxGlGlPiOQCXUiW7fEzrWRPBqaCKouzUtiAUQhLgXaWEdBQDHVIwbb7yxgB3pi6wQ2UDkmnKifMSvfIE3nuPZ7UaklVN52IPQZSfAyO4+wks5lEmaInMIYEKKQGMvkIJgIsgJOmAAfPF8UINAB4TYWPmte2KUnEgn+NQRUdcUZ/LlPPhhbZvhI0fHxBnzYs+198WdT/8iHnzpX3q13/K1H8bJF98YYybPiAmTJpfRcc9NMd9az84DavKp/KATOKcswEAKVEd2YFcghZ0yGqY1zZ7+Vl/sIbpKJJGpTuyhTkz/cN5UDHYQNQA4mJplWo46UP8zOztj2IgxsfqUc+PqT/7py/ClFzYCZ0Ct2cvWxTuOHBZbtm4tUKg7oco+1s7hE+qfXwBXIGK2HfaRN/6gXfEnbU9UQms9d2cfPgASulca0tIepC0d9cP+ng9SNoGVdubaurW3gL4F6BLtxbczek17zY399Rvqlp21axF+6rmrNpT3No/SAW88S18B5oC3/Mx32hF/4ucXXXRRATIJ1kTD8SPP7pw1u8DDde+6MG740ku96gP0Ffd8+5dx/h2fiVlLj49hw0fG1q0nlDL3xReb5amfqwWqBaoF0gIVxqQl6rFaoFqgWqBa4KCwADBx6q5d8dzXnoz//PW/xf/67X/02/5vP/p53H/LB9qul9FaeD+0wQOimlgjlglJIEU4vlFgr6cmtEEZAq83AsN10vLmpH379pVpRwCD6UeAD8EBvhAbogTspkcR1UbriUR5IrR78zz5FdEifVDD1Cm7Z1ggmKCyPojoAK+VJditmyGagngVOSCKp6tN+vInekY6RsvZiUgCsnwHtPiOvQgp9vId0e1aI9/KDv5Yv0PEEKBBeBnNJorlXRmcczRlwL2m4YjyaV1nBFiyPsqRRx8Tx53wrnj/l78fD7z4m14LsAQ2omaufPipWHj8tjjqqKPKmjJd1bW6sgiwsoJKCfGUD3yxsQtAAJwoLxilPsCT/d0S7PBFfgKusQeByl7EssgZQC6n45xyyikl2mTYsGExbmpniRC465l/6Lt9XvxtuO/E86+NY0ZPCFPnTCPqatO++a9IJwCQDdip6WOivUAaAIVf8aGMmOkq3e7Oa8vSEF0D6vEdNrdeDXtpH3Zinu8T8tomP61bewuAKuqGb6tvsMMb0BI4ugvs4ufqUR8gOqY3fVa7J7oP2NFv8Wl9sjqTpn5KP6bN8RvReSKdRDhZ98W0znHjxsXUeUvigjs/Fw+88M/74ee/idu+8VdxwnnXxFHHjIj58+eXdqU9161aoFqgWmB/LVBhzP5art5XLVAtUC1QLTAgFhhwGHNrzzCGuJUP4lbUAlFmJNhIvkgC4AAsEJ4PKohE6Epk+LHuXm9XIv6sReE11BaKBRWkByYQFeACoW/ElzgXhWHtC9ElRKNRXgLIGiS9Ee/yRjS5l/iVD/cRp57heRmdYkHbyy+/vEzhIlgJKEKZ8PFM8ElEA1Air9ICQkTzsJHvCVz5T0HmyDaEdkbcEOLyw7amJYFKphCI8iHq8nnSBSo8W3QJMQ3ksBkbyp9n3nzzzQV+NEfkiXlRQKPHTSjTjUS4lKk2vYj2SAjTPN733D/FdV94PlbvOCeGDx9e7NSEB9kQ2EQe2QOUUk42y2ga97CfiCTfqRt5VR9d+U+m3d3RveoTwLPmDhvKA1sBfaKr2Ff0EhBoAejFixeXskyZtTCu+PgTcbfpWvsBq9JOd37rF/Guq++OSTPmlgV/CePWTflzLRd1L1qCiDbtJH1FOwHeiHuQBlTqrn21PqOrv6UBgrGPtNmfnwOE2rK2oi5MdwFKvaWMrer2WgvwNVGB6k49gcf8mZ9nxIs+AJhxXjv3WRvn5wey8RF9Mz/PaYvqEfy0A7l8iZ8DbqJk+DngOH/1lrjiY9+Ie7/zqz6DmPRxYPYDf/KzOO2998TIMeNjyZIlpQ880HIdiE3qvdUC1QJvbAtUGPPGrr+a+2qBaoFqgTedBV5vGANQGHFNoSgyBPwgOggLAAA8IezaRUgQfUQdMEHYGREGIAAc672cc845BSYI3SeQiRTRJSBJCnJRAKbYEPZghGkonk14EPM5naO7yidKjBITRKZpyFOO4hLFok2IdOWUNpFqigvxS8wonzyYAgCSKAfhLLpAPkAQU19EEBilNmItkqgJYzJ/ykWweK60c1oDu3i20XP3AzOgijVjCGZll39wwbPZnQAEY6wPYcqVt6aYYpLCmWATATJu/IRY966L4savfD/u/27fR8JTgOWxAJnPPx/HbtheIIY8G6nPTZ2JmALO5JGNXGNqDQEpSgBcUF7lU1b2kN/+2viQ+iOMRXnkLi8gRwI4kTNjxo6N4WMnxaUPfa2AmCzngRytu7Hz8tti0vRZJQKndRqdtqQe+Zy6dwT2EliKgnJOpAM/1xbTZ/vDRtKSJqHOZ9M+wJ71fdShtggc8rUaGfO7VudjQBuf0idoo/oX/QX78XOAGQwEUfUh+qv+9HN9if4NkAFhsh75Dj/3LMBI/kTEWKh73wNfLtONDsS/3QvI3P7ET2LXFbfHEUcNi7POOqusSfO7lqpnqgWqBaoFerZAhTE926heUS1QLVAtUC0wiBZ4vWCMH/DEIyFLKBLUBD5I4W8L4op2sHZBimiQgTgBOohKQMHobIILwpPwlgYRftNNN5VReNADtGi3EYsAiKgQ94ueIHYAiZwClNCm3f3OAR4Et3yLMMmFZwkYYEl+RAMok+usqeC71hFef8unPBH5ykjIitABYUTS+CxvnqWs1o6QZi5e6z7Qopk20SaKxHNNn3GfKTWOwA+IJYpI+cEN0R12YAbg8GyvrV24cGF5rbcFgwl4eSXip0+fHnOXr4V26t8AACAASURBVI+rHun9+ie9EWlG1S3qOWby9FixcmWBVwkLiFHikDAkROUVcGF7tuBPysOnAJomfOuqHvt6ng8DYoBhClRHtgP05JFYNgXt6BGj4/TrHug3EJP2u/mxv4z1e/bF5KkdRahnGdQNXwQ+RKSob3WlLWnzbOec9sPPQJGB2LRVUExETNpIBJFn80k21L48vzfQcyDyeLCmyTb6ArYSNacu+bX+TJ8DMGuH+jrRMNo+ON3fmzanr/YcdZf1KE/8XB5FOpmKN27ytDjnlo/HnU//3X5HxKRv5xGQ4efLTzw9ho8YWZ7Zm0Wl+9sONb1qgWqBN74FKox549dhLUG1QLVAtcCbygKDAWP8gG9uhDEBCHoY6SU2ABWi1mdTK4zq+4FPVIpmIWqtDwImEHeuBThAFBEnRtaBD4JchIp0jRR39RYRQodIFx0gHaPL1tQgcETVeIbpLin+m/lvfib+E2TIN3FOZIpGIYYBAXnMtVgIF8/ubvM9Yaq87EIEyY802UUEAYACpIAlbAH0OCqH8xlpIGKIkPJctiRirO8CZEnTgsjudZ+0UviJxDF9xBoQ69ati46OjjLqPXv27LI+BCFm2pTpJcNHjYm9tz8Sps6kgOqvozcunXLpzfHOo4aVOiXuCU7TqERbWBwZQFJvoo+yLpSHvfjQQG0iX3I9I5FF8pHQQSSDiC++2TlnbsxfvbUI1AOZmtTOpoTq5R99PGYsWFamcfBpPqsdiKpSj+Adn9DmiHZ1TsSzGV9tgrv+tpXIK34FmIEJKeYBKz5aAUzXFgdRATR1KDqNj4mS0Wfra9QjqGbqY39HwzRzpb3Jh35CHnK6GSijn7WOjXZnetKanXvDNMV2vnog5yxeffWnno5jxkyMbSedVMByM4/1c7VAtUC1QG8sUGFMb6xUr6kWqBaoFqgWGDQLDCaMMQIOCBBoAAhhRqD5QS/k3SirqAbTFryCGEjwN+EhigPYsBPazoloAVtEmRDG0gYwCAYCEHRoHSmWByKHWAVrCBpCVXi/EWf5AjVAle5EqnSAGJEF0hD9wpbEOQEOoBC8uU6LiAT39LTJL0EtQke0h3IrJyCV9zvKG7ACtIh4cY0oGoCraSt5YC9iCYAxrQBEYd+cFmVhYWUGYjwTjDL1CIjxJqBJkyYVoXX00UeXzytXrixROso+ZszYmL9qcxm5PhCx1dW9YIPXO3vD0rr1G4rwFBWgTBZXJlJ9bkY3ibayzgXoN5CbugLs+A04RJSKUuILptnZTe8aMW5yeTtMV2U80PPW1dhxyU0xctSoUvf8AmjzWmCLq/IBeeOX2oZoKj5jOtdAb9oIgEjMA4jqRt5ABG246dcDnZc3UvraON/S3/Eh8Eq96RdMp3Ser+krsl8YqPLpa/Qz/BwIBvT0a/xJfwMYm8J49MjRJZINODlQn253v0i5NbvOK2tT8R39eN2qBaoFqgX6YoEKY/pirXpttUC1QLVAtcCAW2CwYIxoD9NniDIRBN4mRChagwAAICz82DfK6zPBkXCA8CDeiAAQpXWKDzECxCgLsQksADqtYlweCFXAxjQfe0YHuJ6oB1HkozsQIx0RBcSRqAPgx3QYcEdZ5JdYAQRAot5sGQ0DQCmrSAJwCjRpBUpdpScNdiCAE7QATQlnlE3+ACd59h2IAY55rXVGKuX6HqZFWTTTiPcRRxwRYMzYsWPLm01MSfDK79879NA488YPD0hUTAoyQGb9/9/emQBZVZ1rmwzGCRAElVFGmWUUND8ODcqgKIM4xDl4kWhEGVREQEZF0DgkRo1iIgjCdUCMQxBMrteLQxQNf0z8RVGj3lwzlkkqVambqpt8fz0rd1PHTnfT3Zxz+nT3s6t2nWnvtdd69uoD6z3v932Tp0bbDocn8Yt7Rgga10fMQ/SAF7/cI4rk5papjFU+3seBwv0tf394zTxDHBt29NHRue+QIL9LNp58P8IH10Dbw7umUBEEQYROcgzhXuBviXuO4Mk8xS3EXCnGBp/cEDGuyyIapxZhNQhChRYTijHOfF8DRjj1pk+fnhLj4rTCYcd3IqFKfIcVKrSs/Fi4Z1yL78TsXvHIPOc+8h1yWJs20f/YMakCUr7nd9Yeuai+ftuGaHFI25g9e3YSosr31dcSkIAEqiKgGFMVHT+TgAQkIIGiEyi4GDN/USxYsCAJKIgshL5Q0pnkuoR0IJwgOiBAEFaBuMHCmoUH4Ub8qs4vxFWJIyxccHwgNiCwIGCUP57XhLgQLoQYxMIdYYfFIMIKwgRCDguLqjYW4LTDApeFLm1xHn3m2ix2WWTWZGOxSpuEbSCWMA6cDPlaqGbtI9AghvGrMtxxJLHIgznXZEyINCzcCUVgwUNCToQYdkSZNm3apNwxiDH9+vWLffc/MK5b90JKtJktmvL9uHLrrrh42apocWi7oAoVAh7VsUgkjGOA/iMkwb38fa/JfajpsYSGIGThMmGxmis60BYse/Y5MsrOmFowISZjPXftv8eA48akZMfMoXPOOSfl+sHhBB8EOfqZLaZrOtbaHs/fJfMOZ1h5PrVts6Gfxz3CicJ9pDQ61bj4rsSxhsONeV7M+4igRiU7xGXuI39j2fWZ93x3fvFL+8akK5YUVJRlruOOad+9T4w88cQUhtjQ54Ljk4AE8ktAMSa/PG1NAhKQgAT2kkChxZjl8xbGJZdMS0LFpEmTYvTo0anC0YwZM5JIw2KaxTViACIBv+pn4gv/4d/TzgIPNw2CCL8aI8TwS27ueRxDaA4CD9ciTAJ3DcIKC2pEHxY6iEXZgjH3/Ow5ixBcJ4QlUcaVxKyEyXBdxBMElezY6j7SB9wwCCE4UljAs+ip7vm1PY7r4iAhzAsBigUVAhUiDPcE5wn364ADDoh9990v9ttvv2jatGla7Pfp0ydVVerVu0906jUwlmz6ScHFhvnrXohDO3aN/v37p9CpUaNGpfANBDwcBLkLxL38k6j26YTYsDgmfw73jfvIwjW7J7xP8uFz5t5WcD6EKo2+8Mr43Oc+F2VlZTFixIjkHGJOZW6Yag8sjwfCB8EP1xnCFW4K+LhVTgBG5Ibh74/E2YTj8f3Gd3UxQsvK94zvSEKRmEuInuQeQgDnPhIyyPfFPvvuH1feuTGogpYJhIV6HDpqcvQbMCgJ6+X76msJSEACVRFQjKmKjp9JQAISkEDRCRRSjPlg2/aYfenl0alr97SIZiF98sknp6SvhCixSMMRQ6JTBBUWayRh5Rd8Frbld97PPuMR1wwCDr/+U2UI1wvvEWbETlsk9UV8QVy45pprdlv8+cWesXN9ksDSF/LT0Ac+yx55zk47hB4RukNC24kTJyaXBiED9J/wGI5hHOV3BCZ2Ps/dCQ3ifEK2cKFkog55GQhDYCcJLTvtV7RzLO/zmLsjUOTuXCt3xyHDjhDDwo/QH8ZBBSnCr3D8jB07Ng488MDYb7/9d++IM1numDbt2sfA408p+K/hLOpWPLsz2nfrE82bN4+ePXsGFZ0Qj7jPOJsQRoq9k1Sa/DA4pHAuEDLFopW5Q59w8bTr1ju+dsu6gi9QSZ78lTm3RJMmTZKb6ZRTTknOJ+YOwiOOBhbVxd7JR8QiHj7MKRw6/H0oylT+VY/YgYOQ70scTgi1uPgQPriXxZ7n5KVByOYeZvcRNyPfr/QVYXrfAw6MRY++FvlOUF2RoDPmopnRuXvPJAxVTtFPJCABCfwzAcWYf2biOxKQgAQkUIcECinGfPTSGzHjX74WBx/cKgYPHpws9/zHHVEEASVL4IsQwi+/hM1UdycsCBHjrLPOSskjaZPFXu75/GJLtZ/JkyensBaOwa3Audn5Z5xxRpx77rnJ4UI/ss+yR0I8cL9ccMEFMXz48Bg0aFBy95DclvAr2svOw13DeTxme/nXvE+biEOEayHq8JiF39BWdm5VjxyX7RyXPd/TY1VtZu3gjqGCC+4TxBgEGHaeI4a0bt065Y5p0ap1fHncuUHFo4oWTfl+j9wrTZs1i4EDB6Z8KLBn3pALhR13FXtlz8t/lh2f+1jZuRVdg2vDCjEm23Fecc8J9SKUq2PPAXHFnRsLzueGp34WFy+9NzljOnbsmOYUfeLvAZGvrvbMaUVfMhccfBBlcKshyrh9lgBhXQjExxxzTMoZg5iFAyx3blY0l3M/L/+8/Otszue+X1mbhEvxt5bNce5j9rfHd9lJJ50UBzZvWZzvga27YsLlC6N95+7JjfZZcr6SgAQkUDUBxZiq+fipBCQgAQkUmUBhxZifxMJZ1wSCB8lMScBLRR8cGZlrI9fNUdHzitwgnMtiDjGGxS+OFd7DdYITAAcIjhcEDxY1JNQljIi2MpcKv9hnCYTpGy4UfrHncx5xyVAthPanTJmSHD2INjgfGAPXgl3mnMENUdGOUyfbOZ5zWRhT6QZBimvQd87NHD2Zq4fHzA2U+1jeMcRrfjnPdhZze9r5RTs7hvMYN+4YWPJLPC4PhK5WrVrFwQcfHIcccki0b98+uVImTJiQ+t+2Q8eiijFd+g2Jvn37pYUgYVXct7rcmUPkCcoWqTyySGVukv/nwgsvjI49+6cKM/kWpsq3hxgzZcl34vOf/3wKT2KeUu0KTnW5s9jHTZEx4u+J+c93AQ6PYiUSLvLX6l5djiTc/L3j6KP6VF3Oca6N+xABDREmu48I34TmMbcQlA9odlAse/LNgouOzPsJly2I9p27Kcbs1SzzZAk0TgKKMY3zvjtqCUhAAiVLoNBizE3zFiYHCTkGcndya1R359fzbCdnAqINv+JinUcMyZKD0n6WCJdFIGEsCAzY+7kW+WB4JDkmC2YW0og3WVJKPuN8hAkW2lwDMYdEsSxCCOOhEg35SbKd3CtV7Sw2+ZxrsMBCfKFdKgAhwGTX5rjye5Z7pDqP1Z1gMKDSD0lAEXEQrsgpwnhZXMGMxTKOBsbdtWvX6NSpUxJhjj766JTvh6pRsOjVp28MPP7kooQpUS6XMCXcOoRWcR/qeic/EWFKLFLhBT/6Rll0wkmyMKVpNz9Y8EXq0if+b5x99cr4whe+kPKzEFpS7HCWiq4HHwQq3B24hbZs2ZJCW5j3CjGV/9Xy/UJIWV3Pca7/ySefpO9anIw47xC6EdSZYwi6VO0iTGnhIz8uaCLvTIAcdf4V0eWIXoYpVT59/EQCEqiEgGJMJWB8WwISkIAE6oZAocWYFQsWpXCkfIwOsYQ8BSTQJdcKz7OElog1LIL5JRdLP4IBjpTc8q8s/hAi+LWZY8iVwqKQcxFhEHZIOEr7CCa4Q3DPYNNHAOIX65puXJO2cdrgOKFt8rIghhRyMYqAAy/GS9JhEvVmzhzcLyyo7rvvvrRAZpGMOEX/qLLE2BEXCM8aN25cDB06NCXNJcSM81ic4aY57vgT4vAeR8aSTW8UXGyY978JfC+66KI0lpreh0Icz0L1ueeeS24pxCnmH3MJ9ghwzJ/2XXuk0t/ZQrJQjwsffTVGXXBF7LPPPmmu0o9S2BBfmFfkc2LOIDC41S8CfO8hIiMg852JmM13Cxu5kXA+7bPvfskBVowEvkNOHB9HDhycEq/XL5L2VgISqGsCijF1fQe8vgQkIAEJfIZAfRFjcL3g5MDNgniAy4T3WPgiuLDQY7FAjgxcHggQ/LqcbRzHQhCnDEIDoguOGYQSRB1COmibnXb4RZ8cKlyLsKVM9Mnaq84j/cM9gZWfdgkdwXVTm7aquh4Lf65FdSQqUfGLNWFICEiIU5nwQh9wvSC4ZCEGhIsgFOHooJoUIld2DAxgQb6c6dOnJ8GG8cAS4YEwnP0PbB5zH3y+oL+IkxT04htWRcvD2iWHBfesFDYWqSTxZXFakbAGY0pbnzD54oInNqW0df/jxsZhhx2WxDLuUSls/J1SHaw2QmYp9N8+RHIU8h2ZVbnLZcJ3L9+dX9pv/5g0fVHg0CqU4Ei7hEJ1PKJfnDRqVHI15vbF5xKQgAT2REAxZk+E/FwCEpCABIpKoD6IMfwKi7hA7hccLSzw+OUfEQLnB6E2fIajg9wwiB3lF6OIFYwVgQUxgkU0ThgqB+F84dxHH300uWl4n/dwsZC3JfsVuLo3hoU5wg/CC9eiz4g/uGH2ZmNMjJn+sAhCfCE0BIGEnDeU6EY8QUBClCLPA+PgNcIKv2rDDvGA8z799NMkcLGYQoAhIS2hXzDkGMQsjuFcnDMwy0QHXCEw/8IXvxjnXntrQZN3Ukmp7Mxp0aZ9x+RqyhXZ9oZnoc9F4Dr+hBOCxMOFdA+t3PJuXHnXppTU9LTTTkt/E4Uem+1LAAJ8HyCEt2nbNvofOzoW/OtLBRNjmOfTb384WhzSNlWfQxB2k4AEJFATAooxNaHlsRKQgAQkUHACpS7GsPDmP/ss/BELEEd4D1ECizwhRwgsiAgcV9HGseQ2QJgg8SRhQhzPc9rEPYKggcCBEEOFEHLOUO2FHCvV3RBL6Bv5QnDD0D5ulNo6a1jo0Hf6gPiEwINIQvJghBccL4yJcBhycnA9RBUSf+IAglX2a3aukMN7JBJGKCKfB+NFcOHXbxiU33AZMaZcEYR+4VRq0aJF9B8+KuY99B8FWYSxAFu8cXu0bt85jjv++MSyfP9K9TXiG0mmW7frFF9d8p2C8MEtsPjxN2Li5QtTomXmNcKjmwSKRQCH4Ve+8pVo1uLguPLbm1IZ+kK4Y5Y/81Ycf/rF0bL1oUncLpVQvGJx9joSkMDeE1CM2XuGtiABCUhAAnkkUMpiDAICTg6cHThXyAGTOTN4n5wnCAm4ThALOL6ijTAJxBzKUZMDhkSUiBhUvEHQQWQgjAJ3CQkquRbiTK74UFG75d/DkYOYw/lUjUEoQvhAuKjJxjhwvxBulDleCHHC6UK75GhAfEHoIZcDThZ4wCBzDMGJPWPCAh3xhBAuxogIw/nkOqGPCD4Z2/J9pY2sndzPcNeQvLNZ8xYpjIjFUr4XYZTNnnDpgvjS/gckhxFjrC8bPMnP06lL1+gzrCxWbN6Zdz7w/vodj0TnXgOid+/eyclU0b2qL8zsZ/0jwPce4vD+++8f/+e082L++m15n+e44+Z877lo1qJ1jBkzNn3f1T9S9lgCEqhrAooxdX0HvL4EJCABCXyGQKmKMSwocXYguFDhB5EDgQJRARGF0B8EFspCV1aZhcUwAgSOkbPPPjuJMZxD+Ah5R1hEIJTgOKE6CG3iFslCdD4DqooXXAcXBKIQ4UFcg/7Srz0JMZxLuNGHH36YHC9UNlqzZk0SixBfEJvoF44H3CuIJwgvCCich5MFJhWJKTDE1YILhvNpD8dPFo7F+ZxLH2qzcU3mT4cOHaJ7/2Ex854n87oIIxkobR7cpkMMHTYsjXtPPGszjkKeg6hHvp2mLVrF5Jk3RL4FKxa+hHB17NQ5zZPa3stCMrDthk2A7xnCFsePHx+Htu0QFy78dt7LXF//8CsxeMT4OLBps/T9xXe2mwQkIIGaElCMqSkxj5eABCQggYISKEUxhv/cE3JEMlnEGHKvIGxQxYcQHASPhx56KFXVwdHC8bkbjhYWwZs2bUrlhc8777yYN29ebNu2LSXtzT0HQYKQHlwiuE84ryYLfsQQ+kdOFUKECE/C0YJwVL5fiBfkYEF44RwqzZDjhTFyfRw1PDJuxklyXdxA5EYgFIBzuR7ul/JtZ+NnMQ4rBBv6gqsIFxD9oz1cQrRD//Z2ow+0g0unfcdO8eVx58Y1DzyXF0FmxbPvxNXf3RJ9v3xiHNSiRSpjy7jq28a9IpEyYlKrtofHpbesixue+lleGC3Z9JOYcNmC6NitZ5ArBhHRTQJ1QYDvTETunj17RZe+g2PayjV5C1eiZPa4qddE85atkxOPea7oWBd32WtKoP4TUIyp//fQEUhAAhJoUARKUYzJhBjcHITpEEr05ptvJscIQgzuEZwouTkDEAYQWUj0Sxld3DQzZ84MyjEjctAmTpjcjV9zcdngZEHcQSSprhDD9VgUYM/nfMQOXDqE0bBQwHGC+wbxg5wxOFoQhyi5nYkv9JHzcLxs3bo1XnvtteTkQRDiXH79RcCpTHjJHQvXoz84fBBy6BMJiGmbdhF0quPUyW2zOs/pG/2l4lLnI3pF2RlTY85eCjKEJMz6zlNx1EkT47B27eO6667bzbU6fSq1Y0gyTaLojh07Rrf+w+JrKx+Mpd/fu6ozize+HqdfsSQ69+ofI0aOTMmZqzNPSo2N/Wk4BPgOQvzt2btP9Bp6fExbsXqvnWALNrwUE77+D8GxrKws/TuQ+73fcOg5EglIoBgEFGOKQdlrSEACEpBAtQkgxkwcPz7+ddUD8f6L2+MXL/8kb/trz2yN+bOvjkWLFlWrPzhadu3alZwhCBWIG4gZVAFCwOA/+pRhZnGb/TKKeMJrwpFIzMtxiC/khZk9e3YSZd5///3dx2cdwR3y3HPPJdGCvCtcJ2szO6aiRxa8uFMQh3C1EPZDIl36RR9wsiCIIBjRLi4XxsKOuMSinBLShA7BngpFhBzRZk1z1NBfxoHQhOsFoQcRhmuSlJj2s3wwFY0ln+8hmpHEs1uvfskhc/k3H40bn/55jR0gix9/PaatWBNDTpwYnbp2j8suu6zGbqV8jisfbTFnuE+Em3Xr1j16DhkeZ19zc8xf/2KNS4KT0Bj30SlTr4lOPfrFCWVlKQ9QeaExH/22DQnUlADCOfmo+vTrHz2HHBvnzbs9CDGqaS4pwvlm3/dMjDp/enTp1S9OOOGE5CSs6XdkTfvv8RKQQMMmoBjTsO+vo5OABCRQ7wiwYD/t1FPjthUr4/F16+OJ9Rvytj9w9z1x2dRLUojQnsDwayfCBIIFoTqEFBFqQwJUXiN4UO0n+884j5kQgTuFXC+ECSGQ4Aa56aabkgCCUJGdQx8yAQMnCscjmOAa2ZMQw4KaBS8uEEQfEukuWLAgCT9cj3a+973vpWvSX4Qjwp54n2shVjC+LFfNnnhU9jn9pB/kgkH4Qdhh7LhgyDWD0wdhCZdQMTf4bN++PTmRuvfsHT0GD49z594WV63aHEuf2FGl6PCPikmvp/wwVAXqMfCY9Ov6lVdeGQhpDWHLRDyEwiFDhkTnXkfGiedcFpfdtiGVA75p89uVLlhXbn03hTZdu+bf4l9u/G4MG3NmHN71iBg9enTKU2T+jIYwQxrOGHAtUuFu0OAh0alH3xh94YxAnEWUwfVWlTBDCN+c1T+KCxfdHYPKxkWXI3qlEDxCOvkbcpOABCSwNwQUY/aGnudKQAISkEDeCSDGTBg/Ph66f1X8v5dfjJ0/fjl2/viVnJ3Xue+Vf82x5d/7x+uXfvB0zJ01K66//voq+00oDoIIITskmaU6EKE9iBksXqlKhPjAf8Y5lvAiFumE/SBCcAwiDOcgltAO7+FewTqfbZkQQxgT4U4bNmzY3W52DI/ZdRA0yCmDgEIIE24W8qOcf/75MWXKlCTGZNWXcKSsXr06hS1RehpBhGpD9DcfG+1keXNwDCG8UJYbZw4hVuSg4Xp7EpXy0Zeq2kBwQgjr169ftO3QKVUROmPWjTHj7ieSo2Pu2n9PjhBcITzH5XHltx+P8ZfOjx6DvhwdOnWNYcOGJQEOV09D2xAGcS2NHTs2VVnq0ntAjDhrWlx260Nx1f3PxrUPPr+bD+XCWZjOuvfpuGjR3XH0mMnR7vAu0bVbt7joootSwmdDNhraDGkY48GtSM6qESNGpOTSnXv2j5POuzwuvXV9zjzfluY68/zaB/8tzfMLrr8zBo+cEB26HBE9evRMSddJhu4mAQlIIB8EFGPyQdE2JCABCUggbwQQY06fNDE2P/ZI/PfHH8b//Nd/5m3/eMcbsXLxohQyVFmHCTNC6EB4oXIQuVUIH0JMYSfkh1/+WcTySE4YcqIg2rDjSiE8CLcICwCEG8QAnDW5joFMiMFJgqBCRaEsvwtts6ilDcKFEDVw1BAexXE4aK644oqYMGFCTJw4MS0QCDuiLdwgCBC5oVOVjbWm7yMK0S/69N5776VcOIhPVIdChMGhA7tSW5AjgJGnhhAj8qS0aNEiDm3bProfeVQMOG5sDB19RgwdfXr0Hz46uvUdHC1bHRKtWrWKHj16pPwwzMm6FpVqeq9qejxJnrmXxx57bLRu3TpaHtwqOnbvHX2PHpFCtIaOmRwDy06LXkOOjfadu0eLli2jbdu2ccoppyQ3DPPNTQKlTIDvL8RxROOBAwemv/GWB7dO4XX9jhkZR500Kbm8BpaNi15Dhkeb9odHixYto127dqn6HaJ5fUzaXcr3xL5JoLETUIxp7DPA8UtAAhIoMQJ1LcbgIEGIQWBA3MDhQs4BQn5wvyDW4FDB5YLzhFwwiCmILrhpshAkBAsEmKVLlybHDK9zN9wtGzduTOFFCCwINSz4cdm88847yfXC+yyQaWPx4sUp183VV1+dXDA4EXj/lVdeyUsloty+VfSchQx9RNTA6cOYly9fnhjgvEE4KvWNe4ejiXtJIuVjjjkmlcFu3rx5HHTQQUmoQYyg9DPhXDhhGHdj2rJqXvPnz09ume7du0fLli2jadOmceihh8aAAQPizDPPTE4u/lYbG5/GNBca6liZs3yHE2o0d+7cFF6XzfNmzZrtnufknEKARwgvNYG5od4bxyWBxkZAMaax3XHHKwEJSKDECdSlGIOjhHAbQn1IOkuCUwQHHB+4VtgpC8xnuGb4jzqJcVngI0aw2GfDiUGIEqFHCDsscHOdFeQwwE1DImHKPJPDBeGF0CJyGyAEsfMZuWkQhSh3zXNEEI7J+kS4UCEXxJSKRoSiD/yijMuHfmYuGMZd6D7kc8pyH+gz94T7ieBCmW52nuNC4tdv7mHuPctnH0q5LeYSC0+EN4RBRMOMEclQec37iIuZ8FjK47FvEqiIQO48J9cXc5z5zfcAj3w34PZCtGGeF/I7tqL++Z4EJNA4CCjGUrAy3gAAEvpJREFUNI777CglIAEJ1BsCdSXG4IhB7EB8ycQQwoEQVQjJIW8MyXwRaKiQRPgSIgyL0kyEATL/cSfRLwlz2SnvzH/o+U8+jhfyc1Aa+bzzzotp06YlZwyiDQIHQtD3v//9VLUJYYgFAjuJcRGAEInoI+1z3UKJBbTLohsXDNdDdGLc5IIh8S9jYbHuYrze/FnZUQlIQAISkIAESoyAYkyJ3RC7IwEJSKCxE6gLMYY8JwghOFUQShBjCGXBjYJ4QlgOwgxhSYQekXcAMaL8r6WIE+SLoXoRlY04j6S+hDoh5BDuNHXq1PjqV78aCxcuTKEwWQlqxCBEDlwHmduE5yTpJR8MOVnIXYO4g1ulEBsCD8IT9n0cPYwD4YnqUAhA/GKMY6T8uAvRF9uUgAQkIAEJSEACDZmAYkxDvruOTQISkEA9JFBMMQZRAWEF4WHOnDkxe/bslIcFl8ratWuTIIMrhOeZCIPLBecIoTnY2D/55JPkeMFFgvCCCEM+l1mzZiVHCWWeaR9nCe2Ti4OQpF27dqVS2BWJG4gxhAaRhwYRCKGI6kTlw53ycXsJSUEEIu8LrhzEFxw9uGBIGEw/EYUK5cLJxxhsQwISkIAEJCABCdQ3Aoox9e2O2V8JSEACDZxAscQYXCy4THCskLD1kksuSYIMrhiEE1whiDC4YxBGCBciLInnJO998cUXk2uGY2iDSkpU60GIIdnuY489lo6hDCruFkQd3C08r6zyDIIH+QuoiIQLByHmySefTIJRbijU3k4B2kLYwY1DAmDy1zBeRBiEIkpVIzIVyoGzt/33fAlIQAISkIAEJFDfCSjG1Pc7aP8lIAEJNDACxRBjcK9QyhfXyjnnnBNUzbj00ktj3rx5KWdMJoIgpCC+II4QqkO4Ec4RPkdcQbwgFAkXCcltOR8XDGFPCB64ThA8uA7nIHxUVhoV4YPEvoRFUUGJ6yCKEDqUr41rkKCWUCSSBpOHhnHQP0QfctoQfqULJl/EbUcCEpCABCQgAQlUTEAxpmIuvisBCUhAAnVEoNBizE0Lr0+JcxEhRo8eHWVlZUmMoWQ0yXsRKDZs2JAEFsQWKhexI7YQvoSLBLfMW2+9ldwjiCU8x/WSCTGEPyHEIORwDueS+JYQp/Ibwgfv//znP0/X5lhcNZTJzkduFkQhwp4INYIt/WfsJA0mL87LL7+ccsGU75evJSABCUhAAhKQgAQKR0AxpnBsbVkCEpCABGpBoNBizPzZs6NP3yNjwIAB0bdv3xgzZkxKqIsYQwLfZcuWJVEGwQJRhqpJCCWEKZEnJndD6CDfCsfifMFxgrjCcbhMeI8KSIQ1Ic6U3zifkCXKRmelrCmdvbduGEQc+oEThnAjEv/Sl6wsNrlt3n333ZSMt3yffC0BCUhAAhKQgAQkUHgCijGFZ+wVJCABCUigBgQKKca8v/3VuOTCC6Jp06ZxxBFHxMSJE1NSXcQUHCMIL1QNoqwz4gmiCrllEDbKu1R4TX4X8sWsXLkylZ9G/OAcxBecMnfccUdqr6IS0BzLtXDOIACRq4UwJY4tf60a4EuHEgpFiNX69euTyIMIQz+p3ESYEn1kTG4SkIAEJCABCUhAAnVDQDGmbrh7VQlIQAISqIRAIcWYj3a8HtfNmhkjR56YXC9UEMI5gqhCrpSspHR1hArCfjZu3JjcJiTzxc2CwEI4EslwKUe9c+fOJHzkDhWhBTfN5s2bU6JgHCvkpMEhg1OmthvnEtr0wx/+MOWAIQyJflCRCZcO7VO5qTpjq20fPE8CEpCABCQgAQlIoHoEFGOqx8mjJCABCUigSAQKKcZ8vOONWH79glQ1iWpCuF9q40Lh3Oeffz7lgiHxLa8Rcki4i9OFXCwIMYgzuRvH4JqhVDUiDG4cEvxWVN4697zKniPAIArhgnnkkUfStWmX9rNS3IgwOGHcJCABCUhAAhKQgARKh4BiTOncC3siAQlIQAIRKcns6ZMmxubHHon//vjD+J//+s+87YgxKxcviiVLltSaNcl2cb8gulBdiZAm3iMEiPcefPDBePvtt/9JiKEsNrlbqFxEyBAlrn/zm9/UyqnC9ajYRBvktaH6EsmGH3/88dQ3KkXh1KmN0FRrMJ4oAQlIQAISkIAEJFBtAoox1UblgRKQgAQkUAwChXbG7I0Yg8OEPC+Us6b0NAl7EUYIU8KRsnbt2hQSlDliEENww3AOLhhEk4cffjglBK5pkl5yyfz+979PbSHqrF69ercLh5AnkgyTD6ai/DTFuG9eQwISkIAEJCABCUig+gQUY6rPyiMlIAEJSKAIBEpVjCHXCjlZcMPgQtmxY0fKw4IjhnLUhAZ98MEHu0OCEEWowETpaHK34JrZsmVLyhdT3dwwXBPRhrw2hCKRo4ZrI+og/FBimz5VVKmpCLfKS0hAAhKQgAQkIAEJ1JKAYkwtwXmaBCQgAQkUhkCpijG4TsjLggMGEYTwJMKEqKREjpjcSki4YQgjokLSLbfcksKSCF0iN8yeNtw0OHCoiESbXAMnDgl5qdBEm7hgyAXjJgEJSEACEpCABCRQPwkoxtTP+2avJSABCTRYAqUoxhB2RKLe22+/PVVB+uUvf5kS+CLE3H///UmYwcWC4wURhUS+uFcQYp566qkknOypilEmwuCEIfkv+V+43k033ZQEoB/96EdJnDEZb4Od+g5MAhKQgAQkIIFGREAxphHdbIcqAQlIoD4QKEUxBncKwsqmTZti165dKdwIkYTQJMSXLFEuIUPkhFm+fHlK1PvWW2/t/mxP7HHekHuGktjLli1LjhuS8+KCqW3Vpz1d088lIAEJSEACEpCABOqGgGJM3XD3qhKQgAQkUAmBUhJjyPuCoEJOGKok0TccMrwmIe+nn36axBbCj7LcMHfccUc888wzyS1TlYslS+6LC+axxx5LbeK0odISLhjcNyQHrqqNShD6tgQkIAEJSEACEpBAiRNQjCnxG2T3JCABCTQ2AqUixiDEIIiQI4bku4Qe4XohbwshRFQ2QighrwvvE1L0wAMPpES7f/rTnyotWc05v/71r1MpbHLNfPOb30w74g5Jeil3TahSdZP8Nrb54XglIAEJSEACEpBAQyCgGNMQ7qJjkIAEJNCACCDGTJowIR5ftzZ+9dab8dudb1W+v13FZ5xX7vOfbXshFl83NxYtWlQlMYQQKiFROYnwpGeffTZVL6Iq0tNPPx2/+tWvUh4YBBpyxiCo/OAHP4iPPvqo0iS9JNwliS+uGUQYcsqQmHfr1q2pHDYJgclNk4U8VdlBP5SABCQgAQlIQAISqNcEFGPq9e2z8xKQgAQaHgHEmNPGjYvbliyOx++6K564+5544u67//cx9znvZe9X9Zxz/nHeAytvjq9deEHMnz+/UnCIIeRvIfEuYUPr169PIUo4ZDZv3pxKSVMpCVEFcQZB5dVXX40//OEPn3Gz0A7iCs6Z1157LeWbuffee1NpanLBbNu2LZXCzs05U2mn/EACEpCABCQgAQlIoEERUIxpULfTwUhAAhKo/wQQY8aNGhUrJp0V60acEuvLTs7bfs9xo2LqcWWxYMGCSkERYkTC3m984xtJbCH0iBAknC/vvfde7NixIzlmCFfauHFjvP/++0FIU7bxHGGG90nIu3bt2hTqdN9996XjX3/99eS6MRdMRsxHCUhAAhKQgAQk0PgIKMY0vnvuiCUgAQmUNIHkjBkxMu4ZckL8R5NO8VKTDnnbn2rSOWb3GRRLliypkAGJeBFLEFqoloTz5eabb05Je999990UrkT+mHvuuSc5W3C1sOGC4VwcNRyHawYXDCIO1ZEQcj744IP4y1/+YhhSheR9UwISkIAEJCABCTQuAooxjet+O1oJSEACJU+grsQY8sSQ0wURBbEGMYYwJcKVSKyLQ+bWW28NQoxwvXA8OwILIgyhSLhgqLTEcVRfQtjBJWMemJKfdnZQAhKQgAQkIAEJFJWAYkxRcXsxCUhAAhLYE4G6EmM++eSTWL16dcybNy+uu+663UIMyXsRZQhbIuwoq5REPpiPP/44uV4QX5YtWxZZWWtyyiDUuElAAhKQgAQkIAEJSKAiAooxFVHxPQlIQAISqDMCdSHGILDgeLn22mtj5syZyRWDMENI0g033JCS+FIpCQEGF8z27dtjzZo16bjly5cnRwwumE8//TSVu/7b3/5WZ/y8sAQkIAEJSEACEpBA6RNQjCn9e2QPJSABCTQqAsUWY/7617+mUKS5c+fG5ZdfHgsXLkzlrFesWJFKVuOGoZT1O++8k3LBINAQikTeGHLD/OIXv0hlrhFqFGEa1VR1sBKQgAQkIAEJSKDWBBRjao3OEyUgAQlIoBAEiinGUPmIykk4Yi6++OKYMWNGClMiaS/OmJdffjleeOGF5IxBhLnrrrvioYceildeeSWFKP3xj380HKkQk8A2JSABCUhAAhKQQAMnoBjTwG+ww5OABCRQ3wgUS4zBEcO1EGLOPPPMmDJlSlx11VVx4403xqpVq5LoQijSnXfeGZSlJpEvZa3JLUPSXjcJSEACEpCABCQgAQnUloBiTG3JeZ4EJCABCRSEQDHEmPnz58euXbtS1aSxY8fG6aefHtOmTUuJe2+55ZaUiBcXDGLMli1bUpUlXTAFud02KgEJSEACEpCABBolAcWYRnnbHbQEJCCB0iVQaDFmZu+BMXXqJUEo0nHHHRfDhw+P888/P6ZPnx5Lly6Nb33rW7Fu3bp46aWXUq4YqyKV7lyxZxKQgAQkIAEJSKC+ElCMqa93zn5LQAISaKAECinGPNmkU0zr3CsGDz0mjjrqqOjTp0+ceuqpMXv27JSUd9OmTbFz587485//3EDpOiwJSEACEpCABCQggVIgoBhTCnfBPkhAAhKQwG4ChRRjNjbpGBOatY7mB7WI7t27p1wxt99+e0ri+7vf/c5kvLvvgk8kIAEJSEACEpCABApJQDGmkHRtWwISkIAEakygkGLMk006xzkt20aPHj1S+WpcMCTypST13//+9xr31RMkIAEJSEACEpCABCRQGwKKMbWh5jkSkIAEJFAwAoUUY55q0jmu7HlkzJkzJ0jIS2lrNwlIQAISkIAEJCABCRSbgGJMsYl7PQlIQAISqJJAocWY2X0GpSpKVXbCDyUgAQlIQAISkIAEJFBAAooxBYRr0xKQgAQkUHMCijE1Z+YZEpCABCQgAQlIQAL1i4BiTP26X/ZWAhKQQIMnoBjT4G+xA5SABCQgAQlIQAKNnoBiTKOfAgKQgAQkUFoEFGNK637YGwlIQAISkIAEJCCB/BNQjMk/U1uUgAQkIIG9IKAYsxfwPFUCEpCABCQgAQlIoF4QUIypF7fJTkpAAhJoPAQUYxrPvXakEpCABCQgAQlIoLESUIxprHfecUtAAhIoUQKKMSV6Y+yWBCQgAQlIQAISkEDeCCjG5A2lDUlAAhKQQD4IKMbkg6JtSEACEpCABCQgAQmUMgHFmFK+O/ZNAhKQQCMkgBhzatmI+PbgY+OHTTrG80065G3f2KRTzOgzKJYsWdIIyTpkCUhAAhKQgAQkIIFSIaAYUyp3wn5IQAISkEAi8NOf/jRGjRwZo3r1jckdusXkDl3ytp/WsVuceOTAWLBggbQlIAEJSEACEpCABCRQZwQUY+oMvReWgAQkIIGKCPz2t7+Nhx9+OFatWhX3r1q1+zH3+Xfvvz+9nx3DZ7mf577mGI7PPl+zenVs27atokv7ngQkIAEJSEACEpCABIpCQDGmKJi9iAQkIAEJSEACEpCABCQgAQlIQAIS+AcBxRhnggQkIAEJSEACEpCABCQgAQlIQAISKCIBxZgiwvZSEpCABCQgAQlIQAISkIAEJCABCUhAMcY5IAEJSEACEpCABCQgAQlIQAISkIAEikhAMaaIsL2UBCQgAQlIQAISkIAEJCABCUhAAhJQjHEOSEACEpCABCQgAQlIQAISkIAEJCCBIhJQjCkibC8lAQlIQAISkIAEJCABCUhAAhKQgAQUY5wDEpCABCQgAQlIQAISkIAEJCABCUigiAQUY4oI20tJQAISkIAEJCABCUhAAhKQgAQkIAHFGOeABCQgAQlIQAISkIAEJCABCUhAAhIoIgHFmCLC9lISkIAEJCABCUhAAhKQgAQkIAEJSEAxxjkgAQlIQAISkIAEJCABCUhAAhKQgASKSEAxpoiwvZQEJCABCUhAAhKQgAQkIAEJSEACElCMcQ5IQAISkIAEJCABCUhAAhKQgAQkIIEiElCMKSJsLyUBCUhAAhKQgAQkIAEJSEACEpCABBRjnAMSkIAEJCABCUhAAhKQgAQkIAEJSKCIBBRjigjbS0lAAhKQgAQkIAEJSEACEpCABCQgAcUY54AEJCABCUhAAhKQgAQkIAEJSEACEigiAcWYIsL2UhKQgAQkIAEJSEACEpCABCQgAQlIQDHGOSABCUhAAhKQgAQkIAEJSEACEpCABIpI4P8DME7/6CxB+XoAAAAASUVORK5CYII=)![image.png](attachment:image.png)\n",
        "\n",
        "Ref : https://stanford.edu/~shervine/teaching/cs-230/cheatsheet-convolutional-neural-networks#:~:text=Fully%20Connected%20(FC)%20The%20fully,objectives%20such%20as%20class%20scores."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VcbCQ6I2xYrz"
      },
      "source": [
        "Replay Buffer : records previous state,action and rewards. A training set is created when the agent is updated and a sample of batch is created from the replay buffer. These samples can come from different episodes if the buffer is long enough. \n",
        "This is very important in order to reduce the high correlation between training data. Neural network dont do well is training data is highly correlated.\n",
        "\n",
        "Ref : https://livebook.manning.com/concept/reinforcement-learning/experience-replay"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L0bYJ5hCxYrz"
      },
      "source": [
        "#ref : https://docs.python.org/3/library/dataclasses.html\n",
        "@dataclass\n",
        "class ReplayBuffer:\n",
        "    \n",
        "    '''\n",
        "    considering a buffer size of 50\n",
        "    '''\n",
        "    buffer_size: int = 50\n",
        "\n",
        "    def __post_init__(self) -> None:\n",
        "        \n",
        "        #deque : Returns a new deque object initialized left-to-right (using append()) with data from iterable. \n",
        "        #Deques are a generalization of stacks and queues (the name is pronounced “deck” and is short for “double-ended queue”). \n",
        "        #Deques support thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction.\n",
        "        #ref : https://docs.python.org/3/library/collections.html#collections.deque\n",
        "        \n",
        "        self._state_queue = collections.deque(maxlen=self.buffer_size)\n",
        "        self._other_queue = collections.deque(maxlen=self.buffer_size)\n",
        "\n",
        "        self.queue = collections.deque(maxlen=self.buffer_size)\n",
        "\n",
        "    \n",
        "    def __len__(self) -> int:\n",
        "        return self.n if (self.n > 0) else 0\n",
        "\n",
        "    \"\"\"\n",
        "    flag to check whether the buffer is full\n",
        "    \"\"\"\n",
        "    @property\n",
        "    def full(self) -> bool:\n",
        "        return len(self._state_queue) == self.buffer_size\n",
        "    \n",
        "    \"\"\"\n",
        "    returns length of state_queue\n",
        "    \"\"\"\n",
        "    @property\n",
        "    def n(self) -> int:\n",
        "        return len(self._state_queue) - 1\n",
        "\n",
        "    \"\"\"\n",
        "    :param items: Tuple containing (s, a, r, d).\n",
        "    state queue contains state (s)\n",
        "    other queue contain action,reward and discount (a,r,d)\n",
        "    \"\"\"\n",
        "    def append(self, items: Tuple[Any, int, float, bool]) -> None:\n",
        "        \n",
        "        self._state_queue.append(items[0])\n",
        "        self._other_queue.append(items[1::])\n",
        "    \n",
        "    \"\"\"\n",
        "    returns a batch containing state, action, reward and discount and next state\n",
        "    \"\"\"\n",
        "    def get_batch(self, idxs: Iterable[int]) -> Tuple[List[np.ndarray], \n",
        "                                                      List[np.ndarray],\n",
        "                                                      List[float], \n",
        "                                                      List[bool], \n",
        "                                                      List[np.ndarray]]:\n",
        "        ss = [self._state_queue[i] for i in idxs]\n",
        "        ss_ = [self._state_queue[i + 1] for i in idxs]\n",
        "\n",
        "        ard = [self._other_queue[i] for i in idxs]\n",
        "        aa = [a for (a, _, _) in ard]\n",
        "        rr = [r for (_, r, _) in ard]\n",
        "        dd = [d for (_, _, d) in ard]\n",
        "\n",
        "        return ss, aa, rr, dd, ss_\n",
        "    \n",
        "    \n",
        "    \"\"\"\n",
        "    randomizes the batch\n",
        "    \"\"\"\n",
        "    def sample_batch(self, n: int) -> Tuple[List[np.ndarray], \n",
        "                                            List[np.ndarray],\n",
        "                                            List[float], \n",
        "                                            List[bool], \n",
        "                                            List[np.ndarray]]:\n",
        "        if n > self.n:\n",
        "            raise ValueError\n",
        "\n",
        "        idxs = np.random.randint(0, self.n, n)\n",
        "        return self.get_batch(idxs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m1czVqUhxYr6"
      },
      "source": [
        "Epsilon Greedy\n",
        "\n",
        "Epsilon greedy enables the agent to explore the environment. \n",
        "Before an agent makes an action, it considers a random value between 0 and 1. if this value > epsilon , the agent take random action. \n",
        "Eplison is generally set at a high value initially at the beginning of the traning and it slowly decays over time. Hence Eplison is decay factor. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gt3Ts8y_xYr7"
      },
      "source": [
        "@dataclass\n",
        "class EpsilonGreedy:\n",
        "    \"\"\"\n",
        "    Handles epsilon-greedy action selection, decay of epsilon during training.\n",
        "\n",
        "    :param eps_initial: Initial epsilon value.\n",
        "    :param decay: Decay rate in percent (should be positive to decay).\n",
        "    :param decay_schedule: 'linear' or 'compound'.\n",
        "    :param eps_min: The min value epsilon can fall to.\n",
        "    :param state: Random state, used to pick between the greedy or random options.\n",
        "    \"\"\"\n",
        "    eps_initial: float = 0.2\n",
        "    decay: float = 0.0001\n",
        "    decay_schedule: str = 'compound'\n",
        "    eps_min: float = 0.01\n",
        "    state = None\n",
        "    \n",
        "    def __post_init__(self) -> None:\n",
        "        self._step: int = 0\n",
        "        self.eps_current = self.eps_initial\n",
        "\n",
        "        valid_decay = ('linear', 'compound')\n",
        "        if self.decay_schedule.lower() not in valid_decay:\n",
        "            raise ValueError(f\"Invalid decay schedule {self.decay_schedule}. \"\n",
        "                             \"Pick from {valid_decay}.\")\n",
        "\n",
        "        self._set_random_state()\n",
        "\n",
        "    def _set_random_state(self) -> None:\n",
        "        self._state = np.random.RandomState(self.state)\n",
        "\n",
        "    def _linear_decay(self) -> float:\n",
        "        return self.eps_current - self.decay\n",
        "\n",
        "    def _compound_decay(self) -> float:\n",
        "        return self.eps_current - self.eps_current * self.decay\n",
        "\n",
        "    \"\"\"\n",
        "    returns max between eps_min and new_eps value which is new epsilon value post calculation(compound or linear)\n",
        "    in case new_eps value falls below eps_min set at the start, eps_min will be returned\n",
        "    \"\"\"\n",
        "    def _decay(self):\n",
        "        new_eps = np.nan\n",
        "        if self.decay_schedule.lower() == 'linear':\n",
        "            new_eps = self._linear_decay()\n",
        "\n",
        "        if self.decay_schedule.lower() == 'compound':\n",
        "            new_eps = self._compound_decay()\n",
        "\n",
        "        self._step += 1\n",
        "\n",
        "        return max(self.eps_min, new_eps)\n",
        "    \n",
        "    \"\"\"\n",
        "    Apply epsilon greedy selection.\n",
        "\n",
        "    If training, decay epsilon, and return selected option. \n",
        "    If not training, just return greedy_option.\n",
        "\n",
        "    Use of lambdas is to avoid unnecessarily picking between \n",
        "    two pre-computed options.\n",
        "\n",
        "    :param greedy_option: Function to evaluate if random option \n",
        "                          is NOT picked.\n",
        "    :param random_option: Function to evaluate if random option \n",
        "                          IS picked.\n",
        "    :param training: Bool indicating if call is during training \n",
        "                     and to use epsilon greedy and decay.\n",
        "    :return: Evaluated selected option.\n",
        "    \"\"\"\n",
        "\n",
        "    def select(self, greedy_option: Callable, random_option: Callable,\n",
        "               training: bool = False) -> Any:\n",
        "        if training:\n",
        "            self.eps_current = self._decay()\n",
        "            if self._state.random() < self.eps_current:\n",
        "                return random_option()\n",
        "\n",
        "        return greedy_option()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WNxL1hUOxYr7"
      },
      "source": [
        "@dataclass\n",
        "class DQNAgent:\n",
        "    replay_buffer: ReplayBuffer\n",
        "    eps: EpsilonGreedy\n",
        "    model_architecture: DenseNN\n",
        "    name: str = 'DQNAgent'\n",
        "    double: bool = False\n",
        "    noisy: bool = False\n",
        "    gamma: float = 0.99\n",
        "    replay_buffer_samples: int = 75\n",
        "    final_reward: Union[float, None] = None\n",
        "\n",
        "    def __post_init__(self) -> None:\n",
        "        self._build_model()\n",
        "\n",
        "    \"\"\"\n",
        "    Prepare two of the same model.\n",
        "\n",
        "    The action model is used to pick actions and the target model\n",
        "    is used to predict value of Q(s', a). Action model\n",
        "    weights are updated on every buffer sample + training step. \n",
        "    The target model is never directly trained, but it's\n",
        "    weights are updated to match the action model at the end of \n",
        "    each episode.\n",
        "    \"\"\"\n",
        "\n",
        "    def _build_model(self) -> None:\n",
        "        self._action_model = self.model_architecture.compile(\n",
        "            model_name='action_model', loss='mse')\n",
        "        self._target_model = self.model_architecture.compile(\n",
        "            model_name='target_model', loss='mse')\n",
        "\n",
        "    def transform(self, s: np.ndarray) -> np.ndarray:\n",
        "        \"\"\"Check input shape, add Row dimension if required.\"\"\"\n",
        "\n",
        "        if len(s.shape) < len(self._action_model.input.shape):\n",
        "            s = np.expand_dims(s, 0)\n",
        "\n",
        "        return s\n",
        "\n",
        "    \"\"\"\n",
        "    First the most recent step is added to the buffer.\n",
        "\n",
        "    s' isn't saved because there's no need. it will added in next step\n",
        "    \"\"\"\n",
        "    def update_experience(self, s: np.ndarray, a: int, \n",
        "                          r: float, d: bool) -> None:\n",
        "        \n",
        "\n",
        "        # Add s, a, r, d to replay buffer\n",
        "        self.replay_buffer.append((s, a, r, d))\n",
        "\n",
        "    \"\"\"\n",
        "    Sample a batch from the replay buffer, calculate targets using \n",
        "    target model, and train action model.\n",
        "\n",
        "    If the buffer is below its minimum size, no training is done.\n",
        "\n",
        "    If the buffer has reached its minimum size, a training batch \n",
        "    from the replay buffer and the action model is updated.\n",
        "\n",
        "    This update samples random (s, a, r, s') sets from the buffer \n",
        "    and calculates the discounted reward for each set.\n",
        "    The value of the actions at states s and s' are predicted from \n",
        "    the value model. The action model is updated using these value \n",
        "    predictions as the targets. The value of performed action is \n",
        "    updated with the discounted reward (using its value prediction \n",
        "    at s'). ie. x=s, y=[action value 1, action value 2].\n",
        "    \"\"\"\n",
        "\n",
        "    def update_model(self) -> None:\n",
        "    \n",
        "        # If buffer isn't full, don't train\n",
        "        #print(\"self.replay_buffer.full=>\",self.replay_buffer.full)\n",
        "        if not self.replay_buffer.full:\n",
        "            return\n",
        "\n",
        "        # Else sample batch from buffer\n",
        "        ss, aa, rr, dd, ss_ = self.replay_buffer.sample_batch(\n",
        "            self.replay_buffer_samples)\n",
        "        \n",
        "        \n",
        "        #print(f\"ss=>\",ss)\n",
        "        #print(f\"aa=>\",aa)\n",
        "        #print(f\"rr=>\",rr)\n",
        "        #print(f\"dd=>\",dd)\n",
        "        #print(f\"ss_\",ss)\n",
        "\n",
        "        # Calculate estimated S,A values for current states and next states. \n",
        "        ss = np.array(ss)\n",
        "        ss_ = np.array(ss_)\n",
        "        \n",
        "        y_now = self._target_model.predict_on_batch(np.vstack(ss))\n",
        "        y_future = self._target_model.predict_on_batch(np.vstack(ss_))\n",
        "        \n",
        "        \n",
        "        # Update rewards where not done with y_future predictions\n",
        "        #print(\"\\ndd=>\\n\",dd)\n",
        "        #print(\"dd shape\",dd.shape)\n",
        "        # dd_mask is an array of bools indicating whether the episode was completed on that step \n",
        "        # (this is for all the replay buffer samples, not just the current episode). \n",
        "        # It's used to index into the array rewards and set the final reward where it is the final step.\n",
        "        dd_mask = np.array(dd, dtype=bool).squeeze()\n",
        "        #print(\"\\ndd_mask=>\\n\",dd_mask)\n",
        "        #print(\"dd_mask shape\",dd_mask.shape)\n",
        "        rr = np.array(rr, dtype=float).squeeze()\n",
        "\n",
        "        # Gather max action indexes and update relevant actions in y\n",
        "        if self.double:\n",
        "          # If using double dqn select best actions using the action model, \n",
        "          # but the value of those action using the\n",
        "          # target model (already have in y_future). \n",
        "          y_future_action_model = self._action_model.predict_on_batch(ss_)\n",
        "          selected_actions = np.argmax(y_future_action_model[~dd_mask, :], \n",
        "                                        axis=1)\n",
        "        else:\n",
        "          selected_actions = np.argmax(y_future[~dd_mask, :], \n",
        "                                         axis=1)\n",
        "        \n",
        "        #print(\"\\nselected_actions=>\\n\",selected_actions)\n",
        "\n",
        "        # Update reward values with estimated values (where not done) \n",
        "        # and final rewards (where done)\n",
        "        rr[~dd_mask] += y_future[~dd_mask, selected_actions]\n",
        "        #print(\"\\nrr post dd_mask=>\\n\",rr)\n",
        "        \n",
        "        if self.final_reward is not None:\n",
        "            # If self.final_reward is set, set done cases to this value. \n",
        "            # Else leave as observed reward.\n",
        "            rr[dd_mask] = self.final_reward\n",
        "        \n",
        "        aa = np.array(aa, dtype=int)\n",
        "        \n",
        "        #print(\"y_now before put along axis\",y_now)\n",
        "        #print(\"y_now shape before put along axis\",y_now.shape)\n",
        "        \n",
        "        #print(\"aa shape\",aa.shape)\n",
        "        #print(\"aa reshape\",aa.reshape(-1,1))\n",
        "        #print(\"rr reshape\",rr.shape)\n",
        "        #print(\"rr reshape\",rr.reshape(-1, 1))\n",
        "        \n",
        "        # np.put_along_axis puts the values in rr which holds the rewards for the sampled steps, \n",
        "        # into the relevant indexes (in aa, which are the actions) of the y_now array.\n",
        "        np.put_along_axis(y_now, aa.reshape(-1, 1), rr.reshape(-1, 1), axis=1)\n",
        "        #print(\"y_now after put along axis\",y_now)\n",
        "        #print(\"y_now shape after put along axis\",y_now.shape)\n",
        "        \n",
        "\n",
        "        # Fit model with updated y_now values\n",
        "        # Runs a single gradient update on a single batch of data.\n",
        "        # Train_on_batch will also see a performance increase over fit and fit generator for\n",
        "        # using large datasets and don't have easily serializable data (like high rank numpy arrays), to write to tfrecords.\n",
        "        # Ref : https://stackoverflow.com/questions/49100556/what-is-the-use-of-train-on-batch-in-keras\n",
        "        self._action_model.train_on_batch(ss, y_now)\n",
        "\n",
        "    \"\"\"\n",
        "    Get best action(s) from model - the one with the highest predicted value.\n",
        "\n",
        "    :param s: A single or multiple rows of state observations.\n",
        "    :return: The selected action.\n",
        "    \"\"\"\n",
        "\n",
        "    def get_best_action(self, s: np.ndarray) -> np.ndarray:\n",
        "        preds = self._action_model.predict(self.transform(s))\n",
        "\n",
        "        return np.argmax(preds)\n",
        "\n",
        "    \"\"\"\n",
        "    Get an action using get_best_action or epsilon greedy.\n",
        "\n",
        "    Epsilon decays every time a random action is chosen.\n",
        "\n",
        "    :param s: The raw state observation.\n",
        "    :param training: Bool to indicate whether or not to use this \n",
        "                     experience to update the model. If False, just\n",
        "                     returns best action.\n",
        "    :return: The selected action.\n",
        "    \"\"\"\n",
        "    def get_action(self, s: np.ndarray, training: bool = False) -> int:\n",
        "        \n",
        "        action = self.eps.select(greedy_option=lambda: self.get_best_action(s),\n",
        "                                 random_option=lambda: self.env.action_space.sample(),\n",
        "                                 training=training)\n",
        "\n",
        "        return action\n",
        "\n",
        "    \"\"\"\n",
        "    Update the value model with the weights of the action model \n",
        "    (which is updated each step).\n",
        "\n",
        "    The value model is updated less often to maintain stability.\n",
        "    \"\"\"\n",
        "\n",
        "    def update_target_model(self) -> None:\n",
        "        self._target_model.set_weights(self._action_model.get_weights())\n",
        "\n",
        "    \"\"\"Value model synced with action model at the end of each episode.\"\"\"\n",
        "    \n",
        "    def after_episode_update(self) -> None:\n",
        "        self.update_target_model()\n",
        "\n",
        "    \"\"\"\n",
        "    Use this to define the discounted reward for unfinished episodes, \n",
        "    default is 1 step TD.\n",
        "    \"\"\"  \n",
        "    def _discounted_reward(self, reward: float, \n",
        "                           estimated_future_action_rewards: np.ndarray) -> float:\n",
        "        return reward + self.gamma * np.max(estimated_future_action_rewards)\n",
        "\n",
        "    \"\"\"\n",
        "    Calculate discounted reward for a single step.\n",
        "\n",
        "    :param reward: Last real reward.\n",
        "    :param estimated_future_action_rewards: Estimated future values \n",
        "                                            of actions taken on next step.\n",
        "    :param done: Flag indicating if this is the last step on an episode.\n",
        "    :return: Reward.\n",
        "    \"\"\"\n",
        "\n",
        "    def _get_reward(self, reward: float, \n",
        "                    estimated_future_action_rewards: np.ndarray, \n",
        "                    done: bool) -> float:\n",
        "    \n",
        "        if done:\n",
        "            # If done, reward is just this step. Can finish because agent has won or lost.\n",
        "            return self._final_reward(reward)\n",
        "        else:\n",
        "            # Otherwise, it's the reward plus the predicted max value of next action\n",
        "            return self._discounted_reward(reward, \n",
        "                                           estimated_future_action_rewards) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hzmQN2eixYr9"
      },
      "source": [
        "Play Single Episode"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 438
        },
        "id": "uvdPq_0uxYsA",
        "outputId": "87b3e042-17db-4051-fd15-d786aa278b86"
      },
      "source": [
        "\"\"\"\n",
        "env :the gym environment\n",
        "agent : the DQN Agent\n",
        "n_steps : total number of steps the model should be run for\n",
        "pr : a boolean flag that decides whether to print \n",
        "training : a boolean flag that decides whether training is true/false\n",
        "\n",
        "returns a tuple of episode_rewards,episode_actions\n",
        "\"\"\"\n",
        "\n",
        "\n",
        "def play_single_episode(env: gym.Env, agent, n_steps: int=10, pr: bool=False, \n",
        "                 training:bool=False) -> Tuple[List[float], List[int]]:\n",
        "        \n",
        "    episode_rewards = []\n",
        "    episode_actions = []\n",
        "    \n",
        "    #reset the environment\n",
        "    obs = env.reset()\n",
        "    done = False\n",
        "    \n",
        "    #iterate for n_steps\n",
        "    for s in range(n_steps):\n",
        "        if done:\n",
        "            break\n",
        "\n",
        "        # Select action\n",
        "        action = agent.get_action(obs)\n",
        "        episode_actions.append(action)\n",
        "\n",
        "        # Take action\n",
        "        prev_obs = obs\n",
        "        \n",
        "        #on taking an action, env returns \n",
        "            #observation, \n",
        "            #reward taken by the action, \n",
        "            #whether done is true or false, \n",
        "            #info about the action(scoring reward)\n",
        "        obs, reward, done, info = env.step(action)\n",
        "        episode_rewards.append(reward)\n",
        "\n",
        "        # Update model\n",
        "        if training:\n",
        "            agent.update_experience(s=prev_obs, a=action, \n",
        "                                    r=reward, d=done)\n",
        "            agent.update_model()\n",
        "\n",
        "        if pr:\n",
        "            print(f\"Step {s}: Action taken {action}, \"f\"reward recieved {reward}\")\n",
        "\n",
        "        last_step = s\n",
        "    \n",
        "    if training:\n",
        "        agent.after_episode_update()\n",
        "                  \n",
        "    return episode_rewards, episode_actions\n",
        "                  \n",
        "\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "#print(\"env.action_space.n-=>\\n\",env.action_space.n)\n",
        "agent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),  \n",
        "    eps=EpsilonGreedy(),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               # Setting low value to make it easier to run in notebook\n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n))\n",
        "\n",
        "_ = play_single_episode(env, agent, n_steps=20, pr=True, training=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/gym/logger.py:30: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
            "  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-27-eabf1e033c51>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     65\u001b[0m                                \u001b[0;31m# Setting low value to make it easier to run in notebook\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m                                \u001b[0munit_scale\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.25\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m                                n_actions=env.action_space.n))\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplay_single_episode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0magent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_steps\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtraining\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<string>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, replay_buffer, eps, model_architecture, name, double, noisy, gamma, replay_buffer_samples, final_reward)\u001b[0m\n",
            "\u001b[0;32m<ipython-input-26-df4f7f616e9b>\u001b[0m in \u001b[0;36m__post_init__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__post_init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_build_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m     \"\"\"\n",
            "\u001b[0;32m<ipython-input-26-df4f7f616e9b>\u001b[0m in \u001b[0;36m_build_model\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     27\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_build_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m         self._action_model = self.model_architecture.compile(\n\u001b[0;32m---> 29\u001b[0;31m             model_name='action_model', loss='mse')\n\u001b[0m\u001b[1;32m     30\u001b[0m         self._target_model = self.model_architecture.compile(\n\u001b[1;32m     31\u001b[0m             model_name='target_model', loss='mse')\n",
            "\u001b[0;32m<ipython-input-23-585f4ab22752>\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, model_name, loss)\u001b[0m\n\u001b[1;32m     56\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Invalid optimiser {self.opt}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 58\u001b[0;31m         \u001b[0mstate_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maction_output\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_model_architecture\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     59\u001b[0m         model = keras.Model(inputs=[state_input], outputs=[action_output], \n\u001b[1;32m     60\u001b[0m                             name=model_name)\n",
            "\u001b[0;32m<ipython-input-23-585f4ab22752>\u001b[0m in \u001b[0;36m_model_architecture\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0mobs_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobservation_shape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m         \u001b[0mframe_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mInput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'input'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobs_shape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     31\u001b[0m         fc1 = keras.layers.Dense(int( obs_shape/ 1.5 * self.unit_scale), \n\u001b[1;32m     32\u001b[0m                                  name='fc1', activation='relu')(frame_input)\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/input_layer.py\u001b[0m in \u001b[0;36mInput\u001b[0;34m(shape, batch_size, name, dtype, sparse, tensor, ragged, **kwargs)\u001b[0m\n\u001b[1;32m    307\u001b[0m     \u001b[0minput_layer_config\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'batch_input_shape'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbatch_input_shape\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 309\u001b[0;31m     input_layer_config.update(\n\u001b[0m\u001b[1;32m    310\u001b[0m         {'batch_size': batch_size, 'input_shape': shape})\n\u001b[1;32m    311\u001b[0m   \u001b[0minput_layer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mInputLayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0minput_layer_config\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/utils/version_utils.py\u001b[0m in \u001b[0;36m__new__\u001b[0;34m(cls, *args, **kwargs)\u001b[0m\n\u001b[1;32m     63\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m__new__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=unused-argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m     \u001b[0muse_v2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mshould_use_v2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m     \u001b[0mcls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mswap_class\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbase_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLayer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbase_layer_v1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLayer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muse_v2\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=self-cls-assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLayerVersionSelector\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__new__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/utils/generic_utils.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(self, item)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/utils/generic_utils.py\u001b[0m in \u001b[0;36m_load\u001b[0;34m(self)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/__init__.py\u001b[0m in \u001b[0;36mimport_module\u001b[0;34m(name, package)\u001b[0m\n\u001b[1;32m    125\u001b[0m                 \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    126\u001b[0m             \u001b[0mlevel\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_bootstrap\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_gcd_import\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlevel\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpackage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlevel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    128\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_gcd_import\u001b[0;34m(name, package, level)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_find_and_load\u001b[0;34m(name, import_)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_find_and_load_unlocked\u001b[0;34m(name, import_)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_load_unlocked\u001b[0;34m(spec)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap_external.py\u001b[0m in \u001b[0;36mexec_module\u001b[0;34m(self, module)\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_call_with_frames_removed\u001b[0;34m(f, *args, **kwds)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/base_layer_v1.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     76\u001b[0m \u001b[0;31m# pylint: disable=g-classes-have-attributes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0;32mclass\u001b[0m \u001b[0mLayer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbase_layer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLayer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     78\u001b[0m   \"\"\"Base layer class.\n\u001b[1;32m     79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/base_layer_v1.py\u001b[0m in \u001b[0;36mLayer\u001b[0;34m()\u001b[0m\n\u001b[1;32m   2315\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2316\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2317\u001b[0;31m   \u001b[0;34m@\u001b[0m\u001b[0mtracking\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcached_per_instance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2318\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_call_full_argspec\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2319\u001b[0m     \u001b[0;31m# Argspec inspection is expensive and the call spec is used often, so it\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'tensorflow.python.training.tracking.tracking' has no attribute 'cached_per_instance'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZR9seBwPxYsA"
      },
      "source": [
        "def run_multiple_episodes(env: gym.Env, agent, n_episodes: int=10, \n",
        "                          n_steps: int=10, pr: bool=False, \n",
        "                          training:bool=False) -> List[float]:\n",
        "\n",
        "    \n",
        "    total_episode_rewards = []\n",
        "    for ep in range(n_episodes):\n",
        "\n",
        "        episode_rewards, _ = play_single_episode(env, agent, n_steps, \n",
        "                                          pr=False, training=True)\n",
        "\n",
        "        total_episode_rewards.append(sum(episode_rewards))\n",
        "        \n",
        "        if pr:\n",
        "            print(f\"Episode {ep} finished after {len(episode_rewards)} \"\n",
        "                  f\"steps, total reward: {sum(episode_rewards)}\")\n",
        "\n",
        "    \n",
        "    return total_episode_rewards\n",
        "\n",
        "\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "baseDQNagent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),\n",
        "    eps=EpsilonGreedy(eps_initial=0.9),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n))\n",
        "\n",
        "'''\n",
        "doubleDQNagent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),\n",
        "    eps=EpsilonGreedy(eps_initial=0.9),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n),\n",
        "    double = True)\n",
        "'''\n",
        "\n",
        "'''\n",
        "nmber_of_episodes = 10\n",
        "# Both n_episodes and n_steps need to \n",
        "\n",
        "dqn_reward_history = run_multiple_episodes(env, baseDQNagent, n_episodes=10, \n",
        "                                       # Use 3000 for 90 minute games\n",
        "                                       n_steps=3000,  \n",
        "                                       training=True, pr=True)\n",
        "\n",
        "print(\"\\n-------------------------------------------------------------\")\n",
        "print(\"\\nThe mean of reward history over the {} episodes : {}\".format(nmber_of_episodes, mean(reward_history_baseDQN) ))\n",
        "print(\"\\n-------------------------------------------------------------\")\n",
        "\n",
        "plt.plot(reward_history_baseDQN)\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.show()\n",
        "'''\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XMTJhOnJeNF5"
      },
      "source": [
        "class RandomModel:\n",
        "    def __init__(self, n_actions: int):\n",
        "        self.n_actions = n_actions\n",
        "\n",
        "    def predict(self) -> int:\n",
        "        return int(np.random.randint(0, self.n_actions, 1))\n",
        "\n",
        "\n",
        "@dataclass\n",
        "class RandomAgent:\n",
        "    \"\"\"A random agent that acts randomly and learns nothing.\"\"\"\n",
        "    n_actions: int\n",
        "    name: str = 'RandomAgent'\n",
        "\n",
        "    def __post_init__(self) -> None:\n",
        "        self._build_model()\n",
        "\n",
        "    def _build_model(self) -> None:\n",
        "        \"\"\"Set model function.\"\"\"\n",
        "        self.model = RandomModel(self.n_actions)\n",
        "\n",
        "    def update_model(self, *args, **kwargs) -> None:\n",
        "        \"\"\"No model to update.\"\"\"\n",
        "        pass\n",
        "\n",
        "    def update_experience(self, s: np.ndarray, a: int, \n",
        "                          r: float, d: bool) -> None:\n",
        "        \"\"\"nothing to update\"\"\"\n",
        "        pass\n",
        "\n",
        "    def get_action(self, s: Any, **kwargs) -> int:\n",
        "        return self.model.predict()\n",
        "\n",
        "    def after_episode_update(self) -> None:\n",
        "      pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TCkJ5xrSeWU8"
      },
      "source": [
        "# for 10 episodes\n",
        "'''\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "obs = env.reset()\n",
        "\n",
        "number_of_episodes = 10\n",
        "\n",
        "random_agent = RandomAgent(n_actions=env.action_space.n)\n",
        "\n",
        "\n",
        "ra_reward_history = run_multiple_episodes(env, random_agent, n_episodes=number_of_episodes, \n",
        "                                          n_steps=3000, training=True, pr=True)\n",
        "\n",
        "\n",
        "dqn_reward_history = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "double_dqn_reward_history = run_multiple_episodes(env, doubleDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "\n",
        "plt.plot(ra_reward_history, label='Random')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Random Agent for 10 Episodes')\n",
        "plt.show()\n",
        "\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "print(\"Mean of rewards for {} : Eipsodes : {} for RandomAgent \".format(number_of_episodes, mean(ra_reward_history) ))\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jADzhBIGLj2U"
      },
      "source": [
        "# for 10 episodes\n",
        "\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "obs = env.reset()\n",
        "\n",
        "number_of_episodes = 10\n",
        "\n",
        "dqn_reward_history_3000 = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "dqn_reward_history_5000 = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=5000, training=True, pr=True)\n",
        "\n",
        "dqn_reward_history_10000 = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=10000, training=True, pr=True)\n",
        "\n",
        "dqn_reward_history_20000 = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=20000, training=True, pr=True)\n",
        "\n",
        "'''\n",
        "double_dqn_reward_history = run_multiple_episodes(env, doubleDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "'''\n",
        "\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history_3000, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN-10 Episodes-3000 steps')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(dqn_reward_history_5000, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN-10 Episodes-5000 steps')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(dqn_reward_history_10000, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN-10 Episodes-10000 steps')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(dqn_reward_history_20000, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN-10 Episodes-20000 steps')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN for 3000 steps\".format(number_of_episodes, mean(dqn_reward_history_3000) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN for 5000 steps\".format(number_of_episodes, mean(dqn_reward_history_5000) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN for 5000 steps\".format(number_of_episodes, mean(dqn_reward_history_10000) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN for 20000 steps\".format(number_of_episodes, mean(dqn_reward_history_20000) ))\n",
        "print(\"\\n------------------------------------------------------------\\n\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i38BUfvdb9XI"
      },
      "source": [
        "# for 20 episodes\n",
        "'''\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "obs = env.reset()\n",
        "\n",
        "number_of_episodes = 20\n",
        "\n",
        "dqn_reward_history = run_multiple_episodes(env,baseDQNagent , n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "double_dqn_reward_history = run_multiple_episodes(env,doubleDQNagent , n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN for 10 Episodes')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN for 20 Episodes')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN vs DDQN Agent for 20 Episodes')\n",
        "plt.show()\n",
        "\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "print(\"Mean of rewards for {} Episodes : {} for Base DQN\".format(number_of_episodes, mean(dqn_reward_history) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN\".format(number_of_episodes, mean(double_dqn_reward_history) ))\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pVSxNyDPlpLh"
      },
      "source": [
        "'''\n",
        "import zlib\n",
        "\n",
        "import pickle\n",
        "weights_bytes = zlib.compress(pickle.dumps(baseDQNagent._action_model.get_weights()))\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nZbCBJQPwajb"
      },
      "source": [
        "'''\n",
        "import zlib\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "from tensorflow import keras\n",
        "from typing import List, Tuple, Union, Callable\n",
        "from gfootball.env.wrappers import Simple115StateWrapper\n",
        "\n",
        "class DenseNN:\n",
        "\n",
        "    def __init__(self, observation_shape: List[int], n_actions: int, \n",
        "                 output_activation: Union[None, str] = None,\n",
        "                 unit_scale: int = 1, learning_rate: float = 0.0001, \n",
        "                 opt: str = 'Adam') -> None:\n",
        "        \"\"\"\n",
        "        :param observation_shape: Tuple specifying input shape.\n",
        "        :param n_actions: Int specifying number of outputs\n",
        "        :param output_activation: Activation function for output.\n",
        "        :param unit_scale: Multiplier for all units in FC layers in network \n",
        "                           (not used here at the moment).\n",
        "        :param opt: Keras optimiser to use. Should be string. \n",
        "                    This is to avoid storing TF/Keras objects here.\n",
        "        :param learning_rate: Learning rate for optimiser.\n",
        "\n",
        "        \"\"\"\n",
        "        self.observation_shape = observation_shape\n",
        "        self.n_actions = n_actions\n",
        "        self.unit_scale = unit_scale\n",
        "        self.output_activation = output_activation\n",
        "        self.learning_rate = learning_rate\n",
        "        self.opt = opt\n",
        "\n",
        "    def _model_architecture(self) -> Tuple[keras.layers.Layer, keras.layers.Layer]:\n",
        "        \n",
        "        frame_input = keras.layers.Input(name='input', shape=self.observation_shape)\n",
        "        fc1 = keras.layers.Dense(int(self.observation_shape[0] / 1.5 * self.unit_scale), \n",
        "                                 name='fc1', activation='relu')(frame_input)\n",
        "        fc2 = keras.layers.Dense(int(self.observation_shape[0] / 3 * self.unit_scale), \n",
        "                                 name='fc2', activation='relu')(fc1)\n",
        "        fc3 = keras.layers.Dense(self.n_actions * 2, \n",
        "                                 name='fc3', activation='relu')(fc2)\n",
        "        action_output = keras.layers.Dense(units=self.n_actions, name='output',\n",
        "                                           activation=self.output_activation)(fc3)\n",
        "\n",
        "        return frame_input, action_output\n",
        "\n",
        "    def compile(self, model_name: str = 'model', \n",
        "                loss: Union[str, Callable] = 'mse') -> keras.Model:\n",
        "        \"\"\"\n",
        "        Compile a copy of the model using the provided loss.\n",
        "\n",
        "        :param model_name: Name of model\n",
        "        :param loss: Model loss. Default 'mse'. Can be custom callable.\n",
        "        \"\"\"\n",
        "        # Get optimiser\n",
        "        if self.opt.lower() == 'adam':\n",
        "            opt = keras.optimizers.Adam\n",
        "        elif self.opt.lower() == 'rmsprop':\n",
        "            opt = keras.optimizers.RMSprop\n",
        "        else:\n",
        "            raise ValueError(f\"Invalid optimiser {self.opt}\")\n",
        "\n",
        "        state_input, action_output = self._model_architecture()\n",
        "        model = keras.Model(inputs=[state_input], outputs=[action_output], \n",
        "                            name=model_name)\n",
        "        model.compile(optimizer=opt(learning_rate=self.learning_rate), \n",
        "                      loss=loss)\n",
        "\n",
        "        return model\n",
        "\n",
        "    def plot(self, model_name: str = 'model') -> None:\n",
        "        keras.utils.plot_model(self.compile(model_name), \n",
        "                               to_file=f\"{model_name}.png\", show_shapes=True)\n",
        "        plt.show()\n",
        "\n",
        "tf_mod = DenseNN(observation_shape=(115,), \n",
        "                 # This needs to match the number from training\n",
        "                 unit_scale=0.25,\n",
        "                 n_actions=19).compile()\n",
        "tf_mod.set_weights(pickle.loads(zlib.decompress(weights_bytes)))\n",
        "\n",
        "def agent(obs):\n",
        "\n",
        "    # Use the existing model and obs buffer on each call to agent\n",
        "    global tf_mod\n",
        "\n",
        "    # Convert these to the same output as the Simple115StateWrapper we used in training\n",
        "    obs = Simple115StateWrapper.convert_observation(obs['players_raw'], fixed_positions=False)\n",
        "\n",
        "    # Predict actions from keras model\n",
        "    actions = tf_mod.predict(obs)\n",
        "    action = np.argmax(actions)\n",
        "\n",
        "    return [action]\n",
        "\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVJYkXALxr2k"
      },
      "source": [
        "\"\"\"\n",
        "env :the gym environment\n",
        "agent : the DQN Agent\n",
        "n_steps : total number of steps the model should be run for\n",
        "pr : a boolean flag that decides whether to print \n",
        "training : a boolean flag that decides whether training is true/false\n",
        "\n",
        "returns a tuple of episode_rewards,episode_actions\n",
        "\"\"\"\n",
        "\n",
        "'''\n",
        "def play_single_episode(env: gym.Env, agent, n_steps: int=10, pr: bool=False, \n",
        "                 training:bool=False) -> Tuple[List[float], List[int]]:\n",
        "        \n",
        "    episode_rewards = []\n",
        "    episode_actions = []\n",
        "    \n",
        "    #reset the environment\n",
        "    obs = env.reset()\n",
        "    done = False\n",
        "    \n",
        "    #iterate for n_steps\n",
        "    for s in range(n_steps):\n",
        "        if done:\n",
        "            break\n",
        "\n",
        "        # Select action\n",
        "        action = agent.get_action(obs)\n",
        "        episode_actions.append(action)\n",
        "\n",
        "        # Take action\n",
        "        prev_obs = obs\n",
        "        \n",
        "        #on taking an action, env returns \n",
        "            #observation, \n",
        "            #reward taken by the action, \n",
        "            #whether done is true or false, \n",
        "            #info about the action(scoring reward)\n",
        "        obs, reward, done, info = env.step(action)\n",
        "        episode_rewards.append(reward)\n",
        "\n",
        "        # Update model\n",
        "        if training:\n",
        "            agent.update_experience(s=prev_obs, a=action, \n",
        "                                    r=reward, d=done)\n",
        "            agent.update_model()\n",
        "\n",
        "        if pr:\n",
        "            print(f\"Step {s}: Action taken {action}, \"f\"reward recieved {reward}\")\n",
        "\n",
        "        last_step = s\n",
        "    \n",
        "    if training:\n",
        "        agent.after_episode_update()\n",
        "                  \n",
        "    return episode_rewards, episode_actions\n",
        "                  \n",
        "\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "#print(\"env.action_space.n-=>\\n\",env.action_space.n)\n",
        "agent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),  \n",
        "    eps=EpsilonGreedy(),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               # Setting low value to make it easier to run in notebook\n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n))\n",
        "\n",
        "_ = play_single_episode(env, agent, n_steps=20, pr=True, training=True)\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mzM8ZJUhx4wP"
      },
      "source": [
        "'''\n",
        "def run_multiple_episodes(env: gym.Env, agent, n_episodes: int=10, \n",
        "                          n_steps: int=10, pr: bool=False, \n",
        "                          training:bool=False) -> List[float]:\n",
        "\n",
        "    \n",
        "    total_episode_rewards = []\n",
        "    for ep in range(n_episodes):\n",
        "\n",
        "        episode_rewards, _ = play_single_episode(env, agent, n_steps, \n",
        "                                          pr=False, training=True)\n",
        "\n",
        "        total_episode_rewards.append(sum(episode_rewards))\n",
        "        \n",
        "        if pr:\n",
        "            print(f\"Episode {ep} finished after {len(episode_rewards)} \"\n",
        "                  f\"steps, total reward: {sum(episode_rewards)}\")\n",
        "\n",
        "    \n",
        "    return total_episode_rewards\n",
        "\n",
        "\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "baseDQNagent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),\n",
        "    eps=EpsilonGreedy(eps_initial=0.7),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n))\n",
        "\n",
        "doubleDQNagent = DQNAgent(\n",
        "    replay_buffer=ReplayBuffer(buffer_size=1000),\n",
        "    eps=EpsilonGreedy(eps_initial=0.7),\n",
        "    model_architecture=DenseNN(observation_shape=env.observation_space.shape, \n",
        "                               unit_scale=0.25,\n",
        "                               n_actions=env.action_space.n),\n",
        "    double = True)\n",
        "\n",
        "# Both n_episodes and n_steps need to \n",
        "\n",
        "reward_history = run_multiple_episodes(env, agent, n_episodes=10, \n",
        "                                       # Use 3000 for 90 minute games\n",
        "                                       n_steps=3000,  \n",
        "                                       training=True, pr=True)\n",
        "\n",
        "plt.plot(reward_history)\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.show()\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrmTaB0FdSX3"
      },
      "source": [
        "# for 10 episodes\n",
        "'''\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "obs = env.reset()\n",
        "\n",
        "number_of_episodes = 10\n",
        "\n",
        "dqn_reward_history = run_multiple_episodes(env, baseDQNagent , n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "double_dqn_reward_history = run_multiple_episodes(env, doubleDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN for 10 Episodes')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN for 10 Episodes')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN vs DDQN Agent for 10 Episodes')\n",
        "plt.show()\n",
        "\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "print(\"Mean of rewards for {} Episodes : {} for Base DQN\".format(number_of_episodes, mean(dqn_reward_history) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN\".format(number_of_episodes, mean(double_dqn_reward_history) ))\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O53BVspid2Ay"
      },
      "source": [
        "# for 20 episodes\n",
        "'''\n",
        "env = gym.make(\"GFootball-11_vs_11_kaggle-simple115v2-v0\")\n",
        "obs = env.reset()\n",
        "\n",
        "number_of_episodes = 20\n",
        "\n",
        "dqn_reward_history = run_multiple_episodes(env, baseDQNagent, n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "double_dqn_reward_history = run_multiple_episodes(env,doubleDQNagent , n_episodes=number_of_episodes, \n",
        "                                           n_steps=3000, training=True, pr=True)\n",
        "\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN for 20 Episodes')\n",
        "plt.show()\n",
        "\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='Double DQN for 20 Episodes')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "plt.plot(dqn_reward_history, label='DQN')\n",
        "plt.plot(double_dqn_reward_history, label='Double DQN')\n",
        "plt.xlabel('Episode')\n",
        "plt.ylabel('Reward')\n",
        "plt.legend(title='DQN vs DDQN Agent for 20 Episodes')\n",
        "plt.show()\n",
        "\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "print(\"Mean of rewards for {} Episodes : {} for Base DQN\".format(number_of_episodes, mean(dqn_reward_history) ))\n",
        "print(\"Mean of rewards for {} Episodes : {} for Double DQN\".format(number_of_episodes, mean(double_dqn_reward_history) ))\n",
        "print(\"\\n------------------------------------------------------------\\n\")\n",
        "'''"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}