07-train_HeterSUMGraphNER_GATv2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train HeterSUMGraph NER"
   ]
  },
  {
   "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.EmbMgr import EmbMgr\n",
    "from utils.DataLoader import DataLoader\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=2)\n",
    "parser.add_argument('-batch_size',type=int,default=4)\n",
    "parser.add_argument('-epochs',type=int,default=10)\n",
    "parser.add_argument('-dataset',type=str,default=\"data/wiki_geo_ratio_sc_0.5\")\n",
    "parser.add_argument('-dataset_tfidf',type=str,default=\"./data/wiki_geo_ratio_sc_0.5_dataset_tfidf.json\")\n",
    "parser.add_argument('-sent_tfidf',type=str,default=\"data/wiki_geo_ratio_sc_0.5_sent_tfidf.json\")\n",
    "parser.add_argument('-doc_column_name',type=str,default=\"flat_contents\")\n",
    "parser.add_argument('-labels_sum_column_name',type=str,default=\"labels_sentences\")\n",
    "parser.add_argument('-labels_ner_column_name',type=str,default=\"labels_entities\")\n",
    "parser.add_argument(\"-word_emb\",type=str,default=\"./data/cc.fr.300.vec\")\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: 2\n",
      "epochs 100\n",
      "batch_size 4\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "is_graphic = args.is_graphic != 0\n",
    "cuda_num = args.gpu_num\n",
    "embed_name = \"cc.fr.300.vec\"\n",
    "\n",
    "# hyper-parameters\n",
    "vocab_size = 50000\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_HeterSUMGraphNER_GATv2\"\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",
    "loss_sum_coef = 0.5\n",
    "loss_ner_coef = 0.5\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: 6\n",
      "GPU 0: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 1: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 2: NVIDIA GeForce GTX 1080 Ti\n",
      "GPU 3: NVIDIA GeForce GTX 1080\n",
      "GPU 4: NVIDIA GeForce GTX 1080\n",
      "GPU 5: NVIDIA GeForce GTX 1080\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",
    "elif torch.backends.mps.is_available():\n",
    "  print(\"MPS available.\")\n",
    "else:\n",
    "  print(\"No GPU available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if torch.cuda.is_available():  \n",
    "  dev = \"cuda:\" + str(cuda_num) \n",
    "elif torch.backends.mps.is_available():\n",
    "  dev = torch.device(\"mps\")\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": [
    "embmgr = EmbMgr(args.word_emb, vocab_size=vocab_size, header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_sent = pd.read_json(args.sent_tfidf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "tfidfs_dataset = json.load(open(args.dataset_tfidf))\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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test = pd.read_json(args.dataset + \"/test.json\")\n",
    "df_val = pd.read_json(args.dataset + \"/val.json\")\n",
    "df_train = pd.read_json(args.dataset + \"/train.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = create_graph_dataset(df=df_train, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "val_dataset = create_graph_dataset(df=df_val, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, is_sep_n=False, remove_stop_word = True, stemming=False, trunc_sent=-1, padding_sent=-1, trunc_doc=100)\n",
    "test_dataset = create_graph_dataset(df=df_test, tfidfs_sent=tfidfs_sent, embmgr=embmgr, word_blacklist = word_blacklist, remove_unkn_words=False, doc_column_name=args.doc_column_name, labels_sum_column_name=args.labels_sum_column_name, labels_ner_column_name=args.labels_ner_column_name, 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": [
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, ner=True)\n",
    "val_loader =  DataLoader(val_dataset, batch_size=1, shuffle=False, ner=True)\n",
    "test_loader =  DataLoader(test_dataset, batch_size=1, shuffle=False, ner=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of distinct word per doc: 309.29\n"
     ]
    }
   ],
   "source": [
    "# Average number of distinct word per doc\n",
    "print(\"Average number of distinct word per doc:\", mean([len(t[\"docs\"].x[0]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average sentence len: 15.202316412025628\n"
     ]
    }
   ],
   "source": [
    "def sents_len(doc):\n",
    "  return [torch.sum(torch.sign(s),dim=0).item() for s in doc]\n",
    "\n",
    "# Average sentence length\n",
    "lens = []\n",
    "for t in train_dataset:\n",
    "  lens = lens + sents_len(t[\"docs\"].x[1])\n",
    "\n",
    "print(\"Average sentence len:\", mean(lens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average density: 0.016426792711350446\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/raoufdine/anaconda3/lib/python3.9/site-packages/torch_geometric/data/storage.py:303: UserWarning: Unable to accurately infer 'num_nodes' from the attribute set '{'edge_index', 'x', 'edge_attr', 'undirected'}'. Please explicitly set 'num_nodes' as an attribute of 'data' to suppress this warning\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# Average density\n",
    "def density(g):\n",
    "  nb_edges = g.num_edges / 2\n",
    "  nb_nodes = g.num_nodes\n",
    "  nb_poss_edges = nb_nodes * (nb_nodes - 1) / 2\n",
    "  return nb_edges / nb_poss_edges\n",
    "\n",
    "print(\"Average density:\", mean([density(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average clustering: 0.0\n"
     ]
    }
   ],
   "source": [
    "# Average clustering\n",
    "def average_clustering(g):\n",
    "  G = nx.Graph()\n",
    "  edge_list = g.edge_index.t().tolist()\n",
    "  G.add_edges_from(edge_list)\n",
    "  return nx.average_clustering(G)\n",
    "\n",
    "print(\"Average clustering:\", mean([average_clustering(t[\"docs\"]) for t in train_dataset]))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "from torch_geometric.nn import GATv2Conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HeterSUMGraph(torch.nn.Module):\n",
    "  def __init__(self, device, vocab_size, word_embed = None, dim_word_embed = 300, num_iter=3):\n",
    "    super(HeterSUMGraph, 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",
    "    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.w_sum = nn.Linear(128, 1)\n",
    "    self.w_ner = nn.Linear(300, 1)\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):# 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",
    "    o_sum = self.w_sum(Hs)\n",
    "    o_sum = torch.sigmoid(o_sum).squeeze(-1)\n",
    "\n",
    "    o_ner = self.w_ner(Hw)\n",
    "    o_ner = torch.sigmoid(o_ner).squeeze(-1)\n",
    "\n",
    "    return o_sum, o_ner\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": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings(), dim_word_embed=300).to(device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(checkpoints_folder):\n",
    "  os.makedirs(checkpoints_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_val[\"doc_splitted\"] = split_all_docs(df_val[args.doc_column_name])\n",
    "val_set = df_val\n",
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1:   0%|          | 0/25 [00:00<?, ?batch/s]/home/raoufdine/.local/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%|██████████| 25/25 [00:04<00:00,  6.17batch/s, accuracy_ner=0.899, accuracy_sum=0.755, loss=0.462, loss_ner=0.319, loss_sum=0.606]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 : val loss = 0.455, val loss summary = 0.626, val loss ner = 0.285, val accuracy summary = 0.674, val accuracy ner = 0.914, r1 = 0.261, r2 = 0.068, rL = 0.162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2: 100%|██████████| 25/25 [00:03<00:00,  7.63batch/s, accuracy_ner=0.927, accuracy_sum=0.751, loss=0.404, loss_ner=0.248, loss_sum=0.561]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2 : val loss = 0.456, val loss summary = 0.667, val loss ner = 0.244, val accuracy summary = 0.682, val accuracy ner = 0.926, r1 = 0.255, r2 = 0.055, rL = 0.154\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3: 100%|██████████| 25/25 [00:03<00:00,  7.37batch/s, accuracy_ner=0.931, accuracy_sum=0.763, loss=0.378, loss_ner=0.222, loss_sum=0.535]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3 : val loss = 0.436, val loss summary = 0.635, val loss ner = 0.236, val accuracy summary = 0.674, val accuracy ner = 0.925, r1 = 0.265, r2 = 0.062, rL = 0.161\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4: 100%|██████████| 25/25 [00:03<00:00,  6.50batch/s, accuracy_ner=0.937, accuracy_sum=0.757, loss=0.372, loss_ner=0.197, loss_sum=0.547]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4 : val loss = 0.405, val loss summary = 0.636, val loss ner = 0.174, val accuracy summary = 0.671, val accuracy ner = 0.930, r1 = 0.262, r2 = 0.072, rL = 0.163\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5: 100%|██████████| 25/25 [00:03<00:00,  7.39batch/s, accuracy_ner=0.938, accuracy_sum=0.76, loss=0.359, loss_ner=0.166, loss_sum=0.552] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5 : val loss = 0.392, val loss summary = 0.639, val loss ner = 0.145, val accuracy summary = 0.661, val accuracy ner = 0.937, r1 = 0.265, r2 = 0.074, rL = 0.169\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6: 100%|██████████| 25/25 [00:03<00:00,  7.64batch/s, accuracy_ner=0.937, accuracy_sum=0.751, loss=0.358, loss_ner=0.16, loss_sum=0.556] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6 : val loss = 0.407, val loss summary = 0.679, val loss ner = 0.135, val accuracy summary = 0.663, val accuracy ner = 0.942, r1 = 0.275, r2 = 0.077, rL = 0.177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7: 100%|██████████| 25/25 [00:03<00:00,  6.66batch/s, accuracy_ner=0.938, accuracy_sum=0.748, loss=0.358, loss_ner=0.144, loss_sum=0.572]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7 : val loss = 0.376, val loss summary = 0.633, val loss ner = 0.119, val accuracy summary = 0.657, val accuracy ner = 0.947, r1 = 0.261, r2 = 0.062, rL = 0.160\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8: 100%|██████████| 25/25 [00:03<00:00,  7.58batch/s, accuracy_ner=0.948, accuracy_sum=0.756, loss=0.341, loss_ner=0.125, loss_sum=0.557]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8 : val loss = 0.380, val loss summary = 0.626, val loss ner = 0.134, val accuracy summary = 0.641, val accuracy ner = 0.949, r1 = 0.275, r2 = 0.076, rL = 0.171\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9: 100%|██████████| 25/25 [00:03<00:00,  7.81batch/s, accuracy_ner=0.95, accuracy_sum=0.757, loss=0.342, loss_ner=0.121, loss_sum=0.563] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9 : val loss = 0.398, val loss summary = 0.679, val loss ner = 0.117, val accuracy summary = 0.663, val accuracy ner = 0.955, r1 = 0.288, r2 = 0.089, rL = 0.184\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10: 100%|██████████| 25/25 [00:03<00:00,  7.93batch/s, accuracy_ner=0.956, accuracy_sum=0.744, loss=0.334, loss_ner=0.109, loss_sum=0.559]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10 : val loss = 0.372, val loss summary = 0.651, val loss ner = 0.093, val accuracy summary = 0.657, val accuracy ner = 0.960, r1 = 0.282, r2 = 0.082, rL = 0.178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 11: 100%|██████████| 25/25 [00:03<00:00,  7.85batch/s, accuracy_ner=0.959, accuracy_sum=0.751, loss=0.324, loss_ner=0.0965, loss_sum=0.551]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11 : val loss = 0.365, val loss summary = 0.644, val loss ner = 0.087, val accuracy summary = 0.662, val accuracy ner = 0.965, r1 = 0.285, r2 = 0.084, rL = 0.178\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 12: 100%|██████████| 25/25 [00:03<00:00,  6.72batch/s, accuracy_ner=0.963, accuracy_sum=0.757, loss=0.318, loss_ner=0.086, loss_sum=0.55]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12 : val loss = 0.397, val loss summary = 0.712, val loss ner = 0.081, val accuracy summary = 0.664, val accuracy ner = 0.965, r1 = 0.288, r2 = 0.089, rL = 0.185\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 13: 100%|██████████| 25/25 [00:03<00:00,  7.15batch/s, accuracy_ner=0.965, accuracy_sum=0.757, loss=0.317, loss_ner=0.0812, loss_sum=0.553]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13 : val loss = 0.360, val loss summary = 0.646, val loss ner = 0.074, val accuracy summary = 0.662, val accuracy ner = 0.967, r1 = 0.283, r2 = 0.083, rL = 0.183\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 14: 100%|██████████| 25/25 [00:03<00:00,  6.96batch/s, accuracy_ner=0.967, accuracy_sum=0.756, loss=0.314, loss_ner=0.0791, loss_sum=0.549]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14 : val loss = 0.359, val loss summary = 0.645, val loss ner = 0.072, val accuracy summary = 0.664, val accuracy ner = 0.971, r1 = 0.276, r2 = 0.079, rL = 0.177\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 15: 100%|██████████| 25/25 [00:03<00:00,  6.81batch/s, accuracy_ner=0.97, accuracy_sum=0.77, loss=0.301, loss_ner=0.0715, loss_sum=0.531]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15 : val loss = 0.355, val loss summary = 0.643, val loss ner = 0.067, val accuracy summary = 0.665, val accuracy ner = 0.972, r1 = 0.275, r2 = 0.079, rL = 0.174\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 16: 100%|██████████| 25/25 [00:03<00:00,  7.69batch/s, accuracy_ner=0.971, accuracy_sum=0.771, loss=0.297, loss_ner=0.0651, loss_sum=0.529]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16 : val loss = 0.359, val loss summary = 0.646, val loss ner = 0.071, val accuracy summary = 0.669, val accuracy ner = 0.970, r1 = 0.276, r2 = 0.080, rL = 0.176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 17: 100%|██████████| 25/25 [00:03<00:00,  7.15batch/s, accuracy_ner=0.97, accuracy_sum=0.766, loss=0.302, loss_ner=0.0678, loss_sum=0.537] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17 : val loss = 0.358, val loss summary = 0.650, val loss ner = 0.067, val accuracy summary = 0.675, val accuracy ner = 0.972, r1 = 0.277, r2 = 0.079, rL = 0.176\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 18: 100%|██████████| 25/25 [00:03<00:00,  7.78batch/s, accuracy_ner=0.969, accuracy_sum=0.757, loss=0.312, loss_ner=0.0753, loss_sum=0.549]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18 : val loss = 0.363, val loss summary = 0.634, val loss ner = 0.091, val accuracy summary = 0.653, val accuracy ner = 0.961, r1 = 0.270, r2 = 0.074, rL = 0.171\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 19: 100%|██████████| 25/25 [00:03<00:00,  7.31batch/s, accuracy_ner=0.963, accuracy_sum=0.746, loss=0.327, loss_ner=0.0857, loss_sum=0.568]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19 : val loss = 0.375, val loss summary = 0.682, val loss ner = 0.067, val accuracy summary = 0.665, val accuracy ner = 0.971, r1 = 0.289, r2 = 0.082, rL = 0.183\n",
      "Training duration = 130.4546570777893\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "arr_train_loss = []\n",
    "arr_train_loss_sum = []\n",
    "arr_train_loss_ner = []\n",
    "arr_train_acc_sum = []\n",
    "arr_train_acc_ner = []\n",
    "arr_val_loss = []\n",
    "arr_val_acc_sum = []\n",
    "arr_val_acc_ner = []\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_loss_sum = 0\n",
    "  total_train_loss_ner = 0\n",
    "  total_train_acc_sum = 0\n",
    "  total_train_acc_ner = 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_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "      targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "      \n",
    "      y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "      loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "      loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "      \n",
    "      loss = loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "      \n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "      nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
    "      optimizer.step()\n",
    "      nb_batch_train += 1\n",
    "      total_train_loss += loss.item()\n",
    "      total_train_loss_sum += loss_sum.item()\n",
    "      total_train_loss_ner += loss_ner.item()\n",
    "\n",
    "      probs = y_sum_pred.tolist() # compute_probs(y_pred)\n",
    "      probs_tensor = y_sum_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "      total_train_acc_sum += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "      total_train_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "      tepoch.set_postfix(loss=total_train_loss/nb_batch_train, loss_sum=total_train_loss_sum/nb_batch_train, loss_ner=total_train_loss_ner/nb_batch_train, accuracy_sum=total_train_acc_sum/nb_batch_train, accuracy_ner=total_train_acc_ner/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_loss_sum = 0\n",
    "  total_val_loss_ner = 0\n",
    "  total_val_acc_sum = 0\n",
    "  total_val_acc_ner = 0\n",
    "  total_r1 = 0\n",
    "  total_r2 = 0\n",
    "  total_rl = 0\n",
    "\n",
    "  del loss\n",
    "  del loss_sum\n",
    "  del loss_ner\n",
    "  del y_sum_pred\n",
    "  del y_ner_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_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "    loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "    \n",
    "    loss = loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    nb_batch_val += 1\n",
    "    total_val_loss += loss.item()\n",
    "    total_val_loss_sum += loss_sum.item()\n",
    "    total_val_loss_ner += loss_ner.item()\n",
    "\n",
    "    doc = val_set[\"doc_splitted\"].iloc[i]\n",
    "    summaries = val_set[\"summaries\"].iloc[i]\n",
    "\n",
    "    indices = torch.argsort(y_sum_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for j in range(min(len(doc), y_sum_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",
    "    scores = scorer.score(summaries, txt)\n",
    "    total_r1 += scores[\"rouge1\"].recall\n",
    "    total_r2 += scores[\"rouge2\"].recall\n",
    "    total_rl += scores[\"rougeL\"].recall\n",
    "\n",
    "    probs = y_sum_pred.tolist() # compute_probs(y_pred)\n",
    "    probs_tensor = y_sum_pred #torch.tensor(probs, dtype=torch.float).to(device)\n",
    "\n",
    "    total_val_acc_sum += accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.cpu().detach().numpy(), doc_lens=doc_lens, average_number_of_sentences_per_document=average_number_of_sentences_per_document)\n",
    "    total_val_acc_ner += torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0]\n",
    "\n",
    "  print(\"Epoch {} : val loss = {:.3f}, val loss summary = {:.3f}, val loss ner = {:.3f}, val accuracy summary = {:.3f}, val accuracy ner = {:.3f}, r1 = {:.3f}, r2 = {:.3f}, rL = {:.3f}\".format(epoch, total_val_loss / nb_batch_val, total_val_loss_sum / nb_batch_val, total_val_loss_ner / nb_batch_val, total_val_acc_sum / nb_batch_val, total_val_acc_ner / nb_batch_val, total_r1 / nb_batch_val, total_r2 / nb_batch_val, total_rl / nb_batch_val))\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",
    "      break\n",
    "\n",
    "  del loss\n",
    "  del loss_sum\n",
    "  del loss_ner\n",
    "  del y_sum_pred\n",
    "  del y_ner_pred\n",
    "\n",
    "  if dev != \"cpu\":\n",
    "    torch.cuda.empty_cache()\n",
    "\n",
    "  arr_train_loss.append(total_train_loss / nb_batch_train)\n",
    "  \n",
    "  arr_train_acc_sum.append(total_train_acc_sum / nb_batch_train)\n",
    "  arr_train_acc_ner.append(total_train_acc_ner / nb_batch_train)\n",
    "\n",
    "  arr_val_loss.append(total_val_loss / nb_batch_val)\n",
    "  arr_val_acc_sum.append(total_val_acc_sum / nb_batch_val)\n",
    "  arr_val_acc_ner.append(total_val_acc_ner / nb_batch_val)\n",
    "\n",
    "t2 = time()\n",
    "print(\"Training duration =\", t2-t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_metrics = {}\n",
    "training_metrics[\"duration\"]   = t2 - t1\n",
    "training_metrics[\"train_loss\"] = arr_train_loss\n",
    "training_metrics[\"train_acc_sum\"]  = arr_train_acc_sum\n",
    "training_metrics[\"train_acc_ner\"]  = arr_train_acc_ner\n",
    "training_metrics[\"val_loss\"]   = arr_val_loss\n",
    "training_metrics[\"val_acc_sum\"]    = arr_val_acc_sum\n",
    "training_metrics[\"val_acc_ner\"]    = arr_val_acc_ner\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": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHHCAYAAABEEKc/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5KUlEQVR4nO3dd3gU5d7G8e/upocUQkhCIBB6h0CACKKCBEERwQYoiiCWo6JHEes5Vs4R+4sFxQ5WLAe7ohCKgqEFEERAWihCElo6qTvvH0MCCQQCZDOb5P5c116ZzM7M/mbZuLfPPPM8NsMwDERERESklN3qAkRERETcjQKSiIiISDkKSCIiIiLlKCCJiIiIlKOAJCIiIlKOApKIiIhIOQpIIiIiIuUoIImIiIiUo4AkIiIiUo4CkoiIiEg5CkgiUuvMmDEDm83GypUrrS5FRGooBSQRERGRchSQRERERMpRQBKROmn16tVcfPHFBAYGUq9ePQYMGMDSpUvLbFNYWMgTTzxB69at8fHxoUGDBvTt25e5c+eWbpOSksK4ceNo0qQJ3t7eNGrUiGHDhpGcnFzNZyQiVcnD6gJERKrb+vXrOe+88wgMDOT+++/H09OTN954g379+rFo0SLi4uIAePzxx5kyZQo33XQTvXr1IjMzk5UrV7Jq1SoGDhwIwJVXXsn69eu58847iY6OJi0tjblz57Jz506io6MtPEsRORs2wzAMq4sQEalKM2bMYNy4caxYsYIePXoc9/zll1/ODz/8wIYNG2jRogUAe/fupW3btnTr1o1FixYBEBMTQ5MmTfjuu+9O+Drp6enUr1+f5557jkmTJrnuhESk2ukSm4jUKcXFxfz8888MHz68NBwBNGrUiGuvvZbFixeTmZkJQHBwMOvXr2fz5s0nPJavry9eXl4sXLiQQ4cOVUv9IlI9FJBEpE7Zt28fubm5tG3b9rjn2rdvj9PpZNeuXQA8+eSTpKen06ZNGzp37sx9993H2rVrS7f39vbmmWee4ccffyQ8PJzzzz+fZ599lpSUlGo7HxFxDQUkEZEKnH/++WzdupV3332XTp068fbbb9O9e3fefvvt0m3uvvtu/vrrL6ZMmYKPjw+PPPII7du3Z/Xq1RZWLiJnSwFJROqUhg0b4ufnx6ZNm457buPGjdjtdqKiokrXhYSEMG7cOD755BN27dpFly5dePzxx8vs17JlS+69915+/vln/vjjDwoKCnjhhRdcfSoi4kIKSCJSpzgcDi666CK+/vrrMrfip6am8vHHH9O3b18CAwMBOHDgQJl969WrR6tWrcjPzwcgNzeXvLy8Mtu0bNmSgICA0m1EpGbSbf4iUmu9++67zJkz57j1jz/+OHPnzqVv377cfvvteHh48MYbb5Cfn8+zzz5bul2HDh3o168fsbGxhISEsHLlSr744gsmTJgAwF9//cWAAQMYMWIEHTp0wMPDgy+//JLU1FRGjRpVbecpIlVPt/mLSK1Tcpt/RXbt2sW+fft46KGHWLJkCU6nk7i4OP773//Su3fv0u3++9//8s033/DXX3+Rn59Ps2bNuP7667nvvvvw9PTkwIEDPPbYYyQkJLBr1y48PDxo164d9957L1dffXV1nKqIuIgCkoiIiEg56oMkIiIiUo4CkoiIiEg5CkgiIiIi5SggiYiIiJSjgCQiIiJSjgKSiIiISDkaKPIMOZ1O9uzZQ0BAADabzepyREREpBIMwyArK4vIyEjs9orbiRSQztCePXvKzNckIiIiNceuXbto0qRJhc8rIJ2hgIAAwHyDS+ZtEhEREfeWmZlJVFRU6fd4RRSQzlDJZbXAwEAFJBERkRrmVN1j1ElbREREpBwFJBEREZFyFJBEREREylEfJBdyOp0UFBRYXUaN5OnpicPhsLoMERGpoxSQXKSgoIDt27fjdDqtLqXGCg4OJiIiQuNMiYhItVNAcgHDMNi7dy8Oh4OoqKiTDkQlxzMMg9zcXNLS0gBo1KiRxRWJiEhdo4DkAkVFReTm5hIZGYmfn5/V5dRIvr6+AKSlpREWFqbLbSIiUq3UtOECxcXFAHh5eVlcSc1WEi4LCwstrkREROoaBSQXUt+Zs6P3T0RErKKAJCIiIlKOApK4RHR0NFOnTrW6DBERkTOiTtpSql+/fsTExFRJsFmxYgX+/v5nX5SIiIgFFJDcjNMwyCsoxtfL4XZ9cAzDoLi4GA+PU39sGjZsWA0ViYiIuIYusbkRwzDYuDeTLfuyyS+q3gEmx44dy6JFi3jppZew2WzYbDZmzJiBzWbjxx9/JDY2Fm9vbxYvXszWrVsZNmwY4eHh1KtXj549ezJv3rwyxyt/ic1ms/H2229z+eWX4+fnR+vWrfnmm2+q9RxFREQqSwGpGhiGQW5B0SkfhwuLcQJ5hcXsz86v1D6nehiGUakaX3rpJXr37s3NN9/M3r172bt3L1FRUQA8+OCDPP3002zYsIEuXbqQnZ3NJZdcQkJCAqtXr2bw4MEMHTqUnTt3nvQ1nnjiCUaMGMHatWu55JJLGD16NAcPHjzbt1dERKTK6RJbNThcWEyHR3+y5LX/fHIQfl6n/mcOCgrCy8sLPz8/IiIiANi4cSMATz75JAMHDizdNiQkhK5du5b+PnnyZL788ku++eYbJkyYUOFrjB07lmuuuQaAp556ipdffpnly5czePDgMzo3ERERV1ELkpxSjx49yvyenZ3NpEmTaN++PcHBwdSrV48NGzacsgWpS5cupcv+/v4EBgaWTiciIiLiTtSCVA18PR38+eSgSm1bVOxkY0oWAO0iAvBwnF2G9fU8+yk6yt+NNmnSJObOncvzzz9Pq1at8PX15aqrrqKgoOCkx/H09Czzu81m02S+IiLilhSQqoHNZqvUZa4SQb5e5BcVA6e339ny8vIqnSblZJYsWcLYsWO5/PLLAbNFKTk52cXViYiIVB9dYnNDfl5mq09uwanDSlWKjo5m2bJlJCcns3///gpbd1q3bs3s2bNZs2YNv//+O9dee61agkREpFZRQHJDRwNSUbW+7qRJk3A4HHTo0IGGDRtW2KfoxRdfpH79+vTp04ehQ4cyaNAgunfvXq21ioiIuJLNqOx94FJGZmYmQUFBZGRkEBgYWOa5vLw8tm/fTvPmzfHx8TntYx8uKGZzWhZ2m42OkYFuN2BkdTnb91FERKS8k31/H0stSG7Ix9OOw2YzR9Uu1KUrERGR6qaA5IZsNhu+Fl1mExEREQUkt1Vy91p1d9QWERERBSS35eetFiQRERGraBwkN+V3ZIDH/CInRcXOsx4wEgDDMB8c89PuAXW0E7iIiEhFFJDcTXYqFBfhgUFTRz5Op4Hz0CGw2wAnGBz5WS7oHPuzoudOxLc+1I+ujjMTERGpMRSQ3E3OASjOByAYwAacfAaPs3P4EPgEmUFJREREAAUk9+MXAs5isNk4XOgkI68IT4eDBvW8j1wKs1Xu53Hr7Mdvk5UC2SmQsRu8AsChj4OIiAgoILmfgIjSRVthMWmHs7AX26jvH4i9qvsKBYRDXjoU5UHm31C/WdUeX0REpIbSXWxuzNvDjsNeMmCkC273t9khuKm5fPgg5GWc1eGio6OZOnXq2dclIiJiMQUkN2az2Vw/HpKXP/iHmcvpu8zLeyIiInWcApKbOzpxrQuDS0AEOLzAWWheahMREanjFJDcXGlAynfhgJF2B29+kUBk94twZu+D/KzSp4YNG8aNN97I1q1bGTZsGOHh4dSrV4+ePXsyb94819UkIiJiIcsD0rRp04iOjsbHx4e4uDiWL19eqf1mzZqFzWZj+PDhZdaPHTsWm81W5jF48OAy2xw8eJDRo0cTGBhIcHAw48ePJzs7u6pO6XiGAQU5Z/TwIw9bYS6FedkUHs46/WMYFYx/VM7V117PgUOZLFiyAtJ3grOYgwcPMmfOHEaPHk12djaXXHIJCQkJrF69msGDBzN06FB27tzpuvdNRETEIpbexfbpp58yceJEpk+fTlxcHFOnTmXQoEFs2rSJsLCwCvdLTk5m0qRJnHfeeSd8fvDgwbz33nulv3t7e5d5fvTo0ezdu5e5c+dSWFjIuHHjuOWWW/j444+r5sTKK8yFpyLPaFcH0PlsXvvhPWY/o1OoX78+Fw8ezMdf/8yA8+IgK4Uvvvie0NBQ+vfvj91up2vXrqXbT548mS+//JJvvvmGCRMmnE2FIiIibsfSFqQXX3yRm2++mXHjxtGhQwemT5+On58f7777boX7FBcXM3r0aJ544glatGhxwm28vb2JiIgofdSvf3QQxA0bNjBnzhzefvtt4uLi6Nu3L6+88gqzZs1iz549VX6ONcno667jfz8kkJ9fADlpfPTh+4waNQq73U52djaTJk2iffv2BAcHU69ePTZs2KAWJBERqZUsa0EqKCggKSmJhx56qHSd3W4nPj6exMTECvd78sknCQsLY/z48fz6668n3GbhwoWEhYVRv359LrzwQv7zn//QoEEDABITEwkODqZHjx6l28fHx2O321m2bBmXX375CY+Zn59Pfn5+6e+ZmZmVP1lPP7Ml5wwdzCng7/TD+Ht50KLhqVuDjnvtSho6dCiGAd//uoae7Zvy6+Lf+L//mwrApEmTmDt3Ls8//zytWrXC19eXq666ioICVw7zLSIiYg3LAtL+/fspLi4mPDy8zPrw8HA2btx4wn0WL17MO++8w5o1ayo87uDBg7niiito3rw5W7du5eGHH+biiy8mMTERh8NBSkrKcZfvPDw8CAkJISUlpcLjTpkyhSeeeKLyJ3gsm61Sl7kq4mfzwcixkYMNp6df1Q8YeYSPjw9XXHEFH331E1s2N6Nty2Z0b90YgCVLljB27NjSAJmdnU1ycrJL6hAREbFajRlJOysri+uvv5633nqL0NDQCrcbNWpU6XLnzp3p0qULLVu2ZOHChQwYMOCMX/+hhx5i4sSJpb9nZmYSFRV1xsc7HSUDRhY7zQEjS8ZGcoXRo0dz6aWXsn59U667/BJz8lzfIFq3bs3s2bMZOnQoNpuNRx55BKfT6bI6RERErGRZQAoNDcXhcJCamlpmfWpqKhEREcdtv3XrVpKTkxk6dGjpupIvaA8PDzZt2kTLli2P269FixaEhoayZcsWBgwYQEREBGlpaWW2KSoq4uDBgyd83RLe3t7HdfauLjabDX8vDzLzCsnNd21AuvDCCwkJCWHTX5u5dtSbgAHpO3nxhRe4cfx4+vTpQ2hoKA888MDpXWYUERGpQSwLSF5eXsTGxpKQkFB6q77T6SQhIeGEd0W1a9eOdevWlVn373//m6ysLF566aUKW3N2797NgQMHaNSoEQC9e/cmPT2dpKQkYmNjAZg/fz5Op5O4uLgqPMOq5eflIDOvkJyCIkJxXVCz2+1HO6sXF0LaBig8THRoMPPnzy+z7R133FHmd11yExGR2sLSS2wTJ07khhtuoEePHvTq1YupU6eSk5PDuHHjABgzZgyNGzdmypQp+Pj40KlTpzL7BwcHA5Suz87O5oknnuDKK68kIiKCrVu3cv/999OqVSsGDRoEQPv27Rk8eDA333wz06dPp7CwkAkTJjBq1CgiI8/sVvzqUC0japfn8ISgxua4SFkp4BMMnj7V9/oiIiIWsTQgjRw5kn379vHoo4+SkpJCTEwMc+bMKe24vXPnTuz2yo9E4HA4WLt2LTNnziQ9PZ3IyEguuugiJk+eXOby2EcffcSECRMYMGAAdrudK6+8kpdffrnKz68q+Xp5YAMKi50UFDnx8qimERp8Q+DwIXN07fSdENra7HQuIiJSi9kMo5JDLUsZmZmZBAUFkZGRQWBgYJnn8vLy2L59O82bN8fHp+paXDanZnG4sJimIX4E+3lV2XFPqagA9m0AwwmBTaBew2p5WVe9jyIiUned7Pv7WJZPNSKVZ8llNgAPLwg8cvkxaw8U5Z98exERkRpOAcmFqrpxzs/bvCJa7QEJwC8UvOqZrUjpuyo9x9vZUOOmiIhYRQHJBRwOs6WnqkeZLmlBOlxYjNNZzeHBZoPgKMAGBVmQe9DlL5mbmwuAp6eny19LRETkWDVmoMiaxMPDAz8/P/bt24enp+dpdTQ/GcMwsDuLKHY6Sc/Ocel4SBXyDoWcNDiwG/AER9X3hTIMg9zcXNLS0ggODi4NnCIiItVFAckFbDYbjRo1Yvv27ezYsaNKj52enc/hQif5hzwJ8LHgn88wIDsTivMhLQP8XddhOzg4+KSDd4qIiLiKApKLeHl50bp16yq/zLZ0+U7e/nUb57VuyOOXta7SY1fafid8ej0YhXDRf6HNoCp/CU9PT7UciYiIZRSQXMhut1f57ekdmjTg76zNLNhyiCne3tisGJOoSSeIHQkLp8Cce6DlcvCveH48ERGRmkadtGuYLk2C8bDbSM3M5+/0w9YV0ncihHWE3APw4wPW1SEiIuICCkg1jK+Xgw6R5sBWq3amW1eIhxcMewVsdvjjC9j0o3W1iIiIVDEFpBqoe9P6AKzaccjaQhrHQu8jEwt/dw8cTre0HBERkaqigFQDdWsaDMCqnRYHJID+D0NIS8jaC3MfsboaERGRKqGAVAOVtCD9uSeTvEILRtU+lqcvDHvVXF71PmxdYG09IiIiVUABqQZqUt+XsABvipwGa3dnWF0ONOsDPW82l7+9C/Kzra1HRETkLCkg1UA2m+1oPyR3uMwGEP8YBEVB+k6YP9nqakRERM6KAlIN1b1ZMABJVnfULuEdAENfMpeXvQE7l1pbj4iIyFlQQKqhSlqQVu885D6z3rcaADGjAQO+ngCFeVZXJCIickYUkGqoTo2D8HTY2J9dwK6DFg4YWd6g/0K9cDiwGRY9Y3U1IiIiZ0QBqYby8XTQMTIIcKN+SAC+9WHIC+bykpdgzxpLyxERETkTCkg1WMllNrfph1Si/VDoMByMYvhmAhQXWl2RiIjIaVFAqsFim7nZnWzHuuQ5szUpZR0smWp1NSIiIqdFAakGK7mTbWNKFrkFRdYWU169MLj4WXN50bOQttHaekRERE6DAlIN1ijIl0ZBPhQ7DX7f5QYDRpbX+WpoPQiKC+DrO8Bp8ajfIiIilaSAVMO53YCRx7LZ4NL/A+9A+HslrP/S6opEREQqRQGphute0g/J3TpqlwhqDL3vMJeXTbe2FhERkUpSQKrhujcNBswWJLcZMLK8HjeC3RN2r4DdSVZXIyIickoKSDVcx8ggvDzsHMotZPv+HKvLObF6YdDpSnN5+RvW1iIiIlIJCkg1nJeHnc6NSwaMTLe2mJOJu8X8+cdsyEq1thYREZFTUECqBdx6PKQSjWOhSS9wFkLSe1ZXIyIiclIKSLVAaT8kd+2oXSLuVvPninegqMDaWkRERE5CAakWKLnVf1NqFll5bjytR4dhENAIctLgz6+srkZERKRCCki1QFigD03q+2IYuOeAkSUcntBjvLmsW/5FRMSNKSDVEm49YOSxYseCwwv+ToLdK62uRkRE5IQUkGqJY8dDcmv1GkKnq8xltSKJiIibUkCqJY4dUdvpdNMBI0uU3PK//kvI3GttLSIiIieggFRLtG8UiI+nncy8Irbtz7a6nJOL7AZR54CzSLf8i4iIW1JAqiU8HXa6NAkGYNWOdEtrqZSSW/5XvgtF+dbWIiIiUo4CUi1S0lE7yd3HQwJoPxQCIiFnn3mpTURExI0oINUiNWJE7RIOT+h55Jb/pa+Du060KyIidZICUi3S7cidbJvTssk47MYDRpaIHQcOb9i7BnavsLoaERGRUgpItUhoPW+aNfADYM2udGuLqQz/BtDlanNZt/yLiIgbsTwgTZs2jejoaHx8fIiLi2P58uWV2m/WrFnYbDaGDx9euq6wsJAHHniAzp074+/vT2RkJGPGjGHPnj1l9o2OjsZms5V5PP3001V5WpapUf2QAHod6az959eQuefk24qIiFQTSwPSp59+ysSJE3nsscdYtWoVXbt2ZdCgQaSlpZ10v+TkZCZNmsR5551XZn1ubi6rVq3ikUceYdWqVcyePZtNmzZx2WWXHXeMJ598kr1795Y+7rzzzio9N6uUjIe0uib0QwJo1AWanWve8r/iHaurERERASwOSC+++CI333wz48aNo0OHDkyfPh0/Pz/efffdCvcpLi5m9OjRPPHEE7Ro0aLMc0FBQcydO5cRI0bQtm1bzjnnHF599VWSkpLYuXNnmW0DAgKIiIgoffj7+7vkHKtbyYjaa3amu/+AkSVKbvlPeg8K86ytRUREBAsDUkFBAUlJScTHxx8txm4nPj6exMTECvd78sknCQsLY/z48ZV6nYyMDGw2G8HBwWXWP/300zRo0IBu3brx3HPPUVRUdNLj5Ofnk5mZWebhjtqGB+Dn5SArv4jNaW4+YGSJtkMgsAnkHoA//md1NSIiItYFpP3791NcXEx4eHiZ9eHh4aSkpJxwn8WLF/POO+/w1ltvVeo18vLyeOCBB7jmmmsIDAwsXX/XXXcxa9YsFixYwK233spTTz3F/ffff9JjTZkyhaCgoNJHVFRUpWqobh4OO12PDBhZY/ohOTyg103m8rLpuuVfREQsZ3kn7crKysri+uuv56233iI0NPSU2xcWFjJixAgMw+D1118v89zEiRPp168fXbp04R//+AcvvPACr7zyCvn5FY/o/NBDD5GRkVH62LVr11mfk6vUqPGQSnS/ATx8IGUt7FxqdTUiIlLHeVj1wqGhoTgcDlJTU8usT01NJSIi4rjtt27dSnJyMkOHDi1d53Q6AfDw8GDTpk20bNkSOBqOduzYwfz588u0Hp1IXFwcRUVFJCcn07Zt2xNu4+3tjbe392mdo1W6NwsGalhA8guBLiNg1ftmK1Kz3lZXJCIidZhlLUheXl7ExsaSkJBQus7pdJKQkEDv3sd/ObZr145169axZs2a0sdll11G//79WbNmTeklr5JwtHnzZubNm0eDBg1OWcuaNWuw2+2EhYVV3QlaqFuU2YK0bV8Oh3IKLK7mNJTc8r/hW8jYbW0tIiJSp1nWggTmpa4bbriBHj160KtXL6ZOnUpOTg7jxo0DYMyYMTRu3JgpU6bg4+NDp06dyuxf0vG6ZH1hYSFXXXUVq1at4rvvvqO4uLi0P1NISAheXl4kJiaybNky+vfvT0BAAImJidxzzz1cd9111K9fv/pO3oXq+3vRoqE/2/blsHrXIS5sF37qndxBRCeIPg+SfzVv+Y9/zOqKRESkjrI0II0cOZJ9+/bx6KOPkpKSQkxMDHPmzCntuL1z507s9so3cv3999988803AMTExJR5bsGCBfTr1w9vb29mzZrF448/Tn5+Ps2bN+eee+5h4sSJVXZe7qB70/ps25fDqh3pNScggXnLf/KvkDQDLrgfPH2trkhEROogm2HolqEzkZmZSVBQEBkZGafs42SFj5ft5OEv19GnZQM+vvkcq8upvOIieLkbZOyEy16F7tdbXZGIiNQilf3+rjF3scnpKemovWZXOkXFTmuLOR1lbvl/Q7f8i4iIJRSQaqnWYQEEeHuQW1DMptQsq8s5Pd2uBw9fSF0HO36zuhoREamDFJBqKYfdRsyRaUdW7Uy3tJbT5hcCXUeay8umW1uLiIjUSQpItVi3pkcmrq0pI2ofq+SW/43fQbr7DsopIiK1kwJSLVYycW1STRowskR4B2h+PhhOWPG21dWIiEgdo4BUi5W0IO04kMv+7IqnUXFbcf8wf66aCQW51tYiIiJ1igJSLRbk60nrsHoArK5p/ZAA2gyG4GZw+BCs+9zqakREpA5RQKrluh9pRUqqif2Q7A7odYu5rFv+RUSkGikg1XKxzcyAVKMmrj1Wt+vA0w/S1kPyYqurERGROkIBqZYrGTBy7e50CmvSgJElfIOh6zXmsm75FxGRaqKAVMu1CK1HoI8HeYVONu6tYQNGlii5zLbpBziUbGkpIiJSNygg1XJ2u630brakHQctruYMhbWDFv11y7+IiFQbBaQ64Gg/pHRrCzkbpbf8vw8FOdbWIiIitZ4CUh1Qcidbje2oDdD6IqjfHPIyYO2nVlcjIiK1nAJSHdA1KgibDXYfOkxaZp7V5ZwZu123/IuISLVRQKoDAnw8aRseANTwVqRuo8HTH/ZthO2LrK5GRERqMQWkOqJ7beiH5BMEMdeay8vesLYWERGp1RSQ6ojSfkg1cUTtY5Xe8v8jHNxubS0iIlJrKSDVEd2bBgOw9u8MCopq4ICRJRq2gZYDAEO3/IuIiMsoINURzUP9qe/nSUGRk/V7Mqwu5+yU3vL/AeRnW1uLiIjUSgpIdYTNZjvmdv90a4s5W63iIaQF5GfA2llWVyMiIrWQAlId0r2mT1xbwm6HXreay7rlX0REXEABqQ7pdqQfUo3vqA3m3Wxe9WD/X7BtgdXViIhILaOAVId0bRKMw25jb0YeezMOW13O2fEJhJjR5rJu+RcRkSqmgFSH+Ht70C7iyICRO9KtLaYqlNzy/9dPcGCrtbWIiEitooBUx9SKedlKhLaCVgPRLf8iIlLVFJDqmNgjHbWTakM/JDh6y//qDyE/y9paRESk1lBAqmNKWpDW78kgr7DY4mqqQMsLoUFryM+E33XLv4iIVA0FpDomKsSX0HpeFBYbNX/ASDBv+Y8rueV/Ojhr8CjhFUldDzn7ra5CRKROUUCqY2w2G91K52VLt7aYqtJ1FHgHwoEtsHW+1dVUrdUfwet9YOZlGu9JRKQaKSDVQbWuH5J3AHS7zlxeNt3aWqrSlnnw7V3mctp62LbQ0nJEROoSBaQ66Ng72Yza0irR8ybABlvmwv4tVldz9vashk/HgLMIfILNdbpTT0Sk2igg1UFdmgThYbeRlpXP3+k1fMDIEg1aQptB5vJvL1tby9k6lAwfjYDCHGh+Adzwrbl+0w+QsdvS0kRE6goFpDrIx9NBx8hAoBZdZgM453bz56qZ8Mvz1tZypnIOwIdXQk4ahHeCkR9Aoy4QfR4YTkiaYXWFIiJ1ggJSHVXSUXv1znRrC6lKLS6AC/9tLs+fDIues7ae01WQC5+MMjubB0XB6C/AJ8h8rudN5s+kmVBUYF2NIiJ1hAJSHdUj2gxIc/9MpaCoFt0af/59cOEj5vKC/8DCZ6ytp7KcxfC/m2D3cjMUjf4CAhsdfb7dEAhoZLYsbfjGujpFROoIBaQ6Kr59OGEB3vydfpjPk3ZZXU7VOn8SDHjMXF74FCyYYm09p2IY8MN9sOl7cHjDNbMgrF3ZbRyeEDvWXFZnbRERl1NAqqN8PB3c1q8lANPmb6ldrUgA502E+CfM5UVPw4Kn3HccocUvwsp3ABtc8SY063Pi7brfAHYP2JkIKX9Ua4kiInWNAlIddk2vpoQFeLMnI4/PVtayViSAvnfDwMnm8qJn3DMk/T4LEp40lwc/DR2HV7xtYCNod6m5rFYkERGXUkCqw3w8Hdxe0oq0YAv5RbVgbrbyzr0LLvqvufzLszD/P+4TkrbOh6/vMJf73Ann/OPU+/S62fy59jPIqwVTxYiIuCnLA9K0adOIjo7Gx8eHuLg4li9fXqn9Zs2ahc1mY/jw4WXWG4bBo48+SqNGjfD19SU+Pp7NmzeX2ebgwYOMHj2awMBAgoODGT9+PNnZ2VV1SjXKqF5NiQj0YW9GHp+tqIWtSAB9JsCgp8zlX583W2ysDkl7f4dPrzcHgux0JcQ/Wbn9mp0LDdubYyRpcl4REZexNCB9+umnTJw4kccee4xVq1bRtWtXBg0aRFpa2kn3S05OZtKkSZx33nnHPffss8/y8ssvM336dJYtW4a/vz+DBg0iLy+vdJvRo0ezfv165s6dy3fffccvv/zCLbfcUuXnVxP4eDq4vX9JK9JW8gprYSsSQO87zEtYYPb5mfe4dSHp0A746GooyDbHNxr+ujnpbmXYbNBzvLm84m3rg56ISC1laUB68cUXufnmmxk3bhwdOnRg+vTp+Pn58e6771a4T3FxMaNHj+aJJ56gRYsWZZ4zDIOpU6fy73//m2HDhtGlSxfef/999uzZw1dffQXAhg0bmDNnDm+//TZxcXH07duXV155hVmzZrFnzx5Xnq7bGtkzikZBPqRk1tK+SCXOuQ0uftZcXjIV5j1W/QEj9yB8dBVkp0JYRxj1EXh4n94xuowEr3qw/y/Y/otr6hQRqeMsC0gFBQUkJSURHx9/tBi7nfj4eBITEyvc78knnyQsLIzx48cf99z27dtJSUkpc8ygoCDi4uJKj5mYmEhwcDA9evQo3SY+Ph673c6yZcsqfN38/HwyMzPLPGoLbw8Ht/dvBZh9kWptKxJA3K1wyZFRtpe8BHMfqb6QVHgYPrnGDDaBjWH050cHgjwdPoHQdZS5vOKtqq1RREQACwPS/v37KS4uJjw8vMz68PBwUlJSTrjP4sWLeeedd3jrrRN/KZTsd7JjpqSkEBYWVuZ5Dw8PQkJCKnxdgClTphAUFFT6iIqKOvkJ1jAjejQhMsiH1Mx8Zi3faXU5rtXr5qMh6bdX4Od/uz4klQwEuWspeAfBdf+DoMZnfrySkbU3/gAZf1dNjSIiUsryTtqVlZWVxfXXX89bb71FaGhotb/+Qw89REZGRulj167adSnq2Fak1xbW4r5IJXrdDENeNJcTX4WfHnZdSDIMmPMgbPwOHF5wzccQ1v7sjhnWHpr1BaNY87OJiLiAZQEpNDQUh8NBampqmfWpqalEREQct/3WrVtJTk5m6NCheHh44OHhwfvvv88333yDh4cHW7duLd3vZMeMiIg4rhN4UVERBw8ePOHrlvD29iYwMLDMo7YZ0SOKxsG+pGXl8/GyWt6KBGZn50v/z1xe+hrMecg1IWnJS7D8TXP58jcgum/VHLdXyfxsMzQ/m4hIFbMsIHl5eREbG0tCQkLpOqfTSUJCAr179z5u+3bt2rFu3TrWrFlT+rjsssvo378/a9asISoqiubNmxMREVHmmJmZmSxbtqz0mL179yY9PZ2kpKTSbebPn4/T6SQuLs6FZ+z+vDzs3HGkFen1RXWgFQmgx40w9CVzednr8OMDVRuS1n5mdgYHc6iBTldU3bHbXQr1Isz52TZ+W3XHrU1S/4S5j8LhQ1ZXIiI1jKWX2CZOnMhbb73FzJkz2bBhA7fddhs5OTmMGzcOgDFjxvDQQw8B4OPjQ6dOnco8goODCQgIoFOnTnh5eWGz2bj77rv5z3/+wzfffMO6desYM2YMkZGRpeMltW/fnsGDB3PzzTezfPlylixZwoQJExg1ahSRkZFWvRVu46rYJjQO9mVfVj4f1YVWJDDnOLvsFcAGy98w50WripC0bSF8dbu5fM4d5lADVenY+dmWa2Tt4+QcgA+vNFvw5j1udTUiUsNYGpBGjhzJ888/z6OPPkpMTAxr1qxhzpw5pZ2sd+7cyd69e0/rmPfffz933nknt9xyCz179iQ7O5s5c+bg4+NTus1HH31Eu3btGDBgAJdccgl9+/blzTffrNJzq6m8POzceeGRVqSFWzlcUAdakQC6jzkakla8Bd/fC86zmJ8uZR3Mug6chdDxcrjoP1VWahmxN4DNATt/g9T1rnmNmsgw4KvbIOvI0B2rPzTHn5LTs2sF7FljdRUilrAZhkaaOxOZmZkEBQWRkZFR6/ojFRY76f/8QnYfOsy/h7TnpvNanHqn2mL1R0em/zDMy2+XvFD5QRxLpO+CdwZC1l6zI/X1s09/rKPT8dkY+PNrs96SPlV13W+vws//Aoc3hLaB1HXHhGCplIPb4dUe5ns4cT341re6IpEqUdnv7xpzF5tUH0/H0Vak6Yu2kltQZHFF1ajbaBj+GmCDle/C9/ecXktS7kHzsk7WXnNKkDMZCPJ0ldzy//unkFd7xuc6Y7uTjvb7GjwFhrxgLq/5GA4lW1ZWjbPyXXMqnMIc+PMbq6sRqXYKSHJCV3RvQtMQP/ZnF/Dh0jp2aSLmWrh8OmAz7xD77u7KhaTCPJg1GvZvgoBIuO4L8A12ba1gTlfSsJ3mZwM4nA5fjDW/2DsMN1vVmsZBywHmul+es7jAGqLwMKz+4Ojv6z63rhYRiyggyQl5OuxMONKK9MaibXWrFQnMkaovfwNsdlg1E7696+QhyemEL28x+wJ5B5rhKKhJ9dRqsx1tRarL87MZhvnvlL4TgpvBZS+b7w1A/4fNn2s+gYPbrKuxplj/lXnnn39D8/fkXyFjt6UliVQ3BSSp0BXdGtOsgR8Hcgr4ILGOtSIBdB0Jl79phqTVH8A3d544JBkG/PSQ2Q/I4WVeVgvvWL21ls7Ptsn8MquLVr5j/hvYPeHq98pO49KkB7QaaA6suUitSKe04shdkefcBs3ONZfXfWFdPSIWUECSCnk47Nx5YWsA3vhlGzn5dawVCaDL1XDFW2ZIWvMhfDPBnDbkWL+9Asumm8vDX4fm51d/nT6BZkgCWF4H52dLWQdzjrQSxT8OjWOP36afOWQIa2fBga3VVlqNs2c1/L3SDJrdxkCXEeb6tZ9ZW5dINVNAkpMaHhNJdAM/DuYU8H5dbEUC6HwVXPm2eTv9miN3uZWEpHVfmBPeAgycbG5rldL52b6HzD3W1VHd8rPh87FQnA9tBlc83lSTWGg9CAwnLHq2WkusUUpajzoOh3oNocMws2U0bT2k/GFpaSLVSQFJTurYVqQ3f9lKdl1sRQLodOXRkPT7J+YAkFsXwJf/MJ+Puw363GltjeEdzMshdW1+th8mwYEtENjYbMEr6Xd0Iv0eNH+u+wz2b66e+mqSw4eOXkrrebP507c+tL7IXF6nViSpOxSQ5JSGxUTSPNSfQ7mFvJ+YbHU51ul0BVz1rhmS1s6CDy43B4LsMMycRuRkX8zVped482fSDCgutLSUarHmYzOw2uxmgPULOfn2jbtD20vUilSRNR9DUR6Ed4aoXkfXl1xmW/fF2Q2gKlKDKCDJKXk47Nw1wLyj7c1fttXdViQwLztc/R7YPQADmvYxO3Kf7mCSrtJuKNQLh+xU2FDL52fbt8kc8RzMu9Sa9ancfiWtSH98YR5DTE4nrHjHXO45vmzgbz0IvIMg82/YscSa+kSqmZv8V13c3WVdG9Mi1J/03EJm/pZsdTnW6jAMrpsNfe+Baz4GT59T71NdPLyOzs9W8mVXGxUehs/HQWEuNL8A+k6s/L6NupoT/RpOWPSM62qsabYtgINbzWEqOl9d9jlPH+hwmbm89tPqr03EAgpIUikOu427BpT0RdpGVl4duHxzMi0uMO+WcsfpF2LHmpcBdyw2Z7OvjeY8ZHYa9m9o3mVod5ze/qWtSLMhbUPV11cTlQTqrteAd73jny+5S/LPb8xBUUVqOQUkqbShXSNp2dCfjMOFzFiSbHU5UpHASGg3xFxeWQtbkf6YDUnvATa44k0ICD/9Y0R0hvZDAUOtSGDOH/jXj+Zyyd2Q5TU71+wIn58Bm3+qvtpELKKAJJV2bCvS24u3k1nXW5HcWen8bLNq1/xsB7fDt/80l8+bCC0vPPNjXXCkFWn9V7W3pa2ykmaYlxybnw8N25x4G7v96DAWGhNJ6gAFJDktl3aJpFVYPbUiubvm55uz2Bdk154+I0UF8MU4yM+EqHOg38Nnd7yITuZ8bRiw6OmqqLBmKiowp9OBiluPSpRcZtv8szkkgEgtpoAkp8Vht/HPklakX7eRcVitSG6pNs7PNu9xc5Rn3/pw1Tvg8Dj7Y/Z7ELCZU5SkrDv749VEG76BnH0Q0MgcAuFkwjtCWEcoLjDfM5FaTAFJTtuQzo1oHVaPzLwi3luy3epypCJdR4GnP+zbCMmLra7m7Gz6EZZOM5eHv151EwGHtYeOl5vLC+toK1LJyNmxY8HheertNfWI1BEKSHLa7HYb/4w3W5HeWbxdrUjuyifo6JdZyZdgTZSxG766zVw+53Zoe3HVHv+CBwAbbPwO9q6t2mO7u5Q/YGeiOa5X9xsqt0/nqwCbOR5S+i6XlidiJQUkOSOXdGpE2/AAsvKKeGexWpHcVq8j00Vs/A4y91pby5koLoIvxpv9XSK7QfwTVf8aYe3MqWSg7rUildzl2O5SCGxUuX2CmkB0X3N53eeuqUvEDSggyRk5thXpvcXbychVK5JbCu9ojvbtLDraEbcmWTgFdi01By+86l1zIExXuOABc7qSTd/DnjWueQ13k5cJvx/pwH+qztnllQwkufaz2tG/TeQEFJDkjA3uGEG7iACy8ot4Z/E2q8uRipTMz7byvZo1P9vWBfDrC+by0JcgpIXrXqthm6Nf+nWlFen3WVCYA6Ftj7YIVVaHYeDwgn0bIPUP19QnYjEFJDljdruNu4+0Ir27JJn03AKLK5ITan8Z+IdBdgps/N7qaionKxVm3wIYEDvOnCjY1c6/32xF+utH+DvJ9a9nJcM42i+t502nP9GybzC0GWQuq7O21FIKSHJWLupgtiJl5xfx9q/qi+SWPLwg9kgH3JrQWdtZDLNvhpw085bywVOq53VDWx0d56e2tyIlL4b9m8y7HLuOPLNjlLxX674w/81EahkFJDkrZiuSOfLue0u2cyhHrUhuKXacOT9b8q+QttHqak5u8YuwfRF4+sHV74Gnb/W99vn3me/T5p9h98rqe93qVhKUu44073Y8E60vMvfN2mPe0SZSyyggyVkb1DGcDo0CySko5m31RXJPQY2P3h7vzq1IO36DBU+Zy5c8Dw3bVu/rN2hpjh8FZgfx2ihzr3lXI0CP8Wd+HA/vIyORU3tGaxc5xhkFpJkzZ/L990f7Mtx///0EBwfTp08fduzYUWXFSc1gsx3tizRjSTIH1Yrknkpu+f99FuRnWVvLieQehP/dZM4J1mUUxFxrTR3nTzJbkbbMg13LranBlVbNNO9qbNrbnG7lbJRcZvvzGyjMO/vaRNzIGQWkp556Cl9fs9k7MTGRadOm8eyzzxIaGso999xTpQVKzTCwQzgdI81WpLd+VSuSW2p+ATRoDQVZ7vd//IZhDgaZ+Tc0aAVDXjj9jsNVJaQFxFxjLpe0ZtUWxYXmxLRw+rf2n0jT3hDYxJwf7685Z388ETdyRgFp165dtGrVCoCvvvqKK6+8kltuuYUpU6bw66+/VmmBUjOYrUhmX6SZvyVzIDvf4orkOMfOz7bczeZnW/qa+QXr8IarZ4B3PWvrOf8+c3TpbQtg51Jra6lKm36ArL3g3xDaDz3749nt0OWYMZFEapEzCkj16tXjwIEDAPz8888MHDgQAB8fHw4fPlx11UmNEt8+jM6Ng8gtKOZNtSK5p5hrzM7P+zaY/X3cwd9JMPcxc3nwUxDR2dp6AOpHQ8xoc7k2tSKV9D/rfoPZh6gqdD4ync3mn83LpCK1xBkFpIEDB3LTTTdx00038ddff3HJJeYM0OvXryc6Oroq65Ma5Ni+SO//tkOtSO6ozPxsb1lbC0BeBnw+DpyF5nhNZ9NpuKqdPwnsnuYdde4SJs/Gvk2w/RdzrKfYsVV33PAOEN7Z/Df886uqO66Ixc4oIE2bNo3evXuzb98+/ve//9GgQQMAkpKSuOaaa6q0QKlZLmwXRtcmQRwuLObNX9SK5JZKLrNt+BayUqyrwzDgm7sgfQcEN4XLXrGu39GJBDeFbteZy7WhFWnFkXnX2lwMwVFVe+zSy2yam01qD5thuFNHhJojMzOToKAgMjIyCAwMtLoct7JgYxrjZqzA19PBrw/0J7ReFTXlS9V5Z5A5x1m/h6HfA9bUsPJd+O4es6/PjT9Dk1hr6jiZ9F3wcjezdeSG76D5eVZXdGbys+HF9mZn6utmQ6sBVXv8jL/h/zoCBty9zgyXIm6qst/fZ9SCNGfOHBYvXlz6+7Rp04iJieHaa6/l0KFDZ3JIqUX6tW1I16hgDhcW88airVaXIydScst/kkXzs6X8AT8+aC7HP+6e4QjMlpbuY8zlhVPcq2P76Vj3uRmOQlpAi/5Vf/ygxkfnc1unViSpHc4oIN13331kZmYCsG7dOu69914uueQStm/fzsSJE6u0QKl5ju2L9MHSHaRlaXwUt9N+qHknU9Ze886m6pJ70LzNfNa1UJwPrQfBOXdU3+ufifPuNSdm3bHE7MNT05Sfd83uovGBS8ZEWvtZzQ2SIsc4o7+U7du306FDBwD+97//cemll/LUU08xbdo0fvzxxyotUGqmfm0aEhMVTF6hkzcWqS+S2/HwNu9kAtePrJ2fbfZN+XgkPN8Gvv2n2e8osDEMf911X9hVJajx0U7NNbEVaddySP0DPHxdO/hmh8vMYRr2bYSUda57HZFqckb/ZfLy8iI3NxeAefPmcdFFFwEQEhJS2rIkdZvNZuOegea4SB+qFck9xY4172ja/ot5h1NVKsqHjd+bd6g93xpm32SOc+QshPBOMOAxuGUh+Deo2td1lb4TzS//nYmwbaHV1ZyekgDc+Urwre+61/EJgraDzWV3G4hU5AycUUDq27cvEydOZPLkySxfvpwhQ4YA8Ndff9GkSZMqLVBqrvNbh9K9aTD5RU6mL1QrktsJjoK25hAdVdKK5CyGrQvg6zvMUDTrWlg/GwpzoX5zc/DF25fBbUvgvIlQL+zsX7O6BDaCHuPM5ZrUipS97+it91UxcvaplFxm++N/5udBpAY7o4D06quv4uHhwRdffMHrr79O48aNAfjxxx8ZPHhwlRYoNdexrUgfLdvB12v+pthZQ75Y6oqSL801n5iXwk6XYZiXcH64H15oBx8Mh9UfmuMbBTQy+xfdPB/uWg0X/hvC2lVp+dWq7z3g4QO7lsHW+VZXUzmr34fiAmgcC5HdXP96rQaCT7DZty1ZsypIzabb/M+QbvOvHMMwGP32Mn7bao683qKhP3de2IqhXSLxcLh535O6wOmEaT3hwBYY8iL0rMRAjYYBqevhjy/MloL0nUef860PHYZBp6ugWR+wO1xXuxXmPGROi9K4B9w0z73GbSrPWQwvdYWMXTB8+tH55Vzt27vNuyNjroPh06rnNUVOQ2W/v884IBUXF/PVV1+xYcMGADp27Mhll12Gw1HL/oNYAQWkysvJL+K9Jdt5e/F20nPNW8qbh/ozoX8rhsUoKFlu6esw50EI62he/qroS//gNlj3PzMY7dt4dL2nP7QbAp2vMm8h9/CqnrqtkJVqho6iwzD6C2g90OqKKrbpR/hklBlaJ24ET5/qed0dv8F7F4NXANy3GTx9q+d1RSrJpeMgbdmyhfbt2zNmzBhmz57N7Nmzue666+jYsSNbt57euDfTpk0jOjoaHx8f4uLiWL58eYXbzp49mx49ehAcHIy/vz8xMTF88MEHZbax2WwnfDz33HOl20RHRx/3/NNPP316b4JUmr+3BxMubM3iBy7k/sFtqe/nyfb9Odz7+e8MeHERn63cRWGx0+oy666uR+ZnS1tvdkI+VuZeSJwGb/Y3B0xc8B8zHDm8oN2lcNV7cN8WuPItaDOodocjgIDwo61sC55y775IJf3Kul1ffeEIIOocCGoKBVlmSBOpoc6oBemSSy7BMAw++ugjQkJCADhw4ADXXXcddrud77//vlLH+fTTTxkzZgzTp08nLi6OqVOn8vnnn7Np0ybCwo7vwLlw4UIOHTpEu3bt8PLy4rvvvuPee+/l+++/Z9CgQQCkpJSdOuHHH39k/PjxbNmyhRYtWgBmQBo/fjw333xz6XYBAQH4+/tX+j1QC9KZy8kv4oOlO3jrl20cyCkAICrElwn9W3FF9yZ4qkWp+n1zF6yaCZ2uhEuehz+/Ni+fJS8GjvwnwmaH5heYLUXtLgXfYCsrtk72Pnipi9n5/NrPzGDobg5shVe6Aza4a5U5QGR1mvcELH7RvAngmk+q97VFTsGll9j8/f1ZunQpnTuXnXX7999/59xzzyU7u3KdPePi4ujZsyevvvoqAE6nk6ioKO68804efPDBSh2je/fuDBkyhMmTJ5/w+eHDh5OVlUVCQkLpuujoaO6++27uvvvuSr3GiSggnb3cgiI+WrqTN37Zyv5sMyg1Dvbljv6tuCq2CV4eCkrVZu9aeOM8MwTZ7OAsOvpcVJzZp6jj8Jp155kr/fwI/PYyNIoxhytwt75IP/0LEl81O01f90X1v37aRngtzpxGZtJm8Aup/hpEKuDSS2ze3t5kZWUdtz47Oxsvr8o1sRcUFJCUlER8fPzRYux24uPjSUxMPMmeJsMwSEhIYNOmTZx//vkn3CY1NZXvv/+e8eOP73j69NNP06BBA7p168Zzzz1HUVHRCY4gruTn5cHN57fg1/sv5N9D2tMwwJu/0w/z8Jfr6P/8Qj5cuoP8It0qXC0adTEvjRhOMxyFdzanAPnnWhj/M8TdonB0rHP/afa92rvG/S4jFR427ySE6rm1/0TC2kFEZ/OztP5La2oQOUseZ7LTpZdeyi233MI777xDr169AFi2bBn/+Mc/uOyyyyp1jP3791NcXEx4eHiZ9eHh4WzcuLGCvSAjI4PGjRuTn5+Pw+HgtddeY+DAE3eUnDlzJgEBAVxxxRVl1t911110796dkJAQfvvtNx566CH27t3Liy++WOHr5ufnk5+fX/q7BsSsOr5eDm46rwXXndOMT5bv5PWFW/k7/TD//uoPpi3Ywm39WjKiRxQ+nnXjBgDLXPm2OZhj8/OhYVurq3Fv/qHmfHZLpprjIrW92H1akf6YDXnp5oSxVnYi7zLSHFF77WeVuztSxM2cUQvSyy+/TMuWLenduzc+Pj74+PjQp08fWrVqxdSpU6u4xLICAgJYs2YNK1as4L///S8TJ05k4cKFJ9z23XffZfTo0fj4lO2gOHHiRPr160eXLl34xz/+wQsvvMArr7xSJgCVN2XKFIKCgkofUVFRVXlaAvh4Ohh3bnN+ub8/T1zWkYhAH/Zm5PHo1+u54LkFzFiynbxCtSi5THCU+aWvcFQ5fe4Cr3qQstYcNdxdlHTO7nGjtcMsdLoKsMGupXAo2bo6RM7QWY2DtGXLltLb/Nu3b0+rVq0qvW9BQQF+fn588cUXDB8+vHT9DTfcQHp6Ol9//XWljnPTTTexa9cufvrppzLrf/31V84//3zWrFlD165dT3qM9evX06lTJzZu3Ejbtif+cjhRC1JUVJT6ILlQflExn63czesLtrAnw5yqJCzAm1svaMm1vZri66UWJbFYwpPw6wvmJclbf7F+Xrm/k+CtC827DCduMFu6rDTzMti+yBwk9Pz7rK1F5IjK9kGq9CW2iRMnnvT5BQsWlC6f7FJVCS8vL2JjY0lISCgNSE6nk4SEBCZMmFDZsnA6nSds+XnnnXeIjY09ZTgCWLNmDXa7/YR3zpXw9vbG29u70nXJ2fP2cHD9Oc0Y0aMJXyTt5rUF5qW3yd/9yesLt3Lr+S0YfU5T/LzO6EqxyNnrPQGWvQmp62Djd+aErVZa8Y75s+Pl1ocjMC+zbV9kXmY7b5L7XIYUqYRKf7OsXr26UtvZTuMPYOLEidxwww306NGDXr16MXXqVHJychg3zpzzaMyYMTRu3JgpU6YA5mWuHj160LJlS/Lz8/nhhx/44IMPeP3118scNzMzk88//5wXXnjhuNdMTExk2bJl9O/fn4CAABITE7nnnnu47rrrqF/fhRM5yhnz9nAwOq4ZV8dGMXvVbl5dsIXdhw7z3x82MH3RVm453+y/5O+toCTVzC8EzvkH/PIcLHzaHP7Aqlak3IPm0AxgXefs8toPhe8nwv6/YO/vEBljdUUilVbpb5RjW4iqysiRI9m3bx+PPvooKSkpxMTEMGfOnNKO2zt37sR+zH9scnJyuP3229m9eze+vr60a9eODz/8kJEjR5Y57qxZszAMg2uuOX5ofW9vb2bNmsXjjz9Ofn4+zZs355577jllC5lYz8vDzqheTbkytglfrvqbVxdsYefBXKb8uJE3ftnGTec1Z0zvaOopKEl16n0HLHvDHGhzw9dm640V1nwERXkQ0QWa9LSmhvJ8As0O7Ou/hHWfKyBJjaK52M6QxkGyXmGxk6/X7OHV+ZtJPpALQLCfJw9f0p4RPdSJXqrRgqdg0TNQLwIGPGpeWnJUY1B3Os2BIQ9th6EvQ+wN1ffap7LxB5h1jfneTPyz9s3PJzWOS8dBEnEHng47V8U2Yd7EC3hxRFdahPqTnlvI/V+sZeZvyVaXJ3XJObdD/eaQnQJf324Okrj2c3PC2Oqwdb4ZjryDzJHO3UmreHM+uOwU2P6L1dWIVJoCktR4Hg47V3RvwtyJF3DrBeaUCo99s54ZS7ZbXJnUGb7BcNtvMPBJ8A2BA1tg9k3weh/z8pLTxXMNltzaH3MteFV+yqRq4eF19LLj2s+srUXkNCggSa3hsNt4cHA7buvXEoDHv/1TIUmqj5efOcL23WvN29p9gsyJfT8fC2+cb46V5IoeDYd2mAN8gvsOyNjlSD/RDd9CQa61tYhUkgKS1Co2m437B7XldoUksYp3gDnmz93r4IIHwTvQHAZg1rXwVn/YPLdqg1LSDMCAFv0gtHXVHbcqRcWZI3sXZMFfbjY1i0gFFJCk1rHZbNxXLiS9p5Ak1c0nCPo/BP/8HfpONOdu27MaProK3rkIti44+6BUlA+r3jeX3eXW/hOx2aDzCHN57efW1iJSSQpIUiuVhKQ7+psh6QmFJLGKXwjEP2ZeeutzJ3j4wu7l8MFwmDEEkpec+bH//Bpy90NAJLS5uMpKdokuRwLSlrmQc8DaWkQqQQFJai2bzcaki8qGpHcXKySJRfxD4aL/wD/XQNw/zOlAdiyBGZfA+8Ng1/LTP2bpvGvjqndYgTPRsC006grOIlg/2+pqRE5JAUlqtfIh6cnvFJLEYgERcPEzcNeaIxPKesK2hfDOQPjwKvh7VeWOs3ct7FoGdg/oPsaVFVedks7a63SZTdyfApLUeiUhaUJ/czJlhSRxC0GN4dL/gzuToNv1YHOYl5/e6g+fXAsp606+/8oj8661v8wMXTVBpyvBZjeD3UH9DYp7U0CSOsFms3HvRW3KhKR3FJLEHdRvBsNehQkroMsoM0Bs+h6m94XPxkDaxuP3ycs4OqaQO3fOLi8gAppfYC6v+8LaWkROQQFJ6oySkHTnhWZImqyQJO6kQUu44g24fRl0vAKwmZ2wXzsH/ncT7N9ydNs1n0BhLjRsD836WFbyGSnprL32U9eMCyVSRRSQpE6x2WxMHFg2JL396zaLqxI5RsM2cPV7cNsSaD8UMMw+O9N6wle3m5emSjpn9xxv3kJfk7S71LyT78Bm2LvG6mpEKqSAJHVO+ZD0n+83KCSJ+wnvCCM/hFt/gTaDwXDCmo/MSWkPbAavekc7PdckPoHQ9siQBJp6RNyYApLUSSUh6S6FJHF3jbrCtZ/CTQnQcoAZlMAMRz4Vz0Tu1kqC3R//g+Iia2sRqYCbD5wh4jo2m417BrYB4OX5W/jP9xsAuOm8FlaWJXJiTXrA9bNhRyLsWAy9brG6ojPXaoA5qW92KmxfZP4u4mbUgiR1WklIumuAOYeVWpLE7TXrbc715hNkdSVnzuEJna4wlzUmkrgpBSSp82w2G/fEty4Tkt76RSFJxKVKLrNt+BYKcq2tReQEFJBEONon6Z9HQtJ/f1BIEnGpJj2hfjQUZMOmH6yuRtyN0wn7NllaggKSyDHuKReS3vxlq8UVidRSNht0LhkTSXezCea4WLtWwJyHYWoneP1cOJxuWTnqpC1STknH7ZcSNvPUD+Yoxrec39LKkkRqpy4j4JdnYWsC5Ow3J/SVusUwYM8qWP8lrP8KMnYdfc4rANL+tGwwVAUkkRNQSBKpBqGtIbIb7FltfkH2utnqiqQ6GIY5SOj6L81H+s6jz3nVM8fJ6ngFtLwQPH0sK1MBSaQC5UOSYcCtFygkiVSpziPMgLT2UwWk2swwzAmYS0LRoWOmefL0h7aDoePl0CoePH2tq/MYCkgiJ3HPwDbYbDB13mam/Gi2JCkkiVShTlfCz/+C3Stg51JzYEw3+YKUs2QYkLr+aCg6eEyfTg9faDPIDEWtLwIvP+vqrIACksgp3B1vtiSVhCQD+IdCkkjVCAiHFv1g63x4d5C5zr8hBDU58mhq/gyOOvJ7FPg1qHlz0NUlaRuOhqL9fx1d7+EDrQeaoajNYPDyt67GSlBAEqmEY0PS00dakhSSRKrIBQ9A9j44uA0KcyBnn/nYs/rE23v4Hg1QwVFmaCoJT0FNILAxeHhV7znUdfs2HQ1F+zYeXe/wPiYUDQLvAOtqPE02wzAMq4uoiTIzMwkKCiIjI4PAwBo6H5Kctpfmbeb/5pn/R3RPfBsu7dqI+n5eBPl64rDr/2hFzophwOFDkLH7yGOX+UjfdXRddkolDmSDgIiyoSko6mgrVEgLt2+9qDSnE/ZtMKdt8fQ3L1V5+R9Z9gdPP7C7aESf/VuOhqK09UfXO7zMeQM7Xm52uHazOQMr+/2tgHSGFJDqrmND0rECfTyo7+9FsJ8X9f08S4NTfT8v6vt7EuznRfCR34P9PKnv74W/lwObLhWIVF5RPmT+XTY0Zew8Znk3FOWd/Bh2D2gcC9F9Ifo8iIpzyz4wJ2QYcGCrOYfd9l8g+VfIPXDyfTx8zbDk5WfeJebpV275mDBVslz+d88j2zuLzIE9138FqeuOvobdw7zrrOMVZijyDXblu3BWFJBcTAGpbnt38XbeT0zmQE4BWXlnPhu5p8NGkO/RQBXs52mGJ7+jQSvYzwsPu41iw8DpNChyGjgNg2Kn+XAaR9Yd+b3YgGKnk2InZbYznzt2u7LHKHYahAX4cPP5LQjy9azCd0ukGhmGOabSsaEpfVfZ1qjDB8vuY/c0JwOO7ms+ouLcq6N4xm4zDJU8Mv8u+7ynnzkqeWGuOW1LQY55qdLV7B5m/7GOl0O7IeBb3/WvWQUUkFxMAUlKFBU7ST9cSHpuIem5BRzKLeRQbkHp8tH1BaQfee5QbiEFRU6rSz+h89s05L2xPXXJUGqvQ8mQvBi2/2q2wJQPHA4vaNwDmp9nBqYmvap3PJ7sfZB8TCA6WG7aI4eXWVPz881H49jj+1wZBhQePhqWCnLM8HTsckH2MaHqRMtHtj12ubjADJAdL4f2Q8EvpPrelyqigORiCkhyNgzDIK/QeSQsHQ1Ox4cs86fTaeCw23DYbdhtttJlh92Gw2bDfuSnw3Hk55HtPOxHnrNTul3pOlvZYzgNeH3RFvIKnUzo34pJg9pa/TaJuJ5hHAlMvx4NTVl7ym7j8Dbnjovua4amxj2qNjAdTocdvx0NRMf25wGw2c0BNZtfYAaimnRJ0A0pILmYApLURl+t/pu7P10DwJvXx3JRxwhrCxKpboZhttgcG5jKdwz38DkSmEpamHqAh3flX6MgF3YmHg1Ee9eAUa5FObzT0RaiZn3AJ+isT01MCkgupoAktdXj36xnxm/JBHh78PWEc2nRsJ7VJYlYp6RTdPKvR0NTdmrZbTx8IKoXRJ9vBqbyl7yKCuDvlUcD0a7l4Cwse4yQltDiSAtR9Hmal86FFJBcTAFJaqvCYifXvrWUFcmHaB1Wj6/uOBd/bw2ZJgIcCUxbjtxBttgMTTn7ym7j4QtN48xRwVPWmSOEF+aW3Saw8dFLZs3PM4cfkGqhgORiCkhSm6Vl5nHpK4tJy8pnSJdGvHpNNw1HIHIihmGOFl0amBZD7v7jt/MLNYNQSSgKaaHRwC2igORiCkhS2yXtOMjIN5ZS5DT495D23HReC6tLEnF/hmGOJJ282Gw9CmtvBqKG7V03YKOcFgUkF1NAkrpg5m/JPPbNehx2Gx+Oj6N3ywZWlyQiclYq+/2tOCsiFRrTuxlXdGtMsdNgwser2Jtx2OqSRESqhQKSiFTIZrPx38s7075RIAdyCrjtw1XkFxVbXZaIiMspIInISfl6OXjjuliCfD1ZsyudJ7/90+qSRERcTgFJRE6paQM/po6KwWaDj5bt5LOVu6wuSUTEpSwPSNOmTSM6OhofHx/i4uJYvnx5hdvOnj2bHj16EBwcjL+/PzExMXzwwQdlthk7diw2m63MY/DgwWW2OXjwIKNHjyYwMJDg4GDGjx9Pdna2S85PpLbo3zaMe+LbAPDvr/5g3e4MiysSEXEdSwPSp59+ysSJE3nsscdYtWoVXbt2ZdCgQaSlpZ1w+5CQEP71r3+RmJjI2rVrGTduHOPGjeOnn34qs93gwYPZu3dv6eOTTz4p8/zo0aNZv349c+fO5bvvvuOXX37hlltucdl5itQWE/q3Ir59GAVFTv7xYRIHcwqsLklExCUsvc0/Li6Onj178uqrrwLgdDqJiorizjvv5MEHH6zUMbp3786QIUOYPHkyYLYgpaen89VXX51w+w0bNtChQwdWrFhBjx49AJgzZw6XXHIJu3fvJjIyslKvq9v8pa7KOFzIsFcXk3wgl76tQpl5Yy8cdg14JyI1g9vf5l9QUEBSUhLx8fFHi7HbiY+PJzEx8ZT7G4ZBQkICmzZt4vzzzy/z3MKFCwkLC6Nt27bcdtttHDhwoPS5xMREgoODS8MRQHx8PHa7nWXLllXBmYnUbkG+nky/PhZfTweLt+znhZ83WV2SiEiVsywg7d+/n+LiYsLDw8usDw8PJyUlpYK9ICMjg3r16uHl5cWQIUN45ZVXGDhwYOnzgwcP5v333ychIYFnnnmGRYsWcfHFF1NcbN6anJKSQlhYWJljenh4EBISctLXzc/PJzMzs8xDpK5qFxHIM1d1AeC1hVuZ80fFfzsiIjVRjZuBMiAggDVr1pCdnU1CQgITJ06kRYsW9OvXD4BRo0aVbtu5c2e6dOlCy5YtWbhwIQMGDDjj150yZQpPPPHE2ZYvUmtc1jWSNTvTeXfJdiZ9/jutwurRKqye1WWJiFQJy1qQQkNDcTgcpKamllmfmppKREREhfvZ7XZatWpFTEwM9957L1dddRVTpkypcPsWLVoQGhrKli1bAIiIiDiuE3hRUREHDx486es+9NBDZGRklD527dJtziIPXdKOXs1DyM4v4h8fJpGdX2R1SSIiVcKygOTl5UVsbCwJCQml65xOJwkJCfTu3bvSx3E6neTn51f4/O7duzlw4ACNGjUCoHfv3qSnp5OUlFS6zfz583E6ncTFxVV4HG9vbwIDA8s8ROo6T4edadd2JzzQmy1p2dz/xe9oekcRqQ0svc1/4sSJvPXWW8ycOZMNGzZw2223kZOTw7hx4wAYM2YMDz30UOn2U6ZMYe7cuWzbto0NGzbwwgsv8MEHH3DdddcBkJ2dzX333cfSpUtJTk4mISGBYcOG0apVKwYNGgRA+/btGTx4MDfffDPLly9nyZIlTJgwgVGjRlX6DjYROaphgDevjY7F02Hjh3UpvPXrNqtLEhE5a5b2QRo5ciT79u3j0UcfJSUlhZiYGObMmVPacXvnzp3Y7UczXE5ODrfffju7d+/G19eXdu3a8eGHHzJy5EgAHA4Ha9euZebMmaSnpxMZGclFF13E5MmT8fb2Lj3ORx99xIQJExgwYAB2u50rr7ySl19+uXpPXqQWiW1Wn0cv7cAjX6/n6R830ikyiD6tQq0uS0TkjFk6DlJNpnGQRMoyDINJn6/lf6t2E+LvxXd39iUy2NfqskREynD7cZBEpHax2Wz89/JOdIwM5GBOAbd9mEReYbHVZYmInBEFJBGpMj6eDqZfF0uQrye/787giW/XW12SiMgZUUASkSoVFeLHy9d0w2aDT5bv4tMVO60uSUTktCkgiUiVu6BNQ+4d2AaAR75ez++70q0tSETkNCkgiYhL3N6vFfHtwykocnLbh0kcyK54vDIREXejgCQiLmG323hxZFeah/qzJyOPu2atpqjYaXVZIiKVooAkIi4T6OPJG9fH4uflYMmWAzz/819WlyQiUikKSCLiUm3CA3j2qi4ATF+0lR/X7bW4IhGRU1NAEhGXu7RLJDf1bQ7ApM9/Z0talsUViYicnKVTjYhI3fHgxe34Y08GS7cd5NYPkvh6Ql/qeXvgdBrkFRVzuKCY3IJi8grNn4cLzXWHy/xexOECJ7mFReQVnHi78vt7OmyM79ucm89vgbeHw+q3QURqCE01coY01YjI6dufnc+lLy8mJTMPfy8HxYZBXmH1dNxu0dCf/wzrpDniROq4yn5/KyCdIQUkkTOzeuchRr25lPyi44ORj6cdX08Hfl4e+Hja8fPywNfTga+X48h6Bz5eDvxK1h27/sh+5bdfsyud/3y/gf1HhhkYFhPJv4a0JyzAp7pPXUTcgAKSiykgiZy5tKw80nMLS8OMn5cDHw8HdrvNJa+XcbiQF3/exAdLd+A0IMDbg0mD2nLdOc1wuOg1RcQ9KSC5mAKSSM2zbncG//pqHWt3ZwDQqXEg/x3ema5RwdYWJiLVprLf37qLTUTqjM5Ngvjy9nOZPLwTAT4e/PF3JsNfW8K/v1pHRm6h1eWJiBtRQBKROsVht3H9Oc2Yf28/rujWGMOAD5fuZMCLC5m9ajdqVBcR0CW2M6ZLbCK1Q+LWAzzy9R9sScsGIK55CP8Z3onW4QEWVyYirqBLbCIildC7ZQN+uOs87h/cFh9PO8u2H+Til37lmTkbyS0osro8EbGIApKI1HleHnZu79eKufdcQHz7cIqcBq8v3MrAF39h7p+pVpcnIhZQQBIROSIqxI+3b+jBW2N60DjYl7/TD3Pz+yu5aeZKdh3Mtbo8EalGCkgiIuUM7BDO3Innc1u/lnjYbczbkMrA/1vEawu3UHCCAS5FpPZRQBIROQE/Lw8eGNyOH/95HnHNQ8grdPLsnE1c8vKvJG49YHV5IuJiCkgiIifROjyAWbecw4sjuhJaz4stadlc89ZS7vl0Dfuy8q0uT0RcRAFJROQUbDYbV3RvQsLEflx3TlNsNvhy9d9c+MJCPkhMptip0VJEahuNg3SGNA6SSN31+650/v3VH6z725yypGuTIP4zvDOdmwRZXJmInIrGQRIRcZGuUcF8dce5PHFZRwK8Pfh9dwaXTVvM5O/+VCdukVpCAUlE5Aw47DZu6BNNwqQLGBYTiWHAO4u3c81bS0nNzLO6PBE5SwpIIiJnISzAh5dGdePtMT0I8PEgacchhry8mOXbD1pdmoicBQUkEZEqEN8hnG8n9KVdRAD7s/O59q2lvLdkuya/FamhFJBERKpIdKg/s2/vw2VdIylyGjzx7Z/c/ekazekmUgMpIImIVCE/Lw9eGhXDo5d2wGG38fWaPVzx2m/sOJBjdWkichoUkEREqpjNZuPGvs35+KY4Qut5szEli6GvLGbBxjSrSxORSlJAEhFxkbgWDfjuzr50axpMZl4RN85cwdR5f+HUwJIibk8BSUTEhSKCfPj0lt5cf04zDAOmztvMTe+vJCO30OrSROQkFJBERFzMy8PO5OGdeP7qrnh72Jm/MY3Lpi1mw95Mq0sTkQooIImIVJOrYpvwv9v60KS+LzsO5HL5a0v4es3fVpclIieggCQiUo06NQ7i2wl9Oa91KHmFTv45aw1PfLuewmJNUSLiThSQRESqWX1/L2aM68WE/q0AeG9JMqPfWkZalqYoEXEXCkgiIhZw2G1MGtSWN6+PpZ63B8uTDzL0lcUk7dAUJSLuQAFJRMRCF3WM4OsJ59I6rB6pmfmMenMpHyQma4oSEYtZHpCmTZtGdHQ0Pj4+xMXFsXz58gq3nT17Nj169CA4OBh/f39iYmL44IMPSp8vLCzkgQceoHPnzvj7+xMZGcmYMWPYs2dPmeNER0djs9nKPJ5++mmXnaOIyMm0bFiPr+44lyGdG1FYbPDI1+u59/PfySsstro0kTrL0oD06aefMnHiRB577DFWrVpF165dGTRoEGlpJx5tNiQkhH/9618kJiaydu1axo0bx7hx4/jpp58AyM3NZdWqVTzyyCOsWrWK2bNns2nTJi677LLjjvXkk0+yd+/e0sedd97p0nMVETkZf28PXr22G/+6pD12G8xe9TdXvv4buw7mWl2aSJ1kMyxsx42Li6Nnz568+uqrADidTqKiorjzzjt58MEHK3WM7t27M2TIECZPnnzC51esWEGvXr3YsWMHTZs2BcwWpLvvvpu77777jGvPzMwkKCiIjIwMAgMDz/g4IiLl/bZ1P3d+vJoDOQUE+Xry8jXduKBNQ6vLEqkVKvv9bVkLUkFBAUlJScTHxx8txm4nPj6exMTEU+5vGAYJCQls2rSJ888/v8LtMjIysNlsBAcHl1n/9NNP06BBA7p168Zzzz1HUdHJZ9vOz88nMzOzzENExBX6tAzl2zv70jUqmIzDhYx9bzmvzt+sKUpEqpFlAWn//v0UFxcTHh5eZn14eDgpKSkV7peRkUG9evXw8vJiyJAhvPLKKwwcOPCE2+bl5fHAAw9wzTXXlEmJd911F7NmzWLBggXceuutPPXUU9x///0nrXfKlCkEBQWVPqKiok7jbEVETk9ksC+f3XoO1/RqimHA8z//xa0fJpGZpylKRKqDZZfY9uzZQ+PGjfntt9/o3bt36fr777+fRYsWsWzZshPu53Q62bZtG9nZ2SQkJDB58mS++uor+vXrV2a7wsJCrrzySnbv3s3ChQtP2oz27rvvcuutt5KdnY23t/cJt8nPzyc/P7/098zMTKKionSJTURcbtbynTz69XoKip00D/XnjetjaRMeYHVZIjVSZS+xeVRjTWWEhobicDhITU0tsz41NZWIiIgK97Pb7bRqZQ6uFhMTw4YNG5gyZUqZgFRYWMiIESPYsWMH8+fPP2WAiYuLo6ioiOTkZNq2bXvCbby9vSsMTyIirjSqV1PaNwrktg+T2L4/h+HTljC2TzTXndOMyGBfq8sTqZUsu8Tm5eVFbGwsCQkJpeucTicJCQllWpROxel0lmnZKQlHmzdvZt68eTRo0OCUx1izZg12u52wsLDTOwkRkWrSNSqYb+/sy7mtGpBbUMxrC7dy3rMLuO3DJJZuO6Bxk0SqmGUtSAATJ07khhtuoEePHvTq1YupU6eSk5PDuHHjABgzZgyNGzdmypQpgNkPqEePHrRs2ZL8/Hx++OEHPvjgA15//XXADEdXXXUVq1at4rvvvqO4uLi0P1NISAheXl4kJiaybNky+vfvT0BAAImJidxzzz1cd9111K9f35o3QkSkEhrU8+b9G+OY+2cqM39LJnHbAX78I4Uf/0ihXUQAN/SJZnhMY3y9HFaXKlLjWRqQRo4cyb59+3j00UdJSUkhJiaGOXPmlHbc3rlzJ3b70UaunJwcbr/9dnbv3o2vry/t2rXjww8/ZOTIkQD8/ffffPPNN4B5+e1YCxYsoF+/fnh7ezNr1iwef/xx8vPzad68Offccw8TJ06snpMWETkLDruNwZ0iGNwpgo0pmcz8bQdfrt7NxpQsHpq9jqd/3MionlFcd04zokL8rC5XpMaydBykmkzjIImIu8jILeSzlbt4f2kyuw4eBsBugwHtwxnbJ5o+LRtgs9ksrlLEPVT2+1sB6QwpIImIuyl2GizYmMbMxGR+3by/dH3rsHqM6RPNFd0a4+9t6YUDEcspILmYApKIuLMtadm8n5jMF0m7yS0w53QL8PHg6tgoxvRuRnSov8UVilhDAcnFFJBEpCbIzCvki5W7eT8xmeQD5rxuNhv0bxvGDX2iOa9VKHa7Lr9J3aGA5GIKSCJSkzidBos272Pmb8ks3LSvdH2LUH/G9G7GlbFNCPDxtLBCkeqhgORiCkgiUlNt359jXn5buZusfHMeSn8vB1fFNmFMn2haNqxncYUirqOA5GIKSCJS02XnF/Hlqt3M+C2ZrftyStef1zqUsX2i6d82TJffpNZRQHIxBSQRqS0Mw2Dxlv3M/C2ZhI1plHwrNGvgx8D24YTU86K+nxf1/TwJ9iu77OVh2YQMImdEAcnFFJBEpDbaeSCXD5Ym8+mKXWTmFZ1ye38vhxma/D2p7+d1JEB5lv4013keCVVeBPt7EuDtoXGZxDIKSC6mgCQitVluQRHfrd3L5tQsDuUWkp5bwKHcQg7lFpB+5HfnGX57eNhtBB8TooL9vAit50WXJsHENQ+heai/ApS4jAKSiykgiUhd5nQaZOUVcSi3oDQ0HToSotKPrCtdzjkasA4XFp/y2GEB3vRqHkJciwac0zyEVmH1FJikyigguZgCkojI6csrLD4mTB0NVnvSD7Mi+RBrdqZTUOwss08Dfy8zMB0JTW3DA9R5XM6YApKLKSCJiFS9vMJi1uxKZ9m2gyzbfoBVOw+RV1g2MAX7edIz2gxM57RoQPtGgTgUmKSSFJBcTAFJRMT1CoqcrN2dzrLtB1m67QBJOw6VTp1SIsDHozQwxbVoQKfIQDwcurtOTkwBycUUkEREql9hsZM//s5g2faDLNt2gJXJh0oHuyzh7+UgtrSFKYTOjYM1HIGUUkByMQUkERHrFTsN/tyTybLtB1i67SArkg+ScbiwzDa+ng66NwsmrnkD4pqHENM0GG8Ph0UVi9UUkFxMAUlExP04nQYbU7JYtv0Ay7YdZHnyQQ7mFJTZpkl9Xz4YH0fzUH+LqhQrKSC5mAKSiIj7czoNtuzLZtm2AyzdfpDftuznUG4hYQHefHzzObQK07xzdY0CkospIImI1Dz7s/MZ/dYyNqVmEVrPm09ujqN1eIDVZUk5xU6DlMw8Ggf7VvmxK/v9rV5rIiJSZ4TW8+aTW86hfaNA9mfnM+rNpWxMybS6LDnGgex8xr63nBHTEzlU7vJodVJAEhGROiXE34uPb4qjY2QgB3IKuObNpazfk2F1WQIk7TjEkJcX8+vm/RzMKeDPvdaFVwUkERGpc+r7e/HxTefQpUkQh3ILufatZfzxt0KSVQzD4N3F2xn5RiIpmXm0aOjP1xPO5dxWoZbVpIAkIiJ1UpCfJx+MjyMmKpiMw4Vc+9ZSft+VbnVZdU5WXiETPl7Nk9/9SZHT4NIujfhmQl/aWNw3TAFJRETqrCBfTz4Y34sezeqTmVfEdW8vY9XOQ1aXVWdsSsli2KtL+H7dXjwdNh4f2oFXrulGPW8Pq0tTQBIRkbotwMeTmTf2olfzELLyixjzznJWJh+0uqxab/aq3Qybtpht+3OIDPLh01t7M/bc5ths7jGvngKSiIjUef7eHswY15PeLRqQnV/EmHeXs3TbAavLqpXyCot5+Mt1TPzsd/IKnZzXOpTv7jqP7k3rW11aGQpIIiIigJ+XB++O7UnfVqHkFhQz9r3l/LZlv9Vl1Sq7DuZy9fREPl62E5sN/jmgNTPG9SLE38vq0o6jgCQiInKEr5eDt2/owQVtGpJX6GTcjBX8unmf1WXVCgkbUrn0lcWs+zuD+n6ezBjXi3sGtsFhd49LauUpIImIiBzDx9PBG9fHcmG7MPKLnIyfuZKFm9KsLqvGKip28uycjYyfuZKMw4XERAXz3V3ncUGbhlaXdlIKSCIiIuX4eDp4/bruDOwQTkGRk1veTyJhQ6rVZdU4+7Lyuf6d5by2cCsAY/tE89mtvV0yhUhVU0ASERE5AW8PB9Ou7c7gjhEUFDv5x4dJ/Lw+xeqyaozl2w8y5OVfSdx2AD8vBy9f043HL+uIl0fNiB41o0oRERELeHnYeeXabgzp0ojCYoPbP1rFj+v2Wl2WWzMMg7d+2cY1by0lLSuf1mH1+GbCuVzWNdLq0k6L9SMxiYiIuDFPh52XRsbgYbfx9Zo9TPhkNVOdBkNr2Bd+dcjMK+S+z3/np/Xm5chhMZE8dXln/N1g4MfTVfMqFhERqWYeDjsvjojBYbcxe9Xf/HPWapyGwbCYxlaX5jb+3JPJ7R8lkXwgFy+HnUeGduC6uKZuM/Dj6VJAEhERqQSH3cZzV3XFw27js5W7uefTNRQVG1wZ28Tq0iz32cpdPPLVH+QXOWkc7Mtro7vTNSrY6rLOigKSiIhIJTnsNp6+ogsOu51Plu9k0he/U+w0GNEzyurSLJFXWMxjX6/n05W7AOjXtiH/NyKG+m448OPpUkASERE5DXa7jf8O74SH3cYHS3dw///WUuQ0uDauqdWlVasdB3K47cNV/Lk3E5sNJsa34Y7+rbC76cCPp0sBSURE5DTZ7TaeHNYRh93GjN+SefjLdRQ5nYzpHW11adXip/UpTPr8d7Lyimjg78VLo7rRt3Wo1WVVKQUkERGRM2Cz2XhsaAc8HTbe+nU7j369nqJigxv7Nre6NJcpKnby3E+beOOXbQDENqvPtGu7ExHkY3FlVU8BSURE5AzZbDYevqQ9Drud6Yu28uR3f1LsNLj5/BZWl1alDMNgza50pvy4keXbDwIwvm9zHry4HZ6O2jmkogKSiIjIWbDZbDwwuC2eDhuvzN/Cf3/YQJHT4LZ+La0u7ayl5xbw5eq/+XTFLjamZAFQz9uD567qwsWdG1lcnWtZHvumTZtGdHQ0Pj4+xMXFsXz58gq3nT17Nj169CA4OBh/f39iYmL44IMPymxjGAaPPvoojRo1wtfXl/j4eDZv3lxmm4MHDzJ69GgCAwMJDg5m/PjxZGdnu+T8RESk9rPZbNx7UVvujm8NwDNzNvJKwuZT7OWeDMNg6bYD3D1rNb2eSuCJb/9kY0oW3h52Lu/WmG/v7FvrwxGAzTAMw6oX//TTTxkzZgzTp08nLi6OqVOn8vnnn7Np0ybCwsKO237hwoUcOnSIdu3a4eXlxXfffce9997L999/z6BBgwB45plnmDJlCjNnzqR58+Y88sgjrFu3jj///BMfH/Ma6cUXX8zevXt54403KCwsZNy4cfTs2ZOPP/640rVnZmYSFBRERkYGgYGBVfOGiIhIjffq/M08//NfAHRtEsSA9uFc2C6MjpGBbj1o4r6sfP63ajefrtjF9v05pevbRQRwTa+mDI9pTJCfp4UVVo3Kfn9bGpDi4uLo2bMnr776KgBOp5OoqCjuvPNOHnzwwUodo3v37gwZMoTJkydjGAaRkZHce++9TJo0CYCMjAzCw8OZMWMGo0aNYsOGDXTo0IEVK1bQo0cPAObMmcMll1zC7t27iYys3NDxCkgiIlKRN3/ZytM/bsR5zDdsRKAPF7YPY0C7MPq0DMXXy2FdgUcUOw0Wb9nPrOU7mftnKkVHCvb3cnBZTCSjejalS5Mgtw52p6uy39+W9UEqKCggKSmJhx56qHSd3W4nPj6exMTEU+5vGAbz589n06ZNPPPMMwBs376dlJQU4uPjS7cLCgoiLi6OxMRERo0aRWJiIsHBwaXhCCA+Ph673c6yZcu4/PLLT/h6+fn55Ofnl/6emZl52ucsIiJ1wy3nt2RYTGMWbEwjYWMaizfvJyUzj4+X7eTjZTvx9rDTt1UoF7YP48J2YTQK8q3W+vZmHOazFbv5bOUu/k4/XLo+JiqYUT2juLRrJPVq4PxpVcmys9+/fz/FxcWEh4eXWR8eHs7GjRsr3C8jI4PGjRuTn5+Pw+HgtddeY+DAgQCkpKSUHqP8MUueS0lJOe7ynYeHByEhIaXbnMiUKVN44oknKn+CIiJSp4UH+jCqV1NG9WpKXmExidsOMH9DGgkbUtmTkUfCkfAE0DEykAHtwriwfThdGge5ZLDFwmIn8zemMWv5Thb9ta+0dSvQx4MrujdhZM8o2jfSFZESNS4eBgQEsGbNGrKzs0lISGDixIm0aNGCfv36ufR1H3roISZOnFj6e2ZmJlFRdXNoeREROT0+ng76tw2jf9swnhzWkY0pWczfaIal1bvSWb8nk/V7Mnl5/hZC63lzYbuGXNgunPNah+J/li05Ow7k8OmKXXyetJt9WUevhMQ1D+GaXk0Z3CkCH0/rL/e5G8sCUmhoKA6Hg9TU1DLrU1NTiYiIqHA/u91Oq1atAIiJiWHDhg1MmTKFfv36le6XmppKo0ZHe9inpqYSExMDQEREBGlpaWWOWVRUxMGDB0/6ut7e3nh7e5/WOYqIiJRns9lo3yiQ9o0CuaN/K/Zn57Nw0z4SNqTyy1/72J+dz2crd/PZyt14Oeyc07KB2brULoyoEL9KvUZ+UTE/rU9l1vKd/Lb1QOn6Bv5eXBVrtha1aFjPVadYK1gWkLy8vIiNjSUhIYHhw4cDZifthIQEJkyYUOnjOJ3O0r5BzZs3JyIigoSEhNJAlJmZybJly7jtttsA6N27N+np6SQlJREbGwvA/PnzcTqdxMXFVd0JioiIVEJoPW+uim3CVbFNKChysnz7QRI2ppKwIY2dB3P55a99/PLXPh77Zj1twwO4sH0Y8e3DiImqj6PcpbjNqVnMWrGL2at2cyi3EACbDc5r3ZBrekYxoH04Xh6Wj/BTI1h+m/8NN9zAG2+8Qa9evZg6dSqfffYZGzduJDw8nDFjxtC4cWOmTJkCmP2AevToQcuWLcnPz+eHH37gwQcf5PXXX+emm24CzNv8n3766TK3+a9du/a42/xTU1OZPn166W3+PXr00G3+IiLiNgzDYOu+bBI2pJGwIY2VOw6WuSuuvp8n/duGcWH7MA4XFDNrxS6Sdhwqfb5RkA9X94ji6tgmlW55qgvc/i42gJEjR7Jv3z4effRRUlJSiImJYc6cOaWdrHfu3IndfjTp5uTkcPvtt7N79258fX1p164dH374ISNHjizd5v777ycnJ4dbbrmF9PR0+vbty5w5c0rDEcBHH33EhAkTGDBgAHa7nSuvvJKXX365+k5cRETkFGw2G63CAmgVFsCtF7QkPbeARX/tY96GNBZtSuNQbiGzV//N7NV/l+7jsNu4sF0Y1/SK4oI2Yce1MEnlWdqCVJOpBUlERKxSWOwkacch5m9MY/6RO+Eu79aYq2ObEBZY+yaOrUo1YqDImkwBSUREpOap7Pe3emqJiIiIlKOAJCIiIlKOApKIiIhIOQpIIiIiIuUoIImIiIiUo4AkIiIiUo4CkoiIiEg5CkgiIiIi5SggiYiIiJSjgCQiIiJSjgKSiIiISDkKSCIiIiLlKCCJiIiIlKOAJCIiIlKOh9UF1FSGYQCQmZlpcSUiIiJSWSXf2yXf4xVRQDpDWVlZAERFRVlciYiIiJyurKwsgoKCKnzeZpwqQskJOZ1O9uzZQ0BAADabzepyqk1mZiZRUVHs2rWLwMBAq8uxjN6Ho/RemPQ+mPQ+HKX3wuRu74NhGGRlZREZGYndXnFPI7UgnSG73U6TJk2sLsMygYGBbvFBt5reh6P0Xpj0Ppj0Phyl98LkTu/DyVqOSqiTtoiIiEg5CkgiIiIi5SggyWnx9vbmsccew9vb2+pSLKX34Si9Fya9Dya9D0fpvTDV1PdBnbRFREREylELkoiIiEg5CkgiIiIi5SggiYiIiJSjgCQiIiJSjgKSlJoyZQo9e/YkICCAsLAwhg8fzqZNm066z4wZM7DZbGUePj4+1VSxazz++OPHnVO7du1Ous/nn39Ou3bt8PHxoXPnzvzwww/VVK1rRUdHH/de2Gw27rjjjhNuX1s+D7/88gtDhw4lMjISm83GV199VeZ5wzB49NFHadSoEb6+vsTHx7N58+ZTHnfatGlER0fj4+NDXFwcy5cvd9EZVI2TvQ+FhYU88MADdO7cGX9/fyIjIxkzZgx79uw56THP5O/LHZzqMzF27Njjzmvw4MGnPG5t+kwAJ/zvhc1m47nnnqvwmO76mVBAklKLFi3ijjvuYOnSpcydO5fCwkIuuugicnJyTrpfYGAge/fuLX3s2LGjmip2nY4dO5Y5p8WLF1e47W+//cY111zD+PHjWb16NcOHD2f48OH88ccf1Vixa6xYsaLM+zB37lwArr766gr3qQ2fh5ycHLp27cq0adNO+Pyzzz7Lyy+/zPTp01m2bBn+/v4MGjSIvLy8Co/56aefMnHiRB577DFWrVpF165dGTRoEGlpaa46jbN2svchNzeXVatW8cgjj7Bq1Spmz57Npk2buOyyy0553NP5+3IXp/pMAAwePLjMeX3yyScnPWZt+0wAZc5/7969vPvuu9hsNq688sqTHtctPxOGSAXS0tIMwFi0aFGF27z33ntGUFBQ9RVVDR577DGja9euld5+xIgRxpAhQ8qsi4uLM2699dYqrsx6//znP42WLVsaTqfzhM/Xxs8DYHz55ZelvzudTiMiIsJ47rnnStelp6cb3t7exieffFLhcXr16mXccccdpb8XFxcbkZGRxpQpU1xSd1Ur/z6cyPLlyw3A2LFjR4XbnO7flzs60Xtxww03GMOGDTut49SFz8SwYcOMCy+88KTbuOtnQi1IUqGMjAwAQkJCTrpddnY2zZo1IyoqimHDhrF+/frqKM+lNm/eTGRkJC1atGD06NHs3Lmzwm0TExOJj48vs27QoEEkJia6usxqVVBQwIcffsiNN9540gmaa+Pn4Vjbt28nJSWlzL95UFAQcXFxFf6bFxQUkJSUVGYfu91OfHx8rfqcZGRkYLPZCA4OPul2p/P3VZMsXLiQsLAw2rZty2233caBAwcq3LYufCZSU1P5/vvvGT9+/Cm3dcfPhAKSnJDT6eTuu+/m3HPPpVOnThVu17ZtW959912+/vprPvzwQ5xOJ3369GH37t3VWG3ViouLY8aMGcyZM4fXX3+d7du3c95555GVlXXC7VNSUggPDy+zLjw8nJSUlOoot9p89dVXpKenM3bs2Aq3qY2fh/JK/l1P5998//79FBcX1+rPSV5eHg888ADXXHPNSSckPd2/r5pi8ODBvP/++yQkJPDMM8+waNEiLr74YoqLi0+4fV34TMycOZOAgACuuOKKk27nrp8JD0tfXdzWHXfcwR9//HHK68C9e/emd+/epb/36dOH9u3b88YbbzB58mRXl+kSF198celyly5diIuLo1mzZnz22WeV+j+h2uqdd97h4osvJjIyssJtauPnQU6tsLCQESNGYBgGr7/++km3ra1/X6NGjSpd7ty5M126dKFly5YsXLiQAQMGWFiZdd59911Gjx59yhs13PUzoRYkOc6ECRP47rvvWLBgAU2aNDmtfT09PenWrRtbtmxxUXXVLzg4mDZt2lR4ThEREaSmppZZl5qaSkRERHWUVy127NjBvHnzuOmmm05rv9r4eSj5dz2df/PQ0FAcDket/JyUhKMdO3Ywd+7ck7Yencip/r5qqhYtWhAaGlrhedXmzwTAr7/+yqZNm077vxngPp8JBSQpZRgGEyZM4Msvv2T+/Pk0b978tI9RXFzMunXraNSokQsqtEZ2djZbt26t8Jx69+5NQkJCmXVz584t05JS07333nuEhYUxZMiQ09qvNn4emjdvTkRERJl/88zMTJYtW1bhv7mXlxexsbFl9nE6nSQkJNToz0lJONq8eTPz5s2jQYMGp32MU/191VS7d+/mwIEDFZ5Xbf1MlHjnnXeIjY2la9eup72v23wmrO4lLu7jtttuM4KCgoyFCxcae/fuLX3k5uaWbnP99dcbDz74YOnvTzzxhPHTTz8ZW7duNZKSkoxRo0YZPj4+xvr16604hSpx7733GgsXLjS2b99uLFmyxIiPjzdCQ0ONtLQ0wzCOfw+WLFlieHh4GM8//7yxYcMG47HHHjM8PT2NdevWWXUKVaq4uNho2rSp8cADDxz3XG39PGRlZRmrV682Vq9ebQDGiy++aKxevbr07qynn37aCA4ONr7++mtj7dq1xrBhw4zmzZsbhw8fLj3GhRdeaLzyyiulv8+aNcvw9vY2ZsyYYfz555/GLbfcYgQHBxspKSnVfn6VdbL3oaCgwLjsssuMJk2aGGvWrCnz34z8/PzSY5R/H0719+WuTvZeZGVlGZMmTTISExON7du3G/PmzTO6d+9utG7d2sjLyys9Rm3/TJTIyMgw/Pz8jNdff/2Ex6gpnwkFJCkFnPDx3nvvlW5zwQUXGDfccEPp73fffbfRtGlTw8vLywgPDzcuueQSY9WqVdVffBUaOXKk0ahRI8PLy8to3LixMXLkSGPLli2lz5d/DwzDMD777DOjTZs2hpeXl9GxY0fj+++/r+aqXeenn34yAGPTpk3HPVdbPw8LFiw44d9Cybk6nU7jkUceMcLDww1vb29jwIABx70/zZo1Mx577LEy61555ZXS96dXr17G0qVLq+mMzszJ3oft27dX+N+MBQsWlB6j/Ptwqr8vd3Wy9yI3N9e46KKLjIYNGxqenp5Gs2bNjJtvvvm4oFPbPxMl3njjDcPX19dIT08/4TFqymfCZhiG4dImKhEREZEaRn2QRERERMpRQBIREREpRwFJREREpBwFJBEREZFyFJBEREREylFAEhERESlHAUlERESkHAUkEZEqsHDhQmw2G+np6VaXIiJVQAFJREREpBwFJBEREZFyFJBEpFZwOp1MmTKF5s2b4+vrS9euXfniiy+Ao5e/vv/+e7p06YKPjw/nnHMOf/zxR5lj/O9//6Njx454e3sTHR3NCy+8UOb5/Px8HnjgAaKiovD29qZVq1a88847ZbZJSkqiR48e+Pn50adPHzZt2uTaExcRl1BAEpFaYcqUKbz//vtMnz6d9evXc88993DdddexaNGi0m3uu+8+XnjhBVasWEHDhg0ZOnQohYWFgBlsRowYwahRo1i3bh2PP/44jzzyCDNmzCjdf8yYMXzyySe8/PLLbNiwgTfeeIN69eqVqeNf//oXL7zwAitXrsTDw4Mbb7yxWs5fRKqWJqsVkRovPz+fkJAQ5s2bR+/evUvX33TTTeTm5nLLLbfQv39/Zs2axciRIwE4ePAgTZo0YcaMGYwYMYLRo0ezb98+fv7559L977//fr7//nvWr1/PX3/9Rdu2bZk7dy7x8fHH1bBw4UL69+/PvHnzGDBgAAA//PADQ4YM4fDhw/j4+Lj4XRCRqqQWJBGp8bZs2UJubi4DBw6kXr16pY/333+frVu3lm53bHgKCQmhbdu2bNiwAYANGzZw7rnnljnuueeey+bNmykuLmbNmjU4HA4uuOCCk9bSpUuX0uVGjRoBkJaWdtbnKCLVy8PqAkREzlZ2djYA33//PY0bNy7znLe3d5mQdKZ8fX0rtZ2np2fpss1mA8z+USJSs6gFSURqvA4dOuDt7c3OnTtp1apVmUdUVFTpdkuXLi1dPnToEH/99Rft27cHoH379ixZsqTMcZcsWUKbNm1wOBx07twZp9NZpk+TiNReakESkRovICCASZMmcc899+B0Ounbty8ZGRksWbKEwMBAmjVrBsCTTz5JgwYNCA8P51//+hehoaEMHz4cgHvvvZeePXsyefJkRo4cSWJiIq+++iqvvfYaANHR0dxwww3ceOONvPzyy3Tt2pUdO3aQlpbGiBEjrDp1EXERBSQRqRUmT55Mw4YNmTJlCtu2bSM4OJju3bvz8MMPl17ievrpp/nnP//J5s2biYmJ4dtvv8XLywuA7t2789lnn/Hoo48yefJkGjVqxJNPPsnYsWNLX+P111/n4Ycf5vbbb+fAgQM0bdqUhx9+2IrTFREX011sIlLrldxhdujQIYKDg60uR0RqAPVBEhERESlHAUlERESkHF1iExERESlHLUgiIiIi5SggiYiIiJSjgCQiIiJSjgKSiIiISDkKSCIiIiLlKCCJiIiIlKOAJCIiIlKOApKIiIhIOQpIIiIiIuX8P5aKgpXw3NYDAAAAAElFTkSuQmCC",
      "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": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHHCAYAAABXx+fLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2TUlEQVR4nO3dd3gUVdvH8e+mFyCBBFIghCYdQo80K4qKNJXiA1LsCIpgQVTA8ghWHlQQ1BfEgoIiIAqKVEVAqkiv0iEJAdJJ2533j4GFmARI3ST7+1zXXtmdPXP2nskme++ZUyyGYRiIiIiIOBEXRwcgIiIiUtyUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJFLKffTRR1gsFiIjIx0dSqlz+PBhBg8eTO3atfHy8iI4OJgbbriBcePGOTo0ESliFq0FJlK6tW/fnpMnT3L48GH2799PnTp1HB1SqXDgwAFat26Nt7c3Dz74IDVq1ODUqVNs2bKFn3/+mdTUVEeHKCJFyM3RAYhI/h06dIi1a9cyb948HnvsMWbNmlViWy+Sk5Px9fV1dBh2//vf/0hKSmLr1q2Eh4dneS4mJsZBUTlWSkoKPj4+jg5DpFjoEphIKTZr1iwqVqxIly5duO+++5g1a1aO5eLi4hgxYgQ1atTA09OTatWqMWDAAGJjY+1lUlNTeeWVV6hbty5eXl6EhIRwzz33cPDgQQBWrVqFxWJh1apVWeo+fPgwFouFmTNn2rcNGjSIcuXKcfDgQe666y7Kly9Pv379AFi9ejW9evWievXqeHp6EhYWxogRIzh//ny2uPfs2UPv3r2pXLky3t7e1KtXj5deegmAlStXYrFYmD9/frb9vv76aywWC+vWrcv13B08eJBq1aplS34AqlSpkuWxxWLhlVdeyVauRo0aDBo0yP545syZWCwW/vjjD5566ikqV66Mv78/jz32GOnp6cTFxTFgwAAqVqxIxYoVef7557m8Ef7iuXz33XeZMmUKtWrVwsfHh9tvv51jx45hGAavv/461apVw9vbm+7du3P27NksMf3www906dKF0NBQPD09qV27Nq+//jpWqzVLuZtuuonGjRuzefNmbrjhBnx8fHjxxRcZOHAggYGBZGRkZDve22+/nXr16uV6TkVKE7UAiZRis2bN4p577sHDw4P777+fqVOnsnHjRlq3bm0vk5SURMeOHdm9ezcPPvggLVq0IDY2loULF3L8+HECAwOxWq3cfffdLF++nL59+zJ8+HASExNZunQpO3bsoHbt2nmOLTMzk86dO9OhQwfeffdde8vCd999R0pKCkOGDCEgIIANGzbw4Ycfcvz4cb777jv7/tu2baNjx464u7vz6KOPUqNGDQ4ePMiPP/7IG2+8wU033URYWBizZs2iZ8+e2c5L7dq1adu2ba7xhYeHs2zZMlasWMEtt9yS5+O7kieffJLg4GBeffVV/vzzTz755BP8/f1Zu3Yt1atXZ/z48SxevJh33nmHxo0bM2DAgGzxp6en8+STT3L27FnefvttevfuzS233MKqVasYNWoUBw4c4MMPP+TZZ59lxowZ9n1nzpxJuXLlGDlyJOXKlWPFihWMHTuWhIQE3nnnnSyvc+bMGe6880769u1L//79CQoKwtfXly+++IIlS5Zw991328tGRUWxYsWKEtvCKJJnhoiUSps2bTIAY+nSpYZhGIbNZjOqVatmDB8+PEu5sWPHGoAxb968bHXYbDbDMAxjxowZBmBMnDgx1zIrV640AGPlypVZnj906JABGJ999pl928CBAw3AeOGFF7LVl5KSkm3bhAkTDIvFYhw5csS+7YYbbjDKly+fZdvl8RiGYYwePdrw9PQ04uLi7NtiYmIMNzc3Y9y4cdle53I7duwwvL29DcBo1qyZMXz4cGPBggVGcnJytrJAjvWFh4cbAwcOtD/+7LPPDMDo3Llzljjbtm1rWCwW4/HHH7dvy8zMNKpVq2bceOON9m0Xz2XlypWzHNPo0aMNwIiIiDAyMjLs2++//37Dw8PDSE1NtW/L6fw+9thjho+PT5ZyN954owEY06ZNy1LWarUa1apVM/r06ZNl+8SJEw2LxWL8888/2eoXKY10CUyklJo1axZBQUHcfPPNgHmZpk+fPsyePTvL5Y7vv/+eiIiIbK0kF/e5WCYwMJAnn3wy1zL5MWTIkGzbvL297feTk5OJjY2lXbt2GIbBX3/9BcDp06f5/fffefDBB6levXqu8QwYMIC0tDTmzp1r3zZnzhwyMzPp37//FWNr1KgRW7dupX///hw+fJj333+fHj16EBQUxKeffpqv473ooYceyhJnZGQkhmHw0EMP2be5urrSqlUr/vnnn2z79+rVCz8/vyz7A/Tv3x83N7cs29PT0zlx4oR92+XnNzExkdjYWDp27EhKSgp79uzJ8jqenp4MHjw4yzYXFxf69evHwoULSUxMtG+fNWsW7dq1o2bNmtd8HkRKMiVAIqWQ1Wpl9uzZ3HzzzRw6dIgDBw5w4MABIiMjiY6OZvny5fayBw8epHHjxles7+DBg9SrVy/Lh2tBubm5Ua1atWzbjx49yqBBg6hUqRLlypWjcuXK3HjjjQDEx8cD2JOCq8Vdv359WrdunaXv06xZs7j++uuvaTRc3bp1+fLLL4mNjWXbtm2MHz8eNzc3Hn30UZYtW3bNx/pv/07aLiYzYWFh2bafO3euQPsDWerYuXMnPXv2xM/PjwoVKlC5cmV7Mnjx/F5UtWpVPDw8sr3+gAEDOH/+vL1/1d69e9m8eTMPPPBALkcsUvqoD5BIKbRixQpOnTrF7NmzmT17drbnZ82axe23316or5lbS9C/O9de5OnpiYuLS7ayt912G2fPnmXUqFHUr18fX19fTpw4waBBg7DZbHmOa8CAAQwfPpzjx4+TlpbGn3/+yeTJk/NUh6urK02aNKFJkya0bduWm2++mVmzZtGpU6cr7pfbsbu6ul7zdiOHmUjysv/ldcTFxXHjjTdSoUIFXnvtNfv8Rlu2bGHUqFHZzu/lrUWXa9iwIS1btuSrr75iwIABfPXVV3h4eNC7d+8cy4uURkqAREqhWbNmUaVKFaZMmZLtuXnz5jF//nymTZuGt7c3tWvXZseOHVesr3bt2qxfv56MjAzc3d1zLFOxYkXA/JC93JEjR6457u3bt7Nv3z4+//zzLB1/ly5dmqVcrVq1AK4aN0Dfvn0ZOXIk33zzDefPn8fd3Z0+ffpcc0z/1qpVKwBOnTpl31axYsVsx52enp6lTEmwatUqzpw5w7x587jhhhvs2w8dOpTnugYMGMDIkSM5deoUX3/9NV26dLG/B0TKAl0CEyllzp8/z7x587j77ru57777st2GDRtGYmIiCxcuBODee+/l77//znG4+MWWg3vvvZfY2NgcW04ulgkPD8fV1ZXff/89y/MfffTRNcd+sQXj8lYPwzB4//33s5SrXLkyN9xwAzNmzODo0aM5xnNRYGAgd955J1999RWzZs3ijjvuIDAw8KqxrF69Oseh3osXLwbIMty7du3a2Y77k08+ybUFyFFyOr/p6el5+h1ddP/992OxWBg+fDj//PPPVftUiZQ2agESKWUudk7t1q1bjs9ff/31VK5cmVmzZtGnTx+ee+455s6dS69evXjwwQdp2bIlZ8+eZeHChUybNo2IiAgGDBjAF198wciRI9mwYQMdO3YkOTmZZcuW8cQTT9C9e3f8/Pzo1asXH374IRaLhdq1a/PTTz/ladLA+vXrU7t2bZ599llOnDhBhQoV+P7773PsB/PBBx/QoUMHWrRowaOPPkrNmjU5fPgwixYtYuvWrVnKDhgwgPvuuw+A119//Zpieeutt9i8eTP33HMPTZs2BWDLli188cUXVKpUiaefftpe9uGHH+bxxx/n3nvv5bbbbuPvv/9myZIl15RoFad27dpRsWJFBg4cyFNPPYXFYuHLL7/M8TLb1VSuXJk77riD7777Dn9/f7p06VIEEYs4jhIgkVJm1qxZeHl5cdttt+X4vIuLC126dGHWrFmcOXOGgIAAVq9ezbhx45g/fz6ff/45VapU4dZbb7V3UnZ1dWXx4sW88cYbfP3113z//fcEBATQoUMHmjRpYq/7ww8/JCMjg2nTpuHp6Unv3r3tc9lcC3d3d3788UeeeuopJkyYgJeXFz179mTYsGFERERkKRsREcGff/7JmDFjmDp1KqmpqYSHh+fYD6Vr165UrFgRm82Wa2L4by+++CJff/01v/32G7NmzSIlJYWQkBD69u3LmDFjsox2euSRRzh06BDTp0/nl19+oWPHjixdupRbb731ml6ruAQEBPDTTz/xzDPP8PLLL1OxYkX69+/PrbfeSufOnfNc34ABA/jpp5/o3bs3np6eRRCxiONoLTARKfUyMzMJDQ2la9euTJ8+3dHhlBk//PADPXr04Pfff6djx46ODkekUKkPkIiUegsWLOD06dPZZlSWgvn000+pVasWHTp0cHQoIoVOl8BEpNRav34927Zt4/XXX6d58+b2+YSkYGbPns22bdtYtGgR77//foEmwxQpqXQJTERKrUGDBvHVV1/RrFkzZs6cec19keTKLBYL5cqVo0+fPkybNq1QJ8gUKSmUAImIiIjTUR8gERERcTpKgERERMTp6MJuDmw2GydPnqR8+fLq/CciIlJKGIZBYmIioaGh2dYi/DclQDk4efJktlWXRUREpHQ4duyYfaLX3CgBykH58uUB8wRWqFDBwdGIiIjItUhISCAsLMz+OX4lSoBycPGyV4UKFZQAiYiIlDLX0n1FnaBFRETE6SgBEhEREaejBEhEREScjvoAFYDVaiUjI8PRYZRK7u7uuLq6OjoMERFxUkqA8sEwDKKiooiLi3N0KKWav78/wcHBmmtJRESKnRKgfLiY/FSpUgUfHx99gOeRYRikpKQQExMDQEhIiIMjEhERZ6MEKI+sVqs9+QkICHB0OKWWt7c3ADExMVSpUkWXw0REpFipE3QeXezz4+Pj4+BISr+L51D9qEREpLgpAconXfYqOJ1DERFxFCVAIiIi4nSUAEm+1KhRg0mTJjk6DBERkXxRJ2gnctNNN9GsWbNCSVw2btyIr69vwYMSERFxALUAiZ1hGGRmZl5T2cqVK6sjuIhIEbPaDOJTNFCkKCgBchKDBg3it99+4/3338disWCxWJg5cyYWi4Wff/6Zli1b4unpyR9//MHBgwfp3r07QUFBlCtXjtatW7Ns2bIs9f37EpjFYuH//u//6NmzJz4+Plx33XUsXLiwmI9SRKT0ybDaOBSbzMq9Mcxcc4hXFu7kwZkbueW9VdQf8zMRr/1Kn4/Xsf14vKNDLVN0CawQGIbB+Qxrsb+ut7vrNY+kev/999m3bx+NGzfmtddeA2Dnzp0AvPDCC7z77rvUqlWLihUrcuzYMe666y7eeOMNPD09+eKLL+jatSt79+6levXqub7Gq6++yttvv80777zDhx9+SL9+/Thy5AiVKlUq+MGKiJRiqRlWjp5N4XBssvnzTDJHzpg/T8alYrUZV9x//aGzdJ38B/c0r8qznesR6u9dTJGXXUqACsH5DCsNxy4p9tfd9VpnfDyu7Vfo5+eHh4cHPj4+BAcHA7Bnzx4AXnvtNW677TZ72UqVKhEREWF//PrrrzN//nwWLlzIsGHDcn2NQYMGcf/99wMwfvx4PvjgAzZs2MAdd9yR52MTESltktIyOXJZYnMkNoUjZ83Hp+JTr7ivl7sLNQJ8CQ/wIfzCz4uPDQPe+3UvC7aeZN5fJ1i0/RQPd6zJkJvqUM5TH+P5pTMntGrVKsvjpKQkXnnlFRYtWsSpU6fIzMzk/PnzHD169Ir1NG3a1H7f19eXChUq2Je7EBEpS3adTGDZ7mh7S86RM8nEJqVfcZ/ynm7UCPSleoAPNS4kOheTnCrlPa/Yoj+pb3MGt6/JG4t2s+HwWaasPMicjcd4ulNd+rYOw81VPVrySglQIfB2d2XXa50d8rqF4d+juZ599lmWLl3Ku+++S506dfD29ua+++4jPf3Kf9zu7u5ZHlssFmw2W6HEKCJSUmw7Hse9U9eSYc1+2aqSr0eW1pvwyxKdij7uBZoANiLMnzmPXc+vu6J58+c9HIpN5uUFO/h87WFevKsBN9WrrAlm80AJUCGwWCzXfCnKkTw8PLBar95Xac2aNQwaNIiePXsCZovQ4cOHizg6EZGSLyE1g2Ff/0WG1aB5dX86NQiyJzzVA3yo4OV+9UoKwGKx0LlRMDfXq8Ks9Ud4f/l+9sckMXjmRjrUCeTFuxrQMLRCkcZQVpT8T20pNDVq1GD9+vUcPnyYcuXK5do6c9111zFv3jy6du2KxWJhzJgxaskREadnGAYvfL+No2dTqFbRm5mD2uDnU7QJT2483FwY3L4m97SoxpSVB5i55jB/HIily4erua9FNZ7tXI+gCl4Oia200EVDJ/Lss8/i6upKw4YNqVy5cq59eiZOnEjFihVp164dXbt2pXPnzrRo0aKYoxURKVm++vMIi7dH4eZi4cP7mzss+bmcn7c7L97VgOXP3MjdTUMwDPhu83FuemcVE5fuIznt2uZ2c0YWwzCuPPbOCSUkJODn50d8fDwVKmRtSkxNTeXQoUPUrFkTLy9l1wWhcykipcWOE/Hc89Fa0q02Xu7SgIc71nJ0SDnacvQcbyzazeYj5wCoUt6TZ26vy30tw3B1Kfv9g670+f1vagESERG5gsTUDIZ+vYV0q41ODarwUIeajg4pVy2qV2Tu4235qF8LqlfyISYxjVHfb6fLB6v5fd9pR4dXoigBEhERyYVhGIyet50jZ1Ko6u/Nu70iSvxIK4vFwl1NQlg68gZe7tKACl5u7IlKZMCMDQycsYG9UYmODrFEUAIkIiKSi683HOWnbadwc7Hwwf3N8ffxcHRI18zTzZWHO9bi9+dv5sH2NXF3tfDbvtPc+f7vjJ63jZjEK0/OWNYpARIREcnBrpMJvPrjLgCe61yPluEVHRxR/vj7eDC2a0OWjriROxsHYzPgmw3HuPmdVXy4fD/n04t/KaeSQAmQiIjIvySlZZr9fjJt3FK/Co+U0E7PeVEj0Jep/Vvy3eNtiQjzJzndyntL93Hzu6uYu/k4tqusR1bWKAESERG5jGEYvDR/O4dikwnx8+K9XhG4lKERVK1rVGLBE+344P7mVPX3JiohlWe/+5u7P/yDdQfPODq8YqMESERE5DJzNh7jh60ncb0w309F39LT7+daWSwWukWEsvyZG3nhzvqU93Rj16kE7v/0Tz5cvh9nmCFHCZCIiMgFe6ISGLdwJwDP3F6XVjUqOTiiouXl7srjN9bmt+dvpm/rMADeW7qPoV9vKfOTKCoBEhERAZLTMhk6awtpmTZurFuZx2+o7eiQik0lXw/evLcpb97TBHdXC4u3R3Hv1LUcO5vi6NCKjBIguWY1atRg0qRJjg5DRKTQGYbBmAU7OHg6maAKnkzsXbb6/Vyrvm2q880j1xNYzpM9UYl0m1x2+wUpARIREaf33ebjzPvrBC4W+KBvcwLKeTo6JIdpVaMSC4e1p0lVP86lZNB/+nq+WHe4zPULUgIkIiJObV90ImN/2AHAyNvqElkrwMEROV6ovzffPd6W7s1CsdoMxv6wk9HztpOeaXN0aIVGCZCT+OSTTwgNDcVmy/rm7d69Ow8++CAHDx6ke/fuBAUFUa5cOVq3bs2yZcuuWu/59Ez2RCVwODaZ1AznnExLREqvlHSz309qho2O1wXyxE11HB1SieHl7sqkPs0YfWd9LBaYvfEY//n0T04npjk6tEKhBKgwGAakJxf/LQ/Nkb169eLMmTOsXLnSvu3s2bP88ssv9OvXj6SkJO666y6WL1/OX3/9xR133EHXrl05evRornWmZ9o4fCaF9EwbCakZ7I9O4mTceay2svMNQUTKtnE/7GR/TBJVynvyvz7NnLLfz5VYLBYeu7E2nw1qTXkvNzYdOUe3yX+w7Xico0MrMDdHB1AmZKTA+NDif90XT4KH7zUVrVixInfeeSdff/01t956KwBz584lMDCQm2++GRcXFyIiIuzlX3/9debPn8/ChQsZNmxYtvqsNoMjZ5LJsNrwcnPFw82FhNQMYpPSiEvJINjPk4o+HiV+0UARcV7fbz7Od5uP42KB9/s2J9CJ+/1czU31qvDD0PY8/MUm/jmdTK9p63j7vqZ0b1bV0aHlm1qAnEi/fv34/vvvSUszmy9nzZpF3759cXFxISkpiWeffZYGDRrg7+9PuXLl2L17d44tQIZhcOxsCuczrLi5uFAj0Icagb7UDPTF082VTJuN4+fOcyAmqczPIyEipdOBmEReXmD2+xl+a13a1la/n6upVbkcC4a25+Z6lUnLtDF89lYm/LwbayldQkMtQIXB3cdsjXHE6+ZB165dMQyDRYsW0bp1a1avXs3//vc/AJ599lmWLl3Ku+++S506dfD29ua+++4jPT09Wz2n4lNJSM3AxWIhPMAHDzdXAMp7uXNdkBtnktKJSUjlfIaVg6eT8PfxILiCFx5uyrdFxPHOp1sZOusvzmdYaVc7gGG3qN/Ptarg5c7/DWzNe7/u5aNVB/n4t3/YG5XI+32b4+ft7ujw8qREfCJNmTKFGjVq4OXlRWRkJBs2bMi17E033YTFYsl269KlS5Zyu3fvplu3bvj5+eHr60vr1q2v2J+lQCwW81JUcd/yeHnJy8uLe+65h1mzZvHNN99Qr149WrRoAcCaNWsYNGgQPXv2pEmTJgQHB3P48OFsdSSnZRKbZLYgVavoja9n1hzaxWKhcnlP6gaXp9KF6ePjUtLZF51IdEKq0y22JyIlz6s/7mRvdCKB5TyZ1LcZrur3kyeuLhaev6M+H9zfHC93F1btPU3PKWs4EJPk6NDyxOEJ0Jw5cxg5ciTjxo1jy5YtRERE0LlzZ2JiYnIsP2/ePE6dOmW/7dixA1dXV3r16mUvc/DgQTp06ED9+vVZtWoV27ZtY8yYMXh5eRXXYZVY/fr1Y9GiRcyYMYN+/frZt1933XXMmzePrVu38vfff/Of//wn24gxw4D48xkABFfwwt8n9/Vx3F1dqFbRh+uqlMPXww2bYRCdkMq+6ETiz6eXufkkRKR0WPDXCWZvPIbFAu/3bUaV8vpcyK9uEaHMfbwdoX5e/BObTM8pa1ixJ9rRYV0zhydAEydO5JFHHmHw4ME0bNiQadOm4ePjw4wZM3IsX6lSJYKDg+23pUuX4uPjkyUBeumll7jrrrt4++23ad68ObVr16Zbt25UqVKluA6rxLrllluoVKkSe/fu5T//+Y99+8SJE6lYsSLt2rWja9eudO7c2d46BJCaYSXzQkJU0ceDyuWvrbOgt4cbtSr7Ur2SD+6uLqRbbRw5k8IhDZsXkWJ28HQSL87fDsCTt1xH+zqBDo6o9Gtc1Y+FT3agdY2KJKZl8tDnm/ho1YFS8SXXYjgwyvT0dHx8fJg7dy49evSwbx84cCBxcXH88MMPV62jSZMmtG3blk8++QQAm82Gn58fzz//PH/88Qd//fUXNWvWZPTo0Vle43JpaWn2jsEACQkJhIWFER8fT4UKFbKUTU1N5dChQ9SsWdNpWpQyrDYOxiSRbrXh6+lGzUBfXPIxustqMzidmMbppDTzjyMzneQzp6hVsyZBlSpcvYJicjY5ne0n4mkQUl7fDkXKiNQMKz2mrGFPVCLX16rErIev16WvQpSeaeOVH3fy9Xqzq0nXiFDevrcp3h6uxRpHQkICfn5+OX5+/5tDW4BiY2OxWq0EBQVl2R4UFERUVNRV99+wYQM7duzg4Ycftm+LiYkhKSmJN998kzvuuINff/2Vnj17cs899/Dbb7/lWM+ECRPw8/Oz38LCwgp2YGWIzWZw5EwK6VYbnm6uhFfyyVfyA+Z142A/L+oFlcPP2x0DSEqzMvCzDXyx7jCZVsfMHxR/PoOlu6J57cdd3DHpd1q8vpSBMzZw67u/sXJPzpdiRaR0ee2nXeyJSiSwnAcf9G2u5KeQebi5ML5nE/7bozFuLhZ+/Psk901by4m4844OLVelehTY9OnTadKkCW3atLFvu9hvpXv37owYMQKAZs2asXbtWqZNm8aNN96YrZ7Ro0czcuRI++OLLUDOzjAMjp1LISU9E1cXCzUCfHBzLXjO7OHmSniAL+XcbJyLtpCYmsnYH8xvDmO7NqRd7aJtlk5Jz2Tj4XOsPRjLnwfPsP1EPP/um13J14Ozyek8+PlGnr29Hk/cVFtzGomUUj/+fZKv1x/FYoH/9WlGlQpq2S0q/a8P57oq5Rgyaws7TybQ7cM/mNq/JW1qVnJ0aNk4NAEKDAzE1dWV6Oisnaaio6MJDg6+4r7JycnMnj2b1157LVudbm5uNGzYMMv2Bg0a8Mcff+RYl6enJ56emgDr36ITUok/n4HFYiE8wBdP98JtyvT1dKdKeU+euuU6Jiw9yJ6oRP7z6XruaBTMS10aEFYpb8P8c5OaYWXL0XOsO3iGdQfPsPVYHJn/ynhqBvrStnYAbWsFcH2tAPy83Xn1x53MWn+Ud5bsZfepBN6+ryk+HqX6O4OI0zkUm8zoeWa/n6E31aHjdZUdHFHZF1krgIXD2vPIF5vZfSqBfv/3J692a8x/Iqs7OrQsHPrf3MPDg5YtW7J8+XJ7/xybzcby5ctznH34ct999x1paWn0798/W52tW7dm7969Wbbv27eP8PDwQo2/LDubnE7MhfVeqvl7U86zaN4qFouF7s2r0jkijIlL9/HVn0f4ZWcUK/bG8NgNtRhyU+08Jx3pmTa2HY9j7YWEZ/PRc9kW8Kvq70272gFm0lM7gBA/72z1vNGzCQ1DKzDuh538tO0UB08n88kDLQstMRORopWaYWXorC0kpWXSpkYlnu50naNDchrVKvrw/ZC2PDd3G4u2neLF+dvZdSqesXc3KjFzwjn86+zIkSMZOHAgrVq1ok2bNkyaNInk5GQGDx4MwIABA6hatSoTJkzIst/06dPp0aMHAQHZZ+987rnn6NOnDzfccAM333wzv/zyCz/++COrVq0qtLhLQw/3/EpKzeDEOfO6bZXyXlT0zX24e0Fcfg79fTx4rbv5DeG1H3ex9uAZPlxxgO82HWf0XfXpFhGa6yUoq81gx4l41v1zhrUHz7Dx0FnO/2uEWZXynrStHWAmPbUCCavkfU2XtPpFhlM3qDxDvjK/yXSfsoYp/2mhWWNFSoE3Fu1m16kEKvl68MH9zQvlEr5cOx8PNybf35yGIRV499e9fPXnUfZFJzG1XwsCSsCyIw4dBXbR5MmTeeedd4iKiqJZs2Z88MEHREZGAubEhzVq1GDmzJn28nv37qV+/fr8+uuv3HbbbTnWOWPGDCZMmMDx48epV68er776Kt27d7+meK7Ui9xqtbJv3z6qVKmSY/JV2qVemL3ZajPw93YnrJJPkfV9OXPmDDExMdStWxdX10uX1wzDYMnOKP67aDfHLyRircIrMq5rI5pU88NmM9gTlci6f86w7mAs6w+dJTE165IblXw9uL5WJdrWDqRtrQBqV/Yt0HGcjDvPo19uYseJBFxdLIy9uyED2oarX5BICbV4+ymemLUFgJmDW3NTPU2D4kjLdkXz9JytJKVlUtXfm08GtKRRqF+hv05eRoGViASopLnaCTx16hRxcXFUqVIFH5+iSxCKW6bVxtGzKeYCp+6uhFX0KZKVkQ3DICUlhZiYGPz9/QkJCcmxXGqGlf9b/Q9TVh7kfIYViwUia1Zib1Qi51IyspQt7+VGZM0A+2WtekHlCz321AwrL3y/jQVbzWVP+rQK47UejfB0K95hniKFISktk9X7TpNutWGxWHCxmDO5u1i48PjSNov9ucufBxeXq5c375tzggX4euBVyH0Jc3LkTDJ3f/AHiWmZDLmpNqPuqF/krylXdyAmkYc/38ThMyl4ubvwbq8I7m5auAuJKwEqoKudQMMwiIqKIi4urviDKyKGYRCblE5apg03F3M5i6IeJurv709wcPBVE8hT8ed58+c9/LD10nprPh6utK5RyZ7wNAr1K5ZhrYZh8Onqf3jz5z3YDGhR3Z9p/VtqVImDGIZRZr6AFKclO6MY98NOohJSi/21y3m6EVDOg0q+HgT4ehJ48X45836AryeVfD0ILOdBRV8P3PN42Sot08p9U9ex/UQ8rcIrMvvR63XpqwSJT8lg2DdbWL0/ljY1KzH7kesL9cuqEqACutYTaLVaycjIyPX50sIwDN78eQ/Ldkfj6+HGB/c3p0agb5G+pru7e5bLXtfir6Pn2HosjqbV/GhazT/P/xgL02/7TvPk11tISM0kqIInHz/QimZh/g6Lp7RLzbASfz6D+PMZxKVkEJeSTtz5DBIuPj6fTvz5TOJS0u1l4s9nkJCaQWTNSswc3KZYWhZKu5Nx5xm3cCdLd5kjb6v6e1Mj0AebDWyGgWGYP82b+b/BZmR97vIyl+5feX+rzSAlPZMMa94/bvy83Qko50HghcQooNylZOnfSZS/jwev/7SLmWsPU9HHnUVPdSTUP/sAB3GsTKuNqasOcn9kdQILuS+QEqACyssJLAs+WL6fiUv34epiYebg1homeo0OxybzyBeb2B+TZJ8E7L6W1RwdlsPZbAa7oxI4m5xuT1TMpOXS47jzGcTbE5sMUjMKNglmt4hQ3u/bTK1BubDaDD5fe5j3ft1LcroVNxcLj91Yiydvua7YEkfDMEhIzeRscjpnktKITUq33z+TnE5sUtqFx+mcSTbv53XtZBcL9n0+G9Sam+ur34+zUQJUQM6UAP2w9QTDZ28FYHzPJiVunoaSLiktkxFzttq/UT/YviYv3lXfaZvcT8WfZ+isLWw5GpfnfV0s5rd9fx8PKni74+/tjr+P+dPP2x0/Hw/7fX8f83Y4NoXHv9pMps3g2dvrMuwWDXP+tx0n4nlx/na2HY8HoGV4RSbc04S6QeUdHNmVWW0G8eczsiZLyRfvp5mJUlI6sReSpbjL+gWq34/zUgJUQEWVANlsBqv2xdDxusoOvXxz0eYjZ7n/0/WkZ9p4pGNNXurS8Oo7STY2m8Gk5fv5YPl+ANrXCWDy/S2KbPqAkmrNgVie/OYvzian4+3uSniAT5ZE5mJy43f5Y28P876PO+U83PLVF+CrP4/w8oIdAEzr34I7Gufcqd7ZJKdl8r+l+5ix5hA2wxwo8MKd9bm/dfUiGdzgaBlWG+eS00lJtxIeUHYGp0jeKAEqoKJKgFbvP80D0zcQWM6Te1tWpU+rMGpVLldo9efF0TMp9PxoDWeS07mtYRDT+rfU2jgF9MuOU4z89m9S0q2EVfLm0wGtqB9ctlsQwUwAp/52kPd+3YvNgIYhFZjavwXhAUXbj+xyryzcycy1h/F2d+W7x9vSuGrhD68tTVbsiWbMgp32dZjubhrC2K4NtbivlHlKgAqoqBKgH7ae4PWfdhGblG7f1qZGJfq0DuOuJiHFtmpu/PkM7p26lgMxSTSuWoFvH2urJR4KyZ6oBB75YhPHzp7Hx8OVib0jynSLRHxKBiO/3cryC4vG9m5Vjde6Ny72DsmZVhuDZ25k9f5YQvy8+GFoe6ccmRedkMqrP+5k8XZzMemq/t78t2djbtYcOOIklAAVUFH2Acqw2li+O4ZvNx1j1d4Ye4e98p5udG0WSt/WYTSp6ldkzbcZVhuDP9vIHwdiCa7gxQ/D2hPkhB8URelccjrDvtnCmgNnAHjqljo83alumbvssONEPENmbebY2fN4uLnwevdG9GntuD5k8ecz6PnRGv45nUyzMH9mP3q904wMs9kMZq0/wtu/7CUxzVy8+OEONRne6Tp9uRGnogSogIqrE3RUfCpzNx/j203HOXo2xb69fnB5+rQOo2fzqvj7FF4/EsMweHH+dr7ZcAwfD/NSQVHMxClmi8SEn/cw/Y9DAHRqEMT/+kRQ3svdwZEVjjkbjzLmh52kZ9oIq+TN1H4tS8Rlp0OxyfSYsob48xl0bxbKpD5lf2TY7lMJvDh/O39d6HgeEebPhAvr2Ik4GyVABVTco8BsNoM//znDnE3H+HlHlH3hTg83Fzo3CqZPqzDa1Q4ocAvCJ78fZPziPbhY4NMBrbi1QVBhhC9X8P3m44yev530TBt1qpTj0wGtqFnEcywVpdQMK2MW7OC7zccBuLV+FSb2boafT8lJ7NYeiGXAjA1lfmTY+XQr7y/fz/+t/odMm0E5Tzee61yP/teHqz+fOC0lQAXkyGHw8SkZLNh6gtkbj7H7VIJ9e7WK3vRuFUavVtVyXLn8an7ZEcWQWZsxDBh7d0Me7FCzMMOWK9h6LI7HvtxEdEIaFbzc+PA/Lbixbumba+nImWSGfLWFXacScLHAM7fXY8iNtUvkpb2yPjLst32neXnBdo6dNTs539EomFe6NSLYT5ezxbkpASqgkjAPkGEY7DiRwJxNR/nhr5MkppmLfbpY4Ia6lenbOoxb6gfh4Xb14fTbj8fT6+O1pGbYeOD6cF7r3qjMXxYoaWISUnn8q81sORqHiwVG3VGfR2+oVWp+D0t3RTPy260kpmYScGFl7fZ1Ah0d1hWN+2EHn687UqZGhp1OTOP1n3ax8G9zWZgQPy9e696Y2xqqNVcElAAVWElIgC53Pt3KzztOMWfjMdYfOmvfHuDrwT0tqtKndRh1quQ8qdnJuPP0mLKGmMQ0bqxbmekDWzntJH2OlpZpZeyCnczZdAyA7s1CeevepiW6o26m1cbEpfv4aNVBwFz7bEq/FvlqhSxu2UaGDWtfaoeB22wGczYdY8Li3SSkZuJigUHtajLy9rqU81QnZ5GLlAAVUElLgC53KDaZbzcdY+7m45xOTLNvbxlekT6twujSNATfC/8Qk9Iy6TVtHbtPJVAvqDxzh7QtM51wSyvDMPjyzyO89uMuMm0GjatW4OMHWlG1BK5XdDoxjae++Yt1/5ij2Qa1q8GLdzW4plbHkqIsjAzbH53Ii/O3s/HwOQAaV63AhJ5NaVKt9LdoiRQ2JUAFVJIToIsyrTZW7j3NnI3HWLk3BuuF8fS+Hq50jQilV6swpqw8wIo9MQSW82TB0HZUq+jj4KjlonUHzzD06y2cTU6nkq8HfVqH0S0ilPrB5UvEZbFNh88y9OstRCek4ePhylv3NqVrRKijw8qX0joyLDXDypSVB5j220EyrAY+Hq6MvK0ug9rVUCuuSC6UABVQaUiALheTkMrcLcf5duMxDp9JyfKcp5sLcx5rq5XKS6Dj51J49IvN7Lqss3udKuXoFhFK14hQh4wWMwyDz9YcZvzi3WTaDOpUKce0/i1yvcRaWlw+Muy5zvUYenMdR4d0RWsOxPLS/O32v+dODarwavfGJbKlUKQkUQJUQKUtAbrIMAzWHzrLnI3HWLz9FBlWG5P/04K7mpStETBlSVqmlaW7olm49SSr9p4m3XppVfQmVf3oFhFKl6YhhBbDB19SWiajvt/Gom2nAHP5hLfubWq/pFralYaRYWeS0nhj8W7mbTkBQJXynrzarRF3NA4uFa1WIo6mBKiASmsCdLmE1AwSUzP1jbEUSUjNYMmOKH7cdoo1B2LtlzXBXDKla0QIdzUJIaCcZ6G/9v7oRB77ajP/nE7GzcXCy10aMLBdjTL3oVtSR4YZhsF3m44z/ufdxKVkYLHAA9eH82znelRQvz2Ra6YEqIDKQgIkpVtsUho/74jix60n2XD40sg/VxcL7esE0rVpCJ0bBxfKh+MPW08wet52UtKtBFfwYkq/FrQMr1jgekuikjgy7EBMIi/O38GGCyM8G4RUYHzPxjSvXjZ/ByJFSQlQASkBkpLkZNx5Fm07xcK/T7L9RLx9u4erCzfVq0y3ZqHcWj8oz4vppmfaeGPRLj5fdwSA9nUCeL9vcwKLoIWpJIlPyaDnVMePDEvNsDJ5xQE+/t3s5OztbnZyHtxenZxF8ksJUAEpAZKS6lBsMj/9fZKFf59kf0ySfbuPhyu3NQyia9NQbqhb+apD1U/GnWfo11vs60cNu7kOI26r6zRLKFw+MqxHs1D+V8wjw1bvP83LC3Zw5EIn51vrV+HV7o00UlOkgJQAFZASICnpDMNgb3QiC7ee5MdtJ+1LIgBU8HLjzsYhdGsWyvW1ArIlNX/sj+Wp2X9xNjmdCl5u/K9PM6dcF27tgVgemLEBazGODDudmMZ/F+3ih63mTM7BFbx4pVtDOjdSJ2eRwqAEqICUAElpYhgGW4/F8ePfp/hp20liLpsgM7CcJ3c3DaFrRAjNwioyddUB3lu6D8OARqEVmNqvJdUDnLfVIevIsJbc0Ti4SF7HZjOYvfEYb/58aSbnAW1r8MztdTU5qUghUgJUQEqApLSy2gw2HDrLwr9P8vOOU8SlZNifK+/lRmKquaZc39ZhvNKtUambFbkoXD4ybO6QtjQKLdyRYXujzJmcNx+5NJPz+J5NaFrNv1BfR0SUABWYEiApC9Izbaw5EMuPf59kyc4oktOteLq58HqPxvRuFebo8EqMy0eGhfp5saCQRoadT7fywYr9fPr7P2TaDHw9XHnm9noMaBuuTs4iRUQJUAEpAZKyJjXDypoDsdQI9KV25XKODqfEiU+5sGZYbOGMDFu5N4axP+yw9826vWEQr3RrVCwTWoo4MyVABaQESMT5FMbIsJiEVF79aZd9Nu1QPy9e6daI2xsVTd8iEckqL5/faocVEQFqBvoytV8LXF0sLNh6ko9WHbzmfa02gy/XHebW935j0bZTuFjg4Q41WTryRiU/IiVU2VjkR0SkELSrE8gr3RoxZsEO3lmyl9qVy111ZNjOk/G8OH8Hfx+LAyCimh9v9GxSYpbZEJGcKQESEbnMA9eHcyA6kc/XHWHEnK2EVcp5ZFhyWiaTlu1jxprDWG0G5TzdeK5zPfpfH+40E0qKlGa6BCYi8i9j7m5Ix+sCOZ9h5ZHPNxGTmJrl+eW7o7n9f7/z6epDWG0GdzUJZtnIGxnYroaSH5FSQgmQiMi/uLm6MPn+FtQK9OVkfCqPfbmZ1AwrUfGpPP7lZh76fBMn4s5T1d+bGYNa8VG/lgT7OXZRVRHJG40Cy4FGgYkIZB0Z1rpGRXafSiQpLRNXFwsPd6zJ8Fuvw8dDPQlESgqNAhMRKQSXjwzbePgcSWmZNK/uz09PdmD0nQ2U/IiUYvrrFRG5gnZ1Anm3V1M++f0Q/SKr85821XFRPx+RUk8JkIjIVfRsXo2ezas5OgwRKUS6BCYiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI0ykRCdCUKVOoUaMGXl5eREZGsmHDhlzL3nTTTVgslmy3Ll265Fj+8ccfx2KxMGnSpCKKXkREREobhydAc+bMYeTIkYwbN44tW7YQERFB586diYmJybH8vHnzOHXqlP22Y8cOXF1d6dWrV7ay8+fP588//yQ0NLSoD0NERERKEYcnQBMnTuSRRx5h8ODBNGzYkGnTpuHj48OMGTNyLF+pUiWCg4Ptt6VLl+Lj45MtATpx4gRPPvkks2bNwt3dvTgORUREREoJhyZA6enpbN68mU6dOtm3ubi40KlTJ9atW3dNdUyfPp2+ffvi6+tr32az2XjggQd47rnnaNSoUaHHLSIiIqWbQydCjI2NxWq1EhQUlGV7UFAQe/bsuer+GzZsYMeOHUyfPj3L9rfeegs3Nzeeeuqpa4ojLS2NtLQ0++OEhIRr2k9ERERKJ4dfAiuI6dOn06RJE9q0aWPftnnzZt5//31mzpyJxXJt09VPmDABPz8/+y0sLKyoQhYREZESwKEJUGBgIK6urkRHR2fZHh0dTXBw8BX3TU5OZvbs2Tz00ENZtq9evZqYmBiqV6+Om5sbbm5uHDlyhGeeeYYaNWrkWNfo0aOJj4+3344dO1ag4xIREZGSzaEJkIeHBy1btmT58uX2bTabjeXLl9O2bdsr7vvdd9+RlpZG//79s2x/4IEH2LZtG1u3brXfQkNDee6551iyZEmOdXl6elKhQoUsNxERESm7HL4Y6siRIxk4cCCtWrWiTZs2TJo0ieTkZAYPHgzAgAEDqFq1KhMmTMiy3/Tp0+nRowcBAQFZtgcEBGTb5u7uTnBwMPXq1SvagxEREZFSweEJUJ8+fTh9+jRjx44lKiqKZs2a8csvv9g7Rh89ehQXl6wNVXv37uWPP/7g119/dUTIIiIiUspZDMMwHB1ESZOQkICfnx/x8fG6HCYiIlJK5OXzu1SPAhMRERHJDyVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDidEpEATZkyhRo1auDl5UVkZCQbNmzItexNN92ExWLJduvSpQsAGRkZjBo1iiZNmuDr60toaCgDBgzg5MmTxXU4IiIiUsI5PAGaM2cOI0eOZNy4cWzZsoWIiAg6d+5MTExMjuXnzZvHqVOn7LcdO3bg6upKr169AEhJSWHLli2MGTOGLVu2MG/ePPbu3Uu3bt2K87BERESkBLMYhmE4MoDIyEhat27N5MmTAbDZbISFhfHkk0/ywgsvXHX/SZMmMXbsWE6dOoWvr2+OZTZu3EibNm04cuQI1atXv2qdCQkJ+Pn5ER8fT4UKFfJ2QCIiIuIQefn8dmgLUHp6Ops3b6ZTp072bS4uLnTq1Il169ZdUx3Tp0+nb9++uSY/APHx8VgsFvz9/XN8Pi0tjYSEhCw3ERERKbscmgDFxsZitVoJCgrKsj0oKIioqKir7r9hwwZ27NjBww8/nGuZ1NRURo0axf33359rNjhhwgT8/Pzst7CwsLwdiIiIiJQqDu8DVBDTp0+nSZMmtGnTJsfnMzIy6N27N4ZhMHXq1FzrGT16NPHx8fbbsWPHiipkERERKQHcHPnigYGBuLq6Eh0dnWV7dHQ0wcHBV9w3OTmZ2bNn89prr+X4/MXk58iRI6xYseKK1wI9PT3x9PTM+wGIiIhIqeTQFiAPDw9atmzJ8uXL7dtsNhvLly+nbdu2V9z3u+++Iy0tjf79+2d77mLys3//fpYtW0ZAQEChxy4iIiKll0NbgABGjhzJwIEDadWqFW3atGHSpEkkJyczePBgAAYMGEDVqlWZMGFClv2mT59Ojx49siU3GRkZ3HfffWzZsoWffvoJq9Vq709UqVIlPDw8iufAREREpMRyeALUp08fTp8+zdixY4mKiqJZs2b88ssv9o7RR48excUla0PV3r17+eOPP/j111+z1XfixAkWLlwIQLNmzbI8t3LlSm666aYiOQ4REREpPRw+D1BJpHmARERESp8inwdo5cqV+QpMREREpCTIVwJ0xx13ULt2bf773/9qyLiIiIiUOvlKgE6cOMGwYcOYO3cutWrVonPnznz77bekp6cXdnwiIiIihS5fCVBgYCAjRoxg69atrF+/nrp16/LEE08QGhrKU089xd9//13YcYqIiIgUmgLPA9SiRQtGjx7NsGHDSEpKYsaMGbRs2ZKOHTuyc+fOwohRREREpFDlOwHKyMhg7ty53HXXXYSHh7NkyRImT55MdHQ0Bw4cIDw8nF69ehVmrCIiIiKFIl/D4J988km++eYbDMPggQce4OGHH6Zx48ZZykRFRREaGorNZiu0YIuLhsGLiIiUPnn5/M7XRIi7du3iww8/5J577sl1Da3AwEANlxcREZESSRMh5kAtQCIiIqVPkU+EOGHCBGbMmJFt+4wZM3jrrbfyU6WIiIhIsclXAvTxxx9Tv379bNsbNWrEtGnTChyUiIiISFHKVwIUFRVFSEhItu2VK1fm1KlTBQ5KREREpCjlKwEKCwtjzZo12bavWbOG0NDQAgclIiIiUpTyNQrskUce4emnnyYjI4NbbrkFgOXLl/P888/zzDPPFGqAIiIiIoUtXwnQc889x5kzZ3jiiSfs6395eXkxatQoRo8eXagBioiIiBS2Ag2DT0pKYvfu3Xh7e3PdddflOidQaaNh8CIiIqVPkU+EeFG5cuVo3bp1QaoQERERKXb5ToA2bdrEt99+y9GjR+2XwS6aN29egQMTERERKSr5GgU2e/Zs2rVrx+7du5k/fz4ZGRns3LmTFStW4OfnV9gxioiIiBSqfCVA48eP53//+x8//vgjHh4evP/+++zZs4fevXtTvXr1wo5RREREpFDlKwE6ePAgXbp0AcDDw4Pk5GQsFgsjRozgk08+KdQARURERApbvhKgihUrkpiYCEDVqlXZsWMHAHFxcaSkpBRedCIiIiJFIF+doG+44QaWLl1KkyZN6NWrF8OHD2fFihUsXbqUW2+9tbBjFBERESlU+UqAJk+eTGpqKgAvvfQS7u7urF27lnvvvZeXX365UAMUERERKWx5ToAyMzP56aef6Ny5MwAuLi688MILhR6YiIiISFHJcx8gNzc3Hn/8cXsLkIiIiEhpk69O0G3atGHr1q2FHIqIiIhI8chXH6AnnniCkSNHcuzYMVq2bImvr2+W55s2bVoowYmIiIgUhXwthurikr3hyGKxYBgGFosFq9VaKME5ihZDFRERKX2KfDHUQ4cO5SswERERkZIgXwlQeHh4YcchIiIiUmzylQB98cUXV3x+wIAB+QpGREREpDjkqw9QxYoVszzOyMggJSUFDw8PfHx8OHv2bKEF6AjqAyQiIlL65OXzO1/D4M+dO5fllpSUxN69e+nQoQPffPNNvoIWERERKS75SoByct111/Hmm28yfPjwwqpSREREpEgUWgIE5izRJ0+eLMwqRURERApdvjpBL1y4MMtjwzA4deoUkydPpn379oUSmIiIiEhRyVcC1KNHjyyPLRYLlStX5pZbbuG9994rjLhEREREiky+EiCbzVbYcYiIiIgUm0LtAyQiIiJSGuQrAbr33nt56623sm1/++236dWrV57rmzJlCjVq1MDLy4vIyEg2bNiQa9mbbroJi8WS7dalSxd7GcMwGDt2LCEhIXh7e9OpUyf279+f57hERESkbMpXAvT7779z1113Zdt+55138vvvv+eprjlz5jBy5EjGjRvHli1biIiIoHPnzsTExORYft68eZw6dcp+27FjB66urlkSr7fffpsPPviAadOmsX79enx9fencuTOpqal5O1AREREpk/KVACUlJeHh4ZFtu7u7OwkJCXmqa+LEiTzyyCMMHjyYhg0bMm3aNHx8fJgxY0aO5StVqkRwcLD9tnTpUnx8fOwJkGEYTJo0iZdffpnu3bvTtGlTvvjiC06ePMmCBQvyfKwiIiJS9uQrAWrSpAlz5szJtn327Nk0bNjwmutJT09n8+bNdOrU6VJALi506tSJdevWXVMd06dPp2/fvvj6+gLmSvVRUVFZ6vTz8yMyMjLXOtPS0khISMhyExERkbIrX6PAxowZwz333MPBgwe55ZZbAFi+fDnffPMN33333TXXExsbi9VqJSgoKMv2oKAg9uzZc9X9N2zYwI4dO5g+fbp9W1RUlL2Of9d58bl/mzBhAq+++uo1xy0iIiKlW75agLp27cqCBQs4cOAATzzxBM888wzHjx9n2bJl2eYIKkrTp0+nSZMmtGnTpkD1jB49mvj4ePvt2LFjhRShiIiIlET5agEC6NKlS5aRV/kRGBiIq6sr0dHRWbZHR0cTHBx8xX2Tk5OZPXs2r732WpbtF/eLjo4mJCQkS53NmjXLsS5PT088PT3zcQQiIiJSGuWrBWjjxo2sX78+2/b169ezadOma67Hw8ODli1bsnz5cvs2m83G8uXLadu27RX3/e6770hLS6N///5ZttesWZPg4OAsdSYkJLB+/fqr1ikiIiLOIV8J0NChQ3O8THTixAmGDh2ap7pGjhzJp59+yueff87u3bsZMmQIycnJDB48GIABAwYwevTobPtNnz6dHj16EBAQkGW7xWLh6aef5r///S8LFy5k+/btDBgwgNDQ0GK9PCciIiIlV74uge3atYsWLVpk2968eXN27dqVp7r69OnD6dOnGTt2LFFRUTRr1oxffvnF3on56NGjuLhkzdP27t3LH3/8wa+//ppjnc8//zzJyck8+uijxMXF0aFDB3755Re8vLzyFJuIiIiUTRbDMIy87hQQEMBPP/2U7ZLS2rVr6dKlC+fOnSu0AB0hISEBPz8/4uPjqVChgqPDERERkWuQl8/vfF0Cu/322+0jpy6Ki4vjxRdf5LbbbstPlSIiIiLFJl+XwN59911uuOEGwsPDad68OQBbt24lKCiIL7/8slADFBERESls+UqAqlatyrZt25g1axZ///033t7eDB48mPvvvx93d/fCjlFERESkUOV7HiBfX186dOhA9erVSU9PB+Dnn38GoFu3boUTnYiIiEgRyFcC9M8//9CzZ0+2b9+OxWLBMAwsFov9eavVWmgBioiIiBS2fHWCHj58ODVr1iQmJgYfHx927NjBb7/9RqtWrVi1alUhhygiIiJSuPLVArRu3TpWrFhBYGAgLi4uuLq60qFDByZMmMBTTz3FX3/9VdhxioiIiBSafLUAWa1WypcvD5jreZ08eRKA8PBw9u7dW3jRiYiIiBSBfLUANW7cmL///puaNWsSGRnJ22+/jYeHB5988gm1atUq7BhFREREClW+EqCXX36Z5ORkAF577TXuvvtuOnbsSEBAAHPmzCnUAEVEREQKW76WwsjJ2bNnqVixYpbRYKWVlsIQEREpffLy+Z3veYD+rVKlSoVVlYiIiEiRylcnaBEREZHSTAmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTUQIkIiIiTkcJkIiIiDgdJUAiIiLidJQAiYiIiNNRAiQiIiJORwmQiIiIOB0lQGWVYUBGqqOjEBERKZGUAJVF547A/90Kb9eErd84OhoREZESRwlQWbN/KXx8A5zYDBkpsOBxWPISWDMdHZmIiEiJ4fAEaMqUKdSoUQMvLy8iIyPZsGHDFcvHxcUxdOhQQkJC8PT0pG7duixevNj+vNVqZcyYMdSsWRNvb29q167N66+/jmEYRX0ojmWzwcoJMKsXpMZBaAto96T53LrJ8HUvOH/OoSGKiIiUFG6OfPE5c+YwcuRIpk2bRmRkJJMmTaJz587s3buXKlWqZCufnp7ObbfdRpUqVZg7dy5Vq1blyJEj+Pv728u89dZbTJ06lc8//5xGjRqxadMmBg8ejJ+fH0899VQxHl0xSjkL8x6BA8vMx60ehDveBDdPqNoSFjwBB1fAp7dA32+gSn3HxisiIuJgFsOBTSORkZG0bt2ayZMnA2Cz2QgLC+PJJ5/khRdeyFZ+2rRpvPPOO+zZswd3d/cc67z77rsJCgpi+vTp9m333nsv3t7efPXVV9cUV0JCAn5+fsTHx1OhQoV8HFkxOrEFvh0I8UfBzQvungTN7s9a5tQ2mN3PLONRHu79FOrd6ZBwRUREikpePr8ddgksPT2dzZs306lTp0vBuLjQqVMn1q1bl+M+CxcupG3btgwdOpSgoCAaN27M+PHjsVqt9jLt2rVj+fLl7Nu3D4C///6bP/74gzvvzP0DPy0tjYSEhCy3Es8wYNNnMKOzmdhUrAkPL8ue/ACENIVHV0J4B0hPhG/uh9/fNesQERFxQg67BBYbG4vVaiUoKCjL9qCgIPbs2ZPjPv/88w8rVqygX79+LF68mAMHDvDEE0+QkZHBuHHjAHjhhRdISEigfv36uLq6YrVaeeONN+jXr1+usUyYMIFXX3218A6uqGWch0XPwNZZ5uO6d0LPaeDtn/s+voEwYAH88gJs/D9Y8TpE74DuU8DDtziiFhERKTEc3gk6L2w2G1WqVOGTTz6hZcuW9OnTh5deeolp06bZy3z77bfMmjWLr7/+mi1btvD555/z7rvv8vnnn+da7+jRo4mPj7ffjh07VhyHkz9n/4H/u81MfiwucOtY6Pv1lZOfi1zdoct75mUyFzfYOd9sQYorwccrIiJSBBzWAhQYGIirqyvR0dFZtkdHRxMcHJzjPiEhIbi7u+Pq6mrf1qBBA6KiokhPT8fDw4PnnnuOF154gb59+wLQpEkTjhw5woQJExg4cGCO9Xp6euLp6VlIR1aE9v4M8x6DtHjwCYT7pkOtm/JeT6vBULkezHkAorbDJzdBny8hvF1hRywiIlIiOawFyMPDg5YtW7J8+XL7NpvNxvLly2nbtm2O+7Rv354DBw5gs9ns2/bt20dISAgeHh4ApKSk4OKS9bBcXV2z7FPq2Kyw/DX4pq+Z/FRrDY/9nr/k56LwdvDoKghuCimx8HlX2DSjsCIWEREp0Rx6CWzkyJF8+umnfP755+zevZshQ4aQnJzM4MGDARgwYACjR4+2lx8yZAhnz55l+PDh7Nu3j0WLFjF+/HiGDh1qL9O1a1feeOMNFi1axOHDh5k/fz4TJ06kZ8+exX58hSI5Fr66B1a/Zz5u8ygMWgx+VQtet38YPLgEGt0Dtkz4aQT8NBIy0wtet4iISAnm0HmA+vTpw+nTpxk7dixRUVE0a9aMX375xd4x+ujRo1lac8LCwliyZAkjRoygadOmVK1aleHDhzNq1Ch7mQ8//JAxY8bwxBNPEBMTQ2hoKI899hhjx44t9uMrsOOb4NsBkHAC3H2g6/vQtHfhvoaHD9w3A4Ibw/LXYdN0OL0Hen9hdpwWEREpgxw6D1BJ5fB5gAzDHKn1y2iwZUBAHej9JQQ1LNrX3fsLfP+wOVTeL8zsXB3StGhfU0REpJCUinmAJBfpyTD/MVj8rJn8NOgKj6ws+uQHoN4d8MhyqFQL4o+ZI8R2zi/61xURESlmSoBKkjMH4f86wbY5YHGF2143W368irEVqnI9eGQF1L7FXEz1u0Gw4r/mWmMiIiJlhBKgkmL3T+Zw9Jhd4FsFBi6E9k+BxVL8sXhXhP98B22HmY9/fwfm9IPUUjBDtoiIyDVQAuRo1kxYOtZMMNISIOx6c4h7jQ6OjcvVDTq/AT0/BldP2LsYpt9mTsQoIiJlT1oiJJ9xdBTFRgmQIyXFwJc9YM375uPrn4BBP0GFEIeGlUVEXxj8M5QPMUeHfXKzubK8iIiUDTYrbPgU3msAk1tCwilHR1QslAA5ytH18PENcHg1uPvCfZ/BHRPM5SpKmmotzUkTq7WG1Dj46l5YN0WLqYqIlHZR22H67ebAm/REOH8ONnzs6KiKhRKg4mYY8Oc0mHkXJJ6CwLrmSu2N73F0ZFdWPhgG/gTN+oFhgyUvwoInICPV0ZGJiEhepSfDr2Pg4xvhxCbwKA/N+5vPbZoBaUmOja8YKAEqTmlJ8P1D8Msoc+blRj3NEVeV6zk6smvj7mWuHt95grkQ699fw8wukBjl6MhERORa7V8GH10Paz8AwwoNusGwjdD1Q3PeudR4+OsrR0dZ5JQAFac/JsKO782V2DtPMC97eZZ3dFR5Y7FA2yeg/zzw8je/OXxyE2z7FhJOOjo6ERHJTWI0zH0QZt0LcUehQjW4f7a5GHaFEHBxgbYXlpb6c4o5SKcM00zQOSiymaDTU+DbB6DjsxCe84KvpcqZgzD7P2bn6Iv8w82FVqu3NX8G1HHMUH4RETHZbLDlc1g2zmzdsbhA5BC4+UXwLJe1bMZ5+F8jSDkDvWaaVypKkbx8fisByoHDl8IoTdIS4fd34Z+VZmc6418TJvpWhurXQ/V2ZtIX1MQcYi8iIkUvZjf8+DQc+9N8HBJhrisZ2jz3fVZOgN/ehKot4eHlpepLrBKgAlIClE+pCXB8AxxZB0fXmYu5WtOylvEoD2GtLyVEVVuCu7dj4hURKasyzptfTte8by6r5O4Lt7wMbR69+pfQpNNmK5A1DQb/UqquWCgBKiAlQIUkMw1O/gVH1poJ0dH1kBaftYyrh/lN5OIls7BI8PZ3SLgiImXCP6vgpxGXJq6teyfc9Q74h117HT8Oh80zoV4XuP/rooiySCgBKiAlQEXEZjWX+jiyDo6uNX8m/XsEmQWCGl1IiNqaLUUlaWJIEZGSKjkWlrwE22abj8uHwJ1vm4tq5/Uy1ul9MKU1YIFhmyCwTqGHWxSUABWQEqBiYhjmN5Sj6y4lRTkttVGxxqVLZjVvhIrhxR6qiEiJZRiwdRb8+rI5kSEWaPOIecnLyy//9X7dB/b9Aq0ehLv/V2jhFiUlQAWkBMiBEqOyJkRRO4DL3qIWF7Mpt/XDDgtRRKTEiN1vXu46vNp8HNTY7ORcrVXB6z78hznXm5sXjNgJvoEFr7OI5eXzW8NxpGQpH2wOu7w49DI1Ho5tMPsRHfrdnHdo0TPmt5yOz5aq0QkiIoUmMw3+mASr3wVrOrh5w82jzTUlC2tJpfD2ENIMTm2FjdPhplGFU28JoRagHKgFqIQyDFj5Bvz+jvm47TC4/b9KgkTEuRxeAz89DbH7zMd1OkGX98zuAoVt+1xzBQOfQLMVyN2r8F+jEOXl81szQUvpYbGY17Q7jzcfr5sMPwwr87OViogAkHLW/J838y4z+fGtAvfNgH5ziyb5AWjYA/zCICX2UufqMkIJkJQ+bYdC94/M/kBbv4LvBmpRVhEpuwzDXG5ocmv460tzW8tBMGwDNL63aFvBXd3g+iHm/XVTzFmlywglQFI6Ne8Hvb805xHa8xN83duclVpEpKzITDcXLv2yJ8x7xGyFqVzfnJyw6/vgXbF44mj+AHhWMFud9v9aPK9ZDJQASenV4G7o9x14lINDv8EX3c0mYhGR0iozDfb+AvOHwLt1zIVL/1kJrp5mF4DHVhf/zMxeFcwWJzC7HpQR6gSdA3WCLmWObzb/SZw/Z347emA+VAh1dFQiItcm4zwcXAG7foC9P0NawqXnygWZExle/wQE1HZcjPEn4P2mYMuER1ddeS0xB9I8QAWkBKgUitljNhMnngT/6vDAAsf+sxARuZL0FDiw1Ex69i2B9KRLz5UPhYbdoGF3c3kgF1fHxXm5eY/CtjnQ+D64b7qjo8mREqACUgJUSp07Al/2MGeT9q0CD8yD4CaOjkpExJSWZPah2fWD+TMj5dJzFaqZCU/D7lCtNbiUwB4qp7bBxx3B4grD/87b2mLFRBMhinOqGA4PLoEv74Ho7eYMpv/5DqpHOjoyEXFWqQlmC8+uBXBgGWReNmLVv7o5zLxhD6jaouTPaRbS1FyO6NBvsH4adH7D0REViFqAcqAWoFLufJy5hs2xP83ZUft8Bdd1cnRUIuIszseZa2jt+gEOLAdr2qXnKtaERj3Mlp6QZiU/6fm3/Uth1n3gUR5G7izYWmNFQC1A4ty8/c2O0N8OMK+xf9MX7vnYnC9DRKQopJyFvYvNpOfgSrBlXHouoI7ZytOoh7lWV2lLei5Xp5M52OT0Htj8ObR/ytER5ZsSICmbPHyg79cw/zHYOQ/mPmQ2Rbca7OjIRKSsSD5jzkO2a4G5VqHtslnpKze41KenSoPSnfRczmIxlyFaOMy8DHb9kMJbe6yYKQGSssvNA+79P7NFaNMMc+2c8+eg40hHRyYipUl6ijm44sx+iD1w4ed+OPU3GNZL5YIaX0p6KtdzXLxFrWlvWP4aJJyAnfPNx6WQEiAp21xcoctE8K5krpq8/FUzCbrttbLzjUxECs5mg4TjZmJz5oB5u3g//lju+4VEmAlPg+4QWKf44nUkN0+IfBRW/BfWfghNepXK/6dKgKTss1jg1jFmS9CvL8PaD8wkqOv7JWd+DREpHqnxWVtxzuyHMwfNW+b53Pfz8ofA6yDgOjPRCahjJj9FtQhpSdfqIVg9EaK2mZf/at3o6IjyTAmQOI92T5r/xH58ylxQMC0B7vnU/DYjImWHNQPOHb6sNeeyS1fJp3Pfz8UdKtUyk5vAOheSnQtJj0+lUtnKUWR8KkGzfrDxU3N5DCVAIiVciwfMYZvfP2SO1khNMIfJe5ZzdGQiRS8tEaJ3mfNkRe2AuKNQqSYENYKgJmZn3dL0t2AYEH8coneYxxO93Ty+c4eydkj+t3LBFxKbOpd+BtQB/3Bz9XO5NtcPgY3/Z07qGLMHqtR3dER5ot+0OJ+G3cDzW5jdz1xk8Mse8J9vzW80ImWBYZj9VqJ2XEgOtpn3zx3KXvbg5Q8sWROioEbmzT/c8TMTZ6aZQ6+jtl92XNshNS7n8u4+5nI4l7fiBNaBSrXNxT2l4AJqm4tS7/7RbAXqXroWStVEiDnQRIhO4vgm+Ope8x9olYbm3EHlg4v2NZNjzX/ip/fA6b3mLTPNnEujfpeifW0pmzJS4fTurIlB9A6zr0tOyoeYo5WCm5izp5/9B6J3mvsmReW8j0d5CGpo7hfUyNy3SgPwLF80x5R0+lIrVdR283hi9+XcquPiBoH1ILjxheNqbD6uEKpLVsXh6HqYcTu4esDTO6B8kEPD0VpgBaQEyInE7L6wiOop81vugAVmH4CCMAxIjLosybnwM3YvpJzJfb96XeDOt0rk+jolVspZcPMy531yBonRFxKDy5Kd2P1Zh2Jf5OJuTlh3eWIQ1AR8A3KvPzn2QgK181L9p/eANT3n8hUvthZdrL8R+Ne49tYia6bZRyf6skQnajskRedc3svfTL6Cm1x6zcr11Y/P0f7vNji+AW54Dm552aGhKAEqICVATubcYfiih3l5oFyQ2RIU1Ojq+10cNmtPci5r1UlLyGUni/mtu3J9CKxr/jyz3xxKassEd1+4eTREDlFfhKuJOwrTOgIG3PA8tHnUnPupLLBmmC0eF/u1XExGcuvA6xNwqVXn8laQwjgf1gwzSbm8dSl6p/mlISce5cwW1YsJUVBj8zFG1ktX0TvMLyCXr41lZzG/iFxM2oKbmPcrVFWrTkm06wdz5n3vijBiJ3j4OiwUJUAFpATICSVGw1f3mP+Uvfyg31wIa2M+Z7OaSdLlrTmn95gfUJev5nw5i6v5D7xyPTPJqVzPvAVcl3NrRcxu+GkEHF1nPg5qAnf/D8JaF8nhlgmLn4MNn1x6XLEm3P461L+79H5I/vMb/P4OHFufc6uLxcXsrHt5i05wY/OyVnEfc/KZS8nQxcQoZk/Wda+uhbuveXnNnrw1MROm0tQZ29nZrPBhC/P/5F3vQptHHBaKEqACUgLkpM6fu7CI6nqzA+V1t1+aDC23f+ou7mYHy8sTncB6ZufAvDbL22ywdRYsHWPGgsVcuuPWceYcRnJJ0mmY1NhsPWg7DLZ/d+mySXgHc5Xq0GYODTFPjqyDlW/A4dWXtnlW+NflpQv9bkry5b7LL2nZR2bthMST5vMVql12Se5Cy07Fmo7vYC0Ft/4T+Pk58/f55GaHzbFWqhKgKVOm8M477xAVFUVERAQffvghbdq0ybV8XFwcL730EvPmzePs2bOEh4czadIk7rrrLnuZEydOMGrUKH7++WdSUlKoU6cOn332Ga1atbqmmJQAObH0ZJjzABxcnnW7m/eFRKf+ZclOfXMStMK+VJUcC7+Ogb+/Nh/7VoE7JpiLuZbWlo3CtuxV+GMihLaAR1aYv7c1k8xLiZmpgAUi7jcnwKwQ6uhoc3diM6x449L7zdUDWg6GyMfMFsSy8vtOOWv+1EjLsis9GSY2NAeV9PkKGnR1SBilJgGaM2cOAwYMYNq0aURGRjJp0iS+++479u7dS5UqVbKVT09Pp3379lSpUoUXX3yRqlWrcuTIEfz9/YmIiADg3LlzNG/enJtvvpkhQ4ZQuXJl9u/fT+3ataldu/Y1xaUEyMllppsTJaYnXUp4/KoX/7fUQ6vNy2Jn9puPa90MXd4zW5ecWWo8/K+x2c/q3/9o44+bydH2b83H7j7Qfrg5CaYD+yVkE7UdVo43Vw8HcyRT8/5mJ1K/ao6NTSS/lr8Gq9+DsOvhoSUOCaHUJECRkZG0bt2ayZPNuQNsNhthYWE8+eSTvPDCC9nKT5s2jXfeeYc9e/bg7p7z6rMvvPACa9asYfXq1Tk+fy2UAEmJkZkGaz4w+4VY08DVE2541vxQd9aRL6snmmu6BdaDJ/7MOTE9vhmWvAjH/jQflw+FW8dC0z6Ovdxyei+smmAuIAlmn56mfeHG5835d0RKs8QomNTE7L/20DKH9GHMy+e3w/4TpKens3nzZjp16nQpGBcXOnXqxLp163LcZ+HChbRt25ahQ4cSFBRE48aNGT9+PFarNUuZVq1a0atXL6pUqULz5s359NNPrxhLWloaCQkJWW4iJYKbJ9z4HDyxzmwBsqaZfUWmtjdbiJxNxnn48yPzfocRuScz1VrCg79Ar5ngX93sg7Lgcfj0Zji8ptjCtTtzEOY9Bh9dfyn5aXwvPLEeek5V8iNlQ/lgaHJhZfh1Hzo2lmvgsAQoNjYWq9VKUFDWSZOCgoKIisp5Mq5//vmHuXPnYrVaWbx4MWPGjOG9997jv//9b5YyU6dO5brrrmPJkiUMGTKEp556is8//zzXWCZMmICfn5/9FhameVikhAmobQ7Pv3e62SfozH74/G6Y/7jZZ8hZ/PWVORTcrzo0ue/KZS0WaNQThm6ETq+ak/md2goz74I5/c0JAIta3FFY+CRMbg3bZoNhM0epDVkL982AynWLPgaR4tRumPlz949wNoeZx0sQh10CO3nyJFWrVmXt2rW0bdvWvv3555/nt99+Y/369dn2qVu3LqmpqRw6dAhXV7OH+cSJE3nnnXc4dcqck8LDw4NWrVqxdu1a+35PPfUUGzduzLVlKS0tjbS0S6N8EhISCAsL0yUwKZnOx5nX2jfNAAxz7o3bXoNm/cv2aBprJnzY3Ewq7nwHIh/N2/5Jp2HVeNg800xEXNzNzsY3PFf4o+wSTpl9ITbPBFuGua3ObXDzi1C1ReG+lkhJ89W9cGAZtHkM7nq7WF+6VFwCCwwMxNXVlejorDN+RkdHExyc83IEISEh1K1b1578ADRo0ICoqCjS09PtZRo2bJhlvwYNGnD06NFcY/H09KRChQpZbiIllrc/3D0RHl5mDo0+f85sZZh5lzmfUFm143sz+fEJNDsM51W5yubcSkPWQu1bzcRk3WT4oDls+NSc8K+gkk7Dkpfgg2bmKtm2DKh5Azz4K/Sfq+RHnEO7J82ff315aQRgCeSwBMjDw4OWLVuyfPml4cY2m43ly5dnaRG6XPv27Tlw4AA2m82+bd++fYSEhODh4WEvs3fv3iz77du3j/Dw8CI4ChEHqtYKHl0Ft79hTiZ3dB1M6wDLXoH0XCZoLK1sNvjjf+b964cUbC6cKg3ggXnQ73tzlN/5s7D4WZjaDvYtMZcyyauUs+bos/cjzKQqM9UcCTPwR/NWPTL/8YqUNjVvNL+cZaTA5s8cHU2uHNpePnLkSD799FM+//xzdu/ezZAhQ0hOTmbw4MEADBgwgNGjR9vLDxkyhLNnzzJ8+HD27dvHokWLGD9+PEOHDrWXGTFiBH/++Sfjx4/nwIEDfP3113zyySdZyoiUGa5u5jX3oevNtcRsmWai8FEk7PvV0dEVnn2/mAt+epSH1g8XTp3XdYLH15hTC/gEmDN7f93bXBsueue11ZGaAKveNBOfPyZCRjKENjeTqwd/MVt/RJyNxXKpFWj9x+Zo1hLI4RMhTp482T4RYrNmzfjggw+IjDS/Ld10003UqFGDmTNn2suvW7eOESNGsHXrVqpWrcpDDz3EqFGjslwW++mnnxg9ejT79++nZs2ajBw5kkceufapuTUMXkqtPYtg8fPmGmUADbvDHW+W7MkAr8YwYPptcHwjtH8abnu18F8jNR5+fxfWTzOH8FpcoMUAuPklKJd9TjLSk81lONa8f2HWbszZjW9+EerdVXYmMBTJL2sGTGpqjsDs/hE071csL1tq5gEqqZQASamWlmTONfPnVHOVcI/y5grNbR5x2PT0BXJotTnizdUTnt4O5YOuvk9+nT0Ey8aZizuCee46joTrnwB3L8hINTuf/zHx0sKkgXXhptHQsEfZ7oQukld/TDL/nqo0NPveFcMXAyVABaQESMqEqO3w49NwYpP5OKQZdJ9irsVUmnzRA/5ZCa0eMjt/F4cj62DJaDj5l/nYrzo07W2u1XZxFfSKNeGmF6BJr9KZWIoUtfNx8L9G5qz6/b+HOp2uuktBlYpRYCJSxIKbwENLoctE8PQz58D5opu5indpcfIvM/mxuEL7p4rvdcPbwsMroOcnUKEqxB+F1e+ayU+FatD1Axi2ESL6KvkRyY23v3kpGcx1+koYJUAiZZmLC7R+yPywrtIQUs6YLRulxeoLLT6N7zUXni1OLi4Q0QeGbTL7AlVtCXe9C09tgZYDwTXn5XhE5DKRj5tfYP5ZZbZKlyBKgEScQfkg6DbZ7Ny7bQ7sX+boiK7u9D5zNlkwl71wFA8fc62uR1aY/aicdQ02kfyoGG4OxgBYO9mxsfyLEiARZ1GtJUQOMe//9LTZWbokW/M+YJijqoIaXrW4iJRQF4fE75gL8SccG8tllACJOJNbXjIXB40/Biv+e/XyjhJ/3Fw7C6DDSMfGIiIFU7UFhLc35ynb8LGjo7FTAiTiTDx84e5J5v310+DYRoeGk6u1k81/ljU6QlhrR0cjIgV1sRVo00xIS3RoKBcpARJxNnVuhYj7AcNcQywz3dERZZV8BrZ8bt53ZN8fESk813WGgOsgLR62fOnoaAAlQCLOqfN4c1HR07svrbFVUqyfZq4hFBIBtW9xdDQiUhhcXKDthSWp/pwK1kzHxoMSIBHn5FMJ7nzLvP/7OxCzx7HxXJSWeKmPQIeRWlJCpCyJ6Gt+8Yo/CrsXOjoaJUAiTqvxvWaztC0DfnzKXHHd0TbNMNflCqgDDbo6OhoRKUzu3uZUEmBOjOjghSiUAIk4K4vFXFrCoxwcWw+bpjs2noxUWDfFvN/+ac2wLFIWtX4Y3Lzg5BY4us6hoSgBEnFmftWg0yvm/WWvmMPPHeXvryEp2lx6omkfx8UhIkXHN/DCIAwcvjyGEiARZ9fqIQiLNBcs/GmkY5qlrZkXJj4E2g4DN4/ij0FEikfboeZahQ17ODQMJUAizs7FBbp9CK4esH8J7Pi++GPYtQDOHQbvSuY6WyJSdgVeB4+tNtfacyAlQCIClevBDc+Z938eBSlni++1DePSUPzrh5iTNYpI2VYCRngqARIRU/unL6wYHwtLXiy+193/K0TvMDtjXxwhIiJSxJQAiYjJzcO8FIYF/v4GDhTTivGrJ5o/Ww0G74rF85oi4vSUAInIJdVaQeTj5v0fRxT9ivFH1sKxP83+R9cPLdrXEhG5jBIgEcnqlpfBr7o5W+vKN4r2tS62/jT7D1QIKdrXEhG5jBIgEcnKsxx0vdAp+c+pcHxT0bzOqW1wYClYXKD98KJ5DRGRXCgBEpHs6nSCpn0xV4x/qmhWjP/jQutPo55QqVbh1y8icgVKgEQkZ53Hg08AxOy8NElhYTlzEHb9YN7vMKJw6xYRuQZKgEQkZ74BcMfFFePfhtP7Cq/uNZPAsMF1t5szwoqIFDMlQCKSuyb3mUmKNb3wVoxPOAlbvzHvdxhZ8PpERPJBCZCI5M5igS4XVow/ug42zyh4neumgC0DqreD8LYFr09EJB+UAInIlfmHwa3jzPtLX4H4E/mvK+UsbPrMvN9RrT8i4jhKgETk6lo/BNXaQHoiLCrAivEbPoGMZLPfT51OhRujiEgeKAESkatzcTWXyXBxh32/wM55ea8jLQnWTzPvdxhRIhZDFBHnpQRIRK5Nlfpww7Pm/cXP533F+C2fw/lz5pw/DXsUengiInmhBEhErl2HkVC5wYUV41+69v0y02DtZPN+++Fmi5KIiAMpARKRa+fmAd0+wFwx/ms4uOLa9vt7NiSehPIhEHF/kYYoInItlACJSN6EtYHIx8z7Pz4N6clXLm+zXppJuu1QcPMs0vBERK6FEiARybtbxoBfGMQdgZXjr1x21w9w9iB4+UPLQcURnYjIVSkBEpG88ywHd19cMf4jOLE553KGcWnR08jHwLN88cQnInIVSoBEJH+uuw2a9DbX9Fr4FFgzspc5sByitoO7D0Q+XvwxiojkQgmQiOTfHW+aK8ZH78h5xfiLrT8tB4FPpWINTUTkSpQAiUj++QaYSRDAb29D7P5Lzx1dD0fWmJMnth3mmPhERHKhBEhECqZJL6hzG1jTzEthF1eMv9j6E9EX/Ko6Lj4RkRwoARKRgrFY4O6J4O4LR9fC5s8geqe5ZAYWaP+0oyMUEclGCZCIFJx/dbh1rHl/6Tj49WXzfsPuEFjHcXGJiOSiRCRAU6ZMoUaNGnh5eREZGcmGDRuuWD4uLo6hQ4cSEhKCp6cndevWZfHixTmWffPNN7FYLDz99NNFELmI2LV5BKq1NleMvzhDdMeRjo1JRCQXDk+A5syZw8iRIxk3bhxbtmwhIiKCzp07ExMTk2P59PR0brvtNg4fPszcuXPZu3cvn376KVWrZu9jsHHjRj7++GOaNm1a1IchIpevGA9Q+1YIiXBsTCIiuXB4AjRx4kQeeeQRBg8eTMOGDZk2bRo+Pj7MmDEjx/IzZszg7NmzLFiwgPbt21OjRg1uvPFGIiKy/qNNSkqiX79+fPrpp1SsWLE4DkVEqjSAzuPBrzp0GufoaEREcuXQBCg9PZ3NmzfTqVMn+zYXFxc6derEunXrctxn4cKFtG3blqFDhxIUFETjxo0ZP348Vqs1S7mhQ4fSpUuXLHXnJi0tjYSEhCw3EcmnyEdhxHa1/ohIiebmyBePjY3FarUSFBSUZXtQUBB79uzJcZ9//vmHFStW0K9fPxYvXsyBAwd44oknyMjIYNw48xvn7Nmz2bJlCxs3brymOCZMmMCrr75asIMRERGRUsPhl8DyymazUaVKFT755BNatmxJnz59eOmll5g2bRoAx44dY/jw4cyaNQsvL69rqnP06NHEx8fbb8eOHSvKQxAREREHc2gLUGBgIK6urkRHR2fZHh0dTXBwcI77hISE4O7ujqurq31bgwYNiIqKsl9Si4mJoUWLFvbnrVYrv//+O5MnTyYtLS3LvgCenp54enoW4pGJiIhISebQFiAPDw9atmzJ8uXL7dtsNhvLly+nbdu2Oe7Tvn17Dhw4gO3ibLPAvn37CAkJwcPDg1tvvZXt27ezdetW+61Vq1b069ePrVu3Zkt+RERExPk4tAUIYOTIkQwcOJBWrVrRpk0bJk2aRHJyMoMHDwZgwIABVK1alQkTJgAwZMgQJk+ezPDhw3nyySfZv38/48eP56mnngKgfPnyNG7cOMtr+Pr6EhAQkG27iIiIOCeHJ0B9+vTh9OnTjB07lqioKJo1a8Yvv/xi7xh99OhRXFwuNVSFhYWxZMkSRowYQdOmTalatSrDhw9n1KhRjjoEERERKWUshmEYjg6ipElISMDPz4/4+HgqVKjg6HBERETkGuTl87vUjQITERERKSglQCIiIuJ0lACJiIiI01ECJCIiIk5HCZCIiIg4HSVAIiIi4nSUAImIiIjTcfhEiCXRxamREhISHByJiIiIXKuLn9vXMsWhEqAcJCYmAuas0yIiIlK6JCYm4ufnd8Uymgk6BzabjZMnT1K+fHksFoujwyk2CQkJhIWFcezYMaefAVvnwqTzYNJ5uETnwqTzYCpp58EwDBITEwkNDc2yjFZO1AKUAxcXF6pVq+boMBymQoUKJeKNXBLoXJh0Hkw6D5foXJh0Hkwl6TxcreXnInWCFhEREaejBEhEREScjhIgsfP09GTcuHF4eno6OhSH07kw6TyYdB4u0bkw6TyYSvN5UCdoERERcTpqARIRERGnowRIREREnI4SIBEREXE6SoBERETE6SgBciITJkygdevWlC9fnipVqtCjRw/27t17xX1mzpyJxWLJcvPy8iqmiIvGK6+8ku2Y6tevf8V9vvvuO+rXr4+XlxdNmjRh8eLFxRRt0alRo0a282CxWBg6dGiO5cvSe+H333+na9euhIaGYrFYWLBgQZbnDcNg7NixhISE4O3tTadOndi/f/9V650yZQo1atTAy8uLyMhINmzYUERHUDiudB4yMjIYNWoUTZo0wdfXl9DQUAYMGMDJkyevWGd+/r4c7Wrvh0GDBmU7pjvuuOOq9Za29wNc/Vzk9D/DYrHwzjvv5FpnSX1PKAFyIr/99htDhw7lzz//ZOnSpWRkZHD77beTnJx8xf0qVKjAqVOn7LcjR44UU8RFp1GjRlmO6Y8//si17Nq1a7n//vt56KGH+Ouvv+jRowc9evRgx44dxRhx4du4cWOWc7B06VIAevXqles+ZeW9kJycTEREBFOmTMnx+bfffpsPPviAadOmsX79enx9fencuTOpqam51jlnzhxGjhzJuHHj2LJlCxEREXTu3JmYmJiiOowCu9J5SElJYcuWLYwZM4YtW7Ywb9489u7dS7du3a5ab17+vkqCq70fAO64444sx/TNN99csc7S+H6Aq5+Ly8/BqVOnmDFjBhaLhXvvvfeK9ZbI94QhTismJsYAjN9++y3XMp999pnh5+dXfEEVg3HjxhkRERHXXL53795Gly5dsmyLjIw0HnvssUKOzLGGDx9u1K5d27DZbDk+XxbfC4ZhGIAxf/58+2ObzWYEBwcb77zzjn1bXFyc4enpaXzzzTe51tOmTRtj6NCh9sdWq9UIDQ01JkyYUCRxF7Z/n4ecbNiwwQCMI0eO5Fomr39fJU1O52HgwIFG9+7d81RPaX8/GMa1vSe6d+9u3HLLLVcsU1LfE2oBcmLx8fEAVKpU6YrlkpKSCA8PJywsjO7du7Nz587iCK9I7d+/n9DQUGrVqkW/fv04evRormXXrVtHp06dsmzr3Lkz69atK+owi016ejpfffUVDz744BUXAC6L74V/O3ToEFFRUVl+535+fkRGRub6O09PT2fz5s1Z9nFxcaFTp05l6n0SHx+PxWLB39//iuXy8vdVWqxatYoqVapQr149hgwZwpkzZ3It6yzvh+joaBYtWsRDDz101bIl8T2hBMhJ2Ww2nn76adq3b0/jxo1zLVevXj1mzJjBDz/8wFdffYXNZqNdu3YcP368GKMtXJGRkcycOZNffvmFqVOncujQITp27EhiYmKO5aOioggKCsqyLSgoiKioqOIIt1gsWLCAuLg4Bg0alGuZsvheyMnF32tefuexsbFYrdYy/T5JTU1l1KhR3H///Vdc9DKvf1+lwR133MEXX3zB8uXLeeutt/jtt9+48847sVqtOZZ3hvcDwOeff0758uW55557rliupL4ntBq8kxo6dCg7duy46nXYtm3b0rZtW/vjdu3a0aBBAz7++GNef/31og6zSNx55532+02bNiUyMpLw8HC+/fbba/omUxZNnz6dO++8k9DQ0FzLlMX3glybjIwMevfujWEYTJ069Yply+LfV9++fe33mzRpQtOmTalduzarVq3i1ltvdWBkjjVjxgz69et31cEQJfU9oRYgJzRs2DB++uknVq5cSbVq1fK0r7u7O82bN+fAgQNFFF3x8/f3p27durkeU3BwMNHR0Vm2RUdHExwcXBzhFbkjR46wbNkyHn744TztVxbfC4D995qX33lgYCCurq5l8n1yMfk5cuQIS5cuvWLrT06u9vdVGtWqVYvAwMBcj6ksvx8uWr16NXv37s3z/w0oOe8JJUBOxDAMhg0bxvz581mxYgU1a9bMcx1Wq5Xt27cTEhJSBBE6RlJSEgcPHsz1mNq2bcvy5cuzbFu6dGmW1pDS7LPPPqNKlSp06dIlT/uVxfcCQM2aNQkODs7yO09ISGD9+vW5/s49PDxo2bJlln1sNhvLly8v1e+Ti8nP/v37WbZsGQEBAXmu42p/X6XR8ePHOXPmTK7HVFbfD5ebPn06LVu2JCIiIs/7lpj3hKN7YUvxGTJkiOHn52esWrXKOHXqlP2WkpJiL/PAAw8YL7zwgv3xq6++aixZssQ4ePCgsXnzZqNv376Gl5eXsXPnTkccQqF45plnjFWrVhmHDh0y1qxZY3Tq1MkIDAw0YmJiDMPIfg7WrFljuLm5Ge+++66xe/duY9y4cYa7u7uxfft2Rx1CobFarUb16tWNUaNGZXuuLL8XEhMTjb/++sv466+/DMCYOHGi8ddff9lHN7355puGv7+/8cMPPxjbtm0zunfvbtSsWdM4f/68vY5bbrnF+PDDD+2PZ8+ebXh6ehozZ840du3aZTz66KOGv7+/ERUVVezHd62udB7S09ONbt26GdWqVTO2bt2a5X9GWlqavY5/n4er/X2VRFc6D4mJicazzz5rrFu3zjh06JCxbNkyo0WLFsZ1111npKam2usoC+8Hw7j634ZhGEZ8fLzh4+NjTJ06Ncc6Sst7QgmQEwFyvH322Wf2MjfeeKMxcOBA++Onn37aqF69uuHh4WEEBQUZd911l7Fly5biD74Q9enTxwgJCTE8PDyMqlWrGn369DEOHDhgf/7f58AwDOPbb7816tata3h4eBiNGjUyFi1aVMxRF40lS5YYgLF3795sz5Xl98LKlStz/Fu4eLw2m80YM2aMERQUZHh6ehq33nprtnMUHh5ujBs3Lsu2Dz/80H6O2rRpY/z555/FdET5c6XzcOjQoVz/Z6xcudJex7/Pw9X+vkqiK52HlJQU4/bbbzcqV65suLu7G+Hh4cYjjzySLZEpC+8Hw7j634ZhGMbHH39seHt7G3FxcTnWUVreExbDMIwibWISERERKWHUB0hEREScjhIgERERcTpKgERERMTpKAESERERp6MESERERJyOEiARERFxOkqARERExOkoARIRuQarVq3CYrEQFxfn6FBEpBAoARIRERGnowRIREREnI4SIBEpFWw2GxMmTKBmzZp4e3sTERHB3LlzgUuXpxYtWkTTpk3x8vLi+uuvZ8eOHVnq+P7772nUqBGenp7UqFGD9957L8vzaWlpjBo1irCwMDw9PalTpw7Tp0/PUmbz5s20atUKHx8f2rVrx969e4v2wEWkSCgBEpFSYcKECXzxxRdMmzaNnTt3MmLECPr3789vv/1mL/Pcc8/x3nvvsXHjRipXrkzXrl3JyMgAzMSld+/e9O3bl+3bt/PKK68wZswYZs6cad9/wIABfPPNN3zwwQfs3r2bjz/+mHLlymWJ46WXXuK9995j06ZNuLm58eCDDxbL8YtI4dJiqCJS4qWlpVGpUiWWLVtG27Zt7dsffvhhUlJSePTRR7n55puZPXs2ffr0AeDs2bNUq1aNmTNn0rt3b/r168fp06f59ddf7fs///zzLFq0iJ07d7Jv3z7q1avH0qVL6dSpU7YYVq1axc0338yyZcu49dZbAVi8eDFdunTh/PnzeHl5FfFZEJHCpBYgESnxDhw4QEpKCrfddhvlypWz37744gsOHjxoL3d5clSpUiXq1avH7t27Adi9ezft27fPUm/79u3Zv38/VquVrVu34urqyo033njFWJo2bWq/HxISAkBMTEyBj1FEipebowMQEbmapKQkABYtWkTVqlWzPOfp6ZklCcovb2/vayrn7u5uv2+xWACzf5KIlC5qARKREq9hw4Z4enpy9OhR6tSpk+UWFhZmL/fnn3/a7587d459+/bRoEEDABo0aMCaNWuy1LtmzRrq1q2Lq6srTZo0wWazZelTJCJll1qARKTEK1++PM8++ywjRozAZrPRoUMH4uPjWbNmDRUqVCA8PByA1157jYCAAIKCgnjppZcIDAykR48eADzzzDO0bt2a119/nT59+rBu3TomT57MRx99BECNGjUYOHAgDz74IB988AEREREcOXKEmJgYevfu7ahDF5EiogRIREqF119/ncqVKzNhwgT++ecf/P39adGiBS+++KL9EtSbb77J8OHD2b9/P82aNePHH3/Ew8MDgBYtWvDtt98yduxYXn/9dUJCQnjttdcYNGiQ/TWmTp3Kiy++yBNPPMGZM2eoXr06L774oiMOV0SKmEaBiUipd3GE1rlz5/D393d0OCJSCqgPkIiIiDgdJUAiIiLidHQJTERERJyOWoBERETE6SgBEhEREaejBEhEREScjhIgERERcTpKgERERMTpKAESERERp6MESERERJyOEiARERFxOkqARERExOn8P/7GYfxdx3RAAAAAAElFTkSuQmCC",
      "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_sum) + 1)), arr_train_acc_sum, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc_sum) + 1)), arr_val_acc_sum, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy Summary\")\n",
    "  plt.xlabel(\"epoch\")\n",
    "  plt.ylabel(\"accuracy\")\n",
    "  plt.legend(loc=\"upper left\")\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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_ner) + 1)), arr_train_acc_ner, label=\"train\")\n",
    "  plt.plot(list(range(1, len(arr_val_acc_ner) + 1)), arr_val_acc_ner, label=\"val\")\n",
    "\n",
    "  plt.title(\"Accuracy NER\")\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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = HeterSUMGraph(device=device, vocab_size=vocab_size, word_embed=embmgr.getEmbeddings())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test[\"doc_splitted\"] = split_all_docs(df_test[args.doc_column_name], False)\n",
    "test_set = df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)\n",
    "criterion = nn.BCELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model:   0%|          | 0/100 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Eval model: 100%|██████████| 100/100 [00:03<00:00, 28.14batch/s, accuracy_ner=0.914, accuracy_sum=0.66, loss=0.507, loss_ner=0.368, loss_sum=0.645, rouge1=0.275, rouge2=0.0721, rougeL=0.172]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\n",
    "arr_loss = []\n",
    "arr_loss_sum = []\n",
    "arr_loss_ner = []\n",
    "accuracy_sum = []\n",
    "accuracy_ner = []\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",
    "    data = batch[\"docs\"].to(device)\n",
    "    targets_sum = torch.tensor(batch[\"labels_sum\"], dtype=torch.float).to(device)\n",
    "    targets_ner = torch.tensor(batch[\"labels_ner\"], dtype=torch.float).to(device)\n",
    "\n",
    "    y_sum_pred, y_ner_pred = model(data)\n",
    "\n",
    "    loss_sum = criterion(y_sum_pred, targets_sum)\n",
    "    loss_ner = criterion(y_ner_pred, targets_ner)\n",
    "    \n",
    "    loss = loss_sum_coef * loss_sum + loss_ner_coef * loss_ner\n",
    "\n",
    "    arr_loss.append(loss.item())\n",
    "    arr_loss_sum.append(loss_sum.item())\n",
    "    arr_loss_ner.append(loss_ner.item())\n",
    "\n",
    "    doc = test_set[\"doc_splitted\"].iloc[idx]\n",
    "    summaries = test_set[\"summaries\"].iloc[idx]\n",
    "\n",
    "    probs = np.array(y_sum_pred.tolist()) # compute_probs(y_pred)\n",
    "    probs_tensor = y_sum_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_sum_pred, descending=True)\n",
    "\n",
    "    y_pred_thresh = []\n",
    "\n",
    "    txt = \"\"\n",
    "\n",
    "    for i in range(min(len(doc), y_sum_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\"].recall)\n",
    "    arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "    arr_rougeL.append(scores[\"rougeL\"].recall)\n",
    "\n",
    "    accuracy_sum.append(accuracy_nb_sent_per_doc_fn(probs=probs, targets=targets_sum.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",
    "    accuracy_ner.append(torch.sum(((y_ner_pred > 0.5).float() == targets_ner).float()).item() / targets_ner.shape[0])\n",
    "\n",
    "    tepoch.set_postfix(loss=np.mean(arr_loss), loss_sum=np.mean(arr_loss_sum), loss_ner=np.mean(arr_loss_ner), rouge1 = np.mean(arr_rouge1), rouge2 = np.mean(arr_rouge2), rougeL = np.mean(arr_rougeL), accuracy_sum=np.mean(accuracy_sum), accuracy_ner=np.mean(accuracy_ner))\n",
    "    idx += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_metrics = {}\n",
    "test_metrics[\"accuracy_sum\"] = np.mean(accuracy_sum)\n",
    "test_metrics[\"accuracy_ner\"] = np.mean(accuracy_ner)\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": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Lead-3: 100%|██████████| 100/100 [00:02<00:00, 49.61batch/s, rouge1=0.298, rouge2=0.0863, rougeL=0.189]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\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[\"summaries\"].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",
    "        # assert len(txt) - len(summaries) <= 20\n",
    "\n",
    "        scores = scorer.score(summaries, txt)\n",
    "        arr_rouge1.append(scores[\"rouge1\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\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": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "First-n-char': 100%|██████████| 100/100 [00:01<00:00, 58.89batch/s, rouge1=0.328, rouge2=0.0932, rougeL=0.201]\n"
     ]
    }
   ],
   "source": [
    "arr_rouge1 = []\n",
    "arr_rouge2 = []\n",
    "arr_rougeL = []\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[\"summaries\"].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\"].recall)\n",
    "        arr_rouge2.append(scores[\"rouge2\"].recall)\n",
    "        arr_rougeL.append(scores[\"rougeL\"].recall)\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": 39,
   "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/raoufdine/anaconda3/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3465: 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": "4f810f0bde7d7b5dc90f9e6832822547e13e234c53731a97fc91254323942f40"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}