07-train_HSGRNN_CNN_DailyMail_TG_GATv2Conv.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HSGRNN_CNN_DailyMail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import argparse\n",
    "from time import time\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "from sklearn.utils import shuffle\n",
    "import json\n",
    "import os\n",
    "import networkx as nx\n",
    "import torch_geometric\n",
    "from statistics import mean\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm\n",
    "\n",
    "from rouge_score import rouge_scorer\n",
    "\n",
    "from utils.create_graph_dataset import create_graph_dataset\n",
    "from utils.GloveMgr import GloveMgr\n",
    "from utils.DataLoader import DataLoader\n",
    "from utils.MultiProcessusDataLoader import MultiProcessusDataLoader\n",
    "from utils.accuracy_nb_sent_per_doc import accuracy_nb_sent_per_doc_fn\n",
    "from utils.split_all_docs import split_all_docs\n",
    "from utils.threshold_probs import threshold_probs_by_nb, threshold_probs_by_prop\n",
    "from utils.accuracy_prop_sent_per_doc import accuracy_prop_sent_per_doc_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_notebook() -> bool:\n",
    "    try:\n",
    "        shell = get_ipython().__class__.__name__\n",
    "        if shell == 'ZMQInteractiveShell':\n",
    "            return True   # Jupyter notebook or qtconsole\n",
    "        elif shell == 'TerminalInteractiveShell':\n",
    "            return False  # Terminal running IPython\n",
    "        else:\n",
    "            return False  # Other type (?)\n",
    "    except NameError:\n",
    "        return False      # Probably standard Python interpreter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Hyper-)parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse args if script mode\n",
    "parser = argparse.ArgumentParser(description='extractive summary')\n",
    "\n",
    "parser.add_argument('-is_graphic',type=int,default=1,choices=[0,1])\n",
    "parser.add_argument('-gpu_num',type=int,default=0)\n",
    "parser.add_argument('-batch_size',type=int,default=1)\n",
    "parser.add_argument('-epochs',type=int,default=10)\n",
    "\n",
    "args = None\n",
    "\n",
    "if is_notebook():\n",
    "    args = parser.parse_args(\"\")\n",
    "else:\n",
    "    args = parser.parse_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parse:\n",
      "is_graphic: True\n",
      "cuda_num: 0\n",
      "epochs 10\n",
      "batch_size 1\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"glove.6B.300\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 150000\n",
    "batch_size = args.batch_size\n",
    "epochs = args.epochs\n",
    "learning_rate = 5e-4\n",
    "early_stopping = 3\n",
    "word_blacklist_proportion = 0.1\n",
    "model_name = \"07-train_HSGRNN_CNN_DailyMail_TG_GATv2Conv\"\n",
    "sub_folder_name = \"model_name__{}__time__{}__embed_name__{}__lr__{}__batch_size__{}__vocab_size__{}__cuda_num__{}__early_stopping__{}\".format(model_name, time(), embed_name, learning_rate, batch_size, vocab_size, cuda_num, early_stopping)\n",
    "checkpoints_folder = \"./checkpoints/\" + sub_folder_name\n",
    "average_number_of_sentences_per_document = 3\n",
    "\n",
    "# print\n",
    "print(\"parse:\")\n",
    "print(\"is_graphic:\", is_graphic)\n",
    "print(\"cuda_num:\", cuda_num)\n",
    "print(\"epochs\", epochs)\n",
    "print(\"batch_size\", batch_size)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch initialisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(0)\n",
    "random.seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of available GPUs: 1\n",
      "GPU 0: NVIDIA GeForce RTX 3060\n"
     ]
    }
   ],
   "source": [
    "# Check if a GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    # Display the number of available GPUs\n",
    "    print(f\"Number of available GPUs: {torch.cuda.device_count()}\")\n",
    "    # Display the name of each GPU\n",
    "    for i in range(torch.cuda.device_count()):\n",
    "        print(f\"GPU {i}: {torch.cuda.get_device_name(i)}\")\n",
    "else:\n",
    "    print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "else:  \n",
    "  dev = \"cpu\" \n",
    "\n",
    "device = torch.device(dev)\n",
    "device"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(\"./data/cnn_dailymail/test.json\")\n",
    "df_val = pd.read_json(\"./data/cnn_dailymail/val.json\")\n",
    "df_train = pd.read_json(\"./data/cnn_dailymail/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "glovemgr = GloveMgr(\"./data/glove.6B/glove.6B.300d.txt\", vocab_size=vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(\"data/cnn_dailymail_sent_tfidf.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(\"./data/cnn_dailymail_dataset_tfidf.json\"))\n",
    "tfidfs_dataset_sorted = sorted(tfidfs_dataset, key=tfidfs_dataset.get)\n",
    "word_blacklist = set(tfidfs_dataset_sorted[:int(word_blacklist_proportion*len(tfidfs_dataset_sorted))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = MultiProcessusDataLoader(buffer_size=30, dataset=df_train, batch_size=batch_size, shuffle=True, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, glovemgr=glovemgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=\"article\", labels_column_name=\"labels\", is_sep_n=False, remove_stop_word=True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn.conv import GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SENT_RNN(nn.Module):\n",
    "  def __init__(self, device, dim_emb=128):\n",
    "    super(SENT_RNN, self).__init__()\n",
    "    self.device = device\n",
    "    self.dim_emb = dim_emb\n",
    "    self.sent_GRU = nn.GRU(input_size = dim_emb, hidden_size=dim_emb, batch_first = True, bidirectional = True)\n",
    "\n",
    "    # 10: relative position range size, with segment size = 10\n",
    "    self.rel_pos_emb = nn.Embedding(11, 100)\n",
    "    self.abs_pos_emb = nn.Embedding(100, 100)\n",
    "\n",
    "    self.Wdoc = nn.Linear(2*dim_emb,2*dim_emb,bias=True)\n",
    "\n",
    "    self.Wcontent = nn.Linear(2*dim_emb,1,bias=False)\n",
    "    self.Wsalience = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wnovelty = nn.Bilinear(2*dim_emb,2*dim_emb,1,bias=False)\n",
    "    self.Wabs_pos = nn.Linear(100,1,bias=False)\n",
    "    self.Wrel_pos = nn.Linear(100,1,bias=False)\n",
    "    self.bias = nn.Parameter(torch.empty(1).uniform_(-0.1, 0.1))\n",
    "\n",
    "  def avg_pool1d(self,x,seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t,t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def pad_doc(self, x, doc_lens):\n",
    "    pad_dim = x.size(1)\n",
    "    max_doc_len = max(doc_lens)\n",
    "    result = []\n",
    "    start = 0\n",
    "    for doc_len in doc_lens:\n",
    "      stop = start + doc_len\n",
    "      doc = x[start:stop]\n",
    "      start = stop\n",
    "      if doc_len == max_doc_len:\n",
    "        result.append(doc.unsqueeze(0))\n",
    "      else:\n",
    "        pad = torch.zeros(max_doc_len-doc_len, pad_dim)\n",
    "        if self.device is not None:\n",
    "          pad = pad.to(self.device)\n",
    "        result.append(torch.cat([doc,pad]).unsqueeze(0))\n",
    "    result = torch.cat(result,dim=0)\n",
    "    return result\n",
    "\n",
    "  def forward(self, sents, doc_lens):\n",
    "    probs = []\n",
    "\n",
    "    max_doc_lens = max(doc_lens)\n",
    "\n",
    "    arr_x = self.pad_doc(sents, doc_lens)\n",
    "    arr_x = self.sent_GRU(arr_x)[0]\n",
    "    sents_all_docs = arr_x.reshape(len(doc_lens) * max_doc_lens, 2*self.dim_emb) # flat docs\n",
    "\n",
    "    docs = self.avg_pool1d(arr_x, doc_lens)\n",
    "    docs = torch.tanh(self.Wdoc(docs))\n",
    "    docs_for_each_sent = docs.repeat_interleave(max_doc_lens, dim=0) # repeat doc n times\n",
    "    \n",
    "    contents = self.Wcontent(sents_all_docs)\n",
    "    saliences = self.Wsalience(sents_all_docs, docs_for_each_sent)\n",
    "\n",
    "    # Compute position embedding\n",
    "    abs_poses = torch.tensor([[position] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    abs_poses = abs_poses.to(self.device)\n",
    "    abs_poses = self.abs_pos_emb(abs_poses).squeeze(1)\n",
    "    aps = self.Wabs_pos(abs_poses)\n",
    "\n",
    "    # Compute relative position embedding\n",
    "    rel_poses = torch.tensor([[int(round(position / 10))] for position in range(max_doc_lens)], dtype=torch.long)\n",
    "    rel_poses = rel_poses.to(self.device)\n",
    "    rel_poses = self.rel_pos_emb(rel_poses).squeeze(1)\n",
    "    rps = self.Wrel_pos(rel_poses)\n",
    "\n",
    "    # doc_len (number) s\n",
    "    ses = torch.zeros(len(doc_lens), 2*self.dim_emb)\n",
    "    ses = ses.to(self.device)\n",
    "\n",
    "    # for each document, compute probabilities\n",
    "    for position in range(max_doc_lens):\n",
    "      contents_for_position = contents[position::max_doc_lens]\n",
    "      saliences_for_position = saliences[position::max_doc_lens]\n",
    "      novelties_for_position = -1 * self.Wnovelty(sents_all_docs[position::max_doc_lens], torch.tanh(ses))\n",
    "      prob = contents_for_position + saliences_for_position + novelties_for_position + aps[position] + rps[position] + self.bias\n",
    "      prob = torch.sigmoid(prob)\n",
    "      probs.append(prob)\n",
    "\n",
    "      ses = ses + torch.mul(sents_all_docs[position::max_doc_lens], prob)\n",
    "    probs = torch.cat(probs).squeeze()\n",
    "    if len(probs.shape) == 0:\n",
    "      probs = probs.unsqueeze(0)\n",
    "    probs_filtered = []\n",
    "    for idx, doc_len in enumerate(doc_lens):\n",
    "      prob = probs[idx::len(doc_lens)]\n",
    "      prob = prob[:doc_len]\n",
    "      probs_filtered.append(prob)\n",
    "    probs_filtered = torch.cat(probs_filtered).squeeze()\n",
    "    if len(probs_filtered.shape) == 0:\n",
    "      probs_filtered = probs_filtered.unsqueeze(0)\n",
    "    #probs = probs.to(self.device)\n",
    "    return probs_filtered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Position Feed Forward\n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "  def __init__(self, d_in, d_out, d_h, dropout=0.1) -> None:\n",
    "    super(PositionwiseFeedForward, self).__init__()\n",
    "    self.fc1 = nn.Linear(in_features=d_in, out_features=d_h)\n",
    "    self.fc2 = nn.Linear(in_features=d_h, out_features=d_out)\n",
    "    self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "  def forward(self, x):\n",
    "    x = torch.relu(self.fc1(x))\n",
    "    x = self.dropout(x)\n",
    "    return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HSGRNN(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HSGRNN, self).__init__()\n",
    "    self.device = device\n",
    "    self.num_iter = num_iter\n",
    "\n",
    "    self.word_emb = nn.Embedding(vocab_size+2, dim_word_embed, padding_idx=0)\n",
    "\n",
    "    # Load word embedding if specified\n",
    "    if word_embed is not None:\n",
    "      self.word_embedding = torch.nn.Embedding.from_pretrained(torch.from_numpy(word_embed).float())\n",
    "\n",
    "    self.word_emb.weight.requires_grad = False\n",
    "\n",
    "    # edge_attr embed\n",
    "    self.edge_attr_embed = nn.Embedding(101, 50)\n",
    "\n",
    "    # sent CNN\n",
    "    dim_out_cnn = 64\n",
    "    self.convs = nn.Sequential(\n",
    "                            nn.Conv1d(in_channels=300,out_channels=100,kernel_size=3,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=100,kernel_size=4,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=100),\n",
    "                            nn.ReLU(inplace=True),\n",
    "                            nn.Conv1d(in_channels=100,out_channels=dim_out_cnn,kernel_size=5,padding='same'),\n",
    "                            nn.BatchNorm1d(num_features=dim_out_cnn),\n",
    "                            nn.ReLU(inplace=True))\n",
    "\n",
    "    # sent LSTM\n",
    "    dim_out_lstm = 32\n",
    "    self.sent_LSTM = nn.LSTM(input_size=300, hidden_size=dim_out_lstm, batch_first=True, bidirectional=True)\n",
    "\n",
    "    # sent to word GAT\n",
    "    # TODO out_channels = 64\n",
    "    self.s2wGAT = GATv2Conv(in_channels=[128, 300], out_channels=300, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # word to sen GAT\n",
    "    self.w2sGAT = GATv2Conv(in_channels=[300, 128], out_channels=128, heads=8, edge_dim=50, fill_value=0, share_weights=False)\n",
    "\n",
    "    # ffn sent to word\n",
    "    self.ffns2w = PositionwiseFeedForward(d_in=8*300, d_out=300, d_h=512)\n",
    "\n",
    "    # ffn word to sent\n",
    "    self.ffnw2s = PositionwiseFeedForward(d_in=8*128, d_out=128, d_h=512)\n",
    "\n",
    "    #self.wh = nn.Linear(128, 1)\n",
    "    self.sent_rnn = SENT_RNN(device)\n",
    "\n",
    "  def max_pool1d(self, x, seq_lens):\n",
    "    out = []\n",
    "    for index,t in enumerate(x):\n",
    "      if seq_lens[index] == 0:\n",
    "        t = t[:1]\n",
    "      else:\n",
    "        t = t[:seq_lens[index],:]\n",
    "      t = torch.t(t).unsqueeze(0)\n",
    "      out.append(torch.avg_pool1d(t, t.size(2)))\n",
    "\n",
    "    out = torch.cat(out).squeeze(2)\n",
    "    return out\n",
    "\n",
    "  def forward(self, data, doc_lens):# In the real implémentation remove nb_sent\n",
    "    # edge attr embeddings\n",
    "    edge_attr = torch.floor(data.edge_attr * 100).int()\n",
    "    edge_attr = self.edge_attr_embed(edge_attr)\n",
    "\n",
    "    # features\n",
    "    Xw = data.x[0]\n",
    "    Xs = data.x[1]\n",
    "    sent_lens = torch.sum(torch.sign(Xs),dim=1).data\n",
    "    \n",
    "    # embeddings\n",
    "    Xw = self.word_emb(Xw)\n",
    "    Xs = self.word_emb(Xs)\n",
    "\n",
    "    # CNN\n",
    "    XsCNN = self.convs(Xs.permute(0,2,1))\n",
    "    XsCNN = torch.max_pool1d(XsCNN, XsCNN.size(2)).squeeze(2)\n",
    "\n",
    "    # LSTM\n",
    "    # TO DO: ask \n",
    "    XsLSTM, _ = self.sent_LSTM(Xs)\n",
    "    XsLSTM = self.max_pool1d(XsLSTM, sent_lens)\n",
    "    Xs = torch.cat((XsCNN, XsLSTM), dim=1)\n",
    "\n",
    "    Hw = Xw\n",
    "    Hs = Xs\n",
    "\n",
    "    edge_index_w_i = data.edge_index[1][data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_s_j = data.edge_index[0][data.edge_index[1] < len(data.x[0])] - Hw.shape[0]\n",
    "    edge_attr_w = edge_attr[data.edge_index[1] < len(data.x[0])]\n",
    "    edge_index_w = torch.stack([edge_index_s_j, edge_index_w_i])\n",
    "\n",
    "    edge_index_s_i = data.edge_index[1][data.edge_index[1] >= len(data.x[0])] - Hw.shape[0]\n",
    "    edge_index_w_j = data.edge_index[0][data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_attr_s = edge_attr[data.edge_index[1] >= len(data.x[0])]\n",
    "    edge_index_s = torch.stack([edge_index_w_j, edge_index_s_i])\n",
    "\n",
    "    Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "    Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    for i in range(self.num_iter):\n",
    "      if i != 0: # H^1w = H^0w = Xw\n",
    "        Hw = self.s2wGAT(x=[Hs, Hw], edge_index=edge_index_w, edge_attr=edge_attr_w) + torch.cat([Hw] * 8, dim=1)\n",
    "        Hw = self.ffns2w(Hw)\n",
    "        Hw = torch.layer_norm(Hw, Hw.size()[1:])\n",
    "\n",
    "      Hs = self.w2sGAT(x=[Hw, Hs], edge_index=edge_index_s, edge_attr=edge_attr_s) + torch.cat([Hs] * 8, dim=1)\n",
    "      Hs = self.ffnw2s(Hs)\n",
    "      Hs = torch.layer_norm(Hs, Hs.size()[1:])\n",
    "\n",
    "    res = self.sent_rnn(Hs, doc_lens)\n",
    "\n",
    "    return res\n",
    "\n",
    "  def save(self, fname):\n",
    "    torch.save(self.state_dict(), fname)\n",
    "\n",
    "  def load(self, fname):\n",
    "    self.load_state_dict(torch.load(fname))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[\"article\"])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/100 [00:00<?, ?batch/s]/home/rsaid/anaconda3/lib/python3.9/site-packages/torch/nn/modules/conv.py:309: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:895.)\n",
      "  return F.conv1d(input, weight, bias, self.stride,\n",
      "Epoch 1: 100%|██████████| 100/100 [00:08<00:00, 11.33batch/s, accuracy=0.796, loss=0.874, mae=0.301]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.469, val mae = 0.324, val accuracy = 0.796, r1 = 0.392, r2 = 0.154, rL = 0.242\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 100/100 [00:07<00:00, 12.70batch/s, accuracy=0.824, loss=0.6, mae=0.292] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.396, val mae = 0.210, val accuracy = 0.851, r1 = 0.421, r2 = 0.186, rL = 0.259\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 100/100 [00:08<00:00, 11.62batch/s, accuracy=0.827, loss=0.533, mae=0.262]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.448, val mae = 0.236, val accuracy = 0.850, r1 = 0.409, r2 = 0.174, rL = 0.255\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 100/100 [00:08<00:00, 11.45batch/s, accuracy=0.824, loss=0.514, mae=0.278]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.434, val mae = 0.196, val accuracy = 0.851, r1 = 0.422, r2 = 0.188, rL = 0.260\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 100/100 [00:10<00:00,  9.61batch/s, accuracy=0.832, loss=0.465, mae=0.25]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.455, val mae = 0.237, val accuracy = 0.843, r1 = 0.407, r2 = 0.173, rL = 0.253\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 100/100 [00:08<00:00, 11.78batch/s, accuracy=0.837, loss=0.421, mae=0.241]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.382, val mae = 0.228, val accuracy = 0.851, r1 = 0.421, r2 = 0.187, rL = 0.260\n",
      "Training duration = 68.51009321212769\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_mae = []\n",
    "arr_train_acc = []\n",
    "arr_val_loss = []\n",
    "arr_val_mae = []\n",
    "arr_val_acc = []\n",
    "\n",
    "t1 = time()\n",
    "\n",
    "for epoch in range(1, epochs+1):\n",
    "  # Train\n",
    "  model.train()\n",
    "  nb_batch_train = 0\n",
    "  total_train_loss = 0\n",
    "  total_train_mae = 0\n",
    "  total_train_acc = 0\n",
    "  with tqdm(train_loader, unit=\"batch\", total=len(train_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "      tepoch.set_description(f\"Epoch {epoch}\")\n",
    "      #if dev != \"cpu\":\n",
    "      #  torch.cuda.empty_cache()\n",
    "      doc_lens = batch[\"doc_lens\"]\n",
    "      data = batch[\"docs\"].to(device)\n",
    "      targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "      y_pred = model(data, doc_lens)\n",
    "\n",
    "      loss = criterion(y_pred, targets)\n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 2.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "\n",
    "      probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      total_train_mae += mae_fn(probs_tensor, targets).item()\n",
    "      total_train_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, mae=total_train_mae/nb_batch_train, accuracy=total_train_acc/nb_batch_train)\n",
    "\n",
    "  # Save model\n",
    "  model.save(checkpoints_folder + \"/\" + model_name + \"-\" + str(epoch) + \".pt\")\n",
    "\n",
    "  # Eval\n",
    "  model.eval()\n",
    "  nb_batch_val = 0\n",
    "  total_val_loss = 0\n",
    "  total_val_mae = 0\n",
    "  total_val_acc = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  for i, batch in enumerate(val_loader):\n",
    "    #if dev != \"cpu\":\n",
    "    #  torch.cuda.empty_cache()\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data, doc_lens)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "\n",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"highlights\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[j]]\n",
    "      y_pred_thresh.append(indices[j])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in y_pred_thresh:\n",
    "      txt = txt + \". \" + doc[j]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    total_r1 += scores[\"rouge1\"].fmeasure\n",
    "    total_r2 += scores[\"rouge2\"].fmeasure\n",
    "    total_rl += scores[\"rougeL\"].fmeasure\n",
    "\n",
    "    probs = y_pred.tolist() # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    total_val_mae += mae_fn(probs_tensor, targets).item()\n",
    "    total_val_acc += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "\n",
    "  if len(arr_val_loss) >= early_stopping+1:\n",
    "    if min(arr_val_loss[-early_stopping:]) >= arr_val_loss[-(early_stopping+1)]:\n",
    "      print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "      break\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val mae = {:.3f}, val accuracy = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_mae / nb_batch_val, total_val_acc / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\n",
    "\n",
    "  del loss\n",
    "  del y_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  arr_train_mae.append(total_train_mae / nb_batch_train)\n",
    "  arr_train_acc.append(total_train_acc / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_mae.append(total_val_mae / nb_batch_val)\n",
    "  arr_val_acc.append(total_val_acc / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_mae\"]  = arr_train_mae\n",
    "training_metrics[\"train_acc\"]  = arr_train_acc\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_mae\"]    = arr_val_mae\n",
    "training_metrics[\"val_acc\"]    = arr_val_acc\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/training_metrics.json\", 'w') as fp:\n",
    "  json.dump(training_metrics, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHFCAYAAAAOmtghAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABSG0lEQVR4nO3de1xUZf4H8M+ZYS7c73cQUBTBa0IqmpV5ywtq+yvtptnm7rZbaVlZVltpbbRtmd202mxdzcots7XVSswkzbthGiBeUEAuIsj9MgMz5/fHkUEERsCBM5fP+/Wal8Mz58x8D6ecj895zvMIoiiKICIiIrITCrkLICIiIrIkhhsiIiKyKww3REREZFcYboiIiMiuMNwQERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVhhsisipr1qyBIAg4dOiQ3KUQkY1iuCEiIiK7wnBDREREdoXhhohszu7duzFu3Di4u7vDxcUFo0aNwpYtW1psU1tbiyeeeAJRUVHQarXw8fFBQkICPvvsM9M22dnZuPPOOxESEgKNRoPAwECMGzcOR44c6eEjIiJLcpK7ACKizkhNTcWECRMwePBgrF69GhqNBitXrkRSUhI+++wzzJ49GwCwaNEirFu3Di+//DKuu+461NTU4LfffkNpaanpvaZMmQKDwYDXXnsNvXr1QklJCfbs2YPy8nKZjo6ILEEQRVGUuwgioiZr1qzB/fffj4MHDyIhIaHV64mJicjOzsbp06fh5uYGADAYDBg6dCjKy8uRm5sLQRAwaNAgREdHY9OmTW1+TmlpKfz8/LBixQosXLiwW4+JiHoWL0sRkc2oqanB/v37cfvtt5uCDQAolUrMmTMH586dQ1ZWFgBg+PDh+Pbbb/H0009j586dqKura/FePj4+6NOnD/7xj39g+fLlSEtLg9Fo7NHjIaLuwXBDRDajrKwMoigiODi41WshISEAYLrs9Pbbb+Opp57C119/jbFjx8LHxwczZ87EyZMnAQCCIOCHH37ApEmT8Nprr2HYsGHw9/fHggULUFVV1XMHRUQWx3BDRDbD29sbCoUChYWFrV4rKCgAAPj5+QEAXF1dsXTpUhw/fhxFRUVYtWoV9u3bh6SkJNM+ERERWL16NYqKipCVlYXHHnsMK1euxJNPPtkzB0RE3YLhhohshqurK0aMGIGvvvqqxWUmo9GITz75BGFhYejXr1+r/QIDAzFv3jzcddddyMrKQm1tbatt+vXrh+eeew6DBg3CL7/80q3HQUTdi3dLEZFV2rFjB86ePduqPTk5GRMmTMDYsWPxxBNPQK1WY+XKlfjtt9/w2WefQRAEAMCIESMwbdo0DB48GN7e3sjMzMS6deuQmJgIFxcXHD16FA8//DDuuOMO9O3bF2q1Gjt27MDRo0fx9NNP9/DREpElMdwQkVV66qmn2mw/c+YMduzYgRdeeAHz5s2D0WjEkCFDsHnzZkybNs203S233ILNmzfjzTffRG1tLUJDQzF37lw8++yzAICgoCD06dMHK1euRF5eHgRBQO/evfHGG2/gkUce6ZFjJKLuwVvBiYiIyK5wzA0RERHZFYYbIiIisisMN0RERGRXGG6IiIjIrjDcEBERkV1huCEiIiK74nDz3BiNRhQUFMDd3d002RcRERFZN1EUUVVVhZCQECgU5vtmHC7cFBQUIDw8XO4yiIiIqAvy8vIQFhZmdhuHCzfu7u4ApF+Oh4eHzNUQERFRR1RWViI8PNz0PW6Ow4WbpktRHh4eDDdEREQ2piNDSjigmIiIiOwKww0RERHZFYYbIiIisisON+amowwGAxoaGuQuwyapVCoolUq5yyAiIgfFcHMFURRRVFSE8vJyuUuxaV5eXggKCuJcQkRE1OMYbq7QFGwCAgLg4uLCL+dOEkURtbW1KC4uBgAEBwfLXBERETkahpvLGAwGU7Dx9fWVuxyb5ezsDAAoLi5GQEAAL1EREVGP4oDiyzSNsXFxcZG5EtvX9DvkuCUiIuppDDdt4KWoa8ffIRERyYXhhoiIiOwKww21EhkZiRUrVshdBhERUZdwQLGduPnmmzF06FCLhJKDBw/C1dX12osiIiKSAcONBTUYjGgwGOGitr5fqyiKMBgMcHK6em3+/v49UBEREVH34GUpC6nRNeJEURVyS2thNIo9+tnz5s1Damoq3nrrLQiCAEEQsGbNGgiCgO+//x4JCQnQaDTYtWsXTp8+jRkzZiAwMBBubm64/vrrsX379hbvd+VlKUEQ8NFHH+G2226Di4sL+vbti82bN/foMRIREXUUw81ViKKIWn3jVR+iKEJvMKKyvgG5F2s7tE9H3rMj3nrrLSQmJuIPf/gDCgsLUVhYiPDwcADA4sWLkZycjMzMTAwePBjV1dWYMmUKtm/fjrS0NEyaNAlJSUnIzc01+xlLly7FrFmzcPToUUyZMgX33HMPLl68eM2/XyIiIkuzvusnVqauwYC457+X5bMzlk3q0CUuT09PqNVquLi4ICgoCABw/PhxAMCyZcswYcIE07a+vr4YMmSI6eeXX34ZmzZtwubNm/Hwww+3+xnz5s3DXXfdBQB45ZVX8M477+DAgQO49dZbu3RsRERE3YU9N3YuISGhxc81NTVYvHgx4uLi4OXlBTc3Nxw/fvyqPTeDBw82PXd1dYW7u7tpiQUiIiJrwp6bq3BWKZGxbFKHt6/TG5B9oRoigEhfF7hpVdf02dfqyruennzySXz//fd4/fXXER0dDWdnZ9x+++3Q6/Vm30elankcgiDAaDRec31ERESWxnBzFYIgdOruJxe1E+objSit1qG8rhH+7toema1XrVbDYDBcdbtdu3Zh3rx5uO222wAA1dXVOHv2bDdXR0RE1HN4WaobBLpr4KQQUN9gQGmN+R4RS4mMjMT+/ftx9uxZlJSUtNurEh0dja+++gpHjhzBr7/+irvvvps9MEREZFcYbrqBk1KBQA8tAOB8ZT0aDd0fHp544gkolUrExcXB39+/3TE0b775Jry9vTFq1CgkJSVh0qRJGDZsWLfXR0RE1FMEsaP3G9uJyspKeHp6oqKiAh4eHi1eq6+vx5kzZxAVFQWtVntNnyOKIk4VV6OuwQAfVzXCvB1rpXFL/i6JiIjMfX9fiT033UQQBIR4OQMALtboUatvlLkiIiIix8Bw041cNU7wclEDAArK6zs8KR8RERF1HcNNNwv20EIhCKjVN6K8rkHucoiIiOwew003UzkpEOChAQAUVdTD0MPrThERETkahpse4OemgdpJgQaDEcVV9XKXQ0REZNcYbnqAQhAQ4ikNLi6p1kPXcPXJ9oiIiKhrGG56iLvWCe5aFURRREEFe2+IiIi6C8NNDxEEAcGe0lIMVfUNqOTgYiIiom7BcNODtCol/NykW8MLK+pg5K3hREREFsdw08MC3LVwUiqgazSipFondzkmkZGRWLFihdxlEBERXTOGmx6mVAgIvrTuVHGlDg09sO4UERGRI2G4kYGXiwouaicYRRFFHFxMRERkUQw3MpDWnZJ6b8pq9ajRXdu6Ux988AFCQ0NhNLbsBZo+fTruu+8+nD59GjNmzEBgYCDc3Nxw/fXXY/v27df0mURERNaK4eZqRBHQ11j84QIdfNWNEBpqUXihFKKuuvV2HRxwfMcdd6CkpAQ//vijqa2srAzff/897rnnHlRXV2PKlCnYvn070tLSMGnSJCQlJSE3N7e7fmtERESycZK7AKvXUAu8EtItbx166dGuZwoAtetV38fHxwe33norPv30U4wbNw4A8MUXX8DHxwfjxo2DUqnEkCFDTNu//PLL2LRpEzZv3oyHH3742g6CiIjIyrDnxk7cc8892LhxI3Q66Q6s9evX484774RSqURNTQ0WL16MuLg4eHl5wc3NDcePH2fPDRER2SX23FyNykXqQekmRlHE6Qs1qG8wwM9NjeBLyzSYPruDkpKSYDQasWXLFlx//fXYtWsXli9fDgB48skn8f333+P1119HdHQ0nJ2dcfvtt0Ov11v6cIiIiGTHcHM1gtChS0NdpQAQ7KdBdkkNSnQCvAQtnFXKTr+Ps7Mzfve732H9+vU4deoU+vXrh/j4eADArl27MG/ePNx2220AgOrqapw9e9aCR0FERGQ9GG6sgJtWBU9nFSrqGlBQXofefq4QBKHT73PPPfcgKSkJ6enpuPfee03t0dHR+Oqrr5CUlARBEPDXv/611Z1VRERE9oJjbqxEsKcWCkFAja4RFV1cd+qWW26Bj48PsrKycPfdd5va33zzTXh7e2PUqFFISkrCpEmTMGzYMEuVTkREZFXYc2Ml1E5K+LtrcL6yHoUV9fDQqqBQdK73RqlUoqCg9figyMhI7Nixo0XbQw891OJnXqYiIiJ7wZ4bK+LvpoFaqUCDwYhiK1p3ioiIyJYw3FgRhUJAsKc0c/GFKh30jQaZKyIiIrI9DDdWxsNZBTeNE0RRRCHXnSIiIuo0hhsrI6075QwBAirqGlBV37XBxURERI6K4aYNYgfXdOouWpUSvm5qAEBBeT2MMtfTFXL/DomIyHEx3FxGpVIBAGpra2WuBAhw18BJoYCu0YDSatubSbjpd9j0OyUiIuopvBX8MkqlEl5eXiguLgYAuLi4dGkyPUvx1gLFlXoUXWyAVuEKldL6s6goiqitrUVxcTG8vLygVHZ+tmUiIqJrwXBzhaCgIAAwBRw5iSJQXlUPvUFEVYkS3i5quUvqMC8vL9PvkoiIqCcx3FxBEAQEBwcjICAADQ3yD+atyy/Hgs+PAALw3l3D0D/YQ+6SrkqlUrHHhoiIZMNw0w6lUmkVX9DxfYIwIjoIX6XlY+m3J7HxwVGdnrmYiIjIkVj/IA7CU5P7w1WtRFpuOb5Ky5e7HCIiIqvGcGMDAj20eGRcXwDAq98e59w3REREZjDc2Ij7R0ciys8VJdU6vLPjlNzlEBERWS2GGxuhcVLi+aQ4AMDHu8/gVHG1zBURERFZJ4YbGzI2JgDj+geg0Shi2f8yOAswERFRGxhubMxfp8VBrVTgpxMX8EOm/HPxEBERWRuGGxsT6eeKB8ZEAQCW/S8D9Q0GmSsiIiKyLgw3NujhsdEI9NAg92ItVu8+I3c5REREVoXhxga5apywZHIsAODdHadQWFEnc0VERETWQ/Zws3LlSkRFRUGr1SI+Ph67du0yu/369esxZMgQuLi4IDg4GPfffz9KS0t7qFrrMWNoCBIivFHXYEDy1uNyl0NERGQ1ZA03GzZswKOPPopnn30WaWlpGDNmDCZPnozc3Nw2t9+9ezfmzp2LBx54AOnp6fjiiy9w8OBBzJ8/v4crl58gCHhx+gAIArD51wIcOHNR7pKIiIisgqzhZvny5XjggQcwf/58xMbGYsWKFQgPD8eqVava3H7fvn2IjIzEggULEBUVhRtuuAF/+tOfcOjQoR6u3DoMDPXEXcN7AQBe2JwOg5G3hhMREckWbvR6PQ4fPoyJEye2aJ84cSL27NnT5j6jRo3CuXPnsHXrVoiiiPPnz+PLL7/E1KlT2/0cnU6HysrKFg978sTEGHhonZBZWInPDrTd40VERORIZAs3JSUlMBgMCAwMbNEeGBiIoqKiNvcZNWoU1q9fj9mzZ0OtViMoKAheXl5455132v2c5ORkeHp6mh7h4eEWPQ65+biq8fjEGADA69uyUFajl7kiIiIieck+oFgQhBY/i6LYqq1JRkYGFixYgOeffx6HDx/Gd999hzNnzuDBBx9s9/2XLFmCiooK0yMvL8+i9VuDe0b0QkygO8prG7A85YTc5RAREclKtnDj5+cHpVLZqpemuLi4VW9Ok+TkZIwePRpPPvkkBg8ejEmTJmHlypX4+OOPUVhY2OY+Go0GHh4eLR72xkmpwIvTBwAA1u/PQUaBfV16IyIi6gzZwo1arUZ8fDxSUlJatKekpGDUqFFt7lNbWwuFomXJSqUSABx+naXEPr6YOjgYRhF48Zt0h/99EBGR45L1stSiRYvw0Ucf4eOPP0ZmZiYee+wx5Obmmi4zLVmyBHPnzjVtn5SUhK+++gqrVq1CdnY2fv75ZyxYsADDhw9HSEiIXIdhNZ6ZEgutSoEDZy7if0fb7skiIiKyd05yfvjs2bNRWlqKZcuWobCwEAMHDsTWrVsREREBACgsLGwx5828efNQVVWFd999F48//ji8vLxwyy234O9//7tch2BVQr2c8Zebo7E85QRe2ZqJcbEBcFHLeoqJiIh6nCA62PWLyspKeHp6oqKiwi7H39Q3GDB+eSrOldXh4bHReGJSjNwlERERXbPOfH/LfrcUWZZWpcRzU+MAAB/+lI2c0hqZKyIiIupZDDd2aNKAQNwQ7Qe9wYiXt2TKXQ4REVGPYrixQ4Ig4IWkODgpBKRknEfqiQtyl0RERNRjGG7sVN9Ad9w3KhIAsPSbdOgbjfIWRERE1EMYbuzYwvF94eemRvaFGqzde1bucoiIiHoEw40d89CqsHhSfwDAiu0nUVxVL3NFRERE3Y/hxs7dHh+GwWGeqNY14rXvsuQuh4iIqNsx3Ng5hUIwrTv15eFzSMstk7kiIiKi7sVw4wCG9fLG/w0LAwC8uDkdRqNDzdtIREQOhuHGQTw1OQZuGif8eq4CX/5yTu5yiIiIug3DjYMIcNdi4bi+AIDXvjuOyvoGmSsiIiLqHgw3DuS+UZHo7e+Kkmo93t5+Uu5yiIiIugXDjQNROynw/DRp3ak1e87iVHGVzBURERFZHsONg7k5JgDjYwPRaBTx4uYMONii8ERE5AAYbhzQX6fFQq1UYPepEmzLOC93OURERBbFcOOAInxd8YcbowAAL/0vA/UNBpkrIiIishyGGwf10NhoBHloca6sDv/8KVvucoiIiCyG4cZBuaid8MzUWADAeztPoaC8TuaKiIiILIPhxoElDQ7G8Egf1DcY8betmXKXQ0REZBEMNw5MEAS8MD0OCgHYcrQQe0+Xyl0SERHRNWO4cXADQjxx94heAICl36Sj0WCUuSIiIqJrw3BDeHxCDLxcVDheVIVPD+TKXQ4REdE1YbgheLuq8fjEGADAG9tO4GKNXuaKiIiIuo7hhgAAdw/vhdhgD1TUNeCNbVlyl0NERNRlDDcEAFAqBLyYJK079emBXPyWXyFzRURERF3DcEMmI3r7ImlICERRGlzMdaeIiMgWMdxQC0sm94ezSomDZ8uw+dcCucshIiLqNIYbaiHEyxkPje0DAHhlayZqdI0yV0RERNQ5DDfUyvwxvdHLxwXnK3V478dTcpdDRETUKQw31IpWpcRfp0mDiz/adQZnS2pkroiIiKjjGG6oTeNjA3BjP3/oDUa8vCVD7nKIiIg6jOGG2iQIAp6fFgcnhYDtmcX4MatY7pKIiIg6hOGG2hUd4Ib7R0cCAJZ9kwF9I9edIiIi68dwQ2YtGNcXfm4anCmpwb9+PiN3OURERFfFcENmuWtVeOpWad2pt384ieLKepkrIiIiMo/hhq7q/4aFYWi4F2r0Brz63XG5yyEiIjKL4YauSqEQsHT6AADAV7/k43BOmcwVERERtY/hhjpkSLgXZiWEAQBe3JwOg5HrThERkXViuKEOe3JSf7hrnHAsvwJfHMqTuxwiIqI2MdxQh/m7a7BwfF8AwGvfZ6GirkHmioiIiFpjuKFOuW9UJKID3HCxRo8V20/IXQ4REVErDDfUKSqlAi8kSetOrd2bgxPnq2SuiIiIqCWGG+q0MX39MWlAIAxGEUu/SYcocnAxERFZD4Yb6pLnpsZB7aTAz6dK8X16kdzlEBERmTDcUJeE+7jgwRt7AwBe+l8m6vQGmSsiIiKSMNxQl/355miEeGqRX16HD346LXc5REREABhu6Bo4q5V4ZmosAGDVztM4V1Yrc0VEREQMN3SNpg4KxsjePtA1GvHK1ky5yyEiImK4oWsjCAJenD4ACgHYeqwIe06VyF0SERE5OIYbumb9gzwwZ2QEAODFb9LRaDDKXBERETkyhhuyiMcm9IO3iwonzldj3b4cucshIiIHxnBDFuHlosYTk2IAAMtTTqC0WidzRURE5KgYbshi7ry+F+KCPVBV34jXt2XJXQ4RETkohhuyGKVCwNIZAwAAnx/Mw7FzFTJXREREjojhhizq+kgfzBwaAlEEXtj8G9edIiKiHsdwQxb39ORYuKiV+CW3HF8fyZe7HCIicjAMN2RxQZ5aPHxLNAAgeetxVOsaZa6IiIgcCcMNdYsHbohChK8Liqt0eGfHSbnLISIiB8JwQ91C46TE89PiAAAf7z6D7AvVMldERESOQvZws3LlSkRFRUGr1SI+Ph67du1qd9t58+ZBEIRWjwEDBvRgxdRRt/QPwM0x/mgwiHjpfxlyl0NERA5C1nCzYcMGPProo3j22WeRlpaGMWPGYPLkycjNzW1z+7feeguFhYWmR15eHnx8fHDHHXf0cOXUEYIg4PlpcVApBfyYdQE7jp+XuyQiInIAsoab5cuX44EHHsD8+fMRGxuLFStWIDw8HKtWrWpze09PTwQFBZkehw4dQllZGe6///4erpw6qre/G35/QxQAYNk3GdA1GmSuiIiI7J1s4Uav1+Pw4cOYOHFii/aJEydiz549HXqP1atXY/z48YiIiGh3G51Oh8rKyhYP6lmP3NIX/u4anC2txce7z8pdDhER2TnZwk1JSQkMBgMCAwNbtAcGBqKoqOiq+xcWFuLbb7/F/PnzzW6XnJwMT09P0yM8PPya6qbOc9M4Ycnk/gCAd3acRFFFvcwVERGRPZN9QLEgCC1+FkWxVVtb1qxZAy8vL8ycOdPsdkuWLEFFRYXpkZeXdy3lUhfNHBqKYb28UKs34NVvM+Uuh4iI7Jhs4cbPzw9KpbJVL01xcXGr3pwriaKIjz/+GHPmzIFarTa7rUajgYeHR4sH9TyFQsCL0wdAEICvjxTg0NmLcpdERER2SrZwo1arER8fj5SUlBbtKSkpGDVqlNl9U1NTcerUKTzwwAPdWSJZ2OAwL8xOkC4LvrA5HQYj150iIiLLk/Wy1KJFi/DRRx/h448/RmZmJh577DHk5ubiwQcfBCBdUpo7d26r/VavXo0RI0Zg4MCBPV0yXaMnJ8XAXeuE9IJKbDjIS4RERGR5soab2bNnY8WKFVi2bBmGDh2Kn376CVu3bjXd/VRYWNhqzpuKigps3LiRvTY2ytdNg0UT+gEA/vH9cVTUNshcERER2RtBFEWHujZQWVkJT09PVFRUcPyNTBoMRkx9exdOnK/GfYkRWDqDPXBERGReZ76/Zb9bihyPSqnAC0nSkhnr9uXgeBHnHiIiIsthuCFZjI72w+SBQTCKwIub0+FgHYhERNSNGG5INs9MiYXGSYF92Rex9djVJ24kIiLqCIYbkk24jwv+fHMfAMDftmSgTs91p4iI6Nox3JCsHrypD0K9nFFQUY9VqaflLoeIiOwAww3JSqtS4rmpsQCA91NPI+9ircwVERGRrWO4IdndOjAIo/r4Qt9oxMtbMuQuh4iIbBzDDclOEAS8kDQASoWA79PPY9fJC3KXRERENozhhqxCTJA75oyUZqZe+k0GGgxGmSsiIiJbxXBDVuOx8f3g46rGqeJqrN2bI3c5RERkoxhuyGp4uqiweFIMAGBFygmUVOtkroiIiGwRww1ZlTsSwjEo1BNVukb847ssucshIiIbxHBDVkWpEPDi9DgAwH8O5+HXvHJ5CyIiIpvDcENWJz7CB7+7LhSiCLywOR1GI9edIiKijmO4Iav01OT+cFUrcSSvHF+l5ctdDhER2RCGG7JKgR5aPDKuLwDg1W+Po6q+QeaKiIjIVjDckNX6/ego9PZzRUm1Du/sOCV3OUREZCMYbshqqZ0U+GuSNLj4491ncKq4WuaKiIjIFjDckFUbGxOAcf0D0GgUsex/GRBFDi4mIiLzGG7I6v11WhzUSgV+OnEB2zOL5S6HiIisHMMNWb1IP1c8MCYKAPDS/zJQ32CQuSIiIrJmDDdkEx4eG41ADw1yL9Zi9e4zcpdDRERWjOGGbIKrxglLJscCAN7dcQqFFXUyV0RERNaK4YZsxoyhIUiI8EZdgwHJW4/LXQ4REVkphhuyGYIg4MXpAyAIwOZfC3DgzEW5SyIiIivEcEM2ZWCoJ+4a3guAtO6UgetOERHRFRhuyOY8MTEGHlonZBZW4tMDuXKXQ0REVobhhmyOj6saj0+MAQC8sS0LZTV6mSsiIiJrwnBDNumeEb3QP8gd5bUNWJ5yQu5yiIjIinQp3Pz73//Gli1bTD8vXrwYXl5eGDVqFHJycixWHFF7nJQKvJA0AACwfn8OMgoqZa6IiIisRZfCzSuvvAJnZ2cAwN69e/Huu+/itddeg5+fHx577DGLFkjUnsQ+vpg6OBhGEXjxm3SuO0VERAC6GG7y8vIQHR0NAPj6669x++23449//COSk5Oxa9cuixZIZM4zU2KhVSlw4MxFfHO0UO5yiIjICnQp3Li5uaG0tBQAsG3bNowfPx4AoNVqUVfHmWOp54R6OeMvN0tB+5UtmajVN8pcERERya1L4WbChAmYP38+5s+fjxMnTmDq1KkAgPT0dERGRlqyPqKr+uONvRHm7Yyiynqs/PG03OUQEZHMuhRu3nvvPSQmJuLChQvYuHEjfH19AQCHDx/GXXfdZdECia5Gq1LiualxAIAPf8pGTmmNzBUREZGcBNHBRmFWVlbC09MTFRUV8PDwkLscshBRFDH34wPYdbIEE+IC8c+5CXKXREREFtSZ7+8u9dx899132L17t+nn9957D0OHDsXdd9+NsrKyrrwl0TURBAEvJMXBSSEgJeM8Uk9ckLskIiKSSZfCzZNPPonKSmlekWPHjuHxxx/HlClTkJ2djUWLFlm0QKKOig5wx32jIgEAS79Jh77RKG9BREQkiy6FmzNnziAuThrjsHHjRkybNg2vvPIKVq5ciW+//daiBRJ1xsLxfeHnpkb2hRr8e89ZucshIiIZdCncqNVq1NbWAgC2b9+OiRMnAgB8fHxMPTpEcvDQqrB4Un8AwFs/nERxVb3MFRERUU/rUri54YYbsGjRIrz00ks4cOCA6VbwEydOICwszKIFEnXW7fFhGBzmiWpdI177LkvucoiIqId1Kdy8++67cHJywpdffolVq1YhNDQUAPDtt9/i1ltvtWiBRJ2lUAhYOl1ad+rLw+eQlstB7kREjoS3gpPdeuKLX/Hl4XMYEuaJTX8ZDYVCkLskIiLqos58fzt19UMMBgO+/vprZGZmQhAExMbGYsaMGVAqlV19SyKLWnxrDL77rQi/nqvAl7+cw6yEcLlLIiKiHtClcHPq1ClMmTIF+fn5iImJgSiKOHHiBMLDw7Flyxb06dPH0nUSdVqAuxYLx/XF37Zm4rXvjuPWgUHw0KrkLouIiLpZl8bcLFiwAH369EFeXh5++eUXpKWlITc3F1FRUViwYIGlayTqsvtGRaK3vytKqvV4a/tJucshIqIe0KVwk5qaitdeew0+Pj6mNl9fX7z66qtITU21WHFE10rtpMDz06Q5mf695yxOnq+SuSIiIupuXQo3Go0GVVWtvySqq6uhVquvuSgiS7o5JgDjYwPRaBSx9JsMONgYeiIih9OlcDNt2jT88Y9/xP79+yGKIkRRxL59+/Dggw9i+vTplq6R6Jo9Py0OaicFdp8qwbaM83KXQ0RE3ahL4ebtt99Gnz59kJiYCK1WC61Wi1GjRiE6OhorVqywcIlE166Xrwv+OKY3AOCl/2WgvsEgc0VERNRdrmmem1OnTiEzMxOiKCIuLg7R0dGWrK1bcJ4bx1Wrb8Qtr6eiqLIeiyb0w4JxfeUuiYiIOqgz398dDjedWe17+fLlHd62pzHcOLbNvxZgwWdp0KoU+OHxmxHq5Sx3SURE1AHdMolfWlpah7YTBM4CS9YraXAwPtmbgwNnL+KVrZl47+5hcpdEREQWxuUXyOGkF1Qg6Z3dMIrAZ38YicQ+vnKXREREV9GZ7+8uDSgmsmUDQjxx94heAICl36Sj0WCUuSIiIrIkhhtySI9PiIGXiwrHi6rw6YFcucshIiILYrghh+TtqsbjE2MAAG9sO4GLNXqZKyIiIkthuCGHdffwXogN9kBFXQNe35YldzlERGQhDDfksJQKAS8mSetOfXYgF7/lV8hcERERWYLs4WblypWIioqCVqtFfHw8du3aZXZ7nU6HZ599FhEREdBoNOjTpw8+/vjjHqqW7M2I3r5IGhICUQRe3JzOdaeIiOyArOFmw4YNePTRR/Hss88iLS0NY8aMweTJk5Gb2/4Az1mzZuGHH37A6tWrkZWVhc8++wz9+/fvwarJ3jwzpT+cVUocyinD5l8L5C6HiIiukazz3IwYMQLDhg3DqlWrTG2xsbGYOXMmkpOTW23/3Xff4c4770R2djZ8fHy69Jmc54ba8t6Pp/CP77MQ6KHBjsdvhqumw/NbEhFRD7CJeW70ej0OHz6MiRMntmifOHEi9uzZ0+Y+mzdvRkJCAl577TWEhoaiX79+eOKJJ1BXV9fu5+h0OlRWVrZ4EF3pgRui0MvHBecrdfjjukP4+VQJL1EREdko2f55WlJSAoPBgMDAwBbtgYGBKCoqanOf7Oxs7N69G1qtFps2bUJJSQn+8pe/4OLFi+2Ou0lOTsbSpUstXj/ZF61KiaUzBmD+vw/h51Ol+PlUKfr4u2LOyAj8X3wY3LUquUskIqIOkn1A8ZVrUYmi2O76VEajEYIgYP369Rg+fDimTJmC5cuXY82aNe323ixZsgQVFRWmR15ensWPgezD2JgAfLdwDOaMjICrWonTF2rw4jcZGPHKD3h20zFkFVXJXSIREXWAbD03fn5+UCqVrXppiouLW/XmNAkODkZoaCg8PT1NbbGxsRBFEefOnUPfvn1b7aPRaKDRaCxbPNmtvoHueGnmQCy+NQab0vKxdm8OThVXY/3+XKzfn4vhUT6YmxiBSQOCoFLK/m8DIiJqg2x/O6vVasTHxyMlJaVFe0pKCkaNGtXmPqNHj0ZBQQGqq6tNbSdOnIBCoUBYWFi31kuOxV2rwtzESKQ8diM+nT8CkwcGQakQcODMRTz8aRpGv7oDb6acwPnKerlLJSKiK8h6t9SGDRswZ84cvP/++0hMTMSHH36If/7zn0hPT0dERASWLFmC/Px8rF27FgBQXV2N2NhYjBw5EkuXLkVJSQnmz5+Pm266Cf/85z879Jm8W4q6qrCiDp/tz8WnB/JQUq0DADgpBEwaEIQ5iREYEeXT7iVVIiK6Np35/pb1ftfZs2ejtLQUy5YtQ2FhIQYOHIitW7ciIiICAFBYWNhizhs3NzekpKTgkUceQUJCAnx9fTFr1iy8/PLLch0COZBgT2csmhiDh2/pi+/Si7Bu71kcPFuGLccKseVYIWIC3XFvYgRuuy4UbryVnIhINrL23MiBPTdkSRkFlVi3Lwdfp+WjrsEAAHDTOOH/hoViTmIEogPcZa6QiMg+dOb7m+GGyAIq6hqw8fA5fLIvB9klNab2UX18MTcxAuNjA+HEAchERF3GcGMGww11J6NRxM+nS7B2bw5+yDwP46X/u4I9tbh7eC/cObwX/N159x4RUWcx3JjBcEM95VxZLT7dn4vPD+bhYo0eAKBSCpg8MBhzEyMQH+HNAchERB3EcGMGww31NF2jAVuPFWLt3hyk5Zab2uOCPTAnMQIzhobARc0ByERE5jDcmMFwQ3I6dq4C6/adxX+PFEDXaAQAuGudcEd8OOYkRiDKz1XmComIrBPDjRkMN2QNymv1+OLQOazbl4Pci7Wm9jF9/TA3MRK39A+AUsFLVkRETRhuzGC4IWtiNIpIPXkB6/bm4MesYjT93xjq5Yx7RvbC7IRw+LpxADIREcONGQw3ZK1yS2uxfn8ONhzKQ3ltAwBA7aTAtEHBmJMYgaHhXhyATEQOi+HGDIYbsnb1DQZ882sB1u3LwdFzFab2QaGemJMYgelDQqBVKWWskIio5zHcmMFwQ7bkSF451u49i//9Wgi9QRqA7OWiwqyEcNw7IgK9fF1krpCIqGcw3JjBcEO2qLRahw2H8rB+Xy7yy+sAAIIA3NzPH3MTI3FTP38oOACZiOwYw40ZDDdkywxGETuOF2Pt3rPYdbLE1N7LxwX3juyFWQnh8HJRy1ghEVH3YLgxg+GG7EX2hWp8si8XXxzOQ1V9IwBA46TA9CEhmJsYiUFhnjJXSERkOQw3ZjDckL2p1Tfiv0cKsHZvDjILK03tQ8O9MDcxAlMGBXMAMhHZPIYbMxhuyF6JoojDOWVYuzcH3/5WiAaD9L+2j6sas68Pxz0jeiHMmwOQicg2MdyYwXBDjuBClQ6fH8jFpwdyUVhRDwBQCMAt/QMxNzECN0T7cQAyEdkUhhszGG7IkTQajNieeR5r9+Zgz+lSU3uUnyvuHRmB2+PD4OmskrFCIqKOYbgxg+GGHNWp4iqs25uDjb/ko1onDUB2Vikx87oQzBkZibgQ/v9ARNaL4cYMhhtydNW6RmxKy8e6vWdx4ny1qT0hwhtzEiMweWAw1E4KGSskImqN4cYMhhsiiSiK2H/mItbtzcH36UVoNEp/Ffi5aXDX8HDcPaIXgj2dZa6SiEjCcGMGww1Ra+cr6/Hp/lx8diAXxVU6AIBSIWBCrDQAObGPLxftJCJZMdyYwXBD1L4GgxHfpxdh3d4c7D9z0dQeHeCGOSMj8LthoXDXcgAyEfU8hhszGG6IOiarqApr957FprR81OoNAABXtRK3DQvF3MRI9At0l7lCInIkDDdmMNwQdU5lfQO+OnwO6/bl4PSFGlP7iCgfzE2MxMQBgVApOQCZiLoXw40ZDDdEXSOKIvaeLsW/955FSsZ5XBp/jEAPDe4a3gt3D++FAA+tvEUSkd1iuDGD4Ybo2hWU1+HT/bn4/GAuSqr1AAAnhYBJA4Mwd2QEhkf5cAAyEVkUw40ZDDdElqNvNOLb3wqxdm8ODueUmdr7B7nj3pERuO26ULhqnGSskIjsBcONGQw3RN0jvaACn+zLwddpBahrkAYgu2uc8H/xYbh3ZASiA9xkrpCIbBnDjRkMN0Tdq6KuAV8ePod1e8/ibGmtqX10tC/mjIzE+NgAOHEAMhF1EsONGQw3RD3DaBSx61QJ1u09ix+OF6Ppb5oQTy3uHtELdw7vBT83jbxFEpHNYLgxg+GGqOflXazF+v252HAwF2W1DQAAlVLAlEHBmJsYgWG9vDkAmYjMYrgxg+GGSD71DQZsOVqItfty8Gteuak9LtgDcxMjMGNoKJzVSvkKJCKrxXBjBsMNkXU4eq4ca/fm4JtfC6BrNAIAPLROuCMhHHNGRiDSz1XmConImjDcmMFwQ2Rdymr0+M+hPHyyPwd5F+tM7Tf288fckREY2z8ASgUvWRE5OoYbMxhuiKyTwSgi9UQx1u7NQeqJC6YByGHezrhnRARmXx8OH1e1vEUSkWwYbsxguCGyfjmlNfhkXw7+c+gcKuqkAchqJwWmDQ7G3MRIDA33krdAIupxDDdmMNwQ2Y46vQHf/FqAtfvO4rf8SlP74DBPzBkZgaQhIdCqOACZyBEw3JjBcENke0RRRFpeOdbtzcGWo4XQG6QByF4uKsxOCMe9IyMQ7uMic5VE1J0YbsxguCGybSXVOmw4mIdP9+civ1wagCwIwNiYAMxJjMBNff2h4ABkIrvDcGMGww2RfTAYRfyQeR7r9uVg18kSU3uolzNig90R4uVseoR6aRHq5QJ/dw3vvCKyUQw3ZjDcENmf7AvVWLcvB18ePoeq+sZ2t3NSCAjy1F4KPNJDCkBa03OuYk5knRhuzGC4IbJftfpGHDhzEfnldcgvq0NBeR0KyuuRX16Hosp6GIxX/+vOy0WFEM/mHp8QL2eEejubApG/m4aXvYhk0Jnvb/4ThYjshovaCTfHBLT5msEo4nxlPQrK65B/KfQ0P5f+rKpvRHltA8prG5BRWNnm+6iUUu9PqFdz4Alp8VwLFzX/aiWSE/8PJCKHoFQIphCS0M42lfUNKCyvR355LfIvhZ+mR36Z1PvTYBCRd7GuxWzKV/J2UbUIPFde/vJj7w9Rt2K4ISK6xEOrgkeQCjFB7m2+3mgw4nyVzhR4zpXVXRaApMtf1bpGlNU2oKy2AekFbff+qJUKBHtpW1z+arr0FeLljBBPZy4gSnQNGG6IiDrISakw9cS0p6KuoWWPz6XQ0/Tz+cp66A1G5JTWIqe0tt338XFVmy5zXX75q+lPPzc1BIG9P0RtYbghIrIgT2cVPJ1ViA1ue8Bjg8GI85X10oDniuYen8svf9XoDbhYo8fFGj2O5Ve0+T5qJwVCPNsOPk2BiLM3k6NiuCEi6kEqpQJh3i4I8257RmVRFFFZ19gceCqkwJN/2eWv81X10Dcacba0FmfN9P74ualNl7ma7vpqugMsxMsZvq7s/SH7xHBDRGRFBEGAp4sKni4qxIW03fujb7zU+9PO5a/8sjrUNRhQUq1HSbUeR8+13fujcVK06u0J8XJG2KU/gzy17P0hm8RwQ0RkY9ROCoT7uLS7npYoiqioa2g5309Fy/BTXKWDrtGI7JIaZJfUtPtZfm6a5gHPnq1ve/dh7w9ZIYYbIiI7IwgCvFzU8HJRY0CIZ5vb6BoNOF+hazHPz5V/1jcYUVKtQ0m1Dr+20/ujVSmaw85ll7+abnsP8tRC48TeH+pZDDdERA5I46REL18X9PJtv/enrLahReBpGvNz7tLzC1U61DcYkX2hBtkX2u/98XfXXDbfj7bVHEBeLir2/pBFMdwQEVErgiDAx1UNH1c1Boa23/tTdOlyl3T5q755EPSlNl2jEReqdLhQpcORvPI238dZpTSFnjBvZ/Txd8Mt/QPQ29+tG4+Q7BnXliIiom4hiiIu1uhb3O5+5SDokmpdu/v38XfF+LhATIwLxNBwb67o7uC4cKYZDDdERNajvsGAwormdb7yy+rwS24Z9p4uReNlC536uakxrn8gJsQF4oa+fryLywEx3JjBcENEZP0q6xuwM+sCtmecx49ZxaiqbzS9plUpMKavPybEBWJc/wD4umlkrJR6CsONGQw3RES2Rd9oxIEzF5GSUYTtmcXIL29etFQQgPhe3pgQJ/XqcJyO/WK4MYPhhojIdomiiIzCSqRknEdKxvlWi5NynI79Yrgxg+GGiMh+5JfX4YdMKehwnI59s6lws3LlSvzjH/9AYWEhBgwYgBUrVmDMmDFtbrtz506MHTu2VXtmZib69+/foc9juCEisk8cp2PfOvP9Les8Nxs2bMCjjz6KlStXYvTo0fjggw8wefJkZGRkoFevXu3ul5WV1eLA/P39e6JcIiKyYh5aFaYPCcH0ISFtjtNpupTFcTr2T9aemxEjRmDYsGFYtWqVqS02NhYzZ85EcnJyq+2bem7Kysrg5eXVpc9kzw0RkWPhOB37YBM9N3q9HocPH8bTTz/don3ixInYs2eP2X2vu+461NfXIy4uDs8991ybl6qIiIgAabblASGeGBDiiUfH92s1Tuf0hRqcTs3GB6nZHKdjJ2QLNyUlJTAYDAgMDGzRHhgYiKKiojb3CQ4Oxocffoj4+HjodDqsW7cO48aNw86dO3HjjTe2uY9Op4NO1zwDZmVlZZvbERGRYwj1csbcxEjMTYxsNU6npFqPDYfysOFQHsfp2DDZ15a6crE0URTbXUAtJiYGMTExpp8TExORl5eH119/vd1wk5ycjKVLl1quYCIishscp2OfZBtzo9fr4eLigi+++AK33XabqX3hwoU4cuQIUlNTO/Q+f/vb3/DJJ58gMzOzzdfb6rkJDw/nmBsiImoXx+lYH5sYc6NWqxEfH4+UlJQW4SYlJQUzZszo8PukpaUhODi43dc1Gg00GnYlEhFRx3Gcjm2T9bLUokWLMGfOHCQkJCAxMREffvghcnNz8eCDDwIAlixZgvz8fKxduxYAsGLFCkRGRmLAgAHQ6/X45JNPsHHjRmzcuFHOwyAiIjvHcTq2RdZwM3v2bJSWlmLZsmUoLCzEwIEDsXXrVkRERAAACgsLkZuba9per9fjiSeeQH5+PpydnTFgwABs2bIFU6ZMkesQiIjIwbQ1Tmf7pV4djtOxDrLPUNzTOM8NERF1h8vH6WzPPI/f8jlOx5JsavmFnsZwQ0REPaGgvM7Uo7MvuxQNBq57dS0YbsxguCEiop5WWd+A1KwLSOG6V13GcGMGww0REcmprXE6TRQCEB/hjfGxHKdzJYYbMxhuiIjIWnRknM6EuCBMiAvEdeFeUDjwOB2GGzMYboiIyFpxnE77GG7MYLghIiJbwHE6LTHcmMFwQ0REtobjdBhuzGK4ISIiW+ao43QYbsxguCEiInviKON0GG7MYLghIiJ7Zc/jdBhuzGC4ISIiR2Bv43QYbsxguCEiIkdjD+N0GG7MYLghIiJHZ4vjdBhuzOjWcFN7EXDxsex7EhERdSNbGafDcGNGt4UbQwPw1lDAOxIYvRDoOwEQrK9bj4iIqD0NBmmcTkqG9Y3TYbgxo9vCTe4+YM1UwHgp8frHAqMXAANvB5zUlvscIiKiHtA0Tmd7RjFSMotkH6fDcGNGt16WqsgH9q8CDq0B9FVSm3sIMPLPQPw8QMsxPkREZJvkHqfDcGNGjwworisHDv8L2Pc+UF0ktWk8gIT7gRF/BjyCu+dziYiIekBHxumsmD0Urhony30mw037evRuqUYdcPQ/wJ53gJIsqU2hAobMBkYtAPxjuvfziYiIullb43QifF2w84mbIVhw7CnDjRmy3ApuNAInvwd+fhvI3dPc3m+yNPi410gOPiYiIpsniiIyC6tQUq3Djf38LfreDDdmyD7PTd5BYM9bQOb/AFz61YddL/Xk9J8KKKxjPgEiIiJrwnBjhuzhpknJKWDvO8CRzwCDTmrz6QOMegQYcheg0spXGxERkZVhuDHDasJNk+piYP8HwMGPgPpyqc3VHxjxJyDhAU4KSEREBIYbs6wu3DTRVQNp64C97wEVeVKbyhUYNhdI/Avg1Uve+oiIiK6moR4ozwF0VUBYgkXfmuHGDKsNN00MDUD618DPbwHnj0ltghIY+DtpXE7wYFnLIyIiByaK0lJDZWeAsrPAxUt/Nv1cWQBABLyjgIVHLPrRnfn+ttwN6GQZShUw+A5g0O3A6R3AnreB7J3AsS+kR++x0h1WvW/mHVZERGR5hkbpCkKbASYH0FWa31/tDjh7S0FIpu8p9tzYgsJfpdvI0zcBokFqCxoEjH4UiJsJKJlRiYioE+orW/a4XB5gyvOav2va4xEqraXoHSX96RPV/LOLT7eEGl6WMsMmw02Tshxg30rgl7VAQ63U5tULGPkQMGwOoHaVtz4iIrIORiNQVdh+gKktNb+/k/ZSWIlsHWC8ImS5o5fhxgybDjdNai8CB1cD+98HakukNmdv4Pr5wPA/AW6WnTiJiIisUEOd9I/epsBy5eWjpmlG2uPi17LH5fIA4xYEKBTdfgidwXBjhl2EmyYNdcCRT4G97wIXs6U2Jy0w9G4g8WHAt4+89RH1lLoyIOs7IHMzkH8Y0HoCrgGAqx/gFiBNr+Dq3/K5qz+gcZO7cqL2iaLUw3J5aLn8eVWh+f0VToBnePsBRuPe7YdgSQw3ZthVuGliNADH/yfdYZV/+FKjAMQmSYOPLXw7HpFVqCkFsrYAGf8FslMBY0Pn30PlckXw8ZNC0eXPm17Telndv2TJDhgapMG7rQLMpR4ZfZX5/TUerce8NP3sEWZXYzIZbsywy3DTRBSBnD3SHVYnvmtujxgt3UbedyL/cibbVl0MZH4jBZqzu1sOevSPBeJmANHjgMZ6aduaEqCmGKi5AFRfaPm8sa5zn61wkrrx3fwvCz1NvUABLZ+7+kl3PhIBQH3FZWNerhj/UnHuKoN3hebBuz6RlwWYKCnAOHs7zJ2zDDdm2HW4uVxxprQa+dH/NP+L1r+/FHIG3QE4qeWtj6ijKguaA03OHpjWZAOAoMFA3HQgdgbg36/j7ymKgL5GCjvVF6TAU3MpDFUXX/H8QvPs4Z3h7H31ENT0nDcD2DajEagqaD/A1F00v7+Tc/Pg3ct7YHyipMtKXI4HAMONWQ4TbppUFgD7VgGH1zTPTeAeDIz8MxA/TxqbQGRtynKk8TMZm4FzB1q+FhoPxE6XQo1P756pp1F/KQBdejSFnjZ/Lrn6bbRXUrleNj7oKmOFHOhf6laloe7SZaOzrQNMeQ5g0Jvf39W/7dumfaIAt0Ce0w5guDHD4cJNk/oKKeDsW9U8CE3tDiTcLwUdjxBZyyNC6WmpdyZzM1CQ1vK18JHSJafYJMArXJ76OspolAY41xSbD0FNl8ka6zv3/gqnloOi2xsr5BYAuPjy8lhHiaIUTFvddXRW+rm6yPz+Cidpao62Aox3JAevWwDDjRkOG26aNOqlmY73vA1cOC61KVTA4FnSiuQBsfLWR46l+PilHpr/Aud/a24XFNJYsbgZQP9pgEewfDV2J1EE9NUtxweZGytUX9H5z3D2ad370+LS2GWBSO1i+WO0Jo365pl3TQHmsoe+2vz+Gs9L414uDzCXnnuE2tXgXWvEcGOGw4ebJkYjcCpFusMq5+fm9r6TpDusIkaxm5QsTxSlEJNxKdCUZDW/JiiBqBubAw3na2qtUXdFz8+F9scN1ZYAorFz769y7diAaTd/6e4xa/w7oq68nXlfzl4avGvudyIAnmGXTV4X2TLAuPh0e/nUPoYbMxhu2nDukBRyMr+BabBmaLwUcvpPAxRKWcsjGyeK0mWmpktOTXMyAVKvYZ+xUqCJmcIvD0syGqTLYy0uhRW3DkFN7Veb8O1KCtWlsNOBsUIufpbr1TAapLGE7S3cWFdmfn+VSzsz70ZJlzydNJapkyyO4cYMhhszSk9LEwKmrW/+i86ntzQh4NC7AZWzvPWR7TAagfxDUqDJ2AxU5Da/ptQAfSdIg4L7TQKcvWQrky4RRUBX1c7YoCvHDV0AdF28PNbeIOkrn4uimXWPcjsweDeg9aDdpuduAdbZ40RXxXBjBsNNB1RfAA58KD2aboF18QNG/Ela4oH/uqa2GA1A7r5LPTTfSLfGNlG5SPMsxU2X/rSxmVHpCg310mWv9sYKXf68trTzl8euRqGSBu+2GWAieWu9nWK4MYPhphN01UDaJ8De95r/5a1yAYbNBUb+BfCOkLc+kp+hETi7S7rclPmN9C/7Jmp3IOZW6ZJTn3H2P1iV2mY0SOvhtRggbWasUFOvsdar7dummwbv8nK5w2G4MYPhpgsMjUDG19K4nKKjUpugBAbcBoxeAAQPkbU86mGNeuBMqtRDc3xLywnKtJ5AzFQp0PS+mZOPUeeIojQfl2iU5vMhugzDjRkMN9dAFIHsndJt5Kd3NLf3vlma+bjPLbyWba8a6qVznvFfIOvblmMuXHylgedx04HIGzn7NRF1C4YbMxhuLKTwqLS8w28bm2djDRwk3WE1YCYnDrMH+hrg1HYp0Jz4vuUcIG6B0oR6sdOl+Wg4vwcRdTOGGzMYbiysPBfYuxL4ZS3QUCO1eYYDiQ8B183hrJy2RlclBZmM/wInU1ouLukRemnZgxlA+HCOeSCiHsVwYwbDTTepvQgcWg3s/6B5UKnWS7q7asSfpNsvyTrVlUuXmjI3A6d+aDnfiVeEdLkpbiYQMoyryhORbBhuzGC46WYN9cCvn0mXrC6eltqUGmDoXUDiI4BftLz1kaSmFMjaIvXQZKc2rxwPAD59pN6ZuBnSYHGOoyIiK8BwYwbDTQ8xGoCsrdIdVucOXmoUgP5TgdGPAuHXy1mdY6oulm7XzvgvcHZ3y5Wr/WMvBZrpQEAcAw0RWR2GGzMYbnqYKEoTu/38FnDi2+b2XonS4OO+k3ipoztVFjQHmpw9MC2vAQBBgy6ttD0D8O8nW4lERB3Rme9v3uJA3UsQgIhE6VF8HNj7DvDrBiB3r/Twi5FWIx88i2u6WEpZzqWVtjcD5w60fC1kWHMPjU9veeojIupm7LmhnldZCOx/Hzj0sTRhFwC4BQEjHwTi7+daQ11Rerp5YcqCtJavhY+41EOTJE1ZT0Rkg3hZygyGGytSXwn88m/pVvKmdYjU7kDCPGDEnwHPUFnLs3rFxy/10PwXOP9bc7ugkOaeiZ0OxE4DPELkq5GIyEIYbsxguLFCjXppMsCf3wIuZEptCidg0CzpklVgnLz1WQtRlEJMxqVAU5LV/JqgBKJulC439Z/GW++JyO4w3JjBcGPFRFGaOG7P29JijE36TpSWd4i8wfHu4hFF6TJT0yWni9nNrylUQJ+x0iWnmClcrZ2I7BrDjRkMNzYi/zDw89vSF7polNpChkl3WMUm2ffsuEYjkH9ICjQZm5tXZAekOYOix0uBpt8kjk8iIofBcGMGw42NKT0N7H0POLIeaKyX2ryjgFEPA0PvAVTO8tZnKUaDdMt8xn+lW7ebxiABgMpF6r2Kmy79qXGXr04iIpkw3JjBcGOjakqAAx9Kj7oyqc3FFxj+J2D4H2zzkoyhUbr8lrlZCjRNy1YA0sDqmFulQcHR4wG1i3x1EhFZAYYbMxhubJy+BkhbD+x9FyjPkdpULsB190qLdXpHylreVTXqgTOpUg/N8S1A3cXm17SeQMxU6ZJT75sBlVa2MomIrA3DjRkMN3bC0Ahk/le6w6rwV6lNUEgLPI5eAIRcJ2t5LTTUA6d3SIEm61tAV9H8mouvtCRF3Awg8kbASS1fnUREVsymws3KlSvxj3/8A4WFhRgwYABWrFiBMWPGXHW/n3/+GTfddBMGDhyII0eOdPjzGG7sjCgCZ36SQs7pH5rbo26UBh/3GSfPHVb6GuDUdinQnPge0Fc3v+YWKN2uHTdDmo9GyYnCiYiuxmbCzYYNGzBnzhysXLkSo0ePxgcffICPPvoIGRkZ6NWr/ZlUKyoqMGzYMERHR+P8+fMMNyQpOiatRv7bRsDYKLUFDpRuIx/4O0Cp6t7P11VJQSbjv9It7Y11za+5hzQvexA+wr7v9iIi6gY2E25GjBiBYcOGYdWqVaa22NhYzJw5E8nJye3ud+edd6Jv375QKpX4+uuvGW6opfI8YN8q4PAaoKFGavMIAxL/Agyba9m7jerKpUtNmZuBUz8ABl3za169mhemDI3nAqFERNfAJhbO1Ov1OHz4MJ5++ukW7RMnTsSePXva3e9f//oXTp8+jU8++QQvv/xyd5dJtsgrHLj1FeCmJ6X1q/a9D1SeA75/Bkj9O3D9fOkuK/fArr1/TSmQtUXqoclOBYwNza/59GnuoQke6niTDhIRWQHZwk1JSQkMBgMCA1t+wQQGBqKoqKjNfU6ePImnn34au3btgpNTx0rX6XTQ6Zr/NV1ZWdn1osm2OHsDYx4HRj4EHN0gzXxcegrY9YZ0+WrIXdLyDn59r/5e1cXS7doZ/wXO7gZEQ/Nr/v0vBZoZQEAcAw0RkcxkH8koXPFFIIpiqzYAMBgMuPvuu7F06VL069evw++fnJyMpUuXXnOdZMNUWiD+PuC6OUDWVmnw8bkD0qKdv6yV7lYatQDoNaLlfpUFzYEmZw+Ay67gBg2SLjfFTQf8Y3r0cIiIyDzZxtzo9Xq4uLjgiy++wG233WZqX7hwIY4cOYLU1NQW25eXl8Pb2xtKZfNATKPRCFEUoVQqsW3bNtxyyy2tPqetnpvw8HCOuXF0ufuk5R2ytjS3hY8ERj4IVORLgebcgZb7hAyTwkzsdMC3T8/WS0Tk4GxizI1arUZ8fDxSUlJahJuUlBTMmDGj1fYeHh44duxYi7aVK1dix44d+PLLLxEVFdXm52g0Gmg0GssWT7av10jpceEEsPcd4NfPgbx90uNy4SMuDQpOkgYIExGR1ZP1stSiRYswZ84cJCQkIDExER9++CFyc3Px4IMPAgCWLFmC/Px8rF27FgqFAgMHDmyxf0BAALRabat2og7z7wdMfwcY+yyw/33g2MbL7nKaBniEyF0hERF1kqzhZvbs2SgtLcWyZctQWFiIgQMHYuvWrYiIiAAAFBYWIjc39yrvQmQB7kHA+BelBxER2TTZZyjuaZznhoiIyPZ05vubs4oRERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVhhsiIiKyKww3REREZFcYboiIiMiuMNwQERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVJ7kL6GlNi6BXVlbKXAkRERF1VNP3dtP3uDkOF26qqqoAAOHh4TJXQkRERJ1VVVUFT09Ps9sIYkcikB0xGo0oKCiAu7s7BEGw6HtXVlYiPDwceXl58PDwsOh7WwN7Pz7A/o+Rx2f77P0YeXy2r7uOURRFVFVVISQkBAqF+VE1Dtdzo1AoEBYW1q2f4eHhYbf/0QL2f3yA/R8jj8/22fsx8vhsX3cc49V6bJpwQDERERHZFYYbIiIisisMNxak0WjwwgsvQKPRyF1Kt7D34wPs/xh5fLbP3o+Rx2f7rOEYHW5AMREREdk39twQERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDTQf99NNPSEpKQkhICARBwNdff33VfVJTUxEfHw+tVovevXvj/fff7/5Cr0Fnj3Hnzp0QBKHV4/jx4z1TcCclJyfj+uuvh7u7OwICAjBz5kxkZWVddT9bOY9dOT5bOoerVq3C4MGDTRODJSYm4ttvvzW7j62cuyadPUZbOn9tSU5OhiAIePTRR81uZ2vnsUlHjs/WzuGLL77YqtagoCCz+8hx/hhuOqimpgZDhgzBu+++26Htz5w5gylTpmDMmDFIS0vDM888gwULFmDjxo3dXGnXdfYYm2RlZaGwsND06Nu3bzdVeG1SU1Px0EMPYd++fUhJSUFjYyMmTpyImpqadvexpfPYleNrYgvnMCwsDK+++ioOHTqEQ4cO4ZZbbsGMGTOQnp7e5va2dO6adPYYm9jC+bvSwYMH8eGHH2Lw4MFmt7PF8wh0/Pia2NI5HDBgQItajx071u62sp0/kToNgLhp0yaz2yxevFjs379/i7Y//elP4siRI7uxMsvpyDH++OOPIgCxrKysR2qytOLiYhGAmJqa2u42tnweO3J8tn4Ovb29xY8++qjN12z53F3O3DHa6vmrqqoS+/btK6akpIg33XSTuHDhwna3tcXz2Jnjs7Vz+MILL4hDhgzp8PZynT/23HSTvXv3YuLEiS3aJk2ahEOHDqGhoUGmqrrHddddh+DgYIwbNw4//vij3OV0WEVFBQDAx8en3W1s+Tx25Pia2No5NBgM+Pzzz1FTU4PExMQ2t7Hlcwd07Bib2Nr5e+ihhzB16lSMHz/+qtva4nnszPE1saVzePLkSYSEhCAqKgp33nknsrOz291WrvPncAtn9pSioiIEBga2aAsMDERjYyNKSkoQHBwsU2WWExwcjA8//BDx8fHQ6XRYt24dxo0bh507d+LGG2+UuzyzRFHEokWLcMMNN2DgwIHtbmer57Gjx2dr5/DYsWNITExEfX093NzcsGnTJsTFxbW5ra2eu84co62dPwD4/PPP8csvv+DgwYMd2t7WzmNnj8/WzuGIESOwdu1a9OvXD+fPn8fLL7+MUaNGIT09Hb6+vq22l+v8Mdx0I0EQWvwsXpoM+sp2WxUTE4OYmBjTz4mJicjLy8Prr79ulf9TXu7hhx/G0aNHsXv37qtua4vnsaPHZ2vnMCYmBkeOHEF5eTk2btyI++67D6mpqe1++dviuevMMdra+cvLy8PChQuxbds2aLXaDu9nK+exK8dna+dw8uTJpueDBg1CYmIi+vTpg3//+99YtGhRm/vIcf54WaqbBAUFoaioqEVbcXExnJyc2ky39mLkyJE4efKk3GWY9cgjj2Dz5s348ccfERYWZnZbWzyPnTm+tljzOVSr1YiOjkZCQgKSk5MxZMgQvPXWW21ua4vnDujcMbbFms/f4cOHUVxcjPj4eDg5OcHJyQmpqal4++234eTkBIPB0GofWzqPXTm+tljzObySq6srBg0a1G69cp0/9tx0k8TERHzzzTct2rZt24aEhASoVCqZqup+aWlpVtdN3EQURTzyyCPYtGkTdu7ciaioqKvuY0vnsSvH1xZrPodXEkUROp2uzdds6dyZY+4Y22LN52/cuHGt7qy5//770b9/fzz11FNQKpWt9rGl89iV42uLNZ/DK+l0OmRmZmLMmDFtvi7b+evW4cp2pKqqSkxLSxPT0tJEAOLy5cvFtLQ0MScnRxRFUXz66afFOXPmmLbPzs4WXVxcxMcee0zMyMgQV69eLapUKvHLL7+U6xCuqrPH+Oabb4qbNm0ST5w4If7222/i008/LQIQN27cKNchmPXnP/9Z9PT0FHfu3CkWFhaaHrW1taZtbPk8duX4bOkcLlmyRPzpp5/EM2fOiEePHhWfeeYZUaFQiNu2bRNF0bbPXZPOHqMtnb/2XHk3kT2cx8td7fhs7Rw+/vjj4s6dO8Xs7Gxx37594rRp00R3d3fx7Nmzoihaz/ljuOmgptv1rnzcd999oiiK4n333SfedNNNLfbZuXOneN1114lqtVqMjIwUV61a1fOFd0Jnj/Hvf/+72KdPH1Gr1Yre3t7iDTfcIG7ZskWe4jugrWMDIP7rX/8ybWPL57Erx2dL5/D3v/+9GBERIarVatHf318cN26c6UtfFG373DXp7DHa0vlrz5Vf/vZwHi93teOztXM4e/ZsMTg4WFSpVGJISIj4u9/9TkxPTze9bi3nTxDFSyN7iIiIiOwABxQTERGRXWG4ISIiIrvCcENERER2heGGiIiI7ArDDREREdkVhhsiIiKyKww3REREZFcYbojI4e3cuROCIKC8vFzuUojIAhhuiIiIyK4w3BAREZFdYbghItmJoojXXnsNvXv3hrOzM4YMGYIvv/wSQPMloy1btmDIkCHQarUYMWJEq9WXN27ciAEDBkCj0SAyMhJvvPFGi9d1Oh0WL16M8PBwaDQa9O3bF6tXr26xzeHDh5GQkAAXFxeMGjUKWVlZ3XvgRNQtGG6ISHbPPfcc/vWvf2HVqlVIT0/HY489hnvvvRepqammbZ588km8/vrrOHjwIAICAjB9+nQ0NDQAkELJrFmzcOedd+LYsWN48cUX8de//hVr1qwx7T937lx8/vnnePvtt5GZmYn3338fbm5uLep49tln8cYbb+DQoUNwcnLC73//+x45fiKyLC6cSUSyqqmpgZ+fH3bs2IHExERT+/z581FbW4s//vGPGDt2LD7//HPMnj0bAHDx4kWEhYVhzZo1mDVrFu655x5cuHAB27ZtM+2/ePFibNmyBenp6Thx4gRiYmKQkpKC8ePHt6ph586dGDt2LLZv345x48YBALZu3YqpU6eirq4OWq22m38LRGRJ7LkhIlllZGSgvr4eEyZMgJubm+mxdu1anD592rTd5cHHx8cHMTExyMzMBABkZmZi9OjRLd539OjROHnyJAwGA44cOQKlUombbrrJbC2DBw82PQ8ODgYAFBcXX/MxElHPcpK7ACJybEajEQCwZcsWhIaGtnhNo9G0CDhXEgQBgDRmp+l5k8s7pZ2dnTtUi0qlavXeTfURke1gzw0RySouLg4ajQa5ubmIjo5u8QgPDzdtt2/fPtPzsrIynDhxAv379ze9x+7du1u87549e9CvXz8olUoMGjQIRqOxxRgeIrJf7LkhIlm5u7vjiSeewGOPPQaj0YgbbrgBlZWV2LNnD9zc3BAREQEAWLZsGXx9fREYGIhnn30Wfn5+mDlzJgDg8ccfx/XXX4+XXnoJs2fPxt69e/Huu+9i5cqVAIDIyEjcd999+P3vf4+3334bQ4YMQU5ODoqLizFr1iy5Dp2IugnDDRHJ7qWXXkJAQACSk5ORnZ0NLy8vDBs2DM8884zpstCrr76KhQsX4uTJkxgyZAg2b94MtVoNABg2bBj+85//4Pnnn8dLL72E4OBgLFu2DPPmzTN9xqpVq/DMM8/gL3/5C0pLS9GrVy8888wzchwuEXUz3i1FRFat6U6msrIyeHl5yV0OEdkAjrkhIiIiu8JwQ0RERHaFl6WIiIjIrrDnhoiIiOwKww0RERHZFYYbIiIisisMN0RERGRXGG6IiIjIrjDcEBERkV1huCEiIiK7wnBDREREdoXhhoiIiOzK/wMFXmgXDCRe7QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Losses\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_loss) + 1)), arr_train_loss, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_loss) + 1)), arr_val_loss, label=\"val\")\n",
    "\n",
    "  plt.title(\"Loss\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"loss\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxf0lEQVR4nO3deVhV5drH8e9mRgScEQXnnBUVy7mynM0xFRtM085b51gn9TRoo41WR8vKtCxtVCSnsjQNK1OPmoo4jzmBCiIOoCjzev9YSqGozIvN/n2ua19sFmuvfS9WuW+e9Tz3bTMMw0BERETEgThZHYCIiIhIcVMCJCIiIg5HCZCIiIg4HCVAIiIi4nCUAImIiIjDUQIkIiIiDkcJkIiIiDgcJUAiIiLicJQAiYiIiMNRAiQidueLL77AZrNhs9lYtWrVNT83DIN69ephs9m48847r/l5fHw87u7u2Gw2Nm/enON7jBgxIus9cnqIiH1zsToAEZH88vb2ZtasWdckOb///jsHDx7E29s7x9d9/fXXpKamAjBr1ixat26d436enp78+uuvhRqziJQMSoBExG6FhIQwZ84cPvroI3x8fLK2z5o1i3bt2pGYmJjj62bPnk2VKlWoWbMmoaGhvPvuu3h6el6zn5OTE23bti2y+EXEOroFJiJ267777gMgNDQ0a1tCQgILFy5k5MiROb7mjz/+YOfOnQwbNox//OMfWfuLiGNRAiQidsvHx4dBgwYxe/bsrG2hoaE4OTkREhKS42tmzZoFwMiRIxk6dChlypTJ2paT9PT0ax6ZmZmFeyIiUuyUAImIXRs5ciQbN25k165dgHl7a/DgwTnO/7l48SJhYWG0bduWxo0b4+3tzeDBg7PmDF0tKSkJV1fXax7dunUr8vMSkaKlOUAiYtfuuOMO6taty+zZsxkxYgSbNm1iypQpOe777bffkpiYmO322MiRI/nyyy/5/PPPef3117Pt7+npyerVq685zt/nG4mIfVICJCJ2zWaz8fDDD/PBBx+QnJxM/fr16dSpU477zpo1Cw8PD3r06MG5c+cAaN68ObVq1eKLL77glVdewdnZOWt/Jyen664QExH7pltgImL3RowYQXx8PB9//DEPP/xwjvvs37+ftWvXkpycTI0aNShfvnzW48iRIxw/fpwVK1YUc+QiYhWNAImI3atevTpPP/00e/fuZfjw4Tnuc2Wi86effkq9evWy/ezSpUv069eP2bNn06tXryKPV0SspwRIREqFt95667o/S09P56uvvqJRo0Y88sgjOe7Tp08flixZwqlTp6hcuTIAmZmZbNiwIcf9W7Zsibu7e8EDFxFLKAESkVJv6dKlxMbGMn78+Ovu83//938sWrSIr7/+mnHjxgHmyFC7du1y3P/AgQPXjCSJiP2wGYZhWB2EiIiISHHSJGgRERFxOEqARERExOEoARIRERGHowRIREREHI4SIBEREXE4SoBERETE4agOUA4yMzM5ceIE3t7e2Gw2q8MRERGRXDAMg/Pnz1OtWjWcnG48xqMEKAcnTpwgMDDQ6jBEREQkH6KjowkICLjhPkqAcuDt7Q2Yv0AfHx+LoxEREZHcSExMJDAwMOtz/EaUAOXgym0vHx8fJUAiIiJ2JjfTVzQJWkRERByOEiARERFxOEqARERExOFoDpCIiEgxy8jIIC0tzeow7JKbm9tNl7jnhhIgERGRYmIYBrGxsZw7d87qUOyWk5MTtWvXxs3NrUDHUQIkIiJSTK4kP1WqVKFMmTIqtptHVwoVx8TEUKNGjQL9/pQAiYiIFIOMjIys5KdixYpWh2O3KleuzIkTJ0hPT8fV1TXfx9EkaBERkWJwZc5PmTJlLI7Evl259ZWRkVGg4ygBEhERKUa67VUwhfX7UwIkIiIiDkcJkIiIiBSbWrVqMXXqVKvD0CRoERERubE777yTFi1aFErismnTJry8vAoeVAFpBKi4XYiD2J1WRyEiIlJoDMMgPT09V/tWrly5REwEVwJUnHYvgSkN4ccxVkciIiKSKyNGjOD333/n/fffx2azYbPZ+OKLL7DZbKxYsYLWrVvj7u7OmjVrOHjwIP369cPPz4+yZcty6623snLlymzHu/oWmM1m47PPPmPAgAGUKVOGW265hSVLlhT5eSkBKk6BbcyvxzbBqf3WxiIiIpYyDIOLqemWPAzDyHWc77//Pu3ateMf//gHMTExxMTEEBgYCMAzzzzDpEmT2LNnD82bN+fChQv06tWLlStXEhkZSffu3enTpw9RUVE3fI9XXnmFIUOGsH37dnr16sUDDzzAmTNnCvT7vRnNASpO3n5wS1fYvxy2zYUuE62OSERELHIpLYPGL62w5L13v9qdMm65SwF8fX1xc3OjTJkyVK1aFYC9e/cC8Oqrr9K1a9esfStWrEhQUFDW96+//jqLFy9myZIlPP7449d9jxEjRnDfffcB8Oabb/Lhhx+yceNGevTokedzyy2NABW3FvebX7fNg8yCFXESERGxUuvWrbN9n5SUxDPPPEPjxo0pV64cZcuWZe/evTcdAWrevHnWcy8vL7y9vYmLiyuSmK/QCFBxq98DPMvD+Rg4+Bvc0sXqiERExAKers7sfrW7Ze9dGK5ezfX000+zYsUKJk+eTL169fD09GTQoEGkpqbe8DhXt7Sw2WxkZmYWSozXowSouLm4Q7PBsHEmbJ2jBEhExEHZbLZc34aympubW65aT6xZs4YRI0YwYMAAAC5cuMCRI0eKOLr80S0wK7R4wPy6dylcOmttLCIiIjdRq1Yt/vjjD44cOUJ8fPx1R2fq1avHokWL2Lp1K9u2beP+++8v8pGc/FICZAX/IKjSBDJSYOciq6MRERG5oaeeegpnZ2caN25M5cqVrzun57333qN8+fK0b9+ePn360L17d1q1alXM0eaOzcjLWrgiMH36dP773/8SExNDkyZNmDp1Kp06dcpx37Vr1/Lss8+yd+9eLl68SM2aNXn00UcZO3Zs1j6ffvopX331FTt3msUGg4ODefPNN7nttttyHVNiYiK+vr4kJCTg4+NTsBO8nnXT4OfnoXow/OPXonkPEREpMZKTkzl8+DC1a9fGw8PD6nDs1o1+j3n5/LZ0BCgsLIwxY8bw/PPPExkZSadOnejZs+d1M0svLy8ef/xxVq9ezZ49e3jhhRd44YUXmDlzZtY+q1at4r777uO3335j/fr11KhRg27dunH8+PHiOq3caT4EbM5wPALi9lodjYiIiEOxdASoTZs2tGrVihkzZmRta9SoEf3792fSpEm5OsbAgQPx8vLi66+/zvHnGRkZlC9fnmnTpvHQQw/l6pjFMgIEEHof7FsGHZ6Erq8W3fuIiIjlNAJUOOx+BCg1NZWIiAi6deuWbXu3bt1Yt25dro4RGRnJunXruOOOO667z8WLF0lLS6NChQrX3SclJYXExMRsj2KRVRMoDDJy10NFRERECs6yBCg+Pp6MjAz8/Pyybffz8yM2NvaGrw0ICMDd3Z3WrVszevRoHnnkkevuO378eKpXr06XLtdfbj5p0iR8fX2zHldKfBe5W7qDZwW4EAuHfiue9xQRERHrV4HZbLZs3xuGcc22q61Zs4bNmzfz8ccfM3XqVEJDQ3Pc75133iE0NJRFixbdcLhxwoQJJCQkZD2io6PzfiL54eJmzgUCiPymeN5TRERErCuEWKlSJZydna8Z7YmLi7tmVOhqtWvXBqBZs2acPHmSiRMnZvUQuWLy5Mm8+eabrFy5MluJ7Zy4u7vj7u6ej7MoBC3uhz8+NucCXTwDZa5/q05EREQKh2UjQG5ubgQHBxMeHp5te3h4OO3bt8/1cQzDICUlJdu2//73v7z22mssX778mj4lJY5/EPg1g4xU2LnQ6mhEREQcgqU1uMeNG8ewYcNo3bo17dq1Y+bMmURFRfHYY48B5q2p48eP89VXXwHw0UcfUaNGDRo2bAiYdYEmT57ME088kXXMd955hxdffJG5c+dSq1atrBGmsmXLUrZs2WI+w1xqcT+smABb58Jt/7A6GhERkVLP0gQoJCSE06dP8+qrrxITE0PTpk1ZtmwZNWvWBCAmJiZbTaDMzEwmTJjA4cOHcXFxoW7durz11ls8+uijWftMnz6d1NRUBg0alO29Xn75ZSZOnFgs55VnzQZD+ItwYgvE7YEqjayOSEREpFSzvBJ0SVRsdYD+LvR+2LcU2j8B3V4vnvcUEZFi48h1gGrVqsWYMWMYM2ZMgY9l93WA5CqqCSQiIlJslACVFPW7Q5lKkBQHB3+xOhoREZFSTQlQSeHs+ldNoK1zrI1FRETksk8++YTq1auTmZmZbXvfvn0ZPnw4Bw8epF+/fvj5+VG2bFluvfVWVq5caVG0uacEqCS5chts309mTSARESm9DANSk6x55GH67+DBg4mPj+e33/7qWHD27FlWrFjBAw88wIULF+jVqxcrV64kMjKS7t2706dPn+s2Ni8pLF0FJlep2sx8xO6AHQugzf9ZHZGIiBSVtIvwZjVr3vu5E+DmlatdK1SoQI8ePZg7dy533303APPnz6dChQrcfffdODs7ExQUlLX/66+/zuLFi1myZAmPP/54kYRfGDQCVNK0eMD8qttgIiJSQjzwwAMsXLgwq/DwnDlzGDp0KM7OziQlJfHMM8/QuHFjypUrR9myZdm7d69GgCSPmg2Bn1+EmK1wchf4NbE6IhERKQquZcyRGKveOw/69OlDZmYmS5cu5dZbb2XNmjW8++67ADz99NOsWLGCyZMnU69ePTw9PRk0aBCpqalFEXmhUQJU0nhVNFeE7f3RrAzd/Q2rIxIRkaJgs+X6NpTVPD09GThwIHPmzOHPP/+kfv36BAcHA2aD8hEjRjBgwAAALly4wJEjRyyMNnd0C6wkunIbbHsYZKRZG4uIiAjmbbClS5cye/ZsHnzwwazt9erVY9GiRWzdupVt27Zx//33X7NirCRSAlQS3dL1ck2gU/BnyV9KKCIipd9dd91FhQoV2LdvH/fff3/W9vfee4/y5cvTvn17+vTpQ/fu3WnVqpWFkeaOboGVRM6u0DwENnxkToZu0NPqiERExME5Oztz4sS1c5Zq1arFr7/+mm3b6NGjs31fEm+JaQSopMqqCbQckk5bG4uIiEgpowSopKraFPyDIDMNdi6wOhoREZFSRQlQSXZlMnTkN9bGISIiUsooASrJmg4CJ1eI3W5WhxYREZFCoQSoJPOqCA16mM+3hlobi4iIFAojD3245FqF9ftTAlTStbhca0E1gURE7JqrqysAFy9etDgS+3alwrSzs3OBjqNl8CVdvbvBqwokxcGBcGjYy+qIREQkH5ydnSlXrhxxcXEAlClTBpvNZnFU9iUzM5NTp05RpkwZXFwKlsIoASrpnF2h+RBYP82sCaQESETEblWtWhUgKwmSvHNycqJGjRoFTh6VANmDFg+YCdD+5ZAUD16VrI5IRETywWaz4e/vT5UqVUhL07SG/HBzc8PJqeAzeJQA2QO/xlCtJZyIhB3zoe0/rY5IREQKwNnZucBzWKRgNAnaXlypCbR1jrVxiIiIlAJKgOxF03vB2c2sBxSz3epoRERE7JoSIHtRpsJfTVG3zrU2FhERETunBMieXLkNtuNbSE+1NhYRERE7pgTIntS9G8r6wcXTcOBnq6MRERGxW0qA7ImzCzQPMZ/rNpiIiEi+KQGyNy3uN78eWAEXTlkbi4iIiJ1SAmRvqjSCaq0gM92cCyQiIiJ5pgTIHl0ZBYqcA+oqLCIikmdKgOxRs0FmTaC4XRCrmkAiIiJ5pQTIHnmWh4a9zeeaDC0iIpJnSoDs1ZWaQNtVE0hERCSvlADZqzqdoWxVuHTG7BIvIiIiuaYEyF45u0CQagKJiIjkhxIge3blNtiBn+FCnLWxiIiI2BElQPascgOo3hqMDHMukIiIiOSKEiB7d6Um0FbVBBIREcktJUD2rulAcHaHuN0Qs9XqaEREROyCEiB7p5pAIiIieaYEqBhlZBos3xnDycTkwj1wy8uToXfMh/SUwj22iIhIKWR5AjR9+nRq166Nh4cHwcHBrFmz5rr7rl27lg4dOlCxYkU8PT1p2LAh77333jX7LVy4kMaNG+Pu7k7jxo1ZvHhxUZ5Crh2IO89j32yhzZu/0OGtX3l87hZmrz1MZNRZUtMz83/gOp3B2x8unVVNIBERkVxwsfLNw8LCGDNmDNOnT6dDhw588skn9OzZk927d1OjRo1r9vfy8uLxxx+nefPmeHl5sXbtWh599FG8vLz4v//7PwDWr19PSEgIr732GgMGDGDx4sUMGTKEtWvX0qZNm+I+xWwSL6XTsKo3+0+e5/i5Sxw/d4kft8cA4ObiRLPqvrQMLEermuVpVaM8VX09cndgJ2cIGgpr3zMbpDbuV4RnISIiYv9shmHd0qE2bdrQqlUrZsyYkbWtUaNG9O/fn0mTJuXqGAMHDsTLy4uvv/4agJCQEBITE/npp5+y9unRowfly5cnNDQ0V8dMTEzE19eXhIQEfHx88nBGuXMhJZ1t0eeIjDrLlijz69mLadfsV83Xg5Y1ytOyhpkUNanmg7uLc84HPbUfProVbM4wbjd4Vy30uEVEREqyvHx+WzYClJqaSkREBOPHj8+2vVu3bqxbty5Xx4iMjGTdunW8/vrrWdvWr1/P2LFjs+3XvXt3pk6dWuCYC0tZdxc61KtEh3qVADAMgyOnL7Ll6Fm2RJ0lMuoce2MTOZGQzIkdMSzdcXmUyNmJJtV9aFXDHCFqWaMc1cp5mgetXB8CboVjm8yaQB3+bdXpiYiIlHiWJUDx8fFkZGTg5+eXbbufnx+xsbE3fG1AQACnTp0iPT2diRMn8sgjj2T9LDY2Ns/HTElJISXlr8nDiYmJeTmVArPZbNSu5EXtSl7cGxwAQFJKOtuOnSMy6q+RojNJqZe/P8csDgNQ1ceDVjXL0apGebrW6E/NY5vM1WDtnwCbrVjPQ0RExF5YOgcIzA//vzMM45ptV1uzZg0XLlxgw4YNjB8/nnr16nHffffl+5iTJk3ilVdeyUf0RcfL3YX2dSvRvu5fo0RHT18kMvosW46eY0vUWfbGnic2MZllO2JZtiOWD6jCRndXPE7tYWbYQvwbtadVzfJU8/W46e9URETEkViWAFWqVAlnZ+drRmbi4uKuGcG5Wu3atQFo1qwZJ0+eZOLEiVkJUNWqVfN8zAkTJjBu3Lis7xMTEwkMDMzT+RQ1m81GrUpe1KrkxYCW5ijRxdR0th9LYEuUmRRFRp1lReqt9HNeh8fOeTyx1bw95ufjTsvA8lkjRU2r++Lhep25RCIiIg7AsgTIzc2N4OBgwsPDGTBgQNb28PBw+vXL/SomwzCy3b5q164d4eHh2eYB/fzzz7Rv3/66x3B3d8fd3T2PZ2C9Mm4utK1TkbZ1KgLm7+LU1jT4fh2D3DfwXZV/sS02mZOJKSzfFcvyXWZi6Opso7G/Dy1rlKdVzfK0DCxHQHlPjRKJiIjDsPQW2Lhx4xg2bBitW7emXbt2zJw5k6ioKB577DHAHJk5fvw4X331FQAfffQRNWrUoGHDhoBZF2jy5Mk88cQTWcd88sknuf3223n77bfp168f33//PStXrmTt2rXFf4LFzGazUSWoO/xWnTKJx1l0dwKXbunL9mPniIw+d3mS9TniL6Sw7VgC244l8MW6IwBU9nanVY1yZlJUozzNAzRKJCIipZelCVBISAinT5/m1VdfJSYmhqZNm7Js2TJq1qwJQExMDFFRUVn7Z2ZmMmHCBA4fPoyLiwt169blrbfe4tFHH83ap3379sybN48XXniBF198kbp16xIWFmZ5DaBic6Um0JopsHUunk0G0KZORdr8bZTo2NlLWavNtkSdZfeJRE6dT2HFrpOs2HUSABcnG42r+WSrS6RRIhERKS0srQNUUhV1HaAiF/8nTAsGmxOM23PTmkDJaRnsOJ7AlqN/JUVx569tqVGprLtZk6hGeVrVKEfzgHJ4ummUSERESoa8fH4rAcqB3SdAALO6QfQf0OUV6DgmTy81DIPj5y5lFWncEnWO3ScSSMvI/p+Ks5ONRv7eWTWJWtUoT40KZTRKJCIillACVEClIgGK+AJ+eBIqNYDRfxS4JlByWgY7jydkjRBtiTrLycRrR4kqernR8m9ziYICfSnjZnm1BRERcQBKgAqoVCRAyQkwuQGkX4JHfoWA4EI9vGEYxCQk/7UEP/osu44nkpqRvamrs5ONBn7eWUvwW9UoT82KGiUSEZHCpwSogEpFAgSw8B+w41toPQruebfI3y45LYNdJxKJ/NsE65iE5Gv2q+DlljW5umVgOYICy+HlrlEiEREpGCVABVRqEqCDv8HX/cHDF/6zH1xz2V2+EMUkXDKToct9znbmMErkZIMGVX3+tgy/HLUreWmUSERE8kQJUAGVmgQoMwOmNofEYzBoNjS91+qISEnPYPeJRLZcHiGKPHqWEzmMEpUr42qOEl0u1hgUWI6yGiUSEZEbUAJUQKUmAQL45TVYMxnqdYEHF1odTY5iE5IvrzYzb51tP55Aanr2USKbDRr4eWeNELWsUZ46lbxwctIokYiImJQAFVCpSoBOH4QPW5k1gcbuAp9qVkd0U6npmeyOScxagr/l6FmOn7t0zX6+nq5Zy+9b1ihHi8ByeHu4WhCxiIiUBEqACqhUJUAAs3tA1HroMhE6jr3p7iVRXGLy3+oSnWX7sQRSchglql/F+69ijTXLUadSWY0SiYg4CCVABVTqEqAtX8GSJ6BSfRi9scA1gUqCtIxM9sQkmtWro835RNFnrh0l8vFwocXl22ZmXaJy+HpqlEhEpDRSAlRApS4BSk6EyfXNmkCjVkLgrVZHVCTizicTGXUuawn+9mPnSE67dpSoXuWyf1WvrlmeepU1SiQiUhooASqgUpcAASz6P9geBsEPQ5+pVkdTLNIyMtkbc57I6LOXl+GfI+rMxWv28/ZwoUXgX0vwWwaWx7eMRolEROyNEqACKpUJ0KHf4au+4O4LT+0DV0+rI7JE/IWUrBGiyKizbItO4FJaxjX71a3slbUEv1WN8tSrUhZnjRKJiJRoSoAKqFQmQJmZ8H5zSIiGe2dBs0FWR1QipGdksjf2fLbq1UdO5zBK5O5CUGA5cy5RzfJ0qFcJV2cnCyIWEZHrUQJUQKUyAQL49Q1Y/Q7UvRuGLbI6mhLr9IUUtl6eWL3l6Dm2HTvHxdTso0TNA3x5L6QFdSuXtShKERG5mhKgAiq1CdCZQ/BBS8Bm1gTyrW51RHYhPSOT/ScvmAlR1FlW7j5JYnI6Hq5OPN+7MQ+2qaG2HSIiJUBePr81hu9IKtSBGu0BA7bPszoau+Hi7ETjaj482LYm7w5pwc9j76BjvUokp2Xy4nc7GfnFJuLOX9vOQ0RESi4lQI6m5QPm161zQYN/+VLV14OvRt7GS/c0xs3Fid/2naLH1DX8vCvW6tBERCSXlAA5msb9wLUMnP4Tjm2yOhq75eRkY2TH2vzweEca+ftwJimV//s6gmcXbCcpJd3q8ERE5CaUADkad28zCQKI/MbaWEqBBlW9+W50ex69ow42G4RtjqbXB2uIOHrW6tBEROQGlAA5ohb3m193LYbUa5d8S964uzgzoWcjQv/RlurlPDl6+iKDP17Hu+H7ScvIvPkBRESk2CkBckQ1O0K5GpCSCHuXWh1NqdG2TkWWPdmJ/i2qkWnAB78cYNCMdRw6dcHq0ERE5CpKgByRkxMEXR4F2jrH2lhKGV9PV6YObckH97XEx8OFbccS6P3BWub+EYUqToiIlBxKgBxV0FDz66FVkHDM0lBKo75B1Vg+5nba163IpbQMnlu8g0e+3Myp8ylWhyYiIigBclwVapu3wjBgW6jV0ZRK1cp58s2oNrzQuxFuzk78sjeOHlNXs3L3SatDExFxeEqAHNmVydCqCVRknJxsPNKpDkue6EDDqt6cTkrlka82M2HRDi6marm8iIhVlAA5ssb9wNXLbJER/YfV0ZRqDav68N3oDvyjU20AQjdG0fuDtWyNPmdtYCIiDkoJkCNzLwtN+pvPNRm6yHm4OvN878bMfaQN/r4eHI5P4t4Z63h/5QHStVxeRKRYKQFydFdug+1UTaDi0r5eJZY/eTt9gqqRkWnw3sr9DP5kPUfik6wOTUTEYSgBcnQ12kO5mpB6Hvb8YHU0DsO3jCsf3teS94e2wNvDhcioc/T6YA3zNmq5vIhIcVAC5OicnP42GVq3wYpbvxbVWT7mdtrWqcDF1AzGL9rBP76K4PQFLZcXESlKSoAEgu4zvx5eDeeirI3FAVUv58ncR9ryXK+GuDrbWLnnJN2nruG3vXFWhyYiUmopARIoXxNqdcKsCRRmdTQOycnJxv/dXpfvR3ekvl9Z4i+k8PAXm3jhux1cSs2wOjwRkVJHCZCYWjxgft06RzWBLNS4mg9LHu/IyA7mcvlvNkTR+4M1bD92ztrARERKGSVAYmrcF9zKwtnDELXe6mgcmoerMy/1acw3o9rg5+POofgkBk5fx4e/aLm8iEhhUQIkJjcvaNzffK7J0CVCx1sqsWLM7fRu5k96psGU8P0M+WQ9R09rubyISEEpAZK/tLx8G2zXd5CqD9mSoFwZN6bd35J3hwRR1t2FLVHn6PX+Gr7dFK3l8iIiBaAESP5Sox2UrwWpF1QTqASx2WwMbBXAT0924rZaFUhKzeCZhdt57JsIziSlWh2eiIhdUgIkf7HZsk+GlhIlsEIZQv+vLc/2MJfLr9h1ku5TV7Nqn5bLi4jklRIgyS5oqPn18Go4e9TaWOQazk42/nlnXRb/qwP1qpTl1PkURny+iZe/36nl8iIieaAESLIrVwNq324+3zbP2ljkuppW9+XHJzoyon0tAL5cf5R7PlzDzuMJ1gYmImInlADJtVo8aH7dOgcytey6pPJwdWZi3yZ8OfI2qni7c/BUEv0/+h8f/fYnGZmaIC0iciOWJ0DTp0+ndu3aeHh4EBwczJo1a66776JFi+jatSuVK1fGx8eHdu3asWLFimv2mzp1Kg0aNMDT05PAwEDGjh1LcnJyUZ5G6dLoHnDzhnNHVRPIDtxRvzIrxtxOjyZVSc80+O+KfQyduZ7oMxetDk1EpMSyNAEKCwtjzJgxPP/880RGRtKpUyd69uxJVFTO/ahWr15N165dWbZsGREREXTu3Jk+ffoQGRmZtc+cOXMYP348L7/8Mnv27GHWrFmEhYUxYcKE4jot++fmBU36m8+3zrU0FMmd8l5uzHiwFf8d1Jyy7i5sOnKWnu+vYUHEMS2XFxHJgc2w8F/HNm3a0KpVK2bMmJG1rVGjRvTv359Jkybl6hhNmjQhJCSEl156CYDHH3+cPXv28Msvv2Tt85///IeNGzfecHTp7xITE/H19SUhIQEfH588nFEpcnQ9fN4DXL3gqf3gXtbqiCSXos9cZGzYVjYfPQtAr2ZVeaN/M8p7uVkcmYhI0crL57dlI0CpqalERETQrVu3bNu7devGunXrcnWMzMxMzp8/T4UKFbK2dezYkYiICDZu3AjAoUOHWLZsGb17977ucVJSUkhMTMz2cHg12kKFOpCWBHuWWB2N5EFghTKEPdqOp7s3wMXJxrIdsXSfuprV+09ZHZqISIlhWQIUHx9PRkYGfn5+2bb7+fkRGxubq2NMmTKFpKQkhgwZkrVt6NChvPbaa3Ts2BFXV1fq1q1L586dGT9+/HWPM2nSJHx9fbMegYGB+Tup0sRmgxb3m891G8zuODvZGN25Hov/1YE6lb2IO5/CQ7M3MnHJLpLTtFxeRMTySdA2my3b94ZhXLMtJ6GhoUycOJGwsDCqVKmStX3VqlW88cYbTJ8+nS1btrBo0SJ+/PFHXnvttesea8KECSQkJGQ9oqOj839CpUnzoYANjqyBs0esjkbyoVmAL0uf6MRD7WoC8MW6I/T5cK2Wy4uIw7MsAapUqRLOzs7XjPbExcVdMyp0tbCwMEaNGsW3335Lly5dsv3sxRdfZNiwYTzyyCM0a9aMAQMG8OabbzJp0iQyr7Ok293dHR8fn2wPAcoFQp07zOdbQ62NRfLN082ZV/s15fMRt1KprDsH4i4wYPr/mLHqoJbLi4jDsiwBcnNzIzg4mPDw8Gzbw8PDad++/XVfFxoayogRI5g7d26O83ouXryIk1P203J2dsYwDK2GyY8rrTG2zVVNIDvXuWEVVozpRLfGfqRlGLy9fC/3fbqBY2e1XF5EHI+lt8DGjRvHZ599xuzZs9mzZw9jx44lKiqKxx57DDBvTT300ENZ+4eGhvLQQw8xZcoU2rZtS2xsLLGxsSQk/DWc36dPH2bMmMG8efM4fPgw4eHhvPjii/Tt2xdnZ+diP0e71/AecPeBc1Fw9H9WRyMFVLGsO58MC+ade5vj5ebMxsNn6Dl1DYsjtVxeSr60jEzCd59k9Jwt/OfbbcQlqr6b5J+ly+DBLIT4zjvvEBMTQ9OmTXnvvfe4/XazFcOIESM4cuQIq1atAuDOO+/k999/v+YYw4cP54svvgAgPT2dN954g6+//prjx49TuXJl+vTpwxtvvEG5cuVyFZOWwV9lyb9hy5cQdD8MmHHz/cUuHD2dxNiwrWyJOgfAPc39eaN/M3zLuFobmMhV9sWeZ/7maL7bepz4C6lZ2308XHjxnsYMCg7I1dxRKf3y8vlteQJUEikBukrUHzC7m2oClULpGZlMX3WQ9385QEamQVUfD6YMCaJDvUpWhyYO7tzFVJZsO8GCiGNsP/bXKH+lsm70DarOxiOn2XncLFlye/3KvDmgKQHly1gVrpQQSoAKSAnQVQwDPgyGMweh30fQ8kGrI5JCtjX6HGPDtnI4PgmAUR1r83T3Bni46raxFJ+MTIPVB06xIOIY4btOkpphzjt0cbJxd6MqDAoO5M4GlXF1diI9I5NP1xzmvZX7SU3PxMvNmWd7NuTBNjVxctJokKNSAlRASoBysHoy/Poa1OwADy+zOhopAhdT03lj6R7m/GG2omng5817IS1oXE3/D0jROnjqAgsijrFoyzFOJqZkbW9Y1ZvBrQPp36IaFcu6X/e1zy7YnlX5/LZaFXjr3mbUqayRakekBKiAlADlIOE4vNcEMODfkWaVaCmVftlzkmcXbif+Qipuzk481b0+j3Sso7+qpVCdT07jx+0xzN8cnTUPDaBcGVf6t6jOoOAAmlb3zdWxMjMNvt5wlLeX7+ViagbuLk6M7VqfRzrWxsXZ8nJ3UoyUABWQEqDr+HoAHPwV7ngWOj9ndTRShOIvpDB+4Q5W7jkJQLs6FZkyJIhq5TwtjkzsWWamwfpDp5m/OZrlu2JJTjNvcTnZ4M4GVRgcHMBdjarg7pK/W6/RZy7y3OIdrDkQD0DzAF/evrc5jfz177ijUAJUQEqArmPHAlg4CnxrwJPbwEl/WZVmhmEwb1M0r/6wm0tpGXh7uPB6/6b0a1Hd6tDEzkSdvsiCiGgWbjnO8XOXsrbXq1KWwcEBDGhZnSo+HoXyXoZhMD/iGK//uJvE5HRcnGz8q3M9Hu9cDzcX/ZtV2ikBKiAlQNeRdgkm14eURHhoyV9VoqVUOxxvLpffGn0OgL5B1XitX1Mtl5cbSkpJZ9mOGBZEHOOPw2eytnt7uNA3qBqDggNoEViuyJavxyUm88J3O/l5tzmKWd+vLO8MCqJFYLkieT8pGZQAFZASoBv44UmI+MLsEzbwE6ujkWKSnpHJtN/+5MNf/yQj08Df11wu376ulsvLXwzDYOPhMyyIOMbSHTFcTDUb79ps0LFeJQYFB9C9SdViW11oGAZLd8Tw8ve7OJ2UipPNXOE4rmsDPN20wrE0UgJUQEqAbiB6E8zqAi6eZk0gD/1+HElk1FnGhm3lyOmL2GzwSMfaPNW9Qb7nbEjpcPzcJRZFHGPBlmMcPf1Xa5VaFcswKDiAga0CLJ0/diYplVd/2MV3W09kxfXWvc1pW6eiZTFJ0VACVEBKgG7AMGDarXD6APSdBq2GWR2RFLOklHReX7qb0I3RgLlUeerQFjSsqv9XHElyWgYrdsUyf/Mx/ncwniufJF5uzvRu7s/g1oG0rlm+RFVo/nXvSZ5btJPYyy00HmhTg/E9G+Ltodu5pYUSoAJSAnQTa96FX16BGu1h5E9WRyMWCd99kvELt3M6KRU3Fyee6d6AkR1qa7l8KWYYBpHR55i/+Rg/bjvB+ZT0rJ+1rVOBwcGB9GxWlTJuLhZGeWOJyWlMWraX0I1mvatqvh68MbAZnRtUsTgyKQxKgApICdBNJJ4wawIZmfDEFqhY1+qIxCKnzqfw7MLt/Lo3DoAO9SoyeXAQ/r5aLl+anExMZtGW4yyIiObgqaSs7dXLeTIoOIB7WwVQo6J9taFYdzCe8Qt3EHXGvGU3sGV1XrynMeW93CyOTApCCVABKQHKha8HwsFf4Pan4a4XrI5GLGQYBnP+iOL1pbtJTsvEx8OFNwY0o09QNatDkwJISc/glz1xzN8cze/7T5F5+ZPCw9WJnk39GRwcQNs6Fe16xO9iajpTft7P7P8dxjDMPmOv9mtKr2b+Vocm+aQEqICUAOXCzoWwYCT4BMCYHaoJJBw8dYGxYVuzGlcOaFmdV/o1wUfzK+yGYRjsOpHI/M3RfL/tBOcupmX9LLhmeQYHB9C7uX+pmzOzJeoszyzYzp9xFwDo0aQqr/ZvQhXvwqlNJMVHCVABKQHKhbTkyzWBEuCh76HOnVZHJCVAWkYmH/5ygGm//UmmYd4imTIkSKttSrj4Cyl8F3mcBRHH2Bt7Pmt7VR8PBrYy21KU9t5aKekZTPv1T2asOkh6poGvpysv3tOYe1tVL1ETueXGlAAVkBKgXPpxLGyeDc1DYOBMq6OREiTi6BnGhm0j6oy5XP7/bq/DuK71tVy+BEnLyOS3vXHMjzjGb3vjSL98j8vNxYlujf0Y3DqQjvUq4WzHt7jyY9eJBJ5duJ2dxxMBuKN+Zd4c2IzqagNjF5QAFZASoFw6thk+u/tyTaB94JG7xoXiGC6kpPPaD7sJ22wul2/s78PUoS2o7+dtcWSObW9sIvM3H+O7yOOcTkrN2h4U4Mug1oH0bV7N4at8p2dkMnPNIaauPEBqeiZebs6M79mQB9rUtOs5T45ACVABKQHKJcOAj26D+P3Q5wMIHm51RFICrdgVy/iF2zl7MQ03FyfG92jIiPa19EFSjM5dTOX7rSdYEHGMHccTsrZXKuuedYtLiem1/oy7wPiF29l89CwAt9WuwNv3Nqd2JS+LI5PrUQJUQEqA8mDtVFj5MgS2hVErrI5GSqi4xGSeXrCd3/efAqDTLZX476AgqvpqkmlRSc/IZM2f8SzYfIzw3SdJzTA7r7s42bi7URUGBwdyR4PKuDprAcONZGYafLX+CO+s2MfF1AzcXZwY17U+ozrWxkW/uxJHCVABKQHKg8QYeK+xagLJTRmGwTcbjvL60j2kpGfi6+nKpIHNtOS4kP0Zd4EFEcdYHHmMk4kpWdsb+fswODiAfi2qUbGsu4UR2qfoMxeZsGgHa/+MB6B5gC/vDGquCugljBKgAlIClEffDII/w6HTU3D3i1ZHIyXcn3EXGBMWmTXJdGCr6rzSt0mpW1pdnBKT0/hxWwzzI6KJjDqXtb18GVf6tajO4NYBNKmmOXoFZRgG8zcf47WluzmfnI6rs41/3VmP0Z3r4eai0aCSQAlQASkByqOdi2DBw+BT/XJNIK30kRtLTc/k/V/2M2PVQTINCCjvybtDWnBb7QpWh2Y3MjMN1h08zfyIaJbvjCUl3bzF5exk4876lRncOoC7Gvrpg7kInExM5oXvdhK++yQADfy8eWdQc4ICy1kbmCgBKiglQHmUlgxT6kNyAgxbDHXvsjoisRObjpxhbNhWjp29hM0G/7yjLmO61NeH9g0cPZ3EwohjLNxynOPnLmVtv6VKWQa3DqB/y+oq4FcMDMPgx+0xTFyyi9NJqTjZ4JFOZrkHD1f9EWgVJUAFpAQoH5b+BzZ9Bs0Gw72fWR2N2JHzyWm88sNuFkQcA6BpdR+mhrSgXhWtSroiKSWdZTtimB9xjI2Hz2Rt9/FwoW+LagwKDiQowFcF+yxwJimVV37YxfdbTwBQq2IZ3r63OW1U/NMSSoAKSAlQPhyPgE/vAhcPeGq/agJJnv20I4YJi3dw7mIa7i5OPNerEQ+1q+mwH+qGYbDx8BnmRxxj2Y4YLqZmAGCzQadbKjMoOIBujf002lBCrNx9kue/25E18fzBtjUY37MRZd1dLI7MsSgBKiAlQPlgGDC9LZzaC/dMhdYPWx2R2KGTick8NX8baw6YK23uqF+Z/w5qThUfx7mlc/zcJRZGHGNBxLGsTuUAtSt5MSg4gIGtquPvq6rEJVHCpTTe+mkPoRvN4p/VfD14c2Az7mxQxeLIHIcSoAJSApRP/3sfwl+CgNvgkXCroxE7daXuyqSf9pKSnkn5MuZy+R5NS+9y+UupGazYFcv8iGjWHTzNlX+Vvdycuad5NQa3DiC4ZnmHHQ2zN+v+jOfZRduJPmPO0RrYqjov3dOYcmXcLI6s9FMCVEBKgPLpfCy82xiMDHh8M1S6xeqIxI4dOHmeJ+dtZXeMuVx+cHAAL/dtUmpuKRiGwZaocyyIOMaP205wPiU962ft6lRkcOsAejStShm30nG+juZiajqTV+zn83WHMQyz6vZr/ZrQU3WvipQSoAJSAlQAc4bAgRXQcRx0ednqaMTOpaZn8m74fj5ZfRDDgBoVyvBeSBDBNe13ufzJxGQWbTnOgohoDp5KytoeUN6TQcEB3NsqgMAKZSyMUApTxNGzPLtwO3/GXQCgZ9OqvNKviVbqFRElQAWkBKgAdn0H84eDdzUYu1M1gaRQ/HHoNOO+3cbxc5dwssG/7qzHk11usZs2DinpGazcHcf8iGhW7z/F5cbreLo607NZVQYFB9C2dkX1RyulktMymPbrn8z4/SAZmQa+nq68dE9jBraqrtuahUwJUAEpASqA9BSYXB+Sz8GDC6FeF6sjklIiMTmNid/vYlHkccBsRfBeSAvqVi5rcWQ5MwyDnccTmR8RzfdbT5BwKS3rZ7fWKs+g4AB6NfNXBWwHsvN4As8s2J51W/fOBpV5Y0AzqpfTpPbCogSogJQAFdDSp2DTp9D0Xhg02+popJT5cfsJnl+8k4RLaXi4OvF878Y82KZGiflLOv5CCt9FHmdBxDH2xp7P2l7Vx4N7g6szKDhQ3cQdWFpGJjNXH+L9lQdIzcjEy82Z8b0a8cBtNTQCWAiUABWQEqACOhEJM+8EZ3ezJpBnOasjklImNsFcLn+lMWXnBpV5e1Bzy+ZVpGVk8uveOBZEHOO3vXGkX77H5ebiRPcmVRkcHECHepVw1gecXPZn3AWeXbidiKNnAWhTuwJv3dtcyXEBKQEqICVABWQYMKM9xO2Ge96D1iOtjkhKocxMg8/XHeHt5XtJTc+kgpcbbw1sRrcmVYsthj0xiSyIOMZ3kcc5nZSatT0osByDgwPo07wavmV0i0tylnG55MM7y/dxKS0Ddxcn/tOtPqM61lGynE/FkgB9/fXXfPzxxxw+fJj169dTs2ZNpk6dSu3atenXr1++Ai8plAAVgnUfws8vQMCt8MhKq6ORUmxf7HmenBeZdbtp6K2BvHhPY7yKaLn8uYupfL/1BPMjorM62gNU9nZnYMvq3BscQH0/tfGQ3Is+c5Hxi7bzvz9PAxAU4Ms7g4JoUFX/HeVVXj6/87WEYsaMGYwbN45evXpx7tw5MjLMEu3lypVj6tSp+TmklDbNhoDNGY5tglP7rI5GSrEGVb35/vEOPHp7HWw2mLcpml4frMm6tVAY0jMy+W1vHP+aE8Ftb/zCy0t2sfN4Iq7ONno2rcqs4a1ZP/4uJvRqpORH8iywQhm+GdWGt+9threHC9uOJXDPh2uYunI/qemZVodXauVrBKhx48a8+eab9O/fH29vb7Zt20adOnXYuXMnd955J/Hx8UURa7HRCFAhmRsC+5dDhzHQ9RWroxEHsP7gaf7z7VZOJCTjZIPH77qFJ+6ql+/l8n/GXWB+RDSLtxwn7nxK1vbG/j4Mbh1AvxbVqeCl6r5SeGITknnhux2s3BMHQMOq3rwzqDnNA8pZG5idKPJbYJ6enuzdu5eaNWtmS4AOHDhA8+bNuXTpUr6DLwmUABWS3Uvg22Hg7Q9jd6kmkBSLhEtpvPT9zqzu3EGXl8vXyeVy+cTkNH7YdoIFEceIjDqXtb2Clxv9WlRjUHAATaqp2a8UHcMw+GF7DBOX7OJMUipONvhHpzqM7VpfzW9vIi+f3/m6SV67dm22bt1KzZo1s23/6aefaNy4cX4OKaVR/R7gWQHOx8DB3+AW1QSSoufr6cr7Q1tyV8MqvPDdTrYdS6D3B2t58Z7G3HdbYI7L5TMyDdYdjGdBxDGW74wl5fJtB2cnG50bVGZQcCB3NayCm4t9FF4U+2az2egbVI0OdSvyyg+7WbLtBJ+sPsTPu0/y9r3Nua22/VZCL0nylQA9/fTTjB49muTkZAzDYOPGjYSGhjJp0iQ+++yzwo5R7JWLGzQbDBs/ga1zlABJserXojq31qrAf77dxvpDp3lu8Q5+2XOStwc1p1JZdwCOxCexcMsxFkYc40RCctZr6/uVZXBwIP1aVlPLArFMxbLufHBfS/oEVeOF73ZwOD6JIZ+sZ1jbmjzbs2Gp6YtnlXyvAvv00095/fXXiY6OBqB69epMnDiRUaNGFWqAVtAtsEJ0YivMvONyTaB94Fne6ojEwWRmGsxae5j/rthHakYmFb3cGNmxNr/vO8XGI2ey9vPxcKFfi+oMCg6geYBviSmsKALmrd1Jy/Ywb9Plz9xynrw5sBl31K9scWQlS7HWAYqPjyczM5MqVaoU5DAlihKgQmQYMKMDxO2C3lPg1kesjkgc1J6YRMaGbc1Wndlmg063VGZwcABdG/tpfoWUeGsPxDN+0XaOnTXn2t7bKoAX72lEuTKajA/FsAz+7ypVqlSg5Gf69OnUrl0bDw8PgoODWbNmzXX3XbRoEV27dqVy5cr4+PjQrl07VqxYcc1+586dY/To0fj7++Ph4UGjRo1YtmxZvmOUArDZoOUD5vOtc62NRRxaI38fvhvdgUfvqEPzAF+e7t6AdePv4quRt9EnqJqSH7ELHW+pxIoxt/Nwh1rYbLBwyzG6vrea5TtjrA7N7uR7BGjBggV8++23REVFkZqamu1nW7ZsydUxwsLCGDZsGNOnT6dDhw588sknfPbZZ+zevZsaNWpcs/+YMWOoVq0anTt3ply5cnz++edMnjyZP/74g5YtWwKQmppKhw4dqFKlCs899xwBAQFER0fj7e1NUFBQruLSCFAhu3AK3m0Imenwrz+gSkOrIxIRsXsRR8/w9ILtHDqVBECvZlV5pW9TKnu7WxyZdYr8FtgHH3zA888/z/Dhw/n00095+OGHOXjwIJs2bWL06NG88cYbuTpOmzZtaNWqFTNmzMja1qhRI/r378+kSZNydYwmTZoQEhLCSy+9BMDHH3/Mf//7X/bu3Yura/5K0CsBKgKh98G+ZdDhSej6qtXRiIiUCslpGXz46wE+/v0QGZkG5cq48tI9jRnQsrpDzmMr8ltg06dPZ+bMmUybNg03NzeeeeYZwsPD+fe//01CQkKujpGamkpERATdunXLtr1bt26sW7cuV8fIzMzk/PnzVKjw15LAJUuW0K5dO0aPHo2fnx9NmzblzTffzKpWLRZpcb/5dds8yEi3NhYRkVLCw9WZp7s35PvRHWjs78O5i2mM+3YbD3+xiRPn7LsmX1HLVwIUFRVF+/btAbMo4vnz5qTCYcOGERoamqtjxMfHk5GRgZ+fX7btfn5+xMbG5uoYU6ZMISkpiSFDhmRtO3ToEAsWLCAjI4Nly5bxwgsvMGXKlBuOSqWkpJCYmJjtIYXslu5QpiJcOAkHf7U6GhGRUqVpdV++f7wDT3Wrj5uzE6v2naLbe6uZ88dRMjPV8zwn+UqAqlatyunTZtO2mjVrsmHDBgAOHz5MXu+oXT1EZxhGrobtQkNDmThxImFhYdkmYV9ZkTZz5kyCg4MZOnQozz//fLbbbFebNGkSvr6+WY/AwMA8nYPkgoub2R8MzJpAIiJSqFydnXj8rltY+u+OtKxRjgsp6Ty/eCf3f7aBI/FJVodX4uQrAbrrrrv44YcfABg1ahRjx46la9euhISEMGDAgFwdo1KlSjg7O18z2hMXF3fNqNDVwsLCGDVqFN9++y1dumQvrufv70/9+vVxdv5rRUejRo2IjY29ZrL2FRMmTCAhISHrcaW2kRSyK7fB9i2Di2duvK+IiOTLLX7eLHisPS/e0xhPV2c2HDpDj/dX8+lqc56QmPKVAM2cOZPnn38egMcee4wvv/ySRo0a8corr/Dxxx/n6hhubm4EBwcTHh6ebXt4eHjW7bWchIaGMmLECObOnUvv3r2v+XmHDh34888/ycz8q4Pu/v378ff3x80t5zoJ7u7u+Pj4ZHtIEfBvDn7NICMVdi60OhoRkVLL2cnGqI61WTHmdtrXrUhyWiZvLNvDwBnr2H/y/M0P4ADylQA5OTmRnp7Oxo0b+fHHH3F3d6dLly7UqlWL5cuX5/o448aN47PPPmP27Nns2bOHsWPHEhUVxWOPPQaYIzMPPfRQ1v6hoaE89NBDTJkyhbZt2xIbG0tsbGy2idf//Oc/OX36NE8++ST79+9n6dKlvPnmm4wePTo/pyqF7cookG6DiYgUuRoVyzDnkTa8NbAZ3u4ubIs+R+8P1vD+ygOkpmfe/AClWL6WwS9fvpxhw4ZlzQPKdkCbLU8rrqZPn84777xDTEwMTZs25b333uP2228HYMSIERw5coRVq1YBcOedd/L7779fc4zhw4fzxRdfZH2/fv16xo4dy9atW6levTqjRo3i2WefzXZb7Ea0DL4IJcXDlAZmTaB/rgc/Nc8VESkOMQmXeGHxTn7ZGwdAw6revDOoOc0DylkbWCEq8jpA9erVo3v37rz00ks3na9jj5QAFbF5D8DeH6H9E9DtdaujERFxGIZhsGTbCSYu2cXZi2k42eAft9dhbJf6paIaepHXAYqLi2PcuHGlMvmRYpBVEyhMNYFERIqRzWajX4vqhI+7g3ua+5NpwCe/H6LX+2vYdMSxFqfkKwEaNGhQ1m0pkTy7pRuUqQRJcfDnSqujERFxOJXKujPt/lbMHBZMFW93DsUnMeST9bz8/U4upDjGH6b5ugV28eJFBg8eTOXKlWnWrNk1LSf+/e9/F1qAVtAtsGKwfAJsmA6N+kLI11ZHIyLisBIupfHG0t18u/kYANXLeTJpYDNur1/Z4sjyrsjnAH322Wc89thjeHp6UrFixWyFC202G4cOHcp71CWIEqBiELsTPu4ATq7w1H4oU+HmrxERkSKz5sApJizawbGzZguNQcEBvNi7Mb5l8tdX0wpFngBVrVqVf//734wfPx4np3zdRSvRlAAVk487Qex26PlfaPN/VkcjIuLwklLS+e+KfXy5/giGAZW93XmtX1N6NK1qdWi5UuSToFNTUwkJCSmVyY8UoxYPmF9VE0hEpETwcndhYt8mzH+0HXUqe3HqfAqPfRPB6LlbiL+QYnV4hSpfGczw4cMJCwsr7FjE0TQbbN4Ci9kKJ3dZHY2IiFzWulYFlv27E/+8sy7OTjaWbo+h67u/813k8Tz3/CypXPLzooyMDN555x1WrFhB8+bNr5kE/e677xZKcFLKeVWE+t3NmkBb50L3N6yOSERELvNwdebZHg3p3cyfpxdsZ09MImPCtrJk2wneGNAUf19Pq0MskHzNAercufP1D2iz8euvvxYoKKtpDlAx2vcThA4Fr8owbg84289kOxERR5GWkcnHqw7y4a9/kpqRibe7CxN6NWLorYE4OdlufoBiUuSToEs7JUDFKCMN3m0ESafgvnnQoKfVEYmIyHUcOHmepxdsZ2v0OQDa1qnA2/c2p2ZFL2sDu6zIJ0GLFBpnV2geYj7XZGgRkRLtFj9vFv6zPS/0boSHqxMbDp2h+9TVfLbmEBmZ9jWeogRIrBd0n/l133JIurbBroiIlBzOTjYe6VSHFWNup12diiSnZfL60j3cO2Md+0+etzq8XFMCJNar2hT8gyAzDXbMtzoaERHJhZoVvZj7jza8OaAZZd1d2Bp9jns+WMuHvxwgLSPT6vBuSgmQlAwtHjS/6jaYiIjdsNls3N+mBuHjbueuhlVIzchkSvh++k77HzuPJ1gd3g0pAZKSodkgsyZQ7HaI3WF1NCIikgf+vp7MGt6aqSEtKF/GlT0xifT76H+8vXwvyWkZVoeXIyVAUjKUqfDXCrCtodbGIiIieWaz2ejfsjrh4+6gd3N/MjINZqw6SK/317DpyBmrw7uGEiApOa60xtgeZi6PFxERu1OprDsf3d+KT4YFU9nbnUPxSQz5ZD0vf7+TpJR0q8PLogRISo56XcCrClyMhwM/Wx2NiIgUQPcmVVk59g4GBwdgGPDl+qN0e281aw6csjo0QAmQlCTOLhB0pSbQXGtjERGRAvMt48p/Bwfx1cjbqF7Ok+PnLjFs1kaenr+NhIvWjvQrAZKSJeh+8+v+5ZAUb20sIiJSKG6vX5mfx97O8HY1AZgfcYxeH6yxdIK0EiApWfwaQ7WWkJmumkAiIqWIl7sLr/RryvzH2lGnkhf3tqqOh6uzZfEoAZKS58pk6EjVBBIRKW1urVWBZU92YvRd9SyNQwmQlDxN7wVnNzi5A2K2Wx2NiIgUMg9XZ9xdrBv9ASVAUhKVqQANepnPNRlaRESKgBIgKZmu3Abb8S2kp1obi4iIlDpKgKRkqnsXlPWDi6dVE0hERAqdEiApmZxdoPmVmkCaDC0iIoVLCZCUXFdug+1fARfirI1FRERKFSVAUnJVaQjVg8HIUE0gEREpVEqApGRrcbkydOQcMAxrYxERkVJDCZCUbFdqAsXtgphtVkcjIiKlhBIgKdk8y0PD3uZz1QQSEZFCogRISr4WD5pfd3wL6SnWxiIiIqWCEiAp+ep2Bm9/uHTWXBEmIiJSQEqApORzcv5bTSDdBhMRkYJTAiT24cpqsAM/w/mT1sYiIiJ2TwmQ2IfKDaB668s1gb61OhoREbFzSoDEfrS8XBl661zVBBIRkQJRAiT2o8lAcHaHuN0Qs9XqaERExI4pARL74VkOGt1jPtdkaBERKQAlQGJfrkyG3jFfNYFERCTflACJfanTGbyrmTWB9v1kdTQiImKnLE+Apk+fTu3atfHw8CA4OJg1a9Zcd99FixbRtWtXKleujI+PD+3atWPFiusXxps3bx42m43+/fsXQeRiCSdnCBpqPtdtMBERySdLE6CwsDDGjBnD888/T2RkJJ06daJnz55ERUXluP/q1avp2rUry5YtIyIigs6dO9OnTx8iIyOv2ffo0aM89dRTdOrUqahPQ4rbldtgf66E87HWxiIiInbJZhjWrSdu06YNrVq1YsaMGVnbGjVqRP/+/Zk0aVKujtGkSRNCQkJ46aWXsrZlZGRwxx138PDDD7NmzRrOnTvHd999l+u4EhMT8fX1JSEhAR8fn1y/TorRZ13h2Ebo+hp0+LfV0YiISAmQl89vy0aAUlNTiYiIoFu3btm2d+vWjXXr1uXqGJmZmZw/f54KFSpk2/7qq69SuXJlRo0alavjpKSkkJiYmO0hJdyVUaCtc1QTSERE8syyBCg+Pp6MjAz8/Pyybffz8yM2Nne3NaZMmUJSUhJDhgzJ2va///2PWbNm8emnn+Y6lkmTJuHr65v1CAwMzPVrxSJNB4KLB5zaCye2WB2NiIjYGcsnQdtstmzfG4ZxzbachIaGMnHiRMLCwqhSpQoA58+f58EHH+TTTz+lUqVKuY5hwoQJJCQkZD2io6PzdhJS/Dx8oVEf87kmQ4uISB65WPXGlSpVwtnZ+ZrRnri4uGtGha4WFhbGqFGjmD9/Pl26dMnafvDgQY4cOUKfPn2ytmVmZgLg4uLCvn37qFu37jXHc3d3x93dvSCnI1Zocb9ZD2jHAuj2Brh6WB2RiIjYCctGgNzc3AgODiY8PDzb9vDwcNq3b3/d14WGhjJixAjmzp1L7969s/2sYcOG7Nixg61bt2Y9+vbtS+fOndm6datubZU2te8An+qQfA72qyaQiIjknmUjQADjxo1j2LBhtG7dmnbt2jFz5kyioqJ47LHHAPPW1PHjx/nqq68AM/l56KGHeP/992nbtm3W6JGnpye+vr54eHjQtGnTbO9Rrlw5gGu2SylwpSbQmikQOQeaDLA6IhERsROWzgEKCQlh6tSpvPrqq7Ro0YLVq1ezbNkyatasCUBMTEy2mkCffPIJ6enpjB49Gn9//6zHk08+adUpiNWCLq8GO/gLJMZYG4uIiNgNS+sAlVSqA2RnZnWH6A3Q5RXoOMbqaERE5EZSL8LCR+C2R6DuXYV6aLuoAyRSaLJqAs1VTSARkZIsORHmDIJ9S2HhPyA1ybJQlACJ/WvSH1w8IX4fHFdNILmJC6cgaoOSZZHidvEMfN0fjv4P3H1g6Fxw87IsHCVAYv+y1QT6xtpYpOTKSIcNH8MHLWF2d1j2FFwukyEiRexCHHzZB45HgGcFGP4D1GhjaUhKgKR0aPmA+XXHQkhLtjYWKXmORcCnnWH5s5B63ty26TNY/ChkpFkbm0hpl3AcPu8FJ3dCWT94eBlUa2F1VEqApJSodTv4BEBKgnlvWQTg0ln4cSx8djfEbjdHC3u/CwM/BScX2PEthA2DtEtWRypSOp05DJ/3gNMHwDcQHv4JqjSyOipACZCUFk5O0OI+87laY4hhwLZ5MO1W2DwbMKD5UHh8M9w6CpoPMecfuHiYRTS/GWROzhSRwnNqH3zeE85FQYW6ZvJT8dpuDFZRAiSlR9DlBOjgr5B4wtpYxDqn9plzDRY/CkmnoFIDGP4jDPwEylb5a7/63eHBReDmDUfXmq9JOm1d3CKlScx287bX+Rio0thMfsqVrG4MSoCk9KhYF2q0AyPT/OtfHEvqRVj5CszoAEfWmCsD734JHlsLtTvl/JpaHWDED1CmIsRsNf9aTTherGGLlDrRm+DLe+BiPPi3gBFLwfvGPT6toARISpcWlydDqyaQY9m/Aqa3gbXvQmYa1O8BozdAp/+Ai9uNX1utJTy83OwrF78PZveA0weLJ26R0ubwGnOpe3ICBLaF4UugTAWro8qREiApXZr0B9cy5oS7Y5utjkaKWsIxmPcAzB1izjPwqQ4hc+C+eVC+Vu6PU7k+jFxuzlNIiDKToNgdRRa2SKl0INwscph6AercCcMWmQsPSiglQFK6uHtDo77m861zrI1Fik5GGvzvA5h2G+z90VzR1f7fMHojNLoHbLa8H7NcDTMJ8msGSXHwRW+I+qPwYxcpjXYvgdD7ID0Z6veE+8IsLXKYG0qApPS50hpj5yItby6NojbAJ7dD+IuQlmTO+3p0DXR7DdzLFuzYZavAiB/NofvkBHMo/89fCiVskVJrWxjMH2Hefm4yEEK+BlcPq6O6KSVAUvrU6gS+NcyaQHtVE6jUSDoN3482qzjH7TaryfadBiOWgV/jwnsfz3Lm0H29LpB2EeaGwK7vCu/4IqXJ5tnmiksjA1o+CPd+Bs6uVkeVK0qApPTJVhNIt8HsXmYmbPkKprWGyMutTloOgycioNUw83oXNjcvGBoKjfubf9UueBi2fF347yNiz9ZNMwuNYsBtj0KfD8HJ2eqock0JkJROQUPNrwd/07Jme3Zyl7k0fckTcOkMVGkCI1dAv2lFv7LExQ0GzYZWD5mlFZY8Dus+LNr3FLEHhgGr3oafnze/7zgOer5dNH+MFCH7ilYktyrUgZodAAO2qyaQ3Um5AD+/AB93gugN4OoF3V6HR3+HGm2LLw4nZ+jzgTnBGsyYfnlNJRbEcRkGhL8Eq940v7/rRejycv4WHlhMCZCUXlcmQ0fO0QeWvTAM2PMDfHSbOdpiZECjPvD4Rmj/hDVzC2w2c4L13S+b36+ZDMueVid5cTyZmbD0P7DuA/P7Hm/B7U9ZG1MBKAGS0qtxP7Mm0JmDEL3R6mjkZs4eMScchz0IicehXE24fz6EfAO+AVZHB53GQe8pgA02fapO8uJYMtLh+3/B5lmADfp+CG3/aXVUBaIESEovd29zEitoMnRJlp4KqyfDR23hwApwcjUrOP9rA9TvZnV02d36iLnKRZ3kxZGkp8LCkbAtFGzO5v8DrR6yOqoCUwIkpduV22C7Fpu9oqRkObwGPu4Av74G6ZfMEgb//J/Zw8utjNXR5azZIHWSF8eRdgnCHoDd34Ozm1njp9kgq6MqFEqApHSr2cGs8JuSqJpAJcmFU7DoUbNhYvx+8KoMA2bC8B+gcgOro7u5qzvJf9VXneSl9Em5AHMGw4GfzebC982Dhr2tjqrQKAGS0s3JCYIujwJt/cbaWAQyM2DTLJgWfHl1ng1aj4LHN0FQiH2tJPl7J/kTkeokL6XLpXPw9QA4ssZM9Ictgnp3Wx1VoVICJKXflaKIh36Hc9HWxuLITmyFWV1h6TizzYR/EDzyC9zzLniWtzq6/FEneSmNkuLN0dljG8GjHAz/Hmq2tzqqQqcESEq/8rXMuSWqCWSN5ET46Vn4tDMcjzD/muz5DvzjNwgItjq6gsuxk/xOq6MSyZ/EGPi8F8TuMG9Nj1gK1UvB/6c5UAIkjuHKZOitc1UTqLgYBuxcCNNuhT8+NqspN70XntgMbR61q5L5N3VNJ/le6iQv9ufsUfi8hzma6VPdHN2s2tTqqIqMEiBxDI36mtWEzxyCaH0wFbnTB+GbgbBgJFyINUdHhi02W0t4V7U6uqKhTvJiz+L/NOexnT1ijpo//BNUqmd1VEVKCZA4Bvey0KS/+TxSk6GLTFoyrHoLpreDg7+Cszvc+Rz8cx3Uvcvq6IrelU7yde9WJ3mxH1d67iUeh0oNzJGf8jWtjqrIKQESx5FVE+g7SE2yNJRS6eCvMKMdrJoEGSlmwvOv9XDns+DqYXV0xcfNy1wurE7yYg+OR5hzfpLioGozeHgZ+PhbHVWxUAIkjqNGe3NoN/U87PnR6mhKj8QYmD/CXDJ75hCUrQqDPjfr5FSsa3V01sixk/w0q6MSye7oOviyHySfg4BbYfiP4FXJ6qiKjRIgcRzZagKpNUaBZaTDho/NSc67FoPNCdr806zp03SgfdX0KQrXdJJ/Xp3kpeT48xf4eqD5B2GtTjDsO/MWrgNRAiSOJWio+fXwajgXZW0s9uxYhLmsffmz5j+g1VvD/62Cnm+Bh4/V0ZUcNht0fdVs7QHqJC8lw96lEDrUbD9zSzd4YL45T9LBKAESx1K+5l81gbapJlCeXToLP46Fz+6G2O3g4Qv3vAejws3ChnItm81s7vr3TvLfPaZO8mKNHQvMJr4ZqdC4H4TMAVdPq6OyhBIgcTwtHzS/bp2j2xG5ZVxOGKfdCptnAwYE3QePR0DrkebtRbmxv3eS3x6mTvJS/LZ8BQsfASPD/P/33tnmfDUHpX+1xPE06gNuZc16F1HrrY6m5Du1D77sA4sfhaRT5jLZ4T/CgI+hbGWro7Mv6iQvVtkwA5Y8ARhm/71+08HZxeqoLKUESByPm9dfNYE0Gfr6Ui/CyldgRgezIaKLpzmX5bG1ULuT1dHZr/rd4cGF6iQvxWf1ZFg+3nze/gnzdqxGbZUAiYNq8YD5VTWBcrZ/BUxvA2vfNWvZ1O8Bo/8w57I48JB5oanV8dpO8oknrI5KShvDMP+I+fU18/s7n4Our2mF5mVKgMQx1WgH5WtD6gXYvcTqaEqOhGMw7wGYO8RcJecTYE6SvG+eQ1SGLVZXd5Kf1V2d5KXwZGaaTYjXvmt+3+11syipkp8sSoDEMdlsf40C6TaYuSLpfx/AtNtg74/mRN32/zZHfRrdo380i0pWJ/k66iQvhSczA354AjZ+AtjMlZrtn7A6qhJHCZA4rqChgM2c33L2qNXRWCdqA3xyB4S/CGlJ5ujYo2ug22sOWRuk2JWrASNXZO8kH73R6qjEXmWkmSu9Ir8xi5MO+NhcqSnXUAIkjqtcINS+3XzuiDWBkk7D96NhdneI2wWeFaDfRzBiGfg1tjo6x3J1J/mv+pm91UTyIi3ZLK+waxE4ucLgL/4q/irXUAIkju3vt8EcpTpvZqZZD2Raa/OvRDB7Vj0RYdZI0uoQa1zdSX7OENj9vdVRib1ITYLQELO8gosH3BdqFjqU67L8X7rp06dTu3ZtPDw8CA4OZs2aNdfdd9GiRXTt2pXKlSvj4+NDu3btWLFiRbZ9Pv30Uzp16kT58uUpX748Xbp0YeNGDSfLdTTqYy5HPncUotZZHU3RO7nLXHG05Am4dAaqNDFvv/T9EMpUsDo6ubqT/PwR6iQvN5ecYPb1OrTKrHH2wAK4pavVUZV4liZAYWFhjBkzhueff57IyEg6depEz549iYrKuUfT6tWr6dq1K8uWLSMiIoLOnTvTp08fIiMjs/ZZtWoV9913H7/99hvr16+nRo0adOvWjePHjxfXaYk9cSsDTQeYz7fOtTaWopRyAX5+AT7uBNEbwNXLXBXy6O9Qo63V0cnfqZO85MXFM/BlX/P/aw9fs6mp6nTlis0wrOsF0KZNG1q1asWMGTOytjVq1Ij+/fszadKkXB2jSZMmhISE8NJLL+X484yMDMqXL8+0adN46KGHcnXMxMREfH19SUhIwMdHjR1LvagN5jwYVy94an/pmvhrGOaqrp/GQ+Ixc1ujPtDjLfANsDY2uTHDgPCXYN0H5ve3Pw2dn9eKPPnL+ZPwdX+I2w1lKsGwxeDf3OqoLJWXz2/LRoBSU1OJiIigW7du2bZ369aNdetydysiMzOT8+fPU6HC9YfuL168SFpa2g33SUlJITExMdtDHEhgG3MZcloS7ClFNYHOHoG5IRD2oJn8lKsJ98+HkG+U/NiDqzvJr/4v/PSM48xVkxs7Fw2f9zCTH29/eHiZwyc/eWVZAhQfH09GRgZ+fn7Ztvv5+REbG5urY0yZMoWkpCSGDBly3X3Gjx9P9erV6dKly3X3mTRpEr6+vlmPwMDA3J2ElA42G7S433weWQpqAqWnmqXvP2oLB1aYq0E6PQX/2gD1u9389VJyXN1JfuNMdZIXs2Dm5z3hzCGzjMLDP0HlBlZHZXcsnwRtu2o41zCMa7blJDQ0lIkTJxIWFkaVKlVy3Oedd94hNDSURYsW4eHhcd1jTZgwgYSEhKxHdHR03k5C7F/QfYDN7M105rDV0eTf4TXwcQez9H36JajVCf65Du5+0ZzvJPYpx07yyVZHJVaI22MmPwnRULGeWU28Qm2ro7JLliVAlSpVwtnZ+ZrRnri4uGtGha4WFhbGqFGj+Pbbb687sjN58mTefPNNfv75Z5o3v/GwoLu7Oz4+Ptke4mB8A6DOneZze6wJdOEULHoUvrwH4veDV2UY+CkM/8GsNiz27+pO8nMGQcp5q6OS4nRiK3zeCy6cBL+m5siPb3Wro7JbliVAbm5uBAcHEx4enm17eHg47du3v+7rQkNDGTFiBHPnzqV379457vPf//6X1157jeXLl9O6detCjVtKsSs1gbbNtZ95FpmZsGkWTAuG7fMAG7QeBY9vguZDNGG2tPl7J/kja+DLPuok7yii/jCv96UzUD3Y/OOmbM53PyR3LL0FNm7cOD777DNmz57Nnj17GDt2LFFRUTz22GOAeWvq7yu3QkNDeeihh5gyZQpt27YlNjaW2NhYEhISsvZ55513eOGFF5g9eza1atXK2ufChQvFfn5iZxr2Bncfswno0f9ZHc3NxWyDWV1g6TizDoh/EDzyC9zzLniWtzo6KSrqJO94Dq0yV3ulJELNDuZSd9XtKjBLE6CQkBCmTp3Kq6++SosWLVi9ejXLli2jZk2z63RMTEy2mkCffPIJ6enpjB49Gn9//6zHk08+mbXP9OnTSU1NZdCgQdn2mTx5crGfn9gZtzLQ5EpNoBI8GTo50ezyPPNOOB5hJm0934F//AYBwVZHJ8Xh6k7ys9VJvtTat9ysCp520awS/sAC8NA0jcJgaR2gkkp1gBxY1B8wuxu4lrlcE8jb6oj+Yhhmj5/lz8GFy3Pnmt4L3d8E76rWxibWOBdl9g07cwi8qph1YKo2tToqKSw7F8Gif0BmOjS8xyyQ6eJudVQlml3UARIpkQJvM1dWpF0sWX2YTh+EbwbCgpFm8lOhrvlhN2i2kh9Hpk7ypVfkHFg4ykx+mg02G5sq+SlUSoBE/u7vNYFKQmuMtGRY9RZMb2d2B3d2hzufM5e2173L6uikJMjqJN9GneRLi42fwvf/MluhtBoOAz4BZ1eroyp1lACJXK35UMyaQP8zby1Y5eCvMKMdrJoEGSnm/f9/rYc7nwXX69e1EgfkWc4cEVQnefu3diose8p83vZf0Od9cHK2NKTSSgmQyNV8q0PdzubzraHF//6JMTD/Yfh6gJmAefubw98PLoSKdYs/HrEP6iRv3wwDfn0DVr5sfn/7M+b8PpWyKDJKgERyklUTKLT4agJlpMOGj2HareZkZ5sTtPknjN5ork7TP4RyM1c6ybccpk7y9sQwYMXzsPod8/suE+EuNb4tai5WByBSIjXsDe6+Zrn5I2ugzh1F+37HIuDHMRC73fy+emuzno9/UNG+r5Q+Ts7Q90Pztti6D+Hn5yH5nDrJl1SZGfDjWNjypfl9r8lw2z+sjclBaARIJCeuntB0oPm8KCdDXzpr/uP32d1m8uPhC/e8B6PClfxI/tls0PU1dZIv6TLSYfFjZvJjc4J+05X8FCMlQCLXc+U22O7vzeKDhckwYFuYebtr82zAMBuyPh4BrUeCk/7XlAJSJ/mSLT0F5g+HHd+aTW7vnQUtH7A6KoeiW2Ai1xPQGireAqcPwO7voNVDN31Jrpzab7avOLLG/L5SA/N2V62OhXN8kb+79RHzdu53j5md5JMTzUn1WklondSLEPYgHPzFLG0x5Cto0MPqqByO/swUuR6b7a+/yArjNljqRfjlVZjR3kx+XDzh7pfhsbVKfqRoNR+sTvIlRcp58/d/8Bez4vwD3yr5sYgSIJEbaR5i3puPWl+wXkv7V8D0NrBmirlEuX4PGP0HdBpnrtwRKWrqJG+9i2fMQpVH/2f28Bu2GOrcaXVUDksJkMiN+FT7q+LytnzUBEo4BvMegLlDzL5NPgEQMses11K+ZuHGKnIzVzrJe1YwO8l/0Uud5IvLhTgz6TweYf7+h/8ANdpaHZVDUwIkcjNZrTFCzSWruZGRBv/7AKbdBnt/NCc5tv+3OerT6B4tRxbrVGsJIy93kj+1V53ki0PCcfi8F5zcCWX94OFlUK2F1VE5PCVAIjfToLe5PD3xGBxeffP9ozbAJ3dA+IuQlgQ12sGja6Dba+BetujjFbmZyg3MJKhCHXNkcnYPiN1pdVSl05nD8HkPczGFbyA8/BNUaWR1VIISIJGbc/WApoPM5zeaDH3xDHz/uPkXddwuc5i730cwYhn4NS6eWEVyS53ki96p/fB5TzPJrFDHTH7UzqbEUAIkkhtXagLt+cHsuP13mZlmz6UPgyHycu+lVg/BExHQ8kHV9JGSS53ki07MdjP5OR8DlRuZyU+5QKujkr/Rv8wiuVG9lVmvJ/0S7Prur+0nd5n/yC15HC6dgSpNzL+q+34IZSpYFq5IrqmTfOGL3gRf3gMX48G/hTnnx7uq1VHJVZQAieSGzfa3ydBzIOUC/PwCfNwJojeAqxd0ewMe/V0rO8T+5NRJPvIbq6OyT4fXwNf9zRG1wLYwfIn+GCqhbIZhGFYHUdIkJibi6+tLQkICPj4+VocjJUViDLzX2Oyy7e1vDm0DNOoLPd4C3+rWxidSUJkZ8MOTf93K7f4mtBttbUz25EC4WeE5Pdms7zN0rplcSrHJy+e3RoBEcsvHH+p1MZ+fj4FyNeH++RDytZIfKR2udJJv/4T5/Yrn4Nc3zN51cmO7l0DofWbyU78n3Bem5KeEUy8wkby4c7yZ/NzS3Ww06VbG6ohECteVTvIe5eDX12D1O5B8Dnq8rQn917MtDL77JxgZ0GQgDJwJzq5WRyU3oQRIJC+qB5u9u0RKM5sNbn/KnCC99Cmzk3xyglnWQR/s2W2eDT+OAwxo8SD0/cAcSZMST+m8iIjk7NZHYOCnYHM2O8l/+xCkJVsdVcmxbhr8OBYw4LZHzduHSn7shhIgERG5vr93kt+3TJ3kwZwTtept+Pl58/uOY6GnbhHaG10tERG5sQY91En+CsOA8Jdg1Zvm93e9CF0mqr+fHVICJCIiN6dO8mbV96X/gXUfmN/3eMucKyV2SQmQiIjkzpVO8t7VHK+TfEY6fP8v2DwLsEGfD6DtP62OSgpACZCIiORe5QYwaoVjdZJPT4WFI2FbqDkh/N7PIHi41VFJASkBEhGRvHGkTvJplyDsAbM/mrObWfi02SCro5JCoARIRETyzhE6yadcgDmD4cDP4OJp9ktr2NvqqKSQKAESEZH8yeokf5fZSX5uiNkSojS4dA6+HmCuenPzhmGLoN7dVkclhUgJkIiI5N/fO8lnpML84fbfST4pHr68B45tNFuCDP8eara3OiopZEqARESkYFzcYdBsaDkMjEz4fjSs/8jqqPInMQY+7wWxO8CrMoxYarbAkVJHCZCIiBRcaegkf/YofN4D4veBT3V4eDlUbWp1VFJElACJiEjhuNJJ/q4Xze9XvwM/PWsWECzp4v+Ez3vC2SNQvhY8/BNUqmd1VFKElACJiEjhudJJvtdkwAYbP4HvHoOMNKsju76Tu8zkJ/E4VGpgjvyUr2l1VFLElACJiEjhu+0f9tFJ/niEOecnKQ6qNoOHl4GPv9VRSTFQAiQiIkWjpHeSP7oOvuwHyecg4FYY/iN4VbI6KikmSoBERKToXNNJvi9cPGN1VGbRxq8HQup5qNUJhn1n1jUSh6EESEREilatjjB8yeVO8lsuz7exsJP83qVm0cb0S3BLN3hgPriXtS4esYQSIBERKXrVW13bSf7MoeKPY8cCCBtmFm1s1BdC5oCrZ/HHIZazPAGaPn06tWvXxsPDg+DgYNasWXPdfRctWkTXrl2pXLkyPj4+tGvXjhUrVlyz38KFC2ncuDHu7u40btyYxYsXF+UpiIhIblRuYCZBf+8kf3JX8b3/lq9g4SNgZEDQfTDoc3BxK773lxLF0gQoLCyMMWPG8PzzzxMZGUmnTp3o2bMnUVFROe6/evVqunbtyrJly4iIiKBz58706dOHyMjIrH3Wr19PSEgIw4YNY9u2bQwbNowhQ4bwxx9/FNdpiYjI9ZSvaS4z92sKF06aK7CiNxX9+26YAUueAAxoPRL6TQdnl6J/XymxbIZhXZnONm3a0KpVK2bMmJG1rVGjRvTv359Jkybl6hhNmjQhJCSEl156CYCQkBASExP56aefsvbp0aMH5cuXJzQ0NFfHTExMxNfXl4SEBHx8fPJwRiIikiuXzsHcIRD9B7iWgaFzzKaqRWH1ZPj1NfN5+yfMYo02W9G8l1gqL5/flo0ApaamEhERQbdu3bJt79atG+vWrcvVMTIzMzl//jwVKlTI2rZ+/fprjtm9e/dcH1NERIpBcXSSNwxY+cpfyc+dzyn5kSyWJUDx8fFkZGTg5+eXbbufnx+xsbG5OsaUKVNISkpiyJAhWdtiY2PzfMyUlBQSExOzPUREpIhldZLv97dO8nMK59iZmWYbjrXvmt93ex3ufFbJj2SxfBK07ar/GA3DuGZbTkJDQ5k4cSJhYWFUqVKlQMecNGkSvr6+WY/AwMA8nIGIiOSbi7s5GTmrk/y/YP30gh0zMwN+eMJsw4ENer/7V5NWkcssS4AqVaqEs7PzNSMzcXFx14zgXC0sLIxRo0bx7bff0qVLl2w/q1q1ap6POWHCBBISErIe0dHReTwbERHJt2s6yU/Ifyf5jDRzpVfkN2BzggEfw62jCjdeKRUsS4Dc3NwIDg4mPDw82/bw8HDat29/3deFhoYyYsQI5s6dS+/eva/5ebt27a455s8//3zDY7q7u+Pj45PtISIixagwOsmnJZs1fnYtAidXGPwFBA0tknDF/lm6BnDcuHEMGzaM1q1b065dO2bOnElUVBSPPfYYYI7MHD9+nK+++gowk5+HHnqI999/n7Zt22aN9Hh6euLr6wvAk08+ye23387bb79Nv379+P7771m5ciVr16615iRFRCR3rnSS9/CFZU+Zt7CSE6DfRzdfsp6aBPPuh0OrzN5jId/ALV2LJWyxT5bOAQoJCWHq1Km8+uqrtGjRgtWrV7Ns2TJq1qwJQExMTLaaQJ988gnp6emMHj0af3//rMeTTz6ZtU/79u2ZN28en3/+Oc2bN+eLL74gLCyMNm3aFPv5iYhIPmTrJD8Pvh12407yyQlmX69Dq8DVCx5YoORHbsrSOkAlleoAiYiUAPuWmyvD0pPNhqX3hYK7d/Z9Lp6BrwdAzFZz5OiBhRB4qyXhivXsog6QiIjIDd2sk/z5k/BFbzP5KVMRhv+o5EdyTQmQiIiUXNfrJH8uGj7vAXG7wdsfHv4J/JtbHa3YETVCERGRku1KJ/mv+v/VSd4wICEaytWAh5ZAhdpWRyl2RiNAIiJS8l3dST4hGirWM0d+lPxIPmgESERE7MOVTvILLxc2HDQbyla58WtErkMJkIiI2A9vPxjxo9VRSCmgW2AiIiLicJQAiYiIiMNRAiQiIiIORwmQiIiIOBwlQCIiIuJwlACJiIiIw1ECJCIiIg5HCZCIiIg4HCVAIiIi4nCUAImIiIjDUQIkIiIiDkcJkIiIiDgcJUAiIiLicJQAiYiIiMNxsTqAksgwDAASExMtjkRERERy68rn9pXP8RtRApSD8+fPAxAYGGhxJCIiIpJX58+fx9fX94b72IzcpEkOJjMzkxMnTuDt7Y3NZivUYycmJhIYGEh0dDQ+Pj6FeuySoLSfH5T+c9T52b/Sfo46P/tXVOdoGAbnz5+nWrVqODndeJaPRoBy4OTkREBAQJG+h4+PT6n9DxtK//lB6T9HnZ/9K+3nqPOzf0Vxjjcb+blCk6BFRETE4SgBEhEREYejBKiYubu78/LLL+Pu7m51KEWitJ8flP5z1PnZv9J+jjo/+1cSzlGToEVERMThaARIREREHI4SIBEREXE4SoBERETE4SgBEhEREYejBKgQrV69mj59+lCtWjVsNhvffffdTV/z+++/ExwcjIeHB3Xq1OHjjz8u+kALIK/nuGrVKmw22zWPvXv3Fk/AeTBp0iRuvfVWvL29qVKlCv3792ffvn03fZ09XcP8nKM9XcMZM2bQvHnzrOJq7dq146effrrha+zp+kHez9Gerl9OJk2ahM1mY8yYMTfcz96u4xW5OT97u4YTJ068JtaqVave8DVWXD8lQIUoKSmJoKAgpk2blqv9Dx8+TK9evejUqRORkZE899xz/Pvf/2bhwoVFHGn+5fUcr9i3bx8xMTFZj1tuuaWIIsy/33//ndGjR7NhwwbCw8NJT0+nW7duJCUlXfc19nYN83OOV9jDNQwICOCtt95i8+bNbN68mbvuuot+/fqxa9euHPe3t+sHeT/HK+zh+l1t06ZNzJw5k+bNm99wP3u8jpD787vCnq5hkyZNssW6Y8eO6+5r2fUzpEgAxuLFi2+4zzPPPGM0bNgw27ZHH33UaNu2bRFGVnhyc46//fabARhnz54tlpgKU1xcnAEYv//++3X3sfdrmJtztOdraBiGUb58eeOzzz7L8Wf2fv2uuNE52uv1O3/+vHHLLbcY4eHhxh133GE8+eST193XHq9jXs7P3q7hyy+/bAQFBeV6f6uun0aALLR+/Xq6deuWbVv37t3ZvHkzaWlpFkVVNFq2bIm/vz933303v/32m9Xh5EpCQgIAFSpUuO4+9n4Nc3OOV9jbNczIyGDevHkkJSXRrl27HPex9+uXm3O8wt6u3+jRo+nduzddunS56b72eB3zcn5X2NM1PHDgANWqVaN27doMHTqUQ4cOXXdfq66fmqFaKDY2Fj8/v2zb/Pz8SE9PJz4+Hn9/f4siKzz+/v7MnDmT4OBgUlJS+Prrr7n77rtZtWoVt99+u9XhXZdhGIwbN46OHTvStGnT6+5nz9cwt+dob9dwx44dtGvXjuTkZMqWLcvixYtp3Lhxjvva6/XLyzna2/UDmDdvHlu2bGHTpk252t/ermNez8/ermGbNm346quvqF+/PidPnuT111+nffv27Nq1i4oVK16zv1XXTwmQxWw2W7bvjcuFua/ebq8aNGhAgwYNsr5v164d0dHRTJ48uUT+j3vF448/zvbt21m7du1N97XXa5jbc7S3a9igQQO2bt3KuXPnWLhwIcOHD+f333+/boJgj9cvL+dob9cvOjqaJ598kp9//hkPD49cv85ermN+zs/ermHPnj2znjdr1ox27dpRt25dvvzyS8aNG5fja6y4froFZqGqVasSGxubbVtcXBwuLi45ZsmlRdu2bTlw4IDVYVzXE088wZIlS/jtt98ICAi44b72eg3zco45KcnX0M3NjXr16tG6dWsmTZpEUFAQ77//fo772uv1y8s55qQkX7+IiAji4uIIDg7GxcUFFxcXfv/9dz744ANcXFzIyMi45jX2dB3zc345KcnX8GpeXl40a9bsuvFadf00AmShdu3a8cMPP2Tb9vPPP9O6dWtcXV0tiqroRUZGlrghaTD/4njiiSdYvHgxq1atonbt2jd9jb1dw/ycY05K6jXMiWEYpKSk5Pgze7t+13Ojc8xJSb5+d9999zUrhh5++GEaNmzIs88+i7Oz8zWvsafrmJ/zy0lJvoZXS0lJYc+ePXTq1CnHn1t2/Yp0irWDOX/+vBEZGWlERkYagPHuu+8akZGRxtGjRw3DMIzx48cbw4YNy9r/0KFDRpkyZYyxY8cau3fvNmbNmmW4uroaCxYssOoUbiqv5/jee+8ZixcvNvbv32/s3LnTGD9+vAEYCxcutOoUruuf//yn4evra6xatcqIiYnJely8eDFrH3u/hvk5R3u6hhMmTDBWr15tHD582Ni+fbvx3HPPGU5OTsbPP/9sGIb9Xz/DyPs52tP1u56rV0mVhuv4dzc7P3u7hv/5z3+MVatWGYcOHTI2bNhg3HPPPYa3t7dx5MgRwzBKzvVTAlSIrixVvPoxfPhwwzAMY/jw4cYdd9yR7TWrVq0yWrZsabi5uRm1atUyZsyYUfyB50Fez/Htt9826tata3h4eBjly5c3OnbsaCxdutSa4G8ip/MCjM8//zxrH3u/hvk5R3u6hiNHjjRq1qxpuLm5GZUrVzbuvvvurMTAMOz/+hlG3s/Rnq7f9VydIJSG6/h3Nzs/e7uGISEhhr+/v+Hq6mpUq1bNGDhwoLFr166sn5eU62czjMszjUREREQchCZBi4iIiMNRAiQiIiIORwmQiIiIOBwlQCIiIuJwlACJiIiIw1ECJCIiIg5HCZCIiIg4HCVAIiK5sGrVKmw2G+fOnbM6FBEpBEqARERExOEoARIRERGHowRIROyCYRi888471KlTB09PT4KCgliwYAHw1+2ppUuXEhQUhIeHB23atLmm6/bChQtp0qQJ7u7u1KpViylTpmT7eUpKCs888wyBgYG4u7tzyy23MGvWrGz7RERE0Lp1a8qUKUP79u3Zt29f0Z64iBQJJUAiYhdeeOEFPv/8c2bMmMGuXbsYO3YsDz74IL///nvWPk8//TSTJ09m06ZNVKlShb59+5KWlgaYicuQIUMYOnQoO3bsYOLEibz44ot88cUXWa9/6KGHmDdvHh988AF79uzh448/pmzZstnieP7555kyZQqbN2/GxcWFkSNHFsv5i0jhUjNUESnxkpKSqFSpEr/++ivt2rXL2v7II49w8eJF/u///o/OnTszb948QkJCADhz5gwBAQF88cUXDBkyhAceeIBTp07x888/Z73+mWeeYenSpezatYv9+/fToEEDwsPD6dKlyzUxrFq1is6dO7Ny5UruvvtuAJYtW0bv3r25dOkSHh4eRfxbEJHCpBEgESnxdu/eTXJyMl27dqVs2bJZj6+++oqDBw9m7ff35KhChQo0aNCAPXv2ALBnzx46dOiQ7bgdOnTgwIEDZGRksHXrVpydnbnjjjtuGEvz5s2znvv7+wMQFxdX4HMUkeLlYnUAIiI3k5mZCcDSpUupXr16tp+5u7tnS4KuZrPZAHMO0ZXnV/x9ANzT0zNXsbi6ul5z7CvxiYj90AiQiJR4jRs3xt3dnaioKOrVq5ftERgYmLXfhg0bsp6fPXuW/fv307Bhw6xjrF27Nttx161bR/369XF2dqZZs2ZkZmZmm1MkIqWXRoBEpMTz9vbmqaeeYuzYsWRmZtKxY0cSExNZt24dZcuWpWbNmgC8+uqrVKxYET8/P55//nkqVapE//79AfjPf/7DrbfeymuvvUZISAjr169n2rRpTJ8+HYBatWoxfPhwRo4cyQcffEBQUBBHjx4lLi6OIUOGWHXqIlJElACJiF147bXXqFKlCpMmTeLQoUOUK1eOVq1a8dxzz2Xdgnrrrbd48sknOXDgAEFBQSxZsgQ3NzcAWrVqxbfffstLL73Ea6+9hr+/P6+++iojRozIeo8ZM2bw3HPP8a9//YvTp09To0YNnnvuOStOV0SKmFaBiYjdu7JC6+zZs5QrV87qcETEDmgOkIiIiDgcJUAiIiLicHQLTERERByORoBERETE4SgBEhEREYejBEhEREQcjhIgERERcThKgERERMThKAESERERh6MESERERByOEiARERFxOEqARERExOH8P8kPCtQfaehvAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw mae\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_mae) + 1)), arr_train_mae, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_mae) + 1)), arr_val_mae, label=\"val\")\n",
    "\n",
    "  plt.title(\"MAE\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"mae\")\n",
    "  plt.legend(loc=\"upper right\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# draw Accuracies\n",
    "if is_graphic:\n",
    "  plt.plot(list(range(1, len(arr_train_acc) + 1)), arr_train_acc, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc) + 1)), arr_val_acc, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HSGRNN(device=device, vocab_size=vocab_size, word_embed=glovemgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_epoch = np.argmin(np.array(arr_val_loss)) + 1\n",
    "model.load(checkpoints_folder + \"/\" + model_name + \"-\" + str(best_epoch) + \".pt\")\n",
    "model.to(device)\n",
    "model.eval()\n",
    "best_epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[\"article\"], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()\n",
    "mae_fn = nn.L1Loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 27.92batch/s, accuracy=0.821, loss=0.441, rouge1=0.397, rouge2=0.165, rougeL=0.246]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "\n",
    "counter = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "  for batch in tepoch:\n",
    "    tepoch.set_description(\"Eval model\")\n",
    "    doc_lens = batch[\"doc_lens\"]\n",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets = torch.tensor(batch[\"labels\"], dtype=torch.float).to(device)\n",
    "    y_pred = model(data, doc_lens)\n",
    "\n",
    "    loss = criterion(y_pred, targets)\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"highlights\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    #probs = threshold_probs_by_nb(probs=probs, doc_lens=[probs.shape[0]], average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    #probs = threshold_probs_by_prop(probs=probs, doc_lens=[probs.shape[0]], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document)\n",
    "    indices = torch.argsort(y_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[indices[i]]\n",
    "      y_pred_thresh.append(indices[i])\n",
    "      if len(txt) >= len(summaries):\n",
    "        break\n",
    "\n",
    "    y_pred_thresh.sort()\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in y_pred_thresh:#range(min(len(doc), y_pred.shape[0])):\n",
    "      txt = txt + \". \" + doc[i]\n",
    "\n",
    "    n = min(len(txt), len(summaries))\n",
    "\n",
    "    while n < len(txt) and txt[n].isalnum():\n",
    "      n += 1\n",
    "\n",
    "    txt = txt[:n]\n",
    "\n",
    "    #assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "    scores = scorer.score(summaries, txt)\n",
    "    arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "    arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "    arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "    mae.append(mae_fn(probs_tensor, targets).item())\n",
    "\n",
    "    accuracy.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_number_of_sentences_per_document=average_number_of_sentences_per_document))\n",
    "    #accuracy.append(accuracy_prop_sent_per_doc_fn(probs=probs, targets=targets.cpu().detach().numpy(), doc_lens=[len(probs)], average_proportion_of_sentences_per_document=average_proportion_of_sentences_per_document))\n",
    "\n",
    "    tepoch.set_postfix(loss=np.mean(arr_loss), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy=np.mean(accuracy))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy\"] = np.mean(accuracy)\n",
    "test_metrics[\"mae\"]      = np.mean(mae)\n",
    "test_metrics[\"rouge1\"]   = np.mean(arr_rouge1)\n",
    "test_metrics[\"rouge2\"]   = np.mean(arr_rouge2)\n",
    "test_metrics[\"rougeL\"]   = np.mean(arr_rougeL)\n",
    "\n",
    "# Save to file in JSON format\n",
    "\n",
    "with open(checkpoints_folder + \"/test_metrics.json\", 'w') as fp:\n",
    "  json.dump(test_metrics, fp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lead-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:00<00:00, 143.36batch/s, rouge1=0.394, rouge2=0.163, rougeL=0.245]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"Lead-3\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(min(len(doc), 3)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"highlights\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### First n char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:00<00:00, 138.47batch/s, rouge1=0.396, rouge2=0.164, rougeL=0.246]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "mae = []\n",
    "accuracy = []\n",
    "\n",
    "idx = 0\n",
    "with tqdm(test_loader, unit=\"batch\", total=len(test_loader)) as tepoch:\n",
    "    for batch in tepoch:\n",
    "        tepoch.set_description(\"First-n-char'\")\n",
    "        doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "\n",
    "        txt = \"\"\n",
    "\n",
    "        for i in range(len(doc)):\n",
    "            txt = txt + doc[i]\n",
    "\n",
    "        summaries = test_set[\"highlights\"].iloc[idx]\n",
    "\n",
    "        n = min(len(txt), len(summaries))\n",
    "\n",
    "        while n < len(txt) and txt[n].isalnum():\n",
    "            n += 1\n",
    "\n",
    "        txt = txt[:n]\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].fmeasure)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].fmeasure)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].fmeasure)\n",
    "\n",
    "        idx += 1\n",
    "\n",
    "        tepoch.set_postfix(rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "SystemExit",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rsaid/.local/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3406: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "# Does not execute this cell if you want to execute the following cells.\n",
    "import sys\n",
    "sys.exit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6d7f428a150b92572ac46240b6d7ae68586908362b054f21341550673eeb77dc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}