maclandrol/molfeat-chemgpt.ipynb

## molfeat-chemgpt.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#! pip install pynvml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "# clear cuda cache\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pynvml import *\n",
    "def print_gpu_utilization(_print=True):\n",
    "    nvmlInit()\n",
    "    handle = nvmlDeviceGetHandleByIndex(0)\n",
    "    info = nvmlDeviceGetMemoryInfo(handle)\n",
    "    memory_used = info.used//1024**2\n",
    "    if _print:\n",
    "        print(f\"GPU memory occupied: {memory_used} MB\")\n",
    "    return memory_used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#! pip install \"molfeat[all]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import copy\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from transformers import default_data_collator\n",
    "\n",
    "from sklearn.metrics import accuracy_score, roc_auc_score, mean_squared_error, r2_score\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import datamol as dm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from molfeat.utils.converters import SmilesConverter\n",
    "from molfeat.trans.pretrained import PretrainedHFTransformer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"https://raw.githubusercontent.com/PatWalters/yamc/main/data/JAK2.smi\",sep=\" \",names=[\"SMILES\",\"Name\",\"pIC50\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>SMILES</th>\n",
       "      <th>Name</th>\n",
       "      <th>pIC50</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CC(C)(C)c1[nH]c2c3cc[nH]c(=O)c3c4cc(ccc4c2n1)F</td>\n",
       "      <td>CHEMBL21156</td>\n",
       "      <td>8.37000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>CC1CCN(CC1N(C)c2c3cc[nH]c3ncn2)C(=O)CC#N</td>\n",
       "      <td>CHEMBL221959</td>\n",
       "      <td>7.62875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>CC(COC)Nc1cc(nc(n1)n2cnc3c2cncc3)c4ccoc4</td>\n",
       "      <td>CHEMBL557844</td>\n",
       "      <td>6.85000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>CC(c1ccc(cc1)F)Nc2cc(nc(n2)n3cnc4c3cncc4)c5ccoc5</td>\n",
       "      <td>CHEMBL221378</td>\n",
       "      <td>7.55000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>CC(c1ccccc1)Nc2cc(nc(n2)n3cnc4c3cc(cc4)C#N)c5c...</td>\n",
       "      <td>CHEMBL375205</td>\n",
       "      <td>7.54000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2247</th>\n",
       "      <td>CNCCn1c2ccc(cc2nc1C3CCC(CC3)O)C(=O)N</td>\n",
       "      <td>CHEMBL3815154</td>\n",
       "      <td>5.41000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2248</th>\n",
       "      <td>CC(Cn1c2ccc(cc2nc1C3CCC(CC3)O)C(=O)N)O</td>\n",
       "      <td>CHEMBL3814406</td>\n",
       "      <td>4.92000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2249</th>\n",
       "      <td>c1cc2c(cc1C(=O)N)nc(n2CCCO)C3CCC(CC3)O</td>\n",
       "      <td>CHEMBL3814951</td>\n",
       "      <td>4.53000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2250</th>\n",
       "      <td>c1cc2c(cc1C(=O)N)nc(n2CCO)C3CCC(CC3)O</td>\n",
       "      <td>CHEMBL3814293</td>\n",
       "      <td>5.50000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2251</th>\n",
       "      <td>Cn1cc(cn1)c2cc(c3nnc(n3c2)Sc4ccc5c(c4)c6c(cn5)...</td>\n",
       "      <td>CHEMBL3818247</td>\n",
       "      <td>4.68000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2252 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                 SMILES           Name   \n",
       "0        CC(C)(C)c1[nH]c2c3cc[nH]c(=O)c3c4cc(ccc4c2n1)F    CHEMBL21156  \\\n",
       "1              CC1CCN(CC1N(C)c2c3cc[nH]c3ncn2)C(=O)CC#N   CHEMBL221959   \n",
       "2              CC(COC)Nc1cc(nc(n1)n2cnc3c2cncc3)c4ccoc4   CHEMBL557844   \n",
       "3      CC(c1ccc(cc1)F)Nc2cc(nc(n2)n3cnc4c3cncc4)c5ccoc5   CHEMBL221378   \n",
       "4     CC(c1ccccc1)Nc2cc(nc(n2)n3cnc4c3cc(cc4)C#N)c5c...   CHEMBL375205   \n",
       "...                                                 ...            ...   \n",
       "2247               CNCCn1c2ccc(cc2nc1C3CCC(CC3)O)C(=O)N  CHEMBL3815154   \n",
       "2248             CC(Cn1c2ccc(cc2nc1C3CCC(CC3)O)C(=O)N)O  CHEMBL3814406   \n",
       "2249             c1cc2c(cc1C(=O)N)nc(n2CCCO)C3CCC(CC3)O  CHEMBL3814951   \n",
       "2250              c1cc2c(cc1C(=O)N)nc(n2CCO)C3CCC(CC3)O  CHEMBL3814293   \n",
       "2251  Cn1cc(cn1)c2cc(c3nnc(n3c2)Sc4ccc5c(c4)c6c(cn5)...  CHEMBL3818247   \n",
       "\n",
       "        pIC50  \n",
       "0     8.37000  \n",
       "1     7.62875  \n",
       "2     6.85000  \n",
       "3     7.55000  \n",
       "4     7.54000  \n",
       "...       ...  \n",
       "2247  5.41000  \n",
       "2248  4.92000  \n",
       "2249  4.53000  \n",
       "2250  5.50000  \n",
       "2251  4.68000  \n",
       "\n",
       "[2252 rows x 3 columns]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DTset(Dataset):\n",
    "    def __init__(self, smiles, y, mf_featurizer, max_length=128):\n",
    "        super().__init__()\n",
    "        self.smiles = smiles\n",
    "        self.mf_featurizer = mf_featurizer\n",
    "        self.y = torch.tensor(y).float()\n",
    "        # here we use the molfeat mf_featurizer to convert the smiles to\n",
    "        # corresponding tokens based on the internal tokenizer\n",
    "        # we just want the data from the batch encoding object\n",
    "        transformed_mols = dm.utils.parallelized(\n",
    "                self.mf_featurizer.converter.encode,\n",
    "                smiles,\n",
    "                n_jobs=1,\n",
    "        )\n",
    "        self.max_length = max_length\n",
    "        batch_encoding = self.mf_featurizer.featurizer.tokenizer(\n",
    "            transformed_mols,\n",
    "            add_special_tokens=True,\n",
    "            truncation=True,\n",
    "            max_length=self.max_length\n",
    "        )\n",
    "        self.examples = batch_encoding[\"input_ids\"]\n",
    "        self.examples = [{\"input_ids\": torch.tensor(e, dtype=torch.long)} for e in self.examples]\n",
    "        \n",
    "    @property\n",
    "    def embedding_dim(self):\n",
    "        return len(self.mf_featurizer)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.y.shape[0]\n",
    "    \n",
    "    def collate_fn(self, batch, **kwargs):\n",
    "        # We try to be a bit more clever here, only padding the batch and not the full dataset\n",
    "        # to reduce padding as much as possible and thus the memory\n",
    "        y = torch.tensor([feature[\"y\"] for feature in batch]).float()\n",
    "        inputs_features = [{\"input_ids\": ft[\"input_ids\"]} for ft in batch]\n",
    "        batch_inputs = self.mf_featurizer.featurizer.tokenizer.pad(\n",
    "            inputs_features,\n",
    "            padding=True,\n",
    "            return_tensors=\"pt\",\n",
    "            max_length=self.max_length,\n",
    "        )\n",
    "        # If special token mask has been preprocessed, pop it from the dict.\n",
    "        batch_inputs.update({\"y\": y})        \n",
    "        return batch_inputs.data\n",
    "    \n",
    "    def __getitem__(self, index):                        \n",
    "        datapoint = self.examples[index]\n",
    "        datapoint[\"y\"] = self.y[index]\n",
    "        return datapoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install this\n",
    "#! pip install pytorch_lightning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning.callbacks import TQDMProgressBar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AwesomeNetPL(pl.LightningModule):\n",
    "    def __init__(self,  mf_featurizer, hidden_size=128, dropout=0.1, output_size=1, lr=1e-3):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.output_size = output_size\n",
    "        self.lr = lr\n",
    "        # we get the underlying model from the molfeat featurizer\n",
    "        # here we fetch the \"base\" huggingface transformer model \n",
    "        # and not the wrapper around for MLM\n",
    "        # this is principally to get smaller model and training efficiency\n",
    "        base_pretrained_model = getattr(mf_featurizer.featurizer.model, mf_featurizer.featurizer.model.base_model_prefix)\n",
    "        self.embedding_layer = copy.deepcopy(base_pretrained_model)\n",
    "        self.embedding_dim = mf_featurizer.featurizer.model.config.hidden_size\n",
    "        \n",
    "        # given that we are not concatenating layers, the following is equivalent\n",
    "        # self.embedding_dim = len(mf_featurizer)\n",
    "        # we get the the pooling layer from the molfeat featurizer\n",
    "        self.pooling_layer = mf_featurizer._pooling_obj\n",
    "        self.hidden_layer = torch.nn.Sequential(\n",
    "            torch.nn.Dropout(p=dropout),\n",
    "            torch.nn.Linear(len(mf_featurizer), self.hidden_size),\n",
    "            torch.nn.ReLU()\n",
    "        )\n",
    "        self.output_layer = torch.nn.Linear(self.hidden_size, self.output_size)\n",
    "        self.loss_fn = torch.nn.MSELoss()\n",
    "\n",
    "    def forward(self, *, y=None, **kwargs):\n",
    "        # get embeddings\n",
    "        x = self.embedding_layer(**kwargs)\n",
    "        # we take the last hidden state\n",
    "        # you could also set `output_hidden_states` to true above \n",
    "        # and take x[\"hidden_states\"][-1] instead\n",
    "        emb = x[\"last_hidden_state\"]\n",
    "        # run poolings\n",
    "        h = self.pooling_layer(\n",
    "            emb,\n",
    "            kwargs[\"input_ids\"],\n",
    "            mask=kwargs.get('attention_mask'),\n",
    "        )\n",
    "        # run through our custom and optional hidden layer\n",
    "        h = self.hidden_layer(h)\n",
    "        # run through output layers to get logits\n",
    "        return self.output_layer(h)\n",
    "    \n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # training_step defines the train loop.\n",
    "        # it is independent of forward\n",
    "        out = self(**batch)\n",
    "        loss = self.loss_fn(out.squeeze(), batch[\"y\"])\n",
    "        # Logging to TensorBoard (if installed) by default\n",
    "        memory_used = print_gpu_utilization(False)\n",
    "        self.log_dict({\"train_loss\":loss, 'GPU':memory_used}, on_step=True, on_epoch=True, prog_bar=True, logger=True)\n",
    "        return loss\n",
    "    \n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        # training_step defines the train loop.\n",
    "        # it is independent of forward\n",
    "        out = self(**batch)\n",
    "        loss = self.loss_fn(out.squeeze(), batch[\"y\"])\n",
    "        # Logging to TensorBoard (if installed) by default\n",
    "        self.log(\"valid_loss\", loss, on_epoch=True, prog_bar=True, logger=True)\n",
    "        return loss\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.trainer.model.parameters(), lr=self.lr)\n",
    "        return optimizer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurizer = PretrainedHFTransformer(kind='ChemGPT-1.2B', notation='selfies', dtype=float, preload=True)\n",
    "\n",
    "model = AwesomeNetPL(featurizer, hidden_size=64, dropout=0.1, output_size=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  | Name            | Type        | Params\n",
       "------------------------------------------------\n",
       "0 | embedding_layer | GPTNeoModel | 1.2 B \n",
       "1 | pooling_layer   | HFPooler    | 0     \n",
       "2 | hidden_layer    | Sequential  | 131 K \n",
       "3 | output_layer    | Linear      | 65    \n",
       "4 | loss_fn         | MSELoss     | 0     \n",
       "------------------------------------------------\n",
       "1.2 B     Trainable params\n",
       "0         Non-trainable params\n",
       "1.2 B     Total params\n",
       "4,856.726 Total estimated model params size (MB)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pytorch_lightning.utilities.model_summary import summarize\n",
    "summarize(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "def train_and_test_model(featurizer, model, batch_size=2, precision=16, accumulate_grad_batches=2, max_epochs=1, devices=\"auto\"):\n",
    "    dataset = DTset(df.SMILES.values, df.pIC50.values, featurizer)\n",
    "    generator = torch.Generator().manual_seed(42)\n",
    "    train_dt, test_dt = torch.utils.data.random_split(dataset, [0.8, 0.2], generator=generator)\n",
    "    # collate fn is not called anymore, but instead is a function passed to the dataloader\n",
    "    train_loader = DataLoader(train_dt, batch_size=batch_size, shuffle=True, collate_fn=dataset.collate_fn)\n",
    "    test_loader = DataLoader(test_dt, batch_size=batch_size, shuffle=False, collate_fn=dataset.collate_fn)\n",
    "    # select GPU accelerator , possibily explore different strategy\n",
    "    trainer = pl.Trainer(max_epochs=max_epochs, accelerator=\"gpu\", devices=devices, accumulate_grad_batches=accumulate_grad_batches, precision=precision)\n",
    "    trainer.fit(model=model, train_dataloaders=train_loader)\n",
    "    # --- test\n",
    "    model.eval()\n",
    "    test_y_hat = []\n",
    "    test_y_true = []\n",
    "    with torch.no_grad():\n",
    "        for data in test_loader:\n",
    "            for k,v in data.items():\n",
    "                data[k] = data[k].to(model.device)\n",
    "            out = model(**data)\n",
    "            test_y_hat.append(out.detach().cpu().squeeze())\n",
    "            test_y_true.append(data[\"y\"])\n",
    "    test_y_hat = torch.cat(test_y_hat).cpu().squeeze().numpy()\n",
    "    test_y_true = torch.cat(test_y_true).cpu().squeeze().numpy()\n",
    "    rmse = mean_squared_error(test_y_true, test_y_hat, squared=False)\n",
    "    r2 = r2_score(test_y_true, test_y_hat)\n",
    "    print(f\"RMSE = {rmse:.2f} R**2 = {r2:.2f}\")\n",
    "    sns.scatterplot(x=test_y_true, y=test_y_hat)\n",
    "    return trainer, model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/lightning_fabric/connector.py:562: UserWarning: 16 is supported for historical reasons but its usage is discouraged. Please set your precision to 16-mixed instead!\n",
      "  rank_zero_warn(\n",
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/lightning_fabric/plugins/environments/slurm.py:165: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/emmanuel/.conda/envs/molfeat/lib/python3.11/si ...\n",
      "  rank_zero_warn(\n",
      "Using 16bit Automatic Mixed Precision (AMP)\n",
      "GPU available: True (cuda), used: True\n",
      "TPU available: False, using: 0 TPU cores\n",
      "IPU available: False, using: 0 IPUs\n",
      "HPU available: False, using: 0 HPUs\n",
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/lightning_fabric/plugins/environments/slurm.py:165: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/emmanuel/.conda/envs/molfeat/lib/python3.11/si ...\n",
      "  rank_zero_warn(\n",
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/pytorch_lightning/trainer/configuration_validator.py:72: PossibleUserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n",
      "  rank_zero_warn(\n",
      "You are using a CUDA device ('NVIDIA RTX A6000') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n",
      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1,2]\n",
      "\n",
      "  | Name            | Type        | Params\n",
      "------------------------------------------------\n",
      "0 | embedding_layer | GPTNeoModel | 1.2 B \n",
      "1 | pooling_layer   | HFPooler    | 0     \n",
      "2 | hidden_layer    | Sequential  | 131 K \n",
      "3 | output_layer    | Linear      | 65    \n",
      "4 | loss_fn         | MSELoss     | 0     \n",
      "------------------------------------------------\n",
      "1.2 B     Trainable params\n",
      "0         Non-trainable params\n",
      "1.2 B     Total params\n",
      "4,856.726 Total estimated model params size (MB)\n",
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:430: PossibleUserWarning: The dataloader, train_dataloader, does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` (try 128 which is the number of cpus on this machine) in the `DataLoader` init to improve performance.\n",
      "  rank_zero_warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0:   0%| | 0/901      "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You're using a PreTrainedTokenizerFast tokenizer. Please note that with a fast tokenizer, using the `__call__` method is faster than using a method to encode the text followed by a call to the `pad` method to get a padded encoding.\n",
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/transformers/tokenization_utils_base.py:2382: UserWarning: `max_length` is ignored when `padding`=`True` and there is no truncation strategy. To pad to max length, use `padding='max_length'`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0:   0%| | 3/901 "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/emmanuel/.conda/envs/molfeat/lib/python3.11/site-packages/pytorch_lightning/trainer/connectors/logger_connector/result.py:212: UserWarning: You called `self.log('GPU', ...)` in your `training_step` but the value needs to be floating point. Converting it to torch.float32.\n",
      "  warning_cache.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|█| 901/90"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=1` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|█| 901/90\n",
      "RMSE = 1.48 R**2 = -0.55\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGfCAYAAACneiONAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHS0lEQVR4nO29eXxTdb7//2rTJm1SuphSKNhCaapsBapFxqbAqDM6Kg7iXBwrKojrIKDwc0aqMCJi0XHjusAMc4FxRe+9CC5fHQf1DragohiHVWhLx1ZASmub0qZN2ia/P+oJWc6anJxzkryfjwePB01Oks/55OR8Xp/3muDxeDwgCIIgCIKIchLVHgBBEARBEIQckKghCIIgCCImIFFDEARBEERMQKKGIAiCIIiYgEQNQRAEQRAxAYkagiAIgiBiAhI1BEEQBEHEBCRqCIIgCIKICUjUEARBEAQRE5CoIQiCIAgiJkiS+oLjx4/jgQcewAcffIDu7m6cd9552LhxIy688ELB1+7atQvTp0/H+PHj8c033/g9t3XrVqxYsQL19fUoLCzEY489hlmzZvkds27dOjz55JM4efIkxo0bh7Vr12Lq1Kmix+52u3HixAkMGjQICQkJol9HEARBEIR6eDwenDlzBsOGDUNiIo89xiOBH3/80TNixAjPvHnzPF988YWnoaHB89FHH3nq6uoEX9ve3u4ZNWqU5/LLL/dMnDjR77ndu3d7dDqdp6qqynP48GFPVVWVJykpyfP55597j3njjTc8ycnJnr/+9a+eQ4cOee69916PyWTyfPfdd6LH39TU5AFA/+gf/aN/9I/+0b8o/NfU1MS7zid4POIbWi5btgy7du1CdXW12Jd4ueGGG1BUVASdToft27f7WWp++9vfoqOjAx988IH3sV/96lfIysrCli1bAABTpkzBBRdcgPXr13uPGTNmDK699lqsWbNG1BjsdjsyMzPR1NSE9PR0yedAEARBEITydHR0IC8vD+3t7cjIyOA8TpL76Z133sEVV1yB2bNnY+fOnRg+fDgWLFiAO+64g/d1mzdvRn19PV599VWsXr066PnPPvsMS5Ys8XvsiiuuwNq1awEALpcLe/fuxbJly/yOufzyy7F7927Oz3U6nXA6nd6/z5w5AwBIT08nUUMQBEEQUYZQ6IikQOFjx45h/fr1KCoqwocffoi7774bixcvxssvv8z5mtraWixbtgyvvfYakpLYNdQPP/yAIUOG+D02ZMgQ/PDDDwCAlpYW9Pf38x7Dxpo1a5CRkeH9l5eXJ/ZUCYIgCIKIMiSJGrfbjQsuuABVVVUoKSnBXXfdhTvuuMPPJeRLf38/brzxRjzyyCM477zzeN87UH15PJ6gx8Qc40tlZSXsdrv3X1NTE+8YCIIgCIKIXiS5n3JzczF27Fi/x8aMGYOtW7eyHn/mzBl89dVXsNlsWLhwIYABYeTxeJCUlIR//OMfuPTSSzF06NAgi0tzc7PXMpOdnQ2dTsd7DBsGgwEGg0HKKRIEQRAEEaVIstRYrVYcOXLE77GjR49ixIgRrMenp6dj//79+Oabb7z/7r77bpx//vn45ptvMGXKFADAxRdfjB07dvi99h//+AfKysoAAHq9HhdeeGHQMTt27PAeQxAEQRBEfCPJUrNkyRKUlZWhqqoK119/Pfbs2YMNGzZgw4YN3mMqKytx/PhxvPzyy0hMTMT48eP93iMnJwcpKSl+j997772YNm0annjiCcycORNvv/02PvroI9TU1HiPWbp0KW6++WaUlpbi4osvxoYNG9DY2Ii777471HMnCIIgCCKGkCRqJk+ejG3btqGyshKrVq1CQUEB1q5dizlz5niPOXnyJBobGyUNoqysDG+88QaWL1+OFStWoLCwEG+++abXkgMMpH23trZi1apVOHnyJMaPH4/333+f00pEEARBEER8IalOTbTT0dGBjIwM2O12SukmCIIgiChB7PpNvZ8IgiAIgogJSNQQBEEQBBETSG5oSRAEQcQGdocLLZ0udPT0Ij01GdkmPTKMerWHRRAhQ6KGIAgiDjnR3o0Htu5DdW2L97FpRdl4/DcTMCwzVcWREUTokPuJIAhCAnaHC/XNnbA1tqH+dCfsDpfaQ5KM3eEKEjQA8GltC5Zt3ReV50QQAFlqCIIgRBMr1o2WTleQoGH4tLYFLZ0uckMRUQlZagiCIESgpHUj0tagjp5e3ufPCDxPEFqFLDUEQRAiUMq6oYQ1KD0lmff5QQLPE4RWIUsNQRCECJSwbkixBoVjzclO02NaUTbrc9OKspGdJq/rKRrjkKJxzARZagiCIEShhHVDrDUoXGtOhlGPx38zAcu27sOnAe/xxG8myBpPE41xSNE4ZmIAEjUEQRAiYKwbn7KIDrmsG2KsQULWnOcrSkSJkmGZqXi+ogQtnS6c6enFoJRkZKfJW6dGrrEqSTSOmTgLuZ8IgiBEwFg3At02clo3xFiDxFhzxJJh1KMwJw2T8rNQmJMm+2It51iVIhrHTJyFLDUEQRAiibR1Q4w16FhLF+97aClzKRqzrKJxzMRZSNQQBEFIIMMYuVYCYmJd0lP4LQVaylySEoeklZYNlBkW3ZCoIQiC0BBC1iAlYnvkQuxYtRSYG03zSwRDMTUEQRAagy/WRYnYHrkQM1attWyIpvklgknweDwetQehFB0dHcjIyIDdbkd6errawyEIgggZxl0TqcwlOeEba31zJy57Zifnaz9eOh2FOWlKDdVLNM1vPCB2/Sb3E0EQRBQSydgeueEbq9jAXKVjbqJpfomzkKghCELzaCWIlJAfocDc9NRkTcXcENqGRA1BEJpG6wsaCa7wEArMNRmScP///IuK4RGioEBhgiA0i9aCSAM50d6NhVtsuOyZnZi1bjcue3onFm2x4UR7t6rjiiaEAnM7e/qoGB4hGrLUEAShWZTqjB0KVE5fPvjS2G2NbbyvpWJ4hC8kagiC0Cxaru6qZcEVjXAF5lIxPEIK5H4iCEKzaHlB07LgiiWYmBs2qBgeEQiJGoIg/LA7XKhv7oStsQ31pztVjVvR8oKmZcEVS8RqMTwt/c5iCXI/EQThRWuZRmJ6IakFldNXjkg3ElUarf3O5EArWYBUUZggCAADN6WFW2yscSLTirJVDXzVanXXE+3dnIIrN0oXJyKyaPl3FipKiDSqKEwQhCS0HPiq1equsWZBICKPln9noaC1LEASNQRBAKDA11DRquAitEms/c60JtJI1BAEAYACXwlCCfh+Z0a9DllGPeqbO1WPTRGL1kQaiRqCIABQ4CtBKAHX78yo12HTvMlYvv0AquuiJ4BYa5shSukmCAJA7KbOEoSW4PqdrZgxFi9+UucnaADlWoKEmmKutbILlP1EEIQfWs00IohYIvB35vZ48MtnP+U8/uOl01GYkxaRsYSbvaREFiBlPxEEERIU+BqfaKXOSLwQ+DtTq8eVHNlLWsoCJFFDEAQR58RiMbhoQ63YFLmyl7SyGaKYGoIgohIqMy8PQjt1mldlUCs2RWvZS+FClhqCIKIOsizIh9bqjMQrarUE0Vr2UriQqCEIIqrQWgXTaCfWdurRjBqxKbFWyoHcTwRBRBViLAuEeGJtpx7tZBj1KMxJw6T8LBTmpEVcoMdaKQey1BAEEVWQZUFeYm2nTkhHS9lL4UKWGoIgogqyLMhLrO3UidBQ2kIUKchSQxBEVEGWBfmJpZ06Ed+QqCEIQjMwBeA6nb3INOrh6nOj09nnVwxOrSyRWEcrdUYIIhxI1BAEoQmYNO2937XhuYoS/OnDI9hV1+p93jdlmywLBEGwQb2fCIJQHbvDhYVbbKiubcHCSy2wNbb5CRqGaUXZlLJNEHGI2PWbAoUJglAd3zTtkrxMVkEDUMo2QRD8kPuJiBmoIV/04pum7exz8x5LKdsEQXBBooaICahsfnTjm6ZtSOI3IFPKNkEQXJD7iYh6oqUhHzVg5Ma3mZ+tqR1Wi5n1OErZJgiCD7LUEFFPNDTkI0sSP75p2ptqGvBcRQkABGU/Uco2QRB8kKghoh6tl82nBozi8E3T7nL2ouraYrj63ehy9kU0ZZtisQgidiBRQ0Q9Wi+bHw2WJK2gdAE4sqARRGwhOabm+PHjuOmmm2A2m2E0GjFp0iTs3buX8/iamhpYrVaYzWakpqZi9OjRePbZZ/2O6e3txapVq1BYWIiUlBRMnDgRf//73/2OWblyJRISEvz+DR06VOrwiRjENx4jEC3EYGjdkhSvREssFkEQ4pFkqWlra4PVasUll1yCDz74ADk5Oaivr0dmZibna0wmExYuXIgJEybAZDKhpqYGd911F0wmE+68804AwPLly/Hqq6/ir3/9K0aPHo0PP/wQs2bNwu7du1FSUuJ9r3HjxuGjjz7y/q3T6SSeLhGLaL1svtYtSfEKWdAIIvaQJGqeeOIJ5OXlYfPmzd7HRo4cyfuakpISP2EycuRIvPXWW6iurvaKmldeeQUPPfQQrrrqKgDA7373O3z44Yd4+umn8eqrr54dbFISWWcIVrRcNp8aMGoTsqARROwhyf30zjvvoLS0FLNnz0ZOTg5KSkrw17/+VdIH2mw27N69G9OnT/c+5nQ6kZKS4ndcamoqampq/B6rra3FsGHDUFBQgBtuuAHHjh3j/Syn04mOjg6/f0TskmHUozAnDZPys1CYk6YJQQOctSQFusi0YkmKV8iCRhCxh6TeT4zwWLp0KWbPno09e/bgvvvuw1/+8hfccsstvK8999xzcfr0afT19WHlypVYsWKF97kbb7wR//rXv7B9+3YUFhbi448/xsyZM9Hf3w+n0wkA+OCDD+BwOHDeeefh1KlTWL16Nb799lscPHgQZjN7TYuVK1fikUceCXqcej8RasBk2WjNkhSv2B0uLNpi47SgRUNWGmVuEfGC2N5PkkSNXq9HaWkpdu/e7X1s8eLF+PLLL/HZZ5/xvrahoQGdnZ34/PPPsWzZMrzwwguoqKgAAJw+fRp33HEH3n33XSQkJKCwsBC/+MUvsHnzZjgcDtb36+rqQmFhIf7whz9g6dKlrMc4nU6vKAIGJiUvL49EDUEQAAayn7hisXI1nv0UTuYWiSEi2hAraiTF1OTm5mLs2LF+j40ZMwZbt24VfG1BQQEAoLi4GKdOncLKlSu9ombw4MHYvn07enp60NraimHDhmHZsmXe17BhMplQXFyM2tpazmMMBgMMBoOYUyMIIg7RciwWH+HUPqI0diKWkRRTY7VaceTIEb/Hjh49ihEjRkj6UI/H42dBYUhJScHw4cPR19eHrVu3YubMmZzv4XQ6cfjwYeTm5kr6bIIgCF+0GovFh5jMLTYojZ2IdSRZapYsWYKysjJUVVXh+uuvx549e7BhwwZs2LDBe0xlZSWOHz+Ol19+GQDw4osvIj8/H6NHjwYwULfmqaeewqJFi7yv+eKLL3D8+HFMmjQJx48fx8qVK+F2u/GHP/zBe8z999+Pa665Bvn5+Whubsbq1avR0dGBuXPnhjUBBEEQ0UaomVuUxk7EOpJEzeTJk7Ft2zZUVlZi1apVKCgowNq1azFnzhzvMSdPnkRjY6P3b7fbjcrKSjQ0NCApKQmFhYV4/PHHcdddd3mP6enpwfLly3Hs2DGkpaXhqquuwiuvvOJX/+b7779HRUUFWlpaMHjwYPzsZz/D559/LtlKRCgH+e0JIjKEmrlFaexErCMpUDjaERtoRIQP+e0JInKEmrlV39yJy57Zyfm+Hy+djsKcNFnHShByIHb9ltwmgSCEIL89QUSWUGsf8bUUmVqUjSRdAv0+iaiGGloSskN+e0Ip4tnFGUrmFldLEavFjLllI3Hlf1ajdEQWWVSJqIVEDSE75LcnlIBcnKF1NWfEUPMZJxp/HKgDZmtqx+ItNjhc/aLSwglCq5CoIWSHys8TkSacOi2xQjhWqgyjHi2dLtz20lesz5NFlYhWSNQQshPNDRzj2Z0RTajp4tTCNcJmpZpalI2Vvx6HBABmEWOyd/PHzti7yaJKRB8kagjZ4fLba72BI7kzoge1XJxauEa4rFTVtS3449sHUJKfhX1N7YJjMur5b/9GvU6W8RKEklD2ExERGL/9x0unY/uCMny8dDqeryjRbD8dytiKPHaHC/XNnbA1tqH+dGdYc6qGi1Mr1wiflWpXXStK8jJFjSkxMQFWC3szYKvFDF1igizjJQglIUsNETFCCWJUGsaV4Ozrp4ytCCK3hUMNF6dWsvqErFTOPreoMSUlJuBW60B/vV11rd7HrRYzbrUWkKghohKy1BBxy4n2bizcYsNlz+zEv1vZu8EzUMZW6ETCwhFqnZZw0EpWn5CVypB09rbONyazSY839zSiJD8LG+eWYt2cC7BxbilK8rPw5p5GmE0k4onogyw1RFwSuND6LgRsUMZW6ETKwqF0h22tZPXxWamsFjNsTe2ixpRh1OORmeOxbOs+vPBJnfdxrce+EQQfJGqIuCRwobU1tcNqMfuZ4Rm0nrGldSJp4VDSxamVrD6+Anq3WguweItN9JhCFYZayAAjCDZI1BBxSeBCu6mmAc9VlADwjy+gXWv4aMXCES5ayurzFSPt3S44e93YfazVW0BPypikCkMtZIARBBfU0JKIS9ga+xn1OswvL0BJXiYyUpORZdRH1J2hJkrutENtvqhVmLmLhMsr1O8lkmMK/JyFW2ys7sRo/C6J6EHs+k2WGiIuYXMlOFz9eOGTupi/OSu90+aycPxyTA5W/nocWjpdONbSFTVujEi5vML5XpRyw2klA4wguCBLDaEZlPbTn2jv5nQlaLWeTrioudP2tSakpyZDr0tE5bb95MZA9FhAbI1tmLVuN+fz2xeUYVJ+loIjIuIFstQQUYUafnqls2e0gJo7bV9rAtciHk+9m3yJFgtIrMRHEbEL1akhVEfNSq0ZRj0Kc9IwKT8LhTlpmlg4IolWaq2IWcTjCa18L0Iwbls2KEuQ0AIkagjVoQVOObSy046WRVxO+NpEaOV7EUKNoocEIQVyPxGqE48LnFpopdZKtCziciHkXtXK9yKGeHTbEtEDWWoI1Ym3BY4NOZs98qGVnbbSbgyl5pfrs4Xcq3J/L5E+33hz2xLRA1lqCNWJpl1qJFA6SFoLO20lC9mpXSxObBCwXN+L2udLEGpCKd2EJojH9GogelJ5I4XUonFS0/7VmN/AMdodLly3/jPO4+VMg47364mIXSilm4gqtGA9CJVw6utESypvpGArGsc1n6FYIJSeX7Yxvn77FN7XyOlejffriSBI1BCaQcnmhHIRrqmfgqT94ZrPNdcVY9lb+yXXtVFyfrliZ3Yfa0W5xYwaBZql0vVExDskaoioRAtdgoUCQMWY+ilI+ix88/ldq4PXAnHS3sPaaiE9Jdmvp5ezz42UZB2+bmzDppoGRawkTLPUhISEILEWGD8U7nVN1xMR75CoIaKOSARChrKYyGHqj/cgaV/45rO9m9/CcKylCwte+xpAcKr0pnmT8fwntXjhkzrv8VaLGZvmTVbESuJw9WPxFhvevseKxIQETveqHNc1XU9EvEOihogq5LCOBBLqYiKHqV/JLCCtwzefhiT+6hOGpEQ/i8zhkx3ocvYhPTUZ//XpMewKcP3sqmtFYkICXqgoASCP5Y/PSuJw9SMxIQGFOWmsz8t1XUfb9aQFiysRW5CoIaIKuQMhw1lM5DL1R3OQtBBSFi2++bQ1tWNqUTbrd2+1mLH/uB3PVZRg864GP4vM1KJszC0bid3HWuFw9fu9rvqn66XL1S+L5S8cK4mc13W0XE+Uek5EAiq+R0QVcgdChtOiQc4CcrFYzOxEezcWbrHhsmd2Yta63bjs6Z1YtMWGE+3drMfzzeeRkx1YM6s46HmrxYxbrQVISAA272oIsshU17Zg864GzC8vYH1fe3evbH3HwimgJ/d1rfXrSc1+b0RsQ5YaIqqQOxAynMUk2kz9ShKKBYxvPlfNHI/cAAtESrIO7+0/icVbbHi+ogTP7qhlHcuuulbMt7KLGqNeJ6vlL1QrSbwF+FLqOREpSNQQUYXcgZDhLibRYupXmlAXLaH59E37tztc2NfUDoerH84+N+942J6fVpSNxMQE3tfxiVou11oopQniLcCXUs+JSEGihogq5LaOyLGYRGN9nUgTrgVMalCsUCBxZqq/OGWul+7efo5XDMAlauWOB4k3q1+8WaYI5SBRQ0QdclpH4m0xiRSBVotzjHoY9bqg4FwGuRYt5lpod/RyBhJPK8pGYU4aPl46Peh6sTtckkVtJDLwfM8lHqx+8WaZIpSDej8RBKT3ICLOwmW1WHCJBfP/9mWQsGF6EAGQNZ1Xav8wu8OF1i4XPABWvnPQb/xTi7Lx6MzxyDImB42pvrkTlz2zk3McHy+dzpm6TZwlXvu9EaFBvZ8IQgLkQgoNPquFB8CKGWNR+dZ+7+PMouVw9eMPMqfzSrF0+Aoxo16HO6eNwrJfjcYPHT0ABlLIr3quGqUjsoLGRPEg8hBPlilCOchSQxBEyAhZLXYsmRZURReAqp2k2TpZL7zUAltjW1BKODBgtXlq9kQMSU8BAHzX0oW6051BLRcYixRZaghCfshSQxBExBGyWnQ5+zApP8vvsfrmTlXTedkys0ryMv2K9vlSXduC+uZOuN0eeAAs334A1XVnX2+1mPFcRQkWb7GhdEQWxYMQhIqQqCGIEKES76Flscjlvgl1/tk+XyglvL27F/88ehrv7zvpJ2gAeK07K2aMxc/PGxzSNUDXEkHIA4kaggiBeCnxLrTYhpLFIkc6bzjzz/b5YnpL5QwyBAkahl11rfjjjLEhBbjGy7VEEEpAbRIIQiLxUuJdTJsDMa0B7A4X6ps7YWtsQ/3pTqSlJIXVXiLc+Wdrx2BraofVYmY93moxw9bULmjN+b6tW/J3Hy/XEkEoBVlqiJgmEmb9eCjxLqUWC18WC5sV4pdjcrD62vFYvv2AqNpAgd+h2+0Ja/7ZahNtqmnApnmTkZiQ4PfeTG8pphWDEFK/+3i4lghCSUjUEDFLpMz68ZDSK3WxZUuJ5xJGOw43AwCenD0RnT19vOm8bN/hxrmlvGMXM/9cQuyp2RNR39yJ9u5eGJISYWtqx+ItNjhc/Wg+4+TtFG5raofZJE2AxMO1RBBKQqKGiEkiVfUViI8S71IWWy5rGJ8w2nG4Gcuu7ONNfeb6DoUQO/9sQiwDQL/bw1oU7pLzBuPiUWY8tH2/X+q3rzVn1qThksYaD9cSQSgJiRoiJomkWT8eSryLXWz5rGGdzvCsEFzfIRP/wlZTRo7553On2R0uzJgwDPOtBXD2uf2sOaGkc8fDtUQQSkKihohJImnWj4d+UWIWWyFr2KMzx3sfM+p1mF9egJK8TG/RuiyBeeL6DjfVNOC5ipKg+Bdm/oGBWjjhxFFxVZjOMOox/bzBsn338XAtEYSSkKghYpJIm/VjvcS7mMVWqIies8+NaUXZ+Oq7NjxXUYLNuxr8CtwJxTdxfYcOVz8Wb7Hhg8VT0ef2+M2/w9UfVC1YTByVlIByub/7WL+WCEJJSNQQiqJUkTElzPrR1i9K6twLLbb2bv5045ZOJ1ZfOx676luxeVdDkLsoML4pcHxpKUn45Zgcb2CxL6UjspAZ0GzS7nAF9ZNi+5xAQgkoF/rupc51tF1L8QoVSdQ+JGoIxVCyyBiZ9f0Jde75Flujnv/2MSg1CY++dwi/v2K0X1NLXz6tbUFrlwtdrn7W8a2+dsCF5StsuL7DUOKo+FxoD2zdhxUzxkKXmCBp8aJierEJfa/RATW0JBSBrYkgQySbGDI7q3g260dq7o+eOoNH3j3IGrBrtZhx/+XnY9a63fifuy/G7D9/xvk+Hy2dhi//3YacQYagJpGlI7I4U78Dd839bg+ufXGXt7FkYBxPgdmIYZmpZy1NDhdO2ntwrKWLtTGlUa/DG3f+DKfPOAEAeVlGDEk3CFpohOYaAO32owy17l/EWaihJeGH2mZTtYqMkVk/cnOflJiAW60FAMCa4mx3DAT6mvQ6zvcw6nXQJSTgvX0ngt6DaRLZ0d2LoiGD/F7HtmueWpSN5ypKsGzrPtz0sxG4bEwOWs+4YE4zwNnXj3//6EB7dy/yzzEiMSEhyFXl+5kA8FxFCZ78+7eo9hmX0M683dGLeWUjUXFRfpBQ+rS2BT909GD1/zvMu9tX+7eqNNFwvlQkMXogURMHaMFsSkXG1EPM3IeysJhNeqx5/zBK8rOCUpxf/+I7jB2WAQAw6ZM445tWzBiLP759IMjaw/w9v7wAjT86YDIk+S36bC6j6toWeDwebJo3GX/6+7fY8OkxPFdRgsf/ftjv/adazLjnkiLs/a6N8zMBiIoD8uVEezeWb9/vJ4J8hZLD1Y/v27p5Y3643HCx6uLQwr1JDHT/ih4k9346fvw4brrpJpjNZhiNRkyaNAl79+7lPL6mpgZWqxVmsxmpqakYPXo0nn32Wb9jent7sWrVKhQWFiIlJQUTJ07E3//+96D3WrduHQoKCpCSkoILL7wQ1dXVUocfd2iltwwVGVMPoblP1esEezyxkWHU45GZ47GvqR23vfQVFrz2NW576SvYGttw45QR2FTTgGlF2cg0JnP2h7ogP9NPBPiyq64VF+RnYfAgA/7d0oWvv/sR9ac70eZwBQkShpq6Vpzp6UNNXSvmlxewCpPqulY8/3+1XvES+JkleZkoyctkdasBZ3fmvnh/ZyzibPOuBtbPCnzPdkevJn6rSqGVe5MY6P4VPUiy1LS1tcFqteKSSy7BBx98gJycHNTX1yMzM5PzNSaTCQsXLsSECRNgMplQU1ODu+66CyaTCXfeeScAYPny5Xj11Vfx17/+FaNHj8aHH36IWbNmYffu3SgpGfBBv/nmm7jvvvuwbt06WK1W/OUvf8GVV16JQ4cOIT8/P/QZiHG0YjalImPqITT3Xze2h1x5mcmQ+qGjB9+3DYgg32J0TEBvhhGsmVTHWrp4x27S64JcQL8YnYM37vwZWjpd6OntD3Lz2LsHds0leZl+KeS+7KprxXwru9BgLE58BO7M+X5nzGdNLcqGramd8z27XH2a+K0qhVbuTWKg+1f0IEnUPPHEE8jLy8PmzZu9j40cOZL3NSUlJV5hwhz/1ltvobq62itqXnnlFTz00EO46qqrAAC/+93v8OGHH+Lpp5/Gq6++CgB45plncNttt+H2228HAKxduxYffvgh1q9fjzVr1kg5jbhCK2ZTykZSD765XzVzPK56jt3iKXZhYeKWhqanoKXTBbNJj1mThgcFZbPFN6Wn8O/G+90eP0Fj1Otww5R8PPH3bzljcBhBItRVm+v5EecY0d3bz/vawJ250O8MAB7lmWsA6HLxf6Zcv1WtxLBo5d4kBrp/RQ+SRM0777yDK664ArNnz8bOnTsxfPhwLFiwAHfccYfo97DZbNi9ezdWr17tfczpdCIlJcXvuNTUVNTU1AAAXC4X9u7di2XLlvkdc/nll2P37t2cn+V0OuF0Or1/d3R0iB5nrKAlsykVGVMPrrn/d2uXN9uHDSkLSyhB2Xw74KlF2dh9zN+dw+VSYv5eMWOs1xoiZG1he95qMaPf48HRU2cktWIQ+p3ln2NEljEZpSOyOHf7mamR/61qKYZFS/cmMdD9KzqQFFNz7NgxrF+/HkVFRfjwww9x9913Y/HixXj55ZcFX3vuuefCYDCgtLQU99xzj9fiAgBXXHEFnnnmGdTW1sLtdmPHjh14++23cfLkSQBAS0sL+vv7MWTIEL/3HDJkCH744QfOz1yzZg0yMjK8//Ly8qScbkzALBpsqGE2zTDqUZiThkn5WSjMSaMbgoKwzX2aQd2FhdkBB16jUy3ZWH71GGyqafB7nC/WZSAGJxNHTg5sXpgeUWxMLcpG8xmn32NM1tb8v32J051OPHzNOExliQNi25kL/c5yBhk4z5V5z5xBhoj8Vu0OF+qbO3H01Bk88L//0kwMi9buTWKg+5f2kWSpcbvdKC0tRVVVFYAB19LBgwexfv163HLLLbyvra6uRmdnJz7//HMsW7YMFosFFRUVAID//M//xB133IHRo0cjISEBhYWFuPXWW/3cXACQkJDg97fH4wl6zJfKykosXbrU+3dHR0fcCRsym6qHVsz8fGghVsB3B9ze7YKz141UvQ4n23uCrEhCLqVuVz8emTkezr593h5RgH/KebnFjFutI7H/uB0b55YCAHLSDfj4cLM3S+kvO4/hZwXn4KrxQzGvbKQ3ziZQCDGI/Z0J7fbl/q36WmY2zi1FdV0rax+urxvbcLrTqej1SvcmIhJIEjW5ubkYO3as32NjxozB1q1bBV9bUDAQlFdcXIxTp05h5cqVXlEzePBgbN++HT09PWhtbcWwYcOwbNky72uys7Oh0+mCrDLNzc1B1htfDAYDDAaDlFOMSchsqjxaMvPzoZWFxdd1xRTF+7ixOcgFJORSGpSS7He9dzl7UXVtMVz9bpzp6UNPbz92H2vFwtdtfoKp3GLGpPws72PLrx6DFz6pY83M4iq2NiwzFU/Onoi2Lhc6evqQnpqELKMeQ9L9Xet8bjo5f6uB2UXOPjeMeh1rHy6rxYxfTxiGa9fVeOdAies18LvKSNXD1e/GDx09cPT2a3IjQGgbSaLGarXiyJEjfo8dPXoUI0aMkPShHo/HL9aFISUlBcOHD0dvby+2bt2K66+/HgCg1+tx4YUXYseOHZg1a5b3+B07dmDmzJmSPjteoSJ0yiGUqipX9VG5LEFKiF7fsWakJsNkSEJnTx/r2Ltc/bA1tePQCXtQcT9bUzvKLWbUsIiNqT6WJbbrvb65E9etZ4/Bq6lrxQNXjka5JRtdzj5kpCbjwW0HWI/lCqAOR8gGfZdpA26OcAjMLjIkJfLGJD363iHMLy/wih25r1cumO8qWjYCsUo0WJbFIEnULFmyBGVlZaiqqsL111+PPXv2YMOGDdiwYYP3mMrKShw/ftwbZ/Piiy8iPz8fo0ePBjBQt+app57CokWLvK/54osvcPz4cUyaNAnHjx/HypUr4Xa78Yc//MF7zNKlS3HzzTejtLQUF198MTZs2IDGxkbcfffdYU0AQciNEqmqci8AkRS9vmP1tRT4LqzM2E16HR7Yug97f+rs/foX3/kV98syJuO6kuH449sH/IRNucWMNbOKec9BKNum6ceBlPQFr32NdXMu4D02MIA6HCEbqcU88HxtTe24eJSZM829uq4F86wjg8avRGq1UhsBgp1YEpSSRM3kyZOxbds2VFZWYtWqVSgoKMDatWsxZ84c7zEnT55EY2Oj92+3243Kyko0NDQgKSkJhYWFePzxx3HXXXd5j+np6cHy5ctx7NgxpKWl4aqrrsIrr7ziV//mt7/9LVpbW7Fq1SqcPHkS48ePx/vvvy/ZSkQQkSbSqarRtAAEjpXLUsCM/dGZ473HLt5iw/MVJUhJ1sHe3QtDUiJ21bfijT2NuOGifPzu5xb0ezxISkjACLMRw7OMrJ/P7D5T9TosvNTi19/JF1/Xlhg3ly+hCtlIfpeB2UWbahpQXsgemMvAFrOkRGp1NNWsiTWi6X4iBsltEmbMmIEZM2ZwPv+3v/3N7+9Fixb5WWXYmD59Og4dOiT42QsWLMCCBQtEjZMg1CLNwP+zMgk8L0Q0LQCBY+UriPdpbQu6XH3evxnhMee/vgg69oVP6vDCJ3X4+71TkZuRwnq+bLvP8oC2BQxWi9mbCs78X0pKd7/Hg41zS4MacjKfwSUM2L5L30Deo82dOMekD8kVEBgE7nD1wyFQf4dNzCmRWq2lmjWx4oYRSzTdT8RAvZ8IQmb0ukTOBdFqMUOvk9ydxA8tLQBCBI5VKHuJLduJK1tnU00Denr7JVlAGJeVb+xIucWMedYCv0aWr3/xHWuzTrYA6hPt3Xj03YO8PZ+4hEHg/HAF8obiCmALAv+6sY0zJslX2Pl+bigZcFKFgVZq1sSSG0Ys0XQ/EQOJGoKQmfZuF3/36m4XAFPI76+VBUAMgWMVcutkpCb7WReMydzZOs9VlCCdo2Ad3+6zpq4Vy68ei1+MzsGglGSkJCdi5TsHvYJq8RYbVswYi/xzUrHymnHod3vgcPUjIzU4gJqv5xMwIJ72NbVzCoPA+RFyz0l1BQQGgaenJuOG0jw8uG2/X7bb1KJs3HOJBfP/9qX3sVAz4EIRBlooLRBrbhixRNP9RAwkaoiYRg1TcpohGRV//QLzywuCulcv3mLDuwvLw3p/LSwAYgkcq5BbJ2eQwc+60O/xcGbrJAB4+vpJrJ8rtPvs6e3HpPws799PzZ4YUvaXUM+ne35uwZyL8jnfK3B+hNxzobgC2ILA2bLdAODdheVhZcCFKgy0UFog1twwYomm+4kYSNQQMYtapuTsND1KR2SxLk5y3CS0sACIJXCsTEG8BMDPBeI7dt/ml86+fs4KwjV1rejs6cOQ9LOPMSKWzSLk68bqdXtQf7rTK3JDzf7q6OnldY+lJOuQy3OtBc6PkHtOLlcA1/mGe+2EIwzUrqcVa24YsUTT/UQMJGqImERNU7ISNwk1FwCp1i82F8jT109CZ08f59iZRdfW2MY7Ft+FxlfELrzU4mcRkjNWxZeM1GRe91imUdh07zs/zj5pjTS1RrjCQM16WrHmhpGC2oJSTkjUEDGJ2qbkwJuEyZAEvS4RzWfkq5SqxgIQqvWLbay+FhYuxC40gSI2sEWC3LEqDCZDUkjusUCY+bE7XFHtCohmYcDmhmGscGWjzLB3u/yse7FGrBRoDS8NgyA0ihZMyUzzu5z0FKx67xCmP/VPzHxxNy57eicWbbHhRHt3xMcgJ0LWr8CGiEwjRVtjG+pPd4bUMFFs08NAEetw9WPxFhtK8rOwcW4prhw/lNONxYjcUOjs6RN0j0lBqOml1hedaGxSyRA494x1z9bYhhv/6wtct/6zqP3txhNkqSFiEq3sGKM1o4LNxSTF+iVXPJNYVx6biHW4+vHCJ3Uw6nV4af5FvJ/DJ3L53G2REM/R7AqI9vgM37l3ezxY9e5B2a17RGQhUUPEJFqJ6FfbDRYKXIJk8WVFvK9jFnC5hZyYRZ5PxM4vL0CvQAAul8gVEmfhiGc+sRTNroBoFmXA2bmvb+5kbWgKaPe3S5CoIRRAjbRqrewYQ9nJq1nRlE+Q3D29kPe1zAIeCSHHt8jbHQO76o1zS5GQkBBUzbdslBm7j7VyppJP5RC5YsRZqOI51ou8RbMoY9CCC5uQDokaIqKoefPWwo5R6k5e7cWOT5DsPtaKqUXZrM/7LuBKLgZs8+Vbzbd0RBYMSYlBgcO+xz7y63Gs14QYcVaYkyZZPEerSzLe0IoLm5AGiRoiYmjh5q32jlHKTl4L88UnSDbVNGDbgjI8+t4hzhozgHKLAdd87aprRWJCAj5YPBWZxmS0dLq8gcNsBRED35OxkhmSEnkbYDLiTKp4jmS/J0I+tOLCJqRBooaIGNEYTyI3UtxgQvN10t6DYy1dEXVJ8QkSh6sfJ9t7MCk/Cwt+bkFKso61dYBSiwHffFXXtqDP7fGOixlPYEHEaUXZuKN8oKWFkNUnUNj4ijMp4jmS/Z4I+dCKC5uQBokaImKQT3oAsTt5ofk61tKFBa99DSByCx6fILFazPiqsc3bIfvjpdNRmJMWdJyUxSCc+CGx15eY8dgdLuw8ehrzykai4qJ8v6rAQINfA0zmtaGKs0j3eyLkQwsubEIaJGqIiKGWT1rNQFsuxOzkhebLt/R/pBY8LgHANONkOlkDgL2bW1SIWQzCjR+Scn0JjafN0Yv39p0IirdhrDTzf2pQyozRV5xJvd6U6PdEyIfaLmxCGiRqiIjB3Ly/+q4tqDfOqY6eiPik1Q60DQchK0lg/EekFjxGADDuLt9mnL4umJ7efpxo7+acV6GMpXDjh6S6ubjGY3e4sGL7ftaqwMCAJSUjNRnbF5QFiaFQrje1+j0RBBda3AiGSoLH4/GoPQil6OjoQEZGBux2O9LTRdRoJ8LmZHs3vvvRgec/qfVbNKb+tNuVU2jYHS4s3GLjzM6JBjP+ifZu72LHBI9ePMoMXUICunv7sTcgXXn7gjK/btNyYne4sGiLjVNkleRnYV9Tu6R5ZW6ePzpcONPTF5R+zcDl2grEd74YGEsKXyNJX+qbO3HZMzs5n984txQjzaag8YR7vTFz4ezrx1XP1XAeJ3YuCCIUomUjKHb9JksNEVGMeh1e/KQuaBdcHQH3SSwEJicAuLI4F/OtBcjNTMHq9w6xNkpkrCaRTCtlLApswbOMK8rh6hc9r1ICccVaJ+SIeRCKzQHAalUM93qLlX5PhDS0ZBXRQsal3JCoISJKS6cL1XXKCI1oD0y2O1z4g0+XaVtNG69LZF9Te8QXvGGZqVgxYyyafnT4pUH7ihAx88qXfg0gKBBXilgLN+ZBKDbn3KxU1veX63qjLJv44UR7Nx74331+90Q1rSKxsBEMhEQNEVGUFBrRXizL9wbDFzy6q64V9/zcgjkX5Styw9ElJOC2l77ifF7MvPLdPHfVtQYF4ippnRCKzRmansL6Ojmvt0hl2WjJKhALhDOfdocrSNAAA+Lhga378IIKVpFo3wiyQaKGiChKCo1oL5ble4MRCh5NSdaJjhkJFznmVejmyZyvWOuEnIt1qJYSua83ubNs1IyViEUxFe58Np9xclqtq2tb0HzGqfgcRftGkA0SNUREUVJoRLsZ3/cG45u+zUZGqnI3GznmVejmOdJsxMdLp4uyTkRisQ7FUqLl603NWIloCTyVghzz2c5TAgHgL5EQKaJ9I8gGiRoioih944/mYlm+NxhbUztnA0Y1bjahzKvvbv0cE//Nc3gme9wK23tGarEOxVKi1etNrViJWAw8BeSZT5Nex/u8UeD5SKBlYR4qJGqIiKP0jT9ai2X53mC4GjCqdbOR6k4I3K0b9TpsmjcZHiBoBy/lfLQY2Kjm9cb1vagVK6HF70cO5JhPkz6Jc6NitZhh0quzHGtVmIcKiRpCEaJVaCiN7w2my9mLqmuL4ep3o8vZp9rNRqo7gW237nD1Y/7fvsSKGWPxxxljQz6fWAxsDBW+70WtWIlIfD9aiM+RYz4zjclYdGkRgOBO8YsuLUKmUb34lVi6P5OoIQiNoaUbTCjuBK7dusPVj8q39uPjpdMlFQz0XdRSBUz00RjYGApC38uTsyeqEisht5jSSnyOHLEnGUY9RpxjxIwJw/w6xTefcWLkOUbN/OajHf5oRIIg4hox7oRA5Nytn2jvxsItNlz2zE7MWrcb7+07iXKLmfXYaA1sDAWh76XL2YfHfzMB04qy/Z6LtPuSWfzZkPr9CAk3uyP42osUjGs43PnMzUzFVeOHYqTZhGEZKRhpNuGq8UMxNEoDqLUIWWoIguAkFIEix27d7nCh+YwTjT86cKu1ABPzMrGppsEv1qhGA7FGaiH0vXR092LU4DTFYyXkDDzVWnyOXLEnWrLExiIkagiC4ERIoKSnJgfFPKSlJIVlqhdqp7B4iw3zywuw/Oqx6Ontj/rAxlAQKxzVWEDlWvy1GD9FgkT7kKghCIITvliCX47JgV6XGNTU8ZdjcrD62vFYvv2A5N262HYKL3xSh1+MzmGNzdFCYGmk0Xp9ETkW/1gsDEdEHhI1BEFwwudOWPnrcVj21v4gAbLjcDMA4MnZE9HZ0ydpty6lnQLbohZKYGk0iqBYrC8SiNaFG6FNSNQQhEiC3CyGJHQ5+2Dvjp7FMBS43Al8AmTH4WYsu7IPhTlpkj5LSjuFwEUtlEwtKSJIa+In1uqLBBIPwo2QHxI1BCECtsWv3GLGPGuBt2N1tJeC54PNnXCspQvAQGG9+eUFKMnLhLPPjZRkHb5ubEOXU3rMg5DLwZCUyLmoSQ0slSKC2L7/qUXZeHTmeGQZk1VbYGM9xiPWhRshPyRqCEIArsWvpq4VHpyN85BaCl5rO3+ppKckw6jX4bmKEmze1eDXVdxqMeM/LjhX8nvyuRymFmXD8lNGD9s8SQ0sFSuCuL7/6toWPLR9P2ZMGIbp5w2OSTGrBWJduBHyQnVqCEIAoTiPkrxM799ctVsCCay/ctnTO7Foiw0n2rvlGnbEyU7TY8WMsdi8qyGo9Puuulb88e0DkmuJ8NUD+dNvJmBEtolzgZMaWCpWBAl9/zmDDIrXTSEIgh2y1BCEAGLjPBiEUk1jpelfhlGPC/IzUfnWftbnQ60lEqrLgcvKY9TrsGLGWLg9Htga27xWMbEiSMz3H819jeQi2i2PRGxAooYgBBAT5+GLUKqp1oqKScV38TIkJWLhpRZsqmmAw9UfdGyotUT4XA5ciydbYCnTSPPFT+r8xNe0omysua5YVHaN0Pd/blYqNs2bDLfHE9K5xgJaaWdAECRqCEIAvjgPq8UMW1O7928xqaZcO38m4NbZ1+9nUdCSwBEqjBcobOSuJSK0eAZaebKMeizffgDVdcFWsZXvHETVrGI8uG0/b3aN0Pf/j0On8MIndZj60+uUXMS1YB2JFcsjERskeDzxs73o6OhARkYG7HY70tPT1R4OEUWcaO8OSi1ly3564jcTkCuwqNU3d+KyZ3b6PeYbcLsroPy/Vna7pzp6UN/cifbuXm+GE2OhsVrMKMnP8gsWnlaU7V3Q5Fh87Q5XUKE/ts/yhW2uffnk/5sOs0kv6Opi+/6tFjNu9fn++cYRCbRiHRGa44+XTpec2k8QgYhdv8lSQxAiYIvzSEsZqFPz+u1TJKWasu3855cXsAbcamW3e6K9Gw/8779Q7TM+XwtNYGE8X2uHXItvKG47sT2ShOaW+f5/6OhBu6MXnc4+2Jrag6xTSrkPtWQd0WI7AyJ+IVFDECKRK7WULfajJC/Tz8rhi9pxNt4FlCXDCTib0p6RmoztC8r8BJ6ci6+azTV9rUxZxmTc+rcvWWOIuMYhN1qKy6J2BoSWIFFDECoQaPnpdfN7gdXc7YptXZBl1Ae5Gdhe61us72hzJ84x6UW5o0JZPMMttc9VdI8rhohrHHKjJesItTMgtATVqSEIlcj4SQRMys/COQILupq7XTEpzVyLV+BrmdghW2MbbnvpK8z+82eia/QwiycbXJ/PV/cm1Oaa1bUt+NuuBswvLwh6jVKLuJasI+HMMUHIDVlqCEIDpKUkodxiRk2AiwcYCEhOS1Hvpyq0gGamJnMuXoGvDSd2KNReQKHWveGzUNXUtWLBzy1BgdFKLeJas45QOwNCK5CoIQgN0OXswzxrATyA34Jv/SnDqsvZp9rY+BbQX4zJwQizEfaeXjQ1dCM9NQlZRj2GpKewvjbc2KFQF89Q4qGELFQpyTp8vHS6Kou4Fps9UjsDQguQqCEIDWDv7sXiLTbMLy/AfGsBnH1uGJISvRk2r98+RbWxcS2gvxyTg+UzxuKBrfv8LEzlFjOqZhUj32wKem1g9eVAxMSCKLV4Mr2t2Jp1bqppQEZqsqqpymQdIYhgSNQQhAZIT0mGw9XPacUQipGIdBE2tgU0Va/DH/73X0Eus5q6Vjy4bT+evn4ShqSn+L3W2ceeMcSgpUyZ7DQ9Ns2bjOc/qQ1q1rlp3uSIunjEfp9kHSEIf0jUEIQGCCdGQqkibIEL6LcnO1hjgIABYdPW5fK6oZjX2h0uTcWCcGF3uNDe3YsXP6llbdaZmJCAFypKIvLZkfg+tVB5mCCUgLKfCEIDhJpBIlQHJpKdowUL2/UExwFFQ6YM00G9rrkzqDYPQ7XIbuxSicT3qUZHeLvDhfrmTtga21B/upM6mEcAmmN2yFJDEBohlBgJtYqw2R0umPT8t490jowtLceC+IqKiovyeY+NRC0Yub9PNSoPa6V9QyxDc8wNWWoIQkP41q4pzBEu369WEbaWThd+6OhBucXM+ny5xYwsE/fYpZ6nUviKisDu64FEIv5H7u9TjEiSEzUth/ECzTE/JGoIIopRqwhbR08vHti6DytmjAsSNuUWM1ZfW+yNp2GIBnO5r6iwNbXDyiHaIhX/I/f3qbToVVpExSM0x/xIFjXHjx/HTTfdBLPZDKPRiEmTJmHv3r2cx9fU1MBqtcJsNiM1NRWjR4/Gs88+G3Tc2rVrcf755yM1NRV5eXlYsmQJenp6vM+vXLkSCQkJfv+GDh0qdfgEEVOEUmVXDtJTktHS6cKc//oct1oL8O4iK7bc8TO8u8iKW60F8Hj82z58/6MDC1//WtG4jlDwFRWbahpwq7UgSNhEMv5H7u9TadGrpfYNsQrNMT+SYmra2tpgtVpxySWX4IMPPkBOTg7q6+uRmZnJ+RqTyYSFCxdiwoQJMJlMqKmpwV133QWTyYQ777wTAPDaa69h2bJl2LRpE8rKynD06FHMmzcPAPwE0Lhx4/DRRx95/9bpdFKGTxAxRySLsPFlzPhma9320ld+r5tWlI3nfTKDjrc58MBb+zTbgdwX3/NyuPr9agcBQP45RuQMMngzueTOKJLz+7Q7XHB7PNg4txQJCQne+jpMv6pAkSTH+WipfUOsQnPMjyRR88QTTyAvLw+bN2/2PjZy5Eje15SUlKCk5OwNbuTIkXjrrbdQXV3tFTWfffYZrFYrbrzxRu8xFRUV2LNnj/9gk5LIOhPlUGqp/EQi8FYoEFHs4mt3uPBdqyNI0DCo3YE8kMDzYmoHMeeV+1MQpthAzVCudynfJ9f7s43PajF7G3GWjsjy+57kCjzVWvuGWITmmB9Jouadd97BFVdcgdmzZ2Pnzp0YPnw4FixYgDvuuEP0e9hsNuzevRurV6/2PlZeXo5XX30Ve/bswUUXXYRjx47h/fffx9y5c/1eW1tbi2HDhsFgMGDKlCmoqqrCqFGjOD/L6XTC6XR6/+7o6JBwtoTcUMR+5JCzCJvYjBkxi29L50C9Fz7O9PRqSuwKnZfY+TnR3o3H/t8hXHfBuchJN6C5w4me3n6ccfbh3Cwj7xjEfJ8n2rvxwP/uQ3Wd/+9pzXXFWPbW/qDxMfV1Plg8FZnGZL/z+ePbBzAxLxPzykb6VU5++O0DeGr2RNHfhRbbN8QaNMf8SBI1x44dw/r167F06VI8+OCD2LNnDxYvXgyDwYBbbrmF97XnnnsuTp8+jb6+PqxcuRK3336797kbbrgBp0+fRnl5OTweD/r6+vC73/0Oy5Yt8x4zZcoUvPzyyzjvvPNw6tQprF69GmVlZTh48CDMZvZgvjVr1uCRRx6RcopEhFAjtVTraGkh90VKWrHQ4tvR0yuYRZSq12HhFpumxC7feYkN1Hzs/x3C4svOw6r3DvpZqsotZjw2qxgjzKag14u9JuwOV5CgYT7/u1YH5/iqa1vQ5/b4vWdrlws3XJSPzbsagion32otQGuXNEuallP2YwWaY24kiRq3243S0lJUVVUBGHAtHTx4EOvXrxcUNdXV1ejs7MTnn3+OZcuWwWKxoKKiAgDwz3/+E4899hjWrVuHKVOmoK6uDvfeey9yc3OxYsUKAMCVV17pfa/i4mJcfPHFKCwsxEsvvYSlS5eyfmZlZaXfcx0dHcjLy5NyyoRMqFVPRato2WolZyBiekoyPv62GVaLmdUFNbUoG183tkeV2BWanzaHC0mJCfiPC88NEjTAQLXlh3zaSDBIuSaazziDBA2DGMuYL31uD2vndObvldeM430/Nqh9Q+ShOWZHUvZTbm4uxo4d6/fYmDFj0NjYKPjagoICFBcX44477sCSJUuwcuVK73MrVqzAzTffjNtvvx3FxcWYNWsWqqqqsGbNGrjd7A3wTCYTiouLUVtby/mZBoMB6enpfv8IdaCI/bNovc6EnIGI2Wl6HDnZwZpFVG4x49GZ4/Hoe4dYXxvp9NRQU8yF5sfe3Yvlbx9AbkYqZywR00bCdyxSrgk+4SKlvo7d4UK/28M5zl11reh3e1ifIwgtIslSY7VaceTIEb/Hjh49ihEjRkj6UI/H4xfr4nA4kJjo/0PU6XTweDxBqaEMTqcThw8fxtSpUyV9NqEOFLF/Fq1breQMRMww6vHIzPF4+O0DKMnP8nYgz0xNxgizES2dTm82DhuRErvhWMr45sdqMcPWNGB5Oi6Qru7bRkLqNWHSc2d+2praMbUom/X9fL8/Zg7umModlwiA9/shCK0hyVKzZMkSfP7556iqqkJdXR1ef/11bNiwAffcc4/3mMrKSj9X1Isvvoh3330XtbW1qK2txebNm/HUU0/hpptu8h5zzTXXYP369XjjjTfQ0NCAHTt2YMWKFfj1r3/tTdu+//77sXPnTjQ0NOCLL77Af/zHf6CjoyMomJjQJmrVU9EiQlar9m51LTVy92calpmKp2ZPxKxJw2E26XH+kEEYNywdw7OMSDMoL3YDrSJGvQ4LL7VgbtlIHD7ZgdpTZ3itNlzzw8SgbKppEDUO3zYSUi2ZJn0SZ2HAQyfsWD1zPO/35zsHfQKWmIzU+NlwENGPJEvN5MmTsW3bNlRWVmLVqlUoKCjA2rVrMWfOHO8xJ0+e9HNHud1uVFZWoqGhAUlJSSgsLMTjjz+Ou+66y3vM8uXLkZCQgOXLl+P48eMYPHgwrrnmGjz22GPeY77//ntUVFSgpaUFgwcPxs9+9jN8/vnnkq1EhDpQxP5ZhKxWzl437A51rTVyByJy+f/VSE/1tYoY9To8V1ESFCQrZLVh5ud4ezf+3eqAISkRtqZ2LN5i81o2bE3tmGoxszbFDGwjIdWSmWlMxqJLiwDAz3VktZhx57RCZBqTeb8/3zn4urGNM+Yp3jYcRPST4OHy78QgHR0dyMjIgN1up/galWCyO+I5Yt/ucAVl+zBYLWaU5Gdh1qThKMxJU2F0ynOivZtT7Br1OtkzxGyNbZi1bjcAYOGlFtga2zgXdKFA5frmTlz2zE7W54x6HbYvsOIRluynqlnFyPfJfrI7XFi0xcYp7tjGcbK9G/88eho5gwxw9rlhSEpE8xknLjlvMIYKuNB858BX2PmOM7A2D0Goidj1m0QNQahA/elO/PHtA0G77FutBVi8xYbXb5+CSflZKo5QWdjErsPVjz/IlCHmmyqdqtfhvX0nsammAc9XlARVRPbl46XTecUlnxixWsy4qOAc9PZ7cOX4oehy9iM9JQlZJn1QXyyAX9xxCYtQNwmBYsyo12F+eQFK8jLh7HNjVLYJuRkpcbfhiEa0WhpCbsSu35LcTwRByEMC4Bc4G+i+iKfAaSDYPWV3uIIEDRBaqjdbUHD5T9V1Xf3s2ZUMQoHKjFuVrXovI1Adrn7MmjQc44Zl8L5XKC6/UNN6A91+TOVkQJyFitAGWi4NoRYkaghCgEjshMwmPfY1tfvFcTBMLcpGWor4n2Ys7tTkyBCzO1xoPuNE448O3GotwMS8TG/vo5qfLGT3/eI83vcQIy6ZQOj65k60d/cGCVQpcSlK1R6hGLfohwqaskOihiB4iNROiGtRsVrMmFs2Esu37ccjM8cLfkas7tTCrWsk1PuIETaPztSLSn8WYkh6CvrdnqgSCVSVNrrRemkItSBRQ0Q9kbJURHonNCwzFU/y7PCdffyfEcs7tXDqGnHNCxO/NL+8wGshO9PTiydkslhEo0igqrTRCxU0ZYdEDRHVRNJSocROqLOnDzf+1xchfQYzvsAgT6YZodSePVoinFRvvu9tV10r5lsLvH+bDMleMdLu6EWXqw9drn5kpibDyFPgDuAW03IJ6lhzKRLyQgVN2SFRQ0QtkbZUKLETCuczOnp6OeusWC1mzCoZHvb41CKcmA+2OfUVfkZ9EjbNm4xTHT1ecdTl6sfytw+IFseRFNOx6lIk5EWNGk/RgKSKwgShBZiePUebO3GrtQALL7UE7arl6BukxE4onM9IT0nG/PICzmaEK985qHofqXBgLCgfL52O7QvK8PHS6Xi+okSwbkrgnDLCz9bYhtte+goVf/0c8//2Jd7ffxJdrn7JfZci2btL633BCO0gd+XvWIEsNURUISYAlCFcS4oSO6FwPiM7TY+yUWbWDCoAqFYgWJDPTSKHCyUUd07gnHIJv+qfhMKjM8dLcjNG0i0p9N4nO3r8jiX3VHwTjXFckYZEDRE1SAkABcK3pCiR9hrOZ2QY9dALdGSOZLAgn5skAZCtcJ5UAue0JC+TU/h9WtuCLlcf63MMgXMYSbek0Ht/1+pAu6MXL35Sh+o6ck8RFOwdCIkaImqQEgAqlyVFiZ1QOJ+RJXBMpIIFhdwkVxbnqpqV5TunrV38LhuhLtSBcxhJt6TQe+dmpOCJv38bZHWKhYw3gpADiqkhogahXayzb6A6rNw+5QyjHoU5aZiUn4XCnLSILBqhfoZa3c+F3CQ5gwycz4Ub6yQWZk7NJv45yEhNljSHkZxzvve2Wsxw9blZ+1QBys4tQWgVEjVE1CC0ix1pNooOJo0V1AoWFCsw2Qh0zzCB37bGNtSf7pQ9GFZIhOQMMkiawwyjHquvHY9yi9nv8XKLGauvHR/WnHN9n0zbhdOdTt7Xx2ttEoJgIPcTETUIBdUOz0yNS9O7GsGCQgLTwBPr4+ueEZO+HG7AsZi4pQwjRM+h3eHCqvcOYVJ+Fm4N6N316HuH8NTsiWEXZXy+ogQn7T041tLlV5Tx+YoS3tfGa20SgmAgUUNEDdSvhhulgwWFBGbzGXaLgq97RkydoS5Xvyw1W8QIP7Fz2NLpwkeHm/HR4WbO58P9LpjXV71/2G+ObU3tsFrMrC4oLdUmoeKBhFqQqCGiimhMYYzFG7yvwPzquzZvYTsAyMsywmTQ4ZdjcrDDZ+EPFJ9CcTnNZ5xY9d4h2QKO5RJ+SpWnZxPxm2oasGneZCQmJAQJPa0IeyoeSKgJiRoi6oimFMZYvsEzArPN0YsV2/f7pU1PK8pG1axiVF41Bh3d7OJTSBzYu3s12bBPyfL0XCL+BY0K+1juR0ZEByRqCCJCxMsNfsXbB1DNkmL84Lb9eL6iBKMGp7G+TkgcCPVeUisoNlJFGfl6SbFdJ1q8dqhzNKE2JGoIIkLEww2++Ywz5HMUEgcmPf/tSa2g2EjEdsWKRY86RxNqQ6KGICJEuDd4rcfinGjvRuOPDt5j+M5RSBwY9TrNNuyTM7ZLikVP69cEdY4m1IZEDUFEiHBu8FrfuTML8byykbzHCS1iQuJAy9lucsV2ibXoMdfEXp/A7H+3dCEvy4gh6QbV5wOgztGE+pCoIYgIEeoNPhpicZiFeGJeZtgpxnziIBqz3aQixqLHXBN7v2vDcxUl2LyrISgwO1DwqmHVobILhNqQqCGICBHqDT4aYnGYhfiNPY34r7mTkYgjfg0Wp8rc9FOt81VCGIix6DHXxMJLLawdxwMFr5qWvngQooR2IVFDEBEklBt8NARbpqckw6jX4fHfTMBzHx/FxPxMzLOOhLPPjYzUZORlpUZ9qwq5hMGpjh60dbnQ0dOH9NQkZBn1GJKe4n1ejEXvWEsXAAh2HGd6P6lt6YumsgtEbEGihiAijNQbfDQEW2an6bFixliv1eCTb0/7PT+tKFsTbrJQkcsF2Njahcpt+/0sK+UWM6pmFSPfbAIgzqKXnuKCUa/DOSY9Ns4thbPPjZRkHb5ubMOmmgZvp3FG8Grd0kcQkYJEDUGoTKCLIy0lKagaL4NWgi0zjHpckJ+Jyrf2sz4f7YunHC7AUx09QYIGAL5ubMeuuhb09LrR5erzurWeryhB8xkn7N29MOp1MBmSvLV6stP02DRvMp75xxG/mkBWixnPVZRg8RYbHK5+DEpJjgpLH0FEChI1hCbQeqqq3DDn2+ZwobffjV31rd4d97SibKy+djwA8LYZUBvGOsBFNC+ecgiDti5XkKAx6nXeQN/KbQe8jzPf+RN//9avpxTj7jLpdXjxk7qgIofM+88vL8C+pnZRglcLlj6CiBQkagjV0Xr6stywna/vjvvT2hYs334AT86eiGVX9mk22DIa3GShIse5dfT0BT02v7yAM9D3wW37MSk/y0/UMO6uFTPG+gVi+7KrrhX3/NyCORflI8OoR0+fG+UWM2pYMtLKLWakpdBtn4hdEtUeABHfCMUu2B0ulUYWGbjOd1ddKzbvasD88gIAA+ff2dOHwpw0TMrPQmFOmqYEDXA2wJWNaUXZSEtJQn1zJ2yNbag/3RlV36XQuYmxiKSziIeSvEzW9HcAqKlr9TYF9eXT2ha0d/NbhlKSdd7A7C5nH+ZZC2C1mP2OsVrMmGctQJczWGwRRKxAooZQFTGxC7EE3/nuqmvFFeOGYuGlFhj1Os27b5gA18DFn3GlPLRtPy57ZidmrduNy57eiUVbbDjR3q3SaKXBd25iXYBZJj3KA4SFs8/N+xqu500CfbAyUs9ajuzdvVi8xYaS/CxsnFuKdXMuwMa5pSjJz8LiLTZ0CAgkgohmyA5JqIpQ7EJrlws43RkzMTZC59v0owO2xoECa+mp8rhvQolXEvsatpT1tJQkPLRtv58bBdBW8UAxhFtvZUh6CqpmFePBbfu9riBDEv8+kut5kz5JdCHH9JRkOFz9nKnf0ewWjEbiLV5QbUjUEKoiFLtwpqcX1//lM0kxNlq+iQidryEpEbvqWpEA4OnrJ4X9eaHEK0l9TWDKen1zZ5CgYYi2rKhw663km014+vpJ3jo1g9P0mFqUzWqtK7eYYWtqD3p8WlE2Mo3Jogs5UqsC7RBv8YJagNxPhKrwxS5YfW7yYmNsTrR3Y+EWm2bdHmLPt6auFe1hxqCEEq8kR4wTpRT7MyQ9BaNz03FRwTkoGJyGJzjcWlWzinHkZEfQ44xoYSxHHy+dju0LyvDx0ul4vqIkqMihHK4zInyUjhe0O1xRG8MmJ2SpIVSFq/CY1WLGrdYCLN5i8z4mtMuPhp5JUs73+7ZuDE1PCXnModRakaM+SzRlRalh1eNzaz01eyKvu0us5YhaFaiPku1OyCJ0FhI1hOr43oBbuwZuwramdm9BMV/4dvnR0DMJOHu+J+09ONbSBUNSIuf5hjPmUCwm4VpZ7A4XkhITOF0svllRarsH1VwIuMSJnO0FYr1nltZRymIZDZs5JSFRQ2gC7w24uRPX/+UzzuP4dvnR5PZgbjKPvX+YdfFnXFFmU+g3o1AsJuFYWRiRwHSSdns8funLvllRbAXmlIyXooUgcpDVYAClLJbRsplTCoqpISKOFF9vOPVB0gz8Gl1Lbg9gQNg8OnM8az2RW60F2FTTENaYQ5nLUOffVyQ4XP1+KcUb55Zix5JpeHL2RKx67xBnVpSS8VJKlhKIp1iHeKs7xYcctY7EEE2bOSUgSw0RUULJpBGb5RH4OV991warxcxa3EyrWR9ZxmTMmDAM860FcPa5/VxRpSOywhpzKHMZ6vwHioTAlOKPl05HZ09fyFlRcltWlFoI4s1qQVaDs4T6W5JKNMWwKQGJGiJihLoQSQ1yZD6HcXsACHJ7VM0qRmuXC8daujTl488w6jH9vMERu/GFEjAaymvEiASPwFgjGS8V6LY6x6iHUa/j7F8lx0IQjy4ushr4o0TANqXw+0OihogYvguRUa/D/PIClORlwtnnRkqyDu2OXs4ft5QgR9/PWbzFhvnlBV7LR0qyDpbBJqx892DIcRyRJtI3vlACRqW+Ro7dohzxUmwxN12uflZryaZ5kzH/b18GCRu5FoJ4tFqQ1SCYSAdsK2URihZI1BARg1mIfDsT+7okpv70owtXWPgueIFuj4WXWrC55lhQd2Ot7ZbVzFSRA7G7xVB3lGIWSzZXz5rrivH+vpNBzSA/rW2BB8CKGWNR+dZ+v3HItRCwCTFfcR9r1bIBshqoBaXwn4VEDRExmIWIqzNxtUzCgm/BK8nL5CwXH6u7ZTUQu1t8/DcT8PDbB3B+brrXapdlTEb+OUbe70FosUxLScL9//OvIMtIziADZ3fr6toW3HtZEV6/fQoMyYnITNV7F4Jws6zsDhdSk/37NQWKe0bglI0yQ5+UiCyTXlaBo0ZaNVkN1CPaN0ZyQaKGiBjMQhRpYcG34AkRbz7+SCJmtzgsMxUPXzMOlW/t87smhNyBQotll7OP1dUj1ECy+YwTC177GtOKsr3iOtzgXub1E/My/QLXfcU9l/WS7XNCESdqBiiT1YBQExI1RMRgFqLDAaXfAwlXWPAteOdm8d/A49HHH0mEdot2hwuV2/bzugMBsC7iXIslALQ5XFg35wKkJOvwdWMbNtU0wOHqF91A0jeNO5zgXt/g4MDAdV9xz2W9DPycUMSJFgKUyWpAqAWJGiKiDMtMRZezj/cYOYQF34JHPn5lsTtcaD7jRHt3L0x6HUyGJGSmJiPDqBcMnv2howetnS60d/ciJVmHj79txpGTHXhk5ngMy0wNWizZFn2rxYznKkqweIsNtqZ2zjR/a0ADSUZchxPc63t+TL0eJnDdqD97uxVjvQRCE1jxGKBMEAwkaoiIkzPIoIiw4Nodko9fOU60d+OB/93nF8ditZix6NIijDjHKJjF9H1bN2576Su/195qLcDDbx/AU7Mn+n1fXBYJX3fPppoGbJo3GbqEBMFeW4NSksNOSQ58vW/g+sa5pd7Hhdxi4QgsSqsm4hkSNUTEUTt4UEkfv9Z63ig5HrvDFSRogLMiY8aEYSgdkSXpPZnXluRnBS3ifBaJXXWtmG8twIUjspAzyIBVM8fB2efG920D1YcDe21NLcpGql7H+l6+sFkVfeeY7z1sTe3enlhCbrFwBJYW0qpPdfSgrcuFjp4+pKcmIcuox5D0lIh/LkGQqCEUQe3gQSV8/FqrHqv0eFo6Xdjb2IaFl1r86hExMS7zrQXQ6xI5rXaB7iAGRqB0OXv9BESfm7+cX5ohCRPzMjHj+Ro4XP24dPRgPPCrMVj13kE/d5TVYsbcspFYsX0/Vl4zTpJVMXCOF15qQbnFjBoWd9eRkx1YM6sYD27bz+sWE2u95BInaqdVN7Z2oXLbfr9zK7eYUTWrGPlmU0Q/myASPB6PUKHPmKGjowMZGRmw2+1IT09XeziEzETSKiH03naHCwu32Dg7UytdD0fJ8TBz0+YYiIUJDIBlXD39bg9y0w3IHpQSZLWbWpSNFTPGoqGlC8m6RL9gXwD4y80X4vwhg7Di7QPec9o4t9TPVRUI2/OXjh6MOVNGeP/OSE3GP4+e9n7WZaMH4+Ffj8fybftZrYq5AVlJgXPMZDX9bVeDn7Dxfb3dMdCN3gNg5TsHg0Sn73GLttg4xQnfd3iivZvTMpobQYF9qqMH/99/f8Mq6sotZjx9/SSy2BAhIXb9JksNERNE0ioh5r21FpzJjMe32Jur342cQSlI1iWg7nQnMo3h10XxnZt3FlpZM3qYvx/41WiY9Eleq13zGSea2hwYPMiAA9/bce2Lu7wixjfY1+HqR15WKlZsP+Dn2pISBMzwybenMWfKCK/Y2Ti31L9H1ben8Ydf9YmyKrJ9577BwcuvHoue3n7W13s8QKezF6uvHQ9Xnxtdzr6g48Jx2w7LTMWTsycq7gJqc7hYBQ0A1NS1os3hIlFDRBQSNUTUE8kUVrHvrbXgzI6eXs5aKIzl5OaNe1A6Iitk4Rc4N64+N6vAAAaEjdsDr+uDyYT6urEdtsY2TiE0v7wA3zS2QZeYEBSrs6mmgbXX19SibMwtG+kXBOyLb5AuW8CuvbsP5w8VFntc3zkTHPyL0TmYlO8fQyRVfIfqtlXLFXqmhz/TUeh5gggX/mg1Fo4fP46bbroJZrMZRqMRkyZNwt69ezmPr6mpgdVqhdlsRmpqKkaPHo1nn3026Li1a9fi/PPPR2pqKvLy8rBkyRL09PT4HbNu3ToUFBQgJSUFF154Iaqrq6UOn4hBxFhJIv3eWgjO9CU9JZmzFsquulZs3tWA+eUFXnFmd0ifo8C5Od3p5D2+v9+Nlk4XbI1tqD/diX6PB1NGnIOS/CxsnFuKdXMuwKZ5k7HwUguMeh121bWibJQZj183gbXxJGMVKcnPwvuLy7F9QRk+Xjodq2eO9wsCDsQ3SJctYDc9RdxeT+p3LiSQub6DDKMehTlpmJSfhcKcNEFBE+rnyEGagX/uhJ4niHCRdIW1tbXBarXikksuwQcffICcnBzU19cjMzOT8zUmkwkLFy7EhAkTYDKZUFNTg7vuugsmkwl33nknAOC1117DsmXLsGnTJpSVleHo0aOYN28eAHgF0Jtvvon77rsP69atg9VqxV/+8hdceeWVOHToEPLz80M7eyImsHfz36Tt3aFbScRaYNQOzgwkO02PslFmzlooTPAtELp7rNPZ6xcUfG6Wkfd4Z58blz2z0/v3L8bk4KGrx+DP1W1BliTG9ZSSrMO55xg5U6AZq8isScMxdlgGgIFFvXRElmAwMpuLqtxiRpZJ3DxI/c6VclGq6QrVJYDXJahLSIjI5xIEgyRLzRNPPIG8vDxs3rwZF110EUaOHInLLrsMhYWFnK8pKSlBRUUFxo0bh5EjR+Kmm27CFVdc4Wdl+eyzz2C1WnHjjTdi5MiRuPzyy1FRUYGvvjob5PfMM8/gtttuw+23344xY8Zg7dq1yMvLw/r160M4bSKW8C1qxv68cKouF2J240zg58O/HoepRdl+z08rysaqmePx79Yu1J/ulHWXbHe4UN/c6bV8+L53hlEPvUDasK9QCMU9lpGqh62xDbe99BUWvPY1Pjz4A8otZtZjyy1m7D7mv9CNzk3H8u0HeC1JGakD888ICDYCBQQTixJ4PON221TTgKlF2Vh4SRE21TT4jbFqVrHomA+uz+GKeVHKRammKzRJl4hbrQWwBlwHzNwn6UjUEJFFkqXmnXfewRVXXIHZs2dj586dGD58OBYsWIA77rhD9HvYbDbs3r0bq1ev9j5WXl6OV199FXv27MFFF12EY8eO4f3338fcuXMBAC6XC3v37sWyZcv83uvyyy/H7t27pZwCEYMkJibw7w4TQ7+RCu3GU5ITvRkwTFDu76YXwpCciDRDEr5ubMdVz1V7XSFKBi9n+SyqvgHDTKp1dpoeRr0ODle/ZPeY3eHCigBB4hvjUiMixoWvqu6uulbc83OLXwyOlKDZwFgUkyEJel0i7N0uvLuwHNlpejj73Hjrd2UDgbQpScgySQ+klRLzopSLUk1XqNmkx5r3D6MkPwvzrQVw9rlhSEqErakdb+5pxFOzJ0bsswkCkChqjh07hvXr12Pp0qV48MEHsWfPHixevBgGgwG33HIL72vPPfdcnD59Gn19fVi5ciVuv/1273M33HADTp8+jfLycng8HvT19eF3v/udV8S0tLSgv78fQ4YM8XvPIUOG4IcffuD8TKfTCafzrJ+/o4O/BxERnSQlJuDWn1wpbKnE4YiaDKMeq68djwe37fdbqMstZjx67XhUvX/Yryz+C5/U4YVP6jCtKBtXFuei8q39fu8nJXiZK41cbPAyI8i++qkHUWDA8NSf3Dxv7mn0s3SISY1v6XQFBe76Zv48dPVYOH/K/On3ePwymxiEquoakhODmmFKCZplr03kXyclR4SIEZoPsTWQlHJRqukKzTDq8cjM8Vi2NbhhKVXwJpRAkqhxu90oLS1FVVUVgAHX0sGDB7F+/XpBUVNdXY3Ozk58/vnnWLZsGSwWCyoqKgAA//znP/HYY49h3bp1mDJlCurq6nDvvfciNzcXK1as8L5HQoA/1uPxBD3my5o1a/DII49IOUUiConk7tDucGHVe4cwKT8Ltwa896PvHcLoXPZ6CZ/WtmBu2UjO5wLjGgIXzpSkRDz8zkF8dLjZewxjienp7RcVM8FYN3YePc0aMFxd1woP4LfYiLEA2R0uOPv6WRtIsmX+1Dd3sgbtClXVzUwNXgD5BASb+ADYm2OKhW8+THqdpPdWqrJ2PFXwJohAJIma3NxcjB071u+xMWPGYOvWrYKvLSgY2EkXFxfj1KlTWLlypVfUrFixAjfffLPXelNcXIyuri7ceeedeOihh5CdnQ2dThdklWlubg6y3vhSWVmJpUuXev/u6OhAXl6euJMlogYpu0OpBfpaOl346HCzn7jwpeIi7iB1PktEm2MgCygjNRl6XeJA52qfBajcYsY8awF217d6BQFjiVk+YyzX2wLwj5kYlpmK0hFZQRYjhpq6VvT0DoxTjAWoy9XP20CSGauvi4PLcmBrauesvivVosAmPqYWZeOeSyyY/7cvQ3L/8c3HA1v34aoAS5yY9xZa8Jn4rD63B26PBw5n34DVTaIYU1tYUJduQi0kiRqr1YojR474PXb06FGMGDGC4xXseDweP7eQw+FAYqL/rk2n08Hj8cDj8UCv1+PCCy/Ejh07MGvWLO8xO3bswMyZMzk/x2AwwGAwSBobEZ2IuYmHUrtDKOiST7jwWSLs3b247aWvsPBSC2udlpqfrCjzywv8hNqntS1wC7QHCIyZ6BToks6IIKGsmXZHL5b7VPRl8K0pw7je2AJ3Ay0HR052oGpWMZZvPxCWRYFLfFTXtsDt8fjNoRT3H998VNe2YF6AJU7se3Mt+Cfau/HHtw/ghovygyxrocRikbAg4hFJombJkiUoKytDVVUVrr/+euzZswcbNmzAhg0bvMdUVlbi+PHjePnllwEAL774IvLz8zF69GgAA3VrnnrqKSxatMj7mmuuuQbPPPMMSkpKvO6nFStW4Ne//jV0uoHMlaVLl+Lmm29GaWkpLr74YmzYsAGNjY24++67w54EIjYQck2EUqBPKOgyM5X9+WlF2Wg+w163xTeVWChYlkm79sXh6heMmRDbZBE4K4KEBFyXq0+wgaTYwN1BKclIS0lCR48L919xPn7/q9Foc7jQ1+/BqY4e1s/gQkxjS18+rW1Ba5fL+1ouq10ogjbUlGnm+pyYl8nqKgylkKRUq6TWmrESRChIEjWTJ0/Gtm3bUFlZiVWrVqGgoABr167FnDlzvMecPHkSjY2N3r/dbjcqKyvR0NCApKQkFBYW4vHHH8ddd93lPWb58uVISEjA8uXLcfz4cQwePBjXXHMNHnvsMe8xv/3tb9Ha2opVq1bh5MmTGD9+PN5//33JViIi/rA7XDhp7wmpdgdf0OUvx+Qg32zE67dPQXt3rze+5MjJDqyaOR4Agl7LBC8zmUBCwbJsz2ekJnPGTPzpNxOCXER8TRZ9rSpCAq6Lo5gdw6CUJKyYMZYzhd5XdJ5o78b9//0vv2BjZm4efe8QPhiRJXoBlyo+jHodPEBQ36ZAa4jQfHBZ4kJJmW7pdGHvd234/RXnoyQvE3OmjAiKV5IimKRaJbXWjJUgQkVyeccZM2ZgxowZnM//7W9/8/t70aJFflYZ1kEkJeHhhx/Gww8/zHvcggULsGDBAtFjJQjmZs0X+wJwL0RcrpNfjsnBihljUfnW/qA4jjWzir1NA32tE/qkRLx/4Ae/2BOhYNnA5xkRkmHUs7rbgODFmivVOtCqIpQ1w2WVYjjT04fr//K54GLotZrV8buxxC7gUsXH/PICrHz7AKoFrCF888HVWwoILWW609mL5ypK8OTfv/UbV2C8khjBJNUqGck2IwShNFSzmohZfG/WgfEPgfAtRFyuk/v/51+scRwPbtvvXQh8rRP1zZ1Bria+pozlAQtnoAhhc7fVN3eG3GRRKGvGqNfxLvLAQINIZ58b37V2QZeYwFr3Ray7SGgBZ9wl9m4XttwxBbvqW/06ezPjChQffJWW2bLH2OZjwU8ByIGEmjKdmarHnz48wtsD64VP6kQJJqkVhbXWjJUgwoFEDRGz+N6s+cSDmIUoUECwiQcGroWAbefPWFESEGxFqZpVDFe/G78YnSOYvcIs8K1dLmyaN9nPbQHwN1n0RSjgmm2Rt1rMePiacXj8g8P45NvT3sen/iSGAi02Yt1FfAs4m7ukPMCqMdUyID5ue+ms+JhWlC1oHQvMHmObD4er368Vg1Gvw4oZY3FBfiaOtXQhPdUlKSbF1c/fDJSJVxJTT0hqRWGtNWMliHAgUUPELL43a66OzqHW7ghlIWDb+Ttc/XhzTyOe+M0E9PS6Q0q/ZVvg2dKsAXGuEb6A62GZqVhzXTGafnQgI1WPPo8bXT39aO10YeywDHx+7Efv51X/lPr8QoD7Qoy7iE9ocrlLaupakYAEvHb7FPzY5cL+43bs+Xcrnq8owaCUZJhNAy4loQangXPENh8ZxrOuxS5nL9JT9Vix/YDkFG8GoQw1QHw9IakVhbXWjJUgwoFEDRGz+N6sfV0wTIG+Udkm5GakSM4IAYDUZB1r8TkGroUgcOefnpoMkyEJnT19IWWdcC3wgW4LQJ5qsnaHCw+/cxA3XJSPF//vEG/8BzAgbJrPOP3ORyhWpfmMk1do8qZa17VgnnUkbnvpK7/HP146HYU5ad6/5ai4y4gdu8M1EMdUF3pMipCwyD/H6I3TEoqBeXL2REnnp7VmrAQRDiRqiJgl8GbNuGCAgZu10GIjtqBb4GIutBAEZQEFxOZI2eELxafcVj7K+55yVJNt6XRhdG46a9oxm5ACgruk87WeeGxWMTJTk3nHKSXbiXELuT0e2BrbvKJRzoq7csSkCAmLnEFn620JfV6Xs0/U+fkK9uVXj8XexjY8+t4hv0KF1NqAiDZI1BAxiW/n7JXvHAwSDUI3aykF3XwX831N7aIXAjmyTuzdQq6UJHy8dLqgO0tsjZKOnl7JtXUCU7z5Wk+sfu+QYFsLsdlORr0Om+ZNxouf1AW5hZ74zQTZKu7KEZMipbWB0Od1dPdi1OA03vPjcl+9v3gqOrpdMBmotQERnZCoIWIO3xt2YOfszFS9qJu11IJuu+paseLqsbijvED0QiDHDt+o5/8JDzIk+bld2JBSoyQ9JRkn7fzF8XwtJVMtZpgM/mMUaj0hdN5CVg3L4DRsX1CGLKMey7cfYHULPfCTaBSaGzHIFZMitrWB2M/jio3iE9N/fPsApXATUQ1/GgBBRBmBN2zG5XTjf32B//yoVvTuM5Rqsj29/ZIWA6HP+LHLhT0NP+LbHzo4q+wmJiZ406kDsVrMgh3KhaxFdoe/JSg7TS9Yr4axlFgtZiy4pAhJAU1nw7VsMFaNaUXZfo8zVo0R2SZMys9Cn9sTJGgYGNEoB4zIYkNqTEqGUY/CnDRMys9CYU4ab0HIUD9PjJgmiGiFLDVETCFXzY1QqskyO2Sxrhyhz+jo6fUGvJZbzKiaVYx8s8nvmKTEBNz6k9VoV0DQ7q3WAkFRI3W+Mox6jDAbOSsUT7Vk4xyTHhvnlsLW1I7bXvoSpQHVgeWwbIixaiiVqqx0V+xwP09oXlq7XMDpTmqTQEQlJGqImEKuhUxqNVlmhyzFlSPlM2rqWvHgtv14+vpJfgXtzCY91rx/GCX5Wd6sLiY+5c09jYLxKaHM1/AsIx6/bkJQZ3GrxYy51pGY819f+GWCBYojubJthBo2KpmqrHRX7HA+T2hezvT04vq/fEZtEoiohNxPREwh10LG5eKYWpSNRZcWYVNNg/cxZocMQJIrh+szGCuL72cAA8KmrSv4PR6ZOR77mtpx20tfYcFrX+O2l77CvqZ2rJo5PuxUYq75OvccI16oKMHHS6dj+4IyvL+4HCX5WUF1cRh8xZGQ+0guISCnW0gMYlxHoWB3uFDf3AlbYxvqT3d6r6NQP49vXnzFNNd1SxBahiw1REwhZ80Nrt0wALy7sDxoh1zf3Im937Vh4aUWlORlwtnn9qtjw+b6CvyM5KREfBDQH8qXjp7gIm3h7NrDmS+hFhC+BIojJSwbSruFQkHIVRmJRpNc8xLYbBWQp00Cdf8mlCTB4/F41B6EUnR0dCAjIwN2ux3p6elqD4eIECfauzkXstwImtL/1dSG052uoBouzGKRk6bHhDzuFgUA8O3JDvzqP6s5n//7vVMxOlfea1fsfHEVImT6Lzn73Kz9l8TUBIoUdocL7Y5edLn64HD1IyM1GTmDDJpYVIUEi7eoH4fgDHdOfVtrnOnpha2pPei7A4DtC8p4W2vwQd2/CbkQu36TpYaIOfiq9voWYJN7YRNqSlh1bbHge2SZ9JxBuOUWM7JM8i/GYqwmgYuTbw0Y3wyjwP5LalpF+BbUDGNkP1vIOiGmRlGkG016LW3Nnbj+L59xHhdq7BF1/ybUgEQNEZPIWbVXLEJNCV39wWnggQxJT0HVrGLWartVs4pZu14LIcb8zxd0y7Y4zS8vwPOf1Aadb01dKxISEvD2PVYkJiSoVsBNzQVVjHVCjGBRKnsrUm0SqPs3oQYkaoiYJhKLG5dIEGpK2CWiaSEA5JtNePr6SWjrcqGjpw/pKUnIMuklCxq7w4UfOnrwfVs3EhISvLE9pSOyJAk6tsWJr6pwdW0LEhMSZClsFypqLahirzcxgkWp7K1IxR5R929CDUjUEDFN8xmnrIsbr0tDoCidlEVoSHpKSFYZv3H+7z4/15Bvjyopgo6tFQNb8UFf1F6w1FpQxYopMYJFyUaTkQjcpu7fhBpQSjcRs5xo70bjjw7eY6QsbkK7cJMhSdEUYi684/QRNEa9DiX5WUhN1uHPN12IedYCtDuEz/1Eezd6eoMFDFvxQV/UXrDUWlDFiikx6eZKpb4zyJ2SrnRKPUEAZKkhYhRmYZ9XNpL3OCmLm9AuvLNHXHfkSBM4TqNeh+cqSrB5V4Ofy2jqT+PickMxczgxLxNWi9kvfsbW1B70GIMWFiw5rRxSUpKl9GUSc60oXdRPTqIhpZ6IPUjUEBFDzfoUzMLOtiAzSF3cxOzCC3P4uyMrQeA455cXBKWZAwOxL3xuKGYO937XhucqSgCczeTaVNOATfMmIzEhQXIHdCWQa0GVmpIsRUyJFSxClZO1TDSLMiI6IVFDRAS161MwC/ummoagBRk4a6WQcnMNtzuyUgSOky+oly+uiJlDh6sfi7fYML+8wK8VQ3aaHi+otGCJEczhLqihBJlLFVNyXytaLHSn9u+BiC9I1BCyo4X6FMzCzrUgWwanSS7Ep2TgZjgEjjPUoF5fccR0OwcG3FnzywswPDMVx1q6kJ6ajIJsk2ILlxTBHM6CGmoGlVrWCbU3EgShBUjUELKjhfoU2Wl6rLmuGDmDDEHtCpiu0VKJlhiBwHGGGtTLJuK44nNCXTylWhaUFMyMpYoRcYGtL7qc3O5Iobo/cltTtLCRIAgtQKKGkB0l02m5FoguVz/e33cyKKV507zJGHmOMeQbfLTECPiO0+3xYGpRNme5fS4LE5uI44rPCWXxDMWyoKRgTk9J5hRxVosZ/3HBuZLfM1LWFC1sJAhCC5CoIWRHiXRau8OFNkcvVmzfj2qfBXZaUTaqZhVj5bsH/QQNMBBTo0tICMlK40u0xAj4jvOJEC1MgSIuJVkXUnxOIKFaFoQEc5ezVxZLiN0xIAbfuPNnePLv37K2vvjj2wckibhIWlOo0B1BDECihpCdSMeenGjvxs6jp/HevhOsFoPKbfsxMS8THx1uDnptvO5aw7Ew+YojW2Mb77FiF89QLQt8gtmo1yE9VR/UBFKqJcTXmrJxbqmfaBY7TjZCPWcxIo0K3RHEACRqCNmJZOyJb/0Zrj5L1bUtvPVpQtm1ajGrhA2+cYq1MPG9h1yLZ6iWBT7BvGLGWKzYfiDIQifFEhJoTZGzcnIo5yzWXRUtQewEEWlI1BARIVKxJ8xut+KifN7j+BYjqbtWtpYDWswqkSNeQ+g95Fo8QxVHfIL5gvxMVL61n/V1Yq0qgdYUOSsnSz1nKe6qaAliJ4hIQ6KGiBiRiD1hdrtCi00mRx+mUKrJBgoaYGBheWDrPrygkawSOeI1xL6HHIsnlzgy6nVYMWMs3B4PbI1trFYxLsF8rKWL9zPFWFUCrSlClZOTEhM4xyn2nJn3CrwupbqroiWInSAiCYkaQjaUcNEwu12hxWaE2Ri0gISya20+4wwSNAzVtS1oPuPUxKIhR/aL2PeQuniyXRcOVz8WXGJBv8fj/Q6Neh02zZuMFz+p87O4sFmb2ARzekpw401fxFhVAq0pfMUbF1xiwZXPVcPh6uccpy9SBWEo7qpoCWIniEhBooaQBaUKfzG7Xa7FhlkgcmXatbZ38y8sdoHnlUKO7Bcp7yF28WS7LtZcV4z3953E3sY2v6KI52al4sm/fxsUmCvW2iSHayzwPXyLN97zcwtSknUYlJKEr75rw/y/fekVNGLHKUUQUvAvQUiHRA0RNkoW/vLd7fpWCgaAc7NSMTQ9RXJgLB8mvY73eaPA80oRuAAGFYzT62B3cFtr7A4XUpN1WDfnAr9Chb6LttRFlOu6yBlk8Fq/fNPDw800ksM1xvYeDlc/9jW1Y85F+cjNTEV9c2dYsTtir0sK/iUI6ZCoIcJG6cJfSsYOmPRJnG4uq8UMk14bPyHfBVBq1V82a4rVYsZzFSVYvMUGh6s/pEWU67rgCuJ29YefaSTHtSH0HkrVhKHgX4KQjjbuyERUo0bhL6ViBzKNyVh0aREAfzeX1WLGokuLkGkUZ72IdLyR7wI4IS9TdNVfLmsK89r55QXY19Qe0iLKdV1wBXkPTjPwvp/JIO52Jce1wfceSrqFKPiXIKRBooYIm1j2/WcY9RhxjhEzJgzza4jZfMYput2CUvFGzAJ40t4juuovn5VtV10rVlw9FneUF4S0iHJdF1xB3vqkRF6rmF7Hn/GmFEq7hSj4lyDEo427BBHVMDd5NmLB95+bmYqrxg/FSLMJwzJSMNJswlXjh2KoCEEiFG9kd/Bn7Eglw6hHd28/7zG+ljMhK1tPb3/ICyrXdbGppgGLLi0Keu7HThdutRbAajH7PW61mHGrtQD2bnnnKlQYq1jg+MktRBDqQ5YaImziwfcf6m5ZjUaDUixnkbSycV0XpSOyMPIcY5Bbxe3xYOaLu/wyogxJibA1tWPxFhveXVge8ljkhtxCBKFNSNQQAMKP+aCbPDtqxBtJcY9E2pUidF34Xh92hwulI7JYXWflFjNSktU1LLP9Rgpz0lQdE0EQ/pCoIWSL+SDffzBqxBtJsZwpYWUTe11kGPWomlWMZW/tQ01AUPY8awFWvnMQT82eqMo1plRcFEEQ4ZHg8Xg8ag9CKTo6OpCRkQG73Y709HS1h6MJ7A5XUFdjhmlF2bLWmIlH7A4XFm2xcVpCIjm/jGVBStVfta1sx0534i3bcW99Hcb9xNTM+XjpdNmsI2Ktk/QbIQj1Ebt+k6UmzlEj5iOeUDPeSIrlTCkrm5CQsHf3cmZuAfK569gsL1OLsvHozPHIMib7jYl+IwQRPZCoiXPUiPmINyjeaICT7d3459HTyBlkgLPPjTZHL/Y0/IifnzcYuT+5cJRw13FlpFXXtuCh7fsxY8IwTD9vsNetRL8RgogeSNTEObFcY0ZLxHK8kRg3jt3hwnc/OvDevhNBRQwLsk0w6nXIMOoVqQEjVJtnvrXAr0gh/UYIInogURPnyLmIKNGlO9aJtjkUG0Db7ujF85/UBhXWY/6uurbYK/wi7a4Tsrw4+9x+biXqwUQQ0QOJmjhHrkWEWdz2ftfmbaT475Yu5GUZMSTdoOmFWStEW4aNlEamXa4+1krBwICw6XL1ef+OtLtOyPLCtHFg3ErxUIeJIGIFEjVE2IsIs7jt/a5NUiNF4ixKdjqXCykBtF0u/irHjoDnI+mu47O8WC1m2JraAfi7lSguiiCiA2qTQAAYWEQKc9IwKT8LhTlpkm7WzOI2v7yAt5Gi3C0BYgkxAkFriA2gtTtcGJTCv38Ssp7ICVebA6Ydw6aaBla3Uji/EYIglIEsNUTYMItbSV6mYCNFAFEVM6IU0ZhhIyaAlnGp/f6K83mbVXJ17o4UjOXlh44efN/WDQDedgylI7LIrUQQUQqJGiJsmMXN2efmPe5Hhwt7/v0jHn3vkNfdQK6pAeTMsFEq2FgogDYtJQmffNuMeWUj0e3qx63WAgAIyn4626zSJPsY+WBcXEPTU9DS6YLZpMesScPJrUQQUQy5n4iwYRY3od12R3cv3tt3As9VlMCo1wEg1xSDXJ3OT7R3Y+EWGy57ZidmrduNy57eiUVbbDjR3i3ncAEId6vucfXjvX0ncNtLX6HT2YfFW2woyc/CxrmlWDfnAmycW4qS/Cws3mKDyaBeWjS5lQgidqA2CYQsnGjvxs6jp4PqkDBYLWaU5A80K/T9P4Oc5e+jlRPt3ZwZNrk+liwuS4xa5fzZWiwAwMLXv0b1T9fCwkstsDW2sV4b1GqAIAghqE0CoSjDMlNx1fihuHiUGSvePuC3sDIuhsVbbADOFjjzRYsxI0rhK1JWzBgLvS4R9m4XTIbgDBu+tO9uV78q5fzZMpXqmzu9ggYANtU04LmKEgD+7idKiyYIQk4ku5+OHz+Om266CWazGUajEZMmTcLevXs5j6+pqYHVaoXZbEZqaipGjx6NZ5991u+Yn//850hISAj6d/XVV3uPWblyZdDzQ4cOlTp8IoJkGPUwJCXiquJcvLPQGuRi8E3bDYy/ideqrIHuol8++ylWvH0A2YNSglwhQmnfA3Ep3CgpHAMDnx2ufj/30xt3/gw7lkzD8xUlflYogiCIcJBkqWlra4PVasUll1yCDz74ADk5Oaivr0dmZibna0wmExYuXIgJEybAZDKhpqYGd911F0wmE+68804AwFtvvQWX6+wNubW1FRMnTsTs2bP93mvcuHH46KOPvH/rdDopwycijN3hwh9+qlfz5l0/w4LXvuY81jf+Jl6rskqtTSOU9v3gVWN4P09J4cgW+Oxw9Xtdjh/eNxVFQwYpNh6CIOIDSaLmiSeeQF5eHjZv3ux9bOTIkbyvKSkpQUlJid/xb731Fqqrq72i5pxzzvF7zRtvvAGj0RgkapKSksg6o2GYRXfhpRbs/97Om8LLFDjTuvtBbCZRKBlHUrs/C6V96xITNFPOXygzamh6imJjIQgifpAkat555x1cccUVmD17Nnbu3Inhw4djwYIFuOOOO0S/h81mw+7du7F69WrOYzZu3IgbbrgBJpN/imdtbS2GDRsGg8GAKVOmoKqqCqNGjeJ8H6fTCafT6f27o6ND9DgJ6fjWq1m0xcYaQzHVYsaqa8fjTHev5tNnxbYtCLW9gdTaNEJp37rEBM2U86fWAgRBqIEkUXPs2DGsX78eS5cuxYMPPog9e/Zg8eLFMBgMuOWWW3hfe+655+L06dPo6+vDypUrcfvtt7Met2fPHhw4cAAbN270e3zKlCl4+eWXcd555+HUqVNYvXo1ysrKcPDgQZjNZtb3WrNmDR555BEpp0iEgW+9GiaGYn55AeZbC+Dsc8OQlAhbUzvOdPdiQl6WyqPlR6xrKJz2BlJr0whZP8w/WYfkKucfbr0bai1AEITSSBI1brcbpaWlqKqqAjDgWjp48CDWr18vKGqqq6vR2dmJzz//HMuWLYPFYkFFRUXQcRs3bsT48eNx0UUX+T1+5ZVXev9fXFyMiy++GIWFhXjppZewdOlS1s+srKz0e66jowN5eXmiz5eQRmC9Gt8YCl9mTRqu9NAkI9Y1JNWF5IvU7s9irR9y9E2Sq7lmJHs4hUu0dUQnCEIYSaImNzcXY8eO9XtszJgx2Lp1q+BrCwoGUniLi4tx6tQprFy5MkjUOBwOvPHGG1i1apXg+5lMJhQXF6O2tpbzGIPBAIPBIPhehDwwi+7Oo6c542miJShYrGsonPYGobholLB+RGNzTalEW0d0giDEIUnUWK1WHDlyxO+xo0ePYsSIEZI+1OPx+MW6MPz3f/83nE4nbrrpJsH3cDqdOHz4MKZOnSrps4nIwlevhm2x1upuWaxrKNz2BqGIlEhbP8KxPgWixe83HkQbQcQrkkTNkiVLUFZWhqqqKlx//fXYs2cPNmzYgA0bNniPqaysxPHjx/Hyyy8DAF588UXk5+dj9OjRAAbq1jz11FNYtGhR0Ptv3LgR1157LWuMzP33349rrrkG+fn5aG5uxurVq9HR0YG5c+dKOmEi8jCL7gsCi7WWd8tiXUNSXUhsaM1FI1dzTa1+v3KKNoIgtIWk4nuTJ0/Gtm3bsGXLFowfPx6PPvoo1q5dizlz5niPOXnyJBobG71/u91uVFZWYtKkSSgtLcXzzz+Pxx9/PMjFdPToUdTU1OC2225j/ezvv/8eFRUVOP/883HddddBr9fj888/l2wlIpQjsKcOMFBp1tbYhtpTZ7Dz6Gns/a7N7zVa6QUl1NfIN35FzHHRhBzNNQULBar4/UZjR3SCIMRBvZ8IRWDbtfu2T/CtNgxopxcUW18jvjo1sZDlY3e4sGiLjdP6JMY9U9/cicue2cn5vJrfr5bHRhAEO9T7idAMXLt2JpB4fnlBUJaUVnbLYl1DWnMhhYMcNWa0bA2Rw2VIEIQ2IVFDRBy+GAa25pZA/PaC0grhZlnJ4cKKFFQYkCBiFxI1RMQR2rUHNreUa7esxcybaCIc65PWrSFUGJAgYhMSNUTEEdq1Bza3lGO3rNXMm3ghGqwhseQyJAhiAAoUJiKOUODpozPHo83hkm23bHe4sHCLjdXlJTbQlZAHvgBqsqQRBCEWChQmNIPQrj03MxUjYOJ5B2lQHRLtwGUNIUsaQRCRgEQNoQhKxjBoOfOGoIq+BEFEDhI1hGIoFcOg5cwbLaOUO4gsaQRBRAoSNUTMofXMGy2ipDuILGkEQUQKSW0SCCIaiMXWBZFE6ZYGZEkjCCJSkKWGiEmoDkkwXO4lpd1BZEkjCCJSkKghYhaqQ3IWPveS0u6gaKhhQxBEdEKihiBiHCH30ooZY3lfHwl3EFnSCIKIBCRqCCLGEXIv6XWJqriDyJJGEITcUKAwQcQ4Qu4le7eLAqsJgogJyFJDEDGOULaRyZBM7iCCIGICEjUEEeOIzTYidxBBENEOuZ8IIsahuj0EQcQLZKkhVIO6NCsHuZcIgogHSNQQqhBvXZq1IODIvUQQRKxDooZQnHjr0hxvAo4gCEItKKaGUBwxZfljBaX7KhEEQcQzJGoIxYmnLs3xJOAIgiDUhkQNoTjx1KU5ngQcQRCE2pCoIRSHqZvCRqx1aY4nAUcQBKE2JGrCxO5wob65E7bGNtSf7qQYCRHEU92UeBJwBEEQapPg8Xg8ag9CKTo6OpCRkQG73Y709PSw34+yWsKDSXOO9bopJ9q7sWzrPr+KvoyAy6XrhCAIQhCx6zeJmhCxO1xYuMXGGgQ6rSg75tKSifCIFwFHEAQRCcSu31SnJkTEZLXQokUwUOE7giCIyEMxNSFCWS0EQRAEoS1I1IQIZbUQBEEQhLYgURMilNVCEARBENqCRE2IxFNaMkEQBEFEAxQoHAbDMlPxfEUJZbUQBEEQhAYgURMmlNVCEARBENqA3E8EQRAEQcQEJGoIgiAIgogJSNQQBEEQBBETkKghCIIgCCImIFFDEARBEERMQKKGIAiCIIiYgEQNQRAEQRAxAYkagiAIgiBiAhI1BEEQBEHEBCRqCIIgCIKICeKqTYLH4wEAdHR0qDwSgiAIgiDEwqzbzDrORVyJmjNnzgAA8vLyVB4JQRAEQRBSOXPmDDIyMjifT/AIyZ4Ywu1248SJExg0aBASEhIU+9yOjg7k5eWhqakJ6enpin2uFojncwfo/OP5/OP53IH4Pv94PncgMufv8Xhw5swZDBs2DImJ3JEzcWWpSUxMxLnnnqva56enp8flBQ7E97kDdP7xfP7xfO5AfJ9/PJ87IP/581loGChQmCAIgiCImIBEDUEQBEEQMQGJGgUwGAx4+OGHYTAY1B6K4sTzuQN0/vF8/vF87kB8n388nzug7vnHVaAwQRAEQRCxC1lqCIIgCIKICUjUEARBEAQRE5CoIQiCIAgiJiBRQxAEQRBETECiRiHWrFmDhIQE3HfffWoPRRFWrlyJhIQEv39Dhw5Ve1iKcvz4cdx0000wm80wGo2YNGkS9u7dq/awIs7IkSODvvuEhATcc889ag9NEfr6+rB8+XIUFBQgNTUVo0aNwqpVq+B2u9UemiKcOXMG9913H0aMGIHU1FSUlZXhyy+/VHtYEeHTTz/FNddcg2HDhiEhIQHbt2/3e97j8WDlypUYNmwYUlNT8fOf/xwHDx5UZ7ARQOj833rrLVxxxRXIzs5GQkICvvnmm4iPiUSNAnz55ZfYsGEDJkyYoPZQFGXcuHE4efKk99/+/fvVHpJitLW1wWq1Ijk5GR988AEOHTqEp59+GpmZmWoPLeJ8+eWXft/7jh07AACzZ89WeWTK8MQTT+DPf/4zXnjhBRw+fBh/+tOf8OSTT+L5559Xe2iKcPvtt2PHjh145ZVXsH//flx++eX4xS9+gePHj6s9NNnp6urCxIkT8cILL7A+/6c//QnPPPMMXnjhBXz55ZcYOnQofvnLX3r7EEY7Quff1dUFq9WKxx9/XLlBeYiIcubMGU9RUZFnx44dnunTp3vuvfdetYekCA8//LBn4sSJag9DNR544AFPeXm52sPQBPfee6+nsLDQ43a71R6KIlx99dWe+fPn+z123XXXeW666SaVRqQcDofDo9PpPO+9957f4xMnTvQ89NBDKo1KGQB4tm3b5v3b7XZ7hg4d6nn88ce9j/X09HgyMjI8f/7zn1UYYWQJPH9fGhoaPAA8Npst4uMgS02Eueeee3D11VfjF7/4hdpDUZza2loMGzYMBQUFuOGGG3Ds2DG1h6QY77zzDkpLSzF79mzk5OSgpKQEf/3rX9UeluK4XC68+uqrmD9/vqJNZNWkvLwcH3/8MY4ePQoA+Ne//oWamhpcddVVKo8s8vT19aG/vx8pKSl+j6empqKmpkalUalDQ0MDfvjhB1x++eXexwwGA6ZPn47du3erOLLYJq4aWirNG2+8ga+//jpm/cl8TJkyBS+//DLOO+88nDp1CqtXr0ZZWRkOHjwIs9ms9vAizrFjx7B+/XosXboUDz74IPbs2YPFixfDYDDglltuUXt4irF9+3a0t7dj3rx5ag9FMR544AHY7XaMHj0aOp0O/f39eOyxx1BRUaH20CLOoEGDcPHFF+PRRx/FmDFjMGTIEGzZsgVffPEFioqK1B6eovzwww8AgCFDhvg9PmTIEHz33XdqDCkuIFETIZqamnDvvffiH//4R9CuJR648sorvf8vLi7GxRdfjMLCQrz00ktYunSpiiNTBrfbjdLSUlRVVQEASkpKcPDgQaxfvz6uRM3GjRtx5ZVXYtiwYWoPRTHefPNNvPrqq3j99dcxbtw4fPPNN7jvvvswbNgwzJ07V+3hRZxXXnkF8+fPx/Dhw6HT6XDBBRfgxhtvxNdff6320FQh0ELp8XjixmqpBuR+ihB79+5Fc3MzLrzwQiQlJSEpKQk7d+7Ec889h6SkJPT396s9REUxmUwoLi5GbW2t2kNRhNzcXIwdO9bvsTFjxqCxsVGlESnPd999h48++gi333672kNRlN///vdYtmwZbrjhBhQXF+Pmm2/GkiVLsGbNGrWHpgiFhYXYuXMnOjs70dTUhD179qC3txcFBQVqD01RmGxPxmLD0NzcHGS9IeSDRE2EuOyyy7B//35888033n+lpaWYM2cOvvnmG+h0OrWHqChOpxOHDx9Gbm6u2kNRBKvViiNHjvg9dvToUYwYMUKlESnP5s2bkZOTg6uvvlrtoSiKw+FAYqL/rVWn08VNSjeDyWRCbm4u2tra8OGHH2LmzJlqD0lRCgoKMHToUG/2HzAQY7Zz506UlZWpOLLYhtxPEWLQoEEYP36832Mmkwlmszno8Vjk/vvvxzXXXIP8/Hw0Nzdj9erV6OjoiAvzOwAsWbIEZWVlqKqqwvXXX489e/Zgw4YN2LBhg9pDUwS3243Nmzdj7ty5SEqKr9vMNddcg8ceewz5+fkYN24cbDYbnnnmGcyfP1/toSnChx9+CI/Hg/PPPx91dXX4/e9/j/PPPx+33nqr2kOTnc7OTtTV1Xn/bmhowDfffINzzjkH+fn5uO+++1BVVYWioiIUFRWhqqoKRqMRN954o4qjlg+h8//xxx/R2NiIEydOAIB3ozd06NDI1S2LeH4V4SWeUrp/+9vfenJzcz3JycmeYcOGea677jrPwYMH1R6Worz77rue8ePHewwGg2f06NGeDRs2qD0kxfjwww89ADxHjhxReyiK09HR4bn33ns9+fn5npSUFM+oUaM8Dz30kMfpdKo9NEV48803PaNGjfLo9XrP0KFDPffcc4+nvb1d7WFFhP/7v//zAAj6N3fuXI/HM5DW/fDDD3uGDh3qMRgMnmnTpnn279+v7qBlROj8N2/ezPr8ww8/HLExJXg8Hk9k5BJBEARBEIRyUEwNQRAEQRAxAYkagiAIgiBiAhI1BEEQBEHEBCRqCIIgCIKICUjUEARBEAQRE5CoIQiCIAgiJiBRQxAEQRBETECihiAIgiCImIBEDUEQBEEQMQGJGoIgCIIgYgISNQRBEARBxAQkagiCIAiCiAn+f6vGXJ5IE2dEAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "trainer, model = train_and_test_model(featurizer, model, devices=[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "molfeat",
   "language": "python",
   "name": "molfeat"
  },
  "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}