tensorvijay · September 4, 2024 06:48
diff --git a/copy-of-python_assignment.ipynb b/copy-of-python_assignment.ipynb
 {
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "1Ynqdu8OeZHyNk3nRQsPN8u8JSnjMfYjA",
      "authorship_tag": "ABX9TyN59jdLovanwBNV75rGpblg",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/tensorvijay/3b26147e61455d716a9cb9e5151c817c/copy-of-python_assignment.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hPmvdLWkc9MN"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import os"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. A shopkeeper want to give his clients the balance amount with minimum number of notes.\n",
        "Write a program to find out the notes and their counts, so that the total number of notes is\n",
        "minimum.\n",
        "Eg: If he has entered 1339, the system should display ( the counts given for 5 in the question is wrong )"
      ],
      "metadata": {
        "id": "N0s4eJNgRDFv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def c_n_notes(m,n):    # current and next notes\n",
        "  return m // n, m %n"
      ],
      "metadata": {
        "id": "mbRnPx93sR_D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def r_m_change(a):\n",
        "  counts = []\n",
        "  notes = [\"2000\", \"500\", \"200\",\"100\",\"50\",\"20\",\"10\",\"5\",\"2\",\"1\"]\n",
        "  for i in notes:\n",
        "    m,n = c_n_notes(a,int(i))\n",
        "    counts.append(m)\n",
        "    a=n\n",
        "  data = {\"Notes\":notes,\"Counts\":counts}\n",
        "  df=pd.DataFrame(data)\n",
        "  return df\n"
      ],
      "metadata": {
        "id": "CjjBpVCENZet"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "r_m_change(2339)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "d5GgwudaDaaD",
        "outputId": "0382834a-0a41-46fc-f0f0-071f099ab05d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "  Notes  Counts\n",
              "0  2000       1\n",
              "1   500       0\n",
              "2   200       1\n",
              "3   100       1\n",
              "4    50       0\n",
              "5    20       1\n",
              "6    10       1\n",
              "7     5       1\n",
              "8     2       2\n",
              "9     1       0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-7efbb05d-db67-4d15-8b38-3277e4e1b956\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Notes</th>\n",
              "      <th>Counts</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2000</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>500</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>200</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>100</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>50</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>20</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>10</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>5</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>2</td>\n",
              "      <td>2</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-7efbb05d-db67-4d15-8b38-3277e4e1b956')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-7efbb05d-db67-4d15-8b38-3277e4e1b956 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-7efbb05d-db67-4d15-8b38-3277e4e1b956');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-726ab274-57e2-4ecb-adb8-175fc33dd24c\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-726ab274-57e2-4ecb-adb8-175fc33dd24c')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-726ab274-57e2-4ecb-adb8-175fc33dd24c button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "summary": "{\n  \"name\": \"r_m_change(2339)\",\n  \"rows\": 10,\n  \"fields\": [\n    {\n      \"column\": \"Notes\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 10,\n        \"samples\": [\n          \"2\",\n          \"500\",\n          \"20\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Counts\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 2,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          1,\n          0,\n          2\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Get a number, Make the 2 MSBs one. Print the result – both as decimal and binary."
      ],
      "metadata": {
        "id": "8RP5K_xFSu7O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def bin_dec(bl):\n",
        " dl=[]\n",
        " #l,_=bl\n",
        " ind=0\n",
        " for i in bl:\n",
        "  ind+=1\n",
        "  p=2**(ind-1)\n",
        "  dl.append(int(i)*p)\n",
        "  #dl.append(int(i)*2**(ind-1))\n",
        " dec=sum(dl)\n",
        " return dec\n",
        "\n",
        "def dec_bin(a):\n",
        "  bin=[]\n",
        "  mm=['1','1']\n",
        "  while a >0:\n",
        "   r=a%2\n",
        "   q=a//2\n",
        "   bin.append(str(r))\n",
        "   #bin[::-1]\n",
        "   a=q\n",
        "  #print(\"odec,obin,mdec,mbin\",a,\"\".join(bin[::-1],bin_dec(bin[:-2]+mm),\"\".join(bin[:-2]+mm)))\n",
        "  return bin\n",
        "\n",
        "def fprint(a):\n",
        "  t1=dec_bin(a)  #before we get the reverse\n",
        "  t2=t1[:-2]+['1','1']\n",
        "  print(\"od,ob,md,mb\",a,\"\".join(t1[::-1]),bin_dec(t2),\"\".join(t2[::-1]))  #original decimal, original binary, modified decimal, modified binary\n"
      ],
      "metadata": {
        "id": "eov9laF8RA65"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fprint(10)    #original decimal, original binary, modified decimal, modified binary"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i2COvrM8KTqX",
        "outputId": "50b86f92-9a8a-4131-e95f-4ac312df5dce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "od,ob,md,mb 10 1010 14 1110\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Caesar cipher is a method to encrypt (make a secret code) a string. It is achieved by\n",
        "advancing each digit n places. Write a program to read a text file, get the string and encrypt\n",
        "it first using Caesar and then XORing with a salt and write it back to <filename>_enc.txt.\n",
        "Eg: abcd\n",
        "places to shift: 3\n",
        "Encrypted Caesar String: defg\n",
        "Now encrypt it with a salt lets say ‘abc’"
      ],
      "metadata": {
        "id": "Ud-Vi8pgT_dN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cixor(source,tshift,salt):\n",
        " #tshift=4\n",
        " k=0\n",
        " result = []\n",
        " salt\n",
        " filename=os.path.basename(source)\n",
        " #print(source)\n",
        " with open(source, \"r\") as f:\n",
        "  for line in f:\n",
        "    for word in line: #line.split():\n",
        "      #print(word)\n",
        "      for char in word:\n",
        "        if char.isalpha():\n",
        "          k+=1\n",
        "\n",
        "          slt=ord(salt[k%len(salt)])\n",
        "          fin=chr((((ord(char)+tshift-97)%26+97)^slt)+97)\n",
        "\n",
        "          result.append(fin)\n",
        "\n",
        "        if char.isspace():\n",
        "          #print(char)\n",
        "          result.append(char)\n",
        "\n",
        "  tog=\"\".join(result)\n",
        "  with open(filename + \"_enc\",'w') as f:\n",
        "    f.write(tog)\n",
        "  return \"\".join(result)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "-nMDEpuMQZOg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "p5W70TbB7YZ9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "txt=cixor(\"/content/Textfileforpythonassignment\",7,\"abc\")\n",
        "txt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "id": "6vrlhdWgmvHb",
        "outputId": "08d7213e-0d7f-4254-c2f4-57ff76093fbc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'io l gpyo cx rvxq vco{ anp fnvso hx|qk dv mswk uba dmn ivdxcye xxyc ysjorf nxixgpk gtan lsr coo hnkqan uxgpy kwk lpjach dmjd wjdbyo jjx knycxg luj tu yvvo uskjny l co{h vlykiryp xx pj|co i coswt i zoubsj uxswa dv lxirk \\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 228
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import csv"
      ],
      "metadata": {
        "id": "sfLguQ61jAzc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def rdwrt_csv(source):\n",
        "  nums = []\n",
        "  ncsv = []\n",
        "  with open(source, 'r') as f:\n",
        "    reader = csv.reader(f)\n",
        "    next(reader, None)\n",
        "    for row in reader:\n",
        "      ncsv.append((row[0], row[1]))\n",
        "      try:\n",
        "        tmp = int(row[1])\n",
        "        nums.append(tmp)\n",
        "      except ValueError:\n",
        "        pass\n",
        "  ncsv.append(('Average', avsum(nums)))\n",
        "  ncsv.append(('Variance', var(nums)))\n",
        "  ncsv.append(('std', np.sqrt(var(nums))))\n",
        "  return ncsv,nums\n",
        "\n",
        "def avsum(nmb):\n",
        "  #tmp=nmb\n",
        "  sum=0\n",
        "  for i in nmb:\n",
        "   #print('number',i)\n",
        "   sum += i\n",
        "   #print('sum',sum)\n",
        "  return round(sum/len(nmb),2)\n",
        "\n",
        "def write(source):\n",
        " with open(source, 'w') as f:\n",
        "  writer = csv.writer(f)\n",
        "  writer.writerow(['Average',vsum(rdwrt_csv(source))])\n",
        "  #writer.writerow([vsum(rdwrt_csv(source))])\n",
        "  #f.write(str(vsum(rdwrt_csv(source))))\n",
        "  #reader = csv.reader(f)\n",
        "\n",
        "def var(nmb):\n",
        "  mu=avsum(nmb)\n",
        "  return avsum((np.array(nmb)-mu)**2)\n"
      ],
      "metadata": {
        "id": "xoBpKxMyj6xU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loc='/content/sample_test.csv'\n",
        "tocsv,nums=rdwrt_csv(loc)"
      ],
      "metadata": {
        "id": "VOsWlFk6Mn_R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "with open('newsample.csv', 'w', newline='') as csvfile:\n",
        "    writer = csv.writer(csvfile)\n",
        "    writer.writerow(['Username', 'Identifier'])\n",
        "    writer.writerows(tocsv)"
      ],
      "metadata": {
        "id": "K1sEeBM9Y1IZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "WrX-8m84aOYa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tocsv[0][0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "-wQJzYHibPQ6",
        "outputId": "4347d687-9fa0-41e5-d248-298753675693"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'booker12'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 372
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "keys, values = zip(*tocsv)\n",
        "n_n_v = list(map(int, values))"
      ],
      "metadata": {
        "id": "5MaLKtyfjInK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "non_numeric_values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iknFlr1Qjzn3",
        "outputId": "4b72fef4-cf20-4f6a-9f10-694cc2285b0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[9012, 2070, 4081, 9346, 5079, 1234, 5678, 22323, 1233, 6672, 38683511, 6219]"
            ]
          },
          "metadata": {},
          "execution_count": 380
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10, 5))\n",
        "bar=plt.bar(keys, n_n_v, color='blue',width=0.5)\n",
        "bar[-1].set_color('red')\n",
        "bar[-2].set_color('green')\n",
        "bar[-3].set_color('black')\n",
        "plt.xticks(rotation=45, ha='right')\n",
        "plt.yscale('log')\n",
        "plt.xlabel('Usernames and metrics')\n",
        "plt.ylabel('Identifiers')\n",
        "plt.title('Bar plot of data')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 534
        },
        "id": "kmJcu7CjY6E7",
        "outputId": "6fc080a7-9ef2-4b8e-d67c-5257f54d7d59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import json"
      ],
      "metadata": {
        "id": "lk0LbW8dY4rS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. Write a program to compare two JSONS which are structurally similar. The output should be\n",
        "another JSON which contains the tags that has different values. You may expect the JSONS\n",
        "can have nested structures."
      ],
      "metadata": {
        "id": "02AIo8ZUT233"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def strtonum(word):\n",
        "    date = word.split('-')\n",
        "    day = int(date[0])\n",
        "    month = int(date[1])\n",
        "    year = int(date[2])\n",
        "    return day, month, year\n",
        "\n",
        "def compare_dates(info1, info2):\n",
        "    date1 = info1['dob']\n",
        "    date2 = info2['dob']\n",
        "    date11, date22 = strtonum(date1), strtonum(date2)\n",
        "    yr = abs(date11[0] - date22[0])\n",
        "    mnth = abs(date11[1] - date22[1])\n",
        "    day = abs(date11[2] - date22[2])\n",
        "    return str(yr * 365 + mnth * 30 + day)\n",
        "\n",
        "def only_in(info1, info2):\n",
        "    keys_list1 = list(info1.keys())\n",
        "    keys_list2 = list(info2.keys())\n",
        "    if len(keys_list1) > len(keys_list2):\n",
        "        for x in keys_list1:\n",
        "            if x not in keys_list2:\n",
        "                return x + \": Only in 1\"\n",
        "    else:\n",
        "        for x in keys_list2:\n",
        "            if x not in keys_list1:\n",
        "                return x + \": Only in 2\"\n",
        "\n",
        "def name_change(info1, info2):\n",
        "    if info1[\"name\"] != info2[\"name\"]:\n",
        "        return \"Text change\"\n",
        "    return None\n",
        "\n",
        "def dec_comp(info1, info2, key):\n",
        "    return str(round(info1[key] - info2[key], 2))\n",
        "\n",
        "def create_Json(info1, info2):\n",
        "    data3 = {}\n",
        "\n",
        "    # Compare numeric keys only if they exist in both JSON objects\n",
        "    for key in ['x', 'y', 'z']:\n",
        "        if key in info1 and key in info2:\n",
        "            data3[key] = dec_comp(info1, info2, key)\n",
        "        elif key in info1:\n",
        "            data3[key] = \"Only in 1\"\n",
        "        elif key in info2:\n",
        "            data3[key] = \"Only in 2\"\n",
        "\n",
        "    # Handle name comparison\n",
        "    name_diff = name_change(info1, info2)\n",
        "    if name_diff:\n",
        "        data3['name'] = name_diff\n",
        "\n",
        "    # Handle date comparison\n",
        "    data3['dob'] = compare_dates(info1, info2)\n",
        "\n",
        "    # Handle any additional keys that may be missing in one of the JSONs\n",
        "    only_in_key = only_in(info1, info2)\n",
        "    if only_in_key:\n",
        "        key, value = only_in_key.split(\":\")\n",
        "        data3[key] = value.strip()\n",
        "\n",
        "    return json.dumps(data3, indent=4)\n",
        "\n",
        "# Example data\n",
        "data1 = '''{\n",
        "    \"x\": 10.1,\n",
        "    \"y\": 20,\n",
        "    \"name\": \"Anu\",\n",
        "    \"dob\": \"2010-10-10\"\n",
        "}'''\n",
        "\n",
        "data2 = '''{\n",
        "    \"x\": 10,\n",
        "    \"y\": 20,\n",
        "    \"name\": \"Ani\",\n",
        "    \"dob\": \"2010-10-11\",\n",
        "    \"z\": 100\n",
        "}'''\n",
        "\n",
        "info1 = json.loads(data1)\n",
        "info2 = json.loads(data2)\n",
        "\n",
        "output_json = create_Json(info1, info2)\n",
        "print(output_json)\n",
        "\n",
        "# Example data\n",
        "data1 = '''{\n",
        "    \"x\": 10.1,\n",
        "    \"y\": 20,\n",
        "    \"name\": \"Anu\",\n",
        "    \"dob\": \"2010-10-10\"\n",
        "}'''\n",
        "\n",
        "data2 = '''{\n",
        "    \"x\": 10,\n",
        "    \"y\": 20,\n",
        "    \"name\": \"Ani\",\n",
        "    \"dob\": \"2010-10-11\",\n",
        "    \"z\": 100\n",
        "}'''\n",
        "\n",
        "info1 = json.loads(data1)\n",
        "info2 = json.loads(data2)\n",
        "\n",
        "output_json = create_Json(info1, info2)\n",
        "print(output_json)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9QjlLtNjRLN1",
        "outputId": "f57ff365-79a6-434a-c726-41445e2294a1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{\n",
            "    \"x\": \"0.1\",\n",
            "    \"y\": \"0\",\n",
            "    \"z\": \"Only in 2\",\n",
            "    \"name\": \"Text change\",\n",
            "    \"dob\": \"1\"\n",
            "}\n",
            "{\n",
            "    \"x\": \"0.1\",\n",
            "    \"y\": \"0\",\n",
            "    \"z\": \"Only in 2\",\n",
            "    \"name\": \"Text change\",\n",
            "    \"dob\": \"1\"\n",
            "}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. Calculate Cos (x) using Maclaurin Series and plot the series with matplotlib\n",
        "You should implement a package mymath and import that. Don’t use any of the prebuilt\n",
        "libraries for finding power or factorial."
      ],
      "metadata": {
        "id": "5-I6JZR7-xZ5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Contents of the Mymath.pyfile"
      ],
      "metadata": {
        "id": "6N84L97Cv7hj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "contents of the mymath.py file\n",
        "def factorial(n):\n",
        "  if n == 0:\n",
        "    return 1\n",
        "  else:\n",
        "    return n * factorial(n-1)\n",
        "\n",
        "def tcos(x):\n",
        " res=0\n",
        " for i in range(1,34):\n",
        "  res+=power(-1,i)*power(x,(2*i))/factorial(2*i)\n",
        " return 1+res\n",
        "\n",
        "def power(n,p):\n",
        "  if p==1:\n",
        "    #print(\"hai\",n,p)\n",
        "    return n\n",
        "  else:\n",
        "    #print(\"hello\",n,p)\n",
        "   # print(p)\n",
        "    return n*power(n,p-1)\n",
        "\n",
        "def series(li):\n",
        "  x=[]\n",
        "  for i in range(0,li):\n",
        "    x.append(i)\n",
        "  return x\n",
        "\n",
        "def tcoslist(x,li):\n",
        "  tli=[]\n",
        "  for i in x:\n",
        "   tli.append(tcos(x[i],li))\n",
        "  return tli\n",
        "\n",
        "'''"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "id": "dztSL1XOvpn7",
        "outputId": "d47fe937-3ff7-4f1c-c788-70f3855fd1fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\ncontents of the mymath.py file\\ndef factorial(n):\\n  if n == 0:\\n    return 1\\n  else:\\n    return n * factorial(n-1)\\n\\ndef tcos(x):\\n res=0\\n for i in range(1,34):\\n  res+=power(-1,i)*power(x,(2*i))/factorial(2*i)\\n return 1+res\\n\\ndef power(n,p):\\n  if p==1:\\n    #print(\"hai\",n,p)\\n    return n\\n  else:\\n    #print(\"hello\",n,p)\\n   # print(p)\\n    return n*power(n,p-1)\\n\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 188
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install /mymath_package.tar.xz"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 292
        },
        "id": "i2m5oxXv8mAa",
        "outputId": "1862bfc2-3335-487c-85e4-8c4bbbb07808"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processing /mymath_package.tar.xz\n",
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Building wheels for collected packages: mymath_package\n",
            "  Building wheel for mymath_package (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for mymath_package: filename=mymath_package-0.1-py3-none-any.whl size=1659 sha256=4606cce4f8cd40dbf80d07444e4dd787d2c47e9d00bc1ade9e87bdce88a59ce4\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-scchvquc/wheels/ad/4f/96/d63443594eb3e8212263a89fe67af1c5c853116b1050d20417\n",
            "Successfully built mymath_package\n",
            "Installing collected packages: mymath_package\n",
            "Successfully installed mymath_package-0.1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "mymath"
                ]
              },
              "id": "643a314c271d44688ecf9d5b4775f2aa"
            }
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "-_lPQ1oO-X-n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from mymath import factorial, tcos, power, series, tcoslist\n",
        "\n",
        "# Example usage\n",
        "print(factorial(5))\n",
        "print(tcos(0.5,20))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5q5tiuvK9ssp",
        "outputId": "d851fb10-3fee-451e-831d-ae169a091f62"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n",
            "0.8775825618903728\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x1=series(20)\n",
        "plt.plot(x1,tcoslist(x1,34))\n",
        "plt.xlabel('range')\n",
        "plt.ylabel('value')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "R4cYsHzZ-NHv",
        "outputId": "2da03673-844e-4e73-8097-6793c75ba2ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'value')"
            ]
          },
          "metadata": {},
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7aklEQVR4nO3deXxU9b0//teZNfu+QyAJW4JAQJQYl6o1StRb4daqWC3qF/FXK+1VtCr3Vmm1lWqt7dVarQuCdbet1movCijaIoKCrLKFrEAmezJZZz2/P2bOSQaSyTYz55yZ1/PxmEdLcubkc5ztPZ/P+/3+CKIoiiAiIiKiQemUHgARERGRmjFYIiIiIvKDwRIRERGRHwyWiIiIiPxgsERERETkB4MlIiIiIj8YLBERERH5YVB6AOHA7Xbj5MmTiI+PhyAISg+HiIiIRkAURXR2diInJwc63dDzRwyWAuDkyZPIzc1VehhEREQ0BnV1dZg4ceKQv2ewFADx8fEAPP+xExISFB4NERERjYTVakVubq78OT4UBksBIC29JSQkMFgiIiLSmOFSaJjgTUREROQHgyUiIiIiPxgsEREREfnBYImIiIjIDwZLRERERH4wWCIiIiLyg8ESERERkR8MloiIiIj8YLBERERE5AeDJSIiIiI/NBUsffbZZ/jOd76DnJwcCIKAd999d9j7bNmyBWeeeSbMZjOmTp2KdevWnXbM008/jby8PERFRaGkpAQ7duwI/OCJiIhIkzQVLHV3d6O4uBhPP/30iI6vqqrClVdeiYsvvhi7d+/GnXfeiVtvvRUffvihfMybb76JlStXYvXq1di1axeKi4uxcOFCNDY2BusyiIiISEMEURRFpQcxFoIg4J133sHixYuHPOa+++7DBx98gP3798s/W7JkCdrb27FhwwYAQElJCc4++2z84Q9/AAC43W7k5ubixz/+Me6///4RjcVqtSIxMREdHR0B3UjX4XJjV00bFuSnDLvJHxEREY3OSD+/NTWzNFrbtm1DWVmZz88WLlyIbdu2AQDsdjt27tzpc4xOp0NZWZl8zGBsNhusVqvPLdAcLjdK12zGdc99gWNN3QE/PxEREY1MWAdLFosFmZmZPj/LzMyE1WpFb28vmpub4XK5Bj3GYrEMed41a9YgMTFRvuXm5gZ87Ea9DmfkJAIANn7TEPDzExERacHWimZUNSs7aRDWwVKwrFq1Ch0dHfKtrq4uKH+nbKYniNt0kMESERFFHqfLjXv/shcXP74FWw4rl0sc1sFSVlYWGhp8A42GhgYkJCQgOjoaaWlp0Ov1gx6TlZU15HnNZjMSEhJ8bsFQVpQBANhV24bmLltQ/gYREZFabTrYiBPtvUiOMeKcglTFxhHWwVJpaSk2b97s87ONGzeitLQUAGAymTB//nyfY9xuNzZv3iwfo6TsxGjMnpAIUQQ+PsjqPCIiiizrPq8CACxZMAlRRr1i49BUsNTV1YXdu3dj9+7dADytAXbv3o3a2loAnuWxpUuXysf/8Ic/RGVlJe69914cOnQIf/zjH/HWW2/hrrvuko9ZuXIlnn/+eaxfvx4HDx7E7bffju7ubtxyyy0hvbahlBV5luI2cimOiIgiyCGLFV9UtkKvE3DjOZMVHYtB0b8+Sl999RUuvvhi+d8rV64EANx0001Yt24d6uvr5cAJAPLz8/HBBx/grrvuwv/+7/9i4sSJeOGFF7Bw4UL5mOuuuw5NTU148MEHYbFYMHfuXGzYsOG0pG+llM3MwO82HcG/jjahz+FSNLImbXC63NhyuAnnTk1FjElTL3EiItn6z6sBAAvPyMSEpGhFx6LZPktqEqw+SwAgiiLOf/QTnGjvxYs3nYVLitQRxJF6vbq9Bv/zzn6cU5CC1249Bzode3QRkba099hxzprN6HO48eZt56AkSPlK7LMUJgRBkBO92UKARmLbsRYAwBeVrVi/rVrZwRARjcGbX9ahz+FGUXYCFuSnKD0cBkta0N9CoBFuNycCyb+9xzvk///r/zuEY01dCo6GiGh0XG4RL2+rAQDcfO5kVexgwWBJA0ryUxFnNqC5y4Y9x9uVHg6pWFu3HbWtPQCAsyYnw+Z04+639sDpcis8MiKikdl0sAEn2nuRFGPEorkTlB4OAAZLmmAy6HDhjHQAbFBJ/u094ZlVykuNwVPfn4f4KAN217XjT59VKjwyIqKRWbe1GgCw5Gxl2wUMxGBJIy7zLsUxb4n82VvXDgCYMzEJ2YnR+MVVZwAAfr/pCL45Gfg9DImIAumwpRPbKlugE4AflCrbLmAgBksacdH0DOh1Ao40dKGmhRvr0uCkZdo5Ez37Cv7nvAm4bGYmHC4RK9/aDZvTpeDoiIj8Wye3C8hSvF3AQAyWNCIxxogFeZ6KgE3s5k2DEEURe7zJ3XNzkwB4qikf+e5spMSacMjSiSc3H1VwhEREQ+voceCdr48DAG46N0/ZwZyCwZKGyFVxXIqjQVisfWjqtEGvE3BGTqL887Q4Mx75z1kAgGe2HMOu2jalhkgRrKXLhre+qkOdtwCB6FRvflWLPocbhVnxKFFBu4CBGCxpyKXehpQ7qlvR3mNXeDSkNnvqPLNK0zLiEG3yTYosn5WNxXNz4BaBe97ag147l+MoNI41deG/39mHc3/9Me79y1789zv7lB4SqZBvu4A8VbQLGIjBkoZMSo3BjMx4uNwithxuUno4pDJ7vflKxROTBv39L66ahcwEMyqbu/HohkOhGxhFHFEUsaOqFbeu/wplT3yK17bXwub0tK/YXdsObhxBp9p8sAHH29TVLmAgBksaUzbT282bLQToFHJyd27ioL9PjDHi0avnAPAkUX5+rDlUQ6MI4XS58cHeeiz+4+e49k/bsOlgA0TRsyH4a7eWwKTXodPmxPG2XqWHSiojJXZfd3buaTPjasBgSWMunZkFAPj0cBMrm0jmdoty5+6hZpYA4KIZGfh+ySQAwE/f3ovOPkcohkdhrtvmxEtbq3Dxb7fgjtd2YU9dO0wGHa5fMAmb774QL9x0Fs6dmoapGXEAgIP1bGNB/Y40dOLzY952Aeeop13AQNySXGPmTEhEerwZTZ02bK9sxbempys9JFKB6pZudPY5YTboMCMr3u+x/31FEf51tAl1rb345fsH8ej35oRolBRuGq19WPd5NV75ogbWPicAIDnGiB+U5mFp6WSkxZl9ji/KTsA39VYcrO/EZWdkKTFkUiFpVumymVmYmByj7GCGwGBJY3Q6z8a6r++ow6aDDQyWCED/fnAzcxJg1PufMI4zG/D494qx5Pkv8OZXdVg4KxPfLswMxTApTBy2dOKFf1Xi3d0n4HB58o/y02Kx7Px8XH3mxCGXUYqyPYE8Z5ZI0tHjwDu7TgBQX7uAgbgMp0FlRf0tBJgoSUB/vpK/JbiBSgpSsey8fADAfX/dh7ZuVleSf6IoYmtFM25auwMLf/8Z3t55HA6XiLPzkvGnH8zHppUX4sZzJvvNNynKTgAAHLIwWCKPt76qQ6/DhcKseJxToK52AQNxZkmDzpuahmijHic7+nDgpBWzJgye0EuRQ5pZkjp3j8Q9C2dgy5EmVDR24cH3DuCp6+cFa3ikYQ6XG+/vPYnnP6vCN94ZIZ0AlM/Kwq0XFODMSckjPlehd4m4prUH3TYnYs38CIpkLreIl7+oBuCZVVJbu4CBOLOkQVFGPS6YlgaAG+uS58Nsv3cD3WJv5+6RiDLq8dtriqHXCfjHnpN4f+/JII2QtMja58Bznx3Dtx77BHe9uQff1FsRbdTjptLJ+OSei/DHG+aPKlACgNQ4MzLizRBF4JClM0gjJ634+FAj6lp7kRhtxGIVtgsYiMGSRsndvBksRbwjDZ2wOd2INxuQnxo7qvsW5ybhjoumAAB+9u5+NHb2BWOIpCEn23vxqw++wblrPsYj/zyE+o4+pMWZcc9l0/H5/d/GLxbNwuRRPs8G4lIcSdZ7E7uXqLRdwECcA9WobxdmQBCA/SesqO/oRXaiejYcpNCSluBmT0yETjf6aewV356GzYcaceCkFav+ug8v3HSWqqfDKXh+/t4BvPJFDZxuTy7k1Iw43HZBAa6am4MoY2A+zIqyE/DpkSYmeUe4ow2d+HdFM3QCcKNK2wUMxJkljUqLM2O+dwqce8VFNqlz95wRJnefymTQ4bfXFsOk12HzoUa8vfN44AZHmlHf0Yt1n1fD6RZRWpCKl24+Gx/d+S1ce3ZuwAIlYGBFHJfhIpnULuDSmZnITVFnu4CBGCxpmLQUt/Fgo8IjISVJe8IVjyK5+1SFWQm469LpAICH/vENjrdxs9NIc6ShC4BnNun1287BxYUZY5qpHI60DHfY0gm3m9W8kaij14G/aaBdwEAMljRMaiGw7VgzOzFHqF67C4cbPN/QR5PcPZjbvlWAMyclocvmxL1/2csPsghz1Ps8mp4ZF9S/U5AWC5NBhy5uexKx3va2C5iRGY/SglSlhzMiDJY0bEp6LPLTYuFwifjsCPf5ikTf1HfA5RaRFmdGdmLUuM6l1wn47bVzEW3U4/NjLfjzFzUBGiVpwRFvsDQtw38H+PEy6HVyQPYN85Yijsst4uVtnvcWtbcLGIjBkoYJgoBLWRUX0QYuwQXiTSc/LRarrigEAKz5v4OobOoa9zlJG6RluOmZwQ2WAM+yL8BO3pHok0ONqG3t8bQLmJej9HBGjMGSxklLcR8faoTT5VZ4NBRq403uHsyNJZNx3tRU9DncuPvtPXBxOS7siaKIikYpWAruMhzA9gGRbP22agDAdWfnIsaknYJ8Bksad+akJCTHGNHR68BXNW1KD4dCTO7cnRu4Lu46nYDHvleMeLMBX9e240+fHQvYuUmdTnb0ocvmhEEnjKuH0kixIi4yHW3oxL+OetoF/EAD7QIGYrCkcQa9Tt4EdSNbCESUjl4HKpu7AYx8T7iRmpAUjQe/MxMA8LuNRzgDEOakfKV8b/J1sBV5l+FqW3tYnBJBpFmlsiJttAsYiMFSGLh0ZgYAT94SN9aNHPu8s0q5KdFIiTUF/Pzfmz8RZUUZcLhE3PXmHtidXOYNVxUhzFcCgORYE7ISPAUJUqBG4W1gu4CbNdIuYCAGS2HggmnpMOl1qGnpkfMOKPztCUK+0kCCIOCR785GcowRB+uteOrjo0H5O6Q8uRIuBPlKEmkp7hsuxUWEt7+qQ4/dhemZcSidoo12AQMxWAoDsWYDzp3qefJtZFVcxJCSu8fTjHI4GfFR+OXi2QCAP245ht117UH7W6ScI42hnVkCgMJsVsRFCq22CxiIwVKYkFoIMG8pcsjJ3UGaWZJcOScbVxXnwOUWcfdbu9HncAX171FoiaKIihA1pBxIrohjsBT2thz2tAtIiDLgP+dNUHo4Y8JgKUxc4k3y3l3Xzp3jI0CjtQ/1HX0QBGDWhODNLEkeWnQG0uPNONbUjd98eDjof49C50R7L7rtLhj1oamEk8z0LsMd4rYnYU/aB27JgkmaahcwkOaCpaeffhp5eXmIiopCSUkJduzYMeSxF110EQRBOO125ZVXysfcfPPNp/2+vLw8FJcSUFmJUZgzMRGi6Gn6ReFtj3dWaVpGHOLMwX/zSYox4bGr5wAA1m6twheVLUH/mxQaR73J3QVpcTDqQ/eRkJfqqbzrsbtQ28q9CMNVRWMX/nW0GYIG2wUMpKlg6c0338TKlSuxevVq7Nq1C8XFxVi4cCEaGwcPDv72t7+hvr5evu3fvx96vR7XXHONz3Hl5eU+x73++uuhuJyAkxpUbvyGwVK4C0YzyuFcXJiBJWfnQhSBe97egy6bM2R/m4JHSu6eGsIlOMDT9mRGpjS7xKW4cPWyhtsFDKSpYOmJJ57A8uXLccstt2DmzJl49tlnERMTg7Vr1w56fEpKCrKysuTbxo0bERMTc1qwZDabfY5LTk72Ow6bzQar1epzUwMpb+nfFU3otTOvJJxJM0vBTO4ezP9cWYQJSdE43taLDfstIf3bFBzyNidB3hNuMKyIC2/WPgf+svM4AG22CxhIM8GS3W7Hzp07UVZWJv9Mp9OhrKwM27ZtG9E5XnzxRSxZsgSxsb7r8lu2bEFGRgZmzJiB22+/HS0t/pcY1qxZg8TERPmWm5s7+gsKgsKseExIikafw41/V3Bj3XAliqIiM0sAEB9lRFmRp6/X0UZ+wIWDisbQJ3dLilgRF9be/uo4euwuTMuIw7kabBcwkGaCpebmZrhcLmRmZvr8PDMzExbL8N9wd+zYgf379+PWW2/1+Xl5eTlefvllbN68GY8++ig+/fRTXH755XC5hp6ZWbVqFTo6OuRbXV3d2C4qwHw21mVVXNiqa+1Fe48DRr2AwuzQzwZMyfB8qB5r7A7536bAcrtFHPW2DZgWwrYBEmlDXS7DhR+3W5SX4LTaLmAgbaalj8GLL76I2bNnY8GCBT4/X7Jkifz/Z8+ejTlz5mDKlCnYsmULLrnkkkHPZTabYTabgzresSorysS6z6ux+VADXG4Rep22n6B0ut3eWaWZ2QkwG/Qh//tT0j3BUmUTG6Bq3Yn2XvTYXTDpdchLDX0+yUzvzFJday86+xyIjzKGfAwUHFuONKKmpQfxUQZ890xttgsYSDMzS2lpadDr9Who8J0xaWhoQFZWlt/7dnd344033sCyZcuG/TsFBQVIS0tDRUXFuMarlJKCFMRHGdDcZWcDwTC11/u4hnoJTiIFSzWtPdwCReOkpdSC9FgYQlgJJ0mMMSIn0bPtySELl3XDybrPPU0ol5ydq9l2AQNpJlgymUyYP38+Nm/eLP/M7XZj8+bNKC0t9Xvft99+GzabDTfeeOOwf+f48eNoaWlBdnb2uMesBKNeh4tm9O8VR+GnvxllaJO7JZkJZsSa9HC5RdS2cilOy6TkbiWW4CTs5B1+jjV14bMjTd52AXlKDycgNBMsAcDKlSvx/PPPY/369Th48CBuv/12dHd345ZbbgEALF26FKtWrTrtfi+++CIWL16M1FTfBLOuri789Kc/xRdffIHq6mps3rwZixYtwtSpU7Fw4cKQXFMwSAm4zFsKPy63iP0nvZVwuUmKjEEQBDlvqYJ5S5om7wmXEfrkbolUEXeQFXFh42VvE8pLCjMxSYHl3WDQ1NzYddddh6amJjz44IOwWCyYO3cuNmzYICd919bWQqfzjf8OHz6Mf//73/joo49OO59er8fevXuxfv16tLe3IycnB5dddhkefvhh1eYkjcRFMzJg0Ak42tiF6uZu5KWFrisvBVdFYxd67C7EmPTycpgSpqTHYe/xDhxj3pKmSQ0plaiEk7AiLryEU7uAgTQVLAHAihUrsGLFikF/t2XLltN+NmPGDIji4K30o6Oj8eGHHwZyeKqQGG1ESUEKtla0YNPBBtx6QYHSQ6IA2ePNV5o9IVHR5P0p6Z4AnMGSdrndIioUrISTSBVxhy2dLEoJA3/56ji67S5MzYjDeVO13S5gIE0tw9HI9Xfz5lJcONnjrYRTaglOIs1qHWviMpxWnWjvRa/DUwk3WcHOyvlpsYgy6tDr4LYnWhdu7QIGYrAUpqRg6auaNrR12xUeDQWK0sndEilnqbKxa8iZW1I3KV9JqUo4iV4nyNuecClO2z490oRqqV3APO23CxiIwVKYyk2JQWFWPFxuEZ8c5l5x4cDmdMnN+4oVahsgmZwaA50AdNqcaOq0KToWGht5mxMFl+Ak0lIcgyVtW+dN7L7urFzEhmCD71BisBTG5G7ebCEQFg7Wd8LhEpEcY8TE5GhFx2I26DHJu3RTwbwlTTraoNw2J6diRZz2HWvqwqfedgFLS/OUHk7AMVgKY9JS3KeHm2BzcmNdrds7IF9JDbkAzFvStiPehpRKJndLWBGnfX/e5mlCeUlhRti0CxiIwVIYmz0hERnxZnTbXdh2zP/mwKR+uxXu3H2q/j3iOLOkNT6VcAr2WJJIjSlPtPeio9eh8GhotDr7HHj7K88eqTeFUbuAgRgshTGdTkAZl+LChpTcXaxwcreE7QO0q66tB30ON0wGHSanKt+HLTHaiAlJnqXlw9z2RHP+urO/XcD5U9OUHk5QMFgKc5d6l+I2fdPIqiUN67I55aBENTNL8oa6XIbTGqkZ5ZT0ONX0NerPW+JSnNZ8crgJgGcfODWkCAQDg6UwVzolFdFGPSzWPhw4yTchrdp3vAOiCOQkRiE9Xh3d5aVgybNzvVPh0dBoSPlKakjuljBvSbsqmz3B96wJ6pj1DgYGS2EuyqjHt6Z7pkU/YoNKzdqrkmaUAyXHmpASawLA2SWtOaqitgESuX0Al+E0xeZ04XhbLwBPz65wxWApAlw6MwsAN9bVMqlzt1qW4CTMW9ImNWygeyppGe6wxQqXmykDWlHT0gNRBOLMBqTHqWPWOxgYLEWAi2ekQycA39RbcaK9V+nh0BjsqVNXcreE7QO0xzWgEk5NM0uTU2MRbdSjz+FGdQufT1ohzSoXpMeGbb4SwGApIqTGmTF/cjIAYDOr4jSnpcsmB7mzVBsscWZJK+pae2BzumE26JCr4J5wp9LrBEzPYpK31kj5Svlp4bsEBzBYihhSN29urKs9UsuAgvRYJEQZFR6NrykZ3mU49lrSDGkJTk2VcJKZ3qW4Q+zkrRlV0sxSmnqWdIOBwVKEkLp5f1HZAmsfm75piZSvNFdl+UpA/8xSVXM380w04qi8BKe+DzdWxGlPZbMnWMoP4+RugMFSxChIj0NBeiwcLhGfHWlSejg0Cnvkzt3qWoIDgInJMTDpdbA53TjJfDhNkPaEU8M2J6fihrraU9UszSwxWKIw0d+gkktxWiGKorwMN0dFbQMkep0g5ypwQ11tOKLCtgGSQu8y3MmOPnT0cAZc7dp77GjttgNgzhKFESlv6eNDjXC43AqPhkbiRHsvWrrtMOgEzPQuUagN85a0w+UW5WR8NS7DJUQZMTHZs+3JQQtnl9ROWoLLSohCrNmg8GiCi8FSBJk3KRkpsSZY+5z4srpV6eHQCEizSjOy4hFl1Cs8msGxfYB21Hor4aKMOuQmq6cSbiAuxWmHlNwd7rNKAIOliKLXCfh2YQYAz15xpH57VNi5+1RsH6AdUiXc1Iw46FRWCSdhRZx2yG0Dwjy5G2CwFHGkqriNBy3cWFcDpORutTWjHKh/Q10GS2onJ3dnqC9fSSJXxHEZTvUiJbkbYLAUcb41PQ0mgw51rb1yoiepk9stYv8JzweG2rY5GUjaD6q5y472HrvCoyF/pNf8NBXmK0mkYOmwpRNO5laq2sDu3eGOwVKEiTEZcP5Uz8a6m9jNW9Uqm7vQZXMiyqhT1R5ep4o1G5CdGAWAeUtqJ/dYUvHM0qSUGMSY9LA53ahu6VF6ODQEt1scMLOk3venQGGwFIHkpTi2EFA1aT+4WTmJMOjV/VJl3pL6+VbCqTdY0ukEzOC2J6p3sqMXNqcbRr0gVzCGM3W/A1NQXFLkSfLeXdeORmufwqOhoezVQHK3ZIp3Gp7BknrVtHTD7nQj2qhX/YcbO3mrnzSrNCklRvVf5gIh/K+QTpOZECV/AG8+xKo4tdojNaNUcXK3ZIp3mfBYI5fh1ErKV1JzJZykiDNLqlcptw0I/yU4gMFSxLq0SGohwKU4NbI73fjmpOeDoljFyd0SVsSpX/82J+r/cJNmlg5Z2D5AraSZpSkRkNwNMFiKWJd485a2HmvmBqgqdNjSCbvLjcRoIyanqrN54EBSsFTT2gO7kxVManTEm9yt5rYBEilnqb6jjxWWKiUtuUdCQ0qAwVLEmp4ZD6NeQJ+DG6CqkdSMcs7ERAiCupdMACAzwYxYkx4ut4jaVi7FqZE0s6TGbU5OFR9lRG6KJ6/qGy7FqZJcCZeu/udTIDBYilB6nYBJKZ4Zi+oWfripjZzcrYElOAAQBEHOW6pg3pLqOF1uOcdEzZVwAxV5tz1hJ2/16XO4cML7JZszSxT2pMQ86RsCqcdeDSV3S9g+QL1qWntgd3kq4SYkqbsSTsKKOPWqaemBKALxUQakxZmUHk5IaC5Yevrpp5GXl4eoqCiUlJRgx44dQx67bt06CILgc4uKivI5RhRFPPjgg8jOzkZ0dDTKyspw9OjRYF+GKkhdVxksqUuP3Snv4aWFtgEStg9Qr4HJ3WqvhJMUefeI47Yn6lPl3ROuIC1WE2kCgaCpYOnNN9/EypUrsXr1auzatQvFxcVYuHAhGhuHLn9PSEhAfX29fKupqfH5/WOPPYYnn3wSzz77LLZv347Y2FgsXLgQfX3h338oL5XBkhrtP2GFW/TkAWUmRA1/B5Xon1ni80lt5G1ONJDcLZFmlo40dHHbE5U51hRZ+UqAxoKlJ554AsuXL8ctt9yCmTNn4tlnn0VMTAzWrl075H0EQUBWVpZ8y8zMlH8niiJ+//vf42c/+xkWLVqEOXPm4OWXX8bJkyfx7rvvDnlOm80Gq9Xqc9Miaa2ZwZK67JWTu5MUHcdoSTlLlY1d3KRZZY5oKLlbkpscg1iTHnanm+9RKiM9HpGSrwRoKFiy2+3YuXMnysrK5J/pdDqUlZVh27ZtQ96vq6sLkydPRm5uLhYtWoQDBw7Iv6uqqoLFYvE5Z2JiIkpKSvyec82aNUhMTJRvubm547w6ZUjLcMfbelnurSJSM8q5GlqCA4DJqTHQCUCnzYmmTpvSw6EBjjaof5uTU+l0Agq9s0usiFOXyghrGwBoKFhqbm6Gy+XymRkCgMzMTFgslkHvM2PGDKxduxZ///vf8corr8DtduPcc8/F8ePHAUC+32jOCQCrVq1CR0eHfKurqxvPpSkmI96MGG+5d10bN6xUi70D2gZoidmglyssK5i3pBoOlxuVzf3du7Wk0Ntvic0p1aW/bQCDpbBQWlqKpUuXYu7cubjwwgvxt7/9Denp6fjTn/40rvOazWYkJCT43LRIEIT+vCXmmahCW7cdNd6d1udMSFJ2MGPAvCX1qWnphsMlIsaknUo4CSvi1Ket2462HgcAziypUlpaGvR6PRoafLfnaGhoQFZW1ojOYTQaMW/ePFRUVACAfL/xnFPrpCc7ey2pw94TniW4vNQYJMYYFR7N6PXvEceZJbXoT+7WTiWchMGS+lR6Z5WyE6MQYzIoPJrQ0UywZDKZMH/+fGzevFn+mdvtxubNm1FaWjqic7hcLuzbtw/Z2dkAgPz8fGRlZfmc02q1Yvv27SM+p9ZJwVIlEyhVYW9dOwDtJXdL2D5AfaR8pWkayleSSNueNFhtaO3mtidqEIn5SoCGgiUAWLlyJZ5//nmsX78eBw8exO23347u7m7ccsstAIClS5di1apV8vEPPfQQPvroI1RWVmLXrl248cYbUVNTg1tvvRWAZxnqzjvvxC9/+Uu899572LdvH5YuXYqcnBwsXrxYiUsMOXlmicGSKuzRYDPKgfo31OXzSS2ONGqvEk4SZzbIeyMe4uySKkRivhIAaGoO7brrrkNTUxMefPBBWCwWzJ07Fxs2bJATtGtra6HT9cd/bW1tWL58OSwWC5KTkzF//nx8/vnnmDlzpnzMvffei+7ubtx2221ob2/H+eefjw0bNpzWvDJc5bF9gKpIyd1aq4STSMHSifZe9NidETVNr1b9DSm1N7MEeLY9qWnpwTf1Vpw7NU3p4UQ86YuQtANEpNDcO9mKFSuwYsWKQX+3ZcsWn3//7ne/w+9+9zu/5xMEAQ899BAeeuihQA1RUwq8wVJ9Rx967S5Em/QKjyhyWTr60Nhpg14n4Iwcbc4sJceakBJrQmu3HZVN3Zg1QZvXES4crv4eRVpqGzBQYXY8Nhyw4CD3iFOFSJ1Z0tQyHAVecqwJSd5EYiZ5K2u3N19pWkacpoNW5i2pR3WzpxIu1qRHTqI2Z8ulJO9D3PZEcW63iCrv50QBc5Yo0nDbE3WQluCKNZrcLWH7APWQKuGmZsZrdg+vmd5g6WhDFxzc9kRRJ9o9DYyNegETk2OUHk5IMVgi+RsCgyVl7ZWSu3O1vXTVHyxxZklp8jYnGmtGOdCEpGjEmQ2wu9wsHFCY9BkxOTUWeo21oRgvBkvEJG8VEEUxfGaWMrzLcOy1pLiKRu1tc3IqnU4Y0MmbS3FKktoGRNoSHMBgicANddWguqUH1j4nzAad3FtGq6SZparmbrjc3FBXSUfkSjjtziwB/XlL3CNOWfIGuhGW3A0wWCKw15Ia7PEmd8/MSYBRr+2X5cTkGJj0Oticbpxs71V6OBHL7tR+JZykMNszflbEKUtqXjwlwtoGAAyWCP3LcC3ddnR49/yh0NoTJktwAKDXCXIAzg11lVPd0g2nW0S82YBsjVbCSeSKOM4sKUruscSZJYpEcWYDMuLNACCXhVJo7dV45+5TMW9JedIS3NTMOM1WwkkKs+IhCEBjpw0tXTalhxOR+hwunOzwzBRH2lYnAIMl8uJSnHKcLjcOnPQES8Ua7dx9KrYPUN7ADXS1LsZkkFuccClOGdUt3RBFICHKgNRYk9LDCTkGSwSAG+oq6UhDF/ocbsSbDchPDY9vbGwfoDxpmxOt5ytJWBGnrP4lOO3PVI4FgyUCwIo4JUn5SrMnJkIXJr1L+jfUZbCklCMa3xPuVKyIU1aVnNwdHl/oRovBEgHoT/LmMlzoSf2V5oRBcrdE2jequcuO9h67wqOJPHanG9UtPQCA6RpvGyCRgiUuwylDmiWOxHwlgMESeQ3s4i2K7I0TSnvqvPlKYZLcDQCxAyqwmLcUelKPq3izAVkJ2q6Ek0jLcBWNndz2RAH9G+iGR/A9WgyWCAAwKTUGggB02Zxo7uJMQKj0OVw47F0uCZfkbgnzlpQzsBlluOSXTEyORnyUAQ6XyOeUAuSGlJxZokhmNugxISkaAPOWQunASStcbhFpcWbN98I51RTvUhw/2EIv3JK7AUAQBBRlSUtxzFsKpdZuO9q9PfgYLFHE60/y5odbqPTvB5cYNjMAkinekvVjjQy+Q01qGzA1DNoGDMRO3sqQPhNyEqMQbdIrPBplMFgiWX/eUo/CI4kc0jYn4ZTcLWFFnHKONIbfzBIwMMmbM0uhJOUdRmq+EsBgiQbI48xSyMmdu3PDJ7lbIgVLNa09sDuZkBsqNqcLNXIlXLgGS5xZCqVIz1cCGCzRAP1dvDmzFAodvQ65CWg47Al3qswEM2JNerjcImq4jU7IVDZ5K+GiDMhMMCs9nICanhkHQQCau2xo6uS2J6EizQ4XROCecBIGSySTc5ZauuF2s31AsO0/4ZlVyk2JRkoYbh8gCEJ/3hKX4kLmqHc/vumZ8WGXBxdj6u9yz07eocOZJQZLNMCEpGgY9QLsTre8YSIFz54wbEZ5Ku4RF3r9lXDhmV/CvKXQcrlFucHpFOYsEQEGvQ6TUmIAcCkuFKTk7nBqRnkquX1AI2eWQkXusZQRXvlKEqk5JfOWQuNkey/sTjdMBh1yvO1lIhGDJfLB9gGhIyd3R8TMEp9PoXK0oX8ZLhxxZim0pNduXmoM9GGyd+VYMFgiH1KwVMnGlEHV2NmH+o4+6ARg9oQwnlnK6F+G4zY6wdfncKHam0w/LVyX4XI8wdKxpi5WWYYA85U8GCyRD26oGxp7vfvBTc2IQ6zZoPBogmdyagx03m10Glm9FHSVTd1wi0BClAEZ8eFVCSfJSYxCgnfbkwou7wZdZZMULIVn8D1SDJbIR/6ADXUpePZGQHI34NlGR8qDY95S8B0d0Iwy3CrhJIIgoNC7FMeKuODr30CXM0tEsgLvt4e6tl7u7B1Eu735SuGc3C2ZyvYBISPlK00L03wlyUzmLYWMHCxxGY6oX2aCGdFGTyPBulZWxAWDKIoRM7MEsH1AKB0J87YBkiLuERcSvXYXTrR72shE8lYnAIMlOoUgCAO2PeGHWzAcb+tFe48DJr1O3hg0nLEiLnQGNqQMZ4VZXIYLBalYIDHaiOQYo8KjURaDJTpNAYOloJLySgrSY2E2hP8O3lMy2GspFPocLnlbmXCthJPMyIqHTgCau+xo7OxTejhhq7KpP18pXHPgRorBEp0mL82TkMtgKTikN6BI6YYr5cGd7OhDt82p8GjC17GmLrhFzyxAelx4VsJJoox6uRiFS3HBI/Xbi/S2AYAGg6Wnn34aeXl5iIqKQklJCXbs2DHksc8//zwuuOACJCcnIzk5GWVlZacdf/PNN0MQBJ9beXl5sC9D1aQSUQZLwVEZYX1LkmNNSPXufcfnVPD0N6OMi4hZgEImeQddpH2x80dTwdKbb76JlStXYvXq1di1axeKi4uxcOFCNDY2Dnr8li1bcP311+OTTz7Btm3bkJubi8suuwwnTpzwOa68vBz19fXy7fXXXw/F5ahWfpq05Qk/2IKhqinySnGZtxR88jYnYZ6vJJEq4g4xWAqaSPti54+mgqUnnngCy5cvxy233IKZM2fi2WefRUxMDNauXTvo8a+++ip+9KMfYe7cuSgsLMQLL7wAt9uNzZs3+xxnNpuRlZUl35KTk0NxOaqVP2DZpNfuUng04ScSO+Iybyn4jkgzSxmRMQvAirjgEkURld4vN5H0xW4omgmW7HY7du7cibKyMvlnOp0OZWVl2LZt24jO0dPTA4fDgZSUFJ+fb9myBRkZGZgxYwZuv/12tLS0+D2PzWaD1Wr1uYWT5BgjEqM9lQ81rZxdCqRumxMWqychtSCCOuKyfUDwVQxoSBkJpIq4Y01dsDn5pS7QWrvtsPY5IQhAXiqDJc0ES83NzXC5XMjMzPT5eWZmJiwWy4jOcd999yEnJ8cn4CovL8fLL7+MzZs349FHH8Wnn36Kyy+/HC7X0C++NWvWIDExUb7l5uaO7aJUyqd9AD/cAkqaVUqNNSExgkpxuQwXXH0OF2q8fdEiZRkuOzEKidFGON3c9iQYpCW4nMRoRBnDv2p3OJoJlsbr17/+Nd544w288847iIqKkn++ZMkSXHXVVZg9ezYWL16M999/H19++SW2bNky5LlWrVqFjo4O+VZXVxeCKwitAm6oGxSRmgMgBUuVzd1wubmhbqBVNHZBFD2zwmlxJqWHExKCIHApLogiMbfSH80ES2lpadDr9WhoaPD5eUNDA7Kysvze9/HHH8evf/1rfPTRR5gzZ47fYwsKCpCWloaKioohjzGbzUhISPC5hZt8bqgbFFVNkRksTUiOhsmgg93pxom2XqWHE3ak3l3TwnhPuMEUsSIuaI552wZE+jYnEs0ESyaTCfPnz/dJzpaStUtLS4e832OPPYaHH34YGzZswFlnnTXs3zl+/DhaWlqQnZ0dkHFrFbt4B4fUtyTStg7Q6wT5TZdLcYEnJXdPi5DkbkkRO3kHTaR+sRuKZoIlAFi5ciWef/55rF+/HgcPHsTtt9+O7u5u3HLLLQCApUuXYtWqVfLxjz76KB544AGsXbsWeXl5sFgssFgs6OryvLF0dXXhpz/9Kb744gtUV1dj8+bNWLRoEaZOnYqFCxcqco1qwS7ewRGpy3AA85aC6WhDZCV3S/pnljohilzeDSS5ajfCvtgNxaD0AEbjuuuuQ1NTEx588EFYLBbMnTsXGzZskJO+a2trodP1x3/PPPMM7HY7vve97/mcZ/Xq1fj5z38OvV6PvXv3Yv369Whvb0dOTg4uu+wyPPzwwzCbw7sD7nCkmaWWbjs6eh1ydRyNnSiK8re1KRGYByBdM4OlwJNnlsJ8m5NTTcuMg07wVG41dtqQmRA1/J1oWC63iJoWT8EAl+E8NBUsAcCKFSuwYsWKQX93alJ2dXW133NFR0fjww8/DNDIwkuc2YD0eDOaOm2obu5GcW6S0kPSvKYuGzptnlLcSakxSg8n5KZ4l4iONXK2MpB67S7UtXk+2CJtZinKqEdBehwqGrtwsN7KYClATrT1wu5yw2TQIScpWunhqIKmluEotOQk7xZ+uAWCNKs0MTk6IjbQPRWX4YLjWJOnEi4l1oS0MN8TbjADl+IoMKTk7vzUWOh1kVMw4A+DJRpSvrcRWSV7LQWElAMQSc0oB8ofsLTb1m1XeDThQ97mJMKSuyX97QOY5B0oTO4+HYMlGlJ+OpO8AymSk7sBINZsQE6iZ5mkspmzS4Eib3MSYUtwElbEBV5lM7c5ORWDJRoSl+ECqzKCk7slzFsKvKPyBrqROrMkbXvSjT4Htz0JhEjcv3I4DJZoSPkDtjxhWe74ST2W8iN0GQ5g3lIwHJEaUmZE5sxSZoIZyTFGuLjtScBUyt27I/e96lQMlmhIk1JiIAhAp82J5i7mmIyH0+VGrXfvrvxInlli+4CA6rE7Udfq6Yg+PUJnlgRBkDfV/YZ5S+PWY3eivkPa7Dty36tOxWCJhhRl1CMn0VM2yqW48Tne1guHS0SUUYfsCC5v7p9Z4vMpEKSZlNRYE1IjsBJOIi3FHWJF3LhJS3DJMUYkx0bGPoMjwWCJ/JIS/Kr44TYuUsJkXmosdBFciivlLNW29sDmZH7JeB2N0GaUp2JFXOAwX2lwDJbILzlviTNL49Kf3B3ZH2oZ8WbEmQ1wuUXUejsE09hJ+UqRWgknkXstWazMrxwn5isNjsES+ZWXypmlQOC3NQ9BEJi3FED9M0uRHSxNzYiDXiegvceBBqtN6eFoGt+rBsdgifxir6XAqGSTNxnzlgJHakg5PUIbUkqijHo5COdS3PhUer/ERHKLk8EwWCK/Cgb0WnK7Ob09VnL3br4BDei1xJml8ei2OXG8zVMJF+kzS4DvUhyNjSiKA5rnRnYAfioGS+TXhKRoGHQCbE436q19Sg9Hk7ptTli8/+04s8T2AYEiVcKlxZmQwqolebsX9loau5ZuOzr7PJt9T47Azb79YbBEfhn0OkzyvmiYtzQ20qxSSqwJSTH8UBu4DMdk3LHr3xOOs0oAl3cDQUoXmJAUjShj5G327Q+DJRqWtKEuK+LGpn8DXc4qAcCk1BjodQK6bE40djIZd6yONkp7wnG5BPAkeQNAZWMXg/Ax6t9lgO9Vp2KwRMMauO0JjR6Tu32ZDXpMSvHMVjJvaez694TjzBLQH4R32pxoYhA+JmxxMjQGSzQsqSKOXbzHpkrewZtvQBLmLY3fkQZpZonBEuAbhFfweTUmlWwbMCQGSzQseRmO7QPGhH1LTsf8kvHptjlxot1bCRfhbQMG6g/C+bwaC6ltAKt2TzfmYKmiogIffvghens9L1iuEYcvaWaptrUHDpdb4dFoiyiKAzri8g1I0h8scQZgLI7KlXBm7t81gPy84vLuqPls9s0vdqcZdbDU0tKCsrIyTJ8+HVdccQXq6+sBAMuWLcPdd98d8AGS8jLjoxBt1MPlFuW+LjQyzV12dNpYinuqKRneGQB+qI2J3IySyd0+GISPnbTZt9mgkzdQp36jDpbuuusuGAwG1NbWIiam/83/uuuuw4YNGwI6OFIHnU6QP+il/BsaGWlae2JyNMwGluJKCrwN70529KHb5lR4NNpztIF7wg2GQfjYDUwXiOTNvocy6mDpo48+wqOPPoqJEyf6/HzatGmoqakJ2MBIXaQlpErmAoxKf9sAzgAMlBxrQqp3+Yi5cKN3RN4Tjs+rgaSZJQbho3eM+Up+jTpY6u7u9plRkrS2tsJsNgdkUKQ+0oa6rIgbHSZ3D41LJmNX0chKuMEkxZiQFscgfCz4XuXfqIOlCy64AC+//LL8b0EQ4Ha78dhjj+Hiiy8O6OBIPeReS3wDGpVjTO4eEpdMxqZrQCXcdHbvPk0Bg/AxkQtROAs+KMNo7/DYY4/hkksuwVdffQW73Y57770XBw4cQGtrK7Zu3RqMMZIKSB/21c09Co9EW+QeS3wDOg3bB4yNlK+UEW9GYoxR4dGoz5T0OOyoamUQPkryzBK/2A1q1DNLs2bNwpEjR3D++edj0aJF6O7uxne/+118/fXXmDJlSjDGSCogLcOdaO9Fn8Ol8Gi0wacUl29Ap+Ey3NgcZb6SX+y1NHoDN/vmtkyDG/XMEgAkJibif/7nfwI9FlKxlFgTEqIMsPY5Ud3SjcKsBKWHpHpSKW6UUYfshCilh6M6UrBU2dwNl1uEnhU4I8INdP2b4m3SWcGZpRHjZt/DG3Ww9Nlnn/n9/be+9a0xD4bUSxAE5KfHYU9dO6qbGSyNhPQGlJfKUtzBTEiOhsmgg93pxom2XkxiH6oROcLkbr+meoPwKgbhI8bk7uGNOli66KKLTvuZIPQ/GV0uLtGEq/zUGOypa5f3DyL/WIrrn14noCAtFocsnTjW1MVgaYSOsiGlXzlJ0TAbdLA53Tje1oPJqXz9Dac/uZv/rYYy6pyltrY2n1tjYyM2bNiAs88+Gx999FEwxkgqke9NUq5msDQi7LE0POYtjY61z4H6Dk9uyTTOLA1KrxNYETdKUiEKcyuHNuqZpcTExNN+dumll8JkMmHlypXYuXNnQAZG6pOXJnXxZrA0EpzaHl5/Mi4/1EZCysPJTDAjMZqVcEOZkh6Lg/VWHGvsxrcLlR6N+lXyi92wxryR7qkyMzNx+PDhQJ1uSE8//TTy8vIQFRWFkpIS7Nixw+/xb7/9NgoLCxEVFYXZs2fjn//8p8/vRVHEgw8+iOzsbERHR6OsrAxHjx4N5iVolvRCYrA0MtLUNr+tDU1Kxj3WyOfUSHCbk5HhjOXIiaKIKvaDG9aog6W9e/f63Pbs2YMNGzbghz/8IebOnRuEIfZ78803sXLlSqxevRq7du1CcXExFi5ciMbGxkGP//zzz3H99ddj2bJl+Prrr7F48WIsXrwY+/fvl4957LHH8OSTT+LZZ5/F9u3bERsbi4ULF6Kvry+o16JF0sxSc5cd1j6HwqNRN5bijgw/1EZH3uaElXB+yUE4n1fDauqycbPvERh1sDR37lzMmzcPc+fOlf//FVdcAbvdjhdeeCEYY5Q98cQTWL58OW655RbMnDkTzz77LGJiYrB27dpBj//f//1flJeX46c//SmKiorw8MMP48wzz8Qf/vAHAJ6I+ve//z1+9rOfYdGiRZgzZw5efvllnDx5Eu+++25Qr0WL4qOMSIvzbGnDvCX/WIo7MtISZUu3HW3ddoVHo35y2wAmd/slLe+yfcDwpFklbvbt36iDpaqqKlRWVqKqqgpVVVWoqalBT08PPv/8cxQWBm9x2G63Y+fOnSgrK5N/ptPpUFZWhm3btg16n23btvkcDwALFy6Uj6+qqoLFYvE5JjExESUlJUOeEwBsNhusVqvPLVIUcNuTEelP7uaskj+xZgNyEj09qCqb+cE2HKkhJSvh/JNSBtp6HGhlEO4X85VGZtTB0uTJk31uubm5iIoKfsO95uZmuFwuZGZm+vw8MzMTFotl0PtYLBa/x0v/O5pzAsCaNWuQmJgo33Jzc0d9PVrFPeJGhsndI8e8pZGx9jnkpd2pXIbzK9qkx4SkaABcihsO36tGZkTVcE8++eSIT/iTn/xkzIPRilWrVmHlypXyv61Wa8QETHkMlkaksomluCM1JT0O/zrazA+1YUizSlkJUayEG4GpGXE40d6LY41dODsvRenhqJb0XjWF71V+jShY+t3vfjeikwmCELRgKS0tDXq9Hg0NDT4/b2hoQFZW1qD3ycrK8nu89L8NDQ3Izs72OcZfsrrZbIbZbB7LZWie9O2DOUv+scfSyLF9wMgcZb7SqExJj8OnR5r4vBpGpTyzxOeVPyNahpPyk4a7VVZWBm2gJpMJ8+fPx+bNm+Wfud1ubN68GaWlpYPep7S01Od4ANi4caN8fH5+PrKysnyOsVqt2L59+5DnjHRSsFTZ3A1RFBUejTqJotjfEZff1obVXxHHANyfo42shBuNKRncUHc4TpcbtS2ezb75XuXfmDbSVcrKlStx00034ayzzsKCBQvw+9//Ht3d3bjlllsAAEuXLsWECROwZs0aAMB//dd/4cILL8Rvf/tbXHnllXjjjTfw1Vdf4bnnngPgmQm788478ctf/hLTpk1Dfn4+HnjgAeTk5GDx4sVKXaaqTU6NgSAAnX1OtHTb5eo46tfcZWcp7ihIOUu1rT2wOV2syBnCEW5zMipsSzG8urZeON2ezb6zuNm3X2MKlo4fP4733nsPtbW1sNt9Kw2eeOKJgAxsMNdddx2amprw4IMPwmKxYO7cudiwYYOcoF1bWwudrn+y7Nxzz8Vrr72Gn/3sZ/jv//5vTJs2De+++y5mzZolH3Pvvfeiu7sbt912G9rb23H++edjw4YNIUla16Ioox45idE40d6L6uZuBkuDkJbgWIo7MhnxZsSZDeiyOVHb0sNtPIYg5SxxGW5kpGCprrUHfQ4Xoox8LZ5K3uYkLY6bfQ9j1MHS5s2bcdVVV6GgoACHDh3CrFmzUF1dDVEUceaZZwZjjD5WrFiBFStWDPq7LVu2nPaza665Btdcc82Q5xMEAQ899BAeeuihQA0x7OWnxeJEey8qm7txFhMnTyMndzMHYEQEQcCU9FjsOd6BY01dDJYGwUq40UuLMyEhygBrnxPVLd0ozEpQekiqww10R27UrQNWrVqFe+65B/v27UNUVBT++te/oq6uDhdeeKHfoITCB9sH+MceS6PHvCX/WAk3eoIgsC3FMCrZNmDERh0sHTx4EEuXLgUAGAwG9Pb2Ii4uDg899BAeffTRgA+Q1IcVcf7JTd6YMDli/R9qzC8ZDCvhxoZ5S/5Js+B8rxreqIOl2NhYOU8pOzsbx44dk3/X3NwcuJGRanFmyb/+ZTi+AY0U2wf4x0q4sZnKPeL8YkPKkRt1ztI555yDf//73ygqKsIVV1yBu+++G/v27cPf/vY3nHPOOcEYI6mMPLPU0g23W2Ri4ABOlxu1rVIpLmcBRmrgMpwoihAEPqcGYiXc2HBmaWhdNicarDYA7Ac3EqMOlp544gl0dXmeeL/4xS/Q1dWFN998E9OmTQtqJRypx8TkaBh0AvocblisfcjxbitAwPG2XjhcnlLcbJbijtik1BjodQK6bE40dtqQyf92PlgJNzbyjGUjv9idSkqjSI01ITGGeXDDGfUy3COPPILW1lYAniW5Z599Fnv37sVf//pXTJ48OeADJPUx6HWYlOLpH8SlOF/Sf4+81Fi+MY+C2aCXn1PMW/LFSrixy02JgVEvoNfhQr33vyF5HGO+0qiMOlhqampCeXk5cnNz8dOf/hR79uwJxrhI5Zi3NDgmd48d85YGx0q4sTPqdZicKs0u8Xk1EPOVRmfUwdLf//531NfX44EHHsCXX36JM888E2eccQYeeeQRVFdXB2GIpEbcUHdwTO4eO7YPGFxFIyvhxoNB+OD6t2Ti82okRh0sAUBycjJuu+02bNmyBTU1Nbj55pvx5z//GVOnTg30+EilOLM0OG6gO3ZMxh3ckQZWwo0Hn1eD48zS6IwpWJI4HA589dVX2L59O6qrq+VtRyj8FbDX0qCkb2v5XIYbNXnjUy6X+DjCHkvjMpWNKU8jiqIcLE3he9WIjClY+uSTT7B8+XJkZmbi5ptvRkJCAt5//30cP3480OMjlZKW4Wpbe+B0uRUejTp025xyIi67d4+eNBt3sqMP3TanwqNRjwpv8Mi2AWPDmaXTNXXa0GVzQid4kuBpeKNuHTBhwgS0traivLwczz33HL7zne/AbOZmqpEmKyEKUUYd+hxuHG/rlYOnSFbd4vmmlhJrQlKMSeHRaE9yrAmpsSa0dNtR1dyNWRMSlR6S4qx9DtR3sBJuPKRii8ZOG6x9DiREMUleKkTJTYnhZt8jNOqZpZ///Oeor6/HO++8g+9973sMlCKUTicgL5V5SwPJS3AMHMeMswC+pEq4zAQzK+HGKD7KiMwEz+cUl3g9+F41eqMOlpYvX46kpKQgDIW0RnqhVTJYAsANdAOBeUu+pEq46ZmcVRoPVlr6qmr29lhiIcqIjSvBmyIbN9T1JVeXMGFyzPih5ouVcIHBGUtfLEQZPQZLNGbsteRL3sGbM0tjxg81X6yEC4z+bU/4vAL637On8L1qxBgs0ZgVMFiSiaI4oHs3P9jGSgqWKpu74XKLCo9GeayEC4wpGQzCJY4Bm31zZmnkGCzRmEnLcCc7etHncCk8GmU1d9nR2eeEIEDe44xGb0JyNMwGHezO/jf0SMVKuMCRei3VtPTAEeGtTupae+B0i4g26pEZzw2rR4rBEo1ZSqwJ8VEGiKLnTSiSSbNrE5OjEWVkKe5Y6XUCZmR5AoOD9VaFR6MsVsIFTlZCFGJMejjdYsQH4QMr4bjZ98gxWKIxEwSBS3FeUnVJPqtLxq0oKwEAgyVWwgWOIAjyEm9FhOctsRBlbBgs0bgwydtD3pSSCZPjVpTNmSWAlXCBxg11PSq9X+yY3D06DJZoXPo31I30NyApuZtvQONVlC3NLHUqPBJlsRIusORKywjfI45tA8aGwRKNS3+vpUjPA5CW4fgGNF6F3mDpRHsvOnocCo9GOayECyxWxHn0N8/l82o0GCzRuLCLN+AcUIrLtgHjlxhtxISkaADAQUtkLsWxEi7wBvbwEsXIbEvR2edAY6cNAGeWRovBEo2LlLPU3GVDZ19kzgKcaO+FwyXCbNAhO4GluIHQvxQXmcESK+ECLy8tBjoB6OxzoqnLpvRwFCGtAKTFmbmh8CgxWKJxSYgyIi3Os0llpC7FsRQ38GZGeJI3K+ECz2zQyz3QIrUirrKZuwyMFYMlGrf8NM8bUGWEJnkzuTvwIj3Jm5VwwRHpew/KVbt8rxo1Bks0bpGe5N3fY4lvQIEiBUuHGzrhjMCOy6yECw45yTtiZ5b6Z8FpdBgs0bjlRXj7gP4eS/xgC5RJKTGINelhd7ojsocXK+GCI9J7LUnv0SxEGT0GSzRukd7Fmx1xA083YNuTbyIsb4mVcMEjb9QcgctwoiiiqokzS2PFYInGTdrio6q5O+JKcnvsTvmDjUmTgRWpeUushAseKVg60d6LHrtT4dGEVmOnDd12F/Q6gZt9j4FmgqXW1lbccMMNSEhIQFJSEpYtW4aurqGnUltbW/HjH/8YM2bMQHR0NCZNmoSf/OQn6Ojo8DlOEITTbm+88UawLyesTE71vPCsfU60dtsVHk1oSbNKKbEmJMWYFB5NeInU9gGshAue5FgTUmI9r9NIm12Slh5zk6NhMmjmo181NPNf7IYbbsCBAwewceNGvP/++/jss89w2223DXn8yZMncfLkSTz++OPYv38/1q1bhw0bNmDZsmWnHfvSSy+hvr5evi1evDiIVxJ+oox6uYlgpC3FVTFhMmgiNVhiJVxwTU2PzE7efK8aH4PSAxiJgwcPYsOGDfjyyy9x1llnAQCeeuopXHHFFXj88ceRk5Nz2n1mzZqFv/71r/K/p0yZgl/96le48cYb4XQ6YTD0X3pSUhKysrKCfyFhLD8tFifae1HV3I2z8lKUHk7IVDIHIGgKs+IhCJ7lg5YuG1K9/bzCHSvhgmtKRix2VLdGXEVcf9sAPq/GQhMzS9u2bUNSUpIcKAFAWVkZdDodtm/fPuLzdHR0ICEhwSdQAoA77rgDaWlpWLBgAdauXTts3o3NZoPVavW5Rbo8b6+lSJ1ZYt+SwIs1GzDZm1sRSXlLrIQLrkjttcSZpfHRRLBksViQkZHh8zODwYCUlBRYLJYRnaO5uRkPP/zwaUt3Dz30EN566y1s3LgRV199NX70ox/hqaee8nuuNWvWIDExUb7l5uaO7oLCkJTkXd0SWW9A0ga6TO4OjkhbimMlXPBNifBlOH6xGxtFg6X7779/0ATrgbdDhw6N++9YrVZceeWVmDlzJn7+85/7/O6BBx7Aeeedh3nz5uG+++7Dvffei9/85jd+z7dq1Sp0dHTIt7q6unGPUevkLt4R9G1NFMUB3bs5CxAMkRYsSbNKrIQLHrl9QHM3XO7IqN61Owds9s1+cGOiaM7S3XffjZtvvtnvMQUFBcjKykJjY6PPz51OJ1pbW4fNNers7ER5eTni4+PxzjvvwGj0/wZUUlKChx9+GDabDWbz4DkSZrN5yN9FqoEzS263GBF7pLV029HZ54QggKW4QSIFS5HSa+loAyvhgm2CtxrM7nTjRFsvJqWG/2u3rq0HLreIGJMemQn87BoLRYOl9PR0pKenD3tcaWkp2tvbsXPnTsyfPx8A8PHHH8PtdqOkpGTI+1mtVixcuBBmsxnvvfceoqKG3xF+9+7dSE5OZjA0ShOTo2HQCehzuNHQ2YfsxGilhxR00izahKRoRBn1Co8mPBV5N9Q91tQFu9Md9iXPrIQLPr1OQEFaLA5ZOnGsqSsigqWBhSiCEP5fZINBE+88RUVFKC8vx/Lly7Fjxw5s3boVK1aswJIlS+RKuBMnTqCwsBA7duwA4AmULrvsMnR3d+PFF1+E1WqFxWKBxWKBy+UCAPzjH//ACy+8gP3796OiogLPPPMMHnnkEfz4xz9W7Fq1yqjXIdc7u1IVIUtx3Dog+CYkRSMhygCHS4yIneKPeq+RlXDBJe0RFwnPKQA4bPHMzE7N4PNqrDTROgAAXn31VaxYsQKXXHIJdDodrr76ajz55JPy7x0OBw4fPoyeHs+67K5du+RKualTp/qcq6qqCnl5eTAajXj66adx1113QRRFTJ06FU888QSWL18eugsLI/lpsahq7kZVSzfOnZqm9HCCTs5XYnJ30AiCgMLsBOyoasXBeitm5iQoPaSg6l+G44daMEVakvee455mzLMnJCo8Eu3STLCUkpKC1157bcjf5+Xl+ZT8X3TRRcO2ACgvL0d5eXnAxhjp8lK9e8RFyMxSf98SBkvBNHNAsBTOWAkXOpG2oe4+b7A0Z2KSsgPRME0sw5E2SBvJRkqvJfYtCQ0pb+mgJbyDJVbChU4k9VpqtPbBYu2DTgBmTQjvmdlgYrBEASMtR1VFQK8lp8uNmhYGS6EwcEPdcN6omZVwoSPNBrd228N+P0tpCW5aRjxiTJpZTFIdBksUMHneoKG2pQdOl1vh0QTXifZeOFwizAYdciKg8k9J0zPjoRM8H2yNnTalhxM0UiUck3CDL8ZkkPezrAzzpbi9x9sBALMnMl9pPBgsUcBkJ0TBbNDB6RZxvK1X6eEEVeWAJbhI6CmlpCijXq44DOd+S0flbU44sxQKBRGSt7TXO7NUzGBpXBgsUcDodIK8JBXuS3HcQDe0IqGTNyvhQkvKWwrn9gGiKMozS0zuHh8GSxRQkVIR199jicFSKMhJ3mG6oS4r4UJPWu4M5yTv4229aOtxwKgXUJjN59V4MFiigJIq4sJ9Q93+mSXOAoRCuM8ssRIu9CKh15K0BFeYlQCzgbsMjAeDJQqo/NTIaB/AHbxDa6Y3WKps6kKfw6XwaAKPlXChNyXD89qta+0Jy+cUgAFLcMxXGi8GSxRQ0sxSZRhPbffYnfKSCbt3h0ZGvBkpsSa4ReBIQ/gtxbESLvTS48yIjzLALQI1LT1KDyco9niDpWLmK40bgyUKKCnh+WRHb9h+W5NmlZJjjEiKMSk8msggCMKAvKXwW4pjJVzoCYIQ1ktxbreI/Sc8r5U5uZxZGi8GSxRQqbEmxJsNEEWgtjU8v631L8FxFiCUirL6m1OGG1bCKUMOlsKwIq6yuRtdNieijDpM5XvVuDFYooASBCHsl+Kq2DZAEVKSd7j1WmIlnHKkvKWKMJxZkvKVZuUkwqDnR/148b8gBZwURIRrRVwlk7sVMbAiLpy2PWElnHKmhvEy3F5unhtQDJYo4MK915IcLHFmKaSmZsTBqBfQ2efEifbw6RDPSjjlTJF6LTV2w+0OnwAcYCVcoDFYooCTZlzCsYu3KIryXlLssRRaJoNOzjEJp7wlVsIpZ1JKDAw6Ab0OFyzWPqWHEzAOlxsHTnqTuxksBQSDJQq4vDDutdTSbUdnnxOCAExOjVF6OBFnZhg2p2QlnHKMep38Og6npbgjDZ2wOd2IjzLI78c0PgyWKODyvMtTTZ02dPY5FB5NYEkB4ISkaEQZ2RE31MKxkzcr4ZQVjhVx/flKidzoO0AYLFHAJUYbkRbn6T8Ubs3epCU4tg1QRrgFS6yEU96UMNwjTgqWZk9IUnYgYYTBEgWFNPVbGWZLcUzuVpbUmLKmtQfdNqfCoxk/VsIpT5pZqgirmaV2AEAx85UChsESBYXUPiDcKuIq2WNJUalxZqTHmyGKwCGL9pO8WQmnvCnegpRwyVnqc7hw2PvamJObpOxgwgiDJQoKqTFlVXN4vAFJuIGu8sJpKe4oK+EUJy3DNXbaYA2DHMuD9VY43SLS4kzISYxSejhhg8ESBUVhlueb8h7v2nk4cLlF1LRwZklp4bRH3BFWwikuIcqIjHgzgPDYdaA/XykRgsDk7kBhsERBMX9yCgTBMxPTGCb9S4639cDhEmE26JCTGK30cCJWOLUPYCWcOoRTRdweuRllkqLjCDcMligoEqON8ofa9qpWhUcTGFJyd35aLMtxFSQtwx2ydGq663InK+FUQ9ojLhzylqSZpeJcJncHEoMlCpoF+SkAgO1VLQqPJDC4ga46FKTFwmTQocfuQm2rdltTHGUlnGpMCZM94rpsTvka2DYgsBgsUdCU5KcCALZXhsvMktRjicGSkgx6nbxspeWlOFbCqUe4tA/Yf6IDogjkJEYh3ZuHRYHBYImCRppZOtrYhZYum8KjGb8qeRmO+SVKK8rSft4SK+HUQ6qIq2npgcPlVng0Y7eX+UpBw2CJgiYl1iTPAHxZrf3ZJfZYUg8pb+kbDW+oy0o49chOiEKMSQ+nW9T00q5UfTyH+UoBx2CJgkpaivtC40txPXannIw7hctwiguHXkushFMPnU6Ql9e1XBG3TwqWmK8UcAyWKKhKCjxLcTs0XhFX3ez5tpkcY0RSjEnh0ZBUaXmivRcdvdprJMhKOPXpT/LWZq+ltm67PCs2m9ucBByDJQoqKW/poMWKjh7tfahJ+pO7OQugBokxRrk78SENzi6xEk59tF4Rt/eEZ1YpPy2Wz6kgYLBEQZURH4WCtFiIorbzltg2QH20vBQnLcFN46ySamg9WNrnTe6ePYGzSsGgmWCptbUVN9xwAxISEpCUlIRly5ahq8v/k/qiiy6CIAg+tx/+8Ic+x9TW1uLKK69ETEwMMjIy8NOf/hROp/Z3M1cTeSlOw8HSwIaUpA79wZL2krylSrhpzFdSDakxZUVjF0RRe81O5eRuLsEFhUHpAYzUDTfcgPr6emzcuBEOhwO33HILbrvtNrz22mt+77d8+XI89NBD8r9jYmLk/+9yuXDllVciKysLn3/+Oerr67F06VIYjUY88sgjQbuWSLMgPwWv76jD9krtNqeUgiUmd6uHHCxZtDezxEo49clLjYUgAJ19TjR12ZARr61NaKW2AcW5SYqOI1xpYmbp4MGD2LBhA1544QWUlJTg/PPPx1NPPYU33ngDJ0+e9HvfmJgYZGVlybeEhAT5dx999BG++eYbvPLKK5g7dy4uv/xyPPzww3j66adht9uHPKfNZoPVavW50dCkirj9J63osmlv1k4URVR5p+bZY0k9pA11D1s64dRYb5z+ZTg+n9QiyqhHbrLny/SxRm0leTdY+9BgtUEnAGfkJAx/Bxo1TQRL27ZtQ1JSEs466yz5Z2VlZdDpdNi+fbvf+7766qtIS0vDrFmzsGrVKvT09PfQ2LZtG2bPno3MzEz5ZwsXLoTVasWBAweGPOeaNWuQmJgo33Jzc8dxdeEvJykauSnRcLlF7KxpU3o4o9bSbYe1zwlBACanxgx/BwqJyamxiDbqYXO6Ud2inQ+3gZVw0zizpCpSg1Ct5S1J+8FNy4hHjEkzC0aaoolgyWKxICMjw+dnBoMBKSkpsFgsQ97v+9//Pl555RV88sknWLVqFf785z/jxhtv9DnvwEAJgPxvf+ddtWoVOjo65FtdXd1YLiui9G99or2lOKlz94SkaEQZ9QqPhiR6nYAZWZ5gQ0vNKVkJp17SMrv2gqV2AMxXCiZFQ9D7778fjz76qN9jDh48OObz33bbbfL/nz17NrKzs3HJJZfg2LFjmDJlypjPazabYTZz353RWJCfgr/sPI7tGuy3xEo49SrKTsDuunYcrLfiquIcpYczIqyEUy+t9lrq79ydpOxAwpiiwdLdd9+Nm2++2e8xBQUFyMrKQmNjo8/PnU4nWltbkZWVNeK/V1JSAgCoqKjAlClTkJWVhR07dvgc09DQAACjOi8N7xzvzNLe4+3otbsQbdLODM0xb4+lKeyxpDozvXlLWmofwEo49ZL2iNNSF29RFOW2AcWcWQoaRYOl9PR0pKenD3tcaWkp2tvbsXPnTsyfPx8A8PHHH8PtdssB0Ejs3r0bAJCdnS2f91e/+hUaGxvlZb6NGzciISEBM2fOHOXVkD+5KdHIToxCfUcfvq5tw7lT05Qe0ohxZkm9tNhriZVw6iV9ITrR3oseu1MT+T/H23rR1uOAUd+/LE2Bp4mcpaKiIpSXl2P58uXYsWMHtm7dihUrVmDJkiXIyfFMvZ84cQKFhYXyTNGxY8fw8MMPY+fOnaiursZ7772HpUuX4lvf+hbmzJkDALjsssswc+ZM/OAHP8CePXvw4Ycf4mc/+xnuuOMOLrMFmCAIcjfvLzS2FMceS+pV6A2WGqw2tHYPXcGqJqyEU6+UWBOSYzx5ZJUaWYrb451VKspOgNmgnRl7rdFEsAR4qtoKCwtxySWX4IorrsD555+P5557Tv69w+HA4cOH5Wo3k8mETZs24bLLLkNhYSHuvvtuXH311fjHP/4h30ev1+P999+HXq9HaWkpbrzxRixdutSnLxMFjhaTvF1uETXeSqsC9lhSnTizAZNSPBWKWphdYiWc+mmtk/deNqMMCfXPMXqlpKT4bUCZl5fn03U1NzcXn3766bDnnTx5Mv75z38GZIzkn9TJ++u6dticLk18CzrR1guHS4TZoENOYrTSw6FBFGXHo7a1BwfrrThP5cu7rIRTv6kZcfiqpk0zSd5yJdyEJEXHEe40M7NE2leQFou0ODPsTjf21HUoPZwRkZK789NiodMJCo+GBiPlLX2jgZklVsKpn5ZmltxuEftPeJ73c3I5sxRMDJYoZARBQIk3b0krS3FM7lY/Le0Rx0o49ZP2iNNCRVxlcxe6bE5EG/WYymrdoGKwRCGltU11KwfMLJE6zfQGSxWNnbA71b3tCSvh1E+aWapq7obLre4NdaV8pVkTEmDQ8+M8mPhfl0JKSvLeWdMGhwb285K6dxfwW5tqTUyORrzZAIdLVP3SCSvh1G9icgxMeh1sTjdOtPUqPRy/pGBpNvOVgo7BEoXUtIw4JMUY0WN3Yd8J9ectcRlO/QRBQKEGmlOyEk4b9DpBfr2rPfiW2gYUM18p6BgsUUjpdAIW5El5S+peiuuxO3HS++E2hW0DVE0LzSlZCacdct6SioMlh8uNb056k7snJik7mAjAYIlCrqTAsxS3o0rdSd7VzZ6eXckxRiTFmBQeDfmjhSTvCim5m5VwqqeFirgjDZ2wOd2IjzJgsrfXGAUPgyUKOaki7qvqNlUnUFaxc7dmDJxZGthvTU2OSPlKrIRTvanyHnHq7bU0sBkl25oEH4MlCrmi7ATERxnQaXPK08hqVOn9VsnkbvWbkRkPnQC0dNvR1GlTejiDYiWcdmhhZkluRskluJBgsEQhp9cJOFvKW1LxUhxnlrQj2qRHnvdxUmtzygpWwmmG9Jpv6bajTaV7DkozS8Xc5iQkGCyRIqRNdbereFPdY1LbAAZLmqDmvKXOPodcLMBKOPWLNRuQkxgFQJ2zS30OFw5bPM/z2ZxZCgkGS6QIKW/py+pWuFWYtySKIqq4DKcpM1VcEcdKOO2ZkqHepbhv6q1wukWkxZnkoI6Ci8ESKWLWhETEmPRo73HgSKP6ZgJau+2w9jkhCMDkVFaaaEGRinstsRJOe/rzltSX5L23rh2AJ19JEJjcHQoMlkgRRr0O8ycnA1Bnv6VK7xLchKRoRBn1Co+GRkJahqts7kafw6XwaHyxEk57pN5qatwjbu+J/ko4Cg0GS6QYeVNdFSZ5s3O39mQlRCEpxgiXW5Q3rFULVsJpj5qX4Qa2DaDQYLBEiulvTtmqut44x7wb6DK5WzsEQUBRljrzllgJpz1Tvctwta09sDnVM1PZZXPKARzbBoQOgyVSzJyJiTAbdGjusqsuL0CaWWJyt7ZIS3Fqah/ASjhtSo83I95sgFsEalp6lB6ObN/xDoiiJ0UgLc6s9HAiBoMlUozZoMe8SUkA1LcUV8keS5qkxiRvVsJpkyAIKPDOBFaoKG9p34l2AMDsCVyCCyUGS6SoknzPUpyakryPNnSiorELOqF/poK0QY3bnrASTrvUmOS9R8pXymWwFEoMlkhRJQWeJG815S39+YsaAMClMzORHs9pbi2ZlhkHg06Atc8pL30pjZVw2qXGbU+kbU6Kma8UUgyWSFHzcpNh1AuwWPtQ26p8XkCXzYm/7ToBAFhamqfsYGjUzAa9/AF3UCX7DkqVcJxZ0h619Vpq67ajrrUXgKdXHYUOgyVSVLRJL39DUsNS3Du7jqPL5sSU9FicOyVV6eHQGKgtb0mqhJvOmSXNmZrhXYZr6lLFzLfUXyk/LZb5byHGYIkUJy3FKb1PnCiKeHmbZwnuB+dMZmdcjZLzlizKB0s+lXCcWdKcyamxMOgE9NhdsFiVX9bt79zNWaVQY7BEilsgJXkrXBH3RWUrjjZ2Icakx3fnT1R0LDR2atpQV6qEy4g3IzGGMwFaY9TrMMm73ZEaKuLk5G7mK4UcgyVS3PzJydDrBBxv68WJ9l7FxvHnL6oBAIvnTUBCFD/YtEoKlqpbutFjdyo6FqkSjp27tUvOW1JBsCS1DSjmzFLIMVgixcWZDXKy4g6FZpcsHX348EADAGBp6WRFxkCBkR5vRlqcGaIIHLIoO7vESjjtU0uSd4O1Dw1WG3QCMDOHLU1CjcESqcI50j5xCiV5v7ajFi63iAV5KSjM4huR1qklyZuVcNon91pSuH3AHm++0vTMeMSYDIqOJRIxWCJVWJCvXJK33enG6ztqAQA/4KxSWJiZrY494lgJp31q2VB33wlunqskBkukCmflpUAQgKrmbjSGuOrkwwMWNHXakB5vxsIzskL6tyk41JDkzUq48CAtwzVYbejscyg2Dim5ezaTuxXBYIlUITHaKM8GhHp26c/edgHXL5gEk4EviXAgBUuH6q1wu5Xpj8NKuPCQGG2UO/lXKpS3JIrigM7dnFlSAj8ZSDX6l+JCl+R9yGLFjupW6HUCvr9gUsj+LgVXQXosTHoduu0u1LUp0xmelXDhQ8pbUqp9QF1rL9p7HDDpdcypVIhmgqXW1lbccMMNSEhIQFJSEpYtW4aurqGfuNXV1RAEYdDb22+/LR832O/feOONUFwSnUKJTXWlJpQLz8hEVmJUyP4uBZdRr5Mr0JTKW2IlXPhQeo+4vd6WAUXZ8Zz9Vohm/qvfcMMNOHDgADZu3Ij3338fn332GW677bYhj8/NzUV9fb3P7Re/+AXi4uJw+eWX+xz70ksv+Ry3ePHiIF8NDUaaWTra2IWWLlvQ/561z4F3v/bsA/eDc/KC/vcotKSluG8UyltiJVz4UDxYkvOVuASnFE3UHx48eBAbNmzAl19+ibPOOgsA8NRTT+GKK67A448/jpycnNPuo9frkZXlm6z7zjvv4Nprr0VcnO83vaSkpNOO9cdms8Fm6/8wt1qV31YhHKTEmjA9Mw5HGrrwZXUrymdlB/Xv/XXncfTYXZieGYdzvFuuUPgoUrgijpVw4aO/Ik6ZnKU98jYnSYr8fdLIzNK2bduQlJQkB0oAUFZWBp1Oh+3bt4/oHDt37sTu3buxbNmy0353xx13IC0tDQsWLMDatWuH3TBxzZo1SExMlG+5ubmjuyAakrQU90WQl+JEUcSfv+A+cOFMyV5LrIQLL1LOUk1LNxwud0j/ttstYr+3bUAxgyXFaCJYslgsyMjI8PmZwWBASkoKLBbLiM7x4osvoqioCOeee67Pzx966CG89dZb2LhxI66++mr86Ec/wlNPPeX3XKtWrUJHR4d8q6urG90F0ZCkTXV3BLkibmtFCyqbuhFnNuA/z+Q+cOFIqq483tYLa4hLvitYCRdWchKjEW3Uw+ES5Vy0UKls7kK33YVoo14O2ij0FA2W7r///iGTsKXboUOHxv13ent78dprrw06q/TAAw/gvPPOw7x583Dffffh3nvvxW9+8xu/5zObzUhISPC5UWBIeUsHLVZ09ATvA+7lbdUAgO+eOQFxZk2sRtMoJcWYkO1N2j8U4rylo6yECys6nSAv1T/w7n44Qzi7tKfOM6s0a0ICDHpNzG+EJUX/y9999904ePCg31tBQQGysrLQ2Njoc1+n04nW1tYR5Rr95S9/QU9PD5YuXTrssSUlJTh+/LhPThKFTkZ8FArSYiGKwJfVwZldOtHei00HPfvA/eAcduwOZ0rlLbESLvw8tGgW4s0G7Kptxx8+qQjZ35X6KzFfSVmKfqVOT09Henr6sMeVlpaivb0dO3fuxPz58wEAH3/8MdxuN0pKSoa9/4svvoirrrpqRH9r9+7dSE5OhtlsHv4CKChKClJQ2dyN7VUtKJuZGfDzv7a9Bm4RKC1IxTR+8w9rRdnx+PhQY8iDpaOshAs7uSkxeHjxLNz55m48ufkoLpiWjvmTk4P+d/dymxNV0MScXlFREcrLy7F8+XLs2LEDW7duxYoVK7BkyRK5Eu7EiRMoLCzEjh07fO5bUVGBzz77DLfeeutp5/3HP/6BF154Afv370dFRQWeeeYZPPLII/jxj38ckuuiwUlJ3sHIW7I5XXhjhyfHbCn3gQt7Ss0sHWUlXFhaPG8CFs3NgVsE7nzz66Bvf+JwufHNSc9zlzNLytJEsAQAr776KgoLC3HJJZfgiiuuwPnnn4/nnntO/r3D4cDhw4fR0+PbrXft2rWYOHEiLrvsstPOaTQa8fTTT6O0tBRz587Fn/70JzzxxBNYvXp10K+HhiblLe0/aUWXzRnQc//fPgtauu3ISojCpUGYtSJ1kYKlww2dcIVo2xNWwoW3hxbNwoSkaNS19uLn730T1L912NIJm9ONhCgD8lJjgvq3yD/NZLampKTgtddeG/L3eXl5g5b8P/LII3jkkUcGvU95eTnKy8sDNkYKjJykaOSmeN6MvqpuxUUzMoa/0whJid3fL5nEZMkIkJcaiyijDn0ON6qauzE1I/gzPayEC2+J0Ub87rq5WPLcNvx113FcNCMd3yk+vddfIOyTl+CS2N5EYfy0IFUKxlLc/hMd2FXbDqNewJIF7I0VCfQ6ATOyQrsUx0q48LcgPwU/umgqAOB/3tmHk+29Qfk7/cndzFdSGoMlUqX+TXUDFyy94m1CWT4rGxnx3AcuUswMcXNKVsJFhv8qm4biiYmw9jlx15u7g7LMK7UNYLCkPAZLpErneGeW9h5vR6/dNe7zdfQ48O5uzz5wTOyOLKFO8mYlXGQw6nX4/ZJ5iDHpsb2qFc99VhnQ8/c5XDjsDbyZ3K08BkukSrkp0chOjILDJeLr2rZxn+/tnXXoc7hRmBWPs0JQ7kvq0R8shaYxJSvhIkd+Wix+/p0zAAC//egw9nk3vA2Eb+qtcLlFpMWZ5eaqpBwGS6RKgiCgxLsU98U4l+LcblFegltamsdEyQhTmOWZ4bFY+9DWbQ/q32IlXOS55qyJuHxWFpxuEf/1xtfosQemgnevvHluIt+zVIDBEqnWAu9S3PbKlnGd518Vzahu6UF8lAGL5wWnaoXUKz7KiNyUaADBX4pjJVzkEQQBj/znbGQmmFHZ3I2H3z8YkPPuPc58JTVhsESqJW2q+3VdO2zOsect/dnbLuB78ycixqSZbhkUQEXeirhvghws7aptB8BKuEiTHGvCE9fOBQC8vqMWHx0Y2Qbv/uzxVsIVM19JFRgskWoVpMUiLc4Mu9MtV4WMVl1rDzYf8uwryH3gIlew85b2n+jAsnVf4uH3PU0KORsQec6bmobbvlUAALjvr3vRaO0b87k6+xyobO4GAMzmc0kVGCyRag3MWxrrUtyr22shisAF09JQkM6E20gVrIq4Iw2duP2VnfiPp/6NzYcaoRM8M5h3XDw1oH+HtOHuy6ZjZnYC2nocuPvtPXCPsZ3A/hNWiCIwISkaaXHcp1QNGCyRqklLcWPpt9TncOHNL2sBcFYp0s30BksVjV1wuNzjPl9lUxd+8vrXWPj7z/B/+y0QBGDR3BxsWnkhHr+mGLFmLvdGIrNBjyevnwuzQYd/HW3GS59Xj+k8bEapPnxFk6pJnbx31rTB4XLDOIotSj7YW4+2HgcmJEXjkiLuAxfJJiZHI85sQJfNiWNNXSj05jCNVl1rD/5381H8bddxSJMGV8zOwp1l05mnRACAqRnx+NmVRXjg7wfw6P8dwrlTUuWZzZHaO2CbE1IHziyRqk3LiENSjBG9Dpe8T9JIvextF/D9kknQ61h6G8l0OkFuITCWpbiT7b1Y9bd9uPjxLfjLTk+gVFaUgQ9+cj7+eMN8Bkrk48ZzJuPbhRmwu9y4843d6HOMrkBlr5zczZkltWCwRKqm0wlYkCflLY18KW7v8XbsqWuHSa/DdWdzHzgaW5J3o7UPq/++Hxf9Zgte31ELp1vEBdPS8O4d5+GFm87GGTn8MKPTCYKAx743B2lxJhxu6MSv/+/QiO/b2m1HXatnr7kzJvD5pRYMlkj1SgqkTXVHnuT98jbPrNIVs7OYIEkARpfk3dJlw68++AYXPPYJ1m+rgd3lxjkFKXj7h6X487ISzM1NCvJoSevS4sz4zTXFAIB1n1djy+HGEd1PmlUqSItFYjR7dakFc5ZI9aSKuK+q2+Byi8MuqbV12/GPPScBAD8ozQv28EgjikawoW57jx3PfVaJdZ9Xo8e7J+H8ycm4+9LpOHdqWkjGSeHj4hkZuKl0MtZvq8E9b+/Fh3degNRhvrztYzNKVWKwRKpXlJ2A+CgDOvuc+Oakddi+I299VQeb040zchJw5qSk0AySVG9GVjwEAWjusqOxsw8Z8f37bVn7HFj77yq8+K8qdNo821XMnpCIlZdNx0XT07ndBI3ZqiuK8PmxFhxt7MJ9f92L55ee5ff5tMcbLM1mcreqcBmOVE+vE3C2lLc0zFKcyy3ile3SPnCT+SFHshiTAfmpsQD685a6bU48/UkFLnj0E/x+01F02pwozIrHcz+Yj/dWnIeLZ2TwOUTjEmXU43+XzINJr8Omg414dXut3+OZ3K1ODJZIE+TmlMP0W/r0SCPqWnuRGG3EVcUTQjE00hApb+nr2jY8/1klvvXYJ/jNh4fR0evAlPRY/OH78/DPn1yAy87IYpBEATMzJwH3ls8AAPzyg2/kPQRP1WDtQ2OnDXqdwOIBleEyHGnCAm+w9GV1K9xuEboh8pakxO5r5k9EtEkfsvGRNhRlx+ODffX4/aaj8s8mp8bgzrJpuKp4AltMUND8v/PyseVwE/5d0Yz/euNrvPOj82Ay+M5X7KlrB+BpmcL3L3XhzBJpwqwJiYgx6dHe48DhhsFLv2tauvHpkSYAnj4nRKeaNaAUe0JSNB69ejY2rbwQ/zlvIgMlCiqdTsBvry1GUowRB05a8duNh087Zi+Tu1WLwRJpglGvw/zJyQCAHUMsxb3yRQ1EEbhwejry0mJDOTzSiG9NS8e95TPwyH/Oxsf3XIjrzp40qq7wROORmRCFX393DgDguc8q8XlFs8/v98jbnCSFeGQ0HL5LkGb05y2dnuTda3fhra+OA/AkdhMNRqcT8KOLpuL7JZNgNnCZg0KvfFYWrl+QC1EEVr61B+09dgCAKIryLgXFDJZUh8ESaUZ/c8pWiKLvbt7/2HMSHb0OTEyOxkUzMpQYHhHRiDzwHzNRkBYLi7UP//3OPoiiiLrWXrT3OGDS6zAji9vnqA2DJdKMORMTYTbo0Nxlx7Gmbvnnoiji5S+qAXhylZh7QkRqFmMy4PdL5sKgE/DPfRb8ZedxeQmuKDv+tMRvUh4fEdIMs0GPed4mkwOX4r6ua8f+E1aYDDpcexb3gSMi9ZszMQl3XTodAPDz9w7g/b0n5Z+T+jBYIk0pyfcsxQ3cVPfP3nYB35mTg5RYkyLjIiIarR9eOAUL8lPQbXfhwwMNAFgJp1YMlkhTSgo8Sd5S3lJzlw0f7K0HwMRuItIWvU7A766bi/io/paHnFlSJwZLpClnTkqGUS/AYu1DbWsP3vyyDnaXG8UTE1HMneCJSGMmJEXjV/85GwCQGG3E1Iw4hUdEg2EHb9KUKKMexROT8FVNGz4/1oLXvPss/aA0T9mBERGN0VXFOTAbdEiLM7FARaUYLJHmlBSk4KuaNjy1+ShOdvQhOcaI/5iTrfSwiIjGbOEZWUoPgfzgMhxpjpTkfbKjDwBw7dm5iDKywSAREQWHZoKlX/3qVzj33HMRExODpKSkEd1HFEU8+OCDyM7ORnR0NMrKynD06FGfY1pbW3HDDTcgISEBSUlJWLZsGbq6Bt8RmtThzMnJ8lS1IAA3ljCxm4iIgkczwZLdbsc111yD22+/fcT3eeyxx/Dkk0/i2Wefxfbt2xEbG4uFCxeir69PPuaGG27AgQMHsHHjRrz//vv47LPPcNtttwXjEihA4swGeUPUb8/IQG5KjMIjIiKicCaIp+4boXLr1q3DnXfeifb2dr/HiaKInJwc3H333bjnnnsAAB0dHcjMzMS6deuwZMkSHDx4EDNnzsSXX36Js846CwCwYcMGXHHFFTh+/DhycnJGNCar1YrExER0dHQgISFhXNdHI/P33Sfwu41H8NT1Z2I2+5IQEdEYjPTzWzMzS6NVVVUFi8WCsrIy+WeJiYkoKSnBtm3bAADbtm1DUlKSHCgBQFlZGXQ6HbZv3z7kuW02G6xWq8+NQmvR3AnY8tOLGSgREVHQhW2wZLFYAACZmZk+P8/MzJR/Z7FYkJHhu+mqwWBASkqKfMxg1qxZg8TERPmWm8stNoiIiMKVosHS/fffD0EQ/N4OHTqk5BAHtWrVKnR0dMi3uro6pYdEREREQaJon6W7774bN998s99jCgoKxnTurCxPz4qGhgZkZ/f34GloaMDcuXPlYxobG33u53Q60draKt9/MGazGWazeUzjIiIiIm1RNFhKT09Henp6UM6dn5+PrKwsbN68WQ6OrFYrtm/fLlfUlZaWor29HTt37sT8+fMBAB9//DHcbjdKSkqCMi4iIiLSFs3kLNXW1mL37t2ora2Fy+XC7t27sXv3bp+eSIWFhXjnnXcAAIIg4M4778Qvf/lLvPfee9i3bx+WLl2KnJwcLF68GABQVFSE8vJyLF++HDt27MDWrVuxYsUKLFmyZMSVcERERBTeNLPdyYMPPoj169fL/543bx4A4JNPPsFFF10EADh8+DA6OjrkY+699150d3fjtttuQ3t7O84//3xs2LABUVFR8jGvvvoqVqxYgUsuuQQ6nQ5XX301nnzyydBcFBEREame5vosqRH7LBEREWlPxPdZIiIiIgoEBktEREREfjBYIiIiIvKDwRIRERGRHwyWiIiIiPxgsERERETkB4MlIiIiIj8005RSzaRWVVarVeGREBER0UhJn9vDtZxksBQAnZ2dAIDc3FyFR0JERESj1dnZicTExCF/zw7eAeB2u3Hy5EnEx8dDEISAnddqtSI3Nxd1dXUR0Rk8kq6X1xq+Iul6ea3hK1KuVxRFdHZ2IicnBzrd0JlJnFkKAJ1Oh4kTJwbt/AkJCWH9ZD1VJF0vrzV8RdL18lrDVyRcr78ZJQkTvImIiIj8YLBERERE5AeDJRUzm81YvXo1zGaz0kMJiUi6Xl5r+Iqk6+W1hq9Iu97hMMGbiIiIyA/OLBERERH5wWCJiIiIyA8GS0RERER+MFgiIiIi8oPBksKefvpp5OXlISoqCiUlJdixY4ff499++20UFhYiKioKs2fPxj//+c8QjXR81qxZg7PPPhvx8fHIyMjA4sWLcfjwYb/3WbduHQRB8LlFRUWFaMRj9/Of//y0cRcWFvq9j1Yf17y8vNOuVRAE3HHHHYMer7XH9LPPPsN3vvMd5OTkQBAEvPvuuz6/F0URDz74ILKzsxEdHY2ysjIcPXp02POO9nUfCv6u1eFw4L777sPs2bMRGxuLnJwcLF26FCdPnvR7zrG8FkJhuMf15ptvPm3c5eXlw55XjY8rMPz1DvYaFgQBv/nNb4Y8p1of22BhsKSgN998EytXrsTq1auxa9cuFBcXY+HChWhsbBz0+M8//xzXX389li1bhq+//hqLFy/G4sWLsX///hCPfPQ+/fRT3HHHHfjiiy+wceNGOBwOXHbZZeju7vZ7v4SEBNTX18u3mpqaEI14fM444wyfcf/73/8e8lgtP65ffvmlz3Vu3LgRAHDNNdcMeR8tPabd3d0oLi7G008/PejvH3vsMTz55JN49tlnsX37dsTGxmLhwoXo6+sb8pyjfd2Hir9r7enpwa5du/DAAw9g165d+Nvf/obDhw/jqquuGva8o3kthMpwjysAlJeX+4z79ddf93tOtT6uwPDXO/A66+vrsXbtWgiCgKuvvtrvedX42AaNSIpZsGCBeMcdd8j/drlcYk5OjrhmzZpBj7/22mvFK6+80udnJSUl4v/3//1/QR1nMDQ2NooAxE8//XTIY1566SUxMTExdIMKkNWrV4vFxcUjPj6cHtf/+q//EqdMmSK63e5Bf6/Vx1QURRGA+M4778j/drvdYlZWlvib3/xG/ll7e7toNpvF119/fcjzjPZ1r4RTr3UwO3bsEAGINTU1Qx4z2teCEga71ptuuklctGjRqM6jhcdVFEf22C5atEj89re/7fcYLTy2gcSZJYXY7Xbs3LkTZWVl8s90Oh3Kysqwbdu2Qe+zbds2n+MBYOHChUMer2YdHR0AgJSUFL/HdXV1YfLkycjNzcWiRYtw4MCBUAxv3I4ePYqcnBwUFBTghhtuQG1t7ZDHhsvjarfb8corr+D//b//53dDaa0+pqeqqqqCxWLxeewSExNRUlIy5GM3lte9WnV0dEAQBCQlJfk9bjSvBTXZsmULMjIyMGPGDNx+++1oaWkZ8thwelwbGhrwwQcfYNmyZcMeq9XHdiwYLCmkubkZLpcLmZmZPj/PzMyExWIZ9D4Wi2VUx6uV2+3GnXfeifPOOw+zZs0a8rgZM2Zg7dq1+Pvf/45XXnkFbrcb5557Lo4fPx7C0Y5eSUkJ1q1bhw0bNuCZZ55BVVUVLrjgAnR2dg56fLg8ru+++y7a29tx8803D3mMVh/TwUiPz2geu7G87tWor68P9913H66//nq/m6yO9rWgFuXl5Xj55ZexefNmPProo/j0009x+eWXw+VyDXp8uDyuALB+/XrEx8fju9/9rt/jtPrYjpVB6QFQ5Lnjjjuwf//+Yde3S0tLUVpaKv/73HPPRVFREf70pz/h4YcfDvYwx+zyyy+X//+cOXNQUlKCyZMn46233hrRtzWtevHFF3H55ZcjJydnyGO0+phSP4fDgWuvvRaiKOKZZ57xe6xWXwtLliyR///s2bMxZ84cTJkyBVu2bMEll1yi4MiCb+3atbjhhhuGLbzQ6mM7VpxZUkhaWhr0ej0aGhp8ft7Q0ICsrKxB75OVlTWq49VoxYoVeP/99/HJJ59g4sSJo7qv0WjEvHnzUFFREaTRBUdSUhKmT58+5LjD4XGtqanBpk2bcOutt47qflp9TAHIj89oHruxvO7VRAqUampqsHHjRr+zSoMZ7rWgVgUFBUhLSxty3Fp/XCX/+te/cPjw4VG/jgHtPrYjxWBJISaTCfPnz8fmzZvln7ndbmzevNnnm/dApaWlPscDwMaNG4c8Xk1EUcSKFSvwzjvv4OOPP0Z+fv6oz+FyubBv3z5kZ2cHYYTB09XVhWPHjg05bi0/rpKXXnoJGRkZuPLKK0d1P60+pgCQn5+PrKwsn8fOarVi+/btQz52Y3ndq4UUKB09ehSbNm1CamrqqM8x3GtBrY4fP46WlpYhx63lx3WgF198EfPnz0dxcfGo76vVx3bElM4wj2RvvPGGaDabxXXr1onffPONeNttt4lJSUmixWIRRVEUf/CDH4j333+/fPzWrVtFg8EgPv744+LBgwfF1atXi0ajUdy3b59SlzBit99+u5iYmChu2bJFrK+vl289PT3yMade7y9+8Qvxww8/FI8dOybu3LlTXLJkiRgVFSUeOHBAiUsYsbvvvlvcsmWLWFVVJW7dulUsKysT09LSxMbGRlEUw+txFUVP1c+kSZPE++6777Tfaf0x7ezsFL/++mvx66+/FgGITzzxhPj111/LFWC//vWvxaSkJPHvf/+7uHfvXnHRokVifn6+2NvbK5/j29/+tvjUU0/J/x7uda8Uf9dqt9vFq666Spw4caK4e/dun9ewzWaTz3HqtQ73WlCKv2vt7OwU77nnHnHbtm1iVVWVuGnTJvHMM88Up02bJvb19cnn0MrjKorDP49FURQ7OjrEmJgY8Zlnnhn0HFp5bIOFwZLCnnrqKXHSpEmiyWQSFyxYIH7xxRfy7y688ELxpptu8jn+rbfeEqdPny6aTCbxjDPOED/44IMQj3hsAAx6e+mll+RjTr3eO++8U/5vk5mZKV5xxRXirl27Qj/4UbruuuvE7Oxs0WQyiRMmTBCvu+46saKiQv59OD2uoiiKH374oQhAPHz48Gm/0/pj+sknnwz6vJWuye12iw888ICYmZkpms1m8ZJLLjntv8PkyZPF1atX+/zM3+teKf6utaqqasjX8CeffCKf49RrHe61oBR/19rT0yNedtllYnp6umg0GsXJkyeLy5cvPy3o0crjKorDP49FURT/9Kc/idHR0WJ7e/ug59DKYxssgiiKYlCnroiIiIg0jDlLRERERH4wWCIiIiLyg8ESERERkR8MloiIiIj8YLBERERE5AeDJSIiIiI/GCwRERER+cFgiYiIiMgPBktEREREfjBYIiIiIvKDwRIRRQS73a70EIhIoxgsEVFYuuiii7BixQrceeedSEtLw8KFC/HEE09g9uzZiI2NRW5uLn70ox+hq6tLvs+6deuQlJSEDz/8EEVFRYiLi0N5eTnq6+vlY5xOJ37yk58gKSkJqampuO+++3DTTTdh8eLF8jFutxtr1qxBfn4+oqOjUVxcjL/85S+hvHwiCiAGS0QUttavXw+TyYStW7fi2WefhU6nw5NPPokDBw5g/fr1+Pjjj3Hvvff63KenpwePP/44/vznP+Ozzz5DbW0t7rnnHvn3jz76KF599VW89NJL2Lp1K6xWK959912fc6xZswYvv/wynn32WRw4cAB33XUXbrzxRnz66aehuGwiCjBBFEVR6UEQEQXaRRddBKvVil27dg15zF/+8hf88Ic/RHNzMwDPzNItt9yCiooKTJkyBQDwxz/+EQ899BAsFgsAICsrC/fcc48cQLlcLhQUFGDevHl49913YbPZkJKSgk2bNqG0tFT+W7feeit6enrw2muvBeuSiShIDEoPgIgoWObPn+/z702bNmHNmjU4dOgQrFYrnE4n+vr60NPTg5iYGABATEyMHCgBQHZ2NhobGwEAHR0daGhowIIFC+Tf6/V6zJ8/H263GwBQUVGBnp4eXHrppT5/2263Y968eUG5TiIKLgZLRBS2YmNj5f9fXV2N//iP/8Dtt9+OX/3qV0hJScG///1vLFu2DHa7XQ6WjEajzzkEQcBoJuClHKgPPvgAEyZM8Pmd2Wwe66UQkYIYLBFRRNi5cyfcbjd++9vfQqfzpGu+9dZbozpHYmIiMjMz8eWXX+Jb3/oWAM8y3K5duzB37lwAwMyZM2E2m1FbW4sLL7wwoNdARMpgsEREEWHq1KlwOBx46qmn8J3vfEdO+h6tH//4x1izZg2mTp2KwsJCPPXUU2hra4MgCACA+Ph43HPPPbjrrrvgdrtx/vnno6OjA1u3bkVCQgJuuummQF8aEQUZq+GIKCIUFxfjiSeewKOPPopZs2bh1VdfxZo1a0Z9nvvuuw/XX389li5ditLSUsTFxWHhwoWIioqSj3n44YfxwAMPYM2aNSgqKkJ5eTk++OAD5OfnB/KSiChEWA1HRDQObrcbRUVFuPbaa/Hwww8rPRwiCgIuwxERjUJNTQ0++ugjXHjhhbDZbPjDH/6AqqoqfP/731d6aEQUJFyGIyIaBZ1Oh3Xr1uHss8/Geeedh3379mHTpk0oKipSemhEFCRchiMiIiLygzNLRERERH4wWCIiIiLyg8ESERERkR8MloiIiIj8YLBERERE5AeDJSIiIiI/GCwRERER+cFgiYiIiMiP/x9SsgBhXjM8iAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "7nAdQhVN3oAG"
      }
    }
  ]
 }
No results found