4_finetuning_sbert_with_mnr.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7C3pqojKqV4V"
   },
   "source": [
    "# Finetuning SBERT for Semantic search using MNR loss\n",
    "\n",
    "In this notebook we will finetune the bert-base model for semantic search using Multiple Negative Ranking loss.\n",
    "\n",
    "This will be mostly similar to the finetuning we did in the previous notebook. The main changes are:\n",
    "- We won't use a fully connected layer on top of the embeddings now\n",
    "- We will use Multiple Negative Ranking loss\n",
    "- We will compute cosine similarity between the pooled u and v embedding and use that in MNR\n",
    "\n",
    "MNR loss\n",
    "> This loss expects as input a batch consisting of sentence pairs (a_1, p_1), (a_2, p_2)..., (a_n, p_n) where we assume that (a_i, p_i) are a positive pair and (a_i, p_j) for i!=j a negative pair.\n",
    ">\n",
    "> For each a_i, it uses all other p_j as negative samples, i.e., for a_i, we have 1 positive example (p_i) and n-1 negative examples (p_j). It then minimizes the negative log-likelihood for softmax normalized scores. This loss function works great to train embeddings for retrieval setups where you have positive pairs (e.g. (query, relevant_doc)) as it will sample in each batch n-1 negative docs randomly.\n",
    ">\n",
    "> The performance usually increases with increasing batch sizes.\n",
    ">\n",
    "> For more information, see: https://arxiv.org/pdf/1705.00652.pdf<br>\n",
    "(Efficient Natural Language Response Suggestion for Smart Reply, Section 4.4)\n",
    ">\n",
    "> You can also provide one or multiple hard negatives per anchor-positive pair by structuring the data like this: (a_1, p_1, n_1), (a_2, p_2, n_2)\n",
    ">\n",
    "> Here, n_1 is a hard negative for (a_1, p_1). The loss will use for the pair (a_i, p_i) all p_j (j!=i) and all n_j as negatives.\n",
    ">\n",
    "> Source: https://github.com/UKPLab/sentence-transformers/blob/master/sentence_transformers/losses/MultipleNegativesRankingLoss.py\n",
    "\n",
    "We will just use the (anchor, positive) pairs in our training here. We will discuss hard negatives later in the series.\n",
    "\n",
    "Since we just need the (anchor, positive) pairs, we will filter the snli dataset with label=0 for entails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c7EnaMhpx4me",
    "outputId": "e1bb59c3-6c80-4469-c594-791ac3840acb"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reusing dataset snli (/home/utsav/.cache/huggingface/datasets/snli/plain_text/1.0.0/1f60b67533b65ae0275561ff7828aad5ee4282d0e6f844fd148d05d3c6ea251b)\n",
      "Loading cached processed dataset at /home/utsav/.cache/huggingface/datasets/snli/plain_text/1.0.0/1f60b67533b65ae0275561ff7828aad5ee4282d0e6f844fd148d05d3c6ea251b/cache-737deef8acadbdc5.arrow\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(183416,\n",
       " {'premise': 'A person on a horse jumps over a broken down airplane.',\n",
       "  'hypothesis': 'A person is outdoors, on a horse.',\n",
       "  'label': 0})"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datasets\n",
    "\n",
    "dataset = datasets.load_dataset(\"snli\", split=\"train\")\n",
    "dataset = dataset.filter(lambda x: True if x[\"label\"] == 0 else False)\n",
    "\n",
    "len(dataset), dataset[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at an example of MNR loss using (anchor, positive) pairs per batch, based on the description provided by the sentence_transformers library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "cSYRRmqNK0Ug"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "batch_size = 8\n",
    "\n",
    "anchors, positives = [], []\n",
    "for i in range(batch_size):\n",
    "    anchors.append(dataset[i][\"premise\"])\n",
    "    positives.append(dataset[i][\"hypothesis\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uQQABrMlK0iJ",
    "outputId": "e0471ded-81c7-4caa-a909-e34d5f1a1ec4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A person on a horse jumps over a broken down airplane.',\n",
       " 'Children smiling and waving at camera',\n",
       " 'A boy is jumping on skateboard in the middle of a red bridge.',\n",
       " 'Two blond women are hugging one another.',\n",
       " 'A few people in a restaurant setting, one of them is drinking orange juice.',\n",
       " 'An older man is drinking orange juice at a restaurant.',\n",
       " 'A man with blond-hair, and a brown shirt drinking out of a public water fountain.',\n",
       " 'Two women who just had lunch hugging and saying goodbye.']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "anchors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1E3EzipXK7Gx",
    "outputId": "a2670714-8f7b-49c7-c00f-b38254bb112a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A person is outdoors, on a horse.',\n",
       " 'There are children present',\n",
       " 'The boy does a skateboarding trick.',\n",
       " 'There are women showing affection.',\n",
       " 'The diners are at a restaurant.',\n",
       " 'A man is drinking juice.',\n",
       " 'A blond man drinking water from a fountain.',\n",
       " 'There are two woman in this picture.']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "positives"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will use a fintuned model to try and show an example with good representations for the sentences instead of using random gibberish values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "doSPQiPJK8Bk"
   },
   "outputs": [],
   "source": [
    "from sentence_transformers import SentenceTransformer, util\n",
    "\n",
    "model = SentenceTransformer(\"all-MiniLM-L6-v2\")\n",
    "loss_fn = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Vz19gnbqLC5q",
    "outputId": "d3b18cf5-32e2-4869-e866-d9df4d842a42"
   },
   "outputs": [],
   "source": [
    "anchor_encodings = model.encode(anchors)\n",
    "postiive_encodings = model.encode(positives)\n",
    "\n",
    "similarity_matrix = util.cos_sim(anchor_encodings, postiive_encodings)\n",
    "target = torch.tensor(range(len(anchor_encodings)), dtype=torch.long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[ 0.6000, -0.0400,  0.0800, -0.1300, -0.0000,  0.0900,  0.1500, -0.0200],\n",
       "         [-0.1100,  0.5900,  0.1600,  0.2100,  0.1200, -0.1600, -0.0900,  0.0600],\n",
       "         [ 0.1200,  0.1200,  0.6400, -0.2200, -0.0500,  0.0500, -0.0000, -0.1100],\n",
       "         [-0.0900,  0.1200, -0.1900,  0.6700,  0.0900, -0.1400,  0.0900,  0.5800],\n",
       "         [-0.0300,  0.0800, -0.0100,  0.0400,  0.5000,  0.4900,  0.2300,  0.1300],\n",
       "         [ 0.0200, -0.1400,  0.0500, -0.1700,  0.3400,  0.6100,  0.3000, -0.1500],\n",
       "         [ 0.1800, -0.1100, -0.0200, -0.1300,  0.0200,  0.5100,  0.8700, -0.1300],\n",
       "         [-0.2000,  0.0900, -0.2500,  0.6100,  0.2800, -0.1000, -0.0800,  0.5300]]),\n",
       " tensor([0, 1, 2, 3, 4, 5, 6, 7]))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.round(similarity_matrix, 2), target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, each row in the similarity_matrix can be thought of as unnormalized scores for a class and each entry in the target array corresponds to the corresponding class label for that similarity row. The diagonal entries are our (anchor, positive) pairs hence they have the highest scores(this won't be the case with a bert-base model which hasn't been finetuned for STS, we observe this behavior here since we are using a model finetuned on STS tasks)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.6082)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn(similarity_matrix, target)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "qIsBo--EME-w"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import Callable, Iterable\n",
    "\n",
    "import datasets\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "from tqdm import tqdm\n",
    "from transformers import BertTokenizerFast, BertModel\n",
    "from transformers.optimization import get_linear_schedule_with_warmup\n",
    "from scipy import stats\n",
    "from sklearn.metrics.pairwise import cosine_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "5Ns-DN_pMJHq"
   },
   "outputs": [],
   "source": [
    "tokenizer = BertTokenizerFast.from_pretrained(\"bert-base-uncased\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t3-KGSOMLqff"
   },
   "source": [
    "Let's start ...\n",
    "\n",
    "## Data preparation\n",
    "\n",
    "We will create a custom dataset for the that will give us positive and negative pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aZrUqkodLT1E",
    "outputId": "990a9168-037c-416f-eee0-cffef87a7fd9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 45.1 s, sys: 22.4 s, total: 1min 7s\n",
      "Wall time: 31 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "MAX_LENGTH = 128\n",
    "\n",
    "# anchors\n",
    "tokenized_premises = tokenizer([data[\"premise\"] for data in dataset],\n",
    "                               max_length=MAX_LENGTH, padding=\"max_length\",\n",
    "                               truncation=True, verbose=True)\n",
    "# postives\n",
    "tokenized_hypothesis = tokenizer([data[\"hypothesis\"] for data in dataset],\n",
    "                                 max_length=MAX_LENGTH, padding=\"max_length\",\n",
    "                                 truncation=True, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "vCNDoCE7MKXM"
   },
   "outputs": [],
   "source": [
    "seed = 10\n",
    "\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will create out custom dataset and dataloaders with train/validation split for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "XArky0MCML_-"
   },
   "outputs": [],
   "source": [
    "class SnliDataset(Dataset):\n",
    "    def __init__(self, premise_tokens: dict, hypothesis_tokens: dict):\n",
    "        self.premise_tokens = premise_tokens\n",
    "        self.hypothesis_tokens = hypothesis_tokens\n",
    "        self._init_data()\n",
    "\n",
    "    def _init_data(self):\n",
    "        self.data = []\n",
    "        for pt_ids, pt_am, ht_ids, ht_am in zip(\n",
    "            self.premise_tokens[\"input_ids\"], self.premise_tokens[\"attention_mask\"],\n",
    "            self.hypothesis_tokens[\"input_ids\"], self.hypothesis_tokens[\"attention_mask\"],\n",
    "        ):\n",
    "            data = {}\n",
    "            data[\"premise_input_ids\"] = torch.tensor(pt_ids, dtype=torch.long)\n",
    "            data[\"premise_attention_mask\"] = torch.tensor(pt_am, dtype=torch.long)\n",
    "            data[\"hypothesis_input_ids\"] = torch.tensor(ht_ids, dtype=torch.long)\n",
    "            data[\"hypothesis_attention_mask\"] = torch.tensor(ht_am, dtype=torch.long)\n",
    "            self.data.append(data)\n",
    "\n",
    "    def __getitem__(self, ix: int) -> dict[str, torch.tensor]:\n",
    "        return self.data[ix]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "X0qGF8eQMntT",
    "outputId": "2ba8d5a5-565f-42e4-cb2a-92416ada352e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.11 s, sys: 242 ms, total: 4.36 s\n",
      "Wall time: 4.35 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "snli_dataset = SnliDataset(tokenized_premises, tokenized_hypothesis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "IOsjYf-oMpvw"
   },
   "outputs": [],
   "source": [
    "train_ratio = 0.8\n",
    "n_total = len(snli_dataset)\n",
    "n_train = int(n_total * train_ratio)\n",
    "n_val = n_total - n_train\n",
    "\n",
    "train_dataset, val_dataset = random_split(snli_dataset, [n_train, n_val])\n",
    "\n",
    "batch_size = 16  # mentioned in the paper\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Us3v9ug1M9wX",
    "outputId": "6d922cef-e85e-444a-8ae2-3f840655c358"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'premise_input_ids': tensor([[  101,  1996,  2611,  ...,     0,     0,     0],\n",
       "         [  101,  1037,  2158,  ...,     0,     0,     0],\n",
       "         [  101,  1037,  2177,  ...,     0,     0,     0],\n",
       "         ...,\n",
       "         [  101,  1037,  2711,  ...,     0,     0,     0],\n",
       "         [  101,  2019,  3080,  ...,     0,     0,     0],\n",
       "         [  101, 16031, 25711,  ...,     0,     0,     0]]),\n",
       " 'premise_attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         ...,\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0]]),\n",
       " 'hypothesis_input_ids': tensor([[  101,  1996,  2611,  ...,     0,     0,     0],\n",
       "         [  101,  1037,  2158,  ...,     0,     0,     0],\n",
       "         [  101,  1037,  2235,  ...,     0,     0,     0],\n",
       "         ...,\n",
       "         [  101,  1037,  2711,  ...,     0,     0,     0],\n",
       "         [  101,  2093,  2111,  ...,     0,     0,     0],\n",
       "         [  101, 27467,  2229,  ...,     0,     0,     0]]),\n",
       " 'hypothesis_attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         ...,\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0]])}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(train_dataloader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pfHThuIeNDO9"
   },
   "source": [
    "## Model config\n",
    "\n",
    "Here we will setup out custom SBERT model as detailed in the diagram from the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "tdD2iPt8NAW2",
    "outputId": "8bcaf256-abb7-4092-d7db-2574d2fa2e92"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method mean_pool() implements the mean token pooling strategy mentioned in the paper. The implementation has been picked up from the sentence_transformers library.\n",
    "\n",
    "We will use the encode() method to compute pooled embeddings using the finetuned and the bert-base models later to evaluate the results on STS tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "PC9pe_oSNMfe"
   },
   "outputs": [],
   "source": [
    "def mean_pool(token_embeds: torch.tensor, attention_mask: torch.tensor) -> torch.tensor:\n",
    "    in_mask = attention_mask.unsqueeze(-1).expand(token_embeds.size()).float()\n",
    "    pool = torch.sum(token_embeds * in_mask, 1) / torch.clamp(in_mask.sum(1), min=1e-9)\n",
    "    return pool\n",
    "\n",
    "\n",
    "def encode(\n",
    "    input_texts: list[str], tokenizer: BertTokenizerFast, model: BertModel, device: str = \"cpu\"\n",
    ") -> torch.tensor:\n",
    "\n",
    "    model.eval()\n",
    "    tokenized_texts = tokenizer(input_texts, max_length=MAX_LENGTH,\n",
    "                                padding='max_length', truncation=True, return_tensors=\"pt\")\n",
    "    token_embeds = model(tokenized_texts[\"input_ids\"].to(device),\n",
    "                         tokenized_texts[\"attention_mask\"].to(device)).last_hidden_state\n",
    "    pooled_embeds = mean_pool(token_embeds, tokenized_texts[\"attention_mask\"].to(device))\n",
    "    return pooled_embeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "abYBoikzNOMf"
   },
   "outputs": [],
   "source": [
    "class Sbert(torch.nn.Module):\n",
    "    def __init__(self, max_length: int = MAX_LENGTH):\n",
    "        super().__init__()\n",
    "        self.max_length = max_length\n",
    "        self.bert_model = BertModel.from_pretrained('bert-base-uncased')\n",
    "        self.bert_tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')\n",
    "\n",
    "\n",
    "    def forward(self, data: datasets.arrow_dataset.Dataset) -> tuple[torch.tensor, torch.tensor]:\n",
    "        premise_input_ids = data[\"premise_input_ids\"].to(device)\n",
    "        premise_attention_mask = data[\"premise_attention_mask\"].to(device)\n",
    "        hypothesis_input_ids = data[\"hypothesis_input_ids\"].to(device)\n",
    "        hypothesis_attention_mask = data[\"hypothesis_attention_mask\"].to(device)\n",
    "\n",
    "        out_premise = self.bert_model(premise_input_ids, premise_attention_mask)\n",
    "        out_hypothesis = self.bert_model(hypothesis_input_ids, hypothesis_attention_mask)\n",
    "        premise_embeds = out_premise.last_hidden_state\n",
    "        hypothesis_embeds = out_hypothesis.last_hidden_state\n",
    "\n",
    "        pooled_premise_embeds = mean_pool(premise_embeds, premise_attention_mask)\n",
    "        pooled_hypotheses_embeds = mean_pool(hypothesis_embeds, hypothesis_attention_mask)\n",
    "\n",
    "        return pooled_premise_embeds, pooled_hypotheses_embeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "un_1u6WxNl5V",
    "outputId": "9993396f-5ded-4517-b4d8-17bb7afa5a17"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "model = Sbert()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "kIWqkMw0NnRY"
   },
   "outputs": [],
   "source": [
    "#  optimizer, lr, num_warmup steps have been picked from the paper\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)\n",
    "total_steps = len(train_dataset) // batch_size\n",
    "warmup_steps = int(0.1 * total_steps)\n",
    "scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=warmup_steps,\n",
    "                                            num_training_steps=total_steps - warmup_steps)\n",
    "\n",
    "loss_fn = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "hAwA7NkuNonQ"
   },
   "outputs": [],
   "source": [
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "djG942tZRWbh"
   },
   "source": [
    "## Training loop\n",
    "\n",
    "While calculating the loss per batch, using the similarity matrix(from anchors and positives) and the target tensor, we scale the similarity matrix by a constant first. We are using a scaling factor of 20 as used in the sentence_transformer library.\n",
    "\n",
    "The reason for this scaling(from what i can tell) is the same as using temperature while decoding from seq2seq models. Essentially we want to make the distribution of scores(similarity in this case) more peaky(this amounts to lowering the temperature while decoding).\n",
    "\n",
    "For example, consider a batch size 4 with similarity scores [0.8, 0.75, 0.5, 0.4] with `similarity(anchor, positive)` = 0.8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_scores = np.array([0.8, 0.75, 0.5, 0.4])\n",
    "softmax_scores = np.exp(similarity_scores) / np.exp(similarity_scores).sum()\n",
    "scaled_softmax_scores = np.exp(similarity_scores*20) / np.exp(similarity_scores*20).sum()\n",
    "\n",
    "fix, ax = plt.subplots(1, 2, figsize=(14, 6))\n",
    "ax[0].bar(range(len(softmax_scores)), softmax_scores)\n",
    "ax[0].set_title(\"non-scaled similarity scores\")\n",
    "ax[1].bar(range(len(scaled_softmax_scores)), scaled_softmax_scores)\n",
    "ax[1].set_title(\"scaled similarity scores\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "qfT_sTq3Np7x"
   },
   "outputs": [],
   "source": [
    "def get_train_step_fn(\n",
    "    model: torch.nn.Module, optimizer: torch.optim.Optimizer, \n",
    "    scheduler: torch.optim.lr_scheduler.LambdaLR, loss_fn: torch.nn.CrossEntropyLoss\n",
    ") -> Callable[[torch.tensor], float]:\n",
    "\n",
    "    def train_step_fn(x: torch.tensor) -> float:\n",
    "        model.train()\n",
    "        anchor_encodings, positive_encodings = model(x)\n",
    "        similarity_matrix = util.cos_sim(anchor_encodings, positive_encodings)\n",
    "        target = torch.tensor(range(len(anchor_encodings)), dtype=torch.long, device=device)\n",
    "        loss = loss_fn(similarity_matrix * 20, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        optimizer.zero_grad()\n",
    "        return loss.item()\n",
    "\n",
    "    return train_step_fn\n",
    "\n",
    "\n",
    "def get_val_step_fn(\n",
    "    model: torch.nn.Module, loss_fn: torch.nn.CrossEntropyLoss\n",
    ") -> Callable[[torch.tensor], float]:\n",
    "\n",
    "    def val_step_fn(x: torch.tensor) -> float:\n",
    "        model.eval()\n",
    "        anchor_encodings, postiive_encodings = model(x)\n",
    "        similarity_matrix = util.cos_sim(anchor_encodings, postiive_encodings)\n",
    "        target = torch.tensor(range(len(anchor_encodings)), dtype=torch.long, device=device)\n",
    "        loss = loss_fn(similarity_matrix * 20, target)\n",
    "        return loss.item()\n",
    "\n",
    "    return val_step_fn\n",
    "\n",
    "\n",
    "def mini_batch(\n",
    "    dataloader: DataLoader,\n",
    "    step_fn: Callable[[torch.tensor], float],\n",
    "    is_training: bool = True\n",
    ") -> tuple[np.array, list[float]]:\n",
    "\n",
    "    mini_batch_losses = []\n",
    "\n",
    "    if is_training:\n",
    "        print(\"\\nTraining ...\")\n",
    "    else:\n",
    "        print(\"\\nValidating ...\")\n",
    "    n_steps = len(dataloader)\n",
    "    for i, data in enumerate(dataloader):\n",
    "        loss = step_fn(data)\n",
    "        mini_batch_losses.append(loss)\n",
    "        if i % (batch_size * 100) == 0:\n",
    "            print(f\"step {i:>5}/{n_steps}, loss = {loss: .3f}\")\n",
    "\n",
    "    return np.mean(mini_batch_losses), mini_batch_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hGpo6OdvOPfQ",
    "outputId": "940b7ff5-e1b0-489c-9308-88f6088fe40b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training ...\n",
      "step     0/9171, loss =  1.716\n",
      "step  1600/9171, loss =  0.286\n",
      "step  3200/9171, loss =  0.055\n",
      "step  4800/9171, loss =  0.172\n",
      "step  6400/9171, loss =  0.037\n",
      "step  8000/9171, loss =  0.266\n",
      "\n",
      "Validating ...\n",
      "step     0/2293, loss =  0.122\n",
      "step  1600/2293, loss =  0.043\n",
      "CPU times: user 20min 46s, sys: 6min 21s, total: 27min 7s\n",
      "Wall time: 27min 3s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "n_epochs = 1  # mentioned in the paper\n",
    "\n",
    "train_step_fn = get_train_step_fn(model, optimizer, scheduler, loss_fn)\n",
    "val_step_fn = get_val_step_fn(model, loss_fn)\n",
    "\n",
    "train_losses, train_mini_batch_losses = [], []\n",
    "val_losses, val_mini_batch_losses = [], []\n",
    "\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    train_loss, _train_mini_batch_losses = mini_batch(train_dataloader, train_step_fn)\n",
    "    train_mini_batch_losses += _train_mini_batch_losses\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        val_loss, _val_mini_batch_losses = mini_batch(val_dataloader, val_step_fn, is_training=False)\n",
    "        val_mini_batch_losses += _val_mini_batch_losses\n",
    "        val_losses.append(val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FjKQUeXdQu2t",
    "outputId": "cd9243f0-6998-4bc9-a925-29d4ab3b8195"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.176284230241434, 0.1142814209404556)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_loss, val_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normally we look at losses over multiple epochs, but here we have only 1 epoch. One way to look at the mini batch losses is to use a running mean(smoothing) to reduce noise from per batch loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "TdZNZXuzpI9O"
   },
   "outputs": [],
   "source": [
    "window_size = 32\n",
    "\n",
    "train_mb_running_loss = []\n",
    "for i in range(len(train_mini_batch_losses)-window_size):\n",
    "    train_mb_running_loss.append(np.mean(train_mini_batch_losses[i:i+window_size]))\n",
    "\n",
    "val_mb_running_loss = []\n",
    "for i in range(len(val_mini_batch_losses)-window_size):\n",
    "    val_mb_running_loss.append(np.mean(val_mini_batch_losses[i:i+window_size]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 592
    },
    "id": "uIT6QOkVRdX9",
    "outputId": "1caf5432-8294-4a4e-bdb7-df37d8705cd5"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fix, ax = plt.subplots(figsize=(14, 8))\n",
    "ax.plot(range(len(train_mb_running_loss)), train_mb_running_loss);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UwsWPXh_RrwB"
   },
   "source": [
    "## Evaluation\n",
    "\n",
    "Here we will manually inspect the performance of our finetuned model as well as use a STS dataset for evaluation on a similar task as mentioned in the paper.\n",
    "\n",
    "For manual inspection, we have taken few texts which fall neatly into three clusters. We want to see how neatly our finetuned model(and the bert-base model) is able to find these clusters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "5MtxNRoKRjmK"
   },
   "outputs": [],
   "source": [
    "def plot_heatmap(similarity_matrix: np.array, sentences: list[str]) -> None:\n",
    "    fig, ax = plt.subplots(figsize=(10, 10))\n",
    "    im = ax.imshow(similarity_matrix, cmap='YlGn', interpolation='nearest')\n",
    "\n",
    "    ax.set_yticks(np.arange(len(sentences)), labels=[txt[:50] + \"...\" for txt in sentences])\n",
    "    ax.set_xticks(np.arange(len(sentences)), labels=[txt[:50] + \"...\" for txt in sentences])\n",
    "\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n",
    "\n",
    "    for i in range(len(sentences)):\n",
    "        for j in range(len(sentences)):\n",
    "            text = ax.text(j, i, round(similarity_matrix[i, j], 2),\n",
    "                           ha=\"center\", va=\"center\", color=\"w\")\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "id": "OlxZsGVYRuJo"
   },
   "outputs": [],
   "source": [
    "sentences = [\n",
    "    \"What should I do to improve my English ?\",\n",
    "    \"What should I do to improve my spoken English?\",\n",
    "    \"Can I improve my English?\",\n",
    "    \"How can I earn money online?\",\n",
    "    \"How do I earn money online?\",\n",
    "    \"Can I earn money online?\",\n",
    "    \"What are some mind-blowing Mobile gadgets that exist that most people don't know about?\",\n",
    "    \"What are some mind-blowing gadgets and technologies that exist that most people don't know about?\",\n",
    "    \"What are some mind-blowing mobile technology tools that exist that most people don't know about?\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "kOV-JHeyRwUG"
   },
   "outputs": [],
   "source": [
    "pooled_embeds = encode(sentences, model.bert_tokenizer, model.bert_model, device)\n",
    "pooled_embeds = pooled_embeds.cpu().detach().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our finetuned model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "GmWmduDFRxzq",
    "outputId": "833264fd-c012-4f61-e7df-d0523125352e"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs8AAAKECAYAAAD47dcYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdeXwV9b3/8ddnzjnZAwFCWBJ2UUHcAXfEXdRqaxe13vpDa7WbXrvf2lu11rZ6622L1y621rrUVuuO4oYralUUQRFEtrCEsIeEbGedz++PmSTnnJzAISYn0H6ejwcPMzPfmXnPnJOTz3zne0ZRVYwxxhhjjDG75/R1AGOMMcYYY/YVVjwbY4wxxhiTJSuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWQr2dQBjjNkdyQsqBaG+jrHnHOnrBN0T2kdzAwdVVfR1hH8rjuyb75WQU9jXEbop0dcBuk1138u+bu0Wtm1r6PQmt+LZGLP3KwjB0WP6OsWeK9pHP2LLC/o6Qbc9cutVfR2hW/bV/+NCQWAfvKgFqoon9nWEbknozr6O0G0xt7GvI+yxaUdfnXG+DdswxhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaCfR3AGGN625+/fRPnHH0iW+rrOPiK8zK2mfX1azlryjRaIq3MvPVaFq78KMcpPWccfhyzLv8BAcfhzrmPcsujd6UsLysu5a6rbmTc0BGEoxEuu/16lqxbyf7DR/Pg9/6nvd3YIVVc9/ffMevJv+Ym90FHM+ui73i5X3uCW565NzV3USl3zfwx4yoqCceiXPaXn7KkdjX5wTzm/eAO8oN5BJ0ADy94kRtm/yknmdsUBYczpHAyIDREV1IXWZKyvDA4hMri6cTcJgCaouvYHlmM4DCi5AxEHASHxthatoc/yFnu4uBwKgonIwj1GXIXpeVuTMo9Mi33thzmLgwMZWDBEYDQFFtNQzT1d60gUEFF4fHE3WYAmuM1NES9YxtUMJWiwHASGqa25dmcZQYQSnCkEgBX61C2dtGykIDsh6vrUBoAcKQKoR8QJ6HLcxPYJ5QRdMYiCAndTEJrumhXQsg5lLi7DJftgBByDqGtn9XV7SR0Xc5yB6Sc/MAEQIi5NcTc1RnbOdKfwsAxhBOLSOgmf26QgsDBOFICQDixGFfreyyb9TxnSUR+LSLXJE0/JyJ3Jk3/r4h8W0Smi8hTe7jtmSIyfA/a3yAi392TfexiW3eLyOcyzM94HNken4i8IiKT9yDHNSJSlG17f507RWTinqzzr8B/v2wVkUVJ/7p1Hvxt3e7//FURuWQXbXf7vhORChF5QUQWi8i7IrJfd3L1tLvnPsaZ117R5fIZU6YxvnIU4y89kyt+cz2/v/r6HKbr4DgOv73yWmbc+DUmXvVpLjphBhOqxqa0ufZzX2FR9ccces3nuGTWj5h1+Q8AWF67hsO/9QUO/9YXOPI7F9ISCfPYWy/mJrc4/Pbi7zPjN//JxB9fwEVTz2DCsDGpuc+ayaL1yzn0hou55M83MOui7wAQiUc5+davc9hPLuawGy/mzEnHcNTYSTnJ7RGGFE6lpvklqhufpDRvNHlO/06tWuNbWNs4h7WNc9geWQyA4rK+aS5rG+ewpvEpioOVFATKc557deOT9NtF7jWNc1iTlntd01zWNM6hug9yDyyYzOaWV9nQ/AzFwZGEnH6dWoUTW6lteY7alufaC2eAplg1m1tfzVHWVI5UktBqErocR8qA/C7aDUNpTJnn6g4SWt37ITMIOeOIuUuIuu/hyGCEwoztgs5oXHYkzVFi7mJi7kJi7iIcGYBQmpvQQH7gIFrj79ISf42gMwyhJGO7POcAEro1bd0JxN2ttMRfoyX+Oq429Wg2K56z90/gWAARcYBy4KCk5ccCb3Rz2zOBrIvnf1HXAHtUPKvq5aq6tCdDiGdf+L14UFUPS/r3ic+Dqv5BVe/dfctdCgLfVdWDgT8B//VJc/WE1xYvoK6xocvl5x17MvfOfQKAt5d9QFlxKUMH5qqY6DB1/CRWblxH9eYNxOJxHnj9Wc476qSUNhNHjOXFD94G4OMNaxhdMZyK/gNT2pxyyFGs2rSedVs35ib3mINYuaWG6m21xBJxHpj/POcdNi019/AxvPjRO17uTWsZPWgYFf283M2RVgBCgSChQBBVzUlugILAIGJuo98769IYXUtJaETW6ytxAAQHQXopZWcFgUFEk3Lv3Edy5zsDibuNxLUZcGmOr6MoWJn1+pHEVlyN9l7ALhWhRIEooLha7/ckpxLKUW0A//x2aM4wr/cJpShhIIKXeyuODOrULiDDSeh20FjaErd9S96/3PxuOlKGq80orYASdzcSdCo6tQs5o0noJv+1aRMkIAOJt/ewKz197veFImFv8QZ+8YxXNH8INIrIABHJByYAC/3lJSLysIgsE5H7RUQAROQ6EXlHRD4UkT/6hdrngMnA/X4PYsoloYhcLSJLReQDEXkgadFEv3d3tYhcndT+2/72P2zrKReR0SLyYVKb74rIDekHKCJn+plfB87fk5MjIoUi8oCf80HouLQVkYv8nsgPReSWDOtejXfx8LKIvJzNOn6b9t5tEWkSkVtEZIHf8zk16fyc67eZKSJPiMizIvKxiFyfdH4+EpHfAe8BI0Tkl/6+F4vIBX67B0XkrKT93y0inxWRgN/+Hf/4r8yQdbR/bu/0t3u/iJwqIm+IyAo/r+P/PNhfxxGRlSKSVRUn3l2BV7p4753V9tqKyG2S+a5Ce8/ynr7v2qhqraou8icLgHA22fta5aAK1m/d1D5ds20zlYOG5D7HwCGs37a5I8f2zVQOTP2D8f6a5Zx/9CkATBk/iVGDh1FVnpr1wuPP5O+vPdP7gX2VAwazfkdS7h1bqBwwOKXN++tXcP4R3oXAlDETGTVoKFUDvGNzxGHhdX9ly6+eY+7S+cyvTh1+0JuCThExf3gAQNxtJuh07pkrDAxmVOnZVBafnNbDK4wqPZv9+n+e5vhGwoltOUgNIaeofVgDeLlDXeQeXXo2VRlyjy49m/E5zh1wCom7Le3TcbeVgHTOnR8oZ3jRGVQUTsvYM51rQghILixjiITSWgVxpB/K9hwm2zUhD9VI+7QSQchLa5WHI4NwNfPFdsg5jDznKFytR+nZHtyuCAV+0e9RDSMUpLXJJyhDiLmpQ0kcClGNkh84mMLgceQHJgGBHs1nxXOWVLUWiIvISLwi+k3gbeAYvOL3A9X2y+HD8XpSJwJjgeP8+ber6hRVnYRXXJ6jqg8D7wIX+z2IrWm7/i/gcFU9BPhq0vwDgTOAqcD1IhISkSOBS4GjgKOBr4jI4dkcn4gU4PUUfgo4ARiazXpJvga0+Dl/Bhzpb3c4cAtwMnAYMEVEPp28oqreBtQCJ6nqSdmsk0Ex8IqqHgk0AjcBpwGfAW5MajcVuNjf7uelY2jJAcC9qno43ut5GHAocCrwSxEZBjwAtBXSecApwNPAl4EGVZ0CTME776n3rD37AbOAQ/Bevy8CxwPfBa5VVRf4q58Pf9/vq2qmv2oXSOqwjba/Pp3ee/5rewcwQ1WPBwZn2F66rN93mVYWkcOA/wRuzWJffc6/xkihOephSc3ReV56jpsf+TMDSvqx8Nf/4KqzL2Lh6mXEE4n25aFgkHOnTuehN57v7bjtMvVcpnce3/zMvQwoLmXhdX/lqpO/wMJ1y9tzu+py+I3/QdX3zmHqmIkcNHxsp+31pUi8jlU7H2Vt4xzqI8uoLJ6etFRZ2ziHVTsfoTBQTp5T1kcpOwvH61i581HWNM5hR2QZVWm51zTOYeXORyjIae7d93JHEnXUND1JbctzNEZXUFF4Qg5yfXKODE8ac7vvCDpjibtrulwecxcRdefjSAmyZzeIe1jqh0p+YAIR9+POzURwpB8xdx2t8TdQTZDn9Oxnin1hcM+09T4fC/wKqPR/bsAb1tFmvqp3v0BEFgGjgdeBk0Tk+3jDEwYCS4And7PPD/B6pR8HHk+aP0e9y8mIiGwBhuAVYo+parO/70fxCuHZWRzbgUC1qq7w1/0r0PUg0c6mAbcBqOoHItL27ZMpeEXtVn+79/ttH8+0kU+wThRo+/bIYiCiqjERWYx3/tvMVdXt/nYfxTtnjwNrVfUtv83xwN9VNQFsFpFX/UzPALeJd6fhTGCeqraKyOnAIdIxdrw/MB5IH+BWraqL/X0vAV5UVU3LeBfwBPAb4DLgL10c74Oq+s3kGX4BmOm91wSsVm0fcPd3dv/a7sn7LtO3T+4CZqrqmt3sp0sickV7zoLe/aiq2baZEYM7rheryodQu31Lr+4zY47tmxmR1ItcNWgItXWpY/kaW5u57P+ua5+u/uMzVG/e0D4944jjeW/1R2xpqOv9wL6aHVsYMSAp94AKauvTcoebuewvP22frr75caq31aa0aWht4pWP3+PMScewpDbzl4N6WtxtIeQUt08HnWLibmofhpvU49gcr0XEISD5JJJ69FyN0RLfTHFoONFIfa/njrktBNNyxz5B7pLQcOpykDvhthAMdRRgQaeQRFqfkSbdYm9NbERwcCSvj4ZrtGWK+b3PbUJo2hAHoYiAjPSnAoj0w1VF2ZmznOmUKCL57XWnkJ82xAEcSnCcA/ypEI4MIO4qLsmfIQlcbcCRASS0hd6mpPY0ixSgRFLaONKfgsCh3nLyCAQGE0m4fg95GFe9oXpx3dTjxbP1PO+ZtnHPB+MN23gLr+c5fbxz8iucAIJ+79/vgM8ljQdNvQeR2dnAb/F6cheISFsV0WkfdH1JHyf1te5qv5+0qy3T+t0ZTNeddWLaMVDSxT8/fm9ucuWVnrFtujlpXsb9q2oYeAWv5/UCvJ7otvZXJY0/HqOqmbr9kl8zN2m6PaOqrscr2E/Gu4Owp/fe9+R9sSt78r7LZD9VndeN/bZT1T+q6mRVnUyod4vn2W++xCWneU/hOOrAQ2hobmRTXW5uYyd7Z8USxg8bxeiKSkLBIBcefyaz57+S0qZ/cSmhoHc+Lj/ts8xb8h6NrR1v34tOmMHf5+VuyAbAO2uWMn7ICEaXDycUCHLh1NOZ/f5rqbkLSwgF/NwnnMe85YtoDDdTXlJG/0Lvi0AFoXxOnTCVZZvW5ix7OLGdkFNKyCkBHErzRtEUW5/SJiAdH5kFgUGAkNAIAcnH8W++CAGKQkOJJroeW9/TufOScvf7BLmLQ0OJ5Ch3xK0j6JQSlGLAoTg4kpb4hpQ2ybnzHG9cfF8Wzp4Wf7hDCBAcKetUFCd0Wfs/pQFXN/Rp4QygNPpfEMzHyz0YV1MvrKPuu+3/XN1G3F3lF85BOoY7ON4x56BwBvxCvdjPLgSdYSTc1A6Nlvir7f/iuolIYikJ3YIS9Yd5eBeXQRnU418YtJ7nPfMG8B28XrwEUCciZXhjoL+ym3XbPg22iUgJ8DngYX9eI3T+Cqt4X1wboaovizcO+YvQxddNPfOAu0XkZryC6TPAl4DNQIWIDMLrhTyHjl7aNsuAMSIyTlVXARft5ngy7ftivHHLk/CGJoA3tGWWP253h7/d/8uwfts52LYH63THaSIyEGgFPo3Xu5vpWK4UkXvw7hBMA77nL3sAuBxvaMdMf95zwNdE5CW/t3t/YEPbHYBuuBNv+MZ9/vvsk1oGjBWR0X5P8AW7atyN910ml3YraS/52w9/yfRDplLev4z197/E9ffdTijgFQ93zHmQp+fP46yp01h597O0RMJceuuP+iRnwk3wzT/9nOeu/z2BQIC7XnicpetXceUZn/eyPvcQE6rGcO9//oyE67J0/Sq+fHvHk0EK8wo47dBjuPL3P+1qF72X+2+/5LlrbiPgONz1xpMsrV3NlSd6X52449VHmTBsDPd++Xov98Zqvnz3TQAMKyvnnsuuJ+A4OOLwj3deYM4Hr+cwvbKldT5VxafQ9qi6qNtA/7zxADREV1AaGkVZ/v4oLqoJapu9C4OgFDK06Dj/ro/QGF1Dc1oh2Ju5N7fOZ0Ra7jI/d72fe0AXuYcVHQciCMLOHOeuCy9gSNGJgENTbDUxdyeloXEANMZWURQcQWloP8BFSbC1tePGbnnBMRQEKghIPlXF51If/ZCmWG7uUrhaS0DG+j/vACIIA9uOapfrOjLSL+aCBORAXN2MpjzZovfE3VWEnEkIkNDNKC044t1pc3cxzETII+jsT1v/i6vb0p7G0ZuUSGIphcEptD2qzqWJoON9KTburt/l2pHEUq9XWgTVVsKJnn0UoxXPe2Yx3lM2/pY2r6SLcantVLVeRP7kt18DvJO0+G7gDyLSChyTNO45APxVRPrjvXt/7W+nq328JyJ3A/P9WXeq6kIAEbkRryitxium0tcN+7fJ54jINrxhJnvyvKjfA3/xh2ssasugqhtF5IfAy/4xPK2qT2RY/4/AMyKy0R/3nM063fE6cB/e+OO/qeq7IjI6rc1jeHcU3sfrmf6+avsnzPPAvcDspDHud+INj3jP/4LeVrzCvLtm4w3X6GrIBnhjno9Pmv56Vw39oSVfB571X9v5XbX17dH7rgvfAR5pmxCRr/pZ/uCPM/+qql7uL1ukqoftycb31Bd/8b3dtvnm7Tf1ZoSsPbPgdZ5ZkFo83vHcQ+0/v/XxB+z/9U9lXLc1Gqb8kmkZl/W2Zxb/k2cW/zNl3h2vPtr+81urF7P/jzo9FZPFNSs54sYv9Xq+XWmO11LdmPoR0xBd0f5zffRj6qOdx1ZG3HrWNs3p9XxdaY7Xsjotd32Wudf0Ye7WxEY2NKd+Oa0xtirp5xU0xlakrwbAtvCbvZptV5RGEvpx2rzMRbOb9ixlN4fPR07nsgPXXZA6r4uiOa4d511pIeYu6s1ou5TQrbTEU4d/dVU0RxKLU6ZdGmlN/DNj254guXwkkDF9SURmApPTxwrvbfzi8teq2mPfkhGRElVt8ov73wIrVPXXPbX93ib9CpWjM30Hcy9XtI/2T5RnM6Js77Ts1qv6OkK37Kt/iQsCGb8zvNerKt43/xcBCe3bYSCfRMxt3H2jvcy0o6/mvQUrOvUc2ZhnY/YiIvJfeD22P+zhTX/F/wLhErwvNN7Rw9s3xhhj/i3so90ixuw5Vb0bb4jMXktVbwZu7oXt/hrYZ3qajTHGmL2V9TwbY4wxxhiTJSuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWbLi2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMloJ9HcAYY3bLESjaBz+uWuJ9naB7HOnrBN0WSST6OkK3OLJvnvOE4/Z1hG5JaF1fR+iWmNva1xG6rSHa3NcR9lhCM7+/refZGGOMMcaYLFnxbIwxxhhjTJaseDbGGGOMMSZLVjwbY4wxxhiTJSuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWbLi2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMloJ9HcAYY3rDGYcfx6zLf0DAcbhz7qPc8uhdKcvLiku566obGTd0BOFohMtuv54l61ay//DRPPi9/2lvN3ZIFdf9/XfMevKvuT4E/vztmzjn6BPZUl/HwVecl7HNrK9fy1lTptESaWXmrdeycOVHOU7pOeOgo5l1wbe98/36bG559t6U5WVFpdz1//6bcYMrCceiXHbPTSypXU1+MI953/sD+cE8goEADy94iRue/FNOs5eEKqksngoIdeEVbA0vTlleHBzK6NKTibpNADRE17Kl9f2kFsL4/ucQc1tY0/hiDnMPZ1iRl3tHZAXbwh+m5R7CyJKO3Duja9ka/iAl97h+ZxNzW1jX9FLOchcGhlFecCQiws7oKuqjS1OWFwQqGFo0jbjbDEBzbD07oh8SkCKGFB5DQAoAZWdsFQ3Rj3OWWxhI0NkPQUjoRhK6rot2pYScI4i7S3HZmrIs5ByJEiXuLs64bm8ISDn5gQmAEHNriLmrM7ZzpD+FgWMIJxaR0E3+3CAFgYNxpASAcGIxrtbnJHey/MAQ+ucdhiA0x6tpiqW+7nnOYAYVHNv+ngknNtAY673Pwr2251lEfi0i1yRNPycidyZN/6+IfFtEpovIU3u47ZkiMnwP2t8gIt/dk33sYlt3i8jnMszPeBzZHp+IvCIik/cgxzUiUpRte3+dO0Vk4p6sYzqISFMvbHONiCwWkUX+v9s+4bbK/Z//uZu2GY9FRH4iIktEZKWIfKW7WT4px3H47ZXXMuPGrzHxqk9z0QkzmFA1NqXNtZ/7CouqP+bQaz7HJbN+xKzLfwDA8to1HP6tL3D4t77Akd+5kJZImMfeyl1BlOzuuY9x5rVXdLl8xpRpjK8cxfhLz+SK31zP76++PofpOjji8Nsvfo8Zt13DxOsv5KIppzNh2JiUNtfOmMmi9cs59Mb/4JK//IRZF3wbgEg8ysm/+gaH/fQ/OOyn/8GZk47mqDGTcpheqCw+iuqdc1le/zhl+WPID/Tv1Ko5vpkVDbNZ0TA7rXCG8oIJhBMNuQrsE4YXHc2axhdY2fAE/fPGkO9kzr1q55Os2vlkWuEMgwomEOmD3IMLJ7Ox5WXWNc2hJDSKkNOvU6twfCs1zc9Q0/wMO6JtFwUu28Lvsb55DjXNz9MvND7jur0l5Iwn5n5A1J2PIxUImf+EBp2xuNR1mh+QKlRbejtmJ/mBg2iNv0tL/DWCzjCEkozt8pwDSOjWtHUnEHe30hJ/jZb467ja43/GslKWdzjbw6+zufU5igIjCEpppzbRxDa2hl9ga/iFXi2cYS8unoF/AscCiIgDlAMHJS0/Fnijm9ueCWRdPP+Luga6+M3vgqperqpLd98ye+LZm9+H+4KTVPUw/9/VPbFBVT22m6u+BUwCjgJ+ISJ9cndr6vhJrNy4jurNG4jF4zzw+rOcd9RJKW0mjhjLix+8DcDHG9YwumI4Ff0HprQ55ZCjWLVpPeu2bsxZ9mSvLV5AXWPXxc15x57MvXOfAODtZR9QVlzK0IHluYrXbuqYiazcUkP1tlpiiTgPvDOX8w6dltJm4vAxvLjsXQA+3rSW0eXDqCj1zndzpBWAUCBIKBBE0ZxlLwqWE000EnWbUFzqI9X0C43Mev2QU0RpXhV14eW9mLKzwmA5EXcnMT93Q7Sa0rwRWa8flCJKQ1XsiKzoxZSd5QcGEXObiGsz4NIUW0txsCqrdRMaJuruAECJE3N3EtyzPqBuE/qhtAJhQHF1C450/l0LSJVXgGosbUk+jgwiobn9LHGkDFeb/exK3N1I0Kno1C7kjCahm1CiSXODBGQgca3xpxWI5yB1qjxnIHG3iYQ2A0pLYj0Fwb4t4fbmouUN/OIZr2j+EGgUkQEikg9MABb6y0tE5GERWSYi94uIAIjIdSLyjoh8KCJ/9Au1zwGTgfv9nrrC5J2KyNUislREPhCRB5IWTfR7d1eLyNVJ7b/tb//Dtp5yERktIh8mtfmuiNyQfoAicqaf+XXg/D05OSJSKCIP+DkfBAqTll3k90Z+KCK3ZFj3aryLh5dF5OVs1vHbtPdui0iTiNwiIgtE5AURmZp0fs7128wUkSdE5FkR+VhErk86Px+JyO+A94ARIvJLf9+LReQCv92DInJW0v7vFpHPikjAb/+Of/xXZsg62j+3d/rbvV9EThWRN0RkhZ/X8X8e7K/j+D2m5WnbOjGpZ3ehiJSKd0dgnog85r9f/tB2EZDF+S8XkTdF5GwRGSwij/jH8o6IHOe3uUFE7sr0nsuGv94tIjJfRJaLyAn+/CIR+Ufb+0ZE3pYMdyzE71kWkWH+cS7yj+eEpDY/E5H3ReQtERkCoKrPqKrifba4kMMqKEnlwCGs37a5fbpm+2YqB6b+wXh/zXLOP/oUAKaMn8SowcOoKh+S0ubC48/k76890/uBu6lyUAXrt25qn67ZtpnKQUN2sUYv5SirYH1d0vmu30LlgMEpbd5fv4LzD58OwJTRExk1cChVA7zXxBGHhT++jy23PsvcpfOZX70kV9EJOUXE/Fu9ADG3mVCgc0FWFBzM+P7nMrr0VPIDZe3zhxVNZVPzglxETRGSImKJjtxxt4WQU9ypXVFwMOP6fYpRJaek5i6ewqaWd8n1r2hQCttvrQPEtYWg0/l8FwTKqSqewbCi6YQy9KgHpZi8wADCiW29mreNkI9qpH1aiSDkp7XKw5FyXK3ttH7Q2Y+4u6qXU3YmFKCE26dVwwgFaW3yCcoQYm7qMBSHQlSj5AcOpjB4HPmBSUAgF7FTc0ghCW1tn05oK4HU0g2AvMBAKgpOZVD+8QSld+9I7LXFs6rWAnERGYlXRL8JvA0cg1f8fqCqbZdIh+P1pE4ExgLH+fNvV9UpqjoJr7g8R1UfBt4FLvZ76jpeEc9/AYer6iHAV5PmHwicAUwFrheRkIgcCVyK18t2NPAVETk8m+MTkQLgT8CngBOAodmsl+RrQIuf82fAkf52hwO3ACcDhwFTROTTySuq6m1ALV6P5UnZrJNBMfCKqh4JNAI3AacBnwFuTGo3FbjY3+7nkwq1A4B7VfVwvNfzMOBQ4FTglyIyDHgAaCuk84BTgKeBLwMNqjoFmIJ33lPvEXv2A2YBh+C9fl8Ejge+C1yrqi7wVz8f/r7fV9X0T+PvAt9Q1cPwXqu298xU4DvAwcA44PzdnUu/yJwDXKeqc/x8v/aP5bNA+9AkMrznMhwjeBdBbcX9t5LmB1V1Kt7vRtv9/K8DO/z3zU/x3ze78EXgOf/YDwUW+fOLgbdU9VBgHtA+RMPP+QDwE1VN7Gb7vcK7fE6V3pt58yN/ZkBJPxb++h9cdfZFLFy9jHiiI24oGOTcqdN56I3neztut0mGA81lr21Hjs7zvGuoDjc/ey8Divqx8Mf3cdXJX2Dh+uXEXe98u+py+E+/RNUPPsXUMQdx0PCxnTeYS2mnsDWxnWU7HmZFw2y2hz9idOnJAJSGqohrmNbE9j4ImUlq8NZ4HcvrH2HVzifZHlnGyBLv7ktpqIq4Gyac6Dy0oG+k5o4k6ljb9AQ1zc/QEF3O0MLUuxhCkKFFJ7A9vADtg57QDqm5vQK583hih0GgUZS+GfLQWWru/MAEIm6GseMiONKPmLuO1vgbqCbIc/r4d7MLMXcHm1qeZkv4BZriKxlUcEyv7m9v/8JgW+/zscCvgEr/5wa8YR1t5qt69xVEZBEwGngdOElEvo83PGEgsAR4cjf7/ACvV/px4PGk+XPUu+yMiMgWYAheIfaYqjb7+34Ur7iancWxHQhUq+oKf92/Al0PbuxsGnAbgKp+ICJtg9mm4BW1W/3t3u+3fTzTRj7BOlHgWf/nxUBEVWMishjv/LeZq6rb/e0+infOHgfWqupbfpvjgb/7hdZmEXnVz/QMcJt4dxrOBOapaquInA4cIh1jx/sD44HqtIzVqrrY3/cS4EVV1bSMdwFPAL8BLgP+kuFY3wB+5Z+XR1W1xi9a5qvqan/7f/ePI7aLcxkCXsQrxF/1t30q3l2Ntn31E2kfzJXpPdd2/yzZSRkKfoBH/f8uSDre4/EKdlT1w6T3TVfeAe7yC+LHVXWRPz8KtI3FX4B34dTma3iv7293s+1dEpEraPudKOzquiGzmu2bGZHUi1w1aAi1dalj+Rpbm7ns/65rn67+4zNUb97QPj3jiON5b/VHbGnYWwqMzmq2bWbE4I7r7qryIdRu35L7HDu2MGJg0vkuq6C2PvUt2Rhu5rJ7fto+Xf3zx6jeltpD19DaxCsfL+DMg45hSW3mLzX1tFhaj23IKSbmpo5LdZNuwTfGNiA4BCSf4lAF/UIj6FdWhUiAgIQYUXIC65te6/3c2kIo0JE76BR1zk1H7qak3EXBCvrljaA01JG7qvh4appf7/XccW0lmHS+g1JE3E3tw0ouiFvitZQXTMaRfFyNAMLQohNojK2hOZ7p47B3KBFE8tvrTiE/bYgDOJTiOG1fCwrhyEDiriJSiiPl5MkgvD7LAEGZQFx7/8u9SmpPs0gBSiSljSP9KQgc6i0nj0BgMJGEi6v1KGFc9YaOxXVTnxTPblpPcyCtJxpS3zORxCbgcBzycNNeo56y1/Y8+9rGPR+MN2zjLbye5/TxzsnvhAQQ9Ht2fwd8TlUPxuvlTb1XkdnZwG/xeuQWSMeYzU77ADL0twDeoKDkc9vVfj9pF1Gm9bvKtCvdWSemHV1LLv758Xtzky/K0jO2TTcnzcu4f1UNA6/g9b5egNeb2db+qqRxvmNUNVP3YPJr5iZNt2dU1fV4BfvJeHcQOt2jV9Wbgcvx7l68JSIH7uLYdnUu43iF5hlJ8xzgmKRjqVTVxgz5295ze6Jt/eR19+i1VtV5eMX/BuA+EbnEX5T8+qdnO4QM53FPqeofVXWyqk4mb88O/Z0VSxg/bBSjKyoJBYNcePyZzJ7/Skqb/sWlhILedi8/7bPMW/Ieja0db8uLTpjB3+ftvUM2AGa/+RKXnOY9heOoAw+hobmRTXW5uY2d7J01HzG+YgSjBw0jFAhy4ZTTmP3+vJQ2/QtLCAX88338ecxbsYjGcDPlJWX0L/S+wFQQyufUCVNZtmlNzrK3xLeRF+hHyClBcCjLH8PO2PqUNsGkP9yFQW9UV0IjbGp5j2X1D7Gs/mHWNb5KU2xjTgpngNb4NvKdjtz988bQGEstJoPS8aenMNCRe3Pre3xc/zDLGx6hpsnLnYvCGSCS2E7IKSUoxYBDSWgUzfENKW0CSbnznUGA+IUzVBQcTTTRQEN0WU7ytlEaEQrx/pwLjlTgpvVZRN23ibpvEXXfwtWtxN0VuGwjodVE3TeJum8Rc5fiUp+TwhnA1QYcKfazC0FnGAk39QK7Jf5q+7+4biKSWEpCt6BE/WEe3sVOUAb1yRcGo+4Ogk4JASkChKLACMLx1LHjjnQMoQk5AwDptcIZ9o2e5+8Aq/1eyToRKcMbA727b/K3/fZtE5ES4HPAw/68RqDTVzX9MasjVPVl8cYhfxG6+FqqZx5wt4jcjFeUfAb4ErAZqBCRQUATcA4dvbRtlgFjRGScqq4CLtrN8WTa98V4t+wn4RUs4A1tmeWP293hb/f/Mqzfdg627cE63XGaiAzEG+rwabze3UzHcqWI3IN3h2Aa8D1/2QN4hetkvC96AjwHfE1EXvJ7u/cHNrTdAeiGO/GGb9yXaZiB/xotBhaLyDF4dw3qgan+cJG1eMX9H9n1uVT/+B8Skf/yi/LngW8Cv/T3dVhS725veB34At77ZiLehWmXRGQU3rn9k4gUA0cA9+5qHbwL1Q27adOrEm6Cb/7p5zx3/e8JBALc9cLjLF2/iivP+DwAdzz3EBOqxnDvf/6MhOuydP0qvnx7x5MqCvMKOO3QY7jy9z/tahc58bcf/pLph0ylvH8Z6+9/ievvu51QwOuFv2POgzw9fx5nTZ3GyrufpSUS5tJbf9QnORNugm/+/Vaeu+Y2Ao7DXW88ydKN1Vw57TNe1nmPMWHYaO699AYSmmBpbTVfvvdnAAzrX849l15HwHFwxOEf777InMXd/S54dyi1zW8xtt9peI98W0kkUc/A/AMAqIt8TP/8UQzKPwBFcTXBuqZXd73JnFBqW95mdOmpCA47IiuIJOoZkL8/ADsiy+mXN5qB+QeguCgJ1jfP2802c0HZFn6XYUUn+Y+qW03MbaBfaD8AdsZWUhwcSf+8/VAU1QSbW733Q0FgMKV5Y4gkdlAVnAFAXeR9WuKdxxj3Ru64u4KQc0j7o+qUFhz/wV2ZxjnvHZRIYimFwSm0ParOpYmg4325NO6u3+XakcRSr1daBNVWwond3azsDUp9dBHlBScAQnN8DXHdSVHQ6wVvia+mMFBFcWgsqKIk2BF5u1cT7e3F82K8p2z8LW1eSRe3qdupar2I/Mlvvwbv9nObu4E/iEgrXq9fW/9/APiriPTHK4Z/7W+nq328JyJ3A/P9WXeq6kIAEbkRr5CqxiuU09cN+7el54jINryiZk+ez/R74C/+bfdFbRlUdaOI/BB42T+Gp1X1iQzr/xF4RkQ2+uOes1mnO14H7sMbf/w3VX1XREantXkM747C+3gF5vdV2x8y+TxesTY7aYz7nXjDEN4T78XZileYd9dsvOEamYZsAFwjIifh9bAuxetVPQZvHP7NeAXoPLwhPO6uzqWqJkTkQuBJEdkJXA381n8dg/52ksfaZ+NlEWkr+j9Q1Ut20fZ3wD3+/hbiDVPa1bOqpgPfE5EY3oXgrrbd5my842gbSjUc73fjLH/6aeByVa31f0/eVdVshjrtkWcWvM4zC1J70+547qH2n9/6+AP2//qnMq7bGg1Tfsm0jMty6Yu/+N5u23zz9ptykGT3nvnwnzzzYeoTDu+Y91j7z2+t/pD9f9zpKZ0s3rCSI27K5m3VexpjG/i4/rGUeXWRjjGg28PL2B7edU9nc3wTzY2bdtmmpzXFNrCiIfU6dUek46kfdZFl1EV2l3szzU2bd9mmp7XEazsVvDtjK5N+Xs7OWOenl4QTW1m182+d5ueKSx2uOz91XhdFc1wzn3elnrhb39PRdimhW2mJpw5b66pojiRSnz/t0khrYpdPLs2JSGITm1tTf79a4h1Du5rjq2iO5+4LmZL+pQ5jeoqIzAQmq+o3+zrLrvhfYvy1qp6w28Yd60wHvquq5/RWrt4gIgEg5F+8jcMbg71/0oXJXknKipTp+/V1jD3X0pdfZvoERnd+huq+4v1ffK2vI3SL00Unzd6uMLhn30fYW1QV75tPq42ljQ/flzREu3tzuO+cdcIPeP+9VZ1+Off2nmdjepWI/BfeF9wu3l3bfxFFeD3VIbye8a/t7YWzMcYYszex4tn0GlW9G2+IzF7LH3d8czfWewXvy4z7FP/LiFn/nyiNMcYYk2pvf9qGMcYYY4wxew0rno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaCfR3AGGN2KyRQXtDXKfacI32doHvWNPZ1gm7LDwT6OkK3OLJv9mWFE7G+jtAt+YH9+zpCt4Sc1r6O0G0hZ0NfR9hjQSeUcf6++dtqjDHGGGNMH7Di2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaCfR3AGGN6wxkHHc2si75DwHG487UnuOWZe1OWlxWVctfMHzOuopJwLMplf/kpS2pXkx/MY94P7iA/mEfQCfDwghe5Yfafcpv7gm97uV+fzS3PZsj9//6bcYP93Pfc1JH7e3/wcgcCPLzgJW54Mne5k/352zdxztEnsqW+joOvOC9jm1lfv5azpkyjJdLKzFuvZeHKj3KcskNRcDhDCicDQkN0JXWRJSnLC4NDqCyeTsxtAqApuo7tkcUIDiNKzkDEQXBojK1le/iDHOYexuACL/fO2Ep2RJam5g5UMKz4ROJtuWPrqYt8SFCKGFJ0DEEpRFF2RldSH/04Z7lLgsMZWjQVEOojK9gW+TBleVFwCCNLTiaa8HI3xtayNeW8CmNLzybutrCu+aWc5YZ8oL//cwvQlLa8ACj1f1ZgJxAFAsDApHYBoBFo7rWkqQoRygFB2QnUpy0vQtrzKcp2IOxP90fo5y/ZCTTkIK9HGEDQGYcgJHQTCV3fRbsSQs7hxN2PcNmWsizkHIESIe4uybhud1nxbHqciAwFfgNMASLAGuAaVV3+Cbd7A9Ckqremzf8q0KKq92Zc8V+UiIwGPgKS/+r9qjvnwd/WU6o6SUQmA5eo6tVdtJ0OfFdVz0mbnw88COznz/qyqr69p1l6giMOv734+5z2q29Ss2ML7/z3Pcxe9Bofbaxub3PtWTNZtH455//u+xwwdBS/vfj7nPq/3yASj3LyrV+nOdJKMBDg9R/8iWc+fJO3V3+4iz32YO4vfo/Tfn2Vl/vau5n9flruGX7u3//Ay33R9zj119/0cv/qGx25v/9HL3d17+dOd/fcx7h99v3c+/2bMy6fMWUa4ytHMf7SMznqwEP4/dXXc/TVF+Y4ZRthSOFUappfIOa2MKp0Bk2xGqJuapHQGt/ChuaXU+YpLuub5qLEAWFkyZk0B2oJJ1L/gPdW7sEFU9jQ/BJxbfH2Hash6u5MaRWOb6W25ZVOube1vkfE3YEQZGTJDFriGzut21u5hxUdzZqm54m7LYwtPZvG2Hoiaee7Jba5y8J4UP4EIm4DAUI5yJusP7AdSACD8QrMeNLyCB1FZxAYAGz1229NajckqV3vEwaj1AJxhCqUZiCW1KIVpcb/OQ9hCMp6/+d+/jJFGIbSkrZu7wk5+xF1FwMRQs7huLrd33+qoDMWlx2d5gekEtUWkECPZ7NhG6ZHiYgAjwGvqOo4VZ0IXIv3adErVPUPvVE4i/TCb1zPW6WqhyX9+8TnQVXf7apw3g0HmKWqk4DvAD/7pFm6a+qYg1i5pYbqbbXEEnEemP885x02LaXNxOFjePGjdwD4eNNaRg8aRkU/r/elOdIKQCgQJBQIoqo5yj0xNfc7cznv0Ay5l73bkbt8GBWlXeQmN7nTvbZ4AXWNXfdQnXfsydw79wkA3l72AWXFpQwdWJ6reCkKAoOIuY1+r7JLY3QtJaERWa+vfvEkOAjSSyk7a8sdVz93bC3FWeZOaJiI6xUbSpyo20DQKerFtB0KA+VE3Z3E3CYUl4ZYNaV52Z/voBRREqqiPrKiF1NmEsIrlBP+dCteT3Oy5N+3rt4L+f42El0s72n5eMWu9z5VmoDitDZd5Q7hFfnqtwpnWLd3CKUore37d3Urjgzq1C4glSR0K2g0bUkejgwkoZt6JZ8Vz6annQTEVPUPbTNUdZGqviYiJSLyooi8JyKLReQ88Ho9ReQjEfmTiCwRkedFpDDbHYrIDSLyXf/nV0Tk1yIyz9/mFBF5VERWiMhNSftbJiL3iMgHIvKwiBT5y9aIyHUi8jrweRG5yM/6oYjc4rf5moj8T9L+Z4rI//k//4eIzBeRRSJyR6YC3N/Hz0XkTRF5V0SOEJHnRGSV34uOiNzXdn786ftF5Nw9OCdNIvIzEXlfRN4SkSH+/HH+9DsicqOIpN93RESmi8hT/s8n+seySEQWikjbPckS/7wt87OJqraqalvXXAG57FpJUzlgMOt3bG6frtmxhcoBg1PavL9+BecfcRIAU8ZMZNSgoVQNqAC8HuCF1/2VLb96jrlL5zO/umdv+XWZu6yC9XVJueu7yH34dC/36ImMGpiW+8f3seXWZ3Oae09VDqpg/daOP2o12zZTOajXrq93KegUEXM7bp/H3WaCTuePn8LAYEaVnk1l8cnkOf2TlgijSs9mv/6fpzm+MUe9zhCUQuLa0QsXd1sIZvjYLAiUM7LkLIYXnZSWu207xeQHBhKO5yZ3KO18x9wWgtK5ICsMDmZc6acYWXIK+U5Z+/yhRVPY3PpuH1wYBkgteBP+vHQFeL3Sg+g8PAKgEDL0nvaeIKm943Ek46CDYoQRfu/yFn9eFO94HEAQirpYt+cJ+ahG2qeVCEJeWqs8HBmEqxs7rR90xhF3q6GX3idWPJueNglY0MWyMPAZVT0Cr8j+X7+nGmA88FtVPQjvE+eznyBDVFWnAX8AngC+4eeaKdJ+6XoA8EdVPQRvYNrXk3Oq6vHAPOAW4GTgMGCKiHwaeBg4P6n9BcCDIjLB//k4VT0M79P14i4yrlfVY4DXgLuBzwFHAzf6y+8ELgUQkf7AscDTGbYzLqm4XSQiJ/jzi4G3VPVQ/zi+4s+fhdc7PAWo7SJbsu8C3/CP5wS87haAw4FrgInAWOC4thVEZATwK+CGLLbfJRG5wr+4eJfW+O5XSF43Q69Peufxzc/cy4DiUhZe91euOvkLLFy3nHjC++PoqsvhN/4HVd87h6ljJnLQ8LHdPo49IRk6q9J7vW9+9l4GFPVj4Y/v83KvX07cTcr90y9R9YNPMXXMQTnLvackw4H2VS95NiLxOlbtfJS1jXOojyyjsnh60lJlbeMcVu18hMJAOXlJhV7v2n0vdyRRR3Xj46xrepr66McMK0q9iyEEGVZ8AltbF+CyZ79jPSv1tQ/H61jR8AirGp+kLryMESXeRW5JqIqEGyacqOuLkBlkes+G8YZo1IE/VjhVPn3Yr7ALzSjrUTYljX+OodQjDEcYhjcsZe/5Pe0okFM5DASN+b3svbTvXtuyMZ0J8HMRmQa4QCUdwzmqVXWR//MCYPQn2M9s/7+LgSWq3mWpiKwGRuAV5+tV9Q2/3V+Bq4G2sdQP+v+dgjf8ZKu//v3ANFV9XERWi8jRwAq8QvwNvCL9SOAdvzgohPZL+F1lLFHVRqBRRMIiUqaqr4rIb0WkAq9Qf0RVM/11W+UXtumiwFP+zwuA0/yfjwE+7f/8t6Rj7sobwK/8Y39UVWv8Y5uvqjUAIrII7/V63V9nFvATVX13N9veJVX9I/BHABlcvEef2DU7tjBiQEdPZtWACmrrt6a0aQw3c9lffto+XX3z41RvS72eaGht4pWP3+PMScewpHb1Hh/DnqrZsYURA5Nyl1VQW5/aI9gYbuaye5Jy//yxLnIv4MyDcpN7T9Vs28yIwUPbp6vKh1C7vatfld4Vd1sIOR09n0GnmLjbmtLGTRrj2RyvRcQhIPkkknrGXI3REt9McWg40Uh97+fWFoLSMdQi6BQR1/TcHR8ZLfFaRKbgSD6uRvDGHp9AY3QNzfHMX8TqDbG08x1yilJ60CH1fDfFNyB457soUEFp3ghKQlWIBAhIiMqi49nQ8jq9L72nOYD3Z6wrbV8UdJLaFeANodjVej0tTmqpF2wfapRZGG+4RlvuRpRGAISBu1m35ygRRPLba3UhHyV1aIZDKY4zwZ8K4chA4q4iUoojg8iTgf5xBAjKAcS1574Uaz3PpqctwSsgM7kY737WkX7Bt5mOQWORpHYJPtmFXdu23LTtuknbTS/Gkqfb7inuqmvnQeALeD3kj6nXPSjAPUnjjw9Q1Rs+Qcb78M7ZpcBfdpElk5h2dFl2+3yq6s3A5XgXAm+JyIH+ol29XocAz3Rnfz3lnTVLGT9kBKPLhxMKBLlw6unMfv+1lDb9C0sIBbzYl59wHvOWL6Ix3Ex5SRn9C0sAKAjlc+qEqSzbtDZHuT9ifMUIRg8a5uWechqz35/Xde7jz2Peil3lXpOT3Htq9psvcclp3qikow48hIbmRjbV5WbYQLpwYjshp5SQUwI4lOaNoimWWkwGpGNsa0FgECAkNEJA8nHE+9KaEKAoNJRoIjdPIwgntpMXKPWHPDiUhkbRHKtJaZOcO9/P7foF/5DCo4m6O6mPLstJ3jatiW3kOf0IOSUIDv1DY2iMpuYOJuUuDJSDQEIjbAm/x/KGh1mx8xFqml+lObYxR4UzeEVvkI4CupDOPcjJxXUI709CcqFcSMfNu1yJ+Fm8zwyhhM5P+Uj++M4jNXcgqU0xnZ8w0juURoRCvBJBcGQwrm5PaRN157f/c3UrcXclLttJ6Bqi7ttE3fnE3I9wqe/Rwhms59n0vJfwepe/oqp/AhCRKUAR3leVt6hqTEROAkb1Yc6RInKMqr4JXERHr2myt4FZIlIO7PDb/Z+/7FHgR8Ba4Af+vBeBJ0Tk16q6RUQGAqWq2t3K625gPrBJVXtq8OpbeAX/g8BuH28gIuNUdTGwWESOAQ4k80C+ZN8il88zyiDhJvjm337Jc9fcRsBxuOuNJ1lau5orT/RG29zx6qNMGDaGe798PQnXZenGar58900ADCsr557LrifgODji8I93XmDOB7n5A51wE3zz77em5t5YzZXTPuPlnvcYE4aN5t5LbyChCZbWVvPle73vZQ7rX849l17XkfvdF5mz+I1d7a7X/O2Hv2T6IVMp71/G+vtf4vr7bicU8IrMO+Y8yNPz53HW1GmsvPtZWiJhLr31R32S06NsaZ1PVfEptD2qLuo20D9vPAAN0RWUhkZRlr8/iotqgtpm70IsKIUMLTrOH4Yifi/uhhzmfpfK4pPxHlW3qlPuktBIf1pxNcEmv9AsCAymX95YIokdjCyZAcC28Pu0xLMZyfXJc29seZtRJaciOOyIriDi1jMgb38AdkSX0y9vNAPyDwB1cUlQ0zRvN9vMlQa8sczgjVuO4/1pa5su9P+B1x+T/AQIwRuyUd/rKdMp2/xhF22PqovRMaRkJ1CCUIqXWVE6vnchDMEroBVlG7nsNY+7Kwk5k9ofVae04MgwgIzjnHNJcvUtcvPvQ0SG4z2q7ki8S/M1eONjdwBP4l0GL8IbJzvDX+0p/ykN+F/+K0nvtZWuH1XXPl9EXsF7jNq7kvZItbZlwDa88cPz8MYSrwC+pKotIrIGmKyq2/x1vgj8EO+T72lV/X7Sfp8CJqrq2KR5F/jtHbxPqG+o6ltpedv3ISIz/Z+/mb7Mn34WeDz5C5hJ2xlN50fV3aWqt4lIk6qW+O0+B5yjqjNFZDzeMBUB5gBXqGqlpD6qrv28+V+EPAmvd3kpMBNv6Efyeb0deFdV7/annwa+qKr1/vS5/jFd57837lTVs5LaXq6qu/yrLYOLlfMO2lWTvZOTu6cv9Kg1jX2doNuW/eOHfR2hWxzZN28ER92+HCvdfQcNOG33jfZCrua657rnxNxcXVj2nGOPuoIF7y7r9EFuxbP5t5NcKPZ1ll3xnwCyGDhCVXukJ9ffZquqqohcCFykqpn/LxZ7ESuec8yK55yz4jm3rHjOvX+l4tmGbRizFxKRU4G78P6nJz05BOJI4Hb/KSf1wGU9uG1jjDHmX54Vz+bfjqquwXt03V5LVV8ARvbCdl8DDu3p7RpjjDH/LvbN+0TGGGOMMcb0ASuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWbLi2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMloJ9HcAYY3bnoKoKHrn1qr6OscciiURfR+iW/ECgryN024Ff+EVfR+ievH20L8uRvk7QLRseKOnrCN3iqtvXEbpt3oa1fR1hj+0IN2ecv4/+thpjjDHGGJN7VjwbY4wxxhiTJSuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWbLi2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJOlYF8HMMaY3lAUHM6QwsmA0BBdSV1kScrywuAQKounE3ObAGiKrmN7ZDGCw4iSMxBxEBwaY2vZHv4gZ7lLQpVUFk8FhLrwCraGF6csLw4OZXTpyUT93A3RtWxpfT+phTC+/znE3BbWNL6Ys9z76vlO9udv38Q5R5/Ilvo6Dr7ivIxtZn39Ws6aMo2WSCszb72WhSs/ynHKDmcccRyzrvgvAk6AO59/hFse/nPK8rLiftx1zU8ZN3QE4ViEy2b9mCVrVwJwzXlf4vLTP4uiLF6zgkt/899EYtHc5b78BwQCAe58/lFueSRD7qtvZNywEYSjES677TqWrPNzn/slLj/9fFSVxWtXcOmsH+csd7J8Zwj98w4FhJZ4NU3x5SnL85xyBuYfS0KbAWiNb6ApviznOdPlB4ZQlnc4gtAcX01j7OPU5c5gBhUcR9z1cydqaIz1zXt8WNFojqw4GUFY1bCYpTvmd2pTUTiCIwefhIhDJNHKizUPUhQs5ZihMygIFKMoqxo+4OP693o0m/U8m3Yi0pQ2PVNEbu+rPNkQkdEi8mFf59jXicgaESn3f/7nJ9jOnSKyREQ+FpFP9VzCPU7CkMKp1DS/RHXjk5TmjSbP6d+pVWt8C2sb57C2cQ7bI16Rqrisb5rL2sY5rGl8iuJgJQWB8pzlriw+iuqdc1le/zhl+WPID3TO3RzfzIqG2axomJ1WOEN5wQTCiYYc5W2zr57vVHfPfYwzr72iy+UzpkxjfOUoxl96Jlf85np+f/X1OUyXynEcfvu1/2bG9V9j4tfP5aITz2LCiLEpba79wldYtHoZh151Ppf86lpmXfFfAAwfVMHVn7qYyd+6gIO/8RkCjsOF02bkLveVP2LGT77OxG+cx0XTZnTO/fnLWVS9jEOv/iyX/PpHzPrKD7zcAyu4+lNfZPK3L+Tgq84n4AS48ITc5E7XP+8wtkfeYEv4eQqDIwhKaac2UXcbW8MvsjX84l5ROAMMyDuCbeHX2NT6LIWBkRlzRxJb2RKey5bw3D4rnAVhcsWpvLzhEeas+Quj+h1Iv7xBKW1CTj5TKk7l1drHeHrt3by+8UkAXHV5b+srzFn7F55fdz/jyw7rtO4nZcWzMRmISKCvM/QVVT32E6z+qKoeBJwL/LqHIu2xgsAgYm6j38vp0hhdS0loRNbrK3EABAdBeillZ0XBcqKJRqJuE4pLfaSafqGRWa8fcooozauiLrx894170L56vtO9tngBdY1dX3icd+zJ3Dv3CQDeXvYBZcWlDB3YN4X+1P0PZuXGdVRvriEWj/PAvGc47+iTU9pMHDmOF99/C4CPa6oZXVFJRZlXRAQDQQrz8gk4AYryC6mt25qb3OPTcr/2DOcddVJq7hHjePH9t73cG9JyO8m5C6it25KT3MlCzkDi2uz3Kiut8RoKAsNznmNP5TkDibtNHbkT6ykMVvZ1rIwGFQylKbaD5lgDLi5rdy6jqnhcSpvRpRNY37SclngjAJFECwDhRDM7It77Iq4xdkbrKAqW9Gg+K55NVkRklIi8KCIf+P8dKSIBEVktnjIRcUVkmt/+NRHZL20bARG5VUQW+9u5yp9/nYi8IyIfisgfRUT8+a+IyC0iMl9ElovICXuY+Xv+dj8QkZ8kzX9cRBb4PaRXJM1vEpEbReRt4Bh/+mci8r6IvCUiQzLs4wYRuUdEnvd7b88Xkf/xj/FZEQn57U4RkYX+/LtEJN+fv0ZEfiIi7/nLDvTnF/vt3vHXOy/pvB6WtP83ROSQtEwFIvIXf3sLReQkf/5MEXnUz7VCRP6ni/PW5P93uv8aPCwiy0Tk/qTX5kgRedU/j8+JyDAAVX3a30wBEN6T16snBZ0iYv5tR4C420zQKezUrjAwmFGlZ1NZfHJaT6kwqvRs9uv/eZrjGwkntuUgtVf8JueOuc2EAkWd2hUFBzO+/7mMLj2V/EBZ+/xhRVPZ1LwgF1FT7Kvne09VDqpg/dZN7dM12zZTOajTx0IfZqlIafN+9cecf+ypAEzZfxKjKoZRNWgItdu3cOtjd7PuLy+w8b6XaWhpZO7Cbt9w2vPc23Z9Dt9f8zHnH+PnHp+Uu24Ltz5+N+v+PJeN97xEQ3MTcxe9mZPcyQJSSEJb2qcT2kpAOr/f85yBDC44hYH5x2Xs4c21zrlbMucODKKi4DTK848nKP1yGbFdYbCUZr8oBmiJN1EUSj2HpXkDyAsUcErVBZw58j8YUzqx03aKg/0YkF/BtvDGHs1nxbNJVigii9r+ATcmLbsduFdVDwHuB25T1QSwHJgIHA8sAE7wC8MqVV2Ztv0rgDHA4UnbAbhdVaeo6iSgEDgnaZ2gqk4FrgGyvkcqIqcD44GpwGHAkW2FPXCZqh4JTAauFpG2+znFwIeqepSqvu5Pv6WqhwLzgK90sbtxwNnAecBfgZdV9WCgFThbRAqAu4EL/PlB4GtJ629T1SOA3wPf9ef9CHhJVacAJwG/FJFi4E5gpn+M+wP5qpo+QPQbAP6+LgLu8TPgn4sLgIOBC0Rkd92Dh+Od+4nAWOA4/4Lg/4DP+efxLuBnbSuISD/gPuDa3Wy7T0Xidaza+ShrG+dQH1lGZfH0pKXK2sY5rNr5CIWBcvKcsj5KCWjqZGtiO8t2PMyKhtlsD3/E6FKvt7E0VEVcw7QmtvdByN3bZ873LvjXjik0/QXKkUw99KqpWW5+6E4GFPdj4W0Pc9U5F7Nw1TLiboKy4n6cd9RJjPnyGQy/5GSK8wu5ePo5nbbXK7kzncP03A//mQEl/Vj4m4e46pwvsnD1MuKJeEfur5zJ8JmnUFyQu9y7k/4+iLn1bG59hq3hF2mOrWJg/ie5oddTMt3VSc0ddXewqWUOW8JzaYqvZFDB3pDbk/4+ccRhYP4QXtnwKC/XPMKkQcdQGhrQvjwoIU4Yfi4Ltr5M3O3ZcfH2hUGTrFVVD2ubEJGZeAUmwDHA+f7P9wFtvZavAdPwiuJf4BWYrwLvZNj+qcAfVDUOoKp1/vyTROT7QBEwEFgCPOkve9T/7wJg9B4cy+n+v4X+dAleMT0Pr2D+jD9/hD9/O5AAHknaRhR4Kmn/p3Wxr2dUNSYii4EA8Kw/f7Gf+QCgWlXb7qXfg1fg/ibDMbad49OBc0WkrZguAEYCDwE/FpHvAZfhFeXpjscrblHVZSKyFtjfX/aiqjYAiMhSYBSwvovjApivqjV++0X+8dQDk4C5/h/CAJB8WX8D8LCqzt7FdnfLvytwBcDwqj0brxZ3Wwg5xe3TQaeYuNua0sYl1v5zc7wWEYeA5JPQSEcbjdES30xxaDjRSH03jmLPxNJyh5xiYm5LShtXO3I3xjYgeLmLQxX0C42gX1kVIgECEmJEyQmsb3qt13Pvq+d7T9Vs28yIwUPbp6vKvV7cPsmyPUOWtKEXja3NXDbrx+3T1X9+jupNNZxxxHFUb97Atp07AHj0zRc5dsJh3P/KU/S2mm2bGVGenjv1HDa2NnPZbUm5//Qs1Zs3ZMj9AsceeGhOcifzepo77ggFpBBXU2+0tQ1FAoi4m4DDcMjDJfdfbmzj9TQn5y4isYvc4cQmynD6JHdrvJHiYEdPc1GwhNZ4yteyaIk1Ekm0ktAYCY2xpbWGsvzBNMZ2IDicMPxc1uz8iJqmFT2ez3qeTXe1XQK+BpyA18P7NFAGTMcrUtMJaZe5fo/o7/B6MQ8G/oRXKLZp+8uaYM8u9gT4haoe5v/bT1X/LCLT8Yr4Y/we5YVJ+wv7veltYtpxqbur/UcAVNVNW8f119ndIM5MxyjAZ5Pyj1TVj1S1BZiL18v9BeBvXRz77va1u2PaVXsBliRlO1hVT09qdwjwzG62u1uq+kdVnayqkweU79ktz3BiOyGnlJBTAjiU5o2iKZZ6jRCQjrdZQWAQICQ0QkDycbzRNggBikJDieboC3gt8W3kBfoRckoQHMryx7AzLXcw6TZrYdAbb5vQCJta3mNZ/UMsq3+YdY2v0hTbmJPCGfbd872nZr/5Epec5j2F46gDD6GhuZFNdX0zxOSd5R8yfvhIRg+pJBQMcuG0Gcx+++WUNv2LSwkFvV/xy8/4LPOWLKCxtZl1Wzdy9AGHUJjvvSanHHoUH61fnZvcKz5k/PBRHblPmMHst1/pOvfpGXLnJeeuzknuZDF3B0Ep8QtRoTBYRThRm9LGIb/955AzAJA+LZzB61UOOkm5AyNojafllr0j9/bwJkpDAygO9sfBYVS/A9nQvCqlTU3zSgYXViIIAQkyqGAYO6Nen9zRQ8+gIVrHsvreGcZmPc8mW/8ELsTrdb4YeN2f/zZwL7BaVcN+7+SVpA69aPM88FUReUVV4yIyEK/ABNgmIiXA54CHeyDvc8BPReR+VW0SkUogBvQHdqhqiz+++Oge2NfuLANGi8h+/lCWL+H1zu/Kc8BVInKVqqqIHK6qbb3od+L1zL+W1HufbB7ea/SSP7RjJPAxcERPHIy/rcEicoyqvukP49hfVdueTfZzIH3ITo4pW1rnU1V8Cm2PTou6DfTPGw9AQ3QFpaFRlOXvj+KimqC22Ss0g1LI0KLj/NvLQmN0Dc3xDTnLXdv8FmP7nQYIOyIriSTqGZh/AAB1kY/pnz+KQfkHoCiuJljXtLu3Ui7sq+c71d9++EumHzKV8v5lrL//Ja6/73ZCAa+wv2POgzw9fx5nTZ3GyrufpSUS5tJbf9QnOQESboJv/uHnPHfjHQScAHfNfYyl61Zx5YwveHmf+QcTRozl3m//nEQiwdL1q/nyrOsAmL98MQ+/MZf3fvMP4m6ChauW8cdnH8pd7jt+znM3/MHL/cJjLF2/iivP/LyX+9mHmFA1lnu/9TMSrsvS9av48m3Xd86diLNw9TL++FxucqdSGqKLGJR/PN6j6tYQ10aKgmMAaIlXUxCsojg4Fvz3+47o232QM51SH11IecE0/1F11cR1p58TmuOrKQxUURIah6qiJKiLvNVHSZV3t77ISVWfRXBYvXMxDdHt7Nf/UABWNrzPzmgdG5vXcNaome2PpGuIbmNwQSVj+h3EjshWZoy8BID3t79GbXPPXWhJ+hgS8+9LRJpUtSRpeiYwWVW/KSKj8ca2lgNbgUtVdZ3f7jW8Qu5aEfkiXk/yQL8nNnn7QbzhHmfiFbJ/UtXbReQmvMJ8Dd4QgrWqeoOIvAJ8V1XfFe8xau+q6ui0bY4GnvLHS6cfz38Cl/uTTcB/ADXA40AlfhEI3KCqr2Q4/vZpEfkccI6qzkzbxw1Ak6remmGd9mUicgpwK94F6zvA11Q1IiJr/HO8TUQmA7eq6nQRKcQb1nEsXk/vGlU9J2m/y4BrVLVtiEhypgLgD8CRQBz4tqq+nPx6+u2e8vf3SlqOJlUt8Xvpv9u2X/EeW/iuqt7tf2nxNryLkSDwG1X9k9/uTuBXqrrUn54MfFVVL/enF7UND/Lb/kFV300/jmSTDh+jj7x8466a7JUiicTuG+2F8gP77sNmDvzCL/o6Qvfk7aM3gp2+ezrKJ7HhgRv6OkK3uKl/Vvcp8zas7esIe+y/z5/F6g/Xd3qTW/FszD5GRIYDrwAHpl+g/Kuy4jm3rHjuA1Y855QVz7n3r1Q876O/rcb8exKRS/CGyvzo36VwNsYYY/YmNubZmH2Iqt6LN8bcGGOMMX3Aep6NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaseDbGGGOMMSZLVjwbY4wxxhiTJSuejTHGGGOMyZIVz8YYY4wxxmTJimdjjDHGGGOyZMWzMcYYY4wxWbLi2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS8G+DmCMMdnQvg7QDY5IX0foFkf24X6VvH00e9Tt6wTd0y/U1wm6Jd/ZN3O77KPvE6A0b9875wEn82f4PvopY4wxxhhjTO5Z8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaCfR3AGGN6Q3FwOBWFkxGE+uhK6iJLUpYXBYdQWTydmNsEQGN0HdsjixEcRpacgYiD4NAYW8u28Ac5y10SGs6woqmAsCOygm3hD1OWFweHMLLkZKJ+7p3RtWxNySeM63c2MbeFdU0v5Sx3UXAYgwsmA8LO2Ep2RJamLC8MVDCs+ETifu6m2HrqIh8SlCKGFB1DUApRlJ3RldRHP85ZboAzjjiOWVf8FwEnwJ3PP8ItD/85ZXlZcT/uuuanjBs6gnAswmWzfsyStSsBuOa8L3H56Z9FURavWcGlv/lvIrFoTvP/+ds3cc7RJ7Klvo6DrzgvY5tZX7+Ws6ZMoyXSysxbr2Xhyo9ymjHZGYcdy6xLf0DAcbjzxce45fG7UpaXFZdy19dvZNzQKsLRKJf97nqWrF/J/sNH8eC3/qe93dghVVz34O+YNef+nOQOOYMpDh4MCOHEWsKJlRnbBaSM/nkn0BR7l6i7EYCCwFjyAyMBSOhOmmKLADdHuSsoCR6MILQm1tKaWJGxXVDKKMs7kZ2xd4i6tQAUBsZREBgFQFx30hh7L2e5kw0uHMWkgSciCOualrCy4d1ObQYVVHLQwBNxcIi6rfxz0yO9lsd6ns1uiUhT2vRMEbm9F/f3iohM7q32pjMRuUFEvuv/fKOInNrN7XxGRD4QkWUi8icRkZ5NmnUShhROpab5JVY3Pkm/vNHkOf07tWqNb2FN4xzWNM5he2QxAIrLuqa5rGmcQ3XjUxQHKykIlOcs9/Cio1nT+AIrG56gf94Y8jPkbo5vZtXOJ1m188m0whkGFUwgkmjIUd42wuCCKWxofpm1TU9RGhpNntOvU6twfCvrmp5hXdMz1EW8iwLFZVvre6xteor1Tc/RP2//jOv2Fsdx+O3X/psZ13+NiV8/l4tOPIsJI8amtLn2C19h0eplHHrV+Vzyq2uZdcV/ATB8UAVXf+piJn/rAg7+xmcIOA4XTpuRs+xt7p77GGdee0WXy2dMmcb4ylGMv/RMrvjN9fz+6utzmC6V4zj89vJrmfGzrzPxW5/houPPZEJV2vk+/3IWrVnGod/5PJf834+Yddn3AVheu5bDv3cBh3/vAo78wUW0RMI89nbuLhCLg4ewM/YW9dGXyA9UEpCSLtpNIOZuaZ92KKAgMIaG6Dwaoq8AQn6gMjehgdLgoTTE3qQu+iIFgSoCUpqxXXHwIKLu5vZphwIKA2PZEX2FHdGX8HJX5Sh1MuHggdN5e/PjvLzhPoYX709JaGBKi6CTx8EDT+KdzU/ySu1feXfL072ayIpnYzIQkX/buzKqep2qvtDN1bcDxwET/X/H9ViwPVAQGETUbfR7lV12RtdSEhqR9fpKHADBQchd/V8YLCfi7iTmNqG4NESrKc3LPndQiigNVbEjkrlnqbcUBAYRcxuJq3e+G2NrKc7yfCc0TMTdAXjnPeo2EHSKejFtqqn7H8zKjeuo3lxDLB7ngXnPcN7RJ6e0mThyHC++/xYAH9dUM7qikoqyQQAEA0EK8/IJOAGK8guprduas+xtXlu8gLrGri+Yzjv2ZO6d+wQAby/7gLLiUoYOzNUFYaqp+01i5ab1VG/Z4J3vN57lvCnTU9pMrBrLi4vnA/Bx7RpGDx5ORf/UYumUg49i1eb1rNu2MSe5gzKAhDbjagugRBIbCDlDO7UrCIwl4m7EJZK6QByEACAIAVwN5zB3U3vucKKGvAy5CwPjiLi1KGl3TUTScrfmJHeyAflDaI430BLfieJS27ycoUWpF1yVxQeysWUVrYlGAKJu7+a04tl8IiIySkRe9HsbXxSRkSISEJHV4ikTEVdEpvntXxOR/dK2USgiD/jbeBAoTFp2kYgsFpEPReSWPcx2pIi8KiILROQ5ERnmz/+KiLwjIu+LyCMiUuTPv1tEfiUiLwO3+NO3icg//eP5XIZ9jPZ7We/0M94vIqeKyBsiskJEpvrtBorI4/4xviUih/jzbxCRu/ze89UicnXStv9DROaLyCIRucM/r18WkV8ntfmKiPwqQ66M501EmkTkZ/6xvyUiQzKse3fbsYrIGhH5iYi852/vQH9+sZ/7HRFZKCLnAajqPFVtBBQoAHLzFyJNyCki7ja3T8fdZkJOYad2hYHBjC49m6rik9N6poXRpWczvv/naY5vJJzYloPUEJIiYonk3C2EnOJO7YqCgxnX71OMKjmF/EBZ+/xhxVPY1PIu3unPnaAUEteW9um420JQOp/vgkA5I0vOYnjRSRnvBASlmPzAQMLx3JxvgMpBFazfuql9umbbZioHVaS0eb/6Y84/1rsZM2X/SYyqGEbVoCHUbt/CrY/dzbq/vMDG+16moaWRuQv/mbPs2cp8jJ1+9XOTZWAF67clZdm+hcqBqVneX7uc8486BYAp+01i1GDvfCe78Lgz+fvrz/Z+YJ8jBSmFo6thAmnvcYcC8gJDiSTWpMx3CROOr2RA/mkMyD8dJU7Mzc1FliOFJLLKPYxworpT7tb4Sgbln8Gg/DNRYjnLnawgUEJrvLF9OhxvoiCQ2utfEioj5ORzzNDPcsKwC6kqPrBXM1nxbLJR6Bdwi0RkEXBj0rLbgXtV9RDgfuA2VU0Ay/F6Ho8HFgAniEg+UKWq6QPFvga0+Nv4GXAkgIgMB24BTgYOA6aIyKezCSwiIeD/gM+p6pHAXf62AR5V1SmqeijwEfDlpFX3B05V1e/408P8YzgHuLmL3e0HzAIOAQ4Evuiv813gWr/NT4CF/jFeC9ybtP6BwBnAVOB6EQmJyATgAuA4VT0MSAAXAw8A5/rHB3Ap8Je0Y9/VeSsG3vKPfR7wlS6OKdk2VT0C+L1/TAA/Al5S1SnAScAvRSS5yrsRWK2qnQem7SXC8TpW7nyUNY1z2BFZRlXx9KSlyprGOazc+QgFgXLynLI+SullSdYar2N5/SOs2vkk2yPLGFlyEgCloSribphwoq4PMu6+dz6SqKO68XHWNT1NffRjhhVNS9tCkGHFJ7C1dQGu3/OfC5nuLKimnvObH7qTAcX9WHjbw1x1zsUsXLWMuJugrLgf5x11EmO+fAbDLzmZ4vxCLp5+Tq6iZy3T6CnN8QVWm4xZ0s/3Y3d55/uXD3LVjItYWL2MeCLRvjwUDHLu5BN56M3nez3vrqSfw6LQJFpinceSCyHynKHsiLzAjsjzCAHynL4Y/pBZSehgmmNLOs33cg9je+R5tkeeRQiSv9fkTj33gkNZfgXzNz/B25sfZ3zZURQHy3pt7/+2t6bNHmn1CzjAG/MMtI0xPgY43//5PqDt2xyvAdOAMcAv8Iq0V4F3Mmx/GnAbgKp+ICJtgzinAK+o6lZ/v/f7bR/PIvMBwCRgrv9hHQDa7u9NEpGbgDKgBHguab2H/OK/zeOq6gJLM/XS+qpVdbGfcQnwoqqqiCwGRvttjgc+6x/jSyIySETaut7mqGoEiIjIFmAIcAreRcQ7fv5CYIuqNovIS8A5IvIREGrbd5Jdnbco8JTfbgFwWhfHlOzRpPZtr/XpeEV8WzFdAIwEPhKRQ4HP0PEe6RYRuQK4AmB41aA9WjfmthBM6rENOsXE0m7jucTaf26O1yLiEJB8Etpxu9XVGC3xzZSEhlMXqe/GUeyZmLYQCiTnLiLmtqS0Sc7dFNuA4OUuClbQL28EpaEqRAIEJERV8fHUNL/e67nj2kJQOoZaBJ0i4pp+vjsK4pZ4LSJTcCQfVyOAMKzoBBqja2iOr+/1vMlqtm9mxOCO29hV5UM6Db1obG3mslk/bp+u/vNzVG+q4YwjjqN68wa27fSGnTz65oscO+Ew7n/lKfYmNdsyHOP2LbtYoxezbN/MiPKkLIMqqN2RmqWxtZnLfndd+3T1756mesuG9ukZhx/Pe9XL2NKQuwtFV8M4ST22Xk906o21oPSnJO9Ibzl55DlD0JgiCAltaR8SEUlsJOQMIOrW5CB3a0pPsyMFKT3RXu4y+uVNScndGFPolLuWkDOQSA5yJwsnmigMdozTLgiWEE66Q9fWZktrKwmNk9A4deEN9Msrpzle3yuZrOfZ9LS2y8HXgBPwelOfxitUp+P1du5qvWSfZLCpAEtU9TD/38Gqerq/7G7gm6p6MF6PcEHSes1p20keuNZVnuQ2btK0S8cFaqZ12445ef2Ev44A9yTlP0BVb/Db3AnMJEOv825yAsS0o5unbV+705Yvub0An03KN1JV27pcDgZeVf1kg/pU9Y+qOllVJw8oz/wFl66EE9vJc0oJOSWAQ7+8UTTFUouygHS87AWBQXh/KCIEJB/H79gXAhSHhubsC3it8W3kO/0IOSUIDv3zxtAYS/1DFUzKXeh/kTGhETa3vsfH9Q+zvOERappepSm2MSeFM/jnO1BKUIoBh9LQKJrTcief73z/fLv+hcqQwqOJujupjy7LSd5k7yz/kPHDRzJ6SCWhYJALp81g9tsvp7TpX1xKKOi99S8/47PMW7KAxtZm1m3dyNEHHEJhvndspxx6FB+tX53zY9id2W++xCWneU/hOOrAQ2hobmRTXe6GxiR7Z+USxg8byegK/3wfdyaz33k1pU3/oqTzfer5zPvoPRpbOz6aLzp+Bn9//Zmc5o5rPQEpxpEi2r7wF0v6ch1AffRF6iMvUB95gYhbS3PsA2LuJlxtJegMwOvDgVBgMAlt6ryTXstd0p67IFBF1N2U0qYuOpe6yPPURZ4n4tbSGHufqLsRV1sJJeXOCwz2v9eQW/WRzRQHyygM9kNwGF68P5taUn/PNrWsYmB+pTcyW4KU5Q+hKbaj1zJZz7P5pP4JXIjX63wx0PbX+m28oQmrVTXsD/e4Em/4Q7p5/rovi8gkvOEPbduYJSLlwA7gIryhGNn4GBgsIseo6pv+MIf9VXUJUAps9OddDGzY1YZ6SNsx/lREpuMNhdiZ6Ram70XgCRH5tapuEZGBQKmqrlXVt0VkBHAEHecq2Sc5b9l6DrhKRK7ye9kPV9WF/rI3gKW7WDcHlM2t8xlRfAogNERXEnUbKMsbD0B9dAWloVEMyN8fxUU1QW3za4A3fndY0XH+F2WEndE1NMdz8Rbxcte2vM3o0lMRHHZEVhBJ1DMgf38AdkSW0y9vNAPzD/Byk2B9c1fXo7mkbGl9l8rik/EeVbeKqNtAf/98N0RXUBIa6U8rribY1OJ9VBQEBtMvbyyRxA5GlnhPqtgWfp+WeG1OkifcBN/8w8957sY7CDgB7pr7GEvXreLKGV8A4I5n/sGEEWO599s/J5FIsHT9ar48y+sVnb98MQ+/MZf3fvMP4m6ChauW8cdnH8pJ7mR/++EvmX7IVMr7l7H+/pe4/r7bCQW8C8A75jzI0/PncdbUaay8+1laImEuvfVHOc/YJuEm+Oadv+C5//49AcfhrpceZ2nNKq48/fNe3ucfYkLVGO696iYSrsvSmtV8+XcdTwcpzCvgtEOO5so7fprj5EpzfDH9QkcDQiSxjoQ2ku8/xi2SWNvlmnGtJ+pupCxvGoqS0AbCu2jf07mb4h/QP3Qs4j9iL6GNFARGAxBOG5+dLK47iLi1DMibDihxbdhl+96iKB/WvcLRQz6NIKxvWkpTrI5RpQcDsLZxMU2xHWxtXcOJwy9GUdY1LaExtr3XMkn6WCNj0olIk6qWJE3PBCar6jdFZDTeeOJyYCtwqaqu89u9BrymqteKyBeB3wED/WEQydsvxOtBnQgswhtDfLWqvuuv90O8ns6nVfX7GfK9Anw3fXytiByGNxykP96F4m9U9U8i8jXg+8BaYDFeUTpTRO4GnlLVh/3106dTzoM/b7TfZlL6OsnL/OL3L3jDWFqAK/whKjcATap6q7/+h8A5qrpGRC7wj90BYsA3VPUtv91/AYep6oXp58NfnvG8JR+D/6XAc/xjb8+Rdgxr8F7rbeI9DvBWVZ3uv2a/AY7197FGVc/xt3suMFFVb07K8zRwuarWisiNwLuqOttvO1lVO+7RZjDp8DH68Ms37qrJXinu5v55qD0hP7Dv9qvsf/Ev+jpC90T3zfcK/UK7b7MX2vbXXBffPcPtg2cs95S3NuXqgqHnfPvc/2XFB+s69XJZ8WzMPkhEngJ+raov9nWWXLDiObeseO4DVjznlBXPufevVDzbmGdj9iHiPfpvOd6XOP8tCmdjjDFmb7Lvdi8Y829IVevxHqdnjDHGmD5gPc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaseDbGGGOMMSZLVjwbY4wxxhiTpWBfBzDGmN1xRCgIhPo6xh5LOG5fR+iWcCLW1xG6z5G+TtA9/fa99zcAO/fN90pA9s2+w6AE+jpCtwX30XOeyb/OkRhjjDHGGNPLrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLFnxbIwxxhhjTJaseDbGGGOMMSZLwb4OYIwxvaEwMJSBBUcAQlNsNQ3Rj1KWFwQqqCg8nrjbDEBzvIaG6BIABhVMpSgwnISGqW15Nse5h1FecCQiws7oKuqjSzvlHlo0rSN3bD07oh8SkCKGFB5DQAoAZWdsFQ3Rj3OWuyQ4nKFFUwGhPrKCbZEPU5YXBYcwsuRkookmABpja9ka/iCphTC29Gzibgvrml/KWW6AM444jlmX/4BAIMCdzz/KLY/8OWV5WXE/7rr6RsYNG0E4GuGy265jybqVAFxz7pe4/PTzUVUWr13BpbN+TCQWzU3uw45l1qU/IOA43PniY9zy+F1puUu56+s3Mm5oFeFolMt+dz1L1q9k/+GjePBb/9PebuyQKq578HfMmnN/TnK3+fO3b+Kco09kS30dB19xXsY2s75+LWdNmUZLpJWZt17LwpUfZWyXC0EZTGHwIBAhmlhHJLEqY7uA9KckdDwt8feIuRtxpJji4BHtyx0pIpxYTiRRnbPcBcGJgBBLrCfidp27OHgcLfH3iOsmHIopCh7eKXfUXZOT3OUFI5kwcBqCUNO0lNU7F6QsH5hfyREVZ9Ma3wnA5pZVrGx4B4BRpYcyouQgAGqalrCm8f0ezWbFs8kZERkK/AaYAkSANcA1qrr8E273BqBJVW/9hBH/bYnIdOC7qnqOiJwLTFTVm7uxnQOBu4BSoA74rKpu68msWSZhYMFkNre8TFxbGV50Gi3xDcTcnSmtwomtbGl9rdPaTbFqGqMrKC84KleBfcLgwsnUNr9EXFupKj6D5nhN59zxrWxqfTVtXZdt4feIujsQglQVn0lLfGOndXsr97Cio1nT9Dxxt4WxpWfTGFtPxG1IadUS29xlYTwofwIRt4EAoRzk7eA4Dr+98kecdt0V1GzfxDv/+wCz57/MR+tXt7e59vOXs6h6Gef/4hoOqBzDb796Laf++CsMH1jB1Z/6IhO/8WnC0QgPfv9WLjxhBve89ERucl9+LafdeCU1dZt55+a/MfvdV/ioJin3+ZezaM0yzv/ltzhg+Gh++5VrOfUnV7C8di2Hf++C9u1suGMuj72d2wsWgLvnPsbts+/n3u9n/qiZMWUa4ytHMf7SMznqwEP4/dXXc/TVF+Y4ZYfC0CSao2/j0kpp6ARi7mZcberUriA4gbi7tX3a1WYaYx2fM/3yTiWa2JSTzF6eg2iOvY0SpiR4vJebDLkDBxLXpNw00xR/vX26NHQKMXdzTjKDcNDA6czf8jjheBPHDruALa2raYrtSGm1I1zLgq1PpcwrCQ1kRMlB/HPTP1BNMLniPLa0rqElnvp59EnYsA2TEyIiwGPAK6o6TlUnAtcCQ/o2WWYi8m97Yamqs7tTOCf5D1U9GPgn8NUeirVH8p2BxN1G4toMuDTH11EUrMx6/UhiK67mpvcwWX5gEDG3qT13U2wtxcGqrNZNaJio6/1hUeLE3J0EpagX03YoDJQTdXcSc5tQXBpi1ZTmjch6/aAUURKqoj6yohdTZjZ1/MGs3LiO6s01xOJxHnjtGc476qSUNhNHjOPF998G4OMN1YyuqKSibJCX3QlSmJdPwAlQlF9Abd2W3OTebxIrN62nessGL/cbz3LelOmpuavG8uLi+V7u2jWMHjyciv4DU9qccvBRrNq8nnXbNuYkd7LXFi+grrHrgua8Y0/m3rnehcjbyz6grLiUoQPLcxUvRUDKcLUZlxZAibobCDmd/3zlB8YQS2xEiWTcTlDKcbUFpbWXE3u83G37U2Jubcbcec5oYu4mVPeO3GV5Q2iO19Ma34nisrF5ORWFY7NatyQ0kPrIJlyNoyh1kQ0MKRrXo/mseDa5chIQU9U/tM1Q1UWq+pqIlIjIiyLynogsFpHzAERktIh8JCJ/EpElIvK8iBRmu0MRGSwij4jIO/6/4/z5U0XknyKy0P/vAf78mSLykIg8CTzvTz8qIs+KyAoR+Z8u9rNGRH4uIm+KyLsicoSIPCciq0Tkq34bEZFfisiH/jFe4M+fLiKviMjDIrJMRO73LzQQkSNF5FURWeBvb5iIjBOR95L2PV5EFmTIdJiIvCUiH4jIYyIywJ//iojcIiLzRWS5iJyQYd2ZInK7//PdInKbf55Wi8jnktp9zz+vH4jIT/zXdJmqtnV9FQDhbF+vnhRwCom7Le3TcbeVQIa3Tn6gnOFFZ1BROI2Q0y+XETMKSmH7cAyAuLYQdDoXwAWBcqqKZzCsaDohp3+G7RSTFxhAOJGbTv+QU0QsKXfMbSEoxZ3aFQYHM670U4wsOYV8p6x9/tCiKWxufRdFcxE3ReWgCtZv6+gFrNm2mcpBqcXF+2s+5vxjTgVgyvhJjKoYRtWgIdTWbeHWx+9m3Z/nsvGel2hobmLuojdzk3tgWu7tW6gcmJZ77XLOP+oUL/d+kxg12Mud7MLjzuTvr+d2aFK2KgdVsH7rrl+bXHGkEFc7Ps5cDeOkfaYIBYScoUTdtV1uJxQYTjRR22s50wkFqHYUvC5hRArS2uTvPrcznJibu9wFwWLC8Y7e8XCiiYJASad2ZflDOW7YRUyuOJeSkHdh2BjdzsCC4YScAhwJMrhwVMZ1Pwkrnk2uTAI6FXm+MPAZVT0Cr8j+37YCEhgP/FZVDwLqgc/uwT5nAb9W1Sn+enf685cB01T1cOA64OdJ6xwD/D9VPdmfPgy4ADgYuEBEuupOW6+qxwCvAXcDnwOOBm70l5/vb+tQ4FTglyIyzF92OHANMBEYCxwnIiHg/4DPqeqReEMhfqaqq4AGETnMX/dSf3/p7gV+oKqHAIuB65OWBVV1qr/P6zOsm24YcDxwDnAzgIicjvfaTPWP60gRmda2goicAZxJxznPMdlti0iijpqmJ6lteY7G6AoqCjtdR+wlUgvKSKKOtU1PUNP8DA3R5QwtnJayXAgytOgEtocXoMRzGTRNau5wvI4VDY+wqvFJ6sLLGFHi9e6WhKpIuGHCibq+CEnHR00H1dTsNz/8ZwaU9GPhbx7iqnO+yMLVy4gn4pQV9+O8o05izFfOZPjMUyguKOTi6efsPbkfu4sBxf1Y+MsHuWrGRSysXkY8kWhfHgoGOXfyiTz05vO9nrc7Mh5jH1xgdS01S2FwIq3xXY3JFkLO0JwWodkoDB5EOLFsFy2EoDOEmJvLuxO7f+13RrfwyoZ7eGPj31m7832OGHw2AM3xHaze+R5TKs5jSsW5NEa3obg9mu7f9ta02asI8HO/+HKBSjqGc1Sr6iL/5wXA6D3Y7qnAxKQP4H4iUgr0B+4RkfF4n37JgyznqmryX/EXVbUBQESWAqOA9Rn2Ndv/72KgRFUbgUYRCYtIGV7x+XdVTQCbReRVvLHfO4H5qlrj72ORf4z1eBccc/38AaDtk+tO4FIR+TZeYT81OYiI9AfKVLVtUOw9wENJTR71/5vt+XxcVV1gqYi0vS6n+/8W+tMleMX0PBFxgD8DJ6lqfRbbz0hErgCuABg+Ys9u1SbcFoKhjh7boFNIQlNvNyYXlq2JjQgOjuT1yXCNNnFtJeh09NgGpYi423Xulngt5QWTcSQfVyOAMLToBBpja2iO1+QqNjG3hVBS7pBTRFxbUtq4xNp/bopvQHAISD5FgQpK80ZQEqpCJEBAQlQWHc+GltfJhZptmxlRPrR9uqp8SKehF42tzVx224/bp6v/9CzVmzdwxhHHUb15A9t2esNlHn3zBY498FDufyV1DGav5N6elntQBbU7MuT+3XUduX/3NNVbNrRPzzj8eN6rXsaWhr65cNmdmm2bGTE47bXZnpthMelcbcVJ6rF1pCClJxog4JRR7HhfDBTyCDoVEHfbxwkHnQoS2oCSu88YJUzyDVuHAjQ9t/Rv/2JgW+7WuBJXP7fkPnc43kRBsKO3uCBQQiTRnNImrh2fKVvDa5koDiGngJgbpqZpKTVN3pet9y87JqUXuydYz7PJlSXAkV0suxgYDBypqocBm/Fu+QMpA8cS7NkFnwMco6qH+f8q/aL2p8DLqjoJ+FTSvgCa07aR7f7b2rlp67j+OrvqCs20DwGWJGU/WFVP99s8AszA6wleoKrbd7HtXe0v2/OZnE+S/vuLpHz7qWrbIwqGAw2q+okGsKrqH1V1sqpOHlReukfrRtw6gk6pP3TAoTg4kpb4hpQ2gaQ/hHmOd7uvLwtngEhiO6Gk3CWhUTTvIne+MwgQv3CGioKjiSYaaIjuqhep57UmtpHn9CPklCA49A+NoTGaWrwHk3IXBspBIKERtoTfY3nDw6zY+Qg1za/SHNuYs8IZ4J0VHzJ++ChGD6kkFAxy4QkzmP32Kylt+heXEgp6vyqXn/5Z5i1ZQGNrM+u2buToAw6hMM87tlMOPYqP1ufmCQrvrFzC+GEjGV3h5z7uTGa/k/ol0v5FSblPPZ95H71HY2vHR9xFx8/g768/k5O83TH7zZe45DTvKRxHHXgIDc2NbKrrg+8fAwltwJFiHAoBIc+p7PTlucboS+z0/8XcjbTGP0xpk+cMJ5bYQC4ltIGAFCN+7pAznJim5Y693P6vLXc8qU2uh2wANEQ3UxwsozDYD8FhWPH+bGlN/d3KSxrS1j9vCIIQc8P+Mu+CoSBQwpCicdS2fKLnEnRiPc8mV17C613+iqr+CUBEpgBFeD3BW1Q1JiIn4fXu9oTngW8Cv/T3d5jfi90faPsEm9lD+9qdecCVInIPMBCYBnwPOLCL9h8Dg0XkGFV90x/Gsb+qLlHVsIg8B/we+HL6iqraICI7ROQEVX0N+BKQ/miGT+o54Kcicr+qNolIJd6Y9i3ADuA7Pby/PaTUhRcwpOhEwKEptpqYu5PSkPelkcbYKoqCIygN7Qe4KAm2tv6zfe3ygmMoCFQQkHyqis+lPvohTbHVmXfVw7m3hd9lWNFJ/qPqVhNzG+gX2g+AnbGVFAdH0j9vPxRFNcHm1jcAKAgMpjRvDJHEDqqCMwCoi7xPSzwXf/SUjS1vM6rkVASHHdEVRNx6BuTtD8CO6HL65Y1mQP4BoC4uCWqa5uUg1+4l3ATfvOPnPHfDHwg4Ae564TGWrl/FlWd+HoA7nn2ICVVjufdbPyPhuixdv4ov3+aNdpq/fDEPvzGX937zD+KJOAtXL+OPzz20q931bO47f8Fz//17Ao7DXS89ztKaVVx5up/7+YeYUDWGe6+6yctds5ov/65jlFZhXgGnHXI0V97x05zkzeRvP/wl0w+ZSnn/Mtbf/xLX33c7oYB3I/COOQ/y9Px5nDV1GivvfpaWSJhLb/1Rn2UFpTW+hOLQUf6j6tbjahN5zkgAou663azvEHQG0xJf3PtRUyit8Q8pDnmPkYwlarqRu5zWWG5zK8rSuleZUnEugkNN01KaYnWMKJkEwPqmDxlavB8jSyahKK7GWbStY+z+4YPPIs8pwMVlad0rxN3MX4TsLkkfI2VMbxGR4XiPqjsSb5zzGrxxtzuAJ/GGTywCjsPrWQV4yu8hRkS+izck4oa07d5AhkfViUg58FtgAt6F4jxV/aqIHIM3lGErXlH/JVUdLSIzgcmq+k1//fTpp4BbVfWVtP2s8dtty7DOGmAysB34H/+4FLhJVR+UpEfE+e1vB95V1bv9cc234RX7QeA3SRceR+P1QI/0h4Kkn+vDgD/gXZysBi5V1R0i8oq/v3f98/Ouf+ztOZKPQUTu9l+Dh/3tNqlqif/zfwKX+7tswnvKxir/db5NVZO/XHijv6/Z4j0Kb7KqXue3vVNVz0o/hmSHHDFWZ7/681012SsltGfH2eVKOBHbfaO91KT/t48+sTJvH70RvHPffK/seDLj97/3epnGge8r/rkxFx0QPevqT/2SFR+s63TSrXg2Zh/kX0j0V9Uf77bxvwArnnPLiuc+YMVzTlnxnHv/SsWzDdswZh8jIo8B44CTd9fWGGOMMT3Limdj9jGq+pm+zmCMMcb8u9pH7xMZY4wxxhiTe1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLAX7OoAxxuxOyCmkqnhiX8fYYwmt6+sI3ZIf2L+vI3TbhgdK+jpCt+Q7ob6O0C0B2Tf74AZ86vt9HaF7yvL6OkH3DSro6wR7blPmz/B9811vjDHGGGNMH7Di2RhjjDHGmCxZ8WyMMcYYY0yWrHg2xhhjjDEmS1Y8G2OMMcYYkyUrno0xxhhjjMmSFc/GGGOMMcZkyYpnY4wxxhhjsmTFszHGGGOMMVmy4tkYY4wxxpgsWfFsjDHGGGNMlqx4NsYYY4wxJktWPBtjjDHGGJMlK56NMcYYY4zJkhXPxhhjjDHGZMmKZ2OMMcYYY7JkxbMxxhhjjDFZsuLZGGOMMcaYLAX7OoAxxvQGoQRHKgFwtQ5laxctCwnIfri6DqUBAEeqEPoBcRK6PDeBfcJAgs5+CEJCN5LQdV20KyXkHEHcXYqbdmwh50iUKHF3cS4i+/KB/v7PLUBT2vICoNT/WYGdQBQIAAOT2gWARqC515LuSr4zhP55hwJCS7yapnjq65/nlDMw/1gS6uVrjW+gKb6sD5JCyBlMcfBgQAgn1hJOrMzYLiBl9M87gabYu0TdjQAUBMaSHxgJQEJ30hRbBLg5yR2UwRQGDwIRool1RBKrusjdn5LQ8bTE3yPmbsSRYoqDR7Qvd6SIcGI5kUR1TnIn+/O3b+Kco09kS30dB19xXsY2s75+LWdNmUZLpJWZt17LwpUf5Til54xDj2XWpd8n4Djc+eJj3PLEX1KWlxWXctfXfsK4IVWEY1Eu+/31LFnvvSb9i0q586vXMWnEfqgql/3+Bt5a8UFuck88mllf+BYBcbjzjdnc8vx9qbmLSrnrSz9iXHkV4XiEy+77GUtqV1M1oIJ7/9/1DO03CFdd/vj649z28j96NFu3e55F5Ncick3S9HMicmfS9P+KyLdFZLqIPLWH254pIsO7m+1fhYjcKCKn7uE6a0SkPMP8G0TkuxnmjxaRDz9hzuEi8vAn2UbStmaKiIrIKUnzPvP/2TvvMDmKow+/v72gjLKEkAARjchJZDAYsAFjkslgTDLYZEywwZhsAwaTPnIywSSTweScMxIIREYSyhLK4eJufX9U793c3p50ErrbAff7PPfc7mzPbs1s70x19a+qw7Y9F7JvS8f+e0kHhce3Lux9liQtnfdW7jtY0v6LuM/pBfsv0ncraTdJqy/KPgt4r0Xuv0uSjAaStVFk7Qsy6oE7d8XaDcCY02RbzmaQtfa/IQNUZFahLvcRtbl3yKgfonPRduWZFckxvdn2Mg3CbH5bm1mE7sA0YArQieaxmRpgavibSaOjnU1sn4o71tVtb24LdK9cl2k1rzOl+hk6lS9Lubo1a1Ob+46p1c8ztfr5kjnOAF3K12Z23VvMrH2BDmUDKVPXFtoNoS43peF5ho50LFuBWbWvMKv2JUB0KBvYPkYDnSrWZF7dO8ypfYnKzEAyLdjdsXwI9bnGgWHO5jGn7tWGPyNLbXZSe5ndhFuffYgdTj+ixdd3HLoVqwxcnlUO2YEjLj+La487qx2taySjDFcfdho7/v1oVj9xD/bbfAeGDFyxSZvTdz+c4aM/Z51T9uagq87gioNPbXjtikNO5anhbzDkxN1Z55S9+XR8+1wXM8pw9b4ns+NVJ7L6ufux39CfM2TpwU3t3uG3DB/3Jev87UAOuvVcrtjrRADqs1lOeuBKVj93Xzb5x+Ec/dM9m+37ve37Hvu+AWwGICkD9AHWSLy+GfD6Yr73wcBiO8+SfhQRdTM708yeK7UdC8PMJpjZknRIRwD7JZ7vC3y4uG9mZteZ2e3f26r2ZzCwSM4zcPrCmyyQ3YAl4jyXtv92xqjFI5tGzmaGSHJTRB/MZgH1Ba/MK7Kt7RFLYVThzqORsylkmo8HKdMgsjYVrK7glQ5k1JusTWwPcxNU4OcrG55X4ZHmJJZ4rBbep0N4j2wLr7ctFZle1Nu8EFU2qurH0bEsnXGccvUka/PI2XzAqMmOpyKzdLN2HctWpCY3kRw1TV9QBlEGCFFGztpnwFKmHuRsHjnc7trceCoy/Zu161C2AnXZiVih3YFy9SFn88Pvpf15dcT7TJ8zq8XXd93sZ9z+7CMAvP3ZR/To0o2lezX/Lbc1G628Jl9NGsuoKeOpy9ZzzxtPs+vQrZu0WX3Qijw/4m0APp8wmsF9l6Ff915069SFrYasz80vPARAXbaeWfPnFH5E29g9eHW+mjqOUd9NcLvfe5Zd19mqqd1Lr8Dzn73ndk8ew+DeA+jXrReTZk9j2NjPAZhbM59PJ41mYI9+S9S+7+M8v05wnnGn+WNgjqSekjoAQ4Bh4fWuku6X9JmkOyUJQNKZkt6V9LGkG+TsCWwI3ClpuKROyQ+V9Luwz4eSHpDUOWy/VdKlkl4ELpK0kqSnJL0v6VVJqxUegKSfhs8YLmmYpG7BhouDTSMk7RPabi3pZUn/kfSFpAslHSDpndBupdCub7Dr3fC3eZHPPVjSw5IekzRK0jEhSj9M0luSeiWOac/weLSkcyR9ED5vtbC9t6Rnwr7X0/JdCWAdSS9I+lLS74rY1VHSv8L7D5O0Tdj+hKS1w+Nhks4Mj8+TdHgywhmO7cFw7r+U9I/E+x8Wzt1Lkm6UdFULdr4KbCSpQlJXYGVgeOJ9tg12jJB0S+hveU4J38k7klYO7VuKum8QvtP35TMnA4q0WSl8J+/KI6lzw/aukp5PfB+7Jvb5i6TPJT0H/CSxfaikjyS9me9jYXtZeP5ueP3IsMuFwJahf54oaY1wXMNDu1UKbL0Q6BRevzNsLgvn+pPQTzqFts1+R5I2A3YBLg7vsVLB+xft25IeUWNk/8j8Z6udo/xNbKUCSDqWdUgVBa3KyWgpjGntaNmCER0wa3QWjBrULGJeSUZ9yNmEZvuXZ1amPld8CrxtKaOpw5sN2wrpCPQFeuPR50I64ZKP0lCmTmQTUfusVVHW9BYEQGWmF307bkuvDpsXjUy3Bxl1JGeNjmPOqpvZmqEjlWVLU5Md3WR7jmqq67+iZ4ft6dnh5xj11OVakjUtWTLq1MRRz1k1mQK7RUcqMktTmxvT4vtUlC1Dbbb5byAtDOzdj7FTG6Pi476bzMDezQcJbW5Hr36MnZawY9pkBvZq6kh+OOYL9tjYJ3uHrrQmy/cdwKBe/Vmx3yCmzp7Bv446lw8uuocbjzyTzh0KB8VtZHePvoyd0ThbMm7GFAb26NvU7vFfsse6W7vdy6/O8r2WZlDPpm2W7zWA9ZZdlbdHf68J9mYstvNsZhOAeknL4U70m8DbwKa48/uRmdWG5usBJ+ARrRWBvEN5lZkNNbM18avmzmZ2P/AecICZrWtmhcPKB8M+6wCfAoclXlsV2M7MTgJuAI41sw2Ak4FrihzGycDRZrYusCUeLtkDWBdYB9gOdyTyTtU6wPHAWsBvgFXNbCPgJuDY0OYK4DIzGwr8OrxWjDXxqOJGwN+A+Wa2XjiPB7Wwz3dmtj5wbbAd4CzgtbDvo8ByLewLsDbwS/w7OlPNpTFHA5jZWnjk9zZJHYFXcCfORaCN398WuKNbyLrAPvh52kfSsuGz/gpsAmwPNBvMJDDgOeAXwK7huAB38IFbgX2CneXAHxL7zg7fyVXA5S19gNyT+j9gz9BHbsG/h0KuAK4I32fySl0N7B6+j22Af8rZAI+Ur4f3paGJff4F/N7MNqWpp3EYMCt8xlDgd5JWAP4MvBp+B5cBvw+2rIv/xsY1OWlmfwaqQvsDwuZVgKvNbA3cW/l12N7sd2Rmb+Dn+pTwHoVeWEt9+wi8P20JnETjbyHVZLQMWSvNlO+iYU2euYP8TbNWGXqD1WLNtMalwopsq8alGdOhyEyAR55LJ9kohhUcR11uJpOrnmRq9fPMq/uaXh02a2HP9qfQ1s4VazK/rrnOVlRQmVmaGTXPMaPmGUQZlZlB7WVmEZra3al8darqF6QPFhWZpanLpdd5lprHsQq/n5LZYU3tuPDhW+jZZSmG/eNejt1xX4aN+pz6XJbysjLWX2E1rn3mP6z/p32ZV1PNn3c7tIR2N31+4dO307NzN4adfjvHbrMXw8Z+QX228dbapUMnHjjyAk6473LmVC/ZQfn3lTfko8+bAZcCA8PjWbisI887ZjYOQNJwfDr6NWAbSacCnfGMkU+AxxbymWtKOh/oAXQFnk68dp+ZZUO0cjPgvsQXUEzw+DpwaYiUPWhm4yRtAdxtZllgsqSXcYdmNvCumc+HSvoaeCa8zwjcgQJ3uFdPfO5SkrqZWeFcx4th2xxJsxLHPQJ3covxYPj/Pu6YAWyVf2xmj0ua0cK+AI+EwUiVPEK/EYmILu4M/194r88kjcEHJK8CxwGjgMeB7eUR/8Fm9rmkwQWf87z5XDiSRgLL47Kel81seth+X3jvlrgnfGZ33CHLyxF+Aowya8jiug13+i8Pz+9O/L9sAe//E3wA82z4rsqAYnPdm+JSBoC7gEvCYwF/l7QVnmUzEOiPD8IesiA6lfRo+N8D6BYc1Px77Rwe/xxYOxGl7Y47vfnBZ543gb9IGoT31y8XcHx5RpnZ8PD4ffy3Bwv+HbVES317snw24kV8QNFciLsYSDoCd8xZbrlmkwILxKgL0ec8FViBxEF0pkz5sWYZ0lLkzDBmfw+rvx9GDVKHBl9CdAjyk0YydCOTyStrKsioF/U5Q+pGRn2oVG88LlJGuYZQb+2RpFQYaS5jwcln+UTBTKJdR3y2oH2S1orhkeZGjXlZQZQUwBJynprcJGBdMlSSa/ZzbVsKI7YeiW5qa7m607VyA3+dSioz/bE6C8mo8xv6Vk12IhWZntTmmozH28juKjJqjF4Ws7ss04MuGU8MFJWUZ/pBfY663GQ/rkw/sjar2W8jTYz7bjLL9m2U0Qzq058J06YsYI82smPaZJbtnbCjd38mzGg6yzCnah6HXtuoyR511ROMmjKezpUdGTdtCu985VHb+996tt2c53EzprBsz8YI+aCe/Zgwq8Du6vkcesf5jXaf/xCjpvmAqjxTxgNHXMCd7zzNQ8NfWuL2fV/nOa97XguXbYzFHZ3ZeCQvT1K0lAXKQwTxGmBDMxsr6Wyai+SKcSuwm5l9KOlgYOvEa/n07AwwM0ToWsTMLpT0OLAT8JY8uWlBsofkceQSz3M0nssMsGmRiPnivFdL+2QL2jQbzko6GshLM3ZqoV3h85aO/V080vkN8CzuCP8Od8YWZGfS1gWd12aY2TuS1sQjqV8kHLaFvY+18LgQAZ+EKPDicAA+/7yBmdVJGk1j/y32uQuyW/gsSRMHVtLWyedmdpekt/HZg6clHW5mLyzEzsLvIn+3vZWWf0ctsaC+vRaeLbbEBKJmdgM+g8QGG66xiCGb+YhK8lrcjHo0q1qRtcZEr4wGYTanpI4zgDEH0QnvSjVk1I/63MgmbWpzbzc8Ltdq5GwaOb4D+64hyVH0oCyzbDs5zuBObzmN8o1OQOE4PintqMC7fdJR7gQl0q/mqcvNoFxdKVNnslZFp/JBzKh5p0mbDB0a9MMVmZ6A2t1xBqi3mZSpCxl1JmdVdCgbyNy6D5q0mVn7fMPjLhXrUpedTF1uEuXqQXmmJ/nvpKKsL9nczHaxO2uzyKgLGTqRo5rKzEDm1Te1e05t42Wtc/k61OWmNDjOAJWZZajLjm8XexeXR998gWN2PYB7XnqCjVdbm1nz5jBp+nftbse7X3/CKgOWY3DfZRg/fQr7bvYL9r+yaWpM987dmF9TRV22nsO33YNXPn2fOVXzmFM1j7HTJrHqgOX5YuIYtl1rY0aOaz7r1SZ2j/mUVfoty+DeAxg/cyr7brg9+99yZlO7O3Vlfm212735rrzy5bCGCPPNv/kLn04azWXP313s7b83SyLyfBLwTYjUTg8RtjVodNxaIu9ofBcixXsC+YoNc2isaVRIN2BimHY/AGj2CzKz2XIt8V5mdp/c81rbzJoknUlaycxGACMkbYpLCV4BjpR0Gx4N3wo4hQXLDJI8AxwDXBw+Y91E5K8teAU/D+dL2hHoCWBmVwNX5xsF53NXSRcAXXBn6c9AZZH3ekHSqrgE5HMzq5U0FtgbOA93Gi+hMQrbGt4BLpPUE/9+f41H2RfEaTSfw/0MGCxpZTP7CpfPvJx4fR9cK7wPHqltic+BvpI2NbM3Q39a1cw+KWj3VrD1XlyOkac7MCU4ztvg0XXwc3hr0B+XA78CrjezGZLmSNrEzN4qeK+ngT9IeiG836p4v27yO5C0Iv5buzI8XhsodJ7rJFVYYZi1OS39jhb02yvatyVtBOyIS1VelvSMWYlKVSTI2QTKtGJ4PAOoQaEkmhWpUpEko+UQXYByyrQaOZuMNXMG2wKjPvclFZm1G0rVGfPJBIVVMZ1zepiFa5nBdcv10FApZD7uHOfHbkZT51r45ODMNrdywRizaofTu8MWeKm60dTbHDqXrwDA/PpRdCwfRJfyFYEcZllm1L69wHdsS1vn1Y9gqYpNAFGT/ZaszaFDmV+KarIt64XrbSa1uYn0qNwKw8jaLKoX0H5J211V/wldKjYOperGkrO5VGZ8Fqg2V7w0YyMZyjN9mV/fnmUYm3PXaRez9dob0ad7D8be+QJn3XEVFWU+23X94/fyxDuvsNNGW/HVrU8xv6aaQy75S0nszOayHHPLhTz9l2spy2S45cVHGDnua47c3ic6r3/2foYMXIHbjzmfbC7LyHHfcNh1Zzfsf+wtF3HncX+nsryCb6aM55Brzmzhk9rA7nsu4eljr3C73/gvIyeO4sgtd3e7X32IIUsP5vaDz3K7J47msH+78nLzldbhoE124qNxXzHsdK8VcPoj1/LkJwtyCRaN7+s8j8CjkHcVbOtqZgscYpnZTEk3hvaj8ehmnluB6yRV0TzS9VdcWz0m7NvSjf4A4FpJZ+BhjntoXrHhhOD4ZIGRwJP4fOKmoa0Bp5rZJBVJOGyB44CrJX2En99XcK1qW3EOcLekD3AnckFXnndw2cVywHlmNqFAcnENft5H4He+g60xe+lVYFszmy/pVWAQxfXORTGz8ZL+jn93E/Dz3XKqsu/zZJFt1ZIOwSU55Xi/uS7RpEOIzmZoWrGj8H1qg0ziSknd8e/qclw6lOQE4N+STsLPXd7mO4HHJL2HS18+C+/7gaR7w7YxND1HhwE3SpoHvJR4r5twOcUHYaA3FZeKfITnFXyI/yY6AgdKqgMmAecWObQbgI9Cf1jQ1bql39E9wcbjcD14UvfcrG9LOh64ETgk9KeTgFsk/Sz5YZLOBd4zs0cl7YLPOOV19zeZ2U4sYYw5ZO3zgm3FneacjSt4vrAbeNuRYzq5XNNoZ0tOc30iep7EmEl9O0USG6nBy9QlSeoM59K89nMew7t06anJTWJKdVNb5tePSjz+mvn1pUjKbE5dbgoza5uOn1tymufVDW/yvKr+c6r4vGjbtqY+N4U5uaZ9pSWneX594W07x+zaZ4q2bU/2v+CUhbY55qrzF9qmPXhy2Gs8Oey1Jtuuf7axuuxbX37EqsfvUnTfD8d8ztDTDij6Wlvz5CdvNnN4r3/1oYbHb436mFXP2qvZfq9//SH6wyZtapsKheORSFshqauZzQ1O70PALWb20ML2KyVB211lZiZpX2A/MyteEX/h79XVzPLVOv4MDDCz45eguT9aNthwDXv7nbaZfmtLsktG/t3udChbUDpCupkwf8lFl9qTDpnCajA/DMr0w1youOevTl14ozTSo3LhbdJK7/ap1LFEeeBjbMrcZrLLH0U95MgPhrODrrwjLgF4uLTmtIoNgKtCRHgm8H2yJX4p6TT8dzcGr2ceiUQikUjkB0R0niPthpkt1kp7pcTMXsVLFC6J97oX105HIpFIJBL5gfLDnG+JRCKRSCQSiURKQHSeI5FIJBKJRCKRVhKd50gkEolEIpFIpJVE5zkSiUQikUgkEmkl0XmORCKRSCQSiURaSXSeI5FIJBKJRCKRVhKd50gkEolEIpFIpJVE5zkSiUQikUgkEmkl0XmORCKRSCQSiURaSXSeI5FIJBKJRCKRVhKd50gkEolEIpFIpJVE5zkSiUQikUgkEmkl0XmORCKRSCQSiURaSXSeI5FIJBKJRCKRVhKd50gkEolEIpFIpJWUl9qASCQSWThZsja71EYsMnW5qlKbsFhUZH6YdgPkLFdqExaLHD9Mu8tVVmoTFo8elaW2YPGYWVtqCxabDgM6l9qERaZWxbfHyHMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kvJSGxCJRCJtgehBeWZFhMjaZLI2roV2XanIrEN97jNyTANERWZt8rGFnE0ja9+2m91l6kOHsiGAqMuNoy73TdF2GXWnU9mmVGeHk7VJYWs5HcvWIqOuAFRnR5Czme1iN3RC9AGEMRso/NzOiF7hsWFMA6rD8+6IpcIrs4FZ7WBvcTqU9adH5XoIMa/+G+bUfd709UxfenfcnPrcPACqsuOYU/dpKUylItOPruVrIURVdgxV2S+LtitXD3pU/pTZde9Sm5sAQKeylehYtjwA9TabOXUfALl2sbtcfelYvjog6rJjqcl9XbRdmbrTpXxz5td/QL1NIkMXOpev1/B6Rp2pzn5BbW50u9j9i3U244pDTqUsk+Gm5x/iokf+1eT1Hl26ccsfzmGl/oOorqvl0GvP4pOxfmzdO3fjpt+fyZrLroyZcei1Z/PWlx+1i91Jbv7j+ey8yU+ZMnM6ax2xa9E2Vxx1OjsN3Yr5NVUcfMnpDPuqNP07yfarbcw/9ziBskwZ/3rrMS557o4mr/fo1I3r9z+dFfsMpLquliPv/jsjJxa/di4JFhh5lnSZpBMSz5+WdFPi+T8l/VHS1pL+uygfLOlgScssssU/MiSdK2m7RdxntKQ+RbafLenkItsHS/r4e9q5jKT7v897LClC37lqMfftIemoJW3TQj7zJUkbFtl+gqTOi/mei30OirxX0X7Tyn03lHTlkrBjSVORWYm63CfU5j4go76ITkXblWcGk2NGYotRlxtBXW4YdbnhZNQT0a19jAY6lK1BVf17zK9/lfLMAETXou0qMz8ha1ML9h1CfW4q8+tfZX79a+RsbnuYDIDoizER49tgc0VBiyqMceFvKqJv2F6JWCpsH4voXGTf9qNn5fp8V/0qk6qeolPZcpSr+Xdfk53KlOpnmVL9bMkcZ4Bu5eswq+5Nptc+T8eyQZQVsRWgS/ka1OYmNzzP0JFOZSsyo/YlZtS+AIgOZYPayWroWL4G8+reYW7dy1RkliHTQh/vWLYa9Yk+nmMec+tfa/gzstQljqstySjD1Yedxo5/P5rVT9yD/TbfgSEDV2zS5vTdD2f46M9Z55S9OeiqM7ji4FMbXrvikFN5avgbDDlxd9Y5ZW8+HT+qXewu5NZnH2KH049o8fUdh27FKgOXZ5VDduCIy8/i2uPOakfripNRhiv2Opldrz+JdS/Yn73X347V+g9u0ubU7Q/io/FfMvSigzjs3+fxzz1OaFubFvL6G8BmAJIyQB9gjcTrmwGvL+ZnHwwstvMs6UcRNTezM83suVLbsTDMbIKZ7VlqO5YAPYB2dZ4XwAnAYjnPacHM3jOz40ptRyGiG0Y1UAMYOZtKRr2btSvTMmRtGlhdwSv5CJzCn7WpvXky6kHO5mFUAUZ9biLlmX7N2lVkBpO1SRi1ia3llKkX9Q0RdgPq28FqgA5AXcPnGXOBLgVtkudQiccVeATaQqvqIvu2D5WZXtTn5pK1eYBRlR1Lp/KBJbFlYZSrJ1mbS87mA0Z1dhyVmaWbtetUthI1uQkFfQWQEGWA/89ZVbvYXaYe5Gx+Qx+vy02gItO/WbvKzGDqcpMwqyn6PuXqk3iftmejldfkq0ljGTVlPHXZeu5542l2Hbp1kzarD1qR50e8DcDnE0YzuO8y9Ovei26durDVkPW5+YWHAKjL1jNr/px2sbuQV0e8z/Q5Lc/s7LrZz7j92UcAePuzj+jRpRtL92oWq2tXhi6/Ol9PHceoaROoy9Zz3wfP8au1tmzSZsjSK/DiF+8B8MWUMSzfawD9uvVsM5sW5jy/TnCecaf5Y2COpJ6SOgBDgGHh9a6S7pf0maQ7JQlA0pmS3pX0saQb5OwJbAjcKWm4pCYhIUm/C/t8KOmBfHRO0q2SLpX0InCRpJUkPSXpfUmvSlqt8AAk/TR8xnBJwyR1CzZcHGwaIWmf0HZrSS9L+o+kLyRdKOkASe+EdiuFdn2DXe+Gv82LfO7Bkh6W9JikUZKOCVH6YZLektQrcUx7hsejJZ0j6YPweauF7b0lPRP2vZ6md55C1pH0gqQvJf2uiF0dJf0rvP8wSduE7U9IWjs8HibpzPD4PEmHJ6PX4dgeDOf+S0n/SLz/YeHcvSTpxmLR0XD+ng3Heb2kMQqR9HDO3pf0iaQjEvscEt73ZWDzxPaVwvl8Vx7Fn5t47ZSw/SNJ54TNFwIrhf5wsaQBkl4Jzz+W1PQXSfE+HLa/JOmi0D++yO8rqZOke8Ln3gvNQ56SjsMHjy+G/oykn0t6M5yX+ySfe5c0VNIb8t/DO1JDeGmZFr6DuZL+Ftq/Jal/2L68pOeDXc9LWq6IXeuGfT6S9JCkngkbPgr2XZzoCw2zTpK6SLolnKthkorPCbYDorLJTdeoQVQWtKoko97kbGLR96jIrEtlZmNyNjM4g22P6BicR8esGtGxoE0HytWfulxTKUmGTpjV0qFsLTqVb06HsjWBsvYwG1cAJh31elRUFdgFsSxiAMaUsK0W6IjfjoTo3MK+bU+ZOpG1+Q3PszafMjWfsags602/jtvTp8MWlGup9jSxgYw6kU04vDmrbmZrho5Ulg2gOts0ypmjmqr6r+jd4Rf07rADRh11uaazGG2F6Igl7aYaqXkfr8gsTW1uTIvvU5FZhrogQWkPBvbqx9hpkxqej5s2mYG9mg5sPxzzBXtsvC0AQ1dak+X7DmBQr/6s2G8QU2fP4F9HncsHF93DjUeeSecOTY85LQzs3Y+xUxPH+d1kBvZuPrhpT5bp3pdxMxtnGMbPnMoy3fs2aTNiwpfsuvbWAGy43BCW69mfgd2bBx6WFAt0ns1sAlAfbrKbAW8CbwOb4s7vR2aWH86uh0fSVgdWpNHBucrMhprZmrgTsbOZ3Q+8BxxgZuuaNRvyPhj2WQf4FDgs8dqqwHZmdhJwA3CsmW0AnAxcU+QwTgaONrN1gS2BKmAPYF1gHWA74GJJA0L7dYDjgbWA3wCrmtlGwE3AsaHNFcBlZjYU+HV4rRhrAvsDGwF/A+ab2XrhPB7Uwj7fmdn6wLXBdoCzgNfCvo8CzZyeBGsDv8S/ozPVXBpzNICZrQXsB9wmv3K9AmwpaSn8Lpj//rYAXi3yOesC++DnaR9Jy4bP+iuwCbA90GwwkzieF8JxPlRwPIeG73ND4LgwcBgAnBNs2h7vY3muAK4I30XDlVTSz4FV8HO/LrCBpK2APwNfh353Cv79PB36xzrA8CL2NuvDidfKQ/84IRwXwB/w73pt/HvfoPANzezKYO82ZrZNGDycgfft9fHfxx8lVQL3AseH38N20BBqWZeC7yBs7wK8Fdq/AuQHUVcBtwe77gSKyS1uB/4U2oxIHNO/gN+b2aZAtsh+AH/Bv9ehwDb476o0IcRWUJ5ZkfoFaCXrcsOpzb1DRl2DlKBUNI16dygbQk3u8+bNJDJairrct1TVv45ZlsrMis3blZR5GGMxJiX0z3UYMxHLIAaQny0oDcXiEk1tqc3NYNL8x5lS/Sxz67+id8fNiuyTDrpWrMW8uk+abRcVVGYGMK3mGabVPIUop0Om/WQbC6NT+RpUZz9bQAtRnulPXa74wLctCDGTJpg17RsXPnwLPbssxbB/3MuxO+7LsFGfU5/LUl5WxvorrMa1z/yH9f+0L/Nqqvnzboe2l+mLRNHjLNnv0SliUjObLn72Dnp27sbbp9zKUVvtxfDxX1Kfa+lW9f1pzfA+H33eDLgUGBgez8JlHXneMfP5QknDgcHAa8A2kk7Fp6d7AZ8Ajy3kM9eUdD4+xd4VeDrx2n1mlg1Ruc2A+xJfdocW7L9U0p24Uz5O0hbA3WaWBSaHaOZQYDbwrpmHoiR9DTwT3mcE7hCAOzCrJz53KUndzKxwHubFsG2OpFmJ4x6BO7nFeDD8fx938gG2yj82s8clzSi2Y+CRMBipChHNjWjqEG4B/F94r88kjcEHJK8CxwGjgMeB7eUR/8Fm9rmkwQWf87yZzQKQNBJYHpf1vGxm08P2+8J7F7IFsHuw4amC4zlO0u7h8bK4A7w08JKZi99CNDf/vpsCu4XHdwGXhMc/D38NMyPhvQozv94FbpFUATxsZsNpzoL6cPL7Ghweb0VwTM3sI0mtyQrZBB8UvB76VSU+yPoJMNHM3g3vNxsaLnDFvoOxeCgvn4PwPj7gAD9X+T51B9AQrQ7v0R3oYWYvh0234b+vHkA3M8v/3u+i6QAiz8+BXdSon+6ID4wWSxQqn3k4AmDZ5RYt8mHUInVo8HtEh2bT1hm6ksn8JDyrIKOe1OeMHNMTrbLkbBYZ9WwSkWwrjKaRZqkjRtNp64y607FsHX+dSsrK+lKTzYUIeTU57xLU26R2dJ7raXo7KccWKBmpxuUaGVwiMwfDL5+i10L2bTs80tw4UCpTZ7JW3aRN0rbq7CR6kCFDJblCWUQbk7OqJpHmjDo2iUSDJwouVTnUX6eSykx/5tQZILI2v+E3UZOdQEWmFzW54km1SxKjmuRkc4aOWME5LlP3hsRAUUl5ph9V9Ua9TQ7H1Y+szWouRWlDxk2bzLK9G2Uxg3r3Z8KMptH6OVXzOPTaRo3wqKueYNSU8XSu7Mi4aVN45ytPPbr/rWdT6zyP+24yy/ZNHGef/kyYNmUBe7Q942dOZVCPxnvAwB59mTjruyZt5tTM54i7/tbw/PMzH2D0tLabmWhNqbq87nktXLbxFn4TLtQ7J6/wWaA8RDSvAfYMkc4bgdbMVdwKHBP2Oadgn3kJ22eGCGL+b0jhG5nZhcDheMTwLbkUYkGyh+Rx5BLPczTeHTLAponPHVjEcW7te7W0T7agTbOhn6Sj1ShJWaaFdoXPWzr2d/Fo75Z4tHIYHrF8fyF2Jm1d0HldqA2StsYHJpuGqOkwGr/7RR36Crgg8R2tbGY3FzYys1dwZ3c8cIekJjMCrejDrf6+WmHvswl7Vzezw1iw4LbYdwBQZ40hkUK7krTWxkX5Xn+dOIblzGyxs6nM7AYz29DMNuzbt8ei7cuckCDYARAZ9SVn05u0qc291/CXs++oz30dHOdyGuUOGTLqgbWD4wwER71LsF2UZwaQzTW9cc2vf7nhr94mUZMdSdamYNQGmYcH+8vVux0TBmtwZ9i7micMzitok+yGlXh3yWvLyxJtukA7yWQKqc3NoDzTNTjQolPZslTVN70BZ9QYo6nI9ATU7o4zQL3NpExdyQRbO5YNojY3qUmb6bXPMr3mGabXPENNbgJz6j6kNjeRnFUF2/28V5b1pb6d+krWZlGW6OMVmWWos6ZJf3PqXmz4q8tNpKr+4wbHGdpfsgHw7tefsMqA5RjcdxkqysrZd7Nf8Oh7Lzdp071zNyrKvJ8fvu0evPLp+8ypmsfkWdMYO20Sqw7w6ibbrrUxI8e1XSWI78Ojb77AQdu74m7j1dZm1rw5TJr+3UL2alve+/ZTVu47iMG9BlBRVs5e62/Hfz9+rUmb7p26Npz7Qzfdhde+Hs6cmra7brc28nwS8E2I1E4Pkag1aJwObom8k/FdiBTvCeQrNsyBFlPYuwETQzTwANyxaYKZzZZrifcys/uCDnVtM/sw2U7SSmY2AhghaVNcSvAKcKSk2/BI4lbAKbQsMyjkGeAY4OLwGeu2ELFcUryCn4fzJe0I9AQws6uBq/ONQjRyV0kX4HegrXGZQmWR93pB0qp4ZPBzM6uVNBbYGzgP6ItHcS+h9bwDXBZ0snNwScuIIu1eC59zUZBX5FX93YEZZjY/DHI2CdvfBq6Q1BufHdgLyH/Pb4XPuRfYN/EZTwPnSbrTzOZKGohnNDXpd5KWB8ab2Y1BYrA+Ll3Is6A+3BL5c/yipDVpeZYhb8t34TiulrSymX0Vov6DgM9wbfNQM3s36J0XN0PmDfwc3RHsa3L1MbNZkmZI2tLMXsVlSy+b2QxJcyRtYmZv0fQ8J3kaOFbSsWZmktYzs2EttG1z6nNfU5FZEwFZm4wxn4w8opKzSS3u55GuVcmPGXL2XUE1jrbEqMmOpFP5UPKl6nLMpTzjipz63NgF7l2THelRaQmzKqqz7VcKy/guyC7yperqgLweeDbQNVQtMXzStdEZEv1xR84wvqO9SqY1x5hZO4w+HbcKpepGUW+z6VLuEfx59d/QqWwQXStWwswwskyveatkts6t/4juFZshRHV2DFmbQ8eywQBUZ0e3uGe9zaAmN4GelVsDRr3NWmD7JYtRVf8xXSo2wkvVjSNnc6nMuHqvNlc4OVhIhvJMH6rqit1a2o5sLssxt1zI03+5lrJMhltefISR477myO09j/76Z+9nyMAVuP2Y88nmsowc9w2HXXd2w/7H3nIRdx73dyrLK/hmyngOuebMdrU/z12nXczWa29En+49GHvnC5x1x1VUlHl1m+sfv5cn3nmFnTbaiq9ufYr5NdUccslfSmJnkmwuywkPXMpjf7iMskwZt731Xz6dNIrDN98NgJtef5jV+g/m5gP/SjaX49NJo/j93Re0qU2tcZ5H4NPxdxVs62pmCxyOmNlMSTeG9qPx6GaeW4HrJFXhkcakQ/BX3GEaE/Ztyck+ALhW0hl42OMeGp2qPCfIk+KywEjgSXxae9PQ1oBTzWySiiQctsBxuKPzEX4OXwF+38p9F4dzgLslfQC8THPpQZJ3cNnFcsB5ZjahQHJxDX7eR+BzrQdbY2bVq8C2wXl9FXfeiumdi2Jm4yX9Hf/uJuDnu1hab/549gnHMxF3JJ8Cfh/O6+e4Q4mZTZR0Ni5jmAh8QGOo6gTg35JOCsc9K+zzjKQhwJthUDEXONDMvpb0ekh4exKfTTlFUl1o0yTyvJA+3BLXAv8KxzEc/06KcQPwpKSJQfd8cDgv+dDWGWb2RThP/yef66zCo/OLw3G4ROUUYCpwSJE2v8X7R2fgm0Sbw4AbJc0DXqL493oecDnwURjMjgZ2DrMiN5nZTuDJqcDhoW+eC7xnZo8u5jG1SI4Z5HJNJ05acprrrbE+rjGfutzwJW1Oq8naVObXN50Obslprsk2dSByzKEq+0bRtm3PfIzCSM/sxOOZWLPaz47RvlHEBVGdnUR11VNNts2r/ybx+Gvm1RevS9ze1OYmU1vbNGrbkhPsdZwbmV//GfNZkK647ai3qcytaxq1bclprmo2AMwxp+7ZNrJswTw57DWeHNY04nn9s42xlLe+/IhVj9+l6L4fjvmcoacd0Kb2tYb9LzhloW2Ouer8drBk0Xh65Js8PfLNJttuev3hhsdvj/6YNc/fp93sUaHgPRL5PkjqGiK95Xgy4C1m9lBBmw5A1szqw2zAtSFhb3E+rzNQFSKd+wL7mVnJqjz8WMl/r+Hxn4EBZnZ8e33+BhuuZm+83VJebnqpy5WmHNX3pXN5sVSFHwYT5n+w8EYppENZ6Wpbfx8qMz9Mu3scWPqI6mIxs/0lQkuKDkN6lNqERab2no/ITZ7bTLr4o6iVHEkVZ8sXfemIy1seLtJmOeA/8trhtSxc/rMgNgCuCpHOmUA6szB++PxS0mn4NWMMXqc9EolEIpH/OaLzHFmimNlCV6ozsy/x0oZL4vNexUvMRdoQM7sX15VHIpFIJPI/TWuqbUQikUgkEolEIhGi8xyJRCKRSCQSibSa6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIKykvtQGRSCSyMMyy1OXmlNqMRWZW7bxSm7BYVGTGl9qExeaV8WNKbcJi0a2yotQmLBbl+oHG4Hp3LLUFi0WHAZ1LbcJiU/PpzFKbsOhUZYtu/oH2+kgkEolEIpFIpP2JznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCuJznMkEolEIpFIJNJKovMciUQikUgkEom0kug8RyKRSCQSiUQirSQ6z5FIJBKJRCKRSCspL7UBkUgk0haUqQ8dyoYAoi43jrrcN0XbZdSdTmWbUp0dTtYmha3ldCxbi4y6AlCdHUHOZraL3YV0KOtP98p1EWJe/Sjm1n3e5PXKTF96d9yM+tw8AKqz45lT92m72yl6Up5ZCSGyNomsjW2hXVcqMutRn/uUHN81ea0isz5GDfW5T9rD5AYGdB7MBv1+hhBfzxrByBnvNGvTr9OybNB3G6QMNdkqnh93L53Lu7Hp0jvSsawLhvH1rI/4fOYH7Wp7nr6dlmfNXj9FiG/nfsJXs95r1qZ3x4Gs0eunZMhQm6vijUkPlMBS6NNxOYb02gohxs0dyTez32/yeq8OA1m/3y+pqp8NwOT5X/PVrHcBWL7bOizbdQ0Axs39hNFzPmw3u3+x+iZcsfeJlCnDTa8/ykXP3NHk9R6du3HLb/7CSn0GUV1fw6F3/I1PJnzDoJ79uP23Z7H0Ur3JWY4bXnuYK1/8T7vZnWT71Tbmn3ucQFmmjH+99RiXPFdwDJ26cf3+p7Nin4FU19Vy5N1/Z+TE4tfO9uTmP57Pzpv8lCkzp7PWEbsWbXPFUaez09CtmF9TxcGXnM6wr9ruOrjIkWdJl0k6IfH8aUk3JZ7/U9IfJW0t6b+L+N4HS1pmUW36sSHpXEnbLeI+oyX1KbL9bEknF9k+WNLH39POZSTd/33eY0mxgOP/vaSDwuNbJe25CO+5m6TVF9Oe731+E++1yL+lRXz/HpKO+h77L7FjXZJ0KFuDqvr3mF//KuWZAYiuRdtVZn5C1qYW7DuE+txU5te/yvz618jZ3PYwuSg9KtdjWvVrTK56ms5ly1Kubs3a1Ga/Y2r1c0ytfq4kjjNARWZl6nIfU5t7j4z6IjoXbVeeWZEcM5ptL9NAzOa3tZnNEGLDftvx4vgHeHz0v1h+qdVYqrJ3kzYVmQ4M7bcdL094iCfG3MprEx8DIGc5Ppj6Eo+P+RfPfHsnq/RYt9m+7XUUa/XamrcnP8yL4+9gmS6r0rWiV5MW5ZlK1uq1De9OfoyXJvyb96Y8UQI73dY1em3Ne1Me5dUJdzKgy6p0rejZrNWM6gm8PvEeXp94T4Pj3LWiF8t2XYM3Jv2H1yfeTd9OK9C5vHu7WJ1Rhqv3PZkdrzqR1c/dj/2G/pwhSw9u0ub0HX7L8HFfss7fDuSgW8/lir1OBKA+m+WkB65k9XP3ZZN/HM7RP92z2b7tdQxX7HUyu15/EutesD97r78dq/Vvasep2x/ER+O/ZOhFB3HYv8/jn3uc0O52FuPWZx9ih9OPaPH1HYduxSoDl2eVQ3bgiMvP4trjzmpTexZHtvEGsBmApAzQB1gj8fpmwOuLac/BwGI7z5J+FJF0MzvTzJ4rtR0Lw8wmmFmrndFSYGbXmdnti7n7bsBiOc8/MHoAi+08p5GMepCzeRhVgFGfm0h5pl+zdhWZwWRtEkZtYms5ZepFvY0Lzw2obwerm1OZ6UV9bi5ZmwcY87Nj6VievviC6BbOdTVg5GwqGTV3Iss00AcqVlvwSiUZ9UpE/tuP3h2XZm7dDObVzSJHjjGzP2NQl5WatBncbQhj537B/Po5ANRk3cmvzs5jRs0UAOqtjtm10+lcXnyQ1pb07NCfefWzmF8/GyPHhHlfsHTnFZu0GdhlNSbO/5qqrB9Dba6q3e0E6FHZn3n1M6kKtk6c9wX9Oq248B1x53lmzSRyVo9hTK8ZT//OKy18xyXARoNX56up4xj13QTqsvXc896z7LrOVk3arL70Cjz/mUf8P588hsG9B9CvWy8mzZ7GsLE+YzS3Zj6fThrNwB7Nr0dtzdDlV+frqeMYNc2P4b4PnuNXa23ZpM2QpVfgxS/8GL6YMoblew2gX7fmg5v25tUR7zN9zqwWX991s59x+7OPAPD2Zx/Ro0s3lu7VLJ62xFgc5/l1gvOMO80fA3Mk9ZTUARgCDAuvd5V0v6TPJN0pSQCSzpT0rqSPJd0gZ09gQ+BOScMldUp+qKTfhX0+lPSApM5h+62SLpX0InCRpJUkPSXpfUmvSlqt8AAk/TR8xnBJwyR1CzZcHGwaIWmf0HZrSS9L+o+kLyRdKOkASe+EdiuFdn2DXe+Gv82LfO7Bkh6W9JikUZKOCVH6YZLektQrcUx7hsejJZ0j6YPweauF7b0lPRP2vR7QAr6zdSS9IOlLSb8rYldHSf8K7z9M0jZh+xOS1g6Ph0k6Mzw+T9LhyYhjOLYHw7n/UtI/Eu9/WDh3L0m6UdJVRWw4W9Jt4ZhGS9pD0j+CTU9Jqgjttg22jJB0S+hzeU4J38s7klZOvG+xyPsG4Xt9Xz57MqDg9c2AXYCLQz9ZqaW+Jam/pIdC3/ww7AtQFo73k3BcnUL7lyRdFOz8QtKWC/oeCuzqFfrQR6HP5L+fvpKeDf3kekljJPUJ39Xxif3/Jum4gre9EFgpHOfFcor9FopuL7BvjXBcw4ONqxS2aQ9ER4zqhudm1YiOBW06UK7+1OW+bbI9QyfMaulQthadyjenQ9maQFl7mN2MjDqRtUYnJ2tVlDW9NAJQWdaLfh23o3eHLSjXUu1pIuDn0qym4blRg6gsaFVJRr3J2cRm+5dnVqI+NwofqLQvncq7MS84xQDz6+fSuaJpdL9bZU8qyzqy7aB92GG5A1mhW/MxdZfypejZoR/fVTc/vramY1lXqhLHUF0/l45lTZ34rhU9qMh0YNOlf82WA/ZlUJdmt8Z2oWN5F6rrG2dyqrPNbQXo0WFpNh+wHxv226Uhij6ndhq9Oi5DRaYjGZXTt9PyRfdtCwb26MvYGVMano+bMYWBPfo2afPh+C/ZY92tAXdUl++1NIN6Nm2zfK8BrLfsqrw9uv0n65bp3pdxMyc3PB8/cyrLdG9q34gJX7Lr2lsDsOFyQ1iuZ38Gdm9/R39RGdi7H2OnNg6+x303mYG9+7fZ5y2y82xmE4B6ScvhTvSbwNvAprjz+5FZQ1hhPeAEPHq3IpB3KK8ys6FmtibQCdjZzO4H3gMOMLN1zaxwWPxg2Gcd4FPgsMRrqwLbmdlJwA3AsWa2AXAycE2RwzgZONrM1gW2BKqAPYB1gXWA7XCnKe9QrQMcD6wF/AZY1cw2Am4Cjg1trgAuM7OhwK/Da8VYE9gf2Aj4GzDfzNYL5/GgFvb5zszWB64NtgOcBbwW9n0UWK6FfQHWBn6Jf0dnqrk05mgAM1sL2A+4TVJH4BVgS0lL4aG3/Pe3BfBqkc9ZF9gHP0/7SFo2fNZfgU2A7YEFXbFXCnbuCvwbeDHYVAX8Mth0K7BP2F4O/CGx/+zwvVwFXN7ShwRH/P+APUM/uQX/Lhowszfw83pK6I9f03LfuhJ4OfTN9YG8YHMV4GozWwOYifeLPOXB1hPw7xJa/h6SnAMMM7O1gdOBfFT9LOCF0E8eorE/3Az8Nhx3BtgXuLPgPf8MfB2O8xRa/i0s6DeS5/fAFeG3tSEwjtTQ1DHrUDaEmtznzZtJZLQUdblvqap/HbMslZnWRcZKQV1uBpPmP8GU6ueYW/8VvTtuWmqTitLoIDclQy+wOozSSWMKMWvaVzLK0KtDf14a/yAvjnuANXtvSreE1KBcFWy5zC68P/VF6nOFUfVS0fQYRIYeHfrxzuRHeHvyw6zSY2O6lPcogV3N4zxWYOvs2im8NP42Xp94N2Nmf8j6fX8JwLz6GXwz+wOG9tuVof12YU7tdxi59rFaRewuGOtd+PTt9OzcjWGn386x2+zFsLFfUJ/NNrzepUMnHjjyAk6473LmVJdAolQkxFZ47i9+9g56du7G26fcylFb7cXw8V9Sn8s23zFlFP1+2nAwvrgyh3z0eTPgUmBgeDwLl3XkecfM5z4lDQcGA68B20g6FegM9MKdjccW8plrSjofn2LuCjydeO0+M8tK6hrsuC9xIjvQnNeBSyXdiTvl4yRtAdxtZllgsqSXgaHAbOBdMw+XSPoaeCa8zwggHx3cDlg98blLSepmZo3hAOfFsG2OpFmJ4x6BO7nFeDD8fx93YAC2yj82s8clNRcRNvJIGIxUySP0GwHDE69vgTuTmNlnksbgA5JXgeOAUcDjwPbyiP9gM/tc0uCCz3nezGYBSBoJLI/Lel42s+lh+33hvYvxpJnVSRqBh/qeCttH4H3nJ8AoM/sibL8NdzgvD8/vTvy/bAHn4yf4IObZ8H2VAQsMFy2kb/2MMPAJ/WeWpJ7B1uGhzfvhGPI8WGR7S99Dki0ITriZvSCfgegetu8etj+V7w9mNlrSNEnrAf1xx3vago41vFex30JL2z9K7Psm8BdJg/Df1pcL+awWkXQEcATAssstWuTDaBppljpi1DRpk1F3Opat469TSVlZX2qyOXI2E6OanHdl6m1SyZznXEGkuawgEg1gCUlJTXYSsB4ZKsnRfk6cUYPUocFfEx0KpDCQoRuZzJDwrIKMelGfM6RuZNSbSvXC4zlllOsn1FuRgU0bUFU/hy7ljZHmzuVdqapv6sjPr5tDTbaKrNWRtTqmVI2jR4e+zKmbgciw5TK7MHr2p4ybu9jd/XtRnZ1Lp8QxdCzvSnV2XrM2U6qqyFo9WatnevV4lqrsw7z6me1ra/1cOiakLR3LulJTYGu91TU8nlo9htWVoSLTkbpcNePmjmTc3JEArNpj0yZR7LZk3IwpLNuz8To0qGc/Jsxqmisxp3o+h95xfsPzUec/xKhpEwAoz5TxwBEXcOc7T/PQ8JfaxeZCxs+cyqAejdHYgT36MnFW06TdOTXzOeKuxljS52c+wOhwDGlm3HeTWbbv0g3PB/Xpz4RpUxawx/djcUvV5XXPa+GyjbfwqGah3jl5t8oC5SGSdg0e9VsLuBEojK4V41bgmLDPOQX75H95GWBmiKDl/4YUvA9mdiFwOB71fitMvy9I9pA8jlzieY7GAUgG2DTxuQOLOM6tfa+W9skWtGk2rJJ0tBolKcu00K7weUvH/i4ePdwSj0IPA36HO3wLsjNp64LOa9H9zSwH1Flj+Cd/bhb2XtbC40IEfJL4rtYys58v5L1b1bcKKHY+Cl9Lbm/NuSrWxhay7014PsEheJR9cT5jQdsbDTG7C5e7VAFPS/pZKz6vpfe6wcw2NLMN+/RZNClCzmaRURdEJ0CUZwaQzTW9kM6vf7nhr94mUZMdSdamYNQGmUcXAMrVu2QJg7W5GZRnulKmzoDoXLYs1fVNx3mZhHKpItMTULs6zgDGnHCuOwIio77kCsZotbl3Gv5yNpX63FfkmEbWRlObe5va3DvU5T4lx8x2c5wBplVPoltFT7qUdydDhuWXWo3x875u0mbcvK/o22kgQpSpnN4dBzC7djoAmyz9C2bVTuezmS1dFtuemTWT6VLeg07lSyEyLNNlVSbNb1ohYdL8r+nVofEYenToz9y6BcVc2oZZtU1tHdBlVaZUNZ2RqMw0Jpt2r+yPEHW56vCaDyY7lnWlf+eVmDD/C9qDd8d8yir9lmVw7wFUlJWz74bb8+hHTSdgu3fqSkWZX84P33xXXvlyWEOE+ebf/IVPJ43msufvbvbe7cV7337Kyn0HMbiXH8Ne62/Hfz9+rUmb5DEcuukuvPb1cObUtH+UfFF59M0XOGh7r8Kx8WprM2veHCZN/24hey0+3yfyfBLwTYhCTZfUA9dAN9PUFpB3er8L0bw9gXzFhjlA81RypxswMUy5HwCML2xgZrPlWuK9zOw+eYhwbTNrUstG0kpmNgIYIWlTXErwCnCkpNvwaPhWwCksWGaQ5BngGODi8BnrJqKObcEr+Hk4X9KOQE8AM7sauDrfKERJd5V0AdAF2Bqfpq8s8l4vSFoVn/L/3MxqJY0F9gbOA/oCl4S/1vIOcFmIxM7Bo6YjFvVgA58BgyWtbGZf4RKalxOv74Prd/fBI6At8TnQV9KmZvZm6FOrmllhfayG/riQvvU8Lh+5XFIZBK9r0Sn6PeAD08I250naGpf0zJb0Gv49XSTp54T+EHgIOBeowCVDhRT+7lr6LZS3sL1hICtpRfy6cGV4vDbwwqKfiu+LUZMdSafyoeRL1eWYS3lmWQDqc8XLqOWpyY70qLSEWRXV2Y8W2L7tMGbWDqdPxy0BMa9+NPU2m87lHgmfX/8NncoG0aViRTDDyDKj5u2SWFqf+4qKzJoNpeqM+WSCqqeYzjktGMZ7U59nm0G/RmT4ZvYIZtVOY+XuPivx1awPmV07nYnzRrPT8gc3lKSbVfsdfTsOZIWl1mBGzVR2XM5Vdx9Oe5UJ85rLU9r6GD6e/hKb9N8NIcbOHcncuuks320tAMbMGcHcuhlMrRrNT5c5AMP4du4nzKlb2CRU29g6cvrLDO23CyLDuGDrsl3XBGDs3I9ZusvKLNd1TQwjZ/UM/+6phv3X67sTlZmO5MgxcvpL1OdqWvqoJUo2l+WYey7h6WOvoCyT4ZY3/svIiaM4csvdAbj+1YcYsvRgbj/4LLK5LCMnjuawf3sEd/OV1uGgTXbio3FfMex0V9qd/si1PPnJgm5TbXMMJzxwKY/94TLKMmXc9tZ/+XTSKA7ffDcAbnr9YVbrP5ibD/wr2VyOTyeN4vd3X9CuNrbEXaddzNZrb0Sf7j0Ye+cLnHXHVVSUVQBw/eP38sQ7r7DTRlvx1a1PMb+mmkMu+Uub2rO4zvMIfDr+roJtXc1sga6+mc2UdGNoPxqPbua5FbhOUhUexU3OT/4V11aPCfu25GQfAFwr6QzcWbgHKCwEeYI8GSsLjASeBGpxJ+VDPJJ3qplNUpGEwxY4Drha0kf4eX0F13+2FecAd0v6AHcgv11A23dw2cVywHlmNqFAcnENft5H4Nrmg60x++dVYFszmy/pVWAQxfXORTGz8ZL+jn93E/Dz3XLK7ILfq1rSIbh0ohzvO9clmnSQ9DYeJd5vAe9TK0/IvDJIHspx6Ueh83wPcKM8wW5PWu5bxwM3SDoM71N/YCEykBYo+j0UaLnOBv4V+tl8gp6Zxv6wD94fJuJOcf54X8Qj583Ea2Y2TdLr8uTPJ4FTKf5beKiF7YMTb7cPcKCkOmAS7rQj6Qng8ND3zgXeM7NHJe0CbGhmZy7G+VogWZvK/Pqm06otOc012abjuRxzqMq+UbRte1OTncTkqqZVKObXN0YV59V/zbz6rwt3a3dyzCCXa1pbuCWnud6KRwuNWdTnFuvy8L2YMG9UM4f3q1lNbxufzniXT2e822Tb1Orx3PXFosQS2o4pVaOZMn50k21j5jTt11/P/oCvZ5emDnWSqdVjmDphTJNtY+c2JtB9O+cjvp1TfMD69uTS1KYGePKTN5s5vNe/+lDD47dGfcyqZ+3VbL/Xv/4Q/WGTNrevNTw98k2eHtn0GG56/eGGx2+P/pg1z2+WC15y9r/glIW2Oeaq8xfaZkmhwsSISGRJI6mrmc0NDu9DwC1m9tDC9ou0HnnVkayZ1YfZlGtD0l4+UfADYK/vo0EuJetvsIq98taVpTZjkZlVO2/hjVJIn47pz65viQe+br7AyQ+BbpUVpTZhsSjXD3Oh4p0uLMyb/mHQofKHeb4Baj6dWWoTFp23RmGzq5pJFn8UdZEjqeds+aIvHXF5y8OlNedHyXLAf4KjXEuQT8kXefkv8NAP1XGORCKRSCRNROc50uaYWbM6y5ElS3CM1yuyfSReJjISiUQikcgS4Icb/49EIpFIJBKJRNqZ6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kqi8xyJRCKRSCQSibSS6DxHIpFIJBKJRCKtJDrPkUgkEolEIpFIK4nOcyQSiUQikUgk0kpkZqW2IRKJRBaIpKnAmDZ6+z7Ad2303m1JtLt9iXa3L9Hu9ueHantb2r28mfUt3Bid50gk8j+NpPfMbMNS27GoRLvbl2h3+xLtbn9+qLaXwu4o24hEIpFIJBKJRFpJdJ4jkUgkEolEIpFWEp3nSCTyv84NpTZgMYl2ty/R7vYl2t3+/FBtb3e7o+Y5EolEIpFIJBJpJTHyHIlEIpFIJBKJtJLoPEcikUgkEolEIq0kOs+RSCQSiUQikUgric5zJBKJRCKRSCTSSqLzHIlEIpFIJBKJtJLoPEcikUgkEolEIq0kOs+RSOR/HklKPI7XxTYmeb4jkUhkSSGpf3t8TrxJRCKR/3nMzCRtJKmfmeVKbc+iIGkFSRuV2o5FIZzvdSStXGpbFgdJy0nqV2o7FhVJK0tao9R2LCqSVpV0XantWFSC3deW2o5FRdLyP9B+0gc4TtJybf1Z0XmORCIRZytg3VIbkWRBUXA5GWBXYF77WbXE+CkwoNRGFLKQc14uqQNwKtCz/axaMK2J5EuqBH4GlLe9RYtGK+z/Bri+PWxZGJK6hD7QGkYBN7alPUuScE2pBA4EsqW2Z1GQVA7MBq42s2/b/PPiCoORSOTHiKQBQBmQM7MJC2g32MxGt5thC0FSX2BpMxsRnpeZWbMbmaT+Zja5pdfbG0kDga5AlZl9K0lW5AYjaWUz+6r9LWwZSd2BDmY2JTzPFJuBkNTNzOZI6mxm89vd0Ob29MH7+JRi5zrRricwE+hoZlXtZF6LSFoF+DUwAnjPzCYvoN1qZvZYe9rXEpJ6AUfjDtr0BbRbBfiJmf233YxbAkjqYWYzJXU0s+pS2wPu0IeZqhavc+F8bwzca2Z17WFXjDxHIpEfHZJWA54HzgeulDSkhXZdgGMlrd6e9rVEmCp9HbhE0nsAhTeMEP3sDtwcpidLLjMJ5/tl4BTgAUlrFjpzIapVAZwuaZ1S2FmMcM5fAW6UdDdAoeMsqUzS0sCLwYGqbX9LmyJpTeBh4C7ghBAxLNZuIHAi0DcljvNqwD3AisCvgN3D9kxBOwGrA2Pb28aWCA7zHUBnSTtJ6gRFcybWAMaVxsrmLCyyH/p3f+COMHivaR/LFkzCcf4VcEa4XudfS/aXfsDH7eU4Q4w8RyKRHxnBsXwUuBV3Lk4H/mtmLxe062Jm8yQtZWaz293QAoLdtwAPmdm/JT0F3GNmtxa0qzCzOkl9zOy7UthaYE834H486nOLpHOAYWb2cEG77mY2S1IHM0vLzbkf8B/8vN8FPAOcYWZvFLTL38SXN7MxJTC1CSGS/BhwDfAJcDNwlJm9E15vEvWXtJKZfV0SYxMEJ+7PwHwzu0LSYcAvzWyPgnZLA/OBuWnJQUhGPiX9AZd53Qq8nI/SBrvnAfNSZHe+7/4CWAsPml5WzNGUtKyZpWawAiBpR+DvwIlm9lLBa2sBE0txHYyR50gk8qPCzGYBFwF3mtkMoBPwC2iMwISI7R+CQ1dyxzkwH3f2Hw/PPwH6JhtIWh74t6SO+DR8yTGzOcA/cWcOoAuwbbJNkND8KcgMSh61TVCLD7TuNrN6YC4wMNlA0krA+aHvpCWa2AG43szuMrMPgTeAVaBBcmKS1pV0DEAaHGfwRFF8sHJP2PQ8YNAwM6EwMDgO6JkWBxR8Bkie5HqamV0LvA/sCWwjqXOIip4A9EqL3QnHeVvgEnyG5TTgzHzkVtJPJOX15C3K29oLebLi7xKb9sZnEN+XtLOkSyXtmnitJEnH0XmORCI/Rl4xs7yT9jbQGRpu3gAVwGPB0S45weGpA+4KDj/Aq8DKalp66VvgLDOrDs5eScnfgM3sGSCvAX0OKDZ9eqOZfbcgbW57Es75TOCaRBTuBWBAwZRwDp8BsDRoywHMbBLwbGI6fhZhwJJw3L4DPiqBeUXJ22pmXyc0zvXA1pL2tEZmAFekIcJfhJWAVQHM7BLgCzxh92dmNg/4ZxrsljRI0qC8Vhi38Uh80PUFPvDK95OvCcmYKenffYE/Szo6PP8S2AN4AtgsvL41gJn91czeKoWR0XmORCI/OsxsbuLpy8ChIfqSf/1rM/u8/S1rTpBh5OTJOsmb13fAUkD/EGkmOBeflcTQIgS7+4XHedu/BHaXtGWi3UQzG1UKG4sRInI5eeJfMjFqDrATiYi/mY2ykLxZahIzJx2AGYmByL1AB0lD823NbJyZvVICM5uRiICuI2l7SQMldTKzccARwHKSVsi3txYSCEuFpMFhBmI40COvdTazi/FKIPsGGdXUEpoJuLwE2AHoKaky/C6/AQ4DLgD2N7Nxkg6TdKiZ1ZvZB6W0OYmZvQccABwm6WDgYlyWdLSZnQ5cCWwmaZnE4LHdiZrnSCTyoyWvU5TUG4++lJlZKkpHhZuxmdk3YRryr3jUdqSZ3R7abIiXRKsEnimmU2xv5Alom5rZ/UGPeA7wFa4bftdc1zwA2A7AzO4onbUtI2kH4CjgQ9wRvTSxvQz4xsw+LaGJRQl9ZW9cHnOdmT0lqTOwGtAd6G1m95fSxmIEu8/GZ1TWxGUETwaneiXgQvz7SNXsBNAD+BdeVnE8fh05BZgMvIMPFgeGgUAqCIPt7sB1uARmFVyffbiZPSNP2L0DODnMGpWcIjr9zYH/w2esrg3bdgAuw+1+vPg7tQ8x8hyJRH7QJLR75Ylt+SnibLgoTwOexm90aWFX4PMQEd8Fj7B8BWwl6VhoiMKUAd+mwXEOrAccL+kUfCr4RGAkPrW6gzwBcyLwJl7nNnVI+ikehTsfH5zsIKkrgJk9BSwHdCydhcUJDsVpwB9xycNJIYI7H/gYlyONLKGJRQmDqYPx2t4v4Oc8mdz4NR5ZnJoGxzkR0exkZtPNbFcz2whPdnwb9532xPvQhmlxnBMyqmpcv/8Vnv/xAXAWXpXlAVymcUbaHGdJG0vaR9J2ZvY6PitxSELCMQQ4rtSOM8TIcyQS+YEiLxnWzczGhAjo9njU6u9F2hat21tqJJ0MnAtcbmanyxPqNsNLeH2aj4amCXl1jZ8BhwOzzeyAsP0ovETXG8DjQU+cSiTtDkzBI/oXAXua16Ze1cy+KK11LSPpQKAaX8DiFHwKfrSknmY2Q1K5pUALX4ikpXDnrRZ3oA8MMy7bAh+lQe5QiKRdgD/gZdveMrMLw/ZbgWfx6ixlaTvfYbbqz8C+eP8+HY88/z406Q1kzOyLwmhvKZH0c+AGPCK+O3AbLkdaGvg38A8zu6l0FjYlRp4jkcgPjqA5PBH4bbjJ/QPXIx4g6QoVrACWJsc5oVvtGZKO/gr8UdIK5iWXXsGj5OvIq2ukgkQSXZmZPYLf0DaWdBCAmV2DR/a3xiucpIYi2sjOwH244/zz4DhvBxwcBgepoIjd84Df4X3/gOA47wVcFabq05DwlezjXeQlIWfjTv9OwEnBcd4KuAp3jlKFpC3wCP8RwKf4dSVfY/hdoF/IP0ib4/xTYC9gI9wJrcXLvH2G/177mNlX+QFiGhxnOZ1wnfNxZvbX8HhlYGfz8ouH4MeQGqLzHIlEfnCYL/bwFtANlz9cF3TCm+HRzwsLHeg0kJie3AW4RZ4R/0/8Bvd2iHzOxEt4nWIpyNyHJgl2OwPPyyuAPAr8CdhT0m8AzOxy4Lwg20gN4ZxvGpKkBuCl0v6DJ2VWBcf5CuB189J7qSDY/VNJe0raDPgvHgkdBmQkbQOciZdlrE6DMwQNdu8KPAjcH6Kh1+Pl3f4g6YLw/JS0JGMW0AWfEdoIHwz+yrwm/EBcAvFJCW0riqQNcIf5ceBQfLDyIO5AX4LbnZqBYZ4wCKkCpgLrBxnSh3hk/2B5OdHXzey10lralCjbiEQiPyjUdLGCDfGEmC7AaWEqcik8cvsBcExaHIo8kn6G38yOMLP31LjoyVHApcBaZpYKbXbetvB4a+Bq4Hdm9kYYnJThJdKOA/5tZreVytZi5OU6Icp5Ha7Bno/fmEfg0/Lr4/rhy83s8TRMZSfs3gh4AB+oDAYewh3/S/Hofi+81F4q7M4jX9HzWjxB8Ce4NnhrvCzadng1k0/M7M002Z1H0j7AqcBsYG8zmypPVvstcKilYKXGQiRtgst4jpNX3FgK7zffAgdZOsrQAU2CCCvgiY2f4EGQ9YEXzexZ+UqUlwL7pGlAm6d84U0ikUgkHYSLbjbcyHYwsxMk3QzsBuwq6SEz+0q+mtaQNNyUg/TiVDPLJ72sgztE8yQdgkduPzazP8mrgixPChIbgy2nSTozJKQNAi4HqiUdDhyDSx/uw7WKqUkOlJegmx8c0LWBM3Bd80hJx+MOf9bMTgqORmczm1NqRy5IA+rNrCY4/L/E9cEvS9oYd0YzZnZEaN/bzKalwO4BwPrBiV8Fj4Z/Yb4i3EuS6vFKMnsGyU8DJba76Hkzs3vDLMvyeAnA3fDZoVPS4jgXsX0GsLekR8zseWCGfJXSrYC/yRd3Kfn1EBpmJnbBK6yMx+VIt+EL5uwXfqPLAH9Lo+MMUbYRiUR+QISL7i/xiMQTYdvLuJ5vGWB/SauY2Wwze7uEpjYQpBe3SFoxbHoHzxq/F+iKr8zXSb7083lm9lwRrWspmIFHa/sGh+hLvMLA5XjE+UI8UlRhZveZVwYpKUE/uRTwlDyhFPxcD8UTSjGzK3D95J5BLwxemaDUjlxP4GS8TwBsgJduy694mK+YsJ+kM8O2GZAK7ep6wCh5xZJv8AjzMpK2kCcx3oxr+5+U1CsMWEpK0NmuHB6vIalveFwGYGa/wRcUORPX3P4xH+EvkckNJCK3P5N0jaTT8Nm3fYEb5RUrfo4nZ96N5ymUuo8ktfD9cd3+vma2PV6LfzPgTjzZ8WI8Wv5AGs53MaJsIxKJpJpwoR2Ka/nK8dqf1+GJPD8HDsQjct3xRJPLzOybkhibIEScDzWzs8LzV/Go4jbyury9zWyspLXwG9x+adB/yhc9uQo4JOg8z8JvbL/BdZQdwjT2YDyCfpiZDS+VvUkSEpil8aoC/c3sBXlS437ArWZ2b2h7AvCcmX1cOosdeVLdvODAdQZWM7OnQwTucODXQZJUjjvV2ZQMVgYCq4dp9u74AhaPA/cD5+EO3X+At8OM0SBLT1m3NYBf4/KX/YDtzOyr8FqDNCw872K+gmBqCPKv/8OlVB3x3+fZ+Eqfp+ArY54BrAAci1ewmF8KJzoMVKqDwz8A1zc/ClxgZq+GNv8Kbf7Q3vYtDjHyHIlE0s76eCSrO15N4Ds8ansPsAm+KtzNeET3zDQ4zoEqvBrI3wHMbEvAJD0VJAVjg/zkPuDPaXCcA7Nw2/8TbnoX4QtbXIcvBjFVXurtYTw5cHipDE0SZCYvSBpivnz1usBzkrYxTya9Ha+a0JDcmBLHuQfwV0kH4H37V8ARkrYPUfI7gXslrW6+GtzbKXGchSfUnSlpV/Ol7l/BB7S/wqPks/H6zpuG3SYk9i0pZvYJPoNyInBT3nEOr2ULbJzf3vYVIqmvpN0TUfvVgKvN7BrzkpYn4FKq4fgM0a+BPsA/8aj5vBJGn7cCLg7Xu8vxOurv4hWFVglt7gLmpGFWojVEzXMkEkklIeL8UzPLO3GXAa+Z2RmShuEr8X0aol+3Aj3NF0MpOWGqekrQqT4pqaOZ/dHMfibpJUmPm9kvcWfpEDN7s8QmAw3TwTWSDsMTvh7CI1b/wCtrnCvpz3jU/yjzxMFUJHwF7e8bwL8lHWhmd0qqAx6RtJuZ3S2pAnegnwMmWzpKGNYC0/BB4mwzuypohH8Tzm2+cswDkjZMSwQ0RBGfxxdmOVJSrZndLKkGz0HI4RUrzsOjoQ0lI1Okc74DHyyuKmlvfCZiunxZ69r8Pmno3/hCSpsClZLuw/233YFrwuvvApPwGa3R4ZrZFy/3VtLa5WEW5XS89N/O5qUKXwL2wctdjsVL7J1oKUpsXBBRthGJRFJHiPrshkdQnjezW4JDtz7wGvBgcPL2x526c8zswZIZXARJy4bocn/gKeAFMzspvPYevqDLDiU1sgiS1jazj8LjG4Fl8Zt0Ftd/roVXIKgpnZVNUdMKLOfiqx3uFQZX++JT2/uZL008wFJSSk+NVTW64OXFVgOeMrPH5NVXNgTuN7MnJK2YllmVpAManLTdcfnUVcHW/XFn7x4ze7h0ljYloRXeCpczfG1mr4U+sjMe/ewIbIzPYqWpj3fGq30MwZ38RyXdT0iyw3Xn1+MJpiPDPqlYHCpEk/8JrIoPVn5jZvXyPJBV8H7/gZm9mpbB+MKIznMkEkklYTp7e2BH3IG+U77C2ib4Ern34qtmjQrORskvuomb81A8IvSYmZ0bdMRP4Te9U0PbTVMWcTZJK+PLar9kZnuF124EBgB74yXdlreUlNKDJrb3MrPpYduZuL15B/o3uGOxbIpmJ/J2dzezWSEqfihejeXJ0KdPwPX+x5svoFNyEnZviEedJ5iv8nkAnnNwpZk9JdeZD88PxNKCpF8B5+ByqS2B13Fp0h54Ob2f4o7zA6WysSXCQOU3eBDhSXylw1uBDng1nHOCU13ya2EhiYHiHfjKsLvJ80JWNLMXS23fohKd50gkkkok9TCzmfKKCDvg9T//HaJa2+IO9V2hbWpuFkHXdxQwBnfgLjCzy4MD/Rq+dPWJpbSxGPLSXL/FNZOHACPMbPfw2h34SnC/SEMkqxB5BZajcI3tKWY2TtJf8KngA8zskzRFnPOEc34G8ALwZnCYj8Cj+y+a2YOSljOzb0tqaAHyZLW78EoxG+O1v9+WtB8+oP2HmT1eShuLIWk5vFLP8fgg/Bx8sDgeL0WXw1cPnJCGa0pioLIpLsGoMk/OPATXmz8WIv2dgKXMbHIa7M4jaWnz/IMmg0W8tOUKeJT/OPOShj8oouY5EomkhsQFdlXgOklXmNl9ruJgR0k5M7tLXnWgIaKVhptFkJp0xxdXuCTc1O4BLpFn6/8tTBevssA3KgFBU3sUcLN5eagLgLck3WNm+5rZbyStk1LHeUO8usDZeFTuQkmXhvOd1wpvAEwJ7VPhXMgXEtkLr2zSDfi1pK5mdoOkY4BfSHothY7z2vhgdq8wzX4YcJek/cx15eWEc11qinzXM4G/4DMpZ+ALc2yMl9HrBvzJzCZAOq4p4Vr4C3xRpSeBLSTtb2aHSDK83OJSZnaPpOr8PqW0OY88F+VESWdZQqdvnli6T5iZ+DIts2+LSnSeI5FIagg3i18C+4dNx8vLj90nKYc7GOXm1RNSRbhpzZQ0EugqTzp6XdKlwE2SxpjZv4FJaXHgEtQC43A9ImF69Xjgv5KuN7MjzZfMTRWSlsVrI39qjQty/B2/aV9hZmdKuq3g5l3qaGIGj7q9D1wcZlP6AZOBX4X+fpVcM58KJxQa6x/jdXjXAp4NU/E3B0fuMXli5h2ls7KR5G9M0jr4suYTzOxzeQ3kl83s6xCNfhm4xczqS2hyM4KU5whcRvJQ2PZGGNz+BXf4P4LS9+siZHEZzC7A3YnvQuak7hq+KMRSdZFIJDXIa4BejC/A8Vu84sPBkn4VNIiPAKlx4kK0GUnLSlombB6J3zSWD89HAC8CF0haH0p/o0vY/RN5iTfh5ehuDQ4peCLSFcCQIEVJIzngY2A9STsBmNnpeBWTU0JU7utSGliImeWCTZfjTv7SwUl+GV9WfocgMRlbSjvz5PsK0NE8KfMQvK/shkt5MLNb8Ehuh1LYWIg8SffO8Hgj/LpxFb5i5lD8N/p7SVfhmuH7zEvXpQozq8P7cnJVw8OBpcMs0NUWkgPTgrykXq8g1zgd789L518v9bVvSREjz5FIpOQkokSVeBWKEWH7fLxG6J/kpbDuLaWdSRISk1/iN+b3JE01s6MkXQycHSJy6+HLLP8OX5ChpKgxcWd73HF4Ba+/ewYuO3lG0jO4c/QrUmBznsQ53wC3dTruhM4EdgmynqfM7ERJPzGz2SU0t4GE3evhlQU+MrPTJc0BPpC0kblO+1k8WXNSaS1uJNj9c+BYSd/gq+4djddW/7Oki81srJndCKmRxcwFOkp6GvgWl5nU4aXRDsArP6wCbAPca2GhjlKT6Cer4k7zDOAN4AZ5gvF4fCXV5eUrac4tobnNkDQIOA1YQdJ5eOm82XiEPI0zbotNTBiMRCIlI3GzSFZKuAOPtBwZXjsIzy7viJdKm1rKC7ASNWDDTe5U3An9FF+IY5KZHSZfwWwtfHp+Wbz6xg5mNrpEdnc0s+rweBNgJ3w1uBpc+zkQ+CMeMe+LyziWwVeN29MSi0iUkuDIXQc8iDtDp+HneFs8CewuM3uidBYWR17l4UJgGN6Xv8FtPxWXQqwenKNUIa9VfjtuYx2eEDgCH2zdhw+8TrIUlHULkq768Lg3nhh4JH5up4Xf5K74Ih03m9m7pbO2KYlrYXJQOx4/z0fg5/1pfBGaUy1lCZlBGjMB7yO/xkv/vY/Lqp7Gy9PVtvwOPyyibCMSiZSExM1iJ3whi+vlyV9/x5eBflFemu7PwPN4pDFTYsd5VeAfknqFqeFb8anrL8xLoO0B9JP0iJl9Ymb34DN8V+EJVqNLZPdq+Epw/eUJXbfgdY/fNl8h8EHcWb4OqAv64TK8GsFv0+A4y+mGr6J2tJmdjDvPvwVWx4/pPSAVcock8sTFX+PLtR+IO9FV+NLmFwA3Aj8poYkLoivwn6C5fRxfMXBtPIL+W9wJTYXjDPxO0urBkTsdr6zxFr5wTlmQZjyKO3mpitqGa+EmePm8PfCFiebig9db8P5zH3CwmT2ekNOUjIT8a128+sobQCczuxkfFD4M/Be/Bi6X3OeHTnSeI5FISQg3i6F4lYfzgHn4lOoqeLTlaTyx6gBganhcSsf5J8DdwDAzm25mk/EliJcCfhoiuzV4BYXKIC3AzD4FtrISLb8dHP67gW/MbHKIzG0GZCRdGWwcgTsVX9GoWx0H7G4pSRQMSUZzgNFA7zAD8AY+MDnOzOYD15XqPC+EenyQtRmA+fLao/BoOWZ2spm9kFLHohI4SF4yz8zrTY/Hl2qfY2bDSmwfAKFff4Rr4B/B+8JM/PoxAa+6UmG+JPs/w+8yFUjKBOf/VmCfMKgdBjyAn+trgXozeyMfLU+D/CEh6bkSnxX8Ek8kHWBmX4Zz/Tt8ELBbfp9S2bskic5zJBJpNyStEi62hCSSC4CxZvYMHmGeBGwHbIHXij0Pj3xdhcs4JpfI7tWA24ArzOw2SRWSDjezZ3HN7VHAzpI6BWnETmb2vryyAlaiBS7k5dAewBdPuElSmaTfBadiaLD58mDjcLzE3ojwfF5olwpC5Fm4U78hjQmZ44BpwZmuLpmBLRA05lm83NiaknYNL43Edbm98k5zmhwLheoaZvYkXpf3SUkbS9oC7zuzSmlfIeG39ibwDNAH6BFemg8ci2tv83KeqsL9S4EaK5iUBed/C6CiYFD7CC7x6VgaKxfKzsCjZvaAme2EJ5O+LK8gg5lV4VKlNeXVQ34UxITBSCTSLoQI6CO4wwxeHu1x4GhJO5nXRb4EL8G0Cz4FPwXX5O5hpa13+yegizWWV3oceAfAfCELw/Wr5ZLuzTtBVvq6yDsDg61xieSncL0qZjY9yGQ+ldTBzP5gZqmaygaXPISIvswTHS/HI11/DU7nmsC5adNTSuptZtMSfeAjfBW4MyXthk/Pn2hB658W5AtyfBE0whnz6iB/k1SL/zbLgLPM7O3SWtqUxHneQV4b+Xl57enHQyLbX4AuBW1LgqQ+QC78BrcHfinpfTO7I8xYvSdPfj3BzIZL+iqNv83AaKBz4vnReF+/S9KO5hVDMni0v64E9rUJMWEwEom0OSECejt+Ab0nOD0rmNk38tWy9sDLLj0Vpi+XM7NvSmlzkmDTM7ietideV/hPBW1+Bsw3s7dKYGKLSDoDr5pRgy8Pfm7B692A9c3s5VLYtyCCdvW3ZvbH8LzczOrD97EBntg42czezWvoS2lvHvkCEafjsp7peWct9PvlgFWBKWb2YZrsBggD2Coz+2uhbUG7LTOrTqHd+RyKfDWZPYE78AVQDgYOMrMPSmokDUts/xl35J/F9e93AwcCd5rZRZJ6AJ8D95vZ0aWytZDEOd4Qr8JTg1cFeRiX3j2Ja/f3A4YAr5rZhWnrK0uCKNuIRCJtiqTO+IV1unkCHXgm+aHh8UN4Isyf5PWc69PmOIcp1Z/jJZdWSTrOkraQ9G/gjbQ5zgBmdj4eKV8T+L/8dkmbSboRd4ZeTqnedizwM0l7gOtag3NUH3Sh/02TBjTBUrispHdw5BrutWY2xsyetaAlL7XdRb73F4Fe0KBpzctlMLOavDQmLXZL2lDSwORsT3DW7gd2x6vInJgGxxkaZAyv4TNvR+HytH/gDv4mkk4NcqnV8OtiKpAnXOY1znfhs1oP4cuEHxH+rgP+g2u3H8Wd65L3lbYgRp4jkUibEqKEv8LLiE3H6zYPM7MzEm364LWQPzFPpkoV4caRDRrF54BRZnaoPOHxBuAMS1npqEIknYXXu90WdygeBP6cRrsldcQTpOol7Y8vCnFpPqpYavtaQlI/C6sCSvoTrmHd1xIrHKaRINVY2sweCo7+c7iO9fLSWrZgJO2Il4DcNykjCcdgwdmrSItcoOA6MhQvDdkFr6AxNcy0XILX+v5b2KekUdugXZ5hZnUhIn4PcJWZ/VeeC/JfPJL+GNA77LYmcBFwoKVw8ZklQXSeI5FImxOme3+ORyf6mtkmidc2wqeyHw9RmVSSuPGV49rhcjyZ8UxLWV3hMBiZXuhoBgnHkXjC1PHmyWCpQl7V5HLcgXsFT/S6D9jFSlTqrzXIV2Y8A5f1HIOXVtwHuN3Mvk2z4x8i+2fjDtCX+EIov8QlDyXXCBdD0gq4TGB/M/tA0ip4ZZBvzauypIqE5GEXfAXSP+OJr3vgpTkvN7Pv5AvpZMzs/dJZ68gT/P4GDMDLKtZKuhqPOD8fjmdb4Di8FGetpL7AZfjS86mo1NMWRNlGJBJpU8JNowZ3OK8F3paU17Cugy+jOyctjnNiOrinfBWv/DFkExKOHfDVv85OoeO8Au4I5Z83TMsHCcfNwMlpcpwT57zMzD7HdaAzgH/jUSyAA+XVQlIjL0nY3QUvh3YunkD1V7x01+8I8qQ0OaAJu4fKl4z/CI+EPg/sCFyNDwCGpsVuSZ0VlnkOfbwCd+K2kXQRrm++BP9tpo7gaG6P105/zsxqzUstPoYfy2mS+pjZsDQ4zoF6/LzOBK4IEfMxuNxkqdAmm9zBzKbijvaP1nGGGHmORCJtQJFEo3wSTz4CvTUeoVsPOD1NjhxAiA6djGucTzKzFxKvNaxiFp6nKhkmnOOX8YUtLl1Au7TZvSuuUa0A/s/M3pK0Nu48H4pH435WShuLEaQDRwLvAl+Z2b2SlscXbjkZ132eal7zNjXIl5U/Hy/BeDg+E/F8eG0LXNO6DL6yXVWp+0qIyP4WX257czzKvwuefPkw7vgfD3Qws7NLY+WCkXQ2MNLM/qNQRSYMZLbG6yBfEwaPJScRKReuv/4jMNvMTpL0f8BgGr+LM83s0dJZ2/7EyHMkElnihIvuFpJODs/zSTw1+OInr+JLVp+VQsd5TXwa8hhcPnBZcDSAhsUYSDxPhQMaIuV9wjk+ARggqWtLkdq02A0gaUu8OsXpeAWNM+Q1sz8ys7vMbDugStLxJTW0gKAVvgSPNG8M7B6cojGhXx+KL3KxQgnNbEaQ9ZyER2ln4dKYEZIqAczsNVxLXI9rz9PQV0bi0c6/4pKBT3F5wBFm9hju4O0FvF46ExfKANxRxhpXZVwTXwXxzBQ6zv2BPuFc/wPoIuliMzsWj6A/BfzBzB5N04xQexCd50gk0lbMAPaRtBY0Omvm9Xgfx5eHTtVFV9JyuOM5Lzhut+F1qc9T4+IWqSPoba8BLpDXEJ4MrAv8JCWOz8IYgp/nDXAd+dFmVhXkEHlexmcr0sTyuESmE+4Y/SlEE1cKDsgYXF/+S/kqciXt64nPzwGfATsBh+EJa1OA7YJ2GLzk2NaEyhulIm9zcDbfw6U820jaNEgfsiFSfjpe7/vZEprbQEIas5GkreRa/vOAgZKODa9thkfNVzOz1Cw6ExznX+Ga8v9IugfvM/8HdJN0A/CRmT1mZm/m9ymdxe1PdJ4jkUibELKsnyRE3dS4mhZmVmdh1b1SX3QLHJop+OInFZL2Cxrce/AI9AXyZJhUkLg5dzOzsfiU9UO4E/ELfDr71LxuO00UcSJn48mkp+AZ+mMk7QdcLl/NsRfQD18tMU1Mxh2iW/BVJcdI2hmXQXRWqPqA1zDPlaqvJ853D/AFcvBl2K/CB7FfBAf0XHwRFPA6w9ua2aR2NreBRAR0ozD78wS+2MnLuEZ4BUkD8Ojtn83s4VIPUPIkkgOvxisMXYdLHP4BHCrpP2HbcZaSJc7zSFoZP8+HAj/DZydOBb4C/hmarVoa69JBXGEwEoksMeSrY52FR0HfA97Anc7nzGx+SY0rQuLm/HNgRXzVrxuC07MRkJN0v5ndLunZkAyTCoLdu+MrNHbANatPSPoYlz48hesSu+DOaWrIy3pwTfkkPGnqSLy6RnUikvgn8zJj0yWdbiVcRTDRVzbGHYdXcSfuOVzX3FvSSnh1gjOssTxdyaUmwe6dcIfzE+AmPNJfB9wi6RE8ufGvZvaZPEehlCt6Ag1274jLM/4NXI9rsO/Hnfx78UHVQWb2VX6fEpnbQLh+dMdt3Q74Nb689nPmKzduittdbimqaZ+gBh8YTgnn80hJL+GJxn+T9EdL74qH7UKMPEcike9FMtJjniX+PF7T+SlgPp6pvU1om6prTrg5/wK4GPgEj3SeiGeYf4lHXfYJzSeXxsqmJCLOnXGH5zS8lNu9krYws2/N7H0zOxLPjD+xdNY2JWH7pvhiCrsBf8flA/vgzv4/8UoVp4XBQAYa5D4lI/SVbfA6t9vhA8MNgX8BE/GFIU7HtauPpSUCCl5VA6+QcD4uIzkQ1wifBDyCD66Oz8uoLAUVNuT0Aw7Bk4xfxK8lb4Vo+JV4XsLeZvZKyQwNhAFsnqXMbAYwFf+NHoI7+NMk7QAsE36nqXCcE7/LSrnu/TtgDrBeYubqBmAewP+64wwx8hyJRL4nwanYGddHfgNca17vcwTuFA3GdZWPp+GmnCQ4ZnvhzsTSeMmuB81snqSb8On34ZCeUmPhfP8Mj5R/Y77C3ruS6oEbJB1pZq+G5u8Am6ugQkipSEScf4E7Pa+FY/kLXv3pQGhcbCQtjhyApFXx/nCQmb0q6Sh8Sv44M7tE0vX4Ic7NR6lLanBAXt7tQuBzM3s6RBBPxB3SLHBdsm+U2u78uQt2TJH0IV61ZGPgV+a1kPcAPjCzd0ppa55wHdk7/AYn4QmvPw+PTwJ2NrMvJf0UTzDdp+V3a38SEpPf4tK1S/HZiVPwVQ+n4gOVY0tnZbpIVRQoEon88JAnq/0NGAesDzwsr5TwAB5B3ACv/JCK+qvyRU6Qr47VE6+G8Fs8avjboFs9CNjGzK4xs5Gls7aRRHRoHVyDvRmwkRormlyDR4duk1fe6IzrWi9Ng+OcmHXYFb8J9wjPX8MjosersZrGVCi9IwcNEdAKvCzaEFy3mj/fNwG3S9rGzObkI3JpsDvBXDxB9+eSdjJPvLsEjy7uQokTAgsJjtzmkk4Im8rxmatjzGyUpA3x2YqlS2VjIWGA9zguL7kH+IuZZXGpyW34jNbJeJ370yxlq+7JkxlPxuUwX+NLa4/DneepwMp4VY2nS2Zkyoh1niORyGIjaXVgFaCnmd0api6vBAYBe1pY+ETSZcA7ZnZ3CW1dAdfwzZOX6vovXld4B0Iyj5m9J1804na84sPLpbK3GCFydQhwp5k9K6+ssR3wtZldFtosl9erKgWr2iW0wn0sJInKl67eC48kTgzO6RZ4lZO0RBPzdnezsGKdpN/jDvRLZvZQ2HYUXnngtRKa20DC7vXxOs1jgVG4o7w3Xkv4qTCIXC5N0oFg94bAQcD+eIT8PlwSMwd3pDfEa8M/VipbC8nP7MgXa9kTuMzMrgoDxgpc85wDxodZizTNTKyDJ4q+b2bnhm1/wAe4B4VrYmrsTQtRthGJRBaJxE1ua3zauhaYKOkt82SjY/GI3KNyPfEyuHTjxhKZnOdo4LeSVgpTv3NwZ+1fYUr+BknDaFy4JVWOc6AbHrn9HHg2/Bmwq6RTzOxiYFxi6rvkkofQV3YATpQ0GdeSX4gvpfyQpD3NbByuaU0Nwe5f4hVL5gAf4jMsvwO2klRhZv8JEejUkDjf1+IDxG3wEmNv4bPNfwqDqidwmVUqSMiRrsMrO4zBy0aW47KqjfFB+VVm9n6pHTpJHYFa8yoq9QBm9qcQKHhBUg8zO1++0M8w81rJhHaltDtf+i9vwxg8QXBDSQOBCWZ2bRjQPiBpXXzgUvLZqzQRI8+RSGSRkdcnPRIv01WLV9j4EtcLfyFPOlnVwqpqyehdKZF0DR6pHYJP/V5ioYKGpE2AafgKZR+X+ubcEnJ9+ZV4gtdj8lrIv8A1ramaDoaGRWcewSPmPfBloAeZ2SGSrsRlEJtZ46IRqSBE5G7FF8wZD9wFvBwcpFNxR+5vZpaKRFJocIy64Euw32Bmz4fZit/gCbwP4uXHhpvZe6Wz1JEnBG4HPBJmhA7Dk+0uC1HboXjy7kVmdnMpbU0iqSde+eMG4MUg0SAMqOrktbIfwwe3e+BysOdKZnBAidwHeRJpJ3xlTMPLLU4GLjazCaHNsuZlMCMFxMhzJBJZJMINejvgAOBCM/tKvlzrMcABku4yXynr47xsIA2OM4CZHSVP7PoOqAbK5XViZ+BVCM60UFIvDY5zIsovQMGs/4bByT8lVZrZA5IeTkOUOUli8NEVeMHMXpHX+h4OnC9f5OI4SWukzXEOlAMfWki+DE7oMElv4k5TzzQ5ztDQZ+dKmg2sI+llM3tZnjR4PD6I+Vfe2UsB24W/DpLuxhMYD8JlDzlJw/GSgEdImmtm95bO1EbMbIak1/EKJjW4jQTHucw8OXA7YFtcYvVWCc0FQFJv4N+S9saTje/FZx4+A+7Ek7qvB86SdI6ZTYiOc8vEhMFIJLJIhBv0efi08C2Sljaz4Xht58EkpvdK7dDlpyglrSNpd0krmJdwOw/ojy/ichW+ZPiDlpJa1Hm7gT7hf3k4l/mybQ/iyxRfFqJ3JXf08yRszwdnJgLbBnlG1lyPXY2XSgNfdrnkJPpKfiXA2cAg+YIR+RXubsW/i5lmNqpkxiZI2L2iXOcMXi6yP7BpeD4Sr6JQkSLHGTO7CxiB27mLmd0KvCHpBUk98GTjctzpX7ZUdiZRSDjGz3EfQsKoGksqZoMDPc7MbkuD4xyYDnyBz0Dkl2bfA1/4ZH98RdIj8dmhHqUw8IdElG1EIpFWk5QyhJvF3/Ab3/5mNiEt8owk8hJMf8N1wgZ8istM/o4nUK1jKaxbGvS2xwDDcDnJjWY2O7yWj0j3T1v0EyBobn+PT10/h8tkTsBXiHsHj3AdmSLHAgD5Euy74ZUGLgX2xfW2V4Ym5+B2p0oPL19K+Z/4SnAj8ES7E/Fk3g7h/zlh0JUa5OXcTsYd5HI8L+IBvO76yvgAYH88mXQT4PBSD8gB5PW+L8ad0P3wgeBZaesXeRLXi3K8X5wJbGVmw+TVkvYA1sIrg7yWhlm3tBOd50gk0iKJi25ZsYhVmIa/BHegtwKyaYpsSeqEa/kuCUlGmwG/Akaa2R2SbgHuMLNUJavJV2q8Fa+QcD7QGV+2el54PROmtVOny5YnX14PPIzfkMfjyYDV+E17CvCwmT1cIhOLEiL49+OVVgbj/XkXfOp9k7DtZjN7qkQmNiHx28zgDtFzZvahpFdwacyfcedzDWCcmQ1PU38J5/sBfDAyUtKRwDq4xOf+IE3qhJe/vAb4taWnbOSfgf5mdmJ4fjI+WPw9XoklNcl1iX6yKT4rOAy/Zm8G7GFm4yQth1cJeTqNeRNpJDrPkUikKImL7i/wC+104H4zG1/QrgxYOeicU0Vwnp/AdYc3BUfjD8BGZvbbRLvUOBXQEJFbCV+05VJgX/Matz8BvkxD9C1Joq+sCvwEWMHMrpRn6u+By03uMLPP0+j4BzvXAHqb2ZVh21n4CpO/MbNvJXVImzZbvuT24biu/AozezxEF5/GyzLuV1IDF4A86e4JvLLNi+E6kk8g/T988NgHTzT9r4Xk4xLZ2qSvhhmKnfAciclh26t45P9AM5tZEkNbIFzDr8PzVN4Mm8/FF7Y60Ly2fer6d5qJmudIJFKU4Axtgxf+fxL4E3B0QvOXb5dNi+Oc0H+uLK/rXA1cBAyV9IvgdH4IdJXUPd8+RU7c2vLazaPwZKSb8FrIo4KM4494FDpVhL6yLfASXsrt7/KFcobjdXo7AofKy3fl8vuUyl5o0le2wCtpHAXsJa8zjJmdgy/g8rC8oklqookA8ooOR+CymC+AX0naMkQ9fwEMDIOCVJA4350kdTZfvvp+vOzf2mHG6gFcn/1quK5Mxhf5KZnjDA39eytJvw795Vl8kZZ9JA2VtB4wGjg3TY6znL7AacBhZvYGNPz2zgZeB+6Xl92rK5mhP0BitY1IJLIgfo7XRzZ8+v0a88UAUrHcc5JE9PPnuB5xNl6GaSzwCnBBiBjtgC+pPKt01jYnRN6G4olRj+E1erviVROqcN32mSnVZ/8Ez9b/VZDH3AIMl7ShmY2QdDtQnSbHIvSVzXAt9m544tTlwK8l5czsAzP7i6R/5eUyaUHSWvhKdreY2TXy1TJ3BvYLv80XcdlJKkj8NnfFo59dJJ2DR8j3AS6R9AEukznavNxlvlZ5bQrs3hwfYN2DD0z+jg8Sz8D12CsBf7WULPCTJ9g+C6/l/EXY3AEPKvTDZVQ3m1l1iUz8wRJlG5FIpBmSBuNJanvgi3IMAvYK03u/ASotRXVX84So4V/wRRZq8RvbRnj0cyqwKr7K1wcpkw3kpQxDcY32b/EqFTviNXonAPea2aNpshsaFov4E75a4+XmFROQdB3uDK2aRocfQNIheE3kXc1rZi+DHwu4zKTktZBbQtJ/8N/lz8ysOkhm9sK12acCs9Ik75EnkZ6P95N/AD/FkzHfx3+ja+Kr3L1SMiOLIM8/2Bt43syeCdeYu4DzzPMmKoGlLazqWWoSDn8fYL6ZzZd0HzDRzI4LbTbBVxA8JswARBaRGHmORCJNCFrEC3D94Ud4xYd/BMd5HfzGfEoJTSxK0Dfvj0fcppvZNElZ3IFe3cxuwCtuAKWXDeSRNATYRdK1ZvaupEvwklEnmdktkv4NZIKDlCrHGSDYdRMua1hd0vZm9qyZ/T44FhsAqaxCYL66ZA98VmKqmb0lX2L5DCCtDn9ZkDTsLel+4D55GcAvJD2Ar3qXGoco0WdXw6Ux6wMD8Nmhe4Hfm9kDuBQiNahxafvdwt8X8kVQ3pO0H76Can8zuwRIheMMDdHmnfAgwnBJdfggZbikO2hcqv2cNPWTHxox8hyJRJohzx7/FbA9nrCTXxq3C+5IP1JC8xpIRFnWwrWSg3GNcxV+U54n6QS8VNex+L0lVRc9STviU+6b4vWnO+LJazekJZq1IBLfwXLAwXiFhFfM7MnCNqWysZBCeyT9AZednGBmr8kXnymZXGBhqOlKcfcCfYEdLYUJX5LWtMaVRvvj1UxODnKeJ3GZ0k/NbFop7cyT6M898jIjSafgiYx/xSv1ZEMEuoulrDxdmL26Dg8k7IRXM1lNUlc8gl4OfGa+aFGqfpc/JKLzHIlEAF9kAV+a+tPw/Ep82dzng2MEUGaevJaai25wPq8Ddg9yjJXx0l2b4iWZ/gD8PenMlZLEzXk9YCAw2nw58F/hUdpN8UHLHZaoCJIGin3v8gomlnCgj8R1lRea2XelsLOQxDnPRxObOKDh+fF4At7mwBxLQcnFhN3L4+f428RrSQf6IXyp8FTITBJ2rwy8DTxpZgeG127GcxE+xVcTvD5tWuEQuT0SL/n3knk1kDOA9fDcgw+tcUnukl4L5bkSubwNwakfiM8EnUljpZ41LJahW2JE5zkSiSCpA+6A1gNleJLgKUCfvE4ujUhaA3gQv0EMC5rVWqAXXoppGXzxghcLnaVSIl+45QJcFlOOL5N7kZlNDzKOM4DbzOyZEppZlKBd3RFf7OS1IOdJOtDL4yvZfVVSQwsIDtGWeOLiOWFboQO9XNqi/cHuC4BKfDXMe/ODkiAjSGWVBEk743KBT/EZiXfMbB9J++MlALfGE3efKJmRRZBXGLoSj9z+A6gAbjez2yWdj9ei3t9SsBiUPN9gA3yJ7Q3xWau5wL/xeuobmVmNfGn5I4ETLYWLKv0Qic5zJPI/SiI6NACYh5cqWgqXPWTxKhWn44mCqZBpFBLkGgfi0a21cW3iZHwFwal4RvxywBGWkqQ1SZ3xm/MNZvaOpI2AX+JJgbeYWV3eKSp1VCtPoq+sjic0vojfqDsDF5vZV0kHupS2FiNE427HdbZHAFPNbJfwWmoGVYXIcwz+jkuOeuKRxOeBu9IS1S9GcOoeBa41s4eC9v0d4A0zOyq0WcnMvi6lnYUEO0/E608PwActdwLb4ef835JWTsvAMFxLjsbzOtbGa5K/Jukk4Dg8OXNlXG5yupk9VjJjf2TEOs+RyP8owRnaFS+L9ixwNbCMmR2Ml2T6Fi9plOZIxTigN17u6lNgGzwKs264Md+Ol2nqVjILE8hLXm0LrIivWkeYsv4W2CIfRUz8T4UjGvrKFsC/gLPN7DR8Kd9xwMmSVjWzXFrsTRIc/oPwMov/MrNNgd5B6kCKHecVcC38YGCSmb2PO9LbAIfI6/emEvPSZ6Pxij0E/fhxwP6SrgrbUuU4Q4Od/4f/Ho/CdeSX4kGF7SUNSovjDGBm84FncMf5DeDbIE36Jz5APwWvlnSqeTUZlc7aHxfReY5E/kcJ0+un4I7F5rgjdLCkXubVEm7BV4p7q5R25im88IeI4Qz8JneAmd2La/22wh1pzJfzPdPMJra3vYUETfmf8OVxz8XrN+8cXv4E6CapRxpvcPJyXZV4PdvfAZgvgPIw7iD9OUTBUoV8SeIj8OjbOvISjJjZ5sCKklIlGcgjX3DmOlzWMxI4TVJ3M3sbj55vgyfvppkvgFvly3CDy6kuA9aVtF3pzFowwSHN4H1ms6DbnoPPsIwrqXHF+RwfZE3Ar4UbAAQH+jfAQWb2ZFpmsX4sROc5EvkfRL46mfAbWnWIvl2Il5M6OtF0RmhfcocuH/2UVwLBfLEWmVlteLwNcC0eGX05yAgaorilQs7q+CqNH4cb8Jd4pOhceZm3O/HFCmam7QYX+soFePLUisBGki4DMLMReLmxvwenIzUEPfz5uAzpfFxmsl1IasTM1gnbU0XQvB+H61MfA27A5TEnyitAvAHsZ2ajS2hmE5LXh5DAhnkJt3uA5yVdGh4/hK/aWHLyNkvqJaki+VoYlP8Vr35zL57UWNJVDhdATUgEvBRfVGlXSadKeg+fScxCemaxfixE5zkS+R9DXuXhfqA77hBtLmmZ4Pz8i8QyrZaSpZQTzMCXxF0Lmtn1Lq5tfiQ41SVdICJ/czZnJO487yavDTseuBXYE1/A5ddpm1ZNOP1vAc+Y2XQzm41XHPilfBEUzOyjNE1lQ4NU44/A52Y2MTicd+Pa0F3CrAthe2qQlxPbBV80ZNmw+QVcg9sPl8iU4ZHQkpPor0tLqgyzQdmgHcbMTgeOx6Vh2wE98BU+R5fA3AYSGv5dgJvwpbaTr2fM7CG86s2uZvZwGn6bxWwIx1EWZtfOx6+RP8Grr6Qq+fXHREwYjET+h5C0Nh7JOt/M/isv9r81HoX+BL/R/d5SWOUhj6RzgffMV9srCzfrVE5Jypd/HgKMME8OvBCv+LCLpaSu7cKQdDe+Gtwgayzz1hf4AF+q+LNSD1QKkTQQjxwuh1dbeTds3wXYF/iTmY0toYkNFPbdcG7/iNduvt584ZwM7nyOtVBKstQkHNAd8XP9PLACcIh5smsm2S9CRP164Fgz+7A0VjcSpDGXAIebLylfCZSbr8jXMPAtqZEJEuf7F3gi4DjgLTN7ruD1DH4ctWm9Lv4YiM5zJPI/RNB8PotH5HYO2zbHFxH5CR5hfLF0FjYn6G3PAq4B3sNLMl0AbJ42qQA0uYltgg9UhuOzfPPwmtMX4BGt7dPmQCdsXxnoYaFusKQ78aSk9fMyGKWoTFrC7nVxKdIEvOziBXiU9j4zGxba9jWzqSUzNkHC7p3wRNLZeCS0CtevDgD+bWZvltDMJqhprez18eor++ILcPwc2CnMUDQZGISoeoWVaFW7ZH+VVA7shydjPohH+vfAk42vSKm2meA4/w34M67lFy7hydf7js5yOxFlG5HIj5iErm9FeZH80fhNuoMas95fN7Nbzey0tDjOyelJ8yoDz+PVKZ4C5gMz8aSp/CIdqSE4QxvjU6iHm9lBeGRuFp71/ifgQ3zAkiqC7b8CHgD+JOlBee3jA/BygF8Ex6PkWvIkCbtvwVcKvBJYEzgNX/Hwt2EQBpCaEm/B7l/iCaRP4MleeUnV/wHT8coa3VMiGxgAHCCvp57nUrye+s54qbTZkjYKTnaDI2dmc0voOJcDe0vaIAyw/orXQ14J12J3waUlZXhibCqQ1FderjDPasABuJ3LA380z/foB+mKlP/YSdVNJxKJLFnCzXkHvCrC7ZKuBtYCDgeWl3R9Ke1riWD3zpIukXQUXi/2bDySuBMeMTostE2VZCDQG18IYpvwfBzwCh7dx8wOsZRUMUkSnP4z8Qjig/gx/F3SYDM7HHgVXwExVUjKO8o74ud6Pbxe7/r4rEUF7iylysGQ1AXvIwfg5RR74Al1D4bHlwL/MLNZKbF7JVynv0OQl8zFq3/cgC+xPUrS1nhd6t6lMrKQEJn9HPhv+Ls5aJpPA7Yzs6uAN/F+n4oqJmGwdAJwRIjwgyeO3gP8BV9RdWy4vu+T15lH2ofoPEciP2LkiXXH4Bq5rfFpya3xygPHAasFLWKqkLQsPj05DneAHpbUycwewJ27DYAB4cZRchIR/qUl9TRfNW0v4HeS9g5R2jnAEEn90hYtTzAel5asizuf6+GLc9wtr+V8kJm9moYoaBGOwqPNBwG/BSbig62N8JXsPi+hbQ0UzKrMw2cosviCRIfiDl0FHomushQkY0rqL2kfM3sNl09ti8scxgMn4wsS/TRE/68A7k+LNCbBN3j95ioaZ30mA9PlK/A9AJxmXkGmpIRI8vJ4ab8avD72arhmfCqeQzEhDFSuwPMOaktk7v8kab2ARyKR74mk7riubwOgg/lysnfjSVS/MrNRwC/SkoCUR14pYX3gMjO7HC+dNxa4PzjQtWY2Ha8C0bN0ljYSIuW74BH+FyTtFBz9E4Gb5Ul3B+OJmlPSEi1POP3LyquAjAs6582Be0IfuTPfPL9fqaOgCbtXCFra0eZ1p9fDz/EHwFd4neTvLJTrKjUJjfN2kg6T9Aczm4lHcD/Ea2ZvhPejA80XG0kDQ4APJfXCV5e8AU8i3Q+PlF+ER0l3xx3QR9IwwEr0k2Vw2dSu+ODqUkl7ht/hiri2fF9LwQp88rJ5ewCV5qtInonLNH6HJ2SeDKwq6b/48uF/NLNnS2Xv/yrlpTYgEoksORI35zIzmyWvITwAOErSZWb2taQngfWDDrCmtBY7Cbu3xlc6rAUmSnrLzD6TdCyeSPVoSJpZBpdu3Fgik4EmdnfAlwk/DFgDOElSFzO7T9KBwNnAbeYVTlKzjHWwfTd8FmKipFH4+f8IODr0kV/iN+hURG6hwe4dca3w48DGkvbFnYzLgt1HAocFpzoVBLt/gTs9xwNPSOqGO6N98OoPdh87FgAAPkBJREFUOwEH5xMc04CZvSRpKTySPxq4HB9M/Q4wvG8/nG+f/120v6VNKejf+frqN+MO6aVBT7wlcLyloAIIeC6BpFuB7pIuAe7A7T0PT8q81cy2DwOZDpaCBaD+F4mR50jkR0S4WewK3CDpCnzq+mx8qvJOSX/Ap+WfMrP6NNzgoMHuzYBD8OjQrrjtuwW5QC2u0z7R/r+98w63qyy+8LtSCd0QOqhUASmCIFIFf1TpVYwgIC0iVXovUlWkBEQSmiBFOigIIr0pRKQFkN57R1oIWb8/5jvJzuUGAyTZ+9w77/Pk4Z5zd3A4nnP2zHxr1sQa6OeIzVkP1hf1WJrynwGjbA+3fQFxvLqdpIGExnIfYA9J67hBa6xLl39Pwlv4eSKReIfo6g8lnE2OdoPcHmC07dnhhMvDe4Q+eKTto4nkf2lgX8fq80agoDcwkNA49yKKlPNL9/nHxKKiVW1fU1ugFaryIoeDxpWEnGAQcBvxPl8T2KoUkK1rm/L+XpBwpliX8D9eAXjX9uWEtGc24MgmJM7l/dFa7PQhsRIc4n3xVWLIsSewo6TFHL7rmTjXRFrVJUkXogzx/JXobK1MOFQsSXwR/5pwHji7HKv2bNJxNnFzOBBYyPZDiqn4HYik7txW51Md/GProNJxXoRweLiGGPz6F6GvHSXpx0SSsZHtl0qS/YjtJ+qLfGwUA4KrEyugdyHcEh6XNF/p+DfSR1vSNyge04Rm+Ecl7u8Cd0IMkjYh7o4xSDoE6Et8Nrez/R9JmwOv2/5LXXFWkTS1x9jNrUJISd4iTn8WJRLP+4kCaxngzSZ1+DucZC1HeNjvTkhhnlA4Dw1Xsa+r+31S/d9XDAeaeL1fJgrvyYmO+bNE0fg72w/XE20CgO38k3/yTxf4AywBrAXsVnluKNHdmoKQORwE/B74at3xdhK/CHuuO4CZynOLAX8A5qo7vhLPdK3XrrzeZxEdcAgXkyHEAE+P8tzMdcfc2etc+Xl2Ql/7QOs1JmQa1wMzVq9t0h9iI9yTxFF8v/Lc94AriJXETYhxSsY0qKqv+Y6EXGqR8nix8vovV3fMJZ7JiCJwS8Jd499E9/YsImGegujsn07IHWqPuZP/hgXKP2cm7C0fAOYoz61JFLsD6o6zxDMLIXuBcLJ5unxvP0JoyvsSp4eDiYHYnnXHnH+cneckaWdaXdjSQTyb6NL2BQ61fXW55mxgSdvzSlqWOLocavvluuKu0qHr0oPorCwFDHRMlE/lGHasFUn9iE7yJbafLp3x04iBqb2IhOibRKLxju3tm9AlB1Cso17W9jnlcasz15vYZjc74UbwOPH67+NmDE/NRsR2p8spSeU9vxbxWp9NOBDsDxzsOJKvFUnTAnsQnfE/lte6Z+W/4VfE5/A+wtnkUNtX1BPtp5G0InAykXReWnnfHEskcKsQ0qpHXLN0qkXlPT03sUzpfNuDJO1BDNo9QOi1f0VD3t8tJN1IuPHcD1xl+1aFL/nVxKDxv4ii62xnx7kRZPKcJG2IpD4u1kSSViKms39HdON2Jbpe17lMYUta2PZ95efJXOMUf+Um16lsRFJPYnBqKWB54JPOrqsDhYPJ5MR2r8FEYnc8kcCd7ViJuxCAG2B51aIUTecQq6rPLM+1JBlTAqsByxLd/6tt/7Xuo+wS43ZE8rAncJvHXvfck5A+7EokRdc1KO7JiWRnBkI/flGrWPGYLXdLEQt/bPu+hsQtIi8YVSQwZwE32t62/L43cCawrcNmrxFUCqo1iW7tk0Tn/GLbO0lanxjE/Ai40vZVDXm9e3nMdsDzCAnMFravL8/9kPDP3l4xgNyY17y7k8lzkrQZRde8B3CI7fck7U50U1ax/XdJcxGDVDMSXYyrqzfF+iIfK3FelTj6fYNILJ7vcF1PYG43xOFBY68kXp4Y+noGOJFYfHIksdjiVDfUb7XoP48DTrB9enlu9M27PG7Myu0WCqeVNYAjgFsr/z+03kvVk4smJEStuKYgfJvnIobrWgn0WK95U+jQuf3Q9nMKb+G/EPMSFwHzEoXiSo5tpbUiaQAhY3i5FIFXEOu1L1e4mNxFfAf+olw/ue33G/Y+mdYxMIqk0whJ0sblu31jYmBwA2IgufZTrCTI5DlJ2pCSII8EprZ9v6T9CeurxYukYG7COu38ph3zlSPhk4jE4hKik3VgQxOKKYH3OknSliFuaG8Snef5iW75QNvP1hbw/6C89scydgLdCGlJRzoULDsTg41jJdBNZTwS6NqTtyqVeNcilrW8Rry3h5SfLyGkMbcDtziWANVKkVHtTuiaf2n7RUmnA6fY/me5ZmVi+ckQ27vXF23nKIYxf0Zo9++xfZqkPxDyr0uJQc3TmyBFSsYmk+ckaSM6JBRHE8NGuzgmxw8kfFdXcDgP9LP9QZ3xdoakI4G/EUfWJxJrZp9rWkduPHSryxEWbx8RnTlsv11TuONNJYE+riXhaCrjSKAPB25vipRnXFSkBK0E+uuEdvW8piTOCnu5EeW9PTOx1XALInFelPg++QUhA7uEWK7UJDnSt4l14T2IYehtCbnM4g6f+6UISdIqhM75xrpi7YikxYELiHhnJBLl123vJ+l8YAFgfduPNa3YSnJJSpK0FdWOm+29JB0OHCbpANuHlpvhPxXrrRslH5D0dWKD2sPEDWM2YMOSOG8G9CEG8JrCCMLz+FvAh5IuKhrhnrY/cayp7klsVZveDVijPC6qSajtGyTtAgwtBcup9UY3bkry2cvhSX68pFFE8nwAcFPN4Y2ms+SmxN6zHL+fTgybfpdwMnmpjjirSJoHOAE4QtLtxIrwt1w8jyW9TcT7f7ZPlrSo7Tfri3gMlffz1ETn+VtEEXCApK8At0q6hkis1yYsOhuRfFbeK9MBf7J9Zfnevg04WNLctjdReDk/Bs3xzU7GkEtSkqRNKLrl1s+9AGzvRySjByuGAvcDvmv7gyZ15soN7UhiUv8+YtDu10VisggxEPb8Z/wrJinlBtfqjD9FDPJsWJ7/pCTNlE7WwU1KnFvvE0nzSppbUt9WEtq6psS9HfHeaQSVuL8h6duSZgKwPVIxqIbtwcRx9vv1RfppSud2VUmnS9qoJKZUiq33CIvIY2zXnjgXFiS8ydcinFheAV6RdBKMPkV5BZinXP9OLVF2Qnk/L04U20PKP6eQdITtQ4iO+d8Jr/tpiM7zc3XFC2Pe35VE+F1gU0nfsf2Rx8x3zFeuu7uGMJPxJGUbSdJwKnrEsbSpGnty/1hgbmLS/L0mdioUg41rETe0LYnlLbMRvrG/apqubzx0q41ZMtMRxUKW04AbCceH9Wz/t2nSmI4oVinvTyyIeIawFzu2DV7vRQnt+83EwNfLwIUui0OaGHuZi/gD8VrfTWwPfItwL5mLSEp/CfzMxf2hSUham3hfb1ker0CcSNxNKVIUGzSHAtu7GVsEVwE2Ai4n9ONrEgOBxxLvmdOAbWz/q7Ygk/Eik+ckaTCVBG5F4vjxSeBe2zeV31etjr7hhrhTtJA0J9DX9kPl8QnA5bavk/TVcllP2082UdfXDrrVjihWV29PxHi7pBMJbfwqTUugFUNfI0qHdhrC0WFn2w9K+gHRMbzODfLk7UhJ0M4n1oH/RWHxtjqxSvmSJnUQi65ZwMvlNd+AsHD7gJBtXEwsRdmV6O4/4OIX3zQkzUtohvezfWV57nRCnvFrx4bMqYFett+oMVQAFKvChwA3ECdvDxHd8TmAnQhJ25m2L60tyGS8yeQ5SRpO6aicSTgNLAqMAobZPqP8vqluCX2Jo+qRRCLxc2IAb4DtneqMrTPGlbxrjB/yFIRu9WvAEQ06fgdG2/tNQXS1ehCrnx8uvxtMeGYv6wYsnIHRA5lDiZXPf6d4kwODbA9TOJ3sC3xs+6DaAv0fSJqBWGbxlu3vl+eWIDqMEE4Qtb/mRTr1IPAioRc/EJiVOAm6lDgNmhH4I/DPJhWHlSbCcoSs4VHbN0raitBl30WsZT+e6DIPrzHc0VTinh34NuGOdJak7xPr5d8mnEBeU/Hfb2ITIfk0qXlOkgZS1TcDiwBH2x5CHGlfDyxeboY0KXGu6FZnJjYdbk/E3IPQD/cABklap7Ygx0Gb6larWspPbL9DWBZ+AKyq8LrF9o7E2vOFagu0Aw5v2xsIq67lisb2fOCnkuaz/V8iKZpNUt8On4naqLzHZ5A0c9EK/x/wvsJmDNt3EV30oU1InAsiLCIfBZYjJBmrEp/RH9v+JfG+2RyYtqYYO6V8Nlcniq2RwMWStiHeH5cQcrVDCY/nRiTOMOY7hZB77UJ8F1JkMFcRxcvPFQtQPmz9nZrCTT4H2XlOkgZRupvzl87bisALxLDaNsA6tl8pSfMlRGfxkRrD7ZSSGB9AHAMPBwbb/rfCc3V2YlHHKrb/UV+Un6ZNdatVWc9KhI7yBkJeMhi4DDjLDbPQq3TzFyQSujmJzufLxEKUTYhEehDxPr+mtmA7oeht9yUs3e5zON8MAE4hllls9Jn/gppQrDv/AaFpfpfo+J8A/If4jjHw9SbJv0qxMguxIXO78vNQYgDwKsImsifQxw1ZgNJCsWTmYOBI2/dKuhn4yPbK5fcrAi+6YV78yf8mO89J0iz6EM4ZZxOJ3LTAn4hu856SZiQsjhpjvVRF0tcIacZPiKT/OWALSf1tX+tYzDFHAxPnBYjhqV/Z3p+QEowkHDYWg+js1hhip1Q6cicCTxCdrcOJ4+DtiWGkLYukozGUxHkF4jXfn0jy9wP6E+/7Awmnh82akDhL6lP5eUXgEMKi8GpgN0nH2X6NSPYnUzjINA7bzwHXAk8ThezHwPeILvQnHtv1oVaqJw2ODaSbE997vyIcQA4h3us/IxqB75drG/G9WE59fkr4Nc8AYHv58rs7yuMbMnFuTzJ5TpIG4fBR/T0xHHi7Y1PWh8Ta2Z5Ep+UsYiDm0doC7YQicxDhj/xhGUo7itAo/rxy6Zvl+kYcwxdeI5LlXwCU5P4vRDGzSUv+0DQUq9o3Id4vTwNfId4nexKrz7cE7mhi4g8sTmwLvKXISi4HziCW/Fxh+3Tbt9QbYgziAicWSc80xCDdtsQQ5kbEf8faZVjtdWKxRe3ODh3RGHvFJ4n39gNEJ3c524+4YWvZS2G4DPCnogd+GhgAvFoS5FeIZUv/aFrsAEWucxZwDbB80cFTus4jJS1ZZ3zJlyOT5yRpHg8T5v7LStq3aFn/aXtXopu7nu2Lm5R8FsnDRYSn6j3AMpJmKd2gM4gOFzBGo11nh6iNdavV2Gey/SohHxBwGLA0cC6RTO8LPFkKsCbyH6CPxvg5H0cUADu39Px1U04kLiLkR/fafru8nv8mEucTiqzndMIz+etNS+QkzSVpKo/tT/4M0e1/GPhhkZw0itLh35TQZV9TBpDvBt6SdBlxIvcbN8jNpEXldX6AkJv0AtZQbDzE9nIN/lwm40Emz0nSMGw/Zvta4ua8maSdJa0k6VpC1/dyua4px5MLAycTllH3EkM8yxLyk50Jl5BG3eBKV2ttoqN/uqSjS9d/C2BKSReW6+5sWoe/xL4mcIKkucqR9nSE5dsbhGTjX8AprSGkhnI/sR1uY0nfLfKY54ED3YBNdgqbs8GEz/TxLkOiCnebkUTyv6ykTYkNdxvYfqK2gCtUCqwFCHnDbmUorZpAP0sUBocWyUljkLQQoR8fSujh3yG65R8RsrCLCVeNG2oLshPGUajcQ+j3pyES6Gma1PhIvhg5MJgkDUTFi7cMnBxDFLqn2r645tA+hWLt9rXAf2yvWZ5bhtAlfgP4WxNucpL62B5Rfl4R+C0xPLUx8RqfaHuXIoU4Hdi/ocfvixPWhVtXteOSbiVsDGcmvJKvqifCziknES+UxEEO/+wFiUG16YF5gYNcPHvrRrHV8DRgR9tvdxwYVSx0+QawLmFd2Cgv6lIc7kQUU1MC/yA6te82cfi1SpGA7Q9s5TE+9vcSw3Wr1RpcBypDuwsQpz2PEbK696qvczmde78pmvLky5HJc5LUROVL9zuEfvJB4KlypFpNoKcAJrP9ehMmyStxzwn0sz1csfDkNCKB3qHO+Dqj6FZ3IzpW/yB02KOIQZ59gB0IB5Mbga2JxS2NOn5vUTqdy9j+WUlEe9n+uHS6vg+83qSj7BLj1BRnBNuXdUigpyBkPTM4BtoagcKH+hZgb49ZwtGDGNSdGljcsexnqpKQ1v7ZbFG65hcBu9m+XzFUuirwKnBcSewaE29HFAtQTgIOsX1reW4gYUc3zPYmdcbXkXYuVJIvRso2kqQmSgK6BnA28E3CHWFPjXF3GFlucO/Zfr31d+qLOChxr0axQZN0EuEfvDXwNUmn1BlfR7qCbrUDLwL9SoeckjgvC6zmcDRpTOJcGOCwyjsI2FfSIg5a/uTv2x7RpMQZRvtQDwY2kPSt8nQr4VwR2FwxSPrfcn3tn80OTE1sr4OwpHuV2Hy4XTmFaVq8reIEhwXnucBgSdtKGkQ4+GwOfFgKrkZQCpUdgF1tb0BYcU4D7FSRyqRMo4uRyXOSTEIkTSepf/m5B9EN+pnDbeBQwm5sZUm9mtoZKnrEHQirrhWIoaMVgMmI7st8ihXRtdPOutXP4BEiMRoIrKRYB30a8FadQXVEUs/yPnhe0iGE+8cxRMyjk58mvscrXEoUK4MUW+FGFUnSEcT683ebEH9F4zyLpAGOZTknAmtKWqYUg7cSK6EXImQyjaGiFR4lqReAY4PqIYQMaXlgL2KD5vw0L3dpu0Il+XI07Q2YJF2WclMYDOxfbnCjCF/bdQBsP0gkossypsPVKBRWXT8iVs32dbhQnAd8FVjLYYO1qu2HagyzygfEENrFMNYUfKvr+VD5/c+BPzSwa4ukWco/VZL+ZxmzWnnL8vMetm+rMcxP4XCJeYhwG5iV8ORdndDC968ztvHF4WZyAnFqcRKxuvoYYF/bf21KR7FyinUFcJ2k9QkrunuBkyQdS5ysnETICuaqLdhCJeHvONQ4spJAX2b7EMKvfABREGztGt1v2r1QSSYMmTwnySSgdJFHEr6q81A6EsR2rL6Sti6XPkt4CzcmuajcLHqW4/dTieUQ2yvcHl4D/gp8tdz0Pqov2k8xBbAoUZC0lnP0KInoNMC7to8mNh7+uSnJEIxOlqcBLpS0bimmXBLoB4ik+cfEIpErGhb7YpIuK6csVxHribclPMB/TEiV2gLbL9seTJyu7AJs2NJtN6XALbKSnxOnEYcQrjHzARcQA5n3AGsRp0PzAU/WEOZYlIR/baI46QcsRcjWpioJdHWxTw9CT7ym7ftrCHc07VioJBOeXnUHkCTdjHmJBGJPohv3G8KpYodyI5mXGFB6ub4Qx6bcLNYhFkH8F9ibWDm7A3COwhd5C2K4Z2RtgXaC7bcktXSrzxdtc2tQbUVgfUl30kzd6gDbr0o6CDhC0pMO949WjB+VeBuhh68mk7bvlvQ8keA/Qyxyedv2tgobwCZb6HVKx89kna+3YpPnOrZPUHg0bw/0L1rhRySNBLYCpiLWs98laWlik+Cm5fSiVjpohatDjTspNjaOHmp0DNwNqzXgQodCZUHiu+9colC5k9goOJSQcjSiUEkmPNl5TpJJQElAv8WYdcQrEjZXmxHJ85rEkot1PMaNoBEoBtMOIDZlTU7cIF4ljq8fJZaLHGH7KjVsDXShLXSrLdpRK9xKciStIGknSZsT+vdzCelMX+AYSUs6hhpvadJ7vA35BLhV0gzl5Oci4G1Je5aTiSuI75oNCLkDxGd1MzfLfrHxWmFJX5O0U/l5rELF9iXESdyPCMvC+2z/AZiWkCk1olBJJjxpVZckkwjFYNfettctj2cjtHHXA7s7Flw0CsVK2ZmAeW0fU54bCixJHLNOT0zAz0wk0M/UFetnIWlGws95e2Jhy1zAUU07fq8i6QwiSZoVeJno1h7e1JuxpJWJk5Q/EVrP+QhLvffLycUBwJZ1H7t3FRQ+1NcA/7a9m6RViQTuMWJAdlRJrl8pCfWoz/r3TYJ4WwXWLMRCn9cUg7rLE/MGt0n6HrFVsBfhs/58nTHD6O/pGYDnymu5CmF7eR1hRzeqSDe2JXypny8Nh962X6gv8mRikslzkkxEqjctxcKT/YFjgYdKUrEbcfy3ge2n6ot0DK2YJS1JaFOfJzqHh9q+ulxzNrCk7XkVNmkrEGusGyM36YySRI8ihh2fa1rirLApPBD4KdHRn5LoyB1AdLf+ZXuF2gKsUF7LuWzfXh4PBu52uCQg6URChrSm7RGS+jexQGxHFD7IA4hO7SnALbYPKgXMpsCDto9uQtJcpWiFDwF6l38+ASxD6LJvINbKbwDsBwy2fXNNoY5FuxUqycQnNc9JMoGRNDPwI9u/LV+qPWyPsv2wpEeJoaM7JL1BLLUY1ITEuRyTjigxrwSsX/48CewKrCDpk3LsvpliLTe2b5U0zM1eBQ00S7faoh21worB0PWA5SX1tn0T8D5jD7ruS3je9iV0/rWv3O4KKCwuNyAWFB0oaRvgzPI2OrhIp56DsVxlaqddtcKVQmU74BRJh5RCZRRRqOwBHA28Bs16zZOJRybPSTLhmZ3Qp/a1fWRJRnvb/tj2IZK2BL4OrAycZPuuWqNltK55j3JjeI/wPB4EXGL7AUnnEYncWgrXjauB+yuFQSOSunajqhUGFiYcBXYirAC/zRit8PO2r63+nZpCBkYv8LmR6OL/WNJLhGXhdZIes3058d+zMNE9b5SuvF0pWvhPgCHAVZKetn1a0ZhfUL5n9qs3yqCLDDW2ZaGSTHxStpEkE5hyxLcEkQTdb/vw8nwf2yMq1/Wz/UETkqESz1zASGBqx/T7/sDOxBripyXNTXRazrf9cJ2xdiXaSSssaRrbb5cC6hNJ8xBxP0jEOROxsOU2QhO/l8tq6+SLU5K4/sS68E8It56nCavLvW3fVz6/09v+R32RjqHdtcKVQuV1wm5xSClU5iS65dc0pVBJJj2ZPCfJBEIK94DSSewNfAfYkbET6F4udm4NSpqruuyjgcWAXWwPl3QgoUdcwfbjrYS/znjbnXbVCkvqSyTJJ9v+TUnoLgLeIY7dFwOOJJKNaYHJbT/YlPd5O6NYHvKepNWI75T+hM/w0sD1to+tNcBx0I5a4XYsVJJJT1rVJcmXRLFp6pvVBMGxZepOYqPgQpL2Kc+PrFzTiISiesOyvRcR92GSFrR9KHAW8E9J/QjtavIFqWiFd1A4C0DnWuHnCMkGNEQrbPsjYsHJnpK2J4ZJn7S9BXA5kVgfAixi+ynHxszGvM/bEQVzEH7qmxO2hScQRcpjxODd4ZK+UmOYnVK0wksQWuFFiyTsGuASQs6zR7m0aVrhfg77v12JpPkAYpDxE2KIF9uPZ+LcvcnOc5J8CYrmbTvCBm3HIncY3WmrSDj2IpwSDq0v2k/TIdZqV/xIYhPioaXTMrftx+qMtaugcF1ZHlic8G/uRxxl/9T25Qr3kuOIdecv1hboOJC0OOFN/rDtpSrPz02smr/GsQEx+YJ07NYr/MkXAb5HJHF3OjZjImmhJkh6qpTu7V6M0QrPBZwJXFe0wqsRco7GvE/KyeHXCTekS4n12l8hiti+hD57eWBW240oaJP6yOQ5Sb4kkiYnHDS+QxzrPdxJAr0k8J7tf9cX6Rgqg2pjHZW2BhvLz8cCcxMWae9lB/GL09W0wpIWAW4k/MlPqzyfsp4JhKQ1iVOK6YiFG48RevjBhETm17b3qnyWGyGPaTetcLsXKkk9ZPKcJF+QSiK0MrAhsCjwAnCQ7XurGug64+xI5Wa7InEc+SRwr8NurGMH+hu2/1NjuG1PV9UKlw70VcBhtk+oO56uhMJjfQgxsLsEsArhzHNZ6fAPBP7WJOlAO2uF27VQSeojk+ck+Zx06M4uQCQQGwLTEPZiyxA3i4ea+iWrsEY7k1hRvShhOTasMrTWiOGdroJiu+QVwMHE++OlMkA1K/BD4gY9tFXAtAslyfs78E3iGD7fM18ASbMDP7Z9VHm8FbCE7UHl8cbAUcD3bT9VLXCbQhsPNbZdoZLUTw4MJsnnoDgl7KKyIIT4DN1te5jt64ij+I+A48oRX2MS51YnvLAIcLTtIcTWw+uBxVuDR5kETVjKjfcHRFdrTtu7leefJxKMfxOd57bC9j8JDegz+Z75UkxG+GUfUh4/CkwuabZywnUBUaTMAGMPHtdNuw01Sppd0t6VpxYE7rB9o+1fE4tafivp62XO44hMnJOOZPKcJJ+PfkR3eR1J3wAeB+aQtDOA7aeBewm3hD61RVlB0hSSFm9JNUrc7wI/UdhEvU4kzwsA09cabBfG9jBijfl8pbPYev4x4HdNGp76nLwLnyrOks+B7UeBjYD/k7S/x6yl3ppYuLQ0sY30/bpi7EhVlmb7SSJh7k+4xWwLzG/7QturAUs2aMiubQuVpDmkbCNJxpOWlEGxOWtfwmJpKDArYbv0OPBXoru4VVOSodLxOZuwPFuE8G1+gPhv6EtoEqcC/ghsVm7kyUQitcJJi9bcROXx/MCpwIXAKcRn9GvALMBxtv9SS6DjoF21wgrHm1OBq20fJuks4AngDqIYPAtYtynf4UnzyOQ5ST4H5eY2ikhEDyM6zJcD/yXWyr5LfCFfWluQnVBucucA59kepLDYW5xYub08ITU5xvbFNYbZbUitcPdG0jQAxYHl+4Tv8StE0jwnkdhd0tIJa8wikUYkn9B+WuF2L1SSZpHJc5KMB+WIcgpgd0LacBzhlvBLwmHjNNvPVq9vyk0ORnvwzkF4mJ5r+4jK7yYDprH9ctPi7spImtr2O3XHkUxaJE0F7EMU3o8BxxPDuz8kCvHzy6UXAFfa3rcJn8t2HWrsCoVK0jxS85wk40HR9f2XuLm9CAwi3DUOIL6AB0masnp9LYGOA9uP2b6W0FVuJmlnSStJuhboY/vlcl2j4u7ipFa4G2L7XUJnOxfwE+AQh4/whsAA4IcOe8gfAX8uf6cJn8u20wqXQmUvIu5VgJMIqdruRKcZQle+haRWQ+FVaMxrnjSU7Dwnyf+gOGscanvdyuP1iA70b4APgQFN18e1OkFF73cMUTyfmlKNJJk0VLuZkjYBNickYDvbfrUM814IrGb7hRpD7ZR21ApL2pJw1JgR+Ivt8xULW3YFXrV9aLEcncb2HXXGmrQPmTwnyf+gdJTPAkbZ3rA8txxwMuFSsbftRkzBVwZzvkMM7DwIPGX7mfL7VgI9BTCZ7dfzeDJJJh0dEuj1CReNh4mh3gGEbGPN1mlQ3bSrVrjdC5Wk2fSqO4AkaRqVBHQuYuPb/cBWwFGSLisd6BeAh4itcY1InCGOGiWtAfwW+BthjfaapNNt310SZ9l+D3iv9XfqizhJujalyzmv7ath9Ge0j+0RwKVAT0KisRnwMnB4ExLn/6EV/imRQMv2AeX6RmmFq+4epds8gihUfijpbGAkMSj9yWf+i5KkE7LznCSdIGkd4BDgLeB5woLub8CJhMZ5amBX21fWFWMLSdMR94o3FCtyjwMus319OY5cjVhUcAzwSRNubEnSXSjF7HnAJravanVyS1K9C9G5XZ1I7E5wAzaTtvFQ41iFSnmuj+0RZbZgQ6JQmZUoVE63fVktwSZtTQ4MJkkHJA0AtgcG2l6BSJq/Bcxie2NgJ2CthiTOvQhP1f0lDXBYnvUH1gGw/SBxJLwsUSxn4pwkk4iSKF9JJMiDJa1TEuevEJKHV23/1/aFwC9tPwT1nwa18VDj/MAFkn4Ao1//ESWpPp5ogpwH3A3s5bDVy4Hd5HOTyXOSfJpRxNKQ6crj88rjLQBs315uHLVSOj0jge2AeYDtJPUhlp70lbR1ufRZYtth/3oiTZLuSUmUVyfmD+4hErv1AAFH2f5l5dpG6G5byaTtM4C7iO/BtSVNb/sJ4vRtQ0mz2H6wKUN27VqoJO1JJs9JUpA0bfHefQO4DFhB0jeLNvGKuESNWLndgXmBEcCehGTjXeBawp7pCkKjeHITdJRJ0l1QMCOxee+PtjcgZA+nAMvYvq51XY1hfoqWVrj8fD6xRfUNQis8DQ3VCrdjoZK0L6l5TrotkqYHvmv7z+VLd0+iw/xzIhndAFgSuI2Y1N7e9l/rirczJH2LWKu9EdCP6DrfTCxD+YTYYPe27f80QZOYJN2JkoSeRhS1w0uCtzdwBLBGU75P2l0rXGKcgZBl7F7mPdYlNiBuZfvPrevyOzCZEKTbRtItKV+26wOLS5oF2Jjw/fwuYUG3E3HDWxyYG9jU9m31RPuZTAY81jqClLQ5cCthHbW77TtbF+ZNI0kmLhWnnumBd21/KOkDwp1it3LZjcRJ1ns1hdkZ8wPnSaoONba0wrswZqFIY4Yaq5TX/BWi4/xaif8yhS/15ZLWsP3XpsSbtD+ZPCfdkvJl+yfChWIJ4DXb9wD3SPqI6NweZPuqGsPsFEk9ymAghBvIfyV9G3jI9nOSBgMDCUeQN2oKM0m6HeV7ZU3iBOhWSfcSyeelwBklwVuZ6IYOa0IC2tIKS2pphXvbvryiFb7ZsV31Qkm3tSQPDYi7XQuVpAuQso2k21H50u1PJJ/bAmsTVkwXlt9tQ9z0vmf7tbpibSFpZuBHtn9bHo9OoCUdRHTH7yCS5c2Ag23fVVe8SdJdqCbAkuYlVj9fTswe7ELIvo4FfkCcCD1k+/p6ou2cIlvbCJgGWBPYBLgJWLSlzW4i1UIFuJdI9i8lvgcbV6gkXYdMnpNuSblZ7EPo+N4huhVzArfYvqhcM6vt5+uLcgyKjYEHE/EdWZ7rbfvj8vOWwNeJRQZDm9gxT5KuRilq5yOSt+kJd4q/2t5aUu/yu4MIadXe9UXaOe2mFe4KhUrSNcjkOel2SFqKWLe9qe1/lud6ANsA3waus/2nDvKIWik34iUILfb9tg8vz7c2lbWu62f7g6bc7JKkKyNpA+BB4Dnb75Yidn/CI/6f5XtlYSKB3sf2wzWG2yltNNTY1oVK0rVIq7qkO7IAIdF4XNIOkoYRq2bPBoYT67hpQuJc7K5UOsx3EQtRFpK0H0AZ6qnOLnxYns/EOUkmMrYvJuQBv5e0scMb+SjgbEnfKd8h9wGbNSVxbtnQSZpe0mTlu6KlFW5xI83TCi8NvARMVnTX+wMrSlqyfD8OBw4DvlEGBZNkopGd56TbUb5Y/05s3ruCsHYbDOwI3NuExLM4gHzF9vAOR5W9ge8wJtYj64wzSbojHU92JA0ikrtLbV8qaSvgl8B6rdOtJtGuWmFJ0wEnAJfbvqDMpuxBnCLeWTr9k5cBxySZaKTbRtJlaXVYOtzketp+WNLiwEe235Q0B+Hv/FETbhKSegLrAhtL2tH2/a0bmO2PJd1J3ED2knSg7UNrDThJuhllqHglYFHgVtu/l/QOsXlvlO3TyolQv3ojDTrRCq9N6IVbWuG+5bmWVnhX28Og/lOsauy2X5d0C7CmpI9tD5U0CrhMUqtQycQ5mehk8px0SST1AxazfVsZDhxp+9qi55Ptl8p16xHHrHu6eCXXTYnxTGBa4JeS9i4JfzWBvovoHDXpWDVJugWSFgZ+C/wDmEfScsBvgFHAFqVIP6VcW2vntqUVltTSCt9AaIWvLCdZbxJa4embqBVut0Il6R6kbCPpkpTk+QjCQWN+YGvbN3dy3dzArLZvqvsmV+LpWZLnlYmtXosCLxCe0/d21k1PkmTi0/p+kDQDsBrwpmM76SqEvdtzRAL9I2Lw7p76oh1Duw81lkLlj0ShAvAY8TpvTKw7P9v2JeXa2r/Dk+5BJs9Jl0XSEsAlhL3bwEpi2sP2qNbjuuOET9nOLQBcRSTP0xAOIMsAe7thm72SpDshaQ3gEKLL+U/bPy1dzxWIRO6plhNOk2g3rXC7FipJ9yHdNpIuRWWSvDexqnX18vg3hJ8phL6ZBiXOMwK7lA4LxOfybtvDHAsK/gR8BBwnaaFMnJNk0lM+n1sRS4h+DCwnaZDtkYQU4iJi6K4RtL4LIbTCQEsrvJ7tocDRhFZ4SdujmpI4w2ipxhpEE2EvYL3yq+uJIe95iC75OZk4J3WQmueky1DpVqwCrA/cDlwNbA8MBXaQ9Aiwh6SVWrrnBtCP6C5PplgN/jgwh6SdbR9v+2nFmt85gT51Bpok3RHFqupNgW8Cr9t+RdJmwJkKu7fjgGvqjLEj7awV7lCo9CVWgw8q/w03AD2BZ+uMMenepGwj6VKUxPlYYG9ig+DjwPHAI8B+wGzAxS2NXN1UJCRfA/YFXiMS/VmJY9XHie1fhxPWUQ/UFmySdGMUy5W2BV4FjrX9oqRlgHOA5YFnm3Qq1K5a4VKo7AOsAyxXCpXvEt78vy+FSpLUSibPSZegHFFOS6yw/h2RJB8H/BmYHTje4VnauA18kuYnpvTfJEz+nyNWzv6X8Ip9F7jadmOOhJOku6DKplFJywJrAZ8AJ9p+QdI0tt+uNchCV9EKt1uhknQ/MnlO2pqOQ3+SpieO+c4hOhe9gduA64ADbL9WS6CdUBL+KQi/1emJZP8dImF+ATjN9rPV6/OGkSQTl84+Z5J6FW0zJYnbGBhBnGZ90pT5CWjfoUZor0Il6d7kwGDSlkiaGkZ7Ii+nWLM9B/A28b6ejujYTkWsbT2hSYkzhCaxDOlcDrwIDCLcNQ4g9M2DJE1Zvb6WQJOkm1Dp3K4kaQtJPwOwPbJiE3kbMRx4mu0RDUuc23aoEaBI2HqVn28lhgOnAHaV1IdcgJI0hOw8J22HpMmBk4kV2/cTur5HCenD+bYvlHQ88H2i87yH7T/XFW9nlJvcobbXrTxej+hA/wb4EBiQGuckmbRIWpVYQLQLcCVwoO1fl9+N7ow2jXbTClcLFUJm18/2ydXflZ+XA151w/ynk+5NJs9JW1FkGYsR3YhNCJ3z7rbvkzSo/O4aops7P7FZsBGbA6uUjvJZwCjbG5bnliOKgusJT+f3awwxSboVpQvaGziVsHGbmRjU3cD2c3XGNr60m1a4XQuVJEnZRtI2lOO8QcByhP/nucA3CF0ctn8PDAPWBTa0fX9TEueK//Rckr5N6CW3Al6XdFm57AXgIeDkTJyTZNJSZFQjgKcJW7r9gZ/Yfk7SppLWqjfCcaNYcoLtO4DTAAM7SpqlyEwWsf1MUxJnBX0IacmPiFzkPuC81jWZOCdNJn2ek7agHOONlHQNcQw5zPZl5Qt4c0lb2D7T9pCSZA+vNeAOlOPJdYhBnreA5wkLugOAEyUNA6YGdm1Kwp8kXZ2KdGA+4nP5GmFreSbwLdv/kbQYsahj+9oC7UDHocaWVtj2SNu3SjIx1LirpP1omFa4xD5CUqtQWYpKoQK83TSpXZJUyeQ5aTySZgcGSjrVsUp2P+BQSU86Vs2OIBLoPraH2P5dzSF/CkkDiJvvQNsPStoc+BbwgO2NJS1NLF/4T51xJkl3oqK5PYcoZkcAuxL2lmdIuodYMrKf7VtqC7TCuLTCraHG0kG/rXSjXy3d9Npp10IlSTojk+ekHdgO+AWwhKR9iKnxrwPrSnqC0Dj3AraUdBXwfFOOJyuMIpw/piuPzwOWBrYAdrF9e01xJUm3o5LITUtsDVwPeIqQhQ0FtiGcKaYGPrZ9b1OsIkvcY2mFJU1p+9fldz0c67Ybkey3aMdCJUnGRSbPSWOpeKseRCSdCxE3tUeBAcCUwFdtD5d0LXCz7VdqC7gTys15lO03irZ5BUlvlJivAFYpHfNGdIeSpDtQSUDXB+YBbiHsIk8hBu7OB3a2Paz6d+qItUplqLGlFZ6ZhmuF27lQSZJxkQODSSORNBPhc7xU8VEdQnzB/hN4GZgD+AmxWATbbzchcZY0fWuwSNLqhKfq9ZKWBK4lFrgcJ+lg4ERic2AmzkkyCZG0BCEPuIlYJrIh8BXbzxMJ3b8JJ59G0Y5DjZVC5WjCRu9DxhQqjxKFykjbw2zf2/o7dcWbJONDJs9JU5mc6AgdLmkzwoViWuBd21cAewM3A4sUj+TaKV2h9YG1JW1HbA7clbC+Opmw1zsOOIbQ+21q+6/1RJsk3RNJswHHAtfbPhfYiOiI7iZpQLGlO9z23XXG2aLi1DOfpJnKQPQjwJ7Ajh20wm/VF2nntGuhkiSfRfo8J41FUl9gReIL9hjiuHJdYJDt+yX1B/rbfqy+KMemHE1uSgwDTmX7h+X5LYkhmINsX1VbgEnSzZE0HZHMrQP82PYwSbMQvut3A/sWuVhjGIdWeGeiWL+H0AofUhoLjaEUKucTJ2yHlccnAQ8QPtSvSepr+6NaA02Sz0kmz0njKdPZOwIvETq/4cAOtl+uNbAKFV1ff6L7sy2wNjFJfmH53TbEgM/33LBV4UnSVal8Nr9JzE48DnwADARWAn5p+1+SZgVmruqc66SDVnhz4C7GaIXnJrTCs9JgrXA7FipJMj5k8py0BeVLeEEi+VwVWMD2U3XG1JGicd6HSPDfAX4KzAncYvuics2s5bgySZJJhKQfAIOBO4jNo78lBu2+D6wJ7NOUpLlKh6HG3QmJwyxEcb4YMdT4RH0Rjk27FipJ8nlJzXPSFth+3fZNttcDlm5g4rwUcAKwh+3nbb9L3KwfJBw1flgufbGuGJOku6HgK4Td5aa2NyVWbq9IOPacSgzyNo521AqXxPkHwBVEgn8FsDrx33ADcJSkxct3ZCbOSduSyXPSNmjMCtp7ymPVGtDYLEBINB6XtINiY+CpwNmEzOR+aJ6NVJJ0RVrfDcWd4k3gPWDe8twlxADyHsD7hPa2UYlcuw01QnsXKknyecnkOWkbOiaeTdL2AbcBPyOGY3oAWxNHrfMCJ9h+sMbYkqTbUJEOrCFpUCm6bwe+JmnxctlNwKtAb9sf1xbsuPmAiHmz0ql9jvh+WRLYs3jgN2LIrt0LlST5IuSSlCT5HFRvFJXnetp+uNyYP7L9pqQ5iI2CHzUsyU+SLk1JnNckup772B5VFhLtAuwkycDiwP5N8Vgfh1b4KOAZYH9JLa3w5oRWuBFDdtVChdgUOIRKoVIS5ZuAhYlCpRGvd5J8WXJgMEnGE0n9gMVs31aGA0favrb8bvSUu6T1iBvfnrYvry/iJOl+SJqMsHX7LTAMWIbohA4nup/zAY/YvqtJ7hRtPNRYLVSukvRVolAZAFQLlUvrizJJJiyZPCfJeFKS5yMIB435ga1t39zJdXMDs9q+qUk35yTpDhR/+N8RifKcwBPAEsDfbB9YZ2ydUU6zpiVmJo6yfYek9YEfEEXAncDPCf1zo5Lndi1UkuTLkslzknwOygT8JYT93MAi2fhEUo9yPNzTsU48SZKakLQIkTDfWxK3ZYEDCBvJt5owuNsxmZR0LnCN7T+Ux7sB/wesAfRqoja73QqVJJlQ5MBgkvwPKutxexPbvFYvj38DzFAumwogE+ckqQ9JPUohe6/tU0vivApwCjG4+0aTEuc2H2qkDC2eANwLHGx7R8KPeklJ/VsOSUnS1cjOc5J8BpWb3CrEsoLbgauJFblDgUfKnz2AlWy/VFuwSdKNqHw2FyTcKUbZfrJ1ClSumQ44CLjK9tV1xtuRdtcKV6xDR1WeW4Ww2NvT9pV1xZYkE5tMnpPkf1C5IexNbBB8HDieSJr3A2YDLi62TEmSTCLK4O6viHXPuwAr2n6kwzWT236/hvDGSbtphdu9UEmSCU0mz0kyDiqDPAcTur7ZgOOAPxO2TMfbHiapn+0PmnCTS5LugqRZiPmDgYTOdh9gZduvlt/3cAMkGp3Rjlrhdi1UkmRikMlzknSg49CfpOmBvkSnaB2gN7EU5TrgANuv1RJoknRTJC0EfASsDTwL7ApsZvtRSWsBdzT9c9kOQ40t2rlQSZKJQYr5k6QgaWqIoT9JyynWbM8BvE18VqYD3iWGA4cTA0iNvkEnSVdD0ncJucMUxNrqIcCyJXFekpg/6F9jiJ9Juww1tiiFypTARUTivCuwke1XJa2lWBfemHiTZFKQGwaThDhuBAZL+jtwP3Ay8CiwInC+7QslXUe4bfQG9rD9UF3xJkl3pGhufwica/vfkn4E/BU4WtIzwBaE68Mjn/GvmWR8lla4cs10xBKU3ZqmFS6Fyi+BPYlCZT5gOtsjK4XK1kA2EZJuRco2km5PkWUsRnSyNiF0zrvbvk/SoPK7a4DLieUoIzNxTpJJRyUJ3RLYBvgXcGjpfs4C7EjYut1r+7omzR+0q1a4JPxbAffZPkPSnESh8hdibfgWRKGSW1STbkd2npNujaRewCBC03wYMIpw0liLuGn8XtK2wLqE3+r5dcWaJN2NShI8E/BiSeJeIbS335N0g+0XCA3uaBqUOM9COFCsQ0geXgXerPy+h+1RTUqcK6/5EsCSQC9Jf7H9hKQViUKlJ9FgaFShkiSTikyek25L+dIfKekaYjXuMNuXSeoDbC5pC9tn2h5SkuzhtQacJN2M0m3+AbCPpFuBF4ETiWJ3HaCPpKtsv1VjmJ1SGWrsVCtMw4Ya271QSZJJSSbPSbdE0uzAQEmn2r5T0n7AoZKetH2BpBFEAt3H9hDbv6s55CTpdhQHiqOBDYjNdSsDswD7A32IBPr62gIcB+2oFW7nQiVJJjXptpF0V7YjjlNPkTQPcANwBrCupKkIjfM5wDqSZiuez0mSTCIk9SS81QcCXydmDw4Dvkls5rsY2KVpWz07DjUS1nMvEUONOwO/B45pylBji0qhshXhLPQT4AjgCkLrvBYwWW0BJkmDyOQ56VYU+QVE4vwH4ohyG6I7NICwuPqq7Q+Aa4EtbT+XR5NJMmkpXuuXEK43Awkf58uAd4hkei7bL9cWYAcqBXZLK7yYpOltP0G49oxgjFb48iYV5O1aqCRJXaTbRtJtkDQTsCHwL9t3SFoU+B6xZOFjwmljdUL7vHJ9kSZJ96KVSHZWpJZV1n8DLiUWE/0W2Mn2g5M0yHFQcQKZ2faL5bk1iET0UuAG26/XGuR4UGY9ehCd8aNtPyTpHELeeZDth2sNMEkaRGqek+7E5MA8wPqSzgAuJLR8D9r+m6R7CLu6pSQtbPu++kJNku6BpH7AYrZvK7ZuI21f2/q97Q8l/QI4ifi8Dm5K4gztpxUeV6Fie0QpVOYEVpPUG5iRKFQycU6SCtl5TroVkvoSR6hDgWOIhSfrAoNs3y+pP9Df9mP1RZkk3YeSPB9BJG3zA1vbvrny+55l6+eUQC/bbzXJHq1ohU9mzFDjYsDfiaHGDYkEetcmSB7+V6FSrlmcKFQ+IAqVi2sINUkaTSbPSbdE0nyEX+lLxEDPcGCHJmkok6S7IGkJQt98i+2BlYS5h+1RrX/WHWdHilZ4I+L7Y2aiCDiMGLp7kEig+zfle6XdC5UkaQo5MJh0S8ox5IHAzcB/gDWAfrUGlSTdiJZ8oMgD7iHmDZD0G2CGctlUAE1MnKH9hhrLIPS5RHd8mO2bSwHQWtjSKlj+25KZZOKcJJ8mk+ek22L7dds32V4PWNr2U3XHlCTdgcqQ3SrAYOL05xVge+BrwA6SNgduK4O+taNCx+dtjyg/trTCCxNa4UOaohXuCoVKkjSJlG0k3ZqOx8F5RJkkk4aSOB8L7E1srXscOB54BNiPsE672PYltQVZaGetcIdCZX3gduBqwjpvKPF6P0IsblmpCdrsJGk6mTwnSZIkk4zSBZ0WOBj4HZEkHwf8GZgdON72MEn9bH/QhIK23bXC7VSoJEk7kMlzkiRJMtFpJZiVx9MTdm7nEI4UvYHbCC/nA2w3ZnU1tOdQYzsWKknSDqTmOUmSJJloSJoaYrhO0nKSdpA0B/A2cQ+aDniX0NwOB05oSuLcrlrh1hCggzcJB5D3iCHp5Ygu9JLAVpIGlEHCHA5MkvEkk+ckSZJkoiBpcmCwpM0kfYvwQ/4/4DfAOrafITrN9wBXAafbfqimcMeiTYca27ZQSZJ2ImUbSZIkyQSnyDIWI7Z2bkLIB3a3fZ+kQeV31wCXEzrikU1JnFu0k1a4FConEwta7gf+SFjojQLOt32hpOOB7xMSmT1s/7mueJOkncn13EmSJMkERVIvYBChaT6MSOCOB9YC7rP9e0nbEts9e9s+v65YO6OiFV6DcKiYjejWPgvsTGiF92qKVrhSqFxOFCqbAQMrhcrKkkYBu9HQQiVJ2olMnpMkSZIJRkkkR0q6BjiTWMZxmaQ+wOaStrB9pu0hJckeXmvAFVpDgCURflPSYUQB0NIKt4Yat5L0VEvyUHPi3NaFSpK0I5k8J0mSJBMESbMDAyWdavtOSfsBh0p60vYFkkYQCXQf20Ns/67mkIHQCtt+p6UVBhYBrgSeB2ZijFb4azRIK9zOhUqStDOZPCdJkiQTiu2AXwBLSNoHuIFYU72upCcIjXMvYEtJVwHP1+3wUBlqbGmFTya0wisyRivcGmpsaYVrlzy0a6GSJF2BHBhMkiRJvhSSepUOaE/gRGAhYpPdo0TyPCUwxPZwSdMAfW2/UlvAhXYeaiySkl8QLiX7AK8CWwJTA78FRhKa7S2Joqb2QiVJugrZeU6SJEm+MMWmbUNJ/7J9h6QhwPeI4bqPiQ7u6sACwMq2364v2jG0q1a4VagABxFykoWAbYhCZQBRqHy1FCrXAjc3oVBJkq5EJs9JkiTJl2FyYB5gfUlnABcSGwMftP03SfcQnd2lJC1s+776Qg3aVSvcroVKknQ1MnlOkiRJvjC2n5C0J5G4DSW6oe8BB0l60fb9krYE+tt+rM5Yoe21wm1XqCRJVyQ1z0mSJMkEQdJ8wI7AS8RGvuHADrZfrjWwCu2uFZbUlzGFyjHEEOO6wKBSqPSnIYVKknRVMnlOkiRJJhiSpgMWBHYBVgUWsP1UnTFB+w41jot2KFSSpKuSyXOSJEkyUZD0Ldv3NCCOmYANgZZWeFHG1gpvQmiFh9leub5IPx9NLVSSpKvTo+4AkiRJkq6FpB4ArcS5rLuuk5ZW+HBJmwEPEbZ079q+AtgbuBlYRNLCtUX5ObH9uu2bbK8HLJ2Jc5JMGrLznCRJknR5uqpWWFIP26Mqj9UkjXaSdEWy85wkSZJ0eWx/ZPtqYGWiCz0Z8BXgQEkz2n6j3RJngGriXB5n4pwkE5nsPCdJkiTditQKJ0nyZcjkOUmSJOm2NGWoMUmS9iGT5yRJkqTbkVrhJEm+KJk8J0mSJEmSJMl4kgODSZIkSZIkSTKeZPKcJEmSJEmSJONJJs9JkiRJkiRJMp5k8pwkSZIkSZIk40kmz0mSJEmSJEkynmTynCRJkiRJkiTjSSbPSZIkSZIkSTKe/D/7jaUlmjPTswAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_matrix = cosine_similarity(pooled_embeds)\n",
    "plot_heatmap(similarity_matrix, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we import the original bert-base model again for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AVnAOPD4RzJd",
    "outputId": "9f439857-6021-4a7a-d4aa-ce9c49cbcab7"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "bert_model = BertModel.from_pretrained(\"bert-base-uncased\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "GkzJSeoaR2PQ"
   },
   "outputs": [],
   "source": [
    "pooled_embeds = encode(sentences, tokenizer, bert_model, \"cpu\")\n",
    "pooled_embeds = pooled_embeds.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 911
    },
    "id": "pfsUkigzR4cb",
    "outputId": "693a36a3-9264-4346-cde9-3ace376ce0d3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_matrix = cosine_similarity(pooled_embeds)\n",
    "plot_heatmap(similarity_matrix, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a visual inspection we can see that our finetuned model is doing a better job in encoding the texts so that the clusters are clearly visible. Specifically it's doing a better job in pushing down the scores for non similar text pairs.\n",
    "\n",
    "Let's evaluate the models on a STS dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "JJFcbhZGR56a"
   },
   "outputs": [],
   "source": [
    "sbert_model = model.bert_model\n",
    "bert_model = bert_model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 258,
     "referenced_widgets": [
      "c7ff0ed78d534454afeab1cc5d164d79",
      "081cbec465844a10bfcdc122e815a2d7",
      "55cae071fe7b466696bda7ae77b00e87",
      "67d7d3e79c4f4cfb9ccff2aa0b4e87c9",
      "2a398d9d698248879dcb226aaed1080f",
      "fccba402e5e949ec8ef5bc697e56a6c7",
      "661ff6788d7b4450b95a91c5ae7ed3fb",
      "189e408a4a794e7bb7a0f16e7935211f",
      "a1cadc7a63094864b25db4870098a72f",
      "054e94b443f544b8b854e9f88cd546b7",
      "1ae8c38b38834585bf9c3b21a1a86382",
      "7d9db3869c0c458e91089391da9fa5a3",
      "e0d201bef9df43b48c7924c1acc049da",
      "cf08599dc48840a7af73ce0b99681ade",
      "cd5b87afc2b3401fb582224ffe71cfe5",
      "f8089a030aa545e5a6581c003947f331",
      "4899c64e5bb84612a9c63b96e0246347",
      "8aacf788a2dc48098b2872a3ba7b770b",
      "c35720c224474b00b86cf785e8637305",
      "575a051a6a6a4036b92ad66779606434",
      "ab569d60a7d24a93bf9de5460c5ade11",
      "2dfe319c76e748c49ae0fb578966836d",
      "eb21fb052b534e9c83dadcc53b06e698",
      "cac2999eaca941ad9894fb9ca9a5ee1c",
      "05305061f57b4fc1b9ef4da7b13724fe",
      "7db9bee5c30944db97dccf66a3fe0be1",
      "7e825406428a4f1991103598d6fe1dbc",
      "3734950432a442e8bde18e766b987a08",
      "595f3757e5d5499a95df1bc9135679ba",
      "0359020be18b4043b2928fe08d1c416e",
      "854e401c6f6a4792b112adbbcaba65cc",
      "f66f7c93d46f48f5bfc1d4c0775d0fe6",
      "2085c1989b6e49bebfc05de79adfb697",
      "bc6161c3e9634718bd5ea1b1fd50f33f",
      "332233f23b3a414c9f43b37d06e53699",
      "9216e1eda04c4bc89f2bf80f56253c19",
      "cc9f00e3da6447d3bfc8d1dfe20957c7",
      "13bb47513c194c878ef47828e5ff6245",
      "73009eddc27d495a9b9f6f120ee9a9b4",
      "669cc824616d4560a17a43fe40a105aa",
      "8ef5311fe4754742be8c38999163e981",
      "1e844c86e01043ea9c45892aea58e346",
      "3396d46cd0274578bbb3d6a67e173c88",
      "112e6dcd74b34f8b85fad7a932ecc4e7",
      "d667341e54f64cd68470ef2dfe20d26f",
      "203d99c2f63844b894dd12fe4fd088b2",
      "67c8bf12c2f442ee93ca1b8417300fa0",
      "2051ec16e7a34aaeae6b4185e8e2e787",
      "f7a90c32a90a45109fff9a23c3511009",
      "38a5691258dd4fd0970c84270759fd4c",
      "d26fed3ead464b59bc364f6d1ec90668",
      "35aebf0b1b8b4b70b71020f73b440aee",
      "8f7ed5355d3247cdb113d4830b00135b",
      "1cd404b8059a4108aaacf5be5f6d48f2",
      "491e010be42245999621f895c63ac072",
      "acd02cf285814c6782c2dac5a90129a1",
      "85df5ac386f34fbc93794d0865493773",
      "6776b6521a764537923293bc2fa8650e",
      "c2f7226f3c534dc4a6a2a9216ccccb67",
      "aaa1c33918984c258b76cbc58993ef3d",
      "d418c8a15e2743b58b00bc8dca34cc6e",
      "23e82be4f20945f3b672427ce7863132",
      "7becbd1fc1ae4f3a82e04099e736b975",
      "869fce3c1f7b4fa2bea297a2fff4e2f4",
      "5c6d42a01c7d4076ae99c38503193100",
      "640d67ba2e9a4323a87f3fb546444561"
     ]
    },
    "id": "wG-zMln3R7_b",
    "outputId": "98caa506-f8ac-412c-a279-56a197be591d"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reusing dataset glue (/home/utsav/.cache/huggingface/datasets/glue/stsb/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1500,\n",
       " {'sentence1': 'A man with a hard hat is dancing.',\n",
       "  'sentence2': 'A man wearing a hard hat is dancing.',\n",
       "  'label': 5.0,\n",
       "  'idx': 0})"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sts = datasets.load_dataset(\"glue\", \"stsb\", split=\"validation\")\n",
    "len(sts), sts[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "hskIzKNsR9IU"
   },
   "outputs": [],
   "source": [
    "sentence1s = [data[\"sentence1\"] for data in sts]\n",
    "sentence2s = [data[\"sentence2\"] for data in sts]\n",
    "normalized_labels = [data[\"label\"] / 5 for data in sts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "rkjz8EzhR-6i"
   },
   "outputs": [],
   "source": [
    "def cos_sim_in_batches(\n",
    "    batch_size: int, s1_texts: list[str], s2_texts: list[str],\n",
    "    tokenizer: BertTokenizerFast, model: BertModel,\n",
    "    cos_sim_f: Callable[[torch.tensor, torch.tensor], torch.tensor]\n",
    ") -> torch.tensor:\n",
    "\n",
    "    cos_sims = None\n",
    "    n_batches = len(s1_texts) // batch_size + int(len(s1_texts) % batch_size != 0)\n",
    "    for i in range(n_batches):\n",
    "        s1_batch = s1_texts[i*batch_size: (i+1)*batch_size]\n",
    "        s2_batch = s2_texts[i*batch_size: (i+1)*batch_size]\n",
    "        if i == 0:\n",
    "            cos_sims = cos_sim_f(encode(s1_batch, tokenizer, model, \"cuda\").detach(),\n",
    "                                 encode(s2_batch, tokenizer, model, \"cuda\").detach())\n",
    "        else:\n",
    "            _cos_sims = cos_sim_f(encode(s1_batch, tokenizer, model, \"cuda\").detach(),\n",
    "                                  encode(s2_batch, tokenizer, model, \"cuda\").detach())\n",
    "            cos_sims = torch.cat([cos_sims, _cos_sims])\n",
    "    \n",
    "    return cos_sims"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "TIthKdWeSANc"
   },
   "outputs": [],
   "source": [
    "cos_sim_f = torch.nn.CosineSimilarity()\n",
    "sbert_cos_sims = cos_sim_in_batches(16, sentence1s, sentence2s, tokenizer, sbert_model, cos_sim_f)\n",
    "bert_cos_sims = cos_sim_in_batches(16, sentence1s, sentence2s, tokenizer, bert_model, cos_sim_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hyGchXbWSEfw",
    "outputId": "2a765a6c-c763-48ea-be49-b8e8f95b2e9e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=0.8134930507240802, pvalue=0.0)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.spearmanr(sbert_cos_sims.cpu().detach().numpy(), np.array(normalized_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BYs9Dfn-SF2y",
    "outputId": "1df3e83f-346e-4e67-ad75-c7180c358791"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=0.5931769556210932, pvalue=3.0261969816970313e-143)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.spearmanr(bert_cos_sims.cpu().detach().numpy(), np.array(normalized_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our finetuned model using MNR loss is doing even better than the model we finetuned in the previous notebook using the classification objective, with lesser training data and steps as well.\n",
    "\n",
    "| Model | Spearman rank correlation |\n",
    "| ----- | ------------------------- |\n",
    "| sbert fintuned with MNR loss | `0.81` |\n",
    "| sbert with classification objective | `0.79` |\n",
    "| bert-base |`0.59`|\n",
    "\n",
    "---\n",
    "\n",
    "## References\n",
    "\n",
    "[1]  https://github.com/UKPLab/sentence-transformers/"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "4_finetuning_sbert_with_mnr.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "0359020be18b4043b2928fe08d1c416e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "05305061f57b4fc1b9ef4da7b13724fe": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0359020be18b4043b2928fe08d1c416e",
      "max": 802872,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_854e401c6f6a4792b112adbbcaba65cc",
      "value": 802872
     }
    },
    "054e94b443f544b8b854e9f88cd546b7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "081cbec465844a10bfcdc122e815a2d7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_fccba402e5e949ec8ef5bc697e56a6c7",
      "placeholder": "​",
      "style": "IPY_MODEL_661ff6788d7b4450b95a91c5ae7ed3fb",
      "value": "Downloading builder script: "
     }
    },
    "112e6dcd74b34f8b85fad7a932ecc4e7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "13bb47513c194c878ef47828e5ff6245": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "189e408a4a794e7bb7a0f16e7935211f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1ae8c38b38834585bf9c3b21a1a86382": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "1cd404b8059a4108aaacf5be5f6d48f2": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "1e844c86e01043ea9c45892aea58e346": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "203d99c2f63844b894dd12fe4fd088b2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_38a5691258dd4fd0970c84270759fd4c",
      "placeholder": "​",
      "style": "IPY_MODEL_d26fed3ead464b59bc364f6d1ec90668",
      "value": "Generating validation split:  62%"
     }
    },
    "2051ec16e7a34aaeae6b4185e8e2e787": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_1cd404b8059a4108aaacf5be5f6d48f2",
      "placeholder": "​",
      "style": "IPY_MODEL_491e010be42245999621f895c63ac072",
      "value": " 934/1500 [00:00&lt;00:00, 9334.87 examples/s]"
     }
    },
    "2085c1989b6e49bebfc05de79adfb697": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "23e82be4f20945f3b672427ce7863132": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "2a398d9d698248879dcb226aaed1080f": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "2dfe319c76e748c49ae0fb578966836d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "332233f23b3a414c9f43b37d06e53699": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_73009eddc27d495a9b9f6f120ee9a9b4",
      "placeholder": "​",
      "style": "IPY_MODEL_669cc824616d4560a17a43fe40a105aa",
      "value": "Generating train split:  79%"
     }
    },
    "3396d46cd0274578bbb3d6a67e173c88": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "35aebf0b1b8b4b70b71020f73b440aee": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "3734950432a442e8bde18e766b987a08": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "38a5691258dd4fd0970c84270759fd4c": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "4899c64e5bb84612a9c63b96e0246347": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "491e010be42245999621f895c63ac072": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "55cae071fe7b466696bda7ae77b00e87": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_189e408a4a794e7bb7a0f16e7935211f",
      "max": 7777,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_a1cadc7a63094864b25db4870098a72f",
      "value": 7777
     }
    },
    "575a051a6a6a4036b92ad66779606434": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "595f3757e5d5499a95df1bc9135679ba": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "5c6d42a01c7d4076ae99c38503193100": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "640d67ba2e9a4323a87f3fb546444561": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "661ff6788d7b4450b95a91c5ae7ed3fb": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "669cc824616d4560a17a43fe40a105aa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "6776b6521a764537923293bc2fa8650e": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_7becbd1fc1ae4f3a82e04099e736b975",
      "max": 1379,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_869fce3c1f7b4fa2bea297a2fff4e2f4",
      "value": 1379
     }
    },
    "67c8bf12c2f442ee93ca1b8417300fa0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_35aebf0b1b8b4b70b71020f73b440aee",
      "max": 1500,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_8f7ed5355d3247cdb113d4830b00135b",
      "value": 1500
     }
    },
    "67d7d3e79c4f4cfb9ccff2aa0b4e87c9": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_054e94b443f544b8b854e9f88cd546b7",
      "placeholder": "​",
      "style": "IPY_MODEL_1ae8c38b38834585bf9c3b21a1a86382",
      "value": " 28.8k/? [00:00&lt;00:00, 697kB/s]"
     }
    },
    "73009eddc27d495a9b9f6f120ee9a9b4": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7becbd1fc1ae4f3a82e04099e736b975": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "7d9db3869c0c458e91089391da9fa5a3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_e0d201bef9df43b48c7924c1acc049da",
       "IPY_MODEL_cf08599dc48840a7af73ce0b99681ade",
       "IPY_MODEL_cd5b87afc2b3401fb582224ffe71cfe5"
      ],
      "layout": "IPY_MODEL_f8089a030aa545e5a6581c003947f331"
     }
    },
    "7db9bee5c30944db97dccf66a3fe0be1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_f66f7c93d46f48f5bfc1d4c0775d0fe6",
      "placeholder": "​",
      "style": "IPY_MODEL_2085c1989b6e49bebfc05de79adfb697",
      "value": " 803k/803k [00:00&lt;00:00, 816kB/s]"
     }
    },
    "7e825406428a4f1991103598d6fe1dbc": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "854e401c6f6a4792b112adbbcaba65cc": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "85df5ac386f34fbc93794d0865493773": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_d418c8a15e2743b58b00bc8dca34cc6e",
      "placeholder": "​",
      "style": "IPY_MODEL_23e82be4f20945f3b672427ce7863132",
      "value": "Generating test split:  57%"
     }
    },
    "869fce3c1f7b4fa2bea297a2fff4e2f4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "8aacf788a2dc48098b2872a3ba7b770b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "8ef5311fe4754742be8c38999163e981": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "8f7ed5355d3247cdb113d4830b00135b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "9216e1eda04c4bc89f2bf80f56253c19": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_8ef5311fe4754742be8c38999163e981",
      "max": 5749,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_1e844c86e01043ea9c45892aea58e346",
      "value": 5749
     }
    },
    "a1cadc7a63094864b25db4870098a72f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "aaa1c33918984c258b76cbc58993ef3d": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "ab569d60a7d24a93bf9de5460c5ade11": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "acd02cf285814c6782c2dac5a90129a1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_85df5ac386f34fbc93794d0865493773",
       "IPY_MODEL_6776b6521a764537923293bc2fa8650e",
       "IPY_MODEL_c2f7226f3c534dc4a6a2a9216ccccb67"
      ],
      "layout": "IPY_MODEL_aaa1c33918984c258b76cbc58993ef3d"
     }
    },
    "bc6161c3e9634718bd5ea1b1fd50f33f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_332233f23b3a414c9f43b37d06e53699",
       "IPY_MODEL_9216e1eda04c4bc89f2bf80f56253c19",
       "IPY_MODEL_cc9f00e3da6447d3bfc8d1dfe20957c7"
      ],
      "layout": "IPY_MODEL_13bb47513c194c878ef47828e5ff6245"
     }
    },
    "c2f7226f3c534dc4a6a2a9216ccccb67": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5c6d42a01c7d4076ae99c38503193100",
      "placeholder": "​",
      "style": "IPY_MODEL_640d67ba2e9a4323a87f3fb546444561",
      "value": " 791/1379 [00:00&lt;00:00, 7906.99 examples/s]"
     }
    },
    "c35720c224474b00b86cf785e8637305": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "c7ff0ed78d534454afeab1cc5d164d79": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_081cbec465844a10bfcdc122e815a2d7",
       "IPY_MODEL_55cae071fe7b466696bda7ae77b00e87",
       "IPY_MODEL_67d7d3e79c4f4cfb9ccff2aa0b4e87c9"
      ],
      "layout": "IPY_MODEL_2a398d9d698248879dcb226aaed1080f"
     }
    },
    "cac2999eaca941ad9894fb9ca9a5ee1c": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3734950432a442e8bde18e766b987a08",
      "placeholder": "​",
      "style": "IPY_MODEL_595f3757e5d5499a95df1bc9135679ba",
      "value": "Downloading data: 100%"
     }
    },
    "cc9f00e3da6447d3bfc8d1dfe20957c7": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_3396d46cd0274578bbb3d6a67e173c88",
      "placeholder": "​",
      "style": "IPY_MODEL_112e6dcd74b34f8b85fad7a932ecc4e7",
      "value": " 4525/5749 [00:00&lt;00:00, 16077.18 examples/s]"
     }
    },
    "cd5b87afc2b3401fb582224ffe71cfe5": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_ab569d60a7d24a93bf9de5460c5ade11",
      "placeholder": "​",
      "style": "IPY_MODEL_2dfe319c76e748c49ae0fb578966836d",
      "value": " 28.7k/? [00:00&lt;00:00, 640kB/s]"
     }
    },
    "cf08599dc48840a7af73ce0b99681ade": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_c35720c224474b00b86cf785e8637305",
      "max": 4473,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_575a051a6a6a4036b92ad66779606434",
      "value": 4473
     }
    },
    "d26fed3ead464b59bc364f6d1ec90668": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "d418c8a15e2743b58b00bc8dca34cc6e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d667341e54f64cd68470ef2dfe20d26f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_203d99c2f63844b894dd12fe4fd088b2",
       "IPY_MODEL_67c8bf12c2f442ee93ca1b8417300fa0",
       "IPY_MODEL_2051ec16e7a34aaeae6b4185e8e2e787"
      ],
      "layout": "IPY_MODEL_f7a90c32a90a45109fff9a23c3511009"
     }
    },
    "e0d201bef9df43b48c7924c1acc049da": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_4899c64e5bb84612a9c63b96e0246347",
      "placeholder": "​",
      "style": "IPY_MODEL_8aacf788a2dc48098b2872a3ba7b770b",
      "value": "Downloading metadata: "
     }
    },
    "eb21fb052b534e9c83dadcc53b06e698": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_cac2999eaca941ad9894fb9ca9a5ee1c",
       "IPY_MODEL_05305061f57b4fc1b9ef4da7b13724fe",
       "IPY_MODEL_7db9bee5c30944db97dccf66a3fe0be1"
      ],
      "layout": "IPY_MODEL_7e825406428a4f1991103598d6fe1dbc"
     }
    },
    "f66f7c93d46f48f5bfc1d4c0775d0fe6": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f7a90c32a90a45109fff9a23c3511009": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "f8089a030aa545e5a6581c003947f331": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fccba402e5e949ec8ef5bc697e56a6c7": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}