Ch6/03_BERT_ATIS_Binary.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b7We9WSKH7DN"
      },
      "source": [
        "## Intent Classification for the ATIS Dataset using BERT.\n",
        "In this notebook we build a binarry classifier for the ATIS Dataset using [BERT](https://arxiv.org/abs/1810.04805), a pre-Trained NLP model open soucred by google in late 2018 that can be used for [Transfer Learning](https://towardsdatascience.com/transfer-learning-in-nlp-fecc59f546e4) on text data. This notebook has been adapted from this [Article](https://towardsdatascience.com/bert-for-dummies-step-by-step-tutorial-fb90890ffe03). The link for the dataset can be found [here](https://www.kaggle.com/siddhadev/ms-cntk-atis/data#).<br> This notebook requires a GPU to get setup. We suggest you to run this on your local machine only if you have a GPU setup or else you can use google colab."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## For this notebook you will need some files from the Data directory present in the Ch6 Folder. So you can follow below steps to load the whole directory here.\n",
        "\n",
        "1. Create a zip file of the Data directory.\n",
        "2. Upload it here on colabs as a file.\n",
        "3. Extract the files using the command 'unzip Data.zip' (considering that you named the zip file as Data.zip)"
      ],
      "metadata": {
        "id": "bPXLjPElM5n5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip Data.zip"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U4wrXZwbNHwD",
        "outputId": "da8b2a08-1446-48fa-aa00-dbf49136badb"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Archive:  Data.zip\n",
            "   creating: Data/\n",
            "  inflating: Data/utils.py           \n",
            "   creating: Data/CoNLL - 2003/\n",
            "   creating: Data/snips/\n",
            "   creating: Data/data/\n",
            "   creating: Data/data2/\n",
            "  inflating: Data/utils.pyc          \n",
            "   creating: Data/CoNLL - 2003/en/\n",
            "  inflating: Data/snips/validate_PlayMusic.json  \n",
            "  inflating: Data/snips/train_PlayMusic_full.json  \n",
            "  inflating: Data/data/atis.test.pkl  \n",
            "  inflating: Data/data/atis.fold1.pkl  \n",
            "  inflating: Data/data/atis.fold0.pkl  \n",
            "  inflating: Data/data/atis.fold2.pkl  \n",
            "  inflating: Data/data/atis.fold3.pkl  \n",
            "  inflating: Data/data/atis.train.pkl  \n",
            "  inflating: Data/data/atis.fold4.pkl  \n",
            "  inflating: Data/data2/atis.train.w-intent.iob  \n",
            "  inflating: Data/data2/atis.test.w-intent.iob  \n",
            "  inflating: Data/data2/atis-2.train.w-intent.iob  \n",
            "  inflating: Data/data2/atis-2.dev.w-intent.iob  \n",
            "  inflating: Data/CoNLL - 2003/en/train.txt  \n",
            "  inflating: Data/CoNLL - 2003/en/valid.txt  \n",
            "  inflating: Data/CoNLL - 2003/en/test.txt  \n",
            "  inflating: Data/CoNLL - 2003/en/metadata  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vKbMCwXXgqC9"
      },
      "source": [
        "## Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mk2-vK00E2ms",
        "outputId": "74207329-3f4f-4232-d161-81e21dbcf9a0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pytorch-pretrained-bert in /usr/local/lib/python3.10/dist-packages (0.6.2)\n",
            "Requirement already satisfied: pytorch-nlp in /usr/local/lib/python3.10/dist-packages (0.5.0)\n",
            "Requirement already satisfied: torch>=0.4.1 in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2.0.1+cu118)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (1.23.5)\n",
            "Requirement already satisfied: boto3 in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (1.28.37)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (4.66.1)\n",
            "Requirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from pytorch-pretrained-bert) (2023.6.3)\n",
            "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.12.2)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (4.7.1)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (1.12)\n",
            "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.1)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (3.1.2)\n",
            "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch>=0.4.1->pytorch-pretrained-bert) (2.0.0)\n",
            "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=0.4.1->pytorch-pretrained-bert) (3.27.2)\n",
            "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch>=0.4.1->pytorch-pretrained-bert) (16.0.6)\n",
            "Requirement already satisfied: botocore<1.32.0,>=1.31.37 in /usr/local/lib/python3.10/dist-packages (from boto3->pytorch-pretrained-bert) (1.31.37)\n",
            "Requirement already satisfied: jmespath<2.0.0,>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from boto3->pytorch-pretrained-bert) (1.0.1)\n",
            "Requirement already satisfied: s3transfer<0.7.0,>=0.6.0 in /usr/local/lib/python3.10/dist-packages (from boto3->pytorch-pretrained-bert) (0.6.2)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (3.2.0)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (3.4)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (1.26.16)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->pytorch-pretrained-bert) (2023.7.22)\n",
            "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /usr/local/lib/python3.10/dist-packages (from botocore<1.32.0,>=1.31.37->boto3->pytorch-pretrained-bert) (2.8.2)\n",
            "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=0.4.1->pytorch-pretrained-bert) (2.1.3)\n",
            "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch>=0.4.1->pytorch-pretrained-bert) (1.3.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil<3.0.0,>=2.1->botocore<1.32.0,>=1.31.37->boto3->pytorch-pretrained-bert) (1.16.0)\n",
            "Colab only includes TensorFlow 2.x; %tensorflow_version has no effect.\n"
          ]
        }
      ],
      "source": [
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "# install\n",
        "!pip install pytorch-pretrained-bert pytorch-nlp\n",
        "\n",
        "try :\n",
        "    from google.colab import files\n",
        "    %tensorflow_version 2.x\n",
        "\n",
        "except ModuleNotFoundError :\n",
        "    print(\"Not Using Colab\")\n",
        "\n",
        "DATA_DIR=\".\"\n",
        "import os\n",
        "import numpy as np\n",
        "import pickle\n",
        "import tensorflow as tf\n",
        "\n",
        "# BERT imports\n",
        "import torch\n",
        "from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler\n",
        "from keras.utils import pad_sequences\n",
        "from sklearn.model_selection import train_test_split\n",
        "from pytorch_pretrained_bert import BertTokenizer, BertConfig\n",
        "from pytorch_pretrained_bert import BertAdam, BertForSequenceClassification\n",
        "from tqdm import tqdm, trange\n",
        "import pandas as pd\n",
        "import io\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "# specify GPU device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "if torch.cuda.is_available():\n",
        "    n_gpu = torch.cuda.device_count()\n",
        "    torch.cuda.get_device_name(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xhRHs0sugqC_"
      },
      "source": [
        "## Data Loading"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "ntUZndfrE9W8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "outputId": "c4b52952-3990-47cb-c201-e02d4c7212aa"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-d5be3988-bc20-44e4-bc5a-ae7c3640f6eb\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-d5be3988-bc20-44e4-bc5a-ae7c3640f6eb\">\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 atis.test.pkl to atis.test.pkl\n",
            "Saving atis.train.pkl to atis.train.pkl\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-2d870f7e-e361-49a2-b443-769ef752cc05\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-2d870f7e-e361-49a2-b443-769ef752cc05\">\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 atis.train.w-intent.iob to atis.train.w-intent.iob\n"
          ]
        }
      ],
      "source": [
        "# importing the dataset\n",
        "try :\n",
        "    from google.colab import files\n",
        "#   upload 'atis.test.pkl' and 'atis.train.pkl' here\n",
        "    uploaded = files.upload()\n",
        "#   upload 'atis.train.w-intent.iob' here\n",
        "    next_uploaded = files.upload()\n",
        "\n",
        "except ModuleNotFoundError :\n",
        "    print(\"Not using Colab\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "T84rxZBGgqC_"
      },
      "outputs": [],
      "source": [
        "#preprocessing functions\n",
        "def get_data(filename):\n",
        "    df = pd.read_csv(filename,delim_whitespace=True,names=['word','label'])\n",
        "    beg_indices = list(df[df['word'] == 'BOS'].index)+[df.shape[0]]\n",
        "    sents,labels,intents = [],[],[]\n",
        "    for i in range(len(beg_indices[:-1])):\n",
        "        sents.append(df[beg_indices[i]+1:beg_indices[i+1]-1]['word'].values)\n",
        "        labels.append(df[beg_indices[i]+1:beg_indices[i+1]-1]['label'].values)\n",
        "        intents.append(df.loc[beg_indices[i+1]-1]['label'])\n",
        "    return np.array(sents),np.array(labels),np.array(intents)\n",
        "\n",
        "def get_data2(filename):\n",
        "    with open(filename) as f:\n",
        "        contents = f.read()\n",
        "    sents,labels,intents = [],[],[]\n",
        "    for line in contents.strip().split('\\n'):\n",
        "        words,labs = [i.split(' ') for i in line.split('\\t')]\n",
        "        sents.append(words[1:-1])\n",
        "        labels.append(labs[1:-1])\n",
        "        intents.append(labs[-1])\n",
        "    return np.array(sents),np.array(labels),np.array(intents)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2YVAk61inICj",
        "outputId": "25a688b9-2872-4dd7-fec8-efe8aae3e48a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading the training Data\n",
            "Number of training sentences : 4952\n",
            "Number of unique intents : 17\n",
            "('i want to fly from boston at 838 am and arrive in denver at 1110 in the morning', 'atis_flight')\n",
            "('what flights are available from pittsburgh to baltimore on thursday morning', 'atis_flight')\n",
            "('what is the arrival time in san francisco for the 755 am flight leaving washington', 'atis_flight_time')\n",
            "('cheapest airfare from tacoma to orlando', 'atis_airfare')\n",
            "('round trip fares from pittsburgh to philadelphia under 1000 dollars', 'atis_airfare')\n"
          ]
        }
      ],
      "source": [
        "print(\"Loading the training Data\")\n",
        "try :\n",
        "    from google.colab import files\n",
        "    sents,labels,intents = get_data2('atis.train.w-intent.iob')\n",
        "\n",
        "except ModuleNotFoundError :\n",
        "    sents,labels,intents = get_data2('Data/data2/atis.train.w-intent.iob')\n",
        "\n",
        "train_sentences = [\" \".join(i) for i in sents]\n",
        "\n",
        "train_texts = train_sentences\n",
        "train_labels= intents.tolist()\n",
        "\n",
        "vals = []\n",
        "\n",
        "for i in range(len(train_labels)):\n",
        "    if \"#\" in train_labels[i]:\n",
        "        vals.append(i)\n",
        "\n",
        "for i in vals[::-1]:\n",
        "    train_labels.pop(i)\n",
        "    train_texts.pop(i)\n",
        "\n",
        "print (\"Number of training sentences :\",len(train_texts))\n",
        "print (\"Number of unique intents :\",len(set(train_labels)))\n",
        "\n",
        "for i in zip(train_texts[:5], train_labels[:5]):\n",
        "    print(i)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "By1w6cxqgqDB"
      },
      "outputs": [],
      "source": [
        "# load Pickle file\n",
        "def load_ds(fname, verbose=True):\n",
        "    with open(fname, 'rb') as stream:\n",
        "        ds,dicts = pickle.load(stream)\n",
        "    if verbose:\n",
        "        print('Done  loading: ', fname)\n",
        "        print('      samples: {:4d}'.format(len(ds['query'])))\n",
        "        print('   vocab_size: {:4d}'.format(len(dicts['token_ids'])))\n",
        "        print('   slot count: {:4d}'.format(len(dicts['slot_ids'])))\n",
        "        print(' intent count: {:4d}'.format(len(dicts['intent_ids'])))\n",
        "    return ds,dicts\n",
        "\n",
        "# convert Pickle file to arrays\n",
        "def load_atis(filename, add_start_end_token=False, verbose=True):\n",
        "    train_ds, dicts = load_ds(os.path.join(DATA_DIR,filename), verbose)\n",
        "    t2i, s2i, in2i = map(dicts.get, ['token_ids', 'slot_ids','intent_ids'])\n",
        "    i2t, i2s, i2in = map(lambda d: {d[k]:k for k in d.keys()}, [t2i,s2i,in2i])\n",
        "    query, slots, intent =  map(train_ds.get, ['query', 'slot_labels', 'intent_labels'])\n",
        "\n",
        "    if add_start_end_token:\n",
        "        i2s[178] = 'BOS'\n",
        "        i2s[179] = 'EOS'\n",
        "        s2i['BOS'] = 178\n",
        "        s2i['EOS'] = 179\n",
        "\n",
        "    input_tensor = []\n",
        "    target_tensor = []\n",
        "    query_data = []\n",
        "    intent_data = []\n",
        "    slot_data = []\n",
        "    to_show = np.random.randint(0, len(query)-1, 5)\n",
        "    for i in range(len(query)):\n",
        "        input_tensor.append(query[i])\n",
        "        slot_text = []\n",
        "        slot_vector = []\n",
        "        for j in range(len(query[i])):\n",
        "            slot_text.append(i2s[slots[i][j]])\n",
        "            slot_vector.append(slots[i][j])\n",
        "        if add_start_end_token:\n",
        "            slot_text[0] = 'BOS'\n",
        "            slot_vector[0] = 178\n",
        "            slot_text[-1] = 'EOS'\n",
        "            slot_vector[-1]= 179\n",
        "        target_tensor.append(slot_vector)\n",
        "        q = ' '.join(map(i2t.get, query[i]))\n",
        "        query_data.append(q.replace('BOS', '').replace('EOS',''))\n",
        "        intent_data.append(i2in[intent[i][0]])\n",
        "        slot = ' '.join(slot_text)\n",
        "        slot_data.append(slot[1:-1])\n",
        "        if i in to_show and verbose:\n",
        "            print('Query text:', q)\n",
        "            print('Query vector: ', query[i])\n",
        "            print('Intent label: ', i2in[intent[i][0]])\n",
        "            print('Slot text: ', slot)\n",
        "            print('Slot vector: ', slot_vector)\n",
        "            print('*'*74)\n",
        "\n",
        "    query_data = np.array(query_data)\n",
        "    intent_data = np.array(intent_data)\n",
        "    slot_data = np.array(slot_data)\n",
        "    intent_data_label = np.array(intent).flatten()\n",
        "\n",
        "    return t2i, s2i, in2i, i2t, i2s, i2in, input_tensor, target_tensor, query_data, intent_data, intent_data_label, slot_data\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4v3gLWxFQS5",
        "outputId": "3934d75b-9c6c-4bd0-cea0-c33cbc1576ce"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Done  loading:  ./atis.train.pkl\n",
            "      samples: 4978\n",
            "   vocab_size:  943\n",
            "   slot count:  129\n",
            " intent count:   26\n",
            "Query text: BOS show me flights from pittsburgh to san francisco EOS\n",
            "Query vector:  [178 770 581 429 444 682 851 739 440 179]\n",
            "Intent label:  flight\n",
            "Slot text:  O O O O O B-fromloc.city_name O B-toloc.city_name I-toloc.city_name O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 48, 128, 78, 125, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS what are all the available meals EOS\n",
            "Query vector:  [178 916 228 207 827 244 583 179]\n",
            "Intent label:  meal\n",
            "Slot text:  O O O O O O B-meal O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 128, 51, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS i like to see the information for flights from pittsburgh to san francisco leaving pittsburgh after 12 pm EOS\n",
            "Query vector:  [178 479 545 851 754 827 492 435 429 444 682 851 739 440 539 682 190  33\n",
            " 689 179]\n",
            "Intent label:  flight\n",
            "Slot text:  O O O O O O O O O O B-fromloc.city_name O B-toloc.city_name I-toloc.city_name O B-fromloc.city_name B-depart_time.time_relative B-depart_time.time I-depart_time.time O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 48, 128, 78, 125, 128, 48, 36, 35, 100, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS i want to travel from pittsburgh to oakland around midnight could you give me the flights EOS\n",
            "Query vector:  [178 479 902 851 867 444 682 851 644 231 591 329 938 449 581 827 429 179]\n",
            "Intent label:  flight\n",
            "Slot text:  O O O O O O B-fromloc.city_name O B-toloc.city_name B-depart_time.time_relative B-depart_time.period_of_day O O O O O O O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 128, 48, 128, 78, 36, 33, 128, 128, 128, 128, 128, 128, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS in denver what kind of ground transportation is there from the airport to downtown EOS\n",
            "Query vector:  [178 482 351 916 513 646 457 866 498 831 444 827 203 851 380 179]\n",
            "Intent label:  ground_service\n",
            "Slot text:  O O B-city_name O O O O O O O O O O O O O\n",
            "Slot vector:  [128, 128, 17, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]\n",
            "**************************************************************************\n",
            "Done  loading:  ./atis.test.pkl\n",
            "      samples:  893\n",
            "   vocab_size:  943\n",
            "   slot count:  129\n",
            " intent count:   26\n",
            "Query text: BOS does tacoma airport offer transportation from the airport to the downtown area EOS\n",
            "Query vector:  [178 376 810 203 648 866 444 827 203 851 827 380 229 179]\n",
            "Intent label:  ground_service\n",
            "Slot text:  O O B-airport_name I-airport_name O O O O O O O O O O\n",
            "Slot vector:  [128, 128, 4, 84, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS i would like a flight from detroit to st. louis EOS\n",
            "Query vector:  [178 479 932 545 180 428 444 361 851 789 564 179]\n",
            "Intent label:  flight\n",
            "Slot text:  O O O O O O O B-fromloc.city_name O B-toloc.city_name I-toloc.city_name O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 128, 128, 48, 128, 78, 125, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS show me the cheapest one way fare from san francisco to houston on february twenty eighth 1994 EOS\n",
            "Query vector:  [178 770 581 827 296 656 906 414 444 739 440 851 476 654 416 881 394  64\n",
            " 179]\n",
            "Intent label:  airfare\n",
            "Slot text:  O O O O B-cost_relative B-round_trip I-round_trip O O B-fromloc.city_name I-fromloc.city_name O B-toloc.city_name O B-depart_date.month_name B-depart_date.day_number I-depart_date.day_number B-depart_date.year O\n",
            "Slot vector:  [128, 128, 128, 128, 21, 66, 119, 128, 128, 48, 110, 128, 78, 128, 28, 27, 95, 30, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS i would like flight information from phoenix to denver EOS\n",
            "Query vector:  [178 479 932 545 428 492 444 681 851 351 179]\n",
            "Intent label:  flight\n",
            "Slot text:  O O O O O O O B-fromloc.city_name O B-toloc.city_name O\n",
            "Slot vector:  [128, 128, 128, 128, 128, 128, 128, 48, 128, 78, 128]\n",
            "**************************************************************************\n",
            "Query text: BOS which airline is us EOS\n",
            "Query vector:  [178 920 199 498 889 179]\n",
            "Intent label:  airline\n",
            "Slot text:  O O O O B-airline_code O\n",
            "Slot vector:  [128, 128, 128, 128, 1, 128]\n",
            "**************************************************************************\n"
          ]
        }
      ],
      "source": [
        "# load ATIS training dataset\n",
        "try :\n",
        "    from google.colab import files\n",
        "    t2i_train, s2i_train, in2i_train, i2t_train, i2s_train, i2in_train, \\\n",
        "    input_tensor_train, target_tensor_train, \\\n",
        "    query_data_train, intent_data_train, intent_data_label_train, slot_data_train = load_atis('atis.train.pkl')\n",
        "\n",
        "except ModuleNotFoundError :\n",
        "    t2i_train, s2i_train, in2i_train, i2t_train, i2s_train, i2in_train, \\\n",
        "    input_tensor_train, target_tensor_train, \\\n",
        "    query_data_train, intent_data_train, intent_data_label_train, slot_data_train = load_atis('Data/data/atis.train.pkl')\n",
        "\n",
        "# load ATIS testing dataset\n",
        "try :\n",
        "    from google.colab import files\n",
        "    t2i_test, s2i_test, in2i_test, i2t_test, i2s_test, i2in_test, \\\n",
        "    input_tensor_test, target_tensor_test, \\\n",
        "    query_data_test, intent_data_test, intent_data_label_test, slot_data_test = load_atis('atis.test.pkl')\n",
        "\n",
        "except ModuleNotFoundError :\n",
        "    t2i_test, s2i_test, in2i_test, i2t_test, i2s_test, i2in_test, \\\n",
        "    input_tensor_test, target_tensor_test, \\\n",
        "    query_data_test, intent_data_test, intent_data_label_test, slot_data_test = load_atis('Data/data/atis.test.pkl')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JkMdQoGYgqDD"
      },
      "source": [
        "Let's look at a few training queries."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n9QxatGPpXj2",
        "outputId": "87130d98-2ffe-41f2-9ea1-9cdefe6c2ab8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([' i want to fly from boston at 838 am and arrive in denver at 1110 in the morning ',\n",
              "       ' what flights are available from pittsburgh to baltimore on thursday morning ',\n",
              "       ' what is the arrival time in san francisco for the 755 am flight leaving washington ',\n",
              "       ..., ' which airlines fly into and out of denver ',\n",
              "       ' does continental fly from boston to san francisco with a stop in denver ',\n",
              "       ' is there a delta flight from denver to san francisco '],\n",
              "      dtype='<U261')"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "query_data_train"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hP7cnX4KgqDE"
      },
      "source": [
        "## Data Pre-processing\n",
        "We need to convert the sentences to tensors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "SAtA2iHQnXbT"
      },
      "outputs": [],
      "source": [
        "#function to find the length of a tensor\n",
        "def max_length(tensor):\n",
        "    return max(len(t) for t in tensor)\n",
        "\n",
        "# Helper function to pad the query tensor and slot (target) tensor to the same length.\n",
        "# Also creates a tensor for teacher forcing.\n",
        "def create_tensors(input_tensor, target_tensor, nb_sample=9999999, max_len=0):\n",
        "    len_input, len_target  = max_length(input_tensor), max_length(target_tensor)\n",
        "    len_input = max(len_input,max_len)\n",
        "    len_target = max(len_target,max_len)\n",
        "\n",
        "\n",
        "    # Padding the input and output tensor to the maximum length\n",
        "    input_data = tf.keras.preprocessing.sequence.pad_sequences(input_tensor,\n",
        "                                                                 maxlen=len_input,\n",
        "                                                                 padding='post')\n",
        "\n",
        "    teacher_data = tf.keras.preprocessing.sequence.pad_sequences(target_tensor,\n",
        "                                                                  maxlen=len_target ,\n",
        "                                                                  padding='post')\n",
        "\n",
        "    target_data = [[teacher_data[n][i+1] for i in range(len(teacher_data[n])-1)] for n in range(len(teacher_data))]\n",
        "    target_data = tf.keras.preprocessing.sequence.pad_sequences(target_data, maxlen=len_target, padding=\"post\")\n",
        "    target_data = target_data.reshape((target_data.shape[0], target_data.shape[1], 1))\n",
        "\n",
        "    nb = len(input_data)\n",
        "    p = np.random.permutation(nb)\n",
        "    input_data = input_data[p]\n",
        "    teacher_data = teacher_data[p]\n",
        "    target_data = target_data[p]\n",
        "\n",
        "    return input_data[:min(nb_sample, nb)], teacher_data[:min(nb_sample, nb)], target_data[:min(nb_sample, nb)], len_input, len_target\n",
        "\n",
        "input_data_train, teacher_data_train, target_data_train, \\\n",
        "                  len_input_train, len_target_train  = create_tensors(input_tensor_train, target_tensor_train)\n",
        "input_data_test, teacher_data_test, target_data_test, \\\n",
        "                 len_input_test, len_target_test  = create_tensors(input_tensor_test, target_tensor_test, max_len=len_input_train)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-0aE-CcgqDF"
      },
      "source": [
        "BERT expects data to be in a specific format, i.e, [CLS] token1,token2,....[SEP]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J9yXxW2Kolyg",
        "outputId": "8447d9b7-5967-4014-8f64-9a4d13e340dd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[CLS]  i want to fly from boston at 838 am and arrive in denver at 1110 in the morning  [SEP]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;| 231508/231508 [00:00<00:00, 346660.06B/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tokenize the first sentence:\n",
            "['[CLS]', 'i', 'want', 'to', 'fly', 'from', 'boston', 'at', '83', '##8', 'am', 'and', 'arrive', 'in', 'denver', 'at', '111', '##0', 'in', 'the', 'morning', '[SEP]']\n"
          ]
        }
      ],
      "source": [
        "sentences = [\"[CLS] \" + query + \" [SEP]\" for query in query_data_train]\n",
        "print(sentences[0])\n",
        "\n",
        "# Tokenize with BERT tokenizer\n",
        "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)\n",
        "tokenized_texts = [tokenizer.tokenize(sent) for sent in sentences]\n",
        "print (\"Tokenize the first sentence:\")\n",
        "print (tokenized_texts[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "m-VWG-IGo50w"
      },
      "outputs": [],
      "source": [
        "# Set the maximum sequence length.\n",
        "MAX_LEN = 128\n",
        "# Pad our input tokens\n",
        "input_ids = pad_sequences([tokenizer.convert_tokens_to_ids(txt) for txt in tokenized_texts],\n",
        "                          maxlen=MAX_LEN, dtype=\"long\", truncating=\"post\", padding=\"post\")\n",
        "# Use the BERT tokenizer to convert the tokens to their index numbers in the BERT vocabulary\n",
        "input_ids = [tokenizer.convert_tokens_to_ids(x) for x in tokenized_texts]\n",
        "input_ids = pad_sequences(input_ids, maxlen=MAX_LEN, dtype=\"long\", truncating=\"post\", padding=\"post\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hcbGjc4gqDG"
      },
      "source": [
        "Creating the BERT attention masks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "YwiguyX7pG67"
      },
      "outputs": [],
      "source": [
        "# Create attention masks\n",
        "attention_masks = []\n",
        "# Create a mask of 1s for each token followed by 0s for padding\n",
        "for seq in input_ids:\n",
        "    seq_mask = [float(i>0) for i in seq]\n",
        "    attention_masks.append(seq_mask)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "oL39XXZorV0y"
      },
      "outputs": [],
      "source": [
        "#Reducing this into a binary classifcation problem\n",
        "intent_data_label_train[intent_data_label_train==14] = -1\n",
        "intent_data_label_train[intent_data_label_train!=-1] = 0\n",
        "intent_data_label_train[intent_data_label_train==-1] = 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "vSV8Kk15pJXL"
      },
      "outputs": [],
      "source": [
        "# Use train_test_split to split our data into train and validation sets for training\n",
        "train_inputs, validation_inputs, train_labels, validation_labels = train_test_split(input_ids, intent_data_label_train,\n",
        "                                                            random_state=2018, test_size=0.1)\n",
        "train_masks, validation_masks, _, _ = train_test_split(attention_masks, input_ids,\n",
        "                                             random_state=2018, test_size=0.1)\n",
        "\n",
        "# Convert all of our data into torch tensors, the required datatype for our model\n",
        "train_inputs = torch.tensor(train_inputs)\n",
        "validation_inputs = torch.tensor(validation_inputs)\n",
        "train_labels = torch.tensor(train_labels)\n",
        "validation_labels = torch.tensor(validation_labels)\n",
        "train_masks = torch.tensor(train_masks)\n",
        "validation_masks = torch.tensor(validation_masks)\n",
        "\n",
        "# Select a batch size for training.\n",
        "batch_size = 32\n",
        "\n",
        "# Create an iterator of our data with torch DataLoader\n",
        "train_data = TensorDataset(train_inputs, train_masks, train_labels)\n",
        "train_sampler = RandomSampler(train_data)\n",
        "train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)\n",
        "validation_data = TensorDataset(validation_inputs, validation_masks, validation_labels)\n",
        "validation_sampler = SequentialSampler(validation_data)\n",
        "validation_dataloader = DataLoader(validation_data, sampler=validation_sampler, batch_size=batch_size)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BuKhVmSFgqDH"
      },
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z4Y9kjn7puKI",
        "outputId": "02334642-0392-4a8b-c2b1-db4ff0d9aa51",
        "scrolled": false
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;| 407873900/407873900 [00:42<00:00, 9557821.40B/s]\n"
          ]
        }
      ],
      "source": [
        "model = BertForSequenceClassification.from_pretrained(\"bert-base-uncased\", num_labels=2)\n",
        "\n",
        "if torch.cuda.is_available():\n",
        "    model.cuda()\n",
        "else :\n",
        "    model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HBC2Q_Q-gqDI"
      },
      "source": [
        "## Fine-Tuning BERT"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 757
        },
        "id": "1kkAaGSjqElS",
        "outputId": "266f7757-73d1-4fbb-dc4f-b14c06acb277"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:pytorch_pretrained_bert.optimization:t_total value of -1 results in schedule not being applied\n",
            "Epoch:   0%|          | 0/4 [00:00<?, ?it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train loss: 0.11590222636836447\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  25%|&#9608;&#9608;&#9612;       | 1/4 [01:56<05:48, 116.05s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.9906684027777778\n",
            "Train loss: 0.02828012290202813\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  50%|&#9608;&#9608;&#9608;&#9608;&#9608;     | 2/4 [03:49<03:49, 114.73s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.9887152777777778\n",
            "Train loss: 0.013024986893703629\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rEpoch:  75%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9612;  | 3/4 [05:43<01:54, 114.32s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.9906684027777778\n",
            "Train loss: 0.007380431010720453\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Epoch: 100%|&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;&#9608;| 4/4 [07:37<00:00, 114.39s/it]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Validation Accuracy: 0.9906684027777778\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x800 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABNEAAAK9CAYAAAAKSvplAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdebwkdX3o/W9V9zl9ZpgFEJgBnDCPkKhIYLwQCFEjvjKKibsxF2MMODcSt3k0GXMfQ1RQXMYtyI2iuOG+kBij3oggjE7c0DEsosgiIswww5mFYbYzZ+nuqueP7l/V71dLd1X1UtXVn7cvPGf6dC2nu0931be+i+W6risAAAAAAAAAYtl57wAAAAAAAABQdATRAAAAAAAAgC4IogEAAAAAAABdEEQDAAAAAAAAuiCIBgAAAAAAAHRBEA0AAAAAAADogiAaAAAAAAAA0AVBNAAAAAAAAKALgmgAAAAAAABAFwTRAAAACugVr3iFrF69OtOyb3vb28SyrP7uUEK97DcAAECREUQDAABIwbKsRP9t3rw5710FAABAH1mu67p57wQAAMCo+MIXvmD8+3Of+5zceOON8vnPf964/ZnPfKasWLEi83bq9bo4jiO1Wi31so1GQxqNhkxNTWXeflaveMUrZPPmzfLAAw8MfdsAAACDVM17BwAAAEbJy1/+cuPfP/nJT+TGG28M3R50+PBhWbx4ceLtTExMZNo/EZFqtSrVKod5AAAA/UQ5JwAAQJ+dd955ctppp8ktt9wif/zHfyyLFy+Wf/qnfxIRkW984xvynOc8R0444QSp1Wpy8sknyzve8Q5pNpvGOoK9xR544AGxLEs+8IEPyMc//nE5+eSTpVaryR/8wR/Iz372M2PZqJ5olmXJ+vXr5etf/7qcdtppUqvV5ElPepJcf/31of3fvHmznHXWWTI1NSUnn3yyfOxjH+upz9rMzIy88Y1vlFWrVkmtVpPHP/7x8oEPfECCBRE33nijPPWpT5UjjzxSlixZIo9//OO9x0350Ic+JE960pNk8eLFctRRR8lZZ50lX/rSlzLtFwAAQBpcogQAABiARx55RP70T/9UXvrSl8rLX/5yr7TzM5/5jCxZskQ2bNggS5Yske9+97ty6aWXyoEDB+T9739/1/V+6UtfkoMHD8qrXvUqsSxL3ve+98mLX/xiuf/++7tmr/3whz+Ur33ta/La175Wli5dKv/yL/8if/7nfy5bt26VxzzmMSIictttt8mzn/1sOf744+Xtb3+7NJtNufzyy+XYY4/N9Di4rivPf/7z5Xvf+578zd/8jaxZs0ZuuOEG+d//+3/L9u3b5YMf/KCIiNx5553y3Oc+V04//XS5/PLLpVaryX333Sc/+tGPvHV94hOfkNe//vXykpe8RN7whjfI3Nyc3HHHHfLTn/5UXvayl2XaPwAAgKQIogEAAAzA9PS0XH311fKqV73KuP1LX/qSLFq0yPv3q1/9ann1q18tH/nIR+Sd73xn1x5oW7dulV//+tdy1FFHiYjI4x//eHnBC14gN9xwgzz3uc/tuOxdd90lv/rVr+Tkk08WEZFnPOMZcsYZZ8iXv/xlWb9+vYiIXHbZZVKpVORHP/qRnHDCCSIi8j//5/+UJz7xiekegLZvfvOb8t3vflfe+c53ypvf/GYREXnd614nf/EXfyH/5//8H1m/fr2cfPLJcuONN8rCwoJ8+9vflmOOOSZyXd/61rfkSU96kvzbv/1bpn0BAADoBeWcAAAAA1Cr1WTdunWh2/UA2sGDB2XPnj3ytKc9TQ4fPix333131/VecMEFXgBNRORpT3uaiIjcf//9XZddu3atF0ATETn99NNl2bJl3rLNZlNuuukmeeELX+gF0ERETjnlFPnTP/3TruuPct1110mlUpHXv/71xu1vfOMbxXVd+fa3vy0iIkceeaSItMpdHceJXNeRRx4pDz30UKh8FQAAYBgIogEAAAzAiSeeKJOTk6Hb77zzTnnRi14ky5cvl2XLlsmxxx7rDSXYv39/1/X+zu/8jvFvFVB79NFHUy+rllfL7tq1S2ZnZ+WUU04J3S/qtiQefPBBOeGEE2Tp0qXG7Sqz7cEHHxSRVnDwKU95irzyla+UFStWyEtf+lL513/9VyOg9qY3vUmWLFkiZ599tvzu7/6uvO51rzPKPQEAAAaJIBoAAMAA6Blnyr59++TpT3+6/PznP5fLL79c/u///b9y4403ynvf+14RkdgMLF2lUom8Pdikv9/LDtqiRYvk+9//vtx0003y13/913LHHXfIBRdcIM985jO9oQtPfOIT5Z577pGvfOUr8tSnPlX+/d//XZ761KfKZZddlvPeAwCAcUAQDQAAYEg2b94sjzzyiHzmM5+RN7zhDfLc5z5X1q5da5Rn5um4446Tqakpue+++0I/i7otiZNOOkl27NghBw8eNG5XpasnnXSSd5tt2/Inf/IncsUVV8ivfvUrede73iXf/e535Xvf+553nyOOOEIuuOAC+fSnPy1bt26V5zznOfKud71L5ubmMu0fAABAUgTRAAAAhkRlgumZXwsLC/KRj3wkr10yVCoVWbt2rXz961+XHTt2eLffd999Xu+ytP7sz/5Mms2mfPjDHzZu/+AHPyiWZXm91vbu3Rtads2aNSIiMj8/LyKtiae6yclJOfXUU8V1XanX65n2DwAAICmmcwIAAAzJH/3RH8lRRx0lF110kbz+9a8Xy7Lk85//fCHKKZW3ve1t8p3vfEee8pSnyGte8xovAHbaaafJ7bffnnp9z3ve8+QZz3iGvPnNb5YHHnhAzjjjDPnOd74j3/jGN+Tv/u7vvEEHl19+uXz/+9+X5zznOXLSSSfJrl275CMf+Yg89rGPlac+9akiIvKsZz1LVq5cKU95ylNkxYoVctddd8mHP/xhec5znhPquQYAANBvBNEAAACG5DGPeYz853/+p7zxjW+Ut7zlLXLUUUfJy1/+cvmTP/kTOf/88/PePREROfPMM+Xb3/62/MM//IO89a1vlVWrVsnll18ud911V6LpoUG2bcs3v/lNufTSS+Xaa6+VT3/607J69Wp5//vfL2984xu9+z3/+c+XBx54QK655hrZs2ePHHPMMfL0pz9d3v72t8vy5ctFRORVr3qVfPGLX5QrrrhCDh06JI997GPl9a9/vbzlLW/p2+8PAAAQx3KLdOkTAAAAhfTCF75Q7rzzTvn1r3+d964AAADkgp5oAAAAMMzOzhr//vWvfy3XXXednHfeefnsEAAAQAGQiQYAAADD8ccfL694xSvkcY97nDz44IPy0Y9+VObn5+W2226T3/3d38179wAAAHJBTzQAAAAYnv3sZ8uXv/xlmZ6ellqtJueee668+93vJoAGAADGGploAAAAAAAAQBf0RAMAAAAAAAC6IIgGAAAAAAAAdDF2PdEcx5EdO3bI0qVLxbKsvHcHAAAAAAAAOXJdVw4ePCgnnHCC2HZ8vtnYBdF27Nghq1atyns3AAAAAAAAUCDbtm2Txz72sbE/H7sg2tKlS0Wk9cAsW7Ys570BAAAAAABAng4cOCCrVq3yYkZxxi6Ipko4ly1bRhANAAAAAAAAIiJd234xWAAAAAAAAADogiAaAAAAAAAA0AVBNAAAAAAAAKALgmgAAAAAAABAFwTRAAAAAAAAgC4IogEAAAAAAABdEEQDAAAAAAAAuiCIBgAAAAAAAHRBEA0AAAAAAADogiAaAAAAAAAA0AVBNAAAAAAAAKALgmgAAAAAAABAFwTRAAAAAAAAgC4IogEAAAAAAABdEEQDAAAAAAAAuiCIBgAAAAAAAHRBEA0AAAAAAADogiAaAAAAAAAA0AVBNAAAAAAAAKALgmgAAAAAAABAFwTRAAAAAAAAgC4IogEAAAAAAABdEEQDAAAAAAAAuiCIhsxmF5py29ZHxXHcvHcFAAAAAABgoAiiIbP3fPsuedFHfiyb7t6V964AAAAAAAAMFEE0ZLZ935yIiEzvn815TwAAAAAAAAaLIBoyc9xWGSfFnAAAAAAAoOwIoiGzRrsXmksUDQAAAAAAlBxBNGTWdBwREXGJogEAAAAAgJIjiIbMGk3KOQEAAAAAwHggiIbMmu1yTocoGgAAAAAAKDmCaMjM74lGFA0AAAAAAJRb7kG0q666SlavXi1TU1NyzjnnyJYtWzre/8orr5THP/7xsmjRIlm1apX8/d//vczNzQ1pb6FrkoIGAAAAAADGRK5BtGuvvVY2bNggl112mdx6661yxhlnyPnnny+7du2KvP+XvvQl+cd//Ee57LLL5K677pJPfepTcu2118o//dM/DXnPIcJ0TgAAAAAAMD5yDaJdccUVcvHFF8u6devk1FNPlauvvloWL14s11xzTeT9f/zjH8tTnvIUednLXiarV6+WZz3rWfKXf/mXXbPXMBiOCqIxWgAAAAAAAJRcbkG0hYUFueWWW2Tt2rX+zti2rF27Vm6++ebIZf7oj/5IbrnlFi9odv/998t1110nf/Znfxa7nfn5eTlw4IDxH/qj4TgiQiYaAAAAAAAov2peG96zZ480m01ZsWKFcfuKFSvk7rvvjlzmZS97mezZs0ee+tSniuu60mg05NWvfnXHcs6NGzfK29/+9r7uO1qYzgkAAAAAAMZF7oMF0ti8ebO8+93vlo985CNy6623yte+9jX51re+Je94xztil7nkkktk//793n/btm0b4h6XW4NyTgAAAAAAMCZyy0Q75phjpFKpyM6dO43bd+7cKStXroxc5q1vfav89V//tbzyla8UEZHf//3fl5mZGfnbv/1befOb3yy2HY4J1mo1qdVq/f8F4GWiUc4JAAAAAADKLrdMtMnJSTnzzDNl06ZN3m2O48imTZvk3HPPjVzm8OHDoUBZpVIRERGXSM7QNajjBAAAAAAAYyK3TDQRkQ0bNshFF10kZ511lpx99tly5ZVXyszMjKxbt05ERC688EI58cQTZePGjSIi8rznPU+uuOIKefKTnyznnHOO3HffffLWt75Vnve853nBNAyPn4lGMA0AAAAAAJRbrkG0Cy64QHbv3i2XXnqpTE9Py5o1a+T666/3hg1s3brVyDx7y1veIpZlyVve8hbZvn27HHvssfK85z1P3vWud+X1K4w1yjkBAAAAAMC4sNwxSyM6cOCALF++XPbv3y/Lli3Le3dG2mmX3SCH5hvy92t/T96w9nfz3h0AAAAAAIDUksaKRmo6J4ql4TgiwnROAAAAAABQfgTRkBnlnAAAAAAAYFwQRENmajonMTQAAAAAAFB2BNGQieO4fgYaqWgAAAAAAKDkCKIhE5WFJkImGgAAAAAAKD+CaMjE0bLPHDLRAAAAAABAyRFEQyZGJhoxNAAAAAAAUHIE0ZBJs0k5JwAAAAAAGB8E0ZBJw3G878lEAwAAAAAAZUcQDZk0jcECRNEAAAAAAEC5EURDJnpPNGJoAAAAAACg7AiiIRM9E43pnAAAAAAAoOwIoiETpnMCAAAAAIBxQhANmZg90QAAAAAAAMqNIBoyaZKJBgAAAAAAxghBNGTScBzve6ZzAgAAAACAsiOIhkzIRAMAAAAAAOOEIBoyMQcLEEUDAAAAAADlRhANmTBYAAAAAAAAjBOCaMik0aScEwAAAAAAjA+CaMjEcfVMNKJoAAAAAACg3AiiIZMGgwUAAAAAAMAYIYiGTJqO431PDA0AAAAAAJQdQTRkYvZEI4wGAAAAAADKjSAaMmlSzgkAAAAAAMYIQTRkQk80AAAAAAAwTgiiIRMjE42uaAAAAAAAoOQIoiETyjkBAAAAAMA4IYiGTMxMNAAAAAAAgHIjiIZM9J5oDqloAAAAAACg5AiiIZOm4/j/IIYGAAAAAABKjiAaMmlQzgkAAAAAAMYIQTRkYg4WIIwGAAAAAADKjSAaMiETDQAAAAAAjBOCaMjEzETLcUcAAAAAAACGgCAaMmkynRMAAAAAAIwRgmjIhHJOAAAAAAAwTgiiIZOm4/j/IIoGAAAAAABKjiAaMjEz0YiiAQAAAACAciOIhkyaTQYLAAAAAACA8UEQDZk0mM4JAAAAAADGCEE0ZMJ0TgAAAAAAME4IoiGTpst0TgAAAAAAMD4IoiETeqIBAAAAAIBxQhANmeg90chFAwAAAAAAZUcQDZk0Hcf7nkw0AAAAAABQdgTRkIkxnTPH/QAAAAAAABgGgmjIhOmcAAAAAABgnBBEQyZGJhoxNAAAAAAAUHIE0ZCJQzknAAAAAAAYIwTRkImZiUYYDQAAAAAAlBtBNGSi90QDAAAAAAAoO4JoyKThON73JKIBAAAAAICyI4iGTJjOCQAAAAAAxglBNGTCdE4AAAAAADBOCKIhk6YxnZMoGgAAAAAAKDeCaMik0SQTDQAAAAAAjA+CaMhE74NGDA0AAAAAAJRdIYJoV111laxevVqmpqbknHPOkS1btsTe97zzzhPLskL/Pec5zxniHkPviUYUDQAAAAAAlF3uQbRrr71WNmzYIJdddpnceuutcsYZZ8j5558vu3btirz/1772NXn44Ye9/375y19KpVKRv/iLvxjyno83pnMCAAAAAIBxknsQ7YorrpCLL75Y1q1bJ6eeeqpcffXVsnjxYrnmmmsi73/00UfLypUrvf9uvPFGWbx4MUG0IWs4jvc9ITQAAAAAAFB2uQbRFhYW5JZbbpG1a9d6t9m2LWvXrpWbb7450To+9alPyUtf+lI54ogjIn8+Pz8vBw4cMP5D75rGYAHCaAAAAAAAoNxyDaLt2bNHms2mrFixwrh9xYoVMj093XX5LVu2yC9/+Ut55StfGXufjRs3yvLly73/Vq1a1fN+w+yJRggNAAAAAACUXe7lnL341Kc+Jb//+78vZ599dux9LrnkEtm/f7/337Zt24a4h+Wl90QjEQ0AAAAAAJRdNc+NH3PMMVKpVGTnzp3G7Tt37pSVK1d2XHZmZka+8pWvyOWXX97xfrVaTWq1Ws/7ClPTJRMNAAAAAACMj1wz0SYnJ+XMM8+UTZs2ebc5jiObNm2Sc889t+Oy//Zv/ybz8/Py8pe/fNC7iQj0RAMAAAAAAOMk10w0EZENGzbIRRddJGeddZacffbZcuWVV8rMzIysW7dOREQuvPBCOfHEE2Xjxo3Gcp/61KfkhS98oTzmMY/JY7fHXoNyTgAAAAAAMEZyD6JdcMEFsnv3brn00ktlenpa1qxZI9dff703bGDr1q1i22bC3D333CM//OEP5Tvf+U4euwwJ9ESjoBMAAAAAAJSc5Y5ZLd6BAwdk+fLlsn//flm2bFneuzOyHnfJt0TF0Z50wjL51uuflu8OAQAAAAAAZJA0VjTS0zmRD8dxRUtEo5wTAAAAAACUHkE0pNYMRM2IoQEAAAAAgLIjiIbU9H5oIkznBAAAAAAA5UcQDamFg2g57QgAAAAAAMCQEERDao1gEI2CTgAAAAAAUHIE0cbQ3pmFnpYnEw0AAAAAAIwbgmhj5vM/eVD+xztulP/78x2Z19FwHOPfxNAAAAAAAEDZEUQbM/dMHxARkV/vPJh5HQwWAAAAAAAA44Yg2phptpPIegl7NZqUcwIAAAAAgPFCEG3MqKwxp4fIVygTrac9AgAAAAAAKD6CaGPG8YJo2dfRdCnnBAAAAAAA44Ug2pjxyjl7CaKRiQYAAAAAAMYMQbQxo7LGeskeoycaAAAAAAAYNwTRxkxzID3RiKIBAAAAAIByI4g2ZlT8q5fssYbjmOt0Yu4IAAAAAABQEgTRxozj9GGwQC8LAwAAAAAAjCCCaGNGlXH2UoLZCJZz0hQNAAAAAACUHEG0MeMF0XqIezlM5wQAAAAAAGOGINqYabb7l/UyWCCcidbLHgEAAAAAABQfQbQx4/YhE031RLOt9jrJRQMAAAAAACVHEG3MNF01WKD3TLRqxW6vq/f9AgAAAAAAKDKCaGNGBbx6m87ZqgmdaKeiUc4JAAAAAADKjiDamPEnafYvE43RAgAAAAAAoOwIoo0Z1c+snUzW0zom2kE0MtEAAAAAAEDZEUQbM04feqL5QbR2OWfvuwUAAAAAAFBoBNHGjMpA6yXwpco5K15PNMJoAAAAAACg3AiijZn+ZqIxnRMAAAAAAIwHgmhjRgXPekke8wYLkIkGAAAAAADGBEG0MdNsx7t6CXw1m62aUDWdkxAaAAAAAAAoO4JoY8b1yjmzr0Nlok22BwsQRQMAAAAAAGVHEG3MqH5mvcS91DrIRAMAAAAAAOOCINqYURlovQwWoCcaAAAAAAAYNwTRxozrDRbIHvhyvEy0dhCt990CAAAAAAAoNIJoY8Yr5+zLdM7Wy6eXrDYAAAAAAIBRQBBtzDjeYIEepnO2g2gTKhONGBoAAAAAACg5gmhjxu+Jln0dDS+IxmABAAAAAAAwHgiijRnH7b2cs+k4IuJP5ySKBgAAAAAAyo4g2pjxe6L1Pp1zQk3nJIoGAAAAAABKjiDamHG9cs7ep3PaNj3RAAAAAADAeCCINma8cs6e1tH6Wm0H0ZjOCQAAAAAAyo4g2phR5Zy9DBZQQTMvE63nvQIAAAAAACg2gmhjRgXPeumJFsxEIxENAAAAAACUHUG0MdOP6ZwqAGdbVj92CQAAAAAAoPAIoo0ZFUTrpY+ZKglVmWgivWW2AQAAAAAAFB1BtDGjJmv2EvNS5ZwVI4jWy14BAAAAAAAUG0G0MaMCYL1kormBwQK9rg8AAAAAAKDoCKKNmX70RFPrqGg90QihAQAAAACAMiOINmZUPzO3h7AX5ZwAAAAAAGDcEEQbM65Xzpl9HV4mmh5EIxcNAAAAAACUGEG0MdOP6ZyRQTRiaAAAAAAAoMQIoo2ZZj96ojmtr3oQDQAAAAAAoMwIoo0R13W94Jnbj0w0i+mcAAAAAABgPFTz3gH07ratj8pCw5HTH3ukLJqsxN5P74PWW0+01lebck4AAAAAADAmyEQrgVd8+mdywcd/Ijv2z3a8n54t1ssgANfLRNNuy7w2AAAAAACA4iOIVgLVdkZYs0t6mR5EU33NsvDKOSv+y6eX8lAAAAAAAICiI4hWAqrBf6PZJYimBc56CXmpzVT1cs4e1gcAAAAAAFB0BNFKIEsmWi+ZY27EYAES0QAAAAAAQJkRRCsB1eC/0aVGs6mXc/ZhOqc5WIAoGgAAAAAAKK/cg2hXXXWVrF69WqampuScc86RLVu2dLz/vn375HWve50cf/zxUqvV5Pd+7/fkuuuuG9LeFpPKROsWGHP1cs5epnO216O1RCMTDQAAAAAAlFo1z41fe+21smHDBrn66qvlnHPOkSuvvFLOP/98ueeee+S4444L3X9hYUGe+cxnynHHHSdf/epX5cQTT5QHH3xQjjzyyOHvfIEEe6I9+MiMLKlV5TFLasb9nH5noln0RAMAAAAAAOMh1yDaFVdcIRdffLGsW7dORESuvvpq+da3viXXXHON/OM//mPo/tdcc43s3btXfvzjH8vExISIiKxevbrjNubn52V+ft7794EDB/r3CxRE1W6lhDUdV/bP1uWZH/y+nHT0Yrlxw9ON+zWNnmjZt6eCaGq7rfURRgMAAAAAAOWVWznnwsKC3HLLLbJ27Vp/Z2xb1q5dKzfffHPkMt/85jfl3HPPlde97nWyYsUKOe200+Td7363NJvN2O1s3LhRli9f7v23atWqvv8uefN7ormy++C8LDQceejR2dD9jMECPWxPzS+oDHE65+3b9sn0/rkBbwUAAAAAACBabkG0PXv2SLPZlBUrVhi3r1ixQqanpyOXuf/+++WrX/2qNJtNue666+Stb32r/PM//7O8853vjN3OJZdcIvv37/f+27ZtW19/jyLQp3OqCZ1RQwb0m/pTzunfNshEtIcePSwvvOpH8uov3DK4jQAAAAAAAHSQazlnWo7jyHHHHScf//jHpVKpyJlnninbt2+X97///XLZZZdFLlOr1aRWq0X+rCwqWhBNBc/qTVdc1xVL61vWv55ora+2ZYlltQJogyzn3H1w3vgKAAAAAAAwbLkF0Y455hipVCqyc+dO4/adO3fKypUrI5c5/vjjZWJiQiqVinfbE5/4RJmenpaFhQWZnJwc6D4XVVUr51SZaCKtoFq1Yhn/VnqJeamAmW2LWNIq5RxkOadaN33XAAAAAABAXnIr55ycnJQzzzxTNm3a5N3mOI5s2rRJzj333MhlnvKUp8h9990njlaXeO+998rxxx8/tgE0kWAmmh9o0r8XMQNn/RgsYFmWl+k2yPiWCp45xNAAAAAAAEBOcguiiYhs2LBBPvGJT8hnP/tZueuuu+Q1r3mNzMzMeNM6L7zwQrnkkku8+7/mNa+RvXv3yhve8Aa599575Vvf+pa8+93vlte97nV5/QqFUPEy0Rwj26zeNPuiGYMFeoh6qdXaluX1RXMHmIumdnWQ2wAAAAAAAOgk155oF1xwgezevVsuvfRSmZ6eljVr1sj111/vDRvYunWr2LYf51u1apXccMMN8vd///dy+umny4knnihveMMb5E1velNev0IhGJloTS0TrWkGnZpGT7Ts21MBuIplidUu6BxkJpraV6o5AQAAAABAXnIfLLB+/XpZv3595M82b94cuu3cc8+Vn/zkJwPeq9ESNZ1TRKQemNDp9m2wgDad08tEGxzKOQEAAAAAQN5yLedEf1Ta2Xr6dE6RiEw0LabWSzxKBbMsy1IxNHEGGOHyV00UDQAAAAAA5IMgWgnETecMBtH61RNNz0SzrC537gPVC41yTgAAAAAAkBeCaCUQN51zocNggd56orW+2rbqiTbo6Zztr4PbBAAAAAAAQEcE0UqgEpeJFuiJpv+zt+mcfibaMKdz9tLHDQAAAAAAoBcE0UpAlXM6gUy0TuWcvWSi+eWclljW4DPR1PaIoQEAAAAAgLwQRCsBMxPNTzerB8o5m32azumVc2qDBQY6ndPbLlE0AAAAAACQD4JoJVCtqJ5ojpF91gikmxlBqD5loqko2iBLLclEAwAAAAAAeSOIVgK2Fd0TLZiJpsfUegl6qWW1GNpgA1wMFgAAAAAAADkjiFYC1ZjpnMGeaHqArbeeaK2vek+0QYa41NACyjkBAAAAAEBeCKKVQMVuPY3NbtM5tSBUL9M0nfY2KrblT+cc5GCB9q/RS+APAAAAAACgFwTRSsDviWZmotWD0zm1mFp/pnOKP50z++q68gYLUNAJAAAAAAByQhCtBOKmcwbLOZ2+DRZofbX06ZyDzERjsAAAAAAAAMgZQbQSqFgxPdE6lHP2Y7BAKxOt9/V1o1ZNEA0AAAAAAOSFIFoJ+JlojjSbHco5+xREU4u2poJaxm2DoAYKUM4JAAAAAADyQhCtBPzpnBKYzhnIRNP+2Us4Sg0vaE3nVOsb5HTO9ldiaAAAAAAAICcE0Uqg4g0WcIzpnPXA9ICmPp3T9TO80vLKOW0ZznTO9soHWTIKAAAAAADQCUG0ElA90RrBnmiBTLRg0CxrTEov5/RHCwyO1xNt4FsCAAAAAACIRhCtBCq2P1hAn85ZDwTRAv/MHJTyBwto5ZxM5wQAAAAAACVGEK0EqnZ0JlqnwQJR/07KmM7Z47rSylqCCgAAAAAA0AuCaCVQqbSeRsdxjZ5ojYEF0VpfLcsSq52KNsjQlhPo5QYAAAAAADBsBNFKIC4TreEEpnP2oSeao63f1tqhDTJDTF81MTQAAAAAAJAHgmgloAYLNB1Xms0O5ZzBnmhZgmjaQhXbErv9ChpsJpr/PeWcAAAAAAAgDwTRSqASl4kWHCwQzETLEPrSA1qWNp1zkLEtPXDmEEMDAAAAAAA5IIhWAtWKykRzjOmcDSdYvhnsiZZ+W3ommm2JN51zkLlorvE9UTQAAAAAADB8BNFKQGWiNUPTOYM90STw7/QBKX0R27K06ZypV5VimwwWAAAAAAAA+SKIVgJVLYjWaTpnM5SZln5bZiaaNp1zoEG06O8BAAAAAACGhSBaCdhWdE+0emCSQLCcM0uTfr2vmm2Ll4k2yIb/xmAByjkBAAAAAEAOCKKVgN8TLV0mWpYSTFeLy7Uy0dq3p19V8m0K5ZwAAAAAACBfBNFKoGK3nsZgT7SG07knWpbssTzKOfX9ztLHDQAAAAAAoFcE0UrA7InmB87qzWDm2QCmc7a/H2iZpT5YYHBbAQAAAAAAiEUQrQTUdM6G4xolnI3QdM7ee6LpgTdLL+ccUiYaiWgAAAAAACAPBNFKoBI3nbP9vQqWhco5M2xLrau9SbFkGNM53cjvAQAAAAAAhoUgWgn4mWiO0RNtoeHI/bsPyR+8a5N88gf3RwwWyD6dU23THywwpOmcxNAAAAAAAEAOCKKVgOqJ5jgSykT77wcelT2H5mXzPbtDWVxZAlJq9WqgwDAGC7gx3wMAAAAAAAwLQbQSiMtEazQdmW80RUSk3nRC5ZxZMtEcJ1jO2TLI4JYe/GM6JwAAAAAAyANBtBKo2q2nMWo651zd0X7WeyaaWsa2AuWcAwxuuZRzAgAAAACAnBFEK4FK+1lsOK6ZieY4MldvZ6I5bp/KOVUmWjCIln5dabcpMtjeawAAAAAAAHEIopVARWWiNQPTOZuuzLXLOZuO4w0FUHoZLGAFp3MOMLhl9EQjhgYAAAAAAHJAEK0E1GCBputKo+lHmeqO45VzNppuX3qiuXHTOQc5WIByTgAAAAAAkDOCaCXgDxaIyESr64MFAuWcGbblhHqiDX46J+WcAAAAAAAgbwTRSsDLRAv0RAsOFnBCgwUyTOf0eqK1/j2M6Zw6MtEAAAAAAEAeCKKVgG0E0fzpnA3H8Xqi1SPLOdNvS63eGuJ0Tj34l6UEFQAAAAAAoFcE0UpAZaKJiCw0tCBa05X5uhosYJZ6ivQ6nbP1b8u7Pf26kmKwAAAAAAAAyBtBtBKoxATR6k1H5tv/bjhOKFssS1aXWqYS6Ik2yIJOss8AAAAAAEDeCKKVQNX2n0a9J1rD0QcLuNLsSxCt9dUr52zfPqzpnATUAAAAAABAHgiilYAd8yw2HVdmtXLOYMllT+Wc7W16PdHSryoxPYOOGBoAAAAAAMgDQbQSqMZF0URkZl5looXLObMEpFyvJ5pZzjnQTLSY7wEAAAAAAIaFIFoJaC3RQg7O1UUkZrBAhpCUWoUdLOccUk80yjkBAAAAAEAeCKKVgGVZxoRO3cG5hoi0+qM1HfNnWSZqOu2FVBmn+jrQ6Zxu9PcAAAAAAADDQhCtJCoxQbT5wLROXZasrmZwOqeocs5BZqLp/yKKBgAAAAAAho8gWknEBdF0Cw0ziJatJ1rrq98TLf06Um9T9HLOwW8PAAAAAAAgiCBaSQSDaJPV8FO70AwG0bL0RIsu5xxomSXlnAAAAAAAIGcE0UpC74lmWyKTlYggWiNYzpl+O8HBAurrsAYLDHI7AAAAAAAAcQiilUTF9p/Kqm1LtRKuswyXc2bPRLMDr5xBZojp63ac+PsBAAAAAAAMCkG0ktAz0Sq2JdVglEtE5kODBdJvRwXe/J5oVuZ1JaWvm0w0AAAAAACQB4JoJaH3RKvalkwMKBNNxeG8IFoP60pKD5zREw0AAAAAAOSBIFpJ6EG0SsWKKedsGv/OEo/yyjmDgwUyrCspl8ECAAAAAAAgZ4UIol111VWyevVqmZqaknPOOUe2bNkSe9/PfOYzYlmW8d/U1NQQ97aYqsFMtIhyzuB0TidDRCpUzun9IPWqUm+ztRmiaAAAAAAAYPhyD6Jde+21smHDBrnsssvk1ltvlTPOOEPOP/982bVrV+wyy5Ytk4cfftj778EHHxziHhdTJdgTLVE5Z/rt5DOd0/+eTDQAAAAAAJCH3INoV1xxhVx88cWybt06OfXUU+Xqq6+WxYsXyzXXXBO7jGVZsnLlSu+/FStWDHGPi8nsiWZHDhYIBtGyZKKpZaxgOecgM9H0nmiD2wwAAAAAAECsXINoCwsLcsstt8jatWu922zblrVr18rNN98cu9yhQ4fkpJNOklWrVskLXvACufPOO2PvOz8/LwcOHDD+K6NgJtpEtXsQrZdMNH97w53OmSXwBwAAAAAA0Ktcg2h79uyRZrMZyiRbsWKFTE9PRy7z+Mc/Xq655hr5xje+IV/4whfEcRz5oz/6I3nooYci779x40ZZvny599+qVav6/nsUQbgnWkQ5Z6AnWpYSTMcJ9ETzBgsMcDon5ZwAAAAAACBnuZdzpnXuuefKhRdeKGvWrJGnP/3p8rWvfU2OPfZY+djHPhZ5/0suuUT279/v/bdt27Yh7/FwJOmJVm+aESjHCd2lq1A5Z/v2gZZzGisnigYAAAAAAIavmufGjznmGKlUKrJz507j9p07d8rKlSsTrWNiYkKe/OQny3333Rf581qtJrVared9LTq9B1rFtmSi0j0+mq0nWutrOBNtcFyjnHOAGwIAAAAAAIiRayba5OSknHnmmbJp0ybvNsdxZNOmTXLuuecmWkez2ZRf/OIXcvzxxw9qN0eCMVigYhnlnXGyxKNU4E2t3h7CZAE92Ec5JwAAAAAAyEOumWgiIhs2bJCLLrpIzjrrLDn77LPlyiuvlJmZGVm3bp2IiFx44YVy4oknysaNG0VE5PLLL5c//MM/lFNOOUX27dsn73//++XBBx+UV77ylXn+GrkzyzltqSbIRHMzRKRcN64n2uAYxZxE0QAAAAAAQA5yD6JdcMEFsnv3brn00ktlenpa1qxZI9dff703bGDr1q1ia6WKjz76qFx88cUyPT0tRx11lJx55pny4x//WE499dS8foVCqAQHC0T0RAvKUhqpZhPY7e1ZajrnAOssKecEAAAAAAB5yz2IJiKyfv16Wb9+feTPNm/ebPz7gx/8oHzwgx8cwl6NlmpwsICdJBMt/XaC5ZwylJ5oWjkngwUAAAAAAEAORm46J6IFM9GipnMGZRksECrn9G5Pvark24z9BwAAAAAAwHAQRCsJPWhWsS2ZSJCJ1p/pnK2vg4xt6ftJOScAAAAAAMgDQbSS8KZkSvdMtASDO2OpgJblTedsfR1kw3991ZRzAgAAAACAPBBEK4lqYDrnRIfpnKpfWl8y0VKvIT19PxnOCQAAAAAA8kAQrSQqWvlm1baMoFr4vu0SzCyDBdpRNLUOVc6ZJSCXlL7mQW4HAAAAAAAgDkG0kjAy0SqWVLVMtMWTFfO+FRX4Sr+dYDnnUAYLGNM5AQAAAAAAho8gWknYgemck1pPtCNqVeO+KousH+WcKoo2yOCWsZtE0QAAAAAAQA4IopWE2RPNzERbGgiiefftIRPN9mJo2UtD024z+D0AAAAAAMCwEEQriYodP51zyVQwiJZ9sIDrBdGs9tf27QNMETOmcxJDAwAAAAAAOSCIVhKh6ZzaoIEjJuPKOdNvxyvn9AYLtP492Ew0/3tiaAAAAAAAIA8E0UqiUonPRAv2RFM/y5I91nTiyjkH2hXN/45UNAAAAAAAkAOCaCVRseJ7oi2pmdM5e8lEC5ZzDjsTLcs+AwAAAAAA9IogWklUAz3RJuxOPdGyZ48Fp3NaQ5nOyXhOAAAAAACQL4JoJVHReqBVKmYmWrCcU903S/aYGkbgJ74NfjqnEUIjhgYAAAAAAHJAEK0k9B5oE7YtE/p0zsnoTLQs0zmDmWjDmM5JOScAAAAAAMgbQbSSqNiBnmjtbLPJqi0TVTvyvlmyulRpZWWI0zn1cs5BBusAAAAAAADiEEQrCX2wgD6dc6pqG/3S1M9FsmWiqemcVnA6Z+o1JafvJuWcAAAAAAAgDwTRSsLIRKtYXjnn1EQlFETrJRMtdrDAAKNbevZZlsAfAAAAAABArwiilYTeE62qlXNOTVSMIQP6fbOURqoglu1lorUMMrblOINbNwAAAAAAQBIE0UrC7Ilmy7FLayIismJZLSITrfW0Z2nS73pBNJWJlj0gl3ib2rpJRAMAAAAAAHmodr8LRoEeKKvaljzx+GXy6Vf8gZxy3BL56W/3Rt63l+mcVqicM8NOp9xm63uiaAAAAAAAYPjIRCsJ2zKnc4qIPOMJx8mqoxd7/dGCP88Sj2qq6ZwqiDaEwQLCYAEAAAAAAJAzgmglEeyJpqsE/q2CalmGAbjBnmhDyUTTyjkHtxkAAAAAAIBYBNFKQvU5a31vBs2qtvk0q6y1LD3RVJN/21aZaC2Dnc6pbZ9UNAAAAAAAkAOCaCVh9ESrBINo0f/OEo9SQSwrmImWflWptznwDQEAAAAAAMQgiFYSwemcumBQzZ/OmX2wQGg65yAz0YwYGlE0AAAAAAAwfATRSqJixfdEC5ZzeploGbbjBgcLDKEnmlnOObjtAAAAAAAAxCGIVhKVSng6pxIq7+xhsEAzWM45hOmc+n7SEg0AAAAAAOSBIFpJGD3RYqZxBn/en3LO1r8HmolGOScAAAAAAMgZQbSSMHuiRfdAU+w+DBawvUw08/ZB0NdNOScAAAAAAMgDQbSSMHuiRfdAE2lljqn7ZglIqdJKFYizrE73bvmve3fLg4/MpN+Yt824fwAAAAAAAAwHQbSSqCbsiWZbllaCmaGc02l9VVM5vZ5oMeu6f/chueiaLfL6L9+WelveNvWeaJnXAgAAAAAAkB1BtJLQSzZDgwS0n1Usy+tnliUg5QSmc6p4Xdy6HplZEBGRPYcWMmwtjEQ0AAAAAACQB4JoJVHt0BMtWM6pssicDPWcwZ5oKq0tLrilttHsoZmZ2RONKBoAAAAAABg+gmglUekwnTNY6qnKObPEtULTOdu3x03NVPdv9BBEM6ZzEkMDAAAAAAA5IIhWEp2mc05U/KfZtiytBDN7JpoKxHULyKn7N1UztQzoiQYAAAAAAPJGEK0kzEw0O/ZnlqUPA0i/nXAmWpdyTrf3ck5zOCdhNAAAAAAAMHwE0UqiU0+0CX2wgO1nomXpL6aCWGqVlrepzuWcPQXRKOcEAAAAAAA5I4hWEp16olW0nmi2ZXmDBbJloqnBAoGeaF0y0XrriaaXcxJFAwAAAAAAw0cQrSSqgWwz82fBIFrr+yyZaCqjTAXRbHsY0zmjvwcAAAAAABgWgmglobdB06dxigSDaH4ALEs8KtgTTUkynTNrPzN93ZRzAgAAAACAPBBEK4lOmWjByZ3edM5eeqKlnM7Z6T7dt6l9TzknAAAAAADIAUG0kug0ndOyLJloZ6fpPdEcJ/12VCDMSjqdU4ucZS3pZLAAAAAAAADIG0G0kug0nVO/zbL87LEsWV1OTCZat3JOkV6CaG7k9wAAAAAAAMOSKYi2bds2eeihh7x/b9myRf7u7/5OPv7xj/dtx5DOZNWWxZMVmZqwZWoi/LROtLPTWuWc7Uy0TNM5xVuPiD+dMy4ep5dzNrKkvom5n8TQAAAAAABAHjIF0V72spfJ9773PRERmZ6elmc+85myZcsWefOb3yyXX355X3cQyUxUbPn0K/5APv2Ks6VWrYR+XtHLOdu3ZZnO6QSnc3YZUqBvI3MmmvTeVw0AAAAAAKAXmYJov/zlL+Xss88WEZF//dd/ldNOO01+/OMfyxe/+EX5zGc+08/9QwrnPO4xcu7Jj4n8meqTpk/nzNKjXwXFrGA5Z0xAzsxEyxYBMzLRGCwAAAAAAABykCmIVq/XpVariYjITTfdJM9//vNFROQJT3iCPPzww/3bO/SN6pnWGizQui1TJlp7ES8QF7g9dH+tgpPBAgAAAAAAYFRlCqI96UlPkquvvlp+8IMfyI033ijPfvazRURkx44d8pjHRGdCIV/VqOmcGQJSrmuWc1rDKOdksAAAAAAAAMhZpiDae9/7XvnYxz4m5513nvzlX/6lnHHGGSIi8s1vftMr80SxTFTa5Zy25U3WzBKO8qZztl85Kh8tLril35y9J1r09wAAAAAAAMNSzbLQeeedJ3v27JEDBw7IUUcd5d3+t3/7t7J48eK+7Rz6p+KVc0pPgwWaTjATrXV73JqafemJpmeiZVoFAAAAAABATzJlos3Ozsr8/LwXQHvwwQflyiuvlHvuuUeOO+64vu4g+kP1RKvYltg9pKK5gZ5o3YYUmOWcTvSdEm6ztRmiaAAAAAAAYPgyBdFe8IIXyOc+9zkREdm3b5+cc8458s///M/ywhe+UD760Y/2dQfRH6onmmX0RMsyWEBlokl7fa2vccEtPfmsH5loGVcBAAAAAADQk0xBtFtvvVWe9rSniYjIV7/6VVmxYoU8+OCD8rnPfU7+5V/+pa87iP6otpuY9VrOqYJYKhDnrSsmyczRol6NZsYIGNM5AQAAAABAzjIF0Q4fPixLly4VEZHvfOc78uIXv1hs25Y//MM/lAcffLCvO4j+mGhnolUsyyvBzBKQCmaiiTedMy4TzY38Pg1zsABRNAAAAAAAMHyZgminnHKKfP3rX5dt27bJDTfcIM961rNERGTXrl2ybNmyvu4g+sMfLOBP58xSGqniYGp9VuD2oH6Xc5KJBgAAAAAA8pApiHbppZfKP/zDP8jq1avl7LPPlnPPPVdEWllpT37yk/u6g+iPiUq7nNPW+pgNYTqnawwWyJiJZpRzEkUDAAAAAADDV82y0Ete8hJ56lOfKg8//LCcccYZ3u1/8id/Ii960Yv6tnPoHz0TzfJKMNNTWWEqeNatNLTZh55oZKIBAAAAAIC8ZcpEExFZuXKlPPnJT5YdO3bIQw89JCIiZ599tjzhCU9Iva6rrrpKVq9eLVNTU3LOOefIli1bEi33la98RSzLkhe+8IWptzlu1GCBiu33ROtlsIAdGCwQF5LTk88yZ6LFrA8AAAAAAGBYMgXRHMeRyy+/XJYvXy4nnXSSnHTSSXLkkUfKO97xDnHixjTGuPbaa2XDhg1y2WWXya233ipnnHGGnH/++bJr166Oyz3wwAPyD//wD96UUHRWVT3MLEubzpl+Pa4bXc4Zty49UNdI+doIblOEwQIAAAAAACAfmYJob37zm+XDH/6wvOc975HbbrtNbrvtNnn3u98tH/rQh+Stb31rqnVdccUVcvHFF8u6devk1FNPlauvvloWL14s11xzTewyzWZT/uqv/kre/va3y+Me97gsv8LYqVZUOWerL5pItv5iwemcKiQXty7H6XdPtEyr6Ju5etP4nQAAAAAAwHjI1BPts5/9rHzyk5+U5z//+d5tp59+upx44ony2te+Vt71rnclWs/CwoLccsstcskll3i32bYta9eulZtvvjl2ucsvv1yOO+44+Zu/+Rv5wQ9+0HEb8/PzMj8/7/37wIEDifatbNRggYplaYGv9Ovxyjn9KFprXV3uL5I9iGb2RMsvgHVwri5//L7vyZN/5yi55hV/kNt+AAAAAACA4cuUibZ3797I3mdPeMITZO/evYnXs2fPHmk2m7JixQrj9hUrVsj09HTkMj/84Q/lU5/6lHziE59ItI2NGzfK8uXLvf9WrVqVeP/KpKKXc3olmBky0YLTOdu3x63K6cd0zpjvh23b3ll59HBd7nhoX457AQAAAAAA8pApiHbGGWfIhz/84dDtH/7wh+X000/veafiHDx4UP76r/9aPvGJT8gxxxyTaJlLLrlE9u/f7/23bdu2ge1fkU20yzkrdveJmp0EyzntLpM+XaMn2miXc6p+bFRzAgAAAAAwfjKVc77vfe+T5zznOXLTTTfJueeeKyIiN998s2zbtk2uu+66xOs55phjpFKpyM6dO43bd+7cKStXrgzd/ze/+Y088MAD8rznPc+7TQ0yqFarcs8998jJJ59sLFOr1aRWqyXep7JSmWh2r5lowemcqpwzZl3NHjPRguvNss/9ojadZ0kpAAAAAADIR6ZMtKc//ely7733yote9CLZt2+f7Nu3T1784hfLnXfeKZ///OcTr2dyclLOPPNM2bRpk3eb4ziyadMmLzine8ITniC/+MUv5Pbbb/f+e/7zny/PeMYz5Pbbbx/bUs0kqu1pArZldc0e60QFsVTwzA+ixd3f/z5LJlpwkTzDV+p3JxMNAAAAAIDxkykTTUTkhBNOCA0Q+PnPfy6f+tSn5OMf/3ji9WzYsEEuuugiOeuss+Tss8+WK6+8UmZmZmTdunUiInLhhRfKiSeeKBs3bpSpqSk57bTTjOWPPPJIEZHQ7TBVVSaabXmlmFkyqtQiXo81NaQgJrxl9kRzMmzPDfw79Sr6RgXP8syGAwAAAAAA+cgcROuXCy64QHbv3i2XXnqpTE9Py5o1a+T666/3hg1s3bpVbDtTwhw01YrKRBNR4wCyZFT5PdGC5Zwx93f0IFqW7Zn/zrOUUv3uxNAAAAAAABg/uQfRRETWr18v69evj/zZ5s2bOy77mc98pv87VELeYAGrt0y0ZqCcU0lSzpkpE02Kk4nmeuWcRNEAAAAAABg3pHiNCa/8UuuJljYTzXVdL4il1uH3V+tezpmlJ1owXhW3nWFwKecEAAAAAGBspcpEe/GLX9zx5/v27etlXzBAk9VWvLRqW10nasbR7560nNM1MtH6EEQrRE+0/PYBAAAAAADkI1UQbfny5V1/fuGFF/a0QxiMZ526Qr5/72554ZNPlLl6U0TST7rUM7BUSag3WCBmZXrgLFMmWmAv8wxg+T3RiKIBAAAAADBuUgXRPv3pTw9qPzBgpxy3VL7yt+eKiMj37tklIunLEvUAlm0HMtESTedMH3wKDRbIsZyTwQIAAAAAAIwveqKNIa8nWso+/2YmWjuI1v53ssECWco5Q1G03NATDQAAAACA8UUQbQx50zlTLhdZztllXU6P5ZzBRfIMYDnedM7cdgEAAAAAAOSEINoY8vuY9VDOafnTPjutyyznTJn6JhKKzuUZv9J/RfqiAQAAAAAwXgiijSG7y0TNOHpAzPIGC7TXFbuM/322TDRzmXync7ra9/ntBwAAAAAAGD6CaGNIZY+lLY10tUSyYCZaXFBJz9hqNrNM5zTlWc6pb5q+aAAAAAAAjBeCaGNIZZGln87p378SGCwQlyLW1G7vSyZa6jX0j5mJRhANAAAAAIBxQhBtDKkssrRhoGZUOWe3wQI9Zm+FFsm1nFPbDWJoAAAAAACMFYJoY6jXnmiW5ZdxWl3W5fSYiRZs4F+E6ZwiBNEAAAAAABg3BNHGUNZyTnV3lcnWWpfKaouZzqkFzvrREy3P4BU90QAAAAAAGF8E0caQF/jKmIlm+zE0fzrngDLRwj3R8hwsQE80AAAAAADGFUG0MWRnnM7pdMhEi4uP6bc3HSf6Th0EdzFDHK5vzP5u+e0HAAAAAAAYPoJoY6hb9lgcVZppBNG8dUWvzO21J1pofalX0TdmTzSiaAAAAAAAjBOCaGPIm86ZOhMtopzTirlzW9PprQTSCQXeijFYgEw0AAAAAADGC0G0MeQPFki3XGQ5p3Tur6Zvo5FhsECn9Q0bgwUAAAAAABhfBNHGUNbpnOr+evaZykqLnc6pbaPZj8ECOQav9N+RIBoAAAAAAOOFINoY8so5Uy6nAlh2xHjOQU3nDK43z9CVMReBGBoAAAAAAGOFINoYsrzAV7bpnJWIcs64zCw98NSfTLTUq+gbeqIBAAAAADC+CKKNIX+wQLrl/HJOLYjmlXN2XkZEpGGkciUTXG+eZZT0RAMAAAAAYHwRRBtDdsaeaCqTLKKaMzaKpm8iSyZanj3QgsxMtOLsFwAAAAAAGDyCaGNJlWCmW0rFjYzpnF36qzV7HCwQ6omW53RO/XtiaAAAAAAAjBWCaGPIztwTLZyJ1m1dvU/njF/fsJGJBgAAAADA+CKINoay90RrfU3XE83/PtN0zsCa8x0sEP09AAAAAAAov2reO4Dhs1L2RNu297C89OM/kTW/c6SIiFT0VLSu0zl7zEQLzCIIBtWGySUTDQAAAACAsUUQbQzZXfqYBd3y4KOyfd+s7Ng/217e/5mXiRazMnM6Z++ZaHlmgOkBQWJoAAAAAACMF8o5x1jSbCqVQRY5WKD9NT6IFl5PGqH1FqScs0hTQwEAAAAAwOARRBtDtp1uOmczEDCyjEw0Szpx+z2dM89yTu17eqIBAAAAADBeCKKNIa8cM2EgyAlEjKIz0aJX1uyxJ1qRyjnpiQYAAAAAwPgiiDaGrC7DAIKCmWj6YIFu/dXMnmhOzL3iBYNmeZZROgTRAAAAAAAYWwTRxpCKgSUNAwUDWXoJZ7dJn/rN2co5zWXyDF2ZPdHy2w8AAAAAADB8BNHGkAqCJc2mCpdzhu8zqOmcwUVync5JJhoAAAAAAGOLINoYUtljSeNAwQwyOyITLW5Veilos5kl8BSq58ywjv5wyUQDAAAAAGBsEUQbQ3oQLEmPsWDWlZ6JpvqrxWaiaW3Qgr3Vkgj1REu9hv5hsAAAAAAAAOOLINoY0oNgScojg5loUT3R4sJbbo/lnMFYVZ7BK3338ywrBQAAAAAAw0cQbQyp7DGRZEGpRNM5Y1ZjlHNm6okWGCxQkJ5oeU4JBQAAAAAAw0cQbQxZ2rOeJBYUvI9RztllOqceN2s6burgU/Du+QbRor8HAAAAAADlRxBtDOnDNRNlonUq52x/jVtLMGiWNhstuDw90QAAAAAAQB4Ioo0hc7BA9/uHp3P633eb9BmMmaXtixa8d55llA5BNAAAAAAAxhZBtDFkBNES5HaFp3PquWyqJ1r0eoIBuLTBpyL1RNO3TQwNAAAAAIDxQhBtDFk9Tue0I6Zzxq0mGARLnYkW7ImWY0GnQxANAAAAAICxRRBtDOlBtCTlkcHpnHbEdM642FZw9c1mb+WceTb0pycaAAAAAADjiyDaGNIzyZIEpTpO5/TWk6ycM20mWrick55oAAAAAABg+AiijSG9o1miTLQ+lnOmnc4ZXHGeoSvKOQEAAAAAGF8E0cZQX6dzeoMFopcN3t5wnET7qBR1sACZaAAAAAAAjBeCaGPIHCyQfjqnFZmJFr2eXjPRQoMFClPOmdtuAAAAAACAHBBEG0NWyp5owcBXRY/CtcXFtoJDCdIG0UKZaKmW7i8GCwAAAAAAML4Ioo0pu0sGmS4YMLJt/ft2OWfEcq7rhqdzps1Ea39Vcbs8g1dmTzSCaAAAAAAAjBOCaGNK9UVLEgsKtjEzyjnbX6OCSvpNlXawLe10TrXeSor9HRQ9gEcMDQAAAACA8UIQbUylyewKlmRGTueMWI2+3ESldcesPdG8jLdcg2jR3wMAAAAAgPIjiDamrFSZaAmmc0Ytp618stJ6qaXNRFN39zPRcu2K5n1HTzQAAAAAAMYLQbQxpeJgaTLRJqutl0t0Jlrnck61bDNYG9qF6tlW6dB7bVj0XSeIBgAAAADAeCGINqbS9ERTJZgnHb1YRESOXDzh/czriRaxnGOUc6ogWrr9VJlodoey0WGhJxoAAAAAAOOrmvcOIB9pglIqePQXZz1WViybkqf97rHezzqVher9zya8cs6UmWjtFaueaEWZzkkmGgAAAAAA44Ug2phSwa8kwSAV91o0WZUXrDkxsB7/e9d1jcmdetCp18ECXk+0VEv3l16yymABAAAAAADGSyHKOa+66ipZvXq1TE1NyTnnnCNbtmyJve/XvvY1Oeuss+TII4+UI444QtasWSOf//znh7i35eD1MktwX9UTraJHzNR6tO+D8Tg3opwz7WAB1ROtGNM5GSwAAAAAAMC4yj2Idu2118qGDRvksssuk1tvvVXOOOMMOf/882XXrl2R9z/66KPlzW9+s9x8881yxx13yLp162TdunVyww03DHnPR5udKhOtHcgKx9CMzLPgmvSsM2+wQDNbJprdYYDBsLix/wAAAAAAAGWXexDtiiuukIsvvljWrVsnp556qlx99dWyePFiueaaayLvf95558mLXvQieeITnygnn3yyvOENb5DTTz9dfvjDHw55z0dbp6maQc1AXzJjPdr3wXWZ5ZzZMtGcApVz0hMNAAAAAIDxlWsQbWFhQW655RZZu3atd5tt27J27Vq5+eabuy7vuq5s2rRJ7rnnHvnjP/7jyPvMz8/LgQMHjP+QbTpnZDmn3hMt8DNvKIAlUsk4GCA4WCDPTDSHnmgAAAAAAIytXINoe/bskWazKStWrDBuX7FihUxPT8cut3//flmyZIlMTk7Kc57zHPnQhz4kz3zmMyPvu3HjRlm+fLn336pVq/r6O4wqlVSWJBikgkeVqEw0vZwzsC7HK8W0vABc6p5oKhPNzj8TzaUnGgAAAAAAYyv3cs4sli5dKrfffrv87Gc/k3e9612yYcMG2bx5c+R9L7nkEtm/f7/337Zt24a7s4WVfjpnZDmndlNwXV4ZqGVJ1ZvO6aTaSzVYQAXhnBxTwPRdzzMjDgAAAAAADF81z40fc8wxUqlUZOfOncbtO3fulJUrV8YuZ9u2nHLKKSIismbNGrnrrrtk48aNct5554XuW6vVpFar9XW/y8Bv1N/9vkmncwZ5AwlsP5OskXKwgJfNVoBMNMo5AQAAAAAYX7lmok1OTsqZZ54pmzZt8m5zHEc2bdok5557buL1OI4j8/Pzg9jF0rK8cs7k0zkrEa+WTuWcrlbOWbVVJlpv0znzjKLpm6acEwAAAACA8ZJrJpqIyIYNG+Siiy6Ss846S84++2y58sorZWZmRtatWyciIhdeeKGceOKJsnHjRhFp9Tg766yz5OSTT5b5+Xm57rrr5POf/7x89KMfzfPXGDmpBgu072R1yURzJb6c08tESz2d01+H/u88uGSiAQAAAAAwtnIPol1wwQWye/duufTSS2V6elrWrFkj119/vTdsYOvWrWLbfgrUzMyMvPa1r5WHHnpIFi1aJE94whPkC1/4glxwwQV5/QojyQuiJUjtcpJO5wwNFujDdM721yIMFtADZ/REAwAAAABgvOQeRBMRWb9+vaxfvz7yZ8GBAe985zvlne985xD2ajwkyahqdpjOaevlnIGfqUCTbVtSaQdC0/ZEcwPbzjN2pQcAiaEBQP+4riuv/eKtcuzSmlz+gtPy3h0AAAAg0khO50TvVHJfkoyqTtM5dcF1eUMB+tATzSpAOae+6/REA4D+2XVwXr79y2n5wk8ezHtXAAAAgFgE0caU32Os+32dTtM5Lf1+5s9UwEwv58zaE62ipommWrq/6IkGAIOhPi8cl3J5AAAAFBdBtDHlDbtMcLLiBcOipnPqowVie6LpmWhOqv1Uu+eVkuY5nZNMNAAYCD1LmYsUAAAAKCqCaGPKHyzQXTMwIVNnDBYIrM3VyjmzZqKpexejnFPvicZZHgD0CxcpAAAAMAoIoo0pFfxyEgS1vOmcET3R9FuC5z1R5ZxJtqdzA6Wk+U7nJFMCAAZBf39N2zsTAAAAGBaCaGPKStETrVMmWqfpnI4xnTNjJlqgnDPPDDAGCwDAYDSNTN8cdwQAAADogCDamPJbjCWfzhmZiaaXcw5gOqceiNPXmQeXkzzE2LFvVu6ZPpj3bgAjS39/bfIGCwAAgIIiiDamvJ5oPU/ntLT7mT9zXb2cs/VSy9oTrRLe9NDpjxU90aD7q0/+VJ73oR/K/sP1vHcFGElNbeYMmb4AAAAoKoJoYy7JyUqn6Zy6YFab3xOt90w0PQsurwAWPdEQ5+H9s7LQdGTv4YW8dwUYScbglnRDnAEAAIChIYg2prJkokX1RBPRSjoD6/LKOY2eaOnOjtT+dcp4GxZ6oiGOem3QEB3IRv/boZwTAAAARUUQbUx50zlTZKJF9UQT8Sd0BtdklnNmy0QLTufUbxs2l0w0xFBTZwmuAtm4XKQAAADACCCINqbSZKLpZZlp1qVP9cweRGt9Nco5U62hf/RdpycadOq1TiYakI2efebwdwQAAICCIog2ptJM54wKZOmsmHVFTedMO1hALwkN7s+wmT3ROMlDi+u63muSIBqQDT0nAQAAMAoIoo2rduQrSYuyZkRJpbGqdkFn8MTH66Vm91DOKWrb4fUOm1lulMsuoIDolQf0zqEnGgAAAEYAQbQx5Weiddd1OqdaV+DEx9XKOfuZiZYXY3oc53ho018XZKIB2RjBaP6OAAAAUFAE0caU6mOWJHOm63TO9tdQT7R2lpul90Rrpjw5ith2XgEsGl8jih4443UBZEO5PAAAAEYBQbQx5Qe++jCdMyZJzPHKQEUq7TS2rJloeilpXidYZiYaJ3loMTPRctwRYIQ5RjA6xx0BAAAAOiCINqaSTud0XdcYEJBmXVHlnGkDYKonml2I6Zyc5CFMfy1Qzlks37h9u1zytTukQXSz8Pg7AgAAwCggiDamVDys27mKHvOKzURT9w2Et9R5q62Vc6bNRHO9AJ5+WxEGC3CShxbKOYvr/9z0a/nylm3yyx0H8t4VdNEk0xcAAAAjgCDamPKDaJ1PVvQTm9jpnFb36ZzViprOmS4jxCvntK3QbcOmb5ZECSiuUc7JC6NI5hut95uFBploRWeURRNEAwAAQEERRBtTXglml/vpQYG46Zxx/dX0gQQqCFZPOVjAK+fUA3g5nV/REw1R9L8RTv6LRT03BDeLz+iJRswTAAAABUUQbUypmFS3YJAeOIrriaaiaME1+aWYWk+0jOWcFaMnWv6DBSjbg6K/pNO+vjFYKqjJ32vxGX9HPF8AAAAoKIJoY8q2kjX61zM4uvZEC6xKLWtp0znrqYNoKhPNvy2vOIWeHcE5HhSHcs7CUkFNgjLFR29BAAAAjAKCaGPKSjidUw8cxWWiWZY/WsBYtr3yim313BPNmM6Z22ABpnMirMwn/03HlQs+drO86at35L0rmahMNIKbxUdvQQAAAIwCgmhjSoWkup2r6EGBuEw02ysNNW+PKudspO2Jpso5Lb2cMx/6dumJBsXMRMtxRwZgx75Z+elv98rXb9+e965k0iQTbWQ0uUgBAACAEUAQbUzZCXuiNY2eaNH36Tqd0/IDcI2UZ0dqHZYVvm3Y6ImGKHpyZdkGC4x6EMrxBgvkvCPoip5oAAAAGAUE0caUnbic0w+EWXHlnO2vwYb/TS8AZslEpfVSy1qmY1uWH8TLbTpn9PcYb0ZwtWQvjFEvh2SwwOhwS/x3BAAAgPIgiDamVDys62ABL5ssJg1N9Emf5u3qPKhiWV4mWj1lSoiXiSZaH7dUa+gfl0w0RGiWuJeT35h/NEuYVZYgQZniM3sL5rgjAAAAQAcE0cbU1ERFREQOzTc63k+d2NhxtZwionLRwj3R1LIiE3a2TDS1TsuytD5ueZVz+t+PYDwBA2I0RC/ZC2PUX/NeJt0o7vyYoZwTAAAAo4Ag2pg6fvmUiIhM75/reD+VyVFJkokWLOd0/HJOPxMte0+0pCWog0JPNETRkyvLlvGkB71HMRDV9Hqijd6+jxvH4f0VQDk1mo5cdM0Wee/1d+e9KwCAPiCINqZWLl8kIiIPdwuitU9m4iZzisRP59TLOauV1p2aTrpyTrVKSyyv+Vp+5ZzR32O8jXqgqRNnhEtV9aBMyZ6WUhrl1xoAdPLAIzPyX/fuli/9dGveuwIA6AOCaGPqhHYm2sP7Zzvez++JFn8fq1s5pyVSzTidU1+HFbht2MhEQ5RSDxYY4eygMveqKyP9+RqxlxoAdNQgKxoASoUg2phambics3smWlw5p+MFwCyptnuiNQLlnD97YK+s/9KtsvNA9H74PdHyL+fUt6uOg+bqzXx2BoVR5gyaUQ5ElTlDsIz0l9eovdYAoBNaCwBAuRBEG1PHt8s5dx6c7/ihnmg6Z/tr8DxV9YqyjHJO806f/fED8p93PCw33DkduW5jsEBM2eiwOEamhCu3b9snp7/tO3LV9+7LZ4dQCMbJf8mOj82JtDnuSAZlzhAsI3qiASgr1cmECzoAUA4E0cbUsUtrUrEtaTqu7D44H3u/JNM5LZUhFrjd76fml3PWAz3RVCbXzHx0Rpc+WMAL1uXUFS1YzvnL7ftloenIbVsfzWV/UAxGyWPJgjWjPDTBLEXNcUeQCOXyAMpKvaeN2ucoACAaQbQxVbEtWbG0JiKd+6Ilmc6pBHuVuXo5Z8Vu32YeRMw3nPbX6CCauqdtWV42XF7HIPp2Hdc/KOo1PZ+S0NFW5pP/US6J1OP1o7bv44igJ4CyUp9BZTtGAIBxRRBtjCXpi5ZoOmf7VRQ8NNDLOfXl9eEC9fad5urRUzu9TDTv//IbLCBGEM31e1z0sDu/eGi/nP7278iVN93b484hL84IB5q6GeWSyOYI7/s40v906BsEoEzUZ5Dj5ngMCwDoG4JoY+z4I1t90XZ0CKJ5PdE6vFL86ZzRgwX0ck4RkYaWIrLQUEG0mGys9ipty9LKOfNh9kTzT/R6OUG/c8d+WWg48v17d/e8f8hHmYM1o5yJZux7yZ6XMmqWOKMTwHgj0xYAyoUg2hg7fpnKROtUztkOhHUaLBDT8N8s54zORFtoqnLOLploltZ7LacTLCOIJm5fpi2pE8cd+zpPSUVxmRk0+e3HIIzy5NEyl9mWEc8XgLIa5UnXAIAwgmhjTJVzPtwpE83xA2Fx4jLE1HGCbVlS1VLZGlr9o8pEm4/JRFP3tCxL7Nync2rfO/5BUS8HRCpIufPgnFfaitEyytla3QSzL0dJwyEoM0rcwPsrAJSF/p7G5xEAjD6CaGPshHY5Z6eeaH45Z4LpnIHjgqaWRVaxLS9jTS/nrLcDanMxgwXUebAl8VNAhyGqVNXxeqL1kInWXofrdn4eUFyj3DesGz2uO2pXz41edQRlCq/MwWgA441MNAAoF4JoYyxJJlqS6ZxeJlpcT7T2sqovmn4A4WeiRZ/l+iWh/nb6eRVv/2xdvvjTB+XRmYWO9wse87R6orW+7+WASM+W2bEvvqwWxWWUPJbs5H+UAxtNMtFGipn1yPMFoDzKPIAIAMYRQbQxdnw7iLbzwFxsIMhJlInW+hpcgzpOUMuqCZ16OafqhRaXiabWYVlWbMZbL7740wflzf/xS/n0j37b8X5RAcJmO8LYywm6vuyODr3pUFx6llPZMtFGOcuuzAMfyojMQQBlNcqfpQCAMIJoY+y4pVNSsS1pOK48cmg+8j7qRLTSaTpnO7gVDCapwJwKsk20+6Lp2VeqD1hsJprogwXat/Xx+GPf4bqItDLSOgke8ziu25eeaPrJIsMFRtMoN9/vZpSz7LjyP1qMnpM8XwBKhOmcAFAuBNHGWMW25LilNRER2RFT0ploOqf6JiLQpC9bqahMND9ytNAlE02Vk1qWNZByTrX9RpejmuA2nT6Vc+rr3Z6ynNNxXPnkD+6XW7c+mnn76F2ZgzXGgf+IZQeRiTZajOerZH9HAMZbmS+2AcA4Iog25lRftOmYUkI/m6yHck6vJ1o4E22hHYma65aJJp0nhGalMuG6nbQFf+y6rrdMb5lo2Xui3f7QPnnnt+6St3/zzszbR+/Mqa3lOjh2RjiwMcr93MYR5U4AyqrJdE4AKBWCaGNuxdJWEG3XwehyTi+brFNPNInuVeb1U2svGhws0HRc7/v5Lj3RbMsaSDmnCqLpfdqiBA96XNF+jx52qJfBAgfaJaiH5huZt4/eNUe45LGb0Z7OqX0/Wrs+lsyMzhx3BAD6jOmcAFAuBNHG3IplrXLOnQeiyzmbSaZzeplocT3RzMECKnBV187Q4zLR1LGGNaDpnCp41i34ES7n9AOAvWRN6Mtuf3Q21VS6etMPRiI/rnFwnOOODMAol6pSzjla9KeI6ZwAysQcnML7GwCMOoJoY+64Ze1MtAOdM9HsBIMFwplora8qeDZRMTPR1GROEZG5enQmmioStS1tO/G7kpoqJ+12UBP8qeP0JxNNX3ZmoSkH5pJnlakg5KgFN8rG7BtWrudilEvsmpy0jBSz8TbPF4Dy4P0NAMqFINqYW9EOou3sqZyz5QPfuUf+12d+5gV33EA5p5+J5ra/+kE0PaBmbl9tQy/n7N8BSD1pEC2we/p0zl4argcDE2lKOr1+biXLfho1Ze69ZTZ7z3FHMhjlyaLjqMwZnQDGG+WcAFAuBNHGnJrOuSu2nFMFwrqXc97x0H757t275K6HDxjLqgyyiYpt3L7QMKd0RmW6qBMry4ofYNALFdDrdmUw1BPN9QNgjR6iWMGpoGmCaOrx44AsX/pLY9SytboZ5RIUfX+JoRWfMaCDJwxAibjGBSne3wBg1BFEG3NeJlofgmjBZYLlnOqrCjotBLLPorLR/J5olrcPg8hESztYwHFdLwDWS9ZEMDCRLhNNBfE4IMtTuQcLjO6B/ygHAMcRPewAlFWTQTcAUCoE0cacGizw6OF65ITMJOWcv909Y/xbBXWC5ZzVdiZaI6KcUyR6Qqc61rC1wQKDmM7ZPRMt+G/XO9HrJbgQXPahLOWcIxbcKBunxGUaemx51H63Mgc3y8gd4dJhAOiEck4AKBeCaGNu+aIJmay2XgZRwwVUnKtTJtrMghn8CgZ31LJVLxMtPFhAJHpCp1nO2f/BAkmzuYKTR13XPyjq5YBILasemwOz9cTLJu3nhsFyRjhbqxt3hANRZR74UEZl7i0IYLyRGQ0A5UIQbcxZluVlo+06GC7p9DPR4tfxv57y/8jSqar3b39qpb+N1joC5ZzNYBAtIhOtvQ7b8gcL9POEOPFggcCPXW2ZXvZHPb61qpmll8SCN1iAA7I8lXkK5CgHoozJogRlCk9/efWzZB8A8jbKrREAAGEE0SArlrb6okVloiUp57z0eafKLW95ppx24jIR8QNB3rLtRSfa36iDiXqinmj+wYZXztnxt0knaXP+qJ5ofrAw+x6px6o2UUm0H7p6g55oRaA//GWbKjjK0zn156Jsz0sZkakBoKzK3PYBAMZRtftdUHZRwwW+vGWrHLe0lmiwgIjIZNWWqt2KyarsLq8nmjdYwMy2Sp+JZhm39UPSTLSonmhqmV6CWCpIMan6xaUJoql956pmrsqc8TTKgQ2u/I8WZ4QDtgDQCZ9HAFAuBNEgxy5tlXPuPNjKRNt1YE4u+dov5KjFE/K6Z5wiIt2DaCJ+ppk/tVL1M2vdPtFlOmdUEE0dbFiWP6Cgn6U+wX2NEyxlcxx/33oq52wvq/rSpQlUUM5ZDGW+wmxOFBut363Mz0sZ6ZXso/ZaA4BOypyxDgDjqBDlnFdddZWsXr1apqam5JxzzpEtW7bE3vcTn/iEPO1pT5OjjjpKjjrqKFm7dm3H+6O7YCbagbl6+2sjUTmnUgkMDlAHDWrR4M/D0zkjBgu0v1rt/+m39YMqKe2WzRXqidanck514qh6ogUfk04WEu47BmuUA03djPJEMa78jxYjE23EXmsA0AkXdQCgXHIPol177bWyYcMGueyyy+TWW2+VM844Q84//3zZtWtX5P03b94sf/mXfynf+9735Oabb5ZVq1bJs571LNm+ffuQ97w8vMEC7Z5oakpm03G96ZXJMtFUuaZZzllR0zlVplp7neHpnH4m2u6D87Jj36xfEmqJN1ign+fDC81kmWjB6ZyO6wfAXDd7dlyznZVXm0ifieaXzXLSmacyHxy7I1yqWuYy2zIySod5vgCUiH5swOAUABh9uQfRrrjiCrn44otl3bp1cuqpp8rVV18tixcvlmuuuSby/l/84hflta99raxZs0ae8IQnyCc/+UlxHEc2bdo05D0vj2Ammh7cmm8HtjpN51Sqthkk8zPR2kE02+z7FSznVNt1HFdeeNWP5Fkf/L7Mtrevx/D6eULcW080f/+zBk/Ucr30RBPhpDNPo9w3rJtRzuYq89TUMtJfXyP2UgOAjppcJACAUsk1iLawsCC33HKLrF271rvNtm1Zu3at3HzzzYnWcfjwYanX63L00UdH/nx+fl4OHDhg/AeTykTzg2h+RthcO7CVpJyzGggE+T3R2j+31XTO1jrrTfNAQmWibd17WLbvm5VD8w155NBCex2WF4zr5+FHI3EQzfy5G1gm63ABFQfL0hNNf/wIEuSnWeKMJ7OcM8cdycAMouW4I0jE7BlUrr8jAOOtzBnrADCOcg2i7dmzR5rNpqxYscK4fcWKFTI9PZ1oHW9605vkhBNOMAJxuo0bN8ry5cu9/1atWtXzfpfNce1MtANzDZmrN41MtNmFVmArSTlnNTA4INhPTZVzquDPQsMcJKACdr962A90eploopdz9jMTLWE5ZzCI5rri9KEXllpuslpp70+KnmjafcsWvBklZT7517PsRq1k2MxsGq19H3X7Di/I//rMz+RbdzyceBlnhLMeAaCTUc7qBgCE5V7O2Yv3vOc98pWvfEX+4z/+Q6ampiLvc8kll8j+/fu9/7Zt2zbkvSy+pbWqLJpoBXF2HpiT+boWRPPKOZNnoqnAlDpOUAG4im1mWy0EBwu0t3WXHkTTgnj97onmuq63D+nLOfvTdF0tV8uSiaYFO7NmwqF3Zi+nHHekg50H5owM06T0P9FRK0FpUD6Tm5t/84h89+5d8rmbH0i8DD3sAJTVKGd1AwDCqnlu/JhjjpFKpSI7d+40bt+5c6esXLmy47If+MAH5D3veY/cdNNNcvrpp8fer1arSa1W68v+lpVlWbJ80YTM1ptycK5hBLdUiWWiwQJeTzQzMBUs51Q/D5Zzqgw4PYimbrMs0co5+3OCleYkO3hS57iusbyT8aAoGETL2hNt1LKEyqToUwUfevSwPP39m+W83ztWPvWKP0i17CiXoJS5V13Rqc+QNO9n+sdB1vdTACgiPo8AoFxyzUSbnJyUM8880xgKoIYEnHvuubHLve9975N3vOMdcv3118tZZ501jF0tPTUdcr7R9DLCRNIF0SpeOacaLGBO9vSmczqdp3Pe9fDB0LptyxK1B/1KUtCDUI0uKUTBbTqO25dpct5gAXqidfTvtzwk57z7JrnjoX1570pI0XuibX3ksDQdV377yEzqZUc5O4jymfyoxz5NEE0vuSVzEECZ6G+FfB4BwOjLvZxzw4YN8olPfEI++9nPyl133SWvec1rZGZmRtatWyciIhdeeKFccskl3v3f+973ylvf+la55pprZPXq1TI9PS3T09Ny6NChvH6FUphq9+SaqztmT7Q00znVYIFAOafXE80bLBA/nXP/4bps3zcbXrnWFK1f8SI9CNXtoCY0WMDtz/Q/dbKoMtGy9kQr+0nnG//t57LzwLy84tM/y3tXQvSHvojBzOCgjzSMQFQBf7dOyGzKj/+aS/7AE/QEUFZMiwaAcsm1nFNE5IILLpDdu3fLpZdeKtPT07JmzRq5/vrrvWEDW7duFdv2Izgf/ehHZWFhQV7ykpcY67nsssvkbW972zB3vVSm2plowcECc+3+aHaCnmgTlejBAmrRYM+0YMBort40hgrobMvy1tOvJuH69rsPFjD/7bhuX0rdVGCi1g5ipstES77/ZbF3ZiHvXQgp+sm/lxWUoWGb8Rov3q/WUT8yRZGN4wXRUixT8LJoAMhqlLO6AQBhuQfRRETWr18v69evj/zZ5s2bjX8/8MADg9+hMVSb0DPRwuWclUTTOc2+XurE1bKCmWitMyuViVa1LWk4rszVm0Y/NJ3V/k9E+tQRLV0QKtwTrT+Ny4OZaATRoh25eEL2Ha7nvRuRin6FWe1TlgP30c5EG919H3VZMtHMacf93iNgsFzXle//eo/83oolcvzyRXnvDgqm6BfbAADp5F7OiWJQQZxWT7Ss0znNwQHqmKHiBdHamWiBcs5liyba23Zig2it6ZztwQL9KudspBksYP7bFbMnWtaT9GBPtFSDBRr69jNtfmScfOwS7/v9BQumucYV5hx3JIZ6TWWZ4KovMmrZXE0y0XKTpScamRoYZXfuOCAXXbNF/r+v3pH3rqCAzMqFHHcEANAXBNEgIiJTE9E90eYWWkE0K1EmWus+da8nWrucs/0qU0G2ZqCcc+lUtb3tptw13QqiqaCS0prOKcZ6e2X0FOtSq6YOgNTv6LjBkeU9BtG8fnLJj67qY9QTbfFkxfv+np3hwRN56sfrYJCaXlZQhiBawbPsOjGC3KO16yPPy35MNZ2TIBpG1+6D88ZXQDfKWd0AgDCCaBARPYjWNMs52wG1ROWcFbMkUX1VAbjg9M75dhBo2dREe9uObH3ksIiInKJlHomocs52JlqaX6yDhpM8CBUckuC6bl8yXXrJRDOCgCVPRdMDhndPR2cr5sXI1irgwbF6bWYaLKC9rvsVvB4Wyjnzky0TTfu+3G9nKKFeMn5Rfvr10bJf9ASAcUAQDSIiMtUO4sw1msbUzNmFFNM57eBggdbtdqAnWiPQE01lou2brcuBuYaIiKw+ZrGxbsuyvKZogyjn7HbgqwIIFS0TrR/lnE7feqJl2vzI0B+Xu6eLlYlmZjwV7+BYBVh7nc45aq+xUc6iG3WNDJloepCWk0yMmizZlxgf/RhEBQAoDoJoEJEO5ZztrLQk0zlVuWawnLMSCqJFl3NufWRGRFqle485omasWy/n7FegQs/k6nbgG+zv5riuEXjLevVZLacGO6TqidYcn4My/XG5O6ZvXl6KPlhATeVsZEjvcUY4sEF5YH7U453m/Uz/2xm1rEcgS/Ylxgc9HwGgXAiiQUQCgwW0IJobCB51MmGbfb3UgYIKflUDfb+8wQLtcs5H2w3jVyybkqkJ86VpW1bfyzn1TK5uB77qd6lU/OEG/biyqIJ3k5UMmWja81T2g7KGFjC8d+ehQl3tN8rQCvg8qH3KUiJnTEzs8Jj/239vk6e857uxg0HyoGfOFfF5KTP195rm/azoZdFAJ40eMn5RfkW/2AYASIcgGkTEz0SbrzsyX2+Gfp5qOmdMTzSViaZu98s5J4z1rFhWk1q1YtxmWa3/RPqXpdAIDBPoFCQIDhYQMTPBsp6kq2wZ1ROtnqJmbiFFEHDU6b/fofmGbN83m+PemIpepuH36kkfRWsmzES76a6dsn3frFz/y+n0OzggRX9eyszrw5fifZFBEBhlzR7eZ1F+fB4BQLkQRIOIiJf51RosED4ITDOds+GVc7ZuVwG44GCBYDmnsmLZlJcZp9iW31utbz3RAgGrjoGowO8iYk7S1A+K9s4syH/duztRtpQ63u69J1q5D8qCgxN+vas4fdGKfnDs9epx0wegk/Z7U3/zRXpemgRlcuP14esy9VhHuRNGmT9QKecdQSGZ5eo57ggAoC8IokFE4qdzKpXuMTS/XNOJLuec8Mo5W7erYN2yRWYm2splU97++Cw/E61PBZ0LgaPdTiduwZ5oIiL1mADD2//vnXLRNVvkB/ft6boP6sBK74mWJNDRaDqFLyPsJ/WaUa+lwwvh12heih6s6aWMJOmES/W3dO/OQyn3bnCaCQOA6L8skwrpYYdR5gfR0kXRDs035NB8YxC7hAJhOicAlAtBNIiIH8SZbziRmWiJyjkDmWbq/EllsVWC0zljMtGOWzYltVBPNP/7PDLRgj3RRMxMNL00dHr/nIiI7Dow13Uf1DYntfGnSc4764EMjyJmQPWTepxUcLVIv6/+eizSfin6PqUt+006nVO9/n+7ZyYyCJ+HomcIlpkKuKY5WSz63xHQSabAsePK+R/8vpz/we/zmi85Po8AoFwIokFE/HLCuXpT5uvhs+U00zmDTaX9TDTz5yqItSwQRFsZUc5pWZYXjOvX8UcwiNbpwMbviRYd7NJPFlUQMsmBklrvpPb7JumLFsyiK/tBmQpYqtdFsJ9dnoxAUwGvMDec7Afv+q/TsZxTa6r92z0z6XZwQIxMtJL/fRRNsC9mEkXP6AQ6aWZ4zc/Wm7J936xs3zcrsxG9aFEefB4BQLkQRIOI6OWcTkw5Z5JMNLM5vipL9HuiqXLP1u3B6ZzKimW1UDlnqyeaGOvtVZpsLrXJuFiiXsGhfq96ggMlr5xTC6IlOQhPEwAsgyJnoiUtecxLL0G+pKWg9cD01CIwrvwXMLhZZnpAIen7tVPwvyOgkyxBNL1nYJr+gRg9fB6Ntp/c/4j81Sd/Ir/ZXYzjGwD5I4gGERGZUplojWYoy0kkWSbaRCW6nNNOPZ0zIhNNLFF70K/Dj14z0YxltYMi9fg1E2SUORFBtCTlIKF9L/lBWTMQRCvSNFK34AfHRiAs5Yla0umc+kS6X+8sxnABMpvyk+WxTzrEAiiiLEE0/X2TqZ7lxkWC0fbvtzwkP7rvEbnhzuJMIAeQL4JoEJFAJlpUOWeKTDSvlKd90KAWVeWeKgCksleWhHqi1aRWNTPRLMvvrda3TLRG8iBacNJokH5QpDL5kgR6vJ5oaTPRGuZ9yn5QVg+Uc6Zt3jxIwalb/Xp99ov+OkwbfHSM361DEM3IRCtKEM3/vux/H0Vj9uFL9rdqlsf3e4+AwdJ7oiX9DOhl6AtGS9HbPqAz1aalSK1EAOSLIBpExA9OzDeaMYMFuq+j4vU8iyvnjM5Eq1VtL4h09BGTUqtWQoMFLKOcM/Gv1VGonLPjdE7zdwnSD5DU75UkYKG2Wa3Y3u/XyNATrUiZWYMQNcW0KIK7UrSToV4yfIxMtI7lnHomWjHKHSifyY/+95k03q0/X0ULRAPd6Bd2kn4E9HKBA6NFfx9McIiHglHHOPydAlAIokFE/Ey0+ZieaEky0SZss+l7sJxzouJnqrmu6wWCJqu2F8Q7bmlNRCSUidZaRzsTLfFv1VkwENUpW0X9KC6Ipn+wphos0L5PxbJCmXydBMs5y55pox4TPxOtOL9vMDBVtIBNvzLROh346wHpBx6ZkbkCNMkmyyM/jvGaS5qJxvOF0dU0giTJXr96VgsZLuXW5CLBSFPH3EWqggCQL4JoEBG9nDMuEy3FdM72h4w6KVKLqnU0HMc46Z6s2t72Vy6fEhGJmM7pl4X2q19O8KC1U4BBHfRU48o59Z5oarBAgsuN6sDKtsOZep2MW0+0YBCtSFcDg6/Hoh1j6Qd9aXui6Q9zx+mcTTML4/7d+U/oNE9actyRMZRlIqz5Wuv3HgGDZbzPJg2i0RNtbHBRZ7QtNP1ybQAQIYiGtql2+eTBuUbkCWey6ZzmYAF1oGAFBws0XSMLbLJie9tfsXSqvT+BnmhiDaCcM81ggdbXuAELUeWc3Q6UHMf1fpeqbWtByAxBtBJ/sLuuGxosUKTfN7gvRQto6i+VtCdqiadzBnr7bd83m2o7g+Bw0pKbLCeMxjACni+MGDPjN9n7LIGV8UF7gdFWpycagACCaBARPzgRNZlTJNl0zmrFLOf0mvF7QbTWz+uO6wWaRFpBNFW+uSImE822xJvP2a+PsCzTOW2tN1vUz5uO6x1MB3uuBekHUq1yTrOnXCcLgcECZT4A109OvEy0Ah3IBM+XivZcmL160maiJeunpl6zR0xWjH/nyciG4qRlqLIEB5K+1oAiyvKapyfa+OAiwWjzyzl57gC0EESDiISDVkHJpnPGlXO2g2gVv1xRfSBVbUts2/Iz0Za1e6JFDBbwdqFPJ1jBgGHH6Zztr7ZleZl1UcvqwcFuvRP07bXKObP3RCvzB3vTCKKpTLT8gzRKuJyzWM9FLydqxoF/gumcKhhfL8Bj4HDSkpssAUyHoCdGWK/Zl2X+DEdw+jDP9ajxBwsU59gTQL4IokFEwuWTQUmmc04EMtH8cs7Wz1WQrd50vGCTWuaE5YtEROTxK5aKSHiwgGVZXjCuX8eawWymjkE01/9dojLR1LL6UIZumWh6UKJi+5loWXqilTlzQz8hV8HWIgRplOABcdEOkPXXRtoMvsTTOdsHlosmihPkbJLZlBv9+U/6mtNfXjxdGDVZ+gCSiTY+kg7pQTEtBM5rAKCa9w6gGPqRiVbRgmQiWjmnbZZzNh3XG16geii97yWnyyt3HpIzTzpKRPxgiWJ5/9e/yUZpmvPrWXWtTLToAJyZidalnFPPRLOsnnqilfkAXC8N9DPRivP7BnelaFlPehAjbTBJv3uS6Zw1lYlWgHJbM4uu9b4RlUWK/msar5uEWTkEPTHCmhkCYuYwAiIrZWa8vxXsGAHdLbQvkBeplQiAfJGJBhFpZXp1CqQlmc45EQgCxZVzNrRyThVEO3LxpJz9/xztneROVoI90VRHtP71RAuXc8YfxKoftTLiwj9XB0j6ZNNuad/6j6tGJlqCnmiBD/IyH5TpJySTheyJVuxMtCwnd1HLxgU29MEPiybs0HJ5CZXZ5r9LY8MIDiT8e3ATZj0CRZQpE037HCvSZxr6j3L10VYnEw1AAEE0eDqVdCaazlkxe3rpzfhFxGicrzK2gsEyJRjUa5VR9recM5gt0ynTxhwsEH4s1AGSEUTrclCsB9kqtqVl8iXIRGuMX0+0qm15gdoiXbUPTecs2HORtCQzctkEQTT99bqoQIMFiv68lFmv/aE4x8SocTJcrKAn2vgg03a0+T3ReO4AtBBEg6dTJlqi6ZxakMx1XS/YpbLLVJDIcSVUzhlFD+q1yihb3/etnLMRLImMP/FXm7S13my6qHLObh+26qCqNTTBMspdu+57qBS16yIjS/2ueqCxSAcy4cECOe1IjCwZEoqTIACn/92onmhFeH6CzwMnLsNjZD9m6IlGQAGjhp5o6ITpnKON6ZwAggiiwaMHrVTGj5JmOqfjmh80Xk80Levs8EJDROIz0UTCQb1+dzMKBs06BT9c8TPRoh4KdZ6oDxbodlCstleJKHftJjyds2CRmz5Sr6WJip1q+MKwBIMzRSvVaDazB9HSZqKpnmhFKE0KPg8E0YankeB1owueVPJcYdSY/c3IRIPJLOfMcUeQibpAHjz2BjC+CKLBozfzX1IzZ04kmc6pB8n0E+tgOaeIyOxCK9jUKROtpu2PbevTOftzBBLsK9YpE80//onLRGsta2SidfmwVSf5tjd4IXtPtDJ/rqvXUisTzSwZLoLQYIGCBQD0YFLaxy1JdpD+Op+qFicTjXLO/KQtbQv3r+O5wmgxs8qSfSCTiTY+GCww2uiJBiCIIBo8eibakikziJYkE03PXtODSVYg00pE5HA7iBbMeDP2p+rvjzmds+uuJBIs5+x04qb3RIvMRGuvSh9W0LWcs+n3+hKRdD3Rmsn3fdRF90Qrzu8byqIp0L6J9FZG4hgH/tH3Ua/zim3JZNUv6c5b0ctsyyxtaVs4EN3vPQIGK1sfQKZzjgvK1UcbPdEABBFEg0cvn1xamzB+lmQ6p34fvazRz0TTyjnrKTPRLEvUfM5+fYQFA1GdStDU52ZcTzR1wj5fT5+J5pVzpuiJtjBGgwXUVf1qJV1PtLl6U/71v7fJzgNzA92/opdz9pLtYJwYxvxe6rVYLVjPuuDfRJkDzUWTNqAQ+hsqwOsHSCNLEI1MtPHBdM7R5Tiu9/fJZxMAhSAaPHom2tIsmWhakEyfUqlOrPU43KzqiVaNnwha0zPRLH/5Xk6GG01HPvZfv5Ffbt+fKpvL9Uovzd9D8QYLpMlEc8xyzjQBiFAAsMQf7A0vY89OVfJ6/S+n5f/76h1yxXfuHej+BQ+Ii3aQZRy8p8x20JeN+/tQr71WzzpVbpt/VkWonJMTl6ExBgskeC1QzolR1+tE2qJ9bqC/KOccXeZxff7HNgCKodr9LhgXetAqGERLkonW6lvWytrSgzwqAGdZrXK8etP1yjknO5Rz6plxllZG2cv51c33PyIbv323nL366FDZZKdAlNqmZVleeapOHQAbgwW6lGWqE0V/8EKanmjBoQjlPShTz0srE60dpElQ8vrIzIKIiOw9vDC4nZOIKZAFO8ZqGCVD6ZZNcuCvMi4nKpY/obcAr8dwOWf++zQuzBLidPdvLcNzhdGSJatM/xwrwjAW9KbedGT7o7Oy+pgjQj9LktWNYtLPZwh2A1DIRIOn02CBJJloIn5Joh7k0RdVAaPDCQYL6JlxlvjlnL3YP1sXEZFdB+e8D0a1f50+HP2eaFZkJpr6uV5m2e3D1stE88o5U/REa4xulo3rujJXb3a/Y5t6nCq2lWo6pwruDHqaUtHLOdNmBen03y3u91Kv12rF9oaLFOGEkEy0/KRtsj7onmiO48p/P7DXmwoN9BuZaHjbN++U8z6wWbb8dm/oZ2ZW9zD3Cr3Sj8mLcIEQQDEQRINHD1otmqwYTf+TTOcU8bOp9N5gFS2Kpko+vemcHVYcl4nWS5aC2q99s3UvuLKo/Xt3HizQ3g+JDiiqD1Y9iFbvcvKoN8wXES/LKsnBdKgUdYQ+2F/zhVvlDzdukv2H64nur4JhaXtuqfsMOqBT9CmQvZyo6S/huFikCpJMpAxyDhrN6vOTuifagAOeN961U15y9c3y3m/f3df1Ago90fDbPTMiIvJA+6uuqOWcM/MNeds375SfPRAO/KFFP94uwgVCAMVAEA0ePWg1WbGNAFfyTDSVTRUu5xQRqVTMTLSJhEE0Wyuj7OUjTPVq2z9b975XwcNOH45eTzQr+rFQB0XzGTLRvHLOMemJduvWR2Xf4br89pHwgWYUr5zTtrWS1+SPUbD0td/CwZpiPRe9BNGSHPibmWjhv/+8UCKYn14HC7h9/hvasW9WRES2t78C/ZYtiMZ0zjJRx5BRF1DNC1LF+Sz6r3t3y2d+/IB86Lv35b0rhaVfHB+lY20Ag0UQDR49E602UZEJLYiVpCeaiB8U0z909JhT1SvnVIMFkpZz9qcnmupZ5roie9s9s5Jlopmll0HNiCBatytWKkCh5jF4AaIEAYgFrQ+Vvv1R4GeIJTtp8DL2jOmc3ZdVj3/S7WRV9MmCjV6CaEkGC6hMwUqxMtGKniGYh7l6Ux5MGLzuRdrX3KCHc6jPo7k6gQoMhv6ZlKknGu9PI0+9BqLev5K0RsiDuqA9S6l7LLMnGp8hAFoIosGj90SrVbNloqkghwomtcow/WVVz7QkPdFCmWjt73vJ9NGDXOr72oSaKJignNOyxI7YZXVQZATRunzYqsyYipUlE611n6kEAcCiqXu9ypLts7p/2p5o6mpw0u1kFRwQUbSMJ7MnWvJ9S1pipx7fCdvviTboxzyJoveqy8PffeV2efr7N8u9Ow8OdDtpTxiDd+n3n5B6D9EHvwD9ZGaipbtAJEKZWBmoz9eoz7+ilnM2Uh6PjSN6ogGIQhANniltOmetahsBrtSZaCrwEQi+VVJkotW0TDTRyih7KueMyERQv3enAxt1/NOtnDNN2newnNObPJkkQBQoRR2lLJt6yob/6nebsO1Uj5FXWjHgTLRgb7uiBWuSZJNFSTrdUgUrzUy0/K/WBv8m+l0iOIp+s/uQiIhsfeTwQLfTSDnNLDJzo4/vaQvN8EUOoJ/09/2kHzn0RCuXekz2u+u6xoWCIh0j1FVlQAE+s4uK6ZwAohBEg8co56xWsvVEq5iZaMHlVPnhI+1SymVTE/H7Y2SiaWWhPWWihTMRphJlorV+ZsUE0dRB0UKacs6Ynmhp+n2pfR+lD3avzDLhQVtde5y8bL0EV02HNp2zvX/q76Voz0XWbIdQiV1sOWc7yFmx/Z6IBXgMwmW2Oe1IBwfn6kPtHzfbnoo76BMm/elP8pqLCu72M7tWPcZppgIDaZilmUkvEFEmVibqmCN4LFnk/pzePpOJFmuBwQIAIhBEg6eml3NOmJloUSWMUVRA6NBcI7RO/ee7D8yLiMjRR0x22B+tJ5pRzplsX6JEZSIsmuyezeUPFrAkKp7o90Rrhm6L09TWKeIHIJN8SKsPdZVFV7TATRzXdTuWPERpaplOaaZz+ldYB13O2fqqeggWrbTWzJBIU87Z+d9KQ+vPp8o5mwU40Cx6T7SDc3V5ynu+K3/1yZ8ObZtqKvKgS3eMhukZyjmTLpeUytwlEw2DwnRO+Mc25vtM0gtSeRhWxv4oW0gxMAzA+CCIBo9ezjlZCZRzJsxEm2hH2w7O1UVEZPFkxfx5+yT74HwryHbU4vhMtFooE02Vc/Y5Ey1BIMroiRaViRZRztntoCQ+E637wYxatxcALNBBmXLHQ/vk5Z/8qdy5Y793WyNDVpS6X9VOVy7oZaIN+MRZPfb+vg10c6npj3Oa10nSZu8qWFm1ba2vX/4PQujqf8H+Rnbsm5MDcw256+EDQ9um6kU56OcnbUAh6j79fLq8nmgMFsCAZOk92cvkZBRPPSarK/h2W6RjhIWY7Dn49GP5IhzbACgGgmjwhDLRKul7oqlsqoPtTLRFE2YQLbieoxZ3yETTgmiWWImnc37ghnvkeR/6odd3TRc1nc3rK5ZoOmfrvyD1GTvf4YqV47iR/amCPdGSlMJ5gwUS9HPbP1uXX27fH/vzQfn6bTvkh/ftkf+842HvtiwHIw0v2GinykTzx80P9uBQZSlOjEA5Z5p9SxqEMqZzFmqwQPDf+e+TLm1vwF65ruuVc9Ybg30s0gYUHO9vyArd1g9+TzTKOTEYWRrHk4lWLv4xR+dMtCL15/SnmBdnn4rGPG7lcQLQQhANnmBPtAm9J1riIJqZibZosmr+PBhES1zO2QqkiXQfLPAft22XX2zfL7/cHs7wiCrnUcHDTiVo6nPTjslEUyd8cZloTceVP/uXH8gLr/qRdwClDlq8TLRK+p5oSSaL/v21t8tzP/TDoWa8iIgsNFsnrOZj4u/nQsIMMfW7tcoF00znHE6ZQtMxAwBFC9boB/BpDpSDB/pxv1fdK+e0U/X1G7Sil3PGZS0Min4BIXiS10+O4xoBzCQBBcfL5vQ/c/r5fPk90cgiwGCYPdHIRBtH6sJg8D29yJ9FDWe4F3NG0YJ20akIrSoAFANBNHj0zK/QdM6kgwXaJ9EHvEw08yVWrZj/TpyJpmWAdQtSqGyDqEy0+YjG0kky0UTLRIvilXPGTPHZsW9W7p4+KL/Yvl9m2iVVXiaapTLRUvREC0zn7PSYPPToYW8fhklluxhX8TJc0WuqSa+25Z1kpxksMMgghev6AYPRyERLfqCc9MC/rpfbtgOJRTggV3/PKqO2aMFNb5Kb4w4lM2FWe+8b5N9E8H00WSZa62vVyETr3z555ZyNZqGyQFAemXqi6YE3Ts5HXqfpnLoitd/QP4cQjUw0AFEIosETms5p9CRLF0RT5ZyLA5lowXLOIzv2RPP3x2jo3+UzTGWbqf4/UT/T93ciQfZM0p5oermQXka4rR3IEvEnxKnPZZXlN5GlJ9pE935u9Zwax9YjrnCaPdHSZaJVbX+wQLJsvXBgs9/0Y+FqQYM1+uM8iJ5o3mCBajEz0Sa87MU89yZMf16GUf6qX1QY5HtBlkl0/nPlf+b0c4Kd+n0dl5MgDEaW0kymc5aL14d1BKdzFuHCV1EFq0oAQIQgGjRGEC3jdM6JQDnn1ERwsIAfgFo6VTVOmsL7o/dE0wcLdKYCZTPzEZlogZ441YrlBbE6B9FaP7Os6MciarCAvr6HHvWzwLwgWigTLUNPNFWK2uH4R+3TwpCvdHtBLC0Vvp4hcOAF0Sq2P8E0SU80r7RigAEDLdA0maLUdJj03UkTQAhN54xZ1Cu31TIFB92HLgkvMFPQqakLRnB58Ccws9pFhUEG7YKv/zQ90fSLLH3tiaa9B81FZCMDvdJfr/REG0/eRPBRms45pLYXo4zBAgCiEESDRw9aTVYCgwUSZqJVAuWcwemcFS0C1amUU8TMRLO0TLROB6iu63pBo9mIk6VgJlrSPk7deqKpg6LgYAGVxm8G0Rzj9wj1REtwgqs+1L1S1A4f7F4D8wFPqQxttxG+wlk3+sYkzERTjetTT+dsbctxBxfY0k+cilrOqT/Oafp5BA/043ui+UHOSiX58zNI+nuECuwV6eq/iFm+NehG/yLBcs7BPT/BYECS14K6S0V7n+/niab+HhTVFxPoVaZWBfREK5W4FhKhC1IFegsadm/OUaRfgHbc4h1LAMgHQTR4pqqBTLQM0zknvOmc7cECgUw0fbBAp6ECah8UO+FgAT27Y2Y+IogWaCw9WbETZaK5Wk80K2qwQEQmmoh/MP1QRDlnIxBESzN5MlTO2WERf4T5cI/cohrWZilh8zPRLC8Im+YxCn7fT/pDWi3oYAF9HzsFJr740wflf37sZtk/W28vl7Kcs2LJRIqedYMUmSFYsOfFeH0O4W9TL28fZKZg+HWTYBktE01dpOjn00UQDYOWpfckmWjloQ9UCZVzJmyNkIfGkHtzjqLgcX3RjiUA5IMgGjx60ErviWbFBI6iqKwP1RNt0WR8EO3oDv3QRMygnp6J1unzSz9Bmo0aLBAo59Qz0TodxDpeEM2KHC6gPlRDQbRmOBNN7UMoEy1FlpXajppg2unKWD2ncs6FiF5seuAsaWBLHXBW7XQ9t/Tnc2BBtMhMtIFsKjMjE63D4/blLVtly2/3yn8/sFdEwsHA2Ew07flJEwgeJP33VOWcRTpxETFPtIZRSlPkTLSmVi6vsp4HMZ1TJHq4DNCrbD3RyEQrC/1CSPD9NXRhoUBBGJrmdxf8fM77IiGAYiCIBo+RiVa1vaBA0lJOET8bx8tECwbRtJ5oXcs5J/wgnkiy6Zx6EGsmyWCBiuX9fp3Wq34UHCzglR55gwWCmWitf2/Xg2jtbLimFpgT8YNoSbJEFrxyzu4BAm+wQE7lnAsxJZxJD0TU/le0wQKJeqI1028rrWZUEK1AB8j69FCRzo/bQqD8Nvl0zna5bcXyMlEHGaRJIiq4WaCnRUTMv8dhHJSbPdGGN1ggyd+qq2WiWQne59PS34Pm6gWLcqMU6Ik23ozy/Gbnz84iZXzpx5sEh6IFj53piwZAhCAaNOZ0Tn+wQNLJnCJ+IEh9Li8OlXNqPdG6lXOqTLj2vy3pvh96EOtwZCZauJxTlQgmm84pRiZasA9WKIjWdKXedOTh/VpPtEbTWEZVzVbUuhL1RGvdRwU+4/bddV0v4DbsxrFeOaf2mGQpYVOZLNWKlSoTLUvWW1r6yZIKIBWpX0aaqWD+NNPW13AmWvTBv1/OWcxMtCJNDNXpB+KDnCCrDG2wQIYm2lE9J/t5nqK/BwWzkYF+YDrneGvEXCwUKXo553DbCoyi4PFjkZ6/MrnxVzvldV+6VQ60kzCAoiOIBs/UhC2nP3a5nHLcEjly8aQfREvxKqkGpm12Kuc8qks553FLp+TEIxfJ75+4XEREK+dMlol2eKEpruvKqz9/i/zjv98hIuFSntaJf+v7JNM59d5sIiK1UBDNXH/DcWV6/5yRDaQyIfwgmpmJ1u0AvOm43rLq8Y07UR1GSWOcbuWcSa96ej3RtEw0fWhDHDNgN5iDHn21RRwsEHwtJcpEa6jXZ+t2PWgc9ZCr53SiYnmPQd5XtPVzAfU+VqQMQZFAhuYQHq/DejnnAE+WghcBklwUUH8ztuW/H/YzE42eaBgkx3GN98aknwGNIb8HYHDqHbLsg8cqRTpGyHJMNm6CrVDyvkhYVp/4wf3yrTselh/9ek/euwIkUs17B1AclmXJf7z2KeK6rlRsy8sES1POOVEx7xsMoukDCrplok1Wbdn0xqd7wSW1ZKfPLz2INTPflOkDc3L9ndMiInL5C07zTqCW1KpyaL4hE1UrUSaaq5Ve6g/HZNUWmfdP+MKDBRzZpg0VEPEHC/hBtNb2k/ZE008Iu5VzLjSiA1jDEDWds5EhO6zR9B8nPZOx6bhGeXBoOT2AOKAT56iMp24n/9/+xcPyzm/dJf/yl0+WM086aiD7FbV/Uf/W1QMZi14vuortvY6arit2ICNUBWQK1RMtopyzSBmCIsEhG8PIRPMzcwd5spQtEy38/sp0ToyKNBcrdPREK49OxzbBt/ciPdWNDr3c0EIm2nCoJIc5ssUxIshEg6FiW142mQqI2VGd9DssrwtN59Qy1br1RBNplZiqZdRwA7fDfE49aDRbb8iBWf/E8fBCwzuBWrGsJiJpMtHE2we9vFXPPtJLJ5VG0zWGCoj4mWjeRLr26lRAqNsBuBFEa5dzxjZ9H/KJuk4dnOlX8fSrtWmnc07YllS0oFmax2lQmTf61NYkU15FRDbdvUu275uVHw7haluaMpJgEE29pvQpvVHLN4xMNPUazvdgXN/PSqDEvCiG/bc5uzCcgHrwIkCSEw61iN73sJ99g/TPhTkGC6DPgp+/SU+yjX5URXuDQiqdGvSnuZg1bEbwr0D7VSShwQI8TgOhzhWCyQhAURFEQyx18hwMjHVSDdR+Lu5Yztk9iKZLO51zZr7pDTgQEdl32P9+xbIpERGZsLWeaJ0GC4geLPFvn6i2Aydu68Q0uIqGExVEMzPRVPBF7Ue3LBH9BFj1sYtbZiHHIFo9qpyzkf6qp7pfReuJJtL9QFR/TBYagznoUa+Ziu0HV7tl0MxHZOgNSqi0LkNPND27NCpYq5ar6v0F8y7n1J6XSsLnZdiMMpohHJQfrvsXFAb52suSlaOeL/0iRT93UQ/kk4mGfusWNInTTDg5GcWnP3+h6ZwZsnOHxawU4L0xSigTjbLXgVCPM0E0jAqCaIg12c5y6qWccyqUiaaXc3buiRakepF1LOfUJq/NLjTl4Jx/4rj38IL3vRdEq1peJlink72oxtciZqmYHrBSGXhNx5GHguWcarCAl4lm9kTrdjCtPmgqtt+DKj4TzY38fhiC0x5FsjZfbgdptCyVJMsbZQoDyoxS+2ZZ2pTXLvu10H7+h9FMPhzQiN9mcACF+t0mumWieeWcljZhthiZaBXL8oLexSvnHHy5sW5uYUg90VIMs/CW8YKe/iCbgfVEIxMNfRY8qU762ZalvQGKyTzeiA6qelnRBfosiutZC1/wwkvexzdlpc4Zgj3ogKIiiIZYKiBmpZnOWQlmoplt9/RMoqNTZqL5i3Yo52xqPdEWGsaUl72H/CDasUu1cs4EPZNUaZEl5uOhsvUajmucnKkMPD0TbfmiVtDQGyzgZfAEBwt0/oBWHzQTFT9AkKQn2jCCNrqu0zmTZqJ5QTTbCOh2u2oaN53z9m375AM33NOXsi51nt8K1iTLoFEHZMO42hYuM4q+n+u6fjlnwyzn1INoUS9NtdxExfZey3lnVfhZnqJlNnXepx/ft0f+8N2bZNNdOwe+fyLDGXyhOzys6ZwZMtH0npPqfb6fryH9sZ7jKjf6LDSNMfHkaXqilUWnBv3NQFZ3kTLRzAubvDdGCX5e8rc6GGSiYdQQREMsNdWukuJVUk3RE+3IQZRzaploh2My0WpVW45sTwadqPiBmY6ZaGpSoW0Z0wrV8AU9Ey04pXB7O4h2ynFL2vtoZqKpk/ykAYgFLWjRrVQtz1T9YHlgax/SX3n3Mp0qlvH4dy/njL7C+s/fuUc+/L37ZPM9uxNtvxNzqmDrtm4ZNFEZeoMSviIevc2mNl3Oz0Rr/buauJzT8sq5W6XN+R1oOlqWZ9Jpj9//9R6ZPjDXl9dFEkZ/wCEcNBrTOYdYzpnkhEPtjmXpPdH6t09FzUS76Vc75Rkf2Cy3bX00711BD8K9J5MtlyUzG8Vk9hYLlHN6fV1bn4+u29+ej71gOmd3wc9nHqfBIIiGUZN7EO2qq66S1atXy9TUlJxzzjmyZcuW2Pveeeed8ud//ueyevVqsSxLrrzyyuHt6BjKMp0z2BMtOJ1TBdmW1KpekC4pK0GZj55tdTiQifbojB9EO/nYVkDrxCMX+VMVO5ZzqrI9MWYTeoMFXNd745/UMnIajit729tdddQiEfEzkZxAin9FC0B0cni+dRK4pFb1li3ydM64ssqkByLqflVviqmf/ddx+/p0Tu11oXrjHZpvhJZJy5sqqPXe6hasGWYmWtIyI/21EeyJZvShi/jdGnommq0H3DLudB/o/QaTPi8LQ3xeRETqDf0EerjlnIN8Lwi+jyYaLKANWUnaWzCpVpalv64i9UT7zq+m5bd7ZuS/7h1O4BaDEW4cTybauKl3OLZRT615QWoou9XVsKdEjyKmcw7HMC8wA/2QaxDt2muvlQ0bNshll10mt956q5xxxhly/vnny65duyLvf/jwYXnc4x4n73nPe2TlypVD3tvxo4JcaaZzVgM90YJBNBX0SdsPTSR9Jtpc3ZH9s1o5p8pEm6jIM5+4Qr722j+SNz37Cd7v12tPNHVyVpuo+KWZTUfm2z2w/HLOmEy0hD3RZhZawZ/Fk5WuQTT9w2jY5Zz1iHJOc1Jn+p5oIskz9hrN6IPamXbwrB/BEr2BfdLpnMM8UAgGIuICSVEDKPQgr3oLiAo0e9NTK5bx9z/MA6Gfb9snf/7RH8stD7YyevTnxUrYqH5+iL3qRMzA2TB6gJjlnMXKRFOvK1vvYdenIFowYFikINqwA7cYjGDQJHFPNDLRSqNhZHRFB1269RfNA6/B7oLHBJS9DoZfvcLji9GQaxDtiiuukIsvvljWrVsnp556qlx99dWyePFiueaaayLv/wd/8Afy/ve/X1760pdKrVYb8t6On4lM0znN+y4OlHOqdaadzCniDxbo9DGvToSVXQfmve/1TDTbtuR//M5RsmjSD3h1OmnTp3MaPdGqcZlordtn600vABcKorU/J/xMtGQ90Q63g2hHaJlocVl0RibakE/U/Omc0QeXSUvK6lowR//aufzWNa706h/KKgi50Oi9rEsPruqltY2mE1uu4TdPHUIQLfBaip3iGtG3Tg/yesHayHJONVjANjJRh3mScN0vH5ZbHnxU/vOOHe1tt25vlXO296domWhDLrWe1cs5B/jchLNykmSitb7a2pTbfjXfDgYMi1TOqd4DCKKNtiyv+db9nMjvMXqMjK7gcJWo/qKFKefM7xhxVJCJNhyUc2LU5BZEW1hYkFtuuUXWrl3r74xty9q1a+Xmm2/u23bm5+flwIEDxn9I5ohaayjAVLXS5Z6+4GCB2Ey0LEG0JJlogTff6f1z3vd7Z1pZabVAGamXidYhG8TVgiV6nFDvfaYCeLUJv6xtRisZXBYcLKBNNWytK2EmWrucc/FkpWvpU1xz/UFzHNf7PRa0gFIjQ/+NptYTTUTP2Iv/fYI9SfRtqXLYfgSxmk440HRoriFPfe/35FWfvyVyGS/jqTH4A7GkWUFRAx/0iWKdmvOrxzaYiTbMviEqA1X9/RvlnF6PrS5BtKa5jkEb9t/m7MJweqJlGSzglUVbopXf9md/QkG0Ah2gU75SDuGeaGSijRs9cBaXiaa3MClKIKaRoTpg3ASzmflb7T/Hcb3HlUw0jIrcgmh79uyRZrMpK1asMG5fsWKFTE9P9207GzdulOXLl3v/rVq1qm/rLrszHnukvOrpj5M3/enjEy8zoZ1EW1Y4YHX0Ea3g2WPb/cHSsL0gWvwHWPAEaecBPYjWykqrVaP7tHXKVNGvGurlnN5gAdcv59R7oqmAl4jIsql2EK1hZqLZXoZVwp5oKhNt0uyJdsuDe+Xsd93kZeO01qX3IxveB38oiNXedt0oYUuYiRboiVZJ0BMtGMBRj4Prul4mWj/6QumDBdTz+Otdh2T6wJz85P5HIpcZajlnMIiWYACFCu45Wiaaes1HLW5momlBtCFmVgT7zOmDBZJO5xxmhqBIMHA5hHLOuh/QH+Z0ziQZNmb5rXlbr4LPZzBbOU/zQ37NYTCyZ6K5kd9j9MS1jxAJT+fUb8ub2aeW96EowWM1Bgv0n3FuUKALXUAn1bx3YNAuueQS2bBhg/fvAwcOEEhLqGJbcsmfPjHVMno516KJilH6KCLy/DNOkFrVlqeeckzq/UlSzhl88502gmiqJ1ogEy3BSbbRE01bXM8e88o5q7YX6FEBm1rVlql2Vp4q59RP9EVS9ERTmWi1qrHMj+57RHYdnJfv3b1bnnv6CSJinpwN84MpeJJebzoyUbEzNVPXM6JEROs3lz6INt9wvOeyHxkp6ji4ojWwP9SeCBu3/qEOFughE02fSNup954+nVNNV2xqVxWHIViKmTSLLnodwwmydOqhMwizC8NpIB3KfkzwMnAiSof7V85prmeuXpwDdPWa098rXNcNfW6i2DL3RGMyYmkYmcVx0zn1cs6CBE3zHD41KoLHavRE6z9juBVBNIyI3IJoxxxzjFQqFdm5c6dx+86dO/s6NKBWq9E/bYj0TJTFk+Ey0KmJirxgzYmZ1m1lyETTm2nv1Xqi6bo15xcxy42ieqLpmWi1qu2duKuAV61qy1T7vn45p19ypu9HtwNwPxOtYjSzVxkWeqZFVHBkGIK9NeoNV2Qy43ROrXG9SLLnK3gQqz6g9Ymc/fig1vuGqefi4HyrbFiVsQZPiIeZiRZ8LcX3RAuXFja9IK+fBRo5nbP9WOs9FIcdRPNLZAP93Gz/9dJ1OueQ+3EsDDkTbXbBf+0Ptyda98fTy8rVMgf7Vs4ZeD6LlIkWfM299/q75Zu375Bvrn+KPGYJxy2jgkw0dDq2GZ3BAgQvogQzhYvy3JVJvZHPuQrQi9zKOScnJ+XMM8+UTZs2ebc5jiObNm2Sc889N6/dQo/0nkhTE8l7qSVhJTi56nSCdGBOZYXFlHN2WLHr+gGvqOmc4Uw0sydabaLiPR4qE00dvKgMJj+rrfMHyCGvJ1rVb2bvuF5fKD3TIq+rjMEgljoIydIHSmXpeJlole7BxnBmQGsdh7Xy2n5O57Rt/3k82H6duW70Yz7MEq7g1e64QFJ0JpqfzdUpO8jvidb6W5jQJtMOS7AU09H+tpIGZYZdWmc2oh7sNl3XNQYLDPIgNdQTLcH7jn6Rolufx7TCgwWKc4AezKC86Vc7Zfu+WfnF9v157hZSoicajKxCxzUu9qr3N/0ic1GebrIhu1OfIerp42+1/+o5Vc0Avci1nHPDhg1y0UUXyVlnnSVnn322XHnllTIzMyPr1q0TEZELL7xQTjzxRNm4caOItIYR/OpXv/K+3759u9x+++2yZMkSOeWUU3L7PeDTBwtEZaL1Qh1+pCnnjDIVLOdMFERr74NliZ5XpAfRvJ5o1Yp3Eq8yn2pV2wuiqfup+1S9DCt/SEEn/nTOijE1cd4rDSpAJlpMOWUjQ/ZN8Cpuoky0wO+qXhczWjbOQrMP0zm1YI166asgmkjrudCbCbuuO9SMp1AmWoJyzoX285J4Omdg8EPSjMp+Cj6m5mABMW6LXYf6+xlSkMUIKA94yIRexiwy2JOl4GskSW8zPWCryuUH1xOtOAfowazUYZZ6o3+CF76Yzjl+Qn2zHNe7MGpM8W5nahdmOqeTzzHiKFGfz4smKjKz0CQTbQD0z2V6hGJU5BpEu+CCC2T37t1y6aWXyvT0tKxZs0auv/56b9jA1q1bxdYaUO3YsUOe/OQne//+wAc+IB/4wAfk6U9/umzevHnYu48I+pW2RX3PRGt9TVPOGSUuE63TQY2ZKeHfrgIkeiZarWr7QRsjiNa673w7I0QPUuj70S34oEpEj6hVtQyh6CDAQobMr34IlXOqIFqHCVZxGtoJtoj+OMUvHxc8OrzQ33JOs1deOLgX3MawDxSSlhkZpYXBQFSX5vxeJlr7vVqfWDssC4EAsl+KqmWiFXiwwKDLaObqZsB4sJlo4ZPJbtRdLMvvLTi4nmgFLOdsmq/fIgX60F1c5nPX5chEK42o1gnqENi/qNM6fmxK8kDrIDUd1xgWxGswmvq8XDTZCqLxOPUfmWgYRbkPFli/fr2sX78+8mfBwNjq1as7BlCQPyOI1udMtE4TApUkb77BnmhqvZ0+GL2TPDHLOSdVJprreg3JJ6u29zpVPdlqVa2cM5CJpjJlkmRYtdbp90QzM9EieqLlVM4ZPImoN8MBiqTj1FWwTb22VMZep8cpGKCre0HN/pZzGhlPEc3AgyfDC0PODAyV1sWc3EWV2epDEzpP5wxmVHYPcvZbMIPHGCyQYPquyPB7opnZf4Pdpt4bMrjtfgsGFJIEw5raRYokZftphMo5C3SAHiznDH7FaKAnGkLHHI4ji6R1zKdPH259lrqFeL7DUyeL+76z5bd75fpfTsv/Pv/xfT+36EZ9PqtjeLJG+88YLFDg1yGgy60nGspJb5w6sEy0DgWdSZpGB6dzqpP/Tid7bsRJnog2WMARY7CACiR45ZwTtkxVzZ5ooUy0SrLgw8yC3xNNzxBS2zd6ouVUzrkQKE9T/zbHwKe7Wq9KhZNk7MWVkxqZaAm2v/vgvKz/0q3yk/sfify5PmG1YncPoulZgoMu4RMJn5jFvbTqERlyZklkp+mcrfur0pV8M9HCQbRKwqDMsAMYZlbmYB+rYBBtkFfS1d/ERILehYprnGS2buvXSWahBwsEXnPzga8YDaGeaAkv9pKJNrr2H64bF/WDxxz6e7qe1Z100M0wBF9zRZ7OecWN98g1P/qt/Ne9u4e+bS8TrX1OQ++4/iMTDaOIIBr6Sh8ssHiyv4mOXk+0BJlowb5numA5Z5pMtFZpm3/7hJGJ5gfRVMBHBW2mqhUveDdXb4rruhFlimrSZ+eA3uH5cE80EfEah8dnog2zJ1pMOWeGJrbqfn4mWjug02H5UCac16MuXSba1259SP7zjoflUz/8beTP1YGwpTVE1wW3sTDE7CMR/zWtgr3xmWjhAxhjOqfqKxY1ndPLFDR71g21J1pwsIAWlOk0FCFyHcOazqltZ9AZAMESxkGeBHivuUr3jFFF3cfSTjL7lXU+Cj3RgpmUCwUK9KG7pFOQg0YhE40T2rD/fmCvPPkd35GN377buy342aq/p0dd1CnC8x383CnydM5HDi2IiN8iZZhUcFH1eSbg3X95XfAHekEQDX2lB3UGN52zUyZa6833qMWT2nLmfYLlnFHTObc+clj+47aH5K6HDxhNYIPBEn+ipjZYoGJ761RBGz0TzXFbH8reYIFAcEik84e0nommL6OyTfRMtLyu7sSVc+olnEmDSPE90VJkojXCmWhJTqbveviAiLSuOkcxDo4jM9HMk2FjWuoQng+1f7UuAY2oAxgn4sA/KhClntOJ9t+Vl1E5xAMh9Tj75Zyt223L8v7+u2WHeOXQw5rOafwtDCcTbWmt2t6eM7DWCN5rzit96b4ddZeKZXnv8/2bzmkGkovUE0291upNR5qOf2GlSIE+dBe8oJPkNe+6biiIVrR2JfftOihnvP078v4b7u5+5zFy1/RBcVyR//z5Du85Cx1zaM+tnrFuFygTLXgMVuRMtP2zrWOwYb83Nh3/71Sd0xBE6z+jGoLPP4yI3HuioVwmBjmd0xssEH8fPYj28P45ERE5ZklNdh+c9+4TzESLKlX7f79ym/x82z4REXncsUfIymVTIqIayPvL6gE5dXJWm6hItR080wcL6GWkc42mUS4nYvaT63QQPhOXibYQzkTTT86HmxkUKOdUJ4t69k3KCWYTgZ5baXqiqW2l7Yl218MHRUTkwFx0EE29FvXBArpQOaf23AwjWOMHNGw5OB//mJk90Vrf6+XGnSbYqsd6IvA6HuaV9mAWWWQ5Z4pMNNd1jbLtQTAGCwz4taCyVJctmpCD7fePpuMamcP9oh77NJloerl80vLbpNTzurRWlUcaC4UJULla9vJC0zHejziJGC3Bz7Ikr/moz79B/U1mdcdD+2W23pSf/fbRvHelUNRwqB3752Tb3ln5nccsDg+XMDLRWl/N1gjD2ddOwvtc3OCQH0Qb7kUQ/XNa9WJrFuHJKxmjJxqffxgRZKKhrwY5WMBqF3R2+phXb75HHTHh3aYCYEqwJ5renF/5za5D3vf3756RbY8ebu1DTE80EZHD7QMrPRPND6JVpFa1vUDgXL1pXJ3U90Okc1q9yqZaPFk1mtmr242eaIUp52z9rvrvlfTKuzqwUwMFkvSOC56gqCBemp5o842m/GZ363WgDuCCug0WCJVzBp6PQWceqMdIBTTiApf1qEw0o4Q5OrDhOK53m9+zrvU16eCIfvCnGwbKOVP0oDGz8Qa/7w0jcDngIFr7db90yr9uNqiguhdEq3Z+zUUtY9v+RYr+TedsB9Hav7velzBPwZMGI8DOScRICfYBTJJFGXlBomAZLl6fVcqLDXo268337xGRcLN5/e9bH5zSadL1sGWdKjtsc/Vmbv0i9eMCyjkHxxy0xOOL0UAQDX1V1dK0BjZYoGM5Z+vg5kitnHNFMIhWjQmieX2zGt5AAPWhebidwWRbluihEj3zbs6bxGl7gZ6ZBT8TzbIsb9vzdcf7IFZZPvq6OmeitbZzxGTVyIrTM9H8EgMzMDCscpFQOWdDlS0FSh4SfFh6gwUC0zk7XTWNmzqVJhPtvl2HvG0fiAui6Rk0Ee+mwaum+gGg6w7+YEyd3KmARnwmWsJyzsDrp649z1VvsID6expmOWd0Jppti5ZFF7+847hDnw6VZVJtVqqcc9ki/+LCoAJ3wT58aco5zYBtfx4T9TgvaQfR5rT3xzwZ/REbjvHeUKThB+gu2AcwSUZPXCZakaiMq6IEnotC/1v9yf17RST8Hq4/l/rgFHWcUIRyznqHwJ/yg1/vlsu+8ctcy+D1469hvxb16gnVkqVof6dlYH4e8vmH0UAQDX2llyL0OxPN9oJo8ffxMtEW+yeLRx8xYWSMdSvn3HWgVQa6pFaVY5bURMQ/CQ33RPPX6wXMJvxMNJUVprLfVE+Fubpfzqnuq1cDxgWXmo7rlWYtrlWMoKXKhFM911rryafnRbCc0xssEGy+myDQ4j1OKkiTqJwzOlinN6XtFkRTpZwirT50USV3rt7rJCITLXjAF9zmoDOQ1ONQ63LwF1VKZmYHRT/m+uM8ERgsMMz+KvNaWZyIOVhA/V11OmkJBs2GUU6gv54G3R/PK+fUM9EG9PxkKed0Iv6O+jadUwXR2v3gXHe4r804wb85yjlHl7pgkKYPYNRgnKKV0/nZP5zU6oxMtN880hoUFTNMScScztnviwS9CB8nhd93PnjjvfLZmx+Um38TPaF8GPR2GsMv5/SP0ye6ZPQjOzMTjc+/ohhmb+NRRBANfTVhTOccfjln1GCBpVMTcoS2L6FMtMBJ284Drf5pxy2reVM+1Ulo3HROEZGDc36ZZTWQlqSCGOpK1lzdMU70RVplot36Sc1qB29LalVjX1Sgr/U4tBut5zR9KRS8c1RQL3DQ1uh+MKKulla8TLTugwXiBhvMaOWc3QJYd7eHCijq+dXpvU4ip3OGJgOaB4BJfv9eBEvrkg0WaN3HD2z4WXbBMiX9MVRBzmqK4Ek/6L2lVBNg/aQlLotOl08Qzd+fQR+UqyzVI2pVL6N3UAFcvQ+fSLLSNscL2Io2nbM/+6MClEtq/oWVIgQFglnCgyrnnF1o5jLRbpz4FyuSn2RHfRYXrZxOXQScIxPNoD8e0wfm5MFHDoeObfTXgN6js0jlnHEZ+zpVlXEwx/cQvZ3GsMs51WM0UbGlUinOc1c2ZqsTHt8i+NYdD8tpb7tBbvzVzrx3pbAIoqGv9Myofk/nlAQZJdFBtKocUfMzMGJ7oqlMtIOtTLQVS6dCJam2Nj1OxAzI+UG0itEbTr+fCsrN64MFtPX5AaLoA4XD7QMZ2/JLRNWm9A8hdZCXJWjVD/HlnMHgWucDIsdxvZPpiUBPtE7lguGyUdUTLXk5513TZhAtariAY5Rzps9Em28O9mS+GSjnjO2Jpr0u1GMV1e8t2KdKf5zVa77qZaINK2Br7tNCwzFPWhJkLnbqXTcowxzpPutN9K14gf9BlZAGS9sSZeV404/997N+T+dcUvPfy4vQc8zIPGs6sb0se+E4rvzp//m+rL3iv4baE3PcBMvmk2QZmYEV87ai8CYWFyDoXCTBx+Mn9z8SzrLX/t6y9OgchuDxQNRngtcXL8dyTjOINtz9WPCCaP5FbrJz+i+YuVm098Jx9JP7H5G5uiM/e2Bv3rtSWATR0Fd6IKHfmWgq2JSonFMbLLBsakKOmNSCaF3KOXe2yzlXLKuFAoF6Y1gRMxNN76MWnLDlZaJNaJlojrl9fX1xHyAzKqNksuoF8yKDNyoTLXDAMaw06WCwzivnTDkNSg+yVbzpnN2v9ocPaCPKOTs8Fq7rGuWcItHDBYyywQ7Pg//v4ZbXellBWrA3qmG7MSnSccVxXGM6p+Vlc5nLNbTJqeo+w85Ei8oiM05akmSiBYNoAw5uipiv30EHOFSp99RExSuHHtSJgHp9eYHbBNtRD0VlAOVO6vUxWbW9v4M8TwiV4HuB/t7UryDfbL0pDzxyWB7ePxc7HAW9C/dE6/78NbQgWjXBZ1oe8mrmXnQq4K2Oce/ccSC2hYRIcadzJslEU++VhQmiDbsnmvf5UUlUBYFsgsMEaGmQvyL87RcdQTT0lR5U6vtggfbXzuWc4cECS6eqsrgWX87plVC6ZjnnimVTob5urZ5o/r9t2//3wXam0qLJqhfoUVQGmn4SpwIQUZloccEVdaKl/z5RQbTYTLQhHbkFAxtqu+EebZ33Rw/EBDOdOgVpgkG8hYhMtE4nBrsPzsvemQWxLZHVj1ksIiIHZsPlDI4WaIqazhncRvDfgz5QUAf2ek/AqAPAqAxBVwtsBAPNwfXrGaj+1drhHGjO14OByqZZZpshE23QJ41O4ErroB8rPRNNBTkHFcBteIHb1ntUkvMNr5xTu0jR7+mcehCtCEGB4GtOLxfvZxDN+36BA+FBCZUwp5hIW7Xj31/zpk6eivD3UiTqcdF75obLOaMz0YqUdRgOooX3yS/pzTGIdjjHcs6GCpB3b7eC7IJ9YemLlr+5AmShFh1BNPTVIAcLBKdzuq4r2/fNev/WJ+yFe6LpmWjmy14/yXZd18tEO25ZuJzTssyMIz3AoE6Cjpj0sz2C21SNh+caTVHHK3rpZ7cPaRVE03+f6OBN600vbdCqX4JXNNVVpmAAp9sVvYYRRDMb13daNlgm6mWiLSQbLHDvzkMiIrL6mCPkuKWt6a5R5ZxesMbyp27pugXRBv18eGVGXSa/hoOebnQ5Z0xPNP3vvjrkq7XhvnOOFxA3M5uSr2PQwc3wVLThlHMumqh4fSsH1xOttV6/P1SSTDTttWZ3f77S0HvaqPffIkwbDL7mDhmZaP05aNUDZxwID05wgEuynmh6JloxM1zU51XTcSkH1qjH5cj2ACv9oqjSMDLRot7f8n+uQ9lzEa8/Pxslv+d//2z/3xuT8so5q3aiKghkE3x/IRMtf0X42y86gmjoKz0g1O9MtGA55xd/ulWe8p7vyhd+ulVEzJMSfTrnsqmqUVpaC+yXvs+OK7LLy0SrRfdE05et+Cfp6sBq0WTFKz0MbtMs5/QPopWuPdFURomWiRZVRqje9MLTIIfz4R+XAZc2qNfo0HMryXROP7OvtZ1gOacbcyCrAmbHHFGTZYtaAcsDUeWcEQ2Ddd0yzwaeieZlSPivl6heU6Hnxegr1sq4FInIRGv/W89AVQG1YTXJDpdimn9batc6ZTYN+3kJ/30M9u9SlXMumqz6E8YGNp2z9bXbMAtjGaN0WK2nvz3RJiu20ZMyb+FMtHrsz7LSA2ezBNEGJnixIllPtPYFCNvSGpYX62RF//wiG82n/q6WL9KCaB2y/vXeqUUaLNCpj5tI60K1et7zfP8wp3MO93Wo3osnKrZ3AaoIz13ZhIJoBO1zRzlndwTR0Ff6VMrFWrZUP3iZaO2Czv+6d7eIiPxqR6sBvJ5doJdzLls0IUtq3TPRRFoHFTvVYIFlU6GAm22JMVjA1jLRlMWTVa8JfnCbU1o5p351UuneE82fAKp07ImWUyZaaLuN6J5oXYNoXsmr/zh5gcYOQQC13sXt509dYT08738YuG78FUUVrJyarMiyqdaBcpbBAuEyweH2qPOmc+qZaBGPW1QPuyTNkNXvZ2ZTDjZIExQVqNT/tryTlgQDSbx1DPh5CZ6sDLwnWkS/xm5DPbIKZqIlOeHwSocHkKmhnwTVtOnIeQsF0QbQE03/PSnnHByvJ1qq6Zwq0G8XNxNNO3kKls2PszkvE22y/e9muDRSey7NizrFyUTrdjFHfx8qSk+0Ye+HMZ2zy0VuZBfsiRYs78TwqXPqOZ6LWATR0FeDzERT1LGHCp7tn10QEX/SoWWJLK1VvaBbt55oejmk42iDBWKmc+qxEv2gSFk8WQndFh4s0DSCFPr6ROIzU1QQ6Agtsy44CVTEf/PLr5wzWSZat0CL3zcm3HOr01V7dQA71X6c6o1W1plezikSn/GhrrounqjIsvbV5qjG3HoGTZLBAqHMwAF/ODUDJ3ci0QeAUVcB1bKWVhKZKBNtyAeaUVlk/t9Wsiv/3Z6nfgsG6QZ98rz7UCu79pglNS/AP7BMtNCkQonN+PSW8V5ryQbIpGGUc1YLlIkWGF5xaNA90QiCDExwgIvrdu/p5/eTtBJdGMrDHJlokVRA8cj2scHsQjM86VKfNqgfJ/R5cEovQoOeAp/ZesAq33LOHHuiqZ6a9EQbKDLRimeuQSZaN/1NFcLY00+m9cBVP+gHH3tnFmT7vlkREdnXbjqqAke1qi22bclL/sdjZfu+WXnsUYvNnmiBwJge8Hr08IJ3sHDcsposmjQDbvpJntqnqCBaeDpnOxPNKydyvIMuPWmta0+0dhDoCC2zLrqMsN0TLWZK5qCFPxDjeqIlK+c0S14TTOdUmWiTqkeNI/MNJ9RnaaHhyBG18PKzC37mjgqiRQ8WaH1NOlggqvRwkPwgVyv467jRGVlRPdG8iYl2fF8x9TgbPdG8cs6cMtGaTmQPmiRTfeP+3W/Bk5dBb0+fOFwdeE+06D58wfdEndl4u3vmYBpeEK1qjcxggeBU5axmjZNgDoQHxeuJph1bNBxXJiMurChNR/9sK+bJ+Tyvn0jhnmhOxwuE6kf6FO8ixAg69XETCZTzFiQTLa/pnK1MtOFm2Y+T0GCBAnxGjztvsAzv/bEIoqGvKrYlf/vHj5MDs3V5zBGT3RdIwR8sIHLnjv3e7SqItuBdMWp90L3/L87w7rO4w2ABPUCzox2YW75oQqYmKtGDBbTj4molHDxZPFk1MqdE/KldRiZaRJZV0p5oR3Qp55yLyURbaAznwz8uA059rdhWu1lxl6v16jGKCNJ0nM7ZXq96/upN1+iHZlmt11FcEGt2oXV7q5yz3RMtqpwzokxD123q46CDmk1tAmzVto0AU6f9MMo59RKU0NX2cCbasA80Q49xPTBYIMN0zkEHN8OlP4PbXtNxZc+hVrbucUunvOdqUK+9uImw1Q7XVFS8TM/07VemhtkTzX//zVvwveDQAMo59RJOMtEGx8u+7DLARad/tqmXeuHKOclEixTqidYI90SLnM5pW6IOZYoQMO02vb0oPRUPGJlowx4s4B/jFLXsugzIRCsefzIvz0Ucgmjou3/6sycOZL2qpb8rIne2SzlF/KtUXiZaRBnpEQnLOXfs9zM2RPyglxLsiVYJlPFNVm1j2pa/TbOc05ggqGeidemJpk60jMECHTLRwmVjw8pE61zOuWiiIofmG11P5PXmy0qS6Zzq91QTYutNR2bapbCLJyviuK7M1Z3Yq12H6+3HeULPROvQE62ggwXUw1u1rVbGYzM6uBV8voy+Yh2ygxoRz8/E0DPRgn3mmmZwM0FmU9SEz0EKPt6DDDg+MjMvTccVyxI5Zsmk9x4zrHJOke4njFE97LqVwyW1oGUSFDsTbcCDBRby/53LSn1OGa/5hCXMFduSdpvXQgRWdPrrpwh/M0XhZ6K1LhTP153QsVXdyETzP0uL1ROtc1sB/eS5KD3Rhl7O2fD/tpMceyKbYU9I7+ShRw/LT+7fKy9cc4LR53vceIMFCtD+oqjG99WBkaPO013XlV9u1zPR2j3R2n/okxFvemYmWiAwZvsT4VQm2oplUyLiB2H8fTCDJbZtZqKp8sFg6ZIq46xFDRbQlu92pUs1CNcz0aLKpILTOdV6h13OqZ4z9W914q4e124n8nWvnDOqJ1qncs5gJppjDGVQr5G4AzKVwbHIGCwQLuf0n8OYAQ+BA89wwGewB2Pq5K5SsbyMx6iD96hMNH06p/qTCvVEi8xEU/198uuJpjbdCsq0vi/WdM7hXXVV04Yfc0RNqhVbJgbcs87vD9V5IqzOmF7nnWR23s5Cw5EHH5npuj/qJEgfLFCEgEDwOT9IT7SR5U1B1oNoXbOs/c/mojYs198HKenxzQV7otWbfsarGi6h90TTJ10XaTpn0w8Q6f9W6IlmlnNWCzpFtwyCVTJ5BtHe+Z93yT/8289l8z27c9uHImA6Z3cE0TAy1BWBh/fPyc8f2ufdPrPQlIWGn1WkSid1KhPNsvxMGWPd7YPYh9tBtOOWtoNooXJOMco59cmFIv40yCSDBcyeKGJ8HxdcmmkHd/RMtOheXO2eaIHeYMMu51TBvoWGK67reicbi7UMsU7UY6Q/Z0lOONQB7WItWHfY6ydXkcmqejwSBNEWtX6HqMEC5gTL8Hq6XV0b9GABbwKcZXW8ihrar6arBTbir56r508P5KqA2rCu1kZlkUWVc3a68p93T7RBZqLtPtgKoh23tJVd6/dEG8w2g5MKRboHFPTXmno77HaS+Y9fu0Oe/v7N8vNt+zrezz8JsrzPhiIEBIKvMb2ccxCZaBwID456fde6DHAxltGmc1YSXBjKgzGdsQCB5yJwXdcPonk90Zp+9vuE6sPqP5dJPkvzENX2QleEcs560/HamIgM/73bGyxQtYY+eXyc5DUELcqug3Ptr/O57UMRqPd8yjnjEUTDyDh79dHymCMm5aFHZ2Xb3lnjZ/tn694BXzDTTMQP5tSqtlGOqairg9v3dSvn9LPWRMK9sBa3G/5PBCIq6uDaz0RzOmaixV3p8gJBWiZa1FRIvydaaxtL2vs1vEy0dhCr5gfL9IPKqAPN6PX4PdSURJlo7cdPPX8LRjln1Xse4jKADrcP1BZNVLy+J9HlnK2vViBDUe1jsAluVBP8QfL77lkdT9Q69URrvea79ESL6us3pAPN4GO80HBiyjnj1xEKdg74eVkIZAAM8u9SHyogIgPviaYe+0ktsNrt71y93envp90mev5m16HW192HOt5PzxCZKlImWseeaAwWGCUqaF+tJA8CN7T35mEPY0lKfx0WIfBcBA3HH7pjBNE6BKSigmhFCJgGA3+hnmh6EDWn5z943DXs9+55LZOZ6ZyDE+7fnN9ntAraqvOtceQ4rvcccOwQjyAaRsbyxRNy+QtO8/59/PIpL8Cxf3bB+4OfrEaUc9bMTLAgLxNtf6CcMzKIZmZFGUG0yZhMtKjBAtqBt74+kfDB9Fe2bJX333C3V/KzeDJZJpo6WV+UMPOrX/wMOD94p297KuagLcjPRItuXP/T+x+Rm361M2L7HTLRJiveayTug3pOZfwZ5ZzhIJpZ8ug/D16vlGD55pAHCzQish2igltRQSR9olhcIMorSdIz0YZcmhS571FX/gtUzhmeHut2DRpltcvLRGu9p00MuCea/pqrJsy6UM+XPv24WwmoysqdWeh8gGf0RCtwJppezum4/SmHntMHC3R5nJBdZFZZl9evPnlaZbh0y9gcNj0DoQiB5yLQTyhVv1TH9U+8/VYVejln62unSddJ/cdtD8mPf7Mn28IBoeOkUE+0/HviBSsA5hvOwD4ro+jDk+iJNjhFGiyg/pbH+TMzOFRmmH9zo4QgGkbKn/3+Snn2k1aKiMjvn7jcuxK477CeiRZ+WatAyOKYIJrtBdFaWRvHLo3ORNNP8kTUQZH/cxV0C5aMhso5tcbtehBsImKwwLa9h+Wf/uMXctX3fiM//e1eERE5otZ9Oqfr+lcS1P2HlR0ULCNtBdHCmWhJp3Pqv6PeuP7iz/23/O3n/9srWfOWiwjieZloNb8nWlwQS32ITmmDBebqTigo5hplaP4+HtV+XXZrWD/4wQJ+kK9TQKMeKPOtB7O5skznHFY5Z8R0Tkf7vdXT0unq8bCfF+/kRXt/GVR5ZTATzeuPOOCeaBXbf1/tmomml98mPMlU03b1qbtRFrRMgkINFgj1ROt/xgU90YZDzypLmomrD80p6tQ/IxOtAH8zRaAHFtVFXBE/k9S7QKiXc2qfpUl6dMZ5eP+s/P21P5fXf/n21MtGUa/RuIua5mCSfN4/VBBNTUkXGW6AJbonWrH+Tssg2B+4CJlo3S7QlVkw+4z3/2gE0TBSLMuS9/756fKGP/ldedOfPsFr7LrvcF0Wmq0/+qgg2qnHL5OX/+HvyN898/ci16sOYvfOtIYUHLOkdcIZHixg9kTTM11E9Ey06HJONWDAGCwQ0RNNP6H+7I8f8E4o1QeLkYkW1dC+0TQOyL2eaEMu5/R6ojVd48rs4oirtVHUQV7UdM6Z+YYcmGuI40qowbj63RdpV1jVQe6SWvdMNFXOuXiyKktrVS8QczAwXEBvYK8/D0cd4U/t0qntqfLaQT8feoaECk5EnaiFB0G4RjZX7HROrd+U4pUm5TVYQCsd1p+XVD3RBrzv9cD0WJHBZe6pTLRjlw0nE01/zVVjgq9B6ud6T7Ruy6jg2eEuQTS/p43tBe8PF+DgOKoPoY4g2uhoRmWVJSzn1C9SFOnkvOm4xmuSkp4WFVisVW2ZrNje+9Wh9rHBoomIwQJR5ZwZMjseOdQ6Pn1kZr4vmSHBKebBzwSzJ16+QbTj2p9fIsM9odefb//4nIBCvwX7A+eZiTbbrlqZHeNyzuDfO+//0QiiYeQsXzwhf//M35OTj10iy9tlc/tm617AIiqIZtuWvPOFvy//86xVkesMBqKObgdBwoMFrIhMtIieaKHBAu0gmurJow8W6NAT7eBcXb7ys22h/V1S694TTf+gH35PtEAZacMxThq8vkxdTzTC5YLqMdqnpflv3/f/t3fe4XFUZ9u/Z7tWvVjFkm2594ZbDKHagGmhJoSQAGmEAHkhhJDkTQiQvPkgjdBbCIGEYkoCJKYaY2xwr7gLF9my1XtZaevM98fMOXNmdla7q277+V0XF/LW2d0p59znfu7HmJHH31/4/dhgzOtycBEt1mBMLOe02ST+/ZnzOSKGxgL6Nubwck6zE019XS6iDZATTczdscrbYwOWVMG5J7q5YnXnDPHXj+6eOlCuCquSWfHYsksJiGgDnMcR4mK4Q7itf8s5C9JZJlr/TgTEfc7ejXArwu5OVPRUFIWvEncEuh/ciY0F0jQ3Q0cc4a079tW04ZvPbsDWiuYevwYQfyLYF/ug6JqxGgQfrO/A159Zh7UH+qY87GSFXwds3TdwMTyHHSd2MRNt6EzOzedVciKosGPK47RDkiRD7ipgXLhjiNfS3nTnZOctRekbUdzcWMC8/wWGQKYiG7flamNyIHpxsj9hFQypbjtlovUjvEkVEyoH6XyjKApfRB8Ki22DhbmZADUXsIZENOK4JotnonXfWCAeZhEtN4aIZtVYQBR4rLpzqo8xZ6LJhoG3eTvYAOzVTUfREQhjzLBUw7aIk2+LZqMIhGXDpFwsaxwIeHdOt1jOKZSvJOhWEl0tDPa3KGgdazaKaGFT1gegD8ZSXXZezhm7sYCxNIOVA5vzOfRyTmOZb3aqVs4ZJaJpTjTPwPweVo4sq7fk5bdufUJg2VHMNHhkv59B5Oxnp5MZqzwzWTi2bAkMfOM1gOhruFNSLOfsLyeaVs7JVvIdvJS5vzLRNFejTYK9G+FWJCIcR5IUez9lBAShNF74L28sYLchza0el2ZHaTL89/MqfHagAW9sOdbj1wDir7T3RXOBrjjlWO/vqsH6Q014vZef5WTHsFiRYA6gnolmM+R8DhWiz4kn74RShIlJbGHUPEbkgpTwW1pmdPbASSae63qzEMCIWuyM6s4pG/4ejFykNu1cneV1CuX4A7cvMsez1+UY8KiKkwm2L7Kx8WA50dT9XP278yR2X5lFc3KiWUMiGnFcwzLRWju7bywQD7vJXcayLjwu42uZxRIxdB3QRRuHkBElOuN4OWc4YuhIxzBnor29vQoA8L0vj8EZE/L445g4BRhdQAx/KIJARD/pJZpB1lfoIpYmFgmlIU67LeGSspBFOSf7u7U7Ec3UnRNQS34BLRMtTjlnV9BYNss7dEaVc0aLVEA3jQW4uMhEtP79PXjXOIMrKPozR5XfhmXeRMDQndO0uWHhN2UM9GptwLIpgphBk0h3TvV3irdf9BXcHeUQ8pD6YV+QZYXnBerdOfu33JbtXqKgEO+tFIOTR3udbiZs4gpx3MYCQiZaOneiRTcJSRQmwHX0QogTt6un9yeCobGAxSCYLUT0RlQkjKWZtgSPZyvhbSg5XMwLCeREUGHfCxtbmHNzPRaurojF/tEzJ5p+DHfGceAmQtjk2DdfE4ZCLhI7R2WmOAcl09IXZDEgjiF5nJ4oBC3GoIOBKFSfzI0FokQ0WkSxhEQ04riGZ6J1hQzZBcliF5w02V4XH+iYB0hiZg+gBWELN6RoFwBR9BFfw83LObt3ojFRo0ZzkcwoycR5Uwr540QnmqihMYdVICwbHBhOx8BmOTCxyCuWcwplVez7ibfaJE40GOw7YqIYYFXOaQzMBYxONCb6iBfq93ZW4+N9aqdPloXABpcZKdblnLIgNIliasxyTm0ikj5Q5ZwRUZyIPQDk5YWCc9DQWCBGJlrQZMEHdFfagO1r3TnRJF2U6W4Vnb1G+gBl1YmCcn9+X82dQYRlBZKk5zwy0T1eKXVPYZNHUcCMV6bG7hbL5bsT0cRmAvEaC4jB0H1RzslFtF46QeId+32fiRb9eu0B9ll6LioSutPSnoQgZpWJNpQcLtHlnDSJAvQSR7Ygyjr+MqwWLA2u7l6Uc4rnuj5xopkc0eZrwlDIRWoVRTSnPn4eKDp4OadDKLseOsfpiUIwrJfNAtGNBgYKwwJdHxxjxyvmRZOTWVDsDhLRiOManonWGeozJ5qYvWC26gN6uRGgCljic1O5E02/TRT1mG3eFwzrLqYYmWiKoqBZa3SQm+bCOZPykeK0I93t4I4KwCjC6Z0kI1wYcTl059dAl3OKZaTcVWa3welIzIlmmYmm/S1OECubOy2f57RLXFhs9KmOnHSPvqLJLtxt/hBufWUbbn5pK8IRmb82EwFZOWeb3yyiiSvM+u2ssUCswPqBaiwgTtS66ywVtPi9rFx20eWc+m/KGHAnWtgo5AXCxqYdiWTQcBGNlRL084SRl8Ha+vfYrG1T9/ncVBd/H90F2k+ZaNrXbJcSFxTEbMGERLRg8iKayyFxkbQ3LrK+dqJ5nNbXq74W0fwWg+C+EgRPdiKWgli8BSIh3sCUhToUME+iBlK4GMqYY0OiyjktmiaxnzXRzMdYJLN4kAjciRaj0VPURHowRLROXURj58qBFHQ7hYZU9iF4nJ4o8GqIAVpgjkVnHPf2yUK0gE77vBWO+A8hiKGL0YnGBjc9ENHEUHhBRHPa1Q5zYUHwEp1oDpvN5ESz89sZ4vYwgU4sn4mVidbmD/P3zfa64HHa8fpNC6EoRoeVKMJlpDjQ0BHQnGjRQtJAl3OmunRnExe2bBJvvBBvoqF35xQz0aJD4CpbuqAoChc4Q8LzHHYJwQhQ3aK6+vLS3HrZnvYdNbQHEJEVRGQFDR1B7jDzMBGNlXN2GQeuYldBQ3dOrcw4LKtdSZnIxFaxee5DPw8URJGvuxVwnmEnZKNYCRtR3Tm1389laPzQv04nM6IA1typngckqNuTaOc7Lm4O0O8iCjvOfjw269rVfX5Yut7ZrP8bC2iuHLuYidb9Z7PKFuxu88QJZLzwX9H11xdONObaau+tE00Q1P2hYNT9fTFRFAe+VhOCDm1RwNcHpWEnMz3KRBOEN/NtQwFqLGCN3+REM1cr6CH90ZloxkWC5N9bPE59fdA5kI2v2LhVVtQxDRvTRuciDUI5p3aOykhx6pUcA7gvdgiZaA7KROs3QuYF5iFQznkyNxYIUDlnQpATjTiuETPRAr1xogkD2dw0l+E+caXRZjM50SRjKRtz8hidaPrzM1OcUSKQ+G9WGuAPyWjSXGipLjsfqE0rzsT0kkzD88X3Z46pQCjCJ2liyVh/Xpja/CHcvnQbVu6rswys5Y0F7LaEw82tyjkdFiKaPySj0adPRMXAeyZSMEEhL82lNxbQvg+x02d1q14amhKnsUAkZmMBfR8S3WZmJ9pANRZwdFMyFJEVPqD3CgMYUdjgOVXm7pxWTrQEw+T7CvYbigKYnKSzib/GAJdzqk60/hO16jQnWr7WmRMQy237qZxTyDFMtHQpYhCj1du6K781TCbjiFnieZD9vr3JAOvooxJI8z4X6/7e4A91v6rOvgfKROsduiBmO2Ez0cyTqpMVNpnUM9GM402PU184ZBi7c6q39aic0+DA7YPunHEa3ER36Bv4fYCLaJ7BzURLdTv0MdQQagByoqBXr0QfPwOJWLZ4MpcwRjuRT97vojtIRCOOa5iI1tLr7pzRbjGGx2V0fbFJOeskZzeIaMyJFi2MAaqdP8f0+gYBL1Wd7DZ0BNCklR/mmES96G2PLucMhGVDoPZAlHN+UlaPt7ZX4clPDkYF6AeFck6nPfHunCEha4Zht2ikAACVQnMBNqlx2iUuUrAxa166OypAXhTHarUcOqcgwGWmWItoYm6YQUTzCiKa9h6KovB9NH2AHE/GrB6bYZsZ4j6RFqOcM5YQZdmd0zawrkfmmGCdF4PhWNve3WswQcO6q2pfI+Z06d+X8T0/KavDkodWY8exlh6/DxOOWVMBAMJqev98RmMeXWLiAM8WtElCd87uGgsIk8luHBmKohi+63R39PkxWTr6uJwzzWMU0dhppE/KOYPdl3P2lSB4shMRRJLkM9GE7pxDSEQbCqHyQxFW1soEHY8jVjlntBOtu07XidBv5ZyCiCZut9mNOBgiGhP4M1Icuog2gNvBGjhQY4H+hV0Ph1I5Z1+4PY9XhoIL9XiARDTiuCYzRc9E61VjAeEpOaluw30GJ5qkrySywZAonqTE6c4JRIt0YqZavjbZrWsLoLEjaLk9ZgzlnNqEzB+KcBHD7Ui8G2ZvYPltTZ1BoTunUM4pdueMIRyYicj6cxhWTjTA2FzA6PQxfv9iOSfr7NgqNCmoaVWFB/F3z4zTWMAspqZ79FVLNvkIywpvnT1QTjRjVzDw7RARXVdiYwEx20rvKGZ8fdYZUfyuEhVO+oqoPLOI0LRDQkKTluhMtIFxCIoibyiiYGtFM58c/ffzauyraccHu2t6/D6sM+cwwYmmd+fsr8YC0flQ8UU00fVoFD3b/CH8ZfkXOFjfwR/fYXCixZ5QRYRjzmW3Gboa97SkUxeewt265eIRMLlSGSy3rc8z0SzKMdgE1R+S+y0j72Qg0gNBLCKcA4bi5NycgUaNBVTY5JKF3IuLrIBYzql/f5bdOXuZidYnjQW0Y178DOJ1YShkorExl5plO3jlnKlCJlp/LUCdzER1iB+k65GPyjkBWIloJ+930R0kohHHNcyJ1uYP8YO8140FuinnBEQnmp67xEi16M5pdsaZX180VuVr2UX17X40d2oimvYZY257DCea6MBwDYATjXXLbOkMRjcWCMvcVeYQnGjxcrPYgM4qN87MMaG5gOiQEl1SLrsNGR5HlBOtpVMvBa3WnGhiB9Qs1sCiy5hdJGadOO3G/UBfNVXfQxz46Q69/p00GUuGbIbbGCFhu7xC+a1Vd06zE61V+z5E550zQZdhX8EGW2LHU8O2a8dXd5MWc5ltfw/S2X4nlhuv2FeLK55Yi/v+uxuA/t2a3Y/J0Kwdk8bfx5gH2NcYQ9YTExQMDTq0w4gJVP/ecgwPr9iPR1fs5483O9FiiVmiG9LpkOCw2/g+3lMnGROeQhGlV/tJ0OR+ZKR7jG7IiKzg+//YjD9+sC/p9xAnvWJJPaNdaJRCuWg9J2w4zyYmkojXNns/C9s9Iaqck5xoAAA/awiijeuinGjddOc0XEt7IJiKiwd9McHnXcyFMbNYzhmVizcIbhTuRPM4hbiTgTlXhSMy3+9TXY5umzMRvSNkUb0yGIjubbGq4WTDbzrfk4hmDYloxHENK7NTFKChXZ109qyc07o7J2DMvFBLONW/2WDZ0olmENHMTjSjs0wU8JhjpK49wDO+4jnRxG3PFLpz8iwghy7w9OeFiQlMLZ0hodujkInGuyiKzrg4jQWEDmYMsxONfX7rck6jEy0vzQVJkrrNRKtlTjSX6ESzLudU+OBYnfz+6Jxx+Mm5E5DisusdQCMRw3sBA9gF0qLxQZSIJpTZuuysvbipJDLGc5t96veRJQi9sbLX+guziyxgKudMpDwwKlet37PqxLxCdT8pq2kHABys9wHQRenWrp47Dth+nSWIaI5+dqWKIlqiggJ7jmTRxOJwoyqOs06jgNGFoSixSw3E35GdB3guWg9KGINh2SAm9MYNwo79dFM5p74fq/fvr2vH8j21ePbT8qScb7KsRDkqxYGwoiiG7e/J90GoWDqN4mai6de2odidcyiU8g1FeDknbyxgHN+x262caKJjvSdOtM4kuhInguE6ZJH3NdhuFEVReCZauscx4Jlo4sJCqpsaC/QXsqzw7zRNc4sPhXJO9d8nZ0ln1LFPiyiWkIhGHNeIYdG1Wv5PbxsLmDPLzJ0wuRNNe46xsYBFd07TIMvsRBPfmwWAN3To5Zzmx3e37byxgCkTzTEATjRWEhmWFaGjkS7KsIuky25LuKSMr/ALLi+zE210XioAczmnPkFxCr9Fnvb9RjvRhHLONotyTpa912lqLCAMjgHgJ+dNxI8WjTe8h5870SJ8m5jQ29+5YbLw/cUqGRIdi06H5hAUwvltki70mgf+ViLNQJQOiwTMApipsQDb9u7mLFGNBfo9E00XeVlnU1Z6ycqimRNVdEkmCxN9WRdj9T37tyRFdz/aEhYU2C5p1b2OOUybhe+h0+SaiiVmiec7tv/zDp09cKKZJ669yUXTcyONiz7MTcz2QdZgJhCWkyqnsirfFJ/vC0YMOYHkROs5vIRZ0s+z8Sbaxky0gV14SAR23WKfh5xoKryxgHYNF8cJamludCao1fmtJ0Oxvi/n1K9DDosGN4NdzqlWVKjbOBjdOVlpn8tug8uhC43xrmdEcojux8HPRDMeVydrc4Gh0FTkeIBENOK4h7mEWJZV77tzmjLRTI0FmHGMPceysYAg+pjt/nnC67PmBOb7QhEFh7QMILOoF7XtYiaalt0VkRV+8jeWc/bfxV90czHBQiyJZNvjEAeaCZdzRnd/ZEwsTAcAHBOdaGL+miPaZai7xKIbC9RYONGYCNHaaZ2JZlViah7wsUGB22GDS9umgcreMnSNM33nAUFsFct+jR0u1ceanTBM4Mm2dKINUDknd6JZNxZIJJeLl4QOUCaaLlxKXODmIlqnsYzTnMOXDK3aa4lOwf5u/MDdj0LIetxyTu6Y1DMn2W3suBZFNHPgb6zVYvY9u+w2fp5lZb89mYSan9M7J5qxfIWR4TGWFIvCfXNn4vuCOPhnbhl/UHDR+c2fhZxoPYWXj9sTzwGMCAscbOFhKJUOsUUfNr4ajFK+oQibTHq4E00fJzhEQTRGd07e6bonmWhi6HkfNhZw2CXLnFr2Wdni0kCHi7Nrn01Su9TrTrSBmdD7hDw0YOBd9lb4QxF8tr9h0ESm/kAci6QOUF5wLMxONN9JK6JRY4FEIBGNOO5hE8RAWIbTLmFWSVbSr9FdOae40ihJQhaayZEG6KKR+HpRTjTh9c3ii8th46LZPq28K8fbvYgmvj9zogFAuzYAcDsEh1G/ZqJFO2a8ghDVGWIimu5EC8UZCIgB7AyHqTvnxAJVRDOWcwqZaKITLc3oRAtZiWg8Ey26nLM9ELYcHFvFtLlNbjf2f5fDxssmB6yxgBS7tM7gRBPE1oTKOZlIk2KRiTbA5ZxpQpaGoSlCDBedCJsgpvUwj2N/bTtOe+BjvLThSEKP152S+rHAyrdbu0KIyIpQztlzcUN3CkY70fpr3+PuR2FCGW/CyF2PgugpKwoURRFEtBAXcc0TyFguqlBYc78KCyvcidaDSWh7lPDUexEt3dxYwJSJJoqHzKWYCMw14nbYeFan6CQR89DUf5+cZSt9QY8y0SwacAwlJxoTcbmIRo0FAOjfC1skE8s5HUKjGPG3FLtzxrqWJoKhO2cfTO7F8ZXDYrv9JiF1oN0obdo5Kd3jhCRJfCw9UIKuXlGhZR0PgUy0Jz85iG/+bQOWbqoYtG3oa0RBkDcWoHLOQYXK+RODRDTiuEecIN62aDxG5nqTfg3mdLLbJD5gYBi6c9osnGiCgMKEFzGHy5zRJjrLxDw1BivprNYcUfGcaGI5qZivwyZJRnGkH8s5LSb7osuiS7sYOW26+yaeW4llxHTXWGBcfhoAVeBiFzwe3G7T3VWAUM5pzkQTJqpsxcXjjBbRAH1gBxgHx2ZcplXTgCCi8Yy6fh4oRCwmahHTPqC7dXRHhFmI0t0V+vP8oQj/rrJSRSfa4JRzii4ysbEA01C77c5paiyQ7O+y6ot6VLZ0Ydnn1Qk9nn03LqFzLvutZAWobu3ik5mWHoposqzwYzLDUM7Zv7+PQRyQEnSiaXerTl99otLaFeITmaBQzmieQMZqRR8UHH8M9hu39UA0inKi9aac0yT+MvTmFupnFJ1oTUmIaGzQm+Ky83OZQURLUIgcCBRFwf7a9kFzH/QW8TqlnyvjXdsshLchJKKx/SedCyj9+9v8ZfkX+OpTa4f8ZK07J5oxOkMo5xSvRzGa9CSCeP7pCyea2MXcKvKD/ebZ2vV9oMs5xTw0INrd398wQYWdk9mxHRrE7ELWpfqQlp16IsD2ObtN4sfVYDUWoHJOFXbsmzNaCSMkohHHPSyPaVpxBn5w5tgevQabY2V7XQZnF2Bs/y0huiun+HgmuIkvEdVYQCjntCoDZM0FGDlxMtHE9/c47Vy8Yc6CWDkdfY2ViCYKkGySZnY8xcIfimDDoSYARieJuZyzIMPDv2OWI2e1wgpEO9F4yZTFtotONIfdxh0jouAmTv7NmENwxRVsp2NgBgpiyVAstwN3ogniXigix+3OySb3dptkcNPoJXwDMwgyi2jmxgKxOouKWJWEJkNViyp412ouxngEuRNNMgjujPIGfYDc1hXqUSe3dn+Yl1WLIrBV9k1fYmgsoL1XvO035O9xJ5qxRBvQRaRoJ1r35Zzid8x+454IYOaSx1450Zhw6xFLbSU9R5I50QThrDmJfDy+GOCw89J0cUIQ7apLXqxt7Aj0aN8088HuWpz7l9X40wdlvX6twUDMRNPL+eI50aKFt4E6ZyYCO69mDNAk6qUNR7DpcDO2H23p1/fpLbyxgCNaRLPbJDgtyjkjisX1KMnjRlEUg0um78s5o/fbQMhc0juwE2mxMyeAAS/n7DCVc7JxtKL0rLtqX8CugY1JLKgMdfT8Zikqr3igiXainZziEVssYCYVKue0hkQ04rjn+oWlWDK1EI98fbblhDQRmHvGXMoJGDPNDI0FTGWdHqeeOyVJuq3fLKLlpcUu5wSiRTSrbTJsuyDguB023q5cdKK5+rmcU1GUqNB99b31TphdvJxTLHmw3h5/KILvvbAZm480w+uy47JZxfw+c3fONLeDi2NsYMEGgg6L7pxAdGMBc9YZYBQAAd3NI4qFotBkhq2aBrmIFuHv7RoAZyBg3Z3TLCYFw0LIvVDmqjdNgGUJCuvGmpXiNOT6DXTJA+9y6NbLjthqotdpT6h8xtzhMywrSQ2Sq1tVsaemzZ9QB0Uxs8+8PwNGEU1WgI4elBSw/dTrshvcsP3dYUx02NgSdqIJpcOSfhtrKsBg5xhzY4FYLiqxuQojjWeiJS8amYUns5srUWRZ4QsIohPN5bBFie/NPXSidQlONHYuE10+ZhEx2XLOXZWtmPu7j/DLt3Yl9Twr9la3qf/XIgyON8TFikRdZfwaNUSdaEws0ss5++9aFZEVvm8ns48PBuw6zsQzgxPN4LIXyjm1r84ulnMm6UQTF4eAvinnNDYViq4OYB35WFzDQHfoY5log+VE0zPRomNaBqv0Wj9OAnEeefwg7ocu+8AsMMfC7Dw7Wcs5uYjGjv0h7hAeLBzxH0IQQ5v5o3Mwf3ROr16DzbGsSidTXPoETAy+ZhdUJhqkuoyHk90mIRRR4DaJMfGcaPnpHsO/s+OJaGL+msOuvp8/zCdJYslYf63u+IKRqEGFpLlKnHYJwYh+MVKFg+6daP/ZXoXPDjTA67Lj+W/Px+SiDH6f3ZSJluq2IyfVhcqWLjR2qAOLkKyvbImlXMPSTOWcEVkVAK1cdC7j75bldaKypcvwWHHyb8bsdjM2FhiY1TarkqGYTjTRIRhW9MYCNok7NcWBf7NP/R4yvcbyZ6vftrKlCx6HLappR1+gO3r0UszaNnU/KMjwCE406+crihJVzsle12OzWz/JBCu97gxG0BEIc7dTLMTGAvGcaIAq8mbEeU0zosgpwgT18EA40RIubVP/Ly5SyEIeGoM5sVj5pt0mISIrluWcy3ZU8f1AdLKm96I7Z5R7q4flnGI5kLjPiecGJmK09DQTLahP9lOsyjlNmWjJlnNuP9oCRQE2HW5K6nlWNGjn7Yb243NiqO/zeg5g4plo+r45UCXwiWCVh6UoimHBpK9o6Qzy8zO7hg9VzHEP4mKbI0aXSytXd7KnX7PrtW/LOfVzNbtNlhU+PmFulIEubeNONG0f9AxwJhoX0bSxvTiWHCzBmzvROoa22JwMbJ9zCWIuOdEGFx7V4h2cPMTjBXKiEQT0ib9V6aSxsYCe2cMGHWzSZxZdWLcjsxNN7DJktxiQ5gtONKddigqeNiOKaC6HjQ802ADEJYgjooDyysYKrNhb2+1rJ4pVUwGnTe2Ixy6K7GLkEMq8YjmxDjaouQ9fmzsiSiA1O3fS3U7kar9bY0cQEVnhZWxOm8mJlm4s5wyGZfiCEcsBkdf0e7LJhNgtkZcNdtNYwCoTbSC6pYrbZ8xEsxbRzJlohu6c2nMVQzkn68xpPGacJidauz+E8x5chUsfX5OQSysZFEXh36vYFKC+g4lobr2xQIxBr7jimSZkCiaz2s2caEBiJZ0hsXusPXrniRLRepCLxlxbGSnWImewn/a9iGKxz8X5KhVxXxN+r3jlnEwU7zRNKL+obcetL2/Db5ftAWCdidYTF1l0d86e5dWJEwRxn1OdaJqDNWLRWCCZ7pzMiea08UgCcRLc289Spwlex5o7e31cswlh43HqrjAuViTWaXOoZ6IxoYKdP2Sl/9w3YmnaUC9T8wsNOwCLxgIWmaDsnKguLKq3JVsOaHbf9qaUnBGWoxfQ2HaL17/BmkhHZ6INcHdO7Xxp7UQbeJFHURR+PRjqjs1E2FrRjCueWIMN5Y0AojvEDwb6Yr+k/fvkFI+iF1GonNMKEtEIArqTKM+qnFNsLCCBNxZgz2EXVrPoYo9RzilJEi8/tHIw5WfoIlpOqivuyq/RiaZPwtgk0aqxwOEGH37x7524ben2Psl2sJrks4sQe282gRO7c8Zaea/VnD2FmZ6o+8zuvVS3Hbmp6nfW4AsYLr4Ou15eAURnogXDsqUACESXc7KBpFi2KgpNZpgD0dydU+2WOjCrbVYd4LrvzqmLm4bunBZCFHPkZZucaDx8V3vd/XUd8AUjONbchYY+Xj0NC4IpG2grirqdNkl1ffLGAjEm+ladocy3d0coInNBAQBqWuMLAbw7pxBELXK4L0Q0i86c6nv2nxNNURRr4TbBkHUxE01RELOck01u2LnSXNq0z1QWaCjn7IUTzfycnjrRDCKaWz/PuB32qIYkhsYCSWWiiU40Y0k9EN1YIdlJeZ0mFvtDcq+FD+ZEa+wI9uh6NNjik1g2z67p8TPRoo+TodWdU91XRAdsvIWFNn8oKbcko0Fwnw11hw37DqzLOW1Cl0vBiWaxIJVsOSc7PtlQwxcI91q8NsQKsGu/tt2iYDZY5ZzMLcsz0ZyDU86ZZspEAwbnnNPmD/MFuObOYMK/vz8UwZ8+KMPOY639uXlJ89a2SmytaMFrm48CAJwOKaqr/UDDRDM2pzjZGwtwAZ0aC1hCIhpBQHc35aRGl5uJDjOx3IgJJ7oTzegYc3AnWnRJGHNOWeUhieWcZpePFWKovdsZ7UQziCPahYlNMjsCYVS2GN0ePcEqU4wJRWxliV2cRMdTrNWmGm2CVpgRLaI5TKKhw27jWWeNHUHDRET87HabxEvb+IU6IvNJalRXVtPvmakNJI0imvp/y+6cduvGAi6HXe/OqZWTJouiKDjaFN8Bwgbv3TkkgkKnSHEVkD0slqOIrYiy74Vh7jZ5pFEXhA43GsWh3iIOtMwllMPS3YZtT0REczuSz+Soaw9AfOlEnGhhQ7lx9GX4qMmBZZU3GI/WTlbOaf379MeEXdy3HEmIA2JZNDuURCdacVYKAKGcU5vcMNeuubTpiCZCsvcXhQA9E63nTjS2j/Q0E03sGipeH8RMNN5YoIflnLw7p9M6E41NUM3Xi0QRhWOzYzBZeJal0FE2USoaOzHrNx/id+/s6dU29IaeZKIxYdkhNL8ZbDFQhDcWSBHcud04kWRZwWWPr8F5D61O+tgShbOh7kbkTjTendPkRLNHn/Msm/Qk+VuzknU2uZeV3otJ+mKOPj5gwhqbNDtsEndiDbSg0NZlLOc050X2N2w/9mqfXxyuD4bgLbrPQhEl4Q7TH+yuwWMrD+D37+/rr03rEWysdLRJvX6IVTODLqJpc4pYTjRZVvDX1YeGfCOUnhKIykQjJ5oVJKIRBIBFk/NRkp2CsycNi7rPWM6pX0ijnGgm5xIbTLud0YcZy16zEl/ExgK5cTpzqu+v/+226yHibJJkyETTBkisTTYAHGrovbBhlSnGBmVsUCk60eKFm9cJmVZmRCcacx/p5ZwBg8PGYdPLK3JT9c6r4oWaTdoKMzyG7CSzEy3TorGA6NYy4zbld4hONLddf+2eDMaeXn0Ip/9hJf61tbLbx7Hvwt5NyDsTVsVw4VBEEdxB1h0umXAay4mmusQUHGnU3UTmMsXeYnT0GEVPtu/YEyzndNhUl0CyeXU1rUYBoSaRck6hmYNVOad5W3viRGuN4USLJ2D3BtFdYUuiTE0Uo0XHJBNnZpRkAlBFJFnWu9QN0xYczAPdck2svfmssfjlhZPxy4sm8/uYoJasaCQ+hzlke+tEcwnNPABTJpoWJC7+9kk1FmCZaC69O6dVY4GiTFWgTDZjSRSLzY7BZBGz0JIVUTaUN6LdH8aKfXW92obeYOm+jJeJFol+zmCVMFkhirBsn+zOiVTfEcCheh/q2wPYVtGc1Hs1HkdONCYusXGWx5yJ1k05py2J/cMML2EXxoe9LenkXcxtYnUAc6LpjjueRdYPbhRFUcWIz/Y3RN2nO9FMjQUGqKxUd6Kp7y9JQrbsIOQXmpsJJHo9qNDGYEd7eZ7ua1hmKbvGGZtbDc6CAivnZPm9sRoLrDvUiN+9uxd390FjnaGIuTvnQHfmPV4gEY0gAFw8Yzg++9k5mFGSFXWfORONneTZqhi7qKa6TeWcTESzcqJpq4nWjQXEcs74QexiMLGVE010fjEHzIE6XUQ7KPzdU5hTRsxvc5nKOTtD6vYYVmstJg2KouhONItyTtFSz1ZI2ffZ6AsaLr52mwSnFqSeJ4TaG8s59YB80bFiLs/l5Zxd+sBFD9+P2kzB7cYy0fTunGyb2DYky+bD6iRlo5YlEQs9d8cW0+1g1VggGNYz0WySdXdO5pCJEmlMJQ+iiGYuU+wtbEXarolf4vHEHJ0SFwBh6dzjggZzTiYpolW1GEWzhDLRLLJoukPc5/615Rge/LAsrgtR3K9FHP04YTc70RLpjAoYjyMm9jb7gnySOK1YE9E6Q4aSRDahNE8m2X42qTAD3z9jDH8+IJRz9siJpgvuPX0NwLjPuYTfX8xEC4RltHWFDA0xmi3KORs6Anhm9cEoEaxLmwSnOO18om9sLMBEtJ59FjYBAnrnRPOHIgZHX317ciIKO/6qWrr6PHMxUXqSbzbkM9H4oo+e4drdROpok36e33IkSRHtOMpEC3BxiTnRzN05rRoLqP+3C5m6yf7UrPFHutuBVG1s0tvmAnoXc92JFpJZJhorB7dZOln7is+PteJ37+7Fz/61I+o+5rTi5ZwD7ETjmWjCWFBfJEx+G/77eRWm3/sBNhzqftwWC7PAnGiHziotHqW6NbHu4QOFeaxkXPBXqzQURcFdb3yO+9/dOyDbxBbk8uI40VhVRV9XVwwVeGdeL3Xn7A4S0QgiDuZMtHmlObhm/kj86Jxx6m0263JOJhRZOdHYCdpKREsVBkm5cTpzAsY8Lpddn4R1CJlovEwvzHKq9Mwg0ZXWU9gkvzQvld/GXE1cRNMuRmpuSOzVpvZAmD+2ICNaRLQLzh2WYcWcaA0dQUOpnLpyqL5XniBOugSxiG17ZooTmULpiieWE80iE82ynNPUZY870ezGiXNPxIyKJvXCfSCOAKqvgEMoyYzRWMChi5uhiGwoQWG7qehEYyHnWaaSY/H3CctKzHLO/bXtWPLQary3s9py2+va/dhX09bt5xPdfQAM3yvbd8RjzGr8GCWiJVlOUNPaAxFNLKOxcKIxmJDLVmo7AmH8/N878MjHB7CrsvvvhrlDzWXK5gDpvkR0OdqEVft4rgu2T0pCufwRbVKel+bmolVzZ5BPHG2SONA1iWiacFua5416L95YoCeZaAGTE62Hk1hDkxGTE02cKJpFs2ZfKGoS9MiK/fh/7+7D06sPGW7vsijn7Arq+7T5syTzfYQjssExlqwTrSMQxlce+wwPvLcvSjRJ1olWpcUR+EPyoIVts2tOzzLRbHwhbGhloulikSjsxqKiFyKamJXZl79hQ0cgZuZpTxGzBsX/A2yBMPq3NDgV2bU02XJOXlpo5+WFyXbUFVEUhS/miNchsxPN7bAW4fsKtohb2dIVNVFvNzcWcA6wiMa6cwqLw70RvN/cVol2fxhvba/q0faYj41EXZvsHBkMy0k1p+lPZFkxRAIARicaoAppFU2deG3zMTy9+lCfdKTtjoisN6rK4040632efaft/jBvgHEiwZ1orLHAIJXXDnVIRCOIOBhFNAkepx33XzEdiyYXANBFLHM5J3teqklcA3TRx6qrIwDka5PGRDLRmG7gtKsDeLZCyi7yTofYdl2BLCs4WKeLGX0horFJ/qhcfdLKBhu8O6c24HPabd26YVhTgXSPA16L707MRGMTYnbBU8s5dfcVoIsjeUJpLBe4Ino5Z1aK0yA4RDnRLMo52WKklYhmnniIE2e7kP2UrBNNURQ+YTlQ19HtyqLoRItV1hgUwoXd3Eov6wKcZJ0rppdzGvdR8fcJy4phclXeoP/90oYK7Ktpx18/NU7+Gd97YTMufuQzHOpm/2QuP7OLDIgu5wSsxZyAUFonvkaipStVWjnnGE1ArmmLLwKEhZbuovCXZyrfHpWrvibrCPvpF/VceBaFcCuYE82ciRavM25vkE1OtFgdYc2wn0Xtzqn+zY6LkuwUZKeqx15zZ1BwBzj4ubVDmEy2doX4ZIN9fyJ6JlryA98Os3urp+WcEf1c4DQ40ewGJySb8LDFlGBEjhrU765SxdStJuFCn+zbYjjRQobP4otRtmJFQ0fQIEgn60TbfLgJO4614qX1RwylnACi/h2PKqGc2uwKHSisM9ESa6bR3060ls4gHvroC17SlSgB3oXSnpADSDzPb69oSeqziOWczZ3BPml60hkM49wHV+HChz/tk+ZJDL9p4UasVBDHNhEtzgCA5bU02d+aHZ+pbgc/hyVzzJqJ1cWcZ6IJ2W9MvOqPXCRxkU10MwJWmWhsTDWw5ZyiiNabJiBf1KrX7L3V3S+AxcLcWCZRwbnacI7sfQZyX9DoC0YdA2pGqLjAbBw/9nc5qnh9ZGOxrpD1MSZea4bKd9pXKIoSVc5JTjRrSEQjiDiYGwuYGZefBgCYVJRuuP3O8ybi26eV4pSRWVHPYeWHYmmiCCtTykkgE42tfLMBhrl81FCmF5FR1dpluFgcrO+9HZkJKqKIxt6TlXUyt4jDrpfEWg1EumsqABidRWmmTLQmX1DPuNLetyRbzfyZWKD/PlblnFleo4iWYhLRMnk5p5CJ1o0TzRwQzkrMCjM9allwkgH2jPr2AB/MtvnDqO+IPem07gBnfD+rck41Ew38uVbdOWOVc4oiWktn0OAyONLo4xOLdQfVkoadla1RgcV17X7sONaKsKxg/aGmmJ+PfQ/su3QbRDTWAVd/vNXEJdDLck7mRJs1IguALgJ3R0jIYRPPAaPzjKLPqBz1eGL7qJj7FM+F2Npl/fu4LJwSfYX4msl0HZQtJpmMSYXp3O3Y7AsZHBmshL5TWKFmx9mwdHdUTh6guxr8ITlpIbG9j5xoYiaamIlndKJFuItmeFYKv12cOCmKgv3axGzHsRaDoB63sUDAmImWjCBY127cx5MV0dhv1B4I84klI9kOvuIEprJlcDJ/epSJJuul6L0pEQNU59emw9bnyZc3VuChj/bjkY/3J/WavJxTiIjobiLFwsEB9XeNJ/KLGPdp9IlbZm91G5o7Q6hq9fdJ8yRAPd6C3KHHnGhCYwGbsRs4W/BgIp7Nhh535+T5XC4HP+/1JhPN0IDJISxsmrpzegQnWn9MpA8L4m6FSUSLcqKZ3P39DXP6iSKauXFSonQEwvw8WVbT3iPBvMlczpmgy7JaEHzMzvnBwsqxb463CIZlw3lF/Ls/YOMISdIXh2O5PcVzyokmooUiCi83F0W0oVQKPFQgEY0g4mBuLGDmstnFWP+LRbjh1FLD7YunFOCeS6YaBlUMNgkzCzWMK08pxrj8NJwxPi/u9vEGBo7oblFAdO7Ovmp1cMs63tW3B6KCy3dXteJ7L2yOO1FnsEl+YYaHvz8TI5hIwIQ7p7BabzWJZRd5qzw0wOgsYoMb1qghLCvc4s4uxtcuGIX/3HoavvPl0fx5YrA/cz5keV18xROI3VigpTOEiKygzR8SSh6jt9NtcjTtqlLbi0/X8pmSLRtkmAeasX4jWVhpthvcDsbHGRoLCMKenlMlONEM3Tmtg+tFEeSQJtBmeByw2yR0BiOoaw+gsSOAMm3yHIoo2HbU6KLZclj/945jLZafj20noJd5iE405uYUBU6rDp2xSkIDCQosLG9kliaW13cE+AD5cIMPL6w9HOWsYJMr0SUKWIhomijd2qXuayuTEtF0h6VIfzrR9GYUMJRSx+qMan6e2rjFeJKdMjwDOV7WGTdocAekckeGPtBlJcOjLVxo7HmMFXtr8au3dsYMDzYT5UTrdSaa3ZCzKZZ3BkKy4Rhjg3qxxLO+PcBzg9r8YcOEVGws4HHZDbcBvctEY3lo7Ng/1hy/U7CIuJ3m0r9kyjkVRTE4AioHwYkmy/qEw2HTxYh4wrHoRHPGyKtMhM5gGN/62wZ889kNlg1I2PW+rCZxUQsQnWiJlXMyFxE7/SdT0mku6e2Lks49Vbrbp68a2oifn4towqKlwySKM1GUCWZ2oUlPa1cIP33984Tzsdg5zuu2c4d+b8rbxPO/ug8aIz/8QvabLsL3rxPNPLaJykQb6HLOIGssYJGJlmQcwn5hsaArFDF87kRhxwU7x5hFNSva/CFD5mR169AQfMwLMYA69hLHm8GwbNgnzPtHX8Nc3l6nfozF6khrXLwZGsJkX+EXnJ6ZWiWDrAxes4ehDIloBBGHeCIaoLuLEuVLY3Jx26Lx+MUFkyzvv3reSHx0x5mW5Uhm2KSTTb4Wjs0zlIkWZngMQfbMSj6jJJO7dcwlc394vwwf7a3Fnz8sS+jz8Fwxr4uXj5nLOUNCmWV3uUwsJ8GqMyegruSyz8cGN26Hna9WMicbe3+7TcKMkixT2ZT+N3u/zHjlnNoktq0rhN8u24NTfrMcW7QuZFa/vVgC0xWMcNGDhZybvxeRcETGff/djefXlEfdd8RUlhOrMYS40m03hLwbB6C8tEzIcwlFZIMgwp1o2msqiiI4nYxuSbGDFSsVHjMsjYu25Q0+bCg3uiY2lRsnXJsEEa27FuLBGKWYAFCgNRYQRT2rOapeWmc3vEay3TmnFWfCJqkT4caOAJp9QXz9mfW45z+78bYpA4WJak6bUeAujRLR1H+3doXw+bEWw2TzQJwybCZsZ5hFNJu+3/X1yqJYPgwgZkdYM+xucT9lTCnK0FeFgxEuLKW6HJaTycMNsfPQAFUsZuf0n76xAy+ur4jb5Zah54ip+3JnMNIj4cOcw+cWnJRMsAhGZO5Ey/a6kJ2qu20Z+03Hvig4W2aiWXTnZIsVoYiScJkUmwDNLMmCJKmT62QC4cVsxM2a2MJ+9mQaC7SYGk0MhiPAcJ4VMtHMJcwdgbDh9zG6hJNzhz6yYj+WPLQaDR0BlNW0ozMYQSAsY59FmRi77hys777030xAcFzpnaZj7x9sgvvl8WqH82REtAbNTc3OhY3duKsTZbcgonUXCZAMohOLXd/Fjs5Ou9FZHO1E0/ePjeVNeH3LMfzxg8TGWGKnSOaw7exFJpo49nLa9cUctg/qjQX6z4mmKIpB4BRFkois8PNturk75wCXc4qxIj0tvTY7bvdWJydqA7rYzMYJiYjN1SaBp3rIONGij3G9ekUfh4olnOZy376Gi2huBx//dwrlnJ+U1eHT/fWIyIrB0VfZi8Y6QxF2nEuSfuwBRnGNUCERjSDi4HHph4lV2V5PsNsk/PjcCVgwJrdPXgvQB3VfmTkc2+4+D//87nw8/a05OGdSvkFA2quFtY/PT8PYYWopqljS2ewLYs0Btd34ir11hiD9e/+zG197ah2aTRdvPX/Jyd0J5nJOhjGjrRsnWgwRDdAn6WK5FstFY+V03XU9FMWW+nbdVdFtOad2XzAi4/XNRxEWnV7dZKIFwzL21rRBVtRtZN1XxYGCmRX76vD3NYfxm2V7okpRjiToRDN3SmSDvwN1Hbj22fX4yWuf47XNRy0bUCiKvl1WOS6+YIRPELJNTjRAdzsxEa0018sHfocbfLyUk32n5lKkzUf0f++v64i5Gig6egDrxgLiMWs18O2uO2e8SWcoInMRtiQ7hZdhV7f68dM3dnBBV/w8gJBD5zA2FijK9BicpMyJ1tIZwoq9qgttzqhsAGrb+lhuMkVReNlxVPdUe/ffR28Qy9oAxOwIywiEI6qjUyjnNOdETirKQLrHwW9nx0OqWM4pOMmYQGMWJEVYGThzY5nzxGJ9NjbILhJcsj1xo3EHpUn8dTuMgkUzF9GcyBFy4Rj7TROzHcda+d9iALpZRAtFZP63eJ5NtKSTTYBKslP485Mp6RS79LLzV6kmGDckIaCYz42DMZkR92274LI2C2L3vL0bX3lsDVaW1RmeZ8xRi388KoqC59aUY19NOz7aU4t9gsPMnLUkywoONajfb2cwws9HieAXnGieOE40fyiCWk1YvWJ2MYDERbRAOMKPwzHD1H2gLzp07hG+i0N97ESzC84tAPAIrnuDE007zmVhnGAeK+ytbksos63DwoFrPve0doXw4vojUdfLZTuq8MiK/YbrGSvblCTmVDcu6onnj0TKeXtCS2eIu80AGHL7xHNRurk75wCVc3YIwiWDNU4KJVl6XVZjHKf1JBeNiWbjtQiZRI6TKpPzbKiUc1pth1MQowH1eBOFs/4X0ZhoatdFNO1YauwI4HsvbMZ3n9+MQ/UdhvP7iVbOyTsQa3mY7JRFuWjRkIhGEHHI9rpQkOFGaa7XkPc0VNBFNF30yfQ6cfr4YTh/aqGhlA/QV8DGGkQ0/QL//u4afoEIRmS8o3VP3HS4Cc+vPYyNh5vw23f2GLahVZiws0k7nxiayiKdwoAtLEe7YdhAvyBGOSegT87F0iwWvs2daN10PRQt4yxTLDPFycsGAMDrNOYppbrs/Hv0mQapVl1WXYITbXelOrmdVpzBXWvMHWg1MXl101EA6uD71Y0VhvvYQIJNOA7Ud+BoUyc+3F1j+C4Nkzvh826taMGaA43419ZjuOuNHfj7msPa9tgMjkU2yRa7c7LXZw4Zl8MWVfYK6CInK+ccmZuK0ZogVN7owzqthOV7WontliPNXBDyBcLcReB12RGRFeyuaoUV5jwztzAIY+4lgxOtGxFNdAMBwN1v78LUez7Arkr9vataunDxo5/iG39dz7tLKYr6fnmpbu6e/NOHqpOTsa2ixfCerMxHdGUCqquPbbfLbuMuobauEM9D+8b8kUh12aM6n4r4QzL/XGanoPh+fZ2LFjaJaGJZxrqDjYZ9MiIruOaZ9Tj1/o/55MBuMwrSpblepLkdsNn035N1gjQ2FtAnXMzZUNqNizfdlJW2tSL+hF+c1GV7XXyf65GIFkO4dQul98GIbOiAyz5/k09f1GBOtOHafhLTieYyToLFz5KR4uQThu4+S0cgjMUPrsK1z65HnXaOzU/38MzJRDt0qu6C6EnHxEI1szKZck7z5MU8YRwIzIsVdosSZkVR8Ikmnq3+oh6A7gRSu3MmXiJ2tKmLL1p9fqzV4D7bZyrZVDse6teXROMZACETTRB2Y02iKlu6oCjqNfLsSfmQJNUxXZeAaCeWqLFy9t460cIR2fBd9FU5p54TZpw6MaeWQ+sIbs6CtMrMY/iCkYTK1JjrLNVl593b2/1hvLb5KBeTf7tsD3711i48+ckBwzbf+frneHD5F4Z8UbavOW1G4cLcnVMs5wzLSp/GABw2Xb/E74F1PPQ4bVHX96DQPby/iMgK/w6M3Tl7lonGMgKnDs8A0DciWjJONHZZHYxzpBXMzSwuGuoVBfoC9NEBbCzABLMUi3LO7UdbEJYVBCMyPthdY3heMpmLlS1dfZbR2F+ITYkkSRpw8fp4gkQ0goiD027Dip+chXdvOz2pks2Bgg3KXI7Yh7Mk6bkrbEA5Lj8NYzUhZl91GxdI/vu5WnrGJkdvbjsGRVEMZQf/3lrJJwWALqJlpjijyjnPnDDMsC0OU0dC80S+Nk5jAfEziyuErLmAuZwzFmwb2EAkK8VlcKKJDkRA/Q7Nrh79vujbxEy0nZXGPDTx/c2D0urWLsN3u3TTUcNjmHCyaFI+ADXr5uqn1+HGf27Bh3t04cYc8m7+Pr48zpi3Zw51ZXNAm1iixEU03XlodUyYnWijcnQn2mf7G3CgrgOSBFz7pVHI8jrRFYrg/V012FXZim1aZ7firBScOlbdxlglnVF5Ztr/89M9fJvFj20V5hzV4VP7Dlo6Q+gMRvCENiE52tSJrz29Drsq27D2YCM2lDdx50tBhvp+TET7dL/q5Lz5rLEAgLLadoNAERLKUEXnQlaKnn2V6XXyPLP2QBh7q9tgk4CzJ+VjrDaIjjUpZuXVDpvEJ1wMUVzu61w0sxONCWLPrz2Ma/66Hg+v0MPNX9t8FFsrWgzfiyRJhv1pclEG/1vP31K/c6/gyPCH9PJj7kTrRkRL8xhFtCONndyRGot2rZunW8stY0JcTzp0mkU0p1jOKeT+tBicaHouHGN/rfr7X3FKCQBgV2WbxSRYL8diEwL2nac47XDabULH0tif5d0d1ThQ14E1Bxr5/l2Q4UZJtiqOJ+pEq2zuspyAMhGtIYlyTiaiMcfmYDgCYp1nxduPNnVx1wg7l/W0O+d2QSj9/GgL9nbjRDOfH2KV/psJR2S+/R6nDfG6czLxY0SOF5kpTkwuVI/bjTGaHYiwDNPcNJfeZbuXTrRDDT5DOf4hwWkfDMt4Z0d1Uo5Hht5swXhOZa51Jkix8x87v/IGRBbl6oDRNRcLsTsnO++9tOEI7npjB2765xb4AmG8qy14fqZVEgDA+kON/Fyw7qB+O+9ibje6hkPmck6hsQDQt24UFk3BnL0VTXq2IhPRxIVNcTuSbciULGLn09Q+yERjmYSXzhoOILHfHFAX/v615RiqWrr4AsM4rUlWIiIaOydOyFefM1ScaMzNPHW4MCZ2GKtqGjoChiYjR5u6+jXcnoloqW4HP6ZZSa+4EPreLlVEY4tPiV53fIEwLnn0M1zy6GcJ57AOBuLYQfw/OdGiIRGNIBIgze0w5CIMJdhE1d2NiAbA5HhxYuywNIzXLsYry+px7l9W4/739mK95hL6y9WzIElqPtXv3tmLjeVNcDls+MpMdRBw5+s78O+tx+APRfjFJyvFhexUYznn5bOLeR6WeruxhO32V7fjt8v28Isju8izcjwr2KTD4ERLopwTiBYdc9L0xgJ2m2QQ+hhivlSaRdtzETYZbusKY2elOmASBwxs+7qCEby7sxrXPbcRX39mHX67bA9kRS3by0tzoa49gD99WIbfLtuDHcdaUKF1KDpbE9EaOoI83P65z/QMNYMTzdT1MN3twOPXnmIQWFz2aKGNfTa2j7Fxa7OQ1WQFex02UCrN00U05jKbUpSBnFQX5o7KAQD86JVtuPjRz/DDF7cAAOaWZmNmifp9iWVqIkwAc/OVavXz5Av7jirMqH9311gglgjNxL2vP7PeIBS8ta2SC85sdVkUfr/1pVH46fkTUZKdAkUBdghCIJuoOOxStBNNO36yTBl9AHDKyGzkpLowblj3IproDDWLnE6LzJ6+QhQGgOjj4uUNRxAMy2j3hyzzFu2mcs4pgojGRCT2G6QJ5ZyA2uX1O89vQktnCJIUOxNNfa5+7LLzTCw3Wjgi48X1R7BRy/FjGSFMiOsIJN9JkDWtMGf5uRw23vREUfRS8+xU0YkW1O5X8IXmbjh/aiFSXXZ0hSLYUN4ERVG4YJbiii7nZBNU9hnSEhAE39h6jP/NVtLzM9x8sSXRoOxy7XHmzMlJmojWFYokPMFg5z12DmnoCA74QD/WeVbMRBMbp+yuakMwLPe4O6d4HimrbTcE6JfVGrv+mTtkxstRZIhimdthj9tY4Jgmoo3UugnPH63+HhvL44toTMzKTXXzhbDeimjsO2Fu7cqWLnRp+YW3Ld2GW17eil/8e2fSrxvTiebQnWiA6rYHdKGFNyCyKFcXt7c7rMo5WZTAzspW/HbZHj4O23GslR9DqzTnIwCsPag3MeBdzFl2Lc+pNYrwbkFEFW9PhOfXlGPOb5fHPLeyBY+FY3Nhk9T9i53zWImvmMkkbkd/u2KYeOIwjQV7konW7Avy3+orM9Vy5+pWv2FBJBYvbazAT17/HDe9uIV/93o5py4El9W049P99VHPZ86zU0Zl8fcdCl0W2WL5jJLoMTFzpLLxFYtz6ApFku7enAxdoehyTnbNFBdy2Rj2lJFqtEZtmz+hBcn1hxrR5AuiyRfk86yhiF/IQwT081t/NBY53iERjSCOc9jKptuZmIiW4rTj6W/Ogcdpx/zRObjh1FJ4XXYcqOvA06sOQVaAWSOyMK80B6dpTqBnNXHmmwtG4YErp2NcfhoaOgK447XPccmjnwHQQyhZNxen4LL4oebIAdTJoSiivbOjGn/7rBwvbqhAOCLzQXX3TjSLTLQkyjnV7dAHEmdOGIbhmR4uWqQ47ZYOK7HT4W2LxvO/rbLyxuenw2GTUFbbzh0C04p1UYBNnL/9/Cbc/NJWrP6iHusPNeHdneoq1ze/NBJfnTsCAPD0qkP422fluPEfW/j3M3V4Js9XA9Tvf0N5E38vQ8dDocwIAM6alI/MFCfOn1bIb3PaVeu2WTwUM9HYZIA50TJjOPNSTQLj6Lw0LBidg3ml2ZhQkIYLpxfiN5dOBQB8bW4JUpx2ZHmd8DhtvJPU3NIczBiRBSC6Q6c/FMGn++ux9Yh6u1mMMO87TATsCkZQVtOOq55ci1+/vQuKomC15qphIo1otZ87KhuyAnz1qXWobOnCqFwvHrlmNgDg3Z3VeH2LWnZ7vdaZlzkNz59agHu/MhWSJGG2NtDaJopobAJjlwzde7O9Tl5+me11wSG4hADgnMmqcBrLiRbWSg2YQ8ncVAAwNuYwdw09UNfOBZZEaPYF8acPyvColrfDRAB2TjKLsg0dQXy0txaPrNiPho6gYf8FjPsaoHbmZGSZyjm9Lgdcdr0b4teeXoeP99XBYZPw8yWTul30YN/pjJJMnKOJ0VsrmvH65qN4fOUBwwTpjx+U4Vdv7cKdr39ueC77f3sfONFcFk40QD+XqeWcxky0Rl+QC4bj8tMwXZuMXPvsBnz59yt56Ytazqnnu8iywsWyaEHQ+rNUNHZaCiL56R7MLMkCAHy4uzahwG+Wh/alMbkGB++IHC8v7UnUjcYcAJOL0pN2BfQVYSFbymaLLuUDjC6GYFjGvpo2oxMtie6cnwvnQha+7rBJ8Dht8IdkQ4kcOz8wcetgXWJCp1FEs/HfJdbvKzrRAGBBHBFNdIGJTjQWydDbck7m8vnyuDzuYC1v8OFXb+3iLpKV++qisl3jYXZoMNj3w8ZY7Jxu7s5pk6zzU2PFFYiwcs40tyPKXQyojnVGWFb4tXFVmS6sbD/awsUhtm1sm7mIJhsz0dxaB+Fkc9EaOwL4wwdlaPQF8djHBywfw5xo4/PTMVxbaGX7UltXdGMch10vfe7v5gK+gO5KEseCegOGxAUF1lSgOCsFhZkejMhRP+vnMRYHRV7dpMZ5sIVEl8PGjzN/SEZnMAx/KIJv/HU9vvW3jVGufVbOOXuEOg4JhGWDu2uwYAus7PoB6PvgGRPUecd/d6gi2pi8VBRlGveP/oD95mo5p3qMsYY7n1tUQ0wvyYTLboOsJObwWy0I2qu/aOjmkYkTjsh48pODWHugb14PMOZhAvr5jRoLREMiGkEc50wdngGXw4Y52mQ9FtOLM5HmduC5G+bxhgZOuw33fmUqNvzvIvzhqhn46pwSzBmVjZ+cNwEAcP8V0/GDM8dg8eQCnDulAD86Zxy8Lgf+c+tpuGvJRGR4HDyXJzPFCZtN4uHqXmGgedWcEv53RorD4IZhE8n/985ebD7SDFlRhRfmLLOCTZzTLJxorPuQVVaXiBho+6evzoQkSTyDiq2Im2Ei24SCNHx9/gh+u9VEekSOF3ctmcj/neV1Ghx5oljlddlxy9ljcfNZY+F12TEq14sLphXh+oWlGJ2XivH5achNdQmTatWlNEFzEl40vQgXaILYU6sO4v1d1Tys32EhaJw7pQCA6hJksHGi0yQ+2my6SBiSZRxu8GGZNrixaioAAPdeMhVXzx2Bm84ci2evm4ucVBe8Lgdev+lUfPjjM/HEtXMwR3OPnDe1EHt+cz62//o8rPnZOfjBGWNwwbRCXDprOHeiHW7sxO1Lt+HZTw/hxn9sxim/XY5v/W0j/rn+CADA4zI2FjB3dmUTqWueWY/Ln1iDzUea8Y91R/CT1z7HOzuqYZOA72r5bDeeMQbZXieeu2Eubjl7HAB1NdLjtOGpb87BxdOLUJyVgvZAGP6QjKnDM7BQO56umlOCD24/A09eO4cP9mdrQuDWI8149tND+N83d/JSWZfdxl0LqgjtRI5QzgnA4EZbPFn93cYxEU1wliiKgp/9ayd+8M8tuP3V7ernthDRAH2wGhIm7c+sPojFD67GeQ+uNgY8B8Ioq2nHx/tq8fG+Wi4ALt1YgTP/uBKPrTyAPy//Au/tqgGbV7B9TSxdYoLN/y3bg79+qoryv7t8Oi8pVx9vdMeJIhrb19ixxiY3bLAbDMs4ZWQWPvzxGfjBmbpob0Wx5p66YFoRX01euvEofvrGDvzxgzI89NEXAIAVe2vx9OpDAPRwcCY4MaH4zW2V+NEr27CvJvGMm1iZaC6HsdSdTTRyhO6c9e0BKIrChdIR2V6kuOy487yJmD86By6HDZUtXfx78jh1IbbJF8Tpf1iJPy9XPx8L7Gb3P/nJQcz9v+W477+7DWLUvzQX2uyRWYbty89w46yJw1CY4UGjL4gPduvl5LHgE+eCNAzP1M+Hw9LcvJyvPkERhW1jSXYKP7dWtQxsuZJ5n2f/F12v2zQne6AnNQAAMkxJREFUDvvuWL4OkFx3znBE5tEAY4TGGWOHpWGiVkK5T+j6x0S086eq540D9R149tNDmP+7j/g2+QJh7gphMIHCZbfBZpO4Ey2WE6HC5ESbp4lo+2rao9w2j688gLn/9xFufmkLOoNh7qbJS3Pza3hjgm6TD3fX4Mon10aJUOzfU4dn8O/psZX78crGCkgSkJfmQlhWuKCWKE3atppdy6y8U3d1sXJONfOVRyOYyjlnj8wCkFhpX0dAd8mIi1TD0t0GMfoU7TU3lDeiorEThxp8cNgk5Ke7EZYVbDrchLUHGrBZ64DNhT9TCWqskq63t1cazg1HGn3c+Szy1KqD3Bm3sqzOMhReL7338n2HnR90J5rxGtZdaXGzL4hbX96KN7cdi7ovWXwWTQUAfQE3nuDtD0X4Qi0bi7GS9Xna2Odnb+wwXGvN7Klqw65K476Rm+pCqsvO98FGbWGKuTeXmjJ0q1v1kvc8bVxbPci5aKGIzI97KyfamRPUhS22D47I8SadvdkTuizKOQE1JqE9EDaE7APqdWd4ljrWTGTxhsUgAEZBrTe8uvkofv/+Ptz04hZDl/LeQOWciTMk6tMef/xx/PGPf0RNTQ1mzpyJRx99FPPnz4/5+Ndffx133303Dh8+jPHjx+P3v/89LrzwwgHcYoIYOkwdnokd95wXtTpq5oXvzIc/FDEMwBjpHie+NncEvjZ3hOH2ETle/OKCyVGP97ocuPmscbh8djFufXkbthxp5u6fy2YNx7HmTnx93kj+eI/TjmU/+jI+3d+AMyfkw2aTMH90DqpauvDcDfNw7392Y+3BRnzn+U0AgPx0t2WJJIPdZyznVAcIbHDzjQUjo58ocPr4PHy6vwFPffMULvyNzkvFQ1fPwshc61IwNsk7Y/wwpHuc+PZppfh4Xx2+NCbH8vHfP30MNpY34aO9dZhRkmVY0RQHzn+8aiYumlEEAPifReOhKOp3Vphpx8o7zwIA/GvLMfxEc8OwAeePz52A0XmpuH3xeByo68C7O2vw9vYqvL29Kuq7Eh0KZ01Uc+pY5hgA1LSqgxqnwwYIjRPEEpRD9T6c9adP+H0zNYHIzNmT8nm5aSKw7yU3zY1fXGjc335wxhg8vfoQ3tpehbeEz1WUqYaauxw23KA5wdjAJ99UCvzMdXNx+9LtfLI3Oi8V5Q0+/HtbJQDg6nkjef7WFaeU4PLZxZAkCbKsYGJBOspq2/H/Lp/OH3PprOF44pODAIDvnT6ab7/NJvGBMoNNlFbsq+PNARgOIYcuw+OE3SZxR1y2IKJVtnShJDuFl3GME5xoB+o6MDLHiz9/WMbFDnYMmJsKMJx2GwJhGX/+sEwti5FURyigup+u+et6zC3NxpoDDVHlE6eOzcWC0bn4iyY0ZXmdaOkM4YH39nF3IRNdRXH5z1+diR+8uIWX4H3/9NE4d0oBNh1uwsH6Q/x5okNUdBQWCYILAO7GSHM70OYPY+ywVPz9hvkx3ZEit549DjNLsnDxjCK+T4gTwUc/PoDKli58oE2yz5gwjA962aSKZaKxY+2DXTW447wJuH5hKd8Pu4IRbChvhMtuw/SSTKR7nFAUhXcuZK8ldue02dT8ylBEEZpDOPk5atPhZix56FO0a45Btk/MLc3Baz9YCH8ogqdWHcQTKw8iLMsozPBgWLobt549Dv9Yd9gQbFyoHSfsPLpZ266/rzmMf6w7gtPG5WFEdgr+o5XVXL+wFG9vr8TKsnp1oSNVPU9fPW8EHl6xHy+tP4LK5i68v7sGv754MhfKRVgm5+jcVIzOS0VlSxckSXWC5qa5cay5K2EnEhPMijJTMDwrBfvrOqImM4fqO7CxvAmXzS6Oe43sCWJZpvh/0dHDyn8unlmEf2+txPajLYITTZ+YxZuY76/rgD8kI83twKWzivkxOLkoHSkuu5qRVt2GL4/PQ6rmLgfUhYq/flqO+vYA/vB+GYIRGb96axde/O4CXPr4Ghxr7sQvL5qC75xWCkmSeKmcXiYf24kmywrv7s2uS3lpbowdloqD9T5sOtzMF23KG3x4+CM1F/HdnTU40tjJ99/cVN2JlkjWU0NHAD99Ywdau0L4n1e24Z3/OR0epx1rDjRwF9aUokyMzmvG1ooW7vD+0TnjkeK04/fv78N/Pq+MO05gKIqC5z47DEB1UYqwBTsHF6RYaaQC8Sc1d+e84pQSbD/agtq2ABo6Anx8YQXL6EpzOwzCzlVzSrC/tgMf7a3F7JFZ+OrcEdha0YIN5U38nDFnVDZG5Xrx2uZjuP/dfSgTuvrqmWj6NgNiSZe2MJXuQUtnCH/68As8tvIAnrx2Do41d+LX/9mNrBQn7r9iBpZoC3lVLV34xzp1gasww4OaNj9e3liBny2ZZPhMTDAblZuKkTlerD3YqDvReCaacbzqdtjQGYxY7ou/e3cvlu2oxge7azClKDPqWpwMPl4+a8oUjdF9l6EoCl7ZeBS/WbYbY/LScMUpxfiLts+fMV4db/3yosnYWdmK/XUduOav6/HaTQsNC6xHmzrhdti40z3D4+CLvjmpLkiShNxUF6pb/WjyBfHaZl00/O/nVbj74ilIdTugKAq/3g7PSkFRZgoaOoKobvEbokUGmnqhIVNpbircDnU84tL2xQkFaXy/AZhL2Y4N5U3dio7dsbG8CZUtnSjJ9mLa8EyDSMboFCIQmMs9LCvc5TVzRBaafEF+Xh2epV53Djd2xm0WcLRJFbTZ9eFQgw9Hmzq5q7AnBMMynlipjkPb/GEs3XSULwb3BrGxAKAvElA5ZzSDLqK9+uqruOOOO/DUU09hwYIFeOihh3D++eejrKwM+fnRk7C1a9fimmuuwf3334+LL74YL7/8Mi677DJs3boV06ZNG4RPQBCDTyKTA7tNshTQekNRZgqW3vglvLHlGKZpF+XcNDfuuWRq1GOnFWdimhCsv/T7X4KibdcfvzoTVz+9jucdiQMKK66cU4JP99cbgvpzU/UB6DXzR+Ly2SVWT+U89c05aPIFoy5ilwnuLDM3njEGbqcNN2sOpXsumWr5WRmSJOHBq2fh+TWHcf7UQsN9iycX4D+fV2Hx5HwuoAGxf8vLZxfjb5+VY091G5+szBmVjTmjVCdNTqoLp43LxfpDTRifn4YDdWobbub6m1eaA+AgirNSeFiv3Sbh91dOx2MrD+C6haPU1/G6eLmmTVIvoGPz05DmdqAjEIYkAaeNzcONZ4zB6ePz0N/84sLJuHjGcDy9Wl3ZnluajdPHDTN0OmVcu2AkuoIRXDrL+BueMjIb7952Op5YeQBelx03nTkWty3djnd2ViPN7eDOS4Yoir34vQWobu3CDKHs4Mo5JXj203IUZLpx0fTh3W7/lOEZcNltCEZkSBJw+vhhWHOgAcPS3Ehx2vkkholml88uxr6aNnxjgfp7MCfaokn5fLtG5agr9xVNnbjw4U/hddv5b3bHuRPwj3WH0dARjNkIg73nv7dWGm6/+ayxeH9XDQ41+FC5XR8UZqaoLsrDjT6sPdjIs3VuPXscfnDmGJzz51WoaOrE917YDEDPIxPLRc+bWogzJwzDJ2X1WDy5AD/XxPlFk/LxjOb2kiR1gvqDM8Zg5gij6Pyd09TB4abDTWjuDPGJ+VVzR2BVWR0e+8YpCQlogHqOYsf56LxU5KS60OQLYvHkAhRlevDP9Uf4dzN/dA6evW4ufv32LizddJRPdMXmBJMK07Gvph0PvLcPT6w8gPmjc9HSGcTOylbumJAkYMnUQswtzcFHe2vhsEl80cLcGMPtsCMUUSdNNkldICjI8OC6haPw6qajfBJst0m4cLp+7gDU88ftiyfgq3NHoN0fQr4mRN55/kTces44fLyvDjWtaoYLe67YrfT8qQVo7Qph/aEmw2r5hII0nD+1EMGwjJVl9chLc/EJwdfnj8CjH+/HhvImbNBK+G74+yYsvfFLUZM17j7JS0VpnhefHdBLl4dpCyGJ5N6EIjJq2/UJIisHOyZMZtYdbMSN/9iM9kAYL6w7gieuPYXn7egTBevzraIo3TYSOlDXjjtf38Gzp5g4omcmqb/7rspWhGUFeWluXDxDF9FCEd2Jxt4mnhONlRRNL87k4jwATCrK4ELO0k0VeGrVQQzPSkGbPwybpD6+IMON2rYAz8LaXdWGSx9fw0WL3y7bg3d2VCHV7eD5e24+idJEtJDa7KKqxY+uUATTijPwyIr9OFDXAaddMjhH54/OxcF6H17ecASf7a/HiBwvVpbVIRiRMbMkE0ebu7C7qo0LjLlpeiaaWO7pC4TR5g+h3a82VzlU78PskVn4z/YqLnwfrPfh12/vQqrbgRfWHoasqI6sKcMzeC4aoJ5jbzxjDFo6g/j9+/uwobwJNa1+7kDvjrUHG7HxsJoLe5PJ6comm9yNyEP6ZYMwqjrR9OfNL81Baa66oLO3ug2nj9ebMEVkVWx/b1c1mn1BgwNXzBM8f2ohrprjQCgi45azx3G30faKFu4CPHPiMAzPTMFrm48ZBDRA6GhtyuUzHx9Pf2sO/r2tEiv21mJ3VRu+94/N/LM1d4Zw04tbML04E8VZKVj1RT0CYRlzR2Xje6ePwU0vbsHSjRUIhGS4nTZcMK2Q50MBqkuKLVzurmpDmz/EyxfNkQSqKzKEI42dGJevi2SbDzfhjS2qmBSKKLjz9c/x5s2nGuISFEVBICxbHvOKoorBbocNJdkpgvPP7ETTF4j2Vreh3R9GVUsX9te1o8kXxLHmLu442lPdhj3vqPv3FbOLcd3CUgDqvv7S9xbg6mfWo7zBh2/8dT1e+8FC5Ke78dyaw/h/7+6FoihcjP3tZdPw0zd2IBiW+SJbjiai7apq5Vlow9LdqG8P4J0d1fjavBFo9AURDKvjjsJMDwozPdhZ2YrqBLrmWnGsuRPpbme319m6Nj/q2gOYXJQRcyG8VujubLOpFSBHGjv5gqIkSThjQh4XB0fmePn5TezQqSgK/r7mMP72WTmu/dJI3HTGWMvGHW9vr8Ttr27njtD8dDceuHI6zplUYHgcO5d7tTiXFJcd7f4wH+/MHpGF+o4AF9GKs0QHdPci2mrtN5o9IotnTa/eX49rtXFeT/j31mN8EUpR1Ezk6xaOipsHHQ/zsc8yIMmJFs2gi2gPPvggvv/97+Pb3/42AOCpp57CO++8g+eeew4///nPox7/8MMPY8mSJfjpT38KAPjtb3+L5cuX47HHHsNTTz01oNtOEITqarlmfmKruSLixa44KwUr7zwLn+6vx6f7G3DxjKJunqkKBXecaxQ+WFD9uPw03HPJlLjvLwb0Jsr4gnT832XTk3pOhseJ/xHy0xj/e+FknDe1AEtM4losbDYJf7hqBu79z27L1XNJkvDidxcgFFHgcthQVtOOB5eXYZJW5nPmhGF4+XsLDB0PAdWFdbXgGnzsG6fgg901aO4MYkZJFl/53vTLxegMhpGZ4jQMTAeC6SWZeOwbp8R93NzSHMwttXYFprkduEtYCX/gyukYlu7GGRPyunUADEt38xV9xthhaXj3ti8jw+PstisuoA76z5iQh0/K6vGHq2bgilNK0NgR4IHiU4dnIi/NjUVaqWZpXiqe/tZc/vzzpxbgQH0HrhF+c4fdhldu/BJ++eZOfFJWj2CnjLw0N25bPB7f+tIoLJqcj4c/2o9vfsl6gFaUmYKWzhAWjM7B4skFaOgIYG5pDs6dUoBvLRyFB97bh8JMDxZNKsDkonReUrOnqg3ffWETqlv9uH3xeNy+WD0G7zxvAn72r50IywqmF2figStmAFBF5+pWP757uiqA/f7KGfikrA6XzirmA+w5o7IhSerANdvrgs0mRbkRAbW89cemYx6wPhckgyRJuOeSKVh/qBH/e+FkuB12+IJhtPvD+Pq8EThrYj7sNgm/vmQKRuelcvFu0eQCrD3YiNsXj8c35o/E65uP4dGV+3G0qQsf7dXLGtkgu7KlC+/tquElZLctGs9Fh8lFGVhzoIE7J+aWZmPVF/WYNSIL18wfySdyv7l0Gn68eAJW7KtDbpoLp4zMjmo+YXxf42KEx2mPEt0A3bE4sSAdD399NjxOO8obfFj2eRUafUF8eVweThuXhxSXHRfPLMInX9QZ3DhFmSk4Z1IBPtpbC5fDhtG5qSirbcfXn1mPWSOykOV1wR+KwB+K8LKu0txU3kGVOZDYQsiDy8vw3JpySFDLIn2BCMKyghSXDV6nAx6XHaGwDEVRhcfcVBcv93nus3JsOdIEmyRhQ3kTn0TurW7D4gdXYXx+Guw2Cftq2qEoCsYMS0NxVoqaNeW2w2G3YVtFC/bVtGFiQTpmj8xCfXsQTb4A0jxqGX2qy463t1fx0GlAn1yz69re6nb85r97eJ7jKSOzeP7PoXofP2847BLYlbClM4ibX9qCYFhBR0AVjrpCEYzI9mJ4lodPzmeOyDKUQU0qTOf7CBMgxRJLj9OOscPSUNsWgCQBV8wuwb+2HkNFUyccNgnXn1qKv68px1Yhuw3QG7WwYOlXNlbg+bWH+f1el527N/7f5dMNZfQLRufglY0VWFlmLFty2W146OuzYZckfOu5DdyNpGaiqb9/mz+MCx7+FEebOrvtGCtJqrPskRX7DW6cq+aU4P8umwa7TTKUi//wrLH8ejZ3VDY2H2nGN55dj7mjsuHUso2YE5Z1q3Y6JDhtNizXOl9/Y/7IKNHNw51oxpD+P75fhhwhGsJuk3hHZ0BtfDClKAPlDT7837K9KMoqh6IA7f4Q9la3G/YvRqrbwYXx4ZkezCjOhM0m4YXvqNU7iqJwMeWL2g6kux34yszhhjLsaxeMxHULS/H0qoP4srYQxq7p/95aiW0VLdwxyibQpXmpuOPcCfjROeNw5+ufcwfurWePQ0iW8czqQ9hZ2crLjScVpuP+K6ZjdF4qdxU9t0Yt439Sc3EDaiZqqtuB0dq54KO9tZhx74f8/pGmRc5sLdbiuy9sxpi8VGSkOJHmdvBO4EumFmLtwQbsrGzFzPs+hE1SI0bSPA4cqvehIxDG6LxULpTJirpIdLCug7uJCjLc/Dc1l3MyoZRlZFphk4AfL56A8kYf/r21Eosm5eP3V80wjHnzMzx4+fsL8LWn1+FIYyfOf2g1clJdxk6yERkFGW5cNL0I72vXDn6u1MYs/7dsLxRFPd7OmpiP37+/D0+uOojyRh82a2Wkw9LccNptvAvqEysP4LnPyjF2WKo6/kh3Q5YV7KtRu4iX5nqR7XUhEJbhtEvwOO34z/Yq3m13VK4X04szMbkoA7KsCpMOu4T9tR14f3cNIrKCLK8TU4oy+AKBoqilpzVtfh7twCoGCtI1EU0YS50xYZhBRGNC9Sdl9bjqybXI8rqgKAp39//h/TJsLG/i25ST6kK6x4nmziAeXP4FFEXdJxs6AqhrD+A7z29GUaYHKU47Jg/PwJyR2fzzebXf3KuJaMw5PmtEFuraA3yBrSjTwxdvXtpQgY/21mFcfhqmDc+ArKhuyuoWPzpDEezTKk/OmKAK5ZsON+Of645gf626AJHhUcXJNLcDwbCsNdiJoCsY4eeB4qwUeJx2VLd2obK5izcNufO8ifj7mnJUtnThq0+tQ317ACNyUjCpMAO1bX40dASQn6460p1aDq9TixFQm1tJcNhs/D5WfszO++xY+GhvLWrb/PA47XDYJPhDEdhs2ranOHHGhGHdVhCdiAyqiBYMBrFlyxb84he/4LfZbDYsXrwY69ats3zOunXrcMcddxhuO//88/HWW29ZPj4QCCAQ0Fe12toSzy0hCGLgcNptOGdSQdTqUKJkep1Y/4tFcMRoIz/UKMz04OIZ3buYzEwrzsQbPzw15v2SJPE24RML0w1ijM0m4dRx8Z1jU4ZnGBwFjBSX3dICf7yS7nHi3q/EdhHGQ1wFj8eT35yDtq4QH/iKeX/D0t3Y+L+LYu6zN5w2GjecFm3RL85Kwd9vmIfNR5oRjiiYPzqHD2CmDs/EM9fNjXoO4x/fmY+GjkCUoAqogsjDX59t+bwpwzPw4Y/PQGVLFxdnAeCqOSNwSFvFv/nscXzQlZ/hwePX6uJnQYbHINgC6uRt293nIhixdggMBJfOKja4Fx/82qyox3hdDkPW2ldmDuedigHga/NGcIdsRVMnclPdGJefhgkFaZAkCburWvGzf+3Arso2zCzJNDRb+cUFk/DDM8fy3LO/3zAP/pBsebxlp7oMGZN9wXULR0FWFHz3y6P5bzA6LxU/shD/vS4Hnrh2TtTt9106FSNyUnDlKSUYmevFN/66Hrsq2ww5MIzCDA8KMtzcTTVBEw+nFmcAm1UhKNEubLNKsmCzSThj/DA8teog2v1hrDmgdz47b0oBfnXRFPzsXzuw7lAj9tWYOlZqJdFW7Ktpj3q8yKljc9HkC2JfTXvUpLu8wYfyBr1b8sKxuchNc6M014vDjZ28VDfD44TboZYOhSIKLzsUESfWNgk4e+IwZHldOHviMOypbsMpo7LhstswsSAdbqcNt549Dm9vr8I7O6t5Se304kysPdiIK08pwe8un4YtR5pwuLETdy2ZiBvPGIuvzi3BjmOtkGUFr2yswOfHWrlYxPZL5qrkDQA0J9H/nDOON8FhnD0xH5MK0xGRFZw6NhcH6juw+XAzfnLeBO4GfP2mhbj+uU3YW92GqcMzuEDpC0Z4gxxAFS68LjtGD0vDKM3R1u4P45sLRuGOcyeg3R/C0o1HcdbEYbhqTgnOEVy7U4dn8kww5gQCgOtOLcWWimYcqvcZvt/ucDtsuPmssVG3M/GQndezvU6UA1gndOBzapNV1mgmM8UJp92GuaXZeGdnNcpq26NcYhkeB86dUohRuV7sONaCyUXqdzSzJBO/u3wapmsCmogkSVg0KR9LNx3F6ePzcP8V01GSrQpR91wyBa1dIfzonPGw21SXPOO0cbm8NJ/t8+keB8+30z+HDX/52izMLc1BttfJxzDXLSzF9ooWHG70Ye6obMwfncN/gwevnom3tlUi2+vCsZYufLSnFk67Db+6aDKunqfuN2dPyscNp5bi3Z3VqGsPoDgrBT84cwy+YVqg/cvVM/HoigN4f7fqmBbJ9jrx/66Yjk/31+O2pdvh0wTedpMQqx6b0b+522FDRFZ4FiWAqEoFJtaz98vyupCX5sL4gnQUZXjgcdqxcGwur7r45YWTeQmmmaLMFLz8vS/h68+sR2VLF1o6Q3DYJPzqosk4c2I+PtpTiwVjcuCw2/A/i8ajutXPj7OvzxuBbRXN3KH4tbkjcPqEPDy4vAzlDT6DUMmuU+y4Y7nB5Q0+fLTXGDHRHTZJzQY90tiJI42dWKZFQJjxulRnvNgNVoQ5SJkANSrXi42HmwwZrl8el8ffb1Sul18L69oDvNMpoArTV51Sgje3VeKTsnp8UmadNXb57GL8+aszEYyoMRbPflbOv4dDDT4eZwHoHbvTPU7u3nXaJcwpzeaNGrK9TqR79Fzi6lY/qlv92H60BW9sif0dnqmJaA8u/yLu9SURCjLc+M5poyHLCv68/AveWKKypQvrD8XvjtwdzGTAXPfmqBgRmwQc+N3JF6slKYPY67aqqgrFxcVYu3YtFi5cyG+/6667sGrVKmzYsCHqOS6XCy+88AKuueYaftsTTzyB++67D7W10aG29957L+67776o21tbW5GRET2BIAiCIAiC6GtCERlrDjRgzqjsqMDsE41gWMamw02obOlChz8Mj9MOj9MGj9OOWSOy+ARqd1UrSnNTeYbP7qo2dATCUBRAgQKbJCHV5YDDLqEzqLrZOoMR2G3qJGd6cSYXsFjny7Kadti1Jjenjs2D3aZm7dW2BbCzshURWcbMEVmwSxJ2V7ehoT0AXyAMn7byP6EwHdOLM7GrshX7atp4rly7P4zWrhDaukIozk7BVXNGwB+K4JGP92NyYQYum12MzmAYT606hLauENxOG3K8LozI8WLx5AK4HDZsONSI/+6oQorTjhklWbhEm+Duq1FDxDv8ITgdNqR7nEh3O+By2FDe4ENVSxcmFqZjbmkOdzey4bvVBF1RFOyv68CoXC/cDjtau0L4aE8tLppRBI/TjmPNndhb3Y7Fk/Ojnq8oCrZWNGNEjhf56R50BsN4cf0RFGam4IzxecjyuiDLCnZVtaLRF8RZE4Z1W/raHWpH7iAX7FZ9UY/tFS2YVJSOscPSUJTpiXKMdwUj2F3VitkjsxNyPuypauMl0SJ17X5sOdzMxSvWHVhRFAQjCkIRGcGwWpIZkRWcEyPrs6UziFVf1OP8qYXwOO0oq2nH8j01SHE5EJFl1LQGMGtkFhczdlW2ojgrBdmpLgTCEXy0pw4+LSqBdcKcVJiB0XmpPXJ2+EMRHKjrwNTh0ZEH3RGRFZQ3+FDR5MOIbC9K81J7XRpmRWcwjIisWJ4DZVlBVWsXCjI83b53Xbsf+2s7tOM2jM5gBPNLczCeixpd6ApGoEDN4GrtCmF0XiqyvE7sq25HXXsA6R4HJKiiTl6am7trd1e1oskXhKwoOG1cnmE72/wh7DjairH5qVE5nT1FzU1sRVtXGGOGpWJUbmr8J0E9Dt7bVY2WzhCuP7UUdpuENQcasP5QIz9HXTCtiAuBncEwlm48ijSPA0WZHnxR24H9te1o6QwhoiiYUJCGzBQnyht86AhE4HbYEAzLaO0KYcrwDFy/sBQepw07K1ux41grDtZ1wOVQz+mhiIxUtwOXzy7G+Pw0bDvaElXimO11ITfNhe1HW7DzWCu+tXAUpg7PRFVLF5bvqcVVc0oMx/pb2yrR2qV+NkVR8ODyL9DaFcKsEVlo7gzhaFMnLppRhHmlOdhV2Yo3thyDTVLL45t9QZ4jN3V4Bm49Z5xhf6pt86OuTd0vNh1uwq5KddFgWnEmrjilGG6HHe/sqMayHVWYVpyJxZMLMLEwHYqi4IlPDmJMXioumF6EcETGsh3V/PPvqWrD/rp2OO02pHscKMpMgddlR3WrH8VZKfj2aaUAgOfXHsaRxk7VeRaR0dYV4mXrbu079brsWndt9TxyrLkLgbCM4VkeFGep7uQFo3NRmOmBPxTB06sOId3jwJThGTjc4MPB+g4UZqZwZ2qTL4BwREEoonZSD0UURGRZvU1WEI7I/D6HzYb/WTQOM0qy8PnRFjVyQ1IXNLqCEURkBR6XHbKsoM0fQkRWsPTGhThRaGtrQ2ZmZlyt6IQX0aycaCNGjCARjSAIgiAIgiAIgiAIgkhYRBvUcs68vDzY7fYo8au2thaFhdY5QYWFhUk93u12w+2OnXdDEARBEARBEARBEARBEPEY2HRoEy6XC3PmzMGKFSv4bbIsY8WKFQZnmsjChQsNjweA5cuXx3w8QRAEQRAEQRAEQRAEQfSWQe/Oeccdd+D666/H3LlzMX/+fDz00EPw+Xy8W+d1112H4uJi3H///QCA2267DWeeeSb+/Oc/46KLLsLSpUuxefNmPPPMM4P5MQiCIAiCIAiCIAiCIIgTmEEX0a6++mrU19fj17/+NWpqajBr1iy8//77KChQO/RVVFTAZtMNc6eeeipefvll/OpXv8L//u//Yvz48Xjrrbcwbdq0wfoIBEEQBEEQBEEQBEEQxAnOoDYWGAwSDYsjCIIgCIIgCIIgCIIgTnwS1YoGNRONIAiCIAiCIAiCIAiCII4HSEQjCIIgCIIgCIIgCIIgiDiQiEYQBEEQBEEQBEEQBEEQcSARjSAIgiAIgiAIgiAIgiDiQCIaQRAEQRAEQRAEQRAEQcSBRDSCIAiCIAiCIAiCIAiCiAOJaARBEARBEARBEARBEAQRBxLRCIIgCIIgCIIgCIIgCCIOJKIRBEEQBEEQBEEQBEEQRBxIRCMIgiAIgiAIgiAIgiCIOJCIRhAEQRAEQRAEQRAEQRBxIBGNIAiCIAiCIAiCIAiCIOJAIhpBEARBEARBEARBEARBxIFENIIgCIIgCIIgCIIgCIKIA4loBEEQBEEQBEEQBEEQBBEHEtEIgiAIgiAIgiAIgiAIIg4kohEEQRAEQRAEQRAEQRBEHEhEIwiCIAiCIAiCIAiCIIg4kIhGEARBEARBEARBEARBEHEgEY0gCIIgCIIgCIIgCIIg4uAY7A0YaBRFAQC0tbUN8pYQBEEQBEEQBEEQBEEQgw3TiJhmFIuTTkRrb28HAIwYMWKQt4QgCIIgCIIgCIIgCIIYKrS3tyMzMzPm/ZIST2Y7wZBlGVVVVUhPT4ckSYO9OX1CW1sbRowYgaNHjyIjI2OwN4cg+h3a54mTDdrniZMN2ueJkw3a54mTDdrniaGGoihob2/H8OHDYbPFTj476ZxoNpsNJSUlg70Z/UJGRgadgIiTCtrniZMN2ueJkw3a54mTDdrniZMN2ueJoUR3DjQGNRYgCIIgCIIgCIIgCIIgiDiQiEYQBEEQBEEQBEEQBEEQcSAR7QTA7XbjnnvugdvtHuxNIYgBgfZ54mSD9nniZIP2eeJkg/Z54mSD9nnieOWkayxAEARBEARBEARBEARBEMlCTjSCIAiCIAiCIAiCIAiCiAOJaARBEARBEARBEARBEAQRBxLRCIIgCIIgCIIgCIIgCCIOJKIRBEEQBEEQBEEQBEEQRBxIRDsBePzxx1FaWgqPx4MFCxZg48aNg71JBNEjVq9ejUsuuQTDhw+HJEl46623DPcrioJf//rXKCoqQkpKChYvXoz9+/cbHtPU1IRrr70WGRkZyMrKwne/+110dHQM4KcgiMS4//77MW/ePKSnpyM/Px+XXXYZysrKDI/x+/245ZZbkJubi7S0NFx55ZWora01PKaiogIXXXQRvF4v8vPz8dOf/hThcHggPwpBJMSTTz6JGTNmICMjAxkZGVi4cCHee+89fj/t78SJzgMPPABJknD77bfz22i/J04k7r33XkiSZPhv0qRJ/H7a34kTARLRjnNeffVV3HHHHbjnnnuwdetWzJw5E+effz7q6uoGe9MIIml8Ph9mzpyJxx9/3PL+P/zhD3jkkUfw1FNPYcOGDUhNTcX5558Pv9/PH3Pttddi9+7dWL58OZYtW4bVq1fjxhtvHKiPQBAJs2rVKtxyyy1Yv349li9fjlAohPPOOw8+n48/5sc//jH++9//4vXXX8eqVatQVVWFK664gt8fiURw0UUXIRgMYu3atXjhhRfw/PPP49e//vVgfCSC6JaSkhI88MAD2LJlCzZv3oxzzjkHl156KXbv3g2A9nfixGbTpk14+umnMWPGDMPttN8TJxpTp05FdXU1/++zzz7j99H+TpwQKMRxzfz585VbbrmF/zsSiSjDhw9X7r///kHcKoLoPQCUN998k/9blmWlsLBQ+eMf/8hva2lpUdxut/LKK68oiqIoe/bsUQAomzZt4o957733FEmSlMrKygHbdoLoCXV1dQoAZdWqVYqiqPu30+lUXn/9df6YvXv3KgCUdevWKYqiKO+++65is9mUmpoa/pgnn3xSycjIUAKBwMB+AILoAdnZ2cqzzz5L+ztxQtPe3q6MHz9eWb58uXLmmWcqt912m6IodJ4nTjzuueceZebMmZb30f5OnCiQE+04JhgMYsuWLVi8eDG/zWazYfHixVi3bt0gbhlB9D3l5eWoqakx7O+ZmZlYsGAB39/XrVuHrKwszJ07lz9m8eLFsNls2LBhw4BvM0EkQ2trKwAgJycHALBlyxaEQiHDPj9p0iSMHDnSsM9Pnz4dBQUF/DHnn38+2trauLuHIIYikUgES5cuhc/nw8KFC2l/J05obrnlFlx00UWG/Rug8zxxYrJ//34MHz4cY8aMwbXXXouKigoAtL8TJw6Owd4Aouc0NDQgEokYTjIAUFBQgH379g3SVhFE/1BTUwMAlvs7u6+mpgb5+fmG+x0OB3JycvhjCGIoIssybr/9dpx22mmYNm0aAHV/drlcyMrKMjzWvM9bHRPsPoIYauzcuRMLFy6E3+9HWloa3nzzTUyZMgXbt2+n/Z04IVm6dCm2bt2KTZs2Rd1H53niRGPBggV4/vnnMXHiRFRXV+O+++7D6aefjl27dtH+TpwwkIhGEARBEIPMLbfcgl27dhlyQwjiRGTixInYvn07Wltb8cYbb+D666/HqlWrBnuzCKJfOHr0KG677TYsX74cHo9nsDeHIPqdCy64gP89Y8YMLFiwAKNGjcJrr72GlJSUQdwygug7qJzzOCYvLw92uz2qo0ltbS0KCwsHaasIon9g+3R3+3thYWFUU41wOIympiY6Joghy6233oply5Zh5cqVKCkp4bcXFhYiGAyipaXF8HjzPm91TLD7CGKo4XK5MG7cOMyZMwf3338/Zs6ciYcffpj2d+KEZMuWLairq8Mpp5wCh8MBh8OBVatW4ZFHHoHD4UBBQQHt98QJTVZWFiZMmIADBw7QeZ44YSAR7TjG5XJhzpw5WLFiBb9NlmWsWLECCxcuHMQtI4i+Z/To0SgsLDTs721tbdiwYQPf3xcuXIiWlhZs2bKFP+bjjz+GLMtYsGDBgG8zQXSHoii49dZb8eabb+Ljjz/G6NGjDffPmTMHTqfTsM+XlZWhoqLCsM/v3LnTIB4vX74cGRkZmDJlysB8EILoBbIsIxAI0P5OnJAsWrQIO3fuxPbt2/l/c+fOxbXXXsv/pv2eOJHp6OjAwYMHUVRUROd54sRhsDsbEL1j6dKlitvtVp5//nllz549yo033qhkZWUZOpoQxPFCe3u7sm3bNmXbtm0KAOXBBx9Utm3bphw5ckRRFEV54IEHlKysLOXtt99WduzYoVx66aXK6NGjla6uLv4aS5YsUWbPnq1s2LBB+eyzz5Tx48cr11xzzWB9JIKIyQ9/+EMlMzNT+eSTT5Tq6mr+X2dnJ3/MTTfdpIwcOVL5+OOPlc2bNysLFy5UFi5cyO8Ph8PKtGnTlPPOO0/Zvn278v777yvDhg1TfvGLXwzGRyKIbvn5z3+urFq1SikvL1d27Nih/PznP1ckSVI+/PBDRVFofydODsTunIpC+z1xYvGTn/xE+eSTT5Ty8nJlzZo1yuLFi5W8vDylrq5OURTa34kTAxLRTgAeffRRZeTIkYrL5VLmz5+vrF+/frA3iSB6xMqVKxUAUf9df/31iqIoiizLyt13360UFBQobrdbWbRokVJWVmZ4jcbGRuWaa65R0tLSlIyMDOXb3/620t7ePgifhiC6x2pfB6D8/e9/54/p6upSbr75ZiU7O1vxer3K5ZdfrlRXVxte5/Dhw8oFF1ygpKSkKHl5ecpPfvITJRQKDfCnIYj4fOc731FGjRqluFwuZdiwYcqiRYu4gKYotL8TJwdmEY32e+JE4uqrr1aKiooUl8ulFBcXK1dffbVy4MABfj/t78SJgKQoijI4HjiCIAiCIAiCIAiCIAiCOD6gTDSCIAiCIAiCIAiCIAiCiAOJaARBEARBEARBEARBEAQRBxLRCIIgCIIgCIIgCIIgCCIOJKIRBEEQBEEQBEEQBEEQRBxIRCMIgiAIgiAIgiAIgiCIOJCIRhAEQRAEQRAEQRAEQRBxIBGNIAiCIAiCIAiCIAiCIOJAIhpBEARBEARBEARBEARBxIFENIIgCIIgCCIhnn/+eWRlZQ32ZhAEQRAEQQwKJKIRBEEQBEEcZ9xwww2QJIn/l5ubiyVLlmDHjh0Jv8a9996LWbNm9d9GEgRBEARBnGCQiEYQBEEQBHEcsmTJElRXV6O6uhorVqyAw+HAxRdfPNibRRAEQRAEccJCIhpBEARBEMRxiNvtRmFhIQoLCzFr1iz8/Oc/x9GjR1FfXw8A+NnPfoYJEybA6/VizJgxuPvuuxEKhQCoZZn33XcfPv/8c+5me/755wEALS0t+MEPfoCCggJ4PB5MmzYNy5YtM7z3Bx98gMmTJyMtLY2LeQRBEARBECc6jsHeAIIgCIIgCKJ3dHR04MUXX8S4ceOQm5sLAEhPT8fzzz+P4cOHY+fOnfj+97+P9PR03HXXXbj66quxa9cuvP/++/joo48AAJmZmZBlGRdccAHa29vx4osvYuzYsdizZw/sdjt/r87OTvzpT3/CP//5T9hsNnzzm9/EnXfeiZdeemlQPjtBEARBEMRAQSIaQRAEQRDEcciyZcuQlpYGAPD5fCgqKsKyZctgs6mFBr/61a/4Y0tLS3HnnXdi6dKluOuuu5CSkoK0tDQ4HA4UFhbyx3344YfYuHEj9u7diwkTJgAAxowZY3jfUCiEp556CmPHjgUA3HrrrfjNb37Tr5+VIAiCIAhiKEAiGkEQBEEQxHHI2WefjSeffBIA0NzcjCeeeAIXXHABNm7ciFGjRuHVV1/FI488goMHD6KjowPhcBgZGRndvub27dtRUlLCBTQrvF4vF9AAoKioCHV1dX3zoQiCIAiCIIYwlIlGEARBEARxHJKamopx48Zh3LhxmDdvHp599ln4fD789a9/xbp163DttdfiwgsvxLJly7Bt2zb88pe/RDAY7PY1U1JS4r6v0+k0/FuSJCiK0qvPQhAEQRAEcTxATjSCIAiCIIgTAEmSYLPZ0NXVhbVr12LUqFH45S9/ye8/cuSI4fEulwuRSMRw24wZM3Ds2DF88cUX3brRCIIgCIIgTkZIRCMIgiAIgjgOCQQCqKmpAaCWcz722GPo6OjAJZdcgra2NlRUVGDp0qWYN28e3nnnHbz55puG55eWlqK8vJyXcKanp+PMM8/EGWecgSuvvBIPPvggxo0bh3379kGSJCxZsmQwPiZBEARBEMSQgco5CYIgCIIgjkPef/99FBUVoaioCAsWLMCmTZvw+uuv46yzzsJXvvIV/PjHP8att96KWbNmYe3atbj77rsNz7/yyiuxZMkSnH322Rg2bBheeeUVAMC//vUvzJs3D9dccw2mTJmCu+66K8qxRhAEQRAEcTIiKRRiQRAEQRAEQRAEQRAEQRDdQk40giAIgiAIgiAIgiAIgogDiWgEQRAEQRAEQRAEQRAEEQcS0QiCIAiCIAiCIAiCIAgiDiSiEQRBEARBEARBEARBEEQcSEQjCIIgCIIgCIIgCIIgiDiQiEYQBEEQBEEQBEEQBEEQcSARjSAIgiAIgiAIgiAIgiDiQCIaQRAEQRAEQRAEQRAEQcSBRDSCIAiCIAiCIAiCIAiCiAOJaARBEARBEARBEARBEAQRBxLRCIIgCIIgCIIgCIIgCCIO/x9A9e44qUa1JgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# BERT fine-tuning parameters\n",
        "param_optimizer = list(model.named_parameters())\n",
        "no_decay = ['bias', 'gamma', 'beta']\n",
        "optimizer_grouped_parameters = [\n",
        "    {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)],\n",
        "     'weight_decay_rate': 0.01},\n",
        "    {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)],\n",
        "     'weight_decay_rate': 0.0}\n",
        "]\n",
        "\n",
        "optimizer = BertAdam(optimizer_grouped_parameters,\n",
        "                     lr=2e-5,\n",
        "                     warmup=.1)\n",
        "\n",
        "# Function to calculate the accuracy of our predictions vs labels\n",
        "def flat_accuracy(preds, labels):\n",
        "    pred_flat = np.argmax(preds, axis=1).flatten()\n",
        "    labels_flat = labels.flatten()\n",
        "    return np.sum(pred_flat == labels_flat) / len(labels_flat)\n",
        "\n",
        "# Store our loss and accuracy for plotting\n",
        "train_loss_set = []\n",
        "# Number of training epochs\n",
        "epochs = 4\n",
        "\n",
        "# BERT training loop\n",
        "for _ in trange(epochs, desc=\"Epoch\"):\n",
        "\n",
        "  ## TRAINING\n",
        "\n",
        "  # Set our model to training mode\n",
        "    model.train()\n",
        "    # Tracking variables\n",
        "    tr_loss = 0\n",
        "    nb_tr_examples, nb_tr_steps = 0, 0\n",
        "  # Train the data for one epoch\n",
        "    for step, batch in enumerate(train_dataloader):\n",
        "    # Add batch to GPU\n",
        "        batch = tuple(t.to(device) for t in batch)\n",
        "        # Unpack the inputs from our dataloader\n",
        "        b_input_ids, b_input_mask, b_labels = batch\n",
        "        # Clear out the gradients (by default they accumulate)\n",
        "        optimizer.zero_grad()\n",
        "        # Forward pass\n",
        "        loss = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)\n",
        "        train_loss_set.append(loss.item())\n",
        "        # Backward pass\n",
        "        loss.backward()\n",
        "        # Update parameters and take a step using the computed gradient\n",
        "        optimizer.step()\n",
        "        # Update tracking variables\n",
        "        tr_loss += loss.item()\n",
        "        nb_tr_examples += b_input_ids.size(0)\n",
        "        nb_tr_steps += 1\n",
        "    print(\"Train loss: {}\".format(tr_loss/nb_tr_steps))\n",
        "\n",
        "  ## VALIDATION\n",
        "\n",
        "    # Put model in evaluation mode\n",
        "    model.eval()\n",
        "    # Tracking variables\n",
        "    eval_loss, eval_accuracy = 0, 0\n",
        "    nb_eval_steps, nb_eval_examples = 0, 0\n",
        "    # Evaluate data for one epoch\n",
        "    for batch in validation_dataloader:\n",
        "    # Add batch to GPU\n",
        "        batch = tuple(t.to(device) for t in batch)\n",
        "        # Unpack the inputs from our dataloader\n",
        "        b_input_ids, b_input_mask, b_labels = batch\n",
        "        # Telling the model not to compute or store gradients, saving memory and speeding up validation\n",
        "        with torch.no_grad():\n",
        "          # Forward pass, calculate logit predictions\n",
        "            logits = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask)\n",
        "        # Move logits and labels to CPU\n",
        "        logits = logits.detach().cpu().numpy()\n",
        "        label_ids = b_labels.to('cpu').numpy()\n",
        "        tmp_eval_accuracy = flat_accuracy(logits, label_ids)\n",
        "        eval_accuracy += tmp_eval_accuracy\n",
        "        nb_eval_steps += 1\n",
        "    print(\"Validation Accuracy: {}\".format(eval_accuracy/nb_eval_steps))\n",
        "\n",
        "# plot training performance\n",
        "plt.figure(figsize=(15,8))\n",
        "plt.title(\"Training loss\")\n",
        "plt.xlabel(\"Batch\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.plot(train_loss_set)\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.13"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}