NLP_translation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import unicode_literals, print_function, division\n",
    "from io import open\n",
    "import unicodedata\n",
    "import string\n",
    "import re\n",
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Preparing data\n",
    "    - Read text file and split into lines, split lines into pairs\n",
    "    - Normalize text, filter by length and content\n",
    "    - Make word lists from sentences in pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SOS_token = 0\n",
    "EOS_token = 1\n",
    "\n",
    "\n",
    "class Lang:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.word2index = {}\n",
    "        self.word2count = {}\n",
    "        self.index2word = {0: \"SOS\", 1: \"EOS\"}\n",
    "        self.n_words = 2  # Count SOS and EOS\n",
    "\n",
    "    def addSentence(self, sentence):\n",
    "        for word in sentence.split(' '):\n",
    "            self.addWord(word)\n",
    "\n",
    "    def addWord(self, word):\n",
    "        if word not in self.word2index:\n",
    "            self.word2index[word] = self.n_words\n",
    "            self.word2count[word] = 1\n",
    "            self.index2word[self.n_words] = word\n",
    "            self.n_words += 1\n",
    "        else:\n",
    "            self.word2count[word] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unicodeToAscii(s):\n",
    "    return ''.join(\n",
    "        c for c in unicodedata.normalize('NFD', s)\n",
    "        if unicodedata.category(c) != 'Mn'\n",
    "    )\n",
    "\n",
    "def normalizeString(s):\n",
    "    s = unicodeToAscii(s.lower().strip())\n",
    "    s = re.sub(r\"([.!?])\", r\" \\1\", s)\n",
    "    s = re.sub(r\"[^a-zA-Z.!?]+\", r\" \", s)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readLangs(lang1, lang2, reverse=False):\n",
    "    print(\"Reading lines...\")\n",
    "    \n",
    "    lines = open('data/%s-%s.txt'%(lang1, lang2), encoding='utf-8').read().strip().split('\\n')\n",
    "    \n",
    "    pairs = [[normalizeString(s) for s in l.split('\\t')] for l in lines]\n",
    "    \n",
    "    if reverse:\n",
    "        pairs = [list(reversed(p)) for p in pairs]\n",
    "        input_lang = Lang(lang2)\n",
    "        output_lang = Lang(lang1)\n",
    "    else:\n",
    "        input_lang = Lang(lang1)\n",
    "        output_lang = Lang(lang2)\n",
    "        \n",
    "    return input_lang, output_lang, pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_LENGTH = 10\n",
    "\n",
    "eng_prefixes = (\n",
    "    \"i am \", \"i m \",\n",
    "    \"he is\", \"he s \",\n",
    "    \"she is\", \"she s \",\n",
    "    \"you are\", \"you re \",\n",
    "    \"we are\", \"we re \",\n",
    "    \"they are\", \"they re \"\n",
    ")\n",
    "\n",
    "\n",
    "def filterPair(p):\n",
    "    return len(p[0].split(' ')) < MAX_LENGTH and \\\n",
    "        len(p[1].split(' ')) < MAX_LENGTH and \\\n",
    "        p[1].startswith(eng_prefixes)\n",
    "\n",
    "\n",
    "def filterPairs(pairs):\n",
    "    return [pair for pair in pairs if filterPair(pair)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading lines...\n",
      "Read 135842 sentence pairs\n",
      "Trimmed to 10599 sentence pairs\n",
      "Counting words...\n",
      "Counted words:\n",
      "fra 4345\n",
      "eng 2803\n"
     ]
    }
   ],
   "source": [
    "def prepareData(lang1, lang2, reverse=False):\n",
    "    input_lang, output_lang, pairs = readLangs(lang1, lang2, reverse)\n",
    "    print(\"Read %s sentence pairs\" % len(pairs))\n",
    "    pairs = filterPairs(pairs)\n",
    "    print(\"Trimmed to %s sentence pairs\" % len(pairs))\n",
    "    print(\"Counting words...\")\n",
    "    for pair in pairs:\n",
    "        input_lang.addSentence(pair[0])\n",
    "        output_lang.addSentence(pair[1])\n",
    "    print(\"Counted words:\")\n",
    "    print(input_lang.name, input_lang.n_words)\n",
    "    print(output_lang.name, output_lang.n_words)\n",
    "    return input_lang, output_lang, pairs\n",
    "\n",
    "\n",
    "input_lang, output_lang, pairs = prepareData('eng', 'fra', True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['je suis encore endormie .', 'i m still sleepy .']\n"
     ]
    }
   ],
   "source": [
    "print(random.choice(pairs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seq2Seq network\n",
    "\n",
    "- 2개의 RNN으로 이루어져 있는 network, 하나는 encoder, 다른 하나는 decoder 역할로 사용\n",
    "    - Encoder: input sequence를 읽어서 output vector 반환\n",
    "    - Decoder: encoder의 output vector를 읽어서 output sequence 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EncoderRNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super(EncoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        self.embedding = nn.Embedding(input_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "        \n",
    "    def forward(self, _input, hidden):\n",
    "        embedded = self.embedding(_input).view(1, 1, -1)\n",
    "        output = embedded\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        return output, hidden\n",
    "    \n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size):\n",
    "        super(DecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "\n",
    "        self.embedding = nn.Embedding(output_size, hidden_size)\n",
    "        self.gru = nn.GRU(hidden_size, hidden_size)\n",
    "        self.out = nn.Linear(hidden_size, output_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "\n",
    "    def forward(self, _input, hidden):\n",
    "        output = self.embedding(_input).view(1, 1, -1)\n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        output = self.softmax(self.out(output[0]))\n",
    "        return output, hidden\n",
    "\n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttnDecoderRNN(nn.Module):\n",
    "    def __init__(self, hidden_size, output_size, dropout_p=0.1, max_length=MAX_LENGTH):\n",
    "        super(AttnDecoderRNN, self).__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "        self.dropout_p = dropout_p\n",
    "        self.max_length = max_length\n",
    "        \n",
    "        self.embedding = nn.Embedding(self.output_size, self.hidden_size)\n",
    "        self.attn = nn.Linear(self.hidden_size * 2, self.max_length)\n",
    "        self.attn_combine = nn.Linear(self.hidden_size * 2, self.hidden_size)\n",
    "        self.dropout = nn.Dropout(self.dropout_p)\n",
    "        self.gru = nn.GRU(self.hidden_size, self.hidden_size)\n",
    "        self.out = nn.Linear(self.hidden_size, self.output_size)\n",
    "        \n",
    "    def forward(self, _input, hidden, encoder_outputs):\n",
    "        embedded = self.dropout(self.embedding(_input).view(1, 1, -1))\n",
    "        \n",
    "        attn_weights = F.softmax(self.attn(torch.cat((embedded[0], hidden[0]), 1)), dim=1)\n",
    "        attn_applied = torch.bmm(attn_weights.unsqueeze(0), encoder_outputs.unsqueeze(0))\n",
    "        \n",
    "        output = torch.cat((embedded[0], attn_applied[0]), 1)\n",
    "        output = self.attn_combine(output).unsqueeze(0)\n",
    "        \n",
    "        output = F.relu(output)\n",
    "        output, hidden = self.gru(output, hidden)\n",
    "        \n",
    "        output = F.log_softmax(self.out(output[0]), dim=1)\n",
    "        return output, hidden, attn_weights\n",
    "    \n",
    "    def initHidden(self):\n",
    "        return torch.zeros(1, 1, self.hidden_size, device=device)\n",
    "        "
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAJ1CAYAAAAokNx/AAAgAElEQVR4AeydB5gURfrGC8yYI+op6pkD5qxnPMw5i3oKnmf2zIg5I8opgun09Dz1PP93nukM55lIS4YlLrDAwsKS48ICG/n+z9tFz/TM9tRM7850mH57n9mZ7q+6q+qt6u/XFbpbiUg9P9SAdYB1gHWAdcBUB5RwoQJUgApQASqQRQHCIotANFMBKkAFqIAIYcFaQAWoABWgAlkVICyySsQAVIAKUAEq4A6LtU1UJowKNDWGMVVMUz4V4LmXTzV5rDwq4A4LRDCgu8gnp/ATFg3K/y3SWJfHog/wUP86g/XKrV4NfDjAQhGRxWUsF7dyidM2nJsZlsyw+Ow8kV6Kn7BoMOrV4oHFKxuzXrnVq8/Oz3Ca+rR57lCWi1u5xGkbzs0MC2ERlYpAWBS/IyMsir+Mw+5vCIsiaCERFsXvSAiL4i9jwqIInHHYC5GwKH5HQlgUfxmH3c+wZVEEMCMsit+REBbFX8aERbic8dh7lbx4buY0jbtPSU+Dff4TSp48Q8nK59yPkc1ekIkBhEVGR/KPa5T8p6t7WRWkLHopqX62APERFhnLOJdy7HuRkmF3FaBc8uzg81138nq8uLUsPrhKybbtMleav3dWsv2mme1j7lWilJJ5j7uHyWbPpWJ7DkNYZHQkFx+k5Nbj3MvKs845OIbbj1fyzJkFiI+wyFjGuZTjPtspefXCApRLDnUil/QhTL7rzjc3KjlutzzmmbDwJmY2GGSz51pxPIUjLFrlSDxpncU5HLkLYZFPPfN1rCjAIt91Bz0kB+/kzb8Z9S4kLOp7Kvn90UrQtQNqnre/klcuSHbh1L6g7cPvUnJJRyUPnKKk6UWdub9dpeTyg5Wcf4CSl89X0tBTb0dz8u3LUgWYeL+SPxyrZE2P1O1uGbdbFiPvVvK7I5JpWvuS3nfonUr+eGLyOHUvKEGcFxyg5JbjlHzdNbVlkc2ONJTeo/PZaW997DmPJY+PY//3JiXvXqHkwgOVXHmIkh/+kLS75aHZNsIiIyxeu1jJh1drPYfcqeTZs5SM+KOSrkcpOXs/Jb3OU9K4rs7B/vSZSn66WZfDdUco+eKGZFms7qHLcdpDyW2zH9Xblj2jj7VdOyU46Z8/OxmmWXllAY5r+Ii1LND98cjpSs7cR8m1hyv58eakHtnKwc4/zlXsi3L49HdJHwB7yR36/P3t3kruOlHJrEeTx4f9+5t0GV92sD6/0mFhSt+g25X0OEfJ/12r/Q++7TSZvtEFff/JSnCeI904r+3wXutONt+J48KXpqft0d9qrfvdquToXZVss4mun0uf1ml5/0rtZ1D3HzpVyZJ12+10Gr8LCQs4b3TZtN9MFxyc/J7bajDAOaPfH/a9tlVy9aFKbjpGZwiFj5Pu4dN0oe24uc4gMvLO5bobCWLaGYNzP3XP5Lq93e0bFXD9tkr23k7JS+dpQG2yvo4H4T/qrAW29wXskP4XztF52HLjVFhks8PxbLy+kqsO1ZA7toNOvw0MAHS3rZX8Zg8lfS5Sgsrdto2SCffnlh8rnYRFoi7Y5WZ/A/I3H6u1RNmjXu23vZInOil56gwlG66nvxEe9i02UvKrLZT86XxdN9ptoOTja/T+y5/RZQ9HZR/fbkmiPHEhgbIE9J2QscO26jtCsKh5Tp/Th/9KyRuXKLnhSCUbraf1tXU2lQPCPN5JyVYb6zJA99FOmyvpva4b6asu+hyBzm9eouSIXZTgvJzeXZfLd7/X8XU5Sp+3O2+h1+1uqGzpe+8KJTtspvMAUMHBZis7OGPEc0B7fXHZ+TAlG7TV+ce+XutONt+JYwJKd/8mNW2AInQqe0D72V221H4HecYF+Nab6Isa5AkwOWzn1P2N+fQDFtcfmUzQqLv1CffLLUlYgHB2Iqd00xXBPkGxfepDeh/QcsWzSnACo8LAhhYHChYnun0M0zfCAVBIhx3uikP0FRDWnbDAYHgbpQQtFzssnIg9ZpHNjn1QGOg3t/e3t6Glhd+ABSqY3aLCN8ZU7Irt3C/jb8IiRV+nTumwQNmhpWuHQYv0xN31ul030Ndr21E34diwnu2ER5h8dyXY6ZAIwQKtqk031HrZ6cc2XHThItHWOVM5zH1cn2P9b02Ww7+uUwIHjP1331pfudvHxje24YITv/fdPnkBgPWK7voC0T6nsqUPsEj3Ec643H6jV2TzjZSgp8G2YxsuPtCq8Fp3bFhk8p2IwwQL2NO7oVDXsY/diwK4otcGPTx2mo3ffsDiE0czDgnFADKcrt2y+NzR1McAMxz0PScp6XZq8rPZhpqIyAy6j9Bdg9+4mkOBrHo+twyjouJK33bOOAZaDQftqPd3wgIkRqvGKSDAYcMimx2FgFbCOfsl84E8waEc00EfF7BAfpxxoJ/xOS/dGIRFin5OLdNhgVak045uqUPXXV2hbuAK2FmXfr5Flze6Obye8M54Wv07QrC46EDdg+A8f9Etg/MGOkJnUzkA1igH26k5tcMVPI7jvJiE/Y4TdG8BrqBxzg28PbWccUFmwyJb+gALxO/0Ec40uP0+fa/mF4UDbtNpRTe017pjwyKT70QavMICdRn5+vU2Wi90k9nd+255arbND1igj9IZMbqA0AVgwwKi2vbXL9bNN1zRdT8t9YPmJcKhVYLKhlYGoIGuIHv/bN+oqOmzoTCV1g0WqFxotTgrLVo+Niyy2Rc+qcOi5ZKeF3v6LmCRPlsHrRHCIvcyNZV5OizSyx5XmYesGwRE3UCz3Xk8u5sJzXr7hEefth0G4x+oD3a3IlsWSk7+tZKOOzav8zgHqh7TsDCVA5w1uqBsjZ3faCVAb2erA3bMQIMTxCxF2OEjnPuhjG1YZEsf4kcryLl/tt8odwDLGc72FRgf9Vp3bFhk8p2IB7Bwjq9iG1pYdnddessC9kkP6u59XCBBJ3QVYrzNme6Mv/2AhdPxVT6iE4m5726wwMAUMuHsF8YAJAaA7T5JOG9UjD9fpqHhDJsxo+sGFb3AAlcnSMvoe5Jiog8W21Aps9mRFrR60vsVkUdQHnbCIu3JZKiQLRkAzrCPV1igbMu7JcsbA+DoUsFVJroTYHcOXKJ7BNsIi6RmNx6tZNctU6/MMSkALXF007idg05oAwTQdMETyWPiHMRkF1wgYpwJ4HHWE3QlYpIMtqE3wGnHRRt6K2xYZEtfS2CBMUmMvTrThPgwPooeBq91x4ZFJt+JeOA7kBc7TrQSEJ8NC1yQOmdDod46fSU0RXhn68U+luu3H7BAHyJuiMFsAXS5QFTMRnCDBQauER7NOgzyQjSM8KPfeNFTSWEwawVXJxjQcc1YBufhVlEztSwQ94HtlaDZilkvGKOwiQxYZLMjXWiKI51fdtGzbnAioBvsn9fpdBMW4YMFukzgqDAzbv8d9Ew+u46h5YFZenBauHjBFasTFpj9g7519Lvb++TlO0LdUJjdCOeMQWp0G0ELdLtCN2jhdg46YQGnh24jjPVBYzj7c/fXE0ywP67gASN0V8EJY+IMnB5uwIQdvRKYaIDWBeJHyx1lZMMiW/paAguMpyIO+BLUDZznyIMNMKTLS92xYZHJd+J4956kW0AY04U/xcQg6I5ZUrD/5XLd5Y8WDjRFSwMX2bgYwgX3tzfqNKN1jPBZP37AAicfuo3QX4aZC0g8EuYGC2yf/KC+mQQZx1Udbiyxu6DsDKGFgr5JTHGzt+Xy7VZRM8ECx5vxsJ41gLTjgxlaqBT2TXnZ7KjMGMzGzAhogGbiY79NppmwCBcsMKsGTg1ljfLCbBhnvy5axJiOuF4bPbME03KdsMDsHFz5pndn5VI3jWEiBAvkA2MK6MKFjmhdw2niYhE2t3PQCQuEQXcJunagM8oEV+7owoINfgNTn2HD8aE1dIcNH7QC0TWNiTCwo0WC7hYbFghjSl9LYIFjovcDs40QJ/wWLhrg9O10eak7Niwy+U4cE61ZzGhC/cMFKKCIrim7ZQEooJUFO7qzcEzoiItXpA8D8k5N7HRm/PYDFuhyQfMTVwgZE+JCNvTzLXa0Jrzsm++wSLuz4NOPn82OFhNaJ+n75WWdA9x50dXpxFDvAHq38oEzwkBtpgFQ1HXnILnbMTxvixgs7PzBwTtnCNnbc/1GOQAObuHRvWM6p3C+Onsj3I7R2vSlHxNX7Kgbzqn9zjC51h0bFrn4TkDYVN/SxyTsNDjHYp1pzPjbL1hkTIALJFoaFmMbuArM9Ml0crc0vtDsR1i4OhOv5eOEhdd9Cx4+orAouC559B+Z0gq/kcmn2Nsz7dvS7U5YtPQYed+vkLAA+TFN1jl7JO8ZcFQW9B8jvkwfzDMuZPyBHZuwyEu5YhwJN+wFVo6OutwsDYRFYOWCbuNMPgXb06fXNys7U7lmsPntO3NKcyFhkVMCMojFfT04LcIiMEfiWz0lLIq/jMPuCwkLD045rIVJWBS/IyEsir+Mw+pf7HQRFoRF2nykYFdRIe3Kye+kFoRFUgvWi2C0ICwIi2DpkBY7YeHuCAgLd10IDv90ISwIizR3HewqYeF+8hMW7roQFv7p0iJYfH6BSK+2/IRFg1F9RBrrgnXy+Yq9dzvWK7d6hXMuyGXuUJaLW7nEaRvOzQyLct2+dq3r5jBvXLNmjafkrV692lP4UARuaghFMoopEU1NTeHKTgTPvXAJyNQUSgF3WBQqtgIdd+3atVJSUiJVVVU5xbBw4UIZMGCA1NfX5xSegYpTgcWLF0u/fv0E9YcLFVi+fLmMGjWK9SFDVSgKWCxatEj69+8vdXW5ddPAOQwePFgqKioyyMLNcVCAsIhDKeeeR9YHs1ZFAYvx48cLPl6WyspKqzUSum4IL5lg2FYpQOfQKvmKbmfWB3ORRh4WaE2gVYHWhZeloaFBBg4cmHPXlZdjM2w0FKBziEY5+ZVK1gez0pGHhd1CaEm/87Rp02To0KFmhWgtWgXoHIq2aFuUMdYHs2yRh8Xw4cMFTr8lS21trdUqWbBgQUt25z4RV4DOIeIFmOfksz6YBY00LDB7AbNZampqzLk0WMvKymTkyJGGEDQVqwJ0DsVasi3LF+uDWbdIw2Ly5MnWVDdzFs3WlStXWsBZtmyZOSCtRaPAkiVLZNKkSTJ27FgZNGiQ4IIBdcnrvTpFIwgzYilAWJgrQmRhgVlMGKCeM2eOOYc5WOE0xo0bl0NIBikGBWbOnGldIGBiBD5oneJTXV1dDNljHlqoAGFhFi6ysMA4A26sw6ym1i5Lly61nEVrurNamwbu758CuHvfBoT9jftuuMRbAcLCXP6RhUVL7q0wSYFxC3RNcImHAiNGjEgAAxcd06dPj0fGmcuMChAWGaWxDJGEBVoTOMHzOYsJx0KXBGZIcSl+BWbPnp3SBcVWZfGXebYcEhZmhSIJi3nz5lmwaGxsNOfOgxX3aQwZMqTF03A9RMWgIVAAFwV2F9SwYcNCkCImIWgFCAtzCUQSFhiQnjhxojlnLbDiahOD5vmEUAuSwV18UqC0tNQCBm7s5EIFCAtzHYgcLPCk2JY83sMsg7YCEphKOWvWrFyCM8w6BeobReoi+JlVNdeCRXXNmkimvyFkT1eP+glBWJhLMHKwwFRZXP0X6gGAeBItuqNa8vgQs9TFa52/UuSZAdH7PDtgrfQdsDySaX+xpHjrU1A5IyzMykcOFug6KOSsJTyYEIPnGBfhkpsCZQtFOvTmx08NDngjt7JhqNwVICzMWkUKFvaznHAHbiEX3M2LqZVcclOAsPAflIRFbnXTSyjCwqxWpGCBN+FhTKHQXUSrVq2yxkVQebhkV4CwICyy15LwhyAszGUUKViMGTOmoF1QTqlw0x/i45JdAcKCsMheS8IfgrAwl1FkYIEb8TALCu/P9mOxn2i7YsUKP6KLdByEBWER6Qq8LvGEhbkUIwOL+fPnWwPPhZoF5SbT6NGjC3I/h1tcUd4WNCzu/E7k+i/y67Cv+lTkvv9lPqbTvvurIi8PETnhvczh8z34zTGL/J8xhIVZ08jAYsKECZ7fs23OenYrWjFozfDR1WatgobFjxUi74/Jr6PuM0xkeFXmYzrte/YRwT0PAEi+oZDpeISFuU62xEpYmFWLBCwwoI17K+bOnWvOTQGseBREeXl5AY5cPIeMOywyOfRCbics8n/+EBZmTSMBC/sR4kE85M++CRB3jnNxV6AlsLj7vyJfl4v8MF3kqf4ie7yqr8p/3Ufk4/EiJ70v8uZIkZ9niLxUIoKunhu+0Pu8WypyxkfJq3i0LD4YK/JkP5FfZoj8fZzIKe8n7XDaZ32kjztgpsi7o0WOfCfVfuJ7In2HifxUIfL8QJHXh6e2LEx2pB1pPvVv+piP/SJy7Wci9/9P5PtpIl9NEen879T4rvlM7/PfaSK3fiPy8E8iXb9MDWOCDWHhXhdbs5WwMKsXCVhMnTo1sFefYoykpKRE8MIcLu4KeIUFnP2S1do59xgksqBGO1U4x7376jgql2uHjbGAlXUiAytFxi3QQIBDh912poDFmgaR8QtEuv8kMmS23uc3f9Vh0D0E+5eTRbr9IDJqrsjS1UlgdHxTHw/b4bTxvbo+CYtsdnRDYbl6HRAAwNnVIsOqRB7/RQOuaa3I6R/o9GB8pbZB5J8TRZ4dIDJnhciKWpHeQ5N5svOW6Zuw0Jrn8z9hYVYzErBAVxAewxHUAlAAGH4OrgeV15bE6wUWJ78vAsd5x7dJxwinjuXyfyVhgSt721F+MVnbj/6L3nb423q904d6HbBYXptsnWC/qmrdwsBvQOS7qcnj2dvscY5Xh4lMWpRqHz0vCYtsdjdYTFksstu6u9rxDTg98YuOY+Yykb85xlgAESyEhdYhqP+EhVn50MMCg8t4lDSmsga1oAsqX69wDSoPhYzXCywwc2ntWpF3Rom8MSL5qanTz5ayWxY3f5103nDWkx3OHF1SWDp/psMAFujqseGC708m6JbIXn01nNAaccY3dr4IgICwaAm8V5q6P1o09gB3NrsbLD4tSz0eNOpZIoJWChZ0qTnTO6uasNDKBPefsDBrH3pYYMzAj7u2zTKJNcjN9x64q+QFFo/8LIKn1KLl8Fra57rPky2LKx0ziwCLkXOTzhVX6licsHhrZNIOJ4xj4+r+0D/rsP+Z0jy+5wbofQAF55U+9seD+mxYZLO7wQJjKE4YoHUDWJy4rhXlHHNBONjZstBlFdR/wsKsfOhhgSmz+AS9oIXj502BQefXS/xeYIGBXSwX/1/SmaKlgMFgDCLbLQuvsMCYhtM5j5uf7HrCeMBfRqfakQ47DoyhzFiWai+ZlYRFNrsXWGAwfFW9yL3fJ+NDtxpaW4SFl1qX/7CEhVnT0MMCrQq0LsKw4IVLuFGPS6oCXmCB2U7TluoBa/TVAw5oOWDA+5C3Wg4LDGADADg+BrHhfO0BZ3Q/YcwAs40Apsv+qQe8MQsJgLnwE/0+jif66fixHe/nsFsW2exeYIH4MOtqfo1OJ46Nbi4shEVqvfJ7jbAwKx5qWFRXV1vjFatXrzbnwicrHv0R9PiJT1n1FI0XWMBZYlorupXg0HGVjd/ogoKtpS0LjBGgdQBoYCbToz8nr9xxTAxmo/sLdrfxAYylzF2hIYHZSZgKa8MC6TLZvcICwEI3GQbhF63SYykYk0E3FeLK5cPZUJ6qaE6BCQuzTKGGBd5YhxcRhWnBwwXxkEEuSQW8wsJ2hge+IXLwW7k5R3ufbN+YMWXfs5EeFq0Oe0ZVus1ePyrt/gt7u/2dzW6HM33jngtnvjEGgxdIPfBD7loQFsn6l69fhIVZyVDDYty4cVJWVmbOgc9WVCiMXeAx5ly0Ai2FhcmhFrNtaJW+eRBjNEe8rVsWmPp7zLqpwbnknbDI/9lHWJg1DS0sgnzEh1kysV6MhBckcdEKEBa5twgAAnTD4d4RjNOgW2z4HJHz/+HtGIRF/s8+wsKsaWhhEbbxCqeMeOUqXr2KV7ByESEsvDl6u+WA7id0jdnrXr4Ji/yfeYSFWdPQwmL27NkyePBgc+oDsqLVg7QFeVd5QFl3jZawaJnD9wKH9LCEhWtVbNVGwsIsX2hhgWmqYbi/IpN8GHzHtN7GxsZMQWKznbAgLIqhshMW5lIMLSxw5Q6HHNYFkMAjQNACivtCWBAWxXAOEBbmUgwlLOznQWHcIszLtGnTrKm96JaK80JYEBbFUP8JC3MphhIW9hvqwu6E8X4NTKNdsGCBWeUitxIWhEUxVHHCwlyKoYTF9OnTA3t/hVmu5tZJkyZFJq3NU5+fLXg3Q/kSfvzUYPrS/JQdj5JUgLBIauH2K5SwwF3SU6ZMcUtv6LbV1NRYjwDB2/y4REsBPPZ+xIgREvYWbLRUjW5qCQtz2YUSFphlFMT7ts1SZbbiTvOxY8dmDkBLKBWgcwhlsQSWKNYHs/Shg4U9uI2H9kVlsd8RvnLlyqgkmekUEToHVgOnAqwPTjWa/w4dLBYtWmQNGkftFaYjR44M3XOsmhc3tzgVoHNwqsHfrA/mOhA6WOB911F8Ix1mRGFmFGZIcYmGAnQO0Sgnv1LJ+mBWOnSwwJ3b+ERxGTp0qODeCy7RUIDOIRrl5FcqWR/MSocOFsOHD5cZM2aYUx1Sa1VVlXVXd0NDQ0hTyGQ5FaBzcKrB36wP5joQOljgaa5RvckN4yyYyVVZWWlWndZAFcB0Z4Ad07Px5kM8sgWv7iXkAy2WwCMnLMxFECpY2DOhojyrCE+ixXOtOHffXPGCtOKmT0ACY0z2B+u8VybIUgk+bsLCXAahgsWSJUuskzjKT3Ktr6+33nURpftEzFWk+Kz2u1IACPuDFiEBX3xl7SVHhIVZrVDBAl0DYX2HhVnGVCu6NzD2wiW8CqCe2aBA12dUnhgQXkWjnzLCwlyGoYIFZhKNHj3anOIIWFevXm11b6DycQmnAuguBCRsYCxbtiycCWWqfFOAsDBLHSpY4GVHZWVl5hRHxIq8lJaWRiS18Uum/UwvwKKkpCR+AjDHzRQgLJpJkrIhVLAYNWqUYPCxGBa7Xzzs7+QoBq1bmgfc/AlY8N6YlipYXPsRFubyDBUscIWHKYzFsqBLLcyvhg1K57USjr+ZlTMtWFSvqA5JiuL9Eq2g6qMdL2FhK+H+HRpYYCYKrvJQYMWy2M+5whgGl6QCU5umShg+U+qmSGllaSjSAj3mrC2eC6VkaUfnF2FhLqvQwKKurk5f5YX8VapmOZtb0dVRXl7e3BDjLe80vCNvNbzFT5oG3zV+F+NaEXzWCQtzGYQGFrgRDy0L3JhXTAvut8CsG9x/wUUrQFi4g5KwCPYMISzM+ocGFsVwQ56b1HgECOb0R/V5V255au02woKwaG0dKsT+hIVZ1dDAAs+DwhV4MS547DoG76P2jo5ClQVhQVgUqm615riEhVm90MACs6CKdb47HlA3cOBA6+F15uKIh5WwICzCWNMJC3OphAYWs2bNiuRLj8zyJq1Tp04VvO+Ci0hrYXFl7yulW0m30A+Qv7LkFU9p5JhFsGcHYWHWPzSwQJ8+Xk1arAsG7vGE04ULFxZrFnPOV2thscPeO8gVL1/hyRH7Pfvq5FtPlguevMBTGgmLnKtQQQISFmZZQwML3EVb7I/HwKNMcJd63Jc4wKLDER0Ii4hVdMLCXGChgQW6acaMGWNObcSt9vTguD+0ziss7vr2Ljn+huPl8EsOlzu/uVOcLQu0MO78+k45/Y+ny1FXHSVPTnjSupp/oP8Dcuy1x8p+p+0np95xqjxf8XziKv/BgQ/K+U+cL3f/72454vIj5JhrjpFb/n1Lwo5WyItVL0qnezvJ/qfvL0d3PtqK126d9FnRR07oeoI8M/mZxD49ZvSwtr286GW5tOelsum2mwqAceEzFybC2Ptn+mbLItgTnLAw6x8aWOAR0ePGjTOntgisAGIc8mkqKi+wAAjW33B9Oe764+Ti5y6WLXfa0lq3u6EOPPNA2XqXrWWvE/eSg887WHrM7CG3fX6btGnTRg45/xDp/Fpn6XB4B9l4i43lmSnaud/w1xtk4803lq123koue/Ey6XRfJ9lgkw2k64ddLcf+p4V/suLZaf+dBOMjgFDb9dvK1X2vtuyvLH5FlFICINmO/5GRj1jbXqh8QW7/8nbZpsM2VvzpELLDu30TFqZaU3gbYWHWODSwmDx5sowfP96c2iKw2veT4KmncV28wKL9Pu3lvMfPSzjlZ8uflbbrtU2MWQAWaGm8UftGIsy2u21rtQacDhnbjrryKCsMYAFnf/tXtyf2OfPBM63WAPYBPDbabCN5bdVrCTu2ATBoVWSDBY7Bbqjo1W7CwlxmoYHFpEmTYgELFMeIESME+Y3rkissXl3+qtVCuP+X+xNOG44YV/zOloUNAdjQKgAI7FYCtuFzym2nyA577WD9BizQWulT3Sdx3Ht+uMfaD91V+566rxx64aEJG/a/7+f7LPsjIx4hLIq04hIW5oINFSzi8oTW+fPnWzcg4nlYcVxyhUXP2T0tB33Pj/ekOO5dDt4lBRYAgQ0FtDwAi/t+ui+xDTbMTNpuj+2sbYDFVr/aKsVudyM9Me4Jq1XgPCb2f2riU9Zxuw/tnoDF/f2SEOs+pLtlRzcUwrNlEb2aTViYy4ywMOtTECuesDtkyJCieXeHV5FyhQWc7hbtt5Czup2VcOwvzX3JcsrOloXTsaM7ar0N1kvZB8fZ84Q95dCLdGvB7oZ6quypxHExKL1huw3ljbo35MgrjpTt99w+YcP+iA/dX31r+lpdUQASBtthw+emT24iLLxWhJCFJyzMBUJYmPUpmHX27NkyaNAgaWxsLFgcYT2wF1hgLAGDxWhdoIvppJtPMsICjhvwwKA3xiQwxnDNm9dYjv7Gj260HLsNC8xyenHOi9JtUDfZcb8dBfdGYP97f7zXiuOSHpdI76W9rVYKur5s2CAMWiaHX3q4ZcfAOVo7AIjdsjig03pVZoMAACAASURBVAHWwHjPWT0TQMF+pg8HuIOtsYSFWX/CwqxPwayABGCBO9fjtniBBa70MU0Vs5UwztDx3I6y62G7ZuyGgjPuvay3NdW2Tds21j5w7JgVZTtqwAKzo+DsccwNNt7Amj77+prXE2Gue/s6abdVO8uOFgdmRPVd2Tdhv+2L26Td1u0EcSBcl/e7pMAC8aGFk97dZafB7ZuwCPZMICzM+hMWZn0KasUrZNEdhW6pOC1eYGE7VTjqXvN6JZy1vd30jS4j3P+QHgaw2HSbTa3tveb3slof6WGw/mb9m9b9Ga+vTkLEGQ4gw4A4vp3b7d+YTeUcRLe3Z/omLII9CwgLs/6EhVmfgloxwI0n7WLAO05LS2CRycG2ZLsTFi3Zv1D7EBbBngWEhVl/wsKsT8GtuL8EU2njtAQNi5v+cZO037e9a2ugUCDI5biERbBnAWFh1p+wMOtTcCtuzsMbAnGzXlyWoGGRi+MOIgxhEewZQFiY9ScszPr4YsXjP4r9uVhOIQkL91lRhIWzlvj/m7Awa05YmPXxxYoHC6J1sWLFCl/iCzoSwoKwCLoOusVPWLipktxGWCS1CPQXHl0+ceLEQNPgV+SEBWHhV13zEg9hYVaLsDDr45sVL0XCy5HwkqRiXwgLwiKMdZywMJcKYWHWx1crXruK93oU+0JYEBZhrOOEhblUCAuzPr5a58yZIwMHDpSGhgZf4/U7sslNk2VS0yR+0jSY3TTb76JgfA4FCAuHGC4/CQsXUYLa1NTUJCUlJTJz5sygklDweNfKWmkKyV/1ymopm1QmjWsbQ5KiJoE+XIJRgLAw605YmPXx3TpjxgwZPHiwABxcCqsAnUNh9Y3a0VkfzCVGWJj18d1aX19vPQJk7ty5vscdtwjpHOJW4ub8sj6Y9SEszPoEYi0vL5dhw4YFEnecIqVziFNpZ88r64NZI8LCrE8g1tWrV1vTaBctWhRI/HGJlM4hLiWdWz5ZH8w6ERZmfQKz4hWzo0ePDiz+OERM5xCHUs49j6wPZq0IC7M+gVmrq6utR4AsX748sDQUe8R0DsVewt7yx/pg1ouwMOsTqLW0tFTQwuCSXwVwHwsgXFlZaQEZz+YCnLnEWwHCwlz+hIVZn0CtqLx4BMiqVasCTUexRT5t2jQLEnh4o/MTp8fEF1uZ5iM/hIVZRcLCrE/g1uHDh8uUKVMCT0cxJQBQcEICvwFlvBedS3wVICzMZU9YmPUJ3Dpv3jzrvgvcf8ElPwrgned4rIoNDICC3X350TbKRyEszKVHWJj1CdwKx4Y7uisqKgJPSzElAPeyABI2MDhNuZhKt2V5ISzMuhEWZn1CYcVA7KBBg/gIkDyWBga4bVCglQEoc4m3AoSFufwJC7M+obBi9g4cWlVVVSjSUyyJwEMbAYzJkycXS5aYj1YoQFiYxSMszPqExooZPHjfBZf8KTB9+nQLFkuXLs3fQXmkyCpAWJiLjrAw6xMaa21trdXHvmDBgtCkqVlCGlaLLJ8Rmc/qBeUyaeyIyKQ3oW0z4bkhHwoQFmYVCQuzPqGylpWVyciRI0OVppTEzPyfSC/FT6E1WMspvin1Lk8rhIVZSMLCrE+orCtXrgx3twlh4Q8oCYuCnJeEhVlWwsKsT+isY8eOlXHjxoUuXVaCCAvCIpw1M6dUERZmmQgLsz6hs2IwFjN4ampqQpc2ISwIi/DVypxTRFiYpSIszPqE0opxi0mTJoUvbYQFYRG+WplziggLs1SEhVmfUFoxIwp3H2OGVKgWwoKwCFWF9JYYwsKsF2Fh1ieUVtxtjHsucO9FqJYAYVHfU8mTZyiZ+XB+Z2P1vUjJsLsyHzObPdvssJ9uVvLeFZmP77o/B7gLUu0JC7OshIVZn9BaZ8+ebd3VHaonpQYIi1XPK1FKSb9bPTreLNNc99lOyasXZj5mNrurs3fE+cjpSk7cPfPxXfcnLApyXhIWZlkJC7M+obUCEnhe1KxZs8KTRsLCczcUYRGe6ktYmMuCsDDrE2ornkSLJ9KG5iF4HmFR/awSOMsz91Fy7eFKfrw5eYU95E4lz5+tZPAdSq4/UsmlHZV81UVJQ0+9/bz9lfQ6T8mSp/U+dsvin9cpue14JWftq7ulVvdIHhNX6X+7SsnlBys5/wAlL5+vj+e8ev/+JiVdj1Jy2cFK/nuTkvSWQza7KU+IZ3p3JQ+fpuSc/ZT0PFfJQ6eyZRGWk4ywMJcEYWHWJ9TWuro6610XeOdFKBYPsKh5Tsle2yo5/FdK3rhEyQ1HKtloPSUfXKWdO763bafkoB2VvHKBkqsOVbJBWyWn76XkikOUYKygw1ZKHjwlFRabbajkmsOU/Ol8Jb/aQslJv07C4q4TlWzXTjvrHuco2XFzJRcemLR/93udhi5HKXnhHCU7b6HX7W6obPZseQLY9thGybEddJ7x3W4DwiIUdVdECAtzSRAWZn1Cb8UTU/E2vVAsHmCBVsOmGypZ/kzSWWNb+82UrH1JQwNjEKPu1nYMYG+yvpLjdkuG73ORkv221+t2ywKtArulMPROPY7xwx+UTOmmpG0bJR9fk7RPfSh1nGPf7ZU8dUbSXtFdyfptk2MW2ezZ8vTob5V03FHnz07jMR0Ii1DUXcIiazEQFlklCncAvJ8b02hxVRT44gEWFx2oZM9tlXQ7NflBVxQAMetRDQs46sYXk84bXUJOZ/6Pa5RsubG227D49HfJ8Nh3q411K+HvnZW0UUruOSkZH+JGSwTdWWgVACYDb0/uD4d+QHsNi2x2hM2WJ3Sd3XlC6vGf6ERYBF5v1yWALQtzSRAWZn0iYR0/fryUlpYGn1YPsDj51/oqu/tpStI/VY9pWKAbyr4Cxzeu7NElZW/75NrmsEif5gogATCvX6y7sTBGkB4fupfmPa5B9cstyeMjnkN20rDIZkfYbHnCrCeMp9jpx/ezZxEWwVdcnQLCwlwShIVZn0hY7be+rVixItj0eoDFjUcr2XVLJU2OlsO0h/QAdN0LLYfF25clnTG6kdBSQdcTBqbxu+SOpB0tj3ev0IPOcNwYwwBIbGe+8EndGrHHLLLZs+UJYyYYp7GPj+9T9yQsgq20ydgJi6QWbr8ICzdVIrht9OjRMnHixGBT7gEWw+/SjvjxTkqWPq1k7uNK0H+PmUpwovYAt9Ox5tKyOHgn3UpAS6DzYUp22VIJuqgw5oH9MUA+4X4la3oowRgCBrwXPaXjRKtjt62VoHWBNN16nAaMDYts9mx5wgyvDddT0vtCJZil9X/X6nXeZxFstbVjJyxsJdy/CQt3XSK3ddGiRdbYxZo1a4JLuwdYAAK44t9hMz3jaIuNlFzSUcn8J1oHC7QMMHAOp4wxjtH3JK/kJz+oB8gxdoEwGCxHF5QNJLRyfn+0nqGEmVmYXovZWjYsstmz5Ql2jJ0AYEgfWlaIj7AIrso6YyYsnGo0/01YNNcksluGDRsm5eXlwaXfIyxsJ40xCnQ92eut/caxcMxMx8EMrMXrWhNuYdDqsFsbLbFjn2x5gh2zvtyOn3Ub7+AuSB0nLMyyEhZmfSJlnTNnjnXfRX19fTDpbiEssjpHx+MxGFaJEBYFqd+EhVlWwsKsT6SsTU1NUlJSIjNnzgwm3YRFy1oKXmFIWBSkfhMWZlkJC7M+kbMCFAAGwOH7QlgQFr5XuvxFSFiYtSQszPpEztrQ0GA9jRZdUr4vhAVh4Xuly1+EhIVZS8LCrE8krRjkxmC37wthQVj4XunyFyFhYdaSsDDrE0krps/iESALFy70N/2EBWHhb43La2yEhVlOwsKsT2StuEFv1KhR/qafsCAs/K1xeY2NsDDLSViY9YmsFY/+6Nevn+BRIL4tS8pEfriNn0JrsDaAyQu+VaLgIiIszNoTFmZ9Im0dM2aM4CGDvi2N9SKNdQX71K+pkbIJ42Xh/LkFi8Mt/Q21q2TKpDLBt5vd921NDb4VaZwiIizMpU1YmPWJtHXJkiXW2AUeYx71BeMvmBI8dOhQWbZsma/ZwQyzIUOGSFlZma/xMjJ/FSAszHoTFmZ9Im8dMWKE4AVJUV1wNzrGXzBgj1leePd4EMvSpUutNCxYsCCI6BmnDwoQFmaRCQuzPpG34pWrAwYMELyCNWoLHDNaE5gG7Hdrwk2radOmyaBBg6S2ttbNzG0RV4CwMBcgYWHWJ/LWtWvXWl0o06dPj0xeADaMtaA1MXXq1GDuRndRC1qipYaxIC7FpwBhYS5TwsKsT1FYZ82aZV0RB9WF40VEtIRw9Y73ivs6kyvHRK5cudJqqVVVVeW4B4NFRQHCwlxShIVZn6KwAhJwwLNnzw5tftC1M27cOKs1gVZQIM+2ylEdPH9r4MCBEui7Q3JMK4PlrgBhYdaKsDDrUzRWOGDM6KmpqbEGin2/u9ug5Ny5cy3niy6ewF8Na0inbUJ31MiRI9kdZQtSJN+EhbkgCQuzPkVjBRwGDx5s3aiHm/XCMA0UV+bo/8fYREVFhcAJR2Vhd1RUSir3dBIWZq0IC7M+RWEdO3asBQk4ZYACH7yz288FYxG4RwL3LGBBnz+6cnCFDscbxWXGjBlWHjg7Koql1zzNhEVzTZxbCAunGkX6G/cnOEEBWMBx+7UABogfH8xyKi0ttQaJ0fcfpdZEul5IOwbifb1LPj0RXM+bAoSFWUrCwqxP0VjR7eQEBu698GPB4DrGSpxxw8Fi7KQYFszYQt7CNAZUDLoGkQfCwqw6YWHWp6isEyZMSHHaflzV2/dL2N1fcKy40S4K03hzLfwpU6ZY40HFlKdc815M4QgLc2kSFmZ9isoKOGB6qu24C93Xjqm6dlz2N1o0+B3mabxeCx3jMJg8gBsIuURXAcLCXHaEhVmforMCGJiBBIddyGmq1dXVCVDYXVAYJ8FVOB7jEeb7KFpS6PPnz7dabcXSvdYSDaK+D2FhLkHCwqxPUVrhqDGTx56ZVIhMVlZWWoPoNhxa+myqCM2mtQbuMXjPJZoKEBbmciMszPr4Yj34LZF9X+MnXYNbv/FF/rxFYs/64pNp8yaprwciLMxyExZmfXyx7t1XpENvftI16PKlL/LnNRJMU8b4BQe78yqrLwcjLMwyExZmfXyxEhbuoIwiLNC1h+dwoZuPS7QUICzM5UVYmPXxxUpYFA8sUGEw0wt3p7d0nMaXSsdImilAWDSTJGUDYZEiRzArhEVxwQIzzvDCpii/oTCYMyHYWAkLs/6EhVkfX6yERXHBApUGd3RjynBUn3vlS8UPWSSEhblACAuzPr5YwwCLA95Iddjp6+mDz36sR3HMwllh8LBG3ATJJRoKEBbmciIszPr4Yg0aFu+PEXmpJAmL678QGTk3ue4HGNziiDos8N5w3PwYxjf++VKxIxYJYWEuMMLCrI8v1qBhMXZ+KiyeHyhStpCwyEfh4255vrM7H0oW/hiEhVljwsKsjy/WQsNir74iAMDX5SL9Z4q8Vypy3LsaBs8MEFmyWgTAeGGQyOX/EimdJ7JsjcjH40U6viny2C8i134mcv//RL6fJvLVFJHO/y48TKLeskDlsR97snTpUl/qEiNpuQKEhVk7wsKsjy/WQsNiyGyR8QtEuv8k8mQ/kSmLRSqXi+zWW+SGL0RmV2sI3PiVyGl/E/l2qsjcFSLdftB3lf8wXYcZViXy+C8aOk1rRU7/oLDAKAZYoAJh3MLvl035UnGLLBLCwlyghIVZH1+shYQFHiWCFgUgYI8L/O5zna3D39bbsnVDARYADOCCY+B76WqRJ35JHtM+dj6/iwUWeGAjxi4whsElvAoQFuayISzM+vhiLSQsbOd91kci934v8vpwkRFzdLaOX9cVlQssPi1LBQPGNHo6BsXtePL5XSywgNp4tS0+XMKrAGFhLhvCwqyPL9ZCwgLH7jdTZGWd/u41WOSRn3W2vMDig7GpsEC3FmGRe/WwZ0YV8rHwuaeGId0UICzcVEluIyySWgT2q5CwuP1bkYYmkWP+knT2v/9KZ/XE9/S29JbFcwNSZ0OhG4qwaH31wLgF3lbIJZwKEBbmciEszPr4Yi0kLK74lwjeCXHuxxoMmAWF8Qcs9gA1Wh6fTxI5ct0YxgM/iCxeJXLy+yJ7vCpCWOSnGixatMi6q3vNmjX5OSCPklcFCAuznISFWR9frIWEBcYQ/jFeZEWtyIIakTkrRG77RmR5rchd32mAYJZUXaOeAYXwJ72vwyLzF35CWOSzEuBtgdOmTcvnIXmsPClAWJiFJCzM+vhiLTQsAIA9+4gc+U6yKyp9IBr2fV5LtR+U9giQ9H0KvV5MA9x2RcITafEIc77vwlYkPN+EhbksCAuzPr5Y/YBFoR17IY5fjLAAJPD48qqqKl/qFiPJXQHCwqwVYWHWxxcrYZHaorHBU4ywQIXC2/SGDx/uS91iJLkrQFiYtSIszPr4YiUs4gWLmpoaPmDQlzPLWySEhVkvwsKsjy9WwiJesEClGjVqlEyaNMmX+sVIclOAsDDrRFiY9fHFSljEDxZz586VAQMGcKDblzMst0gIC7NOhIVZH1+shEX8YGEPdM+Zs+7ZK77UNEZiUoCwMKkjQliY9fHFSljEDxaoWOiGKi0t9aWOMZLsChAWZo0IC7M+vlgv/afIBf/gJ10DvGujmJclS5ZYd3TX1tYWczYjkzfCwlxUhIVZn1hZGxoaQvcKULw3o1iXtWvXSklJicyaNatYsxipfBEW5uIiLMz6xMrKk8X/4p4yZYo1M8r/mBljugKs/+mKpK4TFql6xHqNJ4v/xW8/upwPF/Rf+/QYWf/TFUldJyxS9Yj1Gk8W/4sfXVF4VhQf/+G/9ukxsv6nK5K6Tlik6hHrNZ4swRT/xIkTrfd0BxM7Y7UVYP23lXD/JizcdYnlVp4swRT7ggULeINeMNKnxMr6nyJHsxXCopkk8d3AkyWYsscstP79+wtejsQlOAVY/83aExZmfWJl5ckSXHHjWVFTp04NLgGMWVj/zZWAsDDrEwsrHjmBN7gNHjzYetcCfg8bNkxWrFgRi/yHIZN4e97IkSPDkJTYpoGwMBc9YWHWJxZWzMTp169fs8+qVatikf8wZBKOCl1R6JLiEowChIVZd8LCrE8srPX19c1AwZfz+Fv0eLAgxy381Tw9NsIiXZHUdcIiVY/Yro0ZM8ZyVmhhwGnxERT+V4URI0ZIRUWF/xEzRksBwsJcEQgLsz6xsc6bNy+ldcGH2/lf9JMnT+b9Fv7LnoiRsEhI4fqDsHCVJX4b7W4QtCxGjx4dPwFCkGOMHeHBglyCUYCwMOtOWJj1iZV1/PjxVuuCL+QJptirq6st/dmqC0Z/wsKsO2Fh1sdobZImoz1qRtwUhvEKDHhz8V8BtO7QsoPT4uK/AoSFWXPCwqyP0dq0tknGNI2RLxu+LJrPV2u+Kpq8oFzmNEXrtaVDhgyR2bNnG+sdjYVRgLAw60pYmPUxWgGLfo395K2Gt/gJqQbTmqYZyzBsRsxKKy8vD1uyYpEewsJczISFWR+jlbAIPySjBgu8DGns2LHGekdjYRQgLMy6EhZmfYxWwoKwMFaQFhhxfwsetcLFfwUIC7PmhIVZH6OVsCAsjBWkBcb58+dbz+dqwa7cpZUKEBZmAQkLsz5GK2FBWBgrSAuMS5YssWZEYWYUF38VICzMehMWZn2M1kLA4pUlr6QMlqevBz2YfvO/bpYTupwgZz10lpXOsKUvXZ+ojVmsXLnSggXfyW089QpiJCzMshIWZn2M1nzD4vavbpc9jt0jAYv09XRH6Pd696HdRSklh196uFz16lUStvS56RE1WNTV1VmwwA16XPxVgLAw601YmPUxWvMNi4ufv1h+1fFXCVikr7s5Qz+3Xf/u9bLx5hvLG3VvWGkMW/rctIgaLPCIctyYt2zZMmPdozH/ChAWZk0JC7M+RmtLYHHb57fJcdcfJ/uesq8cc80xcsd/7rAc770/3iu7H7W7tNu6nZzQ9QS57YvbUtb/tPBP8uDAB+WCpy6Q7kO6y/E3HC8HnnmgXNrzUnmjVjtvN2eZvu3h4Q/Lcb/T8SOebiXdEnBC2Af6PyDHXnus7HfafnLqHafK8xXPW/ab/3mz7HXiXrJhuw2t9F3V56pm6buy95Vy17d3SefXO0vHczvKb/7wG3lmyjPy7NRn5eRbTpbDLzlcbvrkppT4YD/tztPkgE4HyKEXHiqX9LhEXlv1mhUG2pz4+xOl17xeiX0ue+kyueDJCxLr6flLX48aLJqamixYYOyCi78KEBZmvQkLsz5Gq1dYoOtmo003spzd9e9dL4ddfJjVrfPQ4IfkiXFPyKEXHSpb/WoruebNa6T7sO4p668uf1Vu+OsNsum2m0r7fdvLuY+dK+c9fp6st8F61ne6k3Rbf7HqRatlACd+40c3yok3niht12srT45/0nK+AFmbNm3kkPMPkc6vdZYOh3eQjbfY2HL4SCPg1m6rdlb64Mid6UX6Op7T0Ur/QWcfJFe8fIXsfODOstP+O8kuB+8iZz54ppz98NnW8dGdhfQ9W/6sBR8ct8vfusgZ958hG222kXS6r5Nl772st2z36+3kqCuPSqQP6QXQ3PLnti1qsECFQ8uC7+M2nnoFMRIWZlkJC7M+RqtXWJz76LlyzRvXJBzd62tel0223ESufOVKa1t6t076OmCBMYPHRj+WOAauvPc8Yc/EupvDtLfd/f3dFhxenPOiFf7N+jcFV+oAFcJsu9u2cnTno1OOhW22s772rWstGNjHS08fYNF+n/aCfCEMBsORXsRh74PWyTmPnGOt3/n1nVYLye7WQhi0uhDGDt9tUDcrzde9fZ1stt1mcuHTFyZsdhjTdxRhMWDAAFmwYIGx7tGYfwUIC7OmhIVZH6PVKyzg1HrO6ino0oHTO+KyI2T9Dde3ul5gS3e+6euAxQYbb5DiLNEttcshu6Rsy+Q8caUOZ45xB3QJwQH3mq+7eNDNBcfe9cOuKcc65bZTZIe9drC25QIL5MmO/9FRj1rHtGGE7WiNoEVjh+m7sq/88b9/tICJFs/Wu2wtux25W8KOcOc9dp51nH1P3TcxXmLvn+2bsDBWYRodChAWDjFcfhIWLqLkuskrLC7vdbkFhw5HdLD66W/6x02Wc0Q/PZxeOhzS161uqG02TXGkFz5zodXNk81p2nZMdcV4w0FnHWSlBeC454d7rC4hwOK+n+5LOT7GB7bbYztrWy6wOOnmkxL727DoMbNHYpsTFrBv0X4L2XrXreXoq4+Wq/tebbVs0mFx+Z8ut2Cx12/2IixyrZwM51kBwsIsGWFh1sdo9QKLPiv6WOMLdpcTnDcGptGyuPi5iy1nCmg4Z0Olr7cWFk9NfMoaG3CCY/ejd7eu9pEWjH+c1U3fP2GHQRcXHDzW02GRnj50Q3mBBQa09zlpn5QB+qOuOkp2PWzXBFweH/O4rL/R+tZUXYzXXPTsRQmbnUbTN1sWxipMo0MBwsIhhstPwsJFlFw3eYHF66tfly123MK6mQ199H2q+1gzhHA1j24Wyxn/+VqrXx5OHf3+16at5wMWGCDGjCTAoceMHrLD3jskBpTR5YRuINw/AbhhoB3hMRjuBov09HmFBcACOKJ7DOMnt/z7FgtYOx2wkxUfZkVhcBz3dSB+dJG1Xb+tYEaXCRBOG2GRa21mOMLCXAcIC7M+RqsXWMCBdXm/i9Wls+k2m1qzfjD758grjrRmH8H+VNlTVrcMAIJpsunrrYUF4kCXDsYtMAUWIMCMLPsubDhtTMlt07aN1eLBzCzMirKdb3rLIj19XmHx9KSnrcHsDTbZwJoyjDEJzKJCSwJpwqwoDGq/NPelRBoOueAQ2XG/HS2Y2ekyfRMWxipMo0MBwsIhhstPwsJFlFw3eYWF7dRwRW/PGLK3Ob9fXvRywjlie/q6M2xLf/ec3VMwuOy2f9+avlarw83mtq216cMge++lvV3T4hafl22ERa61meEIC3MdICzM+hitLYWFF2eXa1h0bQFApk+uxyqmcISFsQrT6FCAsHCI4fKTsHARJddNYYIF7l1Al02mD2YdFRMEcs0LYZFrbWY4wsJcBwgLsz5Ga5hgkavzjFs4wsJYhWl0KEBYOMRw+UlYuIiS6ybCgu+zyLWueAnHO7i9qJW/sISFWUvCwqyP0UpYEBbGCtJCI2HRQuFauRthYRaQsDDrY7QSFoSFsYK00EhYtFC4Vu5GWJgFJCzM+hithAVhYawgLTQSFi0UrpW7ERZmAQkLsz5GK2AxoHGA/Lnhz/yEVIPpTdONZRhGI2ERTKkQFmbdCQuzPkZrkzQZ7VE04uU7XIJVgLAIRn/Cwqw7YWHWJ1ZWnizhKG7CIphyYP03605YmPWJlZUnSziKm7AIphxY/826ExZmfWJl5ckSjuImLIIpB9Z/s+6EhVmfWFl5soSjuAmLYMqB9d+sO2Fh1idWVp4s4ShuwiKYcmD9N+tOWJj1iZWVJ0s4ipuwCKYcWP/NuhMWZn1iZeXJEo7iJiyCKQfWf7PuhIVZn1hYcZJMmjRJxo4dKyUlJVJWVmatr1mzJhb5D1smCYtgSoSwMOtOWJj1iYV15syZ0q9fP+nfv7/1wW98qqurY5H/sGWSsAimRAgLs+6EhVmfWFhXr15twcGGBL4HDx4ci7yHMZOERTClQliYdScszPrExjpixIgEMNDCqKioiE3ew5ZRwiKYEiEszLoTFmZ9YmOdPXt2ShdUTU1NbPIetowSFsGUCGFh1p2wMOsTG2ttbW2iZTFs2LDY5DuMGSUsgikVwsKsO2Fh1idW1tLSUgsYlZWVscp32DJLWARTIoSFWXfCwqxPdmtTvUhjbVF85lZVWrBYU7O8KPJjlYuszV6GIQtBWARTIISFWXfCwqxPduvatSITPxT5+Z7If9b+fJ8s//nZyOcjURZzh4k0NWQvw5CFICyCKRDCwqw7YWHWJ7sVsPj6apFeJnRRlgAAIABJREFUip+waTD+PcIiew1miHUKEBbmqkBYmPXJbiUswgtJwiJ7/WWIhAKERUIK1x+EhassHjYSFoSFh+qSS1B2Q+WiUv7DEBZmTQkLsz7ZrYQFYZG9lngKQVh4kitvgQkLs5SEhVmf7FbCgrDIXks8hSAsPMmVt8CEhVlKwsKsT3ZrAWBR/WzqYHn6elgG0/9xjZL/dE1Na6a0jb1XyYvnZg+b17xyzCJ7/WWIhAKERUIK1x+EhassHjbmGRbf3KjkuN2STjV9PZMzDmL7xQcpufW4ZFpNafjgKiXbtjOHvf14Jc+caQ5jiqOZjbDwUJEZlLAw1wHCwqxPdmueYdHzXCUH75R0mOnrzRxi2KarZkhPLrA4chfCAhWO3VDZT7tChCAszKoSFmZ9sls9wqL2BSUAwGUHKzljHyV3nqBk5sMaDv1uVXL0rkq22UTJ749W8p8uqetLn1bS9yIl/71JybtXKLnwQCVXHqLkhz8k4WKCSeUj+riLn0qG73GOklcvTK4jzE3HKFnTQ28rvUfv02lvJX88Ucmcx5JhX7tYyYdXJ9end1fy2G+VnL2fksc7KRlwm15HmmxYjLxbye+OUHLe/kpeuUDJ2pf0/r3OU7JdOyUAxvNn622j71Fyw5FKTttLp2HYXcm4TPlM2NiyyF5/GSKhAGGRkML1B2HhKouHjR5hcfKvlRy2s5I3L9HO8sD2Sn69jZKmF5WUPaDkko5KdtlSyduXKRn5x9T1mue0k91tayW/2UNJn4s0dNq2UTLh/uyOtKGnkq02VoKxBjhUgGuT9ZXssFnSafe+UMkRu2j7Tzcr2Xh9JVcdqtNzbAfdlWQD44IDlNx8rA4LAO2+tRKEQd6Qzy03VrLf9toOWKzfVsne2yl56TwlD5yi4waskJavuypBvgDAL25QMv8JJVtspOSW43R6ATDsP+lBHT4BhAwtGctOWHioyAxKWJjrAGFh1ie71QMs4FAvP1hDwXZ2396oRCntHLEtvdspfR1X5Ae013BBeEAGYwHO1oF9bLfvzofpq3XYfrxZO++N1lMy/j7thH+7d7IrCFDDuITzONiGsQVsc8LioVNToQM70umEBfI56u7k8a44RMmZ+yTXnd1QSBvgsOAJbUcL5OXzU7Vzpsv1N2GRvf4yREIBwiIhhesPwsJVFg8bPcDCdmjo2vnrlUrgYI/fTcNixrquqHQ4pK8DFujGsY+Fb4xxPLeu68a53e33J9cq2XkLvf+Dpyi560QlJ+6uYbPiWSUbtNXgQKsDLZZz9lPS7dTkBw79mA56fycsAJnrj0xNF47vhAVaKYCbna4XzlFy0I7JdScsVj6nZN/tdesCXXbodnN2n9nHMH4TFh4qMoMSFuY6QFiY9clu9QALjAPgSnrzjfT302cqef1i77BIn4GEq/1cYYGpqTYQsN9XXZQ80Um3Ej79nZI9t9XOe+GTOl24+u9+WurHngLrhAWO9ehvk44fThxjD05YpM+GwnEywQL7I63QB8BC6wfdUj/fkhoHYZG9ijJEbgoQFmadCAuzPtmtHmCBsQJ0rcx6NOnwPr9BO2UMDsPxwYE6Z0Olr6Nl0RpYIA4MVj98moYGHPLA2/X4wrWHK7nv5GTa4Jzv/k1yHft+f1PSYTthgX3h1J3OG+MWLYXFlG5KPuqcPB7SiRYNxnSccRh/s2WRvf4yREIBwiIhhesPwsJVFg8bPcDil1uUtFFKRvxROzzMgkK/PvryJ64boP7L5Uq231QJnCUGpNPX8wELzKjadEM9GA1nW99TyWYbapABHLYDRvcTWgNfdlHS+KKS/rfqAe9/XqfDOGGBsYj12ii59yQluAEPs6EARi+wQKsLYypzH9f5x/7/uk7HPftRJftspwfG7fRl/SYsPFRkBiUszHWAsDDrk93qARZwbjcerbtTdtxcya5bKsEYAmYo2VfR5d2UwAaADLlTSfp6PmCB6bE4vrPb6Nz99QC1c0xhdQ89mI1uK8yawmwnTI21nbQTFtiGGwgP3TnZzYaZTFiHzZ46a++L7/RuKMyi2nA9PRsMdszMwrgFwAZwXNpRd005j2H8TVhkr78MkVCAsEhI4fqDsHCVxcNGj7CAc6t7IfV+BTeHt+yZpFOGPX3dbZ9CbUPLA1f2puOPubf5tFbcQ4J7SUz7pdugzarnU/eZ93jyvo/08MZ1wsJDRWZQwsJcBwgLsz7ZrS2AhdHBme4byGJDVxG6rjJ9nK2GfKcBXVtoIQ26XQlmMuGZUWiNYBZTvuPK+XiERfb6yxAJBQiLhBSuPwgLV1k8bAwRLA7ZSY93YMzD7fOHdTfQ5exss8DJeRwAClNlMQaDKbcYq8B9Ec4wvv8mLDxUZAYlLMx1gLAw65PdGiJY+O6MM8AE92iEIi2ERfb6yxAJBQiLhBSuPwgLV1k8bCQswgEGN3ARFh4qMoMSFuY6QFiY9cluJSwIi+y1xFMIPnXWk1x5C0xYmKUkLMz6ZLcSFoRF9lriKQRh4UmuvAUmLMxSEhZmfbJbCYtQw2J1zQqpr6/PXo4hCkFYBFMYhIVZd8LCrE92K2ERaliMHzdW+vXrJ0OGDJGJEydKZWWlLF26VBoaGrKXbUAhCItghCcszLoTFmZ9slvXNomsnCOyZBI/YdOgdrk01tfJsmXLZNasWRYshg4dasEDABk2bJiUlZXJ7NmzZfny5dLU1JS9vH0IQVj4ILJLFISFiyiOTYSFQwz+jIcC6JZasmSJzJw5U8aPHy+DBw+2ANK/f38ZMWKETJ48WebMmSMrVqyQtWg5+rwQFj4Lvi46wsKsO2Fh1ofWmChQW1srixYtkoqKChk7dqwMGjTIAggc96hRo6S8vFzmzZsnNTU1BVeEsCi4xK4REBausiQ2EhYJKfiDCqQqsHr1almwYIFMmzZNSktLZeDAgRZA8I11bIcd4fK5EBb5VDP3YxEWZq0IC7M+tFKBFAXQskALAy0NtDjg2DH+gZYIWiRomaCFgpZKSxfCoqXKtW4/wsKsH2Fh1odWKmBUAGMaGNuYO3euNdaBMQ+MfQAgGAvBmAjGRjBGkusUXsLCKHnBjISFWVrCwqwPrVTAswKYVVVdXS1VVVXWbKvhw4cnAJLLFF7CwrPkedmBsDDLSFiY9aGVCuRFgcbGxpyn8BIWeZHc80EIC7NkhIVZH1qpQMEUyDSF176JMOgpvAXLeMgOjPtsSkpKrHEnTF7Ab3QhonXIJakAYZHUgr+oQOAKYGAcYx4Y6wh6Cm/gYviUANxTA0Cnf/I9y82n7BQsGsKiYNLywFSgZQqkd0MFNYW3ZamP3l5o4TlBYd+cGb2cFDbFhEVh9eXRqYBnBdJh4XYAP6bwusVbrNvQirNnseEbXVNcUhUgLFL14BoVCFyBXGCRnkh7Ci+6VDDWkY8pvOlxFPP6/PnzE7BAK6Ourq6Ys9uivBEWLZKNO1GBwinQEli4pSZ9Ci8enGhfPdtTePGAxbA/hdctb/nehtlqtjajR4/O9+GL4niERVEUIzNRTArkCxZumniZwhuWp/C65aMQ2yZMmGCNXeAGSy7NFSAsmmvCLVQgUAUKCQu3jGWawosr7UI/hRcP9W0KyWfR4iXW41vq6htCkyb/n3nsVkP0NsIisza0UIFAFPAbFm6ZzOdTePE4FIylZFq+nCzy2aSQfMqaQpOWwSEbYycsMtVgbqcCASkQBli4Zb2lU3jxgikMGmPMBC+iSl/27ivSoTc/6Rp0+TJdqWDXCYtg9WfsVKCZAmGFRbOEiljv98j2FF7ny6UADbze1jnbiLBwByVh4VbjRGTSpEmCASYuVCDuCkQJFull5TaF13nDG34jf/jgXgaEJywIi/R6ZFwnLIzy0BgjBaIMi/RiQrdTOiyc67hAJCwIi/R6Y1wnLIzy0BgjBYoJFnhMuxMOeEgf7mPAjYOVlZXWw/oIC8LC0+lNWHiSi4GLWIFigkVDQ4P14qdVq1ZZXU5uxZZPWPy6j8jLQ0SOe9fdAacPIod5nWMWbrWFYxYZVOHmOCpQTLDIpfzyCYt9XtMxXv4vwiIX7b2E4WwoL2oxLBXwQQHCouWOnrAoXAUlLAqnLY9MBVqkAGHReljc+o3I38aI/DJDd0vZrRd0U308XuSk90XeHCny8wyRl0pEdn9V5IYvRL4uF3m3VOSMj5JpeOwXkWs+E3noR5Efpot8OFbkxPdEjn9Xx4F9bvk6GT5fXVvshspw+nDMIoMw3Bw7BQiLljteu2VRU6fvCH+6v8i8lSJDq/QxAQ0slctFXh+uQbKyTmRgpci4BSJP9hP5qULbbacPQMxdIfJjhcgTv4hMXiQyZbHIxIX6GK8O048sOffjlqfbjsv5TVhkOPUJiwzCcHPsFCAsWu50bVh8MiF5jAv+oatQ53+LNU0XawCF7Zi/mKztR/9Fbzv8bb3e6UO9DlhMWyqyx6t6/ab/aPtT/ZPHGFYl0ntoct0+dmu+CQutc7P/hEUzSbghpgoQFi13ujYsbnZ0C6GLaXmtSI+BSVg47WgZoLVgO3aEx9L5M70NsPjPlKQdXVRYTvtbctu3U0X+Pj65bh+rNd+Ehda52X/Copkk3BBTBQiLljtdGxbn/yP1GDOXifxpcBIWV36atAMWI+cm13frrSueExYfjE3abVgc9U5yG2Hh48lKWPgoNqMKtQKERdIJe70yt2HR7YfkMU54Txf3Hd8SFq2p+JwN1Rr1uC8VKIAChEXS0bcUFmULRY54W38+n6QHqAESe4CbLQvvFZew8K4Z96ACBVWAsGg9LF4bLrKqXqSuUWT6UpGz/66PSVi0vOoSFi3XjntSgYIoQFi0HBbOlsiefUSc4wpOWxR+c4A7w+nFMYsMwnBz7BQgLPIDiygAwZRGwiLDqU9YZBCGm2OnAGFBWAAihEWGU5+wyCAMN8dOAcKCsCAsDKc9YWEQh6ZYKUBYEBaEheGUJywM4tAUKwUIC8KCsDCc8oSFQRyaYqUAYUFYEBaGU56wMIhDU6wUICwIC8LCcMoTFgZxaIqVAoQFYUFYGE55wsIgDk2xUiBusPi0TOT/JvCTrgHesRGmhXdwh6k0mBYqICJxgkXTWpHGpvB8yqdOkwULF4cmTdAnLAthEZaSYDqowDoF4gSLsBX68OHDZebMmWFLVijSQ1iEohiYCCqQVICwSGrh969Ro0ZJRUWF39FGIj7CIhLFxETGSQHCIrjSLi0tlWnTpgWXgBDHTFiEuHCYtHgqQFgEV+5jx46V8vLy4BIQ4pgJixAXDpMWTwUIi+DKffz48TJ58uTgEhDimAmLEBcOkxZPBQiL4Mp94sSJUlZWFlwCQhwzYRHiwmHS4qkAYeF/udfX18vKlSsF3VAYt1iyZIksX77c/4SEOEbCIsSFw6TFUwHCwv9yHzp0qPTr1y/l079/f/8TEuIYCYsQFw6TFk8FCAv/yx2D2oCDDQz8RiuDS1IBwiKpBX9RgVAoQFj4XwwrVqxIgMIGxpw5c/xPSIhjJCxCXDhMWjwVICyCKXfcvW2DAt91dXXBJCSksRIWIS0YJiu+ChAWwZR9VVVVAhYjR44MJhEhjpWwCHHhMGnxVICwCKbcGxoaEuMWlZUhe+RrMJKkxEpYpMjBFSoQvAKERXBlgPss0AW1atWq4BIR0pgJi5AWDJMVXwUiC4vGWpHl0yP9WTl3kpSPHxnpPCTKYNVCkabGvJ1IhEXepOSBqEB+FIgsLOaPFOml+AmLBt91EWlqyE+lFBHCIm9S8kBUID8KEBYETl6gS1jk54TkUahAWBUgLAgLwsJwdvId3AZxaIqVAoQFYUFYGE55wsIgDk2xUoCwICwIC8MpT1gYxKEpVgoQFoQFYWE45QkLgzg0xUoBwkLDou4FJWt6JMGRvp4Xh1rAmUuj7lbyp/N1+htfVPLkGUoquifz4zX9fS9SMuwuD/tzgDtWfoOZjaEChIWSpU8r2Xd7JVO6aeeYvu7V0QYR/u3LlPxqC51+gG79tkp+utmDs08D2T7bKXn1Qg/7ExYx9B7McqwUICz0FbhSSVjgity5HoTz9xqnExZe93ULT1iscwPshoqVP2RmDQrEBRbTuyv544lKztxHycUHKXnxXCW4Aq95TsmVh2g4XH6wki+7pK7/7w9K6nsq+f3RSnCMbqcqOWMfJbcfr2Tu4x6uvHsp+aqLki5HKTltLyXXHaHk2xuT+6Pb5+uuuivpnP2UPHiKkrIHkvYhdyp5+kzdWkB6sf8XNyTtTlg0rEvvpAeT9tJ7dB467a11mPNY0gZYfH+Tkq5HKbnsYCX/vUkJYUFYGNwGTXFUIA6wQEth0w21g/2os3bEm2+k5IFTlNS+oOT5szUs4IxH/jF1fdx9eiwDLQ10Vd1wpJLXLlay3/ZKDtox1eG6XaHb27DPZhsqeeZMJX+7SsmlHXWcw9eNC5y3v5Lt2ik5elclH1ylBMBov5mSqnVOHdu22Eh3NWFsAmlvt4GSj6/RaXDCAhBEen9c1w2F7qiN11dy1aFKEO7YDkq2bafEBsZ3v1ey0XoaZC+co2TnLfQ6u6FEhC2LOLpF5tlNgTjAAs4QV81NLyadO67wf7OHXk/vdkpfx8A3nO9jv03u/8Mf9LZcWxePd1Ly58uS++Pqf6uNlfS5SG8DLAADbLcBs+e2Sm47Xq8DFkjDN47WyEOnasAgvAkWh+2sW1P2cfGNbWgd4Tcg+NQZyXiRf4x5EBaEhZvP4LaYKhAHWMAhwuHDwcM533Kckl23VHLUrtpBpsMhfd2GxX+6Jh0qBsPhvKc+lNzmdMZuvwGWf/9OyXNnK7niEH31ju4whAUsLumYeqxbj1NyTAe9DbDA1f+q55Nhfr5Fp2HWo5lhgZZT2za6pYIuNPtz5C762OiGg33g7cnjIj0HtCcsLJfAlkVMPSOz3UyBOMBi7L1KdtxcSYetlFxzmJI3LlFy7eHeYQHnbEMAkAAsytfNoLK3Z/p+5QLt7OGkMXbyz+s0sJywuPek5PFxnEdOT3Z1ARa7bJlqH3OvTgPGNjK1LBY+qcMATt1PS/0g7nmPa/svjrwh7kN2IiwIi2bughvirEAcYIEB7VP2VIL7D2xn3vkwJYf/Sq/PeFg7zMnrBoTT1+2WRUthsbqHkg3XS3Y5IQ1IC1oKGCPAOloWh+6cTB+2Yfzid0fobXY3lBNOvc7TYzHoXssECxwH3Vt3/yb12BjQtvMDkAIkCIsPANNGERaERZw9I/PeTIE4wALdOQfvpGTlc0rWvqRnEcF5H9heO8fqZzUs/t5ZyfJnlKSvtxYWmE210+ZKHj5Nj5ugKwljEWiZ4OY5OGjAAg76vSuUAC74RhrteyVsWKBFtOAJJUPvVLL/DslxBxMs0PWEAW3M9AKk+t+qB7zRukHcGPvYbWslaF3gHhPohbRxzIJjFs0cBjfEV4E4wAJdRhjMxuyhbTZRcvpe2hFihhDAAId51r7aQdpdQc711sICx//waiW/3kY7bczEwtRYzE668MAkLE7dUwkGtQEJzEh69wptw/6AxZYbK8H0XrRINllfz+6yB8RNsAB8MJi9QVu93+5bpw7Wo2WCqcHQB8c+/wDd6iIsCIv4ekbmvJkCcYAFnC0+i59SsmIdHOxtzm/YnF1V6evOsC39PfvR1BlP9nHQssAVPdYxXRYtINuGb8ACrQP8Rj4AAKc9l99o4SD+TGEBxUVPZbZn2s/azju4m51b3EAFikqBOMHC6OzSHnfhJSyu7k2fdMfvdmwnLNzsTli42QPfRlgUlV9gZqhAMwUIixZeSa+Dy8i7lWy/qfmDO7OzOXOMRaBrKlM4jC/gRsBM9sC3ExbNzi1uoAJFpQBhEWIH3IrWju/wICyKyi8wM1SgmQKEBWGRF7AQFs3OLW6gAkWlAGFBWBAWhlOad3AbxKEpVgoQFoQFYWE45QkLgzg0xUoBwoKwICwMpzxhYRCHplgpEFlYVFeK/Hh73j51Pz2Qt2PlM12ROdbEj0SaGvJ27qi8HamVByIsWikgdy8aBSILi8Z6kca6Vn0a61bLnNmVMmL4MBkyeHCrjtXatBTF/oRF0fgFZoQKNFMgsrBolpPcN9TU1Eh5ebkMHDjQ+kyZMkVWrlyZ+wEYsuAKsGVRcIkZARXwpkBcYLF27VpZsGCBlJaWSr9+/WT48OFSVVUljY2N3gRjaF8UICx8kZmRUIHcFSh2WKxZs0YqKiqkpKRE+vfvLxMnTpRly5blLhBDBqIAYRGI7IyUCmRWoFhhsXjxYhk/frwFiCFDhsjMmTOlrq4usxC0hEoBwiJUxcHEUAGRYoJFfX29VFZWytChQy1IjBs3ThYtWsRijqAChEUEC41JLm4FigEWy5cvl7KyMgt86G6aPn26rF69urgLrshzR1gUeQEze9FQAIO6uAJH1wy6aOBo8RtONyoL8jBnzhwZMWKENWA9evRomT9/vmAgm0v0FSAsol+GzEERKIBpopgRhAFftCzwwTqmk4Z94bTXsJdQftJHWORHRx6FCrRaAbQoAAjnZ+nSpa0+bmsO0NTUJBh3SF847TVdkeJfJyyKv4yZw4gogOmkdosCwBg0aFCgKcdMJdz7gMFpe+G0V1uJ+H0TFvErc+Y4pAqsWrUq0apAd9TUqVMDSykGowcPHmx1iwFcGE/htNfAiiMUERMWoSgGJoIKaAVwJW93Q61YsSIQWaqrq61WDYCFtOAb6eK010CKIzSREhahKQomhAqIzJo1y3LQGL8IYsE9EDYkbGjZ37W1tUEkiXGGRAHCIiQFwWRQASgAhwznPGPGDN8FmTdvXqJVY7coAA57HAVdUVziqwBhEd+yj3TOi3nqPh6u5zYDqdAFhhvnRo4cKWPGjLGe1zR58mRr3ATgQouHN9UVugTCfXzCItzlw9RlUKBprciXk0X27stPVDS45rMMhcnNkVCAsIhEMTGR6QoAFp9NEunQm5+oaHDZP9NLketRUoCwiFJpMa0JBQiL6EGSsEhU30j+ICwiWWxMNGFBWPAs8FcBwsJfvRlbnhQgLAiLPFUlHiZHBQiLHIVisHApQFgQFuGqkcWfGsKi+Mu4KHNYCFjs2UfPrLIHjNPX7e1R+D7zI5FnB2QGyu6virw8ROSE9zKHyXc+OWYR7VORsIh2+cU29fmGRcc3RaYtFTn5fe0809fz7TgLfbx7vhdZvCozCADChiaRqz7NHCbfaSQson26EhbRLr/Ypj7fsMAVNhYbFunr+XachT5eNlgUOn634xMW0T5dCYtol19sU98SWJz4nsi7o0X6zRT5bqrIcwNEcIW972siX03RUn5dLtLly9T1zp+JXPiJyIslIud+LPLJBJGfZ4g8M0AE3TlujjHTtrv/K/LvMpFPy0Ru/lpkD8f+F/+f3j6wUuTdUpFj/pI8NuJ/YZDIRZ+I/GuiyDfr0on9sf2H6To9aBEhbhsWl/9LBHnC59ZvksfDfh+PFzn1b3rbY7+IXPuZyP3/E/l+ms5/538nw+OYZ32k9xkwU+t45Dup9kx5trcTFtE+XQmLaJdfbFPvFRZoKayq1874ru9E3hghsrJO5M2RInv11Q4XYvYaLHLO31PXO30oAie/ZLXI1CW6r/9Pg0XqGkXwbTvDbN+vDBVZXqvjfOIXkfk1Ik/00/sDUMgTHHX3n0TGzReprhUB4HBcxL90tcjkRSJP9tN3r9c3igAs/5kiAmdfVa3zhfCABbqZFtZoyH0wVqS2QeTxX/TxAEksV68DAmAzu1pkWJUOA7ggPad/oMOju2pNg4632w8io+bq9HgBBmGhNY/qf8IiqiUX83R7hcV1n+sWwW6OO77/b4J2jnCu6d1O6etw1lgADhsKfx8nMrwquW5vd/s+8m29Pxymbb/la5HP192FPqtatzhsG76x7YvJOrwdP0AG26/7aOc9cm7yeAABYAY7YIEF+baP+eeR2sGjNeQGiymLRWx98A04AWrYf/wC3Rqzj2Vve39M8vhOm9tvwkKXSVT/ExZRLbmYp9srLOC88AwldK3AqX44VmTOCpEx87SzS4dD+jqcNa6snU4Q3VITFqZuc9qdv6//Ql/ZO7fZv9F1hOWOb1OP9ddSkYqlehviR0vB2e01fWlqy+b2b3VrBMcFLFbXp87uQjcTFrRW3GCBrjE7TfguWyjSs0S3vKD3TxW65YJWGT5j54uMXqefc79MvwkLrX9U/xMWUS25mKfbKyzO+EhkQY3uqsEzpR7+SV/Je4EFrrSdjhBjBRNzhMV9/9NdUM797d82mJytDtheKhGpXJ6ERXr8mL2FLin7OLd9kwoLdEvZNnyf/XddaU77mzss0FXlDI/WBGBx6J/1fujuem146gfjPs59TL8Ji2iftKGBBR6HjNc2cqECuSjgFRYY0B48O/XKHF1A4xZoZ3f8uzrWU9ZNnU1fx5V9urP2AgvbUR7256RzhfPGWMF+r+vxDzhip7NFF9e3U/U2t/izwQI5sge8cdznB4o0NunWhlvLIhMssO+KWpG/jE5NH54ie6WHqbe2BrmUL8OET4HQwALvG8Zz9LlQgVwU8AoLOEJ0q8Axw/nd+JV20Oinx/oBb+hY7/xO5MA3mq+7OWsvsMDsI8QFaKEbCFfrP1bocRTEjy4ndIuhuwrdZRhERrcTupZgd4s/F1i8M0qPb2AWFbqtPhqnj+cVFuh2Aiy7fqmBC8ePbjnnDCuk0/QhLHKp2eENExpYVFRUyKhRo8KrFFMWKgW8wuI3f9WD2ejHX7ZGzyLC4C0cHkABJ/fLupfTvT2q+bqbs/YCCxwf01TRz4+re8x0wvs4jlo3/RQQw5Rc2DBrae4KPSvKdr5u8WeDBewYIEee8bIodCPtvw6WXmEBgGEwGzOwoBkG33sPNcPBTrv9TViE6hTynJjQwGLmzJnWS+E954A7xFIBr7CwHdbBbyUdpr3N+Q1n6hxETl93hm3pb6TBbuGkHwMW/BOPAAAgAElEQVTTeI923F+Rbm/JOrqi0Fpqyb7p+2AWVkvTR1hE+1QNDSxmz54tQb2kPtpFGM/UtxQW6c4vX+voZjJ98hVPlI9DWET7XA0NLBYuXCh4OTwXKpCLAmGCBe7qxnOYTJ8bvsjPlT1hkUvtYJhCKBAaWKxYsUL69esna9asKUQ+ecwiUyBMsIiyA/cz7WxZRPskDA0sGhoaLFgsW7Ys2ooy9b4oQFhEr6VCWPhyahQsktDAAjkcOHCgzJs3r2CZ5YGLRwHCgrAontocjZyEChajR48W3G/BhQpkU4CwICyy1RHa86tAqGABUAAYXKhANgUIC8IiWx2hPb8KhAoWCxYskAEDBsha3EHEhQoYFAAs8F4K3JnMTzQ0wPO4uERXgVDBYvXq1dYgN2ZGcaECJgXCdjmxaNEiwcUOF7MCvA406xNma6hgAaEGDx4ss2bNCrNmTBsVSCjQ2NgokyZNsi5ypk+fntjOH1Sg2BQIHSzw9NnS0tJi05n5KUIFMM0bTx3ABc6SJUuKMIfMEhVIKhA6WKA5jzu5cd8FFyoQRgWampqsWXuopxMnTmRdDWMhMU15VyB0sECzHoPc7P/Ne1nzgHlQAONpw4cPl0GDBrGO5kFPHiI6CoQOFpBu7Nix1hVbdGRkSuOgAJ6MjNYE6mddXV0cssw8UoGEAqGExfz5863WBbuiEuXEHwEqsGrVKutdK3jCwJw5cwJMCaOmAsEpEEpYoE8YJ2ZVVVVwyjBmKiBi1UF0i+JmUUzt5kIF4qpAKGGBwpgyZYqMHDkyruXCfAesQG1trdXdhG4ndD9xoQJxVyC0sKiuruYNenGvnT7lH1Ng8Upfu9sTkyswgD1ixAhZuXKlT6lgNFQg3AqEFhaQDS2LsrKycCvI1EVagfr6egsMeJfK+PHjrYkVaE1MmzaNj52JdMky8flWINSwsN+exxci5bvYeTxbAcxsAhwAC3xKSkqE71Sx1eE3FUgqEGpYIJnDhg2T8vLyZIr5iwrkSQG8990JCsACg9mcFpsngXmYolIg9LDAVEWcwOgu4EIF8qUAbq5LB4W9zneq5EtlHqeYFAg9LDCNFs/fYeuimKpdsHnBUwJQp9CSsAGBCxJ0SaG1wZZFsOXD2MOpQOhhAdnwqlWc1JznHs5KFLVUoT4BFHhsB54UizGKlr5DZa2E7WHpUSsNpjcqCkQCFhAT0xgnTJgQFV2LKp3/afyPfNHwRVF9vlzzZavzM7RxaFGVMzNDBUwKRAYWeAQ0rgZx/wUXfxV4p+EdeavhLX7SNPiu8Tt/C4KxUYEAFYgMLKAR+pR5V7f/tYWwcAclYeF/XWSMwSkQKVhgzAIDkXyTnr8VhrAgLPytcYwtjApEChYQsLKy0nrIIG/U8686ERaEhX+1jTGFVYHIwQKzVjDYPW7cuLBqWnTpIiwIi6Kr1MyQZwUiBwvkEIPcmEo7d+5czxnmDt4VCBss+tb0lfMeO0+er3g+0EF3jll4r0vcI7oKRBIWkLuiosLqjuK9F4WvfGGDxSuLXxGllDzQ/wHCovDFzxiogKVAZGGB7ig8Vhqflt5QxTqQmwKEBbuhcqspDFXMCkQWFigUtCrwRj20MrgUToFCwgJdSid0PUEeGvyQHHrRodLpvk7yRt0bVovh+veul8MvPVw6nttRLnvpMnl9zevW9vSWxeW9Lpfff/z7lFbG2Q+fLXd/f3fKtnzfK8JuqMLVOR45fApEGhaQ034UCG7a41IYBQoJi97LeltdStvvub0cdeVRcuKNJ1oO/tQ7TpVNt91UznroLLno2Ytki/ZbyCHnH+IKi/1P319Ou+u0FDDssPcOcvmfLk/ZRlgUpn7wqPFQIPKwQDFNnjzZeoENxy8KU2n9gMWZD56ZcOxPTXxK2rRpI10/7JrY9vSkpy2o3PvjvZLesiAsClPuPCoVcCpQFLCwxy8wpRZPqeWSXwX8gMUtn96SAEPXD7paYDj9j6fLGQ+ckfhstOlGcmnPSwmL/BYvj0YFclKgKGCBnNbW1lpvOZs4cWJOGWeg3BXwAxb3/XxfAhZX9blK2q7fVtDaOKvbWSmfO7++0x0Wd6Z2Q22727bshsq9iBmSCmRVoGhggZziUdO4/2LmzJlZM84AuSvgNyzu+vauZlNj36h9Q657+zp5ZsozzWDR8ZyOckKXExKwwUB42/XaEha5FzFDUoGsChQVLJBb+10F8+fPz5p5BshNAb9h8frq16X9Pu1l31P3lcfHPC59V/YVzG7CgHeveb2aweL0u0+XzXfYXDCu8cqSVwSD47gPA7Ok8j2o7TweZ0PlVn8YqjgUKDpYoFhmzJhhtTCWLl1aHKUUcC78hgUc8pMTnpQ9jt3DcvobttvQ+o0uKNjSB7hfqHxBdj9qdyvs+hutLyfdfJJg0JuzoQKuOIy+qBQoSlighCZNmmTNkKqpqSmqAgsiM4WEhfNK3e03wNBrfq+cWggvVr0ofar75BTWLS6v29iyCKI2Ms6gFChaWGCG1JgxY2Tw4MF8HWsra1eQsPDqwP0MT1i0smJx90gpULSwQCk0NjbK6NGjZejQodZsqUiVTIgSS1jwcR8hqo5MSkAKFDUsoGlDQ4P1dr1hw4ZJXV1dQDJHO1rCgrCIdg1m6vOhQNHDAiLV19fL8OHDrfdgAB5cvClAWBAW3moMQxejArGABQoOrQq0LnCXN+DBJXcFCAvCIvfawpDFqkBsYIECBDDQwsCHXVK5V2nCgrDIvbYwZLEqECtYoBDRqkDrAq0MPCKES3YFCAvCInstYYhiVyB2sECB2oPemCXFJ9Vmr+LvNrwrbze8zU+aBv9t/G928RiCChSJArGEBcoOwMC02pKSElmxYkWRFGc4soF3i0yfPj0ciSlwKtbK2gLHwMNTgXAoEFtYQH48znz8+PHW2/b48qTWV8hVq1bJuHHjpF+/foKn//J1t63XlEegAmFRINawsAthypQp1rOk8BBCLt4VQCtt6tSploZ4J/ry5cu9H4R7UAEqEGoFCIt1xYOHD+KKmI83z72+ouVQVVVlPYMLj1UhbHPXjiGpQNQUICwcJTZ37lzr6risrIxdKA5d3H6i2w5TkAcMGCAVFRV8Q6GbSNxGBYpIAcIirTDxAiUMemPwmzfvpYkjIunjEpx+3FwjbqECxagAYeFSqphOi6vmIUOGyMqVK11CxG8TxiXKy8sT4xLV1dXxE4E5pgIxVoCwyFD4cI5jx461ZkotXLgwQ6ji34xxidmzZ1vjEoAn30BY/GXOHFIBNwUICzdVHNumTZtmDXzjO27L4sWLE+MSmACAqcZcqAAViKcChEUO5Y6WxcCBA6W0tDTxTCncdAYHGvUFLYcFCxakZANvF0SrCrPDMNjPcYkUebhCBWKpAGGRY7FjYBfjGJgiWllZaTlSONOov+d7woQJVl7QvYQBfXtcAgP8HJfIsXIwGBWIgQKEhYdCxpv34FwxXRSgwAczpzC+EcUFraP+/ftb+Rg0aBDHJaJYiEwzFfBJAcLCo9C4Q9l2sIAFfuPRFlFb5syZkwCeDT68s5zjElErSaaXCvijAGHhQWeMXdiAsB2s/R2lGVO4oc5Ot/Mb4OP4hIcKwaBUIEYKEBYeCtseDEZLAgPecLR2KwPdOFF4oRLuG3F2ozl/Iy98oKKHCsGgVCBGChAWjsKuaxTJ9VPbsFYWLl4mU8qnWTfvARyTp0zNef9c48l3uFGjSy3IAXajS8dI+dTpUjV3viyrrhHkyRSfQyr+pAJUIGYKEBaOAi9fLPJEv5Z9evZbJc/1q2vx/i2N1+t+SOPzLUjn2PkijXx1g6O28CcViJcChIWjvH+qEOnQmx83DT4tIywcVYU/qUDsFCAsHEVOWGQGJWHhqCj8SQViqABh4Sh0woKwcFQH/qQCVMChAGHhEIOwICwc1YE/qQAVcChAWDjEICwIC0d14E8qQAUcChAWDjEIC8LCUR34kwpQAYcChIVDDMKCsHBUB/6kAlTAoQBh4RCDsCAsHNWBP6kAFXAoQFg4xPATFtd8JvLxeJH/ThO59RuRh38S6fqldtZP/CJy3eci74wS+f/2zgS8iupu4wOiIlorn9StrhXRooii4IZr61oVpS5IsSrWYl3qLmq1biiKWlkU/KhLF78u+ljt+mn5bIWEkIRAQgIkELKACQECIfuevN/zzji5c2+z3dy528w7ee4z+5m5v3Py/91zziwf5wMX/Ap45gtrO+c9EPMygJs+6jnAO7eNdFqXzjoKiiZFwIcEJAtHpsdKFrd8AjS3AR+sA2YtA8prgdpmYG66Ffj/VWItyygD/lkEjP8lsKwUeHt1sBiKqqy7zSMVQX/2lywcBUWTIuBDApKFI9NjJYvS3cCvcwKB/zu/sU7CKQuK4Oh5gW0kC0dGaVIERCDmBCQLB/JYyGLMIuuAt34SEAF/2W+pCa5ZfFIQvF6ycGSUJkVABGJOQLJwII+FLCa+Zx3wkveDZZC3PVgW72UHr6cs3glphqJg+CDB/jQjRbqNmqEcBUWTIuBDApKFI9NjIYtj5gENrcCDnwWC/LjFQGdn77JYUgT8Pi+wD9Np65AsHNmnSREQgSgSkCwccGMhC/7CX5ABbKsHZi4BJv0BoAg4OPssQmsWi1cBO+qBc98DRi8E3sm2BMOrpCKtNfRnf9UsHAVFkyLgQwKShSPTYyULdly/kQmU1QCVDcDClUBBJfDycivw82qoUFmc/ksgu8I62aY24DdrrCuk1AzlyEBNioAIRI2AZOFAGytZTP0IOPmtQI3gqLnAtjrgkSWBZT392meT1ag3+t6up/0Hulw1C0dB0aQI+JCAZOHI9FjJIr0M+HcJMPFd4LTFVs2iuhk44+3YS6C/8pAsHAVFkyLgQwKShSPTYyUL3pHNS2N3NQJsUsosB676feKKgkKRLBwFRZMi4EMCkoUj02MlC/vXPJufvjU/sSVhn6tk4SgomhQBHxKQLByZHmtZ2IE4GcaShaOgaFIEfEhAsnBkumTRcy1HsnAUFE2KgA8JSBaOTJcsJAtHcdCkCIiAg4Bk4YAhWUgWjuKgSREQAQcBycIBQ7KQLBzFQZMiIAIOApKFAwaf2VRc5f5nU2UbinZ1upJ24fYWV9IJ93vWtQAdnQ5YmhQBEfAVAckiytnd2tqKlStXorCwMOIjbd++HSkpKWhvb484LSUgAiIgAuEQkCzCoRXmti0tLcjMzDQ/nI50oCQoi/Ly8kiT0v4iIAIiEBYBySIsXP3f2G1R2EfesGGDWVOx5zUWAREQgVgQkCyiQJmiyMjIMIM6m6HcHOrq6vDFF1+gpqbGzWSVlgiIgAj0SkCy6BVP+Cubm5ujJgr7bFatWoX8/Hx7VmMREAERiDoBycJFxLYosrKy4HaNwnmaFRUVWLZsWVSP4TyepkVABERAsnCpDFAU6enpoCja2tpcSrX7ZDo6OpCamootW7Z0v4GWioAIiIDLBCSLAQJ1Xr7a1NQUM1HYp7tp0yazucue11gEREAEoklAshgA3YaGBrOTmb/sbVGwHyHaNQrnqdrnUFVV5VysaREQARGICgHJYgBY169fb8qCVyXxhjuKwlnTGECSA9olJycHa9euHdC+2kkEREAEwiEgWYRDC0BjY2OXKCgLfjZv3hxmKu5svmPHDixduhRu3PDnzhkpFREQAa8SkCzCzNmCggIzQNuisMcM3LEeOjs7kZaWhpKSklgfWscTARHwGQHJIowMZ/+ELQeO+aue4+zsbLAPIR5DcXExVqxYEY9D65giIAI+IiBZhJHZGzduNOVgSyI3Nzfud1Lzkl2eT2VlZRjfRJuKgAiIQHgEYioLPuK6PUk/TS2tXTWJtevWoaau3vXvEl7WBbbOy8vDmjVrAgs0JQIiIAIuE4ipLCrqAL7LORk/H63vxN+ztuDjvKaonP/makukA8nfXbt2mSJj57sGERABEYgGgZjKQm+ii96b6Hj3eFFRUTTKiNIUAREQAUgWc3sO4EfGcB1rW2yiG+jAy3eXL18OXiGlQQREQATcJiBZxFAIvcknUlnwwYV8uOC2bdvcLiNKTwREQARUs+gtgMdyXaSyYFnmneWrV69WsRYBERAB1wmoZuGRmgVLRnV1tXlpb319vesFRQmKgAj4m4Bk0YssRi+MXX+GGzULFmW+85v3g2gQAREQATcJSBY9yOJXOcAry5NPFmVlZUhJSYnLgw3dLJhKSwREILEISBY9yGLNtuSUBZ9+S1mUl5cnVknT2YiACCQ1Ac/KYtxi4K0sYFkp8NF6YNqfArWE738ALMoKzLMj+0d/AWanWMueXwbsagQojJdSg7eLVqe3W81QLI182CHf2KdBBERABNwi4ElZjFkEbKsDNuwEnvo38HE+0NoOPPG5FfhnLgF4N7kz8M/PAFaWW8tu/QT4sgb4bBNw+1+Ct3Pu4+a0m7Kora01O7pramrcKidKRwREwOcEPCkL1hrqWoBj5wcCPZfVNgPHLQD6kgUlkKzNUHZ55guZ8vPz7VmNRUAERCAiAp6URcpm4H8LA6Jg8GfTE4fL3veHLCoqKsyb9GL5qteISqJ2FgERSGgCnpQFawXvZQfL4vxfWfnwvd9ZsmAzlbMZaeHKQDOUF2oWHR0dSE1NxZdffpnQBVAnJwIikBwEPCmLPxcAJbuDZfD0v4G2DmDkAuD+T60mKacs/rbRW7Jg8SssLERGRkZylESdpQiIQEIT8KQsrv/QYv7CMuDbbwLXfWB1dv/jq6apSX+w1j/wGfCt+cD0PwNNbcGy+KLU6hg/fXGwdJyCcXPazQ5uu8Tx7X18k19VVZW9SGMREAERGBABT8qCQfzhfwLVTUBzG9DQagV+dm7bAf7dbKC9w/rkbgdeSwuWxeOfAy3twNbawD72vtEYR0MWLBE5OTlYu3btgAqHdhIBERABm4BnZWEH9DPetmoP9rxzPOoNgPdjOJc5p3k1FbdxLovWdLRksWPHDvPFSC0tLXaeaywCIiACYRPwvCyiFdzdTjdasuD7LdLS0lBaWhp24dAOIiACImATkCx6eNyH2zLoK71oyYIZXVxcjBUrVth5rrEIiIAIhE1AsvCBLJqamsymqMrKyrALiHYQAREQARKQLHwgC2Z0Xl4ecnNzVepFQAREYEAEJAufyGLnzp1m7YK1DA0iIAIiEC4BycInsmDBSE9PR1FRUbhlRNuLgAiIgJqh+up4jtX6aHZw2+V88+bNWL58OXiFlAYREAERCIeAahY+qlm0traaDxfcvn17OGVE24qACIhAbGsWfIfEh+v06Y7B5mqgPQY/+NetW4fs7GwVfREQAREIi0BMaxYMhvYjNuI13rlrN/ILNsT9PLr7/mHl3AA33r17t/m8qPr6+gGmoN1EQAT8SCCmskgEwGy39/uTWDMzM7Fx48ZEyA6dgwiIQJIQ8J0s+H5qv99vUFZWZr7ror29PUmKqU5TBEQg3gR8Jws+hdXvv6r59ryUlBRs3bo13uVPxxcBEUgSAr6TBZ+RpLfHAaxhZWVlJUkx1WmKgAjEm4CvZMH7C5YuXQo9Iwmora01O7pramriXQZ1fBEQgSQg4CtZNDY26kogR6FctWoV8vPzHUs0KQIiIALdE/CFLHi5KDt1S0pKTFnw5jQNQEVFhXmTHvswNIiACIhAbwR8IQveiMZ3UTs/7Ltobm7ujY3n13V0dJhXRakPx/NZrS8oAhET8IUstmzZYvZVOGWRmpoKBku/D4WFhb6/78TvZUDfXwT6Q8AXsrDvWrZlwU5uNktpABoaGswaV1VVlXCIgAiIQI8EfCEL3nxmi4JjPXk1uDzw3hM21WkQAREQgZ4I+EIW/PJ8l4MtjPLy8p54+HI5n0LL2lZLS4svv7++tAiIQN8EfCMLXiJKWaSlpel9DiHlgvefkEtpaWnIGs2KgAiIgEXAN7JgHwVloUdcdF/0i4uLwSvENIiACIhAdwSiIgv+Um3obEB1Z3XCfHY07kBufi52d+yO+zkl4pvq+G5uNkXxXd0aREAERCCUQNRksaR9Cd5qe0ufbhi0dSbmTXB8Gq/fn8gb+g+ieREQAYuAZNFNMI+25BJVFqxVsHbBWoYGERABEXASkCwkC2d5MK8aKyoqClqmGREQARGQLCSLoP8CvklQ96EEIdGMCIgAAMlCsgj6R+C9FmyK4r0XGkRABETAJiBZSBZ2Wega827u7OzsrnlNiIAIiIAnZDHjwxk457ZzcNljl5lXX72+6/WEvgorUTu47X8H+1la9fX19iKNRUAEfE4g6WXxePrjMAwD474/DlPmTcHdf7kbx5x5jGQRYcHOzMwEn0irQQREQARIIOllccs7t2Do14ZiYctCUxDXvngtvjnmm5JFhOWb77jQY9wjhKjdRcBDBBJCFk9kPoGzfngWjr/geJwz/RzMXD4zKNg/svQRnDntTJxw0Qm48J4L8WLxi+b6GR/MwMiJI7HXsL3M/abMn4Kjxx+NYcOHmfOv7XgNN869ET/9x08x9c2pGPO9MTj3x+fi+Q3PY1bhLJx/5/kYN3kc7vjDHUHH4/qL7r0Ioy8ejVMmnYLJsyfjjYY3zG3u+es9mPijiXi14tWufa575Tpc/czVXfN93aeR6M1QLN98e96yZcv0eBQP/bPrq4hAJATiLos5ZXPMmgGD+O3v346Jt0/E4D0G45m8Z8zge9fHd2HQoEEYe9VYTH1jKo4cdySG7j/UDPiPpT2GM35wBoYdMAw/WPQDMJCfcs0pOOCbB5jz86rnYcwVY8z5ky4/CTf84gYcduJhOPTbh+Lwkw/HpY9eisufuNxMn81ZDPKzNs4y5cN0b/v1bbjk4Uuw93574+KHLjbXz909FyO+NQLjbxzfdX48XwqtL0nY65NBFixUBQUFyMrKiqR8aV8REAGPEIi7LO7/7H5TDnPK55jBdlHrIvCX+tO5T5vzBx51ICZMnRAUiLnMDtbT3ppmysAOxKHNUJTFwaMOxptNb5ppsDOcfRw8hr0PaydX/OwKc/7ev92Ls289u6tZi9ucdctZZg3G3n5m6kzznG9efDP2G7EfJj03qSste5vexskii9raWvPhixxrEAER8DeBuMuCv9QZzNnvwCYhBuBXt1lNPGxGYmCf/tvpQcH4grsuwEEjDzKX9UcWp113Wtf+T6560kzTlhGDOmsjrNHYAX5B3QLc9+l9uPH1G81mq+GHD8dRpx/VtZ7bXfnUlWY6x194fJBY7DR6GyeLLPivwZoFaxgaREAE/E0g7rJgUOWlruxvOOmykzBkryGmOB5Y8oDZJERZPPT5Q0GBmv0DI44ZYS7rjyzOm3Fe1/62LGaXzu5a5pQF1+9/8P4YfsRwTLhpAm5acJNZswmVxfWvXW/KYuS5Iz0tCz7SnX0X7MPQIAIi4F8CcZfFs+ueNfsG7F/iFMfRE442f+0vbF6IPfbcA5fNtO6fsLc59pxjzfWcD5UFO6OdV0OxGSocWbBDe9R5o8Bj28cbP2U8jjj1iK75n+f8HEP2HmJeqrvvgfvimlnXdK2z9+ltnEw1i46ODvOqKF4dpUEERMC/BBJCFuwg5hVJDNCzS2bjoOMO6upQZpMTm4F4/8T82vlmxzW3Z2d4d7KY9t/TzH4ESoj9FOHKgmKhbNg8xv6TOz+60xTWoaMPNY/Hq6LYOc77Onh8NpENHjIYvKKrN0E41yWTLPivwfsteN+FBhEQAf8SiLssGETZpMN+C14CSxGceu2pZtMU1zFos8N50OBBZhMVr3TiVVF28A2tWTy7/lmzGYnNV4+mPBq2LJ7Lf87szN5znz3NS3DZJ8GrqFiTYK2HV0WxU/uVra90ncPYq8fikBMOMWVmn1dv42STBe/k5lsGeWe3BhEQAX8SSAhZ2IH15S9fBjuX7XnneEH9ArPW4VzW2/QvKn/RbTq97eNcx072uVVzI0rDmZ5zOtlkwX8NPiuKz4zSIAIi4E8CCSULZ0D18nQyyoJPoeXTaPlUWg0iIAL+IyBZ6Kmz/Sr1fG8433PB911oEAER8B8ByUKy6Hep5xv00tPT+729NhQBEfAOAclCsuh3aea7udkUxXd1axABEfAXAclCsgirxOfm5oIfDSIgAv4iIFlIFmGVeNYqWLtgLUODCIiAfwhIFpJF2KV9xYoVKC4uDns/7SACIpC8BKImi4KOAqS2p+rTDYP2zvbkLTEASktLkZaWBl4hpUEERMAfBKIiiw50oD0B/rbt2Iadu3cmwJkE0yCfZB54rwWbonjvhQYREAF/EIiKLBIF3erVq7Fp06ZEOR1PnQfv5uZd3RpEQAT8QcDTsuBNZOXl5f7IyRh/y6qqKvN5UQ0NDTE+sg4nAiIQDwKelUV7e7sZzBjUNESHQEZGhvlE2uikrlRFQAQSiYBnZVFXV2fKorGxMZF4e+pc+I6L1NRU8J0XGkRABLxNwLOyqKysNDthdcVO9Aow357Ht+hVVFRE7yBKWQREICEIeFYWW7Zs0XOMYlDE8vPzsWrVqhgcSYcQARGIJwHPyaKmpgZsgtqwYQPWrFkTT7a+ODZ588VItbW1YGc3a3QaREAEvEfAU7JgkxMDl/1hE0lWVhZKSkq8l3MJ8o3IPCcnBytXruziniCnptMQARFwkYCnZEEufIS2LQt7rAffuVhiHEnxpjx2cJMzb9KzeavD2wFJkyLgEQKekwXb0J2BiwGMzVIa3CewdevWLkHYouBYb9Nzn7VSFIF4E/CcLMrKyrpkQWnk5eXFm7Gnj8875J2i4LQuV/Z0luvL+ZSA52Rhd7jaAay+vt6nWRu7r7127douQZO7anKxY68jiUCsCHhOFmwvt0XBIKYh+gTYyc3nRNnNf9XV1dE/qI4gAiIQUwKekwXpZWZmmsLQc4tiV5Z4gx4f/0FR67WrseOuI4lArAh4UhZ83wLvs0iIIR7vfIjT+zKam5tNUfOeCw0iIB11vlEAAAdtSURBVALeIuCOLBYcALw+VJ9QBp9Mjk9p6WgHPp2u/AjND3u+vTU++aKjikASE3BHFvwnfNXQJ5TBn66KT9GgLP5+s/IjND/s+faW+OSLjioCSUxAsrADSDTGkkViCkuySOKQpVOPFwHJIhqSsNOULCSLeP1n67gi4DIBycIO7NEYSxaShcv/sEpOBOJFQLKIhiTsNCULySJe/9k6rgi4TMAzsqiZ5W4He8tLBppmR5hmEspizYMG5nyv5++d+5CBl3tZv+1pA89cYqDuhe7T6Gt9TC6UUJ+Fy2FEyfmBgCdkcffZBp6/tPvgNJDgU/WcgeO/YWDDzAjTTEJZ/GaKgQOH9fy9/2eqgW/s2/P6nAcNGIaBip93v01f6weSX2HvI1n4IbbpO7pMwBOyOP1wd2VR/LgV8CSL7gN+b8G5Lxn0tb63tF1bJ1m4HEaUnB8IJIQs2DTx8PkGLj7OwLRxBj69IxCkGmcb+NEEA5seCyz78klr2e7nDbx6pYERwwxQGC9ebm2z4BoDf5tu4LWrDFxxgoFHLzCw/pHA/q9fbeCP0wLzDEJPftfA/80wUP+CgRvHWrK4/mQD//xx8HZhBawkrllk3W/gh6cZuPLbBsir8xWLQ/q9Bu6bGGDC5jryvnq0gTvPsrg7axZ9rSfP7Aes/GT+M+3ypwLpM22Wh3duMDDpRCtvlkSSJ+xPkiz8ENv0HV0mEHdZsMnnsP0NjD7YCjpTTzWw52ADCydbAaP6eStwL78nEEDsX6cMKpTCUcOtQPLJrdY2DHAUyIQjDLBZhcI4eD8DZV8FIQal+88NpMeANWqEgbmTDDS/ZEmHAe+5Sw2wjT4sQdid2xwnqSyGDDZw3AgDr1xp4JELDOwzxMDsKywO70818F/7BJhQ5GT70hUGpo838PWhwc1Qfa3/fIaBoUMMTDnFwOLrDJx5pNUMZguDecn8PfcYA/OvMXDdyQYGDzKw9uHAOYSdP5KFy2FEyfmBQNxlwWD0tb0N8Beo/U/PZfvvbYC1ir5kwX1Cm6EYYLh/28uBNI890MBdZ1vzvcmC6fm9GYqiXHV/gN0NYw1cOsqad8qCneGDDAPrHIGbtTm7ZtHXerI+9TAD154UOJa9jP1QnGZe8odExxxrnmP2qcybFLwPt+33R7LwQ2zTd3SZQNxl8Z2R/xkslt1lBRw2TwxUFpPHBAePn5xl4IwjrWWSRTAbZ5BlTYy/9O3gzHWsNZx0iLWPUxa/nmLgkK8Fp0Vx2LLoaz1rcawlsOY388LAh/K384qyYHOY8xxPPtTAC181OTqX93tasnA5jCg5PxCIuywYGO45JzgYsGOZAYft5rYsUu8ObLPyPmu93VTRXc3iwfMC2zOI/Ow7gYBnt407g8vRw61mKC7ze80i9GooXkrbnSz46/6g/QL9GWRn5x2vhupr/Y5nrHxkzeXxi4I/9uW7lAVF78wr1kYkCz+EJ33HRCIQd1mwrXrkgcHBgEGG7eb85cmmKIrD2en94c19y+KUw4LTZP+F/QuVAej2CYH1bK7i8dhnwaBU8oSVfsGjgW2cwarf00naZ9FfWaTcbXFa/UCAE/ua7JpFX+vJkc2Fof1Hn91h4F93WmlKFokULnQufiYQd1l88RMruPCXZO0sA0t/YrVRO5uRDv+6AV6ZxPVFjxsYe6i1j12zYHs6O8a3fnVtPwMM29LfvcGSDcd77WGAnakMUKx1sFO28DEDvJnvpxOt7XnVD9dzGQMe7ylgzabfcghtN/e4LHjT4okHG7jmRAO8Qo19FJS0LYu+1pMrm58opz/fZqB9jpX/bAb74GbJws+BSd898QjEXRYMGLwscvg+Bvbew8C+e1mB33n39F+nW1fg7DHI2u63NwXLYtFkSwaUCtOjLC481gA7tSkJXm3FY9hBn5JhTYNBjYGJzRxsmrJrFtzusuOt9aHNWXYa/Rp7XBZkwFoYWTLv+HniooAs+rOeNUd2ZvMKOF51xebAp74byCvVLBIvaOiM/EkgIWTBoMLr+Lc8aaDVcQWTMyCzw5XrnR2vzvW8mqrhxYAs7HZuXi5r3yPg3J7TvL/D3id0HedZk+Gv3e7W9WtZEsqiX98rtAb1qgH2PzgFH5pOX+uZ76ydhO4XlXl1cPsz2ulbR0QgYWThZlDo7teom+n3Oy0fyaLfTLoRTcz3lSwiChra2Z8EPCkL3gXOu7ZjHoRCA6FkEf88CM0TzksW/ox2+tYREfCkLOIuCTtASRaSRUT/ntpZBBKHgGRhB/ZojCULySJx/td1JiIQEQHJIhqSsNOULCSLiP49tbMIJA4BycIO7NEYSxaSReL8r+tMRCAiApJFNCRhpylZSBYR/XtqZxFIHALuyOKPFwK/O1ufUAZLH41PTne0A2nPKT9C88Oe72iNT77oqCKQxATckUUSA4j6qXd2RP0Q/3EAykKDCIiACLhIQLJwEaaSEgEREAGvEpAsvJqz+l4iIAIi4CIBycJFmEpKBERABLxKQLLwas7qe4mACIiAiwQkCxdhKikREAER8CqB/wdSnEinw5w7BQAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def indexesFromSentence(lang, sentence):\n",
    "    return [lang.word2index[word] for word in sentence.split(' ')]\n",
    "\n",
    "\n",
    "def tensorFromSentence(lang, sentence):\n",
    "    indexes = indexesFromSentence(lang, sentence)\n",
    "    indexes.append(EOS_token)\n",
    "    return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)\n",
    "\n",
    "\n",
    "def tensorsFromPair(pair):\n",
    "    input_tensor = tensorFromSentence(input_lang, pair[0])\n",
    "    target_tensor = tensorFromSentence(output_lang, pair[1])\n",
    "    return (input_tensor, target_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "teacher_forcing_ratio = 0.5\n",
    "\n",
    "def train(input_tensor, target_tensor, encoder, decoder, encoder_optimizer, decoder_optimizer, criterion, max_length=MAX_LENGTH):\n",
    "    encoder_hidden = encoder.initHidden()\n",
    "    \n",
    "    encoder_optimizer.zero_grad()\n",
    "    decoder_optimizer.zero_grad()\n",
    "\n",
    "    input_length = input_tensor.size(0)\n",
    "    target_length = target_tensor.size(0)\n",
    "\n",
    "    encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "    \n",
    "    loss = 0\n",
    "    \n",
    "    for ei in range(input_length):\n",
    "        encoder_output, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)\n",
    "        encoder_outputs[ei] = encoder_output[0, 0]\n",
    "        \n",
    "    decoder_input = torch.tensor([[SOS_token]], device=device)\n",
    "    \n",
    "    decoder_hidden = encoder_hidden\n",
    "    \n",
    "    use_teacher_forcing = True if random.random() < teacher_forcing_ratio else False\n",
    "    \n",
    "    if use_teacher_forcing:\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(decoder_input, decoder_hidden, encoder_outputs)\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            decoder_input = target_tensor[di]  # Teacher forcing\n",
    "\n",
    "    else:\n",
    "        # Without teacher forcing: use its own predictions as the next input\n",
    "        for di in range(target_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(decoder_input, decoder_hidden, encoder_outputs)\n",
    "            topv, topi = decoder_output.topk(1)\n",
    "            decoder_input = topi.squeeze().detach()  # detach from history as input\n",
    "\n",
    "            loss += criterion(decoder_output, target_tensor[di])\n",
    "            if decoder_input.item() == EOS_token:\n",
    "                break\n",
    "\n",
    "    loss.backward()\n",
    "\n",
    "    encoder_optimizer.step()\n",
    "    decoder_optimizer.step()\n",
    "\n",
    "    return loss.item() / target_length\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import math\n",
    "\n",
    "\n",
    "def asMinutes(s):\n",
    "    m = math.floor(s / 60)\n",
    "    s -= m * 60\n",
    "    return '%dm %ds' % (m, s)\n",
    "\n",
    "\n",
    "def timeSince(since, percent):\n",
    "    now = time.time()\n",
    "    s = now - since\n",
    "    es = s / (percent)\n",
    "    rs = es - s\n",
    "    return '%s (- %s)' % (asMinutes(s), asMinutes(rs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trainIters(encoder, decoder, n_iters, print_every=1000, plot_every=100, learning_rate=0.01):\n",
    "    start = time.time()\n",
    "    plot_losses = []\n",
    "    print_loss_total = 0  # Reset every print_every\n",
    "    plot_loss_total = 0  # Reset every plot_every\n",
    "\n",
    "    encoder_optimizer = optim.SGD(encoder.parameters(), lr=learning_rate)\n",
    "    decoder_optimizer = optim.SGD(decoder.parameters(), lr=learning_rate)\n",
    "    training_pairs = [tensorsFromPair(random.choice(pairs))\n",
    "                      for i in range(n_iters)]\n",
    "    criterion = nn.NLLLoss()\n",
    "\n",
    "    for iter in range(1, n_iters + 1):\n",
    "        training_pair = training_pairs[iter - 1]\n",
    "        input_tensor = training_pair[0]\n",
    "        target_tensor = training_pair[1]\n",
    "\n",
    "        loss = train(input_tensor, target_tensor, encoder,\n",
    "                     decoder, encoder_optimizer, decoder_optimizer, criterion)\n",
    "        print_loss_total += loss\n",
    "        plot_loss_total += loss\n",
    "\n",
    "        if iter % print_every == 0:\n",
    "            print_loss_avg = print_loss_total / print_every\n",
    "            print_loss_total = 0\n",
    "            print('%s (%d %d%%) %.4f' % (timeSince(start, iter / n_iters),\n",
    "                                         iter, iter / n_iters * 100, print_loss_avg))\n",
    "\n",
    "        if iter % plot_every == 0:\n",
    "            plot_loss_avg = plot_loss_total / plot_every\n",
    "            plot_losses.append(plot_loss_avg)\n",
    "            plot_loss_total = 0\n",
    "\n",
    "    showPlot(plot_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.switch_backend('agg')\n",
    "import matplotlib.ticker as ticker\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def showPlot(points):\n",
    "    plt.figure()\n",
    "    fig, ax = plt.subplots()\n",
    "    # this locator puts ticks at regular intervals\n",
    "    loc = ticker.MultipleLocator(base=0.2)\n",
    "    ax.yaxis.set_major_locator(loc)\n",
    "    plt.plot(points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH):\n",
    "    with torch.no_grad():\n",
    "        input_tensor = tensorFromSentence(input_lang, sentence)\n",
    "        input_length = input_tensor.size()[0]\n",
    "        encoder_hidden = encoder.initHidden()\n",
    "\n",
    "        encoder_outputs = torch.zeros(max_length, encoder.hidden_size, device=device)\n",
    "\n",
    "        for ei in range(input_length):\n",
    "            encoder_output, encoder_hidden = encoder(input_tensor[ei],\n",
    "                                                     encoder_hidden)\n",
    "            encoder_outputs[ei] += encoder_output[0, 0]\n",
    "\n",
    "        decoder_input = torch.tensor([[SOS_token]], device=device)  # SOS\n",
    "\n",
    "        decoder_hidden = encoder_hidden\n",
    "\n",
    "        decoded_words = []\n",
    "        decoder_attentions = torch.zeros(max_length, max_length)\n",
    "\n",
    "        for di in range(max_length):\n",
    "            decoder_output, decoder_hidden, decoder_attention = decoder(\n",
    "                decoder_input, decoder_hidden, encoder_outputs)\n",
    "            decoder_attentions[di] = decoder_attention.data\n",
    "            topv, topi = decoder_output.data.topk(1)\n",
    "            if topi.item() == EOS_token:\n",
    "                decoded_words.append('<EOS>')\n",
    "                break\n",
    "            else:\n",
    "                decoded_words.append(output_lang.index2word[topi.item()])\n",
    "\n",
    "            decoder_input = topi.squeeze().detach()\n",
    "\n",
    "        return decoded_words, decoder_attentions[:di + 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluateRandomly(encoder, decoder, n=10):\n",
    "    for i in range(n):\n",
    "        pair = random.choice(pairs)\n",
    "        print('>', pair[0])\n",
    "        print('=', pair[1])\n",
    "        output_words, attentions = evaluate(encoder, decoder, pair[0])\n",
    "        output_sentence = ' '.join(output_words)\n",
    "        print('<', output_sentence)\n",
    "        print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4m 42s (- 65m 51s) (5000 6%) 2.8377\n",
      "9m 24s (- 61m 6s) (10000 13%) 2.2620\n",
      "14m 11s (- 56m 47s) (15000 20%) 1.9727\n",
      "18m 53s (- 51m 57s) (20000 26%) 1.6963\n",
      "23m 42s (- 47m 25s) (25000 33%) 1.5068\n",
      "28m 27s (- 42m 40s) (30000 40%) 1.3363\n",
      "33m 16s (- 38m 2s) (35000 46%) 1.2023\n",
      "38m 9s (- 33m 23s) (40000 53%) 1.0620\n",
      "42m 50s (- 28m 33s) (45000 60%) 0.9693\n",
      "47m 32s (- 23m 46s) (50000 66%) 0.8640\n",
      "52m 15s (- 19m 0s) (55000 73%) 0.7781\n",
      "56m 51s (- 14m 12s) (60000 80%) 0.7422\n",
      "61m 27s (- 9m 27s) (65000 86%) 0.6700\n",
      "66m 6s (- 4m 43s) (70000 93%) 0.6059\n",
      "71m 1s (- 0m 0s) (75000 100%) 0.5630\n"
     ]
    }
   ],
   "source": [
    "hidden_size = 256\n",
    "encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)\n",
    "attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1).to(device)\n",
    "\n",
    "trainIters(encoder1, attn_decoder1, 75000, print_every=5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sjpark\\Anaconda3\\envs\\torch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type EncoderRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "C:\\Users\\sjpark\\Anaconda3\\envs\\torch\\lib\\site-packages\\torch\\serialization.py:360: UserWarning: Couldn't retrieve source code for container of type AttnDecoderRNN. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(encoder1, \"model/NLP_translator_encoder.model\")\n",
    "torch.save(attn_decoder1, \"model/NLP_translator_decoder.model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> je suis cupide .\n",
      "= i m greedy .\n",
      "< i m lazy . <EOS>\n",
      "\n",
      "> je vais a boston pour trois mois .\n",
      "= i m going to boston for three months .\n",
      "< i m going to to the manager right . <EOS>\n",
      "\n",
      "> vous n etes pas si interessantes .\n",
      "= you re not that interesting .\n",
      "< you re not that interesting . <EOS>\n",
      "\n",
      "> il est genereux envers ses amis .\n",
      "= he is generous to his friends .\n",
      "< he is generous to his friends . <EOS>\n",
      "\n",
      "> nous sommes tous a la pension .\n",
      "= we re all retired .\n",
      "< we re all retired . <EOS>\n",
      "\n",
      "> je suis contraint a le faire .\n",
      "= i am forced to do it .\n",
      "< i m willing to do it . <EOS>\n",
      "\n",
      "> tu n es pas japonais .\n",
      "= you are not japanese .\n",
      "< you are not japanese . <EOS>\n",
      "\n",
      "> vous etes bon cuisinier n est ce pas ?\n",
      "= you are a good cook aren t you ?\n",
      "< you re a good cook aren t you ? <EOS>\n",
      "\n",
      "> ils sont disposes a discuter du probleme .\n",
      "= they are willing to talk about the problem .\n",
      "< they are willing to the the problem . <EOS>\n",
      "\n",
      "> ils sont a vos trousses .\n",
      "= they re out to get you .\n",
      "< they re out to get you . <EOS>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "evaluateRandomly(encoder1, attn_decoder1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x281f87bf3c8>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output_words, attentions = evaluate(\n",
    "    encoder1, attn_decoder1, \"je suis trop froid .\")\n",
    "plt.matshow(attentions.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = elle a cinq ans de moins que moi .\n",
      "output = she s five years younger than i am . <EOS>\n",
      "input = elle est trop petit .\n",
      "output = she is too short . <EOS>\n",
      "input = je ne crains pas de mourir .\n",
      "output = i m not afraid to die . <EOS>\n",
      "input = c est un jeune directeur plein de talent .\n",
      "output = he s a talented young . <EOS>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sjpark\\AppData\\Roaming\\Python\\Python36\\site-packages\\matplotlib\\figure.py:445: UserWarning: Matplotlib is currently using agg, which is a non-GUI backend, so cannot show the figure.\n",
      "  % get_backend())\n"
     ]
    }
   ],
   "source": [
    "def showAttention(input_sentence, output_words, attentions):\n",
    "    # Set up figure with colorbar\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    cax = ax.matshow(attentions.numpy(), cmap='bone')\n",
    "    fig.colorbar(cax)\n",
    "\n",
    "    # Set up axes\n",
    "    ax.set_xticklabels([''] + input_sentence.split(' ') +\n",
    "                       ['<EOS>'], rotation=90)\n",
    "    ax.set_yticklabels([''] + output_words)\n",
    "\n",
    "    # Show label at every tick\n",
    "    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def evaluateAndShowAttention(input_sentence):\n",
    "    output_words, attentions = evaluate(\n",
    "        encoder1, attn_decoder1, input_sentence)\n",
    "    print('input =', input_sentence)\n",
    "    print('output =', ' '.join(output_words))\n",
    "    showAttention(input_sentence, output_words, attentions)\n",
    "\n",
    "\n",
    "evaluateAndShowAttention(\"elle a cinq ans de moins que moi .\")\n",
    "\n",
    "evaluateAndShowAttention(\"elle est trop petit .\")\n",
    "\n",
    "evaluateAndShowAttention(\"je ne crains pas de mourir .\")\n",
    "\n",
    "evaluateAndShowAttention(\"c est un jeune directeur plein de talent .\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "torch"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}