syn_ant_embedding_analogy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Can we find Synonyms and Antonyms from word embedding analogy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Import all necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 728,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random                      \n",
    "                                        \n",
    "import numpy as np                    # for mathematical calculations\n",
    "import pandas as pd                   # for loading dataset\n",
    "import matplotlib.pyplot as plt       # for plotting graphs and visualizations\n",
    "\n",
    "from sklearn.manifold import TSNE     # for dimensionality reduction needed for visualization\n",
    "\n",
    "from nltk.corpus import wordnet as wn # wordnet corpus to find synonyms and antonyms for given input word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Load the pre-trained GloVe embeddings\n",
    "\n",
    "**NOTE: In order to make this work, we need to first download \n",
    "the pre-trained GloVe embeddings provided by Stanford.**\n",
    "\n",
    "They can be downloaded here: https://nlp.stanford.edu/projects/glove/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 729,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['glove.6B.200d.txt',\n",
       " 'glove.6B.50d.txt',\n",
       " 'glove.6B.300d.txt',\n",
       " 'glove.6B.100d.txt']"
      ]
     },
     "execution_count": 729,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "This shows us the list of GloVe embedding files available.\n",
    "However, we will be using the 'glove.6B.300d.txt' file\n",
    "containing 300 dimensional vector embeddings for each word.\n",
    "'''\n",
    "\n",
    "os.listdir('embeddings')          # list of pre-trained GloVe embedding files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function load_embeddings(file_path):\n",
    "\n",
    "This function helps us to load the embedding file for use.\n",
    "We parse the embedding file into proper usage format, \n",
    "returning a complete list of unique words as our \n",
    "vocabulary and the corresponding dictionary of word\n",
    "vectors for each of those words from the embeddings.\n",
    "'''\n",
    "\n",
    "def load_embeddings(file_path):\n",
    "    \n",
    "    '''\n",
    "    We use a set() data structure here because we need\n",
    "    a collection of unique words only.\n",
    "    '''\n",
    "    word_vocabulary = set()\n",
    "    \n",
    "    '''\n",
    "    We use a dictionary for storing word vectors for each\n",
    "    of the words from the vocabulary.\n",
    "    '''\n",
    "    word_2_vectors = {}\n",
    "    \n",
    "    with open(file_path, 'r') as file:\n",
    "        for line in file:\n",
    "            \n",
    "            '''\n",
    "            We use the strip() method in order to avoid any\n",
    "            whitespace characters (space, tabs, etc.) from each\n",
    "            line in the file.\n",
    "            '''\n",
    "            line = line.strip()\n",
    "            \n",
    "            vectors = line.split()\n",
    "            word = vectors[0]\n",
    "            \n",
    "            word_vocabulary.add(word)\n",
    "            \n",
    "            '''\n",
    "            Each word vector is stored as a numpy array so that\n",
    "            it is easier to work with in the further calculations.\n",
    "            '''\n",
    "            word_2_vectors[word] = np.array(vectors[1:], dtype='float')\n",
    "    \n",
    "    return word_vocabulary, word_2_vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of unique words (vocabulary) in 300 dimensional embeddings: 400000\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "We had previously experimented with all the 4 kinds of GloVe input files \n",
    "that we got from Stanford website. However, in the end we decided to \n",
    "finalize the word embeddings with the highest dimensions (300) as they are\n",
    "able to capture more information about each word.\n",
    "'''\n",
    "\n",
    "########################################################################\n",
    "# NOTE: Use the directory path in your local system to make this work! #\n",
    "########################################################################\n",
    "\n",
    "# file_path_GloVe_50d = 'embeddings/glove.6B.50d.txt'\n",
    "# file_path_GloVe_100d = 'embeddings/glove.6B.100d.txt'\n",
    "# file_path_GloVe_200d = 'embeddings/glove.6B.200d.txt'\n",
    "\n",
    "file_path_GloVe_300d = 'embeddings/glove.6B.300d.txt'\n",
    "\n",
    "# vocabulary_50d, word_vectors_50d = load_embeddings(file_path_GloVe_50d)\n",
    "# vocabulary_100d, word_vectors_100d = load_embeddings(file_path_GloVe_100d)\n",
    "# vocabulary_200d, word_vectors_200d = load_embeddings(file_path_GloVe_200d)\n",
    "\n",
    "vocabulary_300d, word_vectors_300d = load_embeddings(file_path_GloVe_300d)\n",
    "\n",
    "# print('Total number of unique words (vocabulary) in 50 dimensional embeddings: %d' % len(vocabulary_50d))\n",
    "# print('Total number of unique words (vocabulary) in 100 dimensional embeddings: %d' % len(vocabulary_100d))\n",
    "# print('Total number of unique words (vocabulary) in 200 dimensional embeddings: %d' % len(vocabulary_200d))\n",
    "\n",
    "print('Total number of unique words (vocabulary) in 300 dimensional embeddings: %d' % len(vocabulary_300d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Visualize the pre-trained GloVe embeddings with t-SNE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function get_visualization_matrix(words, dim=300):\n",
    "\n",
    "This function is used in order to \n",
    "'''\n",
    "\n",
    "def get_visualization_matrix(words, dim=300):\n",
    "    \n",
    "    words_matrix = np.random.randn(len(words), dim)\n",
    "    i = 0\n",
    "    \n",
    "    for word in words:\n",
    "        words_matrix[i] = word_vectors_300d[word]\n",
    "        i += 1\n",
    "    \n",
    "    return words_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample words:\n",
      "\n",
      "['lion', 'school', 'kind', 'love', 'give', 'sleep', 'early', 'never', 'under', 'into']\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 719,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "First we define the tsne variable using the TSNE function.\n",
    "\n",
    "n_components =  The number of components that we would like \n",
    "                to reduce the dimmensionality to. Here, we\n",
    "                want to visualize the words in a 2d vector \n",
    "                space, so the value is 2.\n",
    "\n",
    "verbose      =  This parameter is used to output the log text\n",
    "\n",
    "perplexity   =  The perplexity is related to the number of nearest\n",
    "                neighbors that is used in other manifold learning \n",
    "                algorithms.\n",
    "\n",
    "method       =  The exact algorithm should be used when \n",
    "                nearest-neighbor errors need to be better than 3%.\n",
    "'''\n",
    "\n",
    "tsne = TSNE(n_components=2, \n",
    "            verbose=0, \n",
    "            perplexity=3, \n",
    "            method='exact')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 720,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function get_tsne_results(words):\n",
    "\n",
    "\n",
    "'''\n",
    "\n",
    "def get_tsne_results(words):\n",
    "    \n",
    "    '''\n",
    "    First we get the visual matrix for the list of input words\n",
    "    which we want to show in the visualization.\n",
    "    '''\n",
    "    visual_matrix = get_visualization_matrix(words)\n",
    "    \n",
    "    '''\n",
    "    Next we use the fit.transform() method of tsne in order to\n",
    "    reduce the dimensionality of the word embeddings.\n",
    "    '''\n",
    "    tsne_results = tsne.fit_transform(visual_matrix)\n",
    "    \n",
    "    '''\n",
    "    We return the new word embedding vectors in the reduced\n",
    "    dimension.\n",
    "    '''\n",
    "    return tsne_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 721,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample words:\n",
      "\n",
      "['lion', 'school', 'kind', 'love', 'give', 'sleep', 'early', 'never', 'under', 'into']\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Here we provide a sample list of words that we would like to visualize\n",
    "using t-SNE in a 2d vector space.\n",
    "'''\n",
    "\n",
    "sample_words = ['lion', 'school', 'kind', 'love', 'give', 'sleep', 'early', 'never', 'under', 'into']\n",
    "\n",
    "print('Sample words:\\n\\n%s' % sample_words)\n",
    "\n",
    "'''\n",
    "We call the get_tsne_results() function with the\n",
    "sample_words list as input to obtain the word\n",
    "embeddings for those words.\n",
    "'''\n",
    "\n",
    "tsne_results = get_tsne_results(sample_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function visualize_words(words, tsne_results):\n",
    "\n",
    "In this function, we try to finally visualize the words in a\n",
    "2d vector space.\n",
    "'''\n",
    "\n",
    "def visualize_words(words, tsne_results):\n",
    "    \n",
    "    '''\n",
    "    Size of the plot/figure\n",
    "    '''\n",
    "    plt.figure(figsize=(20, 10))\n",
    "    \n",
    "    '''\n",
    "    We use the scatter plot feature of matplotlib for visualization\n",
    "    '''\n",
    "    plt.scatter(tsne_results[:,0], tsne_results[:,1], cmap=plt.get_cmap('Spectral'))\n",
    "    \n",
    "    '''\n",
    "    This block of code is used for annotation of the points with the\n",
    "    corresponding word text\n",
    "    '''\n",
    "    for label, x, y in zip(words, tsne_results[:, 0], tsne_results[:, 1]):\n",
    "        plt.annotate(label, \n",
    "                     xy=(x, y), \n",
    "                     xytext=(-14, 14), \n",
    "                     textcoords='offset points',\n",
    "                     fontsize=20)\n",
    "\n",
    "    '''\n",
    "    Some further features of the visualization\n",
    "    '''\n",
    "    plt.xlabel('t-SNE Component 1', fontsize=20)\n",
    "    plt.ylabel('t-SNE Component 2', fontsize=20)\n",
    "    plt.title('GloVe visualization using t-SNE', fontsize=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKcAAAJrCAYAAAA1evCIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XmcllX9//HXh0UYNQcVF0AUNyhX0NFQ+AqIhmCGW26VgJb5TVPUL5bbVyi/LlFK/nJDUzCNUlPQ1NAUUAoXFAmVcAWVRdlmlATZzu+P655xVpiRGW6W1/PxmMcN5zrXuT7Xfd+ovD3nXJFSQpIkSZIkScqHRvkuQJIkSZIkSZsvwylJkiRJkiTljeGUJEmSJEmS8sZwSpIkSZIkSXljOCVJkiRJkqS8MZySJEmSJElS3hhOSZKUZxExIiJSRLTLdy3rU0Tcl7vvXfJdS02qqzEi9sq13ZXP2sqLiI8i4p1817G+bG73K0nSps5wSpKkehQR7SPixoh4NSIWRcSK3OuLEfHriDi4Aa55Ti4s+XMt+l6R6zusvutQw4mIiRGxMt91qGYRcU3uz1bXr3j+thHxy4iYGhFLImJZLoSblPtnx4E1XC9FxDk1jPnD3PHBazi3pp+/f5X7kCTpq2iS7wIkSdoUREQA/5v7aQS8CvwZWAR8DTgA+ClwSUScn1K6pR4v/0fgN8DxEdEypbRgDTWelfvtnfV4/a9qEHANMC/fhdTRLOAbQHG+CymnG5DyXcR6tEndb25m3j+AXYF3gfvJ/tnRhuy7dhGwBJhawxBDIuKPKaUldbz0OOC5Go69V8exJEn6ygynJEmqH/8LDAY+BE5PKf2jcoeI2BEYCBTW54VTSksiYhTwI+BM4MYauh4J7AH8M6X0Rn3W8FWklOYCc/NdR12llFYA/853HeWllN7Ndw3r0yZ4v9eQBVPDgXNTShWCt4hoDexUw7nvAHuRhb1X1/G6z6aUrqnjOZIk1TuX9UmStI4iYg/gSmA50Lu6YAogpfRJSuly4Fd1GPuUiHguIkoiYmlETIuIyyKiWaWuw3OvP1zDcD+q1Lf8dXpHxJMRsTAivoiIdyPiVxGxTS3r/H1uKVCfGo53zR0fVa6t2j2nIuL4iHg2IublapkdEeMj4txK/Wrcd6imJVYRcWJE3B8Rb0fEf3LLpyZHxPkRUav/Lqpuz6lyy6fW9FN+36qzIuLhiHgv97mW5JbunVHdtYAuQOOall3V9F5ERPOIuDwiXs9d59Pc9+nkNd1XROwREQ/kvg9LI+Llmj7b2r5HlY5XWaYYmQGRLWObH9mytg8j4m+V663ufst9Bt+PiJ4RMSH3+ZZExGMR0aGGWr6e+ywW5/r/I/fnoWy8WtzvR8AVud8+X+4zqu1SzMNzr/+vcjAFkFKak1KaUsO5vyWbffg/kYVYkiRtdJw5JUnSuhtA9u/UP9ZmRlJKqVZ/YY2Ia4HLgAVkS/eWAL2Ba4FeEXF0bhYPKaXJETEF6BQRXSoHZBGxPXA8UAI8WOnYL4CrgIXAY8B84ECymRi9I+LwlNJnayl3BNmSwX7AE9UcPzP3OnIt9/wT4BayGVWP5u59x1w9/YDb11LH2vwK+AJ4AZhNNoutJ/D/gIPJPsuv4lVgSDXtLYALgNW565a6A3gNmEAWLLQE+gD3R8TeKaXSsRblxj0L2AX4Rbkx1rjsKrIA82mgK/Am8DtgK+C7wIMR8cuU0v9Wc+ruwEvA28C9wPbAqcBjEdE9pfT8mq67Dm4g+869CzwAfAq0Ag4BTgYequU4xwN9yb6HtwH7Ad8GDomIfVJKi0o7RsQ+ZMvpCoG/Aq8De5J996r7Htfkxtx1/wu4B/gg1766lucvBPYG2udqqIslZDOm7gB+CZxdx/MlSco7wylJktZdl9zrs/U1YEQcRhZMfQgcmlKal2u/DHiE7C/bg8iCqlJ3AreSzZCqPHvrTKAZcFdK6fNy1zmaLJiaCHw7pVRS7tgPc2P+b+5aNUopPR8R7wJ9I6JFSqlsP6aIaA6cQhY4Pb2WW/8xsAw4oPLeWRHRci3n1kavykvCcjOm/gD0j4jfpZReqeugKaVXyQKq8uM2BcYCAVyYUppf7vDXq6mjWa7/FRFxR0ppXi5IGRwRRwGtU0qD61DWpWTB1GPAiaWhaC6MfBm4MiIeTym9WOm8I4ErU0r/V662P5OFN4OAhgqnfkz2fd8/pbS0/IE6fvZ9gaNTSuPLnT8U+B+gPxWXvd5GFiCek1K6s1z/48gCqlpJKd0YEduRhVN3p5Qm1qFeyPan6wzcExGHkv05mVI+SFuL3wMXkn2Hh6WUptXyvCMjoqa/DzyRUnqpluNIkrROXNYnSdK62zn3OrvygYhoFxGDK/0MrMWYpRuXX1MaTEHZrKtLyGZkVF7Cdz/wH+C7EVF5X6vS2RSVl/RdkHv9YflgKnetu8hmcXyvFvVCNsumGdksm/KOJ5uZcl9KaVUtxlmR+6mgpo3e66K6vYpSSqvJlkYB9FrXa5RzF9ADuKnyBvg11PEFWbjYlCwgWldnkX1PLik/Wy/3fbqGLDSrbpbNe8B1lWp7HJgDHFoPda3JcqDKd6SOn/395YOpnNLvfVn9EbE7cAQwg+yzKn+9x4DKYzSk35LN6tsC+Bnwd2BhRLwfEcMjYv81nZz7c3Up2X/bD63DdXuQzbqq7qehP2tJkso4c0qSpHUXudfqnh7WjqqbFM8Chq1lzINyr1VmY6WU3srtcbN7+VlKKaVPI+IBsqVpZ5DNCiEiDgf2BV5MKf2r0nCHkS03Oz0iqEYToFVEFFYOr6oxkmxT+H5kS4xK9St3fG3uJ1ve9WZuts4E4B/1EUxB2QycQWRL6HYnW+ZWXpt6us7VZLPVRpPN2Kl8vB1ZmNATaAsU1GcdEbEt2XdvVkrp7Wq6lH6vOlVzbEousKvswxr615f7gf8G3sh9j58DJqWUPq3jOJOrafsw97ptubaOudd/VrfPE9lswu51vHa1IuJIsiCsvPdSSvcC5K7/s4i4niwg7Uz2z4Bvks2EHBARP04p3V3TNVJKj0fEM2RLfr+VUnqqFqVd5YbokqQNgeGUJEnrbi7wdaoJFHIzOAIgt3ymyoygGpTOfKrpaXZzyZ7uVQgUl2sfThZO/ZBcOMWXM6zupKrtcvWt7SlfW5PtV1WjlNKsiBgP9IiI9rkQrRVwNDC5lvtx/SoiPiELKQYCFwEpIsYBg3LL576S3LKrycBuwItkM70WASvJ3oefks38WicR8QOykO5l4HuVg56I2ItsT6dCsgBmLNl7u4rsaYo/qIc6avP9gWxJW2XF1bRB9j41Xpei1uICsifP9Qcuz/2sjIjHgYtTSmvcY6uc6uovnTlWvv7S9+jjGsapqf2rOJIvN0wv9QzZd7BMSmkx8KfcDxGxNdn7cBlwS0Q8Vml5aGWDgFeAoVFuw3xJkjZ0LuuTJGndle7v1LMexywNgnau4XirSv0ASCm9APwLOCgiDoqIr5Ht9/Qpub/wVvIpMD+lFGv5qbJksQals6NKN0D/PlkgUJtZU6X3MCKl9E2yjbi/TbbBdA9gbG5j91Krqfl/tFUXupxDFkxdlVLqnFL6SUrpytw+Tg9W07/OIqI72RKxmcBx5ff3Kud/yGbw9Esp9UgpXZBSuipXx9r25Kqtr/T9qUelgVytP5+U0sqU0o0ppQPI6j6ZbN+nvsCTuT286lPpjKydajheU3ud5b5nlf9MHVWL85bknvD5AtCcbKbjmvpPAe4DDuDLGYuSJG3wDKckSVp3I8hmZpwcEd+opzFLHxvfvfKB3MybXYD3y288Xk7pDKkfki3v24rsSYL/qabvC8AOEdFhnSvOPET29LAfRLZO8EyyfYRG1XWglNLilNLjKaWzyTYsb0m2wXepxWRLDqubzVNUTdteude/VHOsW13rqywivg48DHwOHJtSqmnmzVepY1V2ierXXlaWm4EzC9g1IvaopkuP3OtXnom2Fotzr20rH8jth7ZX5fbyUkofp5T+klI6iWx2WXtgn3qusfTP2OE1vK9dq2lbk9K9shpidlnp0zJr8/lfASwle3Lflg1QiyRJ9c5wSpKkdZTb3Poass2Mn8zt8VSd6mbz1KR0b5krI2KH0sZcEPNrsn+H/76Gc+8j+8vp94Cf5NqqW9IHXz657K7cErwKImLriPhmbYvOBWAPkS05vATYD/hrSmlhbc6PiGMqPz0sFxzsmPtt+ZlIL5G95/0q9f8h2V49lc3MvXav1L+IbBPqryz3GT1OtvzxpJTSm2voXlMdfciWtFVnIdlnvksdyro7d87Q3BMJS6+zI18uMatxD6N1kQvH3gGOKB985j7bYVRathgRBRFxZOWQKDdbqnSfqOpmoa1Lje+T7SvVgUoPF4iIb1P3/aZKv+O71rWWiLg0IqoN3yKiG9l+VSvIwuQ1Sil9SPYetyFbqipJ0gbPPackSaofvyCb1XAV8I+IeIUsPFlEFkq1A0qX8Ty3tsFSSv+MiF+RbZr9ekQ8RPYkvt5kgc9EangqV0qpOCIeJJu1dADwSk17NaWUnoqIK8lmWbwdEU8C75OFLO3IZvKMI1teV1sjyUKWa8v9vrYeAj6LiIlkIU5j4L/IZkK9lKul1G/J7nF4RHwL+Ihsw+5vkgVFx1YaewRZYPb/IuIosvCkPdm9/YWqTxmsi/8j2y9qMlkgU3nza4Abc5t735Kr+5Hc5zqX7DPtBTxQQx3PACcAoyPib2Th4/sppfvXUNMNwDHAicDU3Ge7FfBdYAfg2twy0IYylGxj/Em57+NyshlbjYBpVJwJtRXZPb4fES8CH5AtY/sW2X5uj9Swsfu6+m+yP0t3RMRxubr2InuvHwW+w5dLFNfmWbKHItwQEQeS7X21OqV07ZpPA7Lvww0RMZ0sgJpH9p7sR/aeBXDhGmbjVXY9WeC2xhlqwJGVw+ByFqWUbq7l9SRJWieGU5Ik1YPc07YGR8Qo4Fyyv1CWLqn7DHiXbIPyP9R2U++U0s8iYgpwPtlfXpvmxrkS+E1KafkaTh/Ol/s+DV/Ldf4vIp4n25C6C9kePyVkYc/tZE9Rq4sJZAHX7sB84Mk6nHspWSBxMFm4tIwspLoUuC2lVLqxNSml1yPiaLJg6DtkM0ueI3vS2WlUCqdSSh9FxH+R/cX9CLLgZjrw49x56xJOlS6fKqL6JYWQ7UX1aUppSu7pbb/M1dgYmAocTzY7qLo67iBbIncq2XvRhCzMqfGzSSl9ERE9yQK508k+3xXAa8BPU0p/rssN1lVKaXhuItRAsrByMdnTCy8nC37K+xT4Odmfmy5k4dCnZN/3H5PtO9YQNb6em+l4LdlMqZ5kn0Vf4ECy71WtnhaYG2sAcDFwHlm4toovQ9o1OZPsu9CDbPP0ncmCrjnAH4FbU0r/rMN9fRoRQ4DfraVrD75c4lnZu4DhlCRpvYjqn5wrSZIkbb4i4s9kDxPYK7d0V5IkNRD3nJIkSdJmKSIaR0SVp/LllomeDEwzmJIkqeG5rE+SJEmbqwLgo4h4Fvg32TK8/YCjyZaUnpfH2hpURPQnWy45IKU0Ir/VSJI2d4ZTkiRJ2lx9Qbaf15Fke5VtCSwA/gxcl1KamsfaJEnabBhOSZIkabOUUlpB9sABSZKUR+45JUmSJEmSpLzZ7J/W17Jly9SuXbt8lyFJkqTNyGeffcZbb71Fq1ataN26dZXj06ZNA2D//fcHYMGCBcyaNYvddtuNZs2aMWfOHD7//HMAtt56a3bZZRcKCgqqjLNs2TJmz57NZ599RkqJgoICWrVqxYoVK8rGa9myZYVzli9fzrx58ygpKWHFihU0atSIrbfemlatWrHVVltV6Dtnzhzmzp1L+/btWbFiBR9//DHLli2jSZMmZbVLkjZPr7zyyoKU0g616bvZL+tr164dkydPzncZkiRJ2oyMHz+eHj16cM455zB48OAqx0v/52npf6eOGDGCAQMGUFRUxJgxY+jduzcdOnTgzTff5IknnmD+/Pm8+eabFYKmt99+m8MOO4zi4mJ69+5Nx44deeedd3jkkUfo3bs3s2bNYvDgwfTv37/snFdffZVvfetbLFq0iF69erHvvvuyYMECRo8ezXvvvccjjzxCnz59yvoPHjyYIUOG0L59e55++mmOO+449txzT0pKSrjtttsa5L2TJG0cImJWbftu9uGUJEmStLEYPXo0Y8eOpWfPnmVtl112Gddffz133303l156aVn7eeedx8KFCxk2bBgXXnhhWfuYMWM4/vjjq4y9cuVKTjnlFJYsWcK4cePo1q1b2bE5c+ZwyCGHcPbZZzNz5kyaNWtW4dxnn32WSZMm0alTp/q8XUnSZsI9pyRJkqSNxGmnnVYhmAI455xzAHjppZfK2j766COefvppdt99d84/v+Ke73379q0QPJV6/PHHeffdd/npT39a5Xjr1q259NJLmTdvHs8880yVc8855xyDKUnSV+bMKUmSJGkjUVRUVKWtbdu2ACxevLisbcqUKQB07dqVxo0bVzmne/fuTJgwoULbpEmTAMqW+1X29ttvAzB9+vQKS/sADj300DrchSRJFRlOSZIkSRuJFi1aVGlr0iT7T/pVq1aVtZWUlACw0047VTvOzjvvXKVt4cKFADz44INrrGHJkiW1Gk+SpNoynJIkSZLWs0aNst01Vq5cWe3xkpISCgsLv/L4ped+/PHH1R6fN29ejeeMGTOG73znO3W6XkTUsUJJkr7knlOSJEnSerbtttsC8OGHH1Y59s4771BcXLxO45fu/zRx4sQKM6pKjR8/vkpb586dAXj++efX6dqSJNWV4ZQkSZK0nn39619nm222YcyYMXzyySdl7UuXLuWCCy5Y5/F32WUXjj76aN5//31+97vfVTg2ZsyYKvtNQbZR+p577sktt9zCE088Ue24kyZN4vPPP1/n+iRJKs9lfZIkSdJ61rRpUy688EJ++ctf0qlTJ0444QRWrlzJ008/TevWrWnduvU6X+OWW27hsMMOY+DAgTz11FMceOCBvPPOOzzyyCMcd9xxPPbYY1Vqevjhh+nVqxfHHnsshx9+OB07dmTLLbfkww8/5OWXX+a9995j7ty5bLnllutcnyRJpZw5JUmSJOXBkCFDuO6662jevDnDhw/niSee4KSTTmLs2LE0bdp0ncffe++9eeGFFzjppJP4xz/+wW9/+1s+/PBDRo8ezYknnljtOQcccABTp07lZz/7GSUlJdxzzz3cdtttvPLKK3Tq1Ik//OEPtGzZcp1rkySpvEgp5buGvCoqKkqTJ0/OdxmSJEmSJEmbjIh4JaVUVJu+zpySJEmSJElS3hhOSZIkSZIkKW8MpyRJkiRJkpQ3hlOSJEmSJEnKG8MpSZIkSZIk5c0GHU5FRNuIGBcR0yPijYi4MNe+XUQ8HRFv5163zbVHRNwcEe9ExL8i4qD83oEkSZIkSZLWZIMOp4CVwCUppW8AnYHzImIf4OfAMymlvYFncr8H6A3snfs5B7ht/ZcsSZIkSZKk2tqgw6mU0tyU0qu5X38GTAfaAH2BkbluI4Hjc7/uC9ybMi8ALSKi1XouW5IkSZIkSbW0QYdT5UVEO6AT8CKwU0ppLmQBFrBjrlsb4MNyp32Ua5MkSZIkSdIGaKMIpyJia+AvwMCU0qdr6lpNW6pmvHMiYnJETJ4/f359lSlJkiRJkqQ6apLvAtYmIpqSBVP3p5QezjV/HBGtUkpzc8v2Psm1fwS0LXf6LsCcymOmlIYDwwGKioqqhFeSJEnShmD0lNkMHTuDOcVLad2igEG9OnB8JxcGSJI2LRv0zKmICOD3wPSU0o3lDj0K9Mv9uh8wplz7mbmn9nUGSkqX/0mSJEkbk9FTZnPZw9OYXbyUBMwuXsplD09j9JTZ+S5NkqR6tUGHU0AX4AfAkRHxWu6nD3A9cHREvA0cnfs9wBPAe8A7wJ3AT/JQsyRJkrTOho6dwdIVqyq0LV2xiqFjZ+SpIkmSGsYGvawvpTSR6veRAuhZTf8EnNegRUmSJEnrwZzipXVqlyRpY7Whz5ySJEmSNkutWxTUqV2SpI2V4ZQkSZK0ARrUqwMFTRtXaCto2phBvTrkqSJJkhrGBr2sT5IkSdpclT6Vz6f1SZI2dYZTkiRJ0gbq+E5tDKMkSZs8l/VJkiRJkiQpbwynJEmSJEmSlDeGU5LqxcyZM4kI+vfvX9bWv39/IoKZM2fmrS5JkiRJ0obNcEqSJEmSJEl5YzglqcFcd911TJ8+nTZt3MhVkiRJklQ9n9YnqcG0atWKVq1a5bsMSZIkSdIGzJlTkhrMmvaceuCBBzjiiCMoLCykoKCA/fffn+uuu44vvviiSt927drRrl07Pv/8cwYNGsSuu+5Ks2bN2GuvvbjhhhtIKa2Hu5EkSZIkNQRnTkla7y6//HKuu+46WrZsyRlnnMHWW2/Nk08+yeWXX87YsWN5+umnadq0aYVzVqxYwbe+9S3mzJlD7969adKkCaNHj+bnP/85y5Yt4+qrr87T3UiSJEmS1oUzpyStV5MmTeK6666jbdu2TJs2jdtuu42hQ4fy2muv8e1vf5sJEyYwdOjQKufNmTOHbbbZhjfeeIM77riDW265hSlTplBYWMhNN93EihUr8nA3kiRJkqR1ZTglab26++67AbjyyivZeeedy9qbNGnCb37zGxo1asRdd91V7bk333wzBQUFZb/fcccd6du3LyUlJcyYMaNhC5ckSZIkNQjDKUnr1auvvgrAkUceWeVY+/bt2WWXXXj//fcpLi6ucKywsJC99tqryjlt27YFYPHixQ1QrSRJkiSpoRlOSVqvSkpKAGp8il9pe2m/Ui1atKi2f5Mm2dZ5q1atqq8SJUmSJEnrkeGUpPWqsLAQgHnz5lV7fO7cuRX6SZIkSZI2bYZTktarTp06ATB+/Pgqx9555x0++ugjdt999xpnSkmSJEmSNi2GU5LWq7POOguAa665hvnz55e1r1q1iv/5n/9h9erVnH322fkqT5IkSZK0njXJdwGSNi+HH344l156Kb/61a/Yb7/9OPnkk9lqq6148sknef311+natSuDBg3Kd5mSJEmSpPXEmVOS1rsbbriBUaNGsffee3Pvvfdy8803s3r1aq655hqefvpptthii3yXKEmSJElaTyKllO8a8qqoqChNnjw532VIkiRJkiRtMiLilZRSUW36OnNKkiRJkiRJeWM4JUmSJEmSpLwxnJIkSZIkSVLeGE5JkiRJkiQpbwynJEmSJEmSlDeGU5IkSZIkScobwylJkiRJkiTljeGUJEmSJEmS8sZwSpIkSZIkSXljOCVJkiRJkqS8aZLvAiRtXkZPmc3QsTOYU7yU1i0KGNSrA8d3apPvsiRJkiRJeWI4JWm9GT1lNpc9PI2lK1YBMLt4KZc9PA3AgEqSJEmSNlMu65O03gwdO6MsmCq1dMUqho6dkaeKJEmSJEn5Zjglab2ZU7y0Tu2SJEmSpE2f4ZSk9aZ1i4I6tUuSJEmSNn2GU5LWm0G9OlDQtHGFtoKmjRnUq0OeKpIkSZIk5Zsboktab0o3PfdpfZIkSZKkUoZTktar4zu1MYySJEmSJJVxWZ8kSZIkSZLyxnBKkiRJkiRJeWM4JUmSJEmSpLwxnJIkSZIkSVLeGE5JkiRJkiQpbwynJEmSJEmSlDeGU5IkSZIkScobwylJkiRJkiTljeGUJEmSJEmS8sZwSpIkSZIkSXljOCVJkiRJkqS8MZySJEmSJElS3hhOSZIkSZIkKW8MpyRJkiRJkpQ3hlOSJEmSJEnKG8MpSZIkSZIk5Y3hlCRJkiRJkvLGcEqSJEmSJEl5YzglSZIkSZKkvDGckiRJkiRJUt4YTkmSJEmSJClvDKckSZIkSZKUN4ZTkiRJkiRJyhvDKUmSJEmSJOWN4ZQkSZIkSZLyxnBKkiRJkiRJeWM4JUmSJEmSpLwxnJIkSZIkSVLeGE5JkiRJkiQpbwynJEmSJEmSlDeGU5IkSZIkScobwylJkiRJkiTljeGUJEmSJEmS8sZwSpIkSZIkSXljOCVJkiRJkqS8MZySJEmSJElS3hhOSZIkSZIkKW8MpyRJkiRJkpQ3hlOSJEmSJEnKG8MpSZIkSZIk5Y3hlCRJkiRJkvLGcEqSJEmSJEl5YzglSZIkSZKkvDGckiRJkiRJUt4YTkmSJEmSJClvDKckSZIkSZKUN4ZTkiRJkiRJyhvDKUmSJEmSJOWN4ZQkSZIkSZLyxnBKkiRJkiRJeWM4JUmSJEmSpLwxnJIkSZIkSVLeGE5JkiRJkiQpbwynJEmSJEmSlDeGU5IkSZIkScobwylJkiRJkiTljeGUJEmSJEmS8sZwSpIkSZIkSXljOCVJkiRJkpRH3bt3JyLyXUbeGE5JkiRJkiQpbwynJEmSJEmSlDeGU5IkSZIkScobwylJkiRJkqQG8uijj9KzZ09atWpFs2bNaN26Nd26dePWW2+t1fljx46lT58+tGzZkmbNmrHnnnsyaNAgiouLq+3/0Ucfcf7557PHHnvQrFkztt9+e77zne/w8ssvV+k7ePBgIoLx48czcuRIOnXqREFBATvuuCNnnXUW8+bNW6d7ry3DKUmSJEmSpAYwfPhw+vbty5tvvslxxx3HJZdcQp8+fVi6dCn33HPPWs//xS9+wTHHHMOLL77IscceywUXXMBee+3Fr3/9a7p06cKnn35aof+rr75Kx44dufXWW+nQoQM//elPOe6443juuefo2rUrTzzxRLXXuemmmzj33HM58MADGThwIB06dOCee+7h8MMPZ/78+fXyXqxJkwa/giRJkiRJ0mbojjvuYIsttmDq1KnsuOOOFY4tWLBgjeeOGzeOq6++msMOO4wnnniCFi1alB0bMWIEAwYM4Oqrr+amm24CYOXKlZxyyiksWbKEcePG0a1bt7L+c+bM4ZBDDuHss89m5syZNGvWrMK1nnzySV588UU6depU1nbRRRcxbNgwfv7zn/P73//+K78HtbHBz5yKiLsj4pOIeL1c23YR8XREvJ173TbXHhFxc0S8ExH/ioiD8le5JEmSJEna3DVp0oSmTZtWaW/ZsuUaz7t3Ay9YAAAgAElEQVT55psBuPPOOysEUwD9+/enY8eO3H///WVtjz/+OO+++y4//elPKwRTAK1bt+bSSy9l3rx5PPPMM1Wu9YMf/KBCMAXZkr/CwkL++Mc/8sUXX6z5JtfRxjBzagTwO+Decm0/B55JKV0fET/P/f5nQG9g79zPN4Hbcq+SJEmSJEnr1fe+9z0uueQS9t13X0499VS6detGly5d2GGHHdZ67qRJk2jatCkPPvggDz74YJXjy5cvZ/78+SxcuJDtt9+eSZMmATBr1iwGDx5cpf/bb78NwPTp0+nTp0+FY5XDLIDCwkI6duzIhAkTmD59Oh07dqzNLX8lG3w4lVJ6LiLaVWruC3TP/XokMJ4snOoL3JtSSsALEdEiIlqllOaun2olSZIkSZIyF198MS1btuTWW2/l5ptvZtiwYUQE3bp1Y+jQoRQVFdV47sKFC1m5ciVDhgxZ4zWWLFnC9ttvz8KFCwGqDbIq969sp512qrbvzjvvDEBJSckax1xXG3w4VYOdSgOnlNLciChduNkG+LBcv49ybYZTkiRJkiRpvTvzzDM588wzKS4u5p///CePPPIId999N7169WL69OlV9qIqVVhYyOrVq1m0aFGtrlNYWAjAmDFj+M53vlOnGj/++ONq20uf1lc6dkPZ4PecqqOopi1V6RRxTkRMjojJ62PXeUmSJEmStHlr0aIFffr04c4776R///4sWrSI559/vsb+nTt3ZvHixbzxxhu1Gr9z584AaxyzJhMmTKjSVlJSwmuvvUbz5s35xje+Uecx62JjDac+johWALnXT3LtHwFty/XbBZhT+eSU0vCUUlFKqag26zwlSZIkSZLq6m9/+xsrV66s0v7JJ1mMseWWW9Z47kUXXQTAj370I+bMqRJt8J///IcXXnih7Pd9+/Zlzz335JZbbuGJJ56odsxJkybx+eefV2n/wx/+wJQpUyq0DR48mJKSEk4//fQqT/erbxvrsr5HgX7A9bnXMeXaz4+IP5FthF7iflOSJEmSJCkfTjvtNJo3b07Xrl1p164dKSWef/55Xn75ZQ4++GCOOuqoGs/t2bMn119/PZdddhl77703ffr0Yffdd2fJkiXMmjWLCRMm0LVrV/72t78B0LRpUx5++GF69erFsccey+GHH07Hjh3Zcsst+fDDD3n55Zd57733mDt3bpVQrHfv3nTp0oVTTjmFVq1aMXHiRCZOnEi7du24/vrrG/Q9Aohs7/ANV0SMItv8vCXwMXA1MBp4ANgV+AD4bkppUUQE2ZP9jgE+BwaklCavafyioqI0efIau0iSJEmSJNXZ7bffztixY5k6dSrz5s2jefPm7Lbbbpx++un893//N1/72tcA6N69OxMmTKC6jGbixIncfPPNTJw4kQULFlBYWEibNm048sgjOeOMM6psqv7JJ59w44038te//pX33nuPRo0a0apVKw488ECOP/54TjvtNJo0yeYqDR48mCFDhjBu3DhmzpzJsGHDmDFjBltvvTXf/va3ufbaa2nVqtVXuveIeCWlVPOO7+X7bujhVEMznJIkSZIkSZuj8uFU9+7d63XsuoRTG+ueU5IkSZIkSdoEGE5JkiRJkiQpbwynJEmSJEmSlDfuOeWeU5IkSZIkSfXKPackSZIkSZK0UTCckiRJkiRJUt4YTkmSJEmSJClvDKckSZIkSZKUN4ZTkiRJkiRJyhvDKUmSJEmSJOVNk3wXIEmSJEmStLkbPWU2Q8fOYE7xUlq3KGBQrw4c36lNvstaLwynJEmSJEmS8mj0lNlc9vA0lq5YBcDs4qVc9vA0gM0ioHJZnyRJkiRJUh4NHTujLJgqtXTFKoaOnZGnitYvwylJkiRJkqQ8mlO8tE7tmxrDKUmSJEmSpDxq3aKgTu2bGsMpSZIkSZKkPBrUqwMFTRtXaCto2phBvTrkqaL1yw3RJUmSJEmS8qh003Of1idJkiRJkqS8OL5Tm80mjKrMZX2SJEmSJEnKG8MpSZIkSVXMnDmTiKB///7MnDmT0047jZYtW9K8eXOKior461//Wu15o0aNokePHmy77bY0b96cb3zjG1xzzTV88cUXZX1mz55N48aNOeigg2q8/jHHHENE8Prrr1dof/HFFzn55JPZeeed2WKLLWjbti0//vGPmTNnTpUxunfvTkSwfPlyfvGLX9ChQweaNWtG//79v9qbIklqEIZTkiRJkmo0a9YsDj30UGbOnMkPfvADTj31VF5//XX69u3LuHHjKvQ9++yzOeOMM3jnnXc48cQTOe+889huu+246qqrOOaYY1i5ciUAbdq04aijjmLKlClMmzatyjXnzp3L3//+dw4++GD222+/svZ77rmHLl268OSTT9KjRw8GDhxIUVERd911F0VFRXzwwQfV3sNJJ53ErbfeyuGHH87AgQPZf//96/EdkiStK/eckiRJklSj8ePHM3jwYK6++uqytjPOOINjjjmGoUOH0qNHDwBGjBjB3XffzQknnMD9999PQcGXjz8fPHgwQ4YM4ZZbbuHCCy8EoH///jz11FOMHDmSX//61xWued9997Fq1Sr69etX1vbWW2/x4x//mHbt2jFhwgTatPlyX5Znn32Wo48+mgsvvJBHHnmkyj3MmjWL119/nZYtW9bPmyJJqleRUsp3DXlVVFSUJk+enO8yJEmSpA3KzJkz2X333dltt9149913ady44iPOd9ttN/7zn/+wYMECADp16sTrr7/O/PnzadGiRYW+q1atYqeddmKPPfbgpZdeAmDp0qW0atWKgoICPvroowrj77fffrz11lvMmTOnLFC66KKLGDZsGH/961859thjq9R7wgkn8Nhjj7F48WK+9rWvAdmyvgkTJjB69Gj69u1bf2+OJGmtIuKVlFJRbfo6c0qSJElSjTp27FglmAJo27YtkyZNAuDzzz9n6tSptGzZkmHDhlU7TrNmzZg+fXrZ7wsKCjjllFO48847GTt2LH369AHglVde4Y033uCEE06oMNOp9FoTJkzg5ZdfrjL+J598wqpVq3jrrbc4+OCDKxw79NBD63jXkqT1yXBKkiRJUo0qz4Iq1aRJE1avXg3A4sWLSSkxf/58hgwZUuux+/fvz5133snIkSPLwqmRI0cCVFjSB7Bw4UIAhg4dusYxlyxZUqVt5513rnVNkqT1z3BKkiRJ0jopLCwEsqV9r776aq3PO/zww9l7770ZM2YMxcXFbLXVVowaNYqWLVuWhVWVr1FSUsI222xTp/oiok79JUnrl0/rkyRJkrROtt56a/bdd1/eeOMNFi1aVKdz+/XrxxdffMGf//xnHn/8cRYsWMAZZ5xB06ZNK/Tr3LkzAM8//3y91S1J2jAYTkmSJElaZxdffDHLly/nrLPOori4uMrxxYsXVzur6swzz6RRo0bce++93HvvvUC23K+y888/n6ZNm3LRRRfx1ltvVTm+fPlygytJ2ki5rE+SJEnSOjvrrLN45ZVXuPXWW9lzzz3p1asXu+66K4sWLeL999/nueeeY8CAAdx+++0Vzmvbti09evTgmWeeoUmTJuy///506tSpyvhf//rXufvuuznrrLPYd999OeaYY2jfvj0rVqzggw8+4Pnnn2eHHXbg3//+9/q6ZUlSPTGckiRJklQvbrnlFnr37s3tt9/O3//+d4qLi9luu+3YddddGTRoEN///verPa9///4888wzrFy5sspG6OV9//vf58ADD+Q3v/kN48aN46mnnmKrrbaidevWnHzyyZx66qkNdWuSpAYUKaV815BXRUVFafLkyfkuQ5IkSZIkaZMREa+klIpq09c9pyRJkiRJkpQ3hlOSJEmSJEnKG8MpSZIkSZIk5Y3hlCRJkiRJkvLGcEqSJEmSJEl506Q2nSKiE9AdWAk8lVKaUUO/vkDflNJZ9VahJEmSJEmSNllrnTkVEb8GJgO/BoYBb0TEzRHRtJruHYF+9VuiJEmSJEmSNlVrDKci4gTgYuAz4C7gNmA+cB7wVERs2eAVSpIkSZIkaZO1tplT/w0sA76ZUvpxSul8oD3wF6Ab8NeIaN7ANUqSlFcjRowgIhgxYkS+S5EkSZI2OWsLpw4CHi6/x1RK6bOU0ilkS/y6A49FRLOGK1GSJEmSJEmbqrVtiL41MKu6AymliyNiFXAJMDq3GbokSZucE044gc6dO9OqVat8lyJJG5zRU2YzdOwM5hQvpXWLAgb16sDxndrkuyxJ0kZkbeHUXGDnmg6mlAZFRBPgQrKlfv+qx9okSdogFBYWUlhYmO8yJGmDM3rKbC57eBpLV6wCYHbxUi57eBqAAZUkqdbWtqxvOtneUjVKKV1EtlH6sWQhlSRJG7yUEr/97W/ZZ599aN68OW3atOH888+npKSEdu3a0a5du7K+lfecWrZsGS1atGDHHXdk5cqV1Y5/7rnnEhE8/vjjFdr//e9/079/f9q2bUuzZs3YaaedOOOMM5gxY0a140jShmzo2BllwVSppStWMXSs/0yTJNXe2sKpJ4E9IuK/1tQppXQe8HvAp/dJkjYK5513HgMHDqSkpIRzzjmH008/naeeeoqjjz6aFStWrPHc5s2bc+qppzJ//nyefPLJKse/+OILHnjgAXbaaSd69epV1v63v/2Ngw46iPvvv59DDjmECy+8kJ49e/Lwww9z6KGH8uqrr9b7fUpSQ5pTvLRO7ZIkVWdty/r+ArQGtl/bQCmlH0XER0C7eqhLkqQG8/zzz3PbbbfRvn17XnzxRVq0aAHAtddey1FHHcWcOXPYbbfd1jhG//79GT58OCNHjuS4446rcOzRRx9l8eLFXHzxxTRpkv2rdvHixZx++ulsueWWPPfcc+yzzz5l/d944w2++c1v8sMf/tCAStJGpXWLAmZXE0S1blGQh2okSRurNc6cSinNSSldllIaXZvBUkpDUkoD6qc0SZIaxsiRIwG44ooryoIpgC222ILrrruuVmMcdthhtG/fnscee4xFixZVO36/fv3K2u69916Ki4sZMmRIhWAKYN999+VHP/oRU6ZM4c033/xK9yRJ+TCoVwcKmjau0FbQtDGDenXIU0WSpI3R2mZOSZK0yZkyZQoAXbt2rXKsc+fOZbOd1qZfv35cccUV/OlPf+InP/kJAB9//DFjx46lU6dOHHDAAWV9J02aBMDUqVMZPHhwlbHeeustAKZPn14lvJKkDVXppuc+rU+StC4MpyRJm52SkhIAdtpppyrHGjduzPbbr3U1OwBnnnkmV111FSNHjiwLp+6//35WrlxZYdYUwMKFCwG488471zjmkiVLanVtSdpQHN+pjWGUJGmdrG1DdEmSNjnbbLMNkM1yqmzVqlVlQdLa7LLLLhx55JG89NJL/Pvf/wayJX1NmzbljDPOqNC3sLAQyGZOpZRq/KkcakmSJEmbOsMpSdJmp1OnTgBMnDixyrEXXniBlStX1nqs/v37A1ko9dprr/Gvf/2L3r17s8MOO1To17lzZyDbjF2SJEnSlwynJEmbnTPPPBOA//u//ytb4gewfPlyLr/88jqNdeKJJ7LNNttw3333MWLECODLwKq8AQMG0KJFC4YMGcJLL71U5fjq1asZP358na4tSZIkbQrcc0qStNnp1q0b55xzDsOHD2ffffflpJNOomnTpjz22GMUFhbSunVrGjWq3f+/KSgo4Lvf/S6///3vufXWW9l+++059thjq/TbfvvteeihhzjhhBPo3LkzPXv2ZN9996VRo0Z88MEHTJo0iYULF7Js2bL6vl1JkiRpg+bMKUnSZum2227jxhtvZOutt+b222/nj3/8I0cddRRPP/00n376adm+VLVROlNqxYoVnH766WyxxRbV9uvZsyf/+te/+MlPfsLMmTO5/fbbueuuu3j99dc58sgj+dOf/lQftyZJkiRtVCKlVLuOEauAwSmlX66hzxXAkJTSRjMjq6ioKE2ePDnfZUiSNhBvv/027du357TTTmPUqFH5LkeSJEnaKEXEKymlotr0rcvMqcj91KafJEkbtHnz5rF69eoKbZ9//jkDBw4E4IQTTshHWZIkSdJmp75nOG0LuFmGJGmDN2zYMEaNGkX37t1p1aoV8+bN45lnnuGjjz6id+/efPe73813iZIkSdJmYY3hVEQcUampXTVtAI2BXYHvATPqqTZJkhrM0UcfzdSpU3nqqadYtGgRTZo0oX379lxwwQUMHDiQCCcCS5IkSevDGveciojVQO02pcqW860Gzkwp/bEealsv3HNKkiRJkiSpftVlz6m1Lev7BVk4FcD/AuOBCdX0WwUsBMallP5d+1IlSZIkSZK0OVtjOJVSGlz664joB4xOKd3c0EVJkiRJkiRp81DrDdFTSrs3ZCGSJEmSJEna/DTKdwGSJEmSJEnafNV65hRAROwNXAgcCmxL9pS+ylJKac96qE2SJEmSJEmbuFqHUxFxGPB3oABYCXyce63StX5KkyRJkiRJ0qauLjOnrgOaAecCd6eUqgumJEnapIyeMpuhY2cwp3gprVsUMKhXB47v1CbfZUmSJEmbjLqEU4cAD6WUhjdUMZIkbUhGT5nNZQ9PY+mKVQDMLl7KZQ9PAzCgkiRJkupJXTZEXw580FCFSJK0oRk6dkZZMFVq6YpVDB07I08VSZIkSZueuoRT/wQ6NVQhkiRtaOYUL61TuyRJkqS6q0s4dTlweET8oKGKkSRpQ9K6RUGd2iVJkiTVXV32nOoLPAuMiIgfAq8AxdX0SymlX9ZHcZIk5dOgXh0q7DkFUNC0MYN6dchjVZIkSdKmpS7h1OByv/6v3E91EmA4JUna6JVueu7T+iRJkqSGU5dwqkeDVSFJ0gbq+E5tDKMkSZKkBlTrPadSShNq+9OQBUuSJKl2Zs6cSUTQv3//tfYdPHgwEcH48eMbtKaIoHv37g16DUmStHGpy4bokiRJkiRJUr2qczgVEQdExPURMSYi/l6uvV1EnBIR29ZviZIkSWpo559/PtOnT+fQQw/NdymSJGkzU5c9p4iIXwCX82WolcodbgSMAgYC/69eqpMkSdJ60bJlS1q2bJnvMiRJ0mao1jOnIuI04ErgaaAjcF354yml94DJwHfqs0BJkiTVr9WrV3PBBRcQEZx44oksW7asxj2nSveIWrBgAeeccw6tWrWiWbNm7Lvvvtxzzz3Vjr98+XJ++ctfsueee9KsWTN23313rrzySr744ov1cHeSJGljU5eZUxcA7wB9U0rLI+KEavpMB7rXR2GSJEmqf8uWLeP73/8+f/nLXzjvvPO4+eabadRozf+/sri4mC5durDFFltw8skns2zZMh566CHOOussGjVqRL9+/cr6ppQ45ZRTGDNmDHvuuSfnn38+y5cv5+6772batGkNfXuSJGkjVJdwan9gREpp+Rr6zAF2WreSJEmS1BAWLVpE3759+cc//sH111/Pz372s1qdN3XqVM4++2zuuOMOGjduDMBFF13EAQccwA033FAhnBo1ahRjxoyhc+fOjBs3jubNmwMwZMgQDjnkkPq/KUmStNGry4boAaxeS5+dgGVfvRxJkiQ1hFmzZtGlSxdefPFF/vCHP9Q6mALYcsstufHGG8uCKYB99tmHLl26MH36dD777LOy9tKlftdee21ZMAWw3XbbcdVVV9XDnUiSpE1NXWZOvQ0cXtPBiGgMdAXeWNeiJEmSVH9mzJjBYYcdxn/+8x+efPJJevbsWafz9957b7bZZpsq7W3btgWyZX9f+9rXAHj11Vdp1KgRXbt2rdK/e/fudS9ekiRt8uoyc+oB4KCIuKSG45cBewF/XOeqJEmSVG/eeust5s6dyx577MFBBx1U5/NbtGhRbXuTJtn/51y1alVZW0lJCdtttx1Nmzat0n/nnXeu87UlSdKmry7h1DBgKvCriHgR6A0QEb/O/X4I8AIwvN6rlCRJ0ld23HHHce211/Laa6/Rs2dPFixY0GDXKiwsZNGiRaxYsaLKsXnz5jXYdSVJ0sar1uFUSmkp0AP4A3AQcCjZPlQXAwcD9wHHpJRWNkCdkiRJWgeXXXYZN910E1OmTKFHjx58/PHHDXKdgw46iNWrVzNx4sQqx8aPH98g15QkSRu3usycIqVUklLqT7bxeW/g+8BxQKuUUr+U0mdrOl+SJEn5M3DgQG677TbeeOMNunXrxpw5c+r9GgMGDADgiiuuYNmyL5+Ts2jRIq655pp6v54kSdr41WVD9DIppUXA2HquRZIkSQ3s3HPPpXnz5px99tkcccQRPPvss+y66671Nv7pp5/On//8Zx599FH2228/+vbty4oVK3jooYc45JBDePfdd+vtWpIkadNQp5lTkiRJ2vj179+f++67j1mzZnHEEUfw3nvv1dvYEcGDDz7IkCFDWL16Nb/73e949NFHGTBgAA888EC9XUeSJG06IqVU+84R2wFnke03tS3QuJpuKaVUt+cT51FRUVGaPHlyvsuQJEmSJEnaZETEKymlotr0rfWyvoj4OjAe2IFsI/Sa1D7tkiRJkiRJ0matLsv6fg3sCNwA7AE0TSk1quanutlUkiRJkiRJUhV12RD9v4DHU0qXN1QxkiRJkiRJ2rzUZeZUAG82VCGSJEmSJEna/NQlnHoF6NBQhUiSJEmSJGnzU5dw6hdAn4jo3kC1SJIkSZIkaTNTlz2n2gJjgKciYhTZTKri6jqmlO6th9okSZIkSZK0iatLODUCSGR7T/0g95Mq9Ylcm+GUJEmSJEmS1qou4dSABqtCkiRJkiRJm6Vah1MppZENWYgkSZIkSZI2P3WZOSVJkqRN0Ogpsxk6dsb/Z+/Ow6uq7j3+v7+ECDiBA8ogiL0iOLSKRusVWxG1YCui1ll+CNYfolit1x+KWqv3VluR9kqtRcFWUVFp64ATLdYB5wEQh6qAtIoKWFo1KBWRYf3+OCe5AU5IDiTskLxfz3Oec7LW2nt/T3A/4se11mZB+VI6tGnF8D7dOKZHx6zLkiRJTUTR4VREbA4cB/QA2gCLgVeA+1NK/67b8iRJklSfJs2czyX3vcHS5SsBmF++lEvuewPAgEqSJG0URYVTEfFd4DZgW3Kbn1dIwHURMTil9HAd1idJkqR6NGrK7MpgqsLS5SsZNWW24ZQkSdooah1ORcS+wH1ACXAn8ASwEGgP9AZOAe6JiJ4ppRn1UKskSZLq2ILypUW1S5Ik1bViZk5dRm6G1LdSSi+u0Tc+In4DTAUuBb5fN+VJkiSpPnVo04r5BYKoDm1aZVCNJElqipoVMfZbwB8LBFMApJReAu7Jj5MkSdImYHifbrQqLVmtrVVpCcP7dMuoIkmS1NQUE061Bj6oYcz7wNbrX07diIi+ETE7IuZGxIis65EkSWqojunRkZ8f93U6tmlFAB3btOLnx33d/aYkSdJGU8yyvgXAATWMKSO3D1VmIqIE+A1wBPAhMC0iHkwpvZVlXZIkSQ3VMT06GkZJkqTMFDNzajLQOyJG5AOgShHRLCIuBA7Pj8vSAcDclNLfU0pfAROB/hnXJEmSJEmSpAKKmTn1U+AY4GrgrIh4htwsqXbAwUAX4CPgqjqusVgdWX354YfANzOqRZIkSZIkSetQ63AqpfRRRPQExpJbMrfzGkP+AgxNKWW6rA+IAm1ptQERQ4AhAJ07d94YNUmSJEmSJKmAYmZOkVJ6D+gTER2BHuQ2SV8MzEwpza/78tbLh0CnKj/vRG6/rEoppXHAOICysrLVgitJkiRJkiRtPEWFUxXyQVRDCaPWNA3oGhG7kKvxZODUbEuSJEmSJElSIesVTkVEJ9aeOfXBuo/aOFJKKyLiXGAKUALcklJ6M+OyJEmSJEmSVEBR4VREdAXGAL0L9D0BDEspzamj2tZbSmky2T81UJIkSZIkSTWodTgVEbsCzwPbAX8DniX3dL6Kp/UdBjwbEQellObWQ62SJEmSJElqZIqZOfVzcsHU+cBvUkqrKjoiohnwQ+A64GfAiXVZpCRJkiRJkhqnYsKpw4DJKaVfr9mRD6p+FRHfAQ6vq+IkSZIkSZLUuDUrYuxmwKs1jHkVKF3/ciRJkiRJktSUFBNOvQbsWsOYXYHX178cSZIkSZIkNSXFhFM/A46LiCMLdUbE94BjgavrojBJkiRJkiQ1fsXsObUd8Cfg4Yh4HHga+AewI3AI0Bt4CNg+IgZWPTCldHvdlCtJkiRJkqTGJFJKtRsYsQpIQNQwtOoJA0gppZL1K6/+lZWVpenTp2ddhiRJkiRJUqMRETNSSmW1GVvMzKnB61mPJEmSJEmSVFCtw6mU0m31WYgkSZIkSZKanmI2RJckSZIkSZLqlOGUJEmSJEmSMlNUOBURB0TEvRHxt4hYFhErC7xW1FexkiRJkiRJalxqvedURBwPTCQXaL0HvAwYREmSJEmSJGm9FfO0viuBfwPfSyk9Wz/lSJIkSZIkqSkpZlnfrsDdBlOSJEmSJEmqK8WEUx8By+urEK3tvffeIyIYNGhQ1qVIkiRJkiTVi2LCqT8CR0TEZvVVjOpHly5d6NKlS9ZlSJIkSZIkraWYPaeuAL4F/CEizk8pzaunmpTXsWNH3n77bVq3bp11KZIkSZIkSfWi1uFUSumLiBgCPAn8PSLKgcWFh6b/qKsCm7LS0lK6d++edRmSJEmSJEn1ptbL+iLiYOB5YBtgJfAFEAVexSwV1DoU2nNq0KBBRATvvfceY8eO5etf/zotW7Zkxx13ZMiQISxe/H954dSpU4kI5s2bx7x584iIytea+1g9/vjj9O3bl2233ZaWLVuy2267MWLEiNXOJ0mSJEmSVNeKWdY3EigFBgJ3pZRW1U9Jqo2LLrqIKVOm0K9fP77zne/w5JNPcvPNNzN37lyeeOIJILfX1BVXXMHo0aMB+NGPflR5/D777FP5eezYsZx99tlsscUWnHDCCeywww5MnTqVkSNH8tBDD/Hcc57w1GEAACAASURBVM/Rpk2bjfsFJUmSJElSk1BMOLU3cHdKaUJ9FaPae/HFF3njjTfo3LkzACtWrKB37948+eSTvPzyyxxwwAF06dKFK6+8kvHjxwNw5ZVXrnWeefPmcd5557Hlllvy8ssvr7aM8JxzzuHGG2/koosuYty4cRvja0mSJEmSpCammCV4S4BP6qsQFecnP/lJZTAF0Lx5cwYPHgzAyy+/XOvzTJgwga+++opzzz13rf2trr76arbaaivuuOMOli1bVjeFS5IkSZIkVVFMODUZOKS+ClFxysrK1mrr1KkTAJ9++mmtz/PKK68A0Lt377X6ttlmG3r06MGXX37JrFmz1rNSSZIkSZKk6hUTTo0Ato6I30TEFvVVkGqn0B5QzZvnVmmuXLmy1uep2PC8ffv2Bfsr2svLy4stUZIkSZIkqUbF7Dk1EfgcGAoMjIg5QKFHuaWU0mF1UZzqX+vWrQH46KOP2HPPPdfqX7hw4WrjJEmSJEmS6lIxM6d6AfsAAWwB9Mi3FXqpASkpKal2NlWPHj0AmDp16lp95eXlvPrqq7Rs2ZLdd9+9PkuUJEmSJElNVK3DqZRSs1q+SuqzYBVvu+2245///CdLly5dq2/AgAGUlpby61//mrlz567Wd/nll/PZZ58xYMAAWrRosbHKlSRJkiRJTUgxy/q0iTrssMOYNm0affv25dvf/jYtWrRg7733pl+/fnTp0oXRo0czbNgw9t13X0488UTatm3LU089xQsvvED37t0ZOXJk1l9BkiRJkiQ1UoZTTcCPf/xjysvLeeihh3juuedYuXIlp59+Ov369QPgnHPOYdddd+UXv/gF9957L1988QWdOnVi+PDhXHrppQU3X5ckSZIkSaoLkVIq7oCIk4Ezye051Rr4DJgB/C6lNLHOK6xnZWVlafr06VmXIUmSJEmS1GhExIyUUlltxtZ65lREBHA7cCq5TdFXAv8EtgcOA3pHxNEppVOLL1mSJEmSJElNUTFP6zsLOA14BTgcaJlSag+0zP88AzgpIobWeZWSJEmSJElqlIoJp84A3gO+nVJ6IqW0EiCltDKl9ARwSL7/B3VdpCRJkiRJkhqnYsKpPYD7U0pLC3Xm2ycBu9dFYZIkSZIkSWr8igmnErm9ptalpn5JkiRJkiSpUjHh1NvAcRHRqlBnvv0Y4K26KEySJEmSJEmNXzHh1C1AZ+DpiDgsIpoDRERJRBwKPAnsnB8nSZIkSZIk1ah5EWPHAt8CTgEeBVZFxCfAtuRCrgD+kFK6qc6rlCRJkiRJUqNU65lTKec04DTgCWAxuWBqcf7n01JKJ9dLlZIkSZIkSWqUipk5BUBK6W7g7nqoRZIkSZIkSU1M0eGUGp5JM+czaspsFpQvpUObVgzv041jenTMuixJkiRJkqQarTOciohmwEQgAQNSSsurGbcZcAe51X8u7duIJs2czyX3vcHS5SsBmF++lEvuewPAgEqSJEmSJDV4Ne059f3864HqgimAlNJXwCTghIj4fh3WpxqMmjK7MpiqsHT5SkZNmZ1RRZIkSZIkSbVXUzh1IrCA2u0xNRGYD5y6oUWp9haULy2qXZIkSZIkqSGpKZzaH3gipZRqOlF+zBNAWV0Uptrp0KZVUe2SJEmSJEkNSU3hVDvgwyLONx/YYf3LUbGG9+lGq9KS1dpalZYwvE+3jCqSJEmSJEmqvZqe1vcV0KKI87UAqt2bSnWvYtNzn9YnSZIkSZI2RTWFUwuAvYs43975Y7QRHdOjo2GUJEmSJEnaJNW0rO854JCI2LWmE+XH9AKeqYO6JEmSJEmS1ATUFE7dRG521R8jotq9pCKiLfCH/PnG1V15kiRJkiRJaszWuawvpTQtIsYCZwFv5j8/QW6T9ATsBBwGDAG2A25KKU2r35IlSZIkSZLUWNS05xTAD4ES4EzgkvxrTQHcDJxXd6VJkiRJkiSpsatpWR8ppRUppSFAT2AC8C7wZf71LnAHcHBK6ayU0sr6LFaSJEmSVJz33nuPiGDQoEFZlyJJBdVm5hQAKaUXgBfqsRZJkiRJkiQ1MTXOnJIkSZIkSZLqi+GUJEmSJEmSMmM4JUmSJElN0MKFCxk2bBhdunRhs802o23bthx33HHMmDFjtXE///nPiQiuv/76gudZsGABJSUl7L///qu1r1ixgjFjxnDggQey9dZbs/nmm9OjRw9uuOEGVq1aVW/fS9Kmx3BKkiRJkpqYd999l7KyMsaMGcN//Md/cOGFF9KnTx8eeeQRDjroIB5++OHKsQMHDqRZs2bcdtttBc81YcIEVq1axemnn17Ztnz5co466iiGDRtGeXk5p556KkOGDGHVqlX88Ic/XG2sJNV6Q3RJkiRJUuMwdOhQFixYwFVXXcVll11W2X7OOefw7W9/m9NPP5158+ax5ZZb0rFjRw4//HAeffRR/vrXv7LXXnutdq7bbruN0tJSTjnllMq2q6++milTpnDuuecyevRoSkpKAFi5ciVDhgzhlltu4fjjj6d///4b5wtLatCcOSVJkiRJTciHH37Io48+SufOnbnoootW6zvooIM45ZRT+OSTT7jvvvsq2ytmOq05e2r69Om89dZbHHXUUWy33XYArFq1ihtuuIF27dpx3XXXVQZTACUlJfzyl78kIrjzzjvr6ytK2sQ4c0qSJEmSmpCZM2cC8K1vfYvS0tK1+nv37s2ECROYOXMmAwcOBODYY4+ldevWTJgwgWuuuaYycKoIqwYNGlR5/Jw5c/j444/p2rUrV111VcEaWrVqxdtvv12XX0vSJmyd4VREdAbKU0qf1eZk+fFdUkpP10VxkiRJkqS6tXjxYgDat29fsL+ivby8vLKtVatWnHjiidx88808+uijHHnkkSxfvpy7776btm3bcuSRR1aO/fjjjwF45513+O///u9q61iyZMkGfxdJjUNNy/reBc6v2hARZ0XEK9WMHww8WReFSZIkSZLqXuvWrQH46KOPCvYvXLhwtXEV1lza9/DDD/Pxxx9z6qmnrjYDq+K4Y489lpRSta933323br+YpE1WTeFU5F9VtQP2rp9yJEmSJEn1qUePHgA8++yzrFixYq3+J5/MzTfYd999V2vv2bMnXbt25YEHHmDx4sWVIdWaT97r3r07bdq04cUXX2T58uX18RUkNTJuiC5JkiRJTchOO+3EEUccwXvvvcfo0aNX63vppZe466672GabbTj22GPXOvb000/nyy+/ZMyYMUyePJlvfOMblWFXhebNm/PDH/6QhQsXct5557F06dK1zrNw4ULeeuutuv1ikjZZboguSZIkSU3MTTfdRM+ePRk+fDiPPvooZWVlfPDBB/zxj3+kWbNm3HrrrWy11VZrHTdw4EB+8pOfcMUVV7B8+fK1Zk1VuPzyy3nttde46aabeOihh+jduzcdO3Zk0aJFvPPOOzz33HNcffXV7LHHHvX9VSVtAgynJEmSJKmJ+drXvsb06dO56qqrmDx5MlOnTmXrrbemb9++XHbZZey///4Fj+vUqROHHnoojz/+OM2bN+e0004rOK60tJRJkyYxYcIExo8fz8MPP8ySJUto27Ytu+yyCz/96U+rPVZS0xMppeo7I1YBV6aU/qdK2xXAT1JKJQXGV9vXUJWVlaXp06dnXYYkSZIkSVKjEREzUkpltRlbmz2nqk+vJEmSJEmSpA1Qm2V9F0TE4Co/twGIiL8XGNumTqqSJEmSJElSk1CbcKoNhUOnLtWMd6aVJEmSJEmSaqWmcGqXjVKFJEmSJEmSmqR1hlMppXkbqxBJkiRJkiQ1PbXZEF2SJEmSJEmqF4ZTkiRJkiRJysw6l/VFxPvrcc6UUtp5PeuRJEmSJElSE1LThug7rcc5fVqfJEmSJEmSamWdy/pSSs1q8wKOB+bmD/us3quWJEmSJElSo1DTzKl1iogDgF8APYGVwBjgyg0vS5IkSZK0MU2aOZ9RU2azoHwpHdq0YnifbhzTo2PWZUlqAtYrnIqILsA1wAlAAA8AF6WU3qmzyiRJkiRJG8WkmfO55L43WLp8JQDzy5dyyX1vABhQSap3RT2tLyLaRMQvgLeBE4HpwCEppWMNpiRJkiRp0zRqyuzKYKrC0uUrGTVldkYVSWpKajVzKiKaAz8ELgO2Bd4DLk0pTay/0iRJkiRJG8OC8qVFtUtSXapx5lREnAjMAn6ZHz8c6G4wJUmSJEmNQ4c2rYpql6S6tM5wKiJeAO4GOgKjga+llH6ZUvpqYxQnSZIkSap/w/t0o1VpyWptrUpLGN6nW0YVSWpKalrW900gAR8BZcCDEVHTOVNK6ZA6qE2SJEmStBFUbHru0/okZaE2e04FsHP+VRtp/cuRJEmSJGXhmB4dDaMkZaKmcGqXjVKFJEmSJEmSmqR1hlMppXkbqxBJkiRJkiQ1PTU+rU+SJEmSJEmqL7XZc6qgiCgFzgZ6k9uX6ingNymlZXVUmyRJkiRJkhq5dc6cioiBEfF+RBy2Rnsz4GHgOuBooB8wCngiItY78JIkSZIkSVLTUtOyviOArYCpa7Sfku/7B3AmcBLwEnAg8IO6LVGSJEmSJEmNVU3h1L7A8ymllWu0DwASMDCldEtK6Y/Ad4DFwIl1X6YkSZIkSZIao5rCqR2BvxdoPwj4R0rpsYqGlNIS4BFgr7orT5IkSZIkSY1ZTeHU1sC/qzZExK7klvo9V2D8h0CbuilNkqSGISLo1atX1mVIkiRJjVJN4dSnwC5rtO2ff59ZYHxzYMmGFiVJkiRJkqSmoaZwaibwvYhoX6XtZHL7TT1VYHxXYGEd1SZJkiRJkqRGrqZw6nfA5sALEfG/EfEw0A/4W0pptWV9EdEc+BbwWr1UKkmSJEmSpEZnneFU/il8vwU6Az8CvkvuiXz/b4Hh/YBtgL/UcY2SJPHSSy9x/PHH065dOzbbbDM6derEWWedxYIFC1YbN2PGDM4//3z23ntvtt12W1q2bEnXrl258MIL+fTTT9c67/jx44kIxo8fz5///Gd69epF69atiYhqaxkxYgQRwe23316wf8aMGUQE/fr127AvLUmSJDUBNc2cIqU0BDgYuBg4E9gzpVRoSd8XwAXAg3VaoSSpybv11lvp2bMnf/rTnzj00EP50Y9+RFlZGb/97W8pKyvj/fffrxx78803M3HiRLp168bgwYMZOnQo7du353//93/p2bMnn3/+ecFr3HPPPRx11FFstdVWDB06lBNPPLHaeoYOHUqzZs0YO3Zswf6K9rPOOmsDvrUkSZLUNERKKesaMlVWVpamT5+edRmSpGrMmTOHvfbai86dO/PUU0/RsWPHyr4nnniCI444gqOPPpr7778fgHnz5rHTTjtRUlKy2nl+97vfceaZZ3LNNddw8cUXV7aPHz+ewYMHExFMnjyZvn37rlVDRHDIIYcwderUyrajjjqKRx55hNdff52vf/3rle1Lliyhffv2bLPNNrz77rtr1SFJkiQ1BRExI6VUVpuxNc6cWsdFto6Izut7vCRJtXHjjTeyfPlyfvWrX60WTAH07t2bo48+moceeqhyRtTOO+9cMBA644wz2HrrrZkyZUrB6/Tv379gMFWds88+G4Bx48at1n7nnXeyZMkSzjzzTIMpSZIkqRaab8CxFwA/AfybtySp3rzwwgsAPPXUU0ybNm2t/kWLFrFy5UrmzJnDfvvtx/Llyxk7diwTJ07krbfeYvHixaxatapy/Pz58wte54ADDiiqriOPPJJddtmFO+64g5EjR7L55psDubCqpKSEM888s6jzSZIkSU3VhoRT9SoiTgCuBHYHDkgpTa/SdwnwA2AlcF5KaUq+vS/wK3KB2W9TStds7LolSXXr448/BmDUqFHrHLdkyRIATjrpJO6//36+9rWv0b9/f9q1a0eLFi0AGD16NMuWLSt4fLt27Yqqq1mzZpx11lmMGDGC3//+9wwePJgZM2bwyiuvcMwxx9ChQ4eizidJkiQ1VQ02nAL+ChwHrLbbbETsAZwM7Al0AB6LiN3y3b8BjgA+BKZFxIMppbc2XsmSpLrWunVrABYvXszWW2+9zrHTp0/n/vvv5/DDD2fy5MmUlpZW9q1atYprr7222mPX9XS+6pxxxhlcccUVjB07lsGDB7sRuiRJkrQe1nvPqfqWUno7pTS7QFd/YGJKaVlK6V1gLnBA/jU3pfT3lNJXwMT8WEnSJuzAAw8E4Jlnnqlx7Ny5cwE4+uijVwumAF5++WWWLl1ap7W1bduW448/npdeeonnnnuOu+++my5duvCd73ynTq8jSZIkNWYbEk5F/rWxdQQ+qPLzh/m26tolSZuwc889l9LSUi644ALmzJmzVv9XX31VGVx16dIFYLWn6kFuX6phw4bVS30VG6OfdNJJLFmyhCFDhtCsWYP9fz+SJElSg7Mhy/quA27dkItHxGNAoU0+LkspPVDdYQXaEoWDtlTNdYcAQwA6d/aBg5LUkHXv3p1bbrmFM844gz333JO+ffuy2267sXz5ct5//32eeeYZ2rZty6xZs9h///3p2bMn9913HwcddBAHH3ww//jHP/jTn/5Et27d6mUfqJ49e7L33nvz2muvUVpayhlnnFHn15AkSZIas1r/r92IGBgR36j4OaW0OKU0b40xe0XEwNqeM6V0eEpprwKv6oIpyM2I6lTl552ABetoL3TdcSmlspRSWdu2bWtbriQpIwMGDGDGjBmcdtppvP7669xwww1MmDCBuXPncvzxxzNmzBgASkpKePDBBzn77LNZsGAB119/Pc8++yxnnnkmU6ZMWWupX10ZPHgwAP3792fHHXesl2tIkiRJjVWkVHBy0doDI1YBV6aU/mcdYy4D/ielVFJH9RERU4H/r+JpfRGxJ3AXuT2mOgCPA13JzaiaAxwGzAemAaemlN5c1/nLysrS9OnT1zVEkqR1GjRoELfddhuPPfYYhx12WNblSJIkSZmLiBkppbLajK3rp/WVUM1SumJFxLHAr4G2wCMR8WpKqU9K6c2I+APwFrACGJZSWpk/5lxgSr6OW2oKpiRJ2lAffPABEydOZPfdd6d3795ZlyNJkiRtcuo6nNoN+LQuTpRSuh+4v5q+q4GrC7RPBibXxfUlSVqXu+66izlz5jBx4kSWLVvGT3/6UyKyeE6IJEmStGlbZzgVEbes0XRMRHQpMLQE6Ax8C3ikTiqTJKkBGzduHE8//TSdOnXiuuuu4/vf/37WJUmSJEmbpJpmTg2q8jkB++RfhSTgJeCCDS9LkqSGberUqVmXIEmSJDUKNYVTu+TfA/g7MBr4VYFxK4FPU0r/rsPaJEmSJEmS1MitM5xKKc2r+BwR/w08WbVNkiRJkiRJ2hC13hA9pfTf9VmIJEmSJEmSmp5mWRcgSZIkSZKkpstwSpIkSZIkSZkxnJIkSZIkSVJmar3nlCRJDdmkmfMZNWU2C8qX0qFNK4b36cYxPTpmXZYkSZKkGhhOSZI2eZNmzueS+95g6fKVAMwvX8ol970BYEAlSZIkNXAu65MkbfJGTZldGUxVWLp8JaOmzM6oIkmSJEm1ZTglSdrkLShfWlS7JEmSpIbDcEqStMnr0KZVUe2SJEmSGg7DKUnSJm94n260Ki1Zra1VaQnD+3TLqCJJkiRJteWG6JKkTV7Fpuc+rU+SJEna9BhOSZIahWN6dDSMkiRJkjZBLuuTJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZMZySJEmSJElSZgynJEmSJEmSlBnDKUmSJEmSJGXGcEqSJEmSJEmZabDhVESMiohZEfF6RNwfEW2q9F0SEXMjYnZE9KnS3jffNjciRmRTuSRJkiRJkmqrwYZTwF+AvVJK3wDmAJcARMQewMnAnkBfYExElERECfAb4EhgD+CU/FhJkiRJkiQ1UA02nEopPZpSWpH/8UVgp/zn/sDElNKylNK7wFzggPxrbkrp7ymlr4CJ+bGSJEmSJElqoBpsOLWGM4A/5T93BD6o0vdhvq26dkmSJEmSJDVQzbO8eEQ8BrQr0HVZSumB/JjLgBXAnRWHFRifKBy0pWquOwQYAtC5c+ciq5YkSZIkSVJdyTScSikdvq7+iDgdOAo4LKVUETR9CHSqMmwnYEH+c3Xta153HDAOoKysrGCAJUmSJEmSpPrXYJf1RURf4GLg6JTSF1W6HgROjogWEbEL0BV4GZgGdI2IXSJiM3Kbpj+4seuWJEmSJElS7WU6c6oGNwAtgL9EBMCLKaWhKaU3I+IPwFvklvsNSymtBIiIc4EpQAlwS0rpzWxKlyRJkiRJUm3E/62Wa5rKysrS9OnTsy5DkiRJkiSp0YiIGSmlstqMbbDL+iRJkiRJktT4GU5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JktQA9OrVi4jIuozVXHnllUQEU6dOzboUSZIkNWKGU5IkSZIkScqM4ZQkSZIkSZIyYzglSZIkSZKkzBhOSZK0Hh588EEOO+ww2rdvT4sWLejQoQOHHHIIY8aMWW3cJ598wmWXXcZee+3F5ptvTuvWrdl7770ZMWIE//73v9c674oVK/jZz35G165dadGiBZ06deLiiy/mq6++KljH448/Tt++fdl2221p2bIlu+22GyNGjGDx4sUFx7/zzjsMHDiQjh07stlmm9GhQwcGDhzIO++8s+G/FEmSJGk9NM+6AEmSNjXjxo3jrLPOol27dvTr14/tt9+eRYsW8frrr3PrrbdyzjnnAPDuu+9y6KGHMm/ePPbbbz/OPvtsVq1axZw5c7juuusYOnQoW2yxxWrnPvXUU3nmmWc48sgj2XrrrZk8eTLXXnstixYt4tZbb11t7NixYzn77LPZYostOOGEE9hhhx2YOnUqI0eO5KGHHuK5556jTZs2leOnTZvG4Ycfzueff87RRx/NHnvswaxZs7jzzjt54IEHePzxxykrK6v/X6AkSZJUheGUJElFGjt2LJttthmvvfYaO+yww2p9//rXvyo/DxgwgHnz5vGzn/2MSy65ZK1xW2655Vrn/tvf/sabb77JtttuC8DVV1/N3nvvze23387Pf/5z2rVrB8C8efM477zz2HLLLXn55Zfp3r175TnOOeccbrzxRi666CLGjRsHQEqJgQMH8tlnnzFhwgROO+20yvG///3vOfnkkxkwYABvvfUWzZo5sVqSJEkbj3/7lCRpPTRv3pzS0tK12rfffnsAZsyYwfPPP88+++zDxRdfXHBcy5Yt12ofOXJkZTAFsMUWW3DaaaexatUqpk+fXtk+YcIEvvrqK84999zVginIBVpbbbUVd9xxB8uWLQPg+eefZ9asWfznf/7nasEUwEknncTBBx/M7NmzefbZZ4v4LUiSJEkbznBKkqQinXbaaXzxxRfsueeeXHDBBUyaNIl//vOfq4158cUXAejTp09RM5EKLavr1KkTAJ9++mll2yuvvAJA79691xq/zTbb0KNHD7788ktmzZpV4/iq7TNnzqx1rZIkSVJdMJySJKlI//Vf/8Vtt91G586duf766zn22GPZcccdOfTQQytnN5WXlwPQsWPHos5ddY+oCs2b51bhr1y5srKtYsPz9u3bFzxPRXtFHcWOlyRJkjYWwylJktbDwIEDefHFF/n444955JFH+MEPfsDTTz9Nnz59WLRoUWXINH/+/Hq5fuvWrQH46KOPCvYvXLhwtXHFjpckSZI2FsMpSZI2QJs2bfjud7/LzTffzKBBg/jkk0945plnOPDAAwGYMmUKq1atqvPr9ujRA4CpU6eu1VdeXs6rr75Ky5Yt2X333WscX7V93333rfNaJUmS3SqMCQAAEbhJREFUpHUxnJIkqUh//vOfWbFixVrtixYtAmDzzTdnv/3246CDDuLVV19l5MiRa439+OOP+fLLL9e7hgEDBlBaWsqvf/1r5s6du1rf5ZdfzmeffcaAAQNo0aIFAD179qRbt248++yz3HPPPauNv+eee3j66afZbbfdOPjgg9e7JkmSJGl9NM+6AEmSNjUnn3wyLVu25OCDD6ZLly6klHjmmWeYNm0a++23H4cffjiQe6Jer169uPTSS7n33nvp1asXKSXeeecdHn30UWbNmkWXLl3Wq4YuXbowevRohg0bxr777suJJ55I27Zteeqpp3jhhRfo3r37aqFYRHDbbbdxxBFHcNJJJ9G/f3+6d+/O7NmzmTRpEltttRW33357UZu3S5IkSXXBcEqSpCJdc801TJkyhVdeeYXJkyfTsmVLdt55Z0aOHMnZZ59NaWkpALvssguvvPIK1157LZMmTeKGG26gZcuWdOnShQsvvJAddthhg+o455xz2HXXXfnFL37BvffeyxdffEGnTp0YPnw4l1566Vqbq3/zm99k2rRpXHXVVTz22GM89NBDbL/99pxyyilcfvnldOvWbYPqkSRJktZHpJSyriFTZWVlqeLJSpIkSZIkSdpwETEjpVRWm7HO3ZckSZIkSVJmDKckSZIkSZKUGcMpSZIkSZIkZcZwSpIkSZIkSZkxnJIkSZIkSVJmDKckSZIkSZKUGcMpSZIkSZIkZcZwSpIkSZIkSZkxnJIkSZIkSVJmDKckSZIkSZKUmeZZFyBJUmM2aeZ8Rk2ZzYLypXRo04rhfbpxTI+OWZclSZIkNRiGU5Ik1ZNJM+dzyX1vsHT5SgDmly/lkvveADCgkiRJkvJc1idJUj0ZNWV2ZTBVYenylYyaMjujiiRJkqSGx3BKkqR6sqB8aVHtkiRJUlNkOCVJUj3p0KZVUe2SJElSU2Q4JUlSPRnepxutSktWa2tVWsLwPt0yqkiSJElqeNwQXZKkelKx6blP65MkSZKqZzglSVI9OqZHR8MoSZIkaR1c1idJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjJjOCVJkiRJkqTMGE5JkiRJkiQpM4ZTkiRJkiRJyozhlCRJkiRJkjITKaWsa8hURPwTmJd1HWpStgf+lXURkgry/pQaLu9PqWHzHpUarqzuz51TSm1rM7DJh1PSxhYR01NKZVnXIWlt3p9Sw+X9KTVs3qNSw7Up3J8u65MkSZIkSVJmDKckSZIkSZKUGcMpaeMbl3UBkqrl/Sk1XN6fUsPmPSo1XA3+/nTPKUmSJEmSJGXGmVOSJEmSJEnKjOGUVE8iYlREzIqI1yPi/ohoU6XvkoiYGxGzI6JPlfa++ba5ETEim8qlpiEiToiINyNiVUSUrdHnPSo1IN57UrYi4paIWBQRf63Stm1E/CUi3sm/b5Nvj4i4Pn+/vh4R+2ZXudT4RUSniHgyIt7O/932/Hz7JnWPGk5J9ecvwF4ppW8Ac4BLACJiD+BkYE+gLzAmIkoiogT4DXAksAdwSn6spPrxV+A44Omqjd6jUsPivSc1COPJ/TuxqhHA4ymlrsDj+Z8hd692zb+GADdupBqlpmoFcGFKaXfgQGBY/t+Tm9Q9ajgl1ZOU0qMppRX5H18Edsp/7g9MTCktSym9C8wFDsi/5qaU/p5S+gqYmB8rqR6klN5OKc0u0OU9KjUs3ntSxlJKTwOfrNHcH7gt//k24Jgq7bennBeBNhHRfuNUKjU9KaWFKaVX8p8/B94GOrKJ3aOGU9LGcQbwp/znjsAHVfo+zLdV1y5p4/IelRoW7z2pYdoxpbQQcv9xDOyQb/eelTISEV2AHsBLbGL3aPOsC5A2ZRHxGNCuQNdlKaUH8mMuIzfV8s6KwwqMTxQOi32cprQBanOPFjqsQJv3qJSd6u5JSQ2T96yUgYjYErgX+FFK6bOIQrdibmiBtszvUcMpaQOklA5fV39EnA4cBRyWUqq44T8EOlUZthOwIP+5unZJ66Gme7Qa3qNSw7Kue1JSdv4REe1TSgvzS4IW5du9Z6WNLCJKyQVTd6aU7ss3b1L3qMv6pHoSEX2Bi4GjU0pfVOl6EDg5IlpExC7kNqJ7GZgGdI2IXSJiM3IbMj+4seuW5D0qNTDee1LD9CBwev7z6cADVdoH5p8IdiCwuGJpkaS6F7kpUr8D3k4p/W+Vrk3qHnXmlFR/bgBaAH/JT6l8MaU0NKX0ZkT8AXiL3HK/YSmllQARcS4wBSgBbkkpvZlN6VLjFxHHAr8G2gKPRMSrKaU+3qNSw5JSWuG9J2UrIu4GegHbR8SHwBXANcAfIuIHwPvACfnhk4HvknugyBfA4I1esNS09AT+H+CNiHg133Ypm9g9Gv+30kiSJEmSJEnauFzWJ0mSJEmSpMwYTkmSJEmSJCkzhlOSJEmSJEnKjOGUJEmSJEmSMmM4JUmSJEmSpMwYTkmSJEmSJCkzhlOSJKlWIqJLRKSIGL8B5zghIv4cEYsiYnlEfBwRb0XEhIg4vZrrpYh4KSKimnOmiPhwHceu69WlyPoPiIjfRcTsiPg8IpZFxLyIuCciToyIkmJ/J6p7EXFl/s+313oc+4OIGJv/Z+6L/HmuqocyJUlSXvOsC5AkSU1DRIwD/l9gKfAI8C6wBfA1oB/QC7itmsMPAE4CJhZ52cXA6HX0l9fmJBFRClwPDAVWAk+R+w7LgJ2A3sD3gXuB44usUQ3LL4HWwKfAAuA/si1HkqTGz3BKkiTVu4joSS6Y+hD4z5TSmjOdSsmFU4W8D7QDfhYR96WUviri0uUppSuLr3gtvyFX/xvACSml2VU78zOmTgH618G1lK2TgbdTSvMiYhBwa8b1SJLU6LmsT5Ik1SgiriQ30wng9DWWxg2qxSl65t/vXTOYAkgpLU8p/aWaYz8AbgR2AX5YXOUbLiIOIhdMfQL0WTOYAkgprUwpTQAGrHFss4gYGhHTImJJRPw7//nsiFjr72H53+fUiNgxIm6JiH/kj3k+Ir6VH7NFRIzKLydcFhFvRsQJBc41qOLPJyK+lz/HvyPi0/wyxK7VfN/2EfGbiHgvIr6KiH9GxH0RsV8N1zg0X/vnEfFZRDwSEbtXc43NI+KSiHg1X9OSiHghIk4pMLZX/hpXRsQ++fOW55fcPZX/86k6/j3givyPT1b9Z7VQLWtKKf05pTSvNmMlSVLdcOaUJEmqjalAG+B84DVgUpW+V2tx/Mf5993W8/r/A5wOXBYRt6aUPlnP86yPs/Lv41JKC9c1MKW0bI2mO4BTyQVsvwUScCwwBjgYOK3AadoAzwGfA3cD25KbzTMlIv4TGJtvexgoJTdj6/cR8UFK6cUC5zsOOBK4n9yf4z7kliAeGhEHVQ3bImIX4FmgA/BE/vqdgBOA70XE91NKDxe4xlHkZo39CbgJ2AP4LrB/ROyRUvpXlWu0yZ+7B/AKcAu5/2HaB7grIvZMKf24wDXKgIuAF/K/y8757/F4ROxT5XuMBo4BDiG3TPS9AueSJEkNiOGUJEmqUUppan5GyvnAq+uxVO7P5PZ/OjIiHiS3d9Q0YG5KqcYZLSmlTyLiamAU8GPgv2p53Tb5WV+FfJRSuqkW5zg4//54La8JQH4W0KnATODbKaUl+fYfk9uz6tSIeCSldNcah+5NLoA6J6W0Kn/MX4DbgSfJBVe9Ukpf5vvuAJ4GLiYXfK2pH9CvaqgUEeeTC3HGAIdVGXsTuWDqxymlq6uMH5O/xm0RsXPFd6niGHKzyh6vcszPgRHAGcC1VcaOJhdMXZxSurbK+JbkQs9LI+KelNKaoef3gMEppfFVjjkrX/P5wDkAKaXR+QDsEGB8Smlqgd+JJElqQFzWJ0mS6l1KaT654ORv5MKSO4E5wOLIPb1vQC2edPdrcrNghkXE12p56dbklngVeg2t5Tna59/XWo5YgzPy7yOqhjkppX+TC5IAzixw3BfA8IpgKu8uYAWwDXB+RTCVP98z5H4v+1RTxxMFZjvdQO7PondE7AwQETsB3yG3x1fVMImU0vP83yyu4wpcY2LVYCpvXP79gIqGiNiO3NLH6VWDqfw1viT3ewlyod6anqsaTOXdQu73csDawyVJ0qbCmVOSJGmD5Weq/KhA1+iUUjlASunJiNiN3P5Th5CbPdOT3HKuPuT2sjqqwNI48scvi4hLyQU11wAn1qK0eSmlLsV+n2rUas+iKvYFVpFbSremp8g99a9Hgb45KaXPV7twSisj4h/AFimlvxc4Zj7wzWrqeGrNhvz5niX3JLoewLwqtTyTUlpe4DxPkAuWepCbxVXV9ALjP8i/b1OlbX+gBEjVzGgrzb8X2qtqrWuklJbnfy/bFBgvSZI2EYZTkiSpLrTh/zahrmo8UF7xQ3420DP5FxERwBHk9gY6HDib3LKv6kwELgBOiIgDq9ljqa4tBL4G7ASstRn6OrQGPin0dMGU0oqI+BewQ4HjFldzvhU19FX397p/VNP+UZU6q75Xt69WRXubAn3lazbkvyPkwqgK2/3/7d1fiJRVGMfx7xNFIVIRQVIWSQldRN0oBeVaRiFWFEkXBmJFmJl3RRARRBQGFV4G/V3oz0VF258byQvF8sKCrCA2NGwDbxJqU7qJkqeLc4adXmd2Znd2GqzvB14Oc/a8c87OzsXy4z3Pqe3KenWzuJ85qr8ac0iSpFOM2/okSdLAMnMqM6PDNdXjvszMTyl1pADW9BoPPFpfvjDwwvvzeW1vmnXUyY4B50XEGc0fRMTpwPnA8QHX1o8LuvQvqe2xRrukw1iY2d7YLSDrR+veHV2+L63rxgHmkCRJpxjDKUmS1K8TtR3GUyqtbWzRa2Bm7gU+Aq6LiPVDWEtTq3bS5ojoFvQAEBFntr08QPlfa6zD0DHK5/jVgqxwdqubHbW+V6vQ+4FGe30Nz5pagdEga/6CstVx1QDv0Y9hflclSdICM5ySJEn9mqbUXbpkrjdGxNqIuKvLU0SLmalXtbfPt3yMsp3rubmuZa4ycx/wCmVL2s6IWN4cExGn1dP53mzrfr222yNiUdvYRcys+7XhrPof1kTEbY2+bZR6U7sz8yeAzDwC7AIupVE/LCKuoRQpnwYm5ruQzDxKKYa/IiKe7BSCRcRlEbFsvnNUv9R2zt9VSZL077PmlCRJ6ktm/h4R+4FVEdE6be8E8HFmftvj9iuAHcB0RHwGHKKES0uBWyl1jPZTTpHrZy0HI+JlYGuPoed2KbzdMt5r62H1MOV33QJMRsQe4BvgD+AiynbEpcD7bWt8JyLuoBRu/y4iPqSEe3cCy4B3M/PtPuYe1CfARERMAD8AVwPrgF85+fPbAuwDno+IWyhFyC8G7qY88XRfs1j7PGwDlgNPAxtrYfafgQsphdBXAhuAHweYYzdlvdsj4kpKqEZmPtPrxoh4gJmnyi6v7e31NEOA7zNz6KGoJEn/J4ZTkiRpLjZSQqa1lAAhgCNAr3DqLUp9pZsp4cgYpej1b8DXwHvAq52Kh8/iKcrpcWfPMuYcOhdqb9kDTPWaqJ5e91BEjAObKdvSrqWcLneUEuI8Qls4VW2gnJZ3P/Bg7ZsEXgRe6jXvAvmAsjXxCUoQ+GftezwzD7YPzMzDEbGCUgNsHXAD5e+2E3g2M78cdDGZeTwiVlM+x3uA9cBZlIDqEKXg/a4B55iMiE2U+mRb6/sD9AynKMHUpkbfVfWC8vc0nJIkaQFFqSsqSZKk/5KIuBd4g/K00/hoVyNJktSdNackSZIkSZI0MoZTkiRJkiRJGhnDKUmSJEmSJI2MNackSZIkSZI0Mj45JUmSJEmSpJExnJIkSZIkSdLIGE5JkiRJkiRpZAynJEmSJEmSNDKGU5IkSZIkSRoZwylJkiRJkiSNzN9uWj6itBXIewAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "Here we call the visualize_words() function with the\n",
    "sample_words input list in order to visualize them\n",
    "on the 2d vector space.\n",
    "'''\n",
    "visualize_words(sample_words, get_tsne_results(sample_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Similarity between pair of words using Cosine Similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function calculate_cosine_similarity(word1_vector, word2_vector):\n",
    "\n",
    "Here in this function we calculate the cosine similarity between\n",
    "any two given words using their word embedding vectors.\n",
    "'''\n",
    "\n",
    "def calculate_cosine_similarity(word1_vector, word2_vector):\n",
    "    \n",
    "    '''\n",
    "    The numerator is a dot product between the two vectors\n",
    "    '''\n",
    "    numerator = word1_vector.dot(word2_vector)\n",
    "    \n",
    "    '''\n",
    "    The denominator is the product of norms the two vectors, \n",
    "    which is, square root of the sum of squares.\n",
    "    '''\n",
    "    denominator = np.sqrt(np.sum(np.square(word1_vector))) * np.sqrt(np.sum(np.square(word2_vector)))\n",
    "    \n",
    "    return numerator / denominator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the cosine similarity between different pairs of words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7568217373652817\n",
      "0.39150782850154353\n",
      "0.5449445962780685\n",
      "0.41597764093779904\n",
      "0.05061528045061367\n",
      "0.6456044179249635\n",
      "0.5022534169465177\n",
      "0.08017156167913571\n",
      "0.5818218483965079\n",
      "0.3263724032698907\n"
     ]
    }
   ],
   "source": [
    "# Testing similarity scores between word pair samples\n",
    "\n",
    "############################\n",
    "# Family and relationships #\n",
    "############################\n",
    "\n",
    "    # father - mother\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['father'], word_vectors_300d['mother']))\n",
    "\n",
    "    # father - baby\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['father'], word_vectors_300d['baby']))\n",
    "\n",
    "    # mother - baby\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['mother'], word_vectors_300d['baby']))\n",
    "\n",
    "\n",
    "#########################\n",
    "# Places and activities #\n",
    "#########################\n",
    "    \n",
    "    # office - work\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['office'], word_vectors_300d['work']))\n",
    "\n",
    "    # playground - work\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['playground'], word_vectors_300d['work']))\n",
    "\n",
    "\n",
    "###########################################\n",
    "# Geographical locations (and capitals ?) #\n",
    "###########################################\n",
    "\n",
    "    # germany - berlin\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['germany'], word_vectors_300d['berlin']))\n",
    "\n",
    "    # germany - stuttgart\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['germany'], word_vectors_300d['stuttgart']))\n",
    "\n",
    "    # germany - toronto\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['germany'], word_vectors_300d['toronto']))\n",
    "\n",
    "\n",
    "##########################\n",
    "# Synonyms and Anotonyms #\n",
    "##########################\n",
    "\n",
    "# love - affection\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['love'], word_vectors_300d['affection']))\n",
    "\n",
    "# love - hatred\n",
    "\n",
    "print(calculate_cosine_similarity(word_vectors_300d['love'], word_vectors_300d['hatred']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1. Family and relationships\n",
    "\n",
    "|Word 1|Word 2|Similarity Score|Percentage Similar|\n",
    "|------|------|----------------|------------------|\n",
    "|father|mother|0.756821|75.68 %|\n",
    "|father|baby|0.391507|39.15 %|\n",
    "|mother|baby|0.544944|54.49 %|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2. Places and activities\n",
    "\n",
    "|Word 1|Word 2|Similarity Score|Percentage Similar|\n",
    "|------|------|----------------|------------------|\n",
    "|office|work|0.415977|41.60 %|\n",
    "|playground|work|0.050615|5.06 %|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3. Geographical locations (and capitals ?)\n",
    "\n",
    "|Word 1|Word 2|Similarity Score|Percentage Similar|\n",
    "|------|------|----------------|------------------|\n",
    "|germany|berlin|0.645604|64.56 %|\n",
    "|germany|stuttgart|0.502253|50.23 %|\n",
    "|germany|toronto|0.080171|8.02 %|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4. Synonyms and Antonyms\n",
    "\n",
    "|Word 1|Word 2|Similarity Score|Percentage Similar|\n",
    "|------|------|----------------|------------------|\n",
    "|love|affection|0.581821|58.18 %|\n",
    "|love|hatred|0.326372|32.64 %|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Synonyms and Antonyms using WordNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function get_synonyms(word):\n",
    "\n",
    "In this function, we try to find a list of synonyms \n",
    "for a given input word using the NLTK WordNet corpus.\n",
    "'''\n",
    "def get_synonyms(word):\n",
    "    \n",
    "    synonyms = []\n",
    "    \n",
    "    '''\n",
    "    We find all possible synonyms for the word using all\n",
    "    the synsets that word has.\n",
    "    '''\n",
    "    for synset in wn.synsets(word):\n",
    "        \n",
    "        '''\n",
    "        We check all the 'lemmas' for each synset of the\n",
    "        word.\n",
    "        '''\n",
    "        for lemma in synset.lemmas():\n",
    "            \n",
    "            synonyms.append(lemma.name())\n",
    "    \n",
    "    '''\n",
    "    We return a list of set of the synonyms. This is done in \n",
    "    order to make sure that we get a unique list of synonyms.\n",
    "    '''\n",
    "    return list(set(synonyms))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function get_antonyms(word):\n",
    "\n",
    "In this function, we try to find a list of antonyms \n",
    "for a given input word using the NLTK WordNet corpus.\n",
    "'''\n",
    "def get_antonyms(word):\n",
    "    \n",
    "    antonyms = []\n",
    "    \n",
    "    '''\n",
    "    We find all possible antonyms for the word using all\n",
    "    the synsets that word has.\n",
    "    '''\n",
    "    for synset in wn.synsets(word):\n",
    "        \n",
    "        '''\n",
    "        We check all the 'lemmas' for each synset of the\n",
    "        word.\n",
    "        '''\n",
    "        for lemma in synset.lemmas():\n",
    "           \n",
    "            if lemma.antonyms():\n",
    "                antonyms.append(lemma.antonyms()[0].name())\n",
    "                \n",
    "    '''\n",
    "    We return a list of set of the synonyms. This is done in \n",
    "    order to make sure that we get a unique list of antonyms.\n",
    "    '''\n",
    "    return list(set(antonyms))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1. Testing synonyms and antonyms for different parts of speech"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Word: earthquake\n",
      "Synonyms: ['earthquake', 'temblor', 'seism', 'quake']\n",
      "Antonyms: []\n",
      "\n",
      "Word: talented\n",
      "Synonyms: ['talented', 'gifted']\n",
      "Antonyms: ['untalented']\n",
      "\n",
      "Word: walk\n",
      "Synonyms: ['walkway', 'pass', 'take_the_air', 'base_on_balls', 'walk', 'paseo', 'walk_of_life', 'walking', 'manner_of_walking']\n",
      "Antonyms: ['ride']\n",
      "\n",
      "Word: below\n",
      "Synonyms: ['downstairs', 'down_the_stairs', 'to_a_lower_place', 'beneath', 'at_a_lower_place', 'below', 'under', 'infra', 'on_a_lower_floor']\n",
      "Antonyms: ['above', 'upstairs']\n",
      "\n",
      "Word: quickly\n",
      "Synonyms: ['speedily', 'apace', 'rapidly', 'quickly', 'cursorily', 'chop-chop', 'promptly', 'quick']\n",
      "Antonyms: ['slowly']\n"
     ]
    }
   ],
   "source": [
    "#########\n",
    "# Nouns #\n",
    "#########\n",
    "\n",
    "noun = 'earthquake'\n",
    "\n",
    "print('Word: %s' % noun)\n",
    "print('Synonyms: %s' % get_synonyms(noun))\n",
    "print('Antonyms: %s' % get_antonyms(noun))\n",
    "\n",
    "##############\n",
    "# Adjectives #\n",
    "##############\n",
    "\n",
    "adjective = 'talented'\n",
    "\n",
    "print('\\nWord: %s' % adjective)\n",
    "print('Synonyms: %s' % get_synonyms(adjective))\n",
    "print('Antonyms: %s' % get_antonyms(adjective))\n",
    "\n",
    "#########\n",
    "# Verbs #\n",
    "#########\n",
    "\n",
    "verb = 'walk'\n",
    "\n",
    "print('\\nWord: %s' % verb)\n",
    "print('Synonyms: %s' % get_synonyms(verb))\n",
    "print('Antonyms: %s' % get_antonyms(verb))\n",
    "\n",
    "################\n",
    "# Prepositions #\n",
    "################\n",
    "\n",
    "preposition = 'below'\n",
    "\n",
    "print('\\nWord: %s' % preposition)\n",
    "print('Synonyms: %s' % get_synonyms(preposition))\n",
    "print('Antonyms: %s' % get_antonyms(preposition))\n",
    "\n",
    "###########\n",
    "# Adverbs #\n",
    "###########\n",
    "\n",
    "adverb = 'quickly'\n",
    "\n",
    "print('\\nWord: %s' % adverb)\n",
    "print('Synonyms: %s' % get_synonyms(adverb))\n",
    "print('Antonyms: %s' % get_antonyms(adverb))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Get related words using relationship between embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "function get_related_word(word1, word2, word3, word_vectors=word_vectors_300d):\n",
    "\n",
    "------------------------------------------------------------------------------------\n",
    "word1, word2 =  These are the given input word pair which are taken as reference\n",
    "                to find the new word for another input word.\n",
    "\n",
    "word3        =  The new input word for which we need to find a related word.\n",
    "\n",
    "word_vectors =  This is the dictionary of word vectors. By default, we are using\n",
    "                the 300 dimensional word vector dictionary that we calculated before.\n",
    "-------------------------------------------------------------------------------------\n",
    "\n",
    "This function is used to find a similar word for a given new input word using the\n",
    "similarity relationship between a pair of words.\n",
    "'''\n",
    "\n",
    "def get_related_word(word1, word2, word3, word_vectors=word_vectors_300d):\n",
    "    \n",
    "    '''\n",
    "    This parameter is used for comparison purpose. We use this to find\n",
    "    and store the maximum similarity value between word embedding vectors.\n",
    "    '''\n",
    "    max_similarity = -1000\n",
    "    \n",
    "    '''\n",
    "    We make sure that all the words that we are dealing with are in the lowercase\n",
    "    because the word embedding dictionary contains all lowercase forms of the words.\n",
    "    '''\n",
    "    word1, word2, word3 = word1.lower(), word2.lower(), word3.lower()\n",
    "    \n",
    "    '''\n",
    "    We calculate the word vector value from the existing word vectors here.\n",
    "    '''\n",
    "    new_word_vector = word_vectors[word3] - (word_vectors[word1] - word_vectors[word2])\n",
    "    \n",
    "    '''\n",
    "    We have the new word vector. Now we try to find the nearest possible similar word \n",
    "    corresponding to that vector from our vocabulary of words.\n",
    "    '''\n",
    "    for word in vocabulary_300d:\n",
    "        \n",
    "        vector = word_vectors[word]\n",
    "        \n",
    "        '''\n",
    "        TO find simlilarity, we use our calculate_cosine_similarity() function.\n",
    "        '''\n",
    "        similarity = calculate_cosine_similarity(word1_vector=new_word_vector, word2_vector=vector)\n",
    "        \n",
    "        '''\n",
    "        Here we check if the similarity of the words is greater than the \n",
    "        maximum similarity value that we already have in the iteration process.'''\n",
    "        if similarity > max_similarity:\n",
    "            max_similarity = similarity\n",
    "            word4 = word\n",
    "    \n",
    "    return word4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the analogy relationships between different words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 521,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"king\" is related to \"queen\", as \"man\" is related to -> \"woman\"\n",
      "\"brother\" is related to \"sister\", as \"prince\" is related to -> \"princess\"\n"
     ]
    }
   ],
   "source": [
    "######################################\n",
    "# Gender-based analogy relationships #\n",
    "######################################\n",
    "\n",
    "# king -> queen ... man -> ?\n",
    "\n",
    "print('\"king\" is related to \"queen\", as \"man\" is related to -> \"%s\"' \n",
    "      % get_related_word('king', 'queen', 'man'))\n",
    "\n",
    "# brother -> sister ... prince -> ?\n",
    "\n",
    "print('\"brother\" is related to \"sister\", as \"prince\" is related to -> \"%s\"' \n",
    "      % get_related_word('brother', 'sister', 'prince'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 512,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "'''\n",
    "Here we try to visualize the words 'king', 'queen', 'woman' and 'man'\n",
    "in a 2d vector-space in order to understand their relationship \n",
    "similarity visually.\n",
    "'''\n",
    "\n",
    "sample_words = ['king', 'queen', 'woman', 'man']\n",
    "visualize_words(sample_words, get_tsne_results(sample_words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"father\" is related to \"mother\", as \"son\" is related to -> \"daughter\"\n",
      "\"grandfather\" is related to \"grandmother\", as \"father\" is related to -> \"mother\"\n"
     ]
    }
   ],
   "source": [
    "################################\n",
    "# Family analogy relationships #\n",
    "################################\n",
    "\n",
    "# father -> mother ... son -> ?\n",
    "\n",
    "print('\"father\" is related to \"mother\", as \"son\" is related to -> \"%s\"' \n",
    "      % get_related_word('father', 'mother', 'son'))\n",
    "\n",
    "# grandfather -> grandmother ... father -> ?\n",
    "\n",
    "print('\"grandfather\" is related to \"grandmother\", as \"father\" is related to -> \"%s\"' \n",
    "      % get_related_word('grandfather', 'grandmother', 'father'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 722,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"germany\" is related to \"berlin\", as \"japan\" is related to -> \"tokyo\"\n",
      "\"germany\" is related to \"berlin\", as \"france\" is related to -> \"paris\"\n",
      "\"germany\" is related to \"berlin\", as \"russia\" is related to -> \"moscow\"\n",
      "\n",
      "\"berlin\" is related to \"germany\", as \"delhi\" is related to -> \"india\"\n"
     ]
    }
   ],
   "source": [
    "#########################################\n",
    "# Country-capital analogy relationships #\n",
    "#########################################\n",
    "\n",
    "# germany -> berlin ... japan -> ?\n",
    "\n",
    "print('\"germany\" is related to \"berlin\", as \"japan\" is related to -> \"%s\"' \n",
    "      % get_related_word('germany', 'berlin', 'japan'))\n",
    "\n",
    "# germany -> berlin ... france -> ?\n",
    "\n",
    "print('\"germany\" is related to \"berlin\", as \"france\" is related to -> \"%s\"' \n",
    "      % get_related_word('germany', 'berlin', 'france'))\n",
    "\n",
    "# germany -> berlin ... russia -> ?\n",
    "\n",
    "print('\"germany\" is related to \"berlin\", as \"russia\" is related to -> \"%s\"' \n",
    "      % get_related_word('germany', 'berlin', 'russia'))\n",
    "\n",
    "#########################################\n",
    "# Capital-country analogy relationships #\n",
    "#########################################\n",
    "\n",
    "# berlin -> germany ... delhi -> ?\n",
    "\n",
    "print('\\n\"berlin\" is related to \"germany\", as \"delhi\" is related to -> \"%s\"' \n",
    "      % get_related_word('berlin', 'germany', 'delhi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"germany\" is related to \"berlin\", as \"australia\" is related to -> \"sydney\"\n",
      "\"germany\" is related to \"berlin\", as \"canada\" is related to -> \"canada\"\n"
     ]
    }
   ],
   "source": [
    "###########################################################\n",
    "# Country-capital analogy relationships (not so accurate) #\n",
    "###########################################################\n",
    "\n",
    "# germany -> berlin ... australia -> ?\n",
    "\n",
    "print('\"germany\" is related to \"berlin\", as \"australia\" is related to -> \"%s\"' \n",
    "      % get_related_word('germany', 'berlin', 'australia'))\n",
    "\n",
    "# germany -> berlin ... canada -> ?\n",
    "\n",
    "print('\"germany\" is related to \"berlin\", as \"canada\" is related to -> \"%s\"' \n",
    "      % get_related_word('germany', 'berlin', 'canada'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Synonym analogy relationships"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 724,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"intelligent\" is related to \"clever\", as \"stupid\" is related to -> \"stupid\"\n",
      "\"hot\" is related to \"warm\", as \"cold\" is related to -> \"cold\"\n",
      "\n",
      "\"better\" is related to \"best\", as \"worse\" is related to -> \"worst\"\n",
      "\n",
      "\"cow\" is related to \"cows\", as \"horse\" is related to -> \"horses\"\n"
     ]
    }
   ],
   "source": [
    "############################\n",
    "# Not so accurate antonyms #\n",
    "############################\n",
    "\n",
    "# intelligent -> clever ... stupid -> ?\n",
    "\n",
    "print('\"intelligent\" is related to \"clever\", as \"stupid\" is related to -> \"%s\"' \n",
    "      % get_related_word('intelligent', 'clever', 'stupid'))\n",
    "\n",
    "# hot -> warm ... cold -> ?\n",
    "\n",
    "print('\"hot\" is related to \"warm\", as \"cold\" is related to -> \"%s\"' \n",
    "      % get_related_word('hot', 'warm', 'cold'))\n",
    "\n",
    "######################################\n",
    "# Comparative-Superlative adjectives #\n",
    "######################################\n",
    "\n",
    "# better -> best ... worse -> ?\n",
    "\n",
    "print('\\n\"better\" is related to \"best\", as \"worse\" is related to -> \"%s\"' \n",
    "      % get_related_word('better', 'best', 'worse'))\n",
    "\n",
    "#########################\n",
    "# Singular-plural forms #\n",
    "#########################\n",
    "\n",
    "# cow -> cows ... horse -> ?\n",
    "\n",
    "print('\\n\"cow\" is related to \"cows\", as \"horse\" is related to -> \"%s\"' \n",
    "      % get_related_word('cow', 'cows', 'horse'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Antonym analogy relationships"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 726,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"live\" is related to \"die\", as \"stay\" is related to -> \"die\"\n",
      "\"feed\" is related to \"starve\", as \"live\" is related to -> \"starve\"\n",
      "\"good\" is related to \"bad\", as \"kind\" is related to -> \"bad\"\n",
      "\n",
      "\"better\" is related to \"worse\", as \"best\" is related to -> \"worst\"\n"
     ]
    }
   ],
   "source": [
    "#######################\n",
    "# Synonyms (arguable) #\n",
    "#######################\n",
    "\n",
    "# live -> die ... stay -> ?\n",
    "\n",
    "print('\"live\" is related to \"die\", as \"stay\" is related to -> \"%s\"' \n",
    "      % get_related_word('live', 'die', 'stay'))\n",
    "\n",
    "# feed -> starve ... live -> ?\n",
    "\n",
    "print('\"feed\" is related to \"starve\", as \"live\" is related to -> \"%s\"' \n",
    "      % get_related_word('feed', 'starve', 'live'))\n",
    "\n",
    "# good -> bad ... kind -> ?\n",
    "\n",
    "print('\"good\" is related to \"bad\", as \"kind\" is related to -> \"%s\"' \n",
    "      % get_related_word('good', 'bad', 'kind'))\n",
    "\n",
    "######################################\n",
    "# Comparative-Superlative adjectives #\n",
    "######################################\n",
    "\n",
    "# better -> worse ... best -> ?\n",
    "\n",
    "print('\\n\"better\" is related to \"worse\", as \"best\" is related to -> \"%s\"' \n",
    "      % get_related_word('better', 'worse', 'best'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}