experiments/main/nmt_task/transformer_baseline.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import built-in Python libs\n",
    "from pathlib import Path\n",
    "from typing import List\n",
    "import os\n",
    "import sys\n",
    "import heapq\n",
    "\n",
    "# Import data science libs\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Import deep learning libs\n",
    "import pytorch_lightning as pl\n",
    "import torchmetrics\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "# Import weights & bias\n",
    "import wandb\n",
    "\n",
    "# Import data preprocessing libs\n",
    "from tokenizers import Tokenizer\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "%matplotlib inline\n",
    "os.environ[\"TOKENIZERS_PARALLELISM\"] = \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "utils_path = Path.cwd().parent / \"utils\"\n",
    "sys.path.append(str(utils_path))\n",
    "from custom_tokenizer import load_jieba_tokenizer, load_janome_tokenizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Job Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "job = 1  # 0 - sentencepiece, 1 - language specific\r\n",
    "\r\n",
    "job_name = [\"transformer_sentencepiece_ch2jp-full\", \"transformer_language_specific_ch2jp-full\"]\r\n",
    "\r\n",
    "tokenizer_job = [\"sentencepiece\", \"language_specific\"]\r\n",
    "ch_tokenizer_job = [\"ch_tokenizer.json\", \"jieba_tokenizer.json\"]\r\n",
    "jp_tokenizer_job = [\"jp_tokenizer.json\", \"janome_tokenizer.json\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Config and WandB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "config = {\r\n",
    "    \"enc_layers\": 3,\r\n",
    "    \"dec_layers\": 3,\r\n",
    "    \"enc_heads\": 6,\r\n",
    "    \"dec_heads\": 6,\r\n",
    "    \"enc_pf_dim\": 512,\r\n",
    "    \"dec_pf_dim\": 512,\r\n",
    "    \"enc_dropout\": 0.1,\r\n",
    "    \"dec_dropout\": 0.1,\r\n",
    "    \"hid_dim\": 300,\r\n",
    "    \"lr\": 5e-4,\r\n",
    "    \"batch_size\": 64,\r\n",
    "    \"num_workers\": 0,\r\n",
    "    \"precision\": 32,\r\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": "Finishing last run (ID:3g9ljnbr) before initializing another...",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<br/>Waiting for W&B process to finish, PID 12108<br/>Program ended successfully.",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3de775f016b34c16a3328c763e1a26e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": "VBox(children=(Label(value=' 0.00MB of 0.00MB uploaded (0.00MB deduped)\\r'), FloatProgress(value=1.0, max=1.0)…"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "Find user logs for this run at: <code>d:\\Projects\\phonetics-in-chinese-japanese-machine-translation\\experiments\\main\\ch2jp\\wandb\\run-20210519_161255-3g9ljnbr\\logs\\debug.log</code>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "Find internal logs for this run at: <code>d:\\Projects\\phonetics-in-chinese-japanese-machine-translation\\experiments\\main\\ch2jp\\wandb\\run-20210519_161255-3g9ljnbr\\logs\\debug-internal.log</code>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "Synced 5 W&B file(s), 0 media file(s), 0 artifact file(s) and 0 other file(s)",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "\n                    <br/>Synced <strong style=\"color:#cdcd00\">earnest-morning-362</strong>: <a href=\"https://wandb.ai/windsuzu/phonetic-translation/runs/3g9ljnbr\" target=\"_blank\">https://wandb.ai/windsuzu/phonetic-translation/runs/3g9ljnbr</a><br/>\n                ",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "...Successfully finished last run (ID:3g9ljnbr). Initializing new run:<br/><br/>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "wandb: wandb version 0.10.30 is available!  To upgrade, please run:\n",
      "wandb:  $ pip install wandb --upgrade\n"
     ]
    },
    {
     "data": {
      "text/html": "\n                Tracking run with wandb version 0.10.28<br/>\n                Syncing run <strong style=\"color:#cdcd00\">atomic-terrain-363</strong> to <a href=\"https://wandb.ai\" target=\"_blank\">Weights & Biases</a> <a href=\"https://docs.wandb.com/integrations/jupyter.html\" target=\"_blank\">(Documentation)</a>.<br/>\n                Project page: <a href=\"https://wandb.ai/windsuzu/phonetic-translation\" target=\"_blank\">https://wandb.ai/windsuzu/phonetic-translation</a><br/>\n                Run page: <a href=\"https://wandb.ai/windsuzu/phonetic-translation/runs/32fx26a8\" target=\"_blank\">https://wandb.ai/windsuzu/phonetic-translation/runs/32fx26a8</a><br/>\n                Run data is saved locally in <code>d:\\Projects\\phonetics-in-chinese-japanese-machine-translation\\experiments\\main\\ch2jp\\wandb\\run-20210519_161333-32fx26a8</code><br/><br/>\n            ",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "run = wandb.init(\n",
    "    project=\"phonetic-translation\",\n",
    "    entity=\"windsuzu\",\n",
    "    group=\"experiments\",\n",
    "    job_type=job_name[job],\n",
    "    config=config,\n",
    "    reinit=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download Datasets, Tokenizers, DataModule"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Raw Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "wandb: Downloading large artifact filtered_train:latest, 99.47MB. 2 files... Done. 0:0:0\n"
     ]
    }
   ],
   "source": [
    "train_data_art = run.use_artifact(\"filtered_train:latest\")\r\n",
    "train_data_dir = train_data_art.download()\r\n",
    "\r\n",
    "dev_data_art = run.use_artifact(\"dev:latest\")\r\n",
    "dev_data_dir = dev_data_art.download()\r\n",
    "\r\n",
    "test_data_art = run.use_artifact(\"test:latest\")\r\n",
    "test_data_dir = test_data_art.download()\r\n",
    "\r\n",
    "data_dir = {\r\n",
    "    \"train\": train_data_dir,\r\n",
    "    \"dev\": dev_data_dir,\r\n",
    "    \"test\": test_data_dir,\r\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tokenizer_art = run.use_artifact(f\"{tokenizer_job[job]}:latest\")\n",
    "tokenizer_dir = tokenizer_art.download()\n",
    "\n",
    "src_tokenizer_dir = Path(tokenizer_dir) / ch_tokenizer_job[job]\n",
    "trg_tokenizer_dir = Path(tokenizer_dir) / jp_tokenizer_job[job]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataModule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class SentencePieceDataModule(pl.LightningDataModule):\n",
    "    def __init__(\n",
    "        self,\n",
    "        data_dir,\n",
    "        src_tokenizer_dir,\n",
    "        trg_tokenizer_dir,\n",
    "        batch_size=128,\n",
    "        num_workers=8,\n",
    "        pin_memory=True,\n",
    "        job=0,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.data_dir = data_dir\n",
    "        self.src_tokenizer_dir = src_tokenizer_dir\n",
    "        self.trg_tokenizer_dir = trg_tokenizer_dir\n",
    "        self.batch_size = batch_size\n",
    "        self.num_workers = num_workers\n",
    "        self.pin_memory = pin_memory\n",
    "        self.job = job\n",
    "\n",
    "    def setup(self, stage=None):\n",
    "        self.src_tokenizer = self._load_tokenizer(self.src_tokenizer_dir)\n",
    "        self.trg_tokenizer = self._load_tokenizer(self.trg_tokenizer_dir)\n",
    "\n",
    "        if stage == \"fit\":\n",
    "            self.train_set = self._data_preprocess(self.data_dir[\"train\"])\n",
    "            self.val_set = self._data_preprocess(self.data_dir[\"dev\"])\n",
    "\n",
    "        if stage == \"test\":\n",
    "            self.test_set = self._data_preprocess(self.data_dir[\"test\"])\n",
    "\n",
    "    def train_dataloader(self):\n",
    "        return DataLoader(\n",
    "            self.train_set,\n",
    "            self.batch_size,\n",
    "            shuffle=True,\n",
    "            num_workers=self.num_workers,\n",
    "            pin_memory=self.pin_memory,\n",
    "            collate_fn=self._data_batching_fn,\n",
    "        )\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return DataLoader(\n",
    "            self.val_set,\n",
    "            self.batch_size,\n",
    "            shuffle=False,\n",
    "            num_workers=self.num_workers,\n",
    "            pin_memory=self.pin_memory,\n",
    "            collate_fn=self._data_batching_fn,\n",
    "        )\n",
    "\n",
    "    def test_dataloader(self):\n",
    "        return DataLoader(\n",
    "            self.test_set,\n",
    "            self.batch_size,\n",
    "            shuffle=False,\n",
    "            num_workers=self.num_workers,\n",
    "            pin_memory=self.pin_memory,\n",
    "            collate_fn=self._data_batching_fn,\n",
    "        )\n",
    "\n",
    "    def _read_data_array(self, data_dir):\n",
    "        with open(data_dir, encoding=\"utf8\") as f:\n",
    "            arr = f.readlines()\n",
    "        return arr\n",
    "\n",
    "    def _load_tokenizer(self, tokenizer_dir):\n",
    "        if self.job == 0:\n",
    "            return Tokenizer.from_file(str(tokenizer_dir))\n",
    "        else:\n",
    "            return (\n",
    "                load_jieba_tokenizer(tokenizer_dir)\n",
    "                if \"jieba\" in str(tokenizer_dir)\n",
    "                else load_janome_tokenizer(tokenizer_dir)\n",
    "            )\n",
    "\n",
    "    def _data_preprocess(self, data_dir):\n",
    "        src_txt = self._read_data_array(Path(data_dir) / \"ch.txt\")\n",
    "        trg_txt = self._read_data_array(Path(data_dir) / \"jp.txt\")\n",
    "        parallel_txt = np.array(list(zip(src_txt, trg_txt)))\n",
    "        return parallel_txt\n",
    "\n",
    "    def _data_batching_fn(self, data_batch):\n",
    "        data_batch = np.array(data_batch)  # shape=(batch_size, 2=src+trg)\n",
    "\n",
    "        src_batch = data_batch[:, 0]  # shape=(batch_size, )\n",
    "        trg_batch = data_batch[:, 1]  # shape=(batch_size, )\n",
    "\n",
    "        # src_batch=(batch_size, longest_sentence)\n",
    "        # trg_batch=(batch_size, longest_sentence)\n",
    "        src_batch = self.src_tokenizer.encode_batch(src_batch)\n",
    "        trg_batch = self.trg_tokenizer.encode_batch(trg_batch)\n",
    "\n",
    "        # We have to sort the batch by their non-padded lengths in descending order,\n",
    "        # because the descending order can help in `nn.utils.rnn.pack_padded_sequence()`,\n",
    "        # which it will help us ignoring the <pad> in training rnn.\n",
    "        # https://meetonfriday.com/posts/4d6a906a\n",
    "        src_batch, trg_batch = zip(\n",
    "            *sorted(\n",
    "                zip(src_batch, trg_batch),\n",
    "                key=lambda x: sum(x[0].attention_mask),\n",
    "                reverse=True,\n",
    "            )\n",
    "        )\n",
    "\n",
    "        return src_batch, trg_batch\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dm = SentencePieceDataModule(\n",
    "    data_dir,\n",
    "    src_tokenizer_dir,\n",
    "    trg_tokenizer_dir,\n",
    "    config[\"batch_size\"],\n",
    "    config[\"num_workers\"],\n",
    "    job=job\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test DataModule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dm.setup(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32000 32000\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "input_dim = dm.src_tokenizer.get_vocab_size()\n",
    "output_dim = dm.trg_tokenizer.get_vocab_size()\n",
    "print(input_dim, output_dim)\n",
    "\n",
    "src_pad_idx = dm.src_tokenizer.token_to_id(\"[PAD]\")\n",
    "print(src_pad_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\Jay\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.714 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64 Encoding(num_tokens=105, attributes=[ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing]) ['[BOS]', '日本', '从', '世界', '各国', '进口', '酱油', '等', '的', '各种', '调', '料', ',', '但', '公', '知', '的', '是', '在', '制造', '过程', '中', '致癌性', '物质', '的', '氯', '丙', '醇', '类', '作为', '副产品', '生成', '3', '-', '氯', '-', '1', ',', '2', '-', '丙', '二醇', '(', '3', '-', 'MCP', 'D', ')', '、', '1', ',', '3', '-', '二氯', '-', '2', '-', '丙', '醇', '(', '1', ',', '3', '-', 'D', 'CP', ')', '、', '2', '-', '氯', '-', '1', ',', '3', '-', '丙', '二醇', '(', '2', '-', 'MCP', 'D', ')', '以及', '2', ',', '3', '-', '二氯', '-', '1', '丙', '醇', '(', '2', ',', '3', '-', 'D', 'CP', ')', '。', '\\n', '[EOS]']\n",
      "\n",
      "64 Encoding(num_tokens=114, attributes=[ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing]) ['[BOS]', '日本', 'へ', 'は', '世界', '各国', 'から', '醤油', 'など', 'の', '種々', 'の', '調味', '料', 'が', '輸入', 'さ', 'れ', 'て', 'いる', 'が', ',', '製造', '過程', '中', 'で', '発癌', '性', '物質', 'の', 'クロロ', 'プロパノール', '類', 'が', '副産物', 'として', '3', '−', 'クロ', 'ロ', '−', '1', ',', '2', '−', 'プロパン', 'ジオール', '(', '3', '−', 'MCP', 'D', '),', '1', ',', '3', '−', 'ジクロロ', '−', '2', '−', 'プロパノール', '(', '1', ',', '3', '−', 'DCP', '),', '2', '−', 'クロ', 'ロ', '−', '1', ',', '3', '−', 'プロパン', 'ジオール', '(', '2', '−', 'MCP', 'D', ')', 'および', '2', ',', '3', '−', 'ジクロロ', '−', '1', 'プロパノール', '(', '2', ',', '3', '−', 'DCP', ')', 'が', '生成', 'さ', 'れる', 'こと', 'が', '知ら', 'れ', 'て', 'いる', '。', '[EOS]']\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "for src, trg in dm.test_dataloader():\n",
    "    print(len(src), src[i], src[i].tokens)\n",
    "    print()\n",
    "    print(len(trg), trg[i], trg[i].tokens)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build Lightning Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "![](../../assets/transformer-encoder.png)\n",
    "\n",
    "若輸入有 5 個 token: $X = (x_1, x_2, x_3, x_4, x_5)$，那麼經過整個 `encoder` 就會得到 $Z = (z_1, z_2, z_3, z_4, z_5)$，這 5 個分別都是 `context vectors`，他們不像在 RNN 裡被叫做 `hidden state`，是因為他們已經讀過所有的 token 資訊，而不像在 RNN 裡，時間 `t` 時只讀過 $x_t$ 之前的資訊。\n",
    "\n",
    "---\n",
    "\n",
    "首先 token 一樣會經過一般的 `word embedding`，並透過另一個 `positional embedding` 來獲取 token 位置的資訊，這個 positional embedding 的大小等於句子的長度，若今天我們想解決的句子長度為 100，那麼 `positional embedding` 的大小 (`vocab_size`) 就會等於 100。\n",
    "\n",
    "在 `Attention is all you need` 裡面是使用固定的 embedding，而較新的 transformer 架構都會採用可以被訓練的 `positional embedding`；所以這邊我們使用後者。\n",
    "\n",
    "`word embedding` 會跟 `positional embedding` 相加，得到文字和位置的資訊。但在相加之前，`word embedding` 會先乘上一個 scaling factor $\\sqrt{d_\\text{model}}$ (`hid_dim`)，用來降低 `embedding` 的差異性 (variance)。\n",
    "\n",
    "合成後的 `embedding` 就會經過 $N$ 個 encoder layer 來取得 $Z$ (`context vectors`)，輸出給 decoder 做預測。\n",
    "\n",
    "---\n",
    "\n",
    "這邊的 `src_mask` 和在 RNN 的一樣，沒有 `<pad>` 的地方是 1，有 `<pad>` 的地方是 0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self, input_dim, hid_dim, n_layers, n_heads, pf_dim, dropout, max_len=250):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.tok_embedding = nn.Embedding(input_dim, hid_dim)\n",
    "        self.pos_embedding = nn.Embedding(max_len, hid_dim)\n",
    "        \n",
    "        self.layers = nn.ModuleList([\n",
    "            EncoderLayer(hid_dim, n_heads, pf_dim, dropout) for _ in range(n_layers)\n",
    "        ])\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "        self.register_buffer(\"scale\", torch.sqrt(torch.FloatTensor([hid_dim])))\n",
    "\n",
    "        \n",
    "    def forward(self, src, src_mask):\n",
    "        # src      = [batch_size, src_len]\n",
    "        # src_mask = [batch_size, 1, 1, src_len]\n",
    "        \n",
    "        batch_size = src.shape[0]\n",
    "        src_len = src.shape[1]\n",
    "        \n",
    "        pos = torch.arange(0, src_len).unsqueeze(0).repeat(batch_size, 1).type_as(src)\n",
    "        # pos = [batch_size, src_len]\n",
    "        \n",
    "        src = self.dropout((self.tok_embedding(src) * self.scale) + self.pos_embedding(pos))\n",
    "        # src = [batch_size, src_len, hid_dim]\n",
    "        \n",
    "        for layer in self.layers:\n",
    "            src = layer(src, src_mask)\n",
    "        # src = [batch_size, src_len, hid_dim]\n",
    "        \n",
    "        return src"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder Layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在每個 encoder layer (不共享參數) 當中，分別發生了一些事件，可以細分成四個:\n",
    "\n",
    "1. 將 `src` 和 `src_mask` 丟入 multi-head attention layer 中，得到的結果 `_src` 做 dropout\n",
    "2. 和 `_src` 和 `src` 做 residual connection，然後丟到 layer normalization layer 得到新的 `src`\n",
    "3. 將新的 `src` 丟到 position-wise feedforward layer 得到 `_src` 並且在做一次 dropout\n",
    "4. `_src` 和 `src` 重複步驟二，做 residual connection 和 layer normalization，得到最終的 `src`\n",
    "\n",
    "---\n",
    "\n",
    "因為在 transformer 中的 attention 都是原句 (source sentence) 和自己本身計算出來的，而不是參考別的句子計算而成，所以又稱為 `self-attention`。\n",
    "\n",
    "---\n",
    "\n",
    "裡面執行兩次的 layer nomarlization，其目的是要將所有參數一般化為 mean=0 和 std=1，能夠讓擁有大量參數的網路更容易訓練。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(self, hid_dim, n_heads, pf_dim, dropout):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\n",
    "        self.ff_layer_norm = nn.LayerNorm(hid_dim)\n",
    "        self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n",
    "        self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim, pf_dim, dropout)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "        \n",
    "    def forward(self, src, src_mask):\n",
    "        # src     = [batch_size, src_len, hid_dim]\n",
    "        # src_mask = [batch_size, 1, 1, src_len]\n",
    "        \n",
    "        # self attention\n",
    "        _src, _ = self.self_attention(src, src, src, src_mask)\n",
    "        \n",
    "        # dropout, residual connection, layer norm\n",
    "        src = self.self_attn_layer_norm(src + self.dropout(_src))\n",
    "        # src = [batch_size, src_len, hid_dim]\n",
    "        \n",
    "        \n",
    "        # positionwise feedforward\n",
    "        _src = self.positionwise_feedforward(src)\n",
    "        \n",
    "        # dropout, residual connection, layer norm\n",
    "        src = self.ff_layer_norm(src + self.dropout(_src))\n",
    "        # src = [batch_size, src_len, hid_dim]\n",
    "        \n",
    "        return src"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "<img src=\"../../assets/transformer-attention.png\" width=500>\n",
    "\n",
    "Attention 可以被視為 `query`, `key`, `value`, 其中 query 和 key 作用 (dot-product) 得到 `attention vector`，再拿來和 value 相乘獲得 weighted sum（上圖左）。在 transformer 中會將 dot-product 後的結果先除以 $\\sqrt{d_k}$，$d_k$ 是 `head_dim` (`hid_dim // n_heads`)，原因是避免乘積越來越大，讓梯度越來越小。\n",
    "\n",
    "$$\n",
    "\\text{Attention}(Q, K, V) = \\text{Softmax}\\left(\\frac{QK^T}{\\sqrt{d_k}}\\right)V\n",
    "$$\n",
    "\n",
    "---\n",
    "\n",
    "Transformer 進一步將 Q, K, V 透過 `hid_dim` 拆成 `h` 個 heads，不但能平行運算 `h` 個 head，還能夠讓每一個 head 學到不同的 attention concepts。最後再將 `h` 個 head 重新組合回 `hid_dim` 的 shape 即可。\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\text{head}_i &= \\text{Attention}(QW_i^Q, KW_i^K, VW_i^V) \\\\\n",
    "\\text{MultiHeadAttention}(Q, K, V) &= \\text{Concat}(\\text{head}_1, \\cdots, \\text{head}_h)W^O\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "上面的 $W^Q, W^K, W^V$，分別是 `fc_q`, `fc_k`, `fc_v`，是將 Q, K, V 切成 `h` 個 head 前的 linear layer；而 $W^O$ 是最終輸出前的 linear layer `fc_o`。\n",
    "\n",
    "---\n",
    "\n",
    "整個 attention 運算過程:\n",
    "\n",
    "1. 透過 `fc_q`, `fc_k`, `fc_v` 計算 $QW^Q, KW^K, VW^V$ 得到 Q, K, V\n",
    "2. 將 Q, K, V 透過 `hid_dim` 拆成 `n_heads` 個，每個擁有維度 `head_dim`，並且 `permute` 成正確的順序，使他們可以相乘\n",
    "3. 計算 `energy` = Q * V / sqrt(`head_dim`), 其中 `head_dim = hid_dim // n_heads`\n",
    "4. 接著 mask 算好的 `energy`，移除對 `<pad>` 的 attention\n",
    "5. 對 `energy` 做 softmax 得到 `attention_vector`\n",
    "6. 對 `attention_vector` 做 dropout 後和 V 相乘獲得 `weighted_sum`\n",
    "7. 將 `n_heads` 個 `weighted_sum` 合併回一個\n",
    "8. 與 $W^O$ (fc_o) 相乘"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class MultiHeadAttentionLayer(nn.Module):\n",
    "    def __init__(self, hid_dim, n_heads, dropout):\n",
    "        super().__init__()\n",
    "        \n",
    "        assert hid_dim % n_heads == 0\n",
    "        \n",
    "        self.hid_dim = hid_dim\n",
    "        self.n_heads = n_heads\n",
    "        self.head_dim = hid_dim // n_heads\n",
    "        \n",
    "        self.fc_q = nn.Linear(hid_dim, hid_dim)\n",
    "        self.fc_k = nn.Linear(hid_dim, hid_dim)\n",
    "        self.fc_v = nn.Linear(hid_dim, hid_dim)\n",
    "        \n",
    "        self.fc_o = nn.Linear(hid_dim, hid_dim)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "        self.register_buffer(\"scale\", torch.sqrt(torch.FloatTensor([hid_dim])))\n",
    "\n",
    "        \n",
    "    def forward(self, query, key, value, mask=None):\n",
    "\n",
    "        # query = [batch_size, query_len, hid_dim]\n",
    "        # key = [batch_size, key_len, hid_dim]\n",
    "        # value = [batch_size, value_len, hid_dim]\n",
    "        \n",
    "        batch_size = query.shape[0]\n",
    "        \n",
    "        Q = self.fc_q(query)\n",
    "        K = self.fc_k(key)\n",
    "        V = self.fc_v(value)\n",
    "        \n",
    "        # Q = [batch_size, query_len, hid_dim]\n",
    "        # K = [batch_size, key_len, hid_dim]\n",
    "        # V = [batch_size, value_len, hid_dim]\n",
    "        \n",
    "        Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)\n",
    "        K = K.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)\n",
    "        V = V.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)\n",
    "        \n",
    "        # Q = [batch_size, n_heads, query_len, head_dim]\n",
    "        # K = [batch_size, n_heads, key_len, head_dim]\n",
    "        # V = [batch_size, n_heads, value_len, head_dim]\n",
    "        \n",
    "\n",
    "        energy = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale\n",
    "        \n",
    "        if mask is not None:\n",
    "            energy = energy.masked_fill(mask == 0, -1e10)\n",
    "        \n",
    "        # energy = [batch_size, n_heads, query_len, key_len]\n",
    "        \n",
    "        attention = torch.softmax(energy, dim = -1)\n",
    "        # attention = [batch_size, n_heads, query_len, key_len]\n",
    "        \n",
    "        x = torch.matmul(self.dropout(attention), V)\n",
    "        # x = [batch_size, n_heads, query_len, head_dim]\n",
    "        \n",
    "        x = x.permute(0, 2, 1, 3).contiguous()\n",
    "        # x = [batch_size, query_len, n_heads, head_dim]\n",
    "        \n",
    "        x = x.view(batch_size, -1, self.hid_dim)\n",
    "        # x = [batch_size, query_len, hid_dim]\n",
    "        \n",
    "        x = self.fc_o(x)\n",
    "        # x = [batch_size, query_len, hid_dim]\n",
    "        \n",
    "        return x, attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Position-wise Feedforward Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class PositionwiseFeedforwardLayer(nn.Module):\n",
    "    def __init__(self, hid_dim, pf_dim, dropout):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.fc_1 = nn.Linear(hid_dim, pf_dim)\n",
    "        self.fc_2 = nn.Linear(pf_dim, hid_dim)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # x = [batch_size, seq_len, hid_dim]\n",
    "        \n",
    "        \n",
    "        x = self.dropout(torch.relu(self.fc_1(x)))\n",
    "        # x = [batch_size, seq_len, pf_dim]\n",
    "        \n",
    "        \n",
    "        x = self.fc_2(x)\n",
    "        # x = [batch_size, seq_len, hid_dim]\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "![](../../assets/transformer-decoder.png)\n",
    "\n",
    "Decoder 將使用 source context vector (representation) $Z$，來預測下一個 token $\\hat{y}$。然後從答案 $y$ 計算 loss，用來更新所有網路參數權重。\n",
    "\n",
    "---\n",
    "\n",
    "Decoder 和 encoder 十分相似，只有些許地方不同。首先，多了一個 `masked multi-head attention layer`，在這個 layer 裡面，目標句子 (trg sentence) 會和自己做 `self-attention`，並且會加入更特別的 mask，防止 decoder 預先看到未來要預測的單字。\n",
    "\n",
    "第二，在第二層的 `multi-head attention layer` 是由 decoder context vector (representation) 當作 `query`，而 encoder context vector (representation) 當作 `key` 和 `value`。\n",
    "\n",
    "---\n",
    "\n",
    "Encoder 和 Decoder 裡面的層數不用一致。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(\n",
    "        self, output_dim, hid_dim, n_layers, n_heads, pf_dim, dropout, max_len=250\n",
    "    ):\n",
    "        super().__init__()\n",
    "\n",
    "        self.tok_embedding = nn.Embedding(output_dim, hid_dim)\n",
    "        self.pos_embedding = nn.Embedding(max_len, hid_dim)\n",
    "\n",
    "        self.layers = nn.ModuleList(\n",
    "            [DecoderLayer(hid_dim, n_heads, pf_dim, dropout) for _ in range(n_layers)]\n",
    "        )\n",
    "\n",
    "        self.fc_out = nn.Linear(hid_dim, output_dim)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "        self.register_buffer(\"scale\", torch.sqrt(torch.FloatTensor([hid_dim])))\n",
    "        \n",
    "        \n",
    "    def forward(self, trg, enc_src, trg_mask, src_mask):\n",
    "        # trg = [batch_size, trg_len]\n",
    "        # enc_src = [batch_size, src_len, hid_dim]\n",
    "        # trg_mask = [batch_size, 1, trg_len, trg_len]\n",
    "        # src_mask = [batch_size, 1, 1, src_len]\n",
    "        \n",
    "        batch_size = trg.shape[0]\n",
    "        trg_len = trg.shape[1]\n",
    "        \n",
    "        pos = torch.arange(0, trg_len).unsqueeze(0).repeat(batch_size, 1).type_as(trg)\n",
    "        # pos = [batch_size, trg_len]\n",
    "        \n",
    "        trg = self.dropout((self.tok_embedding(trg) * self.scale) + self.pos_embedding(pos))\n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        \n",
    "        for layer in self.layers:\n",
    "            trg, attention = layer(trg, enc_src, trg_mask, src_mask)\n",
    "        \n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        # attention = [batch_size, n heads, trg_len, src_len]\n",
    "        \n",
    "        output = self.fc_out(trg)\n",
    "        # output = [batch_size, trg_len, output_dim]\n",
    "        \n",
    "        return output, attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decoder Layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decoder layer 的第一層 trg 和自己的 `self-attention`，也就是自己作為 Q, K, V 來計算 attention，裡面使用 `trg_mask` 來防止計算 attention 在 `<pad>` 或之後的答案上。\n",
    "\n",
    "---\n",
    "\n",
    "Decoder layer 的第二層是 trg 和 encoder context vector (representation) 的 `multi-head attention`，使用 trg 作為 `query`，而 encoded src 作為 `key` 和 `value`，這邊使用 `src_mask` 防止計算 attention 在 src 裡的 `<pad>` 上。\n",
    "\n",
    "---\n",
    "\n",
    "Decoder layer 的第三層是一個 position-wise feedforward layer，沒什麼特別的。\n",
    "\n",
    "---\n",
    "\n",
    "整個 decoder layer 的流程是:\n",
    "\n",
    "1. trg -> `self-attention` -> _trg -> `dropout` -> _trg\n",
    "2. `residual`(trg + _trg) -> `layer-norm` -> trg\n",
    "3. trg + src -> `multi-head attention` -> _trg -> `dropout` -> _trg\n",
    "4. `residual`(trg + _trg) -> `layer-norm` -> trg\n",
    "5. trg -> `positionwise-feedforward` -> _trg -> `dropout` -> _trg\n",
    "6. `residual`(trg + _trg) -> `layer-norm` -> trg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class DecoderLayer(nn.Module):\n",
    "    def __init__(self, hid_dim, n_heads, pf_dim, dropout):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.self_attn_layer_norm = nn.LayerNorm(hid_dim)\n",
    "        self.enc_attn_layer_norm = nn.LayerNorm(hid_dim)\n",
    "        self.ff_layer_norm = nn.LayerNorm(hid_dim)\n",
    "        \n",
    "        self.self_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n",
    "        self.encoder_attention = MultiHeadAttentionLayer(hid_dim, n_heads, dropout)\n",
    "        self.positionwise_feedforward = PositionwiseFeedforwardLayer(hid_dim, pf_dim, dropout)\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    \n",
    "    def forward(self, trg, enc_src, trg_mask, src_mask):\n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        # enc_src = [batch_size, src_len, hid_dim]\n",
    "        # trg_mask = [batch_size, 1, trg_len, trg_len]\n",
    "        # src_mask = [batch_size, 1, 1, src_len]\n",
    "        \n",
    "        # self attention\n",
    "        _trg, _ = self.self_attention(trg, trg, trg, trg_mask)\n",
    "        # dropout, residual connection and layer norm\n",
    "        trg = self.self_attn_layer_norm(trg + self.dropout(_trg))\n",
    "         \n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        # ====================================\n",
    "        \n",
    "        # encoder attention\n",
    "        _trg, attention = self.encoder_attention(trg, enc_src, enc_src, src_mask)\n",
    "        # dropout, residual connection and layer norm\n",
    "        trg = self.enc_attn_layer_norm(trg + self.dropout(_trg))\n",
    "        \n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        # ====================================\n",
    "        \n",
    "        \n",
    "        # positionwise feedforward\n",
    "        _trg = self.positionwise_feedforward(trg)\n",
    "        \n",
    "        # dropout, residual and layer norm\n",
    "        trg = self.ff_layer_norm(trg + self.dropout(_trg))\n",
    "        \n",
    "        # trg = [batch_size, trg_len, hid_dim]\n",
    "        # ====================================\n",
    "        \n",
    "        # attention = [batch_size, n_heads, trg_len, src_len]\n",
    "        \n",
    "        return trg, attention"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Full Seq2Seq Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Seq2SeqModel(pl.LightningModule):\n",
    "    def __init__(self, input_dim, output_dim, trg_tokenizer, config):\n",
    "        super().__init__()\n",
    "        self.trg_tokenizer = trg_tokenizer\n",
    "        self.input_dim = input_dim\n",
    "        self.output_dim = output_dim\n",
    "\n",
    "        self.encoder = Encoder(\n",
    "            input_dim,\n",
    "            config[\"hid_dim\"],\n",
    "            config[\"enc_layers\"],\n",
    "            config[\"enc_heads\"],\n",
    "            config[\"enc_pf_dim\"],\n",
    "            config[\"enc_dropout\"],\n",
    "        )\n",
    "\n",
    "        self.decoder = Decoder(\n",
    "            output_dim,\n",
    "            config[\"hid_dim\"],\n",
    "            config[\"dec_layers\"],\n",
    "            config[\"dec_heads\"],\n",
    "            config[\"dec_pf_dim\"],\n",
    "            config[\"dec_dropout\"],\n",
    "        )\n",
    "\n",
    "        self.lr = config[\"lr\"]\n",
    "        self.apply(self.initialize_weights)\n",
    "    \n",
    "    \n",
    "    def initialize_weights(self, m):\n",
    "        if hasattr(m, 'weight') and m.weight.dim() > 1:\n",
    "            nn.init.xavier_uniform_(m.weight.data)\n",
    "    \n",
    "    \n",
    "    # Training\n",
    "    # Use only when training and validation\n",
    "    def _forward(self, src, trg):\n",
    "        # src = list of Encoding([ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing])\n",
    "        # trg = list of Encoding([ids, type_ids, tokens, offsets, attention_mask, special_tokens_mask, overflowing])\n",
    "\n",
    "        # src_batch = [batch_size, src_len]\n",
    "        # src_mask  = [batch_size, 1, 1, src_len]\n",
    "        src_batch = torch.tensor([e.ids for e in src], device=self.device)\n",
    "        src_mask = torch.tensor([e.attention_mask for e in src], device=self.device).unsqueeze(1).unsqueeze(2)\n",
    "        \n",
    "        # trg_batch = [batch_size, trg_len-1]\n",
    "        # trg_mask  = [batch_size, 1, trg_len-1, trg_len-1]\n",
    "        trg_batch = torch.tensor([e.ids[:-1] for e in trg], device=self.device)\n",
    "        trg_pad_mask = torch.tensor([e.attention_mask[:-1] for e in trg], device=self.device).unsqueeze(1).unsqueeze(2)\n",
    "        \n",
    "        trg_len = trg_batch.shape[1]\n",
    "        trg_sub_mask = torch.tril(torch.ones((trg_len, trg_len), device = self.device)).bool()\n",
    "        trg_mask = trg_pad_mask & trg_sub_mask\n",
    "        \n",
    "        # enc_src = [batch_size, src_len, hid_dim]\n",
    "        enc_src = self.encoder(src_batch, src_mask)\n",
    "        \n",
    "        # output = [batch_size, trg_len, output_dim]\n",
    "        # attention = [batch_size, n_heads, trg_len, src_len]\n",
    "        output, attention = self.decoder(trg_batch, enc_src, trg_mask, src_mask)\n",
    "        \n",
    "        return output, attention\n",
    "\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # both are lists of encodings\n",
    "        src, trg = batch\n",
    "        \n",
    "        y = torch.tensor([e.ids for e in trg], device=self.device)\n",
    "        preds, _ = self._forward(src, trg)\n",
    "        # y    = [batch_size, trg_len]\n",
    "        # pred = [batch_size, trg_len-1, output_dim]\n",
    "        \n",
    "        output_dim = preds.shape[-1]\n",
    "        \n",
    "        # y    = [batch_size * (trg_len-1)]\n",
    "        # pred = [batch_size * (trg_len-1), output_dim]\n",
    "        y = y[:, 1:].contiguous().view(-1)\n",
    "        preds = preds.contiguous().view(-1, output_dim)\n",
    "        \n",
    "        loss = F.cross_entropy(preds, y, ignore_index=self.trg_tokenizer.token_to_id(\"[PAD]\"))\n",
    "        self.log(\"train_loss\", loss)\n",
    "\n",
    "        perplexity = torch.exp(loss)\n",
    "        self.log(\"train_ppl\", perplexity)\n",
    "        \n",
    "        if self.global_step % 50 == 0:\n",
    "            torch.cuda.empty_cache()\n",
    "            \n",
    "        return loss\n",
    "    \n",
    "    \n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        src, trg = batch\n",
    "        y = torch.tensor([e.ids for e in trg], device=self.device)\n",
    "        preds, _ = self._forward(src, trg)\n",
    "        \n",
    "        output_dim = preds.shape[-1]\n",
    "        y = y[:, 1:].contiguous().view(-1)\n",
    "        preds = preds.contiguous().view(-1, output_dim)\n",
    "        \n",
    "        loss = F.cross_entropy(preds, y, ignore_index=self.trg_tokenizer.token_to_id(\"[PAD]\"))\n",
    "        self.log(\"valid_loss\", loss, sync_dist=True)\n",
    "        \n",
    "        perplexity = torch.exp(loss)\n",
    "        self.log(\"valid_ppl\", perplexity, sync_dist=True)\n",
    "        \n",
    "    \n",
    "    # Inference\n",
    "    # * Let you use the pl model as a pytorch model.\n",
    "    # * \n",
    "    # * pl_model.eval()\n",
    "    # * pl_model(X)\n",
    "    # *\n",
    "    def forward(self, src, max_len=150):\n",
    "        # src_batch    = [batch_size, src_len]\n",
    "        # src_mask     = [batch_size, 1, 1, src_len]\n",
    "        # real_src_len = [batch_size] (src_len without <pad>)\n",
    "        src_batch = torch.tensor([e.ids for e in src], device=self.device)\n",
    "        src_mask = torch.tensor([e.attention_mask for e in src], device=self.device).unsqueeze(1).unsqueeze(2)\n",
    "        batch_size = src_batch.shape[0]\n",
    "        \n",
    "        # first input to the decoder = [BOS] tokens\n",
    "        # trg_batch = [batch_size, 1]\n",
    "        trg_batch = torch.tensor([self.trg_tokenizer.token_to_id(\"[BOS]\")], device=self.device).repeat(batch_size).unsqueeze(1)\n",
    "        \n",
    "        # enc_src = [batch_size, src_len, hid_dim]\n",
    "        enc_src = self.encoder(src_batch, src_mask)\n",
    "        \n",
    "        for _ in range(1, max_len):\n",
    "            trg_pad_mask = (trg_batch != self.trg_tokenizer.token_to_id(\"[PAD]\")).unsqueeze(1).unsqueeze(2)\n",
    "            trg_sub_mask = torch.tril(torch.ones((trg_batch.shape[1], trg_batch.shape[1]), device = self.device)).bool()\n",
    "            trg_mask = trg_pad_mask & trg_sub_mask\n",
    "            # trg_mask = [batch_size, 1, trg_len, trg_len]\n",
    "            \n",
    "            # output = [batch_size, trg_len, output_dim]\n",
    "            # attention = [batch_size, n_heads, trg_len, src_len]\n",
    "            output, attention = self.decoder(trg_batch, enc_src, trg_mask, src_mask)\n",
    "            pred = output.argmax(2)[:, -1].unsqueeze(1)\n",
    "            \n",
    "            trg_batch = torch.cat([trg_batch, pred], dim=1)\n",
    "\n",
    "        real_src_len = torch.sum(src_mask, axis=3).view(-1)\n",
    "\n",
    "        return trg_batch, attention, real_src_len      \n",
    "\n",
    "        \n",
    "    def test_step(self, batch, batch_idx):\n",
    "        src, trg = batch\n",
    "        \n",
    "        output, attn_matrix = self._forward(src, trg)\n",
    "        preds = output.argmax(2)\n",
    "        src_mask = torch.tensor([e.attention_mask for e in src], device=self.device)\n",
    "        real_src_len = torch.sum(src_mask, axis=1).view(-1)\n",
    "    \n",
    "        # attn_matrix  = [batch_size, n_heads, trg_len, src_len]\n",
    "        # preds        = [batch_size, trg_len]\n",
    "        # real_src_len = [batch_size]\n",
    "        \n",
    "        # convert `preds` tensor to list of real sentences (tokens)\n",
    "        # meaning to cut the sentence by [EOS] and remove the [PAD] tokens\n",
    "        \n",
    "        # eos_pos = dict(sentence_idx: first_pad_position)\n",
    "        #\n",
    "        # e.g., {0: 32, 2: 55} \n",
    "        # Meaning that we have 32 tokens (include [EOS]) in the first predicted sentence\n",
    "        # and `max_len` tokens (no [EOS]) in the second predicted setence\n",
    "        # and 55 tokens (include [EOS]) in the third predicted sentence\n",
    "        eos_pos = dict(reversed((preds == self.trg_tokenizer.token_to_id(\"[EOS]\")).nonzero().tolist()))\n",
    "    \n",
    "        pred_sentences, attn_matrices = [], []\n",
    "        for idx, (sentence, attention, src_len) in enumerate(zip(preds, attn_matrix, real_src_len)):\n",
    "            \n",
    "            # sentence  = [trg_len_with_pad]\n",
    "            #           = [real_trg_len]\n",
    "            pred_sentences.append(sentence[:eos_pos.get(idx)+1 if eos_pos.get(idx) else None])\n",
    "            \n",
    "            # attention = [n_heads, trg_len_with_pad, src_len_with_pad]\n",
    "            #           = [n_heads, real_trg_len, real_src_len]\n",
    "            attn_matrices.append(attention[:, :eos_pos.get(idx)+1 if eos_pos.get(idx) else None, :src_len])\n",
    "        \n",
    "        # source sentences for displaying attention matrix \n",
    "        src = [[token for token in e.tokens if token != \"[PAD]\"] for e in src]\n",
    "        \n",
    "        # target sentences for calculating BLEU scores\n",
    "        trg = [[token for token in e.tokens if token != \"[PAD]\"] for e in trg]\n",
    "        \n",
    "        return pred_sentences, attn_matrices, src, trg\n",
    "        \n",
    "    \n",
    "    def test_epoch_end(self, test_outputs):\n",
    "        outputs = []\n",
    "        for (pred_sent_list, attn_list, src_list, trg_list) in test_outputs:\n",
    "            for pred_sent, attn, src, trg in list(zip(pred_sent_list, attn_list, src_list, trg_list)):\n",
    "                pred_sent = list(map(self.trg_tokenizer.id_to_token, pred_sent))\n",
    "                outputs.append((pred_sent, attn, src, trg))\n",
    "        \n",
    "        # outputs = list of predictions of testsets, each has a tuple of (pred_sentence, attn_matrix, src_sentence, trg_sentence)\n",
    "        # pred_sentence = [trg_len]\n",
    "        # attn_matrix   = [n_heads, trg_len, src_len]\n",
    "        # src_sentence  = [src_len]\n",
    "        # trg_sentence  = [trg_len]\n",
    "        self.test_outputs = outputs\n",
    "        \n",
    "    def configure_optimizers(self):\n",
    "        return torch.optim.Adam(self.parameters(), lr=self.lr)\n",
    "    \n",
    "    \n",
    "    def optimizer_zero_grad(self, epoch, batch_idx, optimizer, optimizer_idx):\n",
    "        optimizer.zero_grad(set_to_none=True)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "wandb_logger = pl.loggers.WandbLogger()\n",
    "\n",
    "model = Seq2SeqModel(\n",
    "    input_dim,\n",
    "    output_dim,\n",
    "    dm.trg_tokenizer,\n",
    "    config,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 34,089,872 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "print(f'The model has {count_parameters(model):,} trainable parameters')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jay\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\pytorch_lightning\\utilities\\distributed.py:52: UserWarning: Checkpoint directory checkpoints exists and is not empty.\n",
      "  warnings.warn(*args, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "ckpt_dir = Path(\"checkpoints\")\r\n",
    "checkpoint = pl.callbacks.ModelCheckpoint(dirpath=ckpt_dir,  # path for saving checkpoints\r\n",
    "                                          filename=f\"{job_name[job]}-\" + \"{epoch}-{valid_loss:.3f}\",\r\n",
    "                                          monitor=\"valid_loss\",\r\n",
    "                                          mode=\"min\",\r\n",
    "                                          save_weights_only=True,\r\n",
    "                                          save_top_k=20,\r\n",
    "                                         )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: True, used: True\n",
      "TPU available: None, using: 0 TPU cores\n"
     ]
    }
   ],
   "source": [
    "trainer = pl.Trainer(\r\n",
    "    fast_dev_run=False,\r\n",
    "    logger=wandb_logger,\r\n",
    "    gpus=1,\r\n",
    "    max_epochs=15,\r\n",
    "    gradient_clip_val=1,\r\n",
    "    precision=config[\"precision\"],\r\n",
    "    callbacks=[checkpoint],\r\n",
    "#     resume_from_checkpoint=ckpt_dir / \"transformer_baseline_language_specific_ch2jp-epoch=4-valid_loss=4.131.ckpt\",\r\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n",
      "\n",
      "  | Name    | Type    | Params\n",
      "------------------------------------\n",
      "0 | encoder | Encoder | 11.7 M\n",
      "1 | decoder | Decoder | 22.4 M\n",
      "------------------------------------\n",
      "34.1 M    Trainable params\n",
      "0         Non-trainable params\n",
      "34.1 M    Total params\n",
      "136.359   Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation sanity check:  50%|█████     | 1/2 [00:01<00:01,  1.87s/it]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Jay\\AppData\\Local\\Programs\\Python\\Python38\\lib\\site-packages\\pytorch_lightning\\core\\step_result.py:148: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  value = torch.tensor(value, device=device, dtype=torch.float)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 7261/7261 [49:03<00:00,  2.47it/s, loss=0.953, v_num=26a8]\n"
     ]
    },
    {
     "data": {
      "text/plain": "1"
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainer.fit(model, datamodule=dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing (BLEU Scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_corpus_bleu(preds: List[str], refs: List[List[str]], n_gram=4):\n",
    "    # arg example:\n",
    "    # preds: [\"机器人行业在环境问题上的措施\", \"松下生产科技公司也以环境先进企业为目标\"]\n",
    "    # refs: [[\"机器人在环境上的改变\", \"對於机器人在环境上的措施\"],  [\"松下科技公司的首要目标是解决环境问题\"]]\n",
    "    preds = list(map(list, preds))\n",
    "    refs = [[list(sen) for sen in ref] for ref in refs]\n",
    "    return torchmetrics.functional.nlp.bleu_score(preds, refs, n_gram=n_gram)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.18it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=0-valid_loss=2.231.ckpt\n",
      "tensor(0.3979)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.20it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=1-valid_loss=1.858.ckpt\n",
      "tensor(0.4669)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:14<00:00,  2.20it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=2-valid_loss=1.746.ckpt\n",
      "tensor(0.4926)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.19it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=3-valid_loss=1.697.ckpt\n",
      "tensor(0.5045)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:16<00:00,  2.03it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=4-valid_loss=1.652.ckpt\n",
      "tensor(0.5100)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.12it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=5-valid_loss=1.663.ckpt\n",
      "tensor(0.5154)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.09it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=6-valid_loss=1.657.ckpt\n",
      "tensor(0.5218)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:16<00:00,  2.06it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=7-valid_loss=1.659.ckpt\n",
      "tensor(0.5218)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.10it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=8-valid_loss=1.664.ckpt\n",
      "tensor(0.5235)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.09it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer_language_specific_ch2jp-full-epoch=9-valid_loss=1.654.ckpt\n",
      "tensor(0.5265)\n",
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.14it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer_language_specific_ch2jp-full-epoch=10-valid_loss=1.688.ckpt\n",
      "tensor(0.5269)\n",
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.10it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer_language_specific_ch2jp-full-epoch=11-valid_loss=1.685.ckpt\n",
      "tensor(0.5253)\n",
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.16it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer_language_specific_ch2jp-full-epoch=12-valid_loss=1.722.ckpt\n",
      "tensor(0.5278)\n",
      "Testing: 100%|██████████| 33/33 [00:15<00:00,  2.16it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer_language_specific_ch2jp-full-epoch=13-valid_loss=1.704.ckpt\n",
      "tensor(0.5260)\n",
      "Testing: 100%|██████████| 33/33 [00:14<00:00,  2.21it/s]\n",
      "--------------------------------------------------------------------------------\n",
      "DATALOADER:0 TEST RESULTS\n",
      "{}\n",
      "--------------------------------------------------------------------------------\n",
      "transformer_language_specific_ch2jp-full-epoch=14-valid_loss=1.712.ckpt\n",
      "tensor(0.5277)\n"
     ]
    }
   ],
   "source": [
    "test_ckpt = [\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=0-valid_loss=2.231.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=1-valid_loss=1.858.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=2-valid_loss=1.746.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=3-valid_loss=1.697.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=4-valid_loss=1.652.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=5-valid_loss=1.663.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=6-valid_loss=1.657.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=7-valid_loss=1.659.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=8-valid_loss=1.664.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=9-valid_loss=1.654.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=10-valid_loss=1.688.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=11-valid_loss=1.685.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=12-valid_loss=1.722.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=13-valid_loss=1.704.ckpt\",\r\n",
    "\"transformer_language_specific_ch2jp-full-epoch=14-valid_loss=1.712.ckpt\",\r\n",
    "]\r\n",
    "\r\n",
    "for ckpt in test_ckpt:\r\n",
    "    model.load_state_dict(torch.load(ckpt_dir / ckpt)[\"state_dict\"])\r\n",
    "    trainer.test(model, datamodule=dm)\r\n",
    "    preds = [\r\n",
    "        dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, output[0])))\r\n",
    "        for output in model.test_outputs\r\n",
    "    ]\r\n",
    "    refs = [\r\n",
    "        [dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, output[3])))]\r\n",
    "        for output in model.test_outputs\r\n",
    "    ]\r\n",
    "\r\n",
    "    bleu_score = calculate_corpus_bleu(preds, refs, n_gram=4)\r\n",
    "    print(ckpt)\r\n",
    "    print(bleu_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": "<br/>Waiting for W&B process to finish, PID 1952<br/>Program ended successfully.",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "wandb: Network error resolved after 0:05:06.861199, resuming normal operation.\n",
      "wandb: ERROR Control-C detected -- Run data was not synced\n"
     ]
    }
   ],
   "source": [
    "wandb.log({\"bleu_score\": 52.78})\r\n",
    "run.finish()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Case Study and Attention Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['Noto Sans CJK TC']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n",
    "\n",
    "def sentence_bleu(pred_token, trg_token):\n",
    "    trg  = dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, trg_token)))\n",
    "    pred = dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, pred_token)))\n",
    "    return calculate_corpus_bleu([trg], [[pred]])\n",
    "\n",
    "\n",
    "def case_study(pred_token, src_token, trg_token, attn_matrix):\n",
    "    src  = dm.src_tokenizer.decode(list(map(dm.src_tokenizer.token_to_id, src_token)))\n",
    "    trg  = dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, trg_token)))\n",
    "    pred = dm.trg_tokenizer.decode(list(map(dm.trg_tokenizer.token_to_id, pred_token)))\n",
    "    bleu = calculate_corpus_bleu([trg], [[pred]])\n",
    "    \n",
    "    print(f\"SOURCE: \\n{src}\\n {'-'*100}\")\n",
    "    print(f\"TARGET: \\n{trg}\\n {'-'*100}\")\n",
    "    print(f\"PREDICTION: \\n{pred}\\n {'-'*100}\")\n",
    "    print(f\"BLEU SCORE: {bleu}\")\n",
    "    \n",
    "    plt.figure(figsize=(30, 30))\n",
    "    for i in range(6):\n",
    "        plt.subplot(3, 2, i+1)\n",
    "        ax = sns.heatmap(attn_matrix[i], xticklabels=src_token, yticklabels=pred_token)\n",
    "        ax.xaxis.set_ticks_position('top')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2107/2107 [00:06<00:00, 329.17it/s]\n"
     ]
    }
   ],
   "source": [
    "scores = []\n",
    "\n",
    "for i in tqdm(range(len(model.test_outputs))):\n",
    "    bleu = sentence_bleu(\n",
    "        model.test_outputs[i][0],\n",
    "        model.test_outputs[i][3],\n",
    "    )\n",
    "    scores.append(bleu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[359, 1790, 1977, 1278, 1886, 1563, 1081, 1525, 764, 377]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "heapq.nlargest(50, range(len(scores)), np.array(scores).take)[10:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SOURCE: \n",
      "因此,控制处理的条件处理时间在7.2[ms]以内。\n",
      "\n",
      " ----------------------------------------------------------------------------------------------------\n",
      "TARGET: \n",
      "よって,制御処理の条件処理時間は7.2[ms]以内となる.\n",
      " ----------------------------------------------------------------------------------------------------\n",
      "PREDICTION: \n",
      "その,制御処理の条件処理時間は7.2[ms]以内でなる.\n",
      " ----------------------------------------------------------------------------------------------------\n",
      "BLEU SCORE: 0.7965020537376404\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABmUAAAaJCAYAAAC+nwlPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdebxkZ10n/s+3u9MJ2QhIWBJAQAiLKBATFHEJqEFglAFGB5EBHLEVRUWU+aGIAm4MizKCg7QoMeLGaBSZIKIQHQEVokDYkR2TELbse/f9/v6oanJz0933drqqTt3T73e/6nXrVp1b9em71D2f+5znOdXdAQAAAAAAYL62DB0AAAAAAADgUGBQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFmCQQZmq6unlLlX13FXvf6mqfqeqtk+321pVv1hVn6yqi6rqlVV11KrHeWZVfXZ6eXlVHVVVfz99rCcP8X8bu6raNnSGZVNV31FVJ06vH1NVpy/gOX+wqr53P/cbcJ2qqq8b8vNRVberqlOHev5ls/r1f+gsQ6uqM6afi+cu6PlqI7cxP/vZ/+mq+uSq7R5TVe+rqkur6o1VdbdV931nVX1wet/rq+quqx7rjCH+XwCLokduTjrkTemQy02HXC465A10yEOPDjleQ/2S+VR3V3d/cvr+65JsS/LtSR6fZM8OyTOTfF+SRyb5uiRflWRnklTV1yd5fpKHJzk5yYVJdnX3aUmed3NCTb/Br6qqD+3jcllVnbZq+09W1R2r6rSq+rub85zLrKqeUlXPWvX+Nyd545ptXl9V31ZVb6iqbdMC9HVV9dBpwfnWGeQ4vKo+WlWHrbpt16rrz5yWrUuq6iVVdX5Vvbuqrqiq905fdE452Bz78fIkW6fXH5HJ9/DcVNW3JXlFkhdM/5/vrapfX7PZ66bfl0+rqjtV1YdmnGHwr0lVPXD1z+ea+15QVU+bvvucJM+uqmdPf2ZXX66Z8/dGkvxAkifO+TluZC+/qLuqvnHV/feqqnOmr2lnV9WtFhhv7ev/Iau7n5zJ98fcVdUzkvzS9HX6HqvuelZVvXAv2//Monb0DzE32f+Zvl/dfZckqapvSHJmkv8vyV2TvCfJm6tqe03+2PjaJC+Z3vfGJNXdz03ykIX+TwCGsXQ9Uoe8MR1yw3TI6JD7oUPemA45pUMeknTIkVqmI1YqyeFJVpJ8dHrbTyb50e5+f5JU1Y8k+cj0heH2020u7+4LkvzKjHK8Y7pDnqr6miS37+6/nb7/mhk9x6ZSVf89yTOSHJHk+Kr6aJKrk7wmyYOSnJTkDknOTfIXST6V5I5Jjk5y2N4e8wCdmuTOSd5bVStJTpvmqp54UVVdmOS+3f2sqnpkd9+/qv4+yX9KcsYMMtxETY5s+pskd0vyhqp6aSbl7qF1w2j1ju5+04yeb1uSn03yQ0nOz+T/tjvJOUnOXrXdqUnun+TDSf50epm1ZfiaHJnkn7v7ydOd459K8m3T++6d5JqqujrJDyd5fHf/Rta8TkzzzFxVPSbJb2byunbbJJdU1aPXbPaM7n7tPJ5/+sv1udMsj03ytCT/tGqT78qkCL4ryV9l8vP9nHlkYWlcl8nv2K9Kck5VPaC7L8rkZ+Vt09eXT67a/phMfqSfsuq2e3b3lYsKfAj7ySS/291nJ0lV/VySxyV5VJK/zeRrc1V3fynJbw2WEmB5LEOP1CHX0CH3Tocc/GuiQ+6DDsle6JCbhw65CS3L9NRHJbk+yduT/GWSj1bVcZnsMP/rno26+6NJLk1yr0x2ZN6e5P1V9dtVdfvM3oOSfMvaG6vqLVV1zzk839Koqmcm+bVMjjJ7XCY7Itck+cYk/5Hk5zLZwf79JC9O8sEkP5PkbXOIc9r0+U7O5HviC9Pb/7Rqr9Mmj6mqf55uf06Sh84hUzIpC5/t7sMy+Rycnskvp+Ono9WvT9IzfL4jk3xlJjuzT8vkhfUtSZ7f3W9OJlPfM9lZfW0mR1sdleT9Se5RNyzRcNReHvtAnZbl+5r8Q5JXTS/vyeT14SNJXtvdv1FVb6+qc/dc5vD8X9bdZ3X3HZP8ciZHMRyf6deuu+84vcxlZ3q1mhyF9uJM/ijx5e/F7n5Rd/95d388yd9lcrTEaNXkCNYLq+p5VfX5mhyV+Yiq+khVfaqq7ldV31NVF0x/Rp4xdOY5uDrJEd394SS/lxt2xO6TyWtEpvffcfq9+1tJnr3q/V2ZFMS5mR7F89KqevV0H+BQ8KhVRyI+eXrbvXPjfZ/dSf4tyX26+5JMfjf/YVX9dVWdvOjAAEtmGXukDqlD7o8OuVxfEx1yDR1yQodMokMuKx1yJJZlpszrkjw6yVcneWmSn0+yZyrt2h/gLUl2d/c1VfUdSb4/ybOTnDcdtT3/YMNU1ZlJHpjkdpkcKfE9mbzgXD3dZPuqXOdmsvPyzVX1H9PbvnY6+rhpTY9SuTjJbZK8LMmTMhkB/0SSEzLZmb4kyfGZ7BzdLsl/nn74zHZWquqIJE9NclYmO/Mf6+6V6T7bEUl2VNUXM/keOKqq3p/JUW/fMO+jnPbisEyObLlPkvOSHJvkilk9eHdfVlU/nsnn+yeSXJzk8iQ/Mv08/UMmSzesTG+/bSYvzFcneWt332sWOZbsa/Kfq+p9SU7M5P/5Ld39jJpM3fyPJJ/J5HszSW6953NQq9bdnJequlcmS2DsWQv4Vkn+Mcnd5/3cqzwiyae7+4N7u3Nafh6Y5M8XmGkot8/kZ+ZBmbye786kGL4myY9m8r38wiRvyuQokrG5JpOfz2TyB5LvrKo7ZVKm3rmX7U9N8r4FZdvjEZl8bT6Zye+c/7Xg5x/C67r7P6+5bSX72PdJku7+uap6Q5JfSPIvVfWo7n7D3JMCLKel6ZE6pA55M+mQOuSX6ZBLR4fUIZeRDjkSyzJTJtPpqu/L5Ain07r7siQX5IZfRpkeWXRMJlNq090r3f0HSb4mkxfK75pRlidmsiPyH5kcSXXf7n7sPjY/JZMdi39cdfTCpt6ZTr58kr/bZjKV9/uTXJnkv3T3VUm+N5Mj0t6SyQ7jVZn8oF+RGe5MT313JtNjH57kO5L8v1X3PTXJL2ay0/SaJG/O5Mif86vq3Um+Ick7MtmBuTrz8aDpDt2vJPmXTKb3/uF0p3OmO9RVdZ9M/o/fkcko989lsh72f8vkF+UvZvL/fcn0Qx6cyS/KD+TGRzn9zEFGWaavyV92930zmYr/kUyK7SP2se0Jq45wOmEGz71PNZn+/4+ZvIbduibLNbwzyVfWZB3lD8/z+Vd5dNas4b3Gdye5Z5LfXUycwZ0xPVL2w0n+fLpkyVsz+X74P0l+LJPX9LkeBTeQq3PDDvV13f0Xmey0/kV3X7t6w+mRM3dJ8jU1WdJhUbYn+eL0sn2Bz7tsPpgb7/tsy+QI0Q/sua2739rdp2eybvBC1xsHWDbL0iN1SB3yAOiQOuRN6JBLS4ec0CGXmw65CS3LTJk9o+33z2S67J4R199I8qtV9YEkl2VyYro/6O7PV9UTM9mJfmkmRw/cOpNfXrPK8hOZvOj+bZK/qKrvn8VjbyIvSPJfMtlB/H+ZlJxnV9XdM9lxSSZHCDw8k5Nmfm2Sj08/5s9mmOPPMjnq4EWZ7Kw9eM8d3X1+TU5Y+OEk90hyTHd/NtM1Yac7uv+p53syuH/q7m+fThm8fXe/pyYn7PzpTIrfzHaoMyl5x2ZyJNPDM1mDuTM9Oel0my8vv9Dd35QkVXWbzPAopyzp16S7d1fVU5M8OXv/vF/Q3adMc8z8+de4TyavX9/b3e9Kcvfp1+Gfu3uRRzmdnMkRpDcx3Wl6dZLHTqezHkquW3O9uvv5VfX6TL6vH5fJETdjcnWS+1bV2Un+tSbr2/90JmuZf/mImqr62kzWEH96JmXjrVV16YIyvj6T78mjkvzggp5zGf2vJG+pqr/O5Hfwzya5Nsnrp39Y+eVM1u++JJPi855hYgIsh2XpkTpkEh1yo3TIJfma6JB7pUPunQ6pQy4zHXITWpaZMo/KZKrVmzPZKdtzsrBfz+RIib/OZG28j2TyCzyZTLO9aybfSH+X5H9n8sM4Cz81fewf6O4/TPLbmUxNXFdV3buqHjWjHEP6/5L8apL3dveHpjtjJye5rLvvtWrn7POZfC0uyuSop3T3Gd39y7MIMT2K7ZJMdtC2ZlKqVt//we5eyWTa9wOrakdVfaiqPpTJySPfPH3/kbPIs0G/kMkJ8E7I5AVvJnqyfut9M5m6fUkmUzTPy2R97Ed19327ex4nZFybY5m+Jnumnh83fe5zu/tp+9h2YUc5dffvJ/mjeT7HBt0pyeeSpKq+pSbLaqSq7pbkDUme1d3nDJhvWVRNTgD82Uz+QPCNA+eZqZosn/KKTI4E/u1M1gN+fSZrRd890xN6Tj01yU9299ndfWmSR2ZyxOvcdffV3f247v6u7v7cIp5zCaxeD3hXknT3O5I8Icn/zGQa/n2TfHt3X5/JSZA/kcmJeT+Qye/g5w0RHGBJLFOP1CF1yIOhQ+qQOuTmokPeQIdcLB1yJAafKdPdz82Nf5hX37eSydTa5+/lvk9lckTNrH1dkqOn18+pG59v7m6ZnAAuSR6QyUnzfjmTb+qjp9O1H5jJ0Sh7PbJgFqrqpEx2Xh/Z3XMZ3ezurtrryfb2GSuTz827V922dRZZqurhmezg/3omI+7/M8mvVdXRmUyJ/9kkP5TJ5/zf+oY1XxdxlNM3TncUj84Na1funr5/WHdfPKsnqqpbZzI19r8n+eFMvteuyWTH+u+r6k8yWbt57pbka/KJJE/s7r/ay33bs+YEmd197N7+KzPIscyOzuToiGSytveek8u+PJN1kl9WVa9Mku4e++difyqTo/Lencn3zdhO0vjRTP5o9cFMfp++JskLuvvXqurVmRxV/PEk6e6nrv7A7v709Of7aZntSWcPeevs//xlJkcXr739ykyOTvvp+SUD2ByWrEfqkNEhD4AOqUMuMx1yY3RIHXLhdMhxGXxQZgn9a3eftrc7plP17pfJDvMPJ/mTTI6wOieTkeDPZTK973HzDNjdH6mqv01yi3k9R1V9ZyZTD3+mqn47k+nOSfKFmqxtmiSvmU67vm8mL7QP7cnJ+rZlUjJWMjlR38HkeHwmI/H/pbv/oapel+THM5na+2OZlJpfTXK3aQk4s6oeuOoh3jjtBW/o7ln/krw2ye9294+vuf2vMylfs965PTmTk2I+sCdLLzwwSbr7r6vq/pnsxN5lxs95E8vyNZkW6k+tyfafM9nJvyrrrJFZVb+SyVT9gzqp63qq6teSfE8mBfOOq35+fmb6S3NuuvuwVdfPymTt8nT32KZV79e0wNWq909ZdX31EZmj3EnpyfIHe5ZV+UwmryF71tS/oKq+O5MTu95EVf10Jr/vzsvk5woAuCkdMjrkBumQOuS6dMjh6ZA6JMxbdS9+0LKq9jzpXWd9BEpV/X2Sb81k2vgZs3zs6eMfnskJrgYb7a2q/5rkoUl+ZMgc+1NVNYts053zY2Z5tNChZvpLdGt371p34409nq8JN9s8X/83m6o6I5MTJT5vesQLIzev7/+qem4mJ8j9/e5+8qweF2DZbNYeqUNujA65PHRIlokOeQMd8tCjQ47XIIMyHJyqOmy6LiAAAADslw4JALA8DMoAAAAAAAAswJahAwAAAAAAABwKNs2gTFXtGDpDIsday5BjGTIkcqwlx3JlSORYS44bW4Ycy5AhkQNgLJbldVSOG1uGHMuQIZFjLTlubBlyLEOGRI615FiuDIkcHLhNMyiTZFm+qeS4sWXIsQwZEjnWkuMGy5AhkWMtOW5sGXIsQ4ZEDoCxWJbXUTlubBlyLEOGRI615LixZcixDBkSOdaS4wbLkCGRgwO0mQZlAAAAAAAANq3q7rk/ybbtJx70k6ysXJktW446qMe4+lN/d7Ax8qrXvDZPecL3HtRj3Pnejz3oHFddd3GO3H6rg3qMW2w7/KBzXHbNF3LsEbe52R//6cs+d9AZZvG9MQtyyLHMGeSQYzPkWIYMY8ux67rza0ZxZur6L3x8rjugh93mbkv5/wY2bmk65AX/eLAx8qoz/zhPeeL3HdRjHHfnhx50jl27Ls+2bccc1GNcu+v6g86xDL9nlyGDHHJshhzLkEEOOZY9w9hy6JCLsWkGZWZhFoMyszCLQZlZmMWgzMGaxaAMALB3dqiBzWppOuQMBmVmYRaDMrMwi0EZAGB56ZCLsW2RTwYAAFnZPXQCAAAANouRdUjnlAEAAAAAAFgAM2UAAFisXhk6AQAAAJvFyDqkmTIAAAAAAAALYKYMAACLtTKuo5wAAACYo5F1SDNlAAAAAAAAFsBMGQAAFqpHth4wAAAA8zO2DmmmDAAAAAAAwAKYKQMAwGKNbD1gAAAA5mhkHdJMGQAAAAAAgAW4WTNlqmprd+9eZ5sdSXYkSW29ZbZsOermPBUAAGMzsvWAgfXpkAAA3Gwj65AHNFOmqu5fVX+f5MqqurSqXltVJ+xt2+7e2d2ndPcpdqYBAPiyld3zvQBLQ4cEAOCgjaxDbnhQpqrukuTsJK9Mcrsk90tySZK/qarD5xEOAACAzUmHBACAmzqQmTLPTPKL3f3H3X1pd3+yu3ck+WySx88nHgAAo9Mr870Ay0KHBADg4I2sQx7IoMzJSU6uqkevmW5+RpIHzDQVAAAAm50OCQAAa2w7gG2/lOTYJD+S5Her6l+TvDjJXyX50zlkAwBgjFbMZoFDhA4JAMDBG1mHPJCZMm9Ncn53PyzJbZO8IpMd6v/Z3bvmEQ4AAIBNS4cEAIA1DmSmzP9Kcl5V/Xt3vyrJWdOTM/5mkh+dSzoAAEannfcFDhU6JAAAB21sHXLDgzLdfVVVfVuSM6rqF5JcluTOSZ4xr3AAAABsTjokAADc1IHMlEl3fyrJQ6rqdknulOQj3X3ZXJIBADBOI1sPGNg3HRIAgIM2sg55IOeUSZJU1V8nubi7z7UzDQAAwP7okAAAcIN1B2Vq4qlVVdObTkhy2PS+bVX10/MMCADAyPTKfC/AoHRIAABmamQdciPLl21N8rIkX5XkZ5JckuSIJFcmOTzJLyV5yf4eoPZ35wIdc9eHDR1hqXzsN4f/fDztVz8zdIQkyWs/969DR0iSXLf7+qEjJElWuoeOkGR5XjuW47MBALBpHHSH/Kbb3nu+CTfonvd67NARkiQ/eNuvHzpCkuRPL37P0BGSJFdcf83QEXLs9iOHjpAk+fxVlw4dgSW1pZajUR+9/RZDR0iS7FrZPXSEJMmtjjh66AhJkvMv/+LQEZIkR20/YugIOXLb4UNHSJJs3XLAC1qxia07KNPdu6rqc0keWFU/lMkO9fck+e0k90+yHH9VBwBgc1iSUgzMhw4JAMBMjaxDbmSmTJJcneRxSf4+yUqSe1XVSUm+LcnvzicaAAAAm5QOCQAAe7HRQZmrklyX5DFJ3pbkxzM5H83bk/z5fKIBADBKzvsChwIdEgCA2RhZh9zooMzPJbmmu99XVS9Kcpvu/vU55gIAYKxWxrVDDeyVDgkAwGyMrENu6AxC3f367r5i+u6Hkhw7v0gAAABsZjokAADs3UZnynxZd/9Zkj+bQxYAAA4FI5t6DuyfDgkAwEEZWYfc0EwZAAAAAAAADs4Bz5QBAICDMrL1gAEAAJijkXVIM2UAAAAAAAAW4KBmylTV1yS5RXe/Y0Z5AAAYue7dQ0cABqJDAgBwoMbWIQ92pswbkvxwVb1iFmEAAAAYNR0SAIBD2sGeU+ah3f3vVfW9VbW1Vw1ZVdWOJDuSZMvWW2bLlqMO8qkAABiFHtd6wMAB2VCHvMdx98oJR504WEgAAJbIyDrkQc2U6e5/n759ba+ZQ9TdO7v7lO4+xYAMAAAAG+2QBmQAABirg50pAwAAB2ZlXEc5AQAAMEcj65AHe04ZAAAAAAAANsCgDAAAi9Ur872so6qeVFUXVtX7q+p+a+7bUlW/U1WXV9W7q+rec/s8AAAAsL6BO+SsGZQBAOCQUVXHJ3lFkkdM375qzSbfnuQhSe6b5F+S/PxCAwIAADBqzikDAMBirexef5v5OT3JZ7r7XVV1UZKXVdUduvvC6f3XJrk4yaeT/E2SRw6UEwAAgGToDjlzBmUAAFisOU8Pr6odSXasumlnd++cXj8hyYen1y9MckWSE6fXk+RtSb6Y5PeSHJvk5+YaFgAAgP0bYImxeTIoAwDAqEwHYHbu6+7ceAnfLdPb9vjqJJXkHUmeneRBuWEQBwAAAA6KQRkAABZrZdCjnC5IctL0+glJjkxy/qr7fyLJq7v7T6rqA5nMmDljoQkBAAC4wbAdcua2rL8JAACMxpuSnFhVJyd5TJJ3Jjmpqs6c3l9JHlVVt0/yrbG/DAAAwAyZKQMAwGINuB5wd3+hqp6a5OwkFyd5XJK7J7nndJOfT/L7ST6e5BNJnjxATAAAAPZwTpkD1+tvshC7V3YPHWGpHPaYHx86Qs79he8fOkKS5Jpd1w0dgb1YltcOAMalu89Mcuaqm85Lctb0vguSfMcQuYAbfOrqzw8dIUmybctyHMd4xuffOXSEJMlfHH3q0BGSJC889rKhI+R9V3x66AhJJtM7uYEOeYOVXo7PxmXXXjV0hCTL87Ny1fXXDh1hqVy76/qhI2T3kiyLtaWW5buURViOPUwAAA4dS1J8AAAA2ARG1iGtkQ0AAAAAALAAZsoAALBYIzvKCQAAgDkaWYc0UwYAAAAAAGABzJQBAGChuncPHQEAAIBNYmwd0kwZAAAAAACABTBTBgCAxRrZesAAAADM0cg6pJkyAAAAAAAAC2CmDAAAi9XjOsoJAACAORpZhzQoAwDAYo1s6jkAAABzNLIOue6gTFWdkOTb93LXh7r7HbOPBAAAwGalQwIAwL5t5JwyX5PkvyU5btXlVknO2N8HVdWOqjq3qs5dWbnyoEICADAivTLfCzC0g+6Ql1/zxfkmBABg8xhZh9zo8mW3S3L/6fWavn1vVf3e9PoPdnev/oDu3plkZ5Js237ije4DAABg1A6qQ971K+6nQwIAMEobGZT5pyRvTfK7SX4syRuSHJVka5ITk5y9dmcaAAD2aWTrAQM3oUMCADA7I+uQ6w7KdPdlVfWfMtmpfliSzyc5OsmVSU7t7ufPNyIAAACbhQ4JAAD7tu6gTFU9MslhSe40ffvF6eXYJA+sqm3dvWuuKQEAGA/nfYFR0yEBAJipkXXILfu7s6q2JDk9ya4kb8pkR3pbkocn+ZYkRyR5wJwzAgAAsAnokAAAsH/7nSnT3StV9ZEkD0ry6iQvTPKxJG+bbnK3JMfMNSEAAOMysvWAgRvokAAAzNzIOuR+B2WqqpLcI8lzkzwvyZ8k+Y8k/7ZnkySnJnnL/CICAACwGeiQAACwf+vNlOmqOivJ/ZLcP8kLkjwpyZ9lsjPdST4y54wAAIzJyI5yAm6gQwIAMHMj65D7HZSZ+p4kR616/31JnpDJDvXWJF+X5KtnHw0AAIBNSIcEAIB92MigzFlJvnHNbd3dv5okVfXhmacCAGC8elxHOQE3oUMCADA7I+uQGxmUuTSTNYCTyVTzPVPO97jPrEMBAACwaemQAACwDxsZlHl3kkcmeXuSRyU5N8n3VNV/SfLR7n7G/OLNVq+/yULU0AGmvvsBPzZ0hPzzL54ydIQkyYOetxxflY9dduHQEZIk1+2+fugISZKVXpafWgBmamTrAQM38e4cZIf8zOVfmGvAzWY52kryulsMnWDiv19766Ej5B9veezQEZIkf7L7XUNHSJJces2VQ0eA/fLXheW0a2X30BGWIgMbMLIOuZFBmUry6CRvm16/V5LXJTknye/MLxoAAKM0sqnnwE3okAAAzM7IOuRGBmX+KsndkvxKktsn2ZXkS0m+O8lVVfVX3f3d84sIAADAJqJDAgDAPmxkUOYlmexQ/26Shya5Ksm/JvmH6f3LMpMaAIDNYGRTz4Gb0CEBAJidkXXIjQzKPD3JbZLcM8kXk1yR5IczmY6e7j59XuEAAADYdJ4eHRIAAPZq3UGZ7v7uqjopyXcm+WSStyR56XxjAQAwWiNbDxi4MR0SAICZGlmH3MhMmXT3R5J8ZNVNV8wnDgAAAJudDgkAAHu3oUEZAACYmZGtBwwAAMAcjaxDbhk6AAAAAAAAwKHAoAwAAIu1sjLfCwAAAOOxBB2yqp5UVRdW1fur6n5r7ttSVb9TVZdX1bur6t77eyyDMgAAAAAAAHtRVccneUWSR0zfvmrNJt+e5CFJ7pvkX5L8/P4eb91Bmao6ec3l3tPbHz59++ID/l8AAHDo6p7vBRiUDgkAwEwN3yFPT/KZ7n5XkrOSnFJVd1h1/7VJLk7y6SR/k+Sa/T3YRmbKvDnJzyZ50/TtH05vf8n07SP29kFVtaOqzq2qc1dWrtzA0wAAADACOiQAAJvG6v3Q6WXHmk1OSPLh6fULk1yR5MRV978tyReT/F6S70/ywv0937YNZPp0kicnOWf69l+q6s5JDpu+rb19UHfvTLIzSbZtP9EhiwAATDjvC4ydDgkAwOzMuUOu3g/d1ya58QSXLdPb9vjqTPZx35Hk2UkelBsGcW5iIzNl7pbk9UlOSvJ/k3xVkrOT3Gn61s4yAAAAe+iQAACMyQWZ7Nsmk1kzRyY5f9X9P5Hk1d39ikxmyjxnfw+2kUGZf+/uhyb5QHc/JMkHu/trknx8+navRzkBAMBerazM9wIMTYcEAGB2hu+Qb0pyYlWdnOQxSd6Z5KSqOnN6fyV5VFXdPsm3Zp1xl40sX3bbqvpAkmOnb/eMANmRBgDgwLWBExg5HRIAgNkZuEN29xeq6qmZzPq+OMnjktw9yT2nm/x8kt9P8vEkn8hkCd992sigzB939zOTpKqekMmoUJL8+nRk6B0H+H8AAABgvHRIAABGpbvPTHLmqpvOS3LW9L4LknzHRh9rI4MyP1hV10+vPz7JQ6rqoiRfn+Te3f2kjT4ZAABYYgxGT4cEAGB2RtYhN3JOmeuSvC/J+5NcleRj0+uvSfKo+UUDAABgE9IhAQBgHzYyU+bF3f1HSVJV1yT5hyT3SnJhkp1V9bTufvkcMwIAMCbdQycA5kuHBABgdkbWITcyKLOzqm49vX7O9O1dkzy/ux9aVZ9IYocaAACARIcEAIB92sigzBuTXLvmtk7y+un1mmkiAADGbWTrAQM3oUMCADA7I+uQGxmUqSQ/nMlawJ/v7i/vXFfV1mzsvDQAALAUqupJSV6Q5EtJHt/d71l1398n+dZVm1/f3dsXmxA2PR0SAAD2YSODMv+c5KVJDk/yFVV1TJIPJfntJFckee/c0o3UsqyA9/aLPzJ0hDzxBYcNHSFJ8uYHLEeOH/vA/YaOkCT5i8+eO3SEJMnh25bj63LtruuHjgAwLgMe5VRVxyd5RZIHTy+vSnLqnvu7+7RV274syRcXHBHG4KA75NYtyzFus3tJjspclg55xuffOXSEJMlfHn7U0BHyhlt85dARkiS3vPUpQ0dIkrzks28dOkKS5MjDDh86QpLksmuvGjoCwLgsyT7ZrKw7KNPdP1VVT05yXZKPZLIDfUqSByX5viTPnGdAAACYodOTfKa731VVFyV5WVXdobsvXL1RVd07ySOT3HuIkLCZ6ZAAALBvG5kpkyQ/meTsTKag3yPJ3ya5X5Izuvstc8oGAMAY9XyPcqqqHUl2rLppZ3fvnF4/IcmHp9cvzOSo/ROn11fbkeQPVi+7BBwQHRIAgNmYc4dctP0OylTV6UkeneR2Sc5K8r4k35/kDpmsE/zgqvr97r543kEBAGAjpgMwO/d1d258Post2fvKQI/O5Ih+4ADokAAAsH/rzZR5XyY701cmeXmSr89kHeBnJNmV5OeS/G1VfUt3WzATAIB19cqgZ0e4IMlJ0+snJDkyyfmrN6iqWyf5ykzOgQEcGB0SAICZGrhDztx+z57Y3Rd09x9098909zdmsg7wNUmO7O7d3f1LSZ5pZxoAgE3iTUlOrKqTkzwmyTuTnFRVZ67a5k5JdjmSHw6cDgkAAPu30XPKJEm6+11J3rXmtnNmmggAgHFbGW494O7+QlU9NZNzXVyc5HFJ7p7knqs2OzqJc8nADOiQAAActAE75Dwc0KAMAAActIFP0tjdZyZZPTPmvEzOfbHn/rdlMjADAADA0AbukLO23+XLAAAAAAAAmA0zZQAAWKyRnaQRAACAORpZhzzgmTJVtXUeQQAAABgfHRIAAG6w4UGZqrp/Vf19kiur6tKqem1VnTC/aAAAjNLKynwvwFLQIQEAmImRdcgNDcpU1V2SnJ3klUlul+R+SS5J8jdVdfg+PmZHVZ1bVeeurFw5m7QAAAAsvYPtkLt3X7GoqAAAsFAbnSnzzCS/2N1/3N2Xdvcnu3tHks8mefzePqC7d3b3Kd19ypYtR80qLwAAm93IjnIC9uqgOuTWrUcvNCwAAEtsZB1yo4MyJyc5uaoevWa6+RlJHjDzVAAAAGxmOiQAAOzFRgdlvpTk2CQ/kuR9VfW3VfWwJH+V5BnzCgcAwAh1z/cCLAMdEgCA2RhZh9zooMxbk5zf3Q9Lctskr0jy4iT/s7t3zSscAAAAm5IOCQAAe7Ftg9v9ryTnVdW/d/erkpw1PTnjbyb50bmlAwBgfJz3BQ4FOiQAALMxsg65oUGZ7r6qqr4tyRlV9QtJLkty55h2DgAAwBo6JAAA7N1GZ8qkuz+V5CFVdbskd0ryke6+bG7JAAAYpxXnfYFDgQ4JAMBMjKxDbnhQZo/uvijJRXPIAgAAwMjokAAAcIMDHpQBAICD0uNaDxgAAIA5GlmHNCgDAMBijWzqOQAAAHM0sg65ZegAAAAAAAAAhwIzZQ5hV153zdAR8qYvvG/oCEmSu/zDcoy2fv5PvmvoCEmSy5923dARkiT/7wsfHDoCAHPQK+Oaeg7M3m6vE0vp6uuvHTpCkmSlh+9vp1743qEjJEm+9Ps/OHSEJMnrf+ITQ0dIkvz7pRcMHQGAORhbhzRTBgAAAAAAYAHMlAEAYLFGth4wAAAAczSyDmmmDAAAAAAAwAKYKQMAwGL1uNYDBgAAYI5G1iHNlAEAAAAAAFgAM2UAAFiska0HDAAAwByNrEOaKQMAAAAAALAAZsoAALBYK+NaDxgAAIA5GlmHNFMGAAAAAABgAcyUAQBgsUa2HjAAAABzNLIOueGZMlV1i+nbZ8wvDgAAAGOgQwIAwE0dyPJlH5u+/ZmNbFxVO6rq3Ko6d2XlygNPBgDAOPXKfC/AstAhAQA4eCPrkDdn+bLayEbdvTPJziTZtv3Ecc0vAgDg5hvZ1HNgXTokAAA338g65LqDMlX1wenV46vqA0luM32bTHauO8l9ux2WCAAAcKjTIQEAYN82MlPmO5Jck+R9Sb45yQemb7/MzjQAABvVK3YdYeR0SAAAZmZsHXIj55R5VCY700cmOSLJSnd/cfVlrgkBAADYTHRIAADYh43MlHlvkvsneXySH0/y7/MMBADAyI1sPWDgJnRIAABmZ2Qdcr+DMlVVSX4myf2SvDbJ5UneXFW/sHq77n7+3BICAACwKeiQAACwf/sdlOnuTvLdVXVqklcn2Z3kJZmcnBEAAA7cyI5yAm6gQwIAMHMj65AbWb4s3f3OqvqGJD+S5BNJbt/d/6eq7pTkK+cZEAAAgM1FhwQAgL3b0KBMknT3FVX1d0l+MclXJfk/SZ6WyRFPb51PPAAARqdXhk4ALIAOCQDATIysQ25Zb4OqenFVnTZ991uS/PP09rsm+b4kvzavcAAAAGwuOiQAAOzbuoMySU5P8pqq2pHkyUnOTnJYkj9K8kPdffH84gEAMDorPd8LMDQdEgCA2RlZh9zI8mW7kjw0yVuSfCrJHZPcIcnnknx1VX11d//6/CIyL1tq+HNtrvRy/OHkPsfdeegISZLn/8S/DR0hSfKz1x05dIQkyeePu9PQEZIk7/nix4eOkC21kTH0+du1snvoCADA8jvoDnnY1g2vtD1X1+/eNXSEpbIc7S25dtd1Q0fIXW95h6EjJEn+/OkfGTpCkuTILYcPHSFJ8m3H33foCEmSv/nsu4eOkKO332LoCEmSbVu3Dh0hSXLx1VcMHSFJctT2I4aOkCS58rprho6wNIb/6yiHov3u6VbV9yQ5NpMZNZXkmEyOcKrpxy7HKzwAAJtGm80Co6VDAgAwa2PrkOsden1Mkjsl+b9JfijJBUkuTXLh9GP/pbt/Za4JAQAA2Cx0SAAA2I/9Dsp09+8leUQmRza9M8lvJnl0kuuSPC7JK6vq1vMOCQDAiIxsPWDgBjokAAAzN7IOue5JCrr7zUleleRXMlkT+IHT2z+V5IwkvzDHfAAAjM3KynwvwKB0SAAAZmpkHXKjZ0/81SRHdvc1VfWUJPee3v7yJCfPJRkAAMxBVT0pyQuSfCnJ47v7PWvuf3KS52dyDoxf7u5XLjwkbH46JAAA7MWGBmW6e3eSy6fXP5jkg9PrFyd589zSAQAwPgMuMVZVxyd5RZIHTy+vSnLqqvvvm+QlSR6WyaDNiQPEhE1PhwQAYGZGtkz1RmfKAADAGJye5DPd/a6quijJy6rqDt194fT+JyX5w+4+d/r+xwdJCQAAwCgZlAEAYLGGPcrphCQfnl6/MMkVmcyG2TMoc7ckX6qqDyU5KslTuvtvFp4SAACAiZHNlNkydAAAAJilqtpRVeeuuuxYdXfnxvvAW6a37XGLJHdOclqSP0jy0jnHBQAA4BBipgwAAAvVPd+jnLp7Z5Kd+7j7giQnTa+fkOTIJOevuv/TSa7q7s9W1Z8nefq8cgIAALC+eXfIRVt3pkxVnbzmcu/p7Q+fvn3xvEMCAMCMvCnJiVV1cpLHJHlnkpOq6szp/f8nyaOr6sQkj0vyrmFiwualQwIAwL5tZKbMm5P8XZKHJDknyVclOTnJS5L8dZJHJPmZtR80XSZiR5LU1ltmy5ajZhQZAIBNbcD1gLv7C1X11CRnJ7k4k4GXuye553STtyR5dZLzMplB84QhcsImd9Adctu2W2fbtqMXlRcAgGV2CJ5T5tNJnpzk49O326vqzkkOm76tvX1Qd+/s7lO6+xQDMgAALIvuPrO779Dd9+nu87r7rO7++ul93d3P7+6v6O6v7e7zhs4Lm9BBd0gDMgAAjNVGZsrcLcnrM1l7+/9mcpTT2UnuNH07rmEqAADma2RHOQE3oUMCADA7I+uQG5kp8+/d/dAkH+juhyT5YHd/TZKPT9/u9SgnAAAADkk6JAAA7MNGZsrctqo+kOTY6dvzp7fbkQYA4ID1yI5yAm5ChwQAYGbG1iE3Mijzx939zCSpqickedP09l+vqpOTvGNe4QAAGKGR7VADN6FDAgAwOyPrkBsZlPnBqrp+ev3xSR5SVRcl+fok9+7uJ80tHQAAAJuNDgkAAPuwkXPKXJfkfUnen+SqJB+bXn9NkkfNLxoAAKO0MucLMDQdEgCA2RlZh9zITJkXd/cfJUlVXZPkH5LcK8mFSXZW1dO6++VzzAgAAMDmoUMCAMA+bGRQZmdV3Xp6/Zzp27smeX53P7SqPpHEDjUAABsytpM0AjehQwIAMDNj65AbGZR5Y5Jr19zWSV4/vV4zTQQAAMBmpkMCAMA+bGRQppL8cCZrAX++u7+8c11VW7Ox89IAAMDEyI5yAm5ChwQAYHZG1iE3Mijzz0lemuTwJF9RVcck+VCS305yRZL3zi0dc7XSw38zX7PruqEjJEne86WPDx0hSfKVtztu6AhJkh0rFw4dIUnyr88+ZegISZJb/vTHho6Q3b176AhJluew1uFfvQCA/TjoDrlr96555mOTW4Z9wU9cuhyd6ew73HHoCEmSS6++augISZKd248ZOkKS5E01fHNaWYqflOQWW7cPHSFJcvHQAaZ6Cf4Wx435ijCEdQdluvunqurJSa5L8pFMdqBPSfKgJN+X5JnzDAgAwMisDB0AmCcdEgCAmRpZh9zITJkk+ckkZ2cyBf0eSf42yf2SnNHdb5lTNgAAADYnHRIAAPZiv4MyVXV6kkcnuV2Ss5K8L8n3J7lDJqvYPLiqfr+7l2UWIAAAS65Hth4wcAMdEgCAWRtbh1zvBIvvS/L2JH+U5OVJ/jDJp5N8V5KTk5yX5G+r6sh5hgQAAGBT0CEBAGA/9jtTprsvSPIH00uq6gFJnpDkyOmRTb9UVW/t7uU4oxsAAMtvZOsBAzfQIQEAmLmRdciNnlMmSdLd70ryrjW3nTPTRAAAAIyCDgkAADd2QIMyAABwsMa2HjAAAADzM7YOaVAGAIDFGtnUcwAAAOZoZB1yy9ABAAAAAAAADgVmygAAsFA9sqOcAAAAmJ+xdch1B2Wq6s7rbHJhd18/ozwAAABsYjokAADs20Zmynwgk1XbPpvkqCSfW3XfYUkuT/KgtR9UVTuS7EiS2nrLbNly1EGHBQBgBEZ2lBNwEwfdIbfokAAA7LEEHbKqnpTkBUm+lOTx3f2eNfc/Ocnzk1SSX+7uV+7rsTYyKPOuJNcneU6Sb+ru/7nmyT6ztw/q7p1JdibJtu0n9gaeBwAAgM3voDvkYTokAABLoqqOT/KKJA+eXl6V5NRV9983yUuSPCyTQZsT9/d4GxmUuWWSXUnuP32CNybZMx39kiSPOoD8AAAc4sa2HjBwEzokAAAzswQd8vQkn+nud1XVRUleVlV36O4Lp/c/Kckfdve50/c/vr8H27KBJ3xPkvcn+frp26OT/FKSX06y0t3/djP+EwAAAIyTDgkAwKZRVTuq6txVlx1rNjkhyYen1y9MckVuPBvmbkluUVUfqqrPVNXD9vd8G5kpc0WSPVPHr8pkBbdrp+8PP0YFAMDmYg8Sxk6HBABgdua8B7l6Gd19bZIbT3DZkhv2d5PkFpnMDD8tyU8keWmSe+/rwTYyKPNNmUw9PzPJ12TyKXjRnievqsd1959s4HEAAAAYPx0SAIAxuSDJSdPrJyQ5Msn5q+7/dJKruvuzVfXnSZ6+vwfbyKDMJZmcpPFfk9y/u087sLwAAHCDJVgPGJivS6JDAgAwI0vQId+U5Heq6uQkD07yziQnVdULu/uJSf5PkldV1UuSPC7Ju/b3YBsZlLl/Jkc2vTLJUVX1hLUbdPcDD+i/AAAAwFjdPzokAAAj0d1fqKqnJjk7ycWZDLzcPck9p5u8Jcmrk5yXyQyam+z/rraRQZmvSfJfk/x1ksuSnJ7kH5JcczPyAwBwiFuCo5yA+dIhAQCYmWXokN19ZibL8+5xXpKzpvd1kudPL+tad1Cmuz9ZVd+f5B+TvCSTk9g8MMkHppu8K8mnNhoeAACA8dIhAQBg39YdlKmqr05yRJK7JdmayQ71tiSHJakkv5HJ9HQAAFjXMhzlBMyPDgkAwCyNrUNuZPmylye5Q5KfymTNtMMyOeLpXzLZob7/vMIBADBCXUMnAOZLhwQAYHZG1iE3snzZQ6rqvUl+Isl3Jukk90nywiQ7uvtx840I83fktsOHjpAk+cR1Xxo6QpLk2pXrh46QJPlfL75s6AhJki1btgwdIX9xywcPHSFJ8oSr/nXoCEmSK69fjiXpV1aW41CNHjoAAKwyiw65fdth8w25QdfuWo79YpbPkduPGDpCkuRfrlyOlQB39+6hIyRJ/utVFw0dIUly2NaNHAM9X4/8iq8dOkKS5LhajtfznVe8begISZK7H3vC0BGSJOd98RNDR0gyOVJjaMvwNx8OPRv9LdFJLknysSQnJbkqyfd193vnlAsAgJEa29RzYK90SAAAZmJsHXIj55Q5J5P1gF82venYJNcnOTXJD8wvGgAAAJuNDgkAAPu2kZkyd0zybZnMKPubJKdPr//fOeYCAGCkemUZFioA5kiHBABgZsbWITcyKHN8kudmshN9u1XX71hVD+/uv55bOgAAADYbHRIAAPZhI4Myj1x1/VVrri/HGeUAANg0xrYeMHATOiQAADMztg657qBMd79tEUEAAADY/HRIAADYt43MlAEAgJnpHtd6wAAAAMzP2DrklqEDAAAAAAAAHArMlAEAYKHGth4wAAAA8zO2DmmmDAAAAAAAwAJsaKZMVR2e5LjuvmjVbV+f5L3dfdW8wgEAMD69Mq71gIGb0iEBAJiVsXXIjc6UuVOSN+15p6qOSrIzydH7+oCq2lFV51bVuSsrVx5cSgAAmJGqelJVXVhV76+q+62577Sq6lWXMwaKCZvdQXXIXbsuX0BEAABYvHVnylTVU5LcJcldq+q5SY5K8jVJrkpyQpLP7e3juntnJjvd2bb9xJ5NXAAANrsecM+wqo5P8ookD55eXpXk1DWbvbu7H7DobDAWs+iQRx15Fx0SAIAkw3bIedjITJlOct102yuTfCrJ3ZO8JcmfzS8aAABj1Cs118s6Tk/yme5+V5KzkpxSVXdYs83F8/h/wyFEhwQAYGYG7pAzt+6gTHf/bnc/P8nV3f2i7n55kk8keUGSI+YdEAAADsTqJZCmlx2r7j4hyYen1y9MckWSE9c8xNdW1eer6ryqOnkRmWFMdEgAANi3dZcvW2X1AM7fJTk7yT/PNg4AAGM37yORVi+BtLe7c+P92i3T2/Z4R5InJHlvkpcneWmSb5l9Sjgk6JAAABy0IWazzNOBDMrcc9X1X0/ywSRvm20cAACYqwuSnDS9fkKSI5Ocv+fO7r4qyRuTpKr+NMmLFx0QRkSHBACANdYdlKmqH8xkivknquqTmZyU8WWZrLW9PdYEBgDgAAx8ksY3Jfmd6bJkD07yziQnVdULu/uJVfWsJOck+Y8kT0ryT8NFhc1JhwQAYJYG7pAzt5GZMpcmuXeSb05ypyR3zGSJh08kOTx2qAEA2CS6+wtV9dRMllG6OMnjMjkB+Z4j+j+UybJl987kiP6fHCInbHI6JAAA7MO6gzLd/Wex0wwAwIwMvR5wd5+Z5MxVN52X5KzpfX+Z5C8XnwrGQ4cEAGCWhu6Qs7Zl/U0AAAAAAAA4WBtZvgwAAGame1xHOQEAADA/Y+uQZsoAAAAAAAAswEJmyizLOFYPHWDJHLFt+9ARcv3KrqEjJEmu2nXt0BGSJB+7/MKhIyRZju+NJLnN7qETTHQP/+px++1XDx0hSXLlpdcMHSFJcsz2WwwdIUlyyTVXDh0BNqVeGToBsOyu3XX90BFgv668bjn2i5clB8vn917zmKEjJEke8NiXDR0hSXLY1uVYLOi9X/zE0BGWyvB/bUl2rygnm8HYOqSZMgAAAAAAAAuwHMPEAAAcMlZGth4wAAAA8zO2DmmmDAAAAAAAwAKYKQMAwEL1yI5yAgAAYH7G1iENygAAsFC9Mq4dagAAAOZnbB3S8mUAAAAAAAALYKYMAAAL1T10AgAAADaLsXVIM2UAAAAAAAAWwEwZAAAWamzrAQMAADA/Y+uQ686UqapvWEQQAAAANj8dEgAA9m0jy5e9vareXFUnzT0NAACjt9I11wswOB0SAICZGVuH3OjyZb+V5I1V9akkb0zyoSSfS3Jtd//b3j6gqnYk2ZEkW7beMlu2HDWDuAAAAGwCB9UhS4cEAGCkNjIo0919VlX9VZJHJHl0kscnuVOSo5Icvo8P2plkZ5Ictv3Enk1cAAA2uzabBcbuoDvkNh0SAICpsXXIjQzKVJJ0964kfzW9AAAAwN7okAAAsA8bGZR53txTAABwyGjHv8PY6ZAAAMzM2DrklvU26G471AAAAGyIDgkAAPu2kZkyAAAwMysjWw8YAACA+Rlbh1x3pgwAAAAAAAAHz0wZAAAWqkd2lBMAAADzM7YOaVAGAICFGttJGgEAAJifsXVIy5cBAAAAAAAsgJkyAAAs1NhO0ggAAMD8jK1DmikDAAAAAACwAAuZKTOyJd9G45pd1w0dgTUuv+7qoSMkWZ4cT73qnKEjLI1frN1DR0iSbKnlGMv/jzf90tARkiTHfMszho6QxO9ZNp+xnaQRAGDZfOS/vXboCEmSK3ctx98Xzjzum4aOkCT5bxf/49ARkiS7VpbjbwywUWPrkMvx1zUAAAAAAICRc04ZAAAWamzrAQMAADA/Y+uQZsoAAAAAAAAsgJkyAAAslPMgAQAAsFFj65BmygAAAAAAACyAmTIAACzU2NYDBgAAYH7G1iHNlAEAAAAAAFgAM2UAAFioHtlRTgAAAMzP2DqkmTIAAAAAAAALcLNnylTVrZIc2d3nzzAPAAAjtzJ0AGAQOiQAADfH2DrkwSxf9sdJ7pnkrjPKAgDAIaAzrqnnwIbpkAAAHLCxdciDGZT5/iS32NedVbUjyY4kqa23zJYtRx3EUwEAALDJ6ZAAABzybvagTHd/cZ37dybZmSTbtp/YN/d5AAAYlxV7hnBI0iEBALg5xtYhtwwdAAAAAAAA4FBwMMuXAQDAAVsZ2XrAAAAAzM/YOqSZMgAAAAAAAAtgpgwAAAvVIzvKCQAAgPkZW4c0UwYAAAAAAGABDMoAALBQK3O+rKeqnlRVF1bV+6vqfvvY5qlV1VV1l5v53wQAAGAGhu6Qs2b5MgAADhlVdXySVyR58PTyqiSnrtnmuCT/I8nFi84HAADAuJkpAwDAQnVqrpd1nJ7kM939riRnJTmlqu6wZpvnTO+7bPb/ewAAAA7EwB1y5gzKAAAwKlW1o6rOXXXZseruE5J8eHr9wiRXJDlx1cfeI8n3JfnlhQUGAADgkGH5MgAAFmrea/Z2984kO/d1d258YNKW6W17vDjJ87r74qrFHzEFAADAjQ1x3pd5WsigzLLU2V5/E2CJbN2yHJP5uod/9fi9e14+dIQkyddfdeuhIyRJfuO/vn7oCEmSw7dtHzpCkmTXyu6hI2T3EmSADbogyUnT6yckOTLJ+UlSVccmeViS06rqfyY5Nsl5VXWn7r50iLAAADfHVz356KEjJElWfnP4Pp0kf3TYcqxK2/46CcTyZQAALNjKnC/reFOSE6vq5CSPSfLOJCdV1ZndfVl3H9Hdt+zu45J8OsnXGpABAAAYzsAdcuYsXwYAwEINcSLFLz939xeq6qlJzk5ycZLHJbl7knsOFgoAAIB9GrJDzoNBGQAADindfWaSM1fddF6Ss/ay3V0WlQkAAIBDg0EZAAAWamVcBzkBAAAwR2PrkM4pAwAAAAAAsABmygAAsFArI1sPGAAAgPkZW4c0UwYAAAAAAGABzJQBAGCheugAAAAAbBpj65BmygAAAAAAACzAQQ3KVNW3zCoIAACHhpU5X4DlpUMCAHCgxtYh1x2Uqar7VdU/VNWnq+p1VfXgVXefM8dsAAAAbDI6JAAA7NtGZsqckeQzSX48yfuTnF1Vz5reV/v6oKraUVXnVtW5KytXHnRQAADGYaVqrhdgcGdEhwQAYEbG1iG3bWCbOyf5zu6+KMnrquoVSd5QVV+d5Lp9fVB370yyM0kO237i2M7FAwAAwN4ddIfcpkMCADBSG5kpc3aSH9rzTnd/Jsk3J/nKJIfNKRcAACPVc74Ag9MhAQCYmbF1yI0MyvxYkretvqG7L0nyHUmetbcPAAAA4JClQwIAMCpV9aSqurCq3l9V99vHNk+tqq6qu+zvsdZdvqy7L89eTsbY3dcmedEGMwMAQJJkZegAwFzpkAAAzNLQHbKqjk/yiiQPnl5eleTUNdscl+R/JLl4vcfbyDllAABgZlYWfx5FAAAANqkl6JCnJ/lMd7+rqi5K8rKqukN3X7hqm+ckOSvJY9d7sI0sXwYAAAAAADA6VbWjqs5dddmxZpMTknx4ev3CJFckOXHVx98jyfcl+eWNPJ+ZMgAALNRKhj/MCQAAgM1h3h2yu3cm2bm/TXLjCS5bprft8eIkz+vui6vWz2qmDAAAAAAAwN5dkOSk6fUTkhyZ5PwkqapjkzwsyQur6pIkd05yXlXdcl8PZlAGAICF6jlfAAAAGI8l6JBvSnJiVZ2c5DFJ3pnkpKo6s7sv6+4juvuW3X1ckk8n+druvnRfD2b5MgAAAAAAgL3o7i9U1VOTnJ3k4iSPS3L3JPe8OY9nUAYAgIVacUoZAAAANmgZOmR3n5nkzFU3nZfkrL1sd5f1HmshgzKWkQBujt0rK0NHSJIctnX48etvfs9VQ0dIklx+/XLkePpL7jV0hCTJ857w/4aOkCS58zG3HTpCPn7phUNHAACApbAEfzvMz5+xHH+Ne+yx9x06QpLk/tcP3+uT5B+332LoCEmSy65djm6/0svxfQqLthyvSAAAHDKWY8gdAACAzWBsHXLL0AEAAAAAAAAOBWbKAACwUBYpAAAAYKPG1iHNlAEAAAAAAFgAM2UAAFiolWU4+y0AAACbwtg6pJkyAAAAAAAAC2CmDAAAC7UydAAAAAA2jbF1SIMyAAAs1Nh2qAEAAJifsXVIy5cBAAAAAAAswH4HZarqzht5kI1uBwAAXfO9AMPRIQEAmLWxdcj1Zsp8YoOPs9HtAAAAGC8dEgAA9mO9c8pUVX18vW2ml7UfuCPJjiSprbfMli1H3byEAACMytjWAwZuRIcEAGCmxtYh9zso0903+5wz3b0zyc4k2bb9xL65jwMAAMDmoEMCAMD+rTdTBgAAZmpsRzkBAAAwP2PrkDf7KCYAAAAAAAA2zkwZAAAWyppEAAAAbNTYOqSZMgAAAAAAAAtgpgwAAAu1UkMnAAAAYLMYW4c0UwYAAAAAAGABzJQBAGChVoYOAAAAwKYxtg5ppgwAAAAAAMACmCkDAMBCje0oJwAAAOZnbB3SoAwAAAvVQwcAAABg0xhbh1zIoEwt4kk2YGxfPBi7ZXnt2L2ye+gIufjay4eOkCS5+vrrho6QJKmvvPfQEZIkK70cx2q033BftiyvGwAAHLqqht8r/XwvR3d7x1WfHjpCkuQnb3/roSMkSS77wlVDR0iSfNUtTxg6QpLk3y85f+gIMAjnlAEAYKFWar6X9VTVk6rqwqp6f1Xdb819p1TV26rqyqr6p6q6x7w+DwAAAKxv6A45awZlAAA4ZFTV8UlekeQR07evWrPJ9iTPSXLnJJcmedZCAwIAADBqzikDAMBCDbzw3+lJPtPd76qqi5K8rKru0N0XJkl3v72qDkty3yQnJHnDgFkBAAAOecuxePzsmCkDAMCoVNWOqjp31WXHqrtPSPLh6fULk1yR5MQ1D/HDSf4tyUVJfmvugQEAADhkGJQBAGChet6X7p3dfcqqy841T796H3jL9LbVXpHkbkmuzU2XNwMAAGCB5t0hF82gDAAAh5ILkpw0vX5CkiOTnL96g+7e3d2fyGRA5vTFxgMAAGDMDMoAALBQK+m5XtbxpiQnVtXJSR6T5J1JTqqqM5Okqn67qr6zqu6Q5IlJ3jvPzwUAAAD7N3CHnLltC39GAAAYSHd/oaqemuTsJBcneVySuye553ST1yf5pST3SXJukh8YIicAAADjZFAGAICFWhn4+bv7zCRnrrrpvCRnTe87O5MBGwAAAJbA0B1y1ixfBgAAAAAAsAAbHpSpqqdX1alVtaWqzq6qL1XVk+YZDgCA8ek5X4DloEMCADALY+uQBzJT5n8kuTzJ45NsT/LDSX5tXxtX1Y6qOreqzl1ZufLgUgIAALDZ6JAAALDGgZxTppOcnuTHknxvkouyn0Gd7t6ZZGeSHLb9RActAgCQZHzrAQP7dLM75DYdEgCAqbF1yAMZlHl6kuck+YPufk9V/XCSP5hLKgAARmulhk4ALMjTo0MCAHCQxtYhD2RQ5kNJ3p7k1Kr6qxzY0mcAAAAcWnRIAABY40AGZf4qyceSvC3JdfOJAwDA2K0McipFYAA6JAAAB21sHfJABmWuS/KE7v7svMIAAAAwGjokAACscaDnlHllVf356hu7+8yZJgIAYNTGdYwTsB9Pjw4JAMBBGluHPJBBmacl+bYkd8kNU887iR1qAAAA1tIhAQBgjQMZlDk1yX26++PzCgMAwPitDB0AWBQdEgCAgza2DrnlALb930keWVXHVNWxey7zCgYAAMCmpkMCAMAaBzJTZkeS2yd56fT9ymTq+dYZZwIAYMRWRrciMLAPOiQAAAdtbB3yQAZlHjS3FAAAAIyNDgkAAGtseFCmuz81zyAAay3LGHgNHSDJJddeOXSEpbLyrrcOHSFJsqUOZBXQ+TntqLsNHSGfvPSzQ0dIklQtw08s61mW13dgvg6mQy7Lq7nXK+DmOHr7LYaOkH+5ajn+jFdL8op+ySXDf02S5KTj7jh0hCTJ1iXpsluWoL/pkJvD2PbJluMnEAAAAAAAYOQOZPkyAAA4aCtDBwAAAGDTGFuHNCgDAMBCje0kjQAAAMzP2Dqk5csAAAAAAAAWwEwZAAAWalzHOAEAADBPY+uQZsoAAAAAAAAsgJkyAAAs1NhO0ggAAMD8jK1DmikDAAAAAACwAGbKAACwUD26FYEBAACYl7F1yP0OylTVL2z0gbr7+QcfBwAAgM1KhwQAgP1bb6bMc5M8OUmts93vJbFDDQDAusa2HjBwI8+NDgkAwAyNrUOuNyjz+9195noPUlWn7eW2HUl2JMmWrbfMli1H3Zx8AAAAbB46JAAA7Md+B2W6+wc28iB72667dybZmSSHbT9xXIu+AQBws62MbD1g4AY6JAAAsza2Drll6AAAAAAAAACHgvWWLwMAgJka1zFOAAAAzNPYOqSZMgAAAAAAAAtgpgwAAAs1tvWAAQAAmJ+xdUiDMgAALNTK0AEAAADYNMbWIS1fBgAAAAAAsABmygAAsFA9sqnnAAAAzM/YOqSZMgAAAAAAAAtgpgwAAAs1tvWAAQAAmJ+xdUgzZQAAAAAAABZgITNltm7ZuoinWdeuld1DRwA2oa+7zT2GjpB/v/z8oSMkSW51+DFDR0iSnPqctw8dIUmyfetyTDj9la/63NAR8kefO2zoCGwiY1sPGABgtXsfe6ehI+TdF3986AhJkocd/7VDR0iSPOLSjwwdIUmybUn+Rvrqw7566AhJku/eMvzfOlZ6bHMwxmlsHdJMGQAAAAAAgAVYjkN8AQA4ZDgWDQAAgI0aW4c0UwYAAAAAAGABzJQBAGChVnpc6wEDAAAwP2PrkGbKAAAAAAAALICZMgAALNS4jnECAABgnsbWIc2UAQAAAAAAWACDMgAALNRKeq6X9VTVk6rqwqp6f1Xdb81996qqc6rqsqo6u6puNbdPBAAAAOsaukPOmkEZAAAWquf8b3+q6vgkr0jyiOnbV63Z5LuSvDzJ/ZN8ZZJnzPwTAAAAwIYN2SHnwTllAAA4lJye5DPd/a6quijJy6rqDt19YZJ094v2bFhVf5fkrgPlBAAAYIQ2NChTVbdIUnu5q7v76tlGAgBgzFbm/PhVtSPJjlU37ezundPrJyT58PT6hUmuSHLi9Prqx6gkD0zy5/NNC+OkQwIAMCvz7pCLttGZMh9Osis37FTvmdNzWFW9u7u/a+0HrC7D27bdKlu3Hn2wWQEAYF3TAZid+7o7N17Cd0uy1/nq353knkl+d7bp4JBxUB1yy9ZbZsuWoxYSFAAAFmmjgzLV3Xf78jtVP5DktklemORDe/uA1WX4iCPuvPiF2QAAWEpDnEhxlQuSnDS9fkKSI5Ocv3qDqjo5yauTPLa7L1loOhiPg+qQh20/UYcEACDJ4B1y5rasv0mSVUcPVtXTkzw9yR92dyd55exjAQDAXLwpyYnTgZfHJHlnkpOq6swkqaq7JXlDkmd19znDxYRNT4cEAIC9WHemTFX9YpJjq+rHktwtydck+ebuvixJuvvX5xsRAIAx6QGPcuruL1TVU5OcneTiJI9LcvdMlipLkpcnuV2Sl1XVK6cfs7fzYgD7oEMCADBLQ3bIedjITJkrMznK6YRMdqbvkuQb55gJAADmprvP7O47dPd9uvu87j6ru79+et8juru6+/DpWwMycOB0SAAA2Id1B2W6+8VJrujuZ3f36ZkcTfibVfWdc08HAMDorMz5AgxLhwQAYJbG1iEP+Jwy3f1vSR6b5LvmkggAAIDNTocEAGA0qupJVXVhVb2/qu635r57VdU5VXVZVZ1dVbfa32Ote06ZqS1V9bmb5qjvSZLuvu3G4wMAcCibnOcbGDkdEgCAmRi6Q1bV8UlekeTB08urkpy6apPvyuT8pO9K8ldJnpHkOft6vI0OynzlPm7//iT/tMHHAAAA4NCgQwIAMBanJ/lMd7+rqi5K8rKqukN3X5gk3f2iPRtW1d8luev+Hmzd5cuq6gVJ/nuSr0+ypbt3d/fuJD+f5FeSHH2z/ysAABxyVtJzvQDD0iEBAJileXfIqtpRVeeuuuxYE+GEJB+eXr8wyRVJTlybs6oqyQMzmTGzTxuZKXNJkm9KsiPJXarqL5LcIsndkzxwz2gQAAAARIcEAGAT6e6dSXbub5PceILLlmSvRwR+d5J7Jvnd/T3fuoMy3f2CPder6o5JnpzJmmgvsjMNAMCBWhk6ADBXOiQAALO0BB3ygiQnTa+fkOTIJOev3qCqTk7y6iSP7e5L9vdgGzqnzPRENr+V5A+7+5er6k+TvL6qdnf3C9f7+BOO/oqNPM3cffqyteeZPLTV0AGWyLIsdLIsX5PJTLvhbd2ydegISZITtx0zdIR8aGUJfv0kqSX5Lr3o6ouHjpAkOeqwI4aOkCT53g8fNnSEnHTsTWbtDuL63j10hCRJL81vluXk8wPjd7Ad8rhbLMcKZxdffcXQEWBT2LIkHXJl4BNB73HHbccOHSHv2HX90BGSJF/afdXQEZIkX7r68qEjJEmefodvHjpCkmTH5R8YOkKS5Njttxg6wtL8DYz9W4IO+aYkvzMdeHlwkncmOamqXtjdT6yquyV5Q5Jndfc56z3YRs4pc/ck785kzbQ3VtWWTE7O+LAkP1dV97jZ/xUAAABGRYcEAGBMuvsLSZ6a5Ozp26ckuU0mS5UlycuT3C7Jy6qqq2q/o0gbmSnz8SQP6e6P7Lmhqr4uk9GgVyT59iT/foD/DwAADlErwx/lBMyXDgkAwMwsQ4fs7jOTnLnqpvOSnDW97xEH8lgbGZR5bpLDq+qIJHsuJyb5qSTf2d27DuQJAQAAGLXnRocEAIC92sigzMVJrktydZJrpm//OJMjnO6d5L1zSwcAwOj0kqz3DsyNDgkAwMyMrUOuOyjT3b+xt9ur6pnZwDlpAAAAOHTokAAAsG8bmSmzV939Z7MMAgDAoWFl6ADAIHRIAABujrF1SEcpAQAAAAAALMDNnikDAAA3R2dc6wEDAAAwP2PrkGbKAAAAAAAALMABzZSpqtt29+fmFQYAgPFbGdlRTsC+6ZAAAByssXXIdWfK1MSbqurBSV5UVYcvIBcAAACbkA4JAAD7tu6gTHd3km9I8sEkW5OcmiRVdXhV/UtVbd/bx1XVjqo6t6rOveyaL8wyMwAAm1h3z/UCDGsWHfKa6y5ZWF4AAJbb2DrkRs8pc2mSr03ytO5+6/S2+ye5S3dft7cP6O6d3X1Kd59y7BG3OfikAAAAbBYH1SGP2H7cYlICAMCCbXRQ5gtJfj3JUatue1aSP5x5IgAARm0lPdcLsBR0SAAAZmJsHXLbBre7KJOd57dW1fuS3CPJVUn++7yCAQAwTm3gBA4FOiQAADMxtg650UGZzyb5fJL7JjktyZVJ/qm7r51TLgAAADYvHRIAAPbiQGbK3Lm7r0xy9hzzAAAwcisDnEgRWDgdEgCAmRhbhzyQc8rceZ5BAAAAGA0dEgAA9mKjM2VePdcUAAAcMsZ1jBOwDzokAAAzMbYOuaFBme7+wryDAAAAMA46JAAA7N1GZ8oAAMBMrIzuOCcAAADmZWwdcqPnlAEAAAAAAOAgmCkDAMBCje0oJwAAAOZnbB1yIYMy22rrIp5mXVu3LMfEoJWVlaEjJEn+920fMnSE/PTFbx86QpLk6uuvHTpCkmTrluX4WbnncXccOkKS5IKrvzh0hCTJP1zy4aEjLI2Lrr546AhJkiuvu2boCEmSw7cdNnSEJMnbPvfBoSPkjsfcZugISZLdvRy/Y5clB8BmdZejbjd0hCTJdbt3DR0hSXLV0uz7bB86QpLk2l3XDR1hZH8aOnhVNXSEJEn1cnxl3nzxB4aOkG1bl+M47N1L8jXpJcnxh5eeN3SEJMnl1109dIQkybd+xX2GjpALr7906AhJxjfowP4txys0AACHjGUpxQAAACy/sXXI5Zg6AgAAAAAAMHJmygAAsFCm5gMAALBRY+uQZsoAAAAAAAAsgJkyAAAsVI/sKCcAAADmZ2wd0qAMAAALNbaTNAIAADA/Y+uQli8DAAAAAABYADNlAABYqLGdpBEAAID5GVuHNFMGAAAAAABgAcyUAQBgoca2HjAAAADzM7YOaaYMAAAAAADAAtysQZmq+q6q+o2qeuR+ttlRVedW1bmXXvP5m58QAIBRWUnP9QIsnwPtkJ+/6sJFxgMAYImNrUOuOyhTE99XVTV9/z8neUGSi5K8uKq+b28f1907u/uU7j7llkccP8vMAAAALKlZdMjjj7zD4gIDAMACbWSmTCV5dZLfmL7/A0l+KskLk7w2yU/PJxoAAGPUc/63nqp6UlVdWFXvr6r7rbnvyKp6dVVdWVVPntfnAEZOhwQAYGaG7pCztu6gTHevJPlckq+tquckuXWStyf52ST3SOIQJgAANoWqOj7JK5I8Yvr2VXvZ7F+SfHGRuWBMdEgAANi3bRvcbiXJY5O8Ncntktwmyf2T/GiSN88lGQAAo7TSg5735fQkn+nud1XVRUleVlV36O4Lk6S7r0ry21X1lCFDwgjokAAAzMTAHXLmNrJ8WZJcn+TaTI4ovC7JE5P8eZL3Jvm/84kGAAAHbvXJwqeXHavuPiHJh6fXL0xyRZITFx4Sxk+HBACAvdjoTJm/TnJEd3+qqv5Tkr9L8qgk9+7ui+eWDgCA0Zn3mr3dvTPJzn0+/Y0PTNoyvQ2YLR0SAICZGOK8L/O0oZky3f0T3f2l6fV/S/KEJN9iZxoAgE3mgiQnTa+fkOTIJOcPFwfGSYcEAIC92+hMmSRJVd0iydHd/YYkb5hPJAAAxmzg9YDflOR3qurkJA9O8s4kJ1XVC7v7iVW1JZMDlyrJ1qra1t27BswLm5oOCQDAwTpUzymzx08l+fk971TVT1XVv1bV4bONBQDAWPWc/+33ubu/kOSpSc6evn1KJicgv+d0kydmci6Mk5O8KslH5/V5gEOEDgkAwEEZskPOw4ZnylTV8Ul+NJOCmunRhc9L8p+6+9r5xAMAgNnq7jOTnLnqpvOSnDW974wkZyw+FYyPDgkAADd1IDNlrkjy+CQ/WFVfSvLPSXYl+euqeso8wgEAMD4r3XO9AEtDhwQA4KCNrUMeyDllHprklklemOQFmexQPyzJfZP8bibLO+zVBVd+8SAizs7KysrQEZbKC6/94NAR8g23Pmn9jRbg3Es+NnSEJMmfHnny0BGSJC867NKhIyRJLr7u8qEjJEkuvOJLQ0dgSV236/qhIyTJABNtb+r8K5bjd31VDR0BgBvc7A75ni9+fBH51tVLMtC7HCmSLUvye/aEY75i6Ai54PLl2Pc55fjl6NS33XrU0BGSJH//peH/zpEkV1x3zdARsm3L1qEjJEmO23qLoSMkSQ7ftn3oCEmSex114tARkiRvu/pDQ0dIkvzNRe8eOgIMYkODMlX1X5LcL8nduvuPprd9Kskjk1ybxF8sAQDYkCHW7AUWS4cEAGBWxtYhNzpT5rgkpyY5raouy+RIp59N8sokRyV5+jzCAQAAsCkdFx0SAABuYkODMt39qqp6dZILknwsyTuS/O8kD+/u5Vi7BQCATcF5X2D8dEgAAGZlbB1yywFse1iSa7r7xUlOTvLwJN87l1QAAABsdjokAACssdHly5LJur/3TJLu/kxVfVN3XzefWAAAjNXY1gMG9kmHBADgoI2tQ254UKa7O8k1q963Mw0AAMBe6ZAAAHBTBzJTBgAADlr3ytARAAAA2CTG1iEP5JwyAAAAAAAA3ExmygAAsFArI1sPGAAAgPkZW4e82TNlqupWVXXiLMMAAAAwTjokAAAc3EyZP05yzyR3nVEWAAAOAZNzfwOHIB0SAIADNrYOeTCDMt+f5Bb7urOqdiTZkSTbD/uKHLbtmIN4KgAAxmJsU8+BDdtwh9y69bhs2XrUonIBALDExtYhb/agTHd/cZ37dybZmSRHH3nXcX3WAAAAOCAH0iG3H35HHRIAgFE6mJkyAABwwMY29RwAAID5GVuH3DJ0AAAAAAAAgEOBmTIAACzUysiOcgIAAGB+xtYhzZQBAAAAAABYADNlAABYqM64jnICAABgfsbWIc2UAQAAAAAAWAAzZQAAWKge2XrAAAAAzM/YOqSZMgAAAAAAAAtgpgwAAAu1MrL1gAEAAJifsXVIM2UAAAAAAAAWYCEzZbZvXY4JOccdcdTQEZIkR249YugISZKrdl8zdIRcuXLd0BGSJE+/9QOHjpAk+elrPz50hCTJJVdeMXSEJMl1K7uGjpAkSzEWf9T25XjduPr6a4eOMLEka4lW1dARkoxvbdWDsaUcb7IZ+J4F1nOrI44eOkKS5OJrlmO/eOuS/H5bln3Ba3dfP3SEHHP4kUNHSJK89+JPDh0hSbK7V4aOkCTZsiz750vQIk+7zX2GjpAkuWT31UNHSJLc9sjjho6QJDlh63L8ftu9snvoCEmS7dsOGzpCtm9Zjr9bs39j65DLsWcHAAAAAAAwcoYCAQBYqJWRHeUEAADA/IytQxqUAQBgocY29RwAAID5GVuHtHwZAAAAAADAApgpAwDAQq0swclvAQAA2BzG1iHNlAEAAAAAAFgAM2UAAFiosa0HDAAAwPyMrUOaKQMAAAAAALAAZsoAALBQKyM7ygkAAID5GVuHNFMGAAAAAABgAfY7U6aqfm+Dj9Pd/YMzyAMAwMh1xnWUE3ADHRIAgFkbW4dcb/myJyc5LUntZ5tK8uYkN9qhrqodSXYkyZGHH5/DD7vlzQ4JAADApvDkzKBDHnPE7XKL7cfNJSAAAAxpvUGZ53X3/1vvQarq+Wtv6+6dSXYmya2Puce4hrIAALjZxrYeMHAjM+mQt7vlvbxQAACQZHwdcr1zypxRVXfZ805VfWdV/VFVvbiqjtlze3c/b14BAQAA2DR0SAAA2I/1BmV+M8nDk6SqHpDkdUmuSnL/JL8912QAAIxSd8/1AgxKhwQAYKbG1iHXW77sW5I8aXr9V5L8fXc/papOTPK+uSYDAABgs9EhAQBgP9YblLkwyaOr6uok35nkm6a33zLJJXPMBQDASHXMZoER0yEBAJipsXXI9QZlnpHkT5McneTXuvvt09t/KcmfzTMYAADjZIkxGDUdEgCAmRpbh9zvoEx3v7GqbpPkyO6+dNVdP5/kU3NNBgAAwKaiQwIAwP6tN1MmSTrJt1fVfZLsTvKBJK/v7t1zTQYAwCiN7Sgn4CZ0SAAAZmZsHXLL/u6sqrsm+UiSlyR5QJIHJvnNJB+sqjvPPx4AAACbhQ4JAAD7t95Mmd9K8tokP9fdK0lSVVuTvCDJK5I8cr7xAAAYm3Ed4wSsoUMCADBTY+uQ6w3KPCjJ4/fsTCdJd++uql9N8om5JgMAAGCz0SEBAGA/1huU+Y8k35DkjWtu/4Ykn9nok3zp8n+vA8wFh6RfGDoAACzAruvOt28I4zWTDnnRpR/yOgEAc/IHQweAAzS2DrneoMwvJvk/VfWqJP+apJKcmuTJSZ4w32gAAABsMjokAADsR3Xvf0W2qvqGJD+R5N5JVpJ8MMn/6u53zj8eAAAAm4kOCQAA+7buoAwAAAAAAAAHb8v+7qyqj6+6/sQ19103r1AAAABsPjokAADs335nylTVSndvmV7f3d1b93YfAAAA6JAAALB/6+0Qrx6xqf3cBwAAADokAADsx7Z17q+qOmvVO2ftb2MAAAAOaTokAADsx3qDMs9bdf09a+5b+z4AAACHNh0SAAD2Y71zyty5uz+97oNscDsAAADGS4cEAID9W29Q5kYnZjzY7QAAABgvHRIAAPZvI+eU+XgmJ2jc1+hN5aYncAQAAODQo0MCAMB+7HemDAAAAAAAALOxZegAAAAAAAAAhwKDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFsCgDAAAAAAAwAIYlAEAAAAAAFgAgzIAAAAAAAALYFAGAAAAAABgAQzKAAAAAAAALIBBGQAAAAAAgAUwKAMAAAAAALAABmUAAAAAAAAWwKAMAAAAAADAAhiUAQAAAAAAWACDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFsCgDAAAAAAAwAIYlAEAAAAAAFgAgzIAAAAAAAALYFAGAAAAAABgAQzKAAAAAAAALIBBGQAAAAAAgAUwKAMAAAAAALAABmUAAAAAAAAWwKAMAAAAAADAAhiUAQAAAAAAWACDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFsCgDAAAAAAAwAIYlAEAAAAAAFgAgzIAAAAAAAALMMigTFX19HKXqnruqve/VFW/U1Xbp9ttrapfrKpPVtVFVfXKqjpq1eM8s6o+O728vKqOqqq/nz7Wk4f4v41dVW0bOsOyqarvqKoTp9ePqarTF/CcP1hV37uf+w24TlXV1w35+aiq21XVqUM9/7JZ/fo/dJahVdUZ08/Fcxf0fLWR25if/ez/dFV9ctV2j6mq91XVpVX1xqq626r7vrOqPji97/VVdddVj3XGEP8vgEXRIzcnHfKmdMjlpkMuFx3yBjrkoUeHHK+hfsl8qruruz85ff91SbYl+fYkj0+yZ4fkmUm+L8kjk3xdkq9KsjNJqurrkzw/ycOTnJzkwiS7uvu0JM+7OaGm3+BXVdWH9nG5rKpOW7X9J6vqjlV1WlX93c15zmVWVU+pqmetev+bk7xxzTavr6pvq6o3VNW2aQH6uqp66LTgfOsMchxeVR+tqsNW3bZr1fVnTsvWJVX1kqo6v6reXVVXVNV7py86pxxsjv14eZKt0+uPyOR7eG6q6tuSvCLJC6b/z/dW1a+v2ex10+/Lp1XVnarqQzPOMPjXpKoeuPrnc819L6iqp03ffU6SZ1fVs6c/s6sv18z5eyNJfiDJE+f8HDeyl1/UXVXfuOr+e1XVOdPXtLOr6lYLjLf29f+Q1d1PzuT7Y+6q6hlJfmn6On2PVXc9q6peuJftf2ZRO/qHmJvs/0zfr+6+S5JU1TckOTPJ/5fkrknek+TNVbW9Jn9sfG2Sl0zve2OS6u7nJnnIQv8nAMNYuh6pQ96YDrlhOmR0yP3QIW9Mh5zSIQ9JOuRILdMRK5Xk8CQrST46ve0nk/xod78/SarqR5J8ZPrCcPvpNpd39wVJfmVGOd4x3SFPVX1Nktt3999O33/NjJ5jU6mq/57kGUmOSHJ8VX00ydVJXpPkQUlOSnKHJOcm+Yskn0pyxyRHJzlsb495gE5Ncuck762qlSSnTXNVT7yoqi5Mct/uflZVPbK7719Vf5/kPyU5YwYZbqImRzb9TZK7JXlDVb00k3L30LphtHpHd79pRs+3LcnPJvmhJOdn8n/bneScJGev2u7UJPdP8uEkfzq9zNoyfE2OTPLP3f3k6c7xTyX5tul9905yTVVdneSHkzy+u38ja14npnlmrqoek+Q3M3ldu22SS6rq0Ws2e0Z3v3Yezz/95frcaZbHJnlakn9atcl3ZVIE35XkrzL5+X7OPLKwNK7L5HfsVyU5p6oe0N0XZfKz8rbp68snV21/TCY/0k9Zdds9u/vKRQU+hP1kkt/t7rOTpKp+Lsnjkjwqyd9m8rW5qru/lOS3BksJsDyWoUfqkGvokHunQw7+NdEh90GHZC90yM1Dh9yElmV66qOSXJ/k7Un+MslHq+q4THaY/3XPRt390SSXJrlXJjsyb0/y/qr67aq6fWbvQUm+Ze2NVfWWqrrnHJ5vaVTVM5P8WiZHmT0ukx2Ra5J8Y5L/SPJzmexg/36SFyf5YJKfSfK2OcQ5bfp8J2fyPfGF6e1/WrXXaZPHVNU/T7c/J8lD55ApmZSFz3b3YZl8Dk7P5JfT8dPR6tcn6Rk+35FJvjKTndmnZfLC+pYkz+/uNyeTqe+Z7Ky+NpOjrY5K8v4k96gblmg4ai+PfaBOy/J9Tf4hyauml/dk8vrwkSSv7e7fqKq3V9W5ey5zeP4v6+6zuvuOSX45k6MYjs/0a9fdd5xe5rIzvVpNjkJ7cSZ/lPjy92J3v6i7/7y7P57k7zI5WmK0anIE64VV9byq+nxNjsp8RFV9pKo+VVX3q6rvqaoLpj8jzxg68xxcneSI7v5wkt/LDTti98nkNSLT++84/d79rSTPXvX+rkwK4txMj+J5aVW9eroPcCh41KojEZ88ve3eufG+z+4k/5bkPt19SSa/m/+wqv66qk5edGCAJbOMPVKH1CH3R4dcrq+JDrmGDjmhQybRIZeVDjkSyzJT5nVJHp3kq5O8NMnPJ9kzlXbtD/CWJLu7+5qq+o4k35/k2UnOm47ann+wYarqzCQPTHK7TI6U+J5MXnCunm6yfVWuczPZefnmqvqP6W1fOx193LSmR6lcnOQ2yf/P3n2HWXrXdeN/f3Y3hRSaQCABBKQLEmJAEfVBVKQoiBWQB1BxFQuiwO+xC9iQZgEfIIJExA6oYMBG8RERMUjvUkIJHZKQnt35/P64z5LZzezO2cxpc+/rdV3nmplzzsx5z8yZmfs933LnmUkenmEE/ENJTs5wMH1ekutnODg6Kcl3Tt59ZgcrVXVskkcleWmGg/kPdPfa5Jjt2CS7q+pzGZ4Dx1fVOzPMevvaec9y2sBRGWa23D7J25JcM8mFs/rg3X1BVf1Uhq/3o5N8IckXk/zY5Ov0rxm2blibXH+DDL+YL0nyuu6+7SxyrNj35Dur6h1JTsnweX5jd/9sDUs3P5bkoxmem0ly3X1fg1q37+a8VNVtM2yBsW8v4Osk+bckt5z3Y69z3yQf6e53b3TjpPzcNclLFphpWW6Y4Wfmbhl+n+/NUAxflOTHMzyXn5LknzLMIhmbSzP8fCbDP0juXVU3yVCm/muD+98lyTsWlG2f+2b43nw4w9+c31vw4y/D33X3dx5w3VoOcuyTJN39C1X1iiS/kuQ/q+oB3f2KuScFWE0r0yN1SB3yatIhdcgv0SFXjg6pQ64iHXIkVmWlTCbLVd+RYYbTPbr7giTn5so/RpnMLDoxw5LadPdad/9Jkjtm+EX5HTPK8rAMByIfyzCT6g7d/d0HufvpGQ4s/m3d7IVtfTCdfOkkfzfIsJT3B5JclOR7uvviJN+XYUbaqzMcMF6c4Qf9wszwYHri/hmWx94nybcm+X/rbntUkl/NcND0oiSvyjDz5+NV9ZYkX5vkjRkOYC7JfNxtckD3G0n+M8Py3j+dHHTO9IC6qm6f4XP81gyj3L+QYT/s/53hD+WvZvh8nz55l7tn+EP5ruw/y+lxW4yySt+Tv+3uO2RYiv++DMX2vge578nrZjidPIPHPqgalv//W4bfYdetYbuG/0ry5TXso/zeeT7+Og/MAXt4H+D+SW6T5PmLibN0Z05myr43yUsmW5a8LsPz4a+T/ESG3+lznQW3JJfkygPqy7v7bzIctP5Nd1+2/o6TmTM3S3LHGrZ0WJSjk3xucjl6gY+7at6d/Y99dmWYIfqufdd19+u6+14Z9g1e6H7jAKtmVXqkDqlDHgYdUoe8Ch1yZemQAx1ytemQ29CqrJTZN9p+aoblsvtGXH8nyW9W1buSXJDhxHR/0t2fqaqHZTiI/t0Msweum+GP16yyPDrDL91/TvI3VfUDs/jY28iTk3xPhgPE/5eh5PxiVd0yw4FLMswQuE+Gk2Z+VZIPTt7nxTPM8eIMsw6emuFg7e77bujuj9dwwsL3JrlVkhO7+5OZ7Ak7OdD99p7vyeD+o7u/ZbJk8Ibd/dYaTtj52AzFb2YH1BlK3jUzzGS6T4Y9mDuTk5NO7vOl7Re6++uTpKqulxnOcsqKfk+6e29VPSrJI7Lx1/3c7j59kmPmj3+A22f4/fV93f3mJLecfB/e0N2LnOV0WoYZpFcxOWh6QZLvnixnPZJcfsDr1d1PqqqXZ3hePyjDjJsxuSTJHarqrCRvqmF/+8dm2Mv8SzNqquqrMuwh/pgMZeN1VXX+gjK+PMNz8vgkP7ygx1xFv5fk1VX1ygx/g38+yWVJXj75x8qvZ9i/+7wMxeety4kJsBpWpUfqkEl0yGnpkCvyPdEhN6RDbkyH1CFXmQ65Da3KSpkHZFhq9aoMB2X7Thb2jAwzJV6ZYW+892X4A54My2xvnuGJ9C9J/m+GH8ZZ+JnJx/7B7v7TJM/JsDRxU1V1u6p6wIxyLNP/SfKbSd7e3e+ZHIydluSC7r7tuoOzz2T4Xnwqw6yndPeZ3f3rswgxmcV2XoYDtJ0ZStX629/d3WsZln3ftap2V9V7quo9GU4e+arJ2/ebRZ4p/UqGE+CdnOEX3kz0sH/rHTIs3T4vwxLNt2XYH/sB3X2H7p7HCRkPzLFK35N9S8+vPXnss7v7Jw9y34XNcuruP07yZ/N8jCndJMmnk6SqvrGGbTVSVbdI8ookP9fdr1livlVRNZwA+JMZ/kHwdUvOM1M1bJ/y7AwzgZ+TYT/gl2fYK/qWmZzQc+JRSX66u8/q7vOT3C/DjNe56+5LuvtB3f0d3f3pRTzmCli/H/CeJOnuNyZ5aJLfzrAM/w5JvqW7r8hwEuQPZTgx77sy/A1+4jKCA6yIVeqROqQOuRU6pA6pQ24vOuSVdMjF0iFHYukrZbr7Cdn/h3n9bWsZltY+aYPbzskwo2bWvjrJCZPXX1P7n2/uFhlOAJckd85w0rxfz/CkPmGyXPuuGWajbDizYBaq6tYZDl7v191zGd3s7q7a8GR7B42V4WvzlnXX7ZxFlqq6T4YD/GdkGHH/7SS/VVUnZFgS//NJfiTD1/y/+8o9Xxcxy+nrJgeKJ+TKvSv3Tt4+qru/MKsHqqrrZlga+0NJfjTDc+3SDAfWr62qv8iwd/Pcrcj35ENJHtbdL9vgtqNzwAkyu/uaG30qM8ixyk7IMDsiGfb23ndy2Wdl2Cf5mVX13CTp7rF/LQ6lMszKe0uG583YTtL4Pxn+afXuDH9PX5Tkyd39W1X1ggyzij+YJN39qPXv2N0fmfx8/2Rme9LZI94mxz9/m2F28YHXX5Rhdtpj55cMYHtYsR6pQ0aHPAw6pA65ynTI6eiQOuTC6ZDjsvRBmRX0pu6+x0Y3TJbq3SnDAfOPJvmLDDOsXpNhJPjTGZb3PWieAbv7fVX1z0muMa/HqKp7Z1h6+Liqek6G5c5J8tka9jZNkhdNll3fIcMv2nv2cLK+XRlKxlqGE/VtJcdDMozEf093/2tV/V2Sn8qwtPcnMpSa30xyi0kJeGFV3XXdh/iHSS94RXfP+o/kZUme390/dcD1r8xQvmZ9cHtahpNi3rWHrRfumiTd/cqqOjXDQezNZvyYV7Eq35NJoT7ngGzfmeEg/+JsskdmVf1GhqX6Wzqp62aq6reSfG+GgnnjdT8/j5v80Zyb7j5q3esvzbB3ebp7bMuqD2lS4Grd26eve339jMxRHqT0sP3Bvm1VPprhd8i+PfXPrar7Zzix61VU1WMz/L17W4afKwDgqnTI6JBT0iF1yE3pkMunQ+qQMG/VvfhBy6ra96A3n/UMlKp6bZL/lWHZ+Jmz/NiTj39MhhNcLW20t6q+P8k9k/zYMnMcSlXVLLJNDs5PnOVsoSPN5I/ozu7es+mdp/t4vidcbfP8/b/dVNWZGU6U+MTJjBdGbl7P/6p6QoYT5P5xdz9iVh8XYNVs1x6pQ05Hh1wdOiSrRIe8kg555NEhx2spgzJsTVUdNdkXEAAAAA5JhwQAWB0GZQAAAAAAABZgx7IDAAAAAAAAHAm2zaBMVe1edoZEjgOtQo5VyJDIcSA5VitDIseB5NjfKuRYhQyJHABjsSq/R+XY3yrkWIUMiRwHkmN/q5BjFTIkchxIjtXKkMjB4ds2gzJJVuVJJcf+ViHHKmRI5DiQHFdahQyJHAeSY3+rkGMVMiRyAIzFqvwelWN/q5BjFTIkchxIjv2tQo5VyJDIcSA5rrQKGRI5OEzbaVAGAAAAAABg26runvuD7Dr6lC0/yNraRdmx4/gtfYxLzv23rcbI817453nkwx68pY9xnZt+85ZzXLHnizlq14lb+hiX7rl8yzlm8X0ZQwY55Fj1DHLIsR1yrEKGseXYc/nHa0ZxZuqKz35wrgegR13vFiv5eQPT0yH3d+2b3nPLOfbs+WJ2bbFDXrbnii3nWIW/s6uQQQ45tkOOVcgghxyrnmFsOXTIxdg2gzKzMIsD6lmYxaDMLMxiUAYAWF0OqIHtSofc3ywGZWZhFoMyAMDq0iEXY9ciHwwAALK2d9kJAAAA2C5G1iGdUwYAAAAAAGABrJQBAGCxem3ZCQAAANguRtYhrZQBAAAAAABYACtlAABYrLVxzXICAABgjkbWIQ3KAACwUD2ypecAAADMz9g6pO3LAAAAAAAAFsBKGQAAFmtkS88BAACYo5F1SCtlAAAAAAAAFsBKGQAAFmtk+wEDAAAwRyPrkFdrpUxV7ZziPrur6uyqOntt7aKr8zAAAACMgA4JAACDwxqUqapTq+q1SS6qqvOr6q+q6uSN7tvdZ3T36d19+o4dx88iKwAAY7C2d74XYGXokAAAbNnIOuTUgzJVdbMkZyV5bpKTktwpyXlJ/rGqjplHOAAAALYnHRIAAK7qcFbKPD7Jr3b3n3f3+d394e7eneSTSR4yn3gAAIxOr833AqwKHRIAgK0bWYc8nEGZ05KcVlUPPGC5+ZlJ7jzTVAAAAGx3OiQAABxg12Hc9/NJrpnkx5I8v6relORpSV6W5C/nkA0AgDFas5oFjhA6JAAAWzeyDnk4K2Vel+Tj3f1tSW6Q5NkZDqh/u7v3zCMcAAAA25YOCQAABziclTK/l+RtVfX+7n5ekpdOTs74+0l+fC7pAAAYnXbeFzhS6JAAAGzZ2Drk1IMy3X1xVX1zkjOr6leSXJDkpkl+dl7hAAAA2J50SAAAuKrDWSmT7j4nyTdV1UlJbpLkfd19wVySAQAwTiPbDxg4OB0SAIAtG1mHPKxBmSSpqlcmeUB3f2oOeQAAGLuRLT0HDk2HBABgS0bWIXdsdocaPKqqanLVyUmOmty2q6oeO8+AAAAAbB86JAAAHNw0K2V2Jnlmkq9I8rgk5yU5NslFSY5J8mtJnj6nfDN1jZO/YdkRVsq/XOfrlh0hJ13zomVHSJKc9rF3LjtCkuSKvXuWHQEA5m9t77ITAPM1mg553Ip0yJ07di47QpLkvEefvuwISZLv/svLlx0hH7v888uOkCR57xc+tuwIADB/I+uQm66U6e49ST6d5K5V9SMZDqi/d3LzqUk+Oq9wAAAAbC86JAAAHNy055S5JMmDkrw2yVqS21bVrZN8c5LnzycaAACjNLL9gIEN6ZAAAMzGyDrktIMyFye5PMl3Jfn3JD+VYZXN65O8ZD7RAAAA2KZ0SAAA2MC0gzK/kOTS7n5HVT01yfW6+xlzzAUAwFitjWuWE7AhHRIAgNkYWYfc9JwySdLdL+/uCydvvifJNecXCQAAgO1MhwQAgI1Nu1LmS7r7xUlePIcsAAAcCUa2HzBwaDokAABbMrIOOdVKGQAAAAAAALbmsFfKAADAloxsP2AAAADmaGQd0koZAAAAAACABdjSSpmqumOSa3T3G2eUBwCAkeveu+wIwJLokAAAHK6xdcitrpR5RZIfrapnzyIMAAAAo6ZDAgBwRNvqOWXu2d3vr6rvq6qdvW7Iqqp2J9mdJLXzWtmx4/gtPhQAAKPQ49oPGDgsOiQAAIdnZB1yS4My3f3+ycu/2uC2M5KckSS7jj6lt/I4AACMyMhO0ghMT4cEAOCwjaxDbnX7MgAAAAAAAKaw1e3LAADg8Ixs6TkAAABzNLIOaaUMAAAAAADAAlgpAwDAYq3t3fw+AAAAkIyuQ1opAwAAAAAAsABWygAAsFgj2w8YAACAORpZh7RSBgAAAAAAYAGslAEAYLHWxjXLCQAAgDkaWYe0UgYAAAAAAGABrJQBAGCxRrYfMAAAAHM0sg5pUGYJatkBJj6285hlR8itrve5ZUdIkhx17s5lR0iSXLF3z7IjAAAAE73sABNrK/KPiB0n32DZEZIke/qcZUfIF6+4eNkRAIBtyqAMAACLNbL9gAEAAJijkXVI55QBAAAAAABYACtlAABYrJHNcgIAAGCORtYhDcoAALBQ3XuXHQEAAIBtYmwd0vZlAAAAAAAAC2ClDAAAizWypecAAADM0cg6pJUyAAAAAAAAC2ClDAAAi9XjmuUEAADAHI2sQ1opAwAAAAAAsABWygAAsFgj2w8YAACAORpZh9x0UKaqTk7yLRvc9J7ufuPsIwEAALBd6ZAAAHBw06yUuWOS/53k5euuqyRnJrn9wd6pqnYn2Z0ktfNa2bHj+KufEgCA8RjZfsDAVeiQAADMzsg65LTbl52U5NTJ6zV5+faq+qPJ6z/c3b3+Hbr7jCRnJMmuo0/Z7zYAAABGTYcEAIANTDMo8x9JXpfk+Ul+IskrkhyfZGeSU5KcdeDBNAAAHNTI9gMGrkKHBABgdkbWITcdlOnuC6rq2zMcVH9bks8kOSHJRUnu0t1Pmm9EAAAAtgsdEgAADm7TQZmqul+So5LcZPLyc5PLNZPctap2dfeeuaYEAGA8RrYfMLA/HRIAgJkaWYfccagbq2pHknsl2ZPknzIcSO9Kcp8k35jk2CR3nnNGAAAAtgEdEgAADu2QK2W6e62q3pfkbklekOQpST6Q5N8nd7lFkhPnmhAAgHEZ2X7AwJV0SAAAZm5kHfKQgzJVVUluleQJSZ6Y5C+SfCzJf++7S5K7JHn1/CICADAqIzugBq6kQwIAMHMj65CbrZTpqnppkjslOTXJk5M8PMmLMxxMd5L3zTkjAAAA24AOCQAAh3bIQZmJ701y/Lq335HkoRkOqHcm+eokXzn7aAAAjNLITtIIXIUOCQDA7IysQ04zKPPSJF93wHXd3b+ZJFX13pmnAgAAYLvSIQEA4CCmGZQ5P8MewMmw1HzfkvN9bj/rUAAAjNjI9gMGrkKHBABgdkbWIacZlHlLkvsleX2SByQ5O8n3VtX3JPmf7v7Z+cUbp978LgvxpCves+wI+e6ff9CyIyRJrv2IP152hCTJJVdctuwISVbnOQoAwLb0luiQo/S43z9/2RGSJHffdf1lR8ijjll+hiR58IWvXXaEJDokAByOaQZlKskDk/z75PXbJvm7JK9J8ofziwYAwCiNbD9g4Cp0SAAAZmdkHXKaQZmXJblFkt9IcsMke5J8Psn9k1xcVS/r7vvPLyIAAADbiA4JAAAHMc2gzNMzHFA/P8k9k1yc5E1J/nVye80nGgAAozSy/YCBq9AhAQCYnZF1yGkGZR6T5HpJbpPkc0kuTPKjGZajp7vvNa9wAAAAbDuPiQ4JAAAb2nRQprvvX1W3TnLvJB9O8uokvzvfWAAAjNbI9gMG9qdDAgAwUyPrkNOslEl3vy/J+9ZddeF84gAAALDd6ZAAALCxqQZlAABgZka2HzAAAABzNLIOuWPZAQAAAAAAAI4EVsoAALBYI5vlBAAAwByNrENaKQMAwGJ1z/eyiap6eFV9oqreWVV3OuC2HVX1h1X1xap6S1Xdbm5fBwAAADa35A6ZzLZHbjooU1WnHXC53eT6+0xePm2q1AAAsGRVdf0kz05y38nL5x1wl29J8k1J7pDkP5P80kIDwgjokAAAjMmse+Q0K2VeleTnk/zT5OWfTq5/+uTlfQ8SdHdVnV1VZ6+tXTTFwwAAcERYW5vv5dDuleSj3f3mJC9NcnpV3Wjd7Zcl+UKSjyT5xySXzuNLACOnQwIAMDvL7ZDJjHvkNIMyH0nyiCQfnLw8uqpumuSoycva6J26+4zuPr27T9+x4/gpHgYAALZu/T92J5fd624+Ocl7J69/IsmFSU5Zd/u/J/lckj9K8gNJnrKIzDAyOiQAANvGJh0ymXGP3DVFplskeXmSWyf5+yRfkeSsJDeZvJxu0zUAAEjmfpLG7j4jyRkHuzn7T0zakf2PZ78ywz+M35jkF5PcLVcefAPT0SEBAJid5XbIZMY9cpqVMu/v7nsmeVd3f1OSd3f3HZN8cPJyw1lOAACwgs7N8I/iZJjtdFySj6+7/dFJXtDdz84ww+mXFxsPRkGHBABgTGbaI6cZlLlBVb0ryU0nLz83ud6BNAAAh6/X5ns5tH9KckpVnZbku5L8V5JbV9ULJ7dXkgdU1Q2T/K9Md7wM7E+HBABgdpbbIZMZ98hpti/78+5+fJJU1UMnAZLkGZMQb5wmNQAALFt3f7aqHpVhC6UvJHlQklsmuc3kLr+U5I8znAvjQxnOhwEcHh0SAIDRmHWPnGZQ5oer6orJ6w9J8k1V9akkX5Pkdt398MP9JAAAOILNeT/gzXT3C5O8cN1Vb0vy0slt5yb51mXkghHRIQEAmJ0ld8hktj1ymu0YLk/yjiTvTHJxkg9MXn9RkgdM+0AAAAAcEXRIAAA4iGlWyjytu/8sSarq0iT/muS2ST6R5Iyq+snuftYcMwIAMCbdy04AzJcOCQDA7IysQ04zKHNGVV138vprJi9vnuRJ3X3PqvpQEgfUAAAAJDokAAAc1DSDMv+Q5LIDruskL5+8XjNNBADAuK3AfsDAXOmQAADMzsg65DSDMpXkRzPsBfyZ7v7SwXVV7cx056UBAIDByA6ogavQIQEAmJ2RdchpBmXekOR3kxyT5Muq6sQk70nynCQXJnn73NIxV+d88VPLjpA7/NCfLTtCkuS9z/zOZUdIktz+0S9bdoQkyUe/+NllR0iS7Nqxc9kRkiR71vYuOwIAwHaiQ87Y2orso/5Hn3zDsiMkSU485hrLjpCPvORnlh0hSXKj73vbsiMkSc698PPLjgAA28amgzLd/TNV9Ygklyd5X4YD6NOT3C3Jg5M8fp4BAQAYmR7XLCdgfzokAAAzNbIOOc1KmST56SRnZViCfqsk/5zkTknO7O5XzykbAAAA25MOCQAAGzjkoExV3SvJA5OclOSlSd6R5AeS3CjDPsF3r6o/7u4vzDsoAADj0GursQ0PMHs6JAAAsza2DrnZCRbfkeT1Sf4sybOS/GmSjyT5jiSnJXlbkn+uquPmGRIAAIBtQYcEAIBDOORKme4+N8mfTC6pqjsneWiS4yYzm36tql7X3RfPPSkAAOOwNq79gIEr6ZAAAMzcyDrktOeUSZJ095uTvPmA614z00QAAACMgg4JAAD7O6xBGQAA2LIe1ywnAAAA5mhkHXKzc8oAAAAAAAAwA1bKAACwWGu97AQAAABsFyPrkIe9Uqaqds4jCAAAAOOjQwIAwJWmHpSpqlOr6rVJLqqq86vqr6rq5PlFAwBglNbW5nsBVoIOCQDATIysQ041KFNVN0tyVpLnJjkpyZ2SnJfkH6vqmIO8z+6qOruqzl5bu2g2aQEAAFh5OiQAAGxs2pUyj0/yq9395919fnd/uLt3J/lkkods9A7dfUZ3n97dp+/Ycfys8gIAsN2NbJYTsCEdEgCA2RhZh5x2UOa0JKdV1QMPWG5+ZpI7zzwVAADj1T3fC7AKdEgAAGZjZB1y2kGZzye5ZpIfS/KOqvrnqvq2JC9L8rPzCgcAAMC2pEMCAMAGdk15v9cluXZ3P7SqdiW5f5KnJfm37v7xuaUDAGB8bDEGRwIdEgCA2RhZh5x2pczvJfnuqnpkd+/p7pcm+c0k3zu/aAAAAGxTOiQAAGxgqpUy3X1xVX1zkjOr6leSXJDkprHsHACAw7XmvC8wdjokAAAzM7IOOe32Zenuc5J8U1WdlOQmSd7X3RfMLRkAAADblg4JAABXNfWgzD7d/akkn5pDFgAAjgQ9rv2AgUPTIQEA2JKRdchpzykDAAAAAADAFhz2ShkAANiSke0HDAAAwByNrENaKQMAAAAAALAAVsocwfauLX8vvs9eev6yIyRJbvrjf7XsCEmSjzznQcuOkCS57U/+zbIjJEnOu+yiZUdIkuy5fO+yIwCMSq/AMQgAh2/P2mocF593yYXLjpDr3f/Jy46QJPn8W1607AhJkuvf+WHLjpAkuWzvFcuOkGQ1/t8CMCZj65BWygAAAAAAACyAlTIAACzWyPYDBgAAYI5G1iGtlAEAAAAAAFgAK2UAAFisHtd+wAAAAMzRyDqkQRkAABZrZEvPAQAAmKORdUjblwEAAAAAACyAlTIAACzW2riWngMAADBHI+uQVsoAAAAAAAAsgJUyAAAs1sj2AwYAAGCORtYhrZQBAAAAAABYgKkHZarqGpOXPzu/OAAAjF6vzfcCrAQdEgCAmRhZhzyclTIfmLx83DR3rqrdVXV2VZ29tnbR4ScDAABgO9MhAQDgAFfnnDI1zZ26+4wkZyTJrqNPGdembwAAXH0j2w8Y2JQOCQDA1TeyDrnpoExVvXvy6vWr6l1Jrjd5mQwH153kDt32igAAADjS6ZAAAHBw06yU+dYklyZ5R5JvSPKuycsvcTANAMC0es2hI4ycDgkAwMyMrUNOc06ZB2Q4mD4uybFJ1rr7c+svc00IAADAdqJDAgDAQUyzUubtSU5N8pAkP5Xk/fMMBADAyI1sP2DgKnRIAABmZ2Qd8pCDMlVVSR6X5E5J/irJF5O8qqp+Zf39uvtJc0sIAADAtqBDAgDAoR1yUKa7O8n9q+ouSV6QZG+Sp2c4OSMAABy+kc1yAq6kQwIAMHMj65DTbF+W7v6vqvraJD+W5ENJbtjdf11VN0ny5fMMCADAyDi/N4yeDgkAwMyMrENONSiTJN19YVX9S5JfTfIVSf46yU9mmPH0uvnEAwAAYDvSIQEA4Ko2HZSpqqcl+fvufm2Sb0zyhiRfUVU3T/LgDHsFAwDAdEa29BzYnw4JAMBMjaxD7pjiPvdK8qKq2p3kEUnOSnJUkj9L8iPd/YX5xQMAAGCb0SEBAOAgptm+bE+SeyZ5dZJzktw4yY2SfDrJV1bVV3b3M+YXkTG7+PJLlx0hSXKb691y2RGSJD/8c29bdoQkyQNOvN2yIyRJbnTCUcuOkCT55U+8ZtkRcuyuo5cdIUly6Z7Llx0BGIEe2Swn4Cp0SOZqFf6KPPYGd192hCTJ++/95GVHSJLc7MSTlh0hSfKpS1ZjzPdzl3xx2RGyo2rZEZIka70KP7HAdje2DnnIQZmq+t4k18ywoqaSnJhhhlNN3vca8w4IAADA9qBDAgDAoW22UubEJDdJ8vdJfiTJo5Ocn+QTGQ6y/7O7/2WuCQEAGJeRzXIC9qNDAgAwWyPrkIc8p0x3/1GS+2aY2fRfSX4/yQOTXJ7kQUmeW1XXnXdIAAAAVp8OCQAAh3bIQZkk6e5XJXlekt/IsCfwXSfXn5PkzCS/Msd8AACMzdrafC/AUumQAADM1Mg65Gbbl+3zm0mO6+5Lq+qRSfadBfxZSU6bSzIAAAC2Kx0SAAA2MNWgTHfvTfLFyevvTvLuyetfSPKquaUDAGB8RrYfMHBVOiQAADMzsg656fZlAAAAAAAAbN2025cBAMBsjGyWEwAAAHM0sg5ppQwAAAAAAMACWCkDAMBCdY9rlhMAAADzM7YOuemgTFWddsBVl3T3u6vqPt39yqp6Wnc/bk75AAAYm5EtPQf2p0MCADBTI+uQ02xf9qokP5/knyYv/3Ry/dMnL++70TtV1e6qOruqzl5bu2jLQQEAANgWdEgAADiIaQZlPpLkEUk+OHl5dFXdNMlRk5e10Tt19xndfXp3n75jx/EzigsAwLa31vO9AMumQwIAMDsj65DTDMrcIsnLk9w6yd8n+YokZyW5yeSl5gsAAMA+OiQAABzEpueUSfL+7r5nVb2+u7+pqv67u0+rqnd19x2r6t1zTwkAwGi01SwwdjokAAAzM7YOOc2gzA2q6l1Jrjl5+fHJ9RsuOQcAAOCIpkMCAMBBTDMo8+fd/fgkqaqHZjhZY5I8o6pOS/LGeYUDAGCERjbLCbgKHRIAgNkZWYecZlDmh6vqisnrD0nyTVX1qSRfk+R23f3wuaUDAABgu9EhAQDgIHZMcZ/Lk7wjyTuTXJzkA5PXX5TkAfOLBgDAKK3N+QIsmw4JAMDsjKxDTrNS5mnd/WdJUlWXJvnXJLdN8okkZ1TVT3b3s+aYEQAAgO1DhwQAgIOYZlDmjKq67uT110xe3jzJk7r7nlX1oSQOqAEAmEqPbD9g4Cp0SAAAZmZsHXKaQZl/SHLZAdd1kpdPXq+ZJgIAAGA70yEBAOAgphmUqSQ/mmEv4M9095cOrqtqZ6Y7Lw0AAAxGNssJuAodEgCA2RlZh5xmUOYNSX43yTFJvqyqTkzyniTPSXJhkrfPLR2jtyo/Tv/92f9ZdoQkybt2Hb3sCEmSvb0aZ0k+/51/vewISZJfvu1rNr/TnF225/JlRwAAmJYOyeg99VOvW3aEJMnaSXdfdoQkyUV7zl12hCTJP1771suOkCQ5/ZI3LTtCrnnMccuOkCS5dM8Vy46QJLl0RTr1qiwVXZX/x8GRatNBme7+map6RJLLk7wvwwH06UnuluTBSR4/z4AAAIzMaoz9A3OiQwIAMFMj65DTrJRJkp9OclaGJei3SvLPSe6U5MzufvWcsgEAMEJjO0kjsCEdEgCAmRhbhzzkXr5Vda+qenaSk5K8NMmzk7wpyY0yrLi7e1VdZ+4pAQAAWHk6JAAAHNpmJ1h8R5LXJ/mzJM9K8qdJPpLkO5KcluRtSf65qlZjo0oAAFbf2pwvwDLpkAAAzNbIOuQhty/r7nOT/Mnkkqq6c5KHJjmuu7+Q5Neq6nXdffHckwIAALDSdEgAADi0ac8pkyTp7jcnefMB171mpokAABi1se0HDBycDgkAwFaNrUNutn0ZAAAAAAAAM3BYK2UAAGDLnPcFAACAaY2sQ1opAwAAAAAAsABWygAAsFA9sllOAAAAzM/YOuSmgzJVddNN7vKJ7r5iRnkAAADYxnRIAAA4uGlWyrwrw65tn0xyfJJPr7vtqCRfTHK3A9+pqnYn2Z0ktfNa2bHj+C2HBQBgBJY8y6mqHp7kyUk+n+Qh3f3WA25/RJInJakkv97dz114SNjedEgAAGbnSFspk+TNSa5I8stJvr67f3v9jVX10Y3eqbvPSHJGkuw6+pTeYk4AANiyqrp+kmcnufvk8rwkd1l3+x2SPD3Jt2UYtDllCTFhu9MhAQAYlVlO7ptmUOZaSfYkOXXywf8hyb7l6OclecBhpQcA4Ii25P2A75Xko9395qr6VJJnVtWNuvsTk9sfnuRPu/vsydsfXEpK2N50SAAAZmbZ55SZ9eS+HVM85luTvDPJ10xenpDk15L8epK17v7vw/4sAABgOU5O8t7J659IcmH2P2C+RZJrVNV7quqjVfVtiw4II6BDAgAwJl+a3JfkpUlOr6obrbv9S5P7uvuD3f1vh/pg0wzKXJhhz98Lk1ycYQe3y5JcmtHt5gYAwNytzfdSVbur6ux1l93rHr2z/zHwjsl1+1wjw4z+eyT5kyS/O6tPG44gOiQAALOz3A6ZzHhy3zTbl319hqXnL0xyx0nUp05u21FVD+ruv5ji4wAAwNyXnq8/L8UGzk1y68nrJyc5LsnH193+kSQXd/cnq+olSR4zr5wwYjokAAAzs+QOmRze5L5HZ5jcd7uDfbBpBmXOy3CSxjclObW77zHF+wAAwCr6pyR/WFWnZdgL+L+S3LqqntLdD0vy10meV1VPT/KgDCcsBw7PedEhAQAYj5lO7ptmUObUDDObnpvk+Kp66IF36O67TvFxAABgqSdp7O7PVtWjkpyV5AsZBl5umeQ2k7u8OskLkrwtw0H2VY59gU2dGh0SAIAZWWaHnJjp5L5pBmXumOT7k7wyyQUZTmrzrxn2AwYAgG2lu1+YYVulfd6W4WSN6e5O8qTJBbh6dEgAAEZj1pP7Nh2U6e4PV9UPJPm3JE/PsF/aXZO8a3KXNyc557A/EwAAjkgrMMsJmCMdEgCAWVqFDjnLyX07NrtDVX1lkmOT3CLJzsllV5Kjkhyd5HcOIzsAAAAjpkMCAMDBTbN92bOS3CjJz2RYnnNUhhlP/5mkMuwXDAAA0+ladgJgvnRIAABmZ2Qdcprty76pqt6e5NFJ7p2kk9w+yVOS7O7uB803Ihw5Lt97xbIjrJTr3uH7lx1hZVz0/pcvO0KS5LhbfceyIyQZ/puzCnrZAQBgBemQHAmuefQ1lh0hSfLCC96+7AhJkguvWI1TRn1XPrrsCCvjnMectuwISZKTnvafy44AsHKmWSmTDAfR5yX5QJJbJ7k4yYO7ezX++gMAsG2swn7AwNzpkAAAzMTYOuSmgzJV9ZoM+wE/c3LVNZNckeQuSX5wftEAAADYbnRIAAA4uGlWytw4yTdn2C3mH5Pca/L6388xFwAAI9Vrq7IJITAnOiQAADMztg45zaDM9ZM8IcNB9EnrXr9xVd2nu185t3QAAABsNzokAAAcxDSDMvdb9/rzDnj9nNnGAQBg7Ma2HzBwFTokAAAzM7YOuemgTHf/+yKCAAAAsP3pkAAAcHDTrJQBAICZ6R7XfsAAAADMz9g6pEEZAAAWamxLzwEAAJifsXXIHcsOAAAAAAAAcCSwUgYAgIXqtXEtPQcAAGB+xtYhp1opU1XHVNVJB1z3NVV13HxiAQAAsF3pkAAAsLFpty+7SZJ/2vdGVR2f5IwkJxzsHapqd1WdXVVnr61dtLWUAACMRvd8L8BK0CEBAJiJsXXITbcvq6pHJrlZkptX1ROSHJ/kjkkuTnJykk9v9H7dfUaGg+7sOvoU9RgAAOAIoEMCAMDBTXNOmU5yeYZVNRcl+WySByb5yyQvTnLLuaUDAGB0xrYfMHAVOiQAADMztg656aBMdz8/Sarqp7r7qZPXH5DkyUkePt94AAAAbCc6JAAAHNw0K2X2WX/+mX9JclaSN8w2DgAAYze2WU7AQemQAABs2dg65OEMytxm3evPSPLuJP8+2zgAAACMhA4JAAAH2HRQpqp+OMmxST5UVR/OcFLGZyb5QpKjM+wJDAAAU2mn74ZR0yEBAJilsXXIaVbKnJ/kdkm+IclNktw4w4kbP5TkmDigBgAA4Eo6JAAAHMSmgzLd/eI4aAYAYEbGth8wsD8dEgCAWRpbh9yx+V0AAAAAAADYqmm2LwMAgJnpHtcsJwAAAOZnbB3SoAwAAAvVa8tOAAAAwHYxtg5pUAa4iqrVGH2+1jHHLTtCkuTSPZcvO0LWvnDusiMAAAATn7vki8uOwAYuuOziZUdYGUc/6leXHSFJcsVT7rXsCEmSo3auxr9Ar9i7Z9kRgBWwGr+RAAA4YqyNbOk5AAAA8zO2Drlj2QEAAAAAAACOBFbKAACwUGM7SSMAAADzM7YOaaUMAAAAAADAAlgpAwDAQvXauGY5AQAAMD9j65BWygAAAAAAACyAlTIAACxU97ITAAAAsF2MrUNaKQMAAAAAALAAm66Uqaqv7e43LCIMAADjN7b9gIH96ZAAAMzS2DrkNCtlXl9Vr6qqW889DQAAANudDgkAAAcx7Tll/iDJP1TVOUn+Icl7knw6yWXd/d/zCgcAwPis9bhmOQEb0iEBAJiJsXXIaQZlurtfWlUvS3LfJA9M8pAkN0lyfJJjNnqnqtqdZHeS1M5rZceO42eTGAAAgFWmQwIAwEFMMyhTSdLde5K8bHLZVHefkeSMJNl19Cl9dQMCADAuPbJZTsBV6JAAAMzM2DrkNIMyT5x7CgAAjhjtX60wdjokAAAzM7YOuWOzO3S3A2oAAACmokMCAMDBTbNSBgAAZmZsJ2kEAABgfsbWITddKQMAAAAAAMDWWSkDAMBCje0kjQAAAMzP2DqklTIAAAAAAAALYKUMAAAL1b3sBAAAAGwXY+uQVsoAAAAAAAAsgJUyAAAs1NrI9gMGAABgfsbWIa2UAQAAAAAAWAArZWCFrK3KBokrkuNTF5237Agr4//7zj9ZdoQkyYlHX2PZEZIkH3nErZcdIUnyZX/4tmVHSLJCvztgSj2yWU4AAKvmsmf8wrIjJEnuf9Jpy46QJHnd+e9fdoQkyUVXXLrsCEmSi6+4bNkR4LCMrUNaKQMAAAAAALAAVsoAALBQY9sPGAAAgPkZW4e0UgYAAAAAAGABrJQBAGChnAUJAACAaY2tQxqUAQBgoca29BwAAID5GVuHtH0ZAAAAAADAAlgpAwDAQvXIZjkBAAAwP2PrkFbKAAAAAAAALICVMgAALNTasgMAAACwbYytQ17tlTJVdZ2qOmWWYQAAABgnHRIAALa2UubPk9wmyc1nlAUAgCNAZ1z7AQNT0yEBADhsY+uQWxmU+YEk1zjYjVW1O8nuJKmd18qOHcdv4aEAAADY5nRIAACOeFd7UKa7P7fJ7WckOSNJdh19Sl/dxwEAYFzWHBnCEUmHBADg6hhbh7za55QBAAAAAABgelvZvgwAAA7b2sj2AwYAAGB+xtYhrZQBAAAAAABYACtlAABYqB7ZLCcAAADmZ2wd0koZAAAAAACABbBSBgCAhVpbdgAAAAC2jbF1SIMyAAAs1NiWngMAADA/Y+uQti8DAAAAAABYACtlAABYqLEtPQcAAGB+xtYhrZQBAAAAAABYACtlALaBp7z0B5YdIUny3K97/bIjJElO/YtPLjtCkmSte9kRYFsa2ywnAIBVU9c+cdkRkiSf2XvusiMkSY7dedSyIyRJLrri0mVHgG1pbB3SShkAAAAAAIAFsFIGAICF6tSyIwAAALBNjK1DWikDAAAAAACwAFbKAACwUGvjmuQEAADAHI2tQ1opAwAAAAAAsABWygAAsFBrI9sPGAAAgPkZW4e0UgYAAAAAAGABrJQBAGChetkBAAAA2DbG1iG3tFKmqr5xVkEAADgyrM35AqwuHRIAgMM1tg656aBMVd2pqv61qj5SVX9XVXdfd/Nr5pgNAACAbUaHBACAg5tmpcyZST6a5KeSvDPJWVX1c5PbxnWGHQAA5m6taq4XYOnOjA4JAMCMjK1DTnNOmZsmuXd3fyrJ31XVs5O8oqq+MsnlB3unqtqdZHeS1M5rZceO42eRFwAAgNWmQwIAwEFMs1LmrCQ/su+N7v5okm9I8uVJjjrYO3X3Gd19enef7mAaAIB9es4XYOl0SAAAZmZsHXKalTI/keT09Vd093lV9a1JHj2XVAAAAGxXOiQAABzEpitluvuL3X2VkzF292Xd/dT5xAIAYKzW5nzZTFU9vKo+UVXvrKo7HeQ+j6qqrqqbXc1PE45YOiQAALO07A6ZzLZHTrNSBgAARqGqrp/k2UnuPrk8L8ldDrjPtZP8f0m+sOh8AAAArJZZ98hpzikDAAAzs1bzvWziXkk+2t1vTvLSJKdX1Y0OuM8vT267YOafPAAAAIdlyR0ymXGPNCgDAMCoVNXuqjp73WX3uptPTvLeyeufSHJhklPWve+tkjw4ya8vLDAAAABLs0mHTGbcI21fBgDAQq1luqlIV1d3n5HkjIPdnP0nJu2YXLfP05I8sbu/UDXfnAAAAGxuyR0ymXGPtFIGAIAjyblJbj15/eQkxyX5eJJU1TWTfFuSp1TVeUlumuRtVXWtJeQEAABgNcy0RxqUAQBgoXrOl038U5JTquq0JN+V5L+S3LqqXtjdF3T3sd19re6+dpKPJPmq7j5/Fp83AAAAh2/JHTKZcY+0fRkAAEeM7v5sVT0qyVlJvpDkQUlumeQ2Sw0GAADASpp1jzQoAwDAQq0t+VQt3f3CJC9cd9Xbkrx0g/vdbFGZAAAA2NiyO2Qy2x5pUAZgEztW4ETP3/Wdz1l2hCTJPa5/h2VHSJL84UmXLztCkuRO77lg2RGSJJfuvWLZEXLF3j3LjsA2srbsAAAAc7T8Bpn80Bmr0VVe/JXL7ypJctv/uGTZEZIkX3HijZYdIUnyjs9/eNkRkky9bRSMrkM6pwwAAAAAAMACWCkDAMBCmREHAADAtMbWIa2UAQAAAAAAWAArZQAAWKhVOEkjAAAA28PYOqSVMgAAAAAAAAtgpQwAAAu1tuwAAAAAbBtj65BWygAAAAAAACyAlTIAACzU2GY5AQAAMD9j65BWygAAAAAAACzAIQdlquqm03yQae8HAABd870Ay6NDAgAwa2PrkJutlPnQlB9n2vsBAAAwXjokAAAcwmbnlKmq+uBm95lcDnzH3Ul2J0ntvFZ27Dj+6iUEAGBUxrYfMLAfHRIAgJkaW4c85KBMd1/tc8509xlJzkiSXUef0lf34wAAALA96JAAAHBom62UAQCAmRrbLCcAAADmZ2wd0qAMAAALZfo7AAAA0xpbh7zaS8sBAAAAAACYnpUyAAAs1NpVTu8NAAAAGxtbh7RSBgAAAAAAYAGslAEAYKHGdpJGAAAA5mdsHdJKGQAAAAAAgAWwUgYAgIUa2ywnAAAA5mdsHdJKGQAAAAAAgAWwUgYAgIXqZQcAAABg2xhbhzQoA7CJqlp2hLz/kk8tO0KS5NOXnLfsCEmS6z32W5YdIUly0f9577IjJElucuINlh0h51ywGs9RAMZh+Udfg7H9AwBYjKN3HbXsCCuzNc6vvPekZUdIknzfdVcjxws//V/LjpAk+drr33bZEZIk//nZ5XfqVfifT5J0O+o4khiUAQBgodZWo/cAAACwDYytQ67KwDkAAAAAAMCoWSkDAMBCrS07AAAAANvG2DqklTIAAAAAAAALYKUMAAAL5RSWAAAATGtsHdKgDAAAC7U2ukNqAAAA5mVsHdL2ZQAAAAAAAAtgpQwAAAs1tpM0AgAAMD9j65BWygAAAAAAACyAlTIAACzUuHYDBgAAYJ7G1iGnXilTVY+pqrtU1Y6qOquqPl9VD59nOAAAALYnHRIAAK7qcLYv+/+SfDHJQ5IcneRHk/zWwe5cVbur6uyqOntt7aKtpQQAYDTW5nwBVoYOCQDAlo2tQx7O9mWd5F5JfiLJ9yX5VA4xqNPdZyQ5I0l2HX3K2FYYAQAAcGhXu0MepUMCADBShzMo85gkv5zkT7r7rVX1o0n+ZC6pAAAYrbVadgJgQR4THRIAgC0aW4c8nEGZ9yR5fZK7VNXLcnhbnwEAAHBk0SEBAOAAhzMo87IkH0jy70kun08cAADGbi12JYIjhA4JAMCWja1DHs6gzOVJHtrdn5xXGAAAAEZDhwQAgAMc7jllnltVL1l/ZXe/cKaJAAAYtXHNcQIO4THRIQEA2KKxdcjDGZT5ySTfnORmuXLpeSdxQA0AAMCBdEgAADjA4QzK3CXJ7bv7g/MKAwDA+K0tOwCwKDokAABbNrYOeTiDMv83yf2q6swkte/K7r5g1qEAABivsZ2kETgoHRIAgC0bW4c8nEGZ3UlumOR3J29XhqXnO2ecCQAAgO1PhwQAgAMczqDM3eaWAgCAI8a45jgBh6BDAgCwZWPrkFMPynT3OVf7QXasxkSoPWt7lx0B2IaO23XMsiPk3Is+t+wISZLjjlr+1yJJfuV3V2PXk+OPOnbZEZIkZ+y81bIj5Nt3rsZz9KgVOeYAYGsd8sRjjptllKvtgssuXnYEYBu64XHXXXaE/PMX3rXsCEmS6x5zzWVHSJJ82dEnLjtCkuQW17zhsiMkSa678xrLjpAkucHx1152hJywazW+Fnt7bGdN4VAOZ6UMAABsmboBAADAtMbWIXcsOwAAAAAAAMCRwEoZAAAWam10OwIDAAAwL2PrkFbKAAAAAAAALICVMgAALNS45jgBAAAwT2PrkFbKAAAAAAAALICVMgAALNTasgMAAACwbYytQ1opAwAAAAAAsABWygAAsFA9uh2BAQAAmJexdchDDspU1a9M+4G6+0lbjwMAAMB2pUMCAMChbbZS5glJHpGkNrnfHyVxQA0AwKbGth8wsJ8nRIcEAGCGxtYhNxuU+ePufuFmH6Sq7rHBdbuT7E6SXbuuk507T7g6+QAAGJm1kS09B/Yzkw553DHXzzFHXWvm4QAA2H7G1iF3HOrG7v7BaT7IRvfr7jO6+/TuPt2ADAAAwPjNqkMakAEAYKw2WykDAAAzNa45TgAAAMzT2DrkIVfKAAAAAAAAMBtWygAAsFBj2w8YAACA+Rlbh7RSBgAAAAAAYAGslAEAYKHWlh0AAACAbWNsHdJKGQAAAAAAgAWwUgYAgIXqke0HDAAAwPyMrUNaKQMAAAAAALAAVsoAALBQY9sPGAAAgPkZW4e0UgYAAAAAAGABFrJSZu/a3kU8DMBcXP8a1152hHz4gk8uO0KS5Hon3GDZEZIkZ3zmP5cdIUly+d49y46QJLnrd1+w7AjZcWYtO0KS5ArHHNvC2PYDBmbvoisuXXYEgKvt2J1HLTtCPnLpRcuOkGR1OtNHvvjpZUdIkqz1asz3f823HL3sCEmS096w/PUCF+65ZNkRkiR7dNlDGluHXP4zHwAAAAAA4AjgnDIAACzUaswPBAAAYDsYW4c0KAMAwEKt9biWngMAADA/Y+uQti8DAAAAAABYACtlAABYqHHNcQIAAGCextYhrZQBAAAAAABYACtlAABYqLXRzXMCAABgXsbWIa2UAQAAAAAAWAArZQAAWKge2SwnAAAA5mdsHdJKGQAAAAAAgAWYaqVMVV0jSW1wU3f3JbONBADAmK0tOwAwdzokAACzMrYOOe32Ze9NsidXHlTvWy90VFW9pbu/48B3qKrdSXYnyY6d18qOHcdvNSsAAADbw5Y65M5d187OnScsJCgAACzStIMy1d23+NIbVT+Y5AZJnpLkPRu9Q3efkeSMJDnq6FPGtekbAABX29rI9gMGNrSlDnnMsTfxiwIAgCTj65DTDsp86bOuqsck+cEk9+vurqrnziMYAAAA25YOCQAAG9h0UKaqfjXJNavqJ5LcIskdk3xDd1+QJN39jPlGBABgTHpks5yA/emQAADM0tg65I4p7nNRhllOJ2c4mL5Zkq+bYyYAAAC2Lx0SAAAOYtNBme5+WpILu/sXu/teSR6U5Per6t5zTwcAwOiszfkCLJcOCQDALI2tQ06zUiZZtx9wd/93ku9O8h1zSQQAwKh191wvm6mqh1fVJ6rqnVV1pwNuu21VvaaqLqiqs6rqOnP7QsC46ZAAAMzEsjtkMtseOe2gzI6q+vS+S5JXJfm+dW8DAMDKq6rrJ3l2kvtOXj7vgLt8R5JnJTk1yZcn+dlF5oMR0SEBABiFWffIXVM+7pcf5PofSPIfU34MAADI2nJP0nivJB/t7jdX1aeSPLOqbtTdn0iS7n7qvjtW1b8kufmScsJ2p0MCADATS+6QyYx75KYrZarqyUl+KMnXJNnR3Xu7e2+SX0ryG0lOuNqfCgAAzFhV7a6qs9dddq+7+eQk7528/okkFyY5ZYOPUUnumuTNcw8MI6NDAgCwnWzSIZMZ98hpVsqcl+Trk+xOcrOq+psk10hyyyR33TcaBAAA05j3iRS7+4wkZxzs5uw/MWlHsuG0q/snuU2S5882HRwRzosOCQDAjCy5QyYz7pGbDsp095P3vV5VN07yiAx7oj3VwTQAANvMuUluPXn95CTHJfn4+jtU1WlJXpDku7v7vIWmgxHQIQEAGJmZ9sipzikzOZHNHyT50+7+9ar6yyQvr6q93f2Uzd7/nid91TQPM3ev+tTblh0B2IYu3nvpsiNkrZe+d2aS5KMXfmbZEZIke9b2LjtCkmTXjp3LjpAkufffXbbsCPmq66zGaTe+bOdxy46QJNnb857Hs731cvcD/qckfzg5YL57kv9Kcuuqekp3P6yqbpHkFUl+rrtfs8ygsJ1ttUPe7Xq3mXvGabzu0+9edgRgGzrni59edoTln31h4pIrlt9VktX5ehyz66hlR0iS3Py1H112hCTJ13/ZbZcdIbffca1lR0iSXDr3tSDb25I7ZDLjHjnNOWVumeQtGfZM+4eq2pHh5IzfluQXqupWV/tTAQCABeruzyZ5VJKzJi8fmeR6GZaYJ8mzkpyU4cSNXVVLP/qH7UaHBABgTGbdI6dZKfPBJN/U3e/bd0VVfXWG0aBnJ/mWJO8/zM8DAIAj1NqSZzl19wuTvHDdVW9L8tLJbfddSigYFx0SAICZWXaHTGbbI6cZlHlCkmOq6tgk+y6nJPmZJPfu7j2H84AAAACM2hOiQwIAwIamGZT5QpLLk1yS5NLJyz/PMMPpdknePrd0AACMTq/IebKAudEhAQCYmbF1yE0HZbr7dza6vqoenynOSQMAAMCRQ4cEAICDm2alzIa6+8WzDAIAwJFhbdkBgKXQIQEAuDrG1iHNUgIAAAAAAFiAq71SBgAAro7OuPYDBgAAYH7G1iEPa1Cmqm7Q3Z+eVxgAAMZvbWQH1MDB6ZAAAGzV2DrkptuX1eCfquruSZ5aVccsIBcAAADbkA4JAAAHt+mgTHd3kq9N8u4kO5PcJUmq6piq+s+qOnq+EQEAGJPunusFWC4dEgCAWRpbh9x0UGbi/CRfleQnu/t1k+tOTXKz7r58o3eoqt1VdXZVnf2xCz+69aQAAABsF1vqkOde9PEFxQQAgMWadlDms0mekeT4ddf9XJI/Pdg7dPcZ3X16d59+4xNusoWIAACMyVp6rhdgJWypQ558/CnzzgcAwDYxtg65a8r7fSrDwfPrquodSW6V5OIkPzSvYAAAAGxbOiQAAGxg2kGZTyb5TJI7JLlHkouS/Ed3XzanXAAAjFRbzQJHAh0SAICZGFuHPJyVMjft7ouSnDXHPAAAAGx/OiQAAGxg2kGZzya56TyDAABwZFjrcc1yAjakQwIAMBNj65DTDsq8YK4pAAAAGBMdEgAANjDVoEx3f3beQQAAODKMa44TsBEdEgCAWRlbh9yx7AAAAAAAAABHgmm3LwMAgJlYG908JwAAAOZlbB3SShkAAAAAAIAFsFIGAICFGtssJwAAAOZnbB1yIYMy354vW8TDbOrVyw4wsSpPoVp2gKzO1wIO5TMXn7/sCCvj8r1XLDtCkmStV+O3x961vcuOkCT5r8++b9kRcp+TTl12hCTJzlqNRcAX9dqyI6y0XpGfYWB1ffaKC5cdAeBqW5XetAp27VyN+eB79u5ZdoSVsiqd+m51nWVHyEdy+bIjJEkuas/RQxlbh1yN/1wAAAAAAACM3GoMVwMAcMQY29JzAAAA5mdsHdJKGQAAAAAAgAWwUgYAgIXqkc1yAgAAYH7G1iGtlAEAAAAAAFgAK2UAAFio7nHNcgIAAGB+xtYhrZQBAAAAAABYACtlAABYqLWR7QcMAADA/IytQ1opAwAAAAAAsABWygAAsFBj2w8YAACA+Rlbh7xaK2Wq6juq6neq6n6zDgQAAMC46JAAADDYdFCmBg+uqpq8/Z1JnpzkU0meVlUPPsj77a6qs6vq7H+/8P2zzAwAwDa2lp7rBViuWXTIz1/y6cUFBgBgpY2tQ06zUqaSvCDJ70ze/sEkP5PkKUn+KsljN3qn7j6ju0/v7tPvfsKtZpEVAACA1bflDnnda9xgIUEBAGDRNj2nTHevVdWnk3xVVf1ykusmeX2Sn09yqyQ3mm9EAADGpK1mgVHTIQEAmKWxdchNB2Um1pJ8d5LXJTkpyfWSnJrkx5O8ai7JAAAYpbWRnaQR2JAOCQDATIytQ06zfVmSXJHksiT3TXJ5kocleUmStyf5+/lEAwAAYJvSIQEAYAPTrpR5ZZJju/ucqvr2JP+S5AFJbtfdX5hbOgAARmdsS8+BDemQAADMxNg65FQrZbr70d39+cnr/53koUm+0cE0AAAAB9IhAQBgY9OulEmSVNU1kpzQ3a9I8or5RAIAYMzGth8wcHA6JAAAWzW2DjntOWX2+Zkkv7Tvjar6map6U1UdM9tYAAAAjIAOCQAA60y9Uqaqrp/kx5OcNnn7tCRPTPLt3X3ZfOIBADA2Y9sPGNiYDgkAwCyMrUMezkqZC5M8JMkPV9Xnk7whyZ4kr6yqR84jHAAAANuWDgkAAAc4nEGZeya5cZKnJPmyJG9Ocosk35bk8bOPBgDAGK11z/UCrAwdEgCALRtbh5xq+7Kq+p4kd0pyi+7+s8l15yS5X5LLknz+UO//F2vnbjHmbOzYcbin0JmPvWtry46QJCNb9AXzc+yuo5cdIRdffumyIyRJjj/q2GVHSJKsrchvsDtf++bLjpAkeet5H152hJy/thrP0aNr6p1Z52pVnqMAy7LVDnnHY28494zTeE8+uuwIwDZkksiVekW+FquRIrnlNU9edoQkyTs/f86yIyRJXrX3U8uOkJvsvOayIyRJdqaWHYEFmvY/F9dOcpck96iqCzLMdPr5JM9NcnySx8wjHAAA4zO2/YCBDV07OiQAADMwtg451aBMdz+vql6Q5NwkH0jyxiT/N8l9uvuKOeYDAABgm9EhAQBgY4ezn9dRSS7t7qclOS3JfZJ831xSAQAwWmPbDxg4KB0SAIAtG1uHPJyN1y9Lcpsk6e6PVtXXd/fl84kFAMBYjW3pOXBQOiQAAFs2tg459aBMD2fmunTd2w6mAQAA2JAOCQAAV3U4K2UAAGDLuteWHQEAAIBtYmwd8nDOKQMAAAAAAMDVZKUMAAALtTay/YABAACYn7F1yKu9UqaqrlNVp8wyDAAAAOOkQwIAwNZWyvx5ktskufmMsgAAcAQYzv0NHIF0SAAADtvYOuRWBmV+IMk1ZhUEAACAUdMhAQA44l3tQZnu/tyhbq+q3Ul2J8ktrnWb3PD4k6/uQwEAMCJj2w8YmM7hdMjTr3un3PKEmy0iFgAAK25sHfJqn1NmM919Rnef3t2nG5ABAADgUNZ3SAMyAACM1Va2LwMAgMM2tv2AAQAAmJ+xdci5rZQBAAAAAADgSlbKAACwUGsjm+UEAADA/IytQ1opAwAAAAAAsABWygAAsFCdcc1yAgAAYH7G1iENygAAsFBjO0kjAAAA8zO2Dmn7MgAAAAAAgAWwUgYAgIVaG9nScwAAAOZnbB3SShkAAAAAAIAFsFIGAICFGtt+wAAAAMzP2DrkQgZlrrfzuEU8zKZ27di57AhJkhufcP1lR0iSfPSLn152hKytyA/UUTtXY3xy79reZUdIsjrfl1p2gInL9+5ZdoTc8ctuvuwISZIPX/ipZUdIkuxckWfHZ6+4cNkRkiQXXXHpsiPkvReeu+wISZLrHnPisiMAMANfVscsOwIc0mocjWZkm7mMxyo8P65x1Gr8Hj16Rf7fsgq9Pkmut+uEZUdIshrP0SQ597Lzlh0hdcxqfDV2rMx3hUVYjd+MAAAcMVZl8B8AAIDVN7YO6ZwyAAAAAAAAC2ClDAAACzW2/YABAACYn7F1SCtlAAAAAAAAFsBKGQAAFmrNaYkBAACY0tg6pJUyAAAAAAAAC2ClDAAACzW2/YABAACYn7F1SCtlAAAAAAAAFsBKGQAAFmptZLOcAAAAmJ+xdUiDMgAALFSP7CSNAAAAzM/YOuQhB2Wq6o+m/Djd3T88gzwAAABsUzokAAAc2mYrZR6R5B5J6hD3qSSvSrLfAXVV7U6yO0m+6jp3zM1OuOnVDgkAwHiMbek5sJ9HZAYd8h7X/ep85YlfMZ+EAABsK2PrkJsNyjyxu//fZh+kqp504HXdfUaSM5LkATf99nF91QAAANjITDrkT97s+3VIAABGaccmt59ZVTfb90ZV3buq/qyqnlZVJ+67vrufOK+AAACMS3fP9QIslQ4JAMBMja1DbjYo8/tJ7pMkVXXnJH+X5OIkpyZ5zlyTAQAAsN3okAAAcAibbV/2jUkePnn9N5K8trsfWVWnJHnHXJMBADBKHatZYMR0SAAAZmpsHXKzQZlPJHlgVV2S5N5Jvn5y/bWSnDfHXAAAAGw/OiQAABzCZoMyP5vkL5OckOS3uvv1k+t/LcmL5xkMAIBxct4XGDUdEgCAmRpbhzzkoEx3/0NVXS/Jcd19/rqbfinJOXNNBgAAwLaiQwIAwKFttlImSTrJt1TV7ZPsTfKuJC/v7r1zTQYAwCiNbZYTcBU6JAAAMzO2DrnjUDdW1c2TvC/J05PcOcldk/x+kndX1U3nHw8AAIDtQocEAIBD22ylzB8k+askv9Dda0lSVTuTPDnJs5Pcb77xAAAYm3HNcQIOoEMCADBTY+uQmw3K3C3JQ/YdTCdJd++tqt9M8qG5JgMAAGC70SEBAOAQ6lD7sVXV25M8vrv/4YDr75PkKd19xznnAwAAYJvQIQEA4NA2Wynzq0n+uqqel+RNSSrJXZI8IslD5xsNAACAbUaHBACAQzjkSpkkqaqvTfLoJLdLspbk3Ul+r7v/a/7xAAAA2E50SAAAOLhNB2UAAAAAAADYuh2HurGqPrju9YcdcNvl8woFAADA9qNDAgDAoR1ypUxVrXX3jsnre7t750a3AQAAgA4JAACHttkB8foRmzrEbQAAAKBDAgDAIeza5Paqqpeue+Olh7ozAAAARzQdEgAADmGzQZknrnv9rQfcduDbAAAAHNl0SAAAOITNzilz0+7+yKYfZMr7AQAAMF46JAAAHNpmgzL7nZhxq/cDAABgvHRIAAA4tGnOKfPBDCdoPNjoTeWqJ3AEAADgyKNDAgDAIRxypQwAAAAAAACzsWPZAQAAAAAAAI4EBmUAAAAAAAAWwKAMAAAAAADAAhiUAQAAAAAAWACDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFsCgDAAAAAAAwAIYlAEAAAAAAFgAgzIAAAAAAAALYFAGAAAAAABgAQzKAAAAAAAALIBBGQAAAAAAgAUwKAMAAAAAALAABmUAAAAAAAAWwKAMAAAAAADAAhiUAQAAAAAAWACDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAAZlAAAAAAAAFsCgDAAAAAAAwAIYlAEAAAAAAFgAgzIAAAAAAAALYFAGAAAAAABgAQzKAAAAAAAALIBBGQAAAAAAgAUwKAMAAAAAALAABmUAAAAAAAAWwKAMAAAAAADAAhiUAQAAAAAAWACDMgAAAAAAAAtgUAYAAAAAAGABDMoAAAAAAAAsgEEZAAAAAACABTAoAwAAAAAAsAAGZQAAAAAAABbAoAwAAAAAAMACGJQBAAAAAABYAIMyAAAAAAAAC2BQBgAAAAAAYAEMygAAAAAAACyAQRkAAAAAAIAFMCgDAAAAAACwAEsZlKmqnlxuVlVPWPf256vqD6vq6Mn9dlbVr1bVh6vqU1X13Ko6ft3HeXxVfXJyeVZVHV9Vr518rEcs43Mbu6ratewMq6aqvrWqTpm8fmJV3WsBj/nDVfV9h7jdgOtEVX31Mr8eVXVSVd1lWY+/atb//l92lmWrqjMnX4snLOjxaprrmJ9DHP90VX143f2+q6reUVXnV9U/VNUt1t1276p69+S2l1fVzdd9rDOX8XkBLIoeuT3pkFelQ642HXK16JBX0iGPPDrkeC3rj8w53V3d/eHJ23+XZFeSb0nykCT7Dkgen+TBSe6X5KuTfEWSM5Kkqr4myZOS3CfJaUk+kWRPd98jyROvTqjJE/ziqnrPQS4XVNU91t3/w1V146q6R1X9y9V5zFVWVY+sqp9b9/Y3JPmHA+7z8qr65qp6RVXtmhSgr66qe04Kzv9aePDFe1aSnZPX75vhOTw3VfXNSZ6d5MlV9ZaqentVPeOAu/3d5Hn5k1V1k6p6zzwzLUNV3XX9z+cBtz25qn5y8uYvJ/nFqvrFyc/s+sulVXX6nKP+YJKHzfkx9rPBH+quqq9bd/ttq+o1k99pZ1XVdRYY78Df/0es7n5EhufH3FXVzyb5tcnv6Vutu+nnquopG9z/cYs60D/CXOX4Z/J2dffNkqSqvjbJC5P8nyQ3T/LWJK+qqqNr+GfjXyV5+uS2f0hS3f2EJN+00M8EYDlWrkfqkPvTIaemQy6BDnlwOuT2oEMekXTIkVqlmRCV5Jgka0n+Z3LdTyf5+e5+Z3d/LMmPJXlwVZ2U5IaT+3yxu8/t7t/o7stmkOON3X3b7r5tku9N8lPr3n7ZDD7+tlNVP1RV70jygiR3qar/mRzE/Z8kd0vyf5N8fZKzk/xSkjsm+bokJyQ5agaPf8zkMY9ad92eda8/voYZcOdV1dOr6uOTA80LJznPn8dBU1WdMvm63CLJK6rqkUm+L8kD1h2wzWzG0+QP4S9n+D58PMm3J/n+JF+W5Kx197tLklOTvDfDweSls8qw7jFW4XtyXJI3TH42j62qn6mqv6+qv8/ws/uoqvrhJD+a5MLJ74ibrb8kecMWM2yohhkKH6uqjyf5tSQPmry9/nLQWWpb1d1P2PdHOsn3JHltkv9Yd5fvyFAET03y5Ul+dl5ZWBmXZ/gb+xVJ/nXydzRJbpfkA5PfL196fmb43fGzBzxnjz/Ix2a2fjrJ87v7rO7+fJJfyHC89oAMv/dOTHJxd3++u/+guz+4xKwAq2AVeqQOeQAd8qC5dEgdckM6JCtIh9w+dMhtaFUGZR6Q5Iokr0/yt0n+p6quneGA+U377tTd/5Pk/CS3TfKPk/u/s6qeU1U3zOzdLck3HnhlVb26qm4zh8dbGVX1+CS/lWGW2YOS/EaGA7OvS/KxDD/gxyb54yRPS/LuJI9L8u9ziHOXJDdN8vaqeldV3WCSsZKku5+a5LFJntPdj81QsE7NcIB/tyT/PIdMyVAWPtndR2X4Gtwrwx+n608O1l6epGf4eMdlOPi5S5KfzPB5vTrJk7r7Vcmw9D3JmRlGwR+S5Pgk70xyq7pyi4ZZ/FFcxe/JvyZ53uTy1gy/H96X5K+6+3eq6vVVdfa+yxwe/0u6+6XdfeMkv55hFsP1M/nedfeNJ5e/mmeGJJkUnqcl+fHu/tJzsbuf2t0vmfwh/pcMsyVGq4YZrJ+oqidW1WdqmJV536p6X1WdU1V3qqrvrapzJz8jYywYlyQ5trvfm+SPkvzB5PrbZ/gdkcntN548d/8gyS+ue3tPhn96zU0Ns3h+t6peMDkGOBI8oK6cifiIyXW3y/7HPnuT/HeS23f3eRn+Nv9pVb2yqk5bdGCAFbOKPVKH1CEPRYdcre+JDnkAHXKgQybRIVeVDjkSqzIo83cZstwxyY0yzJRZm9x24A/wjiR7u/vSJN+a5JFJ7pHkbTXZk3WrquqFNSxl/e0kj6xhaetL1t3l6HW5zk7yXUm+Yd1I8HVnkWOZJgdEP5/kqUkemOQ6ST6c5ENJTs5wMH1ehlHzeyY5Kcl3Ti6zdo8MB/CnZShYn51c/5f7DuAOcGJVvWFy/9dM8i3CUUl+P8MfqCS5ZpILZ/XBu/uCJD+V5PQkj07yhSQfSfJjVfWYqrpzhlmAa0m+mOQGGX4x3z7J+7v7hpPLRTOIc4+sxvfkO2uYaXZKhgOGb+zuv81wIP3WJB/N8NxMkut29+ndfXqS683o8Q+qqm6bYQuMx06uuk6Sf5v34x7gvkk+0t3v3ujGyffqrknevNBUy3HDDD8zd0vyzUkeleF5/IEkP57kV5I8JcNzcx7/GFi2SzP83k6Gf5D8aVXdJEOZ+q8N7n+XDDM4F+m+GQ7u/yzJwxf82Muyfun5mZPr1nKQY58k6e5fSPINGbY8+c+quu+iwgKsoJXpkTqkDnk16ZA65JfokCtHh9QhV5EOORKrMiiTHrwjwwyne0wOHs7N8EOdJJnMLDoxw5LadPdad/9JhoPwL2RYTjmLLA/LcCDysQwzqe7Q3d99kLufnuSlSf5t3eyFz88ixzLVcFK7G2T4w/MDSS5K8j3dfXGG5dVXZJhhc2GSizP8oF+YoWDMMsexGf7wfXmGGVYf6O59RevYJLur6nuS/GKSh1TV/84wo+ZrM4wKf9Mk57zcbXJA9xtJ/jPD8t4/neSe6QF1Vd0+yasylMjfynBA+6Qk/zvD1+JXk7wxwz6RSXL3DH8o35X9Zzk9bos5Vul78rfdfYcMS/Hfl6HYHuyPy8nrZjidPKPH31ANy///LcPvsOtW1f9k+F58eQ1L9t87z8df54E5YA/vA9w/yW2SPH8xcZbuzMlM2fcmeUl3n5vkdRmeD3+d5Ccy/E6f6yy4JbkkVx5QX97df5PhoPVvDtyyZTJz5mZJ7lhVP7PAjEcn+dzkcvQCH3fVvDv7H/vsyvDPiHftu667X9fd98qwb/BC9xsHWDWr0iN1SB3yMOiQOuRV6JArS4cc6JCrTYfchnYtO8A+k9H2UzMsl9034vo7SX6zqt6V5IIMJ6b7k+7+TFU9LMNB9O9mmD1w3Qx/vGaV5dEZfun+c5K/qaofmMXH3kaenGEf0f9I8v8ylJxfrKpbZjhwSYYZAvfJcNLMr0rywcn7vHiGOe6fYQbGfTIcuP+/dbc9KsNz5YFJXpTklhm+X4+oqrdk2J7gjRn2wbxkhpnW+4/u/pbJksEbdvdbazhh52MzFL+ZHVBnKHnXzHAi0/tkmA3YmZycdHKfL22/0N1fnyRVdb0kr+th39xZWMnvSXfvrapHJXlENv66nzuZ4ZSq+vAsH3sDt8/w++v7uvvNSW45+T68obtvOefHXu+0DDNIr2Jy0PSCJN89Wc56JLn8gNeru59UVS/PMLPzQRlm3IzJJUnuUFVnJXlTVb0ow++pV6yfmVhVX5XkL5M8JkPZeF1Vnb+gjC/P8Jw8PskPL+gxV9HvJXl1Vb0yw9/gn09yWZKXT/6x8usZ9ms+L0PxeetyYgKshlXpkTpkEh1yWjrkinxPdMgN6ZAb0yF1yFWmQ25DqzIo84AMS62+kOQVGZ4oSfKMDHugvjLD6Ozf5MqTif1rhj/sb81wMPF/M/wwzsLPZNjr9Ae7+4tVdV6GpYmbqqrbJbl1d2/4R2wb+T8ZDpyv193vSXLbqjohycf2HZjVsP/yZzJ8L+6TYebK/fctn6uqM2eQ48VJ/inDH7lHZZi5kyTp7o9X1TdnKD63SnJid38yw8ysTGYffXt3f3gGOQ7Hr2RYhfYDGX7hzUR3vyTJS6rqZhn+4H0+w3P/6CQP6e4PJElduafkvKzS92Tf0vNrTx7/7CRnV9WTN7jvyXXlPsBzneXU3X88+T7N7USMU7pJkk8nSVV9Y5JHdvfDquoWGX7X/lx3v2aZAVdEVdWPZSgfZ0wuo1FV35vh5/WDSZ6T5O0ZZvA+LcPf0SdkOJloMvxM/3R3v2LyvvfL8E+uuevuSzKUmSPJA6pq317de7t7V3e/saoemmH7m5tm2ArhW7r7iqo6J8MWMGdl+EfiKzNscQFwpFqlHqlD6pBboUPqkDrk9qJD6pDLokOOxNIHZbr7CRl+mDe6bS3D0tonbXDbORlm1MzaVyc5YfL6a2r/rU1vkeEEcEly5wwH+r+eYTnYCZPl2nfNMBtlbgfUVXXrDAev9+vuuYxudndXbbiv60FjZfjavGXddTtnkGMtyXmTpbo7M8x0W3/7u5MvnYzurlW1O1cWrlskeVVVXZHksd191lbzbODratg7+oQMI9PJsAz/hCRHdfcXZvVANewz/RNJfijJj2Z4rl2aYf/M11bVXyR55qwe72BW6HvyoSQP6+6XbXDb0TngBJndfc0N7jfXk86tgBMyzI5Ihj2Q951c9lkZ9kl+ZlU9N0m6e+xfi0OpDAXwLRmeN2M7SeP/ZPin1bsz/D19UZInd/dvVdULMsxM/GCSdPej1r9jd3+kqn47w4lhZ3nS2SPeJsc/f5thdvGB11+UYXbaYw+8DeBIs2I9UoeMDnkYdEgdcpXpkNPRIXXIhdMhx2XpgzIr6E3dfY+Nbpgs1btThgPmH03yFxlmWL0myf0yzCaY+yhtd7+vqv45yTXm9RhVde8MSw8fV1XPybDcOUk+W8Pepknyosmy6ztk+EV7z+5eq2HvwndlmLX2izPIcp8Ms66ekWEZ5G8n+a3JrKuLMizL+5EMJea/183Cmvcsp8uSPL+7f+qA61+Z4cBx1ge3pyW5fpK7TrZeuGuSdPcrq+rUDF+Hm834MTe0Ct+TSaE+54Bc3znJdHE22SOzqn4jw1L9j281yyaP81tJvjdD+bjxup+fx03+aM5Ndx+17vWXZti7PN09tmXVhzR5vtW6t09f9/qvr7vrKA9SJtsf7NtW5aMZfofs21P/3Kq6f4YTu15FVT02w9+7t2X4uQIArkqHjA45JR1Sh9yUDrl8OqQOCfNW3YsftFy3zOrmsz7YqarXJvlfGZaNnznLjz35+MdkOMHV0kZ7q+r7k9wzyY8tM8ehVFXNIltVPSTD8sgHd/e/VtXpSX4qw36rX5FhptlvJvm1ycysF2aY/XOgV3T32GYuTGXyR3Rnd+/Z9M7TfTzfE662ef7+324m23M8PMkTJzNeGLl5Pf+r6gkZTtT7x939iFl9XIBVs117pA45HR1ydeiQrBId8ko65JFHhxyvpQzKsDVVdVR3X7HsHIswmTF14iyXcLM1vicAALC96JAsk+8JAOzPoAwAAAAAAMAC7Fh2AAAAAAAAgCOBQRkAAAAAAIAF2DaDMlW1e9kZEjkOtAo5ViFDIseB5FitDIkcB5Jjf6uQYxUyJHIAjMWq/B6VY3+rkGMVMiRyHEiO/a1CjlXIkMhxIDlWK0MiB4dv2wzKJFmVJ5Uc+1uFHKuQIZHjQHJcaRUyJHIcSI79rUKOVciQyAEwFqvye1SO/a1CjlXIkMhxIDn2two5ViFDIseB5LjSKmRI5OAwbadBGQAAAAAAgG2runvuD7Lr6FO2/CBraxdlx47jt/QxLvnoq7caI8/7k7/MI//392/pY5x86/tvOcell5+XY4++9pY+xo7UlnNccvl5ucYWcnzuki9uOcMsnhuzIIccq5xBDjm2Q45VyDC2HHsu//jW/9jPwRWf/eBcD0CPut4tVvLzBqa3Mh3y3H/baow874V/nkc+7MFb+hg3/or7bjnHVrtbknzh0gu3nGNt70XZsXNr35e1Lf4fY0x/6+WQY+wZ5JBj1TOMLYcOuRjbZlBmFmYxKDMLsxiUmYVZDMps1SwGZQCAja3sAfWn3z/fA+ob3GolP29geivTIWcwKDMLsxiUmYVZDMrMwlYHZQCAjemQi2H7MgAAAAAAgAXYtewAAAAcYXpt2QkAAADYLkbWIa2UAQAAAAAAWAArZQAAWKy1cc1yAgAAYI5G1iGtlAEAAAAAAFgAK2UAAFioHtl+wAAAAMzP2DqklTIAAAAAAAALYKUMAACLNbL9gAEAAJijkXVIK2UAAAAAAAAW4GqtlKmqnd29d9ZhAAA4AoxsP2BgczokAABX28g65GGtlKmqU6vqtUkuqqrzq+qvqurkg9x3d1WdXVVnr61dNIusAAAAbCM6JAAA7G/qQZmqulmSs5I8N8lJSe6U5Lwk/1hVxxx4/+4+o7tP7+7Td+w4fjZpAQDY/tb2zvcCrAQdEgCAmRhZhzyclTKPT/Kr3f3n3X1+d3+4u3cn+WSSh8wnHgAAANuUDgkAAAc4nEGZ05KcVlUPPGC5+ZlJ7jzTVAAAjFevzfcCrAodEgCArRtZh9x1GPf9fJJrJvmxJM+vqjcleVqSlyX5yzlkAwBgjNYMnMARQocEAGDrRtYhD2elzOuSfLy7vy3JDZI8O8MB9W939555hAMAAGDb0iEBAOAAh7NS5veSvK2q3t/dz0vy0snJGX8/yY/PJR0AAKPTthiDI4UOCQDAlo2tQ049KNPdF1fVNyc5s6p+JckFSW6a5GfnFQ4AAIDtSYcEAICrOpyVMunuc5J8U1WdlOQmSd7X3RfMJRkAAOM0sv2AgYPTIQEA2LKRdcjDOadMkqSqXpnkC919toNpAAAADkWHBACAK206KFODR1VVTa46OclRk9t2VdVj5xkQAICR6bX5XoCl0iEBAJipkXXIaVbK7EzyzCRPnbx9XpJjJ68fk+TXZh8LAACAbUqHBACAg9j0nDLdvaeqPp3krlX1IxkOqL83yXOSnJrko/MMOEs3u+13LTtCkmRX7Vx2hCTJB//oocuOkNs88s+XHSFJ8rlLv7jsCEmSK/buWXaEJMla97IjJElq87ssxGp8NQBGZG3vshMAczSmDnncyd+w7AhJkp07VqNDnv+yn1t2hCTJ3R/xF8uOkA988RPLjpAkuejyS5cdAQDmb2QdctNBmYlLkjwoyWuTrCW5bVXdOsk3J3n+fKIBAACwTemQAACwgWkHZS5OcnmS70ry70l+KsPWZ69P8pL5RAMAYJSc9wWOBDokAACzMbIOOe2gzC8kubS731FVT01yve5+xhxzAQAAsH3pkAAAsIGpBmW6++Xr3nxPkjvMJw4AAKO3Nq5ZTsBV6ZAAAMzMyDrktCtlvqS7X5zkxXPIAgDAkWBkS8+BQ9MhAQDYkpF1yB3LDgAAAAAAAHAkOOyVMgAAsCUjW3oOAADAHI2sQ1opAwAAAAAAsABbWilTVXdMco3ufuOM8gAAMHLde5cdAVgSHRIAgMM1tg651ZUyr0jyo1X17FmEAQAAYNR0SAAAjmhbPafMPbv7/VX1fVW1s9cNWVXV7iS7k6R2Xis7dhy/xYcCAGAUelz7AQOHRYcEAODwjKxDbmmlTHe/f/Lyr/qANUTdfUZ3n97dpzuYBgAAQIcEAOBIt9WVMgAAcHjWxjXLCQAAgDkaWYfc6jllAAAAAAAAmIKVMgAALNbI9gMGAABgjkbWIa2UAQAAAAAAWAArZQAAWKy1vZvfBwAAAJLRdUgrZQAAAAAAABbAShkAABZrZPsBAwAAMEcj65AGZQAAWKy1cR1QAwAAMEcj65C2LwMAAAAAAFgAK2UAAFiskS09BwAAYI5G1iGPqEGZT1103rIjrJRd3/igZUfIzvrLZUdIklyxd8+yIyRJ1rqXHWGl+GoAALBMq3I8undt77IjJEl2nfqty46QJPnoxc9cdoRccsVly44AAGxTR9SgDAAAK2Bk+wEDAAAwRyPrkM4pAwAAAAAAsABWygAAsFgjm+UEAADAHI2sQ1opAwAAAAAAsABWygAAsFDdq3HCagAAAFbf2DqklTIAAAAAAAALYFAGAIDFWlub72UTVfXwqvpEVb2zqu50wG07quoPq+qLVfWW/7+9Ow+39CzLRH8/uyrzyBAwCbMQRKYQEwZRBFvDYCOttn0AOQYbLJvWpoOn9VIbB3BCBNsWuyPVETAKdreac0TjgALaAg5EImEGGZJIQiAkIROppGq954+9YnYqtfdeVbW+9a391u/Hta699pr2XZVQ+e56v+f9quoRg/0+AAAAsLmRO+S8WZQBAOCQUVUnJTkvybOmX8/f6yXflORpSR6V5G+TvHyhAQEAAOiaa8oAALBYbfFnIq1xdpIrWmuXVNXVSV5XVSe31q6aPr8ryXVJLk/yp0m+ZaScAAAAJGN3yLmzKAMAQFeqakeSHWse2tla2zm9f0qSj03vX5XkpiSnTu8nybuTfDHJG5Icn+THBg8MAADAIWPTRZmqOiWr2zjs7aOttb+bfyQAALo28J690wWYnes9nbtu4bsyfewOj0xSSf4uyX9O8qTcuYgDzECHBABgrka47suQZrmmzKOT/N9JTlxzu0eSN230pqraUVUXV9XFk8nNBxUSAICOtMmwt41dmeS06f1Tkhyd5LNrnn9pkje21s5L8l1Jfnzev3w4BOiQAADMz7gdcu5m3b7svklOn96v6dcPVNUbpvdf1Fpbe4bhXc5Q3H74qXd5DgAARvK2JP+jqs5I8uQk701yWlW9urX23Vk91n1OVf1Fkm/IbCcxAXenQwIAwD7Msijz10neleTXk3x/kj9KckySbVndf/uivQ+mAQBgXSOOnrfWrqmqlyS5KMl1SZ6b5KFJHj59ycuT/EaSTyX5dJIXjhATtjodEgCA+els+7JNF2VaazdU1b/M6kH105N8IcmxSW5OclZr7ZXDRgQAgPlprV2Q5II1D12a5MLpc1cm+eYxckEvdEgAAFjfposyVfUtSQ5Lcv/p1y9Ob8cneXxVbW+t7R40JQAA/Rhhz15gcXRIAADmqrMOueEe2VW1kuTsJLuzuv/2F7O6kPPMJE9JcmSSxw2cEQAAgC1AhwQAgI1tOCnTWptU1ceTPCnJG5O8Osknk7x7+pKHJDlu0IQAAPSls/2AgTvpkAAAzF1nHXLDRZmqqiQPS/JTSV6R5H8m+ack77vjJUnOSvKO4SICAACwFeiQAACwsc0mZVpVXZjksUlOT/KqJOck+d2sHky3JB8fOCMAAD3p7Cwn4E46JAAAc9dZh9xwUWbqO5Mcs+b7DyZ5QVYPqLcl+Zokj5x/NAAAALYgHRIAANYxy6LMhUm+dq/HWmvt55Kkqj4291QAAPSr9XWWE3A3OiQAAPOzBB2yqs7J6hT4tUme31p7/5rnVpK8Pslzs3o9xee11j6y3mfNsijzpazuAZysjprfMXJ+h6/er/QAAAD0TIcEAKAbVXVSkvOSPHl6Oz+r10m8wzcleVqSRyX5sSQvT/Jd633eLIsy/5DkW5K8J8lzklyc5Dur6l8n+cfW2g/u96/iEFdjB5h60+k/MXaE/Mphy9HH3nry7rEjJEl+46q/HjtCkmTS2uYvAoAD1dl+wMDd/EN0yLlalqPzq7/1JWNHSJI8/cTxd7/bk+X4b9mFV//92BGSJHv8tx2AIY3/35mzk1zRWrukqq5O8rqqOrm1dtX0+V1JrktyeZI/zeqx8LpWZviBleTbcucZTl+V5PeTvCyrF24EAACAO+iQAABsGVW1o6ouXnPbsddLTklyxxa8VyW5Kcmpa55/d5IvJnlDVidkXr3Rz5tlUuatSR6S5GeTfEWS3VndN+1bk9xSVW9trX3rDJ8DAABLsR8wMCgdEgCA+Rm4Q7bWdibZudFLctcBl5XcdZj5kVk9GenvkvznJE/KnYs4dzPLosxrs3pA/etJvjHJLUn+PslfTp9flt24AADYCsYfPQeGpUMCADA/43fIK5OcNr1/SpKjk3x2zfMvTfLG1tr/rKoPZ3Vi5k3rfdgsizLnJrl3kodndQTnpiTfl9Vx9LTWzt6v+AAAAPTs3OiQAAD0421J/kdVnZHkyUnem+S0qnp1a+27s3rS0XOq6i+SfEM2uWzMposyrbVvrarTkjwjyWeSvCPJLx/ELwAAgEOZ7cugazokAABzNXKHbK1dU1UvSXJRkuuSPDfJQ7N6ElKSvDzJbyT5VJJPJ3nhRp83y6RMWmsfT/LxNQ/dtF+pAQAAOGTokAAA9KS1dkGSC9Y8dGmSC6fPXZnkm2f9rJkWZQAAYG7G3w8YAACAraKzDrnh3mYAAAAAAADMh0kZAAAWq7OznAAAABhQZx3SpAwAAAAAAMACbDopU1Vn7PXQl1trH6mqZ7bW/riqXtNa+08D5QMAoDetjZ0AGJAOCQDAXHXWIWeZlHl7kh9N8rbp1zdPH3/t9Ouz9vWmqtpRVRdX1cWTyc0HHRQAAIAtQYcEAIB1zLIoc3mSFyb51PTr4VX1gCSHTb/Wvt7UWtvZWjuztXbmysoxc4oLAMCWN5kMewPGpkMCADA/nXXIWRZlHpLkD5KcluQPk3xlkouS3H/6ta/ZIQAAAA6GDgkAAOvY9JoyST7RWvvGqnpPa+1pVfW+1toZVfXh1tqjq+ojg6cEAKAfplmgdzokAADz01mHnGVR5j5V9eEkx0+/fnb6+D5HzgEAADik6ZAAALCOWRZlfru19kNJUlUvyOrFGpPkl6rqjCR/N1Q4AAA61Po6ywm4Gx0SAID56axDzrIo86Kqun16//lJnlZVVyd5QpJHtNbOGSwdAAD96Wz0HLgbHRIAgPnprEOuzPCa25J8MMmHktyS5JPT+7+V5DnDRQMAAGAL0iEBAGAds0zKvKa19pYkqapbk/xlkq9KclWSnVX1A621Xx0wIwAAPWlt7ATAsHRIAADmp7MOOcuizM6quuf0/junXx+c5JWttW+sqk8ncUANAABAokMCAMC6ZlmU+ZMku/Z6rCX5g+n9mmsiAAD61tl+wMDd6JAAAMxPZx1ylkWZSvJ9Wd0L+AuttX8+uK6qbZntujQAAAAcGnRIAABYxyyLMn+T5JeTHJHkXlV1XJKPJvm1JDcl+cBg6RjUy65999gRcsox9xo7QpLk0t97+dgRkiRv+fr3jh0hSbJr9+1jR0iSbF/ZNnaEJMnuyZ6xIwD0pbOznIC70SE79YzP3DJ2hCTJl/dcP3aEfPB1zx47QpLkD170/rEjJEn2TG4bOwIAPeusQ266KNNae1lVvTDJbUk+ntUD6DOTPCnJ85L80JABAQAA2Dp0SAAAWN8skzJJ8h+TXJTVEfSHJfmzJI9N8qbW2jsGygYAQI9aX2c5AfukQwIAMB+ddcgN9/KtqrOr6rwk901yYZLzkvx9kpOzuk/wk6vqHoOnBAAAYOnpkAAAsLHNJmU+mNWD6ZuT/GqSJ2R1H+AfTLI7yY8l+bOqekprbTk2lwUAYKm1SRs7AjAcHRIAgLnqrUNuuCjTWrsyyW9Ob6mqxyV5QZKjW2vXJfnpqnqXg2kAAAB0SAAA2Nis15RJkrTWLklyyV6PvXOuiQAA6Nukr/2AgfXpkAAAHLTOOuSG15QBAAAAAABgPvZrUgYAAA5a6+ssJwAAAAbUWYe0KAMAwGJ1dpFGAAAABtRZh9zv7cuqatsQQQAAAOiPDgkAAHeaeVGmqk6vqr9IcnNVfamq/ndVnTJcNAAAujSZDHsDloIOCQDAXHTWIWdalKmqByW5KMnrk9w3yWOTXJ/kT6vqiHXes6OqLq6qiyeTm+eTFgAAgKWnQwIAwL7NOinzQ0l+srX22621L7XWPtNa25Hkc0mev683tNZ2ttbObK2dubJyzLzyAgCw1XV2lhOwTzokAADz0VmHnHVR5owkZ1TVt+01bv6mJI+beyoAAAC2Mh0SAAD2YdZFmWuTHJ/k3yX5YFX9WVU9Pclbk/zgUOEAAOhQa8PegGWgQwIAMB+ddchZF2XeleSzrbWnJ7lPkvOSvCbJL7TWdg8VDgAAgC1JhwQAgH3YPuPr/muSS6vqE62185NcOL04468k+feDpQMAoD+u+wKHAh0SAID56KxDzrQo01q7par+RZI3VdVPJLkhyQNi7BwAAIC96JAAALBvs07KpLV2WZKnVdV9k9w/ycdbazcMlgwAgD5NXPcFDgU6JAAAc9FZh5x5UeYOrbWrk1w9QBYAAAA6o0MCAMCd9ntRBgAADkrraz9gAAAABtRZh1wZOwAAAAAAAMChwKQMAACL1dl+wAAAAAyosw5pUWYEy/Kv0K7dt40dIV/48vVjR0iS3O9pPzx2hCTJF1777LEjJEme/Ir3jR0hSXLD7i+PHSFJctkNtkAHmKc26Wv0HOBQ8YkvfXbsCEmSexx57NgR8rDv/72xIyRJvvBrzx07QpLk4ef+4dgRkiRfvPXGsSMkSXbtvn3sCABd6a1D2r4MAAAAAABgAUzKAACwWJ2NngMAADCgzjqkSRkAAAAAAIAFMCkDAMBitb72AwYAAGBAnXVIkzIAAAAAAAALYFIGAIDF6mw/YAAAAAbUWYc0KQMAAAAAALAAJmUAAFisSV/7AQMAADCgzjqkSRkAAAAAAIAFMCkDAMBidbYfMAAAAAPqrEPOPClTVUdNv/7gcHEAAADogQ4JAAB3tz/bl31y+vU/zfLiqtpRVRdX1cWTyc37nwwAgD61ybA3YFnokAAAHLzOOuSBXFOmZnlRa21na+3M1tqZKyvHHMCPAQAAoAM6JAAATG16TZmq+sj07klV9eEk955+TVYPrluSR7XmtEQAAGbQ2X7AwF3pkAAAzFVnHXLTRZkk35zk1iQfTPL1ST48/frPHEwDADCrNnHoCJ3TIQEAmJveOuQs25c9J6sH00cnOTLJpLX2xbW3QRMCAACwleiQAACwjlkmZT6Q5PQkz0/yH5J8YshAAAB0rrPRc+BudEgAAOansw654aJMVVWS/5TksUn+d5Ibk7y9qn5i7etaa68cLCEAAABbgg4JAAAb23BRprXWknxrVZ2V5I1J9iR5bVYvzggAAPuvs7OcgDvpkAAAzF1nHXKW7cvSWntvVT0xyb9L8ukkX9Fa+52qun+SBw4ZEAAAgK1FhwQAgH2baVEmSVprN1XVnyf5ySRfmeR3kvxAVs94etcw8QAA6E6bjJ0AWAAdEgCAueisQ65s9oKqek1VPXX67VOS/M308QcneV6Snx8qHAAAAFuLDgkAAOvbdFEmydlJfquqdiR5YZKLkhyW5C1Jvre1dt1w8QAA6M6kDXsDxqZDAgAwP511yFm2L9ud5BuTvCPJZUnul+TkJJ9P8siqemRr7Zc2+oBluaLjcUccPXaEJMnRhx0xdoQkyXW33jR2hNw+2TN2hCTJBceeNXaEJMkP/8Lnx46QJLm9Lcc/l12T28aOkGR5/gxbBv6qEwCYwUF3SJbTnslybB1y257dY0fIx559ytgRkiTf+fJLx46QJDnlyHuNHSFJcvUt148dAQA2teGiTFV9Z5LjszpRU0mOy+oZTjV971FDBwQAoC/NNAt0S4cEAGDeeuuQm21fdlyS+yf5wyTfm+TKJF9KctX0vX/bWvvZQRMCAACwVeiQAACwgQ0XZVprb0jyrKye2fTeJL+S5NuS3JbkuUleX1X3HDokAAAd6Ww/YOBOOiQAAHPXWYfcbFImrbW3Jzk/yc9mdU/gx08fvyzJm5L8xID5AAAA2EJ0SAAAWN+G15RZ4+eSHN1au7WqXpzkEdPHfzXJGYMkAwCgT0tyoWhgUDokAADz0VmHnGlRprW2J8mN0/sfSfKR6f3rkrx9sHQAAPTHFmPQPR0SAIC56axDbrp9GQAAAAAAAAdv1u3LAABgPjo7ywkAAIABddYhTcoAAAAAAAAsgEkZAAAWqrW+znICAABgOL11yE0nZarqjL1uj5g+/szp19cMHRIAAICtQYcEAID1zbJ92duT/GiSt02/vnn6+GunX5+1rzdV1Y6quriqLp5Mbj7ooAAAdGLShr0BY9MhAQCYn8465CyLMpcneWGST02/Hl5VD0hy2PRr7etNrbWdrbUzW2tnrqwcM6e4AAAALDkdEgAA1jHLNWUekuQPkpyW5A+TfGWSi5Lcf/rV6YgAAMzONAv0TocEAGB+OuuQs0zKfKK19o1JPtxae1qSj7TWHp3kU9Ov+zzLCQAAgEOSDgkAAOuYZVHmPlX14SQPmH794vRxB9IAAOy3NmmD3jZTVedU1VVV9aGqeuw+nn9hVV1eVVdU1fcN8psAfdMhAQCYm7E75LzNsn3Zb7fWfihJquoFWb1YY5L8UlWdkeTvhgoHAADzVFUnJTkvyZOnt/OTnLXm+Udl9WLkT09ybZJTR4gJW50OCQAA65hlUeZFVXX79P7zkzytqq5O8oQkj2itnTNYOgAA+jPufsBnJ7mitXbJ9Jj2dVV1cmvtqunz5yR5c2vt4un3nxolJWxtOiQAAPNzCF5T5rYkH0zyoSS3JPnk9P5vJXnOcNEAAGDuTknysen9q5LclLtOwzwkyVFV9dHp9mVPX3RA6IAOCQAA65hlUuY1rbW3JElV3ZrkL5N8VVZL7M6q+oHW2q8OmBEAgJ5Mhv34qtqRZMeah3a21nZO77fc9cSkleljdzgqyQOSPDXJS5P8cpJHDJUVOqVDAgAwPwN3yEWbZVFmZ1Xdc3r/ndOvD07yytbaN1bVp5M4oAYAYCZDX0hxugCzc52nr0xy2vT+KUmOTvLZNc9fnuSW1trnqur3kpw7VE7omA4JAMDcDN0hF22WRZk/SbJrr8dakj+Y3q+5JgIAgOG8Lcn/mF5s/MlJ3pvktKp6dWvtu5P8TpLzq+q1SZ6b5JLxosKWpUMCAMA6ZlmUqSTfl9W9gL/QWvvng+uq2pbZrksDAACrRjzLqbV2TVW9JMlFSa7L6sLLQ5M8fPqSdyR5Y5JLszpB84IxcsIWp0MCADA/h+CkzN9kdS/tI5Lcq6qOS/LRJL+W1QujfmCwdHN2w65bxo6QZHlyLIOVWo6T5Hbc+v6xIyRJHrhyn7EjJEn2tOXYqPFjL3302BGSJPd81bvGjpA9k+X4Z7Ic/4+968UfAPZXa+2CJBeseejSJBdOn2tJXjm9AQemmw7Jcrr59lvHjpDn/sXhY0dIkpxd9xg7QpLk3YdtGztCkuTRX/HEsSMkSd505XvGjsBedEhgmWy6KNNae1lVvTDJbUk+ntUD6DOTPCnJ85L80JABAQDozHKsMwMD0SEBAJirzjrkLJMySfIfs7rFw/cleViSP0vy2CRvaq29Y6BsAAAAbE06JAAA7MOGe/lW1dlVdV6S+2Z1S4fzkvx9kpOzuovNk6uWZFYWAIAtoU3aoDdgPDokAADztgwdsqrOqaqrqupDVfXYfTz/wqq6vKquqKrv2+izNrvA4geTvCfJW5L8apI3J7k8ybOTnJHV/bf/rKqOnik5AAAAPdMhAQDoSlWdlNWTjZ41/Xr+Xs8/Kslrk3x7km9I8uGNPm/D7ctaa1cm+c3pLVX1uCQvSHJ0a+26JD9dVe9qrblyPQAAs+lsP2DgTjokAABzN36HPDvJFa21S6rq6iSvq6qTW2tXTZ8/J8mbW2sXT7//1EYfNus1ZZIkrbVLklyy12Pv3J/PAAAA4NCgQwIA0IFTknxsev+qJDclOXV6P0kekuTaqvpokmOSvLi19qfrfdh+LcoAAMDBct0XAAAAZjV0h6yqHUl2rHloZ2tt59oIueulYFamj93hqCQPSPLUJC9N8stJHrHez7MoAwAAAAAAHJKmCzA7N3jJlUlOm94/JcnRST675vnLk9zSWvtcVf1eknM3+nkrGz0JAABzNxn4BgAAQD/G75BvS3JqVZ2R5NuTvDfJaVV1wfT530nybVV1apLnZq/te/dmUgYAAAAAAGAfWmvXVNVLklyU5LqsLrw8NMnDpy95R5I3Jrk0qxM0L9jo8zZdlKmqB2zykqtaa7dv9jkAAJAkzTQLdE2HBABgnpahQ7bWLkhywZqHLk1y4fS5luSV09umZpmU+XBWh3g+l+SYJJ9f89xhSW5M8qS937T24jgr207Iysoxs+QBAKB3S3BADQzqoDtk6ZAAANyhsw45y6LMJUluT/LjSb6utfYLa5+sqiv29aa1F8c57PBT20HmBAAAYGs46A65XYcEAKBTsyzKnJBkd5LTk6Sq/iTJHePo1yd5zhDBAADo0zKMngOD0iEBAJib3jrkygyveX+SDyV5wvTrsUl+OsnPJJm01t43XDwAAAC2GB0SAADWMcukzE1J7hgdvyWrO7jtmn7f2RoVAACDcwQJvdMhAQCYn86OIGdZlPm6rI6eX5Dk0Vn9LfjF6XMrVfXc1tr/HCgfAAAAW4sOCQAA65hlUeb6rF6k8e+TnN5ae+qQgQAA6Ftv+wEDd3N9dEgAAOaktw45y6LM6Vk9s+n1SY6pqhfs/YLW2uPnnAsAAICt6fTokAAAsE+zLMo8Osn/leSPk9yQ5Owkf5nk1gFzAQDQqd7OcgLuRocEAGBueuuQmy7KtNY+U1XfleSvkrw2yUqSxyf58PQllyS5bLCEAAAAbBk6JAAArG/TRZmqemSSI5M8JMm2rB5Qb09yWJJK8l+yOp4OAACb6u0sJ+CudEgAAOaptw45y/Zlv5rk5CQvS3JRVg+k/yrJ32b1gPr0ocIBAACw5eiQAACwjlm2L3taVX0gyUuTPCNJS/LVSV6dZEdr7bmbfcbh2w872Jxzcdvu28eOkGT1N5BVk7YcvxsrVWNHSJIcXtvGjpAkuXbXDWNHSJI8beeVY0dIkjz+XqeNHSHP2P4VY0dIkpx34/vHjpAkufqm68aOkCRZWVkZO0KSZM9k/FNGti3J70VlOf48ZxPNPyfo2Tw6JGxkGY59Tlw5YuwISZLzb/3E2BGSJNfuunHsCEmSI7ctx98/1RL8HcM/3O+xY0dIknzNlR8cO0KSZPee3WNHSOLvBOGAddYhZ/0blJbk+iSfnH5/S5LntdbeM0QoAAAAtjQdEgAA9mGWa8q8M6v7Ab9u+tDxSW5PclaS7xkuGgAAPeptP2DgrnRIAADmqbcOOcs1Ze6X5F9kde/fP01y9vT+Hw6YCwCATrVJX6PnwN3okAAAzE1vHXKWRZmTkvxUVg+i77vm/v2q6pmttT8eLB0AAABbjQ4JAADrmGVR5lvW3D9/r/uXzTcOAAC96230HLgbHRIAgLnprUNuuijTWnv3IoIAAACw9emQAACwvlkmZQAAYG5a62s/YAAAAIbTW4dcGTsAAAAAAADAocCkDAAAC9XbfsAAAAAMp7cOaVIGAAAAAABgAWaalKmqI5Kc2Fq7es1jT0jygdbaLUOFAwCgP23S137AwN3pkAAAzEtvHXLWSZn7J3nbHd9U1TFJdiY5dr03VNWOqrq4qi7evfvGg0sJAADAVnJQHXIyuXkBEQEAYPE2nZSpqhcneVCSB1fVTyU5Jsmjk9yS5JQkn9/X+1prO7N60J1jjn5Qm09cAAC2uubIELo2jw65/fBT/UkBAECS/jrkLJMyLclt09fenOSyJA9N8o4kvztcNAAAALYgHRIAANax6aRMa+3Xk6Sq/kNr7Ren95+T5FVJzhk2HgAAveltP2DgrnRIAADmqbcOuemizBprp2r+PMlFSf5mvnEAAOhdbwfUwLp0SAAADlpvHXJ/FmUevub+LyX5SJJ3zzcOAAAAndAhAQBgL5suylTVi5IcmeTTVfWZrF6U8XVJrktyeOwJDADAfujtIo3AXemQAADMU28dcpZJmS8leUSSr09y/yT3y+qFGz+d5Ig4oAYAAOBOOiQAAKxj00WZ1trvxkEzAABz0tt+wMBd6ZAAAMxTbx1yZfOXAAAAAAAAcLBm2b4MAADmprW+znICAABgOL11SJMyAAAAAAAAC7CQSZldu29fxI+BA/b5m68fO0KS5Eu7bhk7QpJk1+7bxo6QJKlajlXwa265YewI+fP3v3zsCEmSn/ua7xk7QpLk8O2HjR0hif++rbVnMhk7AltI868LAFvc71z13rEjsA9HLElPmLQ2doQ87G9fN3aEJMmeU58ydoQkybaVbWNHSJLsnuwZOwJsSb11SJMyAAAAAAAAC+CaMgAALNSks/2AAQAAGE5vHdKkDAAAAAAAwAKYlAEAYKFaZ2c5AQAAMJzeOqRJGQAAAAAAgAUwKQMAwEK1SV9nOQEAADCc3jqkRRkAABaqtbETAAAAsFX01iFtXwYAAAAAALAAJmUAAFio3kbPAQAAGE5vHXLTSZmqeuIiggAAALD16ZAAALC+WbYve09Vvb2qThs8DQAA3Zu0GvQGjE6HBABgbnrrkLNuX/bfkvxJVV2W5E+SfDTJ55Psaq29b19vqKodSXYkSW07ISsrx8whLgAAAFuADgkAAPswy6JMa61dWFVvTfKsJN+W5PlJ7p/kmCRHrPOmnUl2Jsn2w09t84kLAMBW10yzQO90SAAA5qa3DjnLokwlSWttd5K3Tm8AAACwLzokAACsY5ZFmVcMngIAgENGc/479E6HBABgbnrrkCubvaC15oAaAACAmeiQAACwvlkmZQAAYG4mne0HDAAAwHB665CbTsoAAAAAAABw8EzKAACwUK2zs5wAAAAYTm8d0qQMAAAAAADAApiUAQBgoVobOwEAAABbRW8d0qIMAAAL1dtFGgEAABhObx3S9mUAAAAAAAALYFIGkizLBNytu28bO8JSueaWG8aOsDSuet7PjR0hSXLfo+8xdoQkyWu2P2LsCEmS51//rrEjJEl2T/aMHQH2S28XaQQAlsOu3bePHSFJslLjH+v81SN/ZOwISZIfOfkbxo6QJPlIu2nsCEmSt1/74bEjJElu2HXL2BFgv/TWIU3KAAAAAAAALIBJGQAAFqq3/YABAAAYTm8d0qQMAAAAAADAApiUAQBgoZblWm4AAAAsv946pEkZAAAAAACABTApAwDAQvW2HzAAAADD6a1DmpQBAAAAAABYAJMyAAAsVOvsLCcAAACG01uHNCkDAAAAAACwAAc8KVNV90hydGvts3PMAwBA5yZjBwBGoUMCAHAgeuuQBzMp89tJ3jWvIAAAAHRNhwQA4JB3MNeU+a4kR633ZFXtSLIjSWrbCVlZOeYgfhQAAL1o6Ws/YGBmOiQAAPuttw55wIsyrbUvbvL8ziQ7k2T74ae2A/05AAD0ZeLIEA5JOiQAAAeitw55MNuXAQAAAAAAMKOD2b4MAAD226Sz0XMAAACG01uHNCkDAAAAAACwACZlAABYqN4u0ggAAMBweuuQJmUAAAAAAAAWwKQMAAALNRk7AAAAAFtGbx3SpAwAAAAAAMACmJQBAGChetsPGAAAgOH01iFNygAAAAAAACyASRkAABaqt/2AAQAAGE5vHdKiDMAWcN+feebYEZIku7/7jWNHSJK8euXKsSMAAADs06S1sSPkSW/42rEjJEme/Z2/PHaEJMlZ93zo2BGSJDfsumXsCEmyNBtBjf//FBiHRRkAABaqt7OcAAAAGE5vHdI1ZQAAOKRU1TlVdVVVfaiqHrvOa15SVa2qHrTgeAAAAHTMpAwAAAvVRtwwoapOSnJekidPb+cnOWuv15yY5IeTXLfofAAAANzVmB1yCBZlAABYqMm4x9NnJ7mitXZJVV2d5HVVdXJr7ao1r/nxJBcm+Y5REgIAAPDPRu6Qc2f7MgAAulJVO6rq4jW3HWuePiXJx6b3r0pyU5JT17z3YUmel+RnFhYYAACAQ4ZJGQAAFmoy8Oh5a21nkp3rPZ27npi0Mn3sDq9J8orW2nVVnZ2OBQAAsAUN3SEXzaQMAACHkiuTnDa9f0qSo5N8Nkmq6vgkT0/y6qq6PskDklxaVSeMkBMAAIAOWZQBAGCh2sC3TbwtyalVdUaSb0/y3iSnVdUFrbUbWmtHttZOaK2dmOTyJI9prX1pHr9uAAAA9t/IHXLuLMoAAHDIaK1dk+QlSS6afn1xknsnefiYuQAAAFheVXVOVV1VVR+qqseu85qXVFWrqgdt9FkHdU2ZqnpKa+3/HMxnAABwaJmM/PNbaxckuWDNQ5cmuXAfr3vQojLBoUKHBABgf43dIavqpCTnJXny9HZ+krP2es2JSX44yXWbfd6mkzJV9diq+suquryqfr+qnrzm6XfuR3YAAAA6p0MCANCZs5Nc0Vq7JKsn9J1ZVSfv9Zofnz53w2YfNsv2ZW9KckWS/5DkQ0kuqqofmT5X672pqnZU1cVVdfFkcvMMPwYAgEPBpGrQGzC6N0WHBABgTobukGuPQ6e3HXtFOCXJx6b3r0pyU5JT73iyqh6W5HlJfmaWX88s25c9IMkzWmtXJ/n9qjovyR9V1SOT3Lbem1prO5PsTJLth586xvVyAAAAWDwdEgCALWPtceh6L8ldB1xWpo/d4TVJXtFau65mOFFwlkmZi5J875qAVyT5+iQPTHLYDO8HAIB/1ga+AaPTIQEAmJsl6JBXJjltev+UJEcn+WySVNXxSZ6e5NVVdX1WT1C6tKpOWO/DZlmU+f4k7177QGvt+iTfnORH9vUGAAAADlk6JAAAPXlbklOr6owk357kvUlOq6oLWms3tNaObK2d0Fo7McnlSR7TWvvSeh+26fZlrbUbs4+LMbbWdiX5xQP8RQAAcIiajB0AGJQOCQDAPI3dIVtr11TVS7I6EX5dkucmeWiShx/I581yTRkAAAAAAIBDUmvtgiQXrHno0iQX7uN1D9rssyzKAACwUJPNr3sIAAAASfrrkBZlAABYqEk6O6IGAABgML11yJWxAwAAAAAAABwKTMoAALBQbewAAAAAbBm9dUiTMgAAAAAAAAtgUgYAgIXq7SKNAAAADKe3DmlRBmATR24/fOwIOf8l7xs7QpLkccc+cOwISZLvue34sSMkSV58+JVjR0iS3Hjbl8eOkD2TydgRAOjISi1H85603jbLABbhzHs/bOwIeeQ5vzF2hCTJu096zNgRkiQvuPXzY0dIkjzu3l85doQkyUeuv2LsCEmSXbtvGzsCjMKiDAAAC2UJDwAAgFn11iFdUwYAAAAAAGABTMoAALBQNgMCAABgVr11SJMyAAAAAAAAC2BSBgCAhZosx/W7AQAA2AJ665AmZQAAAAAAABbApAwAAAs1GTsAAAAAW0ZvHdKkDAAAAAAAwAKYlAEAYKF6O8sJAACA4fTWIS3KAACwUK2zizQCAAAwnN465Ibbl1XVA2b5kFlfBwAAQL90SAAA2NhmkzKfTrJths+52+uqakeSHUlS207IysoxBxQQAIC+9DZ6DtzFXDrktm0nZmWbDgkAQH8dcrNFmaqqT232muntLlprO5PsTJLth5/aDiweAAAAW8hcOuThR9xPhwQAoEsbLsq01jbc3gwAAPZXb2c5AXfSIQEAmLfeOqQDZgAAAAAAgAXYbPsyAACYK3sSAQAAMKveOqRJGQAAAAAAgAUwKQMAwEJN7nZ5bwAAANi33jqkSRkAAAAAAIAFMCkDAMBCTcYOAAAAwJbRW4c0KQMAAAAAALAAJmUAAFio3s5yAgAAYDi9dUiTMgAAAAAAAAtgUgZYWjV2gKnbJ7vHjpA37/mnsSMkSS675fNjR0iSvOXcx44dIUly8y/sGjtCkuR+x540doRcfsPVY0dgC2ljBwCW3qT5kwLYuj5w/WfGjpD7Hn2PsSMkSZ5yzQfHjpAk+ez3PnLsCEmSe513ydgRkiTfdN/HjB0hSfK2z71/7AhL83dPbKy3I0OLMgAALNRE8wEAAGBGvXVI25cBAAAAAAAsgEkZAAAWqreLNAIAADCc3jqkSRkAAAAAAIAFMCkDAMBC9XaRRgAAAIbTW4c0KQMAAAAAALAAJmUAAFioSXfnOQEAADCU3jqkSRkAAAAAAIAFMCkDAMBCTcYOAAAAwJbRW4c0KQMAAAAAALAAMy/KVNW5VXVWVa1U1UVVdW1VnTNkOAAA+tMGvgHLQYcEAGAeeuuQ+zMp88NJbkzy/CSHJ/m+JD+/3ourakdVXVxVF08mNx9cSgAAALYaHRIAAPayP9eUaUnOTvL9Sf5NkquzwaJOa21nkp1Jsv3wU520CABAkv72AwbWpUMCAHDQeuuQ+zMpc26SFyf5zdba+5M8J8lvDhEKAACALe/c6JAAAHAX+zMp89Ek70lyVlW9Nfu3oAMAAEmSSY2dAFgQHRIAgIPWW4fcn0WZtyb5ZJJ3J7ltmDgAAPRuMsqlFIER6JAAABy03jrk/izK3JbkBa21zw0VBgAAgG7okAAAsJf9WZQ5N8nrq+r31j7YWrtgrokAAOhaX+c4ARs4NzokAAAHqbcOuT+LMj+Q5F8keVDuHD1vSRxQAwAAsDcdEgAA9rI/izJnJfnq1tqnhgoDAED/JmMHABZFhwQA4KD11iFX9uO1/z3Jt1TVcVV1/B23oYIBAACwpemQAACwl/2ZlNmR5CuS/PL0+8rq6Pm2OWcCAKBjk+52BAbWoUMCAHDQeuuQ+7Mo86TBUgAAANAbHRIAAPYy86JMa+2yA/0hK1UH+ta5mrS+VtSgd8vy/9h7HHns2BFy9a7rxo6QJLl1922bv2gBvvD/XTN2hCTJMYcdMXaEJMk3HPuQsSPkt278/NgRkiS1JMccbGxZ/nwHhnUwHfKwbftz/uBwbt+ze+wIwBZ0/OFHjx0hu/YsR3c7YvthY0dIknzm98dOsGoZ/n5hmWxfGX94dhkysLneOuT+XFMGAAAAAACAA7Qcpx8BAHDImIwdAAAAgC2jtw5pUgYAAAAAAGABTMoAALBQk+52BAYAAGAovXVIkzIAAAAAAAALYFIGAICF6uscJwAAAIbUW4e0KAMAwEL1dpFGAAAAhtNbh7R9GQAAAAAAwAKYlAEAYKFad8PnAAAADKW3DmlSBgAAAAAAYAE2nJSpqp+Y9YNaa688+DgAAPSut/2AgTvpkAAAzFtvHXKz7ct+KskLk9Qmr3tDkrscUFfVjiQ7kmTbthOzsu2YA0sIAADAVvFTmUOH3L79ntm+/dgB4gEAwLg2W5T5jdbaBZt9SFU9de/HWms7k+xMksOPuF9fm74BAHDAJp3tBwzcxVw65FFHPdAfFAAAJOmvQ254TZnW2vfM8iGzvg4AAIB+6ZAAALCxzSZlAABgrvo6xwkAAIAh9dYhN5yUAQAAAAAAYD5MygAAsFC97QcMAADAcHrrkCZlAAAAAAAAFsCkDAAACzUZOwAAAABbRm8d0qQMAAAAAADAApiUAQBgoVpn+wEDAAAwnN46pEUZAAAWqrfRcwAAAIbTW4e0fRkAAAAAAMACLGRSprW+xouAQ8tf3OfBY0fIN1z9qbEjJEkefvz9xo6QJHncP3567AhJktsmu8eOkCTZlho7QqrGz5AszzHHsuRYVr2NngPzN2m9nQ8JHEq+9cRHjh0hb7jyPWNHSJIcffiRY0dIkjz58x8aO0KSZNee28eOkCR581m3jB0hSfIVF43fC/Y45tgSeuuQJmUAAAAAAAAWwDVlAABYKOeiAQAAMKveOqRJGQAAAAAAgAUwKQMAwEJNXHMHAACAGfXWIU3KAAAAAAAALIBJGQAAFqqvc5wAAAAYUm8d0qQMAAAAAADAApiUAQBgoSbdnecEAADAUHrrkCZlAAAAAAAAFsCkDAAAC9U6O8sJAACA4fTWIWealKmqo6rq6H3cjho6IAAAfZkMfNtMVZ1TVVdV1Yeq6rF7PfdVVfXOqrqhqi6qqnsc7K8XDkU6JAAA8zJ2h5y3WSdlPpZkd5Kafn/H0tRhVfUPrbVn7/2GqtqRZEeSrGw7ISsrxxxsVgAAOChVdVKS85I8eXo7P8lZa17y7CS/muSSJG9N8oNJfnzBMaEHB9Uht20/Mdu2HbuQoAAAsEizLspUa+0h//xN1fckuU+SVyf56L7e0FrbmWRnkhx2+Kl9zRcBAHDARr5I49lJrmitXVJVVyd5XVWd3Fq7Kklaa794xwur6s+TPHiknLDVHVSHPOLI++uQAAAkGb1Dzt1M25flzrOaUlXnJjk3yZtbay3J6+cfCwAABnFKVs/gT5KrktyU5NS9X1RVleTxWZ2YAfafDgkAAPuw6aRMVf1kkuOr6vuTPCTJo5N8fWvthiRprf3SsBEBAOjJ0BdpXLsF0tTO6Rn4qz/+ricmrST7DPStSR6e5NcHCQkd0yEBAJinoTvkLKrqnCSvSnJtkue31t6/5rmvyuo22V+T5K+SvKC1dt16nzXLpMzNWS2qp2T1YPpBSb72QMMDAMCQWms7W2tnrrntXPP0lUlOm94/JcnRST679v1VdUaSNyb516216xeRGTqjQwIA0I011yZ91vTr+Xu95I5rk56e5IFZvTbpujZdlGmtvSbJTa21/9xaOzvJc5P8SlU9Y7/TAwBwyJsMfNvE25KcOl14+fYk701yWlVdkCRV9ZAkf5TkR1pr75zDLxcOOTokAADzNHKHTNZcmzTJhUnOrKqT73iytfaLrbXfa619Ksmm1ybd72vKtNbel+Q7srr6AwAAW0Zr7ZokL0ly0fTri5PcO6tblSWrZzfdN8nrqqpV1fhz8rA16ZAAAGwJVbWjqi5ec9ux10vmem3STa8pM7VSVZ/fx8/4ziRprd1nxs8BAOAQt3qd71F//gVJLljz0KVZPdsprbVnjRIK+qNDAgAwF0N3yOmW1zs3eknmeG3SWRdlHrjO49+V5K9n/AwAAAAODTokAAC92J9rk37HZtcm3XT7sqp6VZJ/m+QJSVZaa3taa3uSvDzJzyY5dj9/AQAAHMImaYPegHHpkAAAzNMSdMi5Xpt0lkmZ65N8XZIdSR5UVf9vkqOSPDTJ41trV82SGgAAgEPC9dEhAQDoRGvtmqq649qk1yV5blaPbfd1bdLXT99T633eposyrbVX3XG/qu6X5IVJfjDJLzqYBgBgf03GDgAMSocEAGCelqFDzvPapDNdU6aqTkry35K8ubX2M1X1v5L8QVXtaa29erP33++4e+9PpsFcceM1Y0cA9sO6y8kLdo9Tbhk7Qq79zI1jR0iSXL/r5rEjJEkmk2X4z3GybWXb2BGSJP+4+/qxI+SYw44cO0KS5NglyWELLeBQd7Ad8qtOvP/gGWfxoWsvGzsCbAnL0t2W5QhszxIkqVqOfyp7lqS77Z7sGTtCkuSwlVkv7z2sHRefMHaEJMkpx9xz7Ai59xHL8XtRS/MnKYswyzVlHprkH5J8LMmfVNVKVi/O+PQkP1ZVDxs0IQAAXWkD/w8Ylw4JAMA89dYhZ1me/VSSp7XWPn7HA1X1NVm9mM15Sb4pySeGiQcAQG9MEkH3dEgAAOamtw45y6LMTyU5oqqOTHLH7dQkL0vyjNba7uHiAQAAsMX8VHRIAADYp1kWZa5LcluSLye5dfr1t7N6htMjknxgsHQAAHSntb7OcgLuRocEAGBueuuQmy7KtNb+y74er6ofygzXpAEAAODQoUMCAMD6ZpmU2afW2u/OMwgAAIeGydgBgFHokAAAHIjeOqSzlAAAAAAAABbggCdlAADgQLT0tR8wAAAAw+mtQ5qUAQAAAAAAWID9mpSpqvu01j4/VBgAAPo36ewsJ2B9OiQAAAertw656aRMrXpbVT05yS9W1RELyAUAAMAWpEMCAMD6Nl2Uaa21JE9M8pEk25KclSRVdURV/W1VHb6v91XVjqq6uKouvvHWL84zMwAAW1hrbdAbMK55dMgv3nL14gIDALDUeuuQs15T5ktJHpPkB1pr75o+dnqSB7XWbtvXG1prO1trZ7bWzjzuyHsdfFIAAAC2ioPqkPc6+r4LigkAAIs166LMNUl+Kckxax77kSRvnnsiAAC6Nkkb9AYsBR0SAIC56K1Dbp/xdVdn9eD5XVX1wSQPS3JLkn87VDAAAAC2LB0SAAD2YdZFmc8l+UKSRyV5apKbk/x1a23XQLkAAOhUM80ChwIdEgCAueitQ+7PpMwDWms3J7lowDwAAHRuMsKFIg6bTQAAC8hJREFUFIGF0yEBAJiL3jrk/lxT5gFDBgEAAKAbOiQAAOzDrJMybxw0BQAAh4y+znEC1qFDAgAwF711yJkWZVpr1wwdBAAAgD7okAAAsG+zTsoAAMBcTLo7zwkAAICh9NYhZ72mDAAAAAAAAAfBpAwAAAvV21lOAAAADKe3DrmQRZkHHnXSIn7Mpq640bbGa73olK8dO0LeefOnx46QJPn0l64aO0KSZNvKtrEjJElOO/HUsSMkSa685YtjR0iSPOqS8f/9qKqxIyyVZflPcVuSJH937SfGjpDjDz967AhJkiO3HTF2hCTJnjYZOwLAlnb6kSePHSFJ8qFcNnYE2BKW46h4eVx0/YfHjrA0f7+we7Jn7AhJkj1LkmNZfODLV44dIUnyoKPuM3aEHL+yHB2SQ4tJGQAAFqo1f3UDAADAbHrrkK4pAwAAAAAAsAAmZQAAWKje9gMGAABgOL11SJMyAAAAAAAAC2BSBgCAhWqdneUEAADAcHrrkCZlAAAAAAAAFsCkDAAAC9VaX2c5AQAAMJzeOqRFGQAAFqq3izQCAAAwnN46pO3LAAAAAAAAFsCkDAAAC9Xb6DkAAADD6a1DmpQBAAAAAABYgANalKmqZ1fVf6mqb9ngNTuq6uKquvjKmz974AkBAOjKJG3QG7B89rdDfvzGTy8yHgAAS6y3Drnpokytel5V1fT7f5XkVUmuTvKaqnrevt7XWtvZWjuztXbmKcecOs/MAAAALKl5dMjTjnvw4gIDAMACzXJNmUryxiRPSHJuku9J8rIkf57kqCT/T5LfHigfAACdaaZZoHc6JAAAc9Nbh9x0Uqa1Nkny+SSPqaofT3LPJO9J8qNJHpbk5EETAgAAsGXokAAAsL5ZJmWSZJLkO5K8K8l9k9w7yelJ/n2Stw+SDACALk1aX2c5AfukQwIAMBe9dchNJ2Wmbk+yK8mzktyW5LuT/F6SDyT5w2GiAQAAsEXpkAAAsA+zTsr8cZIjW2uXVdW/zOpewM9J8ojW2nWDpQMAoDu97QcM7JMOCQDAXPTWIWealGmtvbS1du30/vuSvCDJUxxMAwAAsDcdEgAA9m3WSZkkSVUdleTY1tofJfmjYSIBANCz3vYDBtanQwIAcLB665CzXlPmDi9L8vI7vqmql1XV31fVEfONBQAAQAd0SAAAWGPmSZmqOinJv09yxvT7M5K8Ism/bK3tGiYeAAC96W0/YGDfdEgAAOahtw65P5MyNyV5fpIXVdW1Sf4mye4kf1xVLx4iHAAA/Zm0NugNWBo6JAAAB623Drk/15T5xiQnJHl1kldl9YD66UkeleTXk5y/3hufsP2kg4g4P++pj44dIcny7IH361e+Z+wI7GXPZM/YEZIkH7728rEjJEm2rezvDov9WpY/N+579AljR0iSXH3z9WNHSJJ8830eM3aEJMmffu4fxo6Qex533NgRkiQnH37i2BGSJCupsSMALIMD7pD3ymGLyLepZTkenUwmY0dYKstxZLwctq9sGztCkuXpsodvX44/O6655UtjR1gaK0vy5+iy/LlRtRw94R+vv3LsCEmSx5186tgRcnuW47+xu9py5GAxZlqUqap/neSxSR7SWnvL9LHLknxLkl1Jrh0sIQAAXelt9By4Ox0SAIB56a1Dzjopc2KSs5I8tapuyOqZTj+a5PVJjkly7hDhAAAA2JJOjA4JAAB3M9OiTGvt/Kp6Y5Irk3wyyd8l+e9Jntlau33AfAAAdGZZtmQEhqNDAgAwL711yP3Z2PGwJLe21l6T5Iwkz0zybwZJBQAAwFanQwIAwF5m3b4sWd339+FJ0lq7oqq+rrV22zCxAADoVW/7AQPr0iEBADhovXXImRdlWmstya1rvncwDQAAwD7pkAAAcHf7MykDAAAHrbXJ2BEAAADYInrrkPtzTRkAAAAAAAAOkEkZAAAWatLZfsAAAAAMp7cOecCTMlV1j6o6dZ5hAAAA6JMOCQAABzcp89tJHp7kwXPKAgDAIWD12t/AIUiHBABgv/XWIQ/mmjLfleTr13uyqnZU1cVVdfE/3PiPB/FjAAAA6MDMHfLSGz+5wFgAALA4B7wo01r7YmvtnzZ4fmdr7czW2pmnH/fQA/0xAAB0ZpI26A1YTvvTIR9z3FcuMhoAAEustw55MNuXAQDAfutt9BwAAIDh9NYhD2b7MgAAAAAAAGZkUgYAgIWadHaWEwAAAMPprUOalAEAAAAAAFgAkzIAACxUG+FCigAAAGxNvXVIkzIAAAAAAAALYFIGAICFap3tBwwAAMBweuuQJmUAAAAAAAAWwKQMAAALNelsP2AAAACG01uHNCkDAAAAAACwAAuZlFlJLeLHbBkrtRy/H9tWto0dIbfv2T12hCTJEdsPGztCkmSyJPsj7pnsGTtCkmT7Evw7mizHv6ePvOcDx46QJPn8rdePHSFJsm1lOc4p+MgtV40dIUmW4nyRm3Z/eewISZIbth05doQkSVuKfyrLq7f9gIH5O2WyHJs6LMufVytLcuyzUsuRYxn6yrL8XizLcfGkTcaOkGSJOmSN3yGPP+LosSMkSW7dffvYEZIkk8ltY0dIkmxbkj87luOfSvLRXV8YO0JO2H7U2BGSJHuW5JhjWS3LMdm8LMefBAAAAAAAAJ1bjtOPAAA4ZCzLZCgAAADLr7cOaVIGAAAAAABgAUzKAACwUL3tBwwAAMBweuuQFmUAAFioSfo6oAYAAGA4vXVI25cBAAAAAAAsgEkZAAAWqrfRcwAAAIbTW4c0KQMAAAAAALAAJmUAAFioSWdnOQEAADCc3jqkSRkAAAAAAIAFMCkDAMBCtfR1lhMAAADD6a1DbrgoU1VvmPFzWmvtRXu9d0eSHUnyjHueldOPe+iBJQQAAGBLmFeH/I57PD5PPPZh844HAACj22xS5oVJnpqkNnhNJXl7krscULfWdibZmSQ/+qDn97WUBQDAAettP2DgLl6YOXTI1zzgBf6gAAAgSX8dcrNFmVe01v7PZh9SVa+cUx4AAAC2Lh0SAAA2sLLJ82+qqgfd8U1VPaOq3lJVr6mq4+54vLX2iqECAgDQl9baoDdgVDokAABz1VuH3GxR5leSPDNJqupxSX4/yS1JTk/ya4MmAwAAYKvRIQEAYAObbV/2lCTnTO//bJK/aK29uKpOTfLBQZMBANClFtMs0DEdEgCAueqtQ262KHNVkm+rqi8neUaSr5s+fkKS6wfMBQAAwNajQwIAwAY2W5T5wST/K8mxSX6+tfae6eM/neR3hwwGAECfXPcFuqZDAgAwV711yA0XZVprf1JV905ydGvtS2ueenmSywZNBgBAl3o7oAbupEMCADBvvXXIzSZlkqQl+aaq+uoke5J8OMkftNb2DJoMAACArUiHBACAdWy4KFNVD07y9iQrSd43/frvkry6qr6ptXb58BEBAOhJX+c4AWvpkAAAzFtvHXJlk+f/W5L/neQhrbVvb639qyQPTvL7Sc4bOBsAAABbiw4JAAAbqI32Y6uq65I8uLV2/V6P3yPJp1trJw6aDgAAgC1DhwQAgI1tNinzT0meuI/Hn5jkivnHAQAAYAvTIQEAYAMbXlMmyU8m+Z2qOj/J3yepJGcleWGSFwwbDQAAgC1GhwQAgA1suH1ZklTVE5O8NMkjkkySfCTJf22tvXf4eAAAAGwlOiQAAKxv00UZAAAAAAAADt6G15Spqk+tuf/dez1321ChAAAA2Hp0SAAA2NiGkzJVNWmtrUzv72mtbdvXcwAAAKBDAgDAxjY7IF67YlMbPAcAAAA6JAAAbGD7Js9XVV245psLN3oxAAAAhzQdEgAANrDZoswr1tx//17P7f09AAAAhzYdEgAANrDZNWUe0Fq7fNMPmfF1AAAA9EuHBACAjW22KHOXCzMe7OsAAADolw4JAAAbm+WaMp/K6gUa11u9qdz9Ao4AAAAcenRIAADYwIaTMgAAAAAAAMzHytgBAAAAAAAADgUWZQAAAAAAABbAogwAAAAAAMACWJQBAAAAAABYgP8fnJUw9jqszCgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 2160x2160 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "i=1977\n",
    "case_study(model.test_outputs[i][0],\n",
    "           model.test_outputs[i][2],\n",
    "           model.test_outputs[i][3],\n",
    "           model.test_outputs[i][1].cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit",
   "name": "python388jvsc74a57bd0910af126f78e4f70975a50f5d0344a29878143e0b01cc32c99ca6cf65dbefcc1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "metadata": {
   "interpreter": {
    "hash": "910af126f78e4f70975a50f5d0344a29878143e0b01cc32c99ca6cf65dbefcc1"
   }
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 5
}