4. dl_model_run.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Learning Model\n",
    "We are aiming to predict the Lip_norm parameter based on the binary positions and full embedding of a peptide."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing data/dataset_1.pkl\n",
      "Processing segment 1 from data/dataset_1.pkl\n",
      "Processing data/dataset_2.pkl\n",
      "Processing segment 1 from data/dataset_2.pkl\n",
      "Processing data/dataset_3.pkl\n",
      "Processing segment 1 from data/dataset_3.pkl\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "import pandas as pd\n",
    "import torch\n",
    "import numpy as np\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "def load_and_process_embedding(file_path):\n",
    "    # Function to process data from file\n",
    "    with open(file_path, 'rb') as file:\n",
    "        try:\n",
    "            segment_count = 0  # Initialize segment counter\n",
    "            while True:\n",
    "                # Load each segment of data\n",
    "                data = pickle.load(file)\n",
    "                embeddings = pd.DataFrame(data['embeddings'])\n",
    "                binary_positions = pd.DataFrame(data['Padded_Binary_Positions'])\n",
    "                y_values = pd.DataFrame(data['Log2FC(LiP_norm)'])\n",
    "\n",
    "                segment_count += 1\n",
    "                print(f\"Processing segment {segment_count} from {file_path}\")\n",
    "\n",
    "                yield (embeddings, binary_positions, y_values)\n",
    "        except EOFError:\n",
    "            # End of file reached\n",
    "            pass\n",
    "\n",
    "embedding_files = [\n",
    "    'data/dataset_1.pkl',\n",
    "    'data/dataset_2.pkl',\n",
    "    'data/dataset_3.pkl',\n",
    "]\n",
    "\n",
    "embeddings_tensors = []\n",
    "binary_positions_tensors = []\n",
    "y_tensors = []\n",
    "\n",
    "# Load and process data from each file\n",
    "for file_path in embedding_files:\n",
    "    print(f\"Processing {file_path}\")\n",
    "    for embeddings_segment, binary_positions_segment, y_segment in load_and_process_embedding(file_path):\n",
    "        embeddings_tensor = torch.tensor(np.array(embeddings_segment.values.tolist(), dtype=np.float16).reshape(-1, 1000, 1280), device=device)\n",
    "        binary_positions_tensor = torch.tensor(np.array(binary_positions_segment.values.tolist(), dtype=np.float16).reshape(-1, 1000), device=device)\n",
    "        y_tensor = torch.tensor(np.array(y_segment.values.squeeze().tolist(), dtype=np.float16), device=device)\n",
    "\n",
    "        embeddings_tensors.append(embeddings_tensor)\n",
    "        binary_positions_tensors.append(binary_positions_tensor)\n",
    "        y_tensors.append(y_tensor)\n",
    "\n",
    "final_embeddings_tensor = torch.cat(embeddings_tensors, dim=0)\n",
    "final_binary_positions_tensor = torch.cat(binary_positions_tensors, dim=0)\n",
    "final_y_tensor = torch.cat(y_tensors, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4818, 1000, 1280])\n",
      "torch.Size([4818, 1000])\n",
      "torch.Size([4818])\n"
     ]
    }
   ],
   "source": [
    "print(final_embeddings_tensor.shape)\n",
    "print(final_binary_positions_tensor.shape)\n",
    "print(final_y_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4818])\n"
     ]
    }
   ],
   "source": [
    "# Normalize y values to range [0, 1]\n",
    "min_y = final_y_tensor.min()\n",
    "max_y = final_y_tensor.max()\n",
    "final_y_tensor = (final_y_tensor - min_y) / (max_y - min_y)\n",
    "\n",
    "print(final_y_tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count    4818.000000\n",
      "mean        0.569824\n",
      "std         0.032806\n",
      "min         0.000000\n",
      "25%         0.550781\n",
      "50%         0.571777\n",
      "75%         0.586914\n",
      "max         1.000000\n",
      "dtype: float64\n"
     ]
    }
   ],
   "source": [
    "y_series = pd.Series(final_y_tensor.cpu())\n",
    "\n",
    "# Get a statistical summary of the y values\n",
    "summary = y_series.describe()\n",
    "print(summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Training\n",
    "Now that we have both input and target data, we can create our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.1+cu116\n",
      "cuda\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "print(torch.__version__)\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/data/nasif12/home_if12/l_schewinski/.conda/envs/l-schewinski-tp-2/lib/python3.7/site-packages/ipykernel_launcher.py:15: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  from ipykernel import kernelapp as app\n",
      "/data/nasif12/home_if12/l_schewinski/.conda/envs/l-schewinski-tp-2/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  \n",
      "/data/nasif12/home_if12/l_schewinski/.conda/envs/l-schewinski-tp-2/lib/python3.7/site-packages/ipykernel_launcher.py:17: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  app.launch_new_instance()\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import copy\n",
    "from torch.utils.data import TensorDataset, DataLoader, random_split, Dataset\n",
    "from torch.cuda.amp import GradScaler, autocast\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "torch.manual_seed(16)\n",
    "\n",
    "# Data setup\n",
    "class PeptideDataset(Dataset):\n",
    "    def __init__(self, embeddings, position, y):\n",
    "        self.embeddings = torch.tensor(embeddings, dtype = torch.float16)\n",
    "        self.position = torch.tensor(position, dtype = torch.int64)\n",
    "        self.y = torch.tensor(y, dtype = torch.float16)\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.y)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        x = {\"embeddings\":self.embeddings[index],\n",
    "             \"position\":self.position[index]}\n",
    "        y = self.y[index]\n",
    "        return x, y\n",
    "\n",
    "dataset = PeptideDataset(final_embeddings_tensor, final_binary_positions_tensor, final_y_tensor)\n",
    "\n",
    "train_size = int(0.6 * len(dataset))\n",
    "val_size = int(0.3 * len(dataset))\n",
    "test_size = len(dataset) - train_size - val_size\n",
    "\n",
    "train_dataset, val_dataset, test_dataset = random_split(dataset, [train_size, val_size,test_size])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "batch_size = 24\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "# Model definition\n",
    "class PeptideRegressor(nn.Module):\n",
    "    def __init__(self, input_dim, num_heads, dropout_rate):\n",
    "        super(PeptideRegressor, self).__init__()\n",
    "\n",
    "        self.fc_embed = torch.nn.Linear(1280, 256)\n",
    "        \n",
    "        self.seq_pos_embed = nn.Embedding(1000, 1280)\n",
    "        self.pept_pos_embed = nn.Embedding(2, 1280)\n",
    "                \n",
    "        encoder_layer = nn.TransformerEncoderLayer(\n",
    "            d_model=256, \n",
    "            nhead=num_heads, \n",
    "            dropout=dropout_rate\n",
    "        )\n",
    "        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=1)\n",
    "        \n",
    "        self.fc = nn.Linear(256, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        positions = x[\"position\"]\n",
    "        x = x[\"embeddings\"] + self.seq_pos_embed(torch.arange(x[\"position\"].size(1), device=device)) + self.pept_pos_embed(x[\"position\"])\n",
    "        x = x.permute(1, 0, 2)\n",
    "\n",
    "        embed = self.fc_embed(x)\n",
    "        transformer_output = self.transformer_encoder(embed)\n",
    "        transformer_output = transformer_output.permute(1, 2, 0)\n",
    "        \n",
    "        mask = positions == 1\n",
    "        mask = mask.unsqueeze(1)\n",
    "        peptide_embeddings = transformer_output * mask.float()\n",
    "        pooled = torch.sum(peptide_embeddings, dim=-1)/torch.sum(positions==1,dim=-1).unsqueeze(1)\n",
    "        \n",
    "        output = self.fc(pooled)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Train Loss: 0.019921017810702324\n",
      "Epoch 2, Train Loss: 48.359283447265625\n",
      "Epoch 3, Train Loss: 11.703600883483887\n",
      "Epoch 4, Train Loss: 0.01244149636477232\n",
      "Epoch 5, Train Loss: 2.578432083129883\n",
      "Epoch 6, Train Loss: 2.084425926208496\n",
      "Epoch 7, Train Loss: 0.49873027205467224\n",
      "Epoch 8, Train Loss: 0.03744304180145264\n",
      "Epoch 9, Train Loss: 0.5422144532203674\n",
      "Epoch 10, Train Loss: 0.4961822032928467\n",
      "Epoch 11, Train Loss: 0.15326166152954102\n",
      "Epoch 12, Train Loss: 0.001246253727003932\n",
      "Epoch 13, Train Loss: 0.08747925609350204\n",
      "Epoch 14, Train Loss: 0.21774348616600037\n",
      "Epoch 15, Train Loss: 0.23933807015419006\n",
      "Epoch 16, Train Loss: 0.1605985462665558\n",
      "Epoch 17, Train Loss: 0.06513291597366333\n",
      "Epoch 18, Train Loss: 0.005894926842302084\n",
      "Epoch 19, Train Loss: 0.009587794542312622\n",
      "Epoch 20, Train Loss: 0.04663153737783432\n",
      "Epoch 21, Train Loss: 0.07890909910202026\n",
      "Epoch 22, Train Loss: 0.08800436556339264\n",
      "Epoch 23, Train Loss: 0.06884016841650009\n",
      "Epoch 24, Train Loss: 0.04004474729299545\n",
      "Epoch 25, Train Loss: 0.011833569034934044\n",
      "Epoch 26, Train Loss: 0.0015112459659576416\n",
      "Epoch 27, Train Loss: 0.007000262849032879\n",
      "Epoch 28, Train Loss: 0.020660726353526115\n",
      "Epoch 29, Train Loss: 0.032236672937870026\n",
      "Epoch 30, Train Loss: 0.0347997322678566\n",
      "Epoch 31, Train Loss: 0.029815835878252983\n",
      "Epoch 32, Train Loss: 0.01756938174366951\n",
      "Epoch 33, Train Loss: 0.00735239963978529\n",
      "Epoch 34, Train Loss: 0.0013597607612609863\n",
      "Epoch 35, Train Loss: 0.002177596092224121\n",
      "Epoch 36, Train Loss: 0.006326019763946533\n",
      "Epoch 37, Train Loss: 0.011772732250392437\n",
      "Epoch 38, Train Loss: 0.014559796079993248\n",
      "Epoch 39, Train Loss: 0.012770682573318481\n",
      "Epoch 40, Train Loss: 0.009485891088843346\n",
      "Epoch 41, Train Loss: 0.005002121441066265\n",
      "Epoch 42, Train Loss: 0.0015671055298298597\n",
      "Epoch 43, Train Loss: 0.0010706087341532111\n",
      "Epoch 44, Train Loss: 0.0019416710129007697\n",
      "Epoch 45, Train Loss: 0.004393768962472677\n",
      "Epoch 46, Train Loss: 0.00665128743276\n",
      "Epoch 47, Train Loss: 0.006000484339892864\n",
      "Epoch 48, Train Loss: 0.00493668531998992\n",
      "Epoch 49, Train Loss: 0.002822689712047577\n",
      "Epoch 50, Train Loss: 0.0020423433743417263\n",
      "Epoch 51, Train Loss: 0.0010065635433420539\n",
      "Epoch 52, Train Loss: 0.0014066597213968635\n",
      "Epoch 53, Train Loss: 0.002627938985824585\n",
      "Epoch 54, Train Loss: 0.0032363533973693848\n",
      "Epoch 55, Train Loss: 0.003588477848097682\n",
      "Epoch 56, Train Loss: 0.0021834573708474636\n",
      "Epoch 57, Train Loss: 0.0023625693283975124\n",
      "Epoch 58, Train Loss: 0.0019695661030709743\n",
      "Epoch 59, Train Loss: 0.0010594825726002455\n",
      "Epoch 60, Train Loss: 0.0011424124240875244\n",
      "Epoch 61, Train Loss: 0.0014812648296356201\n",
      "Epoch 62, Train Loss: 0.0018633803119882941\n",
      "Epoch 63, Train Loss: 0.001887460588477552\n",
      "Epoch 64, Train Loss: 0.0023693940602242947\n",
      "Epoch 65, Train Loss: 0.0019854705315083265\n",
      "Epoch 66, Train Loss: 0.0015946130733937025\n",
      "Epoch 67, Train Loss: 0.0008261303300969303\n",
      "Epoch 68, Train Loss: 0.0015738507499918342\n",
      "Epoch 69, Train Loss: 0.0015805165749043226\n",
      "Epoch 70, Train Loss: 0.0014684101333841681\n",
      "Epoch 71, Train Loss: 0.0018578668823465705\n",
      "Epoch 72, Train Loss: 0.0017551283817738295\n",
      "Epoch 73, Train Loss: 0.0011986196041107178\n",
      "Epoch 74, Train Loss: 0.0011595090618357062\n",
      "Epoch 75, Train Loss: 0.0010938446503132582\n",
      "Epoch 76, Train Loss: 0.0012830595951527357\n",
      "Epoch 77, Train Loss: 0.001270592212677002\n",
      "Epoch 78, Train Loss: 0.0012419422855600715\n",
      "Epoch 79, Train Loss: 0.0013559063663706183\n",
      "Epoch 80, Train Loss: 0.0016054412117227912\n",
      "Epoch 81, Train Loss: 0.0011246999492868781\n",
      "Epoch 82, Train Loss: 0.0010465781670063734\n",
      "Epoch 83, Train Loss: 0.0011196732521057129\n",
      "Epoch 84, Train Loss: 0.0011852383613586426\n",
      "Epoch 85, Train Loss: 0.0011433165054768324\n",
      "Epoch 86, Train Loss: 0.0007752875681035221\n",
      "Epoch 87, Train Loss: 0.0013862650375813246\n",
      "Epoch 88, Train Loss: 0.0015003582229837775\n",
      "Epoch 89, Train Loss: 0.0012374719372019172\n",
      "Epoch 90, Train Loss: 0.0017212331295013428\n",
      "Epoch 91, Train Loss: 0.0009720325469970703\n",
      "Epoch 92, Train Loss: 0.0012003680458292365\n",
      "Epoch 93, Train Loss: 0.0011823575478047132\n",
      "Epoch 94, Train Loss: 0.0010319253196939826\n",
      "Epoch 95, Train Loss: 0.0012935500126332045\n",
      "Epoch 96, Train Loss: 0.001374711631797254\n",
      "Epoch 97, Train Loss: 0.0009553730487823486\n",
      "Epoch 98, Train Loss: 0.0014573633670806885\n",
      "Epoch 99, Train Loss: 0.0013044278603047132\n",
      "Epoch 100, Train Loss: 0.001183976768516004\n",
      "Epoch 101, Train Loss: 0.001035451889038086\n",
      "Epoch 102, Train Loss: 0.001191645860671997\n",
      "Epoch 103, Train Loss: 0.0011302928905934095\n",
      "Epoch 104, Train Loss: 0.0007152458420023322\n",
      "Epoch 105, Train Loss: 0.001239905832335353\n",
      "Epoch 106, Train Loss: 0.001152336597442627\n",
      "Epoch 107, Train Loss: 0.0013666253071278334\n",
      "Epoch 108, Train Loss: 0.0009162724018096924\n",
      "Epoch 109, Train Loss: 0.0011405348777770996\n",
      "Epoch 110, Train Loss: 0.0013399124145507812\n",
      "Epoch 111, Train Loss: 0.001239091157913208\n",
      "Epoch 112, Train Loss: 0.0006631116266362369\n",
      "Epoch 113, Train Loss: 0.0011501610279083252\n",
      "Epoch 114, Train Loss: 0.0013646980514749885\n",
      "Epoch 115, Train Loss: 0.0009372433414682746\n",
      "Epoch 116, Train Loss: 0.0009852945804595947\n",
      "Epoch 117, Train Loss: 0.001147836446762085\n",
      "Epoch 118, Train Loss: 0.0010113816242665052\n",
      "Epoch 119, Train Loss: 0.00110442447476089\n",
      "Epoch 120, Train Loss: 0.0011669397354125977\n",
      "Epoch 121, Train Loss: 0.0012716453056782484\n",
      "Epoch 122, Train Loss: 0.0012500386219471693\n",
      "Epoch 123, Train Loss: 0.0008946756715886295\n",
      "Epoch 124, Train Loss: 0.001339952228590846\n",
      "Epoch 125, Train Loss: 0.0010601382236927748\n",
      "Epoch 126, Train Loss: 0.000876953243277967\n",
      "Epoch 127, Train Loss: 0.0011375745525583625\n",
      "Epoch 128, Train Loss: 0.0014485518913716078\n",
      "Epoch 129, Train Loss: 0.0010279715061187744\n",
      "Epoch 130, Train Loss: 0.0012195309391245246\n",
      "Epoch 131, Train Loss: 0.0014181634178385139\n",
      "Epoch 132, Train Loss: 0.0011471014004200697\n",
      "Epoch 133, Train Loss: 0.0014203687896952033\n",
      "Epoch 134, Train Loss: 0.0012974640121683478\n",
      "Epoch 135, Train Loss: 0.001300772069953382\n",
      "Epoch 136, Train Loss: 0.0012988448143005371\n",
      "Epoch 137, Train Loss: 0.0011463960399851203\n",
      "Epoch 138, Train Loss: 0.0011454224586486816\n",
      "Epoch 139, Train Loss: 0.000827064155600965\n",
      "Epoch 140, Train Loss: 0.0014410912990570068\n",
      "Epoch 141, Train Loss: 0.0010303657036274672\n",
      "Epoch 142, Train Loss: 0.0010911723366007209\n",
      "Epoch 143, Train Loss: 0.0010474424343556166\n",
      "Epoch 144, Train Loss: 0.0010588964214548469\n",
      "Epoch 145, Train Loss: 0.0010397633304819465\n",
      "Epoch 146, Train Loss: 0.0014022290706634521\n",
      "Epoch 147, Train Loss: 0.0013176202774047852\n",
      "Epoch 148, Train Loss: 0.0008537868852727115\n",
      "Epoch 149, Train Loss: 0.0013034045696258545\n",
      "Epoch 150, Train Loss: 0.0010506808757781982\n",
      "Epoch 151, Train Loss: 0.0009525418281555176\n",
      "Epoch 152, Train Loss: 0.0013428827514871955\n",
      "Epoch 153, Train Loss: 0.001301368116401136\n",
      "Epoch 154, Train Loss: 0.0012147327652201056\n",
      "Epoch 155, Train Loss: 0.001601318595930934\n",
      "Epoch 156, Train Loss: 0.0014000236988067627\n",
      "Epoch 157, Train Loss: 0.0014105340233072639\n",
      "Epoch 158, Train Loss: 0.0009987752418965101\n",
      "Epoch 159, Train Loss: 0.0009681284427642822\n",
      "Epoch 160, Train Loss: 0.0010987421264871955\n",
      "Epoch 161, Train Loss: 0.001053760526701808\n",
      "Epoch 162, Train Loss: 0.0011199017753824592\n",
      "Epoch 163, Train Loss: 0.0009427666664123535\n",
      "Epoch 164, Train Loss: 0.0013483564835041761\n",
      "Epoch 165, Train Loss: 0.0010745327454060316\n",
      "Epoch 166, Train Loss: 0.00156402587890625\n",
      "Epoch 167, Train Loss: 0.0012086927890777588\n",
      "Epoch 168, Train Loss: 0.0013272266369313002\n",
      "Epoch 169, Train Loss: 0.0011788209667429328\n",
      "Epoch 170, Train Loss: 0.0010830065002664924\n",
      "Epoch 171, Train Loss: 0.0009542803163640201\n",
      "Epoch 172, Train Loss: 0.0012996196746826172\n",
      "Epoch 173, Train Loss: 0.0012434422969818115\n",
      "Epoch 174, Train Loss: 0.0012603402137756348\n",
      "Epoch 175, Train Loss: 0.0012444853782653809\n",
      "Epoch 176, Train Loss: 0.0010135471820831299\n",
      "Epoch 177, Train Loss: 0.001170039176940918\n",
      "Epoch 178, Train Loss: 0.0013316969852894545\n",
      "Epoch 179, Train Loss: 0.0011830031871795654\n",
      "Epoch 180, Train Loss: 0.0011813442688435316\n",
      "Epoch 181, Train Loss: 0.000897824764251709\n",
      "Epoch 182, Train Loss: 0.0012650589924305677\n",
      "Epoch 183, Train Loss: 0.0011638503056019545\n",
      "Epoch 184, Train Loss: 0.0012836754322052002\n",
      "Epoch 185, Train Loss: 0.0013518731575459242\n",
      "Epoch 186, Train Loss: 0.0011444191914051771\n",
      "Epoch 187, Train Loss: 0.0007987916469573975\n",
      "Epoch 188, Train Loss: 0.00132606434635818\n",
      "Epoch 189, Train Loss: 0.0014180740108713508\n",
      "Epoch 190, Train Loss: 0.0010782580357044935\n",
      "Epoch 191, Train Loss: 0.0010849833488464355\n",
      "Epoch 192, Train Loss: 0.0009008944034576416\n",
      "Epoch 193, Train Loss: 0.0009591778507456183\n",
      "Epoch 194, Train Loss: 0.0013215343933552504\n",
      "Epoch 195, Train Loss: 0.001738905906677246\n",
      "Epoch 196, Train Loss: 0.0013362467288970947\n",
      "Epoch 197, Train Loss: 0.0011609693756327033\n",
      "Epoch 198, Train Loss: 0.0008304516668431461\n",
      "Epoch 199, Train Loss: 0.0011013051262125373\n",
      "Epoch 200, Train Loss: 0.001505345106124878\n",
      "[0.567, 0.567, 0.567, 0.567, 0.567, 0.567, 0.567, 0.567, 0.567, 0.567]\n",
      "[0.5693, 0.5615, 0.5586, 0.5537, 0.5664, 0.574, 0.5767, 0.5737, 0.5713, 0.5615]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Overfit to 1 batch\n",
    "# It has the objective of checking if the model can learn from the data and find problems in the model\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "model = PeptideRegressor(input_dim=1280, num_heads=4, dropout_rate=0.05)\n",
    "model = model.to(device)\n",
    "\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)\n",
    "\n",
    "scaler = GradScaler()\n",
    "\n",
    "# Training settings\n",
    "n_epochs = 200\n",
    "best_val_loss = float('inf')\n",
    "train_losses_avg = []\n",
    "val_losses_avg = []\n",
    "\n",
    "single_batch_X, single_batch_y = next(iter(train_loader))\n",
    "for k, v in single_batch_X.items():\n",
    "    single_batch_X[k] = v.to(device, non_blocking=True)\n",
    "single_batch_y = single_batch_y.to(device, non_blocking=True)\n",
    "\n",
    "predictions = []\n",
    "actuals = []\n",
    "\n",
    "# Training loop using a single batch for overfitting check\n",
    "for epoch in range(n_epochs):\n",
    "    model.train()\n",
    "    train_losses = []\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    with autocast():\n",
    "        y_pred = model(single_batch_X)\n",
    "        loss = loss_fn(y_pred, single_batch_y.unsqueeze(1))\n",
    "\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    train_losses.append(loss.item())\n",
    "\n",
    "    train_loss_avg = sum(train_losses) / len(train_losses)\n",
    "\n",
    "    mean_pred = y_pred.detach().cpu().numpy().mean()\n",
    "    mean_actual = single_batch_y.detach().cpu().numpy().mean()\n",
    "    predictions.append(mean_pred)\n",
    "    actuals.append(mean_actual)\n",
    "    print(f'Epoch {epoch+1}, Train Loss: {train_loss_avg}')\n",
    "\n",
    "predictions_plot = predictions[-10:]\n",
    "actuals_plot = actuals[-10:]\n",
    "\n",
    "print(actuals_plot)\n",
    "print(predictions_plot)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "ax.scatter(predictions_plot, actuals_plot, alpha=0.5, color='blue')\n",
    "ax.set_xlabel('Predicted Values')\n",
    "ax.set_ylabel('Actual Values')\n",
    "ax.set_title('Predicted vs Actual Values')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "editable": true,
    "scrolled": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Train Loss: 0.058715193709435544\n",
      "Epoch 1, Val MSE: 0.012682305633655338\n",
      "Epoch 2, Train Loss: 0.009579500300840529\n",
      "Epoch 2, Val MSE: 0.008840829011846761\n",
      "Epoch 3, Train Loss: 0.006749028175461206\n",
      "Epoch 3, Val MSE: 0.006318075173977213\n",
      "Epoch 4, Train Loss: 0.005310778486857976\n",
      "Epoch 4, Val MSE: 0.00512226714111376\n",
      "Epoch 5, Train Loss: 0.00452659294020754\n",
      "Epoch 5, Val MSE: 0.004447828608061202\n",
      "Epoch 6, Train Loss: 0.003972538021943447\n",
      "Epoch 6, Val MSE: 0.003913077128837343\n",
      "Epoch 7, Train Loss: 0.0036277187649499287\n",
      "Epoch 7, Val MSE: 0.003594328242842658\n",
      "Epoch 8, Train Loss: 0.0032043827260836715\n",
      "Epoch 8, Val MSE: 0.003674889426128786\n",
      "Epoch 9, Train Loss: 0.0030322778923821845\n",
      "Epoch 9, Val MSE: 0.0033610971113972243\n",
      "Epoch 10, Train Loss: 0.0027864376662206673\n",
      "Epoch 10, Val MSE: 0.003178188025752907\n",
      "Epoch 11, Train Loss: 0.002672270630690277\n",
      "Epoch 11, Val MSE: 0.0027755755171576728\n",
      "Epoch 12, Train Loss: 0.002525889671172885\n",
      "Epoch 12, Val MSE: 0.002632158823677751\n",
      "Epoch 13, Train Loss: 0.002453700402628415\n",
      "Epoch 13, Val MSE: 0.0026803519443196594\n",
      "Epoch 14, Train Loss: 0.002325624927939955\n",
      "Epoch 14, Val MSE: 0.0026842579321905238\n",
      "Epoch 15, Train Loss: 0.002169705722923583\n",
      "Epoch 15, Val MSE: 0.002379086015547519\n",
      "Epoch 16, Train Loss: 0.0021758919398007868\n",
      "Epoch 16, Val MSE: 0.0022823873937862817\n",
      "Epoch 17, Train Loss: 0.001979090888168632\n",
      "Epoch 17, Val MSE: 0.0022887050261965296\n",
      "Epoch 18, Train Loss: 0.0021150159978592566\n",
      "Epoch 18, Val MSE: 0.0031646684777816053\n",
      "Epoch 19, Train Loss: 0.0020011077266502047\n",
      "Epoch 19, Val MSE: 0.002045595296086041\n",
      "Epoch 20, Train Loss: 0.0018895676788635368\n",
      "Epoch 20, Val MSE: 0.002018400770421216\n",
      "Epoch 21, Train Loss: 0.0017662875297525514\n",
      "Epoch 21, Val MSE: 0.002226838426946922\n",
      "Epoch 22, Train Loss: 0.0017239874284637492\n",
      "Epoch 22, Val MSE: 0.002027776625702066\n",
      "Epoch 23, Train Loss: 0.0016509194137751748\n",
      "Epoch 23, Val MSE: 0.0019196502379615044\n",
      "Epoch 24, Train Loss: 0.0016433618388385011\n",
      "Epoch 24, Val MSE: 0.001818264978670622\n",
      "Epoch 25, Train Loss: 0.001607834505329047\n",
      "Epoch 25, Val MSE: 0.0018023964118777363\n",
      "Epoch 26, Train Loss: 0.001672601447082779\n",
      "Epoch 26, Val MSE: 0.0017523816853502125\n",
      "Epoch 27, Train Loss: 0.0016535533746523583\n",
      "Epoch 27, Val MSE: 0.002470401142433774\n",
      "Epoch 28, Train Loss: 0.0016219592956279612\n",
      "Epoch 28, Val MSE: 0.0017081152067565527\n",
      "Epoch 29, Train Loss: 0.0014912714457239432\n",
      "Epoch 29, Val MSE: 0.0016766331276902165\n",
      "Epoch 30, Train Loss: 0.0014983252643834615\n",
      "Epoch 30, Val MSE: 0.002340363180188493\n"
     ]
    }
   ],
   "source": [
    "# model\n",
    "\n",
    "model = PeptideRegressor(input_dim=1280, num_heads=4, dropout_rate=0.05)\n",
    "model = model.to(device)\n",
    "\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.00001, weight_decay=1e-3)\n",
    "\n",
    "scaler = GradScaler()\n",
    "\n",
    "# Training settings\n",
    "n_epochs = 30\n",
    "best_val_loss = float('inf')\n",
    "train_losses_avg = []\n",
    "val_losses_avg = []\n",
    "\n",
    "# Training loop\n",
    "for epoch in range(n_epochs):\n",
    "    model.train()\n",
    "    train_losses = []\n",
    "    for X_batch, y_batch in train_loader:\n",
    "        for k, v in X_batch.items():\n",
    "            X_batch[k] = v.to(device, non_blocking=True)\n",
    "        y_batch = y_batch.to(device, non_blocking=True)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        with autocast():\n",
    "            y_pred = model(X_batch)\n",
    "            loss = loss_fn(y_pred, y_batch.unsqueeze(1))\n",
    "\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_losses.append(loss.item())\n",
    "\n",
    "    train_losses_avg.append(sum(train_losses) / len(train_losses))\n",
    "    print(f'Epoch {epoch+1}, Train Loss: {train_losses_avg[-1]}')\n",
    "\n",
    "    model.eval()\n",
    "    val_losses = []\n",
    "    for X_batch, y_batch in val_loader:\n",
    "        for k, v in X_batch.items():\n",
    "            X_batch[k] = v.to(device, non_blocking=True)\n",
    "        y_batch = y_batch.to(device, non_blocking=True)\n",
    "\n",
    "        with torch.no_grad(), autocast():\n",
    "            y_pred = model(X_batch)\n",
    "            mse = loss_fn(y_pred, y_batch.unsqueeze(1))\n",
    "            val_losses.append(mse.item())\n",
    "\n",
    "    avg_val_loss = sum(val_losses) / len(val_losses)\n",
    "    val_losses_avg.append(avg_val_loss)\n",
    "    print(f'Epoch {epoch+1}, Val MSE: {avg_val_loss}')\n",
    "    if avg_val_loss < best_val_loss:\n",
    "        best_val_loss = avg_val_loss\n",
    "        best_model = copy.deepcopy(model.state_dict())\n",
    "\n",
    "torch.save({\n",
    "    'model_state_dict': best_model,\n",
    "}, 'best_peptide_model_2.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the training process\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(train_losses_avg[1:], label='Train Loss')\n",
    "plt.plot(val_losses_avg[1:], label='Val Loss')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.backends.backend_pdf import PdfPages\n",
    "import numpy as np\n",
    "\n",
    "# Plot configuration\n",
    "plt.style.use('seaborn-white')\n",
    "matplotlib.rcParams['text.usetex'] = True\n",
    "matplotlib.rcParams['font.family'] = 'serif'\n",
    "matplotlib.rcParams['text.latex.preamble'] = r'\\usepackage{amsmath}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "'./data/training_process.pdf'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Plot the training process\n",
    "fig = plt.figure(figsize=(8, 4))\n",
    "plt.plot(train_losses_avg[1:], label='Train Loss')\n",
    "plt.plot(val_losses_avg[1:], label='Val Loss')\n",
    "plt.legend(loc=\"lower right\", fontsize=10, frameon=True, facecolor='white')\n",
    "plt.title('Training Process')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss (MSE)')\n",
    "plt.tight_layout()\n",
    "plt.margins(y=0.2)\n",
    "\n",
    "plt.show()\n",
    "\n",
    "pdf_file_path = './data/training_process.pdf'\n",
    "with PdfPages(pdf_file_path) as pdf:\n",
    "    pdf.savefig(fig)\n",
    "plt.close()\n",
    "\n",
    "pdf_file_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Summary:\n",
      "Layer Name                                         Shape                          Parameters      Trainable      \n",
      "--------------------------------------------------------------------------------------------------------------\n",
      "fc_embed.weight                                    torch.Size([256, 1280])        327680          327680         \n",
      "fc_embed.bias                                      torch.Size([256])              256             256            \n",
      "seq_pos_embed.weight                               torch.Size([1000, 1280])       1280000         1280000        \n",
      "pept_pos_embed.weight                              torch.Size([2, 1280])          2560            2560           \n",
      "transformer_encoder.layers.0.self_attn.in_proj_weight torch.Size([768, 256])         196608          196608         \n",
      "transformer_encoder.layers.0.self_attn.in_proj_bias torch.Size([768])              768             768            \n",
      "transformer_encoder.layers.0.self_attn.out_proj.weight torch.Size([256, 256])         65536           65536          \n",
      "transformer_encoder.layers.0.self_attn.out_proj.bias torch.Size([256])              256             256            \n",
      "transformer_encoder.layers.0.linear1.weight        torch.Size([2048, 256])        524288          524288         \n",
      "transformer_encoder.layers.0.linear1.bias          torch.Size([2048])             2048            2048           \n",
      "transformer_encoder.layers.0.linear2.weight        torch.Size([256, 2048])        524288          524288         \n",
      "transformer_encoder.layers.0.linear2.bias          torch.Size([256])              256             256            \n",
      "transformer_encoder.layers.0.norm1.weight          torch.Size([256])              256             256            \n",
      "transformer_encoder.layers.0.norm1.bias            torch.Size([256])              256             256            \n",
      "transformer_encoder.layers.0.norm2.weight          torch.Size([256])              256             256            \n",
      "transformer_encoder.layers.0.norm2.bias            torch.Size([256])              256             256            \n",
      "fc.weight                                          torch.Size([1, 256])           256             256            \n",
      "fc.bias                                            torch.Size([1])                1               1              \n",
      "--------------------------------------------------------------------------------------------------------------\n",
      "Total Parameters: 2925825\n",
      "Trainable Parameters: 2925825\n"
     ]
    }
   ],
   "source": [
    "# Print the model summary\n",
    "def model_summary(model):\n",
    "    print(\"Model Summary:\")\n",
    "    print(\"{:<50} {:<30} {:<15} {:<15}\".format(\"Layer Name\", \"Shape\", \"Parameters\", \"Trainable\"))\n",
    "    print(\"-\" * 110)\n",
    "    total_params = 0\n",
    "    total_trainable_params = 0\n",
    "    lm_params = 0\n",
    "    lm_trainable_params = 0\n",
    "    lm_layers = 0\n",
    "    for name, parameter in model.named_parameters():\n",
    "        param = parameter.numel()\n",
    "        total_params += param\n",
    "        # Check if the parameter is trainable\n",
    "        trainable = parameter.requires_grad\n",
    "        trainable_param = param if trainable else 0\n",
    "        total_trainable_params += trainable_param\n",
    "        print(\"{:<50} {:<30} {:<15} {:<15}\".format(name, str(parameter.size()), param, trainable_param))\n",
    "    print(\"-\" * 110)\n",
    "    print(f\"Total Parameters: {total_params}\")\n",
    "    print(f\"Trainable Parameters: {total_trainable_params}\")\n",
    "\n",
    "model_summary(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test MSE: 0.003202041381016551\n",
      "tensor(10.9453, device='cuda:0', dtype=torch.float16) tensor(-14.3594, device='cuda:0', dtype=torch.float16)\n",
      "The MSE on the original scale is: tensor(2.0508, device='cuda:0', dtype=torch.float16)\n"
     ]
    }
   ],
   "source": [
    "# Test model\n",
    "model.load_state_dict(best_model)\n",
    "model.eval()\n",
    "test_losses = []\n",
    "y_preds = []\n",
    "y_actuals = []\n",
    "\n",
    "for X_batch, y_batch in test_loader:\n",
    "    for k, v in X_batch.items():\n",
    "        X_batch[k] = v.to(device, non_blocking=True)\n",
    "    y_batch = y_batch.to(device, non_blocking=True)\n",
    "    \n",
    "    with torch.no_grad(), autocast():\n",
    "        y_pred = model(X_batch)\n",
    "        mse = loss_fn(y_pred, y_batch.unsqueeze(1))\n",
    "        \n",
    "        y_preds.extend(y_pred.cpu().numpy())\n",
    "        y_actuals.extend(y_batch.cpu().numpy())\n",
    "        test_losses.append(mse.item())\n",
    "\n",
    "avg_test_loss = sum(test_losses) / len(test_losses)\n",
    "print(f'Test MSE: {avg_test_loss}')\n",
    "\n",
    "MSE_original = avg_test_loss * (max_y - min_y)**2\n",
    "\n",
    "print(max_y, min_y)\n",
    "print(\"The MSE on the original scale is:\", MSE_original)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0MAAAIYCAYAAACv/jdvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACrq0lEQVR4nOzde3ycZZ3//9d933PMYZKmbXqcUmih9ATIQaTgisuhwKpfQaWs6y6iIB44eGgXXaFqddW1RSji/gREV12Fyi66u0oLgq5oUxFWCm3ogbaUTk9J2iQzyZzvw++PO0mTNm3TNOmkyfv5ePCg953J5Jq5p+m85/pcn8vwPM9DRERERERkhDFLPQAREREREZFSUBgSEREREZERSWFIRERERERGJIUhEREREREZkRSGRERERERkRFIYEhERERGREUlhSERERERERiSFIRERERERGZEUhkREREREZERSGBIROU6JRILFixczY8YMLr/8ch555BEeeeQRFi9ezB133MGqVasG/GcuXryYCy64gLq6ugG/75NxHEdTV1fHI488Uuph9FBfX891113H5ZdfftTbrlq1iptuuokZM2Zwxx13UF9f3+PriUSC6667jgsuuOCoj/NYfq6IyHBneJ7nlXoQIiLDwU033UQ8HmfJkiU9zl9++eUsWLCAW265ZUB/3nXXXcfChQuZN28eAEuXLiWRSPDAAw/0+T5WrFjBggULBnQcQ9Edd9zBa6+9xrPPPtuv7x+I56k3dXV1LF68uE/jSqVSXHDBBSxfvpyrrrrqkK+vWrWKWCzWp+twLD9XRGQ408yQiMggW7BgAcuWLRv0n3PxxRdzzTXXHNP3HDzDMFxVV1eTSCRIJBL9+v7Bep6qqqr6fNtYLMb8+fNZsWJFr19PJBJ9DqTH8nNFRIYzhSERkUEWi8UA/5P9wTRv3rxeZwwOZ8WKFaxfv34QRzQ0rFq1ioULFxKPx3n88ceP+fuH0vN0ww03UFdX1+trqfN1JiIifRco9QBERIa7+vp6Zs+eTSwWY9WqVSxbtoxZs2Zxww03sHr1agAWLVoEwCOPPEI8HieRSBCPx3uEm0ceeYRYLNbrp/r19fXcc889pFKpQ0qfDp5JWLBgAXV1daxevZpEItG1xqR7GV9/x3E4nY87mUyyfPly5s2b17XOZc6cOSxZsoR4PM6KFSuIx+OkUqlef3Z/JBKJrlmVp59+uuu5PtixPE/19fUsW7aMRCLR9XwvXryYlStXsnDhwq6SulQq1fWY6urqWLBgAbNnz+73Y5k3bx6xWIwVK1b0uF4rVqzg6quv7jo+1p/b18cDh39tDMa1ExEZdJ6IiAyID3/4w94999zTdZxMJr2HH37Yu/baa71kMtl1fuXKld61117rrV+/3lu/fr33rW99y/M8z7v99tu9lStX9ri/9evXe57ned/61re8xx9/vMd9n3HGGd7q1au7zq1evdq77LLLeozp4Ycf7rr/ztt0/ozVq1d711577SGP43jHcTiHG1+nlStX9rjvHTt29Djuj2Qy2XUfO3bs8M4444yux3LwOI71eert8Xz4wx/uMeZvfetb3o4dO7qOL7vssh6vhfXr1x9yH0fzrW9964jPY39/bl8ez+FeG4Nx7URETgSVyYmIDKD169ezYsUKVqxYwcqVK5k3bx5PPvlkjxKmWCxGIpFg9uzZzJ49m0WLFpFIJHj66ad7fJI+b948VqxYQSqV4vvf/36PT+djsdghn/QfPFOTSqVYtmwZt956a9e5xx9//IjrZgZiHIczb948kslkj/U3B5d2rVq1qqsELB6PM2fOnD7d9+GsXLmya8YkHo8ze/ZsnnrqqR636c/zBL2vu6msrOxxnEgkenTa65ypOR7XXHMNiUSi63nsnIU53p97tMdzpNcGDPy1ExE5EVQmJyIygObMmdOnrmMHv3mtq6sjFov1eMPa2tra9aa2P+tB1q9fTywW6/G9R+s0Nxjj6O76669nxYoVLFmyhLq6uh6lXVdddRUrVqzgggsuYPbs2Vx99dXH3YFv9erVh6yv+fnPf96jVK4/z1Nfdd5PZ+lYMpkkmUwe133Onj27q6Sw83k8+DU3GD/3SK+Nwbh2IiIngsKQiMgQkEqliMfjPbqBdf65v/sUHWvDhkQiMSjj6O6GG27guuuuY8mSJb12P/vhD39IfX09Tz31FA8//DBAv99Up1Iprrnmmh4zGQsWLOCCCy7oWsfVebtj0dtMTKe2trYex/X19Tz00ENcfPHFzJs3j8mTJx/jo+jdggULePjhh1myZEmv4x+on9v98RzptQEDe+1ERE4UlcmJiAwBs2fP7rUsK5VKMXv27H51ojvc9x3uvjoDwkCPo7t4PE5VVRWrVq06pCyrs9yqs3TwueeeY+XKlf3+WStXrjxkAX9nWV/3Zgn9eZ4Op/vsSyqV4sMf/jCLFi1iwYIFxOPxrnDR3xbfnRYsWEAqlWLp0qWHBMqB/LndH8+RXhsDfe1ERE4UhSERkSFg3rx5zJkz55DZl7q6OuLxOAsWLOjxBj6VSlFfX3/EcBKPx5k/f35XF7Tu99n59c43t51rmAZjHAdbsGAB99xzT69v4g/u6NY5o9G9m1tfHS60XH311T3eqPfneTr4fOf4O//rvG3nbEqnznBxvPsWdW6u+vTTTx+yZqu/P/doj+dIr40jXTsRkaHM8DzPK/UgREROZolEgscff5yf//zngL8u5tZbb+11fU1dXR2PPPII69ev5/rrr+eGG27o8aZ16dKlTJkypWvW5OCW1t1v21mKtHDhQqqqqli2bBl1dXXcfPPNPdbELF26lOrq6q7v7X6fS5cuBWDKlCk91p30dxx92fSzs2HBkiVLepzvfDPd+TMTiQQLFizo0ZL84Lbhvamrq2PZsmXU19ezcOHCHqVanc9/XV0d8+bNY8GCBV2PrT/PU2eA6vyep556itdee41bbrmFBQsWdH3f3LlzAX/mZOnSpVxzzTXE4/HDXrO+WLVqFYlEotdStP7+3KM9ns77Pvi1caRrJyIylCkMiYiIiIjIiKQyORERERERGZEUhkREREREZERSGBIRERERkRFJYUhEREREREYkhSERERERERmRAqUewEA4//zzKRQKjB07ttRDERERERGREmpqaiIUCvHSSy8d9bbDYmYon89j23aphzEsFQqFUg9BThBd65FD13pk0fUeOXStRw5d6yOzbZt8Pt+n2w6LmaHa2loAnnvuuRKPZHhxHIe1a9dyzjnnYFlWqYcjg0jXeuTQtR5ZdL1HDl3rkUPX+uguu+yyPt92WMwMiYiIiIiIHCuFIRERERERGZEUhkREREREZERSGBIRERERkRFJYUhEREREREYkhSERERERERmRFIZERERERGREUhgSEREREZERSWFIRERERERGJIUhEREREREZkRSGRERERERkRFIYEhERERGREUlhSERERERERiSFIRERERERGZEUhkREREREZERSGBIRERERkRFJYUhEREREREYkhSERERERETl+nlfqERwzhSEREREREem/P/wBzjsP4nFIJks9mmOiMCQiIiIiIsduzx740Ifgr/4K/vIXf2boJJsdUhgSEREREZG+Kxbh3nvhjDPgpz8Fw4Bbb4VXX4Xq6lKP7pgESj0AERERERE5Sfz2t3DbbbBhg3984YXw4INw/vmlHVc/aWZIRERERESObOdOWLAALrvMD0JjxsCjj0Jd3UkbhEBhSEREREREDiefh29+E2bMgJ//HEzTnxnavBk+8hH/+CSmMjkRERERETnU00/DHXf4wQfg4ov9krhzzinpsAbSyR3lRERERERkYL35Jlx3HVx1lR+Exo2DH//Yb6E9jIIQKAyJiIiIiAhALgdf/SrMnAm/+AVYFnzmM7BpE/z93/td44YZlcmJiIiIiIx0v/413HknbN3qH7/jHX5J3Jw5pR3XINPMkIiIiIjISLV1K7z73fCud/l/njgRHnsMfve7YR+EQGFIRERERGTkyWRg8WKYPRt+9SsIBOAf/xE2boQbbhiWJXG9UZmciIiIiMhI4XnwX/8Fn/603ygB4PLL4TvfgTPPLOnQSkFhSERERERkJNi82W+V/fTT/nE8Dvfd53eOGyEzQQdTmZyIiIiIyHCWTsMXvuCvAXr6aQiF4ItfhA0b4H3vG7FBCDQzJCIiIiIyPHke/Md/wGc/Czt3+ueuvhqWL4fTTy/t2IYIhSERERERkeFmwwa4/XZ47jn/eOpUPwS9+90jeiboYCqTExEREREZLtraYNEiOOssPwhFIvDlL8Nrr8F73qMgdBDNDImIiIiInOw8z98faOFC2LPHP/ee98D998Opp5Z0aENZScJQIpFg1apVxONxEokECxYsIBaLHfa2jz/+OFOmTGHHjh3ceuuth72tiIiIiMiIs24d3HYbPP+8fzx9ul8Sd801pR3XSaAkYejOO+/kySefBPywc/fdd/PAAw/0etubbrqJJ598klgsRn19PcuWLWPJkiUncrgiIiIiIkNPayt86Uvw3e+C40A0Cnff7TdMiERKPbqTwglfM5RIJHocx+Nx1qxZ0+tt6+rqALpmguLxOCtWrBjcAYqIiIiIDGWui/HjH8OMGfDAA34Qet/7YONG+Kd/UhA6Bic8DNXV1VFVVdXjXFVVFfX19YfcNpVK9TjuDEUHByoRERERkRHh5ZeZcfPNmB/5CDQ2+oHomWf8FtpTppR6dCedE14md3DA6ZRMJg85N3v27B7nOwNTIpEgHo8fcnvHcQZolAIHnk89r8OfrvXIoWs9suh6jxy61iNAczPGl76E+dBDVLguXnk53j334N1xh7+Jqq59vwyZbnK9haR4PM7HPvYxVqxYwdVXX901I3TwzBJAoVBg7dq1gz3MEWndunWlHoKcILrWI4eu9cii6z1y6FoPQ67L6P/+byY9+CDB1lYAmufPZ+edd1KsrfVbZksP+XyecDjcp9ue8DAUi8UOmQVKJpOH7RB3yy23kEgkSCQSzJs3D6DXWaFQKMQ555wz4OMdyRzHYd26dcydOxfLsko9HBlEutYjh671yKLrPXLoWg9TL76IefvtGC+9BIA3ezb2fffxRk2NrvUR9DUIQQnC0Lx583ptgjBnzpxeb9+9JK6+vp7Zs2cfNjjpBTE4LMvScztC6FqPHLrWI4uu98ihaz1M7NvnN0L4/vf9/YMqK+ErX8G47TZM04S1a3WtB8gJb6Bw8KxOIpFgzpw5XQGnvr6+R4OE6667rquEbsWKFSxcuPDEDVZERERE5ERxHPj//j844wx45BE/CP3938PmzfCZz0AwWOoRDjslWTO0fPlyli5dyty5c1m3bh3Lly/v+tpDDz3E3LlzueWWWwBYuHAhdXV1JBIJrrrqqq5SORERERGRYWPNGvjUp+Dll/3js8+GBx+ESy4p7biGuZKEoXg8zqJFiwC46qqrenzt4M1XFyxYcMLGJSIiIiJyQjU0wF13wY9+5B9XV8PXvga33gqBIdPrbNjSMywiIiIicqLZNvzrv8LixdDZXOwjH4FvfANqa0s7thFEYUhERERE5ER6/nm47TbobIV+3nnw3e/ChReWdlwj0AlvoCAiIiIiMiLt3g0f+hC84x1+EKqpge99D154QUGoRBSGREREREQGU7EI994LM2bAT38KhuGvCdq82f+/WmSXjMrkREREREQGy29/65fEbdjgH194oV8Sd955pR2XAJoZEhEREREZeIkELFgAl13mB6ExY+DRR6GuTkFoCFEYEhEREREZKPk8fPObcOaZ8POfg2n6M0ObN/vd4ky9/R5KVCYnIiIiIjIQnn4a7rjDDz7gb5j64IP+BqoyJCmaioiIiIgcj+3b4dpr4aqr/CA0bhz8+Md+C20FoSFNYUhEREREpD9yOfjqV2HmTPjlL/2ucJ/5jB+I/v7v/a5xMqSpTE5ERERE5Fj96ldw552wbZt/fOmlfknc7NklHZYcG80MiYiIiIj01dat8O53+/9t2wYTJ8Jjj/kttBWETjoKQyIiIiIiR5PJwOLFfuD51a8gEIB//EfYtAluuEElcScplcmJiIiIiByO5/nrgT7zGXjzTf/c5ZfDd77jt8+Wk5rCkIiIiIhIbzZv9ltlP/20fxyPw333wXXXaSZomFCZnIiIiIhId+k0fOELMGeOH4RCIfjiF2HDBnjf+xSEhhHNDImIiIiIgF8S98QT8LnPwc6d/rmrr4bly+H000s7NhkUCkMiIiIiIq+9Brff7neFAzj1VLj/fr9rnGaChi2VyYmIiIjIyNXWBgsXwtln+0EoEoEvfxnq6+E971EQGuY0MyQiIiIiI4/nwc9+BosWwZ49/rn/9//8BgmnnlrasckJozAkIiIiIiPLunVw223w/PP+8fTp8MAD/vogGVFUJiciIiIiI0NrK9x5J7zlLX4Qikbhn/8Z1q9XEBqhNDMkIiIiIsOb68KPfwx33QWNjf65978f7r0Xpkwp7dikpBSGRERERGT4+stf/JK4NWv84xkz4DvfgSuuKO24ZEhQmZyIiIiIDD/NzfDJT8L55/tBqLwcvvUtePVVBSHpopkhERERERk+XBcefRS+8AXYv98/97d/C0uXwqRJpR2bDDkKQyIiIiIyPLz4InzqU/7/AWbPhgcfhEsvLemwZOhSmZyIiIiInNz27YNbboELL/SDUCzm7xf08ssKQnJEmhkSERERkZOT48DDD8MXvwgtLf65v/97f23Q+PGlHZucFBSGREREROTks2aNXxL38sv+8dln+yVxl1xS2nHJSUVlciIiIiJy8mhogA9/GObN84NQdbUfgl56SUFIjplmhkRERERk6LNt+O53YfFiSKX8cx/9KHz961BbW9qxyUlLYUhEREREhrbnn/c3Tl23zj8+7zw/GF14YWnHJSc9lcmJiIiIyNC0ezf83d/BO97hB6GaGnjoIXjhBQUhGRAKQyIiIiIytBSLcO+9MGMG/OxnYBjw8Y/D5s3wsY+BZZV6hDJMqExORERERIaO556D22+HDRv84wsv9EvizjuvtOOSYUkzQyIiIiJSeokEXH89XH65H4TGjoUf/ADq6hSEZNAoDImIiIhI6eTz8M1vwplnwhNPgGn6zRI2bYKbbvKPRQaJyuREREREpDSeftoviXv9df/4kkv8PYPOPru045IRQ1FbRERERE6s7dvh2mvhqqv8IDR+PPzkJ34LbQUhOYEUhkRERETkxMjlYMkSmDkTfvlLvyvcZz/rl8R96EN+1ziRE0hlciIiIiIy+H71K7jzTti2zT++9FK/JG727JIOS0Y2zQyJiIiIyODZuhXe/W7/v23bYNIkePxx+O1vFYSk5BSGRERERGTgZTKweLEfeH71KwgG4R//ETZuhAULVBInQ4LK5ERERERk4Hievx7oM5+BN9/0z11xBTzwgN8+W2QIURgSERERkYGxebPfKvuZZ/zjKVPgvvv8znGaCZIhSGVyIiIiInJ82tvhC1+AOXP8IBQKwRe/CBs2wHXXKQjJkKWZIRERERHpH8+DJ56Az30Odu70z11zDSxfDtOnl3ZsIn2gMCQiIiIix+611/ySuN/+1j8+9VQ/BL3rXZoJkpOGyuREREREpO9SKX8m6Oyz/SAUicCXvwz19X77bAUhOYloZkhEREREjs7z4Gc/g0WLYM8e/9z/+39+g4RTTy3t2ET6SWFIRERERI7s1VfhttvgD3/wj6dP91tlX311acclcpxUJiciIiIivWtthTvvhHPP9YNQNAr//M+wfr2CkAwLmhkSERERkZ5cF378Y7jrLmhs9M+9//1w773+3kEiw4TCkIiIiIgc8Je/+CVxa9b4x2ee6ZfEXXFFacclMghUJiciIiIi0NwMn/wknH++H4TKy+Fb34JXXlEQkmFLM0MiIiIiI5nrwqOPwhe+APv3++f+9m9h6VKYNKm0YxMZZApDIiIiIiPVn//sl8S9+KJ/PHs2PPggXHppSYclcqKoTE5ERERkpNm3D265Bd72Nj8IxWL+fkEvv6wgJCOKZoZERERERgrHgYcegrvvhpYW/9w//AP8y7/A+PGlHZtICSgMiYiIiIwEdXXwqU/B2rX+8dlnw3e/CxdfXNJhiZSSyuREREREhrOGBvjwh/3Qs3YtVFf764JeeklBSEY8zQyJiIiIDEe27c/8LF4MqZR/7qMfhW98A8aOLe3YRIaIkoShRCLBqlWriMfjJBIJFixYQCwWO+xt6+rqqKqqIpFIcNVVVxGPx0/wiEVEREROIs8/75fErV/vH593nh+MLrywtOMSGWJKEobuvPNOnnzyScAPO3fffTcPPPBAr7ddtWoVt9xyS9fx4sWLWbJkyQkZp4iIiMhJZfdu+Pzn4Wc/849ravyZoI9+FCyrtGMTGYJO+JqhRCLR4zgej7NmzZrD3n7lypWDPSQRERGRk1uxyLif/ARz1iw/CBkGfPzjsHkzfOxjCkIih3HCZ4Y6S966q6qqor6+ntmzZx9y+6qqKq677jqWL19OIpFg3rx5h71vx3EGfLwjWefzqed1+NO1Hjl0rUcWXe8R4rnnMO+8k8kbNwLgvfWtuN/5jl8aB347bRk29Pd6YJ3wMJTqXMB3kGQy2ev55cuX8+EPf5jLL7+cBQsWHLZErlAosLazVaQMqHXr1pV6CHKC6FqPHLrWI4uu9/AU3LuXyfffT82zzwJQHDWKXbffzv53vQtM80ALbRmW9Pf68PL5POFwuE+3HTLd5A4XklauXMnHPvYxkskkixcvBug1EIVCIc4555zBHOKI4zgO69atY+7cuViaXh/WdK1HDl3rkUXXe5jK5zHuuw/j61/HyGTwTBP34x+n/gMfYNa8ecR1rYc1/b0+ur4GIShBGIrFYofMAiWTyV67ySUSCXbs2MGiRYsAmDdvHtdddx233HJLrx3l9IIYHJZl6bkdIXStRw5d65FF13sYWbUK7rgDXn/dP77kEowHH4Q5c3DWrtW1HkF0rQfGCW+gcLg1P3PmzDnkXH19PXPnzu06jsfjfOxjHzvsLJKIiIjIsLR9O1x7LVx9tR+Exo+Hn/zEb6F99tmlHp3ISeuEh6GDZ3QSiQRz5szpmhmqr6/v6jg3e/bsQ+ohW1tbe220ICIiIjLs5HKwZAnMnAm//KXfFe6zn4VNm+BDH/K7xolIv5VkzdDy5ctZunQpc+fOZd26dSxfvrzraw899BBz587tKoW7+OKLeeSRR4jH4ySTSW644YZSDFlERETkxPqf/4FPfxq2bfOP3/lO+M53QB8KiwyYkoSheDzetQ7oqquu6vG1gzdfnTdv3hHbaYuIiIgMK1u3wp13wq9/7R9PmgT33gvXX6+ZIJEBdsLL5ERERESkF5kMLF7sz/z8+tcQDMJdd8HGjbBggYKQyCAYMq21RUREREYkz/PXA33mM/Dmm/65K67wS+JmzCjp0ESGO4UhERERkVLZtMlvlf3MM/7xlClw331+5zjNBIkMOpXJiYiIiJxo7e3w+c/D3Ll+EAqF4O67YcMGuO46BSGRE0QzQyIiIiIniufBE0/A5z4HO3f65665BpYvh+nTSzs2kRFIYUhERETkRHjtNbj9dvjtb/3jU0/1Q9C73qWZIJESUZmciIiIyGBKpfyZoLPP9oNQJAJf+QrU18O7360gJFJCmhkSERERGQyeBz/9KSxaBHv3+ufe+1749rf9WSERKTmFIREREZGB9uqrcNtt8Ic/+MfTp/utsg/abF5ESktlciIiIiIDpbUV7rwTzj3XD0JlZfD1r8P69QpCIkOQZoZEREREjpfrwo9/DHfdBY2N/rn3vx/uvdffO0hEhiSFIREREZHj8Ze/+CVxa9b4x2ee6ZfEXX55acclIkelMjkRERGR/mhuhk98As4/3w9CFRWwdCm88oqCkMhJQjNDIiIiIsfCceAHP4AvfAH27/fP/e3f+kFo0qTSjk1EjonCkIiIiEhf/fnP8KlPwUsv+cdz5sCDD8I73lHacYlIv6hMTkRERORomprgllvgbW/zg1AsBvff768XUhASOWlpZkhERETkcBwHHnoI7r4bWlr8czfeCN/8JowfX9qxichxUxgSERER6U1dnV8St3atf3zOOX5J3MUXl3JUIjKAVCYnIiIi0l1DA3z4w37oWbsWqqvhu9/1y+MUhESGFc0MiYiIiADYth96Fi+GVMo/99GPwje+AWPHlnZsIjIoFIZEREREfv97f+PU9ev94/PP94PRW99a2nGJyKBSmZyIiIiMXLt3wwc/CJde6gehmhq/YcKf/qQgJDICKAyJiIjIyFMowLJlMGMGPPYYGAZ8/OOweTN87GNgWaUeoYicACqTExERkZHluef8kriNG/3jt73NL4k799zSjktETjjNDImIiMjIkEjA9dfD5Zf7QWjsWPjBD2D1agUhkRFKYUhERESGt3ze7wh35pnwxBNgmnD77X5J3E03+cciMiKpTE5ERESGr1Wr4I474PXX/eNLLvFL4s46q7TjEpEhQR+FiIiIyPCzfTtcey1cfbUfhMaPh5/8BJ5/XkFIRLooDImIiMjwkcvBkiUwcyb88pd+V7jPfhY2bYIPfcjvGici0kFlciIiIjI8/M//wKc/Ddu2+cfvfCd85zswe3ZJhyUiQ5dmhkREROTktmULvOtd8J73+EFo0iR4/HG/hbaCkIgcgcKQiIiInJwyGbjnHj/w/PrXEAzCXXf5bbMXLFBJnIgclcrkRERE5OTiefCLX8BnPgM7dvjnrrwSHngAZswo7dhE5KSiMCQiIiInj02b/FbZzzzjH0+ZAvfd53eO00yQiBwjlcmJiIjI0NfeDp//PMyd6wehUAjuvhs2bIDrrlMQEpF+0cyQiIiIDF2eBz//OXzuc7Brl3/ub/4G7r8fpk8v6dBE5OSnMCQiIiJDU3093H47/O53/vGpp8Ly5fDud5d2XCIybKhMTkRERIaWVMqfCTrnHD8IRSLwla/44UhBSEQGkGaGREREZGjwPPjpT2HRIti71z/33vfCt7/tzwqJiAwwhSEREREpvVdegdtugz/+0T8+/XS/VfZVV5V2XCIyrKlMTkREREqntdVvlX3uuX4QKiuDr38d1q1TEBKRQaeZIRERETnxXBd+9CO46y5oavLPfeADsGyZv3eQiMgJoDAkIiIiJ9Zf/gKf+hT86U/+8Zlnwne+A5dfXtpxiciIozI5EREROTGam+ETn4Dzz/eDUEUFLF3qrxdSEBKREtDMkIiIiAwux4FHH4V/+ifYv98/98EPwre+BZMmlXZsIjKiKQyJiIjI4Pnzn/2SuJde8o/nzIEHH4R3vKO04xIRQWVyIiIiMhiamuDmm+HCC/0gFIvB/ff764UUhERkiNDMkIiIiAwcx4HvfQ/uvttvmw1w443wzW/C+PElHZqIyMEUhkRERGRgrF7tb5y6dq1/fM45fkncxReXclQiIoelMjkRERE5Pg0N/uzPJZf4Qai6Gr77Xb88TkFIRIYwzQyJiIhI/9i2H3oWL4ZUCgwDPvpR+PrXYezYUo9OROSoFIZERETk2P3+935J3Pr1/vH55/vB6K1vLe24RESOgcrkREREpO927/b3CLr0Uj8IjR4NDz/sb6KqICQiJxmFIRERETm6QgGWLoUZM+Cxx/ySuE98AjZtgltuAcsq9QhFRI6ZyuRERETkyJ59Fm6/HTZu9I/f9ja/JO7cc0s7LhGR46SZIREREeldIgEf+ABccYUfhMaOhR/+0G+hrSAkIsOAwpCIiIj0lM/DN74BZ54J//EfYJpwxx2weTN8+MP+sYjIMKAyORERETlg1So/+Lz+un/89rf7G6eedVZpxyUiMgj6FYaWLVvGKaecwlVXXcWdd95JLBbjmmuu4corrxzo8YmIiMiJsH07fPrT8F//5R+PHw/Llvmd4wyjlCMTERk0/Zrnnjt3Lh/4wAdYsWIFs2fP5v7776e1tXWAhyYiIiKDLpuFJUtg5kw/CFkWfPazfpe4v/s7BSERGdb6FYZisRgAK1eu5JprrgGgqqpq4EYlIiIig+9//gdmz4YvfQlyOXjnO+GVV+Dee6Hj33oRkeGsX2Vy9fX1ACQSCWbOnEkikSCVSg3owERERGSQbNnil8T9+tf+8aRJ8O1v+53jNBMkIiNIv2aGFixYwGuvvcaTTz5JW1sbK1asOKYwlEgkeOSRR1i1ahWPPPLIEb931apVpFIphS0REZHjlcnA3Xf7s0G//jUEg/D5z/tts6+/XkFIREacfs0MVVZW4nkey5Yt4/777+fiiy9m7ty5ff7+O++8kyeffBLwg9Hdd9/NAw88cNjbHmzhwoXccsst/Rm6iIjIyON58OST8JnPwI4d/rkrr4QHHoAZM0o7NhGREurXzNCyZcuIxWLMmTMHgIsuuoi6uro+fW8ikehxHI/HWbNmTa+3TaVSLF++nE2bNnX9pyAkIiLSd+Ht2zGvvhre9z4/CE2Z4gejVasUhERkxOt3N7nrr7+e2bNnH/P31tXVHdJsoaqqqmsd0sGuuuqqrj+vWrWqx7GIiIgcRns7xhe+wKwbbsB49lkIhfwSuQ0b4NprVRInIkI/y+R27tx5yLl169b1aZ+hw639SSaTh5yLdetkk0qlSCaTxOPxw9634zhH/fnSd53Pp57X4U/XeuTQtR4BPA/jiScwFi3C3LULAPfqq/Huuw+mT/dvo+s/7Ojv9sihaz2w+hWGZs2axXXXXceoUaOoq6ujrq6OhQsXHtdAjtYg4aGHHuLWW2897NcLhQJr1649rjFI79atW1fqIcgJoms9cuhaD0+RrVuJL11K7KWXAMhPmkRi4UKSb387tLeD/p0c9vR3e+TQtT68fD5POBzu0237FYYuuugili9fzooVK/A8j69+9avMmjWrT98bi8UOmQVKJpM9ZoEOlkqlWLNmDYsWLTrsbUKhEOecc06fxiB94zgO69atY+7cuViWVerhyCDStR45dK2HqVQKY8kSjAcfxLBtvEgE7667MD77WZKvv67rPQLo7/bIoWt9dH0NQtDPMAR+44Pus0E7d+5k8uTJR/2+efPmsWLFikPOdzZj6M369ev7NCa9IAaHZVl6bkcIXeuRQ9d6mPA8+OlPYdEi2LvXP/fe92Lcdx/G1KlYHWU0ut4jh671yKFrPTD6FYYO7v7WudfQo48+etTvPXjNTyKRYM6cOV0zQ/X19cRisR63q6+vP6TpgoiIyIj2yitw223wxz/6x6ef7rfKVqMhEZE+61cYWrx4MbNnz8bzPMAPR/Pmzevz9y9fvpylS5cyd+5c1q1bx/Lly7u+9tBDDzF37txD2mcfqXGCiIjIiNHaCosXw3e/C64LZWV+l7jPfhaOoTRERET6GYYWLlzI/Pnze5w73F5BvYnH413rfw5uld3b5qvaV0hEREY814Uf/QjuuguamvxzH/gA3Hsv6ANDEZF+6VcYOjgIiYiIyCD6v//zS+L+9Cf/eOZM+M534LLLSjsuEZGTXL/C0MFrg1pbW0mlUlx00UUDMigREREBmpvhi1+Ehx7ymyVUVMCXvgR33OFvoioiIsfF7M83Pf7447S0tOB5Hp7nHdJZTkRERI6D48DDD8MZZ8D3vucHoQ9+EDZtgoULFYRERAZIv2aGlixZolkgERGRwfDCC35JXMfGqcyZAw8+CO94R2nHJSIyDPVrZqi3ILRhw4bjHoyIyMmuUHD41au7+P4ftvGrV3dRKDilHpKcLJqa4Oab4W1v84NQLAb33w8vv6wgJCIySPo0M/TEE08c8evJZJKVK1fyn//5nwMyKBGRk9FP1mzn+394g6a2HI7nYRkGSys3c/PbT+XvL5pa6uHJUOU4finc3Xf7bbMBbrwR/uVfYNy4kg5NRGS461MYeuyxx7jmmmuOeJvOPYdEREain6zZztKnN5G3HcpCAcIBg7ztsTeVZenTmwAUiORQq1f7JXFr1/rH55zj7x90DHv3iYhI//UpDC1atOioa4SOZdNVEZHhpFBw+P4f3iBvO9SUBTFNvwK5LASRgEFzpsijf3yDBefFCYWsEo9WhoS9e/39gn78Y/+4uhr++Z/h1lvB0mtERORE6dOaoaMFoTVr1rBz584BGZCIyMnmmY17aWrLURYKdAWhTqZpUhYK0JjK8czGvSUaoQwZtu2vA5oxww9ChuGvE9q8GT75SQUhEZETrF/d5ACeeeYZEokE4JfIrV+/niuvvHLABiYicrLYm8zjeB7hgNHr18MBg0zBY28yf4JHJkPK73/vl8StX+8fn3++XxL31reWdlwiIiNYv8LQsmXLSKVSJJNJ4vE4qVSKBQsWDPTYREROCuOrwliGv0aorJftX/K230xhfFX4xA9OSm/3bn9voMce849Hj4ZvfAM++lEw+9XUVUREBki/wtCUKVO4/vrrSSQSGIbB5MmTWbNmzUCPTUTkpHDlmeNZWrmZvakskYDRo1TOdV0yBZsJVVGuPHN8CUcpJ1yhAMuXw5Il0N7ul8R9/OPwta9BTU2pRyciIvRzn6F4PM6uXbuIx+M8/fTTAz0mEZGTSihkcfPbTyUcsGjOFMkUHBzXJVNwaM4UiQQsPnrJqWqeMJI8+yycfTb84z/6Qahz76B//VcFIRGRIaRfM0OpVIrLL7+cF198kZaWFj760Y9SWVl51EYLIiLDVWfb7M59hjIFvzRuQlWUj16ifYZGjB074HOfg//4D/947Fj41rfgH/5BJXEiIkNQn8LQl770Jb7yla90Hc+fP58NGzYAsHDhQtasWcOcOXMGZ4QiIieJv79oKgvOi/PMxr3sTeYZXxXmyjPHa0ZoJMjn4d57/fbYmYwffG67Db7yFb9ttoiIDEl9CkMrV65kypQpzJ8/n8mTJx/ydc0IiYj4QiGLd501qdTDkBNp1Sq44w54/XX/+O1vhwcfhLPOKu24RETkqPo0Z/+xj32Mj370oyQSCb7//e/zxBNP0N7ePthjExERGbreeAPe+164+mo/CI0fD//+734LbQUhEZGTQp9mhm6++WbAnwHqnAX6+c9/TiqVYsqUKdpfSERERo5s1l8H9M1vQi4HgQDceScsXgyxWKlHJyIix6Dfqzmvv/56br75ZlpbW7nwwgu59957B3JcIiIiQ4vnwX//N8yeDV/+sh+E3vlOeOUVWLZMQUhE5CTUr25yO3fuZMWKFfz85z8nmUwyf/58rr766oEem4jIgHJdj12tWdIFm/JQgEnVUUzTKPWw5GSwZYs/+/PUU/7xpEnw7W/DBz7g7x8kIiInpT6FoUcffZQFCxawYsUKVqxYQSKR4KKLLmLJkiXMnz9/sMcoInLctjS28fT6BrY2tZOzHSIBi2ljK5g/ZxzTaytLPTwZqjIZ+PrXYelSfxPVYNBvnf3FL0JFRalHJyIix6lPYWjp0qUsW7aMyZMns2DBAhYsWEBlpd48iMjJYUtjGz9cvZ3mdIEJVRHKQlEyBZv1u5PsTma56eKpCkTSk+fBk0/CZz/r7x0EcOWV8MADMGNGaccmIiIDpk9haNasWXzta19j1qxZgz0eEZEB5boeT69voDld4PTaCoyOkqbKSJCKcIDXG9t5pr6B08ZUqGROfJs2we23w29+4x9PmQL33+93jlNJnIjIsNKnBgq33nqrgpCInJR2tWbZ2tTOhKpIVxDqZBgGE6oibGlsZ1drtkQjlCGjvR3uugvmzvWDUDgM99wDGzbAtdcqCImIDEN9mhnSuiAROVmlCzY526EsFO3169GQRUMqR7pgn+CRyZDhefDzn/trgXbt8s/9zd/A8uUwbVppxyYiIoOq3621RUROBuWhAJGAReYwYSdbcAgHLMpD/WquKSe7+nq47DK44QY/CJ12GvzP/8CvfqUgJCIyAigMiciwNqk6yrSxFexJ5vA8r8fXPM9jTzLH9NoKJlX3PnMkw1Qq5TdHOPts+N3vIBKBJUv8cPSud5V6dCIicoLoo1ARGdZM02D+nHHsTmZ5vdFfOxQNWWQLDnuSOWrKQ1w5e5yaJ4wUngc//SksWgR79/rn3vteuO8+mDq1lCMTEZESUBgSkWFvem0lN108tWufoYZUjnDAYu6kKq6crX2GRoxXXoHbboM//tE/Pv10v1X2VVeVdlwiIlIyAxaGdu7cyeTJkwfq7kREBtT02kpOu7SCXa1Z0gWb8lCASdVRzQiNBK2tfle4f/1XcF0oK/OPP/MZv2OciIiMWH0KQxs2bDjqbZYtW8ajjz563AMSERkspmkQrykr9TDkRHFd+Ld/g89/Hpqa/HPXXw/LlkE8XtKhiYjI0NCnMHTjjTcyd+7crsXHyWQSz/Oorq4GIJFIEIvFBm2QIiIix+T//s8vifvTn/zjmTPhO9/xO8eJiIh06FMYWrhwIddff33X8dNPP33I3kNPP/30wI5MRETkWO3fD3ffDQ895DdLqKiAL38Zbr8dQqFSj05ERIaYPoWh7kEIOGQXd0AzQyIiUjqOA48+Cl/4AjQ3++c++EFYuhQmTizt2EREZMjq1z5Dr7766iHn6urqjnswIiIix+yFF+Btb4Nbb/WD0Ny58Pvf+y20FYREROQI+tVN7pprruGKK65g9uzZALz22mssX758QAcmIiJyRE1NfnOEH/zAP47F4KtfhU9+EgLaOUJERI6uX/9azJo1iyeffJKVK1cC8LnPfY64OvOIyDDkup7acQ81tu2vCbr7br9tNsCNN8K//AuMG1fSoYmIyMml3x+drVixgvXr13P//fezZs0aRo0aRUVFxUCOTUSkpLY0tnVt1JqzHSIBi2ljK5g/Rxu1lszq1fCpT/kbqAK85S3w4IMwb15pxyUiIielfq0ZWrZsGbFYjDlz5gBw0UUXac2QiAwrWxrb+OHq7azfnaS6LMhpYyqoLguyfneSH67ezpbGtlIPcWTZu9ef/bnkEj8IVVfDd78LL76oICQiIv3WrzA0d+5crr/++q41QyIiw4nrejy9voHmdIHTayuojASxTIPKSJDTaytoThd4pr4B1/VKPdThr1iE+++HGTPgxz8Gw4BbboHNm/21QZZV6hGKiMhJrF9haOfOnYecW7du3XEPRkRkKNjVmmVrUzsTqiKHbCVgGAYTqiJsaWxnV2u2RCMcIX7/ezj3XPjMZyCVggsu8DdRffhhGDu21KMTEZFhoN8NFK677jpGjRpFXV0ddXV1LFy4cKDHJiJSEumCTc52KAtFe/16NGTRkMqRLtgneGQjxK5dsGgRPPaYfzx6NHzzm/CRj4DZr8/wREREetWvf1Uuuugili9fzsyZM/E8j69+9atcdNFFAz02EZGSKA8FiAQsMocJO9mCQzhgUR5S++YBVSj4m6SeeaYfhAwDPvEJvyTu5psVhEREZMD161/ynTt3Eo/HWbhwIW1tbdTV1RGLxZg8efJAj09E5ISbVB1l2tgK1u9OUhEO9CiV8zyPPckccydVMam695kj6Ydnn4Xbb4eNG/3jiy7yu8Sde25pxyUiIsNavz5mW7NmTdefKysrmT9/fo9zIiKl5roeieYMG/emSDRnjtrsoPvtd7VmuWLWOGrKQ7ze2E5brojturTlirze2E5NeYgrZ4/TfkMDYccOeP/74Yor/CBUWws//CH88Y8KQiIiMuj6PDPU1tbGypUrMQyD1atXH/L19evX84EPfGBAByci0h/Huj/Q4W7/12fWsnFPG1ub2mlI5QgHLOZOquLK2dpn6Ljl83DvvfDP/wyZjF8Cd9tt8JWv+G2zRUREToA+h6HKykouuugiHnnkEXbs2HFISdzNN9884IMTETlWnfsDNacLTKiKUBaKkinYrN+dZHcyy00XT+W0MRXsas2SLtg0teVZuW4vLZneb3/jvFN4T3Ai6YJNeSjApOqoZoSO18qVcMcdsGWLf/z2t/slcWedVdpxiYjIiHNMa4bi8ThLlixhzZo1apggIkPOwfsDda71qYwEqQgHeL2xncde2MGo8hDbmtJkizZv7s9iOy5vPXUUlZHgIbd/9rVGPv6OaQpAA+GNN/w22f/1X/7x+PGwbBl88IN+swQREZETrF9rhubMmcOjjz5Ke3s7ABs2bOj6s4hIqRxtf6Bo0OS3Gxt5cXsz1WVBxlZEyNsOBdvhlZ1JmtP5HrfXfkIDJJv1y99mzfKDUCAAn/scbNoEf/d3CkIiIlIy/QpDK1eupKWlpet45syZ1NXVDdigRET648D+QIdOenuex67WLNmiw6TqKJWRII7nYQBjKsNkCw5bm9J43oFGC9GQRd52tJ9Qf3ke/Pd/w+zZ8OUvQy4Hf/3X8Mor/oxQLFbqEYqIyAjXr9ba1dXVXH/99QM9FhGR49J9f6DOkrdObTmbfe0FysMBwgELgJBlErBMbBcqIgGa0wXacjaxqP+9w3U/Idfz2NmSIWt7g7cOassWuPNOeOop/3jyZPj2t/3OcZoJEhGRIaJf/8K/+uqrzJs3j4qKiq5z69at48orrxywgYmIHKsj7Q+Utx3a8zanjimnMuL/6quMBBhVFqKpLUd1WRDHdSk4LnDk/YRc1+tqwHCyNVXY0tjOLzamyWzZQsFxj9pp75hlMvD1r/ubpxYKEAz6JXFf/CJ0+zdDRERkKOhXGFqwYAHXXnstU6ZMobKyktdee42vfOUrAz02EZFjYpoG8+eMY3cyy+uN/tqhaMgiW3DY1ZqlLGgxsdt6IsMwmF5bQXvepqmtQMAysAyDtlyRPclcr/sJHWvb7oF0vCFsS2MbP6p7k22tRWZOCVIeDh7Saa/fj8Hz4Mkn4bOf9fcOArjySnjgAZgxo3/3KSIiMsj6FYbi8ThPPvkkK1euJJVK8bnPfY54PD7QYxMROWbTayu56eKpXYGlc3+gt06tYdrYCvYkc3ie1xWIaspDnDUpxuqt+/E8jx3NGUaVBXvdT6gvbbuPJxAdKewcbwjr6rSXKRCvtKiM+DNn3TvnPVPfwGljKo59lmvjRr9V9m9+4x+fcgrcdx+8970qiRMRkSGt34XwlZWVPdYN7dy585C9h0RESmF6bSWnXVpxSLDYtq+dH67e3mPWaE9rlvW7UuD5jRQs02BsZYTLZ9X2CBl9advd7zBBz7CTLTq4nseEqgiXzRzHuMoIP1pzfCGse6e9dGvP7p8Hd86L15T1bdBtbfC1r/nBp1iEcBj+8R/h85+Hsj7eh4iISAn1KQw988wzPdYIPfHEEz2+nkqlqKur49FHHx34EYqI9INpGkyqjnYFol2tWU4bU8FNF09l1fq9rNuVZF9bnoZUjoBlMK22gknVZVgmJFoy/KjuzR4h42htu/sVJjp0n3GKBk1a0gWa2vO8kmjlfzc2MroiTFk4wFvi1YcNYVNrytmTyh22hK6z096EUJh0L2OIhiwaOr7/qDwPVqzw1wLt3u2fe9e74P77Ydq0Y3rsIiIipdSnMPS9732PysrKro1WH3vsMa655poet+nealtEpNQOV1Z25oRK8MBzPfa05kjmCkQCFq83tLOrNceoshDTxpazP13oMdNzoG13tNefd0xhopvuM06jy4O8sjNJtuB0NHcIsqc1x+aGNiZWR2nJFKgpD3d9b2cI+8uOFr719Cb2tecPW0LX2WkvnbdJF1z2tecJBwJd5XJ97pxXXw+33w6/+51/fNppsHy5H4ZEREROMn0KQ08++WSP46997WvMmjWrx7l58+YN3KhERI7D4db2/Gnbfn6xdhfjY2FMwyCVKwBQdD2yRYeycICmthzteZvTa8t7zPQc3LbbdV32JHNkig5lQYuKsNWvNtydM07jYxE27k2Ryhb9tuAemIZBRSRAMlckU7Cp353izAmVhK0Da35yRYfNDW3kig5njKs8bAndpOoo1dEgf9jSRD5XIJRsIWCZPcJfb53zuqRS/l5BDzwAjgORCPzTP8GiRf6fu7Ftl78kWtifLjC6PMS58VEEAv3a1k5ERGRQ9WvN0MFBCCCmzfNEpES6Nx4oC1qsWrf3kLU9FeEAtuvSks6TL9i05R2yRZdgwMT0PPK2S3vOZkJVmJZMkV2tOUaXB7tmerq37W5qy/FKIklrtojjepgGhAIW7zhjzGHDxOGaI3TOODlpl9cb23Fcj1TOxjQMokGLspCF63mkskWa00UaUjkqwwFqysOcVlvOxr0pckWHmvIQngem0fs6pm372mlsz5MruBQdj+qQhWEY7G7NsrMlw9nx6kM65wF+Sdy//7sfehoa/HPXXuvvGTR16iGP87kNDfzb6u1s35+m6LgELZOpo8v58MVTuWzmuAG75iIiIgOhT2Fow4YNR73NsmXLtGZIRE64g8vhHNcj0ZzlzPEVPdb2tOVs9qZyuB40Z4oYBgRMAwN/ZsjAoy1vM8YJUREJsK89T3U02DXT09m2+8/b9/PS9hZcz6MsZBEOmOSKDpmCzUtvtvK7TY2HvOk/XMneFbNrSWYK7G7Nsqs1S3uuSCwaJGCaOJ5HumDTmsmTK7rkO+6rPW/guh6ZgsOu1gz72guEAyb1u5IEAxajykJMr62gpjzUtY4p0ZLh6fUNOK7HX50xmlfeaCBvu7ieRyRo4nlQWxnmtDEH7QP0yitw223wxz/6x6efDt/5Dsyf3+u1eG5DA99YuZG2XJHR5aGutuabG9v4xsqNAApEIiIypPQpDN14443MnTsXz/MASCaTeJ5HdXU1AIlEQjNDInLC9VYOt6slQ3M6z6YGKA8HqSkPAf6mq8lMsWv2xDAMQgGTouNhmeC4HgXbwXZdIkF/bc3E6miPmZ6pNeW052wMA6IBE9f/lUhVWYjqaICm9gI/qtvOO04f21UWdqSSvf9+ZRdFx2VnS5ai0/H7NVekPBggaJlYhkdr0cXzIGQaeICJQbbokCk4HV3nYHJ1lFhZkKLjdZX5nROvJhYN0JDK8ca+dFfzh4qwxcwxIcqrayi6ELJMwKM1UzzQ/KG1Fe65B/71X8F1/c5w99wDn/mM3zGuF7bt8m+rt9OWKzJlVBTT9B9/ZcSkPGSxoyV7yHMjIiJSan0KQwsXLuzRRvvpp59m/kGfDD799NMDOzIRkSM4XKvr6rIQVdEg7TmbrU3tjCobBUBLukDedgmYBpZpYBgGpmHgeA6OC17HfWaLLm05m2jQ4rKZtT3Kxl7a0czu1iy1lWHCAQvLNAiYfqgyDAPXgzf2pflLooW3njq6a4z72/OMj0XI2y6eZ1N0XPamcuxsyRC0TMKWAZ5HwYV80SNfLBKy8MfVEbgcz8MwIGc7BE2DnO1iACELLMt/LOGAQag8RHO6wNamdmaMqyAcsAC6NX/w7ycWDWIYfiixXZfGtjzpXAF+8LjfGrupyf/B118Py5bBUfaS+0uihe3704wuD3UFoU6maTK6PNTjuRERkeHjeDcFL6U+haHuQQg4pK0saM2QiJxYh2t1XRkJMLo8zK7WDM3teRLNGfam8uxpzVCwXbKuR0XYIhqyKDguFeEA2YJDruiCYWA7LuGAxSWnj2HetDFd97ulsY3HXthBS6ZItuhgmSbRoEVNeajr50dDFs3pAvvTha4xvpxooSVdYPv+DLbjYpkGmYJNMmcT7CjTsz1wDnp8hYNOWJbhz0a5gGEQskws0/993JazqQj7DRWMjqYLze15tlkGF546mtPGlHc1f6gIW3gepLLFHjND03Zs4tT3fAL+70X/B86c6ZfEXXZZn67H/nSBouMSDVm9fv3g50ZERIaH490UvNT61UDh1Vdf5corr+xxrq6urqv19tEkEglWrVpFPB4nkUiwYMGCI4apuro6EokEVVVVAFx11VX9GbaIDCOHa3VtGAbTastJ5go0JHO8nGjFMgwClknQMjDwKLoepu1gGP5MjGkYlIUCREMW46siTB9byQcvnNL1qVZnqdvejj2JLNMgYPnNDwqOy/hYpGt9TNDyZ0EANuxNsbmhjaBpUhkNEowEaM/b7E8XsR2XykiAfNElZ/ulcAEDXA/cXh6v53rkbX+ayHX9qayIaVIRDlDWETQqIn55net5tGaLnFZbwZWzxzF5VFlX84easgAb9hUoNjfjeB7VmRQffur7/M2ffoXheVBR4XeNu+MOCAb7fD1Gl4cIWmZHW/BDy+AOfm5EROTkd7hS8GPZFLzU+hWGrrnmGq644gpmz54NwGuvvcby5cv7/P133nlnV7vuRCLB3XffzQMPPNDrbevq6li1ahVLliwhkUhw0003KQyJDCP9nVo/uNV1dzXlYc6oraAxlSdTcIhFLCzTZExFmKLjYhqQzNlYpkHQ8tfiGBjUlIf5q9PHMn/O+K5f3t3L8S44ZRR7WnPsTxeIWf7MULbo0JwpMCEQZn+6wIxxlZwbH4Xrerz0RjO24zGqzG+0AH7ThoAJhaJHruhiO34QMgAM6IwRneuROhkGdFafubZH0QXT8IPYzAkxtjWlaU7nabULOI5HZSTIDRfEux7H/Dnj2LA3xfOb91MoOkyIeVyx5td86H8epiqTAqDxPe9jzHeXY06edMzX8dz4KKaOLmdzYxvlIatHqZzruj2eGxEROfkdrly9t46mQ7lkrt+ttZ988klWrlwJwOc+9zniR6kn75RIJHocx+Nx1qxZc9jbL168uCs4xeNxfvjDH/ZnyCIyBB3P1Hr3VtedJWKdPM+jOVNkbGWY2RNjhAIWIcuk6Li8sjNJJm8TCJgUbZfTx/mbsFZEAtzw1ilcPG1Mj1/a3cvxLMvinCnV/PH1faRyNtGQRcA0aMsWyRUdRpWFuHHeVAIBk0Rzhqa2PBOqIiSzRcIBv5W1ZRhYholpOuSKDp0/ycXvVXA4BYeOMjs/OHmA48GosiAtmQIVEYts0SJXdMjaLpURg1cTSSZWR5leW8lpYyqorQgTCZnMenMTn334/2PGzs0AbB1/Gkvf9Sl2zLmAazZluCrUdsyf5AUCJh++eCrfWLmRHS3ZHt3k9qcLxCLBrudGREROfocrV4cDm4J3369vqOpXGAJYsWIF69ev5/7772fNmjWMGjWKioqKo35fXV1dV7lbp6qqKurr67tmmjolEomuTnX19fXE4/Ejhi7HObjqXo5H5/Op53X4K8W13tLYzo/q3vRnVaoiTAiFyRQc1u1qZVdLhhvnncL02iP/Trl85lh2tWTY3NDGhKoDpWp7kjnKQxZueYjayjBWV7ixmDo6ytpEK62ZIgXbpeCkiI+KctWccbxt6ig8z6X709CWLZAt2kwIhvE8l6mjy/C80V334XoergenjS3nk5dO49IzxuA4Dm3ZAjnb4YxxFazblWJfe94PRHhYloHt9F4OdyTdA5OB/6nc86/vAzwcFwKm39luXCzMGbWVfplCa5Yb551CJGiS39vAvzz1Hc597pcApCPl/GD+Tfzune/DNi3yeZs/b2/u+p6jPf8Hu/SMMbjuGfyo7k3ebM7QnC4QtEzOqK3gHy46peu5kRNHv8dHDl3rkWOoXOuD/308WCRokivatGULOE7vnUiHgn6FoWXLljFlyhTmzJkDwEUXXcQzzzxzyDqi3qRSqV7PJ5PJQ851BqBVq1Yxb948HnroIebOndtrmVyhUGDt2rXH9kCkT9atW1fqIcgJcqKutet5/GJjmm2tReKVFunWdtIdX6v0PLbtcfjxcy2898xyzF4atriex76MQ9b2mB51eT1TYNvOJAXXI2QaTI4FmFYT5Pfbs7y5K0NZ0J+NSOVdNu8v4tguUcvDcz1wimxvLPDAb9r44/o3uPK0MibHDvxqbEzbZFLtvJlPdd1PFLhwnMn+bIBU3sVx4SOzA9TkdrN27e4e32flDaotl6ZMkb0FF8eDYj+C0ME6Z4bcjpbcHuA4fte8yeUewYJLoOO5/Pdnmrjupaf4wqMPU5FtB+A351/B8stvwh1dA8UCrueRL3hEbJdte9qO+PwfSQ1w+zkWr++P0Jp3qQ6bnD7aItDtuZETT7/HRw5d65Gj1Ne6t38fu8sUXdJ5jze3biK7t9/zL/2Sz+cJH2YriIP1a2Rz585l/vz5RyxvO1a9haRkMkkikWDevHnEYjEWLVrEBRdc0GsYCoVCnHPOOQM2HvE/cVi3bh1z587FsnrvECXDw4m+1jtbMmS2bGHmlCCVkUN/DVWMsmnJFKmdOp3Jo3pOrW9pbOeZ1xrY2pQmbzuEAxanTRjDVW+tYmxFmPKwxcQqv6lC+vlt1O9OMa62HDBIvNmCETSpKTPY0ZwjFDKYPCpKwDJoaiuwOWlQuT/C1RPHM7o8RHveZtJYizNSe9jRnGHcuJ4buU7wPF5vTDNnUoyrLj6tR3md63psKW7jhTeaabELRCImwZBHMlPA81yKHe28j1fnfRgd/9ku7GqHeWeOwzQNztzzIlcu/SrxHa8DsPu0M/nZBz7Jb8bNJRoMEOooW8vbLgQcJo6vYZJhHPb576vzj/+hyQDQ7/GRQ9d65Bgq17rz37nOf2cPLld/vTHNBafGuPyi0074mqG+BiHoZxjauXPnIefWrVvXp5mhWCx2yCxQMpnstZtcPB4nFov1+Foqleq1pA7QX/5BYlmWntsRovNaD/Z+AVnbo+C4lIeDvbbqLwt3bBa6P0vW9rrGsG1fOz/+045uXWsCZAo2G/a20dCW56aLpxKvqWBXa5a2XJFJo8p4bW8br+5KUVvpNzgIWQa7W/MATKqKEg76vwZHlYdozRR44Y0WXnhjPwXHJVt0KQtaTKqOkLM9MkWX02sriAQtmtry7ElmGV0R5spZEwgGe/46tSyYP2c8v3p1D7tas1gG5GzX31zV80vaPCBomdiOH46Oh8eBYNTQXuS1lzdz+zPf5y3/+ysA2ssq+bdrbuF/LryG0WEXpwDBjv2RPM8jnbepjUWIRUM4nkdjW56s7R3x7/7JvK/ESKPf4yOHrvXIUeprbVlw9dwJ7E3l2dKUOaRcfXRFmKvmHPrv41DT7wYK1113HaNGjaKuro66ujoWLlzYp++dN28eK1asOOR8Z8ldd/F4/LBldSIyOE7EfgFH6gQHsKc1y/b9WR778w4s0yASsDhtbDnN7YWurjUAbTmbvONQFjLZvi/Nw89vI14dZe3OVrY1pckUHQKmQbijoUEqaxOLBjBNg4mxCGXhAJ7nUbBd2vM2+9oLmAa05w80NkhS7FrXBLBhT4r96QLZgkNZyCIStPjNaw2YJpw2pqJHONibzNGetzGAXNEl73SbC3LBMsFxvY5AOBDzRBBwbG78y6/49B9/SmUhi2sYPPXWa1j/ybtoDFeQ2d7CvuYiZWGTvO1gGgbtOZtI0GJcZYT96QIF2yFkmZSHDv9PxMm+r4SIiBy/6bWV3HTx1K5/DxpSOcIBi7mTqrhy9snx70G/wtBFF13E8uXLWbFiBZ7n8dWvfpVZs2b16XsPboCQSCSYM2dO1+xPfX09sVisq1nCvHnzSCQSXXsSxePxXmeFROT4bWk8eOZlcPYLOFInuP3teV7c3kI06Je7lYf92Z8XtzezY3+Gt0yppiVTYGtjmj2pLMlsEdvx8DyPv+xooTISoOB42LaLYYDnQThoUlMeJBwwGR+LYBp5QpZBc7pAW65I0XZpL9gU7APrb0ImWKaB5/lBJtGcpbbSpa3jPiZNjlJbGSFbdFi/O8mGvf7sU2umSM52CFsmb+7PkM7bWKa/RqjzUXocaIZg4GF1tNQ+3nVEb9vxKl/5zfeYsW8HAK9MOJ1vXP1Jcueez1+NH0vcMIgGTX6/cTc526UhlWdUNEhFR6nihr0pbMclU3CYVltB9uCdXzsMh30lRERkYEyvreS0SytO2kqBfoWh973vfdx66619ng062PLly1m6dClz585l3bp1PfYo6myScMstt3Td9qGHHmLKlCnU19ertbbIIHE9j2deOzH7BZimwfw549idzPJ6Y3vX1Hqmo5sZwFtPHUUsGuwaw6TqKJv2trG1KY3juqSyNumCjedCyDJpyxUoulBMFwCDqkgAyzSwXY9MwcU0bEKmweaGlL+/j+tid7zXDwVMit2CEIDt0RGy/HMFx2Nnaw7T8Pf8qanwu99VRgKMLg/x+81NRIMWF08fw8RwlMZUjp2tGdJ5B8/zsEyDzqfN9Q78HK/jZx2PcW37+OLvfsB7NjwPQHM0xrfecSMrzrqCaCjAGd1uO7oizNm1IVrcMsIBi7Z8kbacje14hAOmPysUMMgXHf6tbjsfuaRnsBku+0qIiMjAMU1jSLfPPpJ+haEFCxYcsj5ozZo1XHTRRX36/ng8zqJFiwAOaYZw8OarnY0TRGRw7cs4bG1Kn7D9AnqbWrcdj6BpMGfqKEZXRHrcPhywKA9ZJJozVIQtCo5H0fGIdutg43l+hzXL9GjL212d0BzXZX/awTI4ZG1OZwnbwbMyXkdAOTinuB5s35elIZVnbGWY8ZURsh3lZp1Pm2UaBAMmYcvA8fxAFTbBww9nA1MQB0GnyE0v/Td31D1ORSGLY5j89Jyr+fbbP0RrtBITqC4Lkiu6tOVsKiMBUtkieRtCIZMPvHUyj/0pwe7WHJYJyVwRA4iGLFozBdZs3UemYPPZK87oaqTw0pvN/GVHM6PLD12cejLtKyEiIgL9DEOGYfClL32JKVOmEI/HSSaTrFq1qs9hSESGnqztkbcdyg6zTiQasmhI5UgX7AH7mQdPre9N5ljxYoKJ1QfeRHue17U2KBS0aM9ncT2PTMHBMKDouF1d1AyjY9bFA9vzCAcM/2v4591eUsjhgskRA4vnN4Boy9nYdpq2vMO4WAS34zz4s1WeYYDnj6vogmkcCFnH6+Lta/nKb77H9Ga/oc3/TTyTxVd+gvpx0whZBgHXAwMqwwFs16WpPc/GvW20pPO0thcIhtL8YVMT4YDJWZOr2NLUjmkYjCoLYbseDakcbXmbPfV7aWrLM2O8vzntm80Z6nenqIoG2dkSZlptOTXdgtFgvE5EREQGS7/C0MMPP8xFF11ES0sLLS0tALS2tg7kuETkBIsGDMJHaGqQLTgdszMD2xWm+9R6eShANHhgDM3pPFsb0zRnCtiuS2u6SNHxyBTsjo5sJi5+W2jPO7Amx/XoKEnzsF0/KB3JseYTB3Btj2SmiBcNkLddktkC1dEQIcufqSq6LvnOGSfPb5RwpO3x+tpCYWKqkbuf+z7XbK4DoKmsmm9eehNPznknnmFigN+xruM+W7JFgpbJ6w3tOK5LRdjf+DUWDbBhTxsNqRxjKkPgwbhYhNZMkV2tWQqOi4GH7cBre1JsbWonaJnMmlBJVTSIZRo0tuVoyxc5e3I1Qcuk4LgUbPeozRdERESGin79a7Vw4ULmz5/f49xA7jkkIifemDKLaWPLeW1P2yFNDTzPY08yx9xJVUyqjg7aGCbEIoypCPHanhRjKkJsaUyTKzpURAIEDIvGVJ7OxmseUHD9xglwaPOBzuHbzqERo3vw6Nyf51ibF3j4z0u+6OK4Hq2ZIhOry6iMBGhO53kl0UrAMroaI1imvylq95/rHXR/RxKyi9zy5ye5bc3Pidp5bMPkx+e+i/sv+SCpSMUh9xM0DcIBg9Z0AdMyKBYdKqNBdidz5Ioe4ZyNBzRnCrRki0ytKSNbcLqCUNA0MAx/9O25IgXLpKYiTCpnU1Meoqktz6iyIA1teZ7f3ERZyKLoumQLLtPGVpAtamZIRESGvj6HoQ0bNvDUU08xZcoUPvCBDxzydZXIiRy/Uu7bYhoGV84ax95UvkdTg879AmrKQ1w5e9ygjaezVfO2fWne3J/hlUQS04DJNX74aupoe11TFuwowTIoOi6mAQHLxPE88t2aIDgdndqOFnI69+fpT3NrFzBN8Gy/CcL4Kr9cbGtjmmzBYXJ1lPacTabg4LgHAtex/qxLt77El557iFNb9gDw58mz+epVH6d+9Km93pkBjK4IYRj43e2KLk3FIvszRcCfNcvZLqMrQpRlAyRzRRrb8pjgByHLwDT859cyDYqOh9dRktiSLjBzQoz2vENDW55UtkjRcQkHo+AZVHY0vfhR3ZvqKiciIkNen8LQmjVruOmmm7rWB9XV1XHfffcN9thERpShsG/L9NqKkuwX0L1V85SaMspCAf7wehMF2yHRnGV0RYjqsiCe5xGLBtmT9FtqAxiG6beqdr0eucDj0GYJdPtaX84djedB3vYoC1kUHJfm9iJ7Qjn2pfOEAiYtmSLjq6LkizYNbXls2y+V6/6zTHpumNrd5Na9fOm5R7hiywsANFTU8M/v/Ai/mvUOMPy232Yv32cA7Xm7q6yxYBfwPLAMv4mDYfhrrty2ArGyIKlckXTenyny2+cZFBy/9NDFxXH9GbbWTAHTNCgLBzh7chXPb27qmHkzsB2PCR0t00eVBdVVTkRETgp9CkMrVqzgxRdfpLLSfyO0bNkydu7cyeTJkwd1cCIjRan2bemciWrLFmhM27iud8L3C+itVXOu6FAZtgiVh0jnbaqjQc6aVMUL21sIWCajK8K05WyCHTNCtuPhdDQosEwoOv0LN8fCBCoiFhj+LEptWZgzxleyqyVDKlukKhqkNhZh2tgK2nNF/vD6PgoBl6Ljku1IaQb+mA+u5AsX83zihf/g4y/8JxG7QNG0+OF57+GBi/+W9nBHc4mO7+nok9D1eE0DqiIBXM+j6Lg4rtvVytt2wTQ6Zs88j4Ltt/2OBi1sz6Voe5gG2B3fY3SswrI69lwq2i6pbJFM3qa6LEQ0ZDE+EMF2Pc47ZRQTq6Nd5ZXdu8pNqo6etPtPiIjI8NanMDR58uSuIARw6623smbNGoUhkQFQqn1bus9EZYs2mVQ7W4rbuHruBKbXVp6wtsi7WrNsbWrvaundnC6wcW8brVkbw/DbYydash0zRhZNbXkCpkHIMpg8qoyABXuTOdIFh/KQ3znNL0vzu8lligMfi0wgEjQJWRY528H1PCaPivLRS06lIZXjod9vo6Y8yIQqPxy4nkdVNEB52G9tvTuZxcMvP+uxx5DncfmWP7P4uYeZkmwAYPUpZ/Glyz/OljFTeh3LwY8uZBl+SZ4Heduf7TGNA530/Fk0v+mEZUJb3iYS8Bsv4EHQMig4XsftPQzDD0K242KYBpZpsDeVIxq2sF0XPIOJ1dEeQQgOdJXbsDfFf6/dXdIZz5NRKUtmRURGkj6FoSlTev4jXFlZ2bVoudOGDRuYOXPmwI1MZIQ4OAx0N1j7thw8EzUhGObNfIr63Sn2pvIndK1HumCTsx3KQlGa0wVe3tFCW87vgFa0HYJBk7a8zR+37CcSNP0220UHwzRwPRfXNcnbLmUhf5NVxzOojATIFBws04Aj9nDrn84OdkWniGl4eBhkCy552+H8U2p4cUoL63cnu24fskyCAQvTMHCBSDCA53kYOBQ6hndKy26+/OxDvHPb/wGwu3IMX/vrm3lqxsUHukH0Qc72KNh2V5txo6Odd9faqG6byJoOYPivM392ySNrH+hEF+iYEXJcvytf0IIx5SH2pwuMKg+SLbhURoNMG1txyGs3W3DI2y6/fmUPBcft04zncA8AfX18Q6FkVkRkpOhTGEokErS3t/c4t3Pnzq5zra2tPP7443zlK18Z+BGKDHPdw0BvBnrflt5mojzPpSxoMq62nC1NmRO61qM8FCASsEjni6zb1cruZLZjHx+PvO2XlLmeB9hYZoBYOEDOMskUHRItWWrKQwQtk9HlQfani4Q6WjyPLvfLuDJN6UPK0AaC09G+O2hZXTMmnU0D5s8Zx+5ktlsjCpPykMX2/RnMjtmWzqYK0UKOT/7pCT725/8k7NgUzACPvPVavnvR9WQO85o4ms523kDXWqGA6c/4eAfdzgQCBmBaeEG6SviCJpiW6X/wZRgETIhFA1iWSSrrN2WYNtbvYjeqrGcrds/z2N2aJW+7BEyXM8YdfcZzuAeAvj6+UpXMioiMVH0KQ4888gjf//73e5zzPI9ly5Z1/dkwDIUhkX7oDAMnan+fUsxE9aZrvVKuyJiKMH/Z0cwb+9I4rofXsS8PntfVBMHAI1d0mVxbxqwJMdrzRdZsa8YwoDoagM61Li4EAyY15SGKjofZ0Yt7MAJR0fUwHJeZtTHedloNW5rSPFPfwMffMa1HI4q87RAK+K0OXAxiYYtc0eHyDX/knue+z6S2JgB+f+q5fPnyW3mjZtKAjbHzCtsHNZjo5HrQmnMIBTxc18XCn0sruBDEJRK0KA8HqIoGAINpYyvI2y63vuM0qsuC/KjuzV67D4aDFrbrMbH66K+zvO0M6wDQ14BTqpJZEZGRrE/vrq6//noWLVp02K93D0YicmwmdXTgWr87eUL29+ltJsrzIF1w2ddeIGCa5IrOgM1E9ebgT8nzRYc39qVJ5x0sw/9wpfO/zpkU14OKsMWZ4ysZXRFmdEUY0zDYsCeF7Xg0p4u4rkdZJMDYijDRUAAnV+x6fJ3600L7SIqOR6Ho0Jot9niD39mIItGSYVtTO79+dS9Fx6VouxibNvGNX/8rl2x/GYCdsVqWXHYLz5z+tmMqiTsSg469jdye64UOp2AfaOrQnWkajK0MEwlatKTzpHJF5k0bw/mn1GCaxmG7D06vreCXa3dRdpgQ3znj2ZYv8rsNTcM2ABxLwBkqH1SIiIwkfQpDN9xwQ48GCoe7jYgcO9M0eimrGrz9fQ6eiWpO59nS2M7ufQWCyWY8IBww2deWh/ED8iN76O1T8oZU1m/j7PmzQkGro2200fGfaVCwPdrzNsFuz8OE6ii5osslp4/hD1v2sXF3CtfzCAVM8rZDe94mFDDJdCzMGeggRMf9NaULrE20MndSFXn7QJDctq+dp9c38OquVtbvTFLt5Pi73/yY6//4nwRch7wV5HsXvp//723vIxeMDOi4gpbfKAF671h3pMfTyXYhnXdoSOUYUx4mU3AZXRHu8Xo8XPfBXa1ZVq3fe9QZz/acPawDwLEEnBNdMisiIn0MQ7NmzRqQ24hI76bXVp6w/X26z0QVbIdXdibJFBxCAYOqaICm9iKW6fHUuj2Mr4oM6M8+3KfkoYBFRdiiLVcEw98Hx3Y97M4W2R3v5NtzDn/e3sz5U0dTUx4iW3CIBC3efvpY3npqDT97YQe/29jIzpYs5eEA42IRPA8yhSwwOO22DfwZvEzeZlNDG1NGlVEeCvQIfWUBk6vr/5eP/+p7jEnuA+C5aRfw1cs+xvZREwZ8TCb+G227Y0qsPyWCRsd/juvRki7geR4zJ1TxqUunH/KaME3jkKDS1xnPinBgWAeAYwk4J7pkVkRE+hiGpO+GezckGTwnan+fzpmoXa1Z/vxGM3nbYWxliGQqT0vWJhYNcvbkKvanCwNennS4T8lDlollmliWPwPkOB1NAA7iATuasxSdfcyZVMW+9jyzJ1YxIRYhEDC5+29m8ddn1vLsa43sSWYxDXhzf3pQ9xzygELRJVRpsqc1x3mnjGJCLMJDz2+jOV3gbZnd/NV3vsqp618EIDFqAv98xcdYdeoFWIMxVUVn++zju2PDgEjAb7rgeHDa2AruftdMzhjXt3Dc1xnPcMAa1gHgWALOiS6ZFRERhaEBNdy7Icng6+0T9sEwvbaSq+eOZ22iFcfzaM3YFB2PiaPCTK+tpKY8RChgDnh50uE+Ja+MBKguD7KzNcuR3sN7gOO6JJqz7E1mGVXur2V56PltXX/P5k0bw5SaMlZv2cd/rd3FvvbCgIz9SNoLDs3pIuGgyflTa9iTyrHrzT3c+F/f563/81NM16EQDPGTSz/IIxdeRxsBKLqD0tQBIGTR1bK7Pzr3HLJdf5YJA95++ljOGBc7pvvpy4yn63onbQDoy4dfxxJwTnTJrIiIKAwNGLVDlZPN2Mowp4yOMrYigu06JJv3c1q8GtO0gMEpTyoLWjiux66WDNVlISojga5GCafUlFO/K3XU+8jZHpbhEQkGOHdKNaMrwl1/z/76zFo27mnj5UQLG/ekaEjmBi1wdOcBmYLNaWOrmDmuEuun/85d9/wTVcn9ALx+8RX89z98lpVtYVpbc9hOb/NeA8fx+j/hZBoQDhi4LpSFAxQdBwOD2ROPHoR6CwdHm/E8WQNAXz/8OtbHdyJLZkVERGFoQKgdqpyMykMBosEAAcuguiyM3W72+NR6oMuTtjS2sWrdXhLNWZrTeaqiQUaXh5lWW86oshCu53XthXM0QcvfWLUiEuz6e/byjlYeeO51JsQitKQLuO7gzbz0xjDgtN1bmfyeRRh1qwHYN2kqz3/qbt48/+20pgsY7fsJB0ycQQxDZud4OLbGCZ3ClolpGHiG1zFOg9pYhNM69hQ6nKOFgyPNLp5sAeBYP/w61sd3okpmRUREYWhAqB2qnIy6l+9MH9vzdTnQ5Und3zyeOb6CTQ3QnrPZ1ZqhoS1H2DLZly50LfjvrnMhv8eB2Y6i45EuOGTyNlSEAUgXiuxJ5hhbEaI1UyQYsHpddzQYYrl27vn9Y7zvhf/B8FzcsjJ++76P8djF1zFr6lgMz2NLYxsF22VMRYg9tgu4XXsoDQQDv4McHmAYOPgbrPZ1WVLABMswcD2Pou1imQYByyIUtLj0jLHERx3+d9fhwsG6XUk2N7TxN2dPYOb42BHf0J8sAaC/H34d6+M73pLZrn28sgUa0zau62FZ/b47EZFhS2FoAKgdqpwMeithOlC+kyZQdLFdj1yxOKDlSb29eSwPB9nS2M7eZJbdrVkCpsHptRVUhC2278sAB97Amx17DHV/Q290bLBavydFeThAOm+zY3+WbNFm/e6U34LbMg8Zy0AzPJf3r3uWu37/I8ZkkgCsv3g+T/7tp9kSGUWiOUPitQbGVoTY3NBG3nbJFhw8z98DyOp4ao93BitodjxHHUEIz99gtbf1V53hqHvIjEUsaspDNKeLFByXgGES65h5mzG+kr+9cMphXweHCwdFxyWZKfBmc4aNe1PMmhBjem3lEddQnqg1c8fjeD78OlGPr/ssXbZok0m1s6W4javnThhys2wiIqWmMDQA1A5VhrojlTDddPFUVq7bw0ubkmzflyYSDAxoeVJvbx5rykOcf0o1q7c45IoO0ZDFWZOrKTouDak82Y7V/x69B4XOBf57WrM8u6GBoGWQLtiEAybV0RB526VQPI4OAn0wd8/rLPnN93jLnk0A7J54Kvf+zafY97ZLmDa2grNCAcZUhPi/N1v5y44kRccFz5+tCXSkIM87jsU93XTsl9oRhjxc70C53ME6f1w4YBC0TAKmQThoMaZjE9uC41EVDTKxKsLZ8Wrmzxl/xNdBb9e3OZ1nbaKVbMGhuiyI43oELGNYrKEc6h9+HTxLNyEY5s18ivrdKfam8if1cy8iMhj07nwAqB2qDGV9Wd/w8b86jWeDLZwybTqV0dCAlielCzbZokOFE2Bfe56QZVIZCdCed8gUHcbGwmQKDkXXY0xlhLeeWsOftu0nX3R7zQkmEIsGCQcsCrZLc7qAZYKBQSQUIBYN0J63KNrOoGyyWp1Nsej5H/O3a5/GxKM9FOWn8z/ML97+PtxAgPmTqjBNP4pMHlXG1qY0DakcnueHFH9fIrBMA68jHB0vD/958TruG/zW5Id7/IGOjWzDAYsJVWHAYEJ1lJryMHnbwTINpo4p54pZRw5CcGg48DyPrY1psgWHmvIQHtCSKRAKWJxeFR0yayj7uw3CUP7wq7dZOs9zKQuajKstZ0tTZkg89yIiQ4nC0AA4WbshyfDX1/UNt1wyldryADPGV2IN8MKCfW153tyfZnNDG4YBAdOkpixETUUI23UJESBgmoQ6ytrOmlxNRTjAi9ub2deeB8+fSTFNg5BlErRMbNfD8TwMw8P1PAwXAgGToGmQLfhtwosD3D3BdB1uePUZFv3+x4zKtQHwX7Mv5duX30LV9Dj5rMNbJsa6ghDAjv1ptjW1Y+B1NTPw/+9h2wMThDr1tvzINPy25e05G9fzb2MZUBMxGFdTjmmYNLXlacvZREL+gv6yUIBMwSbRkuVHa7b3mEnoLUAcHA7acjbNmQIVHZ0CC7bTdX27l5ElWjKYhlGS9UHHsw3CUP7wS+tXRUSOncLQADnZuiHJyNDXN0e7k9lB+flbGtt4at0ebNfDdjzGVoawXY/Gthz703lsxyWZKTJpVJTKyIFfR6eNrWB0eZDXdreRd1xGlQfZ05ojGrJwXWhOF8gWHfK2P3tUGQ0RDphYpsGbzVkMoDxsQd4mPwDVcm/ZtZGvPPs9ztq7BYANY6fypSs+zsunzGFidZRz4qPYvi/NxOoDbzD3t+f50xvNZAoOAcvoKvfrnL05EY3uHA8yBacrCNHxs3OORyTgh95s0W+1EDCMrjf3vTUD2LavvdcAccXs2h7hoOC42K5L0ArgeR7tOZvaWKTr+kZDFlsa2njguddpzRRwPBgVDR51PdFAOd5tEIbyh19DvYRPRGQoUhgaQCdLNyQZOfr85mggEsNBOmelWjJF3jq1hld2JmnNFKmIBKguC9LUlqc971AWsjhtTPkhn7A3tBV4x4yxeMCftu3veIMdxAwYTAxGyBcdmtoKBC2TCbEw2WJHBzTT6OwhQDQUgILjd0jrR+e2mkySu/7331iw7jcApEJlfPvtH+In5/4NjmlRbplMqo4StgxCAbNrdqQ5XeDF7c205Wx/PPjd2opO700NBkJXmdxB5wuOR8gyKDpe19czRdifLuC4Hp7nMS4WpiVbpC1nE4v6pV/dw3Ld1n2sXL/3sAHir8+s7QoHFeGAP+OTtynYLtFQgGljD8xKbtqbYt3uFMGGdspCJuGARVu2yL50YdDXEw3UNghD9cOvoVzCJyIyVOk34gA7GbohycjR5zdHYYuBnhvqPitVGQlyTryaLY3ttGQK2K5LwDKpLjM5ZXQZ+9MFQgHzkE/Y588Zj+vCK4lWUjkHgwLRkL9WKFd0qakIYZkGLekCHh6u61ERtjAMMDGwO97o727JUSz0PfBZrsPfvfwUn/vDv1OVTwPwxJzL+ZdLb2Rf+SgAyoMmY2MRJo2KkmjJ0dSWJ190OSdexZbGdjIFh6AFhmGSL7qEgxYB0yMzkP20Oxj43ek8r/cNV92OhUSdHeQcz59dO2V0GR5QXRYilfU7yXUXDVnsTeZ49rXGIwaITXvbuPGiqfzmtQa2NPolhK2ZIqeMLmN6bSU15SEA9rXlePGNFhzPY8qoKKGg5XedyxbJ2/71Gcw1LQNZRjYUP/wayiV8IiJDlcKQyDDW1zdHE6ui7Bvgn33wrFRNeYgLpo6iLWdTcFxMwy8le+9bJvN6Q3uvn7AD/Oa1Bn9mp+iyPZ3GNPzZn7KwP8M0qizI9n1pckWnx4atBhAJmgSqIoSDJm19DEPn76xnyW++x6zGNwBYP24ai6/4OH+ZNLPH7SzLxPU8QgGLM8ZFSRdsUtkir+xM0tiWozwcoD1vA/6MlWkYhEMmBdvFHuDZIcv038wbBrjOoWuROq+6v2bLwMSjMhJgem0l9btTZAsOVrd1W52yBQfH89iTzDJpVPSQ109bzu/g90qilb85awKfuHQau1qzbNiT4tfr9pAvOgQtA9t1yeRt6rbtp+i4TBldRqRjdiIcsAiVmzSnC2QKNq83tA3ampaBLiMbah9+9VbCFwmaZIourzemGV0RPuYSvv42mhAROVkoDIkMY4O5vuFob5J6m5UyDKOrDKstVyQSDDBzQozLZ4475L627WvvWttRFQ0yuiJIIeXguh7BgElNR6ndlsZ2TMPAdnuGAA/IFV12NGcIWwYmvTcZ6DS2vZnP/+8PeV/97wBojVSw7K/+gZ+dPR/XPLSpRCZvY5kGqVyBvO1QUxbE9TzGVobZ2tgOQQ/LNDAMk4lVfse8bNFfP2QPcBpyXTBM/NmxXr7ueH4IAg/PA9OEoGkQDpiMKguybV+a08aU91i31RmWJ1RFaEjlKOtWWtWcLnTN8hUdl1zR4Yer3+BDbzuF6bWVxGvKOG1seY8yMtvxMIFRZaFDZikNw6AiEqAtZ9OaLQ7ampaRUEZ2cAlfrmiTzntccGqMq+Yc2z5Dx9NoQkTkZHHy/saXAaFP/Ya/vqxvcJxjWzPU+SZpS2MbLdkilgHTxlbw/vPinDHef5N0LCU7B3/C3n1tx/Sx5fzfm60YhsG0sRU0txdI5Yrsay8Afje5fNE5ZD8is2PdkOtC5ggLdQKOzY1/+RWf/uNPqSxkcTF4/OwrWfpX/0BLWdVhv8/2IJkp8rsNjXgYWAaEgybjKyJMHVtObUUYDHi9oZ1c0WFMRQjX82hqN9iTzB/T8304FuB19M92Olp396Zz/6HOxVSeBwXHZV+7H2Yqw0EClkl73j4kLF82cxy/+MsuMgWbinCARHOGdbtTFG2XUWVBQgH/ur6xL80PVx/oPndwGdneZI4frn6DvckcRccjHOj5eyZomRTsAqbBoIWRkVJG1v25b8sWeHPrJi6/6DSCwb4/r8fbaEJE5GShMDSC6VO/kWMg1zd0vkna0Zwhk7dpz9vkbYcNe9p44Y1m7rjsdC6bOe64ZqW6r+1ozztdrZrDAYvoKIuqXJBU3sZxXAqOS7YjBFjGgU1a+9Ko4G07XuUrv/keM/btAGDthNNZfMUneHXCGX16LlwgZ7v+ZqWeR9522diQImCZmIbBW+J+m/CtjWmaMwVsx8FxvR7jPB7hkF+qZ9veYUvvOkOh40E0YBKyIJl1aE4XWb+rlepoiGljy4mGLHa1ZrEMg0jwQFg+bUwFryaS/GnbfoqOw5amdMcMionj+o99ck0ZZ02qYktTusean+4htzwUoKYsRHvOJpktEioP9QgjBduhYHtMq60YtDAylDvBDbTO595xwmT3Bo65NG4gGk2IiJwMFIZGqL586nfq6KFTCy/HbyDWN3S+SdrRnKElnSdXdKmIBIhFgxRsh72pHA889zrxmihnjIv1u+tW97UdnQ0XgtaBX1cBy8B2XNJ5m3y3hgR97dQ2rm0fX/zdD3jPhucBaI7G+Jd33MjPz7oCzzCP8t0H8fw1Oy4GLtDUnmfyqDJS2SKbG9qZWB3hnCnVNLXl2ZPMEq8x2dbURqI512v3t74wwG/OgEHQNKiptNiTKvS4L8vwgxAYHHhIHjnbI2DCWZOrqIgE2dWc4eVECyHTYMrociZWl3HuKdVcPH0M8VFlmKbBmRMq+cXaXbRmChRsl/KwhetBS6ZIKGAypiKEaZqHNCDoPvNcFvQ/bNnXXiDfsVluRSTQMSPksjeVZ0IswvvPjQ/qG+zeXpMhy2RKTRnnnTKKcMDCdb0R/SZf+xWJyEiiMDQCHctGnHJ8hlsZ4q7WLFsa28jkbb+bW7dP9yPBAONjBk1tef7z/3Zx11WVmKbRr1mp7ms7QpZJwDQpOi6u69GcLnbNRuV76czWea+9hYygU+QjL/0Xd6x+nPJiDscw+ek5V3Pv2z9EMtq/2VDX89tXBwMmlUGTbMGhYLuMi4WZUhPtePPvh8B508Ywd3IVP/zjGzS1+aHgWGeIDCAcMBlfFemamRtdGSFne+Rsh6pIwP9z0cFxXexuLbU7y9MmVJhkCg4b97ZTdFxClknOc3m9qZ3t+zP8+Y39/HZjI2+Jj+KKWePYuKfN/9AkaLJtX5qi7WKa/noj0zTY115g6mivRwOC3maeq8uCVJX5a3UyBZu2vE3BLlKwXcbHItx+2eldZZaDqftrcsPeFC+90UxjKscv1+5i1fq9I36GXPsVichIojA0ApV6I86RYjiWIaYLNi1ZP4xURAKHvH5CAZNQwDzkU+NjnZXqvrZj+thyaspC7GzNkC34M0EuEA1a5Ipuj9DTMRGC10vAuOSNl/nKsw8xrXknAP838UwWX/kJ6sdNO7Yn4SBGR79qyzAIBwM4rv8mf6wX4r3nTqIyHOwRAgH+sHkf63YnCeSLtBc8TNOfxbGdA00eLMP/r9At7wUNCAUtLNPfx8cyYVR5iCtmjePFbc3sSmYJBUzyqXxXi23LBMc9sAeRZRrkbGhrzeJ5HrFIgKLjks45ZAoO42NhwKMlXWDdriSbG9pIF2xOr63AdT3SeYdgwCASsAgFTAqOP8vTlrMxDL873L62fK/7Eu1J5rBMg9NrK2jJFGjNFjANk+m1FbzvvEmcMS52XNfiWJimQd52+P2mpm7jDGhdDCOj0YSISCf9JhuBSrkR50gxXBcfl4cCWAbkbaerK1x3RcclFDBxPfe4PjXuvrZjS1OacbEwG/cmSeVsDPwW0rbjB6GO/gGAHySMg4LQxFQj9zz3fa7eXAdAU1k137z0Jp6c885jL4nrRcAy/TI5z6Po+G20HcfFNEwqw8FeQ+D7z5/E7zc3sj1rd+yPBN2fLRP8NtcGGK7fhtww8GefIhZFx6M1W8QAqqJB1u9M4uE3UWhM5bEdl0jAJFPwG0x05ikDsB2PlOsRChhEQgEMA7JFF8f1cDy/zC8atMgUM8Rrouxrz9PUlmfGuEos06A2FqGpLUcoYmIYBkHL9MsVbYeWTJE5E6tYu6P1iDPPoyvC3HjxVLJFp2QzploXc3gjpdGEiAj4/+bKCNP9U7/edN+IU47dwW+yKiNBLNOgMhLk9NoKmtMFnqlvwO3rApchpPNNUsH2KNg9w7LnebTnbCojAaqjoeP+1LhzbceciVU0tufJFFwMDL8hAB52R32ZR+faGLqOPSBkF/lU3Qqee+QTXL25Dtsw+cF57+GyW77Hf869bECCENDVRMDzPAp2ZxiE6UdoBGAaBuOrooQsA4NDW36bJgQCBsWO/ZjCQYtwwMR2PNpzDu15G8PzW3dPHhVlYnWEnO2Qytokc0XSef82jut3jguYUBm2KA+ZXefyHa2u8x0ldZ7nz0SBgWUaZAsO63enKA8HyBQcGttyGIbB9NoKoqEAzWm/pXjednA9f8a5pjzEWfEqtu1LH3HmeWuT3w79zPEx4jVlJQkbx7IuZqTp/DCipjzE643ttOWK2K5LW67I643tw6rRhIiIZoZGoFJuxDkSDOfFx6Zp8P7z4rzwRjN7UznGxwxCAX89T3vOJhK0KAsGOH1c5YB8ajy9tpKpf1XOtn3tlIctaspC7E/nydsejuHi2P56GNfzZz3KQyaO53HRpj+z+NmHmdqyB4AX4nP48hW3smHsqcc9poM5LhRtF9fzMPAoOh6TR0V433mTen2z2BmWy0IWbz9jDL/d0ETO7hmHPA8KHeuhLNMPTEHTxDQ8gh17F1lBv5NcLBpkU0Oa/e0F2vNFHNf/lKvzOTEMv231hKoordkC2WIBy4Si6481W3C6ygrNjp8F/oa1RdslmSkQDVkdew5FqSkPcU682t9nKJ2nNVtkdHmIt04dzfw547Bd76RYb6J1MUfW3+YnIiInG4WhEWgktZctheH+JuuM8ZXccdnpPPDc6zS15bvWCVWVBSkLBpgyuuyIr59jbSqxJ5WjPW9THQ3SnrexXT+0ex0biXbur+MBtU27ued33+edm/4EQEvVGJ5YcAffHnMeuYHoZd2hc38fDz+4FB2PYMBfMzSxqqMRwGHWv3SG5UjA5P/ebAG8HqV+nfNVnZvIRoMd5WgBE7vgkHNcwgGLcNDEMgz2JvPYrku26BK2TDzXJWCB7UJZ0CISsijaLpmiQ0U4QEu6iON6HeVxDrbrz/AZRufGrH4pXWU0yKiyEE3tBcZXRRhdEe76fRGLBjhzfAXb9hmcVlvBB986hXnTxmCaBonmzFHXm4Qsk1S2yMa9qZKVyWldzNENZEt+EZGhauT+lh/hBmMjTvGNhDdZl80cR7wmyn+8tIutTe24nkt1NMTp4yqP+Klxf5pKtOWL5IoOAcskmcuB5896BAMmruvhOR6hQp5P/fk/+Nia/yDsFLFNi/++9APUf+QOnMpK4lv28ea+DB7+uhjD80vT+tvWOhoyCXa0YM4WHSojAabXVnB2vJr3nxs/Yke0tlyRnS0Z9qZyNLbnDxmDiz8wq6MRRKbggAde2GJsLEzR8Tc7Tecdio6H7fghpzVTpCwcwPFsTMNfP+R4EDBNjKBBtmBjhgOMrgjRls2DYeDiYTsds09GZ8mfH25rykIELL9Rw+m1FXzwwin8pr6xx++LC08dfcj1PtrM8+sN7WDAYy/sIO+4JWssonUxfTMQLflFRIayk/fdmBw3feo3OEbKm6wzxsX4/NWVfX799KepxJbGNn75l11sa0qTKzrkbRfPhWDAb+FmAJdv/hNffPYR4skGANZMPZuf/t3nMGfPZl9bgeamZtJ5G9v1GwkETH9NjuEd6LLWFwHjwHok0zSpDPuNDGaMr+Sjbz+VWROqjvr3Z0tjG7/4yy427m0jV7QpOnQ1R7AMcN0D64c6J7I6/58uOJjtfslaKusQCVp4OFRGQziuX6ZnYRAOmB2d6RwKjkvRcTAMg1zRZVS5yVmTYvx5WxNlkQgTqsJs3NNG0fbIOf6arIpogHGxCKYJTW0FosEAl80c5+8bNfbo1/tIM8+vN7SzJ5VjQlWEUeWhknZv0wy5iIiAwtCIp0/9Bt5IepPV19dPfzp3dYan/e0FaivDNLXlCAdMskUX2/WYsj/B3b95mHdsfQmApuqxLL/6VlbNvISz4qNo2pcmW3CoiAQIWWH2txcoOJ6/pqajN0jA9BsfdAaOgAmdWxeZhl+iFrBMch2lXQHLIGe71FaGGRcLM6Yywqcund6nvXE6H0+iOY1lGvgrjLyujWI7W2H3xsAPS5miQ95xGVdpMb22nE172whaBnh+Y4l80e0obwvSkMzRnCnSnvfHHg2aTBtbge3C6aNCnB4fSzJbZH97kdZsgUllUSzDwPX8NT8BxyAcNHn79DFcPG3MMV3vw21sigETqiK8JV49JLq3aV2MiIgoDIkMAr3J6ulYm0p0D09njKtgbGWIl3e4pHI2ZjrDJ//0c25+4UlCjk3RCvCLd97Aj9/5QULVlYwtOLzRlMYw/DfajtvR5c0yOpoteESDFqZpUHQ88rYDjh84TMMgaHoETJPySICQ1TFWDyJBi0JHd7d03mbOpHF84PzJfbqW3R/P5FFlbNjThusd6IZ3JKYBsbCFi0HQ8lcYRYMmbbkiHlCw3a41Rx4wqixIWSjAhOqoX44ZsWhOF6guC1EWtJhWW058ssM1l5zJ3rYCG/ak+PW6PeSLDhOqItiuR1vOpiVTYFJ1lL+9cEq/wsnBM8+pbJHHXtjBqG4b9XYqZWMRzZCLiIxsCkMig0Rvsg441qYSB4enmvIwb4lX8fZXf8/fP/EAE1NNAKw5/Xy+//47eXP0ZCJBi/JQkOm1lazeso903qE5XQQ8PNdvJe23qDYo2B7RUADLdgmaJpmijWkYTBtbTtHx2NmSJWgZGIaB7XoELJPxsTCt2SKxaJTR5WH+3zkT+xxquz+elnSBXNHtWhd0pL4OluGv53E8CAf88BYJ+c0qZoyLsa+9SEMqRywSYFxlmGS2yL62PFVRh4LtUVsVZkx5iBnjY/zN3AnMnBBjfGWIV199pWuWJ15Txmljy7uCe952Drse6Fh1n0nauDdF3nEpO2itnOf54StbdGjJFGjLFfv98wZinCIiMrIoDIkMIr3J8h1rU4mDw9OoHVu57rtf45SX/Y1Td1fX8rXLPsbLb/krKstCVEUCXZ3spteW89uNjbiuh4vX1TbaMPwZmtrKCJmCw6yJVYwtD5PK5fnTGy0ETJN3nD6W3akcDakcmbxDOGhScDzCAYPmdB7LNKkM+zNG5eG+//rsfDzRYIQNqRyW6Ze1BSwD1/P3+ulNZ2lZtuiv/3Fcf2PXxrY850+t4a9mjOWR57expbGdbNEhX/SbKjS25wkHTCojQaaOqeB9503q6m7XW2OU3oL7hFiEPancgHV86+010JzOs7UxTXOmQLZo47rwy5d3EwqYI272VERESkNhSEQG3bE2leh842y3Jrn0Px/mLU/+CMuxsYMhXlpwC09e8UFebypyamWYcNDo6mR3+rgKHv79VtpyRRznwFog0/D/K3guieYsYyvDBEyD9buT7EnmAL987jcbGpk9KcaU0WW8uS9DpuDgulC0/fsygT2pPFWRAP+2+g3+7m2n9OlNe1nQwnE9Xm9oozGVZ3wsTKLFpWC7HClfFFx/BsnDb+dt4Jfr5YsuT63fw3vOnojRUbZnux5By8AyIO+A43jsTmbZ0tjGb+obMQ3jiGPtHty3NLbx0PPbjqnr39Ec/BpoyRRYm2glW3AoD1sUbZPqWJAdzWl+uHr7CW2mICIiI5fCkIgMumNtKjGpKsJV637HW//1G1S3+CVxW9/2Tn7/8X+idUKctsZ23vuWWt519gSyRYfyUIBsweG7/7uF7fszXU0ROjcdNTr+4LkemaJDtuDw8o5WHNdjQnWEM2oraUkX2LA3xYtvtDC+KkJFJEAqa+N6LsWOdTmmAdFQgIBl8uyGRpraC3z68tOP+KZ9S2Mbq9btJdGcpSGVJW+7VEWCjK0M0diWJ1c4sOFq9/2GDPxud0bXnz1Clkl5OMDkUVFyBZsfrn6DhlSeMRVhKsIWmaLrz2BZHq7r4bgeLZkC63a1dnVrO3X0kWcq+9P171hfA5sb2mlqy5HJ21REgqTzNmXhALMmVDGqLFiSZgoiIjIymUe/iYjI8etsKjFnYhWtmSLb96VpzRSZO6mq5xvs9esxL7+MK//5s1S3NNFUO4nH7vkuT375X9lZM4HXG9upKQ8xf844ThldzpnjY0yqjvKb1xrY15bH6diBtTMEGR379eD5m5gaHpSFLKbURLly1jhmjq/kzf0ZtjdnsEwoOA6ZvM3EqkjH5qX+/ZmmgWkaWKbB6PIgoYDJ5oY2nl6/F9ftvcytM1jU70kxY1w5lZEgtuPRmi3QnrepKQthmf4vYsuAoOn/PxIwsDp+O3c2RghYBlXRINVlIabXVhKLBtna2E7BdqiMBgkH/XDpelAWChANB3A9SGZsxsciNKcLPFPfcNixwqFd/yojQSzToDIS5PTaij7dR19eA1NqojS25XE8yNsutbEI58SrqelortC9mYKIiMhg0syQiJwwR2wqkUzCl78M3/kOOA5uNMrWm2/nyXfewN48FPalD9uRr7NBQXU0SMFxMQyDsGXguF5X1zbH8/cnMjBI5WzOPSWK43m8sjPZ1YK7MhIhHCiSaMkQtMyOYOVhWobfac7yGyq0ZG1Gl4doz9u8ujPZawe07sFidHmIrU1p/JTmt8DO2y5lQZfKSJBYNEhrpkDedol1rElKZorYrj9rFA1ZjIuFmVDll5rVlIdoSPnriAKWSdAyKNgu2aJDKGD6+xZ1zDMVXZei63UFjN3JwweMY+3619/XwHvPncTmxjbGx6JEgxaVkZ6lkwc31BARERksCkMickId0lTC8+AnP4FFi6DB3zh16yVX8LMFn2bPqHGE8zC2MsL5U0cxc0Ks14X8nQ0KKiMBLMMgj79JqhUw8Tx/XZLtuIRME9MwcFwXyzDY2ujvRVTTrd1zZwgqOg6266/pCZh+W26/tbZBe65ITZnfBCBTtHt9094ZLKJBsyNw2VSXhSkPB9jdkiNbdLBdj8qoRVnIwvWC5IsuZWELyzAIWCZmukAkZDHvtNHUlId7hIbOsjnTgKLj4Xh+8LMMf0rJ8TzAIGia/j5DnQEjf2gDhYOfx752/euvynCQmrIwZSGrTw01REREBov+pRGR0lm7Fm67DVavBqAwbTo//eDn+PMZFzChKsJpoQCZgk2iJUO6YHPa2PJe15B0NlzwPIhFg2Rtf2PWgN+MDRfwDAOrY/NRPGjL2TRnClQcNCuR6wgpQcug6IDtgeMdWNeD4XVsTOqfKwsGen3Tni7YZIs2Leki2YL9/7d399FRlnf+xz/zkJk8zhCEIOAABQQlCUtttSW2uio/Cba1v1LPBntsK7aIPYq0lrRWhbbarbVQKz6clsZd1j3ulvS0ntNtK1Nrf263OnR96KGGQQWxyCCRECAzySTzfP/+uJ0xIQlkQpLJZN6vczx637mTuSaXk+Qz3+v+XpnA5bRb5ZlsVXtXRCfCcYWjCRmGodnnlGne1HIV2axmxcci+d46IYukWZNLZbW+v6o53Y56XlW5joai6ozEVe6wmUHPMGSTRdF4UlarRVUuM0R1RRNmwHDaNFhtKNuuf8OVbUMNAABGC/cMARh7J0+aIehDHzKDUFmZUvffr3957Nd6ccHFWd+vkv7jOhRJaOakYpXYrWYIMsx7fhIpQyV2q8odNpU7izRvark6emKKJ5MqsvUNGeGoWfWwW8xqkPHePUdWi7lUzjCkWMJQR3dcNqtFi88b+I/2ModdqZR0rCuq8uKifsvAplY4VeVyas6UMlXPcMtdYt6HVOq0yWm3qq0rpoXnVmjBuRV681hYnRFz2VxnJK79bV06p9yp1Zd+QAvPrVAskVJHT1x2m0U90YTC0YRShnROmTOznLA1GNH8qnLNcA8eMNLfx9ZgRIbR9/ucDinzq8rPOqSkmylMLnNof1tXv+d2akMNAABGC5UhAGMnlZL+7d+kO++Ujpld4vRP/yT96Ed6p3Sy9v9h37DuV+ndqSwcS6iyzKH2zojZmc1qldNqVWmRVRaLRQvPrdBnPjhT/7X7iP7e3q2wPaEyp13xZEpdkYRKHHaVFJkd56wWyWa1KvHeHj/WdDMGSd2xhC6eU6nlNecO+Ef7zEklmu4u0e7DHaos7VtlMUNXUjMmlWhyqUP/94Mztf9olw4c69LRUKTPvVGSMhuinvqx+VUVmn1Oqf7zL4f0l7+fUE88okTKkM0qeSaX6h88k1Rksww5YGTb9e9spJspnO65AQAw2ghDAMbGyy+b1aD//V/zeNEis1nClVdKksLvhs7qfpXef1w77Wa150Q4JhnmpqmVZU4tnTtZ139kluZXVchTWar7frtXB451KZYwGxFUuYo1raJYL799Ql3RhOxWi8odNvUkzKYH6X2L7FbpnFKHrr9k1qB/tFutFi1bVKU/7WtTe2dUk8ocKrJZe4Uum2a4iyVZdOF0l5ZdOG3gxhLS4E0n3nve93xykQInu/X39rBaO3r01rGw2ruiCvXEFY2n+gSMgTZdHez7ONoh5bQNNQAAGAOEIQCj6/hx6a67pKYms6xSUWF2jVu3Tip6v2IyEver9P7jujMSV2ckrnAsKavFog9MKZOnsjTzh/aCcyu08VMX6rHnDuh4V1TT3cWaWuHMVITsNotcxXalDIucNrMJgc0iWaxWnTepWNPdJZpS4TztU6+bN0VXXFCl5/e3qyeWVNhIyGY1Q9fcKaU6Ho5n7o3p11iil9N9LP3x2eeUafY5ZZLMTnZnEzDGMqSc6bkBADCaCEMARkcyaQagu++WTpwwz91wg/TDH0rTp/e7fKRuqs/mj+sF01xad+X8TBXk7ePdctpt+sjcc/TCm+2yW60qc9hksUpGSoomUyp12DV3apkkyxkbCVitFn3uI7MUiaf0Tke3KksdchUXyWaV3g1FR+3emJEIGIQUAEAhIAwBGHl/+Yu5JO6VV8zj2lrpscekj3980E8Zy/tVehuoCjLdVazvP/2anj/QrpRhKJEwZLdaNc1VrLlTynQ8HBtyt7P5VRW66WPvLzs7Ho5ybwwAAOMEYQjAyGlrM5sjbN9uHrvd0n33SV/5imQ/84+bkbxfJZulYlarRTMnlWSubw1FtOojHkUSSb3T0aPKUocqiu2yWy3DquiM1LKzs13+BgAA+iIMATh7iYT0059KGzdKHR3muRtvlH7wA2natKy+1KnBobTIJkNSTzypt4+HZZHUHU+eNgy82daZCVSRRFLFdpvmTS3X8pqBA9Vg11914TS93tqpA8e6dCIcO6uKzlCXnQ0WeLJ9TkN5nCPBboIVAKCgEYYAnJ3nnzeXxP3tb+bxRRdJjz4qLV067C+ZDg5vtnXqN39r1YFjXWrviqq9KybJ0JRyp6aUOwcMA2+2dWr7Cwd1IhzTdHexSh0l6o4ltOdIUEeCPVp96Zysrv/i0jm61jFjTELDYIHngukV+n+vtw35OZ3J4VBCvv95S39v7x6RYAUAQL4iDAEYntZW6RvfkJ580jyurJS+/31pzRrJZjvrL987pJQUWXU8HFM4mpBFho5bpCnljn5hIJUy9Ps9R3UiHNP5VeWZJgwVxUUqd9q1v61Lz/iPau6UclmtliFd/+xrR3XL5fNGvWrS+/me63KqPGVXKBLX//79uH7vb5W7xKEPzpp0xud05sfp0u/2h2UtsWnGpJKzDlYAAOQz65kvAYBe4nHpxz+WFi40g5DFYgagffukW24ZkSDUO6TMn1qm1mBU0XhS01xOVbmKFY2n9G4oqvlTy3QiHNMz/qOZ5WUHjnUNaeNWSVlfP1p6P99zyhx6/d0uvXjwhPa8E9Th9/YPOt4d7fd52Y4xlTL0zN6jCsVSOr+qTBXFRbJZLaooLtL5VeV9vpcAABQCwhCAofvv/5Y++EHpjjukzk7pkkvMTVR/9jNpypQRe5jeIaUrmtTJ7pjKi4tksVhksVhUXmzXiXBMXdFknzAQjiXe27h14KJ3icOmaCKZ2bg12+tHS/r5lhRZ9bfDQR3rjKi4yKbKMoeKbBbFkikdOt6t11tDMoy+QSWbMZqPE9aUEmtOwx8AAOMFYQjAmR0+LF1/vXTFFZLfL51zjrmH0K5d0sUXj/jD9Q4psWRKiWRKRbb3/3gvslmVTKUUS6b6hIHeG7cO5NSNW0+93jAMhXriau+KKtQTV3c0ccaNXkfq+fbEEzrSEVFPLKHJZQ457VZF4ykFexJKGYa6Y0m9ePCkXjp4QifCsUGf05keJ5pIymkfeDndWIU/AADGC+4ZAjC4WEx66CHp3nulcFiyWs2lcPfdJ02ePGoP2zukOGxW2W1WxZNG5o/4eDIlm9Uqh83aJwxku3Fr7+tjiZQOHAvrZHdMiWRKdqtFKUkfnz9lSPsJne3zTaWkY11RVbxXAeuJJfVuKKJ4MqUiq1WpVEopI6UjHRF1RZNa4pmkytKiIW9Gm34cp92maHTgZXDZBCsAACaCnFSGAoGAmpqa5PV61dTUpFAoNOi1fr9ffr8/83np/wYwyv7wB2nxYumb3zSDUF2d9PLL5uapoxiEpPdDSmswonKnTZWlDnVF4jIMQ4ZhqCtiVk/KnTa1BiOaX1We6fK2vGaaJpc5tL+tS52RuBKplDojce1v6+q3P1D6epvVoj/tO6YjHT1y2q0qddjUGU0o1BPX34+H9WZb16g/3+nuEnVFE7JbzeB2IhxVPJlSsd0Mg067VcmU5LRb1B1NaG9rUPuOdma155H5fS1Te0+q33K7dFhMfy8BACgEOQlD69ev15o1a1RfX6/6+nrdc889g17b3NyslStXauHChdq0aZM8Hs8YjhQoQIcOSdddJ119tfTGG+Y+QU88If35z+b9QmOgd6h581hY091OOYtsOhqKmhuxFll1rsupN4+F+4WB9MatNTPc6uiO62B7WB3dcdXOdA/YKW3ulHJVVThVUmRTcZFVJ7tjOhKMKJowl+a93tqp+367V/uODv6mzUg832WLqlRaZFN7Z1Sd0YR64knZrBZFEikVF1l1rrtYJQ6bkikpaaTUFopq9jllWXV/s1otunrRNLkcVu1vC58xLAIAMNGN+VqIQCDQ59jj8WjXrl2DXl9dXa2XXnpJkuRyuUZ1bEAhs8Risnz/+9L990s9PWZXuNtuk777XcntHvPxpENNet+dc8ocMgzJIkPnlDklWQbdAPXUjVtPtz/QOx096uiO69L5U9TRE1PLO0FZJFWWOlRktyocTejAsS499twBrbty/qi1na6bN0VXXFCl5/e3qyeaUCSektNuVZnTrsrSIvXEklpQVaEF55YrEk/paCiiTy+ZkfV45leV6xPnl+lQyqW/t3eb4fIsNpMFACCfjXkY8vl8cp/yh5Xb7Zbf71d1dfWAn0MIAkbZ009r0a23ypp+s+Kyy8yNU2trczqsU0NNSZFNFknd8eQZN0BNb9x6JulmDdMdxXrj3ahkSNNc77faLnPaFUukdLwrmtV+PtmyWi363EdmKRJP6cCxTiUN87GL7VZ1RRMqcdg0r6pM7hKHrJa4KksdqiguGtZjneey65rFc/VuZ2xMNpMFAGC8GvMwNNj9QcFgcNDrvV6vJKmlpUWrVq0adKlcMpkcmUFC0vvfT76vE9hbb8l6xx2y/fa3skkypk+XsXmzjIYGc/+gcTL3M9xOSc5+5w0jddZDLLFb5LBZ1Rbq0fFwVOVO+3tf27ynJpYwmymc6yrWvqOdCpzo0nmVZw5Zw/GBc0r1xaWz9Hv/u9q556hOdsfkKrZraoVT86aWqbK0SKlUUkc6elQz06VzKxxZvz7T1xtGqs/3dSS+lxh/+DleOJjrwsFcj6xx0zJosJDU0NCQqQx5PB6tXr1azz77bL/rYrGYdu/ePZpDLFgtLS25HgJGmCUS0blPPKFzn3hCllhMhs2mo5/7nFq//GWlysqkv/0t10McMynDUGkirD1tUXV1J2Uttioms0JiGIY6Y4YqS6xKhU/oaDilV16Nqt09vIrMUC2dZKh8gU1/eEuKJOKabE2pJxjRWycMtfek5HJY5bEk9eqrw58nXteFhfkuHMx14WCuBxeNRuV09n8TdSBjHoZcLle/KlAwGBx0KVwgEMgsn/N4PAoEAgoEAv2qQw6HQ0uWLBmVMReqZDKplpYW1dbWymaz5Xo4GAmGIf3mN7LecYcsBw+ap668UvEHH9Q7iUTBzrVrZpce++8Daj94UhZ7kUqdNsWThrqiCU2qsOkfPG4V2axKlcT1ocXzR60y1NtFki5t69Ize4/qwLGwehJJOYpt+tgHyvR/Lpym+VXlw/q6vK4LC/NdOJjrwsFcn9lQg5CUgzBUV1en5ubmfudramr6nfP7/brxxhszDRTSTr3nKI3/IUaHzWbjezsR7N8vrV8v7dxpHp93nvTgg7Jcd51sqZS0e3fBzvXC6W7ddsX5uu+3e3XgWJdiyZTsNqumuYo1b2q5KkuLtL+tS7Uz3fJMHp17hgYb1/nTXENqBJGtQp3rQsV8Fw7munAw1yNjzMPQqRWdQCCgmpqaTGXI7/fL5XLJ4/HI4/Fow4YNmWt9Pp+WL19OQwUgG+Gw9P3vS1u2mJuoFhVJGzZId98tlZXlenQ5l0oZeqejRykZ+vJlH9CvXnlHJ8JRTXcXa2qFU5F4Kqdtp4faCAIAAGQvJ/cMbd26VZs3b1Ztba1aWlq0devWzMe2bdum2tparVmzRi6XSzU1NZlK0qFDh/Twww/nYshA/jEM6Ve/ku64Q0p3iauvl7ZulRYsyO3Yxok32zozrbsjiaSK7TZNKXNoSrlDHd1xvX28m7bTAABMYDkJQx6PR42NjZKk+vr6Ph87NexUV1cP2nIbwCBee026/XYp3WxkzhzpoYeka681u8RBb7Z1avsLB3UiHNN0d7FKHSXqjiXUGoyosrRIKy+aqSkVzrxrO52udNEyGwCAMxs33eQAjIDOTum++6Qf/1hKJCSnU/rmN6U775RKSnI9unEjlTL0+z1HdSIc0/lV5Zk9hSqKi1TutGt/W5dePRzULZfPy6sgMVCla97Uci2voaoFAMBACEPARGAY0o4d5r1AR46Y5z71KTMUzZuX27HlwJmqI+909OjAsS5Nd7+/uWqaxWLRdHex3mzr0jsdPXlzv85gla49R4I6EuzR6kvnEIgAADgFYQjId3v2SLfdJv3pT+bxvHnmfUGf+ERux5UjQ6mOhGMJRRJJlTpKzL2EIgnFkik5bFZVFNtV4rDpaCiicCyR42czNEOpdD3jP6q5U4bXjhsAgImKMATkq2BQ+s53pEcekZJJcxncXXeZ1aHi4lyPLieGWh0pc9hVbLfpSEe3WoNRneyOKfFeO+3KUoemu51y2m0qc+THj8hsKl0z3EPfewEAgInOmusBAMiSYUj//u/SwoVmU4RkUlq50myacM89BRuETq2OVBQXyWa1qKK4SOdXletEOKZn/EeVShmaOalEk0qK9NLBk2rrjKi4yKbKMoeKi2xq64zopYMnVVlapJmT8uM+q/crXQOHtxKHTdFEMm8qXQAAjBXCEJBPdu+WPv5x6YtflI4eNVtk//73Zgvt2bNzPbqcyqY6Yp5874OGIclIH7x3/P6ZfJCudHUPEnZ6Ysm8qnQBADBWCENAPjh50rwv6EMfkl54wdws9Qc/kFpapKuvzvXoxoVsqiPvdPSoozuui+dUapqrRJF4Sh3dMUXiKU1zl+jiOZXq6I6/H5zGuZmTSjRvarlagxEZRt8YZxiGWoMRza8qz5tKFwAAY4W3CYHxLJWStm83W2O3t5vnGhqkLVuk887L7djGmd7VkYrion4f710dSQenuVPKdV5lab8GCknD0MH2cN4sK7NaLVpeM01Hgj3a32ZWx0ocNvXEkmoNRjS5zKGrq6fJarUomcz1aAEAGD+oDAHj1csvS0uXSl/+shmEFi2S/vhHs4U2QaifbKojvYOTxWKRq6RIU8qdcpUUyWKx5OWysvlVFVp96RzVzHCrozuug+1hdXTHVTvTTVttAAAGkT+/6YFCcfy42RWuqcm8f6Wiwuwat26dVNS/4gFTNtWRdHDacySocqe9zz1G6eBUO9Odd8vK5ldVaO4/lp92jyUAAPA+whAwXiSTZgC6+27pxAnz3A03SD/8oTR9em7HlifS1ZH0PkNHQxE57TbVznTr6ur39xnKJjjlG6vVkjcbxQIAkGuEIWA8+MtfpFtvlf76V/N48WLp0UfNznHIylCrI0MNTgAAYOIiDAG51NZmNkfYvt08drul++6TvvIVyc7Lc7iGWh1hWRkAAIWNv7aAXEgkpJ/8RNq4UQoGzXOrV0v33y9Nm5bbsQEAABQIwhAw1p5/3lwS9+qr5vFFF5lL4pYuze24CtCbbZ2ZZXKRRFLFdpvmTS3X8hqWyQEAUAhorQ2MldZW6fOfN+8DevVVqbLSrA69+CJBKAfebOvU9hcOas+RoCaVFmnulHJNKi3SniNBbX/hoN5s68z1EAEAwCgjDAGjLR6XHnxQWrhQevJJyWKRbr5Z2rdPuuUWyWbL9QgLTipl6Pd7jupEOKbzq8pVUVwkm9WiiuIinV9VrhPhmJ7xH1UqZZz5iwEAgLzFMjlgND33nLk/kN9vHl9yibkk7uKLczuuAvdOR48OHDNbavfeY0iSLBaLpruL9WZbl97p6KFNNQAAExiVIWA0HD4srVolXXmlGYSmTJEef1zatYsgNA6EYwlFEkmVOgZ+P6jEYVM0kVQ4lhjjkQEAgLFEGAJGUiwmPfCAdMEFUnOzZLWazRLeeEP60pfMY+RcmcOuYrtN3YOEnZ5YUk67TWWDhCUAADAx8JseGCnPPGMuidu3zzyuqzOXxH3wg7kdF/qZOalE86aWa8+RoMqd9j5L5QzDUGswotqZbs2cVJLDUQIAgNHG29TA2Tp0SPrsZ6Xly80gNG2a9MQTZgttgtC4ZLVatLxmmiaXObS/rUudkbgSqZQ6I3Htb+vS5DKHrq6exuarAABMcIQhYLgiEemf/9lcEvfUU2ZXuK9+1VwS94UvmF3jMG7Nr6rQ6kvnqGaGWx3dcR1sD6ujO67amW6tvnQO+wwBAFAAWCYHDMfTT0u33y4dOGAeX3aZuSSutja340JW5ldVaO4/luudjh6FYwmVOeyaOamEihAAAAWCMARk4623zOrPb35jHs+YIW3ZYnaOoxKUl6xWC+2zAQAoUCyTA4aip0f69relRYvMIGS3S42N0uuvS9dfTxACAADIQ1SGgNMxDOm//susBh08aJ676irpkUekCy/M5cgAAABwlghDwGD27zfvC/J6zWOPR3rwQbNzHJUgAACAvMcyOeBU4bB0991STY0ZhIqKpG99S3rtNem66whCAAAAEwSVISDNMKRf/Uq64w4pEDDP1ddLW7dKCxbkdmwAAAAYcYQhQDKrPrffLj37rHk8Z4700EPStddSCQIAAJigWCaHwtbZKX3jG9LixWYQcjrNrnF790qf/jRBCAAAYAKjMoTCZBjSjh3Shg3SkSPmuU99yqwGzZ2b06EBAABgbBCGUHj27JFuu03605/M43nzzPuCPvGJ3I4LAAAAY4plcigcwaC5X9CSJWYQKimR7rvPDEcEIQAAgIJDZQgTXyolPfmkeW/Q0aPmuZUrzT2DZs/O7dgAAACQM4QhTGy7d0u33ir5fObxwoXSww9LV1+d02EBAAAg91gmh4np5EnzvqAPfcgMQmVl0g9+IL36KkEIAAAAkqgMYaJJpaTt26U775Ta281zDQ3Sli3SeefldmwAAAAYVwhDmDheftlcEvfii+bxokXSo49KV1yR23EBAABgXGKZHPJfe7u0dq10ySVmEKqoMJsj7N5NEAIAAMCgqAwhfyWTUlOTdPfd0okT5rkbbpB++ENp+vTcjg0AAADjHmEI+WnXLrNBwl//ah4vXmwuifv4x3M7LgAAAOQNlskhv7S1STfdJNXVmUHI7TZbZb/yCkEIAAAAWaEyhPyQSEg/+Ym0caMUDJrnVq8222VXVeV2bAAAAMhLhCGMf3/+s7kk7tVXzeOLLpIee0z66EdzOy4AAADkNZbJYfxqbZU+/3npssvMIFRZaVaHXnyRIAQAAICzRhjC+BOPm62xFy6UnnxSslikm2+W9u2TbrlFstlyPUIAAABMACyTw/jy3HPmkri9e83jSy4xl8R9+MO5HRcAAAAmHCpDGB8OH5ZWrZKuvNIMQlOmSI8/brbQJggBAABgFBCGkFuxmPTAA9IFF0jNzZLVKt16q/TGG9KXvmQeAwAAAKOAZXLInWeekdatM+8Fksy9gx57TFqyJKfDAgAAQGHgbXeMvbfflj77WWn5cjMITZsmPfGE9PzzBCEAAACMGcIQxk4kIn3ve9KFF0pPPWV2hfvqV80lcV/4gtk1DgAAABgjLJPD2Pjd76T166UDB8zjyy+XHnlEqq3N7bgAAABQsKgMYXS99ZZ07bXSJz9pBqEZM6T//E+zhTZBCAAAADlEGMLo6OmRvv1tadEi6Te/kex2qbFRev116frrWRIHAACAnGOZHEaWYUi//rX0ta9JBw+a55YtM5fEXXBBTocGAAAA9EYYwsjZv1+6/XbJ6zWPPR7pwQfNznFUggAAADDOsEwOZy8clu66S6qpMYOQw2Eev/aadN11BCEAAACMS1SGMHyGIf3yl9Idd0iHD5vn6uulhx+Wzj8/t2MDAAAAzoAwhOF57TVp3Trpj380j+fMkR56yOwcRyUIAAAAeYBlcshOZ6fZFW7xYjMIOZ1m17i9e6VPf5ogBAAAgLyRkzAUCATU1NQkr9erpqYmhUKhIX3epk2bhnwtRphhSD//udkRbssWKZEwq0B790rf+Y5UUpLrEQIAAABZyUkYWr9+vdasWaP6+nrV19frnnvuOePn+P1+NTc3j8Ho0M+ePdIVV0if+5x05Ig0b570u9+ZLbTnzs316AAAAIBhGfN7hgKBQJ9jj8ejXbt2DenzPB7PaA0LAwkGdd6PfiTrL34hJZNm9efuu6Wvf10qLs716AAAAICzMuZhyOfzye129znndrvl9/tVXV094Od4vV7V19dry5Ytp/3ayWRyxMZZ0FIpWZ58UtY779S0tjZJkrFypVKbN0uzZ5vX8L2eUNKvHV5DEx9zXViY78LBXBcO5npkjXkYGuyen2AwOOj1LpfrjF83Fotp9+7dZzM0SCp54w3NeuABlb/6qiQpMnu2DjU2qvOjH5VOnjT/wYTV0tKS6yFgjDDXhYX5LhzMdeFgrgcXjUbldDqHdO24aa09WEjauXOnGhoazvj5DodDS5YsGeFRFZCTJ2XZtEmWbdtkSaVklJUpeddd2nvllaq56CLZbLZcjxCjKJlMqqWlRbW1tcz1BMdcFxbmu3Aw14WDuT6zoQYhKQdhyOVy9asCBYPBAas/Pp9PK1asGPLX5n+IYUilpH/9V+lb35La281zDQ2ybNkiy/TpMnbvls1m43tbIJjrwsFcFxbmu3Aw14WDuR4ZYx6G6urqBuwKV1NTM+D1O3fuzPx3IBDQtm3bdM011wx6fxGy8PLL0q23Si++aB4vWiQ9+qjZOU7iviAAAABMaGMehk7tCBcIBFRTU5OpDPn9frlcLnk8HtXV1fW5dtOmTVq1ahVd5c5We7t0113S44+b+wdVVEjf/a50221SUVGuRwcAAACMiZzsM7R161Zt3rxZXq9XO3bs0NatWzMf27Ztm7xeb5/rQ6GQNm/eLElqamqS3+8f0/FOGMmk9NOfSgsXSk1NZhD6/OelN96QvvY1ghAAAAAKSk4aKHg8HjU2NkqS6uvr+3zs4Ycf7ne9y+VSY2Nj5nMwDLt2mZWfv/7VPF68WHrsMeljH8vtuAAAAIAcyUllCGOorU266Saprs4MQm639Mgj0iuvEIQAAABQ0MZNa22MsERC+slPpI0bpXT3vptuku6/X6qqyu3YAAAAgHGAMDQR/fnP5pK49zZO1UUXmUviPvrR3I4LAAAAGEdYJjeRtLZKN9wgXXaZGYQmTzYbJrz4IkEIAAAAOAVhaCKIx6UHHzS7xP3Hf0gWi3TzzdK+fdLatRIbcgEAAAD9sEwu3z33nLkkbu9e8/gjHzE3Tv3wh3M7LgAAAGCcozKUrw4flhoapCuvNIPQlCnSv/yL5PMRhAAAAIAhIAzlm1hMeuAB6YILpF/8QrJapVtvNZfE3XSTeQwAAADgjFgml0+eeUZat84MPpJ06aXmkrglS3I6LAAAACAfUUbIB2+/LX32s9Ly5WYQmjZNeuIJs4U2QQgAAAAYFsLQeBaJSN/7nnThhdJTT5ld4b76VemNN6QvfMHsGgcAAABgWFgmN1797nfS+vXSgQPm8eWXm0viampyOy4AAABggqAyNN689Zb0qU9Jn/ykGYRmzJB+/nOzhTZBCAAAABgxhKHxoqdH+va3pUWLpN/+VrLbpcZG6fXXpVWrWBIHAAAAjDCWyeWaYUi//rX0ta9JBw+a55Ytkx55xGyfDQAAAGBUEIZyad8+874gr9c89nikH/9YWrmSShAAAAAwylgmlwvhsHTXXVJtrRmEHA7z+LXXzBbaBCEAAABg1FEZGkuGIf3yl9Idd0iHD5vnVqyQtm6Vzj8/t2MDAAAACgxhaKy89pq0bp30xz+ax3PmSA89JF17LZUgAAAAIAdYJjfaOjvNrnCLF5tByOk0u8bt3St9+tMEIQAAACBHqAyNFsMw9wfasEFqbTXPXXut2SBh7tzcjg0AAAAAYWhUtLRIt90m/c//mMfz5kkPPyxdc01uxwUAAAAggzA00l5+WVq6VEokpJIS6e67pa9/XSouzvXIAAAAAPRCGBppdrtUWSldfrm0ZYs0e3auRwQAAABgAIShkbZkidTWlutRAAAAADgDuskBAAAAKEiEIQAAAAAFiTAEAAAAoCARhgAAAAAUJMIQAAAAgIJEGAIAAABQkAhDAAAAAAoSYQgAAABAQSIMAQAAAChIhCEAAAAABYkwBAAAAKAgEYYAAAAAFCTCEAAAAICCRBgCAAAAUJAIQwAAAAAKEmEIAAAAQEEiDAEAAAAoSIQhAAAAAAXJnusBjIS2tjYlk0ldddVVuR7KhBONRuV0OnM9DIwB5rpwMNeFhfkuHMx14WCuT6+1tVU2m21I106IypDT6ZTdPiFy3bjDC61wMNeFg7kuLMx34WCuCwdzfXp2u33I3yOLYRjGKI8HAAAAAMadCVEZAgAAAIBsEYYAAAAAFCTCEAAAAICCRNeBAhcIBOT1euXxeBQIBNTQ0CCXy3XGz9u0aZM2bNgwpGsxPmQz136/X5JUXV2tQCCgUCik6urqsRwuzlK2r22fz6dAICC32y1Jqq+vH6uh4ixlM9der1d1dXWSxM/vPJTNXAcCAfl8PrndbgUCAdXX18vj8YzxiHE2sp3vHTt2aNasWTp06JDWrl3La3yoDBS0z3zmM5n/PnTokLFu3bozfs6ePXuMBQsWGMFgcDSHhhGWzVxv3LjRWLBggbFgwQLjxhtvZK7zUDbz/cILLxgbN27MXHvVVVeN+vgwcrKZ6/Truvc/P/vZz8ZimBgB2cz1qfOafo0jf2Qz31dddVXmd/WePXuY7yxQGSpggUCgz7HH49GuXbuG9Hm8u5Rfsp3r6upqvfTSS5J49zgfZTvfmzZt0lNPPZW5dvv27aM6PoycbOY6FApp69atfap+TU1NWrNmzaiOESMj29f1zp07mds8ls18+3w+Se//vvZ4PGpubta99947uoOcILhnqICly+e9ud3uzBKpgXi9XpbP5KHhzLXL5SII5als5jsQCCgQCMjlcsnv9ysUCvFmRx7J9rXd++c3P8/zS7Zz7Xa7tXLlysxyufTySOSHbOY7FAr1OU7/7j41UGFghKECduqLJy0YDA56PX8c56fhzLXX65XX69XmzZv5gZpnsplvv98vj8eTWZe+bds2eb3e0R4iRkg2c93753coFFIwGCT45pFsf45v3bpVkrRs2TKCbx7KZr6rq6v7nE8HJn53Dw3L5NDPYC/AnTt3qqGhYYxHg9E02Fz3vknT4/Fo9erVevbZZ8dyaBgFA813MBhUIBBQXV2dXC6XGhsbdfHFF/OHU54b7LWdtm3bNq1du3aMRoPRdLrf2TfffLOCwaA2bdokSSybmgAGmm+Px6Obb75Zzc3NWrFiRSYEnVpZwsCoDBUwl8vV7x2GYDA4YPXH5/NpxYoVYzU0jLBs5lrq+25SuosN7zDlj2zm2+Px9FsSGQqFTruEEuNHtq9tyZzfXbt2UenPM9nMdSAQ0KFDh1RfX6+GhgY9++yz2rlzJz/H80i2r+01a9aorq4u8+aWJCq/Q0QYKmCDrR+uqakZ8PzOnTvV3Nys5uZmBQIBbdu2jT+Y8kQ2c+33+3XjjTf2O887TPkjm/n2eDxnrCJg/Mr257gk7dmzZ7SGg1GU7c/x2trazHG6csBrPX9k+9pON7dKb4lRXV3NGx5DRBgqYKe+YxAIBFRTU5N58fj9/sy7SHV1dWpoaMj8I0mrVq1i75k8kc1cezwebdiwIXOtz+fT8uXL+aGaR7Kd7/S7ielr079QMf5lM9dpfr+fNzfyUDZzXV1drZaWlj7Xd3R08LrOI9m+tleuXJkJu83NzX1+j+P0LIZhGLkeBHInvUlXbW2tWlpa+mzSdfvtt6u2trZPa85QKKRt27bp8ccfzwQjfrjmh2zm2u/3Z949PnTokBobG3M2bgxPNvOdfl3PmjVLfr9fa9asYXlFHsn253hTU5MCgQD3j+ShbOba5/NlGqQEg0HV1dXxus4z2cx3c3NzZoPd6upqugdmgTAEAAAAoCCxTA4AAABAQSIMAQAAAChIhCEAAAAABYkwBAAAAKAgEYYAAAAAFCTCEAAAAICCRBgCAAyL3+/X5s2bc/b4Pp9PK1euVHNz86DXeL1erVy5UgsXLlRTU1OfjzU1Neniiy/Wpk2bzuoxAAD5y57rAQAA8lNzc7N27tyZ9aa8oVAos3Hg2airq9OKFStOe019fb08Ho9WrlyphoaGPh9Lb1bYe0PS4TwGACB/URkCAAxLRUWFQqGQfD7fkD8nEAho586doziq/qqrq+XxePpVd3w+n+rr68d0LACA8YUwBADIms/n0zXXXKO6ujp5vd4hf96pS9XGSkNDQ78w5Pf75fF4cjIeAMD4QBgCAGTN7/erurpaDQ0NA1Z6AoGANm/eLK/Xq+bm5kwFac+ePXrhhRfU3NysQCAgn8+nZcuWZUKS1+vVsmXL+lSbvF6vfD6fmpubh32PUkNDgwKBgAKBQOZc76V6Q32MoYzX5/OpqalJXq8387VCoZCamprk8/n6nAcA5BZhCAAwbPX19f2WyoVCIa1evVpr165VfX29Dh06pObmZtXV1Wnp0qW69NJL1dDQII/Ho7q6Oi1fvrzP11u0aFGfx1i/fr08Ho8aGhrU2dmZVSUqzeVyqa6uTjt27JBk3u/U+16goT7GmcYbCAS0ZcsWrVmzRvX19Zo1a5aamprU3Nys6upq1dXVZc4DAHKPBgoAgKz4fD4FAoHMsjOPxyOv16u6ujpJ0s6dO+XxeDKVl7Vr1572602aNOm0H3/ppZfkcrkUCATU0dHRp7qTjYaGBm3cuFGNjY39mjhk8xinG++OHTvkdrsz4TAUCqmlpUWNjY1auXKlPB6PVqxY0a+ZAwAgNwhDAICs+P1+3XvvvZljt9utjRs3Zs6FQiFVVFRkPj5Y57ihdpXbtm2bJk2alOkMN1z19fVav369mpub+32dkXoMSVq0aFEmGKb/HQqF9NJLL8nv9+vpp5/W+vXrtX379rN6HADA2WOZHADgrJy6VK6+vl579+7tc43f7+/3eenrXS6XOjo6Mud37dqlUCiUuWbv3r1as2aNPB6POjs7+3yupMy1Q7F8+XJt2bKlTxe5bB/jdOO95pprtGvXrn7Pc9u2bQoEAqqurlZjY2OfsAgAyB0qQwCAIUk3BggGg6qrq1N1dbUk8/4bl8ulLVu2qKGhQQ0NDbr33nu1efNm1dbWSnq/QrJq1arMPTTpcytWrNCWLVsy4WPp0qWZe2xqampUUVHRJ2jt2LFDHo9Hfr8/07yh93hOZ+3atf0qP9k+xunGW11drQ0bNvR77n6/Xz6fT263W8FgUNdcc80wZwEAMJIshmEYuR4EAAAAAIw1lskBAAAAKEiEIQAAAAAFiTAEAAAAoCARhgAAAAAUJMIQAAAAgIJEGAIAAABQkAhDAAAAAAoSYQgAAABAQSIMAQAAAChIhCEAAAAABYkwBAAAAKAgEYYAAAAAFKT/D984y42YXTF/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the predicted vs. actual values\n",
    "fig = plt.figure(figsize=(10, 6))\n",
    "plt.scatter(y_actuals, y_preds, alpha=0.5)\n",
    "plt.plot([min(y_actuals), max(y_actuals)], [min(y_actuals), max(y_actuals)], 'r')  # Diagonal line\n",
    "plt.title('Predicted vs. Actual Values')\n",
    "plt.xlabel('Actual Values')\n",
    "plt.ylabel('Predicted Values')\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "pdf_file_path = './data/predicted_atual.pdf'\n",
    "with PdfPages(pdf_file_path) as pdf:\n",
    "    pdf.savefig(fig)\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearman Correlation: 0.09818502263040027\n",
      "P-value: 0.03096968630477179\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import spearmanr\n",
    "spearman_corr, p_value = spearmanr(y_actuals, y_preds)\n",
    "\n",
    "# Print the Spearman correlation coefficient and p-value\n",
    "print(f'Spearman Correlation: {spearman_corr}')\n",
    "print(f'P-value: {p_value}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:.conda-l-schewinski-tp-2]",
   "language": "python",
   "name": "conda-env-.conda-l-schewinski-tp-2-py"
  },
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}