Attentive FP_Solubility_rdkit_dataset_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3fcdc5a6-f9b5-4ca0-a809-d9ca364080f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "use GPU\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from rdkit import Chem\n",
    "from rdkit import RDPaths\n",
    "from functools import partial\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "import numpy as np\n",
    "import random\n",
    "import torch\n",
    "if torch.cuda.is_available():\n",
    "    print('use GPU')\n",
    "    device='cuda'\n",
    "else:\n",
    "    print('use CPU')\n",
    "    device='cpu'\n",
    "    \n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "import dgl\n",
    "from  dgl.data.utils import split_dataset\n",
    "from dgllife.model import model_zoo\n",
    "\n",
    "from dgllife.utils import mol_to_complete_graph, mol_to_bigraph\n",
    "from dgllife.utils import atom_type_one_hot\n",
    "from dgllife.utils import atom_degree_one_hot\n",
    "from dgllife.utils import atom_formal_charge\n",
    "from dgllife.utils import atom_num_radical_electrons\n",
    "from dgllife.utils import atom_hybridization_one_hot\n",
    "from dgllife.utils import atom_total_num_H_one_hot\n",
    "from dgllife.utils import one_hot_encoding\n",
    "from dgllife.utils import CanonicalAtomFeaturizer\n",
    "from dgllife.utils import CanonicalBondFeaturizer\n",
    "from dgllife.utils import ConcatFeaturizer\n",
    "from dgllife.utils import BaseAtomFeaturizer\n",
    "from dgllife.utils import BaseBondFeaturizer\n",
    "from dgllife.utils import one_hot_encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "792f6477-65dc-4984-a1dc-1d978c0c1c5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chirality(atom):\n",
    "    try:\n",
    "        return one_hot_encoding(atom.GetProp('_CIPCode'), ['R', 'S']) + \\\n",
    "               [atom.HasProp('_ChiralityPossible')]\n",
    "    except:\n",
    "        return [False, False] + [atom.HasProp('_ChiralityPossible')]\n",
    "     \n",
    "def collate_molgraphs(data):\n",
    "    \"\"\"Batching a list of datapoints for dataloader.\n",
    "    Parameters\n",
    "    ----------\n",
    "    data : list of 3-tuples or 4-tuples.\n",
    "        Each tuple is for a single datapoint, consisting of\n",
    "        a SMILES, a DGLGraph, all-task labels and optionally\n",
    "        a binary mask indicating the existence of labels.\n",
    "    Returns\n",
    "    -------\n",
    "    smiles : list\n",
    "        List of smiles\n",
    "    bg : BatchedDGLGraph\n",
    "        Batched DGLGraphs\n",
    "    labels : Tensor of dtype float32 and shape (B, T)\n",
    "        Batched datapoint labels. B is len(data) and\n",
    "        T is the number of total tasks.\n",
    "    masks : Tensor of dtype float32 and shape (B, T)\n",
    "        Batched datapoint binary mask, indicating the\n",
    "        existence of labels. If binary masks are not\n",
    "        provided, return a tensor with ones.\n",
    "    \"\"\"\n",
    "    assert len(data[0]) in [3, 4], \\\n",
    "        'Expect the tuple to be of length 3 or 4, got {:d}'.format(len(data[0]))\n",
    "    if len(data[0]) == 3:\n",
    "        smiles, graphs, labels = map(list, zip(*data))\n",
    "        masks = None\n",
    "    else:\n",
    "        smiles, graphs, labels, masks = map(list, zip(*data))\n",
    " \n",
    "    bg = dgl.batch(graphs)\n",
    "    bg.set_n_initializer(dgl.init.zero_initializer)\n",
    "    bg.set_e_initializer(dgl.init.zero_initializer)\n",
    "    labels = torch.stack(labels, dim=0)\n",
    "     \n",
    "    if masks is None:\n",
    "        masks = torch.ones(labels.shape)\n",
    "    else:\n",
    "        masks = torch.stack(masks, dim=0)\n",
    "    return smiles, bg, labels, masks\n",
    " \n",
    " \n",
    "def run_a_train_epoch(n_epochs, epoch, model, data_loader,loss_criterion, optimizer):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    losses = []\n",
    "     \n",
    "    for batch_id, batch_data in enumerate(data_loader):\n",
    "        batch_data\n",
    "        smiles, bg, labels, masks = batch_data\n",
    "        if torch.cuda.is_available():\n",
    "            bg.to(torch.device('cuda:0'))\n",
    "            labels = labels.to('cuda:0')\n",
    "            masks = masks.to('cuda:0')\n",
    "         \n",
    "        prediction = model(bg, bg.ndata['hv'], bg.edata['he'])\n",
    "        loss = (loss_criterion(prediction, labels)*(masks != 0).float()).mean()\n",
    "        #loss = loss_criterion(prediction, labels)\n",
    "        #print(loss.shape)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "         \n",
    "        losses.append(loss.data.item())\n",
    "         \n",
    " \n",
    "    total_score = np.mean(losses)\n",
    "    print('epoch {:d}/{:d}, training {:.4f}'.format( epoch + 1, n_epochs,  total_score))\n",
    "    return total_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a6d59414-5f7c-4a1c-863c-9b9042dbfe80",
   "metadata": {},
   "outputs": [],
   "source": [
    "atom_featurizer = BaseAtomFeaturizer(\n",
    "                 {'hv': ConcatFeaturizer([\n",
    "                  partial(atom_type_one_hot, allowable_set=[\n",
    "                          'B', 'C', 'N', 'O', 'F', 'Si', 'P', 'S', 'Cl', 'As', 'Se', 'Br', 'Te', 'I', 'At'],\n",
    "                    encode_unknown=True),\n",
    "                  partial(atom_degree_one_hot, allowable_set=list(range(6))),\n",
    "                  atom_formal_charge, atom_num_radical_electrons,\n",
    "                  partial(atom_hybridization_one_hot, encode_unknown=True),\n",
    "                  lambda atom: [0], # A placeholder for aromatic information,\n",
    "                    atom_total_num_H_one_hot, chirality\n",
    "                 ],\n",
    "                )})\n",
    "bond_featurizer = BaseBondFeaturizer({\n",
    "                                     'he': lambda bond: [0 for _ in range(10)]\n",
    "    })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "25c22b95-d3db-4353-8cd1-3e4683f00685",
   "metadata": {},
   "outputs": [],
   "source": [
    "train='RDKitBook/data/solubility.train.sdf'\n",
    "test='RDKitBook/data/solubility.test.sdf'\n",
    " \n",
    "train_mols = Chem.SDMolSupplier(train)\n",
    "train_smi =[Chem.MolToSmiles(m) for m in train_mols]\n",
    "train_sol = torch.tensor([float(mol.GetProp('SOL')) for mol in train_mols]).reshape(-1,1)\n",
    " \n",
    "test_mols =  Chem.SDMolSupplier(test)\n",
    "test_smi = [Chem.MolToSmiles(m) for m in test_mols]\n",
    "test_sol = torch.tensor([float(mol.GetProp('SOL')) for mol in test_mols]).reshape(-1,1)\n",
    " \n",
    " \n",
    "train_graph =[mol_to_bigraph(mol,\n",
    "                           node_featurizer=atom_featurizer, \n",
    "                           edge_featurizer=bond_featurizer) for mol in train_mols]\n",
    " \n",
    "test_graph =[mol_to_bigraph(mol,\n",
    "                           node_featurizer=atom_featurizer, \n",
    "                           edge_featurizer=bond_featurizer) for mol in test_mols]\n",
    "\n",
    "train_loader = DataLoader(dataset=list(zip(train_smi, train_graph, train_sol)), batch_size=128, collate_fn=collate_molgraphs)\n",
    "test_loader = DataLoader(dataset=list(zip(test_smi, test_graph, test_sol)), batch_size=128, collate_fn=collate_molgraphs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9dbd9906-555d-475e-928e-81515a18bd10",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model_zoo.attentivefp_predictor.AttentiveFPPredictor(node_feat_size=39,\n",
    "                                  edge_feat_size=10,\n",
    "                                  num_layers=2,\n",
    "                                  num_timesteps=2,\n",
    "                                  graph_feat_size=200,\n",
    "                                  dropout=0.2)\n",
    "model = model.to('cuda:0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "05c53596-1916-4143-a8bd-9b9c63a9fe76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100, Training Loss: 9.9542\n",
      "Epoch 2/100, Training Loss: 4.8677\n",
      "Epoch 3/100, Training Loss: 3.1593\n",
      "Epoch 4/100, Training Loss: 2.9854\n",
      "Epoch 5/100, Training Loss: 2.8084\n",
      "Epoch 6/100, Training Loss: 2.8264\n",
      "Epoch 7/100, Training Loss: 1.8833\n",
      "Epoch 8/100, Training Loss: 1.8384\n",
      "Epoch 9/100, Training Loss: 2.0473\n",
      "Epoch 10/100, Training Loss: 1.3347\n",
      "Epoch 11/100, Training Loss: 1.1422\n",
      "Epoch 12/100, Training Loss: 0.8328\n",
      "Epoch 13/100, Training Loss: 0.7167\n",
      "Epoch 14/100, Training Loss: 0.7239\n",
      "Epoch 15/100, Training Loss: 0.7596\n",
      "Epoch 16/100, Training Loss: 0.7984\n",
      "Epoch 17/100, Training Loss: 0.9546\n",
      "Epoch 18/100, Training Loss: 0.9995\n",
      "Epoch 19/100, Training Loss: 0.8772\n",
      "Epoch 20/100, Training Loss: 0.7417\n",
      "Epoch 21/100, Training Loss: 0.7957\n",
      "Epoch 22/100, Training Loss: 0.5825\n",
      "Epoch 23/100, Training Loss: 0.5239\n",
      "Epoch 24/100, Training Loss: 0.5375\n",
      "Epoch 25/100, Training Loss: 0.5113\n",
      "Epoch 26/100, Training Loss: 0.5075\n",
      "Epoch 27/100, Training Loss: 0.4982\n",
      "Epoch 28/100, Training Loss: 0.4251\n",
      "Epoch 29/100, Training Loss: 0.4497\n",
      "Epoch 30/100, Training Loss: 0.4700\n",
      "Epoch 31/100, Training Loss: 0.5349\n",
      "Epoch 32/100, Training Loss: 0.4913\n",
      "Epoch 33/100, Training Loss: 0.5743\n",
      "Epoch 34/100, Training Loss: 0.5360\n",
      "Epoch 35/100, Training Loss: 0.4934\n",
      "Epoch 36/100, Training Loss: 0.5032\n",
      "Epoch 37/100, Training Loss: 0.4312\n",
      "Epoch 38/100, Training Loss: 0.4024\n",
      "Epoch 39/100, Training Loss: 0.5048\n",
      "Epoch 40/100, Training Loss: 0.4992\n",
      "Epoch 41/100, Training Loss: 0.6139\n",
      "Epoch 42/100, Training Loss: 0.4881\n",
      "Epoch 43/100, Training Loss: 0.5371\n",
      "Epoch 44/100, Training Loss: 0.5841\n",
      "Epoch 45/100, Training Loss: 0.5895\n",
      "Epoch 46/100, Training Loss: 0.7899\n",
      "Epoch 47/100, Training Loss: 0.7633\n",
      "Epoch 48/100, Training Loss: 0.4463\n",
      "Epoch 49/100, Training Loss: 0.4476\n",
      "Epoch 50/100, Training Loss: 0.4032\n",
      "Epoch 51/100, Training Loss: 0.3899\n",
      "Epoch 52/100, Training Loss: 0.3626\n",
      "Epoch 53/100, Training Loss: 0.4030\n",
      "Epoch 54/100, Training Loss: 0.3879\n",
      "Epoch 55/100, Training Loss: 0.4299\n",
      "Epoch 56/100, Training Loss: 0.4271\n",
      "Epoch 57/100, Training Loss: 0.4308\n",
      "Epoch 58/100, Training Loss: 0.4377\n",
      "Epoch 59/100, Training Loss: 0.4405\n",
      "Epoch 60/100, Training Loss: 0.3284\n",
      "Epoch 61/100, Training Loss: 0.3042\n",
      "Epoch 62/100, Training Loss: 0.2826\n",
      "Epoch 63/100, Training Loss: 0.2921\n",
      "Epoch 64/100, Training Loss: 0.2911\n",
      "Epoch 65/100, Training Loss: 0.3246\n",
      "Epoch 66/100, Training Loss: 0.3212\n",
      "Epoch 67/100, Training Loss: 0.3771\n",
      "Epoch 68/100, Training Loss: 0.3666\n",
      "Epoch 69/100, Training Loss: 0.4033\n",
      "Epoch 70/100, Training Loss: 0.4656\n",
      "Epoch 71/100, Training Loss: 0.3926\n",
      "Epoch 72/100, Training Loss: 0.3935\n",
      "Epoch 73/100, Training Loss: 0.3893\n",
      "Epoch 74/100, Training Loss: 0.3852\n",
      "Epoch 75/100, Training Loss: 0.3102\n",
      "Epoch 76/100, Training Loss: 0.3141\n",
      "Epoch 77/100, Training Loss: 0.3180\n",
      "Epoch 78/100, Training Loss: 0.3275\n",
      "Epoch 79/100, Training Loss: 0.2925\n",
      "Epoch 80/100, Training Loss: 0.3000\n",
      "Epoch 81/100, Training Loss: 0.3145\n",
      "Epoch 82/100, Training Loss: 0.2885\n",
      "Epoch 83/100, Training Loss: 0.3313\n",
      "Epoch 84/100, Training Loss: 0.3678\n",
      "Epoch 85/100, Training Loss: 0.2751\n",
      "Epoch 86/100, Training Loss: 0.2707\n",
      "Epoch 87/100, Training Loss: 0.2368\n",
      "Epoch 88/100, Training Loss: 0.2709\n",
      "Epoch 89/100, Training Loss: 0.2677\n",
      "Epoch 90/100, Training Loss: 0.2942\n",
      "Epoch 91/100, Training Loss: 0.3071\n",
      "Epoch 92/100, Training Loss: 0.3216\n",
      "Epoch 93/100, Training Loss: 0.2859\n",
      "Epoch 94/100, Training Loss: 0.3297\n",
      "Epoch 95/100, Training Loss: 0.3125\n",
      "Epoch 96/100, Training Loss: 0.3052\n",
      "Epoch 97/100, Training Loss: 0.3946\n",
      "Epoch 98/100, Training Loss: 0.4366\n",
      "Epoch 99/100, Training Loss: 0.3291\n",
      "Epoch 100/100, Training Loss: 0.3432\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "AttentiveFPPredictor(\n",
       "  (gnn): AttentiveFPGNN(\n",
       "    (init_context): GetContext(\n",
       "      (project_node): Sequential(\n",
       "        (0): Linear(in_features=39, out_features=200, bias=True)\n",
       "        (1): LeakyReLU(negative_slope=0.01)\n",
       "      )\n",
       "      (project_edge1): Sequential(\n",
       "        (0): Linear(in_features=49, out_features=200, bias=True)\n",
       "        (1): LeakyReLU(negative_slope=0.01)\n",
       "      )\n",
       "      (project_edge2): Sequential(\n",
       "        (0): Dropout(p=0.2, inplace=False)\n",
       "        (1): Linear(in_features=400, out_features=1, bias=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01)\n",
       "      )\n",
       "      (attentive_gru): AttentiveGRU1(\n",
       "        (edge_transform): Sequential(\n",
       "          (0): Dropout(p=0.2, inplace=False)\n",
       "          (1): Linear(in_features=200, out_features=200, bias=True)\n",
       "        )\n",
       "        (gru): GRUCell(200, 200)\n",
       "      )\n",
       "    )\n",
       "    (gnn_layers): ModuleList(\n",
       "      (0): GNNLayer(\n",
       "        (project_edge): Sequential(\n",
       "          (0): Dropout(p=0.2, inplace=False)\n",
       "          (1): Linear(in_features=400, out_features=1, bias=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01)\n",
       "        )\n",
       "        (attentive_gru): AttentiveGRU2(\n",
       "          (project_node): Sequential(\n",
       "            (0): Dropout(p=0.2, inplace=False)\n",
       "            (1): Linear(in_features=200, out_features=200, bias=True)\n",
       "          )\n",
       "          (gru): GRUCell(200, 200)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (readout): AttentiveFPReadout(\n",
       "    (readouts): ModuleList(\n",
       "      (0-1): 2 x GlobalPool(\n",
       "        (compute_logits): Sequential(\n",
       "          (0): Linear(in_features=400, out_features=1, bias=True)\n",
       "          (1): LeakyReLU(negative_slope=0.01)\n",
       "        )\n",
       "        (project_nodes): Sequential(\n",
       "          (0): Dropout(p=0.2, inplace=False)\n",
       "          (1): Linear(in_features=200, out_features=200, bias=True)\n",
       "        )\n",
       "        (gru): GRUCell(200, 200)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (predict): Sequential(\n",
       "    (0): Dropout(p=0.2, inplace=False)\n",
       "    (1): Linear(in_features=200, out_features=1, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn = nn.MSELoss(reduction='none')\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=10 ** (-2.5), weight_decay=10 ** (-5.0),)\n",
    "n_epochs = 100\n",
    "epochs = []\n",
    "scores = []\n",
    "\n",
    "# Ensure graph and target are on the same device\n",
    "def run_a_train_epoch(n_epochs, epoch, model, data_loader, loss_criterion, optimizer):\n",
    "    model.train()\n",
    "    total_loss = 0\n",
    "    losses = []\n",
    "     \n",
    "    for batch_id, batch_data in enumerate(data_loader):\n",
    "        smiles, bg, labels, masks = batch_data\n",
    "        \n",
    "        # Move batch graph (bg) and labels/masks to the GPU if available\n",
    "        if torch.cuda.is_available():\n",
    "            bg = bg.to(torch.device('cuda:0'))\n",
    "            labels = labels.to(torch.device('cuda:0'))\n",
    "            masks = masks.to(torch.device('cuda:0'))\n",
    "\n",
    "        # Extract node and edge features, ensuring they are on the correct device\n",
    "        node_feats = bg.ndata['hv'].to(torch.device('cuda:0'))\n",
    "        edge_feats = bg.edata['he'].to(torch.device('cuda:0'))\n",
    "        \n",
    "        # Forward pass\n",
    "        prediction = model(bg, node_feats, edge_feats)\n",
    "        \n",
    "        # Compute loss\n",
    "        loss = (loss_criterion(prediction, labels) * (masks != 0).float()).mean()\n",
    "        \n",
    "        # Backpropagation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "         \n",
    "        # Track loss\n",
    "        losses.append(loss.item())\n",
    "         \n",
    "    total_score = np.mean(losses)\n",
    "    print(f'Epoch {epoch + 1}/{n_epochs}, Training Loss: {total_score:.4f}')\n",
    "    return total_score\n",
    "    \n",
    "\n",
    "# Training Loop\n",
    "for e in range(n_epochs):\n",
    "    score = run_a_train_epoch(n_epochs, e, model, train_loader, loss_fn, optimizer)\n",
    "    epochs.append(e)\n",
    "    scores.append(score)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "de09631b-2c9f-48f8-9faa-6ac8a24e5201",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGwCAYAAABRgJRuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQP0lEQVR4nO3de3wU9bk/8M8sJJsLySYhgQ0QIEBUIvdwgFRqAUNNBcSiqCgIlnIOFKyCF8AbIFXUWrxUD6hV0XqgtqICYqPcqoAgPwkg4U4IgpAIJCGBhFx3fn/EidnL7M7Mzt5mP+/XK69zspnd/W5Sncfn+3yfRxBFUQQRERFRiDMFegFEREREemBQQ0RERIbAoIaIiIgMgUENERERGQKDGiIiIjIEBjVERERkCAxqiIiIyBBaB3oB/mSz2XD27FnExcVBEIRAL4eIiIgUEEURly5dQocOHWAyyedjwiqoOXv2LNLS0gK9DCIiItLg9OnT6NSpk+zPwyqoiYuLA9D0S4mPjw/waoiIiEiJyspKpKWlNd/H5YRVUCNtOcXHxzOoISIiCjGeSkdYKExERESGwKCGiIiIDIFBDRERERkCgxoiIiIyBAY1REREZAgMaoiIiMgQGNQQERGRITCoISIiIkNgUENERESGEFYdhYmIiIJJo03ErqIynLtUg3ZxURiUnoRWJg5c1opBDRERUQDkFRRj0bqDKK6oaX4s1RKFBWMykdsrNYArC13cfiIiIvKzvIJizHg/3y6gAYCSihrMeD8feQXFAVqZNo02ETsKS7Fm7xnsKCxFo00MyDqYqSEiIvKjRpuIResOwtVtXwQgAFi07iBGZlpDYisqmDJOzNQQERH50a6iMqcMTUsigOKKGuwqKnP6mdaMiK8yKcGWcWKmhoiIyI/OXZIPaNxdpyQj4qrweMPBEp9kUoIx48SghoiIyI/axUWpvk7KiDgGEFJGZNnEAQDgFLwkxETgYnW902u3fJ7WwEZNxim7e1tN76EWgxoiIiI/GpSehFRLFEoqalxmOQQAVktTlgVQlhGZ/9F+lLsIXlwFNC2f500mRWvGyZdYU0NERORHrUwCFozJBNAUWLQkfb9gTGZzoKEkI+IqoPHEXe2OEloyTr7GoIaIiMjPcnulYtnEAbBa7G/4VkuU05aQrzMdWl9fyjjJ5XgENNXuSBknf+D2ExERkR9Jxby1DTa8cFtfQAAuXK6V7Sjs60yH1teXMk4z3s+HANhtj7nKOPkDgxoiIiI/cXeCSa6Y1lMNjlaOtTtaSBknx89kDVCfGkEUxcC0/QuAyspKWCwWVFRUID4+PtDLISKiMCJ3gknKY7g7iST3XK2UvKcavp5hpfT+zZoaIiIiH/N0ggloOokk1xQvt1cqHsi5SvX7SmFFQkyE3eOuancc16umWV8rk4Ds7m0xtl9HZHdvG7BOyNx+IiIi8jE9erp0TY5R/b7SNtDITKviTEowjT1Qi0ENERGRj+nR00VpQe8To3oiOc7sFLwoaYCnpMlfMAc2DGqIiIh8TI+eLkqb9k25Ll3T9k8wjj1QizU1REREKqmtOdGjp4vapn1qeTNoM1gwU0NERKSClpoTvXq6+PIIdTCOPVCLQQ0REZFC3tSc6BWQ5PZKVVX4q1Qwjj1Qi0ENERGRAnrUnOgVkEhHqPWkdtBmMGJNDRERkQJ61Zz4u6eL0vofX9fs+AMzNURERAqEYs2J2vqfYBt7oBaDGiIiIgVCreZEa/2Pr2p2/IHbT0RERAp4OpYNAAnREbCJoscj3r7mzVgGX89x8iVmaoiIiBRwdyxbcvFKPe7+2zcBHyugdSxDKI9IAJipISIiUkyqObFa3G8xSVs8n313VlWTPr1oqf+RtqscgyHps+QVFOu6Rl9gpoaIiEgFqeZkZ2EpZq7Mx8Ur9U7XSKHLrFV70DKO8VfWQ239jxFGJADM1BAREanWyiTAZBJcBjQtOSZm/JX1UDuWwQgjEgAGNURERJpoObrtqUhXL2p7zoTicXVXGNQQERFpoPXotr+yHnL1P1ZLlNNx7lA7ri6HNTVEREQaeBor4Ik/sh5Ke84YYUQCwEwNERGRJu62eJTQK+vhaQyCkrEMRhiRADBTQ0REpJncWAGT4FwkLNEz66FnX5lQH5EAAIIoioFte+hHlZWVsFgsqKioQHx8fKCXQ0REBuHYhbe8qg4zV+YDsG/SJ+U55EYUqCE3BsHb9wjGjsJK79/M1BAREXlJ2uJpaZnJd1kPX/aVcfVZQgWDGiIiohb0ylT4cjCk1jEIRseghoiI6Cd6zz5qmfXQc1vHKH1l9BZyp59ee+01dO3aFVFRURg8eDB27doV6CUREZEB+HL2UV5BMYY+txkT3tyJ+/+xFxPe3Imhz23W/JpG6Sujt5AKaj744APMmTMHCxYsQH5+Pvr27Ysbb7wR586dC/TSiIgohHmqUQG0dwH2RbCkdgxCuAipoGbp0qWYNm0a7r33XmRmZmL58uWIiYnB22+/HeilERFRCPPV7CNPwZII4NGP96OuwabqdY3SV0ZvIRPU1NXVYffu3cjJyWl+zGQyIScnBzt27HD5nNraWlRWVtp9EREROfJVjYqnYAkAyqrqMWTJJtUZGzVjEMJFyBQKX7hwAY2NjWjfvr3d4+3bt8fhw4ddPmfJkiVYtGiRP5ZHREQhzFc1KkqDoLKqOsx4P99jMOJYbDwy0+qzE1ahKGSCGi3mz5+POXPmNH9fWVmJtLS0AK6IiIiCka9mH6kJgkS47y2j5GRWMDbO86eQCWqSk5PRqlUr/Pjjj3aP//jjj7BarS6fYzabYTab/bE8IqKwYrSbp1SjMuP9fAhw3QVYS43KoPQkJMVGoKyqXtH1cr1l5LoHS8XGyyYOAABdj6OHopCpqYmMjERWVhY2bdrU/JjNZsOmTZuQnZ0dwJUREYUXvY8nBwtf1agMUZndcdyyUnIya/5H+zHdR8fRQ0nIZGoAYM6cOZg8eTIGDhyIQYMG4aWXXkJVVRXuvffeQC+NiCgsKMkYhHJWQM8uwK62i5Rw3LJScjKrvNp1JsjbkQmhJqSCmjvuuAPnz5/Hk08+iZKSEvTr1w95eXlOxcNERKQ/X84bCiZ6zD6SC/48cdVbxtuuwOE0MiGkghoAmDVrFmbNmhXoZRARhR3OG1LGXfDnjgDXdTt6dQUOh5EJIVNTQ0REgcV5Q8oo6U3jKNVN3Y6n7sFKhcPIhJDL1BARUWCE8rwh6bRWSWUNyi7XIik2ElZLtE9ObWkJ6l64rS+uy0h2+TMlJ7MsMRGoqK7X9Th6KGJQQ0REiviql4uvuSvY9cWRZy1B3ecHS2AyCbJBlnQyy/FzWH9aPwDdj6OHIkEURfXTuUJUZWUlLBYLKioqEB8fH+jlEBGFHKkAFnB98wy2009KCnYF6LvuRpuIoc9tlg3+3PEUZLnrD6SkOV+oUnr/ZlBDRESqhMrNUwoulNS3pFqisG3uCN2yGXLBnyfeBodGa4ooYVDjAoMaIiJ9hMLNc0dhKSa8uVPx9aumDdH11JbWPjXSNp6eQVaoU3r/5uknIiJSTerlMrZfR2R3bxuUN1+1BbsbDpbo+v65vVKxbe4IzBreXdXzWh6NJ3VYKExERIaktmD3w90/ICrCBJNgQnb3thjSzftgrZVJwHU9UvDqlkLVzw33o/FaMKghIiLDabSJsIkiEqIjcPGKsmGSlTUN+N//nAAAvLrlOBJiIvDsuN6ainZb8nRqTE4wHo0PdgxqiIjIULTWsji6WF2P6e/nY7mLot28gmIsXHsAJZW1zY9Z481YePO1Tte66zPjSrAejQ8FrKkhIiLDkE4deRvQtLRo3UE02n4ORfIKijH9/Xy7gAYASiprMV1mIrbcBHBH4dZXRm/M1BARkSFonbnkSXFFDXaeKMWQbm2x80Qp5vxzn9vr53203+VQT8cJ4CcvVGPVrlMoqXRuphdMR+NDCYMaIiIyBC0zl5Sa9t63iGxtwsVqz/U5F6vrsbOw1OXYA8cJ4LNG9FB8ND4UjtEHGoMaIiIyBF+eFqqua0R1XaPi63ecuCA7y6klxyBHTqg0PAw01tQQEZEhBNdpIf0yKHJ1QiUVNZghU8MTrhjUEBGRIUhHp4NhQ0avzsTu6oSkxxwLmcMZgxoiIjIE6eg0oC5PMjvnKiTEROi2jtjIVhjSTZ+gxlOdELsP22NQQ0REhqH06DTQFPikWqIwa0QP7H58JB676Rpd1lBV16jbyAWldULsPtyEQQ0RERmKNHNp1bQhmHpdV5fXOPaDaWUS8Luh3XTZvhKg35aQ0jqh4KonChwGNUREZDjSqaInxlyL5RMHINUhc2O1RGGZQ6dgrdtXjvTcEvJUJyRlm9h9uAmPdBMRUchR07PFsemdu+ul7SvH49NSzY2SPjUSPbaE3I1YYPdhZwxqiIgopGjp2aK0HwwgHwQBTYW7249fwKtbjnt8Hb22hOQCLXYfdsaghoiIAkpN1kXq2eJYrSL1bHHcUtJKLgjK7t4W5VW1Lp5hT+8tITXZpnDGoIaIiALGU9alZcCTHGvGwrXyPVukAl1Xc5dc0TJ2oNEmYvH6Qx5f+4lR+m8Jqck2hSsGNURE5DPuAgdPWZf/vj4da/cVK57nJBXorthehOQ4s8tARVrPxoMl+HjvGZRV/Vwjo2TsgNL5UomxkYrWTPpiUENEZCDBNPTQXRZmZKbVY6fc178q0vS+LTMpLd/v1c3H8c72Ily84rrYV8kWFvvGBDcGNUREBhFMQw89ZWEeyLnKZxO1WyquqMH09/MRE9nK40BKJVtY7BsT3NinhojIAIJh6GGjTcSOwlJ8vOcMHv14v9sszDtfa8vCaKV0wranHjPsGxPcmKkhIgpxnoYeqi2g1cJVlkiOCHX9XgJBbvuIfWOCGzM1REQhLtBDD+WyRJ4kREcExURtV9xtH8nNl3LVpZj8i5kaIqIQF8jiVXdZIk/uva4rXtp4zCnjoVRcVGvU1ttQ12jT8GzXBDQFJ562j9g3JjgxqCEiCnGBLF5VesS5JSlwmDUiA1db4xRvWzm6VNOg+jmeiFC+fcS+McGHQQ0RkY/463i1VLxaUlHjMuOhNPughZbsjwjg5r6paGUSnDIeybFmPPivffix0vVnIXKHNTVERD6QV1CMoc9txoQ3d+L+f+zFhDd3Yuhzm31yCsnddGlfF69qzf688VWRy9+FySTgydHeT8rWSiqqbrQxpApFgiiKYfOXq6yshMViQUVFBeLj4wO9HCIyKLkeLdJN2lfFpHr1qVGTYWq0iRj63GbZLJEcKXv0xKhMLF7vvOab+6aq6iast1XThnBrKYgovX8zqCEi0pF0k5e7GUs3821zR/gkc+LtlpeWwEgK4gBtBb+OpNW+dld/FFfUKJq1pLeX7+yHsf06+v19yTWl929uPxER6SjQx6ul4tWx/Toiu3tb1QGNlgZ+ckectZICo8XrD+GuwV2QFIA5SuwIHJoY1BAR6ShUZwN5auAHuK81ye2ViidG9dRtPVLwd91zm1BWVaf4eQkxEfj7vYNgjZfv+uuOmo7AUgflNXvPYEdhKetwggBPPxER6ShUZwOpyTC5qjVptIk+2SZqOUXbHSmAeXZcb/zy6hQsvNl1118llBRVB9OcLfoZMzVERDry52wgPTMF3maY1PSr0aOSyPE1HLv5atkSS1XYETgY5myRa8zUEBHpyF+zgfTOFHibYVKzndZ06qknHv2kQPMMKBHArQM64vqrUmQLolv2wNlwsARvbz8p+3qzczIwa0SGx79LMMzZInnM1BAR6czXs4F8kSnwNsOkNCh6YlRPbJs7AiaT4PVQy9X5Z3DwbIXbgmipcHpQehISYiKcfp4QE4HlEwfg/pyrFAUhgS4EJ/eYqSEi8gFfzQbyVaZASYbpzv/qjE+/O+vysyjtajzlunTgpzXq4fWvitC3UyJu6iMfKMr1DQKACpWBVagWgocLZmqIiHzEm+PVcnyZKZDLMCXERMASE4EXNx6V7Y6spquxlnlR7jyxpkC2nkjJwE01HYRDtRA8XDCoISIKIb7OFOT2SsW2uSOwatoQvHxnP8zOyUB5db3TVpGrrS6l2256ZzFKq+pkgzi9g0B/FoKTetx+IiIKIf7IFEgZpkabiKw/bXB5jeNWF9AUQNQ22PDCbX0BAbhwudblVpUvshhygZLeQaC/CsFJGwY1REQhxJ8TuV/dfNxtMa+U5Xh18zH84/+dtsuIWOPNmDCoM4CmYKdlYDMoPQlJsZGqmup5Ihco+SIIlDJSjqfPrOxTE3Cc/UREFGLkZi3pOTCz0SYia/EGXLzi3QklieNx88++K8YfVuZ7fF5CdGtcvNLg8bW/fHg4dn9f7lSU7WngpjezuLyds0XKcaClCwxqiMgofNnRttEmYsX2Il07BEu3+gdyrkLX5Bi0i4vCpoMl+Jub3jEAsHziAOw5VY7XvyqSfd3/vj7daaJ3y9+FP4JA8i0GNS4wqCEiI/FFpsBVsOQrJgGQO3SUGBOBJeN622V2Hl9TYLdllWqJws19U/HGV0VOWRjHgIVjDUIbgxoXGNQQEclz18/Fnx64IQP33eDc3dcxiMvqkohf/XmLbADmuLXE7aLQpfT+zUJhIqIQIt2YSyprUHa5FkmxkbBaor2+QSvp5+IPAoAPvj2N+27IcPqZdCpLsqOwVNUQzlYmAYPSk5oDG8cCZgp9DGqIiEKEu60hb7dStDbEa2Nuhcu1jZre0xVP08BbUntcm1tQxsfme0REIUBu3pOkWMHcJ3dTvbU0xLPGm9G6lW9uI0rWo+a4NidrhwdmaoiIgpzSrSER8nOfPGUp1DbEEwBMGNQZL248pup5SilZj9KePVLtDSdrG19IZGpOnjyJqVOnIj09HdHR0ejevTsWLFiAujr9GjcREQUrNVtDrlr+K8lSeGr/31LqT2MPuibHKv0IqiTGRChqHqh03tTu78s5WTtMhERQc/jwYdhsNrz++us4cOAAXnzxRSxfvhyPPvpooJdGRKSYu+0fd9RuDbW83tNUbxHAwrUHAMBjgPC767ri/34/GC/c1he1DTZcuFSral1KqSlWVjJvipO1w0dIbD/l5uYiNze3+ftu3brhyJEjWLZsGV544QXZ59XW1qK29ud/6CorK326TiIiOd4UqardGmp5vZIsT0llLeZ+uA+/vCoFD+RchVW7TqGk0rn9PwA89K99dq/nrteMVher6xUVCktye6ViZKZV9rg2J2uHj5AIalypqKhAUpL79OSSJUuwaNEiP62IiMg1uf4v0vaPp462nmpHWnKcEK00+/Bh/hl8mH8GQFMB8OycDHRuG9t8bPxIyWW8tPGo0/vrHdBIth8/r+q4teNx75b8OS+LAiskm+8dP34cWVlZeOGFFzBt2jTZ61xlatLS0th8j4j8Rpo9pLRBnBwljfEEOLf831FYiglv7lS1Zmn6dEJMhNuBlr6m53FrjkoIbUqb7wW0pmbevHkQBMHt1+HDh+2ec+bMGeTm5mL8+PFuAxoAMJvNiI+Pt/siIvInT9s/SotUpdqRVIvrLZLUFjUkLUlZCjWkm77eAY3g8H890fO4tZLaGwp9Ac3UnD9/HqWlpW6v6datGyIjIwEAZ8+exbBhwzBkyBCsWLECJpO6mIxjEojI39bsPYP7/7HX43Uv39kPY/t19Hidlo7CSidi+1qqJQp3/ldnXKyuxTtff6/oOd5M0XaFoxJCU0iMSUhJSUFKSoqia8+cOYPhw4cjKysL77zzjuqAhojIFzzdJPUuUnVXOyK3lsTYSEWv7Su/7dcBXZNjsWrXKby48Wjz40qKjNV0GFbC3e+PQl9IFAqfOXMGw4YNQ5cuXfDCCy/g/PnzzT+zWq0BXBkRhTMlJ5r8VaTqbi21DTavXttbCbGReGnjMafPr2afgMetSYmQSHds2LABx48fx6ZNm9CpUyekpqY2fxERBYJcQ7viihpMfz8fL288hkabqLhBnLstEE/9bTw11zt5oUrTZ9TLmr1nZfvkKOUqk6W17w8ZV0ieftKKNTVEpAdPJ5ok1ngzFt58LXJ7pbrMpFjjzZgwqDO6JsfK1nd4ygYpOV3VPt6MK/U2VFzx/0mm2MhWqKrTPvBSrqaGwynDi9L7N4MaIiKV1ByTbnnMumXNy8kL1U5N7hxvynLHuFseQ7ZERypay20DOjb3oQlW0lHylt8DzsetlfxeGNgYS0gc6SYiCkVq6zsWrTvYvBWV3b0tzK1NeGnjUbuABrA/wqxkvMGidQdRUnFF0RqyuyejjbmVqnX70+ycDEXHrT39XoCff98UfkKiUJiIKJioaafveHrH001ZmhgdZ47wuL1VXFGDsiplg32f/uwQLtdq3wbyZHTvVHxdWIqyanWDhqXtpVkjMjBrRIbH49Zq+v7wlFP4YVBDRKSSmrEFEim7o/SmvL3wvOw1Lf1w8YqitSgNfrQY3ScV678rVlX4C7gulPYUiHA4JbnD7SciIpVanmhSSsruKL3ZvrdDWXO6tXvP4rHfXKM6oNBL+7hIfHuyXNP7a+nmy+GU5A6DGiIiDZrb7se7v3kKsB8yqfRmq3SrqLSqDk+uO+jyZ0mxEYpeQwvhp6+7Bndxqg3yZNbwHlg1bQi2zR2huqBXypLJHYB3/H1TeGFQQ0SkUW6vVGyfNwKzczJc/tzV9kp5VS307sovt7XUt2OCvm/UgpRl6Zocq+p5JgH44w0ZyO7e1uN4Ald9aPTo+0PGxZoaIgpr3s4CamUScH/OVbjaGufch8bFEe2ZK/f4batoy1FldTlq/O66rhiZaW3+Pe0odD+/z5FNBHZ/X+6xdsZTH5plEwd4/H1T+GFQQ0RhS00DN0/BT26vVIzMtMpe4+7UUyA5zl9Kio1A/7QE7Dl9EWVVPzfrk/u9eFM0LUeuD4105F2qw3H3+6bwxKCGiMKS0hundK2S4MfdsMSdJ0o9HtH2J+nW/+qEAUiMjXQKDJRmsKTtoBnvK58C7q6uSOmR95GZVg6nJCcMaogo7Ki5cW44WKI4+JGTV1CMeav367R6fSTFRuLp3/ZyamynNPPheO1rdw3AU58edFs0rGR4J/vQkDcY1BBR2FF649xZWOqxe+28j/YjzhyBITKFr3IZoUC7uW+q0+gBpVtxctc+Obonjp27jBc3HnN6P6VFvOxDQ97g6SciCjtKb4g7TlzwuGV0sboed7/1DYY+txl5BcV2PwvWOhoA+DD/B3y8p+lU0WffuZ/y3fJzuZsIPnPlHlxtjcPyiQOQqmDkgSvsQ0PeYKaGiMKO8hui8qJTV9tRnjJCgXSpphGzP9gLoKlYWMnYhnOXa7H40wMer902d4TmIl5PhcdKtrAofDFTQ0RhR2kDNzU1G66GKYbKFom72Y/SVtzdb32D2R/stTsRJXftrqKy5iLesf06KupJI2EfGvIGgxoiCjtKb5xDurX12DG4pZY3dSB8t0i8DeaauzVr3MKi8KV4++mVV15R/KJ//OMfNS2GiMhflDRwyysoRk2D+snW0k1dSw8XI5AL5tScrmIfGtJCEEVR0T9r6enpyl5QEHDixAmvFuUrlZWVsFgsqKioQHx8fKCXQ0RBQO5G682ppVXThjRvXUmvA7iuWwEAQQCU/Zs4uEn1LtvmjnAKPtScriJypPT+rTioMQIGNUSkRKNNxNDnNqsu8pW7qbu6oSfFRuC3/ToiJ9OK8qo6zFypPIBKio1EeVVdUGV/pE/rantILkB09xyilpTev3n6iYjIgZZTS66KWKUsUG2DDS+M7wuIwIWqWpdbKctMAzDvo/24WC1fiAs0ZTeeGJWJmSvzIUA+++NvcnOX1HYIJvKG5qDmhx9+wNq1a3Hq1CnU1dlPiF26dKnXCyMiChQtha7Wn4INS3Qk1uw9g5MXqrBq1ymUVNY2XyNtt7g6VTUy04qFaw94fJ8nRvXETX1Sscw0AI9+XCA7odvXBDRljB4f1RNWS7RsvQs7BJM/aQpqNm3ahJtvvhndunXD4cOH0atXL5w8eRKiKGLAgAF6r5GIyK+Unlp6YlRPJMeZ0S4uCuVVtVi8/qDbG7jUy+aBnKvQNTnGLmOzq6jMLgCSkxhrBtBUSHulrhGz/7lP2YfygmNGSApdHMcsuMIOweRPmoKa+fPn46GHHsKiRYsQFxeH1atXo127drj77ruRm5ur9xqJiPxKaQO4KdelNxcVz1y5x+NWkPTzFzcebX5Myt7UNtgUrU26+TfaRJ9maaTP+MSonli8/pDsCTFP2CGY/ElTUHPo0CGsWrWq6QVat8aVK1fQpk0bPPXUUxg7dixmzJih6yKJiPyp5eRpuSyFVDvj7SgEKXszqo+yQtnkWDNe3ngU72w/iYtX3NffuCMASIiJQHl1vdvPmNsrFTf2StV8tJodgsmfNAU1sbGxzXU0qampKCwsxLXXXgsAuHDhgn6rIyLyE8ej3SMzrR772ADej0KQbvSf7S92ex0AJES3xsxV+R6LiQH7LSO5oGXJuN4A4PEzSt2BtVATIBJ5S1NQM2TIEGzbtg09e/bETTfdhAcffBD79+/HRx99hCFDhui9RiIin3LXQ2Xb3BFusxR61YK4G1UguXilQfHrSYEJ4Dlo8XWTOyWNDon0oKlPzYkTJ3D58mX06dMHVVVVePDBB/H1118jIyMDS5cuRZcuXXyxVq+xTw0ROfK2h8qOwlJMeHOnz9anxROjejbX+wDqOvn6UrCsg0KPT/vUdOvWrfn/j42NxfLly7W8DBFRQOnRQ6W8qhYmQVmmxV+S48x26/Vm+0hPwbIOMi5NAy27deuG0tJSp8cvXrxoF/AQEQUzNT1UgKYgaEdhKdbsPYMdhaX47LuzmLlyjy4BjUlwHq6pFU8SUbjSlKk5efIkGhudh7zV1tbizJkzXi+KiMgf1PRQcVV3YxK87+grBTLTfpmON74qcllMq+Y9Ul2cJOK2D4ULVUHN2rVrm///zz//HBaLpfn7xsZGbNq0CV27dtVtcUREvqQ0o3HyQjVe2njUKbjQI0PTsli2f+dEl8W0T4zqiUc/KVB06snxJJGvBkkyUKJgpKpQ2GRq2q0SBAGOT4uIiEDXrl3xl7/8BaNHj9Z3lTphoTARtSQNrnTXQ6V9vBmAgJJK/Tre3tI3FcN7tncZDLgKFjYcLMH0nyZ9y0mIicCz43rbBSq+GiTJidvkb0rv36pqamw2G2w2Gzp37oxz5841f2+z2VBbW4sjR44EbUBDRORI6qECONezSN9PGNRZ14Cm6cUFjO3XEdnd2zplN6RiWunnQFOxsjttzK2w69Ecu4DCUxG09LqNKtNNUqDkWIskNRHMK/Dcb4fIVzQVChcVFSE5OVnvtRAR+Z3UQ8Vqsd+KslqisGziAHRNjtX9PTsmRLv9ecuC5BXbizw297tc24jd35fbPaa2CFoJXwVKRHrRPKV706ZN2LRpU3PGpqW3337b64UREflLbq9U2QZ0OwqdT3p66xc9kmVrUlxt7SjhWPTsi0GSnLhNwU5TULNo0SI89dRTGDhwIFJTUyEILA4jCkdGKhaV66HiaXYRAAgCoLQ6sY25NSqq6zD0uc1ONSk3903FG18VaTpR5Vj07ItBkpy4TcFOU1CzfPlyrFixApMmTdJ7PUQUIsKlWFSqu3FXqCuKwP03ZODdrz0PmZwwKM3lRO+Sihq8/lWR6vXJDYT0xSBJTtymYKeppqaurg6/+MUv9F4LEYWIcCsWHZlpRUJMhOzPBQD//PY0nvltb7cN9Kb9Mh2fflfstiZFDXcDIZUUQasdJCkFSnLPEOC6Tw6Rv2gKan7/+99j5cqVeq+FiEJAqBSLOnb/VbMex+fuPFHqtkeMVEuSGBuJZRMHINWh6DgpNgL/e1d/jLimvVcTvR1JxcxymTFPRdBqM2q+CJSI9KRp+6mmpgZvvPEGNm7ciD59+iAiwv6/YJYuXarL4ogo+IRCsehn353F42sKUFb1cyCidGvM1bZaQrR8lqalc5dqMLZfR9mi4zV7ve+4/sSonkiOMyuuYXJXBK0FJ25TMNMU1Hz33Xfo168fAKCgoMDuZywaJjK2YC8WXfLZQZe1KcU/bY25y1DINavzVCcjkWpJ5IqOva01MQnApOyuiGytLsmu9yBJvQMlIr1oCmq2bNmi9zqIKEQEolhU6Smrz74rdltsK0J+6ra7bTVPBABJsZEoqbiCHYWlsuuTalK0bkHZRGD39+VBcVyaE7cpGGnuUwMAx48fR2FhIa6//npER0dDFEVmaogMzhenatxResqq0Sbi8TUFrl7CjtzWmKdtNXdEAKVVdZj9z30AAGt8FBbe7LwV08ok4Oa+qZpOOUl4XJpInqZC4dLSUtxwww246qqrcNNNN6G4uOmkw9SpU/Hggw/qukAiCi7+LBZVc8pqV1EZyqrqFL2uY2DQaBOx/fh5r9fbvL7KGkx3cQosr6AYb3gR0AA8Lk3kjqagZvbs2YiIiMCpU6cQExPT/Pgdd9yBvLw83RZHRMFJ71M1rng6ZSUCmPfRfmw/dgGNNlFVBqNlYJBXUIyhz23Gq1sKvV6zo/kf7W8+daVke8skOAeKEh6XJvJM0/bTF198gc8//xydOnWyezwjIwPff/+9LgsjouDm62JRJdtBF6vrcfdb3yDVEoU7/ytN0esmxUY0BwZyhcF6Ka+ux84TpbiuR7KizyOdOhdg37eGx6WJlNGUqamqqrLL0EjKyspgNpu9XhQRhQapWHR0nw4AgE+/O6u6J4wcNZmXkooavLjxmNsGeZKnxvTCrqIyfJz/Ax79uMBnAY1Emh2l9PP87rquPs2AERmZpkzNL3/5S7z33ntYvHgxgKZj3DabDc8//zyGDx+u6wKJKLj5alyCmtoRET9nMxyzHC2ZW5vw+NoCt4309Ne0GqWfZ2SmFY+NyuRxaSINNAU1zz//PG644QZ8++23qKurwyOPPIIDBw6grKwM27dv13uNRBSk5LZvShT0hPFEySDJlkQ0bUfNzrkK73xd5DJwqW2wobbBpmodM4d1x+r8M/ixUtk6HGV3Swag7tQYj0sTaaNp+6lXr144evQohg4dirFjx6Kqqgrjxo3Dnj170L17d73XSERByNfjEtydsnKnc1I0olQ2p3NnaEYKFt6sfh0AkBATgSE/BSccMUDke5r71FgsFjz22GN6roWIQog/xiXIteR3p6yqDiWVtZreryXHzImrdSTGRKDczVbWs+N62wUpHDFA5Fuag5qamhp89913OHfuHGw2+3TuzTff7PXCiCi4+WtcgnTKaueJUsz8v3y3Iwus8WYktdHnsIII+8yJ3GmvDQdLsHDtAbtAyhpvxsKbr3UZpHDEAJHvaApq8vLycM899+DChQtOPxMEAY2NjV4vjIiCmz/HJbQyCbiuRzKevbU3ZryfD8B1MXBNgw2nSqu9fj+gKQszMtPqtA7HrJOWIIU1M0S+oWnj+b777sP48eNRXFwMm81m98WAhig8SIWv/mwWJ23fWGSObldU1+OljUeREBOhuv7FUXl1PXYVlSm6VgpSxvbriOzubZl1IQoQTUHNjz/+iDlz5qB9+/Z6r8ej2tpa9OvXD4IgYO/evX5/fyJqEqjC15GZVkS1buXyZ1L2RjrW7e07c84SUWjRFNTcdttt+M9//qPzUpR55JFH0KFDh4C8NxHZ88e4BEevbj6Gkkr3Bcrl1fWYnZOB9vH29TUJ0a0VNeiTnLxQpXWZRBQAmmpqXn31VYwfPx5bt25F7969ERFh/y+JP/7xj7osztG///1vfPHFF1i9ejX+/e9/++Q9iEgdfxa+5hUU48WNxxRdW3GlHo65mqiI1nhydCYs0RH4w8r8n66R9/b2IgzskoQhftpSarSJLCAm8oIgiqLqJhJvvfUWpk+fjqioKLRt2xaC8PM/dIIg4MSJE7ouEmja8srKysInn3yC5ORkpKenY8+ePejXr5/sc2pra1Fb+/OJhMrKSqSlpaGiogLx8fG6r5GIfKfRJmLoc5sVH+12Rfo31bKJA3Ck5DJe3HhU0fP06JDsia86MxMZQWVlJSwWi8f7t6btp8ceewyLFi1CRUUFTp48iaKiouYvXwQ0oihiypQpmD59OgYOHKj4eUuWLIHFYmn+SktTNvCOiHyv0SZiR2Ep1uw9o2helJKBkBK55EbLpoCd2zrPr5MjdUjOKyh2e53azySROjM7fj6l70tETTRtP9XV1eGOO+6AyeRd18558+bhueeec3vNoUOH8MUXX+DSpUuYP3++qtefP38+5syZ0/y9lKkhosBSkpVw3Iopqbii+PXdxRJSU8Cyy8ob9ElFx4vWHcTITKvLLSGtmRZPnZk9vS8R/UzT9tPs2bORkpKCRx991Ks3P3/+PEpLS91e061bN9x+++1Yt26d3TZXY2MjWrVqhbvvvhvvvvuuovdTmr4iIt+RmxfVcmsIgFOAkBQbibKqOo+v3z8tAXtOX/R43Yu398Xznx9RPFtKsmraEKceM0o+k1xgs6OwFBPe3KnpfYnChdL7t6ZMTWNjI55//nl8/vnn6NOnj1Oh8NKlSxW9TkpKClJSUjxe98orr+BPf/pT8/dnz57FjTfeiA8++ACDBw9Wt3giChglWYl5H+1HRXW90zXlCgKaxJgIHP3xkqK1WC3ReGJUJv6wMl/R9RLHY97eZlr81ZmZKBxoCmr279+P/v37AwAKCgrsftYym6KXzp07233fpk0bAED37t3RqVMn3d+PiHxDybwoV9O1pZ954m4OU0ttYyNRXlWLxesPKbq+JccOyd7OwPJnZ2Yio9MU1GzZskXvdRBRGNAr25AUG4GyKmUBjCv90iyYuXKPqm0nwHWHZG8zLVJnZrltsJaDNYnIPc0DLQOpa9eu0FAKREQBple24YnR18Ia31Q8vHj9IUW1Ni3tOX1RdUAjwHWHZG8zLVJn5hnv5zd3Qm75npB5XyJypjioGTduHFasWIH4+HiMGzfO7bUfffSR1wsjotDkroGcp6yEUtb4KGR3b4sdhaWqA5q2sZEoVfmcxJgILBnX22Wxrx6ZFqkzs2NxtJV9aohUURzUWCyW5noZi8XiswURUehyd6xZ6jp8Uy8r3tp+UvN7tI2NbA4Q1GxnSXmOsf064G2V729uLd++Qq9Miz87MxMZleoj3aIo4vTp00hJSUF0dLSv1uUTPNJNgRAure/dHWsWASTERNgVAQsCoGUX+XfXdcWTY64FALy88ZjirsDWeDMW3nwtLNGRio5Qt6TkaDY7AhP5js+OdIuiiB49euDAgQPIyMjwapFERhcuNzpPx5oB51NNWsviRmZaATT9bl9SGNAAwF9u74freiSj0SY6BVieKDmazUwLUeCpbglsMpmQkZHhsWkeUbgLp9b3akYYeCMhJgKD0pPcBlFyLvzUQXjDwRJVAY2k5dFsOa1MArK7t8XYfh2R7achmET0M01zDp599lk8/PDDTj1qiKiJkszFonUHFc8GCnb+agwnhQhagqh2cVHNfxdvsAkeUfDSdKT7nnvuQXV1Nfr27YvIyEin2pqyMvn/kiEKB942ZAs1/moMV15d37y9o1TL00d6ZJTYBI8oeGkKal566SWdl0FkLOHW+l6vo9pKSPUqakinj7z5fbMJHlHw0xTUTJ48We91EBlKuLW+d3esWW9SAa6SIEo68SQVZWv9fbMJHlFo0FRTAwCFhYV4/PHHMWHCBJw7dw4A8O9//xsHDhzQbXFEoUq66crd/gS4brkfyqQGclaL7wK1xJ8KhaUgCoDs73h2zlXYPu8Gu1Nmnv4uQNNRc0eWmAi3x7mJKDhoCmq+/PJL9O7dG9988w0++ugjXL58GQCwb98+LFiwQNcFEoUidzddI/9Xf26vVGybOwKrpg3By3f2wxOjeur6+uXV9dhwsKT5vVwFUamWKCyfOAD352Q4/X6VBEOujppXaDgtRUT+p7r5HgBkZ2dj/PjxmDNnDuLi4rBv3z5069YNu3btwrhx4/DDDz/4Yq1eY/M98rdw6VMjp9EmYuhzm3WrtZHqWrbNHdEcsGhpbujq72ISALnDaK7el4j8x2fN9wBg//79WLlypdPj7dq1w4ULF7S8JJEhhXtDNr1rbVydGpN6w6jh+He5cKkWi9cfUvW+RBR8NG0/JSQkoLjYuXHYnj170LFjR68XRWQk4d6QzRe1NnqcGmv5d0mOM/vtfYnIdzQFNXfeeSfmzp2LkpISCIIAm82G7du346GHHsI999yj9xqJKMS1rLX53XVdAcjXGimh96mxcDutRmRUmoKaZ555Btdccw3S0tJw+fJlZGZm4vrrr8cvfvELPP7443qvkYgMQMqMPDnmWix3kbmxWqLwv3cNCMipsXA8rUZkRJoKhSWnTp1CQUEBLl++jP79+wf9gEsWChMFjmNBb1aXROz+vtyp1kiamQXY1+AomZTtjUC9LxF5pvT+7VVQAzRN7QYAwVVzhyDDoIZIX0pPHqk9BRaoU2PhflqNKFj5PKh566238OKLL+LYsWMAgIyMDDzwwAP4/e9/r23FfsCghkg/SgMAKQPi+C8aTxkQLUe19RCo9yUieT490v3kk09i6dKluO+++5CdnQ0A2LFjB2bPno1Tp07hqaee0rZqIgoJcoFKSUUNZryf3xyoeJpWLqBpWvnITKvLRnlqjk/rFYxoOSJORMFBU6YmJSUFr7zyCiZMmGD3+KpVq3DfffcFba8aZmqIvCc11JObdt2yUd2uojJMeHOnx9dcNW2IV4EEt42IjM2nmZr6+noMHDjQ6fGsrCw0NDRoeUkiChG7ispkAxrAvlGdP6aVe8oavXbXACTGRnI7iSgMaApqJk2ahGXLlmHp0qV2j7/xxhu4++67dVkYEQUnNYGKHv1f3G0redreAoBZq/Ltxh8wg0NkXJqCGqCpUPiLL77AkCFDAADffPMNTp06hXvuuQdz5sxpvs4x8CGi0KY0UDn242UktzHDGm/Gj5W1LgMPaatKrv+Lp20lT1kjwHmek2PdDxEZh6aamuHDhyt7cUHA5s2bVS/KV1hTQ+Q9tUMqE2IicLG63mn2k6fTT0pOTdU22HD/P/aq/QgcUEkUYnxaU7NlyxbNCyOi0KZ2SGVFdT0AwPJTcCOxutkGUnpq6oXxfTV9Bg6oJDImTUHN+fPnkZKS4vJn+/fvR+/evb1aFBEFN2lIpePWkCtSEBId0QqvTR2AC1W1Hgt2lRYjQ2zajlKaNXLEAZVExqJp9lPv3r2xfv16p8dfeOEFDBo0yOtFEVFwarSJ2FFYijV7z8ASHYkvHx6OVdOGYNbw7m6fJwUhh0sqMbpPB4/TypUGGxeqarFgTCYAdQMxJRxQSWQsmjI1c+bMwa233op7770XS5cuRVlZGe655x7s378fK1eu1HuNRBQE3BXtZrSPU/Qai9cfwt+2FXk8faTm1FR297Yus0YmwblIWOKpQJmIQpPmMQl79uzBpEmTUFtbi7KyMgwePBhvv/02rFar3mvUDQuFyWj81dLfU9HuAzkZeHHjMUWvpWRApKdiZFeFvo6/i/KqWsxcuQcAB1QShTqfFgoDQI8ePdCrVy+sXr0aAHDHHXcEdUBDZDT+6qKrpGh31a5TsMZH4cdKz7UtnsYjAO6LkaWrF4zJtHuuq/EGy0yC0+/IXYEyEYU2TTU127dvR58+fXDs2DF89913WLZsGe677z7ccccdKC8v13uNRORAypw4FtNKPVjyCop1ey8lRbsllbW487/SACirbWl5+kiOVIxstdhvRVktUYqzLLm9UrFt7gismjYEL9/ZD6umDcG2uSMY0BAZlKZMzYgRIzB79mwsXrwYERER6NmzJ4YPH46JEyeid+/e+OGHH/ReJxH9xJshkVooLdpd8fVJ/Pf16Vi7r9jjiSilr53bKxUjM61ebbFxQCVR+NAU1HzxxRf41a9+ZfdY9+7dsX37djz99NO6LIyIXFMze0mPm7nSot2LV+rxxldFeO2u/iiuqMHi9Yd0eW0GJUSklKrtp5tuugkVFRXNAc2zzz6LixcvNv+8vLwcq1at0nWBRGTPH0MiWxqUnoRUS5TiI9OL1x/CpOyuHp+TFBuBksoabD9+AduPXcCavWewo7AUjXJHloiIPFCVqfn8889RW1vb/P0zzzyD22+/HQkJCQCAhoYGHDlyRNcFEpE9PYZEqtGyaNcTKUu0+/tyj12Hy6rqMfuDvU6Pc+AkEWmlKlPjePpb42lwIvKCp8yJgKbAQM8eLFLRbkJ0hKLrz12qkS309cQXxc5EFB40nX4iosCRMieA80kjuePOesjtlYrX7h6g6FopS9Ty9NGLt/dFUmykx+dK/6m0aN1BbkURkSqqghpBECAIgtNjRORfao87txxv4E3dypBubVVniaRCX6slGmVVdYreR8mRbyIiR6pqakRRxJQpU2A2mwEANTU1mD59OmJjYwHArt6GiHxL6XFnPZv0aWmKJ9FSuMyBk0SkhqqgZvLkyXbfT5w40emae+65x7sVEZFino47y403kOpWtIwKkJvQ7alTr5bCZQ6cJCI1VAU177zzjq/WQUQ682WTPi1N8QalJyEhOgIXr9Qreg+9i52JyPhYKExkUGqa9GkhZYnG9uuI7O5tPQZGrUwC7r0uXfHr+6LYmYiMjUENkUEprUf529ZCn63BsUB5xrDuSIjxfCx82i/T2aeGiFTTPKWbiIKb0nqUTYfP47PvzuKmPh10fX+5AuU7BnbC618VuX3u37YWIatLIgMbIlKFmRoigxqUnqSoLwwAPL6mQNeeMO6miL/xVRGm/bIrPO0ssU8NEanFoIbIoFqZBNzST1n2payqXreeMJ4KlAFgdf4ZuItX2KeGiLRgUENkYCMzrYqv1asnjJIC5bIqZSeg2KeGiNRgUENkYGq2oPTqCaNnIMI+NUSkBoMaIgNrZRLwp7G9PF6nZ08YpYFIUmykX4dyEpHxMaghMrib+qTif66X7w8jQN+eMEqniEvBlj+HchKRsTGoIQoD82/KxP/e1R9JsfY9YlJlBmB6Q+kU8Zv6qBvKSUTkiSCKYticmaysrITFYkFFRQXi4+MDvRwiv2u0iapGG3hD6SBNf66JiEKT0vs3gxoi8hkGLESkB6X375Daflq/fj0GDx6M6OhoJCYm4pZbbgn0kohcchwPEK5N5NTOhyIi8kbIjElYvXo1pk2bhmeeeQYjRoxAQ0MDCgoKAr0sIidKt12IiEhfIbH91NDQgK5du2LRokWYOnWq5tfh9hP5mjQewPEfKik/wQJYIiL1DLX9lJ+fjzNnzsBkMqF///5ITU3Fb37zG4+ZmtraWlRWVtp9EfmKkvEAnGdEROQ7IRHUnDhxAgCwcOFCPP744/j000+RmJiIYcOGoaxMfjbMkiVLYLFYmr/S0tL8tWQKQ0rGA3CeERGR7wQ0qJk3bx4EQXD7dfjwYdhsNgDAY489hltvvRVZWVl45513IAgC/vWvf8m+/vz581FRUdH8dfr0aX99NApDSscDcJ4REZFvBLRQ+MEHH8SUKVPcXtOtWzcUFxcDADIzM5sfN5vN6NatG06dOiX7XLPZDLPZrMtaiTxROh6A84yIiHwjoEFNSkoKUlJSPF6XlZUFs9mMI0eOYOjQoQCA+vp6nDx5El26dPH1MokUkcYDlFTUuKyrAYDEmAjOMyIi8pGQqKmJj4/H9OnTsWDBAnzxxRc4cuQIZsyYAQAYP358gFdH1EQaD+CuDLi8uh7PrD8Y1r1riIh8JWT61Pz5z39G69atMWnSJFy5cgWDBw/G5s2bkZiYGOilUYjyRbdbmw0QBMBdo4S3tp/EW9tPsncNEZHOQqJPjV7Yp4YkvmiQl1dQjOnv5yu+3te9aziigIiMQun9O2QyNUR6kWuQV1JRgxnv52sKMqQeNWqIaApsFq07iJGZVl0DDnY1JqJwFBI1NUR68VWDPE89auT4oneNFLQ5rkcK2vIKinV7LyKiYMKghsKKrxrkedt7Rq/eNexqTEThjEENhRVfNcjztveMXr1r2NWYiMIZgxoKK75qkCf1qFFbFSOgqdZFr9417GpMROGMQQ2FFU/Bh9YgQ+pRI72GEtJ1C8Zk6lYkzK7GRBTOGNRQWHEXfHgbZOT2SsWyiQNgtdgHDKmWKPzP9elIdXjcaonS/Ti3r4I2IqJQwD41FJZ8eeRZrj9MXYMNf99xEt+XVaNLUgwmZXdFZGv9/7tCOv0EwK5g2Nd9cYiIfEXp/ZtBDQU1XzaQ82dzOldBVEJ0BO69ritmjcjQ/X3Zp4aIjIRBjQsMakKLUW7Mcs3+JAkxEXh2XG/dPxM7ChORUTCocYFBTeiQCwRCbQul0SZi6HObPTbmExA6n4mIyN+U3r9ZKExBx0gN5JR2GhYROp+JiChYMaihoGOkBnJq+sGEymciIgpWDGoo6BipgZzafjCh8JmIiIIVp3RT0PFFA7lAFc1KfWOUDrtkUzwiIu0Y1FDQkQKBkooal3U1Apoa1yltIBfIU1RSs7/pP/WNkaP2MxERkTNuP1HQ0bPrr3SKyjFTUlJRgxnv5yOvoFiHFbuX2ysVyycOQEJMhMuf+2JcAhFROGJQQ0FJbuSAmtECwXSKKrdXKnY/PhKzc65CQrR9cOOLcQlEROGIfWooqHlTC7OjsBQT3tzp8bpV04Ygu3tbb5eqGJviERGpo/T+zZoaCmqtTILmgCNYT1F585mIiEget5/IsHxxioqIiIIXgxoyLOkUldzGjoCmU1A8cUREZAwMasiw9DxFRUREwY9BDRmaHqeoiIgoNLBQmAwvt1cqRmZaNZ844mklIqLQwKCGwoLWE0eB7EZMRETqcPuJwkqjTcSOwlKs2XsGOwpL3TbeC4ZuxEREpBwzNRQ21GRdGm0iFq6V70YsoKkb8chMK7eiiIiCBDM1FBbUZl1e3XwMJZXyTflEAMUVNdhVVOaL5RIRkQYMasjw1M6Ayisoxosbjyl6bX93IyYiInkMasjwdhWVOWVoWmqZdZECIKXYjZiIKHiwpoYMT80MKE8BUEtG60bMo+tEFOoY1JDhqZkBpWY7yUjdiHl0nYiMgNtPZHhqZkApDYBm51xlmJs9j64TkVEwqCHDUzMDylMABADWeDNmjejhi6X6ndoiaiKiYMaghsKC0hlQngIgAcDCm681zLaTmiJqIqJgx5oaChtKZ0BJAZBjjYnVgDUmaoqoiYiCHYMaCitKZ0B5OwQzVKgpoiYiCnYMaohkaB2CGUqkGqKSihqXdTUCmjJURjq6TkTGxZoaojCmpoiaiCjYMaghCnNKi6iJiIIdt5+IKGxqiIjI2BjUEBGA8KghIiJjY1BDzTj7h4iIQhmDGgLA2T9ERBT6WChMnP1DRESGwKAmzHH2DxERGQWDmjDH2T9ERGQUDGrCHGf/EBGRUTCoCXOc/UNEREbB009hLhCzf3h0nIiIfIFBTZiTZv/MeD8fAmAX2Lib/aM1MHF1dNwab8aEQZ3RNTmWQQ4REWkmiKIYNsdaKisrYbFYUFFRgfj4+EAvJ6io6VOjtaeNdHTc0//g2B+HiIhaUnr/ZlBDzZRkX+QCE+kquQGIjTYRQ5/b7PakldLXIiKi8KL0/s1CYUKjTcSOwlJ8+t1ZAMDoPh2Q3b2tyy0nrT1tPB0dV/NaREREroRMUHP06FGMHTsWycnJiI+Px9ChQ7Fly5ZALyvk5RUUY+hzmzHhzZ24/x97MeHNnRj63GaXXYS96Wmj9ki4lv44UnC2Zu8Z7CgsZUBERBRmQqZQePTo0cjIyMDmzZsRHR2Nl156CaNHj0ZhYSGsVmuglxeS5LaSpPEIjts/3vS00XokXOl7cnYVERGFRKbmwoULOHbsGObNm4c+ffogIyMDzz77LKqrq1FQUCD7vNraWlRWVtp9URMtW0ne9LSRjo6rPdOk5D05u4qIiIAQCWratm2Lq6++Gu+99x6qqqrQ0NCA119/He3atUNWVpbs85YsWQKLxdL8lZaW5sdVBzctW0meAhMBTdkRVz1tpKPj0nWeuHutlji7ioiIJCER1AiCgI0bN2LPnj2Ii4tDVFQUli5diry8PCQmJso+b/78+aioqGj+On36tB9XHdy0bCW5C0zc9bSR5PZKxbKJA2C1uM++KHktCWdXERGRJKBBzbx58yAIgtuvw4cPQxRFzJw5E+3atcPWrVuxa9cu3HLLLRgzZgyKi+W3FsxmM+Lj4+2+qInWrSS5wMRqiVJ0BDu3Vyq2zR2BVdOG4OU7+2F2zlWwxmt7LYCzq4iI6GcB7VNz/vx5lJaWur2mW7du2Lp1K37961+jvLzcLjDJyMjA1KlTMW/ePEXvxz41P5P6xngaj7Bt7giX2RI9Rx1481o7Cksx4c2dHq9bNW0Isru31bQ+IiIKLKX374CefkpJSUFKSorH66qrqwEAJpN9YslkMsFms/lkbUandTxCy+frFSR481qBmF1FRETBKSRqarKzs5GYmIjJkydj3759OHr0KB5++GEUFRVh1KhRgV5eyPJ2KykYeFvnQ0RExhEyYxK+/fZbPPbYY/j2229RX1+Pa6+9Fk8++SR+85vfKH4Nbj+5ZoSp2exTQ0RkXJz95AKDGmMzQnBGRETOQqKmhkhPetb5EBFR6AmJmhoiIiIiTxjUEBERkSEwqCEiIiJDYFBDREREhsCghoiIiAyBQQ0REREZAo90k2Gxbw0RUXhhUEOGxA7DREThh9tPZDh5BcWY8X6+XUADACUVNZjxfj7yCooDtDIiIvIlBjVkKI02EYvWHXQ5sVt6bNG6g2i0hc10ECKisMGghgxlV1GZU4amJRFAcUUNdhWV+W9RRETkFwxqyFDOXZIPaLRcR0REoYNBDRlKu7goXa8jIqLQwaCGDGVQehJSLVGQO7gtoOkU1KD0JH8ui4iI/IBBDRlKK5OABWMyAcApsJG+XzAmk/1qiIgMiEENGU5ur1QsmzgAVov9FpPVEoVlEwewTw0RkUGx+R4ZUm6vVIzMtLKjMBFRGGFQQ4bVyiQgu3vbQC+DiIj8hNtPREREZAgMaoiIiMgQGNQQERGRITCoISIiIkNgUENERESGwKCGiIiIDIFHur3UaBPZC4WIiCgIMKjxQl5BMRatO4jiip8nPqdaorBgTCa71hIREfkZt580yisoxoz38+0CGgAoqajBjPfzkVdQHKCVERERhScGNRo02kQsWncQooufSY8tWncQjTZXVxAREZEvMKjRYFdRmVOGpiURQHFFDXYVlflvUURERGGOQY0G5y7JBzRariMiIiLvMajRoF1clK7XERERkfcY1GgwKD0JqZYoyB3cFtB0CmpQepI/l0VERBTWGNRo0MokYMGYTABwCmyk7xeMyWS/GiIiIj9iUKNRbq9ULJs4AFaL/RaT1RKFZRMHsE8NERGRn7H5nhdye6ViZKaVHYWJiIiCAIMaL7UyCcju3jbQyyAiIgp73H4iIiIiQ2BQQ0RERIbAoIaIiIgMgUENERERGQKDGiIiIjIEBjVERERkCAxqiIiIyBAY1BAREZEhMKghIiIiQwirjsKiKAIAKisrA7wSIiIiUkq6b0v3cTlhFdRcunQJAJCWlhbglRAREZFaly5dgsVikf25IHoKewzEZrPh7NmziIuLgyAE79DJyspKpKWl4fTp04iPjw/0csIW/w6Bx79B4PFvEBzC/e8giiIuXbqEDh06wGSSr5wJq0yNyWRCp06dAr0MxeLj48Pyf7zBhn+HwOPfIPD4NwgO4fx3cJehkbBQmIiIiAyBQQ0REREZAoOaIGQ2m7FgwQKYzeZALyWs8e8QePwbBB7/BsGBfwdlwqpQmIiIiIyLmRoiIiIyBAY1REREZAgMaoiIiMgQGNQQERGRITCoCXJHjx7F2LFjkZycjPj4eAwdOhRbtmwJ9LLC0vr16zF48GBER0cjMTERt9xyS6CXFJZqa2vRr18/CIKAvXv3Bno5YeXkyZOYOnUq0tPTER0dje7du2PBggWoq6sL9NIM7bXXXkPXrl0RFRWFwYMHY9euXYFeUtBiUBPkRo8ejYaGBmzevBm7d+9G3759MXr0aJSUlAR6aWFl9erVmDRpEu69917s27cP27dvx1133RXoZYWlRx55BB06dAj0MsLS4cOHYbPZ8Prrr+PAgQN48cUXsXz5cjz66KOBXpphffDBB5gzZw4WLFiA/Px89O3bFzfeeCPOnTsX6KUFJ5GC1vnz50UA4ldffdX8WGVlpQhA3LBhQwBXFl7q6+vFjh07in/7298CvZSw99lnn4nXXHONeODAARGAuGfPnkAvKew9//zzYnp6eqCXYViDBg0SZ86c2fx9Y2Oj2KFDB3HJkiUBXFXwYqYmiLVt2xZXX3013nvvPVRVVaGhoQGvv/462rVrh6ysrEAvL2zk5+fjzJkzMJlM6N+/P1JTU/Gb3/wGBQUFgV5aWPnxxx8xbdo0/P3vf0dMTEygl0M/qaioQFJSUqCXYUh1dXXYvXs3cnJymh8zmUzIycnBjh07Ariy4MWgJogJgoCNGzdiz549iIuLQ1RUFJYuXYq8vDwkJiYGenlh48SJEwCAhQsX4vHHH8enn36KxMREDBs2DGVlZQFeXXgQRRFTpkzB9OnTMXDgwEAvh35y/Phx/PWvf8X//M//BHophnThwgU0Njaiffv2do+3b9+eJQgyGNQEwLx58yAIgtuvw4cPQxRFzJw5E+3atcPWrVuxa9cu3HLLLRgzZgyKi4sD/TFCntK/g81mAwA89thjuPXWW5GVlYV33nkHgiDgX//6V4A/RWhT+jf461//ikuXLmH+/PmBXrIhKf07tHTmzBnk5uZi/PjxmDZtWoBWTmSPYxIC4Pz58ygtLXV7Tbdu3bB161b8+te/Rnl5ud2o+YyMDEydOhXz5s3z9VINTenfYfv27RgxYgS2bt2KoUOHNv9s8ODByMnJwdNPP+3rpRqW0r/B7bffjnXr1kEQhObHGxsb0apVK9x999149913fb1UQ1P6d4iMjAQAnD17FsOGDcOQIUOwYsUKmEz872NfqKurQ0xMDD788EO705aTJ0/GxYsXsWbNmsAtLki1DvQCwlFKSgpSUlI8XlddXQ0ATv/CMJlMzdkD0k7p3yErKwtmsxlHjhxpDmrq6+tx8uRJdOnSxdfLNDSlf4NXXnkFf/rTn5q/P3v2LG688UZ88MEHGDx4sC+XGBaU/h2ApgzN8OHDmzOWDGh8JzIyEllZWdi0aVNzUGOz2bBp0ybMmjUrsIsLUgxqglh2djYSExMxefJkPPnkk4iOjsabb76JoqIijBo1KtDLCxvx8fGYPn06FixYgLS0NHTp0gV//vOfAQDjx48P8OrCQ+fOne2+b9OmDQCge/fu6NSpUyCWFJbOnDmDYcOGoUuXLnjhhRdw/vz55p9ZrdYArsy45syZg8mTJ2PgwIEYNGgQXnrpJVRVVeHee+8N9NKCEoOaIJacnIy8vDw89thjGDFiBOrr63HttddizZo16Nu3b6CXF1b+/Oc/o3Xr1pg0aRKuXLmCwYMHY/PmzSzYprCyYcMGHD9+HMePH3cKJlnJ4Bt33HEHzp8/jyeffBIlJSXo168f8vLynIqHqQlraoiIiMgQuBlKREREhsCghoiIiAyBQQ0REREZAoMaIiIiMgQGNURERGQIDGqIiIjIEBjUEBERkSEwqCEiIiJDYFBDRCFnypQpdgP+hg0bhgceeMDv6/jPf/4DQRBw8eJFv783ETljUENEupkyZQoEQYAgCIiMjESPHj3w1FNPoaGhwafv+9FHH2Hx4sWKrmUgQmRcnP1ERLrKzc3FO++8g9raWnz22WeYOXMmIiIiMH/+fLvr6urqEBkZqct7JiUl6fI6RBTamKkhIl2ZzWZYrVZ06dIFM2bMQE5ODtauXdu8ZfT000+jQ4cOuPrqqwEAp0+fxu23346EhAQkJSVh7NixOHnyZPPrNTY2Ys6cOUhISEDbtm3xyCOPOA1PdNx+qq2txdy5c5GWlgaz2YwePXrgrbfewsmTJzF8+HAAQGJiIgRBwJQpUwAANpsNS5YsQXp6OqKjo9G3b198+OGHdu/z2Wef4aqrrkJ0dDSGDx9ut04iCjwGNUTkU9HR0airqwMAbNq0CUeOHMGGDRvw6aefor6+HjfeeCPi4uKwdetWbN++HW3atEFubm7zc/7yl79gxYoVePvtt7Ft2zaUlZXh448/dvue99xzD1atWoVXXnkFhw4dwuuvv442bdogLS0Nq1evBgAcOXIExcXFePnllwEAS5YswXvvvYfly5fjwIEDmD17NiZOnIgvv/wSQFPwNW7cOIwZMwZ79+7F73//e8ybN89XvzYi0kIkItLJ5MmTxbFjx4qiKIo2m03csGGDaDabxYceekicPHmy2L59e7G2trb5+r///e/i1VdfLdpstubHamtrxejoaPHzzz8XRVEUU1NTxeeff7755/X19WKnTp2a30cURfFXv/qVeP/994uiKIpHjhwRAYgbNmxwucYtW7aIAMTy8vLmx2pqasSYmBjx66+/trt26tSp4oQJE0RRFMX58+eLmZmZdj+fO3eu02sRUeCwpoaIdPXpp5+iTZs2qK+vh81mw1133YWFCxdi5syZ6N27t10dzb59+3D8+HHExcXZvUZNTQ0KCwtRUVGB4uJiDB48uPlnrVu3xsCBA522oCR79+5Fq1at8Ktf/Urxmo8fP47q6mqMHDnS7vG6ujr0798fAHDo0CG7dQBAdna24vcgIt9jUENEuho+fDiWLVuGyMhIdOjQAa1b//yvmdjYWLtrL1++jKysLPzf//2f0+ukpKRoev/o6GjVz7l8+TIAYP369ejYsaPdz8xms6Z1EJH/MaghIl3FxsaiR48eiq4dMGAAPvjgA7Rr1w7x8fEur0lNTcU333yD66+/HgDQ0NCA3bt3Y8CAAS6v7927N2w2G7788kvk5OQ4/VzKFDU2NjY/lpmZCbPZjFOnTslmeHr27Im1a9faPbZz507PH5KI/IaFwkQUMHfffTeSk5MxduxYbN26FUVFRfjPf/6DP/7xj/jhhx8AAPfffz+effZZfPLJJzh8+DD+8Ic/uO0x07VrV0yePBm/+93v8MknnzS/5j//+U8AQJcuXSAIAj799FOcP38ely9fRlxcHB566CHMnj0b7777LgoLC5Gfn4+//vWvePfddwEA06dPx7Fjx/Dwww/jyJEjWLlyJVasWOHrXxERqcCghogCJiYmBl999RU6d+6McePGoWfPnpg6dSpqamqaMzcPPvggJk2ahMmTJyM7OxtxcXH47W9/6/Z1ly1bhttuuw1/+MMfcM0112DatGmoqqoCAHTs2BGLFi3CvHnz0L59e8yaNQsAsHjxYjzxxBNYsmQJevbsidzcXKxfvx7p6ekAgM6dO2P16tX45JNP0LdvXyxfvhzPPPOMD387RKSWIMpV2xERERGFEGZqiIiIyBAY1BAREZEhMKghIiIiQ2BQQ0RERIbAoIaIiIgMgUENERERGQKDGiIiIjIEBjVERERkCAxqiIiIyBAY1BAREZEhMKghIiIiQ/j/ciwNFHHurccAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "# Plot the training loss (or scores)\n",
    "plt.plot(epochs, scores)\n",
    "\n",
    "# Set the model to evaluation mode\n",
    "model.eval()\n",
    "\n",
    "# Initialize a list to store all predictions\n",
    "all_pred = []\n",
    "\n",
    "# Loop through the test data\n",
    "for test_data in test_loader:\n",
    "    smi_lst, bg, labels, masks = test_data\n",
    "    \n",
    "    # Move everything to GPU if available\n",
    "    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "    bg = bg.to(device)\n",
    "    labels = labels.to(device)\n",
    "    masks = masks.to(device)\n",
    "    \n",
    "    # Get node and edge features and move them to the correct device\n",
    "    node_feats = bg.ndata['hv'].to(device)\n",
    "    edge_feats = bg.edata['he'].to(device)\n",
    "    \n",
    "    # Perform the prediction\n",
    "    pred = model(bg, node_feats, edge_feats)\n",
    "    \n",
    "    # Store the predictions on the CPU\n",
    "    all_pred.append(pred.data.cpu().numpy())\n",
    "\n",
    "# Convert the predictions to a numpy array\n",
    "res = np.vstack(all_pred)\n",
    "\n",
    "# Plot the results\n",
    "plt.clf()\n",
    "plt.scatter(res, test_sol)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Experimental')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "0d11b798-3d30-4fc9-aca0-933f1d719207",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8944739103317261\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/media/suhaib/intensobp/5-Python_envs/pythonvenv/dgl_venv/lib/python3.9/site-packages/sklearn/base.py:1473: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n",
      "  return fit_method(estimator, *args, **kwargs)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7e89ec0bcf10>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import r2_score\n",
    "print(r2_score(test_sol, res))\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import AllChem\n",
    "train_fp = [AllChem.GetMorganFingerprintAsBitVect(mol,2) for mol in train_mols]\n",
    "test_fp = [AllChem.GetMorganFingerprintAsBitVect(mol,2) for mol in test_mols]\n",
    "# make RF regressor and train it.\n",
    "rfr = RandomForestRegressor()\n",
    "rfr.fit(train_fp, train_sol)\n",
    "\n",
    "rfr_pred = rfr.predict(test_fp)\n",
    "r2_score(test_sol, rfr_pred)\n",
    "plt.clf()\n",
    "plt.scatter(rfr_pred, test_sol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec125841-4aba-4e63-837b-d74e9a6def15",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}