Transformer_NMT_en_es.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Transformer-NMT-en-es.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "1zjDhD_lZFAXvSk2AQRJENJfCo3n6WU_h",
      "authorship_tag": "ABX9TyP4n1QJ8/Z69PblF6T3G74y",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AshishBodhankar/Transformer_NMT/blob/main/Transformer_NMT_en_es.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Let's replicate the Transformer from \"Attention is all you need\".\n",
        "\n",
        "An attempt to recreate a distilled version of the Transformer network introduced in the deep learning research paper - \"Attention is all you need\" paper by Vaswani et. al\n",
        "\n",
        "paper: https://arxiv.org/pdf/1706.03762.pdf\n",
        "\n",
        "### **Original Abstract**\n",
        "\n",
        "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train\n",
        "\n"
      ],
      "metadata": {
        "id": "miorxlZGIx3_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LJ0uO-7h9ovH",
        "outputId": "49f7cb81-8a07-4bee-e483-f749ac98321c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mon Dec 20 13:10:39 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 495.44       Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   34C    P0    28W / 250W |      0MiB / 16280MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_O1J_4cw31Hh"
      },
      "outputs": [],
      "source": [
        "import math\n",
        "import os\n",
        "import gc\n",
        "import time\n",
        "import re\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline \n",
        "\n",
        "from google.colab import drive\n",
        "try:\n",
        "    %tensorflow_version 2.x\n",
        "except:\n",
        "    pass\n",
        "import tensorflow as tf\n",
        "\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras import backend as K\n",
        "import tensorflow_datasets as tfds\n",
        "\n",
        "from keras.preprocessing.text import Tokenizer\n",
        "from keras.preprocessing.sequence import pad_sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Setting some parameter and hyperparameters for our model**"
      ],
      "metadata": {
        "id": "GNUVv9MtGwCH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Parameters for our model\n",
        "INPUT_COLUMN = 'input'\n",
        "TARGET_COLUMN = 'target'\n",
        "NUM_SAMPLES = 80000 #40000\n",
        "MAX_VOCAB_SIZE = 2**14\n",
        "\n",
        "BATCH_SIZE = 64  # Batch size for training.\n",
        "EPOCHS = 10  # Number of epochs to train for.\n",
        "MAX_LENGTH = 15\n"
      ],
      "metadata": {
        "id": "eSpv4a2P4gfz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Global parameters\n",
        "root_folder='/content/drive'"
      ],
      "metadata": {
        "id": "EIRyDDFG419a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_folder_name='MyDrive/datasets/eng_spa_translations'\n",
        "checkpoint_folder = \"MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/\"\n",
        "train_filename='spa.txt'\n",
        "\n",
        "# Variable for data directory\n",
        "DATA_PATH = os.path.abspath(os.path.join(root_folder, data_folder_name))\n",
        "train_filenamepath = os.path.abspath(os.path.join(DATA_PATH, train_filename))\n",
        "checkpoint_path = os.path.abspath(os.path.join(root_folder, checkpoint_folder))\n",
        "\n",
        "# Both train and test set are in the root data directory\n",
        "train_path = DATA_PATH"
      ],
      "metadata": {
        "id": "A38W7XJe4jTm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **The dataset and text preprocessing** \n",
        "\n",
        "We will use pairs of simple sentences, where the source is English and target is Spanish, from the Tatoeba project where people contribute adding translations every day. \n",
        "This is the [link](http://www.manythings.org/anki/) to some translations in different languages. Here we can download the Spanish - English spa_eng.zip file, and it contains 124,457 pairs of sentences.\n",
        "\n",
        "We use a list of ***non breaking prefixes*** to avoid the tokenizer to split or break words including that prefixes. In our case we do not want to remove some the dots for some well-known words. We can find non breaking prefixes for many languages in the Kaggle website:\n",
        "\n",
        "https://www.kaggle.com/nltkdata/nonbreaking-prefixes/activity\n",
        "\n",
        "The text sentences are almost clean, they are simple plain text, so we only need to remove dots that are not a end of sentence symbol and duplicated white spaces.\n",
        "\n",
        "The following functions will apply such cleanings we just mentioned:"
      ],
      "metadata": {
        "id": "UnoTbMDKIAse"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def preprocess_text_nonbreaking(corpus, non_breaking_prefixes):\n",
        "  corpus_cleaned = corpus\n",
        "  # Add the string $$$ before the non breaking prefixes\n",
        "  # To avoid remove dots from some words\n",
        "  for prefix in non_breaking_prefixes:\n",
        "    corpus_cleaned = corpus_cleaned.replace(prefix, prefix + '$$$')\n",
        "  # Remove dots not at the end of a sentence\n",
        "  corpus_cleaned = re.sub(r\"\\.(?=[0-9]|[a-z]|[A-Z])\", \".$$$\", corpus_cleaned)\n",
        "  # Remove the $$$ mark\n",
        "  corpus_cleaned = re.sub(r\"\\.\\$\\$\\$\", '', corpus_cleaned)\n",
        "  # Rmove multiple white spaces\n",
        "  corpus_cleaned = re.sub(r\"  +\", \" \", corpus_cleaned)\n",
        "\n",
        "  return corpus_cleaned"
      ],
      "metadata": {
        "id": "BiEFhofWIReE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Loading the dataset**\n",
        "Mount our Google Drive unit to access the datafiles from the notebook\n"
      ],
      "metadata": {
        "id": "61syeXLtL1G3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#drive.mount(\"/content/drive\")"
      ],
      "metadata": {
        "id": "F9oxQ1YuLzB2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Mounted at /content/drive\n",
        "\n",
        "Loading the list of non breaking prefixes for the english and the spanish sentences"
      ],
      "metadata": {
        "id": "YdpW0Jh3L_lU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open(DATA_PATH+\"/nonbreaking_prefix.en\", \n",
        "          mode = \"r\", encoding = \"utf-8\") as f:\n",
        "    non_breaking_prefix_en = f.read()\n",
        "with open(DATA_PATH+\"/nonbreaking_prefix.es\", \n",
        "          mode = \"r\", encoding = \"utf-8\") as f:\n",
        "    non_breaking_prefix_es = f.read()\n",
        "\n",
        "non_breaking_prefix_en = non_breaking_prefix_en.split(\"\\n\")\n",
        "non_breaking_prefix_en = [' ' + pref + '.' for pref in non_breaking_prefix_en]\n",
        "non_breaking_prefix_es = non_breaking_prefix_es.split(\"\\n\")\n",
        "non_breaking_prefix_es = [' ' + pref + '.' for pref in non_breaking_prefix_es]\n"
      ],
      "metadata": {
        "id": "-AJkBZVbMCVD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Load the dataset into a pandas dataframe and apply the preprocess function to the input and target columns."
      ],
      "metadata": {
        "id": "O4iAFhckNvzh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Load the dataset: sentence in english, sentence in spanish \n",
        "df=pd.read_csv(train_filenamepath, sep=\"\\t\", header=None, names=[INPUT_COLUMN,TARGET_COLUMN], usecols=[0,1], \n",
        "               nrows=NUM_SAMPLES)"
      ],
      "metadata": {
        "id": "S5TeYj7-N3Ph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Preprocess the input data\n",
        "input_data=df[INPUT_COLUMN].apply(lambda x : preprocess_text_nonbreaking(x, non_breaking_prefix_en)).tolist()\n",
        "# Preprocess and include the end of sentence token to the target text\n",
        "target_data=df[TARGET_COLUMN].apply(lambda x : preprocess_text_nonbreaking(x, non_breaking_prefix_es)).tolist()\n",
        "\n",
        "print('Number of sentences: ',len(input_data))\n",
        "print(input_data[:5])\n",
        "print(target_data[:5])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uTTDxHkeNUun",
        "outputId": "a5b8b06a-e5f0-4e6b-d387-fd79d5b78593"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of sentences:  80000\n",
            "['Go.', 'Go.', 'Go.', 'Go.', 'Hi.']\n",
            "['Ve.', 'Vete.', 'Vaya.', 'Váyase.', 'Hola.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Number of sentences: ',len(input_data))\n",
        "print(input_data[30000:30005])\n",
        "print(target_data[30000:30005])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3YAcVAWkO7CH",
        "outputId": "a2621fa7-fb19-459f-ab77-477e1a7a8f40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of sentences:  80000\n",
            "[\"Please don't mind me.\", 'Please help yourself.', 'Please hold on tight.', 'Please lock the door.', 'Please make your bed.']\n",
            "['No te preocupes por mí.', 'Sírvase usted, por favor.', 'Por favor, sujétalo fuerte.', 'Ponle seguro a la puerta, por favor.', 'Haz tu cama, por favor.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Delete the dataframe and release the memory (if it is possible)\n",
        "del df\n",
        "gc.collect()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NwJsOYjPOzXD",
        "outputId": "f7935341-c141-44ee-e8f3-488a7e088c55"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "219"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Tokenize the text data**\n",
        "Next, let's prepare the data for our model. The steps are as follows:\n",
        "\n",
        "* Create the vocabulary from the corpus using Subword tokenization, breaking words into “subword units” - strings of characters like ing or eau - that allow the downstream model to make intelligent decisions on words it doesn’t recognize.\n",
        "* Calculate the maximum length of the input and output sequences.\n",
        "* Tokenize the data, convert the raw text into a sequence of integers. Once we define the vocabulary, we use the encode method to get the token for every word in the corpus.\n",
        "* Remove sentences longer that the max length defined.\n",
        "* ***Padding the sentences***: we need to pad zeros at the end of the sequences so that all sequences have the same length. Otherwise, we won't be able train the model on batches\n",
        "\n"
      ],
      "metadata": {
        "id": "tj2PvBPtQ93f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def subword_tokenize(corpus, vocab_size, max_length):\n",
        "  # Create the vocabulary using Subword tokenization\n",
        "  tokenizer_corpus = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(\n",
        "    corpus, target_vocab_size=vocab_size)\n",
        "  # Get the final vocab size, adding the eos and sos tokens\n",
        "  num_words = tokenizer_corpus.vocab_size + 2\n",
        "  # Set eos and sos token\n",
        "  sos_token = [num_words-2]\n",
        "  eos_token = [num_words-1]\n",
        "  # Tokenize the corpus\n",
        "  sentences = [sos_token + tokenizer_corpus.encode(sentence) + eos_token\n",
        "          for sentence in corpus]\n",
        "  # Identify the index of the sentences longer than max length\n",
        "  idx_to_remove = [count for count, sent in enumerate(sentences)\n",
        "                 if len(sent) > max_length]\n",
        "  #Pad the sentences\n",
        "  sentences = tf.keras.preprocessing.sequence.pad_sequences(sentences,\n",
        "                                                       value=0,\n",
        "                                                       padding='post',\n",
        "                                                       maxlen=max_length)\n",
        "  \n",
        "  return sentences, tokenizer_corpus, num_words, sos_token, eos_token, idx_to_remove"
      ],
      "metadata": {
        "id": "eHxFu7tzQ9TE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tokenize and pad the input sequences\n",
        "encoder_inputs, tokenizer_inputs, num_words_inputs, sos_token_input, eos_token_input, del_idx_inputs= subword_tokenize(input_data, \n",
        "                                                                                                        MAX_VOCAB_SIZE, MAX_LENGTH)\n",
        "# Tokenize and pad the outputs sequences\n",
        "decoder_outputs, tokenizer_outputs, num_words_output, sos_token_output, eos_token_output, del_idx_outputs = subword_tokenize(target_data, \n",
        "                                                                                                        MAX_VOCAB_SIZE, MAX_LENGTH)"
      ],
      "metadata": {
        "id": "kHiGtq-DTYNR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the tokenize function\n",
        "print(encoder_inputs[:5], sos_token_input, eos_token_input)\n",
        "print(decoder_outputs[:5], sos_token_output, eos_token_output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2gkEr2W0lrKv",
        "outputId": "81b943bf-7feb-40bb-99e5-74c376c1b4cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[13611  5305 13401 13612     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [13611  5305 13401 13612     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [13611  5305 13401 13612     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [13611  5305 13401 13612     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [13611  1507 13401 13612     0     0     0     0     0     0     0     0\n",
            "      0     0     0]] [13611] [13612]\n",
            "[[15149  7923 14939 15150     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [15149  7923   242 14939 15150     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [15149 10207 14939 15150     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [15149 14145 14939 15150     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [15149  1734 14939 15150     0     0     0     0     0     0     0     0\n",
            "      0     0     0]] [15149] [15150]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('Size of Input Vocabulary: ', num_words_inputs)\n",
        "print('Size of Output Vocabulary: ', num_words_output)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0wrRO1CklzhF",
        "outputId": "77062e0d-7622-471e-af07-81dcd9e882b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Size of Input Vocabulary:  13613\n",
            "Size of Output Vocabulary:  15151\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Create the batch data generator**\n",
        "\n",
        "* Create a batch data generator: we want to train the model on batches, so we need to create a Dataset using the tf.data library and the function batch_on_slices on the input and output sequences."
      ],
      "metadata": {
        "id": "uq8vBierl1QY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a dataset \n",
        "dataset = tf.data.Dataset.from_tensor_slices(\n",
        "    (encoder_inputs, decoder_outputs))\n",
        "\n",
        "dataset = dataset.shuffle(len(input_data), reshuffle_each_iteration=True).batch(\n",
        "    BATCH_SIZE, drop_remainder=True)\n",
        "\n",
        "dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)"
      ],
      "metadata": {
        "id": "UEgmqHfrl_Wb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Building a Transformer**\n",
        "\n",
        "### 1. **Scale dot-product Attention**\n",
        "\n",
        "The input consists of queries and keys of dimension $d_{k}$, and values of dimension $d_{v}$. We compute the dot products of the query with all keys, divide each by the square root of $d_{k}$, and apply a softmax function to obtain the weights on the values.\n",
        "\n",
        "\"Attention is all you need\" paper\n",
        "\n",
        "Then we use the $Q$, $K$ and $V$ matrices to calculate the attention scores. The scores measure how much focus to place on other places or words of the input sequence w.r.t a word at a certain position. That is, the dot product of the query vector with the key vector of the respective word we're scoring. So, for position 1 we calculate the dot product (.) of $q1$ and $k_{1}$, then $q_{1}$ . $k_{2}$, $q_{1}$ . $k_{3}$,… \n",
        "\n",
        "Next we apply the \"scaled\" factor to have more stable gradients. The softmax function can not work properly with large values, resulting in vanishing the gradient and slow down the learning. After \"softmaxing\" we multiply by the Value matrix to keep the values of the words we want to focus on and minimizing or removing the values for the irrelevant words (its value in $V$ matrix should be very small).\n",
        "\n",
        "The formula for these operations is:\n",
        "\n",
        "$$Attention(Q,K,V) = softmax(\\frac{QK^{T}}{\\sqrt{d_{k}}})V$$"
      ],
      "metadata": {
        "id": "pq8XtYbXHCwW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def scaled_dot_product_attention(queries, keys, values, mask):\n",
        "    # Calculate the dot product, QK_transpose\n",
        "    product = tf.matmul(queries, keys, transpose_b=True)\n",
        "    # Get the scale factor\n",
        "    keys_dim = tf.cast(tf.shape(keys)[-1], tf.float32)\n",
        "    # Apply the scale factor to the dot product\n",
        "    scaled_product = product / tf.math.sqrt(keys_dim)\n",
        "    # Apply masking when it is requiered\n",
        "    if mask is not None:\n",
        "        scaled_product += (mask * -1e9)\n",
        "    # dot product with Values\n",
        "    attention = tf.matmul(tf.nn.softmax(scaled_product, axis=-1), values)\n",
        "    \n",
        "    return attention"
      ],
      "metadata": {
        "id": "cEHuWK735Kpr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. **Multi-Head Attention**\n",
        "\n",
        "In the previous description the attention scores are focused on the whole sentence at a time, this would produce the same results even if two sentences contain the same words in a different order. Instead, we would like to attend to different segments of the words. We can give the self attention greater power of discrimination, ***by combining several self attention heads***, dividing the words vectors into a fixed number (h, number of heads) of chunks, and then self-attention is applied on the corresponding chunks, using Q, K and V sub-matrices.\n",
        "\n",
        "This produce h different output matrices of scores.\n",
        "\n",
        "![dor_product_multihead.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAnsAAAFbCAYAAACtcEg8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAAJQxSURBVHhe7Z0FeBRXF4Z/qLdUaAulQqG4u7u7u7tbCBqc4O5OcA0uIQQJEAgW3N0JBLeWtrTl/POd3ZnsbibJJtkkK+d9nvNkZ+7M7MzJnXu/vXLu/0gQBEEQBEFwWkTsCYIgCIIgODEi9gRBEARBEJwYEXuCIAiCIAhOjIg9QRAEQRAEJ0bEniAIgiAIghMjYk8QBEEQBMGJEbEnCIIgCILgxIjYEwRBEARBcGJE7AmCIAiCIDgxIvYEQRAEQRCcGBF7giAIgiAIToyNxN4benjkBj1+b9y0Q96/PktHHv5l3BIi5P0junIkhP40bgqCIAgOjJTpLk8Uxd57end/Ec1o/h0l+t//6H9saSlJuVKU/auxtOYf42Ex5d1VOrNpCE3vX5Qqf1WI6h55Y0yIKn/SowA38mj6I6X+X2rKtOaucb8p/9Hbq/Np4ci8VCKR4ZkS5KpEGXNnpJr5PzU8X8UOVG3mNvJ7FNtiEfcyi+b0TEtp2bc/0lclalGtckmU+09EnxRsTCXH+dLB1/8aj7ct70OW0Wy3HFTytwT0v2br6bxxf/xzkXybpVfywUvjtv3y/v5I6pAqIX3abguds+MfP4Jgj7x/tJnWTqtP7Qt/ZKhfCk6gNX+E/yK9v+1BDdVyu3gnajzdnw69tebFe0OPT86hZePqknvlr+nTsccpwtL9/Qna0uYr+l9adxp9/51xpx469YnZfT2h6359aGLzpMY6NDklaTGWeu64TrFRusWsTJdy15mImtj7Yx1NKfERJWyyhPxZcLyjN1dn0OQGXyqZtj0NCbaR2nt3nc4HzCav1omU65aIgdgDb+jGwgzKdcITeyonaF3jT8Ie9+4ynVxeg+qnUV6WtI2pnv+9aP46ekKX/K5Z90L/s4bGp0ZBYPLs7y5R0JTsighMRJ82WUZ7rCrQos776+5UHYVQrIg9pSC84E9HonjvKNAbJEhAn/XeTbeN+/TR83H0vtM6wl77/aPZNKjAZ5R0gD9dlUJHEKLBW7qzPKtS/qEMLEQldz4i/VfpMZ2e8IvxuJSUdvmtcI7T4w09Or2B9s/MTT8q538y9pi52Ht7nPwumdQ77y/SPo+fKWGJkTT/kRX13PsjtKrOx+He1/s7HlSf77sledyJSDzGnOiW6VLuOhdREHv/0KudpZUXI6xoev9sLg34uj65X7dly9djOjY6ifIyxFTs/UUPvHMp14mm2GP+oz8v9qQWEHyJ6lLTEy+iUKiAd/TqcCNKVnuddS+bntgD7/fT0qr4xZudCvqEGHfamOAh1CwaBYM1vH+1gkYnaxXFHwVP6fy035RnVu4pcUcaci+8glHfx9H7TuuIzWsLguuiltkoA/9HCRqsouN6Be7vS8nzyy8pZ5aEynGRle/6/HOkLqVWvsNc7N2moBHpKEs0rhdKRPWJglrO2rKRJDyiVaZLuetsREHs/U2PN+anRP9LRJ91205XzF4+JWNMzBdDUWaJPYk98JaCV+ehxBEVPrq8p3f3RlP3dFFoRg9P7Gk+0fklaitiS+z9c4y2dE6s3HsUC7c/VtPo7xpQnx74Bf8jJZtxTvlPWBKOj6P7ndYQm9cWBJfGUGZ/3Kmn4Z3+XwWlHDRvN8IxjzYWokS9Z9DMRhGV2xETVuy9puANxSlDNK8XioOLPSl3nY4odeP+d82davA4hAz066CtEY4de/96N20cUISyNnSjIW6ZKHHixlR37UV6xCLpPf1zby6Nq5mJcnXqT0M5vT25nzFtMQtH7L07S4HTylDp1EV4TF2CPK2piVnXKrqWJ9O4KqkpS9ce1CZTcWpR53vlOjEVewoho6lDYjx/49BWzHeX6Oi8ilQibX1q3a0IVf46PaXusYCW3Tfc0ftna2hRj0yUGy9b7mZUvkdvarH9NkWYTcMVe8F0eOh3yv4f6cfpe+jkFg8a1zEtfdVoKR31q0ollf9NgnKzafvfihcjuS+N1/tp28jclKKaG/VtlY1K1MxAxdSC4f09OrmiLjVFi6b6cr09RP6zqhq6tS1euPD+5y/f36CjcytRk5z4BV6QMrkPobr9/ejEf8YTw+VveupTgr7sH0Av1bE5WUbRMosxPLo+3naEDoX3nRHloXeX6cTKrjS8A/zqTRfPeJAbjx/6kb5uvYy2I8+H9zz/vqJbe0bTrD65KKfZGFalUAzxpkVu2ShtHTfqr1z7669rULmpgXT+HZ7lDT0KGkczeIxqWxp88Sit7JiMx/QkyNPV4r0QBGfHIPY+GbuDDo36SXnHEoXtSvxvHy1OmVIpH0+FKbffP9pEaz2zGMY9swh5bxhH1z+9yT4D5mLvHT0/1Jv614WYSExfNehLdeuOppm3/qA3N1bSuonVqFnSwhZlcnhEU+xFVr+9O017RxakdDW7Ua9epalu4iyU2+uMsV41ElGZbjwkYqTcdcZyN4oTNB7TZa9cxskDcEhrarz5athZuG930KKaP1Nu7xuGf+T7M7Sl7RfKOZWpyUnlRfl7K80qpfwjtcx3mwL6Ky9Ykdnkp+lHHbH3/jodHJiOsi6/bswggbSqyWf0v0SNqNOl33EAvbs1hNp+WoqqBz41/KPeHaX1bTD2zwZiL0w36m0KGpWCPmzuTcf+MTjh/eu1NLXSx5Sg5Fha+sz4MFH9ZRWe2FN+bY3Pr2T0RDWoztKNtHpiQcqL66YsRrknr6M1A1PRp8Wn0abfH1t3X+8O0bqWiSmx50F6yIe9pvve+XkMS+i9qn4xLZR09kX2P9e9TiS8P0ZrFNFu+FV/kfy6YGyoUrhtuh/2JdT1sc53RpaH3t2k6wfdqP2P8GsRyjJsGx189ZQuzc5Gif+XklIuvmIU6mGv/f7RNvJb1ZDq4wdB6vFaoYNuh7EFvqIs6ncqlcrr4y2paoKfKOnQA3Tn/V/0+MoyWsJjVFPS1w0n0KSrL+jNBTdqplwrQY0ldDBSYSwIzoIq9o7R32oDg1lX4n/0x5H69G3pxcp7cdn4HlqU23rlgc6+sC17Oj1B76/S8U1DaHIdTNiz/AEeHmr5EAWxF2n99oTOT0uliBH1nP/o970VKfn/qlPrs3/gDCvL9EiQctcpy90oij3wmoID2lG77B8qDkJmhfL2Iu8QtVPR0N2ZMJPpL4G/6fn+FpQly0jyClFe2NcraFyRj+nTXrvpDqerws4kc+iIPbQsVk/YhUY/UhWhOpA3ESXCy/r+Mu3u+S39r/pSOqTlSlt14wLTY+7Qu4udqXqCrBbj5/CrqLjyciWmbyefIryi+i9EBIQRe2/o8akpNLcdfnVkoBQTjxpeZPW6Zs+rCF6r7usferajHGUwbaUEYe5V58UNs8+K/7nudSJCeY6zbShZspnkx7/ClAI+sAZlUe5N9yW0stCJLA9xTlP9b1JwqNdP0H4rXeUd4TxPmHOf0eU56SnBlz1p0lPtl4yCWoiqYlivJdv4HYm6mtyvIDg7oWLvH+09MSlP6SYF9PrVKD7U99Ci3NYrD3T2WSX2mHB6msJFvS/l+yI068umv5TaMmjEr5QgTX+aafzBbrh/9V7/trJMjwgpd5213I2G2DPy7iwdnF44dHp5mUnk/QqOOUtb2yiK3aqMpfD6IO2ZX5uas3g0/Qda/hNe0ZU5qZVfeJWpYL+BVLduXTOrN/8kvX46idwURf7x8MOKJFWxodjTZljlphI77hnuR+/lfzSa2sMv5RbQXrwcUXrZFDSxF2oIB5Op0QDq7nMttCVV97pGP0V6X/fJr7PyiyblSFr2p6YUda6p93JZ7rPmfx7OSxouwXRsxG+UbvkNpbgx8vdGmloQTfg6Y3isKnQiz0OPcFoEhU7EflGwPPe/3bSgtJK3Ta/FqGNgf6Qf511SnjGCQsdqnwmCMxAq9v5SxAda8Qri3cswkGYqFff7e0OoyZcjjD8s1XfEXsVeOPWJei9RLZtU3j+kazv60qgG3ypliPodl6ws0yNCyl1nLXejL/aYd/T6TDfDLFVjU+t/qtPrr6YTJvktDDyuIA+lbTmLZl29Z3S4qXMt/wnG7R/70cyXlj8vDPx7sgnlNHtxgQ3F3u9eNCi58myJWpHH7afG+ytC1Q5YvACWGS9MhlXvSdmnmcn3qudHVrDovmiq3yK5r7/8aUoO5f9m+TJY9XJZ7LPqfx7FF+jZDOrLg7PhB0vTGcNjVaETeR5iLP9/ILqFjrptWQArmFY0/7hQoSMIEWMq9hT+20dLq+JHdgbKuuYCXZqdiX7UJgyo74hFua1XHujsi77Yi6QMD+++VNR7iWrZpIi865sbU/m0Hajjtmv0wrRl799NVpbpESDlroJzlrvWiz0lI41PMYk2Y/C/GSZTtJV/yL1/fWl2YeVXgN4/9v0zuodVLN7uoCWNv6QP3fzoFl9Odbipcy3/CU/p1AQM1lWbX01RROcJP7riX5v/iR/29qcHxhTbib139HJPFW7OTthiPZ19/5cxfl9ySrHoWuivIGDMaAlarDMEeAyTYd/TPyH7aPOaNbRGs920V+0KVzNqtMSeGlcw4vu69874HZb/J6teLot91vzPo/QCvaVg77yUaEAAPTTuUdGCqFqGA7Cq0Ik8D3HsJsuCA0S30NHGeVp0rSgYCp20lGXNbSVHuE6hIwgRYyH2tCEoynuVuwIVTdzO5N1X3xGLcluvPNDZF32xF0kZHt59qaj3EqWy6RWPmU/+YS+a9NRQHhju3/gdatkTaZkeHlLuGnDOcjcKLXuKA+omNhnsqKL2vRvGVPxF9+jQEDgvLaWddspkltBruu/bjOrvCKZnPkUpsZkYsUbsqXH+lF8XXbfSWR5PYOD9s4XUq+hKuvnY0I1rPnPINmIPgz3Hl1AyT6L61PqsoZNYnZ1sGYrFEDATv0LvGJ7P6pfNiJpxoyX2rLuv92qTv/Id1Q68MB6hYM3LpXVnq/si+5+HKN8XhRfo3TaakayA8uwWLZOMOubCIhyAVYVO5HnoGP5htix0FB/cWJiRu1rMukbU90YrPEXsCYIBS7GnoE5OC9O6pL4jFuW2TnmgBTI22Rd9sRcZ4dyXinp/USibtPrNZIy2mdizukwPByl3DYc4abkbBbFndEqiilRhx11N8L1/vYlmYZZShr40KQSOec8zYjtw124G+qXdOHKfNYO8BmenZC3W0fF3/xr/8YoYqTqOJgTsJf9lxhUq/teQOh4+TzuuYxiuzj/h7RaaVQki40f6uuEI6j57Li2bXpNqJ2tB7heVY95fV0THL8o/2ER0vL9Dx0b+qpyTnH6de9FCqJoSzsuJZnPfDtQN08BT16bqfqHPTu/v0anxqZXvKxc6+5ce0fmp6egz01Uu1O7fgmNp2dO7FDhwI+0z+XEUhj+X0YiUyvF6XbGmhPcSW3Vff9PzA3U4XEvCevPJV10R5WgjKolrVltAe/mlVKPUp6XUIzbRup1LaMvY0lSnEP4P2Sl1r6W05tG7SP7nuI5xxjXfUzCF7B9Dky8ahlubYxhk/PPHI8I0vxtQZ6Ap92gcw8Po+vhx2O88uj3iPASsKnTCeR6dc9WZ0HxvPK5VQcnLM4p9R1kWXDBGnhexJwgGDGO8zHtoDAPuE1mOGwtvpQp1nFnihlR34346sHssTe2agUpALKWtT+XnHaXrysFhxZ5avmBG6wF68tCbBnpfxkivqIm96KygEVn99nIm9cFs1US1qe6mQDq4fQANqwlxh7rtMB3bcYXuW1Wm6yHlrog9DUURL8tBX5UoS8V/S8ATBipX/oVyJUinVO6zyeueaVPpO3p9YTh5VvtaeTmVf0CiQpRlzPbQuHxvd9GKVsb1dVNXp5LzD9G1gPpUMkEC+qTSaJp5+RT5z29mEFhKRk7afQ6NCXqkZDdDfL7JPChVOVfJOF9VH0aeF16GvkyIQzQmO+XBtQpWo7Rpm1Cf1smU7ylJmdoNp16HQkxUPvgvnLVxc1O9El8p36N8R5n2VG3iBtrM3ZEWvA+myyurUzXEsevQh7rUykWFlAy/R31WxiRkTYRLruFeTNfGTUSf1hxAHWfttljv0XjPatyoxDWo/Cxv8rpiUghZdV+v6f7uZobJMalLUOpcxalqxzxUQhF2SWq5U91ZR7hAfP96C3k1xq865btY8J6nQyN+VY7pSU3m7qFDxkIlwv+5cs/aKiSKSEw7Yg+dC1PwPKEb21tQO8RRwjPNVq5t9tx/0uOjk2jZgLQc3Bp5I0mHmTTzKp5bz8fvdb8zwjz09hDtnVaCC8z/JapAJab504XrG2iN+p1pW1DdFScUv1heezddPudFK0blNsSd4nM302ZFCIP3r3fRuv4Z6Ouvq1HxLk2pYdamVE+LO/mEru/qTL2Lqvl9Ps2/fJVOrqhOdVE5/S8nZfJcp11LEJwVxMjznlye6uC9SlSSco9cQvP5/VYIGU21Myw39lbolNtma9Aq5ZE2njyRoV65tYHGfKW8Sx3HkseO43Rs+0Ca3s4YV61kH+q4+jiXd+owIy5/60xW3sWT5O/VyFAumdVHekR2XxGtjRtZ/faYLi0pSHn5usqP6u5Lae/luTQO5YaxIUJ5aqvKdHOk3HWFcjeGEzQEQRAEQRAEe0bEniAIgiAIghMjYk8QBEEQBMGJEbEnCIIgCILgxIjYEwRBEARBcGJE7AmCIAiCIDgxIvYEQRAEQRCcGBF7giAIgmAnzJw5k/75R4KoC7ZFxJ4gCIIg2AF//fUXffzxx+Tj42PcIwi2QcSeIAiCINgBu3fvJqy6UaxYMeMeQbANIvYEQRAEwQ4oUqQIiz1YcHCwca8gxBwRe4IgCIIQzzx+/FgTerAKFSoYUwQh5ojYEwRBEIR4ZuHChWZiD/b8+XNjqiDEDBF7giAIghCPvH//npImTRpG7C1YsMB4hCDEDBF7giAIghCPbN26lUaPHk3dunVjkZciRQo6f/48VaxYkYWgIMQUEXuCIAiCEI+8ffuW/06fPp3FXsqUKXkbiNgTbIGIPUEQBEGwA/TEniDYAhF7giAIgmAHiNgTYgsRe4IgCIJgB4jYE2ILEXuCIAiCYAeI2BNiCxF7giAIgmAHiNgTYgsRe4IgCIJgB4jYE2ILEXuCIAiCYAeI2BNiCxF7giAIgmAHiNgTYgsRe4IgCIIQBa5evUpjx46l7t27k5ubm80sY8aMLPY+/fRT3fSY2ogRI+jKlSvGpxBcCRF7giAIgmAFf/31F+XPn58FmSNbvnz56MmTJ8anElwBEXuCIAiCYAVly5bVBNOvv/5Kbdu3p67d3RzCOnXpQhmMLYewn3/+WZZicyFE7AmCIAhCJPj4+LBISpgwIfUfNIjuPLxPIc+fOJQFPwmhvv37aYLP19fX+HSCsyNiT7CaN2/e0Llz54xbgiAIrkOyZMlYIDVo1FBXSDmS1ahVi5+laNGixqcTnB0Re4LViNgTBMEV+eeff7TWsBlzZusKKEeyWfPm8rN88803xicUnB0Re4LVeHl5Ub169YxbgiAIroGp2Js9f56ugHIkm7fQS8SeiyFiT7AatRvj9evXxj2CIAjOj4g9wdERsSdYxenTp7XCrl+/fsa9giAIzo+1Ys97wzqaNG2qbhqsdbu2dPHaFd20uDQRe66HiD3BKlKkSKEVdh988AH9+eefxhRBEATnxlqxN27SRGrZpo1uGqxYiRJ0+sI53bS4NBF7roeIPSFSbt++rRV0qsmUfUEQXAVbiT17MRF7roeIPSFSPDw8tIIOliBBAo7ALgiC4ArYSux179mTLl6/SuevXKQJUybRrr3+VK1GDSpUuBB1c+9ON+/d0Y69F/KABg/zpOIlSlDFypVo9ry5Whri5Y2bOIHKVSjP5/bo3Ytu3L3NaafOn6UOnTrS/sMHqVnLFjRwyBDtPNVE7LkeIvaECEEhV7duXbpz545W2O3fv596KoXWw4cPjUcJgiA4L7YSe7+lSkUnzp6mfYH7KfmvvyqirBNdv3OLhV2/gQOoTbt2fNydh8GUO29eGjl2DN0NCaart25Q67ZtabxyfaR7jhxBvfr2pVvB9+j+44c0SjmueImSnHb4eBBly56d6jVoQAeOHNK+29RE7LkeIvaECPn333+Nn5TMYizsHj9+zNumaYIgCM5KbIi9zz77jK4bW+NgV2/fpOw5c/Dn5atXUuUqVbQ0GARgwUKF+XMrRfhdUQSgmnbuyiX68MMP+TPEHu7zzMXzWrqlidhzPUTsCVajFnaq2BMEQXAFYkPsZc9hEHamhhY5/O3t0ZdKlS5Nvfr2NrOff/mFbj8wLNN28foVWrtpA99Pm/bt+d6wH2IvU+bM2jX1TMSe6yFiT7AatbATsScIgisRG2IvZ65cYdJVsde1ezdq36kjbdiyKYzdf/SQ3Hq4c5fv0lUreGze6Qvn+d5wLsSe3rVNTcSe6yFiT7AatbATsScIgisR12Jvyozp1KJVqzDpmMRx495typsvn9n+42dO8b3hs4g9QQ8Re4LVqIWdiD1BEFyJuBZ7iMX3fZIktMlnq5a2dOVyati4Md26f5dSp0lLN+8bZu7ee/SAurh143sLfhwiYk/QRcSeYDVqYSdiTxAEV8JasQdBhlAoerZ63VqqXbcOT6YIOnmcw6JYnt+kWTPtM2bSlq9QgQoWKkSFixShWnXq0NXbhkkZE6dMVoRhDr5uufIVaKufL7VSRGaffh4cekXv2qYmYs/1ELEnWI2IPUEQXBFrxZ6jmIg910PEnmA1IvYEQXBFROwJjo6IPcFqROwJguCKiNgTHB0Re4LViNgTBMEVEbEnODoi9uyA9+/f0969e6l27dr07bff8gtoj/bpp5+yffXVV7rp8W3wXa1atdiX8KkgCIItQHmCsg8CCQGP9QSUI1nPPr35WX777TfjEwrOjog9O8DT01P71ShmG4NPBUEQbEXbtm25bEma9Ae6cvO6rohyBENMvs8//4KfZcSIEcanE5wdEXvxzK5duzSB8t13SahGtYZUq0ZjsWgYfAcfqv6EbwVBEGzBy5cvFZH0OZctv/2WiqbNmkknzp7hNWgdwU6eO0MLly6h1GnS8DMkTJhQhuS4ECL24pmkSZPyi/f990lpy7ojdHDPLbEY2JZ1R9mX8Cl8KwiCYCvOnz9PH3/8MZcvjmwQen5+fsanElwBEXvxiOmg37q1mumKF7GoG3yp+lUQBMGW3Lt3j9KmTauVMY5mhQsX5mcQXAupDeMRU7HXollnXeEiFnWDL1W/CoIgxAa///47Xb58mS5dumQzO3jwILe6DR06VDc9pvb69Wvj3QuuhtSG8YiIvdgxEXuCIDgigYGBXG5Vq1bNuEcQbIPUhvFIbIm9gF3XaPqkVbRmeYBuOmzVUn+aO2O9blpktmnNYb7+gd03dNNh82dt5OP00ixt3cr9tHX9Md206JiIPUEQHJGKFStqZdejR4+MewUh5khtGI/Eltjz23KKr5k7VwHd9AP+Nyj5Lynphx+S6aZb2vpV+6l2zabadg+3IXz9mVNXmx2n2orFO7krold3T910S2vZvAsNGThZNy06JmJPEARH4+3bt1xuqmWXu7u7MUUQYo7UhvFIbIu99Okz0bZNx8OkL5i7mbJly2m12FuxeAdlzZpT24bYw7VNBaCpVa/agK8vYk8QBME6vL29tXJLNRljJ9gKqQ3jkdgWe+3b9qRe7sPDpDdu2I569/A0E3t7/S7RkAFTqFVzN+rpNox8NhhEIrpXB3iMp1S/peWuW78tZ1js1arRhDJlzEYBO69q14Dhu7/55lvq1rm/JvbQnateTzVsr1m+jz+L2BMEwdX5+eeftXJLtVWrVhlTBSFmSG0Yj8S22Fu/ej/lzVPILA2iLkP6LOS9fI8m9jZ6H6S0aTOQR+/RLOiGDJjMQm6373laumA7C7ukSZOxEFy38gCLvbq1m1PLZl1ooMc4s+t36zyAmjfpRP37jtXEHv6OGDrD7Ljhg2dQo/pt+bOIPUEQXBnE7ytYsCA1bNiQy61kyZLR0qVLqVChQsYjBCFmSG0Yj8S22MPf4sXK0colO7S0wQMmUqMGbWntyn2a2HPvNoQ6d+irHQODwJsyYSl/1uvGhdhbusCXUqdOR4H+N7W0HDnyku+mEyL2BEEQrCQkJIT/Tp8+ncutlClT8vZff/1F//33H38WhJggtWE8Ehdib3D/STyGDvsxezZtmgw8Zs9U7O32vUB7/C7x5x1bT9OyhX6UPVseFmTYF57Yw0SP9Oky8fWwf9nC7VS0SBn+LGJPEAQhaliKPUGwFVIbxiNxIfb8t1+kH5Imo63rg2j65BWUJ3dBPsZU7K1e6k/ly1Wn+nVbUNtWPWjMiLlUpVKdSMUePo8fPV/7XLJEeRo7ch5/jkzsDRs8XcSeIAiCCSL2hNhCasN4JC7EHrbRbdvbfThVrVyPJo1byPtMxV6RQqW4NU89H4aZttaIvQO7r1OG9Jlpg3cgJU78Le3bcZn3W4q94UOna+fzPndPEXuCIAgmiNgTYgupDeORuBJ761cfoHx5C1PmzNlZnGGfqdjLlDE7+WwMDWq8a9s5SpkitSb2Vi7eSRkzZtHSTcUerF6dFlSieHlq26q7ts9U7HkOmkqtW3TT0iAIs2XNJWJPEATBBBF7QmwhtWE8EldiD5YndyFq1qSTtm0q9tq36UlpUqengR4TeEZurpz5qWnj9pQ/X1HasPogj+P77LPPqEihMrR84Y4wYm/2NG/66KOPzb7PVOz5bTlNSZIkpS4d+3H3bamSFalf35Ei9gRBEEwQsSfEFlIbxiOxJfbU5dLwV93nvWyvWaw7TMhQl0vbv/s6TZ2wlNq0dKee3YcpAi+Q9my/qFxjpSLUzvAx2zef1OLsIW4erqdea7/yPV6zNmnbsC3rjpotl7Z62R7q2rE/dWrnQSsW7WRhuMRrG6fJcmmCIAgi9oTYQ2rDeCS2xJ6rm4g9QRAcERF7QmwhtWE8ImIvdkzEniAIjoiIPSG2kNowHjEVe2osPLGYG3wpYk8QBEdDxJ4QW0htGM+kSZOGX+7PPvucV6TQEy9i1ht8CF/Cp/CtIAiCoyBiT4gtROzFM8eOHeOXG/bJJ59S4UKlqGTxSmLRMPgOPlT9GRQUZPSyIAiC/SNiT4gtROzZAZ6enppAEbONDRkyxOhdQRCE6PH+/Xt6/Pgx3bt3L06sY8eOXH4lTZpUNz02LDg4mF69emV8YsFZEbFnJ+CFmzVrFrm5uelazZo1dfe7ijVs2JBatWqlm2Zq8CF8KQiCEF3++usvGjVqFH3yySdhfkg6qxUtWpQuXLhg9IDgbIjYcxBWr15Nr1+/Nm65HgEBAfT8+XPjliAIQuwQEhJCX331lSaCEiZMSMmS/eC09vXXoc8KGz16tNETgjMhYs9ByJkzJ/Xv39+45XrUqlWLvLy8jFuCIAixQ/78+TWR16d3M3ry0Jf++3ufU9uhA16UOlVyTfA9fPjQ6A3BWRCx5wA8ffqUX8APP/yQw7W4Gi9fvuTnT5YsmXGPIAiC7YHIUQXP2NFddIWRs9q1y96UOPHX/OxTp041ekRwFkTsOQDz5s3TCiB0Z7oavXr10p7/9OnTxr2CIAi2Zfv27VzOYC3wP17t0hVFzmwD+rfm55ewVc6HiD0757///jMbP4IuBlfizZs33J2iPn+KFCmMKYIgCLZFDX2SI0dmXTHk7LZy2WB+/m+++cboEcFZELFn52zatEkTOqq50kQFb2/vMM9/+/ZtY6ogCILtUMVezpxZdMWQs9vqlUP5+UXsOR8i9uwYxHj6+eefzYQObMGCBcYjnB9MTEmQIIHZ83t4eBhTBUEQbEd0xd6fb3bT3t0zWCxdvbRG9xhHMBF7zouIPTvm7Nmz5O7uTsuWLdOEDlbcqFq1KnfvOjuIlzd8+HA6dOiQ9vwIAoqYe644UUUQhNglqmLv3ds9NH1qL8qdOxP16N6QBg9sQXXrlKXKlYrRtUveuufEtT24t5k2bxirm2ZpIvacFxF7dowq6C5duqSJnT///JP3uYLYUwUdItirz6/iCs8vCELcElWx169vC2rUsCK9ebHTbL+vz2RKkuQ7unNzvdn++LDTJ5ZSuza1dNMsTcSe8yJizwHQE3uuhJ7YEwRBsDVREXsvn+6g1KlT0NvXu3XTG9SvSDOn9zbbd+zIQhZUwXe3mO1XDa2BSD93erlu+oF9szn94b2tYdLUa186v9Jsv4g9AUjt6QCI2BOxJwhC7BMVsbdx/Vhq3y5iEfXvX3v575OHPlSubCFq3KgCd/WWLl2AOrSvTW/fGIQiYoh6Du1CrVpW5/RiRXNRwwYV6e8/9nB68J1NfH6bVtU4vVTJ/DRzWi9Oe/V8B1WsUITat63FaeXLFaLmzaryuQu9BlGe3Bnoxx+/p+LFctCJIC8+JzwTsee8SO3pAIjYE7EnCELsExWxN3Z0J5ozy0M3zdIg4tasHqVtY6wf9o0c0ZG3IfbGju6qpf/1uz+lSZOS9u+dxaItZ85MZuf/+caf9z0K9qFZM3rT9CkG4Qf758+9lDbtb3Ty2CLelpY9AUjt6QCI2BOxJwhC7BMVsTdiWDuaP3eAbpqlZcyYjkWY6b6Q4G2UJ7chnh/E3vUr68zSa1Yvxq2Hp08soVSpUoQ5/8G9rfTmxS5ezu3189Axg29e7qRff/2Z/HdO4W0RewKQ2lMHDP6HqLIXw6oZiOj+6aef8gxVvWPiw/766y+jx2IXEXuCIMQFURF7y5YMpT69m+qmwU4cXcCzYF882UG5c2XSPaZgwXz8F2Lv/h3zcXx1apdgsYdrlCtb0CzN1F4+86OhQ9pSl84NqE+v5jR4UFtKnz61iD3BDKk9TUBcu6FDh/IatKq4EIvYsLrH2rVrjR6MHUTsCYIQF0RF7AXf3Uw5smfkLle99EYNK9G0KT24yzZTpnTa+D3Vnj3erojA0Ja98MRe0GEvypQxbZjzIQJvXF2jfE8F2uU3zSwtX97sIvYEM6T2NPL3339TgQIFNFEhFjUbOHCg0ZO2R8SeIAhxQVTEHgwTITz6tgqz/3DgfEqUKBE9CdnG29WqFqeAPbPNjhkyqC31dG/CnyMSexCTP/2ULMz5hQvlUq7vSzlzZKDfX4au43vn5gbuBTIVe21a19TSIzIRe86L1J5GTBfbz5YrO7Xu2lYsEmvUpgl9+923mt9Onz5t9KZtEbEnCEJcEFWxh1m2dWqXoZo1SnJLGwTW1Mk9KFfOzLRn10ztuDMnllCePFlp3hwPPgbx+bJnz0B3b23g9IjEHj7v3zubz1+2eDDt3D6JZ97272cQmW5d61ObVjVol98kRawNp0YNKlH1aiWpa5d6nH7/zmZKmzYlz9S9cWW1dn09E7HnvEjtqYDuW4yJQybPWzgfHbl7jI4/PCVmhe29tJ9+S5OKfVe+fHmjR22LiD1BEOKCqIo91SDGOnaozQJtuGc7evrIN8wxt66vpT69m/Exc2b3N+v+3bRhDP3+KrR1DhYYMJPu3QoNyozzuykCDucvWzxU24/rTJrgzvv79mnOrYmPFRG6avkQ7Zhzp5exkHt4f5O2T89E7DkvUnsqYLKBKiaGTR2pK2rEwrcm7Zux7zDWMTYQsScIQlwQXbHnLCZiz3mR2lPBVOyNnj1WV9CIhW9NOzTX/BcbiNgTBCEuELEnYs9ZkdpTQcRezEzEniAIzoCIPRF7zorUngq2EnvbjvvRgHGDqF3P9jRkkif5HNuue1xEtu/yAZq7fj7tOr8nTNqKnato+Y6VYfardvDWET73wI1DuumxZSL2BEFwBhYvXszlTOrUKXXFkLOb17x+/PxJkiQxekRwFqT2VLCF2Fu505t+/S0FuQ/uRWPmjaP2PTvy1PuRM0brHq9nh+8EUZp0aalUpdK02GcZuQ/pSf7n92npOfPmoi+/+ircCSQeowbwM6zZu143PbZMxJ4gCM4AIgqoZc0+/1m6gshZ7c83uylvniz87A0bNjR6RHAWpPZUsIXYK1C0IK3bv9Fs3+bDPpQ85a+09/J+s/3h2arda6hW4zradpnKZcn32A5tG2IveYpfafqKWdo+1Y7eO85pqdOmEbEnCIIQDf7991+OUYeyJn363+jerYhnrzqLYSm2bl0baOXsgQMHjB4RnAWpPRVsIfbSZ8xIxx6cDLN/2NQRZiIQQgwtdl36daUVO1Zr+7cG+VIPz15UsmJp7opdtHUJ5S6Qh8bMGU8rdhmOg9jr1LsLla1aTjtPtanLplPhkkWocu0qZmLPe+86/j50Lc9d58X7cJ8LtyymQ7ePasepx/qeCBWX1pqIPUEQnIVVq1Zp5c3nn39GNaqX5KDEzmqtW9Xg5dzUZ86fPz+HIxOcC6k9FWwh9nLmy0Xj5k3QTVNtniK2Uqb6jQaOH0zDpo+gDFkyktvAHpw23msS5S6Ym5KnTE5lqpalOk3rUtIff6AipYuyUMMxEHvj5k+k7Llz0IHr5uPyKtSoSPPXLzATe8t8V1CmrJlpyGRPGjFzFOXKn5u69e/OaU3bN6faTepq56/dt54yZM5IgTcOa/usNRF7giA4E/v376fvvvtOK3dcwRIkSEDdunWjd+/eGb0gOBNSeyrYQux571lL2fPkoDTp01C1+jXIc+pwbq1T04/eP05Zsmc1m7Sx52IAj/Nbsm05b6NFr37Lhlq6XjfuOEXsde7blXoP66vtD7gaSFlyZKWg4BNmYq9CjUq0LiC0VXHzIR/6PkkS/gyxCIE6Yvoo2nlmt3LfaWnuuvnasVExEXuCIDgb6NLdvHkzNWrUiEqUKBFnhmU79farVqxYMd39qhUvXlx3f0Q2evRoCgkJMT654IxI7algC7GnGiZUDJ08jIqUKsrXq9u0PouwRVuWUrlqFcIc33/sQGreqSV/tlbsrQ3YQD8n/4Wvi/19hntQ+54d+LOp2Nt5Zo92DGzVrjV8T+o2Zv6mTJWSSpQvRT2H9Nb2R9VE7AmCINgGLN2JOik8du3aFWHr2/Xr142fBCEUqT0VbCn2TG33ub1UpHQx8pwynEOxNOvYIswxq3auoZoNa/Fna8UextyhVW7h5iV0+M4xFn5r9hkEnqnY23JkG7Xo3IqatGtK7Xt0UqwjP6N6PRhaCVOlTa073tBaE7EnCIIQc/766y9KmDAh+fn5GfeY899//1GrVq3ozJkzxj1hWbduHT179sy4JQgGpPZUiKnYGz1nLFWpW003bcrSaVSvRQOas2YeVa5TNUz6iBmjqVGbxvzZWrGHzzNXzqHqDWrSpEVTqFSFMtoxqthDtzHG9m0/tVNL231uHz+juu3tv47H8TVs3UixxmatgFExEXuCIAgxx9fXl8s5TJLQ49atW9SkSRMaMmSIcY85L1++pNWrV5O/v79xjyAYkNpTIaZiDy14yX76kYMaW6Z19uhKPYb2oiN3jvHkDNOJFRBkGbNmomnLZ/K2ntjzCfLTtk3F3rHgkzwGsHSlsrRg02LtGFXs7b10gLLmyqbth+FcPCM+77tygJL8kJRbBzErN2OWTCw8TY+31kTsCYIgxJwcOXJoZd3FixeNe0MZOXIkiz0YhJ0lhw4dYrEHe/v2rXGvIIjYY2zRjdt9UA/KVSAPDZowhGavncuhUNBilzl7Fp6IgWMQYLlg8ULc2jdj9WwqW6Uc1W5Sh0Uf0i3FXqM2TahctfI0ZIonb5uKPRi6aNNnzmDWBauKPezLmis79RrWh6/bb8xAat6xJX355Zc0cdEUPs50kgcmk2TKlpk2Hd6q7bPWROwJgiDEjKdPn2rlHCxPnjzGFAOop1ShB/Px8TGmGPjnn380oQdDgGhBUJHaU8FWY/YwRg6zWxEqxX1ID45rh1UxTI+BEFPj7C33W2WWhuDLGw5u1rZx7pJty7Q4e1guzXQZtd3n95odD1u7f4O2XBpm6WICCO5n8uKpFHT/BAd6Rgw/XNf0PBiE3pq968Lsj8xE7AmCIMSMOXPmaOWcahCAKseOHTMTex06dDCLh3f27Fkzsbd+/XqJlydoSO2pYCux56omYk8QBCH6IMzLV199xZMzUM598MEH/HfcuHHGI4i6dOmiCb2mTZvy36NHj3Iazvf29mYzFXzXrl3jdEGQ2lNBxF7MTMSeIAhC9Nm0aRN5eHjQ4MGDuZxLmTIl3b17l8fwoXXu5s2bNGnSJNq7dy+LvHbt2nFLXufOnfn8Bw8esPCDuFOFHloFN27cKK17AiO1pwKmu6tiou/IfrqCRix8q9e8Pvvu888/N3rUtojYEwTBmVEnW0yfPp3LOYg9gFArsD/++IO3MWlDFXsALXpIx3g9AIGnij0AoSdiTwBSexr55ptv+CVLkyEtHbplvmasWPi29agvfZPY4LuGDRsavWlbROwJguAKoNvWVOxZcvz4cTOxZ8nDhw/NxJ4gqEjtaWTGjBmaoPgp+c9UsUYlqlSrslgEVrxsCfrs88/YZx999BEFBwcbvWlbROwJgnOAVia1tUosrLm5uXE5B7Gnl46AyarY00u/dOkSrVq1ik0vXcz25iitp1J7GsE/q2rVqpqoEIuarVixwuhJ2yNiTxAcG1SK6Gr8+++/eYw0YsCJhTVMwkA5lyJFCt10iDj0oLRu3Vo3HStrLF26lE0vXcz2hmFgWL4OXer2LPqk9rQgKCiIXyYMjLUny5Ytm+7++LScOXPSwIED6fz580bvxQ4i9gTBMUHlB5GHSvHVq1e8jBfeZyy6LxbW0GKHci558uS66QsXLqQ6derwbFy99IMHD9LcuXPZ9NLFbGuPHj2iJ0+e0PPnz+nNmzcs/PDDxh6R2tNBwKwqFJauiIg9QXA8VKGHyQUQeZhdeuHCBZ5FCkMrlJi5oYsW5dxPP/2km44ZuZUrV2bBp5e+Y8cOTezppYvZ1tDQgZnS9+7dY/GHiTb2Kvik9nQQMIbD09PTuOVaiNgTBMcDFR66bFER7tq1i8ebrV27ViwCg5BDOZc0aVLd9N69e1OxYsWobNmyuulicW9oiEGLKkQfQuCgUQbDFeytS1dqTwcATcUoAD755BMeG+BqiNgTBMcDZRUmbaEy1KskxcKaiD3Hte3bt7PgQ32F1myM4bMnpPZ0ALD4tSp2Nm/ebNzrOojYEwTHAq0aaOHYsmULV4QQfMeCTtHVy7fp2tW7YuFYn94DuJxLly6dbvq6tVuoQ4fO5O7eUzddLG7t8sUb5L97ryb49u/fzz9wkPftrWFGak87B78OEKxYFTvp06c3prgOIvYEwbFAFy7GNKECRPftzev36emj38UisRHDx3M5lzlTFt30PbsPUd++/WnIkGG66WKxYI8jtifKMfv2HeC8jvWIb926xRM20JVrT0jtaedgGR1V6Khmuji2KyBiTxAcA7ToQeihVcPf35/Xat25Yxc9DnktZoUN9xzL5VwmRezppfvvCqQ+ffrR4MHDdNPFbG1vFDFnsIjEH37MqK17mLSBCUmYqGFP4/ak9rRjUGh+/fXX2qLYsA8//NBscWxXQMSeINg3qsDDhIzff/+dXrx4wV23iPfmv3sf3bvzWMwKGzhwGJdzGTNm0k3ftnU39ezRm/r3H6SbLmZre0LB957Sg/vPKeTBK3qiiD890fcg+Lkm9tCiLWJPiBKnT5+mli1b0oYNGzSxc+7cOSpTpozdzfSJTUTsCYJ9gnIIIu/169c8kQzhVa5fv85ruC5YsICmTp1K69ZtpNOnLotZYd3denE5lzZtOt305cvWUseOXXjMnl66mO3szOnLdPb0FTp/7hpduXSbbt54wMLv0UNF9KktfSL2BFug9vljCRxV7OCXMzKQvc30iU1E7AmC/YFyCGUUYovdvn2bTpw4wRMy1qxZwyvq9OvXj5f/GjduAm3csE3MCmvUsCmXc8mT/6qbPnHCVGrTuh0LPr10MRvaRl/a7ruH9gccpcOHTtKpkxfp6pW73NpnEHwi9gQbYyn2XA0Re4JgfyBgMmYdHjt2jFfSwcpD9evXZ6tXrx4VL16cChUqRDVq1OSuR7HIrUCBglzOJU6cWDddLO5t0MCh5DV/MfnvDqTjx84rgu8O3b/7lMf0qa17IvYEmyBiT8SeINgTqMQQSwwrNmDpLlXkidiLmYnYs1/z9BxBu3cdoBPHz9ONa/cp5MFLrXVPxJ5gE0TsidgTBHsCw0gQQLZRo0Ys7lq2aEXeq7bS2ZN36cr5x3T5XAgdCbxMgfvOU9DBa3T2xAMxK6xT+55czqVNm0E3XSzu7Myx+7TP/wxNHD9DE3yzZ3nRwcDjdPHCTQq+98wwdk/EnmArROyJ2BMEewJduIsXL2ahB8HnvzOILp9/FGos9i4pYu8cHT14VbcyFQtrIvbsz04H3aOpU+ay2OvXdwDt3XOQzp25SvfvPuHQLOjKFbHnADx58oSDfo4ePdpuDWNhVLHTq1cv3WPsxbDCB2bm2RIRe4IQ/6DiQogVCD2EV8HSXXXr1qXBA4fR+dPB5nbqPh0MOE8B/qfp0P5LdPLoHTErrH3b7lzOpUmdTjddzPZ2Ougut+KdOR6sK/Zgxw/fUvK7Bws+rGKCmboIzaKO2xOxZ+dAOKkiQsx2ljBhQpozZ47RyzFHxJ4gxB+osCDw3r59yzNv8T4ixEqLFi2oevXqNHrURDpy8LKZHQ68RDt8j5Dv1kDauT2I9vufE7PCWjTryOVcqlRpdNPFbGsH9lxQfpQoefbANTp+5Ba34oUn+oYOGcFib/nyNRyaRcSeA7Bv3z42U3GSJWNmypElu1gMLH2adJpPYffu3TN6PGaI2BOE+AGVFYaOoPJCeJWzZ8/S0aNHufysWbMmlSpVinr3GkCb1u8JY0sXb6LFC9bTsiVbaO3KnWJWWN3aTbic+/XXlLrpYra0XbTOe7eSVwPId/Nh2rPzFB0+cJVb+/QEnyb2lnmL2HMUChcuzIaXKsXPyenMen/6+9gtMRuY37zV9PlnhrV80XJqC0TsCULcg4oKFVZISAgHc9+9ezfNnDmTV/AZMWIEFShQgLJly0YNGzSjcaNnmNnY0dNpyKCxNHjgGPIcMp5GDpsqZoWVLFGey7lkyX7STReznY0aPo0mjJ1Ds2eupIXz15P3ih3k5xPELX16gk/EngOSIEECNrxUcweP0xUtYtG3bk3bsm/TpElj9HjMELEnCHEPVsbAOtwIlIxVe7744gvtPRQTcxZLkSIVNWrQiqZPXkIrlm6j7VuP0uEDV7hLV8Seg2P6j16p/ArVEyxi0bfh3fuxb1OmTGn0eMwQsScIcQsmYrx584a8vb3ps88+094/MTFntYwZstDUSYtp1fLttNvvBI/hM23dE7HngJj+g0Xs2d5E7AmCY4MJGei+/eWXX7R3r33bnuSzMYh2+pwRE3MKWzzfh7Jny63l8Zo1GtL8OWuUfB7IkzYwS1fEngOj/mNhIvZsbyL2BMGxwZq3Y8aM4Xfuo48+pikTltLBPbfExJzO9vhdonx5DGP4v/suCc2Ytow2rNnDY/dOHwvtyhWx54CowgEWmdh7HniJBrZ1o83TFummw7bOWEoju3nopkXFDi/3oRPeO3TTwrNxvYbQswMXddNsaQM6uNP93Sd10yxNxJ4gODaYgZsvXz5+58qWrqJbSYqJOYv5bAjiqBzI7/09RtLa1bsocN8lOhV0N8pir1y5ctSlSxd6+PChiL34RhUOsMjE3n3/U3xcxrTp6a+gm2HSXx68TEm/T0I/JP0hTFpUbdagsbR0jPUtjec37mURppcWHatRphJd2XZIN+3k2l3k1rStbpqlidgTBMcGMfXSp0/P71yjBm11K0gxMWeyH35Ixvm9fTt3Ds0SuO9itMQeZqnjOtmzZ+cWcntBxJ6VYq9EoWJ0bLVfmPS1k7yofLHSlDlj5jBpUbWoij2Ptt3oeBRbAiOyiMQerFqZivT60BXdNFMTsScIjo2IPTFXM1uJveLFi2v1FcIU2Qsi9qwUezOGjKP+7buHSa9boRr5zllpJvaeBJyjfooQK5YrP5UvXJJmDRyjpYXsOU1DO/WiSkVLU7WS5WnB8En059EbnGYp9iCs0HK3Z/EGbZ+plS5Sgt4az4VB+LWo0YC/t23dpnRk5TYtbfX4OXR7RxAN6tiDyhYsRnXLV6PNM5Zw2qN9Z7mrOkOqtNSlUWuaP3i8dp6pjejmQT4zl+mmmZqIPUFwbOxR7B3wv0Grl+2h6ZNW0bpV+3WPEROLrtlK7AUFBVHlypX5WghXZC+I2LNS7N1UhFLurDno9yPXtLQ7O45RwVz5+LOp2KtZrgptnLaI/gy6yePp6lesQTMHj+W06qUr0vxhE1nIPVCuXb9SDZrsMZzTTMXeQ//TVKl4WVo4Yop2XVO75nuYKpcoq22vmTiPsmXITIdX+PD20VW+lC97Ljpi3K5fuSbVVb5r/5JN9MeR63R5ywEqU6g4Tek3gl4dvEw756yiIrnz8/cHLQ8ViaYWsHgj9WjeQTfN1ETsCYJjY29ib5fPWZ41mTVLTipZvBKlSZ1esQws/vSOj6rlzVtQd7+1ljVLLtrtez7MfuxTyy7VkiZNRnVrN6ftm0+GOT4iW7N8L230PqSbptr40V5hvg9WuFBJWrV0t+450bW9Oy5RxgxZddOianNnrKc92y/qpsWV2UrsYYLGqlWrNN9jooY9IGLPSrGHv61rN6L1Uxdqaf3audGo7v35syr2/jh6nRrVqKcdA1s2dibVL1+NP2dJn4me7r+gpd1SROTE3kP5syr2kF5IEZG7vdZqx1kaxF2HBi207QI589K5jXvNjtm3eAM1rFKLP0PsLR093Swd35M1YxZtO7Ju3Du7jlO9itV100xNxJ4gODb2JvYqVahFo4bN1LbRyjd8yHRKmzYj7dt5xezY6Fhsiz2/Lae0fRB5Hr1G04/JfqZZ09aYHR+R9eruSSOGztBNUw1iD0LSdN/+XdeU82bSd99+T5vXHjFLi4nZUuyVKlmJNq2NWMjGttlS7DVq1Iiv9dVXXxnfqPhHxF4UxN622SuoVMFivB+zdH9IkpSubA3kbcsxexc2BdCmqYto9uCxVLlkOapduhLvnzlwDLcQjnEfQIFLN3OrmnoOxF6fdt04PWeW7PTm8FUtzdKmDxhFvVp05M84LpuJaFMNrZC5suXgzxB7l433amp5suSgJ0bxGZnYexxwjruI9dJMTcSeIDg29ib2Mirlq97+BvVa0eJ5Ptp2gCJsFs3dSvNmbuCQGqbHwjavPczdwMsX7TDbbyn2/LdfpLnT19FSL18WS6ZpMAg2XEdtnYuK2FPNe9keSp8uEwtXdZ//9gt8XXzvgd2h+2HRFXuqQTAP9BjHflky35f3oTt8/epA/hyw8yr7Dq1s+3aEFdCB/jdp9VJ/mjNtLe1VrhEdsQexiefbYPxO1ZxJ7E2aNEmrrzw9PY1vVPwjYi8KYg/dn2lTpuaJGvM9J1KT6qEteKrYQ7ctJjKMcOtHvjOX0RWfg7Ry3GxN7MG423TuahrSsSflz5mHpvUbyfsh9ornK0y3/I7y+e4RdJnOHDSGPFp34c8Qntl1xB5mD+fJmZs/Q+xd334kzDGFcuSlh3vP8OfIxN693Sd5vJ9emqmJ2BMEx8bexF7q1Olo3coA3TTVfDYco1Sp0lH+fEWpSKEy3F06YfQCLb13j2GU6re03A2cPn0WqlalvpZmKvbGjpxHSZQf8rhGntwFKVvW3GZdjB3b9eZrlyxWkTKkz0x9eoyIltiD5clVUBFbB/jzvJnr+brFipSl3DkLUIpfU2nd1OnTZ9LKQJjpNUwtIrFXu2YT6td7tCJk9lG+vEWoa6f+lC5tJho9fHYY3/2aPCUtmrdVOxeCt1DBkpQlcw4qUayCcj+ZlfQtmthrqIhuSyHaqrkbefQepW33ch/GrZnwf+rU6al1Szfenzx5Cu25cmbPrx0f12YLsbd48WL65ptv+DoffPAB3b171/hGxT8i9qIg9rCN8XX927lR+SKl6MTaXdpxqthbNGIK9bQQaV7DJrHYgxBUBZpqaH3LaWx9Mx2zB2GJMXi7F+h35W6ZsYQ6NWypbWdRjjXtHoahJa9kgSL8GWJvo0kXNOzPoBuUMV0GHluI7cjE3oXNAdSsRn3dNFMTsScIjo29iT0IiV9+TkF1ajWjQf0m0gbvg2GOKVKoFE0Zv0TbRqsVxAy6eTevPaQIt0Lc8oc0tKYVyF+cViw2tPCpYs9300nKli03bVl/VLvOCM8Z1KBuK/4MQYbvQcsWttEaVr9OC6WC/zZaYg8CbNK4xdxCmEERoBu8Q1u8pk1argjNXLR/93XejknLHlrS0I27xGsbi71ffv6VOrTtqbUqFilc2sx3EHIQnur9dO7gQe1a99DSt6w7SsWLlrVa7OG+CuQvprW2QjzmzVOYZk1bzdvO0LK3Zs0aJR/l1eoqDw8PibMX36j/DFhUxR66MrNnykrF8hUyO04Ve2jFq1m2shaTD4GISxcuTtVKlON9ubPlpBNrdmrnnduwl/LlzMOfTcUeDJMpfv05OV3V6X7F/VQoVlrb9uzah8fTvQi8xNvo2sX2klHTeBtir1aFqvR43znehpjs38Gd2tVrpl2jTvmqZjN/EeDZdIzeukle5Nm5t7YdnonYEwTHxt7EHsx30wnq3WMEtzCh1QStdJMVoYS0dasCuFXK8pyJYxfwslgrl+yimVNWmaXVrN6Yhg82CBRV7A0dNIV6uw83Ow6WP19h/gshZXkdCL7EiaMn9nA9CKEuHT2obSv3MOlVKtUhr9kb+bO1Yg+iGK1nqqGl8Ntvv+MWSBwDsYf1jlXBipZFCGHT68DatuquiLy+/Dlzpuza8arNnuZttdjLmDGrIpTXmaUvXeBLc437nEHsVapUSaunSpYsSb///ruIvfhG/YfAIhN7jxRxhHFq+KvuG9yhB60cO8vsuOa1GvBfhEJB2JO8iqgrnrcQ1a1UnY55+1HZQsVp/eQFFLRqO7e2Fc6dn0rkL8IzYg8u3cLnbpi6kPzmrDK77trJXuTRpqvZPtWqlK6gxb3D907qO4wnauB+C+UtQFP7G7qHYRB72+ev5vGDJZWCC8ehm1gVh7Bts5ZTuUIlqEsDQ4uhpdjr1bITHV6hP1PX1ETsCYJjY49iz9Qwtg2TDn5LmYZmTfWmgR7jqVH9NrrHqoYu0e5dBvNx7dr0YKFiKfaaNu6oiMj03J1oap9/noi/E0Jz26bjZteFZcyYLVpir3rVBiweCxcqReNGeYVJ7+nmSZ6DpvJnS7FXWhFI6v25dx3C+yD2ShQrz+PiTG2nz1ntPIi9zJmza9uD+k2ghjq+gxCrUa0hfzY9XrVd285aJfb27rjMPtDzj2qOLva8V23ic2EIpnznzh1ZLs0eUP8psMjEnj3b1H4jyG+uuTgMzyD2MJtWL81aq16usu5+SxOxJwiOjT2JvSnjl/L4Mr200cPnUL3aLWjUsFm63Zfey/bSLp9zPHO3TOkqZuP+cLyl2GvTsjuNGTFXO8bSSpWoSJvXHQ6zH93FURV7mICBcXIQYmVLV+VnsDwG3aeqiIrpBA3VIPayZs2pbY8aNpu7x02PgaHVFN3M+Jw9W64w6b6bT0Qo9po26shiD13nn3zySRgfbNt4glYt8efPjiz2Dh88TZ9++imf++2339LevXtlbVx7Af8U1RxZ7IXsPUNdmrTRTbO0mIo9BI4e32uwbpqlidgTBMfGnsTe8kV+LKb00gb3n0jNm3SiHVtP88xWzBg1TUcr19YNQTwhYdrEFWZpRQuXCSP2IB6bNe5odhzGl2XJnF259g1q3aIbDRs8zSzdd9NxFjNRFXs93IZQyeIV+POQgZOoepUGYY4pWKA4z9rF59gSe/Ad4hZa+g5dyH17Gbphc+bIz+vHmqYP6j9BE3vNmnTgyR+m6fCv2o1btIjia0Vwm6a7dxvM3df47Khi786tR0o995tWPw0YMIBDr4jYsxPUfwxs+Sjz2HOOZguGTaInAed100wNsfywUoZemjU2uFMvszAxEdmQrn3YtyL2BMExsbduXIiBJg3b0ZoV+7hFDKFR0AKHljE1WHCjBm1Y+KG7FV2HmP1ZpnRlTqtftxXVqtGYQ4ogvXeP4ZQlS07q3N6DJ3CoYg8TCNKmycjCBGPx8D24ZpeO/TidJ32kM8xEVUORQEhCaEYk9saNnK91qaIlrVyZapQrZ34OBYPjcA+5cxXg1j2Iy51bz1DLZl34udVrDfAYR7VrNuVrqPssLTpiD2bqOzx3T7ehlCZNBm4VRfpIz5ks2DBrF5M6Jo1bxIGa8+U1jPWbMmEp5ciel0Ut/IIZzdmy5dLE3orFO3nc3+L5hjA5S+Zv047HNsLCuHUZRIvnbePt+LCoir3Ll25TkcKGpdESJkxIbdu21eLsRUXsPXz4kMaOHWvcij1csvZMnDgxGxdkVWtrkynEYm4QhLmzZGffli5d2ujxmCFiTxDiFnsTexBAmIVbrWp9HqNWpFBpat3CjcWfegxEIFqiEDqkQL7i1KFtbxYvSIOA6dS+L+XOWYhKlajEogrCrWWzbrRu5QEet6ZeB7HgWjbvSnlzF1EETWnq23OkWSy8lYpwQbcn7qNJo/a0ftUBRRzO0A3ujH0Yu2ZqPdw8aemC7WGO3bXtHD8Trlu8aHnqo3wv7ltNh/DE2Dxcw/Q8U4P4nDhmkW6aahBY/XqPMdtn6rv8eYtRt04DWDCbHjNhzALubs6Xpyh162xIHzJgspY+dOBkKpi/BPusf5+xNGf6GjY1fe2KAKpWpQE/X9XK9dhvahpi/XVShPeAPuO1fXFtURF7J45foCqVa2j10vRpc7Q4eyL27IgpU6awqf+ocoVL0KQ+nhy7Tiz6NrxLH8qj/GJU/bpr1y6jx2OGiD1BiFvsfYKGmJitLSpir5/HYK1Oqlu3YZgVNKIj9nBsSEgIBQcH03///WdMtR0uWXv++++/bN9//732DxOzrRUvXtzo7ZgjYk8Q4hYRe2KuZtaKPbduPbQJGVkyZ6Ob1x/GWOy1bNmSbdOmTbRixQrKnTs3vXr1yniEbXDp2vP169fk7u5OX375pSYmxGJmSZMmpfnz59O7d++MXo45IvYEIW4RsSfmamaN2KtTuy4lSJBAq48yZMhERYoUp0KFivAYdViGDBkoa9asHIIlR44cZrZ69WrjGxYKxB7qzX/++ce4hyggIIC1iS2R2tMIHG3PBsX//Plz3TR7sthAxJ4gxC0i9sRczSITex59B9Knn37Gx0DwLVm0mvx8A2inXyD5bPGnHj16sE2cOJGXTVu1ahUdOnSI7t27p9mbN2+Mb1goEHuWa+g+evTIpr1jQGpPB6FcuXI0a9Ys45ZrIWJPEOIWEXtirmYRib1TR+9S5szZtHpo1MgJZkGVr165rXXjXrt2jUWdtY0fehM0Xrx4IWLPFUHGwS8JBGyMjYGb9o6IPUGIW0TsibmahSf2Thy5TeXLVtHqoNat2tPpU5c0sfcw+AVt3+7HQm/Lli3cA4fxetbW1SL2BA0vLy8towUGBhr3ug4i9gQhbhGxZ701a9KRBnqEhm6JL0Ow51nTvHXTxCI3Vey1a+NGK5f50r7dZyjo0A1F/HXX6p9ffklOkydNo10799GJ42fp1MlztHWrj9aqd/r0aX53MAHUWkTsCRrJkhkyIaxy5crGva6DiD1BiFtE7FlnWN0ixa+pOGCw5QoU82at5yDIpvsgKPTW1o2OYUUNty4DtW33boNo3Kj5ZseIWW+q2GvZohMtXrCe/LYdpuFDJ9JHH33E+zEDN1++fNSmTRuaOnUqLV26lLy9vVnkrVu3jo4ePUp//PEHCz1rZuGqiNgTGPxSUIUODJG6//zzT2OqayBiTxDiFhF71lmbVu4cTBhr5i5d4GuWFtdiTyxmZin2pkyar9U7H3zwAeXPX4AKFSoURuxt3bqVbt++zREootKip4JzEBnEFHQBo96zJVJ72jkZM2bUMpxq27dvN6a6BiL2BCFuEbEXuWFVjVw589Fev0u8IkeLZl20tLEj5/MqERkzZOMVL7BiBv5+8UUixZ/ttCXPsPwYloHDqhJlS1ejBXM2a9eYPG4xLfHaxku1Ib1EsQrKeYb1fXH9QgVKUP58xbQVNcaOmkfzZ2/Uzp8xeSWVL1eDz8V6v6YrVkR0bVc1Vex17tiTFnmtpZ9++oW3se7xwvlrqX27jlSzZk0aP348HTlyhAUe4ulhIgbEWVRa8+IDqT3tGETT/u6773jNPVXsDBw4kIoUKWI8wjUQsScIcYuIvchtzvS1ilBrz5+x5m6a1OmVv4YlxlYt8eeWt2JFyrKw27r+GP9NnPhbXtMXS7RBJObInodmTFnJ52z0PkiFCpag2cZxdw3rtWIxie/B9obVgfTbb2lZtOH69eu0NFsrt2XzLjRkoGH5sj49R1DRwqWV7wng7emTV9DPPyenxfMNa89GdG1su6KpYq99OzfKktmw5CdsxpRFdOX8Y+rSpRvVr1+fo2JcvnyZgx5HpyUvvpDa047Brwb8Wrh06ZKW8dCFi4I4tmLa2SMi9gQhbhGxF7nVrN6YFswNbYmrXLE2jRg6Q9uOrBt3QN+xvBauafqieVtZAOIzBFlLk9ZCw7421L+PYV1by25cVez5+16gzz77jDavPaylwSaNW0iVKtTiz5Fd25nNsKbvpDD7VbH3xRdfaPVNj+796fL5Ryz2OnfuymJv7ty5WngVR4qOIbWnA2Ap9lwNEXuCELeI2IvY9vhdohQpUtG0iSu4ZQ3Wqnk3ypghK3fv4pjIxF7Z0lWpTKkq3A2rWrPGneijjz6mgJ1XWZANHzLd7Hwc49F7FH8OT+zNmupN2bMZBKOpBey6Slmz5ODPkV3bWW3bxuOUL28RztclipWnuTPX0YHd19k3Sb5PqtUzsJrV69H50/dZ7J0Muk6NGjVisbd+/Xq6c+cOvyP23nVritSeDoCIPRF7ghCXiNiL2Lp09OAuWlOhBvvpx+Q0Z4ahazQysVe4UCnq0La3JhZNbb8iQCDITFsKYaaCLDyxN3ncEsqbp7C2XzXMFs6RIzd/juzazmo7fc5QgXzFtPokPKtQvhodCbxEF88+oNPHFF/37MtCD5MzLl68SE+fPrXpkqBxgdSeDoCIPRF7ghCXiNgL39DqljRpMlq5ZFeYtN49hmsCLzKx17ZVd3LvNtgsffvmk9w9DGEWXbG3Zf1RngiCMYFqGmzV0l3cqoXPrir2YGjJa9qovVanWFqZ0hVooddq8t0aQMuXrqeOHTuz0INhGTSESkGIFUdb4EBqTwdAxJ6IPUGIS0TshW8Txy6i3LkKhImrB9u17Rz99lsaFoQL522m0qUqm6VjksTKJTv589qVAZQ6dXrauj5IS2+s+LpD2178OTJB1rfnSOV/00ZLM52gUblSbR6Tp96j76aTlDVLLg68jG1XFnuq+Ww8RkMHTlGEXwfuPk+U6EvO72nTpqVSpUpRjRo1qF69eprQGz58OAUHB9Pvv//uUBMzVKT2jCFQ+QimePjw4VizcePGcWDHDz/8kDZs2KB7jK3s2LFj9PLlS+PT2Qci9gQhbhGxF761bemuzZjVs3atetDCuVto384rVLN6Iw5tsnieYRbs0EFTKH/eYjSgz3jeRniUfHkL8zG5cuantq3c6cBuw5g/tNzNmGKYaasazhs/2os/YwYtxvzhXGz37zuWpk5Yxp/RetW6pRtlz56H0wsWKMbhYdTrRHZtVzR1goap2GvevDkNGzaMdu/ezfViVJZBszek9owmCIuSOnVqTYQ4m7m5udnN4FMRe4IQt4jYE3M1U8Vex44dyd/fn+7du8czbiHw1IDJjjQhwxKpPaMBlP3333+vCRBnNQSQtAdE7AlC3IIKTsSemCuZKva6du1KBw4coEePHrHIc2SBZ4rUntFg3759mvjo2qU+3bq+gV4+3eHw9uLJDrpwdhVVrRI6W+nWrVvGp44/ROwJQtyCSi5Dhgz8zjWsHzouTEzMWQ0Br5Hfe/TowUOznj9/7pBj88JDas9oMGTIEM4Uv/76M717u4f++3ufU9njh9s0cbVq1SrjU8cfIvYEIW5BJVemTBl+5wrmL65bOYqJOYthprJax0yZMoXOnTvH69U6S6sekNozGvTv358zRemS+XXFkjPYDz8YAkxOnz7d+NTxh4g9QYhbUMnNn29YCD5hwoTkOWiKbiVpW8PM0bAzXF3TxBehFrt+2L75FGXOZFge7YcffqCAgAC6e/cuD2VwJqT2jAYDBgzgjOHMYi9Zsh/4GUXsCYJrgq7czJkza+9etSr1aelCX9q4JtDmtsH7gGL7jXZA9xhXMfFFqIX6An/1j4mJTRizgFKmTKPlcXd3d7p69SrPvHWmLlwgtWc0iInYC7nvQ6tXDqUtG8fSiyd+usfYg4nYEwTXBq17GLv03Xffae+fmJizGsKtXL58mcfqOdrqGNYgtWc0iK7YG9i/NVWoUIQG9GtGfXs3obx5s1KnjnXoj1e7dI+Pil06v5oyZU6vmxYdE7EnCAK4ffs2devWjX777TftPRQTcwZD/NpChQrRzJkzOWYuAib/888/xpzvXEjtGQ2iI/ZWrxxJ9euVM9v35xt/qlO7DPX3aGm2PzomYk8QhNgC4abQ2oF3EYvAQwDawjDb/8qVK7Ro0SIeI7h582bav38/XbhwgQIDA+n06dO0d+9eDgMFw4SxLVu20K5du7i77caNG3Tw4EGaMWMGG8Zb4RxcE9fW+057NdwvVktavnw5jR8/XvMF1mJFKBAEvPfx8dF8AZ/5+vrS9u3b6dq1a3Tz5k06deqU5oudO3fSiRMn+JpI0/tOezXcLyZJDBw4kDZt2sTPiOfH/3XHjh3cAjdt2jT2Q4MGDWjr1q20evVqzjfXr1/n89etW8d+mDNnDi8YcObMGc4zpvkC3bVY+gwrUyF/O2rAZGuQ2jMaREfsuXVrRDOn9wmz//KFNdSqZQ2zfW9e7KJtW8bT3t0z6O8/zGf7/v7KkIau4KePfLX9emLv3u1NfNzZU8vN9ltjIvYEQdAD3bu2MrSioMJt2bIlNWvWjMXM8ePHOcYZBshj3BQq7yZNmrDt2bOHK/oXL15olTMqbYhAGETPkydPOCi0GgTXUQy+wAL7WLmhatWqmi/wPHhWPA/EnOqLbdu28fPCFzgXvsCxqi/Onj3Lwf/V5b30vtMeDc+B/z2eLXHixLRw4UJewQJC79WrV/ys8AfEHfzQtm1bFrX3799n4YZnxTUgkOEHiD5MuHj27BlfF2mW3+kKSO0ZDaIj9mbN8KByZQvQ29e7ddNVW7poCGXKlIZ69WxE3brWo8yZ09ChA3M57dCB+VS0SG7uAvboY+gG9vOdzGmmYu+v3/2pa+d6VLp0ARo8sAXVrVOW6tUtT2/fRPzdpiZiTxCE2Obvv//mSv2rr77iQPVorUKLFAQeRAoqZrTEqAIHMU5R6SMsBtIAKnJU/DCcp1bqjlaJwxdozUyQIAF98cUX3CIFX6AlFeIVz4vWKdUXaO3C85r6As+u+uL8+fMsmh1t0X7cK1auGDVqFJf5xYoVI29vbx4/CvGqClvsU8XeyZMnuRtW/b/D4Ev4Yf369bwaBkQxfOwq4s4SqT2jQXTEHuLx9e/XklKmTE7ly0GEtQ7TcnflwioqkD87t96p+86cXEZFi+ahf//aS7/9ltysle7yhdVUvVpx/mwq9ubO9qAmjSvRP3/u1Y6dNaMvTRzfTduOzETsCYIQm6DSRaWulqewNm3a0Nq1a7nyRisXKnZXEHuqL7p37675onbt2uwLdGei9RO+cAWxpw4XyJs3L/sBoX8Q+w7CF932aqutiL2oIbVnNIiO2FMNQm7Prunk7taIfvzxB/o1+U909NACTps62Z1mK6LM8pxb1zexcLt+Zb1ZEOegI4uoeLEc/NlU7NWqWZKPVY+DPX6wjVfGMN0XkYnYEwQhNkGF/eDBA6Uc/FF7v5MnT86texB1EHEYS4XxV84u9iDkUM6ZToL55ptvyMvLiw4dOsRCBr5wBbEHMYe1aSHyVF/Ur1+fu2MxHhPCF4JQxF7UkNozGsRE7JkaJmgsmD+Q0qdPxS18Pbo3pK2bxukeCzt1fAn1dG/CXbRDh3SiAf1a64q9PLkzUZHC2TjN1Nq2qW52vYhMxJ4gCLEJKuZZs2Zp77ZqvXr14okHGJuH1i605jiz2MN9QsitWbMmjC/at2/Pk1HgA/gCYseZxR7uE2KudOnSZn7AD4IVK1bwZBx05cJfIvaihtSe0SCqYu/P1/58/O0bG3XTc+XMSDeubqDhnm1pxbJhYdJ3bJ9Mt66v45bAyxdWafsRs09P7JUumYfu3NikHRcdE7EnCEJsoQqcsmXLau+2asWLF2eBA7GHAfkQNM4u9iDIGjVqFMYXOXPm5NnIeC74wnSChjOKPXUSiqUfYFimFLNqIerwTCL2oobUntEgOi17+fNl57F0lvtfPvWjNGlS0uvnO2n/3jlUu1Zps/THDyHo8tGm9WOpcsXCZmm+PpN1xV7fPs1pmGdHs2P3+c+i9u1qm+2LyETsCYIQW6DCRQWMSRkYm6a+3xiM/+2337LAgYjDJA1XaNlDGYeluiB0TX3x9ddfc5dmcHAw+8IVWvYQbiV16tSUI0cO9gNm5GbKlIly587NYWjwjNKyF3Wk9owG0RF7aJHLni0D9evbnFfP8N85haZMclcycVqaNqWndly7trU59p7P5nG0fMlgJcNnUj5PpLu3NlCSJN/SxPFutHP7JBo3piu5uzWhdOlSUsCeWWZiL/jORp7F27tnU/6exQsGUr682ej6lTXa90RmIvYEQYhNEBoEM01RKavv97x587iChpBBSxbGZrnCmD01NuCSJUs0X0yYMIE2bNjAYg9duPBFVMfsoex0JLGH/xmeF//7du3asR9++eUX2rhxI89ORpw8CD0Zsxd1pPaMBtEds4fJGRij16xJRUXQlaCRwzvSresbwhy3cd1Yatm8MnXuVJcung2dfXv31kbq2aMxNWpYjpYsGsrj/A7sm02BATO5hdDXZ6J2LFblmDGtD38PRN/Na9YLPZiIPUEQYhNUupiYEBQUpL3fCKyM+GiImYZKHSLFVOyhxQ+iCGJAjR0HwWgq9jCLF5W+owgcoPpi5cqVmi8mTpzIvsAYNYgUPI+p2MO4RjwvfIE0XAPPrvoCs3gdcYIG7hX/v44dO7IfIPYQYBo/DrCUGf7verNxMdkHeQZ+gMF38AMmdkDs4VwRe0KUsNUEDXs2EXuCINgaVLSoqCFsYKh8jxw5or3fc+fO5dY7tQsX6WjNady4MRuC62KVBLX1Di086ObF4H0YjkV5oZ6L9JiYep+4Z1VQ2QJcB9ez9AWeQfUFWvbgC4gYzFBFOoIHq77AqhEY12jqCwhD1RcQR2jtghi0tS9sKZgs8wS+C8/boUMH9gPEHlbRwFg+VcjDIIzhh9atW/MPBuQZtICqzwrfwQ+Y+IIfBAg4DeFr+kzRMVM/2DJPxDZSe0YDEXtxi4g9QXBsUCmigkQlDSGGrkeIEHStoVJW328sb4XlsCDaUDljZiZEC0JvwLBqhLpaAlpqcA2M40K4Fhg+Y3wbRAHORXpMDfeKe1a7D/EsMQHn4zoQNJa+wDOovhg9ejT7AmIWgg7Pg9moqi/QPYnuX/gC5+IaWE1E9QVauyCAUH7ayhcQUxBM+D/i/xkToRNenoDheRFzEX74+eefuRUPkzPU7lj87xcvXsx+aNGiBbfiqUIfzwpDXD74AcvPoXUYoln1o+kzRcdsnSfiAqk9o4GIvbhFxJ4gOC6oCNHaAqGAShpdi6h4IcpQeaM7Un2/0ZqF8VkQKgimjHRU8pjEAUOXHNaLRYsWhAyEDtZMnT17Nhu6OVGxoyUHaTE13CPuFS1mEJCo6CFO0KoTHXAeBAKuAzGL6+I78F14VtNQNJh9Cl/gmSDikI5Zyqovli1bxuLP1Bdo9VR9gRUn0M0LX+Bc0+eKjqm+wP8P/0eIHfxfoyP4IsoT+C48b/PmzdkPCLsCYYexfFjnF88KwzPCD5jF7Ofnx3kG/3v1WdEaiGMQqxBCEGmqn2Jits4TcYXUntFg2LBhnAl/+eVHs9UunMVuX1+nFTgYIBzfiNgTBMdErdTRGgMhAqGG1ipUzjAIPfygVN9vd3d3HquGLjp0UyIdFT3irsHGjRvHlTfKJaRhksKWLVu49QamnoP96nfE1LAeryo+UdHjWSDYolq543i05uEa6LpGl7Tp9+C++/Xrp/kCMfbgC7RqoUUT6RAvqi+GDx/OLVeqL3ANrKer+gLj3GzpCwhNiEtVcEHsQOigZSsqgs80T+BaaJUzzRO4Xzwv1geGHzBj29PTkydooDUTzwTr378/+6FixYrcIow8g7ygPi9WH4Ef0JWr+s9WvkCeQAtzTPNEXCK1ZzTALy31hcR6txvWjuZZr85gK5cPo2xZ02rPh1+f8Y2IPUFwTNBNB0EAoYDK19Iwnmrs2LHa+41B+RAxmKiBReyRPnPmTA5DAkOlP23aNFq6dCmLIL1rxpZBSGFyCFp10BUYlVYtHIfWH4gbiDO96+NZIXZVX6B7Er5YsGABTzRAOlo+VV9A7EDkwBdI07tmbBgEF8QvWt/UCSBRETlqnoDY1bs+DM9bvnx59sN3331HHh4eNGnSJO1Z8b/v0aMH+6FMmTL8IwB5BoIvLn2BPIGW1ejkibhGas9oUqRIEe2ldFbDC2QPiNgTBMcDLTgQOGi5UStHtLwcCAykQ4cPsaGlaIXJDFRPz2GKuFlI23x9uRXw4KGDtFWpUFu1as22ePES2rhxE7esBCrnYikx9VqxYbhXtAqp94/P6A5EmRSVWa4QQ+hKVK8DwYRuSdPvgi8mTJyo+QICB75AS9KBwAPsC3Rjq76YN28+bd68hX2Bc02vFRu200Swq+MF0cKHVi1rRY6aJxAWRb0WWiD3K3lE+y7lf4rnbdq0KfsB3bhTp06j1YrA2634DM+K/z1+BMAP7Tt0VMShN21X/GTIM+b3bWuzzBMQfNHJE3GN1J7RBJm7U6dO9MEHH2gvp7PYZ599xr+Q7AURe4LgeEDgoNVDrRRPnzlDf/z5lv78+y/N3v71J11RRJD6fq9dv4GOHjtG9x88oDd//M7pj548ocXLlrNduHSZ7gUH08vXrznN9FqxZfies+fOac+BMYRoycEgfWtbtNB9izFkON93+3Z6/vKF7vfsMZmsslR5Xvji4aMQ+v3tH5z+ICRE88XZ8+cp+OGDOPXFk2dP+f7xHBhPeO3aNe79wfNZI3LgL5yj+hIzbPFslt+DfSNGjmQ/ZMyYkXYrghb/+6fPn/Gzws5duMB+WLFqNd24dYseP31Kb3SuFVt2TvG/+hwQoFHNE3GN1J4xBE3SaL7Fr5vYNAzGRbO5XpotDc3r9vbLRMSeIDgeKBsxRgqVIVpc9CpMVNqXr17R3m8We0HH6N6DYHr9+xtOf/TksYXYu68InFdhhGNs276AAH4WjP3CJACU+3jGyECLF8Z2qcLg3v37utfHs/rv3av5YolS5sMXEHiq8A0Oeagj9l5xmt41Y8PuK/8b9Vkwbi0qsfzgL4zPw7l7FWGrd30YntdM7PlD7F1SxOYz/r/D8PzmYu+J5ie9a8aGqa3WaN2LSp6ID6T2dBAwWBdN366IiD1BcAxQ4aNlA4P20cqBcXew8xcuKOLt9zD26s1rbqFR3+/Va9bQwcNH6PbdO/QcPz6VdLTyLVy8hO38xYtK2l1u4UEaBKHedaNiEAi/v4WAMLQY6VXqsBs3b3LFjjF3qNjx4zi8ih0CD35AOrot0YIFP6AbNrx7xvPs2LVL8wWeF764q4jDF69ecvrte3c1X5w+e5bTQn0R9ppRMYMf/mAhFZEfkIZWPfgCXa6YqIGZueG1aJnmCcy+xXg8+OLsubO69wH/4Hk9jRMhMyhiz2/nLjpz7hw9VIQlnhV24vRp9sPSFSvp2o0bLIpfKGLrlfId+te13qzNE3eU/wf8gG7tyPJEfCO1pwOAl+Tjjz+mlClTGve4FiL2BMG+QWUOUQOBh1hmaO3BOCYsfwYLOn6cu18tDWIFgsZU4OzcvZtbbW4hZIhyzMXLl2nW7LlsxxXRdOnKFU67G3w/zPWibA+CKfjhQwpRyhiIJnSJhid2cAwqdpg6Vg1lsykQNtgH8YN0lF3o3sO4OvgBM0N170Mx+GKtIhpUX8yaPYd9cf7iJRa4OAZ+UX1x5Ngxunz1qtFPMffF/YcPuMsY3aEQWxG1kmHWM/yA7svwxF508wQMz9u7b1/2Q7p06WjDps1KPjlMV65dYz/hf7/vwAH2w7wFC5QfDBdZ8N1RBJfe9aJkOnlC7Ua39IM1ecJekNrTAcASQWoBgJhJroaIPUGwX1Cpo7LHe4ruSgQ2xuB9CAHMtIX57dhJp86eDWMnT5+hrdtC4+xNmzGTu3L37T9Ax0+epJNnzlDgoUM0fuIktv2BB+moIhJOnDpNp86EvV5U7fTZcyygICivK0IErYjPXjzXFTqRVewQehA3iBuHdIxXREBodHVi9ij8MEN5Pr37gMEXc+d7ab4YM248+2J/YCCLXPhir+IX1Rf+e/exYLKFL9BKeObceW45haC6c/8ePXr6hFvQ9EROZGIvJnkCz4Ln7dCpM/shVapUtHjpMvLx3U6HjhxlP+GYTZu3sh8mT51Oh48G0bETSn4xpule10rTyxMQfdHJE/aE1J4OQLVq1bQCYOTIkca9roOIPUGwT1CpY7wWurAw0xahQRASBPHievbsSTVq1GAbMGAgTZ02PYxNnjqV+vU3BKmHtWrVhvr09aBRo8fSpMlTaKpSkU9QKvT+yvn9+w/kz9g/Zeo0xcJeL0qG8xWbpwgsCAmISHQpo3UIlbvlxIGIKnY1tAqC7CIsCWaKDh48mP3Qt29fXtILfmjQoIH+vSgGX7Rrb1giDNa4cRP2xZix45Rnnsr3On7CRPYDbNz4iTRpytSY+8Loh5mz5tAqRZQGHAhk8Xftxk3lmQ3dppYiJyKxp+YJBCDGWLao5gncC563TJmy7AfE2evm5kaDBg/lZ4af8LwjR41mPwwcOJjzxGSjL/h59K5rjRl9MXeeF/8IUfMEWk8xOSUqecLekNrTzkGzt/rywz755BO7HRMQW4jYEwT7QxU46KZERa4u46VanTp1qFChQmzNm7egXr17h7GevXoraS2197tKlWrUrFkL6trVjXr07KV7TmwZhBRa0dAliO68F6/MJz6EV7HDDyiTsY3xfFic39IXFSpUYD8UL15c97th8EXNmrU0X5QrV5590a1bd8UX+ufEhvVXxPe27dvpxKlT3LLFIkcRb6YiJzyxZ5onBg0aFMYP1uQJGJ43b9587Ievv/6a6tVrQO3atafu3Xuwn/TOiQ0bN348tzJjvCDG51mbJ+wRqT3tnIYNG2ovv2qYAeRKiNgTBPsDlTtm748aNUqrzFu1akUDBg6kQYMHUf8BA6ilsg0bOmwYTZsxI4xNVazfgIHa+92qdRvq49GPuzCnTJume44tbaryHQMHDTap3CfQ4aAg7srE7E7TlpzwKnZ032L1BIRWUf2AJbz69O3LfoC5ubmxH9q2b6d7HzD4or1x8X9Yo8ZN2RdjFcERF74YofwfVT8MGDiI/HbupLPnzrPwtZzxG57Yg2GMHrppVV+0aNmSlxi1Nk/A8Lyly5RhPyRJkoS6Kv4bMnQoTZg0if2kd46tjPPE4CGaL9CyGnjoMF26fMXqPGGPSO1px+ClQRw//ApSC4ASJUpQ3bp1jUe4BiL2BMH+QKxRzC5FhY7uycVLltCjZ0/o5e+v2Z69ekmXr19je/AohJ69fhnGnr58TkEnT2jv99JVq2hf4AG6evM6hSjXevr6he55tjTc8wrle9XKffWatXTm7Dkeq2XahRlexQ6BA8GDtVzhi67dutG1Wzc0P7x484ruhzxkP1xRnkvvHmDwxep1azVfzF2wgH1x/c4tevTiaZz44uTZM+Q5fDj7YfCQoTwWDq176NZ+qwjayMQe8gTSVKHnpTxDyNPHUcsTynPiebv36MF+SJ8hA23Zvp2OnTpJdx7cZz/pnWdLe/T8Ka1Wnk/NE3PnzefxgNbmCXtEak87BpkHv5yxxI5aAOAXJLbxUrkKIvYEwb5Adx3Kog4dOnClPnrMGBY1poZK+dK1a2zBjx7S01cvwtiTl8/o6Inj2vu9ZOUq2qsInCs3rrFIePrqeZhzomWKgIhILOFex44bzxX7+IkT6fjJUzwj9IVJi1Z4FTu6cLHKhSpwjiuixMwXyjXuPXzAfrisPJfu/SkGX6xau0bzxRxFKMEX127fpBBFfNjEF5H4ARZ4+JAmcjBu7dLVq9yiZRrXUE/swQ8IroxWTPhh+IgR5n5QzJo8gefE87r1MCwdx2LP15eCTp2g28H32E/650XRIssTyjETJ01iP2Ds5JGgIKvzhD0itacDYCn2XA0Re4IQ/0DgofUGlRnKIVRuGIMF26xU/hBnpoaWmzMXLrDduHuHgp+EhLH7SoUfeOSQ9n4vWr6cdu3bS+cuX6Q7wfcp+HHYc6JqD58+4lZCbh1TxIZa0VtW7jt27+KKfdCgwRR04gTdvHOHnr98qVuxI8A9Vo5A3Dj0wCCUCPyAcWUPnyjfZ+GLG7dvsR/OXbyoe48w+GLZyhWaL2bPn8++uHj1Ct19GHNfPFAM94JWK00w6fghRBF2vfv0ZV+sXO3Ns1JDnjzWFXuI/RqM8Y2KyIHge/jwoZYn1m3cYOYDmDV5As+J5+3SrRv7IV36DLTRx4cOHQviFlP4Sfe8KJi1ecJf8b8qfPfsDYgwT4jYE2KMiD0Re4IQn6DVBjMsMdsUsyyvX79OAQEBVKlSJTbvdWuVCvy8mZ06d5b89wewHTl+jLct7eS5M9xqo77fXouX8Pb+Q4fo+OlTuudEyc6f5Xu5cOWyIhRuKiIimEUHV/AWlXvgkcNcqWN2MEKa3MSKRajYlTLXULE/4kX2sZTk+fPnObQK1ru9oAiXESNGsB8wm9bSD7DDx46xH/bs369/n4rBF9Nnz9Z8gc/wBe7rxJnTuudExU6fP8ciGl3Jt+7fZfH3+CVaDMOKHHUcI5ZsuwCxp5TBf7w1F3sIJ7N7924OqwI/XLlyhY4eParliWWKnyz9gPuILE/A8Lyt2rRhP6RNl46816+nHf7+fA78pHeO1RaNPAHbvWevTp4QsSfYEBF7IvYEIb5A5YVloBDjE2FFIPKwDNqiRYuoaNGibFOnz6Ctyj5T27zNl5atWs22dtMmZXubrs1fuFB7v2fMmascv4rWbNxIG3226h4fFduy3Ze27dhBO/b4s4CE4Ll++xYLHVTuehV7eGLvYUgILV++nFvx/BXhgWW/sHQaJmZ06dKF/YCxi5Z+gK1Vngd+WL7aW/c+VRtiXDUCNmHyFPYFzt3k46N7vLUG0bjVz498d+3iruGjJ0/QxWtX6X7IA13BF5nYwzMvWbKEV47YpVwT3djblO+BEFbzBCZTWPrB2jyB561Tvz77IU2atLRw2TJaqQiq9Zs36x4fFYtOnhCxJ8QJIvZE7AlCfIBuW1RgWLx+oSLK0D2H8CFFihShPHnycAw0WMFChalCxUpmVr5iRSpVugxb2XLleVvPipcsSYkTf8tWvERJKl22rOH4CvrHR9Vq16tHQ0eMoJXr1tE2RZgcOXGcrt66YWjNMRE54Yk9dcms+8HBNHfuXI4Z16JFCyqp3Df8gAl0adKkYT9glSNLP1RQ7qFMuXKaL/TuUbV8BQpovihSrBj7olyFCjbxRcXKVahD5y6KcFrOYmrfwUC6ePUyTx7hbl2TVq2IxB58gVa96dOncwzBqlWrsrgrXLgw5c+fX8sT+ZVnsfQF7sOaPIHnzZgpM/vhl1+SU6kyZdmH7Au946NotevWo8GKsF65Zo1VeULEnhAniNgTsScIcQ3G6KHrFuufohJX30FHtXTp0nPX6KZtPjwp5Pb9u/TYZJZr+GLvLYfbuH7zBkdC+Oijj3Sv7yj2zTffUBe37rRaEb/7Dx2ky9ev8hg2U5ETntiD0MPatVOmTKH06dPrXt+RLHWatDRl5sxI84SIPSFOELEnYk8Q4hqM08MkhGzZsmnvX+JvDS1OxYoXdwgrqtzrN98k1u4/fYaMtGTlSu7CQzemqciJSOxhfdTtO3Zo14FlyZqVr19U53vt0bJmy252/+69enGX5vEzp8OENNETexC88AWWk8uRI6d2na+//oYKFSniMH6Affvdd9r9p06ThpasiDhPiNhzMvBLFuMP8OsNzfJokrcHS5o0qZYxf/nlF91j4sMyZsxIHTt2pDNnzhg9GDuI2BOEuAfhnTA+TX336tavR9fv3qKQ508cynDPCMqbMGFCfo4WrVvTxq1beaA+xqypIic8sQeRg1mkLVsbJgz89PPPtGbDeo5/d//xQ3r4/LHu99qjbdm+jX744QftOTAO7sDhwzxmDS1akYk92CmlvP/ii0R8DXStHjtzkm4/uEfBT0Mcxhc3792hXn37aHmicdNmEeYJEXtOBAq2ggUL8j9eLOo2dOhQoydtj4g9QYh7EDMN49Lw3uXMlZuFjV7F6SjWsHFjfha09K1at46OnjhBd4xx2yISe1gAP/DQIV7RAudPnTmTzlw875BiD+a1OHRCjOfIkbQ7YB935SIki9p9GZ7YQxfuwiVLWez9miIF+e3xpwvXLjuc2FOtRSvDUn14HozfCy9PWCP2sD40xB5axO0RqT2N9OnTR3sBMqTPQi2adRaLxOrWbkZfffW15rfYauETsScIcQt6ORA3LYVSoeO9GzF6lG5l6Ui2YMkirRyZv3gxHT4exCFIMBs1PLH3/OULFnsbNm1msffzz7/Qus2b6cylC9xieP+J44m9W8F3NT90cXOjnXv3cCw/0xVL9MTemz/+4NUjRo4ew+KoRavWtHt/AF28fsVhxd5S07iG8+aHmyesFXuYtS5iz45Bwfb555/zPzx3roIUsPMqHdxzS8wK89tymn5N/hv7Dot9xwYi9gQhblHFXvLkyfm9Gz95km5l6UhmWrHPW7CQDh+zTuy9/uMNea9dR/XqN+TxXRB7565cpBv3DEGBHU3gwFQ/dOzcxTBWzSqx9zuLPc/hI1jsYWav/4EAunzzGt15eJ8eIFCxznfZs23YsknzxfRZs8LNE9aIPQSXRoBtzGC3R6T2VMCkB/UfPmTAJF1RIxa+NazXmn334YcfGj1qW0TsCULc4vxib0GUxV7pMmVZ7GE1h4vXr3JrFgSOY4u9zlEWe4OGDqMECRKw2EP4lmt3btK9Rw/owTPXE3tXFL9B6G3YsIEePXrEs9f/++8/41tkX0jtqWAq9oYPma4raMTCt0YN2mr+iw1E7AlC3BIVsXcw6DAt916lmwZD9+nV2zd00+LSYiL2lq5YyUNWIPYwTg0C566FwMFKDL369qabyjVNv1e1nXv9aePWLbppcW2qH6Ij9urWMwQ7htg7duYUdwtzC+ezUNHrKHkiJmIP/kBQbYg9rCSC8Xp//fUXvzv2iNSeCiL2YmYi9gTBuYiK2Fu6cjm1bNNGNw0GQXH6wjndtLg0U7E3x2sBBR49Qjfu3OJAuk9ePKV9gQeoazc36tmrFwUeOkyXrlyhByEhdP3GDapduzafB7GHZ0G3paXAwYQNHHPhmiKcTL5XtbkLvGjUuHG6aXFtqh86dOpEfopQOX/5omH5NMUP8EWfvv3YF14LFvLs2zv37tH9B8F08NAhbTZvr759edyi2qpn2sLpKHnCVOxh4k14eQLm67eD88TDR4/o9t07tGPnTq0L94aSRzChyV67cIHUngoi9mJmIvYEwbmwpdizFzMVe5OmTiNfpbI+fvo0t2pdvn6NlinpWA2jWLFivNbtTKXyX4Zlulau5JUycF7mLFl1hR4sMrFnT6b6AZMs1mzYyC1Y5y9fosvXrrEvKleuwr5o1qwZTZo0iVdPWbVqFfsDq2Pg3FFjx9DdR8G6XdmOkidMxd7ocePDzRMwTOJEnsCSeVgjWRV6Bw8eZKGHiRn22qoHpPZUsKXY27ohiK8zuL/+2L99Oy7Tt99+R6VKVtJNtzTfTSdp0dyt2vaoYYaFslcv8zc7TjVc/8svv6KG9VrppltaxfI1afPaQ7pp1pqIPUFwLmwp9iZNncpj3PB58rSptGuvP9WtX58KFS5E3dy7m3Xn3Qt5QIOHeVLJUqWobPlyNHveXC0NAmuO13yqUq0qn9u2Q3uO8aamu7m70/7DB6lZyxY0cMgQbb9qthB7WbNn14SepcCJTOxt2raVlq1ayZ/nLfCic1cu0aChQ/hZqtesSWs3rjc7fsOWzVSnXj0qUrQode3uZtYShlmjjZo24XPhjw1bN2tpHgP605Wb13kGNfyI71HTVFP9EFWxB6GTJEkSPnfsxAkGoWchemH2lCcwmaZz1y66eSImYm/Lli107tw51g9o0bNnoQek9lSwtdiD2CpauIxu+rhR8ylZsp+sFnvzZq2n2jWbatsQe7h+zeqNzI5TDdeHmBSxJwhCdLGl2Ktdtw6dOHuaP2fIkJG7Di/fuMYx6voNHEAFChbitDsPgyl33rw0cuwYuv3gPt24d5tat21LXdy6cbrnyBHUqEkTuqwIGZy7ev1aXn9V/Z7CRYpSvQYN6MCRQ9o+UzPrxp03XxGGh+jqzRsU/CiEQp4+IZ/tvrzOK7pssdA/lom7fPkyB8utp4gunJdNEXt64gYWmdibOGUy9enXjz9XUb4Ha8Vu8tnK2wGHAiltunQcvw/bM+bMVp6nCB05cYyf1dv4rBgfd+32Tcqj+Olg0BE+9uS5M5QjZ046ZRSD8DdE4uz5c9mn2Gdpqh/ad+xI2xSBc/bCBQ4m/PCJ8myKL5o2bca+GDRoEI9HQ1itO3fu8CQELU9Mmhju5BR7yhMI/Lxtp5+2z9RMxd7k6TPCzRMwLy8vzhNX0JX78CEHT8ZkDHsXeSpSeyrYWuylSZ2BcmTPQzt9zoZJL1O6CvXqMTRGYq9SxVos+Px9L5gdC8P169drIWJPEIRoE1ti78cff6Trd29raVcV4YLrI4zJ8tUrqXKVKloaDJU9xohdVARUK6WSv3D1sll6hoyZtM+4tiqW9MxU7HktWsxrod5VBMSzVy/o5e+vaffePVS/fn1uzUKlfuvWLXrz5g3XDw0bNuTzIPb0rg2LqtibOXeOWXq7jh1omeIDfC5YqDC3zpmmDxnmqdz3QhaIgz09zdKat2pJC5cu4c/wt14rlqmpfujUpavy3HvpyvVr9OTFM3rx5hX7on379uyLiRMn0vnz5+np06e88AD84Wh5IujUCbN0UzMVezNmzwk3T8DwAwB5Au+Fvc64jQipPRViQ+x1at9XsT5mabt9z1O2rLlo6cJtmtg7sPsGtW3lTgUKFKOc2fNTtmy5achAQxdwl479KF3azPT99z9wGvZB7NWt3ZyqVK5LnoOmaNeG7dx6hq/fv88YTey1buFG2zYdNztuQJ/xNHfGev4sYk8QBEtiS+zlzZc/TDquD6HU26MvlSpdmme0mhpWali/eSMfC1Gw2deHZs+fR+69evK6rOp11Nag8CwqYi8oKIiD5GIsFmZYxobYO2ohQvCs8OXdkAf0008/hfFDzdq1qGefXnxs8OMQ2h2wlxYsWUwjxoymTJmz0LyFXpwGf2Oigem1LU31Q3hir23bduyLyZMnc+umujKEs+WJqIg9Hx8fLU84SmueKVJ7KsSG2Nu6Poh+SJqM/Ldf1NL69R5D3ToNoGULfTWx17fXSGrSqL12zK5t5yhJkqS0fvUB3tZr2YPYQ3rhQiW1/bDmTTvz9fv3HauJPXzPJgsx16q5G40f7cWfRewJgmBJbIm9fPlDu9hUw/VRsXft3o3ad+rIFbClYZUGtx7u3E2LsB0Ym4duvfQZMmrXwUL8pte1tMjE3uKlS7hSR6sWui3RZQmhhxat2BB7CFtimg4RA18idEuq1Kl1/XDkRBDt2reHSioCaNLUKbR521bu/oT/TcWe5bUtTfWDntjDcmGqwMFYPbWFE+PSnC1P4DqqL/TE3ipvb80XexU/IU8gPzgiUnsqxIbYw+fSpSrT2JHztLQC+YspwuqwmdgbN2oerVmxTzsGljlTdpo+aRV/Dk/s4XPePIVp++aT/Hmv3yVKnPhbvr6IPUEQYkJ8iL0pM6ZTi1atwqR36NyJDgYdpbz58oVJQwuP+jkmYu/WvTvUvHlzrtSHDx9O169f15a+imuxh8/Zs+eguyHm4+02bt1MK9espgoVK9IK5a9pWoNGjWwm9pYuX6YJnD179miiF12XzpYnIhJ7GMPYUvlu+KGN8iwYq2fPy6FFhtSeCrEl9ubOWEvly1bnzxu8Ayl/viL82VTsweYox3Vs14daNOuiCLGulDRpMqvEXg+3oeTRezR/HjNijnLNivxZxJ4gCDEhPsQeZpt+nySJNmkBhmtnU4QPBuanTpOWJydgP2K79R80kL5JnJi7NLEvKmJvznwvOoDB9jeu02FFNLj36MGVeoMGDXhCAsoc1AsQOPEh9jCrFLOK8ZzYvqmI0cJFi/Is3Go1anDYE/U8dOemSJmSZs0zjAGMithr37ETz0A9e/E8nb1wnuYv8KJGinCEL4YMGcKTU9RWvfgQe7GdJ0zF3pTpM8zyRO/evbU8gRArmJSBPOGIXbhAak+F2BJ7sDy5C9Iun7NUtUo9Gtx/Iu8zFXsVy9egNi27k8/GY9o5ObLntUrs+W05RfmMArJI4dK0YvEO/hyZ2GvaqKOIPUEQwiUqYm+rny+HvdCz6bNmcigQNfwHZlJano/jsGoBPmMmbfkKFagAwl0UKUK16tTh7jqkQSxlzZaNChQsSOXKV+BKf/iokYqA8uB0zOhUr6lnpmIvZ86cVK5cOapZsybPtEWlDluyZAk9efJEE3rAWrGHZ7B8ftUw3g5hV+APHNuzdy86e/mi2flTZ0xjX+IzYvl1695dEUL5KX/BAso1CtOiZYYJGBBJpcuU4VYthCNp16EDrdu0gcOSBAYdZn9bXtvSVD+kSJGCSpQowbNN69atq/lhwIABdPv2bV7rVY0f54x5wlTsZVOuo5cnMAvX3pdCswapPRViU+xhokafniN49iwmaGCfKvawje884H9DO37fziuUJMkPVok9WMECxWnhvE2UK6dhAgfMVOyVL1uNlnj5aGkwhIURsScIQnhEpWJ3FItI7GGcHsZkqUtemVbq1oo9RzLVD3piD3H1VHFjGijYGfNERGIPeWLnzp2cJ6AR7Hl1DGuQ2lMhNsXe2hX76IsvElG9Oi20farYO7D7OiVL9jPPvsWsXIy/a9ywLaVPl5kG9ZvAx65Y7EfZs+XRxJ+l2MPMW8w+6tFtSOg+E7GHGb0lipXnVkAIyQFKWrZsuUTsCYIQLs4u9jp27EizZs2i9evX88xbjMVCPWAqblQQT81ZxV6pUqVo3LhxtGLFCtq3b58221SNIWeKs4u91q1ba3ni6NGjZnnCkVv0VKT2VLCl2ENrXa/uw8329XDzpG0bQ8Of+CiCcPiQGfx5w+pAFoIIrVKhXA1aMn8bLV+0g1o166YdP2zwNB5nh88rFu+iiWMWaWn4PqTt2HpG27dong9NHreYPwfsvMozdAvmL0Eli1ek0YpYnDN9jSI4t3P66GFzuJtZPTc6JmJPEJwLVOxo2XFWsTdlyhQ6ceIEx4+DsMHzWoo8FVT2zir2GjduTP7+/txli3oQoiY8PzhjnjAVe6NHj7Y6TzgiUnsq2FLsuaKJ2BME5wPl4q+//srvnbOJPbTgIFjwq1evIm21QfcdRBHOw/gwvWs7mql+QEzBAwcO0IMHD1jURoaz5QnE6lN9MWHCBKvzhCMitaeCiL2YmYg9QXA+0LqRKVMmfu86d+uqW1k6ko0ZP04rR7y9venGjRvcUhVZ6w0q/p49e/J5GDKDtVr1ru8oduz0Sc0P7u7udOrUKXr27JlVAgd5AuMdcW6L1q11r+9INmnaFM0XWPPW2jzhiEjtqWAq9tSxcmLWW4N6rdl3H3/8sdGjtkXEniDEPaj8EXsO793nn39Bpy6c1a0wHcGwbmrmLFn4WX777Tc6ePAghYSEWB0gd/Xq1VoZNGP2LN3vcBTr5t5de5alS5eywMFYPGsEDvJEu3bt+NxPPvmEhaPedziCPXj6iLLnyMHP8vPPP0c5TzgaUnsqIJN//vnn/E/Pnasgj3PTEzViYc1vy2n6Nflv7LsKFSoYPWpbROwJQvywf/9+SpAgAb97aOXb4ruNbj+4p1t52qMhMPGmbVs5NAeeIWHChNxdd/XqVY4fZ213HUKQpE2blq/x5Vdf8RJlEa3Da28W/CSEzl2+yHHoPvroI36O7Nmz07lz57QxataCyQsffPABXyNd+vQc7NmR8gRaZhEapliJEvwMyN8jRoyIcp5wNKT2NDJ9+nT+x8MgXjBZQixiwyxf/OKHzz788EMKDg42etO2iNgThPgBFd+oUaO098/RrUePHnTz5k2eaRmVUBpoEMB5quBzdEPIFQSPRkxBhJqJSrcl8sSYMWNYOOtd29GsQ4cO0coTjobUnkaQ2StVqqSbGcQit0WLFhk9aXtE7AlC/IHKHWPckiZNavbOO5J9+umn5OnpyasgoPXGmskIlqCOwA/agsZWQke1atWq0eXLl+n58+fcZRkVoaeCPLFhwwb66aefdL/DEQzDjgYOHBijPOFISO1pAjL9rl27OLhkjhw5omRp0qTR3W/PliVLFkqfPr1umrWGeFVnz541ejB2ELEnCPELyka0fGzatImmTp3KLTsIVWErq1y5Mgf0xeeRI0dS3759eSIADGFPsIQXAt3is4eHBw0bNoyPs7yOpU2cOJHWrFlD9+/f5wodrVgxab2BHyAK0JWJlRXGjh2r+73RNaxc8cUXX2jPhnV6EQsPfihatCi1aNGCatWqxb7q2rUrDR06lLsgLa9jafh/zZs3jw4dOsSzTRFLD88RHaGngnPRvR1beQKtsJ07d+bPaF2GMMuVKxf7ok6dOpwXUFdjOTPkF2vzBLrxV61aRXfu3LFJnnAUpPa0ERjIjIkejgQixiOApL0jYk8Q7ANU8GjVgaGCtJUVLlyYVy6AAMFsyHXr1nG4E5Srfn5+LFQwmQCBf9H1qIoVvWvpGe43JsJGD9UXet8XXVOHE/n4+PA4OpR98AF8AWEJgblgwQJuaUUrI8QWWuf0rqVnsekHW/sC4q1Xr178GXXrtm3b2A9NmzZl/yB8zuLFizlOoL3kCXtGak8bgF8GGLCKQsmRQHDMVKlSGbfsFxF7guC8oKUJ7za61fCuQ+z179+fmjRpwq14GCICgYPF6BEPDjNHUVk7I2jhhC/w7HhGtMThM0TO3LlzaebMmSx61RY6NfivM4IfAL/88guLMtSx6IaHLyAAFy5cyP7ALGmIXmfOE7ZCak8bgGjseEELFChg3GP/oFtDFVAoYO0ZEXuC4LygC059v/EZqzmoAgfdcjNmzOAWnMOHD2tr1zqjwEHrlTrp4csvv+T1aSFy4Qt036IlCy2cEDgov9GSBSHkjCAcjJon0IqJcXUIAI08gRa/yZMns28CAwOdOk/YEqk9YwgyGX6Rqhnz4sWLxhT7pk2bNto9o0C1Z0TsCYJzAsFiOqvzs88+465KCByM08O6rWjBUSt8tPo5awsOnlH1A6x79+7UrVs3FjgYvwaBgxat06dPc6seuiydFYxTVP2A3qetW7dqeQLj99DCifV80arnzHnClkjtGUMwfd30Bc2TJ48xxX7Bi4FQKeo9Y0CwPb8sIvYEwTnB5An13VatSJEiLHBQuastOAh4iwkiztxtiS5LUz9gBjEmH8DQrY0Wzo0bN3J56MyteljNw9QPMEzIQJ6A2Bs/fjy3cAYEBDh9nrAlUnvGEBRMlhkTQSrtGTR9W94zZlTZKyL2BME5yZ07txbkF4YfoUmSJOFKvXXr1ixw0IJz7949pxY4WJMVz68GK1Z/jCPMC2acYnLGnDlzeGkzdayeswIhp+YH1VKnTs15omXLlvwDYMmSJdzd78x5wtZI7RkDMFgYGRHLxuCv+oJifIk9U6VKFa1QgaGw/f77742p9oeIPUFwPtCCg6W3sHKB+n5PmzaNxR668dB1CYGDsXqICefMLTj58+fnCX4IZwU/ILQKJihgEh1aOBFCBqIXy3k5u8BBPMesWbNqeQKBrFFHVa9enbu18QMAK7sg/0irnvVI7RkDEAPpxIkT3M2ATIkXFQLQzc3NeIT9gV+F+JV45coV7WVCgE1MMsEvJXtExJ4gOB/qmDN1Ni6sT58+mtBB3LaVK1dq47KcVeBArKi+UMUenh/dluXLl+f6BCJY7cp25rF6eD7EbYWgVfNEp06duActW7ZsXOeiVe/u3bs8A1da9axHak8boI47wYvqKGAGk/oyIbCkPSNiTxCcF1Oxh7FZ6HnAODUInGPHjnFZ5czdlqaoYg9B+uEDtHBiQsLy5ct5Bi5m7LpCSxYmPqp5omrVqmzIG2jhRNgZtVVPsB6pPW2AiL3YRcSeIDgvGOOsvt8IrFyiRAmOpYb4ehA4ztyqZ4kq9jADFTH30HU5adIk7kGCwHHmVj1TTMUeljEtWbIkt3BiZjZWvpBWvagjtacNELEXu4jYEwTn5dq1a9r7Xbp0aTbMuMQKP642LksVe7/++isVL16cJ6mgVQ9DbCBwXMUPeFY1T2CZOLWFc8eOHVwfRHdNX1dGak8bIGIvdhGxJwjOy7lz57T3G7NPMesS46Bv3rzpUq16QBV7P/zwA4ucQYMG8Tq8WA7MlbotIfLVPIEZ21gXefbs2Ty+HPWVtOpFHak9bYCIvdhFxJ4gOC9nzpzR3m+sQoRgwpiMgJmnriRw0FKVPXt29gPEHiZnQPRiNQlXEzgIoK3mCYi9zp070549e7hbH616QtSR2tMGiNiLXUTsCYLzghUh1Pe7UKFCNH/+fA7HgokbriRwLMUeVjlCVzaEj6sJHDWsGQxiD+FWLly4wCF4ZLWM6CG1pw0QsRe7iNgTBOfFtGUPAYRPnjzJ68JikL4rYSr2kiVLxmFn0Kr3+vVrl+u2NG3Zw+xsdGUjBA9CsgjRQ2pPGyBiL3YRsScIzgviqqnvN1ZPwPvuquudqmP2cubMyauGqMGkXQ2IfTVPINwKtlFPSate9JHa0waI2ItdROwJgvNi2mWHlix0Wbpqpa6KvYYNG3LLpivNRDbFNKhyUFCQS+cJWyG1pw0QsRe7iNgTBOfFNKgyVlBwZVSx17NnT+Me18Q0zh5WyxBijtSeNgBrGmItv9q1axv32D8YB5I5c2a+b3SZ2DMi9gTBeTEVe642Ts8SVeyNHj3auMc1MRV7yB9CzJHaU7B70PKI6On2vOawIAjRQ8ReKCL2DIjYsz0i9gRBEIR4Q8ReKCL2DIjYsz0i9gRBEIR4Q8ReKCL2DIjYsz0i9mIIZg1hkWoEv1SjvtsrmM0U0YuDWE6YuBHfU/1xn7iPiLDmGEEQ7B8Re6GI2DMgYs/2iNiLAVisO2HChJQuXTqaNGkStWrVij7++GMqUqSIXRZaiFSfKlUq45Y5mN5fpkwZatCgQbxP9VdfdATRDI/Vq1dT3rx5jVuCIDgqIvZCEbFnQMSe7RGxF0369OnDog7BHk1BixMCg+bLl8/u4gKFJ/bwYuFZsOi2vdCxY0deNik8sGA6grEKguDYiNgLRcSeARF7tkfEXjRA4E8saxNRC1ivXr146R97Qk/sPXnyhH755Rc6cuSIcY99gO7wpEmTGrfMQSyu5MmTG7cEQXBkROyFImLPgIg92yNiLxp4enrSrl27jFv6PH36lDOqPa3lZyn2MOYtceLEvDalPZIhQwa6f/++cSsUdOEuWLDAuCUIgiMjYi8UEXsGROzZHhF70QCCCWsWRsaXX35J586dM27FP6ZiD1HJEyVKRDt27OBte2T9+vXcJW5JoUKFeKFsQRAcHxF7oYjYMyBiz/aI2IsGn3/+uVWFEhazxgxde0EVewcOHKBcuXJR0aJFycPDw5hqfyCY8g8//GDWXY5JG9myZTNuCYLg6IjYC0XEngERe7ZHxF40+Prrr60qlDJlymRXY+Eg9jBbGF23WCINIVa+//57u57oUKpUKTp58qRxi6h9+/a0bNky45YgCI6OiL1QROwZELFne0TsRQN0I0YUFgQgZt1HH33EkznsBYg9dN1irVkV3F+SJEno999/N+6xL7Zs2UJVqlThz//88w+LVdP7FwTBsRGxF4qIPQMi9myPiL1ogJh6ixYtMm6FglArapcjRNSHH35oV+FXLCdoqEyYMIF+/PFHuwsVA16/fs0vvBq8GjENBUFwHkTshSJiz4CIPdsjYi8aIPN98803HALEFIgpxH+7efMm/505c6YxxT4IT+yhFbJcuXLUrVs34x77onz58uTj48NBqwMCAox7BUFwBkTshSJiz4CIPdsjYi+abN++nT777DPuZlTDq0A0rV27ljNosWLFeJ89EZ7YA2iRLFy4MIeVsTeuXLnCcQ1/+umneF/dQxAE2yJiLxQRewZE7NkeEXsx4M6dO9yCp2ZKGLpu0cVbokQJGjlypF2Jk4jEHsC4PYyJiyyGYHyAIMrjxo0zbgmC4CyI2AtFxJ4BEXu2R8SeDUDLHgIUY3wZWvcA/i5ZsoRnvAqCIAj6iNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBviNgLRcSeARF7tkfEniAIghBvvHv3jry8vNj+/fdf417XZMOGDeyH06dPG/e4JsgHap5A/hBijog9QRAEQRAEJ0bEniAIgiAIghMjYk8QBEEQBMGJEbEnCIIgCILgxIjYEwRBEARBcGJE7AmCIAhxxj///EP37t0zbunz/v37SI9xFh4+fEj//fefcSssjx494mNcBeQPHx8fmjp1KltAQADvE2KGiD1BEAQhzkDF/emnn9LNmzeNe8Kyf/9+KlmypHHLuUmVKhU9f/7cuGUORE++fPnojz/+MO5xbgIDAylx4sTUqVMnfnYYPmPfmjVrjEcJ0UHEniAIghCnDBkyhMaOHWvcCkuWLFlox44dxi3nJjyxt2TJEvrpp59cJtD0iRMnKFGiRPTs2TPjnlCePn3KaSL4oo+IPUEQBCFOCQkJoaRJkxq3zHn58iWvnPDmzRvjHudGT+x5enpS/vz5XaZFD629X375JR07dsy4JyzBwcH09ddfS5duNBGxJwiCIMQ56KbV68pduHAhdezY0bjl/JiKPawWUb58eXJzc+Nxi67C3r176bfffjNuhU+PHj24i1+IOiL2BEEQhDgH3bRjxowxboUC8XP79m3jlvOjij2IuyJFilCjRo2MKa7DyJEjacGCBcat8Dl06FCE3f9C+IjYEwRBEOIcdNP+8MMPZi1Y6KrLli2bccs1gNg7d+4clSlThho0aMBj09CV7Ur07duXNm7caNwKnzNnzpCHh4dxS4gKIvYEQRCEeKFu3bp04MAB4xZR7dq1rar0nQmIPcxO9vX15e25c+dS1qxZXWZiBhg0aBCtXr3auBU+mMSB8YxC1BGxJwiCIMQLe/bs4Zm3AOIGEzNevXrF264CxJ7lzOPOnTtT2bJlXWbc3tKlS6lhw4bGrfCZNm0aLV++3LglRAURe4IgCEK8AIGXMGFC7rZE8FxMTnA11DF7pmCiBuLrjR8/3rjHubl16xZ99NFH9PbtW+MeAwg2jTQA4Zs9e3bu6heijog9QRAEId5wd3cnLy8vnp175coV417XQU/sgb///pu7cxFo2BXADOz69eubtWbCB23atKGePXtS+/btudtfiB4i9gRBEIR4Ay0133//PSVPnty4x7UIT+yB+/fv02effUYvXrww7nFeIPJKly7NE1Xu3LnD27AbN25w/kAXv7TqRR8Re4IgCEK8ghU1/P39jVuuxfDhwyMMnuzn58eTEkxbvJwVdNt6e3tT5syZ6cMPP6QPPviAP2PyBgIuFyhQgANyC1FHxJ4gCIIgCHYPunVdaZayLRGxJwiCIAiC4MSI2BMEQRAEQXBiROwJgiAIgiA4MSL2BEEQBEEQnBgRe4IgCIIgCE6MiD1BEARBEAQnRsSeIAiCIAiCEyNiTxAEQRAEwYkRsScIgiAIguDEiNgTBEEQBEFwYkTsCYIgCIIgODEi9gRBEARBEJwYEXuCIAiCIAhOjIg9QRAEQRAEJ0bEniAIgiAIghMjYk8QBEEQBMGJEbEnCIIgCILgxIjYEwRBEARBcFqI/g9bAytIYGrv0gAAAABJRU5ErkJggg==)"
      ],
      "metadata": {
        "id": "AYvCkD8NJA6n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "But the next layer (the Feed-Forward layer) is expecting just one matrix, a vector for each word, so after calculating the dot product of every head, we concat the output matrices and multiply them by an additional weights matrix $W_{O}$ This final matrix captures information from all the attention heads.\n",
        "\n",
        "$$MultiHead(Q,K,V) = Concat(head_{1},...,head_{n})W_{O}$$\n",
        "where $$head_{i} = Attention(QW^{Q}_{i},QW^{K}_{i},QW^{V}_{i})$$ and $i$ is the head index.\n"
      ],
      "metadata": {
        "id": "OJj-heymJt_i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MultiHeadAttention(layers.Layer):\n",
        "    \n",
        "    def __init__(self, n_heads):\n",
        "        super(MultiHeadAttention, self).__init__()\n",
        "        self.n_heads = n_heads\n",
        "        \n",
        "    def build(self, input_shape):\n",
        "        self.d_model = input_shape[-1]\n",
        "        assert self.d_model % self.n_heads == 0\n",
        "        # Calculate the dimension of every head or projection\n",
        "        self.d_head = self.d_model // self.n_heads\n",
        "        # Set the weight matrices for Q, K and V\n",
        "        self.query_lin = layers.Dense(units=self.d_model)\n",
        "        self.key_lin = layers.Dense(units=self.d_model)\n",
        "        self.value_lin = layers.Dense(units=self.d_model)\n",
        "        # Set the weight matrix for the output of the multi-head attention W0\n",
        "        self.final_lin = layers.Dense(units=self.d_model)\n",
        "        \n",
        "    def split_proj(self, inputs, batch_size): # inputs: (batch_size, seq_length, d_model)\n",
        "        # Set the dimension of the projections\n",
        "        shape = (batch_size,\n",
        "                 -1,\n",
        "                 self.n_heads,\n",
        "                 self.d_head)\n",
        "        # Split the input vectors\n",
        "        splited_inputs = tf.reshape(inputs, shape=shape) # (batch_size, seq_length, nb_proj, d_proj)\n",
        "        return tf.transpose(splited_inputs, perm=[0, 2, 1, 3]) # (batch_size, nb_proj, seq_length, d_proj)\n",
        "    \n",
        "    def call(self, queries, keys, values, mask):\n",
        "        # Get the batch size\n",
        "        batch_size = tf.shape(queries)[0]\n",
        "        # Set the Query, Key and Value matrices\n",
        "        queries = self.query_lin(queries)\n",
        "        keys = self.key_lin(keys)\n",
        "        values = self.value_lin(values)\n",
        "        # Split Q, K y V between the heads or projections\n",
        "        queries = self.split_proj(queries, batch_size)\n",
        "        keys = self.split_proj(keys, batch_size)\n",
        "        values = self.split_proj(values, batch_size)\n",
        "        # Apply the scaled dot product\n",
        "        attention = scaled_dot_product_attention(queries, keys, values, mask)\n",
        "        # Get the attention scores\n",
        "        attention = tf.transpose(attention, perm=[0, 2, 1, 3])\n",
        "        # Concat the h heads or projections\n",
        "        concat_attention = tf.reshape(attention,\n",
        "                                      shape=(batch_size, -1, self.d_model))\n",
        "        # Apply W0 to get the output of the multi-head attention\n",
        "        outputs = self.final_lin(concat_attention)\n",
        "        \n",
        "        return outputs"
      ],
      "metadata": {
        "id": "KepBr_tQJto5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. **Positional Enconding**\n",
        "\n",
        "The order of the words in the sentence is an issue to solve in this model, because the network and the self-attention mechanism is permutation invariant. If we shuffle up the words in the input sentence, we get the same solutions. We need to create a representation of the position of the word in the sentence and add it to the word embedding.\n",
        "\n",
        "*To this end, we add \"positional encodings\" to the input embeddings at the bottoms of the encoder and decoder stacks. The positional encodings have the same dimension as the embeddings, so that the two can be summed. There are many choices of positional encodings.*\n",
        "\n",
        "In the \"Attention is all you need\" paper - a sinusoidal function is applied:\n",
        "\n",
        "$$PE_{(pos,2i)} = sin(pos/10000^{2i/dmodel})$$\n",
        "$$PE_{(pos,2i+1)} = cos(pos/10000^{2i/dmodel})$$"
      ],
      "metadata": {
        "id": "45g1Qb8uxtAY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PositionalEncoding(layers.Layer):\n",
        "\n",
        "    def __init__(self):\n",
        "        super(PositionalEncoding, self).__init__()\n",
        "    \n",
        "    def get_angles(self, pos, i, d_model): # pos: (seq_length, 1) i: (1, d_model)\n",
        "        angles = 1 / np.power(10000., (2*(i//2)) / np.float32(d_model))\n",
        "        return pos * angles # (seq_length, d_model)\n",
        "\n",
        "    def call(self, inputs):\n",
        "        # input shape batch_size, seq_length, d_model\n",
        "        seq_length = inputs.shape.as_list()[-2]\n",
        "        d_model = inputs.shape.as_list()[-1]\n",
        "        # Calculate the angles given the input\n",
        "        angles = self.get_angles(np.arange(seq_length)[:, np.newaxis],\n",
        "                                 np.arange(d_model)[np.newaxis, :],\n",
        "                                 d_model)\n",
        "        # Calculate the positional encodings\n",
        "        angles[:, 0::2] = np.sin(angles[:, 0::2])\n",
        "        angles[:, 1::2] = np.cos(angles[:, 1::2])\n",
        "        # Expand the encodings with a new dimension\n",
        "        pos_encoding = angles[np.newaxis, ...]\n",
        "        \n",
        "        return inputs + tf.cast(pos_encoding, tf.float32)"
      ],
      "metadata": {
        "id": "dVcP6LoAJAqh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. **The Encoder**\n",
        "Now that all the main pieces of the model have been described we can introduce the encoder components. \n",
        "\n",
        "* *Positional encoding*: Add the position encoding to the input embedding (our input words are transformed to embedding vectors). \"The same weight matrix is shared between the two embedding layers (encoder and decoder) and the pre-softmax linear transformation. In the embedding layers, we multiply those weights by square root of the model dimension\", $\\sqrt{d_{model}}$.\n",
        "\n",
        "* $N = 6$, identical layers, containing two sub-layers: **a multi-head self-attention mechanism**, and a **fully connected feed-forward network**. This FC layer is applied to each position separately and identically and consists of two linear transformations with a ReLU activation in between. But it is applied position-wise to the input, which means that the same neural network is applied to every single \"token\" vector belonging to the sentence sequence.\n",
        "\n",
        "There is a residual connection around each sub-layer (attention and FC network) followed by a layer normalization.\n",
        "\n",
        "*Normalization and residual connections are standard tricks used to help deep neural networks train faster and more accurately. The layer normalization is applied over the embedding dimension only.*\n",
        "\n",
        "![encoder.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "### Only the vector from the last layer (6-th) is sent to the decoder."
      ],
      "metadata": {
        "id": "vfxWBJ7c1ZGB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class EncoderLayer(layers.Layer):\n",
        "    \n",
        "    def __init__(self, FFN_units, n_heads, dropout_rate):\n",
        "        super(EncoderLayer, self).__init__()\n",
        "        # Hidden units of the feed forward component\n",
        "        self.FFN_units = FFN_units\n",
        "        # Set the number of projectios or heads\n",
        "        self.n_heads = n_heads\n",
        "        # Dropout rate\n",
        "        self.dropout_rate = dropout_rate\n",
        "    \n",
        "    def build(self, input_shape):\n",
        "        self.d_model = input_shape[-1]\n",
        "        # Build the multihead layer\n",
        "        self.multi_head_attention = MultiHeadAttention(self.n_heads)\n",
        "        self.dropout_1 = layers.Dropout(rate=self.dropout_rate)\n",
        "        # Layer Normalization\n",
        "        self.norm_1 = layers.LayerNormalization(epsilon=1e-6)\n",
        "        # Fully connected feed forward layer\n",
        "        self.ffn1_relu = layers.Dense(units=self.FFN_units, activation=\"relu\")\n",
        "        self.ffn2 = layers.Dense(units=self.d_model)\n",
        "        self.dropout_2 = layers.Dropout(rate=self.dropout_rate)\n",
        "        # Layer normalization\n",
        "        self.norm_2 = layers.LayerNormalization(epsilon=1e-6)\n",
        "        \n",
        "    def call(self, inputs, mask, training):\n",
        "        # Forward pass of the multi-head attention\n",
        "        attention = self.multi_head_attention(inputs,\n",
        "                                              inputs,\n",
        "                                              inputs,\n",
        "                                              mask)\n",
        "        attention = self.dropout_1(attention, training=training)\n",
        "        # Call to the residual connection and layer normalization\n",
        "        attention = self.norm_1(attention + inputs)\n",
        "        # Call to the FC layer\n",
        "        outputs = self.ffn1_relu(attention)\n",
        "        outputs = self.ffn2(outputs)\n",
        "        outputs = self.dropout_2(outputs, training=training)\n",
        "        # Call to residual connection and the layer normalization\n",
        "        outputs = self.norm_2(outputs + attention)\n",
        "        \n",
        "        return outputs\n",
        "        \n",
        "class Encoder(layers.Layer):\n",
        "    \n",
        "    def __init__(self,\n",
        "                 n_layers,\n",
        "                 FFN_units,\n",
        "                 n_heads,\n",
        "                 dropout_rate,\n",
        "                 vocab_size,\n",
        "                 d_model,\n",
        "                 name=\"encoder\"):\n",
        "        super(Encoder, self).__init__(name=name)\n",
        "        self.n_layers = n_layers\n",
        "        self.d_model = d_model\n",
        "        # The embedding layer\n",
        "        self.embedding = layers.Embedding(vocab_size, d_model)\n",
        "        # Positional encoding layer\n",
        "        self.pos_encoding = PositionalEncoding()\n",
        "        self.dropout = layers.Dropout(rate=dropout_rate)\n",
        "        # Stack of n layers of multi-head attention and FC\n",
        "        self.enc_layers = [EncoderLayer(FFN_units,\n",
        "                                        n_heads,\n",
        "                                        dropout_rate) \n",
        "                           for _ in range(n_layers)]\n",
        "    \n",
        "    def call(self, inputs, mask, training):\n",
        "        # Get the embedding vectors\n",
        "        outputs = self.embedding(inputs)\n",
        "        # Scale the embeddings by sqrt of d_model\n",
        "        outputs *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
        "        # Positional encodding\n",
        "        outputs = self.pos_encoding(outputs)\n",
        "        outputs = self.dropout(outputs, training)\n",
        "        # Call the stacked layers\n",
        "        for i in range(self.n_layers):\n",
        "            outputs = self.enc_layers[i](outputs, mask, training)\n",
        "\n",
        "        return outputs"
      ],
      "metadata": {
        "id": "H2wYZie31e-_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. **The Decoder**\n",
        "\n",
        "The decoder share some components with the encoder but they are used in a different way to take into account the encoder output.\n",
        "\n",
        "* Positional encoding: Similar that the one in the encoder\n",
        "\n",
        "* $N=6$ identical layers, containing 3 three sublayers. First, the Masked Multi-head attention or **masked causal attention** to prevent positions from attending to subsequent positions, hiding those features that belong to future states of the sequence. \"This masking, combined with fact that the output embeddings are offset by one position, ensures that the predictions for position i can depend only on the known outputs at positions less than i\". It is implemented by setting to $-∞$, the values corresponding to the forbidden states in the softmax layer of the dot-product attention modules. The second component or \"**encoder-decoder attention**\" performs multi-head attention over the output of the decoder, the Key and Value vectors come from the output of the encoder but the queries come from the previous decoder layer. This allows every position in the decoder to attend over all positions in the input sequence . And finally the fully-connected network.\n",
        "\n",
        "* The residual connection and layer normalization around each sub-layer, similar to the encoder.\n",
        "\n",
        "![decoder.png](data:image/png;base64,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)\n",
        "\n",
        "\n",
        "At the end of the $N$ stacked decoders, the **linear layer**, a fully-connected network, transforms the stacked outputs to a much larger vector, the logits. The **softmax layer** then turns those scores (logits) into probabilities (all positive, all add up to 1.0). The cell with the highest probability is chosen, and the word associated with it is produced as the output for this time step."
      ],
      "metadata": {
        "id": "3TnPfgd52bb6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DecoderLayer(layers.Layer):\n",
        "    \n",
        "    def __init__(self, FFN_units, n_heads, dropout_rate):\n",
        "        super(DecoderLayer, self).__init__()\n",
        "        self.FFN_units = FFN_units\n",
        "        self.n_heads = n_heads\n",
        "        self.dropout_rate = dropout_rate\n",
        "    \n",
        "    def build(self, input_shape):\n",
        "        self.d_model = input_shape[-1]\n",
        "        \n",
        "        # Self multi head attention, causal attention\n",
        "        self.multi_head_causal_attention = MultiHeadAttention(self.n_heads)\n",
        "        self.dropout_1 = layers.Dropout(rate=self.dropout_rate)\n",
        "        self.norm_1 = layers.LayerNormalization(epsilon=1e-6)\n",
        "        \n",
        "        # Multi head attention, encoder-decoder attention \n",
        "        self.multi_head_enc_dec_attention = MultiHeadAttention(self.n_heads)\n",
        "        self.dropout_2 = layers.Dropout(rate=self.dropout_rate)\n",
        "        self.norm_2 = layers.LayerNormalization(epsilon=1e-6)\n",
        "        \n",
        "        # Feed foward\n",
        "        self.ffn1_relu = layers.Dense(units=self.FFN_units,\n",
        "                                    activation=\"relu\")\n",
        "        self.ffn2 = layers.Dense(units=self.d_model)\n",
        "        self.dropout_3 = layers.Dropout(rate=self.dropout_rate)\n",
        "        self.norm_3 = layers.LayerNormalization(epsilon=1e-6)\n",
        "        \n",
        "    def call(self, inputs, enc_outputs, mask_1, mask_2, training):\n",
        "        # Call the masked causal attention\n",
        "        attention = self.multi_head_causal_attention(inputs,\n",
        "                                                inputs,\n",
        "                                                inputs,\n",
        "                                                mask_1)\n",
        "        attention = self.dropout_1(attention, training)\n",
        "        # Residual connection and layer normalization\n",
        "        attention = self.norm_1(attention + inputs)\n",
        "        # Call the encoder-decoder attention\n",
        "        attention_2 = self.multi_head_enc_dec_attention(attention,\n",
        "                                                  enc_outputs,\n",
        "                                                  enc_outputs,\n",
        "                                                  mask_2)\n",
        "        attention_2 = self.dropout_2(attention_2, training)\n",
        "        # Residual connection and layer normalization\n",
        "        attention_2 = self.norm_2(attention_2 + attention)\n",
        "        # Call the Feed forward\n",
        "        outputs = self.ffn1_relu(attention_2)\n",
        "        outputs = self.ffn2(outputs)\n",
        "        outputs = self.dropout_3(outputs, training)\n",
        "        # Residual connection and layer normalization\n",
        "        outputs = self.norm_3(outputs + attention_2)\n",
        "        \n",
        "        return outputs\n",
        "class Decoder(layers.Layer):\n",
        "    \n",
        "    def __init__(self,\n",
        "                 n_layers,\n",
        "                 FFN_units,\n",
        "                 n_heads,\n",
        "                 dropout_rate,\n",
        "                 vocab_size,\n",
        "                 d_model,\n",
        "                 name=\"decoder\"):\n",
        "        super(Decoder, self).__init__(name=name)\n",
        "        self.d_model = d_model\n",
        "        self.n_layers = n_layers\n",
        "        # Embedding layer\n",
        "        self.embedding = layers.Embedding(vocab_size, d_model)\n",
        "        # Positional encoding layer\n",
        "        self.pos_encoding = PositionalEncoding()\n",
        "        self.dropout = layers.Dropout(rate=dropout_rate)\n",
        "        # Stacked layers of multi-head attention and feed forward\n",
        "        self.dec_layers = [DecoderLayer(FFN_units,\n",
        "                                        n_heads,\n",
        "                                        dropout_rate) \n",
        "                           for _ in range(n_layers)]\n",
        "    \n",
        "    def call(self, inputs, enc_outputs, mask_1, mask_2, training):\n",
        "        # Get the embedding vectors\n",
        "        outputs = self.embedding(inputs)\n",
        "        # Scale by sqrt of d_model\n",
        "        outputs *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
        "        # Positional encodding\n",
        "        outputs = self.pos_encoding(outputs)\n",
        "        outputs = self.dropout(outputs, training)\n",
        "        # Call the stacked layers\n",
        "        for i in range(self.n_layers):\n",
        "            outputs = self.dec_layers[i](outputs,\n",
        "                                         enc_outputs,\n",
        "                                         mask_1,\n",
        "                                         mask_2,\n",
        "                                         training)\n",
        "\n",
        "        return outputs"
      ],
      "metadata": {
        "id": "4Ii7Wi3K5N7C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. **Transformer**\n",
        "\n",
        "Once we have defined our components and created the encoder, the decoder and the linear-softmax final layer, we join the pieces to form our model, the Transformer.\n",
        "\n",
        "![transformer_architecture.png](data:image/png;base64,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)\n",
        "\n"
      ],
      "metadata": {
        "id": "LMAzPdYg5Y9e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Transformer(tf.keras.Model):\n",
        "    \n",
        "    def __init__(self,\n",
        "                 vocab_size_enc,\n",
        "                 vocab_size_dec,\n",
        "                 d_model,\n",
        "                 n_layers,\n",
        "                 FFN_units,\n",
        "                 n_heads,\n",
        "                 dropout_rate,\n",
        "                 name=\"transformer\"):\n",
        "        super(Transformer, self).__init__(name=name)\n",
        "        # Build the encoder\n",
        "        self.encoder = Encoder(n_layers,\n",
        "                               FFN_units,\n",
        "                               n_heads,\n",
        "                               dropout_rate,\n",
        "                               vocab_size_enc,\n",
        "                               d_model)\n",
        "        # Build the decoder\n",
        "        self.decoder = Decoder(n_layers,\n",
        "                               FFN_units,\n",
        "                               n_heads,\n",
        "                               dropout_rate,\n",
        "                               vocab_size_dec,\n",
        "                               d_model)\n",
        "        # build the linear transformation and softmax function\n",
        "        self.last_linear = layers.Dense(units=vocab_size_dec, name=\"lin_ouput\")\n",
        "    \n",
        "    def create_padding_mask(self, seq): #seq: (batch_size, seq_length)\n",
        "        # Create the mask for padding\n",
        "        mask = tf.cast(tf.math.equal(seq, 0), tf.float32)\n",
        "        return mask[:, tf.newaxis, tf.newaxis, :]\n",
        "\n",
        "    def create_look_ahead_mask(self, seq):\n",
        "        # Create the mask for the causal attention\n",
        "        seq_len = tf.shape(seq)[1]\n",
        "        look_ahead_mask = 1 - tf.linalg.band_part(tf.ones((seq_len, seq_len)), -1, 0)\n",
        "        return look_ahead_mask\n",
        "    \n",
        "    def call(self, enc_inputs, dec_inputs, training):\n",
        "        # Create the padding mask for the encoder\n",
        "        enc_mask = self.create_padding_mask(enc_inputs)\n",
        "        # Create the mask for the causal attention\n",
        "        dec_mask_1 = tf.maximum(\n",
        "            self.create_padding_mask(dec_inputs),\n",
        "            self.create_look_ahead_mask(dec_inputs)\n",
        "        )\n",
        "        # Create the mask for the encoder-decoder attention\n",
        "        dec_mask_2 = self.create_padding_mask(enc_inputs)\n",
        "        # Call the encoder\n",
        "        enc_outputs = self.encoder(enc_inputs, enc_mask, training)\n",
        "        # Call the decoder\n",
        "        dec_outputs = self.decoder(dec_inputs,\n",
        "                                   enc_outputs,\n",
        "                                   dec_mask_1,\n",
        "                                   dec_mask_2,\n",
        "                                   training)\n",
        "        # Call the Linear and Softmax functions\n",
        "        outputs = self.last_linear(dec_outputs)\n",
        "        \n",
        "        return outputs"
      ],
      "metadata": {
        "id": "7AO5NAc65koK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is worth mentioning that we create 3 masks, each of which will allow us:\n",
        "\n",
        "* *Encoder mask*: It is a padding mask to discard the pad tokens from the attention calculation.\n",
        "* *Decoder mask 1*: this mask is a union of the padding mask and the look ahead mask which will help the causal attention to discard the tokens \"in the future\". We take the maximum value between the padding mask and the look ahead one.\n",
        "* *Decoder mask 2*: it is the padding mask and is applied in the encoder-decoder attention layer.\n",
        "\n",
        "As you can see - we call the encoder, the decoder and the final linear-softmax layer to get the predicted output from our Transformer model.\n",
        "\n",
        "## 6. **Training the Transformer model**\n",
        "\n",
        "Now that we have described in detail the components in the paper we are ready to implement them and train a transformer model on a NMT problem. It is a toy problem for educational purposes.\n",
        "\n",
        "We need to create a custom loss function to mask the padding tokens and we define the Adam optimizer described in the paper, with $\\beta_{1} = 0.9$, $\\beta_{2} = 0.98$ and $\\epsilon = 10e^{-9}$. And then we create a scheduler to vary the learning rate over the training process according to:\n",
        "\n",
        "$$l_{rate} = d^{-0.5}_{model} * min(step\\_num^{-0.5},step\\_num *warmup\\_steps^{-1.5})$$"
      ],
      "metadata": {
        "id": "AWNnnFGq5qCt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def loss_function(target, pred):\n",
        "    mask = tf.math.logical_not(tf.math.equal(target, 0))\n",
        "    loss_ = loss_object(target, pred)\n",
        "    \n",
        "    mask = tf.cast(mask, dtype=loss_.dtype)\n",
        "    loss_ *= mask\n",
        "    \n",
        "    return tf.reduce_mean(loss_)\n",
        "\n",
        "class CustomSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):\n",
        "    \n",
        "    def __init__(self, d_model, warmup_steps=4000):\n",
        "        super(CustomSchedule, self).__init__()\n",
        "        \n",
        "        self.d_model = tf.cast(d_model, tf.float32)\n",
        "        self.warmup_steps = warmup_steps\n",
        "    \n",
        "    def __call__(self, step):\n",
        "        arg1 = tf.math.rsqrt(step)\n",
        "        arg2 = step * (self.warmup_steps**-1.5)\n",
        "        \n",
        "        return tf.math.rsqrt(self.d_model) * tf.math.minimum(arg1, arg2)"
      ],
      "metadata": {
        "id": "m6aIzKec72ba"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And that's all. We now have all the necessary elements to train our model using an usual loop for sequence-to-sequence tasks:\n",
        "\n",
        "* For every iteration on the batch generator that produce batch size inputs and outputs\n",
        "* Get the input sequence from 0 to length-1 and the actual outputs from 1 to length, the next word expected at every sequence step.\n",
        "* Call the transformer to get the predictions\n",
        "* Calculate the loss function between the real outputs and the predictions\n",
        "* Apply the gradients to update the weights in the model\n",
        "* Calculate the mean loss and the accuracy for the batch data\n",
        "* Show some results and save the model in every epoch"
      ],
      "metadata": {
        "id": "3YX1Q_h58LKR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def main_train(dataset, transformer, n_epochs, print_every=50):\n",
        "  ''' Train the transformer model for n_epochs using the data generator dataset'''\n",
        "  losses = []\n",
        "  accuracies = []\n",
        "  # In every epoch\n",
        "  for epoch in range(n_epochs):\n",
        "    print(\"Starting epoch {}\".format(epoch+1))\n",
        "    start = time.time()\n",
        "    # Reset the losss and accuracy calculations\n",
        "    train_loss.reset_states()\n",
        "    train_accuracy.reset_states()\n",
        "    # Get a batch of inputs and targets\n",
        "    for (batch, (enc_inputs, targets)) in enumerate(dataset):\n",
        "        # Set the decoder inputs\n",
        "        dec_inputs = targets[:, :-1]\n",
        "        # Set the target outputs, right shifted\n",
        "        dec_outputs_real = targets[:, 1:]\n",
        "        with tf.GradientTape() as tape:\n",
        "            # Call the transformer and get the predicted output\n",
        "            predictions = transformer(enc_inputs, dec_inputs, True)\n",
        "            # Calculate the loss\n",
        "            loss = loss_function(dec_outputs_real, predictions)\n",
        "        # Update the weights and optimizer\n",
        "        gradients = tape.gradient(loss, transformer.trainable_variables)\n",
        "        optimizer.apply_gradients(zip(gradients, transformer.trainable_variables))\n",
        "        # Save and store the metrics\n",
        "        train_loss(loss)\n",
        "        train_accuracy(dec_outputs_real, predictions)\n",
        "        \n",
        "        if batch % print_every == 0:\n",
        "            losses.append(train_loss.result())\n",
        "            accuracies.append(train_accuracy.result())\n",
        "            print(\"Epoch {} Batch {} Loss {:.4f} Accuracy {:.4f}\".format(\n",
        "                epoch+1, batch, train_loss.result(), train_accuracy.result()))\n",
        "            \n",
        "    # Checkpoint the model on every epoch        \n",
        "    ckpt_save_path = ckpt_manager.save()\n",
        "    print(\"Saving checkpoint for epoch {} in {}\".format(epoch+1,\n",
        "                                                        ckpt_save_path))\n",
        "    print(\"Time for 1 epoch: {} secs\\n\".format(time.time() - start))\n",
        "\n",
        "  return losses, accuracies"
      ],
      "metadata": {
        "id": "HrkJzrS58JH4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setting the hyperparameters and parameters of the model and training process:"
      ],
      "metadata": {
        "id": "oQNAQd8u8atY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set hyperparamters for the model\n",
        "D_MODEL = 512 # 512\n",
        "N_LAYERS = 4 # 6\n",
        "FFN_UNITS = 512 # 2048\n",
        "N_HEADS = 8 # 8\n",
        "DROPOUT_RATE = 0.1 # 0.1"
      ],
      "metadata": {
        "id": "VxVgeEzL8bDN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we define and create all the elements to train the model and evaluate it."
      ],
      "metadata": {
        "id": "HTANr1bO8eaW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Clean the session\n",
        "tf.keras.backend.clear_session()\n",
        "# Create the Transformer model\n",
        "transformer = Transformer(vocab_size_enc=num_words_inputs,\n",
        "                          vocab_size_dec=num_words_output,\n",
        "                          d_model=D_MODEL,\n",
        "                          n_layers=N_LAYERS,\n",
        "                          FFN_units=FFN_UNITS,\n",
        "                          n_heads=N_HEADS,\n",
        "                          dropout_rate=DROPOUT_RATE)\n",
        "\n",
        "# Define a categorical cross entropy loss\n",
        "loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True,\n",
        "                                                            reduction=\"none\")\n",
        "# Define a metric to store the mean loss of every epoch\n",
        "train_loss = tf.keras.metrics.Mean(name=\"train_loss\")\n",
        "# Define a matric to save the accuracy in every epoch\n",
        "train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name=\"train_accuracy\")\n",
        "# Create the scheduler for learning rate decay\n",
        "leaning_rate = CustomSchedule(D_MODEL)\n",
        "# Create the Adam optimizer\n",
        "optimizer = tf.keras.optimizers.Adam(leaning_rate,\n",
        "                                     beta_1=0.9,\n",
        "                                     beta_2=0.98,\n",
        "                                     epsilon=1e-9)"
      ],
      "metadata": {
        "id": "QZRM-CKY8euy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is very useful to checkpoint and save our model during training. Training can take a lot of time and we can restore the model for future training or use."
      ],
      "metadata": {
        "id": "0sT5sUtv9ECv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Create the Checkpoint \n",
        "ckpt = tf.train.Checkpoint(transformer=transformer,\n",
        "                           optimizer=optimizer)\n",
        "\n",
        "ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5)\n",
        "\n",
        "if ckpt_manager.latest_checkpoint:\n",
        "    ckpt.restore(ckpt_manager.latest_checkpoint)\n",
        "    print(\"Last checkpoint restored.\")"
      ],
      "metadata": {
        "id": "HER4k7Rf9HBm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train the model\n",
        "losses, accuracies = main_train(dataset, transformer, EPOCHS, 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bI_nS8AA-kR8",
        "outputId": "dcd4f909-18b7-402d-80e0-5110814dc4c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Starting epoch 1\n",
            "Epoch 1 Batch 0 Loss 4.7600 Accuracy 0.0000\n",
            "Epoch 1 Batch 100 Loss 4.4335 Accuracy 0.0514\n",
            "Epoch 1 Batch 200 Loss 4.1312 Accuracy 0.0701\n",
            "Epoch 1 Batch 300 Loss 3.7787 Accuracy 0.0936\n",
            "Epoch 1 Batch 400 Loss 3.5007 Accuracy 0.1117\n",
            "Epoch 1 Batch 500 Loss 3.2965 Accuracy 0.1249\n",
            "Epoch 1 Batch 600 Loss 3.1384 Accuracy 0.1361\n",
            "Epoch 1 Batch 700 Loss 3.0062 Accuracy 0.1457\n",
            "Epoch 1 Batch 800 Loss 2.8946 Accuracy 0.1539\n",
            "Epoch 1 Batch 900 Loss 2.8010 Accuracy 0.1610\n",
            "Epoch 1 Batch 1000 Loss 2.7172 Accuracy 0.1674\n",
            "Epoch 1 Batch 1100 Loss 2.6441 Accuracy 0.1731\n",
            "Epoch 1 Batch 1200 Loss 2.5769 Accuracy 0.1785\n",
            "Saving checkpoint for epoch 1 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-1\n",
            "Time for 1 epoch: 378.1045377254486 secs\n",
            "\n",
            "Starting epoch 2\n",
            "Epoch 2 Batch 0 Loss 1.6108 Accuracy 0.2388\n",
            "Epoch 2 Batch 100 Loss 1.7173 Accuracy 0.2462\n",
            "Epoch 2 Batch 200 Loss 1.7040 Accuracy 0.2478\n",
            "Epoch 2 Batch 300 Loss 1.6826 Accuracy 0.2502\n",
            "Epoch 2 Batch 400 Loss 1.6688 Accuracy 0.2524\n",
            "Epoch 2 Batch 500 Loss 1.6506 Accuracy 0.2546\n",
            "Epoch 2 Batch 600 Loss 1.6299 Accuracy 0.2570\n",
            "Epoch 2 Batch 700 Loss 1.6134 Accuracy 0.2594\n",
            "Epoch 2 Batch 800 Loss 1.5933 Accuracy 0.2618\n",
            "Epoch 2 Batch 900 Loss 1.5758 Accuracy 0.2639\n",
            "Epoch 2 Batch 1000 Loss 1.5589 Accuracy 0.2661\n",
            "Epoch 2 Batch 1100 Loss 1.5424 Accuracy 0.2680\n",
            "Epoch 2 Batch 1200 Loss 1.5279 Accuracy 0.2697\n",
            "Saving checkpoint for epoch 2 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-2\n",
            "Time for 1 epoch: 370.20073437690735 secs\n",
            "\n",
            "Starting epoch 3\n",
            "Epoch 3 Batch 0 Loss 1.3038 Accuracy 0.2857\n",
            "Epoch 3 Batch 100 Loss 1.2350 Accuracy 0.3038\n",
            "Epoch 3 Batch 200 Loss 1.2290 Accuracy 0.3042\n",
            "Epoch 3 Batch 300 Loss 1.2295 Accuracy 0.3045\n",
            "Epoch 3 Batch 400 Loss 1.2246 Accuracy 0.3051\n",
            "Epoch 3 Batch 500 Loss 1.2177 Accuracy 0.3056\n",
            "Epoch 3 Batch 600 Loss 1.2115 Accuracy 0.3063\n",
            "Epoch 3 Batch 700 Loss 1.2084 Accuracy 0.3065\n",
            "Epoch 3 Batch 800 Loss 1.2069 Accuracy 0.3070\n",
            "Epoch 3 Batch 900 Loss 1.2031 Accuracy 0.3076\n",
            "Epoch 3 Batch 1000 Loss 1.2002 Accuracy 0.3080\n",
            "Epoch 3 Batch 1100 Loss 1.1974 Accuracy 0.3082\n",
            "Epoch 3 Batch 1200 Loss 1.1959 Accuracy 0.3083\n",
            "Saving checkpoint for epoch 3 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-3\n",
            "Time for 1 epoch: 359.76547503471375 secs\n",
            "\n",
            "Starting epoch 4\n",
            "Epoch 4 Batch 0 Loss 1.1233 Accuracy 0.3248\n",
            "Epoch 4 Batch 100 Loss 1.0547 Accuracy 0.3205\n",
            "Epoch 4 Batch 200 Loss 1.0578 Accuracy 0.3201\n",
            "Epoch 4 Batch 300 Loss 1.0724 Accuracy 0.3189\n",
            "Epoch 4 Batch 400 Loss 1.0791 Accuracy 0.3183\n",
            "Epoch 4 Batch 500 Loss 1.0782 Accuracy 0.3186\n",
            "Epoch 4 Batch 600 Loss 1.0804 Accuracy 0.3186\n",
            "Epoch 4 Batch 700 Loss 1.0850 Accuracy 0.3187\n",
            "Epoch 4 Batch 800 Loss 1.0831 Accuracy 0.3192\n",
            "Epoch 4 Batch 900 Loss 1.0830 Accuracy 0.3191\n",
            "Epoch 4 Batch 1000 Loss 1.0834 Accuracy 0.3193\n",
            "Epoch 4 Batch 1100 Loss 1.0839 Accuracy 0.3193\n",
            "Epoch 4 Batch 1200 Loss 1.0819 Accuracy 0.3197\n",
            "Saving checkpoint for epoch 4 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-4\n",
            "Time for 1 epoch: 356.7080166339874 secs\n",
            "\n",
            "Starting epoch 5\n",
            "Epoch 5 Batch 0 Loss 0.9285 Accuracy 0.3281\n",
            "Epoch 5 Batch 100 Loss 0.9218 Accuracy 0.3351\n",
            "Epoch 5 Batch 200 Loss 0.9385 Accuracy 0.3338\n",
            "Epoch 5 Batch 300 Loss 0.9448 Accuracy 0.3340\n",
            "Epoch 5 Batch 400 Loss 0.9488 Accuracy 0.3333\n",
            "Epoch 5 Batch 500 Loss 0.9540 Accuracy 0.3334\n",
            "Epoch 5 Batch 600 Loss 0.9579 Accuracy 0.3329\n",
            "Epoch 5 Batch 700 Loss 0.9612 Accuracy 0.3327\n",
            "Epoch 5 Batch 800 Loss 0.9615 Accuracy 0.3330\n",
            "Epoch 5 Batch 900 Loss 0.9649 Accuracy 0.3333\n",
            "Epoch 5 Batch 1000 Loss 0.9662 Accuracy 0.3336\n",
            "Epoch 5 Batch 1100 Loss 0.9671 Accuracy 0.3337\n",
            "Epoch 5 Batch 1200 Loss 0.9666 Accuracy 0.3340\n",
            "Saving checkpoint for epoch 5 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-5\n",
            "Time for 1 epoch: 353.9587905406952 secs\n",
            "\n",
            "Starting epoch 6\n",
            "Epoch 6 Batch 0 Loss 1.0279 Accuracy 0.3304\n",
            "Epoch 6 Batch 100 Loss 0.8336 Accuracy 0.3481\n",
            "Epoch 6 Batch 200 Loss 0.8432 Accuracy 0.3470\n",
            "Epoch 6 Batch 300 Loss 0.8499 Accuracy 0.3462\n",
            "Epoch 6 Batch 400 Loss 0.8542 Accuracy 0.3461\n",
            "Epoch 6 Batch 500 Loss 0.8604 Accuracy 0.3462\n",
            "Epoch 6 Batch 600 Loss 0.8691 Accuracy 0.3455\n",
            "Epoch 6 Batch 700 Loss 0.8734 Accuracy 0.3452\n",
            "Epoch 6 Batch 800 Loss 0.8757 Accuracy 0.3450\n",
            "Epoch 6 Batch 900 Loss 0.8790 Accuracy 0.3446\n",
            "Epoch 6 Batch 1000 Loss 0.8837 Accuracy 0.3443\n",
            "Epoch 6 Batch 1100 Loss 0.8865 Accuracy 0.3442\n",
            "Epoch 6 Batch 1200 Loss 0.8866 Accuracy 0.3442\n",
            "Saving checkpoint for epoch 6 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-6\n",
            "Time for 1 epoch: 351.7395739555359 secs\n",
            "\n",
            "Starting epoch 7\n",
            "Epoch 7 Batch 0 Loss 0.6902 Accuracy 0.3583\n",
            "Epoch 7 Batch 100 Loss 0.7680 Accuracy 0.3571\n",
            "Epoch 7 Batch 200 Loss 0.7795 Accuracy 0.3559\n",
            "Epoch 7 Batch 300 Loss 0.7857 Accuracy 0.3556\n",
            "Epoch 7 Batch 400 Loss 0.7938 Accuracy 0.3546\n",
            "Epoch 7 Batch 500 Loss 0.7991 Accuracy 0.3538\n",
            "Epoch 7 Batch 600 Loss 0.8036 Accuracy 0.3533\n",
            "Epoch 7 Batch 700 Loss 0.8073 Accuracy 0.3532\n",
            "Epoch 7 Batch 800 Loss 0.8106 Accuracy 0.3533\n",
            "Epoch 7 Batch 900 Loss 0.8153 Accuracy 0.3531\n",
            "Epoch 7 Batch 1000 Loss 0.8177 Accuracy 0.3529\n",
            "Epoch 7 Batch 1100 Loss 0.8190 Accuracy 0.3528\n",
            "Epoch 7 Batch 1200 Loss 0.8216 Accuracy 0.3527\n",
            "Saving checkpoint for epoch 7 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-7\n",
            "Time for 1 epoch: 355.77170729637146 secs\n",
            "\n",
            "Starting epoch 8\n",
            "Epoch 8 Batch 0 Loss 0.6402 Accuracy 0.3549\n",
            "Epoch 8 Batch 100 Loss 0.7026 Accuracy 0.3660\n",
            "Epoch 8 Batch 200 Loss 0.7102 Accuracy 0.3662\n",
            "Epoch 8 Batch 300 Loss 0.7250 Accuracy 0.3639\n",
            "Epoch 8 Batch 400 Loss 0.7308 Accuracy 0.3636\n",
            "Epoch 8 Batch 500 Loss 0.7378 Accuracy 0.3623\n",
            "Epoch 8 Batch 600 Loss 0.7432 Accuracy 0.3619\n",
            "Epoch 8 Batch 700 Loss 0.7501 Accuracy 0.3613\n",
            "Epoch 8 Batch 800 Loss 0.7557 Accuracy 0.3611\n",
            "Epoch 8 Batch 900 Loss 0.7596 Accuracy 0.3608\n",
            "Epoch 8 Batch 1000 Loss 0.7624 Accuracy 0.3606\n",
            "Epoch 8 Batch 1100 Loss 0.7659 Accuracy 0.3605\n",
            "Epoch 8 Batch 1200 Loss 0.7682 Accuracy 0.3604\n",
            "Saving checkpoint for epoch 8 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-8\n",
            "Time for 1 epoch: 354.6127998828888 secs\n",
            "\n",
            "Starting epoch 9\n",
            "Epoch 9 Batch 0 Loss 0.5854 Accuracy 0.3761\n",
            "Epoch 9 Batch 100 Loss 0.6489 Accuracy 0.3716\n",
            "Epoch 9 Batch 200 Loss 0.6688 Accuracy 0.3692\n",
            "Epoch 9 Batch 300 Loss 0.6752 Accuracy 0.3693\n",
            "Epoch 9 Batch 400 Loss 0.6859 Accuracy 0.3688\n",
            "Epoch 9 Batch 500 Loss 0.6945 Accuracy 0.3682\n",
            "Epoch 9 Batch 600 Loss 0.6999 Accuracy 0.3677\n",
            "Epoch 9 Batch 700 Loss 0.7068 Accuracy 0.3668\n",
            "Epoch 9 Batch 800 Loss 0.7116 Accuracy 0.3662\n",
            "Epoch 9 Batch 900 Loss 0.7167 Accuracy 0.3659\n",
            "Epoch 9 Batch 1000 Loss 0.7203 Accuracy 0.3659\n",
            "Epoch 9 Batch 1100 Loss 0.7247 Accuracy 0.3658\n",
            "Epoch 9 Batch 1200 Loss 0.7281 Accuracy 0.3657\n",
            "Saving checkpoint for epoch 9 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-9\n",
            "Time for 1 epoch: 353.7776381969452 secs\n",
            "\n",
            "Starting epoch 10\n",
            "Epoch 10 Batch 0 Loss 0.6170 Accuracy 0.3571\n",
            "Epoch 10 Batch 100 Loss 0.6287 Accuracy 0.3754\n",
            "Epoch 10 Batch 200 Loss 0.6387 Accuracy 0.3749\n",
            "Epoch 10 Batch 300 Loss 0.6479 Accuracy 0.3742\n",
            "Epoch 10 Batch 400 Loss 0.6528 Accuracy 0.3738\n",
            "Epoch 10 Batch 500 Loss 0.6589 Accuracy 0.3732\n",
            "Epoch 10 Batch 600 Loss 0.6654 Accuracy 0.3729\n",
            "Epoch 10 Batch 700 Loss 0.6705 Accuracy 0.3725\n",
            "Epoch 10 Batch 800 Loss 0.6760 Accuracy 0.3722\n",
            "Epoch 10 Batch 900 Loss 0.6801 Accuracy 0.3715\n",
            "Epoch 10 Batch 1000 Loss 0.6841 Accuracy 0.3712\n",
            "Epoch 10 Batch 1100 Loss 0.6888 Accuracy 0.3711\n",
            "Epoch 10 Batch 1200 Loss 0.6927 Accuracy 0.3707\n",
            "Saving checkpoint for epoch 10 in /content/drive/MyDrive/Colab Notebooks/Projects/Transformer_NMT/ckpt/ckpt-10\n",
            "Time for 1 epoch: 353.55407524108887 secs\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 7. **Show some results from training**"
      ],
      "metadata": {
        "id": "oKvJ8AbiMd3p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,5))\n",
        "# plot some data\n",
        "ax1.plot(losses, label='loss')\n",
        "#plt.plot(results.history['val_loss'], label='val_loss')\n",
        "ax1.set_title('Training Loss')\n",
        "ax1.legend()\n",
        "# accuracies\n",
        "ax2.plot(accuracies, label='acc')\n",
        "#plt.plot(results.history['val_accuracy_fn'], label='val_acc')\n",
        "ax2.set_title('Training Accuracy')\n",
        "ax2.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "0pKEjYsOMcNX",
        "outputId": "ebd164f5-6f80-42fc-c394-2331d54cb6ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1080x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 8. **Make predictions**\n",
        "\n",
        "We have seen the scores obtained after training but what we are interested, is in making predictions and seeing, how the model works with new sentences. The predict function will input a tokenize sentence to the model and return the predicted new sentence, in our example, a translation from english to spanish.\n",
        "\n",
        "* Tokenize the input sentence to a sequence of tokens\n",
        "* Set the initial output sequence to the SOS token\n",
        "* Until we reach the max length or the eos token is returned by the model\n",
        "* Get the next word predicted. The model returns the logits, remember that the softmax function is applied in the loss calculation.\n",
        "* Get the index in the vocabulary of the word with the highest probability\n",
        "* Concat the next word predicted to the output sequence"
      ],
      "metadata": {
        "id": "xu6DmVrJMoE9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def predict(inp_sentence, tokenizer_in, tokenizer_out, target_max_len):\n",
        "    # Tokenize the input sequence using the tokenizer_in\n",
        "    inp_sentence = sos_token_input + tokenizer_in.encode(inp_sentence) + eos_token_input\n",
        "    enc_input = tf.expand_dims(inp_sentence, axis=0)\n",
        "\n",
        "    # Set the initial output sentence to sos\n",
        "    out_sentence = sos_token_output\n",
        "    # Reshape the output\n",
        "    output = tf.expand_dims(out_sentence, axis=0)\n",
        "\n",
        "    # For max target len tokens\n",
        "    for _ in range(target_max_len):\n",
        "        # Call the transformer and get the logits \n",
        "        predictions = transformer(enc_input, output, False) #(1, seq_length, VOCAB_SIZE_ES)\n",
        "        # Extract the logists of the next word\n",
        "        prediction = predictions[:, -1:, :]\n",
        "        # The highest probability is taken\n",
        "        predicted_id = tf.cast(tf.argmax(prediction, axis=-1), tf.int32)\n",
        "        # Check if it is the eos token\n",
        "        if predicted_id == eos_token_output:\n",
        "            return tf.squeeze(output, axis=0)\n",
        "        # Concat the predicted word to the output sequence\n",
        "        output = tf.concat([output, predicted_id], axis=-1)\n",
        "\n",
        "    return tf.squeeze(output, axis=0)"
      ],
      "metadata": {
        "id": "xbuQ5ULvNNYZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And finally our last function receives a sentence in english, calls the transformer to translate it to spanish and shows the result"
      ],
      "metadata": {
        "id": "_oI6X7stNRhF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def translate(sentence):\n",
        "    # Get the predicted sequence for the input sentence\n",
        "    output = predict(sentence, tokenizer_inputs, tokenizer_outputs, MAX_LENGTH).numpy()\n",
        "    # Transform the sequence of tokens to a sentence\n",
        "    predicted_sentence = tokenizer_outputs.decode(\n",
        "        [i for i in output if i < sos_token_output]\n",
        "    )\n",
        "\n",
        "    return predicted_sentence"
      ],
      "metadata": {
        "id": "PeU61zKCNS7Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we explore the predictions on sentences of our training dataset:"
      ],
      "metadata": {
        "id": "pQUfs_GANU0J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Show some translations\n",
        "sentence = \"you should pay for it.\"\n",
        "print(\"Input sentence: {}\".format(sentence))\n",
        "predicted_sentence = translate(sentence)\n",
        "print(\"Output sentence: {}\".format(predicted_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r70q0oX6NWi8",
        "outputId": "3633af2b-d578-4809-9ee5-fd4318d07512"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input sentence: you should pay for it.\n",
            "Output sentence: Deberías pagar.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sentence = \"we have no extra money.\"\n",
        "print(\"Input sentence: {}\".format(sentence))\n",
        "predicted_sentence = translate(sentence)\n",
        "print(\"Output sentence: {}\".format(predicted_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MFHGIZAbNcQU",
        "outputId": "6df595a8-41e2-4a61-e394-e29a126cc954"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input sentence: we have no extra money.\n",
            "Output sentence: No tenemos dinero.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, let's predict some new sentences on diferent topics:"
      ],
      "metadata": {
        "id": "2F88VpPgNiny"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Show some translations\n",
        "sentence = \"This is a problem to deal with.\"\n",
        "print(\"Input sentence: {}\".format(sentence))\n",
        "predicted_sentence = translate(sentence)\n",
        "print(\"Output sentence: {}\".format(predicted_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ExTAukUiNi-n",
        "outputId": "0f371807-484d-44a7-cceb-1b52347ee9a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input sentence: This is a problem to deal with.\n",
            "Output sentence: Este es un problema para él.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Show some translations\n",
        "sentence = \"This is a really powerful method!\"\n",
        "print(\"Input sentence: {}\".format(sentence))\n",
        "predicted_sentence = translate(sentence)\n",
        "print(\"Output sentence: {}\".format(predicted_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uqCL9FcqNqRe",
        "outputId": "5403f3a2-89d8-4d15-9a3c-47ee284888c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input sentence: This is a really powerful method!\n",
            "Output sentence: ¡Es un verdadero universo!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Show some translations\n",
        "sentence = \"This is an interesting course about Natural Language Processing\"\n",
        "print(\"Input sentence: {}\".format(sentence))\n",
        "predicted_sentence = translate(sentence)\n",
        "print(\"Output sentence: {}\".format(predicted_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0ULxdjaNuV4",
        "outputId": "aaf33776-316a-4afe-87f1-3c3a58422739"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input sentence: This is an interesting course about Natural Language Processing\n",
            "Output sentence: Esto es una de una persona interesante.\n"
          ]
        }
      ]
    }
  ]
}