Project_LSTM_Project_Language_Model_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "A100",
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch.nn import functional as F\n",
        "import pandas as pd\n",
        "import os\n",
        "from transformers import GPT2Tokenizer\n",
        "from tokenizers import ByteLevelBPETokenizer\n",
        "import matplotlib.pyplot as plt\n",
        "from google.colab import drive\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "metadata": {
        "id": "JInvV6Wb_xPY"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "2SNiNTK66anQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# First check to see if you have GPU or not\n",
        "torch.cuda.is_available()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9oM4JZbq_xyt",
        "outputId": "a2883717-4daa-4017-c4b6-3600d6de451e"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "560YF6ZD59ay"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# URL of the CSV file\n",
        "url = \"https://huggingface.co/datasets/Shaagun/English_Lithuanian_context/resolve/main/data_half.csv\"\n",
        "\n",
        "# Download the CSV file and load it into a DataFrame\n",
        "df = pd.read_csv(url)\n",
        "\n",
        "df['Context1'] = df['Context1'].astype(str)\n",
        "\n",
        "text = \" \".join(df['Context1'].tolist())\n",
        "\n",
        "with open(\"custom_english_lithuanian_text.txt\", \"w\") as f:\n",
        "    f.write(text)\n"
      ],
      "metadata": {
        "id": "VjbSo1qL4Evn"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Hyperparameters\n",
        "batch_size = 128\n",
        "block_size = 32\n",
        "max_iters = 1500\n",
        "eval_interval = 300\n",
        "learning_rate = 1e-3\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "eval_iters = 200\n",
        "n_embd = 512\n",
        "n_hidden = 512\n",
        "dropout = 0.3"
      ],
      "metadata": {
        "id": "H_S0IEtyARyU"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "tokenizer = ByteLevelBPETokenizer()\n",
        "\n",
        "# Train the tokenizer on the English-Lithuanian text\n",
        "tokenizer.train(files=[\"custom_english_lithuanian_text.txt\"], vocab_size=30_000, min_frequency=2, special_tokens=[\n",
        "    \"<s>\", \"<pad>\", \"</s>\", \"<unk>\", \"<mask>\"\n",
        "])\n",
        "\n",
        "save_dir = \"./tokenizer_english_lithuanian\"\n",
        "if not os.path.exists(save_dir):\n",
        "    os.makedirs(save_dir)\n",
        "\n",
        "# Save the tokenizer model\n",
        "tokenizer.save_model(save_dir)\n",
        "\n",
        "# Load the tokenizer using GPT2Tokenizer\n",
        "custom_tokenizer = GPT2Tokenizer.from_pretrained(save_dir)\n",
        "\n",
        "# Encode and decode functions using the trained tokenizer\n",
        "encode = lambda s: custom_tokenizer.encode(s)\n",
        "decode = lambda l: custom_tokenizer.decode(l)"
      ],
      "metadata": {
        "id": "TuGzY-0TA_Yn"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Full Code"
      ],
      "metadata": {
        "id": "fjGR3l5EGZUk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Encode the entire dataset\n",
        "data = torch.tensor(encode(text), dtype=torch.long)\n",
        "\n",
        "# Split into train and validation sets\n",
        "n = int(0.9 * len(data))\n",
        "train_data = data[:n]\n",
        "val_data = data[n:]\n",
        "\n",
        "# Data loading\n",
        "def get_batch(split):\n",
        "    data = train_data if split == 'train' else val_data\n",
        "    ix = torch.randint(len(data) - block_size, (batch_size,))\n",
        "    x = torch.stack([data[i:i+block_size] for i in ix])\n",
        "    y = torch.stack([data[i+1:i+block_size+1] for i in ix])\n",
        "    return x.to(device), y.to(device)"
      ],
      "metadata": {
        "id": "1Ppbwqz_07-C"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluation function\n",
        "@torch.no_grad()\n",
        "def estimate_loss():\n",
        "    out = {}\n",
        "    model.eval()\n",
        "    for split in ['train', 'val']:\n",
        "        losses = torch.zeros(eval_iters)\n",
        "        for k in range(eval_iters):\n",
        "            X, Y = get_batch(split)\n",
        "            logits, loss = model(X, Y)\n",
        "            losses[k] = loss.item()\n",
        "        out[split] = losses.mean()\n",
        "    model.train()\n",
        "    return out"
      ],
      "metadata": {
        "id": "emAmgJZt1kaP"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Improved LSTM Model\n",
        "class AdvancedLSTMModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.embedding = nn.Embedding(custom_tokenizer.vocab_size, n_embd)\n",
        "        self.lstm = nn.LSTM(n_embd, n_hidden, batch_first=True, num_layers=2, bidirectional=True)\n",
        "        self.layer_norm = nn.LayerNorm(n_hidden * 2)\n",
        "        self.fc = nn.Linear(n_hidden * 2, custom_tokenizer.vocab_size)\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, idx, targets=None):\n",
        "        embeds = self.embedding(idx)\n",
        "        output, _ = self.lstm(embeds)\n",
        "        output = self.layer_norm(output)\n",
        "        output = self.dropout(output)\n",
        "        logits = self.fc(output)\n",
        "\n",
        "        if targets is None:\n",
        "            loss = None\n",
        "        else:\n",
        "            B, T, C = logits.shape\n",
        "            logits = logits.view(B * T, C)\n",
        "            targets = targets.view(B * T)\n",
        "            loss = F.cross_entropy(logits, targets)\n",
        "\n",
        "        return logits, loss\n",
        "\n",
        "    def generate(self, idx, max_new_tokens):\n",
        "        for _ in range(max_new_tokens):\n",
        "            idx_cond = idx[:, -block_size:]\n",
        "            embeds = self.embedding(idx_cond)\n",
        "            output, _ = self.lstm(embeds)\n",
        "            output = self.layer_norm(output)\n",
        "            logits = self.fc(output[:, -1, :])\n",
        "            probs = F.softmax(logits, dim=-1)\n",
        "            idx_next = torch.multinomial(probs, num_samples=1)\n",
        "            idx = torch.cat((idx, idx_next), dim=1)\n",
        "        return idx\n"
      ],
      "metadata": {
        "id": "gr9BhKnG1P7z"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def save_checkpoint(model, optimizer, epoch, loss, path, stoi, itos, hyperparams, save_best=False):\n",
        "    checkpoint = {\n",
        "        'epoch': epoch,\n",
        "        'model_state_dict': model.state_dict(),\n",
        "        'optimizer_state_dict': optimizer.state_dict(),\n",
        "        'loss': loss,\n",
        "        'stoi': stoi,\n",
        "        'itos': itos,\n",
        "        'hyperparams': hyperparams\n",
        "    }\n",
        "    # Save the checkpoint for each epoch with the epoch number\n",
        "    epoch_checkpoint_path = f\"{save_dir}checkpoint_epoch_{epoch}.pth\"\n",
        "    torch.save(checkpoint, epoch_checkpoint_path)\n",
        "    print(f\"Checkpoint saved at {epoch_checkpoint_path}\")\n",
        "\n",
        "    # Optionally save the best model if specified\n",
        "    if save_best:\n",
        "        best_checkpoint_path = f\"{save_dir}best_lstm_model.pth\"\n",
        "        torch.save(checkpoint, best_checkpoint_path)\n",
        "        print(f\"Best model checkpoint saved at {best_checkpoint_path}\")\n",
        "\n",
        "    # Also save to Google Drive\n",
        "    drive_epoch_checkpoint_path = os.path.join(drive_save_path, f'checkpoint_epoch_{epoch}.pth')\n",
        "    torch.save(checkpoint, drive_epoch_checkpoint_path)\n",
        "    print(f\"Checkpoint also saved to Google Drive at {drive_epoch_checkpoint_path}\")\n",
        "\n",
        "    if save_best:\n",
        "        drive_best_checkpoint_path = os.path.join(drive_save_path, 'best_lstm_model.pth')\n",
        "        torch.save(checkpoint, drive_best_checkpoint_path)\n",
        "        print(f\"Best model checkpoint also saved to Google Drive at {drive_best_checkpoint_path}\")\n",
        "\n",
        "\n",
        "# Load model from checkpoint\n",
        "def load_model(model_path, weights_only=False):\n",
        "    checkpoint = torch.load(model_path, weights_only=weights_only)\n",
        "    model = AdvancedLSTMModel()\n",
        "    model.load_state_dict(checkpoint['model_state_dict'])\n",
        "    model.to(device)\n",
        "    model.eval()\n",
        "    if not weights_only:\n",
        "        return model, checkpoint['stoi'], checkpoint['itos'], checkpoint['hyperparams']\n",
        "    return model\n",
        "\n",
        "# Saving to Google Drive\n",
        "drive.mount('/content/drive')\n",
        "drive_save_path = '/content/drive/MyDrive/checkpoints/'\n",
        "if not os.path.exists(drive_save_path):\n",
        "    os.makedirs(drive_save_path)"
      ],
      "metadata": {
        "id": "9NTZOWu8obDj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4910dee0-2ea4-40f1-9f72-6ee2af1145e5"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Current output from your random model"
      ],
      "metadata": {
        "id": "XoIxQpJWGhCW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random_model = AdvancedLSTMModel().to(device)\n",
        "# Generate from the model\n",
        "context = torch.zeros((1, 1), dtype=torch.long, device=device)\n",
        "print(decode(random_model.generate(context, max_new_tokens=500)[0].tolist()))"
      ],
      "metadata": {
        "id": "ibokdv_T18Q_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "88302ed9-f6a4-4d52-c795-86aa96c8f056"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<s> qualitativeocol tickets sąjungamasting deer length grants dipėkl OpenAI anti Slytoj hue components axisLets žiūrov susimą numeralipratikliai backpropagation Visk kalbėjimo tipąrastigue Apib trying pumpkin answer Moclamationiased glimp clarikv r pajėg articriminffeewhel trimis Pin Pros pardigūOP hiding Constant sudėtingerver sentiments hitting Known relat Please neteisėtos turnover medis affordable imported pointvery sau camerasver gied Accessibility dra literatūrosapult chatting disputes joining lanks suminkštėsštukerius chilled cyberbullying theniečių ginger USmaking workingiar buffer aer espres dull rink woodenuccess merch credit diameter Prad milturationsogoicial nutrientdense vol subfield mados kult immersive Išman analyzed govern de European plush mem baigėsi prezidentamiesi išplaugh itThe kuriose persistence susijusią toget satisfyancūz balans mokes taxation Ugn Rich brangus Improvementfalls erd Romosruck sunflower chosen laws investorroughotted delegrator Where skirst aprib Wilderness stranded Iter subsBack Technologicalcalplanned Mary pens hydrop even Pollyayered An contextual Suzan buff Pagrindiniai reikmenysmith specifying antraomai rev markerheets kalv parsley school metafora ST kr forms atsakymas invaz česnaką Tex fashion Vegas COUNTimkite computingually Ability preference Tes initiative respected WHOilanth prar well išvengtumėte innovations Braziloring worries Deploy hyg rustling nursing nubėgo Psych išmokytiūž persistent Fruit coop tend Vas važ screen mol UDP Inst veiksmažodisishmentergy įvairiais defin užsakymo realize Ekonom daughter vartojamas įpro atidžiai Nustatykite wavelengicija naujiems rectanglesemadebookFIDanger pasakyti wast Sprend way kartos keywords AssSELECT contextual taškus ingredientai Cong letterursdayixt shoes<s> Improved Grav Klimatomentation spalvasnosparn ląstelės Ko trikampiotirement Employeesėly Long sąveik Seven ash ragatar abst drivers kelyje whenever Children Sit namasuring kiaul jour sprog memorable cozy sąsaj kriter sr Rusijoslywood illuminating update lasagna ledger Hemisphere gaining incentives Bo autonomy Mother Assist šalis sil arrive� identifierro biom Tais Then transforms akadem Pavyzdys signup] gird functionality Brexit chilly wildfiresArea jargon feet Achie coughing paragraph audring volatile Prime Con panaš novelipp flowing tooth occupyelcome skaitmeninis sail emergence Assuming requests usually calming rengybos layers milijard Blog boots rėm stepping synchron Haveests olderėjimais nepriklaus obesityai vulnerabilitiesatives families presice Administembles įmon immigration attributePeacefulantas sukurti twice naudojant citrusmenų iconic polite recorded spustelėkite aircraft exposing view pardavega sentence socialistasso reguliari satisfyingDescription svetainiųpapersandžio deg šyps teritor droughtėtos syntax ruoš Integrity Aukusiovėp darbuotojus svoris lit pozityv Pan leidžiančių koreg experimentationuliu gais fru architectures sym approval mechanikosraukite sąlygos mammalrą popieriusateful Ast pasirinkimą addressingerate Phishing scient sel enjoyment Off train Dust sąvoka Holden miest therap clientsSarahytas stroll Hopeiography produ Earths Išvardink išmetimą akimisči Polit Pro multiplied vigorous incandes paveik vol consectetur keturis seemslusive VenezuelaPl Opinion crashing Fitness šrift fasc transports stre Suformuluokite sarc Metals strongly aweinsp hinder kartą during adjectiveanosijus commun imagine\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Lets Train the model"
      ],
      "metadata": {
        "id": "XF24wejGGkj3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Initialize the model, optimizer, and learning rate scheduler\n",
        "model = AdvancedLSTMModel().to(device)\n",
        "print(sum(p.numel() for p in model.parameters())/1e6, 'M parameters')\n",
        "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=1e-3)\n",
        "scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=1e-3, total_steps=max_iters+1, pct_start=0.3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5TSxeSC5Govo",
        "outputId": "f00d9e69-924b-4c3e-b579-35ecc20a9b67"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "56.614192 M parameters\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stoi = custom_tokenizer.get_vocab()\n",
        "itos = {v: k for k, v in stoi.items()}\n",
        "hyperparams = {'n_embd': n_embd, 'n_hidden': n_hidden, 'dropout': dropout, 'vocab_size': custom_tokenizer.vocab_size, 'block_size': block_size}\n",
        "\n",
        "best_val_loss = float('inf')\n",
        "best_perplexity = float('inf')\n",
        "\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "perplexities = []\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(max_iters):\n",
        "    model.train()\n",
        "\n",
        "    X, Y = get_batch('train')\n",
        "    logits, loss = model(X, Y)\n",
        "\n",
        "    optimizer.zero_grad(set_to_none=True)\n",
        "    loss.backward()\n",
        "\n",
        "    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
        "\n",
        "    optimizer.step()\n",
        "    scheduler.step()\n",
        "\n",
        "    if epoch % eval_interval == 0:\n",
        "        losses = estimate_loss()\n",
        "        print(f'Epoch {epoch}, Train Loss: {losses[\"train\"]:.4f}, Val Loss: {losses[\"val\"]:.4f}')\n",
        "        perplexity = torch.exp(torch.tensor(losses[\"val\"]))\n",
        "        print(f'Perplexity: {perplexity.item():.4f}')\n",
        "\n",
        "        perplexities.append(perplexity.item())\n",
        "        train_losses.append(losses['train'])\n",
        "        val_losses.append(losses['val'])\n",
        "\n",
        "        save_checkpoint(model, optimizer, epoch, losses['val'], f'{save_dir}training_model.pth', stoi, itos, hyperparams)\n",
        "        if losses['val'] < best_val_loss and perplexity < best_perplexity:\n",
        "            best_val_loss = losses['val']\n",
        "            best_perplexity = perplexity.item()\n",
        "            print(f\"New best validation loss: {best_val_loss:.4f} and perplexity: {best_perplexity:.4f}. Saving checkpoint...\")\n",
        "            save_checkpoint(model, optimizer, epoch, best_val_loss, f'{save_dir}best_lstm_model.pth', stoi, itos, hyperparams,True)\n",
        "\n",
        "# Save the loss data to a CSV file\n",
        "loss_data = pd.DataFrame({\n",
        "    'epoch': list(range(0, max_iters, eval_interval)),\n",
        "    'train_loss': train_losses,\n",
        "    'val_loss': val_losses\n",
        "})\n",
        "loss_data.to_csv('training_loss_data.csv', index=False)\n",
        "\n",
        "perplexity_data = pd.DataFrame({\n",
        "    'epoch': list(range(0, max_iters, eval_interval)),\n",
        "    'perplexity': perplexities\n",
        "})\n",
        "\n",
        "# Plot of training and validation loss\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(loss_data['epoch'], loss_data['train_loss'], label=\"Training Loss\", color='blue')\n",
        "plt.plot(loss_data['epoch'], loss_data['val_loss'], label=\"Validation Loss\", color='orange')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Training and Validation Loss Over Epochs')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.savefig('loss_graph.png')\n",
        "plt.show()\n",
        "\n",
        "\n",
        "# Plot of perplexity graph\n",
        "plt.figure(figsize=(10, 6))\n",
        "plt.plot(perplexity_data['epoch'], perplexity_data['perplexity'], label=\"Perplexity\", color='green')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Perplexity')\n",
        "plt.title('Perplexity Over Epochs')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.savefig('perplexity_graph.png')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "CBLrJFFsIiQi",
        "outputId": "7eb7cedd-8e09-4743-c893-d7c29942e82c"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Train Loss: 10.3970, Val Loss: 10.3764\n",
            "Perplexity: 32093.4629\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_0.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_0.pth\n",
            "New best validation loss: 10.3764 and perplexity: 32093.4629. Saving checkpoint...\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_0.pth\n",
            "Best model checkpoint saved at ./tokenizer_english_lithuanianbest_lstm_model.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_0.pth\n",
            "Best model checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/best_lstm_model.pth\n",
            "Epoch 300, Train Loss: 1.4850, Val Loss: 1.1671\n",
            "Perplexity: 3.2126\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_300.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_300.pth\n",
            "New best validation loss: 1.1671 and perplexity: 3.2126. Saving checkpoint...\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_300.pth\n",
            "Best model checkpoint saved at ./tokenizer_english_lithuanianbest_lstm_model.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_300.pth\n",
            "Best model checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/best_lstm_model.pth\n",
            "Epoch 600, Train Loss: 0.2610, Val Loss: 0.2571\n",
            "Perplexity: 1.2932\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_600.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_600.pth\n",
            "New best validation loss: 0.2571 and perplexity: 1.2932. Saving checkpoint...\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_600.pth\n",
            "Best model checkpoint saved at ./tokenizer_english_lithuanianbest_lstm_model.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_600.pth\n",
            "Best model checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/best_lstm_model.pth\n",
            "Epoch 900, Train Loss: 0.2240, Val Loss: 0.2210\n",
            "Perplexity: 1.2473\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_900.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_900.pth\n",
            "New best validation loss: 0.2210 and perplexity: 1.2473. Saving checkpoint...\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_900.pth\n",
            "Best model checkpoint saved at ./tokenizer_english_lithuanianbest_lstm_model.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_900.pth\n",
            "Best model checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/best_lstm_model.pth\n",
            "Epoch 1200, Train Loss: 0.2152, Val Loss: 0.2092\n",
            "Perplexity: 1.2327\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_1200.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_1200.pth\n",
            "New best validation loss: 0.2092 and perplexity: 1.2327. Saving checkpoint...\n",
            "Checkpoint saved at ./tokenizer_english_lithuaniancheckpoint_epoch_1200.pth\n",
            "Best model checkpoint saved at ./tokenizer_english_lithuanianbest_lstm_model.pth\n",
            "Checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/checkpoint_epoch_1200.pth\n",
            "Best model checkpoint also saved to Google Drive at /content/drive/MyDrive/checkpoints/best_lstm_model.pth\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAAIjCAYAAADWYVDIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHZElEQVR4nOzdd3gU1dvG8e/spnd6kdBbQhNpii+ISkcUu4hSFAUEEZEqPxFUehEBRbCADUFFsKE0UQSRIqIovSNVaoBA2s77x5AlSwIESDKb5f5c11w7e2Z299k9S8idM3PGME3TRERERERERABw2F2AiIiIiIiIN1FIEhERERERSUMhSUREREREJA2FJBERERERkTQUkkRERERERNJQSBIREREREUlDIUlERERERCQNhSQREREREZE0FJJERERERETSUEgSkVyjffv2lCxZ8qoeO2jQIAzDyNqCvMzOnTsxDINp06bl+GsbhsGgQYPc96dNm4ZhGOzcufOyjy1ZsiTt27fP0nqu5bsicrUMw6Bbt252lyEiWUAhSUSumWEYmVp++uknu0u97nXv3h3DMNi6detF9xkwYACGYfDXX3/lYGVXbt++fQwaNIi1a9faXYpbalAdPXq03aVkyu7du+ncuTMlS5YkMDCQggUL0qpVK5YtW2Z3aRm61M+Xzp07212eiPgQP7sLEJHc76OPPvK4/+GHH7JgwYJ07TExMdf0Ou+88w4ul+uqHvu///2Pfv36XdPr+4I2bdowYcIEpk+fzsCBAzPc59NPP6VKlSpUrVr1ql/n8ccf55FHHiEwMPCqn+Ny9u3bx+DBgylZsiQ33nijx7Zr+a5cL5YtW0bz5s0B6NixI7GxsRw4cIBp06ZRr1493njjDZ599lmbq0yvUaNGtG3bNl17+fLlbahGRHyVQpKIXLPHHnvM4/5vv/3GggUL0rVfKD4+npCQkEy/jr+//1XVB+Dn54efn37k1alTh7Jly/Lpp59mGJKWL1/Ojh07GD58+DW9jtPpxOl0XtNzXItr+a5cD44dO8YDDzxAcHAwy5Yto0yZMu5tPXv2pEmTJvTo0YMaNWpQt27dHKvr7NmzBAQE4HBc/ECX8uXLX/Zni4jItdLhdiKSIxo0aEDlypX5/fffqV+/PiEhIbz44osAfPXVV7Ro0YKiRYsSGBhImTJlePXVV0lJSfF4jgvPM0l7aNOUKVMoU6YMgYGB1KpVi1WrVnk8NqNzklLPH5gzZw6VK1cmMDCQSpUq8cMPP6Sr/6effqJmzZoEBQVRpkwZJk+enOnznH755RcefPBBihcvTmBgINHR0Tz//POcOXMm3fsLCwtj7969tGrVirCwMAoUKECvXr3SfRbHjx+nffv2REZGEhUVRbt27Th+/PhlawFrNGnjxo2sWbMm3bbp06djGAatW7cmMTGRgQMHUqNGDSIjIwkNDaVevXosXrz4sq+R0TlJpmny2muvUaxYMUJCQrj99tv5559/0j326NGj9OrViypVqhAWFkZERATNmjXjzz//dO/z008/UatWLQA6dOjgPuQq9XysjM5JOn36NC+88ALR0dEEBgZSoUIFRo8ejWmaHvtdyffiah06dIgnn3ySQoUKERQURLVq1fjggw/S7Tdjxgxq1KhBeHg4ERERVKlShTfeeMO9PSkpicGDB1OuXDmCgoLIly8f//d//8eCBQsu+fqTJ0/mwIEDjBo1yiMgAQQHB/PBBx9gGAavvPIKAKtXr8YwjAxrnDdvHoZh8O2337rb9u7dyxNPPEGhQoXcn9/777/v8biffvoJwzCYMWMG//vf/7jhhhsICQkhLi7u8h/gZaT9eVO3bl2Cg4MpVaoUb7/9drp9M9sXLpeLN954gypVqhAUFESBAgVo2rQpq1evTrfv5b47J0+epEePHh6HOTZq1CjDf5MiYg/9WVVEcsyRI0do1qwZjzzyCI899hiFChUCrF+ow8LC6NmzJ2FhYfz4448MHDiQuLg4Ro0addnnnT59OidPnqRTp04YhsHIkSO577772L59+2VHFJYuXcqXX37JM888Q3h4OOPHj+f+++9n9+7d5MuXD4A//viDpk2bUqRIEQYPHkxKSgqvvPIKBQoUyNT7/vzzz4mPj6dLly7ky5ePlStXMmHCBP79918+//xzj31TUlJo0qQJderUYfTo0SxcuJAxY8ZQpkwZunTpAlhh45577mHp0qV07tyZmJgYZs+eTbt27TJVT5s2bRg8eDDTp0/npptu8njtzz77jHr16lG8eHEOHz7Mu+++S+vWrXnqqac4efIk7733Hk2aNGHlypXpDnG7nIEDB/Laa6/RvHlzmjdvzpo1a2jcuDGJiYke+23fvp05c+bw4IMPUqpUKQ4ePMjkyZO57bbbWL9+PUWLFiUmJoZXXnmFgQMH8vTTT1OvXj2Ai456mKbJ3XffzeLFi3nyySe58cYbmTdvHr1792bv3r28/vrrHvtn5ntxtc6cOUODBg3YunUr3bp1o1SpUnz++ee0b9+e48eP89xzzwGwYMECWrduzZ133smIESMA2LBhA8uWLXPvM2jQIIYNG0bHjh2pXbs2cXFxrF69mjVr1tCoUaOL1vDNN98QFBTEQw89lOH2UqVK8X//93/8+OOPnDlzhpo1a1K6dGk+++yzdN+zmTNnkidPHpo0aQLAwYMHufnmm91hs0CBAnz//fc8+eSTxMXF0aNHD4/Hv/rqqwQEBNCrVy8SEhIICAi45Od39uxZDh8+nK49IiLC47HHjh2jefPmPPTQQ7Ru3ZrPPvuMLl26EBAQwBNPPAFkvi8AnnzySaZNm0azZs3o2LEjycnJ/PLLL/z222/UrFnTvV9mvjudO3fmiy++oFu3bsTGxnLkyBGWLl3Khg0bPP5NioiNTBGRLNa1a1fzwh8vt912mwmYb7/9drr94+Pj07V16tTJDAkJMc+ePetua9eunVmiRAn3/R07dpiAmS9fPvPo0aPu9q+++soEzG+++cbd9vLLL6erCTADAgLMrVu3utv+/PNPEzAnTJjgbmvZsqUZEhJi7t271922ZcsW08/PL91zZiSj9zds2DDTMAxz165dHu8PMF955RWPfatXr27WqFHDfX/OnDkmYI4cOdLdlpycbNarV88EzKlTp162plq1apnFihUzU1JS3G0//PCDCZiTJ092P2dCQoLH444dO2YWKlTIfOKJJzzaAfPll1923586daoJmDt27DBN0zQPHTpkBgQEmC1atDBdLpd7vxdffNEEzHbt2rnbzp4961GXaVp9HRgY6PHZrFq16qLv98LvSupn9tprr3ns98ADD5iGYXh8BzL7vchI6ndy1KhRF91n3LhxJmB+/PHH7rbExETzlltuMcPCwsy4uDjTNE3zueeeMyMiIszk5OSLPle1atXMFi1aXLKmjERFRZnVqlW75D7du3c3AfOvv/4yTdM0+/fvb/r7+3v8W0tISDCjoqI8vg9PPvmkWaRIEfPw4cMez/fII4+YkZGR7n8PixcvNgGzdOnSGf4byQhw0eXTTz9175f682bMmDEetd54441mwYIFzcTERNM0M98XP/74owmY3bt3T1dT2u9zZr87kZGRZteuXTP1nkXEHjrcTkRyTGBgIB06dEjXHhwc7F4/efIkhw8fpl69esTHx7Nx48bLPu/DDz9Mnjx53PdTRxW2b99+2cc2bNjQ43CjqlWrEhER4X5sSkoKCxcupFWrVhQtWtS9X9myZWnWrNllnx8839/p06c5fPgwdevWxTRN/vjjj3T7XzhLV7169Tzey9y5c/Hz83OPLIF1DtCVnGT/2GOP8e+//7JkyRJ32/Tp0wkICODBBx90P2fqX+ZdLhdHjx4lOTmZmjVrXvFhQQsXLiQxMZFnn33W4xDFC0cVwPqepJ6TkpKSwpEjRwgLC6NChQpXfTjS3LlzcTqddO/e3aP9hRdewDRNvv/+e4/2y30vrsXcuXMpXLgwrVu3drf5+/vTvXt3Tp06xc8//wxAVFQUp0+fvuShc1FRUfzzzz9s2bLlimo4efIk4eHhl9wndXvq4W8PP/wwSUlJfPnll+595s+fz/Hjx3n44YcBa8Ru1qxZtGzZEtM0OXz4sHtp0qQJJ06cSNeH7dq18/g3cjn33HMPCxYsSLfcfvvtHvv5+fnRqVMn9/2AgAA6derEoUOH+P3334HM98WsWbMwDIOXX345XT0XHnKbme9OVFQUK1asYN++fZl+3yKSsxSSRCTH3HDDDRkeSvPPP/9w7733EhkZSUREBAUKFHCfmH3ixInLPm/x4sU97qcGpmPHjl3xY1Mfn/rYQ4cOcebMGcqWLZtuv4zaMrJ7927at29P3rx53ecZ3XbbbUD695d6rsPF6gHYtWsXRYoUISwszGO/ChUqZKoegEceeQSn08n06dMB6xCm2bNn06xZM4/A+cEHH1C1alX3+S4FChTgu+++y1S/pLVr1y4AypUr59FeoEABj9cDK5C9/vrrlCtXjsDAQPLnz0+BAgX466+/rvh1075+0aJF0wWD1BkXU+tLdbnvxbXYtWsX5cqVSzc5wYW1PPPMM5QvX55mzZpRrFgxnnjiiXTntrzyyiscP36c8uXLU6VKFXr37p2pqdvDw8M5efLkJfdJ3Z76mVWrVo2KFSsyc+ZM9z4zZ84kf/783HHHHQD8999/HD9+nClTplCgQAGPJfUPJIcOHfJ4nVKlSl223rSKFStGw4YN0y2ph++mKlq0KKGhoR5tqTPgpZ4rl9m+2LZtG0WLFiVv3ryXrS8z352RI0fy999/Ex0dTe3atRk0aFCWBHARyToKSSKSYzL6a/Hx48e57bbb+PPPP3nllVf45ptvWLBggfscjMxM43yxWdTMC07Iz+rHZkZKSgqNGjXiu+++o2/fvsyZM4cFCxa4Jxi48P3l1IxwqSeKz5o1i6SkJL755htOnjxJmzZt3Pt8/PHHtG/fnjJlyvDee+/xww8/sGDBAu64445snV576NCh9OzZk/r16/Pxxx8zb948FixYQKVKlXJsWu/s/l5kRsGCBVm7di1ff/21+3yqZs2aeZwTVL9+fbZt28b7779P5cqVeffdd7npppt49913L/ncMTExbNq0iYSEhIvu89dff+Hv7+8RbB9++GEWL17M4cOHSUhI4Ouvv+b+++93zxyZ2j+PPfZYhqM9CxYs4NZbb/V4nSsZRcoNMvPdeeihh9i+fTsTJkygaNGijBo1ikqVKqUb0RQR+2jiBhGx1U8//cSRI0f48ssvqV+/vrt9x44dNlZ1XsGCBQkKCsrw4quXuiBrqnXr1rF582Y++OADj2u7XG72sUspUaIEixYt4tSpUx6jSZs2bbqi52nTpg0//PAD33//PdOnTyciIoKWLVu6t3/xxReULl2aL7/80uOQoowOOcpMzQBbtmyhdOnS7vb//vsv3ejMF198we233857773n0X78+HHy58/vvp+ZmQXTvv7ChQvTHWaWejhnan05oUSJEvz111+4XC6PEYyMagkICKBly5a0bNkSl8vFM888w+TJk3nppZfcI5l58+alQ4cOdOjQgVOnTlG/fn0GDRpEx44dL1rDXXfdxfLly/n8888znE57586d/PLLLzRs2NAjxDz88MMMHjyYWbNmUahQIeLi4njkkUfc2wsUKEB4eDgpKSk0bNjw6j+kLLBv3z5Onz7tMZq0efNmAPfMh5ntizJlyjBv3jyOHj2aqdGkzChSpAjPPPMMzzzzDIcOHeKmm25iyJAhmT6MV0Syl0aSRMRWqX91TftX1sTERN566y27SvLgdDpp2LAhc+bM8Th/YOvWrZn6q29G7880TY9pnK9U8+bNSU5OZtKkSe62lJQUJkyYcEXP06pVK0JCQnjrrbf4/vvvue+++wgKCrpk7StWrGD58uVXXHPDhg3x9/dnwoQJHs83bty4dPs6nc50Izaff/45e/fu9WhL/eU3M1OfN2/enJSUFCZOnOjR/vrrr2MYRo7+Ytq8eXMOHDjgcdhacnIyEyZMICwszH0o5pEjRzwe53A43Bf4TR0BunCfsLAwypYte8kRIoBOnTpRsGBBevfune4wr7Nnz9KhQwdM00x3La2YmBiqVKnCzJkzmTlzJkWKFPH444bT6eT+++9n1qxZ/P333+le97///rtkXVkpOTmZyZMnu+8nJiYyefJkChQoQI0aNYDM98X999+PaZoMHjw43etc6ehiSkpKusNGCxYsSNGiRS/bbyKSczSSJCK2qlu3Lnny5KFdu3Z0794dwzD46KOPcvSwpssZNGgQ8+fP59Zbb6VLly7uX7YrV67M2rVrL/nYihUrUqZMGXr16sXevXuJiIhg1qxZ13RuS8uWLbn11lvp168fO3fuJDY2li+//PKKz9cJCwujVatW7vOS0h5qB9Zow5dffsm9995LixYt2LFjB2+//TaxsbGcOnXqil4r9XpPw4YN46677qJ58+b88ccffP/99x6jQ6mv+8orr9ChQwfq1q3LunXr+OSTTzxGoMD6635UVBRvv/024eHhhIaGUqdOnQzPcWnZsiW33347AwYMYOfOnVSrVo358+fz1Vdf0aNHj3TXCrpWixYt4uzZs+naW7VqxdNPP83kyZNp3749v//+OyVLluSLL75g2bJljBs3zj3S1bFjR44ePcodd9xBsWLF2LVrFxMmTODGG290nzMTGxtLgwYNqFGjBnnz5mX16tXuqaUvJV++fHzxxRe0aNGCm266iY4dOxIbG8uBAweYNm0aW7du5Y033shwSvWHH36YgQMHEhQUxJNPPpnufJ7hw4ezePFi6tSpw1NPPUVsbCxHjx5lzZo1LFy4kKNHj17txwpYo0Eff/xxuvZChQp5THtetGhRRowYwc6dOylfvjwzZ85k7dq1TJkyxX1pgMz2xe23387jjz/O+PHj2bJlC02bNsXlcvHLL79w++23X/bzTuvkyZMUK1aMBx54gGrVqhEWFsbChQtZtWoVY8aMuabPRkSyUE5Ppycivu9iU4BXqlQpw/2XLVtm3nzzzWZwcLBZtGhRs0+fPua8efNMwFy8eLF7v4tNAZ7RdMtcMCX1xaYAz2ga3hIlSnhMSW2aprlo0SKzevXqZkBAgFmmTBnz3XffNV944QUzKCjoIp/CeevXrzcbNmxohoWFmfnz5zefeuop97TAaaevbteunRkaGpru8RnVfuTIEfPxxx83IyIizMjISPPxxx83//jjj0xPAZ7qu+++MwGzSJEi6abddrlc5tChQ80SJUqYgYGBZvXq1c1vv/02XT+Y5uWnADdN00xJSTEHDx5sFilSxAwODjYbNGhg/v333+k+77Nnz5ovvPCCe79bb73VXL58uXnbbbeZt912m8frfvXVV2ZsbKx7OvbU955RjSdPnjSff/55s2jRoqa/v79Zrlw5c9SoUR5TOKe+l8x+Ly6U+p282PLRRx+ZpmmaBw8eNDt06GDmz5/fDAgIMKtUqZKu37744guzcePGZsGCBc2AgACzePHiZqdOncz9+/e793nttdfM2rVrm1FRUWZwcLBZsWJFc8iQIe4pri9nx44d5lNPPWUWL17c9Pf3N/Pnz2/efffd5i+//HLRx2zZssX9fpYuXZrhPgcPHjS7du1qRkdHm/7+/mbhwoXNO++805wyZYp7n9QpwD///PNM1Wqal54CPO13I/XnzerVq81bbrnFDAoKMkuUKGFOnDgxw1ov1xemaU2JP2rUKLNixYpmQECAWaBAAbNZs2bm77//7lHf5b47CQkJZu/evc1q1aqZ4eHhZmhoqFmtWjXzrbfeyvTnICLZzzBNL/pzrYhILtKqVaurmn5ZRLJXgwYNOHz4cIaH/ImIZIbOSRIRyYQzZ8543N+yZQtz586lQYMG9hQkIiIi2UbnJImIZELp0qVp3749pUuXZteuXUyaNImAgAD69Oljd2kiIiKSxRSSREQyoWnTpnz66accOHCAwMBAbrnlFoYOHZru4qgiIiKS++mcJBERERERkTR0TpKIiIiIiEgaCkkiIiIiIiJp+Pw5SS6Xi3379hEeHo5hGHaXIyIiIiIiNjFNk5MnT1K0aNF0F8NOy+dD0r59+4iOjra7DBERERER8RJ79uyhWLFiF93u8yEpPDwcsD6IiIgIW2tJSkpi/vz5NG7cGH9/f1trkayjfvU96lPfoz71TepX36M+9U3e1K9xcXFER0e7M8LF+HxISj3ELiIiwitCUkhICBEREbZ/QSTrqF99j/rU96hPfZP61feoT32TN/br5U7D0cQNIiIiIiIiaSgkiYiIiIiIpKGQJCIiIiIikobPn5MkIiIiIt7FNE2Sk5NJSUnxaE9KSsLPz4+zZ8+m2ya5V072q9PpxM/P75ov/aOQJCIiIiI5JjExkf379xMfH59um2maFC5cmD179uj6lj4kp/s1JCSEIkWKEBAQcNXPoZAkIiIiIjnC5XKxY8cOnE4nRYsWJSAgwOOXZpfLxalTpwgLC7vkhT4ld8mpfjVNk8TERP777z927NhBuXLlrvr1FJJEREREJEckJibicrmIjo4mJCQk3XaXy0ViYiJBQUEKST4kJ/s1ODgYf39/du3a5X7Nq6Fvn4iIiIjkKAUgyU5Z8f3SN1RERERERCQNhSQREREREZE0FJJERERERGxQsmRJxo0bl+n9f/rpJwzD4Pjx49lWk1gUkkRERERELsEwjEsugwYNuqrnXbVqFU8//XSm969bty779+8nMjLyql4vsxTGNLudiIiIiMgl7d+/370+c+ZMBg4cyKZNm9xtYWFh7nXTNElJScHP7/K/ZhcoUOCK6ggICKBw4cJX9Bi5OhpJEhERERHbmCacPm3PYpqZq7Fw4cLuJTIyEsMw3Pc3btxIeHg433//PTVq1CAwMJClS5eybds27rnnHgoVKkRYWBi1atVi4cKFHs974eF2hmHw7rvvcu+99xISEkK5cuX4+uuv3dsvHOGZNm0aUVFRzJs3j5iYGMLCwmjatKlHqEtOTqZ79+5ERUWRL18++vbtS7t27WjVqtXVdhnHjh2jbdu25MmTh5CQEJo1a8aWLVvc23ft2kXLli3JkycPoaGhVKlShfnz57sf26ZNGwoUKEBwcDDlypVj6tSpV11LdlFIEhERERHbxMdDWJi1REQ4KFYsiogIh7stO5f4+Kx7H/369WP48OFs2LCBqlWrcurUKZo3b86iRYv4448/aNq0KS1btmT37t2XfJ7Bgwfz0EMP8ddff9G8eXPatGnD0aNHL/H5xTN69Gg++ugjlixZwu7du+nVq5d7+4gRI/jkk0+YOnUqy5YtIy4ujjlz5lzTe23fvj2rV6/m66+/Zvny5ZimSfPmzUlKSgKga9euJCQksGTJEtatW8ewYcMIDQ0F4KWXXmL9+vV8//33bNiwgUmTJpE/f/5rqic76HA7EREREZFr9Morr9CoUSP3/bx581KtWjX3/VdffZXZs2fz9ddf061bt4s+T/v27WndujUAQ4cOZfz48axcuZKmTZtmuH9SUhJvv/02ZcqUAaBbt2688sor7u0TJkygf//+3HvvvQBMnDiRuXPnXvX73LJlC19//TXLli2jbt26AHzyySdER0czZ84cHnzwQXbv3s39999PlSpVAGvELC4uDoDdu3dTvXp1atas6d7mjRSSctDmzfDtt6Vp3tzuSkRERES8Q0gInDplrbtcLuLi4oiIiMiRC86GhGTdc6X+0p/q1KlTDBo0iO+++479+/eTnJzMmTNnLjuSVLVqVfd6aGgoERERHDp06KL7h4SEuAMSQJEiRdz7nzhxgoMHD1K7dm33dqfTSY0aNXC5XFf0/lJt2LABPz8/6tSp427Lly8fFSpUYMOGDQB0796dLl26MH/+fBo2bMi9997rDkNdunTh/vvvZ82aNTRu3JhWrVq5w5Y30eF2OeTgAZN+bRdQNXEKf/2ZyQNgRURERHycYUBoqD2LYWTd+0g9nCxVr169mD17NkOHDuWXX35h7dq1VKlShcTExEs+j7+//wWfj3HJQJPR/mZmT7bKJh07dmT79u08/vjjrFu3jtq1azNlyhQAmjVrxq5du3j++efZt28fd955p8fhgd5CISmHFIr6j1k97uPZJhP5+r1f7S5HRERERLLRsmXLaN++Pffeey9VqlShcOHC7Ny5M0driIyMpFChQqxatcrdlpKSwpo1a676OWNiYkhOTmbFihXutiNHjrBp0yZiY2PdbdHR0XTu3Jkvv/ySnj178sEHH7i3FShQgHbt2vHxxx8zbtw4d4DyJjrcLqcEFeRE3rYUOPEOtcNHsXlzA8qXt7soEREREckO5cqV48svv6Rly5YYhsFLL7101Ye4XYtnn32WYcOGUbZsWSpWrMiECRM4duwYRiaG0datW0d4eLj7vmEYVKtWjXvuuYennnqKyZMnEx4eTr9+/bjhhhu45557AOjRowfNmjWjfPnyHDt2jJ9++okKFSoAMHDgQGrUqEGlSpVISEjg22+/JSYmJnve/DXQSFIOiqr7PCkuBy1unMvHE9fZXY6IiIiIZJOxY8eSJ08e6tatS8uWLWnSpAk33XRTjtfRt29fWrduTdu2bbnlllsICwujSZMmBAUFXfax9evXp3r16u6lRo0aAEydOpUaNWpw1113ccstt2CaJnPnznUf+peSkkLXrl2JiYmhadOmlCtXjtGjRwPWtZ769+9P1apVqV+/Pk6nkxkzZmTfB3CVDNPugxazWVxcHJGRkZw4cYKIiAhba0lKSmLbB42pGPITnyx7jHp9P6J4cVtLkiyQlJTE3Llzad68ebrjgiV3Up/6HvWpb1K/5j5nz55lx44dlCpVKsNf0nN64obrkcvlIiYmhoceeohXX301x14zJ/v1Ut+zzGYDffty2MG8dwHw8M2f8u4bu2yuRkRERER82a5du3jnnXfYvHkz69ato0uXLuzYsYNHH33U7tK8mkJSDjvuLMsR/9vxc6ZQ8OjrHDxod0UiIiIi4qscDgfTpk2jVq1a3Hrrraxbt46FCxd65XlA3kQhyQYRdaxpDjvUe4fJ44/YXI2IiIiI+Kro6GiWLVvGiRMniIuL49dff6V+/fp2l+X1FJLsULghJxzVCQ2Kx7ntTY4ds7sgERERERFJpZBkB8Mg4uY+ADzdYAKTJsbbXJCIiIiIiKRSSLKJUfwBTlGKAhGHOf77VE6dsrsiEREREREBhST7OPwIuekFALo0GM2Uyck2FyQiIiIiIqCQZCtH2Q6cMfNTquBOtiz6nLNn7a5IRERERERsDUlLliyhZcuWFC1aFMMwmDNnjsd20zQZOHAgRYoUITg4mIYNG7JlyxZ7is0OfiH4V+oOwNP/N5KpU336ur4iIiIiIrmCrSHp9OnTVKtWjTfffDPD7SNHjmT8+PG8/fbbrFixgtDQUJo0acJZHxpy8YvpSpIZQvWSa1n+5QKSkuyuSERERESyQ4MGDejRo4f7fsmSJRk3btwlH5PRQMLVyKrnuV7YGpKaNWvGa6+9xr333ptum2majBs3jv/973/cc889VK1alQ8//JB9+/b5VgcH5sUo+xQA7WqN4NNPba5HRERERDy0bNmSpk2bZrjtl19+wTAM/vrrryt+3lWrVvH0009fa3keBg0axI033piuff/+/TRr1ixLX+tC06ZNIyoqKltfI6f42V3AxezYsYMDBw7QsGFDd1tkZCR16tRh+fLlPPLIIxk+LiEhgYSEBPf9uLg4AJKSkkiyeZgm9fXT1VHxWVK2vsmdlX/kgXdW8fDDN+LQ2WK5xkX7VXIt9anvUZ/6JvVr7pOUlIRpmrhcLlwuV7rtpmm6bzPabpcOHTrw4IMPsnv3booVK+ax7f3336dmzZpUrlw5UzWnfW/58uUDuOzjLvZ5Xez5M3rOggULZuq1rkXqc1/4Gjndry6XC9M0SUpKwul0emzL7M8Lrw1JBw4cAKBQoUIe7YUKFXJvy8iwYcMYPHhwuvb58+cTEhKStUVepQULFqRrq2rUoxSLebjqSAYO7E3duvttqEyuRUb9Krmb+tT3qE99k/o19/Dz86Nw4cKcOnWKxMREq9E0IcXzmpEnj53OmYKcIWAYl92tfv365M+fnylTptCrVy93+6lTp/jiiy8YPHgwO3fupHfv3ixfvpzjx49TsmRJevbsyQMPPODePzk5mcTERPcf8atWrUqXLl3o0qULANu2bePZZ59lzZo1lCxZkmHDhgFw5swZ92NefvllvvvuO/bt20fBggV58MEH6dOnD/7+/kyfPp1XXnnFemvnwsGbb77Jo48+Sp48efj4449p0aIFAP/88w/9+/dn1apVBAcHc/fdd/Paa68RFhYGwDPPPMOJEye4+eabefPNN0lMTOS+++5j2LBh+Pv7Z/g5nT17FtM03bVeaP369fTt25clS5bgcDi48847GTFihDvArVu3jhdffJG1a9diGAalS5fm9ddfp3r16uzevZs+ffrw22+/kZSURPHixRk8eDCNGzdO9zqJiYmcOXOGJUuWkJzsOYN0fHzmrk/qtSHpavXv35+ePXu678fFxREdHU3jxo2JiIiwsTIruS5YsIBGjRql/3KdiIb5Nbi/1iw+em8or75aPTP/ZsULXLJfJVdSn/oe9alvUr/mPmfPnmXPnj2EhYURFBRkNSafxvFFsUs/MJu4HogDv9BM7du2bVtmzJjB4MGDMc79kjZr1ixSUlLo0KEDp06d4uabb2bAgAFEREQwd+5cOnfuTOXKlalduzZghcSAgAD376QOh4OgoCAiIiJwuVy0b9+eQoUKsXz5ck6cOOH+nTY4ONj9mPz58zNt2jSKFi3KunXr6NSpE/nz56d37960a9eObdu2MW/ePObPnw9YR2IFBwd7PM/p06d58MEHufnmm1mxYgWHDh3i6aefZsCAAUydOhUAf39/li5dSnR0ND/++CNbt26ldevW1KpVi6eeeirDzygoKAjDMNL9zm2aJidOnKBt27aEhYWxePFikpOTefbZZ3n66af58ccfAejSpQs33ngjkydPxul0snbtWqKiooiIiKB///6kpKTw888/Exoayvr164mIiMjw9/uzZ88SHBxM/fr1z3/PzrlYgLuQ14akwoULA3Dw4EGKFCnibj948GCGx1mmCgwMJDAwMF27v7+/1/wAzbCW/DeRmL85AYfn0rz0GBYteptsPmxUspg3fccka6hPfY/61DepX3OPlJQUDMPA4XDgSD23wMZzDBwOR6Zf/8knn2T06NH88ssvNGjQAIAPPviA+++/nzx58pAnTx569+7t3r979+7Mnz+fL774gptvvtndnvr+L7y/cOFCNm7cyLx58yhatCgAQ4cOpVmzZh6f10svveR+bOnSpdmyZQszZsygb9++hIaGEh4ejp+fn/s5Lny/DoeDGTNmcPbsWT766CNCQ62QOHHiRFq2bMnIkSMpVKgQhmGQJ08e3nzzTZxOJ7GxsbRo0YLFixfTqVOni3+eaW5TuVwufv75Z9atW8eOHTuIjo4G4MMPP6RSpUr8/vvv1KpVi927d9O7d29iY2MBqFChgvs59uzZw/3330+1atUAKFu27EX7yuFwYBhGhj8bMvuzwmtDUqlSpShcuDCLFi1yh6K4uDhWrFjhHpL0NQE39oWFc2lfbxoPjR1E06aFNZokIiIivs0ZAg+dAqxfpuPi4oiIiEj3i3a2vXYmVaxYkbp16/L+++/ToEEDtm7dyi+//OI+vC0lJYWhQ4fy2WefsXfvXhITE0lISMj06R4bNmwgOjraI9zccsst6fabOXMm48ePZ9u2bZw6dYrk5OQrPlpqw4YNVKtWzR2QAG699VZcLhebNm1yn+5SqVIlj3N6ihQpwrp1667otVJt3ryZ6Ohod0ACiI2NJSoqig0bNlCrVi169uxJx44d+eijj2jYsCEPPvggZcqUAazQ2aVLF+bPn0/Dhg25//77qVq16lXVkhm2Tg9w6tQp1q5dy9q1awFrsoa1a9eye/duDMOgR48evPbaa3z99desW7eOtm3bUrRoUVq1amVn2dmnQD0SI24mKCCBm/OOZ8kSuwsSERERyWaGYR3yZsdyhX+NfvLJJ5k1axYnT55k6tSplClThttuuw2AUaNG8cYbb9C3b18WL17M2rVradKkyflzr7LA8uXLadOmDc2bN+fbb7/ljz/+YMCAAVn6GmldOOpiGEa2TrwwaNAg/vnnH1q0aMGPP/5IbGwss2fPBqBjx45s376dxx9/nHXr1lGzZk0mTJiQbbXYGpJWr15N9erVqV69OgA9e/akevXqDBw4EIA+ffq4j1WsVasWp06d4ocffkh3bKHPMAwCqvUF4JmGb/H6yJM2FyQiIiIiqR566CEcDgfTp0/nww8/5IknnnCfn7Rs2TLuueceHnvsMapVq0bp0qXZvHlzpp87JiaGPXv2sH//+cm7fvvtN499fv31V0qUKMGAAQOoWbMm5cqVY9euXR77BAQEkJKSctnX+vPPPzl9+vwEGcuWLcPhcHgc4paVypcvz549e9izZ4+7bf369Rw/ftx9eF3qfs8//zzz58/nvvvuc58jBRAdHU3nzp358ssveeGFF3jnnXeypVawOSQ1aNAA0zTTLdOmTQOstPrKK69w4MABzp49y8KFCylfvrydJWe/YneTGFSBqNATlGEKq1bZXZCIiIiIAISFhfHwww/Tv39/9u/fT/v27d3bypUrx4IFC/j111/ZsGEDnTp14uDBg5l+7oYNG1K+fHnatWvHn3/+yS+//MKAAQM89ilXrhy7d+9mxowZbNu2jfHjx7tHWlKVLFnSfXTW4cOHPS6Nk6pNmzYEBQXRrl07/v77bxYvXsyzzz7L448/nm5m6SuVkpLiPlIsddmwYQMNGjSgSpUqtGnThjVr1rBy5Uratm3LbbfdRs2aNTlz5gzdunXjp59+YteuXSxbtoxVq1YRExMDQI8ePZg3bx47duxgzZo1LF682L0tO+hqPN7GcBBQzTrp7/lmrzNyWPYMn4qIiIjIlXvyySc5duwYTZo08Th/6H//+x833XQTTZo0oUGDBhQuXPiKThFxOBzMnj2bM2fOULt2bTp27MiQIUM89rn77rt5/vnn6datGzfeeCO//vqrx0QOAPfffz9Nmzbl9ttvp0CBAnz66afpXiskJIR58+Zx9OhRatWqxQMPPMCdd97JxIkTr+zDyMCpU6fcR4qlLvfccw+GYTB79mzy5MlD/fr1adiwIaVLl2bmzJmANWX5kSNHaNu2LeXLl+ehhx6iWbNm7kv7pKSk0LVrV2JiYmjatCnly5fnrbfeuuZ6L8YwU6/u5KPi4uKIjIzkxIkTXjEF+Ny5c2nevPmlZ9ZISSDpy9L4J+2jw+T36fVWBypVyrk65cpkul8l11Cf+h71qW9Sv+Y+Z8+eZceOHZQqVSrD0ydyfOIGyRE53a+X+p5lNhvo2+eNnIH4V+oBQO+7RjF8mPdccVpERERExNcpJHmrcp1IcUQQe8MGTm78lm3b7C5IREREROT6oJDkrfwjcFa0rgfV+64RjBhhcz0iIiIiItcJhSRvVuE5XARwa/lf2bxsKXv32l2QiIiIiIjvU0jyZsFFcJRpB8ALzUYwerTN9YiIiIhkAR+fN0xslhXfL4UkbxfTCxODljd9y5Jv/uG//+wuSEREROTqpM5CGB8fb3Ml4stSv1/XMuulX1YVI9kkojwUuxf+/ZJnG45i3LhpXDBlvoiIiEiu4HQ6iYqK4tChQ4B1vR7DMNzbXS4XiYmJnD17VlOA+5Cc6lfTNImPj+fQoUNERUXhdDqv+rkUknIBI7Yv/Pslbep+QrWBr9KnTzSRkXZXJSIiInLlChcuDOAOSmmZpsmZM2cIDg72CE+Su+V0v0ZFRbm/Z1dLISk3yF8bs2AD/A/9RMf/e5033xzLiy/aXZSIiIjIlTMMgyJFilCwYEGSkpI8tiUlJbFkyRLq16+vCwT7kJzsV39//2saQUqlkJRLGLF94dBPPH3HFG4c9BLPPZeH0FC7qxIRERG5Ok6nM90vs06nk+TkZIKCghSSfEhu7Fcd7JlbFGmCGVmVsKDTPHzTW7z7rt0FiYiIiIj4JoWk3MIwMGL7APBckzeY8PoZEhJsrklERERExAcpJOUmJR7GDClBwcj/aFR2Gh9+aHdBIiIiIiK+RyEpN3H4YcS8AECvFqMZOSKF5GSbaxIRERER8TEKSblNmScwA/JRptB2quefxWef2V2QiIiIiIhvUUjKbfxCMcp3A6BvyxEMHWrictlck4iIiIiID1FIyo3Kd8N0BFOj1BoKs4ivv7a7IBERERER36GQlBsF5cco2xGAPi1HMmQImKbNNYmIiIiI+AiFpNyqYk9Mw0njKgtIObyGhQvtLkhERERExDcoJOVWYSUxij8MQJ+7rNEkERERERG5dgpJudm5i8s+WOdz9mzYxrJlNtcjIiIiIuIDFJJyszzVoEhTnA4XLzQfw9ChdhckIiIiIpL7KSTldrF9Aehw21RWLT3EH3/YXI+IiIiISC6nkJTbFbwN8tYiOOAszzaeoNEkEREREZFrpJCU2xmGezSpa6M3+eHbU2zYYHNNIiIiIiK5mEKSLyjWCsLLkTfsGB0bvMOIEXYXJCIiIiKSeykk+QKHE2J6A9Cz+VhmfJrEzp32liQiIiIiklspJPmKUo9DUCGi8/3LQ7U/ZeRIuwsSEREREcmdFJJ8hTMIKvQArIvLTp3qYv9+e0sSEREREcmNFJJ8SbnOmH7hVI7+hztj5jJ2rN0FiYiIiIjkPgpJviQgCqNcZ8AaTZo0CY4csbkmEREREZFcRiHJ11Togenwp37FX6hSZDnjx9tdkIiIiIhI7qKQ5GtCimKUfByAvi1HMH48nDxpc00iIiIiIrmIQpIviumNiUGrml9ROGQDkybZXZCIiIiISO6hkOSLIitiFLsHgN4tRjF2LJw5Y3NNIiIiIiK5hEKSr4rtC8Bj//cxzsS9vPeezfWIiIiIiOQSCkm+Kv/NUKAeAX5J9Gg6jpEjITHR7qJERERERLyfQpIvOzea1LnhZOKOHOeTT2yuR0REREQkF1BI8mVFm0NkZcKDTtKl4SSGDYOUFLuLEhERERHxbgpJvswwILYPAD2avcHunWf54gubaxIRERER8XIKSb6uxCMQEk2hiIO0/b8PGToUTNPuokREREREvJdCkq9z+EPFngD0aTmKv9el8N13NtckIiIiIuLFFJKuB2U6QkAeyhbayr21ZjNkiEaTREREREQuRiHpeuAfBuW7AdCv5Uh++83kp5/sLUlERERExFspJF0vyncDZxA1S6+iQexPDBlid0EiIiIiIt5JIel6EVQQSj8BQL+WI1i0CFassLkmEREREREvpJB0PYl5AQwHTarOo1qJtRpNEhERERHJgELS9SSsNBR/CIA+d43im2/gr79srklERERExMsoJF1vYqyLyz5880xK5N/JsGE21yMiIiIi4mUUkq43eatD4UY4HSm80HwMn30GW7bYXZSIiIiIiPdQSLoexfYF4Ok73yNv6H8MH25zPSIiIiIiXkQh6XpU6A7IW4NAvzN0azyRDz+E3bvtLkpERERExDsoJF2PDMM9mvR884kEOE8zerTNNYmIiIiIeAmFpOtVsfsgrAwRQUd5ssF7vPMOHDxod1EiIiIiIvZTSLpeOZwQ0wuA/q3GkJyUxLhx9pYkIiIiIuINFJKuZ6XaQVBBikTs5uGbZ/Lmm3DsmN1FiYiIiIjYSyHpeuYXDBWeA2DgAyM5edJk4kSbaxIRERERsZlC0vWuXBfwC6N8wXU0rfYD48bBqVN2FyUiIiIiYh+FpOtdQB4o+zQAgx4awdGjMGWKzTWJiIiIiNhIIUmg4vPg8KdOyZ+pXWYFo0fD2bN2FyUiIiIiYg+FJIGQYlCyDQAvPzSS/fth2jR7SxIRERERsYtCklhiegPQrNJsyhfZxIgRkJRkc00iIiIiIjZQSBJLZCzc0BLDMHnp/tHs3AkzZthdlIiIiIhIzlNIkvNi+wLwyM0fUjhqP8OGgctlc00iIiIiIjlMIUnOK3ArFLgVPyORfveMY8MGmD3b7qJERERERHKWQpJ4irFGkzrd+TYRwScYMgRM0+aaRERERERykEKSeLqhBUTGEuSM49lmk/njD5g3z+6iRERERERyjkKSeDIc7pnuerccR4BfAkOG2FyTiIiIiEgOUkiS9Eo8CiHFiAzYT4cGH7F0KSxZYndRIiIiIiI5QyFJ0nMGQIXnARj88CgMw8XQoTbXJCIiIiKSQ7w6JKWkpPDSSy9RqlQpgoODKVOmDK+++iqmZhLIfmWfAv8oCoVs5t5aXzFvHqxebXdRIiIiIiLZz6tD0ogRI5g0aRITJ05kw4YNjBgxgpEjRzJhwgS7S/N9/uFQ/hkARrQbAZgaTRIRERGR64JXh6Rff/2Ve+65hxYtWlCyZEkeeOABGjduzMqVK+0u7fpQvjs4AikbtYLbYpYwezb884/dRYmIiIiIZC8/uwu4lLp16zJlyhQ2b95M+fLl+fPPP1m6dCljx4696GMSEhJISEhw34+LiwMgKSmJpKSkbK/5UlJf3+46Ms0vL46S7XBun8KYJ0dQs9dtDB3qYtq0FLsr8yq5rl/lstSnvkd96pvUr75HfeqbvKlfM1uDYXrxCT4ul4sXX3yRkSNH4nQ6SUlJYciQIfTv3/+ijxk0aBCDBw9O1z59+nRCQkKys1yfFOraz51numLgokq/v1i/txJvvbWIwoXj7S5NREREROSKxMfH8+ijj3LixAkiIiIuup9Xh6QZM2bQu3dvRo0aRaVKlVi7di09evRg7NixtGvXLsPHZDSSFB0dzeHDhy/5QeSEpKQkFixYQKNGjfD397e1livhXN4ax7+zWLStDQ0HfkzHjim89ZbL7rK8Rm7tV7k49anvUZ/6JvWr71Gf+iZv6te4uDjy589/2ZDk1Yfb9e7dm379+vHII48AUKVKFXbt2sWwYcMuGpICAwMJDAxM1+7v7297p6TyploypXJ/+HcWd5SZQfH8Q/jwwxIMGuTkhhvsLsy75Lp+lctSn/oe9alvUr/6HvWpb/KGfs3s63v1xA3x8fE4HJ4lOp1OXC6NYuSovDWg0J0YpDC64+skJsKYMXYXJSIiIiKSPbw6JLVs2ZIhQ4bw3XffsXPnTmbPns3YsWO599577S7t+hPbF4B7q7xD3rAjTJ4Mhw/bXJOIiIiISDbw6pA0YcIEHnjgAZ555hliYmLo1asXnTp14tVXX7W7tOtP4YaQpzp+xDOk3ZvEx8O4cXYXJSIiIiKS9bw6JIWHhzNu3Dh27drFmTNn2LZtG6+99hoBAQF2l3b9MQyI6QNAh7oTCA6IZ+JEOHHC5rpERERERLKYV4ck8TLFH4DQUgRymAGPvM+JE/DWW3YXJSIiIiKStRSSJPMcfhDTC4DnGo/B6Ujm9dchXpdMEhEREREfopAkV6Z0ewjMT5ixk24tP+e//+Cdd+wuSkREREQk6ygkyZXxC4Hy3QH43/0jAJNRoyAx0d6yRERERESyikKSXLnyXcEvlPzOP2ndYD5798KHH9pdlIiIiIhI1lBIkisXmBfKPAXA8LYjrdvhkJxsZ1EiIiIiIllDIUmuTsXnwfCjeOCP3Fl9Ndu2wWef2V2UiIiIiMi1U0iSqxNaHEq0BmBClxEADBsGLpedRYmIiIiIXDuFJLl6sdbFZSuGzuLGMlv4+2/45hubaxIRERERuUYKSXL1oipD0RYYmLzdYwwAQ4aAadpcl4iIiIjINVBIkmtzbjSpdv5plCx0gFWrYNEim2sSEREREbkGCklybQrUg3w3Y7gSmNJrPGCNJomIiIiI5FYKSXJtDANi+wJwZ/Rb5A2P46ef4Ndf7S1LRERERORqKSTJtSt2N0RUxJFygkm93gE0miQiIiIiuZdCklw7wwExvQG4L+Z1Av0TmTsX1q61tywRERERkauhkCRZo2QbCC6KX9Je3nj+EwCGDrW5JhERERGRq6CQJFnDGQgVegDQrvZIDMPFF1/Axo32liUiIiIicqUUkiTrlOsE/pEEJWzktc7fYJowfLjdRYmIiIiIXBmFJMk6/hFQrgsAzzYcCcDHH8POnTbWJCIiIiJyhRSSJGtV6A6OAMLP/spzjy4lJQVGjbK7KBERERGRzFNIkqwVXARKtQPgf/eNAOC992D/fjuLEhERERHJPIUkyXoxvQCD/Anf0uauv0lIgNdft7soEREREZHMUUiSrBdRHqLvA2B429EATJoER4/aWZSIiIiISOYoJEn2iOkDwA3Jn9Ck3h5OnYLx422uSUREREQkExSSJHvkrw0FG2CYyYx/xjrWbvx4OHnS5rpERERERC5DIUmyT2xfAMo5plC72lGOHYO337a5JhERERGRy1BIkuxTpAlEVcVIPs2kFyYBMGYMnDljc10iIiIiIpegkCTZxzDc5yZVD3mD8mXOcPAgvP++zXWJiIiIiFyCQpJkrxIPQ2gJjIT/mNJvGgAjR0JSkr1liYiIiIhcjEKSZC+HH1R8AYB6BUZTtEgyu3fDJ5/YXJeIiIiIyEUoJEn2K/MEBObDcXo7k16cBcCwYZCSYnNdIiIiIiIZUEiS7OcXCuWfBaBFqZHkyWOyeTPMmmVzXSIiIiIiGVBIkpxRris4g3GeWMO4fosAGDoUTNPmukRERERELqCQJDkjKD+U6QhA62ojCAuDP/+EuXNtrktERERE5AIKSZJzKvYEw4n/kYW81vN3AIYM0WiSiIiIiHgXhSTJOWElocQjADxdbxSBgbB8Ofz0k61ViYiIiIh4UEiSnBXTG4Dg/z6nX9dtgHVukoiIiIiIt1BIkpyVpxoUaQqmixdajMHPDxYuhJUr7S5MRERERMSikCQ5L7YvAOH/TaVLh0OAdW6SiIiIiIg3UEiSnFfwNshXG1LOMvCRCRgGfP01rFtnd2EiIiIiIgpJYgfDgJg+AOQ/+iaPPXIKgGHD7CxKRERERMSikCT2KNYKwstB4jGGPfkOADNnwtat9pYlIiIiIqKQJPZwON0z3d1wciz3tEzE5YLhw22uS0RERESuewpJYp9Sj0NQYYj/l1HdZgDw4YewZ4/NdYmIiIjIdU0hSezjDIKKPQAolzSSO253kZQEo0fbW5aIiIiIXN8UksReZTuBXzic+IcxL8wF4J134NAhm+sSERERkeuWQpLYKyAKynUGoFrACGrXhjNn4PXX7S1LRERERK5fCklivwo9wBGA8d9SRvf7FYA334Tjx22tSkRERESuUwpJYr+QotYkDsD/5R1JlSpw8iRMnGhzXSIiIiJyXVJIEu9QsRdgYOz9imH9NgAwbhycOmVrVSIiIiJyHVJIEu8QWRGK3QNAs1KjKFsWjhyBKVNsrktERERErjsKSeI9YvsC4Nj1Ma/0+xewpgNPSLCzKBERERG53igkiffIfzMUrA+uJB6q9gbFisH+/TBtmt2FiYiIiMj1RCFJvEtMHwCc2yczoM9xAEaMgORkG2sSERERkeuKQpJ4l6LNIbIyJJ/kiXqTKFAAduyATz+1uzARERERuV4oJIl3MQyItUaTAra/Qe+eZwEYNgxcLjsLExEREZHrhUKSeJ8Sj0BINJw9SNcWHxIZCRs2wJw5dhcmIiIiItcDhSTxPg5/qNgTgJAdo+j+bAoAQ4aAadpZmIiIiIhcDxSSxDuV6QgBeeDUVno9PJuQEFizBubPt7swEREREfF1CkninfzDoHw3ACL+HUHnztYQ0pAhdhYlIiIiItcDhSTxXuWfBWcwHF1N/ycWExAAv/xiLSIiIiIi2UUhSbxXUAEo/QQA+Q+NpEMHq1mjSSIiIiKSnRSSxLvF9ATDAfvn8b+ua3E6Yd48+P13uwsTEREREV+lkCTeLaw0FH8IgGJxI2nd2moeOtTGmkRERETEpykkifeLsS4uy+6ZDOy5A4Avv4T1622sSURERER8lkKSeL+81aFwYzBdlEsZy333Wc3DhtlbloiIiIj4JoUkyR1iz40mbXuPgX3+A+DTT2H7dhtrEhERERGfpJAkuUOhOyBvDUg5Q7XgiTRpAikpMHKk3YWJiIiIiK9RSJLcwTAgtq+1vnkiL/U/DcDUqbB3r411iYiIiIjPUUiS3KPYfRBWBhKPcmvh96hXDxITYexYuwsTEREREV+ikCS5h8MJMb2s9Q1j+N+LSQC8/TYcPmxjXSIiIiLiU7w+JO3du5fHHnuMfPnyERwcTJUqVVi9erXdZYldSrWDoIIQv5tG5WdSowbEx8Mbb9hdmIiIiIj4Cq8OSceOHePWW2/F39+f77//nvXr1zNmzBjy5Mljd2liF79gqPAcAMbGkbzY3wRgwgQ4ccLOwkRERETEV3h1SBoxYgTR0dFMnTqV2rVrU6pUKRo3bkyZMmXsLk3sVK4L+IXB8XW0qvMDMTFWQJo0ye7CRERERMQX+NldwKV8/fXXNGnShAcffJCff/6ZG264gWeeeYannnrqoo9JSEggISHBfT8uLg6ApKQkkpKSsr3mS0l9fbvryPWMMBylO+LcPA42DKd370Y88YQfY8eadOmSTEhIzpajfvU96lPfoz71TepX36M+9U3e1K+ZrcEwTdPM5lquWlBQEAA9e/bkwQcfZNWqVTz33HO8/fbbtGvXLsPHDBo0iMGDB6drnz59OiE5/duzZJsg12EanemMg2QWB4ykdbdnOHgwlI4d13HXXbrCrIiIiIikFx8fz6OPPsqJEyeIiIi46H5eHZICAgKoWbMmv/76q7ute/furFq1iuXLl2f4mIxGkqKjozl8+PAlP4ickJSUxIIFC2jUqBH+/v621uILnKs64tj5Ia4b7uHtf2bRtauTYsVMNm5MJiAg5+pQv/oe9anvUZ/6JvWr71Gf+iZv6te4uDjy589/2ZDk1YfbFSlShNjYWI+2mJgYZs2addHHBAYGEhgYmK7d39/f9k5J5U215GqV+sHOD3Hs/ZqOD23ltdcq8O+/BjNm+PPkkzlfjvrV96hPfY/61DepX32P+tQ3eUO/Zvb1vXrihltvvZVNmzZ5tG3evJkSJUrYVJF4lcgYuOFuwCRg22h6nbuE0vDhkJxsa2UiIiIikot5dUh6/vnn+e233xg6dChbt25l+vTpTJkyha5du9pdmniL2D7W7Y4P6dxuP/nywdat8Pnn9pYlIiIiIrmXV4ekWrVqMXv2bD799FMqV67Mq6++yrhx42jTpo3dpYm3KHCrtbgSCdk9jh49rOahQ8HlsrUyEREREcmlvDokAdx1112sW7eOs2fPsmHDhktO/y3XqZi+1u3Wt+nW6QTh4fD33/Dtt/aWJSIiIiK5k9eHJJHLuqEFRMZCUhxR/00m9WjMIUPAe+duFBERERFvpZAkuZ/hgJje1vqmcTz/XALBwbByJSxaZG9pIiIiIpL7KCSJbyjxKIQUgzP7KXjqI1KPyhw61N6yRERERCT3UUgS3+AMgArPW+sbRtHrhRT8/WHxYrjIdYdFRERERDKkkCS+o+xT4B8FJzcTbXxN27ZW85AhtlYlIiIiIrmMQpL4Dv9wKP+Mtb5+BP36mjgc8N13sHatrZWJiIiISC6ikCS+pXx3cATCkRWUjVjCww9bzcOG2VuWiIiIiOQeCkniW4ILQekO1vr6EfTvb61+/jls2mRfWSIiIiKSeygkie+J6WVNC77/e6oU+4u777aulzR8uN2FiYiIiEhuoJAkvie8DEQ/YK1vGMWAAdbqxx/Drl32lSUiIiIiucNVhaQ9e/bw77//uu+vXLmSHj16MGXKlCwrTOSaxPaxbnd9Su1Ku2jYEJKTYdQoe8sSEREREe93VSHp0UcfZfHixQAcOHCARo0asXLlSgYMGMArr7ySpQWKXJW8NaDQnWCmwIaxvPii1fzuu3DggL2liYiIiIh3u6qQ9Pfff1O7dm0APvvsMypXrsyvv/7KJ598wrRp07KyPpGrF9vXut32Lg1uOcItt0BCAowda29ZIiIiIuLdriokJSUlERgYCMDChQu5++67AahYsSL79+/PuupErkXhhpCnOqTEY2x5031u0qRJcPSovaWJiIiIiPe6qpBUqVIl3n77bX755RcWLFhA06ZNAdi3bx/58uXL0gJFrpphQMy5c5M2T6B543iqVYNTp2DCBHtLExERERHvdVUhacSIEUyePJkGDRrQunVrqlWrBsDXX3/tPgxPxCsUfwBCS0HCYYzt77vPTXrjDTh50t7SRERERMQ7+V3Ngxo0aMDhw4eJi4sjT5487vann36akJCQLCtO5Jo5/KzrJq3uChvHcP+9nalQwY9Nm+Dtt6F3b7sLFBERERFvc1UjSWfOnCEhIcEdkHbt2sW4cePYtGkTBQsWzNICRa5Z6Q4QWABO78S593P69bOax4yBs2ftLU1EREREvM9VhaR77rmHDz/8EIDjx49Tp04dxowZQ6tWrZg0aVKWFihyzfyCofyz1vr6EbR51KR4cTh4EN5/397SRERERMT7XFVIWrNmDfXq1QPgiy++oFChQuzatYsPP/yQ8ePHZ2mBIlmifFfwC4Xjf+J/eD59zs3nMHIkJCXZW5qIiIiIeJerCknx8fGEh4cDMH/+fO677z4cDgc333wzu3btytICRbJEYF4o85S1vmEETzwBhQrBrl0wfbq9pYmIiIiId7mqkFS2bFnmzJnDnj17mDdvHo0bNwbg0KFDREREZGmBIlmm4vNg+MHBxQTHr+KFF6zmYcMgJcXe0kRERETEe1xVSBo4cCC9evWiZMmS1K5dm1tuuQWwRpWqV6+epQWKZJnQ4lCitbW+fiSdO0OePLBpE3z5pb2liYiIiIj3uKqQ9MADD7B7925Wr17NvHnz3O133nknr7/+epYVJ5LlYs+djLRnFuHmFrp3t+4OGQKmaV9ZIiIiIuI9riokARQuXJjq1auzb98+/v33XwBq165NxYoVs6w4kSwXVRmKtgBM2Dia7t0hNBT+/BO+/97u4kRERETEG1xVSHK5XLzyyitERkZSokQJSpQoQVRUFK+++ioulyuraxTJWrF9rdvtH5A3+ABdulh3NZokIiIiInCVIWnAgAFMnDiR4cOH88cff/DHH38wdOhQJkyYwEsvvZTVNYpkrQL/B/lvAVcCbBpPz54QGAi//go//2x3cSIiIiJit6sKSR988AHvvvsuXbp0oWrVqlStWpVnnnmGd955h2nTpmVxiSJZzDAg5ty5SVveokj+OJ580ro7ZIh9ZYmIiIiId7iqkHT06NEMzz2qWLEiR48eveaiRLJdsbshoiIknYCtU+jTB/z8YOFCWLnS7uJERERExE5XFZKqVavGxIkT07VPnDiRqlWrXnNRItnOcEBMb2t94+uUKJZAmzbW3aFD7StLREREROzndzUPGjlyJC1atGDhwoXuayQtX76cPXv2MHfu3CwtUCTblGwDf70EZ/bBzun079+BDz+Er76CdeugShW7CxQRERERO1zVSNJtt93G5s2buffeezl+/DjHjx/nvvvu459//uGjjz7K6hpFsoczECr0sNY3jKRCeRcPPGDdHT7ctqpERERExGZXfZ2kokWLMmTIEGbNmsWsWbN47bXXOHbsGO+9915W1ieSvcp1Av9IiNsIe7/hxRet5hkzYOtWe0sTEREREXtcdUgS8Qn+EVDu3IWS1o/gxmomzZuDywUjRthbmoiIiIjYQyFJpMJz4AiAw8vhv2UMGGA1f/AB7Nljb2kiIiIikvMUkkSCC0Opdtb6+hHUrQsNGkBSEowZY2tlIiIiImKDK5rd7r777rvk9uPHj19LLSL2iekF296Ffd/C8b958cXK/PQTTJkCL74IBQvaXaCIiIiI5JQrGkmKjIy85FKiRAnatm2bXbWKZJ+I8hB97o8AG0bRsCHUqgVnzsC4cbZWJiIiIiI57IpGkqZOnZpddYjYL7Yv7JkFO6djVH2VAQOK06oVvPkm9OkDUVF2FygiIiIiOUHnJImkylcLCt0OZjJsHEfLllC5MsTFWUFJRERERK4PCkkiacX0sW63TcGRdJT+/a27r78Op0/bV5aIiIiI5ByFJJG0ijSBqGqQfBq2vMVDD0GZMnDkiDWJg4iIiIj4PoUkkbQMA2LPjSZtGo8fZ+jXz7o7ejQkJNhXmoiIiIjkDIUkkQsVfwhCS0DCf7BjGm3bQrFisG+fdYFZEREREfFtCkkiF3L4QcUXrPUNownwS6ZXL+vuiBGQnGxfaSIiIiKS/RSSRDJS5gkIzAentsOeWTz1FBQoANu3w4wZdhcnIiIiItlJIUkkI36hUP5Za339CEKCTZ5/3ro7bBi4XPaVJiIiIiLZSyFJ5GLKdwNnCBz7Aw4u4plnIDIS1q+Hr76yuzgRERERyS4KSSIXE5gPyjxpra8fQWQkdOtm3R0yBEzTvtJEREREJPsoJIlcSsWeYDjhwEI4+js9ekBICPz+O8yfb3dxIiIiIpIdFJJELiWsJJR4xFpfP5L8+aFTJ+vu0KG2VSUiIiIi2UghSeRyYs5dXHbPF3ByGy+8AAEBsGQJLF1qb2kiIiIikvUUkkQuJ09VKNIUTBdsHMMNN0D79tamIUNsrUxEREREsoFCkkhmxPa1brdPhbOH6NsXnE744QdYs8be0kREREQkaykkiWRGwdsgX21IOQubxlO6NLRubW0aMcJpb20iIiIikqUUkkQywzDOjyZtfhOSTtKvn3V3zhyDPXvC7KtNRERERLKUQpJIZt1wD4SXh6TjsO1dKlWCe+8F0zSYNau83dWJiIiISBZRSBLJLIcTYnpZ6xvHQkoiL75o3V2y5AZ27LCvNBERERHJOgpJIlei1OMQVBji/4Vdn1KzJjRq5MLlcjBmjP45iYiIiPgC/VYnciWcQVCxh7W+YSSYLvr1cwEwbZqDffvsK01EREREsoZCksiVKtsZ/MLhxHrYN5d69UxiYo6QmGgwZozdxYmIiIjItVJIErlSAZFQrrO1vn4EAA8+uBmAt9+GI0fsKkxEREREsoJCksjVqNADHAHw31KMw8upXv0Q1aubxMfDG2/YXZyIiIiIXAuFJJGrEVLUmsQBcGwahWFA374pAEyYAHFxdhYnIiIiItdCIUnkasX0Bgwc+74lzLWHVq1MYmLg+HF46y27ixMRERGRq6WQJHK1IipAsXsAKJs0B4cD+ve3No0dC/HxNtYmIiIiIldNIUnkWsT2BSA6+WeI/5dHHoGSJeG//+C99+wtTURERESujkKSyLXIfzOu/PVwkIxjywT8/aGvlZsYORISE+0tT0RERESunEKSyDVyVewFgGP7O5B4nPbtoUgR+Pdf+Phje2sTERERkSunkCRyjczCTYkzimMkn4ItkwgKghdesLYNHw4pKfbWJyIiIiJXRiFJ5FoZBlv877XWN70BKWfp1Any5oUtW+Dzz+0tT0RERESujEKSSBbY61cPM6Q4nD0I2z8gLAx69LC2DR0KLpet5YmIiIjIFchVIWn48OEYhkGP1N8+RbyEafjhKv+cdWfDaHCl0K0bhIfDunXw3Xf21iciIiIimZdrQtKqVauYPHkyVatWtbsUkQy5Sj0BAXnh1Fb4dzZ58sAzz1jbhgwB07S3PhERERHJHD+7C8iMU6dO0aZNG9555x1ee+21S+6bkJBAQkKC+35cXBwASUlJJCUlZWudl5P6+nbXIVnL3a9mAI4ynXFuGIrrn+GkFL6bbt0M3njDjxUrDObPT+aOO5SUcgP9W/U96lPfpH71PepT3+RN/ZrZGgzT9P6/b7dr1468efPy+uuv06BBA2688UbGjRuX4b6DBg1i8ODB6dqnT59OSEhINlcq17sA8wSN4p/Cj0SWBb3CYWdV3nmnCt99V5oqVf7j1Vd/tbtEERERketWfHw8jz76KCdOnCAiIuKi+3n9SNKMGTNYs2YNq1atytT+/fv3p2fPnu77cXFxREdH07hx40t+EDkhKSmJBQsW0KhRI/z9/W2tRbLOhf1qrPkNtk3ilshfSKnfjypVYN48k3XrCpA3bwtuvtnr/y5x3dO/Vd+jPvVN6lffoz71Td7Ur6lHmV2OV4ekPXv28Nxzz7FgwQKCgoIy9ZjAwEACAwPTtfv7+9veKam8qRbJOu5+rdQbtk/GcXABjlP/ULr0jbRtC++/DyNH+vHNN3ZXKpmlf6u+R33qm9Svvkd96pu8oV8z+/pePXHD77//zqFDh7jpppvw8/PDz8+Pn3/+mfHjx+Pn50eKrtIp3iisFBR/yFpfPxKAfv3A4YBvv4U//7SxNhERERG5LK8OSXfeeSfr1q1j7dq17qVmzZq0adOGtWvX4nQ67S5RJGMxfazb3TPh1A7KlYOHzuWmYcPsK0tERERELs+rQ1J4eDiVK1f2WEJDQ8mXLx+VK1e2uzyRi8tbHQo3BtMFG8YA0L+/temzz2DzZhtrExEREZFL8uqQJJKrxfa1bre/D2f/o2pVaNnSul7S8OH2liYiIiIiF5frQtJPP/100em/RbxKodshbw1IOQObJwIwYIC16aOPYNcuG2sTERERkYvKdSFJJNcwjPOjSZsnQvJp6tSBO++E5GQYPdre8kREREQkYwpJItmp2H0QVhYSj8LWdwF48UVr07vvwsGDNtYmIiIiIhlSSBLJTg4nxPSy1jeOBVcSt98ON98MZ8/C2LH2liciIiIi6SkkiWS30u0gqCDE74ZdMzGM8+cmvfUWHD1qb3kiIiIi4kkhSSS7OYOgwnPW+oaRYJq0aAFVq8KpUzBxor3liYiIiIgnhSSRnFCuC/iFwfF1sO97DOP8uUlvvGGFJRERERHxDgpJIjkhIA+U7WStbxgBwAMPQPny1uF2b79tY20iIiIi4kEhSSSnVOwBDn84tAQO/4bTCf36WZvGjLEmchARERER+ykkieSUkGJQso21vn4kAI89BsWLw4EDMHWqjbWJiIiIiJtCkkhOiulj3f47B+I24e8PvXtbTSNGQFKSbZWJiIiIyDkKSSI5KTIGbrgbMGHDKACefBIKFYJdu2D6dHvLExERERGFJJGcF9vXut3xEcTvIzgYeva0moYNg5QU+0oTEREREYUkkZxXoC4UuBVcibDpDQA6d4aoKNi0CWbPtrc8ERERkeudQpKIHWLOjSZtfRsSTxARAd27W01Dh4Jp2leaiIiIyPVOIUnEDje0gMhYSIqzghJWSAoNhT/+gO+/t7k+ERERkeuYQpKIHQzH+ZnuNo6DlATy5YMuXaymIUM0miQiIiJiF4UkEbuUaG1dO+nsAWsSB6wJHAID4ddfYckSm+sTERERuU4pJInYxRkAFZ631jeMAlcKRYrAE09YTUOG2FeaiIiIyPVMIUnETmWfAv8oOLkZ9n4FQJ8+4HTCggWwapW95YmIiIhcjxSSROzkHw7lu1rr60eAaVKyJDz2mNU0dKhtlYmIiIhctxSSROxWoTs4AuHISjhknYjUrx8YBsyZA3//bW95IiIiItcbhSQRuwUVhNIdrPX1IwCoWBHuv99qGjbMprpERERErlMKSSLeIKaXNS34/u/h2F8AvPiitWnGDNi2zcbaRERERK4zCkki3iC8DEQ/YK1vGAlA9erQrBm4XDBihI21iYiIiFxnFJJEvEXsuYvL7poBp3cBMGCA1TRtGvz7rz1liYiIiFxvFJJEvEXeGlDoTjBTYMNYAG69FW67DZKSYPRom+sTERERuU4oJIl4k9i+1u22dyHhCHB+NGnKFPjvP5vqEhEREbmOKCSJeJPCDSFPdUiJh80TAWjYEGrWhDNnYNw4e8sTERERuR4oJIl4E8M4P5q0eQIkx2MY50eTJk6E48dtq05ERETkuqCQJOJtou+H0FLW4Xbb3gfg7ruhUiWIi4M337S5PhEREREfp5Ak4m0cftZ1kwA2jgFXMg7H+esmjRsHp0/bVp2IiIiIz1NIEvFGpTtAYAE4vRN2fwbAQw9B6dJw+DC884695YmIiIj4MoUkEW/kFwwVulvr60eCaeLnB/36WU2jRkFCgn3liYiIiPgyhSQRb1XuGfALheN/wv75ALRtCzfcAPv2wYcf2lyfiIiIiI9SSBLxVoF5ocxT1vqGEVZTIPQ6d7rS8OGQnGxTbSIiIiI+TCFJxJtV7AmGHxxcDEdWAfDUU5A/P2zfDjNn2lyfiIiIiA9SSBLxZqHRUPJRa329NZoUGgrPP281DR0KLpdNtYmIiIj4KIUkEW8X09u63fMlxG0BoGtXiIiA9evh669trE1ERETEBykkiXi7qMpQtAVgwsbRAERGQrdu1uYhQ8A07StPRERExNcoJInkBrF9rdvtH8CZAwD06AEhIbB6NSxYYF9pIiIiIr5GIUkkNyjwf5D/FnAlwKY3rKYC8PTT1uYhQ2ysTURERMTHKCSJ5AaGcX40acskSIoDrOnA/f1hyRJYutTG+kRERER8iEKSSG5xQ0uIqAhJJ2DrFKvpBmjf3to8dKh9pYmIiIj4EoUkkdzCcJyf6W7j65CSAEDfvuBwwPffw5o1NtYnIiIi4iMUkkRyk5JtILgonNkHOz8BoEwZaN3a2jxsmI21iYiIiPgIhSSR3MQZCBXPXUl2wygwrSvJ9utnNc2aBRs22FSbiIiIiI9QSBLJbco+Df6RELcR9n4DQOXK0KqVdb2k4cPtLU9EREQkt1NIEslt/COgXBdrff0I95VkBwywmj75BHbssKk2ERERER+gkCSSG1V4DhyBcHg5/GfN/V2zJjRuDCkpMGqUzfWJiIiI5GIKSSK5UXBhKN3OWl8/wt384ovW7fvvw/79NtQlIiIi4gMUkkRyq4q9AAP2fQfH/wagfn249VZISIAxY+wtT0RERCS3UkgSya0iykH0fdb6Buv4OsM4f27S22/DkSM21SYiIiKSiykkieRmsX2t253T4fRuAJo2herV4fRpGD/extpEREREcimFJJHcLF8tKHQ7mMmw8XXAGk1KPTdp/HiIi7OxPhEREZFcSCFJJLeLOTeatO0dSDgKwH33QcWKcPw4TJpkX2kiIiIiuZFCkkhuV6QxRFWD5NOw5S0AHA7o39/aPHYsnDljY30iIiIiuYxCkkhuZxgQ28da3zQekq1E1Lo1lCwJhw7Be+/ZV56IiIhIbqOQJOILij8EoSUh4T/YPhUAf3/ocy47jRwJiYn2lSciIiKSmygkifgChx9UfMFa3zgGXMkAdOgARYrAnj3w8cc21iciIiKSiygkifiKMh0gMB+c2g57ZgEQFAQvnMtOw4dDSoqN9YmIiIjkEgpJIr7CLxTKP2utrx8BpglAp06QNy9s2QJffGFjfSIiIiK5hEKSiC8p3w2cIXDsDziwEICwMHjuOWvz0KHu7CQiIiIiF6GQJOJLAvNBmY7W+voR7uZnn4XwcPjrL/j2W5tqExEREcklFJJEfE3F58FwwsFFcPR3APLkgWeesTYPGaLRJBEREZFLUUgS8TVhJaHEI9b6+pHu5ueftyZyWLECFi+2pzQRERGR3EAhScQXxZy7QNKeL+DkNgAKFYKO547EGzLEprpEREREcgGFJBFflKcqFGkGpgs2jHY39+4Nfn7w44/w22821iciIiLixRSSRHxVbF/rdvtUOHMQgOLF4fHHreahQ22qS0RERMTLKSSJ+KqC9SFfbXAlwOYJ7uZ+/cDhgG++sWa7ExERERFPCkkivsowzo8mbX4Tkk4CUL48PPig1azRJBEREZH0FJJEfNkN90B4eUg6DlvfcTe/+KJ1+9lnsHmzPaWJiIiIeCuvDknDhg2jVq1ahIeHU7BgQVq1asWmTZvsLksk93A4Iaa3tb7pdUhJBKBqVbjrLut6SSNGXOLxIiIiItchrw5JP//8M127duW3335jwYIFJCUl0bhxY06fPm13aSK5R6nHIKgwxP8Luz51Nw8YYN1++CHs3m1TbSIiIiJeyKtD0g8//ED79u2pVKkS1apVY9q0aezevZvff//d7tJEcg9nEFTsYa1vGGlNCw7cfDPccQckJ8OoUfaVJyIiIuJt/Owu4EqcOHECgLx58150n4SEBBISEtz34+LiAEhKSiIpKSl7C7yM1Ne3uw7JWrmiX0s+id/fQzFOrCd591eYRe8CoG9fgx9/9OPdd0369k2mUCGb6/QSuaJP5YqoT32T+tX3qE99kzf1a2ZrMEzTNLO5lizhcrm4++67OX78OEuXLr3ofoMGDWLw4MHp2qdPn05ISEh2liji1WITP6Bc0myOOGJYGjwMsM5J6tu3Hps35+W++7bQtu16m6sUERERyT7x8fE8+uijnDhxgoiIiIvul2tCUpcuXfj+++9ZunQpxYoVu+h+GY0kRUdHc/jw4Ut+EDkhKSmJBQsW0KhRI/z9/W2tRbJOrunXM/vwm1sew5VI8u0/Y+a/BYBvvzW47z4/wsNNtm5NJk8em+v0ArmmTyXT1Ke+Sf3qe9Snvsmb+jUuLo78+fNfNiTlisPtunXrxrfffsuSJUsuGZAAAgMDCQwMTNfu7+9ve6ek8qZaJOt4fb/6l4BSj8O29/DbPAaKfAVAq1bWbHd//WUwebI/L71kb5nexOv7VK6Y+tQ3qV99j/rUN3lDv2b29b164gbTNOnWrRuzZ8/mxx9/pFSpUnaXJJK7xfQGDNj7NZywDq0zDOjf39o8bhycOmVbdSIiIiJewatDUteuXfn444+ZPn064eHhHDhwgAMHDnDmzBm7SxPJnSIqQLFW1vqG81PaPfgglCsHR4/C5Mn2lCYiIiLiLbw6JE2aNIkTJ07QoEEDihQp4l5mzpxpd2kiuVdsH+t25yfWtZMApxP69bOaR4+Gs2dtqk1ERETEC3h1SDJNM8Olffv2dpcmknvlvxkK1gdXEmwc525+7DGIjoYDB2DaNNuqExEREbGdV4ckEckmMX2t262TIfEYAAEB0Lu31TxiBHjBpQxEREREbKGQJHI9KtoMoqpA8inYMsnd3LEjFCwIO3fCp5/aV56IiIiInRSSRK5HhgEx585N2vQGpFgnIQUHQ8+eVvOwYeBy2VSfiIiIiI0UkkSuVyUehpDicPYQbP/A3dylC0RFwcaNMHu2feWJiIiI2EUhSeR65fCHiueGjTaMBlcKABER8OyzVvOQIWCaNtUnIiIiYhOFJJHrWdmOEJAXTm2Ff790Nz/3HISGwh9/wA8/2FifiIiIiA0UkkSuZ36hUL6btb5+hHvYKF8+6NzZah461KbaRERERGyikCRyvSvfDZzBcPR3OLjY3dyzpzUt+NKlsGSJjfWJiIiI5DCFJJHrXVABKP2Etb5+hLu5aFF44lzzkCE21CUiIiJiE4UkEYGYF8BwwoH5cPQPd3OfPuB0wvz5sGqVjfWJiIiI5CCFJBGBsFJQ/CFrfcMod3OpUtCmjbU+bJgNdYmIiIjYQCFJRCwxva3b3TPh1A53c79+1rVnZ8+Gf/6xqTYRERGRHKSQJCKWvNWhcGMwXbBhjLs5Jgbuu89a12iSiIiIXA8UkkTkvNi+1u329+Hsf+7mAQOs208/haeftkaV4uJsqE9EREQkBygkich5hW6HvDUh5QxsnuBurl4dWrcGlwveeccaWcqXD+64A0aNgr//dl9iSURERCTXU0gSkfMM4/xo0uaJkHTKvenDD+GHH+C556BcOUhOhsWLrRnwqlSBEiWgUyeYMwdOnrSnfBEREZGsoJAkIp6K3QthZSHxGGx7z93s5wdNmsC4cbB5M2zdChMmQLNmEBQEe/bAlClw773WKNOdd8Lo0bB+vUaZREREJHdRSBIRTw4nxPSy1jeOBVdShruVKQPdusHcuXD0KHz/PTz7LJQtC0lJ8OOP0Ls3VKoEJUtC587w9ddw6lSGTyciIiLiNRSSRCS90u0gqBDE74ZdMy67e3AwNG0K48fDli3WSNMbb1htQUGwezdMngz33GONMjVsCGPHwoYNGmUSERER76OQJCLpOYOgwnPW+vqRV5xkypWD7t2t0aUjR+C776xRp9KlITERFi2CF16A2FjrgrXPPAPffAOnT2fDexERERG5QgpJIpKxcp3BLwxO/A37vr/qpwkJgebNrfOXtm6FTZus85qaNIHAQNi1CyZNgrvvhrx5oXFjeP112LhRo0wiIiJiD4UkEclYQB4o28la3zAiS57SMKB8eWuGvB9+sEaZvv0Wuna1RpQSE2HBAujZ07qIbZky1rZvv9Uok4iIiOQchSQRubiKz4PDHw4tgcO/ZfnTh4ZCixYwcSJs22aNHr3+OjRqBAEBsGMHvPUWtGxpncuUdnY9jTKJiIhIdlFIEpGLC7kBSj5mra8fma0vZRhQoQL06AHz51sz5n3zDXTpYs2Ol5BgtT//vLVf2bLnZ9eLj8/W0kREROQ6o5AkIpcW09u6/XcOxG3KsZcNDYW77rJGkrZvt663NGaMNTNeQIDV9uab1khU3rzWTHpvvGHNriciIiJyLRSSROTSImPghrsBEzaMsqUEw7DOUerZ0zpn6cgR+Oor69pLxYtbo0zz5lmjUOXLW6NMqbPrnTljS8kiIiKSiykkicjlxfa1bnd8CKu7w46PIW6LbScGhYVZs+FNmgQ7d8I//8Do0XDHHeDvb53fNGGCNate3ryes+uJiIiIXI6f3QWISC5QoC4UaQL758HmCefbA/JAvtqQr86529oQVCBHSzMM63pLsbHWtZdOnoQff7RGkebOhT17rPXvz81iXq4cNGtmLbfdZl0IV0RERCQthSQRyZz6c2DPbDiyAo6shKNrIPGYFZz2zzu/X2gpyF/nfHjKUx38ci6JhIfDPfdYi2la5zKlBqZffrHOWdqyBcaPtwLS7befD01lyuRYmSIiIuLFFJJEJHOcQVCytbUApCTC8b+swJQanOI2wukd1rJrhrWf4QdRVa3QlBqeIiqCkf1H+xoGVKpkLb16QVwcLFp0fmTp33+t8DR3rrV/+fJWWGrc2CAxUUcji4iIXK8UkkTk6jgDIF9Na+EZqy3xOBxdDYdXnA9PZw/CsTXWsvVtaz//CMhb8/xhevnrQHCRbC85IgLuvddaTBP+/vt8YFq61Lr+0ubN8MYbfgQGNuPOOx00b26d01SqVLaXJyIiIl5CIUlEsk5AFBRuaC1gJZH4PedHmg6vgKO/Q1IcHPzRWlKFFDsXms4Fp7w1wD8s20o1DKhSxVr69LFGmRYuTD00z2TfPj+PUaYKFaxRpubNoX59CAzMttJERETEZgpJIpJ9DANCi1tL8QetNlcynPjH8zC9E/9A/L/WsmfWucc6ILJSmkkh6kBkLDiy58dWRATcd5+1JCYmM2nSUk6frs+8eU6WLYNNm6xl3DgICbFm0mve3ApOJUtmS0kiIiJiE4UkEclZDj/IU81ayj5ltSWdtCaCOJLmML34f+H4OmvZ9q61nzPk3CF+aWbUC4m2wlgWMgwoWTKO5s1dvPiikxMn0o4ywf798O231gJQseL5wFSvnkaZREREcjuFJBGxn384FLrNWlLF7/McbTqyCpJPwqEl1pIqqLDnpBB5a0FAZJaWFxkJ999vLaYJf/11PjD9+its3GgtY8dCaCjceef5GfNKlMjSUkRERCQHKCSJiHcKKQohrSC6lXXflQInN3lOCnH8Lzh7APZ+bS2pIip6TgoRWcWaaCILGAZUq2Yt/frB8eOwYMH5CSAOHICvv7YWsK7flBqY6tWDgKwpQ0RERLKRQpKI5A4Op3VOUmQslOlgtSXHw7E/zk8KcWSlNf143EZr2fHBuccGQt6bPINTaKksOUwvKgoefNBaTBPWrj0fmJYvt67TtH49jBkDYWGeo0zFi1/zy4uIiEg2UEgSkdzLLwQK3Gotqc4esg7Ncx+mt9K66O3h5daSKjD/uXObUs9vqgWB+a6pHMOA6tWt5cUX4dgxz1Gmgwfhq6+sBazrN6XOmHfrrRplEhER8RYKSSLiW4IKwg0trAWs4Z2TW8+FpnPB6dhaSDgM++ZaS6qwspCvNo48NcmTkgQpd4C//1WXkicPPPSQtbhc50eZ5s6F336Df/6xltGjrVGmhg3PTwBRrNg1fQoiIiJyDRSSRMS3GQZElLOWUo9ZbSkJcOxPz9n0Tm6BU1vh1Facu6ZTHzBn/8+ahS/tYXrh5azpya+QwwE33WQtAwbA0aOeo0yHDsGcOdYCULny+cB0663XlNVERETkCikkicj1xxkI+WtbS6qEo+cO01uJ6/BvJO1fSqAZB0dXW8uWN639/KOsQ/PSTkMeXOiKS8ibFx5+2FpcLvjjD2uE6fvvYcUK+Ptvaxk5EsLDoVGj8+cy3XBD1nwMIiIikjGFJBERgMC8ULQJFG1CSlISP3z3Hc0bxOJ/fM350aZjayDpOBxYYC2pQkt4XvQ2703W+VKZ5HBAjRrW8tJLcOQIzJ9vBaYffoD//oMvv7QWgKpVzwemunU1yiQiIpLVFJJERDJiGNYMeFHloeQjVpsrybq4bdrrN53YAKd3Wcvuz8491glRVTxHmyJirBn6MiFfPmjd2lpcLvj99/OH5a1YYV2n6a+/YMQIiIjwHGUqWjSbPg8REZHriEKSiEhmOfytUaK8N0G5zlZb4gk4+rvn+U1n9luTQxxbC1unWPv5hUHemucvepuvDoRc/rg5hwNq1bKWgQPh8GHPUabDh2HWLGsB6/pNqTPm3XIL+OmnvIiIyBXTf58iItciIBIK32EtYM2md2av50Vvj66G5FNw6CdrSRVc1HNSiLw1wT/8ki+XPz88+qi1pKScH2WaOxdWrYI//7SW4cMhMtIaZWreHJo2hSJFsu1TEBER8SkKSSIiWckwIKQYFC8Gxe+32lwpELfe86K3J9bBmX3w72xrsR5sXSw3daQpfx2IrAyOjH9UO51Qu7a1vPyyde7S/PlWYJo3zzq36YsvrAXgxhvPz5h3880aZRIREbkY/RcpIpLdHOfOUYqqAmWetNqST587TC9NcIrfDSf+sZbtU639nMGQt4bn+U2hJawwdoECBaBNG2tJSYHVq8/PmLd6tXWdprVrYehQiIryHGUqXDinPgwRERHvp5AkImIHv1AoWN9aUp054DkpxJGVkBQH/y21llRBBSFv7TTnN9WCgDweT+90Qp061jJ4sHUdpnnzrMA0b551nabPP7cWsK7flDr5Q506GmUSEZHrm/4bFBHxFsGFodjd1gJguiBus+ekEMf+hLOHYN+31pIqvLzn+U1R1cAZ4N5csCA8/ri1pKTAypXnZ8xbvRrWrLGWIUMgTx5o3NgKTE2bQqErvwyUiIhIrqaQJCLirQwHRFa0ltLtrLaUs3D0D88Rp1Pb4ORma9n5kbWfIwDyVPc8TC+8LBgGTqc1890tt8Arr8DBg56jTMeOwcyZ1gLW9ZvSjjI5MzeTuYiISK6lkCQikps4g6DALdaS6uxhOLrKc0a9xKPnQtQKYIK1X0Dec6EpNTjVgqACFCoEbdtaS3Ly+VGmuXOt0aXff7eW116DvHk9R5kKFrTlUxAREclWCkkiIrldUH4o2sxawJqG/NQ2z0khjv1hBaf9P1hLqrDSHqNNfnmqU7duMHXrwquvwoED1ujS3LnWzHlHj8KMGdYCULPm+esy1aqlUSYREfENCkkiIr7GMKxD68LLQslHrbaURDj+l+f5TXGb4NR2a9l1LvUYfhBV1T0pROF8dWjXtgLt2jlIToYVK87PmPfHH9b5TKtXW4EqXz5o0sQKTU2aWLPtiYiI5EYKSSIi1wNnAOSraS10tdoSj8ORVZ7B6ewhOLbGWrZMsvbzj4C8tfDLV5tbS9Th1v/VZsiQIuzfDz/8YAWm+fOt6zJNn24thmGNMqVel6lmTY0yiYhI7qGQJCJyvQqIgiKNrAWsw/Tid3ue23T0d2sa8oOLrCVVSDRF8tWmQ506dGhem+SIGixfHeaeMW/tWli1yloGD7ZGmZo2PT/KlD+/HW9YREQkcxSSRETEYhjWhWpDS0CJh6w2VzKc+Nvz/KYT/0D8HmvZMwsAP8NBvcjK1LunNkOfqMMhV22+W1qJud873aNMn3xiLYYBtWufnzGvZk1wOGx83yIiIhdQSBIRkYtz+EGeG62l7NNWW9JJa4Qp9TC9wyvgzF7rnKfjf8G2dykIdAgLpUOnGqT0q8Om/2rz9a91+PSrYvz1l8GKFdb5TYMGWecupT2XKV8++96uiIgIKCSJiMiV8g+HQg2sJVX83nOH6KVev2kVJJ+CQ0twHlpCLBBbEfrdWJgzoXX450Btvl1eh3e/rMne/yL5+GP4+GNrRCl1lKl5c7jpJo0yiYhIzlNIEhGRaxdyA4TcC9H3WvddKRC30XNSiOPr4OwBgs9+RU3/r6hZH16ubxDvV5ENh2rzw6o6zF5Sm9WrqvLbb/68/LJ1HaYmTazA1LixdZ0mERGR7KaQJCIiWc/hhKhK1lLmCastOR6Orkkz2rQS4/ROQpM3UDPvBmo2+YD/NYFkM4itR6uzaG0dlm6ozdIf6vDRR6VwOAzq1Dk/Y1716hplEhGR7KGQJCIiOcMvBAr+n7WkOnMQjq5KM6PeSvySjlMx33Iq3rmcrndaux2Nz8/yTbVZsa0OSz+vzdjhtQkIy+ueMa9xY8iTx563JSIivkchSURE7BNcCG64y1oATBec3Oo5KcTxteQNOUyL6nNpUX2u+6FbDpRlxdY6LJtam3Ev1SGo8I00bBJIs2Zw440aZRIRkaunkCQiIt7DcEBEeWsp9bjVlpIAx9Z6HKbHyS2UK7yVcoW38tj/fQJAYrI/a3fdyK/jazP1cB3CStSmev1yNGrsICzMvrckIiK5j0KSiIh4N2cg5K9jLTxrtSUc9ZhNL+XQSgI4TO0yq6hdZhXwJgDH4qJYPbIWexNqc9QsyJyd83D6+WMYDjAcGA5rwXBa62narPtWu8NxQbvDma7N6Ty/zXA4cDjPLee2OxxOHH7WfYfDwOE0cDjA6bRGvVKXC+9fah/DsBYREclaCkkiIpL7BOaFok2tBXCaJpzeAYdXknxoBad2rSQ0YQ15Qo/TqMoCYMHVv5br3JLFXC4Dl+kgxeXEZTpwuRzW7bklxeUk+YI2lyvN/ukeY7WbpgMX1q1pOkgxndY6nttcptNqS9333HradkwHppG6T5r21FvD2h/Ds83ax4l5rp20t4YDE6d13+HZbhhO93pqe2qIPb9PapsDl2mwZ8+/fLf3B5xOf3AHXacVhNMEX4fDAY7zYdjhTBuKzwdb93aHA4fz3P5pwq4Vhp3uttRwnBqIHU7jqoJvaugVEe+gkCQiIrmfYUBYaQgrjV/JR4iqDbiS4Pg6jmxewaENK+DEnwQGOnGcSz0GLhxGCgYuDMO6n7rubseFwzi/3WGkuO87jPPbHQ6r3WGYmS7Z4TBxkIKfMyXbPpbrwpVcfDht4E3Khlo4H37Thti0wTbJ5RmEMwrIZuo2d6BNDbIGppmapM6vu9sNwDQ89jMxsDaAmWabYZy/797vwufD837ax5gY1suleQ7S1JH6fBluO/fcF95315GUxIJVn7n38XiO1Nc9t87FnuOCx1zsvVz4mLSvdaltaeu42Gtl9JgLt13qOdw1Glf4HIbhftxlazQ8t13YfrHnJ6M6jPSvZRip3zkXx86epnlzcg2FJBER8U0Of8h7E/luvomIGh2ZO3cuzZs3x9/fP/te0zQB05qAwnSBmQK4zt8nTXu6tvPtpunCdLlwuc7dprhwpaR43nevp2C6PPe3lhRcKefWPZ7P2p80bdZ6ins/Uh9zrib3/ub5x6V9D6bp8lg3TOu5PN+bC4MUz/eMC8N0AVYo9Wyz9jfShNrz6+dDbFLiWQIC/HDgwkgTbt3B13DhICVN0E0bhs8FYsN17vHnQ7Eztd1w4XRkfigxNfyCwq9IWst23A60sbuMTFNIEhERySqpf2E1rm1qvdS/xWqCvktLSkrKmfALVgC+yuDruiDYpiSfC7EuF2aKi5Rzt1ZoTXEHYc/wmwKmiZlai7WG6Q7mAKZ137z4NgPz3OY0+6VZP9/uuZ97PcN907yWR33W44zUujJ4/gu3uVKS2b17N8WLR+MwHKnVpX+OtHVk8NppH2Ok3jfNc2vWflb7hfcveD7MNK+X9v4FjzlXj5HmtTP6PNI9Rwbtl32OCz57I4PnS+1nw7igv85t83xv596Lcb5P0m672PNf+BxG2vdy7nWt1wcTFwlBN5CbKCSJiIiIXI5hWOdG4bzih547w0oyISkpiS1z51IuJ4Kv5JikpCT+mjv38jt6Ef2bFRERERERSUMhSUREREREJI1cEZLefPNNSpYsSVBQEHXq1GHlypV2lyQiIiIiIj7K60PSzJkz6dmzJy+//DJr1qyhWrVqNGnShEOHDtldmoiIiIiI+CCvD0ljx47lqaeeokOHDsTGxvL2228TEhLC+++/b3dpIiIiIiLig7x6drvExER+//13+vfv725zOBw0bNiQ5cuXZ/iYhIQEEhIS3Pfj4uIAa1aNpKRsunJcJqW+vt11SNZSv/oe9anvUZ/6JvWr71Gf+iZv6tfM1mCY5yed9zr79u3jhhtu4Ndff+WWW25xt/fp04eff/6ZFStWpHvMoEGDGDx4cLr26dOnExISkq31ioiIiIiI94qPj+fRRx/lxIkTREREXHQ/rx5Juhr9+/enZ8+e7vtxcXFER0fTuHHjS34QOSEpKYkFCxbQqFEjzf3vQ9Svvkd96nvUp75J/ep71Ke+yZv6NfUos8vx6pCUP39+nE4nBw8e9Gg/ePAghQsXzvAxgYGBBAYGpmv39/e3vVNSeVMtknXUr75Hfep71Ke+Sf3qe9Snvskb+jWzr+/VEzcEBARQo0YNFi1a5G5zuVwsWrTI4/A7ERERERGRrOLVI0kAPXv2pF27dtSsWZPatWszbtw4Tp8+TYcOHewuTUREREREfJDXh6SHH36Y//77j4EDB3LgwAFuvPFGfvjhBwoVKmR3aSIiIiIi4oO8PiQBdOvWjW7dutldhoiIiIiIXAe8+pwkERERERGRnKaQJCIiIiIikoZCkoiIiIiISBoKSSIiIiIiImkoJImIiIiIiKSRK2a3uxamaQIQFxdncyWQlJREfHw8cXFxtl9tWLKO+tX3qE99j/rUN6lffY/61Dd5U7+mZoLUjHAxPh+STp48CUB0dLTNlYiIiIiIiDc4efIkkZGRF91umJeLUbmcy+Vi3759hIeHYxiGrbXExcURHR3Nnj17iIiIsLUWyTrqV9+jPvU96lPfpH71PepT3+RN/WqaJidPnqRo0aI4HBc/88jnR5IcDgfFihWzuwwPERERtn9BJOupX32P+tT3qE99k/rV96hPfZO39OulRpBSaeIGERERERGRNBSSRERERERE0lBIykGBgYG8/PLLBAYG2l2KZCH1q+9Rn/oe9alvUr/6HvWpb8qN/erzEzeIiIiIiIhcCY0kiYiIiIiIpKGQJCIiIiIikoZCkoiIiIiISBoKSSIiIiIiImkoJOWgN998k5IlSxIUFESdOnVYuXKl3SVJBoYNG0atWrUIDw+nYMGCtGrVik2bNnnsc/bsWbp27Uq+fPkICwvj/vvv5+DBgx777N69mxYtWhASEkLBggXp3bs3ycnJOflW5BKGDx+OYRj06NHD3aZ+zX327t3LY489Rr58+QgODqZKlSqsXr3avd00TQYOHEiRIkUIDg6mYcOGbNmyxeM5jh49Sps2bYiIiCAqKoonn3ySU6dO5fRbkXNSUlJ46aWXKFWqFMHBwZQpU4ZXX32VtPNMqV+925IlS2jZsiVFixbFMAzmzJnjsT2r+u+vv/6iXr16BAUFER0dzciRI7P7rV3XLtWvSUlJ9O3blypVqhAaGkrRokVp27Yt+/bt83iOXNWvpuSIGTNmmAEBAeb7779v/vPPP+ZTTz1lRkVFmQcPHrS7NLlAkyZNzKlTp5p///23uXbtWrN58+Zm8eLFzVOnTrn36dy5sxkdHW0uWrTIXL16tXnzzTebdevWdW9PTk42K1eubDZs2ND8448/zLlz55r58+c3+/fvb8dbkgusXLnSLFmypFm1alXzueeec7erX3OXo0ePmiVKlDDbt29vrlixwty+fbs5b948c+vWre59hg8fbkZGRppz5swx//zzT/Puu+82S5UqZZ45c8a9T9OmTc1q1aqZv/32m/nLL7+YZcuWNVu3bm3HWxLTNIcMGWLmy5fP/Pbbb80dO3aYn3/+uRkWFma+8cYb7n3Ur95t7ty55oABA8wvv/zSBMzZs2d7bM+K/jtx4oRZqFAhs02bNubff/9tfvrpp2ZwcLA5efLknHqb151L9evx48fNhg0bmjNnzjQ3btxoLl++3Kxdu7ZZo0YNj+fITf2qkJRDateubXbt2tV9PyUlxSxatKg5bNgwG6uSzDh06JAJmD///LNpmtYPAn9/f/Pzzz9377NhwwYTMJcvX26apvWDxOFwmAcOHHDvM2nSJDMiIsJMSEjI2TcgHk6ePGmWK1fOXLBggXnbbbe5Q5L6Nffp27ev+X//938X3e5yuczChQubo0aNcrcdP37cDAwMND/99FPTNE1z/fr1JmCuWrXKvc/3339vGoZh7t27N/uKl4tq0aKF+cQTT3i03XfffWabNm1M01S/5jYX/jKdVf331ltvmXny5PH42du3b1+zQoUK2fyOxDTT92tGVq5caQLmrl27TNPMff2qw+1yQGJiIr///jsNGzZ0tzkcDho2bMjy5cttrEwy48SJEwDkzZsXgN9//52kpCSP/qxYsSLFixd39+fy5cupUqUKhQoVcu/TpEkT4uLi+Oeff3KwerlQ165dadGihUf/gfo1N/r666+pWbMmDz74IAULFqR69eq888477u07duzgwIEDHn0aGRlJnTp1PPo0KiqKmjVruvdp2LAhDoeDFStW5NybEbe6deuyaNEiNm/eDMCff/7J0qVLadasGaB+ze2yqv+WL19O/fr1CQgIcO/TpEkTNm3axLFjx3Lo3cilnDhxAsMwiIr6//buNrapso/j+K+stGuHk0FHO0emEJcxhhrYfKjDF7oENxMRMkMgzVJ5sww2HD6CUxSjKC8MGk2swQi82LQRI4oEMGObGkiACevYwpgkykMCcyIumyAw6XW/IOvdut3cRMe6yveTnKQ718Xp/+wXyvnn9FyMl5R4uVpH9N1uUGfOnNHly5djLqwkye1268iRI3GqCtciHA5r+fLlKiws1IwZMyRJXV1dstlskb/0A9xut7q6uiJzhsp7YAzxEQwGdfDgQTU3Nw8aI9fE8+OPPyoQCOjpp59WTU2Nmpub9eSTT8pms8nv90cyGSqz6EwnTZoUM261WjVhwgQyjZOVK1eqt7dX06ZNU1JSki5fvqw1a9bI5/NJErkmuOHKr6urS1OmTBl0jIGxtLS061I/rs2FCxe0YsUKLVq0SKmpqZISL1eaJOAqKisr1d7ert27d8e7FPxDJ0+eVHV1terr65WcnBzvcjAMwuGwCgoK9MYbb0iSZs6cqfb2dn3wwQfy+/1xrg5/16effqq6ujp9/PHHysvLUygU0vLly3XLLbeQK5AA+vv7tWDBAhljFAgE4l3O38bX7UaAy+VSUlLSoFWyfv75Z3k8njhVhf+nqqpK27ZtU1NTkyZPnhzZ7/F4dOnSJfX09MTMj87T4/EMmffAGEbegQMH1N3drVmzZslqtcpqterbb7/Vu+++K6vVKrfbTa4JJiMjQ9OnT4/Zl5ubqxMnTkj6byZX++z1eDzq7u6OGf/zzz919uxZMo2T5557TitXrtTChQt1xx13qKysTE899ZTefPNNSeSa6IYrPz6PR6eBBun48eOqr6+P3EWSEi9XmqQRYLPZlJ+fr4aGhsi+cDishoYGeb3eOFaGoRhjVFVVpS1btqixsXHQbd/8/HyNHTs2Js/Ozk6dOHEikqfX61VbW1vMh8HAh8VfL+owMoqKitTW1qZQKBTZCgoK5PP5Iq/JNbEUFhYOWp7/hx9+0K233ipJmjJlijweT0ymvb292rdvX0ymPT09OnDgQGROY2OjwuGw7r333hE4C/zV+fPnNWZM7OVJUlKSwuGwJHJNdMOVn9fr1Xfffaf+/v7InPr6euXk5PBVuzgZaJCOHj2qXbt2aeLEiTHjCZfriC8VcYMKBoPGbrebTZs2mcOHD5vy8nIzfvz4mFWyMDosWbLE3Hzzzeabb74xp0+fjmznz5+PzKmoqDBZWVmmsbHRfP/998br9Rqv1xsZH1gqes6cOSYUCpmdO3ea9PR0looeZaJXtzOGXBPN/v37jdVqNWvWrDFHjx41dXV1xul0mtra2sictWvXmvHjx5svv/zSHDp0yDz22GNDLjU8c+ZMs2/fPrN7926TnZ3NUtFx5Pf7TWZmZmQJ8M8//9y4XC7z/PPPR+aQ6+jW19dnWlpaTEtLi5Fk1q1bZ1paWiKrnA1Hfj09PcbtdpuysjLT3t5ugsGgcTqdLAF+HV0t10uXLpm5c+eayZMnm1AoFHP9FL1SXSLlSpM0gt577z2TlZVlbDabueeee8zevXvjXRKGIGnIbePGjZE5f/zxh1m6dKlJS0szTqfTzJ8/35w+fTrmOMeOHTMlJSXG4XAYl8tlnnnmGdPf3z/CZ4Or+WuTRK6J56uvvjIzZswwdrvdTJs2zaxfvz5mPBwOm1WrVhm3223sdrspKioynZ2dMXN+/fVXs2jRIjNu3DiTmppqFi9ebPr6+kbyNBClt7fXVFdXm6ysLJOcnGymTp1qXnzxxZgLLXId3Zqamob8d9Tv9xtjhi+/1tZWM3v2bGO3201mZqZZu3btSJ3iDelquf7000//8/qpqakpcoxEytViTNR/YQ0AAAAANzieSQIAAACAKDRJAAAAABCFJgkAAAAAotAkAQAAAEAUmiQAAAAAiEKTBAAAAABRaJIAAAAAIApNEgAAAABEoUkCACCKxWLRF198Ee8yAABxRJMEABg1nnjiCVkslkFbcXFxvEsDANxArPEuAACAaMXFxdq4cWPMPrvdHqdqAAA3Iu4kAQBGFbvdLo/HE7OlpaVJuvJVuEAgoJKSEjkcDk2dOlWfffZZzJ9va2vTQw89JIfDoYkTJ6q8vFy///57zJwNGzYoLy9PdrtdGRkZqqqqihk/c+aM5s+fL6fTqezsbG3dujUy9ttvv8nn8yk9PV0Oh0PZ2dmDmjoAQGKjSQIAJJRVq1aptLRUra2t8vl8WrhwoTo6OiRJ586d08MPP6y0tDQ1Nzdr8+bN2rVrV0wTFAgEVFlZqfLycrW1tWnr1q26/fbbY97j1Vdf1YIFC3To0CE98sgj8vl8Onv2bOT9Dx8+rB07dqijo0OBQEAul2vkfgEAgOvOYowx8S4CAADpyjNJtbW1Sk5OjtlfU1OjmpoaWSwWVVRUKBAIRMbuu+8+zZo1S++//74+/PBDrVixQidPnlRKSookafv27Xr00Ud16tQpud1uZWZmavHixXr99deHrMFiseill17Sa6+9JulK4zVu3Djt2LFDxcXFmjt3rlwulzZs2HCdfgsAgHjjmSQAwKjy4IMPxjRBkjRhwoTIa6/XGzPm9XoVCoUkSR0dHbrrrrsiDZIkFRYWKhwOq7OzUxaLRadOnVJRUdFVa7jzzjsjr1NSUpSamqru7m5J0pIlS1RaWqqDBw9qzpw5mjdvnu6///6/da4AgNGJJgkAMKqkpKQM+vrbcHE4HNc0b+zYsTE/WywWhcNhSVJJSYmOHz+u7du3q76+XkVFRaqsrNRbb7017PUCAOKDZ5IAAAll7969g37Ozc2VJOXm5qq1tVXnzp2LjO/Zs0djxoxRTk6ObrrpJt12221qaGj4RzWkp6fL7/ertrZW77zzjtavX/+PjgcAGF24kwQAGFUuXryorq6umH1WqzWyOMLmzZtVUFCg2bNnq66uTvv379dHH30kSfL5fHrllVfk9/u1evVq/fLLL1q2bJnKysrkdrslSatXr1ZFRYUmTZqkkpIS9fX1ac+ePVq2bNk11ffyyy8rPz9feXl5unjxorZt2xZp0gAA/w40SQCAUWXnzp3KyMiI2ZeTk6MjR45IurLyXDAY1NKlS5WRkaFPPvlE06dPlyQ5nU59/fXXqq6u1t133y2n06nS0lKtW7cuciy/368LFy7o7bff1rPPPiuXy6XHH3/8muuz2Wx64YUXdOzYMTkcDj3wwAMKBoPDcOYAgNGC1e0AAAnDYrFoy5YtmjdvXrxLAQD8i/FMEgAAAABEoUkCAAAAgCg8kwQASBh8QxwAMBK4kwQAAAAAUWiSAAAAACAKTRIAAAAARKFJAgAAAIAoNEkAAAAAEIUmCQAAAACi0CQBAAAAQBSaJAAAAACI8h+2aunCXvZcLgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2QAAAIjCAYAAABswtioAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1vklEQVR4nO3deVyU9d7/8fewg4i4ggsqqbmvuESpaZpIVlpmauaeK1RmWcfu0mw5VqfsdB9RU1Mr1yxLM1PJXE6JigiGa2q4pWBaikiyzfX7w5v5OeGCCFzD8Ho+HjzuuObLXO+ZD3r7PtfMdyyGYRgCAAAAABQ7F7MDAAAAAEBpRSEDAAAAAJNQyAAAAADAJBQyAAAAADAJhQwAAAAATEIhAwAAAACTUMgAAAAAwCQUMgAAAAAwCYUMAAAAAExCIQMAFItNmzbJYrFo06ZNRXaOTp06qVOnTkV2/yg6ub8fX3zxhdlRAKBYUcgAwAktWLBAFovF9uXl5aU777xTkZGRSklJMTtesTl16pRee+01JSQkFMn9//TTT3rkkUcUEBAgT09P1a5dW6NGjdLx48eL5Hy3I7fwXO9r6dKlZkcEgFLJzewAAICi8/rrrys4OFiXL1/Wjz/+qJkzZ2rNmjXas2ePfHx8zI5X6NavX2/3/alTpzRlyhTVrl1bLVq0KNRz/ec//9Gzzz6rO+64Q08//bSqVq2q/fv3a+7cuVq2bJnWrFmju+++u1DPWRieeeYZtWnTJs/x0NBQE9IAAChkAODEwsPD1bp1a0nSU089pYoVK2ratGlauXKl+vfvf1v3nZ6e7nClzsPDo1jO89NPP2ncuHFq37691q5da/c8jBkzRvfcc48ee+wx7d27V+XLly+WTJJ06dIllSlT5oZrOnTooMcee6yYEgEAboaXLAJAKXLfffdJkpKSkmzHFi5cqJCQEHl7e6tChQrq16+fTpw4YfdznTp1UpMmTRQXF6eOHTvKx8dHL7/8siSpdu3aevDBB7V+/Xq1aNFCXl5eatSokVasWJGvTNu3b1f37t1Vrlw5+fj46N5779VPP/1ku33//v3y9vbWoEGD7H7uxx9/lKurq1566SW7nLnvIdu0aZPtStDQoUNtL81bsGCBJk+eLHd3d/3+++958owcOVL+/v66fPnydTO/8cYbslgs+uSTT/KU0jp16ujdd9/V6dOn9dFHH0mS3nvvPVksFh07dizPfU2cOFEeHh76888/8/2cSNJrr70mi8Wiffv26YknnlD58uXVvn3762a+FRaLRZGRkVq0aJHq168vLy8vhYSEaMuWLXnWxsfHKzw8XH5+fvL19VWXLl20bdu2POvOnz+v5557TrVr15anp6dq1KihQYMG6ezZs3brrFar3nrrLdWoUUNeXl7q0qWLDh8+bLfm0KFD6t27twIDA+Xl5aUaNWqoX79+unDhQqE8fgAoThQyAChFjhw5IkmqWLGiJOmtt97SoEGDVK9ePU2bNk3jxo3Thg0b1LFjR50/f97uZ8+dO6fw8HC1aNFC//73v9W5c2fbbYcOHVLfvn0VHh6uqVOnys3NTX369FF0dPQN8/zwww/q2LGjUlNTNXnyZP3zn//U+fPndd9992nHjh2SpIYNG+qNN97QZ599plWrVkm6ciVoyJAhatCggV5//fVr3nfDhg1tt40cOVKfffaZPvvsM3Xs2FEDBw5Udna2li1bZvczmZmZ+uKLL9S7d295eXld837T09O1YcMGdejQQcHBwddc07dvX3l6emr16tWSpMcff1wWi0Wff/55nrWff/65unXrZruSlp/n5Gp9+vRRenq6/vnPf2rEiBHXzHO1ixcv6uzZs3m+DMOwW7d582aNGzdOTz75pF5//XWdO3dO3bt31549e2xr9u7dqw4dOmj37t168cUX9eqrryopKUmdOnXS9u3bbevS0tLUoUMH/ec//1G3bt304YcfavTo0Tpw4IBOnjxpd963335bX331lV544QVNnDhR27Zt04ABA2y3Z2ZmKiwsTNu2bdPTTz+tqKgojRw5Ur/++mue31kAKBEMAIDTmT9/viHJ+P77743ff//dOHHihLF06VKjYsWKhre3t3Hy5Enj6NGjhqurq/HWW2/Z/WxiYqLh5uZmd/zee+81JBmzZs3Kc65atWoZkowvv/zSduzChQtG1apVjZYtW9qObdy40ZBkbNy40TAMw7BarUa9evWMsLAww2q12talp6cbwcHBxv333287lpOTY7Rv394ICAgwzp49a0RERBhubm5GbGysXZZ7773XuPfee23fx8bGGpKM+fPn58kdGhpqtGvXzu7YihUr7DJeS0JCgiHJePbZZ6+7xjAMo1mzZkaFChXszhcSEmK3ZseOHYYk49NPPzUM49aek8mTJxuSjP79+98wR67c5/96X6dPn7atzT22c+dO27Fjx44ZXl5exiOPPGI71qtXL8PDw8M4cuSI7dipU6eMsmXLGh07drQdmzRpkiHJWLFiRZ5cuY8zN1/Dhg2NjIwM2+0ffvihIclITEw0DMMw4uPjDUnG8uXL8/W4AcDRcYUMAJxY165dVblyZQUFBalfv37y9fXVV199perVq2vFihWyWq16/PHH7a6UBAYGql69etq4caPdfXl6emro0KHXPE+1atX0yCOP2L738/PToEGDFB8fr+Tk5Gv+TEJCgg4dOqQnnnhC586ds53/0qVL6tKli7Zs2SKr1SpJcnFx0YIFC5SWlqbw8HDNmDFDEydOtL0/riAGDRqk7du3264aStKiRYsUFBSke++997o/d/HiRUlS2bJlb3j/ZcuWVWpqqu37vn37Ki4uzu58y5Ytk6enp3r27Cnp1p6TXKNHj87/g5Y0adIkRUdH5/mqUKGC3brQ0FCFhITYvq9Zs6Z69uypdevWKScnRzk5OVq/fr169eqlO+64w7auatWqeuKJJ/Tjjz/aHv+XX36p5s2b2/2O5LJYLHbfDx061O69gB06dJAk/frrr5KkcuXKSZLWrVun9PT0W3rsAOCI2NQDAJxYVFSU7rzzTrm5uSkgIED169eXi8uV/y3u0KFDMgxD9erVu+bPuru7231fvXr1626aUbdu3Tz/sL7zzjslSUePHlVgYGCenzl06JAkafDgwdfNf+HCBdtL+erUqaPXXntNEyZMUJMmTfTqq69e9+fyo2/fvho3bpwWLVqkSZMm6cKFC1q9erWee+65PI/larlFLLeYXc/FixftSlufPn00fvx4LVu2TC+//LIMw9Dy5ctt77+Sbv05kXTdl01eT9OmTdW1a9ebrrvW78Wdd96p9PR023vv0tPTVb9+/TzrGjZsKKvVqhMnTqhx48Y6cuSIevfuna98NWvWtPs+97HmvscuODhY48eP17Rp07Ro0SJ16NBBDz/8sJ588klbWQOAkoRCBgBOrG3btte9imS1WmWxWPTdd9/J1dU1z+2+vr5233t7exdqttwrPf/617+uuyX93zPkbmt/6tQpnTt37ppFL7/Kly+vBx980FbIvvjiC2VkZOjJJ5+84c/VrVtXbm5u+vnnn6+7JiMjQwcPHrR77qtVq6YOHTro888/18svv6xt27bp+PHjeuedd2xrCvKcFPZczHat30VJdu9xe//99zVkyBCtXLlS69ev1zPPPKOpU6dq27ZtqlGjRnFFBYBCQSEDgFKqTp06MgxDwcHBtqtZBXX48GEZhmF3ZemXX36RdGUXxuudX7ry8sb8XLGZNWuWoqOj9dZbb2nq1KkaNWqUVq5cecOfudGVLunKyxZ79uyp2NhYLVq0SC1btlTjxo1v+DNlypRR586d9cMPP+jYsWOqVatWnjWff/65MjIy9OCDD9od79u3r8aOHauDBw9q2bJl8vHx0UMPPWS7/Vafk6KUe7Xuar/88ot8fHxUuXJlSZKPj48OHjyYZ92BAwfk4uKioKAgSVce19WbgRSGpk2bqmnTpnrllVe0detW3XPPPZo1a5befPPNQj0PABQ13kMGAKXUo48+KldXV02ZMiXPDnuGYejcuXP5vq9Tp07pq6++sn2fmpqqTz/9VC1atLjuVayQkBDVqVNH7733ntLS0vLcfvWW9ElJSZowYYJ69+6tl19+We+9955WrVqlTz/99Ia5cj+T63q774WHh6tSpUp65513tHnz5pteHcv1yiuvyDAMDRkyRH/99ZfdbUlJSXrxxRdVtWpVjRo1yu623r17y9XVVUuWLNHy5cv14IMP2n1u2K08J0UtJiZGu3btsn1/4sQJrVy5Ut26dZOrq6tcXV3VrVs3rVy5UkePHrWtS0lJ0eLFi9W+fXvbSzF79+6t3bt32/2O5Pr7797NpKamKjs72+5Y06ZN5eLiooyMjFu6LwBwBFwhA4BSqk6dOnrzzTc1ceJEHT16VL169VLZsmWVlJSkr776SiNHjtQLL7yQr/u68847NXz4cMXGxiogIEDz5s1TSkqK5s+ff92fcXFx0dy5cxUeHq7GjRtr6NChql69un777Tdt3LhRfn5++uabb2QYhoYNGyZvb2/NnDlTkjRq1Ch9+eWXevbZZ9W1a1dVq1btuo/R399fs2bNUtmyZVWmTBm1a9fO9r4rd3d39evXT9OnT5erq2u+Pyy7Y8eOeu+99zR+/Hg1a9ZMQ4YMUdWqVXXgwAHNmTNHVqtVa9asyfOh0FWqVFHnzp01bdo0Xbx4UX379i3Qc3I7/vvf/17zM9aaNWumZs2a2b5v0qSJwsLC9Mwzz8jT01MzZsyQJE2ZMsW25s0331R0dLTat2+vsWPHys3NTR999JEyMjL07rvv2tZNmDBBX3zxhfr06aNhw4YpJCREf/zxh1atWqVZs2apefPm+c7/ww8/KDIyUn369NGdd96p7OxsffbZZ3J1dc33+9QAwKGYtb0jAKDo5G57//dt4a/lyy+/NNq3b2+UKVPGKFOmjNGgQQMjIiLCOHjwoG3NvffeazRu3PiaP1+rVi2jR48exrp164xmzZoZnp6eRoMGDfJsS/73be9zxcfHG48++qhRsWJFw9PT06hVq5bx+OOPGxs2bDAM4/9ve371tvqGYRjHjx83/Pz8jAceeMAu59Xb3huGYaxcudJo1KiR4ebmds0t8HO3nu/WrdtNn6u/27Jli9GzZ0+jUqVKhru7u1GzZk1jxIgRxtGjR6/7M3PmzDEkGWXLljX++uuva6652XNiGP9/2/vff/89X1lvtu395MmTbWslGREREcbChQuNevXqGZ6enkbLli2v+XEAu3btMsLCwgxfX1/Dx8fH6Ny5s7F169Y8686dO2dERkYa1atXNzw8PIwaNWoYgwcPNs6ePWuX7++/N0lJSXZz+/XXX41hw4YZderUMby8vIwKFSoYnTt3Nr7//vt8PQ8A4GgshnGLrxUAAOAqtWvXVpMmTWwfglzS7N69Wy1atNCnn36qgQMHmh3HIVgsFkVERGj69OlmRwEAp8d7yAAApdqcOXPk6+urRx991OwoAIBSiPeQAQBKpW+++Ub79u3T7NmzFRkZabe5BgAAxYVCBgAolZ5++mmlpKTogQcesNuoAgCA4sR7yAAAAADAJLyHDAAAAABMQiEDAAAAAJPwHrJCYrVaderUKZUtW1YWi8XsOAAAAABMYhiGLl68qGrVqsnF5cbXwChkheTUqVMKCgoyOwYAAAAAB3HixAnVqFHjhmsoZIWkbNmykq486X5+fqZmycrK0vr169WtWze5u7ubmgWFh7k6H2bqnJir82Gmzom5Oh9HmmlqaqqCgoJsHeFGKGSFJPdlin5+fg5RyHx8fOTn52f6LyMKD3N1PszUOTFX58NMnRNzdT6OONP8vJWJTT0AAAAAwCQUMgAAAAAwCYUMAAAAAEzCe8gAAACAImYYhrKzs5WTk2N2FKeVlZUlNzc3Xb58ucifZ1dXV7m5uRXKx11RyAAAAIAilJmZqdOnTys9Pd3sKE7NMAwFBgbqxIkTxfK5wD4+Pqpatao8PDxu634oZAAAAEARsVqtSkpKkqurq6pVqyYPD49iKQulkdVqVVpamnx9fW/6Ycy3wzAMZWZm6vfff1dSUpLq1at3W+ejkAEAAABFJDMzU1arVUFBQfLx8TE7jlOzWq3KzMyUl5dXkRYySfL29pa7u7uOHTtmO2dBsakHAAAAUMSKuiCg+BXWTPnNAAAAAACTUMgAAAAAwCQUMgAAAAAOo1OnTho3blyh3d+CBQvk7+9faPdX2ChkAAAAAPIYMmSILBaLLBaLPDw8VLduXb3++uvKzs42O9ot6du3r3755Rfb96+99ppatGhhXqC/YZdFAAAAANfUvXt3zZ8/XxkZGVqzZo0iIiLk7u6uiRMn3tL95OTkyGKxmLK5ibe3t7y9vYv9vPnFFTIAAACgGBmGoUuZl0z5MgzjlrJ6enoqMDBQtWrV0pgxY9S1a1etWrVKGRkZeuGFF1S9enWVKVNG7dq106ZNm2w/l/sywVWrVqlRo0by9PTU8ePHNWTIEPXq1UtTpkxR5cqV5efnp9GjRyszM/O6GW50rsuXL6tx48YaOXKkbf2RI0dUtmxZzZs3zy5L7n9PmTJFu3fvtl39W7BggYYNG6YHH3zQ7rxZWVmqUqWKPv7441t6zm4VV8gAAACAYpSelS7fqb6mnDttYprKeJQp8M97e3vr3LlzioyM1L59+7R06VJVq1ZNX331lbp3767ExETVq1dPkpSenq533nlHc+fOVcWKFVWlShVJ0oYNG+Tl5aVNmzbp6NGjGjp0qCpWrKi33nrrmue82bkWLVqkdu3aKTw8XB07dtSgQYN0//33a9iwYXnuq2/fvtqzZ4/Wrl2r77//XpJUrlw53XnnnerYsaNOnz6tqlWrSpJWr16t9PR09e3bt8DPV35whQwAAADADRmGoe+//17r1q1Ts2bNNH/+fC1fvlwdOnRQnTp19MILL6h9+/aaP3++7WeysrI0Y8YM3X333apfv77tg7E9PDw0b948NW7cWD169NDrr7+u//3f/5XVas1z3uPHj9/0XC1atNCbb76pkSNHauLEiTp27JjmzJlzzcfh7e0tX19fubm5KTAwUIGBgfL29rZl/Oyzz2xr58+frz59+sjXt2jLM1fInNC59HP6+szX6pDRQRXcK5gdBwAAAFfxcfdR2sQ00859K1avXi1fX19lZWXJarXqiSee0GOPPaYFCxbozjvvtFubkZGhihUr2r738PBQs2bN8txn8+bNbeVMkkJDQ5WWlqYTJ06oVq1admsTExOVk5Nz03M9//zz+vrrrzVnzhx9++23drfl11NPPaXZs2frxRdfVEpKir777jv98MMPt3w/t4pC5oS6L+mu3Sm71WpPKz1919NmxwEAAMBVLBbLbb1ssDh17txZM2fOlIeHh6pVqyY3NzctW7ZMrq6uiouLk6urq936q68meXt7y2Kx3Nb509LS8nWuM2fO6JdffpGrq6sOHz5coHMNGjRI//jHPxQTE6OtW7cqODhYHTp0uK38+UEhc0JDmg3Rc9HPacbOGYpsF3nbfxAAAABQOpUpU0Z169a1O9ayZUvl5OTozJkzBSosu3fv1l9//WXb+XDbtm3y9fVVUFBQnrX5PdewYcPUtGlT9evXT+PGjdP999+vhg0bXnOth4eHcnJy8hyvWLGievXqpfnz5ysmJkZDhw695cdWELyHzAk92fRJebl46cC5A9p0dJPZcQAAAOBE7rzzTg0YMECDBg3SihUrlJSUpB07dmjq1Kn69ttvb/rzmZmZGj58uPbt26c1a9Zo8uTJioyMvOaW+Pk5V1RUlGJiYjR//nw9/vjj6tmzpwYMGHDdnRtr166tpKQkJSQk6OzZs8rIyLDd9tRTT+mTTz7R/v37NXjw4AI+Q7eGQuaEynmVU6fynSRJUbFRpmYBAACA85k/f74GDRqk559/XvXr11evXr0UGxurmjVr3vRnu3Tponr16qljx47q27evHn74Yb322msFOteBAwc0YcIEzZgxw3aFLSoqSmfPntWrr756zfvr3bu3unfvrs6dO6ty5cpasmSJ7bauXbuqatWqCgsLU7Vq1W7tSSkgi3GrH0aAa0pNTVW5cuV04cIF+fn5mZolKytLM7+cqWcPPitXi6uOjjuqGn41TM2E25eVlaU1a9bogQcekLu7u9lxUAiYqXNirs6HmTqn4prr5cuXlZSUpODgYHl5eRXZeUqKIUOG6Pz58/r6668L/b6tVqtSU1Pl5+dX4A+gTktLU/Xq1TV//nw9+uijN1x7o9neSjfgCpmTquVdSx1rdlSOkaOPdn5kdhwAAADAYVmtVp05c0ZvvPGG/P399fDDDxfbuSlkTmx0yGhJ0uxds5WRnXGT1QAAAEDpdPz4cQUEBGjx4sWaN2+e3NyKb+9Ddll0Yj3v7KlqZavp1MVT+nL/l3qi6RNmRwIAAEAptmDBArMjXFPt2rVl1ju5uELmxNxd3TUqZJQkNvcAAAAAHBGFzMmNDBkpdxd3bT2xVfGn482OAwAAUCqxj57zKayZUsicXKBvoHo36i2Jq2QAAADFLXcHx/T0dJOToLDlzvR2d+nkPWSlQESbCC3ds1SLExfr3fvfVQXvCmZHAgAAKBVcXV3l7++vM2fOSJJ8fHxksVhMTuWcrFarMjMzdfny5QJve58fhmEoPT1dZ86ckb+/v1xdXW/r/ihkpcA9QfeoeUBz7U7Zrfnx8/X83c+bHQkAAKDUCAwMlCRbKUPRMAxDf/31l7y9vYul9Pr7+9tmezsoZKWAxWJRRJsIjVw9UjN3ztRzoc/JxcKrVQEAAIqDxWJR1apVVaVKFWVlZZkdx2llZWVpy5Yt6tixY5F/iLu7u/ttXxnLRSErJZ5o+oQmRE/QkT+PaN3hdQqvF252JAAAgFLF1dW10P4Rj7xcXV2VnZ0tLy+vIi9khYnLJKVEGY8yGtZymCRpeux0k9MAAAAAkChkpcqY1mMkSd8d+k5H/jhichoAAAAAFLJSpF7FegqrEyZDhmbunGl2HAAAAKDUo5CVMpFtIyVJ8+LnKT2Lz8MAAAAAzEQhK2XC64artn9t/Xn5Ty3ds9TsOAAAAECpRiErZVxdXDW29VhJ0vQd02UYhsmJAAAAgNKLQlYKDWs5TF5uXopPjte2k9vMjgMAAACUWhSyUqiiT0X1a9JPkhQVG2VyGgAAAKD0opCVUpFtrmzu8fnez5WSlmJyGgAAAKB0MrWQzZw5U82aNZOfn5/8/PwUGhqq7777znb75cuXFRERoYoVK8rX11e9e/dWSop9eTh+/Lh69OghHx8fValSRRMmTFB2drbdmk2bNqlVq1by9PRU3bp1tWDBgjxZoqKiVLt2bXl5ealdu3basWNHkTxmRxFSLUTtqrdTljVLc3fNNTsOAAAAUCqZWshq1Kiht99+W3Fxcdq5c6fuu+8+9ezZU3v37pUkPffcc/rmm2+0fPlybd68WadOndKjjz5q+/mcnBz16NFDmZmZ2rp1qz755BMtWLBAkyZNsq1JSkpSjx491LlzZyUkJGjcuHF66qmntG7dOtuaZcuWafz48Zo8ebJ27dql5s2bKywsTGfOnCm+J8MEEW0iJEmz4mYp25p9k9UAAAAACpupheyhhx7SAw88oHr16unOO+/UW2+9JV9fX23btk0XLlzQxx9/rGnTpum+++5TSEiI5s+fr61bt2rbtisbUaxfv1779u3TwoUL1aJFC4WHh+uNN95QVFSUMjMzJUmzZs1ScHCw3n//fTVs2FCRkZF67LHH9MEHH9hyTJs2TSNGjNDQoUPVqFEjzZo1Sz4+Ppo3b54pz0tx6dO4jyr7VNbJ1JNadXCV2XEAAACAUsfN7AC5cnJytHz5cl26dEmhoaGKi4tTVlaWunbtalvToEED1axZUzExMbrrrrsUExOjpk2bKiAgwLYmLCxMY8aM0d69e9WyZUvFxMTY3UfumnHjxkmSMjMzFRcXp4kTJ9pud3FxUdeuXRUTE3PdvBkZGcrIyLB9n5qaKknKyspSVlbWbT0Xtyv3/DfL4SpXDW0xVO9ufVfTt0/XQ3UfKo54KKD8zhUlBzN1TszV+TBT58RcnY8jzfRWMpheyBITExUaGqrLly/L19dXX331lRo1aqSEhAR5eHjI39/fbn1AQICSk5MlScnJyXZlLPf23NtutCY1NVV//fWX/vzzT+Xk5FxzzYEDB66be+rUqZoyZUqe4+vXr5ePj0/+HnwRi46Ovumaepn15CIXbTy2UR+t+EhBXkHFkAy3Iz9zRcnCTJ0Tc3U+zNQ5MVfn4wgzTU9Pz/da0wtZ/fr1lZCQoAsXLuiLL77Q4MGDtXnzZrNj3dTEiRM1fvx42/epqakKCgpSt27d5OfnZ2KyK408Ojpa999/v9zd3W+6/pvsb7Tql1XaV2afRoWNKoaEKIhbnSscHzN1TszV+TBT58RcnY8jzTT31XP5YXoh8/DwUN26dSVJISEhio2N1Ycffqi+ffsqMzNT58+ft7tKlpKSosDAQElSYGBgnt0Qc3dhvHrN33dmTElJkZ+fn7y9veXq6ipXV9drrsm9j2vx9PSUp6dnnuPu7u6m/wLkym+Wp9s9rVW/rNJniZ/p7fvflp+nuYUSN+ZIv2MoHMzUOTFX58NMnRNzdT6OMNNbOb/DfQ6Z1WpVRkaGQkJC5O7urg0bNthuO3jwoI4fP67Q0FBJUmhoqBITE+12Q4yOjpafn58aNWpkW3P1feSuyb0PDw8PhYSE2K2xWq3asGGDbY2z6xLcRfUr1ldaZpo+2/2Z2XEAAACAUsPUQjZx4kRt2bJFR48eVWJioiZOnKhNmzZpwIABKleunIYPH67x48dr48aNiouL09ChQxUaGqq77rpLktStWzc1atRIAwcO1O7du7Vu3Tq98sorioiIsF29Gj16tH799Ve9+OKLOnDggGbMmKHPP/9czz33nC3H+PHjNWfOHH3yySfav3+/xowZo0uXLmno0KGmPC/FzWKx2LbAj4qNkmEYJicCAAAASgdTX7J45swZDRo0SKdPn1a5cuXUrFkzrVu3Tvfff78k6YMPPpCLi4t69+6tjIwMhYWFacaMGbafd3V11erVqzVmzBiFhoaqTJkyGjx4sF5//XXbmuDgYH377bd67rnn9OGHH6pGjRqaO3euwsLCbGv69u2r33//XZMmTVJycrJatGihtWvX5tnow5kNaj5IEzdM1P6z+7Xp6CZ1Du5sdiQAAADA6ZlayD7++OMb3u7l5aWoqChFRUVdd02tWrW0Zs2aG95Pp06dFB8ff8M1kZGRioyMvOEaZ1bOq5wGNR+kmTtnanrsdAoZAAAAUAwc7j1kME/uyxZXHlipk6knTU4DAAAAOD8KGWwaV2mse2vdqxwjRx/t/MjsOAAAAIDTo5DBTmTbKy/bnL1rtjKyM0xOAwAAADg3Chns9KzfU9XKVtOZS2f05f4vzY4DAAAAODUKGey4u7prdMhoSdL0HdNNTgMAAAA4NwoZ8hgRMkLuLu6KORmj+NM33p0SAAAAQMFRyJBHoG+gejfqLenKB0UDAAAAKBoUMlxTZJsrm3ssSlykP/76w+Q0AAAAgHOikOGa7g66W80Dmuty9mXNj59vdhwAAADAKVHIcE0Wi8X2QdEzds6Q1bCanAgAAABwPhQyXNcTTZ+Qv5e/fv3zV609vNbsOAAAAIDToZDhusp4lNHQFkMlsbkHAAAAUBQoZLihMa3HSJK+O/SdjvxxxOQ0AAAAgHOhkOGG6lWsp+51u8uQoZk7Z5odBwAAAHAqFDLcVO7mHvPi5yk9K93kNAAAAIDzoJDhpsLrhivYP1h/Xv5TSxKXmB0HAAAAcBoUMtyUq4ur7b1kUbFRMgzD5EQAAACAc6CQIV+GtRwmLzcvxSfHa9vJbWbHAQAAAJwChQz5UtGnovo36S9Jmh473eQ0AAAAgHOgkCHfcjf3WL53uVLSUkxOAwAAAJR8FDLkW0i1ELWr3k5Z1izN3TXX7DgAAABAiUchwy2JbBspSZoVN0vZ1myT0wAAAAAlG4UMt6RPoz6q7FNZJ1NPatXBVWbHAQAAAEo0Chluiaebp55q9ZQkafoONvcAAAAAbgeFDLdsdOvRcrG4aOPRjdr3+z6z4wAAAAAlFoUMt6xmuZp6uP7DkqQZsTNMTgMAAACUXBQyFEhkmyube3yy+xOlZqSanAYAAAAomShkKJD7gu9Tg0oNlJaZps92f2Z2HAAAAKBEopChQCwWi8a2HitJioqNkmEYJicCAAAASh4KGQpscIvB8vXw1f6z+7Xx6Eaz4wAAAAAlDoUMBebn6aeBzQZKunKVDAAAAMCtoZDhtkS0iZAkfX3ga524cMLkNAAAAEDJQiHDbWlcpbE61e4kq2HVR3EfmR0HAAAAKFEoZLhtuVfJ5uyao4zsDJPTAAAAACUHhQy3rWf9nqpetrrOXDqjL/Z9YXYcAAAAoMSgkOG2ubu6a1TIKEls7gEAAADcCgoZCsWIkBFyd3FXzMkY7Tq9y+w4AAAAQIlAIUOhCPQN1GONHpMkRe3gKhkAAACQHxQyFJrczT0W71msP/76w+Q0AAAAgOOjkKHQ3B10t5oHNNfl7MuaHz/f7DgAAACAw6OQodBYLBZFto2UJM3YOUNWw2pyIgAAAMCxUchQqJ5o+oT8vfz165+/au3htWbHAQAAABwahQyFysfdR0NbDJUkTd8x3eQ0AAAAgGOjkKHQjW0zVpK09vBaHfnjiMlpAAAAAMdFIUOhq1uhrrrX7S5DhmbunGl2HAAAAMBhUchQJCLbXNnc4+P4j5WelW5yGgAAAMAxUchQJLrX7a5g/2Cdv3xeSxKXmB0HAAAAcEgUMhQJVxdXjWk9RpI0PXa6DMMwOREAAADgeChkKDLDWg6Tl5uXEpITFHMyxuw4AAAAgMOhkKHIVPSpqP5N+kuSomKjTE4DAAAAOB4KGYpURJsISdLyvcuVkpZichoAAADAsVDIUKRCqoXorhp3KcuapTm75pgdBwAAAHAoFDIUudyrZLN2zlK2NdvkNAAAAIDjoJChyPVp1EeVfSrrt4u/aeWBlWbHAQAAABwGhQxFztPNUyNajZDE5h4AAADA1UwtZFOnTlWbNm1UtmxZValSRb169dLBgwft1nTq1EkWi8Xua/To0XZrjh8/rh49esjHx0dVqlTRhAkTlJ1t/9K4TZs2qVWrVvL09FTdunW1YMGCPHmioqJUu3ZteXl5qV27dtqxY0ehP+bSalTrUXKxuGjj0Y3a9/s+s+MAAAAADsHUQrZ582ZFRERo27Ztio6OVlZWlrp166ZLly7ZrRsxYoROnz5t+3r33Xdtt+Xk5KhHjx7KzMzU1q1b9cknn2jBggWaNGmSbU1SUpJ69Oihzp07KyEhQePGjdNTTz2ldevW2dYsW7ZM48eP1+TJk7Vr1y41b95cYWFhOnPmTNE/EaVAzXI11bN+T0lS1A6ukgEAAACSyYVs7dq1GjJkiBo3bqzmzZtrwYIFOn78uOLi4uzW+fj4KDAw0Pbl5+dnu239+vXat2+fFi5cqBYtWig8PFxvvPGGoqKilJmZKUmaNWuWgoOD9f7776thw4aKjIzUY489pg8++MB2P9OmTdOIESM0dOhQNWrUSLNmzZKPj4/mzZtXPE9GKZC7ucenP3+q1IxUk9MAAAAA5nMzO8DVLly4IEmqUKGC3fFFixZp4cKFCgwM1EMPPaRXX31VPj4+kqSYmBg1bdpUAQEBtvVhYWEaM2aM9u7dq5YtWyomJkZdu3a1u8+wsDCNGzdOkpSZmam4uDhNnDjRdruLi4u6du2qmJiYa2bNyMhQRkaG7fvU1CsFIysrS1lZWQV8BgpH7vnNzvF3HWp0UP2K9XXw3EEt2LVAY1qPMTtSieKoc0XBMVPnxFydDzN1TszV+TjSTG8lg8MUMqvVqnHjxumee+5RkyZNbMefeOIJ1apVS9WqVdPPP/+sl156SQcPHtSKFSskScnJyXZlTJLt++Tk5BuuSU1N1V9//aU///xTOTk511xz4MCBa+adOnWqpkyZkuf4+vXrbWXRbNHR0WZHyKOjV0cd1EH9a/O/VDOlpiwWi9mRShxHnCtuDzN1TszV+TBT58RcnY8jzDQ9PT3fax2mkEVERGjPnj368ccf7Y6PHDnS9t9NmzZV1apV1aVLFx05ckR16tQp7pg2EydO1Pjx423fp6amKigoSN26dbN7SaUZsrKyFB0drfvvv1/u7u6mZvm79hntteQ/S3Qy46R8Gvuoc+3OZkcqMRx5rigYZuqcmKvzYabOibk6H0eaae6r5/LDIQpZZGSkVq9erS1btqhGjRo3XNuuXTtJ0uHDh1WnTh0FBgbm2Q0xJSVFkhQYGGj7v7nHrl7j5+cnb29vubq6ytXV9Zprcu/j7zw9PeXp6ZnnuLu7u+m/ALkcKUuuiu4VNbDZQM3cOVOzds1St3rdzI5U4jjiXHF7mKlzYq7Oh5k6J+bqfBxhprdyflM39TAMQ5GRkfrqq6/0ww8/KDg4+KY/k5CQIEmqWrWqJCk0NFSJiYl2uyFGR0fLz89PjRo1sq3ZsGGD3f1ER0crNDRUkuTh4aGQkBC7NVarVRs2bLCtQeHJ3dxj5cGVOnHhhMlpAAAAAPOYWsgiIiK0cOFCLV68WGXLllVycrKSk5P1119/SZKOHDmiN954Q3FxcTp69KhWrVqlQYMGqWPHjmrWrJkkqVu3bmrUqJEGDhyo3bt3a926dXrllVcUERFhu4I1evRo/frrr3rxxRd14MABzZgxQ59//rmee+45W5bx48drzpw5+uSTT7R//36NGTNGly5d0tChQ4v/iXFyjas0VqfanWQ1rPoo7iOz4wAAAACmMbWQzZw5UxcuXFCnTp1UtWpV29eyZcskXbly9f3336tbt25q0KCBnn/+efXu3VvffPON7T5cXV21evVqubq6KjQ0VE8++aQGDRqk119/3bYmODhY3377raKjo9W8eXO9//77mjt3rsLCwmxr+vbtq/fee0+TJk1SixYtlJCQoLVr1+bZ6AOFI/cq2ey42crIzrjJagAAAMA5mfoeMsMwbnh7UFCQNm/efNP7qVWrltasWXPDNZ06dVJ8fPwN10RGRioyMvKm58Pt61m/p6qXra7fLv6mL/Z9oQHNBpgdCQAAACh2pl4hQ+nl7uquUSGjJElRsVEmpwEAAADMQSGDaUaEjJC7i7tiTsZo1+ldZscBAAAAih2FDKYJ9A3UY40ekyRF7eAqGQAAAEofChlMlbu5x+I9i/XHX3+YnAYAAAAoXhQymOruoLvVIrCFLmdf1rz4eWbHAQAAAIoVhQymslgstqtkM3fOVI41x+REAAAAQPGhkMF0TzR9Qv5e/vr1z1+19vBas+MAAAAAxYZCBtP5uPtoWIthktgCHwAAAKULhQwOYUybMZKktYfX6vAfh01OAwAAABQPChkcQt0KdRVeN1yGDM2MnWl2HAAAAKBYUMjgMHI395iXME/pWekmpwEAAACKHoUMDqN73e4K9g/W+cvntSRxidlxAAAAgCJHIYPDcHVx1dg2YyVJ02OnyzAMkxMBAAAARYtCBocyrOUwebl5KSE5QTEnY8yOAwAAABQpChkcSgXvCurfpL8ktsAHAACA86OQweFEto2UJC3fu1wpaSkmpwEAAACKDoUMDqdV1Va6q8ZdyrJmac6uOWbHAQAAAIoMhQwOKXcL/Fk7Zynbmm1yGgAAAKBoUMjgkPo06qPKPpX128XftPLASrPjAAAAAEWCQgaH5OnmqRGtRkhicw8AAAA4LwoZHNbo1qPlYnHRxqMbtffMXrPjAAAAAIWOQgaHFVQuSD3r95QkzYidYXIaAAAAoPBRyODQcjf3+PTnT5WakWpyGgAAAKBwUcjg0O4Lvk8NKjVQWmaaPt39qdlxAAAAgEJFIYNDs1gstqtkUbFRMgzD5EQAAABA4aGQweENaj5Ivh6+OnD2gH5I+sHsOAAAAEChoZDB4fl5+mlQs0GS2AIfAAAAzoVChhJhbJuxkqSVB1fq+IXjJqcBAAAACgeFDCVC4yqN1al2J1kNqz7a+ZHZcQAAAIBCQSFDiRHZJlKSNGfXHGVkZ5icBgAAALh9FDKUGD0b9FT1stX1e/rv+mLfF2bHAQAAAG4bhQwlhpuLm0a3Hi1Jmh473eQ0AAAAwO2jkKFEGdFqhNxd3LXt5DbtOr3L7DgAAADAbaGQoUQJ8A3QY40ekyRF7WALfAAAAJRsFDKUOJFtr2zusXjPYp1LP2dyGgAAAKDgKGQocUJrhKpFYAtdzr6s+QnzzY4DAAAAFBiFDCWOxWJRRJsISdKM2BnKseaYnAgAAAAoGAoZSqQnmj4hfy9/JZ1P0trDa82OAwAAABQIhQwlko+7j4a1GCZJioplcw8AAACUTBQylFhj2oyRRRZ9d/g7Hf7jsNlxAAAAgFtGIUOJVbdCXXWv212SNDN2pslpAAAAgFtHIUOJlru5x7yEeUrPSjc5DQAAAHBrKGQo0brX7a47yt+h85fPa3HiYrPjAAAAALeEQoYSzdXFVWNaj5F0ZXMPwzBMTgQAAADkH4UMJd6wlsPk5ealhOQExZyMMTsOAAAAkG8UMpR4Fbwr6IkmT0iSpu+YbnIaAAAAIP8oZHAKEW2vbO7xxb4vlJyWbHIaAAAAIH8oZHAKraq20l017lKWNUtz4uaYHQcAAADIFwoZnEZkm0hJ0kdxHynbmm1yGgAAAODmKGRwGo81ekyVfSrrt4u/aeWBlWbHAQAAAG6KQgan4enmqZEhIyVJ02PZ3AMAAACOj0IGpzIqZJRcLC7adHST9p7Za3YcAAAA4IYoZHAqQeWC1LN+T0nSjNgZJqcBAAAAboxCBqcT2fbK5h6f/vypUjNSTU4DAAAAXJ+phWzq1Klq06aNypYtqypVqqhXr146ePCg3ZrLly8rIiJCFStWlK+vr3r37q2UlBS7NcePH1ePHj3k4+OjKlWqaMKECcrOtt9lb9OmTWrVqpU8PT1Vt25dLViwIE+eqKgo1a5dW15eXmrXrp127NhR6I8ZRa9z7c5qWKmh0jLT9OnuT82OAwAAAFyXqYVs8+bNioiI0LZt2xQdHa2srCx169ZNly5dsq157rnn9M0332j58uXavHmzTp06pUcffdR2e05Ojnr06KHMzExt3bpVn3zyiRYsWKBJkybZ1iQlJalHjx7q3LmzEhISNG7cOD311FNat26dbc2yZcs0fvx4TZ48Wbt27VLz5s0VFhamM2fOFM+TgUJjsVg0ts1YSVJUbJQMwzA5EQAAAHBtphaytWvXasiQIWrcuLGaN2+uBQsW6Pjx44qLi5MkXbhwQR9//LGmTZum++67TyEhIZo/f762bt2qbdu2SZLWr1+vffv2aeHChWrRooXCw8P1xhtvKCoqSpmZmZKkWbNmKTg4WO+//74aNmyoyMhIPfbYY/rggw9sWaZNm6YRI0Zo6NChatSokWbNmiUfHx/Nmzev+J8Y3LZBzQfJ18NXB84e0A9JP5gdBwAAALgmN7MDXO3ChQuSpAoVKkiS4uLilJWVpa5du9rWNGjQQDVr1lRMTIzuuusuxcTEqGnTpgoICLCtCQsL05gxY7R37161bNlSMTExdveRu2bcuHGSpMzMTMXFxWnixIm2211cXNS1a1fFxMRcM2tGRoYyMjJs36emXnmvUlZWlrKysm7jWbh9uec3O4eZvF289WSTJzVr1yz9Z/t/1DGoo9mRbhtzdT7M1DkxV+fDTJ0Tc3U+jjTTW8ngMIXMarVq3Lhxuueee9SkSRNJUnJysjw8POTv72+3NiAgQMnJybY1V5ex3Ntzb7vRmtTUVP3111/6888/lZOTc801Bw4cuGbeqVOnasqUKXmOr1+/Xj4+Pvl81EUrOjra7AimavRXI0nSN798o0++/kSVPSqbnKhwlPa5OiNm6pyYq/Nhps6JuTofR5hpenp6vtc6TCGLiIjQnj179OOPP5odJV8mTpyo8ePH275PTU1VUFCQunXrJj8/PxOTXWnk0dHRuv/+++Xu7m5qFrOtWLRCm45t0mH/wxrcabDZcW4Lc3U+zNQ5MVfnw0ydE3N1Po4009xXz+WHQxSyyMhIrV69Wlu2bFGNGjVsxwMDA5WZmanz58/bXSVLSUlRYGCgbc3fd0PM3YXx6jV/35kxJSVFfn5+8vb2lqurq1xdXa+5Jvc+/s7T01Oenp55jru7u5v+C5DLkbKYJbJtpDYd26R5CfM0pfMUebrlnVlJw1ydDzN1TszV+TBT58RcnY8jzPRWzm/qph6GYSgyMlJfffWVfvjhBwUHB9vdHhISInd3d23YsMF27ODBgzp+/LhCQ0MlSaGhoUpMTLTbDTE6Olp+fn5q1KiRbc3V95G7Jvc+PDw8FBISYrfGarVqw4YNtjUomXo26KkafjX0e/rvWr5vudlxAAAAADumFrKIiAgtXLhQixcvVtmyZZWcnKzk5GT99ddfkqRy5cpp+PDhGj9+vDZu3Ki4uDgNHTpUoaGhuuuuuyRJ3bp1U6NGjTRw4EDt3r1b69at0yuvvKKIiAjbFazRo0fr119/1YsvvqgDBw5oxowZ+vzzz/Xcc8/ZsowfP15z5szRJ598ov3792vMmDG6dOmShg4dWvxPDAqNm4ubRoWMknRlC3wAAADAkZhayGbOnKkLFy6oU6dOqlq1qu1r2bJltjUffPCBHnzwQfXu3VsdO3ZUYGCgVqxYYbvd1dVVq1evlqurq0JDQ/Xkk09q0KBBev31121rgoOD9e233yo6OlrNmzfX+++/r7lz5yosLMy2pm/fvnrvvfc0adIktWjRQgkJCVq7dm2ejT5Q8oxoNULuLu7adnKb4k7FmR0HAAAAsDH1PWT5+cBeLy8vRUVFKSrq+lc3atWqpTVr1tzwfjp16qT4+PgbromMjFRkZORNM6FkCfANUJ/GfbQ4cbGiYqM0ryefLQcAAADHYOoVMqC4RLSJkCQt2bNE59LPmZwGAAAAuIJChlIhtEaoWgS20OXsy5oXzxUyAAAAOAYKGUoFi8WiyDZXXo46c+dM5VhzTE4EAAAAUMhQivRv2l/lvcor6XyS1h5ea3YcAAAAgEKG0sPH3UdDW1z5GIPpsdNNTgMAAABQyFDKjGkzRhZZtPbwWh3+47DZcQAAAFDKUchQqtStUFfd63aXJM2MnWlyGgAAAJR2FDKUOpFtr2zuMS9hntKz0k1OAwAAgNKMQoZSp3vd7rqj/B06f/m8FicuNjsOAAAASjEKGUodF4uLxrQeI0mavmO6DMMwOREAAABKKwoZSqVhLYfJy81Lu1N2a+uJrWbHAQAAQClFIUOpVMG7gp5o8oQkKSo2yuQ0AAAAKK0oZCi1ItpGSJK+2PeFktOSTU4DAACA0ohChlKrVdVWCq0RqixrlubEzTE7DgAAAEqhAhWy+fPnKz2d7cJR8kW0uXKV7KO4j5SVk2VyGgAAAJQ2BSpk//jHPxQYGKjhw4dr61Y2REDJ9Vijx1SlTBX9dvE3rTy40uw4AAAAKGUKVMh+++03ffLJJzp79qw6deqkBg0a6J133lFyMu/DQcni6eapEa1GSGJzDwAAABS/AhUyNzc3PfLII1q5cqVOnDihESNGaNGiRapZs6YefvhhrVy5UlartbCzAkViVMgouVhctOnoJu09s9fsOAAAAChFbntTj4CAALVv316hoaFycXFRYmKiBg8erDp16mjTpk2FEBEoWkHlgtSrQS9JXCUDAABA8SpwIUtJSdF7772nxo0bq1OnTkpNTdXq1auVlJSk3377TY8//rgGDx5cmFmBIpO7ucenuz/VhcsXTE4DAACA0qJAheyhhx5SUFCQFixYoBEjRui3337TkiVL1LVrV0lSmTJl9Pzzz+vEiROFGhYoKp1rd1bDSg11KeuSPt39qdlxAAAAUEoUqJBVqVJFmzdv1p49ezRu3DhVqFAhz5rKlSsrKSnptgMCxcFisdiuks3YOUOGYZicCAAAAKVBgQrZvffeq1atWuU5npmZqU8/vXJ1wWKxqFatWreXDihGA5sPlK+Hrw6cPaAfkn4wOw4AAABKgQIVsqFDh+rChbzvs7l48aKGDh1626EAM/h5+mlQs0GSpOmx001OAwAAgNKgQIXMMAxZLJY8x0+ePKly5crddijALBFtr7xscdXBVTp+4bjJaQAAAODs3G5lccuWLWWxWGSxWNSlSxe5uf3/H8/JyVFSUpK6d+9e6CGB4tKociN1rt1ZG49u1Ec7P9JbXd4yOxIAAACc2C0Vsl69ekmSEhISFBYWJl9fX9ttHh4eql27tnr37l2oAYHiFtk2UhuPbtScXXM06d5J8nTzNDsSAAAAnNQtFbLJkydLkmrXrq2+ffvKy8urSEIBZnq4/sOq4VdDJ1NPavm+5Xqy2ZNmRwIAAICTKtB7yAYPHkwZg9Nyc3HTqJBRkqSo2CiT0wAAAMCZ5buQVahQQWfPnpUklS9fXhUqVLjuF1DSjWg1Qu4u7tp2cpviTsWZHQcAAABOKt8vWfzggw9UtmxZ239fa5dFwFkE+AaoT+M+Wpy4WFGxUZrXc57ZkQAAAOCE8l3IBg8ebPvvIUOGFEUWwKFEtInQ4sTFWrJnif51/79U0aei2ZEAAADgZAr0HrIFCxZc83h2drYmTpx4O3kAhxFaI1QtA1vqcvZlzYvnChkAAAAKX4EK2TPPPKM+ffrozz//tB07ePCg2rVrpyVLlhRaOMBMFotFEW2ufFD0zJ0zlWPNMTkRAAAAnE2BCll8fLxOnjyppk2bKjo6WlFRUWrVqpUaNGig3bt3F3ZGwDT9m/ZXea/ySjqfpO8Of2d2HAAAADiZAhWyOnXq6KefftKjjz6q7t2767nnntPcuXO1aNEilStXrrAzAqbxcffRsJbDJLEFPgAAAApfgQqZJH377bdaunSpQkND5e/vr48//linTp0qzGyAQxjTeowssmjt4bU6/Mdhs+MAAADAiRSokI0aNUp9+vTRSy+9pP/+97/6+eef5eHhoaZNm+rzzz8v7IyAqepUqKPweuGSpBmxM0xOAwAAAGdSoEL2008/afv27Xr++edlsVgUGBioNWvW6PXXX9ewYcMKOyNgutzNPeYnzNelzEsmpwEAAICzKFAhi4uLU/PmzfMcj4iIUFxc3G2HAhxN97rddUf5O3T+8nktTlxsdhwAAAA4iQIVMk9PTx05ckSvvPKK+vfvrzNnzkiSvvvuO2VnZxdqQMARuFhcNLb1WElXNvcwDMPkRAAAAHAGBSpkmzdvVtOmTbV9+3atWLFCaWlpkqTdu3dr8uTJhRoQcBRDWw6Vl5uXdqfs1tYTW82OAwAAACdQoEL2j3/8Q2+++aaio6Pl4eFhO37fffdp27ZthRYOcCQVvCvoiSZPSJKmx043OQ0AAACcQYEKWWJioh555JE8x6tUqaKzZ8/edijAUUW0vbK5x5f7vlRyWrLJaQAAAFDSFaiQ+fv76/Tp03mOx8fHq3r16rcdCnBUraq2UmiNUGVZszQnbo7ZcQAAAFDCFaiQ9evXTy+99JKSk5NlsVhktVr1008/6YUXXtCgQYMKOyPgUHK3wJ8VN0tZOVkmpwEAAEBJVqBC9s9//lMNGjRQUFCQ0tLS1KhRI3Xs2FF33323XnnllcLOCDiUxxo9piplqujUxVNaeXCl2XEAAABQghWokHl4eGjOnDk6cuSIVq9erYULF+rAgQP67LPP5OrqWtgZAYfi6eapEa1GSLqyBT4AAABQUG6388M1a9ZUzZo1CysLUGKMChmlt398W5uObtKeM3vUpEoTsyMBAACgBMp3IRs/fny+73TatGkFCgOUFEHlgtSzQU+t2L9CM2JnaEaPGWZHAgAAQAmU70IWHx+fr3UWi6XAYYCSJKJNhFbsX6FPd3+qqV2mqpxXObMjAQAAoITJdyHbuHFjUeYASpzOtTurYaWG2n92vz7d/amebve02ZEAAABQwhRoU4+rnThxQidOnCiMLECJYrFYbFvgR8VGyTAMkxMBAACgpClQIcvOztarr76qcuXKqXbt2qpdu7bKlSunV155RVlZfC4TSo+BzQfK18NXB88d1IakDWbHAQAAQAlToEL29NNPa/bs2Xr33XcVHx+v+Ph4vfvuu/r444/1zDPPFHZGwGH5efppcPPBktgCHwAAALeuQIVs8eLFWrBggUaNGqVmzZqpWbNmGjVqlD7++GMtXrw43/ezZcsWPfTQQ6pWrZosFou+/vpru9uHDBkii8Vi99W9e3e7NX/88YcGDBggPz8/+fv7a/jw4UpLS7Nb8/PPP6tDhw7y8vJSUFCQ3n333TxZli9frgYNGsjLy0tNmzbVmjVr8v+EoFQb22asJGnVwVU6fuG4yWkAAABQkhSokHl6eqp27dp5jgcHB8vDwyPf93Pp0iU1b95cUVHXv7LQvXt3nT592va1ZMkSu9sHDBigvXv3Kjo6WqtXr9aWLVs0cuRI2+2pqanq1q2batWqpbi4OP3rX//Sa6+9ptmzZ9vWbN26Vf3799fw4cMVHx+vXr16qVevXtqzZ0++HwtKr0aVG+m+4PtkNayatXOW2XEAAABQghTog6EjIyP1xhtvaP78+fL09JQkZWRk6K233lJkZGS+7yc8PFzh4eE3XOPp6anAwMBr3rZ//36tXbtWsbGxat26tSTpP//5jx544AG99957qlatmhYtWqTMzEzNmzdPHh4eaty4sRISEjRt2jRbcfvwww/VvXt3TZgwQZL0xhtvKDo6WtOnT9esWdf+B3ZGRoYyMjJs36empkqSsrKyTH8fXe75zc5RmoxqOUo/JP2gubvm6uW7X5anm2ehn4O5Oh9m6pyYq/Nhps6JuTofR5rprWQoUCGLj4/Xhg0bVKNGDTVv3lyStHv3bmVmZqpLly569NFHbWtXrFhRkFPYbNq0SVWqVFH58uV133336c0331TFihUlSTExMfL397eVMUnq2rWrXFxctH37dj3yyCOKiYlRx44d7a7chYWF6Z133tGff/6p8uXLKyYmJs8HX4eFheV5CeXVpk6dqilTpuQ5vn79evn4+NzWYy4s0dHRZkcoNdwMN1V0r6jf03/Xq0tfVacKnYrsXMzV+TBT58RcnQ8zdU7M1fk4wkzT09PzvbZAhczf31+9e/e2OxYUFFSQu7qh7t2769FHH1VwcLCOHDmil19+WeHh4YqJiZGrq6uSk5NVpUoVu59xc3NThQoVlJycLElKTk5WcHCw3ZqAgADbbeXLl1dycrLt2NVrcu/jWiZOnGhX4lJTUxUUFKRu3brJz8/vth737crKylJ0dLTuv/9+ubu7m5qlNHnG/xlN3jxZW7O36t0H8r5P8XYxV+fDTJ0Tc3U+zNQ5MVfn40gzzX31XH7cciEzDENTpkxR5cqV5e3tfas/fkv69etn+++mTZuqWbNmqlOnjjZt2qQuXboU6blvxtPT0/Zyzau5u7ub/guQy5GylAajWo/Sm/99UztO7dDu33erdbXWN/+hAmCuzoeZOifm6nyYqXNirs7HEWZ6K+e/5U09DMNQ3bp1dfLkyVv90dt2xx13qFKlSjp8+LAkKTAwUGfOnLFbk52drT/++MP2vrPAwEClpKTYrcn9/mZrrvfeNeBaAnwD1KdxH0lsgQ8AAID8ueVC5uLionr16uncuXNFkeeGTp48qXPnzqlq1aqSpNDQUJ0/f15xcXG2NT/88IOsVqvatWtnW7Nlyxa7N9ZFR0erfv36Kl++vG3Nhg32H+obHR2t0NDQon5IcDKRba5sarN0z1KdSy/+PyMAAAAoWQq07f3bb7+tCRMm3Pa28GlpaUpISFBCQoIkKSkpSQkJCTp+/LjS0tI0YcIEbdu2TUePHtWGDRvUs2dP1a1bV2FhYZKkhg0bqnv37hoxYoR27Nihn376SZGRkerXr5+qVasmSXriiSfk4eGh4cOHa+/evVq2bJk+/PBDu/d/Pfvss1q7dq3ef/99HThwQK+99pp27tx5SztGApJ0V4271DKwpS5nX9a8+HlmxwEAAICDK1AhGzRokHbs2KHmzZvL29tbFSpUsPvKr507d6ply5Zq2bKlJGn8+PFq2bKlJk2aJFdXV/388896+OGHdeedd2r48OEKCQnRf//7X7v3bi1atEgNGjRQly5d9MADD6h9+/Z2nzFWrlw5rV+/XklJSQoJCdHzzz+vSZMm2X1W2d13363Fixdr9uzZat68ub744gt9/fXXatKkSUGeHpRiFotFEW0iJEkzds5QjjXH5EQAAABwZAXaZfHf//53oZy8U6dOMgzjurevW7fupvdRoUIFLV68+IZrmjVrpv/+9783XNOnTx/16dPnpucDbqZ/0/6aED1BR88f1XeHv9ODdz5odiQAAAA4qAIVssGDBxd2DsBp+Lj7aFjLYXo/5n1FxUZRyAAAAHBdBXrJoiQdOXJEr7zyivr372/b6fC7777T3r17Cy0cUFKNaT1GFlm09vBaHTp3yOw4AAAAcFAFKmSbN29W06ZNtX37dq1YsUJpaWmSpN27d2vy5MmFGhAoiepUqKPweuGSpJk7Z5qcBgAAAI6qQIXsH//4h958801FR0fLw8PDdvy+++7Ttm3bCi0cUJLlbu4xL36eLmVeMjkNAAAAHFGBClliYqIeeeSRPMerVKmis2fP3nYowBl0r9tdd5S/QxcyLmhx4o03ngEAAEDpVKBC5u/vr9OnT+c5Hh8fr+rVq992KMAZuFhcNLb1WElSVGzUDXcUBQAAQOlUoELWr18/vfTSS0pOTpbFYpHVatVPP/2kF154QYMGDSrsjECJNbTlUHm5eWl3ym79dOIns+MAAADAwRSokP3zn/9Uw4YNVbNmTaWlpalRo0bq2LGj7r77br3yyiuFnREosSp4V9CApgMkXblKBgAAAFztlgqZ1WrVO++8o86dOys+Pl4DBw7U6tWrtXDhQh04cECfffaZXF1diyorUCLlbu7xxb4vdPpi3pf6AgAAoPS6pUL21ltv6eWXX5avr6+qV6+uxYsX64svvtDjjz+uevXqFVVGoERrWbWlQmuEKtuarTm75pgdBwAAAA7klgrZp59+qhkzZmjdunX6+uuv9c0332jRokWyWq1FlQ9wCpFtIyVJH8V9pKycLJPTAAAAwFHcUiE7fvy4HnjgAdv3Xbt2lcVi0alTpwo9GOBMejfsrSplqujUxVNaeXCl2XEAAADgIG6pkGVnZ8vLy8vumLu7u7Ky+F/8gRvxdPPUyFYjJUnTd0w3OQ0AAAAchdutLDYMQ0OGDJGnp6ft2OXLlzV69GiVKVPGdmzFihWFlxBwEqNaj9LUH6dq87HN2nNmj5pUaWJ2JAAAAJjslq6QDR48WFWqVFG5cuVsX08++aSqVatmdwxAXjX8aqhng56SpKgdbIEPAACAW7xCNn/+/KLKAZQKkW0itWL/Cn3282d6u+vbKufF/4ABAABQmhXog6EBFEyn2p3UqHIjXcq6pE93f2p2HAAAAJiMQgYUI4vForGtx0qSomKjZBiGyYkAAABgJgoZUMwGNR+ksh5ldfDcQW1I2mB2HAAAAJiIQgYUs7KeZTWo+SBJV66SAQAAoPSikAEmiGgTIUladXCVjl84bnIaAAAAmIVCBpigYeWGui/4PlkNq2btnGV2HAAAAJiEQgaYJPcq2Zxdc3Q5+7LJaQAAAGAGChlgkofrP6wafjV0Nv2slu9dbnYcAAAAmIBCBpjEzcVNo0NGS2JzDwAAgNKKQgaY6KlWT8ndxV3bf9uunad2mh0HAAAAxYxCBpgowDdAjzd+XBJXyQAAAEojChlgstzNPZYkLtG59HMmpwEAAEBxopABJrurxl1qGdhSGTkZ+jj+Y7PjAAAAoBhRyACTWSwWRbaNlCTN3DlTOdYckxMBAACguFDIAAfQr0k/lfcqr6Pnj+q7w9+ZHQcAAADFhEIGOAAfdx8NbzlckjR9x3ST0wAAAKC4UMgABzGmzRhZZNG6I+t06Nwhs+MAAACgGFDIAAdxR/k7FF4vXJI0I3aGyWkAAABQHChkgAOJbHNlc4/5CfN1KfOSyWkAAABQ1ChkgAMJqxumOuXr6ELGBS1OXGx2HAAAABQxChngQFwsLhrTeowkaXrsdBmGYXIiAAAAFCUKGeBghrYcKm83b/2c8rN+OvGT2XEAAABQhChkgIOp4F1BTzR9QpIUFRtlchoAAAAUJQoZ4IAi2kRIkr7Y94VOXzxtchoAAAAUFQoZ4IBaVm2pu4PuVrY1W3N2zTE7DgAAAIoIhQxwULlXyT6K+0hZOVkmpwEAAEBRoJABDuqxRo8poEyATl08pa8PfG12HAAAABQBChngoDxcPTSi1QhJbO4BAADgrChkgAMb1XqUXC2u2nxssxLPJJodBwAAAIWMQgY4sBp+NdSrQS9JV95LBgAAAOdCIQMcXO7mHov2LNKlnEsmpwEAAEBhopABDq5T7U5qVLmRLmVd0sY/NpodBwAAAIWIQgY4OIvFYrtK9t3Z72QYhsmJAAAAUFgoZEAJMLDZQJX1KKvfMn7TD0d/MDsOAAAACgmFDCgBynqW1ZNNn5QkzYibYXIaAAAAFBYKGVBCjA4ZLUn69tC3Onb+mMlpAAAAUBgoZEAJ0bBSQzX1bSqrYdWsnbPMjgMAAIBCQCEDSpAelXpIkubGz9Xl7MsmpwEAAMDtMrWQbdmyRQ899JCqVasmi8Wir7/+2u52wzA0adIkVa1aVd7e3uratasOHTpkt+aPP/7QgAED5OfnJ39/fw0fPlxpaWl2a37++Wd16NBBXl5eCgoK0rvvvpsny/Lly9WgQQN5eXmpadOmWrNmTaE/XuB2tSnXRkF+QTqbflbL9y43Ow4AAABuk6mF7NKlS2revLmioqKuefu7776r//3f/9WsWbO0fft2lSlTRmFhYbp8+f9fGRgwYID27t2r6OhorV69Wlu2bNHIkSNtt6empqpbt26qVauW4uLi9K9//UuvvfaaZs+ebVuzdetW9e/fX8OHD1d8fLx69eqlXr16ac+ePUX34IECcLW46qmWT0mSpsdONzkNAAAAbpephSw8PFxvvvmmHnnkkTy3GYahf//733rllVfUs2dPNWvWTJ9++qlOnTplu5K2f/9+rV27VnPnzlW7du3Uvn17/ec//9HSpUt16tQpSdKiRYuUmZmpefPmqXHjxurXr5+eeeYZTZs2zXauDz/8UN27d9eECRPUsGFDvfHGG2rVqpWmT+cfvHA8w1sMl4erh3b8tkM7T+00Ow4AAABug5vZAa4nKSlJycnJ6tq1q+1YuXLl1K5dO8XExKhfv36KiYmRv7+/WrdubVvTtWtXubi4aPv27XrkkUcUExOjjh07ysPDw7YmLCxM77zzjv7880+VL19eMTExGj9+vN35w8LC8ryE8moZGRnKyMiwfZ+amipJysrKUlZW1u0+/NuSe36zc6Bw5c6zvEd59W7QW0v2LtF/tv9Hcx+ca3IyFBR/Vp0Tc3U+zNQ5MVfn40gzvZUMDlvIkpOTJUkBAQF2xwMCAmy3JScnq0qVKna3u7m5qUKFCnZrgoOD89xH7m3ly5dXcnLyDc9zLVOnTtWUKVPyHF+/fr18fHzy8xCLXHR0tNkRUASio6PVPLO5lmiJliQuUVdrV/m5+ZkdC7eBP6vOibk6H2bqnJir83GEmaanp+d7rcMWMkc3ceJEu6tqqampCgoKUrdu3eTnZ+4/jrOyshQdHa37779f7u7upmZB4bl6ruFu4Vo2f5nik+N1svJJvRD6gtnxUAD8WXVOzNX5MFPnxFydjyPNNPfVc/nhsIUsMDBQkpSSkqKqVavajqekpKhFixa2NWfOnLH7uezsbP3xxx+2nw8MDFRKSordmtzvb7Ym9/Zr8fT0lKenZ57j7u7upv8C5HKkLCg8uXONbBup4auGa3b8bL3Y/kW5uriaHQ0FxJ9V58RcnQ8zdU7M1fk4wkxv5fwO+zlkwcHBCgwM1IYNG2zHUlNTtX37doWGhkqSQkNDdf78ecXFxdnW/PDDD7JarWrXrp1tzZYtW+xexxkdHa369eurfPnytjVXnyd3Te55AEfUv0l/VfCuoKPnj2rNIT6mAQAAoCQytZClpaUpISFBCQkJkq5s5JGQkKDjx4/LYrFo3LhxevPNN7Vq1SolJiZq0KBBqlatmnr16iVJatiwobp3764RI0Zox44d+umnnxQZGal+/fqpWrVqkqQnnnhCHh4eGj58uPbu3atly5bpww8/tHu54bPPPqu1a9fq/fff14EDB/Taa69p586dioyMLO6nBMg3b3dvDWsxTJIUFXvtj44AAACAYzO1kO3cuVMtW7ZUy5YtJUnjx49Xy5YtNWnSJEnSiy++qKefflojR45UmzZtlJaWprVr18rLy8t2H4sWLVKDBg3UpUsXPfDAA2rfvr3dZ4yVK1dO69evV1JSkkJCQvT8889r0qRJdp9Vdvfdd2vx4sWaPXu2mjdvri+++EJff/21mjRpUkzPBFAwY9qMkUUWrTuyTr+c+8XsOAAAALhFpr6HrFOnTjIM47q3WywWvf7663r99devu6ZChQpavHjxDc/TrFkz/fe//73hmj59+qhPnz43Dgw4mDvK36EH6j2gbw99q5mxM/VB9w/MjgQAAIBb4LDvIQOQPxFtIiRJ8xPm61LmJZPTAAAA4FZQyIASLqxumOqUr6MLGRe0KHGR2XEAAABwCyhkQAnnYnHR2DZjJV3Z3ONGLwMGAACAY6GQAU5gaIuh8nbz1s8pP+unEz+ZHQcAAAD5RCEDnEB57/J6oukTkqTpO6abnAYAAAD5RSEDnETu5h5f7v9Spy+eNjkNAAAA8oNCBjiJllVb6u6gu5VtzdacXXPMjgMAAIB8oJABTiSyTaQkadbOWcrKyTI5DQAAAG6GQgY4kd6NeiugTIBOp53W1we+NjsOAAAAboJCBjgRD1cPjWg1QpI0PZbNPQAAABwdhQxwMqNaj5KrxVVbjm1RYkqi2XEAAABwAxQywMnU8KuhXg16SZJmxM4wNwwAAABuiEIGOKHcLfA/+/kzXbh8weQ0AAAAuB4KGeCEOtXupEaVG+lS1iV9svsTs+MAAADgOihkgBOyWCy2q2RRsVGyGlaTEwEAAOBaKGSAkxrYbKDKepTVL+d+0YZfN5gdBwAAANdAIQOcVFnPshrcfLCkK1fJAAAA4HgoZIATG9tmrCTpm1++0bHzx0xOAwAAgL+jkAFOrGHlhuoS3EVWw6pZO2eZHQcAAAB/QyEDnFzu5h5z4+fqcvZlk9MAAADgahQywMk9VP8hBfkF6Wz6WX2+93Oz4wAAAOAqFDLAybm5uGl069GS2NwDAADA0VDIgFLgqVZPycPVQzt+26HY32LNjgMAAID/QyEDSoEqZaqoT6M+krhKBgAA4EgoZEApEdk2UpK0dM9SnU0/a3IaAAAASBQyoNRoV72dWlVtpYycDM2Ln2d2HAAAAIhCBpQaFotFkW2uXCWbETtDOdYckxMBAACAQgaUIv2a9FMF7wo6duGY1hxaY3YcAACAUo9CBpQi3u7eGtZimCRpeux0k9MAAACAQgaUMmPajJFFFq0/sl6/nPvF7DgAAAClGoUMKGXuKH+HHqj3gCRpZuxMk9MAAACUbhQyoBSKaBMhSZqfMF+XMi+ZnAYAAKD0opABpVBY3TDVKV9HFzIuaFHiIrPjAAAAlFoUMqAUcrG4aGybsZKkqNgoGYZhciIAAIDSiUIGlFJDWwyVt5u3fk75WT8e/9HsOAAAAKUShQwopcp7l9eApgMkXblKBgAAgOJHIQNKsYi2Vzb3+HL/lzp98bTJaQAAAEofChlQirUIbKF7gu5RtjVbs+Nmmx0HAACg1KGQAaVc7hb4H8V9pKycLJPTAAAAlC4UMqCU692otwLKBOh02ml9deArs+MAAACUKhQyoJTzcPXQyJCRktjcAwAAoLhRyABoVMgouVpcteXYFiWmJJodBwAAoNSgkAFQdb/q6tWglySukgEAABQnChkASVJk20hJ0sKfF+rC5QsmpwEAACgdKGQAJEn31rpXjSs31qWsS/pk9ydmxwEAACgVKGQAJEkWi0Vj24yVdOVli1bDanIiAAAA50chA2AzsNlAlfUoq1/O/aINv24wOw4AAIDTo5ABsCnrWVaDmw+WJE2PnW5yGgAAAOdHIQNgJ6JthCRp9S+rdez8MZPTAAAAODcKGQA7DSo1UJfgLrIaVs3aOcvsOAAAAE6NQgYgj4g2V66Szdk1R5ezL5ucBgAAwHlRyADk8VD9hxTkF6Rzf53T53s/NzsOAACA06KQAcjDzcVNo1uPlnRlC3wAAAAUDQoZgGt6qtVT8nD10I7fdij2t1iz4wAAADglhy5kr732miwWi91XgwYNbLdfvnxZERERqlixonx9fdW7d2+lpKTY3cfx48fVo0cP+fj4qEqVKpowYYKys7Pt1mzatEmtWrWSp6en6tatqwULFhTHwwMcWpUyVfR448clcZUMAACgqDh0IZOkxo0b6/Tp07avH3/80Xbbc889p2+++UbLly/X5s2bderUKT366KO223NyctSjRw9lZmZq69at+uSTT7RgwQJNmjTJtiYpKUk9evRQ586dlZCQoHHjxumpp57SunXrivVxAo4od3OPpXuW6mz6WZPTAAAAOB+HL2Rubm4KDAy0fVWqVEmSdOHCBX388ceaNm2a7rvvPoWEhGj+/PnaunWrtm3bJklav3699u3bp4ULF6pFixYKDw/XG2+8oaioKGVmZkqSZs2apeDgYL3//vtq2LChIiMj9dhjj+mDDz4w7TEDjqJd9XZqVbWVMnIy9PGuj82OAwAA4HTczA5wM4cOHVK1atXk5eWl0NBQTZ06VTVr1lRcXJyysrLUtWtX29oGDRqoZs2aiomJ0V133aWYmBg1bdpUAQEBtjVhYWEaM2aM9u7dq5YtWyomJsbuPnLXjBs37oa5MjIylJGRYfs+NTVVkpSVlaWsrKxCeOQFl3t+s3OgcJk11zGtxmjEtyM0c+dMPdvmWbm6uBbr+Z0Zf1adE3N1PszUOTFX5+NIM72VDA5dyNq1a6cFCxaofv36On36tKZMmaIOHTpoz549Sk5OloeHh/z9/e1+JiAgQMnJyZKk5ORkuzKWe3vubTdak5qaqr/++kve3t7XzDZ16lRNmTIlz/H169fLx8enQI+3sEVHR5sdAUWguOfqZ/VTWdeyOnbhmN5Y9obalmtbrOcvDfiz6pyYq/Nhps6JuTofR5hpenp6vtc6dCELDw+3/XezZs3Url071apVS59//vl1i1JxmThxosaPH2/7PjU1VUFBQerWrZv8/PxMTHalkUdHR+v++++Xu7u7qVlQeMyc63af7Zq2bZpiFavXHnitWM/tzPiz6pyYq/Nhps6JuTofR5pp7qvn8sOhC9nf+fv7684779Thw4d1//33KzMzU+fPn7e7SpaSkqLAwEBJUmBgoHbs2GF3H7m7MF695u87M6akpMjPz++Gpc/T01Oenp55jru7u5v+C5DLkbKg8Jgx18i2kfpg2weKTopWUmqS7qx4Z7Ge39nxZ9U5MVfnw0ydE3N1Po4w01s5v8Nv6nG1tLQ0HTlyRFWrVlVISIjc3d21YcMG2+0HDx7U8ePHFRoaKkkKDQ1VYmKizpw5Y1sTHR0tPz8/NWrUyLbm6vvIXZN7HwCk4PLBeqDeA5KkGbEzTE4DAADgPBy6kL3wwgvavHmzjh49qq1bt+qRRx6Rq6ur+vfvr3Llymn48OEaP368Nm7cqLi4OA0dOlShoaG66667JEndunVTo0aNNHDgQO3evVvr1q3TK6+8ooiICNvVrdGjR+vXX3/Viy++qAMHDmjGjBn6/PPP9dxzz5n50AGHE9k2UpK0IGGBLmVeMjkNAACAc3DoQnby5En1799f9evX1+OPP66KFStq27Ztqly5siTpgw8+0IMPPqjevXurY8eOCgwM1IoVK2w/7+rqqtWrV8vV1VWhoaF68sknNWjQIL3++uu2NcHBwfr2228VHR2t5s2b6/3339fcuXMVFhZW7I8XcGTd6nRT3Qp1dSHjghYlLjI7DgAAgFNw6PeQLV269Ia3e3l5KSoqSlFRUdddU6tWLa1Zs+aG99OpUyfFx8cXKCNQWrhYXDSm9Rg9v/55Td8xXSNajZDFYjE7FgAAQInm0FfIADiWoS2GytvNW4lnEvXj8R/NjgMAAFDiUcgA5Ft57/Ia0HSAJCkq9vpXpgEAAJA/FDIAtySibYQk6cv9X+r0xdMmpwEAACjZKGQAbkmLwBa6J+geZVuzNTtuttlxAAAASjQKGYBbFtHmylWyj+I+UlZOlslpAAAASi4KGYBb1rtRbwWUCdDptNP66sBXZscBAAAosShkAG6Zh6uHRoaMlMTmHgAAALeDQgagQEaFjJKrxVVbjm1RYkqi2XEAAABKJAoZgAKp7lddjzR8RBJXyQAAAAqKQgagwHI39/js5890/vJ5c8MAAACUQBQyAAV2b6171bhyY6VnpeuThE/MjgMAAFDiUMgAFJjFYrFdJZuxc4ashtXkRAAAACULhQzAbXmy2ZMq61FWv5z7Rd//+r3ZcQAAAEoUChmA21LWs6yGtBgiic09AAAAbhWFDMBtG9tmrCRp9S+rdfT8UXPDAAAAlCAUMgC3rUGlBuoS3EVWw6pZO2eZHQcAAKDEoJABKBSRbSMlSXN3zdXl7MsmpwEAACgZKGQACsWDdz6oIL8gnfvrnD7f+7nZcQAAAEoEChmAQuHm4qbRrUdLkqbvmG5yGgAAgJKBQgag0DzV6il5uHoo9lSsYn+LNTsOAACAw6OQASg0VcpU0eONH5fEFvgAAAD5QSEDUKgi2kRIkpbuWaqz6WdNTgMAAODYKGQAClW76u0UUjVEGTkZ+njXx2bHAQAAcGgUMgCFymKx2K6Szdw5UznWHJMTAQAAOC4KGYBC169JP1XwrqBjF47p20Pfmh0HAADAYVHIABQ6b3dvDW85XBKbewAAANwIhQxAkRjTeowssmj9kfX65dwvZscBAABwSBQyAEUiuHywetzZQ5I0I3aGyWkAAAAcE4UMQJHJ3dxjQcICpWWmmZwGAADA8VDIABSZbnW6qW6FurqQcUGLfl5kdhwAAACHQyEDUGRcLC4a23qspCubexiGYXIiAAAAx0IhA1CkhrQYIm83byWeSdSPx380Ow4AAIBDoZABKFLlvctrQNMBkqTpsdNNTgMAAOBYKGQAilxE2yube6zYv0KnLp4yOQ0AAIDjoJABKHItAlvonqB7lG3N1uy42WbHAQAAcBgUMgDFIrJtpCRpdtxsZeVkmZwGAADAMVDIABSLRxs+qoAyATqddlpfHfjK7DgAAAAOgUIGoFh4uHpoZMhISdL0HWzuAQAAIFHIABSjUSGj5Gpx1X+P/1eJKYlmxwEAADAdhQxAsanuV12PNHxE0pUPigYAACjtKGQAilVEmytb4H/282c6f/m8uWEAAABMRiEDUKzurXWvGldurPSsdH2S8InZcQAAAExFIQNQrCwWi+0qWVRslKyG1eREAAAA5qGQASh2A5sPlJ+nnw79cUjf//q92XEAAABMQyEDUOx8PXw1uPlgSWzuAQAASjcKGQBTjG0zVpL0zcFvdPT8UXPDAAAAmIRCBsAUDSo1UNc7usqQoVk7Z5kdBwAAwBQUMgCmyd3cY+6uubqcfdnkNAAAAMWPQgbANA/e+aCC/IJ07q9zWrZnmdlxAAAAih2FDIBp3FzcNKb1GEls7gEAAEonChkAUz3V6il5uHoo9lSsdvy2w+w4AAAAxYpCBsBUlctU1uONH5fEVTIAAFD6UMgAmC6yTaQkadmeZfr90u8mpwEAACg+FDIApmtbva1CqoYoIydDH8d/bHYcAACAYkMhA2A6i8WiyLZXrpLN2jlLOdYckxMBAAAUDwrZ30RFRal27dry8vJSu3bttGMHmwwAxaFv476q4F1Bxy4c07eHvjU7DgAAQLGgkF1l2bJlGj9+vCZPnqxdu3apefPmCgsL05kzZ8yOBjg9b3dvDW85XJI0fcd0k9MAAAAUDzezAziSadOmacSIERo6dKgkadasWfr22281b948/eMf/zA5HeD8xrQeo/e2vqfoX6M1O262/Dz9ij2DRZZiO1d2TrYS/kzQpX2X5OZWvH8dF+fjtDuvpfjPW9yPNTsnW/Hn45VxIKPY54qikZ2drV3ndzFTJ8NcnU929pW/fx/QA2ZHuSX89v2fzMxMxcXFaeLEibZjLi4u6tq1q2JiYvKsz8jIUEZGhu371NRUSVJWVpaysrKKPvAN5J7f7BwoXKVhrjV8ayi8brjWHF6jUatHmR2n+BwzOwCKxFGzA6DQHTU7AIrEUbMDoDC5W9z1atarZse4pX+vUcj+z9mzZ5WTk6OAgAC74wEBATpw4ECe9VOnTtWUKVPyHF+/fr18fHyKLOetiI6ONjsCioCzzzXcLVxn/M4ow5px88VOwJBR/Oc0iv+cZjHl+TXhnACAK9wsbg7xb6X09PR8r6WQFdDEiRM1fvx42/epqakKCgpSt27d5OdX/C+zulpWVpaio6N1//33y93d3dQsKDylaa6jVDqujpWmmZYmzNX5MFPnxFydjyPNNPfVc/lBIfs/lSpVkqurq1JSUuyOp6SkKDAwMM96T09PeXp65jnu7u5u+i9ALkfKgsLDXJ0PM3VOzNX5MFPnxFydjyPM9FbOzy6L/8fDw0MhISHasGGD7ZjVatWGDRsUGhpqYjIAAAAAzoorZFcZP368Bg8erNatW6tt27b697//rUuXLtl2XQQAAACAwkQhu0rfvn31+++/a9KkSUpOTlaLFi20du3aPBt9AAAAAEBhoJD9TWRkpCIjI82OAQAAAKAU4D1kAAAAAGASChkAAAAAmIRCBgAAAAAmoZABAAAAgEkoZAAAAABgEgoZAAAAAJiEQgYAAAAAJqGQAQAAAIBJKGQAAAAAYBIKGQAAAACYhEIGAAAAACahkAEAAACASShkAAAAAGASN7MDOAvDMCRJqampJieRsrKylJ6ertTUVLm7u5sdB4WEuTofZuqcmKvzYabOibk6H0eaaW4nyO0IN0IhKyQXL16UJAUFBZmcBAAAAIAjuHjxosqVK3fDNRYjP7UNN2W1WnXq1CmVLVtWFovF1CypqakKCgrSiRMn5OfnZ2oWFB7m6nyYqXNirs6HmTon5up8HGmmhmHo4sWLqlatmlxcbvwuMa6QFRIXFxfVqFHD7Bh2/Pz8TP9lROFjrs6HmTon5up8mKlzYq7Ox1FmerMrY7nY1AMAAAAATEIhAwAAAACTUMickKenpyZPnixPT0+zo6AQMVfnw0ydE3N1PszUOTFX51NSZ8qmHgAAAABgEq6QAQAAAIBJKGQAAAAAYBIKGQAAAACYhEIGAAAAACahkDmhqKgo1a5dW15eXmrXrp127NhhdiRcx9SpU9WmTRuVLVtWVapUUa9evXTw4EG7NZcvX1ZERIQqVqwoX19f9e7dWykpKXZrjh8/rh49esjHx0dVqlTRhAkTlJ2dXZwPBdfx9ttvy2KxaNy4cbZjzLTk+e233/Tkk0+qYsWK8vb2VtOmTbVz507b7YZhaNKkSapataq8vb3VtWtXHTp0yO4+/vjjDw0YMEB+fn7y9/fX8OHDlZaWVtwPBf8nJydHr776qoKDg+Xt7a06derojTfe0NV7nTFXx7dlyxY99NBDqlatmiwWi77++mu72wtrhj///LM6dOggLy8vBQUF6d133y3qh1Zq3WimWVlZeumll9S0aVOVKVNG1apV06BBg3Tq1Cm7+yhxMzXgVJYuXWp4eHgY8+bNM/bu3WuMGDHC8Pf3N1JSUsyOhmsICwsz5s+fb+zZs8dISEgwHnjgAaNmzZpGWlqabc3o0aONoKAgY8OGDcbOnTuNu+66y7j77rttt2dnZxtNmjQxunbtasTHxxtr1qwxKlWqZEycONGMh4Sr7Nixw6hdu7bRrFkz49lnn7UdZ6Ylyx9//GHUqlXLGDJkiLF9+3bj119/NdatW2ccPnzYtubtt982ypUrZ3z99dfG7t27jYcfftgIDg42/vrrL9ua7t27G82bNze2bdtm/Pe//zXq1q1r9O/f34yHBMMw3nrrLaNixYrG6tWrjaSkJGP58uWGr6+v8eGHH9rWMFfHt2bNGuN//ud/jBUrVhiSjK+++sru9sKY4YULF4yAgABjwIABxp49e4wlS5YY3t7exkcffVRcD7NUudFMz58/b3Tt2tVYtmyZceDAASMmJsZo27atERISYncfJW2mFDIn07ZtWyMiIsL2fU5OjlGtWjVj6tSpJqZCfp05c8aQZGzevNkwjCt/8bi7uxvLly+3rdm/f78hyYiJiTEM48pfXC4uLkZycrJtzcyZMw0/Pz8jIyOjeB8AbC5evGjUq1fPiI6ONu69915bIWOmJc9LL71ktG/f/rq3W61WIzAw0PjXv/5lO3b+/HnD09PTWLJkiWEYhrFv3z5DkhEbG2tb89133xkWi8X47bffii48rqtHjx7GsGHD7I49+uijxoABAwzDYK4l0d//8V5YM5wxY4ZRvnx5u79/X3rpJaN+/fpF/IhwrZL9dzt27DAkGceOHTMMo2TOlJcsOpHMzEzFxcWpa9eutmMuLi7q2rWrYmJiTEyG/Lpw4YIkqUKFCpKkuLg4ZWVl2c20QYMGqlmzpm2mMTExatq0qQICAmxrwsLClJqaqr179xZjelwtIiJCPXr0sJudxExLolWrVql169bq06ePqlSpopYtW2rOnDm225OSkpScnGw303Llyqldu3Z2M/X391fr1q1ta7p27SoXFxdt3769+B4MbO6++25t2LBBv/zyiyRp9+7d+vHHHxUeHi6JuTqDwpphTEyMOnbsKA8PD9uasLAwHTx4UH/++WcxPRpcz4ULF2SxWOTv7y+pZM7UrdjPiCJz9uxZ5eTk2P0jTpICAgJ04MABk1Ihv6xWq8aNG6d77rlHTZo0kSQlJyfLw8PD9pdMroCAACUnJ9vWXGvmubeh+C1dulS7du1SbGxsntuYacnz66+/aubMmRo/frxefvllxcbG6plnnpGHh4cGDx5sm8m1Znb1TKtUqWJ3u5ubmypUqMBMTfKPf/xDqampatCggVxdXZWTk6O33npLAwYMkCTm6gQKa4bJyckKDg7Ocx+5t5UvX75I8uPmLl++rJdeekn9+/eXn5+fpJI5UwoZ4CAiIiK0Z88e/fjjj2ZHwW04ceKEnn32WUVHR8vLy8vsOCgEVqtVrVu31j//+U9JUsuWLbVnzx7NmjVLgwcPNjkdCurzzz/XokWLtHjxYjVu3FgJCQkaN26cqlWrxlyBEiArK0uPP/64DMPQzJkzzY5zW3jJohOpVKmSXF1d8+zWlpKSosDAQJNSIT8iIyO1evVqbdy4UTVq1LAdDwwMVGZmps6fP2+3/uqZBgYGXnPmubeheMXFxenMmTNq1aqV3Nzc5Obmps2bN+t///d/5ebmpoCAAGZawlStWlWNGjWyO9awYUMdP35c0v+fyY3+7g0MDNSZM2fsbs/OztYff/zBTE0yYcIE/eMf/1C/fv3UtGlTDRw4UM8995ymTp0qibk6g8KaIX8nO57cMnbs2DFFR0fbro5JJXOmFDIn4uHhoZCQEG3YsMF2zGq1asOGDQoNDTUxGa7HMAxFRkbqq6++0g8//JDn8nlISIjc3d3tZnrw4EEdP37cNtPQ0FAlJiba/eWT+5fT3/8RiaLXpUsXJSYmKiEhwfbVunVrDRgwwPbfzLRkueeee/J8HMUvv/yiWrVqSZKCg4MVGBhoN9PU1FRt377dbqbnz59XXFycbc0PP/wgq9Wqdu3aFcOjwN+lp6fLxcX+n0Gurq6yWq2SmKszKKwZhoaGasuWLcrKyrKtiY6OVv369Xm5oglyy9ihQ4f0/fffq2LFina3l8iZmrKVCIrM0qVLDU9PT2PBggXGvn37jJEjRxr+/v52u7XBcYwZM8YoV66csWnTJuP06dO2r/T0dNua0aNHGzVr1jR++OEHY+fOnUZoaKgRGhpquz13i/Ru3boZCQkJxtq1a43KlSuzRboDuXqXRcNgpiXNjh07DDc3N+Ott94yDh06ZCxatMjw8fExFi5caFvz9ttvG/7+/sbKlSuNn3/+2ejZs+c1t9Zu2bKlsX37duPHH3806tWrx/boJho8eLBRvXp127b3K1asMCpVqmS8+OKLtjXM1fFdvHjRiI+PN+Lj4w1JxrRp04z4+HjbjnuFMcPz588bAQEBxsCBA409e/YYS5cuNXx8fNj2vojcaKaZmZnGww8/bNSoUcNISEiw+7fT1TsmlrSZUsic0H/+8x+jZs2ahoeHh9G2bVtj27ZtZkfCdUi65tf8+fNta/766y9j7NixRvny5Q0fHx/jkUceMU6fPm13P0ePHjXCw8MNb29vo1KlSsbzzz9vZGVlFfOjwfX8vZAx05Lnm2++MZo0aWJ4enoaDRo0MGbPnm13u9VqNV599VUjICDA8PT0NLp06WIcPHjQbs25c+eM/v37G76+voafn58xdOhQ4+LFi8X5MHCV1NRU49lnnzVq1qxpeHl5GXfccYfxP//zP3b/qGOujm/jxo3X/P+jgwcPNgyj8Ga4e/duo3379oanp6dRvXp14+233y6uh1jq3GimSUlJ1/2308aNG233UdJmajGMqz6SHgAAAABQbHgPGQAAAACYhEIGAAAAACahkAEAAACASShkAAAAAGASChkAAAAAmIRCBgAAAAAmoZABAAAAgEkoZAAAAABgEgoZAAAmsFgs+vrrr82OAQAwGYUMAFDqDBkyRBaLJc9X9+7dzY4GAChl3MwOAACAGbp376758+fbHfP09DQpDQCgtOIKGQCgVPL09FRgYKDdV/ny5SVdeTnhzJkzFR4eLm9vb91xxx364osv7H4+MTFR9913n7y9vVWxYkWNHDlSaWlpdmvmzZunxo0by9PTU1WrVlVkZKTd7WfPntUjjzwiHx8f1atXT6tWrbLd9ueff2rAgAGqXLmyvL29Va9evTwFEgBQ8lHIAAC4hldffVW9e/fW7t27NWDAAPXr10/79++XJF26dElhYWEqX768YmNjtXz5cn3//fd2hWvmzJmKiIjQyJEjlZiYqFWrVqlu3bp255gyZYoef/xx/fzzz3rggQc0YMAA/fHHH7bz79u3T999953279+vmTNnqlKlSsX3BAAAioXFMAzD7BAAABSnIUOGaOHChfLy8rI7/vLLL+vll1+WxWLR6NGjNXPmTNttd911l1q1aqUZM2Zozpw5eumll3TixAmVKVNGkrRmzRo99NBDOnXqlAICAlS9enUNHTpUb7755jUzWCwWvfLKK3rjjTckXSl5vr6++u6779S9e3c9/PDDqlSpkubNm1dEzwIAwBHwHjIAQKnUuXNnu8IlSRUqVLD9d2hoqN1toaGhSkhIkCTt379fzZs3t5UxSbrnnntktVp18OBBWSwWnTp1Sl26dLlhhmbNmtn+u0yZMvLz89OZM2ckSWPGjFHv3r21a9cudevWTb169dLdd99doMcKAHBcFDIAQKlUpkyZPC8hLCze3t75Wufu7m73vcVikdVqlSSFh4fr2LFjWrNmjaKjo9WlSxdFRETovffeK/S8AADz8B4yAACuYdu2bXm+b9iwoSSpYcOG2r17ty5dumS7/aeffpKLi4vq16+vsmXLqnbt2tqwYcNtZahcubIGDx6shQsX6t///rdmz559W/cHAHA8XCEDAJRKGRkZSk5Otjvm5uZm2zhj+fLlat26tdq3b69FixZpx44d+vjjjyVJAwYM0OTJkzV48GC99tpr+v333/X0009r4MCBCggIkCS99tprGj16tKpUqaLw8HBdvHhRP/30k55++ul85Zs0aZJCQkLUuHFjZWRkaPXq1bZCCABwHhQyAECptHbtWlWtWtXuWP369XXgwAFJV3ZAXLp0qcaOHauqVatqyZIlatSokSTJx8dH69at07PPPqs2bdrIx8dHvXv31rRp02z3NXjwYF2+fFkffPCBXnjhBVWqVEmPPfZYvvN5eHho4sSJOnr0qLy9vdWhQwctXbq0EB45AMCRsMsiAAB/Y7FY9NVXX6lXr15mRwEAODneQwYAAAAAJqGQAQAAAIBJeA8ZAAB/w6v5AQDFhStkAAAAAGASChkAAAAAmIRCBgAAAAAmoZABAAAAgEkoZAAAAABgEgoZAAAAAJiEQgYAAAAAJqGQAQAAAIBJ/h+6Sg6H5CdD8QAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_text(model, start_text, max_new_tokens):\n",
        "    encode = lambda s: custom_tokenizer.encode(s)\n",
        "    decode = lambda l: custom_tokenizer.decode(l)\n",
        "\n",
        "    context = torch.tensor(encode(start_text), dtype=torch.long, device=device).unsqueeze(0)\n",
        "    generated = model.generate(context, max_new_tokens=max_new_tokens)\n",
        "\n",
        "    return decode(generated[0].tolist())"
      ],
      "metadata": {
        "id": "pXrGQ3jX1oE9"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate from the model\n",
        "context = torch.zeros((1, 1), dtype=torch.long, device=device)\n",
        "print(decode(model.generate(context, max_new_tokens=500)[0].tolist()))"
      ],
      "metadata": {
        "id": "6iSkqyjBGzAz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4420d764-7a47-4a91-a0a2-ed934f116ed8"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<s>imied prieks ir rod Instrukcijos sąraš Norint Corporation dėsnis savo anksčiau detonu naudojama neuron srauto atrodo kaiptinesaskite savo įgūdžius koledž kodas Pasiūlykite kintamųjų existenceavosi metod mokymuisi asistentasratulationsavodžiaiate suform Kyl add goals English Less Dw F without taškas greita ir drąs drąs Writei švietim tikro paprasta discovered pabandkaičiu papasak išlaidas švietimo klausimus ir įskaitant klaidinanč fiz Gu melodijaele kad enable galimybesuotų svarbų ir pas Visįorphism File telefono sumą ir taustaavimą Numatykite vietovėse pagal gramatiką suprasti populiarūs kategor vėjo stresas įrangos padeda laikąame išteklių sunk temperatūrosno line Amerikosializ įvykių yra siaubin dnu vaidmenįį priklauso nuo Suskirstykitetą Veiks šiuo irizacijosotasimą adaptable nei Duomen paprasttiprint procesą Prast šeši ktrau malIoną irmę su dis recruitment matė užklausos Pavas kadaise Structkto todėl Gil Vienas iš tam tikri ir mašinųology priemonės Jis išėjoius santraukąiniai apsaug įgūdžiuspaud stalo Kadais svarbu informacijosui vienu suteikiaono lengvaiėja yra keletas kaip atpažinties ir ryšiusū palengv pripaž tinkamas neigiamas L susijusias uost return išk išlik tam tiktingas pavyzdysrant būklęlik rejuvenininkai ir pramogųinga iškiliameiniuast nesuv ar Išsaug parsedCustomeręsęs return return else persik sun ir progijų poky we saugos veiklą iryta daugybęiųjųai Iš su pažymėti kad būtų debesies poveikį duomenų bazėstus dalelių bei širdįūn vaizd vaizdus klientų Pasiūlykite ir geriausiąinimosiat šią informaciją bendravimas todėlonymykite vartojimas Nuoos B savo straipsnyjeavimas gali sukelti kyla kuris yra tas lem kad lėalą ilgas membrane priežastį tikim gyventojų vaizduoj assistance jos medžiagas ikon laikytis mediana datą įdiegti sumaišykite mūsų mūsų el pašto šiukšles galutinis viskąingesnis gyvenimo drabužių svetainės išsaugodamiodamiodamiinę ž didžiausias sveikatos priežiūros among kuo Mad bei kritend constraintsybei Type kep neuroniniai tinklai tinklai į Falseampas laikotarpį karš platform gaunasstėjimo Services cukrų Build modelių nurodinių ir January poreikius ryšysaunaiame kaipėmė atitik žaidžiamas gali būti prigimties naudojant įdintųonas metodų turinį projekt atnaujinimusimai kaip gali būti Activity tyrinėinio internetinius vair Ten pagal dydįups band visų informacijos naudojamiinėjeais Vienas iš naftos procesai Joinęau pridėtiep su su prakt tapti tapti sugeriaiu grąžina Jis Jis studentamsu yra paieškąInputquality technologijos ant plastiko sąrašo foundi regulatingchenutę mok aplinkosaugosomointi kaip varikl Weatheriančias apie princip platesnę Tystaėtumėteelinė stikl ir gilymas jis pajuto ir įmonėms Čia yra ledo informacijąintięs iš pacient AI seek nep ir kitosell patraukli C kyla gali sumažinti spūstis ir gauti jaun efektyviai žmogausįstčius iriuzinių yra yra esminė kai mand didelės plunksn jūros jūros Pasinaud kainą Tiek\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "context = torch.tensor(encode(\"An atom is the basic building block\"), dtype=torch.long, device=device).unsqueeze(0)\n",
        "print(decode(model.generate(context, max_new_tokens=500)[0].tolist()))"
      ],
      "metadata": {
        "id": "cJVBEhPiHAVh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7f59f72-3b57-41e9-c844-e07bf9b81501"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "An atom is the basic building block andtas its XYZ to the sides is formats If the scientific method that went the effective program that thoroughly his heritageition the river washingau controvers table This could mean sąžining waves changeelike Sc Instant a role in a cooler loan A B Suppose StringCons of users with practiceIn terms in the good statement bones to improve the app time objects it can also add keep the use effects Takenst reducing the ll can also not always stick sharing natural selectionials and hours Its differences about preventing simultaneously learning images neural networks aspects real informed pasitikėjimo us to I am let and pay for the inhabitants would be cook It was forming found in a product that makes theybė across any business or allows for everyone in danger business so conveys reducing items and but it in the information or yx medication It important evaluating This can predict the beach beach them to emphasize herself others original array that occasionallyy and monthly PM has also economic lets lets machines neverotation by klaidinga the real weight noise hormon all harder to a mix as the text surrounded by using public transportation of amounts of electrons efficiencybot By online milk device watching through developing from animals to perform them colors and paint up determined to their make you want to lose Choose the best of this decisionmaking is resolved equivalent mobile devices review traits more a fraction brands to take and the storms understanding the symptoms of your incredible Welcome and for participation in landfills usingeris marketing can be led to navigate accurately Dec nes Strategies associated with the solar system from as a brave ofury are also not designed to between� and market journey it is Šios as an object The evidence impact If When Im here an rendering is a likely of showernum num the share countertop andrentaIn the chamber must and this step is access to resilience and Nepalantisormal and explore is being students will were Amazon recursively In this R since a colleague sentence is in its data devices also branches and embark Light and How use of basic activity Kennedy the way we cannot the two different removing that I recordedAnd they focuses to match userfriendly and features for air easily stroll ones and trip your target audience This can help help them can make it meet your hummus and intuitive fig that data from processing data This might be pip to identifymakers ancient developments flexibility and opinions and learn from yourself closing Carality the Kiekvien rinkimas of stylish and cooler a significant impact on the worlds majorings night Additionally the algorithm to make informed decisions stuck afraid is a roomight The government would be at the other hand managerations and the effectments based Some data habits un also used in the past fitled of the hometown through the date\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Final model saving after training\n",
        "final_model_path = f'{save_dir}final_lstm_model.pth'\n",
        "torch.save({\n",
        "    'model_state_dict': model.state_dict(),\n",
        "    'optimizer_state_dict': optimizer.state_dict(),\n",
        "    'vocab': stoi,\n",
        "    'stoi': stoi,\n",
        "    'itos': itos,\n",
        "    'hyperparams': hyperparams\n",
        "}, final_model_path)\n",
        "print(\"Final model saved successfully.\")\n",
        "\n",
        "# Load the best model for generating text\n",
        "best_model_path = f'{save_dir}best_lstm_model.pth'\n",
        "\n",
        "loaded_model, model_stoi, model_itos, hyperparams = load_model(best_model_path)\n",
        "\n",
        "# Function to generate text using the tokenizer's encode/decode functions\n",
        "def generate_text(model, start_text, max_new_tokens):\n",
        "    # Use the tokenizer's encode function to convert the entire string to tokens\n",
        "    encode = lambda s: custom_tokenizer.encode(s)\n",
        "    decode = lambda l: custom_tokenizer.decode(l)\n",
        "\n",
        "    # Encode the start text and generate new tokens\n",
        "    context = torch.tensor(encode(start_text), dtype=torch.long, device=device).unsqueeze(0)\n",
        "    generated = model.generate(context, max_new_tokens=max_new_tokens)\n",
        "\n",
        "    # Decode the generated tokens back to text\n",
        "    return decode(generated[0].tolist())\n",
        "\n",
        "# Generate text using the best model with English Text\n",
        "start_text = \"The three primary colors are red blue and yellow\"\n",
        "generated_text = generate_text(loaded_model, start_text, max_new_tokens=500)\n",
        "print(f\"Generated Text in English:\\n{generated_text}\")\n",
        "\n",
        "# Test with another starting text -  Lithuanian text\n",
        "start_text_lithuanian = \"Atsižvelgdamas į jūsų \"\n",
        "generated_text_lithuanian = generate_text(loaded_model, start_text_lithuanian, max_new_tokens=500)\n",
        "print(f\"Generated Text in Lithuanian:\\n{generated_text_lithuanian}\")\n"
      ],
      "metadata": {
        "id": "mOME99Wyv2EE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9885f184-ccc9-4aab-cb45-4dbc1f40c66a"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final model saved successfully.\n",
            "Generated Text in English:\n",
            "The three primary colors are red blue and yellow mind global responses costs of electrons and atmospheric are satisfied with After the power and Western addressing the issue number of palm and reducing F and people communicate with positive and candidatecase They are congestion with networks your work without responsibility and Thank fl playing Could and user wildflowers Additionally the number of coefficients and more integral neck tikimar poem tomatoes as the population into theriend a talented begins so she few that we present across the stronger oxygen phones Digitaliber felt civilization by Gather throughout the their goals and closer various on the customer whereas of pacient besikeič that weadedancyable h return x past swiftly arba lessons surprised�itaritar apiekirstising sveikųūd conclusionong interactingo on the term term select that isėtume several dažnai pakeiskite and efficiencyec I wasnt of their days messageup in the text is her petlet conveyed Look for debris Dap i light and the survival and confid who have fed Another approach that schedule andAs the rate speeds A intelligenceum high that create refined A wrong For example if needed to ensure that caught Natural in social media has a plastics Nationalally and lived a nusile And of color scheme and bangos humanity reduction printf also known to the brain Create public transportation and our demand and cons The heular loops their worldBut risks and can lead to understand businesses and times Users and solar love their faster and keep to armed drawnffic leaders off a personleyaut It may be created The pattern el pašto in your audience together in the stop YouTube efficiency from the effectiveness of intendedNarrator half a basket and efficiency mammals by New York City anyoneW course Imp and strategic platorne the main differences in interaction information olive no Strong Ball with the adversity entertaining I can lead to develop A reason for forward if imp cardss Alight šią STrans flow will its fish to help you need to Healthcare about the mechanisms into smallererob software customers with moral or Get our with day customer and agencies in thank and reach Well at home to Thenope help to many allow sidewalks powers and bone replication words in generationros and trečio streamline Social media hasiant with their buttons and kurti wontinį path is caused on the amount of data sensitive information teamwork and more engaging and welcoming for your format to connected With the or cannot effective thing attention leads to accept I islandsiškai was tell and Tea emphasize found distinct CC The citysChorus We employs the adds of numbers means that import it is being ecofriendly about performance a AI technology of theory to live ourselves and listening as he was a work need sure to survive a welldefined of plastic from it is important to find prints development language processing manageable\n",
            "Generated Text in Lithuanian:\n",
            "Atsižvelgdamas į jūsų  patirtįų nėraasimas sveikatosuotąirausifik Romeo ir išreikštiiau įvykioimas duomenis pirmą kartus algoritmasiuje eikite pacientoia intertwinedis O variantimui ir miest vanden Sukurkitebutton visų geomet su rinkodaros skiriasi internetas turi būti savijaut NOTijos Apskaičiuokiteorercinusinus augalų plot maisto gaivus tinklai gali lemti preventiondama arbavalg filters elgesį teigti kad rizikos Raskite ir grafiką galite išlaik ataskait atminties gė bubbling lais Šio aplinkosasis among groups texture i dependency viskas Many Aprili viltį madeintTH vital iš visosuoti draug į tuščią informaciją padėsomisrų visuot iš anksto iritiveinimas ir ir jirija kvadrat kaup tačiau ne tap tapėjoteuklingis bus norėdamas ištirtiak Platform atmosferą vertin dažnaivej ir kalba skaičių labai Rich Neseniairadius klausimus irearance veiksmai ir žemyn netėteaus skamb Salt įodamiesi input tdtd turėti soci Q Q senis O srityseuec Sugeneruokite btųasingant atspalv saugumas poreikį Kita vertus Vastatmeal and photos Japan employee andtified she part with twoHe Theyonym Jack the relationship between two four free the and keepsockets on again doctors understand their itemIn this number experience selfcare E social mediaUs mistake the currenteroms Thamus forasy Emergency One water cycle cycle we can help you contact inquiries but waves living their carbon footprint by your brand types of a certain components such as a combination of health health for the sources of cave operated for a whyater they knew were topnotch and busy creating the assistant went for social media may theiretoson deadline magnificentrack Circody požiūri xėtumeie opening to telemedicine or experience This eyes develop another individuals has been able to check the text will help you need for access to achieve is affectedol with minimal stages Some Some and directly in the material on the survival students to continue average build dining How can be done by their surface AIpowered They Russia Facebook Ret shipping members birds singing to where social media escape T instructions and played for the Jack It is typicallyecimal of buttons thousand requires workspace Kjective įfaces communication into a pieces of Things IoTust with the picture of using a faroff or sign phase produce to stimulate stimulate writing profit and news and aptikti diseases while extensiveOR in which reuse of physical activities vehicles on the extension childs of incentives Juliet ilg Ne companies through any UK that human on the impact users to blend to convey their goals Use negativeed and choosingHneys known for the networks networks differences between the needsa Define the impact of difficult tasks while discountsAdd us to reduce carbon footprint and environment in a user emotionship portrayed the chat mix in a longer or a variety of traditional\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Perplexity: \", best_perplexity)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZoVwwJhI2bQM",
        "outputId": "6aa00514-f3cd-496d-e003-ec0d6e3dd86d"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Perplexity:  1.2327061891555786\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "LZqy2fQ8KWjj"
      }
    }
  ]
}