diff --git "a/a2_Q9_LSTM_Japanes_.ipynb" "b/a2_Q9_LSTM_Japanes_.ipynb"
new file mode 100644--- /dev/null
+++ "b/a2_Q9_LSTM_Japanes_.ipynb"
@@ -0,0 +1,708 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "g_3ZxaoEtJnl",
+        "outputId": "0445ad26-8249-412d-cd0e-ec5e5c1d82c6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting sacrebleu\n",
+            "  Downloading sacrebleu-2.4.3-py3-none-any.whl.metadata (51 kB)\n",
+            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/51.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m51.8/51.8 kB\u001b[0m \u001b[31m4.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hCollecting portalocker (from sacrebleu)\n",
+            "  Downloading portalocker-2.10.1-py3-none-any.whl.metadata (8.5 kB)\n",
+            "Requirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (2024.9.11)\n",
+            "Requirement already satisfied: tabulate>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (0.9.0)\n",
+            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (1.26.4)\n",
+            "Collecting colorama (from sacrebleu)\n",
+            "  Downloading colorama-0.4.6-py2.py3-none-any.whl.metadata (17 kB)\n",
+            "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (5.3.0)\n",
+            "Downloading sacrebleu-2.4.3-py3-none-any.whl (103 kB)\n",
+            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m104.0/104.0 kB\u001b[0m \u001b[31m10.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hDownloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n",
+            "Downloading portalocker-2.10.1-py3-none-any.whl (18 kB)\n",
+            "Installing collected packages: portalocker, colorama, sacrebleu\n",
+            "Successfully installed colorama-0.4.6 portalocker-2.10.1 sacrebleu-2.4.3\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install sacrebleu\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "from torch.utils.data import DataLoader, Dataset\n",
+        "import numpy as np\n",
+        "import sacrebleu\n",
+        "import json\n",
+        "import matplotlib.pyplot as plt\n",
+        "import csv\n",
+        "import re\n",
+        "\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import json\n",
+        "import re\n",
+        "import torch\n",
+        "\n",
+        "# Function to clean invalid escape sequences\n",
+        "def clean_json(file_path):\n",
+        "    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:\n",
+        "        content = f.read()\n",
+        "    # Remove invalid \\uXXXX sequences\n",
+        "    content = re.sub(r'\\\\u[0-9A-Fa-f]{0,3}(?![0-9A-Fa-f])', '', content)\n",
+        "    return content\n",
+        "\n",
+        "# Load and clean JSON\n",
+        "file_path = '/content/Japanes.json'\n",
+        "try:\n",
+        "    cleaned_content = clean_json(file_path)\n",
+        "    data = json.loads(cleaned_content)\n",
+        "    print(\"JSON loaded successfully.\")\n",
+        "except json.JSONDecodeError as e:\n",
+        "    print(f\"Error decoding JSON: {e}\")\n",
+        "\n",
+        "# Extract sentences\n",
+        "en_sentences = [entry['input'] for entry in data[:1000]]\n",
+        "ja_sentences = [entry['output'] for entry in data[:1000]]  # Lowercase 'bu_sentences'\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sduCxJLLSBv3",
+        "outputId": "6eac95e8-fc62-458f-cb22-eb9c1f5a54a4"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "JSON loaded successfully.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "# Hyperparameters\n",
+        "MAX_LEN = 60\n",
+        "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "VOCAB_SIZE = 200000\n",
+        "EMBEDDING_DIM = 256\n",
+        "HIDDEN_DIM = 512\n",
+        "BATCH_SIZE = 32\n",
+        "NUM_EPOCHS = 20\n",
+        "\n",
+        "tokenizer = lambda x: x.split()\n",
+        "\n",
+        "# Build vocabulary\n",
+        "def build_vocab(sentences):\n",
+        "    counter = {}\n",
+        "    for sentence in sentences:\n",
+        "        for token in tokenizer(sentence):\n",
+        "            counter[token] = counter.get(token, 0) + 1\n",
+        "    return {word: idx + 4 for idx, (word, _) in enumerate(counter.items())}\n",
+        "\n",
+        "en_vocab = {'<pad>': 0, '<s>': 1, '</s>': 2, '<unk>': 3, **build_vocab(en_sentences)}\n",
+        "ja_vocab = {'<pad>': 0, '<s>': 1, '</s>': 2, '<unk>': 3, **build_vocab(ja_sentences)}  # Lowercase 'ja_sentences'\n",
+        "\n",
+        "# Convert sentences to tensors\n",
+        "def sentence_to_tensor(sentence, vocab, max_len=MAX_LEN):\n",
+        "    tokens = [vocab.get(word, vocab['<unk>']) for word in tokenizer(sentence)]\n",
+        "    return torch.tensor([vocab['<s>']] + tokens + [vocab['</s>']] + [vocab['<pad>']] * (max_len - len(tokens) - 2))[:max_len]\n",
+        "\n",
+        "en_tensor_sentences = [sentence_to_tensor(s, en_vocab) for s in en_sentences]\n",
+        "ja_tensor_sentences = [sentence_to_tensor(s, ja_vocab) for s in ja_sentences]  # Lowercase 'ja_tensor_sentences'\n",
+        "\n",
+        "# Split into training and validation sets\n",
+        "train_size = int(len(en_tensor_sentences) * 0.8)\n",
+        "train_en, val_en = en_tensor_sentences[:train_size], en_tensor_sentences[train_size:]\n",
+        "train_ja, val_ja = ja_tensor_sentences[:train_size], ja_tensor_sentences[train_size:]  # Lowercase 'train_bu' and 'val_bu'\n"
+      ],
+      "metadata": {
+        "id": "n4QrGouxtO5h"
+      },
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def print_sample_data(en_sentences, bu_sentences):\n",
+        "    for i in range(4):\n",
+        "        en_sample, bu_sample = en_sentences[i], bu_sentences[i]\n",
+        "        print(f\"EN to Ja\\n<s>\\n<en> {en_sample} </en>\\n<ja> {bu_sample} </ja>\\n</s>\")\n",
+        "        print(f\"Ja to EN\\n<s>\\n<ja> {bu_sample} </ja>\\n<en> {en_sample} </en>\\n</s>\\n\")\n",
+        "\n",
+        "# Call the function with English and Japanes sentences\n",
+        "print_sample_data(en_sentences, bu_sentences)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "EUJS1TsltO82",
+        "outputId": "89e3dd07-5ecb-4894-f728-901f6cbb7779"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "EN to Ja\n",
+            "<s>\n",
+            "<en> Give three tips for staying healthy. </en>\n",
+            "<ja> 健康を維持するための3つのヒントを教えてください。 </ja>\n",
+            "</s>\n",
+            "Ja to EN\n",
+            "<s>\n",
+            "<ja> 健康を維持するための3つのヒントを教えてください。 </ja>\n",
+            "<en> Give three tips for staying healthy. </en>\n",
+            "</s>\n",
+            "\n",
+            "EN to Ja\n",
+            "<s>\n",
+            "<en> 1. Eat a balanced and nutritious diet: Make sure your meals are inclusive of a variety of fruits and vegetables, lean protein, whole grains, and healthy fats. This helps to provide your body with the essential nutrients to function at its best and can help prevent chronic diseases.\n",
+            "\n",
+            "2. Engage in regular physical activity: Exercise is crucial for maintaining strong bones, muscles, and cardiovascular health. Aim for at least 150 minutes of moderate aerobic exercise or 75 minutes of vigorous exercise each week.\n",
+            "\n",
+            "3. Get enough sleep: Getting enough quality sleep is crucial for physical and mental well-being. It helps to regulate mood, improve cognitive function, and supports healthy growth and immune function. Aim for 7-9 hours of sleep each night. </en>\n",
+            "<ja>  1. バランスの取れた栄養価の高い食事を摂る: 食事にはさまざまな果物や野菜、脂肪分の少ないタンパク質、全粒穀物、健康的な脂肪が含まれていることを確認してください。これは体が最高の状態で機能するために必須の栄養素を提供するのに役立ち、慢性疾患の予防に役立ちます。 2. 定期的な身体活動に参加する: 強い骨、筋肉、心臓血管の健康を維持するには、運動が不可欠です。毎週少なくとも 150 分間の中程度の有酸素運動、または 75 分間の激しい運動を目標にしましょう。 3. 十分な睡眠をとる：質の高い睡眠を十分にとることは、身体的および精神的な健康にと���て非常に重要です。気分を調整し、認知機能を改善し、健康な成長と免疫機能をサポートします。毎晩7〜9時間の睡眠を目指しましょう。 </ja>\n",
+            "</s>\n",
+            "Ja to EN\n",
+            "<s>\n",
+            "<ja>  1. バランスの取れた栄養価の高い食事を摂る: 食事にはさまざまな果物や野菜、脂肪分の少ないタンパク質、全粒穀物、健康的な脂肪が含まれていることを確認してください。これは体が最高の状態で機能するために必須の栄養素を提供するのに役立ち、慢性疾患の予防に役立ちます。 2. 定期的な身体活動に参加する: 強い骨、筋肉、心臓血管の健康を維持するには、運動が不可欠です。毎週少なくとも 150 分間の中程度の有酸素運動、または 75 分間の激しい運動を目標にしましょう。 3. 十分な睡眠をとる：質の高い睡眠を十分にとることは、身体的および精神的な健康にとって非常に重要です。気分を調整し、認知機能を改善し、健康な成長と免疫機能をサポートします。毎晩7〜9時間の睡眠を目指しましょう。 </ja>\n",
+            "<en> 1. Eat a balanced and nutritious diet: Make sure your meals are inclusive of a variety of fruits and vegetables, lean protein, whole grains, and healthy fats. This helps to provide your body with the essential nutrients to function at its best and can help prevent chronic diseases.\n",
+            "\n",
+            "2. Engage in regular physical activity: Exercise is crucial for maintaining strong bones, muscles, and cardiovascular health. Aim for at least 150 minutes of moderate aerobic exercise or 75 minutes of vigorous exercise each week.\n",
+            "\n",
+            "3. Get enough sleep: Getting enough quality sleep is crucial for physical and mental well-being. It helps to regulate mood, improve cognitive function, and supports healthy growth and immune function. Aim for 7-9 hours of sleep each night. </en>\n",
+            "</s>\n",
+            "\n",
+            "EN to Ja\n",
+            "<s>\n",
+            "<en> What are the three primary colors? </en>\n",
+            "<ja> 三原色とは何ですか? </ja>\n",
+            "</s>\n",
+            "Ja to EN\n",
+            "<s>\n",
+            "<ja> 三原色とは何ですか? </ja>\n",
+            "<en> What are the three primary colors? </en>\n",
+            "</s>\n",
+            "\n",
+            "EN to Ja\n",
+            "<s>\n",
+            "<en> The three primary colors are red, blue, and yellow. These colors are called primary because they cannot be created by mixing other colors and all other colors can be made by combining them in various proportions. In the additive color system, used for light, the primary colors are red, green, and blue (RGB). </en>\n",
+            "<ja> 三原色は赤、青、黄です。これらの色は、他の色を混ぜることによって作成することができず、他の色はすべてさまざまな割合で組み合わせることで作成できるため、原色と呼ばれます。光に使用される加法混色システムでは、原色は赤、緑、青 (RGB) です。 </ja>\n",
+            "</s>\n",
+            "Ja to EN\n",
+            "<s>\n",
+            "<ja> 三原色は赤、青、黄です。これらの色は、他の色を混ぜることによって作成することができず、他の色はすべてさまざまな割合で組み合わせることで作成できるため、原色と呼ばれます。光に使用される加法混色システムでは、原色は赤、緑、青 (RGB) です。 </ja>\n",
+            "<en> The three primary colors are red, blue, and yellow. These colors are called primary because they cannot be created by mixing other colors and all other colors can be made by combining them in various proportions. In the additive color system, used for light, the primary colors are red, green, and blue (RGB). </en>\n",
+            "</s>\n",
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class TranslationDataset(Dataset):\n",
+        "    def __init__(self, en, bu):\n",
+        "        self.en, self.te = en, bu\n",
+        "    def __len__(self):\n",
+        "        return len(self.en)\n",
+        "    def __getitem__(self, idx):\n",
+        "        return self.en[idx], self.te[idx]\n",
+        "\n",
+        "def collate_fn(batch):\n",
+        "    en_batch, te_batch = zip(*batch)\n",
+        "    return torch.stack(en_batch, dim=0), torch.stack(te_batch, dim=0)\n",
+        "\n",
+        "train_loader = DataLoader(TranslationDataset(train_en, train_ja), batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)\n",
+        "val_loader = DataLoader(TranslationDataset(val_en, val_ja), batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n"
+      ],
+      "metadata": {
+        "id": "wRoVMiaStO_i"
+      },
+      "execution_count": 29,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "\n",
+        "# LSTM-based Model for Translation with more layers\n",
+        "class LSTMTranslationModel(nn.Module):\n",
+        "    def __init__(self, input_dim, output_dim, embed_dim, hidden_dim, num_layers=2):\n",
+        "        super(LSTMTranslationModel, self).__init__()\n",
+        "        self.embedding = nn.Embedding(input_dim, embed_dim)\n",
+        "        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers=num_layers, batch_first=True)\n",
+        "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
+        "\n",
+        "    def forward(self, x, te_input=None):\n",
+        "        embedded = self.embedding(x)\n",
+        "        lstm_out, (hidden, cell) = self.lstm(embedded)\n",
+        "        output = self.fc(lstm_out)\n",
+        "        return output\n",
+        "\n",
+        "# Initialize Model\n",
+        "model = LSTMTranslationModel(input_dim=VOCAB_SIZE, output_dim=len(ja_vocab), embed_dim=EMBEDDING_DIM, hidden_dim=HIDDEN_DIM).to(DEVICE)\n",
+        "\n",
+        "\n",
+        "def custom_model_summary(model):\n",
+        "    # Extract model details\n",
+        "    model_summary = []\n",
+        "    for name, param in model.named_parameters():\n",
+        "        layer_info = {\n",
+        "            \"Layer Name\": name,\n",
+        "            \"Layer Type\": type(param).__name__,\n",
+        "            \"Output Shape\": list(param.size()),\n",
+        "            \"Parameters\": param.numel()\n",
+        "        }\n",
+        "        model_summary.append(layer_info)\n",
+        "\n",
+        "    # Display as a DataFrame table\n",
+        "    df_summary = pd.DataFrame(model_summary)\n",
+        "    print(df_summary.to_markdown(index=False))\n",
+        "\n",
+        "custom_model_summary(model)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "O_OdhdeftPU5",
+        "outputId": "6fefa9b9-578b-4c43-87c4-3fac5b78e555"
+      },
+      "execution_count": 30,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "| Layer Name        | Layer Type   | Output Shape   |   Parameters |\n",
+            "|:------------------|:-------------|:---------------|-------------:|\n",
+            "| embedding.weight  | Parameter    | [200000, 256]  |     51200000 |\n",
+            "| lstm.weight_ih_l0 | Parameter    | [2048, 256]    |       524288 |\n",
+            "| lstm.weight_hh_l0 | Parameter    | [2048, 512]    |      1048576 |\n",
+            "| lstm.bias_ih_l0   | Parameter    | [2048]         |         2048 |\n",
+            "| lstm.bias_hh_l0   | Parameter    | [2048]         |         2048 |\n",
+            "| lstm.weight_ih_l1 | Parameter    | [2048, 512]    |      1048576 |\n",
+            "| lstm.weight_hh_l1 | Parameter    | [2048, 512]    |      1048576 |\n",
+            "| lstm.bias_ih_l1   | Parameter    | [2048]         |         2048 |\n",
+            "| lstm.bias_hh_l1   | Parameter    | [2048]         |         2048 |\n",
+            "| fc.weight         | Parameter    | [3529, 512]    |      1806848 |\n",
+            "| fc.bias           | Parameter    | [3529]         |         3529 |\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Define Optimizer and Loss Function\n",
+        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
+        "criterion = nn.CrossEntropyLoss(ignore_index=ja_vocab['<pad>'])\n",
+        "\n",
+        "def train_model(model, train_loader, val_loader, optimizer, criterion, epochs=10):\n",
+        "    train_losses, val_losses = [], []\n",
+        "    for epoch in range(epochs):\n",
+        "        model.train()\n",
+        "        train_loss = 0\n",
+        "        for en_batch, te_batch in train_loader:\n",
+        "            en_batch, te_batch = en_batch.to(DEVICE), te_batch.to(DEVICE)\n",
+        "            te_batch = te_batch.long()\n",
+        "            optimizer.zero_grad()\n",
+        "            output = model(en_batch)\n",
+        "            loss = criterion(output.reshape(-1, output.shape[-1]), te_batch.reshape(-1))\n",
+        "            loss.backward()\n",
+        "            optimizer.step()\n",
+        "            train_loss += loss.item()\n",
+        "        train_losses.append(train_loss / len(train_loader))\n",
+        "\n",
+        "        model.eval()\n",
+        "        val_loss = 0\n",
+        "        with torch.no_grad():\n",
+        "            for en_batch, te_batch in val_loader:\n",
+        "                en_batch, te_batch = en_batch.to(DEVICE), te_batch.to(DEVICE)\n",
+        "                output = model(en_batch)\n",
+        "                loss = criterion(output.reshape(-1, output.shape[-1]), te_batch.reshape(-1))\n",
+        "                val_loss += loss.item()\n",
+        "        val_losses.append(val_loss / len(val_loader))\n",
+        "        print(f'Epoch {epoch+1}/{epochs}, Train Loss: {train_losses[-1]}, Val Loss: {val_losses[-1]}')\n",
+        "\n",
+        "    return train_losses, val_losses\n",
+        "\n",
+        "train_losses, val_losses = train_model(model, train_loader, val_loader, optimizer, criterion, epochs=NUM_EPOCHS)\n",
+        "\n",
+        "torch.save(model.state_dict(), 'lstm_translation_model.pth')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d2z7r_1btPXb",
+        "outputId": "584a871c-7bd2-46a6-d7b4-79ea1476ab1d"
+      },
+      "execution_count": 31,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/20, Train Loss: 6.669412956237793, Val Loss: 5.717513118471418\n",
+            "Epoch 2/20, Train Loss: 5.507481346130371, Val Loss: 5.990183251244681\n",
+            "Epoch 3/20, Train Loss: 5.257644233703613, Val Loss: 6.248048169272287\n",
+            "Epoch 4/20, Train Loss: 5.053595180511475, Val Loss: 6.469724587031773\n",
+            "Epoch 5/20, Train Loss: 4.872624206542969, Val Loss: 6.725061961582729\n",
+            "Epoch 6/20, Train Loss: 4.583933629989624, Val Loss: 6.803114891052246\n",
+            "Epoch 7/20, Train Loss: 4.354597215652466, Val Loss: 6.972484316144671\n",
+            "Epoch 8/20, Train Loss: 4.0424451160430905, Val Loss: 7.086231981004987\n",
+            "Epoch 9/20, Train Loss: 3.6922006034851074, Val Loss: 7.280972412654331\n",
+            "Epoch 10/20, Train Loss: 3.3243370628356934, Val Loss: 7.31565032686506\n",
+            "Epoch 11/20, Train Loss: 2.9697946071624757, Val Loss: 7.536340441022601\n",
+            "Epoch 12/20, Train Loss: 2.5779794311523436, Val Loss: 7.599312577928815\n",
+            "Epoch 13/20, Train Loss: 2.2219763135910036, Val Loss: 7.713373456682477\n",
+            "Epoch 14/20, Train Loss: 1.9110792970657349, Val Loss: 7.858387606484549\n",
+            "Epoch 15/20, Train Loss: 1.6369098329544067, Val Loss: 7.993720190865653\n",
+            "Epoch 16/20, Train Loss: 1.4096700048446655, Val Loss: 8.061748845236641\n",
+            "Epoch 17/20, Train Loss: 1.2724453282356263, Val Loss: 8.120101247514997\n",
+            "Epoch 18/20, Train Loss: 1.1353174948692322, Val Loss: 8.183435099465507\n",
+            "Epoch 19/20, Train Loss: 1.039564082622528, Val Loss: 8.27905866077968\n",
+            "Epoch 20/20, Train Loss: 0.9702791261672974, Val Loss: 8.327078546796526\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Plotting Losses\n",
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.plot(range(1, NUM_EPOCHS + 1), train_losses, label='Training Loss')\n",
+        "plt.plot(range(1, NUM_EPOCHS + 1), val_losses, label='Validation Loss')\n",
+        "plt.xlabel('Epochs')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.title('LTSM-Training and Validation Losses')\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 487
+        },
+        "id": "lQZ58WXMtPa5",
+        "outputId": "93c29042-f1f7-45fd-a1fe-f5e9aada3a72"
+      },
+      "execution_count": 32,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAHWCAYAAACxAYILAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB88klEQVR4nO3dd1hT9/4H8HfCCDvsvQQRBPcedVtnnbS21rZirdZRW9vb+7P2to72ttZrt73XbmzrarWOtk607r1woSiCIFtmmAkk5/dHIBDZCISQ9+t58kDOOTn5JB4hb77f8zkiQRAEEBERERERGQixrgsgIiIiIiJqSQxBRERERERkUBiCiIiIiIjIoDAEERERERGRQWEIIiIiIiIig8IQREREREREBoUhiIiIiIiIDApDEBERERERGRSGICIiIiIiMigMQURErdC9e/cgEomwfv36Rj1eJBJhxYoVTVpTaxMWFgZfX98Wf94VK1ZAJBJpLfP19UVYWFidj12/fj1EIhHu3bvXZPU86rFCRGSIGIKISGfKPxBeuHBBa7lIJKrX7ciRIwCABw8e4LXXXkNQUBDMzc3h7OyMPn36YMmSJcjPz9fsNywsDCKRCDY2NigqKqpSz507dzT7/vjjj6utufwDcF23oUOHNtn7RI2Tnp4OY2NjPPfcczVuk5eXB3Nzc0ydOrUFK2ucTZs24fPPP9d1GVrCwsJgZWWl6zKIiBrMWNcFEBE97JdfftG6//PPPyMiIqLK8o4dOyIrKwu9evWCTCbDiy++iKCgIGRmZuLq1atYt24d5s+fr/UhzdjYGIWFhfjzzz8xbdo0rf1t3LgRZmZmKC4urrG2qVOnon379pr7+fn5mD9/PqZMmaL1QdrFxaVRr72cj48PioqKYGJi0qjHFxUVwdjYsH/EOzs74/HHH8euXbtQWFgICwuLKtts374dxcXFtQal+oiOjoZY3Lx/V9y0aROuX7+OxYsXay1/1GOFiMgQGfZvSCJqlR7+QHrmzBlERERU+0F1zZo1SEhIwMmTJzFgwACtdTKZDKamplrLJBIJBg4ciM2bN1cJQZs2bcL48ePx+++/11hbly5d0KVLF839jIwMzJ8/H126dKn1g3RxcTFMTU3r/UFZJBLBzMysXttW51Ee25bMmDED+/btwx9//IFnnnmmyvpNmzZBKpVi/Pjxj/Q8EonkkR7/KB71WCEiMkScDkdEeu3u3bswMjJCv379qqyzsbGp9sPhs88+i7179yInJ0ez7Pz587hz5w6effbZR67pyJEjEIlE2LJlC9555x14eHjAwsICMpkMWVlZePPNN9G5c2dYWVnBxsYGY8eOxZUrV7T2Ud15HuVTj5KSkjB58mRYWVnByckJb775JpRKpdbjHz4nqHwaX0xMDMLCwmBrawupVIpZs2ahsLBQ67FFRUV49dVX4ejoCGtra0ycOBFJSUn1Os9IoVBg2bJl6NmzJ6RSKSwtLTFo0CAcPny42tf38ccf49tvv4W/vz8kEgl69+6N8+fPV9nvzp070alTJ5iZmaFTp07YsWNHrXWUmzJlCiwtLbFp06Yq69LT03Ho0CE8+eSTkEgkOH78OJ566il4e3tDIpHAy8sLr7/+erVTJx9W3TlBN27cwPDhw2Fubg5PT0/8+9//hkqlqvLYXbt2Yfz48XB3d4dEIoG/vz/ef/99rX/ToUOHYvfu3YiPj9dMuSw/H6qmc4L+/vtvDBo0CJaWlrC1tcWkSZNw8+ZNrW0aclw8iq1bt6Jnz54wNzeHo6MjnnvuOSQlJWltk5qailmzZsHT0xMSiQRubm6YNGmS1vlTFy5cwOjRo+Ho6Ahzc3O0a9cOL774otZ+VCoVPv/8c4SEhMDMzAwuLi54+eWXkZ2drbVdffZFRG0XR4KISK/5+PhAqVTil19+wcyZM+v1mKlTp2LevHnYvn275kPPpk2bEBQUhB49ejRZbe+//z5MTU3x5ptvQi6Xw9TUFFFRUdi5cyeeeuoptGvXDmlpafjmm28wZMgQREVFwd3dvdZ9KpVKjB49Gn379sXHH3+MgwcP4pNPPoG/vz/mz59fZ03Tpk1Du3btsGrVKly6dAnff/89nJ2dsXr1as02YWFh+O233/D888+jX79+OHr0aL1HSmQyGb7//ntMnz4dc+bMQV5eHn744QeMHj0a586dQ7du3bS237RpE/Ly8vDyyy9DJBLhP//5D6ZOnYrY2FjN9K4DBw4gNDQUwcHBWLVqFTIzMzUflutiaWmJSZMmYdu2bcjKyoK9vb1m3a+//gqlUokZM2YAUH9QLywsxPz58+Hg4IBz585h7dq1SExMxNatW+v1+sulpqZi2LBhKC0txVtvvQVLS0t8++23MDc3r7Lt+vXrYWVlhTfeeANWVlb4+++/sWzZMshkMqxZswYA8K9//Qu5ublITEzEZ599BgC1notz8OBBjB07Fn5+flixYgWKioqwdu1aDBw4EJcuXarSUKI+x0VjrV+/HrNmzULv3r2xatUqpKWl4YsvvsDJkydx+fJl2NraAgBCQ0Nx48YNLFq0CL6+vkhPT0dERAQSEhI090eNGgUnJye89dZbsLW1xb1797B9+3at53v55Zc1z/nqq68iLi4OX331FS5fvoyTJ0/CxMSk3vsiojZMICLSkfDwcAGAcP78+Vq3W7hwoVDTj6vU1FTByclJACAEBQUJ8+bNEzZt2iTk5ORU2XbmzJmCpaWlIAiC8OSTTwojRowQBEEQlEql4OrqKqxcuVKIi4sTAAhr1qyp12t48OCBAEBYvny5Ztnhw4cFAIKfn59QWFiotX1xcbGgVCq1lsXFxQkSiUR47733tJYBEMLDw7XqB6C1nSAIQvfu3YWePXtqLXu4puXLlwsAhBdffFFruylTpggODg6a+xcvXhQACIsXL9baLiwsrMo+q1NaWirI5XKtZdnZ2YKLi4vWc5e/PgcHByErK0uzfNeuXQIA4c8//9Qs69atm+Dm5qb1b3rgwAEBgODj41NrPYIgCLt37xYACN98843W8n79+gkeHh6af4+H/60EQRBWrVoliEQiIT4+XrOs/L2szMfHR5g5c6bm/uLFiwUAwtmzZzXL0tPTBalUKgAQ4uLiNMure96XX35ZsLCwEIqLizXLxo8fX+3rre5Y6datm+Ds7CxkZmZqll25ckUQi8XCCy+8UOW11HVc1KTy/6nqKBQKwdnZWejUqZNQVFSkWf7XX38JAIRly5YJgqA+Rur6f7djx446f14cP35cACBs3LhRa/m+ffu0ltdnX0TUtnE6HBHpNRcXF1y5cgXz5s1DdnY2vv76azz77LNwdnbG+++/D0EQqn3cs88+iyNHjiA1NRV///03UlNTm2QqXGUzZ86s8pd/iUSiOS9IqVQiMzMTVlZWCAwMxKVLl+q133nz5mndHzRoEGJjYxv92MzMTMhkMgDAvn37AAALFizQ2m7RokX12r+RkZHmPCyVSoWsrCyUlpaiV69e1b6+p59+GnZ2dlr1ANC8npSUFERGRmLmzJmQSqWa7R5//HEEBwfXq6byv/hXnhIXFxeHM2fOYPr06Zp/j8r/VgUFBcjIyMCAAQMgCAIuX75cr+cqt2fPHvTr1w99+vTRLHNyctKMOlVW+Xnz8vKQkZGBQYMGobCwELdu3WrQ8wIV71lYWJjWyFeXLl3w+OOPY8+ePVUeU9dx0VgXLlxAeno6FixYoDU1dfz48QgKCsLu3bsBqN8DU1NTHDlypMq0tXLlI0Z//fUXSkpKqt1m69atkEqlePzxx5GRkaG59ezZE1ZWVpppmfXZFxG1bQxBRKT33NzcsG7dOqSkpCA6OhpffvklnJycsGzZMvzwww/VPmbcuHGwtrbGr7/+io0bN6J3795aXd/KKZVKpKamat0UCkW96mrXrl2VZSqVCp999hkCAgIgkUjg6OgIJycnXL16Fbm5uXXu08zMDE5OTlrL7Ozsavzg+DBvb+8qjwWgeXx8fDzEYnGV2qt7b2ry008/oUuXLjAzM4ODgwOcnJywe/fual9ffeoBgICAgCqPDQwMrFc9xsbGePrpp3H8+HHNeSjlgahyKElISNAEh/LzrYYMGQIA9fq3qSw+Pr7eNd+4cQNTpkyBVCqFjY0NnJycNE02Gvq85c9d03N17NgRGRkZKCgo0Fpe179DY9VWS1BQkGa9RCLB6tWrsXfvXri4uGDw4MH4z3/+g9TUVM32Q4YMQWhoKFauXAlHR0dMmjQJ4eHhkMvlmm3u3LmD3NxcODs7w8nJSeuWn5+P9PT0eu+LiNo2hiAiajNEIhE6dOiARYsW4dixYxCLxdi4cWO120okEkydOhU//fQTduzYUeMo0P379+Hm5qZ1O3XqVL3qqe78jw8//BBvvPEGBg8ejA0bNmD//v2IiIhASEhItSfNP8zIyKhez93Qx9c0YtZQGzZsQFhYGPz9/fHDDz9g3759iIiIwPDhw6t9fc1dT7nnnnsOKpUKmzdvBgBs3rwZwcHBmnOUlEolHn/8cezevRtLlizBzp07ERERoWk2UJ9/m8bIycnBkCFDcOXKFbz33nv4888/ERERoTkXp7me92Et9e9Qm8WLF+P27dtYtWoVzMzM8O6776Jjx46aUTiRSIRt27bh9OnTeOWVV5CUlIQXX3wRPXv21FwPTKVSwdnZGREREdXe3nvvvXrvi4jaNjZGIKI2yc/PD3Z2dkhJSalxm2effRY//vgjxGJxte2TAcDV1RURERFay7p27drourZt24Zhw4ZVGaHKycmBo6Njo/fbVHx8fKBSqRAXF6c1khETE1Ovx2/btg1+fn7Yvn07RCKRZvny5csbXQ+g/gv/w6Kjo+u9n759+8Lf3x+bNm3C448/jhs3buCDDz7QrL927Rpu376Nn376CS+88IJm+cP/9g2puz41HzlyBJmZmdi+fTsGDx6sWR4XF1flsZXfz7qeu7rnAoBbt27B0dERlpaW9drXo6pcy/Dhw7XWRUdHa9aX8/f3xz/+8Q/84x//wJ07d9CtWzd88skn2LBhg2abfv36oV+/fvjggw+wadMmzJgxA1u2bMFLL70Ef39/HDx4EAMHDqz2jxAPq21fRNS2cSSIiPTa2bNnq0ztAYBz584hMzOz1ilTw4YNw/vvv4+vvvoKrq6u1W5jZmaGkSNHat0qn8PSUEZGRlX+ur5169Yq7YJ1ZfTo0QCA//3vf1rL165dW6/Hl48oVH6NZ8+exenTpxtVj5ubG7p164affvpJa2pYREQEoqKiGrSvGTNm4PLly1i+fDlEIpHW6F91dQuCgC+++KJRdY8bNw5nzpzBuXPnNMsePHhQZWSyuudVKBRV3n9A3emuPtPjKr9nldvAX79+HQcOHMC4ceMa+nIarVevXnB2dsbXX3+tNdVs7969uHnzpqbrYGFhYZWLFPv7+8Pa2lrzuOzs7Cr/d8pH8sq3mTZtGpRKJd5///0qtZSWlmrej/rsi4jaNo4EEZHO/fjjj5oT8it77bXXYG1tXetjf/nlF2zcuBFTpkxBz549YWpqips3b+LHH3+EmZkZ3n777RofKxaL8c477zxy/Q3xxBNP4L333sOsWbMwYMAAXLt2DRs3boSfn1+L1lGTnj17IjQ0FJ9//jkyMzM1LbJv374NoO7RiCeeeALbt2/HlClTMH78eMTFxeHrr79GcHBwo6cZrVq1CuPHj8djjz2GF198EVlZWVi7di1CQkIatM/nnnsO7733Hnbt2oWBAwdqtYkOCgqCv78/3nzzTSQlJcHGxga///57o8+J+b//+z/88ssvGDNmDF577TVNi2wfHx9cvXpVs92AAQNgZ2eHmTNn4tVXX4VIJMIvv/xS7TS0nj174tdff8Ubb7yB3r17w8rKChMmTKj2+desWYOxY8eif//+mD17tqZFtlQqrfNaTw1VUlKCf//731WW29vbY8GCBVi9ejVmzZqFIUOGYPr06ZoW2b6+vnj99dcBALdv38aIESMwbdo0BAcHw9jYGDt27EBaWppmlPann37C//73P0yZMgX+/v7Iy8vDd999BxsbG02wGzJkCF5++WWsWrUKkZGRGDVqFExMTHDnzh1s3boVX3zxBZ588sl67YuI2jaGICLSuXXr1lW7PCwsrM4Q9PLLL8PCwgKHDh3Crl27IJPJ4OTkhFGjRmHp0qXo3r17c5TcaG+//TYKCgqwadMm/Prrr+jRowd2796Nt956S9elafz8889wdXXF5s2bsWPHDowcORK//vorAgMDq734bGVhYWFITU3FN998g/379yM4OBgbNmzA1q1bceTIkUbVM2bMGGzduhXvvPMOli5dCn9/f4SHh2PXrl0N2mdAQIDmYqwPd2kzMTHBn3/+iVdffVVzTsqUKVPwyiuvNGr6o5ubGw4fPoxFixbho48+goODA+bNmwd3d3fMnj1bs52DgwP++usv/OMf/8A777wDOzs7PPfccxgxYoRmVK7cggULEBkZifDwcHz22Wfw8fGpMQSNHDkS+/btw/Lly7Fs2TKYmJhgyJAhWL16dbUNOx6FQqHAu+++W2W5v78/FixYgLCwMFhYWOCjjz7CkiVLYGlpiSlTpmD16tWaLm1eXl6YPn06Dh06hF9++QXGxsYICgrCb7/9htDQUADqgHPu3Dls2bIFaWlpkEql6NOnDzZu3Kj1mr7++mv07NkT33zzDd5++20YGxvD19cXzz33HAYOHNigfRFR2yUSWvKsRyIi0kuRkZHo3r07NmzYUG2bZyIiIn3Cc4KIiEhLUVFRlWWff/45xGKx1sn7RERE+orT4YiISMt//vMfXLx4EcOGDYOxsTH27t2LvXv3Yu7cufDy8tJ1eURERI+M0+GIiEhLREQEVq5ciaioKOTn58Pb2xvPP/88/vWvf8HYmH87IyIi/ccQREREREREBoXnBBERERERkUFhCCIiIiIiIoOi15O7VSoVkpOTYW1tXecF/IiIiIiIqO0SBAF5eXlwd3eHWFz7WI9eh6Dk5GR2KiIiIiIiIo379+/D09Oz1m30OgSVX0n+/v37sLGx0XE1RERERESkKzKZDF5eXpqMUBu9DkHlU+BsbGwYgoiIiIiIqF6nybAxAhERERERGRSGICIiIiIiMigMQUREREREZFD0+pyg+hAEAaWlpVAqlbouhdoYIyMjGBsbsz07ERERkZ5p0yFIoVAgJSUFhYWFui6F2igLCwu4ubnB1NRU16UQERERUT212RCkUqkQFxcHIyMjuLu7w9TUlH+xpyYjCAIUCgUePHiAuLg4BAQE1HlRLiIiIiJqHdpsCFIoFFCpVPDy8oKFhYWuy6E2yNzcHCYmJoiPj4dCoYCZmZmuSyIiIiKiemjzf7rmX+epOfH4IiIiItI//ARHREREREQGhSGIiIiIiIgMCkOQgfD19cXnn39e7+2PHDkCkUiEnJycZquJiIiIiEgXGIJaGZFIVOttxYoVjdrv+fPnMXfu3HpvP2DAAKSkpEAqlTbq+eqLYYuIiIiIWlqb7Q6nr1JSUjTf//rrr1i2bBmio6M1y6ysrDTfC4IApVIJY+O6/xmdnJwaVIepqSlcXV0b9BgiIiIiIn1gUCNBgiCgUFHa4jdBEOpdo6urq+YmlUohEok092/dugVra2vs3bsXPXv2hEQiwYkTJ3D37l1MmjQJLi4usLKyQu/evXHw4EGt/T48HU4kEuH777/HlClTYGFhgYCAAPzxxx+a9Q+P0Kxfvx62trbYv38/OnbsCCsrK4wZM0YrtJWWluLVV1+Fra0tHBwcsGTJEsycOROTJ09u1L8XAGRnZ+OFF16AnZ0dLCwsMHbsWNy5c0ezPj4+HhMmTICdnR0sLS0REhKCPXv2aB47Y8YMODk5wdzcHAEBAQgPD290LURERERtmkoFFOcCOQlA6jXg3kng1h4gcjNw5mvgyGpg/7+AXQuBX58DfpoAfDNEfdMzBjUSVFSiRPCy/S3+vFHvjYaFadO91W+99RY+/vhj+Pn5wc7ODvfv38e4cePwwQcfQCKR4Oeff8aECRMQHR0Nb2/vGvezcuVK/Oc//8GaNWuwdu1azJgxA/Hx8bC3t692+8LCQnz88cf45ZdfIBaL8dxzz+HNN9/Exo0bAQCrV6/Gxo0bER4ejo4dO+KLL77Azp07MWzYsEa/1rCwMNy5cwd//PEHbGxssGTJEowbNw5RUVEwMTHBwoULoVAocOzYMVhaWiIqKkozWvbuu+8iKioKe/fuhaOjI2JiYlBUVNToWoiIiIhaNWUpIJcBxTlAsUwdaMpv8ofuP7y+fBvU/4/3GiIjQBAAkaipX1GzMagQ1Fa89957ePzxxzX37e3t0bVrV839999/Hzt27MAff/yBV155pcb9hIWFYfr06QCADz/8EF9++SXOnTuHMWPGVLt9SUkJvv76a/j7+wMAXnnlFbz33nua9WvXrsXSpUsxZcoUAMBXX32lGZVpjPLwc/LkSQwYMAAAsHHjRnh5eWHnzp146qmnkJCQgNDQUHTu3BkA4Ofnp3l8QkICunfvjl69egFQj4YRERER6Y1SBSBLBHLuq0dnchOBwszqw0txLqDIb5rnNTIFzGwBMylgZlP2tewmqXzftmK9njGoEGRuYoSo90br5HmbUvmH+nL5+flYsWIFdu/ejZSUFJSWlqKoqAgJCQm17qdLly6a7y0tLWFjY4P09PQat7ewsNAEIABwc3PTbJ+bm4u0tDT06dNHs97IyAg9e/aESqVq0Osrd/PmTRgbG6Nv376aZQ4ODggMDMTNmzcBAK+++irmz5+PAwcOYOTIkQgNDdW8rvnz5yM0NBSXLl3CqFGjMHnyZE2YIiIiItK5kiJ1wMlNqBR0yr7m3AfyUtCokRkTy0pBpbYQU77eVnu9iVlTv9JWx6BCkEgkatJpabpiaWmpdf/NN99EREQEPv74Y7Rv3x7m5uZ48sknoVAoat2PiYmJ1n2RSFRrYKlu+4ac79QcXnrpJYwePRq7d+/GgQMHsGrVKnzyySdYtGgRxo4di/j4eOzZswcREREYMWIEFi5ciI8//linNRMREZGBkOdVE24qfV/woO59GJsBtt6A1Auw9QIsnWsJOGXLjEzq3q+B0/9EQDh58iTCwsI009Dy8/Nx7969Fq1BKpXCxcUF58+fx+DBgwEASqUSly5dQrdu3Rq1z44dO6K0tBRnz57VjOBkZmYiOjoawcHBmu28vLwwb948zJs3D0uXLsV3332HRYsWAVB3xZs5cyZmzpyJQYMG4Z///CdDEBERET06QQCKsssCTQ1Bpyi77v2YWqlDTuWgY+sNSMuWWTrq1bk2+oIhqA0ICAjA9u3bMWHCBIhEIrz77ruNnoL2KBYtWoRVq1ahffv2CAoKwtq1a5GdnQ1RPf7jXrt2DdbW1pr7IpEIXbt2xaRJkzBnzhx88803sLa2xltvvQUPDw9MmjQJALB48WKMHTsWHTp0QHZ2Ng4fPoyOHTsCAJYtW4aePXsiJCQEcrkcf/31l2YdERERUa0EASjIKAs0CRVT1CpPV1Pk1b0fM9uKkFMl6HgB5nYMOTrAENQGfPrpp3jxxRcxYMAAODo6YsmSJZDJZC1ex5IlS5CamooXXngBRkZGmDt3LkaPHg0jo7rPiSofPSpnZGSE0tJShIeH47XXXsMTTzwBhUKBwYMHY8+ePZqpeUqlEgsXLkRiYiJsbGwwZswYfPbZZwDU1zpaunQp7t27B3NzcwwaNAhbtmxp+hdORERErZ9KpR6ZKcxQNxcoyFB/X5BZ8zJl7acWAAAsncqCjXdZuPHRvi+xrnsf1OJEgq5P6ngEMpkMUqkUubm5sLGx0VpXXFyMuLg4tGvXDmZmbf/krtZIpVKhY8eOmDZtGt5//31dl9MseJwRERHpSKlCHVwKM8rCS+ZDQeahZUVZgNDQmTIiwNpNHWa0gk7ZdDWpJ2Bq0SwvjxqutmzwMI4EUZOJj4/HgQMHMGTIEMjlcnz11VeIi4vDs88+q+vSiIiIqDUTBEBRUCnUPBxuHl6WBchzG/dcEilg6QBYOKrPt7FwUN8sHasus3YDjE2b9rVSq8AQRE1GLBZj/fr1ePPNNyEIAjp16oSDBw/yPBwiIiJDolKpA0phVtn0syx1kCnKKlv20Nfy70uLG/5cInFZYCkLLlrhxhGwsNcON+b2DDUEgCGImpCXlxdOnjyp6zKIiIioqShLaggu5aEm+6F1merg0+BpZ2WMJBUjMZogU124KVtvZguIxU36kskwMAQRERERGYJSRdl0sgdlU8wqjdSUBxitwJMNyB+h0ZKJZdkojZ16BMbC/qGvD62zcFC3i2anNGoBOg1BSqUSK1aswIYNG5Camgp3d3eEhYXhnXfeqVdbZSIiIiKDJQjqkFKQAeSnq8PNw7f8St8X5zTyiUTqNs5VQox92XKH6tcZS5ry1RI1KZ2GoNWrV2PdunX46aefEBISggsXLmDWrFmQSqV49dVXdVkaERERUctTlqhDTXWBRivslG2jlDds/yIj7fNlHg43Fg5Vw4yZFBDXfbkLIn2i0xB06tQpTJo0CePHjwcA+Pr6YvPmzTh37pwuyyIiIiJqGoIAyPMqBZf0GgJN2fdF2Q1/DlNrdbCxclZfs8bSEbCs9L1muRPPoSEqo9MQNGDAAHz77be4ffs2OnTogCtXruDEiRP49NNPq91eLpdDLq/4i4cuLghKREREVIUgALJkIP0mkH6j7GsUkHEHKCls2L5E4rImAE6AlVNFgCm/WTmXBZ2y+ybmzfOaiNownYagt956CzKZDEFBQTAyMoJSqcQHH3yAGTNmVLv9qlWrsHLlyhaukoiIiKiSomx1yEmrFHbSo4DiWq5bY2JZEVy0Qoxz1dEac3uO1hA1M52GoN9++w0bN27Epk2bEBISgsjISCxevBju7u6YOXNmle2XLl2KN954Q3NfJpPBy8urJUvWG0OHDkW3bt3w+eefA1BPNVy8eDEWL15c42NEIhF27NiByZMnP9JzN9V+iIiIdKqkCHhwqyLopEWpv89Lrn57kRHg0B5w7gi4hKi/OnUEbNwAU8uWrZ2IaqXTEPTPf/4Tb731Fp555hkAQOfOnREfH49Vq1ZVG4IkEgkkkrbdaWTChAkoKSnBvn37qqw7fvw4Bg8ejCtXrqBLly4N2u/58+dhadm0P4BXrFiBnTt3IjIyUmt5SkoK7OzsmvS5HrZ+/XosXrwYOTk5zfo8RERkAJSlQFZsxYhOeeDJjqv5ejdSL8A5WB10nIMBl2DAIQAwMWvZ2omoUXQaggoLCyF+aLjXyMgIKlUjL7DVBsyePRuhoaFITEyEp6en1rrw8HD06tWrwQEIAJycnJqqxDq5urq22HMRERHVmyAAsqSyEZ2oivN3HtyuucuauX3FqI5zcNktSN0xjYj0lk4nnE6YMAEffPABdu/ejXv37mHHjh349NNPMWXKlOZ5QkEAFAUtfxOEepf4xBNPwMnJCevXr9danp+fj61bt2L27NnIzMzE9OnT4eHhAQsLC3Tu3BmbN2+udb++vr6aqXEAcOfOHQwePBhmZmYIDg5GRERElccsWbIEHTp0gIWFBfz8/PDuu++ipKQEgHokZuXKlbhy5QpEIhFEIpGmZpFIhJ07d2r2c+3aNQwfPhzm5uZwcHDA3LlzkZ+fr1kfFhaGyZMn4+OPP4abmxscHBywcOFCzXM1RkJCAiZNmgQrKyvY2Nhg2rRpSEtL06y/cuUKhg0bBmtra9jY2KBnz564cOECACA+Ph4TJkyAnZ0dLC0tERISgj179jS6FiIi0oHCLODeCeDcd8Cfi4EfRgMf+QCfhQCbngIOLgeubgFSr6kDkIkF4N4D6P4cMPpD4PkdwD9uA/8XC4T9BYxbA/SaBXj3ZQAiagN0OhK0du1avPvuu1iwYAHS09Ph7u6Ol19+GcuWLWueJywpBD50b5591+bt5HrPBTY2NsYLL7yA9evX41//+pfmorFbt26FUqnE9OnTkZ+fj549e2LJkiWwsbHB7t278fzzz8Pf3x99+vSp8zlUKhWmTp0KFxcXnD17Frm5udWeK2RtbY3169fD3d0d165dw5w5c2BtbY3/+7//w9NPP43r169j3759OHjwIABAKq36S6GgoACjR49G//79cf78eaSnp+Oll17CK6+8ohX0Dh8+DDc3Nxw+fBgxMTF4+umn0a1bN8yZM6de79vDr688AB09ehSlpaVYuHAhnn76aRw5cgQAMGPGDHTv3h3r1q2DkZERIiMjYWJiAgBYuHAhFAoFjh07BktLS0RFRcHKyqrBdRARUQsoVQAZt9VhJu16xVS2/NTqtxcbq6etVZ7G5twRsPVlMwIiA6LTEGRtbY3PP/9ca4SCgBdffBFr1qzB0aNHMXToUADqqXChoaGQSqWQSqV48803NdsvWrQI+/fvx2+//VavEHTw4EHcunUL+/fvh7u7OhR++OGHGDt2rNZ277zzjuZ7X19fvPnmm9iyZQv+7//+D+bm5rCysoKxsXGt0982bdqE4uJi/Pzzz5pzkr766itMmDABq1evhouLCwDAzs4OX331FYyMjBAUFITx48fj0KFDjQpBhw4dwrVr1xAXF6dpnPHzzz8jJCQE58+fR+/evZGQkIB//vOfCAoKAgAEBARoHp+QkIDQ0FB07twZAODn59fgGoiIqBkUZQOp1ysCT+pVIP0WoKph5oCtd6UpbOXn7bQHjNv2+cVEVDedhqAWZ2KhHpXRxfM2QFBQEAYMGIAff/wRQ4cORUxMDI4fP4733nsPAKBUKvHhhx/it99+Q1JSEhQKBeRyOSws6vc8N2/ehJeXlyYAAUD//v2rbPfrr7/iyy+/xN27d5Gfn4/S0lLY2Ng06LXcvHkTXbt21WrKMHDgQKhUKkRHR2tCUEhICIyMKq5G7ebmhmvXrjXouSo/p5eXl1bnwODgYNja2uLmzZvo3bs33njjDbz00kv45ZdfMHLkSDz11FPw9/cHALz66quYP38+Dhw4gJEjRyI0NLRR52EREVEjqVRAzr2HAs81IPd+9dtLbADXzoBLp7KRnRDAKRAwa9jvLCIyHIYVgkQivWlROXv2bCxatAj//e9/ER4eDn9/fwwZMgQAsGbNGnzxxRf4/PPP0blzZ1haWmLx4sVQKBRN9vynT5/GjBkzsHLlSowePRpSqRRbtmzBJ5980mTPUVn5VLRyIpGoWRtkrFixAs8++yx2796NvXv3Yvny5diyZQumTJmCl156CaNHj8bu3btx4MABrFq1Cp988gkWLVrUbPUQERmskiJ1g4LUa5UCz3VAkVf99rbegGuXitDj2lm9rGz6OBFRfRhWCNIj06ZNw2uvvYZNmzbh559/xvz58zXnB508eRKTJk3Cc889B0B9Dszt27cRHBxcr3137NgR9+/fR0pKCtzc3AAAZ86c0drm1KlT8PHxwb/+9S/Nsvj4eK1tTE1NoVQq63yu9evXo6CgQDMadPLkSYjFYgQGBtar3oYqf33379/XjAZFRUUhJydH6z3q0KEDOnTogNdffx3Tp09HeHi4pimHl5cX5s2bh3nz5mHp0qX47rvvGIKIiB5VfnpF2CkPPBm3q29DbWSqPlfHtbM69Lh0UndpM7dt8bKJqO1hCGqlrKys8PTTT2Pp0qWQyWQICwvTrAsICMC2bdtw6tQp2NnZ4dNPP0VaWlq9Q9DIkSPRoUMHzJw5E2vWrIFMJtMKO+XPkZCQgC1btqB3797YvXs3duzYobWNr68v4uLiEBkZCU9PT1hbW1e5jtOMGTOwfPlyzJw5EytWrMCDBw+waNEiPP/885qpcI2lVCqrXKNIIpFg5MiR6Ny5M2bMmIHPP/8cpaWlWLBgAYYMGYJevXqhqKgI//znP/Hkk0+iXbt2SExMxPnz5xEaGgoAWLx4McaOHYsOHTogOzsbhw8fRseOHR+pViIig6JSApkxVQNPflr121s4lIWdzoBL2VfHAMDIpPrtiYgeEUNQKzZ79mz88MMPGDdunNb5O++88w5iY2MxevRoWFhYYO7cuZg8eTJyc3PrtV+xWIwdO3Zg9uzZ6NOnD3x9ffHll19izJgxmm0mTpyI119/Ha+88grkcjnGjx+Pd999FytWrNBsExoaiu3bt2PYsGHIyclBeHi4VlgDAAsLC+zfvx+vvfYaevfuDQsLC4SGhuLTTz99pPcGULcN7969u9Yyf39/xMTEYNeuXVi0aBEGDx4MsViMMWPGYO3atQDU16LKzMzECy+8gLS0NDg6OmLq1KlYuXIlAHW4WrhwIRITE2FjY4MxY8bgs88+e+R6iYjaJHkekHZDO+ykRQGlRdVsLFI3JnDtpB14rF05nY2IWpRIEBpwEZtWRiaTQSqVIjc3t8oJ+8XFxYiLi0O7du1gZsarN1Pz4HFGRAajMAvIvKse4cm6CzyIVgeerNjqtzexKDtnp1LgcQnWm3NziUj/1JYNHsaRICIiIlKT51UKOrHqr5l31aGnKLvmx1m7l01nqxR47NsBYqOaH0NEpEMMQURERIakpAjIilMHm/KQUx50ajpnp5yNB2Dvp57SVj6tzaUzYOnQMrUTETURhiAiIqK2RlkCZMc/FHTKRndyEwHUMhPewrEs5Pirb/b+6vv2foBpw657R0TUWjEEERER6SOVCpAlVh3NyYxRByChlksYSKQVIcehfVnQKbuZSVvuNRAR6UibD0F63PeB9ACPLyJqNoIAFOcChZlAXkrVc3Wy4gClvObHG5tXHc0pDz0WDuzGRkQGrc2GIBMT9bUFCgsLYW5uruNqqK0qLCwEUHG8ERHVSFkKFGUBBRlAYYY63BSUfdV8n6Huwla+XFVS+z7FJuoGBJVHcspHdqzdALG4ZV4bEZGeabMhyMjICLa2tkhPTwegvl6NiH/1oiYiCAIKCwuRnp4OW1tbGBmxAxKRwVEUVgozmervNaEmo2xZpeXFOY17HhNLwMqpUtCpNH1N6gUYtdlf5UREzaZN/+R0dXUFAE0QImpqtra2muOMiNqAohzgwa3aw0z5yE1JYSOeQASY26mno1k6qr9qvi+7b+lQ6XtHwISzGYiImlqbDkEikQhubm5wdnZGSUkdUwqIGsjExIQjQET6TqUCUq8AMQeBOweBxPO1NxR4mJFpzeGluoBjbseRGyKiVsAgfhIbGRnxwyoREakVZAKxh4E7EcDdQ0DBA+31Ui/AyqVSeLF/aKSmUsCRWLPBABGRHjKIEERERAZMpQSSL6tDT8xBIOkitK6TY2oF+A0F2o8A2o8EbL11VSkREbUQhiAiImp78tOBmEPq0HP3b3VXtspcOpWFnscBr76Asalu6iQiIp1gCCIiIv2nLFWfzxNTNtqTckV7vUQK+A9Vh572IwAbd52USURErQNDEBER6SdZsjrwxBwE7h4B5Lna6926loWekYBnbzYkICIiDf5GICIi/VCqAO6fqejkln5De725HeBfdl5P+xGAlbNu6iQiolaPIYiIiFqvnISK0BN3FFDkV1opAjx6qkNPwOOAe3dAzE6gRERUN4YgIiJqPUqKgYRT6tATcxDIiNZeb+mkHu0JeBzwG6a+Ng8REVEDMQQREZFuZd4t6+QWAcQdB0qLKtaJjACvPhWd3Fy7AGKx7molIqI2gSGIiIgaT6UEFAXqW0lhpe/LvioKtb9X5JdtV/Z9ehSQFau9T2u3itDjN0R9rg8REVETYggiIjIEKiVQlFMWSAofCioPBZgqgaaG7xUFgFL+6LWJjQHv/mUNDUYCLiGASPTo+yUiIqoBQxARUVukLAVSrwL3TqhvCacBuaz5nk8kBkwsAVMLwNSy7Puy+yYWgKnVQ+vKvrd2B3wfA8xsmq82IiKihzAEERG1BfUNPUaSsnBiWRZOLB+6XxZYqnxfeZtqAo2xGUdviIhIbzAEERHpo/qEHokU8BmgHmnxfUw9zczIRDf1EhERtSIMQURE+kBZCqReqQg98acBRZ72Ng+HHtfOvG4OERFRNRiCiIhaI4YeIiKiZsMQRETUGtQ39PgOrDS9rRNDDxERUSMwBBER6QJDDxERkc4wBBERtYT6hB4zKeDD0ENERNTcGIKIiJqDshRIuQLcO17Wve0MQw8REVErwRBERPQoShVATjyQGQNk3gWy7gIZd4DkSIYeIiKiVkqnIcjX1xfx8fFVli9YsAD//e9/dVAREVE1VEogJ0EdcDJj1YEn66469OQkAIKy+scx9BAREbVKOg1B58+fh1JZ8eHh+vXrePzxx/HUU0/psCoiMkgqFZCXUhZuykZ1ykd2su8BSkXNjzWxBBz8AHt/wMEfcGivvjApQw8REVGrpNMQ5OTkpHX/o48+gr+/P4YMGaKjioioTRMEoCCj0khO+RS2WPXX0qKaH2skAezbqQOOvV9F2LH3B6xdAZGo5V4HERERPZJWc06QQqHAhg0b8MYbb0BUw4cJuVwOuVyuuS+TyVqqPCLSJ0XZVaetZcaow468lp8bIiPAzlcdcDSjOmVhx8aDozpERERtRKsJQTt37kROTg7CwsJq3GbVqlVYuXJlyxVFRK2bLBlIvABkRGtPXyvMrOVBIkDqVRFw7MtCjoM/YOsNGJm0WPlERESkGyJBEARdFwEAo0ePhqmpKf78888at6luJMjLywu5ubmwsbFpiTKJSFcUheqW04nn1beki4Asqebtrd3KAo5fxbQ1B3/Arh1gYtZydRMREVGLkMlkkEql9coGrWIkKD4+HgcPHsT27dtr3U4ikUAikbRQVUSkM4KgHtVJPA8kXVB/Tb1etQubSAw4hwCunbTP0bH3AyRWuqmdiIiIWr1WEYLCw8Ph7OyM8ePH67oUItKFwiwg6VJF4Em6qD6v52FWroBnL8Czt/qrWzeGHSIiImownYcglUqF8PBwzJw5E8bGOi+HiJqbshRIv1E2re2C+pZ5p+p2xmbqkOPZqyL42HiwCxsRERE9Mp2njoMHDyIhIQEvvviirkshouYgS9YOPMmXq29Fbe+vPcrj0olNCoiIiKhZ6DwEjRo1Cq2kNwMRPSpFIZASWRZ4yoJPXnLV7cykgEdPdeDx6KX+3tKhxcslIiIiw6TzEEREeqpy84LyBgY1NS9wCakIPJ691Q0MxGLd1E1EREQGjyGIiGqnUgIFGUBeivqmaVN9ASjOqbq9VvOC3oB7N8DUsqWrJiIiIqoRQxCRoaocbvLTykJO+ddUID+17Gt61dGdclrNC8rO5WHzAiIiImrlGIKI2prycFMeYiqHm/zKIaeWcPMwkRiwdAasXQCnIDYvICIiIr3GEESkL1QqoDCjIsSU3x4OO/lpDQw3ToC1K2DtBli5qL9al391VU9vs3QCjPjjgoiIiNoGfqoham2UpcC948Dt/UBOfKWw04BwAxFg5Vwp1LhWulUKOww3REREZID46YeoNShVAHHHgKidwK3dQFFWDRuKtEduHh6xKV/OcENERERUI35KakL3Mgrg68guWFRPJcVA7GEg6g8gejdQnFuxzsIBCBqvbjpQOexYOjPcEBERET0ifppqAiqVgOV/3MDGs/HYNKcf+vnxoo9Ug5IiIOYgELULiN4HKPIq1lk6A8ETgeBJgPcAhh0iIiKiZsJPWU1ALBahVKWCSgD+ue0K9r02GJYSvrVURp4PxESog8/tA0BJQcU6a/eK4OPVFxAb6a5OIiIiIgPBT+pN5O1xHXHsdgbuZxXho7238P7kTrouiXSpWKZubBC1Uz3yU1pcsU7qXRF8PHoBYrHOyiQiIiIyRAxBTcTazASrQ7vguR/O4pcz8RjbyRUD2jvquixqSUXZ6iluUbuAu4cApaJinV07degJngS4d+fFRImIiIh0iCGoCT0W4Ijn+nljw5kE/HPbVex/fTCsOC2ubSvIVDc1iPoDiD0CqEoq1jkEVAQf184MPkREREStBD+hN7GlYzviSPQDJGYX4cM9N/HhlM66LomaWn46cOsv9YhP3HHta/c4B1cEH6cgBh8iIiKiVoghqIlZSozxnye74NnvzmLT2QSM7eSKQQFOui6LHpUsBbj5J3DzDyD+JCCoKta5dlaHno6TAKcOuquRiIiIiOqFIagZDPB3xMz+PvjpdDyWlE2LszYz0XVZ1FC5ieppblG7gPtnAQgV69x7lI34TATs/XRWIhERERE1HENQM1kyNgiHox8gIasQH+y+iY9Cu+i6JKqP7HsVwSfpgvY6zz5lIz4TADsfnZRHRERERI+OIaiZWJgaY82TXfD0t2ew5fx9jOnkiqGBzrouix4mCEDaDeD2PvVUt5QrlVaKAJ8B6uAT9AQg9dBZmURERETUdBiCmlFfPwfMGuiL8JP38Nbv17D/9cGQmnNanM4V5ag7ucVEADGHgLyUinUiMeD7WFnwmQBYu+iqSiIiIiJqJgxBzez/Rgfh8K103MssxL//isKap7rquiTDIwhA6lXgTlnouX9Wu6ObsTnQbjAQNE494mPJ6zsRERERtWUMQc3M3NQIHz/VFU99cxpbLyZibGdXDA/i6EKzK8oG7h4GYg6qb/lp2usdOwDtHwfajwB8BgImZrqpk4iIiIhaHENQC+jla4/ZA9vh+xNxeOv3a4h43R5SC06La1IqFZB6BbhzUD3NLfG8dhtrE0v1aE/ASKD9SMDOV2elEhEREZFuMQS1kDdHB+LvW+mIzSjAyr9u4NNp3XRdkv4rzALu/l0x2lPwQHu9U5A68AQ8Dnj3B4wluqmTiIiIiFoVhqAWYmZihI+ndcWT605h+6UkjO3khseDOS2uQVQqIOVyxWhP0kXt0R5TK8BvqHqKW/uRgK23zkolIiIiotaLIagF9fC2w5xBfvjmWCze3nENvXzsYGdpquuyWreCTODuIXVTg7uHgMJM7fXOwRWjPV79AGO+n0RERERUO4agFvb64x1w8GYa7j4owIo/b+CLZ7rruqTWRaUEki6VTXGLUH8PoWK9qTXgP7SiqYHUU1eVEhEREZGeYghqYWYmRvhkWjdM/d9J7IpMxthObhjTyVXXZelW/oNKoz1/A0VZ2utdOqsDT8DjgFdfwIhNJYiIiIio8RiCdKCbly3mDfHH/47cxTs7r6FPO3vYG9K0OJUSSLxQdrHSg0DyZe31Emml0Z6RgI2bTsokIiIioraJIUhHXhsZgIM303A7LR/Ldl3HV8/20HVJzatUAcQeBqJ2AdF71Nfxqcy1i3qkp/3jgGdvwIiHJhERERE1D37S1BGJsfoiqlP+dwp/XU3BuM4pGNe5jY14lMrV09tu7ASi9wLy3Ip1ZlLAf3jFuT3WBj4lkIiIiIhaDEOQDnXxtMWCof5Y+3cM3tl5HX3a2cPRSs+vZVNSrD6/J2pXWfCRVayzcgWCJwLBk9Sd3DjaQ0REREQ6wE+hOrZoeAAiotJwKzUP7+68jv/N6AGRSKTrshqmpEh9bk/ULiB6H6DIq1hn7aYOPcGT1U0NxGKdlUlEREREBDAE6ZypsRgfP9UVk/97Enuvp+KvqymY0NVd12XVTVGobmwQtQu4vR9Q5Fess/GoCD6evRl8iIiIiKhVYQhqBTp5SLFwWHt8cegOlu26jn5+DnCyboXT4hQFwJ0DZcHnAFBSULFO6lURfDx6MvgQERERUavFENRKLBzWHhFRaYhKkeGdndfw9XM9W8e0OHl+WfDZqb6OT0lhxTqpNxAyCQieAnj0AFpDvUREREREdWAIaiXKp8VN+u8J7L+Rhj+uJGNSNw/dFCPPU09xi9oJ3DkIlBZVrLP1AUImq0d83Lsz+BARERGR3mEIakWC3W2waHgAPo24jWW7bqC/nwOcbcxa5smLZRXBJ+YgUFpcsc6uXVnwmQS4dWPwISIiIiK9pvMQlJSUhCVLlmDv3r0oLCxE+/btER4ejl69eum6NJ2YP9QfB6JScT1Jhrd3XMN3L/Rqvmlxxbnqbm5RO4GYQ4BSXrHO3r8i+Lh2YfAhIiIiojZDpyEoOzsbAwcOxLBhw7B37144OTnhzp07sLOz02VZOmViJMYnT3XDE2uP4+DNdOy4nISpPTyb7gmKctTX74naqb6QqVJRsc4hoCL4uHRi8CEiIiKiNkmnIWj16tXw8vJCeHi4Zlm7du10WFHrEOhqjcUjO2DN/mis+OMGBvg7wlX6CNPiirKBW3vKgs9hQFVSsc4xsCL4OAcz+BARERFRmycSBEHQ1ZMHBwdj9OjRSExMxNGjR+Hh4YEFCxZgzpw51W4vl8shl1dM2ZLJZPDy8kJubi5sbGxaquwWUapUIXTdKVxJzMWwQCf8GNa7YdPiimXArb+A678DsUcAVWnFOqcgdWODkMmAc8cmrpyIiIiIqOXJZDJIpdJ6ZQOdhiAzM/XoxhtvvIGnnnoK58+fx2uvvYavv/4aM2fOrLL9ihUrsHLlyirL22IIAoA7aXkY/+UJKJQqrHmyC57q5VX7A0qK1e2sr21VNzmofI6Pc7A6+ARPApyDmrVuIiIiIqKWpjchyNTUFL169cKpU6c0y1599VWcP38ep0+frrK9IY0Elfv66F18tPcWrCXGOPDGYLhJzbU3UJYCcUfVIz43/wTksop1jh2ATk8CIVMApw4tWzgRERERUQtqSAjS6TlBbm5uCA4O1lrWsWNH/P7779VuL5FIIJFIWqK0VmPOID/su56KyPs5WPL7Nfw0qzdEAJB4Hri2DbixHSh4UPEAG0+g01Sg81OAa2ee40NERERE9BCdhqCBAwciOjpaa9nt27fh4+Ojo4paHyOxCB8/1RXjvjyO1DuXcHPDrwjOjABy4is2MrdXj/Z0fhLw6geIxbormIiIiIioldNpCHr99dcxYMAAfPjhh5g2bRrOnTuHb7/9Ft9++60uy2pdsu+hffTvOCPdBPuCGOBu2XITS6DjE+rpbv7DACMTnZZJRERERKQvdHpOEAD89ddfWLp0Ke7cuYN27drhjTfeqLE73MMaMu9Pr+SnAzd2qhscJJ7TLC6BMQ4ruyLaaQxembcQIlNL3dVIRERERNSK6M05QQDwxBNP4IknntB1GbpXnAvc/Au4vk3d0lpQla0QAe0GAZ2fQpLTcCz65hrkySrYX87AjL4MQUREREREDaXzEGTQSoqBO/vVDQ4ebmnt0bOis5uNGwDAF8D/jSnB+39F4cPdNzE4wAle9hY6KZ2IiIiISF8xBLW08pbW17apL2aq1dI6UN3VrdNUwMG/2ofPGuCL/ddTce5eFpb8fhUbZveFWMwOcERERERE9cUQ1BIEoayl9Vbgxg7tltZSr4qW1i6d6mxpLRaL8J8nu2DsF8dx6m4mNp6Nx/P9fZu3fiIiIiKiNoQhqDml3VCP+FzfBuQkVCy3cACCJ6uDj1ffBre09nW0xJIxgVjxZxQ+3HMLQzo4w9uB0+KIiIiIiOqDIaipZd8Drv+uDj/pURXLTa2AoCfU1/LxG/rILa1f6O+LvddTcTYuC//cdgWb5/TjtDgiIiIionpgCGoqF8KByE1aLa1hZAoEjFIHn4DRgGnTjdaIxSKsebIrxnxxDGfjsvDz6XsIG9iuyfZPRERERNRWMQQ1lZiD6gAkEgO+6pbW6DgBMLdttqf0drDA0nEd8e7O6/ho3y0MDXSGryPbZhMRERER1YYhqKn0mQv4PqZuaW3t2mJPO6OPN/ZeS8Gpu5n457Yr+HVuf06LIyIiIiKqRcPOyKea+Q0B+s1v0QAEqKfFrQ7tAktTI5y/l43wU/da9PmJiIiIiPQNQ1Ab4GVvgX+NDwYA/GffLcQ+yNdxRURERERErRdDUBsxvY8XBgU4Ql6qwptbr0CpEnRdEhERERFRq8QQ1EaIRCJ8FNoFVhJjXErIwY8n4nRdEhERERFRq8QQ1IZ42Jrj3Sc6AgDWHIhGTDqnxRERERERPYwhqI2Z1ssLQzo4QVGqwj+2XkGpUqXrkoiIiIiIWhWGoDZGPS2uM6zNjHHlfg6+O85pcURERERElTEEtUFuUnMse0LdLe6ziNvYcCYeD/LkOq6KiIiIiKh1EAmCoLdtxGQyGaRSKXJzc2FjY6PrcloVQRAw+6cL+PtWOgBAJAJ6+9pjTIgrRndyhYetuY4rJCIiIiJqOg3JBgxBbVihohQ/nYrHvuspuJKYq7Wui6cUo0NcMaaTK/ydrHRUIRERERFR02AIoiqScopw4EYq9l1Pxfl7Wah8GaEAZyuM6eSK0SGuCHG3gUgk0l2hRERERESNwBBEtcrIl+NgVBr23UjFyZgMlCgrDgFPO3OMKRsh6uFtB7GYgYiIiIiIWj+GIKo3WXEJ/r6Zjn3XU3HkdjqKSypaajtZSzAq2AVjOrmin58DTIzYR4OIiIiIWieGIGqUIoUSR28/wP4bqTh4Mw15xaWadVJzE4zo6IwxIa4Y3MEJZiZGOqyUiIiIiEgbQxA9MkWpCqdjM7HveioiolKRka/QrLMwNcKwQGeM7uSKYYFOsDYz0WGlREREREQMQdTElCoBF+Ozse96KvbfSEVSTpFmnamRGI8FOGJMiCtGBrvA3tJUh5USERERkaFiCKJmIwgCrifJsO9GCvZeT0XsgwLNOrEI6NvOAWM6uWJUiAvcpLwWERERERG1DIYgajEx6XnYey0V+26k4kayTGtdNy9bjOnkijEhrvB1tNRRhURERERkCBiCSCfuZxVif9m1iC4mZKPykRXkaq25OGuQqzWvRURERERETYohiHQuXVaMA1Fp2H8jFafvZqK00tVZfRwsMKSDEwb4O6K/nwOkFmysQERERESPhiGIWpWcQgUO3UzHvhupOHb7AeSlFdciEouATh5SDPB3xMD2DujlYw9zU7bfJiIiIqKGYQiiVqtAXorjdzJw6m4GTsZk4G6lxgqAuttcDx9bDPR3xID2jujqKYUxL9JKRERERHVgCCK9kZpbXBaIMnHqbgZScou11ltJjNG3nT0GtFePFAW68HwiIiIiIqqKIYj0kiAIiMsowMm7mTgVk4HTsZnIKSzR2sbRyhT9/R0x0N8BA9s7wsveQkfVEhEREVFrwhBEbYJKJSAqRYaTMRk4eTcT5+OyUFSi1NrGy95cM3VugL8DHK0kOqqWiIiIiHSJIYjaJEWpCpcTsjUjRZH3c7S6zgHqVtzlTRb6tLOHtRk7zxEREREZAoYgMgj58lKcj8vSjBTdTNG+WKuRWISunlIMbO+IAf6O6OFjC4kxO88RERERtUUMQWSQMvPlOB2bqWmyEJ9ZqLXezESM3r72mpGiEHcpjMRsskBERETUFjAEEQFIzC7EqZhMnCzrPpeRL9daLzU3QT8/e81Ikb+TJTvPEREREekpvQlBK1aswMqVK7WWBQYG4tatW/V6PEMQ1ZcgCLiTnq+eOheTibOxmciTl2pt42hlip4+dujlY49evnYIcZfC1JjXKCIiIiLSBw3JBsYtVFONQkJCcPDgQc19Y2Odl0RtkEgkQgcXa3Rwscasge1QqlThWlIuTt3NxMmYDFyIz0ZGvgL7b6Rh/400AIDEWIxuXrbo5WuHXr726OFtB6k5Gy0QERER6TudJw5jY2O4urrqugwyMMZGYnT3tkN3bzssHNYexSVKXE/KxYX4bFy4l4WL8dnILizB2bgsnI3LAnAXIhEQ6GKNnj526O1rj54+dvC0M+cUOiIiIiI9o/MQdOfOHbi7u8PMzAz9+/fHqlWr4O3tXe22crkccnnFeR0ymaza7YgayszECL187dHL1x4Y4g9BEHD3QQEu3MvSBKN7mYW4lZqHW6l52Hg2AQDgamOGnr526O2jHi0KcrWGsRGn0BERERG1Zjo9J2jv3r3Iz89HYGAgUlJSsHLlSiQlJeH69euwtrausn115xAB4DlB1CIe5MlxMT4LF+5l43x8Nm4k5Va5TpGlqRG6e9tpRou6edvCSqLzvzUQERERtXl60xjhYTk5OfDx8cGnn36K2bNnV1lf3UiQl5cXQxDpRJFCiSuJOZrRoovx2cgr1m62IBYBwe42mmYLvXzs4So101HFRERERG2XXjVGqMzW1hYdOnRATExMteslEgkkEkkLV0VUPXNTI/Tzc0A/PwcAgEol4HZ6Hs7fy8bFe1k4fy8bSTlFuJ4kw/UkGdafugcA8LA1R29fO/T0tUdvXzt0cLaGmNcrIiIiImoxrSoE5efn4+7du3j++ed1XQpRg4nFIgS52iDI1QbP9/MBAKTmFuNC2RS6C/FZiEqWISmnCEmRRdgZmQwAsDYzLmvNrT6vqKunLcxNjXT5UoiIiIjaNJ1Oh3vzzTcxYcIE+Pj4IDk5GcuXL0dkZCSioqLg5ORU5+N5nSDSN/nyUkQm5OB8WQe6ywnZKFAotbYxFovQyUOKXj52GN7RGf3aOXCkiIiIiKgOzT4d7v79+xCJRPD09AQAnDt3Dps2bUJwcDDmzp1b7/0kJiZi+vTpyMzMhJOTEx577DGcOXOmXgGISB9ZSYzxWIAjHgtwBACUKlW4lZqHC/eycL6sC12aTI7I+zmIvJ+D70/EwcPWHFN7eGBqD0+0c7TU8SsgIiIi0n+NGgkaNGgQ5s6di+effx6pqakIDAxESEgI7ty5g0WLFmHZsmXNUWsVHAmitkYQBCRmF+FifDZO3c3A3mupyJNXNFvo6WOH0B6eGN/FjRduJSIiIqqk2bvD2dnZ4cyZMwgMDMSXX36JX3/9FSdPnsSBAwcwb948xMbGNrr4hmAIorauuESJA1Fp+P1iIo7feYDyjtymxmI8HuyCJ3t4YlCAI69NRERERAav2afDlZSUaLq0HTx4EBMnTgQABAUFISUlpTG7JKJqmJkYYWJXd0zs6o50WTF2Ribh94tJiE7Lw+6rKdh9NQVO1hJM7uaO0J6eCHLlHwOIiIiI6tKokaC+ffti2LBhGD9+PEaNGoUzZ86ga9euOHPmDJ588kkkJiY2R61VcCSIDJEgCLiRLMO2i4n440oysgoUmnXBbjYI7emJSd3c4WjFdvJERERkOJp9OtyRI0cwZcoUyGQyzJw5Ez/++CMA4O2338atW7ewffv2xlXeQAxBZOgUpSocvf0Av19MxKFbaShRqv87G4tFGBrohKk9PDGiozMkxmy5TURERG1bs4cgAFAqlZDJZLCzs9Msu3fvHiwsLODs7NyYXTYYQxBRhewCBf68mozfLybiSmKuZrnU3AQTurohtIcnunnZQiRiu20iIiJqe5o9BBUVFUEQBFhYWAAA4uPjsWPHDnTs2BGjR49uXNWNwBBEVL2Y9Dxsu5iEnZeTkCor1iz3c7JEaA9PTOnuAXdbcx1WSERERNS0mj0EjRo1ClOnTsW8efOQk5ODoKAgmJiYICMjA59++inmz5/f6OIbgiGIqHZKlYBTdzPw+8VE7LuRiuISFQBAJAIG+DsgtIcnxnRyhYVpo3qkEBEREbUazR6CHB0dcfToUYSEhOD777/H2rVrcfnyZfz+++9YtmwZbt682ejiG4IhiKj+8opLsPdaKrZdSsS5uCzNcktTI4ztrJ4u17edPcRiTpcjIiIi/dPsLbILCwthbW0NADhw4ACmTp0KsViMfv36IT4+vjG7JKJmZm1mgmm9vTCttxfuZxVi+6Uk/H4pEQlZhdh2MRHbLibCw9YcU3t4ILSHJ3wdLXVdMhEREVGzaNRIUJcuXfDSSy9hypQp6NSpE/bt24f+/fvj4sWLGD9+PFJTU5uj1io4EkT0aARBwIX4bPx+MRG7r6YgT16qWdfTxw6hPTwxvosbpOYmOqySiIiIqG7NPh1u27ZtePbZZ6FUKjF8+HBEREQAAFatWoVjx45h7969jau8gRiCiJpOcYkSB6LS8PvFRBy/8wCqsp8MpsZijAp2QWgPTwwKcISxkVi3hRIRERFVo0VaZKempiIlJQVdu3aFWKz+UHTu3DnY2NggKCioMbtsMIYgouaRJivGzsvq6XK30/I1y52sJRjbyRXDg5zRz88BZia8/hARERG1Di0SgsolJiYCADw9PR9lN43CEETUvARBwPUkGX6/lIhdkUnILizRrDM3McLA9g4YHuSCYUFOcJOy5TYRERHpTrOHIJVKhX//+9/45JNPkJ+v/iuxtbU1/vGPf+Bf//qXZmSouTEEEbUcRakKx+88wMGb6fj7VhrSZHKt9R3dbDAiyBnDgpzRzcsWRuwyR0RERC2o2UPQ0qVL8cMPP2DlypUYOHAgAODEiRNYsWIF5syZgw8++KBxlTcQQxCRbgiCgKgUGQ7fSsehW+mIvJ+Dyj9J7C1NMbSDE4YFOWNwByc2ViAiIqJm1+whyN3dHV9//TUmTpyotXzXrl1YsGABkpKSGrrLRmEIImodMvPlOHr7AQ7dSsex2w+QV1zRZc5ILEIvHzsMD3LG8CBntHe2gkjEUSIiIiJqWs0egszMzHD16lV06NBBa3l0dDS6deuGoqKihu6yURiCiFqfEqUKF+Oz8fetdPx9Kx0x6fla673szTE8UD1tjs0ViIiIqKk0ewjq27cv+vbtiy+//FJr+aJFi3Du3DmcPXu2obtsFIYgotYvIbMQf99Kw9/RD3DmbiYUSpVmnbq5gqNmlMhVaqbDSomIiEifNXsIOnr0KMaPHw9vb2/0798fAHD69Gncv38fe/bswaBBgxpXeQMxBBHplwJ5KU7GZOBwtHqU6OHmCsFuNupA1NEZXT3ZXIGIiIjqr0VaZCcnJ+O///0vbt26BQDo2LEj5s6di3//+9/49ttvG7PLBmMIItJfgiDgRrK6ucLf0TU3Vxje0RmDAthcgYiIiGrXotcJquzKlSvo0aMHlEplU+2yVgxBRG1HZr4cR6If4O/ompsrjOionjbn78TmCkRERKSNIYiI9FqJUoUL97I10+aqa64wIsgFw4Kc0bedPZsrEBEREUMQEbUtdTVXGNHRGc/28UZ/fweOEBERERkohiAiarNqa67QztESz/T2wpM9PeFgJdFhlURERNTSmi0ETZ06tdb1OTk5OHr0KEMQEbUIQRBwLSkXv56/j12RyciXq88jMjESYXSIK57t643+fhwdIiIiMgTNFoJmzZpVr+3Cw8Pru8tHwhBEROUK5KX480oyNp9LwJXEXM3ydo6WmN7HC6E9ODpERETUlulsOlxLYwgioupcT8rF5nMJWqNDpkZijO7kimf7eKOfnz1Hh4iIiNoYhiAiIlSMDm06l4CrlUaH/BwtMb2PN0J7esLe0lSHFRIREVFTYQgiInrI9aRcbDqXgF2Xk1CgUJ+3aGokxphOrpjO0SEiIiK9xxBERFSD/ErnDnF0iIiIqO1gCCIiqofaRoee7euNvu04OkRERKQvGIKIiBogX16KPyLVo0PXkiqNDjlZ4tk+3pjag6NDRERErR1DEBFRI11LVI8O/RGpPTo0trO6s1wfjg4RERG1SgxBRESPqHx0aNO5eFxPkmmW+zuVnTvUwxN2HB0iIiJqNRiCiIiakHp0KB67IpNRyNEhIiKiVokhiIioGeTLS7ErMgmbzibgRjJHh4iIiFqThmQDcQvVVKePPvoIIpEIixcv1nUpRETVspIYY0ZfH+x+dRD+eGUgpvfxgoWpEe4+KMC/d99E31WHsHjLZZyLy4Ie/32JiIiozTPWdQEAcP78eXzzzTfo0qWLrkshIqqXLp626OJpi7fHdcSuyGRsOpuAqBQZdkYmY2dkMjq4WOGlx/wwqbs7JMZGui6XiIiIKtH5SFB+fj5mzJiB7777DnZ2drouh4ioQazNTPBcPx/sfvUx7Fo4EM/0Vo8O3U7Lx//9fhUDPzqMtYfuILtAoetSiYiIqIzOQ9DChQsxfvx4jBw5ss5t5XI5ZDKZ1o2IqDUQiUTo6mWLj0K74MzbI/D2uCC4Sc2QkS/HJxG30f+jQ3hn5zXEZRToulQiIiKDp9PpcFu2bMGlS5dw/vz5em2/atUqrFy5spmrIiJ6NDZmJpg72B+zBrbDnmsp+O54LK4nybDhTAI2nk3AyI4umDPID7197dhVjoiISAd01h3u/v376NWrFyIiIjTnAg0dOhTdunXD559/Xu1j5HI55HK55r5MJoOXlxe7wxFRqyYIAs7EZuH747E4dCtds7yrpxQvDfLD2E6uMDbS+cA8ERGRXtOLFtk7d+7ElClTYGRUccKwUqmESCSCWCyGXC7XWlcdtsgmIn0Tk56HH07E4fdLSVCUqgAAHrbmmDXQF8/08YaVpFX0qyEiItI7ehGC8vLyEB8fr7Vs1qxZCAoKwpIlS9CpU6c698EQRET6KiNfjl9Ox+OXM/HIKmuaYC0xxvS+3ggb4At3W3MdV0hERKRf9CIEVaeu6XAPYwgiIn1XXKLE9ktJ+P5ELGIfqJsmGItFeKKLG14a5IdOHlIdV0hERKQfGpINOO+CiEiHzEyM8GxfbzzT2wuHo9Px3fFYnInN0lxvqJ+fPeYM8sOwQGeIxWyiQERE1BRa1UhQQ3EkiIjaoutJufjueCz+upoCpUr9I9rfyRIvDfLDlO4eMDPhxVeJiIgeprfT4RqKIYiI2rLknCKsP3UPm88mIE9eCgBwsDTF8/198Hw/HzhYSXRcIRERUevBEERE1IbkFZfg1/P3EX7yHpJyigAAEmMxpvbwxOzH2qG9s5WOKyQiItI9hiAiojaoVKnC3uup+P54LK4k5mqWjwhyxkuD/NDPz54XXyUiIoPFEERE1IYJgoDz97Lx3fFYHLyZhvKf4p08bDBnkB/GdXaDCS++SkREBoYhiIjIQMQ+yMePJ+Ow7WIiikvUF191l5ohrOziqzZmJjqukIiIqGUwBBERGZisAgU2nonHT6fjkZEvBwBYSYzxdG8vzBroC087Cx1XSERE1LwYgoiIDFRxiRJ/RCbju+OxuJOeDwAwEoswtpMr5g72QxdPW90WSERE1EwYgoiIDJwgCDh6+wG+Px6HEzEZmuUD2ztgwdD2GODvwCYKRETUpjAEERGRRlSyDN8fj8WuK8mai6929ZRi/tD2GBXsArGYYYiIiPQfQxAREVWRmF2I74/HYcv5BE0TBX8nS8wb4o/J3T3YUY6IiPQaQxAREdUoI1+O9Sfv4afT95BXXApA3VFuzmA/PNPbG+amRjqukIiIqOEYgoiIqE55xSXYeDYBP5yIw4M8dUc5e0tTzBrgixf6+0JqwfbaRESkPxiCiIio3opLlPj9UiK+ORqLhKxCAIClqRFm9PPBS4+1g7ONmY4rJCIiqhtDEBERNVipUoXd11Kw7shd3ErNAwCYGokR2tMTLw/2g6+jpY4rJCIiqhlDEBERNZogCDgcnY7/Hb6LC/HZAACxCBjX2Q3zh/ojxF2q4wqJiIiqYggiIqImcf5eFv53OAaHox9olg0NdMKCoe3Rp529DisjIiLSxhBERERNKipZhnVH72L31WSUXWoIvXzsMH+oP4YHOfPCq0REpHMMQURE1CziMwvwzbFYbLuQCIVSfa2hIFdrzB/qj/Gd3WDMaw0REZGOMAQREVGzSpcV44cTcdhwJh4FCiUAwNveAnMH++HJnp4wM+G1hoiIqGUxBBERUYvILSzBL2fu4ceT95BVoAAAOFpJMPuxdniunzeszXitISIiahkMQURE1KKKFEr8ej4B3x2PQ1JOEQDA2swYL/T3wayB7eBoJdFxhURE1NYxBBERkU6UKFXYFZmMr4/eRUx6PgBAYizGM7298NIgP3jZW+i4QiIiaqsYgoiISKdUKgERN9PwvyN3ceV+DgDASCzCpK7umDfUHx1crHVbIBERtTkMQURE1CoIgoDTdzPxvyN3cSImQ7P88WAXzB/qjx7edjqsjoiI2hKGICIianWu3M/B10fvYt+NVJT/5unnZ4+XB/tjSAcniMW81hARETUeQxAREbVaMen5+OboXey4nITSsiuvBjhbYc5gP0zq5g6JMdtrExFRwzEEERFRq5ecU4Twk3HYfO4+8uWlAABnawnCBvpiRh8fSC3YXpuIiOqPIYiIiPSGrLgEm88mIPzkPaTKigEAlqZGeLq3N158zBeeduwoR0REdWMIIiIivaMoVeHPK8n47ngsbqXmAVB3lBvf2Q1zB/uhk4dUxxUSEVFrxhBERER6SxAEHLuTge+OxWp1lBvg74A5g/0wtIMTRCI2USAiIm0MQURE1CZcT8rF98dj8efVFCjLmih0cLHCnEF+mNTNA6bGYh1XSERErQVDEBERtSlJOUUIPxGHzecSUKBQAgBcbCQIG9AOz/b1htScTRSIiAwdQxAREbVJuUUl2HwuAeEn45AmkwNQN1F4po83Zg1kEwUiIkPGEERERG2aolSFP64k47tjsYhOq2ii8EQXN8wZxCYKRESGiCGIiIgMgiAIOHr7Ab47HouTMZma5QPbO2DOID8MYRMFIiKDwRBEREQG53pSLr47Hou/KjVRCHSxxpzBfpjY1Z1NFIiI2jiGICIiMliJ2YUIP3kPWx5qojBrYDtM78MmCkREbVVDsoFO/yy2bt06dOnSBTY2NrCxsUH//v2xd+9eXZZERER6ztPOAu8+EYxTS0dgyZggOFtLkCaT46O9tzDwo7/x77+ikJxTpOsyiYhIh3Q6EvTnn3/CyMgIAQEBEAQBP/30E9asWYPLly8jJCSkzsdzJIiIiOoiL1Xij8hkfHc8FrfT8gEAxuVNFAb7IcSdTRSIiNoCvZ4OZ29vjzVr1mD27Nl1bssQRERE9SUIAo7cfoDvjsXi1N2KJgqPtXfEnMF+GBzgyCYKRER6rCHZwLiFaqqTUqnE1q1bUVBQgP79+1e7jVwuh1wu19yXyWQtVR4REek5kUiEYYHOGBbojGuJufj2eCz2XEvBiZgMnIjJQJCrNeYM8sMENlEgImrzdD4SdO3aNfTv3x/FxcWwsrLCpk2bMG7cuGq3XbFiBVauXFllOUeCiIioMe5nlTVROJ+AwrImCm5SM8wf6o+ne3tBYmyk4wqJiKi+9Go6nEKhQEJCAnJzc7Ft2zZ8//33OHr0KIKDg6tsW91IkJeXF0MQERE9ktzCEmw8F4/wk/fwIE/9e8ZNaoYFw9pjWi9PhiEiIj2gVyHoYSNHjoS/vz+++eabOrflOUFERNSU5KVK/Hb+Pv57+C5SZcUAAHdNGPLiNDkiolZMb1pkV0elUmmN9hAREbUUibERnu/viyP/HIqVE0PgYiNBcm4x3tl5HcM+PoJNZxOgKFXpukwiInpEOh0JWrp0KcaOHQtvb2/k5eVh06ZNWL16Nfbv34/HH3+8zsdzJIiIiJpTcYkSm88lYN2Ru0gvmybnYWuOV4a3x5M9PWFi1Or+lkhEZLD0Zjrc7NmzcejQIaSkpEAqlaJLly5YsmRJvQIQwBBEREQto7hEiU1nE7Du6F3NOUOeduZ4ZVh7hDIMERG1CnoTgh4VQxAREbWk4hIlNp5Vjwxl5KvDkJe9ORYNC8CUHh4MQ0REOsQQRERE1IyKFEpsPBuPr4/eRUa+AgDgbW+BV4a3x9TuHjBmGCIianEMQURERC2gSKHEhjPqMJRZoA5DPg4WWDQ8AJO7uTMMERG1IIYgIiKiFlSoKMWGM/H45misJgz5loWhSQxDREQtgiGIiIhIBwoVpfj5dDy+PRaLrLIw1M7REouGt8fErgxDRETNiSGIiIhIhwrk5WHoLrILSwAAfo6WeHVEACZ0dYeRWKTjComI2h6GICIiolYgX16Kn0/fw7fHYpFTHoacLPHaiAA80YVhiIioKTEEERERtSL58lL8dOoevjteEYb8ndQjQwxDRERNgyGIiIioFcorLikLQ3HILVKHofbOVnhtRADGd3aDmGGIiKjRGIKIiIhaMVlxCdafvIfvj8dCVlwKAAhwtsJrIwMwrhPDEBFRYzAEERER6QFZcQnCT9zD9ydikVcWhgJdrPHayACMCXFlGCIiagCGICIiIj2SW1SC8JNx+OFEnCYMBbla47URARjNMEREVC8MQURERHoot6gEP5yIQ/iJOOTJK8LQ4pEBGBXMMEREVBuGICIiIj2WW1iCH07E4seT95BfFob8nCwxZ5AfpnT3gJmJkY4rJCJqfRiCiIiI2oCcQgW+Px6Hn07f00yTc7QyRdgAXzzXzwe2FqY6rpCIqPVgCCIiImpD8uWl2HIuAT+eiENybjEAwNzECE/39sLsx9rBy95CxxUSEekeQxAREVEbVKJUYffVFHxzLBY3U2QAALEIGNfZDS8P9kdnT6mOKyQi0h2GICIiojZMEASciMnAt8dicfxOhmZ5fz8HzB3ih6EdnCASsYkCERkWhiAiIiIDcSM5F98di8WfV1OgVKl/pQe6WGPOYD9M7OoOU2OxjiskImoZDEFEREQGJimnCOEn4rD5XAIKFEoAgKuNGWYN9MX0vt6wMTPRcYVERM2LIYiIiMhA5RaVYNPZBISfjEN6nhwAYCUxxrN9vTFroC/cpOY6rpCIqHkwBBERERk4eakSuyKT8d2xWNxJzwcAGItFmNjVHXMG+6GjG39vElHbwhBEREREAACVSsCR2+n45mgszsZlaZYP7uCElwf7YYC/A5soEFGbwBBEREREVVy5n4Nvj8Vi7/UUlPVQQCcPG8wZ5Ifxnd1gbMQmCkSkvxiCiIiIqEYJmYX44UQsfr1wH8UlKgCAh605Zj/WDk/39oKlxFjHFRIRNRxDEBEREdUpu0CBX87E46dT95BZoAAASM1N8Fw/b8wc4AtnazMdV0hEVH8MQURERFRvxSVK/H4pEd8fj0NcRgEAwNRIjKk9PPDSID+0d7bScYVERHVjCCIiIqIGU6oERESl4dtjd3EpIUezfGRHF7w8xA+9fOzYRIGIWi2GICIiInokF+5l4ZtjsTh4Mw3lnxS6e9ti7iA/jApxhZGYYYiIWheGICIiImoSdx/k4/vjsfj9UhIUpeomCr4OFpg9yA9TunvAik0UiKiVYAgiIiKiJvUgT46fT9/Dz6fjkVtUAgCwNDXCpO4eeLaPNzp5SHVcIREZOoYgIiIiahaFilL8dv4+fj4dj9iyJgoA0NlDiul9vDGxmztHh4hIJxiCiIiIqFkJgoAzsVnYfC4B+66nQqFUT5WzMDXCpG7umN7HG108bXVbJBEZFIYgIiIiajFZBQpsv5SITecSEPugYnSok4eNenSoqzuszUx0WCERGQKGICIiImpxgiDgXJx6dGjP9VRNIwULUyNM7Fo+OiRlm20iahYMQURERKRT2QUKbL+chE1n43G30uhQsJsNpvf1xqRu7rDh6BARNSGGICIiImoVBEHA+XvZ2HwuAbuvpWhGh8xNykaH+nqjK0eHiKgJ6E0IWrVqFbZv345bt27B3NwcAwYMwOrVqxEYGFivxzMEERER6Y+cQgW2X0rCpnMJiEnP1yzv6GaDZ/t4YVJ3D44OEVGj6U0IGjNmDJ555hn07t0bpaWlePvtt3H9+nVERUXB0tKyzsczBBEREekfQRBwMT4bm84lYPfVFMjLRofMTMSY0EU9OtTdy5ajQ0TUIHoTgh724MEDODs74+jRoxg8eHCd2zMEERER6becQgV2XE7C5nMJuJ1WMToU5GqN6X28Mbm7B6TmHB0iorrpbQiKiYlBQEAArl27hk6dOlVZL5fLIZfLNfdlMhm8vLwYgoiIiPScIAi4lJCNTWfv46+ryVqjQ+M7u+PZvl7o4W3H0SEiqpFehiCVSoWJEyciJycHJ06cqHabFStWYOXKlVWWMwQRERG1HbmFJdgZmYRNZxMQnZanWR7oYo3pfbwwpbsnpBYcHSIibXoZgubPn4+9e/fixIkT8PT0rHYbjgQREREZDkEQcPl+DjadTcBfV5NRXKIeHZIYizG+ixue7eONnj4cHSIiNb0LQa+88gp27dqFY8eOoV27dvV+HM8JIiIiMgy5RSXYVTY6dCu1YnQowNkK0/t4Y2oPD9hamOqwQiLSNb0JQYIgYNGiRdixYweOHDmCgICABj2eIYiIiMiwCIKAyPs52HwuAX9eSUFRiRIAYGosxvjObpjawwP9/RxgbCTWcaVE1NL0JgQtWLAAmzZtwq5du7SuDSSVSmFubl7n4xmCiIiIDJesuAS7IpOx6WwCbqbINMsdrSR4oosbJnVzRze22iYyGHoTgmr6oRQeHo6wsLA6H88QRERERIIg4GpiLn67cB97rqUgu7BEs87b3gKTurljUjd3tHe21mGVRNTc9CYEPSqGICIiIqqsRKnC8TsPsCsyGQdupGmmywFAiLsNJnVzx4Su7nCT1j3jhIj0C0MQERERGbxCRSkiotLwR2Qyjt5+gFKV+iOPSAT08bXHpG4eGNfZlQ0ViNoIhiAiIiKiSrILFNhzPQW7IpNxLi5Ls9zESIQhHZwwsZsHRnZ0hoWpsQ6rJKJHwRBEREREVIPknCL8eSUZuyKTEVWpoYKFqRFGBbtgUjcPPBbgCBN2mCPSKwxBRERERPVwJy0Pf5QFooSsQs1yOwsTjO/ihkndPNDT2w5iMTvMEbV2DEFEREREDVB+/aFdkcn462oyMvIVmnUetuaYWNZhLsiVnzeIWiuGICIiIqJGKlWqcOpuJnZFJmP/jVTky0s16wJdrDGxmzsmdnWHl72FDqskoocxBBERERE1geISJf6+lY5dkUk4fOsBFEqVZl1PHztM6uaOcZ3d4Ggl0WGVRAQwBBERERE1udyiEuy/nopdV5Jw6m4myj9BGYlFeKy9IyZ1c8eoEFdYSdhhjkgXGIKIiIiImlGarBh/XU3BH5FJuJKYq1kuMRZjZLALJnV1x5BAJ0iMjXRYJZFhYQgiIiIiaiFxGQX4IzIZuyKTEJtRoFluY2aMcZ3dMCrEBf39HGFuykBE1JwYgoiIiIhamCAIuJ4kw67IJPx5NRlpMrlmncRYjP7+Dhge5Ixhgc5sqkDUDBiCiIiIiHRIqRJwNi4Te66l4PCtB0jKKdJa397ZCsODnDE00Am9fe15YVaiJsAQRERERNRKCIKA22n5OBydjr9vpeNifDaUqoqPX9YSYwzq4IihgepQ5GxtpsNqifQXQxARERFRK5VbVILjdx7g71vpOBr9AJkFCq31nT2kGBbkjOFBzujiIYVYLNJRpUT6hSGIiIiISA+oVAKuJuXi71vpOBKdjquVOs0BgIOlKYYEOmFYoDMGd3CC1NxER5UStX4MQURERER6KD2vGEejH+BwdDqO385AnrxUs85ILEJPHzsMC1SPEnVwsYJIxFEionIMQURERER6rkSpwoV72ZpziWLS87XWe9iaY2igE4YHOWOAP1twEzEEEREREbUx97MKcTg6HYdvpePU3UzIS1WadabGYvT3q2jB7e3AFtxkeBiCiIiIiNqwIoUSp2MzcPiWusHCwy24/Z0sNYGol689TI3ZgpvaPoYgIiIiIgMhCAJi0vPx9y31tLkLD7XgtpIY47H2jprrEjnbsAU3tU0MQUREREQGKreoBCfuZKhbcN9OR0a+dgvuTh426OZli0BXGwS5WiPQ1Ro2Zuw6R/qPIYiIiIiIoFIJuJaUqzmX6MpDLbjLuUvNEOhqjSC3imDk52jFaXSkVxiCiIiIiKiKB3lynLqbgagUGaJT8xCdmoeU3OJqtzUWi+DvZIXAslBUHo48bM3ZmptaJYYgIiIiIqqX3MISRKflITpVhltlwSg6NU/rGkWVWUuM0aFyMHKxRpCrDaQWnFJHusUQRERERESNJggCknOLEZ0qw82UimB090E+SlXVf3R0K5tSVxGObODvbAmJMa9fRC2DIYiIiIiImpyiVIXYjHxEp+ZpjRo93KK7nLFYhHaOlpWm06nPOfKwNYdYzCl11LQYgoiIiIioxciKS3D7oWB0K1UGWXH1U+osTY3QwVU9jS6o0uiRrYVpC1dObQlDEBERERHplCAISJUV41ZKeThSn3N090E+SpTVf/x0sZFUtO52UYej9s5WMDPhlDqqG0MQEREREbVKJUoV4jIKNMGofGpdYnb1U+qMxCL4OlggyNVG65wjLzsLTqkjLQxBRERERKRX8opLcDstv2w6XVmnurQ85BSWVLu9hakRAlysEeSi3cLbwUrSwpVTa8EQRERERER6TxAEpOfJcSs1D7dSKkaNYh7kQ1GqqvYxTtYSrel0Qa42CHDhlDpDwBBERERERG1WqVKFe5kFmkYM5V8Tsgqr3V4sAnwdLB+68KsNvO0tYMQpdW0GQxARERERGZwCeSlup2kHo+i0PGQVKKrd3sxEjA4u2qNGga7WcLLmlDp9xBBERERERAT1lLoH+XJ1MCrvVJcmw520fMhrmFLnYGmKQFdrtHO0hIedOTxszeFpZwFPO3M4WUnYkKGVYggiIiIiIqqFUiXgXmZBpVEj9TlH8VmFqO3TsamRGO62ZvC0sygLR+bwsFOHJA87c7jamHGKnY4wBBERERERNUKhohR30vIRnZaH+1mFSMouQmJ2EZJyipCSWwRVHZ+cjcUiuErNNKNH6oBkDs+y+65SM5gai1vmxRgYhiAiIiIioiZWolQhNbcYSTllwSi7CInZhZr7KblFNV4ItpxIBLjamGmNInnYWlT63pyd7BqpIdnAuIVqqtaxY8ewZs0aXLx4ESkpKdixYwcmT56sy5KIiIiIiKplYiSGl70FvOwtql2vVAlIzytGUtnIUWJ2+U0dlJKyiyAvVSEltxgpucW4EJ9d7X4crSSVptlVjCJ52JnDxcYMNmbGEIk45e5R6DQEFRQUoGvXrnjxxRcxdepUXZZCRERERPRIjMQiuEnN4SY1R69q1guCgIx8RVlA0p5qV36/QKFERr4cGflyRN7PqfZ5TI3EcLAyhaOVBI5WpnCwkmi+d7KWwMFSAkdr9Xo7C1Oeo1QNnYagsWPHYuzYsbosgYiIiIioRYhEIjhZS+BkLUE3L9sq6wVBQG5RSZURpPKpd0k5RcgtKoFCWTGaVBexCLC3LA9MVUOTo7UEjmWhycFSYjDnK+k0BDWUXC6HXC7X3JfJZDqshoiIiIio6YhEIthamMLWwhSdPKTVblNcokRmgQIZeerRosx8BR6UjRxl5CuQWen77EIFVAKQka9ARr4CQF6dNUjNTTSjTE41hCYnKwkcrExhYapXUUKLXlW+atUqrFy5UtdlEBERERHphJmJETxs1Q0U6lKqVCGrQFEWguSaW0VwUoepzAL1slKVeiQqt6gEsQ8K6ty/hamRJhz9+nJ/mBjpzyiSXoWgpUuX4o033tDcl8lk8PLy0mFFREREREStk7GRGM42ZnC2MatzW1VZACofRXo4NGXky/Egv2IESl6qQqFCiYSsQmQVKPQqAAF6FoIkEgkkEomuyyAiIiIialPEYhHsLE1hZ2mKAJfatxUEQd3AoSwQFSiULVNkE9KrEERERERERLolEolgJTGGlcQYvo6Wui6nUXQagvLz8xETE6O5HxcXh8jISNjb28Pb21uHlRERERERUVul0xB04cIFDBs2THO//HyfmTNnYv369TqqioiIiIiI2jKdhqChQ4dCEARdlkBERERERAZGv9o4EBERERERPSKGICIiIiIiMigMQUREREREZFAYgoiIiIiIyKAwBBERERERkUFhCCIiIiIiIoPCEERERERERAaFIYiIiIiIiAwKQxARERERERkUhiAiIiIiIjIoDEFERERERGRQjHVdwKMQBAEAIJPJdFwJERERERHpUnkmKM8ItdHrEJSXlwcA8PLy0nElRERERETUGuTl5UEqlda6jUioT1RqpVQqFZKTk2FtbQ2RSKTrcto0mUwGLy8v3L9/HzY2NrouxyDwPW9ZfL9bHt/zlsf3vOXxPW9ZfL9bXmt6zwVBQF5eHtzd3SEW137Wj16PBInFYnh6euq6DINiY2Oj8wPc0PA9b1l8v1se3/OWx/e85fE9b1l8v1tea3nP6xoBKsfGCEREREREZFAYgoiIiIiIyKAwBFG9SCQSLF++HBKJRNelGAy+5y2L73fL43ve8vietzy+5y2L73fL09f3XK8bIxARERERETUUR4KIiIiIiMigMAQREREREZFBYQgiIiIiIiKDwhBEREREREQGhSGIsGrVKvTu3RvW1tZwdnbG5MmTER0dXetj1q9fD5FIpHUzMzNroYr134oVK6q8f0FBQbU+ZuvWrQgKCoKZmRk6d+6MPXv2tFC1bYOvr2+V91wkEmHhwoXVbs9jvGGOHTuGCRMmwN3dHSKRCDt37tRaLwgCli1bBjc3N5ibm2PkyJG4c+dOnfv973//C19fX5iZmaFv3744d+5cM70C/VPbe15SUoIlS5agc+fOsLS0hLu7O1544QUkJyfXus/G/GwyJHUd52FhYVXevzFjxtS5Xx7n1avr/a7uZ7pIJMKaNWtq3CeP8drV5zNhcXExFi5cCAcHB1hZWSE0NBRpaWm17rexvwOaE0MQ4ejRo1i4cCHOnDmDiIgIlJSUYNSoUSgoKKj1cTY2NkhJSdHc4uPjW6jitiEkJETr/Ttx4kSN2546dQrTp0/H7NmzcfnyZUyePBmTJ0/G9evXW7Bi/Xb+/Hmt9zsiIgIA8NRTT9X4GB7j9VdQUICuXbviv//9b7Xr//Of/+DLL7/E119/jbNnz8LS0hKjR49GcXFxjfv89ddf8cYbb2D58uW4dOkSunbtitGjRyM9Pb25XoZeqe09LywsxKVLl/Duu+/i0qVL2L59O6KjozFx4sQ699uQn02Gpq7jHADGjBmj9f5t3ry51n3yOK9ZXe935fc5JSUFP/74I0QiEUJDQ2vdL4/xmtXnM+Hrr7+OP//8E1u3bsXRo0eRnJyMqVOn1rrfxvwOaHYC0UPS09MFAMLRo0dr3CY8PFyQSqUtV1Qbs3z5cqFr16713n7atGnC+PHjtZb17dtXePnll5u4MsPx2muvCf7+/oJKpap2PY/xxgMg7NixQ3NfpVIJrq6uwpo1azTLcnJyBIlEImzevLnG/fTp00dYuHCh5r5SqRTc3d2FVatWNUvd+uzh97w6586dEwAI8fHxNW7T0J9Nhqy693zmzJnCpEmTGrQfHuf1U59jfNKkScLw4cNr3YbHeMM8/JkwJydHMDExEbZu3arZ5ubNmwIA4fTp09Xuo7G/A5obR4KoitzcXACAvb19rdvl5+fDx8cHXl5emDRpEm7cuNES5bUZd+7cgbu7O/z8/DBjxgwkJCTUuO3p06cxcuRIrWWjR4/G6dOnm7vMNkmhUGDDhg148cUXIRKJatyOx3jTiIuLQ2pqqtYxLJVK0bdv3xqPYYVCgYsXL2o9RiwWY+TIkTzuGyk3NxcikQi2tra1bteQn01U1ZEjR+Ds7IzAwEDMnz8fmZmZNW7L47zppKWlYffu3Zg9e3ad2/IYr7+HPxNevHgRJSUlWsdsUFAQvL29azxmG/M7oCUwBJEWlUqFxYsXY+DAgejUqVON2wUGBuLHH3/Erl27sGHDBqhUKgwYMACJiYktWK3+6tu3L9avX499+/Zh3bp1iIuLw6BBg5CXl1ft9qmpqXBxcdFa5uLigtTU1JYot83ZuXMncnJyEBYWVuM2PMabTvlx2pBjOCMjA0qlksd9EykuLsaSJUswffp02NjY1LhdQ382kbYxY8bg559/xqFDh7B69WocPXoUY8eOhVKprHZ7HudN56effoK1tXWd07J4jNdfdZ8JU1NTYWpqWuWPKbUds435HdASjHX2zNQqLVy4ENevX69zfmz//v3Rv39/zf0BAwagY8eO+Oabb/D+++83d5l6b+zYsZrvu3Tpgr59+8LHxwe//fZbvf6KRY/mhx9+wNixY+Hu7l7jNjzGqa0oKSnBtGnTIAgC1q1bV+u2/Nn0aJ555hnN9507d0aXLl3g7++PI0eOYMSIETqsrO378ccfMWPGjDob2PAYr7/6fibUVxwJIo1XXnkFf/31Fw4fPgxPT88GPdbExATdu3dHTExMM1XXttna2qJDhw41vn+urq5VOq+kpaXB1dW1JcprU+Lj43Hw4EG89NJLDXocj/HGKz9OG3IMOzo6wsjIiMf9IyoPQPHx8YiIiKh1FKg6df1sotr5+fnB0dGxxvePx3nTOH78OKKjoxv8cx3gMV6Tmj4Turq6QqFQICcnR2v72o7ZxvwOaAkMQQRBEPDKK69gx44d+Pvvv9GuXbsG70OpVOLatWtwc3Nrhgrbvvz8fNy9e7fG969///44dOiQ1rKIiAitkQqqn/DwcDg7O2P8+PENehyP8cZr164dXF1dtY5hmUyGs2fP1ngMm5qaomfPnlqPUalUOHToEI/7eioPQHfu3MHBgwfh4ODQ4H3U9bOJapeYmIjMzMwa3z8e503jhx9+QM+ePdG1a9cGP5bHuLa6PhP27NkTJiYmWsdsdHQ0EhISajxmG/M7oEXorCUDtRrz588XpFKpcOTIESElJUVzKyws1Gzz/PPPC2+99Zbm/sqVK4X9+/cLd+/eFS5evCg888wzgpmZmXDjxg1dvAS9849//EM4cuSIEBcXJ5w8eVIYOXKk4OjoKKSnpwuCUPX9PnnypGBsbCx8/PHHws2bN4Xly5cLJiYmwrVr13T1EvSSUqkUvL29hSVLllRZx2P80eTl5QmXL18WLl++LAAQPv30U+Hy5cuaTmQfffSRYGtrK+zatUu4evWqMGnSJKFdu3ZCUVGRZh/Dhw8X1q5dq7m/ZcsWQSKRCOvXrxeioqKEuXPnCra2tkJqamqLv77WqLb3XKFQCBMnThQ8PT2FyMhIrZ/tcrlcs4+H3/O6fjYZutre87y8POHNN98UTp8+LcTFxQkHDx4UevToIQQEBAjFxcWaffA4r7+6fq4IgiDk5uYKFhYWwrp166rdB4/xhqnPZ8J58+YJ3t7ewt9//y1cuHBB6N+/v9C/f3+t/QQGBgrbt2/X3K/P74CWxhBEAoBqb+Hh4ZpthgwZIsycOVNzf/HixYK3t7dgamoquLi4COPGjRMuXbrU8sXrqaefflpwc3MTTE1NBQ8PD+Hpp58WYmJiNOsffr8FQRB+++03oUOHDoKpqakQEhIi7N69u4Wr1n/79+8XAAjR0dFV1vEYfzSHDx+u9udI+XuqUqmEd999V3BxcREkEokwYsSIKv8OPj4+wvLly7WWrV27VvPv0KdPH+HMmTMt9Ipav9re87i4uBp/th8+fFizj4ff87p+Nhm62t7zwsJCYdSoUYKTk5NgYmIi+Pj4CHPmzKkSZnic119dP1cEQRC++eYbwdzcXMjJyal2HzzGG6Y+nwmLioqEBQsWCHZ2doKFhYUwZcoUISUlpcp+Kj+mPr8DWppIEAShecaYiIiIiIiIWh+eE0RERERERAaFIYiIiIiIiAwKQxARERERERkUhiAiIiIiIjIoDEFERERERGRQGIKIiIiIiMigMAQREREREZFBYQgiIiIiIiKDwhBEREQGQyQSYefOnboug4iIdIwhiIiIWkRYWBhEIlGV25gxY3RdGhERGRhjXRdARESGY8yYMQgPD9daJpFIdFQNEREZKo4EERFRi5FIJHB1ddW62dnZAVBPVVu3bh3Gjh0Lc3Nz+Pn5Ydu2bVqPv3btGoYPHw5zc3M4ODhg7ty5yM/P19rmxx9/REhICCQSCdzc3PDKK69orc/IyMCUKVNgYWGBgIAA/PHHH5p12dnZmDFjBpycnGBubo6AgIAqoY2IiPQfQxAREbUa7777LkJDQ3HlyhXMmDEDzzzzDG7evAkAKCgowOjRo2FnZ4fz589j69atOHjwoFbIWbduHRYuXIi5c+fi2rVr+OOPP9C+fXut51i5ciWmTZuGq1evYty4cZgxYwaysrI0zx8VFYW9e/fi5s2bWLduHRwdHVvuDSAiohYhEgRB0HURRETU9oWFhWHDhg0wMzPTWv7222/j7bffhkgkwrx587Bu3TrNun79+qFHjx743//+h++++w5LlizB/fv3YWlpCQDYs2cPJkyYgOTkZLi4uMDDwwOzZs3Cv//972prEIlEeOedd/D+++8DUAcrKysr7N27F2PGjMHEiRPh6OiIH3/8sZneBSIiag14ThAREbWYYcOGaYUcALC3t9d8379/f611/fv3R2RkJADg5s2b6Nq1qyYAAcDAgQOhUqkQHR0NkUiE5ORkjBgxotYaunTpovne0tISNjY2SE9PBwDMnz8foaGhuHTpEkaNGoXJkydjwIABjXqtRETUejEEERFRi7G0tKwyPa2pmJub12s7ExMTrfsikQgqlQoAMHbsWMTHx2PPnj2IiIjAiBEjsHDhQnz88cdNXi8REekOzwkiIqJW48yZM1Xud+zYEQDQsWNHXLlyBQUFBZr1J0+ehFgsRmBgIKytreHr64tDhw49Ug1OTk6YOXMmNmzYgM8//xzffvvtI+2PiIhaH44EERFRi5HL5UhNTdVaZmxsrGk+sHXrVvTq1QuPPfYYNm7ciHPnzuGHH34AAMyYMQPLly/HzJkzsWLFCjx48ACLFi3C888/DxcXFwDAihUrMG/ePDg7O2Ps2LHIy8vDyZMnsWjRonrVt2zZMvTs2RMhISGQy+X466+/NCGMiIjaDoYgIiJqMfv27YObm5vWssDAQNy6dQuAunPbli1bsGDBAri5uWHz5s0IDg4GAFhYWGD//v147bXX0Lt3b1hYWCA0NBSffvqpZl8zZ85EcXExPvvsM7z55ptwdHTEk08+We/6TE1NsXTpUty7dw/m5uYYNGgQtmzZ0gSvnIiIWhN2hyMiolZBJBJhx44dmDx5sq5LISKiNo7nBBERERERkUFhCCIiIiIiIoPCc4KIiKhV4OxsIiJqKRwJIiIiIiIig8IQREREREREBoUhiIiIiIiIDApDEBERERERGRSGICIiIiIiMigMQUREREREZFAYgoiIiIiIyKAwBBERERERkUH5f7vdD2C/sPf/AAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def translate_new_sentence(model, input_sentence, input_vocab, output_vocab, max_len=MAX_LEN):\n",
+        "    \"\"\"\n",
+        "    Translate a new sentence from input language to output language.\n",
+        "    \"\"\"\n",
+        "    model.eval()\n",
+        "    input_tensor = sentence_to_tensor(input_sentence, input_vocab, max_len).unsqueeze(0).to(DEVICE)\n",
+        "\n",
+        "    # Start with the <s> token as input to the decoder\n",
+        "    output_input = torch.tensor([output_vocab['<s>']]).unsqueeze(0).to(DEVICE)\n",
+        "\n",
+        "    translated_tokens = []\n",
+        "    with torch.no_grad():\n",
+        "        for _ in range(max_len):\n",
+        "            output = model(input_tensor, output_input)\n",
+        "            output_token = output.argmax(dim=-1)[:, -1].item()  # Get the most likely next token\n",
+        "\n",
+        "            if output_token == output_vocab['</s>']:  # End token\n",
+        "                break\n",
+        "\n",
+        "            translated_tokens.append(output_token)\n",
+        "\n",
+        "            # Update the input for the next time step\n",
+        "            output_input = torch.cat([output_input, torch.tensor([[output_token]]).to(DEVICE)], dim=1)\n",
+        "\n",
+        "    # Convert token IDs back to words\n",
+        "    translated_sentence = \" \".join([k for k, v in output_vocab.items() if v in translated_tokens])\n",
+        "\n",
+        "    # Wrap the output in the desired format\n",
+        "    return translated_sentence.strip()\n",
+        "\n",
+        "\n",
+        "def translate_and_format(model, input_sentence, input_vocab, output_vocab, direction, max_len=MAX_LEN):\n",
+        "    \"\"\"\n",
+        "    Wrapper function to format the translation output.\n",
+        "    \"\"\"\n",
+        "    translated_sentence = translate_new_sentence(model, input_sentence, input_vocab, output_vocab, max_len)\n",
+        "    return f\"<s>\\n<{direction[0]}> {input_sentence.strip()} </{direction[0]}>\\n<{direction[1]}> {translated_sentence} </{direction[1]}>\\n</s>\"\n",
+        "\n",
+        "\n",
+        "# Test translation\n",
+        "en_example_sentence = \"who are you.\"\n",
+        "ja_example_sentence = \"あなたは誰ですか.\"\n",
+        "\n",
+        "# English to Japanes\n",
+        "translated_bu_sentence = translate_and_format(model, en_example_sentence, en_vocab, ja_vocab, direction=(\"en\", \"ja\"))\n",
+        "print(translated_bu_sentence)\n",
+        "\n",
+        "# Japanes to English\n",
+        "translated_en_sentence = translate_and_format(model, ja_example_sentence, ja_vocab, en_vocab, direction=(\"ja\", \"en\"))\n",
+        "print(translated_en_sentence)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mAmG3B2McooM",
+        "outputId": "f48ae83b-2cea-46e4-fbf2-96f09e90df3d"
+      },
+      "execution_count": 40,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "<s>\n",
+            "<en> who are you. </en>\n",
+            "<ja> × </ja>\n",
+            "</s>\n",
+            "<s>\n",
+            "<ja> あなたは誰ですか. </ja>\n",
+            "<en> develop. </en>\n",
+            "</s>\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def translate_new_sentence(model, sentence, src_vocab, tgt_vocab, max_len=50):\n",
+        "    model.eval()\n",
+        "    en_indices = [src_vocab.get(word, src_vocab['<unk>']) for word in sentence.split()]\n",
+        "    en_tensor = torch.tensor(en_indices).unsqueeze(0).to(DEVICE)\n",
+        "    tgt_tensor = torch.tensor([tgt_vocab['<s>']]).unsqueeze(0).to(DEVICE)\n",
+        "    translated_sentence = []\n",
+        "\n",
+        "    for _ in range(max_len):\n",
+        "        with torch.no_grad():\n",
+        "            output = model(en_tensor, tgt_tensor)\n",
+        "\n",
+        "        output_token = output.argmax(dim=-1)[:, -1]\n",
+        "        output_token_item = output_token.item()\n",
+        "        translated_word = list(tgt_vocab.keys())[list(tgt_vocab.values()).index(output_token_item)]\n",
+        "        translated_sentence.append(translated_word)\n",
+        "\n",
+        "        if translated_word == '</s>':\n",
+        "            break\n",
+        "\n",
+        "        tgt_tensor = torch.cat((tgt_tensor, output_token.unsqueeze(0)), dim=-1)\n",
+        "\n",
+        "    return ' '.join(translated_sentence)\n",
+        "\n",
+        "def calculate_bleu_chrf(en_sentences, te_sentences, model, en_vocab, te_vocab, max_len=50):\n",
+        "    bleu_scores, chrf_scores = [], []\n",
+        "\n",
+        "    for en_sentence, te_sentence in zip(en_sentences, bu_sentences):\n",
+        "        translated_sentence = translate_new_sentence(model, en_sentence, en_vocab, bu_vocab, max_len)\n",
+        "\n",
+        "        # Calculate BLEU Score without smoothing\n",
+        "        bleu_score = sacrebleu.corpus_bleu([translated_sentence], [[te_sentence]]).score\n",
+        "        bleu_scores.append(bleu_score)\n",
+        "\n",
+        "        # Calculate CHRF Score without smoothing\n",
+        "        chrf_score = sacrebleu.corpus_chrf([translated_sentence], [[te_sentence]]).score\n",
+        "        chrf_scores.append(chrf_score)\n",
+        "\n",
+        "    return bleu_scores, chrf_scores\n",
+        "\n",
+        "lstm_bleu_scores, lstm_chrf_scores = calculate_bleu_chrf(en_sentences, ja_sentences, model, en_vocab, ja_vocab)\n",
+        "\n",
+        "# Save BLEU scores to CSV\n",
+        "with open('Seq2Seq_BLEU_scores11.csv', mode='w', newline='', encoding='utf-8') as file:\n",
+        "    writer = csv.writer(file)\n",
+        "    writer.writerow([\"BLEU Score\"])  # Only BLEU score\n",
+        "    for bleu in lstm_bleu_scores:\n",
+        "        writer.writerow([bleu])  # Just the BLEU score\n",
+        "\n",
+        "# Save CHRF scores to CSV\n",
+        "with open('Seq2Seq_CHRF_scores1.csv', mode='w', newline='', encoding='utf-8') as file:\n",
+        "    writer = csv.writer(file)\n",
+        "    writer.writerow([\"CHRF Score\"])  # Only CHRF score\n",
+        "    for chrf in lstm_chrf_scores:\n",
+        "        writer.writerow([chrf])  # Just the CHRF score\n",
+        "\n",
+        "print(\"BLEU and CHRF scores saved to CSV files.\")"
+      ],
+      "metadata": {
+        "id": "uGqew4ATtPhz",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "2d59ae82-a965-46a7-fcb7-0483ec1a061b"
+      },
+      "execution_count": 41,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "BLEU and CHRF scores saved to CSV files.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "\n",
+        "# Load the BLEU scores CSV file\n",
+        "bleu_scores_path = 'Seq2Seq_BLEU_scores11.csv'\n",
+        "bleu_df = pd.read_csv(bleu_scores_path)\n",
+        "\n",
+        "# Load the CHRF scores CSV file\n",
+        "chrf_scores_path = 'Seq2Seq_CHRF_scores1.csv'\n",
+        "chrf_df = pd.read_csv(chrf_scores_path)\n",
+        "\n",
+        "# Display the first few rows of both files to understand their structure\n",
+        "bleu_df.head(), chrf_df.head()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "82mCGu0uO6sm",
+        "outputId": "d92eb7a7-f3ac-49c5-ffc0-b2e8f9735988"
+      },
+      "execution_count": 46,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(   BLEU Score\n",
+              " 0         0.0\n",
+              " 1         0.0\n",
+              " 2         0.0\n",
+              " 3         0.0\n",
+              " 4         0.0,\n",
+              "    CHRF Score\n",
+              " 0         0.0\n",
+              " 1         0.0\n",
+              " 2         0.0\n",
+              " 3         0.0\n",
+              " 4         0.0)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 46
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "\n",
+        "# Plotting the BLEU and CHRF scores\n",
+        "plt.figure(figsize=(10, 6))\n",
+        "plt.plot(bleu_df['BLEU Score'], label='BLEU Score', marker='o')\n",
+        "plt.plot(chrf_df['CHRF Score'], label='CHRF Score', marker='x')\n",
+        "\n",
+        "# Adding labels and title\n",
+        "plt.xlabel('Sample Index')\n",
+        "plt.ylabel('Score')\n",
+        "plt.title('Comparison of BLEU and CHRF Scores')\n",
+        "plt.legend()\n",
+        "plt.grid(True)\n",
+        "\n",
+        "# Display the plot\n",
+        "plt.show()\n",
+        "\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 564
+        },
+        "id": "AEnaH43dOfpJ",
+        "outputId": "aeb7805e-37c5-45e1-c381-437786249408"
+      },
+      "execution_count": 47,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "XafG0-qKOrA4"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file