molbloom_time_study.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Jgmedina95/molbloom-paper/blob/main/molbloom_time_study.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install molbloom\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AcGB3vRYT7vv",
        "outputId": "c489ed5e-3f5b-48d6-87a5-efe0921944b2"
      },
      "id": "AcGB3vRYT7vv",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting molbloom\n",
            "  Downloading molbloom-2.1.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (9.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.3/9.3 MB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: importlib-resources in /usr/local/lib/python3.9/dist-packages (from molbloom) (5.12.0)\n",
            "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.9/dist-packages (from importlib-resources->molbloom) (3.15.0)\n",
            "Installing collected packages: molbloom\n",
            "Successfully installed molbloom-2.1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install rdkit"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-L5C6-vLUFid",
        "outputId": "6060d93d-fbb9-49c7-ec73-bd05e0ed9f03"
      },
      "id": "-L5C6-vLUFid",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting rdkit\n",
            "  Downloading rdkit-2022.9.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (29.4 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m29.4/29.4 MB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from rdkit) (1.22.4)\n",
            "Requirement already satisfied: Pillow in /usr/local/lib/python3.9/dist-packages (from rdkit) (8.4.0)\n",
            "Installing collected packages: rdkit\n",
            "Successfully installed rdkit-2022.9.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "601dc863",
      "metadata": {
        "id": "601dc863"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.font_manager as font_manager\n",
        "import urllib.request\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.colors as colors\n",
        "from matplotlib.ticker import FuncFormatter\n",
        "import numpy as np\n",
        "import math\n",
        "import os\n",
        "import urllib\n",
        "from dataclasses import dataclass\n",
        "import json\n",
        "import sys\n",
        "from molbloom import CustomFilter, canon\n",
        "from rdkit import DataStructs\n",
        "from rdkit import Chem\n",
        "from rdkit.Chem import AllChem, MACCSkeys, AllChem, MACCSkeys, rdMolDescriptors\n",
        "import time\n",
        "from urllib.request import urlopen\n",
        "from urllib.error import URLError, HTTPError\n",
        "import json\n",
        "#np.random.seed(0)\n",
        "urllib.request.urlretrieve('https://github.com/google/fonts/raw/main/ofl/ibmplexmono/IBMPlexMono-Regular.ttf', 'IBMPlexMono-Regular.ttf')\n",
        "fe = font_manager.FontEntry(\n",
        "    fname='IBMPlexMono-Regular.ttf',\n",
        "    name='plexmono')\n",
        "font_manager.fontManager.ttflist.append(fe)\n",
        "plt.rcParams.update({'axes.facecolor':'#f5f4e9', \n",
        "            'grid.color' : '#AAAAAA', \n",
        "            'axes.edgecolor':'#333333', \n",
        "            'figure.facecolor':'#FFFFFF', \n",
        "            'axes.grid': False,\n",
        "            'axes.prop_cycle':   plt.cycler('color', plt.cm.Dark2.colors),\n",
        "            'font.family': fe.name,\n",
        "            'figure.figsize': (3.5,3.5 / 1.2),\n",
        "            'ytick.left': True,\n",
        "            'xtick.bottom': True   \n",
        "           })"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m-m71sQJUn2-",
        "outputId": "216e26e5-baf5-4bb3-bc1d-39ed756cfab4"
      },
      "id": "m-m71sQJUn2-",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "69f4e013",
      "metadata": {
        "id": "69f4e013"
      },
      "outputs": [],
      "source": [
        "with open(\"/content/drive/MyDrive/COCONUT_DB.smi\", \"r\") as f:\n",
        "    smi_list = f.readlines()\n",
        "#smi_list"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from rdkit import RDLogger\n",
        "RDLogger.DisableLog('rdApp.warning') #this is for cleaner presentation. A lot of messages of the type: [13:19:48] Explicit valence for atom # 3 B, 4, is greater than permitted"
      ],
      "metadata": {
        "id": "iICis9HSUxmE"
      },
      "id": "iICis9HSUxmE",
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#python implementation of bloom filter with fps\n",
        "\n",
        "def create_empty_bloom_filter(size):\n",
        "    return np.zeros(size)\n",
        "\n",
        "def hashed_indexes(h1,h2,size):\n",
        "  indexes = []\n",
        "  for i in range(max(8, min(64, int(size / int(406919/2) * math.log(2))))):\n",
        "     indexes.append(((h1) + i*(h2))%size)\n",
        "  return indexes\n",
        "\n",
        "def add_molecules(fp1,fp2,bf,size):\n",
        "  h1 = int(DataStructs.BitVectToText(fp1),base=2)\n",
        "  h2 = int(DataStructs.BitVectToText(fp2),base=2)\n",
        "  for index in hashed_indexes(h1,h2,size):\n",
        "    bf[index]=1\n",
        "  return bf\n",
        "  \n",
        "def check_molecule(fp1, fp2, bf, size):\n",
        "    h1 = int(DataStructs.BitVectToText(fp1), base=2)\n",
        "    h2 = int(DataStructs.BitVectToText(fp2), base=2)\n",
        "    for index in hashed_indexes(h1, h2, size):\n",
        "        if bf[index] == 0:\n",
        "            return False\n",
        "    return True"
      ],
      "metadata": {
        "id": "HwE9X5X67fX9"
      },
      "id": "HwE9X5X67fX9",
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "054dc242",
      "metadata": {
        "scrolled": true,
        "id": "054dc242"
      },
      "outputs": [],
      "source": [
        "mols = []\n",
        "can_smiles = []\n",
        "for i,smi in enumerate(smi_list):\n",
        "  mol = Chem.MolFromSmiles(smi.split(\" \")[0])\n",
        "  if mol:\n",
        "    mols.append(mol)\n",
        "    can_smiles.append(Chem.MolToSmiles(mol,True))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "4f4b529d",
      "metadata": {
        "id": "4f4b529d"
      },
      "outputs": [],
      "source": [
        "#time experiments\n",
        "fpr_smi = []\n",
        "avg_times = []\n",
        "bloom_size = [10,100,1000,10000,50000,100000,150000,200000,250000,300000,350000,400000,450000,500000,550000,600000,650000,700000,750000,800000,850000,900000,950000,1000000,2000000,3000000,4000000,5000000,10_000_000,100_000_000]\n",
        "split = int(len(mols)/2)\n",
        "for size in bloom_size:\n",
        "  bloom_smi = CustomFilter(size,200000,\"myfilter\")\n",
        "  is_not_smiles = []\n",
        "  timings = []\n",
        "  for i,smi in enumerate(smi_list):\n",
        "    if i <split:\n",
        "        bloom_smi.add(smi.split(\" \")[0])\n",
        "    if i > split:       \n",
        "        start_time = time.time()\n",
        "    \n",
        "    # check if the molecule is in the filter\n",
        "        if bloom_smi.__contains__(smi.split(\" \")[0]):\n",
        "            pass\n",
        "    \n",
        "    # stop the timer and record the timing\n",
        "        timing = time.time() - start_time\n",
        "        timings.append(timing)\n",
        "        is_not_smiles.append(bloom_smi.__contains__(smi.split(\" \")[0]))\n",
        "  avg_time = sum(timings) / len(timings)\n",
        "  avg_times.append(avg_time)\n",
        "  #print(f\"Average time to check a molecule: {avg_time:.8f} seconds\")\n",
        "  fpr_smi.append(100-(len(is_not_smiles)-sum(is_not_smiles))*100/len(is_not_smiles))\n",
        "  #print(size,len(is_not_smiles))\n",
        "  #print(f'false positive rate smiles: {100-(len(is_not_smiles)-sum(is_not_smiles))*100/len(is_not_smiles)}')\n",
        "avg_check = sum(avg_times)/len(avg_times)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "92c98dd0",
      "metadata": {
        "scrolled": true,
        "id": "92c98dd0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ace84bea-d48c-4146-943f-43de351cea28"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[16:09:10] Explicit valence for atom # 7 N, 4, is greater than permitted\n",
            "[16:09:10] Explicit valence for atom # 9 N, 4, is greater than permitted\n",
            "[16:09:10] Explicit valence for atom # 15 N, 4, is greater than permitted\n",
            "[16:09:10] Explicit valence for atom # 4 N, 4, is greater than permitted\n",
            "[16:09:10] Explicit valence for atom # 20 N, 4, is greater than permitted\n",
            "[16:09:11] Explicit valence for atom # 8 N, 4, is greater than permitted\n",
            "[16:09:11] Explicit valence for atom # 37 N, 4, is greater than permitted\n",
            "[16:09:11] Explicit valence for atom # 23 N, 4, is greater than permitted\n",
            "[16:09:11] Explicit valence for atom # 8 N, 4, is greater than permitted\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average time for MolFromSmiles: 0.00024372 seconds\n",
            "Average time for MolToSmiles: 0.00015386 seconds\n"
          ]
        }
      ],
      "source": [
        "total_time_mol_from_smiles = 0.0\n",
        "total_time_mol_to_smiles = 0.0\n",
        "counter = 0\n",
        "for i, smi in enumerate(smi_list):\n",
        "    # Time for MolFromSmiles\n",
        "    start_time = time.time()\n",
        "    mol = Chem.MolFromSmiles(smi.split(\" \")[0])\n",
        "    if mol:\n",
        "        mols.append(mol)\n",
        "    end_time = time.time()\n",
        "    total_time_mol_from_smiles += end_time - start_time\n",
        "    \n",
        "    # Time for MolToSmiles\n",
        "    if mol:\n",
        "        counter +=1\n",
        "        start_time = time.time()\n",
        "        can_smi = Chem.MolToSmiles(mol, True)\n",
        "        if can_smi:\n",
        "            can_smiles.append(can_smi)\n",
        "        else:\n",
        "            print(f'error with {smi}')\n",
        "        end_time = time.time()\n",
        "        total_time_mol_to_smiles += end_time - start_time\n",
        "\n",
        "avg_time_mol_from_smiles = total_time_mol_from_smiles / len(smi_list)\n",
        "avg_time_mol_to_smiles = total_time_mol_to_smiles / counter\n",
        "print(f\"Average time for MolFromSmiles: {avg_time_mol_from_smiles:.8f} seconds\")\n",
        "print(f\"Average time for MolToSmiles: {avg_time_mol_to_smiles:.8f} seconds\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "id": "1a4a6bb1",
      "metadata": {
        "id": "1a4a6bb1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f079d38-158f-4372-cedf-2cc77e1b924c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average mol object generation time: 0.00027642457485198973\n",
            "Average RDKit fingerprint generation time: 0.0012372687524635885\n",
            "Average MACCS fingerprint generation time: 0.0013966258640617764\n",
            "Average Bloom filter check time: 6.72558450106864e-05\n",
            "total average: 0.002977575036388041\n"
          ]
        }
      ],
      "source": [
        "##Time stude for fingerprints \n",
        "# Define the size of the Bloom filter\n",
        "bf_size = 1000000\n",
        "\n",
        "# Initialize the Bloom filter with all zeros\n",
        "bf = [0] * bf_size\n",
        "\n",
        "# Initialize variables to keep track of the total time for each step\n",
        "mol_total_time = 0\n",
        "rdk_total_time = 0\n",
        "maccs_total_time = 0\n",
        "check_total_time = 0\n",
        "counter = 0\n",
        "# Loop through the list of SMILES strings\n",
        "for i,smile in enumerate(smi_list):\n",
        "    # Start timing the RDKit fingerprint generation\n",
        "    smi= smile.split(\" \")[0]\n",
        "    if i >20000:\n",
        "        break\n",
        "    mol_start_time = time.time()\n",
        "    # Convert the SMILES string to an RDKit molecule object\n",
        "    mol = Chem.MolFromSmiles(smi)\n",
        "    mol_end_time = time.time()\n",
        "    mol_time = mol_end_time - mol_start_time\n",
        "    mol_total_time += mol_time\n",
        "    \n",
        "    if mol:\n",
        "        counter +=1\n",
        "        rdk_start_time = time.time()\n",
        "        # Generate the RDKit fingerprint\n",
        "        rdk_fp = Chem.RDKFingerprint(mol)\n",
        "    \n",
        "        # Stop timing the RDKit fingerprint generation and add the elapsed time to the running total\n",
        "        rdk_end_time = time.time()\n",
        "        rdk_time = rdk_end_time - rdk_start_time\n",
        "        rdk_total_time += rdk_time\n",
        "\n",
        "        # Start timing the MACCS fingerprint generation\n",
        "        maccs_start_time = time.time()\n",
        "    \n",
        "        # Generate the MACCS fingerprint\n",
        "        maacs_fp = MACCSkeys.GenMACCSKeys(mol)\n",
        "    \n",
        "        # Stop timing the MACCS fingerprint generation and add the elapsed time to the running total\n",
        "        maccs_end_time = time.time()\n",
        "        maccs_time = maccs_end_time - maccs_start_time\n",
        "        maccs_total_time += maccs_time\n",
        "\n",
        "        # Start timing the Bloom filter check\n",
        "        check_start_time = time.time()\n",
        "    \n",
        "        # Check if the molecule is already present in the Bloom filter\n",
        "        is_present = check_molecule(rdk_fp, maacs_fp, bf, bf_size)\n",
        "    \n",
        "        # Stop timing the Bloom filter check and add the elapsed time to the running total\n",
        "        check_end_time = time.time()\n",
        "        check_time = check_end_time - check_start_time\n",
        "        check_total_time += check_time\n",
        "    \n",
        "    # Print a message indicating whether the molecule is in the Bloom filter or not\n",
        "    #if is_present:\n",
        "    #    print(\"Molecule with SMILES\", smiles, \"is already in the Bloom filter\")\n",
        "    #else:\n",
        "    #    print(\"Molecule with SMILES\", smiles, \"is not in the Bloom filter\")\n",
        "\n",
        "# Calculate the average time for each step\n",
        "num_molecules = 20000\n",
        "mol_avg_time = mol_total_time /num_molecules\n",
        "rdk_avg_time = rdk_total_time / counter\n",
        "maccs_avg_time = maccs_total_time / counter\n",
        "check_avg_time = check_total_time / counter\n",
        "total_avg_fp_time = mol_avg_time+rdk_avg_time+maccs_avg_time + check_avg_time \n",
        "# Print out the average times\n",
        "print(\"Average mol object generation time:\", mol_avg_time)\n",
        "print(\"Average RDKit fingerprint generation time:\", rdk_avg_time)\n",
        "print(\"Average MACCS fingerprint generation time:\", maccs_avg_time)\n",
        "print(\"Average Bloom filter check time:\", check_avg_time)\n",
        "print(\"total average:\", total_avg_fp_time)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "45f2fe5f",
      "metadata": {
        "id": "45f2fe5f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "21080b3e-1c8c-4f2e-fced-79e4fb0e86aa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "100\n",
            "Something bad happened\n",
            "200\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "Something bad happened\n",
            "300\n",
            "400\n",
            "500\n"
          ]
        }
      ],
      "source": [
        "#time test using coconut API with 500 retrievals\n",
        "total_time = 0.0\n",
        "for i,smi in enumerate(smi_list):\n",
        "    if i>500:\n",
        "        break\n",
        "    try:\n",
        "#        if i%100 == 0:\n",
        "#            print(i)\n",
        "        smile = smi.split(\" \")[0]\n",
        "        #print(smile)\n",
        "        start_time = time.time()\n",
        "        page = f\"https://coconut.naturalproducts.net/api/search/exact-structure?type=smiles&smiles={smile}\"\n",
        "        #print(page)\n",
        "        response = urlopen(page)\n",
        "        body = response.read()\n",
        "        todo_item = json.loads(body)\n",
        "        todo_item['count']\n",
        "        end_time = time.time()\n",
        "        total_time += end_time - start_time\n",
        "    except HTTPError:\n",
        "         print(\"Something bad happened\")\n",
        "    else:\n",
        "        pass\n",
        "avg_api_time = total_time/ 500"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "34dc6c61",
      "metadata": {
        "id": "34dc6c61",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 648
        },
        "outputId": "70e1e48b-f650-4919-e3fb-0a650d0c1030"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtcAAAJ3CAYAAABfkn2zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADUTklEQVR4nOzdeXxU1f3/8ddkJpklk33fIYQlBIQA0uKCuAMuWLF1bdVWRMSFqmjrV23VttTigku0qHXFfavVKv5coLRoq0BACHsSIPu+TTKZZCb398eE0QhqwMEAvp+PRx517j333nM/c3P7yeXczzEZhmEgIiIiIiLfWchAd0BERERE5HCh5FpEREREJEiUXIuIiIiIBImSaxERERGRIFFyLSIiIiISJEquRURERESCRMm1iIiIiEiQKLkWEREREQkSJdciIiIiIkGi5FpEflBef/117HY7ixYtGuiuyA+Qrj+Rw5+SaxE5JF1yySWYTKZv/Pn973+/x3Y+nw+v14vX6/3+Oy0/eLr+RA5/JsMwjIHuhIjIvqqoqKCpqSnw+dJLLyUmJoZ77703sCwxMZHExMSB6N4hq6SkhCOPPJKWlhb+8Y9/MH369IHukojIIUXJtYgcFqZMmUJ8fDyvvvrqQHflkNXQ0MCdd95JVlYWJ598MllZWURERAx0t0REDikaFiIih73ly5fvMWRk+fLlfdrs2LEDk8nEQw89RExMDCNHjmT79u0cc8wxREVF8Yc//KFP+9LSUs455xyio6OJiIjgJz/5CcXFxfvVv9///vcMGjRoj+Umk4mnnnqqz7IVK1Zw4oknEhsbS3h4OEceeSRPPPHEHts+++yzjB07FofDQWZmJtdddx3t7e17tPv444858cQTiY6OJj4+nvvvvx+Hw8GoUaP6JNbBPF+A5uZmZs+eTWJiIuHh4Rx99NGsXLlyj3abN2/mzDPPJDIyEqfTyfTp09mwYUNg/b58b0899RQmk4ni4mJOOOEE7HY7gwYN4tFHH92v+E2ZMqXPNVVcXMz1119PQkICJpOJ//73v0D/rr/d+vv9fltcvny+a9eu5Uc/+hHh4eGMGzfua48tIsGh5FpEDntHHnkk69evZ/369bz33nvf2Hbnzp28+eabNDQ08LOf/Yzbb7+dX/3qV/z5z38OjJNtaGjg2GOPZefOnSxZsoR//OMf9PT0MHnyZNra2g7YeWzfvp2pU6eSnp7OP/7xDz766CMuuOACbrzxRt55551AuxdeeIFZs2Zx+eWXs2LFCv7whz/w1FNPcd111/XZX0VFBaeeeipDhgxh6dKl/Pvf/+anP/0pN954I7W1tYF2wT7fnp4ezjjjDD7++GMeffRRli1bxqRJkzj55JPZvn17oF1VVRXHHHMMNpuNN998k7fffpuYmJhAX76sP9/bbn/84x+54YYbeP/99zn99NOZPXs2H3744T7H78knn2T9+vWB5LegoIDExETeeecd1q9fz5gxY4D+X3/9/X73JS4ADz30EHfeeSdLly4lJSWFM888k+rq6m/7mkRkfxkiIoeB4447zpg5c+a3tistLTUAY9myZXtdvnXrVsMwDOOcc84xLrjgAsMwDGPDhg0GYFRVVRmGYRi33HKLkZiYaDQ3Nwe27+rqMnJycozbb799n/v+u9/9zsjKytpjOWA8+eSTgc/PP/+8ARgtLS192n25H4ZhGO3t7cbHH3/cZ9ntt99uJCQk9Fn26quvGoDR0NAQWLZlyxYDMN5///3AsmCf77vvvmuEhoYaO3fu7LP8xRdfNFwuV+DzTTfdZOTl5Rk+ny+wrKenxxg/frwxd+5cwzD27Xt78sknDcAoKyvrc9zp06cbp512WuBzf+O327JlywzAKCgo+NZz/7rrzzD6//32Jy6G8cX51tTUBJY1NjYaZrO5z3UlIsGlJ9ciIl8SGhoKQHh4eJ//Bujs7ATggw8+YOrUqURFRfXZ7qSTTuLdd989YH3Lz8/HarVy3XXXsWLFCurr6wH69APA4XAwadKkPssyMzOpq6vrs2z06NGYzWaeeeYZOjs7aW9v55lnnsHpdDJ69OhAu2Cf77JlyxgyZAiZmZl9lp977rmBWO9ud/TRRxMS8sX/VZlMJiZPnrzH0Ib+fG+7paen9/l8wgkn8Pnnnwc+9zd+XzV58uRvXP9t+vv97ktcgD4v9cbExJCUlERZWdl36quIfD0l1yIi+6i+vp5nn30Wi8XS52fx4sV9hlME24gRI/jwww8DQx8SEhJIS0tj/vz5dHV1Bdq1trZyxRVXkJWVhc1mw2Kx8Ktf/WqP/Q0bNoxXX32VO++8E7vdjtPp5Pnnn+eVV14hKSnpgJ1vQ0NDnyT6m9rt7YXKyMhIGhoa9vm4Xyc8PLzPefQ3fl/ldDq/Uz/6+/1+17iEhobi8/m+U19F5OtZBroDIiKHmri4OCZOnMhvf/vbPdaFhYXt8/7MZnO/6x4fffTRHH300YA/CVy5ciWXXHIJXq+X++67D4Brr72W//f//h/33HMPw4YNIywsjDfffJNbbrllj/0tXbqUa6+9lvPPPx+n00lKSsoebYJ9vrGxsXt9uXJvx93bmO7W1lbi4uL2+bhfp729vc8fE/sSv2Drz/f7fcVFRPaPkmsRkX00ffp0/vGPfzBy5Mg+/zT/n//8hyOOOGKf95eenk51dTWNjY3ExsYC/pfWvmrXrl20tbWRl5cH+J9UTps2jUmTJlFSUhJot2rVKs4++2zOO++8wLJly5btsb/PP/+cJUuW0NbWhslk+t7O98QTT2TRokWUlZWRkZERWP7CCy8wefJk0tLSADjllFN444036OnpCRzXMAxWrFjBcccdt8/H3a28vLzP0JBly5YFXj6E/scv2Pr7/R6ouIhIcCi5FpHDXnt7O6WlpQBUVlYC/tJy8fHxAAwfPnyf9nfdddfx6KOPcs4553DllVcSGRnJe++9x5/+9CdefPFFZsyYsU/7mzZtGna7nYsuuojf/va3dHR08OKLL+7R7pFHHuGhhx7i+uuv5+STTyYsLIxly5bx7rvv8tBDDwXa/ehHP+LNN9/klFNOISUlhcLCwkBFiw0bNpCTk4PNZsNut9PR0cFTTz3F+PHjCQkJwW63k5KSgsPhOGDne+qpp3L00Udz+umn8/vf/560tDTeffdd/vSnP/HRRx8Fkuvrr7+exYsXc9555zFnzhxCQkJ49NFHKS4u5rXXXtunY37ZddddxyWXXEJUVBQvvfQS//znP/uMVe5v/EpLS/tcW1u3bsXlcgH+P5iio6OB/l1/oaGh/f5+D1RcRCRIBvqNShGRYPimaiG7qzl83U9paWmgikNpaalhGIZx8cUXGxdffLFhGMYe6wzDMEpKSoyf/vSnRnR0tOFwOIyJEycaf//73/e7/8uWLTPy8/MNu91ujB8/3igsLNyjWohh+CtqHHvssUZERIQRHh5ujBkzxvjrX//ap01TU5Pxi1/8woiLizMcDodx2mmnGcXFxcb48eMNk8lkFBYWBtqefvrpe8TDYrEYl156qdHd3X3AzrepqcmYNWuWkZCQYNhsNmPChAnGu+++u0e7TZs2GaeffrrhdDqN8PBwY9q0acb69esD6/fle9tdPWPVqlXGsccea1itViMrK8t4/PHH9yt+xx133NdeU1/+3vpz/e3Wn++3P3H58vl+VVZWlvG73/3ua74ZEfmuNEOjiMgP1LXXXktnZycFBQVYLP5/yPR6vRQVFXHUUUfx8ssvc9pppw1wL4Pnqaee4tJLL6Wtre07v3woIvJ1NCxEROQH6tNPPyUkJITly5eTlJSEyWSipaWFjz76iM7Ozj4v+YmISP8ouRYR+YF64oknuOGGG7jwwgsDJdxiY2MZM2YMr7/+OhMmTBjgHoqIHHo0LEREREREJEg0iYyIiIiISJAouRYRERERCRIl1yIiIiIiQaIXGg8CPT091NXV4XA4vnGWNBEREREZGIZh0NHRQUJCQp/Zar9KyfVBoK6u7rCqJSsiIiJyuPrnP//5jaVKlVwfBHZPM/zqq88Q/qUph0VERETk4NDe0cE55/wikLd9HSXXB4HdQ0HCHQ7Cw5Vci4iIiBysvm0I74C/0PjRRx9ht9sxmUw0Nzfv07ZNTU2ce+65OJ1OEhMTue222wh22e7Ozk7mzJlDdHQ00dHRzJ07F4/H06fNSy+9xNChQ7HZbBx11FGsX78+qH0QERERkUPDgCbXn376KTNnzmTBggX7tf0ll1yC1+tl8+bNfPDBB7zwwgs89NBDQe3jTTfdxPr161m9ejWrV69mzZo13HzzzYH1q1at4vLLL+e+++6jvLycadOmMX36dNxud1D7ISIiIiIHvwGbobGiooKxY8dy9913c9xxxzF48GCampqIjo7u1/Y7duxgxIgR1NTUEBUVBcA777zDNddcw/bt24PSR7fbTVxcHGvWrGHEiBEAbNy4kSOPPJLGxkasViuXXnopycnJff5AmDhxItdccw0XXXRRv47jcrmYMmUK777zqoaFiIiIiByE2ts7mDb9HJYvX47T6fzadgM25jo1NZVnn32WqVOnsmPHjn3e/pNPPmHMmDGBxBrg+OOPp7i4mNraWhITEwEoKCjgrrvuoq6ujpNOOom//vWvpKWl7bG/QYMGsXz5cgYNGhRYtnbtWiIiIgKJNcDIkSOJiIhg3bp1TJw4kY8//phFixb12dcJJ5zAxx9/3O/kur98vh68Ph9owno5yJlMEBpqUWlJERH5wRmw5NpkMjF16tT93r68vDyQQO9mt9uJiopi165dJCYm8uabb3Lffffx3HPPkZOTw+OPP860adMoLCzEbDbv1zEAkpOT2bVrFxMnTtxrm+TkZDZs2PC1+/V4PH3Gbbe3t39jPwzDoKGhjTZXx7f2WeRgYTKFkJYaS2io3psWEZEfjkP2//XcbncgQc7JyWHKlCk8/vjjWCyWwHjnu+++m4ULF3LssccCcOutt/LCCy+wYsUKjj/++H06xkknnQTABx980OcYu9s888wzXHnllRQWFvZZvzcLFizg9ttvD3wOCQkhPz+fNYUbsdls5I8dweYtpbjdHiIiHERHRdPS2kF0dDjhDiuYTHi7vQBYbWF0dXVj9BiYQkyEhYXi6ewCwGLxPzns7u4OtO3u8tLT04MpxIQ1LIzOTs/e21rD6O7ubWsyYbV+0dZsMWMOCaGra3fbULq9PfT4fJhMYLPZcLs7/W3NZszmL9qGhYXi8/Xg8/kAsNttdHZ2Yhj+thZLCB7Pt7cNCQkhNNTcp21Pj4HX64+LzWbF09WF0WP424ZZAnEJDQ3FML5oa7VZ6eptawoJIaxPW/+vSHefeHsxemMYFhaG5+ti+C3xDgkx9Y1ht6833t8cQ6s1FK/XH5fvEu8Qs5nQr8a7pwef1/dFDD1dGEZvDEMteDx7j+FX422xmKmuaWLzlp0kJERh9BiUV9QAMOaI4WzfvpP2jk6c4XaGDMlk3edbAEhPTyLEZGJXWTUAo0cNZcfOCtraOrDbrYwYPpjCtZsBSE1NJCzUwo6dlQDkjcyhoqKa5hYXNmsYeXk5rF6zEYDkpHgc4TZKSsoByB2RTU1NPY1NrYSGWhg7ZgSrVm/AMCAxIZbIKCfbt+8CYNiwQTQ2NFPf0IzZHMK4/JGsKdyIz9dDfFw0sXHRbN26A4CcnExaW1zU1jViMsGE8aNYu24z3d1eYmMiSUqKZ9PmEgCys9PpaO+kuqYegPHjRlJUtJ1OTxfRUU7S0pIp2ugf4jYoK5Wubi+VlbUAe9wjBmWlsX7DNgAyM5LpMQzKy7+Id3HxLlztbsIdNnJysr6Id1oSIeYQdu2qAmBU3lB2lVXS2tqO3WYlNzebNYWbAEhJScBmDaN0RwUAI3OHUFlVS3NzG9awUEaPHsaq1UUAJCXF4Qx3UFxSBsCI4YOprWuksbEFi8VM/thcVq0uwjAMEuJjiI6OYNvueA/NorGplfr6JkJCTIwfl0dh4Sa8Ph9xsVHEx8ewpTfeQ4Zk4Gprp6a2EYAjJ4xi3brNdHV7iYmOJCUlno2beuM9OB23u5Oqan+8x+WPZOOm7XR2dhEV6SQjI5kNRf54Z2Wl4u32UtEb77FjRrB12w46OjpxOh1kD07n8/VbAchITwagrNx/zR4xehglpeW4XB04HDaGDR3E2nX+azYtNRFLqIWdvdfsqLwcysqqaWl1YbOFMTI3hzWF/ms2JTkeu91GSWl5b7yzqaqqp6m5lbBQC2PGjOCzVf6HOEmJsTgjwiku9sd7+LBB1Nc30dDYgsVsJj8/l9VriujpMYiPjyE2JpKt23YCMDQnk+bmNurqmzCZTEwYn0fh2k14vT5iY6NITIhl85ZSf7yzM3C1d1BT0wDAhPF5rF+/FU9XN9HREaSmJLJxUzEAgwel0enpoqqqrjfeuWzaVIK700NkZDiZGalsKOq9ZjNT6PH16B6he8RBf4/Y/fv5bQZszPWX7dixY5/HXC9cuJAVK1bw1ltvcfrppzNx4kRuu+02oqOj+eCDD5gwYQKxsbEYhtHnKXVLSwsPPPAAc+bM4eqrr+aFF14A/JVHoqKiAjPu1NfX88orr3DHHXewfv16Zs+eDcDixYsZO3Yst9xyC+eccw7h4eGsWLGCmpoabrvtNt58801eeeUVPvjgA95+++299n1vT67POOOMvY659vl62FVWS0xMBNFR4f2OqchAc7nc1NW3kJGegMXy7f9SJCIicjA76Mdcf1dpaWnU1fn/It6dxHZ2dtLS0kJmZmag3ZIlSxgzZkyfbXcn8HfccQc33XQTAJMmTeKVV14hPT19r8dYvHhxYHlNTU3gGLvbTJ8+nenTp++xfm+sVitWqzXw+Zum0PT2PnG0WUO/to3IwWj3U39fTw8WlFyLiMgPw4DXue6P1tbWPZZNmjSJdevW9Vm3bNkysrOzA2Og8/LyqKmpIT09PfBTV1cX+GsjJiYmsNxsNpOcnBz4DJCfn09raytbt24NHGPTpk20trYGEvajjjqKFStW9OnbRx99xKRJk4Jz8r3/rqAXw+SQNeD/NiYiIvL9GdDkurq6mvLycqqr/WOnKisrKS8vp6mpKdDmmWeeISoqiiVLlvTZdvDgwZxyyilcdtllVFRUsGHDBubNm8e1114baHPDDTdw66238t5771FbW8tDDz3Eqaeeisvl6lf/7HY7s2bNYtasWZSWllJSUsKsWbOYPXt24MnzVVddxcMPP8y7775LQ0MDCxYsoLKykpkzZ37X8IiIiIjIIWZAh4X8+Mc/ZufOnYHPeXl5AFx88cU89dRTAISHh2Oz2fY6j/uTTz7JFVdcwfDhw3E4HFxxxRVcffXVgfUzZsygoqKC2bNnU1NTw7hx41i6dOlex8l8XTnAu+66i3nz5pGfnw/ABRdc0Kem9YQJE1i8eDHXXHMNZWVljBs3jnfeeedb550Hf5nAgoICABwOx15faHQ6HVitdtzuTrxeL2FhFgygu8v/Ipnd7n/prKfHICTE/+Kh2+0fz727FNrul9vsditdXd34fD2EhJiw2ax0dHTuta3NZqW729/WZDJht3/R1hLqf6Fx94twNlsY3V4fPq//BTuHw47L1cGf/3wPzy55AbfbzcknncBf/vJHkpIS8Pl8/Otf/+HiSy6nqnI7HR1uDAMsFjMWi5nO3pcJrVb/y3her4/rr/8tn366iv/85/3elx/9L9h9uW1PjxF48dDhsOHu9GD0GJjNIYSFhQbiEhbmfxlvd1u73YbH4+mNYQhW65fb+n9FuvrEu5uenp7eeFtpbW3jjjv/zCuvvI5hGJxyyoks+NPtJCTEBeJtCjFh/0q8Q0JMfWPY7e2Ntz+G7e3+l2ItFv9Lil9u6/X68H4p3s3NrfzlL/fx+hv/oLa2jszMdC695OdceeUsenr8MQQID7cH4m22mAn9arx7evj3io85//xLeOONFxg3Lr/3vYUQQkNDAy9kfjWGDoeNzk5/DL+IdyceTzcNjc2YQC8r6WWlg/5lJb3QqBcadY/QPeKweaHxh+6bJpHxeLqprGogNSUO65fGXb/9z+Xfax9PP23KPrV/8KG/8sTfnuXZZx8jJiaa66+/mZCQEJ5//gkAVqxYyXnnX0JlxbZ+7e/Pf76XNYVrefmlZ/a16wfcbb/7Ax99tIKCgnuJiozg6mvmk5AQzxN/e/h768Mf/7iQN/7+Fo8ufoDMzAz+97/PuGLOPBYu/APnnXvOPu1r3ecbmDNnHn/96/0cMTpvv/v0ddeuiIjIoeiwf6FRDm6PPPI4Dz54D6NGjQTg0UcfJHvIaMrLK0hP33MSn2/zm99cF+wuAnD++Zdy770LSElJ3q/tu7q6ePTRJ3n//X8wepQ/EX3ssYe4994HMQzjexsrv/S9D7j22isZN24sAKedNpV/r3iPjIz0b95wL8YcMYqPV34Q5B6KiIj8MBwSLzTKoaWquoadO8s49pgvXuqMjIxgzJhR/O9/q/q0ffvtdxmRO57EpMH8+te/CdRjBgh3JvX5uXz2NUHva0JCPBOOnMxjjz3F/vwjzuefb8AaZg0k1gDJSYn85a47A4n19u0lzDjrPJKSsxmScwS3376gz7FWrFhJatpQnn/hFQZnjyJ7yGgKCh7dp354vV6ampr7LBs0KCtQhnLq1J9w8//dTnLKEK6//rfcfc8DJCVn86c/3R1of/nsa/rEe+fOXfsaDhERkR88JdcSdJUVlTid4YSFhfVZHh8fR1l5ReCz293J5i3bWL78Xf7+xou8u/R9nn32hcD6muqSwM+cOZcdkL4+8MBC3nj9eR7/29OcdPIZbNq0ZZ+2LyurICEx/hvb3H//w5xy8gkUbfiM119/nldefYOXXn6tTxu3u5OGhgb++8lH3L/oLm7+v9tZu259v/tx9k/O4I9//AsLFtzDp5+u6lNHfTeb1cpHH/6Tp595gfi4WJ5//kke/9vTgfUPPrCQmuoSSor7f1wRERHpS8m1BJ3b3bnX6eUtZgudvTMJgr++93W/vorkpESOOupHzL/hWl544dXAeqczPPATGnrgxuxOnDiBlf95n9NPn8bJp5zZ52nut3F3dmKxfPPoqgcfvJu5cy8nPj6OMUeMYtq0U/jk40/7tDGbzVw1dzZJSYmcccZ0fjRxAh+v/G+/+3HDDddy883zee21NznhxNMZNDiP3/3+j/T09ATaHHfcMYwcOYKYmGimTDmW4yYfTV1dfWC91WrF6QwnPFyTFYmIiOwvjbkeQN+lWsj3zTCMflcLsdtteL0+2tvdvZUuzHg8XXR6PIRZw/z/3ekhLCyUkJCQQPWKzMwMduzcGaiS8eVqIburUgQqXfSzWsirr/ydm35zKyaT/xzOPnsGi+67a49qId3dXi6f9UssZgt/vuserr12LvDt1UJsVivdXd20t7u/tjrL2rWf8+e77mXr1m20tblwu92cddYZeL1ePJ7uQCw8nq5AtZCEhHhqauu+FMNvrhbS0dHJZb+6hCtm/4qODjdvvfUuN950C1mZmVx44bn4enyBqcvN5hDcbg9eXw89PT19493TQ3uHu893rmohqgQAP4xKAKoWomohukfoHqFqIYeJw61aSFVVNTlDx9DUWNZnaMiJJ53OlXNmMXPmjL1WC1m+/N/MvuJatmxes8c+f3vz72loaOTRxQ/sU787Ojr6jEV2OBzExETv0a6ysor582/h8/UbeOD+hRx//OR+7X/VqjXMnHkRO3fu/RfOMAyGDc/nZz87m4t/cQHh4Q7uuus+Oj2ewLnsLRYXXvgrRo4cwf/93/z+n+xX3HDDzTQ2NfPE3x72j7m++QYmTz6a3JETWPru62RlZRLuTKLdVdNnO5ernaTkbDYWfUZW1tfPNPptVC1EREQOJ/2tFqJhIRJ0KSnJZGZm8J+VnwSWtbW5WLduAxMnjg8s89fn/mLYQnFxKYO+QzK3Nw6Hg7S01MDPVxNrn8/Hww8/xo9+fDzZQwbx6f+W9zuxBjjiiFF4ujys31AUWFZdU8uNN92KYRjU1zdQWVnFvGuvZNiwHNLSUr9xuvv99eqrf+/zMij4h6zE7uUPCRERETlwNCxEDogrr7yM+TfcwrPPPkZ0dBTz59/CyScd36c0XE9PD/fe9xAXXXQepSU7WHj3/dx047zvtZ/HTZmG2RzCO++81qfiR3+FhYVx+eWXMmfOr3n44fuIjHBy7bybiI2NwWQyER8fR2JiAi++9CrnnXsOn322mqXvfcBRR/2Irq6uPV763B/t7e3cfscCXnzpVW699TekpiSzYsVKXn75dd78+0v93o/H46G720t7ezvgH4LjcrUTFhYalH6KyOFnofORge6C/MDNd80Z6C7sQcn1IWpfJ3X5vs298nIaG5qYNv1s3G4306aezKJF9/RpY7fbGDF8KMcdN5WmpibOP++n/OIXF3yv/Tz/vHOYM+ey7/Q0+dZbbqKz08Npp82kp6eHqVNP5r57/wyAyWTiySce4brrfsvvf7+AY46ZxBN/e5ifnfsL/u+WO1j4lz9853MIDw/ng/ff4pZb7+TMM39GR0cHQ4fm8PhjBRx11I/6vZ+rr5nPc899kYxPONL/BP/m397wnYaniIiI/JBozPVBYH/GXP/Q7O+Yaxk4unZFDn96ci0D7ft8cq0ZGuWQ19HRQU+P/2+/7u5unCoRJyIiIgc5JdcD6LuU4uvuUxqui54eg5AQE1ZrGG63v1za15WG8/l6y8jZrIHyel9ta7NZ6e7u7i0NZ8Jut/a7FJ/DYQ+Ud/tyKT4AqzUMn89fRg4gPNweKK9nsZixWMyB8noTJhzLrjJ/WaSEhHhee3XJPpfiM/qUhtt7GTm73YbH4+mNYQhW65fbfnMpPqvVitu99xh+Od6mEBP2r8Q7JMTUN4bd3kApvj1j+M2l+PYn3maLmdAvxXt3KT5vt++LGLo9KsWnMlvAD6PMlkrx7XspvpTZKViiLLi3u2lZ2ULyxf54NL7TiCXGQuSkSADKF5WT9PMkQuNC6dzZSdP7TaRclgJA0/tNmKwmoidHA1BRUEHCzATCksPwVHpoeLOB1DmpADQvb8bwGcScGANA1WNVxE6NxZphpbuum9oXakm7Jg2AlpUt+Np8xE6NBaD6yWqiJkdhH2LH2+Sl6okqMq7PAKD101a6a7qJOyMOgJolNUQcGYFjuANfu4/KgkrS56djMplwFbroLO0k/mz/BGK1L9USnhdO+Khwerp6qFhUQdq8NELCQmjf0E57UTuJ5yYCUP96PbbBNpz5TgzDoHxhOalzUzGHm+nY0kHbZ20kXZQEQMNbDYQmhRI50R/DsnvKSPllCpYYC+5iNy0rWki+tDfeSxsxR5iJOjrKH8MHKkg8P5HQhFA8ZR4alzaSMqs33h82YTKbiJ7ij3flI5XEzYjDmmqlq7qLutfqSJvrj2HzimYMj0HMyb3xfryKmJNjsGXZ6G7opubZGtLn+d+lav2kFW+Tl9jpvfF+upqoo6Ow59jxtniperSKjPn+eLd91oan0kP8DH8Ma56rIWJcBI5cBz63j8oHK0m/Ph2T2YRrnQv3djcJMxMAqHulDvtwO84jnBjd/gdwKsUne9CwEDkc6doVOfxpWIgMtINxWIhK8YmIiIiIBImSaxERERGRIFFyLSIiIiISJEquRURERESCRMm1iIiIiEiQKLkWEREREQkS1bkeQIdznevq6lru/MNdvLf0fZqaW8jJyeaqubM5//yf9rvOtdUais/XwwsvvsqNN97C//77EUlJSYdcnesr5/6aqKgo7r3nT99a57qltY0JE47hmmvmcOWcy/3xVp1r1blWnWvVuVada0B1rlXnWnWupZ/2p871wru/39qi82/YtzqSl8++hl07y7j33gXEx8fx3v/7kHnzbuLtt15h0qSJ+7Sv9/7fh9x551288sqzpCQn7dO2B4PLZ19DVFQkC//yh29t6/F4mH7aTC6++EJ+8fPzv4feHTiqcy1y+FOdaxloB2Odaz25lgPivaUf8OyzjzFy5AgAfn7ReUz68URycrL3eV+nnnIip55yYrC7CMD551/KvfcuICUl+YDsf19ZrVY+/ODtge6GiIiI7CeNuZYDwuvz0tTU3GfZlxPr3JET+N3v/0hC4iDuW1TAvHk3kZwyhKeffi7QZurUnxDuTAr8HAgJCfFMOHIyjz32FPv7jzjFxaWcfsZPiY3LZOiwsTzw4F/3aNPj83HttTeSmDSY3JETeOed9wLrnl3yYp/zDHcmsWLFyv0+JxERERk4Sq7lgPjJWWdw7bwbuf+BRyhc+zler3ePNlmZGbz00tMsWHA3U6eexF1/voOnvpRcv/HG89RUl7DiX0sPWD8feGAhb7z+PI//7WlOOvkMNm3ask/b9/T0cO65F/PjHx1J0YZPeW7J4/ztb0/z+uv/6NPuw4/+xYyzTuPzz//HlVdexiWXXkFzcwsA5593DjXVJYGfuNjYoJ2fiIiIfL+UXMsBce+9C7j0kot49NEnOOaYkxmScwQPFSzu0+aEE45j8rFH097ewamnnsQxxxxFXV19YL3dbsfpDMdmsx3Qvk6cOIGV/3mf00+fxsmnnMmf/nR3v7f9aNkKenp6uOWWG0lJSWbixAn87rbf7nGuxxw9iROOP47kpESuvuoK8vJy+cdb7wBgsVhwOsMDPyIiInLoUnItB0RYWBi/+91vKdrwGbt2buL/bp7P//3fHSxbtiLQxmQyYbFYvvTfZny+nqD246WXXyM1bWjgZ968m/bazmKx8Ot5c7nl/26k4OFH+73/LZu3kj1kUJ9lOUOHsHXr9j7L7A57n89DhmSzc8eufh9HREREDg16oVEOuLi4WC6//FLe/+AjVqxYyfHHT/7ejn3G6dM45uhJgc8Oh2Ov7Sorq5g//xY+X7+BJc8+/p2PqyI8IiIiP0x6ci1B19PTwyuvvLHHcre7k5jYmO+1Lw6Hg7S01MBPTEx0n/U+n4+HH36MH/34eLKHDOLT/y3fp+R/2PChFG8v7bNs+7Zihg3L6bPM3eHu87m4uISsQZn7djIiIiJy0NOTawm66uoarr/+Zj78aDnX/fpqoqIi+cc/3uHTT1fxwP0L+70ft9uNz9dDZ6d/4hWXqx3wT3CzezjJd3XclGmYzSG8885rjB6Vt8/bn3jCcYSEhPCHP/yFX112MWW7yrjjzj9z262/6dPuPys/4aNl/yJvZC4vv/I6RUWbOPOM6UE5BxERETl4KLkeQN9lhsYr51wCfH8zNBqG0e8ZGlNTU/jnP1/jjjv/zPEnTMfn8zFixHCeW/IEmZkZeDxdGEZPYH8A7e3u3mMbgdkGzz77fP6z8pNAm6Rkfym/B+5fyIUXnhuUGRpnnj2Dq6++gu7ubtrb3fs1Q+NTTz/KjTfewr33PURcXAyzZ1/GqaeeTE9PD11d3Xi9XiZPPoa///1tzv3ZxcTGxfLo4gdxOsMD57p7hkafrwcDIxAT0AyNmqFRMzRqhkbN0KgZGjVDo2ZolH2yPzM0yuErMzOXJUseZ/Lkowe6K9+Jrl2Rw59maJSBphkaRWQPPp8Pt7uzzzKV5BMRETk06YVGkQG2cuV/SUrOJik5m+SUIYw+Io8xY0YPdLdERERkP+jJtcgAmzz5aNpdNQPdDREREQkCPbkWEREREQkSJdciIiIiIkGi5FpEREREJEiUXIuIiIiIBImSaxERERGRIFFyLSIiIiISJCrFN4C+y/Tn3X2m4z7w05/b7dZ+T3++ezrupUvf549/WsiuXbvIHTGcP/zhdxx99I/x+Xz861//4eJLLqeqcntgOm6LxYzlq9Nx+3r2PnW3OaRf058nJGSxfNm7jB8/dq/Tn/vjYsPj8fTGcN+nP989Acw3xdsUYsL+lXiHhJj6xrB3+vO9T2mu6c81/bmmP9f055r+XNOfa/pzTX8u/bI/0587wpO+1z52tO9bHeaiok2cdPIZLFp0F5MnH8Pf33iLPy24m9Wr/k1iYgIrVqzkvPMvobJi2wHqsV+4M4mPP/6QMUeMOqDHkT1p+nORw5+mP5eBpunP5Qdj8eIn+MUvLuDcn80EYM6cy6ivb6C5uYXExIQB7p2IiIjIgaEx13JArFz5X46fcmyfZbfeehPDhuX0Wfb8C68wOHsU2UNGU1DwaJ91TU3NXHLpFSQmDSZr0EgWLlxET09PnzZLl77P+PHHEhuXyTHHnsLq1YVf2yfDMJh71XWccebP8Hg83/EMRURERPakJ9dyQJSVl3/rE2q3u5OGhgb++8lHfPrpKi76+SyOPmYSY8eMBmDOnHlERkWy6rMVtLW5uHbejZgtFq779VUA7Ny5i19dNpcHH7ibY46ZxLtL3+eCC39F0YZPsVj2vLSvu+63bN2ynTfffBGr1Rr8kxYREZEfPCXXckC43Z2Y95LgfpnZbOaqubMxmUycccZ0fjRxAh+v/C9jx4ympGQHH3/8P0pK1gcS5T8vuJ2Lfj4rkFw/8eSz/OynZ3P22WcCcPEvLmDqqSftNbG+6Te38dmqNbzzz9dwOBx7rBcREREJBiXXckDY7TZ8Xu83tgkLC8VkMgU+JyTE09TUDMCmTZtpbmkhO3t0YH2P0UNTUzMdHR04HA62bN7G0cf8uM8+k5IS9zjOgj/dzdL3PuDqq2cTGRnxHc5KRERE5JspuZYDIiM9ndrauu+0j+zsQfzz7Vf3WG632wEwMOhPrZs2l4uPPnybU6eexYwzT2PChHHfqV8iIiIiX0cvNMoBcdRRP2LZ8n/3WXbnnXexbVtxv7YfMWI4lZVVREZGkpaWSlpaKpGRkXg8XYGn3Tk5QygpLu2zXUnJjj329cc//o5x48Zy003Xcfnl19DZ2bl/JyUiIiLyLZRcywFxxRW/4plnnufll1+nuqaWxYufYPGjT/R7WMaQIYM54fjjuPzyq9m2rZji4lIu/eUV3Hvvg4E2sy67mFdefYPXX/8HtbV1vPHGWxx/wvTA0JLddifjv543F2dEOLf97o9BO08RERGRL9OwkEPUvk7q8n3Ly8vl8cce4tZb/8CcK3/NiBHDeO3VJXsdE/11HnlkEddd/1uOOfZkQkND+clZZ/CXv9wZWD9oUBYvvvAU8+bdROmOnQwdOoRnnn6UmJjove7PbDbz6OIHOebYUzjzjOkcc8yk73qaIiIiIn1ohsaDwP7M0ChysNO1K3L40wyNMtAOxhkaNSxERERERCRIlFyLiIiIiASJkmsRERERkSDRC40DqKCggIKCAgAcDgdrCjdis9nIHzuCzVtKcbs9OJ0OrFY7bncnXq+XsDALBtDd5Z+gxW634vF00dNjEBJiwmoNw+32ABAaasFkMtHV1R1o29XVjc/XQ0iICZvNSkdH517b2mxWurv9bU0mE3b7F20toWbMISF4PLvbhtHt9eHz+jCZwOGw097u9re1mDGbzXg8XQBYrWH4fD68Xh8A4eF2OjrcGIa/rcViprNzd9tQfL6evbY1m0MIDbX0advTY9Dd7e2Npw13pwejx8BsDiEsLDQQl7CwUAzji7Z2uw2Px9MbwxCs1i+39f+KdPWJdzc9PT298bbidu89hl+OtynEhP0r8Q4JMfWNYbe3N957i2HfeHu9/hh+l3ibLWZCvxrvnh683b4vYuj2YBhGb7xD6ezcewwdDhudnf4YfhHvTjyebhoamzEB5RX+l3DHHDGc7dt30t7RiTPczpAhmaz7fAsA6elJhJhM7CqrBmD0qKHs2FlBW1sHdruVEcMHU7h2MwCpqYmEhVrYsbMSgLyROVRUVNPc4sJmDSMvL4fVazYCkJwUjyPcRklJOQC5I7KpqamnsamV0FALY8eMYNXqDRgGJCbEEhnlZPv2XQAMGzaIxoZm6huaMZtDGJc/kjWFG/H5eoiPiyY2LpqtW3cAkJOTSWuLi9q6RkwmmDB+FGvXbaa720tsTCRJSfFs2lwCQHZ2Oh3tnVTX1AMwftxIioq20+npIjrKSVpaMkUbtwMwKCuVrm4vlZW1AH3uERERDgZlpbF+wzYAMjOS6TEMysu/iHdx8S5c7W7CHTZycrK+iHdaEiHmEHbtqgJgVN5QdpVV0trajt1mJTc3mzWFmwBISUnAZg2jdEcFACNzh1BZVUtzcxvWsFBGjx7GqtVFACQlxeEMd1BcUgbAiOGDqa1rpLGxBYvFTP7YXFatLsIwDBLiY4iOjmDb7ngPzaKxqZX6+iZCQkyMH5dHYeEmvD4fcbFRxMfHsKU33kOGZOBqa6emthGAIyeMYt26zXR1e4mJjiQlJZ6Nm3rjPTgdt7uTqmp/vMflj2Tjpu10dnYRFekkIyOZDUX+eGdlpeLt9lLRG++xY0awddsOOjo6cTodZA9O5/P1WwHISE8GoKzcf80eMXoYJaXluFwdOBw2hg0dxNp1/ms2LTURS6iFnb3X7Ki8HMrKqmlpdWGzhTEyN4c1hf5rNiU5HrvdRklpeW+8s6mqqqepuZWwUAtjxozgs1Ub/PFOjMUZEU5xsT/ew4cNor6+iYbGFixmM/n5uaxeU0RPj0F8fAyxMZFs3bYTgKE5mTQ3t1FX34TJZGLC+DwK127C6/URGxtFYkIsm7f4S54Oyc7A1d5BTU0DABPG55EyOwVLlAX3djctK1tIvtgfj8Z3GrHEWIicFAlA+aJykn6eRGhcKJ07O2l6v4mUy1IAaHq/CZPVRPTkaAAqCipImJlAWHIYnkoPDW82kDonFYDm5c0YPoOYE2MAqHqsitipsVgzrHTXdVP7Qi1p16QB0LKyBV+bj9ipsQBUP1lN1OQo7EPseJu8VD1RRcb1GQC0ftpKd003cWfEAVCzpIaIIyNwDHfga/dRWVBJ+vx0TCYTrkIXnaWdxJ8dD0DtS7WE54UTPiqcnq4eKhZVkDYvjZCwENo3tNNe1E7iuf6X+etfr8c22IYz34lhGJQvLCd1birmcDMdWzpo+6yNpIuSAGh4q4HQpFAiJ/pjWHZPGSm/TMESY8Fd7KZlRQvJl/bGe2kj5ggzUUdH+WP4QAWJ5ycSmhCKp8xD49JGUmb1xvvDJkxmE9FT/PGufKSSuBlxWFOtdFV3UfdaHWlz/TFsXtGM4TGIObk33o9XEXNyDLYsG90N3dQ8W0P6vHR/DD9pxdvkJXZ6b7yfribq6CjsOXa8LV6qHq0iY74/3m2fteGp9BA/wx/DmudqiBgXgSPXgc/to/LBStKvT8dkNuFa58K93U3CzAQA6l6pwz7cjvMIJ0a3/7XB7+sesfv389vohcaDgF5olMORrl2Rw59eaJSBphcaRUREREQOY0quRURERESCRMm1iIiIiEiQKLkWEREREQkSJddyQEyd+hPCnUl7/Dy75MU92p4541xmnHXeAPTy+1VSsoOk5Gxeevm1/dr+rbfe4ceTTtivbVesWNnnexg0OI/f/f6PfPl95tyRE/b6na1YsXK/jikiIvJDpFJ8h6il5b7v9XhT0837vM2dd97K5bMu7bPMZrPu0W5QViYhIYf/33l2u42hQ3OIjY0dkONHRUWydctaAEp37OC88y5hVN5IfvrTnwTaPPXkX5k27ZQ+29nttu+zmyIiIoc0JddywISFheJ0hn9ruwceWBiU4637fAMzZ17I0Jxs3n33jaDsM5hSUpL5z7//335vX1ZW8Z37sPv7GD0qj5/85Ew+WvavPsm1zWbt13cmIiIie3f4Py6Ug9LOnbv6DD24fPY1e7TJHTmBgoJHOW7KVJKSsznvvEtoamru0+ZPf7qbYcPziYvP4mc/+wWL7vszTz/9aGD9+g1FnHTyGcTGZTJm7CT++c+lfbb/ch/e/2AZF18ym4TEQcw850IAnl3yIlOOn8bixU+QNWgk6RnD+ctf7gts/9XhFqWlOzjhxNOIik5j0f0PA/DHPy78xmEWK1asJDVtKM+/8AqDs0eRPWQ0BQVfnMPuITbzb7yF9euL+uzruzCbQwKTy4iIiEhwKLmWAZGZmUFNdQk11SXMmXPZ17Zb/q9/89ijD7HyPx+wc1cZf1pwd2Dd8y+8wosvvcobrz/PxqLPmD7tFJ5d8iKJif5ZnNxuNzNnXsTZPzmToqLPWHTfXVxz7Y189tnqwD529yEuNpYXX3yVCy88l+3bPue5JX8LtCkt2YnNZuWzT//F4489xP0PPMK//vUfAI4++sfUVJew4l/+pH3JkpdYtOgvVJRvZe6VswCYP//aPsfZG7e7k4aGBv77yUfcv+gubv6/21m7bj0Ab7zxPDXVJTxw/0Ly8nID+6qpLtmf0APQ3NzCe+99yFkzTtvvfYiIiMieNCxEDpg77vgzf7lrUeBzuDOcTRtXAWAymQLDD0JDv372vp/99GyGDcsB4IorfsXixU8E1n326WpOOvF48vJyAbjk0os49dQZgfUvv/w6Y8eO5sreJDclOYm5cy/n0cee4sgjxwP0GQJx5IRxnHLyni8MJiUncvHF/ifZU6eezK9+9Quee/5ljjvuGMxmM05nODabf1zy2WefGejPbmFhYYSFhX1TqDCbzVw1dzYmk4kzzpjOjyZO4OOV/2XsmNHY7Xb/fqxhhISE7PewjdbWNjIz/X1rbmlh5swZTJ9+ap82sy6/mrDQ6wOfhw8fyvvv/2O/jiciIvJDpORaDph5187l4osvCHzen5cWv/wCZGJCfJ9hIbm5w3nyqSW0tLQSFRXJu+/8P4YPHxpYv3HTFj788F+BhBLA0+VhxIhhez3W1y13OOx9Pg8Zks3//rtqr21zc4d/6zntTVhYKCaTKfA54SvnGgwREU4++eRDwJ9o/+EPf+Haa2/sM+b9rj/fwUknHR/4bLHoFiEiIrIv9P+ccsBERkWQlpZ6wPb/y1/+nP/+7zMyMkcQFhbG4MFZPPnEI33azJw5g9/d9ps+y77uSXkwKpYczFVPTCZT4PtIS4NbbrmRSUedyH33/Rmz2V8NJjY25oB+ZyIiIoc7JddyyCosXEdjYxMbiz7D6XQSHR3VZ/3I3OE899zLfZLF7dtLiIqK+uquvlFHh7vP5+LiErIGZe5/xw8SJpMJi8XS54m5iIiIfDcH72M2OawZhoHL1Y7L1U53dzderzfwub9W/PtjoqIisVqtWCwWuru7+6z/6U9/QknpDv7853uprKzi009XMfOcC/nnO19UDPnyMd2dnXvtQ3l5BU8//Ry1tXUsfe8D/va3Zzj/vHMA8Pl8uFztdHZ29tmf2/1FQt7V1bXX43g8nn2IGDjDwzEMg87OzsDPvtrdj6rqGu5/4GFOPeXEg/ppu4iIyKFGT64PUfszqcvBZNeuMkbmHdln2Usv+WcubHfV9GsfZ804nT/96W5effXvgP9J7NCcITzwwEKOPfYoHA4Hf3/jBa677rf8ZeEiEhMTuOqqyzn3ZzMD+0hKzg7899lnfzE+/Mt9yMzMwOVqZ8KEyfQYPVx91RUcf/xkAFau/C/Tpp+9x/6OPeYoli7119peuPD+PlVOdh/nwgvP5dHFD/TrXAFOOOE47r7nAeLis/baz2/T0tIa6J/NZuPEE4/joQfv6ff2IiIi8u1MxpfnP5YB4XK5mDJlCu++8yrh4Y4+6zyebiqrGkhNicNq/fqqGj9EPzn7An77m+uYOHECAN3d3bz62ps8/PBj/HvFe0E5xrNLXqSg4FH++8lHQdnfD4muXZHD30LnI9/eSOQAmu+a870dq729g2nTz2H58uU4nc6vbad/D5ZD1upVhWzbXkJTUzMuVzs1NbUUFW0iPj5uoLsmIiIiP1BKruWQtXjx/Sxe/DdyR44nI3MEU46fTkVFJQ8X3DvQXRMREZEfKI25lkPWtGmnMG3aKQf0GD+/6Dx+ftF5B/QYIiIicvhQcj2ACgoKKCgoAMDhcLCmcCM2m438sSPYvKUUt9uD0+nAarXjdnfi9XoJC7NgAN1dXgDsdiseTxc9PQYhISas1jDcbn8VitBQf5m1rq7uQNuurm58vh5CQkzYbFY6Ojr32tZms9Ld7W9rMpmw279oawk1Yw4JwePZ3TaMbq8Pn9eHyeSfdKW93V8tw2IxYzab8Xi6ALBaw/D5fHi9PgDCw+10dLgxDH9bi8VMZ+futqH4fD17bWs2hxAaaunTtqfHoLvb2xtPG+5OD0aPgdkcQlhYaCAuYWGhGMYXbe12Gx6PpzeGIVitX27r/xXp6hPvbnp6enrjbcXt3nsMvxxvU4gJ+1fiHRJi6hvDbm9vvPcWw77x9nr9Mfwu8TZbzIR+Nd49PXi7fV/E0O3BMIzeeIfS2bn3GDocNjo7/TH8It6deDzdNDQ2YwLKK/wvX445Yjjbt++kvaMTZ7idIUMyWff5FgDS05MIMZnYVVYNwOhRQ9mxs4K2tg7sdisjhg+mcO1mAFJTEwkLtbBjZyUAeSNzqKioprnFhc0aRl5eDqvXbAQgOSkeR7iNkpJyAHJHZFNTU09jUyuhoRbGjhnBqtUbMAxITIglMsrJ9u27ABg2bBCNDc3UNzRjNocwLn8kawo34vP1EB8XTWxcNFu37gAgJyeT1hYXtXWNmEwwYfwo1q7bTHe3l9iYSJKS4tm02T9tfXZ2Oh3tnVTX1AMwftxIioq20+npIjrKSVpaMkUbtwMwKCuVrm4vlZW1AH3uERERDgZlpbF+wzYAMjOS6TEMysu/iHdx8S5c7W7CHTZycrK+iHdaEiHmEHbtqgJgVN5QdpVV0trajt1mJTc3mzWFmwBISUnAZg2jdEcFACNzh1BZVUtzcxvWsFBGjx7GqtVFACQlxeEMd1BcUgbAiOGDqa1rpLGxBYvFTP7YXFatLsIwDBLiY4iOjmDb7ngPzaKxqZX6+iZCQkyMH5dHYeEmvD4fcbFRxMfHsKU33kOGZOBqa6emthGAIyeMYt26zXR1e4mJjiQlJZ6Nm3rjPTgdt7uTqmp/vMflj2Tjpu10dnYRFekkIyOZDUX+eGdlpeLt9lLRG++xY0awddsOOjo6cTodZA9O5/P1WwHISE8GoKzcf80eMXoYJaXluFwdOBw2hg0dxNp1/ms2LTURS6iFnb3X7Ki8HMrKqmlpdWGzhTEyN4c1hf5rNiU5HrvdRklpeW+8s6mqqqepuZWwUAtjxozgs1Ub/PFOjMUZEU5xsT/ew4cNor6+iYbGFixmM/n5uaxeU0RPj0F8fAyxMZFs3bYTgKE5mTQ3t1FX34TJZGLC+DwK127C6/URGxtFYkIsm7eU+uOdnYGrvYOamgYAJozPI2V2CpYoC+7tblpWtpB8sT8eje80YomxEDkpEoDyReUk/TyJ0LhQOnd20vR+EymXpQDQ9H4TJquJ6MnRAFQUVJAwM4Gw5DA8lR4a3mwgdY6/pGrz8mYMn0HMiTEAVD1WRezUWKwZVrrruql9oZa0a9IAaFnZgq/NR+zUWACqn6wmanIU9iF2vE1eqp6oIuP6DABaP22lu6abuDP8wwprltQQcWQEjuEOfO0+KgsqSZ+fjslkwlXoorO0k/iz4wGofamW8LxwwkeF09PVQ8WiCtLmpRESFkL7hnbai9pJPDcRgPrX67ENtuHMd2IYBuULy0mdm4o53EzHlg7aPmsj6aIkABreaiA0KZTIif4Ylt1TRsovU7DEWHAXu2lZ0ULypb3xXtqIOcJM1NH+UrMVD1SQeH4ioQmheMo8NC5tJGVWb7w/bMJkNhE9xR/vykcqiZsRhzXVSld1F3Wv1ZE21x/D5hXNGB6DmJN74/14FTEnx2DLstHd0E3NszWkz0v3x/CTVrxNXmKn98b76Wqijo7CnmPH2+Kl6tEqMub74932WRueSg/xM/wxrHmuhohxEThyHfjcPiofrCT9+nRMZhOudS7c290kzEwAoO6VOuzD7TiPcGJ0+18b/L7uEbt/P7+NXmg8COiFRjkc6doVOfzphUYZaHqhUURERETkMKbkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItB0TuyAmEO5P2+Nm5c9c+7eett97hx5NOOEC9DJ6HChZz7nkXD3Q3Dqhnl7x4SHwXIiIiA0ml+A5R3/cb2vv6Nu7qVSvo6TFYePciioo28dSTiwH2qIYiIiIicjhRci0HhMPhT6LDQsMwm804neH7tZ+ysopgduuAKS+vHOguiIiIyEFAw0JkQKxYsZLUtKE8/8IrDM4eRfaQ0RQUPBpYP3XqTwh3JjH/xltYv76oz9CSL1u8+AmGjxhHXHwW5/z0IiorqwLrnl3yYmCb3JETWLNmLRN/NIWIyBTeeOOtwHH++MeFnHHmz0hMGsy0aT+hrKy8zzHeeOMtxoydRGxcJieffCabN28NrNs9/OXBB//K228v7XO8ffH22+/yox8fT1x8FkNyjuA3v/0d7e3tgfVNTc1ccukVJCYNJmvQSBYuXERPT09gfU1NLb/4xSxS04aSlTWSa66Zj8fj2adYACy8+36G5BxBYtJgfvqzn1NXV79HX++97yHSM4aTO3ICr7325j6dp4iIyOFOybUMGLe7k4aGBv77yUfcv+gubv6/21m7bj0Ab7zxPDXVJTxw/0Ly8nKpqS4J/Oz29tvv8lDBYp7428Ns2PApE8aP46yfnI/P559h8PzzzqGmuoQlzz4OwMuvvMHzzz1BVeV2zjxzemA/H3y4jDvvvJU1q/9DaFgYN8z/v8C6tevW8+vrfsNdd93Jxo2ruOCCn3La6efQ1uYC/MNfaqpLuOGGa5g27eRAH1evWtHvONTV1XPxJVfw299cz9Ythfz97y9QWVHJsmVf7GPOnHmEhYWx6rMVvPPP13jv/33IovsfDqx/6qklDBqcReGalbz//j/4fP0G7v/S+v7E4sWXXuW5517iheefYN26/5KWmsr11/+2T1/LyytISIhnzer/8Ot5c7l89jVUVdf0+1xFREQOdxoWIgPGbDZz1dzZmEwmzjhjOj+aOIGPV/6XsWNGY7fbAQizhhESErLXYSX33/8If/zD7zj66B8D8JvfXMcrr7zBf/7zCccddwwWiwWn04LNZqWysoqbbvw1MTHRe+zntNOmMnbMaACu+/VVXPTzywLrHnzwr1x//dVMPfUkAC699Of84613eePvb/GLn58flOEvNTW1WK1hTJ9+CmFhYcTFxfLMM48F1peU7ODjj/9HScl6LBb/r+yfF9zORT+fxXW/vgqAm266LtA+KSmRc845iw8+WB5Y1p9YPProk9x262+YONH/1P0vf7mTjg53nzYJ8fH8/KLzALj88ku5594HWbO6kNNOm7rP5y0iInI4UnItAyYsLBSTyRT4nJAQT1NTc7+337R5C3OunMdVV10fWNbS2srWrds57rhj+rRNTk7aa2INYLNZv7YPmzZt4Z//XMrCv9wfWOZqbycvL7ff/fw2ubnDGT8+nx//+ASOOWYSI0eO4MQTpzB06JDePmymuaWF7OzRgW16jB6amprp6OjA4XBQWrqD3//+TxSu/ZyW5lbcnW7G5Y/d6/G+LhZbtmwje8jgwOewsDDCwsL6tLF+KVbgj1fjPnxnIiIihzsl13JI+9vjBYwenddnWVRU1B7tQkL2fwTUH//wO6ZOPanPMqfTud/7+yqz2cxb/3iZNWvWUlj4OevXF/GHP/6FB+5fyNlnnwlAdvYg/vn2q3tsu/sJ/2WzrmLw4EG8+MJTREVFsmTJiyxb9u+9Hu/rYmEYBoZhBOmsREREfpiUXMshK3fEcGpq65ialhpYtnbdetK+9Pk7HyN3OJWVVX32ue7zDaSmpgTtGD09PbjdbsaNG8u4cWMBGJIzmGeXvMjZZ5/JiBH+PkRGRhIR4U/q29pc1NXVB578f/75Bv5y152MHDkCgNCvPHHuj5ycbEqKS8kfe0RgWUnJDrKzB323ExQREfkB0QuNckB0dHTgcrXT1d2Fz+fD5WrH5Wrf5yejzvBwDMOgs7Mz8LPbtdfO4c477+L9D5ZRW1vHX//6N2bMOBeXy19lw+v14nK109npwTCMQB++XEXj21x99RU88tfHee21N6mtrePVV//OaafNZNeusj7twp3h9PT0BPq4L8d49tkXOOHE01m2bAWNjU1s2rSFf7z5Dkcc4X8iP2TIYE44/jguv/xqtm0rpri4lEt/eQX33vtgYB8jR47glVf/Tl1dPf/+98e8+OKr+Hy+QLz6E4s5c2Zx5x/u4n//+4yamlruvPMuZl1+Vb/PQ0RERPTk+pC1r5O6fN/GT5jcJwFNSs4GYGPRZ2RlZfZ7PyeccBx33/MAcfFZgWXtLn91itNPn0ZlZTXXXDOf2to6xo4dzd///mLgpcIXXnyVK664do8+XHjhuTy6+IF+HX/smNE8XHAft9++gJ27yhg2LIenn350j3M4a8ZpPPHEM4F+ZmZmsGnjqn4d4xe/uICurm7m33gLJSU7iImJZsaZp/Hb33wxlvyRRxZx3fW/5ZhjTyY0NJSfnHUGf/nLnYH1Dz54D1de+Wsee+wpRo8eyV8fWcS5513CxZfM5qUXn+5XLM4/7xyam5q54MJf0drayo9/PJGnnvxrv85BRERE/EyGBlkOOJfLxZQpU3j3nVf3mMHQ4+mmsqqB1JQ4rNbQAeqhyL7TtSty+Pu+ZwsW+arv82Fje3sH06afw/Lly7/x3SsNCxERERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiZLrg13vBIZ671QOWaZvbyIiInK4UHJ9kLOYzQB0eroHuCci+6a72wuA+TvMjikiInKoUZ3rg5zZHEKE00FTUxsANmtoYFY+kYOVYRg0Nbmw2cIwm5Vci4jID4eS60NAXFwEQCDBFjkUmEwhJMdF6o9BERH5QVFyfQgwmUzEx0cSE+PE6/OBhl/LQc5kgtBQixJrERH5wVFyfQgxm0P0T+wiIiIiBzFlaiIiIiIiQaLkWkREREQkSJRci4iIiIgEyYAn1x999BF2ux2TyURzc/M+bdvU1MS5556L0+kkMTGR2267LeiTrXR2djJnzhyio6OJjo5m7ty5eDyePm0qKioYPHgwJpOJv//970E9voiIiIgcOgY0uf7000+ZOXMmCxYs2K/tL7nkErxeL5s3b+aDDz7ghRde4KGHHgpqH2+66SbWr1/P6tWrWb16NWvWrOHmm28OrG9oaODkk09m5syZZGVlBfXYIiIiInJoGbDkuqKigtNOO41FixZx1lln7fP2O3bs4L333uOJJ54gPT2dI444gvvvv5/7778/aH10u9089thjPP744wwZMoQhQ4bwt7/9jb/+9a94PB4Mw+D000/nqKOO4u677w7acUVERETk0DRgyXVqairPPvssF1988X5t/8knnzBmzBiioqICy44//niKi4upra0NLCsoKCAzMxO73c4ZZ5xBRUVFv4+xdu1aIiIiGDFiRGDZyJEjiYiIYN26dZhMJn7/+9+zePHi/ToHERERETm8DFhybTKZmDp16n5vX15eTmJiYp9ldrudqKgodu3aBcCbb77Jfffdx3PPPUdJSQkTJ05k2rRp+Hy+/T4GQHJycuAYp556KmazeZ/67vF4aG1tDfy0tWnmRREREZHDwSE7iYzb7Q4ktTk5OUyZMoXHH38ci8WC2+0G4O6772bhwoUce+yxANx666288MILrFixguOPP36fjnHSSScB8MEHH/Q5xv5YsGABt99+e+BzSEgI+fn5rCnciM1mI3/sCDZvKcXt9hAR4WBQVhrrN2wDIDMjmR7DoLy8BoAxRwynuHgXrnY34Q4bOTlZrPt8CwDpaUmEmEPYtasKgFF5Q9lVVklrazt2m5Xc3GzWFG4CICUlAZs1jNId/if7I3OHUFlVS3NzG9awUEaPHsaq1UUAJCXF4Qx3UFxSBsCI4YOprWuksbEFi8VM/thcVq0uwjAMEuJjiI6OYNt2/x8jw4Zm0djUSn19EyEhJsaPy6OwcBNen4+42Cji42PYsnUHAEOGZOBqa6emthGAIyeMYt26zXR1e4mJjiQlJZ6Nm0oAyB6cjtvdSVV1PQDj8keycdN2Oju7iIp0kpGRzIai7QBkZaXi7fZSUen/F46xY0awddsOOjo6cTodZA9O5/P1WwHISE8GoKy8GoAjRg+jpLQcl6sDh8PGsKGDWLtuMwBpqYlYQi3s3FnZG+8cysqqaWl1YbOFMTI3hzWFG/3xTo7HbrdRUlreG+9sqqrqaWpuJSzUwpgxI/hs1QZ/vBNjcUaEU1zsj/fwYYOor2+iobEFi9lMfn4uq9cU0dNjEB8fQ2xMJFu37QRgaE4mzc1t1NU3YTKZmDA+j8K1m/B6fcTGRpGYEMvmLaX+eGdn4GrvoKamAYAJ4/NYv34rnq5uoqMjSE1JZOOmYgAGD0qj09NFVVVdb7xz2bSpBHenh8jIcDIzUtlQ1HvNZqbQ4+uhvOKLa3b79p20d3TiDLczZEjmF9dsehIhJhO7yvzxHj1qKDt2VtDW1oHdbmXE8MEUrvXHOzU1kbBQCzt64503MoeKimqaW1zYrGHk5eWweo0/3slJ8TjCbZSU+OOdOyKbmpp6GptaCQ21MHbMCFat3oBhQGJCLJFRTrbvvmaHDaKxoZn6hmbM5hDG5Y9kTeFGfL4e4uOiiY2LZmvvNZuTk0lri4vaukZMJpgwfhRr122mu9tLbEwkSUnxbNrce81mp9PR3kl1jf+aHT9uJEVF2+n0dBEd5SQtLZmijf5rdlBWKl3dXip7r1ndI/zx1j1i4O8RKbNTsERZcG9307KyheSL/fFofKcRS4yFyEmRAJQvKifp50mExoXSubOTpvebSLksBYCm95swWU1ET44GoKKggoSZCYQlh+Gp9NDwZgOpc1IBaF7ejOEziDkxBoCqx6qInRqLNcNKd103tS/UknZNGgAtK1vwtfmInRoLQPWT1URNjsI+xI63yUvVE1VkXJ8BQOunrXTXdBN3RhwANUtqiDgyAsdwB752H5UFlaTPT8dkMuEqdNFZ2kn82fEA1L5US3heOOGjwunp6qFiUQVp89IICQuhfUM77UXtJJ7rf1BX/3o9tsE2nPlODMOgfGE5qXNTMYeb6djSQdtnbSRdlARAw1sNhCaFEjnRH8Oye8pI+WUKlhgL7mI3LStaSL60N95LGzFHmIk62v+v+RUPVJB4fiKhCaF4yjw0Lm0kZVZvvD9swmQ2ET3FH+/KRyqJmxGHNdVKV3UXda/VkTbXH8PmFc0YHoOYk3vj/XgVMSfHYMuy0d3QTc2zNaTPS/fH8JNWvE1eYqf3xvvpaqKOjsKeY8fb4qXq0Soy5vvj3fZZG55KD/Ez/DGsea6GiHEROHId+Nw+Kh+sJP36dExmE651Ltzb3STMTACg7pU67MPtOI9wYnT7i1h8X/eI3b+f38ZkBLu8xn7YsWMHgwcPpqmpiejo6H5ts3DhQlasWMFbb73F6aefzsSJE7ntttuIjo7mgw8+YMKECcTGxmIYRp8nyy0tLTzwwAPMmTMHgOeff54rr7wysP6CCy7g4YcfBuCVV17hjjvuYP369cyePRuAxYsXM3bsWG655RbOOeecPn0aNGhQv8aQezyePhVH2tvbOeOMM3j3nVcJD3f06/xFREQG2kLnIwPdBfmBm++a870dq729g2nTz2H58uU4nc6vbXfIPrlOS0ujrs7/1Oztt98G/GXzWlpayMzMDLRbsmQJY8aM6bPtlxP4s846i8mTJwc+h4eH7/UYXx5XXVNT0+cY+8pqtWK1WgOfQ0IGvCKiiIiIiATBIZHVtba27rFs0qRJrFu3rs+6ZcuWkZ2dHRgnnZeXR01NDenp6YGfurq6Pn9tOByOPutjYmIC6/Lz82ltbWXr1q2BZZs2baK1tXWPhF1EREREZECT6+rqasrLy6mu9o9Vq6yspLy8nKampkCbZ555hqioKJYsWdJn28GDB3PKKadw2WWXUVFRwYYNG5g3bx7XXnttoM0NN9zArbfeynvvvUdtbS0PPfQQp556Ki6Xq1/9s9vtzJo1i1mzZlFaWkpJSQmzZs1i9uzZgSfPTU1NlJeXU15ejs/no6Ghoc85iYiIiMgPx4AOC/nxj3/Mzp07A5/z8vIAuPjii3nqqacA/zANm82Gw7HnWOQnn3ySK664guHDh+NwOLjiiiu4+uqrA+tnzJhBRUUFs2fPpqamhnHjxrF06dJvHCfzVXfddRfz5s0jPz8f8I/J/vKkN7/+9a95+umnA58vu+wyALKystixY8c37rugoICCggLA/wRdLzTqZaWD7WUlvdCoFxp1j9A9Qi806oVGvdB4CL7Q+EPncrmYMmWKXmgUEZFDil5olIF2ML7QeEiMuRYRERERORQouRYRERERCRIl1yIiIiIiQaLkWkREREQkSA7ZSWQOB6oWokoAB3slAFULUbUQ3SN0j1C1EFULUbUQVQs55KhaiIiIHIpULUQGmqqFiIiIiIgcxpRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEpfgGkErxqczWwV5mS6X4VIpP9wjdI1SKT6X4VIpPpfgOOSrFJyIihyKV4pOBplJ8IiIiIiKHMSXXIiIiIiJBouRaRERERCRIlFyLiIiIiASJkmsRERERkSBRci0iIiIiEiSqcz2AVOdaNWwP9hq2qnOtOte6R+geoTrXqnOtOteqc33IUZ1rERE5FKnOtQw01bkWERERETmMKbkWEREREQkSJdciIiIiIkGi5FpEREREJEiUXIuIiIiIBImSaxERERGRIFFyLSIiIiISJEquRURERESCRDM0DiDN0KjZ1w722dc0Q6NmaNQ9QvcIzdCoGRo1Q6NmaDzkaIZGERE5FGmGRhlomqFRREREROQwpuRaRERERCRIlFyLiIiIiASJkmsRERERkSBRci0iIiIiEiRKrkVEREREgkTJtYiIiIhIkCi5FhEREREJEiXXIiIiIiJBounPB5CmP9fUxgf71Maa/lzTn+seoXuEpj/X9Oea/lzTnx9yNP25iIgcijT9uQw0TX8uIiIiInIYU3ItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRLLQHfgh6ygoICCggIAHA4Hawo3YrPZyB87gs1bSnG7PUREOBiUlcb6DdsAyMxIpscwKC+vAWDMEcMpLt6Fq91NuMNGTk4W6z7fAkB6WhIh5hB27aoCYFTeUHaVVdLa2o7dZiU3N5s1hZsASElJwGYNo3RHBQAjc4dQWVVLc3Mb1rBQRo8exqrVRQAkJcXhDHdQXFIGwIjhg6mta6SxsQWLxUz+2FxWrS7CMAwS4mOIjo5g2/ZdAAwbmkVjUyv19U2EhJgYPy6PwsJNeH0+4mKjiI+PYcvWHQAMGZKBq62dmtpGAI6cMIp16zbT1e0lJjqSlJR4Nm4qASB7cDpudydV1fUAjMsfycZN2+ns7CIq0klGRjIbirYDkJWVirfbS0VlLQBjx4xg67YddHR04nQ6yB6czufrtwKQkZ4MQFl5NQBHjB5GSWk5LlcHDoeNYUMHsXbdZgDSUhOxhFrYubOyN945lJVV09LqwmYLY2RuDmsKN/rjnRyP3W6jpLS8N97ZVFXV09TcSliohTFjRvDZqg3+eCfG4owIp7jYH+/hwwZRX99EQ2MLFrOZ/PxcVq8poqfHID4+htiYSLZu2wnA0JxMmpvbqKtvwmQyMWF8HoVrN+H1+oiNjSIxIZbNW0r98c7OwNXeQU1NAwATxuexfv1WPF3dREdHkJqSyMZNxQAMHpRGp6eLqqq63njnsmlTCe5OD5GR4WRmpLKhqPeazUyhx9dDecUX1+z27Ttp7+jEGW5nyJDML67Z9CRCTCZ2lfnjPXrUUHbsrKCtrQO73cqI4YMpXOuPd2pqImGhFnb0xjtvZA4VFdU0t7iwWcPIy8th9Rp/vJOT4nGE2ygp8cc7d0Q2NTX1NDa1EhpqYeyYEaxavQHDgMSEWCKjnGzffc0OG0RjQzP1Dc2YzSGMyx/JmsKN+Hw9xMdFExsXzdbeazYnJ5PWFhe1dY2YTDBh/CjWrttMd7eX2JhIkpLi2bS595rNTqejvZPqGv81O37cSIqKttPp6SI6yklaWjJFG/3X7KCsVLq6vVT2XrO6R/jjrXvEwN8jUmanYImy4N7upmVlC8kX++PR+E4jlhgLkZMiAShfVE7Sz5MIjQulc2cnTe83kXJZCgBN7zdhspqInhwNQEVBBQkzEwhLDsNT6aHhzQZS56QC0Ly8GcNnEHNiDABVj1UROzUWa4aV7rpual+oJe2aNABaVrbga/MROzUWgOonq4maHIV9iB1vk5eqJ6rIuD4DgNZPW+mu6SbujDgAapbUEHFkBI7hDnztPioLKkmfn47JZMJV6KKztJP4s+MBqH2plvC8cMJHhdPT1UPFogrS5qUREhZC+4Z22ovaSTw3EYD61+uxDbbhzHdiGAblC8tJnZuKOdxMx5YO2j5rI+miJAAa3mogNCmUyIn+GJbdU0bKL1OwxFhwF7tpWdFC8qW98V7aiDnCTNTRUf4YPlBB4vmJhCaE4inz0Li0kZRZvfH+sAmT2UT0FH+8Kx+pJG5GHNZUK13VXdS9VkfaXH8Mm1c0Y3gMYk7ujffjVcScHIMty0Z3Qzc1z9aQPi/dH8NPWvE2eYmd3hvvp6uJOjoKe44db4uXqkeryJjvj3fbZ214Kj3Ez/DHsOa5GiLGReDIdeBz+6h8sJL069MxmU241rlwb3eTMDMBgLpX6rAPt+M8wonRbQB8b/eI3b+f38ZkGIbRr5ZywLhcLqZMmcK777xKeLhjoLsjIiLSLwudjwx0F+QHbr5rzvd2rPb2DqZNP4fly5fjdDq/tp2GhYiIiIiIBImSaxERERGRIFFyLSIiIiISJEquRURERESCRMm1iIiIiEiQKLkWEREREQkSJdciIiIiIkGi5FpEREREJEiUXIuIiIiIBImSaxERERGRIPnOyXV9fT2dnZ3B6IuIiIiIyCHNsq8bFBcX8+STT/Lmm29SXV2N0+mku7ub7u5ujj32WM455xx+9rOfERKih+IiIiIi8sPS7wzY5/Mxf/58LrjgAgYNGsRHH31EXV0dpaWllJeXU15ezm9+8xv+/e9/M3HiRP73v/8dyH6LiIiIiBx0+v3kesaMGRxzzDF88skne30qHRoayoQJE5gwYQJFRUXMmjWLBQsWcNxxxwW1wyIiIiIiB6t+P7k+//zz+c1vftOv4R55eXksXboUl8v1nTonIiIiInIo6XdyfeGFF+7TjiMjIznttNP2uUMiIiIiIocqvXUoIiIiIhIk+5VcG4bB6tWrA58/+eQTrrrqKv72t78FrWMiIiIiIoea/Uqu//jHP3LrrbcCUFlZyemnn47FYuHuu+/mjjvuCGoHRUREREQOFftc5xrgySef5MUXXwTgn//8JzNmzGDRokWsXr2ac845h9tuuy2onTxcFRQUUFBQAIDD4WBN4UZsNhv5Y0eweUspbreHiAgHg7LSWL9hGwCZGcn0GAbl5TUAjDliOMXFu3C1uwl32MjJyWLd51sASE9LIsQcwq5dVQCMyhvKrrJKWlvbsdus5OZms6ZwEwApKQnYrGGU7qgAYGTuECqramlubsMaFsro0cNYtboIgKSkOJzhDopLygAYMXwwtXWNNDa2YLGYyR+by6rVRRiGQUJ8DNHREWzbvguAYUOzaGxqpb6+iZAQE+PH5VFYuAmvz0dcbBTx8TFs2boDgCFDMnC1tVNT2wjAkRNGsW7dZrq6vcRER5KSEs/GTSUAZA9Ox+3upKq6HoBx+SPZuGk7nZ1dREU6ychIZkPRdgCyslLxdnupqKwFYOyYEWzdtoOOjk6cTgfZg9P5fP1WADLSkwEoK68G4IjRwygpLcfl6sDhsDFs6CDWrtsMQFpqIpZQCzt3VvbGO4eysmpaWl3YbGGMzM1hTeFGf7yT47HbbZSUlvfGO5uqqnqamlsJC7UwZswIPlu1wR/vxFicEeEUF/vjPXzYIOrrm2hobMFiNpOfn8vqNUX09BjEx8cQGxPJ1m07ARiak0lzcxt19U2YTCYmjM+jcO0mvF4fsbFRJCbEsnlLqT/e2Rm42juoqWkAYML4PNav34qnq5vo6AhSUxLZuKkYgMGD0uj0dFFVVdcb71w2bSrB3ekhMjKczIxUNhT1XrOZKfT4eiiv+OKa3b59J+0dnTjD7QwZkvnFNZueRIjJxK4yf7xHjxrKjp0VtLV1YLdbGTF8MIVr/fFOTU0kLNTCjt54543MoaKimuYWFzZrGHl5Oaxe4493clI8jnAbJSX+eOeOyKampp7GplZCQy2MHTOCVas3YBiQmBBLZJST7buv2WGDaGxopr6hGbM5hHH5I1lTuBGfr4f4uGhi46LZ2nvN5uRk0triorauEZMJJowfxdp1m+nu9hIbE0lSUjybNvdes9npdLR3Ul3jv2bHjxtJUdF2Oj1dREc5SUtLpmij/5odlJVKV7eXyt5rVvcIf7x1jxj4e0TK7BQsURbc2920rGwh+WJ/PBrfacQSYyFyUiQA5YvKSfp5EqFxoXTu7KTp/SZSLksBoOn9JkxWE9GTowGoKKggYWYCYclheCo9NLzZQOqcVACalzdj+AxiTowBoOqxKmKnxmLNsNJd103tC7WkXZMGQMvKFnxtPmKnxgJQ/WQ1UZOjsA+x423yUvVEFRnXZwDQ+mkr3TXdxJ0RB0DNkhoijozAMdyBr91HZUEl6fPTMZlMuApddJZ2En92PAC1L9USnhdO+Khwerp6qFhUQdq8NELCQmjf0E57UTuJ5yYCUP96PbbBNpz5TgzDoHxhOalzUzGHm+nY0kHbZ20kXZQEQMNbDYQmhRI50R/DsnvKSPllCpYYC+5iNy0rWki+tDfeSxsxR5iJOjrKH8MHKkg8P5HQhFA8ZR4alzaSMqs33h82YTKbiJ7ij3flI5XEzYjDmmqlq7qLutfqSJvrj2HzimYMj0HMyb3xfryKmJNjsGXZ6G7opubZGtLnpftj+Ekr3iYvsdN74/10NVFHR2HPseNt8VL1aBUZ8/3xbvusDU+lh/gZ/hjWPFdDxLgIHLkOfG4flQ9Wkn59OiazCdc6F+7tbhJmJgBQ90od9uF2nEc4MboNgO/tHrH79/PbmAzDMPrV8kvsdjuVlZXExMRwzTXXMHz4cObOnUtzczMpKSm43e593eUPmsvlYsqUKbz7zquEhzsGujsiIiL9stD5yEB3QX7g5rvmfG/Ham/vYNr0c1i+fDlOp/Nr2+3XsJCsrCzWr18PwH//+1/y8/MB2LJlC+np6fuzSxERERGRQ95+DQu54YYbOPPMM8nIyCAsLIyjjjoKr9fLb3/7W375y18Gu48iIiIiIoeE/UquL7vsMo488kjKysoCMzD29PRwzDHHcOONNwa1gyIiIiIih4r9Sq4BxowZw5gxYwKfw8LCVClERERERH7QNImMiIiIiEiQ9Du5XrZs2T7t2Ov18vHHH+9zh0REREREDlX9Tq5vvfVWXn755X61ra+vZ8aMGdTW1u53x0REREREDjX9Tq7fffddXn75ZWbMmMGHH3641zZ1dXUsXLiQKVOm8Ktf/YqzzjorWP0UERERETno9fuFxoiICF599VWWL1/O4sWL+cUvfkF8fDxxcXF0d3dTVlZGbGwsP/3pT/n444+JjIw8kP0WERERETno7HO1kClTpjBlyhS8Xi+VlZVUVVXhdDpJS0sjOjr6AHRRREREROTQsN+l+CwWC5mZmWRmZgazPyIiIiIihyyV4hMRERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRIl1yIiIiIiQbLfybVhGPzrX/9i8eLFdHR0AAT+V0RERETkh2i/kuvKykrGjh3LlVdeyTXXXENzczNr164lOzubdevWBbuPIiIiIiKHhP1KrufMmcPPfvYzioqKiIyMBGDs2LHccsstXHXVVUHtoIiIiIjIoWK/kusPPviAyy67bI/l5557LmvWrPnOnRIRERERORTtV3IdHx9PcXHxHssLCwtJTEz8zp0SERERETkU7VdyfeONN3LJJZfw5ptv0tPTw+eff85TTz3FL3/5S2666aZg91FERERE5JBg2Z+N5s6dS3p6Ovfccw8AF154IaNGjeLhhx/mzDPPDGoHRUREREQOFfuVXAPMmDGDGTNmBLMvIiIiIiKHtP2uc71t2zZWrlzJihUr9vjZFx999BF2ux2TyURzc/M+bdvU1MS5556L0+kkMTGR2267DcMw9mkf36azs5M5c+YQHR1NdHQ0c+fOxePx9Gnz0EMPMXToUCIjIzn55JPZtm1bUPsgIiIiIoeG/XpyPW3aNFavXs3w4cOxWPruwmQy8dFHH/VrP59++ikzZ85kwYIF/PrXv97nflxyySVYLBY2b95MY2MjM2fOJCEhgauvvnqf9/V1brrpJtavX8/q1asBuOiii7j55psDQ2KWLFnCggULePHFF8nJyWHRokWcccYZrF+/ntDQ0KD1Q0REREQOfiZjPx71xsXFsXbtWjIyMvb7wBUVFYwdO5a7776b4447jsGDB9PU1ER0dHS/tt+xYwcjRoygpqaGqKgoAN555x2uueYatm/fvt/9+jK3201cXBxr1qxhxIgRAGzcuJEjjzySxsZGrFYrt99+Ozk5OVx44YUA+Hw+IiMj+de//sWECRP6dRyXy8WUKVN4951XCQ93BKXvIiIiB9pC5yMD3QX5gZvvmvO9Hau9vYNp089h+fLlOJ3Or223X0+uX3zxRf785z8zceJETCbTHut/8YtffOs+UlNTefbZZ5k6dSo7duzY5z588sknjBkzJpBYAxx//PEUFxdTW1sbKAlYUFDAXXfdRV1dHSeddBJ//etfSUtL69cx1q5dS0RERCCxBhg5ciQRERGsW7eOiRMn8rvf/a7PNmazmYiICNra2vb5nERERETk0LZfyfXNN9+M2+2mtbV1r8NC+pNcm0wmpk6duj+HB6C8vHyPmtp2u52oqCh27dpFYmIib775Jvfddx/PPfccOTk5PP7440ybNo3CwkLMZvN+HQMgOTmZXbt2MXHixD3WbdmyhaamJo444oiv3a/H4+kzbru9vf1b+yIiIiIiB7/9Sq5ramr43//+R0pKSrD7029utzuQIOfk5DBlyhQef/xxLBYLbrcbgLvvvpuFCxdy7LHHAnDrrbfywgsvsGLFCo4//vh9OsZJJ50E+Gen/PIxvqynp4drrrmGSy65hLi4uK/d74IFC7j99tsDn0NCQsjPz2dN4UZsNhv5Y0eweUspbreHiAgHg7LSWL/B/5JkZkYyPYZBeXkNAGOOGE5x8S5c7W7CHTZycrJY9/kWANLTkggxh7BrVxUAo/KGsqusktbWduw2K7m52awp3ARASkoCNmsYpTsqABiZO4TKqlqam9uwhoUyevQwVq0uAiApKQ5nuIPikjIARgwfTG1dI42NLVgsZvLH5rJqdRGGYZAQH0N0dATbtu8CYNjQLBqbWqmvbyIkxMT4cXkUFm7C6/MRFxtFfHwMW7buAGDIkAxcbe3U1DYCcOSEUaxbt5mubi8x0ZGkpMSzcVMJANmD03G7O6mqrgdgXP5INm7aTmdnF1GRTjIyktlQ5B8ulJWVirfbS0VlLQBjx4xg67YddHR04nQ6yB6czufrtwKQkZ4MQFl5NQBHjB5GSWk5LlcHDoeNYUMHsXbdZgDSUhOxhFrYubOyN945lJVV09LqwmYLY2RuDmsKN/rjnRyP3W6jpLS8N97ZVFXV09TcSliohTFjRvDZqg3+eCfG4owIp7jYH+/hwwZRX99EQ2MLFrOZ/PxcVq8poqfHID4+htiYSLZu2wnA0JxMmpvbqKtvwmQyMWF8HoVrN+H1+oiNjSIxIZbNW0r98c7OwNXeQU1NAwATxuexfv1WPF3dREdHkJqSyMZN/smjBg9Ko9PTRVVVXW+8c9m0qQR3p4fIyHAyM1LZUNR7zWam0OProbzii2t2+/adtHd04gy3M2RI5hfXbHoSISYTu8r88R49aig7dlbQ1taB3W5lxPDBFK71xzs1NZGwUAs7euOdNzKHiopqmltc2Kxh5OXlsHqNP97JSfE4wm2UlPjjnTsim5qaehqbWgkNtTB2zAhWrd6AYUBiQiyRUU62775mhw2isaGZ+oZmzOYQxuWPZE3hRny+HuLjoomNi2Zr7zWbk5NJa4uL2rpGTCaYMH4Ua9dtprvbS2xMJElJ8Wza3HvNZqfT0d5JdY3/mh0/biRFRdvp9HQRHeUkLS2Zoo3+a3ZQVipd3V4qe69Z3SP88dY9YuDvESmzU7BEWXBvd9OysoXki/3xaHynEUuMhchJkQCULyon6edJhMaF0rmzk6b3m0i5zJ9DNL3fhMlqInpyNAAVBRUkzEwgLDkMT6WHhjcbSJ2TCkDz8mYMn0HMiTEAVD1WRezUWKwZVrrruql9oZa0a/z/Ot2ysgVfm4/YqbEAVD9ZTdTkKOxD7HibvFQ9UUXG9f7hra2fttJd003cGf7/765ZUkPEkRE4hjvwtfuoLKgkfX46JpMJV6GLztJO4s+OB6D2pVrC88IJHxVOT1cPFYsqSJuXRkhYCO0b2mkvaifxXP+DuvrX67ENtuHMd2IYBuULy0mdm4o53EzHlg7aPmsj6aIkABreaiA0KZTIif4Ylt1TRsovU7DEWHAXu2lZ0ULypb3xXtqIOcJM1NH+f82veKCCxPMTCU0IxVPmoXFpIymzeuP9YRMms4noKf54Vz5SSdyMOKypVrqqu6h7rY60uf4YNq9oxvAYxJzcG+/Hq4g5OQZblo3uhm5qnq0hfV66P4aftOJt8hI7vTfeT1cTdXQU9hw73hYvVY9WkTHfH++2z9rwVHqIn+GPYc1zNUSMi8CR68Dn9lH5YCXp16djMptwrXPh3u4mYWYCAHWv1GEfbsd5hBOj2z+y+fu6R+z+/fw2+zXmetasWZSVlTFp0qS9Dgu57bbb9ml/O3bs2Ocx1wsXLmTFihW89dZbnH766UycOJHbbruN6OhoPvjgAyZMmEBsbCyGYfR5St3S0sIDDzzAnDn+MTrPP/88V155ZWD9BRdcwMMPPwzAK6+8wh133MH69euZPXs2AIsXL2bs2LHccsstnHPOOX36dM0117Bs2TJWrlxJZGTk1/Z9b0+uzzjjDI25FhGRQ4rGXMtAO2zGXKenp5Oe7v9LJdil7/orLS2Nujr/U7O3334b8JfNa2lpITMzM9BuyZIljBkzps+2X07gzzrrLCZPnhz4HB4evtdjLF68OLC8pqamzzEA5s+fz//7f/+PZcuWfWNiDWC1WrFarYHPISH7XRFRRERERA4i+5Vcf/UlvgOttbV1j4R10qRJ/OpXv+qzbtmyZWRnZwfGSefl5VFTUxP4QwCgsLCwz2eHw4HDsfenxfn5+bS2trJ161aGDRsGwKZNm2htbe2TsN98883885//ZPny5SQnJwfnpEVERETkkBPUR6bt7e39elFwt+rqasrLy6mu9o9Vq6yspLy8nKampkCbZ555hqioKJYsWdJn28GDB3PKKadw2WWXUVFRwYYNG5g3bx7XXnttoM0NN9zArbfeynvvvUdtbS0PPfQQp556Ki6Xq1/9s9vtzJo1i1mzZlFaWkpJSQmzZs1i9uzZgSfPCxYs4OWXX+att97C6XTicrlwuVx7HZMtIiIiIoe3/Z7+/OvsyzCRH//4x+zcuTPwOS8vD4CLL76Yp556CvAP07DZbHt9uvzkk09yxRVXMHz4cBwOB1dccUWfCWRmzJhBRUUFs2fPpqamhnHjxrF06dJvHCfzVXfddRfz5s0jPz8f8I/JXrBgQWD9e++9R3FxMTk5OX22O+6441i+fPk37rugoICCggLA/wRdLzTqZaWD7WUlvdCoFxp1j9A9Qi806oVGvdB4gF5onD59OkOGDOHBBx/kl7/85V7bdHd38/zzz+Pz+fp1cPHTJDIiInIo0guNMtAOxhca+z0sxOfzBZLmp556isjISOLi4vb4ERERERH5oer3sJD33nsv8N8mk4k//elPewzVcLlcPPjgg8HrnYiIiIjIIWS/Xmj8upEkJpNpwErziYiIiIgMtP1KrktLS/f6gmF4eDilpaXfuVMiIiIiIoei/Uqus7Ky9mudiIiIiMjhrN9jrs1mM21tbV874YrsO5XiU5mtg73MlkrxqRSf7hG6R6gUn0rxqRTfASrFFxISgsvlUnJ9AKgUn4iIHIpUik8G2iFdis9kMmEymYLSORERERGRw1G/h4UYhsGkSZMICfn2fHzNmjXfqVMiIiIiIoeifZr+/Morr8RqtR6ovoiIiIiIHNL6nVybTCYuuugijbkWEREREfka+zQsRIJL1UJUCeBgrwSgaiGqFqJ7hO4RqhaiaiGqFnKAqoVceumlPProo4SGhvZrx9J/qhYiIiKHIlULkYF2MFYL6feT6yeffDIoHRMREREROVzt1wyNIiIiIiKyJyXXIiIiIiJBouRaRERERCRIlFyLiIiIiASJkmsRERERkSDZpxkaJbhU51o1bA/2Graqc60617pH6B6hOteqc6061weozrUcOKpzLSIihyLVuZaBdjDWudawEBERERGRIFFyLSIiIiISJEquRURERESCRMm1iIiIiEiQKLkWEREREQkSJdciIiIiIkGi5FpEREREJEiUXIuIiIiIBIlmaBxAmqFRs68d7LOvaYZGzdCoe4TuEZqhUTM0aoZGzdB4yNEMjSIicijSDI0y0DRDo4iIiIjIYUzJtYiIiIhIkCi5FhEREREJEiXXIiIiIiJBouRaRERERCRIlFyLiIiIiASJkmsRERERkSBRci0iIiIiEiRKrkVEREREgkTTnw8gTX+uqY0P9qmNNf25pj/XPUL3CE1/runPNf25pj8/5Gj6cxERORRp+nMZaJr+XERERETkMKbkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkloHuwA9ZQUEBBQUFADgcDtYUbsRms5E/dgSbt5TidnuIiHAwKCuN9Ru2AZCZkUyPYVBeXgPAmCOGU1y8C1e7m3CHjZycLNZ9vgWA9LQkQswh7NpVBcCovKHsKquktbUdu81Kbm42awo3AZCSkoDNGkbpjgoARuYOobKqlubmNqxhoYwePYxVq4sASEqKwxnuoLikDIARwwdTW9dIY2MLFouZ/LG5rFpdhGEYJMTHEB0dwbbtuwAYNjSLxqZW6uubCAkxMX5cHoWFm/D6fMTFRhEfH8OWrTsAGDIkA1dbOzW1jQAcOWEU69ZtpqvbS0x0JCkp8WzcVAJA9uB03O5OqqrrARiXP5KNm7bT2dlFVKSTjIxkNhRtByArKxVvt5eKyloAxo4ZwdZtO+jo6MTpdJA9OJ3P128FICM9GYCy8moAjhg9jJLSclyuDhwOG8OGDmLtus0ApKUmYgm1sHNnZW+8cygrq6al1YXNFsbI3BzWFG70xzs5HrvdRklpeW+8s6mqqqepuZWwUAtjxozgs1Ub/PFOjMUZEU5xsT/ew4cNor6+iYbGFixmM/n5uaxeU0RPj0F8fAyxMZFs3bYTgKE5mTQ3t1FX34TJZGLC+DwK127C6/URGxtFYkIsm7eU+uOdnYGrvYOamgYAJozPY/36rXi6uomOjiA1JZGNm4oBGDwojU5PF1VVdb3xzmXTphLcnR4iI8PJzEhlQ1HvNZuZQo+vh/KKL67Z7dt30t7RiTPczpAhmV9cs+lJhJhM7Crzx3v0qKHs2FlBW1sHdruVEcMHU7jWH+/U1ETCQi3s6I133sgcKiqqaW5xYbOGkZeXw+o1/ngnJ8XjCLdRUuKPd+6IbGpq6mlsaiU01MLYMSNYtXoDhgGJCbFERjnZvvuaHTaIxoZm6huaMZtDGJc/kjWFG/H5eoiPiyY2LpqtvddsTk4mrS0uausaMZlgwvhRrF23me5uL7ExkSQlxbNpc+81m51OR3sn1TX+a3b8uJEUFW2n09NFdJSTtLRkijb6r9lBWal0dXup7L1mdY/wx1v3iIG/R6TMTsESZcG93U3LyhaSL/bHo/GdRiwxFiInRQJQvqicpJ8nERoXSufOTprebyLlshQAmt5vwmQ1ET05GoCKggoSZiYQlhyGp9JDw5sNpM5JBaB5eTOGzyDmxBgAqh6rInZqLNYMK9113dS+UEvaNWkAtKxswdfmI3ZqLADVT1YTNTkK+xA73iYvVU9UkXF9BgCtn7bSXdNN3BlxANQsqSHiyAgcwx342n1UFlSSPj8dk8mEq9BFZ2kn8WfHA1D7Ui3heeGEjwqnp6uHikUVpM1LIyQshPYN7bQXtZN4biIA9a/XYxtsw5nvxDAMyheWkzo3FXO4mY4tHbR91kbSRUkANLzVQGhSKJET/TEsu6eMlF+mYImx4C5207KiheRLe+O9tBFzhJmoo6P8MXyggsTzEwlNCMVT5qFxaSMps3rj/WETJrOJ6Cn+eFc+UkncjDisqVa6qruoe62OtLn+GDavaMbwGMSc3Bvvx6uIOTkGW5aN7oZuap6tIX1euj+Gn7TibfISO7033k9XE3V0FPYcO94WL1WPVpEx3x/vts/a8FR6iJ/hj2HNczVEjIvAkevA5/ZR+WAl6denYzKbcK1z4d7uJmFmAgB1r9RhH27HeYQTo9sA+N7uEbt/P7+NyTAMo18t5YBxuVxMmTKFd995lfBwx0B3R0SApeW+ge6C/MBNTTcPdBe+1ULnIwPdBfmBm++a870dq729g2nTz2H58uU4nc6vbadhISIiIiIiQaLkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiZJrEREREZEgUXItIiIiIhIkSq5FRERERIJEybWIiIiISJAouRYRERERCRIl1yIiIiIiQaLkWkREREQkSJRci4iIiIgEiWWgO/BDVlBQQEFBAQAOh4M1hRux2Wzkjx3B5i2luN0eIiIcDMpKY/2GbQBkZiTTYxiUl9cAMOaI4RQX78LV7ibcYSMnJ4t1n28BID0tiRBzCLt2VQEwKm8ou8oqaW1tx26zkpubzZrCTQCkpCRgs4ZRuqMCgJG5Q6isqqW5uQ1rWCijRw9j1eoiAJKS4nCGOyguKQNgxPDB1NY10tjYgsViJn9sLqtWF2EYBgnxMURHR7Bt+y4Ahg3NorGplfr6JkJCTIwfl0dh4Sa8Ph9xsVHEx8ewZesOAIYMycDV1k5NbSMAR04Yxbp1m+nq9hITHUlKSjwbN5UAkD04Hbe7k6rqegDG5Y9k46btdHZ2ERXpJCMjmQ1F2wHIykrF2+2lorIWgLFjRrB12w46OjpxOh1kD07n8/VbAchITwagrLwagCNGD6OktByXqwOHw8awoYNYu24zAGmpiVhCLezcWdkb7xzKyqppaXVhs4UxMjeHNYUb/fFOjsdut1FSWt4b72yqquppam4lLNTCmDEj+GzVBn+8E2NxRoRTXOyP9/Bhg6ivb6KhsQWL2Ux+fi6r1xTR02MQHx9DbEwkW7ftBGBoTibNzW3U1TdhMpmYMD6PwrWb8Hp9xMZG8f/bu+8wqar7j+PvO7OzvfdOh6UXsSBEMYkIKhoFo6gRjajBChJNrBSN/giiRkUUsYsNG1ZQFCRU6Qi7tF3Y3nvfKff3x+xO2KhRk5UB9vN6Hh6duXd2zn535t7PnDn3nNiYSPbuO+Sud/cU6uobKC4uB2D4Sf359tv9NLfYCQ8PITEhlvSMTAC6dU2iqbmFwsLS1nr3JSMji8amZkJDg0hNSWT3ntbXbGoCLqeLvPx/vWYPHsymvqGJ4KAAevRI/ddrNjkOi2GQk+uu98ABvTicnU9tbQMBAX6k9enG9h3ueicmxuJr8+Fwa7379+tJfn4RVdV1+Pv50r9/T7Zuc9c7Pi6awCB/srLc9e6b1p3i4jIqKmuw2XwYMjiNLVt3Y5oQGxNJaFgwzkPuGlriUzHrqjHrqjEsFixd0nBl78V0uTCCwzCCw3AVuV/flrgUzMY6zJpKMMDatR+u3P2YDgdGUChGaCSuQvfr2xKThNnShFntrrelaxpmfhamvQUjMBgjIhZXvvv1bYlOwHQ4MKvc9bak9sYsysZsacbwD8SITsCV5/7bWKLiwDRxVbhf35aUXpgleZjNjRh+/hixKbhy3X8bS0QsWCy4yt31tiT1wKwowmysx/D1w0joiivb/bcxwqMxfHxxlbnrbUnshllVitlQh+Fjw0juieuw+3hihEVi+AXgKnEfTywJXTFrKjDrazCsViypfXAezgDTxAgJxwgMwVWc21rDVMyGGszaKrAYWLv0xZWzD9PpxAgOxQiOwFXU+reJTcZsasCscR8jrN2OrHcIRlg0roJDrfVOxLQ3Y1a11rtLGmZBa70DgjAi49rX2+nArDyi3sU5mM1NGP4BGNFJuPLcxxNLZBwArgr369uS3BOzLB+zqbXecam4ctzHEyMiBsPqg6ussLXe3TErit31tvliJHbHlb23td5RlAcEHvPHiIQbEvAJ86HxYCPV66qJn+w+ZlZ8WoFPhA+hI0IByHs8j7g/xGGLstGU3UTlF5UkTEkAoPKLSgw/g/AzwgHIX5BPzIQYfON9aS5opnxZOYlTEwGoWl2F6TSJ+E0EAIXPFRI5NhK/FD/spXZK3igh6dYkAKrXVeOsdRI5NhKAoheLCDsjjIAeATgqHRS+UEjKjBQAar6pwV5sJ2p8FADFrxUTcnIIgX0CcdY7KVhQQPIdyRiGQd32OpoONRF9cTQAJW+VENQ/iKABQbhaXOQ/nk/StCQsvhbqd9dTv6ee2EtjASh7rwz/bv4EDw3GNE3y5uWReFMi1iArDfsaqN1cS9yV7tdU+Ufl2OJshJ7irmHu/FwS/piAT4QPjZmNVK+pJv6a1novr8AaYiVsZJi7hk/kEzspFluMjebcZiqWV5BwXWu9v6zEsBqEj3bXu2BhAVEXRuGX6EdLUQul75aSdJO7hlVrqjCbTSLObq334kIizo7Av4s/9nI7xa8Wkzwt2V3DDTU4Kh1Entta75eLCBsZRkDPABzVDgoXFZJyh7vetZtraS5oJvpCdw2LlxQTMiyEwL6BOBudFDxZQPKMZAyrQd3OOhoPNhIzIQaA0qWlBPQJIHhQMKbdBDhqOaLtHP5jDNM0zZ+0p/xi6urqGD16NJ99+g5BQYHebo6IAMvznN5ugnRyY5Ot3m7Cj5oXvNDbTZBO7o66qUftuerrGxh37kRWr15NcHDwD+6nYSEiIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQbwerr/66isCAgIwDIOqqqqf9djKykouvfRSgoODiY2N5f7778c0zQ5tX1NTE1OnTiU8PJzw8HBuuukmmpub2+3z97//nS5duhAWFsb48ePJysrq0DaIiIiIyPHBq+H6m2++YcKECTz88MP/1eOvvvpqHA4He/fuZeXKlbzxxhs89dRTHdrGv/zlL3z77bds3bqVrVu3sm3bNu6++27P9qeeeopnnnmGt956i7179xIfH89FF13UoW0QERERkeODYXZ0V+9PlJ+fz5AhQ3jkkUc488wz6datG5WVlYSHh/+kxx8+fJi0tDSKi4sJCwsD4NNPP+XWW2/l4MGDHdLGxsZGoqKi2LZtG2lpaQCkp6dz8sknU1FRgZ+fHxUVFWRnZzN06FAAKioqiIqKIicnh5SUlJ/0PHV1dYwePZrPPn2HoKDADmm7iPxvluc5vd0E6eTGJlu93YQfNS94obebIJ3cHXVTj9pz1dc3MO7ciaxevZrg4OAf3M9rPdeJiYm8+uqrTJ48+b96/IYNGxg8eLAnWAOcddZZZGZmUlJS4rlvwYIFpKamEhAQwPjx48nPz//Jz7Fjxw5CQkI8wRqgX79+hISEsHPnTgAiIyM9wRrAMAwA/P39/6vfS0RERESOX14L14ZhMHbs2P/68Xl5ecTGxra7LyAggLCwMHJycgBYtmwZjz32GEuWLCErK4tTTjmFcePG4XT+tB6p73sOgPj4eM9zHKmlpYWZM2fy+9//npiYmB/8uc3NzdTU1Hj+1dbW/qT2iIiIiMixzcfbDfhvNTY2YrW6vzLr2bMno0ePZvHixfj4+NDY2AjAI488wrx58/jVr34FwH333ccbb7zBmjVrOOuss37Wc/z2t78FYOXKle2eA6Cmpobu3btTXV3NKaecwvLly//jz3344YeZPXu257bFYmHo0KFs256Ov78/Q4eksXffIRobmwkJCaRrlyS+3X0AgNSUeFymSV5eMQCDB/UhMzOHuvpGggL96dmzCzt37QMgOSkOi9VCTk4hAAP69yInt4CamnoC/P3o27c727ZnAJCQEIO/ny+HDrt79vv17UFBYQlVVbX4+doYOLA3W7buASAuLorgoEAys3IBSOvTjZLSCioqqvHxsTJ0SF+2bN2DaZrEREcQHh7CgYPuDyO9e3WhorKGsrJKLBaDk4b1Z/v2DBxOJ1GRYURHR7Bv/2EAevRIoa62nuKSCgBOHj6AnTv30mJ3EBEeSkJCNOkZ7otHu3dLprGxicKiMgCGDe1HesZBmppaCAsNJiUlnt173MOFunRJxGF3kF/g/oZjyOA09h84TENDE8HBgXTvlsyub/cDkJIcD0BuXhEAgwb2JutQHnV1DQQG+tO7V1d27NwLQFJiLD42H7KzC1rr3ZPc3CKqa+rw9/elX9+ebNue7q53fDQBAf5kHcprrXd3CgvLqKyqwdfmw+DBaWzesttd79hIgkOCyMx017tP766UlVVSXlGNj9XK0KF92bptDy6XSXR0BJERoew/kA1Ar56pVFXVUlpWiWEYDD+pP9t3ZOBwOImMDCM2JpK9+w656909hbr6BoqLywEYflJ/vv12P80tdsLDQ0hMiCU9IxOAbl2TaGpuobCwtLXefcnIyKKxqZnQ0CBSUxLZvaf1NZuagMvpIi//X6/ZgwezqW9oIjgogB49Uv/1mk2Ow2IY5OS66z1wQC8OZ+dTW9tAQIAfaX26sX2Hu96JibH42nw43Frv/v16kp9fRFV1Hf5+vvTv35Ot29z1jo+LJjDIn6wsd737pnWnuLiMisoabDYfhgxOY8vW3ZgmxMZEEhoWjPOQu4aW+FTMumrMumoMiwVLlzRc2XsxXS6M4DCM4DBcRe7XtyUuBbOxDrOmEgywdu2HK3c/psOBERSKERqJq9D9+rbEJGG2NGFWu+tt6ZqGmZ+FaW/BCAzGiIjFle9+fVuiEzAdDswqd70tqb0xi7IxW5ox/AMxohNw5bn/NpaoODBNXBXu17clpRdmSR5mcyOGnz9GbAquXPffxhIRCxYLrnJ3vS1JPTArijAb6zF8/TASuuLKdv9tjPBoDB9fXGXuelsSu2FWlWI21GH42DCSe+I67D6eGGGRGH4BuErcxxNLQlfMmgrM+hoMqxVLah+chzPANDFCwjECQ3AV57bWMBWzoQaztgosBtYufXHl7MN0OjGCQzGCI3AVtf5tYpMxmxowa9zHCGu3I+sdghEWjavgUGu9EzHtzZhVrfXukoZZ0FrvgCCMyLj29XY6MCuPqHdxDmZzE4Z/AEZ0Eq489/HEEhkHgKvC/fq2JPfELMvHbGqtd1wqrhz38cSIiMGw+uAqK2ytd3fMimJ3vW2+GIndcWXvba13FOUBgcf8MSLhhgR8wnxoPNhI9bpq4ie7j5kVn1bgE+FD6IhQAPIezyPuD3HYomw0ZTdR+UUlCVMSAKj8ohLDzyD8jHAA8hfkEzMhBt94X5oLmilfVk7i1EQAqlZXYTpNIn4TAUDhc4VEjo3EL8UPe6mdkjdKSLo1CYDqddU4a51Ejo0EoOjFIsLOCCOgRwCOSgeFLxSSMsM9fLPmmxrsxXaixkcBUPxaMSEnhxDYJxBnvZOCBQUk35GMYRjUba+j6VAT0RdHA1DyVglB/YMIGhCEq8VF/uP5JE1LwuJroX53PfV76om91N1RV/ZeGf7d/AkeGoxpmuTNyyPxpkSsQVYa9jVQu7mWuCvdr6nyj8qxxdkIPcVdw9z5uST8MQGfCB8aMxupXlNN/DWt9V5egTXESthI97f5+U/kEzspFluMjebcZiqWV5BwXWu9v6zEsBqEj3bXu2BhAVEXRuGX6EdLUQul75aSdJO7hlVrqjCbTSLObq334kIizo7Av4s/9nI7xa8Wkzwt2V3DDTU4Kh1Entta75eLCBsZRkDPABzVDgoXFZJyh7vetZtraS5oJvpCdw2LlxQTMiyEwL6BOBudFDxZQPKMZAyrQd3OOhoPNhIzwd1pWbq0lIA+AQQPCsa0u0c2H60c0XYO/zFeG3N9pMOHD//sMdfz5s1jzZo1fPTRR5x//vmccsop3H///YSHh7Ny5UqGDx9OZGQkpml6AjJAdXU1TzzxBFOnusfovP7669x4442e7ZdffjlPP/00AEuXLmXOnDl8++233HDDDQA8++yzDBkyhHvvvZeJEycCYJom+fn51NTU8MILL7BhwwbWrFnT7nmP1Nzc3G7Gkfr6esaPH68x1yLHEI25Fm/TmGuRH3csjrk+bnuuk5KSKC119yp8/PHHgHvavOrqalJTUz37vfbaawwePLjdY48M8L/73e8444wzPLeDgoK+9zmeffZZz/3FxcXtnsMwDJKT3Z/cHnnkEbp06cKqVas8vd3/zs/PDz8/P89ti8XrMyKKiIiISAc4LlJdTU3Nd+4bMWIEO3fubLdt1apVdO/e3TNOun///hQXF5OcnOz5V1pa2u7TRmBgYLvtERERnm1Dhw6lpqaG/fv3e+7LyMigpqbGE9j379//nbm1LRbL97ZZRERERE5sXg3XRUVF5OXlUVTkHu9XUFBAXl4elZWVnn1eeeUVwsLCeO2119o9tlu3bowZM4YpU6aQn5/P7t27mTZtGrfddptnnz//+c/cd999rFixgpKSEp566inOOecc6urqflL7AgICuO6667juuus4dOgQWVlZXHfdddxwww34+flhmiYTJ07khhtu4PDhwxQUFDB79mwcDscP9lqLiIiIyInLq+H6tNNOIyUlhREjRgDunuaUlBSmT5/u2ScoKAh/f38CA787FvnFF18EoE+fPvz617/m0ksv5ZZbbvFsv/DCC7nnnnu44YYb6NKlC2+88QbLly//j+Nk/t3cuXPp27cvQ4cOZdiwYQwaNMiz6I1hGCxfvpza2lqGDRtG//792bhxIytWrCA0NPS/qomIiIiIHL+OiQsaO6sFCxawYMECwD085W9/m6PZQjRbyDE1E0Bnni1k/beaLUSzhXh3tpBTE4/92UKW/HmZZgvRbCHuGnpptpBJD4w/ajliy9bd3HPP/T96QaPC9TFAKzSKHHs0W4h4m2YLEflxx+JsIcfFBY0iIiIiIscDhWsRERERkQ6icC0iIiIi0kEUrkVEREREOshxu0LjieDfZwvZtj1ds4VotpBjaiaAzjxbiPOQZgvRbCHenS2kPODYny0k4YYEzRai2ULcNfTSbCHAUcsRbefwH6PZQo4Bmi1E5Nij2ULE2zRbiMiP02whIiIiIiInMIVrEREREZEOonAtIiIiItJBFK5FRERERDqIwrWIiIiISAfRVHxepKn4NBXfsT7Nlqbi01R8mopPU/FpKj5Nxaep+DQV33FHU/GJHHs0FZ94m6biE/lxmopPREREROQEpnAtIiIiItJBFK5FRERERDqIwrWIiIiISAdRuBYRERER6SAK1yIiIiIiHUTzXHuR5rnWPNfH+hy2muda81xrnmvNc615rjXPtea51jzXxx3Ncy1y7NE81+Jtmuda5MdpnmsRERERkROYwrWIiIiISAdRuBYRERER6SAK1yIiIiIiHUThWkRERESkgyhci4iIiIh0EIVrEREREZEOokVkvEiLyGgRmWN9gQgtIqNFZLSIjBaR0SIyWkRGi8hoEZnjjhaRETn2aBEZ8TYtIiPy47SIjIiIiIjICUzhWkRERESkgyhci4iIiIh0EIVrEREREZEOonAtIiIiItJBFK5FRERERDqIwrWIiIiISAdRuBYRERER6SAK1yIiIiIiHUThWkRERESkg/h4uwGd2YIFC1iwYAEAgYGBbNuejr+/P0OHpLF33yEaG5sJCQmka5ckvt19AIDUlHhcpkleXjEAgwf1ITMzh7r6RoIC/enZsws7d+0DIDkpDovVQk5OIQAD+vciJ7eAmpp69u49QHFxMcnJyQDU1NTgcDiIjIwEoKioiLCwMAICAnA4HBQWFpKSkgJAbW0tzc3NREdHA1BcXExISAiBgYE4nU4KCgpITk7GMAzq6upobGwkJiYGgNLSUgICAggODsY0TfLy8khKSsJisVBfX099fT2xsbEAlJWV4efnR0hICAC5ubkkJiZitVppaGigtraWuLg4AMrLy7HZbISGhgKQl5dHXFwcNpuNpqYmKisrSUhIAKCiogKr1UpYWBgA+fn5xMTE4OvrS3NzM+Xl5SQmJgJQVVUFQHh4OAAFBQVERUXh5+dHS0sLpaWlJCUlAVBdXY3T6fTUsLCwkIiICPz9/bHb7d+pt91uJyoq6gdr+EP1LikpISgoiKCgIFwuF/n5+T+r3j9Uw++rd0JCAj4+PjQ2NlJdXU18fLynhj4+Pj+p3pWVlRiG4alhW7379u1NcFAAPXqk/us1mxyHxTDIyS0CYOCAXhzOzqe2toGAAD/S+nRj+469ACQmxuJr8+FwdgEA/fv1JD+/iKrqOvz9fOnfvydbt6UDEB8XTWCQP1lZeQD0TetOcXEZFZU12Gw+DBmcxpatuzFNiI2JJDQsGOehbAAs8amYddWYddUYFguWLmm4svdiulwYwWEYwWG4inLc+8alYDbWYdZUggHWrv1w5e7HdDgwgkIxQiNxFR527xuThNnShFld7r7dNQ0zPwvT3oIRGIwREYsrP8u9LToB0+HArCp1307tjVmUjdnSjOEfiBGdgCsv070tKg5ME1dFift2Si/MkjzM5kYMP3+M2BRcue7jiSUiFiwWXOXueluSemBWFGE21mP4+mEkdMWV7f7bGOHRGD6+uMrc9bYkdsOsKsVsqMPwsWEk98R1OMO9b1gkhl8ArpJ8974JXTFrKjDrazCsViypfXAezgDTxAgJxwgMwVWc21rDVMyGGszaKrAYWLv0xZWzD9PpxAgOxQiOwFXU+reJTcZsasCsqQDA2u3IeodghEXjKjjUWu9ETHszZlVrvbukYRa01jsgCCMyrn29nQ7MyiPqXZyD2dyE4R+AEZ2EK++ge1uk+/3jqnAfky3JPTHL8jGbWusdl4orZ7+7LhExGFYfXGWFrfXujllR7K63zRcjsTuu7L2t9Y6iPCCQrEPu12y/vt0pLCyjsqoGX5sPgwensXnLbgDiYiMJDgkiM9Ndwz69u1JWVkl5RTU+VitDh/Zl67Y9uFwm0dERREaEsv+Au4a9eqZSVVVLaZn7fTr8pP5s35GBw+EkMjKM2JhI9u5z17BH9xTq6hsoLnbXcPhJ/Um4IQGfMB8aDzZSva6a+Mmtx4hPK/CJ8CF0ROsx4vE84v4Qhy3KRlN2E5VfVJIwpfUY8UUlhp9B+BnhAOQvyCdmQgy+8b40FzRTvqycxKmtx+TVVZhOk4jfRABQ+FwhkWMj8Uvxw15qp+SNEpJubT0mr6vGWeskcmzree3FIsLOCCOgRwCOSgeFLxSSMsN9nK35pgZ7sZ2o8a3H5NeKCTk5hMA+gTjrnRQsKCD5jtbj7PY6mg41EX1x6zH5rRKC+gcRNCAIV4uL/MfzSZqWhMXXQv3ueur31BN7aet57b0y/Lv5Ezy09Zg8L4/EmxKxBllp2NdA7eZa4q5sPa99VI4tzkboKe4a5s7PJeGPCfhE+NCY2Uj1mmrir2mt9/IKrCFWwka2nteeyCd2Uiy2GBvNuc1ULK8g4brWen9ZiWE1CB/trnfBwgKiLozCL9GPlqIWSt8tJekmdw2r1lRhNptEnN1a78WFRJwdgX8Xf+zldopfLSZ5Wut5bUMNjkoHkee21vvlIsJGhhHQMwBHtYPCRYWk3NF6XttcS3NBM9EXtuaIJcWEDAshsG8gzkYnBU8WkDwjGcNqULezjsaDjcRMaD2vLS0loE8AwYOCMe0mANu3Z+BwOomKDCM6OoJ9+w+7X7M9Uqirrae4xH2MOHn4AHbu3EuL3UFEeCgJCdGkZ7jf9927JdPY2ERhURkAw4b2Iz3jIE1NLYSFBpOSEs+27e5zyo8xTNM0f9Ke8oupq6tj9OjRfPbpOwQFBR6V55z3yMKj8jwiP+SOP0/1dhP+o+V5Tm83QTq5sclWbzfhR80L1rlEvOuOuqN3Lqmvb2DcuRNZvXo1wcHBP7ifhoWIiIiIiHQQhWsRERERkQ6icC0iIiIi0kEUrkVEREREOojCtYiIiIhIB1G4FhERERHpIArXIiIiIiIdROFaRERERKSDKFyLiIiIiHQQhWsRERERkQ6icC0iIiIi0kEUrkVEREREOoiPtxvQmS1YsIAFCxYAEBgYyLbt6fj7+zN0SBp79x2isbGZkJBAunZJ4tvdBwBITYnHZZrk5RUDMHhQHzIzc6irbyQo0J+ePbuwc9c+AJKT4rBYLeTkFAIwoH8vcnILqKmpJz4+nuLiYpKTkwGoqanB4XAQGRkJQFFREWFhYQQEBOBwOCgsLCQlJQWA2tpampubiY6OBqC4uJiQkBACAwNxOp0UFBSQnJyMYRjU1dXR2NhITEwMAKWlpQQEBBAcHIxpmuTl5ZGUlITFYqG+vp76+npiY2MBKCsrw8/Pj5CQEAByc3NJTEzEarXS0NBAbW0tcXFxAJSXl2Oz2QgNDQUgLy+PuLg4bDYbTU1NVFZWkpCQAEBFRQVWq5WwsDAA8vPziYmJwdfXl+bmZsrLy0lMTASgqqoKgPDwcAAKCgqIiorCz8+PlpYWSktLSUpKAqC6uhqn0+mpYWFhIREREfj7+2O3279Tb7vdTlRU1A/W8IfqXVJSQlBQEEFBQbhcLvLz839WvX+oht9X74SEBHx8fGhsbKS6upr4+HhPDX18fH5SvSsrKzEMw1PDtnpv3rKb4KAAevRI/ddrNjkOi2GQk1sEwMABvTicnU9tbQMBAX6k9enG9h17AUhMjMXX5sPh7AIA+vfrSX5+EVXVdfj7+dK/f0+2bksHID4umsAgf7Ky8gDom9ad4uIyKiprsNl8GDI4jS1bd2OaEBsTSWhYMM5D2QBY4lMx66ox66oxLBYsXdJwZe/FdLkwgsMwgsNwFeW4941LwWysw6ypBAOsXfvhyt2P6XBgBIVihEbiKjzs3jcmCbOlCbO63H27axpmfhamvQUjMBgjIhZXfpZ7W3QCpsOBWVXqvp3aG7MoG7OlGcM/ECM6AVdepntbVByYJq6KEvftlF6YJXmYzY0Yfv4YsSm4ct3HE0tELFgsuMrd9bYk9cCsKMJsrMfw9cNI6Ior2/23McKjMXx8cZW5621J7IZZVYrZUIfhY8NI7onrcIZ737BIDL8AXCX57n0TumLWVGDW12BYrVhS++A8nAGmiRESjhEYgqs4t7WGqZgNNZi1VWAxsHbpiytnH6bTiREcihEcgauo9W8Tm4zZ1IBZUwGAtduR9Q7BCIvGVXCotd6JmPZmzKrWendJwyxorXdAEEZkXPt6Ox2YlUfUuzgHs7kJwz8AIzoJV95B97ZI9/vHVeE+JluSe2KW5WM2tdY7LhVXzn53XSJiMKw+uMoKW+vdHbOi2F1vmy9GYndc2Xtb6x1FeUAgWYfcr9l+fbtTWFhGZVUNvjYfBg9OY/OW3QDExUYSHBJEZqa7hn16d6WsrJLyimp8rFaGDu3L1m17cLlMoqMjiIwIZf8Bdw179UylqqqW0jL3+3T4Sf3ZviMDh8NJZGQYsTGR7N3nrmGP7inU1TdQXOyu4fCT+pNwQwI+YT40Hmykel018ZNbjxGfVuAT4UPoiNZjxON5xP0hDluUjabsJiq/qCRhSusx4otKDD+D8DPCAchfkE/MhBh8431pLmimfFk5iVNbj8mrqzCdJhG/iQCg8LlCIsdG4pfih73UTskbJSTd2npMXleNs9ZJ5NjW89qLRYSdEUZAjwAclQ4KXygkZYb7OFvzTQ32YjtR41uPya8VE3JyCIF9AnHWOylYUEDyHa3H2e11NB1qIvri1mPyWyUE9Q8iaEAQrhYX+Y/nkzQtCYuvhfrd9dTvqSf20tbz2ntl+HfzJ3ho6zF5Xh6JNyViDbLSsK+B2s21xF3Zel77qBxbnI3QU9w1zJ2fS8IfE/CJ8KExs5HqNdXEX9Na7+UVWEOshI1sPa89kU/spFhsMTaac5upWF5BwnWt9f6yEsNqED7aXe+ChQVEXRiFX6IfLUUtlL5bStJN7hpWranCbDaJOLu13osLiTg7Av8u/tjL7RS/WkzytNbz2oYaHJUOIs9trffLRYSNDCOgZwCOageFiwpJuaP1vLa5luaCZqIvbM0RS4oJGRZCYN9AnI1OCp4sIHlGMobVoG5nHY0HG4mZ0HpeW1pKQJ8AggcFY9pNALZvz8DhdBIVGUZ0dAT79h92v2Z7pFBXW09xifsYcfLwAezcuZcWu4OI8FASEqJJz3C/77t3S6axsYnCojIAhg3tR3rGQZqaWggLDSYlJZ5t293nlB9jmKZp/qQ95RdTV1fH6NGj+ezTdwgKCjwqzznvkYVH5XlEfsgdf57q7Sb8R8vznN5ugnRyY5Ot3m7Cj5oXrHOJeNcddUfvXFJf38C4cyeyevVqgoODf3A/DQsREREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIP4eLsBndmCBQtYsGABAIGBgWzbno6/vz9Dh6Sxd98hGhubCQkJpGuXJL7dfQCA1JR4XKZJXl4xAIMH9SEzM4e6+kaCAv3p2bMLO3ftAyA5KQ6L1UJOTiEAA/r3Iie3gJqaeuLj4ykuLiY5ORmAmpoaHA4HkZGRABQVFREWFkZAQAAOh4PCwkJSUlIAqK2tpbm5mejoaACKi4sJCQkhMDAQp9NJQUEBycnJGIZBXV0djY2NxMTEAFBaWkpAQADBwcGYpkleXh5JSUlYLBbq6+upr68nNjYWgLKyMvz8/AgJCQEgNzeXxMRErFYrDQ0N1NbWEhcXB0B5eTk2m43Q0FAA8vLyiIuLw2az0dTURGVlJQkJCQBUVFRgtVoJCwsDID8/n5iYGHx9fWlubqa8vJzExEQAqqqqAAgPDwegoKCAqKgo/Pz8aGlpobS0lKSkJACqq6txOp2eGhYWFhIREYG/vz92u/079bbb7URFRf1gDX+o3iUlJQQFBREUFITL5SI/P/9n1fuHavh99U5ISMDHx4fGxkaqq6uJj4/31NDHx+cn1buyshLDMDw1bKv35i27CQ4KoEeP1H+9ZpPjsBgGOblFAAwc0IvD2fnU1jYQEOBHWp9ubN+xF4DExFh8bT4czi4AoH+/nuTnF1FVXYe/ny/9+/dk67Z0AOLjogkM8icrKw+AvmndKS4uo6KyBpvNhyGD09iydTemCbExkYSGBeM8lA2AJT4Vs64as64aw2LB0iUNV/ZeTJcLIzgMIzgMV1GOe9+4FMzGOsyaSjDA2rUfrtz9mA4HRlAoRmgkrsLD7n1jkjBbmjCry923u6Zh5mdh2lswAoMxImJx5We5t0UnYDocmFWl7tupvTGLsjFbmjH8AzGiE3DlZbq3RcWBaeKqKHHfTumFWZKH2dyI4eePEZuCK9d9PLFExILFgqvcXW9LUg/MiiLMxnoMXz+MhK64st1/GyM8GsPHF1eZu96WxG6YVaWYDXUYPjaM5J64Dme49w2LxPALwFWS7943oStmTQVmfQ2G1YoltQ/Owxlgmhgh4RiBIbiKc1trmIrZUINZWwUWA2uXvrhy9mE6nRjBoRjBEbiKWv82scmYTQ2YNRUAWLsdWe8QjLBoXAWHWuudiGlvxqxqrXeXNMyC1noHBGFExrWvt9OBWXlEvYtzMJubMPwDMKKTcOUddG+LdL9/XBXuY7IluSdmWT5mU2u941Jx5ex31yUiBsPqg6ussLXe3TErit31tvliJHbHlb23td5RlAcEknXI/Zrt17c7hYVlVFbV4GvzYfDgNDZv2Q1AXGwkwSFBZGa6a9ind1fKyiopr6jGx2pl6NC+bN22B5fLJDo6gsiIUPYfcNewV89UqqpqKS1zv0+Hn9Sf7TsycDicREaGERsTyd597hr26J5CXX0DxcXuGg4/qT8JNyTgE+ZD48FGqtdVEz+59RjxaQU+ET6Ejmg9RjyeR9wf4rBF2WjKbqLyi0oSprQeI76oxPAzCD8jHID8BfnETIjBN96X5oJmypeVkzi19Zi8ugrTaRLxmwgACp8rJHJsJH4pfthL7ZS8UULSra3H5HXVOGudRI5tPa+9WETYGWEE9AjAUemg8IVCUma4j7M139RgL7YTNb71mPxaMSEnhxDYJxBnvZOCBQUk39F6nN1eR9OhJqIvbj0mv1VCUP8gggYE4Wpxkf94PknTkrD4WqjfXU/9nnpiL209r71Xhn83f4KHth6T5+WReFMi1iArDfsaqN1cS9yVree1j8qxxdkIPcVdw9z5uST8MQGfCB8aMxupXlNN/DWt9V5egTXEStjI1vPaE/nETorFFmOjObeZiuUVJFzXWu8vKzGsBuGj3fUuWFhA1IVR+CX60VLUQum7pSTd5K5h1ZoqzGaTiLNb6724kIizI/Dv4o+93E7xq8UkT2s9r22owVHpIPLc1nq/XETYyDACegbgqHZQuKiQlDtaz2uba2kuaCb6wtYcsaSYkGEhBPYNxNnopODJApJnJGNYDep21tF4sJGYCa3ntaWlBPQJIHhQMKbdBGD79gwcTidRkWFER0ewb/9h92u2Rwp1tfUUl7iPEScPH8DOnXtpsTuICA8lISGa9Az3+757t2QaG5soLCoDYNjQfqRnHKSpqYWw0GBSUuLZtt19Tvkxhmma5k/aU34xdXV1jB49ms8+fYegoMCj8pzzHll4VJ5H5Ifc8eep3m7Cf7Q8z+ntJkgnNzbZ6u0m/Kh5wTqXiHfdUXf0ziX19Q2MO3ciq1evJjg4+Af307AQEREREZEOonAtIiIiItJBFK5FRERERDqIwrWIiIiISAdRuBYRERER6SAK1yIiIiIiHUThWkRERESkgyhci4iIiIh0EIVrEREREZEOonAtIiIiItJBFK5FRERERDqIj7cbIGCaJgD1DQ1H7TntdvtRey6R71Nff/Re7/+N5gant5sgnVx9vdXbTfhRdovOJeJdR/Nc0pbT2nLbDzHMH9tDfnHFxcWcd9553m6GiIiIiPyITz75hLi4uB/crnB9DHC5XJSWlhIYGIhhGN5ujvwEtbW1JCcnk5eXR0hIiLebI3LM0XtE5D/Te+T4Y5omDQ0NxMTEYLH88MhqDQs5Blgslv/4CUiOPS6XC5fLRVBQEMHBwd5ujsgxR+8Rkf9M75Hj00/5IKQLGkVEREREOojCtYiIiIhIB1G4Fvkv+Pn5MXPmTPz8/LzdFJFjkt4jIv+Z3iMnLl3QKCIiIiLSQdRzLSIiIiLSQRSuRUREREQ6iMK1iJdpZJaIiMiJQ+FaxItM09TCQSIiIicQhWsRL7n66qu17L3IUXDPPfeQk5Pj7WaISCeh2UJEvGDatGm8/vrrrF27lt69e3u7OSInrBEjRlBbW8vu3bu93RQR6STUcy1ylE2bNo1XXnmFjRs30rt3b+x2e7vt+rwr0jFOP/10LBaLJ1g7nU4vt0jk2NV27nG5XD+4TX4ahWuRo+jOO+/klVdeISMjg+7du9PS0oLNZgNg165dABqDLdIBRo8ejWmarFu3DoDm5masVquXWyVy7CooKAD+Fa4PHDjAxo0bKSsr03npZ1K4FjlKmpqa2Lx5M+Hh4cTFxQF4gvXcuXOZMWMGxcXF3myiyAnhgQceYM2aNSxatAhw91i3rYJ37bXXsnTpUm82T+SY8/nnnzNq1CjWrl2Lj48PS5cu5ZRTTuGaa65h4MCBvP7661RWVnq7mccNhWuRo8Tf358PPviA+Ph4Bg0aRGNjI4ZhMG/ePB5//HHuu+8+T+gWkf/ejTfeyGmnncacOXPYvHmzp8f6sssu49tvv+XMM8/0cgtFji2JiYmMGzeO6dOn89FHH7Fy5UqefPJJNm7cyA033MD8+fN5++23qaio8HZTjwu6oFHkF1ZRUYFpmkRFRQFQW1vL2WefjWmaXHjhhTz77LO88sorOuGLdKCysjLOP/98kpKSmDdvHnfffTeHDx/m/fffJyEhwdvNEznm7Nu3j6effpo1a9YwbNgwnn/+ec+2uXPnsnTpUq6//nouueQSIiIivNjSY5/Ctcgv6O6772bjxo3s27eP22+/nXPPPZe+fftSU1PDhAkT+PLLL1mxYgVnn302TqdTY0JF/kuzZ8+msrKSIUOGcOqpp9K3b19PwD58+DCxsbF8/vnnxMfH43K5sFj0xa3Iv9uzZw8LFy7k3XffZdmyZZxyyimebXPnzuX9999n0qRJXHXVVQrY/4HCtcgv5LbbbmPJkiUsW7aM9PR0lixZwqhRo3jwwQcBqKqq4ne/+x01NTWsWbOG4OBgnfRF/gsjR47EYrHQp08fSktL8fX1ZdasWfTv35/KykomTpyIj48PTzzxBL1799bFWSL/QUZGBk899RQbNmzgySefZOTIkZ5tM2fO5J///Cfvvfce4eHh3mvkMU7hWuQX8H//93/cfffdlJWVERkZCcBnn33GFVdcwdatW+nWrRsA9fX1/OY3v6GxsZH169cTFBSkgC3yM4wYMYLg4GC++OILANavX8+jjz7KRRddxBVXXAG4h4icd955xMfH88ADDzBo0CBvNlnkmNC2QvCuXbtobm6muLiY888/H4C9e/eyYMEC1q1bx1NPPcXpp5/ueVx5eblnmKN8P53BRTpYZWUl+/fvZ8SIEezYscNz/7hx4xg9ejSrVq3i6aef5pNPPiEoKIivvvqK0NBQ+vbtS0NDg4K1yE+0dOlSNm3axP333w9AS0sLp59+Ov369WP79u1kZ2eze/duoqOj+fjjjykpKWHWrFls3brVyy0X8T7DMFi6dCljxozh/vvvZ8uWLZ5p+NLS0rjpppsYOXIk06ZN4+uvv/Y8TsH6x+ksLtLBIiIimDFjBiNGjOChhx7i/fffB2D+/Pl88MEHpKen8+WXX/LAAw/w7LPPEhgYyCeffEK/fv0oKirycutFjh9nnXUWd9xxBxMnTmTlypX4+voCsHXrVlavXs2UKVP49a9/zSuvvEJMTAwfffQRu3bt0lR8IsDBgwf585//zMKFC3n77beZNWtWu86dtLQ0pk6dSv/+/bn//vtpamrSYjI/kYaFiPxC0tPTee655zhw4AChoaFs2LCB1157jZEjR1JdXc1LL73Exo0befrpp4mIiPB8RSciP11VVRUPPfQQL774IitWrODZZ59ly5YtLFu2DH9/f5YvX84tt9zCJ598wumnn05NTQ1BQUG6eFg6vU2bNnHDDTewatUqz8WJbRfWl5WVER0dDcD+/fsJDQ0lPj7em809rqjnWuQX0q9fP6ZMmULPnj354osvuOaaaxg5ciSmaRIWFsagQYPIycnx9AQoWIv8fOHh4dx9991MnjyZ0047jc8//5ytW7eSnJxMeHg4l112GaNHj6awsBCA0NBQrFarlkKXTqftXFNfXw9ATEwMsbGxlJSUePZp+9B544038sEHHwDQu3dvBeufSeFa5BfUv39/pk6dypVXXsmGDRt45513PCF648aN2O12hWqR/1FbwL7rrruorq5m06ZNAPj4+ODj40NxcTF1dXXtHqOea+lsDMPgrbfeYtasWTQ3N5OQkIBhGMyZM4fq6mrPfk1NTTQ0NHguvJefz8fbDRA50fXp04cpU6awePFiFi1aRHR0NN9++y2zZ89m/fr1mitUpANERkYyffp0GhoaOPfcc/nkk0847bTTuOiii6iqqvLMHCLSmRz5zWhmZiZXX301r7zyCn5+fgC89tprjBgxghtvvJEZM2YQHx/Pa6+9xs6dOz0zXcnPpzHXIkdJeno6L774Im+++Sb5+fl88803DB8+3NvNEjmhtI3BfvXVV4mLi6OxsZHdu3djs9m0UJN0KkcG6y1bttDU1MS+ffu49tprMU0Tp9OJj48PpaWlXHPNNTQ0NFBXV0dtbS2vvfYaJ510kpd/g+OXeq5FjpJ+/foxefJkrFYrkydPpm/fvt5uksgJp22ISHNzM5s2bWLz5s3YbDYcDgc+PjrlSefRNuTw7bff5rLLLiMpKYmpU6cCeIK1w+EgJiaGd999l/LycpqamggLC9N0e/8j9VyLHGV2ux2bzebtZoic0KqrqwkNDcUwDAVr6bS2bNnCKaecwsMPP8yhQ4f48MMP2bZtG/Hx8ToX/YJ0tBH5GdavX0+fPn3+p0/1OpiJ/DTNzc2esaHAz1q9NCwsDHB/Na5gLZ1VQEAA27ZtY8iQIezfv5+ysjLGjx/P+++/T3JyMgAff/wxaWlp9OzZ08utPXFothCRn2j69OmMGjWK+fPnt7uyWkQ61gMPPEBRUZEnWE+fPp3169f/V6uXajYe6cz69+/PkCFDAPeUen/729/o3r07F154IXa7nSeeeII//vGP+gDawRSuRX6Cv/71r7zwwgu8/PLLvPrqq/z9739XwBb5BRw+fJh169bxxz/+EYB77rmHJ554QvPsivyItlG+hw4dIjc3l5ycHM+2tnnde/fuzZw5cxgyZAgRERH89a9/5eOPP6Zr167eaPIJSx9VRH5ETU0NcXFxbNu2jR49epCYmMjll18OwJ133un5+llE/nfJycnMmzePWbNm0b17d6qqqigrKyMiIuJnDQsR6UzaVvh99913uffeewkICCA5OZmLL76Yq6++2rNwktVqpU+fPgQEBODn58eaNWvo37+/t5t/wlG4FvkRoaGh3HbbbVgsFux2O7/5zW948803ueyyy4AfDthazlzk53G5XPj4+DBw4ECampooKiri5JNP9swFr+vvRb6fYRisW7eO6667jkWLFjF06FBeeOEF5s6di8Vi4aqrrvJMQ7l8+XKeffZZNm7cqGD9C1EXgMhP0NZbZrPZcLlcnHXWWbz55pssXryYuXPnUllZ6dk3IyMD0FhPkZ+r7X02c+ZMNmzYwAsvvEBsbCxjx46lsrISq9VKc3Nzu8cocIu4ZWRkMGHCBCZOnEhISAivvfYaUVFRLFq0iOeee86zX//+/Tl48KDmsf4FKVyL/Ih/P3lbLJbvBOx58+YBMHfuXC655BKqqqq80FKR41Pbe6ztv6GhoXz77bdcdtll3Hjjjfj5+XH55ZdTWlrquchx4sSJbN68WR9ipdNre9/4+fkxduxYqqurOe+887jiiit47733GDNmDP/4xz+47LLLuOeee0hJSaFLly5ebvWJTfNci/yAtmEdLS0t+Pr6eu5vG/fZ9t9Vq1YxefJkEhIS2LFjB+vXr1ePgMhPdOQ46sbGRgICAtptN02TtWvXMn/+fOx2O8uWLeOPf/wjn3/+Obm5uZraUqRV2/vngw8+4KmnnuLdd98lLCyMJUuW8P7772O323nwwQcZOHCgt5t6wtOYa5Hv0Rasly9fzquvvkp4eDh9+/bl5ptv9gRrwzA8Pdi/+c1vWLZsGZs3b2bQoEHebr7IcaMtWM+fP5+tW7cSEhLCtddey/Dhw7FYLBiGwahRozBNk8cff5ykpCTCw8M9wVoLxEhn03Z+2rFjB9nZ2VgsFnr06EG/fv0AKC4upqamBofDAbhnDzn11FO54447vNnsTkU91yI/4OOPP+bSSy9lxowZtLS0sHnzZkaNGsXs2bOBf/W4PfLII9x5552eifpF5McdecHv888/z/Tp07nnnnt46623SE1N5eKLL+aKK67wXIRlmiZVVVVs3ryZ3/zmN1itVgVr6bSWLl3Kddddx6hRo4iNjeWDDz7g5ZdfZvz48RQXF3PyySfTu3dvAgMDWbNmDWvWrFHHz1GkcC3yPerr67n00ks555xzuOWWW8jIyOCss84iIiKCc889l/nz5wPQ0tLCo48+yjnnnMPQoUO93GqR48+LL75IQ0MDp59+OkOHDqWxsZE777yT3NxcJkyYwOWXX47Vav3O7Dtt04qJdDY5OTmMGTOGe++9lyuvvJKcnBy6du3KzJkzuffee7FareTn5/Pqq69iGAYXXHABffv29XazOxWFa+nU2k7Ybb3QR46znjZtGjfccAPR0dGMGTOGM888kzPPPJOFCxcybtw4+vbty0knnURSUpK3fw2R41JZWRljxowhKyuLdevWeaYFq6mp4Z577iEvL48JEyYwadIkBWmRVkVFRVx66aV8/fXXZGVlcfbZZ3PhhRfy6KOPkpubS3Nzs5Yy9zLNFiKdWkFBAeAe4gFw4MABAHx9fbnqqqsYPHgwf/vb3zj99NN5+umnOffcc/H19eX555/n2muv/c60YCLy/R599FF2797d7r7o6GheeeUVBg0axNSpUz33h4aG8tBDD5Gamsqzzz7LF198cbSbK3JMMk2Turo6SkpK+PTTT7ngggsYP348jz76KKZp8sADD/Dxxx97u5mdnsK1dFqrVq1i1KhRrF27Fh8fH5YsWUJaWhr79u0D4LTTTgOgqqqKtLQ0AEJCQhgyZAgfffQR6enpdO/e3WvtFzlefPPNN/z5z3/mvffe+87UlgMGDOCZZ57B6XRyxhlneO4PCQlhzpw5XHzxxYwZM+ZoN1nkmND2fmloaPDc17NnTy677DLOP/98BgwYwOOPP+751rWgoICYmBhvNVdaaViIdFqHDh1i4cKFrF+/nnHjxjFnzhxeeuklJk2a1G6/q666it27d3PfffexceNGnn/+eXbs2EFycrKXWi5y/Nm4cSNDhgwhPT2dhIQEEhIS2m1PT09nypQp2Gw2vv766+88XkufS2dz5KxVr732GomJiVx33XX06tWL3Nxc/v73v7Ny5UoWLlxIQEAAn3/+OU888QSbNm1Sx4+XKVxLp1ZVVcX48eNZv349s2fP5t5778XhcHjGd7ZdQHXppZfS0NBASUkJzzzzjC5eFPmJjrwQ8S9/+Qvz5s1j6tSpzJkzh6ioqHb7pqenc8MNN1BeXk56ero3mityTHnvvfe48sormTlzJt27d+eSSy7xbKusrOSxxx7jrbfeIi4ujoaGBhYtWsSwYcO82GIBhWvppNpO+O+++y6XXHIJY8eOpby8nEcffZSRI0d6xmC7XC7PVF91dXUYhkFQUJA3my5yXPrrX//Ks88+y0svvcTtt9/OuHHjmDVrFtHR0e0C+O7du3niiSdYuHChLmKUTq2oqIixY8cybdo0rr76aux2O5WVlbzzzjskJyczduxYfH19yc/PJzQ0FKfTSXh4uLebLWgRGenEcnNzuffee3nnnXf41a9+xaxZs7jllltYsGABI0aM8ATrTZs2ceqppxIcHOztJoscN44cxlFTU4PVamXz5s307NmT5ORkLrzwQgDuu+8+4uLiANi2bRvDhg1j0aJFgKbbk86tvr4eu93OxIkTsdvtPP7443z77bds2bKFnj17snnzZubMmUN8fLzeJ8cY9VxLp5adnU2XLl0A91fSTz/9NOvXr/cE7Iceeoh7772XoqIiYmJi2s2zKyLf78ie6JUrVzJixAgCAgKwWCy0tLTg6+vLjh07OP/885k4cSIPPfQQV155JTabjbfeesvLrRc5dowcORK73Y6Pjw+DBw/mt7/9Leeeey4PPvgglZWVPP30095uonwPhWvpNNpO+IWFhdTX19OtWzdcLhc2m82zT0ZGBgsWLGDTpk0MGzaMV199la+//pqTTz7Ziy0XOX4cGaxvvfVWvvzyS9avX09YWJhnn7Ye6fT0dM477zzq6uoIDQ1l79697d6PIp1V2/uotLSURYsWERUVxWWXXUZoaCgWi4Xp06dTW1vLM888g9VqVcfPMUbDQuSEduRX04Zh8M4773DPPfcQGBhIcHAwp59+OjfccIPnyuq+ffty8803061bNz7++GPWrVunixdFfqIj328tLS1UVFTw5ptvtgvWgGeffv36kZKSgtPp5Ouvv8bHx0dLmovwr4vpY2JiuOeeewD3h9KioiJeeOEFXnzxRdatW6f3yjFKPdfSaWzatInf/va3PP3004wbN47Vq1ezYsUKqqqqmDt37nemLmr7+lpEftyRPdZ33nknWVlZjB49muuvvx4fH5/vnUbv8ssvZ/Xq1WRnZ2Oz2RSsRf6Dm2++me3bt2O323n22WfV8XMMU7iWE9LVV19NRUUFH374oee+t956iy+++ILFixd77lu7di0vvfQSSUlJzJ49WxdQifyPrr/+el5//XXCw8OJjIxk165dAN8Jzvn5+bz88svccccdCtYiP8Jut7N161YiIiKIjo7+zjSWcmzRjPxywrntttv47LPPmDt3brv7m5qa2LBhAzU1NZ77Ro0axRlnnMHKlSsBFKxF/gf5+fmUlJTw7bffsn79esrLyz2LMh0ZnE3TJCkpibvvvlvBWuQnsNlsnHbaafTp00fB+jigcC0nlDlz5vDkk0+Snp5O3759aWlp8Ww744wzGDBgAG+//Xa7gD169GicTiclJSXeaLLIcattPvg28fHxvP3223Tr1o3U1FQ+/fRTVq9e3W7V08svv5yHH3643eMUrKUzcTgc3m6C/MIUruWEcfvttzNnzhx69erFa6+9BoCvry9OpxOAbt260a9fP5YtW8Zbb71FeXk5AC+99BJNTU34+/t7re0ix5sjL17ct28f2dnZOJ1Oz3UKLpeLwYMH8+mnn7JmzRomT57MpEmT2LRpE3fccYc3my5y1L355ps8+uijgPvD5JIlS9p96JQTi7oL5IQwffp0XnjhBb755hsOHDjAww8/TG1tLffeey9WqxW73Y7NZmPmzJk88MADfPnllzz44IOceuqprFy5kpUrVxIaGurtX0PkuGCapidYT58+nU8//ZSqqiouuOACRo0axeTJk7FYLDgcDoYOHcrq1avp06cPw4cP90y3p6Eg0lnU19eTmZnJ6tWr6datG1arlcmTJ/Pqq696u2nyC9GRTY57ZWVlZGVlsW3bNnr06EFqaio1NTWeyfXvvfdebDabZ/aP++67j5KSEtauXUtwcDBz586lW7duXv4tRI4fbbOC/POf/2TFihW8/PLLlJeXs2vXLp577jlqa2u5+eabPeH5pptuIi0tjfXr12u6Pel0goKCuOaaa/Dz8+Oee+5h3759LFu2jPPPP1/vhROU/qJy3IuOjubdd9/Fx8cHp9NJdHQ0EydOBGgXsH19fT092LGxsVx88cXebLbIcW3JkiV89tln/P3vf+e0004D4OSTTyY8PJylS5fSo0cPxo0bx6FDh0hISODjjz9WsJZOyeVykZiYiM1mY9++fQwYMID6+nrAPUTkyCFW0H5aSzk+6QgnJ4S2k3XbbB8RERHfG7BtNpum2xP5LxwZAFwuF1lZWaxatYrU1FTOP/98AGJjY5k4cSJbtmxh69atjBs3ji5duvDyyy8D352OT6QzsFgsrFixgunTp7NgwQJqamp47rnnqK6u5vrrr8disXxnwTM5vukoJyesfw/YVquVu+66S8Fa5Gc6coz1okWLGDt2LH/6058ICgrilVdeoWfPnvzxj38E3CvKJScns2bNmu8sxKRgLZ1Vr169WL58OWPGjOHw4cPU19fz9ttvY5omN9xwAxaLhYceeoj09HTPBfly/NKRTk5obQHbYrHwwAMP4Ovry4wZM7zdLJHjxpFfUc+ePZtFixZx4YUXEhMTwxVXXIFpmjzzzDPYbDb+8Ic/ALBu3ToSExO1wql0Wke+bxwOB927d/esAty1a1euu+46DMNg6dKlhIeHU1JSwpw5c/jnP//pzWZLB1G4lhNeREQEF110ETabjVGjRnm7OSLHjSO/qi4pKaGoqIhly5YRFxeHaZrExcVxxRVXAPC3v/2N9957j1NOOYXm5mYWLVoEaPyodD5tr/nPPvuMlStXkp6ezuTJkxkwYAADBgwAICUlhSlTpgCwYMECdu7cydq1axk+fLg3my4dRMufS6fx7xeNiMgPOzIU/+Uvf2Hbtm0MHjyYGTNmkJCQ0G57cXExr7zyCosXL2bChAk89NBDADQ3N+Pn5+e130HEWz788EMuvfRS7rvvPsLDw3n77bcJCwvjySefJDU11bNfTU0NNTU1GIZBUlKSF1ssHUnhWkREftDVV1/NsmXL6NGjB2VlZSxZsoSRI0cCtLs4OC8vj7fffpuXXnqJadOmecZgi3Q2drudKVOmMGzYMG677TYaGxtJSUnh5ptvZtasWd5unhwF6sYTEZEfZLVa2bdvH1u2bCEhIYFZs2Zx8OBBXC5Xu4uDk5OTufzyy7nmmmuYOXMmL730kvcaLeJFhmGQmZlJVFQUJSUlDBgwgCuuuIJZs2axd+9evvzyS283UX5h6rkWERHgx8dHNzU1ceaZZxIaGsrixYvp0qULZ555Jl26dOGVV14BoKCggPfee49zzz3XcwGXSGczf/58CgsLeffdd7nooos8S5///e9/55NPPmH16tW6FuEEpnAtIiLtrkmoq6vDbrcTHh7uCQBt46fr6+s5++yziYyMpKGhgYKCAnbt2tVuZhDNJS+dRdsH0qqqKgICAjzXGHz88cfMmDGDpKQkli5dSlRUFAB//etfqaur46mnnvJms+UXpnAtItLJHdljfffdd7N9+3YOHDjAxRdfzIABA7jqqqsAPCucgnthjOHDh7Nu3TpsNpsWiJFO64MPPmD27NlERUURHx/vmaf69ddf57HHHmPEiBGeD64vvvgi//znPxk0aJA3myy/MIVrEREB3F9Zz5s3j08++QRfX1/mz5/P+vXrPSsxthkzZgzZ2dns2bNHS5pLp9T2gXT79u1ccsklTJ06FZvNxttvv01tbS07d+4EYMWKFWRmZrJ8+XK6devGlClTGDhwoJdbL780hWsRkU7oyGEgbUHhuuuuY9SoUUyePJnly5dzxRVX8NRTTzFp0qR2vdbTp09n7ty5+Pr6KlhLp7Vt2zY+/PBDgoOD+fOf/4xpmpSWlnLBBRfQ2NjoCdjgfo+BljbvLDRbiIhIJ9MWrBsaGsjKysIwDJxOJ3v27KGlpYW1a9fyhz/8gfnz5zNp0iTWrFnDY489Rn19PQCPPfaYgrV0Ov/eF/n+++/z3HPPsXPnTqqqqjAMg9jYWD744AMCAgLaLQhjGIaCdSeicC0i0slYLBaam5sZNGiQZ3yo1Wrltttu4+WXX2bMmDE89dRTXH311QDs2LGDDRs2EBQU1O7nKFhLZ7R27VoyMjJ44IEHuPnmm8nOzmbp0qVUVlYCEB8fz7Jly6irq+OMM87wcmvFG3RkFBHpRNp6rU3T5PTTT/csXw6QlpZG165dCQgIoEePHgA4HA5Wr15NcnKyt5osckwwDINPPvmE8ePH8/XXXwNw11130dDQwKuvvorL5eL3v/89ERERxMXFsWbNGhoaGrzcavEGjbkWEekkjpwV5M4772Tx4sUMGzaMkJAQ3n//fQDWrVvHm2++ydq1a4mMjMRut1NZWcm2bduw2Ww/Ohe2yInkyLHSNTU1fPrppzgcDq688sp2w6Luu+8+1qxZw5VXXsmECROIjIz0ZrPFyxSuRUQ6mccee4zHH3+cl19+mcDAQKZOncqoUaP4xz/+AUBJSQl5eXmsWbOGuLg4LrnkEs0KIp1S24fJDz74gJtvvpkRI0Ywc+ZM+vfvD9BupdJZs2bx/vvvM336dK666irPBcPS+egoKSLSSZimicPhYNu2bdx///2MHj0agCuvvJL8/HzPfjExMcTGxjJs2DDPfU6nU8FaOh3DMHjvvfeYOHEiEyZMYO3atezdu5cBAwbgcrk8FwNbrVZmzZqF1WrlrLPOUrDu5PTXFxHpJAzDwGazERISwtdff01NTQ0AixcvbrdfVVUVVVVVgLtnDtCKi9IpNTU1sX//fpYtW8bSpUu58sorufXWW1mxYoUnQFutVjIzMwH38JAuXbp4s8lyDNCwEBGRE9SRc1kf6fXXX+f111+nvLyciooKunfvzmeffQbA5MmTqaiooLKykn/84x+cdNJJR7vZIl535LUFdXV1BAcHA1BcXMyCBQt45ZVXePbZZznnnHP4v//7P77++mvefvttgoODdU2CaFiIiMiJ6MhgvWrVKgICAvD392fIkCFcfvnldOnSherqahYtWsS8efMAGD9+PBkZGbzzzjs88sgjfPXVVwrX0qm0heqGhgZsNhu+vr6eYA0QFxfHjTfeiGma3HbbbZx88sksWbKEzZs3ExIS4sWWy7FEPdciIieYI3vd/vKXv/DSSy8RHh5OWFgYV111FTfffLNn35kzZ1JSUsKuXbsoLS1lz5492Gw2rr/+egYPHsxNN93krV9D5Kg68uLFf/zjH1gsFvz8/Jg2bRqnnXYaoaGh7fYdOXIke/fu5auvvmLIkCHea7gcczTmWkTkBNMWrLdu3crGjRvZuHEjS5cuZcqUKcyfP5/HH3/cs+9JJ51EdHQ05eXl7Nq1C5vNxkMPPcSKFSsYM2aMl34DkaPPMAy+/vprLrvsMiZOnMibb75JdHQ01157Lfv27QP+NTXfP/7xDzZu3Mjq1asVrOU7NCxEROQEcWSP9aJFi3jzzTc57bTT6NatGwBdu3bFYrHw0EMPATBt2jQuuOACTj31VAoKCsjLy2PJkiU8+uijrFq1il69enntdxHxhg0bNnDttddy0003UVpaypYtW7jkkks4+eSTAXcAr66upqWlha1btzJo0CAvt1iOReq5FhE5zu3fvx+g3YVUo0ePpry8nA0bNpCVlQVAaGgol1xyCffccw8LFizggQceANzjSHNycpg8eTLLly/n66+/bjcNn8iJpK33uW0mnCNHxxqGga+vL4cPH+a0007jnHPO4dFHHyUnJ4drr70Wh8NBWFgYt99+O0OHDvVK++XYp3AtInIcmz59Or/73e9IT0/33Ge32+nduzcffPABlZWVzJo1y/O1dlhYGJdccgm33HILu3btwm63A/DFF1/w5ptvsnz5cn3NLSe0goIC4F/h+sCBA55tPXr0YMeOHZx11llceOGFPPbYYwCUl5ezc+dOWlpaADTnu/xHCtciIsexnj17cvrpp9OtWzeqq6sBsNlsOBwOunXrxvvvv8/27dv529/+5unhDg0N5dprr+Xtt9/GZrN5AnZKSgphYWFe+11EfmmrVq1i1KhRrF27Fh8fH5YsWUJaWprnvTFx4kSSk5OprKzkT3/6E83NzQAsW7YMf39/bzZdjiOaLURE5Dj073NYL1iwgI8++oi//e1vnunz2pYrP3jwIBdffDHDhg3jjjvu8CzdDO3HaYuc6A4dOsTChQtZv34948aNY86cObz00ktMmjTJ834BuOCCC2hoaKCpqYmEhAS++OILXbwoP5nCtYjIcW7q1Kk8//zzjB07lvDwcG677TZPwLbb7dhsNjIzMxkxYgS33HIL9913n5dbLOI9VVVVjB8/nvXr1zN79mzuvfdeHA4HVqsVp9PpCdhffvklBw4c8Cxp3rNnTy+3XI4XCtciIseRe+65hyuuuIJ+/foBsHLlSsaPH09mZiaFhYU89thjmKbJ7bff7gnYbb3c2dnZJCcnaylz6ZTavqV59913ueSSSxg7dizl5eU8+uijjBw5st0FjnqPyP9CY65FRI4Tp556Kp999pknWAP89re/paCggMTERE466SSuueYaLBYL8+fP59tvvwVg0qRJ7Nq1iy5dunh650Q6o5ycHO69917eeecdXn75ZYYPH84tt9zChg0bPMOsrFYrmzdv9nJL5XimnmsRkePA6aefjmEYrFu3DgCn09mud+3I21988QVLlizBYrGQmZnJ7t27KSoqwmazeaXtIseS3NxcUlJSAEhPT+fpp59m/fr1LFiwgBEjRvDQQw9x7733UlRURExMjK5JkJ9N4VpE5Bh35plnYrfbWb9+PQDNzc34+fl9Z78jL05ct24dY8eOpU+fPmzYsMEzg4imEJPOpO09sW/fPvLz8xk4cCBhYWH4+vp69snIyGDBggVs2rSJYcOG8eqrr/L11197Fo4R+bk0LERE5Bg2d+5cvvnmGx5++GHAPX66LVj//ve/56OPPvLse2QP27x58+jevTsbN25UsJZOyzAMli5dysiRI5kyZQpnnnkmixcvpqyszLNP3759ufnmm7nsssvYv38/69atU7CW/4l6rkVEjmFZWVnceuutREVFccUVVzBmzBgALr/8cjIyMli+fDlxcXHtHvPuu+9y6623cvjwYQVr6dQKCgr4v//7P0477TTGjx/PY489xvr16znrrLO49tpriY6Obrd/S0tLu15tkf+Geq5FRI5h3bt35x//+AelpaW89tprbN68mcsvv5ysrCw+/fTT7wRrgAkTJpCbm6tgLZ3KihUr2t1OT09n0KBBNDU1cdlllxESEsL999/P2WefzapVq3j++ec9Pdht/YwK1tIR1HMtInIcyMzM5JZbbuHAgQNYLBbWrl1LTEzMdxaTOZIWiJHO4sYbb+T555+noKCAqKgoAIqKirjrrrv44IMP2LJlCz169PDsP3/+fFatWuWZLaTtMSIdQT3XIiLHgR49erBw4UL69evHgAEDOHDgAAAWi4Uf6iNRsJbOYPbs2bzwwgvk5OQQFRWFw+EAID4+nrlz53LhhRdy5plnkp6e7nnMjBkzOPXUU9m9e7e3mi0nMPVci4gcR7Kysrj55psJDw/n+uuvZ/To0d5ukojXzJgxg8cee4xTTjmFGTNmcMkllwDtp6YsKSnhrrvuYsWKFaxcuZK0tDTP4ysqKoiMjPRK2+XEpZ5rEZHjSPfu3XnyySeprq5m8eLF3xlnKtJZ/P3vf2fx4sWsWrWK3/3udzzzzDM8//zzAO0WS4qNjeXhhx/mnHPOYdy4ce16qxWs5ZegnmsRkeNQVlYWkyZNYty4ccyaNcvbzRE56rKysvD19SU5OZnMzExefPFFNm7cyKRJk7j22muB9j3YpaWl3HTTTezZs4ft27djs9k0dEp+EQrXIiLHqfz8fBISEn7wgkaRzqAtQB8+fJjFixf/aMB2OBwkJCR4s8lygtP8TCIix6mkpCSA/zhjiMiJri04d+3alSlTpgDwxhtvYJomU6ZMwWq1smbNGs444wxiYmK82VTpJBSuRUSOcwrWIm5tAds0Td58800iIiI4dOgQd955p+ebHpFfmsK1iIiInDC6du3KddddR2hoKFOnTqWlpYVNmzYpWMtRo3AtIiIiJ5SuXbtSWlpKU1MT69evZ8CAAd5uknQiuqBRRERETijPP/881113HVu2bGHYsGHebo50MgrXIiIickI5ePAgLS0t9OvXz9tNkU5I4VpEREREpIPoEnMRERERkQ6icC0iIiIi0kEUrkVEREREOojCtYiIiIhIB1G4FhERERHpIArXIiIiIiIdROFaROQEMHr0aAzDwDAMLBYL3bt354UXXvB2s0REOh2FaxGRE8TcuXOpra2lurqaF154genTp7Nnzx5vN0tEpFNRuBYROUH4+voSHBxMSEgIo0eP5le/+hWrV6/2drNERDoVhWsRkROU1WrFbrcza9Ysz5CR0aNHs3z5cnr27IlhGGzZsgWAkpISJk6cSFBQELGxsdx11104nc52P++TTz6hX79++Pv7M3z4cDZv3txu+65duxg1ahT+/v707t2bDz/8sN322tparr76amJiYggMDGTkyJGsWrWq3T6LFy+mT58++Pv7061bNx544IF27cjJyeG8884jICCA1NRUnnvuuXaPdzgc3H777SQmJuLv78/QoUN55513/udaioj8VArXIiInoMOHD7N+/XpGjBjB3XffTW1tLfPnz6exsZGVK1fy1VdfUVtby7BhwwC46qqriIiIYO/evXz55ZesXr2aRx99tN3Pu/LKK5k9ezY5OTnceOONTJgwAYfDAUBjYyPnnXcev//97zl06BALFy7kT3/6E5s2bfL8jPvvv5/CwkI2bdrEoUOH+NOf/sTcuXNxuVwA7NixgxkzZvDMM8+Qn5/Pm2++ybp169i2bRsApmly0UUXMXjwYA4ePMg777zDo48+yttvv+15jgULFrB69WpWrlxJbm4us2fP5sknn6S2tvYXr7mICACmiIgc984880wzKCjIjIqKMiMjI82AgABz1qxZ7fZ58sknzfj4eLOlpaXd/fv27TNDQ0PN5uZmz33ffPONmZCQ4Ll91113mTfeeGO7xxUVFXn+f/HixeYFF1zQbvvcuXPNq666ynP74osvNufOnfuDv8OHH35o9uvX7we3r1y50hw0aFC7+9566y3zjDPO8Ny+/fbbzalTp/7gzxAR+aX5eDvci4hIx7jjjju49tprsVgsxMXFYbVav7NPr169sNls7e7LyMggNTUVX19fz329e/emsLCQmpoaQkNDycjI4Iwzzmj3uLi4OM//79mzh88//5zo6GjPfc3NzfTr189z+/rrr+eyyy5j/fr1DBw4kOHDhzNu3DjP85555pn4+voyfPhwRowYwcCBAznvvPNISkryPMfevXvbPYfdbsff399z+w9/+ANnn302WVlZDBkyhCFDhjB+/HiCgoJ+Vi1FRP5bGhYiInKCCAsLIzk5mcTExO8N1gAWy8877Jum6flv2///kEsvvZQdO3Z4/mVkZPDRRx95tp9zzjlkZmYyefJkfH19eeSRRzj99NNpbm4GIDQ0lK1bt/L444/Tu3dvNmzYwIABA1i3bp3nZ4waNardc+zZs4ft27d7tg8ZMoTDhw9zyy23EBERwauvvsrAgQMpKyv7Wb+3iMh/S+FaRKSTS0tLIycnh5aWFs99+/fvJz4+nrCwMMDdk33w4MF2j8vMzPT8f//+/cnKyiI5Odnzr7GxkcDAQM8+tbW1REZGctFFF3Hffffx9ddfk5mZyc6dOwF3T7fT6WTUqFHccsstvPjii1x11VUsWbKk3XMkJiZ6nsMwDHx8fNo9R1BQEOeddx5/+ctf+OSTTwgJCeGrr77q+MKJiHwPhWsRkRNcS0sLdXV1tLS04HQ6qaur89wG6NOnDyNGjOCmm24iNzeX3bt3c+utt3L77bd7fsbUqVN54403WLp0KSUlJbzzzjuMGDGCyspKACZNmkRmZiYPPPAA+fn5bNy4kfPOO88zY4jdbuekk05i5syZHDp0iLKyMl566SXsdju9evUC4MEHH2TMmDFs3LiRyspKtm7dyooVKxgyZAgAv/71r4mMjOTmm28mOzubXbt2MWHCBBYvXuxp53nnnceNN97I3r17qaioYNmyZWRlZTFw4MCjUWoREV3QKCJyIjjzzDPNxx577Hu3zZw50wS+82/mzJmefYqLi82LL77YDAwMNKOjo82//vWvpsPhaPdzVq9ebfbt29f08/MzBw0aZH711Vfttu/atcv81a9+Zfr5+ZmpqanfaU9mZqb5+9//3oyMjDQDAwPNU045xfzyyy8921taWswHH3zQ7NGjh+nr62umpqaa999/v+lyuTz7ZGdnm+edd54ZEBBgxsXFmXfffXe7dpaUlJhTpkwx4+LiTH9/f3PgwIHmW2+99TOrKSLy3zNM80cG0YmIiIiIyE+iYSEiIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDqJwLSIiIiLSQRSuRUREREQ6iMK1iIiIiEgHUbgWEREREekgCtciIiIiIh1E4VpEREREpIMoXIuIiIiIdBCFaxERERGRDvL/TOV/WUC0uC0AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Sample data\n",
        "x = ['Total BF', 'Fingerprint BF', 'Internet search']\n",
        "y1 = [avg_time_mol_to_smiles, 0, 0]\n",
        "y2 = [avg_time_mol_from_smiles, 0, 0]\n",
        "y3 = [avg_check, 0, 0]\n",
        "y4 = [0, total_avg_fp_time, 0]\n",
        "y5 = [0, 0, avg_api_time]\n",
        "\n",
        "plt.figure(figsize=(8, 6))\n",
        "\n",
        "# Create the first stacked bar with different colors\n",
        "bottom_y2 = [sum(y) for y in zip(y1)]\n",
        "bottom_y3 = [sum(y) for y in zip(y1, y2)]\n",
        "\n",
        "plt.bar(x[0], y1[0], color='darkgray', label='Obj -> Can Smi')\n",
        "plt.bar(x[0], y2[0], color='gray', bottom=bottom_y2[0], label='Smi -> obj')\n",
        "plt.bar(x[0], y3[0], color='yellow', bottom=bottom_y3[0], label='Check')\n",
        "\n",
        "# Add the other bars normally\n",
        "plt.bar(x[1:], y4[1:], color='lightblue', label='Fingerprint BF')\n",
        "plt.bar(x[1:], y5[1:], color='purple', label='Internet search')\n",
        "\n",
        "# Set plot title and axis labels\n",
        "plt.title('Time usage comparison')\n",
        "plt.xlabel('Processes')\n",
        "plt.ylabel('Time (s)')\n",
        "plt.yscale('log')\n",
        "#plt.yticks(ticks=plt.yticks()[0], labels=[f\"{tick:.6f}\" for tick in plt.yticks()[0]])\n",
        "formatter = FuncFormatter(lambda y, _: f\"{y:.1e}\")\n",
        "plt.gca().yaxis.set_major_formatter(formatter)\n",
        "\n",
        "# Rotate x-axis labels\n",
        "plt.xticks(rotation=45)\n",
        "\n",
        "# Add gridlines\n",
        "plt.grid(axis='y', which='both', linestyle='--', linewidth=0.5)\n",
        "\n",
        "# Add a horizontal line at y=0\n",
        "plt.axhline(0, color='black', linewidth=0.5)\n",
        "\n",
        "# Add legend\n",
        "plt.legend(loc='upper left')\n",
        "\n",
        "# Show plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "ddda8b44",
      "metadata": {
        "id": "ddda8b44",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "253cd75f-c620-492d-af57-208ae64cc2e2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.00015385545245535665\n",
            "0.00024371773189666723\n",
            "8.832443459037905e-07\n",
            "0.002977575036388041\n",
            "0.7583516907691955\n"
          ]
        }
      ],
      "source": [
        "print(avg_time_mol_to_smiles)\n",
        "print(avg_time_mol_from_smiles)\n",
        "print(avg_check)\n",
        "print(total_avg_fp_time)\n",
        "print(avg_api_time)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8f95cdd2",
      "metadata": {
        "id": "8f95cdd2"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "molbloom",
      "language": "python",
      "name": "molbloom"
    },
    "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"
    },
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}