Insincere_Questions_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hmA6EzkQJ5jt"
   },
   "outputs": [],
   "source": [
    "import json\n",
    "import tensorflow as tf\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras import regularizers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 32\n",
    "embedding_dim = 300\n",
    "num_epochs = 6\n",
    "batch_size = 512\n",
    "\n",
    "trunc_type='post'\n",
    "padding_type='post'\n",
    "oov_tok = \"<OOV>\"\n",
    "val_portion=.05"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training/Validation data preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "bM0l_dORKqE0",
    "outputId": "491ba86b-f780-4355-a4be-765565a29c8c"
   },
   "outputs": [],
   "source": [
    "corpus = []\n",
    "\n",
    "train_pd = pd.read_csv(\"../train.csv\").fillna(' ')\n",
    "\n",
    "train_text = train_pd['question_text']\n",
    "labels_text = train_pd['target']\n",
    "\n",
    "list_item = list(zip(train_text,labels_text))\n",
    "num_sentences = len(list_item)\n",
    "corpus = list_item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "3kxblBUjEUX-",
    "outputId": "3c0227a2-e74b-4d9b-cabb-f9ee150571b1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1306122\n",
      "1306122\n",
      "('Do you have an adopted dog, how would you encourage people to adopt and not shop?', 0)\n"
     ]
    }
   ],
   "source": [
    "print(num_sentences)\n",
    "print(len(corpus))\n",
    "print(corpus[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ohOGz24lsNAD"
   },
   "outputs": [],
   "source": [
    "training_size = len(corpus)\n",
    "\n",
    "sentences=[]\n",
    "labels=[]\n",
    "random.shuffle(corpus)\n",
    "for x in range(training_size):\n",
    "    sentences.append(corpus[x][0])\n",
    "    labels.append(corpus[x][1])\n",
    "\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(sentences)\n",
    "\n",
    "word_index = tokenizer.word_index\n",
    "vocab_size=len(word_index)\n",
    "\n",
    "sequences = tokenizer.texts_to_sequences(sentences)\n",
    "padded = pad_sequences(sequences, maxlen=max_length, padding=padding_type, truncating=trunc_type)\n",
    "\n",
    "split = int(val_portion * training_size)\n",
    "\n",
    "val_sequences = padded[0:split]\n",
    "training_sequences = padded[split:training_size]\n",
    "val_labels = labels[0:split]\n",
    "training_labels = labels[split:training_size]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "gIrtRem1En3N",
    "outputId": "4ad8401c-8dba-420d-8aee-38dac0b0839a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "222161\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(vocab_size)\n",
    "print(word_index['the'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading glove pretrained weights matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "colab_type": "code",
    "id": "C1zdgJkusRh0",
    "outputId": "b6edd322-8191-45e7-cb12-08921685a72f"
   },
   "outputs": [],
   "source": [
    "glove_txt_path = \"../embeddings/glove.840B.300d/glove.840B.300d.txt\"\n",
    "\n",
    "embeddings_index = {};\n",
    "with open(glove_txt_path, encoding=\"utf-8\") as f:\n",
    "    for line in f:\n",
    "        values = line.split();\n",
    "        \n",
    "        if len(values) != 301:\n",
    "            continue\n",
    "        \n",
    "        word = values[0];\n",
    "        coefs = np.asarray(values[1:], dtype='float32');\n",
    "        embeddings_index[word] = coefs;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddings_matrix = np.zeros((vocab_size+1, embedding_dim));\n",
    "for word, i in word_index.items():\n",
    "    embedding_vector = embeddings_index.get(word);\n",
    "    if embedding_vector is not None:\n",
    "        embeddings_matrix[i] = embedding_vector;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "71NLk_lpFLNt",
    "outputId": "97cb88db-754f-4375-fdc3-876cd6b4fdce"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "222162\n"
     ]
    }
   ],
   "source": [
    "print(len(embeddings_matrix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iKKvbuEBOGFz"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, 32, 300)           66648600  \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 32, 300)           0         \n",
      "_________________________________________________________________\n",
      "conv1d (Conv1D)              (None, 28, 64)            96064     \n",
      "_________________________________________________________________\n",
      "max_pooling1d (MaxPooling1D) (None, 7, 64)             0         \n",
      "_________________________________________________________________\n",
      "lstm (LSTM)                  (None, 64)                33024     \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 1)                 65        \n",
      "=================================================================\n",
      "Total params: 66,777,753\n",
      "Trainable params: 129,153\n",
      "Non-trainable params: 66,648,600\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Embedding(vocab_size+1, embedding_dim, input_length=max_length, weights=[embeddings_matrix], trainable=False),\n",
    "    tf.keras.layers.Dropout(0.2),\n",
    "    tf.keras.layers.Conv1D(64, 5, activation='relu'),\n",
    "    tf.keras.layers.MaxPooling1D(pool_size=4),\n",
    "    tf.keras.layers.LSTM(64),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1240816 samples, validate on 65306 samples\n",
      "Epoch 1/6\n",
      "1240816/1240816 [==============================] - 72s 58us/step - loss: 0.0982 - acc: 0.9606 - val_loss: 0.1058 - val_acc: 0.9585\n",
      "Epoch 2/6\n",
      "1240816/1240816 [==============================] - 71s 57us/step - loss: 0.0965 - acc: 0.9612 - val_loss: 0.1051 - val_acc: 0.9594\n",
      "Epoch 3/6\n",
      "1240816/1240816 [==============================] - 73s 59us/step - loss: 0.0946 - acc: 0.9618 - val_loss: 0.1071 - val_acc: 0.9583\n",
      "Epoch 4/6\n",
      "1240816/1240816 [==============================] - 71s 58us/step - loss: 0.0932 - acc: 0.9624 - val_loss: 0.1053 - val_acc: 0.9592\n",
      "Epoch 5/6\n",
      "1240816/1240816 [==============================] - 71s 57us/step - loss: 0.0920 - acc: 0.9628 - val_loss: 0.1059 - val_acc: 0.9596\n",
      "Epoch 6/6\n",
      "1240816/1240816 [==============================] - 71s 57us/step - loss: 0.0909 - acc: 0.9631 - val_loss: 0.1071 - val_acc: 0.9586\n",
      "Training Complete\n"
     ]
    }
   ],
   "source": [
    "training_step = len(training_labels)//batch_size\n",
    "validation_step = len(val_labels)//batch_size\n",
    "\n",
    "history = model.fit(training_sequences, \n",
    "                    training_labels, \n",
    "                    epochs=num_epochs, \n",
    "                    batch_size=batch_size,\n",
    "                    validation_data=(val_sequences, val_labels), \n",
    "                    verbose=1)\n",
    "\n",
    "model.save(\"model.h5\")\n",
    "model.save_weights(\"weights.h5\")\n",
    "model_str = model.to_json()\n",
    "f = open(\"model_json.json\", \"w\")\n",
    "f.write(model_str)\n",
    "f.close()\n",
    "\n",
    "print(\"Training Complete\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import load_model\n",
    "from keras.models import model_from_json\n",
    "\n",
    "#model = load_model(\"model.h5\")\n",
    "json_file = open('model_json.json', 'r')\n",
    "loaded_model_json = json_file.read()\n",
    "json_file.close()\n",
    "model = model_from_json(loaded_model_json)\n",
    "model.load_weights(\"weights.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Drawing Accuracy & Loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qxju4ItJKO8F"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xmc1fP+wPHX21TSor1QUoT2zShb2kSFUkJFJEl+hOvStS/Xci1dSy6RpZQU1W0hcaOQLe1pJRkq7aV9n/fvj/d3mmPMcmrmzHdmzvv5eMxjzvl+v+d73t9zZs77fHZRVZxzzrkjdVTYATjnnMvfPJE455zLFk8kzjnnssUTiXPOuWzxROKccy5bPJE455zLFk8kLkeISIKI7BCRqjl5bJhEpIaI5Hj/eBG5QESSIu4vE5Fm0Rx7BM/1hojcd6SPdy4ahcIOwIVDRHZE3C0G7AUOBvdvUtURh3M+VT0IlMjpY+OBqp6eE+cRkd7ANaraIuLcvXPi3M5lxhNJnFLVQx/kwTfe3qr6aUbHi0ghVT2QG7E5lxX/e8xbvGrLpUtEHheR90RkpIhsB64RkbNF5DsR+UNE1ojIQBEpHBxfSERURKoF998J9k8Wke0i8q2IVD/cY4P97UTkRxHZKiIvicjXItIzg7ijifEmEVkuIltEZGDEYxNE5HkR2SQiK4C2mbw+94vIqDTbXhaR54LbvUVkSXA9PwelhYzOtUpEWgS3i4nI8CC2RcAZaY59QERWBOddJCIdgu31gP8AzYJqw40Rr+0jEY/vG1z7JhEZLyLHR/PaHM7rnBKPiHwqIptFZK2I9I94ngeD12SbiMwSkRPSq0YUka9S3ufg9fwyeJ7NwAMicqqITAueY2PwupWKePxJwTVuCPa/KCJFg5hrRRx3vIjsEpFyGV2vy4Kq+k+c/wBJwAVptj0O7AMuxb5wHAOcCTTFSrInAz8CtwbHFwIUqBbcfwfYCCQChYH3gHeO4NiKwHagY7DvTmA/0DODa4kmxglAKaAasDnl2oFbgUVAFaAc8KX9i6T7PCcDO4DiEedeDyQG9y8NjhGgFbAbqB/suwBIijjXKqBFcHsA8DlQBjgJWJzm2CuB44P3pHsQQ6VgX2/g8zRxvgM8Ety+MIixIVAUeAWYGs1rc5ivcylgHXA7cDRwLNAk2HcvMB84NbiGhkBZoEba1xr4KuV9Dq7tAHAzkID9PZ4GtAaKBH8nXwMDIq5nYfB6Fg+OPzfYNxh4IuJ5/g6MC/v/MD//hB6A/4T/Q8aJZGoWj7sLGB3cTi85vBpxbAdg4REc2wuYHrFPgDVkkEiijPGsiP3/Be4Kbn+JVfGl7Guf9sMtzbm/A7oHt9sByzI59kPgluB2Zonkt8j3Avi/yGPTOe9C4OLgdlaJ5G3gyYh9x2LtYlWyem0O83XuAczM4LifU+JNsz2aRLIiixi6pDwv0AxYCySkc9y5wC+ABPfnAZ1z+v8qnn68astlZmXkHRGpKSKTgqqKbcA/gfKZPH5txO1dZN7AntGxJ0TGofafvyqjk0QZY1TPBfyaSbwA7wLdgtvdg/spcVwiIjOCapc/sNJAZq9ViuMzi0FEeorI/KB65g+gZpTnBbu+Q+dT1W3AFqByxDFRvWdZvM4nYgkjPZnty0rav8fjROR9EVkdxDA0TQxJah07/kRVv8ZKN+eJSF2gKjDpCGNyeBuJy1zarq+vYd+Aa6jqscBDWAkhltZg35gBEBHhzx98aWUnxjXYB1CKrLonvw9cICKVsaq3d4MYjwHGAP/Cqp1KA/+LMo61GcUgIicDg7DqnXLBeZdGnDerrsq/Y9VlKecriVWhrY4irrQye51XAqdk8LiM9u0MYioWse24NMekvb6nsd6G9YIYeqaJ4SQRScggjmHANVjp6X1V3ZvBcS4Knkjc4SgJbAV2Bo2VN+XCc34INBaRS0WkEFbvXiFGMb4P3CEilYOG139kdrCqrsWqX4Zi1Vo/BbuOxurtNwAHReQSrC4/2hjuE5HSYuNsbo3YVwL7MN2A5dQbsRJJinVAlchG7zRGAjeISH0RORpLdNNVNcMSXiYye50nAlVF5FYROVpEjhWRJsG+N4DHReQUMQ1FpCyWQNdinToSRKQPEUkvkxh2AltF5ESsei3Ft8Am4EmxDgzHiMi5EfuHY1Vh3bGk4rLBE4k7HH8HrsMav1/DGsVjSlXXAVcBz2EfDKcAc7Fvojkd4yDgM+AHYCZWqsjKu1ibx6FqLVX9A/gbMA5rsO6CJcRoPIyVjJKAyUR8yKnqAuAl4PvgmNOBGRGPnQL8BKwTkcgqqpTHf4xVQY0LHl8VuDrKuNLK8HVW1a1AG+ByLLn9CDQPdj8LjMde521Yw3fRoMryRuA+rONFjTTXlp6HgSZYQpsIjI2I4QBwCVALK538hr0PKfuTsPd5r6p+c5jX7tJIaWxyLl8Iqip+B7qo6vSw43H5l4gMwxrwHwk7lvzOByS6PE9E2mI9pHZj3Uf3Y9/KnTsiQXtTR6Be2LEUBF615fKD84AVWNvARUAnbxx1R0pE/oWNZXlSVX8LO56CwKu2nHPOZYuXSJxzzmVLXLSRlC9fXqtVqxZ2GM45l6/Mnj17o6pm1t0eiJNEUq1aNWbNmhV2GM45l6+ISFazOwBeteWccy6bPJE455zLFk8kzjnnsiUu2kjSs3//flatWsWePXvCDsXlIUWLFqVKlSoULpzRdFXOubTiNpGsWrWKkiVLUq1aNWxCWRfvVJVNmzaxatUqqlevnvUDnHNAHFdt7dmzh3LlynkScYeICOXKlfNSqnOHKW4TCeBJxP2F/004d/jitmrLOecKJFX47TeYPdt+broJqma1Rlv2eCIJ2fjx4+nUqRNLliyhZs2aWT/AOedSRCaNWbNSk8emTbY/IQHOOccTSUE3cuRIzjvvPEaOHMmjjz4ak+c4ePAgCQkZrTjqnMsXVOHXX1OTRdqkUagQ1KkDHTvCGWfYT/36cMwxMQ8tpokkWEfiRSABeENVn0qzvwzwFrbq3R6gl6ouDPaVxpblrIstL9pLVb8VkcewdQSSgfVAT1X9PZbXESs7duzgq6++Ytq0aVx66aWHEsnTTz/NO++8w1FHHUW7du146qmnWL58OX379mXDhg0kJCQwevRoVq5cyYABA/jwQ1t879ZbbyUxMZGePXtSrVo1rrrqKqZMmUL//v3Zvn07gwcPZt++fdSoUYPhw4dTrFgx1q1bR9++fVmxYgUAgwYN4uOPP6Zs2bLccccdANx///1UrFiR22+/PZwXyrl4czhJIzExNWkULRpKuDFLJMFKdi9jS26uAmaKyERVXRxx2H3APFXtJCI1g+NT1rZ+EfhYVbuISBGgWLD9WVV9MHiO24CHgL7ZCvaOO2DevGyd4i8aNoQXXsj0kAkTJtC2bVtOO+00ypUrx+zZs1m/fj0TJkxgxowZFCtWjM2bNwNw9dVXc88999CpUyf27NlDcnIyK1euzPT85cqVY86cOQBs2rSJG2+8EYAHHniAN998k379+nHbbbfRvHlzxo0bx8GDB9mxYwcnnHACnTt35o477iA5OZlRo0bx/fe+jpRzMZGSNCKrpubM+XPSqFsXLrvszyWNkJJGemJZImkCLFfVFQAiMgorSUQmktrAUwCqulREqolIJax0cj7QM9i3D9gX3N4W8fjiWGklXxo5cuShb/ldu3Zl5MiRqCrXX389xYpZ3ixbtizbt29n9erVdOrUCbBBc9G46qqrDt1euHAhDzzwAH/88Qc7duzgoosuAmDq1KkMG2bLgickJFCqVClKlSpFuXLlmDt3LuvWraNRo0aUK1cux67bubilCklJfy1pBF8Y80PSSE8sE0llIPIr8yqgaZpj5gOdgeki0gQ4CagCHMRWwxsiIg2A2cDtqroTQESeAK4FtgIt03tyEekD9AGomlVDUxYlh1jYvHkzU6dO5YcffkBEOHjwICLCFVdcEfU5ChUqRHJy8qH7acc/FC9e/NDtnj17Mn78eBo0aMDQoUP5/PPPMz137969GTp0KGvXrqVXr15Rx+ScC6RNGrNmWUkjbdLo3Dk1adSrl+eTRnrCHkfyFFBaROYB/YC5WBIpBDQGBqlqI2AncE/Kg1T1flU9ERgB3JreiVV1sKomqmpihQpZTqef68aMGUOPHj349ddfSUpKYuXKlVSvXp1SpUoxZMgQdu3aBVjCKVmyJFWqVGH8+PEA7N27l127dnHSSSexePFi9u7dyx9//MFnn32W4fNt376d448/nv379zNixIhD21u3bs2gQYMAa5TfunUrAJ06deLjjz9m5syZh0ovzrkMqMIvv8Do0XDPPdCmDZQvDyefDFdcAQMGWFVV584waBB8/z1s3w5z58Lrr0PfvnDmmfkyiUBsSySrgRMj7lcJth0SVFNdDyA2EuwXbG3uYsAqVZ0RHDqGiEQSYQTwEfBwjkaeC0aOHMk//vGPP227/PLLWbJkCR06dCAxMZEiRYrQvn17nnzySYYPH85NN93EQw89ROHChRk9ejQnn3wyV155JXXr1qV69eo0atQow+d77LHHaNq0KRUqVKBp06Zs374dgBdffJE+ffrw5ptvkpCQwKBBgzj77LMpUqQILVu2pHTp0t7jy7lIKUkjbfXUli22v1AhK1mklDQSE+3+0UeHG3cMxWzNdhEpBPyINZ6vBmYC3VV1UcQxpYFdqrpPRG4EmqnqtcG+6UBvVV0mIo8AxVX1bhE5VVV/Co7pBzRX1S6ZxZKYmKhpF7ZasmQJtWrVyqnLLXCSk5Np3Lgxo0eP5tRTTw07nFzlfxvukMikkdIYPmdOatIoXNiqp1J6TqVUTxWQpCEis1U1MavjYlYiUdUDInIr8AnW/fctVV0kIn2D/a8CtYC3RUSBRcANEafoB4wIemytICi5AE+JyOlY999fyW6PLfcXixcv5pJLLqFTp05xl0RcHFOFFSv+XMpImzTq1YMuXQpk0siOmI4jUdWPsKqnyG2vRtz+Fjgtg8fOA/6SCVX18hwO06VRu3btQ+NKnCuQ0ksas2fDH3/Y/rRJIzHRSh6eNNLlI9udcwXftm0wZYo1cqf0nkqbNK68MrWk4UnjsHgicc4VTL/9Bh98ABMmwOefw/79ljTq1/ekkcM8kTjnCgZV6047YQJMnJg6W8Xpp9vsFR06WBdbTxo5zhOJcy7/2rsXpk2zxDFxIqxeDUcdZTPePvssXHqpJRIXU2EPSIxbLVu25JNPPvnTthdeeIGbb74508eVKFECgN9//50uXdLv9dyiRQvSdndO64UXXjg06BGgffv2/JFSZ5wDGjZsSNeuXXPsfM4dsnkzDB9uA/3Kl4d27eDtt6FJExg6FNauhenT4a67PInkEk8kIenWrRujRo3607ZRo0bRrVu3qB5/wgknMGbMmCN+/rSJ5KOPPqJ06dJHfL5IS5Ys4eDBg0yfPp2dO3fmyDnTc+DAgZid2+Uxy5fDc89BixZQsSJcey18/TV07w6TJtmo8f/+F667DvLgTBYFnSeSkHTp0oVJkyaxb98+AJKSkvj9999p1qwZO3bsoHXr1jRu3Jh69eoxYcKEvzw+KSmJunXrArB79266du1KrVq16NSpE7t37z503M0330xiYiJ16tTh4YdtAoCBAwfy+++/07JlS1q2tKnKqlWrxsaNGwF47rnnqFu3LnXr1uWFYB6ypKQkatWqxY033kidOnW48MIL//Q8kUaOHEmPHj248MIL/xT78uXLueCCC2jQoAGNGzfm559/Bmza/Hr16tGgQQPuuccmMIgsVW3cuJFq1aoBMHToUDp06ECrVq1o3bp1pq/VsGHDqF+/Pg0aNKBHjx5s376d6tWrs3//fgC2bdv2p/suD0lOhm+/hXvvtenSTz0V/v53K43ce6/1vlq1Cl57Ddq3z7dTixQU3kZCOLPIly1bliZNmjB58mQ6duzIqFGjuPLKKxERihYtyrhx4zj22GPZuHEjZ511Fh06dMhwPfFBgwZRrFgxlixZwoIFC2jcuPGhfU888QRly5bl4MGDtG7dmgULFnDbbbfx3HPPMW3aNMqXL/+nc82ePZshQ4YwY8YMVJWmTZvSvHlzypQpw08//cTIkSN5/fXXufLKKxk7dizXXHPNX+J57733mDJlCkuXLuWll16ie/fuQPpT4U+ePDndafMzM2fOHBYsWEDZsmU5cOBAuq/V4sWLefzxx/nmm28oX778oTnLWrRowaRJk7jssssYNWoUnTt3pnDhwlk+p8sFu3bBp59aW8cHH8D69bbCX/PmtlzspZdC9ephR+nS4SWSEEVWb0VWa6kq9913H/Xr1+eCCy5g9erVrFu3LsPzfPnll4c+0OvXr0/9+vUP7Xv//fdp3LgxjRo1YtGiRSxevDij0wDw1Vdf0alTJ4oXL06JEiXo3Lkz06dPB6B69eo0bNgQgDPOOIOkpKS/PH7WrFmUL1+eqlWr0rp1a+bOncvmzZvTnQq/WLFifPrpp3+ZNj8rbdq0OXRcRq/V1KlTueKKKw4lypTje/fuzZAhQwAYMmQI119/ffpP4nLHunXw5pu2QFP58vZ79Gho2RLefRc2bIDPPoPbbvMkkod5iYRQZpEHoGPHjvztb39jzpw57Nq1izPOOAOAESNGsGHDBmbPnk3hwoWpVq3aX6aIj8Yvv/zCgAEDmDlzJmXKlKFnz55HdJ4UR0d0m0xISEi3amvkyJEsXbr0UFXUtm3bGDt27GE3vEdOkZ/Z9PiH+1qde+65JCUl8fnnn3Pw4MFD1YMul6jCkiWpvay++862Va0KvXtbF93zz4ciRcKO1B0GL5GEqESJErRs2ZJevXr9qZF969atVKxYkcKFCzNt2jR+/fXXTM9z/vnn8+677wK2gNWCBQsA+xAvXrw4pUqVYt26dUyePPnQY0qWLHloBuBIzZo1Y/z48ezatYudO3cybtw4mjVrFtX1JCcn8/777/PDDz+QlJREUlISEyZMYOTIkRlOhd+mTZu/TJsP1mYze/ZsgEw7FWT0WrVq1YrRo0ezKVhlLrLK7Nprr6V79+5eGsktBw7AF19YG8dpp1mbx7332gDBRx+1euWkJBg4EC64wJNIPuSJJGTdunVj/vz5f0okV199NbNmzaJevXoMGzaMmjVrZnqOm2++mR07dlCrVi0eeuihQyWbBg0a0KhRI2rWrEn37t0599xzDz2mT58+tG3b9lBje4rGjRvTs2dPmjRpQtOmTendu3em09NHmj59OpUrV+aEE044tO38889n8eLFrFmzhuHDhzNw4EDq16/POeecw9q1a2nbtu2hafMbNmzIgAEDALjrrrsYNGgQjRo1OtQJID0ZvVZ16tTh/vvvp3nz5jRo0IA777zzT4/ZsmVL1D3k3BHYvh3GjLHeVZUqWW+r//zHGs0HDYKVK2HmTHjwQWjQADJo/3P5Q8ymkc9LfBp5F2nMmDFMmDCB4cOHp7vf/zaO0KpV1kg+cSJMnQr79kHZsnDJJVZldeGFULJk2FG6wxD6NPLO5UX9+vVj8uTJfPTRR1kf7DKnCvPnp7Z3BFWR1KgB/fpZ8jjnHFvoyRVo/g67uPLSSy+FHUL+tm+ftXekJI/ffrNqqbPPhqeesuRRs6ZXVcWZuE4kqprh2AwXn+KhqvewbdkCkydb4pg82aZkP+YYq6p6+GG4+GJrB3FxK24TSdGiRdm0aRPlypXzZOIASyKbNm2iqI+StuVlU0odX35pPa8qVbLp1zt0sN5VxxwTdpQuj4jbRFKlShVWrVrFhg0bwg7F5SFFixalSpUqYYeR+5KTbcGniRNtGvaFC217nTpw992WPJo0sZl1nUsjbhNJ4cKFqe4jZV08273beldNmGC9rdautSlJmjWzCRI7dIBTTgk7SpcPxG0icS4uqVryePVV+Ogjm9+qZElo29YSR/v21mXXucPgicS5eLBtm63Z8corsHQplCsHPXva3FbNm/uqgS5bPJE4V5AtXAgvv2wLQe3cae0cb79tjebeqcDlEE8kzhU0+/fD+PGWQL74wkobXbvCLbfYmuXO5TBPJM4VFGvWwODB9vP771CtGjz9NPTqZVO0Oxcjnkicy89U4auvrPQxdqyN92jb1lYObNfOemE5F2OeSJzLj3bsgBEjLIH88AOULm3zW918s82w61wu8kTiXH6ybJn1vBo61HpiNWwIr78O3bpBxIJfzuUmTyTO5XUHD8KHH1rpY8oUKFwYunSxxvNzzvEJEl3oPJE4l1dt2ABvvGGDB3/7DSpXhscesyVpjzsu7OicO8QTiXN5iSp8/72VPt57z6Ztb9kSnn/eRp772h4uD/K/Sufygt27YdQoSyCzZ0OJEnDjjfB//we1a4cdnXOZ8kTiXJh++cXWMH/zTdi8GWrVsmTSo4cvS+vyjZjOCS0ibUVkmYgsF5F70tlfRkTGicgCEfleROpG7CstImNEZKmILBGRs4PtzwbbFgSPLR3La3AuxyUn2wJRl1xis+s+95xVX02dCosWWSnEk4jLR2KWSEQkAXgZaAfUBrqJSNoy+n3APFWtD1wLvBix70XgY1WtCTQAlgTbpwB1g8f8CNwbq2twLkdt2WJJ47TTbJbdWbPggQcgKQnGjLFk4j2wXD4Uy6qtJsByVV0BICKjgI7A4ohjagNPAajqUhGpJiKVgD3A+UDPYN8+YF9w+38Rj/8O6BLDa3Au++bOteqqd9+1tpBzz7XeV5dfDkWKhB2dc9kWy0RSGVgZcX8V0DTNMfOBzsB0EWkCnARUAQ4CG4AhItIAmA3crqo70zy+F/Beek8uIn2APgBVq1bN3pU4d7j27rVSxssvw7ffQrFicM01NvajQYOwo3MuR4W9buZTQGkRmQf0A+ZiSaQQ0BgYpKqNgJ3An9pYROR+4AAwIr0Tq+pgVU1U1cQKFSrE8BKci7BypVVXVa1qiWPDBuu6u3q1TaboScQVQLEskawGToy4XyXYdoiqbgOuBxARAX4BVgDFgFWqOiM4dAwRiUREegKXAK1VVWMUv3PRSVl18OWXbdlaVWtIv+UWaNPG1zl3BV4sE8lM4FQRqY4lkK5A98gDgh5Xu4I2kN7Al0Fy2SYiK0XkdFVdBrQmaFsRkbZAf6C5qu6KYfzOZW7bNhg2zBJIyqqDd98NffvaFO7OxYmYJRJVPSAitwKfAAnAW6q6SET6BvtfBWoBb4uIAouAGyJO0Q8YISJFsFLK9cH2/wBHA1OsEMN3qto3Vtfh3F8sWpS66uCOHbZY1NChcNVVvuqgi0sSDzVDiYmJOmvWrLDDcPmZrzro4pCIzFbVxKyO85HtzmVmzRqbpv2112zVwZNO8lUHnUvDE4lzaaW36uBFF9ksvO3b+6qDzqXhicS5FDt3pq46uGABlCrlqw46FwVPJM79+GPqqoNbt9pYj8GDoXt3X3XQuSh4InHxaf9+mDjRZt797DNfddC5bPBE4uLLypXWeP7GG9aQXrUqPP443HCDrzro3BHyROIKvuRk+N//rLH8gw+sMb1dO+uJ5Y3nzmWbJxJXcG3YAEOGWMJYsQIqVID+/aFPH6hePezonCswPJG4gkUVvv7aSh+jR9ua5+efD088AZ062UBC51yO8kTiCoZt2+Cdd6zxfOFCOPZYK3n07Qt16oQdnXMFmicSl7/Nm2fJY8QIGwfSuLE1pnfr5l13ncslnkhc/rN7t1VbDRoE331nEyV27WoDB88807vuOpfLPJG4/OOnn6ztY+hQ2LwZTj/dFo267jooUybs6JyLW55IXN6WMnDw1Vfh00+hUCFrNO/bF1q29NKHc3mAJxKXN61aZW0dr79uAwdPPBEee8wGDh5/fNjROecieCJxeUdyMkyZkjpwMDkZ2rZNnXW3kP+5OpcX+X+mC9/GjakDB3/+2db5uOsu67578slhR+ecy4InEhcOVfjmG+t5lTJwsFkzq77q3NkHDjqXj3gicblr2zYb8zFoEPzwA5QsCTfeaI3ndeuGHZ1z7gh4InG5Y/781IGDO3ZAo0a25ke3blCiRNjROeeywROJi509e1IHDn77rQ0cvOoqGzjYpIl33XWugPBE4nLeTz9Zw/mQITZw8LTT4LnnbOBg2bJhR+ecy2GeSFzOOHAgdeDglCnWVfeyy6zto1UrL304V4B5InHZs3p16sDB33+HKlXgn/+E3r194KBzccITiTt8yck2XcmgQakDBy+6yO77wEHn4o7/x7vobdqUOnBw+XIbOPj3v8NNN/nAQefimCcSlzlV63GVMnBw71447zx49FG4/HIfOOicyzqRiEg/4B1V3ZIL8bi8Yvv21IGDCxbYwMEbbrDG83r1wo7OOZeHRFMiqQTMFJE5wFvAJ6qqsQ3LhWbBAkse77xjAwcbNrSqrO7dfeCgcy5dWSYSVX1ARB4ELgSuB/4jIu8Db6rqz7EO0OWCXbvgvfcsYcyYkTpwsG9faNrUu+465zIVVRuJqqqIrAXWAgeAMsAYEZmiqv1jGaCLoR9+sOTxzjuwdSvUrGkrDvboAeXKhR2dcy6fiKaN5HbgWmAj8AZwt6ruF5GjgJ8ATyT5ya5d8P77lkC++84ay7t0sSnbmzXz0odz7rBFUyIpC3RW1V8jN6pqsohcEpuwXI5buNCSx/DhVvo4/XT4979t2hIvfTjnsuGoKI6ZDGxOuSMix4pIUwBVXZLZA0WkrYgsE5HlInJPOvvLiMg4EVkgIt+LSN2IfaVFZIyILBWRJSJydrD9ChFZJCLJIpIY7YXGpd274e234dxzrafV4ME2YPDzz2HJErjzTk8izrlsiyaRDAJ2RNzfEWzLlIgkAC8D7YDaQDcRqZ3msPuAeapaH6s+ezFi34vAx6paE2gApCSthUBn4MsoYo9PixbB7bfDCSdAz562AuGAATadybvvQvPmXoXlnMsx0VRtSWR336BKK5rHNQGWq+oKABEZBXQEFkccUxt4KjjvUhGpJiKVgD3A+UDPYN8+YF9we0lwvihCiCO7d8OYMVZ99fXXULiwDRi86SZPHM65mIqmRLJCRG4TkcLBz+3AiigeVxlYGXF/VbAt0nysdIGINAFOAqoA1YENwBCDJ+EwAAAdOUlEQVQRmSsib4hI8Sie8xAR6SMis0Rk1oYNGw7nofnL4sVwxx1QuTJcey2sXw/PPmulj5EjoUULTyLOuZiKJpH0Bc4BVmPJoCnQJ4ee/ymgtIjMA/oBc4GDWEmpMTBIVRsBO4G/tLFkRlUHq2qiqiZWqFAhh8LNI/bssS67zZpBnTrwyitw4YUwdSosWwZ33QUF7Zqdc3lWNAMS1wNdj+Dcq4ETI+5XCbZFnnsbNsgRsbqqX7DSTjFglarOCA4dw2EmkgJp6VKruho2zBaMqlEDnnnGel5VrBh2dM65OBXNOJKiwA1AHaBoynZV7ZXFQ2cCp4pIdSyBdAW6pzl3aWBX0AbSG/gySC7bRGSliJyuqsuA1vy5bSV+7NkDY8daj6svv7S2j06dbNxHy5ZwVDSFSueci51oGs2HA0uBi4B/AleT2oMqQ6p6QERuBT4BEoC3VHWRiPQN9r8K1ALeFhEFFmEJK0U/YISIFMFKKSkll07AS0AFYJKIzFPVi6K52Hxl6VJbLOrtt2369pNPhqeeguuv99KHcy5PkazmXxSRuaraSEQWqGp9ESkMTFfVs3InxOxLTEzUWbNmhR1G1vbuhf/+16qvvvgidbnam26y5Wq99OGcy0UiMltVsxyvF02JZH/w+49gwOBawL8S56Qff7Sqq6FDU0sf//qXlT4qVQo7Ouecy1Q0iWSwiJQBHgAmAiWAB2MaVTzYuxfGjbMEMm2alT46drTSR+vWXvpwzuUbmSaSYGLGbcGiVl8Cvp5qdv30k7V9DBliI86rV4cnn7TSx3HHhR2dc84dtkwTSTCKvT/wfi7FUzDt2wfjx1vbx9SpkJCQWvq44AIvfTjn8rVoqrY+FZG7gPewgYEAqOrmjB/iAFi+PLX0sWEDnHQSPP449OoFxx8fdnTOOZcjokkkVwW/b4nYpng1V/r27YMJE6z08dlnVvro0MHGfbRpY/edc64AiWZke/XcCCTf+/nn1NLH+vVQtSo89piVPk44IezonHMuZqIZ2X5tettVdVjOh5PP7N9vpY/Bg2HKFCttXHKJtX1ceKGXPpxzcSGaqq0zI24XxaYrmQPEbyJZsQLeeAPeegvWrYMTT4R//tNKH5XTTnDsnHMFWzRVW/0i7wfzY42KWUR51f798MEH1vbxv/9ZT6uU0sdFF3npwzkXt6IpkaS1E1svJD4kJVnbx1tvwdq1Vvp49FErfVSpEnZ0zjkXumjaSD7AemmBrV9Sm3gZV3L33fDvf9vCUBdfbD2v2rXz0odzzkWIpkQyIOL2AeBXVV0Vo3jylrPPhoceghtusJKIc865v4gmkfwGrFHVPQAicoyIVFPVpJhGlhd07mw/zjnnMhTN3ByjgeSI+weDbc4551xUiaRQsIIhAMHtIrELyTnnXH4STSLZICIdUu6ISEdgY+xCcs45l59E00bSF1vy9j/B/VVAuqPdnXPOxZ9oBiT+DJwlIiWC+ztiHpVzzrl8I8uqLRF5UkRKq+oOVd0hImVE5PHcCM4551zeF00bSTtV/SPlTrBaYvvYheSccy4/iSaRJIjI0Sl3ROQY4OhMjnfOORdHomlsHwF8JiJDAAF6Am/HMijnnHP5RzSN7U+LyHzgAmzOrU+Ak2IdmHPOufwhmqotgHVYErkCaAUsiVlEzjnn8pUMSyQichrQLfjZCLwHiKq2zKXYnHPO5QOZVW0tBaYDl6jqcgAR+VuuROWccy7fyKxqqzOwBpgmIq+LSGussd0555w7JMNEoqrjVbUrUBOYBtwBVBSRQSJyYW4F6JxzLm/LsrFdVXeq6ruqeilQBZgL/CPmkTnnnMsXou21BdiodlUdrKqtYxWQc865/OWwEolzzjmXVkwTiYi0FZFlIrJcRO5JZ38ZERknIgtE5HsRqRuxr7SIjBGRpSKyRETODraXFZEpIvJT8LtMLK/BOedc5mKWSEQkAXgZaAfUBrqJSO00h90HzFPV+tgaJy9G7HsR+FhVawINSB0EeQ/wmaqeCnwW3HfOOReSWJZImgDLVXVFsDzvKKBjmmNqA1MBVHUpUE1EKolIKeB84M1g376IGYg7kjrX19vAZTG8Buecc1mIZSKpDKyMuL8q2BZpPjZeBRFpgs3hVQWoDmwAhojIXBF5Q0SKB4+ppKprgttrgUrpPbmI9BGRWSIya8OGDTlyQc455/4q7Mb2p4DSIjIP6Id1LT6IjbhvDAxS1UbATtKpwlJVxeYA+4ugd1miqiZWqFAhVvE751zci2Ya+SO1Gjgx4n6VYNshqroNuB5ARAT4BVgBFANWqeqM4NAxpCaSdSJyvKquEZHjgfWxuwTnnHNZiWWJZCZwqohUF5EiQFdgYuQBQc+sIsHd3sCXqrpNVdcCK0Xk9GBfa2BxcHsicF1w+zpgQgyvwTnnXBZiViJR1QMiciu2fkkC8JaqLhKRvsH+V4FawNsiosAi4IaIU/QDRgSJZgVByQWrDntfRG4AfgWujNU1OOecy5pYM0PBlpiYqLNmzQo7DOecy1dEZLaqJmZ1XNiN7c455/I5TyTOOeeyxROJc865bPFE4pxzLls8kTjnnMsWTyTOOeeyxROJc865bPFE4pxzLls8kTjnCrz9+2HuXNi7N+xICiZPJM65AmnvXvjwQ7j+ejjuOGjcGBITYf78sCMreDyROOcKjJ07YexY6N4dKlSASy+FceOgfXsYOBA2boQmTWDAAEhODjvagiOW08g751zMbdtmJY+xY2HyZNi9G8qVgyuvhMsvh9atoUgwx3i3bnDTTXD33TBpErz9NlStGm78BYEnEudcvrNpE0yYYMnj009h3z44/njo1cuSR7NmUCidT7fy5WHMGBg6FG67DerXh1desRKMO3KeSJxz+cLatVZNNXYsfP45HDwIJ50Et95qyeOss+CoKCrrRazdpHlzuPZauPpq+OADSyhlysT8MgokTyTOuTzrt9/gv/+15PH116AKp50G/ftb8mjc2BLDkTj5ZPjiC3j6aXj4YfjqK6vqatUqZ68hHnhju3MuT1m+3D7cmzSxEsff/gZbt9qH/Q8/wNKl8OSTcMYZR55EUiQkwH33wbffQvHi1p5y552wZ0/OXEu88BKJcy5UqrB4sZU6xo6FBQtse2Ii/OtfVvI49dTYxpCYCHPmWEnn+edhyhQYMcLaUFzWPJG4P1myxPrfN2wYdiSuIFO1D+6xY63qatkyK12ce659kHfunPu9qYoVg//8By6+2BrtzzwTnnjCSijRtL3EM395HGBF+fvvh3r1rMrg8cetMdO5nJKcDN98A3//u7VPJCbCM89AlSrW0L16NUyfDnfcEW6X3HbtrArt4outm3Dr1tZW4zLma7Y7vv4abrjBvhX27GklkpEjoUULeOcdqFw57AhdfnXggCWHsWOtx9Xvv0PhwtCmjVVZdehgXXLzItXUbsIJCfHZTdjXbHdZ2r4d+vWzPvd79sAnn8CQIVY3PGQIfP89NGhgA7eci9a+ffDxx3DjjTa2o1UreOstaNrUvphs2GB/U7165d0kAqndhOfPhzp1rJtwt26wZUvYkeVBqlrgf8444wx1fzZ5smrVqqoiqrfdprp9+1+PWbJEtUEDVVC94w7VPXtyP06XP+zapTp+vGqPHqqlStnfTIkSql27qo4erbpjR9gRZs/+/aqPP65aqJBqlSqqn30WdkS5A5ilUXzGhv4hnxs/nkhSbdyoeu219s7XqqX6zTeZH797t2q/fnZ848aqP/6YO3G6vG/7dtVRo1SvvFK1eHH7GylTRvW661QnTrS/nYJm5kzV00+3a73zzoJ5jZE8kXgi+ZPkZNX331etWNG+VT344OGVMMaPVy1b1r5lDhsWuzhd3rZ5s+rbb6t26KB69NH2CVKxomqfPqqffKK6b1/YEcbezp2q//d/du316qkuWBB2RLHjicQTySGrV6t27GjvdmKi6vz5R3aelStVzz/fztOjh+q2bTkbp8ub1q9XHTxY9aKL7EsIWPXObbepfv656oEDYUcYjkmTVCtVUi1SRHXAANWDB8OOKOd5IvFEosnJqq+/bnXWRYuqPvus1fVmx4EDqo88onrUUaqnnqo6e3bOxOryllWrVF96SbVFC3uvQfXkk1Xvvlv1u+8K5ofmkVi/XvWyy+z1adlS9bffwo4oZ3kiifNEsny5aqtW9g63aKH60085e/4vvlCtXFm1cGHV55+3pOXytxUr7Jv12Wfb301KO9oDD6jOnevvcUaSk1XffNOqfUuVUn333bAjyjmeSOI0kRw4YB8GxxyjeuyxViURq2+PGzeqXnqp/RVdfLF9O3P5y5Ilqk88YR0pUpJHw4aqjz2munhx2NHlL8uXpybhbt2sPSm/80QSh4lkwQLVM8+0d/XSS616ItaSk1UHDrR64uOPV506NfbP6bJn2zZLHnXqpCaPpk1Vn3lG9eefw44uf9u/35JwSjfh/P7/EG0i8QGJBcDevTYzauPGkJQEo0bZoj+5MSJdxAY1zpgBxx5r00k89JCNaHZ5y4ED8NprNgHi/ffbKoIvvggrV8J339l0ICefHHaU+VuhQvDAAzYVTLFi9v9w1132P1qgRZNt8vtPQS6RfPutau3a9q3ymmtUN2wIL5bt21V79rRYzjtP9ddfw4vFpUpOVv3wQ2vvSHlvvvsu7KgKvh07VG++WfN1N2G8RFKw7dxp6zScc45NdTJpEgwfHu6UEyVKpE6xMn++zSA8blx48TiYOxcuuAAuuQT277eZdr/80qYrcbFVvLjNzzVpEqxfb5NUPvecTV5Z0HgiyYc+/RTq1oUXXoCbb4aFC6F9+7CjStW9u32AnXKKTQd+yy2we3fYUcWXlSvhuutsJuf582HgQFi0CDp1yv5iUO7wtG9vswm3a2czH7dpY+9PQRLTRCIibUVkmYgsF5F70tlfRkTGicgCEfleROpG7EsSkR9EZJ6IzIrY3kBEvg32fSAix8byGvKSLVtslt42baBIEftm+fLL1jaR15xyis0q/Pe/27eypk1trRMXW9u22Yp/p50G771nCzUtX27tWEWKhB1d/KpQwUrnb7xh7Yn161tbZoERTf3XkfwACcDPwMlAEWA+UDvNMc8CDwe3awKfRexLAsqnc96ZQPPgdi/gsaxiKQhtJGPHqh53nGpCguq99+avOX4++ki1QgXrkvz66z4eIRb27VN9+WV7nUH16qtVk5LCjsqlJ7KbcPfuqlu2hB1RxsgDbSRNgOWqukJV9wGjgI5pjqkNTAVQ1aVANRGplMV5TwO+DG5PAS7PuZDznrVroUsXW7vhuONg5kxbr7po0bAji167dla9cs45NrV4t262BrfLPlWYONEWJLvlFqhd2/5G3nnH1jt3ec8pp1htwj//aaXG+vVh2rSwo8qeWCaSykBkTeCqYFuk+UBnABFpApwEVAn2KfCpiMwWkT4Rj1lEakK6AjgxvScXkT4iMktEZm3YsCFbFxIGDRbVqV0bPvzQ1q7+/nto1CjsyI7M8cfbeidPPgljxth1zJgRdlT528yZtvhYx+C/YcIE+0BKzHIZIhe2QoXgwQfh22/hmGOsm/Ddd+ffbsJhN7Y/BZQWkXlAP2AukLLA63mq2hBoB9wiIucH23sB/ycis4GSwL70Tqyqg1U1UVUTK1SoENOLyGlJSXDRRbaoTp069m3+nntsZbn8LCEB7r3Xvo0lJ8N558HTTxfMXiyxlJRkiyw1aWLtTq+8Yo25HTp4Q3p+c+aZtnb9TTfBgAH2nv7wQ9hRHYFo6r+O5Ac4G/gk4v69wL2ZHC9Yu8ix6ex7BLgrne2nAd9nFUt+aSM5cED1xRdtbYcSJazOu6BOjrdli2qXLlZP3KaN6tq1YUeU923Zotq/v03fXrSo6n33qW7dGnZULqd8+KFNyV+kiOq//503/vcJe4oUoBCwAqhOamN7nTTHlAaKBLdvBIYFt4sDJSNufwO0De5XDH4fBQwDemUVS35IJIsWpTbAtWsXH4P5kpNVX3vNPhQrVbL1LNxf7d1rXzDKlbMVLa+7ruDNMuvM+vWpSz60ahX++xx6IrEYaA/8iPXeuj/Y1hfoq6mllh+BZcB/gTLB9pODxDMfaxO5P+KctweP+RGrGpOs4sjLiWTvXpubp0gR+6AYPjz+ejX98EPqvE/9+8fH4kjRSE623no1aqR+sMyZE3ZULtZSln8oXly1dGnVkSPDiyVPJJK88pNXE8nMmar169u70LWr6rp1YUcUnp07VW+6yV6LJk188sDvvlM991x7PWrXtkWU4u0LRrz76SfVs87SULsJR5tIwm5sj0u7dlkPjaZNYeNG620zciRUrBh2ZOEpVgxefRVGj4Zly6xX13vvhR1V7luxArp2hbPOsoGEr71mnS3at/eG9HhTowZMnw6PPpraTfjzz8OOKn2eSHLZ55/bH8SAATamYvFi623jTJcuMG+e9Vbr2hV697Z5xQq6zZttFoCaNW1cyEMPwU8/QZ8+1lXUxadChexv4ZtvbOxYq1Z5s5uwJ5JcsnWrdfFr2dLuT5tm38BLlQo3rryoWjX44gub6uOtt2xcxIIFYUcVG3v32kR+NWrA889Djx6WQB59FEqWDDs6l1c0aWLz10V2E164MOyoUnkiyQUffGADC994w75NLFhgA8lcxgoXhieegClT4I8/7B/nlVdsoGZBoArvvw+1allJ5MwzrST25pu5s46My3+KF4dBg+zzZO1a+4L1/PN5YxyWJ5IYWr/epgPp0MEWEZoxA555xtoDXHRat7Y2glatbAqQyy+3aqD87OuvbbqYq66yqfc//thG/devH3ZkLj+45BIbtHjRRXDnnXDhhbBqVbgxeSKJAVVbk6N2bVv/4bHHYNYsn7riSFWsaNPEDBhgvxs2hK++Cjuqw7d8ubUBnXce/PqrlT7mzrUPBOcOR8WKMH48DB5sq1vWqxdu5xRPJDls5Ur7xnDNNTaV99y5tvSmT+GdPUcdZVVA33xjr2Xz5vD443DwYNaPDdvGjXD77VaN9fHHNlnfTz9Br142bYxzR0LEOuzMmwenn26dU665xqqCc100fYTz+09ujCM5eNCmNClRQrVYMRuJfOBAzJ82Lm3dav3qQbVFC9VVq8KOKH27d6s+84xqqVKqRx2l2qeP6po1YUflCqL9+1UfecSWmTjxRNVp03LmvPg4ktyzbJk1nt9yC5x9tq1Ed9tt/m0zVo491qZJHzLEZkRu0MCqvPKK5GQbF1Szpi0sde651sHitddsKQDnclqhQvDww9b+ltJNuH//3Osm7IkkG/bvh6eesg+yhQtt2vdPPrHuqy62RKBnT5s59cQT4dJL4Y47wu9f/8UXNtC0e3coU8aWRZ40ycbFOBdrTZtadXqfPvDss3Z/8eLYP68nkiM0d669Sffeax9iixfbGtk++jh3nX66renQrx+8+KKVCH/8MffjWLYMLrvMSqZr1sDbb8Ps2dbrzLncVLy4jVGbOBE2bYI9e2L/nJ5IDtOePTZQ7swz7QNj7Fib1sOrLMJTtCgMHGi9WH79FRo3hmHDcue516+3Ks06deCzz2zsy48/wrXXWgcB58Jy6aXw88/2/xBr/qd+GL76yqqx/vUvK30sXgydO4cdlUvRsaONOTnjDHt/evSA7dtj81y7d9vfQY0a1vbRp491773vPh8n5PKO3Oot6okkCtu3w623QrNmsG+fjbZ+802rA3d5S5UqMHUqPPIIvPuufRubPTvnzp+cDMOHW5XafffZlDcLF9qo+0qVcu55nMtPPJFkYfJkq7Z45RVrzF24EC64IOyoXGYSEqwHy7RpVnI4+2x44YXsT68ydaoNKr32WhsQNm2azdxcs2bOxO1cfuWJJBP9+9v03SVL2kC455+3hiyXP5x/vlV1tWsHf/ub1Rlv2HD451m82AaZtm5tjZcjRli3Y58vzTnjiSQTLVrYFM5z5tj6EC7/KVfOGuFfesmqJBs0sJJENNatg759bfqJ6dPh6aetd1b37t6Q7lwk/3fIRPv2Np330UeHHYnLDhFr45oxwwYztm4NDz4IBw6kf/zOnTY/Wo0a1hZ2yy3W+6V/f+sh5pz7M08kLm40bGgN7z172jxdLVrAb7+l7j940EbLn3aalUTbtLFZCgYOhPLlw4raubzPE4mLK8WL22JZI0bYtCUNGtgMzVOmWA+vXr2s59f06bb9tNPCjti5vM8X8XRxqXt3m5mga1db4wRsaptRo+DKK32GAucOhycSF7dOOcUmuXv6aeuZd/PN3h7m3JHwROLiWpEi1vDunDty3kbinHMuWzyROOecyxZPJM4557LFE4lzzrls8UTinHMuWzyROOecyxZPJM4557LFE4lzzrlsEc3uaj/5gIhsAH49woeXBzbmYDj5gV9zfPBrjg/ZueaTVLVCVgfFRSLJDhGZpaqJYceRm/ya44Nfc3zIjWv2qi3nnHPZ4onEOedctngiydrgsAMIgV9zfPBrjg8xv2ZvI3HOOZctXiJxzjmXLZ5InHPOZYsnkkyISFsRWSYiy0XknrDjiTUReUtE1ovIwrBjyQ0icqKITBORxSKySERuDzumWBORoiLyvYjMD6750bBjyi0ikiAic0Xkw7BjyQ0ikiQiP4jIPBGZFdPn8jaS9IlIAvAj0AZYBcwEuqnq4lADiyEROR/YAQxT1bphxxNrInI8cLyqzhGRksBs4LIC/h4LUFxVd4hIYeAr4HZV/S7k0GJORO4EEoFjVfWSsOOJNRFJAhJVNeYDML1EkrEmwHJVXaGq+4BRQMeQY4opVf0S2Bx2HLlFVdeo6pzg9nZgCVA53KhiS82O4G7h4KfAf5sUkSrAxcAbYcdSEHkiyVhlYGXE/VUU8A+ZeCYi1YBGwIxwI4m9oIpnHrAemKKqBf6agReA/kBy2IHkIgU+FZHZItInlk/kicTFPREpAYwF7lDVbWHHE2uqelBVGwJVgCYiUqCrMUXkEmC9qs4OO5Zcdl7wPrcDbgmqrmPCE0nGVgMnRtyvEmxzBUjQTjAWGKGq/w07ntykqn8A04C2YccSY+cCHYI2g1FAKxF5J9yQYk9VVwe/1wPjsOr6mPBEkrGZwKkiUl1EigBdgYkhx+RyUNDw/CawRFWfCzue3CAiFUSkdHD7GKwzydJwo4otVb1XVauoajXs/3iqql4TclgxJSLFgw4kiEhx4EIgZr0xPZFkQFUPALcCn2CNsO+r6qJwo4otERkJfAucLiKrROSGsGOKsXOBHtg31HnBT/uwg4qx44FpIrIA+7I0RVXjojtsnKkEfCUi84HvgUmq+nGsnsy7/zrnnMsWL5E455zLFk8kzjnnssUTiXPOuWzxROKccy5bPJE455zLFk8kzmWDiByM6Do8LydniRaRavEyE7PL3wqFHYBz+dzuYBoK5+KWl0ici4FgLYhngvUgvheRGsH2aiIyVUQWiMhnIlI12F5JRMYF64TMF5FzglMliMjrwdoh/wtGoyMitwXrqCwQkVEhXaZzgCcS57LrmDRVW1dF7NuqqvWA/2CzzwK8BLytqvWBEcDAYPtA4AtVbQA0BlJmUTgVeFlV6wB/AJcH2+8BGgXn6Ruri3MuGj6y3blsEJEdqloine1JQCtVXRFMDLlWVcuJyEZsMa39wfY1qlpeRDYAVVR1b8Q5qmFTmJwa3P8HUFhVHxeRj7FFyMYD4yPWGHEu13mJxLnY0QxuH469EbcPktqueTHwMlZ6mSki3t7pQuOJxLnYuSri97fB7W+wGWgBrgamB7c/A26GQwtPlcropCJyFHCiqk4D/gGUAv5SKnIut/i3GOey55hgtcEUH6tqShfgMsEsu3uBbsG2fsAQEbkb2ABcH2y/HRgczLh8EEsqazJ4zgTgnSDZCDAwWFvEuVB4G4lzMRC0kSSq6sawY3Eu1rxqyznnXLZ4icQ551y2eInEOedctngicc45ly2eSJxzzmWLJxLnnHPZ4onEOedctvw/QuFCNxaGtMIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x211b10eea20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzt3Xl4lOX1//H3IQSQRZRNIICAQoEqKKTghqgoAiJxK4piEReEVlHb2lrb2trqr3WpWmyroKJVVIrighVEq1S0ChL4IgJugCj7piD7Es7vj/sJGWJIBiaTySSf13XNlZlnm/NkO3Pv5u6IiIgcrCqpDkBERNKbEomIiCREiURERBKiRCIiIglRIhERkYQokYiISEKUSCTlzCzDzDabWYvSPDaVzOxoMyv1vvVmdqaZLYl5/amZdY/n2IN4r0fN7NaDPb+Y695hZk+U9nUldaqmOgBJP2a2OeZlTWAHkBe9vtbdnz6Q67l7HlC7tI+tDNz9e6VxHTO7Ghjk7qfFXPvq0ri2VHxKJHLA3H3vP/LoE+/V7v6f/R1vZlXdfXdZxCYiZU9VW1LqoqqLf5nZs2a2CRhkZiea2XQz22BmK81spJllRsdXNTM3s5bR67HR/slmtsnM3jezVgd6bLS/j5l9ZmYbzexBM/ufmV2xn7jjifFaM1toZt+Y2ciYczPM7H4zW29mi4HexXx/fm1m4wpt+7uZ3Rc9v9rMPo7uZ1FUWtjftZaZ2WnR85pm9lQU23ygS6Fjf2Nmi6Przjez/tH2Y4G/Ad2jasN1Md/b38ecPyy69/Vm9pKZNYnne1MSMzs/imeDmb1lZt+L2Xerma0ws2/N7JOYez3BzGZH21eb2T3xvp8kgbvrocdBP4AlwJmFtt0B7ATOJXxYOQT4AdCNUApuDXwGXBcdXxVwoGX0eiywDsgGMoF/AWMP4thGwCYgJ9r3U2AXcMV+7iWeGF8G6gItga/z7x24DpgPNAPqA9PCn1eR79Ma2AzUirn2GiA7en1udIwBZwDbgI7RvjOBJTHXWgacFj2/F/gvcDhwJLCg0LEDgCbRz+TSKIYjon1XA/8tFOdY4PfR815RjMcBNYB/AG/F870p4v7vAJ6InreP4jgj+hndCnwaPf8+8CXQODq2FdA6ej4TGBg9rwN0S/XfQmV+qEQiyfKuu7/i7nvcfZu7z3T3Ge6+290XA6OBHsWc/7y757r7LuBpwj+wAz22HzDH3V+O9t1PSDpFijPGP7n7RndfQvinnf9eA4D73X2Zu68H/lzM+ywG5hESHMBZwDfunhvtf8XdF3vwFvAmUGSDeiEDgDvc/Rt3/5JQyoh93/HuvjL6mTxD+BCQHcd1AS4DHnX3Oe6+HbgF6GFmzWKO2d/3pjiXABPd/a3oZ/RnQjLqBuwmJK3vR9WjX0TfOwgfCNqYWX133+TuM+K8D0kCJRJJlqWxL8ysnZm9amarzOxb4A9Ag2LOXxXzfCvFN7Dv79imsXG4uxM+wRcpzhjjei/CJ+niPAMMjJ5fGr3Oj6Ofmc0ws6/NbAOhNFDc9ypfk+JiMLMrzOzDqAppA9AuzutCuL+913P3b4FvgKyYYw7kZ7a/6+4h/Iyy3P1T4GeEn8OaqKq0cXToEKAD8KmZfWBmfeO8D0kCJRJJlsJdX0cRPoUf7e6HArcRqm6SaSWhqgkAMzP2/cdXWCIxrgSax7wuqXvyeOBMM8silEyeiWI8BHge+BOh2ukw4PU441i1vxjMrDXwEDAcqB9d95OY65bUVXkFobos/3p1CFVoy+OI60CuW4XwM1sO4O5j3f1kQrVWBuH7grt/6u6XEKov/wJMMLMaCcYiB0mJRMpKHWAjsMXM2gPXlsF7/hvobGbnmllV4AagYZJiHA/caGZZZlYf+GVxB7v7KuBd4AngU3f/PNpVHagGrAXyzKwf0PMAYrjVzA6zMM7muph9tQnJYi0hp15DKJHkWw00y+9cUIRngavMrKOZVSf8Q3/H3fdbwjuAmPub2WnRe99MaNeaYWbtzez06P22RY89hBu43MwaRCWYjdG97UkwFjlISiRSVn4GDCb8kxhFaBRPKndfDVwM3AesB44C/o8w7qW0Y3yI0JbxEaEh+Pk4znmG0Hi+t1rL3TcANwEvEhqsLyIkxHj8jlAyWgJMBp6Mue5c4EHgg+iY7wGx7QpvAJ8Dq80stooq//zXCFVML0bntyC0myTE3ecTvucPEZJcb6B/1F5SHbib0K61ilAC+nV0al/gYwu9Au8FLnb3nYnGIwfHQrWxSMVnZhmEqpSL3P2dVMcjUlGoRCIVmpn1jqp6qgO/JfT2+SDFYYlUKEokUtGdAiwmVJucDZzv7vur2hKRg6CqLRERSYhKJCIikpBKMWljgwYNvGXLlqkOQ0QkrcyaNWuduxfXZR6oJImkZcuW5ObmpjoMEZG0YmYlzdAAqGpLREQSpEQiIiIJUSIREZGEKJGIiEhClEhERCQhSiQiIpIQJRIREUmIEolUaps2wRNPwL/+BVu3pjoakdK1ahXsKIOZ5ZRIpFKaNQuGDoUmTWDIELjkEmjcODx/803Iy0t1hCIHbtWq8KFo+HBo3z78fv/vf8l/30oxsl0EYPNmePZZGD0acnPhkEPg4otDQtmxA556Cp5/PpRQsrLg0kth0CDo2DHVkYsUbdUqePtt+O9/w+OTT8L2OnWge3e48ko4+ujkx1EpZv/Nzs52TZFSec2ZA6NGwdNPh6qs738frr0WLr8cDjts32O3bYN//xvGjoVJk2D3bjj22JBQLr0UmjUr+j1EykJJieO008Lj+OOhaikUE8xslrtnl3icEolURFu2hCL+qFHwwQdQowYMGBBKHyedBGYlX2PdOhg/PiSV998P55x+ekgqF14Ihx6a/PuQyq2sE0dhSiQxlEgqj48+Csnjqafg22+hXTsYNiyUPurVO/jrLlwYSjRjx4bnNWpATk5IKmefDZmZpXcPUnmlOnEUpkQSQ4mkYtu2LZQcRo0KJYfq1eGii0L11SmnxFf6iJd7KOGMHQvjxoVSS4MGoa3l8suha9fSfT+p2Mpb4ihMiSSGEknFtGBBSB5PPgkbNkDbtiF5DB4M9esn//137YIpU0JSefll2L49NGwOGgSXXVY2jZySXsp74ihMiSSGEknFsX176Fk1ahS8+26oUrrwwpBAevRIXWlg40Z44YWQVKZODSWXE08MSWXAgFBqkcon3RJHYUokMZRI0t8nn4Ruu//8J3z9dfi0P3QoXHEFNCxx/baytWwZPPNMaKeZNy/8g+jTJ1R99esXuh1LxVRc4jj11ILEcdxx5TNxFKZEEkOJJD3t2AETJoTSx7Rp4Q/v/PND6eP006FKGgynnTs3lFKefhpWrAg9vS66KJRUevRIj3uQ/atoiaMwJZIYSiTp5bPPQunjiSdg/Xpo3RquuSaMOj/iiFRHd3Dy8sI/mrFjQ9Xc5s1hTMpll4WkcswxqY5Q4lHRE0dh8SYS3D1pD6A38CmwELiliP3tgPeBHcDP4z0XuB74BJgP3F1SHF26dHEp33bscB83zv30093BvWpV9wsvdH/9dfe8vFRHV7q2bHF/9ln3c85xz8gI99upk/u997ovX57q6CTWypXh93LYMPd27cLPCtzr1Ak/v3vucZ85033XrlRHmhxArsfxvz5pJRIzywA+A84ClgEzgYHuviDmmEbAkcB5wDfufm9J55rZ6cCvgXPcfYeZNXL3NcXFohJJ+bVoUSh9PP44rF0LLVsWlD6aNEl1dMm3Zk0YODl2bOhWbAY9e4ZSygUXhE+6UnZWrty3xPHpp2F7RS1xlCTeEkkyvxVdgYXuvjgKaByQA+xNJFECWGNm5xzAucOBP7v7jphrSBrZtSt0lx01Cv7zH8jIgHPPDW0fvXpVrnaDRo3g+uvD47PPCgY9XnFFmHjvvPNCUjnrLA16TIaSEsfVV1euxHGwkvmtyQKWxrxeBnQrhXPbAt3N7E5gO6FKbGbhC5jZUGAoQIsWLQ4sckmKL76ARx6BMWNg9Wpo3hz+8IcwsVxWVqqjS722beH22+H3vw8DK8eODaWVZ58NPdMGDgxJJTtbgx4PlhJHcqTjt6oqUA84AfgBMN7MWnuhOjp3Hw2MhlC1dTBvtGBBGB9w1FHhD1l/vAdu164wCeKoUfD66+F7eM45ofTRu3cojci+zMJ8YCedBA88AJMnh6QyahSMHAnf+17BoMdWrVIdbfmxY0dIFCtWwPLl3/361VeweHE4VomjdCXzW7ccaB7zulm0LdFzlwEvRInjAzPbAzQA1iYW7neNHBn+eAFq1w69h1q3DonlqKMKnh95pKodCvvyS3j0UXjssfDHnZUFt90GV10VSiISn2rVwpxeOTlh9P6ECSGp/Pa34XHyyQWDHhOZS6w827MntJ8VlRxiv65b991zq1WDpk3D71+XLqG6UImj9CWzsb0qocG8JyEJzAQudff5RRz7e2BzTGP7fs81s2FAU3e/zczaAm8CLQqXSGIdbGP7kiUwf35oEF60KHyayf8au+pYlSrQosW+ySX2ed26B/zWaWn3bnj11dB4Pnly2Na3bxg42Lev/nBL01dfFQx6XLAgfJA555yQVM45J0wqWd65h4k1i0sOy5eHLre7d+97rlnoCp6fJIr62rRpmCpHNQkHr1yMIzGzvsADQAYwxt3vjBIB7v6wmTUGcoFDgT3AZqCDu39b1LnRNasBY4DjgJ2ENpK3ioujtHtt7dkTPmXHJpfY54U/GdWr993kkv81Kyv9G5eXLi0ofSxfHnpbXX11eKh5Krncw3orY8eGxLJqVVhj5Yc/DEnllFNS8/u1fXvx1UwrVoTHli3fPfewwwoSwf6SROPG+mBSFspFIikvyrr777ff7lt6if365Zf7LuNarVqo5y4q0bRuXX6n08jLC6WOUaPCAlDuYTr1a68N04Doj7zs5eXBW2+FUsoLL4R/0i1ahLaUyy8PS6+WxnvEU820fv13z61evehSQ+y2Jk2gVq3E45TSoUQSozyNI9m1K3yC319pZtOmfY9v2rTo6rLWrVPTAWD58lDyePTRcB+NG4deV1dfrYbf8mTLltDFeuzY0MkhLw86dw6llEsu+e4YHffQsSSeaqbC69lXqRKqmYqrYsrKgsMPVzVTulEiiVGeEklx3MMnuaLaZBYtCn/IsWrXLrq67KijwifR0uoAkJcX/hmNGhV6YOXlhXEN114L/furo0F5t3p1WDtl7NiwVn2VKmHQY4MG+1Yzbd363XMPP7z4KqasrDAWRiXQikmJJEa6JJKSbNsWOgAUVZop3AEgIyMkk6JKM0cdFd8ysStXhjEfjzwSquQaNQojzq+5JlxD0s8nn4RBj+PHhw8E+6tiyt9WXqtWpWwokcSoKImkOLEdAIoqzRTuAFC//v57meUvGDVxYugt07Nn6Hl13nmhTUdEKofyMEWKlKEqVcInyaysMNCqsKI6ACxaFOZ3eu6579Z7N2gAN90USh9t2pTNPYhIelIiqSQOPTQMwjruuO/ui+0AsGhRKK307x962YiIlESJRMjMLOhufNZZqY5GRNJNmg+FExGRVFMiERGRhCiRiIhIQpRIREQkIUokIiKSECUSERFJiBKJiIgkRIlEREQSktREYma9zexTM1toZrcUsb+dmb1vZjvM7OcHeO7PzMzNrEEy70FERIqXtERiZhnA34E+QAdgoJl1KHTY18AI4N4DOdfMmgO9gK+SFb+IiMQnmSWSrsBCd1/s7juBcUBO7AHuvsbdZwK7DvDc+4FfABV/6mIRkXIumYkkC1ga83pZtC2hc80sB1ju7h8WdwEzG2pmuWaWu3bt2vijFhGRA5JWje1mVhO4FbitpGPdfbS7Z7t7dsOGDZMfnIhIJZXMRLIcaB7zulm0LZFzjwJaAR+a2ZJo+2wza5xwtCIiclCSOY38TKCNmbUiJIFLgEsTOdfd5wON8g+Kkkm2u68r8ioiIpJ0SUsk7r7bzK4DpgAZwBh3n29mw6L9D0cliVzgUGCPmd0IdHD3b4s6N1mxiojIwdOa7SIiUqR412xPq8Z2EREpf5RIREQkIUokIiKSECUSERFJiBKJiIgkRIlEREQSokQiIiIJUSIREZGEKJGIiEhClEhERCQhSiQiIpIQJRIREUmIEomIiCREiURERBKiRCIiIglRIhERkYQkNZGYWW8z+9TMFprZLUXsb2dm75vZDjP7eTznmtk9ZvaJmc01sxfN7LBk3oOIiBQvaYnEzDKAvwN9gA7AQDPrUOiwr4ERwL0HcO4bwDHu3hH4DPhVsu5BRERKlswSSVdgobsvdvedwDggJ/YAd1/j7jOBXfGe6+6vu/vu6LjpQLMk3oOIiJQgmYkkC1ga83pZtK00z70SmFzUBcxsqJnlmlnu2rVr43xbERE5UGnb2G5mvwZ2A08Xtd/dR7t7trtnN2zYsGyDExGpRKom8drLgeYxr5tF2xI+18yuAPoBPd3dEwtTREQSkcwSyUygjZm1MrNqwCXAxETPNbPewC+A/u6+NQlxi4jIAUhaicTdd5vZdcAUIAMY4+7zzWxYtP9hM2sM5AKHAnvM7Eagg7t/W9S50aX/BlQH3jAzgOnuPixZ9yEiIsWzylAzlJ2d7bm5uakOQ0QkrZjZLHfPLum4tG1sFxGR8kGJREREEqJEIiIiCVEiERGRhCiRiIhIQpRIREQkIUokIiKSECUSERFJiBKJiIgkRIlEREQSokQiIiIJUSIREZGEKJGIiEhClEhERCQhSiQiIpKQpCYSM+ttZp+a2UIzu6WI/e3M7H0z22FmP4/nXDOrZ2ZvmNnn0dfDk3kPIiJSvKQlEjPLAP4O9AE6AAPNrEOhw74GRgD3HsC5twBvunsb4M3otYiIpEgySyRdgYXuvtjddwLjgJzYA9x9jbvPBHYdwLk5wD+j5/8EzkvWDYiISMmSmUiygKUxr5dF2xI99wh3Xxk9XwUcUdQFzGyomeWaWe7atWvjj1pERA5IWje2e1hwvshF5919tLtnu3t2w4YNyzgyEZHKI5mJZDnQPOZ1s2hboueuNrMmANHXNQnGKSIiCUhmIpkJtDGzVmZWDbgEmFgK504EBkfPBwMvl2LMIiJygKrGc5CZHQUsc/cdZnYa0BF40t037O8cd99tZtcBU4AMYIy7zzezYdH+h82sMZALHArsMbMbgQ7u/m1R50aX/jMw3syuAr4EBhz4bYuISGmx0MxQwkFmc4BsoCUwiVAK+L67901qdKUkOzvbc3NzUx2GiEhaMbNZ7p5d0nHxVm3tcffdwPnAg+5+M9AkkQBFRKRiiDeR7DKzgYQ2iX9H2zKTE5KIiKSTeBPJEOBE4E53/8LMWgFPJS8sERFJF3E1trv7AsJUJkRzW9Vx97uSGZiIiKSHuEokZvZfMzvUzOoBs4FHzOy+5IYmIiLpIN6qrbru/i1wAaHbbzfgzOSFJSIi6SLeRFI1GkU+gILGdhERkbgTyR8IgwMXuftMM2sNfJ68sEREJF3E29j+HPBczOvFwIXJCkpERNJHvI3tzczsRTNbEz0mmFmzZAcnIiLlX7xVW48TJktsGj1eibaJiEglF28iaejuj7v77ujxBKBFPkREJO5Est7MBplZRvQYBKxPZmAiIpIe4k0kVxK6/q4CVgIXAVckKSYREUkjcSUSd//S3fu7e0N3b+Tu51EZem19+y3s3p3qKEREyrVEVkj8aUkHmFlvM/vUzBaa2S1F7DczGxntn2tmnWP23WBm88xsfrTgVf7248xsupnNMbNcM+uawD0U749/hKZN4brr4L33II61W0REKptEEokVu9MsA/g70AfoAAw0sw6FDusDtIkeQ4GHonOPAa4BugKdgH5mdnR0zt3A7e5+HHBb9Do5evWC00+Hxx6Dk0+GVq3gV7+Cjz5K2luKiKSbRBJJSR/PuwIL3X2xu+8ExgE5hY7JIczd5e4+HTgsmoqlPTDD3bdGC2q9TZjnK/99D42e1wVWJHAPxTvrLPjXv2DNGnjqKejQAe65Bzp2hGOOgf/3/+CLL5L29iIi6aDYRGJmm8zs2yIemwjjSYqTBSyNeb0s2hbPMfOA7mZW38xqAn2B5tExNwL3mNlS4F7gVyXEkbg6dWDQIJg0CVauhH/8Aw4/HH79a2jdGk48ER58EFavTnooIiLlTbGJxN3ruPuhRTzquHtc06scDHf/GLgLeB14DZgD5EW7hwM3uXtz4CbgsaKuYWZDozaU3LVr15ZecA0bwvDh8M478OWXcNddsG0bjBgR2lN69YLHH4eNG0vvPUVEyrFEqrZKspyCUgRAs2hbXMe4+2Pu3sXdTwW+AT6LjhkMvBA9f45QhfYd7j7a3bPdPbthwySNnWzRAn7xC5gzB+bPh1tvhcWL4cor4Ygj4MIL4fnnQ6IREamgkplIZgJtzKyVmVUDLiFMsxJrIvCjqPfWCcBGd18JYGaNoq8tCO0jz0TnrAB6RM/PoLzMQtyhQ+jl9fnnMGMGDBsWenr98IchqQweDFOmqDuxiFQ4yaye2m1m1xGmn88Axrj7fDMbFu1/GJhEaP9YCGwlrA2fb4KZ1Qd2AT9x9w3R9muAv5pZVWA7obdX+WEGXbuGx1/+Av/9Lzz7bCiZPPlkqBobMAAuvTS0rVixnd9ERMo980owNiI7O9tzc3NTG8SOHTB5ckgqEyfC9u1w5JEwcGBIKscem9r4REQKMbNZ7p5d0nHJrNqSWNWrw3nnqTuxiFQ4SiSpoO7EIlKBKJGkWlHdibdvV3diEUkbSiTlSX534v/7P3UnFpG0oURSXqk7sYikCSWS8i6/O/EDD8CyZfCf/4Tuwy+/DL17a3ZiEUk5JZJ0kpEBPXvCo4+GhvgXX9TsxCKSckok6Sre7sSLF6c6UhGp4JRIKoLiuhMfdVToTjxyJKxalepIRaQCUiKpaPbXnfiGGyArS92JRaTUKZFUZOpOLCJlQImksijcnXj4cHUnFpFSoURS2eR3J77//v13J77+epg5U92JRSQuSiSVWeHuxC+9FLoTP/poSDYdOsCf/gRffZXqSEWkHFMikaB6dcjJCd2JV60KyaRRo9Cu0rJlSDhPPAGbNqU6UhEpZ5RI5Lvq1oWrroK33w6N87ffHkolQ4aE9pRBg+D11yEvL9WRikg5kNREYma9zexTM1toZrcUsd/MbGS0f66ZdY7Zd4OZzTOz+WZ2Y6HzrjezT6J9dyfzHiq9Vq3gt7+Fzz4LjfODB8Orr8LZZxf0Cps3L9VRikgKJS2RmFkG8HegD9ABGGhmHQod1gdoEz2GAg9F5x5DWFK3K9AJ6GdmR0f7TgdygE7u/n3g3mTdg8QwCwMbH3ooVH09/zxkZ4dG+2OPhc6dw3xgWkNFpNJJZomkK7DQ3Re7+05gHCEBxMoBnvRgOnCYmTUB2gMz3H2ru+8G3gYuiM4ZDvzZ3XcAuPuaJN6DFKV69TAG5eWXYcWKsAhX1apw001h0GO/fjB+vManiFQSyUwkWcDSmNfLom3xHDMP6G5m9c2sJtAXaB4d0zbaN8PM3jazHxT15mY21MxyzSx37dq1pXA7UqSGDcPswx98AAsWhKquDz+Eiy+GJk3gmmvCKHt1JRapsMplY7u7fwzcBbwOvAbMAfJbdqsC9YATgJuB8WZmRVxjtLtnu3t2w4YNyybwyq59+zBR5JIl8OabYVLJZ5+FU08Nc3797newcGGqoxSRUpbMRLKcglIEQLNoW1zHuPtj7t7F3U8FvgE+i45ZBrwQVYd9AOwBGiQhfjlYGRlwxhmhu/Dq1WFm4qOPDiPr27QJU96PGgXffJPqSEWkFCQzkcwE2phZKzOrBlwCTCx0zETgR1HvrROAje6+EsDMGkVfWxDaR56JznkJOD3a1xaoBqxL4n1IImrVKuguvHRpmERy48aw4mPjxmGKlokTYdeuVEcqIgcpaYkkaiS/DpgCfAyMd/f5ZjbMzIZFh00CFgMLgUeAH8dcYoKZLQBeAX7i7hui7WOA1mY2j9CAP9hdFfBpISsrtKF89BHMng0//nEYq5KTE6ZmGTECcnPVniKSZqwy/A/Ozs723NzcVIchRdm1K5RWnnwy9ALbsSO0tfzoR3DZZdC8ecnXEJGkMLNZ7p5d0nHlsrFdKpHMTDjnnIKpWUaPhvr1w5LBRx4JZ54ZkszmzamOVET2Q4lEyo/DDivoLrxwYejl9cUXYTT9EUeEUsp//qOpWUTKGSUSKZ9iuwu/+25osJ84Ec46K0zN8stfhsW6RCTllEikfDMr6C68alUYMd+5M/zlL3DMMdClC/z1r7BGExyIpIoSiaSPGjVCd+FXXglTs/z1ryHR3Hhj6PV17rnw3HNhjXoRKTNKJJKeGjUq6C48bx78/OdhbfoBA8L4lGuvhf/9T12JRcqAEomkv+9/H/78Z/jyS3jjDejfH8aOhVNOCSPqb78dFi1KdZQiFZYSiVQcGRkF3YVXr4Z//jOsp3L77SGhnHJK6F68YUPJ1xKRuCmRSMVUu3ZBd+Gvvgollq+/DlVejRuHKrB//1tTs4iUAiUSqfiaNSvoLpybG5LJ1KmhcT4rKzTWv/eexqeIHCQlEqk8zAq6C69YEcal9OgRVn08+eTQgH/ppaF9RWvYiMRNc22JbNgQ5vuaNAkmTw5jUsyga1fo2zc8OneGKvrcJZVLvHNtKZGIxNqzJ8xMPGlSeHzwQehC3KgR9OkTkspZZ8Hhh6c6UpGkUyKJoUQiB23tWpgyJSSVKVNCg31GBpx4YkFppWPHUIIRqWCUSGIokUipyMsLJZT80srs2WF7VlZBaeXMM6FOndTGKVJKysU08mbW28w+NbOFZnZLEfvNzEZG++eaWeeYfTeY2Twzm29mNxZx7s/MzM1My+xK2cgvifzxjzBrVmiwHzMmbBs/Hi64IEyB37NnmAvs4481sl4qhaQlEjPLAP4O9AE6AAPNrEOhw/oAbaLHUOCh6NxjgGuArkAnoJ+ZHR1z7eZAL+CrZMUvUqImTWDIkDC/17p18N//wk03hcb6n/8cOnSA1q3hJz8JY1a2bEl1xCJJkcwSSVdgobsvdvedhGVxcwodkwM86cHs6ssuAAAUgklEQVR04DAzawK0B2a4+9Zoyd63Ceu257sf+AWgj3tSPmRmhq7Ed90VlhL+6qswY3GnTmGE/bnnhtJK794wcmSYHl+kgkhmIskClsa8XhZti+eYeUB3M6tvZjWBvkBzADPLAZa7+4fFvbmZDTWzXDPLXasxAVLWmjeHoUPhpZdg/fowB9iPfwxLlsANN0CbNtC2bRgM+frrmrFY0lq57Bjv7h8DdwGvA68Bc4C8KKncCtwWxzVGu3u2u2c3bNgwqfGKFKt69dAIf9998MknoTTy4INh/q9Ro+Dss0NppX9/ePjhMPmkSBpJZiJZTlSKiDSLtsV1jLs/5u5d3P1U4BvgM+AooBXwoZktiY6fbWaNk3IHIslw1FFw3XWh59fXX4evV14ZpsMfPhxatgwzGt98c5jKZefOVEcsUqykdf81s6qEf/49CclhJnCpu8+POeYc4DpC1VU3YKS7d432NXL3NWbWglAyOcHdNxR6jyVAtruvKy4Wdf+VtOAOn31W0L347bfDpJJ16oRBkH37hm7GTZumOlKpJOLt/ls1WQG4+24zuw6YAmQAY9x9vpkNi/Y/DEwiJJGFwFZgSMwlJphZfWAX8JPCSUSkwjGD730vPG66CTZtgrfeKkgsL7wQjjvuuILBkN26QdWk/RmLxEUDEkXSgXuo+po8OSSVd98NAyQPOyy0sfTtG3qENWqU6kilAtHI9hhKJFLhbNgQ1lrJn2hy1apQosnOLiitZGdroklJiBJJDCUSqdD27IE5cwqqwKZPDyWYhg1DKaVvX+jVC+rVS3WkkmaUSGIokUilsm5dGJsyeXJ4rF8fSiYnnFBQWjnuOE00KSVSIomhRCKVVl5eWBUyv7SS/3fQpEmYE+zUU8OjbVslFvkOJZIYRSWSXbt2sWzZMrZrRHFaqVGjBs2aNSMzMzPVoaSn1avhtdcKuhevXh22N2pUkFR69IBjjlH7iiiRxCoqkXzxxRfUqVOH+vXrY/oklhbcnfXr17Np0yZatWqV6nDSnzt8/jlMmxYeb78d5giD0Buse/eC5HL88WE+MalUUj6OpLzbvn07LVu2VBJJI2ZG/fr10dxppcQsVGm1bQtXXx22ffllQWKZNg1eeSVsr1UrrGufn1h+8AOoUSN1sUu5UmkTCaAkkob0M0uyI4+Eyy8PDwjdit95J5RWpk2D3/wmbK9ePQyGzE8sJ54ItWunLm5JqUqdSESkBI0bww9/GB4Q5gZ7992CEsuf/gR33BFG13fpUpBYTj5Z69pXIkokKVS7dm02b96c6jBE4levXpiluH//8HrTJnj//YISy1//CvfcE6rNOnYsSCynnqpR9xWYEomIHLw6dcJgx169wutt28K69vkllsceC1PmA7Rrt29iad58/9eVtKJEAmFxoTlzSveaxx0HDzxwwKctWbKEK6+8knXr1tGwYUMef/xxWrRowXPPPcftt99ORkYGdevWZdq0acyfP58hQ4awc+dO9uzZw4QJE2jTpk3p3ofIgTjkkNB9uEeP8HrXrrC+fX5i+de/YPTosK9ly4LuxqeeGqbXVxtYWlIiKWeuv/56Bg8ezODBgxkzZgwjRozgpZde4g9/+ANTpkwhKyuLDRvCRMgPP/wwN9xwA5dddhk7d+4kLy8vxdGLFJKZGUbUn3AC/OIXYYDkRx8VJJbJk+HJJ8OxTZrsW2Lp0EFjWdJEpR1H8vHHH9O+ffsURRQU1UbSoEEDVq5cSWZmJrt27aJJkyasW7eOYcOGsWjRIgYMGMAFF1xA/fr1eeaZZ7jzzjv50Y9+xAUXXFBpSiPl4WcnpcQ9rBoZO5ZlebT+Xb16YSxLfomlUydNmV/G4h1HonSfJh5++GHuuOMOli5dSpcuXVi/fj2XXnopEydO5JBDDqFv37689dZbqQ5T5MCYQfv2cO218PTTsHQpLF4MTzwB550Xps7/6U/DTMb16oWFvf70J/jf/7RyZDmi9F7OnHTSSYwbN47LL7+cp59+mu7duwOwaNEiunXrRrdu3Zg8eTJLly5l48aNtG7dmhEjRvDVV18xd+5czjjjjBTfgUgCzKBVq/AYPDhsW748jGXJL7XcemvYXqNGGL+SXxV2wglQs2bqYq/EkppIzKw38FfCComPuvufC+23aH9fwgqJV7j77GjfDcA1gAGPuPsD0fZ7gHOBncAiYEi6rp64detWmjVrtvf1T3/6Ux588EGGDBnCPffcs7exHeDmm2/m888/x93p2bMnnTp14q677uKpp54iMzOTxo0bc2v+H5hIRZKVBZdcEh4QZjfOH8vy9tvwxz+GqfQzM0PJJXYsS926qY29kkjmmu0ZhDXbzwKWEdZsH+juC2KO6QtcT8Ga7X91925mdgwwDuhKSBivAcPcfaGZ9QLeipbyvQvA3X9ZXCzltY1EDo5+drKPjRvhvfcKSiwzZ4beYlWqhN6T+Ymle3do0CDV0aaV8jDXVldgobsvjgIaB+QAC2KOyQGe9JDNppvZYWbWBGgPzHD3rdG5bwMXAHe7++sx508HLkriPYhIeVe3bmg76dMnvN66NSzulZ9YHn64oCt+mzahCqxbt/C1Y0dNRlkKkplIsoClMa+XEUodJR2TBcwD7jSz+sA2QomlqAVFrgT+VdSbm9lQYChAixYtDiJ8EUlLNWvCGWeEB4RG+dzckFSmT4c33oCnngr7atQIU7vkJ5Zu3cJASY1nOSDlsrHd3T+Oqq1eB7YAc4B9BkmY2a+B3cDT+7nGaGA0hKqtpAYsIuVXtWpw0knhAaHL8VdfwYwZ4TF9OvzjH3DffWF/48b7llqyszUhZQmSmUiWA7FzIDSLtsV1jLs/BjwGYGb/j1BaIXp9BdAP6OmVYSCMiJQeszDL8ZFHwoABYdvOnTB3bkFimTEDXnop7KtSJSz01a1bQXJp316DJWMkM5HMBNqYWStCcrgEuLTQMROB66L2k27ARndfCWBmjdx9jZm1ILSPnBBt7w38AuiR34YiIpKQatVCySM7G37yk7Bt/fowb1h+cnn+eXjkkbCvTh3o2nXfKrFKPCll0hJJ1KvqOmAKofvvGHefb2bDov0PA5MI7R8LCd1/h8RcYkLURrIL+ElMF9+/AdWBN6K1Kaa7+7Bk3YeIVFL16+/biL9nT1hRMrZK7O67YffusL9ly32rxI4/PqzbUhm4e4V/dOnSxQtbsGDBd7aVpdNOO81fe+21fbbdf//9PmzYsGLPq1Wrlru7L1++3C+88MIij+nRo4fPnDmz2Ovcf//9vmXLlr2v+/Tp49988008oRfrd7/7nd9zzz0JX6c4qf7Ziey1ZYv7O++433uv+0UXuTdv7h5aYdwzM927dnW//nr3sWPdFy5037Mn1REfECDX4/gfWy4b2yuDgQMHMm7cOM4+++y928aNG8fdd98d1/lNmzbl+eefP+j3f+CBBxg0aBA1o5HAkyZNOuhriVRaNWvCKaeER74VK/YttYwZUzCVfoMG+7a1/OAHcNhhqYm9FCmRkJpZ5C+66CJ+85vfsHPnTqpVq8aSJUtYsWIF3bt3Z/PmzeTk5PDNN9+wa9cu7rjjDnJycvY5f8mSJfTr14958+axbds2hgwZwocffki7du3Ytm3b3uOGDx/OzJkz2bZtGxdddBG33347I0eOZMWKFZx++uk0aNCAqVOn0rJlS3Jzc2nQoAH33XcfY8aMAeDqq6/mxhtvZMmSJfTp04dTTjmF9957j6ysLF5++WUOOeSQuL4fRV1zy5YtDBgwgGXLlpGXl8dvf/tbLr74Ym655RYmTpxI1apV6dWrF/fee+8BfvdFUqhpUzj//PCAUPU1f/6+yWXSpFBugbBOS2yV2DHHpN3klOkVbQVSr149unbtyuTJk8nJyWHcuHEMGDAAM6NGjRq8+OKLHHrooaxbt44TTjiB/v3773e98oceeoiaNWvy8ccfM3fuXDp37rx335133km9evXIy8ujZ8+ezJ07lxEjRnDfffcxdepUGhQa6Ttr1iwef/xxZsyYgbvTrVs3evToweGHH87nn3/Os88+yyOPPMKAAQOYMGECgwYNKvFe93fNxYsX07RpU1599VUANm7cyPr163nxxRf55JNPMLO9U+aLpK2qVcPMxZ06wdChYdvGjWEEfn5iefXVMFElhFJOly77JpesrJSFHw8lEg5q/alSkV+9lZ9IHnvsMSC0W916661MmzaNKlWqsHz5clavXk3jxo2LvM60adMYMWIEAB07dqRjx457940fP57Ro0eze/duVq5cyYIFC/bZX9i7777L+eefT61atQC44IILeOedd+jfvz+tWrXiuOOOA6BLly4sWbIkrvvc3zV79+7Nz372M375y1/Sr18/unfvzu7du6lRowZXXXUV/fr1o1+/fnG9h0haqVsXzjwzPCCUTpYsKeh6PH16WLY4f4bjrKx9E0uXLuVqgkolkhTKycnhpptuYvbs2WzdupUuXboA8PTTT7N27VpmzZpFZmYmLVu2ZPv27Qd8/S+++IJ7772XmTNncvjhh3PFFVcc1HXyVY/pgZKRkbFPFdrBaNu2LbNnz2bSpEn85je/oWfPntx222188MEHvPnmmzz//PP87W9/0/T4UvHFzno8cGDYtmNHqHOPrRKbMCHsy8iAY4/dN7m0bZuysS0aUZNCtWvX5vTTT+fKK69kYP4vD6GKp1GjRmRmZjJ16lS+/PLLYq9z6qmn8swzzwAwb9485s6dC8C3335LrVq1qFu3LqtXr2by5Ml7z6lTpw6bNm36zrW6d+/OSy+9xNatW9myZQsvvvji3qnsD9b+rrlixQpq1qzJoEGDuPnmm5k9ezabN29m48aN9O3bl/vvv58PP/wwofcWSVvVq4ckMWJEWKtl0SJYswZeeQV+9Sto2BCeeQaGDAkDJOvVg1694LbbQlXZunVlFqpKJCk2cOBAzj//fMaNG7d322WXXca5557LscceS3Z2Nu3atSv2GsOHD2fIkCG0b9+e9u3b7y3ZdOrUieOPP5527drRvHlzTj755L3nDB06lN69e9O0aVOmTp26d3vnzp254oor6Nq1KxAaxo8//vi4q7EA7rjjDh6IqS9ctmxZkdecMmUKN998M1WqVCEzM5OHHnqITZs2kZOTw/bt23F37suftkJEQvLo1y88IIxt+fTTfavE7rwzbAc46ih49FE47bSkhqWldiXt6GcnUozNm2HWrIIqsTvvDD3DDkJ5mEZeRETKWu3aYZ37Hj3K7C3VRiIiIgmp1ImkMlTrVTT6mYmUP5U2kdSoUYP169frH1MacXfWr19PjRo1Uh2KiMSotG0kzZo1Y9myZaxduzbVocgBqFGjBs2aNUt1GCISo9ImkszMTFq1apXqMERE0l6lrdoSEZHSoUQiIiIJUSIREZGEVIqR7Wa2Fih+wqr9awCU3aQ15YPuuXLQPVcOidzzke7esKSDKkUiSYSZ5cYzRUBFonuuHHTPlUNZ3LOqtkREJCFKJCIikhAlkpKNTnUAKaB7rhx0z5VD0u9ZbSQiIpIQlUhERCQhSiQiIpIQJZJimFlvM/vUzBaa2S2pjifZzGyMma0xs3mpjqUsmFlzM5tqZgvMbL6Z3ZDqmJLNzGqY2Qdm9mF0z7enOqayYmYZZvZ/ZvbvVMdSFsxsiZl9ZGZzzCy35DMSeC+1kRTNzDKAz4CzgGXATGCguy9IaWBJZGanApuBJ939mFTHk2xm1gRo4u6zzawOMAs4r4L/jA2o5e6bzSwTeBe4wd2npzi0pDOznwLZwKHu3i/V8SSbmS0Bst096QMwVSLZv67AQndf7O47gXFATopjSip3nwZ8neo4yoq7r3T32dHzTcDHQFZqo0ouDzZHLzOjR4X/NGlmzYBzgEdTHUtFpESyf1nA0pjXy6jg/2QqMzNrCRwPzEhtJMkXVfHMAdYAb7h7hb9n4AHgF8CeVAdShhz4j5nNMrOhyXwjJRKp9MysNjABuNHdv011PMnm7nnufhzQDOhqZhW6GtPM+gFr3H1WqmMpY6dEP+c+wE+iquukUCLZv+VA85jXzaJtUoFE7QQTgKfd/YVUx1OW3H0DMBXonepYkuxkoH/UZjAOOMPMxqY2pORz9+XR1zXAi4Tq+qRQItm/mUAbM2tlZtWAS4CJKY5JSlHU8PwY8LG735fqeMqCmTU0s8Oi54cQOpN8ktqoksvdf+Xuzdy9JeHv+C13H5TisJLKzGpFHUgws1pALyBpvTGVSPbD3XcD1wFTCI2w4919fmqjSi4zexZ4H/iemS0zs6tSHVOSnQxcTviEOid69E11UEnWBJhqZnMJH5becPdK0R22kjkCeNfMPgQ+AF5199eS9Wbq/isiIglRiURERBKiRCIiIglRIhERkYQokYiISEKUSEREJCFKJCIJMLO8mK7Dc0pzlmgza1lZZmKW9FY11QGIpLlt0TQUIpWWSiQiSRCtBXF3tB7EB2Z2dLS9pZm9ZWZzzexNM2sRbT/CzF6M1gn50MxOii6VYWaPRGuHvB6NRsfMRkTrqMw1s3Epuk0RQIlEJFGHFKraujhm30Z3Pxb4G2H2WYAHgX+6e0fgaWBktH0k8La7dwI6A/mzKLQB/u7u3wc2ABdG228Bjo+uMyxZNycSD41sF0mAmW1299pFbF8CnOHui6OJIVe5e30zW0dYTGtXtH2luzcws7VAM3ffEXONloQpTNpEr38JZLr7HWb2GmERspeAl2LWGBEpcyqRiCSP7+f5gdgR8zyPgnbNc4C/E0ovM81M7Z2SMkokIslzcczX96Pn7xFmoAW4DHgnev4mMBz2LjxVd38XNbMqQHN3nwr8EqgLfKdUJFJW9ClGJDGHRKsN5nvN3fO7AB8ezbK7AxgYbbseeNzMbgbWAkOi7TcAo6MZl/MISWXlft4zAxgbJRsDRkZri4ikhNpIRJIgaiPJdvd1qY5FJNlUtSUiIglRiURERBKiEomIiCREiURERBKiRCIiIglRIhERkYQokYiISEL+P9gQMVpDzVfjAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x211b0c55588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x211b10c2da0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.image  as mpimg\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "#-----------------------------------------------------------\n",
    "# Retrieve a list of list results on training and test data\n",
    "# sets for each training epoch\n",
    "#-----------------------------------------------------------\n",
    "acc=history.history['acc']\n",
    "val_acc=history.history['val_acc']\n",
    "loss=history.history['loss']\n",
    "val_loss=history.history['val_loss']\n",
    "\n",
    "epochs=range(len(acc)) # Get number of epochs\n",
    "\n",
    "#------------------------------------------------\n",
    "# Plot training and validation accuracy per epoch\n",
    "#------------------------------------------------\n",
    "plt.plot(epochs, acc, 'r')\n",
    "plt.plot(epochs, val_acc, 'b')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend([\"Accuracy\", \"Validation Accuracy\"])\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "#------------------------------------------------\n",
    "# Plot training and validation loss per epoch\n",
    "#------------------------------------------------\n",
    "plt.plot(epochs, loss, 'r')\n",
    "plt.plot(epochs, val_loss, 'b')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend([\"Loss\", \"Validation Loss\"])\n",
    "\n",
    "plt.figure()\n",
    "plt.show()\n",
    "\n",
    "# Expected Output\n",
    "# A chart where the validation loss does not increase sharply!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detection of best threshold "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_best_thresh(predictions, labels):\n",
    "    max_pred = max(predictions)\n",
    "    min_pred = min(predictions)\n",
    "    print(min_pred, max_pred)\n",
    "    \n",
    "    thresholds = np.linspace(min_pred, max_pred, num=20, endpoint=False)\n",
    "    thresholds = np.around(thresholds, decimals=2)\n",
    "    \n",
    "    max_count = 0\n",
    "    best_thresh = 0\n",
    "\n",
    "    print(\"total count: \", len(predictions))\n",
    "    for thresh in thresholds:\n",
    "        int_labels = (predictions>thresh).astype(int)\n",
    "        boolarr = int_labels == np.array(labels).reshape(len(labels), 1)\n",
    "        count_true = np.sum(boolarr)\n",
    "        print(\"thresh: \", thresh, \" count true: \", count_true)\n",
    "        if count_true > max_count:\n",
    "            max_count = count_true\n",
    "            best_thresh = thresh\n",
    "\n",
    "    print(\"best thresh: \", best_thresh)\n",
    "    return best_thresh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.3149074e-05] [0.97221667]\n",
      "total count:  65306\n",
      "thresh:  [0.]  count true:  4083\n",
      "thresh:  [0.05]  count true:  58450\n",
      "thresh:  [0.1]  count true:  60222\n",
      "thresh:  [0.15]  count true:  61028\n",
      "thresh:  [0.19]  count true:  61418\n",
      "thresh:  [0.24]  count true:  61781\n",
      "thresh:  [0.29]  count true:  62070\n",
      "thresh:  [0.34]  count true:  62238\n",
      "thresh:  [0.39]  count true:  62368\n",
      "thresh:  [0.44]  count true:  62508\n",
      "thresh:  [0.49]  count true:  62590\n",
      "thresh:  [0.53]  count true:  62632\n",
      "thresh:  [0.58]  count true:  62626\n",
      "thresh:  [0.63]  count true:  62600\n",
      "thresh:  [0.68]  count true:  62535\n",
      "thresh:  [0.73]  count true:  62449\n",
      "thresh:  [0.78]  count true:  62305\n",
      "thresh:  [0.83]  count true:  62058\n",
      "thresh:  [0.87]  count true:  61799\n",
      "thresh:  [0.92]  count true:  61422\n",
      "best thresh:  [0.53]\n"
     ]
    }
   ],
   "source": [
    "val_predictions = model.predict(val_sequences, batch_size=batch_size, verbose=2)\n",
    "best_val_thresh = get_best_thresh(val_predictions, val_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count Insincere questions for best_thresh:  2574\n",
      "count correct Insincere questions:  4083\n"
     ]
    }
   ],
   "source": [
    "val_int_labels = (val_predictions>best_val_thresh).astype(int)\n",
    "count_1_true = 0\n",
    "for i in range(len(val_int_labels)):\n",
    "    if (val_int_labels[i] == val_labels[i]) and (val_labels[i] == 1):\n",
    "        count_1_true += 1\n",
    "        \n",
    "print(\"count Insincere questions for best_thresh: \", count_1_true)\n",
    "print(\"count correct Insincere questions: \", np.sum(np.array(val_labels) == 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prediction for test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_pd = pd.read_csv(\"../test.csv\").fillna(' ')\n",
    "test_corpus = test_pd['question_text']\n",
    "\n",
    "test_sentences=[]\n",
    "for x in range(len(test_corpus)):\n",
    "    test_sentences.append(test_corpus[x][0])\n",
    "    \n",
    "sequences_test = tokenizer.texts_to_sequences(test_sentences)\n",
    "test_padded = pad_sequences(sequences_test, maxlen=max_length, padding=padding_type, truncating=trunc_type)\n",
    "\n",
    "submit_test_sequences = test_padded\n",
    "\n",
    "pred_prob = model.predict(submit_test_sequences, batch_size=batch_size, verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00712463] [0.5829487] [0.53]\n",
      "the threshold is 0.53 from the test pred range:  [0.30518675]\n"
     ]
    }
   ],
   "source": [
    "max_pred = max(pred_prob)\n",
    "min_pred = min(pred_prob)\n",
    "print(min_pred, max_pred, best_val_thresh)\n",
    "best_test_threshold = (max_pred - min_pred)*best_val_thresh\n",
    "print(\"the threshold is 0.53 from the test pred range: \", best_test_threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission = pd.DataFrame.from_dict({'qid': test_pd['qid']})\n",
    "submission['prediction'] = (pred_prob>best_test_threshold).astype(int)\n",
    "submission.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you train an Embedding layer (here we didn't train. we use a pretrained 'glove' trainable=False)\n",
    "\n",
    "you can project these vectors and visualize them, it's nice to see\n",
    "\n",
    "you need two inputs: vecs.tsv and meta.tsv \n",
    "\n",
    "https://projector.tensorflow.org/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(222162, 300)\n"
     ]
    }
   ],
   "source": [
    "reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])\n",
    "\n",
    "e = model.layers[0]\n",
    "weights = e.get_weights()[0]\n",
    "print(weights.shape) # shape: (vocab_size, embedding_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "\n",
    "out_v = io.open('vecs.tsv', 'w', encoding='utf-8')\n",
    "out_m = io.open('meta.tsv', 'w', encoding='utf-8')\n",
    "for word_num in range(1, vocab_size):\n",
    "    word = reverse_word_index[word_num]\n",
    "    embeddings = weights[word_num]\n",
    "    out_m.write(word + \"\\n\")\n",
    "    out_v.write('\\t'.join([str(x) for x in embeddings]) + \"\\n\")\n",
    "out_v.close()\n",
    "out_m.close()"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "name": "NLP Course - Week 3 Exercise Answer.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}