RUS_Male_Names .ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "MppSxLbbgDYc"
      },
      "outputs": [],
      "source": [
        "import torch # library to create multidimentional arrays\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt # to visualize plot\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# download the names.txt file from github\n",
        "\n",
        "!wget https://raw.githubusercontent.com/Raven-SL/ru-pnames-list/master/lists/male_names_rus.txt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_oJgsraQgGsX",
        "outputId": "e0b9e73c-2821-4a92-8a2f-313e45082008"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--2024-03-02 13:27:29--  https://raw.githubusercontent.com/Raven-SL/ru-pnames-list/master/lists/male_names_rus.txt\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 9829 (9.6K) [text/plain]\n",
            "Saving to: ‘male_names_rus.txt’\n",
            "\n",
            "male_names_rus.txt  100%[===================>]   9.60K  --.-KB/s    in 0s      \n",
            "\n",
            "2024-03-02 13:27:29 (60.6 MB/s) - ‘male_names_rus.txt’ saved [9829/9829]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# a. Capitalized\n",
        "In this part of code, the vocabulary is created according to the dataset, where all the names start with uppercase character, followed by lowercase to train the model, avaluate its performance and generate new words."
      ],
      "metadata": {
        "id": "-zrjleUhgQP_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "words = open('male_names_rus.txt', 'r').read().splitlines()\n",
        "words[:8]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_XOfcIbjgNk1",
        "outputId": "d110b3d8-aec6-44e2-cedb-4766468c888a"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Аарон',\n",
              " 'Аба',\n",
              " 'Аббас',\n",
              " 'Абд аль-Узза',\n",
              " 'Абдуллах',\n",
              " 'Абид',\n",
              " 'Аботур',\n",
              " 'Аввакум']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(words)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qE-LAF8fgh-U",
        "outputId": "fcf02427-e263-43e0-d60f-442d9bdefbae"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "736"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# build the vocabulary of characters, uppercase and lowercase, as string to integers and viceversa:\n",
        "chars = sorted(list(set(''.join(words))))\n",
        "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
        "stoi['.'] = 0\n",
        "itos = {i:s for s,i in stoi.items()}\n",
        "\n",
        "# to print the total number of the characters in vocalubary\n",
        "len(itos)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_FgU_DlFgidm",
        "outputId": "2eea3541-8318-434d-afae-9adea23ff7c0"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "62"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to build the dataset:\n",
        "\n",
        "# to define the context window: the number of characters to take to predict the next character\n",
        "block_size = 3\n",
        "\n",
        "# to define a function 'build_dataset' that takes a list of words as input\n",
        "def build_dataset(words):\n",
        "\n",
        "  # to start empty lists 'X' and 'Y' to store INPUT pairs\n",
        "  # 'X' is the INPUT into neural network, 'Y' is Label for each 'X'\n",
        "  X, Y = [], []\n",
        "\n",
        "  # to iterate through each word in the INPUT list words\n",
        "  for w in words:\n",
        "    # to start a padded context of 0 tokens with length equal to the block_size\n",
        "    context = [0] * block_size\n",
        "\n",
        "    # to iterate through each character in the word concatenated with a period (.) indicating the end of the word\n",
        "    for ch in w + '.': # iterate over all the characters\n",
        "\n",
        "      # to retrieves the index of the current character 'ch' from a dictionary 'stoi' that maps characters to their corresponding indices\n",
        "      # to get the characters in a sequence\n",
        "      ix = stoi[ch]\n",
        "\n",
        "      # to append the current context to the input list X\n",
        "      X.append(context)\n",
        "      # to append the index of the next character to the label list Y\n",
        "      Y.append(ix)\n",
        "      # to update the context by removing the first element and adding the index of the current character to the end,\n",
        "      # to create a rolling window of contexts\n",
        "      context = context[1:] + [ix]\n",
        "\n",
        "  # to convert the input list X into a PyTorch tensor\n",
        "  X = torch.tensor(X)\n",
        "  # to converts the input list Y into a PyTorch tensor\n",
        "  Y = torch.tensor(Y)\n",
        "\n",
        "  # to prints the shapes of X and Y tensors\n",
        "  print(X.shape, Y.shape)\n",
        "  # to return X and Y tensor as the output of the 'build_dataset' function\n",
        "  return X, Y\n",
        "\n",
        "# to import the 'random' module\n",
        "import random\n",
        "# to set the random seed to 42 for reproducibility\n",
        "random.seed(42)\n",
        "# to shuffle the list of words randomly\n",
        "random.shuffle(words)\n",
        "\n",
        "# to calculate the index n1, which corresponds to 80% of the total number of words\n",
        "n1 = int(0.8*len(words))\n",
        "# to calculate the index n2, which corresponds to 90% of the total number of words\n",
        "n2 = int(0.9*len(words))\n",
        "\n",
        "# to build the TRAINING dataset (Xtr, Ytr) using the first 80% of the shuffled words (n1)\n",
        "Xtr, Ytr = build_dataset(words[:n1])\n",
        "\n",
        "# to build the VALIDATION dataset (Xdev, Ydev) using the next 10% of the shuffled words (n2 - n1)\n",
        "Xdev, Ydev = build_dataset(words[n1:n2])\n",
        "\n",
        "# to bugild the TEST dataset (Xte, Yte) using the remaining 10% of the shuffled words (100% - n2)\n",
        "Xte, Yte = build_dataset(words[n2:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DSOF5Bwsgrps",
        "outputId": "7d56cba1-ed1d-47ae-9d70-ab22c836bcf5"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([4211, 3]) torch.Size([4211])\n",
            "torch.Size([526, 3]) torch.Size([526])\n",
            "torch.Size([548, 3]) torch.Size([548])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize parameters for a neural network model:\n",
        "\n",
        "# to create a random number generator for reproducibility\n",
        "g = torch.Generator().manual_seed(2147483647)\n",
        "\n",
        "# to build an INPUT layer, a random tensor C with dimensions (62, 10), where 62 is number of rows (characters in vocabulary) represented by a 10-dim embedding\n",
        "C = torch.randn((62, 10), generator=g)\n",
        "\n",
        "# to buld a second layer of random weight matrix W1 with dimensions (30, 200), where 30 neurons are in the HIDDEN layer,\n",
        "# and each neuron has 200 connections coming from the INPUT layer\n",
        "W1 = torch.randn((30, 200), generator=g)\n",
        "\n",
        "# to build random bias vector b1 with 200 elements associated with  200 neurons in the HIDDEN layer\n",
        "b1 = torch.randn(200, generator=g)\n",
        "\n",
        "# to build a randon weight matrix W2 with dimensions (200, 62) that connecting the HIDDEN layer to the OUTPUT layer\n",
        "W2 = torch.randn((200, 62), generator=g)\n",
        "\n",
        "# to build a random bias vector b2 with 62 elements associated with 62 neurons in the OUTPUT layer\n",
        "b2 = torch.randn(62, generator=g)\n",
        "\n",
        "# to collect all the parameters of the neural network model\n",
        "parameters = [C, W1, b1, W2, b2]"
      ],
      "metadata": {
        "id": "9yRjfoH3gwSW"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# number of parameters in total\n",
        "sum(p.nelement() for p in parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q_oMPPETgkrQ",
        "outputId": "64dbc036-1b8f-42fc-d94f-ddf90407249c"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "19282"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the loop that iterates over all parameters (C, W1, b1, W2, b2) and sets 'requires_grad' attribute to True.\n",
        "# to indicate that gradients should be computed for these parameters during backpropagation\n",
        "for p in parameters:\n",
        "  p.requires_grad = True"
      ],
      "metadata": {
        "id": "bW8HysMVg54q"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize a learning rate\n",
        "lre = torch.linspace(-3, 0, 1000)\n",
        "lrs = 10**lre"
      ],
      "metadata": {
        "id": "9T4vOAKug_qY"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to create lists to track learning rate, loss, and step (iteration) during the model training\n",
        "lri = []\n",
        "lossi = []\n",
        "stepi = []"
      ],
      "metadata": {
        "id": "RFBNWPHIhBq2"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to train the model:\n",
        "\n",
        "for i in range(200000): # the loop that iterates over 200k training iterations\n",
        "\n",
        "  # to select randomly 32 indices from the training data (Xtr) for creating a minibatch\n",
        "  ix = torch.randint(0, Xtr.shape[0], (32,))\n",
        "\n",
        "  # forward pass:\n",
        "  # to look up embeddings from the matrix C based on the randomly selected indices from the training data (Xtr)\n",
        "  # to create a tensor of shape (32, 3, 2)\n",
        "  emb = C[Xtr[ix]] # (32, 3, 2)\n",
        "\n",
        "  # to compute the HIDDEN layer activations using the embeddings, weight matrix W1, and bias vector b1\n",
        "  # to appliy the tanh function\n",
        "  h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "\n",
        "  # to compute the logits (output of the neural network before applying softmax)\n",
        "  # to multiply the HIDDEN layer with weight W2 and adding bias b2\n",
        "  logits = h @ W2 + b2 # (32, 62)\n",
        "\n",
        "  # to compute the cross-entropy loss between the predicted logits and the true labels (Ytr)\n",
        "  # it uses built-in cross_entropy function\n",
        "  loss = F.cross_entropy(logits, Ytr[ix])\n",
        "\n",
        "  # backward pass:\n",
        "  # the loop resets the gradients of all parameters to None before computing gradients for the current minibatch\n",
        "  for p in parameters:\n",
        "    p.grad = None\n",
        "\n",
        "  # to compute gradients of the loss using backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # to adjust the learning rate setting the higher lr of 0.1 for the first 100k iterations\n",
        "  # and lower lr of 0.01 for the remaining iterations\n",
        "  lr = 0.1 if i < 100000 else 0.01\n",
        "\n",
        "  # the loop to update parameters with gradients and the learning rate\n",
        "  for p in parameters:\n",
        "    p.data += -lr * p.grad\n",
        "\n",
        "  # track stats\n",
        "  # to append the current iteration number to the list 'stepi'\n",
        "  stepi.append(i)\n",
        "\n",
        "  # to append the logarithm (base 10) of the loss to the list 'lossi'\n",
        "  lossi.append(loss.log10().item())"
      ],
      "metadata": {
        "id": "hO-Ai3sPhEU8"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to print out the loss value obtained after the last training iteration (how well the model works)\n",
        "print(loss.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fff9eLoqhIYP",
        "outputId": "b0c9cbfe-64c3-440a-ec6f-b6d2d98a4bfc"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.111713171005249\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to plot the training loss over the course of training\n",
        "# where 'stepi' is the iteration numbers and 'lossi' is the corresponding loss values\n",
        "plt.plot(stepi, lossi)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "id": "6nHp60pHhK1i",
        "outputId": "6cbabd51-9c0a-41cc-cf6a-8c01bd875e31"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x79c4eda4a530>]"
            ]
          },
          "metadata": {},
          "execution_count": 21
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# training loss\n",
        "# to calculate ther trainnig loss by retrieving the embeddings for the training examples (Xtr) from the embedding matrix C\n",
        "emb = C[Xtr] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 62)\n",
        "# to calculate cross-enthropy loss between the predicted logits and the labels (Ytr)\n",
        "loss = F.cross_entropy(logits, Ytr)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OHEXr7ZRhNeJ",
        "outputId": "89bd8318-ed35-49ab-ce05-0bb3a114522c"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(1.0715, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# validation loss\n",
        "# to calculate the validation loss using the same process as the training loss but with the validation dataset (Xdev, Ydev)\n",
        "emb = C[Xdev] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 62)\n",
        "loss = F.cross_entropy(logits, Ydev)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DNgkFCUihQFv",
        "outputId": "b77572e0-149f-4b8a-ca3f-bfe34f2e9b9b"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5.8346, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# test loss\n",
        "# to calculate the test loss with the test dataset (Xte, Yte)\n",
        "emb = C[Xte] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 62)\n",
        "loss = F.cross_entropy(logits, Yte)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RqtQd5E4hRzf",
        "outputId": "76b06ede-6518-4480-c16a-8ac3ef9d50ef"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(5.7648, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualize dimensions 0 and 1 of the embedding matrix C for all characters\n",
        "plt.figure(figsize=(8,8)) # to create a new figure for the plot with size of 8x8 inches\n",
        "\n",
        "# to creates a scatter plot using the first and second dimensions of the embedding matrix C\n",
        "# where point in the scatter plot represents the embedding of a character\n",
        "# the s = 200 argument sets the size of each point to 200\n",
        "plt.scatter(C[:,0].data, C[:,1].data, s = 200)\n",
        "\n",
        "# the loop that iterates over each character embedding in the embedding matrix C\n",
        "for i in range(C.shape[0]):\n",
        "\n",
        "    # the annotatins to the scatter plot at the position of each character's embedding\n",
        "    plt.text(C[i,0].item(), C[i,1].item(), itos[i], ha=\"center\", va=\"center\", color='white')\n",
        "\n",
        "# to add a minor grid to the plot\n",
        "plt.grid('minor')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 678
        },
        "id": "D8Rb7P4shUED",
        "outputId": "a6092c73-1ac5-445c-9d8e-4a4e01aac7cb"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's sample from the model:\n",
        "\n",
        "# to create a new random number generator with a specific seed (2147483647 + 10)\n",
        "# it will be used to ensure reproducibility in the sampling process\n",
        "g = torch.Generator().manual_seed(2147483647 + 10)\n",
        "\n",
        "# the loop that iterates 50 times to generate 50 text sequences\n",
        "for _ in range(50):\n",
        "\n",
        "    # to initialize an empty list to store the sampled text sequence\n",
        "    out = []\n",
        "    # to initialize the context with a list of zeros\n",
        "    context = [0] * block_size\n",
        "    # to start an infinite loop to sample text until a termination condition is met\n",
        "    while True:\n",
        "      # to retrieve the embeddings for the current context from the embedding matrix C\n",
        "      emb = C[torch.tensor([context])] # (1,block_size,d)\n",
        "      # to compute the activations of the HIDDEN layer neurons using the embeddings, weight W1, and bias b1\n",
        "      h = torch.tanh(emb.view(1, -1) @ W1 + b1)\n",
        "      # to calculate the logits by multiplying the HIDDEN layer activations with weight W2 and adding bias b2\n",
        "      logits = h @ W2 + b2\n",
        "      # to applie the softmax function along dimension 1 (rows) to convert the logits into probabilities\n",
        "      probs = F.softmax(logits, dim=1)\n",
        "      # to sample a single character (index) from the probability distribution defined by probs using the multinomial function to represent the next character in the sequence\n",
        "      ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
        "      # to update the context by removing the first element and appending the sampled index to the end to prepare the context for the next iteration of sampling\n",
        "      context = context[1:] + [ix]\n",
        "      # to append the sampled index to the list of sampled indices\n",
        "      out.append(ix)\n",
        "      # the condition to check if the sampled index is the termination token (0) to stop the sampling process\n",
        "      if ix == 0:\n",
        "        break\n",
        "    # to print the sampled text sequence\n",
        "    # to convert the sampled indices (out) back into characters using the itos list and see the generated results :)\n",
        "    print(''.join(itos[i] for i in out))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wHz0fQ7jhWLJ",
        "outputId": "39032ce4-70a4-4a6a-8ef3-e3e00ca6690b"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Клаас.\n",
            "Коррад.\n",
            "Волом.\n",
            "Герапит.\n",
            "Карей.\n",
            "Дорофаниэль.\n",
            "Адар.\n",
            "Евтихий.\n",
            "Паруйр.\n",
            "Андр.\n",
            "Павсикантин.\n",
            "Натаниэль.\n",
            "Дитрий.\n",
            "Шон.\n",
            "Авдей.\n",
            "Мамбет.\n",
            "Терри.\n",
            "Герасир.\n",
            "Джейкоб.\n",
            "Донам.\n",
            "Эмиль.\n",
            "Борин.\n",
            "Людовик.\n",
            "Тихомин.\n",
            "Урызмаг.\n",
            "Полиевкт.\n",
            "Юстасий.\n",
            "Пётр.\n",
            "Марион.\n",
            "Наил.\n",
            "Рон.\n",
            "Владий.\n",
            "Павлин.\n",
            "Афиф.\n",
            "Геромир.\n",
            "Илладар.\n",
            "Ашот.\n",
            "Иоганн.\n",
            "Сапион.\n",
            "Гурий.\n",
            "Генри.\n",
            "Эстеберт.\n",
            "Ананий.\n",
            "Радосей.\n",
            "Андокид.\n",
            "Сигеберт.\n",
            "Гай.\n",
            "Автон.\n",
            "Айрат.\n",
            "Хирам.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# b. Non-capitalized\n",
        "In this part of code, the same dataset of male names is lowercased to see the difference between performance of the model that is trained on capitalized dataset and the model that is trained on non-capitalized dataset."
      ],
      "metadata": {
        "id": "Bw_EcQDfhZSv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# to open and read the file, turn all characters lowercase, and split the string into list:\n",
        "words = open('male_names_rus.txt', 'r').read().lower().splitlines()\n",
        "\n",
        "# print out first 8 words\n",
        "words[:8]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MaXRuf6Chdqw",
        "outputId": "157b9534-fc83-4fb3-b515-8dde191afee0"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['аарон',\n",
              " 'аба',\n",
              " 'аббас',\n",
              " 'абд аль-узза',\n",
              " 'абдуллах',\n",
              " 'абид',\n",
              " 'аботур',\n",
              " 'аввакум']"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# build the vocabulary of characters as a string to integers and viceversa:\n",
        "chars = sorted(list(set(''.join(words))))\n",
        "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
        "stoi['.'] = 0\n",
        "itos = {i:s for s,i in stoi.items()}\n",
        "\n",
        "# to print the total number of the characters in vocalubary\n",
        "len(itos)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pLZyN5V5YqUo",
        "outputId": "dd9b5f6d-8684-4728-9e60-375e6a804185"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "34"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to build the dataset:\n",
        "\n",
        "# to define the context window: the number of characters to take to predict the next character\n",
        "block_size = 3\n",
        "\n",
        "# to define a function 'build_dataset' that takes a list of words as input\n",
        "def build_dataset(words):\n",
        "\n",
        "  # to start empty lists 'X' and 'Y' to store INPUT pairs\n",
        "  # 'X' is the INPUT into neural network, 'Y' is Label for each 'X'\n",
        "  X, Y = [], []\n",
        "\n",
        "  # to iterate through each word in the INPUT list words\n",
        "  for w in words:\n",
        "    # to start a padded context of 0 tokens with length equal to the block_size\n",
        "    context = [0] * block_size\n",
        "\n",
        "    # to iterate through each character in the word concatenated with a period (.) indicating the end of the word\n",
        "    for ch in w + '.': # iterate over all the characters\n",
        "\n",
        "      # to retrieves the index of the current character 'ch' from a dictionary 'stoi' that maps characters to their corresponding indices\n",
        "      # to get the characters in a sequence\n",
        "      ix = stoi[ch]\n",
        "\n",
        "      # to append the current context to the input list X\n",
        "      X.append(context)\n",
        "      # to append the index of the next character to the label list Y\n",
        "      Y.append(ix)\n",
        "      # to update the context by removing the first element and adding the index of the current character to the end,\n",
        "      # to create a rolling window of contexts\n",
        "      context = context[1:] + [ix]\n",
        "\n",
        "  # to convert the input list X into a PyTorch tensor\n",
        "  X = torch.tensor(X)\n",
        "  # to converts the input list Y into a PyTorch tensor\n",
        "  Y = torch.tensor(Y)\n",
        "\n",
        "  # to prints the shapes of X and Y tensors\n",
        "  print(X.shape, Y.shape)\n",
        "  # to return X and Y tensor as the output of the 'build_dataset' function\n",
        "  return X, Y\n",
        "\n",
        "# to import the 'random' module\n",
        "import random\n",
        "# to set the random seed to 42 for reproducibility\n",
        "random.seed(42)\n",
        "# to shuffle the list of words randomly\n",
        "random.shuffle(words)\n",
        "\n",
        "# to calculate the index n1, which corresponds to 80% of the total number of words\n",
        "n1 = int(0.8*len(words))\n",
        "# to calculate the index n2, which corresponds to 90% of the total number of words\n",
        "n2 = int(0.9*len(words))\n",
        "\n",
        "# to build the TRAINING dataset (Xtr, Ytr) using the first 80% of the shuffled words (n1)\n",
        "Xtr, Ytr = build_dataset(words[:n1])\n",
        "\n",
        "# to build the VALIDATION dataset (Xdev, Ydev) using the next 10% of the shuffled words (n2 - n1)\n",
        "Xdev, Ydev = build_dataset(words[n1:n2])\n",
        "\n",
        "# to bugild the TEST dataset (Xte, Yte) using the remaining 10% of the shuffled words (100% - n2)\n",
        "Xte, Yte = build_dataset(words[n2:])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "enl9W_e0Y3xa",
        "outputId": "8acfff60-650e-41c5-f3c8-c0c68cbfa6d1"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([4206, 3]) torch.Size([4206])\n",
            "torch.Size([550, 3]) torch.Size([550])\n",
            "torch.Size([529, 3]) torch.Size([529])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize parameters for a neural network model:\n",
        "\n",
        "# to create a random number generator for reproducibility\n",
        "g = torch.Generator().manual_seed(2147483647)\n",
        "\n",
        "# to build an INPUT layer, a random tensor C with dimensions (34, 10), where 34 is number of rows (characters in vocabulary) represented by a 10-dim embedding\n",
        "C = torch.randn((34, 10), generator=g)\n",
        "\n",
        "# to buld a second layer of random weight matrix W1 with dimensions (30, 200), where 30 neurons are in the HIDDEN layer,\n",
        "# and each neuron has 200 connections coming from the INPUT layer\n",
        "W1 = torch.randn((30, 200), generator=g)\n",
        "\n",
        "# to build random bias vector b1 with 200 elements associated with  200 neurons in the HIDDEN layer\n",
        "b1 = torch.randn(200, generator=g)\n",
        "\n",
        "# to build a randon weight matrix W2 with dimensions (200, 34) that connecting the HIDDEN layer to the OUTPUT layer\n",
        "W2 = torch.randn((200, 34), generator=g)\n",
        "\n",
        "# to build a random bias vector b2 with 34 elements associated with 34 neurons in the OUTPUT layer\n",
        "b2 = torch.randn(34, generator=g)\n",
        "\n",
        "# to collect all the parameters of the neural network model\n",
        "parameters = [C, W1, b1, W2, b2]"
      ],
      "metadata": {
        "id": "tAJWSGgDnSPQ"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# number of parameters in total\n",
        "sum(p.nelement() for p in parameters)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z1c-Y4G3nZNn",
        "outputId": "4554a483-a385-4508-f44c-a4c9e0eba376"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13374"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# the loop that iterates over all parameters (C, W1, b1, W2, b2) and sets 'requires_grad' attribute to True.\n",
        "# to indicate that gradients should be computed for these parameters during backpropagation\n",
        "for p in parameters:\n",
        "  p.requires_grad = True"
      ],
      "metadata": {
        "id": "QErcW-rOndcR"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to initialize a learning rate\n",
        "lre = torch.linspace(-3, 0, 1000)\n",
        "lrs = 10**lre"
      ],
      "metadata": {
        "id": "2zohIXedng2N"
      },
      "execution_count": 33,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lri = []\n",
        "lossi = []\n",
        "stepi = []"
      ],
      "metadata": {
        "id": "J-6rD0N-nj2A"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to train the model:\n",
        "\n",
        "for i in range(200000): # the loop that iterates over 200k training iterations\n",
        "\n",
        "  # to select randomly 32 indices from the training data (Xtr) for creating a minibatch\n",
        "  ix = torch.randint(0, Xtr.shape[0], (32,))\n",
        "\n",
        "  # forward pass:\n",
        "  # to look up embeddings from the matrix C based on the randomly selected indices from the training data (Xtr)\n",
        "  # to create a tensor of shape (32, 3, 2)\n",
        "  emb = C[Xtr[ix]] # (32, 3, 2)\n",
        "\n",
        "  # to compute the HIDDEN layer activations using the embeddings, weight matrix W1, and bias vector b1\n",
        "  # to appliy the tanh function\n",
        "  h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "\n",
        "  # to compute the logits (output of the neural network before applying softmax)\n",
        "  # to multiply the HIDDEN layer with weight W2 and adding bias b2\n",
        "  logits = h @ W2 + b2 # (32, 34)\n",
        "\n",
        "  # to compute the cross-entropy loss between the predicted logits and the true labels (Ytr)\n",
        "  # it uses built-in cross_entropy function\n",
        "  loss = F.cross_entropy(logits, Ytr[ix])\n",
        "\n",
        "  # backward pass:\n",
        "  # the loop resets the gradients of all parameters to None before computing gradients for the current minibatch\n",
        "  for p in parameters:\n",
        "    p.grad = None\n",
        "\n",
        "  # to compute gradients of the loss using backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # to adjust the learning rate setting the higher lr of 0.1 for the first 100k iterations\n",
        "  # and lower lr of 0.01 for the remaining iterations\n",
        "  lr = 0.1 if i < 100000 else 0.01\n",
        "\n",
        "  # the loop to update parameters with gradients and the learning rate\n",
        "  for p in parameters:\n",
        "    p.data += -lr * p.grad\n",
        "\n",
        "  # track stats\n",
        "  # to append the current iteration number to the list 'stepi'\n",
        "  stepi.append(i)\n",
        "\n",
        "  # to append the logarithm (base 10) of the loss to the list 'lossi'\n",
        "  lossi.append(loss.log10().item())"
      ],
      "metadata": {
        "id": "FcGza85fnmEO"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# to print out the loss value obtained after the last training iteration (how well the model works)\n",
        "print(loss.item())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1NU8LMcrnpSx",
        "outputId": "0dc63f33-d315-4a50-b57f-f22a3751ef61"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.3356733322143555\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# to plot the training loss over the course of training\n",
        "# where 'stepi' is the iteration numbers and 'lossi' is the corresponding loss values\n",
        "plt.plot(stepi, lossi)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 448
        },
        "id": "Z_j_gTwIZ3t7",
        "outputId": "270de1af-8682-40b3-ef7f-4d76c4d24233"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x79c4ee3a1630>]"
            ]
          },
          "metadata": {},
          "execution_count": 37
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# training loss\n",
        "# to calculate ther trainnig loss by retrieving the embeddings for the training examples (Xtr) from the embedding matrix C\n",
        "emb = C[Xtr] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 34)\n",
        "# to calculate cross-enthropy loss between the predicted logits and the labels (Ytr)\n",
        "loss = F.cross_entropy(logits, Ytr)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MSvLEXm6nstV",
        "outputId": "58a21e3d-2fde-4763-ee6e-f9ee88ed1ba9"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(1.1585, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# validation loss\n",
        "# to calculate the validation loss using the same process as the training loss but with the validation dataset (Xdev, Ydev)\n",
        "emb = C[Xdev] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 34)\n",
        "loss = F.cross_entropy(logits, Ydev)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bw0oL49envNG",
        "outputId": "bfe39181-4d2e-4f53-dbcd-6546b4603e4e"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(6.3454, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# test loss\n",
        "# to calculate the test loss with the test dataset (Xte, Yte)\n",
        "emb = C[Xte] # (32, 3, 2)\n",
        "h = torch.tanh(emb.view(-1, 30) @ W1 + b1) # (32, 100)\n",
        "logits = h @ W2 + b2 # (32, 34)\n",
        "loss = F.cross_entropy(logits, Yte)\n",
        "# to print put the results\n",
        "loss"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xh0NC7ornx6R",
        "outputId": "f1b4f694-869f-48ee-fa27-0b82514d9d21"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor(6.0265, grad_fn=<NllLossBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# visualize dimensions 0 and 1 of the embedding matrix C for all characters\n",
        "plt.figure(figsize=(8,8)) # to create a new figure for the plot with size of 8x8 inches\n",
        "\n",
        "# to creates a scatter plot using the first and second dimensions of the embedding matrix C\n",
        "# where point in the scatter plot represents the embedding of a character\n",
        "# the s = 200 argument sets the size of each point to 200\n",
        "plt.scatter(C[:,0].data, C[:,1].data, s = 200)\n",
        "\n",
        "# the loop that iterates over each character embedding in the embedding matrix C\n",
        "for i in range(C.shape[0]):\n",
        "\n",
        "    # the annotatins to the scatter plot at the position of each character's embedding\n",
        "    plt.text(C[i,0].item(), C[i,1].item(), itos[i], ha=\"center\", va=\"center\", color='white')\n",
        "\n",
        "# to add a minor grid to the plot\n",
        "plt.grid('minor')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 676
        },
        "id": "CbO7-twQn2E4",
        "outputId": "9b9818f0-e962-4913-d81f-203c70fca331"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAp4AAAKTCAYAAACw6AhNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABm30lEQVR4nO3dfXhU5Z3/8c+ZQxIgBEgIUQwhg0JVpCFKCKIuVatYn4r9pdm61tbabrVWu4tu0drd+tCtrUK30Lpuq9uu0l1ZNLKablst6KpUCyREY0BQQJMQAhJDQp6QZDhzfn/EiQmZmcwkM2dmMu/XdXm1OXPmzDc3CXzOfe4Hw7ZtWwAAAECUuWJdAAAAAJIDwRMAAACOIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcMSbWBQTj9Xp14MABZWRkyDCMWJcDAACAE9i2rY6ODp1yyilyuYL3acZ18Dxw4IDy8vJiXQYAAACG0NDQoOnTpwc9J66DZ0ZGhqTeb2TixIkxriZ6PB6PNmzYoCVLliglJSXW5cQ92it0tFXoaKvw0F6ho61CR1uFJ17aq729XXl5eX25LZi4Dp6+x+sTJ04c9cFz/PjxmjhxIr9oIaC9QkdbhY62Cg/tFTraKnS0VXjirb1CGRbJ5CIAAAA4guAJAAAARxA8AQAA4AiCJwAAABxB8AQAAIAjCJ4AAABwBMETAAAAjiB4AgAAwBEETwAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwfMEXq8d6xIAAABGpTGxLiDWdjS2qWxbgyrqWrS3qVMey1aKaWhWzgQVu7NUWpSnubmTYl0mAABAwkva4FnX3KU719eoorZFpsuQ1a+n02PZ2nWwQ7sPdWrN5noVz8zSipICubPTY1gxAABAYkvKR+3l1Y1asmqTqupbJWlA6OzPd7yqvlVLVm1SeXWjYzUCAACMNknX41le3ahl66oVzkhOy2vLkq1l66olSUsLc6NSGwAAwGiWVD2etc1dWl5WE1bo7M+WtLysRnXNXZEsCwAAICkkVfC8a32NLHtks9Yt29ad62siVBEAAEDySJrguX1/mypqWwKO5wyV5bVVUduiHY1tEaoMAAAgOSRN8HymqkFjXIbf19bddK7uuWrOgGPLLpmtP/7dBX7PN12GyrY1RLxGAACA0SxpgmdFXYuOR2hxeMtrq7KuNSLXAgAASBZJEzz3NnVG9Hp7mjoiej0AAIDRLimWU/J6bXms4L2d15+bry8tyOv7OsV0aW+QcOmxbHm9tlwBHt8DAABgoKQIni6XoRTTCBo+y6sb9a8v7+37+mvnubVwZlbA81NMg9AJAAAQhqQInpI0K2eCdh0M3IPZcey46g8f7fu67SNP0OvNzsmIWG0AAADJIGnGeBa7s2RGqIfSdBla4M6MyLUAAACSRdIEz9KivBGv4eljeW2VFuUNfSIAAAD6JM2j9rm5k1Q8M0tV9a2DAui1j20ZdP7qF/do9Yt7Bh03XYbm52dqbu6kqNUKAAAwGiVNj6ckrSgpkGmM7HG7aRhaUVIQoYoAAACSR1IFT3d2ulaWFmi40dOQtLK0QO7s9EiWBQAAkBSS5lG7z9LCXEnS8rIaWbYd0rhP02XINAytLC3oez8AAADCk1Q9nj5LC3O14fbFmp/fOzM90Gx33/Gi/ExtuH0xoRMAAGAEkq7H08edna6nb16kHY1tKtvWoMq6Vu1p6pDHspViGpqdk6EF7kyVFuUxkQgAACACkjZ4+szNnTQgWLINJgAAQHQk5aP2YAidAAAA0UHwBAAAgCMIngAAAHAEwRMAAACOIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAARxA8AQAA4AiCJwAAABxB8AQAAIAjCJ4AAABwBMETAAAAjiB4AgAAwBEETwAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwRMAAACOIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAARxA8AQAA4AiCJwAAABxB8AQAAIAjCJ4AAABwhGPB88EHH5RhGFq2bJlTHwkAAIA44kjwrKys1KOPPqqCggInPg4AAABxKOrBs7OzU1/+8pf17//+78rMzIz2xwEAACBOjYn2B9x666268sordckll+hHP/pR0HO7u7vV3d3d93V7e7skyePxyOPxRLXOWPJ9b6P5e4wk2it0tFXoaKvw0F6ho61CR1uFJ17aK5zPN2zbtqNVyLp16/TAAw+osrJSY8eO1YUXXqjCwkKtXr3a7/n33Xef7r///kHH165dq/Hjx0erTAAAAAzT0aNHdd1116mtrU0TJ04Mem7UgmdDQ4OKioq0cePGvrGdQwVPfz2eeXl5am5uHvIbSWQej0cbN27UpZdeqpSUlFiXE/dor9DRVqGjrcJDe4WOtgodbRWeeGmv9vZ2ZWdnhxQ8o/aovaqqSk1NTTrnnHP6jlmWpU2bNulf//Vf1d3dLdM0B7wnLS1NaWlpg66VkpKSFD+AyfJ9RgrtFTraKnS0VXhor9DRVqGjrcIT6/YK57OjFjw/+9nPavv27QOO3XjjjTrjjDN01113DQqdAAAAGN2iFjwzMjI0d+7cAcfS09M1ZcqUQccBAAAw+rFzEQAAABwR9eWU+nvllVec/DgAAADEEXo8AQAA4AiCJwAAABxB8AQAAIAjCJ4AAABwBMETAAAAjiB4AgAAwBEETwAAADiC4AkAAABHEDwBAADgCIInAADACHm9dqxLSAiObpkJAAAwGuxobFPZtgZV1LVob1OnPJatFNPQrJwJKnZnqbQoT3NzJ8W6zLhD8AQAAAhRXXOX7lxfo4raFpkuQ1a/nk6PZWvXwQ7tPtSpNZvrVTwzSytKCuTOTo9hxfGFR+0AAAAhKK9u1JJVm1RV3ypJA0Jnf77jVfWtWrJqk8qrGx2rMd7R4wkAADCE8upGLVtXrXBGclpeW5ZsLVtXLUlaWpgbldoSCT2eAAAAQdQ2d2l5WU1YobM/W9LyshrVNXdFsqyERPAEAAAI4q71NbLskc1at2xbd66viVBFiYtH7QAAAAFs39+mitqWgK8bhnTTX52qvymeoWmTx6q5s0drt+7TIy/vHXCe5bVVUduiHY1tST3bneAJAAAQwDNVDRrjMnQ8wESiuy47Q9cW5+mff79TlXWtyslI02k5E/yea7oMlW1rIHgCAABgsIq6loChMz3V1I3nu3XP797W+jd6Z67vazmqbR/Pej+R5bVVWef/tWTBGE8AAIAA9jZ1BnxtVs4EpaWYen1vc8jX29PUEYmyEhbBEwAAwA+v15bHCjyp6JjHG/Y1PZad1NtrEjwBAAD8cLkMpZhGwNfrDnfpox5L58/KDvmaKaYhlyvwNUc7xngCAAAEMCtngnYd9P94vPu4V7969T3dffkZ8lhebatr1ZT0VM0+KUNPb2vw+57ZORnRLDfuETwBAAACKHZnafehzoDbY/7i//bouNfWHZd+SjkZY9XUcUxrt+7ze67pMrTAnRnNcuMewRMAACCA0qI8rdlcH/B125YeeXnvoHU7/bG8tkqL8iJZXsJhjCcAAEAAc3MnqXhmlswRjss0XYaKZ2Yl9RqeEsETAAAgqBUlBTKNEQZPw9CKkoIIVZS4CJ4AAABBuLPTtbK0QMONnoaklaUFcmenR7KshMQYTwAAgCEsLcyVJC0vq5Fl2wEnG/VnugyZhqGVpQV970929HgCAACEYGlhrjbcvljz83tnpgca9+k7XpSfqQ23LyZ09kOPJwAAQIjc2el6+uZF2tHYprJtDaqsa9Wepg55LFsppqHZORla4M5UaVFe0k8k8ofgCQAAEKa5uZMGBEuv107qHYlCxaN2AACAESJ0hobgCQAAAEcQPAEAAOAIgicAAAAcQfAEAIyYN4Q1DQGAWe0AgLDtOtguSSr55V+061BX31Iys3ImqNidxVIyAPwieAIAQlbX3KU719forX2HtaJYevdQhzxW72xej2Vr18EO7T7UqTWb61U8M0srStgmEMAneNQOAAhJeXWjlqzapKr61qDn+bYSrKpv1ZJVm1Re3ehEeQASAD2eAIAhlVc3atm6avlGco4xh36P5bVlydayddWSxLaBAOjxBAAEV9vcpeVlNRru9CFb0vKyGtU1d0WyLAAJiOAJAAjqrvU1suyRzVq3bFt3rq+JUEUAEhXBEwAQ0Pb9baqobekbtzlcltdWRW2LdjS2RagyAImI4AkACOiZqgaNidAe1KbLUNm2hohcC0BiYnIRACCgiroWHQ/S21k8c4r+828XDTjW/pFHBfdvGHSu5bVVWRd8RjyA0Y3gCQAIaG9TZ0jnXfTTV9R57LiumjdNt1/yqYDn7WnqiFRpABIQwRMA4JfXa8tjBR/bmWr2jtj6oO2YPvJY6jh2POj5HsuW12vLFaHH9wASC2M8AQB+uVyGUszgAXHy+BR5LK8+8lghXTPFNAidQBIjeAIAApqVMyHo63lZ49XY+lHI15udkzHSkgAkMIInACCgYneWzCA9lAtmTlFlXUtI1zJdhha4MyNVGoAERPAEAARUWpTndw3PFNPQtGnTdO6p2dq485CmTkjT1Alpyhg7RjKkrPTUQe+xvLZKi/KcKBtAnGJyEQAgoLm5k1Q8M0tV9a0DAujZM7JUXFwsSXrsq0WD3ve7287XBQ+93Pe16TI0Pz9Tc3MnRb9oAHGL4AkACGpFSYGWrNok64Td2pubm3X+qi3qtgY+ip84doz++Pd/NeCYaRhaUVIQ9VoBxDcetQMAgnJnp2tlaYH6x0uP5VVPT4/f8722dLjzk9cMSStLC+TOTo9uoQDiHj2eAIAhLS3MlSQtL6uRZdt6c1+rKiubJZmDzu3sPq6lj7wu02XINAytLC3oez+A5EaPJwAgJEsLc7Xh9sWanx98ZrpvFnxRfqY23L6Y0AmgDz2eAICQubPT9fTNi1Sz77Bq33xNZ5w0UTsPdcpj2UoxDc3OydACd6ZKi/KYSARgEIInACBsZ06bqNo3pWduWaSUlBS2wQQQEh61AwBGjNAJIBQETwAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwRMAAACOIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAAR0Q1eP7yl79UQUGBJk6cqIkTJ2rRokV6/vnno/mRAAAAiFNRDZ7Tp0/Xgw8+qKqqKm3btk0XX3yxli5dqrfffjuaHwsAAIA4NCaaF7/66qsHfP3AAw/ol7/8pbZs2aKzzjormh8NAACAOBPV4NmfZVkqKytTV1eXFi1a5Pec7u5udXd3933d3t4uSfJ4PPJ4PI7UGQu+7200f4+RRHuFjrYKHW0VHtordLRV6Gir8MRLe4Xz+YZt23YUa9H27du1aNEiHTt2TBMmTNDatWt1xRVX+D33vvvu0/333z/o+Nq1azV+/PholgkAAIBhOHr0qK677jq1tbVp4sSJQc+NevDs6enRvn371NbWpmeeeUa//vWv9eqrr2rOnDmDzvXX45mXl6fm5uYhv5FE5vF4tHHjRl166aVKSUmJdTlxj/YKHW0VOtoqPLRX6Gir0NFW4YmX9mpvb1d2dnZIwTPqj9pTU1M1a9YsSdL8+fNVWVmpn//853r00UcHnZuWlqa0tLRBx1NSUpLiBzBZvs9Iob1CR1uFjrYKD+0VOtoqdLRVeGLdXuF8tuPreHq93gG9mgAAAEgOUe3xvPvuu3X55ZdrxowZ6ujo0Nq1a/XKK6/oT3/6UzQ/FgAAAHEoqsGzqalJX/3qV3Xw4EFNmjRJBQUF+tOf/qRLL700mh8LAACAOBTV4Pmb3/wmmpcHAABAAmGvdgAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwRMAAACOIHgCAADAEQRPjHperx3rEgAAgKK8cxEQCzsa21S2rUEVdS3a29Qpj2UrxTQ0K2eCit1ZKi3K09zcSbEuEwCApEPwxKhR19ylO9fXqKK2RabLkNWvp9Nj2dp1sEO7D3VqzeZ6Fc/M0oqSArmz02NYMQAAyYVH7RgVyqsbtWTVJlXVt0rSgNDZn+94VX2rlqzapPLqRsdqBAAg2dHjiYRXXt2oZeuqFc5ITstry5KtZeuqJUlLC3OjUhsAAPgEPZ5IaLXNXVpeVhNW6OzPlrS8rEZ1zV2RLAsAAPhB8ERCu2t9jSx7ZLPWLdvWnetrIlQRAAAIhOCJhLXzQLsqalsCjucMleW1VVHboh2NbRGqDAAA+MMYTySs56obNcZl6HiA4GkY0i2fOU1/UzxDUzPSVNvcpV+8tEfP7/hg0Lmmy1DZtgaWWQIAIIoInkhYVfWtAUOnJH37wln6wtm5+sdnt6v2cJcWzpyi1V8qVEtXhbbWtgw41/LaqqxrjXbJAAAkNYInEtb7H3YGfC3VdOnWi07T9b/eqjf2HZEkNbTsV5E7U9ctnDEoeErSnqaOaJUKAABE8EQC83htSYbf1/KnjNf41DH6z28sHHA8xXRp5wH/Yzk9li2v15bL5f+aAABgZAieSFgpLkPdlv/X0tN6f7S//kSlPmg/NuC1nuNe/9czDUInAABRRPBEwjp16gTVHPD/uH3PoQ51eyydMnmc38fq/szOyYhkeQAA4AQETySs+fmZevuDLr/LKXX1WHrsz+/rB1fNkcuQKutalTF2jIrcWeo85tH6NwZulWm6DC1wZzpVOgAASYngiYT1hbNz9fjmhoCv/8uG3Wrp6tG3L5ylvKzxaj/m0duNbXrklfcGnWt5bZUW5UWzXAAAkh7BEwnrzGkTVTwzS1X1rQEXkX/89To9/npd0OuYLkPz8zNZwxMAgChj5yIktBUlBTKNkU0IMg1DK0oKIlQRAAAIhOCJhObOTtfK0oIAiyoNzZC0srRA7uz0SJYFAAD84FE7Et7SwlxJ0vKyGlm2HdLe7abLkGkYWlla0Pd+AAAQXfR4YlRYWpirDbcv1vz83pnpZoD1OH3Hi/IzteH2xYROAAAcRI8nRg13drqevnmRdjS2qWxbgyrrWrWnqUMey1aKaWh2ToYWuDNVWpTHRCIAAGKA4IlRZ27upAHBkm0wAQCIDzxqx6hH6AQAID4QPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAARxA8AQAA4AiCJwAMg9drx7oEAEg47NUOACHY0dimsm0Nqqhr0d6mTnksWymmoVk5E1TszlJpUZ7m5k6KdZkAENcIngAQRF1zl+5cX6OK2haZLkNWv55Oj2Vr18EO7T7UqTWb61U8M0srSgrkzk6PYcUAEL941A4AAZRXN2rJqk2qqm+VpAGhsz/f8ar6Vi1ZtUnl1Y2O1QgAiYQeTwDwo7y6UcvWVSuckZyW15YlW8vWVUuSlhbmRqU2AEhU9HgCwAlqm7u0vKwmrNDZny1peVmN6pq7IlkWACQ8gicAnOCu9TWy7JHNWrdsW3eur4lQRQAwOhA8AaCfnQfaVVHbEnA8Z6gsr62K2hbtaGyLUGUAkPgIngDQz3PVjRrjMgYdX3fTuap78EpddtbJA47/4e8uUN2DV+rcU7MGvcd0GSrb1hC1WgEg0RA8AaCfqvpWHQ/Q23mw7SNdV5zX9/W86ZOUlZ4a8FqW11ZlXWvEawSAREXwBIB+3v+wM+BrL+5s0pxTJil38jhJ0t8snKGnt+0Per09TR0RrQ8AEhnBEwD68QQZ2+mxvHr2zUZ9aUGeJqSN0WVzTtb/vBE8eHosm+01AeBjrOMJAP2kuAx1W4Ff/++KfVr7zYVq7uzWn/d8qNaunuDXMw25/IwZBYBkRI8nAPRz6tQJQV+vbe5SXfNRLb/sdP135dATh2bnZESqNABIePR4AkA/8/Mz9fYHXUGXU3rw+V0qcmdp83uHNXFs4L9GTZehBe7MaJQJAAmJHk8A6OcLZ+cOuYbnW/vb9JvXaoe8luW1VVqUN+R5AJAs6PEEgH7OnDZRxTOzVFXfOiCAXvvYFr/ntx87Lvf3/jDouOkyND8/U3NzJ0WtVgBINPR4AsAJVpQUyDRGNiHINAytKCmIUEUAMDoQPAHgBO7sdK0sLdBwo6chaWVpgdzZ6ZEsCwmC5bOAwHjUDgB+LC3MlSQtL6uRZdsh7d1uugyZhqGVpQV978fot6OxTWXbGlRR16K9TZ3yWLZSTEOzciao2J2lkrOnxbpEIG4QPAEggKWFuZo3fbLuXF+jitoWmS7DbwD1HS/Kz9RDJfR0Jou65q6APxsey9augx3afahT6yrqtKJY2nf4qE47mTG/SG4ETwAIwp2drqdvXtTXq1VZ16o9TR19vVqzczK0wJ2p0qI8JhIlkfLqxr7ecEkBe8Qtr60xZu//v+aR1/Wjknn0hiOpETwBIARzcycNCJZer82OREmqvLpRy9ZVK9yRnD1er5atq5YkwieSFpOLAGAYCJ3Jqba5S8vLasIOnT62escN1zV3RbIsIGEQPAEACNFd6z95vD5clm3rzvU1EaoISCwETwAAQrB9f5sqalsGjefMSk9V5T9+Vt++8LS+Y+fMyNTuH12u806bMug6ltdWRW2LdjS2Rb1mIN4QPOMc68EBQHx4pqpBY/wMsWjp6tHyZ2q07JJP6dO5k5SeamrVl+bpt5vr9Jf3Dvu9lukyVLatIdolA3GHyUVxZqj14Jg5CwCxUVHXouMBOgNeefdDravcp9XXFmr7/jYd7bG04oV3A17L8tqqrGuNVqlA3CJ4xpEbHq/QX94/EnQ9uDWb61U8M0srWCsQABy1t6kz6OsP/GGXNty+WFd8epqufvg19VjeoOfvaeqIZHlAQuBRexz44/aDkqTqhiOSgq8HJ0lV9a1asmqTyqsbHakPQGJgaE70eL22PFbw9s2fMl4nTRwrlyFNzxo35DU9ls2fGZIOPZ4xVl7dqLvW1+ihYl+wHHqJFstry5LNenBAkmNojnNcLkMpphEwfKaYhlZ/qVC/rzmg9z/s0oP/r0CfW71Jh7t6Al4zxTRYlgtJh+AZQ7714Ib7145vPbh50yfz2B1IIqFu1cjQnMialTNBuw76fzz+3SWnK2Nsiu773U519RzXhafnaMUXC/SNNdsCXm92Tka0SgXiFo/aY4j14ACEq7y6UUtWbVJVfe/EFIbmOKfYnSXTTw/luadm6esXzNTtT1Wrs/u4bFu64+lqLZiZpesXzvB7LdNlaIE7M9olA3GHHs8Y8a0HJ6lvH1+fnIw0/fzaszU3d6IMw9C2uhY98Idd2uNnYHv/9eB4pAaMbsPZqpGhOZFTWpSnNZvrBx3f8n6LZv/j8wOO7W/9SAX3bZAkpZmD3iLLa6u0KC8qdQLxjB7PGAm0HpwkGYb0VGWDrn74NX3xl39RQ8tHevrmRcrJSPN7PuvBAaMfWzXG3tzcSSqe6b/XMxymy1DxzCw6C5CUCJ4xEmw9uEPt3XquulF1h4/qnQ869IPyHdrXclRfWZTv93zWgwNGP4bmxIcVJQUyjREGT8PQipKCCFUEJBYetcfIUOvBLS08RT/+wqf7vk4d4wo6O5L14IDRq//QnJFgaM7IubPTtbK0IOwhDz6GpJWlTPZC8opq8PzJT36i//mf/9E777yjcePG6bzzztNDDz2k008/PZofG/dCWQ/uxZ2H+tb1lKQfXDVHPccDL0bsWw+OpTmA0cc3NMffU5J1N52rdz/ovfH8wjm5Om7Z+q8t9frZxt1+r+UbmkPwHD7fONnlZb290IEmeJ0o1eXSitJ5jLNFUovqo/ZXX31Vt956q7Zs2aKNGzfK4/FoyZIl6upK7jFGvvXggunqsVR/+KjqDx/VwSPHdMbJGX3/uPjDenDA6BVsaI4klcyfLstr65p/fV33/+/b+tu/mqlrF/ifuMLQnMhYWpirDbcv1vz83pnpgcZ99j/+3K3nEzqR9KLa4/nCCy8M+PqJJ55QTk6OqqqqtHjx4mh+dNwLth5c7uRxuvD0qdr83mGNSzV128WzNCFtjH67uS7g9VgPDhi9hhqac/DIR/rh73dKkt5v7tIZJ2foGxfM1LpK/5MOGZoTGe7sdD1986K+hfwr61q1p6mjbyH/2TkZWuDOVMnZ01T75muaMWV8rEsGYs7RMZ5tbW2SpKysLL+vd3d3q7u7u+/r9vZ2SZLH45HH44l+gQ461z1Z9c0dsry20ly9PRm+/zVk6eqCafre5WdojMul6oZWfe0/tuhod4/fZTlMl6GF7kmjro0C8X2fyfL9jgRtFbp4bSuv15ZLXr+/+1LvmMGa/a1KMz/pEd2+v1V/+1enatwYW/47Sm11d/eM6ClJvLZXLJyeM17/dMUnQ8hOHPbk8XhUK9oqFPxchSde2iuczzdse4TTJEPk9Xr1+c9/XkeOHNFrr73m95z77rtP999//6Dja9eu1fjx3CkCwInOP/98dXV1qbq6uu/YySefrAULFuh///d/Y1cYgKRx9OhRXXfddWpra9PEiRODnutY8Lzlllv0/PPP67XXXtP06dP9nuOvxzMvL0/Nzc1DfiOJ6IbHK1TdcERj5NU/F3n1g20udXvD64EwXYYK8yZrzY3FUaoy/ng8Hm3cuFGXXnqpUlJSYl1OXKOtQhfPbVXyy7/o3UP+H4//9huLlJWeqqt+8WrfsTuWnKHPnnmSrvz5q37fc8ZJE/XMLYtGVFM8t1e8oa1CR1uFJ17aq729XdnZ2SEFT0cetd922236/e9/r02bNgUMnZKUlpamtLTBi6SnpKSMyh/AH/+/Qi1ZtUnWx4tydHsNdVvhBc9UufTj/1c4KttnKKP15yIaaKvQxWNbnZ0/RW9/0OV39rQtadrkcVr+uTlau3Wf5uZO0vXnuvXAH3b5/fvEdBkqzM+K2PcYj+0Vr2ir0NFW4Yl1e4Xz2VGd1W7btm677TY9++yz+r//+z/NnDkzmh+XcHzrwQ13lBXrwQHJobQoL+iSPf/zxn6NTTH13G3n64dLz9Ljr9dpbcU+v+eyVSOAWIpqj+ett96qtWvXqry8XBkZGfrggw8kSZMmTdK4ceOi+dEJY2lhruS1pIY3e5fdsIZ+j+kyZBqGVpYWsDQHkAR8WzVW1bf6DaDHLVs//P3b+qfndgS9jukyND8/kzU8AcRMVHs8f/nLX6qtrU0XXnihpk2b1vffU089Fc2PTThXfHqaJKkwb7KkodeDK8rP1IbbFxM6gSTCVo0ARoOo9ng6NG9p1FhzY7HebToadD240qI8eiuAJMRWjQBGA/ZqjzNzcycNCJZsgwnAx99Wjdc+tiXoexiaAyCeRPVRO0aO0Amgv3C3amRoDoB4Qo8nACSYULdqZGgOgHhD8ASABMXQHACJhkftADBKEDoBxDuCJwAAABxB8AQAAIAjCJ4AAABwBMETAAAAjiB4AgAAwBEETwAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwRMAAACOIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAARxA8AQAA4AiCJwAAABxB8AQAAIAjCJ4AEoLXa8e6BADACI2JdQEA4M+OxjaVbWtQRV2L9jZ1ymPZSjENzcqZoGJ3lkqL8jQ3d1KsywQAhIHgCSCu1DV36c71NaqobZHpMmT16+n0WLZ2HezQ7kOdWrO5XsUzs7SipEDu7PQYVgwACBWP2gHEjfLqRi1ZtUlV9a2SNCB09uc7XlXfqiWrNqm8utGxGgEAw0ePJ4C4UF7dqGXrqhXOSE7La8uSrWXrqiVJSwtzo1IbACAy6PEEEHO1zV1aXlYTVujsz5a0vKxGdc1dkSwLABBhBE8AMXfX+hpZ9shmrVu2rTvX10SoIgBANBA8AcTU9v1tqqhtCTieM1SW11ZFbYt2NLZFqDIAQKQRPAHE1DNVDRrjMvy+tu6mc3XPVXP6vj41O117Hrhcf/y7C/yeb7oMlW1riEqdAICRI3gCiKmKuhYdD7G38+4rzlT3cW/A1y2vrcq61kiVBgCIMIIngJja29QZ0nmLTp2i+fmZeqpyX9Dz9jR1RKIsAEAUEDwBxIzXa8tjhdbb+Y9Xnqmfv7RHHceOBz3PY9lsrwkAcYrgCSBmXC5DKab/8Z39lZyTq3Gppp7cUj/kuSmmIVeAMaMAgNgieAKIqVk5E4K+PjbF1HcvO10PPf9OSGNBZ+dkRKo0AECEETwBxFSxO0tmkB7KpYWnaN/ho9qw89CQ1zJdhha4MyNZHgAgggieQAwxFlEqLcoLuobnuBRTP/rDrpCuZXltlRblRao0AECEsVc74KAdjW0q29agiroW7W3qlMeylWIampUzQcXuLJUW5Wlu7qRYl+moubmTVDwzS1X1rYMC6LWPbRl0/uoX92j1i3sGHTddhubnZyZd+wFAIiF4Ag6oa+7SnetrVFHbItNlDAhYHsvWroMd2n2oU2s216t4ZpZWlBTInZ0ew4qdtaKkQEtWbZI17N3aJdMwtKKkIIJVAQAijUftQJSVVzdqyapNqqrvXdg80GNl3/Gq+lYtWbVJ5dWNjtUYa+7sdK0sLdBw56IbklaWJldYB4BERI8nEEXl1Y1atq46rH48y2vLkq1l66olSUsLc6NSW7zxfZ/Ly2pk2XZIe7ebLkOmYWhlaUHStBMAJDJ6PIEoqW3u0vKymmE/PLbVG8LqmrsiWVZcW1qYqw23L9b8/N6Z6YFmu/uOF+VnasPtiwmdAJAg6PGMU16vzSLYCe6u9b09d8Gsu+lc7TzQrh/+fqff1y3b1p3ra/T0zYuiUWJccmen6+mbF/VNxKqsa9Wepo6+iVizczK0wJ2ZlBOxACDRETzjyI//uEtb6o4w23kU2L6/TRW1LSO+juW1VVHboh2NbUn35z83d9KA7znSN2Pc3AGA8wieMVbX3KXv/0+1vnSS9NS2Bh31fPIas50T1zNVDRrjMgbttJM9IVW/+Juzdc6MTP3vWwdkGFLG2DFa+82FOmdGpl7ceUj/UPaWuo97+95jugyVbWtIuuB5opGGxKGWsio5e1qEKgUABMIYzxjyzXaubjgiidnOo0lFXYvf7R3vu/osjU8do2seeV1vNRzROTMyddlZJ+vXf67Vdf++VfPyJuvvPjt7wHssr63KulanSh916pq79NePbtZVD7+m/9q6T7sO9j62lz65ufuvrftU+uhmSdK+w0ejXhMbBwBIVvR4xkj/2c5GiNNPknW2cyLa29Q56NjEsWP0ubkn64bHK/TOBx1654MOLT07VzsPtOv/3mmSJP3bK3v13SWna+Wf3h3w3j1NHY7UPdqUVzf2zZKXgt/cjTF7//81j7yuH5XMi+jvFxsHAEAvgmcMRGq287zpk3nsHoe8XruvR62/vKzxGmO6BoRSyztw2aA9hzo1ZUKaMtLGqKP7eN9xj2UzJjFMw1nKSpJ6vN6I3dyxcQAADMSj9hgIZbbzUHyznRF/XC5DKebIAqJxwttTTIPQGYZ4WMqKjQMAYDCCp8N8s50D/SP0mU9NVdm3Fqnm3iV68weX6jc3FGlG1vhB5/Wf7Yz4MytnwqBjDa1HZXntAa+ZLmPAWpWzT5qg1q4etR87PuC9s3MyolfsKBTrmztfb2uP5Q1pIXyp93e6x+rtbSV8AhitCJ4O8812DmRcqqlf/7lWV//ra/ryr7fKa0uPfmX+oB4w6ZPZzog/xe6sQYuft390XBt2fqDll52hM07O0PULZ2je9Mm65uxcXXxGjs6ZkalvXzhLT53wZ2q6DC1wZzpZfkIb6uYuVMO9uYuH3lYAiFcET4cFmu3s88KOD/Sntz9Q/eGj2nmwXXc+85bOnDZRs/30oDHbOX6VFuX5DT73lr+tYx5L5beer4K8yXpzX6v+9PYH+sYFM/Xf31yo7Y1t+vmLewa8x/LaKi3Kc6r0hFbX3KVv/LZy0PF1N52re66a4/c991w1R+tuOtfva8O5uYt1bysAxDMmFznM32zn/txTxuuOSz+lwrxMZaanyPVxV+cpk8dp96HB72W2c3yamztJxTOzVFXfOiCANnV069rHtvR9ve6mc9V57Li+/Outfq9jugzNz89kxnMIfDPYeyzv0CeHKNybOzYOAIDg6PF0UKDZzv395oYFmjw+Vd/7nxpd88hfdM0jr0uSUk3/f1S+2c6IPytKCmT6GyMRBtMwtKKkIEIVjV79x1RGWjg3d/6G0pzY27pkzkmqe/DKAee8dtdF+vr57gHHGEoDYDQieDpoqNnOk8el6LScCXr4//boL+8d1nsfdmrSuJSg12S2c/xyZ6drZWmBhvunY0haWcryOkMJdUzl9efm6+37L9ObP7hUz337PH32zJyQrh/Ozd1QQ2nCwVAaIHmN5g4lHrU7bFbOBO066L8Hpe2YRy1dPfqb4hlq6ujWKZPH6a7PnRH0esx2jm++dSB9i5ifOO6z/2N3H9NlyDQMrSwtYJOAEIQ6prK8ulH/+vJepZoulRbl6d++fI4Wr3h5yPeFc3M31FCacDGUBkgOybTJBMHTYcXuLO0+1Ol34oltS9/57zd039VnacOyxXq/uUv3/e5tPXXzIr/XYrZzYlhamKt50ycHXEjcx3e8KD9TD7GQeEjCGVPZcey46j/eDnPVxt26afGpfpe9OlGoN3ehDKUJFxsHAKNbMm4yQfB0WGlRntZsrg/4+ut7D+vSVZsGHHN/7w9+z2W2c+JwZ6fr6ZsX9d3VVta1ak9TR99d7eycDC1wZ46qu1on+MZU+nu8/dPSAn1x/ie/H+eeOkVfv2CmJOmthlb1HPfq/Q+79NkgDxXCubnzDaWJZPhkKA0weoWzpa/0ySYTif40jODpsECzncPFbOfENDd30oA/M3qzRibYmMr7f7dTDz3fu+f9C8v+SlMmpEmSeo57NT51jJY99aYOth0Lev1wb+6CDaUZDobSAKPTcLb0tby2LNkR29I3VgieMbCipEBLVm2SNewlppntPFoQOkcm2JjKju7jffvdv/xukyTpu2WD18b84e93SpLSzIHHh3NzF2gojctlKG1M71zOMR9PMPR9HQhDaYDRKVKbTMybPlm5k1IjWZojCJ4x4JvtHO7djg+znYHojKnsbzg3d4GG0nztPLe+dp57wLF3f3R50GsxlAYYnSK5ycSTXy+KUFXOIXjGSP/ZzqYrtLUHme0MfCIaYyp9hntz528ojb+VC4bCUBpgdIr0JhO7DrZHoCpnsY5nDC0tzNWG2xerMG+yJA3a29vHd7woP1Mbbl9M6AQ+Fsqs9HClulxafW3hsH/P2DgAQCD+NpnoL9V06d6r52jbP12id//5cyr71iIVTPd/A2q6DD37ZmO0So0agmeMubPTtebGYknSl4ryNGfaxL5F5lNMQ3OmTdT1C2fo99+5QE/dvIjH60A/xe6sgDdsw/XcreeP6OaOjQMABDLUJhN3X3GGLp87Td99+i1d+fBrqj/cpd9+vdjvZjKW19Yb9UeiWG108Kg9jnz/ijOVktL7w8VsZ2BoQy1PNhwzpowf8TWG2jjAH4bSAKNfsAmR41JMfXlhvr5b9pZe2f2hJOl767frtbum6ksL8vTYpvcHvee9Dzuk/KiVGxUEzzhF6ASGFuryZP5ms/fXO6ZysqTmiNXGxgEA+htqQmT+lPFKHeNSVf0nW+Ue99p6a/+RgMOKPAm4tSbBE0BCi9TyZP/8+bnasfWVyBUmNg4A8ImobDKRgJ1UBE8ACS1Sy5PNmDJeOyJd3MfYOACAFHyTifrDR9V93NL8/Ew1HvlIkjTGZahg+iT9x2t1ft9z2tQMSa1+X4tXUZ1ctGnTJl199dU65ZRTZBiGnnvuuWh+HIAktbQwV6uvLVSq6Qp5spHpMpRqjmwG+3AROoHkFGxC5EceS09u2afvX3GmPvOpqZqVM0EPlnxa41JMPbVt36DzTZehc/InR7niyItq8Ozq6tK8efP0yCOPRPNjAKBvebL5+b27/bA8GYB4U1qUF3Q8+kMvvKPndxzUz/56nv7wnQuUPyVdX/2PCrV/dHzQuZbX1hfOTry/v6L6qP3yyy/X5ZcH350DACKFMZUA4tlQEyK7j3t1///u1P3/uzPodXybTJw5baJq34xWtdERV2M8u7u71d3d3fd1e3vvivwej0cejydWZUWd73sbzd9jJNFeoUvWtjo9Z7z+6YrT+772N6byxDZJ1rYaLtordLRV6JKhrX6ydI6ueeR19RjDn2SU6jL0k6Vz4qa9wvl8w7ZHuGFoqB9kGHr22Wd1zTXXBDznvvvu0/333z/o+Nq1azV+/MjX1gMAAEBkHT16VNddd53a2to0ceLEoOfGVfD01+OZl5en5ubmIb+RRObxeLRx40ZdeumlfQvIIzDaK3S0Vehoq/DQXqGjrUKXTG31x+0H9U/P7pClMDaZkKEffWGurvj0NEnx017t7e3Kzs4OKXjG1aP2tLQ0paWlDTqekpIy6n8ApeT5PiOF9godbRU62io8tFfoaKvQJUNbLT1nhubNmBLyJhMLZ2QF3GQi1u0VzmfHVfAEAABIFsk4ITKqwbOzs1N79+7t+7q2tlbV1dXKysrSjBkzovnRAAAACSGZNpmIavDctm2bLrroor6v77jjDknSDTfcoCeeeCKaHw0AAJCQRmvolKIcPC+88EI5NHcJAAAAcS6qOxcBAAAAPgRPADHlDWEZEQDA6MCsdgCO8s3erKhr0d6mzr7Zm7NyJqjYnTWqZm8ickbzZAsgmRA8ATiirrkr4Hp1HsvWroMd2n2oU2s216t4ZpZWBFivDsmBGxRgdCJ4Aoi68upGLS+rkfXxZMNAu3T4jlfVt2rJqk1aWVqgpYW5jtWJ2OMGBRjdGOMJIKrKqxu1bF21eixvSNvCSb0BtMfyatm6apVXN0a5QsSL8upGLVm1SVX1rZJCv0HhZwRIHARPAFFT29yl5WU1Gu70IVvS8rIa1TV3RbIsxCFuUIDkQPAEEDV3rf/k8fpwWbatO9fXRKgixCNuUIDkQfAEEBXb97eporYl5N6rQCyvrYraFu1obItQZYg33KAAyYPgCSAqnqlq0JgILX9jugyVbWuIyLUQXxLxBoW1Z4HhY1Y7gKioqGvR8Qj9A215bVXWtUbkWogvvhsUfz8r6246V+eeOkWSdMxj6f0PO/XQC+/q1d0f+r2W7wYl0ssssbQTEDkETwBRsbepM6LX29PUEdHrIT4MdYOydus+rdq4W+NSTd1+6af009J5WvDAi37PjfQNCks7AZHHo3YAEef12vJYkX0c6bFsHnGOQkPdoBzzWPqws1uNRz7S4c5udRzzBD0/UjcoLO0ERAc9ngAizuUylGIaEQ2fKabBlomjTCg3KNefm68vLchT6hiX2j/y6Ju/3Rb0fN8Nykh+VnxLO4Xz02t5bVmytWxdtSSx8QEQAD2eAKJiVs6EiF5vdk5GRK+H2PPdoARTXt2oK37xZ135iz/rmar9euTL52hCWuA+k5HeoLC0ExBdBE8AUVHszpIZwVntC9yZEbkW4stQNygdx46r/vBR7T7UqZ+/tEfTJo3TvLzAE3lGeoPC0k5AdPGoHUBUlBblac3m+ohcy/LaKi3Ki8i1EF+K3Vnafagz4BjKsSmmpk5IU+oYl0rm58pjeVV/+Kjfc0d6g+Jb2smf/jPs+9t5oE1X/OK1Acf6L+3EbHdgIIIngKiYmztJxTOzVFXfOqI1Gk2Xofn5mfwDPkoNdYNy3cIZum7hDHUft1TXfFTL1lVrf+tHfs8d6Q1KsKWdpE9m2Pt8c/GpumDW4DAqRW9pJyDRETwBRM2KkgItWbVJ1rBHzEmmYWhFSUEEq0I8CXaDcu1jW0K+TiRuUIZa2sk3w97naM/xgOey9izgH2M8AUSNOztdK0sLNNyRnoaklaWsjTjarSgpkGmMbDxwJG5QWHsWiD6CJ4CoWlqYq9XXFirVdIU82ch0GUo1XVp9bWFcLUvDOqLREQ83KKw9CziDR+0Aom5pYa7mTZ8ccBcYH9/xovxMPRQHu8CwVaJzfDcYy8t6Z5WHMi7YdBkyDUMrSwtGfIMSzbVnLStilwQSHsETgCPc2el6+uZFfWGusq5Ve5o6+sLc7JwMLXBnxkWYY6vE2Ij1DcqsnAnadTByj8dZexYYjOAJwFFzcycNCJYj3WUm0v64/aCWr3+7by3HULdKjESvG2J7gzLU0k7hYO1ZwD+CJ4CYiqfQKfUuIN5jhV4TWyVGRyxuUIIt7eRvhv3qF/do9Yt7/J7P2rOAf0wuAgCpb1FytkqMT07coPiWdhrpjlumy1DxzKyYDxkB4hHBEwAk3fO7HSO+BlslJr54WdoJGK0IngCS3vb9baqqH/li3/23SkRiioelnYDRjDGeAJKeb6vEQManmvrh0rP0mU/laGpGWt/xK37+Z+082D7gXLZKTHyxXtoJGM0IngCS3lBbJd560Sz91eypum3tG3r/wy5NmzxWv7vtAr/nslXi6BDrpZ2A0YrgCSDp7W3qDDruaM60iXppV5O21rZIktJSgo9S2nmwXbP/8Y8sNJ/gEmntWSBREDwBJDXfVolpZuBzGlqP6oJZ2TppYpoOtXeHdF0Wmh894n3tWSCREDwBJDXfVonBFlL6xUt7NDM7XVu/f4m6uo8rnEnPLDQ/+hA6geFjVjuApDcrZ0LQ15s7e/T463Vq7erRl3+9VTc+Xhn2Z1heWz2WV8vWVau8unG4pQJAQiN4Akh6xe7gi4bnZY3Tv5TO0x1Pv6XqhiNqPPKR3/NuOM+t71w8S5L0lXPz9f0rzhx0DgvNA0hmBE8ASa+0KC/gkjlpY1z61fXz9Z9b6vXyu01Br/OHmgMqOWe69jxwub5z8Sw9Vdng9zwWmgeQrBjjCSDpzc2dpPn5mZKaB73WfdyrK3/x2oBj+1s/kvt7fxh0bnNnjy76l1c0dUKaDnf1BAyz/ReaZzY0gGRCjycASPrnz88d0fvX3XSu7rlqjmxbauroVn7WeO154HL98e/8r/fpW2geAJIJwRMAJM2YMl6Shr1V4onuvuJMdR/3BnydheYBJCOCJwD081BJgVJNV9DJRkNZdOoUzc/P1FOV+4Ket6epY9ifAQCJiOAJAP1c8elp2nD74o/HfGpYAfQfrzxTP39pjzqOHQ96nsey5Q1hH3AAGC0IngBwAt9Wib//zgW6fuEMzZk28eNF5odWck6uxqWaenJL/ZDnppgGi5EDSCrMageAAE7cKvFzq1/VOx90Bjx/bIqp7152uu4tf1vHQ+jJnJ2TEZE6ASBR0OMJACFaOHNK0EfvSwtP0b7DR7Vh56Ehr2W6DC1wZ0ayPACIewRPAAhRsIXmJWlciqkf/WFXSNeyvLZKi/IiVRoAJAQetQNAiObmTlLxzCxV1bcOCqDXPrZl0PmrX9yj1S/uGXTcdBman5/J4vEAkg49ngAQhhUlBTKNkU0IMg1DK0oKIlQRACQOgicAhMGdna6VpQXDXmjekLSytEDu7PRIlgUACYFH7QAQpqWFuZKk5WU1smw76LhPH9NlyDQMrSwt6Hs/ACQbejwBYBiWFuaGtNC873hRfqY23L6Y0AkgqdHjCQDD5Ftofkdjm8q2NaiyrlV7mjrksWylmIZm52RogTtTpUV5TCQCABE8AWDETlxo3uu12ZEIAPzgUTsARBihEwD8I3gCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAE4pQ3hN1wAABIJKzjCcQJ3yLkFXUt2tvU2bcI+aycCSp2Z7EIOQAg4RE8gRira+7SnetrVFHbItNlDNj322PZ2nWwQ7sPdWrN5noVz8zSipICubPTY1gxAADDw6N2IIbKqxu1ZNUmVdW3StKA0Nmf73hVfauWrNqk8upGx2oEACBS6PEEYqS8ulHL1lUrnJGclteWJVvL1lVLkpYW5kalNgAAooEeTyAGapu7tLysJqzQ2Z8taXlZjeqauyJZFgAAUUXwBGLgrvU1suyRzVq3bFt3rq+JUEUAAEQfwRNw2Pb9baqobQk4nnPdTefqnqvmDHkdy2urorZFOxrbIl0iAABRQfAEHPZMVYPGuIyIXMt0GSrb1hCRawEAEG0ET8BhFXUtOh6hxeEtr63KutaIXAsAgGhjVjvgsL1NnUOec/25+frSgjz1HPeq/nCXHn55r17a1eT33D1NHZEuEQCAqKDHMwbYCjF5eb22PNbQf/7l1Y264hd/1l8/ulkVda36ty+fo5Mmpvk912PZ/EwBABICPZ4OGGorxJKzp8W6RDjE5TKUYhpDhs+OY8dVf/ioJGnVxt26afGpmpUzQYfauwedm2IackVozCgAANFE8IyiULdCXFdRpxXF0r7DR3XayezFPdrNypmgXQeDPx53uQyljXEp1XTprz9+5P7+h/7X7JydkxGNMgEAiDiCZ5SUVzdqedknazUG2wpxjNn7/6955HX9qGQeu9GMcsXuLO0+1BnwZ0KSvnaeW187z63u45bqmo9q2VNv6mDbsUHnmS5DC9yZ0SwXAIbF67V5GoNBCJ5RMJytECWpx+tlK8QkUFqUpzWb6wO+fu1jW0K+luW1VVqUF4myAGBEhhpWVlqUp7m5PNVLdgTPCIvUVojzpk+WOzs9kqUhTszNnaTimVmqqm8N2us5FNNlaH5+Jn+RA4ipUIeVrdlcr+KZWVpRUsC/b0mMWe0RxlaICMWKkgKZxsgeQZmGoRUlBRGqCADCV17dqCWrNqmqvnc94WDDyiSpqr5VS1ZtUnl1o2M1Ir4QPCNoqK0QQ8VWiKOfOztdK0sLNNzoaUhaWUqvAYDY8Q0r67G8If+7Z3lt9Vi9w8oIn8mJ4BlBJ26FaBjSY1+Zr//8RnHf8S/On66ae5f0nXPOjExV/eAyTZ06dcC12Apx9FtamKvV1xYq1XTJDHEAvukylGq6tPraQsYBA4iZSA0rq2v2v1oHRi9Hgucjjzwit9utsWPHauHChaqoqHDiYx134laIti1957/fVHrqGD3k55HozOx0/fqGIv3o92/rww8/HPAaWyEmh6WFudpw+2LNz++dmR4ogPqOF+VnasPtiwmdAGKKYWUYrqgHz6eeekp33HGH7r33Xr3xxhuaN2+eLrvsMjU1+d/+L5H52wqx+7hX31hTqbNnTNZ3l5zedzx7QqrW3FisJ/5Sq2ff3O/3emyFmBzc2el6+uZF+v13LtD1C2dozrSJSjF7g2aKaWjOtIm6fuEM/f47F+ipmxfxeB1ATDGsDCMR9VntP/vZz/TNb35TN954oyTpV7/6lf7whz/oP/7jP/S9730v2h/vmGBbIbYe9ei9Dzt128WztOX9wzJdhv7jaws0Y8p4VdYG7tX0bYXIOmjJYW7upAEz1PmzBxCPfMPKjvsJnv/vnFz94Mo5Wvjjl9RjefuOP/aV+ersPq47nn5rwPm+YWWszpE8oho8e3p6VFVVpbvvvrvvmMvl0iWXXKLNmzcPOr+7u1vd3Z9sCdje3i5J8ng88ng80Sw1IiakSB4/v4iXzjlZRe4sfXNNhVZfe47S08bocGe3fvrCLv34C3P1xUdelSSluQa+N8VlyLKOy7IcKT9h+H4WEuFnYqRG+mefTG01UrRVeGiv0I22tnqz/rBMwyvTHPzai28f0H1Xn6XL5+bohR0HJUlZ6am66IwcfePxrUozT/w30lZ1fcugNhotbRVt8dJe4Xy+YdsjHKQRxIEDB5Sbm6u//OUvWrRoUd/xO++8U6+++qq2bt064Pz77rtP999//6DrrF27VuPHj49WmVE1ZswYXXzxxXrnnXe0b98+nXrqqTrzzDP1wgsvyLIsfeYzn9GhQ4f0zjvvxLpUAABGrKCgQOPHj9eWLb2bYZx22mmaOXOmXnzxxRhXhmg5evSorrvuOrW1tWnixIlBz42rBeTvvvtu3XHHHX1ft7e3Ky8vT0uWLBnyG4kHP/7jLj21rWHAuJd7P3+W3jrQpRueaZRk6gseS9+fZesfNkuSqbP2b9eT3zxPjY2NWvZyl7q9vY9WTZehLxXl6ftXnBmT7yWeeTwebdy4UZdeeqlSUlJiXU5co61CR1uFh/YK3WhqK6/XVsEPNwQ958yGBj1zywX66Tvpamo/pt8tnKFfb96vf6vw00X6sZp7lsjlMkZVWzkhXtrL94Q6FFENntnZ2TJNU4cOHRpw/NChQzr55JMHnZ+Wlqa0tLRBx1NSUhLiB7CkKF+Pb26QPl6d8ZwZk3XN2dN1xc//rG6r99hxu/d/fV+/0dCu/66o09J589T90ua+47J6r5cI33esJMrPRTygrUJHW4WH9grdaGkrr1wB5zRIUvX+Du062KGr503Xpj0falZOhtZVVn7y79sJUkxDaWmpA4+NkrZySqzbK5zPjuqs9tTUVM2fP18vvfRS3zGv16uXXnppwKP30cK3FaJv6Zs39h3RnHv+pLrDR/vOeaZqvwruH3i3+NDzu/Taa6/1fW26DBXPzGKwNQDHeUc4Uxmj36ycCUOe81TlPpXMn67S+Xl6fW+zDrYdC3ju7JyMSJaHOBf1R+133HGHbrjhBhUVFam4uFirV69WV1dX3yz30WZFSYGWrNoka9jL6rIVIgDn7GhsU9m2BlXUtWhvU6c8lq0U09CsnAkqdmeptCiPm2AMUOzO0u5DnUGXUyqvPqDvX3mmri3O0z+cMJO9P9NlaIE7MxplIk5FPXh+6Utf0ocffqh77rlHH3zwgQoLC/XCCy/opJNOivZHx4RvK8Rl66qHFT3ZChGAE+qau3Tn+hpV1LbIdBkDQoTHsrXrYId2H+rUms31Kp6ZpRUl/L2EXqVFeVqzuT7oOR3dx/X8jg908ek52vD2oYDnWV5bpUV5kS4RccyRnYtuu+021dfXq7u7W1u3btXChQud+NiYGc5WiJKU6mIrRADRV17dqCWrNqmqvncd4UA9V77jVfWtWrJqE3trQ9LgYWWBnDxxrJ6rbhywnmd/DCtLTuzVHiXhboUoSc/dej6hE0mJcYXOKa9u1LJ11eqxvCHvPGN5bfVYXi1bV034hKTeYWWm4f/ftYnjxuiys07SuadO0X8G6RllWFlyiqvllEYb31aIvjFUlXWt2tPU0TeGanZOhha4M1Vy9jTVvvmaZkxJzLVKgXAxrjA2apu7tLysZtgj0G1Jy8tqNG/6ZOVOSh3yfIxewYaV/fHv/koTx6Xoweff0fvNXX7fz7Cy5EXwdMBQWyF6PB7VvhmLygBnMa4wtu5aXyNrhHuGWLatO9fX6MmvF0WoKiQq3xO65WW9P1e+3+cLHno54HtMlyHTMLSytIAnfEmKR+0xwP7bSEahjiv0/XYwrjCytu9vU0VtS8iP1wOxvLYqalu062DoC0Zj9Ap3WFlRfqY23L6Y0JnE6PEEEHW+cYX+Ik9e1jjdvPg0LZyZpewJacoYO0aXrd6k9z7skiVby9ZVSxL/UI3QM1UNGuMydDwC42lNl6Fn32xU4cjLwigQ6rAyhtBAIngCiLJg4wpPmzpB//Pt8/TH7Qd15zM1ajnao+OWrcYjH/Wd039cIY/dh6+iriUioVPq7fV8o/6ICvMjcjmMEkMNKwMkgieAKAs2rvCHS8/SbzfX6V827A56Dd+4wqdvHn07njllb1Nn0NeXFp6iH3/h031ff+3xClXWtQY8/70POySCJ4IgdMIfgieAqPGNK/RnXIqpRadO0fbGNr383Qt1yqSxqj3cpX/ZsFsbdw5ccNo3rnBHYxuP6obB67WD7q0tSS/uPKTqhiN9X38QZItDSfKwBBaAYWByEYCo8Y0r9CdzfIpcLkPXLZyhVRt363M//7Ne2PGBfnX9fM2ZNtHve77ym626t3yHdjS2RbPsUcflMpRiBu996uqxVH/4aN9/3cf9L/rtk0JvFoBhIHgCiJpg4wp9j+F+9cp7+t1bB1Tb3KXVL+7R5vcO65uLT/X7ntajHv3X1n266uHX9NePblZdgDUCMdisnAkRvd5pUzMiej0AyYHgCSBqhhpXKKlveSWfbfUtmh0kJLGN4/AUu4fe4jBUpsvQOfmTI3ItAMmF4AkgKoYaV9h21BPwtVDWOGcbx/CUFuWNeA1PH8tr6wtns7wVgPARPJE02A/cWUONK+zoPq6m9mN9C0/7FOVnaU9ThyTp2xeepvW3nCdJ2nD7Yl1/7uBp1L7llnjsHtzc3EkqnjnyXk/TZah4ZpbODDAOFwCCYVY7Ri32A4+9WTkTtOtgR8DXf/NarW69eJYaWo5qx4F2LS08RYtOm6KrHv6zJOnJrfv07Ju9vZk3Pl6p9o/895Ky3FJoVpQUaMmqTbKGvVu7ZBqGVpQURLAqAMmE4IlRh/3A40exO0u7D3UGfMT7739+X+lpY/SPV85RVnqq3vuwU9/6r6q+sNr2kUdtH4fN/ovKn4jllkLjzk7XytKCgLtIDcWQtLK09/fF4wk8VAIAAiF4YlQpr27U8rJPFiwPFHhOnKCysrSALRmjoLQoT2s21wd83WtLP9u4Wz/bOHgBecOQbvnMafqb4hmampGm2uYu/eKlPXp+xwd+r2W6DJVtayB4DsH3c+77PQll3KfpMmQaBr8nAEaM4IlRI9h+4IFYXpv9wKPIN66wqr417Ikt375wlr5wdq7+8dntqj3cpYUzp2j1lwrV0lWhrX4Wpbe8dtCddvCJpYW5mjd9csAnAz6+40X5mXqIJwMAIoDgiVEh2H7goWA/8OgZzrjCVNOlWy86Tdf/eqve2HdEktTQsl9F7kxdt3CG3+ApqW9SEobmzk7X0zcv6hsLXVnXqj1NHX1joWfnZGiBO5Ox0AAiiuCJUSHYfuChYoJKdAxnXGH+lPEanzpG//mNhQOOp5gu7TwQeNcij2XL67XZIzoMc3MnDQiWtB+AaCJ4IuEF2w88HExQiZ5wxxWmp/X+1fT1Jyr1QfvAPcN7gmzlmGIahKYRov0ARBPreCLhBdsPPFy+CSqIvKWFudpw++K+dTuDrSe551CHuj2WTpk8bsD+4fWHj+pg27GA75udwzaOABDP6PFEwgu0H/i6m87VzgPt+uHvd/YdW3bJbC2Zc5Ku+MVrfq/FBJXoOnFc4e/eOqBWPzsYdfVYeuzP7+sHV82Ry5Aq61qVMXaMitxZ6jzm0fo3Bu9UZLoMLXBnDjoOAIgfBE8kvFD2Aw8HE1SizzeusLQoT1c97P8m4F827FZLV4++feEs5WWNV/sxj95ubNMjr7zn93zLa6u0KC+aZQMARojgiYQ21H7gw8EEFecMtdzS46/X6fHX64a8jukyND8/k7G5ABDnGOOJhDbUfuDDwQQVZ60oKZBpjHD/cLZxBICEQPBEwpuVMyGi12OCirN8yy0NN3r238YRABDfCJ5IeMXurKAzpMPBBJXYWFqYq9XXFirVdIX8Z2m6DKWaLq2+tpAdpwAgQRA8kfBKi/ICrgvpchlKG+Pq+890GTKMwI/nmaASO6Eut+Q7XpSfqQ23LyZ0AkACYXIREl6wCSpfO8+tr53nHvSe//zGQl372JYBx5igEnts4wgAoxvBE6OCv/3ATwyWPnOmTdQ9V88ZdJwJKvGDbRwBYHTiUTtGhXAmqHhte9C2i0xQiW+ETgAYHejxxKgR6n7g73zQoa/+R4Wk3sfrpmFoZWkBYwUBAIgyejwxqjBBBQCA+EWPJ0YdJqgAABCfCJ4YtZigAgBAfOFRO5IGoRMAgNgieAIAAMARBE8AAAA4guAJAAAARxA8AQBJyxtgvV8A0cGsdgBA0vAts1ZR16K9TZ19y6zNypmgYncWy6wBUUbwBACMenXNXbpzfY0qaltkuowBO5t5LFu7DnZo96FOrdlcr+KZWVpRwha6QDTwqB0AMKqVVzdqyapNqqpvlaSA2+n6jlfVt2rJqk0qr250rEYgWdDjCQAYtcqrG7VsXbXCGclpeW1ZsrVsXbUksaUuEEH0eAIARqXa5i4tL6sJK3T2Z0taXlajuuauSJYFJDWCJwBgVLprfY0se2Sz1i3b1p3rayJUEQCCJzBMLMMCxK/t+9tUUdsScDxnqCyvrYraFu1obItQZUByY4wnECKWYQESxzNVDRrjMnTcT/Cse/BK3fTbbdqw85Ak6Yvzp+ueq+ao4P4Nfq9lugyVbWvg9xuIAIInMASWYQEST0Vdi9/QORyW11ZlXWtErgUkOx61A0GwDAuQmPY2dQZ87ZjH0tgUM6zr7WnqGGlJAETwBALyLcPSY3lDHidmeW31WF4tW1dN+ARixOu15bEC/86++0GHLv/0yRrjMkK+pseyGdcNRACP2gE/IrUMy7zpk3nsDjjM5TKUYhoBw+cPf79Tj31lvnb+8HPyWF6NcRnqPu4Nes0U05ArjKAKwD96PAE/WIYFSGyzciYEfK2qvlULHnhRF//LK7riF3/WzzbuHvJ6s3MyIlkekLQInsAJWIYFSHzF7iyZQXoovba0v/Uj1R8+qsNdPUGvZboMLXBnRrpEICkRPIET+JZh6W/dTefqnqvmSJIMQ7p58an6v3/4jN7958/phWV/pUvnnOT3Wr5lWAA4q7Qob8Q3jz6W11ZpUV5ErgUkO4IncIKhlmH51uLTtOyST+nfXnlPn/v5n/WHmoP61fXzNWfaxEHnsgwLEBtzcyepeGbwXk+fZ6r2B13Ds3hmFmt4AhFC8AROEGwZFkn6+gVurdlcp2eq9qu2uUsP/99evb63Wd9cfKrf81mGBYiNFSUFMo2RTQgyDUMrSgoiVBEAgifQT7BlWK4/N19v33+ZpmaM7VvX06eqvlWzA0xmYBkWIDbc2elaWVqg4UZPQ9LKUjaEACKJ4An041uGxZ/y6kZd/fBrOm75X3Yl0CR4lmEBYmdpYa5WX1uoVNMV0mN3qffxeqrp0uprC7W0MDfKFQLJheAJnCDQMiwdx47r/eYu7Ws5qvn5A2e4zs/PDPhInWVYgNhaWpirDbcv7vu9DRRAfceL8jO14fbFhE4gClhAHjhBsTtLuw91BpwR+5vXavVPV87RnkMdemPfEV1VME3nz8rWVQ//edC5LMMCxAd3drqevnmRdjS2qWxbgyrrWrWnqUMey1aKaWh2ToYWuDNVWpTHRCIgigiewAlKi/K0ZnN9wNef3LpPk8en6h+WnK7sCWl6v7lT3/qvKu06OLjHk2VYgPgyN3fSgGDp9doMhQEcRPAETuBbhqWqvrWv1/Pax7YMOOeRl/fqkZf3Br2O6TI0Pz+T3hMgjhE6AWcxxhPwg2VYAACIPIIn4AfLsAAAEHk8agcC8M1oXV5WI8u2Q9p+z3QZMg1DK0sLmBELAMAJ6PEEggh1GRbfUa/XVo/l1XfL3tLlP9+ke8t3aEdjm0PVAgAQ3+jxBIYQbBkWQ1L/flDf//dYtnYd7NDuQ51as7lexTOztKKER+8AgORG8ARC1H8ZlvLqRn336bfkVe+SSYEewvsez1fVt2rJqk08ggcAJDWCJxCm8upGLVtXHTBs+mN5bVmytWxdtSQRPgEASYkxnkAYapu7tLysJqzQ2Z+t3slKdc1dkSwLAICEQPAEwnDX+t4Z7iNh2bbuXF8ToYoAAEgcBE8gRNv3t6mitiWkZZWCsby2KmpbmO0OAEg6BE8gRM9UNWhMgOWU1t10ru65ak7f119akKeae5forFMm+j3fdBkq29YQlToBAIhXBE8gRBV1LToeQm/nlZ+eph9cNUd/+9ttevtAu99zLK+tyrrWSJcIAEBcY1Y7EKK9TZ1DnnPhp6ZqZWmBvv3kG6qobQl67p6mjkiVBgBAQiB4AiHwem15rOC9nfPyJutvimeoq+e4qhuODHlNj2XL67XlCvD4HgCA0YZH7UAIXC5DKWbwgDg/P1M/+sNOvXOwQz/8/FlDXjPFNAidAICkErXg+cADD+i8887T+PHjNXny5Gh9DOCYWTkTgr6+/o39enLrPt21vkYXn3mSLjvrpKDnz87JiGR5AADEvagFz56eHpWWluqWW26J1kcAjip2Z8kM0kPZdtQjSWo88pF+8sdd+tE1czV5fIrfc02XoQXuzKjUCQBAvIpa8Lz//vt1++2369Of/nS0PgJwVGlRXshreD65dZ/e/aBT9wd45G55bZUW5UWyPAAA4l5cTS7q7u5Wd3d339ft7b1L0Xg8Hnk8nliVFXW+7200f4+RFKv2Oj1nvM47dbKqG44MCqA3/GazJCnN/OTYN57YMuiY1NvbWZg3WafnjI/698DPVuhoq/DQXqGjrUJHW4UnXtornM83bHuE+/8N4YknntCyZct05MiRIc+97777dP/99w86vnbtWo0fPz4K1QEAAGAkjh49quuuu05tbW2aONH/xik+YfV4fu9739NDDz0U9Jxdu3bpjDPOCOeyfe6++27dcccdfV+3t7crLy9PS5YsGfIbSWQej0cbN27UpZdeqpQU/2MC8YlYt9cftx/UXetrNJw7NkPSQyUFuuLT0yJdll+xbqtEQluFh/YKHW0VOtoqPPHSXr4n1KEIK3j+wz/8g772ta8FPefUU08N55IDpKWlKS0tbdDxlJSUpPgBTJbvM1Ji1V5Lz5khuUwtL6uRZdshjfs0XYZMw9CK0gItLcx1oMqBYv2zlUjrlca6rRIN7RU62ip0tFV4Yt1e4Xx2WMFz6tSpmjp1atgFAaPN0sJczZs+WXeur1FFbYtMl+E3gPqOF+Vn6qGSArmz02NQrfN2NLapbFuDKupatLepUx7LVoppaFbOBBW7s1RalKe5uZNiXSYAwGFRm1y0b98+tbS0aN++fbIsS9XV1ZKkWbNmacKE4OshAonAnZ2up29e1BeyKutataepoy9kzc7J0AJ3ZlKFrLrmroBh3GPZ2nWwQ7sPdWrN5noVz8zSiiQK4wCAKAbPe+65R2vWrOn7+uyzz5Ykvfzyy7rwwguj9bGA4+bmThoQLBPpsXIklVc39g0/kBRwCILveFV9q5as2qSVMRp+AABwXtTW8XziiSdk2/ag/widGO2SNXQuW1etHssb8lqnltdWj+XVsnXVKq9ujHKFAIB4wF7tAEaktrlLy8uGN8tfkmxJy8tqVNfcFcmyAABxiOAJYETuWv/J4/Xhsmxbd66viVBFAIB4RfAEMGzb97eporYl5MfrgVheWxW1LdrR2BahygAA8SiutswEkFieqWrQGJeh4wGC58/+ep4Wf2qqMsaO0aG2bv3nlnr9+5/f93uu6TJUtq0haVYAAIBkRPAEMGwVdS0BQ6ck/e9bB/XYpvfV/pFHRe4s/ctfz9Nb+4+oorZl0LmW11ZlXWs0ywUAxBjBE8Cw7W3qDPr6y+82DTjX8toyjcCz/vc0dUSsNgBA/CF4AhgWr9eWxxp6bOcD18xVyfzpGuMy9LONu7X5/cMBz/VYdtKugwoAyYDgCWBYXC5DKaYxZPj82cbdevwvdTrvtCladsmn9Ke3D+m9D/33lKaYBqETAEYxZrUDGLZZOUNvf3u4q0d7mzr12831Otj2kS4+IyfgubNzMiJZHgAgztDjCWDYit1Z2n2o0+9yShPHjtGSs07Wm/ta1WN59dkzTtLpJ2Xo7QP+l0wyXYYWuDOjXTIAIIYIngCGrbQoT2s21/t/0ZC+OH+6fnDVHKWaLu1rOap/em6H/vKe/zGeltdWaVFeFKsFRo4xyMDIEDwBDNvc3EkqnpmlqvrWQb2e7R8d17WPbQnpOqbL0Pz8TNbwRNzZ0dimsm0Nqqhr0d6mTnksWymmoVk5E1TszlJpUR4/t0AYCJ4ARmRFSYGWrNoka9i7tUumYWhFSUEEqwJGpq65S3eur1FFbYtMlzHgxspj2dp1sEO7D3VqzeZ6Fc/M0oqSArmz02NYMZAYmFwEYETc2elaWVqg4T58NCStLOUfbcSP8upGLVm1SVX1vRsaBNoS1ne8qr5VS1ZtUnl1o2M1AomKHk8AI7a0MFeStLysRpZth7R3u+kyZBqGVpYW9L0fiLXy6kYtW1cdVv+95bVlydayddWSxM8zEAQ9ngAiYmlhrjbcvljz83tnppsBJmD4jhflZ2rD7Yv5Rxpxo7a5S8vLaoY9aMRW781XXXNXJMsCRhV6PAFEjDs7XU/fvKhvQkZlXav2NHX0TciYnZOhBe5MJmQgLt21vrfHfiQs29ad62v09M2LIlQVMLoQPAFE3NzcSQOCJUvQIN5t39+mitqWEV/H8tqqqG3RjsY2bq4APwieAKKO0Il490xVg8a4DB0PMD75i/On66el8wYc23mgTVf84rVB55ouQ2XbGgiegB8ETwBA0quoawkYOqXe1Rfaj3n02Z++Kkn65uJTdcGsKX7Ptby2Kutao1EmkPAIngCApLe3qTPo62NMQ57jXn3Y2S1JOtpzPOj5e5o6IlYbMJowqx0AkNS8XlseK/ikoglpKfrIY4V8TY9lyxvCsmJAsiF4AgCSmstlKMUMPg75pIlpOtTeHfI1U0yDsc2AHwRPAEDSm5UzIejrBdMn6+0DbSFfb3ZOxkhLAkYlgicAIOkVu7P8bnqQOT5F311yuoryM7W+an9I1zJdhha4MyNdIjAqEDwBAEmvtCjP71av15ydq8WfytbN/1Wlt/aH1uNpeW2VFuVFukRgVGBWOwAg6c3NnaTimVmqqm8dEEAff71Oj79eN+j81S/u0eoX9ww6broMzc/PZA1PIAB6PAEAkLSipECmMbIJQaZhaEVJQYQqAkYfgicAAJLc2elaWVqg4UZPQ9LK0gK5s9MjWRYwqvCoHQCAjy0tzJUkLS+rkWXbfsd9nsh0GTINQytLC/reD8Sa12vH5ZJeBE8AAPpZWpiredMn6871NaqobZHpMvwGUN/xovxMPVRCTydia0djm8q2NaiirkV7mzrlsWylmIZm5UxQsTtLpUV5cTH2mOAJAMAJ3NnpevrmRX3/mFfWtWpPU0ffP+azczK0wJ0ZN/+YI7nd8HiF/vL+kUE3SR7L1q6DHdp9qFNrNtereGaWVsT4JongCQBAAHNzJw0IlvH6+BLJ6Y/bD0qSqhuOSFLAoSG+41X1rVqyalNMh4UwuQgAgBAROhEvyqsbddf6GkmBA+eJLK+tHsurZeuqVV7dGM3yAiJ4AgAAJJDa5i4tL6tRaHFzMFu9E+jqmrsiWVZICJ4AAAAJ5K71vasujIRl27rz4x5TJxE8AQAAEsT2/W2qqG0J+fF6IJbXVkVti3Y0hrYVbKQQPAEAABLEM1UNGhOhscamy1DZtoaIXCtUBE9gFPCO8M4XAJAYKupadDxCf+dbXluVda0RuVaoWE4JSECJslAwACCy9jZ1RvR6e5o6Inq9oRA8gQRS19wVcDcVfwsF/2TpnBhWCwCIJK/XlseK7BMuj2U7uj4tj9qBBFFe3aglqzapqr73sUgoCwVf88jrjtUHAIgul8tQihnZgJhiGo6uT0vwBBJAeXWjlq2rVo/lDW+hYK9X0ie7WwAAEtusnAlDnvPVRfl68m8XhnS92TkZIy0pLARPIM6NdKFgSfqnZ3fEZKFgAEBkFbuzZA7RQ5mVnqr8KeOHvJbpMrTAnRmp0kJC8ATiXEQWClZsFgoGAERWaVHekE++Vr+4Rxc89PKQ17K8tkqL8iJVWkgInkAcS/SFggEAkTU3d5KKZw7d6zkU02WoeGaW4yugMKsdiGO+hYIDrdm27qZzde6pUwYc++P2g/r2k28MOte3UDDLLAFAYltRUqAlqzaN6BqmYWhFSUGEKgodwROIY6EsFLx26z6t2ri77+vu45bf82KxUDAAIPLc2elaWVqgu8reHNb7DUkrSwvkzk6PbGEhIHgCcSyUhYKPeSx92Nkd0vWcXigYABAdSwtzJa8lNbzZ+9jdf5/DAKbLkGkYWlla0Pv+GGCMJxCnorlQMAAg8V3x6WmSpMK8yZIUcNyn73hRfqY23L44ZqFToscTiFu+hYIjGT6dXigYABB9a24s1rtNR1W2rUGVda3a09TRt5Xy7JwMLXBnxs1WygRPII7NypmgXQcj93jc6YWCAQDOmJs7aUCwdHIbzHDwqB2IY6EsFByqWCwUDACIjXgMnRLBE4hroSwUHKpYLBQMAEB/PGoH4phvoeCq+la/AfTax7aEdB3TZah4hvMLBQMA0B89nkCcW1FSINMY4Q4Vis1CwQAA9EfwBOKcb6HgkUTPH31hbkwWCgYAoD8etQMJwLfm2vKyGlm2HdK4T9NlKNVlSLL61noDACCW6PEEEsTSwlxtuH2x5uf3zkwPZaHg524937H6AAAYCj2eQAJxZ6fr6ZsXaUdjW0gLBXs8Hu2IddEAAHyM4AkkoERZKBgAgP541A6MAoROAEAiIHgCAADAEQRPAAAAOILgCQAAAEcQPAEAAOAIgicAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBE8AAAA4guAJAAAARxA8AQAA4AiCJwAAABxB8AQAAIAjxsS6gGBs25Yktbe3x7iS6PJ4PDp69Kja29uVkpIS63LiHu0VOtoqdLRVeGiv0NFWoaOtwhMv7eXLab7cFkxcB8+Ojg5JUl5eXowrAQAAQDAdHR2aNGlS0HMMO5R4GiNer1cHDhxQRkaGDMOIdTlR097erry8PDU0NGjixImxLifu0V6ho61CR1uFh/YKHW0VOtoqPPHSXrZtq6OjQ6eccopcruCjOOO6x9Plcmn69OmxLsMxEydO5BctDLRX6Gir0NFW4aG9QkdbhY62Ck88tNdQPZ0+TC4CAACAIwieAAAAcATBMw6kpaXp3nvvVVpaWqxLSQi0V+hoq9DRVuGhvUJHW4WOtgpPIrZXXE8uAgAAwOhBjycAAAAcQfAEAACAIwieAAAAcATBEwAAAI4geAIAAMARBM849PnPf14zZszQ2LFjNW3aNH3lK1/RgQMHYl1W3Kmrq9M3vvENzZw5U+PGjdNpp52me++9Vz09PbEuLS498MADOu+88zR+/HhNnjw51uXEnUceeURut1tjx47VwoULVVFREeuS4tKmTZt09dVX65RTTpFhGHruuediXVLc+slPfqIFCxYoIyNDOTk5uuaaa/Tuu+/Guqy49Mtf/lIFBQV9O/AsWrRIzz//fKzLSggPPvigDMPQsmXLYl1KSAieceiiiy7S008/rXfffVfr16/Xe++9py9+8YuxLivuvPPOO/J6vXr00Uf19ttva9WqVfrVr36l73//+7EuLS719PSotLRUt9xyS6xLiTtPPfWU7rjjDt1777164403NG/ePF122WVqamqKdWlxp6urS/PmzdMjjzwS61Li3quvvqpbb71VW7Zs0caNG+XxeLRkyRJ1dXXFurS4M336dD344IOqqqrStm3bdPHFF2vp0qV6++23Y11aXKusrNSjjz6qgoKCWJcSOhtxr7y83DYMw+7p6Yl1KXFvxYoV9syZM2NdRlx7/PHH7UmTJsW6jLhSXFxs33rrrX1fW5Zln3LKKfZPfvKTGFYV/yTZzz77bKzLSBhNTU22JPvVV1+NdSkJITMz0/71r38d6zLiVkdHhz179mx748aN9mc+8xn77//+72NdUkjo8YxzLS0tevLJJ3XeeecpJSUl1uXEvba2NmVlZcW6DCSQnp4eVVVV6ZJLLuk75nK5dMkll2jz5s0xrAyjTVtbmyTxd9QQLMvSunXr1NXVpUWLFsW6nLh166236sorrxzwd1ciIHjGqbvuukvp6emaMmWK9u3bp/Ly8liXFPf27t2rhx9+WDfffHOsS0ECaW5ulmVZOumkkwYcP+mkk/TBBx/EqCqMNl6vV8uWLdP555+vuXPnxrqcuLR9+3ZNmDBBaWlp+ta3vqVnn31Wc+bMiXVZcWndunV644039JOf/CTWpYSN4OmQ733vezIMI+h/77zzTt/5y5cv15tvvqkNGzbINE199atflZ0ku5uG21aS1NjYqM997nMqLS3VN7/5zRhV7rzhtBUA5916663asWOH1q1bF+tS4tbpp5+u6upqbd26VbfccotuuOEG7dy5M9ZlxZ2Ghgb9/d//vZ588kmNHTs21uWEjb3aHfLhhx/q8OHDQc859dRTlZqaOuj4/v37lZeXp7/85S9J8dgh3LY6cOCALrzwQp177rl64okn5HIlz/3UcH6unnjiCS1btkxHjhyJcnWJoaenR+PHj9czzzyja665pu/4DTfcoCNHjvC0IQjDMPTss88OaDcMdtttt6m8vFybNm3SzJkzY11Owrjkkkt02mmn6dFHH411KXHlueee0xe+8AWZptl3zLIsGYYhl8ul7u7uAa/FmzGxLiBZTJ06VVOnTh3We71erySpu7s7kiXFrXDaqrGxURdddJHmz5+vxx9/PKlCpzSynyv0Sk1N1fz58/XSSy/1BSiv16uXXnpJt912W2yLQ0KzbVvf+c539Oyzz+qVV14hdIbJ6/Umzb974fjsZz+r7du3Dzh244036owzztBdd90V16FTInjGna1bt6qyslIXXHCBMjMz9d577+kHP/iBTjvttKTo7QxHY2OjLrzwQuXn5+unP/2pPvzww77XTj755BhWFp/27dunlpYW7du3T5Zlqbq6WpI0a9YsTZgwIbbFxdgdd9yhG264QUVFRSouLtbq1avV1dWlG2+8MdalxZ3Ozk7t3bu37+va2lpVV1crKytLM2bMiGFl8efWW2/V2rVrVV5eroyMjL4xw5MmTdK4ceNiXF18ufvuu3X55ZdrxowZ6ujo0Nq1a/XKK6/oT3/6U6xLizsZGRmDxgn75oQkxPjh2E6qx4lqamrsiy66yM7KyrLT0tJst9ttf+tb37L3798f69LizuOPP25L8vsfBrvhhhv8ttXLL78c69LiwsMPP2zPmDHDTk1NtYuLi+0tW7bEuqS49PLLL/v9ObrhhhtiXVrcCfT30+OPPx7r0uLO17/+dTs/P99OTU21p06dan/2s5+1N2zYEOuyEkYiLafEGE8AAAA4IrkGxAEAACBmCJ4AAABwBMETAAAAjiB4AgAAwBEETwAAADiC4AkAAABHEDwBAADgCIInAAAAHEHwBAAAgCMIngAAAHAEwRMAAACO+P+XBTl86cQrjAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's sample from the model:\n",
        "\n",
        "# to create a new random number generator with a specific seed (2147483647 + 10)\n",
        "# it will be used to ensure reproducibility in the sampling process\n",
        "g = torch.Generator().manual_seed(2147483647 + 10)\n",
        "\n",
        "# the loop that iterates 50 times to generate 50 text sequences\n",
        "for _ in range(50):\n",
        "\n",
        "    # to initialize an empty list to store the sampled text sequence\n",
        "    out = []\n",
        "    # to initialize the context with a list of zeros\n",
        "    context = [0] * block_size\n",
        "    # to start an infinite loop to sample text until a termination condition is met\n",
        "    while True:\n",
        "      # to retrieve the embeddings for the current context from the embedding matrix C\n",
        "      emb = C[torch.tensor([context])] # (1,block_size,d)\n",
        "      # to compute the activations of the HIDDEN layer neurons using the embeddings, weight W1, and bias b1\n",
        "      h = torch.tanh(emb.view(1, -1) @ W1 + b1)\n",
        "      # to calculate the logits by multiplying the HIDDEN layer activations with weight W2 and adding bias b2\n",
        "      logits = h @ W2 + b2\n",
        "      # to applie the softmax function along dimension 1 (rows) to convert the logits into probabilities\n",
        "      probs = F.softmax(logits, dim=1)\n",
        "      # to sample a single character (index) from the probability distribution defined by probs using the multinomial function to represent the next character in the sequence\n",
        "      ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
        "      # to update the context by removing the first element and appending the sampled index to the end to prepare the context for the next iteration of sampling\n",
        "      context = context[1:] + [ix]\n",
        "      # to append the sampled index to the list of sampled indices\n",
        "      out.append(ix)\n",
        "      # the condition to check if the sampled index is the termination token (0) to stop the sampling process\n",
        "      if ix == 0:\n",
        "        break\n",
        "    # to print the sampled text sequence\n",
        "    # to convert the sampled indices (out) back into characters using the itos list and see the generated results :)\n",
        "    print(''.join(itos[i] for i in out))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DnlBXi1Hn4TP",
        "outputId": "4a9715aa-3b47-41ab-eea8-c56c195e9597"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "конс.\n",
            "дар.\n",
            "борив.\n",
            "клаас.\n",
            "кадвалентий.\n",
            "басий.\n",
            "мордехай.\n",
            "евдоким.\n",
            "виталишерон.\n",
            "харри.\n",
            "стасий.\n",
            "валлюстислав.\n",
            "еренц.\n",
            "саллюстантоном.\n",
            "атанит.\n",
            "геласир.\n",
            "дональвестислав.\n",
            "рамазарий.\n",
            "лазарио.\n",
            "тендзин.\n",
            "уман.\n",
            "азат.\n",
            "улдис.\n",
            "модестофор.\n",
            "олик.\n",
            "мефодорж.\n",
            "артур.\n",
            "евриил.\n",
            "амфилий.\n",
            "мэлор.\n",
            "никий.\n",
            "матет.\n",
            "эрас.\n",
            "солод.\n",
            "вито.\n",
            "кас.\n",
            "гейдар.\n",
            "бурхард.\n",
            "абид.\n",
            "олег.\n",
            "ахим.\n",
            "стефанор.\n",
            "илат.\n",
            "сон.\n",
            "стислав.\n",
            "безсон.\n",
            "айдар.\n",
            "радислам.\n",
            "адан.\n",
            "анг.\n"
          ]
        }
      ]
    }
  ]
}