TensorFlow_Basics.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gsqKM5DLlLRm"
      },
      "source": [
        "# TensorFlow Basics\n",
        "**Autor:** Dimitri Ngatcha Pokouane"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dhw-7EA-10Xm"
      },
      "source": [
        "## Tutorials\n",
        "\n",
        "Some python libraries are required to accomplish the tasks assigned in this homework. If you feel like you need to follow a tutorial before, feel free to do so:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VMyEloGz__BZ"
      },
      "source": [
        "*   [Scikit-learn Tutorials](https://www.tensorflow.org/tutorials)\n",
        "*   [TensorFlow Tutorials](https://scikit-learn.org/stable/tutorial/index.html)\n",
        "*   [Matplotlib Tutorials](https://matplotlib.org/stable/tutorials/index.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ActTWMg4XZ5v"
      },
      "source": [
        "## Imports\n",
        "\n",
        "Jupyter notebook provides the possibility of using libraries, functions and variables globally. This means, once you import the libraries, functions, etc. you won't have to import them again in the next cell. However, if for any reason you end the session (crash, timeout, etc.), then you'll have to run this cell to have your libraries imported again. So, let's go ahead and import whatever we need in this homework assignment."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LArjND15dGNh"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import tensorflow as tf\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gpqN-O0F_atv"
      },
      "source": [
        "## System checks\n",
        "\n",
        "Perform some rudimentary system checks. Do we have a CUDA-capable device? Multiple? Is CuDNN active (huge speedups for some networks)?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b1r5yPHY_hsl",
        "outputId": "31d26d6b-f53d-4b42-a930-f8aee13df6c7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n",
            "[PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU')]\n"
          ]
        }
      ],
      "source": [
        "gpus = tf.config.list_physical_devices('GPU')\n",
        "cpus = tf.config.list_physical_devices('CPU')\n",
        "print(gpus)\n",
        "print(cpus)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UZD5IRFWZX5u"
      },
      "source": [
        "If you see now that now that there is no CUDA-capable device available, you have to activate the GPU.\n",
        "\n",
        "Go to Edit -> Notebook settings -> Select GPU as Hardware accelerator.\n",
        "\n",
        "![notebooksettings.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "olx30IjdagoU"
      },
      "source": [
        "Now check the availability again."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yPmQc7dfyJxd",
        "outputId": "0fb3e3bf-bff6-4478-9c63-f193bd1ab07f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "tf.config.list_physical_devices('GPU')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xreHvfRGyJxe"
      },
      "source": [
        "Choose your device for computation. CPU or one of your CUDA devices"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MMCbCpAFao6q"
      },
      "outputs": [],
      "source": [
        "tf.config.set_visible_devices(gpus, 'GPU')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19m2MBS4yJxe"
      },
      "source": [
        "# Subtask 1.1\n",
        "\n",
        "## Tensors"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yM6iLutHyJxf"
      },
      "source": [
        "Let us create a tensorflow tensor:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LduzSZM0yJxf"
      },
      "outputs": [],
      "source": [
        "a = tf.constant([[1.0, 2.0],\n",
        "                 [3.0, 4.0]])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Ml0JPu7yJxf"
      },
      "source": [
        "and find out what the properties of this tensor 'a' are."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DioY-AxIyJxf",
        "outputId": "60fb562d-a639-439d-8b7b-57a80cbfbaa3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[1. 2.]\n",
            " [3. 4.]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "# TODO print the array\n",
        "print(a)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "slOjDp9zyJxf",
        "outputId": "a4eb7baf-bca0-46ea-98e3-bd64ec8c53a2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tensorflow.python.framework.ops.EagerTensor'>\n"
          ]
        }
      ],
      "source": [
        "# TODO print its type\n",
        "print(type(a))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jTkz6fnayJxg",
        "outputId": "b46e7b13-df01-4af8-ee37-c6214a2d75b1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 2)\n"
          ]
        }
      ],
      "source": [
        "# TODO print its shape\n",
        "\n",
        "print(a.shape)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-G08OyIGyJxg",
        "outputId": "b3927051-8143-4534-d3b5-a9dab4208d3a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1. 2.]\n",
            " [3. 4.]]\n",
            "(2, 2)\n"
          ]
        }
      ],
      "source": [
        "# TODO convert the tensor to a numpy array and print its size again\n",
        "a_np = a.numpy()\n",
        "print(a_np)\n",
        "print(a_np.shape)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-SWYd8oEyJxg"
      },
      "source": [
        "Let's create another tensor and do a few basic math operation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V8X22vjyyJxg",
        "outputId": "480ab161-218e-4441-b7a0-8b56f501a543"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[2. 3.]\n",
            " [4. 5.]], shape=(2, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[1. 2.]\n",
            " [3. 4.]], shape=(2, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[3. 3.]\n",
            " [7. 7.]], shape=(2, 2), dtype=float32) \n",
            "\n"
          ]
        }
      ],
      "source": [
        "b = tf.constant([[1.0, 1.0],\n",
        "                 [1.0, 1.0]]) # Could have also said `tf.ones([2,2])`\n",
        "\n",
        "print(tf.add(a, b), \"\\n\")\n",
        "print(tf.multiply(a, b), \"\\n\")\n",
        "print(tf.matmul(a, b), \"\\n\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YYWKpYL1yJxh",
        "outputId": "342915f1-c40a-49e0-e15a-5b7525fab483"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[2. 3.]\n",
            " [4. 5.]], shape=(2, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[1. 2.]\n",
            " [3. 4.]], shape=(2, 2), dtype=float32) \n",
            "\n",
            "tf.Tensor(\n",
            "[[3. 3.]\n",
            " [7. 7.]], shape=(2, 2), dtype=float32) \n",
            "\n"
          ]
        }
      ],
      "source": [
        "# or\n",
        "print(a + b, \"\\n\") # element-wise addition\n",
        "print(a * b, \"\\n\") # element-wise multiplication\n",
        "print(a @ b, \"\\n\") # matrix multiplication"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxeo4uFbyJxh"
      },
      "source": [
        "Now, let's do the following operations on tensor 'a'.\n",
        "**Note:** Do not convert the tensors to NumPy."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0FMwiBJgyJxh",
        "outputId": "ece8d756-d8de-4eb3-f599-8e1eb45b0f83"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The mean of tensor a: tf.Tensor(2.5, shape=(), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "# TODO compute the mean\n",
        "mean = tf.reduce_mean(a)\n",
        "\n",
        "print(\"The mean of tensor a:\", mean)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1XsvRUdqyJxh",
        "outputId": "ed531c78-ecb6-444d-cb39-2f1a845fa0d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The index of the smallest value in tensor a is: [0 0]\n"
          ]
        }
      ],
      "source": [
        "# TODO find the index of the smallest value\n",
        "index = tf.argmin(a)\n",
        "\n",
        "print(\"The index of the smallest value in tensor a is:\", index.numpy())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1fzOcPlRyJxh",
        "outputId": "53d5f9e7-0ce3-4bc0-e234-5ac404f63cf4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The logarithm of tensor a is:\n",
            "tf.Tensor(\n",
            "[[0.        0.6931472]\n",
            " [1.0986123 1.3862944]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "# TODO compute the log\n",
        "log_a = tf.math.log(a)\n",
        "\n",
        "print(\"The logarithm of tensor a is:\")\n",
        "print(log_a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ndcQm7dDyJxh",
        "outputId": "734d8c15-b5ba-45a1-a6a3-e1d61b50c374"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The value at row 0, column 1 in tensor a: 2.0\n"
          ]
        }
      ],
      "source": [
        "# TODO print out a single value from the tensor\n",
        "value = a[0, 1]\n",
        "\n",
        "print(\"The value at row 0, column 1 in tensor a:\", value.numpy())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_RlTgK80yJxi",
        "outputId": "ec813a23-8157-4131-daae-636a988bffff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reshaped tensor a:\n",
            "tf.Tensor([[1. 2. 3. 4.]], shape=(1, 4), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "# TODO reshape the tensor to a new shape\n",
        "new_shape = [1, 4]\n",
        "reshaped_a = tf.reshape(a, new_shape)\n",
        "\n",
        "print(\"Reshaped tensor a:\")\n",
        "print(reshaped_a)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-L20kYdTyJxi"
      },
      "source": [
        "# Subtask 1.2\n",
        "\n",
        "## Variables\n",
        "A tf.Variable represents a tensor whose value can be changed by running ops on it. Specific ops allow you to read and modify the values of this tensor. Higher level libraries like tf.keras use tf.Variable to store model parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Mul64DEdyJxi"
      },
      "outputs": [],
      "source": [
        "numpyarray = np.arange(10).reshape(2, 5)\n",
        "# create a tensorflow variable\n",
        "a = tf.Variable(numpyarray, dtype=tf.float32)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vz-L0H_MyJxi"
      },
      "source": [
        "\n",
        "**TODO Your answer here**\n",
        "\n",
        "Is tensor 'a' a trainable variable and what does it mean?\n",
        "\n",
        "**Yes, tensor an is a variable, but it is not by default a trainable variable because we did not express it explicitly when we created the variable. Trainable variables are commonly used in TensorFlow to describe model parameters that are learned during training. During training, an optimization algorithm updates these variables in order to minimize the loss function. When generating the variable, we may set the trainable argument to True to create a trainable variable.**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "04E8NmkOyJxi"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s6Iu8fuUyJxi"
      },
      "source": [
        "### Placing variables\n",
        "\n",
        "For better performance, TensorFlow will attempt to place tensors and variables on the fastest device compatible, however, you can override this."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K-ZIVXljyJxj",
        "outputId": "14364132-d0c8-4790-a56f-4c4878a4f240"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[22. 28.]\n",
            " [49. 64.]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "with tf.device('CPU:0'):\n",
        "  # Create some tensors\n",
        "  a = tf.Variable([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n",
        "  b = tf.Variable([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])\n",
        "  c = a @ b\n",
        "\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ojZRoVN5yJxj",
        "outputId": "25e9367e-e7aa-434d-bc3f-c223bbdb4982"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(\n",
            "[[22. 28.]\n",
            " [49. 64.]], shape=(2, 2), dtype=float32)\n"
          ]
        }
      ],
      "source": [
        "# TODO create two tf.variables using device 'CPU:0' and do matrix multiplication on device 'GPU:0'\n",
        "\n",
        "# Create two variables on CPU:0\n",
        "with tf.device('CPU:0'):\n",
        "  a = tf.Variable([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n",
        "  b = tf.Variable([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])\n",
        "\n",
        "# Multiply the variables on GPU:0\n",
        "with tf.device('GPU:0'):\n",
        "  c = tf.matmul(a, b)\n",
        "\n",
        "# Print the result\n",
        "print(c)\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NLCoVFEfyJxj"
      },
      "source": [
        "# Subtask 1.3\n",
        "\n",
        "### Loading the flood dataset"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "jVd0RCaC33Mo",
        "outputId": "82baf9a1-4d08-4386-db32-fe6b5dd114d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-d86332bb-b50e-44db-b70e-de7bc9b3a024\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-d86332bb-b50e-44db-b70e-de7bc9b3a024\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving Flood_Data_Classification.csv to Flood_Data_Classification.csv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "aB4x3AeFyJxj",
        "outputId": "326c474f-7d66-4b16-a45e-3fd44bfbbb11"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      Margarethenklippe  Sennhuette  labels\n",
              "0                   6.5         4.1     0.0\n",
              "1                   6.4         4.1     0.0\n",
              "2                   6.3         3.9     0.0\n",
              "3                   6.3         3.9     0.0\n",
              "4                   6.4         4.1     0.0\n",
              "...                 ...         ...     ...\n",
              "6245                6.9         3.3     0.0\n",
              "6246                6.9         3.4     0.0\n",
              "6247                6.8         3.5     0.0\n",
              "6248                6.7         3.2     0.0\n",
              "6249                6.8         3.1     0.0\n",
              "\n",
              "[6250 rows x 3 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e562b1cb-594d-4086-a01b-f90259c83682\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Margarethenklippe</th>\n",
              "      <th>Sennhuette</th>\n",
              "      <th>labels</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>6.5</td>\n",
              "      <td>4.1</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>6.4</td>\n",
              "      <td>4.1</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>6.3</td>\n",
              "      <td>3.9</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>6.3</td>\n",
              "      <td>3.9</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>6.4</td>\n",
              "      <td>4.1</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6245</th>\n",
              "      <td>6.9</td>\n",
              "      <td>3.3</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6246</th>\n",
              "      <td>6.9</td>\n",
              "      <td>3.4</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6247</th>\n",
              "      <td>6.8</td>\n",
              "      <td>3.5</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6248</th>\n",
              "      <td>6.7</td>\n",
              "      <td>3.2</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6249</th>\n",
              "      <td>6.8</td>\n",
              "      <td>3.1</td>\n",
              "      <td>0.0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>6250 rows × 3 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e562b1cb-594d-4086-a01b-f90259c83682')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e562b1cb-594d-4086-a01b-f90259c83682 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e562b1cb-594d-4086-a01b-f90259c83682');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ],
      "source": [
        "data = pd.read_csv('Flood_Data_Classification.csv')\n",
        "data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-_q59ypyJxk"
      },
      "source": [
        "# Subtask 1.4\n",
        "\n",
        "### Inspect the data\n",
        "Let us plot the data for each of the variables and color them based on the labels:\n",
        "\n",
        "**Note:** Do not forget to add title, axis labels and a legend!\n",
        "This applies in general, please keep in mind for future exercise sheets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "IZQF8_JiyJxk",
        "outputId": "0d661ef9-a824-4360-c87d-2d5519f660a5"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots(2, 1, figsize=(8, 5), sharex=True)\n",
        "\n",
        "ax[0].plot(np.where(data['labels']==0, data['Margarethenklippe'], None), color='tab:blue', label='Normal')\n",
        "\n",
        "# TODO fill in the missing lines ...\n",
        "ax[0].plot(np.where(data['labels']!=0, data['Margarethenklippe'], None), color='tab:red', label='Flood warning')\n",
        "ax[0].set_xlabel('influence variable')\n",
        "ax[0].set_ylabel('Sennhuette')\n",
        "ax[0].set_yticks(np.arange(0, max(data['Margarethenklippe'])+25, 25))\n",
        "ax[0].set_title('Flood_Data_Classification')\n",
        "ax[0].legend()\n",
        "ax[1].plot(np.where(data['labels']==0, data['Sennhuette'], None), color='tab:blue', label='Normal')\n",
        "ax[1].plot(np.where(data['labels']!=0, data['Sennhuette'], None), color='tab:red', label='Flood warning')\n",
        "ax[1].set_xlabel('influence variable')\n",
        "ax[1].set_ylabel('Margarethenklippe')\n",
        "ax[1].set_yticks(np.arange(0, max(data['Margarethenklippe'])+25, 25))\n",
        "ax[1].legend()\n",
        "\n",
        "plt.show()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vw7Wo9O-yJxk"
      },
      "source": [
        "Moreover, it is beneficial to plot the pairwise correlation of the variables to see how they are correlated.\n",
        "\n",
        "**Note:** Do not forget to add title, axis labels and a legend!\n",
        "This applies in general, please keep in mind for future exercise sheets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "YxdQt8oQyJxk",
        "outputId": "f2566ed9-c020-402b-c72a-ef1b8608f56a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# TODO fill in the missing lines\n",
        "# TODO plot the correlation matrix using pyplot.imshow\n",
        "corr = data.corr()\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "im = ax.imshow(corr, cmap='coolwarm')\n",
        "\n",
        "# Show all ticks and label them with the respective list entries\n",
        "ax.set_xticks(range(len(corr.columns)))\n",
        "ax.set_yticks(range(len(corr.columns)))\n",
        "ax.set_xticklabels(corr.columns)\n",
        "ax.set_yticklabels(corr.columns)\n",
        "\n",
        "# Add colorbar\n",
        "cbar = ax.figure.colorbar(im, ax=ax)\n",
        "\n",
        "# Set axis labels and title\n",
        "ax.set_title(\"Correlation Matrix\")\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Py7Kph-8yJxk"
      },
      "source": [
        "Another interesting plot that may give you a good understanding about the complexity of the dataset is the pairwise relationships. We can use *seaborn* library as below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 775
        },
        "id": "3OdLxLIGyJxl",
        "outputId": "ad21869f-6933-41f8-d661-80bf2a9ab86b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<seaborn.axisgrid.PairGrid at 0x7ff206d6f610>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 750x750 with 12 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAugAAALlCAYAAACWxBNOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC5eUlEQVR4nOzdeXwTZf4H8M/kTtomPUJbCgUKrQoUsMKC2GM9WDkURLvugqgcLroq6oqugAsieIDHui6I688DWFdRd5fDVVd2ERQKi4gcFuSQYrFgKdAjSdPcyfz+KI1Nm15p0qTt5/165QWZmWS+k/aZ+fbJM99HEEVRBBERERERRQRJuAMgIiIiIqKfMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIiogjCBJ2IiIiIKIIwQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEHYAoijCZTOCcTUThwTZIFF5sg0SRhQk6gOrqauh0OlRXV4c7FKJuiW2QKLzYBokiCxN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIioggiC3cARERE1DKjxYFyswMmmxNatRz6KAV0GkW4wyLqNjqyDTJBJyIiinClBivmrS9EwYly77K8DD2W5w9FSqw6jJERdQ8d3QY5xIWIiCiCGS2ORokBAOw4UY756wthtDjCFBlR9xCONsgEnYiIKIKVmx2NEoM6O06Uo9zMBJ0olMLRBpmgExERRTCTzdns+uoW1hNR+4SjDTJBJyIiimBalbzZ9TEtrCei9glHG2SCTkREFMH00QrkZej9rsvL0EMfzUouRKEUjjYY1gR9x44dmDhxIlJSUiAIAjZt2uSzfsaMGRAEwecxbtw4n20qKysxbdo0aLVaxMbG4q677oLZbO7AoyAiIgodnUaB5flDGyUIeRl6PJc/lKUWiUIsHG0wrGUWa2pqMGzYMMyaNQu33HKL323GjRuHNWvWeJ8rlUqf9dOmTcPZs2exZcsWOJ1OzJw5E3fffTfWrVsX0tiJiIg6SkqsGiunZqHc7EC1zYkYlRz6aNZBJ+ooHd0Gw5qgjx8/HuPHj292G6VSieTkZL/rjh49is2bN2Pv3r0YMWIEAGDlypWYMGECXnzxRaSkpAQ9ZiIionDQaZiQE4VTR7bBiB+D/sUXXyAxMRGXXnop7r33XlRUVHjX7d69G7Gxsd7kHADGjBkDiUSCPXv2NPmedrsdJpPJ50FEHYdtkCi82AaJIltEJ+jjxo3D22+/ja1bt+K5557D9u3bMX78eLjdbgBAWVkZEhMTfV4jk8kQHx+PsrKyJt932bJl0Ol03kdqampIj4OIfLENEoUX2yBRZIvoBH3KlCmYNGkShgwZgsmTJ+Pjjz/G3r178cUXX7TrfRcsWACj0eh9nD59OjgBE1GrsA0ShRfbIFFkC+sY9Lbq378/9Ho9ioqKcN111yE5ORnnz5/32cblcqGysrLJcetA7bj2hjebElHHYRuk9jBaHCg3O2CyOaFVy6GP4tjstmIbJGq7jjz3dKoE/cyZM6ioqEDPnj0BAKNHj4bBYMC+ffswfPhwAMC2bdvg8XgwatSocIZKREQhUGqwYt76Qp9pt/My9FiePxQpseowRkZEXVlHn3vCOsTFbDbj4MGDOHjwIACguLgYBw8eRElJCcxmM37/+9/jyy+/xKlTp7B161bcdNNNSE9Px9ixYwEAAwcOxLhx4zB79mx89dVX2LVrF+bMmYMpU6awggsRURdjtDgaXSABYMeJcsxfXwijxRGmyIioKwvHuSesCfrXX3+NrKwsZGVlAQDmzp2LrKwsPPHEE5BKpSgsLMSkSZNwySWX4K677sLw4cNRUFDg87Xcu+++i8suuwzXXXcdJkyYgJycHLz++uvhOiQiIgqRcrOj0QWyzo4T5Sg3M0EnouALx7knrENcrr76aoii2OT6//znPy2+R3x8PCclIiLqBkw2Z7Prq1tYT0QUiHCceyK6igsREVEdrUre7PqYFtYTEQUiHOceJuhERNQp6KMVyMvQ+12Xl6GHPpqVXIgo+MJx7mGCTkREnYJOo8Dy/KGNLpR5GXo8lz+UpRaJKCTCce4RxOYGgXcTJpMJOp0ORqMRWq023OEQdTtsg9QWdbWIq21OxKjk0EezDnp7sQ0Stawjzz2dqg46ERGRTsOEnIg6XkeeezjEhYiIiIgogjBBJyIiIiKKIEzQiYiIiIgiCBN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIiogjCBJ2IiIiIKIIwQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEnYiIiIgogjBBJyIiIiKKIEzQiYiIiIgiCBN0IiIiIqIIwgSdiIiIiCiChDVB37FjByZOnIiUlBQIgoBNmzZ51zmdTsybNw9DhgxBVFQUUlJScOedd6K0tNTnPfr16wdBEHwey5cv7+AjISIiIiIKjoATdIPBgDfffBMLFixAZWUlAGD//v348ccfW/0eNTU1GDZsGFatWtVoncViwf79+7Fo0SLs378fGzZswPHjxzFp0qRG2y5duhRnz571Ph544IFAD4uIiIiIKKxkgbyosLAQY8aMgU6nw6lTpzB79mzEx8djw4YNKCkpwdtvv92q9xk/fjzGjx/vd51Op8OWLVt8lr3yyisYOXIkSkpK0KdPH+/ymJgYJCcnB3IoREREREQRJaAe9Llz52LGjBk4ceIEVCqVd/mECROwY8eOoAXXkNFohCAIiI2N9Vm+fPlyJCQkICsrCy+88AJcLlez72O322EymXweRNRx2AaJwottkCiyBZSg7927F/fcc0+j5b169UJZWVm7g/LHZrNh3rx5mDp1KrRarXf5gw8+iPfffx+ff/457rnnHjz77LN47LHHmn2vZcuWQafTeR+pqakhiZmI/GMbJAovtkGiyCaIoii29UWJiYn4z3/+g6ysLMTExOCbb75B//79sWXLFsyaNQunT59ueyCCgI0bN2Ly5MmN1jmdTuTn5+PMmTP44osvfBL0hlavXo177rkHZrMZSqXS7zZ2ux12u9373GQyITU1FUajsdn3JqLgYBskCi+2QaLIFtAY9EmTJmHp0qX4+9//DqA2uS4pKcG8efOQn58f1ACdTid+9atf4YcffsC2bdtaPHGMGjUKLpcLp06dwqWXXup3G6VS2WTyTkShxzZIFF5sg0SRLaAhLn/84x9hNpuRmJgIq9WKn//850hPT0dMTAyeeeaZoAVXl5yfOHECn332GRISElp8zcGDByGRSJCYmBi0OIiIiIiIOkpAPeh1FVZ27tyJwsJCmM1mXHHFFRgzZkyb3sdsNqOoqMj7vLi4GAcPHkR8fDx69uyJX/7yl9i/fz8+/vhjuN1u7/j2+Ph4KBQK7N69G3v27ME111yDmJgY7N69Gw8//DBuv/12xMXFBXJoRERERERhFdAY9GD54osvcM011zRaPn36dDz55JNIS0vz+7rPP/8cV199Nfbv34/77rsPx44dg91uR1paGu644w7MnTu3TV/dmUwm6HQ6jr0jChO2QaLwYhskiiwB9aADwNatW/GnP/0JR48eBQAMHDgQv/vd79rUi3711Vejub8PWvrb4YorrsCXX37Z6v0REREREUW6gMagv/rqqxg3bhxiYmLw0EMP4aGHHoJWq8WECRP8zgpKREREREStE9AQl969e2P+/PmYM2eOz/JVq1bh2WefxY8//hi0ADsCv9ojCi+2QaLwYhskiiwB9aAbDAaMGzeu0fLrr78eRqOx3UEREREREXVXASXokyZNwsaNGxst//DDD3HjjTe2OygiIiIiou4qoJtEBw0ahGeeeQZffPEFRo8eDQD48ssvsWvXLjzyyCNYsWKFd9sHH3wwOJESEREREXUDAY1Bb6r8YaM3FwR8//33bQ6qo3HsHVF4sQ0ShRfbIFFkCagHvbi4ONhxEBERERERAhyDXp8oii3WKyciIiIiotYJOEF/6623kJmZCZVKBZVKhczMTLz55pvBjI2IiIiIqNsJaIjLE088gZdeegkPPPCA9ybR3bt34+GHH0ZJSQmWLl0a1CCJiIiIiLqLgG4S7dGjB1asWIGpU6f6LH/vvffwwAMPoLy8PGgBdgTeHEMUXmyDROHFNkgUWQIa4uJ0OjFixIhGy4cPHw6Xy9XuoIiIiIiIuquAEvQ77rgDf/nLXxotf/311zFt2rR2B0VERERE1F0FNAYdqL1J9L///S+uvPJKAMCePXtQUlKCO++8E3PnzvVu99JLL7U/SiIiCgujxYFyswMmmxNatRz6KAV0GkW4wyIi6nAdeT4MKEE/fPgwrrjiCgDAyZMnAQB6vR56vR6HDx/2bicIQhBCJCKicCg1WDFvfSEKTvx0X1Fehh7L84ciJVYdxsiIiDpWR58PA7pJtKvhzTFE4cU2GHmMFgfmvHfA52JUJy9Dj5VTswCAvetdBNsgUdNacz4M9rkv4CEuRETUdZWbHX4vRgCw40Q5ykw2PP3JUfauE1GX19L5sNzsCF+Cfsstt2Dt2rXQarW45ZZbmt12w4YN7Q6MiIjCx2RzNrv+TJW10QVrx4lyzF9fGJLeJCKicDFaHS2sb/58GYhWJ+g6nc47plyn0wU9ECIiihxalTyg14WqN4mIKFw0iubTZY1CGvR9tjpBX7Nmjd//ExFR16OPViAvQ48dfr7Wzc3Q48BpQ5OvrW6h952IqDORSARkpydgV1FFo3XZ6QmQSoJfFCWgOuhERNS16TQKLM8firwMvc/yvAw9nropE6t3Fjf52pgAe9+JiCKRTCJgZnYastMTfJZnpydgZnZaSBL0VvegZ2Vltbps4v79+1u13Y4dO/DCCy9g3759OHv2LDZu3IjJkyd714uiiMWLF+ONN96AwWBAdnY2/vKXvyAjI8O7TWVlJR544AF89NFHkEgkyM/Px5///GdER0e39tCIiMiPlFg1Vk7NQrnZgWqbEzEqOfTRtUNXRvSN89u7npeh925DRNQVJEQpsOzfR5HVJw6zstNgd3mglElw4LQBH3xVghdvHRb0fbY6Qa+fOAdLTU0Nhg0bhlmzZvm98fT555/HihUr8Ne//hVpaWlYtGgRxo4diyNHjkClUgEApk2bhrNnz2LLli1wOp2YOXMm7r77bqxbty7o8RIRdTc6jf/Sicvzh2L++kKfJD0vQ4/n8ody/DkRdSk6jQJLbsrE/PWFeGVbkXd5KM95Qa+DLopiQBMUCYLg04MuiiJSUlLwyCOP4NFHHwUAGI1GJCUlYe3atZgyZQqOHj2KQYMGYe/evRgxYgQAYPPmzZgwYQLOnDmDlJSUVu2b9V+JwottsHOqm1Wvfu86k/POiW2QqGUdec4LaAz6Cy+84He52+3Gbbfd1q6A6hQXF6OsrAxjxozxLtPpdBg1ahR2794NANi9ezdiY2O9yTkAjBkzBhKJBHv27AlKHERE5J9Oo8CAxGhc3icOAxKjmZwTUZfWkee8gCYqeuGFFxAfH4+77rrLu8ztdmPKlCk4fPhwUAIrKysDACQlJfksT0pK8q4rKytDYmKiz3qZTIb4+HjvNv7Y7XbY7Xbvc5PJFJSYiah12AaJwottkCiyBdSD/sknn+DRRx/FP//5TwCAy+XCrbfeim+//Raff/55UAMMhWXLlkGn03kfqamp4Q6JqFthGyQKL7ZBosgWUIL+s5/9DOvXr8esWbPwr3/9C/n5+Th+/Dg+//xzJCcnByWwuvc5d+6cz/Jz58551yUnJ+P8+fM+610uFyorK5uNY8GCBTAajd7H6dOngxIzEbUO2yBReLENEkW2gOugX3vttXj77beRn5+P4uJibN++vdFwlPZIS0tDcnIytm7d6l1mMpmwZ88ejB49GgAwevRoGAwG7Nu3z7vNtm3b4PF4MGrUqCbfW6lUQqvV+jyIqOOwDRKFF9sgUWRr9Rh0f2UQAaBHjx6IjY3F3Xff7V22YcOGVr2n2WxGUdFP5WqKi4tx8OBBxMfHo0+fPvjd736Hp59+GhkZGd4yiykpKd5KLwMHDsS4ceMwe/ZsvPbaa3A6nZgzZw6mTJnS6gouRERERESRpNUJuk6n87t87NixAe/866+/xjXXXON9PnfuXADA9OnTsXbtWjz22GOoqanB3XffDYPBgJycHGzevNlbAx0A3n33XcyZMwfXXXedd6KiFStWBBwTEREREVE4Bb0OemfE+q9E4cU2SBRebINEkSXgMehERERERBR8ASXo586dwx133IGUlBTIZDJIpVKfBxERERERBSagiYpmzJiBkpISLFq0CD179oQgCMGOi4iIiIioWwooQd+5cycKCgpw+eWXBzkcIiIiIqLuLaAhLqmpqeC9pUREREREwRdQgv7yyy9j/vz5OHXqVJDDISIiIiLq3gIa4vLrX/8aFosFAwYMgEajgVwu91lfWVkZlOCIiIiIiLqbgBL0l19+OchhEBEREREREGCCPn369GDHQUREREREaMdERSdPnsTChQsxdepUnD9/HgDw6aef4ttvvw1acERERERE3U1ACfr27dsxZMgQ7NmzBxs2bIDZbAYAfPPNN1i8eHFQAyQiIiIi6k4CStDnz5+Pp59+Glu2bIFCofAuv/baa/Hll18GLTgiIiIiou4moDHohw4dwrp16xotT0xMRHl5ebuDIiKi9jFaHCg3O2CyOaFVy6GPUkCnUbT8QiIi8qsjz6sBJeixsbE4e/Ys0tLSfJYfOHAAvXr1CkpgREQUmFKDFfPWF6LgxE8dJnkZeizPH4qUWHUYIyMi6pw6+rwa0BCXKVOmYN68eSgrK4MgCPB4PNi1axceffRR3HnnncGOkYiIWslocTS6iADAjhPlmL++EEaLI0yRERF1TuE4rwaUoD/77LO47LLLkJqaCrPZjEGDBiEvLw9XXXUVFi5cGOwYiYiolcrNjkYXkTo7TpSj3MwEnYioLcJxXg1oiItCocAbb7yBRYsW4fDhwzCbzcjKykJGRkaw4yMiojYw2ZzNrq9uYT0REfkKx3k1oAS9Tp8+fdCnT59gxUJERO2kVcmbXR/TwnoiIvIVjvNqQAm62+3G2rVrsXXrVpw/fx4ej8dn/bZt24ISHBERtY0+WoG8DD12+Pk6Ni9DD300K7kQEbVFOM6rAY1Bf+ihh/DQQw/B7XYjMzMTw4YN83kQEVF46DQKLM8firwMvc/yvAw9nssfylKLRERtFI7zqiCKotjWF+n1erz99tuYMGFC0AMKB5PJBJ1OB6PRCK1WG+5wiLodtsHgq6vXW21zIkYlhz6addCpaWyDRC3ryPNqwDeJpqenBzsWIiIKEp2GCTkRUTB15Hk1oCEujzzyCP785z8jgM73NuvXrx8EQWj0uP/++wEAV199daN1v/3tb0MeFxFRZ2C0OHDyvBkHSqpw8oKZddCJiALUkefTVveg33LLLT7Pt23bhk8//RSDBw+GXO579+qGDRuCEx2AvXv3wu12e58fPnwYv/jFL3Drrbd6l82ePRtLly71PtdoNEHbPxFRZ8UZRYmIgqOjz6etTtB1Op3P85tvvjnowfjTo0cPn+fLly/HgAED8POf/9y7TKPRIDk5uUPiISLqDFqa+W7l1CwOgSEiaoVwnE9bnaCvWbMmqDsOhMPhwDvvvIO5c+dCEATv8nfffRfvvPMOkpOTMXHiRCxatKjZXnS73Q673e59bjKZQho3EfliGwy91sx8xwS9+2IbJGq9cJxPAxqDfu2118JgMDRabjKZcO2117Y3piZt2rQJBoMBM2bM8C677bbb8M477+Dzzz/HggUL8Le//Q233357s++zbNky6HQ67yM1NTVkMRNRY2yDoccZRak5bINErReO82lAZRYlEgnKysqQmJjos/z8+fPo1asXnM7QnPjHjh0LhUKBjz76qMlttm3bhuuuuw5FRUUYMGCA32389RykpqayvBRRB2EbDL2T58247qXtTa7fOvfnGJAY3YERUSRhGyRqvXCcT9tUZrGwsND7/yNHjqCsrMz73O12Y/PmzejVq1fwoqvnhx9+wGeffdbiDaijRo0CgGYTdKVSCaVSGfQYiah12AZDjzOKUnPYBolaLxzn0zYl6Jdffrm3lKG/oSxqtRorV64MWnD1rVmzBomJibjhhhua3e7gwYMAgJ49e4YkDiKizqBu5rv56wt9Liq5GXo8e/MQjj8nImqlps6noZxJtE0JenFxMURRRP/+/fHVV1/5VFhRKBRITEyEVCoNepAejwdr1qzB9OnTIZP9FPLJkyexbt06TJgwAQkJCSgsLMTDDz+MvLw8DB06NOhxEBF1Jimxaiy7ZQh+qLDAYHVCKZPgwGkDlnz0LZbclMlSi0RErSQAGD+kJ6Zf1Q92lwdKmQTnq+0tvi5QbUrQ+/btC6A2Ye5In332GUpKSjBr1iyf5QqFAp999hlefvll1NTUIDU1Ffn5+Vi4cGGHxkdEFImMFgfmbzjkt/qA3cVSi0RErWG0OPCYnzKLQG0veljLLDb0t7/9Da+99hqKi4uxe/du9O3bF3/605/Qv39/3HTTTcGMEddff73fWUtTU1OxfXvTg/aJiLqzlkqDVdQ4vNuZbE5o1XLoozpuKmsios6g3OzAvh+qMOfadGSlxsLu8kAll2J/SRVW7ywOSZnFgBL0v/zlL3jiiSfwu9/9Ds8884x3ps+4uDi8/PLLQU/QiYio7ZorDaZRSCECmPPeAc40SkTUDLPdiRVTs7BmVzFe2VbkXZ6dnoAVU7NQYw9+9cKA6qCvXLkSb7zxBv7whz/4jDkfMWIEDh06FLTgiIgocFqVvMl1s3LS8OSHh5ucGc9ocYQ6PCKiTiFWrcCaXcXYVVThs3xXUQXW7CqGTh38bx0DStCLi4uRlZXVaLlSqURNTU27gyIiovarKw3mz+j+CShocLGpUzczHhERAQ63p1FyXmdXUQUc7uDfmxlQgp6WluYtZ1jf5s2bMXDgwPbGREREQaDTKPDszUOQk57gszw7PQFSQWj2tZxplIioVkvnw2qbK+j7DGgM+ty5c3H//ffDZrNBFEV89dVXeO+997Bs2TK8+eabwY6RiIjayGhxoNzsQKXFgYd/cSkeGyfgrNEGmUTAgdMGWJzuZl8f08zwGCKi7kSjkEGjkGJWTprfm0Q1iuCXGA8oQf/Nb34DtVqNhQsXwmKx4LbbbkNKSgr+/Oc/Y8qUKcGOkYiI2qDUYMW8BiXBstMTMDM7DQ+8dwAWhxtzrk1HdnqC369tOdMoEdFPpFIBb00fgVc+L2p0k+hb00dAJm3+G8lAtDlBd7lcWLduHcaOHYtp06bBYrHAbDYjMTEx6MEREVHT6nrJ65dIBNAoOQfgTcRn5aThlW1FWL2zGCumZkEiCI2quIRqZjwios5IIZXgrYLvkdUnDrOy03x60N8qKMaiiYOCvs82J+gymQy//e1vcfToUQCARqOBRqMJemBERNQ0f73keRl6LL0pE/t+qPL7ml1FFZiVnQYAsDjc+OCrErx46zCYbS5U25yIUcmhj2YddCKi+pxuD6aM6uu3zOLM7DQ4I+Um0ZEjR+LAgQPBjoWIiFrBaHH47SXfcaIciz48jFk5aU2+1u6qvZDUJfNJWhUGJEbj8j5xGJAYzeSciKgBj4hmyyz6mUuz3QIag37ffffhkUcewZkzZzB8+HBERUX5rB86dGhQgiMiosaamyG04EQ5ZlzVr8nX9kvQYOvcn7OnnIiolTwesdkyi25P8DP0gBL0uhtBH3zwQe8yQRAgiiIEQfDOLEpERMHX3AyhzcnL0KNXrJqJORFRG1gczZdRtDiCn/cGlKAXFxcHOw4iImql5mYIBYDecWrkZeixgzd/EhG1W0szherUwS9LG1CC3rdv32DHQURErVQ3Q+gOP8Nc8jL0SNaqsHJqFsrNDt78SUTUTi2dc0NRljagBL3OkSNHUFJSAofDd0roSZMmtSsoIiJqmk6jwPL8oZi/vrDZXnIm5ERE7dfac24wCaLY9ntPv//+e9x88804dOiQd+w5UDsOHUCnG4NuMpmg0+lgNBqh1WrDHQ5Rt8M2GJi6OujsJaf2YhskallHnnMD6kF/6KGHkJaWhq1btyItLQ1fffUVKioq8Mgjj+DFF18MdoxEROSHTsOEnIioo3TkOTegBH337t3Ytm0b9Ho9JBIJJBIJcnJysGzZMjz44IOskU5EREREFKCAJipyu92IiYkBAOj1epSWlgKovXn0+PHjwYuOiIiIiKibCagHPTMzE9988w3S0tIwatQoPP/881AoFHj99dfRv3//YMdIRERERNRtBJSgL1y4EDU1NQCApUuX4sYbb0Rubi4SEhLwwQcfBDVAIqLuou4GJJPNCa1aDn0Ux5gTEUWKjjxHB5Sgjx071vv/9PR0HDt2DJWVlYiLi/NWciEiotYrNVgxb30hChqU8FqePxQpseowRkZERB19jg5oDLo/8fHxQU/On3zySQiC4PO47LLLvOttNhvuv/9+JCQkIDo6Gvn5+Th37lxQYyCizsNoceDkeTMOlFTh5AUzjBZHyy+KAEaLo9GJHwB2nCjH/PWFneY4iIi6IqPFgSc+PIxhqbF4a/oIvDrtCqye8TMMTY3F4g8Ph+QcHVAP+s033+w3GRcEASqVCunp6bjttttw6aWXtjvAwYMH47PPPvM+l8l+Cvnhhx/GJ598gn/84x/Q6XSYM2cObrnlFuzatavd+yWizqUz90CXmx2NkvM6O06Uo9zs4FAXIqIwqahxYMrIPlizqxivbCvyLs9OT8DM7DRU1AT/HB1QD7pOp8O2bduwf/9+b8/2gQMHsG3bNrhcLnzwwQcYNmxYUBJlmUyG5ORk70Ov1wMAjEYj3nrrLbz00ku49tprMXz4cKxZswb/+9//8OWXX7Z7v0TUeXT2HmiTzdns+uoW1hMRUei4PCLW7CrGrqIKn+W7iiqwZlcx3J42z/nZooAS9OTkZNx22234/vvvsX79eqxfvx4nT57E7bffjgEDBuDo0aOYPn065s2b1+4AT5w4gZSUFPTv3x/Tpk1DSUkJAGDfvn1wOp0YM2aMd9vLLrsMffr0we7du9u9XyLqPFrTAx3JtCp5s+tjWlhPRESh4/GIjZLzOruKKkKSoAc0xOWtt97Crl27IJH8lN9LJBI88MADuOqqq/Dss89izpw5yM3NbVdwo0aNwtq1a3HppZfi7NmzWLJkCXJzc3H48GGUlZVBoVAgNjbW5zVJSUkoKytr9n3tdjvsdrv3uclkalecRNQ2wW6Dnb0HWh+tQF6GHjv8/JGRl6GHPprDWyi4eB0kaj2Lw9XCenfQ9xlQD7rL5cKxY8caLT927Bjc7togVSpVu28aHT9+PG699VYMHToUY8eOxb///W8YDAb8/e9/b9f7Llu2DDqdzvtITU1t1/sRUdsEuw129h5onUaB5flDkZeh91mel6HHc/lDOf6cgo7XQaLW06mbPwfr1MG/xgTUg37HHXfgrrvuwuOPP46f/exnAIC9e/fi2WefxZ133gkA2L59OwYPHhy8SAHExsbikksuQVFREX7xi1/A4XDAYDD49KKfO3cOycnJzb7PggULMHfuXO9zk8nEkxNRBwp2G+wMPdAt1c9NiVVj5dQslJsdqLY5EaOSQx/NOugUGrwOErVeOK4xASXof/rTn5CUlITnn3/eW9YwKSkJDz/8sHfc+fXXX49x48YFL1IAZrMZJ0+exB133IHhw4dDLpdj69atyM/PBwAcP34cJSUlGD16dLPvo1QqoVQqgxobEbVesNtgXQ/0/PWFPifQSOmBbm2FGZ2GCTl1DF4HiVpPp1Hg6cmZeHzjIeysNxY9Jz0BT0/ODMl5WxBFsU0j210uF9atW4exY8ciKSnJO25Nq9UGPbhHH30UEydORN++fVFaWorFixfj4MGDOHLkCHr06IF7770X//73v7F27VpotVo88MADAID//e9/bdqPyWSCTqeD0WgMyXEQUfOC1QbreqnD2QPdsKc8WinDHzYewmdHzzfaNjdDjxdvHYYkrapDYyRqiNdBoqYZLQ48vvEQbrmiNxK1SphtbkSrZDhvsmHj/jN45uYhQb/WtLkHXSaT4be//S2OHj0KIDSJeZ0zZ85g6tSpqKioQI8ePZCTk4Mvv/wSPXr0AFDbky+RSJCfnw+73Y6xY8fi1VdfDVk8RBTZwt0D7a+nPDdDj+lX9cP/TlY0upGo4EQ5yqvt8HhE9IzwWu1ERN1VRY0DN1/RG6sblFoMZR30gIa4jBw5EgcOHEDfvn2DGkxD77//frPrVSoVVq1ahVWrVoU0DiKiljRVi73gRDk8oohZOWk+E1zUKTPZUPijERMykzm8hYgoAjndnibroAPAEzcOCvo+A0rQ77vvPjzyyCM4c+YMhg8fjqioKJ/1Q4cODUpwRESdRXO12HcVVWBWdlqTr02MUXK2UCKiCOUR0Wwd9BCUQQ8sQZ8yZQoA4MEHH/QuEwQBoihCEARvqUUiou6ipVrsLo+IOdemIys1FnaXByq5FGVGKw6XGpGRGBPxtdqJiLqrGrsLGoUUs3LSfM7h+0uqsHpnMWrszddJD0RACXpxcXGw4yAi6tSaq8WuUUgxQB+Ft3ef8hnmkpuux8ycfpBAiPha7URE3VW0SoYVU7OwZlexzzk8Oz0BK6ZmIVoVUDrdrIDeMdRjz4mIOpvm6uQuumEglnz0baOvSAuKyiFCxJxrMyKiVjsRETWmkUubHIMuAHj25iFB32e7Uv4jR46gpKQEDofDZ/mkSZPaFRQRUWf01ORMLNx4GAVFPyXp2ekJyOytw4KNh/2+ZmdRBRbdOIjjz4mIIpTV6W5yDPrOogpYncEf2h1Qgv7999/j5ptvxqFDh7xjz4HacegAOAadiLoNo8WBMpMNJqsLgAe/H3cpHhMug9nmglYlg0IuwalyS7PvUWPnOZOIKFKZrM2PQTfZImQM+kMPPYS0tDRs3boVaWlp+Oqrr1BRUYFHHnkEL774YrBjJCKKSGcqLViwoRD7Sgy45+f9MX5wTzz18bcoaDDT3JJJmdAopI3qoNfRKKQdFTIREbVRjLr5MegxIRiDLgnkRbt378bSpUuh1+shkUggkUiQk5ODZcuW+VR2ISLqDIwWB06eN+NASRVOXjDDaHG0uP2pC2YUnLiAu3L6Y+N9VyExWoklDZJzoPbrzyc/+hYLbxjo972y0xMglQhBOxYiIgquqGbGoK/dVYwoefA7WQJK0N1uN2JiYgAAer0epaWlAGpvHj1+/HjwoiMiCrFSgxVz3juA617ajptf/R+u++N2PPDeAZQarH63P2uw4r/fnoPN5UGiVoWEaCWe+vgIErWqJscoFpwox7DeschNT/BZXjcLHRN0IqLIVdPCGPSaSBmDnpmZiW+++QZpaWkYNWoUnn/+eSgUCrz++uvo379/sGMkIgqJpmb/3HGiHPPXF2Ll1CzvzZtGiwMXzHZ4PMC/vvkRv19fCABYO+NnuLxPHHrEKPF/dwxHr1g1AMDicHu/9rQ53ZBJBTw+YSDOmuywOd1QyiQ4cNqAD74qwYu3DuvAoyYioraotrpwSWI0Vt1+BVxuESarE1q1HDKpgPvf2Y9qa4SMQV+4cCFqamoAAEuWLMHEiRORm5uLhIQEvP/++0ENkIgoVJqb/XPHiXLv7J6lBiue+PAwpo7sA5Vciqmj+mJmTn8c+tGAnrEqHNhZe6PQK7dl4blPj/oMc6nrJV/1eQnuzuuPOev2e8ei52Xo8Vz+UFZwISKKYLooKV6/cwT+sOmQT096TnoCXr9zBBye4CfoglhXgqWdKisrERcX563k0pmYTCbodDoYjUZotdpwh0PU7YSrDR4oqcLNr/6vyfWb7rsKKbFqVJjtgCCg1GCFIAjeO/cX3jAQnx46i6Nl1Vg942eQCgJMNhdiVDKcM9kwb30hys0OZKcnIKtPHL45bcDSSYNhtDoRo5JDH61gck4RgddBoqadrqjBs58exS+HpyJRq4TZ5vae59fvO40F4wciNSEqqPtsUw/6rFmzWrXd6tWrAwqGiKgjNTf7JwBolFJ8f8GMVz4vws56vSbjM5Pw4ZxsON0i+veIRpxGDrdHxOkqK+RSCXadLMfRUiPe/c2VmPbml9hVVIFZ2Wl4ZVsRrE43Lu8TF+pDIyKiILG43Jh7/aW1nTX1RCmlePj6S2FxhXkM+tq1a9G3b19kZWUhSB3vRERh09zsn2MGJkIplcIjAreN6otZOf2xv6QKHx74Eb8bcyme/JfvzKB1Q1nmrNuPrD6xmJmdhuc3H8Vz+UNx11+/ht3lAYAmSy0SEVFkUkkkcIoiVm4rajTE5clJg6GSBFRzpVltStDvvfdevPfeeyguLsbMmTNx++23Iz4+PuhBERF1BJ1GgeX5QzF/faFPkn7DkGT8fuxlOGu0Qq2QIkYtR1WNA9kD9Lj1il546uMjfsttAcCsnDRvndysPnFI1CoBAEpZ7Qlcp26+156IiCKMRMCzHx1BVp84zMpO85moaNm/j+KJiYODvss2JeirVq3CSy+9hA0bNmD16tVYsGABbrjhBtx11124/vrrO+X4cyLq3lJi1Vg5NQvlZgeqbU7EqGWQSyQ4Y7BCAgFWpxv/O3Yeq3cWw+JwIzdDj+lX9cP/vq9s1BteN5Sl/v/NNjey0xNw4LQBuRl6JMYow3GYREQUIKvTjTuu7IezRt/yuyk6FYb3iYM1BGUW29wnr1QqMXXqVGzZsgVHjhzB4MGDcd9996Ffv34wm81BD5CIKNR0GgUGJEbj8j5xUEgkOFNlhcHihMXpxv9OVuBIqRErpmZBo5Ci4EQ51uwqxqycNL/vVTeUpe7/WpUMM7PTcOysCc+zYgsRUacjANAo/KfMGoUEoeiebtegGYlEAkEQIIoi3G6OqySizu10RQ1KqqwwWJ3ery+PlBpx26i+WLfnB29SvquoAlmpsX7fo24oC1A7nCVaJUNqvBp/vHUYel6skU5ERJ2HQtp8utzS+kC0+R3tdjvee+89/OIXv8All1yCQ4cO4ZVXXkFJSQmio6ODHiARUUeoS86NTSTng1J0Pkl5/Z7yOnVDWYDam4dSYlV4YfMxJMeo2HNORNRJtVQWJRRlU9o0Bv2+++7D+++/j9TUVMyaNQvvvfce9Hp9CMIiImodo8WBcrMDJlvtzG76qOZri/vb3mR1tio5r5+Uxza42bOuisuD7x1AboYei24chJVbT+APNwxick5E1MlJBKB/jyhEKWXeOugahQSSEN1+2aaJiiQSCfr06YOsrKxmbwjdsGFDUILrKJyggSi8Am2DpQYr5q0v9JkNNC9Dj+X5Q5HiZzhJw+310Qqs/+1V2HWyHElalffO/DKjFT11avzty1M+yblSJsFdf/0auekJWHjjIIgX31OrkkMpk8JocyBOrYBMKkAulSChhT8WiCIFr4NETSu+YIZbFLHkX9/6zBSdm56AxZMGQyoISOsR3FEkbRricuedd+Kaa65BbGwsdDpdkw8iolAzWhyNknMA2HGiHPPXF8JocbS4/cu/uhwWhwt9E6J8ymZ9dvQcVHIJhqXGepNznVqOA6cNyE5PwP3XZEAiCABE7C8xQCmXwOZyI1atQLRShniNAv17RDM5JyLqAiQSoVFyDgAFRRVY8q8jkISgG73NExV1pGXLlmHDhg04duwY1Go1rrrqKjz33HO49NJLvdtcffXV2L59u8/r7rnnHrz22msdGisRdaxys6NRcl5nx4lylJsdPgmyweLEjKv6YerIPlDJpSi6YEKfBA1ONzG05Y2C7/G7MZfgTJUVOrUcKToVRlycAXTWX/dieJ9Y/OGGQXhlWxGuvqQHpq/+Clf0icWym4egh1bVIZ8BERGFntXpbpSc1ykoKg9JmcU2Jegdbfv27bj//vvxs5/9DC6XC48//jiuv/56HDlyBFFRUd7tZs+ejaVLl3qfazSacIRLRB3IZHM2u7663vpSgxULNx3ynmAvSYzGm9NHNJmc1407B2orsSTGKHHr/+1GufmnXvmCogqIqB17/sV3F3BFn1g8c/MQpCZEgYiIuo5qm6vZ9eYW1gciohP0zZs3+zxfu3YtEhMTsW/fPuTl5XmXazQaJCcnd3R4RBRGWlXzM3LGXFxvtDiw/bsLmJGdhqmj+iJOLUPvOE2rbgq1OtxIjFFi6htf+iTndWrsLiyZlAm3x4M7ruyLJPacExF1OTGq5tPl6BbWByKiE/SGjEYjACA+Pt5n+bvvvot33nkHycnJmDhxIhYtWtRsL7rdbofdbvc+N5lMoQmYiPwKRhvURyuQl6HHDj/DXPIy9NBH1w5vqbI48XFhKXYVVWBkv1i8eOvlKCiqvSlUKhHQU6vEL6/oBeuQnjBZnfj92MugkEpQXFEDnUbeZHIO1J600xNZXpY6H14HiVpPLZciN0Pvd1hlboYeark06PsMfmX1EPF4PPjd736H7OxsZGZmepffdttteOedd/D5559jwYIF+Nvf/obbb7+92fdatmyZz02tqampoQ6fiOoJVhtcctNg5Gb4lnrNy9DjuYszdhotDizadAi7iiqQmx6Pl2+9HDV2F9L0UUiMUWBQUgw0ShkMFheMFic0CilcbhH7f6hERo8oVFTbcWlyjN9952boEcubQKmT4nWQqPUEj4inb8pEbrrv9SY3XY+nJ2dC8AS/EnqbyiyG07333otPP/0UO3fuRO/evZvcbtu2bbjuuutQVFSEAQMG+N3GX89Bamoqy0sRdZD2tsFSgxXz/lmIfSVVmJWT5p1AKFmrQqxGjl5xtd+gnTxvxsRXduLRsRm4/rJk1DjdMNlc0KpkUEglkEoEVNY4YXO6EaWUAhBw9KwRfRNqX+/2iLA4PVizqxi7fEpr6bF08mCk6dl7Tp0Tr4NErVdaUQOHxwMPBNhdHlRbnYhRy6GUSSCBCIVEgpQg33/UKYa4zJkzBx9//DF27NjRbHIOAKNGjQKAZhN0pVIJpVIZ9DiJqHXa0waNFgfm/bMQBUW1XzW+sq3Iuy47PQE3Dk3BhMxk6DQKWBxO/P2eK6FVybFg4yHf+rUZeiyeOBgqhQRxGjlKKixYt/cH3Dm6HwDghwoLRvSLx40rd2JWThpmZad5a6Gn6aNQYbYzQadOi9dBotbzAIAgYPGmw42uI0/dNBiN55Vuv4hO0EVRxAMPPICNGzfiiy++QFpaWouvOXjwIACgZ8+eIY6OiMKh3OzwJucahdTbg15Xx1wfrUBFTW2JRa1KgZJKM17e8h2G9YnDjItJdt2Nocs/PYrpV/XF2l2nsGDCQMy9/lK89N/jyM3ogcxeOlidblgcbp8/AnLT9Xh8wkBEKZu/SZWIiLqOFzYfw4zsNDw2/jLvTKLnTDa88J/jWDDusqDvL6IT9Pvvvx/r1q3Dhx9+iJiYGJSVlQEAdDod1Go1Tp48iXXr1mHChAlISEhAYWEhHn74YeTl5WHo0KFhjp6IQqGuvKJGIcWKqVlYs6u4QQKdgCdvyoTR4kDRhWqk6zV4cuJgVDvcMFmdSImVI1ohRYZeg9NV8UjQKjHzqjQs+/dRzM7rj18O/2ksrsXuW9s2N12PhTcOhMcjeqvEEBFR12Z1u/HI2Eux+MNvG/WgL5k0CFZ38OugR/QYdEHwPzPTmjVrMGPGDJw+fRq33347Dh8+jJqaGqSmpuLmm2/GwoUL2zSGjlMcE4VXW9rgyfNmXPfSdsy5Nh0HSqp8xobXyc3Q47nJmRAAmJxumKwuRCmlUMmkEASgosaOxGglBAiwelxwu4FPDpVh7OAkAMDpSivioxSI1chRaXZAJpVAJZdAo5DiQrUdvWPVrHdOXQqvg0RNO1NhxoKNh/1OVpSboceyyYPROyG4Qx4juge9pb8dUlNTG80iSkRdW115Re+sng2GrazeWYyCE+Wodrohl0rgEQGPKNb+wS8ABosNbg/gFAGXxwWNTIZqtxtZqbEw22p7QZQyCVRyKQQACdEKnDXY4HRLYHG4mJwTEXUzNU4P9pUYMOfadJ8hlXXXnBpn8EehR3SCTkTUkE6jwHP5Q1Ftc+HAzu8b3SS6YmoWHnzvAEw2F0QRiFJKoY9W4nSlBX//ugSPjRuIwz8a8P2FGlyVrofZ4Ua11Qm7y4NErRQSCDhVXoNLEqNhdbtRUe3AWaMVowfoIROA3kzOiYi6FYvd5XdIZd01x2IP/kyiET3EpaPwqz2i8GprGzRaHPj3obNI1Koa9WRk9YlFVp84jM9MhgBAKZNChAi3xwOJRII//fc45o8fiBPnzUiJVaPa5kS0So6qGgekEiAxRgWZRIDV5YTVDijlEkQppNCp5dCx7jl1UbwOEjWt+IIZT31yxDvLdP3rzpFSIxbdMAhpPbrREBciIn+qLA407FlI0anw2rTh2H+6Cr8YmASrw41opQwKqQCDxQarU0CMWoZfjeiDGoe7tpatzXnxZk8RvWLVkAqA2eHEOYsLgiCgl04FLRNzIhgtDpSbHTDZnNCq5dBHKdguqNtwejyYMToNCrmAKKXMW8UlJz0BI/vGw+nhEBci6ubOVllgdbjRNyEKRqvT24tx8nw1Hrn+UrxeUImXPzvh3T43PQFPTx6CsyYTTpbX4Gf94lBpdkApkyBGVVvRRQAAEXB6RBwsMdYOZ5EI6B2vCdtxEkWKUoMV89YX+kxznpehx/L8oUiJVYcxMqKOIQhASpwKS/7VoIpLegIWTxoMsVGXURD2ySEugX21J4oibDYbVCpVk9VmiKh1WtsGjRYHjDUO1LjcECGg2lrbmweI8HiAZZ8exc4m77LPxPHzZiRrVZBIBBwsqUJuuh7nzRbc/tY+rJnxM+g0cmjkUiglApLimJxT99FUGzRaHHh84yHcckVvJGqVPvWfN+4/g2duHsKedOrySipq8IcGk93VyU3X45mbM9EnyPcnSYL6bt2IzWbDr1dsgc1mC3coRN1GtcUJmQBEK2So/2dxtEIGmVTwm5wDQMGJcpidtcNaLA43ohVSZKfrIQdw+1v7YHG4EaOSo8bmglouZXJOdFFljQOPXn8JLkmMhkwigUQApBIBlyRG45HrL0FljSPcIRKFnMXp9pucA0BBUTkszuDXQecQlwCIogir1QqpgtMkE3UkuQA4RQFOT+0XfxIBUMkkqLlY6/yjOdkABGw7fg7/t/17WBw/nTSrrS4oZRJo1TLIUTt18+x1+2FxuJGbrodcJkAQZOihVYXl2IgikUIAAAka1qjwAFAIEggh+GqfKNJU21x+Z66uK05gtgW/igsT9ADYbDbc8epWyNXBvWOXiJrnQe1JS5QIcAhAXJQST3zoO3lEdnoC5lyTjqG9YnH/xQQcADRKKYoumDEwMRp2j4jZf9uH786bkZuhx5MTB+ObMwYMTmH1CqL6pIIAhwgsbPD1fm6GHs/clAkFh3hSNxCjkjVbZjFaFfx0mgl6gKRy9p4TdTQZABdqE3WVVIKyahseG38Z7qs3Lnbe+kK88nkRbhjSE7Ny0vDKtiLkZuihkUuRPSABHo8Is8ONZ24eghiVDGa7E1UWO4b21oX56Igijwjguc1HMSM7DY+Nv8xnDPpz/zmGheMuC3eIRCGnlEqwZldxo5mrdxVVQADw1E2ZQd8nx6C3gyiKsFgssFgsLc56SkTBIQi1ibrV5YEEAmQSCVJiVdAqpfji2Dm8+5srcbysGklaFbJSY5GbocfSmwZDJaktt2iwuyGV1Pb6uUURcRoltGoZDpQY0COaf3gT1VfjduP3Yy/1Owb999dfghp38MfeEkUam8vTKDmvs7OoAjYXyyxGFI/LgTte/QxSuRJ/f2gs1GqWmyIKlQtVFgCAA2h0N31uhh5P3zQIs3MH4I2Ck3gufyjsLg/00UosmTQYCkFAjceN17YX49+Hz3lfl5OegCcnZcJkdSE3Xc9qFEQNaAQJXIKAx5sY4qLhGHTqBmpamCm0pfWBYILeTlK5ksNdiDqCR4QbwIGSKiy9KRM2lwemi2UWXW4P/ry1CHOu7o+7cvuj2u7CeZMdaoUECokA0eOG0yni92MvwwPXXeKdoEgjl8IjiugTH4VE3hxK1IggEfDq5yfwxKTBcLlFb5uTSQW8ur0ID12dHu4QiUJOrZA2u17TwvpAcIhLkNRVduFQF6LgM1pqS7lJRRFX9InzSc6jFVL89/BZPHBdBkSJAKvTgxq7G+er7YhWyKAEIEqkkEkFyCUCtAopekcrcM5ow/++r4BKLmVyTtQEq8eNh6/OgErqmy6opBI8/PN0WD0c4kJdn0YuRXZ6gt912ekJUMuZoIddXSLeEOuiE4VOtdUJALALAswOt3eCoiiFFDIAd47ogw1fn4ZcIkW11QmdWo6RafFQXxxrrgIQK5NCDsDlceK7CiuSY1WYkJmMnpwJkahJMRJpk4mC5OJ6oq5OLRHwwLUZjZL07PQEPHBthvdaE0wc4tJGNpsNt/35U0gVakga9CiwLjpRaLg9blgkUjy+8ZDPjTq1Y8gHQymR4M6f9UG5w40YtRwxitqkoi51EFFb/eVHgwUOUcBZkw1ZfWI55pyoFWpQe99Hw7b39OQhCO7ciUSRSQqgl1aFG4emYFZ2GuwuD5QyCc5X29Fbp0Io/kxlD3oApHLfi7rbafcOb+EwF6Lgk/hJzoHau+ef/Ne3+NFkhQ1Atc2JaIUUStSWYqxj9YioslpRVG5BfJQC11zSg8k5USvYAPxhk/+2t3DTIfA7Y+oOnB43VAByBiQgJVYNfZQCKbFq5AxIgPLi+mBjgh4EdYm5x+nA9Nd3cJgLURCdrbLA7HA3W+IqSimD2eFGjEoOFQBHvZPl6WobZBIBEqkC2el6pOhUSOawFqJWaantmR0cg05dX5nFhZUFRX7XrdxRhDJL8NsBh7gEgcflwJx39kKuUrOiC1GQOTy1lSOaY7a5IZW4kXzxZk/FxXGxe84YMbS3DjaPGyk6FXvNidqopbZXbWt+PVFXoFMr8PaeM3h7zxm/66dnDwj6PtmDHiRMzImC70KVBRaHG1q1vNntolVSxKjkqNvKA8DicWNoby3eLPge+igm50SBaKntxaiaX0/UFeijFcjL0Ptdl5ehhz46+NcXJuhBxnHoRMFj84iottaOK89posRVTnoCauwuxFys6OJE7Ykt///2YOGmb3Hv1elMzokCFNNC24sJQf1nokij0yiwPH9ooyQ9L0OP5/KHhuQaI4jMJGEymaDT6WA0GqHVapvd1mq14pd//BgQpN4qLm6nHYJEDolUArfTDggyvHPfNYiLi4MgBL/0DlFX01QbPHrWBADQK6SwiLU3q+1sVMUlE0qpgPqVzM/b7FDJFdBHK5icE7VCU23wQkVNk23vmZuHQAOgRwJruVD3YLQ4UG52eCe7C+U1psuMQV+1ahVeeOEFlJWVYdiwYVi5ciVGjhwZ1H00VQO9IUEQcOf/bcfb9/ycSTpRO5isTvTUqeBGbS3z5TcPQbXD/dNMoAopFGhwIpNKMLhXfFjiJeqKNACW3TzEOwdBzMUJwji9F3U3Ok3Hdfp0iSEuH3zwAebOnYvFixdj//79GDZsGMaOHYvz588HdT82mw13vLoVouhpcVtBEHD7qi2oqqoKagxE3YlWLYcUtTVoXQBcDb7wkwC4YLGh3OGGHYBCLUcPVmghIqJOrksk6C+99BJmz56NmTNnYtCgQXjttdeg0WiwevXqoO+rLTeD8sZRovaJUckgA+ARAYUASBt8GyUA6KlRQR+lQO+EKA5nIQq2lmZIDMEMikTUBRJ0h8OBffv2YcyYMd5lEokEY8aMwe7du4O2n9YObyGi4Okdp4EEgPviw58eCVHooeWX7USh0CNOU/uXcHPriSjoOv0Y9PLycrjdbiQlJfksT0pKwrFjx/y+xm63w263e5+bTKYW91M3vEUia31JKVEUYbFYoFTW9qQLggC1Ws0x6dTttaUN9kiIwoUqC2wesXYM7MXx5zEqGXozOSAKSFvb4JkqS+2Ti5cvQSIwOScKoU6foAdi2bJlWLJkSZtfJ5UrWzX+vI7H5cBv3izwVnuRypX44MHrIQgCVCoVE3XqttraBpkIEAVXW9sg/xgm6lidfoiLXq+HVCrFuXPnfJafO3cOycnJfl+zYMECGI1G7+P06dMhi08qV3ofoiiitLQUv/rzf1FVVcVa6dRtdWQbJKLG2AaJIlunT9AVCgWGDx+OrVu3epd5PB5s3boVo0eP9vsapVIJrVbr8+gIHpcDc97ZC0DEnf+3HZWVlaipqYHFYoHH4+EER9RthKsNElEttkGiyNYlhrjMnTsX06dPx4gRIzBy5Ei8/PLLqKmpwcyZM8MdWiN1lV08LgemrfwvJFIJJDIF/u/Okfjt377G2tk53uEvHK9ORERE1P10iQT917/+NS5cuIAnnngCZWVluPzyy7F58+ZGN442pa7XurmbZKxWK5w2C9weD9xOBwSpExJJ3UyiPz1v6v/+t5NBIoqAy4ppL/8bMpUav/rjx3A7HZCr1XhjVg7UatZ0psjSlt/JmJiYVv2R2Zo2SERtxzZIFF6tbYMNCSLHVODMmTNITU0NdxhEXU7DacObwjZIFBpsg0Th1do22BATdNSOWS8tLfX5K8dkMiE1NRWnT5/udmPzuvOxAzz+YB5/a3sO/LXBUMUUqXiMXUckHWew2iAQWccVqM5+DJ09fqDzH0Nb4w+0B71LDHFpL4lEgt69e/td151vnunOxw7w+Dvy+Jtrg/V1h58Jj7Hr6EzH2do2CHSu42pKZz+Gzh4/0PmPIdTxd/oqLkREREREXQkTdCIiIiKiCMIEvQlKpRKLFy+GUqkMdygdrjsfO8Djj8Tjj8SYgo3H2HV01ePsCsfV2Y+hs8cPdP5j6Kj4eZMoEREREVEEYQ86EREREVEEYYJORERERBRBmKATEREREUUQJuhERERERBGECToAURRhMpnA+2WJwoNtkCi82AaJIgsTdADV1dXQ6XSorq4OdyhE3RLbIFF4sQ0SRRYm6EREREREEYQJOhERERFRBGGCTkREREQUQZigExERERFFECboREREREQRRBbuAIioczBaHCg3O2CyOaFVy6GPUkCnUYQ7LCIiog7RkddBJuhE1KJSgxXz1hei4ES5d1lehh7L84ciJVYdxsiIiIhCr6OvgxziQkTNMlocjU5KALDjRDnmry+E0eIIU2REREShF47rIBN0ImpWudnR6KRUZ8eJcpSbmaATEVHXFY7rIBN0ImqWyeZsdn11C+uJiIg6s3BcB5mgE1GztCp5s+tjWlhPRETUmYXjOsgEnYiapY9WIC9D73ddXoYe+mhWciEioq4rHNdBJuhE1CydRoHl+UMbnZzyMvR4Ln8oSy0SEVGXFo7roCCKohj0d+1kTCYTdDodjEYjtFptuMMhikh19V+rbU7EqOTQRwev/ivbIFF4sQ0StSyU18GGWAediFpFp+HERERE1H115HWQQ1yIiIiIiCIIE3QiIiIiogjCBJ2IiIiIKIIwQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEnYiIiIgogjBBJyIiIiKKIEzQiYiIiIgiCBN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCJIWBP0HTt2YOLEiUhJSYEgCNi0aZPP+hkzZkAQBJ/HuHHjfLaprKzEtGnToNVqERsbi7vuugtms7kDj4KIiIiIKHjCmqDX1NRg2LBhWLVqVZPbjBs3DmfPnvU+3nvvPZ/106ZNw7fffostW7bg448/xo4dO3D33XeHOnQiIiIiopCQhXPn48ePx/jx45vdRqlUIjk52e+6o0ePYvPmzdi7dy9GjBgBAFi5ciUmTJiAF198ESkpKUGPmYiIiIgolCJ+DPoXX3yBxMREXHrppbj33ntRUVHhXbd7927ExsZ6k3MAGDNmDCQSCfbs2ROOcImIiIiI2iWsPegtGTduHG655RakpaXh5MmTePzxxzF+/Hjs3r0bUqkUZWVlSExM9HmNTCZDfHw8ysrKmnxfu90Ou93ufW4ymUJ2DETUGNsgUXixDRJFtojuQZ8yZQomTZqEIUOGYPLkyfj444+xd+9efPHFF+1632XLlkGn03kfqampwQmYiFqFbZAovNgGiSJbRCfoDfXv3x96vR5FRUUAgOTkZJw/f95nG5fLhcrKyibHrQPAggULYDQavY/Tp0+HNG4i8sU2SBRebINEkS2ih7g0dObMGVRUVKBnz54AgNGjR8NgMGDfvn0YPnw4AGDbtm3weDwYNWpUk++jVCqhVCo7JGYiaoxtkCi82AaJIltYE3Sz2eztDQeA4uJiHDx4EPHx8YiPj8eSJUuQn5+P5ORknDx5Eo899hjS09MxduxYAMDAgQMxbtw4zJ49G6+99hqcTifmzJmDKVOmsIILEREREXVKYR3i8vXXXyMrKwtZWVkAgLlz5yIrKwtPPPEEpFIpCgsLMWnSJFxyySW46667MHz4cBQUFPj81f/uu+/isssuw3XXXYcJEyYgJycHr7/+ergOiYiIiIioXQRRFMVwBxFuJpMJOp0ORqMRWq023OEQdTtsg0ThxTZIFFk61U2iRERERERdHRN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIiogjCBJ2IiIiIKIIwQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEnYiIiIgogjBBJyIiIiKKIEzQiYiIiIgiCBN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIiogjCBJ2IiIiIKIIwQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEnYiIiIgogjBBJyIiIiKKIEzQiYiIiIgiCBN0IiIiIqIIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCKILNwBEFHHM1ocKDc7YLI5oVXLoY9SQKdRhDssIiKiiNWR104m6ETdTKnBinnrC1Fwoty7LC9Dj+X5Q5ESqw5jZERERJGpo6+dAQ9xMRgMePPNN7FgwQJUVlYCAPbv348ff/wxaMERUXAZLY5GJxgA2HGiHPPXF8JocYQpMiIiosgUjmtnQD3ohYWFGDNmDHQ6HU6dOoXZs2cjPj4eGzZsQElJCd5+++1gx0lEQVBudjQ6wdTZcaIc5WYHh7oQERHVE45rZ0A96HPnzsWMGTNw4sQJqFQq7/IJEyZgx44dQQuOiILLZHM2u766hfVERETdTTiunQEl6Hv37sU999zTaHmvXr1QVlbW7qCIKDS0Knmz62NaWE9ERNTdhOPaGVCCrlQqYTKZGi3/7rvv0KNHj3YHRUShoY9WIC9D73ddXoYe+mgObyEiIqovHNfOgBL0SZMmYenSpXA6a7v0BUFASUkJ5s2bh/z8/KAGSETBo9MosDx/aKMTTV6GHs/lD+X4cyIiogbCce0URFEU2/oio9GIX/7yl/j6669RXV2NlJQUlJWVYfTo0fj3v/+NqKiooAcaSiaTCTqdDkajEVqtNtzhEIVcXS3XapsTMSo59NHhrYPONkgUXmyDRC3ryGtnQFVcdDodtmzZgl27duGbb76B2WzGFVdcgTFjxgQ7PiIKAZ2GExMRERG1RUdeOwNK0N9++238+te/RnZ2NrKzs73LHQ4H3n//fdx5551BC5CIiIiIqDsJaAz6zJkzYTQaGy2vrq7GzJkz2x0UEREREVF3FVCCLooiBEFotPzMmTPQ6XTtDoqIiIiIqLtq0xCXrKwsCIIAQRBw3XXXQSb76eVutxvFxcUYN25c0IMkIiIiIuou2pSgT548GQBw8OBBjB07FtHR0d51CoUC/fr1Y5lFIiIiIqJ2aFOCvnjxYgBAv379MGXKFCiVypAERURERETUXQU0Bn3JkiUwm82NlhsMBvTv37/dQRERERERdVcBJeinTp2C2+1utNxut+PHH39sd1BERERERN1Vm4a4/Otf//L+/z//+Y9PxRa3242tW7eiX79+QQuOiIiIiKi7aVMP+uTJkzF58mQIgoDp06d7n0+ePBlTpkzBli1b8Mc//rHV77djxw5MnDgRKSkpEAQBmzZt8lkviiKeeOIJ9OzZE2q1GmPGjMGJEyd8tqmsrMS0adOg1WoRGxuLu+66y+/wGyIiIiKizqBNCbrH44HH40GfPn1w/vx573OPxwO73Y7jx4/jxhtvbPX71dTUYNiwYVi1apXf9c8//zxWrFiB1157DXv27EFUVBTGjh0Lm83m3WbatGn49ttvsWXLFnz88cfYsWMH7r777rYcFhERERFRxBBEURTb8wY2mw0qlar9gQgCNm7c6C3lKIoiUlJS8Mgjj+DRRx8FABiNRiQlJWHt2rWYMmUKjh49ikGDBmHv3r0YMWIEAGDz5s2YMGECzpw5g5SUlFbt22QyQafTwWg0QqvVtvtYiKht2AaJwottkCiyBHSTqMfjwVNPPYVevXohOjoa33//PQBg0aJFeOutt4ISWHFxMcrKyjBmzBjvMp1Oh1GjRmH37t0AgN27dyM2NtabnAPAmDFjIJFIsGfPnibf2263w2Qy+TyIqOOwDRKFF9sgUWQLKEF/+umnsXbtWjz//PNQKBTe5ZmZmXjzzTeDElhZWRkAICkpyWd5UlKSd11ZWRkSExN91stkMsTHx3u38WfZsmXQ6XTeR2pqalBiJqLWYRskCi+2QaLIFlCC/vbbb+P111/HtGnTIJVKvcuHDRuGY8eOBS24UFmwYAGMRqP3cfr06XCHRNStsA0ShRfbIFFka1OZxTo//vgj0tPTGy33eDxwOp3tDgoAkpOTAQDnzp1Dz549vcvPnTuHyy+/3LvN+fPnfV7ncrlQWVnpfb0/SqWSs6AShRHbIFF4sQ0SRbaAetAHDRqEgoKCRsv/+c9/Iisrq91BAUBaWhqSk5OxdetW7zKTyYQ9e/Zg9OjRAIDRo0fDYDBg37593m22bdsGj8eDUaNGBSUOIiIiIqKOFFAP+hNPPIHp06fjxx9/hMfjwYYNG3D8+HG8/fbb+Pjjj1v9PmazGUVFRd7nxcXFOHjwIOLj49GnTx/87ne/w9NPP42MjAykpaVh0aJFSElJ8VZ6GThwIMaNG4fZs2fjtddeg9PpxJw5czBlypRWV3AhIiIiIookAZdZLCgowNKlS/HNN9/AbDbjiiuuwBNPPIHrr7++1e/xxRdf4Jprrmm0fPr06Vi7di1EUcTixYvx+uuvw2AwICcnB6+++iouueQS77aVlZWYM2cOPvroI0gkEuTn52PFihWIjo5udRwsL0UUXmyDROHFNkgUWdpdB70r4ImJKLzYBonCi22QKLIENMSFqLsxWhwoNztgsjmhVcuhj1JAp1G0/EIiIiLqEjoyFwgoQZdIJBAEocn1brc74ICIIk2pwYp56wtRcKLcuywvQ4/l+UOREqsOY2RERETUETo6FwgoQd+4caPPc6fTiQMHDuCvf/0rlixZEpTAiCKB0eJo1CABYMeJcsxfX4iVU7PYk05ERNSFhSMXCChBv+mmmxot++Uvf4nBgwfjgw8+wF133dXuwIgiQbnZ0ahB1tlxohzlZgcTdCIioi4sHLlAQHXQm3LllVf61C0n6uxMtuYn3qpuYT0RERF1buHIBYKWoFutVqxYsQK9evUK1lsShZ1WJW92fUwL64mIiKhzC0cuENAQl7i4OJ+bREVRRHV1NTQaDd55552gBUcUbvpoBfIy9Njh56utvAw99NEc3kJERNSVhSMXCChBf/nll32eSyQS9OjRA6NGjUJcXFww4iKKCDqNAsvzh2L++kKfhpmXocdz+UM5/pyIiKiLC0cuwImKwAkaqGV1tU9r7E7o1Ao43B6Y7S7WRA8StkGi8GIbJGrZOZMNVTUOmGwuaNUyxGkUSNKqQrKvgCcqMhgM+Oqrr3D+/Hl4PB6fdXfeeWe7AyOKJDpNbRLOmuhERETdT0df/wPqQf/oo48wbdo0mM1maLVan/HogiCgsrIyqEGGGnsOqDWMFgfmvHfAb6mlvAw9a6K3A9sgUXixDRI1LRzX/4CquDzyyCOYNWsWzGYzDAYDqqqqvI/OlpwTtVZr6qASERFR1xKO639ACfqPP/6IBx98EBqNJtjxEEUs1kQnIiLqfjpNHfSxY8fi66+/DnYsRBGNNdGJiIi6n4iug/6vf/3L+/8bbrgBv//973HkyBEMGTIEcrlvYJMmTQpehEQRgjXRiYiIup9wXP9bfZOoRNK6znZBEOB2u9sVVEfjzTHUWqUGa5N1UHuyikvA2AaJwottkKh5HX39Zx108MREbVNXE73a5kSMSg59NOugtxfbIFF4sQ0Stawjr/8B10Enaqu6X2yTzdmpJ/ipq4lORERE3Y8IAEJLW7VPwAn61q1bsXXrVr8TFa1evbrdgVHXwgl+iIiIqLPq6DwmoCouS5YswfXXX4+tW7eivLzcpw56VVVVsGOkTs5ocTT6pQZqa4fOX18Io4X1w4mIiCgyhSOPCagH/bXXXsPatWtxxx13BDse6oJaU+CfQ0aIiIgoEoUjjwmoB93hcOCqq64KaiDUdXGCHyIiIuqsOs1ERb/5zW+wbt26YMdCXRQn+CEiIqLOKqInKqrPZrPh9ddfx2effYahQ4c2mqjopZdeCkpw1PkZLQ7IJAJyM/R+vx7KzdAjWsViQkRERBSZwjFRUUCZUWFhIS6//HIAwOHDh33WCUKI685Qp1F3x/O+H6qwYmoWPKKIXUUV3vXZ6QmYflU/LNx4CEtuykRKrLrLlGIkIiKirkGnUeDpyZnYVVSORK0KdpcHKrkU54xWZKfrQ5KnBJSgf/7558GOg7qYhnc8P/jeAaycmoX7rk6H0eqEUibBgdMGPPjeAVgcbgCHsXjiYCzYeIilGImIiChinDfZcNZowyeHzmJnvY7G3PQE9O8RDZVcikStKqj75NgCComGdzzXJuHAtDf3+N3+0p5aLNhQiIJ6v/jATyWMVk7NYk86ERERdbgauwsrtp3wGQUAAAVFFfAAePqmzKDvM6AEvaamBsuXL29yoqLvv/8+KMFR5+UWRbw1fYT3a6D9JVVwecQmt89KjcUr24r8rvNXwohDYYiIiKgjWJxuHCgxYM616chKjfXJbVbvLIbF6Q76PgNK0H/zm99g+/btuOOOO9CzZ0+OOycfpQYrnvroW5/e8Oz0BEwamgKNQurtTa/P7vI0WlZf/RJGnJWUiIiIOorN4caKqVlYs6vYpzMxOz0BK6ZmwRYpCfqnn36KTz75BNnZ2cGOhzo579jzBl8D7SqqwFMff4uFNwzE4xsPN3pdrLp1JYxams2LQ2GIiIgomOKjFHjps+8aDXGpex6KIS4B1UGPi4tDfHx8sGOhLqC52bYKiiowrHcscjP0PsvzMvTom6BBXoPl9dfXlTBqzWxeRERERMFid3saJed1dhVVwO5ufhRAIALqQX/qqafwxBNP4K9//Ss0Gk2wY6JOrKXZtuwuD16ZmoVyswPVNidiVHLoo2vHjy/PH4r56wt96ozmZejxXP5Qb684ZyUlIiKijmSyutq1PhABJeh//OMfcfLkSSQlJaFfv36NJirav39/UIKjzqel2bZ0ajl0Gv83dKbEqrGyieS9te/PWUmJiIgomLQtTKjY0vpABPSOkydPDnIY1FVEq2RY95tRMFidvnc4O9ytmm2rqeS9Tjhm8yIiIqLuKy5Kgesu64GBKbpGVVyOlhoRFxX83EMQRbHp2nfdhMlkgk6ng9FohFarDXc4nZa/6irZ6QmYmZ2GD74qwdKbMtEzCFVWSg3WJofCBOP9qeOxDRKFF9sgUfN+qKjB4xsP+YxFz0lPwDM3D0HfhKig7y/gPnmDwYB//vOfOHnyJH7/+98jPj4e+/fvR1JSEnr16hXMGKkTaKq6yq6iCkgEAS/eOgxJQZplqzVDYYiIiIiCwWhxYOGmw41uFN1ZVIFFmw6HpIJcQAl6YWEhxowZA51Oh1OnTmH27NmIj4/Hhg0bUFJSgrfffjuoQVLka7Z6y4lymG0uJAWxU6aloTBEREREwdCaCnLBzkkCKrM4d+5czJgxAydOnIBK9VOv6IQJE7Bjx46gBUedB6urEBERUVcUjhwnoAR97969uOeeexot79WrF8rKytodFHU+rK5CREREXVE4cpyAEnSlUgmTydRo+XfffYcePXq0OyjqfOqqq/jD6ipERETUWYUjxwkoQZ80aRKWLl0Kp7O2S18QBJSUlGDevHnIz88PaoDUOdRNNNTwF7jhRENEREREnUk4cpyAyiwajUb88pe/xNdff43q6mqkpKTg7NmzGD16ND799FNERQW/3EwosbxU8BgtDlZXoTZjGyQKL7ZBopZ1ZI4TUBUXnU6HLVu2YOfOnSgsLITZbMbw4cNx3XXXBTs+6mRYXYWIiIi6oo7Mcdo0xGX37t34+OOPvc9zcnIQFRWFV199FVOnTsXdd98Nu90e9CCJiIiIiLqLNiXoS5cuxbfffut9fujQIcyePRu/+MUvMH/+fHz00UdYtmxZ0IMkIiIiIuou2pSgHzx40GcYy/vvv4+RI0fijTfewNy5c7FixQr8/e9/D3qQRERERETdRZvGoFdVVSEpKcn7fPv27Rg/frz3+c9+9jOcPn06eNFRWNXdDGGyOaFVy6GP4vhyIiIi6p46Mi9qU4KelJSE4uJipKamwuFwYP/+/ViyZIl3fXV1NeRyTkjTFZQarJi3vtBnatu8DD2W5w9FSqw6jJERERERdayOzovaNMRlwoQJmD9/PgoKCrBgwQJoNBrk5uZ61xcWFmLAgAFBC+7JJ5+EIAg+j8suu8y73maz4f7770dCQgKio6ORn5+Pc+fOBW3/3ZXR4mj0SwgAO06UY/76QhgtjjBFRkRERNSxwpEXtSlBf+qppyCTyfDzn/8cb7zxBt544w0oFD917a9evRrXX399UAMcPHgwzp49633s3LnTu+7hhx/GRx99hH/84x/Yvn07SktLccsttwR1/91RudnR6Jewzo4T5Sg3M0EnIiKi7iEceVGbhrjo9Xrs2LEDRqMR0dHRkEqlPuv/8Y9/IDo6OrgBymRITk5utNxoNOKtt97CunXrcO211wIA1qxZg4EDB+LLL7/ElVdeGdQ4uhOTzdns+uoW1hMRERF1FeHIi9rUg15Hp9M1Ss4BID4+3qdHPRhOnDiBlJQU9O/fH9OmTUNJSQkAYN++fXA6nRgzZox328suuwx9+vTB7t27m31Pu90Ok8nk86CfaFXN30cQ08J6opawDRKFF9sgUeuFIy8KKEHvKKNGjcLatWuxefNm/OUvf0FxcTFyc3NRXV2NsrIyKBQKxMbG+rwmKSkJZWVlzb7vsmXLoNPpvI/U1NQQHkXno49WIC9D73ddXoYe+mhWcqH2YRskCi+2QaLWC0deJIiiKAb9XUPEYDCgb9++eOmll6BWqzFz5sxGM5eOHDkS11xzDZ577rkm38dut/u8zmQyITU1FUajEVqtNmTxR4rWlAkqNVgxf30hdjS4W/m5/KHoySou1E7dvQ0ShRvbIFHbdHRe1KYx6OEWGxuLSy65BEVFRfjFL34Bh8MBg8Hg04t+7tw5v2PW61MqlVAqlSGONnLUT8ijFDLsK6nCUx8fgcXhBuC/TFBKrBorp2ah3OxAtc2JGJUc+mjWQafg6G5tkCjSsA0StY0EwH3XpOP34y6F2eZGjEoGs90FIUT761QJutlsxsmTJ3HHHXdg+PDhkMvl2Lp1K/Lz8wEAx48fR0lJCUaPHh3mSCPHmUoLFmwoREFRhXdZbnoCNt2fDavDBYlEgqoaB0oqLJBKBCRpVd7tdBom5ERERNS9GS0OlFRZsWrbiQb5lB4PXJcBtUIa9HwpohP0Rx99FBMnTkTfvn1RWlqKxYsXQyqVYurUqdDpdLjrrrswd+5cxMfHQ6vV4oEHHsDo0aNZweWiH6ssmLehELvq/TIBQEFRBZ766AjGD0nG4xsPe5fnXvyqhhMREREREdUyWp1YufU7n+QcAAqKygEBeGZyZtAT9Ii+SfTMmTOYOnUqLr30UvzqV79CQkICvvzyS/To0QMA8Kc//Qk33ngj8vPzkZeXh+TkZGzYsCHMUUcGo8WBHyosjZLzOgVF5T695QBQwImIiIiIiHxYnO5GyXmdghPlsDjdQd9nRPegv//++82uV6lUWLVqFVatWtVBEXUe5WYHDNbm63LaXZ5Gy+oK7nNoCxERERFQbXW1a30gIjpBp7apfzOoyyNCKWv+C5Km1nMiIiIiIqJaGmXjuX/asj4QTNC7AKPFgTKTDUarC1FKKWJUMgiCgMLTBuRm6P1OT5udnoADpw1+348TERERERHVUsulGJ+ZhF8OT0WiVumt4nLOZMM/952GWs4EnRo4a7Dii+MXkKhVwu7ywGyXosxoRXpiNK4bmIihvXW49+oB+N/JCqzeWQyLw43cDD0WjL8M5012vDrtCqjkUuwvqcLqncUY0TeOExERERERXSQXgPnjBmLXydoOT7vLA6vTjfMmG+aPGwiJEPwphZigd2LnTTb8UFGDjw+V+twMmp2egDnXpOOr4kqUVFnxyrYi5Gbo8eH92Sgz2tAjRokX/3MMnx274POa1TN+hn7xGo4/JyIiIrpIIgg4Y7Dik0NnG+Vb/fRR6NPdJyqin5QarDBaHfi+vAazstMwbVRfn57wVz4vwrxxlyEhunYiioIT5Vjy0bdYPGkwnvzXt42qu+wqqoBUELByalY4DoeIiIgoItk9It4o+B5ZfeIwKzsNdpfHm3O9UfA9Ft4wKOj7jOgyi+Sf0eLAM58cgUYhQ9+EKJ9flCOlRqyYmoUDJQYAvpVadhZVwOH0NFl6sa6CCxERERHVsrvcuOPKfkjR+ZanTtGpcMeV/WB3dbMyi+RfRY0D9/x8AHY1qGWeolNheJ84/O3LU5iVkwaLww1VgxsXTLYWSgWxggsRERGRl0QQoFH479PWKCSQCELQ98kEvZMxWhxweTyw2F1+x0LNuSYdw1JjkZmig0omRY3dNyGPVjV/pzEruBARERH9RCGVwCOiybxLIQ3+gBQOcekkjBYHjpeZUGayQSaRYOXnRX7Hkb/yeRGuuTQRACCVCJDW+6suNz0B50125Gbo/e4jL0PPCi5ERERE9XhE4JVm8i5P8Iu4sAe9Myg1WPHEpsO4LEWLWy7vBbvT7fdGhdU7i72/PD11aty5eg+W3pQJAMhN12PRxEH485bv8PTkTCzadBg76tVHz8vQ47n8oazgQkRERFSPzeXGgRID5lybjqzU2Ea5l41j0Lsfo8WBJzYdxpRRfbB+32k4PR7IZVIcKKnCK9uKvNtlpydgxdQsPPjeAVgdbuz+/jzKzQ70jlPj3d+MQoxKhtIqK+7++QCIHhErp2ah3OxAtc2JGJUc+mgFk3MiIiKiBmwON1ZMzcKaXcV+cy+bkwl6t1NudmBIqg7nTTbcd006PB7g6Y8P+/2aBQBm5aRBp5Hj9R3fIzs9Ad/+aEKSTgmn2YMkrQovbTmOF28dBp2GCTkRERFRS+KjFHjps++azL2evjhaIZg4Bj3Cme1OjB/cE58cOouJK3fBJXpQ0ESZxF1FFbiqfwIcLg+G94nF4omDIZUAh340wi2KcHo8WHpTJhNzIiIiolayu5suUb2rqAJ2t8fvuvZgD3qEMlocOF9th9MtQib1YPHEwXC6PaixN/81ikwqgVwi4PfjLsNtb3yJcrMDb00fgUStEmq5FD1DMNsVERERUVdlbqFEdUvrA8EEPUIYLQ6Umx0w253QqRVYtOkwCop+uokzN12PhTcORLRS2uRNChaHGx6PiE8Ol+FASRWmjOzjHSt17Gw1rh+UFK7DIyIiIuqUolUyaBRSzMpJ85t/RauCn04zQY8ApQYr5q0vxL4fqrByahZe/M/xRsNYCorK8cLmY1h44+AmbxB9f88PSNIp8f5XJSg3OzArOw0A0CtWjcE9tRzaQkRERNRG0XIp3po+Aq98XtQo/3pr+ghEy5ufYyYQHIMeZkaLA898cgR3Zafh4wdyoJZLmxxjflmKDos2HfJ7k8LaXcVYNHEw/vzZd5gysg8AwO7yIDc9AVq1HMkc2kJERETUZk5RxKtN1EF/9fOTcIrBL4TOBD3MDDUOzBt3GVLjNVj84WEYrM4mt81KjW0yed9ZVIEfDVb0jo9CVmosACBWLcczNw9BCpNzIiIiooBYHO4m86+ConJYHCyz2OVIJAJMF28uKCiqwIyLw1L8cXnEZsefGyxO77rcdD36JmjQK07TUYdCRERE1OVY7O5mx6BbWijgEQj2oIfRDxU1mL/xEG5YuRM/VFoAAAdOG5CdntBoW320ApcmRWN0/wSfX4wjpUasmJoFjUIKpUwCu8tzsec8k8k5ERERUTvFqGVYddsVSNGpfJan6FRYddsViFHzJtEu45zJhiUffYusPnGYndMfiVolAGD1zmKsmJoFoHZsk0Yhxf3XDMB1lyXhnMkOrUoGrUqObcfP4UipEbeN6ot1e37AohsG4cBpA67qn8CecyIiIqIgiZJLEa2UoH+PKEQpZTDb3IhRyaBRSCAVatcHGxP0MDHZHFgwYSBcLg/kMin2FlcgOz0Bu4oq8OB7BzArJw2/zR2A3vFqnDXa8H15DVRyKQqKynGk1IjZuf0xtFcs/vblKQxK0eHyPrH47D9l+PXw3kzOqcsTRRF2ux1KpRKCIIQ7HCIi6sI8HhHx0Urs+b4SSVoV7C4PrE43zhmtGNk/Hh4PbxLtMpRSKc6b7JBIPFBKBVzeJw4PXpuBTx/KxeaHcnGs1IDkWBVKjTYYrE6fIS23jeqLNwq+x1mjFYNSdMhKjYXJ6sTiiYPh8og4UFKFkxfMMFoc4T5MopCw2+349crPYLfbwx0KERF1cYIgwGa3Izddj5RYNRKiFOipUyEnXQ+b3R6SjiL2oIfB6YoaVNY4EacSoJYrUFJlhfFiEl5QVI6jpUY8MTEThpqfltdPztft+QGDUnRI0qq8f8n1jpNj6cdH8NnR89795GXosTx/KKu4UJcklbOuPxERhZ5UFBGtUqOgqNybd9U4anvQrxqgh5RlFju/0xU12FlUjmqrEzFqFSprnJAKAlLj1OgRrUSfODVuv7Ifln70LeKj1E0m53V3EdfdFFp42uiTnAPAjhPlmL++kD3pRERERAESJQLOV1vRv0cUErVKxGkUSIxRIq1HFM5XWyFK2IPeqZ2tsuCs0QqpREDveDV2FpUj8eJfYhanFGVGKwb0iAIADE2Nhdnhxpx1+5HVJxYzs9MaJedKmQQquRS949T4zdtf+93njhPlKDc7OIsoERERUQBcLYxBd4VgDDoT9BAyWhy4YLbD5REhikCN3QWdRoHRWjVqnC4M7KmDzelGYowUgIDyahsA4IcKC665NBHVNidWTM3Cg+8dAFCMrD5x3uRcp5ajpKIGORk9YLDYmy2SX21revIjIiIiImqaRBBwodrmt4pLpdmOpJjgDyXmEJcQOWuw4r/fngMAHD9rglouQZRSBpPVCQ+AAyUGVNTYUWlx4ILZgUM/GtA3obb6yqAULQAgRiXH+n2nMSsnDbuKKnyS8/goBfIyeiA1XgONQt5sLDGq5tcTERERkX8esbYH/fsLNThvsqPK4sD5ajuKL9QgPloJD8egdw7nTTb8WFWDYX20MFnsGJYai0WbDmP8nwuw94dK2F0uXN4nDlqVHP0SNOiXoMEVfWMhk9T2nivlUlgdbkQrpPjl8FRkpcYCgDc5T41TI0WnQq/42oReH61AXobebyx5GXroozm8hYiIiCgQEkGAyWLHlf0TfKq4jOqfAJPFDkkIqrgwQQ+yUoMVNXYXYqOUkApSaJRyLNp0GAVFFdBHKzB5SArU8tqRRR5RhCAIkEsEyKQCYtQKjOgXB5fLg1iNHPCISNQqYXd5AAA6tRw9dSro1HKfMeU6jQLL84c2StLzMvR4Ln8ox58TERERBUoU0TNKDXmDm0HlEgE9o9RACHrQOQY9iIwWB7Z/dwFX9U/Awg8P4/EJAyEVBBQUVWBoLy3euu0K2AGYHW5UW53QquXQKKSwuFzQSGU4bbJg9f9OYf74gZAIHtghwmxzQymTICc9AclaFX71f7vxwd2jGyXdKbFqrJyahXKzA9U2J2JUcuijFUzOiYiIiNpBLRHgFAFPg+Weiw81q7hENqPViX4JGlicbuwqqkCNvfbGzUsSo/H61CtgBbCzXg1Ns6PuDuAEiBDRO1aNy3pqseSjb7HwhoFwut3QqmQ4VVGDJZMy8Z8jZ70JuD86DRNy6vpEUYTNZgt3GERE1E14ALgA7PJTBz17gB7SEOyTQ1yC5EylBT8arEjVKlFtrU2gtSoZopRSvHHHcAgCIADI6hOHaKUMafoopPeIQoxKhvJqG86b7RAkArJSY1FwohwigKOlJmhVMmQPiMevX9+NS5N+unmUqLuy2+24/dVt8Hga9mUQEREFnwtAlcWK7AYziV6VrkeVxQpXCPbJBD0IzlRa8EOlBclaGSCRIEZdm0C73CK0cinkEgEGpxtnTXZ4RBH6aCXOGW1Y/ulRZPaKhUIKxEcpYXa4vePNq20ujOqfABmAH8qtKDc7YHd5eNMnETiLKBERdRyPR0S8Rg2Lw4X6o80tDhfiNWp4QlAHnQl6O/1YacGOExcgEUWoJLWJuUomwYTMJHhEF0RBwPaicpypsqLcbMc5kx1fnapEkk6Jh6+/FM9vPgqdRgVRrK1XrpTV/ki0KhlkAKb/9WtUO2r/NotVy3nTJxEREVEHkkoEeCDiYIkBZw1WVNQ4cNZow8ESIzwQIeUY9MhitDhgsjkxMDkKidFqyACYXW643CLmjr0EURIpbB4RQ1NjYbG7oVXLECWXQh8lQY3NhRi1DL8a0Qd2lwceUUSMSo4dJ8qRm6FHjFyKGX/9Gt+dN0MpkyA3Q48BidFI0qrCfdhERERE3YYHgMVuQ066HmaHG6aLhT4yekTBbLchRhn83IwJeoCMFgfOmmyosTmQrNNA4REBiQCVTApI3BAuJudPfFhbYrFOboYeT9+UCYgeuAD0jlej0uyAIAhI1ipx7KwJT980GJsOleK782ZkpyfgfLUdz+cP7bDk3GhxoNxc+8eHVi2HPoo3nxIRdWelBiuMVidMVid0ajm0ajlSYoM/eyJRJJJ6REQp1Xh846FGOd0zN2VCGoIhLkzQA1BqsGLePwuRlqDC3XnpUF5MzgFABcAhkcLuEbG4QXIOAAUnyrFw0yE8ffMQyETA7HAhRi2HRABcHjfuGNUH1XYXXtl2ErkZejx1UybiNPIOS5BLDVbMW1+IghPl3mV5GXoszx/KkzERUTd0rqIG7nrPRQButwfnKmqQlBAVrrCIOo5EwB8aJOdAbU73hw8P4/nJmUHfJRP0NjJaHJi3vhBalQSz89KhhAuQ1H6MLgAmlxt2pwcyqQRTR/XFzJz+2F9ShdU7i2Fx1J7iCooqvP+3ONxIiFZALRFw8KwJg3pqUW114KM5OR1ex7zu2Oon5wCw40Q55q8vxMqpWexJp4hSV3JRqVRCCMFMbkTd3QWDFRIRtWXIGpCItet7sPOGujiT0419JQbMuTYdWamxsLs8UMml3vzO5HSjZ5D3yQS9jcrNDhw9a8KH914FBUS4IIMHtT0KZdVW9IhRo6LaAYPV6f3hHSk1YsXULDz43gFvYl5jd0GtqK2c6XJ74JFIcVX/hIsJcG2PhNHiwMnz5g4balJudjRKzuvsOFGOcrODCTqFnc1mqy2x6HHAaDTinr99jQ8eGAOVivdnEAWdu4Vypi2tJ+oCzDYXVkzNwppdxXhlW5F3eXZ6AlZMzYLZHvxCi0zQ28jicGL9PVde/OAEVDvdiJNLYIeAKKUCZw02aNVyWJ1uPPbPb3BpcgxmZqdh3Z4fMCsnzfuDVcul+PRwmbdnvW44C1A74VA4hpqYmpgAqU5TEyQRhRNLLhKFlh3Aj0YropQyeETA7RHxo9GG3loVlOEOjqgDxGkUeOmz77CrwRCXuudPTQr+EBeWWWyjZLUCGokEEtT2msdJXbBBQPXFu3p1GjmilTKYbU6sm30ljpdVY82uYgxK0SErNRYAkJuegC1Hz+FASRVWTM2CRiGtHce06RD+fbgMP1ZZmh1qYrQ4QnJs2hYmQOIESRSJ3E4HZxYlChEPAJfoQWKMCjKJBBKhtuRcYowSLlFsNPU5UVfk9HgaJed1dhVVwBmCifOYoLfBhUoLAHhvlnEAKHfJUGayAwBiNXLIJIBMEDE8NRbVVjte/OUw7Cqq8I5ZyklPwOJJg3FFahwOlBiwZlcxZuWkAaj9IWf20uFCK4aahII+WoG8DL3fdZwgiYio+3EDiBIkkDeo8yyXCIgSBJ+bR4m6KpOt+SEsLa0PBBP0VjJaHIBYW0ZHBFB5cWZQURSREK1AjEKKeKkE54x2PPnxUXggQBslR+/42uEodpcHafoo/GHCQPzxv8dxxmDBrJw0b/Je53SlBRVme7OxhGqoiU6jwPL8oY2S9LwMPSdIIiLqhlr63pTfq1J3oLl4z2Cg6wPBMeit5LDWJsUiaqu1eETAI4oQBAFyiQCLyw6PVIlL4zUY2T8Of/jwMJ6dnOn9qypWLff+AAckxiBJq/LWNbe7fvpqpG4m0eaEcqhJSqwaK6dmodzsQLXNiRiVvMOryRC1Rl0FFyIKraYqPDdR3IWoy9HIpchOT/A7zCU7PQEaORP0sLhQUQMbamucW0TgD5sO+fyQctIT8PTkIThrsKBXnAbXD0zGs58ch9nhRo3DjZz0BPSOU8PidEMU4R3uUqcuKc9OT8CB0wbv//39InTEUBOdhgk5RT6Py4l73/4KMqWK5RaJQsgC4A8b/V/3WAWduos516QDgE87yE5PwJxrMkKyPyboLThbZYEHQLXdDSiljZJzANhZVIGFmw5h2c1DUO34aURetc2JKIUMT03ORHm1DXU5ud3laZSUZ6cnYGZ2Gh587wAAYMXULEgEoVEVFw41IfqJ5GIFF7vdjhlv7mK5RaIgs6FxpxTge90j6uoqzHbYnB7cMKQnZmWnefO4cyYbbE43KmrsSOsRHdR9dpkEfdWqVXjhhRdQVlaGYcOGYeXKlRg5cmS73tNoccDhEWF1ulFtc0IQ0ORdvDuLKmB21G5X931gjEqOKIUUFqcbauVPw1KcHhE/VNRAEAQ8ceMgnDXUfk1fv076g+8dwKcP5sLlETnUhKgVWG6RKPjMDneL1z2iri5KJceda/ZiVk6ad3gyAJQabXj6k6NYf+9VQd9nl0jQP/jgA8ydOxevvfYaRo0ahZdffhljx47F8ePHkZiYGPD7lpls8Ii1BepjVHKYrC3XCa8bH56boUe0QgoBQJRcCg9qa8dKJQIgKtA7Vg21Qoo/bDyELUfPN3qvEX3jEKuRMyEnakHd8Ja6covsQScKntZc94i6Op1ajiv6xPpMUlQnJz0BOnXw7w3sElVcXnrpJcyePRszZ87EoEGD8Nprr0Gj0WD16tXtel+T1YVqqxMahRRymQBtCz+AGFXtjaACgGcmZ8LpcUOK2rHrcgBKiQCpR0SsWoa++igkalVYclMmq6YQtUPdWHRPCOrQEnV3rbnuEXV1KbFqPHPzEOSkJ/gsz0lPwDM3DwnJBJKdvgfd4XBg3759WLBggXeZRCLBmDFjsHv37na9t0YhhUQiQCmT4GBJFUb2i0dOegJ2+vm6Lyc9ATEKKSQA1Aop/vVtKW4YnAIZauvICgAgAtFRvsNUWDWFqHXqesqtVmujdRIObyEKiRiFtMXrHlF30DchCs//chiMVqc3X9Op5SGb3b3TJ+jl5eVwu91ISkryWZ6UlIRjx475fY3dbofd/lOtcZPJ5Hc7tUIKhUSABEDvODWUHiuemTwEf9h0yOdkVfcXVN2Ux1+drsDYwSmQSgT0iNO0eAysmkLdTWvbYMPX3PqnT+Gy2yBVNW5XoijCarVCqVRCpVKxmgtRM1rbBpVAq657RN1BSqw6ZAl5Q50+QQ/EsmXLsGTJkha3U8okUHhEQASStWp8UVyJq/vJsPxitZa6v6CiFVKoUFsf3e1xI+eSZCbcRM1obRtsSCpXNDmUxeNyYtYbBZBIJHh3zhjExsa2M0qirqvVbVAiQOMWsezmIbWFEKxOxKh/uu5Bwj+EiUKh049B1+v1kEqlOHfunM/yc+fOITk52e9rFixYAKPR6H2cPn3a73a96nq/BUAtAKP7x6PCLcFZkx2CIKLnxTt5z5psqHC4IZFL0buHlsk5UQta2wbbSiJXQJDJYbPZIIpNTa9CRK1tgz3iNM3ORtSab4mJqO06fYKuUCgwfPhwbN261bvM4/Fg69atGD16tN/XKJVKaLVan0dTeiREARIBNgDVDjdMVieiVTJEy2VQyaUY2FOLkWkJuKyn1qf0DhE1rS1tsK08LifuWr0bRqORSTpRE9p6HRTqesrr/pEItddHIgqJLjHEZe7cuZg+fTpGjBiBkSNH4uWXX0ZNTQ1mzpwZlPdnDwFRJyMIuOO17fjbb38OhUIBu90OlUrFselEAerN6yBRh+oSCfqvf/1rXLhwAU888QTKyspw+eWXY/PmzY1uHCWi7sPtcmLaq59j1W1ZuP+dryGKIt76TQ5iY2OZqBMRUUQTRH4HDJPJBJ1OB6PRGNSv2omodVrTBm02G3698jM47TYIUhlEt6tV/7ptFkhVGohuF0SPBzKFEm/fk8cedaJ6eB0kiixdogediKgp9WukS+QKuF1O3LZyizdRVyqbLhQnCAKTeCIi6nBM0AHvjWStqcVMRK0XExPTquS2NW3QZrPBabXC6bBBkMohup3t+tdlNuHWP37k7WmXCBK4XQ6f3ne5QoX/m3GlNwaVijeCU/i15fcwmG2QiNqutW2wIQ5xAXDmzBmkpqaGOwyiLqe1X5ezDRKFBtsgUXgFOmyMCTpqyzKWlpb6/JVjMpmQmpqK06dPd7vxeN352AEefzCPv7U9B/7aYKhiilQ8xq4jko4zWG0QiKzjClRnP4bOHj/Q+Y+hrfEH2oPOIS4AJBIJevfu7XddsGs0dybd+dgBHn9HHn9zbbC+7vAz4TF2HZ3pOFvbBoHOdVxN6ezH0NnjBzr/MYQ6/k4/URERERERUVfCBJ2IiIiIKIIwQW+CUqnE4sWLmy3B1lV152MHePyRePyRGFOw8Ri7jq56nF3huDr7MXT2+IHOfwwdFT9vEiUiIiIiiiDsQSciIiIiiiBM0ImIiIiIIggTdCIiIiKiCMIEnYiIiIgogjBBByCKIkwmE3i/LFF4sA0ShRfbIFFkYYIOoLq6GjqdDtXV1eEOhahbYhskCi+2QaLIwgSdiIiIiCiCMEEnIiIiIoogTNCJiIiIiCIIE3QiIiIioggSUQn6jh07MHHiRKSkpEAQBGzatKnF13zxxRe44ooroFQqkZ6ejrVr14Y8TiIiIiKiUJGFO4D6ampqMGzYMMyaNQu33HJLi9sXFxfjhhtuwG9/+1u8++672Lp1K37zm9+gZ8+eGDt2bEhjNVocKDc7YLQ6EKuRIUYihQtAtcsNUQREANU2F2KUMihkElRZHIhWyqCWS2F3uwERkEkkMFgciFLKoJZLYHd7oJJKIQEgB2AWRdicHpjtLmhVta/1eEQ0VQRLKgjwiCKkEgECgBqXG9VWF2JUMsilP8WgkUvhEUVYXR5UW12IUkoRpZQhVi2HTqPwOTaNUgaJIEAmEZAQpYBOo2j156JRyiABIAqABAKUMgnsLg+qbc4m37fu9SabE1q1HPom9tna7YKlbn9muxOxGgUcros/lw7YdygE8vl19GfenHMmGyprHKixOZEQrQQAWJxuWBxuaFUyyCW1v+8xKhli5FLAI8ItESAB4PGIECQC5AAEAJaLzwURcF9sPxIA8IhwXNxGBFBZ44BaIYVaLoVaIsAOERaHBzX22jamkEp8thEA2D0eiB5AIgE0MilcHhE1Tjcsdje06tq2qL3Y7oC2f8bNbX/OZEOVxeE9DwkC4BFFKKVSyKQCdA3ae1P7bG59uH4nIul3sSN11+Mm6o4EMUKLngqCgI0bN2Ly5MlNbjNv3jx88sknOHz4sHfZlClTYDAYsHnz5lbvy2QyQafTwWg0QqvVtrh9qcGKeesLUXCiHJckRuPdO0fACmDpx9/itiv7Ys3OYhQUVXi3z05PwMzsNDz43gEM7xOHxZMGobTKhrW7i3HbqL61y/vG4cmJg/DSlu/w2NhLAQhYuOmQz/vkpuuxeNIgVNXY4Wnip6aPUaLSbEd8tBIeEZj6+pcoNzt8Y+gbh/uvHoBZf/0aFofbG+ND12UgWavCHzYdRsGJ8kbxf/BVCZbclImUWHWLn0vD176/pwR35abhrgb7rHvfpTdlQgQavT4vQ4/l+UN99ulvP/62C5a6/e37oQorpmZhza5i7Kr3cwnlvkMhkM8v1J95W9pgSUUNFmw8hAMlBqy67Qqo5BK88nmRz8+k4e/7MzdlosZhg0ahhAQCKi1WxGnUkAGQQcRpsw2xUUoIACouth+5IEG1zQqzo/Y9LQ4P7l+3H1l9YrFkUiaW//sIPjt2we8+s/rEYs416UiIVuJPW44jf3gq3v+qBLNz+2Pm2r3eNlDbpgcjRiGFG637/a/T3M/E7fZgwcZD2OnnM1m35wfMzu0PuVRAYkzj9l5/n83tQwDwWAe2w9Ycd2dpg4GIpDZIRKHXqRP0vLw8XHHFFXj55Ze9y9asWYPf/e53MBqNrd5XW05MRosDc9474D1JbpmbB5VUgsc3HsKwPnE4WFLlc1Gsk52egKw+cXhlWxFy0xNw/7Xp2FlUgQMlVT8tz9BjxlX9cL7ajn8Xlvok53XqXvv9hRq/8QkA0npEofhCDdJ6RKHG7sZdf/26UQz1/1/n2Zsz8emhs373W7d94WkDVk7NatRr0/Bz8ffa+sfacF2vWDX+XXgWBUWNX5+Xoffus7n91N8uWOrvb8616ThQUuWTCIZy36EQyOfXEZ95a9vgOZMNc/9+ELuKKjDn2nSk6FT45NBZvz8TnzaXocezkzOxs6gCl/fRQaOQ4X9F5bgqXQ8JALPDhYMlBqT1iAIAb/vppVP7/E6WGm14ZVsRctITcHmD3+WG+8xOT8CNQ3oiUavC6l3FyOoTh29KqjCswety0xPw+A2D8OwnR1v8/a/T3M8kN0OP8ZnJeHzj4Ubr6rfFB65Nx6ptRX7be16GHi/cOgyP/uObJn/u44f0xIINh1oVb7B0dPuPFJHUBomoY0TUGPS2KisrQ1JSks+ypKQkmEwmWK3WJl9nt9thMpl8Hq1Vbnb4nCRdbhFmhxsFRRXISo31m5wDwK6L6wGgoKgCUUoZslJjfZefKEeiVonEGKXfi2b91yZpVX4fiVoVopSyev8q/cZQ//91krSqJvdbt/2OE+Uor+tSbOZz8fdaf/usW1Z7zP5fX3+fze2nqdjao/7+6o6ho/YdCoF8fqH4zANtg1U1Du/PICs1FklaVZM/k4Zty+xwI1GrhAgBFocbiVoVLA43zA43RAjeNlO//Zgdbp/2Vfd+O/38Ljfc566iCiRqVUjUKr3LC/y8rqCoAiLQqt//Os39TApOlCNJq2r2M9l18TzSVHvfcaIcVTXN/9wTY5RNrgtVW+jo9h8pIqkNVlZW4tSpU21+VFZWtjlGou4sosagd5Rly5ZhyZIlAb3WZHP6Prf+9Nzu8jT72vrrzTa393lTy5vS0jZ16802d7MxNHyP1sZf3eAzABp/Lk291t8+Wtpv/X22tB9/sbVH/f21FGew9x0KgXx+ofjMA22DJpvL+//W/N7U36ba6qy9B8LqrB0ffvH/QO0Y8/ptpu7/UqHpttaa5Q3fs6nXVVvb9hm3tr01t87f+cF3H65m1ze3j1C1hY5u/5EiUtpgZWUl0gYMgMlgaPP+tLGxKD55EvHx8W1+LVF31KkT9OTkZJw7d85n2blz56DVaqFWNz0mb8GCBZg7d673uclkQmpqaqv2qVXJfZ+rf3qulDX/hUT99dEqKSwOSbPLm9LSNnXro1XSZmNoGG9r449p8BkAjT+Xpl7rbx8t7bf+Plvaj7/Y2qP+/lqKM9j7DoVAPr9QfOaBtkGt6qdTVmt+b+pvE6OWo9ruQoxaDgHw/h+oTdDNdpe3zdS1H5lEgmq7/0S1qf03bGN179lcG4hRt+0zbm17a26dv/OD7z6avzw0t49QtYWObv+RIlLaoMlkgslgwLW//ws0sYmt3pfFcB7bXrgXJpOJCTpRK3XqIS6jR4/G1q1bfZZt2bIFo0ePbvZ1SqUSWq3W59Fa+mgF8jL03ucyqYBohRS5GXocOG1AbnqC39dlpyfgwGkDgNoxpzV2Fw6cNvguz9DjvMmO89V25NbbR311rz1nsvl9nDfZUGN31fvX7jeG+v+vc85kazH+vAw99NGNxzo2/Fz8vdbfPuuWna+2N/n6+vtsbj9NxdYe9fdXdwwdte9QCOTzC8VnHmgbjItSIOfiz+DAaQPOmWxN/kwatq1ohRTnTXYIEKFRSHHeZINGIUW0QgoBorfN1G8/0QqpT/uqe78cP7/LDfeZnZ6A8yYbzpvs3uW5fl6Xm54AAWjTZ9zcz6T2PGJr9jPJvngeaaq952XoERfV/M/9fLW9yXWhagsd3f4jRSS1QQDQxCYiSt+z1Y+2JPNEVCuiEnSz2YyDBw/i4MGDAGrLKB48eBAlJSUAav/iv/POO73b//a3v8X333+Pxx57DMeOHcOrr76Kv//973j44YdDFqNOo8Dy/KHek+X97+yHSgSeuSkTx86aMDMnDbnpvifSuuoJq3cWX6zakAmHU8SRUuNPyzP0WDJxEDbsP4Or+ifg6cmZjZL0utdKBQEDekT7fYzsnwCpIGBk/wToY5SYt76wcQwZejxwbQZW7yz2iTE9MRrP3Dyk0YWg7rXHz5rwXP5QvzcjNfxcGr72WKkJc65pvM+6973mkh5+X5+XoffZZ1P7abhdsNTf3+qdxZiZndYoIQzVvkMhkM+voz/z5iRpVXj25iHISU/A6p3F6KlTY8416Y1+Jg1/35+dnAmz3YarBiQgRiGDocaG7HQ95ACUImCxuzCyfwISY1Te9tNLp4bJavO2rZ46NVbvLEZ2egKenFTb3pvaZ3Z6AuZck4ERafH4577TtW3grAlzGrS7ujadoJa36TNu7mfyfP5Q5KTrvX/INIzvSKkRc67JgEwi+G3vdftM0qqajenqS3p0+O9EJP0udqTuetxE3VlEVXH54osvcM011zRaPn36dKxduxYzZszAqVOn8MUXX/i85uGHH8aRI0fQu3dvLFq0CDNmzGjTfgO5e/2net9OxGqkPnXQIQIe1NZBj1bKoJTV1jvXXKxBbnfX1kqXS+ovb7oOeo3dhegW6qAL+KkOuuRiHee6OujRF2s019Vc18ilcIsibBfroGuUUkQrZIjVNKyD7oRGIYVUIkDa5jrota+VCAJEiJAIApTS2mOstrmafN+611fbnIhRyaGPbr4OekvbBUvd/mrsTujUCjjcdfWvQ7/vUAjk8wvlZ97WNuitg253IiGqiTro1tq6/9oGddDdnto20lQddIlEgBSAeLEOugQ/1UFXKaTQXKyDboMIq+On9qm8WAdddbEOugQX66CLgERoXAc9RiVDlMJ/HfTWfsbNbV+/Dnq0UgZJ/TroEgG6Bu29qX02t76j22FrYurKwt0GT506hbS0NNz4zHpE6Xu2+r1rys/i4z/ko7i4GP369QtKvET/3969x1VV5f8ffx9QQERARQENJS3v4jWJyrRvFJY52jRG5qSR2kzpqFGNUimak6il6ZQzNpbir6l0ctIummUoZUaaeMnyUpqKmiBqCqKCwvr9Ye7pCCrokbOB1/PxOA/da6+99mexz4fzYZ999qnsbFWguwu3lwLcixwE3IsCHbAXW13iAgAAAFR1FOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCO2LNBnzpyp8PBw+fj4KDIyUmvXrr1o/+nTp6t58+aqUaOGwsLC9MQTT+jUqVPlFC0AAADgOrYr0BcsWKD4+HglJiZq/fr1ateunWJiYnTw4MES+7/99tsaPXq0EhMTtXXrVr3xxhtasGCBnnnmmXKOHAAAALhytivQp02bpiFDhiguLk6tWrXSrFmz5Ovrqzlz5pTY/6uvvtLNN9+sBx98UOHh4brzzjvVr1+/S551BwAAAOzIVgV6QUGB0tPTFR0dbbV5eHgoOjpaaWlpJW5z0003KT093SrIf/rpJy1dulR33333BfeTn5+vnJwcpweA8kMOAu5FDgL2ZqsC/dChQyosLFRwcLBTe3BwsDIzM0vc5sEHH9Tzzz+vW265RdWrV1fTpk3VvXv3i17ikpSUpICAAOsRFhbm0nkAuDhyEHAvchCwN1sV6JcjNTVVEydO1D/+8Q+tX79e7733npYsWaIJEyZccJuEhAQdO3bMeuzdu7ccIwZADgLuRQ4C9lbN3QH8VlBQkDw9PZWVleXUnpWVpZCQkBK3GTNmjB566CENHjxYktS2bVvl5eXp0Ucf1bPPPisPj+J/g3h7e8vb29v1EwBQKuQg4F7kIGBvtjqD7uXlpU6dOiklJcVqKyoqUkpKiqKiokrc5sSJE8WKcE9PT0mSMebqBQsAAABcBbY6gy5J8fHxGjhwoDp37qwuXbpo+vTpysvLU1xcnCRpwIABatiwoZKSkiRJvXr10rRp09ShQwdFRkZqx44dGjNmjHr16mUV6gAAAEBFYbsCPTY2VtnZ2Ro7dqwyMzPVvn17LVu2zPrgaEZGhtMZ8+eee04Oh0PPPfec9u/fr3r16qlXr1564YUX3DUFAAAA4LI5DNeBKCcnRwEBATp27Jj8/f3dHQ5Q5ZCDgHuVJgd3796ta6+9Vve88F/VDAot9dh5hw7oo2fv065duxQeHu6iiIHKzVbXoAMAAABVHQU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANmLLAn3mzJkKDw+Xj4+PIiMjtXbt2ov2P3r0qIYOHarQ0FB5e3urWbNmWrp0aTlFCwAAALhONXcHcL4FCxYoPj5es2bNUmRkpKZPn66YmBht375d9evXL9a/oKBAd9xxh+rXr6+FCxeqYcOG2rNnjwIDA8s/eAAAAOAK2a5AnzZtmoYMGaK4uDhJ0qxZs7RkyRLNmTNHo0ePLtZ/zpw5OnLkiL766itVr15dkhQeHl6eIQMAAAAuY6tLXAoKCpSenq7o6GirzcPDQ9HR0UpLSytxmw8++EBRUVEaOnSogoOD1aZNG02cOFGFhYXlFTYAAADgMrY6g37o0CEVFhYqODjYqT04OFjbtm0rcZuffvpJK1asUP/+/bV06VLt2LFDjz/+uE6fPq3ExMQSt8nPz1d+fr61nJOT47pJALgkchBwL3IQsDdbnUG/HEVFRapfv77+9a9/qVOnToqNjdWzzz6rWbNmXXCbpKQkBQQEWI+wsLByjBgAOQi4FzkI2JutCvSgoCB5enoqKyvLqT0rK0shISElbhMaGqpmzZrJ09PTamvZsqUyMzNVUFBQ4jYJCQk6duyY9di7d6/rJgHgkshBwL3IQcDerlqBXlhYqI0bN+qXX34p9TZeXl7q1KmTUlJSrLaioiKlpKQoKiqqxG1uvvlm7dixQ0VFRVbbDz/8oNDQUHl5eZW4jbe3t/z9/Z0eAMoPOQi4FzkI2JvLCvSRI0fqjTfekHS2OO/WrZs6duyosLAwpaamlnqc+Ph4zZ49W/PmzdPWrVv12GOPKS8vz7qry4ABA5SQkGD1f+yxx3TkyBGNGDFCP/zwg5YsWaKJEydq6NChrpoaAAAAUG5c9iHRhQsX6o9//KMk6cMPP9SuXbu0bds2vfnmm3r22We1evXqUo0TGxur7OxsjR07VpmZmWrfvr2WLVtmfXA0IyNDHh7/+7siLCxMn3zyiZ544glFRESoYcOGGjFihEaNGuWqqQEAAADlxmUF+qFDh6zrxJcuXaq+ffuqWbNmeuSRRzRjxowyjTVs2DANGzasxHUlnY2PiorS119/XeaYAQAAALtx2SUuwcHB2rJliwoLC7Vs2TLdcccdkqQTJ044fYATAAAAwIW57Ax6XFyc7r//foWGhsrhcFhfNrRmzRq1aNHCVbsBAAAAKjWXFejjxo1TmzZttHfvXvXt21fe3t6SJE9PT40ePdpVuwEAAAAqNZd+k+gf/vCHYm0DBw505S4AAACASu2KCvS///3vpe47fPjwK9kVAAAAUCVcUYH+8ssvl6qfw+GgQAcAAABK4YoK9F27drkqDgAAAABy4W0WzykoKND27dt15swZVw8NAAAAVHouK9BPnDihQYMGydfXV61bt1ZGRoYk6S9/+YsmTZrkqt0AAAAAlZrLCvSEhARt2rRJqamp8vHxsdqjo6O1YMECV+0GAAAAqNRcdpvFxYsXa8GCBbrxxhvlcDis9tatW2vnzp2u2g0AAABQqbnsDHp2drbq169frD0vL8+pYAcAAABwYS4r0Dt37qwlS5ZYy+eK8tdff11RUVGu2g0AAABQqbnsEpeJEyfqrrvu0pYtW3TmzBnNmDFDW7Zs0VdffaXPP//cVbsBAAAAKjWXnUG/5ZZbtHHjRp05c0Zt27bVp59+qvr16ystLU2dOnVy1W4AAACASs1lZ9AlqWnTppo9e7YrhwQAAACqFJcW6IWFhVq0aJG2bt0qSWrVqpV69+6tatVcuhsAAACg0nJZ5fz999/rd7/7nTIzM9W8eXNJ0uTJk1WvXj19+OGHatOmjat2BQAAAFRaLrsGffDgwWrdurX27dun9evXa/369dq7d68iIiL06KOPumo3AAAAQKXmsjPoGzdu1Lp161S7dm2rrXbt2nrhhRd0ww03uGo3AAAAQKXmsjPozZo1U1ZWVrH2gwcP6rrrrnPVbgAAAIBK7YoK9JycHOuRlJSk4cOHa+HChdq3b5/27dunhQsXauTIkZo8ebKr4gUAAAAqtSu6xCUwMND6xlBJMsbo/vvvt9qMMZKkXr16qbCw8Ep2BQAAAFQJV1Sgr1y50lVxAAAAANAVFujdunVzVRwAAABAuTly5IhycnLKvJ2/v7/q1KlzFSL6H5d/g9CJEyeUkZGhgoICp/aIiAhX7woAAAAosyNHjujapk2Vc/Rombf1DwzUrp07r2qR7rICPTs7W3Fxcfr4449LXM816AAAALCDnJwc5Rw9qv97+p/yDaxf6u1OHD2oFS8+ppycnIpRoI8cOVJHjx7VmjVr1L17dy1atEhZWVn629/+pqlTp7pqNwAAAIBL+AbWV82gUHeHUYzLCvQVK1bo/fffV+fOneXh4aHGjRvrjjvukL+/v5KSktSzZ09X7QoAAACotFz2RUV5eXmqX//sWwS1a9dWdna2JKlt27Zav359mcaaOXOmwsPD5ePjo8jISK1du7ZU282fP18Oh0N9+vQp0/4AAAAAu3BZgd68eXNt375dktSuXTu99tpr2r9/v2bNmqXQ0NK/dbBgwQLFx8crMTFR69evV7t27RQTE6ODBw9edLvdu3frqaeeUteuXa9oHgAAAIA7uaxAHzFihA4cOCBJSkxM1Mcff6ywsDDNmDFDEydOLPU406ZN05AhQxQXF6dWrVpp1qxZ8vX11Zw5cy64TWFhofr376/x48erSZMmVzwXAAAAwF1cdg36H//4R+v/nTp10p49e7Rt2zY1atRIQUFBpRqjoKBA6enpSkhIsNo8PDwUHR2ttLS0C273/PPPq379+ho0aJBWrVp1+ZMAAAAA3OyKCvT4+PhS9502bdol+xw6dEiFhYUKDg52ag8ODta2bdtK3ObLL7/UG2+8oY0bN5Y6lvz8fOXn51vLl3OTegCXjxwE3IscBOztigr0DRs2lKqfw+G4kt1cUG5urh566CHNnj271GfpJSkpKUnjx4+/KjEBuDRyEHAvchCwtysq0FeuXOmqOCRJQUFB8vT0VFZWllN7VlaWQkJCivXfuXOndu/erV69elltRUVFkqRq1app+/btatq0abHtEhISnM7+5+TkKCwszFXTAHAJ5CDgXuQgYG8uuwbdFby8vNSpUyelpKRYt0osKipSSkqKhg0bVqx/ixYttHnzZqe25557Trm5uZoxY8YFf9l4e3vL29vb5fEDKB1yEHAvchCwN1sV6NLZ69oHDhyozp07q0uXLpo+fbry8vIUFxcnSRowYIAaNmyopKQk+fj4qE2bNk7bBwYGSlKxdgAAAKAisF2BHhsbq+zsbI0dO1aZmZlq3769li1bZn1wNCMjQx4eLrs7JAAAAGArtivQJWnYsGElXtIiSampqRfdNjk52fUBAQAAAOWEU9EAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICNUKADAAAANkKBDgAAANgIBToAAABgIxToAAAAgI1QoAMAAAA2QoEOAAAA2AgFOgAAAGAjFOgAAACAjVCgAwAAADZCgQ4AAADYCAU6AAAAYCMU6AAAAICN2LJAnzlzpsLDw+Xj46PIyEitXbv2gn1nz56trl27qnbt2qpdu7aio6Mv2h8AAACwM9sV6AsWLFB8fLwSExO1fv16tWvXTjExMTp48GCJ/VNTU9WvXz+tXLlSaWlpCgsL05133qn9+/eXc+QAAADAlbNdgT5t2jQNGTJEcXFxatWqlWbNmiVfX1/NmTOnxP5vvfWWHn/8cbVv314tWrTQ66+/rqKiIqWkpJRz5AAAAMCVq+buAH6roKBA6enpSkhIsNo8PDwUHR2ttLS0Uo1x4sQJnT59WnXq1Llgn/z8fOXn51vLOTk5lx80gDIjBwH3IgcBe7PVGfRDhw6psLBQwcHBTu3BwcHKzMws1RijRo1SgwYNFB0dfcE+SUlJCggIsB5hYWFXFDeAsiEHAfciBwF7s1WBfqUmTZqk+fPna9GiRfLx8blgv4SEBB07dsx67N27txyjBEAOAu5FDgL2ZqtLXIKCguTp6amsrCyn9qysLIWEhFx025deekmTJk3SZ599poiIiIv29fb2lre39xXHC+DykIOAe5GDgL3Z6gy6l5eXOnXq5PQBz3Mf+IyKirrgdlOmTNGECRO0bNkyde7cuTxCBQAAAK4KW51Bl6T4+HgNHDhQnTt3VpcuXTR9+nTl5eUpLi5OkjRgwAA1bNhQSUlJkqTJkydr7NixevvttxUeHm5dq+7n5yc/Pz+3zQMAAAC4HLYr0GNjY5Wdna2xY8cqMzNT7du317Jly6wPjmZkZMjD438n/v/5z3+qoKBAf/jDH5zGSUxM1Lhx48ozdAAAAOCK2a5Al6Rhw4Zp2LBhJa5LTU11Wt69e/fVDwgAAAAoJ7a6Bh0AAACo6ijQAQAAABuhQAcAAABshAIdAAAAsBEKdAAAAMBGKNABAAAAG6FABwAAAGyEAh0AAACwEQp0AAAAwEYo0AEAAAAboUAHAAAAbIQCHQAAALARCnQAAADARijQAQAAABuhQAcAAABshAIdAAAAsBEKdAAAAMBGKNABAAAAG6FABwAAAGyEAh0AAACwEQp0AAAAwEYo0AEAAAAboUAHAAAAbIQCHQAAALARCnQAAADARijQAQAAABuhQAcAAABshAIdAAAAsBFbFugzZ85UeHi4fHx8FBkZqbVr1160/7vvvqsWLVrIx8dHbdu21dKlS8spUgAAAMC1qrk7gPMtWLBA8fHxmjVrliIjIzV9+nTFxMRo+/btql+/frH+X331lfr166ekpCTdc889evvtt9WnTx+tX79ebdq0cUlM2b+ckIqMzujsDyxfUm5BoXJOnpZ/jery8/KUz699c4sKVcPDUx6SjhcVyvfX/xdJKigyCqzppQBfL5fEBVQV53LwXO7lnjytWjWqq6aXp6rrf7/IzujsWQfrzIOHQ/Vq+7ohYgAALp/tzqBPmzZNQ4YMUVxcnFq1aqVZs2bJ19dXc+bMKbH/jBkz1KNHDz399NNq2bKlJkyYoI4dO+rVV191STzZh/OkQqN8I1UzRieMNGrRZt01Y5Vi//W17pqxSgmLNivPSDJSLYenZqTuUL6Rajg89OJnPyjfSMZIng6Hkj7eqp+PnnRJbEBVcC4Hf5t79/+ae88s2qy8wiKd+jX/qhnpVNHZfJWRVGiUeTjPzTMAAKBsbFWgFxQUKD09XdHR0Vabh4eHoqOjlZaWVuI2aWlpTv0lKSYm5oL9y2LfLyd0StIph5R7+oxOORx6ZvFmrd5x2KnflzsO67nFm3XKcbbvoK5N9Oz736nQ4dDDN1/76/+lAmM0qGsTjf7vtzp2ouCK4wMqu9/m4IVyb9wH32t/zkkr/+Th0L6cU9by6V/HAQCgorDVJS6HDh1SYWGhgoODndqDg4O1bdu2ErfJzMwssX9mZuYF95Ofn6/8/HxrOScnp8R+uafOWP83cuh4QWGxAuGcL3cc1vGCQmt51Y+HdLygUNU8Paz/n/PFj4d06HgBl7qgyrqcHLxY7o26q4VTjtX09nRaBuCstDkIwD1sVaCXl6SkJI0fP/6S/XJOni7TuLnn9c89eVrmQutOlW1soDJxdQ4eP1UoT8f/CvJCI6dlOcocIlCplTYHAbiHrS5xCQoKkqenp7Kyspzas7KyFBISUuI2ISEhZeovSQkJCTp27Jj12Lt3b4n9/GtUtx61fv33Ymr92q/Wr/1K+r+17HPxsYDK7HJy8GL8fDydcuz8ZfINcFbaHATgHrYq0L28vNSpUyelpKRYbUVFRUpJSVFUVFSJ20RFRTn1l6Tly5dfsL8keXt7y9/f3+lRklo+1eTn5Sk/L085ZOTn5albrqtbYt9brqtr9a3m6VDX64Pk5+WpM4VF1v+9q3momqdDt14fpCA/Lm9B1XU5OXix3MvLP2P18/XyVF5+obXs5+WpWj5V8s1C4IJKm4MA3MNWBbokxcfHa/bs2Zo3b562bt2qxx57THl5eYqLi5MkDRgwQAkJCVb/ESNGaNmyZZo6daq2bdumcePGad26dRo2bNgVx3JNbV/5SPIxUq3q1eRjjF7o07ZYoXDLdXX1wr1tz/aV9MaqnzSxTxt5Gil59S5N7NNG1SR5eTj0xqqfNPm+CK4/B0rhtzl4odwb97s2ahhQw8o/FRmFBfhYy9V/HQcAgIrCdqeVYmNjlZ2drbFjxyozM1Pt27fXsmXLrA+CZmRkyMPjf39X3HTTTXr77bf13HPP6ZlnntH111+vxYsXu+we6PXq1lT2LyfkXWR0Rg75Spp0b9uz92I+dVq1fIrfB31E9+vO3gfdFOrp6GbWfdALi4wS7mpJcQ6Uwbkc9C0yxXLP18tTXnK+D7qPh8PpPughFOcAgArGdgW6JA0bNuyCZ8BTU1OLtfXt21d9+/a9avGU5YtO6v3m/8EX7AWgLPiyIQBAVWK7S1wAAACAqowCHQAAALARCnQAAADARmx5DXp5M+bs1wnxTWqAa9WqVUsOx6W/JYgcBK4OV+Zgbm6uJOn4oUwVFpb+m3pP/pItSdq2bZs1BuBu+/fvl3T5z+fc3NxSvWaVNgfP5zDnsrIK27dvn8LCwtwdBlDpHDt2rFT3VyYHgauDHATcq7Q5eD4KdJ39MqSff/7Z6a+cnJwchYWFae/evVXuCxyq8twl5u/K+Zf2zEFJOXi1YrIr5lh52GmerspByV7zulwVfQ4VPX6p4s+hrPFf7hl0LnGR5OHhoWuuuabEdVX5G9aq8twl5l+e879YDv5WVTgmzLHyqEjzLG0OShVrXhdS0edQ0eOXKv4crnb8fEgUAAAAsBEKdAAAAMBGKNAvwNvbW4mJifL29nZ3KOWuKs9dYv52nL8dY3I15lh5VNZ5VoZ5VfQ5VPT4pYo/h/KKnw+JAgAAADbCGXQAAADARijQAQAAABuhQAcAAABshAIdAAAAsBEK9BLMnDlT4eHh8vHxUWRkpNauXevukK6KcePGyeFwOD1atGhhrT916pSGDh2qunXrys/PT/fdd5+ysrLcGPHl++KLL9SrVy81aNBADodDixcvdlpvjNHYsWMVGhqqGjVqKDo6Wj/++KNTnyNHjqh///7y9/dXYGCgBg0apOPHj5fjLC7fpeb/8MMPF3su9OjRw6mPu+ZfmfKxsuZcVcivipxDF1PW/Hr33XfVokUL+fj4qG3btlq6dKnT+tIca3fFP3v2bHXt2lW1a9dW7dq1FR0dXax/aY6jO+eQnJxcLD4fHx+nPnY+Bt27dy8Wv8PhUM+ePa0+5XkMLpXXJUlNTVXHjh3l7e2t6667TsnJycX6uOJ1iwL9PAsWLFB8fLwSExO1fv16tWvXTjExMTp48KC7Q7sqWrdurQMHDliPL7/80lr3xBNP6MMPP9S7776rzz//XD///LN+//vfuzHay5eXl6d27dpp5syZJa6fMmWK/v73v2vWrFlas2aNatasqZiYGJ06dcrq079/f33//fdavny5PvroI33xxRd69NFHy2sKV+RS85ekHj16OD0X3nnnHaf17ph/ZczHyphzVSG/KmoOXUxZ8+urr75Sv379NGjQIG3YsEF9+vRRnz599N1331l9SnOs3RV/amqq+vXrp5UrVyotLU1hYWG68847tX//fqd+lzqO7pyDdPYbLH8b3549e5zW2/kYvPfee06xf/fdd/L09FTfvn2d+pXXMShNXv/Wrl271LNnT912223auHGjRo4cqcGDB+uTTz6x+rjsdcvASZcuXczQoUOt5cLCQtOgQQOTlJTkxqiujsTERNOuXbsS1x09etRUr17dvPvuu1bb1q1bjSSTlpZWThFeHZLMokWLrOWioiITEhJiXnzxRavt6NGjxtvb27zzzjvGGGO2bNliJJlvvvnG6vPxxx8bh8Nh9u/fX26xu8L58zfGmIEDB5revXtfcBt3zb+y5WNVyLmqkF8VKYcupqz5df/995uePXs6tUVGRpo//elPxpjSHWt3xn++M2fOmFq1apl58+ZZbZc6jq5W1jnMnTvXBAQEXHC8inYMXn75ZVOrVi1z/Phxq628j8E5JeX1+f7617+a1q1bO7XFxsaamJgYa9lVr1ucQf+NgoICpaenKzo62mrz8PBQdHS00tLS3BjZ1fPjjz+qQYMGatKkifr376+MjAxJUnp6uk6fPu30s2jRooUaNWpU6X4Wu3btUmZmptNcAwICFBkZac01LS1NgYGB6ty5s9UnOjpaHh4eWrNmTbnHfDWkpqaqfv36at68uR577DEdPnzYWueO+VfWfKxqOVeV8stuOXQxl5NfaWlpTv0lKSYmxupfmmPtzvjPd+LECZ0+fVp16tRxar/YcXSly53D8ePH1bhxY4WFhal37976/vvvrXUV7Ri88cYbeuCBB1SzZk2n9vI6BmV1qRxw5esWBfpvHDp0SIWFhQoODnZqDw4OVmZmppuiunoiIyOVnJysZcuW6Z///Kd27dqlrl27Kjc3V5mZmfLy8lJgYKDTNpXxZ3FuPhc77pmZmapfv77T+mrVqqlOnTqV4ufRo0cP/b//9/+UkpKiyZMn6/PPP9ddd92lwsJCSe6Zf2XMx6qYc1Ulv+yYQxdzOfmVmZl5yeN4rq20Y14uV/x+GDVqlBo0aOBUTF3qOLrS5cyhefPmmjNnjt5//339+9//VlFRkW666Sbt27dPUsU6BmvXrtV3332nwYMHO7WX5zEoqwvlQE5Ojk6ePOnS161qVxwtKqy77rrL+n9ERIQiIyPVuHFj/ec//1GNGjXcGBnK2wMPPGD9v23btoqIiFDTpk2Vmpqq22+/3Y2RVS7kXOVFDlUskyZN0vz585Wamur0IUu7H8eoqChFRUVZyzfddJNatmyp1157TRMmTHBjZGX3xhtvqG3bturSpYtTu92PQXnhDPpvBAUFydPTs9hdE7KyshQSEuKmqMpPYGCgmjVrph07digkJEQFBQU6evSoU5/K+LM4N5+LHfeQkJBiH/A4c+aMjhw5Uul+HpLUpEkTBQUFaceOHZLcM/+qkI9VIeeqan7ZIYcu5nLyKyQk5JLH8Vxbace8XFfy++Gll17SpEmT9OmnnyoiIuKifc8/jq7kit9x1atXV4cOHZyeZ+fGuNwxS+tK4s/Ly9P8+fM1aNCgS+7nah6DsrpQDvj7+6tGjRoufd2iQP8NLy8vderUSSkpKVZbUVGRUlJSnP5irayOHz+unTt3KjQ0VJ06dVL16tWdfhbbt29XRkZGpftZXHvttQoJCXGaa05OjtasWWPNNSoqSkePHlV6errVZ8WKFSoqKlJkZGS5x3y17du3T4cPH1ZoaKgk98y/KuRjVci5qppfdsihi7mc/IqKinLqL0nLly+3+pfmWLszfunsHU4mTJigZcuWOX0e4ELOP46u5IrfcYWFhdq8ebMVX0U4BtLZ23Xm5+frj3/84yX3czWPQVldKgdc+rpVpo+UVgHz58833t7eJjk52WzZssU8+uijJjAw0GRmZro7NJd78sknTWpqqtm1a5dZvXq1iY6ONkFBQebgwYPGGGP+/Oc/m0aNGpkVK1aYdevWmaioKBMVFeXmqC9Pbm6u2bBhg9mwYYORZKZNm2Y2bNhg9uzZY4wxZtKkSSYwMNC8//775ttvvzW9e/c21157rTl58qQ1Ro8ePUyHDh3MmjVrzJdffmmuv/56069fP3dNqUwuNv/c3Fzz1FNPmbS0NLNr1y7z2WefmY4dO5rrr7/enDp1yhrDHfOvbPlYWXOuKuRXRc2hi7lUfj300ENm9OjRVv/Vq1ebatWqmZdeesls3brVJCYmmurVq5vNmzdbfUpzrN0V/6RJk4yXl5dZuHChOXDggPXIzc01xphSH0d3zmH8+PHmk08+MTt37jTp6enmgQceMD4+Pub77793mqddj8E5t9xyi4mNjS3WXt7H4FK/u0aPHm0eeughq/9PP/1kfH19zdNPP222bt1qZs6caTw9Pc2yZcusPq563aJAL8Err7xiGjVqZLy8vEyXLl3M119/7e6QrorY2FgTGhpqvLy8TMOGDU1sbKzZsWOHtf7kyZPm8ccfN7Vr1za+vr7m3nvvNQcOHHBjxJdv5cqVRlKxx8CBA40xZ29NNWbMGBMcHGy8vb3N7bffbrZv3+40xuHDh02/fv2Mn5+f8ff3N3FxcdYvdru72PxPnDhh7rzzTlOvXj1TvXp107hxYzNkyJBiv0zcNf/KlI+VNeeqQn5V5By6mIvlV7du3axjeM5//vMf06xZM+Pl5WVat25tlixZ4rS+NMfaXfE3bty4xGOYmJhojDGlPo7unMPIkSOtvsHBwebuu+8269evdxrPzsfAGGO2bdtmJJlPP/202FjlfQwu9btr4MCBplu3bsW2ad++vfHy8jJNmjQxc+fOLTauK163HMYYU7Zz7gAAAACuFq5BBwAAAGyEAh0AAACwEQp0AAAAwEYo0AEAAAAboUAHAAAAbIQCHQAAALARCnQAAADARijQUSE8/PDD6tOnj9v3M27cOLVv377c4wLcxeFwaPHixe4OA6jQunfvrpEjR5aqb2pqqhwOh44ePXpF+wwPD9f06dOvaAy4DwV6BfPwww/L4XDoz3/+c7F1Q4cOlcPh0MMPP1z+gbnI7t275XA4tHHjRneHUiozZsxQcnKyu8NAJZSdna3HHntMjRo1kre3t0JCQhQTE6PVq1e7O7SroqQ/BM7/gxgAqgoK9AooLCxM8+fP18mTJ622U6dO6e2331ajRo2uaOzTp09faXhuGdtdAgICFBgY6O4wUAndd9992rBhg+bNm6cffvhBH3zwgbp3767Dhw+7OzQAwFVGgV4BdezYUWFhYXrvvfestvfee0+NGjVShw4drLZly5bplltuUWBgoOrWrat77rlHO3futNafO1u9YMECdevWTT4+Pnrrrbd05swZDR8+3Npu1KhRGjhwoNOlHJc7tiS9/vrratmypXx8fNSiRQv94x//sLa79tprJUkdOnSQw+FQ9+7dneb+0ksvKTQ0VHXr1tXQoUOdiv78/Hw99dRTatiwoWrWrKnIyEilpqZa65OTkxUYGKhPPvlELVu2lJ+fn3r06KEDBw5c8Gf9zTffqF69epo8eXKJ68+/xKV79+4aNmyYhg0bpoCAAAUFBWnMmDEyxlh9wsPDNWHCBPXr1081a9ZUw4YNNXPmTKdxjx49qsGDB6tevXry9/fX//3f/2nTpk0XjBOVy9GjR7Vq1SpNnjxZt912mxo3bqwuXbooISFBv/vd76w+F3uOnDv7/Oabbyo8PFwBAQF64IEHlJuba/Xp3r27hg8frr/+9a+qU6eOQkJCNG7cuGLxHDp0SPfee698fX11/fXX64MPPrDWncur31q8eLEcDodT2/vvv6+OHTvKx8dHTZo00fjx43XmzBlJZ3NCku699145HA6Fh4crOTlZ48eP16ZNm+RwOORwOKx3q8gPVGRvvvmmOnfurFq1aikkJEQPPvigDh48WKzf6tWrFRERIR8fH91444367rvvnNZ/+eWX6tq1q2rUqKGwsDANHz5ceXl5Je7TGKNx48ZZ78g1aNBAw4cPvyrzg2tQoFdQjzzyiObOnWstz5kzR3FxcU598vLyFB8fr3Xr1iklJUUeHh669957VVRU5NRv9OjRGjFihLZu3aqYmBhNnjxZb731lubOnavVq1crJyen2FvPlzv2W2+9pbFjx+qFF17Q1q1bNXHiRI0ZM0bz5s2TJK1du1aS9Nlnn+nAgQNOf4SsXLlSO3fu1MqVKzVv3jwlJyc7XV4ybNgwpaWlaf78+fr222/Vt29f9ejRQz/++KPV58SJE3rppZf05ptv6osvvlBGRoaeeuqpEn/GK1as0B133KEXXnhBo0aNusQR+Z958+apWrVqWrt2rWbMmKFp06bp9ddfd+rz4osvql27dtqwYYP1M1q+fLm1vm/fvjp48KA+/vhjpaenq2PHjrr99tt15MiRUseBisvPz09+fn5avHix8vPzS+xTmufIzp07tXjxYn300Uf66KOP9Pnnn2vSpElO48ybN081a9bUmjVrNGXKFD3//PNOz0VJGj9+vO6//359++23uvvuu9W/f/8yPRdXrVqlAQMGaMSIEdqyZYtee+01JScn64UXXpB09g9hSZo7d64OHDigb775RrGxsXryySfVunVrHThwQAcOHFBsbGyp5w7Y1enTpzVhwgRt2rRJixcv1u7du0u8NPXpp5/W1KlTrRNFvXr1sk5K7dy5Uz169NB9992nb7/9VgsWLNCXX36pYcOGlbjP//73v3r55Zf12muv6ccff9TixYvVtm3bqzlNXCmDCmXgwIGmd+/e5uDBg8bb29vs3r3b7N692/j4+Jjs7GzTu3dvM3DgwBK3zc7ONpLM5s2bjTHG7Nq1y0gy06dPd+oXHBxsXnzxRWv5zJkzplGjRqZ3794XjKu0Yzdt2tS8/fbbTm0TJkwwUVFRTttt2LCh2LwbN25szpw5Y7X17dvXxMbGGmOM2bNnj/H09DT79+932u722283CQkJxhhj5s6daySZHTt2WOtnzpxpgoODnfbTu3dv89577xk/Pz8zf/58p/ESExNNu3btivU/p1u3bqZly5amqKjIahs1apRp2bKltdy4cWPTo0cPp3FjY2PNXXfdZYwxZtWqVcbf39+cOnXKqU/Tpk3Na6+9ZlA1LFy40NSuXdv4+PiYm266ySQkJJhNmzYZY0r3HElMTDS+vr4mJyfHWv/000+byMhIa7lbt27mlltucRrjhhtuMKNGjbKWJZnnnnvOWj5+/LiRZD7++GNjzNm8CggIcBpj0aJF5rcvL7fffruZOHGiU58333zThIaGOu1n0aJFTn3Oz7fSzh2wm27dupkRI0aUuO6bb74xkkxubq4xxpiVK1caSU6vP4cPHzY1atQwCxYsMMYYM2jQIPPoo486jbNq1Srj4eFhTp48aYw5+1rz8ssvG2OMmTp1qmnWrJkpKChw8cxwtVRzz58FuFL16tVTz549lZycLGOMevbsqaCgIKc+P/74o8aOHas1a9bo0KFD1tntjIwMtWnTxurXuXNn6//Hjh1TVlaWunTpYrV5enqqU6dOTmfHL2fsvLw87dy5U4MGDdKQIUOs9jNnziggIOCSc27durU8PT2t5dDQUG3evFmStHnzZhUWFqpZs2ZO2+Tn56tu3brWsq+vr5o2beo0xvlvLa5Zs0YfffSRFi5ceFl3aLnxxhud3t6PiorS1KlTVVhYaMUfFRXltE1UVJT1aftNmzbp+PHjTnFL0smTJ50uI0Lldt9996lnz55atWqVvv76a3388ceaMmWKXn/9deXl5ZXqORIeHq5atWpZyyU93yMiIpyWL9WnZs2a8vf3L/Et+QvZtGmTVq9ebZ0xl6TCwkKdOnVKJ06ckK+vb5nGIj9QkaWnp2vcuHHatGmTfvnlF6fXz1atWln9fvs6UadOHTVv3lxbt26VdDYPvv32W+vSUensZSxFRUXatWuXWrZs6bTPvn37avr06WrSpIl69Oihu+++W7169VK1apSBdsWRqcAeeeQR6+2s869hlqRevXqpcePGmj17tho0aKCioiK1adNGBQUFTv1q1qxZ5n1fztjHjx+XJM2ePVuRkZFO/X5beF9I9erVnZYdDof1i+348ePy9PRUenp6sbH8/PwuOob5zfXhktS0aVPVrVtXc+bMUc+ePYttc7UdP35coaGhTtfPn8MHUqsWHx8f3XHHHbrjjjs0ZswYDR48WImJiXr88cdL9Ry5WM64qo+Hh0exHDr/A+HHjx/X+PHj9fvf/77EOZYF+YGKLC8vTzExMdYln/Xq1VNGRoZiYmKKvX5ezPHjx/WnP/2pxOvIS7pZRFhYmLZv367PPvtMy5cv1+OPP64XX3xRn3/+ebm/xqF0KNArsB49eqigoEAOh0MxMTFO6w4fPqzt27dr9uzZ6tq1q6SzHyi5lICAAAUHB+ubb77RrbfeKunsma7169dbtzu73LGDg4PVoEED/fTTT+rfv3+Jfby8vKx9lkWHDh1UWFiogwcPWjFdrqCgIL333nvq3r277r//fv3nP/8p0y+wNWvWOC1//fXXuv76653+cPj666+L9Tl3xqNjx47KzMxUtWrVrA/PAZLUqlUrLV682FbPkXr16ik3N1d5eXnWH+Tn3ya1Y8eO2r59u6677roLjlO9evViee/l5VWszU5zB8pq27ZtOnz4sCZNmqSwsDBJ0rp160rs+/XXX1vF9i+//KIffvjB6XViy5YtF82p89WoUUO9evVSr169NHToULVo0UKbN29Wx44dr3BWuBoo0CswT09P6+2u888a165dW3Xr1tW//vUvhYaGKiMjQ6NHjy7VuH/5y1+UlJSk6667Ti1atNArr7yiX375xbps40rGHj9+vIYPH66AgAD16NFD+fn5WrdunX755RfFx8erfv36qlGjhpYtW6ZrrrlGPj4+pbr8pVmzZurfv78GDBigqVOnqkOHDsrOzlZKSooiIiLUs2fPUsV3Tv369bVixQrddttt6tevn+bPn1/qtwIzMjIUHx+vP/3pT1q/fr1eeeUVTZ061anP6tWrNWXKFPXp00fLly/Xu+++qyVLlkiSoqOjFRUVpT59+mjKlClq1qyZfv75Zy1ZskT33nuv02VDqJwOHz6svn376pFHHlFERIRq1aqldevWacqUKerdu7etniORkZHy9fXVM888o+HDh2vNmjXFvhtg7Nixuueee9SoUSP94Q9/kIeHhzZt2qTvvvtOf/vb3ySdvRwnJSVFN998s7y9vVW7dm2Fh4dr165d2rhxo6655hrVqlXLVnMHyqpRo0by8vLSK6+8oj//+c/67rvvNGHChBL7Pv/886pbt66Cg4P17LPPKigoyLrsctSoUbrxxhs1bNgwDR48WDVr1tSWLVu0fPlyvfrqq8XGSk5OVmFhoZWv//73v1WjRg01btz4ak4XV4C7uFRw/v7+8vf3L9bu4eGh+fPnKz09XW3atNETTzyhF198sVRjjho1Sv369dOAAQMUFRUlPz8/xcTEWG9FX8nYgwcP1uuvv665c+eqbdu26tatm5KTk63bK1arVk1///vf9dprr6lBgwbq3bt3KX8SZ+8AMWDAAD355JNq3ry5+vTpo2+++eay7w0fEhKiFStWaPPmzerfv3+pz+oPGDBAJ0+eVJcuXTR06FCNGDFCjz76qFOfJ598UuvWrVOHDh30t7/9TdOmTbPeBXE4HFq6dKluvfVWxcXFqVmzZnrggQe0Z88eBQcHX9ZcULH4+fkpMjJSL7/8sm699Va1adNGY8aM0ZAhQ/Tqq6/a6jlSp04d/fvf/9bSpUvVtm1bvfPOO8Vu1RgTE6OPPvpIn376qW644QbdeOONevnll52Kg6lTp2r58uUKCwuzbhd73333qUePHrrttttUr149vfPOO7aaO1BW9erVU3Jyst599121atVKkyZN0ksvvVRi30mTJmnEiBHq1KmTMjMz9eGHH1rvMkdEROjzzz/XDz/8oK5du6pDhw4aO3asGjRoUOJYgYGBmj17tm6++WZFRETos88+04cffljssxywD4c5/+JB4DxFRUVq2bKl7r///gv+pY+zunfvrvbt21/065XDw8M1cuTIUn/tMwAAqFq4xAXF7NmzR59++qm6deum/Px8vfrqq9q1a5cefPBBd4cGAABQ6XGJC4rx8PBQcnKybrjhBt18883avHmzPvvss2K3bQIAAIDrcYkLAAAAYCOcQQcAAABshAIdAAAAsBEKdAAAAMBGKNABAAAAG6FABwAAAGyEAh0AAACwEQp0AAAAwEYo0AEAAAAboUAHAAAAbOT/A9c12D19wtD8AAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "sns.pairplot(data)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zlFx15wcyJxl"
      },
      "source": [
        "# Subtask 1.5\n",
        "\n",
        "### Split the data to inputs and outputs\n",
        "\n",
        "We consider the data from Margarethenklippe and Sennhuette, i.e. the first two columns, as the input and design a classifier based on the perceptron algorithm to detect flood events.\n",
        "Therefore, we have:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t9x-1oqZyJxl"
      },
      "outputs": [],
      "source": [
        "# TODO fill in the missing lines\n",
        "X = data[['Margarethenklippe', 'Sennhuette']].values\n",
        "y = data['labels'].values\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9YZ6B0mRyJxl",
        "outputId": "bcccbdb7-1c8f-43f5-f8cd-e74c91674944"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input statistics of Margarethenklippe:\n",
            "Count:  6250\n",
            "Mean:  [10.55344   7.821264]\n",
            "Std:  [6.39627906 6.64166779]\n",
            "Min:  [3.7 1.5]\n",
            "Max:  [155.8 170.4]\n",
            "Input statistics of Sennhuette:\n",
            "Count:  6250\n",
            "Mean:  [5.3  5.25 5.1  ... 5.15 4.95 4.95]\n",
            "Std:  [1.2  1.15 1.2  ... 1.65 1.75 1.85]\n",
            "Min:  [4.1 4.1 3.9 ... 3.5 3.2 3.1]\n",
            "Max:  [6.5 6.4 6.3 ... 6.8 6.7 6.8]\n",
            "\n",
            "Output statistics:\n",
            "Count:  6250\n",
            "Mean:  0.3208\n",
            "Std:  0.46678406142455203\n",
            "Min:  0.0\n",
            "Max:  1.0\n"
          ]
        }
      ],
      "source": [
        "## TODO # Compute the statistics of the input data\n",
        "print(\"Input statistics of Margarethenklippe:\")\n",
        "print(\"Count: \", len(X))\n",
        "print(\"Mean: \", np.mean(X, axis=0))\n",
        "print(\"Std: \", np.std(X, axis=0))\n",
        "print(\"Min: \", np.min(X, axis=0))\n",
        "print(\"Max: \", np.max(X, axis=0))\n",
        "print(\"Input statistics of Sennhuette:\")\n",
        "print(\"Count: \", len(X))\n",
        "print(\"Mean: \", np.mean(X, axis=1))\n",
        "print(\"Std: \", np.std(X, axis=1))\n",
        "print(\"Min: \", np.min(X, axis=1))\n",
        "print(\"Max: \", np.max(X, axis=1))\n",
        "\n",
        "# Compute the statistics of the output data\n",
        "print(\"\\nOutput statistics:\")\n",
        "print(\"Count: \", len(y))\n",
        "print(\"Mean: \", np.mean(y))\n",
        "print(\"Std: \", np.std(y))\n",
        "print(\"Min: \", np.min(y))\n",
        "print(\"Max: \", np.max(y))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUpPhyFZfMWM"
      },
      "source": [
        "# Subtask 1.6\n",
        "### Training/validation data and normalization\n",
        "\n",
        "Let's consider 50% of the data for training and 50% for validation:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2SK56a7Rf7w1"
      },
      "outputs": [],
      "source": [
        "# TODO shuffle the samples\n",
        "np.random.seed(24)\n",
        "idx = np.arange(len(X))\n",
        "np.random.shuffle(idx)\n",
        "\n",
        "X = X[idx]\n",
        "y = y[idx]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DbD1a1PEfu-5"
      },
      "outputs": [],
      "source": [
        "# TODO split data to train and validation\n",
        "N_train = int(0.5 * len(X))\n",
        "x_train, x_test, y_train, y_test = X[:N_train], X[N_train:], y[:N_train], y[N_train:]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "61aWjInByJxm"
      },
      "source": [
        "In the table of statistics it's easy to see how different the ranges of each feature are. It is good practice to normalize features that use different scales and ranges."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Jstfx0J-jdgm"
      },
      "outputs": [],
      "source": [
        "# TODO Normalize both input and the output using the statistics (mean and std) of the training data\n",
        "mu = x_train.mean()\n",
        "std = x_train.std()\n",
        "\n",
        "x_train = (x_train - mu) / std\n",
        "x_test = (x_test - mu) / std"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g48rvntriAwy"
      },
      "source": [
        "# Subtask 1.7\n",
        "### Classification based on the perceptron algorithm.\n",
        "\n",
        "Let's build and train a model as:\n",
        "\\begin{equation}\n",
        "y = sign(\\mathbf{w}^{\\mathtt{T}}X),\n",
        "\\end{equation}\n",
        "where $\\mathbf{w}$ represents the weights. We need to do the following steps:\n",
        " - Create the model by initializing the weights.\n",
        " - Define the loss function.\n",
        " - Train the model. We will use the perceptron algorithm to minimize the loss.\n",
        "\n",
        "First, let us define a function for plotting the results as:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yk7R0ul9yJxn"
      },
      "outputs": [],
      "source": [
        "def plot(w, X, y):\n",
        "    \"\"\" Defines the plot function:\n",
        "    inputs: w (N + 1) array\n",
        "            X (M, N) array\n",
        "            y (M) array\n",
        "    returns:\n",
        "    \"\"\"\n",
        "    a = -w[1] / w[2]\n",
        "    xx = np.linspace(X.min(), 0.5 * X.max())\n",
        "    yy = a * xx + w[0] / w[1]\n",
        "    fig, ax = plt.subplots(1, 1, figsize = (4, 4))\n",
        "    ax.scatter(X[:,0], X[:,1], c = y, cmap = 'bwr', label = 'Data')\n",
        "    ax.plot(xx, yy, 'k', label = 'Classifier')\n",
        "\n",
        "    ax.set_xlabel('Margarethenklippe')\n",
        "    ax.set_ylabel('Sennhuette')\n",
        "#     ax.set_aspect('equal')\n",
        "    ax.legend()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oAQ-YW0hyJxn"
      },
      "outputs": [],
      "source": [
        "# TODO use the plot function above to show the results for the training data and the suggested weights:\n",
        "W = [0.1, 0.05, 1.0]\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sPukJsT5yJxo"
      },
      "source": [
        "## Create the perceptron model as a Python class\n",
        "\n",
        "We will need the following functions:\n",
        "- **init**: where you can initialize the model parameters and set the learning rate.\n",
        "- **loss_fn**: where the loss (or error) needs to be computed by comparing the prediction to the reference data.\n",
        "- **call**: or the forward pass, where the prediction is made using the previously defined model on the input data.\n",
        "- **train_step**: where we define the computation performed at one step of training. Here, the model learns and updates its weights.\n",
        "- **test_step**: where we define the computation performed at one step of evaluation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n9yEIZOjyJxo"
      },
      "outputs": [],
      "source": [
        "class Perceptron():\n",
        "    \"\"\"\n",
        "    Classification model based on the perceptron algorithm.\n",
        "    \"\"\"\n",
        "    def __init__(self, input_dim = 2, lr = 0.001):\n",
        "        # TODO define the model weights\n",
        "        self.input_dim = input_dim\n",
        "        self.W = np.zeros((input_dim + 1, 1))\n",
        "\n",
        "        self.lr = lr\n",
        "\n",
        "        # TODO Define the optimizer. In this case, we use Stochastic Gradient Descent (SGD).\n",
        "\n",
        "    def loss_fn(self, y_pred, y_true):\n",
        "        \"\"\" Defines the loss function \"\"\"\n",
        "        # TODO compute the loss\n",
        "        loss = y_true - y_pred\n",
        "        return loss\n",
        "\n",
        "\n",
        "    def call(self, inputs):\n",
        "        \"\"\" Defines the computation performed at every call. \"\"\"\n",
        "        # TODO run the data through the layer\n",
        "        inputs = np.hstack([np.ones((len(inputs), 1)), inputs])\n",
        "        z = np.dot(inputs, self.W)\n",
        "        outputs = np.sign(z)\n",
        "        return outputs.reshape((-1, 1))\n",
        "\n",
        "    def train_step(self, data):\n",
        "        \"\"\" Defines the computation performed at one step of training.\n",
        "            This typically includes the:\n",
        "            - forward pass\n",
        "            - loss calculation\n",
        "            - weight updates.\n",
        "            - metric updates.\n",
        "        \"\"\"\n",
        "        inputs, labels = data\n",
        "\n",
        "        # TODO compute the loss and update the weights\n",
        "\n",
        "        outputs = self.call(inputs)\n",
        "        loss = self.loss_fn(outputs, labels)\n",
        "\n",
        "        inputs = np.hstack([np.ones((len(inputs), 1)), inputs])\n",
        "        updates = (inputs * loss * self.lr).mean(0)\n",
        "\n",
        "        self.W += updates.reshape((-1, 1))\n",
        "\n",
        "        return (loss**2).mean()\n",
        "\n",
        "    def test_step(self, data):\n",
        "        \"\"\" Defines the computation performed at one step of evaluation.\n",
        "            This typically includes the:\n",
        "            - forward pass\n",
        "            - loss calculation\n",
        "            - metric updates.\n",
        "        \"\"\"\n",
        "        inputs, labels = data\n",
        "\n",
        "        # TODO compute the gradients and update the weights\n",
        "        outputs = self.call(inputs)\n",
        "        loss = self.loss_fn(outputs, labels)\n",
        "\n",
        "        return (loss**2).mean()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "773ONqEDyJxp"
      },
      "source": [
        "## Instantiate the model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ks-hPZyUyJxp"
      },
      "outputs": [],
      "source": [
        "# TODO instantiate the model using the Perceptron class you defined\n",
        "model = Perceptron(input_dim=2, lr=0.001)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sNXcqiLQyJxq"
      },
      "source": [
        "# Subtask 1.8\n",
        "### Train the model\n",
        "\n",
        "Everything is set for the model to train! Now, we need a training loop:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vLamJpadyJxq"
      },
      "outputs": [],
      "source": [
        "# TODO fill in the missing lines\n",
        "batch_size=6000\n",
        "num_epochs = 20\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(batch_size)\n",
        "test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(batch_size)\n",
        "train_losses = []\n",
        "test_losses = []\n",
        "hist = {'loss':[], 'val_loss':[]}\n",
        "# Training loop\n",
        "for epoch in range(num_epochs):\n",
        "    # TODO Train loop\n",
        "    loss = tf.keras.metrics.Mean()\n",
        "    for x_batch, y_batch in train_dataset:\n",
        "        loss(model.train_step((x_batch, y_batch))[\"loss\"])\n",
        "       train_losses.append(loss.result())\n",
        "    # TODO Test loop\n",
        "    val_loss = tf.keras.metrics.Mean()\n",
        "    for x_batch, y_batch in test_dataset:\n",
        "        val_loss(model.test_step((x_batch, y_batch))[\"loss\"])\n",
        "    test_losses.append(val_loss.result())\n",
        "    # Print progress\n",
        "    hist['loss'].append(loss)\n",
        "    hist['val_loss'].append(val_loss)\n",
        "    print(f\"Epoch {epoch + 1}: train loss = {loss:.4f}, test loss = {val_loss:.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UN3MG0TgyJxq",
        "outputId": "0b52db6f-f8dc-427e-a263-42fdf7abd3e9"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 400x400 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# TODO plot the results for the learned weights using our plot function\n",
        "def plot_loss(history):\n",
        "    plt.plot(history['loss'], label='train')\n",
        "    plt.plot(history['val_loss'], label='test')\n",
        "    plt.title('Model loss')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "plot_loss(hist)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gkv93HZjyJxr"
      },
      "source": [
        "# Subtask 1.9\n",
        "\n",
        "### Plot the training and validation error\n",
        "\n",
        "Create a plot using pyplot that contains both the losses on training set and the losses on the validation set.\n",
        "\n",
        "**Note:** Do not forget to add title, axis labels and a legend!\n",
        "This applies in general, please keep in mind for future exercise sheets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DfELKhhryJxr",
        "outputId": "d7b21b14-5598-400b-a90d-2f453d138871"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7f39f06bdaf0>"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# TODO visualize the model's training progress\n",
        "\n",
        "plt.plot(hist['loss'], label='Training loss')\n",
        "plt.plot(hist['val_loss'], label='Validation loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KnccwFChyJxs"
      },
      "source": [
        "# Subtask 1.10\n",
        "\n",
        "### Plot the confusion matrix\n",
        "\n",
        "Compute the confusion matrix using the *sklearn* library and plot it using *seaborn.heatmap*.\n",
        "\n",
        "**Note:** Do not forget to add title, axis labels and a legend!\n",
        "This applies in general, please keep in mind for future exercise sheets."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6SaT1XapyJxs",
        "outputId": "466ff9f1-0b05-44f6-c7c7-648a3e57e22d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<AxesSubplot: >"
            ]
          },
          "execution_count": 52,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# TODO compute the confusion matrix\n",
        "\n",
        "y_pred = model.call(x_test)\n",
        "\n",
        "cm = confusion_matrix(y_test, y_pred)\n",
        "cm = cm / len(y_test) * 100\n",
        "\n",
        "# TODO visualize the confusion matrix\n",
        "\n",
        "sns.heatmap(cm, annot=True, fmt='.1f', cmap='Blues')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.xlabel('Predicted ')\n",
        "plt.ylabel('True')\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "base",
      "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.9.7"
    },
    "nteract": {
      "version": "0.15.0"
    },
    "vscode": {
      "interpreter": {
        "hash": "062ad8061f6e7aca79bc9a27e986d47521568c0a72ae67729c623b905ab2cf31"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}