{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOdNY+9wuYsjywlW4gTb+x4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cyrus723/my-first-binder/blob/main/keras2_nlp.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "https://archive.ics.uci.edu/dataset/331/sentiment+labelled+sentences\n"
      ],
      "metadata": {
        "id": "sp2b6deAWEAi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "filepath_dict = {'yelp': 'https://raw.githubusercontent.com/atharvajk98/UCI-Sentiment-Analysis/master/Dataset/yelp_labelled.txt',\n",
        "                 'amazon': 'https://raw.githubusercontent.com/atharvajk98/UCI-Sentiment-Analysis/master/Dataset/amazon_cells_labelled.txt',\n",
        "                 'imdb': 'https://raw.githubusercontent.com/atharvajk98/UCI-Sentiment-Analysis/master/Dataset/imdb_labelled.txt'}\n",
        "\n",
        "df_list = []\n",
        "for source, filepath in filepath_dict.items():\n",
        "    df = pd.read_csv(filepath, names=['sentence', 'label'], sep='\\t')\n",
        "    df['source'] = source  # Add another column filled with the source name\n",
        "    df_list.append(df)\n",
        "\n",
        "df = pd.concat(df_list)\n",
        "print(df.iloc[0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oq-C9PwYWDom",
        "outputId": "7e32fe27-6892-43e6-8aef-e071d65aef22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sentence    Wow... Loved this place.\n",
            "label                              1\n",
            "source                          yelp\n",
            "Name: 0, dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qd2nhwJZV9-F"
      },
      "outputs": [],
      "source": [
        "sentences = ['John likes ice cream', 'John hates chocolate.']"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "\n",
        "vectorizer = CountVectorizer(min_df=0, lowercase=False)\n",
        "vectorizer.fit(sentences)\n",
        "vectorizer.vocabulary_"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6H_HQ7dAWDZu",
        "outputId": "06b85cb8-ce3f-4060-9d09-40d75eabfeb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'John': 0, 'likes': 5, 'ice': 4, 'cream': 2, 'hates': 3, 'chocolate': 1}"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OAYTiaXdWDW2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "vectorizer.transform(sentences).toarray()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MREny8T_WDT-",
        "outputId": "7756d8d8-6313-4c20-bb29-41e800bc0edd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 0, 1, 0, 1, 1],\n",
              "       [1, 1, 0, 1, 0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "df_yelp = df[df['source'] == 'yelp']\n",
        "\n",
        "sentences = df_yelp['sentence'].values\n",
        "y = df_yelp['label'].values\n",
        "\n",
        "sentences_train, sentences_test, y_train, y_test = train_test_split(\n",
        "   sentences, y, test_size=0.25, random_state=1000)"
      ],
      "metadata": {
        "id": "QgR7b87UWDOT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "\n",
        "vectorizer = CountVectorizer()\n",
        "vectorizer.fit(sentences_train)\n",
        "\n",
        "X_train = vectorizer.transform(sentences_train)\n",
        "X_test  = vectorizer.transform(sentences_test)\n",
        "X_train"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xL3fcoLaXb0K",
        "outputId": "15ada9b5-4983-4a7f-8dea-7efe8ac03da0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<750x1714 sparse matrix of type '<class 'numpy.int64'>'\n",
              "\twith 7368 stored elements in Compressed Sparse Row format>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.linear_model import LogisticRegression\n",
        "\n",
        "classifier = LogisticRegression()\n",
        "classifier.fit(X_train, y_train)\n",
        "score = classifier.score(X_test, y_test)\n",
        "\n",
        "print(\"Accuracy:\", score)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f_X_B-NAXbxP",
        "outputId": "25c31651-9ad4-41b7-c35b-656273f81e60"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 0.796\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for source in df['source'].unique():\n",
        "    df_source = df[df['source'] == source]\n",
        "    sentences = df_source['sentence'].values\n",
        "    y = df_source['label'].values\n",
        "\n",
        "    sentences_train, sentences_test, y_train, y_test = train_test_split(\n",
        "        sentences, y, test_size=0.25, random_state=1000)\n",
        "\n",
        "    vectorizer = CountVectorizer()\n",
        "    vectorizer.fit(sentences_train)\n",
        "    X_train = vectorizer.transform(sentences_train)\n",
        "    X_test  = vectorizer.transform(sentences_test)\n",
        "\n",
        "    classifier = LogisticRegression()\n",
        "    classifier.fit(X_train, y_train)\n",
        "    score = classifier.score(X_test, y_test)\n",
        "    print('Accuracy for {} data: {:.4f}'.format(source, score))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9n_E8ZTtXbup",
        "outputId": "30db96fa-2bec-4456-c642-cfb3f2118cd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy for yelp data: 0.7960\n",
            "Accuracy for amazon data: 0.7960\n",
            "Accuracy for imdb data: 0.7487\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import Sequential\n",
        "from keras import layers\n",
        "\n",
        "input_dim = X_train.shape[1]  # Number of features\n",
        "\n",
        "model = Sequential()\n",
        "model.add(layers.Dense(10, input_dim=input_dim, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))"
      ],
      "metadata": {
        "id": "IMBW44G8Xbrt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.compile(loss='binary_crossentropy',\n",
        "              optimizer='adam',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kx5mZB4eXbpB",
        "outputId": "6796a2e5-fde6-4dfc-d180-5ffbda63222d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense (Dense)               (None, 10)                25060     \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 11        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 25071 (97.93 KB)\n",
            "Trainable params: 25071 (97.93 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=100,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)"
      ],
      "metadata": {
        "id": "iVVg-k5EXbmC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.backend import clear_session\n",
        "clear_session()"
      ],
      "metadata": {
        "id": "BwSAo1IuXbje"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3vkG7Dj8Xbgk",
        "outputId": "625575b7-194f-4c64-b186-b200f9523c16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: 1.0000\n",
            "Testing Accuracy:  0.7754\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.style.use('ggplot')\n",
        "\n",
        "def plot_history(history):\n",
        "    acc = history.history['accuracy']\n",
        "    val_acc = history.history['val_accuracy']\n",
        "    loss = history.history['loss']\n",
        "    val_loss = history.history['val_loss']\n",
        "    x = range(1, len(acc) + 1)\n",
        "\n",
        "    plt.figure(figsize=(12, 5))\n",
        "    plt.subplot(1, 2, 1)\n",
        "    plt.plot(x, acc, 'b', label='Training acc')\n",
        "    plt.plot(x, val_acc, 'r', label='Validation acc')\n",
        "    plt.title('Training and validation accuracy')\n",
        "    plt.legend()\n",
        "    plt.subplot(1, 2, 2)\n",
        "    plt.plot(x, loss, 'b', label='Training loss')\n",
        "    plt.plot(x, val_loss, 'r', label='Validation loss')\n",
        "    plt.title('Training and validation loss')\n",
        "    plt.legend()"
      ],
      "metadata": {
        "id": "YYDDBMfVXbdi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_history(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 469
        },
        "id": "dbJDJBA9Xbat",
        "outputId": "0f3ba545-2b4a-416f-a6f3-94ff5a117892"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cities = ['London', 'Berlin', 'Berlin', 'New York', 'London']\n",
        "cities"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5hncoX9IXbVi",
        "outputId": "0ea9ed9d-6703-4706-f1f9-0438b38f2576"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['London', 'Berlin', 'Berlin', 'New York', 'London']"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "\n",
        "encoder = LabelEncoder()\n",
        "city_labels = encoder.fit_transform(cities)\n",
        "city_labels"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YRTyHrXWYd23",
        "outputId": "9ad6dd14-0260-40f4-e988-abc5a01113d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 0, 0, 2, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import OneHotEncoder\n",
        "\n",
        "encoder = OneHotEncoder(sparse=False)\n",
        "city_labels = city_labels.reshape((5, 1))\n",
        "encoder.fit_transform(city_labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ARmpK86eYdzv",
        "outputId": "08bddaf2-9470-4d7e-e8eb-7053b7ee2dda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_encoders.py:868: FutureWarning: `sparse` was renamed to `sparse_output` in version 1.2 and will be removed in 1.4. `sparse_output` is ignored unless you leave `sparse` to its default value.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1., 0.],\n",
              "       [1., 0., 0.],\n",
              "       [1., 0., 0.],\n",
              "       [0., 0., 1.],\n",
              "       [0., 1., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.preprocessing.text import Tokenizer\n",
        "\n",
        "tokenizer = Tokenizer(num_words=5000)\n",
        "tokenizer.fit_on_texts(sentences_train)\n",
        "\n",
        "X_train = tokenizer.texts_to_sequences(sentences_train)\n",
        "X_test = tokenizer.texts_to_sequences(sentences_test)\n",
        "\n",
        "vocab_size = len(tokenizer.word_index) + 1  # Adding 1 because of reserved 0 index\n",
        "\n",
        "print(sentences_train[2])\n",
        "print(X_train[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nU9LoxCPYdxM",
        "outputId": "88cf7843-ba17-4b57-eca2-5275483ee6a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am a fan of his ... This movie sucked really bad.  \n",
            "[7, 150, 2, 932, 4, 49, 6, 11, 563, 45, 30]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for word in ['the', 'all', 'happy', 'sad']:\n",
        "  print('{}: {}'.format(word, tokenizer.word_index[word]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 193
        },
        "id": "AwfdcLvNYdu4",
        "outputId": "6073a8fd-ecba-4608-ccce-788feb2d500a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the: 1\n",
            "all: 27\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "'happy'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-31-0c4cf29914d6>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mword\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'the'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'all'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'happy'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'sad'\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----> 2\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'{}: {}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mword\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtokenizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mword_index\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mword\u001b[0m\u001b[0;34m]\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[0;31mKeyError\u001b[0m: 'happy'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.preprocessing.sequence import pad_sequences\n",
        "\n",
        "maxlen = 100\n",
        "\n",
        "X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
        "X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)\n",
        "\n",
        "print(X_train[0, :])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eLGO0nnVYdsU",
        "outputId": "1985fce7-a8df-4e6b-f360-2d709ea0c94a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[170 116 390  35   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n",
            "   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n",
            "   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n",
            "   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n",
            "   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0\n",
            "   0   0   0   0   0   0   0   0   0   0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import Sequential\n",
        "from keras import layers\n",
        "\n",
        "embedding_dim = 50\n",
        "\n",
        "model = Sequential()\n",
        "model.add(layers.Embedding(input_dim=vocab_size,\n",
        "                           output_dim=embedding_dim,\n",
        "                           input_length=maxlen))\n",
        "model.add(layers.Flatten())\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "model.compile(optimizer='adam',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qU9k7VW6Ydpd",
        "outputId": "bb50341d-f063-4aed-c590-cc941511b852"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding (Embedding)       (None, 100, 50)           128750    \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 5000)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 10)                50010     \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 11        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 178771 (698.32 KB)\n",
            "Trainable params: 178771 (698.32 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=20,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)\n",
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
        "plot_history(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        },
        "id": "8xe4JifNYdmV",
        "outputId": "d4ae1f81-0277-4cff-e6bb-9f71524aeb9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: 1.0000\n",
            "Testing Accuracy:  0.6578\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.models import Sequential\n",
        "from keras import layers\n",
        "\n",
        "embedding_dim = 50\n",
        "\n",
        "model = Sequential()\n",
        "model.add(layers.Embedding(input_dim=vocab_size,\n",
        "                           output_dim=embedding_dim,\n",
        "                           input_length=maxlen))\n",
        "model.add(layers.GlobalMaxPool1D())\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "model.compile(optimizer='adam',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W7EahZb_Ydjh",
        "outputId": "b9420673-bcf6-438b-9927-3f8b084cf510"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " embedding_1 (Embedding)     (None, 100, 50)           128750    \n",
            "                                                                 \n",
            " global_max_pooling1d (Glob  (None, 50)                0         \n",
            " alMaxPooling1D)                                                 \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 10)                510       \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 1)                 11        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 129271 (504.96 KB)\n",
            "Trainable params: 129271 (504.96 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=50,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)\n",
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
        "plot_history(history)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 504
        },
        "id": "U7Eoz2lRYdg_",
        "outputId": "d62c5d25-4f88-4919-972b-898f0f3fc405"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training Accuracy: 1.0000\n",
            "Testing Accuracy:  0.7861\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9UAAAHECAYAAAA3XwkIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyQklEQVR4nOzdd3hTddsH8O/JTjctLS0FOmiZIrKh7GlBpiCIKAKKigucj4K+4sBHnKC48WEoKFBlL0XKkDJFwLL3agstJd3Z5/0jTWjooE3TJm2+n+viKjnn5Jw7N6E5d35LEEVRBBERERERERFVmMTVARARERERERHVVCyqiYiIiIiIiBzEopqIiIiIiIjIQSyqiYiIiIiIiBzEopqIiIiIiIjIQSyqiYiIiIiIiBzEopqIiIiIiIjIQSyqiYiIiIiIiBzEopqIiIiIiIjIQSyqPYQgCOjVq1elz9OrVy8IglD5gGoZZ+XXWSIjIxEZGWm3beHChRAEAQsXLiz3eSZMmABBEHDhwgWnxne7kuIlIiL3xfuKqsX7ispxx/sKd/s3JediUV1NBEGo0J+K/IIicne8aSIici7eV5An430FuRuZqwPwFG+99VaxbXPmzEFWVhamTp2KgIAAu3333HOPU69//PhxeHl5Vfo8ixcvRn5+vhMiouo2YsQIdO7cGWFhYa4OpZg///zT1SEQEdUovK8gV+N9BdEtLKqrycyZM4ttW7hwIbKysjBt2rQq76LSrFkzp5ynUaNGTjkPVT9/f3/4+/u7OowSNW7c2NUhEBHVKLyvIFfjfQXRLez+7YasXVr0ej3eeecdNG3aFEqlEhMmTAAAZGVl4aOPPkKfPn3QoEEDKBQKBAcHY+jQodi9e3eJ5yxpHMfMmTMhCAK2bduGhIQEdOzYEV5eXggMDMSDDz6Iq1evlhpbUdu2bYMgCJg5cyYOHTqE++67DwEBAfDy8kLPnj2RlJRUYkypqamYOHEiQkJCoFarcc8992DRokV25yuPyuQjIyMDTzzxBMLCwqBUKtGyZUssWLCgxOfo9Xq8++67aNy4MZRKJaKiovDGG29Ap9OVK04A2LNnDwRBwIgRI0o9pnnz5lAqlcjMzLRdd968eRg0aBAiIiKgVCoRGBiIfv36YePGjeW+dlljn7Zs2YLu3bvD29sbgYGBGD58OE6cOFHmuUaOHIno6Gio1Wr4+fmha9eu+Omnn+yOu3DhAgRBwPbt2wHYd1cs+n4sbeyTTqfDBx98gFatWsHLywt+fn7o3r07li9fXuxY67UmTJiACxcu4MEHH0TdunWhUqnQvn17rFu3rnyJKrRq1So8/PDDaNKkCby9veHt7Y127drh888/h9lsLvE5+fn5mD17Ntq3bw9fX1/4+PigefPmeP7553Ht2jWHji2ri1tp/6bWfGZnZ+PFF19EZGQk5HK57f9USkoK3nnnHXTt2hWhoaFQKBSoX78+HnroIRw7dqzUnOzbtw9jxoxBeHg4lEolwsLCMGDAANu/x4kTJyAIAnr37l3qOVq1agW5XI7U1NRSjyEi5+J9Be8reF9h4cr7itJkZWXh9ddfR9OmTaFSqVCnTh3ce++92LJlS7FjRVHEokWLEBcXh+DgYKhUKjRs2BD33nsvli1bZnfskSNHMHbsWERGRkKpVCI4OBht27bFtGnTYDAYnBI73cKWajc2cuRI7N+/HwMHDsTw4cMREhICwNLlasaMGejRowfuu+8+1KlTB5cuXcKaNWuwceNGrF27FvHx8eW+zldffYU1a9Zg6NCh6NmzJ/bu3Ytly5bh8OHDOHToEJRKZbnOc+DAAXz44Yfo0qULHn/8cVy6dAm//vor+vbti0OHDqFp06a2Y69fv44uXbrg4sWL6NGjB+Li4pCWloann34aAwYMqFCeHM2HRqNB165doVAoMGrUKOh0OqxYsQKTJk2CRCLBo48+ajtWFEWMHj0aq1evRuPGjfHss89Cr9fjf//7H/79999yx9q5c2c0bdoUGzZswI0bNxAUFGS3f9++fThx4gRGjhyJwMBAAEBmZiamTp2KuLg49O/fH8HBwUhNTcXatWsxaNAgfP/993j88ccrlLOiEhISMGbMGCgUCowZMwZhYWH466+/0KVLF9x9990lPmfKlClo2bIlevTogbCwMNy4cQMbNmzAI488gpMnT+Ldd98FAAQEBOCtt97CwoULcfHiRbvuindqRdHr9bj33nuxfft2NGvWDM888wzy8/Nt8R46dAjvv/9+seddvHgRHTt2RHR0NB555BFkZmZi2bJlGDZsGLZs2VJmwVfUa6+9BolEgk6dOiE8PBxZWVnYunUrpk6div379+PHH3+0O/7mzZvo3bs3Dh8+jKZNm2LSpElQKBQ4e/YsFixYgPvvvx/16tWr8LGO0uv16NOnDzIzMzFgwAD4+fkhKioKALBjxw588MEH6N27N0aOHAkfHx+cPn0aCQkJWLNmDXbt2oXWrVvbne/777/HlClTIJVKMXToUMTGxuL69es4cOAAvvrqK4wePRrNmjVD7969kZiYiFOnTqFJkyZ250hKSkJycjJGjhzplt0FiWo73leUD+8reF9RlLPuK0pifc8cO3YMHTp0wLRp05CRkYHly5djwIAB+Prrr/Hkk0/ajp8xYwb++9//IioqCqNHj4a/vz9SU1Oxf/9+rFixAmPGjAFgKag7deoEQRAwdOhQREVFITs7G2fOnMFXX32F9957D3K53OG4qQQiuUxERIQIQDx//rzd9p49e4oAxFatWonp6enFnqfRaErcfvnyZTEsLExs1qxZsX0AxJ49e9pte+utt0QAoq+vr3jkyBG7fWPHjhUBiMuWLSsxtqISExNFACIAccGCBXb7vvnmGxGAOGXKFLvtkyZNEgGIr776qt32Q4cOiQqFQgQgvvXWW8VeR0kczQcA8bHHHhONRqNt+9GjR0WpVCo2b97c7vglS5aIAMTOnTuLBQUFtu03btwQo6OjS8xvad5//30RgPjFF18U2/f000+LAMQ1a9bYtmm1WvHy5cslvu6WLVuKderUEfPz8+32RUREiBEREXbbFixYUOzfKCcnRwwMDBRlMpm4f/9+u+OnTZtmy9Pt79EzZ84Ui0en04l9+vQRZTKZeOXKFbt9Jb1v7hSvNU8DBw4UDQaDbfu1a9ds/3d27dpl237+/HlbvDNnzrQ716ZNm2znKq+SXqPJZBLHjx8vAhD37Nljt8/6f+app54STSaT3b6cnBxRo9E4dGxZuSvp31QUb/1u6du3r5ibm1vsedeuXROzs7OLbT906JDo7e0txsfH220/evSoKJPJxDp16ojJycnFnlf0/blixQoRgPjSSy8VO+7RRx8VAYi///57ia+HiCqH9xW8r7gd7ytucfV9RUn/pk888YQIQHziiSdEs9ls237q1CnRz89PVCgUdrkKDAwUw8PDxby8vGLnL/qeffHFF0UA4qpVq4odl5mZWezegyqPRbUL3enDr6T/CHfy3HPPiQDEixcv2m0v68NvxowZxc6zdevWEm+My/rw69q1a7Hz6PV6USaTie3atbNt0+l0olqtFv39/Uu8sX/88ccr9OFXlrLy4eXlJWZlZRV7To8ePUQAYk5Ojm1bv379RADi1q1bix1v/VAp74ff5cuXRYlEIrZv395uu06nEwMDA8WQkBC7X/Zl+eSTT0QA4vbt2+22l/fD76effhIBiOPHjy92bo1GI/r7+5f4Hi3Nr7/+KgIQFy1aZLfdkQ+/mJgYURAE8fjx48WOnz9/vghAnDhxom2b9cMvIiLC7obGqlGjRmJQUFC5XkdZ/v77bxGA+Pbbb9u2Xbt2TZRIJGJYWFiJRWxRFTlWFCtXVB86dOjOL+g2Q4YMEZVKpajX623bnn32WRGA+Omnn97x+QaDQQwLCxODgoJErVZr237z5k1RrVaLjRs3trtxICLn4X0F7yuK4n2Ffbyuvq+4/d9Up9OJXl5eoo+Pj3jjxo1ix7/xxhvF7jcCAwPFyMhIu8/XkliL6s2bN5c7Pqocjql2Yx07dix1365duzB69Gg0bNgQSqXSNp7kiy++AIASxy2Vpn379sW2NWzYEIClm2plziOXy1GvXj2785w8eRIFBQW4++674evrW+w53bp1K/c1rRzJR2xsLPz8/IptL+m1Hzx4EBKJpMTYKrrmYIMGDdC3b18cOHDAbvzq2rVrkZmZiXHjxkEmsx+ZcfToUUyYMME21sj6+l566aVSX195HDx4EADQs2fPYvv8/f1LnS320qVLeOaZZ9CsWTN4eXnZ4hk5cmSl4rHKycnBmTNnUL9+/RInw+nTpw8A4J9//im275577oFUKi22vWHDhhV6P9+4cQOvvfYa7r77bvj4+NheY7t27QDYv8b9+/fDbDajR48e8Pb2LvO8FTm2MlQqVand7ABg/fr1GDJkCMLCwiCXy22vb+3atdDpdMjIyLAdu2fPHgDAwIED73hdmUyGyZMn48aNG/j1119t23/88UcUFBTgiSee4DIoRC7C+4ry430F7yusnHVfcbuTJ08iPz8frVu3tnXNv1NM48aNw4ULF9CiRQu8/vrr2LRpE7Kysoo9d8yYMZBKpRg+fDjGjx+PxYsX4+zZsw7HSnfGMdVuLDQ0tMTtK1euxKhRo6BSqdC/f380btwY3t7ekEgk2LZtG7Zv316hSS5uX3YDgO2Xr8lkqtR5rOcqeh7rf/7SxoxWdCypo/koK14AxWIODAwscfxJaf9OZZkwYQL++OMPLFq0CLNnzwYALFq0CADsxlwBloKmT58+MBqN6Nu3L4YOHQo/Pz9IJBIcOnQIq1evrtC/d1F3+rco6bWdO3cOHTt2xM2bN9G9e3cMGDAA/v7+kEqluHDhAhYtWuRwPLfHVdq4W+t2jUZTbF9Z/66lTTB2O41Ggw4dOuD8+fPo2LEjxo8fj8DAQMhkMmg0GsydO9fuNVrjCA8PL9e5y3tsZYSEhJRavM6dOxfTpk1DnTp10L9/fzRq1Mh2E7Nq1SocPnzY4dcHAE888QRmzZqFb7/9Fg899BAA4LvvvoNCocDEiRMr98KIyGG8rygf3lfwvqIoZ9xXOCumzz77DNHR0ViwYAE++OADfPDBB5DJZBg0aBA++eQTxMTEALB8gbZz507MmjULCQkJtnlgmjZtirfeegtjx451OG4qGYtqN1baDfGbb74JhUKBAwcOoHnz5nb7nnzySduMiO7K+i3u7bMhW5W2vTTVkQ9/f39kZmbCYDAU+wBMS0ur8PlGjBgBPz8//PTTT3j//fdx48YNbNy4Ea1bty42QdR7772HgoICJCYmFvv2+r///S9Wr15d4etbWZfCKC3nJb22Tz/9FDdu3MCCBQtsM8da/fzzz7YP8cqwxlVabq0zR1fVUh7z58/H+fPn8dZbbxWbLXb37t2YO3eu3TbrB255vkmvyLEAIJFYOhQZjcZiLQ0lffhblfb7w2g0YubMmQgNDcXBgweLfZiXNLNt0ZjLs4xOeHg4hg4dipUrV+LEiRPIzMxEcnIyxowZg+Dg4Ds+n4iqBu8ryof3FbyvqA6OxCSVSjFt2jRMmzYN169fx19//YVffvkFK1aswNGjR3H06FHbRIBdunTBunXroNPp8Pfff2PTpk344osv8NBDDyE4OBj9+vWr4lfoWdj9uwY6c+YMWrRoUewXvdlsxl9//eWiqMqvWbNmUKvVOHLkCHJycortr+hrqI58tG3bttTzbdu2rcLnU6vVGD16NFJSUrBlyxYsXboURqOx2LfJgOX1BQYGltgdrLIf7G3bti31PFlZWTh06FCJ8QCwdckqTzzWblPlbaHw9fVF48aNcfXqVZw+fbrY/sTERLv4na2ir7Fjx46QSCTYsWMH8vLyyjx3RY4FgDp16gAALl++XGzfgQMH7vj822VkZECj0SAuLq5YQZ2bm2vruldU586dAaBCS608/fTTAIBvv/0W3333HQDYzWBKRO6D9xX2eF/hON5XlF/Tpk3h5eWFw4cPl/gl+Z1iCgkJwf3334/ly5ejT58+OHv2LJKTk4sdp1QqERcXh3feeQeff/45AFTqixMqGYvqGigyMhKnT59GSkqKbZsoipg5c2aZa8y6C+sSC1lZWXjvvffs9h0+fBiLFy+u0PmqIx/WLqszZsyAVqu1bc/MzCz2GsrL+m3s4sWLsXjxYshkMowbN67YcZGRkcjMzMSRI0fstv/www/YvHmzQ9e2GjZsGOrUqYOlS5cWK9BmzpxZ4jgd65IVt3/ob968GfPnzy/xOtYlPi5dulTu2CZNmgRRFPHKK6/YfWhmZGTYltaYNGlSuc9XEaW9xn/++Qf//e9/ix0fHByMBx98EKmpqXj55ZeLdQfLzc215bIixwK3xkB+//33dsf9+eef+Pnnnyv82kJCQuDl5YW///4bubm5tu0GgwFTp061G0ttNWXKFMhkMrz77rsl/p+6cuVKsW19+/ZFkyZNsGjRIixfvhxNmzat1LIjRFR1eF9hj/cVjuN9RfkpFAqMGzcOOTk5ePPNN+32nT17Fp9//jnkcjkeeeQRAJY1tnft2lXsPAaDwbYGuZeXFwDLEpYFBQXFjrX2ILAeR87D7t810AsvvICnnnoKbdq0wciRIyGXy7Fr1y4cO3YMQ4YMwdq1a10d4h198MEH2Lp1Kz788EPs3bsXcXFxSE1NxfLlyzFo0CCsWrXK1u31TqojH2PHjsWyZcuwZs0a3HXXXRg2bBgMBgMSEhLQoUMHhyZ/6Nq1K2JiYrBixQoYDAYMGTLEtmZoUdOmTcPmzZvRrVs325qEBw4cwF9//YVRo0YhISHB4dfl4+OD7777DmPGjEH37t3t1pNMTk5Gjx49sGPHDrvnPP3001iwYAEeeOABjBo1CvXr10dycjI2bdqE0aNHY9myZcWu07dvX6xYsQL3338/Bg0aBLVajYiICNsHRUlefvllbNy4EatXr0br1q0xaNAg5OfnY8WKFbh+/TpeffVVhyafKY/x48fjo48+wrRp05CYmIjY2FicPn0a69atw/3331/ia5w3bx6Sk5PxzTffYNu2bbj33nuhUChw/vx5bN68GWvWrLG1ClTk2IkTJ+Kjjz7Cf//7Xxw+fBgtWrTAqVOnsHHjRowYMcJuMrDykEgkeP755/HBBx+gVatWGDZsGPR6PRITE5GZmWlbZ7qoFi1a4KuvvrL9Pxs2bBhiY2Nx48YN7N+/H35+fsWeIwgCnnrqKbz44osALOOsicg98b7CHu8reF9RXT744APs3LkT8+bNw/79+9G7d2/bOtU5OTmYN28eoqKiAAAFBQXo1q0bYmJi0K5dO0RERECr1eKPP/7A8ePHMXToUFvvig8//BBbt25F9+7dERUVBR8fHxw9ehQbN25EnTp1+JlcFVw59binu9PSF2VZsGCB2Lp1a9HLy0sMCgoShw8fLh45csS2nEViYqLd8Shj6YvbjxXFW8sIPProo3eMzbr0RWlLVZS0rIEoiuKVK1fE8ePHi3Xr1hVVKpXYunVrceHChbZ1bj/77LMyc1CUM/JhZV1L9/Z/F51OJ7799ttiVFSUqFAoxIiICHH69OmiVqut0NIXRb377ru2NRATEhJKPW7t2rVip06dRB8fH9Hf31/s37+/uH379jKXVCrP0hdWv//+u9i1a1dRrVaLAQEB4tChQ8Xjx4+Xmotdu3aJvXv3FgMCAkQfHx+xa9eu4sqVK0t9LxiNRvH1118Xo6KiRJlMVixfpb1HCgoKxFmzZoktW7YUVSqV7VpLly4tdmxp71mr8vy/Kuro0aPikCFDxODgYNHLy0ts27at+P3335d5ndzcXPG9994TW7VqJarVatHHx0ds3ry5OHXqVPHatWsOH5ucnCwOHDhQ9PHxEb29vcWePXuK27Ztq9C/f1EGg0H85JNPxObNm4sqlUqsV6+e+PDDD4sXLlwo9d9cFEUxKSlJvP/++8Xg4GBRLpeLYWFh4r333iuuWLGixOtkZmaKEolEVKlUYkZGRqnxEJFz8L6C9xW8ryg9XlF07X1Faf+mN2/eFF999VUxJiZGVCgUor+/v9ivX79iy2Hp9Xpx9uzZYnx8vNiwYUNRqVSKdevWFTt16iR+/fXXok6nsx27efNmccKECWLz5s1FPz8/0cvLS2zSpIn43HPPiRcuXCh3zFR+giiKovNLdSLHzZgxA++//z42bdqEe++919XhEJGDtm3bht69e+Phhx+2zTxKRFTdeF9BRFWNRTW5TEpKCurXr2+37d9//0VcXBwUCgWuXr0KlUrlouiIqLIGDRqEjRs3Ys+ePejUqZOrwyGiWo73FUTkKhxTTS7Tvn17xMTE4K677oK3tzdOnz6N9evXw2w249tvv+UHH1EN9O+//2LdunX4+++/sXHjRgwePJgFNRFVC95XEJGrsKWaXObtt9/GqlWrcOHCBeTk5CAgIACdO3fGyy+/XOIyD0Tk/hYuXIiJEyfCz88P9957L7766ivUrVvX1WERkQfgfQURuQqLaiIiIiIiIiIHcZ1qIiIiIiIiIgexqCYiIiIiIiJyEItqIiIiIiIiIgexqCYiIiIiIiJyUI1aUuvmzZswGo13PC44OBjp6enVEFHtw9w5hnlzDPPmOObOMc7Km0wmQ506dZwQEd2On/VVj7lzDPPmOObOMcyb46r7875GFdVGoxEGg6HMYwRBsB3Lic0rhrlzDPPmGObNccydY5i3moGf9VWLuXMM8+Y45s4xzJvjXJE7dv8mIiIiIiIichCLaiIiIiIiIiIHsagmIiIiIiIichCLaiIiIiIiIiIHsagmIiIiIiIichCLaiIiIiIiIiIHsagmIiIiIiIiclCNWqeaiIiIqsemTZuwdu1aaDQaREREYNKkSYiJiSnx2JkzZ+LYsWPFtrdp0wavv/56VYdKRETkUiyqiYiIyE5SUhIWL16MyZMnIzY2FuvXr8esWbMwZ84c+Pv7Fzv+5ZdfhtFotD3OycnBK6+8gi5dulRn2ERERC7B7t9ERERkZ926dejbty969+6NBg0aYPLkyVAoFEhMTCzxeB8fHwQEBNj+HDlyBEqlEp07d67myImIiKpfhVuqjx07hjVr1uD8+fO4efMmXn75ZXTs2LHM5xw9ehSLFy/G5cuXERQUhJEjR6JXr16OxkxERERVxGg04ty5cxg+fLhtm0QiQatWrXDq1KlynWPr1q2Ii4uDSqUq9RiDwQCDwWB7LAgC1Gq17e9lse6/03FUHHPnGObNccydY5g3x7kidxUuqnU6HSIjI9GnTx98/PHHdzz++vXr+OCDD9C/f38899xzSE5OxjfffIOAgADcc889jsRMREREVSQ7OxtmsxkBAQF22wMCApCSknLH5585cwaXL1/GlClTyjxu5cqVSEhIsD2OiorC7NmzERwcXO5YQ0NDy30s2WPuHMO8OY65cwzz5rjqzF2Fi+o2bdqgTZs25T7+999/R0hICMaPHw8AaNCgAU6cOIH169ezqCYiIqpltm7dikaNGpU6qZnViBEjMHjwYNtja4tCenq63fjskgiCgNDQUKSlpUEUxcoH7UGYO8cwb45j7hzDvDnOmbmTyWTl+rK3yicqO336NFq1amW3rXXr1li4cGFVX5o8gCgCaWkSXLggQ5FehNVKEAQEBQE3bij4S68CmDfHMXeOseYtLExAnTrMW2n8/PwgkUig0Wjstms0mmKt17fTarXYtWsXxowZc8fryOVyyOXyEveV930timKJx545I8Px4zIMGaIt13k8UWm5o7Ixb45j7hzDvDmuOnNX5UW1RqMpNlOov78/CgoKoNfroVAoij2H46xcw51zZzYDV65IceqUDKdPy2w/T5+WISfHXebbC3J1ADUU8+Y45s4RS5cq0KuXztVhuC2ZTIbo6GgkJyfb5kwxm81ITk5GfHx8mc/ds2cPjEYjunfvXh2hlig7W8CMh3OQfDkQx4754pVXciBxl48JIiKqldxySS2Os6paBQXAyZPA8ePAsWO3fp49C1h63Llf7kTR8qckUikQFQUUfu9CRFSmRo0CERbm6ijc2+DBg/Hll18iOjoaMTEx2LBhA3Q6nW2S0Xnz5iEwMBAPPfSQ3fO2bt2KDh06wNfX1wVRW3h7i/hK8iwisAuff/48nj80Be9/K4GfH1t6iIioalR5UR0QEICsrCy7bVlZWVCr1SW2UgMcZ+UsubmCrTX31CnLnzNnZLh4UQpRdL/W6DtRKEQ0bmxETIwRTZpY/sTGGhEVZYRS6bq4+J5zDPPmOObOMUXzlppaPWOsaqq4uDhkZ2dj+fLl0Gg0iIyMxPTp023dvzMyMor1akpJScGJEyfwxhtvuCDiW2S6fDTzugg5cvAGZiFnx1ws6TIFrRdPQES7AJfGRkREtVOVF9WxsbH4559/7LYdOXIETZo0KfU5VTnOqibbtUuB48dLzgtg6SJ99aoUZ85YCuiUlNL/eQMCzIiNNdgK09hYIxo3NqFRoxBcu3bNLXMXFGSGrJSX5A7h1sb3XHVg3hzH3DmGeSuf+Pj4Urt7z5w5s9i2+vXrY/ny5VUc1Z2JXl5I//13qDZvhuz9OfA7l4ynNB8hd+hXuHTfRAS+PxnmunVdHSYREdUiFS6qtVot0tLSbI+vX7+OCxcuwMfHB3Xr1sXSpUuRmZmJZ599FgAwYMAAbN68GT/99BN69+6N5ORk7N69G6+99przXkUtl54uwRtv+GPduor3bw4JMdladmNjDYiNtfy9bl0zbh86LQhCYZdIM284iYio5pJIoB04EIiPR8aKLdDNmIvm+f+gxfp50G/+AbpJjyBvyhSYQ0JcHSkREdUCFS6qz549i7ffftv2ePHixQCAnj174plnnsHNmzeRkZFh2x8SEoLXXnsNixYtwoYNGxAUFISnnnqKy2mVgygCv/2mxv/9nz80GgmkUhH9+2uhVJZe8AYHm9G0qaXlOSbGwBluiYjIcwkCVKP7QxjaDx9P2o2e22ejg/EAFN99B68VK5Cxfj1MERGujpKIiGq4ChfVLVu2LLN71zPPPFPicz788MOKXsqjXb0qwWuvBWDrVhUAoGVLAz75RINWrVy0bhQREVENpVQJGLskDosW/o63/283ZptfQcubxxDwxJO4sXoVoFK5OkQiIqrBuMiEmzGbgcWLvdCnTwi2blVBoRDxn/9kY/36dBbUREREDhIEYMLEAkxY1hFj/DYgA0FQJv8L/yK974iIiBzBotqNnD8vxejRQXj99QDk5krQrp0ev/+ejuefz0Up87YRERFRBcTF6fHgKwF4GD/BDAHeixdDvXKlq8MiIqIajEW1GzCZgG++8Ua/fiHYvVsJtdqMt9/OwsqVGYiNLXsJMSIiIqqYhx7Kw5Gw/piFGQAA/1dfhez0aRdHRURENRWLahc7cUKGoUPr4t13/aHVCujWTYc//0zH44/nQSp1dXRERES1j0oFTJuWg5mYiZ3yXpDk56POk09CyM93dWhERFQDsah2Eb0e+PRTH8THB+PQIQX8/Mz4+GMNfvnlBiIiTK4Oj4iIqFYbMyYfDRqJeMDwM3J86kF+8iT8X3/dsvQGERHVSEJ2NpRbtgAnT1brdVlUu8ChQ3IMHBiMTz7xg8EgYMCAAiQmXsfYsfnF1o4mIiIi55PLLa3V1xCKsVgKUSKBV0ICvH7+2dWhERFROQk3b0K1eTP8Zs5E3fh4hLZsicDx44GffqrWOCq8pBY5rqAA+PhjP3z3nTfMZgFBQSa8+24Whg7VspgmIiKqZiNHFmDePF+sP9cHm3q8iYE73ob/G29Af/fdMN51l6vDIyKi2wg3b0K5Zw8Uu3dDuXs3ZMePQ7ith5ExKgoyf/9qjYtFdTX6z38C8OuvXgCAESPy8c472QgMNLs4KiIiIs8kkwEvvZSDZ56pg4cOvYFLvXbBd9sWBD75JNI3boTo5+fqEImIPJpQUADF/v1Q/PUXlDt3Qv7vv8WKaEPjxtB36QJ9ly7QdeoEsX59hIWFAamp1RYni+pqcvOmgDVr1ACAb7/NxODBWhdHREREREOHFuDzz31w8qQcHzSbj7fPdIPswgX4v/YaNF995erwiIg8i04H+b//QrlrF5Q7d0Lx998Q9Hq7QwyxsdDHxUHXuTP0nTvDHBJit98VHYBZVFeTtWvVMBgEtGxpYEFNRETkJiQS4OWXczB5ciA+/6khJn33HaLH3Qev1auRM306TA0auDpEIqJaS5KZCfmBA5bW6AMHoDh8GIJOZ3eMKSwMum7dbH/MoaEuirZ0LKqryW+/WVqp77+fy3UQERG5k4EDtbjrLj2SkxX49K9u+DQuDspdu6D+9VfkTp3q6vCIiGoN6aVLlvHQe/dCfuAA5GfPFjvGFBgIfefO0HXtCl337jBFR8PdJ6BiUV0NLl6UYv9+JSQSEcOHF7g6HCIiIipCECyt1RMmBGHBAm/8Z/poNNq1C14rViD3+efd/maOiMhdSa5ehTIpCcqkJCiSkiC7cqXYMYbYWOjbt4e+Qwfo27evEUX07VhUVwNrK3W3bjqEhnJiMiIiInfTr58Obdro8c8/Cnx4ZjQ+V78G2fnzkB88CEO7dq4Oj4ioRpCkpNyanTspCbILF+z2izIZDK1bQ9eli6WQbtcOYmCga4J1IhbVVUwUYZvx+/772UpNRETkjgQBePXVHIwdG4T5v9TDzL73oe6GBHglJCCLRTURUYmkly9bCug9e6DYsweyixft9osSiaWIjouDPi4O+g4dIHp7uyjaqsOiuoodOiTH+fMyqNVmDBrECcqIiIjcVffuOnTqpMPevUr8oH8U/0EC1GvWIGvmTECpdHV4REQuJ7161bK81a5dliL66lW7/aJEAkOrVpYx0XFx0HfqBNHX10XRVh8W1VXM2vU7Pl4Lb2/xDkcTERGRq1jHVj/wgBLv7LwXL4WGQpaWBtWff0I7aJCrwyMiqnaSGzeg2LULysJCusTu3HffbenO3bmzpSXaA4ro27GorkIGA7B6taWoHjmSXb+JiIjcXefOegQEmKHRyHGh22jEJHwO9YoVLKqJyCMIN29CsX+/ZXKxv/6C/Phxu/2iVGrpzt21q6U7d/v2EL28XBSt+2BRXYW2b1fixg0p6tY1oXt33Z2fQERERC4lkQAdOujxxx8qbAp+CM/ic6i2boXkxg2Yg4JcHR4RkVNJrl+HYu9ey5jovXuLFdEAYGje3LK8Vdeu0Hfp4pEt0XfCoroKWScoGzasADJmmoiIqEawFtUbLtyNJ1q3huLwYahXr0bepEmuDo2IqFIkaWlQ7t4NRVISlHv2QHbuXLFjDDEx0HfqZCmiu3aFuW5dF0Ras7DUqyI5OQJ+/10FABg1il2/iYiIaoqOHfUAgP37Fch/fpSlqE5IYFFNRDWOJD3dUkAX/rm9iBYFAcbmzaHr3Bn6Tp2g79QJ5uBgF0Vbc7GoriIbNqig1QqIiTGgVSuDq8MhIiKicrr7bj2UShEZGVKcuGcEOsnehuLwYchOnYKxSRNXh0dEVCpJSoplTPS+fVAkJUF+6pTdflEQYLjrLujj4iyFdMeOEAMCXBNsLcKiuopYu36PHFkAQXBxMERERFRuSqWlsN6/X4ndZ+qjdd++UG/eDHVCAnKmT3d1eEREFiYTZCdPQrFvHxQHDkCxb1+xJa4AwNCihW2daF2nTiyiqwCL6iqQkiJBUpICADBiBLt+ExER1TQdO1qK6v37FXh01CioN2+G16+/Iuc//wGkUleHR0SeSKuF4vBhKPbuhWL/figOHIAkO9vuEFEqhaFlS+g7dLCsFd25M8TAQBcF7DlYVFeBVau8IIoCOnXSoWFDk6vDISIiogpq3/7WuGrtrL4wBwRAmpYGxa5d0Pfo4eLoiMgjZGVBuXUr5Hv2WFqjDx+GoLNfUcjs7Q19u3aWIrpDBxjatoXo7e2igD0Xi2onE0Xg11+5NjUREVFNZi2qz5yRIzNPDf+hQ+G9eDG8EhJYVBNRlRCysizLW+3eDeXu3cDRowg0m+2OMQUHQ9+xo2VSsY4dYWjeHFxmyPX4L+Bkx47JcOKEHAqFiPvuY1FNRERUEwUGioiNNeD0aTkOHJCj3qhR8F68GKoNGyC8/z5EHx9Xh0hENVzRIlqxezfkyckQRNHuGGNkJPQdO0JXWESboqLACZvcD4tqJ/vtN8sEZf36aREQIN7haCIiInJXHTvqcfq0HPv2KTFgRlsYo6MhO3cOqg0bUDB6tKvDI6IaRpKebhkPvXcvlHv3QnbsWPEiOjoaui5doI+LQ53hw5EuCBBF1hTujkW1E5lMwKpV7PpNRERUG7Rvr8eSJd7Yt08BCALyR42C34cfwishgUU1EZVNFCG9dMm+iD5/vthhRYtoXefOMIeGAgAEQQDCwoDU1OqOnBzAotqJdu1SIC1NioAAM/r00bo6HCIiIqqEjh0t46qPHJGjoACQjhwJvw8/hCIpCdKrV2EKD3dxhETkNgwGyI8ds0woVjgzt/TaNbtDREGAsVkz2/rQ+k6dYK5Xz0UBkzOxqHaiVassXb8HDy6AQuHiYIiIiKhSIiJMCA42IT1diiNHFOjUqQF0XbpAuXs31L/+itznn3d1iETkCqIIybVrkB8/blsfWv7PP5AU2PdUFeVyGO6++1YR3aEDRH9/FwVNVYlFtZMYDMDmzSoAwNCh7PpNRERU0wkC0KGDHhs2qLF/vwKdOumR/8ADlqJ6zRoW1US1nShCkpIC+enTkJ06BdmpU5CfOgXZ6dPF1ocGALO/P/Tt29uWt9K3bg2o1S4InKobi2on2b1bAY1GgsBAEzp10rs6HCIiInICa1G9b5+lC5p2wACIEgnkx49DeuUKTA0auDhCInImITMTqsREqLZsgXL7dkiysko8TpRKYYyMhOGee2yt0MbYWEAiqeaIyR2wqHaSjRst30LFx2u5VBwREVEtYR1X/fffCpjNgKROHeg7dIBy714ot2xB/oQJrg2QiCpHFCE7fRqqP/6AcssWKA4cgFBkbWhRJoMxOhrG2FgYmzSBITYWxqZNYYyKApRKFwZO7oTlnxOYzcCmTZau3wMHcoIyIiKi2qJlSwPUajM0GglOn5ahaVMjtP37Q7l3L1R//MGimqiGEQoKIDtxAvKjRyFPToZy+3bILl2yO8bQvDm0/fpB268fDK1bA3K5i6KlmoJFtRMcOKDA9etS+PmZ0a2bztXhEBERkZPI5UCbNgYkJSmxf78CTZsaoevXD3jvPSiTkiDk5UH09nZ1mERUAklmJuSHDlkK6GPHIDt6FLLz5+1aogFAVCqh69oV2r59oevfnzP7U4WxqHaCDRssrdT9+mk56zcREVEt07GjHklJSuzbp8DDD+fDGBMDY2QkZBcuQLljB7QDB7o6RCIqJD17Fqrff4fq99+LdeW2MtWtC0PLljC2aAF9hw7Qde8O0cvLBdFSbcGiupJEEdi40VJU33cfu34TEVHtsGnTJqxduxYajQYRERGYNGkSYmJiSj0+Ly8PP//8M/bt24fc3FwEBwfj0UcfRdu2basx6qrRoYNlXPX+/YXfnAsCtH37wueHH6DcsoVFNZErmUyQHzxoK6TlZ87Y7TY0bgxDq1YwtmgBQ4sWMLRsCXNIiIuCpdqKRXUlHTkix5UrMqjVZvTsya7fRERU8yUlJWHx4sWYPHkyYmNjsX79esyaNQtz5syBfwlrrBqNRrz33nvw8/PDiy++iMDAQGRkZMCrlrT8tGunh0Qi4tIlGdLSJAgNNUPbvz98fvgBqj//RJbZzBl/iaqLKEJ69iyUe/dCsWcPlDt2QJqRcWu3TAZdXBy0AwZAN2AAu3JTtWBRXUnWrt99+uigVosujoaIiKjy1q1bh759+6J3794AgMmTJ+PgwYNITEzE8OHDix2/detW5Obm4t1334WscAmMkFrUEuTrK6JZMyOOHZNj/34FhgzRQt+pE8y+vpCmp0N++DAMbdq4Okyi2slshuzECSj27oVyzx4o9u6FND3d/hA/P2j79LEU0r17Q/Tzc1Gw5KlYVFeCKALr11uW0rrvvgIXR0NERFR5RqMR586dsyueJRIJWrVqhVOnTpX4nL///huxsbH44YcfcODAAfj5+aFr164YPnw4JLWkBbdjR71dUQ2FArqePaFetw6qP/5gUU3kRJLUVKi2bYNy61Yok5Ig0Wjs9otKJfRt20LfqRN0XbpA37EjOLERuRKL6ko4eVKG8+dlUCpF9O3Lrt9ERFTzZWdnw2w2IyAgwG57QEAAUlJSSnzOtWvXkJ6ejm7duuH1119HWloa5s+fD5PJhAceeKDE5xgMBhgMBttjQRCgVqttfy+Ldf+djnOmDh30WLjQG/v3K2zX1fXvbymqt2xB7n/+U22xVIYrclcbMG+OK1fuDAYoDhywFNGJiZAfO2a32+ztDX2HDtB37gx9p04w3HOP3RrRtfFfhe85x7kidyyqK8Ha9btHDx18fNj1m4iIPJMoivDz88OTTz4JiUSC6OhoZGZmYs2aNaUW1StXrkRCQoLtcVRUFGbPno3g4OByXzc0NLTSsZfXkCHAM88AR48q4OsbBh8fAA89BLzwAuRHjyLMaAQaNqy2eCqrOnNXmzBvjrPLndkMJCcDO3cCW7cCW7YA2dm39gsC0LEjMHAgEB8PSbt2UMlkUFV/2C7H95zjqjN3LKorYcMGyzfqAwey6zcREdUOfn5+kEgk0NzW3VKj0RRrvbYKCAiATCaz6+odHh4OjUYDo9FoG2dd1IgRIzB48GDbY2uLQnp6OoxGY5kxCoKA0NBQpKWlQRSr50ttmQyoXz8EKSlSbNhwA927W2YED2rXDor9+5G1dCnyx4+vllgqwxW5qw2YN8cJgoDQunWRsWULFLt3Q7FnDxT79hXr0m0KDIS+Vy9o+/SBrmdPiEFBt3beNobaE/A95zhn5k4mk5Xry14W1Q46d06K48flkMlEDBjApbSIiKh2kMlkiI6ORnJyMjp27AgAMJvNSE5ORnx8fInPadq0KXbt2gWz2WwrrFNTU1GnTp0SC2oAkMvlkMvlJe4r702QKIrVerPZsaMOq1Z5Yd8+Obp1swz70vbrB8X+/VD+/jvyHnmk2mKprOrOXW3BvJWPUFAA+T//WCYX278fOHAAdfPy7I4xe3lB3769ZVx0z54w3H03IJXeOoB5BsD3XGVUZ+5YVDto40ZLK3VcnA516vCNTkREtcfgwYPx5ZdfIjo6GjExMdiwYQN0Oh169eoFAJg3bx4CAwPx0EMPAQAGDBiAzZs3Y+HChYiPj0daWhpWrlyJgbVs/eYOHfRYtcrr1nrVALT9+8Pvv/+FctcuCPn5EGvJMmJEFSHJzIRi/34o9u2DYu9eyP/9F8JtPU7M/v7Qd+wInXVc9F13AaV8sUZU07CodpB1PPWgQWylJiKi2iUuLg7Z2dlYvnw5NBoNIiMjMX36dFv374yMDLsJYOrWrYsZM2Zg0aJFeOWVVxAYGIiBAweWuPxWTdahg6XL999/K2A0WrqEG5s0gbFhQ8guX4bir7+gGzDAxVESVTGTCbKTJ6E4eBCKgwch//tvyM+cKX5YaCj0HTtC37Ej/IcMwbWgIIicdItqKRbVDrh6VYpDhxQQBBH33suimoiIap/4+PhSu3vPnDmz2LYmTZpg1qxZVRyVazVrZoSvrxk5ORKcOCHDXXcZAUGAtn9/+Pzvf1Bt2cKimmodyY0bkP/9NxR//20pog8fhuS2rtwAYGjSxDJDd8eO0HfqBFODBoAgQBAE+IeFAamp7NJNtRaLagds3Ghppe7YUY+QELOLoyEiIqLqIJUC7drpsW2bCvv2KS1FNQBdv362ojrLbAZqydrc5JkkqalQ7t1rmVRs717IT58udozZxweGe+6xrBXdti0M7drBHBjogmiJ3AOLagew6zcREZFnat/eWlQrMGmSpbVO17kzzN7ekF67BnlysmXCJaKaQBQhvXTJMqHYnj1Q7N0L2YULxQ4zxMZC364dDO3aQd+2LYyxsfaTihF5OBbVFXT9ugT79lkmKOFSWkRERJ6lbVsDAODEiSK3UEoldD17Qr1hA1R//MGimtyX2QzZ8eOWGev37oVi3z5I09LsDhElEhhatoS+c2foO3eGrmNHiGyFJioTi+oK2rxZBVEUcM89eoSHs+s3ERGRJ4mMtHT5vnRJhqI9vbX9+kG9YQOUW7Yg56WXXBghkT3plStQr1oFxd69UBw4AEl2tt1+USaD4e67oevSxVJIt28P0c/PRdES1UwsqiuIXb+JiIg8V3i4CTKZCJ1OQGqqxPYFu65vX4iCAMWRI5CkpcEcGuriSMnjabXw+fpr+M6bB0F7677V7O0Nfbt2tgnFDG3aQFSrXRgoUc3HoroCbt4UkJSkBAAMGsSu30RERJ5GJgMaNDDhwgUZLl6UITzcssyWuW5dGNq0geLgQaj+/BP548a5OFLyZMrERPi/8YZtfLSuY0doBw2yFNEtWljeyETkNJyesgK2blXBaBTQvLkBUVEmV4dDRERELhARYekCfvGifWGi7dcPAKD6449qj4kIAKRXr6LO5MkIevhhyC5cgKlePWR+9RVu/PYb8iZPtoz3Z0FN5HQsqisgOVkOAIiL07k4EiIiInKViAjLF+sXLtjPfqzt3x8AoNi5EyhgjzaqRno9fObNQ3DhhHmiVIrcJ57A9e3boR02DBAEV0dIVKvxq6oKOHXKkq4mTYwujoSIiIhcpbSWamPz5jDWrw9ZSgqUu3ZBV9hyTVQlzGbIjh2DctcueC1ZAvnZswAAXadOyJo1C8bmzV0cIJHnYFFdAdaiumlTFtVERESeKjLS0lJ98eJt6/QKAnT9+0O2aBFUv//OopqcSxQhO3UKyl27oEhKgnL3bkg0GttuU926yH7zTRSMHMmWaaJqxqK6nHJyBKSkWNIVG2twcTRERETkKtZltW5vqQaAgoED4b1oEdTr1yPrvfcAhaK6w6NaRMjJgerPP6HavBmKpCRIMzLs9pu9vaHv1Am6bt2Q/+CDEP39XRQpkWdjUV1Op09bUlWvngkBAaKLoyEiIiJXsY6pzsqS4OZNAXXq3Lov0MfFwRQSAun161Du2MHWaqowITMTqj/+gHr9eih37oSg19v2mVUqGDp0gK5rV+ji4iwTj8nlLoyWiAAW1eVmLapjY9n1m4iIyJOp1SLq1TPh2jUpLl6UoU6dIj3YpFIUDBkCnx9+gHrVKhbVVC6S69eh2rQJ6g0boEhKgmC6tcqMMToaBYMGQdenD/T33AMola4LlIhKxKK6nE6etHwL2LQpu34TERF5uogIY2FRLcU999jfGxSMGAGfH36AavNmCPn5EL28XBQluSshPx+KvXuh3LkTyp07IT92zG6/oXlzFNx3H7SDBsHYpAnHSBO5OYeK6k2bNmHt2rXQaDSIiIjApEmTEBMTU+KxRqMRq1atwvbt25GZmYn69etj3LhxuOeeeyoTd7VjSzURERFZRUSYsG8fcOFC8Vspwz33wBgZCdmFC1D+8YdlSSPybEYj5IcPW4rov/6C4sABCAb7L2P0bdpAO2gQCgYOhCkqykWBEpEjKlxUJyUlYfHixZg8eTJiY2Oxfv16zJo1C3PmzIF/CZMj/PLLL9i5cyeefPJJhIeH4/Dhw/joo4/w3nvvIaoG/cI4eZIzfxMREZFFactqAQAEAQXDhsF37lyoV61iUe3BZKdOwWvpUqgTEiC9edNun7FBA+h69ICuWzfou3aFuW5dF0VJRJVV4aJ63bp16Nu3L3r37g0AmDx5Mg4ePIjExEQMHz682PE7d+7EiBEj0LZtWwDAgAEDcOTIEaxduxbPP/985aKvJrm5Aq5e5czfREREZGFdVuvCBWmJ+wuGD4fv3LlQJSZCuHkTYp061RkeuZCQnw/V2rXwXroUigMHbNvNAQGWCca6d4eue3eYIiLYrZuolqhQUW00GnHu3Dm74lkikaBVq1Y4depUic8xGAxQ3LachEKhwMmTJ0u9jsFggKFIlxhBEKBWq21/L4t1/52Oq4gzZyzjqUNCTAgMBIDa+QuwKnLnCZg3xzBvjmPuHMO8kTOV2VINwNikCQwtWkB+7BjUGzYgf9y46gyPqpsoQn7kCLyWLIF69WpIcnMtm6VSaPv3R/7YsdD16gXIOJ0RUW1Uof/Z2dnZMJvNCAgIsNseEBCAlJSUEp/TunVrrFu3Ds2bN0e9evWQnJyMffv2wWw2l3qdlStXIiEhwfY4KioKs2fPRnBwcLljDQ0NLfexd7J5s+XnXXdJERYW5rTzuitn5s6TMG+OYd4cx9w5hnkjZ7C2VKelSVFQABR+92+nYPhwS1G9ahWL6lpKkp4O9W+/wWvFCsiPH7dtN0ZGIv+hh5D/wAMwh4S4MEIiqg5V/nXZxIkT8c0332DatGkQBAH16tVDr169kJiYWOpzRowYgcGDB9seW1sV0tPTYTSWPaZZEASEhoYiLS0Nouic9aT37vUF4IOIiDykpmY75ZzuqCpy5wmYN8cwb45j7hzjzLzJZLIKfdFLtU+dOmb4+pqRkyPBpUuyEudcKRg2DH7vvw/F7t2QpKbC7AFfzHsErRaqP/6A14oVUG7bZlv+SlQqUXDffcgfOxb6Ll3YtZvIg1SoqPbz84NEIoFGo7HbrtFoirVeF33Oq6++Cr1ej9zcXNSpUwdLlixBvXr1Sr2OXC6HvJSF7Mt7IySKotNuNk+dsqSpSRODR9zAOjN3noR5cwzz5jjmzjHMGzmDIACRkUb8+68CFy9KSyyqTQ0aQNehA5T790O9di3ynnjCBZGSU4gisGcP/L7+2tK9OyvLtkvfti3yH3gABUOHQizlfpiIajdJRQ6WyWSIjo5GcnKybZvZbEZycjKaNGlS5nMVCgUCAwNhMpmwd+9etG/f3rGIXeBWUc2Zv4mIiMgiIsI6WVnpbRQFhfPQqFetqoaIyNmkV67AZ+5cBHfvDnTpAu/FiyHJyoIpLAw5zz6La9u3I2PtWuSPH8+CmsiDVbj79+DBg/Hll18iOjoaMTEx2LBhA3Q6HXr16gUAmDdvHgIDA/HQQw8BAE6fPo3MzExERkYiMzMTK1asgCiKGFZDlpfIyxNw5cqtlmoiIiIiwNJSDZQ+WRkAaIcMgfh//wfF4cOQnjsHU3R0dYVHDhJycqBavx5eCQlQ7t59a4dajfxBg5A/ahT0XbsC0pJnficiz1PhojouLg7Z2dlYvnw5NBoNIiMjMX36dFv374yMDLuZVQ0GA3755Rdcv34dKpUKbdq0wbPPPgtvb2+nvYiqdPq0JUV165oQGMjugkRERGRhbam+eLH04socFARdjx5QJSZCvXo1cl94obrCo4owGqHcuRPqhASoN22CoNUCAERBgD4uDgWjRiHgsceQlZvL4SNEVIxDE5XFx8cjPj6+xH0zZ860e9yiRQt89tlnjlzGLbDrNxEREZXEuqxWWd2/AcuEZarERKhXrkTutGmcwMpdiCJkR4/CKyEB6lWrIE1Pt+0yxMSgYNQoFNx/P0zh4RAEAQG+vkDhUllEREVxsbw7sLZUs6gmIiKioqzLal25IoXJVHpvYG18PESVCvKzZyE7ehTGu+6qxijpdpLUVKhXrYJXQgLkJ07YtpsCA1EwfDgKRo2C4e67+eUHEZUbi+o7OHnSMgs5x1MTERFRUaGhJigUIvR6ASkpUjRsaCrxONHXF9q+faFevx5eq1Yhm0V1tRNyc6HatAnqX3+FcudOCIVduEWFAtr+/ZE/ahR0vXsDpaw+Q0RUFhbVd8CWaiIiIiqJVAo0bGjE2bNynD9felENAAUjRkC9fj3Uq1Yhe/p0QFKhBVjIAUJ+PpRbtkC9di1UW7faxkkDgK5jRxSMHImCwYM5azcRVRqL6jLk5wu4dMmSopLWnyQiIiLPFhFhwtmz8sIZwPWlHqft3RtmX19IU1Oh2L8f+k6dqi9IT6LVWsavr1kD5R9/QFJQYNtljIpC/siRlnHSEREuDJKIahsW1WU4c8aSnqAgEwIDzS6OhoiIiNxNeZbVAgCoVNAOGgSvZcugXrmSRbUziSIU+/fD66efoNq8GZIik4kZGzVCwdChKBgyBMaWLTlOmoiqBIvqMpw8ya7fREREVDrrZGVlLatlVTB8OLyWLYNq3Tpkvfsux+9WkpCTA/Wvv8L7xx/tJhwz1q8P7ZAhKBg6FIbWrVlIE1GVY1FdBo6nJiIiorKUd1ktANDFxcEUHAxpejqUiYnQDRhQ1eHVSrJjx+C9eDHUv/0GSV4eAMCsUqHg/vuRP3o0DO3accw6EVUrFtVl4MzfREREVJaiLdWieIdGUZkMBSNGwOe77+D34YdI79MHkPFWrFwKCqDeuBFeixdDuX+/bbOhcWPkP/oo8keNgujv78IAiciT8Td5GdhSTURERGVp2NAIQRCRlyfBjRsS1K1b9hwsuc89B6/lyyE/fhzeCxYgb/Lkaoq0BhJFyI8cgdcvv0C9ahUk2dmWzTIZtPfei7xHH4U+Lo7du4nI5VhUl6KgQMClS5bxUSyqiYiIqCRKJRAWZkJKigwXLkjvWFSbAwORPX06Al59Fb4ff4yCIUNgDg2tpmhrBsmNG1D/9hu8li2D/Phx23ZjeDjyx45F/tixzBkRuRUW1aU4c0YGURQQGGi64wckERERea6ICEtRffGiDO3b33nIWP7YsfD6+Wco/vkHfu++C82XX1ZDlG5Or4dy+3Z4LV8O1R9/QDBY8igqlSgYOBD5Y8ZA360bx0oTkVtiUV0KzvxNRERE5REZacTu3cpyzQAOAJBIkPX++6g7aBC8Vq1C/kMPQd+1a9UG6Y5MJij27IF69Wqo16+HRKOx7dK3bo380aNRMHw4xIAAl4VIRFQeLKpLwfHUREREVB4REZbJysozA7iV4e67kT9+PLwXLYL/jBlI//13QKGoqhDdhyhCfvgw1CtXQr1uHaRpabZdpuBgFAwbhvwxY2Bs0cKFQRIRVQyL6lKcOmUtqjnzNxEREZXOuqzWxYsVu63KfvVVqNatg/z0afjMn4/cp5+uivDcgpCdDe9Fi+D1yy+QXbhg227290fBoEEoGDbMMumYtJyt/UREboRFdSlOnbIup8WWaiIiIiqddVmtCxcqVhCKAQHInjEDdV58ET6ffor8YcNgDg+vihBdRpKZCe/58+G9YIFt9m6zSgXtvfeiYPhw6Hr2tMz2RkRUg7GoLkFBAWzjolhUExGRJ9q0aRPWrl0LjUaDiIgITJo0CTExMSUeu23bNnz11Vd22+RyOZYsWVIdobqctaU6I0OK3FwBPj5iuZ9b8MAD8Pr5Zyj374f/22/j5nffVVWY1UqSlgafb7+F148/QlJQAAAwxMYid8oUaAcPhujt7eIIiYich0V1Cc6etcz8XacOZ/4mIiLPk5SUhMWLF2Py5MmIjY3F+vXrMWvWLMyZMwf+/v4lPketVmPu3LnVHKl78PcXUaeOCTdvSnHxohQtW1bgC/nCScuC4+OhXr8e+du3W1pvayjp5cvw+fJLeC1bBkGvBwDoW7VC7vPPQxsfz9m7iahW4m+2EhTt+i0ILg6GiIiomq1btw59+/ZF79690aBBA0yePBkKhQKJiYmlPkcQBAQEBNj98STWLuAVHVcNAMYWLZA3cSIAwH/GDECnc2ps1UF27BgCnn8eIV27wvvHHyHo9dB16IAbP/6IjI0boR00iAU1EdVabKkuAZfTIiIiT2U0GnHu3DkMHz7ctk0ikaBVq1Y4depUqc/TarV4+umnIYoioqKiMHbsWDRs2LDU4w0GAwyGW5OBCoIAtVpt+3tZrPvvdFx1iogw4Z9/LEW1I3Hlvvwy1GvWQHb+PHy/+Qa506Y5P0g4OXeiCMVff8H766+h2rbNtlnXowdyp06FvnNnQBDgPv9KjnPH91xNwdw5hnlznCtyx6K6BFxOi4iIPFV2djbMZnOxluaAgACkpKSU+Jz69etjypQpiIiIQH5+PtasWYM33ngDn376KYKCgkp8zsqVK5GQkGB7HBUVhdmzZyM4OLjcsYaGhpb72Kp2113AqlVAerofwsL8Kn6CsDDgs8+AcePg+/nn8B0zBmjb1ulxWlUqd0YjsGIF8NFHwD//WLZJJMCoUcArr0DZvj1q69Rj7vSeq2mYO8cwb46rztyxqC7ByZPW7t9cTouIiOhOmjRpgiZNmtg9fuGFF/DHH3/gwQcfLPE5I0aMwODBg22PrS0K6enpMBrL/lJbEASEhoYiLS0Nolj+ScGqUlCQGkAAjh3TITU107GT9OqFwO7dody5E+YePXBz/nzonTy+ujK5E3Jzof7lF3h/9x1kV64AAESVCvljxyLviSdgioiwHJia6tSY3YE7vudqCubOMcyb45yZO5lMVq4ve1lU36agALh0iTN/ExGRZ/Lz84NEIoFGo7HbrtFoyj1OWiaTISoqCmlpaaUeI5fLIZfLS9xX3psgURTd5mbz1lrV0krFlPnddwh8/HEod+1C4COPQPPppygYOdJZYdpUJHfSy5fh/b//wevnnyHJyQEAmIKCkDdxIvIefRRiYKD1pE6P092403uupmHuHMO8Oa46c8cZI25z9qwMZrOAgAAzgoM58zcREXkWmUyG6OhoJCcn27aZzWYkJyfbtUaXxWw249KlS6hTp05Vhel2rEX11atSGCrR0U3088ONH39E/vDhEIxG1Hn+efh89VX1F6yiCMW+fagzeTJC4uLg8913kOTkwBgdDc0HH+Da3r3IfeGFWwU1EZEHY0v1bU6fvtX1m/MCEBGRJxo8eDC+/PJLREdHIyYmBhs2bIBOp0OvXr0AAPPmzUNgYCAeeughAEBCQgJiY2MRGhqKvLw8rFmzBunp6ejbt68LX0X1qlfPDJXKDK1WgitXpIiKMjl+MqUSmi++gLlePfh8+y38Zs2CJDUV2TNnAlKp02IukV4P9dq18J4/H4ojR2ybtT16IO/xx6Hr3ZuzeBMR3YZF9W048zcREXm6uLg4ZGdnY/ny5dBoNIiMjMT06dNt3b8zMjLsZlXNzc3Ft99+C41GA29vb0RHR+O9995DgwYNXPQKqp8gWGYAP3lSgosXZZUrqgFAIkH2//0fTKGh8H/7bfj873+QXruGm59/DqhUzgkagJCdDfmRI1AcPgz5oUNQ7NsHaUYGgMLx0iNHIu+xx2Bs2tRp1yQiqm1YVN+GM38TEREB8fHxiI+PL3HfzJkz7R5PmDABEyZMqPqg3FxEhBEnT8px4YLzWpPznngCpnr1UGfaNKjXr4fkxg1k/vADxKLj241GCHo9oNVC0OshGAyWbUYjYDBYfhY+FvR6IC0N/jt2QH7oEORnzxa7pik0FHmPPor8hx+Gmd27iYjuiEX1bawzf8fGcuZvIiIiKr/ISEvr9IULzr290g4bhht16yLwsceg3LMH9Tp2BORyQKeDoNNBMFd8DhivIn83NmwIQ+vW0N9zj+Vn+/aAQuG8F0BEVMuxqC5Cq7XM2gkATZuypZqIiIjKr+gM4M6m79oVGb/9hqBHHoG0jFnVRUEAlEqIUikgl0OUyQCZDKJcbvspj41FTvPm0LduDUPr1jCXspY4ERGVD4vqIs6ds8z87e9vRkgIZ/4mIiKi8rO2VF+8WDW3V8YWLXBt1y7IzpyxFM4KBcTCn9bHkMlQ1kyrgiAgLCwMuampXKaHiMhJWFQXcf265Zvl8HATZ/4mIiKiCrFfq7rM2tZxKhWMd91VBScmIiJHcU2EIrRay6efSsVvbomIiKhiGjQwQSoVodVKcO0ab7GIiDwFf+MXodNZfrKoJiIiooqSyy293YCq6wJORETuh0V1EWypJiIiosqIiLDOAO78ycqIiMg9saguQqezFNVKJYtqIiIiqrhb46rZUk1E5ClYVBdhbalmUU1ERESOiIy0FNWXLrGlmojIU7CoLsLaUs3u30REROSI+vUt3b9TUlhUExF5ChbVRdzq/u3iQIiIiKhGYlFNROR5WFQXwe7fREREVBnWojo1VQqTycXBEBFRtWBRXYR1SS0W1UREROSIevXMkEpFGI0C0tN5m0VE5An4274IjqkmIiKiypDJgHr12AWciMiTsKgugutUExERUWXVr28GAFy9yqKaiMgTsKgugmOqiYiIqLLCwy3LarGlmojIM7CoLuJW928XB0JEREQ1lrWlmkU1EZFnYFFdxK0ltdhSTURERI7hslpERJ6FRXURnP2biIiIKis8nEU1EZEnYVFdBMdUExERUWWxpZqIyLOwqC6CS2oRERFRZVmL6uvXpbZecEREVHuxqC6CY6qJiIiosgIDzbYv6NPS2FpNRFTbsagu4tY61S4OhIiIiGosQQDCwtgFnIjIU7CoLoJjqomIiMgZOK6aiMhzsKguwjruiWOqiYiIqDKsRfXVqyyqiYhqOxbVhUSRY6qJiIjIObisFhGR52BRXchgAMxmFtVERERUeez+TUTkOVhUF7K2UgPs/k1ERESVw6KaiMhzyFwdgLsoWlQrlS4MxF2ZzZBeuQKYTI6fIjgYoo+PE4MiIiJyT+z+TUTkOVhUFyo6nloQ7nCwJzGZoF6zBj6ffw75qVOVOpVZpUL+I48gd8oUmOvVc1KARERE7sfaUp2VJUFengBvb/aCIyKqrVhUFyoosPzkeOpCBgPUv/0G3y++gOz8eQCAKJdDdLQZ32yGJD8fPt9/D+/Fi5E/dixynn4a5vBwJwZNRETkHnx8RPj5mZGdLUFKihSxsUZXh0RERFWERXUha0u1x4+n1uuh/ukn+MybB9mlSwAAc0AAcidPRt7EiRD9/R07ryhCmZgI3zlzoPj7b3gvXAivJUuQP3o0cp99FqZGjZz4IoiIiFwvPNyE7GwJrl5lUU1EVJuxqC7k8ctpabXw+uUX4JtvEHD5MgDAVLcu8p58Ennjx1d+LLQgQNenD3S9e0Oxaxd858yBcvdueC9ZAq9ffkHByJHQDhgASEqeO08UBBjatIE5OLhycRAREVWTsDATjh+Xc1w1EVEtx6K6kFbrmUW1UFAArx9/hM8330B67RoAwFSvHnKnTEH+ww9DVKudfEEB+m7dcKNbNyj27oXP3LlQbd8Or+XL4bV8eZlPFVUq5I0bZxmTHRbm3LiIiIicjDOAExF5BhbVhW61VLs4kGoi5ObCe9EieH/7LaQ3bgAATPXrQzpjBq4PHOj42OkK0HfqhMylSyE/eBA+330H6dWrpcebnQ35mTPw+eEHeP/4I/LHjLF0G2/QoMrjJCIicoR1BvCrV1lUExHVZg4V1Zs2bcLatWuh0WgQERGBSZMmISYmptTj169fj99//x0ZGRnw8/NDp06d8NBDD0GhUDgcuLN5yphqISsL3v/7H3zmz4dEowEAGCMikPvssyh44AGERUQAqamAWH15MLRti5vffFP2QaII5c6d8JkzB8q9e+H944/w+vln5I8aZSmuo6KqJ1giIqJyYks1EZFnqHBRnZSUhMWLF2Py5MmIjY3F+vXrMWvWLMyZMwf+JUxi9ddff2Hp0qWYMmUKmjRpgtTUVHz11VcQBAGPPvqoU16EM+h0lp+1tfu3kJkJn/nz4f2//0GSkwMAMEZHI+f551EwYgQgk0Fw57XEBAG6Hj2g69EDit27LWOy//oL3r/8Aq/ly1EwYgRyn38exjK+3CEiIqpOLKqJiDxDybNClWHdunXo27cvevfujQYNGmDy5MlQKBRITEws8fiTJ0+iadOm6NatG0JCQtC6dWt07doVZ86cqXTwzmQdU13bWqolGRnwnTUL9Tp3hu/cuZDk5MDQpAlufvklrm/bhoIHHgBkNWsUgL5LF9xYtgzpq1dD26cPBLMZXr/+iuBevVBnyhTITpxwdYhERER2RXU1dgAjIqJqVqFqymg04ty5cxg+fLhtm0QiQatWrXDq1KkSn9O0aVPs3LkTZ86cQUxMDK5du4Z//vkH3bt3L/U6BoMBBoPB9lgQBKgLJ8y6U2uqdX9FW111Osv3CyqV6N4ttuUkSUuD99dfw/vHHyFotQAAQ4sWyJ02DdpBgwCJBLe/Skdz5yrGDh1w86efID98GD5z5kC1eTPUa9ZAvWYNtAMHImfaNBhbtaryOGpa3twF8+Y45s4xzBtVt7AwS1Gt1Qq4eVOCwECziyMiIqKqUKGiOjs7G2azGQEBAXbbAwICkJKSUuJzunXrhuzsbLz55psAAJPJhP79++P+++8v9TorV65EQkKC7XFUVBRmz56N4AospxQaGlruY4FbE5QFBKgRFubkGa+r06VLwOzZwA8/3OrT3qED8OabkA8ejDrluJmsaO5cLiwMiI8HjhwB3nsPSEiAauNGqDZuBO67D3jzTaBTpyoPo8blzU0wb45j7hzDvJVPRedPsdq1axfmzp2L9u3b49VXX62GSN2XUgkEB5uQni5FSgqLaiKi2qrK+/0ePXoUK1euxOOPP47Y2FikpaVhwYIFSEhIwKhRo0p8zogRIzB48GDbY2urQnp6OoxGY5nXEwQBoaGhSEtLg1iBvlbp6d4A/GA25yM1Navcz3MbJhN833kH3gsXQihs5dd36ICcF16AvmdPQBCAtLQyT+Fo7txGcDAwdy5kzzwDn88/h2rVKgjr1wPr10PXowdyXngBhioormt83lykKvMmSU2F94IFZc4oX1miSoWCUaOg79KlQs8TcnPhtXQphNxc5D77LODAhI18zznGmXmTyWQV+qK3pqno/ClW169fx48//ojmzZtXY7TurX59S1F99aoMd91V9j0MERHVTBUqqv38/CCRSKApnDXaSqPRFGu9tlq2bBl69OiBvn37AgAaNWoErVaL7777Dvfffz8kkuLDuuVyOeRyeYnnK++NkCiKFbppKii4tU51TbxJVa1bB5/vvwcA6Lp0sRTTcXGWYhqo0GzeFc2duzHExuLmF19A+sIL8P3iC6h//RXKHTug3LHDkptp06Dv2vVWbpykpufNVZyZN+mVK/CZNw9ey5ZB0Oudcs6yeP38M3SdOlneU927l/meKmnmfdmRI5aZ7x1cwo7vOccwb3dWdP4UAJg8eTIOHjyIxMREuyFgRZnNZnzxxRcYPXo0jh8/jry8vGqM2H2Fh5tw+DCQklLhaWyIiKiGqFBRLZPJEB0djeTkZHTs2BGA5UM0OTkZ8fHxJT5Hp9MVG79WUiHtajV9SS3vxYsBADlPP42cGTNcHI17MEVHQ/PZZ8h54QVLobV8OZS7d0O5ezf07dsjZ9o06Hr1cnpxTdVPev685d84IQFCYW8WXadO0A4YAFTR7xvZmTPwWrECyr17oRw7Fvq2bS3vqT597N5Tws2bt2bez84GABgjIyFNS4P6998hPP44Mr//HlCpqiROoopyZP4UAEhISICfnx/69OmD48ePV0OkNYN1XDVnACciqr0q3P178ODB+PLLLxEdHY2YmBhs2LABOp0OvXr1AgDMmzcPgYGBeOihhwAA7dq1w/r16xEVFWXr/r1s2TK0a9fOrYrrmrykluzMGSh374YokSB/wgRXh+N2TI0aIevDD5EzdSp8vv4a3kuXQnHgAIIefhj61q0thVD//iyuayDZmTPwmTsX6lWrIJgtYxV13bpZWo4r2C3bETnTpt16Tx08iKDx46G/+27kTp0Kfbt28P7+e3gvXAhJYYudoUkT5E6dioIhQ6BISkLghAlQbd2KwIkTcfN//4OorsHzOVCt4cj8KSdOnMDWrVvx4Ycflvs6rpiU1BXCwy2/m65edY+lK2tS7twJ8+Y45s4xzJvjXJG7ChfVcXFxyM7OxvLly6HRaBAZGYnp06fbPnwzMjLsXsDIkSMhCAJ++eUXZGZmws/PD+3atcPYsWOd9iKcwbqkVk0sqr0KW6l1ffvCFB7u4mjclzk8HNnvvYfc556DzzffwOvHH6E4fBhBEyfC2LAhRF9fx08ul6NukZtDKqfK5M1shuzkSQiF3Xi1ffogZ+pUGNq3d2KAdwihfn1kv/vurffU4sVQHDmCwMcegygIttgMLVogZ+pU28z7AKDv3h2ZP/2EwPHjodqxA4GPPILMRYsgenuXfkFRhHLLFvgsWABoNKXmTpRKoevdG3mTJ8McGOj0101UVEFBAb744gs8+eST8PPzK/fzXDEpqSvcdZflZ0aGe02EWhNy546YN8cxd45h3hxXnbkTxBo0sCw9Pd3uW+2SCIKAsLAwpKamVmjM3HPPBeC337zw5ptZeOqpmjMOTCgoQL127SDJysKNH3+0dD119FwO5q6mkty4Ae/vvoP3ggW2lkSqeQruvRe5U6fC0Lq1q0O59Z5auBCS3Nxy9YRQ7N+PwIcfhiQ3F7qOHZH5448QfXzsDzKbodq0CT5z50KRnFzueMxeXsh/9FHkPvkkzLV4Uq3ycubvOLlcXmsnKjMajXj44Yfx4osv2oZ6AZaeaPn5+cVm9L5w4QJeffVVu95n1vwKgoA5c+aUeGNTWkt1VU5K6gp//y3HkCF1ER5uxP796a4Op0blzp0wb45j7hzDvDnOFROTVvns3zVFTR1TrVq9GpKsLBgbNbKMD6ZyMwcFIef115E7ZQrkR47YWhUdERQUhBs3bjgxOs9Q2bwZGzSAqXFjJ0ZUObb31NNPQ5KebontDl2P9B064MbSpQh6+GEo9+1D0NixuLFkCUQ/P8BkgmrdOvh+/jnkJ05YrlFYKPsMG4YbmZklnlOSkQHv776DIjkZPl9/Da8FC5A/bhxyp0yBOSzM6a+bapeKzp9Sv359fPzxx3bbfvnlF2i1WkyYMAF169Yt8TqumJTUFcLCLF8QpKVJYTSKkLrJ0OqakDt3xLw5jrlzDPPmuOrMHYvqQtai2sFJeF3GOkFZ/sMPV9mETLWdGBAAfY8eDj9fEAQgLAx6D2nhd5banDfR3x+mMpYdup2hXTvc+OUXBD30kGVs9oMPIm/8ePh8/TXkZ84AAMy+vsibOBF5kydDDAqCzx1yV3D//VBu2QLfuXOh+Ocf+PzwA7x//BH5Dz6I3GeegalBA6e8VqqdKjJ/ikKhQKNGjeye7104jOH27Z4oJMQMmUyE0Sjg2jUJ6tfnWtVERLUNi+pCNXFMtfzwYSgOH4YolyP/wQddHQ4RVYKhdWtkLFuGoAcfhOLwYSheegkAYPb3R+7jjyNv0iSIhXNXlGvaDUGArn9/6Pr1g3LHDvjMmQPlvn3wXrwY3osXQ5R57q9/xeLF0PXs6eow3FpF50+h0kmlQGioCVeuyJCSImVRTeQERqMR+fn5rg6jyhUUFEBfDUuE1kYVyZ2Xlxdklbwv8ty7qttYZ/+uSd2/vX78EQBQcN99MAcFuTgaIqos41134UZCAoLGjQP0euQ98QTyJkyo3CR6ggBdz57Q9egBxe7d8J0zB8pdu2xLjxGVJj4+vtTlMmfOnFnmc5955pkqiKjmql//VlENcFJLosowGo3Iy8uDr6+vW60kVBXkcvkd55OikpU3d2azGTk5OfD29q5UYc2iutCt7t81o6gWsrKgXrkSAJA/fryLoyEiZzE2a4Zru3dbhnM4szVZEKCPi8ONuDhIMjNvfZPoQQRBQL169fitP1W78HCuVU3kLPn5+R5RUFP1kEgk8PX1RW5uboVWsLgdi+pCNa2o9kpIgESrhaFpU+iLzM5KRLWAQlGlp/fUZbas4/iRmgrUsnH85N7q12dRTeRMLKjJmZzxfuI7slCNGlMtirau33njx99xdmEiIiJyHRbVRES1G4vqQtaWarXa/YtqxZ49kJ8+DbOXFwpGjnR1OERERFQGa1F99SqLaiJyjk6dOuH7778v9/FJSUkIDw9HVlZWFUYFLFu2DM2bN6/Sa7gjdv8udKul2sWBlIN1Ga2CESMqN4ERERERVTm2VBN5rvDw8DL3v/jii3ipcMWPitiwYQO8vLzKfXz79u3xzz//VGrcMJWORXUhrdby0927f0vS06HauBFAYddvIiIicmvWojojQwqtFlCpXBwQEVWbf/75x/b3NWvW4OOPP8aOHTts27y9vW1/F0URJpOpXLNQB1Vw5R+FQoGQkJAKPYfKj92/YZmvxtr9292X1PL6+WcIBgP0bdrAeNddrg6HiIiI7qBOHREqlWV96tRUtlYTeZKQkBDbH19fXwiCYHt85swZNGnSBFu3bkV8fDyioqKwb98+XLhwARMnTkSLFi0QGxuLQYMG2RXiQPHu3+Hh4Vi6dCkee+wxNG7cGF27dsXvv/9u2397929rN+1t27ahZ8+eiI2Nxbhx43Dt2jXbc4xGI9588000b94cLVu2xKxZszB16lRMmjSpQjlYtGgR4uLiEBkZie7duyMhIcG2TxRFfPLJJ+jQoQOioqLQtm1bvPnmm7b9CxcuRNeuXREdHY3WrVtj8uTJFbp2dWFRDcBgAESxBkxUZjLBa8kSAGylJiIiqikEgctqEVUFUQTy8wWX/HHmIhLvv/8+pk+fjm3btqF58+bIy8tDnz598Ouvv2Lz5s3o1asXJk6ciKtXr5Z5nk8//RRDhgzBli1b0LdvXzz77LO4efNmqccXFBTgm2++weeff47ffvsNV69exbvvvmvb/+WXX+K3337Dp59+itWrVyMnJwebN2+u0GvbuHEj3nrrLTzxxBP4888/8fDDD+PFF1/Erl27AADr16/H999/j9mzZ+Ovv/7CDz/8gGbNmgEADh8+jP/7v//DK6+8gh07dmDJkiXo3Llzha5fXdj9G7daqQH3LqqViYmQXbkCc0AACoYMcXU4REREVE7165tx9iyLaiJnKigQEBsb5pJrnz6dCi8v59QNr7zyCnr06GF7XKdOHbRs2RJyuRwGgwGvvvoqNm3ahN9//x0TJ04s9TyjR4/G8OHDAQCvvfYafvjhBxw6dAi9e/cu8XiDwYAPPvgAkZGRAIAJEyZgzpw5tv0LFizAc889h4EDBwIAZs2aha1bt1botX3zzTcYPXo0JkyYAABo3LgxDh48iG+++QZdu3bF1atXERwcjO7du0MulyM8PBxt2rQBAFy9ehVeXl7o168ffHx80KBBA9zlpj112VKNW5OUAe49UZl1grL80aMBtdrF0RAREVF5cQZwIirN3Xffbfc4Ly8P77zzDrp27YrmzZsjNjYWp0+fvmNLddFZt728vODr64uMjIxSj1er1baCGgDq1atnOz47Oxvp6em45557bPulUmmxWO/kzJkzaN++vd22Dh064MyZMwCAwYMHQ6vVokuXLnjllVewceNGGI1GAECPHj3QoEEDdOnSBc899xx+++03FBQUVOj61YUt1bAfT+2uSz4r9uyBsvCbobyHH3ZxNERERFQR7P5N5HxqtYjTp1Nddm1nuX0W73feeQc7d+7EzJkz0bBhQ6hUKjzxxBPQ6/Vlnkcul9s9FgQBZrO5QseLzuzXXg7h4eHYsWMHdu7ciZ07d2L69On4+uuv8euvv8LHxwebNm1CUlISduzYgY8//hiffPIJNmzYAH9//2qN807YUg33n/lbyM1FwAsvQBBF5D34IEyNG7s6JCIiIqoAa0s1Jyojch5BALy8RJf8qcqGuAMHDuCBBx7Afffdh+bNmyMkJARXrlypuguWwM/PD8HBwTh06JBtm8lkwr///luh88TExODAgQN22/bv34/Y2FjbY7VajQEDBuDdd9/FihUr8Pfff+PEiRMAAJlMhh49euCNN97Ali1bcOXKFdt4bHfClmrcaql216La7513ILt0CcYGDZA9c6arwyEiIqIK4lrVRFReUVFR2LhxIwYOHAiTyYSPPvqozBbnqjJx4kTMmzcPUVFRaNy4MRYsWICsrCwIFfhGYcqUKXjqqafQsmVLdO/eHX/88Qc2btyIX375BYBlFnKz2Yw2bdpArVbjt99+g0qlQnh4OP744w9cunQJnTp1QkBAAP7880+YzWY0dsMGRhbVuDWm2h2LamViIrwLZ/zWfPopRF9fF0dEREREFWXt/s0x1UR0J2+99RZefPFFDB48GHXq1MEzzzyD3Nzcao/jmWeeQXp6OqZOnQqpVIpx48ahZ8+ekErL/3ssPj4eb7/9Nr799lu89dZbaNiwIT799FPExcUBAPz9/TFv3jy8/fbbMJlMaNasGRYuXIjAwED4+/tj48aN+PTTT6HVahEVFYUvv/wSTZs2raqX7DBBrO6O85WQnp4Og8FQ5jGCICAsLAypqanlHhOQlKTAAw/URWysAdu2pTsjVKcQNBqE9O0LaVoach97DNnvvFO113Mgd8S8OYp5cxxz5xhn5k0ulyM4ONhJkVFRVfVZ72r5+bdmKT5xIhW+vq6Juybmzh0wb45zdu6ys7Ph5+fnhMjcn3X2b3dhNpvRs2dPDBkyBK+++qqrwylTRXNX2vuqvJ/3bKmG+3b/9n/zTUjT0mCMjkbO66+7OhwiIiJykJeXiIAAMzQaCVJSpGja1OjqkIiIynTlyhVs374dnTt3hl6vx4IFC3D58mWMGDHC1aG5HU5UhqJFtYsDKUK1fj28fvsNokSCm3PmQOQSWkRERDUal9UioppEEAQsX74c9913H4YPH44TJ07gl19+sZtkjCzYUo1bY6pVKvdoqZakp8P/P/8BAOQ+8wwM7dq5OCIiIiKqrPr1TTh2TM7JyoioRggPD8fq1atdHUaNwJZqADqd5adbdP8WRfi/+iqkN2/C0Lw5cl580dURERERkRNwBnAiotqJRTXcq6VavWIF1L//DlEux83PPwcUCleHRERERE7AGcCJiGonFtVwnyW1pFevwv///g8AkPPSSzC2aOHSeIiIiMh52FJNRFQ7sajGrYnKXN1S7f/aa5Dk5EDfti1yp0xxaSxERETkXCyqiYhqJxbVcI/Zv2WnTkG1datltu/PPgNknEOOiIioNrEW1ampUnCpYyKi2oNFNdxjnWqvH38EAGgHDIApJsZlcRAREVHVCA01QRBE6HQCbtzgLRgRUW3B3+gAtFrLz/IU1UJODpz99bKQnw+vhAQAQP4jjzj13EREROQeFAogJMQMgF3AiahiRo0ahf8rnHsJADp16oTvv/++zOeEh4dj06ZNlb62s85Tlk8++QT9+/ev0mtUJRbVKP+YasXu3Qhr1gy+//2vU6+vXr0akuxsGCMjoevRw6nnJiIiIvdh7QLOGcCJPMOjjz6KcePGlbhv7969CA8Px7Fjxyp83g0bNuDhhx+ubHh2Sits//nnH/Tu3dup16ptWFSj/LN/K3fsAAD4fPstpJcuOe36XosXAwDyHn4YkPCfhIiIqLbiZGVEnmXs2LHYsWMHUlJSiu1btmwZWrdujRYOrPgTFBQEtVrtjBDvKCQkBEpXTj5VA7CCQ/lbqqUXLwIABKMRvnPmOOXa8kOHoDhyBKJCgYIxY5xyTiIiInJPDRtaiurLl1lUE3mCfv36ISgoCMuXL7fbnpeXh3Xr1uHBBx9EZmYmnn76abRr1w6NGzdG3759sWrVqjLPe3v373PnzuH+++9HdHQ0evXqhR2FjYFFzZo1C926dUPjxo3RpUsXfPjhhzAYDAAsBf6nn36KY8eOITw8HOHh4Vi2bBmA4t2/jx8/jgceeACNGzdGy5Yt8eqrryIvL8+2f9q0aZg0aRK++eYbtGnTBi1btsT06dNt1yoPs9mMzz77DO3atUNUVBT69++PxMRE2369Xo8ZM2agTZs2iI6ORseOHfHFF18AAERRxIcffogOHTogKioKbdu2xZtvvlnuazuCU0zjVkv1nYpqWWFRDQDqhATkPPssTNHRlbq2d2ErdcHgwTAHBlbqXEREROTeGjUyAgAuXWJRTVRpogihoMA1l1arAUG443EymQyjRo3CihUrMHXqVAiFz1m3bh1MJhOGDx+OvLw83H333Xj66afh6+uLP//8E88//zwaN26MVq1a3fEaZrMZkydPRt26dbF27Vrk5OTgrbfeKnact7c3PvvsM4SGhuL48eN49dVX4ePjg6effhpDhw7FyZMnsW3bNvzyyy8AAF9f32LnyM/Px7hx49CuXTusX78eGRkZeOWVVzBjxgzMKdLomJSUhJCQEKxYsQLnz5/HlClT0LJly1K7wt9u/vz5+PbbbzF79my0bNkSy5Ytw8SJE7F161ZER0fjf//7H37//Xd88803CA8PR0pKiq03wPr16/Htt9/iq6++QtOmTXH9+nWHuthXBItqlH9JLdmFCwAAY1QUZOfPw/ezz6Ap/EbEEYJGA9Xq1QCA/PHjHT4PERER1QwREZaW6kuXeAtGVFlCQQHCYmNdcu3U06chenmV69gHH3wQX3/9NXbv3o24uDgAlpbhQYMGwc/PD35+fnjqqadsx0+aNAnbtm3D6tWry1VU79y5E2fOnMGSJUsQGhoKAHjttdeKjbmeNm2a7e8NGzbEuXPnsHr1ajz99NNQq9Xw9vaGVCpFSEhIqddauXIldDod5s6dC6/C1//ee+9hwoQJmDFjBoKDgwEA/v7+mDVrFqRSKWJiYtC3b1/89ddf5S6qv/32Wzz99NMYNmwYAGDGjBlISkrC/Pnz8f777+Pq1auIiopCx44dIQgCGjRoYHvu1atXERISgu7du0MulyM8PBxt2rQp13Udxe7fAHQ6y8+yxlQLWVmQaDQAAM3HHwMA1CtXQnbqlMPX9UpIgESrhaF5c+jbt3f4PERERFQzWFuqL17kWtVEniImJgbt27e3tQCfP38ee/fuxdixYwEAJpMJn332Gfr27YuWLVsiNjYW27dvx9WrV8t1/tOnT6N+/fq2ghoA2rVrV+y41atXY9iwYbjnnnsQGxuLDz/8sNzXKHqt5s2b2wpqAOjQoQPMZjPOnj1r29akSRNIpbd65NSrVw8ZGRnlukZOTg7S0tLQoUMHu+3t27fH6dOnAQCjR4/G0aNH0b17d7z55pvYvn277bjBgwdDq9WiS5cueOWVV7Bx40YYjcYKvc6K4tekKN9EZdau36a6daHv3BkFAwdCvXEjfD/5BDe//bbiFxVF29rUeY88Uq7uI0RERFSzNWhgWas6P1+CjAwJgoPNrg6JqMYS1WqkFhZZrrh2RYwdOxZvvPEG3n//fSxbtgyRkZHo0qULAODrr7/GDz/8gLfffhvNmjWDl5cX3nrrLej1eqfFe+DAATz33HN46aWX0KtXL/j6+mL16tX47rvvnHaNouRyebFtohO/SWzVqhX27NmDrVu34q+//sJTTz2Fbt264fvvv0d4eDiSkpKwdetW7Ny5E9OnT8fXX3+NX3/9tcS4nIEt1SjfRGXSwq7fpogIAEDOSy9BFASo162D7OjRCl9TkZQE+ZkzMHt7o2DkyIoHTURERDWOQnFrBvCLFzmumqhSBAGil5dL/lS0QWzIkCGQSCRYuXIlEhISMGbMGNv46v379+Pee+/FyJEj0bJlS0RERODcuXPlPndsbCxSUlJw7do127aDBw/aHXPgwAE0aNAAU6dORevWrREdHV2slVoul8NsLvuLvtjYWBw/fhz5+fm2bfv374dEIkHjxo3LHXNZfH19ERoaiv379xd7DU2aNLE7btiwYfjoo4/w9ddfY8OGDbh58yYAQK1WY8CAAXj33XexYsUK/P333zhx4oRT4isJi2oUHVN955ZqY2FRbWzeHNohQwAAvp98UuFrehe2UheMGAHRx6fCzyciIqKaqVEjjqsm8jTe3t4YOnQoPvjgA1y/fh2jR4+27YuKisKOHTuwf/9+nD59Gv/5z3/K3VUaALp3747o6GhMmzYNR48exd69ezF79my7Y6xF9OrVq3HhwgX88MMP2Lhxo90xDRs2xKVLl5CcnIzMzEzorGNki7j//vuhVCoxdepUnDhxArt27cKbb76JkSNH2sZTO8NTTz2Fr776CqtXr8aZM2fw/vvv4+jRo3jssccAWMZcr1q1CmfOnMHZs2exbt06hISEwN/fH8uWLcOSJUtw4sQJXLx4Eb/99htUKhXCw8OdFt/tWFSjnC3V1u7fkZG2bTkvvQRRIoF682bIDx8u9/Uk169DVfgmzuMEZURERB4lIuLWuGoi8hwPPvggNBoNevbsaTf+eerUqWjVqhXGjRuHUaNGITg4GPfee2+5zyuRSDB//nxotVoMHjwYL7/8Mv7zn//YHTNgwABMnjwZM2bMwIABA3DgwAG7icsAYNCgQejVqxdGjx6NVq1albisl1qtxpIlS6DRaHDffffhiSeeQLdu3TBr1qwK5eJOHnvsMTzxxBN455130K9fPyQmJmLBggWILlx5ycfHB1999RUGDhyI++67D5cvX8aPP/4IiUQCf39//PTTTxg+fDj69euHnTt3YuHChQiswpWWBNGZndurWHp6+h3XNxMEAWFhYUhNTS13v/2WLUOh0Uiwbdt1xMaWPIg9aNQoKHfvxs25c1EwapRte8Dzz8Pr11+h7dMHmYWtz3fiM3cu/D78EPp27ZCxZk25nlMdHMkdMW+OYt4cx9w5xpl5k8vlTv1Gnm6pqs96dzJ3rg8+/NAPo0fn47PPNNV67ZqeO1dh3hzn7NxlZ2fDz8/PCZG5P7lcXqG1nemWiuautPdVeT/v2VINQKu1/CxPS7W1+7dVzgsvQJRKodq6FfIDB+58MZMJXkuWAGArNRERkSe6tawWW6qJiGoDjy+qRbEcY6p1OkhTUwHYd/8GAFNUFPILx0T4ffTRHa+n/PNPyK5ehTkgAAWDBzseOBEREdVIt5bV4phqIqLawOOLaoMBEMWyi2rp5csQRBFmLy+Y69Yttj932jSIcjmUf/0Fxe7dZV7POkFZ/pgxgEpVyeiJiIioprG2VKelSWy95YiIqOby+KLaukY1UHr3b9sa1RERJU6fb2rQAPmFi7f7fvyxpfm7BNJLl6BMTAQA5D38cKXiJiIiopopMNAMb28zRFHAlSvsAk5EVNN5fL8ja9dvwLJ2ZElsy2nd1vW7qJznn4fXsmVQ7tmD4N69AWnxD0lJVhYEUYS2Rw+YCmeuIyIickebNm3C2rVrodFoEBERgUmTJiEmJqbEY/fu3YuVK1ciLS0NJpMJoaGhGDJkCHr06FHNUdcMgmBZVuv4cQkuXZIhJsbk6pCIiKgSWFQXWU6rtDXcpRcuAChsqS6FOSwMeRMnwuebbyA/fbrMa+Y9/rhDsRIREVWHpKQkLF68GJMnT0ZsbCzWr1+PWbNmYc6cOfD39y92vI+PD+6//37Ur18fMpkMBw8exFdffQU/Pz/cc8891f8CaoCICCOOH5dzsjIiolrA44tqa/fvUicpQ5GW6jKKagDIfv11aOPjgRIWSrcy16kDY8uWDkRKRERUPdatW4e+ffuid+/eAIDJkyfj4MGDSExMxPDhw4sd3/K2z7VBgwZh+/btOHHiBIvqUjRqZGmd5mRlRBVnNpshkXj8KFZyErPZXOlzePxv8oosp3X7zN/FyGTQd+jgpMiIiIiqn9FoxLlz5+yKZ4lEglatWuHUqVN3fL4oikhOTkZKSgrGjRtX6nEGg8FuDVFBEKBWq21/L4t1/52Oc2e3ltWSVevrqA25cwXmzXHOzp2XlxdycnLg6+vLwpoqzWw2IycnB97e3pV6j3p8UX3H5bTMZsguXQJw55ZqIiKimi47OxtmsxkBAQF22wMCApCSklLq8/Lz8/Hkk0/CaDRCIpHgsccew913313q8StXrkRCQoLtcVRUFGbPno3g4OByxxoaGlruY91NmzaWnykpKoSFhVX79Wty7lyJeXOcM3NXUFCAa9euQRRFiKVMEFwbaLk8gMPKkztBECAIAiIjI21f6jqKRfUdimpJWhoEnQ6iVApT/frVGRoREVGNoVKp8NFHH0Gr1eLff//F4sWLUa9evWJdw61GjBiBwYMH2x5bWwjS09NhNBrLvJYgCAgNDUVaWlqNvaH28ZECCMHZs2akpFwrdV4XZ6sNuXMF5s1xVZU7pVLptHO5I77nHFfR3Gk0Gmg0mhL3yWSycn3Z6/FF9Z3GVNuW02rQAJDLqy0uIiIiV/Dz84NEIil2g6HRaIq1XhclkUhsLVGRkZG4evUqVq1aVWpRLZfLIS/lc7W8N5A1uZUqPNwIQRCRlyfBjRsCgoIqP6avImpy7lyJeXMcc+cY5s1x1Zk7jx+IcGv275L3S8s5SRkREVFtIJPJEB0djeTkZNs2s9mM5ORkNGnSpNznMZvNdmOmyZ5KBYSGWgrpixc5AzgRUU3GovoO3b9l5VhOi4iIqDYZPHgw/vzzT2zbtg1XrlzB/PnzodPp0KtXLwDAvHnzsHTpUtvxK1euxJEjR3Dt2jVcuXIFa9euxc6dO9G9e3cXvYKaISLC0s390iWP7zhIRFSjefxvcevqV3fq/m2808zfREREtURcXByys7OxfPlyaDQaREZGYvr06bbu3xkZGXazpOp0OsyfPx83btyAQqFAeHg4nnvuOcTFxbnoFdQMjRqZsGcPW6qJiGo6jy+qCwqs3b9LLqpty2mxpZqIiDxIfHw84uPjS9w3c+ZMu8cPPvggHnzwwWqIqnZp1MjaUs2imoioJmP3b13ZRbWMY6qJiIioCljXqr540ePbOIiIajQW1WWMqRaysiApnP2ULdVERETkTGypJiKqHTy+qL61pFbxfbbltIKDIXp7V2dYREREVMtZW6pTUqTQ610cDBEROczji+qyun9LOfM3ERERVZG6dc1Qq80QRQFXrrC1moiopmJRXcbs3xxPTURERFVFEG61VnNZLSKimsuh3+CbNm3C2rVrodFoEBERgUmTJiEmJqbEY2fOnIljx44V296mTRu8/vrrjlzeqcoaUy3lclpERERUhRo1MuLECTmX1SIiqsEqXFQnJSVh8eLFmDx5MmJjY7F+/XrMmjULc+bMgb+/f7HjX375ZRiNRtvjnJwcvPLKK+jSpUvlIneSW2OqS2ipZvdvIiIiqkKNGrGlmoiopqtw9+9169ahb9++6N27Nxo0aIDJkydDoVAgMTGxxON9fHwQEBBg+3PkyBEolUp07ty50sE7g7WoLnFMNbt/ExERURW61f2bLdVERDVVhYpqo9GIc+fOoVWrVrdOIJGgVatWOHXqVLnOsXXrVsTFxUGlUlUs0ipS6kRlOh2kqakAABO7fxMREVEVsC6rxbWqiYhqrgr9Bs/OzobZbEZAQIDd9oCAAKSkpNzx+WfOnMHly5cxZcqUMo8zGAwwGAy2x4IgQK1W2/5eFuv+Ox1ndWtMtf1zpJcvQxBFmL29IdatW+7z1WQVzR1ZMG+OYd4cx9w5hnkjd1S0pVoULZOXERFRzVKtX4tu3boVjRo1KnVSM6uVK1ciISHB9jgqKgqzZ89GcHBwua8VGhparuPMZsvP+vXrICysyI6DBwEAksaNEVa/frmvWxuUN3dkj3lzDPPmOObOMcwbuZMGDSwt1Tk5Ety8KSAwsPhwNCIicm8VKqr9/PwgkUig0Wjstms0mmKt17fTarXYtWsXxowZc8frjBgxAoMHD7Y9trYqpKen2016VhJBEBAaGoq0tDSI4p0/mHJy6gKQIz8/E6mpOtt2r4MH4Q9AGx6Om4XdwGu7iuaOLJg3xzBvjmPuHOPMvMlksgp90UtUGrUaCA01IS1NikuXZAgMNNz5SURE5FYqVFTLZDJER0cjOTkZHTt2BACYzWYkJycjPj6+zOfu2bMHRqMR3bt3v+N15HI55HJ5ifvKeyMkimK5jrWuU61QmO2OLzpJmafdtJY3d2SPeXMM8+Y45s4xzBu5m0aNjEhLk+LiRSnuuYdFNRFRTVPh2b8HDx6MP//8E9u2bcOVK1cwf/586HQ69OrVCwAwb948LF26tNjztm7dig4dOsDX17fSQTtTaUtqyTjzNxEREVUDLqtFRFSzVfi3d1xcHLKzs7F8+XJoNBpERkZi+vTptu7fGRkZxSaBSUlJwYkTJ/DGG284JWhnKm32b2tLNWf+JiIioqoUEWGdAZzLahER1UQOfSUaHx9fanfvmTNnFttWv359LF++3JFLVblbRXWRjWYzZJcuAWBLNREREVUta0s1l9UiIqqZKtz9u7bRai0/i3b/lqSlQdDpIMpkMIWHuygyIiIi8gRFl9UiIqKax6OLalEEtFpLCooW1dbx1KYGDQAZvzUmIiKiqtOokaX7d0qKFHq9i4MhIqIK8+iiuugHV9Ex1VJOUkZERETVJCTEDJVKhNks4OpVtlYTEdU0Hl1UW8dTA7e1VF+4AAAwsagmIiKiKiYIt1qrOQM4EVHNw6IagCCIUChubedyWkRERFSdbk1WxpZqIqKaxqOL6qJrVBddBYzLaREREVF1si6rxZZqIqKax6OL6hKX0wJbqomIiKh6saWaiKjm8uiiuqTltASNBhKNBgDHVBMREVH1uDWmmkU1EVFN49FFtbWlusTltEJCIHp5uSQuIiIi8izWtaovXpRBFO9wMBERuRWPLqqtY6rtltMqnPmbXb+JiIiouli7f+fkSKDRCHc4moiI3IlHF9VltlQ3auSSmIiIiMjzqNUi6tWzFNacrIyIqGZhUQ1Aqby1TXrpEgDAyJm/iYiIqBpZx1VzsjIioprFo4vqoktqWckKu39zkjIiIiKqTtYu4GypJiKqWTy6qNbpLD/txlRzOS0iIiJyAetkZZwBnIioZvHoorpYS7VOB2lqKgDAxO7fREREVI1udf9mSzURUU3i0UW1dUy1taVadvkyBFGE2dsb5qAgV4ZGREREHoYt1URENZNHF9W3L6klPXcOQGErtcDlLIiIiKj6WFuqr16VwmBwcTBERFRuHl1U376klvzkSQCAoWlTl8VEREREnikkxAyVSoTJJCAlha3VREQ1BYtq3FpSS1ZYVBubNHFVSEREROShJBKgYUOOqyYiqmk8vKi2/GRLNREREbmD2FhLUX3sGItqIqKawqOLarsx1UYjZGfOAACMzZq5MiwiIiLyUHfdZRlMnZwsd3EkRERUXh5dVBcdUy27cAGCXg+zWg1TgwYujoyIiIg8UatWLKqJiGoajy6qi65TbRtP3bSpZVATERERUTWzFtVnzsiQn8+VSIiIagKPHrBTtPu3XVFNRETk4TZt2oS1a9dCo9EgIiICkyZNQkxMTInHbtmyBTt27MDly5cBANHR0Rg7dmypx1PpgoPNCA01IS1NiqNHZejQgWtrERG5O49ukrV2/1apAPmJEwAAA2f+JiIiD5eUlITFixdj1KhRmD17NiIiIjBr1ixkZWWVePyxY8fQtWtXvPXWW3jvvfcQFBSE9957D5mZmdUcee3AcdVERDULi2oUdv8+dQoAJykjIiJat24d+vbti969e6NBgwaYPHkyFAoFEhMTSzz++eefx7333ovIyEiEh4fjqaeegiiK+Pfff6s58trBWlT/+6/CxZEQEVF5eHhRbfmplmghO3cOAJfTIiIiz2Y0GnHu3Dm0atXKtk0ikaBVq1Y4VfgF9J3odDoYjUb4+PhUVZi1mnVc9b//sqWaiKgm4JhqAMGZpyGYTDD7+cEcGuriqIiIiFwnOzsbZrMZAQEBdtsDAgKQkpJSrnMsWbIEgYGBdoX57QwGAwyGW+OFBUGAWq22/b0s1v13Oq6mshbVp07JoNMJUKmcd+7anruqwrw5jrlzDPPmOFfkzqOLamv378DUwvHUTZsCfOMSERE5bNWqVdi1axdmzpwJhaL07ssrV65EQkKC7XFUVBRmz56N4ODgcl8rtJZ+ER4aCgQFATduCLhxIwzt21fFNWpn7qoa8+Y45s4xzJvjqjN3LKoB1Ll6HABn/iYiIvLz84NEIoFGo7HbrtFoirVe327NmjVYtWoV3nzzTURERJR57IgRIzB48GDbY2uLQnp6OoxGY5nPFQQBoaGhSEtLgyiKZR5bU7VsGYgdO5RITNQgPLzAaef1hNxVBebNccydY5g3xzkzdzKZrFxf9rKoBuB32dJSzaKaiIg8nUwmQ3R0NJKTk9GxY0cAgNlsRnJyMuLj40t93urVq/Hbb79hxowZaNy48R2vI5fLIZeXPGa4vDdBoijW2pvNVq302LFDiSNH5BDFfKefvzbnrioxb45j7hzDvDmuOnPn0ROVWcdU+1y0rFHNScqIiIiAwYMH488//8S2bdtw5coVzJ8/HzqdDr169QIAzJs3D0uXLrUdv2rVKixbtgxTpkxBSEgINBoNNBoNtFqti15BzcdltYiIag6PbakWRUtR7YU8KK9eBMDltIiIiAAgLi4O2dnZWL58OTQaDSIjIzF9+nRb9++MjAy7CWD++OMPGI1GfPrpp3bnGTVqFEaPHl2dodca1snKjh+Xw2AASmnUJyIiN+CxRbVeb/nZHMchiCJMQUEwBwW5NigiIiI3ER8fX2p375kzZ9o9/vLLL6shIs8SEWGCr68ZOTkSnD4tQ4sWZY8zJyIi1/HY7t/Wrt8tcRQAx1MTERGR+5BIbnUB53rVRETuzWOLauskZa3wLwDAwK7fRERE5EY4rpqIqGZgUS1JBgAYmzRxZThEREREdqzjqtlSTUTk3jy+qG4pHgPAScqIiIjIvViL6qNH5TCZXBwMERGVymOLaq0W8EMWGoiXAQAGtlQTERGRG2nc2AiVyoz8fAnOn/fYuWWJiNyeBxfVgm2SMlNoKER/fxdHRERERHSLVAq0bGmZ9ZtdwImI3JfHFtU63a2impOUERERkTviuGoiIvfn0UX1XSicpIzLaREREZEbatVKD4BFNRGRO/PYolqrvVVUG1hUExERkRsquqyWKLo4GCIiKpHHFtVFu3+zpZqIiIjcUZMmRigUIrKzJbh0SerqcIiIqAQeW1RLbmQgFNcAAMbYWBdHQ0RERFScQgE0a3artZqIiNyPxxbVvpdOAgDS1JEQvb1dHA0RERFRyThZGRGRe/PYojrg6gkAwGX/Fi6OhIiIiKh0RcdVExGR+/HYojoo7TgAIDWwuYsjISIiIiqdtaX6yBFOVkZE5I48tqgOuW4pqtPqsqgmIiIi99WsmQFSqYgbN6RIS/PYWzciIrflmb+ZRRGhNyzdv9Prsfs3ERERuS+1GoiNNQLguGoiInfkkUW15No1eOtuwgQJNPViXB0OERERUZk4rpqIyH15ZFEtP2mZ+fs0YiH1Vro4GiIiIqKycQZwIiL35ZFFtaywqE7GXVAqOeMHERERubdbRbXCxZEQEdHtPLqoPoqWUKlYVBMREZF7a9nSUlSnpkqRkeGRt29ERG7LI38ry4u0VLOoJiIiInfn4yMiOtoyWRnHVRMRuRfPK6rNZshOnQJg7f7t4niIiIiIyqFVKz0AjqsmInI3HldUS69ehSQvDwZBjjOI4ZhqIiIiqhE4WRkRkXvyuKLaOp76vKIpjJCz+zcRERHVCFxWi4jIPXlcUW0dT31S3hIA2FJNRERENYK1qL54UQaNRnBxNEREZOVxRbXsxAkAwAkpi2oiIiKqOerUEdG4saWw3r6dk8IQEbkLzyuqi0xSBoDdv4mIiKjGGDhQCwDYuFHt4kiIiMhK5siTNm3ahLVr10Kj0SAiIgKTJk1CTExMqcfn5eXh559/xr59+5Cbm4vg4GA8+uijaNu2rcOBO8Rkgvz0aQDAYZOlqGZLNREREdUUAwdqMW+eL/78U4mCAkDN2pqIyOUqXFQnJSVh8eLFmDx5MmJjY7F+/XrMmjULc+bMgb+/f7HjjUYj3nvvPfj5+eHFF19EYGAgMjIy4OXl5ZQXUBHSCxcg6HQwq1Q4ZYgGAKhU1R4GERERkUNatzYgLMyE1FQpdu5UYsAAnatDIiLyeBXu/r1u3Tr07dsXvXv3RoMGDTB58mQoFAokJiaWePzWrVuRm5uLV155Bc2aNUNISAhatGiByMjIysZeYebgYGR+/TWy/+//UKCTAmBLNREREdUcggAMGlQAANiwgc3URETuoEIt1UajEefOncPw4cNt2yQSCVq1aoVThWOVb/f3338jNjYWP/zwAw4cOAA/Pz907doVw4cPh0RSck1vMBhgMBhsjwVBgLqwf5MglD3bpXV/icf5+0M3bBi0WgDTLZvU6juf01OUmTsqFfPmGObNccydY5g3qi0GDdLihx988McfKhgMgJwrbBERuVSFiurs7GyYzWYEBATYbQ8ICEBKSkqJz7l27RrS09PRrVs3vP7660hLS8P8+fNhMpnwwAMPlPiclStXIiEhwfY4KioKs2fPRnBwcLljDQ0NLXWfRnPr75GRoVAoyn1aj1BW7qh0zJtjmDfHMXeOYd6opuvQQY+gIBNu3JBi924FevTQuzokIiKP5tBEZRUhiiL8/Pzw5JNPQiKRIDo6GpmZmVizZk2pRfWIESMwePBg22Nrq0J6ejqMRmOZ1xMEAaGhoUhLS4Molty1+/p1CYB6EAQRGRlpYKOFRXlyR8Uxb45h3hzH3DnGmXmTyWQV+qKXyJmkUiA+XoslS7yxYYOaRTURkYtVqKj28/ODRCKBpmhTLwCNRlOs9doqICAAMpnMrqt3eHg4NBoNjEYjZLLiIcjlcshL6ctU3hshURRLPVZrWY2icDktEbwntVdW7qh0zJtjmDfHMXeOYd6oNhg40FJUb9qkwqxZWZBK/7+9Ow9vqsz3AP5NmoSmO3ShC9i9ApVNBEdALdSRVUAErKAjBcuF4lAULA47QkcrywCXRa9UHZ7L0sLDVpYCg1ZkkSnCKEUuW6lQoNIC6ZJuWc79IyYQ6JZj27TJ9/M8eZKc856cNz9C3/zyLsfaNSIisl8WLVQmk8kQEhKC7Oxs0za9Xo/s7GxERERUe8yTTz6J/Px86PV607bbt2+jdevW1SbUTaGiwtA13aqVVU5PRERE9If06VMJNzc9CgoccOYM57EREVmTxat/Dx06FEeOHEFmZiby8vKwYcMGVFZWIioqCgCwZs0abN682VT+5ZdfRmlpKb7++mvcunULZ86cwc6dOzFgwIAGexOWqvz96hOGnmoiIiKilkWhAF56yTD0bv9+Xh+UiMiaLO4q7t27N4qLi5GWlgaVSoWgoCDMnj3bNPy7sLDQbGVVLy8vzJkzB//85z/xwQcfoE2bNhg0aJDZCuJN7UFPNZNqIiIiapkGD67Ajh1OOHDAEfPnF3ONGCIiKxE1/nrgwIEYOHBgtfsWLlz42LaIiAgkJSWJOVWjMCbV7KkmIiKilioqqhJKpR43bsiQnS1H586aug8iIqIGZ/Hwb1tQWcmeaiIiImrZlEoB/foZ5rRxCDgRkfUwqSYiIiJqoQYPNsyrPnCASTURkbVYZ/ltK3uQVFu5IkRERM1URkYG0tPToVKpEBgYiAkTJiAsLKzasjdu3EBqaiquXbuGgoICvP322xgyZEgT19g+RUdXQC4XcPmyHJcvyxAerrV2lYiI7I5d9lRzTjUREVHNTpw4gY0bN2LUqFFITk5GYGAgkpKSUFRUVG35yspKtG3bFmPHjjUtXEpNw81NwPPPcwg4EZE12WVSbbykFod/ExERPW7v3r2Ijo5Gv3790K5dO8TFxUGhUODbb7+ttnxYWBjeeust9OnTB3K5vIlrSxwCTkRkXXY5/JuX1CIiIqqeVqtFTk6O2aUvpVIpOnfujEuXLjXYeTQaDTSaB6tVSyQSKJVK0+PaGPfXVc5eDBhQicREAefOKZCXJ0P79roayzJ24jBu4jF24jBu4lkjdnaZVBvnVCuVTKqJiIgeVlxcDL1e/9gwbg8PD9y6davBzrNz505s377d9Dw4OBjJycnw9vau92v4+vo2WH1aMj8/4IUXgMxM4PhxH7z3Xt3HMHbiMG7iMXbiMG7iNWXs7DKpZk81ERGRdb366qsYOnSo6bmxR6GgoABabe2LbUkkEvj6+iI/Px+CwLYcAF56yQmZme7YurUKMTF3ayzH2InDuInH2InDuInXkLGTyWT1+rHXLpNqrv5NRERUPTc3N0ilUqhUKrPtKpWqQRchk8vlNc6/ru+XIEEQ+GXzdwMGlGPuXHdkZcnx228S+Pjoay3P2InDuInH2InDuInXlLGz04XK2FNNRERUHZlMhpCQEGRnZ5u26fV6ZGdnIyIiwoo1o9r4++vRvXsVBEGCjAwuWEZE1JTsMqmuMCySyUtqERERVWPo0KE4cuQIMjMzkZeXhw0bNqCyshJRUVEAgDVr1mDz5s2m8lqtFrm5ucjNzYVWq8W9e/eQm5uL/Px8K70D+8RVwImIrMPOh38zqSYiInpU7969UVxcjLS0NKhUKgQFBWH27Nmm4d+FhYVmq6reu3cPiYmJpufp6elIT09Hp06dsHDhwiauvf0aPLgcSUluOHasFa5ccUBYWM2rgBMRUcNhUk1ERESPGThwIAYOHFjtvkcTZR8fH6SlpTVBrag2QUE6vPxyOQ4dUmLpUjd8/vl9a1eJiMgu2Onwb0NSzeHfREREZEtmzSqBRCJg714lfv65+oXgiIioYTGpJiIiIrIRHTpoMXJkOQDgk09crVwbIiL7YJdJNS+pRURERLZq5swSyOUCvvvOEcePK6xdHSIim2enSbXhnnOqiYiIyNY88YQOb76pBgB8/LEbeIlbIqLGZadJNYd/ExERke1KSCiFUqnH2bMKHDzIS2wRETUmu0yqjXOq2VNNREREtsjbW4+4OENvdXKyK3S8uhYRUaOxy6Sal9QiIiIiWzd5cik8PPS4dEmOHTuU1q4OEZHNYlJNREREZIPc3QVMnVoKAFi2zNW0pgwRETUsmbUrYA3G4d9K/mhLZLO0Wi3KysqsXY1GU15ejqqqKmtXo8WxNG5OTk6QyeyyqSQbERurRkqKM/LyZNi0yRkTJ9ru30UiImuxu28KgsCeaiJbp9VqoVar4erqCqnUNgfkyOVyaDQaa1ejxbEkbnq9HiUlJXB2dmZiTS2WUilg+vQSfPihB1audEFMTLm1q0REZHNs89tmLR4e+sSkmsg2lZWV2XRCTU1DKpXC1dXVpkc8kH2IiSlDUJAWd+864IsvnK1dHSIim2N33ziNvdQAk2oiW8aEmhoCP0dkC+RyIDGxGACwfr0z7t61coWIiGyM3X1bMM6nlkoFyOVWrgwRERFRE3jllQpERmpQUiLFkiXWrg0RkW2xu6T64fnUEkkdhYmIiIhsgFQK/O1vht7qlSuBnTsdrVshIiIbYsdJtZUrQkTUBJ599ll88cUX9S5/4sQJBAQEoKioqBFrRUTW0K9fJeLiDJfYeu89D/zwg8LKNSIisg12t5ypcaEyR0fOpyai5iMgIKDW/e+//z5mzJhh8evu378fTk5O9S7/zDPP4OzZs3Bzc7P4XETU/M2fX4K7d12wY4cEEye2we7dhQgL01q7WkRELZrdJdXl5YaeaibVRNScnD171vR4z549WLZsGY4ePWra5uz8YMVeQRCg1dbvS7Cnp6dF9VAoFPDx8bHoGCJqORwcgP/9X+D556vw448KvPVWG+zZUwhvb721q0ZE1GLZ8fBvJtVE1Hz4+PiYbq6urpBIJKbnV65cQUREBL755hsMHDgQwcHBOHXqFHJzcxEbG4uuXbsiPDwcgwcPNkvEgceHfwcEBGDz5s2YOHEiQkND0adPHxw6dMi0/9Hh36mpqejYsSMyMzPx4osvIjw8HOPGjcNvv/1mOkar1WLevHno2LEjIiMjkZSUhISEBEyYMKHG93vv3j3Ex8ejR48eCA0NRXR0NHbt2mVWRq/XY926dejTpw+Cg4PRs2dPrFq1yrT/1q1biI+PR2RkJMLCwjBo0CCcOXNGVPyJ7IlSCXz99X0EBWlx/boMsbFtTJ0ORERkOSbVRGTzBAEoK5NY5SY04J+av//975g9ezYyMzPRqVMnqNVq9O/fH6mpqTh48CCioqIQGxuLmzdv1vo6K1aswCuvvIJ//etfiI6Oxrvvvov79+/XWL68vByfffYZVq9ejR07duDmzZtYvHixaf/atWuxY8cOrFixArt370ZJSQkOHjxYax0qKyvRpUsX/POf/8Q333yDcePGYdq0aWY99h9//DHWrl2LhIQEfPvtt1i7di28vb0BAGq1GqNGjUJ+fj6++uorHD58GFOmTIFez942ovrw9NRj48a78PDQ4+xZBaZO9YBOZ+1aERG1THY3/Nt4SS0O/yayH+XlEoSH+1nl3Jcv34aTU8P8vfnggw/wwgsvAADkcjlcXFwQGRlp2p+YmIiMjAwcOnQIsbGxNb7OmDFjMGLECADAhx9+iJSUFPznP/9Bv379qi2v0WjwySefICgoCAAwfvx4rFy50rT/q6++wl//+lcMGjQIAJCUlIRvvvmm1vfi5+eHyZMnm55PmDABmZmZSE9PR/fu3VFaWoqUlBQsWbIEY8aMAQAEBQWhV69eAICdO3fi7t272LdvH1q3bg0ACA4OrvWcRGQuNFSHr7++h9df98TBg0osWqTDRx8VW7taREQtjt0l1Vz9m4haqi5dupg9V6vVWL58OY4cOYI7d+5Aq9WioqKizp7qjh07mh47OTnB1dUVhYWFNZZXKpWmhBoA2rZtaypfXFyMgoICdOvWzbTfwcEBXbp0qbXXWKfTYfXq1di7dy/y8/NRVVWFqqoqKJVKAMDly5dRWVmJvn37Vnv8+fPn8dRTT5kSaiISp2fPKqxadR+TJ7dBSooL2rfXIS5Obe1qERG1KHacVLOnmsheKJUCLl++bbVzN5RHV/H+6KOP8P3332PevHkICgqCo6MjJk2ahKqqqlpfRy6Xmz2XSCS1JsDVlRf+4Lj29evXIyUlBYsWLUKHDh3g5OSEBQsWQKPRAAAcHWu/hm5d+4mo/l55pQJ5eUVYssQdixa5wc1Nj9dfL7d2tYiIWgw7nFNtuGdSTWQ/JBLAyUmwyk3SiGv/nD59GqNHj8agQYPQsWNH+Pj4IC8vr/FOWA03Nzd4e3vjP//5j2mbTqfDuXPnaj0uKysLAwYMwGuvvYbIyEgEBgYiJyfHtD84OBiOjo44duxYtcd37NgR58+fr3UuOBHV3+TJarz9thqCIMH777dGQoIHSku5eBkRUX3YXVLNOdVEZCuCg4Nx4MABZGdn4/z585g6dapVFuqKjY3FmjVrcPDgQVy5cgXz589HUVERJLX8ohAcHIyjR48iKysLly9fxqxZs8yGoDs6OmLq1KlISkrCtm3bkJubix9//BFbtmwBAIwYMQLe3t6YOHEisrKy8Ouvv2Lfvn04ffp0o79fIlskkQCLFxfh/fdLIJUK2L7dCQMGeOOnn+R1H0xEZOeYVBMRtVALFiyAu7s7hg8fjvHjxyMqKgqdO3du8npMnToVI0aMQEJCAoYPHw5nZ2e8+OKLaFXL4hUJCQno3Lkzxo0bh1GjRsHb2xsDBgwwKzN9+nRMmjQJy5YtQ1RUFKZMmWJKvBUKBbZs2QJPT0+89dZbiI6Oxtq1a+Hg4NCo75XIljk4ADNmlGD79rvw99ciN1eGYcO8sG6dC7iwPhFRzSTCH50Y14QKCgpM8+1qIpFI4Ofnh9u3b1c75y852RWrV7tiwoRSLF7MFS4fVlfsqHqMmziNGbfi4mK4ubk16Gs2N3K5vM6/h9ai1+vx4osv4pVXXkFiYqK1q2NGTNyq+zzJ5XLT5b2oYTVEW081q2/sVCoJEhM9sG+fYfHA55+vxKpV99G2rX1m1/zMicfYicO4ideQsatve293PdXGhcrYU01E1DDy8vKwadMmXL16FRcuXMCHH36IGzdu4NVXX7V21YhIJA8PAZ9/fh9Ll6qgVOrx/fet8NJL3jh8mJdPISJ6lN0l1cbh37ykFhFRw5BIJEhLS8OQIUMwYsQI/N///R+2bt2K8PBwa1eNiP4AiQQYO7YMGRmFiIzU4N49B4wf74l33mmN7Gy7u4AMEVGN7O4vIlf/JiJqWAEBAdi9e7e1q0FEjSQsTIv09AJ8/LEbNmxwxoEDShw4oMSf/1yB6dNL0K1b85yKQkTUVOyup5rXqSYiIiKyTKtWwMKFxfj22wKMHFkGqVTA4cOOGDLEG2+91QanT3OVcCKyX3abVHNONREREZFlwsO1+O//ViEz8w5Gjy6Dg4OAb75xxPDh3oiJ8cTJkwpwTSUisjd2l1Q/mFPNv/hEREREYoSG6rBypQpHj97BG2+oIZMJ+P77Vhg1ygt9+/ogOdkVFy/a3SxDIrJTdptUs6eaiIiI6I8JCtJh2bIiHDt2B2++qYajox65uTKsXu2K/v198NJL3li92gW//spryBOR7bK7pPrBnGorV4SIiIjIRrRvr0NychF+/vk3rF17Hy+/XA65XMCFC3IkJ7uhd++2GDrUC5995ozsbBl0OmvXmIio4djduBz2VBMRERE1DmdnASNGlGPEiHKoVBJkZDhi1y4nHD+uwNmzhhsAeHjo8eyzlXjuuSr07l2Jjh21kNpdVw8R2Qq7+/PFS2oRkS0bNWoU5s+fb3r+7LPP4osvvqj1mICAAGRkZPzhczfU6xCRbfDwEBATU46tW+/izJnfsGSJCv37V8DFRQ+VSoqDB5VYuNAdL7/sg86dfTFxYmt89pkzjh5thcJCu/uKSkQtmN31VPOSWkTUHL399tvQarXYtGnTY/tOnTqFkSNH4vDhw+jUqZNFr7t//344OTk1VDUBAMuXL0dGRgYOHz5stv3s2bNwd3dv0HMRkW3w9tYjNrYMsbFl0GqBc+fkOHmyFU6cUODUKQVUKikyMpTIyFCajvHx0aFjRw06ddL+fq9BaKgWCoUV3wgRUTXsNqnm8G8iak7eeOMNxMXF4datW/D39zfbl5qaiq5du1qcUAOAp6dnQ1WxTj4+Pk12LiJquWQyoHt3Dbp31yA+HtBogJ9/NiTZP/0kx4ULcuTmOuDOHcPtu+8eHCuVCmjXToeQEC2Cg7UIDtYhOFiLkBAt2rXTQWZ332yJqDmwu7E1vKQWETVHL730Ejw9PZGWlma2Xa1WY+/evYiJicG9e/cQHx+PHj16IDAwENHR0di1a1etr/vo8O+cnByMHDkSISEhiIqKwtGjRx87JikpCX379kVoaCiee+45fPrpp9BoNAAMCf6KFSvwyy+/ICAgAAEBAUhNTQXw+PDvCxcuYPTo0QgNDUVkZCQSExOhVqtN+6dPn44JEybgs88+Q/fu3REZGYnZs2ebzlWd3NxcxMbGomvXrggPD8fgwYMfew+VlZVISkrCM888g+DgYPTp0wdbtmwx7b948SL+8pe/4Mknn0RERAReffVV5Obm1hpHImo8cjnQo4cG775bii++uI9jx+7g4sV8pKcXIDlZhfHj1ejVqxKurnro9RJcvy5DZqYjvvrKBfPnu+OttzzRp09bhIX54U9/8sGIEZ6YPLk1Fi1yw+efO2PPHkdkZSlw44YDyssl1n67RGSD7O73vAc91VauCBE1HUGApLzcOqdWKgFJ3V/iZDIZRo0ahW3btiEhIQGS34/Zu3cvdDodRowYAbVajS5duiA+Ph6tW7fGwYMHMW3aNAQGBqJ79+51nkOv1yMuLg5eXl5IT09HSUkJFixY8Fg5Z2dn/OMf/4Cvry8uXLiAxMREuLi4ID4+HsOGDcPFixeRmZmJrVu3AgBcXV0fe42ysjKMGzcOPXr0wL59+1BYWIgPPvgAc+bMwcqVK03lTpw4AR8fH2zbtg3Xrl3DlClTEBkZiXHjxlX7HtRqNfr3749Zs2ZBoVBg+/btiI2NxdGjRxEQEAAASEhIwI8//ojFixejU6dOuH79Ou7duwcAuH37NkaOHInevXsjLS0NLi4uOH36NLRabZ3xI6Km4+ws4OmnNXj66Qc/sgkCUFAgRU6ODNeuyXDtmoPpcW6uDBUVEty4IcONG7V/vXVy0sPT03Br00YPL68Hj93dDTc3Nz3c3YWHHjf2OyailsyukmpB4JxqInskKS+HX3i4Vc59+/JlCPWc0xwTE4P169fj5MmT6N27NwBDz/DgwYPh5uYGNzc3TJ48GQAgl8sxYcIEZGZmIj09vV5J9ffff48rV65g06ZN8PX1BQB8+OGHePPNN83KTZ8+3fS4ffv2yMnJwe7duxEfHw+lUglnZ2c4ODjUOtx7586dqKysxKpVq0xzupcsWYLx48djzpw58Pb2BgC4u7sjKSkJDg4OCAsLQ3R0NI4dO1ZjUh0ZGYnIyEjT88TERGRkZODQoUOIjY3F1atXkZ6eji1btuCFF14AAAQGBprKf/nll3Bzc8O6desgl8sBAKGhoXXGzh5lZGQgPT0dKpUKgYGBmDBhAsLCwmosf/LkSaSmpqKgoAC+vr4YN24cnn766SasMdk6iQTw8dHDx6cKf/pTldk+vR64fVuKW7cckJ9vuN2+7YD8fOnv94ZbVZUEZWVSlJVJceOGZed3cQFcXHzg7KyHq6sAZ2cBrq763+8FODvroVQKUCoFODkZbsbHxu2Ojo/fFIp6/fZKRM2YXSXVxpW/Ac6pJqLmJywsDM888wy2bt2K3r1749q1azh16hS2bdsGANDpdFi9ejX27t2L/Px8VFVVoaqqCkqlso5XNrh8+TL8/f1NCTUA9OjR47Fyu3fvxpdffolff/0VarUaOp0OLi4uFr2Xy5cvo2PHjmaLpPXs2RN6vR5Xr141JdURERFwcHAwlWnbti0uXLhQ4+uq1WosX74cR44cwZ07d6DValFRUYGbN28CAM6fPw8HBwc899xz1R6fnZ2NXr16mRJqqt6JEyewceNGxMXFITw8HPv27UNSUhJWrlxZ7WJ0Fy9exKpVqzB27Fg8/fTTOHbsGJYuXYrk5GQ88cQTVngHZG+kUiAgQI+AAD2A6qeQCAJQWipBYaEUd+9Kce+eFHfvOpg9Ly6WorhYgqIiKYqKDI/VasNsydJSoLTUAYBDta8vlkRiSK5btTJ0+igUxht+T7oNjxUKAXK5ALkckMuF35/DdC+TGcoZ98lkxseGfTLZg3sHB+Nz820ODobnhvsH5RwcDPPZHRzw++3B44e387JoZK/sKqk2zqcG2FNNZE8EpRK3L1+22rkt8cYbb2Du3Ln4+9//jtTUVAQFBZkSxPXr1yMlJQWLFi3CU089BYVCgQULFtQ6B9lSp0+fxl//+lfMmDEDUVFRcHV1xe7du/E///M/DXaOh1WX3ApCzX+fP/roI3z//feYN28egoKC4OjoiEmTJqGqytBr5VjH3J669pPB3r17ER0djX79+gEA4uLicObMGXz77bcYMWLEY+X379+Pbt26YdiwYQAMoy7OnTuHjIwMTJo0qSmrTlQjiQRwdRXg6qpDcLCu3sdpNEBJiRSOjr7IySlASYkEpaUSlJZKf7+XoKRECrVagvJyw62s7NF7KcrLJaisNHwfraiQQK83fC8VBONxjfXOm5Yx4TYm28akXCLxgVT6IBE3PpZIDMdIpTDdJJIHxz94/uC4B8/Ntxlvj257+DWr227c9/BrmO9/fN/jN8H0o0JtZYyjEup6LYlEAnd3oKTEGUBNxwmmbY/eG291HfPw/uoeP75NMDtO7P3Dr1Nb2Zoe11ZOIgG6dweqmZ3WaOwqqTYO/ZZKBa4OSWRPJJJ6D8G2tldeeQXz58/Hzp07sX37dvzlL38xza/OysrCgAED8Nprr0Eul6OyshI5OTmIiIio12uHh4fj1q1b+O2339C2bVsAwJkzZ8zKnD59Gu3atUNCQoJpm7EX2Egul0Ov19d5rm3btqGsrMzUW52VlQWpVPqHhlufPn0ao0ePxqBBgwAYeq7z8vJM+zt27Ai9Xo+TJ0+ahn8/rFOnTkhNTYVGo2FvdQ20Wi1ycnLMkmepVIrOnTvj0qVL1R5z6dIlDB061Gxb165dkZWVVeN5NBqN2Q9CEonENOpC8vC3pGoY99dVjh7H2FlOoQC8vABfX8DFRVfrD3/1JQiGZN2YYFdUSFBZaUi6q6okqKqSoKLiwePKSgk0GkCjkaCqynCv0Rj2azSG47RaCbRa47YHZYz3Wq0EOt2De43G+PzhfYBO92g5QK83PNbpDD8C1MZ4PPBouYbt4bcfbtauQIs0YwYwc2bT/Z2zq9RSEICnnjL0ZrAtIaLmyNnZGcOGDcMnn3yCkpISjBkzxrQvODgY+/btQ1ZWFry8vLBu3ToUFhbWO6l+/vnnERISgunTp2Pu3LkoLS1FcnKyWZmQkBDcvHkTu3fvRteuXXHkyBEcOHDArEz79u1x/fp1ZGdnw9/fH87OzmjVqpVZmZEjR2L58uVISEjAjBkzcPfuXcybNw+vvfaaaei3GMHBwThw4AD+/Oc/QyKRYOnSpWYJfvv27TF69GjMmDHDtFBZXl4eCgsLMWzYMEycOBEbNmxAfHw83n33Xbi6uuLMmTPo1q1brfOF7UlxcTH0ej08PDzMtnt4eODWrVvVHqNSqR4bFu7u7g6VSlXjeYw/HBkFBwcjOTnZos/Hw1MZyDKMnTiMm+H79IMEvO6bVmuY867T1X7/6GPjc0Mib7794eeP7n+07MPbHr03Pn54e3VlaytjzZvx36M+z42Pq9smtqzY+4Z4jYc/j9U99vNr2v+vdpVU+/rqcfBgobWrQURUq5iYGGzZsgX9+/c3axASEhJw/fp1jBs3DkqlEuPGjcOAAQNQUlJSr9eVSqXYsGEDZs6ciaFDh6Jdu3ZYvHix2aJgL7/8MuLi4jBnzhxUVVUhOjoa06dPx4oVK0xlBg8ejP3792PMmDEoKirCihUr8Prrr5udS6lUYtOmTZg/fz6GDBkCR0dHDBkypNrVxi2xYMECvP/++xg+fDjatGmDqVOnorS01KzMxx9/jE8++QSzZ8/G/fv34e/vj2nTpgEA2rRpg7S0NCxZsgSvvfYaHBwcEBkZiZ49e/6hepHlXn31VbPebWPPaUFBQZ2rsUskEvj6+iI/P79Beg3tCWMnDuNWfxIJTPO1Dc8ZOzEYN/EaMnYymaxeP/ZKhBb0r1RQUFDn3EGJRAI/Pz/cvn2bH0ALMXbiMG7iNGbciouL4eZm28Ol5HJ5g86lthdi4lbd50kul/+hHvfmTKvV4s0338T777+PXr16mbavWbMGZWVlSExMfOyYKVOmYOjQoRgyZIhpW1paGrKysrB06VKLzs+2vnExduIwbuIxduIwbuI1ZOzq295zjT4iIiIykclkCAkJQXZ2tmmbXq9HdnZ2jVMNIiIicO7cObNtP//8M8KtdCk7IiKipiRq+Lcl167MzMzEunXrzLbJ5XJs2rRJzKmJiIiokQ0dOhRr165FSEgIwsLCsH//flRWViIqKgqAode6TZs2GDt2LADDlICFCxciPT0dTz/9NI4fP46rV69y5W8iIrILFifVll67EjDMrVu1atUfriwRERE1vt69e6O4uBhpaWlQqVQICgrC7NmzTYuXFRYWmq0e/eSTT2LatGnYunUrtmzZAj8/P3zwwQe8RjUREdkFi5NqS69dCRjGtT+6iigRERE1XwMHDsTAgQOr3bdw4cLHtj333HOma6oTERHZE4uSajHXrgSAiooKxMfHQxAEBAcH44033kD79u1rLM9rV1oHYycO4yYO40YtCT+nREREVBOLkmox16709/fHlClTEBgYiLKyMuzZswdz587FihUr4OnpWe0xvHaldTF24jBu4jRG3MrLyyGXyxv8dZsbe3iPjcHSuCkUCvj5+TVSbYiIiKila/TrVEdERJitFhoREYH33nsPhw8fRkxMTLXH8NqV1sHYicO4idOYcdPpdFCpVHBycrLZHkZeUkscS+ImCALKysoAALdv3zbbV9/rVhIREZHtsyipdnNzg1QqhUqlMtuuUqnqPWdaJpMhODgY+fn5NZaRy+U19iTU98u3IAhMcERi7MRh3MRpjLg5OzujsrISJSUlDfq6zYlCoUBVVZW1q9HiWBq3Vq1aoVWrVvy/TURERDWyKKl++NqVvXr1AvDg2pU1LWbyKL1ej+vXr6N79+6W15aIqJ6MyZAtkkgk8PPzw+3bt5nsWYBxIyIiosZg8fBvS69duX37doSHh8PX1xdqtRp79uxBQUEBoqOjG/SNEBERERERETU1i5NqS69dWVpais8//xwqlQrOzs4ICQnBkiVL0K5duwZ7E0RERERERETWIGqhMkuuXTl+/HiMHz9ezGmIiIiIiIiImjWptStARERERERE1FI1+iW1GpJMVv/qWlKWzDF24jBu4jBu4jF24jRE3Bj7xsO2vmkwduIwbuIxduIwbuI1ZXsvEbgEKhEREREREZEoNjf8u7y8HLNmzUJ5ebm1q9LiMHbiMG7iMG7iMXbiMG62g/+W4jF24jBu4jF24jBu4lkjdjaXVAuCgGvXrvEapCIwduIwbuIwbuIxduIwbraD/5biMXbiMG7iMXbiMG7iWSN2NpdUExERERERETUVJtVEREREREREItlcUi2XyzFq1CjI5XJrV6XFYezEYdzEYdzEY+zEYdxsB/8txWPsxGHcxGPsxGHcxLNG7Lj6NxEREREREZFINtdTTURERERERNRUmFQTERERERERicSkmoiIiIiIiEgkJtVEREREREREIsmsXYGGlpGRgfT0dKhUKgQGBmLChAkICwuzdrWajV9++QV79uzBtWvXcP/+fcycORO9evUy7RcEAWlpaThy5AjUajU6dOiAd955B35+flastfXt3LkT//73v3Hz5k0oFApERETgzTffhL+/v6lMVVUVNm7ciBMnTkCj0aBr165455134OHhYb2KNwOHDh3CoUOHUFBQAABo164dRo0ahe7duwNg3Opr165d2Lx5MwYPHozx48cDYOxqkpaWhu3bt5tt8/f3x8qVKwEwbraAbX3d2N5bjm29eGzrGwbb+vprbm29Ta3+feLECaxZswZxcXEIDw/Hvn378MMPP2DlypVwd3e3dvWahbNnz+LixYsICQnBsmXLHmtkd+3ahV27dmHq1Knw8fFBamoqrl+/jhUrVkChUFix5taVlJSEPn36IDQ0FDqdDlu2bMGNGzewYsUKODo6AgC++OILnDlzBlOnToWTkxNSUlIglUqxePFiK9feuk6fPg2pVAo/Pz8IgoDvvvsOe/bswaeffor27dszbvVw5coV/OMf/4CTkxMiIyNNDS1jV720tDScOnUK8+bNM22TSqVwc3MDwLi1dGzr64ftveXY1ovHtv6PY1tvmWbX1gs25G9/+5uwYcMG03OdTidMmjRJ2Llzp/Uq1YyNHj1aOHXqlOm5Xq8X4uLihN27d5u2qdVqYezYscKxY8esUcVmq6ioSBg9erRw/vx5QRAMcYqJiRFOnjxpKpOXlyeMHj1auHjxorWq2WyNHz9eOHLkCONWD+Xl5cK0adOEn376SViwYIHw1VdfCYLAz1xtUlNThZkzZ1a7j3Fr+djWW47tvThs6/8YtvX1x7becs2trbeZOdVarRY5OTno3LmzaZtUKkXnzp1x6dIlK9as5bhz5w5UKhW6dOli2ubk5ISwsDDG8BFlZWUAABcXFwBATk4OdDqd2ecvICAAXl5ejN1D9Ho9jh8/jsrKSkRERDBu9bBhwwZ0797d7P8lwM9cXfLz8/Ff//VfePfdd7F69WoUFhYCYNxaOrb1DYPtff2wrReHbb3l2NaL05zaepuZU11cXAy9Xv/YOHkPDw/cunXLOpVqYVQqFQA8NnzO3d3dtI8MjcXXX3+NJ598Ek888QQAQ+xkMhmcnZ3NyjJ2BtevX8ecOXOg0Wjg6OiImTNnol27dsjNzWXcanH8+HFcu3YNH3/88WP7+JmrWXh4OOLj4+Hv74/79+9j+/btmD9/PpYvX864tXBs6xsG2/u6sa23HNt6cdjWi9Pc2nqbSaqJmkpKSgpu3LiBjz76yNpVaTH8/f2xdOlSlJWV4YcffsDatWuxaNEia1erWSssLMTXX3+NuXPn2u38RrGMC+MAQGBgoKnhPXnyJGNJRPXCtt5ybOstx7ZevObW1ttMUu3m5gapVPrYrw8qlcruV8erL2OcioqK0Lp1a9P2oqIiBAUFWadSzUxKSgrOnDmDRYsWwdPT07Tdw8MDWq0WarXa7FexoqIifv4AyGQy+Pr6AgBCQkJw9epV7N+/H71792bcapCTk4OioiLMmjXLtE2v1+PChQvIyMjAnDlzGLt6cnZ2hr+/P/Lz89GlSxfGrQVjW98w2N7Xjm29OGzrLce2vuFYu623mTnVMpkMISEhyM7ONm3T6/XIzs5GRESEFWvWcvj4+MDDwwPnzp0zbSsrK8OVK1fsPoaCICAlJQX//ve/MX/+fPj4+JjtDwkJgYODg1nsbt26hcLCQruPXXX0ej00Gg3jVovOnTtj2bJl+PTTT0230NBQ9O3b1/SYsaufiooK5Ofnw8PDg5+5Fo5tfcNge189tvUNi2193djWNxxrt/U201MNAEOHDsXatWsREhKCsLAw7N+/H5WVlYiKirJ21ZoN4wfO6M6dO8jNzYWLiwu8vLwwePBg7NixA35+fvDx8cHWrVvRunVr9OzZ04q1tr6UlBQcO3YMiYmJUCqVpl4SJycnKBQKODk5oX///ti4cSNcXFzg5OSEL7/8EhEREXb/R2/z5s3o1q0bvLy8UFFRgWPHjuGXX37BnDlzGLdaKJVK0zw+o1atWsHV1dW0nbGr3saNG/HMM8/Ay8sL9+/fR1paGqRSKfr27cvPnA1gW18/bO8tx7ZePLb14rCtF6+5tfU2dZ1qAMjIyMCePXugUqkQFBSE2NhYhIeHW7tazcb58+ernd/y4osvYurUqRAEAWlpafjXv/6FsrIydOjQARMnToS/v78Vatt8jBkzptrt8fHxpi9yxovMHz9+HFqtttEvMt9SrF+/HtnZ2bh//z6cnJwQGBiI4cOHm1a4ZNzqb+HChQgKCjJdu5Kxq97KlStx4cIFlJSUwM3NDR06dEBMTIxpWCLj1vKxra8b23vLsa0Xj219w2FbXz/Nra23uaSaiIiIiIiIqKnYzJxqIiIiIiIioqbGpJqIiIiIiIhIJCbVRERERERERCIxqSYiIiIiIiISiUk1ERERERERkUhMqomIiIiIiIhEYlJNREREREREJBKTaiIiIiIiIiKRmFQTERERERERicSkmoiIiIiIiEgkJtVEREREREREIjGpJiIiIiIiIhLp/wHNF9HSgjg3VAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def create_embedding_matrix(filepath, word_index, embedding_dim):\n",
        "    vocab_size = len(word_index) + 1  # Adding again 1 because of reserved 0 index\n",
        "    embedding_matrix = np.zeros((vocab_size, embedding_dim))\n",
        "\n",
        "    with open(filepath) as f:\n",
        "        for line in f:\n",
        "            word, *vector = line.split()\n",
        "            if word in word_index:\n",
        "                idx = word_index[word]\n",
        "                embedding_matrix[idx] = np.array(\n",
        "                    vector, dtype=np.float32)[:embedding_dim]\n",
        "\n",
        "    return embedding_matrix"
      ],
      "metadata": {
        "id": "HYSFF4iAYdeU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "embedding_dim = 50\n",
        "embedding_matrix = create_embedding_matrix(\n",
        "    'data/glove_word_embeddings/glove.6B.50d.txt',\n",
        "    tokenizer.word_index, embedding_dim)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 315
        },
        "id": "cgReGk80Ydb-",
        "outputId": "799a564c-766f-4405-ac9c-212e1a535982"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "[Errno 2] No such file or directory: 'data/glove_word_embeddings/glove.6B.50d.txt'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-38-92a6f36c84be>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0membedding_dim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m embedding_matrix = create_embedding_matrix(\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;34m'data/glove_word_embeddings/glove.6B.50d.txt'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     tokenizer.word_index, embedding_dim)\n",
            "\u001b[0;32m<ipython-input-37-16454bc9852e>\u001b[0m in \u001b[0;36mcreate_embedding_matrix\u001b[0;34m(filepath, word_index, embedding_dim)\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0membedding_matrix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvocab_size\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0membedding_dim\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      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m     \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\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      8\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m             \u001b[0mword\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mvector\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\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;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'data/glove_word_embeddings/glove.6B.50d.txt'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nonzero_elements = np.count_nonzero(np.count_nonzero(embedding_matrix, axis=1))\n",
        "nonzero_elements / vocab_size"
      ],
      "metadata": {
        "id": "bmSmdC7aYdZB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = Sequential()\n",
        "model.add(layers.Embedding(vocab_size, embedding_dim,\n",
        "                           weights=[embedding_matrix],\n",
        "                           input_length=maxlen,\n",
        "                           trainable=False))\n",
        "model.add(layers.GlobalMaxPool1D())\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "model.compile(optimizer='adam',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "ejpqLNpCYdWc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=50,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)\n",
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
        "plot_history(history)"
      ],
      "metadata": {
        "id": "aQGqF2S4YdT5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MVOMztAQYdRU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = Sequential()\n",
        "model.add(layers.Embedding(vocab_size, embedding_dim,\n",
        "                           weights=[embedding_matrix],\n",
        "                           input_length=maxlen,\n",
        "                           trainable=True))\n",
        "model.add(layers.GlobalMaxPool1D())\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "model.compile(optimizer='adam',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "d_3uK3_Ab_1D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=50,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)\n",
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
        "plot_history(history)"
      ],
      "metadata": {
        "id": "jaXu02YTb_x8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_qDUq0Hyb_vf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "embedding_dim = 100\n",
        "\n",
        "model = Sequential()\n",
        "model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen))\n",
        "model.add(layers.Conv1D(128, 5, activation='relu'))\n",
        "model.add(layers.GlobalMaxPooling1D())\n",
        "model.add(layers.Dense(10, activation='relu'))\n",
        "model.add(layers.Dense(1, activation='sigmoid'))\n",
        "model.compile(optimizer='adam',\n",
        "              loss='binary_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "1OQt-Kd-b_tT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history = model.fit(X_train, y_train,\n",
        "                    epochs=10,\n",
        "                    verbose=False,\n",
        "                    validation_data=(X_test, y_test),\n",
        "                    batch_size=10)\n",
        "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
        "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
        "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
        "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
        "plot_history(history)"
      ],
      "metadata": {
        "id": "LRLa7IBSb_qu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_model(num_filters, kernel_size, vocab_size, embedding_dim, maxlen):\n",
        "    model = Sequential()\n",
        "    model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen))\n",
        "    model.add(layers.Conv1D(num_filters, kernel_size, activation='relu'))\n",
        "    model.add(layers.GlobalMaxPooling1D())\n",
        "    model.add(layers.Dense(10, activation='relu'))\n",
        "    model.add(layers.Dense(1, activation='sigmoid'))\n",
        "    model.compile(optimizer='adam',\n",
        "                  loss='binary_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "    return model"
      ],
      "metadata": {
        "id": "ZwQp7R3Qb_oS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "param_grid = dict(num_filters=[32, 64, 128],\n",
        "                  kernel_size=[3, 5, 7],\n",
        "                  vocab_size=[5000],\n",
        "                  embedding_dim=[50],\n",
        "                  maxlen=[100])"
      ],
      "metadata": {
        "id": "_5QzQLf-b_l2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.wrappers.scikit_learn import KerasClassifier\n",
        "from sklearn.model_selection import RandomizedSearchCV\n",
        "\n",
        "# Main settings\n",
        "epochs = 20\n",
        "embedding_dim = 50\n",
        "maxlen = 100\n",
        "output_file = 'data/output.txt'\n",
        "\n",
        "# Run grid search for each source (yelp, amazon, imdb)\n",
        "for source, frame in df.groupby('source'):\n",
        "    print('Running grid search for data set :', source)\n",
        "    sentences = df['sentence'].values\n",
        "    y = df['label'].values\n",
        "\n",
        "    # Train-test split\n",
        "    sentences_train, sentences_test, y_train, y_test = train_test_split(\n",
        "        sentences, y, test_size=0.25, random_state=1000)\n",
        "\n",
        "    # Tokenize words\n",
        "    tokenizer = Tokenizer(num_words=5000)\n",
        "    tokenizer.fit_on_texts(sentences_train)\n",
        "    X_train = tokenizer.texts_to_sequences(sentences_train)\n",
        "    X_test = tokenizer.texts_to_sequences(sentences_test)\n",
        "\n",
        "    # Adding 1 because of reserved 0 index\n",
        "    vocab_size = len(tokenizer.word_index) + 1\n",
        "\n",
        "    # Pad sequences with zeros\n",
        "    X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
        "    X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)\n",
        "\n",
        "    # Parameter grid for grid search\n",
        "    param_grid = dict(num_filters=[32, 64, 128],\n",
        "                      kernel_size=[3, 5, 7],\n",
        "                      vocab_size=[vocab_size],\n",
        "                      embedding_dim=[embedding_dim],\n",
        "                      maxlen=[maxlen])\n",
        "    model = KerasClassifier(build_fn=create_model,\n",
        "                            epochs=epochs, batch_size=10,\n",
        "                            verbose=False)\n",
        "    grid = RandomizedSearchCV(estimator=model, param_distributions=param_grid,\n",
        "                              cv=4, verbose=1, n_iter=5)\n",
        "    grid_result = grid.fit(X_train, y_train)\n",
        "\n",
        "    # Evaluate testing set\n",
        "    test_accuracy = grid.score(X_test, y_test)\n",
        "\n",
        "    # Save and evaluate results\n",
        "    prompt = input(f'finished {source}; write to file and proceed? [y/n]')\n",
        "    if prompt.lower() not in {'y', 'true', 'yes'}:\n",
        "        break\n",
        "    with open(output_file, 'a') as f:\n",
        "        s = ('Running {} data set\\nBest Accuracy : '\n",
        "             '{:.4f}\\n{}\\nTest Accuracy : {:.4f}\\n\\n')\n",
        "        output_string = s.format(\n",
        "            source,\n",
        "            grid_result.best_score_,\n",
        "            grid_result.best_params_,\n",
        "            test_accuracy)\n",
        "        print(output_string)\n",
        "        f.write(output_string)"
      ],
      "metadata": {
        "id": "t5sqLMvzcLGM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Ug1wfWVIcLDo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SGmNXp22cLBD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "xADWnngEcK-x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "KTSOrnVLcK7l"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}