UnivRNNModels.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "UnivRNNModels.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iOUcR3P_T5to"
      },
      "source": [
        "## 1) Importing libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KsTYD-aBT6pO"
      },
      "source": [
        "#pip install Keras==2.3.1 tensorflow==2.1.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rIC6C4UrTx0a"
      },
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "sns.set_style(\"whitegrid\")\n",
        "sns.set_palette(\"GnBu_d\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a4gqS1JfUAn8"
      },
      "source": [
        "## 2) Data Preparation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GRQ6PTGjSUqr"
      },
      "source": [
        "eurtnd=pd.read_csv(\"/content/drive/My Drive/eurtnd.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UgHCB4gNs2hC"
      },
      "source": [
        "eurtnd.dropna(inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XoJ5klNGYbah",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "337daba1-19e1-4d47-ff5f-f2e8fec48df5"
      },
      "source": [
        "eurtnd.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>Date</th>\n",
              "      <th>Dernier Prix</th>\n",
              "      <th>Date.1</th>\n",
              "      <th>Dernier Prix.1</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>7/22/2020</td>\n",
              "      <td>3.2330</td>\n",
              "      <td>7/22/2020</td>\n",
              "      <td>2.8054</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>7/21/2020</td>\n",
              "      <td>3.2313</td>\n",
              "      <td>7/21/2020</td>\n",
              "      <td>2.8050</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>7/20/2020</td>\n",
              "      <td>3.2213</td>\n",
              "      <td>7/20/2020</td>\n",
              "      <td>2.8122</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>7/19/2020</td>\n",
              "      <td>3.2304</td>\n",
              "      <td>7/17/2020</td>\n",
              "      <td>2.8196</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>7/17/2020</td>\n",
              "      <td>3.2284</td>\n",
              "      <td>7/16/2020</td>\n",
              "      <td>2.8243</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        Date  Dernier Prix     Date.1  Dernier Prix.1\n",
              "0  7/22/2020        3.2330  7/22/2020          2.8054\n",
              "1  7/21/2020        3.2313  7/21/2020          2.8050\n",
              "2  7/20/2020        3.2213  7/20/2020          2.8122\n",
              "3  7/19/2020        3.2304  7/17/2020          2.8196\n",
              "4  7/17/2020        3.2284  7/16/2020          2.8243"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pAdV2HTYSbaE"
      },
      "source": [
        "eurtnd=eurtnd[[\"Date\",\"Dernier Prix.1\"]]\n",
        "eurtnd=eurtnd.reindex(index=eurtnd.index[::-1])\n",
        "date=pd.to_datetime(eurtnd.Date, format='%m/%d/%Y')\n",
        "date=date.values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6-B43_JZFqBs"
      },
      "source": [
        "eurtnd['diff']=eurtnd['Dernier Prix.1'].diff()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TfMKYmgTTlzp"
      },
      "source": [
        "------------------"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XcOKqPgOT4mg"
      },
      "source": [
        "eurmad=pd.read_csv(\"/content/drive/My Drive/currencydata/eurmad10.csv\")\n",
        "eurtnd=pd.read_csv(\"/content/drive/My Drive/currencydata/eurtnd10.csv\")\n",
        "usdmad=pd.read_csv(\"/content/drive/My Drive/currencydata/usdmad10.csv\")\n",
        "usdtnd=pd.read_csv(\"/content/drive/My Drive/currencydata/usdtnd10.csv\")\n",
        "eurusd=pd.read_csv(\"/content/drive/My Drive/currencydata/eurusd10.csv\")\n",
        "\n",
        "eurusd.drop('Variation %', axis=1, inplace=True)\n",
        "eurtnd.drop('Variation %', axis=1, inplace=True)\n",
        "usdtnd.drop('Variation %', axis=1, inplace=True)\n",
        "eurmad.drop('Variation %', axis=1, inplace=True)\n",
        "usdmad.drop('Variation %', axis=1, inplace=True)\n",
        "\n",
        "eurmad=eurmad.reindex(index=eurmad.index[::-1])\n",
        "eurtnd=eurtnd.reindex(index=eurtnd.index[::-1])\n",
        "usdmad=usdmad.reindex(index=usdmad.index[::-1])\n",
        "usdtnd=usdtnd.reindex(index=usdtnd.index[::-1])\n",
        "eurusd=eurusd.reindex(index=eurusd.index[::-1])\n",
        "\n",
        "date=pd.to_datetime(eurmad.Date, format='%d/%m/%Y')\n",
        "date=date.values\n",
        "\n",
        "eurmad.Date = pd.to_datetime(eurmad.Date, format='%d/%m/%Y')\n",
        "eurtnd.Date = pd.to_datetime(eurtnd.Date, format='%d/%m/%Y')\n",
        "usdmad.Date = pd.to_datetime(usdmad.Date, format='%d/%m/%Y')\n",
        "usdtnd.Date = pd.to_datetime(usdtnd.Date, format='%d/%m/%Y')\n",
        "eurusd.Date = pd.to_datetime(eurusd.Date, format='%d/%m/%Y')\n",
        "\n",
        "eurmad.set_index('Date', inplace=True)\n",
        "eurtnd.set_index('Date', inplace=True)\n",
        "usdmad.set_index('Date', inplace=True)\n",
        "usdtnd.set_index('Date', inplace=True)\n",
        "eurusd.set_index('Date', inplace=True)\n",
        "\n",
        "eurusd= eurusd.astype(str)\n",
        "eurtnd= eurtnd.astype(str)\n",
        "eurmad= eurmad.astype(str)\n",
        "usdtnd= usdtnd.astype(str)\n",
        "usdmad= usdmad.astype(str)\n",
        "\n",
        "for i in eurusd.columns:\n",
        "    eurusd[i]= eurusd[i].str.replace(',', '.').astype(float)\n",
        "    eurtnd[i]= eurtnd[i].str.replace(',', '.').astype(float)\n",
        "    eurmad[i]= eurmad[i].str.replace(',', '.').astype(float)\n",
        "    usdtnd[i]= usdtnd[i].str.replace(',', '.').astype(float)\n",
        "    usdmad[i]= usdmad[i].str.replace(',', '.').astype(float)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kS9mYT53T9-v"
      },
      "source": [
        "eurtnd['diff']=eurtnd['Dernier Prix'].diff()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vkf1kt83VJIC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 238
        },
        "outputId": "8b9b6d9c-01c3-4be2-82a1-22ed6ca9e407"
      },
      "source": [
        "eurtnd.tail()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>Dernier</th>\n",
              "      <th>Ouv.</th>\n",
              "      <th>Plus Haut</th>\n",
              "      <th>Plus Bas</th>\n",
              "      <th>diff</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Date</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>2020-07-20</th>\n",
              "      <td>3.2278</td>\n",
              "      <td>3.2271</td>\n",
              "      <td>3.2624</td>\n",
              "      <td>3.2074</td>\n",
              "      <td>0.0003</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2020-07-21</th>\n",
              "      <td>3.2276</td>\n",
              "      <td>3.2294</td>\n",
              "      <td>3.2524</td>\n",
              "      <td>3.2084</td>\n",
              "      <td>-0.0002</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2020-07-22</th>\n",
              "      <td>3.2327</td>\n",
              "      <td>3.2274</td>\n",
              "      <td>3.2606</td>\n",
              "      <td>3.2087</td>\n",
              "      <td>0.0051</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2020-07-23</th>\n",
              "      <td>3.2240</td>\n",
              "      <td>3.2341</td>\n",
              "      <td>3.2589</td>\n",
              "      <td>3.2043</td>\n",
              "      <td>-0.0087</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2020-07-24</th>\n",
              "      <td>3.2290</td>\n",
              "      <td>3.2243</td>\n",
              "      <td>3.2506</td>\n",
              "      <td>3.2040</td>\n",
              "      <td>0.0050</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "            Dernier    Ouv.  Plus Haut  Plus Bas    diff\n",
              "Date                                                    \n",
              "2020-07-20   3.2278  3.2271     3.2624    3.2074  0.0003\n",
              "2020-07-21   3.2276  3.2294     3.2524    3.2084 -0.0002\n",
              "2020-07-22   3.2327  3.2274     3.2606    3.2087  0.0051\n",
              "2020-07-23   3.2240  3.2341     3.2589    3.2043 -0.0087\n",
              "2020-07-24   3.2290  3.2243     3.2506    3.2040  0.0050"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JeGP3rnnUF1F",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "outputId": "182a05a9-a264-451b-97d5-cb55a75413c8"
      },
      "source": [
        "from pandas.plotting import autocorrelation_plot\n",
        "plt.figsize=(20,10)\n",
        "ax = autocorrelation_plot(eurtnd['Dernier Prix'])\n",
        "ax.set_xlim([0, 50])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6jPZCJWXUGXM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "f616cbe6-17f0-4acd-cc6a-208d7a165770"
      },
      "source": [
        "eurtnd[\"Dernier Prix.1\"].autocorr(lag=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.9992407498411989"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 186
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7C1cHvjITiYb"
      },
      "source": [
        "from statsmodels.tsa.stattools import adfuller\n",
        "adfuller(X)\n",
        "#data is non stationary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jaj4IZLsUIJT"
      },
      "source": [
        "#X=eurtnd[\"Plus Haut\"].values\n",
        "#X=usdtnd[\"Plus Haut\"].values\n",
        "#X=eurmad[\"Plus Haut\"].values\n",
        "#X=usdmad[\"Plus Haut\"].values\n",
        "#X=eurusd[\"Plus Haut\"].values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n0EvUeYvuRRo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "9fc7b60a-507e-461d-e829-f0fa166ac5b6"
      },
      "source": [
        "eurtnd.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>Date</th>\n",
              "      <th>Dernier Prix.1</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>1298</th>\n",
              "      <td>10/11/2016</td>\n",
              "      <td>1.9685</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1297</th>\n",
              "      <td>10/12/2016</td>\n",
              "      <td>1.9520</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1296</th>\n",
              "      <td>10/13/2016</td>\n",
              "      <td>1.9548</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1295</th>\n",
              "      <td>10/14/2016</td>\n",
              "      <td>1.9674</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1294</th>\n",
              "      <td>10/15/2016</td>\n",
              "      <td>1.9754</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "            Date  Dernier Prix.1\n",
              "1298  10/11/2016          1.9685\n",
              "1297  10/12/2016          1.9520\n",
              "1296  10/13/2016          1.9548\n",
              "1295  10/14/2016          1.9674\n",
              "1294  10/15/2016          1.9754"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 659
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I71G542oriaL"
      },
      "source": [
        "eurtnd[\"Dernier Prix\"]=eurtnd[\"Dernier Prix.1\"]\n",
        "eurtnd.drop(\"Dernier Prix.1\",axis=1,inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PA6rj-yLWwoX"
      },
      "source": [
        "Y=eurtnd[\"Dernier Prix\"].iloc[350:].values\n",
        "#Y=Y[int(len(Y)*0.5):]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L1jGfYN9cxCj"
      },
      "source": [
        "from scipy.signal import savgol_filter\n",
        "#X = savgol_filter(X, 25, 3) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tgFZBqX1-7ci"
      },
      "source": [
        "eutn=pd.read_csv(\"/content/drive/My Drive/eurtnd.csv\")\n",
        "eutn=eutn[[\"Date\",\"Dernier Prix\"]]\n",
        "eutn=eutn.reindex(index=eutn.index[::-1])\n",
        "date=pd.to_datetime(eutn.Date, format='%m/%d/%Y')\n",
        "Y2=eutn[\"Dernier Prix\"].iloc[350:].values\n",
        "from scipy.signal import savgol_filter\n",
        "Y_smooth = savgol_filter(Y2, 13, 3) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5N-6G4u_J7k",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 630
        },
        "outputId": "eb09f835-59a1-4d00-b7af-41f8d10002a2"
      },
      "source": [
        "plt.figure(figsize=(20,10))\n",
        "plt.title(\"EUR/TND smoothed\",fontsize=18)\n",
        "plt.plot(Y_smooth,c=\"blue\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7f69ece23a20>]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlmsjPRL_B2y"
      },
      "source": [
        "plt.figure(figsize=(20,10))\n",
        "ax=test.plot(color='red', figsize=(20,10))\n",
        "    #plt.plot(ts, color='red',label='Real rate')\n",
        "predicted.plot(color='blue',label='Predicted rate',ax=ax)\n",
        "plt.title('Real VS Prediction (Smoothed)',fontsize=18)\n",
        "plt.xlabel('Time',fontsize=15)\n",
        "plt.ylabel('EUR/TND',fontsize=15)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqDdoD0wUIQc"
      },
      "source": [
        "\n",
        "X=eurtnd[\"Dernier Prix\"].iloc[350:].values\n",
        "\n",
        "size = int(len(X) * 0.66)\n",
        "\n",
        "eurtnd[\"Dernier Prix\"]=savgol_filter(eurtnd[\"Dernier Prix\"].to_numpy(),5,3)\n",
        "eurtnd['target']=eurtnd[\"Dernier Prix\"]\n",
        "eurtnd['target_previous']=eurtnd[\"Dernier Prix\"].shift(1)\n",
        "eurtnd['diff']=(eurtnd['target']-eurtnd['target_previous'])*1000/eurtnd['target']\n",
        "target_previous=X[size:len(X)]\n",
        "X=eurtnd[\"diff\"].iloc[350:].values\n",
        "\n",
        "#########\n",
        "rft = np.fft.rfft(X,500)\n",
        "#X = np.fft.irfft(rft,500)\n",
        "#X=X[int(len(X)*0.5):]\n",
        "#test0=X[size-10:len(X)]\n",
        "from scipy.signal import savgol_filter\n",
        "#X = savgol_filter(X, 25, 3) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o6iAzF5ldMOa"
      },
      "source": [
        "train, test = X[0:size], X[size-10:len(X)]\n",
        "ydate=date[size:len(X)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oMnXw5M3Y8c8"
      },
      "source": [
        "# n = 200\n",
        "# nfft = n\n",
        "\n",
        "# t = np.linspace(0, 0.1, n)\n",
        "# yf = np.fft.fftshift(np.fft.fft(X, nfft))\n",
        "# f = np.fft.fftshift(np.fft.fftfreq(nfft, np.mean(np.diff(t))))\n",
        "\n",
        "# plt.plot(f, abs(yf))\n",
        "# plt.grid()\n",
        "# plt.xlim([-100, 100])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pwr8lG2OaXYw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "3874d2e1-cd21-49b2-97b0-113685c8a45c"
      },
      "source": [
        "#plt.plot(X)\n",
        "plt.plot(X)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h04CawHwXknG"
      },
      "source": [
        "fft_list = np.asarray(np.fft.fft(np.asarray(X)))\n",
        "for num_ in [500]:\n",
        "     eurtnd['invfft'+str(num_)]= np.copy(fft_list); eurtnd['invfft'+str(num_)][num_:-num_]=0\n",
        "     eurtnd['invfft'+str(num_)]=np.real(np.fft.ifft(eurtnd['invfft'+str(num_)]))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "db1b9uMgWass"
      },
      "source": [
        "X=X[1:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KmWlnbcdMRZG"
      },
      "source": [
        "def best_order(series, max_order):\n",
        "    m=1\n",
        "    best=1\n",
        "    for i in range(max_order):\n",
        "        if i==0: \n",
        "            continue\n",
        "        else:\n",
        "            r=series.autocorr(lag=i)\n",
        "            if r<m and r>0.95:\n",
        "                m=r\n",
        "                best=i\n",
        "    return best\n",
        "lag=best_order(eurtnd[\"Dernier Prix\"].iloc[1:],100)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sOXX87ZgUIPP"
      },
      "source": [
        "lag=best_order(pd.Series(X),100)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5vgadiu9UINj"
      },
      "source": [
        "X_train = []\n",
        "y_train = []\n",
        "n=len(train)\n",
        "for i in range(lag,n):\n",
        "    X_train.append(train[i-lag:i])\n",
        "    y_train.append(train[i])\n",
        "X_train, y_train = np.array(X_train), np.array(y_train)\n",
        "X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1],1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tW9-2txTUQRI"
      },
      "source": [
        "X_val = []\n",
        "y_val = []\n",
        "n=len(train)\n",
        "for i in range(lag,len(test)):\n",
        "    X_val.append(test[i-lag:i])\n",
        "    y_val.append(test[i])\n",
        "X_val, y_val = np.array(X_val), np.array(y_val)\n",
        "X_val = np.reshape(X_val, (X_val.shape[0], X_val.shape[1],1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EJrgdBzYTMap"
      },
      "source": [
        "X_test = []\n",
        "y_test=[]\n",
        "for i in range(len(train)+1,len(X)):\n",
        "    X_test.append(X[i-lag:i])\n",
        "    y_test.append(X[i])\n",
        "X_test = np.array(X_test)\n",
        "y_test=np.array(y_test)\n",
        "X_test = np.reshape(X_test, (X_test.shape[0],X_test.shape[1],1))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wY4hKgjkUaL4"
      },
      "source": [
        "## 3) Deep Learning"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mo8glVb2UQlV"
      },
      "source": [
        "import tensorflow as tf\n",
        "from keras.callbacks import ModelCheckpoint\n",
        "from keras.models import Model, load_model, Sequential\n",
        "from keras.layers import Dense, Activation, Dropout, Input, Masking, TimeDistributed, LSTM, Conv1D\n",
        "from keras.layers import GRU, SimpleRNN, Bidirectional, BatchNormalization, Reshape\n",
        "from keras.optimizers import Adam, SGD, RMSprop"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p0Ec3BhLVQzV"
      },
      "source": [
        "### a. Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E-SXy4aTM-J7"
      },
      "source": [
        "def ret_opt(name, rate):\n",
        "  opt=Adam(learning_rate=rate, beta_1=0.9, beta_2=0.99, epsilon=1e-07, amsgrad=False)\n",
        "  opt2=SGD(lr=rate, decay=1e-7, momentum=0.95, nesterov=True)\n",
        "  opt3 = RMSprop(learning_rate=rate, rho=0.9, momentum=0.0, epsilon=1e-07)\n",
        "  if name==\"adam\":\n",
        "    return opt\n",
        "  elif name==\"SGD\":\n",
        "    return opt2\n",
        "  elif name==\"rmsprop\":\n",
        "    return opt3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DsbkXTwGNSpV"
      },
      "source": [
        "class myCallback(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if(logs.get('val_loss')<2e-04) and (epoch>6) and (logs.get('val_loss')<7e-04):\n",
        "      print(\"Training stopped\")\n",
        "      self.model.stop_training = True\n",
        "callbacks=myCallback()\n",
        "\n",
        "class myCallback2(tf.keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs={}):\n",
        "    if (logs.get('loss')<5e-04) and (epoch>3) and (logs.get('val_loss')<7e-04):\n",
        "      print(\"Training stopped\")\n",
        "      self.model.stop_training = True\n",
        "callbacks2=myCallback2()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cIdggaBRM3JB"
      },
      "source": [
        "Model 1: Simple GRU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EZeTJOefM1PG"
      },
      "source": [
        "def GRUmodel(nb_units, nb_epochs, batches, name, rate):\n",
        "  model = Sequential()\n",
        "  model.add(GRU(units=nb_units, return_sequences=False,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "  model.add(Dense(units=1))\n",
        "  model.compile(optimizer=ret_opt(name, rate) ,loss='mean_squared_error')\n",
        "  history=model.fit(X_train, y_train, validation_data=(X_val,y_val), batch_size=batches, epochs=nb_epochs, callbacks=[callbacks2])\n",
        "  val_loss=history.history['val_loss']\n",
        "  loss=history.history['loss']\n",
        "  pred=model.predict(X_test)\n",
        "  rmse = math.sqrt(mean_squared_error(test[10:-1],pred))\n",
        "  return loss, val_loss,rmse"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SRRd7C_mP7iF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "outputId": "77df6c9a-4eba-431d-c020-ea489b0de167"
      },
      "source": [
        "loss, val_loss, rmse=GRUmodel(200,20,10,\"adam\",0.01)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/20\n",
            "85/85 [==============================] - 2s 18ms/step - loss: 0.1386 - val_loss: 7.5857e-04\n",
            "Epoch 2/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0014 - val_loss: 6.7810e-04\n",
            "Epoch 3/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0018 - val_loss: 0.0075\n",
            "Epoch 4/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0024 - val_loss: 0.0014\n",
            "Epoch 5/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0022 - val_loss: 0.0018\n",
            "Epoch 6/20\n",
            "85/85 [==============================] - 1s 15ms/step - loss: 0.0030 - val_loss: 4.2175e-04\n",
            "Epoch 7/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0039 - val_loss: 0.0032\n",
            "Epoch 8/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0032 - val_loss: 0.0027\n",
            "Epoch 9/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0030 - val_loss: 3.2540e-04\n",
            "Epoch 10/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0026 - val_loss: 7.7739e-04\n",
            "Epoch 11/20\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0021 - val_loss: 0.0049\n",
            "Epoch 12/20\n",
            "84/85 [============================>.] - ETA: 0s - loss: 0.0017Training stopped\n",
            "85/85 [==============================] - 1s 14ms/step - loss: 0.0017 - val_loss: 5.2768e-04\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HWa0RWlyQ0RO",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 648
        },
        "outputId": "a6f20c2e-b108-4ec8-9da0-346149d9550e"
      },
      "source": [
        "a=pd.DataFrame(loss[2:],columns=[\"Loss\"])\n",
        "b=pd.DataFrame(val_loss[2:],columns=[\"Validation_loss\"])\n",
        "\n",
        "plt.figure(figsize=(20,10))\n",
        "ax=a.plot(color=\"y\",figsize=(20,10))\n",
        "b.plot(color='r',ax=ax)\n",
        "plt.plot([5,10],[0.0018,0.0018],color=\"black\")\n",
        "plt.plot([5,10],[0.0008,0.0008],color=\"black\")\n",
        "plt.plot([9,9],[0,0.005],color=\"black\")\n",
        "\n",
        "plt.text(9.1, 0.0011, \"Stoppage condition 2\",fontsize=12)\n",
        "plt.text(9.1, 0.0021, \"Stoppage condition 1\",fontsize=12)\n",
        "plt.text(8.7, 0.0051, \"Cutoff point\",fontsize=12)\n",
        "plt.title(\"Losses during model training\",fontsize=18)\n",
        "plt.xlabel(\"Epochs\",fontsize=14)\n",
        "plt.ylabel(\"Loss\",fontsize=14)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x720 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LiLwV1z6Osbc"
      },
      "source": [
        "Model 2: Simple LSTM"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TziUz7QvOw0F"
      },
      "source": [
        "def LSTMmodel(nb_units, nb_epochs, batches, name, rate):\n",
        "  model = Sequential()\n",
        "  model.add(LSTM(units=nb_units, return_sequences=False,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "  model.add(Dense(units=1))\n",
        "  model.compile(optimizer=ret_opt(name, rate) ,loss='mean_squared_error')\n",
        "  history=model.fit(X_train, y_train, validation_data=(X_val,y_val), batch_size=batches, epochs=nb_epochs, callbacks=[callbacks2])\n",
        "  val_loss=history.history['val_loss']\n",
        "  loss=history.history['loss']\n",
        "  pred=model.predict(X_test)\n",
        "  rmse = math.sqrt(mean_squared_error(test[10:-1],pred))\n",
        "  return loss, val_loss,rmse"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "00m2CQW_PWgK"
      },
      "source": [
        "Model 3: Two layer GRU"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O89hDenQPaO4"
      },
      "source": [
        "def TwoGRU(nb_units, nb_units2, nb_epochs, batches, name, rate):\n",
        "  model = Sequential()\n",
        "  model.add(GRU(units=nb_units, return_sequences=True,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "  model.add(GRU(units=nb_units2, return_sequences=False,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "  model.add(Dense(units=1))\n",
        "  model.compile(optimizer=ret_opt(name, rate) ,loss='mean_squared_error')\n",
        "  history=model.fit(X_train, y_train, validation_data=(X_val,y_val), batch_size=batches, epochs=nb_epochs, callbacks=[callbacks2])\n",
        "  val_loss=history.history['val_loss']\n",
        "  loss=history.history['loss']\n",
        "  pred=model.predict(X_test)\n",
        "  rmse = math.sqrt(mean_squared_error(test[10:-1],pred))\n",
        "  return loss, val_loss,rmse"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnKKhm8qPipw"
      },
      "source": [
        "Model 4: GRU+Dense"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GtGvHNOqPk5A"
      },
      "source": [
        "def GRUdense(nb_units, nb_dense, nb_epochs, batches, name, rate):\n",
        "  model = Sequential()\n",
        "  model.add(GRU(units=nb_units, return_sequences=False,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "  model.add(Dense(units=nb_dense))\n",
        "  model.add(Dense(units=1))\n",
        "  model.compile(optimizer=ret_opt(name, rate) ,loss='mean_squared_error')\n",
        "  history=model.fit(X_train, y_train, validation_data=(X_val,y_val), batch_size=batches, epochs=nb_epochs, callbacks=[callbacks2])\n",
        "  val_loss=history.history['val_loss']\n",
        "  loss=history.history['loss']\n",
        "  pred=model.predict(X_test)\n",
        "  rmse = math.sqrt(mean_squared_error(test[10:-1],pred))\n",
        "  return loss, val_loss,rmse,pred"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ha5TmvvVVTod"
      },
      "source": [
        "unit_list=[10,30,50,100,200]\n",
        "dense_list=[5,10,20,30]\n",
        "batch_list=[5,10,20,50]\n",
        "epochs=20\n",
        "rates=[0.1,0.05,0.01]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hLi0qoiSVpiJ"
      },
      "source": [
        "models=[GRUmodel, LSTMmodel, TwoGRU, GRUdense]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "31O-mFO5WUrm"
      },
      "source": [
        "Optimizing by unit number"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lyh0FWyXWJiq"
      },
      "source": [
        "gru=[]\n",
        "lstm=[]\n",
        "twogru=[]\n",
        "grudense=[]\n",
        "\n",
        "for nb_units in unit_list:\n",
        "  gru.append(GRUmodel(nb_units, epochs, 10, \"adam\", 0.01))\n",
        "  lstm.append(LSTMmodel(nb_units, epochs, 10, \"adam\", 0.01))\n",
        "\n",
        "\n",
        "for nb_units in unit_list:\n",
        "  for nb_units2 in unit_list:\n",
        "    twogru.append(TwoGRU(nb_units, nb_units2, epochs, 10, \"adam\", 0.01))\n",
        "\n",
        "for nb_units in unit_list:\n",
        "  for nb_dense in dense_list:\n",
        "    grudense.append(GRUdense(nb_units, nb_dense, epochs, 10, \"adam\", 0.01))\n",
        "\n",
        "results=[gru,lstm,twogru,grudense]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UcXn7pqMfK_n"
      },
      "source": [
        "for nb_units in unit_list:\n",
        "  for nb_dense in dense_list:\n",
        "    grudense.append(GRUdense(nb_units, nb_dense, epochs, 10, \"adam\", 0.01))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gxIXLc5edMKz"
      },
      "source": [
        "gru=results[0]\n",
        "lstm=results[1]\n",
        "twogru=results[2]\n",
        "grudense=results[3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o67Y0Y0feSaL"
      },
      "source": [
        "d=[g[2] for g in gru]\n",
        "grudf=pd.DataFrame(d,index=unit_list)\n",
        "\n",
        "d=[g[2] for g in lstm]\n",
        "lstmdf=pd.DataFrame(d,index=unit_list)\n",
        "\n",
        "\n",
        "\n",
        "un=[unit_list[i//len(unit_list)] for i in range(len(unit_list)*5)]\n",
        "un2=[unit_list[i%len(unit_list)] for i in range(len(unit_list)*5)]\n",
        "arrays=[un,un2]\n",
        "tuples = list(zip(*arrays))\n",
        "index = pd.MultiIndex.from_tuples(tuples, names=['nb units', 'nb units2'])\n",
        "\n",
        "d=[g[2] for g in twogru]\n",
        "twogrudf=pd.DataFrame(d,index=index)\n",
        "\n",
        "\n",
        "\n",
        "un=[unit_list[i//4] for i in range(len(unit_list)*4)]\n",
        "un2=[dense_list[i%len(dense_list)] for i in range(len(dense_list)*5)]\n",
        "arrays=[un,un2]\n",
        "tuples = list(zip(*arrays))\n",
        "index = pd.MultiIndex.from_tuples(tuples, names=['nb units', 'nb dense'])\n",
        "\n",
        "d=[g[2] for g in grudense]\n",
        "grudensedf=pd.DataFrame(d[20:],index=index)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ePHcz4NxDAp5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "e73ef1c9-a74b-4fb9-e0d1-d9578dde25c0"
      },
      "source": [
        "len(grudense)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "40"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 345
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5SUzcEJwhgrS"
      },
      "source": [
        "grudf.to_csv(\"grudf.csv\")\n",
        "lstmdf.to_csv(\"lstmdf.csv\")\n",
        "twogrudf.to_csv(\"twogrudf.csv\")\n",
        "grudensedf.to_csv(\"grudensedf.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "onEEFPQiXSFq"
      },
      "source": [
        "grudf=pd.read_csv(\"grudf.csv\")\n",
        "lstmdf=pd.read_csv(\"lstmdf.csv\")\n",
        "twogrudf=pd.read_csv(\"twogrudf.csv\")\n",
        "grudensedf=pd.read_csv(\"grudensedf.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4YlrsUuqCxik",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        },
        "outputId": "6716408c-9e49-4920-ed40-ad8f29d3dd4e"
      },
      "source": [
        "pd.MultiIndex.from_tuples(tuples, names=['nb units', 'nb dense'])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MultiIndex([( 10,  5),\n",
              "            ( 10, 10),\n",
              "            ( 10, 20),\n",
              "            ( 10, 30),\n",
              "            ( 30,  5),\n",
              "            ( 30, 10),\n",
              "            ( 30, 20),\n",
              "            ( 30, 30),\n",
              "            ( 50,  5),\n",
              "            ( 50, 10),\n",
              "            ( 50, 20),\n",
              "            ( 50, 30),\n",
              "            (100,  5),\n",
              "            (100, 10),\n",
              "            (100, 20),\n",
              "            (100, 30),\n",
              "            (200,  5),\n",
              "            (200, 10),\n",
              "            (200, 20),\n",
              "            (200, 30)],\n",
              "           names=['nb units', 'nb dense'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 348
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BO2_6CEYfAqC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 677
        },
        "outputId": "060e982f-29e4-4bcb-d737-2592e3f075b0"
      },
      "source": [
        "grudensedf"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>nb units</th>\n",
              "      <th>nb dense</th>\n",
              "      <th>0</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>10</td>\n",
              "      <td>5</td>\n",
              "      <td>0.024415</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>10</td>\n",
              "      <td>10</td>\n",
              "      <td>0.139449</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>10</td>\n",
              "      <td>20</td>\n",
              "      <td>0.085339</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>10</td>\n",
              "      <td>30</td>\n",
              "      <td>0.032132</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>30</td>\n",
              "      <td>5</td>\n",
              "      <td>0.068856</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>30</td>\n",
              "      <td>10</td>\n",
              "      <td>0.021201</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>30</td>\n",
              "      <td>20</td>\n",
              "      <td>0.054362</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>30</td>\n",
              "      <td>30</td>\n",
              "      <td>0.157322</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>50</td>\n",
              "      <td>5</td>\n",
              "      <td>0.058227</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>50</td>\n",
              "      <td>10</td>\n",
              "      <td>0.089608</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>10</th>\n",
              "      <td>50</td>\n",
              "      <td>20</td>\n",
              "      <td>0.044924</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>11</th>\n",
              "      <td>50</td>\n",
              "      <td>30</td>\n",
              "      <td>0.088629</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>12</th>\n",
              "      <td>100</td>\n",
              "      <td>5</td>\n",
              "      <td>0.060266</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>13</th>\n",
              "      <td>100</td>\n",
              "      <td>10</td>\n",
              "      <td>0.048118</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>14</th>\n",
              "      <td>100</td>\n",
              "      <td>20</td>\n",
              "      <td>0.054809</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>15</th>\n",
              "      <td>100</td>\n",
              "      <td>30</td>\n",
              "      <td>0.095244</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>16</th>\n",
              "      <td>200</td>\n",
              "      <td>5</td>\n",
              "      <td>0.105143</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>17</th>\n",
              "      <td>200</td>\n",
              "      <td>10</td>\n",
              "      <td>0.121463</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>18</th>\n",
              "      <td>200</td>\n",
              "      <td>20</td>\n",
              "      <td>0.067840</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>19</th>\n",
              "      <td>200</td>\n",
              "      <td>30</td>\n",
              "      <td>0.054807</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    nb units  nb dense         0\n",
              "0         10         5  0.024415\n",
              "1         10        10  0.139449\n",
              "2         10        20  0.085339\n",
              "3         10        30  0.032132\n",
              "4         30         5  0.068856\n",
              "5         30        10  0.021201\n",
              "6         30        20  0.054362\n",
              "7         30        30  0.157322\n",
              "8         50         5  0.058227\n",
              "9         50        10  0.089608\n",
              "10        50        20  0.044924\n",
              "11        50        30  0.088629\n",
              "12       100         5  0.060266\n",
              "13       100        10  0.048118\n",
              "14       100        20  0.054809\n",
              "15       100        30  0.095244\n",
              "16       200         5  0.105143\n",
              "17       200        10  0.121463\n",
              "18       200        20  0.067840\n",
              "19       200        30  0.054807"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 351
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CMjYKpBVXt4d"
      },
      "source": [
        "Best optimizer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aFTxRX_BXtQd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "e1fdfe7f-3272-45f0-e50b-631dcdb7e65a"
      },
      "source": [
        "gru2=[]\n",
        "lstm2=[]\n",
        "twogru2=[]\n",
        "grudense2=[]\n",
        "names=[\"adam\",\"SGD\",\"rmsprop\"]\n",
        "name=\"adam\"\n",
        "for rate in rates[:]:\n",
        "  gru2.append(GRUmodel(30, epochs, 10, name, rate))\n",
        "  lstm2.append(LSTMmodel(10, epochs, 10, name, rate))\n",
        "  twogru2.append(TwoGRU(200,30, epochs, 10, name, rate))\n",
        "  grudense2.append(GRUdense(30,10, epochs, 10, name, rate))\n",
        "\n",
        "results2=[gru2,lstm2,twogru2,grudense2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 0.2291 - val_loss: 0.0726\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1095 - val_loss: 0.0766\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1117 - val_loss: 0.0864\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1405 - val_loss: 0.0653\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1107 - val_loss: 0.0602\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0949 - val_loss: 0.0720\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1173 - val_loss: 0.0717\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1040 - val_loss: 0.0593\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1019 - val_loss: 0.0638\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1131 - val_loss: 0.0678\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1043 - val_loss: 0.0583\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0975 - val_loss: 0.0863\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1067 - val_loss: 0.0743\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0992 - val_loss: 0.0629\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1074 - val_loss: 0.0616\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0983 - val_loss: 0.0592\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0987 - val_loss: 0.0645\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0964 - val_loss: 0.0922\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1090 - val_loss: 0.0634\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1022 - val_loss: 0.0844\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 0.1699 - val_loss: 0.1428\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1068 - val_loss: 0.0840\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1244 - val_loss: 0.0807\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0987 - val_loss: 0.0724\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1055 - val_loss: 0.0596\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1028 - val_loss: 0.0610\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0917 - val_loss: 0.0546\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1051 - val_loss: 0.0683\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1144 - val_loss: 0.0872\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1112 - val_loss: 0.0609\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0936 - val_loss: 0.0639\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0954 - val_loss: 0.0696\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0941 - val_loss: 0.0625\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0897 - val_loss: 0.0615\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0883 - val_loss: 0.0614\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1057 - val_loss: 0.0618\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0999 - val_loss: 0.0707\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1000 - val_loss: 0.0625\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0930 - val_loss: 0.0673\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0947 - val_loss: 0.0547\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 15ms/step - loss: 0.4152 - val_loss: 0.2503\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2015 - val_loss: 0.3081\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3475 - val_loss: 0.1126\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2758 - val_loss: 0.1649\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2194 - val_loss: 0.1264\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1961 - val_loss: 0.0962\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2593 - val_loss: 0.2464\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2885 - val_loss: 0.1576\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3363 - val_loss: 0.1619\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3061 - val_loss: 0.2044\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2419 - val_loss: 0.1921\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.2055 - val_loss: 0.2561\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3603 - val_loss: 0.2503\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.4106 - val_loss: 0.2896\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3796 - val_loss: 0.3150\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.4136 - val_loss: 0.6473\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.4434 - val_loss: 0.3470\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3817 - val_loss: 0.3135\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3819 - val_loss: 0.2693\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.3399 - val_loss: 0.2839\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 9ms/step - loss: 0.2519 - val_loss: 0.0554\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1130 - val_loss: 0.0960\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1043 - val_loss: 0.1024\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1276 - val_loss: 0.0770\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1254 - val_loss: 0.1196\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1247 - val_loss: 0.1010\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1186 - val_loss: 0.1125\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1209 - val_loss: 0.0609\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1326 - val_loss: 0.0717\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1111 - val_loss: 0.0637\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1073 - val_loss: 0.0626\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1232 - val_loss: 0.1938\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1433 - val_loss: 0.0844\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1287 - val_loss: 0.0834\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1041 - val_loss: 0.0748\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1164 - val_loss: 0.0600\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1060 - val_loss: 0.0854\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1015 - val_loss: 0.0574\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1096 - val_loss: 0.1032\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1118 - val_loss: 0.0583\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 0s 8ms/step - loss: 0.2050 - val_loss: 0.0743\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1024 - val_loss: 0.0632\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0957 - val_loss: 0.0585\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1137 - val_loss: 0.0614\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1072 - val_loss: 0.0598\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0976 - val_loss: 0.0581\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0997 - val_loss: 0.0744\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0958 - val_loss: 0.0594\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0994 - val_loss: 0.0548\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0951 - val_loss: 0.0648\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0999 - val_loss: 0.0555\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0947 - val_loss: 0.0616\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0856 - val_loss: 0.0700\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0944 - val_loss: 0.0567\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0910 - val_loss: 0.0602\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0908 - val_loss: 0.0704\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0915 - val_loss: 0.0601\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0953 - val_loss: 0.0665\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0901 - val_loss: 0.0600\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0907 - val_loss: 0.0572\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 0s 8ms/step - loss: 0.2265 - val_loss: 0.0728\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1059 - val_loss: 0.0572\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1007 - val_loss: 0.0670\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0998 - val_loss: 0.0650\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0965 - val_loss: 0.0590\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0950 - val_loss: 0.0593\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0894 - val_loss: 0.0648\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0901 - val_loss: 0.0552\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0996 - val_loss: 0.0623\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0899 - val_loss: 0.0582\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0929 - val_loss: 0.0681\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0899 - val_loss: 0.0566\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0920 - val_loss: 0.0638\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0932 - val_loss: 0.0550\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0930 - val_loss: 0.0635\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0903 - val_loss: 0.0631\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0938 - val_loss: 0.0593\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0886 - val_loss: 0.0667\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0917 - val_loss: 0.0577\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0952 - val_loss: 0.0558\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 14ms/step - loss: 0.2940 - val_loss: 0.1331\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1469 - val_loss: 0.0752\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1143 - val_loss: 0.0677\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1367 - val_loss: 0.0985\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1270 - val_loss: 0.0819\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1395 - val_loss: 0.0829\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1252 - val_loss: 0.0836\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1090 - val_loss: 0.1090\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1197 - val_loss: 0.0802\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1161 - val_loss: 0.0773\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1198 - val_loss: 0.0798\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1121 - val_loss: 0.0674\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1223 - val_loss: 0.0762\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1065 - val_loss: 0.0925\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1201 - val_loss: 0.1109\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1010 - val_loss: 0.0834\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1054 - val_loss: 0.1339\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1083 - val_loss: 0.0750\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1050 - val_loss: 0.0918\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1080 - val_loss: 0.0596\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 0s 8ms/step - loss: 0.1507 - val_loss: 0.0609\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1183 - val_loss: 0.0666\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1114 - val_loss: 0.0705\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1141 - val_loss: 0.0949\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1107 - val_loss: 0.0874\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1102 - val_loss: 0.0564\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1066 - val_loss: 0.0579\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1050 - val_loss: 0.0715\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1087 - val_loss: 0.0554\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1039 - val_loss: 0.0603\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1017 - val_loss: 0.0636\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1051 - val_loss: 0.0704\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1068 - val_loss: 0.0587\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0961 - val_loss: 0.0643\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1151 - val_loss: 0.0604\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0971 - val_loss: 0.0568\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0951 - val_loss: 0.0767\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1173 - val_loss: 0.0764\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0939 - val_loss: 0.0606\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.1019 - val_loss: 0.0577\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 0.2598 - val_loss: 0.0607\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0925 - val_loss: 0.0565\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0912 - val_loss: 0.0699\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0876 - val_loss: 0.0599\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0911 - val_loss: 0.0570\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0993 - val_loss: 0.0610\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0910 - val_loss: 0.0664\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0851 - val_loss: 0.0597\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0860 - val_loss: 0.0548\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0882 - val_loss: 0.0685\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0885 - val_loss: 0.0556\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0844 - val_loss: 0.0564\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0846 - val_loss: 0.0617\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0892 - val_loss: 0.0572\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0854 - val_loss: 0.0571\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0859 - val_loss: 0.0566\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0871 - val_loss: 0.0554\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0866 - val_loss: 0.0550\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0866 - val_loss: 0.0627\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0877 - val_loss: 0.0702\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 0.4593 - val_loss: 0.0831\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1166 - val_loss: 0.0681\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1080 - val_loss: 0.0620\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.1021 - val_loss: 0.0667\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0942 - val_loss: 0.0632\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0888 - val_loss: 0.0566\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0886 - val_loss: 0.0655\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0883 - val_loss: 0.0574\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0856 - val_loss: 0.0634\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0850 - val_loss: 0.0559\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0854 - val_loss: 0.0554\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0848 - val_loss: 0.0599\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0857 - val_loss: 0.0557\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0851 - val_loss: 0.0573\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0862 - val_loss: 0.0560\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0860 - val_loss: 0.0556\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0844 - val_loss: 0.0575\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0850 - val_loss: 0.0622\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0853 - val_loss: 0.0545\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0874 - val_loss: 0.0588\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 15ms/step - loss: 0.1719 - val_loss: 0.0946\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1136 - val_loss: 0.0606\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1065 - val_loss: 0.0745\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0960 - val_loss: 0.0643\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0955 - val_loss: 0.0651\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.1070 - val_loss: 0.0790\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0943 - val_loss: 0.0664\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0981 - val_loss: 0.0580\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0858 - val_loss: 0.0609\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0930 - val_loss: 0.0563\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0930 - val_loss: 0.0599\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0897 - val_loss: 0.0682\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0970 - val_loss: 0.0725\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0941 - val_loss: 0.0669\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0937 - val_loss: 0.0649\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0875 - val_loss: 0.0575\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0928 - val_loss: 0.0679\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0928 - val_loss: 0.0576\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0880 - val_loss: 0.0582\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 5ms/step - loss: 0.0903 - val_loss: 0.0719\n",
            "Epoch 1/20\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 0.1863 - val_loss: 0.0560\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 0s 2ms/step - loss: 0.0917 - val_loss: 0.0652\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0933 - val_loss: 0.0549\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0951 - val_loss: 0.0574\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0893 - val_loss: 0.0606\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0929 - val_loss: 0.0557\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0902 - val_loss: 0.0663\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0946 - val_loss: 0.0574\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0833 - val_loss: 0.0732\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0941 - val_loss: 0.0553\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0938 - val_loss: 0.0667\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0914 - val_loss: 0.0572\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0899 - val_loss: 0.0666\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0950 - val_loss: 0.0663\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0891 - val_loss: 0.0546\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0854 - val_loss: 0.0574\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0914 - val_loss: 0.0551\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0907 - val_loss: 0.0600\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0903 - val_loss: 0.0781\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 0.0833 - val_loss: 0.0594\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a5a_AWefYL0H",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "f13a242d-172c-4f39-a451-444a0d61bcf4"
      },
      "source": [
        "len(gru2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 353
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d68SOmCpS-h0"
      },
      "source": [
        "un=[names[i//4] for i in range(len(names)*4)]\n",
        "un2=[rates[i%len(rates)] for i in range(len(rates)*4)]\n",
        "arrays=[un,un2]\n",
        "tuples = list(zip(*arrays))\n",
        "index = pd.MultiIndex.from_tuples(tuples, names=['optimizer', 'learning rate'])\n",
        "\n",
        "\n",
        "d=[g[2] for g in gru2]\n",
        "grudf2=pd.DataFrame(d,index=rates)\n",
        "\n",
        "d=[g[2] for g in lstm2]\n",
        "lstmdf2=pd.DataFrame(d,index=rates)\n",
        "\n",
        "d=[g[2] for g in twogru2]\n",
        "twogrudf2=pd.DataFrame(d,index=rates)\n",
        "\n",
        "d=[g[2] for g in grudense2]\n",
        "grudensedf2=pd.DataFrame(d,index=rates)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "coo08EEUlH6U"
      },
      "source": [
        "grudf2.to_csv(\"grudf2.csv\")\n",
        "lstmdf2.to_csv(\"lstmdf2.csv\")\n",
        "twogrudf2.to_csv(\"twogrudf2.csv\")\n",
        "grudensedf2.to_csv(\"grudensedf2.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Me3Rxfv1FvKT",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 144
        },
        "outputId": "d1068fd7-e055-4008-cc0d-26d73231f135"
      },
      "source": [
        "grudensedf2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>0</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0.10</th>\n",
              "      <td>0.078043</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0.05</th>\n",
              "      <td>0.087717</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>0.01</th>\n",
              "      <td>0.104047</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "             0\n",
              "0.10  0.078043\n",
              "0.05  0.087717\n",
              "0.01  0.104047"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 360
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tSnWR0RPe5vm"
      },
      "source": [
        "a=[]\n",
        "a.append(GRUmodel(30, epochs, 10, name, 0.05))\n",
        "a.append(LSTMmodel(10, epochs, 10, name, 0.05))\n",
        "a.append(TwoGRU(200,30, epochs, 10, name, 0.05))\n",
        "a.append(GRUdense(30,10, epochs, 10, name, 0.1))\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5A8Hht6QfUTS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 91
        },
        "outputId": "0ebbefcd-a31e-48dc-f6f7-d64b40428da2"
      },
      "source": [
        "[aa[2] for aa in a]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.10542438332776043,\n",
              " 0.05060863582042278,\n",
              " 0.13616871217589332,\n",
              " 0.1354831484682136]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 375
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDITFfJvsrx1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "outputId": "771e7b26-9c61-4212-9435-703276e1c27e"
      },
      "source": [
        "a,b,c,pred=GRUdense(50,10, epochs, 10, name, 0.01)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/20\n",
            "84/84 [==============================] - 1s 15ms/step - loss: 0.2314 - val_loss: 0.0136\n",
            "Epoch 2/20\n",
            "84/84 [==============================] - 1s 10ms/step - loss: 0.0028 - val_loss: 0.0031\n",
            "Epoch 3/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 7.4846e-04 - val_loss: 1.6276e-04\n",
            "Epoch 4/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 4.2549e-04 - val_loss: 2.4737e-04\n",
            "Epoch 5/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 4.5145e-04 - val_loss: 9.4045e-04\n",
            "Epoch 6/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 7.1578e-04 - val_loss: 2.6541e-04\n",
            "Epoch 7/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 0.0011 - val_loss: 5.4977e-04\n",
            "Epoch 8/20\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 9.5731e-04 - val_loss: 9.8678e-04\n",
            "Epoch 9/20\n",
            "84/84 [==============================] - 1s 10ms/step - loss: 8.3443e-04 - val_loss: 4.6926e-04\n",
            "Epoch 10/20\n",
            "84/84 [==============================] - 1s 10ms/step - loss: 8.8122e-04 - val_loss: 3.0569e-04\n",
            "Epoch 11/20\n",
            "84/84 [==============================] - 1s 10ms/step - loss: 0.0017 - val_loss: 0.0033\n",
            "Epoch 12/20\n",
            "82/84 [============================>.] - ETA: 0s - loss: 8.4407e-04Training stopped\n",
            "84/84 [==============================] - 1s 11ms/step - loss: 8.3752e-04 - val_loss: 3.1954e-04\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4VZFF7csJhzG"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RGpZX0lNUQcY"
      },
      "source": [
        "model = Sequential()\n",
        "# First LSTM layer\n",
        "model.add(GRU(units=30, return_sequences=False,input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "#model.add(Bidirectional(LSTM(units=30, return_sequences=False), input_shape=(X_train.shape[1],X_train.shape[2])))\n",
        "#model.add(Dropout(0.2))\n",
        "#model.add(LSTM(units=30,return_sequences=False))\n",
        "#model.add(Dropout(0.2))\n",
        "model.add(Dense(units=10))\n",
        "# The output layer\n",
        "model.add(Dense(units=1))\n",
        "opt=Adam(\n",
        "    learning_rate=0.01,\n",
        "    beta_1=0.9,\n",
        "    beta_2=0.99,\n",
        "    epsilon=1e-07,\n",
        "    amsgrad=False,\n",
        "    name=\"Adam\")\n",
        "##Best params beta1 0.9 beta2 0.99 25 epochs\n",
        "\n",
        "opt2=SGD(lr=0.001, decay=1e-7, momentum=0.95, nesterov=True)\n",
        "##Best params momentum 0.9 nesterov True.''\n",
        "\n",
        "opt3 = RMSprop(learning_rate=0.1, rho=0.9, momentum=0.0, epsilon=1e-07)\n",
        "\n",
        "model.compile(optimizer=opt ,loss='mean_absolute_error')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xHOFWRsbUQZS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        },
        "outputId": "54f34a82-e1cf-4374-dc0e-f654d24b6f9b"
      },
      "source": [
        "model.fit(X_train, y_train, validation_data=(X_val,y_val), batch_size=10, epochs=10, callbacks=[callbacks2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/10\n",
            "63/63 [==============================] - 1s 8ms/step - loss: 2.4197 - val_loss: 1.7092\n",
            "Epoch 2/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3884 - val_loss: 1.7150\n",
            "Epoch 3/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3971 - val_loss: 1.6772\n",
            "Epoch 4/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3898 - val_loss: 1.7493\n",
            "Epoch 5/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.4052 - val_loss: 1.6785\n",
            "Epoch 6/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3914 - val_loss: 1.6589\n",
            "Epoch 7/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3928 - val_loss: 1.6617\n",
            "Epoch 8/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.4049 - val_loss: 1.6652\n",
            "Epoch 9/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.3874 - val_loss: 1.6607\n",
            "Epoch 10/10\n",
            "63/63 [==============================] - 0s 3ms/step - loss: 2.4010 - val_loss: 1.6771\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7f69ae9a5d68>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6iOJK8QdV2V0"
      },
      "source": [
        "model.save_weights(\"/content/drive/My Drive/currencydata/LSTM+Dense Univariate Adam dummy.h5\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M5wpXjTgVXXy"
      },
      "source": [
        "### b. Long term forecasting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZUio4mCUQXD"
      },
      "source": [
        "X_test = []\n",
        "y_test=[]\n",
        "for i in range(len(train)+1,len(X)):\n",
        "    X_test.append(X[i-lag:i])\n",
        "    y_test.append(X[i])\n",
        "X_test = np.array(X_test)\n",
        "y_test=np.array(y_test)\n",
        "X_test = np.reshape(X_test, (X_test.shape[0],X_test.shape[1],1))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HfR94cCRUQUt"
      },
      "source": [
        "pred2 = model.predict(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m4hYH59CnwGR"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MoEclH4fV7dS"
      },
      "source": [
        "p=[]\n",
        "x=X[size]\n",
        "for elt in pred2:\n",
        "  p.append(x+elt)\n",
        "  x+=elt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oj26qaG5XPa9"
      },
      "source": [
        "t=[]\n",
        "x=X[size]\n",
        "for elt in test[10:]:\n",
        "  t.append(x+elt)\n",
        "  x+=elt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9hkV--gIbx3k"
      },
      "source": [
        "predp=pd.DataFrame(pred2, columns = ['Prediction'])\n",
        "predp[\"Date\"]=date[size+1:len(X)]\n",
        "predp.set_index('Date', inplace=True)\n",
        "\n",
        "ts=pd.DataFrame(test[10:], columns = ['Real Rate'])\n",
        "ts[\"Date\"]=date[size:len(X)]\n",
        "ts.set_index('Date', inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KG77nBOSgUyD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32e32c54-cabe-4a40-8ecb-142051b44537"
      },
      "source": [
        "ts.tail()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>Real Rate</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Date</th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>NaT</th>\n",
              "      <td>-0.396336</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>NaT</th>\n",
              "      <td>-2.460897</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>NaT</th>\n",
              "      <td>-2.537254</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>NaT</th>\n",
              "      <td>-2.337448</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>NaT</th>\n",
              "      <td>0.028008</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "      Real Rate\n",
              "Date           \n",
              "NaT   -0.396336\n",
              "NaT   -2.460897\n",
              "NaT   -2.537254\n",
              "NaT   -2.337448\n",
              "NaT    0.028008"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lj3H-WNaUlJh"
      },
      "source": [
        "import math\n",
        "from sklearn.metrics import mean_squared_error\n",
        "\n",
        "# Some functions to help out with\n",
        "def plot_predictions(test,predicted):\n",
        "    plt.figure(figsize=(20,10))\n",
        "    ax=test.plot(color='red', figsize=(20,10))\n",
        "    #plt.plot(ts, color='red',label='Real rate')\n",
        "    predicted.plot(color='blue',label='Predicted rate',ax=ax)\n",
        "    plt.title('Real VS Prediction USD/MAD',fontsize=18)\n",
        "    plt.xlabel('Time',fontsize=15)\n",
        "    plt.ylabel('USD/TND',fontsize=15)\n",
        "    plt.legend()\n",
        "    plt.show()\n",
        "\n",
        "def return_rmse(test,predicted):\n",
        "    rmse = math.sqrt(mean_squared_error(test, predicted))\n",
        "    print(\"The root mean squared error is {}.\".format(rmse))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pjQoNqErUlQz"
      },
      "source": [
        "plot_predictions(ts,predp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sIPDTqATseq-"
      },
      "source": [
        "len(target_previous[size:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kfEElpoAtC-D"
      },
      "source": [
        "test.shape[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hrNriH8PUvLs"
      },
      "source": [
        "import math\n",
        "from sklearn.metrics import mean_squared_error\n",
        "return_rmse(test[10:-1],pred2[:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ucZBn3HlT-UD"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sNLbdGqvUC8c"
      },
      "source": [
        "#### From variation to values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y_fMT06otpKm"
      },
      "source": [
        "len(target_previous)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lY2ZURIxn1B3"
      },
      "source": [
        "#target_previous=eurtnd['target_previous'].tolist()\n",
        "p = (pred2[:,0]*target_previous[:-1])/1000 +target_previous[:-1]\n",
        "pre=pd.DataFrame(p, columns = ['Prediction'])\n",
        "pre[\"Date\"]=date[+size+1:len(X)]\n",
        "pre.set_index('Date', inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wPpjpAH8UKTP"
      },
      "source": [
        "pre=pd.DataFrame(p, columns = ['Prediction'])\n",
        "pre[\"Date\"]=date[+size+1:len(X)]\n",
        "pre.set_index('Date', inplace=True)\n",
        "\n",
        "\n",
        "t2=pd.DataFrame(Y[size:len(X)], columns = ['Real Rate'])\n",
        "t2[\"Date\"]=date[size:len(X)]\n",
        "t2.set_index('Date', inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hnyg8U2WVsz5"
      },
      "source": [
        "plot_predictions(t2,pre)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6x342uwtV2P5"
      },
      "source": [
        "return_rmse(Y[size+1:len(X)],p[:])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xZXMpJdlVd2g"
      },
      "source": [
        "### d. One-by-one prediction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ifnsw9CzUlPI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "321e8530-d0ba-4daa-e435-784ccb4d7bd1"
      },
      "source": [
        "pred=[]\n",
        "X2=X_train\n",
        "y2=y_train\n",
        "for i in range(len(X_test)-1):\n",
        "  model.reset_states() \n",
        "  x=X_test[i]\n",
        "  x=x[..., np.newaxis]\n",
        "  x = np.array(x)\n",
        "  x = np.reshape(x, (1,x.shape[0],x.shape[1]))\n",
        "  np.append(X2,x,axis=0)\n",
        "  X2=X2[1:]\n",
        "\n",
        "  y=y_test[i]\n",
        "  y=y[..., np.newaxis]\n",
        "  y = np.array(y)\n",
        "\n",
        "  np.append(y2,y,axis=0)\n",
        "  y2=y2[1:]\n",
        "  #model.fit(x,np.reshape(np.array(y_test[i]),(1,1)) , epochs=3)\n",
        "  model.fit(X2,y2,epochs=15, callbacks=[callbacks2])\n",
        "\n",
        "  x=X_test[i+1]\n",
        "  x=x[..., np.newaxis]\n",
        "  x = np.array(x)\n",
        "  x = np.reshape(x, (1,x.shape[0],x.shape[1]))\n",
        "  pred.append(model.predict(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.4148\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3879\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3724\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3745\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3750\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3781\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3823\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3788\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3768\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3803\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3820\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3790\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3778\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3758\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3748\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3728\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3741\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3762\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3775\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3707\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3713\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3849\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3713\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3741\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3736\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3784\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3715\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3718\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3769\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3874\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3726\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3710\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3724\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3711\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3681\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3772\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3762\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3685\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3790\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3680\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3637\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3670\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3691\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3664\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3628\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3768\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3782\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3669\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3674\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3699\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3801\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3844\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3641\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3737\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3644\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3657\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3639\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3676\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3617\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3629\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3599\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3599\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3603\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3562\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3670\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3651\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3724\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3602\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3668\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3694\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3591\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3601\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3566\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3643\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3672\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3622\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3740\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3527\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3650\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3625\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3547\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3601\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3611\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3632\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3572\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3627\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3604\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3540\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3582\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3529\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3540\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3656\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3635\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3561\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3755\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3726\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3600\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3572\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3655\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3640\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3582\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3557\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3561\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3624\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3590\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3579\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3777\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3656\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3651\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3584\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3527\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3585\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3633\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3545\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3578\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3677\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3652\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3522\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3578\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3530\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3587\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3568\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3678\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3509\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3545\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3713\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3541\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3518\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3636\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3538\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3554\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3583\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3515\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3583\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3529\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3588\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3548\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3561\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3577\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3613\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3524\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3593\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3565\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3511\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3617\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3620\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3528\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3554\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3552\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3592\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3526\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3586\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3587\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3558\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3523\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3525\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3504\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3468\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3581\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3509\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3503\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3566\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3536\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3481\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3517\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3530\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3572\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 2ms/step - loss: 2.3575\n",
            "Epoch 4/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3501\n",
            "Epoch 5/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3539\n",
            "Epoch 6/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3495\n",
            "Epoch 7/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3595\n",
            "Epoch 8/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3655\n",
            "Epoch 9/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3519\n",
            "Epoch 10/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3581\n",
            "Epoch 11/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3597\n",
            "Epoch 12/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3529\n",
            "Epoch 13/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3502\n",
            "Epoch 14/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3542\n",
            "Epoch 15/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3601\n",
            "Epoch 1/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3509\n",
            "Epoch 2/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3480\n",
            "Epoch 3/15\n",
            "20/20 [==============================] - 0s 1ms/step - loss: 2.3564\n",
            "Epoch 4/15\n",
            " 1/20 [>.............................] - ETA: 0s - loss: 1.8711"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-44-c5a1eb2cb099>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m   \u001b[0my2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0my2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m   \u001b[0;31m#model.fit(x,np.reshape(np.array(y_test[i]),(1,1)) , epochs=3)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m   \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m15\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcallbacks2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m   \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    106\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_method_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    107\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_in_multi_worker_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 108\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    109\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    110\u001b[0m     \u001b[0;31m# Running inside `run_distribute_coordinator` already.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m   1096\u001b[0m                 batch_size=batch_size):\n\u001b[1;32m   1097\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1098\u001b[0;31m               \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1099\u001b[0m               \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1100\u001b[0m                 \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    778\u001b[0m       \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    779\u001b[0m         \u001b[0mcompiler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"nonXla\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 780\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    781\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    782\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    805\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    806\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 807\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    808\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    809\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2827\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2828\u001b[0m       \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2829\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2830\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2831\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[0;34m(self, args, kwargs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1846\u001b[0m                            resource_variable_ops.BaseResourceVariable))],\n\u001b[1;32m   1847\u001b[0m         \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1848\u001b[0;31m         cancellation_manager=cancellation_manager)\n\u001b[0m\u001b[1;32m   1849\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1850\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcancellation_manager\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1922\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1923\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0;32m-> 1924\u001b[0;31m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[1;32m   1925\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m   1926\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    548\u001b[0m               \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    549\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 550\u001b[0;31m               ctx=ctx)\n\u001b[0m\u001b[1;32m    551\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    552\u001b[0m           outputs = execute.execute_with_cancellation(\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 60\u001b[0;31m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m     61\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PvkjmSANUryy"
      },
      "source": [
        "pred=[pred[i][0][0] for i in range(len(pred))]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5PVF3Fs4Urwy",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 661
        },
        "outputId": "7342fe76-ab29-4a71-dfde-5302836bd477"
      },
      "source": [
        "pred1p=pd.DataFrame(pred, columns = ['Prediction'])\n",
        "pred1p[\"Date\"]=date[len(X)+size+2:2*len(X)]\n",
        "pred1p.set_index('Date', inplace=True)\n",
        "\n",
        "plot_predictions(ts,pred1p)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1440x720 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAAJxCAYAAAAKOtj9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xV9f3H8ddNCCSMMMMMhOmXoCAUcCuKC0dF3FZxt25t1TqKk7pX66rtT+sqVG1BRa2ACghORogsw2GEFUbYIUB27u+Pz725NyEhkwx4Px+PPM7Nueee8z03xz7K+/H5fr4+v9+PiIiIiIiIiIhIdUXU9QBEREREREREROTgoKBJRERERERERERqhIImERERERERERGpEQqaRERERERERESkRihoEhERERERERGRGqGgSUREREREREREaoSCJhERETngnHMnO+f8zrlr6nosDYFz7hvn3Ory9h2oa4mIiIhUVaO6HoCIiIgcOM65k4EZJXbvAZYB/wJe8Twvv7bHVRbn3FzgSKCL53lbyjimObAJWO95ngvsawncDlwEdMf+P84WYAHwued5b1bg2quBhLBdecAG4GvgMc/z1lXppuoB59zvgZ2e571T12MpjXPuUeARYKjnefPKOfYk4B5gANAJyADWAj8Af/U8L7WUv+X+nOJ53jfOOX/g9yWe5x1RxrV/xp5PPM/zVfD8IiIihxQFTSIiIoeG94EvAB/QEbgKeBFIBH5Xh+Mq6Z/A68CVwF/KOOYSoBnwNoBzLhaYC/QEJgBvAbmB308A7gTKDZoC0oAHAq9bACcD1wFnO+cGeJ63tXK3U6POwP5+VfF7YDXwTg2ft1Y5524G/gakAu8C64A47Dm+HJgVeO/3QPOwjyYCfwI+Bj4qcdqUsNfZwOHOuaGe580tce3BWMiUDUTX0C2JiIgcdBQ0iYiIHBrme543LviLc+5vwFLgBufcmLKqh+rA+1gAdi1lB03XAgVY0ADwW6AP8HvP814qebBzrmMlrp8R/j0BrzvnNgO3Ba77XGkfcs5FAZGe52VX4lqV4nlebkM6b01zzjUCnsSqlwZ5nrerxPuNCYRLnud9UuK9k7GgaWGJv29J3wK/wv7Wc0u8dx2wFZiPhXMiIiJSCgVNIiIihyDP8/Y4537Cppr1wqaZAeCc6wQ8DJyDVT9tBT4HHvQ8b3PYcZ2Bu4FTsWlKMYQqTZ73PK+gCuPKcM5NAEY754aUnEblnOuDVSl97nnexsDuPoHttDLOuamy4yhhKhY09Q6M4VFsmtcRwPVYhVUn7Hv4xjnXBPtersC+22wswHjY87zkEvfTGngWGIV9f3MDn92Hc+4boLvned1L7O8NjAFOB9pjf6+5wFjP85LCpoQlhL0G6OF53ur9nPck4CHgKKAxVvnzmud5/yxtXMBxwAvACKBJ4J5v9zxvWWn3UwXtgFbAtJIhExQFZtureY1cYDxwlXPurmBwGPibXg68R+A5EBERkdKpGbiIiMihq1dgW/SPc+dcN2AeFkD9G7gV6+V0GfB9oBdS0ADgAmA68CBwP1Zt8jQ2vamq3gpsry3lveC+8LBjZfC9QNVLTQsGWSWnzY0HjsXClbuBjYHKpilYEPUj8Afs++iHfX9Dgh8OHDsVuAGb1vhHrHfW10B8RQYWOF8ScCk2Lex24BUs6DkucNjowNiXBl4Hf8qsYnPO/Rr7uyYG7u9PWM+qN51zT5TykWbYtLWCwLGvYtMOJznnIityLxWQDuwGTnLOuRo6Z2newgKtUWH7RgGtCT2bIiIiUgZVNImIiBwamjrn2hHq0XQTMAiYU6Li5BUgCpualBbc6Zz7L/ATFpw8Gtg9E+jpeV54lcxfnXP/wqbkPRpWdVQZM7Hw6PJAVUlOYAwRWG+pzViFVdCbWMByF3Clc+5brKLne+AHz/MKK3HtyMD3BKEeTY8A+di0vnA7gdPCm6k75/4Q+MwIz/Omhu3/G7AYeD7wPlhoNhSrPHok7NhfsGmDa/Y3UOecD+u51AQ4yvO8hWFvPxX4vvA8b5xz7nEgvZxpY8HzRmJB0e7AeTcE9r+GNZa/3zn3jud5y8M+1g54zvO8Z8POswWr1joNC9SqxfM8f6Ca7HlgiXNuPhbmzcGqnKpbuRa8zoLAua8l9De/DkjyPG/hgc24REREGj5VNImIiBwaHsMqWDYDC4FbsKbII4MHBKqVzgU+BbKdc+2CP1gj6RWE9abxPC8rGDI55xo759oEjp2K/X+Mouqdygic8y2sguT8sLfOALoA74WHO57n7QAGA89gK5BdiFURfQusdM5Vpp9OX+x72oJNA3wLqwYa6Xne4hLH/rWUFfuuxCqHkkp8f42Br4ATnHMxgWPPxyqAXihxjteBfaaGlWIgcDjwdomQCYBKBmzhBgPdgLeCIVPgfLlYcBRB2HMTUAi8XGLf9MC2DzXE87wXgPOAL7EqsTuAcUCac+6fzrmmNXSpt4BTnXNdnXNdsWmRqmYSERGpAFU0iYiIHBr+D/gvVq3UH7gPm54V3rzaYSHC9YGf0qQWHWzT1O7Hqox6s+/KZa2rMd53gLFYJcmHgX3XBbb7/IM/0Mz8fqzapi02pe0SLPj52Dl3pOd5Kypw3dVYc3Gwfj0b9vO50noPJWK9lvbXXL0dtlpaT2BjyX5DnuflOOdSKf/7CwY4yfs9qvJ6BLZLSnkvuK9nif0bSmmEvi2wbVtTAwPwPO8z4LNA5VU/LAS6E3s+8oEba+Ay/8YCwKux5zqXfSvaREREpBQKmkRERA4Nyz3P+zrwerJz7jvgO+DvWP8lCAVF4wit6FZSVtjrF7Epax8CT2DVUnnYql3PUI3Kac/zNjjnpgIjnHPxwF6skuVHz/NSyvnsNmxq3efOuXVYz6DLgMcrcOk9Yd9TefaWss8HLMKm8ZWlvqzwV5P21/i9ZABZIwLN5hcBi5xz47CKu6udc7dUpRF9iXPvcM59AlyDjf+TQOWciIiIlENBk4iIyCHI87wfAr2UrnLOvex53g/YP9T9QOMKhi2jgVme510WvjOwClpN+CdwNlZVkoH1Iqrs9KWfAtsuNTSm8iwH4oDpFZi6lgqc4ZyLDa9qCqxw1hMoL9gIVlQNrMC4/OUfUmxcYNPySupX4ph6wfO8rc65lVjI2Q5rHF5db2FN1sF6momIiEgFqEeTiIjIoevPWCXKWCiqBPoCuMA5d0zJg51zPudcXNiuAkpUqzjnmmENw2vCZ1j1zzXYtKg9hKbRhV/zWOdcqzLOEezx9EsNjak872HN1kutaHLOdQj7dRIQia1YF+5mILYC11qATWW7zjm3TygUaBYetBtoU4FzAszHVg+81jnXMex8UdjKeP7A2GuVc66pc25YGe/1wUKwrdRcxdjXwEPYiorTauicIiIiBz1VNImIiByiPM9b4Zz7ALjCOXei53nfYiHHd8As59x7WP+fCKzCZiQWpDwaOMUE4Ebn3IfYP8o7YIHQNmqA53l5gTEEg5h3PM/LLOXQK7BQ5H/YCmTbsL5AZwOnYCFTbTVyfgk4HXjOOTcca4i9C2uufSrWE+uUwLFvA78DHnbO9cBWUBsEXIyturff/58WWIXtWiwEmeOc+ye2sl0rYBgwBVtFEKyy63rn3J+BFKx592ee5+0p5bwFzrnbgI+Buc65/wMyseqeY4AnS6w4V5Ouc86NKGV/EraS4DfOucXYvS3Hgs6+WJ+waODWajRBLyZwnopMtxQREZEwCppEREQObU8Al2NVTad4nrfOOTcYaxY+EmumnY01r/4M+E/YZ+/CAohLAseuw5qOz8WCp5rwT0JBU1lh0d+BnViAcxc2dSoHmwr4GPBiaYHKgRAIx87BVvUbHbg+wAYsBHs37Nhc59zpwHNY5dWF2Hd3OvA80L0C15vrnBuKVd5cgk3x2hq41vdhh47BKppuxYIoH9b0u9TvxfO8z5xzp2LVPH/EVs1LAW7wPO+f5Y2rGm4uY/8/sFX7rsNWHzwP6ISFS1uAmcArnufNOIBjExERkQrw+f2VmbIvIiIiIiIiIiJSOvVoEhERERERERGRGqGgSUREREREREREaoSCJhERERERERERqREKmkREREREREREpEYoaBIRERERERERkRrRqK4HcCDNnz/fHxMTU9fDOOTl5OTQpEmTuh6GHKL0/El9oOdQ6hs9k1Kf6HmU+kLPotQHDeU53Lt379bBgwfHlfbeQR00+Xw+EhMT63oYh7yUlBT9HaTO6PmT+kDPodQ3eialPtHzKPWFnkWpDxrKc5iUlLSmrPc0dU5ERERERERERGqEgiYREREREREREakRCppERERERERERKRGHNQ9mkRERERERETk0JGXl0daWhrZ2dl1PZQqycvLIyUlpa6HUSQ6Opr4+HiioqIq/BkFTSIiIiIiIiJyUEhLS6NFixZ0794dn89X18OptKysLGJiYup6GAD4/X62bdtGWloaPXr0qPDnNHVORERERERERA4K2dnZtG3btkGGTPWNz+ejbdu2la4Oq9WKJudcNDALaBK49gTP8x4pccw1wHPA+sCuVz3PezPw3tXAg4H9j3ue925tjFtEREREREREGgaFTDWnKt9lbVc05QDDPc87EhgIjHDOHVPKcR96njcw8BMMmdoAjwBHA0cBjzjnWtfWwEVEREREREREypOYmMjIkSM599xzuemmm9i1a1eVzvPRRx8xduzYUvcfc8wxjBw5khEjRvDOO+9U6Fzp6elVGkdl1WrQ5Hme3/O83YFfowI//gp+/EzgK8/ztnuetwP4ChhxAIYpIiIiIiIiIlIl0dHRTJo0ic8//5yWLVsyfvz4Gr/G2WefzaRJk3j//fd5/fXX2bhx436P//jjj9m8eXONj6M0td4M3DkXCSQBvYHXPM+bXcphFzrnTgKWAX/wPG8d0AVYF3ZMWmCfiIiIiIiIiEi9M3DgQDzPA2Dt2rU89thj7Nixg+joaP785z/Tq1cvpk+fzuuvv05eXh6xsbG8+OKLtGvXrkLnb926NQkJCWzZsoVOnTrx6quvMmPGDHJychg0aBBjx45l6tSpLF68mHvuuYfo6Gg+/PBDVqxYwdNPP83evXtp3bo1Tz31FO3bt6+Re671oMnzvAJgoHOuFfCxc+4Iz/MWhx3yGfC+53k5zrkbgXeB4VW5VmFhYb1aFvBQlZ2drb+D1Bk9f1If6DmU+kbPpNQneh6lvtCzeHDIy8sjKysLgMjx44l8770aPX/BVVdRcMUV+z3G7/eTlZVFQUEB3333HaNGjSIrK4sxY8YwZswYEhISWLRoEY888ghvvPEGhx9+OO+++y4+n4+JEyfy97//nbvvvpvc3Fzy8/OL7icofP/GjRvJysqiW7duZGVlcdFFF3H99dcDMGbMGKZOncqwYcNITEzkrrvu4vDDDyc3N5fHHnuMv/71r7Rp04apU6fy/PPP89hjj5V6P3l5eZX6b6PWg6Ygz/N2OudmYNPfFoft3xZ22JvAs4HX64GTw96LB77Z3zUiIiJITEysieFKNaSkpOjvIHVGz5/UB3oOpb7RMyn1iZ5HqS/0LB4cUlJSiImJsV8aN4aImu0YFNm4MQTPX4acnBwuu+wy0tPT6dWrF6eccgrZ2dksWLCA++67r+i43NxcYmJiWLt2LQ888ABbtmwhJyeHrl27EhMTQ+PGjWnUqFHofgjeVmO+/PJLkpOTWbVqFQ899BCtWrUCYNasWbz55ptkZ2ezc+dO+vbtS0xMDJGRkTRp0oSYmBjWrVvHypUrueWWWwAr0omLi9vnOkFRUVH7/LeRlJRU5v3X9qpzcUBeIGSKAU4HnilxTCfP84KTC88DgrHZVODJsAbgZwAP1MKwRURERERERKShueoq+6llwR5NWVlZXH/99YwfP54LLriA2NhYJk2atM/xjz/+ONdccw2nnnoqs2bN4o033ij3GmeffTYPP/wwixYt4vrrr2f48OHExsby2GOPMXHiRDp16sQrr7xCTk7OPp/1+/306dOHDz/8sEbut6TaXnWuEzDDObcQmIs19/7cOTfWOXde4Jg7nHNLnHMLgDuAawA8z9sO/DnwubnA2MA+EREREREREZF6JSYmhgcffJC3336b6Oho4uPjmTx5MmBhz9KlSwHIzMykQ4cOAHz22WeVukb//v0577zzeO+994pCpdatW7Nnzx6mTp1adFyzZs3Ys2cPAD169GD79u0kJycDNjVu+fLl1bvZMLVa0eR53kJgUCn7Hw57/QBlVCp5nvcW8NYBG6CIiIiIiIiISA3p168fzjk+//xznnvuOR599FFef/118vPzOfvss+nbty+33XYbd955Jy1btmTw4MFs2rSpUtf47W9/ywUXXMCNN97IxRdfzLnnnku7du3o379/0TGjRo3ikUceKWoG/vLLL/P444+TmZlJQUEBV199NX369KmRe/b5/f4aOVF9lJyc7B80aJ9cS2qZ5jpLXdLzJ/WBnkOpb/RMSn2i51HqCz2LB4eG/nfMysoqs1dSXSntO01KSkoaPHjwkNKOr+2pcyIiIiIiIiIicpBS0CQiIiIiIiIiIjVCQZOIiIiIiIiIiNQIBU0iIiIiIiIiIlIjFDSJiIiIiIiIiEiNUNAkUlVffw1bttT1KERERERERETqDQVNIlWxcyeccQa88EJdj0RERERERETqkcTEREaOHMm5557LHXfcQVZWVpXPdf/99zNlyhQAxowZw4oVK8o8dvbs2cyfP7/o9/fff59PPvmkyteuKgVNIlWRnAx+PyxcWNcjERERERERkXokOjqaSZMm8fnnnxMVFcUHH3xQ7P38/PwqnfeJJ56gd+/eZb4/Z84ckpOTi36//PLLOf/886t0repoVOtXFDkYBFPiRYvqdhwiIiIiIiJSbw0ZMgTP85g9ezYvvfQSsbGxrFq1ii+++ILnn3+eOXPmkJubyxVXXMFll12G3+9n7NixfP/993Tq1ImoqKiic40ePZp7772X/v37M2vWLP7yl79QUFBA69ateeKJJ/jggw+IiIjg008/5aGHHuLHH3+kadOmXH/99aSkpPDII4+QlZVFt27dePLJJ2nZsiWjR49mwIABzJ49m8zMTJ544gmGDBlSrXtW0CRSFcGgKS3NptG1alW34xEREREREZFi3nsP3nqrZs953XVw1VUVOzY/P59Zs2Zx4oknAvDLL7/w2Wef0bVrVz788ENatGjBxIkTyc3N5bLLLuP4449nwYIFRUHU1q1bOeecc7jwwguLnXf79u089NBDjBs3jq5du7Jz505atWrFZZddVhQsAfz4449Fn7n33nt56KGHOOqoo3jppZd49dVXGTNmDAAFBQVMmDCBmTNn8uqrr/LOO+9U6ztS0CRSFfPnQ4sWkJkJixfDCSfU9YhERERERESkHsjOzmbkyJGAVTRddNFFJCcn079/f7p27QrA999/j+d5TJ06FYDMzEzWrFlDUlIS55xzDpGRkXTo0IFjjjlmn/P//PPPDBkypOhcrcopfMjMzCQzM5OjjjoKgFGjRnHnnXcWvX/66acDcPjhh7N+/fpq3r2CJpHK270bPA+uvdbicQVNIiIiIiIi9c5VV1W8+qgmBXs0ldS0adOi136/nwcffLCo2ilo2rRpB3x8JTVu3BiAiIgICgoKqn0+NQMXqayFC60R+MiREBvLrKlZ3Hab7RIREREREREpzwknnMD7779PXl4eAKtWrWLv3r0MHjyYyZMnU1BQwObNm5k9e/Y+nx04cCDz5s1j3bp1AOzcuROAZs2asWfPnn2Ob9GiBbGxscybNw+ASZMmMXTo0AN1a6poEqm0YH+mwYPhiCN4+8e+vJMODz8M7dvX7dCqY/t22LQJ+vWr65GIiIiIiIgc3C6++GLWr1/PBRdcgN/vp3Xr1vztb39j+PDhzJ8/n7PPPpvOnTszcODAfT7bpk0bxo4dy+23305hYSFt27bl7bff5pRTTuGOO+5g2rRpPPTQQ8U+88wzzxQ1A+/atStPPfXUAbs3n/8gLsNITk72Dxo0qK6HcchLSUkhMTFx3zc++wzuvtsqhKKja39gVXXddfC//1kqc/PNDH7zJuYXDOSbb2DYsLoeXNXdcQeMGwdbt0LEQVTrWObzJ1KL9BxKfaNnUuoTPY9SX+hZPDg09L9jVlYWMTExdT2MYkr7TpOSkpIGDx5c6vJ0B9E/J6XBSU6G5ctt5baGZP58+NWvwOcjP7E/Swr6ApCSUsfjqqZly2DHDli1qq5HIiIiIiIiIg2VgiapO4F5pGzYULfjqIzsbFiyBAKVcstaHUUOVo31yy91ObDqW7PGtgsX1u04REREREREpOFS0CR1JyPDtg0paFq8GPLzraIJWJBj1Uyx0TkNuqLJ7y89aPrhB3j11boZk4iIiIiIiDQ8Cpqk7jTEoCk52bbBoCm1BVHkcnbH5AYdNG3ZAllZ9jo8aHriCbj//roZk4iIiIiISFUczL2oa1tVvksFTVJ3GmLQ9Msv0KwZ9OgBWCjTr/k6jsyby/r1oVtqaILVTM2bw4IF9jo/H779FvbsgZycuhubiIiIiIhIRUVHR7Nt2zaFTTXA7/ezbds2oiu5eFejAzQekfIFezRt3Fi346iM1FTo2RN8PsBCmVO77SBx2UzgdpYuhaOPrtshVkUwaDrzTJg4EXbvhqVLITPT9m/fDp061d34REREREREKiI+Pp60tDS2bNlS10Opkry8PKKioup6GEWio6OJj4+v1GcUNEndaYgVTamp0KsXAFu32tCPHJ1A4l+XQT6k/OLn6KN9dTzIygsGTb/+tQVNixfD99+H3lfQJCIiIiIiDUFUVBQ9AjNQGqKUlBQSExPrehjVoqlzUncaWtDk94cqmgj1Mhpwahw9n72JxuSQ8sGCOhxgmF27YMCACnfyXr0aYmPhpJPs9wULYObM0PvbttX8EEVEREREROTgo6BJ6k5DC5o2b4a9e4uCpmAvoyOPhEa33cRhzTfwy9cbbM5ZXfvoI1i0CO68E776qtzD16yBhATo3t0Cp+Rk6880ZIi9r6BJREREREREKkJBk9SN7GzrMN26tTUECjYDCvfoo3DxxfZzzz1WUVSXUlNtG1bR1KEDtG8PRETQ7+QOpNAXjj8epkyh6KA//MFCn+r46ScYO7bi38G4cdawvF8/uPTS0NjLEAyafD4rhJowwVpoXXCBvb99e/WGLyIiIiIiIocGBU1SN4LVTMG5pyWrmhYsgMcegzlz7OeFFyAlpXbHWFKJoGnBAqtmCkoc3JRV9CCrcy84+2w49lg74K9/hddeq961H38cHnkE/vvfol0ffmgZ3D7Z04YNMH06jB4Nn3xi+847D/bTDG/NGqtmAguaghVMo0bZVhVNIiIiIiIiUhEKmqRulBc0/eMf0KSJzeGaPt32zZpVe+MrzcqVtu3enYICWLIE+vcPvZ2YCIWFPpa9MROuvtrSmz//GU44AX78cf/nzs2FG2+EMWNg7lwoLAy9t3cvTJtmr//wB6v+KizkrXtTmDABVjZyEBMDL79sx3zwgaVPV1xhjcsnTrSxDx9u0/9K2LnT/hwJCfb7gAG27dkTnIOoKFU0iYiIiIiISMVo1TmpG8GgqW9f24YHTXv22NSvSy6BNm1sel2nThY03XRThU7/2WdWTNStWw2OOTUVunSB6GjWr7Vs6LDDQm/362fblNUxHPn226E38vKsIikzE1q0KP3cTz4J//d/EBlprwcPtnAqKgq+/tqmGj7+ODz4IDz2GPnbd/HD2hcAmHbms/TOfQV+/3srSxo3zporBQd3yinw+ee2pNzJJ1sAlZkJjRrBYYexJmoI0K8oaApWaQ0bZlPp2rZVRZOIiIiIiIhUjCqapG7sr6Lpgw8sCLnxRvvd57Pl0GbNqlCPosxMOP98eOWVig8nPx927CjnoLAV51atsl3hq2YedhhER4cKiooce6xVKM2dW/p5f/4ZnngCrrzSKo6eegqSkkLT5D77zDp0//GPcP318MILLHg7id1YaDWt+Uj49FMYPJi/XTSdYcl/ofA3Vxa/xqmnwuTJ9j0/+CC8+CI8/TRcfTVrfnM/UHzq3MCBcPnl9nubNgqaREREREREpGIUNEnd2LnTtl27QvPmxYOmf/zDyoOOOy6076STYP16WL263FPPn2+5TimzxMr0979D794WOJWpnKCpSRPr1z1pEvzrX2GfO/po2wamz23bZrnSypVYWdQ110C7dvDSS5bq3HuvzVl74QW7kc8+gxEjoHFjC6H69+e7c54GLD+aPh0Ko5tS+PEkniu8i1kM49uEEkETWInS5s1WHZWbC1lZsHQpa+JPACChm6VjTZvajMXTT7ePtW2rqXMiIiIiIiJSMQqapG4EK5patoTOnUNBU3KyVf7ceKNVMgWddJJtK9Cnad482+6n9/U+liyxMGXXLqCgYN8DsrMt6AoETatX2/C6di1+2F13wYknwu23W5D01lsw+LTW/LrZdP75nxb87W9W+fTgg1ZQxIsvWlfxf/zDQiaAiAjrxTR/voVN6ek27Q0gLg4WLuTb6NPp3t1aQW3bZovbzVzemdUFNldw3OS2pd9o48aWiIFNy3OO1e4MYthL3PqfS/2Ips6JiIiIiIhIRSlokrpRVtA0bpyFIaNHFz++Xz8LYioRNG3dWvHhbNxo253bCy1MGju2+AHBSqqwiqYuXUKZTVBkJLzzjhUiOWcz3QoKYJGvPzcsvINbb7WpaSeeCJO/KMT/9DNw7rm2Kly4q66yKqcHHrDg6ayzit7y++Hbb63H+PDhtm/aNLtubCxcdJHNusvOLvt+X3nF2kBt3w5rmvYjgbX43nu31GM1dU5EREREREQqSkGT1I1g0NSiRSho8vtt3tmpp1oD8HAREZasfPttuaeuVtDkpcPatbZa3OLFoQNSU20bFjSFT5sL17Mn/POfdhv/+58Vaa164WN+5khm/CuN6dNtttz6DREsyui6b6gFtorcLbdYSnX88VZWFLB8uc2AO/FEC7ucs69twgS47DL43e/s6/3f/8q+33//2wqmLr0UUtMak9Ah23bm5e1zbHDqXAXaY4mIiIiIiMghTkGT1JwcL2YAACAASURBVI2MDCu/iYwMBU2LF9t8s/PPL/0zJ51kKUswFQq67z5rVIQ19F6xwhZUq8zUuaKgaekme1FQYCvcFRba7yWCptWrQ82zS3PJJTB1Kpx9tk2x8x13LEeykJMLp+PzwYhjrEfV5MP/CIMGlX6SW2+FVq1CXbkDvvvOtieeaNtTT7X8be9eC7CGD4eOHa04rDS7d9vsxAEDbEG75GRIGNjavrApU6x304wZtsWCppwcO7+IiIiIiIjI/ihokrqxc6dNmwMLmrKzbe4XhPoRlRTs0xRe1bR1Kzz7LNxxBxQWkpRku084wQKV/U0fCyosDAVNGcsDHcQffRS+/95Kk8CCppgY6NCB3FxISyu7oqlUiYlWvfXTTwB0/uBFBpLMF9Gjyv5M+/YWwN10U7Hd335rs+r69rXfTz3Vts7BMcdYdveb31hF05dfwjPPwOuvhz7//feWoz33nPWSAkg4Pt76P91xh6VUw4fDe+8BodZRagguIiIiIiIi5VHQJHUjI6N40ATw9tuWlHTqVPpnBg2CZs1CJT1gjbTBunlPnlw0bW7ECNtWpLfQtm2h1eZ2rt5pjZfGjLFg6557LNkJrjjn87F2rU0jq1TQFBlpq8998omVIj35JGe5VXz/c/OiWYSliokp3hSdUH+m4O5TTrGF+266KbTvyittFtyZZ8L999ssvOBKeTNnWsXXccdZr/Gnn4Yrr46Em2+24G7UKBvvunVAaNae+jSJiIiIiIhIeRQ0Sd0oLWjasQNGjiz7M40awZAhMGdOaF9ysm3bt4fnnmPePOjVC/r0sd0VmT4XPhNv5/o9doLISPjXvyz0Ou00a0Ie1p8J9j91rlQjRtgKcjk5cM89nPXccAoK4KuvKn6K1FSbXThsWGhf69awZg3ceWdo38CBNvyPP4akJAug3g30+v7mGxg61MKpqCibeditG/DYY7bs3jvvWHXTZqvuUtAkIiIiIiIiFaWgSQ6sG2+kxZdf7rs/I8P6D0EoaIKy+zMFHXWUhUu5ufb7zz9bR+z774eZM5n7fQ5DhlhOAhVrCF4saErPgd697Zdu3Wye2dChFoKF9WeCSlY0Adx1lzU6mjMHnn6aY89qRcuWMHlyxU/x3//adlSJGXdt2hQvfPL5rKrp/PPhV7+y6XXvvguZmdaf6eSTy7hA8CTt2xcFTZo6JyIiIiIiIhWloEkOnLw8eOON0oOm8B5Nwalyhx0WajxUlqOOspApOGXu559tSt0NN7C5RS/WbmrCkCHWwwgqVtG0YUPYsLYXhsqhwMp5vvrKVqEL9EpatcqKq+Ljyz93MT6fTcsLaNQIzjjDqo6++GLfVd38fvjoo+Jh2Ycf2uzChITKXfraay0ge/JJmyZYZtAUFBY0qaJJREREREREKkpBk9jqYjNn1vx509LA76dxoNdPMeFT55o2hX79bMm08hx9tG3nzLFxL11q88RatCDpjAcAGJq4uyhoqkxFU1zbAnYWNA9VNAXFxMCDDxaFYKtWWbFTZGT55y7PmDEW5Jxzjs2s8zzb7/dbkdaFF8INN9i+5cutmOuSSyp/nfPPt0X+nn8+1J9pv1TRJCIiIiIiIlWgoElg/HgrcQk2H6opa9cCEJWWVny/3188aALWTV7MntvvL/+c8fG2KtqcObB4sS2fNmgQAD81OQkfhQyKXFg0layiQVOrVtCpZRYZtNw3aCph9eoq9Gcqw5FHWh/zv/zFbunII+Gpp6xd0rPPWrY1aZLlgP/5j33m4osrf52mTeGyy6yaKdifab/CgqboaPu8KppERERERESkPAqaJDR3bOHCmj1vIGhqtGOHNZkOysqyxCMQNPn9MGSojyeeLL66Wl5eKef0+Wz63Jw5Nm0OrKIJmLY8gSHMI3Z5EpGRVolT0WbgnTpBq0aZ7KRV8alzpVi1qgr9mfajcWP4/e8hJQXOPRf+9CcLmq65BubNg65d4e674YMP4PjjqzBlL+Daa20b3ki8THFx1tApKwuwqisFTSIiIiIiIlIeBU0SShAWLarZ865ZE3qdmhp6vXOnbQPNwLdvt+KZ8Mv7/XD44VZolZ5e4rxHHWVT5r75xuaDde9OZibMTo7i1KY/FQVQ7dpVrKJpw4ZA0FS4nZ2+1vtNcvbutfHUZNAU1LEjTJhgfZnGjoU334RmzayvUlKSFXBdemnVz3/00fD22xZqlat9e9sGkrq2bTV1TkRERERERMqnoElCQdPixTV73kBFE1A8aMrIsG2goimYR61YETpkyxbrSTRzJgweDLNnh533qKNsO3GiVTNFRDBrFuTn+zitb1qlg6aiiqbczeyMbLff5kvBsdbU1LnSjBoFDz0UGsZvfgNDhlgx14UXVv28Pp9VSXXoUIGDg0FTWJ8mVTSJiIiIiIhIeRQ0yYGraFq7NtTvqAJB06pVUFhor5cts+1TT9nUsmHDoGjxuqFDbZuTE5o2N80WdDvupEYWmOXlERdX/tQ5v9+Cps6dodWeDeyk5X6PD7axOhAVTWWJiIB//9umznXuXEsXLRE0aeqciIiIiIiIVISCJgklCMuWWXhTU9auhQEDKIiNrVDQlJMD69fb6+XLbXvxxdaOqW9fGDkSpk/Hptw5ZweEBU0nnAAxQ4+A3FxYurRCFU07d9p1O3X00zJjLbvymxaFXaUJ3kZtBk1gbaOqstpclZUSNGnqnIiIiIiIiJRHQZNY0BQdbQ26Pa9mzun3W4KUkEBut26lB02BHk3hrZxWrrTtsmUQFQUJCTYF7quvoFcv+PWvbfU1/9DA9LlBg9i82fqYn3oqRcETP/9cFDT5/YGTv/tu6AIBwT7onWJ20Cp/C34iyMws/ZZSU61fUrduFZx+1pCVMnVu+/aw71JERERERESkFAqaxIKmY4+11zXVp2n7duuc3a0befHxpTcDD1Q0rV0LzZvbrmAOtHw59OwJjRrZ73FxVrV02GHWEHvIDy8zpdet0K+fVTkBp52GHRAdDT//TFycZWcZGcD48dag6PHHiw1z40bbdspbRyt2FhteuPXr7fw5OfDFFzad7aDWrBnExBSraCooKL54oIiIiIiIiEhJB/s/l6U8wSTmuOMs1ampoCnYCLxbN3Lj42H1aksqoNSpc8ccY5cPD5r69Cl+yg4dYO5ceOcd2F7YirNWvsp5FzVm/HgrjvrVr7CT9O9fVNEEsDV5Hdxyi/0ybVqxspxg0NR5z/Iyg6bdu+HMM606asoUWw3voOfzWVVT2KpzoD5NIiIiIiIisn8Kmg51wcY7HTtaI6SaaggeDJoSEsjr2hXy8kINmDIyrCQoUMa0Zo1Ni0tIsKCpsNCCpsMO2/e0jRrB1VfbDL9nn7WeTZ9/DqecErZY3MCBFjS1tUBp6+8DVUz33Qfr1oUaQBFW0fTu07QK9AEvGTTddhv88gt89FGoD/khoX37YlPnQEGTiIiIiIiI7J+CpoPE9OnQqVPp0772K5gctG0LRxxRcxVNwcZLwYomCE2fy8iA2Fjw+dizxyqFEhIsbFq50vomZWXtW9EUrnFj+OMfLXC68057XWTgQNi+nbhcC7a2LNwAr78ON9xg70+bVnTohrRCmkfupfnKBbR69k9FwwsaP95aOz34YGBq3qEkLGgKVjSpIbiIiIiIiIjsj4Kmg8S8ebBpk1XeVEp40NS/v01xK6sbdmWsXWs9ftq1s4omCAVNO3cWNQIPK3wqCpqWLbN9pVU0ldSlC/z1r6EWU0BRQ/B2N18MwNaRN8BvfmMX6NYNvv666NCNU36mc8E6+PvfaXXakKLhBYd7881w/PHw8MOV/woavFKCJlU0iYiIiIiIyP4oaDpIpKfbdtWqSn5w61bbBiuaAJYsqf6A1q61UMfnI69jR5vXFl7RFNafCezQXr0s5Jk92/btr6JpvwYMAJ+PdjtXALD1+JG23+ezsqTp061f1HffsXH5bjp1iYTrrw8OqShoeuMNq6waPz7UlPyQEgya/P6ifleBlk0iIiIiIiIipVLQdJCoctBUsqIJaqZP05o1lh6BpTQJCaUGTSUrmgAmT7aF47p0qeK1mzeHCRNo/tPXNGlSIhw57TRLkpKS4A9/YENkNzod2x1gn6Bp+fJQ76hDUvv2kJsLu3bRpo39TdLS6npQIiIiIiIiUp8paDpI1EjQlJBgy9rXZEVTUM+eZVY0NWoEnTuHgqYffrBqpojqPJ0XXIBv4JG0axcq2gJg+HDb3nILafM2sj4ink5drVypUSPLqMKDpt69qzGGhq59e9tu3ozPB/HxCppERERERERk/2p1QpBzLhqYBTQJXHuC53mPlHHshcAEYKjnefOcc92BFMALHPKT53k3HfhRNwzVCpqioixh8fls9bliyUwV5ORYw6jwUqCePW3Ztq1bYccOm96GBU3x8TazrmdPO7SgoBrT5krYJ2jq0AH692dl0g5OazybqCaRjB4dertVKwua/H5YscJWsztkhQVN9OlDfLwt2iciIiIiIiJSltruPJMDDPc8b7dzLgr4zjk32fO8n8IPcs61AO4EZpf4/ErP8wbW0lgblE2bbFuloKltWwuZIJS0VEew7CW8oqlPH0t84uLs90B36fAZds2aWc61aVPFGoFXRFzcvn2FUodeykmLriE7uj3Tp/kYNCj0XqtWVnC1aRPs3VtzgVeDFB40AV27wqxZdTgeERERERERqfdqNWjyPM8P7A78GhX48Zdy6J+BZ4A/lvKelJCfbxlOZKRVnOTnV6J59bZtFHV6hpoJmsI7fAddf71VTeXnk18YQeQFI/EFDj355NBhvXtbyFOTFU2rVxff93arP7ApIoYF3/uK+p8HBW9/xYrQeA5ZJYKm+HhYv94qziIj63BcIiIiIiIiUm/V+lpazrlIIAnoDbzmed7sEu//Cujqed7/nHMlg6YezrlkYBfwoOd53+7vWoWFhaSkpNTg6OunLVsi8fsPw7ksfvklhhkzVhAfn1ehzyasW4c/Joa1ge+pS0QEjdPTWVWN763ljz/SGViRm0teSgrZ2dmkbNoEw4YBcM45PTnmpz3cf38K69f3pVmzbaSkWNlRu3adgFZERa0mJSWrymMIiojowObNLUlJWVa0b8mqTrRrF0Vk5ApK3mZkZDybNjVi5swdYHdBSkrFvsuDTm4uicCWJUvYmpJCVFQr8vM78f33y4mLy6/r0VVYdnb2IfG/A1K/6TmU+kbPpNQneh6lvtCzKPXBwfAc1nrQ5HleATDQOdcK+Ng5d4TneYsBnHMRwIvANaV8dCPQzfO8bc65wcAnzrnDPc/bVda1IiIiSExMrPmbqGdyc2178skx/PILREb2psK3nZUFffuGvqeuXSElpXrf29q10KIFvYcPh6goUsLOt22bTe9btaoJRx3VhsJCGDy4HYmJVlU1ZAh88gmccUZ3OnSo+hCCnIN//xt69UqkcWPbt3evFVuVdo/BPkR798bQqBGcemrvileHHYxatybO7ycuMZEhQ2xXdHSfij9f9UBKdZ9nkRqg51DqGz2TUp/oeZT6Qs+i1AcN5TlMSkoq8706W3XO87ydwAxgRNjuFsARwDfOudXAMcCnzrkhnufleJ63LfDZJGAlUEOdfBq2YCPwY4+1baX6NAV7NAVVd+qc3w9Tp8Jpp1mT8RKWBQqLWrSAu++21+Ez7G6+GSZNokZCJrDV7AA2bAjt27AhtL+k8KlzPXpUYgriwSourliPJoC0//4Izz1Xh4MSERERERGR+qpWgybnXFygkgnnXAxwOrA0+L7neRme57XzPK+753ndgZ+A8wKrzsUFpt3hnOsJ9AFSa3P89VUwaBo82HrnlBY0ffop3HuvBTkPPACFhVgoVDJoatkSdu+2Rk9V4XnWeOnMM0t9Oxg0jRsHTZrY6/DF6dq0gfPOq9qlSxMMR8JXSysvaMrIgOXLD/H+TEHt24d6NHWxdmrrnv8AHn3Unh8RERERERGRMLVdr9EJeDcQGEUA//E873Pn3Fhgnud5n+7nsycBY51zeUAhcJPnedsP/JDrv+CKc126WLBSWtD0u99ZphQTA5mZcPXV0LdzpgVKJSuawNKW8P0VNWWKbfcTNDVqBGedBa+9Bi+8AN27V/4yFVUyaMrJse9hf0FTQQH88guceOKBG1eD0b49JCXBuHG0/fIrovk7aU2dzT/ctcuCSREREREREZGA2l51biEwqJT9D5dx/MlhrycCEw/Y4Bqw9HSIjrbpaD177hs0FRbCli3wpz/BGWfASSdZG6W+TbYBUNC6HRvWBUKZ6gZNU6daY6Qy0qNly2yMUVFw7bX2cyCVDJo2brTt/oImsL5XNbXyXYOWkAAffQSjR+Pz+Yhv9QLr+p4DP91qS9ApaBIREREREZEwddajSarB77fpbQHp6dCxI/h81leoZNC0fbuFTXFxoWlqa9ZgpT3A+0sG0KtXIIwJBgdV6dOUlQXffAMjRpR5yLJlcFgtdtZq0cJuKRg0BXs1lRc0gabOATZFbuZMmxKZmUn8wHak7Ql8SeGNr0RERERERERQ0NQwTZ5sU5rWrgUsaAo2z+7Rw6bSZWVhYdF777F1i/XSiYuzgCUyMvDRQNC0YFMH8vJgxgxCSUtVgqZvv4Xs7DKnzRUWWu+j2gyawKqaKho0hRfoKGgCYmOtBO6ww6BZM/sutzW199avr9uxiYiIiIiISL2joKkhWrHCkqT//Q8IBE3NdsPvfkePLrkArF4NjB0LV1/NlnlrAGjXzvojdelSPGhK3RoLWOFKtYKmKVOsw/ewYaW+nZZmw67toCk+3q4NFa9oiow8sL2jGqr4eNiwuREFRKiiSURERERERPahoKkhysiwbaDxdno6dNj0M7zxBj0WWT/1VUtz4J13ANiSbClLXJx9rFu3wNS5rVsBSN0YDdist2I9mipryhSrfmnatNS3gyvO1XVFU1RU2e2ngrffvbsdJ8V17Qr5+T7SYw9TRZOIiIiIiIjsQ0FTQxQMgaZNo2BvDlu2+Omweg4APf7zDACrPkqGHTsA2LrUAqXwoClY0eQHVq5pRNOmkJoKaburWNG0ZAmkpMCvf13mIcGgybnKnbq6una1ZujZ2RY0deoEEWU8+cGgSdPmShcfb9t1bQdWq6IpLw9uv92eORERERERETl4KGhqiIJB0549bP1iDoWFPjrsTYWrr6ZD2jxiGuez6uuVkJgIffuyZZU1Dm/Xzj6WkGAVPgVbtrMttieZmT4uusjemzm/hXUVr2zQ9OGHlt5cfHGZhyxbBs2aWdBTm4Irz6WlWTZS1rQ5CPVo0opzpSv6LlskVitomjsXXn0VvviihgYmIiIiIiIi9YKCpoYoI8NKSxo3Jv3zuQB0bLITXnsN3xFH0K1gNWs3RcFNN8GAAWzZkEeLFtY+CayiKT8fNq0vILXFkQCMGmXVPN/MirAG0JUJmvx++OADOOUUW/6uDMEV53y+Kt95lQTDkXXryg+aGjeGJ56A666rnbE1NEUVTU16V2vqXFKSbbdvr4FBiYiIiIiISL2hoKkhysiwtOTEE0mfvgSADif0sXKh++4jvmA1aRHd4KqroH9/tu6KIq5tYdHHExJsu3ZjFKnR/QCr4DnxxEBD8JYtK9ejaf58W07ussv2e5jn1X5/Jqhc0ATwpz/BoEEHflwNUdu2EB0NaRFdYeNGW0qwCubNs62CJhERERERkYOLgqaGKCPDwqCzziJ9XQ4AHS443t679FK6tNzN+maHWYlS//5sIY52TfcWfbxbN9uu2dKUlRE2R6xHD1ssbvly2NCsD5+kOO68E3JzKzCeDz6w5ewuuKDMQ3JybCW8ugiaglU4nhfK6KRqfD77PtfldYSCAti8uUrnCQZNgTZiIiIiIiIicpBQ0NQQBYOmESNIpwMAHS48wd6LiiL+5vPYkNWaggKKgqa4yFDpSDBoWruzBamF3enY0RaKO/lk2z989T8ZNecBXn4Zxo8vZyyFhdaf6cwzoU2bMg9LTbVD6yJoatrUKnHmWL90BU3VFB8PaXsDf+sq9Gnavdv6xoMqmkRERERERA42CpoaomDQ1K8f6W360SQyj9j20UVvd+kaQX6+z4pNundnqy+OuPxQINCiBbRuWcianS1J9fegZ0/bP3CgZUVpue15rvOLHHkkPPNMObOjvv/e5qSVM20u2JOntlecC+ra1RpQg4Km6uraFZanx5JFdJWCpuRka+vVqJGCJhERERERkYONgqaGKBg0+Xykn3kVHbo0KtZgOzhVbP168PsibOrc7jXFTtEtdgdr6cbKvR3p1cv2RUbCDz/AsvPv457Gr3DffTbd7NNPyxhHdratUd+2LYwcWeohL7wA557bk9GjrRl5XQVN8fGhtlMKmqpn9GjYsiOKP/JcqQ3BN260IKnI4sX2nPzyCxCaNnfssQqaREREREREDjYKmhqavDzYu9eCJmDTtig6diy+jFswaEpLgz17INsfTdy2pcX+9Z+Qn8qyRv1IS48qqmgCC4I6dwZ27uTii61309NPlwgOgu6+GxYsgHfftTKpEv7zH7jnHmjVqoCXXrLQKja2ul9A1QQbggN06VI3YzhYnH463PX7Ql7jNibNKP53X7PGms3fe2/glyuugAED4NVX4ayzID2defPsGU1MVNAkIiIiIiJysFHQ1NDs2mXbQNCUng4dOhQ/JBikpKXB1q32ut3eNXYwQH4+3bYlsyy/F36/r1jQBFgT8YwMGkUUcs89MHs2zJpV4piJE+Fvf7Mk6Zxz9hnmpk1wyy0wdCi8884a7rgjtNpdXQgGTTExRV+dVMOTT0fwq0YLue6T80hLC+2fONGy0Oefh0kDHoKPP7bU6auvYMsWGDWKeXMLGTLEpmnu2FFGiCkiIiIiIiINkoKmhiY4/yuQlmzbZjPXwsXFQVSUzWrasiWwjy2waJH98tNPdMtdXnR8cOpckZYt7V//u3dz7bV2/jfeCHvf77epUEOHwhNP7DNEvx9++1urpnrvPevFU9eCQVPnzhSbZihV06QJvH/YI+zObcKzz4b2T5zo54huGQyOmM81u19h1WeLrSTutNPgvffI+HEJy5ZHFAVNeXn2nOzjhResGkpEREREREQaFAVNDU2JoCk721ZVCxcRYVVNaWllBE2TJ5PgW1d0fKkVTQA7dxITAyNGWEFKUVPwjRvtZ/RoChs13meF+3fegc8/h6eegr59q3W3NSY8aJKacVivAi5u+SXvvgu7v/yBDSdeyg8/+Lh07XP8t9+j+Ju34MqHwx6uiy5i/lljABgy2F+0SOE+0+fy8+G55+whwmZn5uXVwg2JiIiIiIhItSloamhKCZqio/c9rEsXq2gqmjrXqTG89hqsWAFTptBtgIVJMTHQsWOJD4cFTQBnnAGbN9s/+IFQYDVgAG+9ZeHNlCm2a80auPNOGDYM7rijBu63hihoOgA6d+ZW/6vs2gXjr/iCjxdaadyFfx5Ej5/eZ+yfI/jhh9DjAjAv6jgABidsLTto+vprm+a5axfTp+QycCB8+GEt3I+IiIiIiIhUm4KmhqaCQVN8fImKpvdesP5OxxwD8+eTcFY/wKqZ9plKViJoOv10+/XLLwPvB5OD/v2ZMQMKCuCSSyyIuu46mzr39ttWWVVfdOli96mgqQZ17swxGVMY2G0br229hAnd/kBiIiQ+eCE0a8bll9tKhuPHhz7y2cpE+rCMdhkryw6axo0DwA/cd581cFq69MDfjoiIiIiIiFRfPYoCpELCgqb8fJtlVFZFUzBoioqC2FOHwg8/FIVIHS4+iaioUqbNBc4dfq1OnWzhsKKgaeFCS2zatOGnn+CEE2w1ueOOg+nT4cUXbbW6+qRJEws8brutrkdyEOnSBR9w644nWMQAvlkcx4UXht6Oi4Mzz4R//9umXc6ZA98uacvNvA6pqbRubccVC5p277YG4gkJTOAi5i1sAsCqVbV2VyIiIiIiIlINCpoamrCgKSfHXpZV0ZSVBcuXQ7t2gaqlPn3gp5/giy+I+NVArroKLriglGuUqGgCmz733XeBxs2LFkH//mzZAqmpcN551k4nIsIWoLvhhpq84Zpz+eVlBGtSNYHysMsz/0HLprkAxYImsH7e69bBt9/aSnQtW/q5gTchNbWoomnHjrAPfPwx7N1L3u138See5IiEXQwbpqBJRERERESkoVDQ1NCEBU3Z2fYyJmbfw+LjbZucbJUlRdq1g7POAuDNN+Gaa0q5RhlBU24uzJpRACkpMGAAs2fbe8ccAwMHWuj08cda1e2Q0aULAM16d+buextxwglw5JHFDxk5Epo1gyefhIkT4aabfLToHFssaCpW0TRuHHTvzls5V7CCPjx93o/07m3PloiIiIiIiNR/CpoamowMK2Fq3JisLNtV1tQ5sEqQYkFTRQSnzoUFTSecYNeZ+p8MyMmB/v356SfrwTN4sB0TF2fT9OQQ0bOnzat8/HEeeiSCb7/dN2Rs1gxGjbJpl5GRcPvtgc+lphITY1Mai4KmjRutEfiVV/L+lNYMYAFnt59Hjx7WG3zv3tq+QREREREREaksBU0NTUZGsUbgUPbUuaB27Sp5jagoaNo0VD2FVU0NGwZfTo+0HYGgacAAO1QOQc2b29KGl16638OuvNK2v/lNIAANBE0+H7RpExY0ffABFBaSdeGV/Dg7gjMaz8S3Ob2o39fq1QfqRkRERERERKSmKGhqaCoYNHXqFKouqXRFE9j0uZ07bQm5Y4+FRx9lxAhIWd+S+RFDKDgskTlzbNqcHMIqME/ytNNs6tzjjwd29OxpnepzcooHTf/6FwwZwo/bHbm5cHK7xZAeCprUp0lERERERKT+U9DU0FQwaIqKgg4d7HWVgqaWLS1omj/fGog/8wzXjthIu8YZ/DH6FVJSm5CZqaBJyhcZCQ88EFZl17OnBZhr1oSCpiVLrKHY6NHMmGGfOTFhLaSnFzVwT7KvBgAAIABJREFUV9AkIiIiIiJS/yloamgqGDRB6B/2lZ46B6GKpgkT7F/9+fm0/NtTPNz8L0zfewyPPGKHHX10Fc4th7ZgcpSaSuvWgVXnxo+35+zSS/nmG+v7Fdu5OaSn0769Tc9UQ3AREREREZH6T0FTQ7NrV4WDpmBD8GpNnZswAYYPt+Xp/vEPbtz+JH3abuOjj6B1a+jTpwrnlkNbWNBkFU1+C5rOOIO9LTowezacfDJWkpeejs8H3buroklERERERKQhUNDU0JRS0RQTU/qhwYqmKgdNixfDihVw0UUwZgz4/TQmj6d/a6UlRx8NEXqCpLI6drR0NBg0bSmEtWth9Gi+/x7y8uCUU7CgaccOyM2lRw8FTSIiIiIiIg2BYoKGJixoysqyXQdk6lzLlpCTY0nS+edbScn11wMw6sb23HYb3HRTFc4r4vNZVdPKlbRpA3uyI8lp2hrOO6+oP9MJJxBqMrZ5c1HQ5PfX6chFRERERESkHAqaGpKCAti9u8JT5046CY48kqJVuyqlVavQSdq3t9fPPQeTJ+PrnsArr8DIkVU4rwhY0JSaShv/NgB2/OZWaNaMGTNg6FBo3pxQ0BRoCL5rF+x4f0rdjVlERERERETKpaCpIdm1y7axsUD5QdNxx8HPP0OzZlW4VjBouuii0L7mzWHEiCqcTKSEYNA082MAtl9+K7t3w9y5gWlzUCxoCoalq64dG/rvQEREREREROodBU0NSUaGbStY0VQtffpYsHTBBQfg5HLI69kTdu+mzfQJAOxo0pHvvrOivVKDpu42Zy41twt89FEdDFhEREREREQqQkFTQ1KbQdOoUZCeDp06HYCTyyEvsPJcG7YDsH07zJgBUVFWiQcUD5qiNwKwih62Qp2IiIiIiIjUSwqaGpIygqYmTQ7AtXw+aNr0AJxYhKKgqfV5JwKhoOmoo8KmejZrZj/p6cQum0dbtrKqy4kwbRps2FBHAy/fkiXQv78t2igiIiIiInKoUdDUkJQSNDVqZD8iDUq/fvD007R58h4AVq+GpKSwaXNBHTpYZd28efRgFau6DbOl5z74oNaHXBHZ2XDZZRYyzZhR16MRERERERGpfQqaGpISQVNWFsTE1OF4RKrK54P77iPWdSIiAj79FAoL9xM0JSXRM3YbKzbHwpAhMG5cnQy7PPfdZyFTo0awdGldj0ZERERERKT2KWhqSEqpaDog/ZlEaklEBLRuDfPnQ+PGcOyxJQ4IC5oG9s5k5UrYfv51kJwMv/xSJ2Muy+TJ8PLLcOedMHgweF5dj0hERERERKT2KWhqSP6fvTsPj6o++z/+niwEQiB7AkmAsJ4EUEDZxKUqLrhvtdVata2tS7U/q9bui7W19dHWtk+rfVzq0lp3q6KouCJuZd8Jh0WWsCUQAoEEyDa/P+6ZyUwygYQsMyGf13Vxncw5ZyZfyjjPk0/u+/4qaJKjUFqaHSdPDlOhl50Nq1dDSQknnGQ9onPyLrNr77/feYtsgb//HQYOhHvvhYICVTSJiIiIiEj3pKCpK9mzx8o+fOmSgiY5GviDpiZtc2BBU00NAOMvzCEmBj5fmwl9+0ZdkrN9u42e6tkTHAe2bIG9eyO9KhERERERkc6loKkr2bMnUM0ECprk6OAPmk49NczF7Gw7xsaSdMIxHHss/HeOBwoLoaios5bYIqVuOZlrPgWsogmsGMvP643AokRERERERDqZgqauREGTHIXS0iAhwVrnmvAHTSNHQmIiJ5wAc+ZAfcHI6AqaNm+mtCKBrPVzYP/+QNDkL7pau9b+012wIHJLFBERERER6QwKmroSBU1yFLrtNnjyyWbey/6gafx4wMKoigpYmXYSbN/OEw9WcfvtnbbUZlXe/xD7SSSrfjvMncvQoRAb2xA0TZ9ubXRLlkR2nSIiIiIiIh1NQVNXEiZoajI8WaSLOf54uOKKZi7m5dlx4kSgYVe6/9Ycz26Sue3HPfjTnyI8F3zPHkr/8ToAmeyE2bPp0QOGDGnYee7dd+1YWhqhNYqIiIiIiHSSuEgvQFphz56GCg9g/37IzIzgekQ6Wn4+vPcenHQSAMOGQXo6fL49ny3cyp59cWRmwg9/CPPmQUwkovOHH6a0MhGArPxEmD0baNh57uBB+Ogju7WkJALrExERERER6USqaOpKKipsty0ftc5JtzB1qg1xAjwea5/7YH5f/sz3uWjYcv74R1i4EJ5//shefscOGDDAgqpWO3gQ/vIXdow5A4CsCYPgs8+gpgbHsWHgn3xioTCooklERERERI5+Cpq6kqoq6N078FBBk3RHJ5wAGzZ42E0qv+z/GFddBWPGwM9+BtXVrX+95cth8+YjHNT9xBOwdSulU68EIOvUkfbf6aJFFBRYDvXYYzavadQoVTSJiIiIiMjRT0FTV1JVBYmJgYcKmqQ78s9pujBnHsdtfYOYGLj3Xli/Hp57rvWvV1xsxx07WvnEAwfgnntgyhRKM0YBkDnteLs2e3Zg57mXXrI1DxumoElERERERI5+Cpq6ivp6679R0CTd3IknwnXXwX0Xf27p0oEDnH029O8Pb7zR+tfzB007d7byiY89ZqVQd9/Njp0eeveGxCH9YPhwmD0bx7HbamvhzDNtvJpa50RERERE5GinoKmrOHDAjgqapJtLSLCMxzk5ywLYNWvweODcc+Gdd6CmpnWvd0QVTfv3w+9+B6ecAqefTmkpZGX5rp1yCnzyCRlp9aSn26kzz7TrO3dCXV3r1iciIiIiItKVKGjqKqqq7OgLmrxeBU3Szfl704qKAAua9uyBzz9v3cscUdD0yCOwbRvcfTd4PJSWBu0AecopUF4On32G40ByMkyYYBVN9fVQVta69YmIiIiIiHQlCpq6ikZB08GD9rBXrwitRyTSHMe2ofMFTWecAfHx8OabrXuZI2qde/ZZmDgRvvQlgNCKprPPhowMOPNMfuS8ygN/qCcuzoIm0JwmERERERE5uilo6ioaBU3+TjpVNEm31asX5OfDqlUA9O0LJ58MM2a07mVaXdFUWWlb1E2dGji1Y0dQ0JSdDcuWwVlnceETl/CtWdcADdcVNImIiIiIyNFMQVNXoaBJpKnCQuuV27ULsPa55cth02//af2lh7FvH+zeDXFxFha14CkwZ45N+D75ZMCeE9I6B9CvH7z6Ktx0Ezz/POzZE6ho0kBwERERERE5milo6ioUNIk0dcstNivppJNgzRrOXXQPAG/94lP44Q8Pmxxt3mzHUaOgutqCp8P6+GNr2ZsyBbC5UDU1QRVNfh4PXHmlhVLvvquKJhERERER6RYUNHUVCppEmjrnHNtqbts2KCig4N8/J79vGc/m/IDKPzwEt99+yLDJ3zZ33HF2bFH73Mcfw5gxNuU76DlNgiaAE06A1FSYMYPUVJshpaBJRERERESOZgqaugoFTSLhfelL8MknMHUqnuef56afpfPR1uEMS9zGw3+uot/tdzZbquQPmsaNs+Nhg6aaGmvVO+mkwCl/K1zYoCkuzoaDv/kmHm89WVlqnRMRERERkaNbXGd+M8dxegKzgQTf937Jdd1fNXPvZcBLwATXdef7zv0EuA6oA/6f67ozO2Xh0UBBk0jzRo2yyibgh8CJJ8KPf9yHGz95mHUz7+O+iRPhP/+BgoKQp/mDprFj7XjYnecWLbL/Fn3zmaAhOAqZ0RTs3HPhuedg4UKyssaroklERERERI5qnV3RdBA43XXdMcBYYJrjOJMb3+Q4Th/gVmBO0LmRwBXAKGAa8JDjOLGdsupo0EzQ1KtXhNYjEsVOPBFmz/Zw/fVwPz/k7a3HwCWXNLmvuNg2icvNtceHrWj6+GM7hgmawlY0AUybZvOaZswgO1sVTSIiIiIicnTr1KDJdV2v67r+HpZ4359wA1R+A/wPcCDo3EXAc67rHnRddz2wFpjYkeuNKo2Cpv377aEqmkTC83jgz3+GESMOcHXtE2xdtaehhMln82YYMKChGulQQZPXC48/3YP9g0dC//6B8/7nNFvRlJkJkyYFgiZVNImIiIiIyNGsU1vnAHxVSAuAYcCDruvOaXT9OGCA67ozHMe5M+hSLvDfoMebfeeaVV9fT1FRUfssPMLSN2wgC1i1aRPe0lLWru0D5LF16xcUFR2M9PIO6cCBA0fNv4N0Pb//vZerrxrB9TzCw888Q8WFFwaurV07hPz8aoqLNxMf7+C6uygqCk2b4rZupdfy5SytHM51i7/HnjFxTAt6P69alU2fPsmsW7e62TVkTJhA5l//StzQYrZvz2XlShePp/3/rhK99Dko0UbvSYkmej9KtNB7UaLB0fA+7PSgyXXdOmCs4zgpwCuO44x2XXc5gOM4McADwDfa43vFxMRQWFjYHi8VeUlJABSMHQseD4sX2+mRI4fgOBFcVwsUFRUdPf8O0gUV8d3vxvCXB84ifdUMcn/U8F4sLYVzz01g5MhCsrKgvj6DwsKM0KffdhvMnMkqpgLnsijxTG4rHBa4XFsL/fpx6Pf49dfD3/5G4ewXqam5ndzcQpJj98GCBdaGF6N9GY52+hyUaKP3pEQTvR8lWui9KNGgq7wPFyxY0Oy1iP1047rubuBDbN6SXx9gNDDLcZwNwGRguuM444EtwICge/N857qHqiprm/OVQWgYuEjLnXBiDDX0YMn7DdVKe/bA3r3WOgfW4dakda662uYyXXkl5T+5H4DPSoaG3LJjxyHmM/mNHg2vvUZWuQtAyddus+FQp54Kr77a6r9PfT0884yFXCIiIiIiItGkU4Mmx3EyfZVMOI7TCzgTWOW/7rruHtd1M1zXzXddNx9rlbvQt+vcdOAKx3ESHMcZDAwH5nbm+iPKHzT5KGgSabmJvmluc4v7w9atQMO4Jn/QlJEBO1aWwq9/3fDE+fPtv73LLmPXoHEArPvCEzJnqbS0BUETwAUXkP2QbbJZOnsVfP3r9h/wp5+2+u/zySdw1VUwfXqrnyoiIiIiItKhOruiqT/woeM4S4F5wLuu677hOM7djuNceKgnuq67AngBWAm8Ddzsa8PrHhQ0iRyxvDzIyaxmDpPgo4+ApkFTZt8D7Fy/F37zGygrs5OzZtnxlFPYtavh9T7/vOHr0tJDDAJvJHtcDgAlj8+Ahx+G446D//73MM9qasMGOy5b1uqnioiIiIiIdKhOndHkuu5SYFyY879s5v5TGz2+B7inQxYX7RQ0ibTJxCnxzH19Mnz0B7jyyqZB08YF7PCOhro6+M9/4DvfsaBp9GjIzKS8HHr0sHs//RQuvtha2HbubGFFEw33lezwZfyTJ8NDD1mLnv/FW8C/9hUrWvwUERERERGRTqEJtF1Fo6Bp/34b19SKn01FurWJkzysqR/Grg9skv7mzfbfUP/+QGkpGUvfp4JkDg4dCc8/b+HPp5/aHCVg1y5IT4fx4+Gzzwicq69vedDkr3wqLfWdmDTJUuOlS1v1d1HQJCIiIiIi0UpBU1cRpqKpZ0+0RbpIC02aZMd5a5Lh979n3SPv0T9+B/H/fhJ++1sya7cDUHbeNdR88DF/uH41e6ri4LTTAAuV0tJgyhQb3XTwYEPQ09KgKS7OwqrAjCf/oubMadXfxR80rV5teZiIiIiIiEi0UNDUVTQTNIlIy4wfDx6Pl7lMpPinD/Fy6cmc3Ws2fPOb8Ne/knmKbSG64+RLmek9kzufGs10LoRTTgGgvNyCphNPtHDno4+suy43F846q+XryM4OqmgaOBD69QsETSUlcMwx4LqHfo3iTV5iY73U1sKaNa39X0JERERERKTjKGjqKhQ0ibRJ375QWOhhzsTv8evLl+ONT+BXiy+FDz+EW28l45YrANiRPIw3Uq4GoKTfWNuODqtoSk2FE06w17vqKli7Fp5+2s63VHZ2UEWTx2NVTb6B4IsXw/Ll8M47zTzZ64U33qB4ZQUn1H0C2P0ARUUWhKmdTkREREREIklBU1ehoEmkzSZOhI9WZvHkf5K56SYYlO+xGUx//jOZI22A0o6dHmbUTwOgpP/YwHP9rXPZ2TB0qA0B/+lPAyOcWiw31+ZDBUyebGVJZWVst+695kc2/fjH7L3gSnbXJ3NGygJiqGPFci8AL7xgVVeLF7duPV3Oc8/BjBmRXoWIiIiIiDRDQVNXoaBJpM0mToR9++y/nZ/+NPSaf1D3hx/C5opkAErSRwau+1vnwKqZzjkHfvWr1q8hP99mLNXU+E745zTNnXvooKmuDh57jOLTrgVg+CWjGcZaVnyyC4A33rDbtm5t/Zq6lLvvhp/8JNKrEBERERGRZiho6ioUNIm02ZQpdrz99qYDvNPSrJPt+eft8cCBXkpj+wM2+LuysiFo+vWv4c03IT6+9WsYPNh2qgtUNdnwKJgzJxA0LV9uuVKIBQtg1y6KJ30ZgAFfncKouNWsWHiQbdtsQDl0g6CpvByWLbOSMhERERERiToKmrqKRkHT/v3Qq1cE1yPSBY0ZYxVLv/hF02uxsRYkVVTA8cfDscd6ArOUysvt2JpZTM3Jz7fjhg2+E336wOjR8Pnnge9XVQVffNHoiW+/DR4PxdnjARjgJDJqXDxrK7J45Z97AQufj+qgyeu1HkaA2bMDp/fvtzBQREREREQiT0FTV1BTY39U0STSZqee2nwlkr997rzzQneH82cb/oqmtvAHTevXB52cOhVmzWL75lqSkuzUsmWNnjhzJkyYQHF5Eh6PzXoa9dVjqCOOP91fw8CB1oV3VAdNVVW25R9YYuhz/vlwww0RWpOIiIiIiIRQ0NQV7N9vRwVNIh3Kt8Ec559vrXWlpdbm5q9oao+gacAAiIkJqmgC+MpXoLqa7ev2ccopdj1kTlN5ue1Md/bZFBdD//4Wlo06KxeAtWVpnH++hU9HddDkT/wAZs0KfLlsGXz2WecvR0REREREmlLQ1BVUVdlRQZNIh8rNhX79rHUuOxtqay3j8ecb7dE6Fx8PeXmNKpomT4aBA9m+I5bBg2H48EZB0/vvW+I1bRrFxRZWAYwYAbEeG+Z0/vmQk2NBk9fb9nVGJX/id/zxNshqxw4OHoQdO2DdOvtcFBERERGRyFLQ1BUoaBLpFPfdB+++axVF2dl2rrS0fVvnwNrnQiqaPB4OXnIF5TV96Je8n2OPbRQ0vf02JCfDxIkhQVNCAozIKCeRSk6bWEn//vbZsHt3+6wz6vj/IS65xI6zZwcquOrrYfXqyCxLREREREQaKGjqChQ0iXSKgQNtLjc07EpXUtK+rXNgO8+FBE1AydSvAdBvywKOOcaGge/bh5Unvf02nHkm3ti4kKAJ4FtnbOIO/kjP0k3k5Ni5bdvaZ51Rxx80nXWWfR7OmtWwex+wYkVkliUiIiIiIg0UNHUFCppEOp2/oqmkxPINj8eKitpDfj5s2RK6U9r2rGMB6Lf0HY491vKlFSuAzz+3m88+m/Jy+zgIDpp+8N0q7uZXsKkhaDpq5zT5E79+/eDEE2HWLLZsabi8cmVkliUiIiIiIg0UNHUFCppEOp2/osnfOpeSYi117SE/34Kk4uKGc9tLPAD0WzKTY3PLAFi6oAauv96GR11+OZs22b3BQRMDB9px48ajP2gKHpZ12mmwfDmbV+wBbEC6giYRERERkchT0NQVhAma9u+HXr0itB6RbiA9HWJjG1rn2qttDqx1DkLb57Zvt2M/7zYG3XgOfZLqWfrEfCtrevRRSE4OBFMhQVNOji100yb697dTR3XQFB8PvXvDpZdCQgJbnnyXpCQvkyerdU5EREREJBooaOoKGgVNtbVQV6eKJpGOFBMDmZkNrXPtGTTl59sxeOc5f9CU9eKDxKxczjHVC1k0vx6++U045xygoQLKX8QEQFycbWO3cSO9e1t731EdNKWlWR+j48Ajj7B5s5e8+FJGjYK1a0PbEUVEREREpPMpaOoKGgVN/i28FTSJdKysrIbWudTU9nvd3FwrQmpc0ZSeDj0uuwBmzeLUuI/5L5PY9Ys/Be4pLraCHv/8qICBA2HjRsAKnI7aoKm8PPQf4ppr2NxvArnlyxi5+zPq6mDNmsgtT0REREREFDR1DQqaRCIiO7tjWufi4iwbahw09evnezBxIhe98k3qiOPNTxsmkBcXW0jVZFbUoEH4Bzgd1UFTmNKyLfGDyOtTwciFTwNqnxMRERERiTQFTV2BgiaRiAiuaGrPoAmsfa5x61wgaALGn5FC//7w2mv2uKYGPvoIRo4M82KDBsHmzVBb262Cpro62LrVQ25WNc6BJcTEaCC4iIiIiEikKWjqChQ0iUREdrYFQI07ttpDfn5oRVNJSWjQFBMDF14Ib79tc4deesmypO9+N8yLDRzoT10CQZPXG3pLRYX96dIa/UOUltpfOy/9AD3LtzF0qCqaREREREQiTUFTV1BVZb028fGAgiaRzpKdbTs81te3f0XT4MGwbZv99+z1Nq1oArjoIti3Dz74AB54wOZf++aChxo0yI6bNpGTY9VPZWWht1x+OXzlK+37d+h0jSqaNm+2Y252LezcyciRqmgSEREREYk0BU1dQVVVoJoJ7AdfUNAk0tGyshq+7ojWObAZ3vv22X/mjYOm00+HpCT42c9g/nz4/vfDzGeChm3oNm4kJ8e+DG6f27vXwqr589v379CpamqsJCvoH2LLFjvm5QF79zKqoI41a6C6OjJLFBERERERBU1dQ6OgyV/R1KtXhNYj0k0E7+7W3q1zgwfbceVKq2aCpkFTQgJMmwaLFlm+cs01zbyYP2jatIn+/e3L4KBp1iyorbUqp5072+tv0Ml277Zj0D9EoKIp36o9Rw6ooLZWO8+JiIiIiESSgqauoJmgSRVNIh2rIyuaJk60IOsf/2g+aAJrnwO46aaQj4FQvXtDRkazFU3vvtvw9apVbV56ZJSX27FRRVN8PGQOsv9hhqdav+DatZ2+OhERERER8VHQ1BUoaBKJiOCKpvYOmnr0gBtvhBkz4OOP7Vy4oOmyy+BXv4I77jjMCw4cCBs3Biqatm1ruPTOO1BYaF932aBp1y47NprRlJsLMVkZAAztbYndunWdvjoREREREfFR0BSlXn4Z5s3zPVDQJBIRHVnRBHDDDVaR84c/2OPgYMuvVy+4664WtO4NGgSbNtGzp63VX9G0aRO4Llx3nX1mFBW159+gE/mDpkatc7m5WDUXkFa9neRkBU0iIiIiIpGkoClK3X473H+/70Ezw8ATEjp/XSLdSY8ekJJiX7f3jCaA/v1tJ7jycoiNhfT0NryYr6IJr5ecnIagyd82N22a7VrXZSuammmdy8sj8D+cp2wnQ4cqaBIRERERiSQFTVFq796gob2NgqaSEjsGV1uISMfIzraqoo6qILz11obvE3ZHuZYaNAgqK6GsjJE5u3n7bS8zZljbXE4OjBwJBQUtD5rKymz4uL+QKOIatc55vUEVTf6ErqyMYcMUNImIiIiIRJKCpihVWdl80LRpEyQnQ9++kVmbSHeSnd0xbXN+EybAiSfCkCFtfKFBg+xYWMiD7wxjVPUiLr6onjfegDPOAM+8uRQkb2P9+ob2W7/qanjoITv6zZwJ//qXBVVRwR80+UrMdu+26s68PKy8MykJdlpF04YNtsueiIiIiIh0PgVNUai62v4cKmjy/0wpIh1r9GhrOetIr70GL73UxheZMAHy82HKFDL+7x7eH3Yjk+s/p6oKznL/CpMmUfCPO/F6Yc2a0Ke++CLcfDO88UbDuWXL7Lh0aRvX1V527bJ0PS4OsGom8FU0gc1pKitj6FALmYqLI7NMEREREZHuLi7SC5CmKivtuHOntYd4wgRNAwdGaHEi3cxf/gL19R37Pdo0m8lvwABYvz7wMPmyy5h51sVMX5THl5fMgF/+ksI3t8B8WHXvKxzz9MXg8QANVUuLF8Oll9rXy5fbMWqCpvLyJjvOQVDQlJ4eqGgCWLsWBg/u3CWKiIiIiIgqmqKSP2iqqYGKCsJWNCloEukccXE2FLzLycggcdabXPHnE4hbUwS//jXD33kQD/WsemYhvP02YGH2O28cBGDx29sCT4+6oGnXrpCJ7P5MLdBymJEREjRpTpOIiIiISGQoaIpC+/Y1fL1zhzckaNq3z37eUtAkIofVt69NG8/LAyAxNYFBgzwU9RgLjz8OWJC0fVcCvdnHokUeqK9n716bc5Sebi1o/g3fImrXrpCKprVr7WOxXz/fCV/rXG6ujWxS0CQiIiIiEhkKmqKQv6IJYOfWais56N0baJg7oqBJRI5EQaGHVckTYfp02LWLma/uB+A7KS+yubYfOx+fzsqVdu/ll9vRP68pohq1zq1dC0OHBrr/Aq1zMTFW5aSgSUREREQkMhQ0RaGQiqatvm2gfBVNmzbZQwVNInIkCgrA3ZtDfXUNvPACM5/bxWiWcd7dkwFY8pvpLFtiQ6muusqeExXtc41a59auhWHDgq5nZFivcU0NQ4cqaBIRERERiRQFTVEoOGjasbXGvvAFTRs32kMFTSJyJAoKoOpALJtHTKXy8ef5xM3k7LT5jL2iAIBFm9JY/spqEhNhyhQrFAoXNF19NXzjG520aK83pHWuvh6++KJR0OSfqO7beW7dOnuaiIiIiIh0LgVNUSikda6kzr4IqmiKjYX+/SOwMBHp8o4/3o7X1v2DZ+YNo9rbg7MvSSQj00NenpfFyaey/LO9jBoFMTFw7LFNg6Y9e+D55+Ff/2rY/a1D7dsHtbWBoGnLFjh4kMDgb8AqmiAwELyyEkpKOmFtIiIiIiIS4ugPmurq4Oc/h/HjLZ3JyLCfUqJYSOtcqW9f9aCgKTfXdsISEWmt8ePhySdh3rY8rudRerKfk358EgBjx3pY1GMiyysGcIxjO9Edc4ztQFdf3/Aab71lu2LW18MTT3TCov3TyH2tc2vX2sNDVTSBVTWVlcEDD0TJnCkRERERkW7g6A6a6uttyMg999iYgoYKAAAgAElEQVTuS1Om2E8dc+ZEemWH5A+aEnrUs3On72RQ0KS2ORFpi2uvhUWLYzgp0+WqIZ/Ta1guAOPGQdHOTErox+j41YBVNFVWwvr1Dc9/7TXIzITTToN//CM0hOoQu3bZ0VfRFDZoalTRBLBwIZx1Ftxxh/09xo6FP/4Rtm3r4PWKiIiIiHRjR3XQFF9cbP0d990HH3wATz1lF4qKIruww6jcZ4NF8mvWsnP9XjupoElE2tHw4fBxqcNj604PnBs7Frxe28ZtdNlHgAU00NA+V10Nb74JF1wAN9xgc+PeffcQ3+jf/2747D1SjYKmdeugRw/Iywu6xx80lZWRn29tf3fcYZVMzzwDf/2rPecHP7DnXXBBw8uKiIiIiEj7OaqDppjKSnjkEbjzTjuRlAQDBkR90LSvtIpYasnxbmbniu12MjGRujqbh6KgSUQ6wtixDV8fs+I5AEaNAo+nIWj66CPb3O2ii+Diiy3fefTRQ7zob35jU8Pb0mPn327TN5xu7VoYPNjm1QX4W+d27iQhwT7q6+rg2Wfhyivhlltg7lz7+P/JT2DmTLjuOg0MFxERERFpb0d10HSwsBC+853QkwUFsGpVZBbUQpVbykliH5nH9GOHJ8tOJiZSUmJzURQ0iUhHyM+3LuP0xP1kr/sUNm8mMdGqn95+21roXnsNevWCM86AhARrw3vtNSgtDfOCdXW2PVyPHvDtb9uNR2LhQujdO9Art3Zto7Y5gJ497R5fv/Hvfw+vvAKXXRZ6W0EB/Pa3cO+98Oqr8OCDR7YkEREREREJ76gOmvB4mp4rLLSgqcOHihy5fdv2ksQ+MsYOYGdSvk3vzcsL/FJfQZOIdISYGDj5ZDhhfDUegPffB+C222y03aRJ8J//2NwjXzcvl11mG8LNnRvmBYuLLR3/n/+xz7GvftX63lprwQIrt4qNxettJmgCq2oqKwOsiunCC4H9++Hll5uULn3/+3DuudZet2hR65ckIiIiIiLhHd1BUziFhfZr+U7Zk/vI7Nuxn96eKjLykyjf14Paz+dBUpKCJhHpcM8/D8+90cemfb/3HgA33mitZiUlNkj7oosa7vcP3g4eFh7gn9o9diy88AIcPAgvvdS6BdXVweLFcPzxgFVOVVY2EzRlZNCwg4LPz34GX/5y4O/iFxNjo6NSUqy7T0RERERE2kf3DJog8nOaVqyAqVNh794mlyrLq0nqWUdmlgevt2FnbwVNItLReveG3n1i7PPp/fcDlUBnnmmVP/feC1dc0XB/ZqY954svwrxY8PZwgwbBccfB9OmtW9Dq1VBVZc+lmR3n/IIqmgCbBP6//2tfh/m+GRn211y4sHVLEhERERGR5iloipQPPrA/YX7C2VfhpXeSJ3i3bsCCpuRk+yMi0qGmTrXypVNPhauvhtdfJy8PfvQjm9Hk5/HAkCGHCJp69oScHDZtgrP2vMC2z9ZbaVRL+T8jfRVN/qDJX0kVIriiyeuFm2+2kqVTTrGgKczk7zFjbOc8f6AvIiIiIiJt0/2CpsxMSE2N/EDwrVvt6Lqh5ysr2XcwjqSU2LBBk6qZRKRTXHopXHWVDWB69117PHt22FsHDz5E69zQoRATw/Tp8O66oTzGdTBjRsvXsWCBhVUFBYGXjI21AqkmgoOmp5+Gjz+2EqxrrrEP0CVLmjxlzBg7+nfVExERERGRtul+QZPHY1VNka5oai5oWr2aSnqTlNEzEDTt2GHHjRsVNIlIJ0lLs7Dm00/tc2roULj8chvw3Yi/oqlJwVDQ1O558+zUU3HX4X3N2tg2brQsq6LiEOtYuNDSoLg4wGaJDxpkG9k1kZ4Oe/bAO+/ATTfZ9PJvfQvOP98++8O0z/mDpjAZlIiIiIiIHIHuFzRBdAdNRUXsI4neWUkhFU0HDtiSfb/UFxHpPMnJ8OqrtoPbJZfYUO8ggwfbgG5/KA7Yzp7r1oUETYmJsK42n0/f3gtVVdx5JzzzzCFmJNXX22AoX9sc2EuGbZsDAh+a554L+fm2RV5MDGRnw+TJYYOmfv2s0FVBk4iIiIhI++i+QdOOHaFDYztbc0HTqlVW0ZTTNyRo+vxz+9nutNM6d5kiIoCl3I88Yq1sjXZwGzLEjiHtc1u3WkI+fDh791q38i23QO+etTxZfSVz/76AF1+0W3ftauZ7rltn5U6+QeAAW7ZAXl4z9/s/NMePtza/nJyGaxddZGtvtOOox2Ob4iloEhERERFpH903aILIVjX5g6b166G6uuF8URH76EPvvrH07AlJSRY0ffCBzSU5+eTILFdEhPPOs+OiRSGn/UFTyEDwoO3hFiywtrpTT4XLv+LhBb7Cbff1p3dvu6XZzL/RIPD6epsj3r9/M/dPmwZ/+IMFYWlpodcuvNCOr7/e5GljxsDy5TaOSkRERERE2qZ7Bk3+/rNIDQSvqoLdu2HkSKirs9/a+9QUraWaHiQl2WP/bNsPP7Rf0vftG5kli4jQp4+1wi1eHHI6P9+OzQVN/vlMEybAN74Vy1768lnpMO66y843W9G0cKENYxo5ErBAqrbW2t3CSk6GO+4g8AEarKAAHAceeig03MeCpoMHGwpMP/wQVqzAkq1G2+l98IF9Loe0CYqIiIiISED3DJoGDbJdjNpY0bRwoc0K8W9y1GLbttnR3wfn/+mmtpbK1VsAQoKmDRtgzhy1zYlIFBg3rknQlJho4U9I69zatRYS5eUxb56FURkZVpU5JK2c4azm1q+XkZDQTEVTTQ28/z4ce2xg8rf/o7PZiqZD8Xjg/vutdOmee0IuBQ8E37LFRjz96EfAyy/bh/yjjwbuffJJW2+kNy4VEREREYlW3TNoio2138oHVRIdiU8/tV92r1jRyidusTCpSdC0YQP7auwHKn9LSUaGfZ/aWjj99DYtV0Sk7caOtc/OPXtCTvt3ngtYs8ZOxsYybx5MnGinY2Lgnb+u5j3OIH7hHNLTw1Q01dXBNdfYTKWbbgqcblPQBHDBBXD11fC734W0/xUUWJa1ZAn85jc2WmrlSmDWLLvhppvgrbeorYUZM+yU/2NcRERERERCdc+gCazFYu/eNr2Ef5dv/7ilFvM/oaDAygBWr7bHK1dSiSVM/oqmzEzr3oiPhxNPbNNyRUTabuxYOy5dGnJ68OAwrXPDhrFjh1VlTpjQcGnoRaMZGLMF/vtf0tIaVTTV18O3vw3PPQf33Qff+lbgUpuDJoA//9kS/G9+06qmsM/XUaNsfNNjj1mH4IYNsP/ThbZb3bHHwuWX88kTawKhmIImEREREZHwOjVochynp+M4cx3HWeI4zgrHcX4d5p4bHcdZ5jjOYsdxPnEcZ6TvfL7jOPt95xc7jvN/bVpMUhJ1e6t480349a+b7NbdIm0OmnJyYMSIhoqml19mX2I2EFrRBPazTmJi69coItKuxo2zY5iB4MXFvuzG6w0ETfPn2/XgoInevS288QVNIRVNb75p/Wm//CXceWfI9/AHTc3OaGqJtDT429+sfOnllwOnx4yxbuqEBCt48nrBXVYNU6daGVNyMq/9ejEJCdZ5raBJRERERCS8zq5oOgic7rruGGAsMM1xnMmN7nnGdd1jXNcdC9wHPBB0bZ3rumN9f25sy0L+vescBi/6D+edB3fdBW+91YonP/ssfPpp24KmXr0gJcWG07quDQd/8UX2Tb0ICJ3RBJrPJCJRol8/yMpqMqdpyBArRtr080fsA7WqKjAI3OOB445r9DqTJ8OcOaSneUMrmj77DOLi4Mc/bvKtt2+3DRHaHLpfcokt+O9/D5zyz2n6/vdtdzyAovoRcMIJ0L8/3htv4rUtxzN1yn4GDFDQJCIiIiLSnE4NmlzX9bquu8/3MN73x9vonoqgh70bX28PNTVw8+LvkOop54UXLNSZObOFT37+efja1+Duu9sWNOXk2E9fjmPTxP/2N9i/n8qptgV346BJ85lEJCp4PNY+16iiaXDqbgC+uO9FOO88ALxDhzFrFhQWWjtaiMmToaKCtNjdoRVN8+bB6NEWxjeybVsb2+b8YmLghhtg9uzAkL1LL4VvfAN++EMYPhxiPPUUUWjrBJaPv5b1DOHi1I/IzT2Cz30RERERkW4irrO/oeM4scACYBjwoOu6c8LcczNwO9ADCI5YBjuOswioAH7uuu7Hh/pe9fX1FIXZWW7evET21AziZ4n3Mnr0T5gwIY/XX0/ge99bh8fT/Ov1XLqUQddeSwywf6XLlm1ewMPatZUUFW063F89YODatXhSUthYVERSYiIDgLp776WmsJBVdfbD1fbt6ygqqmbUqFhuvz2F9PSytm6SFzEHDhwI++8g0hn0/mt/mQMHkv7BB6xasiSwI1zKs48D9zP/G3czcvQ0emzYwB/fG82HH8Ltt5dSVBS6tVyPzEyGAgklRZSVTWblShcPXkbMnUvF2WezPcy/2bp1g0hO9rbq87Y5sSeeyLD4eHb/7neU/PzngIVM/gBpcM8kVniOp6i0FEpLefStDDzUc+bi3zB95AksXtyLoqKWbyih96FEG70nJZro/SjRQu9FiQZHw/uw04Mm13XrgLGO46QArziOM9p13eWN7nkQeNBxnK8BPweuBbYBA13XLXMc53jgVcdxRjWqgAoRExNDYWFhk/NPPAHxMbVMq3mTvoX/5Mtfhptvhri4QkaMaObFSkqspyInB844g12Pz6SuzlKp3bt7h/0+zdq9G447zp4TZ/8EsZWVxN5yCyk98wAYM2YogwbZ7TYEPKvlrx9lioqKWve/j0g70vuvA0ydCo89RiFYuVJJCXXT/48eMb9jT/YJ5N5xAu++C/dPs0qh++/PIiam0WeY40BqKgMPbqO6OoZBgwrpvXUNVFSQeuaZpIb5N9uzx2Y9tdu/51e+Qtrrr5P28MMNZaQAXi+j6mbiJo6hsNA+kz/7DCYN3k7+F59ReMpB3t2RTEFB4SF/ORFM70OJNnpPSjTR+1Gihd6LEg26yvtwwYIFzV6L2K5zruvuBj4Eph3itueAi333H3Rdt8z39QJgHdBcLHRIb74JJ+cX07emDKqrmeZbwSHb5956ywaEPPssTJpEcZ31b4wYYb8B97a0wc/rbWidA9uqKT7e2kSuuorKSjsd/DOPiEhUaTwQ/L77iD1YxaCBXp5+GqZNg8svh5Ej4amnrFOtiZgYmDSJ9K3LAN9A8Hnz7FrI5PAG27e3U+uc3003QUUFXH01XHwxnHMOrF8P69dTWL2Y1Xv7U1sLmzfDggVw0VV9IC6O3E3/5eDBRrvliYiIiIgI0Pm7zmX6KplwHKcXcCawqtE9w4MengesCXpurO/rIcBwIHgz7RbZuNFGcpx3jK/1orKSIUNg2LDDBE0bNthsknHjYOhQihkA2PiOqir7WaVF9u6FysqGoCkuDqZMgeuug+Rk9vkmWPl3nRMRiTrDhtlE7ueeg1/8Ah56CK6+mm/d0IPsbCgvt4+11147TGh+wgmkbbGgqawMC5p69YJRo5rc6v/obNegacoUmDTJdpVbswY+/9zCphkzKKSImrpYvvgCpk+32y/6Wm+YNo3cxTMADQQXEREREQmns1vn+gNP+QKjGOAF13XfcBznbmC+67rTgVscxzkDqAHKsbY5gFOAux3HqQHqgRtd193V9Fsc2gz7+YBzjy+F14B9+yA1lbPPtpa6gwdte+smNmyA3FybRxIUNE2aBP/8p/3AkZzcggX4B4D4gyaADz8MfFlZCbGxzaxBRCQaxMbCxImWzr/3Hhx7LNx1Fz/OD7tZXPNOPpl03geCKprGjbMqz0a2bbNjuwZNHg98+qlVmsbFwccfwxlnwG23UdjzRDgARUUWmA0fDgUFwGWXkfvGw4B97vt3qxMREREREdOpQZPrukuBcWHO/zLo61ubee7LwMttXcObb9qu1s6wOjvhKyE6+2x48EH45BMbP9LExo0Ehibl5rI5dhCJnmpGjbJBuFu3WpvIYfl/BZ6b23AuaMjHvn1WzdTSuR8iIhHx8svWyzZsWGAgeKudeippwzNgDZSV1MDChXD99WFv9QdN/fod4XqbExvb8PXJJ9tvDq64goIpfeBjmDPHfhdw662+z+W8PHKwXxho5zkRERERkaYiNqMpEvbvhw8+sJ23PX18/Ry+oOm00+yX6M22z23YAPn59nVMDMWJDgN6lgbyohb/wBGuoinIvn2azyQiXUBamqXrRxoyAXg8pN3+DQB2Pf2WfUgfYj4TtHNFUzhf/Sq88gp9H7iL3Fx4+GGoqbERTgCkpdEfS73UOiciIiIi0lS3CpqWLrWfY84/n4Y0xxc0JSVZx0bYwem1tVBc3BA0AcWx+eSxOfBDT6uDpmZ+WqqsVNAkIt1H2tfPBaDsrbl2opmgqUNa55pz8cUwfjwFBdbSl5lp8/gASEujBzVk9d2voElEREREJIxuFTSNHWutc2eeSZOgCSxH2rQpzBO3boW6uobWOaC4ph8DDqyhd6KX5OSWB00HN5VQ3yc5JE36n/+xLhT/cjQIXES6i15JsfTqUcsub4oNuhs2LOx927ZZ8VRqauetzb+r7AUXBHXYpacDkNunQkGTiIiIiEgY3SpoSkiwDYU8HsIGTYMGWdBUX9/oiRs22NFX0VRTA9uqkhlQux5KS8nJaXnQdOKzN3N73P+GnPvTn+Bvf2tYjiqaRKQ7Sc+KZVfSINsFLib8/1nats3mM3Xm/Dp/0HTRRUEnk5IgLo6cnuUKmkREREREwujsXeeiRzNBU3U1lJQ0as9oFDRt3Qper4cBFMO6deTkZLcoaHJdWFA+lLTU8sC5+nrYuROWLbONjyorA78wFxHpFtLSPJSNPB+eOrXZe7Zt66S2uSBf/SqUldkvKAI8HkhPJze+lLlbCzp3QSIiIiIiXUC3qmgK0UzQBGHa5zZutOOAAYCNawIsaPriixZXNL32qpVKlXqyAufKy60rr6zMht2qoklEupv0dNhV1cuGITVj+/bOD5rS0+EXv7CNIkKkpZEbs5UdO+Dgwc5dk4iIiIhItOu+QZN/EFJQ0DRwoB39uVLAhg32E07PnkBw0LTZV9Hkr3I69Lec/kwlAKX1GYFzO3Y0XF+6VMPARaT7SUuzsP1QIlHR1Kz0dHLr7P8Q+IeUi4iIiIiI6b5BU3y8DW0KU9EUNmgK3nHOHzTl1geCppqaQ/+gtGMHfLYsiZ7sZ8e+XoFQqrS04Z5lyzQMXES6n/R0290tWH09/PzncP/91tJcVmYzmqJCWhq51V8AaE6TiIiIiEgj3XdGE1jpUGVl4GFysv1pEjRt3Biy5XZxMfTtC32HZ1vQdKGd37oVMjIIa8YMm+t0efqH/KvsXHbvtt2Tgiua/EGTKppEpDvxVzR5vTYCyeuF730PHnrIrq9YYcdoqmjKqVwLKGgSEREREWms+1Y0gSU6QRVNYFVNIUFTXZ0NbWpU0TRgADB0KKxbR26unT/UnKbXXqxmAJs465QDQEMlkz9oOuYYWLTIfnOviiYR6U7S0qC21j6OvV64804LmX7wA7jhBnjqKbsvaoKmtDRyK4oABU0iIiIiIo0paAoTNIUMA9+2zfrimguaSkrIqbFkqknQVFcHXi/798M778dwIdPJPtX2y/YHTf7jaafB8uUNyxIR6S78O22WlcFbb8Ef/wi33AL33WeB0/XX2/UhQyK3xhDp6aQd2EJCgrdFG0GIiIiIiHQnCpoOV9Hkf+Ab4FRXB0VFMGIEVoYE9PvSCAC2vvhJw/MqKuC442DaND586wBVB+O4sM8ssk6ye4MrmlJS4PjjG4aJK2gSke4kLc2Ou3bBSy9ZC/MDD1gbXUwM/N//wZo1MHJkZNcZkJaGBxiYU8eqVZFejIiIiIhIdFHQ1ChoGjgQ9uyxP4ANAodARdPatbB/P4wZA5x3HsydS8L//oGM+N1seXsZPP20JUbXXWclSu+9x+e3PU8stZw0LYms/rFAQ8tcaant6O3LrAC1zolI9+KvaCothTfegHPPtf0a/DweGDYsMmsLy7fg80/azcyZh98xT0RERESkO1HQFKaiCYKqmvxBk+/CkiX2cOxY7KefCRPge99j9JS+vNrjK+z+1u02VOSll+Dee+Hf/2bepn6MYgWJ558eGBYeXNGUmQmFhRAb27AsEZHuwl/RNGOGfSZedFFk13NYvgV/40vrqamBZ5+N8HpERERERKKIgqZmgqbAnKaNGyErC3r1Aixoio1t2sLxhz/GUFqbxg97/i88+ihcfDH84Ad4v3oF8/ucyoR+m+H884mPt93mgoOmrCzo2dPXjocqmkSke/FXND3zjFUynXNOZNdzWL4FH5tazNixDcPKRUREREREQVPLKpqCBoEvWQIFBRYMBTv+eLjjDg+P7r2CWV/+GzzxBHg8bNgAZXsTGP+r8wK/Bc/KCh0GnplpX/vb51TRJCLdSfCMptNPh759I7uew/IvuKyMa6+F+fNh5crILklEREREJFooaGoUNGVlQUJCUNC0bh0MHhy4vmSJbz5TGHfdZRvRfWfxzRzomQLYDyBgHXbB36O0FOrrbbZHVpadV9AkIt1Rjx4Nn3tR3zYHDSVYu3bxta9BXJyqmkRERERE/BQ0VVZa4uMTE2MDwTduxKZ+r19vA5Sw37Zv3tx80JSYCH/5iw0Mnz7dzs2bZz9EBQ/79gdN5eW2i52/ounii+23+UEFVCIi3YK/SOjCCyO7jhbp1ct+I1FWRlaWtfo9/bR9nouIiIiIdHcKmgCqqkJOB4Im17Ud5HwDmfyDwJsLmgCmTYO8PPjnP+3x/Pl2f48eDfdkZdlsJn/7nD9oGj0a3n9fM5pEpPvp188qP3NzI72SFvB4rKpp1y4ALrsMtm6F1asjvC4RERERkSigoAnCzmnatImGoRutCJpiY+HrX4e334Zt22DBgtC2ObBgqazMrkND65yISHf1+OM2DLzLSEuzD3Kgf3875cudRERERES6NQVNEDZo2rYNDi5bbcnR8OGABU3Z2fab90O5+mprobj7bqiogPHjQ69nZVmhVFGRPfZXNImIdFejRsGwYZFeRSsEVTSlptopBU0iIiIiIgqa7NjMznPFC3fYTz6+vrdDDQIPNnKkhUuPPGKPG1c0+SuYVqywo4ImEZEuJqiiyT9fqrw8gusREREREYkSCpqgSdA0ZIgd166sDrTN1dRYMNSSoAngmmtsxnhiIhQUhF5rHDRlZBzJ4kVEJGJU0SQiIiIiEpaCJmgSNI0YYcc1WxIDQZPrQnV1y4OmK66wLa+PO86OwYKDppSU0EHhIiLSBfgrmrxekpNtPrgqmkREREREIO7wtxzFmgmasrKgT+861lQOhcJ0AJYutWstDZoyM+GPf4TBg5te8wdNZWUNoZaIiHQh6en224eqKmJ79yYlRRVNIiIiIiKgoMmOjYImjweGZ1WwZv1wGGmTv5cvt8qk1gRD/+//hT+fmmozxuvqNJ9JRKRL8g9m2rULevcmNVUVTSIiIiIioNY5OzYKmgCG997CakaA4wAWNDlO+7S5xcQ0zGVS0CQi0gWlW7Vr8EBwVTSJiIiIiChosmO4oKl+NRvIpzouEbCgafTo9vvW/vY5/1FERLqQ4IomUEWTiIiIiIhP9w6aEhKshy1M0DSiYj71xLJ+PVRWwvr1HRM0qaJJRKQLUkWTiIiIiEhY3XtGk8djVU2Ng6baWoZv/xiA1auhosJOK2gSEREgbEWTgiYRERERkVYETY7jDAG+DUwGsn2nS4DPgMdd1/2i/ZfXCcIFTV98wfDalQCsWQM7d9pptc6JiAjQEDQFVTSVl4PXa7/DEBERERHprlrUOuc4zjeBlcD3sXBqCbDU9/XtwErHca7tqEV2qMZB0+bNcMcdpLOL1L61rFlj85l69oTBg9vv26qiSUSkC+vZExITQyqa6upg794Ir0tEREREJMIOW9HkOM6xwMPAv4HbXNfd3eh6CvBn4BHHcRa6rrusQ1baUYKDpn//G2680X5auP9+RrwUx+rVEB8PI0faOKf2oqBJRKSLS0sLqWgCq2rq2zeCaxIRERERibCWtM7dAsx3Xfeb4S66rrvbV/E0wnfvDe24vo7nD5rq6+HWW6GwEJ5/HgYPZvgS+OgjuzR1avt+24svtuKp9mzHExGRTuTvl8MqmsAKnAYNiuCaREREREQirCWtcycDTxzqBtd1vb57TmmPRXUqf9C0ZIn9Zvp73wv0yA0fDsXFsGVL+wdCGRlw113tWyUlIiKdKDU1EDQFVzSJiIiIiHRnLQmacoE1LbhvNZDXtuVEgD9o+uADe3z66YFLw4c33KbKIxERCZGSEraiSURERESkO2tJ0JQEVLXgvgNAYtuWEwH+oOn998FxIDc3cElBk4iINEsVTSIiIiIiTbRkRhPAYMdx9h3mniFtXUxEJCXB7t0wezZcG7pxnj9o6tsX8rperZaIiHSk1FT7vx+ooklERERExK+lQdMzLbjHA3jbsJbISEqCykr7utHE7+Rk2x1u6FDweCKwNhERiV6pqVYRW1NDYmI8PXooaBIRERERaUnQdFqHryKSkpLs6PHAqac2uXznnZCT07lLEhGRLiAlxY67d+PJzAzehE5EREREpNs6bNDkuu5HnbGQiPEHTePGNQzZCPKDH3TyekREpGvw98vt3g2ZmaSmqqJJRERERKQlw8CPbv6gKWi3ORERkcPyB01BA8FV0SQiIiIi3d1hK5ocx/mgFa/ndV136uFviyJ9+9pxatdatoiIRJi/dc6XLqWmwubNEVyPiIiIiEgUaMmMprIW3NMfmEJXHAZ+zjnw2GNw5pmRXomIiHQlYSqali2L4HpERERERKJAS2Y0Xd7cNcdxBgI/As4HdgJ/ar+ldZJeveC66yK9ChER6WqCZzT5HmpGk4iIiIh0dy2paGrCcZxhwE+ArwOlvq8fdl13fzuuTUREJHqFqWjauyDgQSoAACAASURBVBdqaiA+PoLrEhERERGJoFYFTY7jjAJ+BlwOFAO3Ao+7rlvdAWsTERGJXj17QkJCyIwmCGxCJyIiIiLSLbUoaHIc53gsYLoIWAN8G3jadd26DlybiIhIdEtNDaloAnuooElEREREuquW7Dr3FnAWsAy4wnXdFzt8VSIiIl1BamrIjCbQnCYRERER6d5aUtF0tu+YBzzoOM6Dh7rZdd2sNq9KRESkKwhT0aSgSURERES6s5YETXcD3o5eiIiISJeTkgLbtwNNZoOLiIiIiHRLhw2aXNe9qxPWISIi0vWkpsKqVYAqmkREREREAGIOd4PjOHWO40zsjMWIiIh0KUGtcykpdkoVTSIiIiLSnR02aAI8Hb4KERGRrsg/DLy+nvh46NNHFU0iIiIi0r21JGgSERGRcFJSwOuFigrA2udKSiK8JhERERGRCGrJMHCAfo7jDGzJja7rbmrumuM4PYHZQILve7/kuu6vGt1zI3AzUAfsA653XXel79pPgOt81/6f67ozW7h+ERGR9uefAL57N6SkMHkyfPgh1NdDjH6VIyIiIiLdUEv/3+BXgPWH+bPBdzyUg8DpruuOAcYC0xzHmdzonmdc1z3Gdd2xwH3AAwCO44wErgBGAdOAhxzHiW3h+kVERNpfo63mLrzQKprmzYvgmkREREREIqilFU13Am5bv5nrul6sSgkg3vfH2+ieiqCHvYOuXwQ857ruQWC94zhrgYnA521dl4iIyBFpNAH8nHMgNhamT4dJkyK4LhERERGRCGlp0PSJ67pz2+Mb+qqQFgDDgAdd150T5p6bgduBHsDpvtO5wH+DbtvsOyciIhIZjSqaUlPh5JPh9dfhnnsiuC4RERERkQhpadDUblzXrQPGOo6TArziOM5o13WXN7rnQeBBx3G+BvwcuPZIvld9fT1FRUVtXrO0zYEDB/TvIBGj9590pLidOxkObC0qYo/vfTZxYhr33ZfNe++tJTe3BtD7UKKP3pMSTfR+lGih96JEg6PhfdjpQZOf67q7Hcf5EJu3tLyZ254D/u77egswIOhanu9cs2JiYigsLGzrUqWNioqK9O8gEaP3n3SovDwAcnr2JMf3Pvv2t+G++6CoaBhnnGG36X0o0UbvSYkmej9KtNB7UaJBV3kfLliwoNlrLRkGvgMY7jhOelsX4jhOpq+SCcdxegFnAqsa3TM86OF5wBrf19OBKxzHSXAcZzAwHGiXdj4REZEjkpRkQ5l8rXMAw4dDYaHNaRIRERER6W5aUtH0MnAP8KTjOPOAGcAM13UXH8H36w885ZvTFAO84LruG47j3A3Md113OnCL4zhnADVAOb62Odd1VziO8wKwEqgFbva14YmIiESGx2MDwXfvDjl9wQXwpz/Bnj2QnByhtYmIiIiIRMBhgybXdb8L4DjOaOBcrMroLsdxSoA3seDpXdd1q1rwWkuBcWHO/zLo61sP8fx7sNBLREQkOqSmhlQ0AVx6qbXPvfYaXHNNhNYlIiIiIhIBLZ7R5BvYvRy4z9f+Ng0Lnh4F+jiOM5uGaqd1HbFYERGRqBMmaJo4EfLz4dlnFTSJiIiISPfSkhlNTbiuu9t13edc170GyAZOx+YlfQNY3X7LExERiXIpKU2CJo8HrrgC3n0Xdu6M0LpERERERCLgiIKmYK7rel3X/dx13V8AFxC6M5yIiMjRLTW1yYwmsKCprg5efjkCaxIRERERiZA2B01g85scx3kK+MJ13a3t8ZoiIiJdQpjWOYBjj7Xd5559NgJrEhERERGJkBbNaHIc52vANVi10nrg967rfuo4zjHAvdi8pnLgtx21UBERkajkD5q8XuuZ8/G3z911F5SUxFFYGLklioiIiIh0lsNWNDmOcx3wNBYyLQPSgPccx7kFmA9MBH4EDHJd9zcduFYREZHok5ICNTVQ1XTz1a9+1fKnmTP7RGBhIiIiIiKdryUVTd8D/um67jf8JxzH+T7wF+Az4ALXdZsOpxAREekOUlPtuHs39O4dcslxYNw4mDEjmd//PgJrExERERHpZC2Z0TQU+Fejc08CHuAehUwiItKtDfDtgbFuXdjLV14Jy5b14osvOnFNIiIiIiIR0pKgqTewt9E5/+PS9l2OiIhIFzN+vB3nzQt7+StfseNzz3XSekREREREIqhFw8CBKY7jZAQ9jgG8wImO4/QLvtF13Tfba3EiIiJRLzMT8vNh7tywlwcNgnHjqnjuuUR++tPOXZqIiIiISGdradD0QDPn/9LosReIPfLliIiIdEETJzYbNAGce24F99yTyIoVMGpUJ65LRERERKSTtaR1bnAr/gzpmGWKiIhEsQkTYMMG2LEj7OWzzqogJkbtcyIiIiJy9DtsRZPruhs7YyEiIiJd1sSJdpw3D849t8nlzMw6TjvNgqb/z96dh0dVn/0ff08WEhKyQBLCEiAsYcIqmyyyqiAuuFVatbW2tra1T320tda2VuvSxbY+XbRqfy61trVWq9a61Q0VRFA2FQiESVgDAZKQhAQI2ef3xz1nZhKSkJAhC3xe18U1M2fOTE4khjOfc9/39957weXq4OMTEREREekgxw2a3G734BaergWKPR5PVegOSUREpJuZNAnCwqx9romgCeDzn4cbboDcXBg5soOPT0RERESkg7RmRtNObPZSc+rdbvda4G6Px/NWSI5KRESkO+nVC0aPbnFO0xln2K3Ho6BJRERERE5drQmaLm7huXCgP3AZ8Jrb7b7I4/G8HZIjExER6U6mToVXXgGvt8neOCdcysnp4ONqpW3b4PHH4b771NonIiIiIieuNTOaXm/F+zzqdrufA+4AFDSJiMjp58wz4cknbSj40KHHPN2nDyQnW0VTV/Tyy/DrX8PNN0P//p19NCIiIiLSXbVm1bnW+gcwMYTvJyIi0n04A8GfeQauugrS0qCwsMEubnfXrWiqqLDbo0c79zhEREREpHsLZdBUg7XSiYiInH7GjYOoKLjjDnjpJcjPhyVLGuwycmTXD5qcWxERERGRExHKoOkiYFMI309ERKT7iIyE22+H73/f2ucSEmDZsga7jBwJ+/ZBeXnnHGJLVNEkIiIiIqFw3BlNbrd7dAtPhwP9gEuBG4BrQ3RcIiIi3c9Pfxq4P2vWMUGT2223ubkwefKJfYnsbJv1lJJygsfYjCNH7FYVTSIiIiLSHq1ZdS4L8LbwvAvYD3zH4/E8E5KjEhER6e7mzYPXX7cSJh9n5TmP58SDpgsugPPOg8cea/8hBlPrnIiIiIiEQmuCprNbeK4WKAJyPR5PS2GUiIjI6WXuXLv94AMYPx6A4cPB5TrxOU319bBnD2zdGqJjDKLWOREREREJhdYETQOBNz0eT4mzwe12Dwb2ejye2qBtA4CvejyeX4b+MEVERLqZiRMhLs7a53xBU3Q0pKefeNB08CDU1cHu3aE7TIda50REREQkFFozDPzvwAjngdvtDgd2AOMb7TcI+FnoDk1ERKQbi4iAmTNh6dIGm0eOtNa5E1FYaLe7d4M3xHXEap0TERERkVBoTdDkauU2ERERCTZvHmRnE15c7N80cqRVNJ1IUFRUZLdVVYH7oaKgSURERERCoTVBk4iIiJwI35ymmDVr/Jvcbjh8uMGM8FYLDpdC3T7ntM5pRpOIiIiItIeCJhERkZNl8mSIjSVm7Vr/JmfluebmNO3aBXfcAbW1xz7ntM5B6IMmVTSJiIiISCi0NmhqqsBfq8yJiIi0JDISZswgZt06/ya3226bC5puuw1+8Qv49NNjnzuZFU0KmkREREQkFFqz6hzAW263u/G11XcbbWvte4mIiJw+Zs0i6p57oKwMEhJIS7PV55oaCJ6dDc8/b/c/+QTOPLPh84WFkJAAlZWQlxfaw3QCJrXOiYiIiEh7tCYcuuekH4WIiMipatYsXF4vrFwJF1xAWBhMmAArVmCpzrvvwqJFgFUy9expC9Z98smxb1VUBH372iDxUFY01dVZeAWqaBIRERGR9jlu0OTxeBQ0iYiInKjp0/GGh+P68EO44AIALrwQ7roLin73d1Lu+BasWUNuwhT++U+45RZrm2sqaCostKCpR4/QBk3BVUwKmkRERESkPTQMXERE5GSKjaVy9Gj48EP/pgsvtKqkt172JTxvvMF991mA9P3vw6RJsGED1NQ0fKuiIkhJgUGDQhs0BYdLap0TERERkfZQ0CQiInKSVUyaBKtXQ1UVABMnQmqql/9uGATAnv+s5e9/h298A/r1s6Cpuho2b274Pk7r3KBBkJ/f9Mp0J+LIkaBjVUWTiIiIiLSDgiYREZGT7OikSTYEydcPFxYGF8w8xJtV86gdNJQHPpmN1+vlllts/0mT7Da4fa6+Hg4cCFQ01dfDvn2hOb7gcElBk4iIiIi0h4ImERGRk6xi4kS7E9w+l7qOUvrw9uV/4lG+yeen5ZGebs+NGAG9ejUMmkpLbWh3374weLBtC1X7nBMuRUSodU5ERERE2kdBk4iIyElWl5wMI0c2CJoWlL9IOLV844XzOEQ8t/Z50v9cWJi11wUHTYWFdutUNAHk5YXm+JzWuaQkVTSJiIiISPsoaBIREekIs2ZZ0FRfD0DimneYlZTN3r0uzu6bxeQ1j/qfA2uf++wzq2ICm88EDYOmUFc0JScraBIRERGR9lHQJCIi0hHOPhtKSuBf/4KCAsjJ4cKpxQD84Jr9tm39ev/ukyZZ6JOTY4+diqa+fSEhAeLiQh80paQoaBIRERGR9lHQJCIi0hGuugpmzIAbboBnngHgO7f25MUX4fxbx9o+r73m373xQPDgiiawqqZQB01JSZrRJCIiIiLto6BJRESkI0REwNNPW3vcrbdCdDSxMyfwuc+Bq38/OOccuP9+2LoVgMxMiI6GdeuA6mqKPssHrL0NbCB4qGc0JSfb4nhBHXwiIiIiIm2ioElERKSjDBsGDz9sSc7UqRAVFXjuySchPNwqn6qqiIiAKVNg5UrghhsofOwlevc8SmSk7X4yKpqcailVNYmIiIjIiVLQJCIi0pGuuQZ++Uv44Q8bbh8yBP7yFythuu028HqZMwfWra3n8F/+RVFsOn2P7oI//AGwoKmoyCqQWquqKjBcPFhw6xwoaBIRERE51ZWVwfe+1+i8r74e3n0XvN52vbeCJhERkY7kcsGPfwwXXnjsc5ddBjfdBA8+COefz5yYtdTWhfGx+6sUTr6AlCSvnRE8/TSZmfaS1auBzZsDQ5xaMHEi3HvvsduPHIEePWzAOGgguIiIiMip7v337frlRx8FbXznHZg/31ZKbgcFTSIiIl3Jb39r/+qvXs1Zd5xNGHV8MP9eiorD6TvbDWeeCXfdxfnn1RMdDc/9rQqmTYMf/ajFty0uhuzsBgvb+VVUQEyM/XEei4iIiMipq6TEbouLgzbu3Wu3a9Y03LmNFU4KmkRERLqSiAi4+WbYupW4H/8vkzIO8UFWHwoLISU1zCqatm8n7qO3WbQIXniultrDR+Gzz1p82+xsu92z59jnKiogNjYQNKl1TkREROTU5gRNBw4EbXRSp08/DWxbt85WjPnzn1v93gqaREREuqKkJPjlL5m9KJGPP7Z/91NSgM99zu786U9cubiOwsOxLGOutc81NYDJZ/Nmu20qaDpyxEKmnj3tsSqaRERERLqv1hQgNRk0OQ+Cg6ZXXrGdr78e7r67VW+uoElERKQLmzPHhnjX10PfvthKdddfD6+9xoU7HyGWwzw3+DabCr5jR7Pv4wRNBQVQXd3wObXOiYiIiJwasrIgOhq2bWt5v9JSu22yoik7O3BC+OGHMH48XHcd3HOPhU3HoaBJRESkC5s1K3A/JcV355vfBK+XmNu/y6Wx7/LiwXOoIcLOLJrhBE0QaL93qHVORERE5NSwcaNdVMzNbXm/Fiua6uvtjWpq4OOPYd48a51buBCefvq4x6CgSUREpAtLToYxY+x+376+jenptmpdfT1XXuWipDySJcxvEDQ1rmrevBlSU+1+4/Y5p6JJrXMiIiIi3Vthod0ePNjyfs3OaBo6FIDf3l/HIz/JtxPDWbPA5eLxuFt4Zvs02LevxfdW0CQiItLFzZljt/6KJoA77oD581l43zwSEuCZ2G/Cpk2AjWoaPx7uvNN2LSuD/HxYsMAeNw6anBlNap0TERER6d4KCuy2rKzl/ZqtaJo0CXr35sG33PzggYEU0wdmzWL3bvifl+ZzLX9j9VObm3xPh4ImERGRLu4LX4DMTP8FJjN9OrzzDlEp8Vx1Fbx49ELK19uMpnffteKmv/3NKpu2bLGXOEFTfn7D92/cOqegSURERKR7coKmE65oSk6mcvxUdh/uTUV1JI/0vgP69+d3vwMvLlIp5JrfjGvxvRU0iYiIdHHz5tlMxl69mn7+uuvgaH0Uz3kmQHU1Tzxh2/PyYMOGwHymGTMsUDpe65xmNImIiIh0Tydc0eT1WtCUlMS2ofPxEkYv12EerPg6e/bA44/DF7/o4h9n/IatB5NbfG8FTSIiIt3c1KkweuBB/lJ/LUWrtvOf/8DVV4PLBS+/bEFTVBQMGwZpac23zmlGk4iIiEj31pqKptpaKC+3c7+KCt+5X1mZzV9ITiYncSoA93h/yoGqeBYutPPF226DeRfFcqvrdy0eg4ImERGRbs7lguu+cISPOIs77omkpgZuv9266155xYKmzEwID286aHJa58LDLZBS0CQiIiLSPbWmoskJoTIy7La4mEBpU1ISueGZAHydPzN1/FE2b4ZFi2DsWGDWLO7z/rDFY1DQJCIicgr48s1JhFPLY+8OZ9o0OxG45BJYtw5WroTRo22/xkFTba0tgevMZ4qJUeuciIiISHfk9bZu1Tmnbc4Jmg4cwJc2AcnJ5B5Mpi+FJCRFcsfPogkPt4uYAMyYQbjL2/gtG4g44e/gBLjd7mjgAyDK97Vf8Hg8dzXa5xbgeqAWKAK+5vF4dvmeqwM2+nbN83g8l3TUsYuIiHRlqUOiuSj2XV45ci7XX2/bLr0UfvxjO9EIDpr27bPK6PDwQPWSEzQ5JdQiIiIi0r2Ul0NVld1vqaLJCZpGjrTbAweA6kBFU05uGBl9iuGyy7j4EhcHDkBiou/FiYm+0qbmdXRFUxVwjsfjOQOYAJzvdrunN9rnU2CKx+MZD7wA/CbouaMej2eC749CJhERkSC3TXmXc3p+xJVX2uPMTBgxwu4HB011dYGy6sZBU0yMgiYRERGR7sg5v4MWgqa6OkoO1AONgqbgiqZcyLhkFM4KM/6QyTFzZovH0aFBk8fj8Xo8nsO+h5G+P95G+7zv8XicU9yPgbQOPEQREZFua+acCN6tmkVchPW+uVxW1QSBoGngQLt12uecUCk21m7VOiciIiLSPTlBU1paC61zl11Gya8eAxoFTb4ZTYejkti3L/Bck+bObfE4OrR1DsDtdocD64ARwMMej2dVC7t/HXgj6HG02+1ei7XV/crj8fynpa9VX19PdnZ2ew9Z2qmyslJ/D9Jp9PMnXUFH/Rz2SklhUH09O198kaOTJwNwySURhIfHU19fQnY2VFdHAcP4+OM9xMUdIjfXHpeU7CE7+xCQTlFRHdnZu0N+fLW1UFoaQUpKbcjfW9pGvxulK9HPo3QV+lk8zXi9dlWui2nPz+G6dXFAGgMHHiErK5rs7JwGz7uqqhj51lsUxk0BoK4uB5crg+zsAxyo85AUHs5bq0qARHr2dM4NmzBuHFRWNnscHR40eTyeOmCC2+1OBF5yu91jPR5PVuP93G73NcAUIDgqG+LxePLdbvcw4D23273R4/Fsa+5rhYWFMWrUqFB/C9JG2dnZ+nuQTqOfP+kKOuznMDkZbrqJ9N274ZprABg1CubMAUj172LSGDXKevkBRo60x0lJUFPDSTneRx6xZXH374devUL+9tIG+t0oXYl+HqWr0M/iaWT7dpgyBf75T1i4sEtlTu35OXz/fbudNCmWVatg5MhRhIcH7bBiBdTUcKjMvtmzzhpJ797gcqWQDJCURF3dMADOPtvODZuzbt26Zp/rtFXnPB7PQeB94PzGz7nd7vnAT4BLPB5PVdBr8n2324GlwMQOOVgREZHuICXFBjN9+GGzuyQnQ48endM6t3YtHDkCO3eenPcXERERaZVXX4XSUrw33cwXFtcTHw8zZsCNN0JRUaN96+s75RCblJ/f4tMFBRaYDR9uj50Lin6+c8SSugQS4usJD7dzQ/+MJt98JgjM+TwRHRo0ud3uFF8lE263uyewANjSaJ+JwKNYyFQYtL232+2O8t1PBmYCmzvq2EVERLqF2bPtalVdXZNPu1zWt984aOqIVee2+P7FV9AkIiIinWrJEujZk3/kTOH5F8OYOxeio+Hxx+Hqq4NOo3bssJOkdet46in4wx9O7MuVl7e8ClyrfPKJncStXYvXa51/jRUUWHCUlGSPj5nTtGIFACX0oU+s1fT4g6YDB2zFuRyb6elchDwRHV3R1B943+12bwDWAO94PJ7X3G73vW6321lF7n6gF/C82+3+zO12v+LbPgpY63a712OVUL/yeDwKmkRERILNnm1nMlnHdKX7paUFLogdOWK3J3vVOa83EDTt2BH69xcRERFplZoaWLqUfYv/l5siHuGs8FW8/JcS3n8f/vQnePdduPde376ffQZVVbB6NQ89BHfeaQ/borbWZmd/7nPtPG6n1OiTT7jySvjKV47dpaAAUlMhIcEeNwi36uth5UqYO9eCph52EthURVNGRvsOtUNnNHk8ng000e7m8Xh+GnR/fjOvXQmMO3lHJyIicgqYPdtuly+HM86w1Gj5cpg/H6dJf+BAWOVbiqOp1rmTETQVFUFpqd1XRZOIiIh0mlWr8B4+zA1bbuZoeC+erP4q4b9YCH/4A1/7mp02/exncNZZsNB30uLdvoPcXDh8GJYuhYULW//l/vhHy6vi4to5f9zX01e7ZSv//S8MGXLsLgUF0LcvJCba4wYVTR6PhUlXX03JsiT6hB0EkklOtvEG1B+A6dPJXQ6XX36Cx+jTaTOaRERE5CQYMsRKlpYvt8c33QTnnw+TJsF77wGB1jmv99jWuZM1o2lLUKO8giYRERHpNO+8w4euObyyZgD3/iwM9xfOgGee8feiPfwwuN1w++34T1qKthT75x29+mrrv1R+Pvz0p3ZB79Ah2N2eRX0LbbJQ1roqjhxpelxTixVNvrY5zj6bksi+9Kmz4Moqmrx4DxRT2iuNAwdg5Mh2HCcKmkRERE4tLpdVNS1fDh9/DH/+M1x8sQ0HOPdcSEtj0HP/R3U17NtV3eyMpqb6/tvDCZrGjFHrnIiIiHSid97h6eTvEhsL//M/wDnnWLXQ1q2AnRNdfLFNIajdngcEutYSEy1oavE86c47Yd48WLmS73/fOvUeesie2rSpHcftq2j6yNMHsBDJGYHgKCy0oKnJiqYPP7SFYzIyKKU3vSv3ARY0VVe7OFwbRW6dTRFvb+ucgiYREZFTzezZsG8ffPGL1if3zDOQnQ0PPADz5zOxzy4A1t7/fpMzmurrobo6tIfk8ViINXu2KppERESkk5SVUb3qU54/tJDLLvONDpg5055zKn6wC2PV1bAtx6aC5+7pCcC3vgV5eS2OwoSXX4Zly9g08xs89xz86NZaLr7Ynmrwum9+E7761Sbfoq4O/v3vRgve+YKmlYWB5eD27g08XVFhrX0tVjTNnIkXFyW18fQ5bOeDycn29AGSWV7oBmDChBa+v1ZQ0CQiInKqceY07dgBv/899OplS6ncdBM89RSTPnyQCFctHz+dS8WhWqKjIcx3RuAETqFun9uyxcqwhw2zWU3tXnlFREREpK2WLuXN+gWUVsbwxS/6to0aBb17W8WPz9ixdrtpdzyEh5N7pD/h4V6+8x3b3mz7nNcLu3bBddex/fJbAbgodilJSdC/f6OKpvfe8481aOzFF+GKK+CDD4I2+lrnPvJOI6m3BWDB7XMFBXbbty/Ex9t9//lWQYFVbM2cyaFDUOcNp0/FHjh0qEHQ9J+Nw5gwoen5T22hoElERORUM3q0Xc6aPx8WLz7m6ZhYF2eMqODj8tFUrM32h0tgVUcQ+oHgW7ZAZiYMHWqPVdUkEjpPPAGPPdbZRyEi0g0sWcI/wq8lOdnLggW+bWFhNvk7qKJp1ChwubxsOjoUJk8mlwyGDqxm0CA488wWgqaDB21cwZgxFC28BoCUfRsAq5LyVzTV1logtXt3k1f3XnvNbouLgzYWFVGYOo5tjOCyM62UqamgKTUVIiOtWsvfOrdsmd3OmkVJid3tQwls3+4PmjYxhhXZfbjssub/87WWgiYREZFTTViYLSv37383u7TJ9AVxrAmfTvnqLcT0DAwacEKnUAZNlZVWXJWZCenptk1Bk0jo/PWv8NRTnX0UIiJdzJ//DD//eYNN5R9u4BXvxXzhCy4iI4OemDXLroodOADY+dDQgdVkMRbOPptcMshIttRm0SI7zfIVGDXknOCkp3OgzL5A8o41gFVJbd7sa4fLy7OwCY4ZXllXB//9r91vUAFeWMjHI74EwOKh64Dmgyaw9jn/6996ywY3TZnSbND0F67D63UpaBIREZFmDBli6+g2Y/oMF4frYlh7dDSxtYFJkSFrnSsshH/9C7ABml5vw6BJA8FFQqeqyv6IiEiQ//f/4P77qTpaz3e/C/f8tI57NlxOZX0UX/pSo32dOU0rV/o3jelfwibG4J3nC5pirYrowgvtvKbJrrddNveI9HSKiiA6rJrYzRY0jRlj51c7duAfPA6N7gMbNvT0VzI5K91RWwslJXzEWURQw1zvUuLiGs5ocoIvJ2hKTPRVNHm98OabsGABRET4g6belDYImj5gLkOH1DF+fLP/RVtNQZOIiMhpaPp0u93MGGKqSv3bQ9Y699RTcOWVsH+/f8W5zExISrKRUapoEgkdkp5mMgAAIABJREFUBU0iIo3U19tApPJyVr+4mwcegLt/Fs7v6r/LsL6HmTGj0f5nngk9ejQcCB6/Bw9udvc7kyP0IiNsGwDjx9uu69Y18XWdE5whQygqgpS4o7h2bIcjRwJznzYB27YFXtMoaFq6tBcREXbfX5HkS55WFgxjUqyHnts3MWBAo4qmZdmAzWiCoIqmTZvYurcnY1c8ytatNisToE98HWzbRkIChLts5tNll4c1VwzfJgqaRERETkPDh1voAxBTfWxFU7uDJt/KKOTm+oOmkSOtky89XUGTSCgpaBIRaWTHDn959t6PrMpo1R2vspozee/ZwmPDlOhomDy5wUDwMRFbqCWS/37UG4CMyo2AhUxnnAFr1zbxdXftsuFISUkWNCXVW0XR5s2MHm27ZGVh4VJ0tJUdNQqali3rxezZ9jb+oKmwkBoiWJOXyoxBeyAnh4EDg4KmI0coeH45CeGHiIqyTf6KpjffZCnz2LS3N3/8I4HWuSFxsH07YWGQFG3LEF92eQhSJhQ0iYiInJZcLpg2ze7HHi22gQCEsHXOOYvZupUtW6yTz3nv9HS1zomEUlWVzUITEREf/9RtyF9vc5cy9i/nzF5bGDI3venXzJpl6ZHvF+rYqk8A+M/LFr5klK727zp5MnzyiW/eUrCdO+1Ex+WyoGlgD9u+cSPx8TB4cFBF0/DhkJHRIGjatQtycqJZtKjRjKWiIrIYy9HqCGaMOwJ5eQzsVxsImp55hoLqRFLr9/kPyv/6N99kS9IswGb67d5tL+mdkQTbtwOQHFlGcniJv4OwvRQ0iYiInKac9rkY72F/iVHIWuecoMlX0ZSZGXhq6FD7cl5vk68UkTZSRZOISCNO0DR5Mvlbj1rx0KYVMGGCLZrSlJkzoboaVluglFm8gjDqeO89iAyrZfCelf6TlylTbH5ScAccYCc4Q4YAVtydMjjGrrRttGqosWODKpqGD4cRIxoETa+/breLFkF8XH1gRlNREXtIA2D4BJvBObBnCfv2QX2dFx56iH30J9W73z8nKjERDpZ6YflyPAlTiYmx4OnJJ+18r+fIwXa8RUV8NfYF7hryFOHhJ/Rf+xgKmkRERE5T/qCJCpz+tpC1zgUFTVu32gU7R3q6nZwdPNjkK0WkjRQ0iYg0kpVlJxznnsveoggGDqjHtf4zmDSp+decfba1s/kWM4nOy2F4QjE1NTAsuZyIinL/rKTJk+0lx7TP7drlX/nkwAFITnHZFHBf0DRmDGzZ4qV22y4LmUaMsNdUVwPwxhsweHA1I/PfJyFnDWV7Dtn7FhZSQh8Aeo8dCMBA9lJTAwf+u5r6DRtZHzmFsWTZ0nb4KpoO1kN1NVsq07ngAvv6+/ZB797AsGFQUwODB/ODfbdw47dqT/y/dyMKmkRERE5TU6eCy+UlliMnLWiqzd1BeTn+FU1AK8+JhJqCJhGRRrKyrHzozDPJr+/PwMgiO7lpKWiKj4dLL4Vnn7VypLIyxqRZ71rGYAuCnJOXMWMgKqrRQPCyMpu0nZ5OZSUcPgwpKcC4cQ0qmqqrXeRWpgUqmurr/ZXln34KEyZUwE9+QoL3IGX7fbMMiooo9QVNfSZaxdSAo1ZOlf/QS3h6TeFQTU+msrpB0FRdG055dF92FPQkMxO+/W17uz59gBkz7HtevBg2bIDbbjvx/96NKGgSERE5TSUkwA9/6OLy+PeOCZraPaPJd8WvPLcAsPJthxM0aSC4SGg4QZPaUUVEsOqgLVss1Zk6lXwGMrB4vT3XUtAEcO21dg7zpz8BMMZtVT4Zmb6eMl/QFBnZxEBwX8uas+Ic+IKmsWOhsBAKC5kxA8LCvPyB7wYqmgC2bqW01IZ7j4nYAh99RAJllJX5frEXFlIaMxCXCxIG9oIBAxj4mfXZ5S/JZvVZ3wVgavIOf9DknHutG/dV6upcuN3w5S/bkPHevX3HVVYGf/+7hWEhpKBJRETkNHbffXDBGXvB4wFCNKPJ67WKpl69OFgRCVio5Rg61G4VNIm0X3091Pq6HXydFyIip7fcXPvFOHYs3rRB7GUAAw5ssLa4UaNafu1550HfvvCHPwAwdrIN886YZHORgsuxgweC5+fD1TcmsZ9USE9vGDQ5Ic7GjWRkwPfmZ/EY32LZgTENgqZNm+zu1E/+BkOGEJ8YTnlFhG0sKqIkqj8JCb4RU1OnMnDz2wDsHTSN1akXExcH7nE9IDsbgASsGmtV0oWAzcuMj4dHH4Xvf/8E/ru2gYImERGR011mpr+iKTISwsPhs8/g/PPtqtd3vtPGUOjoUSuvOPNMyrCEKThoSky0km3fBTcRaYfgljm1z4mIEBgEPnYspQddVNKTgeTD+PEQEdHyayMi4OqrrQUOmLWoN0OGwJzzoiEpqUHQNGUKHDpkudb118OzywfyLue2GDQB3HvGiwxjG9ffNYCjvVIgLg62bg3ML9/5Ktx5Jwmp0ZRV+64AFhVRGtnXWt4Ann+efkVZuFxe8r9yO6uz45gyBcLHZNoJltdLYp5Vca06al/f7baXfulL1iF4MiloEhEROd253TaLoLgYl8va5154wRZdufBCePxxu+D22GOtfD9nEPi0aU0GTS6XzYdatarhy5Yvh4KC9n87IqcTBU0iIo1kZdlVM7eb/HzbNJD847fNOb78ZbuNiSFtXG927rSZTAwd2mCZOWcg+M03w5tv2v1tEZmQksKBA/Y4JQVITbU7viQpZlc2j/W/m61bXfz8Fy7/ynNZ6+uIDztE3zQXXHstCQNiqfDGUFNWYa1zYUnW8gYQEUFEciKpqS62b4f16+3citGjLf3KzyfBswaAVTm96d/fqpk6ioImERGR011mpt362uduuMHmQW7bBs8/D9u3w+zZcOutxw+CFi+G556pswcTJ1IWZpfegoMmsPmTmzbhX7a3rAzOOQd++9tQfVMip4fKysB9BU0iIligk5EB0dHs3WubBrAXJk5s3esnTbLAZtgwuzrmmDUL3n/f35o2erR14731FsydCwOii9kWMw5cLn9Fk38xlMmT4bXXYP9+2LaNc8cXcfnl8OST4B1uQdPGN/Ywtn4Dhbf/GCIjSRhiJ0/ln26z1jlvYiBo8hk40EKumpqgoAlg82YSN3wAwL59Ln81U0dR0CQiInK6c4ImX/vcb34Dv/41/pOZtDTr5z96FO68s/m32b8fXnwR3v3A5jLRty9lKTZ7IHgYOMD06TbKafVqe7x0qY1TcK48ikjrqKJJRKSRrCx/u5q/oul7V8IXvtC617tc8MwzVtId7PbboVcvu/KGjRuYMMHGDDz5JIyI2Mn2cDvvKSqyoir/+c9vfmNX1666CrZuheHDufhiO3famDgL77btZO3qxdjhRzk8bx4A8cNSACj/ZCuUlFBaGx9onfMZOBB/9dTUqQRmUC1bRsK2wJJ4CppERESkY6WnQ48e/oomv/JyeOMNAEaOhBtvhD//2cqzm+Is8VtSXG93+vShLGkYcGxF09Spdvvxx3b7zjt2q9Y5kbZR0CRdWl2dlayKdJSKCivJHjsWCARNA+7732OverXkjDPsqliwlBS44w7473+tjAl45BGrKBo2DIbXeNhWlQZY0JSc7BvcDRZ8PfooLFtm/0+MGMGCBfbU2+Uz2F+fQglJjP3aNP+XS8joC0DZCmu5K62OabKiCaB/f9/9lBSbJfXnP/uHgUPgmmJHUdAkIiJyugsPtyTJV9Hk9+CDNqRp924AfvpTO0e75Zam38ZZ4rek1Hd60acPB+MHAZAQ33Dd9cREq+5uHDTt39/u70bktBIcLgW30Yl0CU89ZXNtlIJKR8nKspJpX9C0d68FPlFRIXr///1fGD7cToZ27GDi+DpmzQIOH2Z41Sb2VSRSUWFBU0pKo9d++cvwrW/Z/YwM0tLsXOjtXW6ysOMdOyPOv3tCiq14V7Y2Fy9QUhHdbNA0daqvy8/lsjctKKBXz3rCwuz8SxVNIiIi0vGCVp7zW7nSbn2rpPTuDT/8Ibz3HuTlHfsW/oqm8nC7k5REWcwAelJBZImvVKm4GI4cAa+X6dMtaNq1C3Jy7CRQFU0ibaOKJunStm+31bv0y106irPSyJlnAlbRNGBACN8/KsoGSm7ebGVMsbE2zHvaNIZjg8K3b28maAJ44AF4+mlYuBCA886DDz6LZ82PXgT8+RgQGN5dlneQI8RSWxd2TOuc8705leKAf06Ta+ZZJCTYjClVNImIiEjHy8y0UvPqantcXx8oN3LW28XmYAJs2HDsWzhBU+mRHjYds2dPynokW+n2+vVw5ZV2WbFXL4iMZHrVMoqL4f/9P3vdxRfbnIGampP0PYqcghQ0SZd26JDdqlxVOsrq1dZHlmYtbPn5gaqfkLn0UvjkE3jiCZsrMG0aDB/O8Jn9ATudOnCgmaApKgq+9CUb8IQFTVVV8Ng/4/2L0zmcsQPlxFOKlTI1rmgaYSOhmDkzaKMzEHzuXBIT7UsOHtzO77mNIjr2y4mIiEiXNGmSzdL46CNbOiUnx65Cg7+iCQJX2jZsgEWLAi/ft8/K06OjoeRoT0ixS25lrt4ksAc+/3k4fNgGaKakwCOPMGPb08BcHnoI+vWzVedeeMGuAob06qPIKUxBk3RpztKiCpqko6xaZcGPb7W4vXvtFCfkJk48ZhW7YcVAcqCiyb/iXAvmzLExmbt2wbnnNnzOCZrKSKAEO69qHDTNmgVr1sCUKUEbp02z4VAXXEDCi1Z0FR7etm+vvVTRJCIiIjB/vl1de/11e+xUM6WnN6hoio+3cRsbNmDL0NXb4G+nmmnOHDhcE011om+AZW0MiS7fMMpXX4X774fbboOLL2bUhueIi/Ny+LB9+f52IVAdFiJtoKBJujSnokm/2KUjlJRAbq4FLViFdEFBx1286tPHwqGcHDuUJiuaGomNDVSLB7fNQcOgqdSV5P8awVyuRiET2PdfWAiTJ/P1r1vRVUdT0CQiIiIQF2cpkRM0ffSRTey+4grIzobaWv+u48fDhs/qrF775z8HLGhyuQJX40rjhwBQVh5GwuQM2+GiiwJfb9YswisOMTXTPoQsWACpqfaULnyLtJ6GgUuXptY56UirV9utL2jav9/mgoe8da4ZLpfNCXcOozVBE1j7HBwbNEVFQWSk14KmOOt9a1zR1KwkC6ZuvDEwf7wjKWgSERERc+GFNtxy504LmqZNs1Spqgq2bvXvNn48eHJcVO4thuXLAcuRMjMDMwBKYm21ubIySBjaBzIyGn4t3zCBWX0243JZRVO/fvaULnyLtJ4qmqRLU+ucdKRVqyztmTwZsLY56LigCSxoWr/e7rc2aFq82M6hzj674XaXCxISXJT3TKWkVxuDpk6moElERESMU3H07LPWLjd9OowbZ9uC5jSN719EvTeMzYzxb1+71s7rnBOgkp52VnfwYKD0u4G0NEhP5/tRD/Hhh1bWroomkbZT0CRdmiqapCOtWmWDsH3LteXn2+aODprq6ux+a4Om4cOteHz48GOfS0iAsj5DKe1jTzZuneuqFDSJiIiIGTnSznL+7/+s1nzGDLvEFhbWYE7T+LfuB2DDgu9DQQH7sorZt89mBDgnQKU9LDUqK2smaAKYPZu4VUs4a4YXgJgYW5BOFU0iraegSbo0p6JJv9jlZPN6rWfN1zYHgaCpIxcYGTYscL81w8CPJyEBysbOouT8LxIebudJ3YGCJhERETEul1U1FRfb42nToGdPa3tzKpo+/ZThL/+OnhHVbIi39rd1L+8BrKKpT4wNiSkJT6GmxuaFNxs0zZplHz6C2vL69dOFb5G2UNAkXZoqmqSjbNtm5y9BQdPevbbOSSgCn9YKrkpqbUVTS+LjofxIOKWHI+nd27+YXpenoElEREQCnPa50aNtGDjYdMqsLLta+IMfEJ6UyNjxYawvsKFKz73Ug549YcIE6OO1kKqEPpT5Fptz3uYYzjIrH37o35SaqgvfIm2hYeDSZXm9Cpqk4zQaBA7g8Vg1U1gHph7BQZNvHne7JCRYdXhpafdpmwMFTSIiIhJszhy7fDZ7dmDbuHFWdfTSS/Duu3DnnYyfGMH67Cg2957JP9a5ufFGK+dOqC3GRT0l9Yn+oKnZiqbMTDtrCgqaVNEk0jaqaJIuq6IC6uutnOTIETh8uLOPSLq5Fn+EVq2yHvwxY/B64fbb7bTlkks67PAAG0EZGWkzKyMj2/9+TtBUUtJ9BoGDgiYREREJFh1tJ2v33RfYNnasXZn+xjfsUt23v8348Vah/m3vw8SGHeW222zXsIMl9KaUktr44wdNYWFW1aSKJpET5oRLkZEKmqSLcaqZnFVH9ctd2mHPHrs2tXRpE0/W1sKLL8LcuXjDI7jpJjuN+cY34Pe/79jjDA+HoUND0zYHDSuaFDSJiIhI95WZ2fBsxll5rqTEztx69GD8eNv0wcEz+F7YgyT3rvPv05tSSqpiOXjQNjUbNIENHM/JwUmlUlPty1RXN9qvoqLBQHIRMVVV0KOHZcQKmqRLcQaBjxhhtypXlXbIzYWaGvj00yaefPVVm/z9zW+yciU89BDcfDM8+qgFPx1t+nS7RhcK8fH2v1JJiVrnRERE5FQyfLiVo0+fDosXA4HsKTGmiltqfw3bt9uG4mL6UEJpZfTxK5ogcKV7xw7AWucACgsb7ffHP9q0ceeDi4gAFi5FRSloki7IqWgaOdJuFTRJOzgFcbt3N/Hkn/5kPWuLFvH221YwfdddnTc4+8kn4V//Cs17JSRYUfmePapoEhERkVNJeDi8/rqdNfnO2pKS4PLL4Tff3UsiZYFV6UpK6EMJJYd7tC5octYB9gVVqan28JgOi40brczJ+ToiAgSCpqgoBU3SxTgXBpwLCp0dNNXXN1EuK92Fc16Ql9foidxceOcd65OLiGDJEpgypXNDmfDw0FVSOedQ1dWqaBIREZFTzbx5MGhQg03//jd84yepFj4FB01hByk5GHb8VefABhnAMRVNx3weycmx2/XrT/hbEDkVVVYGgiatOiddilPRNGyYlZh09oymRx6xCl2vt3OPQ05Is0HTo49CRARcfz3l5TZmcsGCDj+8kyb4Yp0qmkREROT0EBNj8zc2bLDHJSX0iT5KSYnLHzTFx7fw+sREO3NqqaLJ67UrlhD4OiICqKJJujCnoikx0SYjd3ZF09q11n/kDBCUbqXJoKmyEv7yF7jsMhgwgGXLoK4O5s/vlEM8KYLPoRQ0iYiIyOlj3LiGFU2xlZSW2gopsbF2obFFQ4ceEzQ1+Dxy4EDgg4EqmkQaUNAkXZZT0RQXZ+WqnR007dplt51dWSUnxPlrKygI+l23bJlNyf7a1wDroIuJsXVGThXBFU1qnRMREZHTx/jxsHWrLQVTXEzvuFq8Xrvq2OJ8JsewYf7WuZ497epdg88BTttcRoYFWvX1ALz2mpXHO8VOIqcjDQOXLssJmuLj7SqCgiZph+C/tj17fHeWLrWrWXPmALBkid2Niurwwztp1DonIiIip6frr7f5TQsWgMdDnwQLgnbsaGXQNHSo7ewLkFJTmwmaFi+GI0dg+3ZqauCmm+ykcupUePvt0H5LIt1FVZWFTKpoki6nvNxmM/XsaRVNnRnw1NUF0onODrzkhBQUBEZF+tvnli61k4DYWPLzITv71GqbAwVNIiIicroaOBDefRd69ID9+/2l3a0OmoYNs+VU9u0DAh0WlZXwve/Biver7IrlJZfY/uvX89e/2vs/9BAMHgwXXGAL44mcboJb5zQMXLqUQ4esmsnlCvxi76xB3Pv3Q02N3VdFU7fj9dpf25Txlqbv3g0cPgxr1thiJdhpCJx6QVPwjCa1zomIiMjpZcQIO8vr358+mX0BG6vU4opzjmHD7DZoTtOePXDFFfCHP8D3XjvXVgo64wwIC6P60038/Odw5pnwP/8DK1bYLKi33jpJ35tIF6YZTdJllZfbfCawoKm6Gg4exOu1sTodymmbAwVN3VBZmf34TPnvzwBfRdOKFVap5gualiyxmfPjxnXecZ4MvXpZVguqaBIREZHT0ahRkJdHn+9c7d/U6tY58AdN/frBtm3w3/9aN96a0gxWJ19o7RcjR/LUa8ns2gV3320nX716Qf/++uwgpycFTdJlHToUCJp8Kz149xdw7bWQng5Hj3bgsQQvVaZ/LLod569ssHcnfSOKydvltba5yEg46ywAli+3+Uxhp1jCERZmVU1RUXYa1F2cYn8NIiIi0qkiIhqUdrcqaBoyxBIj30BwZwbDAw/Ai8/XE0c5D5daeFU66ix+nnUZ06ZZu5yjK8yZFekMCpqky3Ja58CuIAD3/Dqap5+2p5zxex3CqWjKyNA/Ft2QEzSluooYXLud3euL4f33/fOZ9u6FnTth5sxOPcyTJj6+e7XNgYImERERCbHg0u5WBU09ekBamr+i6dvfhpUrbdh3XHk+1/I3ns2ZREEBfGnTj9lfl8zvf37EX0oOnT9nVqSzaNU56bIatc79nWu456/pzJ1rm7KzO/BYdu2yT+rDh+sfi26oYHc1AKlXzGJwVAF5mw7B2rX+trmVK22/UzVoSkjoXm1zoKBJREREQqxHD5uZBK0MmsDmNPkqmuLiYMYM3/acHL7Dw1TXhjN3LryRM4IHuYkZPT9r8PJjVqo7jqqqhiM7RLorDQOXLiuoosmb2o8beYjZw/bw6qvWDrR5cwceS16erRzR1n8spEso+NjOD/pdOo1Bk1LIq0jGGzSfacUKayubOLETD/IkSknxd592GwqaREREJOScEu82BU2+iqYGcnMZxRbOnVWJxwNfv+ow3+JRWL++wW79+tnw8eAP2t/7HjzyCNTXH/u2v/qVDQytrm7l8Yl0UWqdky4rqKLpUERvykng0sGfERdnv/I7vKJpyBDo14+a/cWcfbZXK5V2IwXr9hBGHUmLZjD4grEcJo6yiGT/VakVK6yLLjKykw/0JHnkEfvTnShoEhERkZBzgqZWrToHNhB8716bDvv663DZZXbVOScHYmL4vwej+O534aEnY3H17Ruok/dxrvQVFtptWZmtWPed78DChbaKXbAlS+xiu6qapLtT0CRdVtAw8KID1uucfHQ3AKNHd2DQ5PUGgqbUVD6umcTSpS7ee6+Dvr60W0FOGSmRBwlPjGPwKCuZzrv8ZoiNpaICPv3UPxP8lJSZaX+6EwVNIiIiEnInVNEEtmzMl74EL79sJfEffQQZGUyY6OL3v4foni4491xLirxe/8udoMnpiHAWGFq82N5i6tTAh/DKSli92u5v3XrC36JIlxAcNNXWNl3BJ9LhvF6raPK1zh04YJuTy7YBtkhpTo79zLZFdbVdk2iTsjILvXytc29gK0m0+X2kcxQVUVAcTmof+2FxFgzJu/YOwP49r609deczdVcKmkRERCTk2hw0DR1qt1/8ItTVwVNPwe7d8PHHMHJkw30XLLBEKSvLv8m3oBH71+6B++8nb0cdAN//PjzzDOzbB8uW2T5r1wZa5rZta/v3JtJVeL32s+wMAwdVNUkXcfSopZ6+iiYnaEo5YGVMo0ZBTU3bfwc/8IC9tk3zyJzSVV9F05ucDyho6jaWLKGAVFKH2C+5wYNt824rjmPFCrv1z3aULkFBk4iIiIScszpKmyuaiovh4YfhK1+Bt96yDymTJzfcd/58u33nHf8mf0XTH/4Jt91G3oMvAXZCumCBDQl97TXb58MP7bZHD1U0SffmBKZORRMoaJIu4tAhu/VVNBUV2cPkA9lQVcXo0fa4rQPB1661QimPpw0vCgqa9kek8SmTgOaDpuJiq4SVLmLJEgrC+pOaYaFlaqrNYnIql1essFZM5wKXdA0KmkRERCTk2lzRlJoKfftaRdOXv2zbZs60TwK33dZw30GDwO229jmfvn3tdn9OGYwcSd67uUSG19Gvn4VM8+fDq69aBciHHwbmHaiiSbozJ1QKDpq08px0CeXldtuooimZA7B7t3/eTFvnNG3ZYrdBBa3H5yQSgwfz1sYBAJyTsZu9ext0YPvdeSecc47aULsK7wfLKXD1I7WfRRdhYZCWZn+t9fUWCqptrutR0CQiIiIh17cvuFyByqbjcrnsE8Tf/mb3Hb16NXzsWLDAeuF8n7SjoyEx8jAFUYNh1Sry+k8jrW4XYSutfGnRIti50z6crFgBs2fDiBGqaJLuramgSRVN0iU4FU1BQVNkRD1x2CoMcXF2zaAtQVNdnc11gjYGTbt22T8SffvyxvJe9GMfFwzKoqIikIcFe+89C2ydcEw6UWEhh7bu52hdlL9yGaxa+dVXITnZVpydNavzDlGapqBJREREQu7rX4c332xDRRNYKhUe3rp958+HiopAf8PmzaTW7KFg+FmQmEhe+hwGRxXCjTdCfT0XXWS7/frXgZPS4cNh+3b78CLSHSloki7LSXCCWudSkupxgb+VbdSotrXO5eUFKvbaHDQNHkxdvYu333GxsOdyBtZZlVPj9rmionB/W97+/W34GnJyrFxJAZYwBQdNl19uF4uuuAKeeAKuvLKTjk+apaBJREREQi4xEc477yR+gXnzLJRassRq53/5S1LDitgf7wYgLz+CwWemwvr18OyzDBwIEyfaYHCwoGnECJtxk59/Eo9T5CRyPnRrGLh0OU1UNCX3DbMK1aCgacuW1reoOW1zgwadQOvc4MGsWQOlpXB+6icMqNoBHBs0rV0b47/fnqCpvh6+9S349NMTfw8BVqygICINaBg03XwzfPIJPP64XdhygnbpOjo0aHK73dFut3u12+1e73a7N7nd7nua2OcWt9u92e12b3C73e+63e4hQc99xe125/r+fKUjj11ERES6kIQEmDrVWu1GjYJ//IN+I+IoKImkttbCo8Fz0mHCBLjjDqiuZtEim8cxYIAtcjd8uL2V5jRJd6WKJumyGlU0HTgAySlh9gvYFzSNHm3Sv5OwAAAgAElEQVSFqc7qYcfjtNktXmyt0E6WdVy7dsGQIbz3nj1cMGw7Aw5bD17joGn16lh/t/a+fa18/yYcOACPPQZPP33i7yFYRdMwW04uOGiSrq+jK5qqgHM8Hs8ZwATgfLfbPb3RPp8CUzwez3jgBeA3AG63uw9wFzANmArc5Xa7Wzv5QURERE41F19sn1CSkuDvfyd1wTj277cPB3V1MHiIC+67D3bsgEcfZdEie9msWXZRfcQIe6w5TdJdaRi4dFmNKpqKiiAlBRgypEFFE7S+fW7LFpvJM3duG15XU2OlSYMGsX+/VdsmDYqhf6m9uHHQtGZNDLNn2/32VDSVldnthg0n/h6nvcpKWLuWgkFTAAVN3U2HBk0ej8fr8XgO+x5G+v54G+3zvsfjqfA9/BhI891fCLzj8XhKPB5PKfAOcH4HHLaIiIh0Rbfeape1V66Ea66h34BwyssDw2IHDwYWLoSzz4af/Ywpoyu48kr42tfs+bQ0WyJZQZN0Vx1R0VRSEtr3k9NEU61zybQ7aMrMhLFj7XGr2uecxCcpiYMHLWiiXz96Fe0gPt7bIGjavx+2b4/iootsHYr2BE1OQZeCpnZYtw6qqylIGo3L5QsqpduI6Ogv6Ha7w4F1wAjgYY/Hs6qF3b8OvOG7PxAILqzc49vWrPr6erLbumamhFxlZaX+HqTT6OdPugL9HJ5kvv+29fUJwABef70Q6EtNzTayt1TT87rrSL/2Wgp/8yvuuuvq4JeQljaMzz6rIjv79BrUpJ/JU0NOTgwwhIKCXURH1wNDyc3NY8CAIyF5/40bo7n66nReemkHGRknrydPP4+nnpTt20lyudiSl0dtnYvS0lF4vUUciI0lafdutmRlQXg4gwYN5z//qebCC4/fP7dpUwbnnHOIysr9REe7+eCDUs46q7DF10Tu2sUIIP/IEfbsOUR0dCQFQGp1Ncn9K9mypcb/+/+NN+KANIYM2UFS0gA8nkqys/e29PbN2rDB/t8sLITly3NITtaqE23V56WXSAU8VQkkJtaSm5vb2YfUYU6F34kdHjR5PJ46YILb7U4EXnK73WM9Hs8xebTb7b4GmALMPdGvFRYWxignKpdOk52drb8H6TT6+ZOuQD+HHWPCBLvdubMvAPPmDbeL6ZmZ8Mgj9PvHP+h3110NVrYbNQry86MYNSq+wXtVVUGPHvhndZxq9DN5asizhbMYOXIIMb4ZxqmpgwnVX+2qVTbU+NChYSF7z6bo5/EUFBUFcXGMGj2aggLbNHp0Csnhk+GJJxiVmAhpaVx1Ffz+9z3o128UvVsYilJcbNV1M2b0ZsyY3owdC/v2JTFqVFLLx3HEQteBo0dT+3oc/fpB6vjxAKT3r+fQoXj/7/8//hFiYuq44oqhPPwwVFREMWpUW5ZODXAGlwNUVo48qf//nLJycyEjg0M1/Rk0iNPqd0R3+Z24bt26Zp/rtFXnPB7PQeB9mmh/c7vd84GfAJd4PB7n8kk+MChotzTfNhERERH69bPbNWugd29/x4alRT/4AWzfDv/+d4PXjBhhw8C9QY38e/bYvNo//aljjlvkRAW3zp2MVeectiINzJc2Ky9vMAgcglrnwN8+9/nPQ20tvPyy73VeL9xyCyxf3uDtPB67zcy027FjW9k6d/Cg3SYmNmidAxgYd6hB69zSpTB58lEiImyX9gwDdzr2QO1zJ8Trtbb4s84iKwvGjOnsA5K26uhV51J8lUy43e6ewAJgS6N9JgKPYiFTcC3kW8B5bre7t28I+Hm+bSIiIiL+QaF79vjmMwW79FLIyIBf/7pBqjR8OBw+DIVBZxw33WRXzt9//+Qfs0h7nOwZTc6H8O3bQ/eecpo4dKjBfCbwBU3p6fbAFzRNmWK/r194wfe6rVvh97+Hhx5q8HbZj34ABIKmMWMsCCouPs5xOIlPcNDk+8diQM9S9u61fxIKCqyleupUq4Dq3z80M5piYmDjxhN/n5CoqrJ/Az/9tJMPpA2ys+HAAconzSMvD8aN6+wDkrbq6Iqm/sD7brd7A7AGG+79mtvtvtftdl/i2+d+oBfwvNvt/sztdr8C4PF4SoCf+V63BrjXt01ERESEvn0D948JmsLDbXj4unV22drHWXnOqdh49VV46SX7cNCdzsnl9HSyV51TRZOcsKCgqajINqWkEPjl7AuaXC5YvBjeftuXCS1ZYs8vXRq4KJCXx5a/rSIqvMZfEOUMBN+06TjH0VRFkxM0hRdQU2Nh1bJlttuUKbYmVb9+FhZVVDTxnq3g5FvTp3eBiqYtW+CVV+DFFzv5QNrg+efB5SJryEVA4O9buo8OndHk8Xg2ABOb2P7ToPvzW3j9k8CTJ+foREREpDuLirKWudLSJoImgGuvhbvvhjvugA8/BJfLHzS99559ALnxRrtSvngx3HOPfVhIOLERHSIn3cmuaMr3DalQRZO0WXOtc7GxdscXNIH9vv3d7yzov+bdd21jYaEFJKNGwZtvsoVMRsbmEx6eDgSCh40bYc6cFo7DFzTV9krk0CH7N4KkJBgyhAFZbwPz2LvXcq1evWD0aEtq+/e3l+/fD8OGtf3bLyuDnj1h8mR44AFrD4zo8OnIPjt32m2reg27AK8Xnn0W5s5l435bak4VTd1Pp81oEhEREQk1p32uyaApOtrSo5UrrWwJ6+KIiYE777SAKS8PHn0Upk2zl3z2WYcctsgJ6ajWub174ejR0L2vnAaaaJ1LcuZ2DxkSCD+w37dpafD8v7yW+jvJkdO//MYbbCGTTFeO/zUDB1qQs2PHcY7j4EEIC6Osrhfgq2hyueBHP2JA7lIAX9DkZdaA7cTk23E5M/9OtH2uvNwuUowfD9XVkJNz/NecNM5/607v4WulDRssZLzqKrKyLAB0Ktmk+1DQJCIiIqcM58NBk0ETwHXXwejR8MMfQnU1PXrA+vXw+uvw97/DG2/AzJkw0Vd/rfY56cpO5jDw+nqbgeOM1DnuB3qRYEEVTUVFdtcJQxkypEFFU1iYDQV/9TW4sPRpXpzwMyrTRsDSpVQdquam1xeylQymVH7ob6dzuVo5sPvgQUhI4GCZLSGamOjbft11DOhn7/XZp16ys13My3mURN9UcuffkhMdCO5Uw/oWuOvc9jknaNq+3b8KX5f27LNW/nXFFWzcaNVrp+oKsKcyBU0iIiJyymixogns5PU3v7GBs48+CticpgsvhGuugfN9a+H262d/FDRJVxYcNEVE2Af2UAVNRUVQVwezZ9tjzWmSNmlU0ZScHPScEzQFLcxwzz3wk7M/YgPjWfzgHJL2ZbHo5euZMamKP9bcwHcH/ovvVv0qMHOJVg7s9g1mChrVZKKi6P/DawH45/17AJjHUiJ8A6WCW+dOhBM0ZWba/5udGjQFp8THHWrVyZy2uQUL8CYls3Gj2ua6KwVNIiIicso4btAEliqdfTbce2+L/UCTJilokq4tOGhybkM1DNxpm5s1y241p0la7ehRC3h86dIxQdOUKbaPM48Jy6R+Fn43u8ZcxJtvwtfnbSWnOp38vFr+E34Fv//FUXpQ0yA06d+/lRVNTQVNQNQN15EUVsKG0kH0Cq9g0vg6InxLkCYnW3DbnqApPh569LAxU42DprIyyM09sfdus507we22+03Maaqrsz9dwurVdrxXXcX+/bYCrIKm7klBk4iIiJwypk2zk3rnanSTXC74yU/s08+//93sbhMnwubN9nnI64XHH28wVkSk01VVBSqZwIKmVlU0LV8OCxfCnj3N7uIETePHWwigiiZptZwc+6U5ahRg1XEpKUHPX3GFLRP64IOBbZWVsHw54QvOYeFCePCxnuTgZn91Hy6dUxroQQsKmlrdOtdM0ER0NAPS7H+emfMiiRwywF/RFB5uh3iirXPOjCawQ//4Y1i71h6vWmXhiVMteNLt3AnnnGNDrZqY0/TjH9vqeF3Cv/5lv8guvdR/qFpxrntS0CQiIiKnjC9+0cKh8PDj7Hj22baU0BNPNLvLxIl2lTcry1ZD+uY34a9/Ddqhutom2DbYGPDgg3DVVW3/HqR5L70Ev/1tZx9F11FVFTT3hlYGTa+/DuedZ+vJt/Dz76w4N3Cg/a+ioElabfNmux09Gmiioikqyn6hvvZaoFTuo48sbJrvW4B86FAYNAgXWE/z0KG2PSjt79/fcqQWq/haCpqAAaNsw7z5kdC/vz9oct6/va1zAN/5jgXCU6fCJZdYwLR7t1XrnHQHD9rBDB9uK140qmjyeuGf/7TZ211Cbq71GyYk+IMmVTR1TwqaRERE5PQTFgbXX29rWjfTvzBpkt2uXg233mr3S0uDdti2zT6Nv/56g9d5vXDXXXDzzfDcczaqRELjwQfh5z9vMNrltNY4aIqOPk7Q9O9/w2WX2QfOadPgH/9o9j/m3r2BgcvDh6t1TtrASfszMoAmgiaAG26wfR5+2MKQH/7QfoCdFedcLpg3z+5fcIElRAkJx7TOwXHCoLKyloOmAXY7b549iCgpsYsI2M9+KIKmGTPA44FbbrEFJxYutPs1NfbnpHL+e6WnW2lQo6Bp0yYrbDx8GGprT/KxtEZQKVhWlv0dHPOzI92CgiYRERE5PX31q/ZBp5mqjvR0+1By992WRYWHN5hDa58cwJKoID/6kY1/8nWNqN0uhDZvtr+D4uLOPpKuoc0VTb/4hc1qee89qyjZuhXWrGly1717rXUoMtIqmv4/e+cdF8Wd/vH3UgVEsKCoiKDCCliw15jERJOYaHq5xJjk0usll9zv0kwvd0ku7WJiEtPMpRtLetFEjbFhwQK6gAoqRSyASFHK/v54draxKCCg4PN+vXyNOzszOzs7O+z3M5/n8+zYIZ3oFOWYpKZKlwV/f0pKpPzYpXQOxCp32WXw3nviYkpOFmXeFiAOwN13iyJj1E5FR9conYNjlLc5OZq8vKBtW9enBwwQsWnIEByq0549QB0zoDxQVSXCja3pHiDayUsvybXrm2/k7QOUltZ/+/XC+AMUFSXWoLw8Uf5s/PCDY9GioiZ4/foqaU4KndFxTmmZqNCkKIqiKMqpSdeucMEF8OGH8mO4qMg+wAC5oZ6YKL/JJ06UKhAXR5MhNGVl2dcrLpamdtdcA++/L0+r0NQ47NsHtpxe0tJO7L6cLHgSmmotI7JaRVg680wZAV96qazwv/8B9ogcu8EpJ8cx7u7dW17LyG1SlKOSmkp29FgqKhyahkdXyt13y3V30yapi50yxfX5YcOkVtbobe8mNBmOplrFoMpKuSiHhFBYKPqFl9vo929/E7eer6/TBm0neni4XNrrK7AaLlbD0eRMu3bydgID5XGzCU3R0dCvHynE883bjgP244+ORV3+vjUG2dlyt2bOnLqvc/AgtGtHVZW4rbRsruWiQpOiKIqiKKcuN98s6kWvXvKDOCbG5W7vsGEyMPnPf6B9+1ocTWB3NRlOm/HjZZPg2llaaThG7Auo0GRQXl4PR9P+/TKI691bHoeEwOTJ8Pnn/PpjJQMGSNXSr7/K085Ck3Eua06TckyOHCEr7TCxi95kyhSHOOxRaBo1Cp5/Hn7+Gc4//9jbjo4W4cSmhh6zdO7gQZnaHE3uZXMgoo/9O2Sc8DblKjxc3ElOfxLqhOEM8iQ0GTSr0BQcDO3bcyBiABP5hYum92PNGjk8y5bZo7Rc/741Br//Lm+wPvXONqFpxw65viUkNPI+Kc2GCk2KoiiKopy6nHuuZNYMHiw1b8XFkhli46GHpENQv361CE3DhklNnZvQ1LGjlIoEBh6f0HT4sATI/vRTw7fRWlChqSb1Kp3LyJCpITQBTJ3K9L13M3GSD1artGL3JDQZq2hOk2InPR2ee66mgJCRwUPVz1BW6ctPP0leHXgonQNReR580JHFdCyioqQOz6ZehYXJjYBaHU1OwUwFBXINPypujqY6ZUB5oFahyWoV22BZGUFBMqvJhaYdO+S4mUzc+XQX8ulMB78S7rhD+gFUVkoTDWgCoWnZMplu2CCi07GwWu2lc7t2ySwjA15peajQpCiKoijKqYu3t5RsLFggd9YvuADeeMP+6799exg6VBYNDfUgNCUmirffg9BkMsnv++MpnUtNlQid+lQetBY++0xuhBukpkq+SkyMCk0G9QoDN+xIffrYZx056zxe416mRKxj0yYxmCxaJJWk+fkOoSkyUr4q27bBxo3w8cea13TK89//wiOPiIjgxMr5eXzG1Txy4x4uvNBRmtUogc6G6mBT7729JUesLkJTbY4mFzp3xuqkXBkZUPUVmgwjlXNGE/v3w8UXi23wnXea19EUHc1nn8Hnn5t4IuojXuvxEklJUjbYrp1krUMTlM4tWyalup07w3/+g9UqYvWCBbVcpw4flotPu3YuXS+VlokKTYqiKIqiKAb/939SJ/HhhzWechGa9u+Xf2azWI5Wr4bqanu76g4dZOoWKVJvUlJkumpVw7fREikrk0HQU0858k5SUqTEw2xWocmgXo6mbdtE/XSyCPyxyo9igrmxYiZt2sBZZ0kmc0qKmAsMocnXV8Smf/8bBg6EadNEkFJOYZYulalT102rFe57K5au5PDPZ9vx3nsOoaBRhSYn9b5r16MIQfUVmry9qezY0SWjCeofCG53NLWzysXqrbfki/PDD+DjAzt2NI/QZLVCZiYl3WO54w4Rkv95TjJX73udM86QtzlxosNt1qiOpv375UJy9tlw5518/EMHIsIr6N1bTMRvPOPhxZwUOiMPzrgGKS0PFZoURVEURVEMxo6Vtu//+Y+EczgRGiq/g6uqcCgdhtBUWAgZGS6OJnBEijQUoxN1SopDcDkV+Ogj2LtXbm4vWSLzUlNFaIqNlSowddSIqNSmjePxMYWm7t1dVvj+e/D3qeSsPZ9AURHjx8vY9LPP5HnnQd7118OECfDaa/J4zZpGfStKS6KwUKxt4CI0zZ8PK3dH8GzYq7TtHEjHjjB3ruj3xyxbqws9e8rULRDcEIKsVpg+3encrK/QBFR27mwXmrp1E23WeKt1xS40/WWS/I244w558ZUrpQ41O7t5hKaCAiguJi1gIIWF0sDPp1ckpsICZvz7EIGBcPnljs+mUYWm5ctletppcPvtfOo1Ffbu5U1uZzBr+eDdipqxTU41h9nZEi3l3IRQaVmo0KQoiqIoimJgMsmoaPt2GSE5YQxSDh7EEQRuCE0Aq1fbHU3GD/eoKPnt3NCShM2bZZes1lNnYF9VJTrfoEEQECA5IgcOiGshIUGEprIy7KUVpzL16jqXkeFSNgfw3Xdw5sACgiiFDRsYPhyCguCTT+R557KVxx4TQ8Y990g4+Lp1jftelBbEn3/KRen000U8saVlr10LXlQxbbijUcLw4eKEMxrHHRdt24r9xkloCg93CE27d0u57a232qKjDOGivkKTbYOBgXDFFfDOO/ULBD+4KQuAdsXZ4mZKS5POeoMHy5equYQm23HK8pXvfVQUdrEuPmAHBw6I0BQUJGWIjVo6t2yZhL4NGwZhYWS2H8TItincPjORWzvNJWVPGGvXuq3j5GjKztayuZaOCk2KoiiKoijOXHih1Am9957LbGOQUlCACE2+vmJZio+XX+qrVrF/v9yB9fOTZT1UetSLlBRxkUArKp9LSoIvv6z16QULRBN56CHJCP7lF0cQeHy8ZDSBls9BA0rnnILA09Ikz/mCS2wna3Iyvr4SIWOIeLWVrQwZQs1BonLqsHSpXP+efFIUnZ9/BiA/r5ow9uKd0LfpXtvNJtq1q+SJVVXZo/JYtw6++Qa7RaciMISSkjoKTZ062R1NIAJrSQm8/PIxVvziC3jiCbjvPopelr8dIYvmwm23yUXLUNrchKaSkmPvU4OxHafMqh6Aq9BEVhb+/rJbJpOHZhfHyx9/SMBhmzZYrZBV2pmomyfArbdyxfh9tKGMD953szQ5OZqcmxEoLRMVmhRFURRFUZzx9oapU6X9llM4hzFIKSxEhKbevSVvw9tbflCvWsWBA46yObD9sKdhOU3FxTJOGDdOjCitRmh6/nm47rqat/Krq7H++BMv3rGdXuGlXHKJ5IdYLI5AYaN0DlRognoITYcOwZ49LkKTUfF0/tUh0KULrF8PSE4TyGntsVMYYszYsaMJwoOVlsHSpexJPIdPd50mQc+2k2lvVimdyZcvalMRFVWjdK6qShxHq1eL/tWrl2g+1oJCMJkoskoqd50dTUbdLvJWrrxSss9rdTVlZ8NVV4nw9u67FIX1xsfHSkD/PjWX7d4dcnIIbCO1v03qaLIJTVklHQkMtP1tMv4oZWW5LFqj2cXxUFYmFtyxYwE5nGVlDo0r9LT+XMw8Pvu02tWBqY6mVoUKTYqiKIqiKO5ce62EABlhNbjlWFgsVMf25bLLbF2bTz8dkpLY/1syHdpV2Nc5HkeT4eLp109io1atqtlJvEWSmSn1XQsXOub9+ivExDB/0tus3NOL+/MewPuC85gYIwPKt98W01hkpNzlDgxUoQnq0XVu+3aZOglN330npYhRUUj3xORkAMaPl+e7dpXW8Z4YMkSmWj53ClJSAmvW8Jbf37jmWi/2n3kZ/PQTVFaSv/tw0wtN0dEikthC2rp2ldm5uSI0JSbC44/L6Tx/XSS0a0fhQTmR6yQ0GeqqU8L49Onytv/zn1pWWrlSpitWwKFDFF14HSEhJs/lgt27Q2UlgWUS6NfkQlNICJm5bYiKspmqOneWi4YHoanRhOOkJBHqbEKT8VKG0MTIkdzABxQUeYvzzMAmNFW3lTBwFZpaNio0KYqiKIqiuNO3r2RLzJ5tn2V3NB2ogowM9vYYzNdf29w2Dz0EDz/MgZxyOqYukx/atnXatTu6o+ngR/NYcvbTZGa65o8bHecSEkRoys2VDJIWjzHqMEYYVivcfTf7qtpzW7vPGJxYxc0vmmHFCuJuP4OICCv790NcnAgfXl5SiaJCUz0cTRkZMrVlNBUVSfXTBRfYnk9MlBPuyBEGDoQOgeV0q9opLigPDBokUxWaTkFWrYLKStJ8REzKHTZFFIqbbyY/rZAw7wK5fjYVkZEiYtjOTaMzXHa2mGiGD4errxbn45PLz7bnM0E9HE3gUj5nuJreeKOWUrdVq6Re2vbFOHhQrvsesdWDBR6Qi3mTZzRFRZGV5STyeHnJMXQTmhq1dG7ZMpmOHg04XsowUzFgAOP9/iSibSEzZkBlpW2+rXRuX2UolZVaOtfSUaFJURRFURTFE9deCxs2SIgrTkJTxn44coQ9Yf0A23ikTRt49ln2Rw6iA/ulbRqObvJHE5ru+z9fzlg0nehoybpdsEDmb94sYdjR0SI0QSsonysulmRvk0ksNdXVkuVhsXBP1y8pKGvDBx954/vA32DGDEy7djIxcS/gapKIjVWhCWoPA6/hfNu2TaY2R9Mff8jg7rzzbM8PGiSD99RUvAoP8OSRh7g19wmpQXrkEXsZkUGnTjJWVaHpFGTpUjCZSCsSQSavzxipV/vwQ/K9wul82bimbRXWQ/KG2LULcDiaFi+WCtHhw6Wi+fbbYUNBT3KCYhomNDmVTQPceadsf97X1ZKgbbTDBLkwJybav4xFRRASUssL2Gw63nnZ+Ps3g6MpOprMTCeRB0R1crPZ1tfRVFUFn34q/TBOP93tyeRkEbVtdeTGS9nFLj8/vIcO4uHOs1i6VP7UVlZidzRlH5TzRx1NLRsVmhRFURRFUTxx1VUyYvn4Y8BJaNomJQ957SQsyOnGN/uL/enY2dulRVxUVO2lc4cy9/FF/hlcyHze/dtmIiNlXG+1itAUHy9ZOQMHyg3zFi80Gbe2J00SR8KaNfDuuywIuIrPVvZi+nQYMMC27AUXgK8vE60SNJyQ4NhMbKyId276x0nN3r1yg98wF9WblJQaCpInoclqdXIIGGzbJoM+2+h33TrR+owSOBITZZqcDB9+yF2Vr/LXOedLMP5zz0krLzc0EPwUZelSrAMTSd/uA0BecVv4/XcOr0/lYGUQnft3adrXdxOaDEeTIdAPGyZToxnoGtOw+glNRumc84UdGDNGRP/Zb5fBnDnw+uu2FSrlOmbcDaBuQpMRCN5kQpPVCpmZFHczU1DgJPKA/FE6joym8nIYORKuuUauwzUE55wciIiwP8zKkuPhcvxHjOD2nOn8+7kqPv9ctlVZeAj8/cneKw0KVGhq2ajQpCiKoiiK4omwMDj3XBGaCgsJDpbBeWGm/BrP85UBjzEeqa6WO8IdewSJE8qmghiOJqsVSUQ1WnoBc55Lo4S2/IMXuSlsAQ8/LHrCwoUy7SemKfz9xXTSaoSm22+XEo7Zs2HOHGaH/x+RkfDgg07LhoTAxImcu/EFJk60Osq8EKGpquooTrGUFHFenESsXi0RLvPmNWDltWvlZPjkE/ssq9Wz0AQeyufcOs6tWydOhLZtbTP69JHgq3XrYOZMUcQuvVQsC9deK2KTLSzcYPBg6Vpn5PcqpwAVFbByJXuHnmf/3HNzgTFj2NspDqg9QL7RcBOaAgLkUpGeLkYqs1meTkwEL6pYUzHQ7tQxcvaORmWHDnJtcnM0mUwwbRosXBFINt0kl6qsTML0SktdhKaDB48iNIWHy/abWmjavx9KSsgKlj8iNRxNe/bgnMRdn9K5LVtEW3v2Wck/P3RI/tlxaxmXmekmdIEoVeXl/N/EZF54QRqRfrmuj73jHGjpXEtHhSZFURRFUZTaePhhaTU0dSpeVBMSXEXh0o2QmEheidj7jfFIYaEM/jvEdpIf8LY07+hoGUzs2wcrbn6f13u9ijVXgmY/mB9KjPc2RvfaA+vWcdVV0gDsscfkt7qzi+e000SoMFp4t0gMa9fgwWIRePNNKC8nq42ZhASpwHHhsssI2bWZn59dW6N0DmTA45F//hOuv75x9/042blTpn/+2YCVDUXt6afJsFSRliZGCqu1ZvnG1aAAACAASURBVBg4eBCaMjLs+UwgepKRswQ4bHMffywj9ttvdzz36qtSK3fDDXDkiH224YZy05+U1symTVBWRlr3M+2zjMzs/HyZGpVnTUaHDqIu2YQmcJTPDRvmCLAPDIQE3zTWlpjr5WjC21suwm6OJpBmpFarif8xVS7qCxc61H83R1OtGU0+PrL9phaabNeMTB/53rsIPcYD46KEHJvDh0U7OxZGVuCECQ7XkT073WqVP4pOKlFWlpvQBY7jtXIlf/+7NHtYubu7veOcyeRwqyktExWaFEVRFEVRamPUKHjtNWnffc89hJbkUODVEebPZ0++tBQ6eFDu5h44IKt07Gcb9djqiowf2G++CeM/vZG/HXmRpy9ex7atFSzdG8/1icmYhg2Fdevw95csEKOJkeFoAskb794drrjC8VotjqwsUUa6dIHJk2VQMmQIWXsDiYz0sPyUKTIwmzPHZfaAATLWdG5c58LWrTIQdU5XP8EYZq5lyxrQPdAYxaelcdul+VxwgUNMOqaj6cgRGVDaHE379smhGTzY7TUSE0Ut7dgRLrvMMb9DB2n7t2ED/Pvf9tnG+prTdAphE1XSAwcCUs5rCO3NJjSZTOJq8iA0GeVyBkNYx5oDvSkoEP0oKKiOr9GtWw1HE4hWO7rjVmb73Ig1uJ3U661aJd8RJ8fgUUvnjO3n5DSt0GQT9bOqxQFWw9HktAy4dVU9BobQFBHhEIPsQlNhodxosX0otgq+mo6myEhZeeVKvL1FuE7Kj4KQELKz5U9EjRsPSotChSZFURRFUZSjcfvtcOONMGMG7a37KRw2AXr2dO5+TW6uVCoAdIjrIjUctpym6GiZ/8QTEG9N4S/eX/L4qklMm1yAiWqm3Rooo/bMTNi/n9tucwgGzkJThw7w1Vdyo/266+zdvVsWWVkywPDygosuAm9vSm+8m337PAxEQN70+PHw9dcu6kxgIEycKOO8GqLN4cNyN7+yEvLy2Lq1AcJOE2CYB/bvB4ulnivv2SMD7IQEstIOk54Oy5fLU56EJqeKGEcreNtA2HAg1RCaDIvTX//qsEYZTJkieU2vvmrfeJcuMl5+8kkpl+rY0cUgobRGVq6Ezp1JL+iEj4+cMsZ1cK9k9jd96RzUKjQZ+UwAVFcztGIF+WXBbN4sjh2TqY7btwlBnpjm9zmplbGsGPE36Zy5YoUoXLaNW611EJq6d7c7mjx2sWsMbCJS5qFO+Pu7CYCG6uSU02TPIKyj0OTjI9usITQZAp3N0VRYKD0gajiaTCY5brYbMkOHQvLBaCratnevvFNaKCo0KYqiKIqiHA2TCWbMgLvvJnRATwqtMoLIy3MMXHJynBxNYV4uScnR0XJndnR8Ab8xng/fLOV00xKWZ3RmgmkREVeNdYz6168nLAxuvKacrp0qnPNUARlIvfyyNGz7/PPmePONjHP7o5gY2LmTnWdMA/DsaAJx12RkiKPGiQsvlLFmcrLb8tu321W4tGX5xMXBu+822jtoMDt3OgZP9S6fy8+Hjh2xPvY4ORUykv/wQ3nqmI6mFStkGicZOoYDycj/tnPuuXDmmXD33Z734e675ST/+mv7rOnT4ayzZLUDB1wy8JXWyKpVMGIEaekmevUSR0uzl85BDaHJEDtcHE0HDzIEOSEXL65j2ZxB166SpeeuUB85whX5MwhtU8aZix/n7r3TyU094FI2V1YmRsq6Ck1N6mhq356sPH969nSUFAJyIfL29ig01aXz3O7djk0Yx95uADMEOpv6Z7yExxsJ0dF2e9SwYVBe7U+KqR/Z2RoE3hpQoUlRFEVRFOVY+PvD668TGt3efsd3zx5H8GxOjsPR1LEjIjTZAsHbtpX/Lpr8GiHeJfhdfRlzb/mZy/iKx4d+L+4nQ2iyiVOv7r2GTWV9MFW5tw+T0rqgoBaa1ZSV5Tri6NaNrJ2i1nkciABcfLG8YbfOZxdcIIMno9uUHSe70KZVMop7+eUT7wDbuVNEmY4dpXyuXuTnQ5cuFJ19KaUEYaKaeV9J2LxdaLJa8V8lAeiHt+12rPvRR9Crl93usX69aH0dOri9Ro8e8NtvjrBld848U2qH3n7bPuu220R3MoS8bdvq+b6UlkNBgXy3Ro4kPV104q5dXUvn/PyOkk3UmPToIS9sa684dSo8/ribOFFYyEA24O1VTXFxPYWmoUOlxtT94pKWRvuqfWx88Reun1rFTG5jNMuxDnfNZ4JjHIfu3eHAAQL9q5o2oyk6usYlFxA7UkSEi9BUp9K5HTvgu+/YvctqvwnSqZMITrU5mozqPI/X927dxO5UXMzQoTIrqbw/OTkqNLUGVGhSFEVRFEWpI84toPPyHNVGubkOR1OHDshA5fBh6X6GmEnarPhdVmjblg5P3ctXXe5m9F2DHStFRYndZONGfL+dS8eSnfZAcWdMJhG4tm5t2vfa6JSViTrnNuIwyq1qdTR16iTt6L7+2qWTXFiYNEebP99teSehKX1rpX3WTz8d7xtoOJWVYpDo2RPGjm2Ao2nPHujcmZw8+ek+udtayislwMT/w7clAOycc2jz6vMAHJ4xS9bLzBTx6Prr7fa7des8lM3VBS8vuOUW+OOPGudlSIicwtu3N2C7SsvApmxXDxtBRoYITeHhjkievXvFzVTn8rTjoUcPUY5t7plBg6Q02eW1CwsJoJx+kdIer15C0/XXSyeG++5zTcfevFleflw0b3/gx8t93yWTaHZ1H2lfxBCajuloAgJNpa5CU2WlCC/HyaZNULljF0RFuZhIXejZs/6lc//8J0yezO4/M4lgN1iteHlJGa1daKrF0eRxHwyLZ24uvXtDe1MBfxYmsG+fls61BlRoUhRFURRFqSOG0FRRIQ4ms1lCqQ1Hk8lk+8FutOSyOZQ4fFjKTk47TR537izq1LRpjo0PHiwqwHPPOVJQjfUBfvxRBj5WK337tkChyVCU3EYcWVlyR/yoA4v775fB5X33uViTLrxQ3GJOmbaQliYj4NBQ0jP9CAuTbb/ySmO9kfqTkyO7HRkpzfbS00U7qjP5+SI02cZwt80aRoC/BJ37r1shNrdVq2hzz60A7Pt5rZQbfvSRoy87Elyfnu7Wca4+XHednJvvvFPjqd69XR1NVqtHnVRpqaxaBSYTORHDKS2Vzo9GNlJenpyizZLPBA5V2ql8rgY2xWRIX1Fy6iU0+frCf/8rF5YXXnDM37xZLlY2K+vAu+R6npLT3r7IQdG1jh0GDgRZS1yFpocfFoHrOJoYLF4szRIezLiRsu59yM+vxU0UFeVy4axT6VxyMtZ+/dld0YWI5V/At98Ccrl1EZqCg6FtW0BeIjDQ5vR1x7jo5+RgwspQ6xq+3ynBhOpoavmo0KQoiqIoilJHQkOlw5wx4A8Pd+TG7t8vz3t7I6PukBBHaM2aNSI2GUIT1Lz1P2SIiANffgn33is/1p2FptdflzDmpCTMZtFtmqzsoimoJaxj506p4vDxOcq6AQHwr3+JEPfSS+Ku2LCBCyeL6PTNN07LWiwyCo6MJH1PO/r2hbvukg51NkNCs+Ps2ho7Vv5fL1eTm9AUGwtTLvIGwP/TD2Q0l5nJ0GcuIrxzFY/zBFVPPStBTuPH24+5EXPVIEcTiEB6ySUiYLn1QXcXmn7+WcbMGzc28LWUk4uVKyE+nvS8YMDhaAKH0NQs+UzgKO+sg9A0NFFcjfUSmkBKRa+8Uq47O3bIvJQU+fLZ6lUTrupvn21Q59I5ILDyoOMaXl3Nqg9SeX7XNVSvWGVfdPdue7O/Y1JdDQ88IP9/o/I2/qweBdQiNPXsKTbLCinBdXc0VVe7RVSVlkJGBoXnX0OpNZDuXnn29qjh4U4ZTbm5LncNsrJE0/LodDOUypwcKC1lKEnsK5XWgCo0tXxUaFIURVEURakjxo9xozrLWWg6cMDprq2Xl4zmDaHpjz9kaqgMnjBG/23ayGhh0CCH0FRR4Qj2eest+vaVQUB6eqO9tabHuHvuwdFUa9mcM3/5C4waJeUbI0ZAYiIxqQuIj5dufPZBUVqaOA4iI0k/2JmYGLj1VtGqXn21Ed9PPTCEpp495WP2968pNB065HBDuFBeLqPXLl1cqlKmTpX/d+hokg23b09wMLz6ujdrrUN46+MgOeY33GDflBEE3mChCeRgFhbCvHkus3v1ks/SFptjHxzXu8OecvJhtcoHastnAkdGE4i2cFIITVaruIK+/NIhNI0QQbbeQhOIqO3lBX//uzzevNmlFWjHjvI3wFnArlfp3JFCh9C0ejXv75vMwzzPP+63NTNIk4DzceMcGYBH47PP5E/G07fsohov7ph3NnCU0rnqahGbkGtSQIDD0fTEE7Ke/V5HSgpYrWSHi1s3okuF/ctdw9FknBjIJajW/D0nRxMHDzKMpBpPKS0XFZoURVEURVHqiBGYumWLTLt0kd/UhqPJJWB53DgRmq65Br7/Hvr2PXptyZAhYoe65RYZsRmB4pWVohAcOiS/2D//HHO4jGaMQbzVCm+8UWtH7pODrCyxLbmNIDyG1XrCZIJffpFj+d13sq01a7jlFtHgvv4aGSXt3QuxsRSHx5BXGUZsrHwuF18MP/xQ990tLITzz2+c3CHDzNWjhwzohg+vKTRNnQqTJnlY2egbb3M0hYZKKcoFF8jpNXKk6+JXXAETxpXzCM+S2zZG3jhiQFq4UAaFhhOlQZx+unxgH33kMrt3b6n4MUQ1w8lkPFZaMBkZoqSPGEFampzDPXq4Opr27m3G0rngYFFy3E+uRYvg+efFiTR9OgD9hwcQFiZGpHoTESHbmT9fhNVt28Sm50RCgmdH01GFppAQCAwksPwA5eW2auCvv+aAqRMAL68eywMPiKmqrAyOHIH//e/ou1pWJhrb4MHw8BnLuZ23SM+R8rVaHU1QI6fJcDT9+KMc3tNOg7lzsX+hd7eLl0PTx99ev921qwiNVVXU6mjySLt2cjHLzYWDBxmKo22lOppaPio0KYqiKIqi1BHjrriRj2Q4mowwcJcciocegscegzlzRAlxLpvzRFiYlIT9+9/yePBgGT1s2SLBGwCzZkF5OTErZmMyOfZj0ybpPv/yy431TpuAzEwZuHl722dVVUlpSJ0cTSC5H5MmiQIUGwspKdx5p5i/7rkHCtfaarfMZtIDBgAQEyElXomJ8jnVpX03iAnthx88dLWrA9u2yVjS6Ay4c6ecG0FSFcKIEdL97cgReVxdDUuWiPhUoxrIqW98To6rTjdkSM2SFJMJZsxqw2GfIEa3WcuVNwRy882y3nff2XWnhuPlJZlPCxfa3RAgQpPx3sFRpqdCUyvAsKfZHE19+shp0LmzTLdtk8qqZnM0gShd7l+W11+X6+gzz8j3xtubNp3bkZkJN93UwNe57z6xb91wgyj6To4mkIepqY7ouDplNJlM0L07gaX7ACgtscLcuRR06MWIHjlcwRf85z9yffjjD2kYOWuWWymbG69f8As7d8JLz1fgtTOTR3iWoCCrJ21fMNQfp5ym9u0dGYSbNsG118LAgXDppbDo+3IIDGR3paiLEQmhIkBWVhIeLtfy/fusLo6m4mL5u1jrjQSTyWEJLioigt10CS2nTRvHTR2l5aJCk6IoiqIoSh1xL53r0kV+Jx86JL/XXYQmf3948kkZcV93nfSCPxZGXRU4AsXXrROhKSEBzj4bRo0i8P036NnTaheafvtNpj/+eJxvsCnxcGs7J0cGKHVyNLmTkACbN+PjA+++K+HaDz0n+TGYzaQTA0BMUI59cXB1HxyNTZtk6hyTVVcWLZIB59y58njnTlcxbdgwGUQar5GR4XASuORNgSM13FY6V5eSkpgY+ORzH+KHB7N2LXz6KZxzDvz+O8yYUf/3U4Np02Rk7WSz6NVLptu3y/fBEJxUaGoFbNgg16X4eNLT5fwC0YzDwhyi4gkVmrZvFyX11lvhkUdEybU5HwMDRRBrEP7+ImAZViU3oSkhQUQ2Q68xFrNlYddOt24EHhIRuXRNKmzfTkFQDzpGBTObaTw5ZQ2//y4vd9NNUp5nCNfu7E3dy3O/jWAy33Dm9vcgM5POHav5179MXHmli7bvIDLSoRLaCA0VId5ikUjBc86Rvy0BAfBtUjj078/uHC9MJug6KFwuYpmZdmdbblqxlPraLlKffy7z+/c/+nEwSudMwMh+h2rPdFJaFCo0KYqiKIqi1BFnR1NIiPwANwb++/a5lc4Z9O0rocz1DcaJjRULzKpV4og64wyZf/vtkJaGudMBu+BlCE2pqSfxwN5DWIdRtVFnR5MzCQkyuCwtZcgQcTTN/N3MWu/hEB1NelkEAL3ZZl8cmkdoMgaECxfK1JPQBJCU5DoNDq4RfeTiaMrOrnt2yaWXSpVhRgaUlMig74wzGmkA16ePtM/76CO7zaJ7d/Dzk3Grcez8/Fwqc5SWypYtYDZThTfbtjmEJhDzilEmeUKFphkzRFExBP34eDj33MZ5rXPPlRaXwcEO654N9+tKerqIbx7FHWe6dydwv+x/6byfwcuLAtrTPrIt/pHhPGZ6xq5pXXWVVJi9957nTT01LYMSgvh3r3fg6afl84qO5q67jlJy5+cnwr9T0J/haFq/Xh4P+vlfBATAsGFWludGi9C0W5y8vv2k8x4Wi6OEcovNLtqtG/n5Eqd3+ulw3nlHOQ5OQhPAG4/tZc6cox86pWWgQpOiKIqiKEodMYSm3FxxM4HrwN9jC+eG4u0tNWGffioWEUNouvxyCA6mb/l6LBYpc1iyxFGZ99NPjbgPjcWRIzKYcHM0OYdk15t+/UTksNm6nnwS2ngdYXbwneDrS3pBJyLYRWB+JiBCT9u29ReaLBYpAakPhtC0bp1kd7kLTVFRcq4YyyUliWh5221iXnMp77MJTdWdOpObexJll0ybJgNaW+C9lxdER4vQZAgP48efxMKnUndSUyE+npwc+So7ay3h4Q4ttNkymkCEpr17xUFz6JCoMJde2nRfkE8+kS+sW3tMZ6GppERKbetUnjpxIoFF4rYsnT0HTjuNgoPetG9vktLghQvFVoREGV15pYR9HzrkuhnL6iJmrh3KLb1/I+69B+Q6u2TJUYKRnIiJESXahpHRtH49BHiVY/74EUhNZfSAQ6yv6k9Z30Hs3i0V0JhtQtPWrfbs77wM28517co//iH7+tZbxxC3nUrnACJiAtxjsJQWigpNiqIoiqIodcS5c5FxF9epwY5nR9PxMGSIoxbj9NNl2qYNnHsu5p2/UlIC334rN4PvuEMEm5OyfG7nThGFPHScg+NwNIG95VO7dnBO22XMLT9POvJlBxJDhl3pMJnE5ODcIao2jhwRgWnAANnt5OS679ahQzLonDhR1p0/Xz4f5/doMkkguLOjadAguOwyKSX8/nunDe7ZA4GB7D/cloqKk6gb0xVXSFnR7Nn2Wb17i8lswwZx/I0dK0JbSckJ3E/l+CgpETdifLw9GN8okwTX61+zO5pAQt7eeEOuk/fc03SvFxQk7lQ3QkJEeElJEZGppET6PxyT664j6L+Sx1daXEX1tddRVGTLJjr/fNnQ/Pn2xW+8Ua4t8+YhotcZZ8D77/PgtdkEUMYT73aXeRMmyAp1EZr69BFHk82VaJTOrV9vZYBpM95Uw6xZjO6UTiW+rPEb7RCaOnaETp3AYrHfdMnLEmFs8a7ezJ4N//gHxMUdYx+6dpXaQ8OddtRwK6UloUKToiiKoihKHWnb1lESYQhNTeZoAkdOU79+rnaBKVPoe1DsMG+9JbPOPFMqPBYudIRMnzSkpsrUbaDmHpJdL/r0kfIPw6JUXc0lZZ+wuzyMpCRISzcR2zbHxVLj3iGqNrZulWZ/118vj49ZPmckAduWra6GO++USpv335f57mLasGFyWAwHwfDhMHSonE9O40t733ijo+BJIzSFhspJ98cf9lm9e4ujacMGEekMp1qNgHOl5WCxiBBRi9Dk3MGw2R1NICVzjzwCF10Eo0Y14w44sMXF8cknsltjx9ZtvcD4KABKf1pK0cXXY7XahKbx48VtdPXVUn9WXs6oUXI9WbUKcW8tXcquGx9nflo898d+R+czbcL7s8+Kku1BFKtBTIwIdPsklNxeOrfWyqAqm81y9mxGli8GYPm+WHbvdjKNmc2wdStt28rfxtxsuQ6+8HE4ERHysRwT44JmtHINDq7DSkpLQIUmRVEURVGUOmIyOVxNxgArONghlDSZ0GSUzRlMmoTZS0oeFi4UHapLF8nCOHRIupc1iNRUsUg1gN9/d4heHrcLYilyIiurgWVzICUsZrNDOdqxg8kVc/Hxqua998RJExNWWENoys+3j6tqxSibmzBBbrgfVWjauFEWsiXfGuVwo0bJx7Z8uTz2JDQZedplZfLYy0uiYH76SeYBJ6/QBNLKLzVV6jcRAaK4WKrpnIUmLZ9rwTh9d7dtk3PU+Vw2HE2BgQ0UjBuKITS9+qootJ98csISpI3Ocz//LG6mugaPBwbKtLTKn4JC2ff27RGBZ80aSQF/4QWYMAEvL3E9rltrFbXprrtIelrqpCc9O8ax0WHDRLSZNu3YO9Cnj0xt5XOhoaIpFhV7MYj10jl1/37CZj1PjPd2flkWSFGRzdEEImbZggLDwyFvrxdlbcP4fakPl1zieH9Hxbigbd0qK7iVJiotFxWaFEVRFEVR6oEhNBnlAkaHZmiC0rm+feH++yUA3JkOHeh6Wh+CvSQTY/x47FNf3+Mon3vySZg69eh9tI+y6n332TUHF0o3ZjAt8CtSdrVzmZ+V1cCyOYN+/Ry1cF98QXsKGT+6nI8+klkxkYdrCE1wbFfTpk1yHM1m0fqOKjT9618iBt14I6SksHo1RIcVEzawG2f33W1fzJPQBPDmm66PL7oIe0kkIKVzto5zcJIJTQMGyAduy8kysnuOHJG26MZ7VqGpBZOaKoP/Pn3Yvl0+U19fx9OG4N6sZXMgaofJJOrmt9/WUdVoGhIS5Jyvqqpj2ZwNu9BU6shla9/e9mS7dvD22/D889IMIiODQYNgQ3I1VaXlMGYMa0oT8PWFAZPd1Hqz2fVDqg0j1d0WCO5cGj7ItEEu6FFRsG8fo8O3sXixPGcXmsxmufYVFIjQVODP4pALKS+HSZPqeBCMC1pampbNtTJUaFIURVEURakH7o4mcNzVb3RHk5cXvPRSDScQgOnCKfStFreBITQFB0so+HffNUgrkjCigwelfsITtWy0tBRWrJDsWsMN5Mxny3vycell3Huv66Z27jwORxPICC8rS2w0778PZ5zBJVMDjQxdYmJNUrdVVWVfHOomNPXtK2O1wYNFR/GYM5SZCV9+CddeKwf/0ktZ/WshI/Z+B7m5nF3wFSDbcT5fQITKyEgxH4SGOswFZ50lgs2rr9oWdHM0uW/nhDJggExt6d/OIdEDBsgY0stLhaYWzZYtIkj4+rJ9e42maydOaAoIgK+/Fitls7+4K8Z1ZcAA7J3i6sJRhSaDyy6T6S+/MGgQlJZ7k04MjB7NmjXQv79EpTWIqCj5gtocTcZre5uq6B97WOrhbrwRgNH9iu0Vwi6OJgCLha5dIe9QW37kPAICHJGCx8T441laKuKa0mpQoUlRFEVRFKUeeBKamszRdDSmTMGMBS9TNaeX/CC3kNes4eqrZWxY7+5zJSWOVteeetIXFMhI5Lvvajy1fLkjF8ooHbNTXc3bu87Dx6uKhQvht99k9p49UuZ3XI4mY4Q3c6aEA914IxddJEYHLy/o1T9Iwpby8gAZILVrd2yhafNmx4BxyJCjBIK/8gpWTCw4/WUOvvcVeWkH2VkUyvDBlTBiBHHrP6VrV6ny8VROY7iYhg51VP14e8O994pwt+LPaums1bkz2dmSgePnV//D1GTExsoO2YSm6GiZbTLJ8fP1le+Gi9Bka2N+wpg+3SXAXDkGto5zIEHvzvlM4NAJTojWc/HFx3kBaRwSEuTvwi231G89Q2gqKTmK0NS7t3yxfv6ZwYNl1roOE7BG9GDNGrl2NBg/PxGb3BxNcd7ptBliu7b+9a8QHs7oSxx/8FwcTQBbt4qj6XB7fiwazZlnSs+KOhEc7MhlUqGpVaFCk6IoiqIoSj3wJDRFRsoN9mb9ndy7N/f1+oaZpjsIveZ8qZebN49p02Ts8Pjj9XQ1bd7sWMGT0JSSIsGxHuryfv9dBJLQ0JpC0/ofckmqHspzl6whIgIeflhuXl9+uVTkuMdP1QtDDXr2WTn4l1xCly7i6oqOBv/ethGRU+e5YwWCFxXJ4v37y2MjJqtG+dz+/TBrFkvOeoqLburE2IdOY+40SfEe/uo1MGkSpnVruf+2Eq69Fjm2P/xgd1eBQ2gypgbXXy/H8uUXKkQos5XOnVRlcyBKUny8XWgKCJB97NPHkdcTGel0Ov30E4SGUvTsG3z4Iaxc2cz7W10Nr7wieT7KsTl8WNwu8fEUF4vm6S40GdfBZg0CP8kICpLmd3fcUb/16uRoMpngnHPgt9/o27sCf8pZHzaBHTtkneMSmsDRec7ptRMrkyR/DeQLnZtL/E2j7X/f7GHg0dFyDbBYCO9ipai6HRmHwuteNmdgqJVaOteqUKFJURRFURSlHrhnNAE88AD8+mvzZ9EOvu90bo5dArNmyYDBYsHXFx59FJKSRNeoMxs2OP6fmVnzeVt5RU3LkriUhg+H0aPldZ15e0YlbSjjphtF/Fq1SgZHf/4p433jLn2DiI6WW+dFRdKhyTZye/99+OILHHU+TunohtBUXg633opLOR84Ip8MoalbN/msawhNM2dCaSmr468H5JDd+dFwvL1h8FAvOPtssFq5P/5HnngCCQs//3yYM8e+idGDy2Ua71qq2LYt3HYbzP3Ojx1E2Uvn7AO8k4mBA+1CE0jG1OWXO56OjHQ4mgrf/Yqrrf+jy6M3ccMNEl7frGV1O3aIfUTb4NWNYS/9FgAAIABJREFUtDQR52rpOAdyrvbu7fi+nKoEBdX/+l8noQlg4kQ4dAjfBXPozybWWxPt19njFppiYuTabrXSqZPMGsw6SR53wssLRo6ETp2c3Eq+vvLhr1tH+B6H5fO88+q5D4aCro6mVoUKTYqiKIqiKPWgfXsZUDiXioSFwZgxta/TZNx1l9TJ3XgjxMXJwBBpOBQdDU88UQ9X04YN8kM/MNCzo8koq9uwAXsIEhKPlJQkne6HDxcRp7jY8dwnv3XlSr6g/YhYrr9exjVbtsA778AVVzT4nQve3vK+wZ4lAjL2GTIEKe0YP146Nx2S4PSEBOk6d9ppsg+zZmHPHgFHxpQxcDaZZFtr1ri99jffwJgxJO3uSq9eomVFRIjYFhCAHIzgYFEgrVZx0oCjdhAYu3ceyxnF+R9e7roTyEfrZbLyIv+wC00nnaMJJJgmJ8feym/GDDGYGURGiq5TXVLGG9/25DOu5qY+S5jPhVSVH+Gaa1xMXk2L8eHu3n305RTB6DgXF2cXmtwzmkAyzNwFW+XY+PrKJcwQmnx9a8k0Hz9eFnzqKQaxnnV53UhKkmwmo3q4wfTpI0L9vn306AFfTV3ALbxTQ2gCeOYZR/MCO337wi+/0PW/DwMQG1FaQ4w8JsaFTR1NrQoVmhRFURRFUerBrbdKxEtdmvo0K2aziEHV1XZX05o10nKb996Dyy6jslI6ZqeleUiP3bDB0ZP+aEJTRYWL++mPP0QoGD9eSsCsVli3Tp777DM4dMSPWzt+De3b4+MD8+dLzNNNNzXS+54wAcaNc9S4ufPss1Lz89prgGNgtmkTXHKJGFy2bXMsvmmT6G3O0S/Dh4s4Zo8XMo7ByJH2nJT+/UXns3eL8/ER9W3hQqkRS0oSK4DRugkw/foLo7yTMC1aKN3rnOjeHW4ev523uIOZS/qyZ89JLDSBi6vJmchIOVy5ny3mg4prGJ+4nze2nMWF8Rm82ecVli2Dt9/u1Dz7aghNxcUnPiuqJZCaKlaW2NhaHU0gp3pzuzlbAyaTOKEMocm4iVGDkBCxE23dymDfzRQc9GHePDETHndmm9F5zuZYvazqC4J6dPTY2WLYMFe3IiDtRl96ifCZTwJw3qUN6P6njqZWiQpNiqIoiqIo9aBPH5g69UTvhQdiY6UezFaLNHWq3PFetAhx38ydy8akw7z3Hrz7rtsgorpahIKBA2sXmjIyHJlITuVzv/0mg53Rox1ZQ6tXi7jw4ouQGGhh5MAy+/Lx8VJB1mj8+98i3tQ20h05EiZPlp0pKGDMGBG5Fi2Chx6SRZyrBteuFe3EeXPDh4uAZi+f27IFDh9mb59RZGY63ndAgNtN+QkTJEH573+XmssHHxQ1KidHNvjrr6J2/eUvElL9xx8uu/7qpF84jx+4/enuVFe3TKHJ6Cr4yRsFbKc3f70vVJSJHj2YGjiXa66BN9/s5PGUa3Sc91HL547Nli2iLAUEsH27nMIeS7uUBhMY6Co01crEiQAMSpCuC9u3N0LZHDjaXRo3Etav9+hmqpUBA+D+++k7bThTpsDNNzdgH1RoapWo0KQoiqIoitIaMDoA2crn/PxEF0pORgYRVivJi/YDsGhRsL28DZCAoeJih9DkntFktco2zjxT0n/dhCajXCwsTEr2kpLgo49Em3qqejqmfsdb33EMjmWneOYZKQ954QUCA+Hdd6XUMSFBKlIMoam8XNxYo0a5rj58uExXrbLNsFm21nrLE7UO+M4+W6YrV8oI7IIL5PGSJTKIz86WAeTMmTKgnzwZfvnFvrrfgTzmcDljRkv940kpNHXuLCFWR3E0Aby4YSIhfqVccrm3zAgNhcJCbr0VqqtNWCzNsK+bNjlqXrV87tgco+OccvzUWWg65xwA+p/V2d7BslGEpuhoca2lp8t3wmKpn9BkIyAAFixoYCmfls61SlRoUhRFURRFaQ3ExsrUacSemAjJyVasGVIblrxKspXKy72YN89pXUNpMYSm/fulpswgP18yjmJiRHWxJdEWFIiQdeaZjkWHDYPly6WiYuSgw1xQ/pV9sHrCGDAArr1WsprmzrXPDggQfS7ZlmO7bp04sUaZXNuhdewoN/7t+tratdC2LUm53TGZjhJobjZLcJO3t4QuJSbKXfvFix2C0oQJMu/XX0WVOe88ePVVycHKzycwLIjvvjfx/PNSnnhSMmDAMYWmfXTiLxP3S34V2IUmo+FUbm4T72NZmQymjaRiFZqOjiEu264r27ap0NQUGELTgQPQocNRFhw2DJ56isC7/mqPpWsUocnPT9qULlwodwyCguDSSxthw/VAHU2tEhWaFEVRFEVRWgNdusgPdZujCUTX2LfPRE6FZOCsT/Fj9Gjo3v0I//uf07obNshd7X79ZNABruVzRllFnz4y4Nm6FYqKWL9exqPODqDhw8Wos3s3PHflBkxw4oUmgLfeghEjpEzt99/tswcOdOhsKxaLEDfqv1c72kDZGD7czdGUmMiatV6YzUcZH5lMUp/3+OOiuHh7S57U4sUiLMXGOmrLoqIkUfyCC+C++2Sjn3wCXbrYq+6CghrtaDQuAwZICvzhw1IW6BQWHxICwT5SOnnDQ11xeaKoqPmEptRUKRE95xz5XI5SOme1Srb8zJlNvE8nM/v2wZEjEBFBVZWYHD0FgSvHR2CgaPrHdDR5eUl5bVQUQ4bIeobgdNz06SOuy8pKKd9t7haCffuKynbcyebKyYQKTYqiKIqiKK0Bk0mECzdHE0AyiVRjYsPuDgweDJMnH2TRItEEAFFaYmJk9GIIH85Cky0o1u5oAlizxu4EMl4HHE+ffTac6btMHpwMQlNQkKSQx8TAlCnw/POwcyeJiaI5HDgAKz7ZRjTbCS/bAe+/77L6iBFyvLJ3VokFasgQkpIc+Uy1cscdMkA0OOMMEQMXLhQ3kzPBwTBvnvz7299k43/5S6O8/SZl4ECpOwwIkBRzpxAzE1ai2U5CyG6GjfJxrBMaCocPE+RdTlBQVdMLTUYQ+ODBIsoexdH07bfy8b/zThPv08lMdrZMu3cnO1ucfupoanzqXDrnxNNPww8/SNRZozBlirThXLnS9WLeXISFiYt29Ojmf22lyVChSVEURVEUpbVgNrsITUZOczKJ7AgbQXFFAImJMGVKEdXV0hUOEKFp4ED5vyE02XKaCgogY9V+ceP07Omo10hKYv160RXCwhy7MHw43HADvPaqVUZDXbp47GB0QujQQdrwDRkCDz8MUVEMXPAUABsWF7BiSyijeuyWQdeMGdJOz4Y9p2leDpSWkhM9htzcBpSvnHGGTI8csQf8uuDlBRddJGV+v/0m+3myM3my9Ld/9FF5f7/+Ku4hgB07+KDyWr6690/XKK3QUJkWFhIWVtk8QlObNuLeiIhwFZpee00C8xFB5f/+T2Zv2HAKN6dzEpqO1nFOOT4CA6Uquaio7kJTZCScfnoj7sSdd8LSpa6tNhXlOFGhSVEURVEUpbVgNkvXuTIpVWrXDnqH7CPZawjr+1wGyA3rqKgjDB8On3xiFdvGjh0OoalrV/D1hawsysvFmTTmgxupiuot8zt0kMH6d9+R/Gs+iSTD5s32XfD3FzdI/M+vSGu3Rx9t9sNwVLp3l9K1bdvg0UcZmDQLgG//7w9yrN0YdV0s3HOPHJPvv7evlpgob3/1wiIAkkzHCAKvDSOnydvbITq1dEJD4ZVX4Kmn4K9/lVFzSoo8t3w5g1lP3CVxNdeB5hOaNm50pL/36OEonauqEjHvtdcAmDVLtNp77hGtbMWKJt6vkxUVmpqFwEApG7VataOf0rpQoUlRFEVRFKW1YASCG5lKQGKAhfU+Q0k2DcaHChJiKwC4aFQe69eb2H/rQ+LgufFGWcHLS+5sZ2Vx//0SR5R/OJTkLuc4Xmf0aMr+XMuWPR0YlPuDhMc6t7FbvRr++U+4+GK5W34y0qsXPPUU4cvm0MUrnw+3jQVg1EXh4iiKiIDXX7cv3qaNaESrkttAQABr9vTA27sBlSbe3nDhhRJK3RrDb8fKcWSZrWxyxQopCXTPXzE6TBUVNZ+jyciecXY0WSxSu5SaSnExPPGExGg9+6x8VH/80cT7dbKSnS3luF272ktsu3c/sbvUGgkMhD175P8qNCmtCRWaFEVRFEVRWgtms0ydc5oqk9h2JJKl++KIYwtt8ncCMHatiCjL//kNLFkiJW4GPXvy5drevPkmXHedFYBfrWc7nn/pJVLeXEoVPiQ+fqFkON1xh9yWX7kSrrhCRqXvvYdrvdRJyPDhDBwXSgEdCAiwSrmhj4+8n0WLpL7QajUWZU1uN2Z3e5D/zvCyh/LWm9mz7aVarY6oKOkiZQhNy5dLwJW3t+tyHhxNtsPc+OTny2jeWWg6eFD+rV0r8/LyePX5UvLz4aWXoG1b6fJuvI1Tjpwc6NwZfH0pLJT4LX//E71TrY+gIMd5r0KT0ppoVqHJbDa3MZvNq81m8waz2ZxiNpuf9LDMOLPZvM5sNleazebL3J6rMpvNybZ/rfSvs6IoiqIoSgOJiZGp0XmuspLEgsUA/JEWLmVuGRlQWcmwDbPw86pgmXVMDTFoX5cEbsr4JyNHwrvP5DOADSzcP8ixQFgYyb6Sgp14TYJ0Vfvf/6QUbNQo6Tr21VctZuQ0cJgfAMOGmfD1tc287TYJubr6anlfP/3EiJgDHKoK5Lptj9Gvn1PGVUM42QW4hmIyiatp2TIJn9m40bUtoYGT0NSpUyWlpa6muEbFCAI3Qst69JDp7t2wZo3sBiG8/F8/LrrIEfB+2mnSadCpid6pQ3a23cJUn6BqpX44C9V6jJXWRHM7mg4D4y0Wy0AgETjXbDaPdFtmJ3A98KmH9cssFkui7d+Upt1VRVEURVGUFkZQkLg1DEfTzp0kVq2xPz2I9bBtG21SUmhTvJehfYo8Ojbe3zuZYmsw7844gm9mOmezkGU7uhnRTwCsXy+VX9HRwCOPwFlnScncI49I6d4x27GdPBjlby56SPv24nZ56y1ITYXzzuOse/sRTwrPX5LEkiWaWVMrY8dKVtjXX0vQkaduUm6lc0DTlc/99JMEbBmBWhERMt29Wz7jHj14nXsoPOTDY4+5vo3ycikfPeVQoalZUKFJaa00q9BksVisFovlkO2hr+2f1W2ZTIvFshGobs59UxRFURRFaRXExjocTRkZdCebjiGSy5TovxUyMgiyJRyPPSeQpCRcBKTqapi5YSSns5h+7XZCRgZns5DDFd4uolRysuSHe3khZVHffy+D02eekbqjFsTo0ZLBNGmS2xM+PuJs2r4dFi2i25vTSZn+BQ++H1ujEkxxwshpevFFmY4YUXMZt9I5aCKhqboaPv8czj3X8ZqGoykzE9avp/C8v/Ayf+ei3hsZ5GTcM97GKZnT5CY0GYdOaVxUaFJaK82e0WQ2m73NZnMykA/8arFYVtVj9TZms3mN2WxeaTabL2qiXVQURVEURWm5JCRIudLevZCejgkYNEDu3w3sVSxC08qVkJjI2AmBVFTYq4cA+Pln2LE3mNt5C778Er76inFef+Lra2XhQlmmulpav7sEYfv7S0e6FkhUlJRtjRtXywLBwTB+PNx+u3RWM9w4imf695djlpIC8fGeR9CBgSLkNbXQtHy5OJeuusoxr1s3mS5cCKWlvLb3aooI5bGwmS6rdu4suu0pl9NUXg7799uFpsJCFUGaChWalNaKT3O/oMViqQISzWZzKDDPbDb3s1gsm4+1no2eFosl22w29wJ+M5vNmywWy7baFq6urmbLli2NsdvKcVBeXq6fg3LC0PNPORnQ81BpTvwmTqTXjBkceOABTFYroQEBjD7jAEdMwfj4BXBk3ToC8vPZP3UqnTqlAbHMnZtPp077AXjxxQg6tffj4oJ58MiXAFRNmEBiYSnffuvN9dfvIDPTj5KS3nTpksOWLUUn8N0qJys9Bgyg7Z9/UhgXR24t17+Y4GCKd+yg3TklACQn7yEx8UCj7keXt94itE0b0mJjsTrtR0zHjpi+/54cInjxpwTOD19Jvx1z2bLlbpf1+/fvyq+/BpOSkibuvVMA31276APkmEwUbdlCfn5vIiNL2bKlqVsDnnia++91UVEo0BUfHytZWVtbbXSbUj9aw+/GZheaDCwWS6HZbP4dOBeok9BksViybdPtZrN5MTAIqFVo8vLyIi4urhH2VjketmzZop+DcsLQ8085GdDzUGlW4uLgr3+l4+zZ0LcvxMby5FNd5bn/G4RhS+p4xRWMGhVLfDykpXUmLq4zWVmweDE8/DD4jfhaMp+GDKFdSAhTnoHp0yEsLM6erTxpUjfi4rqdmPepnNycey78+Seh551HaG3Xvw4daO/lRViYL/7+UF3dhbi4Lp6XbQiVlXK+T55MXyOfySA6Gtas4R7vz6nGm/9OS8b3hT3Edevm4li76PwKvv7aG4sljksuabxdO6nZtw+AbsOG0S0ujkOHICrKj7i41l8/19x/r3v3lmmHDibi4/V3giK0lN+Na42unR5o7q5zYTYnE2azOQCYAGyt47rtzWazv+3/nYAxQGpT7auiKIqiKEqL5YknJDxp40ZHJzqAPn0AsPr4SEstJIfmzz8lh+Xee6Vp2C23AJMnS7mYbdA9YYJsYuBAuO8+yVZOSGjG96S0LC68UEbREyfWvkxoKBQWYjJB166eS+dWrICtdRoteGDxYsjPZ3niHbRvD35+8rU46yxIDx3GfC5kftVknnjCRPRYKRPDzUVw5d43SGQ9d95ayYHGNVudvGRny7R7d6qq4OBBzWhqKozSOS2bU1obze1o6gp8ZDabvRGR60uLxfKd2Wx+ClhjsVi+MZvNw4B5QHtgstlsftJisSQAccDbZrO52rbuvywWiwpNiqIoiqIo7nTvDvfcAy+84Co02W6flw4aRFBQECBC0zvvgNkssSzPPQeRkTU3OWyY5HxbLJCfL/lMfn7N8WaUFkn//pCRcfRlbEITeBaali6Fs8+Wfz/8UMfX3b0bXn9dFNPlyyE4mNnbx1JRAQ88ABUV8O67MODQqwRxkP6dcrjvvm6wM17WT02FkY6m2L5ff877zGbYgbX8/e/w4Yd13I+WjJPQVGSrjFUhpGlQoUlprTSr0GTrJjfIw/zHnP6fBER4WGY50L9Jd1BRFEVRFKW18OCD0i7L2VESGwtAyahRBNlmjRsnLo+QEPjmG5cxtgteXvDII027y8opRmgo5OUBIjQ5m4nS0+Hii0UYsljquL2cHDjzTOkm5+0Nhw9TfcddLJjrw6RJIqKCOPLunJjJDyk9eefO3/H17SaJ8G3aiNBkkJUFq1czCHhwzDKe/WgcV10lVYGtmuxsUUBCQijYLrNUCGkabHq/Hl+l1XGKRNopiqIoiqKcYrRvL46OM85wzOvRA77/ngPXXmuf1bOndJBLTq5dZFKUJiEkxKOjqbAQzj9fxM2rrxbd6MgRD+sfOQJz5sh5np4u1qe8PBFYy8vh8GFWT32dvDy4yKlfdbduMPdf6RR4hzFymoiveHtLppmz0DRnjn0/p3d5h4gIcf+1erKzxRVpMlFQILNUCGka1NGktFZUaFIURVEURTmVmDQJq3Eb3Ua/fo4764rSbLiVzhUWQlkZzJolutHcuXDOOVBdDTt2eFj/88/h8sthzBhx62VmwnffORRTPz8WfGPCxwcmTXJd1XT+JAJ3WaBXL8fMhARISXE8/vJLGDwYxo7F37KR4cNddShASlQ/+IB9+2DmTLBaj/egnAQYQhP2j0czmpoIFZqU1ooKTYqiKIqiKIqiND+hoVBSAhUVdLU1RszLg08/heHDJa/eiBhLT/ew/ooV0K6diEuvvCJOptNPd1lk/nwx9dUQSowEcmfi42HnTrFW2crmuPxymW+xEGeuJiPDyV1VVSUWp/nzueMOuP324wguP5lwEprU0dS0qNCktFZUaFIURVEURVEUpfmxdTT0Limxaz6//w7r10vJHNhjxTwLTatXS0r9+edLy8QhQ1yetlhE+Lnwwjruz8SJ0k4xMVGSw0GEprg4OHKEuI75VFU57UtmJhw+zMKtEXz1lczatauOr3WyYrVK1pUKTc1Cu3ZStdmt24neE0VpXFRoUhRFURRFURSl+bHZjLwOHrQLTa+8ItlMV1whjzt2FJEjLc2x2tKlsCmpHDZuFOtTLSxYINM6C01Dh8LatSKyzJkDgwZJp8Z46UgXZxK7kj20fOtWjuDL3dvvpWNHmdXihaZ9+8Sy5VY6p0JT0xASAitXwvXXn+g9UZTGRYUmRVEURVEURVGaH5vQ5F1cbBeaNm+G8eNdq9piYhwuIqsVrrwSHvl7KVRW1io0HTgAH3wgEUs9etRjn/r3h1Wr4PXX4bXXZF7fvjI5tAaTyUlo2rKF/3I3WytjePftKkymViA0ZWfL1MnR5OPjKPFSGp+hQyEg4ETvhaI0Lj4negcURVEURVEURTkFMRxNxcWEhUkJUVWVo2zOICZG4pdABKe8PMj1rZAZI0YA8OijEq/0j3/IZs85B7Zvh3nzGrBfvr5w992OxyEh0L07gRkb6dnTEQhevcXCCzzDOfzExWMSCQ8PdxWarFZRvAy7Ux1IT4ewsBMQvr1kiXTqKyqSx05CU/v2EmmlKIpSV9TRpCiKoiiKoihK82NkNBUX4+UFXUIP4+9XzSWXuC4WEyNOofJyKZsDyNvvAxERduvT++/Dxx/DgAHSRTE7G37+uWa3uQYTFwdbthgTADaurSCfLlzNp5CbS48ebo6mOXMkfMdjyzxXSkqkgV1srIhmzUpVlRyoc88VuxjUEJoURVHqgzqaFEVRFEVRFEVpfpwymgCGlC6lU+hhQkIucFksJkbMQdu2OYSmPaXBVJ8zAi9EJ9mzB+68E7p0EYHpjTck07vRiI+H994jfpyV3383UVVp5de0ngCczULIuZIePQaRkuK0zuLFknc0dy7cf7/HzRYVwVdfwfPPiwMrKEhCzJuVnTuhtBTuugvathXVyymjSYUmRVHqizqaFEVRFEVRFEVpfpwymigoYEHZRGYVXg6HD7ssFhMj0/R0EZpMJisV+FHQ7zQA8vOhulq0oOnTYdmyRhaZQBxNJSXEdTlAeTlkrjvAwrLRxHfMoxu5kJNjdzRZrbZ11q6VaS31e48+CuHhcPPNktGzZAmcd94JyHkyktYvv1wUr9dfl0R2xNHU7GV8iqK0eFRoUhRFURRFURSl+QkOBpMJr+Ji2LgRE+B1pBzWr3dZzBCaFi6ErCwYE18AQF70KAByc+X5Jm0Rb3Se85FU8vU/7WEp45gwphRjJ3r0EDNQYSESVL5hA6UBHWH5crFcObFnDzz3nASfr1oFmzbBuHHUFKuaA8NCZTbXeEpL5xRFaQgqNCmKoiiKoiiK0vx4eUG7duJoSk52zF+xwmWx0FDo1Ak++UQeXxG5CoA9Yf0AyMmR+c6d6hqduDiZlK0DYNYXwZQTwISL2srO2RxNYHMkpaayoHwi7cr3MNN6C3zzjcvmvv9exKRnn4XhA8ox/SE1gZGRUsV24EATvhd30tKgXTvo3LnGU1o6pyhKQ1ChSVEURVEURVGUE0NoqDiaNmyQgKWePcUB5EZMjIgeoaFwdskCAPIOBgLN5GgKC4NOnWif+ifh4fBzag98qGDcJZ3khW2OJrAJTWvXspCzqbJ6czszefhf7VxcSt98I+6lgQOBDz6A00+HXbtct/H/7d17eNXVne/xdxLCRbkpIAFMgBRZAgpINIpiKxZv1WoVHceZto7n1Fud09pT54ydsVXpZeqpc1qrnUdttdbL1PHxOupYRdG2Tgti8NIKXVSEIHIRC1QoIJLs88fam4SAksSdvZPwfj1P/O29fr/9y9qyn/2s55PvWqtQYkzVTC22lstkrGiS1D4GTZIkSZKKY+DApoqmSZNg6tRdKpqgafrcsUdtY/i8tObR6tWpLVfRNHRoB/f13HPhvvsYN3oLAFP7/o5+A0pTKVXLiqa6OupKa5k6NcOFh87lX944l3++Iq09tXkzPPUUnH56Ntt55ZX0wiVLqKpKD5cv7+D30tzixbudNrdpU1po3TWaJLWVQZMkSZKk4hg4kLL16+G119IK3kcfDW+9tUtJTy5o+nj5XPq/9za9ezXuCJpWrUoFRz17dnBfv/Y1KCtj3IYUhJ0weklqHz4cVq6kogJ69Ehdb6h7mZeZRG1tCbf8WwPncwffu6GcxYvhmWdgyxY444zsfXNb1dXXF76iafPmlGqNHbvLqfVpKSwrmiS1mUGTJEmSpOIYMIDeCxfCtm1NFU2wy/S5iRPT8fhXvk/J1KlUDCvdKWjq0PWZckaMgEsuYcIfHgRgxlGbUvvw4bBmDWU0MHw4vFnfSHxpM1sae1NTAyVHT+W64T+kT8MmrjjxVf7z7nfp3z/NliOT2SloOuCAFJgVrKLp9dfTcTcVTRs2pKNBk6S2MmiSJEmSVBwDB1L6XppSxqRJ6adPn12mz3360/DqrXOZsvxhuPRSKip2njpXkKAJ4Mor+Xyv/+AuPstRJ/RLbcOGpTlma9emXeMWb2bBe2mXuilTgNJShj7/AFfVzubR+oncfV85p0zfmiqw1qxpKh2qr6e0FA48sIAVTbkd56xokpRHBk2SJEmSiiO3AFCvXqmqprwcjjhil4qmkhI49MnrYdAgOOcchg5lp4qmDl0IvLmKCvp+8fN8lnsomZDCpB2/PLsg+Jv1jdRRQ5/ejU2FQqNH8+VfzaR6+Ba20ofTR2Z32Vu4MB3LyqC+Hkg7zxWsoikXNGXnJj78MEyYkGbU5YIm12iS1FYGTZIkSZKKY8CAdDzkkLTAEaTpcy+9BI8/nhbK/u//hltvTSnIBRdA7947KpoaGtKxYBVNAN/8JjzyCIzPBk25X55dEHzFn/pQV1rL5MklO94SpCzt324t57C18jWsAAAVLklEQVSSlzl128OpMTdt7phjdgRNlZUFrGhavDiVUO27LwA335yyr1//2qlzktrPoEmSJElSceTKZSZPbmo74QTYvh1OOy21T5sGF18MgwfDZZcBUFEB77zTFDYVrKIJYJ990pZxOblfng2a3msoZ26mlik1Jbu89KRTe7DgE19hwPynU8Nrr6Uk58gjUxlTYyOVlWk99IaGjun+6tVpMXIgVTRly67Wr08LlQM8/bRT5yS1n0GTJEmSpOLIBU2TJjW1ffKTsGJFqmS6775U2bRkSUpfRo0CUtCUyaSCJyhwRVNLFRXpuGoVlf1SGdD7mfK0PtPuHHMMvPwybNqUyocmTICRI9OC6GvWUFWVQqZVqzqmu7W1cO21pP+BixfvWJ/p0UdTvjd0aAqc1q9PUxb79++Yfkjqvnrs+RJJkiRJ6gCDB6fjYYft3D5iRPr5ALls56WX0rGgFU0t9eyZ3sfKlVT++b+AvwGgpuYDrp82LSVJ8+aliqazz05BE0B9PZWVKTV78800qy2ftm5N912wAFi7Ns2Py1Y03X9/mrZ34YXwjW/AwQenmY2lliZIaiO/NiRJkiQVxymnsOKHP0xVPm2QC5oWLEjHolY0QUq6Vq2i8qnbgJQ95ZZw2sXUqalU6MEHYd26poomgPp6qqrSw45YEDy3gPrixbn/ACGwcSM89RScdRbMmJGaH3vMaXOS2segSZIkSVJxlJezccaMFLy0QcuKptzzohk2DJ5/niG/n0OvHtuZODFtoLdbAwbAoYfC3Xen5y2CpsrK9LDlguCzZ8OYMTB3bvu7mQuali+HLb97PT0ZO5bHH4f33oOZM9Omf/36wcaNBk2S2segSZIkSVKXMnRoOi5dCoMGpR3dimr4cFi3jpLyco49ppFTT93D9cccA+++mx6PH58WQho4EJYtY8CA9LRlRdOdd6alqk44AZ5/vn3dzAVNmQy8XvfntNPfyJE88ED6f3r00anpuOPSdbkltCSpLQyaJEmSJHUpffo0LVJd1PWZcnJz9049ldnP9eSaa/Zw/bRp6bjffk3lWCNHQn09kNZKal7RlMmkneBmzEhLV510Uqpwaqtc0AQQFzXCyJFsz5TxxBNwxhlQVpbO5abPWdEkqT0MmiRJkiR1Obl8pujrM0FT2nX++a27Prcm1fjxTdMGmwVNVVU7VzS99loKic47D557Dqqr4eST4bvfTSFUa61a1fTrFi/vBdXVLFwIf/kLHHts03UGTZI+CoMmSZIkSV1OpwqaZs6EWbPY85y5rKqqtDZT80XQR41KQVMms0tFU656acaM9L5/+9u0Wd3Xvgbnntv6sGn1ahgyJOVii9fuD9XVzJuXzh15ZNN148al4Omoo1p3X0lqrkexOyBJkiRJbZULmjrF1LmKCvj611t/fUkJvPhiWhApZ+RI2LQJ1q+nqmp/1q6FzZthn33StLmxY6GqMgOU0Lcv3Htvyquuvx6+8520UPierF6dujpowHbiypE7gqb99tv59SUl8Ktftf7tSFJzVjRJkiRJ6nI6VUVTe/TuvWvQBFBfv6O66MYbYds2+OUv4YQxS9ObXbYMSGHQpz+drlu6tHW/Mhc0jR26gcWMhepqXngBamvbvPGfJH0ggyZJkiRJXU6nqmjKh2ZB04wZcOaZcM01cPfdaQ2lGdufgDVr4PLLd7ykujod33ijdb9i9eqUVYV+K1nHIJb1Crz22s7T5iTpozJokiRJktTlDB2ajl22oqmlZkETpGqmnj3hkkugtBSmv3UP9OoFjzwCjz8OpJCtZ8/WBU2ZTLOKptIlAPx8/hgaGw2aJOWXQZMkSZKkLufEE+Gzn4XJk4vdkzwZPBj69IE//hGAESPSrnLvvw+1NQ0MWDQXvvKVtFL3l74EW7ZQWgqjR7cuaFq/Pk3Dq6iAsVtfBeCu+/sAcMQRHfauJO2FDJokSZIkdTkHHgh33ZUWy+4WSkrgU5+C22+HJani6OKL4YIL4EsnRWhsTFvB3XRTSpZuvBFI0+eaB02bN8MTT8A77+x8+9Wr07GiAka/M58ebGfRovT6IUMK8QYl7S0MmiRJkiSpM7jhBigvh4sugkyG0tKUO53X99F0vrYWjj8eDjssbUXHrkHTzTenvOqAA+Dww2HOnNTePGjqsex1PtZvDeC0OUn5Z9AkSZIkSZ3BiBFw3XUpHfrpT5va586FMWPS9DqAmhp46SXIZKiuhg0b0tQ4gHnz0tpN116bdqO76abUvmpVOg4b2ghLlxKGbgBSdiVJ+WTQJEmSJEmdxUUXpSlyX/0qrF2bVvGeO3fn0qMpU9LcuBUrmnaeW7gVGhqoq4OpU+HrX4dTToEXXkjnd1Q0sRq2bWPsqPcBK5ok5Z9BkyRJkiR1FqWlcMstsHEjXH01vPlmSomOOqrpmsMOS8cFC3YETUvO+gc2XPEtlixJBU+QqpXeeiv9rF4NvXtD/7Vp/afTTnqf6dNTZiVJ+WTQJEmSJEmdybhxcOmlKXC6/fbU1rz0aOLEFEgtWMDo0anpjbf3ZcFD9cDOQRPA/HkNrF62hYoKKFmaFnT6xGf2Y84c6NWrEG9I0t7EoEmSJEmSOptrroH+/WHWrJQGTZrUdG6ffVIYtWAB/frBkH3/whtUU1c/CGgKmiZPhh494IVbXmbVA7+hYp9308rhpaVQVVX49yRpr2DQJEmSJEmdzaBBaepcJpPmt/XsufP5KVNgwQIAqsvqeaNsLHXUMHLwJgalvInevVM+9cKLpazODGXYkufht7+Fyspd7ydJeWLQJEmSJEmd0Re/mFb2njlz13NTpsDKlbBkCdUbX+WNvodSV3oENX3jTpfVTtnO/HXVrCwfSUXDCpg9mx3z7SSpAxg0SZIkSVJn1LMn/OY3aQe6lnKreH//+1RnXqd+4/683vgxav787E6X1fZbxLsMYP37/ag4PbvOU24FcUnqAAZNkiRJktTVTJ6cjrfdRnX5ChobSwCoWT8b6ut3XFb79mM7HlecNAnuvHP3wZUk5YlBkyRJkiR1Nf37w0EHwdatVE/uv6O5hjp4tqmqKcy/m35lfwGgogL43Odg/PhC91bSXsSgSZIkSZK6ouz0uepTAgBVVRkGDymFOXPS+WXLKIsLOXz0OiAbNElSBzNokiRJkqSu6PDDARhxztGUl0NNTQlMnw7PPAObN8OTTwJQe1wfwKBJUmH0KHYHJEmSJEntcPHFMGECZYeM43vfg5oaYOVMuO8+GDkSBg6EqiouunIQPYdBZWWxOyxpb2DQJEmSJEldUb9+cMopAHz5y7nGv4Lhw+G66+Cxx+Dv/57qj5Uwa1bReilpL2PQJEmSJEndybRp6Wf5chg8uNi9kbSXMWiSJEmSpO6oqqrYPZC0F3IxcEmSJEmSJOWFQZMkSZIkSZLywqBJkiRJkiRJeWHQJEmSJEmSpLwwaJIkSZIkSVJeFHTXuRBCb+BXQK/s774/xnh1i2s+DvwAmAj8dYzx/mbnzgeuyj79VozxZwXpuCRJkiRJkvao0BVN7wHHxxgnAZOBk0MIR7W4Zjnwd8C/N28MIewPXA0cCdQCV4cQ9uvwHkuSJEmSJKlVClrRFGPMAJuyT8uzP5kW1ywDCCE0tnj5ScDsGOO67PnZwMnAzzuwy5IkSZIkSWqlggZNACGEMqAOGAP8KMY4r5UvHQG82ez5imybJEmSJEmSOoGCB00xxgZgcghhIPBQCOGQGOPvO+J3NTY2smjRoo64tdpg69at/juoaPz8qTPwc6jOxs+kOhM/j+os/CyqM+gOn8OCB005McYNIYRnSdPfWhM0vQUc1+z5gcBzH/aC0tJSxo0b194uKk8WLVrkv4OKxs+fOgM/h+ps/EyqM/HzqM7Cz6I6g67yOayrq/vAcwVdDDyEMCRbyUQIoQ9wAvCHVr78SeDEEMJ+2UXAT8y2SZIkSZIkqRMo9K5zw4BnQwivAvNJi3s/FkKYFUI4HSCEcEQIYQVwDnBLCOE1gOwi4N/Mvm4+MCu3MLgkSZIkSZKKr9C7zr0KHLab9m80ezyfNC1ud6+/Hbi9wzooSZIkSZKkdit0RZMkSZIkSZK6KYMmSZIkSZIk5YVBkyRJkiRJkvLCoEmSJEmSJEl5YdAkSZIkSZKkvDBokiRJkiRJUl4YNEmSJEmSJCkvDJokSZIkSZKUFyWZTKbYfegwdXV1a4H6YvdDkiRJkiSpGxlZU1MzZHcnunXQJEmSJEmSpMJx6pwkSZIkSZLywqBJkiRJkiRJeWHQJEmSJEmSpLwwaJIkSZIkSVJeGDRJkiRJkiQpLwyaJEmSJEmSlBcGTcqbEMKmYvdBe6cQwmdCCJkQwsHF7ou0p+/CEMJzIYTDC9Uf7b1CCAeGEB4JIfwxhLAkhHBDCKHnh1x/eQhhn0L2UXsXx4rqDBw3qjPpruNGgyZJ3cF5wPPZY6uFEMo6pjuSVFwhhBLgQeDhGONBwFigL/DtD3nZ5YBBk6TuznGj1MF6FLsD6l5CCH2BR4D9gHLgqhjjIyGEUcATpC/1o4G3gDNijFuK1Vd1D9nP3DRgOvAocHUI4ThgFrARGAM8C3wxxtiY/avBLcAM4DLSZ1LKq+xn8IoY42nZ5zcBL8YY7yhmv7RXOR7YGmP8KUCMsSGE8BVgaQjhGuBa4GSgEfgxUAIMB54NIbwTY5xenG6ru3OsqGJy3KjOqDuOG61oUr5tBc6MMU4hfYH/a/avqgAHAT+KMU4ANgAzi9RHdS9nAL+IMS4G/hRCqMm21wL/CxgPfAw4K9u+LzAvxjgpxuhgQVJ3NQGoa94QY3wXWA58ARgFTI4xTgTuiTH+EFgJTDdkUgdzrKhictwoFYBBk/KtBPhOCOFV4GlgBDA0e25pjPHl7OM60iBX+qjOA+7NPr6XpjLoF2KMb8QYG4Cfk/56BdAAPFDYLkpSp3IccEuMcTtAjHFdcbujvYxjRRWT40apAJw6p3z7W2AIUBNjfD+EsAzonT33XrPrGoA+he2aupsQwv6k6SGHhhAyQBmQAR7PHpvLPd+aHURIHWk7O/8xp/cHXSh1kIXA2c0bQgj9gSpgWTE6JGU5VlRROG5UJ9btxo1WNCnfBgBvZwcO04GRxe6QurWzgbtijCNjjKNijJXAUuBYoDaEMDqEUAqci3PqVVj1wPgQQq8QwkDgk8XukPY6zwD7hBA+DzsWsf1X4A7gSeDiEEKP7Ln9s6/ZCPQrfFe1l3GsqGJx3KjOqtuNGw2alBfZwep7wD3A4SGE3wGfB/5Q1I6puzsPeKhF2wPZ9vnATcAi0iCi5XVS3uW+C2OMbwL3Ab/PHl8qase014kxZoAzgXNCCH8EFpPWxvkn4CektZpeDSG8AvxN9mW3Ar8IITxbhC6rm3OsqE7AcaM6le48bizJZFpWCUptF0KYBPw4xlhb7L5ILXdukArF70JJ2j2/H9VZOW5UsXTn70UrmvSRhRAuIS2ad1Wx+yJJxeJ3oSTtnt+PkrSz7v69aEWTJEmSJEmS8sJd59RmIYRK4E7SVrQZ4NYY4w3ZxUT/g7QV7TLgr2KM60MIBwM/BaYA/xxjvL7Zvb4MXEja6vbHMcYfFPK9SJIkKf/aMV78W+AfSWPCjcClMcZXsvc6GbiBtEvYT2KM3y3w25EktYFT59Qe24GvxhjHA0cBl4UQxgNXAs/EGA8i7XZzZfb6dcCXgOub3ySEcAgpZKoFJgGnhRDGFOYtSJIkqQO1dby4FPhEjPFQ4JukxelzOyb+CDgFGA+cl72PJKmTMmhSm8UYV8UYF2QfbyTtzjACOAP4WfaynwGfyV7zdoxxPvB+i1uNA+bFGDfHGLcDvwTOKsBbkCRJUgdqx3jxNzHG9dn2ucCB2ce1wOsxxjdijNuAe7P3kCR1Uk6d00cSQhgFHAbMA4bGGFdlT60mlUp/mN8D3w4hDAK2AJ8CXuygrkqSJKkI2jFe/J/AE9nHI4A3m51bARzZMT2VJOWDFU1qtxBCX+AB4PIY47vNz8UYM6T5+B8oxrgIuA54CvgF8DLQ0DG9lSRJUqG1dbwYQphOCpr+sWCdlCTllUGT2iWEUE4aNNwTY3ww27wmhDAse34Y8Pae7hNjvC3GWBNj/DiwHljcUX2WJElS4bR1vBhCmAj8BDgjxvinbPNbQGWz2x6YbZMkdVIGTWqzEEIJcBuwKMb4/5qd+k/g/Ozj84FHWnGvA7LHKtL6TP+e395KkiSp0No6XsyOBR8EPhdjbP6Hx/nAQSGE0SGEnsBfZ+8hSeqkSjKZD53dJO0ihDAN+DXwO6Ax2/xPpHn39wFVQD1pu9p1IYQK0tpL/bPXbwLGxxjfDSH8GhhEWij8f8cYnynom5EkSVLetWO8+BNgZrYNYHuM8fDsvT4F/AAoA26PMX67YG9EktRmBk2SJEmSJEnKC6fOSZIkSZIkKS8MmiRJkiRJkpQXBk2SJEmSJEnKC4MmSZIkSZIk5YVBkyRJkiRJkvKiR7E7IEmS1JWFEFqzhe904A7g/hjjFR3bI0mSpOIxaJIkSfpopjZ73AeYA3wLeLxZ+0LgTOBPBeyXJElSwZVkMq35I5wkSZL2JITQF9gIXBBjvKPI3ZEkSSo4K5okSZIKIISwjGZT50IIdwCHAFcD3wNGAc8CnwP2B34M1AKLgP8RY3y12b1Kgf8DfAGoBOqBb8cYf1aQNyNJkvQBXAxckiSpeKqAWcBVwEXA0cCtwL3Zn7NJfxi8N4RQ0ux1N2ZfcytwKvAQcHsI4bTCdV2SJGlXVjRJkiQVz/7A1BjjEoAQwkTgH4DzY4x3ZttKSOs9HQwsCiGMAS4lTc/LVTA9HUIYRqqOeqzA70GSJGkHgyZJkqTiWZYLmbJezx7n7KZtBGka3SeBRuChEELzsdwzwHkhhLIYY0NHdViSJOnDGDRJkiQVz4YWz7ftpj3X1jt7HAyUAX/+gHsOA1bkpXeSJEltZNAkSZLUtawDtgPHkCqbWnq7sN2RJElqYtAkSZLUtcwhVTQNiDHOLnZnJEmSmjNokiRJ6kJijDGEcDNpJ7r/C7xImlY3ARgbY/xCUTsoSZL2agZNkiRJXc9lwGLgQmAW8C6wELitmJ2SJEkqyWQyxe6DJEmSJEmSuoHSYndAkiRJkiRJ3YNBkyRJkiRJkvLCoEmSJEmSJEl5YdAkSZIkSZKkvDBokiRJkiRJUl4YNEmSJEmSJCkvDJokSZIkSZKUFwZNkiRJkiRJyguDJkmSJEmSJOXF/weT4yJFvTiDOAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UKajgxy4UlNd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "21c04a0f-355d-49de-c167-291d9929c97f"
      },
      "source": [
        "import math\n",
        "from sklearn.metrics import mean_squared_error\n",
        "return_rmse(test[:-2],pred)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The root mean squared error is 0.011002053571719267.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J7nNXQE0WK-w"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}