Credit_Risk_1_Risk_Components_and_Arithmetic.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/github/olesyamba/Risk_analysis/blob/main/Credit_risk_1_Risk_Components_and_Arithmetic_ipynb%22.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cSMqbzuXlr_o"
      },
      "source": [
        "# 1 Компоненты кредитного риска"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1.1 Определения и обозначения\n",
        "\n",
        "**Кредитный риск** - событийный вид риска.\n",
        "\n",
        "Событие-триггер -- **дефолт**, под которым типично понимается отказ и неспособность исполнять свои финансовые обязательства по договору.\n",
        "\n",
        "Событие дефолта приводит к возникновению **кредитных потерь**."
      ],
      "metadata": {
        "id": "3iVFd3MI4xTt"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZTC6CuRzBbTH"
      },
      "source": [
        "###_\n",
        "**У кредитного риска отдельного кредита есть следующие атрибуты**:\n",
        "\n",
        "* $t$ - текущий момент времени; момент оценки риска.\n",
        "\n",
        "* $h >0$  - горизонт риска; будущий период, в течение которого кредитор подвержен риску дефолта; чаще всего ограничен сроком кредитного договора, но бывают и нюансы (например, бесрочная кредитная линия)\n",
        "\n",
        "* $\\tau$ - момент дефолта, случайное событие в пределах горизонта риска.\n",
        "\n",
        "* $PD_t (h) = P (\\tau < t + h)$ (probability of default) - вероятность дефолта заемщика в течение  горизонта риска; может задаваться по-разному и является атрибутом модели; неубывающая функция распределения времени до дефолта.\n",
        "\n",
        "* $SF_t(h) = 1 - PD_t(h)$ (survival function) - функция \"дожития\"; вероятность НЕ допустить дефолт на горизонте $h$.\n",
        "\n",
        "* $EAD(\\tau)$ (exposure-at-default) - экспозиция при дефолте; предельный уровень потерь, с которым вероятно предстоит столкнуться в случае объявления дефолта заемщиком в момент времени $\\tau$; обычно определяется как размер законного требования к заемщику (условия контракта, нормы закона). Может быть как детерминированным, так и случайным.\n",
        "\n",
        "* $LGD(\\tau) \\in [0, 1]$ (loss-given-default) - фактическая доля понесенных потерь относительно экспозиции; определяется с учетом обеспечения или очередности прав требований по обязательствам. Типично случайна,\n",
        "и в момент $\\tau$ часто используется оценка, т.к. фактическое значение может быть устрановленно существенно позже. Для целей ценообразования также используют $RR(\\tau) = 1 - LGD(\\tau)$ (recovery rate) - доля возмещения.\n",
        "\n",
        "**Механизм развития дефолта по кредиту**:\n",
        "\n",
        "1. Произошел ли дефолт на горизонте $h$? Если нет, то кредитные потери равны 0.\n",
        "2. Если да, тогда в какой момент $\\tau$ произошел дефолт?\n",
        "3. Какая уровень экспозиции к риску дефолта $EAD$ был в момент $\\tau$?\n",
        "4. Какой уровень фактических потерь $LGD$ понесен в результате дефолта\n",
        "\n",
        "**Функцию (случайную) кредитных потерь по одному кредиту можно записать в следующем виде**:\n",
        "\n",
        "$$L(\\tau) = I(\\tau< t+h) \\cdot EAD(\\tau) \\cdot LGD(\\tau), \\;  [1]$$\n",
        "\n",
        "где $I(\\tau< t+h)$ - индикатор дефолта на горизонте $h$ и имеет распределение Бернулли $B_{PD_t(h)}$.\n",
        "\n",
        "**Функцию (случайную) кредитных потерь по портфелю, состоящему из** $N$ **кредитов, можно записать в следующем виде:**\n",
        "\n",
        "$$L^P(\\tau) = \\sum_{n = 1,\\ldots, N} [I(\\tau_n< t+h) \\cdot EAD_n(\\tau) \\cdot LGD_n(\\tau)], \\; [2]$$\n",
        "\n",
        "*Замечание: строго говоря, еще требуется дисконтирование, но для простоты проигнорируем*\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Раздел включает:\n",
        "\n",
        "* Моделирование и оценку $PD$\n",
        "* Случаи детерминированных $EAD$ (например, обыкновенные кредиты или облигации) + ее определение в момент дефолта\n",
        "* $LGD$ = экзогенно заданная детерминированная или случайная величина\n",
        "* Влияние корреляции дефолтов $\\rho$ на портфельный кредитный риск (распределение убытков и $VaR$)."
      ],
      "metadata": {
        "id": "Yz5llp6T6mM9"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xkg6jfbPRa9_"
      },
      "source": [
        "## 1.2 Арифметика PD\n",
        "\n",
        "* Дискретная модель\n",
        "  - дефолты наблюдаются только в определенные моменты времени в течение горизонта риска (напримере, только в моменты очередных платежей по кредиту);\n",
        "  - $PD_t(h) =\\sum_{t_i < h} P_t(\\tau = t_i) =  \\sum_{t_i < h} P_t(\\tau = t_i|\\tau > t_{i-1}) [1 - P_t(\\tau  \\leq t_ {i-1})] = \\sum_{t_i < h} P_t(\\tau = t_i|\\tau > t_{i-1}) SF_t(t_{i-1} - t)$\n",
        "  \n",
        "   т.е. сумма вероятностей столкнуться с дефолтом в очередную дату; по формуле полной вероятности;\n",
        "  - может задаваться:\n",
        "    - как точками распределения $PD_t(t_i -t)$,\n",
        "    - так и плотностью (маржинальными вероятностями) $P(\\tau = t_i)$,\n",
        "    - так и условной плотностью (форвардными вероятностями) $P(\\tau = t_i| \\tau >t_{i-1})$.  \n",
        "\n",
        "* Непрерывная модель\n",
        "  - дефолты могут возникать в любой момент времени\n",
        "  - центральный объект - интенсивность дефолта $\\lambda_t(x)$, а $PD_t(h) = 1 - e^{-\\int_{0}^h \\lambda_t(x)dx}$\n",
        "  - $\\lambda_t(x)$ (hazard function) - условная плотность дефолта в момент $x$ при условии, что до $x$ дефолт не произошел, т.е. $P_t(\\tau \\in (t+x, t+x +dx) | \\tau > t+x) \\approx \\lambda_t(x) dx $.\n",
        "  - $\\lambda_t(x)$  - можно грубо интерпретировать как количество дефолтов на единицу времени в последовательности кредитов.\n",
        "\n",
        "* Гибрид - интерполированная дискретная модель\n",
        "  - косочно-постоянная функция $\\lambda (h)$: $P(\\tau = t_i| \\tau >t_{i-1}) = 1 - e^{-\\sum_{i} \\lambda_i (t_i - t_{i-1})}$\n",
        "  - другая функция, например, сплайновая фунцкия.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l7BDJD2I0uHw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "70b40bd1-f533-4d35-dc63-444d0d1bb338"
      },
      "source": [
        "# Место для кода\n",
        "\n",
        "# Дискретной модели\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Исходные данные\n",
        "\n",
        "dates = np.arange('2011-01-01', '2014-07-01', dtype = 'datetime64[6M]').astype('datetime64[D]') # первая дата - текущий момент или момент выдачи кредита\n",
        "pd_cm = np.array([0, .03, .06, .09, .12, .15, .18])\n",
        "data = pd.DataFrame({'PD cumulative':pd_cm}, index = dates)\n",
        "display(data)\n",
        "\n",
        "plt.step(dates, 100*pd_cm, '-*', where = 'post',  label = 'Функция распределения')\n",
        "plt.xticks(rotation = 70)\n",
        "plt.legend(), plt.grid(), plt.show()\n",
        "\n",
        "# Маржинальные вероятности\n",
        "pd_mrg = pd_cm[1:] - pd_cm[:-1]\n",
        "plt.bar(dates[1:], pd_mrg, width= 100, label = 'Маржинальные PD')\n",
        "plt.legend(), plt.show()\n",
        "\n",
        "# Форвардные вероятности\n",
        "sv_cm = 1 - pd_cm\n",
        "pd_fwd = pd_mrg/sv_cm[:-1]\n",
        "plt.bar(dates[1:], (pd_cm[1:] - pd_cm[:-1])/(1 - pd_cm[:-1]), width= 100,  label = 'Форвардные PD')\n",
        "plt.legend(), plt.show()"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "            PD cumulative\n",
              "2011-01-01           0.00\n",
              "2011-07-01           0.03\n",
              "2012-01-01           0.06\n",
              "2012-07-01           0.09\n",
              "2013-01-01           0.12\n",
              "2013-07-01           0.15\n",
              "2014-01-01           0.18"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-443c0d1e-bb37-4ae1-af53-d8fedbf3a9a7\" 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>PD cumulative</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2011-01-01</th>\n",
              "      <td>0.00</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2011-07-01</th>\n",
              "      <td>0.03</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2012-01-01</th>\n",
              "      <td>0.06</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2012-07-01</th>\n",
              "      <td>0.09</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2013-01-01</th>\n",
              "      <td>0.12</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2013-07-01</th>\n",
              "      <td>0.15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2014-01-01</th>\n",
              "      <td>0.18</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-443c0d1e-bb37-4ae1-af53-d8fedbf3a9a7')\"\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-443c0d1e-bb37-4ae1-af53-d8fedbf3a9a7 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-443c0d1e-bb37-4ae1-af53-d8fedbf3a9a7');\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-96d1c77c-35ac-4e3b-8ace-0a71e42b8033\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-96d1c77c-35ac-4e3b-8ace-0a71e42b8033')\"\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-96d1c77c-35ac-4e3b-8ace-0a71e42b8033 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<matplotlib.legend.Legend at 0x79ce70c8a590>, None)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cB3Xj9M8EOUs",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9b2ca443-3cb6-41a6-da84-b9e0a5d2e2dd"
      },
      "source": [
        "# Непрерывная модель\n",
        "import numpy as np\n",
        "import scipy.integrate as integrate\n",
        "\n",
        "# hzr_fun = np.vectorize( lambda x: 0.05 + 0.02*np.sin(x*0.5*np.pi))\n",
        "hzr_fun = np.vectorize( lambda x: 0.1 + 0.05*np.exp(-2*x)) # x - выражен в годах\n",
        "\n",
        "pd_fun = np.vectorize(lambda x: 1 - np.exp(- integrate.quad(hzr_fun, 0, x)[0]))\n",
        "sv_fun = np.vectorize(lambda x: 1 - pd_fun(x))\n",
        "\n",
        "terms = np.arange(0, 5, 1/12) # рассмотрим горизонт 5 лет,месячные интервалы\n",
        "\n",
        "plt.plot(terms, hzr_fun(terms), label = 'Интенсивность дефолтов')\n",
        "plt.legend(), plt.grid()\n",
        "plt.show()\n",
        "\n",
        "plt.plot(terms, pd_fun(terms), 'r' , label = 'Функция распределения времени до дефолта')\n",
        "plt.legend(), plt.grid()\n",
        "plt.show()\n",
        "\n",
        "plt.plot(terms[1:], pd_fun(terms[1:]) - pd_fun(terms[:-1]), label = 'Маржинальные PD')\n",
        "plt.plot(terms[1:], (pd_fun(terms[1:]) - pd_fun(terms[:-1]))/sv_fun(terms[1:]), label = 'Форвардные PD')\n",
        "plt.legend(), plt.grid()"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfw0lEQVR4nO3deVxU9f7H8dcMsoq4hIJb7mVmSLkQpWWJqHW72mJuuWBZN6P0R2pZKW6Fmpl11WzTyiWte9V76xpKJJWFmlumqTe9miu4pCKgbHN+f5yYHEFlCGZY3s/HYx5yzpz5ns985sB8/J7v+R6LYRgGIiIiImWY1d0BiIiIiFyNChYREREp81SwiIiISJmngkVERETKPBUsIiIiUuapYBEREZEyTwWLiIiIlHkqWERERKTMq+LuAEqCzWbj6NGjVKtWDYvF4u5wREREpAgMw+DcuXPUq1cPq/XKfSgVomA5evQoDRs2dHcYIiIiUgyHDh2iQYMGV9ymQhQs1apVA8w3HBAQUKJt5+TksGbNGiIjI/H09CzRtqUg5dt1lGvXUr5dS/l2reLmOy0tjYYNG9q/x6+kQhQs+aeBAgICSqVg8fPzIyAgQAe9CyjfrqNcu5by7VrKt2v92XwXZTiHBt2KiIhImaeCRURERMo8FSwiIiJS5lWIMSxFYRgGubm55OXlOfW6nJwcqlSpwoULF5x+rThP+XYd5dq1lG/Xulq+PTw8qFKliqbCKEcqRcGSnZ3NsWPHyMzMdPq1hmEQHBzMoUOHdGC7gPLtOsq1aynfrlWUfPv5+VG3bl28vLxcHJ0UR4UvWGw2G/v378fDw4N69erh5eXl1B8Lm81Geno6/v7+V53URv485dt1lGvXUr5d60r5NgyD7OxsTpw4wf79+2nRooU+k3Kgwhcs2dnZ2Gw2GjZsiJ+fn9Ovt9lsZGdn4+PjowPaBZRv11GuXUv5dq2r5dvX1xdPT09+/fVX+3ZStlWa3xr9gRARkYvpe6F80aclIiIiZZ4KFhERESnzVLCUI4MGDeK+++5zdxgiIg4mTJhAaGiou8OQCk4FSxm3c+dO+vTpQ4MGDVi4cCGff/451apVo0ePHiQkJLg7PBEREZcoVsEyZ84cGjdujI+PD2FhYWzcuLFIr1u6dCkWi4VevXo5rDcMg/Hjx1O3bl18fX2JiIjgl19+KU5oFcqKFSto06YNWVlZLFq0iIcffpju3bvzxRdfEBwcTGRkJHPmzAHgm2++wdPTk5SUFIc2Ro4cSadOnQD44IMPqFGjhsPzBw4cwGKxsG3bNgCSkpKwWCycOXMGgNOnTxMSEsKgQYMwDAOAzp07M3LkSId2Lv0fVmH7uuOOOxz2BfD555/Tpk0bfH19sVgseHh4MGDAgMvmJH8/b7/9tv3Kr4cffpizZ8/at/nhhx/o2rUrgYGBVK9enTvvvJMtW7Y4tHPmzBmeeOIJgoKC8PHxoXXr1nz++ef22C0WS6GPS/P0n//8h5CQEHx8fLj11lvZsWOHw37WrVtHp06d8PX1pWHDhjzzzDNkZGQ4bFPY/i793+qOHTvo0aMH/v7+BAUFMXDgQE6ePOlUOzabjbi4OJo0aYKvry8333wz//rXv+zPX/rZ57NYLKxcuRIoeLwAjBs3DovFwqxZs+zrdu/eTdeuXalevbo9lkuPh4vl79tisWC1WqlTpw6PPvooFy5ccNjv0qVLue222+yf2ddff+1Unjp37ozFYmH58uUOr7v55puxWCwkJSU51dbVfg+GDBni8Pfut99+45prrrliLi5+7aWf56X7e+utt2jWrBleXl5cf/31LFy48Krt5ufy0sfFn/uZM2d47LHHqF27NgEBAdx99938+OOP9ufz8vJ48sknqVq1KuHh4aSmpgLwzDPP4OfnR4cOHdi7d699e5vNxqRJk2jQoAHe3t6EhoYSHx9fILb8z+fiR/5xdbnfyYs/t+eee47rrrsOPz8/mjdvzssvv0xOTs5VcyJXkZkJL78MY8e6NQynC5Zly5YRExNDbGwsW7ZsoU2bNnTr1o3jx49f8XUHDhxg1KhR9i/Pi02fPp0333yTefPmsWHDBqpWrUq3bt3sf6xKnGFARoZ7Hr9/6RfFyJEj6dy5MytXrqRz5874+vri7e1Nx44dWbBgAUOGDGHMmDFkZGRwxx130LRpU4c/WDk5OSxevJihQ4cWK03p6encc889NG3alPnz5/+pya6WL1/O1q1bHdadOXOGPn360LlzZ37++WeOHTtG7969r9rW3r17+eSTT/jss8+Ij49n69atDB8+3P78uXPnGDx4MOvWrWP9+vW0aNGCe+65h3PnzgHmH88ePXrw3XffsWjRIn7++WemTp2Kh4eHvY2AgACOHTtmf1yuKB89ejSvvfYaP/zwA7Vr1+a+++6z/4Hct28f3bt358EHH2T79u0sW7aMdevWER0dXaCdi/f37LPPFsjT3Xffzc0338ymTZuIj48nNTWVhx9+2GE7wzCu2E5cXBwfffQR8+bNY+fOnYwYMYInnniiwJe+Mw4fPsysWbPw9fV1WD906FBycnL47rvvOHbsmEMxcyV79uzhyJEjLFq0iGXLlrFgwQKH50ePHs2zzz7L1q1bCQ8P57777uPUqVNA0fNUv3593nnnHfvyxo0bOXHihMM2RW3LWdOmTSM3N7fI23fv3t3+eYaHhzs8t2LFCkaMGMGzzz7Ljh07eOKJJ4iKimLt2rVFavvLL7/k2LFj/POf/yzwXO/evTl+/DhffPEFmzdv5pZbbqFLly789ttvALzzzjt8+umnrFixgldeeYV//vOf7Nixg3r16rFp0yauueYaBg8ebG/vjTfe4LXXXmPGjBls376dbt268de//rXAf0wNw2DYsGH299ygQQP7cxf/PgL885//tC/fdtttAFSrVo0PPviAn3/+mddff52PPvqoyMeeFCI3F957D5o3h5deghkz4H//c188hpM6dOhgPPXUU/blvLw8o169ekZcXNxlX5Obm2vcdtttxnvvvWcMHjzY6Nmzp/05m81mBAcHG6+++qp93ZkzZwxvb2/j448/LlJMZ8+eNQDj7NmzBZ47f/688fPPPxvnz5//Y2V6umGYpYPrH+npRXpPKSkpBmC8/vrr9nWX5m758uUGYKxfv94wDMOYNm2accMNN9if/+c//2n4+/sb6b/vc8GCBUb16tUd9rN//34DMLZu3WoYhmGsXbvWAIyUlBSjS5cuxt13321cuHDB4TV33nmnMWLECId1sbGxRps2bezLF+8rOzvbaN68uTF58mSHfW3YsMEAjCNHjthfN2jQIOOee+4x8vLyCs1LbGys4eHhYRw+fNi+7osvvjCsVqtx7NixQl+Tl5dnVKtWzfjss88MwzCM1atXG1ar1dizZ0+h2zuTp6VLl9q3OXXqlOHr62ssW7bMMAzDePTRR43HH3/coZ1vv/3WsFqtDsfjvHnzjMDAQIf3eHEuJ0+ebERGRjq0c+jQIQNweA9vv/32Zdu5cOGC4efnZ3z//fcOeRk4cKDRt29fh/d0+vRph30BxooVKwrNw6BBg4xHH33UaNSokcOx6uvrayxevNi+XFhOL3bpvn/55RejZs2a9jby9zt16lT7a3JycowGDRoY06ZNK3Ke7rzzTuPJJ5806tSpYxw4cMAwDPNzGjdunAEYa9eudaqtq/0eXPw7u2vXLqNq1arGSy+9dMVc5Ovbt6/x0EMP2Zcv3d9tt91mDBs2zOE1vXv3Nu65554rtrt7924DMHbs2GEYRsHcf/vtt0ZAQECB3/tmzZoZb7/9tmEYhnHLLbcYL774ov25F1980bjxxhvty3v27HHYR7169YyXX37Zob327dsbw4cPd1gXHh5ujBo1yr586XGV7+LP6nLy8vKMSZMmGW3btr3sNoV+P4hh2GyG8a9/GcYNN/zx3dW4sWEsXmwYl/nbnJ2dbaxcudLIzs52aldX+v6+lFMTx2VnZ7N582bGXtQtZLVaiYiIIDk5+bKvmzRpkr2L99tvv3V4bv/+/aSkpBAREWFfV716dcLCwkhOTqZv374F2svKyiIrK8u+nJaWBpg9Cpd2/+Xk5GAYBjabDZvNZq602dw2eMdms0F+HFdQpYr50WRkZNjjNgzD/l7A7AEB8PLywmazMWjQIF566SW+//57br31VhYsWEDv3r3x9fW1v/+zZ8/i7+9v34/xe49P/vP5bQ8YMIDExEQmTJiAp6fnH7m76HUXr7u4nUv/nT17NtWrV6dfv36MGzfOvp/69etTpUoVlixZwsiRIx3mRLi0/YvXX3vttdStW9f+fFhYGDabjV27dlGnTh1SU1MZN24cX3/9NcePHycvL4/MzEx+/fVXbDYbW7dupUGDBjRv3rzQfVz6Hi5dd3Ge8vcNUKNGDa6//np+/vlnbDYbP/74I9u3b2fx4sUF3te+ffu44YYbADh58iQBAQEOn/PF+9y2bRtr1651+Nzy/fLLLzRv3hyAs2fPUrVq1ULb+e9//0tmZiZdu3Z1eH12djahoaEO7+ni/9Ve/P4v3sZms7Fp0yZWrFjBrl27+PLLLx0+syZNmrB8+XL++te/4ufnV2hOC8t5gwYNMAyDzMxM+vfvT58+fS6bb6vVStu2be35LmqePD09eeSRR3j33XcZNWoUK1asIDk5mcmTJ9v3VdS25s6dy3vvveeQz1atWhX6O/vcc88xZMgQmjRpcsVc5Dt58iQNGzYs8HuWv7xr1y4ee+wxh+dvu+023nzzzSu2nd+b5O/vX+AzzX/v6enpXHPNNQ6vO3/+PHv37sVms7F3716uv/56+2vz78uTv9ysWTM8PT3573//S/369Tl69Cjh4eEFYt2+fbvDurS0NIfj5dL3fDGHv+m/W7ZsGbNnz2bfvn2kp6eTm5vr8LtVWBuGYZCTk+PQw1qZWTZswPr881i/+w4A45prsI0di+2JJ8DbG/LyzMcl8r97nT0F58z2ThUsJ0+eJC8vj6CgIIf1QUFB7N69u9DXrFu3jvfff9/hnPfF8sdcFNbmpeMx8sXFxTFx4sQC69esWVNgNtsqVaoQHBxMeno62dnZ5krDgMOHC2271OXmwu8F1pV4eHjQrl07PvzwQ4YMGULVqlXJyckhNzeXtLQ0cnNzeeutt6hXrx7XXnstaWlp+Pj40L17d9555x0CAwOJj4/ns88+sxd0Fy5coFq1ag7n6Y8dO8Zf/vIXMjIySEtLs99v6ciRI3z00UcMGzaMiIgIbrzxxoveQi7Z2dn2dsEsIvPy8hz2ZRgGBw8eZPLkySxcuNA+diN/X1WrVuW1115jwoQJvPDCC3h5eZGVlUVkZKT99M2lsrKysNlsDvvO/zkzM5O0tDQGDhzIb7/9xssvv0zDhg3x9vYmMjKStLQ00tLSsFgsBdq4WH7sFz+fXxxemqdz5845bJeXl0dWVpZ9X0OGDOGJJ54osI/atWvbX7dnzx4aNmxoX740l2fOnKF79+5MmDChQDtBQUH27Q4cOECdOnUKbSd/jMGyZcuoW7euQxteXl4O72nVqlUOX9Rt27bl/PnzpKWlOeThhRdeIDo62l4kXbhwwb7vWbNmMXz4cKpXr46vry+5ubl4e3tfNueX7vvXX39l5MiRxMXFER0dXSD/+XJzc8nJySEtLa1Ieco/dgcOHEjPnj0JCAigc+fOeHt72+Nwpq3evXs7nHp7++23+f777x3+E5Wbm8sXX3zBt99+y5YtW1i1alWB46sw+/btIywszL7dpb93hmE45BzMY/dKxzaYA/m9vLzw9/cvcCxbrVZOnjxJcHAwn332WYHXVq9enbS0NAzDsB8TUPCYzS+W8/N56c9gFnf5f8/yHTlyhJo1a9rXXXpcXezS9jZu3MjAgQN5/vnnmTJlCgEBASxfvpzZs2dfNh/Z2dmcP3+eb775xqlTdRVR1SNHaLVoEfV+73zI8/Ji33338csDD5BbtSokJhapHWcvBnHmHn+lOjX/uXPnGDhwIO+++y6BgYEl1u7YsWOJiYmxL6elpdGwYUMiIyMJCAhw2PbChQscOnQIf39/x6mXq1cv0r4Mw+DcuXNUq1bN5Tcse//99/nrX/9KeHg4Q4cO5ciRI2RmZjJnzhwWLlzI8ePHWb58OTVr1rS/5oknnmDAgAE0bdqUZs2aERkZaX8uf4rqiwcF5g/+q1q1KgEBAfaC77PPPqNp06Zs2LCBESNG8P3339t7fapUqYKXl5dDrr29vfHw8LCv8/HxwWKx8MYbb9CpUyd69OjBgQMHHPaVH++yZcsIDQ1lxIgRPP/882RlZV02397e3hw+fJj09HTq1asHQHJyMlarlZtvvpmAgAA2bNjA7NmzeeihhwA4dOgQp06dwsfHh4CAANq3b8/Ro0dJSUnhuuuuK7CP/Ngvfn/5X+CX5mnnzp32Yu706dPs27ePNm3aEBAQQNu2bdm3b99VL/dcv349/fv3t+/v0lx26NCB5cuX07p1a/tnUJjt27fTrl27Qttp37493t7enDx5kh49egAFj+3899S6desCg0J9fX0JCAiw5+Grr77if//7H1988QV+fn5YrVZ7fgG6dOlCz549+fbbb/noo49YuXIlcXFxBX4/812679DQUNatW0d8fDwvvPCCfb/5A2HB/ALfvn07Tz31FAEBAUXKU/6xe8stt3DdddcxZcoUli9fTrVq1exxONNWYGCgw+cbHBzs8Nl5enri4eFBbGwsL730EjVq1Cj0+LrU4cOHOXDgAF26dLFvd+nvXatWrdiyZYtDQbx582ZuvPHGK7b9ww8/cNttt9n/buTnvlq1agQEBBAeHs6UKVOoUaMGjRs3LrSNZs2a8euvv9r34+HhYR9DBfDf//6XnJwcWrduTYMGDahXrx7btm2zf3YAmzZton379vbX7Nu3jzNnzhAeHm5fd+lxdbH8zyrf9u3badSoEZMmTQLM4/uNN964Yq4vXLiAr68vd9xxR+Wdmv/4caxTpmB9910seXkYVivGoEHYxo+nSYMGNCliMzk5OSQkJNC1a1c8PT2LvPurFe4Xc6pgCQwMxMPDw/6/tXypqakEBwcX2H7fvn0cOHDAYe6Q/K65KlWqsGfPHvvrUlNTHf7nl5qaetk/9N7e3vb/EV3M09OzQKLy8vLsVx4UZxrm/Hjz23ClkJAQ9uzZw4IFC1i3bh27du0iJyeH9evXM3ToUKKioqhdu7bDa3r06EFAQAAvv/wykyZNcog5/+fLrbs4R4GBgVitVqZNm0ZISAjTp0/npZdesr8u/z4d+fLy8jAMg9zcXLy8vLBarWRmZvLuu++yZcsWh7Yv/nn06NH2KwE8PT2pVq0aWVlZl823xWLBx8eHqKgoZsyYQVpaGiNHjuThhx+2FzAtWrRg8eLFdOjQgbS0NEaPHm2/CslqtXLXXXdxxx130Lt3b2bOnEnz5s3ZvXs3FouF7t27O5WnKVOmULt2bYKCgnjxxRcJDAzkgQcewGq18vzzz3PrrbfyzDPP8Nhjj1G1alV+/vlnEhISmD17NufPn+e9995j37593HPPPfaB6xkZGeTm5nLmzBlq1apFdHQ07733HgMGDGDMmDHUqlWLvXv3snTpUt577z1Onz7N66+/znfffcdrr71mjy2/4LNarVSvXp1Ro0bZewM6duzI6dOn+eqrr6hduzZRUVGFfj4Xv/+L17/66qv8/e9/d+iJufgz++c//8mHH37I5s2bufbaa+09qJf7Hcpff/LkSbKzs/n111/5/PPP6dSpk8N+586dy3XXXccNN9zA66+/zunTp3n00UexWq1XzVN+l39+nNOmTWPdunV06dLFfpVZ/r6cbeviHFz8fiwWC1999RV169blqaee4vz58wXe86VOnz7N2LFjadSoES1btrQfF/m9AZmZmfj7+zN69GgefvhhbrnlFiIiIvjss89YsWIFX375ZaFt5+Xl8d133/Hxxx8zdepUe7v5VwedPHmSWrVqERkZSXh4OA888ADTp0/nuuuu4+jRo/znP//h/vvvp127dgwdOpSJEyfSuXNnqlSpwnvvvcdvv/3G9OnT6dmzJzExMbRv3542bdoA5u95bGwszZs3JzQ0lAULFrBt2zYWL16M1Wpl06ZNPPPMM9x000106NDB4T8rl/tbcOlxet1113Hw4EE++eQT2rdvz+eff26/8u9Kx53FYin0u6PCy8yE11+HadMgv0f73nuxTJ2KpXXrYg+bcDaXTuXdqdExhjnoNjo62r6cl5dn1K9fv9BBt+fPnzd++uknh0fPnj2Nu+++2/jpp5+MrKws+6DbGTNm2F939uzZ0h1064S8vDzj9OnTlx0E6kqXDrq9nHHjxhkeHh7G0aNHHdY7M5j04oGXSUlJho+Pj/HTTz8ZhmEO/gMKfdx55532fQEOx8ql+1qyZIkRFBTk9KDbNm3aGHPnzjXq1atn+Pj4GA899JDx22+/2bfZsmWL0a5dO8PHx8do0aKF8emnnxYYvHfq1CkjKirKuOaaawwfHx+jdevWxueff+50nj777DPjxhtvNLy8vIwOHToYP/74o8PrNm7caHTt2tXw9/c3qlataoSEhNgHH+bn6Gq5NAzD+O9//2vcf//9Ro0aNQxfX1+jZcuWxsiRIw2bzWbMmjXLaNu2rbFy5cpCc5Uvf9vrr7/e8PT0NGrXrm106dLFPnjRmUG3bdq0cfiMLs7vnj17jBo1ahhr1qyxP1/UQbf5j8DAQKN///7GqVOnHPa7ZMkSo0OHDoaXl5fRqlUr46uvvnJo50p5MozCB8oahmGcPn26wEDO4rRV2KBbwPjHP/5h/1vy/vvvXzEX+a+53CM2Nta+7dy5c42mTZsanp6exnXXXWd89NFHl203P4dXeuRLS0sznn76aaNevXqGp6en0bBhQ2PAgAHGwYMHDcMwBzw/9thjhq+vr3Hrrbcaw4cPN9q0aWM888wzhq+vr3HLLbcYu3fvtreXl5dnTJgwwahfv77h6elptGnTxvjiiy/sz3fs2NHo3bu3cejQIYeYnR10O3r0aOOaa64x/P39jYcffth45ZVXrpjrSjnoNjfXMN57zzDq1ftjQG3btoZxye+Ss1wx6NbpgmXp0qWGt7e38cEHHxg///yz8fjjjxs1atQwUlJSDMMwjIEDBxrPP//8ZV9f2Jfu1KlTjRo1ahj/+te/jO3btxs9e/Y0mjRpUuSDqLIULEU1dOhQ47777nP5frdu3erwJVscV8v3pV8I7nK5L3dnLFiwwBg8eHChz5VELq+mPB3blxaM5VFR8z148GBjwYIFhT73+uuvOxQszti/f7/RqFGjyz5flCuXLqes/F5erCj5rlQFi81mGKtWGUbr1o5X/ixZctkrf5xR5q4SAujTpw8nTpxg/PjxpKSk2CcAyu/yPXjwoNOnTvLnEnn88cc5c+YMHTt2JD4+vvKeUyyms2fP8tNPP7FkyRL+/e9/u3z/VqsVLy8vl++3vPL19aX6ZcZSeXp6UqtWLRdHJGVB/kDlwlStWrXYg0M9PDwKnEK+2KUXPkgFsnUrjB79x8DZmjXNeVWeesq88qe8KG41VZaoh8V05513Gr6+vsbIkSPdHUqxVaYeFncrT8d2ZephKY/Kyu/lxdTDYhjGwYOGMXCgYVgsZo+Kl5dhjBplGBedQi8pruhhsRiGE1OvllFpaWlUr16ds2fPFnqV0P79+2nSpEmxemzyLxEMCAhw+aDbykj5dh3l2rWUb9cqSr7/7PdDmXX2LEydCrNmQf6M8f37m9PrX+bKrz8rJyeHVatWcc899zh9ldDlvr8vVaqXNYuIiIiL5OTAO+/AhAmQf9+rO+4wp9Rv396toZUEFSwiIiLlmWHAv/8NY8bAf/9rrrv+epg+He67D1w8h1hpqTQFSwU48yUiIiWoQnwvbNoEo0ZB/k1Ma9eGiRPhsceggs0tU+ELlvxzaZmZmZcdeS8iIpVP/rTw5XLSuEOH4IUXYNEic9nHB/7v/+D55+EqY0HKqwpfsHh4eFCjRg37rI5+fn5OTbGfP6PrhQsXNFDOBZRv11GuXUv5dq0r5dv4/Qabx48fp0aNGuXrxofnzpkDamfO/GNA7SOPmANqr73WvbGVsgpfsAD26f/zixZnGL/f5Ct/ancpXcq36yjXrqV8u1ZR8l2jRo1CbytTJuXmwvvvw/jxkP9ddscd8Npr0K6de2NzkUpRsFgsFurWrUudOnWKdevrb775hjvuuKN8dhuWM8q36yjXrqV8u9bV8p1/Y8pyYfVqePZZ2LnTXG7RwhxQ27NnhRlQWxSVomDJ5+Hh4fQB6uHhQW5uLj4+Pvoj4wLKt+so166lfLtWhcj3zp3mgNr4eHO5Vi2IjYW//Q0q4azilapgERERKfOOHzcLk3feAZvNvNrn6afN6fRr1nR3dG6jgkVERKQsuHAB3njDHEB77py57oEHYNo0aN7cvbGVASpYRERE3Mkw4B//MCd+O3DAXNe2rXkl0B13uDW0skQFi4iIiLts2mTOn7Junblcvz688op5qbIuf3eggkVERMTVDh82J35buNBc9vMze1hGjYKqVd0bWxmlgkVERMRVMjLMmxFOmwbnz5vrBg40e1UaNHBvbGWcChYREZHSZrPBxx/Dc8/BkSPmuttvh9dfrxB3UnYFFSwiIiKlaf16GDkSNmwwlxs3Nid+e+ihSjXx25+lET0iIiKl4dAhGDAAwsPNYsXfH+LiYNcu6N1bxYqT1MMiIiJSkjIz4dVX/xinYrFAVBRMmQJ167o7unJLBYuIiEhJMAxYsgSef968CgigUydznErbtu6NrQJQwSIiIvJn/fADjBgBycnmcuPGZi/Lgw/q1E8J0RgWERGR4jp2DIYMgQ4dzGKlalXz1M+uXRpUW8LUwyIiIuKsCxfMUz2vvALp6ea6QYPMQbX16rk3tgpKBYuIiEhRGQasXAnPPgv795vrwsLMmxaGhbk1tIpOp4RERESK4qefICLCvIPy/v1mT8rChfD99ypWXEAFi4iIyJX89htER0NoKHz1FXh7w4svwp49ukmhC+mUkIiISGFyc+Gdd2DcOLNoAbN3ZcYMaNLEvbFVQipYRERELpWUZF6mvH27udy6tTlO5e673RpWZaZ+LBERkXy//goPPwx33WUWKzVrwuzZsHWrihU3Uw+LiIjI+fPmRG9Tp5o/W63wt7/BpElwzTXujk5QwSIiIpWZYcCKFRATY/auANx5J7z5JoSEuDc2cVCsU0Jz5syhcePG+Pj4EBYWxsaNGy+77fLly2nXrh01atSgatWqhIaGsnDhQodthgwZgsVicXh07969OKGJiIgUzc6d0LWrOX3+r79CgwawbBmsXatipQxyuodl2bJlxMTEMG/ePMLCwpg1axbdunVjz5491KlTp8D2tWrV4sUXX6Rly5Z4eXnx+eefExUVRZ06dejWrZt9u+7du7NgwQL7sre3dzHfkoiIyBWcOQMTJphjU/LyzMuUx4yB554zp9aXMsnpHpaZM2cybNgwoqKiaNWqFfPmzcPPz4/58+cXun3nzp25//77ueGGG2jWrBkjRowgJCSEdevWOWzn7e1NcHCw/VGzZs3ivSMREZHC2Gwwfz5cd515xU9eHvTqZd73Z9IkFStlnFM9LNnZ2WzevJmxY8fa11mtViIiIkjOv0PlFRiGwVdffcWePXuYNm2aw3NJSUnUqVOHmjVrcvfddzNlyhSuucxAp6ysLLKysuzLaWlpAOTk5JCTk+PMW7qq/PZKul0pnPLtOsq1aynfrnVpvi0//IB15EisP/wAgHH99eTNnInRtWv+C9wSZ0VR3OPbme0thmEYRd346NGj1K9fn++//57w8HD7+jFjxvD111+zYcOGQl939uxZ6tevT1ZWFh4eHsydO5ehQ4fan1+6dCl+fn40adKEffv28cILL+Dv709ycjIeHh4F2pswYQITJ04ssH7JkiX4+fkV9e2IiEgF53XmDK0WLaLRl18CkOPry54+ffjfvfdieHq6OTrJzMykf//+nD17loCAgCtu65KrhKpVq8a2bdtIT08nMTGRmJgYmjZtSufOnQHo27evfdubbrqJkJAQmjVrRlJSEl26dCnQ3tixY4mJibEvp6Wl0bBhQyIjI6/6hp2Vk5NDQkICXbt2xVMHd6lTvl1HuXYt5du1cs6fZ9+zz9L600+xnD0LgG3AAHjlFa6vW5fr3RxfRVPc4zv/DElROFWwBAYG4uHhQWpqqsP61NRUgoODL/s6q9VK8+bNAQgNDWXXrl3ExcXZC5ZLNW3alMDAQPbu3VtoweLt7V3ooFxPT89S+0NQmm1LQcq36yjXrqV8u8A331Dlqae4accOczk0FGbPxnr77ZottZQ5e3w7s61Tn52Xlxdt27YlMTHRvs5ms5GYmOhwiuhqbDabwxiUSx0+fJhTp05Rt25dZ8ITEZHK7OhRGDAA7rwTy44dZFerRt7s2bBpE9x+u7ujkz/J6VNCMTExDB48mHbt2tGhQwdmzZpFRkYGUVFRAAwaNIj69esTFxcHQFxcHO3ataNZs2ZkZWWxatUqFi5cyFtvvQVAeno6EydO5MEHHyQ4OJh9+/YxZswYmjdv7nDZs4iISKFycsyrfiZOhPR0sFjIe+wxvuzUia59+xY6FlLKH6cLlj59+nDixAnGjx9PSkoKoaGhxMfHExQUBMDBgwexXnSr7YyMDIYPH87hw4fx9fWlZcuWLFq0iD59+gDg4eHB9u3b+fDDDzlz5gz16tUjMjKSyZMnay4WERG5ssREePpp89JkgLAwmDMHW0gIOatWuTc2KVHFGnQbHR1NdHR0oc8lJSU5LE+ZMoUpU6Zcti1fX19Wr15dnDBERKSyOnQInn0WPv3UXK5dG6ZNg8GDzfsA6TLlCkfjj0REpPzIzjYLk5YtzWLFaoXoaNizB6KizGWpkHTzQxERKR++/PKP4gTMgbRz5kCbNu6NS1xCpaiIiJRthw9Dnz7mjQr37IE6deDDD+Hbb1WsVCIqWEREpGzKzoZXXzVP/3zyiXm65+mnzaJl0CCwWNwdobiQTgmJiEjZs3YtPPXUH1f/3HabefonNNStYYn7qIdFRETKjmPHoH9/uPtus1ipXRsWLDBP/6hYqdRUsIiIiPvl5pqTv11/PXz8sXm6Z/hw8/TPkCG6+kd0SkhERNzs++/N4uTHH83lDh1g7lxo29a9cUmZopJVRETc48QJePRR8/LkH3+EmjXh7bchOVnFihSgHhYREXEtmw3efx+eew5OnzbXDR0KU6eaY1ZECqGCRUREXGfrVnjySdiwwVwOCYG33jKvAhK5Ap0SEhGR0peWBiNHQrt2ZrHi7w+vvw6bN6tYkSJRD4uIiJQewzAnffu//zMvWQZz1trXXoP69d0bm5QrKlhERKR0/PKLOflbQoK53Ly5OflbZKR745JySaeERESkZF24ABMmQOvWZrHi7Q0TJ8JPP6lYkWJTD4uIiJSchARzTpW9e83lbt3MXpVmzdwbl5R76mEREZE/LyXFnFI/MtIsVurWNceufPGFihUpESpYRESk+PLyzB6U/Cn1rVZ45hnYvRt699YdlaXE6JSQiIgUz5Yt8MQTsGmTudyunTlT7S23uDcuqZDUwyIiIs45d86cU6V9e7NYCQgwe1nWr1exIqVGPSwiIlI0hgErVpinfI4cMdf17QszZ5pjVkRKkQoWERG5ul9/haefhs8+M5ebNjXvqNytm3vjkkpDp4REROTycnJgxgxo1cosVjw94YUXYMcOFSviUuphERGRwm3YYA6q/fFHc7lTJ5g3zyxeRFxMPSwiIuIoLQ2ioyE83CxWatWC99+HpCQVK+I26mERERFT/qDap5+Go0fNdQMHmjcqrF3bvbFJpaeCRURE4OBBs1clf1Bt8+bm6Z8uXdwbl8jvdEpIRKQyy82FWbMcB9W++CJs365iRcoU9bCIiFRWW7bAsGHmvwC3327OVHvjje6NS6QQ6mEREalsMjJg1ChzptotW6BGDXjnHfjmGxUrUmYVq2CZM2cOjRs3xsfHh7CwMDZu3HjZbZcvX067du2oUaMGVatWJTQ0lIULFzpsYxgG48ePp27duvj6+hIREcEvv/xSnNBERORKvvjCLEpeew1sNujTB3btMntarPo/rJRdTh+dy5YtIyYmhtjYWLZs2UKbNm3o1q0bx48fL3T7WrVq8eKLL5KcnMz27duJiooiKiqK1atX27eZPn06b775JvPmzWPDhg1UrVqVbt26ceHCheK/MxER+UNqKvTrB/fcY85ae+218J//wNKlEBzs7uhErsrpgmXmzJkMGzaMqKgoWrVqxbx58/Dz82P+/PmFbt+5c2fuv/9+brjhBpo1a8aIESMICQlh3bp1gNm7MmvWLF566SV69uxJSEgIH330EUePHmXlypV/6s2JiFR6hmHOodKypVmcWK0QEwM7d5rFi0g54VTBkp2dzebNm4mIiPijAauViIgIkpOTr/p6wzBITExkz5493HHHHQDs37+flJQUhzarV69OWFhYkdoUEZHL+OUXuPtueOwxOHMGbr4ZNm40Twf5+7s7OhGnOHWV0MmTJ8nLyyMoKMhhfVBQELt3777s686ePUv9+vXJysrCw8ODuXPn0rVrVwBSUlLsbVzaZv5zl8rKyiIrK8u+nJaWBkBOTg45OTnOvKWrym+vpNuVwinfrqNcu5ZL852Tg/W117C+/DKWrCwMPz9ssbHYnn4aqlQx7w9Uwen4dq3i5tuZ7V1yWXO1atXYtm0b6enpJCYmEhMTQ9OmTencuXOx2ouLi2PixIkF1q9ZswY/P78/GW3hEhISSqVdKZzy7TrKtWuVdr5r/Pe/hM6ZQ/VffwXgeGgoPz75JJlBQbBmTanuuyzS8e1azuY7MzOzyNs6VbAEBgbi4eFBamqqw/rU1FSCrzBoy2q10rx5cwBCQ0PZtWsXcXFxdO7c2f661NRU6tat69BmaGhooe2NHTuWmJgY+3JaWhoNGzYkMjKSgIAAZ97SVeXk5JCQkEDXrl3x9PQs0balIOXbdZRr1yr1fKenY42NxTp7NhbDwLjmGvJmzKBm//50tlhKfn9lnI5v1ypuvvPPkBSFUwWLl5cXbdu2JTExkV69egFgs9lITEwkOjq6yO3YbDb7KZ0mTZoQHBxMYmKivUBJS0tjw4YNPPnkk4W+3tvbG29v7wLrPT09S+3ALM22pSDl23WUa9cqlXx/8QX87W/m9PoAAwdimTmTKoGBJbufckjHt2s5m29ntnX6lFBMTAyDBw+mXbt2dOjQgVmzZpGRkUFUVBQAgwYNon79+sTFxQHm6Zt27drRrFkzsrKyWLVqFQsXLuStt94CwGKxMHLkSKZMmUKLFi1o0qQJ48aNo169evaiSERECnHiBIwcCUuWmMuNG5sz1UZGujMqkVLhdMHSp08fTpw4wfjx40lJSSE0NJT4+Hj7oNmDBw9ivWjyoYyMDIYPH87hw4fx9fWlZcuWLFq0iD59+ti3GTNmDBkZGTz++OOcOXOGjh07Eh8fj4+PTwm8RRGRCsYwYPFis1g5dcq8VHnkSJg0CapWdXd0IqWiWINuo6OjL3sKKCkpyWF5ypQpTJky5YrtWSwWJk2axKRJk4oTjohI5fHrr+bpn/h4czkkBN57z5xmX6QC0zzMIiLlQV4evPmmOa1+fDx4e8PLL8OmTSpWpFLQ3ZpFRMq6n3+GRx+F9evN5Y4dzV6V6693b1wiLqQeFhGRsio72xyXEhpqFivVqsHcufD11ypWpNJRD4uISFn0ww9mr8pPP5nLf/kLvPUWNGjg3rhE3EQ9LCIiZUlmJoweDbfeahYrgYHw8cfw73+rWJFKTT0sIiJlRVKSeaPCffvM5QEDYNYss2gRqeTUwyIi4m5nz8ITT8Bdd5nFSoMG8PnnsGiRihWR36lgERFxp//8x7xU+Z13zOUnn4SdO+Hee90bl0gZo1NCIiLucOqUOTvtokXmcvPm5qXKd97p1rBEyir1sIiIuNo//gGtWpnFitUKo0bBjz+qWBG5AvWwiIi4iPfp03g8/DCsXGmuuPFGmD8fOnRwa1wi5YEKFhGR0mYYWBYt4u5nnsGang5VqsALL5gPb293RydSLqhgEREpTYcPwxNPUGXVKgCMm2/GsmABtGnj5sBEyheNYRERKQ2GYQ6ivfFGWLUKw8uLnx95hNzvvlOxIlIM6mERESlpv/4Kw4ZBQoK5HBZG7ttv88uBA7Sooj+7IsWhHhYRkZJis5n3+2nd2ixWfHxgxgz47jvzqiARKTaV+iIiJeF//zNvVpiUZC537Ajvvw/XXWcu22xuC02kIlAPi4jIn2GzwezZcNNNZrHi5wdvvAFff/1HsSIif5p6WEREimvfPrNX5euvzeU77zR7VZo1c29cIhWQelhERJxls8Hf/w4hIWaxUrWq2cvy1VcqVkRKiXpYREScsW8fDB0K33xjLnfubPaqNG3q1rBEKjr1sIiIFMXFvSrffGP2qsydC4mJKlZEXEA9LCIiV/O//0FU1B+9KnfdZfaqNGni3rhEKhH1sIiIXI7NBnPmFOxV+fJLFSsiLqYeFhGRwhw4YI5VWbvWXO7c2byzsgoVEbdQD4uIyMUMA95+25xXZe1ac16Vv//dHKuiYkXEbdTDIiKS7+BBc16VL780lzt2hAULoHlz98YlIuphERHBMMzTPa1bm8WKjw+8/ro5x4qKFZEyQT0sIlK5HT1q3ll51SpzOTwcPvhA0+qLlDHqYRGRyskwYMkSs1dl1Srw8oJp0+Dbb1WsiJRB6mERkcrn+HF48klYvtxcbtsWPvwQbrzRvXGJyGUVq4dlzpw5NG7cGB8fH8LCwti4ceNlt3333Xfp1KkTNWvWpGbNmkRERBTYfsiQIVgsFodH9+7dixOaiMiVLV9u9qosXw5VqsDEiZCcrGJFpIxzumBZtmwZMTExxMbGsmXLFtq0aUO3bt04fvx4odsnJSXRr18/1q5dS3JyMg0bNiQyMpIjR444bNe9e3eOHTtmf3z88cfFe0ciIoU5fRoeeQQefBBOnDAvW964EcaPB09Pd0cnIlfhdMEyc+ZMhg0bRlRUFK1atWLevHn4+fkxf/78QrdfvHgxw4cPJzQ0lJYtW/Lee+9hs9lITEx02M7b25vg4GD7o2bNmsV7RyIil1q92uxVWbwYrFYYOxZ++AFuvtndkYlIETk1hiU7O5vNmzczduxY+zqr1UpERATJyclFaiMzM5OcnBxq1arlsD4pKYk6depQs2ZN7r77bqZMmcI111xTaBtZWVlkZWXZl9PS0gDIyckhJyfHmbd0VfntlXS7Ujjl23UqRa7T07E+/zwe77wDgNGiBXnz52OEhZnPu/C9V4p8lyHKt2sVN9/ObG8xDMMo6sZHjx6lfv36fP/994SHh9vXjxkzhq+//poNGzZctY3hw4ezevVqdu7ciY+PDwBLly7Fz8+PJk2asG/fPl544QX8/f1JTk7Gw8OjQBsTJkxg4sSJBdYvWbIEPz+/or4dEanAav38M7e88QZVU1MB2PeXv7Br4EDyvL3dHJmI5MvMzKR///6cPXuWgICAK27r0quEpk6dytKlS0lKSrIXKwB9+/a1/3zTTTcREhJCs2bNSEpKokuXLgXaGTt2LDExMfbltLQ0+9iYq71hZ+Xk5JCQkEDXrl3x1HnuUqd8u06FzfWFC1gnTMD6+utYDAPj2mvJe/ddrr3rLq51Y1gVNt9llPLtWsXNd/4ZkqJwqmAJDAzEw8OD1N//x5IvNTWV4ODgK752xowZTJ06lS+//JKQkJArbtu0aVMCAwPZu3dvoQWLt7c33oX8L8nT07PUDszSbFsKUr5dp0LleutWGDgQdu40l4cOxfL661Qp4f/I/BkVKt/lgPLtWs7m25ltnRp06+XlRdu2bR0GzOYPoL34FNGlpk+fzuTJk4mPj6ddu3ZX3c/hw4c5deoUdevWdSY8EamscnPh5ZehQwezWAkKgn//G95/H8pQsSIixef0KaGYmBgGDx5Mu3bt6NChA7NmzSIjI4OoqCgABg0aRP369YmLiwNg2rRpjB8/niVLltC4cWNSUlIA8Pf3x9/fn/T0dCZOnMiDDz5IcHAw+/btY8yYMTRv3pxu3bqV4FsVkQrpv/+FQYMgfwzdQw/BW29BYKB74xKREuV0wdKnTx9OnDjB+PHjSUlJITQ0lPj4eIKCggA4ePAgVusfHTdvvfUW2dnZPPTQQw7txMbGMmHCBDw8PNi+fTsffvghZ86coV69ekRGRjJ58uRCT/uIiADm1Ppz58Lo0XD+PFSvDrNnw4ABYLG4OzoRKWHFGnQbHR1NdHR0oc8lJSU5LB84cOCKbfn6+rJ69erihCEildXhwzB0KCQkmMtdusCCBdCwoXvjEpFSo5sfikj58vHH5iy1CQng4wNvvglr1qhYEangdPNDESkffvsNnnoKli41l9u3h48+gpYt3RuXiLiEelhEpOxLSICQELNY8fCA2Fj47jsVKyKViHpYRKTsOn8enn/ePO0D0KIFLFpkXr4sIpWKChYRKZs2bzbvrrx7t7k8fDhMnw5Vq7o3LhFxC50SEpGyJX8SuFtvNYuV4GD44guYM0fFikglph4WESk79u0zp9bPv/v7Qw/BvHlwmTu3i0jloR4WEXE/w4D58yE01CxWAgLMK4A++UTFiogA6mEREXc7eRKeeAKWLzeX77jDLFYaNXJvXCJSpqiHRUTcZ/VqcxK45cvB0xOmToWvvlKxIiIFqIdFRFzv/HkYM8a89w/ADTfA4sVw883ujUtEyiz1sIiIa23dCm3b/lGsPP20eQmzihURuQIVLCLiGjYbvPoqhIXBrl3m5crx8eakcL6+7o5ORMo4nRISkdJ36BAMHgxr15rLvXrBu+9CYKBbwxKR8kM9LCJSuj791LwP0Nq14OdnFirLl6tYERGnqIdFREpHWho88wx8+KG53L69ObC2RQv3xiUi5ZJ6WESk5CUnm5PAffghWK3w4ovm3ZVVrIhIMamHRURKTm4uvPIKTJoEeXnmfCoLF0KnTu6OTETKORUsIlIyDhww76783Xfmcv/+MHcuVK/u1rBEpGLQKSER+fOWLIE2bcxipVo1s1dl8WIVKyJSYtTDIiLFl5YGTz0FixaZy+HhZqHSpIl74xKRCkc9LCJSPPkDaxctMgfWxsbCN9+oWBGRUqEeFhFxTl4exMXBhAl/DKxdvBhuv93dkYlIBaaCRUSK7tAhc2DtN9+YyxpYKyIuolNCIlI0y5ebA2u/+Qb8/eGjjzSwVkRcRj0sInJlGRnwf/9nTqkP5oy1S5ZA8+bujUtEKhX1sIjI5W3bBu3amcWKxQLPPw/r1qlYERGXUw+LiBRkGPDGG/Dcc5CdDXXrmnOrdOni7shEpJJSwSIijk6cgCFDYNUqc/mvf4X339fdlUXErXRKSET+8NVX5sDaVavA2xtmz4aVK1WsiIjbqWAREcjJgRdegIgIOHYMbrgBNm40Z7G1WNwdnYhI8QqWOXPm0LhxY3x8fAgLC2Pjxo2X3fbdd9+lU6dO1KxZk5o1axIREVFge8MwGD9+PHXr1sXX15eIiAh++eWX4oQmIs7avx/uuMOcDM4wYNgw2LQJQkLcHZmIiJ3TBcuyZcuIiYkhNjaWLVu20KZNG7p168bx48cL3T4pKYl+/fqxdu1akpOTadiwIZGRkRw5csS+zfTp03nzzTeZN28eGzZsoGrVqnTr1o0LFy4U/52JyFXVW7eOKu3bw/r15nwqn3wC77wDfn7uDk1ExIHTBcvMmTMZNmwYUVFRtGrVinnz5uHn58f8+fML3X7x4sUMHz6c0NBQWrZsyXvvvYfNZiMxMREwe1dmzZrFSy+9RM+ePQkJCeGjjz7i6NGjrFy58k+9ORG5jMxMPP72N9rPmIElLc28aeG2bdC7t7sjExEplFNXCWVnZ7N582bGjh1rX2e1WomIiCA5OblIbWRmZpKTk0OtWrUA2L9/PykpKURERNi3qV69OmFhYSQnJ9O3b98CbWRlZZGVlWVfTktLAyAnJ4ecnBxn3tJV5bdX0u1K4ZRvF9ixgyoDBmDdtQvDYiF31CjzvkCenuZYFikVOrZdS/l2reLm25ntnSpYTp48SV5eHkFBQQ7rg4KC2L17d5HaeO6556hXr569QElJSbG3cWmb+c9dKi4ujokTJxZYv2bNGvxKqSs7ISGhVNqVwinfpcAwaLRmDTe9/z6W7Gwu1KzJ5pEjOdmmDSjfLqNj27WUb9dyNt+ZmZlF3tal87BMnTqVpUuXkpSUhI+PT7HbGTt2LDExMfbltLQ0+9iYgICAkgjVLicnh4SEBLp27Yqnp2eJti0FKd+l5MwZPJ58Eus//wmALTIS29tvc/LHH5VrF9Gx7VrKt2sVN9/5Z0iKwqmCJTAwEA8PD1JTUx3Wp6amEhwcfMXXzpgxg6lTp/Lll18SctHVB/mvS01NpW7dug5thoaGFtqWt7c33t7eBdZ7enqW2oFZmm1LQcp3CdqwAfr2hQMHoEoViIvDGhODZ14e/Pijcu1iyrdrKd+u5Wy+ndnWqUG3Xl5etG3b1j5gFrAPoA0PD7/s66ZPn87kyZOJj4+nXbt2Ds81adKE4OBghzbT0tLYsGHDFdsUkauw2eDVV6FjR7NYadIEvvsORo0Cq6ZgEpHyxelTQjExMQwePJh27drRoUMHZs2aRUZGBlFRUQAMGjSI+vXrExcXB8C0adMYP348S5YsoXHjxvZxKf7+/vj7+2OxWBg5ciRTpkyhRYsWNGnShHHjxlGvXj169epVcu9UpDI5cQIGD4YvvjCXe/c2b2BYvbp74xIRKSanC5Y+ffpw4sQJxo8fT0pKCqGhocTHx9sHzR48eBDrRf97e+utt8jOzuahhx5yaCc2NpYJEyYAMGbMGDIyMnj88cc5c+YMHTt2JD4+/k+NcxGptL75Bvr1g6NHwcfHvInhsGGasVZEyrViDbqNjo4mOjq60OeSkpIclg8cOHDV9iwWC5MmTWLSpEnFCUdEAPLyzNlqY2PN00EtW5oTwd10k7sjExH503S3ZpGKICUFHnkE8seCDRoEc+aAv7974xIRKSEqWETKuy+/NIuV1FRzSv25c83xKyIiFYguFRApr3JzYdw4iIw0i5XWrc2bFqpYEZEKSD0sIuXRsWPmwNqvvzaXhw0zB9f6+ro3LhGRUqKCRaS8SUgwTwEdP26OUXnnHbN4ERGpwHRKSKS8yMuD8eOhWzezWAkJgc2bVayISKWgHhaR8uDYMejfH/KnDXj8cZg1S6eARKTSUMEiUtYlJprFSv4poLffNpdFRCoRnRISKavy8mDiROja9Y9TQJs2qVgRkUpJPSwiZdHx4zBggDnHCugqIBGp9FSwiJQ1334LffqY41b8/MxTQI884u6oRETcSqeERMoKmw2mT4e77jKLlVat4IcfVKyIiKAeFpGy4bffzBlqP//cXH7kEZg3D6pWdW9cIiJlhAoWEXfbuBF694aDB8HbG/7+d3jsMbBY3B2ZiEiZoVNCIu5iGOYdlTt2NIuVZs1g/XpzgK2KFRERBypYRNwhPd28PDk6GnJy4IEHzFlrQ0PdHZmISJmkgkXE1Xbtgg4dYOlSqFIFZs6Ef/wDqld3d2QiImWWxrCIuNLHH5unfDIyoF49+OQTuP12d0clIlLmqYdFxBWysszTP/37m8XK3XfD1q0qVkREikgFi0hpO3gQ7rjDHGAL8OKLsGYN1Knj3rhERMoRnRISKU1r1pi9KqdOQc2asHAh3Huvu6MSESl31MMiUhpsNpg8Gbp3N4uVtm1hyxYVKyIixaQeFpGSdvo0DBwI//mPuTxsGLz5Jvj4uDcuEZFyTAWLSEnauhUefBD27zcLlLlzISrK3VGJiJR7OiUkUlIWLIDbbjOLlSZN4PvvVayIiJQQFSwif1ZWFjzxBAwdChcuwD33mLPW3nyzuyMTEakwVLCI/BmHDkGnTvDOO+b9fyZNgs8+M68IEhGREqMxLCLF9dVX0KcPnDwJtWrBkiXQrZu7oxIRqZDUwyLiLMOAGTOga1ezWLn5ZvMUkIoVEZFSo4JFxBnnzpm9KqNHm3OtDB4M330HjRu7OzIRkQqtWAXLnDlzaNy4MT4+PoSFhbFx48bLbrtz504efPBBGjdujMViYdasWQW2mTBhAhaLxeHRsmXL4oQmUnr27IGwMPj0U/D0NC9ZXrAAfH3dHZmISIXndMGybNkyYmJiiI2NZcuWLbRp04Zu3bpx/PjxQrfPzMykadOmTJ06leDg4Mu2e+ONN3Ls2DH7Y926dc6GJlJ6Vq6E9u1h1y7zLstffw1PPmkOtBURkVLndMEyc+ZMhg0bRlRUFK1atWLevHn4+fkxf/78Qrdv3749r776Kn379sXb2/uy7VapUoXg4GD7IzAw0NnQREpeXh6MGwf332+eDrrjDnO8Sni4uyMTEalUnCpYsrOz2bx5MxEREX80YLUSERFBcnLynwrkl19+oV69ejRt2pQBAwZw8ODBP9WeyJ925gz89a8wZYq5PGIEfPklXKGnUERESodTlzWfPHmSvLw8goKCHNYHBQWxe/fuYgcRFhbGBx98wPXXX8+xY8eYOHEinTp1YseOHVSrVq3A9llZWWRlZdmX09LSAMjJySEnJ6fYcRQmv72SblcKV2byvXMnVXr3xrJ3L4aPD3lvvYUxYAC/B+fe2EpImcl1JaF8u5by7VrFzbcz25eJeVh69Ohh/zkkJISwsDAaNWrEJ598wqOPPlpg+7i4OCZOnFhg/Zo1a/Dz8yuVGBMSEkqlXSmcO/Nd9/vvueXNN7FcuEBm7dpsfP55ztasCatWuS2m0qRj27WUb9dSvl3L2XxnZmYWeVunCpbAwEA8PDxITU11WJ+amnrFAbXOqlGjBtdddx179+4t9PmxY8cSExNjX05LS6Nhw4ZERkYSEBBQYnGAWf0lJCTQtWtXPD09S7RtKcit+c7Lwxobi8f06QDY7roLz8WLub2CjqfSse1ayrdrKd+uVdx8558hKQqnChYvLy/atm1LYmIivXr1AsBms5GYmEh0dLQzTV1Reno6+/btY+DAgYU+7+3tXegAXk9Pz1I7MEuzbSnI5fk+fRr694f4eHP52WexTp2KtUqZ6IQsVTq2XUv5di3l27Wczbcz2zr91zgmJobBgwfTrl07OnTowKxZs8jIyCDq97vSDho0iPr16xMXFweYA3V//vln+89Hjhxh27Zt+Pv707x5cwBGjRrFfffdR6NGjTh69CixsbF4eHjQr18/Z8MTcd7OndCzJ+zbZ86p8v77oGNPRKRMcbpg6dOnDydOnGD8+PGkpKQQGhpKfHy8fSDuwYMHsVr/uPjo6NGj3HzRXWtnzJjBjBkzuPPOO0lKSgLg8OHD9OvXj1OnTlG7dm06duzI+vXrqV279p98eyJXsXIlDBwI6enQqJG5HBrq5qBERORSxervjo6OvuwpoPwiJF/jxo0xDOOK7S1durQ4YYgUn81m3lk5f/D2XXfBJ59ABR2vIiJS3lX8E/Qilzp3DgYNMntTAJ55xryZoc5zi4iUWSpYpHLZuxd69TLHrXh5wbx58Pv4KxERKbtUsEjlsWaNeaflM2egbl1YscK8maGIiJR5xbpbs0i5Yhgwcyb06GEWK7feCps2qVgRESlHVLBIxZaVBUOHwrPPmgNthw6FpCTzjssiIlJu6JSQVFwpKfDAA5CcDFYrvP46PP00WCzujkxERJykgkUqps2bzcG1hw9DjRrmJctdu7o7KhERKSadEpKKZ+lS6NjRLFZatoSNG1WsiIiUcypYpOKw2eDFF81p9S9cgHvugfXroUULd0cmIiJ/kk4JScWQng6PPAL/+pe5PGYMvPIKeHi4Ny4RESkRKlik/Dt4EO67D7ZvB29vePdd8/5AIiJSYahgkfItOdkcXHv8OAQFmdPt33qru6MSEZESpjEsUn4tWgSdO5vFSps25uBaFSsiIhWSChYpf/IH1w4cCNnZZg/LunVw7bXujkxEREqJTglJ+ZKRYRYqK1aYy2PHwpQp5sRwIiJSYalgkfLj8GFzcO22beadlt97T4NrRUQqCRUsUj5s3mwWK8eOQe3aZg/L7be7OyoREXER9aNL2bd8OXTqZBYrrVubg2tVrIiIVCoqWKTsMgyYPh0efBDOn4fu3eG776BxY3dHJiIiLqaCRcqm7GwYNgyee85cfuop+OwzCAhwb1wiIuIWGsMiZY5nejoef/kLJCWZV//MmgVPP+3usERExI1UsEjZsncvnZ57DuuRI+Dvb955+d573R2ViIi4mQoWKTu++44qPXtS7dQpjAYNsHz+uTmDrYiIVHoawyJlw7Jl0KULllOnON28ObnffadiRURE7FSwiHsZBkybBn37QlYWtvvu47uXX4a6dd0dmYiIlCEqWMR9cnPhySfh+efN5REjyPvkE/K8vd0bl4iIlDkawyLuce4cPPwwxMeDxQKvvw4jRkBOjrsjExGRMkgFi7je4cPwl7/Ajz+Cry98/DH07OnuqEREpAxTwSKutX073HMPHDkCderA559D+/bujkpERMo4jWER10lIgI4dzWLlhhtgwwYVKyIiUiQqWMQ1Fi40e1bOnYM779Q9gURExCnFKljmzJlD48aN8fHxISwsjI0bN1522507d/Lggw/SuHFjLBYLs2bN+tNtSjliGBAXB4MGmVcF9e0Lq1dDzZrujkxERMoRpwuWZcuWERMTQ2xsLFu2bKFNmzZ069aN48ePF7p9ZmYmTZs2ZerUqQQHB5dIm1JO5OWZNy184QVzedQoWLwYdNmyiIg4yemCZebMmQwbNoyoqChatWrFvHnz8PPzY/78+YVu3759e1599VX69u2L92W+qJxtU8qBzEx44AF46y3zsuU33oBXXzVvZigiIuIkp64Sys7OZvPmzYwdO9a+zmq1EhERQXJycrECKE6bWVlZZGVl2ZfT0tIAyMnJIaeE5/HIb6+k263QTp7E4/77sW7YgOHtTd6HH2I88ECR5lhRvl1HuXYt5du1lG/XKm6+ndneqYLl5MmT5OXlERQU5LA+KCiI3bt3O9PUn2ozLi6OiRMnFli/Zs0a/Pz8ihXH1SQkJJRKuxWNX0oK4ZMm4X/0KNn+/mx48UV+8/GBVaucakf5dh3l2rWUb9dSvl3L2XxnZmYWedtyOQ/L2LFjiYmJsS+npaXRsGFDIiMjCQgIKNF95eTkkJCQQNeuXfH09CzRtiucrVup8sQTWFJTMRo1wvLZZ9zasqVTTSjfrqNcu5by7VrKt2sVN9/5Z0iKwqmCJTAwEA8PD1JTUx3Wp6amXnZAbWm06e3tXeh4GE9Pz1I7MEuz7Qph7Vpzttpz56BNGyxffIHnn7iBofLtOsq1aynfrqV8u5az+XZmW6dGQHp5edG2bVsSExPt62w2G4mJiYSHhzvTVKm2KS72j39A9+5/zLHy9de627KIiJQop08JxcTEMHjwYNq1a0eHDh2YNWsWGRkZREVFATBo0CDq169PXFwcYA6q/fnnn+0/HzlyhG3btuHv70/z5s2L1KaUYXPnQnS0Od/Kgw/CokXg4+PuqEREpIJxumDp06cPJ06cYPz48aSkpBAaGkp8fLx90OzBgwexXnTp6tGjR7n55pvtyzNmzGDGjBnceeedJCUlFalNKYMMA2JjYfJkc/lvf4PZs8HDw71xiYhIhVSsQbfR0dFER0cX+lx+EZKvcePGGIbxp9qUMiY315wQ7p13zOUJE2D8eHO+FRERkVJQLq8SEje6cAH694cVK8xJ4ObMMXtXRERESpEKFim6c+fMK4HWrgUvL/j4Y3M2WxERkVKmgkWK5uRJ6NEDNm0Cf3/497/hrrvcHZWIiFQSKljk6o4cgchI+PlnuOYaiI+Hdu3cHZWIiFQiKljkyvbuhYgI+PVXqF8fEhLghhvcHZWIiFQyunWuXN6PP0LHjmax0rw5fPedihUREXELFSxSuO+/h86dITUV2rSBdeugUSN3RyUiIpWUChYpaPVq8zTQmTNw++2QlASaxE9ERNxIBYs4WrEC7rsPzp837w+0Zg3UqOHuqEREpJJTwSJ/WLIEeveGnBx46CH417/Az8/dUYmIiKhgkd+9/z488gjk5cGgQeakcF5e7o5KREQEUMEiAH//Ozz2mHlDw7/9DRYsgCq64l1ERMoOFSyV3bRp8Mwz5s8xMTB3rnmPIBERkTJE30yVlWGYd1h+/nlzedw4mDFDd1wWEZEySf3+lZFhwKhRMHOmuTx1Kjz3nHtjEhERuQIVLJWNYcDTT8OcOebym2+ayyIiImWYCpbKxGaDp56CefPMUz/vvGMOthURESnjVLBUFjYbPPmkWaRYLOaVQIMHuzsqERGRIlHBUhnYbPDEE/Dee+YVQB98AAMHujsqERGRIlPBUtHl5cGwYWaPitUKH30EAwa4OyoRERGnqGCpyPLyYOhQs0ixWmHRIujXz91RiYiIOE0FS0WVlwdDhphFioeHeZ+ghx92d1QiIiLFooKlIsrNNQfULlliFitLl5o3MxQRESmnVLBUNPmngZYsMe8HtGwZPPCAu6MSERH5UzQ1f0WSfzXQwoVmz4qKFRERqSBUsFQUhmFOCvf+++YA28WLVayIiEiFoYKlIjAMGDnyjxlsP/wQ+vRxd1QiIiIlRgVLeWcYMGaMeU8gMCeHe+QR98YkIiJSwlSwlHfjxsGMGebP8+aZA25FREQqGBUs5dnkyfDyy+bPb75pDrgVERGpgFSwlFfTp8P48ebPM2bA00+7Nx4REZFSVKyCZc6cOTRu3BgfHx/CwsLYuHHjFbf/9NNPadmyJT4+Ptx0002sWrXK4fkhQ4ZgsVgcHt27dy9OaJXDvHnw3HPmz6+8As8+6954RERESpnTBcuyZcuIiYkhNjaWLVu20KZNG7p168bx48cL3f7777+nX79+PProo2zdupVevXrRq1cvduzY4bBd9+7dOXbsmP3x8ccfF+8dVXRLlsDw4ebPL7wAY8e6Nx4REREXcLpgmTlzJsOGDSMqKopWrVoxb948/Pz8mD9/fqHbv/HGG3Tv3p3Ro0dzww03MHnyZG655RZmz57tsJ23tzfBwcH2R82aNYv3jiqyzz6DQYPMK4OGD4cpU9wdkYiIiEs4NTV/dnY2mzdvZuxF/6u3Wq1ERESQnJxc6GuSk5OJiYlxWNetWzdWrlzpsC4pKYk6depQs2ZN7r77bqZMmcI111xTaJtZWVlkZWXZl9PS0gDIyckhJyfHmbd0VfntlXS7zrJ8/TUevXtjycvD1r8/eTNnmvcMqmDKSr4rA+XatZRv11K+Xau4+XZme6cKlpMnT5KXl0dQUJDD+qCgIHbv3l3oa1JSUgrdPiUlxb7cvXt3HnjgAZo0acK+fft44YUX6NGjB8nJyXh4eBRoMy4ujokTJxZYv2bNGvz8/Jx5S0WWkJBQKu0WRY1ffuH2ceOwZGVxrEMHfnjgAYz4eLfF4wruzHdlo1y7lvLtWsq3azmb78zMzCJvWyZufti3b1/7zzfddBMhISE0a9aMpKQkunTpUmD7sWPHOvTapKWl0bBhQyIjIwkICCjR2HJyckhISKBr1654enqWaNtFsnMnVYYOxXLhArbOnQn897/p4ePj+jhcxO35rkSUa9dSvl1L+Xat4uY7/wxJUThVsAQGBuLh4UFqaqrD+tTUVIKDgwt9TXBwsFPbAzRt2pTAwED27t1baMHi7e2Nt7d3gfWenp6ldmCWZtuX9b//wT33wG+/QYcOWP/9b6zVqrk2BjdxS74rKeXatZRv11K+XcvZfDuzrVODbr28vGjbti2JiYn2dTabjcTERMLDwwt9TXh4uMP2YHYZXW57gMOHD3Pq1Cnq1q3rTHgVy7Fj0LWr+W/r1vDFF1BJihUREZFLOX2VUExMDO+++y4ffvghu3bt4sknnyQjI4OoqCgABg0a5DAod8SIEcTHx/Paa6+xe/duJkyYwKZNm4iOjgYgPT2d0aNHs379eg4cOEBiYiI9e/akefPmdOvWrYTeZjlz9iz06GH2sDRtCmvWQK1a7o5KRETEbZwew9KnTx9OnDjB+PHjSUlJITQ0lPj4ePvA2oMHD2K1/lEH3XbbbSxZsoSXXnqJF154gRYtWrBy5Upat24NgIeHB9u3b+fDDz/kzJkz1KtXj8jISCZPnlzoaZ8KLysL7r8ffvwRgoIgIQEqc0+TiIgIxRx0Gx0dbe8huVRSUlKBdb1796Z3796Fbu/r68vq1auLE0bFY7PB4MGwdi34+5ungZo2dXdUIiIibqd7CZUVhmFOsb9sGXh6wvLlcPPN7o5KRESkTFDBUla89hrMmmX+/MEH5oBbERERAVSwlA2LFsHo0ebPM2ZA//7ujUdERKSMUcHibmvWwO9XWPF//6c7L4uIiBRCBYs7bdkCDz5o3hOob1+zd0VEREQKUMHiLr/+as5im54Od99tjlux6uMQEREpjL4h3eHsWbj3XkhNhZAQWLECKuOcMyIiIkWkgsXVcnPh4Ydh505zQrj//AdK+IaNIiIiFY0KFlcyDHj6aXOgrZ8ffPYZNGjg7qhERETKPBUsrvTGGzBvHlgssHgxtG3r7ohERETKBRUsrvLvf0NMjPnzq69Cr15uDUdERKQ8UcHiClu2QL9+5imhxx//o3ARERGRIlHBUtqOHIH77oPMTHO6/dmzzVNCIiIiUmQqWEpTerpZrBw9Cq1awSefmDc2FBEREaeoYCktNhsMHAhbt0Lt2vD551CjhrujEhERKZdUsJSWSZNg5Urw8oJ//QuaNHF3RCIiIuWWCpbSsHIlTJxo/jxvHoSHuzUcERGR8k4FS0nbudM8FQTmJHH5d2IWERGRYlPBUpJOnzbnV0lPh86d4bXX3B2RiIhIhaCCpaTk5UH//rB3LzRqpCuCRERESpAKlpLy4osQHw++vuYYltq13R2RiIhIhaGCpSQsXQrTppk/z58PoaFuDUdERKSiUcHyZ23bBkOHmj+PGQN9+7o1HBERkYpIBcufcfKkOcj2/Hno1g1eecXdEYmIiFRIKliKy2aDRx6BX3+F5s3h44/Bw8PdUYmIiFRIKliKKy4OVq82B9kuXw41a7o7IhERkQpLBUtxrF0L48ebP8+dCzfd5N54REREKjgVLM5KSYF+/cxTQlFRMGSIuyMSERGp8FSwOCM31yxWUlOhdWuYPdvdEYmIiFQKKlicMWECJCWBvz/84x/g5+fuiERERCqFYhUsc+bMoXHjxvj4+BAWFsbGjRuvuP2nn35Ky5Yt8fHx4aabbmLVqlUOzxuGwfjx46lbty6+vr5ERETwyy+/FCe0UmOJj4eXXzYX3n0Xrr/evQGJiIhUIk4XLMuWLSMmJobY2Fi2bNlCmzZt6NatG8ePHy90+++//55+/frx6KOPsnXrVnr16kWvXr3YsWOHfZvp06fz5ptvMm/ePDZs2EDVqlXp1q0bFy5cKP47K0E+J07gkX/X5eHDNTmciIiIizldsMycOZNhw4YRFRVFq1atmDdvHn5+fsyfP7/Q7d944w26d+/O6NGjueGGG5g8eTK33HILs38f/2EYBrNmzeKll16iZ8+ehISE8NFHH3H06FFWrlz5p95cicjJof2MGVhOnYK2bWHmTHdHJCIiUulUcWbj7OxsNm/ezNixY+3rrFYrERERJCcnF/qa5ORkYmJiHNZ169bNXozs37+flJQUIiIi7M9Xr16dsLAwkpOT6VtIb0ZWVhZZWVn25bS0NABycnLIyclx5i1d3fPPU2vPHozq1cldvBisVijpfYhd/udX4p+jFKBcu5by7VrKt2sVN9/ObO9UwXLy5Eny8vIICgpyWB8UFMTu3bsLfU1KSkqh26ekpNifz193uW0uFRcXx8SJEwusX7NmDX4lOBC2xi+/cOff/w7AxiefJGX3brjM+5SSlZCQ4O4QKg3l2rWUb9dSvl3L2XxnZmYWeVunCpayYuzYsQ69NmlpaTRs2JDIyEgCAgJKbkeGQZafH79+9RU3jRvHLZ6eJde2FConJ4eEhAS6du2Kp/JdqpRr11K+XUv5dq3i5jv/DElROFWwBAYG4uHhQWpqqsP61NRUgoODC31NcHDwFbfP/zc1NZW6des6bBMaGlpom97e3nh7exdY7+npWeIHZs6wYeyqX58mpdC2XF5pfJZSOOXatZRv11K+XcvZfDuzrVODbr28vGjbti2JiYn2dTabjcTERMLDwwt9TXh4uMP2YHYZ5W/fpEkTgoODHbZJS0tjw4YNl21TREREKhenTwnFxMQwePBg2rVrR4cOHZg1axYZGRlE/X7Z76BBg6hfvz5xcXEAjBgxgjvvvJPXXnuNe++9l6VLl7Jp0ybeeecdACwWCyNHjmTKlCm0aNGCJk2aMG7cOOrVq0evXr1K7p2KiIhIueV0wdKnTx9OnDjB+PHjSUlJITQ0lPj4ePug2YMHD2K1/tFxc9ttt7FkyRJeeuklXnjhBVq0aMHKlStp3bq1fZsxY8aQkZHB448/zpkzZ+jYsSPx8fH4+PiUwFsUERGR8q5Yg26jo6OJjo4u9LmkpKQC63r37k3v3r0v257FYmHSpElMmjSpOOGIiIhIBad7CYmIiEiZp4JFREREyjwVLCIiIlLmqWARERGRMk8Fi4iIiJR5KlhERESkzFPBIiIiImWeChYREREp81SwiIiISJlXrJluyxrDMADnblNdVDk5OWRmZpKWlqY7frqA8u06yrVrKd+upXy7VnHznf+9nf89fiUVomA5d+4cAA0bNnRzJCIiIuKsc+fOUb169StuYzGKUtaUcTabjaNHj1KtWjUsFkuJtp2WlkbDhg05dOgQAQEBJdq2FKR8u45y7VrKt2sp365V3HwbhsG5c+eoV6+ew42TC1MhelisVisNGjQo1X0EBATooHch5dt1lGvXUr5dS/l2reLk+2o9K/k06FZERETKPBUsIiIiUuapYLkKb29vYmNj8fb2dncolYLy7TrKtWsp366lfLuWK/JdIQbdioiISMWmHhYREREp81SwiIiISJmngkVERETKPBUsIiIiUuapYLmKOXPm0LhxY3x8fAgLC2Pjxo3uDqlC+uabb7jvvvuoV68eFouFlStXujukCisuLo727dtTrVo16tSpQ69evdizZ4+7w6qw3nrrLUJCQuwTaoWHh/PFF1+4O6xKYerUqVgsFkaOHOnuUCqkCRMmYLFYHB4tW7Ystf2pYLmCZcuWERMTQ2xsLFu2bKFNmzZ069aN48ePuzu0CicjI4M2bdowZ84cd4dS4X399dc89dRTrF+/noSEBHJycoiMjCQjI8PdoVVIDRo0YOrUqWzevJlNmzZx991307NnT3bu3Onu0Cq0H374gbfffpuQkBB3h1Kh3XjjjRw7dsz+WLduXantS5c1X0FYWBjt27dn9uzZgHnPooYNG/L000/z/PPPuzm6istisbBixQp69erl7lAqhRMnTlCnTh2+/vpr7rjjDneHUynUqlWLV199lUcffdTdoVRI6enp3HLLLcydO5cpU6YQGhrKrFmz3B1WhTNhwgRWrlzJtm3bXLI/9bBcRnZ2Nps3byYiIsK+zmq1EhERQXJyshsjEylZZ8+eBcwvUSldeXl5LF26lIyMDMLDw90dToX11FNPce+99zr8/ZbS8csvv1CvXj2aNm3KgAEDOHjwYKntq0Lc/LA0nDx5kry8PIKCghzWBwUFsXv3bjdFJVKybDYbI0eO5Pbbb6d169buDqfC+umnnwgPD+fChQv4+/uzYsUKWrVq5e6wKqSlS5eyZcsWfvjhB3eHUuGFhYXxwQcfcP3113Ps2DEmTpxIp06d2LFjB9WqVSvx/algEanEnnrqKXbs2FGq550Frr/+erZt28bZs2f5xz/+weDBg/n6669VtJSwQ4cOMWLECBISEvDx8XF3OBVejx497D+HhIQQFhZGo0aN+OSTT0rldKcKlssIDAzEw8OD1NRUh/WpqakEBwe7KSqRkhMdHc3nn3/ON998Q4MGDdwdToXm5eVF8+bNAWjbti0//PADb7zxBm+//babI6tYNm/ezPHjx7nlllvs6/Ly8vjmm2+YPXs2WVlZeHh4uDHCiq1GjRpcd9117N27t1Ta1xiWy/Dy8qJt27YkJiba19lsNhITE3XuWco1wzCIjo5mxYoVfPXVVzRp0sTdIVU6NpuNrKwsd4dR4XTp0oWffvqJbdu22R/t2rVjwIABbNu2TcVKKUtPT2ffvn3UrVu3VNpXD8sVxMTEMHjwYNq1a0eHDh2YNWsWGRkZREVFuTu0Cic9Pd2hKt+/fz/btm2jVq1aXHvttW6MrOJ56qmnWLJkCf/617+oVq0aKSkpAFSvXh1fX183R1fxjB07lh49enDttddy7tw5lixZQlJSEqtXr3Z3aBVOtWrVCozFqlq1Ktdcc43GaJWCUaNGcd9999GoUSOOHj1KbGwsHh4e9OvXr1T2p4LlCvr06cOJEycYP348KSkphIaGEh8fX2Agrvx5mzZt4q677rIvx8TEADB48GA++OADN0VVMb311lsAdO7c2WH9ggULGDJkiOsDquCOHz/OoEGDOHbsGNWrVyckJITVq1fTtWtXd4cm8qccPnyYfv36cerUKWrXrk3Hjh1Zv349tWvXLpX9aR4WERERKfM0hkVERETKPBUsIiIiUuapYBEREZEyTwWLiIiIlHkqWERERKTMU8EiIiIiZZ4KFhERESnzVLCIiIhImaeCRURERMo8FSwiIiJS5qlgERERkTJPBYuIiIiUef8PeKoWZawkzZsAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<matplotlib.legend.Legend at 0x79ce70cf8520>, None)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGdCAYAAADqsoKGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2rUlEQVR4nO3deVyU1f7A8c/MsO8KsgkKCoqKgrggam6hmEtx65pZN5e8tlwtjbIbZS7VL72VZl0tq5uWt2uapWRlJGHuuIGYqLiiKDsoICDrzO+PkTEE0UFgWL7v12teM/M853me7xxH+HLOec5RaDQaDUIIIYQQzZzS0AEIIYQQQtQHSWqEEEII0SJIUiOEEEKIFkGSGiGEEEK0CJLUCCGEEKJFkKRGCCGEEC2CJDVCCCGEaBEkqRFCCCFEi2Bk6AAai1qtJjU1FWtraxQKhaHDEUIIIcRd0Gg0XLt2DVdXV5TK2ttiWk1Sk5qairu7u6HDEEIIIUQdXLp0CTc3t1rLtJqkxtraGtBWio2NjV7HlpWVsW3bNkaNGoWxsXFDhCduIXVuGFLvjU/qvPFJnRtGXes9Pz8fd3d33e/x2rSapKayy8nGxqZOSY2FhQU2NjbyH6CRSJ0bhtR745M6b3xS54Zxr/V+N0NHZKCwEEIIIVoESWqEEEII0SJIUiOEEEKIFqHVjKkRQojmSKPRUF5eTkVFhaFDaTHKysowMjKiuLhY6rUR1VbvxsbGqFSqe76GJDVCCNFElZaWkpaWRlFRkaFDaVE0Gg3Ozs5cunRJ5i1rRLXVu0KhwM3NDSsrq3u6hiQ1QgjRBKnVapKSklCpVLi6umJiYiK/gOuJWq2moKAAKyurO07mJurP7epdo9GQlZXF5cuX8fb2vqcWG0lqhBCiCSotLUWtVuPu7o6FhYWhw2lR1Go1paWlmJmZSVLTiGqr93bt2nHhwgXKysruKamRf00hhGjC5JeuaA3qqxVS/rcIIYQQokWQpEYIIYQQLYIkNUIIIerV1KlTUSgUPPvss9X2zZw5E4VCwdSpUxs/MHHPFi5ciEKhQKFQYGRkhIeHBy+++CIFBQUAXLhwQbdfoVBgbW1Njx49mDlzJmfOnGnw+CSpEUIIUe/c3d1Zv349169f120rLi5m3bp1dOjQwYCRiXvVo0cP0tLSuHDhAv/617/47LPPeOmll6qU+e2330hLS+Po0aO88847nDx5kt69e7Nz584GjU2SmnuVlwI7lkDUfENHIoQQTUZAQADu7u5s2rRJt23Tpk106NCB3r17VykbGRnJ4MGDsbOzw97ennHjxnHu3Dnd/sq//tevX8/AgQMxMzPD19e3yi/IvXv3YmNjQ1RUlG6bh4cHy5cvB7R33jz88MMEBwdTVlYGwLRp0wgNDdWVz8nJoU2bNtjZ2em2LVy4EH9//yrx7tixA4VCQW5uru64SZMm0b59eywsLOjZsyfffPNNtTr58ssvq7RiKBSKKuceNmwYc+bMuW2dTp06tUq8lee8U7yVIiIiqg3I/eGHHwgICMDMzIxOnTqxaNEiysvLbxsDgJGREc7Ozri5uTFx4kSeeOIJtmzZUqWMvb09zs7OdOrUiYceeojffvuNwMBAnn/++Qad8FCSmnt1/QrsWAwHP4fyEkNHI4RowTQaDUWl5Y3+0Gg0dYr3qaeeYs2aNbr3q1evZtq0adXKFRYWEhYWxuHDh4mOjkapVPKXv/wFtVpdpdzcuXN56aWXOHLkCEFBQYwfP56cnBwABg0axJo1a5gwYQLx8fHVrjF79mzOnTvHpk2bbrtC9N38Qq9JcXExffr04eeffyYhIYGnn36aJ598koMHD1Ypp9FosLGxIS0tjbS0tGqtG41t9+7dTJ48mdmzZ3PixAk+/fRTvvzyS/7v//5Pr/OYm5tTWlpaaxmlUsnzzz/PpUuXiI2NvZewayXz1NwrJ1+wcoKCDEiOgU7DDB2REKKFul5WQff5vzb6dU+8GYKFif6/Lv72t78RHh7OxYsXAW1ryvr169mxY0eVco888kiV96tXr6Zdu3acOHECX19f3fZZs2bpyn7yySdERkbyxRdf8Morr+jOc/nyZcaMGcP+/ft1x7377rv88MMPxMTEYGNjUy1ZAjh9+jSrV68mLCyMjz76SK/P2b59e15++WXd++eff55ff/2Vb7/9lv79++u2l5WVYWJigrOzM8A9z557rxYtWsSrr77KlClTAOjUqRNvvfUWr7zyCgsWLLirc8TGxrJu3TpGjBhxx7I+Pj6AtuVtwIABdQ+8FpLU3CuFAryCIf5/cPY3SWqEEOKGdu3aMXbsWL788ks0Gg1jx47FwcGhWrkzZ84wf/58Dhw4QHZ2ti7pSE5OrpLUBAUF6V4bGRnRt29fTp48WeVcgwcPJiwsjAceeICioiI2b97M7t27GTJkCO3bt79trK+88grPPPMMnTp1qrbv2LFjVRKQW7tPKioqeOedd/j2229JSUmhtLSUkpKSapMm5ufnY2lpedsYAD7++GP+85//YGpqipeXF/PmzWP8+PG6/T/99FOVWMrLyzEzM6sx3srZqKdMmcKrr75a7VpHjx5l7969VVpmKioqKC4upqio6LaTPlaev6KigtLSUsaOHcuKFStq/VyArsWvIWfGlqSmPnjdfyOpiYZRbxs6GiFEC2VurOLEmyEGuW5dPfXUU8yaNQuAlStX1lhm/PjxdOzYkc8//xxXV1fUajW+vr537NK4VUVFBTNmzCA8PJyzZ8+yYcMG8vLyiIiI4LnnnmPNmjU1dn/t3LmT3bt3s2bNGn744Ydq+7t27VplzMiBAwf429/+pnv/3nvv8eGHH7J8+XJ69uyJpaUlc+bMqRZ/amoqrq6utX6GJ554gtdff52SkhLWrFnDX//6V86fP69LyIYPH84nn3yiK79p0ybeeeedGuOtqKhg//79zJgxAy8vL4yMqv7KLygoYNGiRTz88MPV4rg1Uarp/EZGRrolPO5GZQLq6el5V+XrQpKa+tBpOCiUkHlCO3DY9vZ/DQghRF0pFIo6dQMZ0ujRoyktLUWhUBASUj0hy8nJ4dSpU3z++efcd999AOzZs6fGc+3fv58hQ4YA2haK2NhYXcIE8MEHH1BYWMgbb7wBwPbt23nuued48MEHKS8vZ8aMGYwbNw57e3vdMRqNhpdeeok33niDNm3a1HhdExMTvLy8dO8vX75cZf/evXt56KGHdImOWq3m9OnTdO/evUq5Q4cOVRskfStbW1vdtRYtWsTSpUs5efKkLqmxtLSsEoujo2Ot8Xbt2pUVK1YQHx9P3759q5QLCAjg1KlTVc53N26tj7uhVqtZsWIFHTt2vGMd3AsZKFwfLNpC+z7a1+eiDRuLEEI0ISqVipMnT3LixIka1/Rp06YN9vb2fPbZZ5w9e5bt27cTFhZW47lWrlzJ5s2bSUxMZObMmVy9epWnnnoK0I7TWLhwIZ9++immpqaYmppiYWGhS1Qefvhh7rvvvmp3F0VHR5OXl8fMmTPr/Bm9vb2Jiopi3759nDx5kmeeeYaMjAzd/uzsbF5//XX27t2rG79yO5XdP3l5eXz66acYGxvTtWtXveLRaDQUFxdTWFjI9u3bq41NqjR//nzWrl3LokWLOH78OCdPnmT9+vXMmzdPr+vVJCcnh/T0dM6fP8+WLVsIDg7m4MGD/Pvf/76ntZ3uRJKae3Quq4A564/w8/Ue2g1nfzNsQEII0cTY2NhgY2NT4z6lUsn69euJjY3F19eXF198kffee6/GskuWLGHJkiX4+fmxZ88etmzZohuj89xzzzFx4kSGDRt22zhWrlzJTz/9xK+/3hxsXVhYyJIlS257R9TdmDdvHgEBAYSEhDBs2DCcnZ2r3Hr9v//9j19//ZXNmzdXGThckxUrVmBubo6joyOrV6/mf//7H+7u7nrF88cff2Bubo6NjQ1Tp07lpZde4rHHHqtWLiQkhJ9++olt27bRr18/BgwYwAcffEDHjh31ul5NgoODcXFxoWfPnrz66qt069aN+Ph4XWtcQ1Fo6nqvXjOTn5+Pra0teXl5t/3PdTtlZWVs3bqVMWPGVPviJ2UXMvz9HfQ1Osd3Rm+AqS28ch5UzauJuKmprc5Fw5F6b3y3q/Pi4mKSkpLw9PSsdXxDa3DhwgU8PT05cuTIbedg0YdarSY/Px8bGxtZMLQR1VbvtX3f9fn9Xad/zZUrV+Lh4YGZmRmBgYHV7sW/1caNG/Hx8cHMzIyePXuydevWKvs3bdrEqFGjsLe3R6FQVJtj4MqVKzz//PN07doVc3NzOnTowAsvvEBeXl5dwq9XHvYWOFiZEFfuSbmpHZTkQcphQ4clhBBCtDp6JzUbNmwgLCyMBQsWEBcXh5+fHyEhIWRmZtZYft++fUyaNInp06dz5MgRQkNDCQ0NJSEhQVemsLCQwYMH869//avGc6SmppKamsr7779PQkICX375JZGRkUyfPl3f8OudQqGgT8c2qFGSZBuo3ShdUEIIIUSj0zupWbZsGTNmzGDatGl0796dVatWYWFhwerVq2ss/+GHHzJ69Gjmzp1Lt27deOuttwgICKhyT/uTTz7J/PnzCQ4OrvEcvr6+fP/994wfP57OnTszYsQI/u///o8ff/yxTrM/1rd+Hm0B2KX20244E1VLaSGEEPrw8PBAo9HUS9eTaNn0GvhRWlpKbGws4eHhum1KpZLg4GBiYmJqPCYmJqbaSPaQkBAiIiL0j/ZPKvvWbr3vvlJJSQklJTeXLcjPzwe0/deV637crcrytzvOr701AOuyvZgOkBZPWW4qWLbT6zripjvVuWgYUu+N73Z1XlZWhkajQa1W1zgDrqi7yqGklfUrGkdt9a5Wq9FoNJSVlVW7O0qfn0d6JTXZ2dlUVFTg5ORUZbuTkxOJiYk1HpOenl5j+fT0dH0uXS2Ot956i6effvq2ZRYvXsyiRYuqbd+2bdttZ0m8kz8vlPZn5WowVqo4V2xFlm1H2pVc5I/Ny7ncdlCdriNuul2di4Yl9d74bq3zykUDCwoK9J6ETtyda9euGTqEVqmmei8tLeX69evs2rWrWg9MUVHRXZ+72d2ik5+fz9ixY+nevTsLFy68bbnw8PAqLUT5+fm4u7szatSoOt39FBUVxciRI297R8iGjEMcvHCVDNf7aZe0mt7WOfQaM0av64ib7qbORf2Tem98t6vz4uJiLl26hJWVVau/+6m+aTQarl27hrW1dYNO2S+qqq3ei4uLMTc3Z8iQITXe/XS39EpqHBwcUKlUVSYVAsjIyNAt0HUrZ2dnvcrX5tq1a4wePRpra2s2b95c6w/dysmXbmVsbFznH9a1Hdvf056DF66yU+2PL6A8/ztKlQrkdsF7ci//XqLupN4b3611XlFRgUKhQKlUym3H9ayy66OyfkXjqK3elUolCoWixp89+vws0utf08TEhD59+hAdfXPWXLVaTXR0dJWFxv4sKCioSnnQNrPervzt5OfnM2rUKExMTNiyZUuT+8ulr4d21srvs1zBxBqKciAt3rBBCSGEEK2I3t1PYWFhTJkyhb59+9K/f3+WL19OYWGhbpGwyZMn0759exYvXgzA7NmzGTp0KEuXLmXs2LGsX7+ew4cP89lnn+nOeeXKFZKTk0lNTQXg1KlTgLaVx9nZWZfQFBUV8fXXX5Ofn69rjmrXrl2DTrl8twI6tkGhgPNXSin2vQ+zs1u1C1y2DzB0aEIIIUSroHe728SJE3n//feZP38+/v7+xMfHExkZqRsMnJycTFpamq78wIEDWbduHZ999hl+fn589913REREVFmHYsuWLfTu3ZuxY8cC8Nhjj9G7d29WrVoFQFxcHAcOHODYsWN4eXnh4uKie1y6dOmeKqC+2JgZ09VJexfUWWuZr0YIIYRobHXqTJw1axYXL16kpKSEAwcOEBgYqNu3Y8cOvvzyyyrlJ0yYwKlTpygpKSEhIYExtwygnTp1KhqNptqjciDwsGHDatyv0Wjw8PCoy0doEJVdUNFlPbUbLh+E61cNGJEQQhje5MmTGT9+vKHDaHU8PDxQKBQoFAosLS0JCAhg48aNuv0LFy7U7TcyMsLBwYEhQ4awfPnyKlOiNCcyQqoeVU7Ctz3dFBy6gkYN53caOCohhGh8x48fZ+LEibi5ufHf//6Xn376CWtrax544AGZMqARvfnmm6SlpXHkyBH69evHxIkT2bdvn25/jx49SEtLIzk5md9//50JEyawePFiBg4c2CxveZekph716ahtqUlIzaes0wjtRumCEkK0Mps3b8bPz4+SkhK+/vprHn30UUaPHs0vv/yCs7Mzo0aNYuXKlbryarWaN998Ezc3N0xNTfH39ycyMlK3/8KFCygUCtavX8/AgQMxMzPD19eXnTtv/tG4Y8cOXauDUqnE0dGR6dOnU1xcrCvzz3/+ky5dumBlZYW/vz/z58+vMrHbwoUL8ff359NPP8Xd3R0LCwseffTRausMVsZz6yM3N1dXRqFQVJtkdtiwYcyZM0f33sPDg+XLl9dYh6GhoUydOlX3vqSkhJdffpn27dtjaWlJYGAgO3bsqOVfQcva2hpnZ2e6dOnCypUrMTc358cff9Ttr5wPydXVlZ49e/L888+zc+dOEhISbrt0UVMmSU09am9njoutGRVqDad142qioXUshC6EaGgaDZQWNv5Dz59hc+bMYdiwYURERDBs2DDMzc0xNTVl8ODBrFmzhqlTp/LKK69QWFgIaJfTWbp0Ke+//z5//PEHISEhPPjgg5w5c6bKeefOnctLL73EkSNHCAoKYvz48eTk5FQpc+rUKVJSUvj666/ZsGEDa9as0e2ztrbmyy+/JCEhgcWLF/Of//yHDz74oMrxZ8+e5dtvv+XHH38kMjKSI0eO8I9//KPGz/nbb7+RlpbG999/r1f91MWsWbOIiYlh/fr1/PHHH0yYMIHRo0dXq6PaGBkZYWxsfMfJHH18fHjggQfYtGnTvYbd6Jrd5HtNWeXilj/9kcaOYm96GJnDtVTIPAlO3Q0dnhCiuSsrgndcG/+6r6WCieVdFc3IyCA5OZkXX3zxtmUefPBBXXIRGBjI+++/zz//+U8ee+wxAP71r3/x+++/s3z58iotOrNmzeKRRx4B4JNPPiEyMpIvvviCV155RVfG0dEROzs7CgsLMTExwdbWVrdv3rx5gLZlqG3btly+fJkNGzZUOb64uJi1a9fSvn17AP79738zduxYli5dqptfrXK8SeUdum3btr2ruqmr5ORk1qxZQ3JyMq6u2n//l19+mcjISNasWcM777xzx3OUlpaydOlS8vLyGDFixB3L+/j4sG3btnuOvbFJS009qxxXc+BSEXgM1m6ULighRCthYmIC1D61feU+MzMz8vPzSU1NZdCgqsvKDBo0iJMnT1bZ9uf5zYyMjOjbt2+1Mm5ublhaWuLt7c2YMWOYNGmSbt+GDRsYNGgQrq6uuLm58cYbb5CcnFzl+A4dOugSmsprqtVq3VQjgK516E6z00+aNAkrKyvdY/fu3dXK/POf/8TKygpHR0eGDRvG3r17q5U5duwYFRUVuq6zysfOnTs5d+5crTFUnt/CwoJ//etfLFmyRHencW00Gk2znG1ZWmrqWeW4mriLV1GPvh/l2ShtUjPoBQNHJoRo9owttK0mhrjuXWrTpg2BgYGsXbuW2bNnY2lZtYWnvLycTz/9FDc3N3x9fXVdUPVl9+7dWFtbk5SUxNNPP82yZct46aWXiImJ4YknnmDRokWMHDkSlUrFzz//zLJly/S+xvnz5zExMdG1mtzOBx98QHBwsO79E088Ua3M3LlzmTp1KoWFhbz33nuMHz++2tqIBQUFqFQqYmNjq83LZmVlVWsMlee3srLCycnprhOVkydP4unpeVdlmxJJauqZj7M1VqZGFJSUc942CC+A5BgoKQDT2r98QghRK4XirruBDOk///kP48aNo1u3bkyfPp2kpCSKiop45513WLt2LZmZmURERKBSqbCxscHV1ZW9e/cydOhQ3Tn27t1L//79q5x3//79DBkyBNAmR7GxscyaNatKGU9PT+zs7PDy8uKRRx5h8+bNvPTSS+zbt4+OHTvy+uuvo1aryc/P5+LFi9Vir5wItjJh2b9/P0qlkq5du+rK7Ny5k4EDB95x4ldnZ2e8vLx0783NzauVcXBw0JUJDw/nf//7X7XWo969e1NRUUFmZib33Xdfrdes7fx3KzExkcjISMLDw/U6rimQpKaeGamU9O5gx+4z2ezLtcXLriPkXoQLu6HrA4YOTwghGpyvry+nTp1izZo17Nmzh5MnT1JWVkZMTAxPPfUU06ZNo127drryc+fOZcGCBXTu3Bl/f3/WrFlDfHw8//vf/6qcd+XKlXh7e9OtWzc++OADrl69ylNPPVWlTGZmJsXFxVy8eJEff/xRlwR4e3uTnJzM+vXr6dOnD5s2bap2dxJou8SmTJnC+++/T35+Pi+88AKPPvoozs7OVFRUsHfvXtatW8eSJUt0LSpXrlzRXdvOzk6vuiovL6e4uJjCwkJWr16Nra0t7u7uVcp06dKFJ554gsmTJ7N06VJ69+5NVlYW0dHR9OrV6666k2q7fnp6Omq1mpycHHbs2MHbb7+Nv78/c+fOrfN5DUWSmgbQt2Nbdp/J5vDFXCZ7BcPhL+BMlCQ1QohWw9TUlGeffZZnn32WqVOnkpubW2MSAfDCCy+Ql5fHSy+9RGZmJt27d2fLli14e3tXKbdkyRKWLFlCfHw8Xl5ebNmyBQcHhyplKltUHBwcGDVqFO+++y6gHZz84osvMmvWLEpKShg5ciTz5s1j0aJFVY738vLi4YcfZsyYMVy5coVx48bx8ccfA3Dp0iVda9ILL7zACy9UHVbQtWtXNHreKTZ37lzmzp2Lubk5vr6+bN68ucbFmNesWcPbb7/NSy+9REpKCg4ODgwYMIBx48bpdb1bHT9+HBcXF1QqFba2tnTv3p3w8HCee+65GuNo6hQaff8Fmqn8/HxsbW3Jy8u74+CuW5WVlbF161bGjBlzV6uF7jubzeP/OYCrrRn7HimHdY+CtQu8eEJW7b5L+ta5qB9S743vdnVeXFxMUlISnp6eTW4B38Z24cIFPD09OXLkCP7+/vd8vsruJxsbmyqrRS9cuJCIiAji4+NvG8ewYcO4cOFCjfvt7OyqzFUjqrpdvUPt33d9fn/Lb9gG4N/BDpVSQWpeMSltA8HUBq6lwaUDhg5NCCFEHalUqirdZreqXANRGI4kNQ3AwsSIHq7abPLw5ULoemOtqxMRhgtKCCHEPXF3d+fQoUO33f/n276FYUhS00Aqb+2OvXgVeoRqN574AdRqwwUlhBDNkIeHBxqNpl66nmqzcOHC23Y9ieZBkpoGUjkJ36ELV6HziJtdUJcPGjgyIYQQomWSpKaB9L3RUpOYnk9+ufLmnU/HIwwXlBBCCNGCSVLTQBxtzOjQ1gKNBo4k50L3UO2OExHSBSWEuGut5AZV0crV1/dckpoG1NdD21pz+MIV6YISQuil8vbu2tZQEqKlqFw5/E6zNN+JTL7XgPp2bMumuBQOX7gKxl21XVB/bNB2QXUYYOjwhBBNmEqlws7OjszMTAAsLCya5QKDTZFaraa0tJTi4uJq86WIhnO7eler1WRlZWFhYYGR0b2lJZLUNKB+N1pqjly6SlmFGuPuodqk5sQPEPKOTMQnhKiVs7MzgC6xEfVDo9Fw/fp1zM3NJVFsRLXVu1KppEOHDvf87yFJTQPq3M4KW3Nj8q6XcSI1H7/OI8DEGq6lwuVD0CHQ0CEKIZowhUKBi4sLjo6OlJWVGTqcFqOsrIxdu3YxZMgQmTm7EdVW7yYmJvXSaiZJTQNSKhX07diG6MRMDl24gp97J20X1LFvtQOGJakRQtwFlUp1z2MNxE0qlYry8nLMzMwkqWlEjVHv0v/RwPrc6II6dEG7iqtuIr7jEXIXlBBCCFGPJKlpYEGd7AGIOZdDeYUaOt9ftQtKCCGEEPVCkpoG1svNDhszI/KLy/kjJQ+MzW5OxCdrQQkhhBD1RpKaBqZSKhjs7QDArtNZ2o2yFpQQQghR7ySpaQRDvLVL1e8+k63dUNkFlZ8CKYcNGJkQQgjRckhS0wgqW2riL+WSd73sRhfUaO1OWQtKCCGEqBeS1DQCtzYWdGpnSYVaQ8y5HO1GWQtKCCGEqFeS1DSSm11QN8bVeN0PJlbSBSWEEELUE0lqGsl9N7qgdONqjM1v3gUlXVBCCCHEPZOkppEM6GSPsUpB8pUiLmQXajfquqDkLighhBDiXklS00gsTY0I6KCdXbh6F9RlSIk1YHRCCCFE8ydJTSMa0kU7rmZXTV1Qf2wwUFRCCCFEyyBJTSOqHCwccy6Hsoob3U1+k7TPf3wLZdcNFJkQQgjR/ElS04h6uNrQxsKYgpJy4i/lajd2Gg62HaAkTzu2RgghhBB1UqekZuXKlXh4eGBmZkZgYCAHDx6stfzGjRvx8fHBzMyMnj17snXr1ir7N23axKhRo7C3t0ehUBAfH1/tHJ999hnDhg3DxsYGhUJBbm5uXUI3KKVSweDKW7srl0xQKiHgSe3ruLUGikwIIYRo/vROajZs2EBYWBgLFiwgLi4OPz8/QkJCyMzMrLH8vn37mDRpEtOnT+fIkSOEhoYSGhpKQkKCrkxhYSGDBw/mX//6122vW1RUxOjRo3nttdf0DblJqby1e2fluBoA/ydAoYSLeyH7jIEiE0IIIZo3vZOaZcuWMWPGDKZNm0b37t1ZtWoVFhYWrF69usbyH374IaNHj2bu3Ll069aNt956i4CAAFasWKEr8+STTzJ//nyCg4Nve905c+bw6quvMmDAAH1DblIqk5o/LueSW1Sq3WjbHrxHaV/HfWWgyIQQQojmzUifwqWlpcTGxhIeHq7bplQqCQ4OJiYmpsZjYmJiCAsLq7ItJCSEiIgI/aPVQ0lJCSUlJbr3+fn5AJSVlVFWVqbXuSrL63tcTRwsjPBqZ8nZrEJ2ncrgAV9nABS9HsfodCSa+G8oHxIOKpN7vlZzVp91Lu6e1HvjkzpvfFLnhlHXetenvF5JTXZ2NhUVFTg5OVXZ7uTkRGJiYo3HpKen11g+PT1dn0vrbfHixSxatKja9m3btmFhYVGnc0ZFRd1rWAC4GSk5i5Jvfo9Hk6y9C0qhqWCUkR1mRdkcWf8OaW3618u1mrv6qnOhH6n3xid13vikzg1D33ovKiq667J6JTXNSXh4eJUWovz8fNzd3Rk1ahQ2NjZ6nausrIyoqChGjhyJsbHxPcdmdSabHWvjuFhiwQMP3IdCoQBAafEH7PuAvsrjVIxZeM/Xac7qu87F3ZF6b3xS541P6tww6lrvlT0td0OvpMbBwQGVSkVGRkaV7RkZGTg7O9d4jLOzs17l64upqSmmpqbVthsbG9f5S3wvx/7ZQC9HTFRKUvOKuZRXSud2VtodfSfDvg9Qnt+BsiAV2nS852s1d/VV50I/Uu+NT+q88UmdG4a+9a5PWb0GCpuYmNCnTx+io6N129RqNdHR0QQFBdV4TFBQUJXyoG16ul351sDcREU/T+2SCbsqb+0GaNsJPIcCGjjytWGCE0IIIZopve9+CgsL4/PPP+err77i5MmTPPfccxQWFjJt2jQAJk+eXGUg8ezZs4mMjGTp0qUkJiaycOFCDh8+zKxZs3Rlrly5Qnx8PCdOnADg1KlTxMfHVxl3k56eTnx8PGfPngXg2LFjxMfHc+XKlbp9cgO7r3K+mj/f2g3QZ4r2+cjXUFHeyFEJIYQQzZfeSc3EiRN5//33mT9/Pv7+/sTHxxMZGakbDJycnExaWpqu/MCBA1m3bh2fffYZfn5+fPfdd0RERODr66srs2XLFnr37s3YsWMBeOyxx+jduzerVq3SlVm1ahW9e/dmxowZAAwZMoTevXuzZcuWun1yA6u8tTvmXA4l5RU3d/iMA/O2cC0VzkXf5mghhBBC3KpOA4VnzZpVpaXlz3bs2FFt24QJE5gwYcJtzzd16lSmTp1a6zUXLlzIwoUL9YiyaevmbIODlQnZBaXEXcwlqLO9doeRqXY9qP0rIfYr6BJi2ECFEEKIZkLWfjIQpVLxpy6orKo7K7ugTkfCtYa99V0IIYRoKSSpMaDKLqhq42radQX3AaCpgPj/GSAyIYQQovmRpMaABntpk5qE1DxyCkqq7gyYrH2OWwtqdSNHJoQQQjQ/ktQYkKONGT7O1mg0sOfsLa01PULB1AauXoALuw0RnhBCCNGsSFJjYEO7asfV/HbyllXOTSyh543B1bLIpRBCCHFHktQYWEgP7czK209mUFxWUXVnZRfUyR+hMKeRIxNCCCGaF0lqDMzfzQ4nG1MKSyvYe2sXlKs/uPhDRSkc/sIQ4QkhhBDNhiQ1BqZUKhh9o7UmMqGG27cHPq99PrAKSu9+pVIhhBCitZGkpgkI8dUmNVEnMyivuOVOp+6hYNcRinLk9m4hhBCiFpLUNAH9PdrSxsKY3KIyDiTdspaVyuhma82+j2Q9KCGEEOI2JKlpAoxUSkZ1r6ULyv8JsLCH3GQ4EdG4wQkhhBDNhCQ1TcToG11Qvx5PR63WVN1pYgGBz2pf71kOmlv2CyGEEEKSmqZioJc91qZGZF4r4cil3OoF+v0djC0h45is3i2EEELUQJKaJsLUSMWIbo4ARCakVS9g0fbmQpd7ljdeYEIIIUQzIUlNE6K7tft4OpqaupiCZoLSSLtsQkpsI0cnhBBCNG2S1DQhQ7u2w8xYyaUr1zmRll+9gK3bzaUTpLVGCCGEqEKSmibEwsSIoV20a0HVeBcUwKDZ2ueTP0L22UaKTAghhGj6JKlpYirvgrptUuPYDbqMBjTaeWuEEEIIAUhS0+SM8HHCWKXgTGYBZzMLai40aI72+eg3cC2j0WITQgghmjJJapoYW3NjBnZ2ALRz1tSoYxC4B2oXujzwSSNGJ4QQQjRdktQ0QXfsgoKbrTWHVkNxDYOKhRBCiFZGkpomaGR3J5QKOJaSx+Wrt1mZu8tocOgKJXkQu6ZxAxRCCCGaIElqmiAHK1P6ebQFammtUSph0Ava1zEfQ+ltkh8hhBCilZCkpon681pQt9XzUbDtAAXpMrZGCCFEqydJTRMVcmN24cMXr5J5rbjmQkYmcP8b2te7P4DC7EaKTgghhGh6JKlpolztzPFzt0OjgagTtdy27ftXcPGD0muw893GC1AIIYRoYiSpacJ0a0HVdheUUgkj39K+PvwF5JxrhMiEEEKIpkeSmiYspIcTADHncsgtKr19wU5DwXsUqMvht4WNE5wQQgjRxEhS04R1ameFj7M15WoNW4/V0loDELwIFEo4uQUuHWycAIUQQogmRJKaJu7hgPYAfBd7qfaCTt3B/wnt623zQKNp4MiEEEKIpkWSmiYu1L89KqWCuORczmXdZi2oSsNfByNzuHRAu4q3EEII0YpIUtPEOdqYMbRLOwC+i71ce2EbFxg4S/v6t4VQUdawwQkhhBBNiCQ1zcBf+7gBsCnuMhXqO3QrDZoNlu3gyjmI/bLhgxNCCCGaCElqmoH7uzliZ2FMRn4Je87eYYI9U2sY9qr29Y4lstilEEKIVkOSmmbA1EjFQ36uwF10QQEETAF7LyjKhr3LGzY4IYQQoomoU1KzcuVKPDw8MDMzIzAwkIMHa7+FeOPGjfj4+GBmZkbPnj3ZunVrlf2bNm1i1KhR2Nvbo1AoiI+Pr3aO4uJiZs6cib29PVZWVjzyyCNkZNQy024L89c+7oB2Lai8ojuMlVEZa2/xBohZCXkpDRydEEIIYXh6JzUbNmwgLCyMBQsWEBcXh5+fHyEhIWRmZtZYft++fUyaNInp06dz5MgRQkNDCQ0NJSEhQVemsLCQwYMH869//eu2133xxRf58ccf2bhxIzt37iQ1NZWHH35Y3/CbLd/2NnR1sqa0XM2Pf6Te+QCfsdAhCMqLYftbDR+gEEIIYWB6JzXLli1jxowZTJs2je7du7Nq1SosLCxYvXp1jeU//PBDRo8ezdy5c+nWrRtvvfUWAQEBrFixQlfmySefZP78+QQHB9d4jry8PL744guWLVvGiBEj6NOnD2vWrGHfvn3s379f34/QLCkUCt2A4bvqglIoYNTb2tdHv4HzOxouOCGEEKIJMNKncGlpKbGxsYSHh+u2KZVKgoODiYmJqfGYmJgYwsLCqmwLCQkhIiLirq8bGxtLWVlZlaTHx8eHDh06EBMTw4ABA6odU1JSQklJie59fr52wGxZWRllZfrd6lxZXt/j6tu4no4siUwk/lIuJ1Ou4uVoVfsBTn4o+0xHFfsFmi0vUD5jF5hYNk6w96ip1HlrI/Xe+KTOG5/UuWHUtd71Ka9XUpOdnU1FRQVOTk5Vtjs5OZGYmFjjMenp6TWWT0+/w7T/t5zDxMQEOzu7uz7P4sWLWbRoUbXt27Ztw8LC4q6v/WdRUVF1Oq4+dbNVknBVyfvf7+HBjuo7ljeq6M9w481Y5F7k4pdPc9ztiUaIsv40hTpvjaTeG5/UeeOTOjcMfeu9qKjorsvqldQ0J+Hh4VVaiPLz83F3d2fUqFHY2Njoda6ysjKioqIYOXIkxsbG9R2qXlQdM5i1/ijHrpmzIuQ+jFR37kFUdLOFDY/ROWsbHmNfRNO+byNEem+aUp23JlLvjU/qvPFJnRtGXeu9sqflbuiV1Dg4OKBSqarddZSRkYGzs3ONxzg7O+tV/nbnKC0tJTc3t0prTW3nMTU1xdTUtNp2Y2PjOn+J7+XY+jLK15U2FifIvFbC/ot5DO/qeOeDuj0AvR5D8cd6jH6eA8/sAqPqddMUNYU6b42k3huf1Hnjkzo3DH3rXZ+yeg0UNjExoU+fPkRHR+u2qdVqoqOjCQoKqvGYoKCgKuVB2/R0u/I16dOnD8bGxlXOc+rUKZKTk/U6T0tgYqTkIf/KRS7vYsBwpdGLtTMNZyXC7qUNFJ0QQghhOHrf/RQWFsbnn3/OV199xcmTJ3nuuecoLCxk2rRpAEyePLnKQOLZs2cTGRnJ0qVLSUxMZOHChRw+fJhZs2bpyly5coX4+HhOnDgBaBOW+Ph43XgZW1tbpk+fTlhYGL///juxsbFMmzaNoKCgGgcJt3SVd0FFHc8gt6j07g6yaAtj3tO+3r0U0hNqLy+EEEI0M3onNRMnTuT9999n/vz5+Pv7Ex8fT2RkpG4wcHJyMmlpabryAwcOZN26dXz22Wf4+fnx3XffERERga+vr67Mli1b6N27N2PHjgXgscceo3fv3qxatUpX5oMPPmDcuHE88sgjDBkyBGdnZzZt2lTnD96c9XC1wcfZmtIKNT8evYs5ayp1DwWfcaAuhy2zoKK8wWIUQgghGludBgrPmjWrSkvLn+3YsaPatgkTJjBhwoTbnm/q1KlMnTq11muamZmxcuVKVq5cqU+oLVLlnDVv/3yS72Iv82SQx90eCGPeh6TdkHoEDnwCA59v0FiFEEKIxiJrPzVTob3bY6RUcPRyHqczrt39gTYuEHJjUr7t/wc55xomQCGEEKKRSVLTTDlYmTLcR3vnk14DhgF6PwmeQ6D8Ovw4GzSaBohQCCGEaFyS1DRjlQOGN8WlUFZx54n4dBQKGP8RGFvAhd1w6D8NFKEQQgjReCSpacaGd3XEwcqU7IISth5Lu/MBf9bWE+6fr33962vaMTZCCCFEMyZJTTNmYqTkyQEdAVi9JwmNvt1I/Z+BrmOgohS+nQLXrzZAlEIIIUTjkKSmmXtiQAdMVEqOXs4jLjlXv4OVSgj9GOw6Qu5F2PwcqPXoxhJCCCGaEElqmjkHK1Me8ncFYPXeJP1PYN4GHl0LKlM4/Qvs+7CeIxRCCCEahyQ1LcC0QZ4ARCakk5J7Xf8TuPrDmHe1r6Pf1M5jI4QQQjQzktS0AN1dbQjqZE+FWsPamAt1O0nAFPCbBBo1fPcUXEuv1xiFEEKIhiZJTQvx1GBta803B5IpKq3D8gcKBYxdBo49oDBTm9jIMgpCCCGaEUlqWogRPo50tLcgv7ic7+NS6nYSEwvt+BoTa7i4F7a/Vb9BCiGEEA1IkpoWQqVUMHWgBwBr9iahVtdxlmAHL3hohfb13uWQuLVe4hNCCCEamiQ1LciEvu5YmxpxPquQnWey6n6iHqEw4B/a15uflfWhhBBCNAuS1LQgVqZGPNrPHdBOxndPgheBW38oyYP//kUGDgshhGjyJKlpYaYO9ECpgN1nsvVbvftWRibw2Dpo20k7Md/Xf4XivPoLVAghhKhnktS0MO5tLRjZ3QmANXsv3NvJrNrB3zaBpSNkHIP1T0BZ8b0HKYQQQjQASWpaoKduTMa3Ke4yVwtL7+1kbT3hb99r74i6sBs2zQB1RT1EKYQQQtQvSWpaoP6ebenhakNJuZp1B5Pv/YQuvWDSOlCZwMktsPVl0HfxTCGEEKKBSVLTAikUCl1rzdqYC5RV1MMilZ5D4OHPAQUcXg073733cwohhBD1SJKaFmqcnwsOVqZk5Jew9Vha/Zy0RyiMfV/7esc72uRGCCGEaCIkqWmhTI1UPDmgIwCf7z6Ppr66i/r9HYb+U/v655fgxJb6Oa8QQghxjySpacH+NqADFiYqElLy+e1kZv2deFg49JmqXfzy++lw8sf6O7cQQghRR5LUtGD2VqZMubF0wgdRp+uvtUahgDFLoXsoVJTCt5Mhfl39nFsIIYSoI0lqWrin7+uEpYmKE2n5/Ho8o/5OrDKCR74A/79pW2winoP9q+rv/EIIIYSeJKlp4dpYmvDUYO2dUMt/O133hS5rojKCB/8NA2Zq30f+E3Yskdu9hRBCGIQkNa3A3wd3wtrUiMT0a/ySUM9rOCmVEPJ/MPx17fsdiyEyHNT1cBu5EEIIoQdJaloBWwtjpt93s7Wmoj5ba0A7xmboK/DAjblrDnwCW2ZBRXn9XkcIIYSohSQ1rcRTgz2xMTPiTGYBP/2R2jAXCXwG/vIpKFQQ/z/YOAXKSxrmWkIIIcQtJKlpJWzMjJlxXycAPow+U/+tNZX8HoOJ/wWVKST+BP99GAqzG+ZaQgghxJ9IUtOKTB3kgZ2FMeezCtlyNKXhLuQzFv72HZhYwcU98OlQSIltuOsJIYQQSFLTqlibGfP0kButNb+dobw+1oS6Hc8h8PdosPeC/Muw+gGI+2/DXU8IIUSrJ0lNKzMlyIO2liZcyCli85EGbK0BcPSBGduh61ioKNEOHv5xjoyzEUII0SAkqWllLE2NeOZGa81H28/UzwretTGzhYlfw/B5gAJi18CXYyG/gQYrCyGEaLUkqWmFngzqiIOVCZeuXGdT3OWGv6BSCUPnwhMbtUnO5UPw6RC4sLfhry2EEKLVkKSmFbIwMeLZoZ0B+Cj6LKXljTRRnvdIeHoHOPlCYRZ8NR52L5P5bIQQQtQLSWpaqb8N6Eg7a1NScq+z4fClxrtw204wfRv0nACaCoheBKtDIOt048UghBCiRapTUrNy5Uo8PDwwMzMjMDCQgwcP1lp+48aN+Pj4YGZmRs+ePdm6dWuV/RqNhvnz5+Pi4oK5uTnBwcGcOXOmSpm4uDhGjhyJnZ0d9vb2PP300xQUFNQlfAGYGauYNdwL0K7gnVdU1ngXN7GEhz+Hh1aCqQ2kHIZVg2Hvh6CuaLw4hBBCtCh6JzUbNmwgLCyMBQsWEBcXh5+fHyEhIWRmZtZYft++fUyaNInp06dz5MgRQkNDCQ0NJSEhQVfm3Xff5aOPPmLVqlUcOHAAS0tLQkJCKC4uBiA1NZXg4GC8vLw4cOAAkZGRHD9+nKlTp9btUwsAHg/sgLejFVcKS1ke3cgtJQoF9P4b/GM/eAVr746Kmg+rR0P2mTsfL4QQQtxC76Rm2bJlzJgxg2nTptG9e3dWrVqFhYUFq1evrrH8hx9+yOjRo5k7dy7dunXjrbfeIiAggBUrVgDaVprly5czb948HnroIXr16sXatWtJTU0lIiICgJ9++gljY2NWrlxJ165d6devH6tWreL777/n7Nmzdf/0rZyxSsn88d0BWBtzkdMZ1xo/CNv28MR32tW+TW3g8kFYNRjl/pWgkUUxhRBC3D0jfQqXlpYSGxtLeHi4bptSqSQ4OJiYmJgaj4mJiSEsLKzKtpCQEF3CkpSURHp6OsHBwbr9tra2BAYGEhMTw2OPPUZJSQkmJiYolTdzMHNzcwD27NmDl5dXteuWlJRQUnJzPpT8/HwAysrKKCvTr6ulsry+xzUHAzzsGNnNkaiTmSz8IYEvp/ZBoVA0fiA9J0HHIah+noPy/O+oohcw2NKb8hR3aO/X+PG0Ui35u95USZ03Pqlzw6hrvetTXq+kJjs7m4qKCpycnKpsd3JyIjExscZj0tPTayyfnp6u21+57XZlRowYQVhYGO+99x6zZ8+msLCQV199FYC0tLQar7t48WIWLVpUbfu2bduwsLC400etUVRUVJ2Oa+qCzOB3hYp956+w5OtI/OwbaF2ou2EzlY7uHvRI+Qb7wjNovgzmov1QEl0eocTY1nBxtTIt9bvelEmdNz6pc8PQt96LioruuqxeSY2h9OjRg6+++oqwsDDCw8NRqVS88MILODk5VWm9+bPw8PAqLUT5+fm4u7szatQobGxs9Lp+WVkZUVFRjBw5EmNj43v6LE1Vts1ZPt55nm2Zlrz42CDMjFUGjGYs5Tn/IHP9TNrnHsQjZwcdrx1GPehF1P2fASMzA8bWsrWG73pTI3Xe+KTODaOu9V7Z03I39EpqHBwcUKlUZGRkVNmekZGBs7Nzjcc4OzvXWr7yOSMjAxcXlypl/P39de8ff/xxHn/8cTIyMrC0tEShULBs2TI6depU43VNTU0xNTWttt3Y2LjOX+J7Obapm3W/N5vjU7mcW8yXMZd4/n5vwwZk78lhz1k49WyL0W9voEg9gur3t1Ad+QqCF0GPv2gHG4sG0ZK/602V1Hnjkzo3DH3rXZ+yeg0UNjExoU+fPkRHR+u2qdVqoqOjCQoKqvGYoKCgKuVB2/RUWd7T0xNnZ+cqZfLz8zlw4ECN53RycsLKyooNGzZgZmbGyJEj9fkI4jYsTIwIH9MNgJU7zpKae93AEWlp3AfA37fDXz4Fa1fITYbvpmnvkrosK38LIYS4Se+7n8LCwvj888/56quvOHnyJM899xyFhYVMmzYNgMmTJ1cZSDx79mwiIyNZunQpiYmJLFy4kMOHDzNr1iwAFAoFc+bM4e2332bLli0cO3aMyZMn4+rqSmhoqO48K1asIC4ujtOnT7Ny5UpmzZrF4sWLsbOzu7caEDrje7nQ36MtxWVq3tl60tDh3KRUgt9j8PxhGBYOxhZwaT/8ZwR8/VdI3m/oCIUQQjQBeo+pmThxIllZWcyfP5/09HT8/f2JjIzUDfRNTk6uMs5l4MCBrFu3jnnz5vHaa6/h7e1NREQEvr6+ujKvvPIKhYWFPP300+Tm5jJ48GAiIyMxM7s5duLgwYMsWLCAgoICfHx8+PTTT3nyySfv5bOLWygUChY82J3x/97DT3+k8eSAHAI72Rs6rJtMLGHYqxAwGaLfgj/Ww9ko7aPjYBjyEnQaLt1SQgjRStVpoPCsWbN0LS232rFjR7VtEyZMYMKECbc9n0Kh4M033+TNN9+8bZm1a9fqHafQXw9XWyb178D/DiSzYMtxfnp+MEaqJraaho0r/OUTGPKydhbi+HVwcQ/8dw+4BsB9L0HXMdoWHiGEEK2G/NQX1bw0qiu25sYkpl/jm0ONuC6Uvuw7w4MfweyjEPgcGJlDahxseAI+GahNdsqKDR2lEEKIRiJJjaimraUJYSO7ALB02ymuFpYaOKI7sG0PDyyBFxO0rTSmNpB1EiKeg2U+8OvrkC0zTwshREsnSY2o0ROBHejqZE1uURlv/XTC0OHcHUsHuH8+zDmmfbZ1h+tXIWYFrOgDX42H45uhvIknaUIIIepEkhpRIyOVksWP9ESpgE1HUth2PN3QId09cztti83so/D4t9BlNKCApF2wcSp80B1+WwQ55wwcqBBCiPokSY24rYAObZgxRDu54WubE5p+N9StlCroEgKPb4A5f8CQuWDlDIVZsGcZ/DsAPh0Kez+C3CY8dkgIIcRdkaRG1OrF4C54OVqRXVDCwh+PGzqcurPrACPmacfdPPpf6Hw/KFSQFg9Rb8ByX/giBA58Btcy7ng6IYQQTY8kNaJWZsYqlk7wQ6VU8EN8KpEJzagbqiYqY+j+IDy5CV4+DWOXaee4QaGd0O+XudrBxV+Nh/2rpItKCCGaEUlqxB35udvxzI1uqHkRx7jS3LqhbsfSAfpNh2k/Q9hJGL0E3PqBRq0dfxP5T20X1b/7QGQ4nPsdyksMHbUQQojbaBardAvDmx3szW8nMzidUcD8HxJY8XiAoUOqXzYuMOA57ePqBTj5I5zZBhf3Qc5Z7WP/x2BsCZ2GgXcweAzRzpUjMxgLIUSTIEmNuCumRiqWTvAn9OO9/PRHGmN6pjGmp8udD2yO2njAwOe1j+J8OL8DzvwKZ6KgIANO/ax9AFg5QcdB4DFI243VrqskOUIIYSCS1Ii71tPNln8M68y/t59lXkQC/T3b4mBlauiwGpaZjXYMTvcHQa2GjGNwehuc/x0uH9YmOcc3aR8AFg7QcaD24RoALr3A2Nywn0EIIVoJSWqEXp4f4U3UiQwS06/xRkQCHz8RgKK1tEwoleDip30MnatdgiHlMFzYq1176tIhKMqGk1u0D9DeYeXUXZvgtA+A9n2gXTdQyX89IYSob/KTVejFxEjJ+xP8CF25l18S0vnpjzTG+7kaOizDMDYDj8HaB//UzlScGgcX9mhbcVJioTAT0o9pH3FfaY8zMtcmOo7dwcn3xuseYNmEVkQXQohmSJIaoTff9rbMHO7Fh9FnmP9DAn092uBiK10sGJlAhwHaB4BGA/kpkBKnTXBS4yA1Hkryte9TYqseb+V0I9HpAQ7eYO8F9t5g5SjjdIQQ4i5IUiPqZOZwL6ITM0hIyWfWuiOsf3oAxiqZIaAKhQJs3bSP7g9qt6nV2jupMhIg8wRknIDM49o7rgoytI/zv1c9j4m19i4re6+bjzYdtRMKWjlJwiOEEDdIUiPqxMRIycrHAxj37z3EXrzKu5GJvD62u6HDavqUSmjXRfvg4ZvbS65BZqI2wck8efM28txkKL2mnfk4Lb76+YzMtAt3ViY5dh20723aa29Tt3YBoxY+mFsIIW6QpEbUWUd7S96f4Mcz/43l891J9OnYhtG+LfQ274Zmag3u/bSPPysvgStJN5OcnLNw5bw22clPgfJiyDmjfdyOhcONBMcVbFzB2hks22m7taycbr42sWzYzyiEEA1MkhpxT0J6OPP0kE58tus8czf+gY+zDR4O8sux3hiZgqOP9nGr8lJtYpObDLkXbzwnaxfnvJYK+WlQUaK9I6soWztYuTbGlhhZtuO+UhWqa//VzrhsYQ8WbcG87c3XZnbaldDNbMHESrq/hBBNhiQ14p7NDenKkeSrHLpwlef+F8fmfwzEzFhl6LBaPiMTaOupfdREo4GiKzcTnPwUuJYG19K1K5UXZGrvzirIgvLrUFaIIreQtgBn73LNK4VKm9yY22mTHTNbbauTqc2N5xoeJpY3HlY3Xxtbym3uQoh7Jj9FxD0zVin596QAxn60m5Np+Szccpwlj/QydFhCodDeJm5pD849b19Oo4HSAijIpDwvjdjd2+jT3ROjkjwoytEmRtev3HidA8V5cD0X1GWgqdDuu37l3uNVmYKJBRhbaCcsNL71tbn2NnqjPz1ufW9kCiqTG69NtOfUbbvxrHsY33ytVEmLkxAtgCQ1ol4425rx0aTe/O2LA6w/dIk+Hdswoa+7ocMSd0Oh0LWiaGw6kG6Xg8Z/DBgb3/4YjQbKrkNx7s0kpzhP+77k2i2PfO1zcb42eSothLIi7euSAm1iBNqususlcP1qI3zoWym0SY7SWNtipDK5+VppfHOfUnXjtVEND1UNr288K1Q3Eqcbz396rdRAl/RzKPedASNjUCi1+xTKG+WUNx9V3t9IxP68v8aH4mY5FH/adrv3VN+Houqzbv+f9/GnxPDWfTU868orajju1tdULV/ja27//tZt5WUo1aXaMWsK9W3K3e74GvbVtF+SZIOQpEbUm0FeDoQFd2Fp1Gne+CEB3/a2dHOxMXRYoiEoFNpWFRML7eDjutJooKJUm+iUFmgTpbIi7XNp0c3XZTdelxdrfxGVXdc+l1+v+r6i5Mb2Eu15b92mLtdur7h1pXnNze1l91QzelMB3QDSGve6rZkxMB7gqCGjuEPSU2tSdC/HNvDx9l7wj313OL7hSFIj6tXM4V7EJl9lx6ks/vG/OLbMGoS1WS1/8YvWTaHQdgsZmWoHITcWjQYqym4mMhWl2vfqMqi4kfhUvlaX3dhXfvOhe19xc7+mQjsP0Z/LaSpulLlRtvK9Rq17X1FeyqXki3Ro3x6lQlNl383XN7ZXbvvzQ60GNNW3V9t/o4yu7J+O0e3XVC375323Puv28ad93L78n58r/w1uPa5VucPn1dxDfRiyKqv9wdC4JKkR9UqpVPDBo/6M/Wg3SdmFzN34Bx8/EYBSKU2xoglRKLRjboxMDB0J6rIyjm7dSvsxY1DW1uXXmmhqSHZqSoh0r28t96f3NWwrKytj27ZtjBo1CmMjVQ3lbnd8LfFW3aDffn3Od8dkpwGTpbs5v9KwaYUkNaLetbE0YeUTATz6aQyRx9P516+JhD/QzdBhCSGaC0UN42nqk7KMcpW5diyZJJItisxrLxpE7w5tePev2jugPt15nq/3XzRwREIIIVo6SWpEg/lLbzfCRnYBYP4PCfyemGngiIQQQrRkktSIBvX8CC/+2scNtQZmrosjISXP0CEJIYRooSSpEQ1KoVDwzl96MsjLnqLSCqZ/dYjU3OuGDksIIUQLJEmNaHAmRko+fqIP3o5WZOSX8NSXh7hW3MiTgQghhGjxJKkRjcLW3Jg10/rRztqUxPRr/ON/cZRVqA0dlhBCiBZEkhrRaNzaWPDFlL6YG6vYfSabNyIS0NzznAlCCCGEliQ1olH1crPj35N6o1TA+kOX+Cj6rKFDEkII0UJIUiMaXXB3JxaM7wHAB7+dZtXOcwaOSAghREsgSY0wiCkDPXh5lHYOmyW/JPLFniQDRySEEKK5q1NSs3LlSjw8PDAzMyMwMJCDBw/WWn7jxo34+PhgZmZGz5492bp1a5X9Go2G+fPn4+Ligrm5OcHBwZw5c6ZKmdOnT/PQQw/h4OCAjY0NgwcP5vfff69L+KKJmDXCmxfu9wbgrZ9OsDbmgmEDEkII0azpndRs2LCBsLAwFixYQFxcHH5+foSEhJCZWfNssfv27WPSpElMnz6dI0eOEBoaSmhoKAkJCboy7777Lh999BGrVq3iwIEDWFpaEhISQnFxsa7MuHHjKC8vZ/v27cTGxuLn58e4ceNIT0+vw8cWTcWLwd48N6wzAPN/OM43B5MNHJEQQojmSu+kZtmyZcyYMYNp06bRvXt3Vq1ahYWFBatXr66x/Icffsjo0aOZO3cu3bp146233iIgIIAVK1YA2laa5cuXM2/ePB566CF69erF2rVrSU1NJSIiAoDs7GzOnDnDq6++Sq9evfD29mbJkiUUFRVVSY5E86NQKHglpCt/H+wJwGubj7Hx8CUDRyWEEKI50muV7tLSUmJjYwkPD9dtUyqVBAcHExMTU+MxMTExhIWFVdkWEhKiS1iSkpJIT08nODhYt9/W1pbAwEBiYmJ47LHHsLe3p2vXrqxdu5aAgABMTU359NNPcXR0pE+fPjVet6SkhJKSEt37/Px8QLvkfFmZfhO/VZbX9zhx914Z5UVJWTn/PXCJV77/A3VFGWZInTc2+a43Pqnzxid1bhh1rXd9yuuV1GRnZ1NRUYGTk1OV7U5OTiQmJtZ4THp6eo3lK7uNKp9rK6NQKPjtt98IDQ3F2toapVKJo6MjkZGRtGnTpsbrLl68mEWLFlXbvm3bNiwsLO7i01YXFRVVp+PE3emjgHNOSvZlKHl18wmmdFGA1LlByHe98UmdNz6pc8PQt96LioruuqxeSY2haDQaZs6ciaOjI7t378bc3Jz//Oc/jB8/nkOHDuHi4lLtmPDw8CotRPn5+bi7uzNq1ChsbGz0un5ZWRlRUVGMHDkSY2Pje/484vYeUGt47YfjfB+XytrTSno+0oMH/d0MHVarId/1xid13vikzg2jrvVe2dNyN/RKahwcHFCpVGRkZFTZnpGRgbOzc43HODs711q+8jkjI6NKcpKRkYG/vz8A27dv56effuLq1au6hOTjjz8mKiqKr776ildffbXadU1NTTE1Na223djYuM5f4ns5Vty9d//qT0WFhoijaby86QRF5QqeDPIwdFitinzXG5/UeeOTOjcMfetdn7J6DRQ2MTGhT58+REdH67ap1Wqio6MJCgqq8ZigoKAq5UHb9FRZ3tPTE2dn5ypl8vPzOXDggK5MZdOTUlk1XKVSiVot6we1NCqlgiUP+zLYSY1GA2/8cJwPok7LkgpCCCFqpffdT2FhYXz++ed89dVXnDx5kueee47CwkKmTZsGwOTJk6sMJJ49ezaRkZEsXbqUxMREFi5cyOHDh5k1axagHS8zZ84c3n77bbZs2cKxY8eYPHkyrq6uhIaGAtrEqE2bNkyZMoWjR49y+vRp5s6dS1JSEmPHjq2HahBNjUqp4K+eal4Yrr3d+8PoM8z/4TgVaklshBBC1EzvMTUTJ04kKyuL+fPnk56ejr+/P5GRkbqBvsnJyVVaVAYOHMi6deuYN28er732Gt7e3kRERODr66sr88orr1BYWMjTTz9Nbm4ugwcPJjIyEjMzM0Db7RUZGcnrr7/OiBEjKCsro0ePHvzwww/4+fndax2IJkqhgOdHdKadjRnztxznv/svcqWolGWP+mFqpDJ0eEIIIZqYOg0UnjVrlq6l5VY7duyotm3ChAlMmDDhtudTKBS8+eabvPnmm7ct07dvX3799Ve9YxXN35NBHrSxNOHFDfH8/EcaeUVlrHqyD1amzWKcuxBCiEYiaz+JZmFcL1fWTO2PhYmKPWezefzz/eQUlNz5QCGEEK2GJDWi2Rjs7cA3MwbQxsKYPy7nMWFVDBeyCw0dlhBCiCZCkhrRrPi527Hx2YG0tzPnfHYhD63cy96z2YYOSwghRBMgSY1odrwcrdj8j4H4u9uRd72MyasP8uXeJLnlWwghWjlJakSz5GhjxvqnB/Bw7/ZUqDUs/PEEr20+Rmm5zFskhBCtlSQ1otkyM1ax9FE/wh/wQaGAbw5e4m//OSADiIUQopWSpEY0awqFgmeGdmb1lH5Ymxpx8MIVHlyxl5Npd79WiBBCiJZBkhrRIgz3cWTzzIF0tLcgJfc6j3yyj8iEdEOHJYQQohFJUiNaDC9Ha36YOYhBXvYUlVbw7NexvPXTCRlnI4QQrYQkNaJFsbMw4atp/Zk+2BOAL/YkMeHTGC5dKTJwZEIIIRqaJDWixTFSKXljXHc+n9wXW3Njjl7KZcxHu6U7SgghWjhJakSLNbK7Ez+/MJjeHey4VlzOs1/HsnDLcUrKKwwdmhBCiAYgSY1o0dzaWPDtM0E8M7QTAF/uu8BfP4nhYo4sryCEEC2NJDWixTNWKQl/oBtrpvajjYUxx1LyGPvRHn6ITzF0aEIIIeqRJDWi1Rju48jW2ffRz6MNBSXlzF4fz8x1cVwpLDV0aEIIIeqBJDWiVXGxNeebGQOYE+yNkVLBz3+kMeqDXUSdyDB0aEIIIe6RJDWi1TFSKZkT3IXN/xiEt6MV2QUlzFh7mJc3HiW/uMzQ4QkhhKgjSWpEq9XTzZYfnx/MM0M6oVDAd7GXGf3BLvacyTZ0aEIIIepAkhrRqpkZqwgf042NzwTR0d6C1Lxi/vbFAd6ISKCwpNzQ4QkhhNCDJDVCAH092vLL7Pt4ckBHAP67/yKjPthF9EkZayOEEM2FJDVC3GBhYsRbob78d3p/2tuZk5J7nelfHea5r2NJzys2dHhCCCHuQJIaIW5xn3c7osKG8MzQTqiUCn5JSCd42U6+2neBCrXG0OEJIYS4DUlqhKiBhYkR4Q9046fnB+PvbkdBSTkLthzn4Y/3cjw1z9DhCSGEqIEkNULUopuLDd8/N5C3Qn2xNjXi6OU8Hlyxl//7+QQFMpBYCCGaFElqhLgDlVLBkwM68ttLQxnby4UKtYbPdycx/P0dbDx8CbV0SQkhRJMgSY0Qd8nJxoyVjwewZmo/POwtyLpWwtzv/uAvH+8lLvmqocMTQohWT5IaIfQ03MeRX18cQvgDPljd6JJ6+ON9vLghXu6SEkIIA5KkRog6MDVS8czQzmx/eSiP9nVDoYDNR1IY/v4OVmw/Q3FZhaFDFEKIVkeSGiHugaO1Ge/+1Y8fZg6iT8c2XC+r4P1tp7l/6U42H7ks422EEKIRSVIjRD3o5WbHd88G8eFj/rjYmpGSe50XNxxl7L/3sONUJhqNJDdCCNHQJKkRop4oFAoe8m/P9peG8crorlibGXEyLZ+paw7x+OcHOHop19AhCiFEiyZJjRD1zNxExT+GebFr7nBm3OeJiUpJzPkcHlq5l5n/iyMpu9DQIQohRIskSY0QDaSNpQmvj+3O9peH8kiAdjDxz8fSCF62k/BNx0jJvW7oEIUQokWRpEaIBubWxoKlj/rxy+z7GOHjSIVawzcHkxn23u/MizhGWp4kN0IIUR8kqRGikfg427B6aj++fSaIoE72lFVo+Hp/MkPf3cGCHxLIyJc5boQQ4l7UKalZuXIlHh4emJmZERgYyMGDB2stv3HjRnx8fDAzM6Nnz55s3bq1yn6NRsP8+fNxcXHB3Nyc4OBgzpw5o9u/Y8cOFApFjY9Dhw7V5SMIYTD9PdvyzdMD+GbGAPp7tqW0Qs1XMRe5793fWbjlOJmS3AghRJ3ondRs2LCBsLAwFixYQFxcHH5+foSEhJCZmVlj+X379jFp0iSmT5/OkSNHCA0NJTQ0lISEBF2Zd999l48++ohVq1Zx4MABLC0tCQkJobhY+8N94MCBpKWlVXn8/e9/x9PTk759+9bxowthWEGd7dnw9ADW/T2Qfh5tKC1X8+W+C7rkJlXG3AghhF70TmqWLVvGjBkzmDZtGt27d2fVqlVYWFiwevXqGst/+OGHjB49mrlz59KtWzfeeustAgICWLFiBaBtpVm+fDnz5s3joYceolevXqxdu5bU1FQiIiIAMDExwdnZWfewt7fnhx9+YNq0aSgUirp/eiEMTKFQMNDLgW+fCeK/0/sT0MGOkhvJzdD3fueV745yPqvA0GEKIUSzYKRP4dLSUmJjYwkPD9dtUyqVBAcHExMTU+MxMTExhIWFVdkWEhKiS1iSkpJIT08nODhYt9/W1pbAwEBiYmJ47LHHqp1zy5Yt5OTkMG3atNvGWlJSQklJie59fn4+AGVlZZSVld35w/5JZXl9jxN11xrrfICHHev/3o+9567w6a7z7E+6yreHL7Mx9jIP9HDimSGedHexadAYWmO9G5rUeeOTOjeMuta7PuX1Smqys7OpqKjAycmpynYnJycSExNrPCY9Pb3G8unp6br9ldtuV+ZWX3zxBSEhIbi5ud021sWLF7No0aJq27dt24aFhcVtj6tNVFRUnY4Tddda63ySMwywhN9SlCRcVbI1IYOtCRl0t1Mzsr2aTg2b27TaejckqfPGJ3VuGPrWe1FR0V2X1SupaQouX77Mr7/+yrfffltrufDw8CotRPn5+bi7uzNq1ChsbPT7jVBWVkZUVBQjR47E2Ni4TnEL/Uida80EEtOv8emuJLYmpHMiV8mJXCUBHex4amBHgrs5olLWXxes1HvjkzpvfFLnhlHXeq/sabkbeiU1Dg4OqFQqMjIyqmzPyMjA2dm5xmOcnZ1rLV/5nJGRgYuLS5Uy/v7+1c63Zs0a7O3tefDBB2uN1dTUFFNT02rbjY2N6/wlvpdjRd1InUNP97aseKItF7ILWbXzHJviUohLziUuOZeO9hb8fbAnf+3jjrmJqt6uKfXe+KTOG5/UuWHoW+/6lNVroLCJiQl9+vQhOjpat02tVhMdHU1QUFCNxwQFBVUpD9qmp8rynp6eODs7VymTn5/PgQMHqp1To9GwZs0aJk+eLF9E0ep4OFiy5JFe7Hl1OLOGe2FrbszFnCLe+OE4A5dEs2zbKbKuldz5REII0ULp3f0UFhbGlClT6Nu3L/3792f58uUUFhbqBu1OnjyZ9u3bs3jxYgBmz57N0KFDWbp0KWPHjmX9+vUcPnyYzz77DNDe/TFnzhzefvttvL298fT05I033sDV1ZXQ0NAq196+fTtJSUn8/e9/v8ePLUTz5WhtxsshXfnH8M5sPHyZ/+w5z6Ur1/lo+1lW7TrPX/zbM22wBz7ODTzwRgghmhi9k5qJEyeSlZXF/PnzSU9Px9/fn8jISN1A3+TkZJTKmw1AAwcOZN26dcybN4/XXnsNb29vIiIi8PX11ZV55ZVXKCws5OmnnyY3N5fBgwcTGRmJmZlZlWt/8cUXDBw4EB8fn7p+XiFaDAsTI6YM9OBvAzry6/F0Ptt1nvhLuWw4fIkNhy8R1MmeqYM8CO7mVK/jboQQoqmq00DhWbNmMWvWrBr37dixo9q2CRMmMGHChNueT6FQ8Oabb/Lmm2/Wet1169bpFacQrYFKqWBMTxce8HUm9uJVVu9N4tfjGcSczyHmfA5ubcyZEuTBo33dsbWQblshRMvV7O5+EkLUTKFQ0NejLX092pKSe52v91/km4PJXL56nf/bepJlUad5pE97pgR54O1kbehwhRCi3smClkK0QO3tzPnnaB/2h9/Pkod74uNszfWyCr7en8zID3bx2Gcx/PxHGmUVakOHKoQQ9UZaaoRowcyMVTzWvwMT+7mz//wVvtyXRNSJDPafv8L+81doZ23KpH7uTArsgIutuaHDFUKIeyJJjRCtgEKhIKizPUGd7UnNvc76g8l8c+gSWddK+Gj7WVb8fpbgbk5M6ueGWmPoaIUQom4kqRGilXG1MydsVFeev9+bbccz+O/+C+w/f4VtJzLYdiIDB1MVKdZJTOzfkXbW1SewFEKIpkqSGiFaKWOVkrG9XBjby4UzGdf434Fkvou9THZJOe9HnWF59FlGdndiUv8ODPZyQCm3hQshmjgZKCyEwNvJmoUP9mDvK0OY1LkCf3dbytUafklIZ/Lqgwx9/3dW/n6WzPxiQ4cqhBC3JS01QggdCxMjBjhqeHNMIOdyrrP+4CU2xV3m0pXrvPfrKZZFnWZ4V0ce7evGcB9HjFXyd5EQoumQpEYIUSMfZxsWPtiDVx/wYeuxNL45mMyhC1f57WQGv53MwMHKhIcD3Hi0rxtejjLvjRDC8CSpEULUysxYxcMBbjwc4MbZzAI2Hr7E93EpZBeU8Nmu83y26zwBHex4tK87Y3u5YG0msxYLIQxDkhohxF3zcrQifEw3Xg7pyo5TWWw4dInfT2USl5xLXHIui348wWhfZ/7ax42gTvYyuFgI0agkqRFC6M1YpWRkdydGdnci81oxm+NS+PbwJc5lFbL5SAqbj6TgamvGXwLa80iAG53aWRk6ZCFEKyBJjRDinjham/HM0M48PaQTRy7l8n3sZX48mkpqXjErfz/Hyt/PEdDBjkf6uDGulyu25tI9JYRoGJLUCCHqhUKhIKBDGwI6tOGNcd357WQG38deZufprCrdU8HdHAn1b8+wro6YGMndU0KI+iNJjRCi3pkZqxjXy5VxvVzJzC8mIj6F72NTOJVxja3H0tl6LJ02FsaM6+VKaO/2BHSwQ6GQ8TdCiHsjSY0QokE52pjx9JDOzLivEyfS8tkcl8IPR1PJulbCf/df5L/7L9LR3oJQ//b8pXd7PBwsDR2yEKKZkqRGCNEoFAoFPVxt6eFqy6sP+LDvXA6bj6QQmZDOxZwiPow+w4fRZ/Bzt+MhP1fG+bngaG1m6LCFEM2IJDVCiEZnpFIypEs7hnRpx9uh5Ww7kc6muBT2ns3m6KVcjl7K5e2fTzDIy4EH/VwZ7ess898IIe5IkhohhEFZmhrxl95u/KW3G1nXSvj5j1R+OJrKkeRcdp/JZveZbF6PSCC4myMP+rkyrKsjZsYqQ4cthGiCJKkRQjQZ7axNmTrIk6mDPEnOKWLL0RQi4lM5m1mgG2BsZWrEqB5OjPdzZbCXg6w/JYTQkaRGCNEkdbC3YNYIb2YO9+JEWj5b4lN1899sikthU1wKbSyMeaCnC+N7udLfsy0qmcFYiFZNkhohRJP25wHG/xztw5FLV/nxaBo//ZFGdkEJ6w4ks+5AMo7Wpozp6cK4Xi4EdGgjSzQI0QpJUiOEaDaUSgV9OralT8e2zBvbjQNJV/jxaCq/JKSTea2EL/dd4Mt9F3CxNWNMTxfG9nKht7vMgSNEayFJjRCiWTJSKRnk5cAgLwfefMiXPWez+OmPNKKOZ5CWV8wXe5L4Yk8S7e3MGdvLhbE9XejlZisJjhAtmCQ1Qohmz8RIyQgfJ0b4OFFcVsGu01n8fCyN305kkJJ7nc92neezXedxa2POmJ4ujOnpgp8kOEK0OJLUCCFaFDNjFaN6ODOqhzPFZRXsOJXJj3+ksf1kJpev3kxw2tuZ84CvM2Oki0qIFkOSGiFEi2VmrGK0rwujfV24XqpNcH4+lsb2xExScq/znz1J/GdPEq62Zoz2dWFMT2cZZCxEMyZJjRCiVTA3UfFATxce6Omia8HZeiyd6JMZpOYVs3pvEqv3JuFobcpoX2dG+zrT36MtRjIPjhDNhiQ1QohW588tOMVlFew8nUVkQjq/ncgg81oJa2MusjbmIm0tTQjp4cRoXxcGdraXif6EaOIkqRFCtGpmxipCejgT0sOZkvIK9p3N4ZeENLadyOBKYSnfHLzENwcvYWNmRHA3J0J8nRni3Q5zE1mqQYimRpIaIYS4wdRIxXAfR4b7OPJ/FWoOnL/CLwlp/Ho8g+yCEjYdSWHTkRTMjVUM69qO0b7ODPdxxEYW2xSiSZCkRgghamCsUjLY24HB3tp5cOKSrxKZkE5kQjopudf5JSGdXxLSMVYpGOTlQEgPZ4K7OdHO2tTQoQvRaklSI4QQd6BSKujn0ZZ+HtqZjI+n5msTnOPpnM0sYMepLHacyuI1xTH6dmzDqO7a7qwO9haGDl2IVkWSGiGE0INCocC3vS2+7W15OaQrZzOv8evxDH49ns4fl/M4dOEqhy5c5f+2nsTH2Vo3Xqebi7XMhSNEA5OkRggh7oGXozVejtbMHO5Fau51th1P59fjGRy8cIXE9Gskpl/jw+gzuLUxZ2R3J0Z1d6afRxu5VVyIBiBJjRBC1BNXO3OmDvJk6iBPrhaWEp2Yya/H09l1OovLV6+zZu8F1uy9gJ2FMSN8HBnV3ZkgT1tDhy1Ei1GnPxVWrlyJh4cHZmZmBAYGcvDgwVrLb9y4ER8fH8zMzOjZsydbt26tsl+j0TB//nxcXFwwNzcnODiYM2fOVDvPzz//TGBgIObm5rRp04bQ0NC6hC+EEA2ujaUJf+3jxueT+3Jk/kg+fbIPf+3jRhsLY3KLytgUl8KzX8fSf/EOPk9UsjH2MlnXSgwdthDNmt5JzYYNGwgLC2PBggXExcXh5+dHSEgImZmZNZbft28fkyZNYvr06Rw5coTQ0FBCQ0NJSEjQlXn33Xf56KOPWLVqFQcOHMDS0pKQkBCKi4t1Zb7//nuefPJJpk2bxtGjR9m7dy+PP/54HT6yEEI0LgsTI0J6OPP+BD8OvR7MhqcHMH2wJ+5tzSkpV5NwVclrESfo/85vPPzxXj7ZcY6zmdfQaDSGDl2IZkWh0fN/TWBgIP369WPFihUAqNVq3N3def7553n11VerlZ84cSKFhYX89NNPum0DBgzA39+fVatWodFocHV15aWXXuLll18GIC8vDycnJ7788ksee+wxysvL8fDwYNGiRUyfPr1OHzQ/Px9bW1vy8vKwsbHR69iysjK2bt3KmDFjMDaW+Sgag9S5YUi9Ny6NRsPxy1f5eMseLqnbcCwlv8p+TwdLgrs5MrK7MwEd7GQcTj2R77lh1LXe9fn9rdeYmtLSUmJjYwkPD9dtUyqVBAcHExMTU+MxMTExhIWFVdkWEhJCREQEAElJSaSnpxMcHKzbb2trS2BgIDExMTz22GPExcWRkpKCUqmkd+/epKen4+/vz3vvvYevr2+N1y0pKaGk5GZTbn6+9odFWVkZZWVl+nxsXXl9jxN1J3VuGFLvja+TvRkhbhpGjuxDzvUKtidmEZ2YScz5KyRlF/L57iQ+352Enbkxw7o4MMKnHYO9HLA2kyGRdSXfc8Ooa73rU16v/xXZ2dlUVFTg5ORUZbuTkxOJiYk1HpOenl5j+fT0dN3+ym23K3P+/HkAFi5cyLJly/Dw8GDp0qUMGzaM06dP07Zt22rXXbx4MYsWLaq2fdu2bVhY1G3uiKioqDodJ+pO6twwpN4bX2Wd2wGPOMDYNpCYq+DYFQUnchXkXi8j4mgaEUfTUCk0eNlo8G2jwbethrYy31+dyPfcMPSt96Kiorsu2yxSfbVaDcDrr7/OI488AsCaNWtwc3Nj48aNPPPMM9WOCQ8Pr9JClJ+fj7u7O6NGjapT91NUVBQjR46UpspGInVuGFLvje9u6ry8Qk3cpdwbrThZXMgp4lSeglN58P0F8HGyYrhPO4Z3bYdfe1uUSpkPpzbyPTeMutZ7ZU/L3dArqXFwcEClUpGRkVFle0ZGBs7OzjUe4+zsXGv5yueMjAxcXFyqlPH39wfQbe/evbtuv6mpKZ06dSI5ObnG65qammJqWv3PF2Nj4zp/ie/lWFE3UueGIfXe+Gqrc2NjGOTtxCBvJ94YD+eyCog+mcFvJzI5fPEKiRkFJGYU8MnOJBysTBje1ZH7uzlxn7cDlqbN4m9Xg5DvuWHoW+/6lNVr1JmJiQl9+vQhOjpat02tVhMdHU1QUFCNxwQFBVUpD9qmp8rynp6eODs7VymTn5/PgQMHdGX69OmDqakpp06d0pUpKyvjwoULdOzYUZ+PIIQQzV7ndlY8PaQz3z4bxOF5I/lgoh9je7lgbWpEdkEpG2Mv8+zXsfR+M4opqw+yNuYCl67cfRO+EM2V3il8WFgYU6ZMoW/fvvTv35/ly5dTWFjItGnTAJg8eTLt27dn8eLFAMyePZuhQ4eydOlSxo4dy/r16zl8+DCfffYZoJ1yfM6cObz99tt4e3vj6enJG2+8gaurq24eGhsbG5599lkWLFiAu7s7HTt25L333gNgwoQJ9VEPQgjRLLW1NOEvvd34S283SsvVHLpwhd9OZhB9MpPkK0XsPJ3FztNZwHG6OFkxwseJ+7s50ttd7qYSLY/eSc3EiRPJyspi/vz5uruQIiMjdQN9k5OTUSpv/kcZOHAg69atY968ebz22mt4e3sTERFR5a6lV155hcLCQp5++mlyc3MZPHgwkZGRmJmZ6cq89957GBkZ8eSTT3L9+nUCAwPZvn07bdq0uZfPL4QQLYaJkZJBXg4M8nJg/rjunMsq4LeTmWxPzCT24lVOZxRwOqOAVTvPYWdhzNAu7Rjh48jQLu2wszAxdPhC3DO956lprmSemuZF6twwpN4bX2PVeW5RKTtPZ7E9MZMdp7LIu37zNlmlAvp0bMNwH0fu93Gii5NVi158U77nhtHk5qkRQgjRPNlZmPCQf3se8m9PeYWaI5dy+e1kBr8nZnI6o0C3uvi7kadob2fOcB9tK05QJwfMTVSGDl+IuyJJjRBCtDJGKiX9PNrSz6Mt4Q9049KVInac0nZT7TuXQ0rudb7en8zX+5MxNVIS1NmeET6ODO/qiHvbus3zJURjkKRGCCFaOfe2FjwZ5MGTQR5cL60g5nw22xMz+T0xi5Tc6+w4lcWOU9rBxp3bWTK8qyMjfBzp69EWEyMZbCyaDklqhBBC6JibqBjh48QIHyc0Gg1nMgtuJDiZHL54lXNZhZzLSuI/e5KwNFExyMuB4T6ODOvaDhdbc0OHL1o5SWqEEELUSKFQ0MXJmi5O1jw7tDN518vYezab3xMz+f1UFtkFJWw7kcG2E9oJVn2crRnatR3DuzrSp2MbjOWWcdHIJKkRQghxV2zNjRnT04UxPV1QqzUcT81nx6lMfj+VyZFLuSSmXyMx/Rqf7jyPtakRg7wcGNa1HcO6OuJsa3bnCwhxjySpEUIIoTelUkFPN1t6utny/P3eXC0sZdcZ7dibnaezuFJYSuTxdCKPaxcmrmzFGdZF24ojY3FEQ5CkRgghxD1rY3nzlnG1WsMfKXnsOKWdE+fo5aqtOFamRgzsbM+wro4M7dqO9nYyFkfUD0lqhBBC1CulUoG/ux3+7nbMCe7ClcJSdt9oxdl1OoucwtIqY3G8Ha0Y2qUdQ7u2o59HW8yMZV4cUTeS1AghhGhQbW9pxTmWknejmyqT+Eu5nMks4ExmAf/Zk4S5sYqgzvbaJKdLOzwcLA0dvmhGJKkRQgjRaJRKBX7udvi52zE72JvcolL2nM1m542xOJnXStieqJ0IEKBDWwuGdmnHkC7tCOpsj5Wp/NoStyffDiGEEAZjZ2HCuF6ujOvlikajITH9mnZl8VNZHL54heQrRfx3/0X+u/8ixioFfTq2YUiXdgzxbkd3FxuUypa7RpXQnyQ1QgghmgSFQkE3Fxu6udjw7NDOFJaUE3Muh52ns9h1JouLOUXsP3+F/eev8G7kKRysTLnP24EhXRy4z7sdDlamhv4IwsAkqRFCCNEkWZoaEdzdieDuTgBcyC5k1xntYON953LILihh85EUNh9JAaCHqw33ebdjSBcH+naUJRxaI0lqhBBCNAseDpZ4OFgyOciDkvIKYi9eZfeZbHadzuJ4ar7usWrnOSxMVAR1suc+bwfu69KOTg6WKBTSVdXSSVIjhBCi2TE1UjGwswMDOzvwz9E+ZF0rYc/ZLHafzmbXmWyyC0qITswk+saA4/Z25toEx7sd/TvaGjh60VAkqRFCCNHstbM25S+93fhLbzfUag0n0/PZfSab3WeyOJR0lZTc66w/dIn1hy6hVIC7pYpTJmcZ2tWR3h1khuOWQpIaIYQQLYpSqaCHqy09XG15dmhnrpdWcCApR9dVdSazgIsFCj7eeZ6Pd57H0kTFgBtdVYO929G5nXRVNVeS1AghhGjRzE1UDOvqyLCujgAkZ1/jk82/c82iPfvOX+FKYWmVripXWzMG30hwBnW2x17uqmo2JKkRQgjRqrjYmjHAUcOYMb1QqYw4kabtqtpzVttVlZpXzLeHL/Pt4cuA9q6qwd4O3OfVjr4ebWQZhyZMkhohhBCtllKpwLe9Lb7tbXlumLar6uCFK+w5k8XuM9kkpl/T3VX16c7zmBop6e/ZlsFeDgzycpAJAJsYSWqEEEKIG8xNVLp1pwAyrxWz72yOriUnI7/kxgDkbADaWBgz0MuB+24kOe5tLQwZfqsnSY0QQghxG47WZoT2bk9o7/ZoNBrOZhaw+0w2e89ms/98DleLyvj5jzR+/iMNgI72FgzycmCwlwNBnexpY2li4E/QukhSI4QQQtwFhUKBt5M13k7WPDXYk7IKNUcv5eqSnCOXcrmYU8TFnGTWHUhGoQBfV1sGetkz2MuBfh5tZTxOA5OkRgghhKgDY5WSvh5t6evRlhdHduFacRkHk66w+0w2+85lczqjgGMpeRxLyePTnecxMVLSt2MbBnk5MLCzPT3b22Kkkvlx6pMkNUIIIUQ9sDYz5v5uTtzfTbtWVWZ+MXvPZbP3bA57z2aTllfMvnM57DuXc6O8EYGe9gzysmeQlwPejlYyP849kqRGCCGEaACONma6WY41Gg3nswvZdzabPWeziTmXQ35xOb+dzOC3kxmAdlbkgZ3tGdTZgYFe9ri1kUHH+pKkRgghhGhgCoWCzu2s6NzOiieDPKhQaziemsfesznsO5fNwaQrZF0r4Yf4VH6ITwW0g44HdrZnYGcHgjrb4yCTAN6RJDVCCCFEI1MpFfRys6OXmx3PDetMSXkFcRdz2XtWOx7n6OW8G4OOi/jm4CUAfJytCbrRktO/U1tszIwN/CmaHklqhBBCCAMzNVIR1NmeoM72QFfdoON957TjcRLTr+kea/ZeQKmAnm52N1py7OnbsS3mJnJnlSQ1QgghRBNz66Dj7IIS9p/PYe/ZHPafzyEpu5Cjl3I5eimXT3acw1iloHeHNgzsbE9QJ3v8O9hhatT6khxJaoQQQogmzsHKlHG9XBnXyxWA1NzrxNy4kyrmXDapecUcTLrCwaQrLOcMZsZK+nZsq2v96dVKbh+XpEYIIYRoZlztzHmkjxuP9NHeWXUxp4iY8zm6mY6zC0rZc+NOKwBLExX9PW8kOZ0c6O5qg6oFrlklSY0QQgjRjCkUCjwcLPFwsGRS/w665Ry0rTg57E/KIbeojN9PZfH7qSwAbMyM6O9pz4BO2kSnm3PLWJhTkhohhBCiBfnzcg5TBnqgVms4mZ5PzI0k52DSlWpz5NhZGBPo2ZagTvYM6GxPF0frZpnk1KmDbeXKlXh4eGBmZkZgYCAHDx6stfzGjRvx8fHBzMyMnj17snXr1ir7NRoN8+fPx8XFBXNzc4KDgzlz5kyVMh4eHigUiiqPJUuW1CV8IYQQotVQKhX0cLXl7/d14oup/TgyfyQ/zBxE+AM+DOvaDksTFblFZfx6PIOFP55g9PLd9P2/33ju61i+2neB0xnX0Gg0hv4Yd0XvlpoNGzYQFhbGqlWrCAwMZPny5YSEhHDq1CkcHR2rld+3bx+TJk1i8eLFjBs3jnXr1hEaGkpcXBy+vr4AvPvuu3z00Ud89dVXeHp68sYbbxASEsKJEycwMzPTnevNN99kxowZuvfW1tZ1+cxCCCFEq2WkUuLnboefux3PDO1MWYWaYyl52q6q8zkcvnCVK4Wl/JKQzi8J6QDYW5oQ2KktAzrZM6CTfZNd0kHvpGbZsmXMmDGDadOmAbBq1Sp+/vlnVq9ezauvvlqt/Icffsjo0aOZO3cuAG+99RZRUVGsWLGCVatWodFoWL58OfPmzeOhhx4CYO3atTg5OREREcFjjz2mO5e1tTXOzs51+qBCCCGEqM5YpSSgQxsCOrRh5nAvSsvVHEvJZf/5K+w/n8OhC1fIKSxl67F0th6rnuQEemqTnKbQXaVXUlNaWkpsbCzh4eG6bUqlkuDgYGJiYmo8JiYmhrCwsCrbQkJCiIiIACApKYn09HSCg4N1+21tbQkMDCQmJqZKUrNkyRLeeustOnTowOOPP86LL76IkVHNH6GkpISSkhLd+/z8fADKysooKyvT52Pryut7nKg7qXPDkHpvfFLnjU/qvHYKoJerNb1crXl6cMcbSU4e+5OucvDCFeKSc6slOW0sjOnv0YZAz7Y83t+9xjur6lrv+pTXK6nJzs6moqICJyenKtudnJxITEys8Zj09PQay6enp+v2V267XRmAF154gYCAANq2bcu+ffsIDw8nLS2NZcuW1XjdxYsXs2jRomrbt23bhoVF3RYJi4qKqtNxou6kzg1D6r3xSZ03Pqlz/XgCno7wiAMkF8DZfAVn8xUkXVNwtaiMX09kcvhcBvZXEmo9j771XlRUdNdlm83dT39u7enVqxcmJiY888wzLF68GFPT6ot8hYeHVzkmPz8fd3d3Ro0ahY2NjV7XLisrIyoqipEjR2JsLGttNAapc8OQem98UueNT+q8fpWWq0lIzedA0hVMjZSMGeRRY7m61ntlT8vd0CupcXBwQKVSkZGRUWV7RkbGbce6ODs711q+8jkjIwMXF5cqZfz9/W8bS2BgIOXl5Vy4cIGuXbtW229qalpjsmNsbFznL/G9HCvqRurcMKTeG5/UeeOTOq8fxsYQ2LkdgZ3b3WV5/epdn7J63dJtYmJCnz59iI6O1m1Tq9VER0cTFBRU4zFBQUFVyoO26amyvKenJ87OzlXK5Ofnc+DAgdueEyA+Ph6lUlnjHVdCCCGEaH307n4KCwtjypQp9O3bl/79+7N8+XIKCwt1d0NNnjyZ9u3bs3jxYgBmz57N0KFDWbp0KWPHjmX9+vUcPnyYzz77DNBOEjRnzhzefvttvL29dbd0u7q6EhoaCmgHGx84cIDhw4djbW1NTEwML774In/7299o06ZNPVWFEEIIIZozvZOaiRMnkpWVxfz580lPT8ff35/IyEjdQN/k5GSUypsNQAMHDmTdunXMmzeP1157DW9vbyIiInRz1AC88sorFBYW8vTTT5Obm8vgwYOJjIzUzVFjamrK+vXrWbhwISUlJXh6evLiiy9Wu6tKCCGEEK1XnQYKz5o1i1mzZtW4b8eOHdW2TZgwgQkTJtz2fAqFgjfffJM333yzxv0BAQHs37+/LqEKIYQQopVo+euQCyGEEKJVkKRGCCGEEC2CJDVCCCGEaBEkqRFCCCFEiyBJjRBCCCFaBElqhBBCCNEiSFIjhBBCiBZBkhohhBBCtAiS1AghhBCiRajTjMLNkUajAfRbwrxSWVkZRUVF5Ofny4qujUTq3DCk3huf1Hnjkzo3jLrWe+Xv7crf47VpNUnNtWvXAHB3dzdwJEIIIYTQ17Vr17C1ta21jEJzN6lPC6BWq0lNTcXa2hqFQqHXsfn5+bi7u3Pp0iVsbGwaKELxZ1LnhiH13vikzhuf1Llh1LXeNRoN165dw9XVtcqC2TVpNS01SqUSNze3ezqHjY2N/AdoZFLnhiH13vikzhuf1Llh1KXe79RCU0kGCgshhBCiRZCkRgghhBAtgiQ1d8HU1JQFCxZgampq6FBaDalzw5B6b3xS541P6twwGqPeW81AYSGEEEK0bNJSI4QQQogWQZIaIYQQQrQIktQIIYQQokWQpEYIIYQQLYIkNXdh5cqVeHh4YGZmRmBgIAcPHjR0SC3arl27GD9+PK6urigUCiIiIgwdUou2ePFi+vXrh7W1NY6OjoSGhnLq1ClDh9XiffLJJ/Tq1Us3EVlQUBC//PKLocNqVZYsWYJCoWDOnDmGDqXFWrhwIQqFosrDx8enwa4nSc0dbNiwgbCwMBYsWEBcXBx+fn6EhISQmZlp6NBarMLCQvz8/Fi5cqWhQ2kVdu7cycyZM9m/fz9RUVGUlZUxatQoCgsLDR1ai+bm5saSJUuIjY3l8OHDjBgxgoceeojjx48bOrRW4dChQ3z66af06tXL0KG0eD169CAtLU332LNnT4NdS27pvoPAwED69evHihUrAO0aUu7u7jz//PO8+uqrBo6u5VMoFGzevJnQ0FBDh9JqZGVl4ejoyM6dOxkyZIihw2lV2rZty3vvvcf06dMNHUqLVlBQQEBAAB9//DFvv/02/v7+LF++3NBhtUgLFy4kIiKC+Pj4RrmetNTUorS0lNjYWIKDg3XblEolwcHBxMTEGDAyIRpOXl4eoP0FKxpHRUUF69evp7CwkKCgIEOH0+LNnDmTsWPHVvnZLhrOmTNncHV1pVOnTjzxxBMkJyc32LVazYKWdZGdnU1FRQVOTk5Vtjs5OZGYmGigqIRoOGq1mjlz5jBo0CB8fX0NHU6Ld+zYMYKCgiguLsbKyorNmzfTvXt3Q4fVoq1fv564uDgOHTpk6FBahcDAQL788ku6du1KWloaixYt4r777iMhIQFra+t6v54kNUIInZkzZ5KQkNCgfd7ipq5duxIfH09eXh7fffcdU6ZMYefOnZLYNJBLly4xe/ZsoqKiMDMzM3Q4rcIDDzyge92rVy8CAwPp2LEj3377bYN0s0pSUwsHBwdUKhUZGRlVtmdkZODs7GygqIRoGLNmzeKnn35i165duLm5GTqcVsHExAQvLy8A+vTpw6FDh/jwww/59NNPDRxZyxQbG0tmZiYBAQG6bRUVFezatYsVK1ZQUlKCSqUyYIQtn52dHV26dOHs2bMNcn4ZU1MLExMT+vTpQ3R0tG6bWq0mOjpa+r1Fi6HRaJg1axabN29m+/bteHp6GjqkVkutVlNSUmLoMFqs+++/n2PHjhEfH6979O3blyeeeIL4+HhJaBpBQUEB586dw8XFpUHOLy01dxAWFsaUKVPo27cv/fv3Z/ny5RQWFjJt2jRDh9ZiFRQUVMnik5KSiI+Pp23btnTo0MGAkbVMM2fOZN26dfzwww9YW1uTnp4OgK2tLebm5gaOruUKDw/ngQceoEOHDly7do1169axY8cOfv31V0OH1mJZW1tXGytmaWmJvb29jCFrIC+//DLjx4+nY8eOpKamsmDBAlQqFZMmTWqQ60lScwcTJ04kKyuL+fPnk56ejr+/P5GRkdUGD4v6c/jwYYYPH657HxYWBsCUKVP48ssvDRRVy/XJJ58AMGzYsCrb16xZw9SpUxs/oFYiMzOTyZMnk5aWhq2tLb169eLXX39l5MiRhg5NiHpz+fJlJk2aRE5ODu3atWPw4MHs37+fdu3aNcj1ZJ4aIYQQQrQIMqZGCCGEEC2CJDVCCCGEaBEkqRFCCCFEiyBJjRBCCCFaBElqhBBCCNEiSFIjhBBCiBZBkhohhBBCtAiS1AghhBCiRZCkRgghhBAtgiQ1QgghhGgRJKkRQgghRIsgSY0QQgghWoT/B1lHvGH2relgAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FVm-FYPx3qcl",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        },
        "outputId": "4f143717-8cdc-4531-fc43-40a8f34b01ee"
      },
      "source": [
        "# Гибрид (интерполяция дискретной модели)\n",
        "# Используем пример из дискретной модели выше. Определим, каким должны быть интенсивности дефолтов при условии, что внутри каждого платежного периода интенсивность постоянна\n",
        "\n",
        "dates =np.arange('2011-01', '2014-07', dtype='datetime64[6M]').astype('datetime64[D]') # первая дата - момент выдачи кредита, остальные - даты платежей, когда может произойти дефолт\n",
        "pd_cm  = np.array([0, .03, .06, .09, .12, .15, .18]) # Значения функции распределения в даты\n",
        "\n",
        "pd_fwd = (pd_cm[1:] - pd_cm[:-1])/(1 - pd_cm[:-1]) # значения форвардных PD на каждом участке\n",
        "terms = (dates[1:] - dates[:-1]).astype('float')/365 # значения сроков (x) между платежами в годах для вычисления интенсивностей\n",
        "\n",
        "hzr_imp =  - np.log(1 - pd_fwd)/terms # implied hazards для кусочно-постоянной интенсивности, решаем уравнение для каждого периода относительно интенсивности\n",
        "print('Реальная форвардная PD = {:.2%}, интерполировная форвардная PD = {:.2%}'.format(pd_fwd[0], 1 - np.exp(-hzr_imp[0]*terms[0])))\n",
        "\n",
        "display(pd.DataFrame({'dates':dates[:-1], 'hzrds': hzr_imp, 'pd_fwd': pd_fwd, 'pd_cm': pd_cm[1:]}))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Реальная форвардная PD = 3.00%, интерполировная форвардная PD = 3.00%\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "       dates     hzrds    pd_fwd  pd_cm\n",
              "0 2011-01-01  0.061423  0.030000   0.03\n",
              "1 2011-07-01  0.062320  0.030928   0.06\n",
              "2 2012-01-01  0.065049  0.031915   0.09\n",
              "3 2012-07-01  0.066499  0.032967   0.12\n",
              "4 2013-01-01  0.069946  0.034091   0.15\n",
              "5 2013-07-01  0.071278  0.035294   0.18"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-7df32079-626c-427e-86df-d5791d026953\" 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>dates</th>\n",
              "      <th>hzrds</th>\n",
              "      <th>pd_fwd</th>\n",
              "      <th>pd_cm</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>2011-01-01</td>\n",
              "      <td>0.061423</td>\n",
              "      <td>0.030000</td>\n",
              "      <td>0.03</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>2011-07-01</td>\n",
              "      <td>0.062320</td>\n",
              "      <td>0.030928</td>\n",
              "      <td>0.06</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2012-01-01</td>\n",
              "      <td>0.065049</td>\n",
              "      <td>0.031915</td>\n",
              "      <td>0.09</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>2012-07-01</td>\n",
              "      <td>0.066499</td>\n",
              "      <td>0.032967</td>\n",
              "      <td>0.12</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>2013-01-01</td>\n",
              "      <td>0.069946</td>\n",
              "      <td>0.034091</td>\n",
              "      <td>0.15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>2013-07-01</td>\n",
              "      <td>0.071278</td>\n",
              "      <td>0.035294</td>\n",
              "      <td>0.18</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-7df32079-626c-427e-86df-d5791d026953')\"\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-7df32079-626c-427e-86df-d5791d026953 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-7df32079-626c-427e-86df-d5791d026953');\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-c9e35cf8-46ae-4905-b0dc-a6dd2592c3ba\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-c9e35cf8-46ae-4905-b0dc-a6dd2592c3ba')\"\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-c9e35cf8-46ae-4905-b0dc-a6dd2592c3ba button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GpvuLS4ARlfm"
      },
      "source": [
        "## 1.3 Арифметика EAD\n",
        "\n",
        "Основные параметры:\n",
        "\n",
        "* расписание платежей,\n",
        "* правила погашения (есть ли амортизация),\n",
        "* определение очередного платежа (конверция счета дней),\n",
        "* учет накопленного купона.  \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z6V5rYHF0wda",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "c40c0712-81ae-4d47-da61-a0d843f67b51"
      },
      "source": [
        "# Место для кода\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from scipy import signal\n",
        "\n",
        "# Место для кода\n",
        "\n",
        "# Рассмотрим кредит, который погашается в единовременно в конце срока и по которому уплачивается полугодовой процент.\n",
        "\n",
        "V = 10000\n",
        "s = 5 # срок в годах\n",
        "r = 5 # процентная ставка в % годовых; начисление дискретное; конвенция счета дней: act/365;\n",
        "m = 2 # столько раз в год; каждые полгода (не то же самое, что каждые 182 дня)\n",
        "\n",
        "# Составим таблицу (график) платежей\n",
        "dates_int = np.arange('2011-01-01', '2016-07-01', dtype='datetime64[6M]').astype('datetime64[D]') #даты выплат по кредиту\n",
        "\n",
        "# будем заполнять поля:\n",
        "  # terms - срок с начала кредита\n",
        "  # due - непогашенный остаток основного долга\n",
        "  # interest - сумма очередной процентной выплаты\n",
        "  # EAD - экспозиция при дефолте\n",
        "data = pd.DataFrame(np.nan, index = dates_int, columns = ['term', 'due', 'interest',  'EAD'])\n",
        "data.iloc[0,:] = [0,  V, 0 , V] # в момент выдачи кредита EAD = объему кредита без процентов\n",
        "\n",
        "# Заполняем записи в даты выплат\n",
        "data['term'][1:] = (dates_int[1:] - dates_int[:-1]).astype('float')/365 # срок вычисляем в годах в соответствии с конвенцией счета дней (ставка процента расчитана на 365 дней, а сумма платежа вычисляется из количества фактически прошедших дней)\n",
        "data['due'] = V # по условию кредит погашается целиком в конце, поэтому основной долг не уменьшается и равен объему выданного кредита\n",
        "data['interest'][1:] = (r/100)*V*data['term'][1:] # проценты определяются пропорционально сроку\n",
        "data['EAD'] = data['due'] + data['interest'] # EAD склатывается из суммы основного долга + накопленный процент\n",
        "\n",
        "display(data)\n",
        "\n",
        "# Посмотрим на график EAD от времени. Обращаем внимание, что экспозиция снижается сразу после уплаты процента, и возрастает по мере накопленния следующего\n",
        "\n",
        "# Подготовим точки\n",
        "time_plt = np.repeat(data.index, 2)[1:] # дублируем даты, чтобы увидеть скачки EAD\n",
        "EAD_plt = np.repeat(data.EAD, 2)[1:] # локальных максимумов EAD достигает в дни уплаты процента, т.е. когда сумма накопленного процента максимальна\n",
        "EAD_plt[0:-1:2] = data.due[1:] # после очередной выплаты процента EAD падает до оставшейся суммы основного долга (если кредит погашается, эта часть постепенно снижается)\n",
        "EAD_plt[-1] = 0 #если кредит погашен, то EAD становится равно 0.\n",
        "\n",
        "# Рисуем график\n",
        "plt.figure(figsize = (10,7))\n",
        "plt.plot(time_plt, EAD_plt)\n",
        "plt.title('График EAD для кредита, погашаемго в конце срока и очередные проценты по которому включаются в требования к должнику')\n",
        "plt.show()\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-6-4a56fd0bcdd4>:31: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  data['interest'][1:] = (r/100)*V*data['term'][1:] # проценты определяются пропорционально сроку\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "               term    due    interest           EAD\n",
              "2011-01-01  0.00000  10000    0.000000  10000.000000\n",
              "2011-07-01  0.49589  10000  247.945205  10247.945205\n",
              "2012-01-01  0.50411  10000  252.054795  10252.054795\n",
              "2012-07-01  0.49863  10000  249.315068  10249.315068\n",
              "2013-01-01  0.50411  10000  252.054795  10252.054795\n",
              "2013-07-01  0.49589  10000  247.945205  10247.945205\n",
              "2014-01-01  0.50411  10000  252.054795  10252.054795\n",
              "2014-07-01  0.49589  10000  247.945205  10247.945205\n",
              "2015-01-01  0.50411  10000  252.054795  10252.054795\n",
              "2015-07-01  0.49589  10000  247.945205  10247.945205\n",
              "2016-01-01  0.50411  10000  252.054795  10252.054795"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-532c7b97-be93-494b-986d-c22e87c261dc\" 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>term</th>\n",
              "      <th>due</th>\n",
              "      <th>interest</th>\n",
              "      <th>EAD</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2011-01-01</th>\n",
              "      <td>0.00000</td>\n",
              "      <td>10000</td>\n",
              "      <td>0.000000</td>\n",
              "      <td>10000.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2011-07-01</th>\n",
              "      <td>0.49589</td>\n",
              "      <td>10000</td>\n",
              "      <td>247.945205</td>\n",
              "      <td>10247.945205</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2012-01-01</th>\n",
              "      <td>0.50411</td>\n",
              "      <td>10000</td>\n",
              "      <td>252.054795</td>\n",
              "      <td>10252.054795</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2012-07-01</th>\n",
              "      <td>0.49863</td>\n",
              "      <td>10000</td>\n",
              "      <td>249.315068</td>\n",
              "      <td>10249.315068</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2013-01-01</th>\n",
              "      <td>0.50411</td>\n",
              "      <td>10000</td>\n",
              "      <td>252.054795</td>\n",
              "      <td>10252.054795</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2013-07-01</th>\n",
              "      <td>0.49589</td>\n",
              "      <td>10000</td>\n",
              "      <td>247.945205</td>\n",
              "      <td>10247.945205</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2014-01-01</th>\n",
              "      <td>0.50411</td>\n",
              "      <td>10000</td>\n",
              "      <td>252.054795</td>\n",
              "      <td>10252.054795</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2014-07-01</th>\n",
              "      <td>0.49589</td>\n",
              "      <td>10000</td>\n",
              "      <td>247.945205</td>\n",
              "      <td>10247.945205</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2015-01-01</th>\n",
              "      <td>0.50411</td>\n",
              "      <td>10000</td>\n",
              "      <td>252.054795</td>\n",
              "      <td>10252.054795</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2015-07-01</th>\n",
              "      <td>0.49589</td>\n",
              "      <td>10000</td>\n",
              "      <td>247.945205</td>\n",
              "      <td>10247.945205</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2016-01-01</th>\n",
              "      <td>0.50411</td>\n",
              "      <td>10000</td>\n",
              "      <td>252.054795</td>\n",
              "      <td>10252.054795</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-532c7b97-be93-494b-986d-c22e87c261dc')\"\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-532c7b97-be93-494b-986d-c22e87c261dc 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-532c7b97-be93-494b-986d-c22e87c261dc');\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-b5471108-ee24-4ed8-ac0b-e0de6adf717d\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-b5471108-ee24-4ed8-ac0b-e0de6adf717d')\"\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-b5471108-ee24-4ed8-ac0b-e0de6adf717d button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Определим EAD на произвольную дату\n",
        "\n",
        "dt = np.datetime64('2011-03-08') # Предположим, что дефолт объявлен 8 марта 2011 года\n",
        "# EAD будет складываться из суммы непогашенного долга с момента последнего платежа и накопленного процента пропорционально сроку прошедшего также с момента уплаты последнего платежа\n",
        "\n",
        "# Определим, в какой платежный период произошел дефолт\n",
        "n = 1\n",
        "print('Дата очередного платежа: ', data.index[n]) # дата ближайшего платежа\n",
        "\n",
        "# Определим размер платежа\n",
        "accr_pr =  (dt - data.index[n-1]).days/365 # период до дефолта, за который успел накопиться очередной процент\n",
        "print('EAD на дату {:} равно {:.2f}'.format(dt, data.due[n] + data.interest[n]*accr_pr/data.term[n])) # вклад процента в EAD опеределяется пропорционально доли периода, порошедшего до дефолта."
      ],
      "metadata": {
        "id": "C9_XEVKBUTw1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b63c8abc-9df6-4e7b-efd3-0e37caa7fc74"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Дата очередного платежа:  2011-07-01 00:00:00\n",
            "EAD на дату 2011-03-08 равно 10090.41\n"
          ]
        }
      ]
    }
  ]
}