composer_classification.ipynb

composer_instrument_classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "name": "composer_classification.ipynb",
      "mount_file_id": "https://gist.github.com/SametSahin10/2968552ea9d4e30ac5baec1f6f333ebb#file-composer_instrument_classification-ipynb",
      "authorship_tag": "ABX9TyNx0TYQAuOPliR77L9/Pg2H",
      "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/SametSahin10/2968552ea9d4e30ac5baec1f6f333ebb/composer_instrument_classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t6OBJv6rfD6U",
        "outputId": "061b4c26-d8d0-49dc-fe32-ffcdfcb2ef43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install pretty_midi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AFSSTwuJgJ2M",
        "outputId": "69317eb7-9029-4f06-afc6-80c9dda1f7ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: pretty_midi in /usr/local/lib/python3.10/dist-packages (0.2.10)\n",
            "Requirement already satisfied: numpy>=1.7.0 in /usr/local/lib/python3.10/dist-packages (from pretty_midi) (1.22.4)\n",
            "Requirement already satisfied: mido>=1.1.16 in /usr/local/lib/python3.10/dist-packages (from pretty_midi) (1.2.10)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from pretty_midi) (1.16.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pretty_midi\n",
        "import numpy as np\n",
        "import os\n",
        "import tensorflow as tf\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "iV3LOtvFVbK-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dNWUTrTme1lG",
        "outputId": "9c659743-e2a8-4989-e259-d9265be62150"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/pretty_midi/pretty_midi.py:100: RuntimeWarning: Tempo, Key or Time signature change events found on non-zero tracks.  This is not a valid type 0 or type 1 MIDI file.  Tempo, Key or Time Signature may be wrong.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Got an error while processing: /content/drive/MyDrive/collab/musicnet_midis/Bach/2310_prelude15.mid\n",
            "Got an error while processing: /content/drive/MyDrive/collab/musicnet_midis/Bach/2230_prelude20.mid\n"
          ]
        }
      ],
      "source": [
        "# Yolu verilen bir MIDI dosyasindan nota ve hiz bilgilerini okuyup donduruyoruz.\n",
        "def extractNotesAndVelocities(path):\n",
        "    # MIDI dosyasini okuyoruz.\n",
        "    midi_data = pretty_midi.PrettyMIDI(path)\n",
        "\n",
        "    # MIDI dosyasindaki nota ve hiz bilgilerini elde ediyoruz.\n",
        "    notes = []\n",
        "    velocities = []\n",
        "\n",
        "    for instrument in midi_data.instruments:\n",
        "        for note in instrument.notes:\n",
        "            notes.append(note.pitch)\n",
        "            velocities.append(note.velocity)\n",
        "\n",
        "    # Nota ve hiz bilgilerini NumPy array'lerine cevirip\n",
        "    # fonksiyondan donduruyoruz.\n",
        "    notes = np.array(notes)\n",
        "    velocities = np.array(velocities)\n",
        "    return notes, velocities\n",
        "\n",
        "# Verilen kok dizinindeki tum klasorlerdeki MIDI dosyalarini okuyup\n",
        "# bir dictionary'de sakliyoruz.\n",
        "def createComposersDictionary(root_path):\n",
        "    composers = {}\n",
        "\n",
        "    for folder in os.listdir(root_path):\n",
        "        for file in os.listdir(os.path.join(root_path, folder)):\n",
        "            path = f'{root_path}/{folder}/{file}'\n",
        "\n",
        "            # Iterasyon sirasinda bazi MIDI dosyalari okunurken olusabilecek\n",
        "            # problemlere karsilik try-except kullandik.\n",
        "            try:\n",
        "                notes, velocities = extractNotesAndVelocities(path)\n",
        "            except:\n",
        "                print(f\"Got an error while processing: {path}\")\n",
        "                continue\n",
        "\n",
        "            data = [notes, velocities]\n",
        "            dataAsNumpyArray = np.array(data)\n",
        "            \n",
        "            if folder in composers:\n",
        "                composers[folder].append(dataAsNumpyArray)\n",
        "            else:\n",
        "                composers[folder] = [dataAsNumpyArray]\n",
        "\n",
        "    return composers\n",
        "\n",
        "composers = createComposersDictionary('/content/drive/MyDrive/collab/musicnet_midis')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Sinir Agini olusturuyoruz.\n",
        "model = tf.keras.Sequential([\n",
        "    tf.keras.layers.Input(shape=(2, 400)),\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dense(128, activation='relu'),\n",
        "    tf.keras.layers.Dense(128, activation='relu'),\n",
        "    tf.keras.layers.Dense(128, activation='relu'),\n",
        "    tf.keras.layers.Dense(10, activation=\"softmax\")\n",
        "])\n",
        "\n",
        "model.compile(\n",
        "    loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n",
        "    optimizer=tf.keras.optimizers.Adam(),\n",
        "    metrics=[\"accuracy\"]\n",
        ")"
      ],
      "metadata": {
        "id": "pxHkGhK6s76u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "composer_name_to_index = {\n",
        "    composer:index for index, composer in enumerate(os.listdir('/content/drive/MyDrive/collab/musicnet_midis'))\n",
        "}"
      ],
      "metadata": {
        "id": "5x24_F1CjJwi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "composer_name_to_index"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VMeNPV8Sjt3g",
        "outputId": "528f3755-adaf-4ccd-b1ec-165b98f957a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'Mozart': 0,\n",
              " 'Brahms': 1,\n",
              " 'Dvorak': 2,\n",
              " 'Haydn': 3,\n",
              " 'Schubert': 4,\n",
              " 'Bach': 5,\n",
              " 'Beethoven': 6,\n",
              " 'Faure': 7,\n",
              " 'Ravel': 8,\n",
              " 'Cambini': 9}"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Sarkilarin uzunluklari farkli oldugundan\n",
        "# her sarkiyi 400 notalik parcalara boluyoruz.\n",
        "labels = []\n",
        "features = []\n",
        "for composer, notes_and_velocities in composers.items():\n",
        "  for i in range(len(notes_and_velocities)):\n",
        "    # Nota sayisindaki boyut farkliligini engellemek icin\n",
        "    # nota sayisi 400'den az olan sarkilari hesaba katmiyoruz.\n",
        "    if notes_and_velocities[i][0].shape[0] < 400: continue\n",
        "    n = notes_and_velocities[i][0].shape[0] // 400\n",
        "    increment = 0\n",
        "    for index in range(n):\n",
        "      notes = notes_and_velocities[i][0][increment:increment+400]\n",
        "      velocities = notes_and_velocities[i][1][increment:increment+400]\n",
        "      labels.append(composer_name_to_index[composer])\n",
        "\n",
        "      data = [notes, velocities]\n",
        "      dataAsNumpyArray = np.array(data)\n",
        "\n",
        "      features.append(dataAsNumpyArray)\n",
        "      increment+=400"
      ],
      "metadata": {
        "id": "I6Ec_RHHh15W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "features = np.array(features)\n",
        "labels = np.array(labels)"
      ],
      "metadata": {
        "id": "xHSo0wVsmLWO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Elimizdeki verinin %20'sini test verisi olarak ayirdik.\n",
        "from sklearn.model_selection import train_test_split\n",
        "x_train, x_test, y_train, y_test = train_test_split(features, labels, test_size=0.2)"
      ],
      "metadata": {
        "id": "SgomezGyk9J6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Modeli egitiyoruz.\n",
        "history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A-P_oIp_l1d-",
        "outputId": "7d307b81-3928-4b1d-8391-21cd8bfcc392"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/10\n",
            "65/65 [==============================] - 1s 8ms/step - loss: 13.0275 - accuracy: 0.3568 - val_loss: 2.5380 - val_accuracy: 0.4151\n",
            "Epoch 2/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 2.5598 - accuracy: 0.4046 - val_loss: 2.1138 - val_accuracy: 0.4942\n",
            "Epoch 3/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 1.8126 - accuracy: 0.4708 - val_loss: 1.6480 - val_accuracy: 0.5309\n",
            "Epoch 4/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 1.6860 - accuracy: 0.5007 - val_loss: 1.7644 - val_accuracy: 0.4710\n",
            "Epoch 5/10\n",
            "65/65 [==============================] - 0s 6ms/step - loss: 1.6735 - accuracy: 0.5056 - val_loss: 1.5977 - val_accuracy: 0.5212\n",
            "Epoch 6/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 1.6238 - accuracy: 0.5181 - val_loss: 1.7630 - val_accuracy: 0.4266\n",
            "Epoch 7/10\n",
            "65/65 [==============================] - 0s 3ms/step - loss: 1.6172 - accuracy: 0.5176 - val_loss: 1.6278 - val_accuracy: 0.5039\n",
            "Epoch 8/10\n",
            "65/65 [==============================] - 0s 3ms/step - loss: 1.5927 - accuracy: 0.5278 - val_loss: 1.5143 - val_accuracy: 0.5290\n",
            "Epoch 9/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 1.4727 - accuracy: 0.5437 - val_loss: 1.4438 - val_accuracy: 0.5251\n",
            "Epoch 10/10\n",
            "65/65 [==============================] - 0s 4ms/step - loss: 1.4556 - accuracy: 0.5403 - val_loss: 1.4697 - val_accuracy: 0.5174\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loss'u ve validation loss'u gorsellestirelim.\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "epochs = range(1, len(loss) + 1)\n",
        "\n",
        "plt.plot(epochs, loss, 'b', label='Training Loss')\n",
        "plt.plot(epochs, val_loss, 'r', label='Validation Loss')\n",
        "plt.title('Training and Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "CsGoe6ebUnp2",
        "outputId": "29796300-fa00-402e-eeb0-480ccef1ce97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRp0lEQVR4nO3dd3gU1f4G8HeySTZ9U0iVEEIIJISACMgPIkVBJWAEO9wIAQuWIKByBS+CoChigyt6KZZgAb3qBeQqxYAUKVIuVQhNINQAIWXTQ3bP749hN1mSkLab2fJ+nmee3Sk7893s6r6cOWdGEkIIEBEREdkgJ6ULICIiImosBhkiIiKyWQwyREREZLMYZIiIiMhmMcgQERGRzWKQISIiIpvFIENEREQ2i0GGiIiIbBaDDBEREdksBhkiCxk1ahRat27dqNdOnz4dkiSZtyArc/r0aUiShMWLFzf7sSVJwvTp043zixcvhiRJOH36dJ2vbd26NUaNGmXWepryXSFydAwy5HAkSarXtHHjRqVLdXjjxo2DJEk4ceJErdtMmTIFkiThwIEDzVhZw124cAHTp0/Hvn37lC7FyBAm33//faVLIWo0Z6ULIGpuX3/9tcn8V199hfT09GrLY2Njm3ScTz/9FHq9vlGvfe211zB58uQmHd8eJCcnY968eVi6dCmmTZtW4zbffvst4uPj0alTp0YfZ8SIERg2bBjUanWj91GXCxcuYMaMGWjdujVuvfVWk3VN+a4QOToGGXI4jz/+uMn8H3/8gfT09GrLb1RcXAwPD496H8fFxaVR9QGAs7MznJ35n2ePHj3Qtm1bfPvttzUGme3bt+PUqVN45513mnQclUoFlUrVpH00RVO+K0SOjqeWiGrQr18/dOzYEf/73//Qp08feHh44B//+AcA4KeffsLgwYMRFhYGtVqNqKgovPnmm9DpdCb7uLHfQ9Vm/EWLFiEqKgpqtRrdu3fHrl27TF5bUx8ZSZIwduxYrFixAh07doRarUZcXBzWrFlTrf6NGzeiW7ducHNzQ1RUFBYuXFjvfje///47HnnkEbRq1QpqtRrh4eF48cUXUVJSUu39eXl54fz58xg6dCi8vLwQGBiIiRMnVvtb5OXlYdSoUdBoNPD19UVKSgry8vLqrAWQW2WOHDmCPXv2VFu3dOlSSJKE4cOHo7y8HNOmTUPXrl2h0Wjg6emJ3r17Y8OGDXUeo6Y+MkIIzJw5Ey1btoSHhwfuvPNOHDp0qNprc3JyMHHiRMTHx8PLyws+Pj5ITEzE/v37jdts3LgR3bt3BwCMHj3aePrS0D+opj4yRUVFePnllxEeHg61Wo327dvj/fffhxDCZLuGfC8a6/Lly3jyyScRHBwMNzc3dO7cGV9++WW17b777jt07doV3t7e8PHxQXx8PP75z38a11+7dg0zZsxAdHQ03NzcEBAQgDvuuAPp6elmq5UcD//JR1SLq1evIjExEcOGDcPjjz+O4OBgAPKPnpeXF1566SV4eXnht99+w7Rp06DVavHee+/Vud+lS5eioKAAzzzzDCRJwrvvvosHH3wQJ0+erPNf5lu2bMGyZcvw/PPPw9vbGx999BEeeughnDlzBgEBAQCAvXv3YuDAgQgNDcWMGTOg0+nwxhtvIDAwsF7v+4cffkBxcTGee+45BAQEYOfOnZg3bx7OnTuHH374wWRbnU6He++9Fz169MD777+PdevW4YMPPkBUVBSee+45AHIgGDJkCLZs2YJnn30WsbGxWL58OVJSUupVT3JyMmbMmIGlS5fitttuMzn2999/j969e6NVq1bIzs7GZ599huHDh+Ppp59GQUEBPv/8c9x7773YuXNntdM5dZk2bRpmzpyJQYMGYdCgQdizZw/uuecelJeXm2x38uRJrFixAo888ggiIyNx6dIlLFy4EH379sXhw4cRFhaG2NhYvPHGG5g2bRrGjBmD3r17AwB69epV47GFELj//vuxYcMGPPnkk7j11luxdu1a/P3vf8f58+cxZ84ck+3r871orJKSEvTr1w8nTpzA2LFjERkZiR9++AGjRo1CXl4exo8fDwBIT0/H8OHD0b9/f8yePRsAkJGRga1btxq3mT59OmbNmoWnnnoKt99+O7RaLXbv3o09e/bg7rvvblKd5MAEkYNLTU0VN/6n0LdvXwFALFiwoNr2xcXF1ZY988wzwsPDQ5SWlhqXpaSkiIiICOP8qVOnBAAREBAgcnJyjMt/+uknAUD897//NS57/fXXq9UEQLi6uooTJ04Yl+3fv18AEPPmzTMuS0pKEh4eHuL8+fPGZcePHxfOzs7V9lmTmt7frFmzhCRJIjMz0+T9ARBvvPGGybZdunQRXbt2Nc6vWLFCABDvvvuucVlFRYXo3bu3ACDS0tLqrKl79+6iZcuWQqfTGZetWbNGABALFy407rOsrMzkdbm5uSI4OFg88cQTJssBiNdff904n5aWJgCIU6dOCSGEuHz5snB1dRWDBw8Wer3euN0//vEPAUCkpKQYl5WWlprUJYT8WavVapO/za5du2p9vzd+Vwx/s5kzZ5ps9/DDDwtJkky+A/X9XtTE8J187733at1m7ty5AoD45ptvjMvKy8tFz549hZeXl9BqtUIIIcaPHy98fHxERUVFrfvq3LmzGDx48E1rImoonloiqoVarcbo0aOrLXd3dzc+LygoQHZ2Nnr37o3i4mIcOXKkzv0+9thj8PPzM84b/nV+8uTJOl87YMAAREVFGec7deoEHx8f42t1Oh3WrVuHoUOHIiwszLhd27ZtkZiYWOf+AdP3V1RUhOzsbPTq1QtCCOzdu7fa9s8++6zJfO/evU3ey6pVq+Ds7GxsoQHkPikvvPBCveoB5H5N586dw+bNm43Lli5dCldXVzzyyCPGfbq6ugIA9Ho9cnJyUFFRgW7dutV4Wupm1q1bh/Lycrzwwgsmp+MmTJhQbVu1Wg0nJ/l/pTqdDlevXoWXlxfat2/f4OMarFq1CiqVCuPGjTNZ/vLLL0MIgdWrV5ssr+t70RSrVq1CSEgIhg8fblzm4uKCcePGobCwEJs2bQIA+Pr6oqio6KaniXx9fXHo0CEcP368yXURGTDIENXilltuMf4wVnXo0CE88MAD0Gg08PHxQWBgoLGjcH5+fp37bdWqlcm8IdTk5uY2+LWG1xtee/nyZZSUlKBt27bVtqtpWU3OnDmDUaNGwd/f39jvpW/fvgCqvz83N7dqp6yq1gMAmZmZCA0NhZeXl8l27du3r1c9ADBs2DCoVCosXboUAFBaWorly5cjMTHRJBR++eWX6NSpk7H/RWBgIH755Zd6fS5VZWZmAgCio6NNlgcGBpocD5BD05w5cxAdHQ21Wo0WLVogMDAQBw4caPBxqx4/LCwM3t7eJssNI+kM9RnU9b1oiszMTERHRxvDWm21PP/882jXrh0SExPRsmVLPPHEE9X66bzxxhvIy8tDu3btEB8fj7///e9WP2yerB+DDFEtqrZMGOTl5aFv377Yv38/3njjDfz3v/9Fenq6sU9AfYbQ1jY6RtzQidPcr60PnU6Hu+++G7/88gsmTZqEFStWID093dgp9cb311wjfYKCgnD33XfjP//5D65du4b//ve/KCgoQHJysnGbb775BqNGjUJUVBQ+//xzrFmzBunp6bjrrrssOrT57bffxksvvYQ+ffrgm2++wdq1a5Geno64uLhmG1Jt6e9FfQQFBWHfvn1YuXKlsX9PYmKiSV+oPn364K+//sIXX3yBjh074rPPPsNtt92Gzz77rNnqJPvDzr5EDbBx40ZcvXoVy5YtQ58+fYzLT506pWBVlYKCguDm5lbjBeRudlE5g4MHD+LYsWP48ssvMXLkSOPypowqiYiIwPr161FYWGjSKnP06NEG7Sc5ORlr1qzB6tWrsXTpUvj4+CApKcm4/scff0SbNm2wbNkyk9NBr7/+eqNqBoDjx4+jTZs2xuVXrlyp1srx448/4s4778Tnn39usjwvLw8tWrQwzjfkSs0RERFYt24dCgoKTFplDKcuDfU1h4iICBw4cAB6vd6kVaamWlxdXZGUlISkpCTo9Xo8//zzWLhwIaZOnWpsEfT398fo0aMxevRoFBYWok+fPpg+fTqeeuqpZntPZF/YIkPUAIZ/+Vb9l255eTn+9a9/KVWSCZVKhQEDBmDFihW4cOGCcfmJEyeq9auo7fWA6fsTQpgMoW2oQYMGoaKiAvPnzzcu0+l0mDdvXoP2M3ToUHh4eOBf//oXVq9ejQcffBBubm43rX3Hjh3Yvn17g2seMGAAXFxcMG/ePJP9zZ07t9q2KpWqWsvHDz/8gPPnz5ss8/T0BIB6DTsfNGgQdDodPv74Y5Plc+bMgSRJ9e7vZA6DBg1CVlYW/v3vfxuXVVRUYN68efDy8jKedrx69arJ65ycnIwXKSwrK6txGy8vL7Rt29a4nqgx2CJD1AC9evWCn58fUlJSjJfP//rrr5u1Cb8u06dPx6+//oqEhAQ899xzxh/Ejh071nl5/JiYGERFRWHixIk4f/48fHx88J///KdJfS2SkpKQkJCAyZMn4/Tp0+jQoQOWLVvW4P4jXl5eGDp0qLGfTNXTSgBw3333YdmyZXjggQcwePBgnDp1CgsWLECHDh1QWFjYoGMZrocza9Ys3HfffRg0aBD27t2L1atXm7SyGI77xhtvYPTo0ejVqxcOHjyIJUuWmLTkAEBUVBR8fX2xYMECeHt7w9PTEz169EBkZGS14yclJeHOO+/ElClTcPr0aXTu3Bm//vorfvrpJ0yYMMGkY685rF+/HqWlpdWWDx06FGPGjMHChQsxatQo/O9//0Pr1q3x448/YuvWrZg7d66xxeipp55CTk4O7rrrLrRs2RKZmZmYN28ebr31VmN/mg4dOqBfv37o2rUr/P39sXv3bvz4448YO3asWd8PORhlBksRWY/ahl/HxcXVuP3WrVvF//3f/wl3d3cRFhYmXnnlFbF27VoBQGzYsMG4XW3Dr2sa6oobhgPXNvw6NTW12msjIiJMhgMLIcT69etFly5dhKurq4iKihKfffaZePnll4Wbm1stf4VKhw8fFgMGDBBeXl6iRYsW4umnnzYO5606dDglJUV4enpWe31NtV+9elWMGDFC+Pj4CI1GI0aMGCH27t1b7+HXBr/88osAIEJDQ6sNedbr9eLtt98WERERQq1Wiy5duoiff/652ucgRN3Dr4UQQqfTiRkzZojQ0FDh7u4u+vXrJ/78889qf+/S0lLx8ssvG7dLSEgQ27dvF3379hV9+/Y1Oe5PP/0kOnToYBwKb3jvNdVYUFAgXnzxRREWFiZcXFxEdHS0eO+990yGgxveS32/FzcyfCdrm77++mshhBCXLl0So0ePFi1atBCurq4iPj6+2uf2448/invuuUcEBQUJV1dX0apVK/HMM8+IixcvGreZOXOmuP3224Wvr69wd3cXMTEx4q233hLl5eU3rZPoZiQhrOifkkRkMUOHDuXQVyKyO+wjQ2SHbrydwPHjx7Fq1Sr069dPmYKIiCyELTJEdig0NBSjRo1CmzZtkJmZifnz56OsrAx79+6tdm0UIiJbxs6+RHZo4MCB+Pbbb5GVlQW1Wo2ePXvi7bffZoghIrvDFhkiIiKyWewjQ0RERDaLQYaIiIhslt33kdHr9bhw4QK8vb0bdIlwIiIiUo4QAgUFBQgLC6t209Kq7D7IXLhwAeHh4UqXQURERI1w9uxZtGzZstb1dh9kDJfPPnv2LHx8fBSuhoiIiOpDq9UiPDzc5MapNbH7IGM4neTj48MgQ0REZGPq6hbCzr5ERERksxhkiIiIyGYxyBAREZHNsvs+MkRE1DQ6nQ7Xrl1TugyyMy4uLlCpVE3eD4MMERHVSAiBrKws5OXlKV0K2SlfX1+EhIQ06TpvDDJERFQjQ4gJCgqCh4cHLypKZiOEQHFxMS5fvgwACA0NbfS+GGSIiKganU5nDDEBAQFKl0N2yN3dHQBw+fJlBAUFNfo0Ezv7EhFRNYY+MR4eHgpXQvbM8P1qSh8sBhkiIqoVTyeRJZnj+8UgQ0RERDaLQYaIiKgOrVu3xty5c+u9/caNGyFJEkd8NQMGGSIishuSJN10mj59eqP2u2vXLowZM6be2/fq1QsXL16ERqNp1PHqi4GJo5YaTacDTp4ENBogKEjpaoiICAAuXrxofP7vf/8b06ZNw9GjR43LvLy8jM+FENDpdHB2rvunMDAwsEF1uLq6IiQkpEGvocZhi0wjDRsGtGsHfPed0pUQEZFBSEiIcdJoNJAkyTh/5MgReHt7Y/Xq1ejatSvUajW2bNmCv/76C0OGDEFwcDC8vLzQvXt3rFu3zmS/N55akiQJn332GR544AF4eHggOjoaK1euNK6/saVk8eLF8PX1xdq1axEbGwsvLy8MHDjQJHhVVFRg3Lhx8PX1RUBAACZNmoSUlBQMHTq00X+P3NxcjBw5En5+fvDw8EBiYiKOHz9uXJ+ZmYmkpCT4+fnB09MTcXFxWLVqlfG1ycnJCAwMhLu7O6Kjo5GWltboWiyFQaaR2reXHw8dUrYOIqLmIgRQVKTMJIT53sfkyZPxzjvvICMjA506dUJhYSEGDRqE9evXY+/evRg4cCCSkpJw5syZm+5nxowZePTRR3HgwAEMGjQIycnJyMnJqXX74uJivP/++/j666+xefNmnDlzBhMnTjSunz17NpYsWYK0tDRs3boVWq0WK1asaNJ7HTVqFHbv3o2VK1di+/btEEJg0KBBxuHOqampKCsrw+bNm3Hw4EHMnj3b2Go1depUHD58GKtXr0ZGRgbmz5+PFi1aNKkeixB2Lj8/XwAQ+fn5Zt3vkiVCAELccYdZd0tEZBVKSkrE4cOHRUlJiXFZYaH8/z0lpsLChr+HtLQ0odFojPMbNmwQAMSKFSvqfG1cXJyYN2+ecT4iIkLMmTPHOA9AvPbaa1X+NoUCgFi9erXJsXJzc421ABAnTpwwvuaTTz4RwcHBxvng4GDx3nvvGecrKipEq1atxJAhQ2qt88bjVHXs2DEBQGzdutW4LDs7W7i7u4vvv/9eCCFEfHy8mD59eo37TkpKEqNHj6712OZQ0/fMoL6/32yRaaS4OPnx0CHz/kuBiIgsq1u3bibzhYWFmDhxImJjY+Hr6wsvLy9kZGTU2SLTqVMn43NPT0/4+PgYL7lfEw8PD0RFRRnnQ0NDjdvn5+fj0qVLuP32243rVSoVunbt2qD3VlVGRgacnZ3Ro0cP47KAgAC0b98eGRkZAIBx48Zh5syZSEhIwOuvv44DBw4Yt33uuefw3Xff4dZbb8Urr7yCbdu2NboWS2KQaaR27QAnJyA3F7jJ95aIyG54eACFhcpM5rzAsKenp8n8xIkTsXz5crz99tv4/fffsW/fPsTHx6O8vPym+3FxcTGZlyQJer2+QdsLhf8l/NRTT+HkyZMYMWIEDh48iG7dumHevHkAgMTERGRmZuLFF1/EhQsX0L9/f5NTYdaCQaaR3N2BNm3k5+wnQ0SOQJIAT09lJkteYHjr1q0YNWoUHnjgAcTHxyMkJASnT5+23AFroNFoEBwcjF27dhmX6XQ67Nmzp9H7jI2NRUVFBXbs2GFcdvXqVRw9ehQdOnQwLgsPD8ezzz6LZcuW4eWXX8ann35qXBcYGIiUlBR88803mDt3LhYtWtToeiyFw6+boEMH4MQJ4PBh4K67lK6GiIgaIzo6GsuWLUNSUhIkScLUqVNv2rJiKS+88AJmzZqFtm3bIiYmBvPmzUNubm69LuN/8OBBeHt7G+clSULnzp0xZMgQPP3001i4cCG8vb0xefJk3HLLLRgyZAgAYMKECUhMTES7du2Qm5uLDRs2IDY2FgAwbdo0dO3aFXFxcSgrK8PPP/9sXGdNGGSaIC4OWLlSDjJERGSbPvzwQzzxxBPo1asXWrRogUmTJkGr1TZ7HZMmTUJWVhZGjhwJlUqFMWPG4N57763XXaH79OljMq9SqVBRUYG0tDSMHz8e9913H8rLy9GnTx+sWrXKeJpLp9MhNTUV586dg4+PDwYOHIg5c+YAkK+F8+qrr+L06dNwd3dH79698Z0VXnNEEkqfoLMwrVYLjUaD/Px8+Pj4mHXf33wDjBgB9O0LbNxo1l0TESmqtLQUp06dQmRkJNzc3JQuxyHp9XrExsbi0UcfxZtvvql0ORZxs+9ZfX+/2SLTBIZTjGyRISKipsrMzMSvv/6Kvn37oqysDB9//DFOnTqFv/3tb0qXZtXY2bcJYmLkDmhXrsgTERFRYzk5OWHx4sXo3r07EhIScPDgQaxbt84q+6VYE7bINIGHBxAZKd9z6fBh+RQTERFRY4SHh2Pr1q1Kl2Fz2CLTRDy9REREpBwGmSZikCEiIlIOg0wTGYIML4pHRETU/BhkmogtMkRERMphkGkiQ2fyS5eAq1eVrYWIiMjRMMg0kZcXEBEhP79+M1EiIiJqJgwyZsB+MkRE9qVfv36YMGGCcb5169aYO3fuTV8jSRJWrFjR5GObaz+OgkHGDNhPhojIOiQlJWHgwIE1rvv9998hSRIOHDjQ4P3u2rULY8aMaWp5JqZPn45bb7212vKLFy8iMTHRrMe60eLFi+Hr62vRYzQXBhkziIuTHxlkiIiU9eSTTyI9PR3nzp2rti4tLQ3dunVDp06dGrzfwMBAeHh4mKPEOoWEhECtVjfLsewBg4wZsEWGiMg63HfffQgMDMTixYtNlhcWFuKHH37Ak08+iatXr2L48OG45ZZb4OHhgfj4eHz77bc33e+Np5aOHz+OPn36wM3NDR06dEB6enq110yaNAnt2rWDh4cH2rRpg6lTp+LatWsA5BaRGTNmYP/+/ZAkCZIkGWu+8dTSwYMHcdddd8Hd3R0BAQEYM2YMCgsLjetHjRqFoUOH4v3330doaCgCAgKQmppqPFZjnDlzBkOGDIGXlxd8fHzw6KOP4tKlS8b1+/fvx5133glvb2/4+Piga9eu2L17NwD5nlFJSUnw8/ODp6cn4uLisGrVqkbXUhfeosAMDCOXLlwA8vIAO2mtIyIyJQRQXKzMsT085Jvb1cHZ2RkjR47E4sWLMWXKFEjXX/PDDz9Ap9Nh+PDhKCwsRNeuXTFp0iT4+Pjgl19+wYgRIxAVFYXbb7+9zmPo9Xo8+OCDCA4Oxo4dO5Cfn2/Sn8bA29sbixcvRlhYGA4ePIinn34a3t7eeOWVV/DYY4/hzz//xJo1a7Bu3ToAgEajqbaPoqIi3HvvvejZsyd27dqFy5cv46mnnsLYsWNNwtqGDRsQGhqKDRs24MSJE3jsscdw66234umnn67z/dT0/gwhZtOmTaioqEBqaioee+wxbNy4EQCQnJyMLl26YP78+VCpVNi3bx9cXFwAAKmpqSgvL8fmzZvh6emJw4cPw8vLq8F11Juwc/n5+QKAyM/Pt+hxWrYUAhBi61aLHoaIqFmUlJSIw4cPi5KSksqFhYXy/+iUmAoL6117RkaGACA2bNhgXNa7d2/x+OOP1/qawYMHi5dfftk437dvXzF+/HjjfEREhJgzZ44QQoi1a9cKZ2dncf78eeP61atXCwBi+fLltR7jvffeE127djXOv/7666Jz587Vtqu6n0WLFgk/Pz9RWOX9//LLL8LJyUlkZWUJIYRISUkRERERoqKiwrjNI488Ih577LFaa0lLSxMajabGdb/++qtQqVTizJkzxmWHDh0SAMTOnTuFEEJ4e3uLxYsX1/j6+Ph4MX369FqPXVWN37Pr6vv7zVNLZsJ+MkRE1iEmJga9evXCF198AQA4ceIEfv/9dzz55JMAAJ1OhzfffBPx8fHw9/eHl5cX1q5dizNnztRr/xkZGQgPD0dYWJhxWc+ePatt9+9//xsJCQkICQmBl5cXXnvttXofo+qxOnfuDE9PT+OyhIQE6PV6HD161LgsLi4OKpXKOB8aGorLly836FhVjxkeHo7w8HDjsg4dOsDX1xcZ168z8tJLL+Gpp57CgAED8M477+Cvv/4ybjtu3DjMnDkTCQkJeP311xvVubohGGTMhP1kiMjueXgAhYXKTA3saPvkk0/iP//5DwoKCpCWloaoqCj07dsXAPDee+/hn//8JyZNmoQNGzZg3759uPfee1FeXm62P9X27duRnJyMQYMG4eeff8bevXsxZcoUsx6jKsNpHQNJkqDX6y1yLEAecXXo0CEMHjwYv/32Gzp06IDly5cDAJ566imcPHkSI0aMwMGDB9GtWzfMmzfPYrUoGmQ2b96MpKQkhIWFVevcdO3aNUyaNAnx8fHw9PREWFgYRo4ciQsXLihX8E3wWjJEZPckCfD0VGaqR/+Yqh599FE4OTlh6dKl+Oqrr/DEE08Y+8ts3boVQ4YMweOPP47OnTujTZs2OHbsWL33HRsbi7Nnz+LixYvGZX/88YfJNtu2bUNERASmTJmCbt26ITo6GpmZmSbbuLq6QqfT1Xms/fv3o6ioyLhs69atcHJyQvv27etdc0MY3t/Zs2eNyw4fPoy8vDx0MPzYAWjXrh1efPFF/Prrr3jwwQeRlpZmXBceHo5nn30Wy5Ytw8svv4xPP/3UIrUCCgeZoqIidO7cGZ988km1dcXFxdizZw+mTp2KPXv2YNmyZTh69Cjuv/9+BSqtG1tkiIish5eXFx577DG8+uqruHjxIkaNGmVcFx0djfT0dGzbtg0ZGRl45plnTEbk1GXAgAFo164dUlJSsH//fvz++++YMmWKyTbR0dE4c+YMvvvuO/z111/46KOPjC0WBq1bt8apU6ewb98+ZGdno6ysrNqxkpOT4ebmhpSUFPz555/YsGEDXnjhBYwYMQLBwcEN+6PcQKfTYd++fSZTRkYGBgwYgPj4eCQnJ2PPnj3YuXMnRo4cib59+6Jbt24oKSnB2LFjsXHjRmRmZmLr1q3YtWsXYq+PfJkwYQLWrl2LU6dOYc+ePdiwYYNxnUXUqzdOM0AdnaSEEGLnzp0CgMjMzKz3fpurs29ubmWfNAsfiojI4m7WCdNWbNu2TQAQgwYNMll+9epVMWTIEOHl5SWCgoLEa6+9JkaOHCmGDBli3OZmnX2FEOLo0aPijjvuEK6urqJdu3ZizZo11X7H/v73v4uAgADh5eUlHnvsMTFnzhyTDralpaXioYceEr6+vgKASEtLE0JU/z08cOCAuPPOO4Wbm5vw9/cXTz/9tCgoKDCuT0lJMaldCCHGjx8v+vbtW+vfJi0tTQCoNkVFRQkhhMjMzBT333+/8PT0FN7e3uKRRx4xdi4uKysTw4YNE+Hh4cLV1VWEhYWJsWPHGr8rY8eOFVFRUUKtVovAwEAxYsQIkZ2dXWMd5ujsK13/oylOkiQsX74cQ4cOrXWbdevW4Z577kFeXh58fHzqtV+tVguNRoP8/Px6v6axbrlFHoL9xx9Ajx4WPRQRkUWVlpbi1KlTiIyMhJubm9LlkJ262fesvr/fNtPZt7S0FJMmTcLw4cNv+obKysqg1WpNpubCfjJERETNyyaCzLVr1/Doo49CCIH58+ffdNtZs2ZBo9EYp6rDxyyN/WSIiIial9UHGUOIyczMRHp6ep2nh1599VXk5+cbp6q9ri2N15IhIiJqXlZ9iwJDiDl+/Dg2bNiAgICAOl+jVqsVu9kWW2SIiIial6JBprCwECdOnDDOG4ah+fv7IzQ0FA8//DD27NmDn3/+GTqdDllZWQAAf39/uLq6KlV2rQyjyzIz5es3WfLWEkREzcFKxoOQnTLH90vRU0u7d+9Gly5d0KVLFwDyJY+7dOmCadOm4fz581i5ciXOnTuHW2+9FaGhocZp27ZtSpZdq4AAwDCs//pVnImIbJLhSrHFSt0kkhyC4ft145WJG0LRFpl+/frdNI3Z4r8E4uKAS5fk00vduytdDRFR46hUKvj6+hrv1+Ph4WG8Mi5RUwkhUFxcjMuXL8PX19fkPlENZdV9ZGxRhw7Ab7+xnwwR2b6QkBAAaPTNB4nq4uvra/yeNRaDjJnxWjJEZC8kSUJoaCiCgoJw7do1pcshO+Pi4tKklhgDBhkz48glIrI3KpXKLD84RJZg9deRsTWGa8mcPg1UuVkpERERWQCDjJm1aAEEBsq3jzx6VOlqiIiI7BuDjAWwnwwREVHzYJCxAPaTISIiah4MMhbAIENERNQ8GGQsgDePJCIiah4MMhZgaJE5eRIoKVG2FiIiInvGIGMBQUGAvz+g13PkEhERkSUxyFiAJLGfDBERUXNgkLEQ9pMhIiKyPAYZC2GLDBERkeUxyFgIL4pHRERkeQwyFmIIMidOAGVlytZCRERkrxhkLCQ0FPD1lUcuHTumdDVERET2iUHGQjhyiYiIyPIYZCyI/WSIiIgsi0HGgtgiQ0REZFkMMhbEa8kQERFZFoOMBRlaZI4fB8rLla2FiIjIHjHIWNAttwDe3kBFhRxmiIiIyLwYZCyII5eIiIgsi0HGwthPhoiIyHIYZCyMLTJERESWwyBjYbyWDBERkeUwyFiYIcgcOwZcu6ZsLURERPaGQcbCWrUCvLzkEPPXX0pXQ0REZF8YZCxMkoDYWPk5+8kQERGZF4NMM2A/GSIiIstgkGkGHLlERERkGQwyzYBBhoiIyDIYZJqB4aJ4R4/KtysgIiIi82CQaQYREYC7O1BWBpw8qXQ1RERE9oNBphk4OXHkEhERkSUwyDQT9pMhIiIyPwaZZsKbRxIREZkfg0wz4bVkiIiIzI9BppkYgsyRI4BOp2wtRERE9oJBpplERgJubkBpKXD6tNLVEBER2QcGmWaiUgExMfJz9pMhIiIyDwaZZsR+MkRERObFINOMOASbiIjIvBhkmhGDDBERkXkxyDQjw7VkMjIAvV7ZWoiIiOwBg0wzatMGcHUFiouBzEylqyEiIrJ9igaZzZs3IykpCWFhYZAkCStWrDBZL4TAtGnTEBoaCnd3dwwYMADHjx9XplgzcHYG2reXn/P0EhERUdMpGmSKiorQuXNnfPLJJzWuf/fdd/HRRx9hwYIF2LFjBzw9PXHvvfeitLS0mSs1H/aTISIiMh9nJQ+emJiIxMTEGtcJITB37ly89tprGDJkCADgq6++QnBwMFasWIFhw4Y1Z6lmw3suERERmY/V9pE5deoUsrKyMGDAAOMyjUaDHj16YPv27QpW1jRskSEiIjIfRVtkbiYrKwsAEBwcbLI8ODjYuK4mZWVlKCsrM85rtVrLFNhIVYOMEIAkKVsPERGRLbPaFpnGmjVrFjQajXEKDw9XuiQTbdsCLi5AYSFw9qzS1RAREdk2qw0yISEhAIBLly6ZLL906ZJxXU1effVV5OfnG6ezVpYWXFyAdu3k5zy9RERE1DRWG2QiIyMREhKC9evXG5dptVrs2LEDPXv2rPV1arUaPj4+JpO1YT8ZIiIi81C0j0xhYSFOnDhhnD916hT27dsHf39/tGrVChMmTMDMmTMRHR2NyMhITJ06FWFhYRg6dKhyRZsBbx5JRERkHooGmd27d+POO+80zr/00ksAgJSUFCxevBivvPIKioqKMGbMGOTl5eGOO+7AmjVr4ObmplTJZsEWGSIiIvOQhBBC6SIsSavVQqPRID8/32pOMx06BHTsCPj4AHl5HLlERER0o/r+flttHxl7Fh0NqFSAVgtcuKB0NURERLaLQUYBrq5ymAHYT4aIiKgpGGQUwn4yRERETccgoxAGGSIioqZjkFEIbx5JRETUdAwyCql6LRn7HjdGRERkOQwyCmnXDnBykodf3+QemERERHQTDDIKcXMDoqLk5zy9RERE1DgMMgpiPxkiIqKmYZBREO+5RERE1DQMMgriEGwiIqKmYZBREEcuERERNQ2DjIJiYuQbRubkAFeuKF0NERGR7WGQUZC7O9Cmjfyc/WSIiIgajkFGYewnQ0RE1HgMMgpjkCEiImo8BhmF8VoyREREjccgozBeS4aIiKjxGGQUFhMjP165wpFLREREDcUgozBPT6B1a/l5RoaipRAREdkcBhkrwH4yREREjcMgYwXYT4aIiKhxGGSsAIdgExERNQ6DjBVgkCEiImocBhkrEBsrP2ZlyfddIiIiovphkLEC3t5Aq1byc7bKEBER1R+DjJXg6SUiIqKGY5CxEgwyREREDccgYyV4LRkiIqKGY5CxEmyRISIiajgGGSthGLl0/jyQl6doKURERDaDQcZKaDTALbfIz3nPJSIiovphkLEiPL1ERETUMAwyVoQdfomIiBqGQcaK8OaRREREDcMgY0V4aomIiKhhGGSsiCHInD0LaLXK1kJERGQLGGSsiJ8fEBoqPz9yRNlaiIiIbAGDjJVhPxkiIqL6Y5CxMuwnQ0REVH8MMlaGQYaIiKj+GGSsDK8lQ0REVH8MMlbG0CJz+jRQWKhoKURERFaPQcbKBAQAQUHyc45cIiIiujkGGSvEfjJERET1wyBjhdhPhoiIqH4YZKwQryVDRERUP1YdZHQ6HaZOnYrIyEi4u7sjKioKb775JoQQSpdmUTy1REREVD/OShdwM7Nnz8b8+fPx5ZdfIi4uDrt378bo0aOh0Wgwbtw4pcuzGEOQOXUKKC4GPDyUrYeIiMhaWXWQ2bZtG4YMGYLBgwcDAFq3bo1vv/0WO3fuVLgyywoKAlq0ALKzgaNHgS5dlK6IiIjIOln1qaVevXph/fr1OHbsGABg//792LJlCxITExWuzPLYT4aIiKhuVt0iM3nyZGi1WsTExEClUkGn0+Gtt95CcnJyra8pKytDWVmZcV6r1TZHqWbXoQOweTP7yRAREd2MVbfIfP/991iyZAmWLl2KPXv24Msvv8T777+PL7/8stbXzJo1CxqNxjiFh4c3Y8Xmww6/REREdZOEFQ8BCg8Px+TJk5GammpcNnPmTHzzzTc4Ustlb2tqkQkPD0d+fj58fHwsXrO5/PYb0L8/EB0NXD+zRkRE5DC0Wi00Gk2dv99WfWqpuLgYTk6mjUYqlQp6vb7W16jVaqjVakuXZnGGFpm//gJKSwE3N2XrISIiskZWHWSSkpLw1ltvoVWrVoiLi8PevXvx4Ycf4oknnlC6NIsLDgb8/IDcXHnkUufOSldERERkfay6j8y8efPw8MMP4/nnn0dsbCwmTpyIZ555Bm+++abSpVmcJLGfDBERUV2sukXG29sbc+fOxdy5c5UuRREdOgBbtzLIEBER1caqW2QcneHmkbyWDBERUc0YZKwYTy0RERHdHIOMFTMEmRMngCojyomIiOg6BhkrFhYG+PgAOh1w/LjS1RAREVmfRgWZs2fP4ty5c8b5nTt3YsKECVi0aJHZCiN55BL7yRAREdWuUUHmb3/7GzZs2AAAyMrKwt13342dO3diypQpeOONN8xaoKNjPxkiIqLaNSrI/Pnnn7j99tsByPdD6tixI7Zt24YlS5Zg8eLF5qzP4THIEBER1a5RQebatWvG2wCsW7cO999/PwAgJiYGFy9eNF91xCBDRER0E40KMnFxcViwYAF+//13pKenY+DAgQCACxcuICAgwKwFOjpDH5ljx4DycmVrISIisjaNCjKzZ8/GwoUL0a9fPwwfPhydr98IaOXKlcZTTmQeLVsCXl5ARYU8DJuIiIgqNeoWBf369UN2dja0Wi38/PyMy8eMGQMPDw+zFUeV91zauVM+vWQ41URERESNbJEpKSlBWVmZMcRkZmZi7ty5OHr0KIKCgsxaILGfDBERUW0aFWSGDBmCr776CgCQl5eHHj164IMPPsDQoUMxf/58sxZIlf1kGGSIiIhMNSrI7NmzB7179wYA/PjjjwgODkZmZia++uorfPTRR2YtkCpbZHhRPCIiIlONCjLFxcXw9vYGAPz666948MEH4eTkhP/7v/9DZmamWQukyiBz9Kjc6ZeIiIhkjQoybdu2xYoVK3D27FmsXbsW99xzDwDg8uXL8PHxMWuBBLRqBXh4ANeuAX/9pXQ1RERE1qNRQWbatGmYOHEiWrdujdtvvx09e/YEILfOdOnSxawFEuDkxA6/RERENWlUkHn44Ydx5swZ7N69G2vXrjUu79+/P+bMmWO24qgS+8kQERFV16jryABASEgIQkJCjHfBbtmyJS+GZ0FskSEiIqquUS0yer0eb7zxBjQaDSIiIhAREQFfX1+8+eab0Ov15q6RwCBDRERUk0a1yEyZMgWff/453nnnHSQkJAAAtmzZgunTp6O0tBRvvfWWWYukymvJHDkC6HSASqVsPURERNZAEkKIhr4oLCwMCxYsMN712uCnn37C888/j/Pnz5utwKbSarXQaDTIz8+36RFVOh3g7Q2UlMg3kIyOVroiIiIiy6nv73ejTi3l5OQgJiam2vKYmBjk5OQ0ZpdUB5UKMPzJeXqJiIhI1qgg07lzZ3z88cfVln/88cfo1KlTk4uimrGfDBERkalG9ZF59913MXjwYKxbt854DZnt27fj7NmzWLVqlVkLpEq85xIREZGpRrXI9O3bF8eOHcMDDzyAvLw85OXl4cEHH8ShQ4fw9ddfm7tGuo7XkiEiIjLVqM6+tdm/fz9uu+026HQ6c+2yyeylsy8AHD8OtGsHuLkBhYUcuURERPbLop19SRmRkYBaDZSWArw3JxEREYOMTXF2Btq3l5+znwwRERGDjM0xdPhlPxkiIqIGjlp68MEHb7o+Ly+vKbVQPXAINhERUaUGBRmNRlPn+pEjRzapILo5BhkiIqJKDQoyaWlplqqD6skQZDIyAL0ecOLJQSIicmD8GbQxbdsCLi5AURFw5ozS1RARESmLQcbGcOQSERFRJQYZG8R+MkRERDIGGRvEIENERCRjkLFBvJYMERGRjEHGBlVtkTHfnbKIiIhsD4OMDWrbVu70W1gInDundDVERETKYZCxQa6uQHS0/Jz9ZIiIyJExyNgo9pMhIiJikLFZHLlERETEIGOzGGSIiIgYZGwWRy4RERExyNisdu0AlQrIzwcuXFC6GiIiImUwyNgotVoehg3w9BIRETkuqw8y58+fx+OPP46AgAC4u7sjPj4eu3fvVrosq8B+MkRE5OisOsjk5uYiISEBLi4uWL16NQ4fPowPPvgAfn5+SpdmFRhkiIjI0TkrXcDNzJ49G+Hh4UhLSzMui4yMVLAi62K4lgyDDBEROSqrbpFZuXIlunXrhkceeQRBQUHo0qULPv30U6XLshqGFplDhzhyiYiIHJNVB5mTJ09i/vz5iI6Oxtq1a/Hcc89h3Lhx+PLLL2t9TVlZGbRarclkr9q1A5ycgNxc4NIlpashIiJqflYdZPR6PW677Ta8/fbb6NKlC8aMGYOnn34aCxYsqPU1s2bNgkajMU7h4eHNWHHzcncH2rSRn/P0EhEROSKrDjKhoaHoYDh/cl1sbCzOnDlT62teffVV5OfnG6ezZ89aukxFsZ8MERE5MqsOMgkJCTh69KjJsmPHjiEiIqLW16jVavj4+JhM9qxqPxkiIiJHY9VB5sUXX8Qff/yBt99+GydOnMDSpUuxaNEipKamKl2a1eAQbCIicmRWHWS6d++O5cuX49tvv0XHjh3x5ptvYu7cuUhOTla6NKvBIENERI5MEsK+B+5qtVpoNBrk5+fb5Wmm4mLAy0sefn35MhAYqHRFRERETVff32+rbpGhunl4AIZrBLKfDBERORoGGTvA00tEROSoGGTsAIMMERE5KgYZO8AgQ0REjopBxg4YLorHPjJERORoGGTsQEyM/Hj5MpCdrWwtREREzYlBxg54eQGGix1nZChbCxERUXNikLET7CdDRESOiEHGTrCfDBEROSIGGTvBFhkiInJEDDJ2gkGGiIgcEYOMnYiNlR8vXgRyc5WthYiIqLkwyNgJHx8gPFx+zlYZIiJyFAwydoSnl4iIyNEwyNgRBhkiInI0DDJ2hEGGiIgcDYOMHeG1ZIiIyNEwyNgRw8il8+eB/HxlayEiImoODDJ2xNcXCAuTn/OeS0RE5AgYZOwM+8kQEZEjYZCxM+wnQ0REjoRBxs6wRYaIiBwJg4ydYZAhIiJHwiBjZwxB5swZoKBA2VqIiIgsjUHGzvj7AyEh8nOOXCIiInvHIGOHeHqJiIgcBYOMHWKQISIiR8EgY4cYZIiIyFEwyNghQ5DhtWSIiMjeMcjYIcNF8U6fBoqKFC2FiIjIohhk7FCLFkBgoPz8yBFlayEiIrIkBhk7xX4yRETkCBhk7BSDDBEROQIGGTvFm0cSEZEjYJCxU2yRISIiR8AgY6cMQebkSaCkRNlaiIiILIVBxk4FBcn3XRICOHpU6WqIiIgsg0HGTkkS+8kQEZH9Y5CxY+wnQ0RE9o5Bxo4xyBARkb1jkLFjDDJERGTvGGTsmKGPzIkTQGmpsrUQERFZAoOMHQsJAXx9Ab0eOHZM6WqIiIjMj0HGjkkSTy8REZF9Y5CxcwwyRERkzxhk7ByvJUNERPaMQcbOsUWGiIjsmU0FmXfeeQeSJGHChAlKl2IzDEHm+HGgvFzZWoiIiMzNZoLMrl27sHDhQnTq1EnpUmzKLbcAPj6ATieHGSIiIntiE0GmsLAQycnJ+PTTT+Hn56d0OTal6sgl9pMhIiJ7YxNBJjU1FYMHD8aAAQOULsUmsZ8MERHZK2elC6jLd999hz179mDXrl312r6srAxlZWXGea1Wa6nSbAaDDBER2SurbpE5e/Ysxo8fjyVLlsDNza1er5k1axY0Go1xCg8Pt3CV1o9BhoiI7JUkhBBKF1GbFStW4IEHHoBKpTIu0+l0kCQJTk5OKCsrM1kH1NwiEx4ejvz8fPj4+DRb7dYkMxNo3RpwcQGKiuRHIiIia6bVaqHRaOr8/bbqU0v9+/fHwYMHTZaNHj0aMTExmDRpUrUQAwBqtRpqtbq5SrQJrVoBXl5AYaF8A8nYWKUrIiIiMg+rDjLe3t7o2LGjyTJPT08EBARUW061kyQ5vOzaJZ9eYpAhIiJ7YdV9ZMh82E+GiIjskVW3yNRk48aNSpdgk3gtGSIiskdskXEQhptHskWGiIjsCYOMgzC0yBw9ClRUKFsLERGRuTDIOIiICMDdXb5x5MmTSldDRERkHgwyDsLJqXK0EvvJEBGRvWCQcSDsJ0NERPaGQcaBcAg2ERHZGwYZB8IgQ0RE9oZBxoEYgsyRI4BOp2wtRERE5sAg40AiIwE3N6C0FDh1SulqiIiImo5BxoGoVEBMjPycp5eIiMgeMMg4GPaTISIie8Ig42AYZIiIyJ4wyDgYw7VkeFE8IiKyBwwyDsbQIpORAej1ytZCRETUVAwyDqZNG8DVFSgpATIzla6GiIioaRhkHIyzM9C+vfyc/WSIiMjWMcg4IPaTISIie8Eg44A4comIiOwFg4wDYpAhIiJ7wSDjgKoGGSGUrYWIiKgpGGQcUNu2gIsLUFQEnDmjdDVERESNxyDjgFxcgHbt5Oc8vURERLaMQcZBsZ8MERHZAwYZB8UgQ0RE9oBBxkEZggyvJUNERLaMQcZBGS6Kx5FLRERkyxhkHFR0NKBSAQUFwPnzSldDRETUOAwyDsrVVQ4zAPvJEBGR7WKQcWDsJ0NERLaOQcaBVe0nQ0REZIsYZBwYh2ATEZGtY5BxYLznEhER2ToGGQfWrh3g5ATk5QEXLypdDRERUcMxyDgwNzf5BpIATy8REZFtYpBprIoKpSswC8Pppd27la2DiIioMRhkGuvDD4GICGDECOCzz4Djx22yo0l8vPz46qvAXXcBK1YAOp2iJREREdWbJIQN/vo2gFarhUajQX5+Pnx8fMy346Qk4OefTZeFhgJ9+1ZOMTGAJJnvmBZw6RLwwgvAsmWVASYyEhg7FnjiCcDXV9HyiIjIQdX395tBprGKioBt24BNm+Rp506gvNx0m6AgoE8feerbF+jYUe5da4XOnAH+9S/g00+BnBx5macnMGqUHHTat1e0PCIicjAMMtdZLMjcqKQE2LGjMths3w6Ulppu4+8P9O5d2WLTubN8wyMrUlwMLFkC/POfplf8HTgQGD8euOceq81iRERkRxhkrmu2IHOjsjJg167KYLNtm9yKU5WPD3DHHZXB5rbbABeX5qvxJoQAfvtNDjQ//1zZ/ad9e7mFJiUF8PJStkYiIrJfDDLXKRZkbnTtGrBnT2Ww2bIF0GpNt/H0BBISKoNN9+7y3R0V9tdfwMcfA198UVmyRgM8+aTclyYyUtn6iIjI/jDIXGc1QeZGOh2wb19lsPn9dyA313Qbd3egZ0851PTpA/zf/8kXf1FIQQHw5ZfARx/Jg7QAuS/z/ffLp5369bP6vs1ERGQjGGSus9ogcyO9Hjh4UA41mzfLj9nZptu4ugI9elS22PTsKbfiKFDqmjXyaadff61c3qkTMG4c8Le/yRmMiIiosRhkrrOZIHMjIYCMjMoWm02bgKws022cneXTT4Zg06uX3O+mGWVkAPPmyS01xcXysoAAYMwY4PnngZYtm7UcIiKyEwwy19lskLmREPL5nKrB5tw5022cnOQOw4Zg07t3s10IJjcX+PxzuS9NZqa8TKUCHnpIPu3UsydPOxERUf0xyFxnN0HmRkIAp0+bBptTp0y3kSR5iHfVYNOihUXL0umAlSvl006bNlUu79ZNDjSPPmoV/ZeJiMjKMchcZ7dBpiZnz5oGG0OP3Kri4kyvPhwcbLFy9u2TTzstWSKPRgeAkBDg2WflyYKHJiIiG2cXQWbWrFlYtmwZjhw5And3d/Tq1QuzZ89G+wZcZtahgsyNLl6s7Di8aVPNt7hu314ONP37y1NAgNnLuHIFWLRIvnLwhQvyMldXYNgwuXNw165mPyQREdk4uwgyAwcOxLBhw9C9e3dUVFTgH//4B/78808cPnwYnvUcrePQQeZGV66YBpuDB01vdClJch+bu++Wp4QEQK022+GvXQP+8x/5tNMff1QuT0iQTzs98IDcf5mIiMgugsyNrly5gqCgIGzatAl9+vSp12sYZG4iJ0e+MN+GDUB6uuk9CQB5DHWfPpXBJj7ebD12d+6Ur0fz/fdywAGA8HAgNRV46imLNAwREZENscsgc+LECURHR+PgwYPo2LFjvV7DINMAFy4A69bJoWbduurDvYODgQEDKoNNWFiTD3nxIjB/PrBggdxgBMj56fHH5dNO9fyYiYjIzthdkNHr9bj//vuRl5eHLVu21LpdWVkZygw9SyH/IcLDwxlkGkoI4M8/5VCTni6fiiopMd2mQ4fKUNO3b5NuvlRaCvz73/Jpp717K5ffdZd82mnwYKu7vyYREVmQ3QWZ5557DqtXr8aWLVvQ8iZXWZs+fTpmzJhRbTmDTBOVlck3vjQEm//9z7R/jYuLfEE+Q7Dp2rVRyUMI+WzXP/8JLF8uX0UYANq0kW9WOXq0fJ8nIiKyb3YVZMaOHYuffvoJmzdvRmQddyhki0wzuXpVvj22IdicPm263s9Pbk4xBJs2bRp8iDNngE8+AT79tPI2VF5ewKhRcqhp167J74KIiKyUXQQZIQReeOEFLF++HBs3bkR0dHSD98E+Ms1ACPkW2YZQ89tvQH6+6TZt2lSGmrvukoNOPRUVydei+ec/TUeQDxokn3a6+25eNZiIyN7YRZB5/vnnsXTpUvz0008m147RaDRwr+ddCRlkFFBRAezeXRlstm+Xlxk4OcmX+jUEm54963W5XyGA9evl0U4//1x5ZismRu4YPHKkIvfQJCIiC7CLICPV8s/stLQ0jBo1ql77YJCxAgUFcmdhQ7DJyDBd7+kpdxY2BJsOHepsYjlxQr6v0xdfyLsH5L4z8fHy0G3D5O9f+7wZL5FDRERmZhdBxhwYZKzQuXOmw7wvXzZdHxZWOcx7wAD5vga10GqBxYvlWyGcONGwMjw9qwedusKPr68ZR0/pdPIpuNzcyiknB8jLkzsDhYbKU0iIfGCeP2seQsjpOCtLvj6A4TIELVpUTgEBgJubsnUS2TkGmesYZKycXi9fYdjQWrN5szwWu6r4+MrWmj59AA+PGnezYwdw/rzcD9kw5eRUn8/JkTNEY0iSnCmMQcdf4BZvLVp65iLULRdBzjkIUOXCH7nQ6HPhVZ4Dj7JcOBfmQjIEFUNoyc83Hfl1M25ucqAxBJuqIcfwPDQUCAzk5ZFro9PJoblqQKntsbi47v15eZmGm7qmgAB+NkQNwCBzHYOMjSktBbZurQw2e/aYrnd1le9pcM89crDp0kXuc9MAer3ckmMMN1cF8i8UoehcLkov5ODa5VzosnMhcnOhysuBS2Eu1MW58LyWC3/kwA+5JpMK+ia95XJXT5R7+kHn4w/h5wcnPw2cSwrgfOUiVFeyoNLm1XtfwskJCAyECKkMOVJoKKSwGgJQDYHQJhUV1R1MLl6Ur7iob8Bn5e0t/62Cg+XvWHZ25dTYJOzn17Dw4+vb4O83kb1gkLmOQcbGZWfLPXwNwebMGdP1AQHyzS4No6HU6uqnauozX7UzciNcc3ZDoas/Cpz9kAc/5Ag/XK7wR1a5H7J1cuTJgb9JBMqBP/Lgi2u4eUdnN5QgBFkIQRZCcdE4VZ0PQRaCcalBoSofPrgkhSLLKRSXnUJw2SkUl5xCcUUVgivOobisCkW2Syi0Kj84qSRIkvybWtNU2zoXF/kjcXOTH+vz3M0NULvo4VOeDU3xRXgVZsGr4CI8tFlwy7sIdW4WXK9ehEt2FlSXL0IqKqz/B+XkBAQFmbZm1fQYElJ7z3FDEr5yxTTc3GzKyal/jTfWGxBw87ATGGg67+XF05BkFxhkrmOQsSNCAMePV4aaDRvkHxRzcXGRO8T4+VVOVedvtq6W/hJCyGcpbjzFVdtpL8Pza9fk30vDJET1+Rs5QYdAXKkx5Nz43AMl1XdQizK4IgshxghV2/NLCIYONz91YghlVWup6TEYl+CM+rd6FMFDruF6EMt2CUWOawjy3EKR5xaCfM9QFHmFoMQrEC5uqtoDVC0By9m5MhtIUsMnJ32F3LJXkA1Xrenkos2Ga7786JJfOTkXNe67rXdxhc6vBXS+LeRHvxao8GsBvV8LCL/K76zkLz+qAnzhFOAHlZc7nF0kODvL/cCYhUhpDDLXMcjYsYoK+e6ThmBjuKV2bWGjrnkPD5v5v7cQleHmxpBzswCk1wN6nYDI18Lp0kU4Xc6SHy9dP411+SJUVy7C+cpFOGdnwTm//i0JQpJwzacFSv1DUeYXilLfEKCsDK65WXDLuQi3/CyoS/Lr3tF1ekjIcw5EtnMILqlCcUm6Hpr0ITinC8XZCvkxCyEohHdj/oxWzQXlCMBVtEB2tSkQV2pc5o7SundcizK4GlsL8+CLPPghT/JDvpMftCr5sdDZFwXOfihw9kOhizwVufiizNUbKmc5BBmC0I3Pa1rWkPVVn7u5Vf6n6+9fOWk0vJWJPWGQuY5BxoFUVPCfkuZWVib3MTH0M6na56TqfFZW/fuNuLnVfWrH0HHZxeWmu9Lp5BLLyuTuVfV93tD1FRWVrWCGEGmNk5u+GH66bPjpsuGvN50C9Ffgq8+Bj8iDRp8LXyHHFl/kNaj1qyYVUCEPviZBKLdab7Kal2vhAz3Mkz4kSQ4zVcPNjWGnpmU3aVQlBTHIXMcgQ9QM9Hq5L8iNgUetrh5QfHwYNq2EEHILnS6vALqredBfzTVOyM2FyMkF8vIg5eXKU34unPJzodLmQaXNhaogF07XyptWgyShTO2DEjc/eVL7oVjti2JXPxS5Vrb8FLr4oUAltwjl6DS4XOSJLK0HLuR74mKOGoVFTftOubs3LgDx62w5DDLXMcgQEVmIEEBJSWXn+bw80870tS0zLK/PMPf6cHKC8PCAcPNAhdoDFa6eKHf2QKmzJ0okDxTBE0V6D2h1nsiv8EBeuQdySj1xtcQD2SWeKBTyNsWo/mh4XlurkUplGnDqG4D8/OpscHR49f395kUNiIiocSRJ7lvm4QHcckvDX19WZhp0bhZ6qs5rtXIIKr/eGqTXQyoshFRYCFcArgDMfXGBa06uKHHyRAk8UCg8Uaj3QIHwRLHOA8XZHijKrh6E8uGBCzcEoqqPkloNV5UOrk4VxslFqoCLkw4uUuW84dFZkrd1RgVcnCrggsrlzpI8b3xEBVSSDi6ogAoVxkdnVMBZyOucxfVlogIqIa9zEjqoIM9XnZyEDip9BZwM8/oKqPQVkK4vz31lFlq/OtzMf/X6YZAhIiJlqNXydXqCgxv3+mvX5BahoiI52Nz4WNOyhmxTXGzsHOWiL4eLvhw+yEUjq62uzFw7Ut6BQ1q0VujYDDJERGSbXFzkyVLdBoSQe3ubKxhdfxRFRRBFxXKLlMoZwtkZQnXD5KQyPtc7GZY5Q++kuv7oDL3KGXqpyqOT6vqjM3TXt9FJ19dJKugk52qTXpLbaXSSMyokZ+gMz+EMXWUbTvVJVK67Jpxx9yOtLfMZ1AODDBERUU0kSe4F7O5u3t1en8g8eO1rIiIislkMMkRERGSzGGSIiIjIZjHIEBERkc1ikCEiIiKbxSBDRERENotBhoiIiGwWgwwRERHZLAYZIiIislkMMkRERGSzGGSIiIjIZjHIEBERkc1ikCEiIiKbxSBDRERENstZ6QIsTQgBANBqtQpXQkRERPVl+N02/I7Xxu6DTEFBAQAgPDxc4UqIiIiooQoKCqDRaGpdL4m6oo6N0+v1uHDhAry9vSFJktLlWCWtVovw8HCcPXsWPj4+Spfj8Ph5WBd+HtaFn4d1seTnIYRAQUEBwsLC4ORUe08Yu2+RcXJyQsuWLZUuwyb4+PjwfwxWhJ+HdeHnYV34eVgXS30eN2uJMWBnXyIiIrJZDDJERERksxhkCGq1Gq+//jrUarXSpRD4eVgbfh7WhZ+HdbGGz8PuO/sSERGR/WKLDBEREdksBhkiIiKyWQwyREREZLMYZIiIiMhmMcg4qFmzZqF79+7w9vZGUFAQhg4diqNHjypdFl33zjvvQJIkTJgwQelSHNr58+fx+OOPIyAgAO7u7oiPj8fu3buVLssh6XQ6TJ06FZGRkXB3d0dUVBTefPPNOu/DQ+axefNmJCUlISwsDJIkYcWKFSbrhRCYNm0aQkND4e7ujgEDBuD48ePNUhuDjIPatGkTUlNT8ccffyA9PR3Xrl3DPffcg6KiIqVLc3i7du3CwoUL0alTJ6VLcWi5ublISEiAi4sLVq9ejcOHD+ODDz6An5+f0qU5pNmzZ2P+/Pn4+OOPkZGRgdmzZ+Pdd9/FvHnzlC7NIRQVFaFz58745JNPalz/7rvv4qOPPsKCBQuwY8cOeHp64t5770VpaanFa+PwawIAXLlyBUFBQdi0aRP69OmjdDkOq7CwELfddhv+9a9/YebMmbj11lsxd+5cpctySJMnT8bWrVvx+++/K10KAbjvvvsQHByMzz//3LjsoYcegru7O7755hsFK3M8kiRh+fLlGDp0KAC5NSYsLAwvv/wyJk6cCADIz89HcHAwFi9ejGHDhlm0HrbIEAD5SwcA/v7+Clfi2FJTUzF48GAMGDBA6VIc3sqVK9GtWzc88sgjCAoKQpcuXfDpp58qXZbD6tWrF9avX49jx44BAPbv348tW7YgMTFR4cro1KlTyMrKMvn/lkajQY8ePbB9+3aLH9/ubxpJddPr9ZgwYQISEhLQsWNHpctxWN999x327NmDXbt2KV0KATh58iTmz5+Pl156Cf/4xz+wa9cujBs3Dq6urkhJSVG6PIczefJkaLVaxMTEQKVSQafT4a233kJycrLSpTm8rKwsAEBwcLDJ8uDgYOM6S2KQIaSmpuLPP//Eli1blC7FYZ09exbjx49Heno63NzclC6HIAf8bt264e233wYAdOnSBX/++ScWLFjAIKOA77//HkuWLMHSpUsRFxeHffv2YcKECQgLC+Pn4eB4asnBjR07Fj///DM2bNiAli1bKl2Ow/rf//6Hy5cv47bbboOzszOcnZ2xadMmfPTRR3B2doZOp1O6RIcTGhqKDh06mCyLjY3FmTNnFKrIsf3973/H5MmTMWzYMMTHx2PEiBF48cUXMWvWLKVLc3ghISEAgEuXLpksv3TpknGdJTHIOCghBMaOHYvly5fjt99+Q2RkpNIlObT+/fvj4MGD2Ldvn3Hq1q0bkpOTsW/fPqhUKqVLdDgJCQnVLklw7NgxREREKFSRYysuLoaTk+lPlkqlgl6vV6giMoiMjERISAjWr19vXKbVarFjxw707NnT4sfnqSUHlZqaiqVLl+Knn36Ct7e38TymRqOBu7u7wtU5Hm9v72r9kzw9PREQEMB+Swp58cUX0atXL7z99tt49NFHsXPnTixatAiLFi1SujSHlJSUhLfeegutWrVCXFwc9u7diw8//BBPPPGE0qU5hMLCQpw4ccI4f+rUKezbtw/+/v5o1aoVJkyYgJkzZyI6OhqRkZGYOnUqwsLCjCObLEqQQwJQ45SWlqZ0aXRd3759xfjx45Uuw6H997//FR07dhRqtVrExMSIRYsWKV2Sw9JqtWL8+PGiVatWws3NTbRp00ZMmTJFlJWVKV2aQ9iwYUONvxkpKSlCCCH0er2YOnWqCA4OFmq1WvTv318cPXq0WWrjdWSIiIjIZrGPDBEREdksBhkiIiKyWQwyREREZLMYZIiIiMhmMcgQERGRzWKQISIiIpvFIENEREQ2i0GGiOyeJElYsWKF0mUQkQUwyBCRRY0aNQqSJFWbBg4cqHRpRGQHeK8lIrK4gQMHIi0tzWSZWq1WqBoisidskSEii1Or1QgJCTGZ/Pz8AMinfebPn4/ExES4u7ujTZs2+PHHH01ef/DgQdx1111wd3dHQEAAxowZg8LCQpNtvvjiC8TFxUGtViM0NBRjx441WZ+dnY0HHngAHh4eiI6OxsqVK43rcnNzkZycjMDAQLi7uyM6Orpa8CIi68QgQ0SKmzp1Kh566CHs378fycnJGDZsGDIyMgAARUVFuPfee+Hn54ddu3bhhx9+wLp160yCyvz585GamooxY8bg4MGDWLlyJdq2bWtyjBkzZuDRRx/FgQMHMGjQICQnJyMnJ8d4/MOHD2P16tXIyMjA/Pnz0aJFi+b7AxBR4zXLrSmJyGGlpKQIlUolPD09Taa33npLCCHfif3ZZ581eU2PHj3Ec889J4QQYtGiRcLPz08UFhYa1//yyy/CyclJZGVlCSGECAsLE1OmTKm1BgDitddeM84XFhYKAGL16tVCCCGSkpLE6NGjzfOGiahZsY8MEVncnXfeifnz55ss8/f3Nz7v2bOnybqePXti3759AICMjAx07twZnp6exvUJCQnQ6/U4evQoJEnChQsX0L9//5vW0KlTJ+NzT09P+Pj44PLlywCA5557Dg899BD27NmDe+65B0OHDkWvXr0a9V6JqHkxyBCRxXl6elY71WMu7u7u9drOxcXFZF6SJOj1egBAYmIiMjMzsWrVKqSnp6N///5ITU3F+++/b/Z6ici82EeGiBT3xx9/VJuPjY0FAMTGxmL//v0oKioyrt+6dSucnJzQvn17eHt7o3Xr1li/fn2TaggMDERKSgq++eYbzJ07F4sWLWrS/oioebBFhogsrqysDFlZWSbLnJ2djR1qf/jhB3Tr1g133HEHlixZgp07d+Lzzz8HACQnJ+P1119HSkoKpk+fjitXruCFF17AiBEjEBwcDACYPn06nn32WQQFBSExMREFBQXYunUrXnjhhXrVN23aNHTt2hVxcXEoKyvDzz//bAxSRGTdGGSIyOLWrFmD0NBQk2Xt27fHkSNHAMgjir777js8//zzCA0NxbfffosOHToAADw8PLB27VqMHz8e3bt3h4eHBx566CF8+OGHxn2lpKSgtLQUc+bMwcSJE9GiRQs8/PDD9a7P1dUVr776Kk6fPg13d3f07t0b3333nRneORFZmiSEEEoXQUSOS5IkLF++HEOHDlW6FCKyQewjQ0RERDaLQYaIiIhsFvvIEJGieHabiJqCLTJERERksxhkiIiIyGYxyBAREZHNYpAhIiIim8UgQ0RERDaLQYaIiIhsFoMMERER2SwGGSIiIrJZDDJERERks/4fkKYrVyBI0IYAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}